r/tmux

I got tired of network monitors that look like they were designed for a BBS, so I built flow. It's a real time bandwidth monitor with Braille grid waveforms, spring smoothed numbers, and glowing borders that react to traffic load.

What it does

It shows live download and upload throughput with units that auto scale from B/s up to GB/s. The waveform is a high res Braille grid scrolling at 30fps, and the borders glow brighter as traffic picks up, going from a dark idle state to bright cyan and emerald under load. Numbers are spring interpolated so they glide instead of jumping around. It tracks session peaks, flashing white when you hit a new record, and keeps a running daily total.

There are three views that adapt to your terminal width. Hero is the full dashboard. Compact strips it down to numbers only. Tiny is a single line built for tmux status bars.

Philosophy

If a feature doesn't help you understand your network in under a second, it doesn't make the cut. No CPU panels, no packet counters, no multi pane clutter. Just download and upload throughput, done well.

Usage

flow                        # hero view, auto interface
flow --compact              # numbers only
flow --tiny                 # tmux status bar
flow --json                 # one-shot JSON for scripts
flow --once                 # one-shot plain text

tmux integration

set -g status-right "#(flow --tiny --no-color)"
set -g status-interval 1

Install

go install github.com/programmersd21/flow/cmd/flow@latest

or AUR:

yay -S flow-network-monitor-bin

or homebrew:

brew install programmersd21/flow/flow

Pre-built binaries for Linux, macOS, and Windows (amd64/arm64) are on the releases page.

It works with zero config out of the box. If you want to tweak the refresh rate, history length, or units, there's an optional TOML config at ~/.config/flow/config.toml.

Platform support

It runs on Linux (/proc/net/dev), macOS (sysctl), and Windows (GetIfTable2, no admin needed). Idle CPU stays under 1%.

Links

Source and demo: https://github.com/programmersd21/flow

---

Would love feedback, especially on the tiny/tmux mode. Curious if the info density is right for people running it in a status bar all day.

The whole idea is one Ghostty window that shows every pane at once. I usually have a bunch of things running across projects — a localhost dev server here, two or three Claude Code sessions there — and I wanted to see all of them side by side in a single window instead of tabbing between terminals. That's the default view: the full grid, one row per repo.

From there, Opt+1 through 9 focuses the matching pane, or you can just click it with the mouse. Cmd+1 through 9 focuses AND zooms it fullscreen when you want to actually work in one, and Cmd+0 drops you back to the overview of everything.

Setup is one script — it installs tmux if you don't have it, drops in the tmux.conf, and appends the Ghostty keybinds. macOS + Ghostty only for now.

Makes it very easy to work on multiple projects at the same time.

Repo (MIT, demo in the README): https://github.com/philmard/mygrid

Hi guys!

I have tried herdr and I liked the agents list on the sidebar, and how it works with almost any agent harness. The thing is, I prefer tmux, so I built this plugin that implements the best feature I found in herdr.

This is agent-radar. It shows a popup window running fzf with a list of panes where you have an agent harness instance running. It detects whether the agent is working or not. It notifies you via OS notifications (osascript on MacOS and notify-send on Linux), and it shows a small status bar section with the tmux session where the agent finished. It also highlights the agent's window in the status bar until you focus it.

The popup reloads every 2 seconds and shows a dot with a different color depending on the state of the agent from that pane: seen (green), working (yellow), stopped-unseen (red).

Maybe some of you find it interesting. I'd love to get some feedback.

https://github.com/vieitesss/agent-radar

Really loved the side-chat feature of the Codex app.

It was an easy way to understand issues and brainstorm solutions without polluting the main thread's context, so implemented it for Pi.

Link: https://pi.dev/packages/@snehalyelmati/pi-tmux-sidechat

Pre-requisite: tmux session with Pi.

How to use,

1. Create a new tmux pane.
2. Type in /scc, for side-chat connect.
3. It will automatically connect to the main session in "this" tmux window.
4. If you want a fresh one, just clear the chat (/new) and reconnect (/scc).

Note, if there are multiple panes with pi, it'll show a picker for you to choose from.

https://github.com/nov1n/squawk

This project offers an alternative approach to handling multiple agent sessions within tmux. Rather than relying on a sidebar or a dedicated management UI, it uses Claude Code hooks to trigger native macOS notifications whenever Claude requires your attention.

Clicking a notification takes you directly to the relevant tmux pane, and you can even respond to or approve requests straight from the notification itself.

I've been running it for about a week and have really come to appreciate the workflow. I decided to make it public in case it could be helpful for others, too. I'm curious to hear your feedback!

This is a tool I (or better say ai by my prompts) built for myself.

So, I have 2 notebooks, one orangepizero, one small server and 4 android devices.

I put everything into tailscale.

And I wanted the panel to quickly access any terminal from any other device from web browser.

So I build this - webmux https://github.com/samoylenkodmitry/webmux (posting here for likes, not other reason)

When i run multiple agents across multiple tmux sessions, it's hard to keep an overview of all of them, and they have no way of collaborating with each other.

There are already a lot of plugins for an agent sidebar. But what if that isn't enough? What if you want the agents to coordinate with each other, and you just talk to the orchestrator?

So i built it: Cotal, an open coordination layer that lets agents share one space (see each other, dm directly, hand off work) across vendors like claude code, opencode, hermes and whatever else you wire up.

In the video you can see how it works. The full team is spawned and ready: two GLM-5.2 instances as the frontend and backend devs (bottom right), GPT-5.5 as the reviewer (running in the background), all through opencode, and a claude opus lead running the loop (bottom left). That's it. i talk directly to opus, the lead, give it one small prompt, and it starts delegating and building, without me relaying anything between them. i still keep full control and visibility: the top pane is the console, a live overview of everything they send each other.

Together they built a new feature for the console: a tree view of all agents, so you see exactly where each agent is currently working.

That's the whole setup. Opus defined the targets, the two GLMs implemented them and settled the contract between themselves, and GPT reviewed the result.

Repo + one-line setup if you want to try it:
- github.com/Cotal-AI/Cotal
- npx cotal-ai setup --full
- apache-2.0

What's your experience running multiple agents at once? Do you struggle to keep the overview, and to get them to actually collaborate?

I run a lot of AI coding sessions across tmux panes and worktrees, and I wanted a tmux-native way to see them all and jump between them instead of cycling windows. mux is a display-popup overlay (bound to prefix + u) that lists every live session on the current tmux server, sorted with the ones waiting for input on top, with a live capture-pane preview on the right. j/k move, Enter does switch-client + select-window + select-pane to land you on the pane (works across windows and sessions), ctrl-x kills one and the list reloads.

(And yes, I know I just took a t off tmux for the name. Couldn't help myself.)

you can check out the repo here for installation process and make sure to leave a star if you enjoy it! Repo: https://github.com/fashton28/mux

Hi everyone,

I always wanted to make most of my configurations in Lua, since it's a really simple and easy to read language for me. I wanted something similar to the neovim setup, with plugins and just Lua code to improve the UI.

I created tpane, basically so I could manage and extend my tmux config using Lua.

It ships with some themes, plugins and widgets but you can extend it to your own needs.

Let me know what you all think. Cheers

I was keeping a browser tab with Claude usage page and checking it constantly. I usually have several projects going at once across multiple tmux windows, and the limits are shared across all of them anyway — so putting Claude's status line in every window felt redundant and just cluttered each pane. I wanted one clean place to see usage instead of duplicating the same number everywhere.

So I built a tmux plugin that puts it right in the status bar — progress bar, percent used, and time until reset, in a single spot.

The part I'm happiest with: it makes zero API calls. Claude Code already hands its status line official session data (including rate_limits) on every render. The plugin just taps that — a small "harvester" status-line command caches it and prints nothing (so no line appears in your panes), and a tiny bash segment reads the cache and draws the bar. No curl, no API key, no separate rate limits, no network at all. Pure bash + jq, and it refreshes live as you work.

Features:

• Progress bar + percent + reset time in the status bar
• Color thresholds, configurable
• Resets to 0% the moment a limit window rolls over — no lingering on a stale leftover percentage
• Optional staleness marker (off by default) for when usage happened elsewhere and the cached number isn't live yet

Requirements: tmux 3.0+, jq, and Claude Code (logged in).

Install via TPM:

set -g u/plugin 'docker-run/tmux-claude-usage'

set -g status-right '#{claude_usage}  %Y-%m-%d %H:%M'

Then prefix + I and run the one-time init.sh (it wires the status-line command into ~/.claude/settings.json, backing it up first).

Repo: https://github.com/docker-run/tmux-claude-usage

Thanks for taking a look, and I hope it saves someone else the constant tab-switching. Hope you find it useful!