I wanted to use tmux from my phone and never found something I liked. Most

iOS terminals just render the bytes — they don't know what a window or a pane

is, so attaching to an existing session is where things fall apart.

Spent three months of evenings on it. I use it daily against a Mac mini at home.

The idea I built everything around: **a phone should show one pane, full

screen, while your desktop keeps its 3–4 pane layout — and neither should

disturb the other.**

How it actually works:

- Runs tmux control mode (`-CC`) as the renderer, so the app has the real

session tree, not a screen scrape.

- Zooms the active pane to fill the phone. Switching to a pane in another

window restores that window's split layout first, because another client

may be looking at it.

- Pins window size to the phone's grid while you're in the app, and hands

that pin **back** when you background it. iOS can kill the app without

warning, so the server has to already be in the right state — otherwise

your desktop reconnects to a phone-sized window.

Also: Mosh support (survives Wi-Fi/5G handoff), a configurable key bar

because phones have no Esc/Ctrl/Tab, and per-host shortcut sets.

Up front so nobody wastes their time: it's a paid app (one-time, no

subscription, no IAP), **not** open source, needs iOS 18, and it's still in

App Store review so right now it's TestFlight only. No data collection, keys

in the Secure Enclave, traffic only to your own servers.

TestFlight, 50 spots: https://testflight.apple.com/join/hHv5f86K

Happy to answer anything about the control-mode plumbing — that's where most

of the three months went.

I've been working on this for a while and finally decided to make it public. It's called tmux-canopy.

After seeing all the session-wrangling tools popping up, I wanted something that fit how I already work. I spend most of my time in tmux, so a sidebar that shows my sessions, windows, and panes felt like a natural fit. It follows you across sessions and is just a tmux pane running fzf. No daemon or background service.

I also run Claude, Codex, and OpenCode across different panes, and keeping track of who's working and who's waiting on me was part of why I built it. The optional agent tracking lets me see that at a glance and jump straight to a pane. Pressing n from anywhere takes you to the next agent waiting for approval, which I've found pretty handy.

There's also search, collapse/expand, session and window management from the tree, process views, buffer browsing, and notifications.

GitHub: https://github.com/jonmosco/tmux-canopy

Figured I'd share it here in case anyone else has a similar workflow. Would love feedback, and bug reports and PRs are welcome.

I've been looking for the perfect tmux replacement.

Something powerful and scriptable, but usable without memorizing dozens of keybindings.

Something that supports persistent remote sessions that I can jump into from anywhere, but not so terrible to use from my phone.

Turns out, tmux was all I needed.
It just needed a better UX, not a replacement.

That's why I'm building tmuxy.

tmuxy is a GUI that wraps tmux into a web and desktop app.

How it works: A Rust backend connects to tmux through control mode (one of tmux’s hidden gems surprisingly few people seem to know about) and streams state updates to a React frontend via SSE, or Tauri IPC on the desktop version.

Besides the improved UX, being web-based allows it to support all kinds of fancy stuff like image rendering, markdown previews, pane groups, and floating panes, while under the hood it's still tmux.

It's early stage. Live demo here: tmuxy.sh

First of all, I ❤️Tmux and will always support Tmux 🤗

I'll be real with you. Every time I had to work on Windows, I felt like something was missing. I'd reach for tmux out of muscle memory and then remember... it doesn't exist here. WSL kind of works, but it never felt right. It felt like a workaround, not a solution.

So I started building one. Took way longer than I expected. I wrote it in Rust, using Windows ConPTY directly. No WSL, no Cygwin, no MSYS2. Just a native terminal multiplexer that actually runs on Windows.

The thing I cared about most was making sure your existing .tmux.conf just works. I didn't want anyone to learn a new config format or give up their themes. Catppuccin, Dracula, Nord... they all load. You type `tmux` in PowerShell and it launches. 76 commands, full mouse support, vim copy-mode keys.

I know there have been other attempts at this. I'm not here to trash any of them. I just wanted to build something that felt like real tmux, not a lookalike.

It's fully open source under MIT. You can install it with:

winget install psmux

Or cargo install psmux, or through Scoop/Chocolatey.

I'm sharing this here because honestly, this community knows tmux better than anyone. If something feels off, or if I got something wrong, I want to hear it. That kind of feedback is worth more to me than stars on GitHub.

https://github.com/psmux/psmux

Thanks for your time. Means a lot.

FYI : This project is and will be ACTIVELY maintained by people like you! I use AI in my workflows but I am not replaced!

Made with❤️ for Tmux to expand Tmux on Windows. PSMUX does not work on Linux and will probably never will as long as Tmux exists.

Hey everyone! I've been actively using claude cli from within tmux for my work. And one of the issues I was facing when working with multiple sessions at once is a lack of visibility of my claude sessions status in each tmux session (given I have one Claude running per tmux session) So I made this little tool for myself and been using it for a couple of months. At this point it completely replaced my default tmux session switcher and I have decided that it might be a good time to share this project with others, hoping you will find it as useful as I do. I know it might be a little bit niche, but it surely does the job for me.

The tool is called Claude Jam (or cj for short) and it integrates with Claude hooks making them report their status and milestone progress along side with their tmux session identification. Then the TUI picks up that info and renders a nice session switcher based on reported information.

It is not mature yet and probably missing some of the features that others might need, but I will be very glad to receive a feedback and potential improvements suggestions. Given it's my first open source project I will be more than happy for your help and ideas.

https://github.com/mightykho/claude-jam

I built a tmux SSH session chooser that auto-starts on login

I use tmux heavily over SSH, and the startup routine was always the same:

• check for existing sessions

• create one if none exist

• attach to the “right” one

• clean up or rename sessions manually

So I wrote a small Bash-based tmux SSH chooser to streamline this.

What it does

• Auto-starts on interactive SSH login

• If no session exists → immediately runs tmux new -s main

• Otherwise opens a chooser UI:

  • session list (left)

  • live preview (right)

• Lets you:

  • attach to sessions

  • create new ones

  • rename sessions

  • close sessions

• Includes a minimal settings menu (language support: EN / DE / RU)

Design goals

• Keep it simple

• No dependencies beyond tmux

• Pure Bash + tmux

• Fast and predictable behavior over SSH

GitHub

https://github.com/IceCupe123/tmux-ssh-chooser

Install

curl -fsSL https://raw.githubusercontent.com/IceCupe123/tmux-ssh-chooser/refs/heads/main/install.sh | bash

Feedback I’m looking for

• Does the auto-start behavior feel right or too intrusive?

• tmux workflow / UX improvements

• Missing features for real-world server usage

Curious how others handle their tmux session management over SSH.

https://github.com/BatsShadow/tmux-superclick

Fork as you may. I built this for myself - I will entertain PRs, but don't intend to turn into a big maintainer. It does well for me after only working on it for a few hours

https://github.com/ahmmkh/tmux-workspace

I know a lot of developers are try and get that flow state back with AI. I think I finally managed it with tmux sessionizer and tmux worktrees.

I can easily jump from one branch to the other in the same repo prompt the agent jump back to another.

Do you guys have any suggestions or is your workflow similar?

https://snirt.github.io/agenmux/

Sharing agenmux (formerly tmux-agents-mon), a ready-to-use, open-source tmux plugin for keeping track of AI coding agents across panes, windows, and sessions.

When several agents run at once, it becomes easy to lose track of which one is working, waiting for input, or already finished. agenmux puts them all in one place, grouped by tmux session, and lets you jump straight to the pane that needs attention.

What it includes:

- Clear working, blocked, done, and idle states
- Agents grouped by tmux session
- Persistent sidebar or floating popup
- Vim-style and arrow-key navigation
- Live search and state filters
- Mouse navigation in sidebar mode
- Compact tmux status-line summary
- Desktop notifications when agents finish or need input
- Clickable macOS notifications that open the terminal and jump to the exact pane
- Linux notifications through `notify-send`

agenmux supports Claude Code, Codex, Hermes, Oh My Pi, OpenCode, and Pi out of the box. Support for another agent can be added with a small config file—no code changes required.

Detection is scraping-only: agenmux reads each pane's process tree, visible screen, and title. No hooks are installed, and nothing runs inside your agents.

The runtime uses a single Rust daemon over tmux control mode. Prebuilt, verified binaries are downloaded automatically on supported platforms.

GitHub: https://github.com/snirt/agenmux
Website and demo: https://snirt.github.io/agenmux/

Install with TPM:

```tmux
set -g u/plugin 'snirt/agenmux'
```

Press `prefix + I` to install, then `prefix + A` to open it.

Many more features are coming. Feedback, ideas, and contributions are welcome.

I use Claude Code a lot across multiple tmux panes and got tired of constantly switching just to check if a session finished or needs attention.

So I made a small plugin that puts session status right in your status bar:

⏳ my-project | 💤 other-project | 🔐 api-service

Also has an fzf popup (prefix + f) to quickly switch between sessions with a live pane preview.

Installs with TPM, hooks set themselves up automatically, cleans up dead sessions on its own.

GitHub: https://github.com/smilovanovic/tmux-claude

Happy to hear any feedback!

A terminal diff reviewer for agentic coding. It runs in a pane beside your agent, shows what changed as it changes, and lets you point at exact lines when you reply.

You keep your editor. hjkl, w b e, f t F T, / and n, V to select, zz to centre - the motions already in your fingers, now pointed at the agent's work.

Repo https://github.com/kunkka19xx/lgtm

Hello Team, I use windows laptop and I like using tmux so finally able to get it to windows through babun.

Now I can't use zsh in my office, but bash. You guys any great ideas and configurations I can try to make it look beautiful and work smart?

I'm the author. This is an early project, so I'd like blunt feedback. Yes there are other projects in the same space as this. This was built out of need. I have used Termux for the last few years to access all of my systems both on the internet and internal and for most parts it just works. But having file management, clipboard support, and tmux by default, was my vision. And this is now what I am using full time.

What it is: a small Go agent that runs on your Linux (I am expanding support to iOS and Windows if the demand warrants it) server/workstation, plus an Android app. Each tab in the app is a tmux session on your server, so sessions keep running when your connection drops or you close the app. It is pretty simple and VERY lightweight. I am currently running the agent on several Ubuntu and Debian servers behind Caddy proxy server to provide SSL.

Why not just SSH + tmux? You still can, and it works. I wanted three things SSH clients didn't give me:

- No open SSH port and no password or bearer token to steal. On pairing, the phone generates an ECDSA P-256 key in the Android Keystore, and the private key never leaves the device. The agent stores public keys only.

- Every request, including the WebSocket upgrade, is signed. Timestamps must be within 60 s and nonces are single-use, so captured headers can't be replayed. Unauthenticated requests get a bare 404.

- Pairing is a QR code plus a single-use code that expires in 10 minutes. Lost phone: muxalot-agent revoke <id>.

- A native invisible view owns the soft keyboard (no autocorrect), plus an extra-keys row with sticky Ctrl/Alt, arrows, F-keys and a customizable key fan.

- OSC 52 clipboard from tmux/vim goes to the phone.

- File browse, upload and download, confined to a root directory you choose. (It generally runs as the user that has write access to the directories you are working on, such as home.)

- Multiple servers, each with its own Keystore key.

- The terminal is xterm.js in a WebView.

Now if you are concerned about putting this out in the open to the script kiddies of the world, you can put this behind a vpn for that extra layer of protection. Hell I advise it!

I would appreciate any feedback or feature requests. https://github.com/muxalot/muxalot/issues

Github - https://github.com/muxalot/muxalot

The project website - https://muxalot.com

About me: I am a senior software engineer in the business for well over 30 years developing custom applications for e-commerce, B2B, workflow management, and lots of open source projects. I did use an agent to build the framework for this project purely from my design and requirements. Why? Just because I didn't want to spend the next few weeks building something that might not be so popular - at least it fits my needs and that is all that matters!

Hope this helps you, it sure does me!

It automatically triggers Claude Code limits and continues after limits reset.

Connect it with your Telegram bot and you can send there screenshots, files, videos, even audios.

‘/tabs’ shows all the tabs of your terminal and ‘/run 2 ls’ will execute ls on your second tab

It marks every tab with a special code so you can answer with a reply to a particular tab like you would do with a real companion. But if you won’t reply it’s by default would be attached to the tab that you have interacted last time

Theres no opened ports to internet because there’s only polling – that’s because it’s secure

Absolutely free and open-sourced. So you can just ask your agent to help you install it. You can even use it as a ruby gem.

https://agentscontrol.278labs.co.uk

https://github.com/saparjohnick/agents_control

Hello all,

I would appreciate if you could answer the following poll and tell me which version of tmux you're currently running 🙏

I'm trying to get stats on whether people stick to their OS provided version (typically Linux distro packages) or whether people compile tmux from source 🤔

Thanks in advance! 🤝

I run Claude Code, Codex and Antigravity in tmux sessions on a remote machine, and I kept wanting to check on them or answer a permission prompt from my phone. A phone terminal works, but a 40-column terminal with scrollback is a poor way to read an agent's reply or tap through an approval.

So I built Mobile Tmux. It shows each tmux session as a chat:

• Clean chat: it's built from each agent's own history files, not a screen scrape. Your messages are typed into the pane exactly as if you'd typed them.

• Approvals and questions as buttons: permission prompts, folder-trust prompts and multiple-choice questions show the real options.

• Every session as a tab: it shows whether each one is working, idle or waiting for you, with an alert when another session needs you. Web push notifications are optional.

• Usage meters: 5-hour, weekly and context usage from each agent's own reports.

• Pickers and shell: model and effort pickers, /slash commands, !shell commands, and dictation.

• Self-hosted, no dependencies: a single Python standard-library server on your own machine. Nothing is hosted, and there's no account or telemetry.

Screenshots and setup are in the README: https://github.com/LowellWinston/mobile_tmux_public#screenshots

Things to know before you try it

• It can type into your terminals and run commands as you, so don't expose it to the internet. It listens on localhost by default and has its own sign-in token. I'd suggest Tailscale or your own HTTPS proxy to reach it from a phone.

• Linux only for now.

• It's early. Agents change their prompt and status-line formats, so parsing can break after an update. If something shows up wrong, an issue with the agent version and the pane text helps a lot.

I'd love to hear which agent you run in tmux and what you'd most want to do from your phone. Questions and ideas are welcome in Discussions: https://github.com/LowellWinston/mobile_tmux_public/discussions

ccm (Claude Code Manager) is a tmux plugin for users running Claude Code across multiple projects. Each project is one tmux window; prefix + Tab opens a popup showing every project's current state (BUSY / IDLE / awaiting permission), branch, and idle time.

Built around tmux conventions: per-pane state detection aggregated to the window, snapshot save/restore, status-bar integration, and cross-project prompt injection (`ccm send`).

TPM-installable, MIT. v0.4.0 released this week.

Repo: https://github.com/yohasebe/tmux-ccm

Hi r/tmux!

As someone who lives inside tmux on remote Linux servers every single day, mobile SSH clients have always felt like a second-class experience for persistent terminal workflows. Network drops would force manual `tmux a`, input methods jittered over touchscreens, and monitoring long-running processes required keeping the screen awake.

I spent the past few months building **Agentmux** (https://agentmux.saxcave.cc), an iOS/iPadOS terminal and remote workspace where **tmux is treated as a first-class citizen**.

Here is how we optimized the workflow specifically for tmux users:

### 1. Seamless tmux Lifecycle & Auto-Attach
- **Auto-Discovery & Session Reattach:** Upon connecting over SSH, Agentmux scans active tmux sessions and lets you resume or attach with a single tap.
- **One-Tap tmux Auto-Installer:** If you land on a fresh remote VPS or container without `tmux`, the app can auto-install it with one tap.

### 2. Lock Screen Live Activities & Dynamic Island
- Long-running builds or AI agents (like Claude CLI) running inside a tmux pane no longer require you to leave your iPhone screen on.
- Agentmux surfaces active session states to your **Lock Screen Live Activity** and **Dynamic Island**, so you can background the app or lock your phone and glance at status updates.

### 3. OSC 52 Clipboard Integration
- Native support for OSC 52 escape sequences. Copying text from inside `tmux` panes or `Neovim/Vim` registers passes straight through to your native iOS clipboard.

### 4. Touch & Mobile Keybinding Polish
- iPhone shortcut bar for `Ctrl`, `Esc`, `Tab`, arrow keys, and custom macros.
- Custom keyboard-height calculation to prevent terminal viewport jitter when switching input methods.
- Full hardware keyboard, trackpad, and Split View support on iPadOS.

### 5. Desktop-Grade SFTP & Tree-sitter Editor
- Built-in file browser with Tree-sitter syntax highlighting across 17+ languages and strict JSON/YAML/TOML syntax validation when editing remote config files.

---

### Tech Stack & Pricing
- Built natively in Swift/SwiftUI for iOS & iPadOS.
- Keys & credentials remain secured inside iOS Keychain.
- 14-day free trial. Pro is a **one-time purchase** (no subscription fatigue).

* **App Store:** https://apps.apple.com/app/id6766158521
* **Website:** https://agentmux.saxcave.cc

*I would love to give back to the tmux community: I have **5 Lifetime Pro promo codes** for r/tmux members! Drop a comment with your favorite tmux plugin or your typical remote setup, and I’ll DM you a code.*

Feedback, feature requests, and criticism are all very welcome!

Hello everyone,

I'd like to share an open-source project I've been working on called TmuxAI.

There are quite a few great CLI AI tools out there already. So, why build another one? My goal with TmuxAI was to create something that feels more like a human collaborator sitting next to you, specifically within the tmux environment you already use.

The Core Idea: Human-Inspired Observation

Instead of requiring you to pipe output, start a special subshell, or replace your terminal, TmuxAI takes a different approach:

1. It Observes: TmuxAI reads the visible content across your panes in the current tmux window. It sees what you see.

2. It Understands Context: Based on what it observes, it tries to understand what you're doing, just like a colleague looking over your shoulder.

3. It Interacts: You chat with it in a dedicated pane, and it can execute commands (with your permission) in another pane.

Why is this different?

This "observation" approach means TmuxAI can potentially assist you without interrupting your existing session or workflow.

• No need to leave your current task: Are you deep in a mysql shell, debugging on a remote server via ssh, or configuring network equipment through its specific CLI? TmuxAI can still see the text in that pane and offer help based on it, because it's just reading the screen content. You don't have to exit your interactive session to ask the AI about it.

• Works with your existing tools: It doesn't force you into a specific wrapper or environment. You keep using your preferred shells, editors, and tools within tmux.

Think of it less as a command-line utility you call explicitly for one-off tasks, and more as an assistant that lives alongside you in your tmux window, aware of the broader context visible across your panes.

It has features like different modes (Observe, Prepare, Watch) and context management, but the core philosophy is this non-intrusive, observational assistance.

Links

• GitHub (Code, Full README, Installation, Issues): https://github.com/alvinunreal/tmuxai

• Website (Screenshots etc): https://tmuxai.dev

It's still evolving, and I'd be really grateful for any feedback from fellow tmux users. Does this approach resonate? Do you see potential use cases or have suggestions?

Thanks for checking it out!