Self-host cmux
v0.65.2.2Ghostty-powered macOS terminal with vertical agent tabs
brew install --cask cmux- Stars
- 28 829
- CPU
- Apple Silicon or Intel Mac
What is cmux?
cmux is a Swift/AppKit terminal for macOS, aimed at developers who keep many AI coding agents running side by side. Rendering comes from libghostty, and cmux picks up your Ghostty theme, font and colour settings, while its sidebar lists workspaces as vertical tabs annotated with the git branch, pull-request state, current folder, ports in use and newest alert text. Agents waiting for you stand out: the pane draws a blue outline, its tab lights up, and alerts coming from OSC 9/99/777 sequences or the cmux notify command collect in a shared notification panel. A real browser can be split in beside your terminals and driven by scripts (DOM snapshots, clicks, form filling, JavaScript evaluation, console and network reads); workspace and split management plus those browser actions are all scriptable over the cmux CLI and a local Unix socket. Workspaces open on remote hosts via cmux ssh, and existing remote tmux sessions can be attached. Layout, folders, scrollback and supported agent sessions come back after you quit or reboot. Install it by dragging the DMG into Applications or with brew tap manaflow-ai/cmux followed by brew install --cask cmux; macOS 14.0 or newer on Apple Silicon or Intel is required. The client is GPL-3.0-or-later, while the web/ and worker server code is BUSL-1.1, and Cloud VMs, the iOS companion and self-hosted cloud execution sit behind paid plans.
cmux alternatives
nexus4ccSelf-hosted web terminal bridging browsers to tmux sessions running Claude Code and other AI agents, with project/channel management, file browser, and PWA support.Comparenexus4cc with cmux
agent-tmux-webSelf-hosted web UI for running AI coding agents in tmux sessions from any browser or Android device, with TTY/raw modes, file uploads, and notifications.Compareagent-tmux-web with cmux
tlbxA self-hosted, open-source terminal multiplexer that runs shells and AI coding agents on your own hardware, reachable from any browser.Comparetlbx with cmux
BrowserOS neoA self-hosted, open-source Chromium browser for your AI agents: one-click Chrome login import, parallel agent tabs, and full session replay, all running locally.CompareBrowserOS neo with cmux
poolPool is a self-hosted AI coding agent for terminal and ACP-compatible editors, supporting Poolside Platform, OpenRouter, Ollama, and OpenAI-compatible APIs.Comparepool with cmux
Agent of EmpiresManage multiple Claude Code, OpenCode agents from either TUI or Web for easy access on mobile. Also supports Mistral Vibe, Codex CLI, Gemini CLI, Pi.dev, Copilot CLI, Factory Droid Coding.CompareAgent of Empires with cmux
SidecarSidecar is a self-hosted terminal workspace unifying AI coding agents, task management, git workflows, and file browsing in one interface with split panes.CompareSidecar with cmux
CodemanSelf-hosted web dashboard running 11 AI coding agents in tmux sessions, streaming live terminals to any browser with zero-lag input, QR login, and autonomous runs.CompareCodeman with cmux
Should you self-host cmux?
cmux scores 78/100 on selfhost.directory (how scoring works) and ranks #1 of 8 in Terminal. It has 28 829 GitHub stars, +630 in the last 30 days.
It shipped 296 stable releases in the past year. The latest, cmux-app-ffi-db4a10c216e4962be4109fb3fd9f5d37bdcbc4cf, came out on 19 November 2026.
Setup is easy: most people get it running in one sitting. It is GPL-3.0-licensed and written mostly in Swift.
Its closest alternative on selfhost.directory is TermIDE (50/100, 189 stars). cmux scores higher overall. See cmux vs TermIDE side by side.
Features
- Agent attention notifications
- Agent Skills
- CLI and socket API automation
- Configurable keyboard shortcuts
- Custom Commands
- GPU-accelerated rendering
- Multi-Agent Orchestration
- Notification panel
- Programmable built-in browser
- Remote tmux attachLabelled beta by the project.
- Session restore
- Split Panes
- SSH remote workspaces
- Vertical Tabs
cmux README
A Ghostty-based macOS terminal with vertical tabs and notifications for AI coding agents
English | 日本語 | Tiếng Việt | 简体中文 | 繁體中文 | 한국어 | Deutsch | Español | Français | Italiano | Dansk | Polski | Русский | Bosanski | العربية | Norsk | Português (Brasil) | ไทย | Türkçe | ភាសាខ្មែរ | Українська
▶ Demo video · The Zen of cmux
Docs · Blog · Changelog · Community
| Panes get a blue ring and tabs light up when coding agents need your attention |
|
| See all pending notifications in one place, jump to the most recent unread |
|
| Split a browser alongside your terminal with a scriptable API ported from agent-browser |
|
| Sidebar shows git branch, linked PR status/number, working directory, listening ports, and latest notification text. Split horizontally and vertically. |
|
cmux ssh user@remote creates a workspace for a remote machine. Pass --command 'omp "investigate auth"' to run an initial command once in its first remote terminal. Browser panes route through the remote network so localhost just works. Drag an image into a remote session to upload via scp.
|
|
cmux claude-teams runs Claude Code's teammate mode with one command. Teammates spawn as native splits with sidebar metadata and notifications. No tmux required.
|
|
- Browser import — Import cookies, history, and sessions from Chrome, Firefox, Arc, and 20+ browsers so browser panes start authenticated
- Custom commands — Define project-specific actions in
cmux.jsonthat launch from the command palette - Programmable — CLI and socket API to create workspaces, split panes, send keystrokes, and automate the browser
- Native macOS app — Built with Swift and AppKit, not Electron. Fast startup, low memory.
- Ghostty compatible — Reads your existing
~/.config/ghostty/configfor themes, fonts, and colors - GPU-accelerated — Powered by libghostty for smooth rendering
- Keyboard shortcuts — Extensive shortcuts for workspaces, splits, browser, and more
- Open source — Free and GPL-licensed
Open the .dmg and drag cmux to your Applications folder. cmux auto-updates via Sparkle, so you only need to download once.
brew tap manaflow-ai/cmux brew install --cask cmux
To update later:
brew upgrade --cask cmux
On first launch, macOS may ask you to confirm opening an app from an identified developer. Click Open to proceed.
The Homebrew cask installs completions for zsh, bash, and fish. Start a new shell after installing. If they don't load, make sure Homebrew's completion directories are wired into your shell (see Homebrew's shell completion docs).
If you installed cmux another way, add the matching line to your shell startup file, then start a new shell:
autoload -Uz compinit && compinit eval "$(cmux completion zsh)"
eval "$(cmux completion bash)"
cmux completion fish | sourceI run a lot of Claude Code and Codex sessions in parallel. I was using Ghostty with a bunch of split panes, and relying on native macOS notifications to know when an agent needed me. But Claude Code's notification body is always just "Claude is waiting for your input" with no context, and with enough tabs open I couldn't even read the titles anymore.
I tried a few coding orchestrators but most of them were Electron/Tauri apps and the performance bugged me. I also just prefer the terminal since GUI orchestrators lock you into their workflow. So I built cmux as a native macOS app in Swift/AppKit. It uses libghostty for terminal rendering and reads your existing Ghostty config for themes, fonts, and colors.
The main additions are the sidebar and notification system. The sidebar has vertical tabs that show git branch, linked PR status/number, working directory, listening ports, and the latest notification text for each workspace. The notification system picks up terminal sequences (OSC 9/99/777) and has a CLI (cmux notify) you can wire into agent hooks for Claude Code, OpenCode, etc. When an agent is waiting, its pane gets a blue ring and the tab lights up in the sidebar, so I can tell which one needs me across splits and tabs. Cmd+Shift+U jumps to the most recent unread.
The in-app browser has a scriptable API ported from agent-browser. Agents can snapshot the accessibility tree, get element refs, click, fill forms, and evaluate JS. You can split a browser pane next to your terminal and have Claude Code interact with your dev server directly.
Everything is scriptable through the CLI and socket API — create workspaces/tabs, split panes, send keystrokes, open URLs in the browser.
cmux is not prescriptive about how developers hold their tools. It's a terminal and browser with a CLI, and the rest is up to you.
cmux is a primitive, not a solution. It gives you a terminal, a browser, notifications, workspaces, splits, tabs, and a CLI to control all of it. cmux doesn't force you into an opinionated way to use coding agents. What you build with the primitives is yours.
The best developers have always built their own tools. Nobody has figured out the best way to work with agents yet, and the teams building closed products definitely haven't either. The developers closest to their own codebases will figure it out first.
Give a million developers composable primitives and they'll collectively find the most efficient workflows faster than any product team could design top-down.
For more info on how to configure cmux, head over to our docs.
To theme cmux (colors, fonts, transparency, sidebar, and more), see Customizing cmux's look.
For shell watcher churn and managed-Mac process audit volume, see the supported
CMUX_NO_GIT_WATCH=1 mitigation and its Git/PR update trade-offs.
| Shortcut | Action |
|---|---|
| ⌘ N | New local workspace |
| ⌘ Y | New Cloud workspace on the last usable Cloud context; opens New Cloud Machine when none is available |
| ⌘ ⇧ Y | New Cloud machine |
| ⌘ 1–8 | Jump to workspace 1–8 |
| ⌘ 9 | Jump to last workspace |
| ⌃ ⌘ ] | Next workspace |
| ⌃ ⌘ [ | Previous workspace |
| ⌘ ⇧ W | Close workspace |
| ⌘ ⇧ R | Rename workspace |
| ⌥ ⌘ E | Edit workspace description |
| ⌘ B | Toggle sidebar |
| ⌥ ⌘ B | Toggle right sidebar |
| ⌘ ⇧ E | Toggle right sidebar focus |
| Shortcut | Action |
|---|---|
| ⌘ T | New surface |
| ⌘ ⇧ ] | Next surface |
| ⌘ ⇧ [ | Previous surface |
| ⌃ Tab | Next surface |
| ⌃ ⇧ Tab | Previous surface |
| ⌃ 1–8 | Jump to surface 1–8 |
| ⌃ 9 | Jump to last surface |
| ⌘ W | Close surface |
| Shortcut | Action |
|---|---|
| ⌘ D | Split right |
| ⌘ ⇧ D | Split down |
| ⌥ ⌘ ← → ↑ ↓ | Focus pane directionally |
| ⌃ ⇧ H J K L | Resize pane left/down/up/right |
| ⌘ ⇧ H | Flash focused panel |
Browser developer-tool shortcuts follow Safari defaults and are customizable in Settings → Keyboard Shortcuts.
Command palette navigation shortcuts, including ⌃ P, are also customizable and can be cleared so the keypress reaches the active terminal.
| Shortcut | Action |
|---|---|
| ⌘ ⇧ L | Open browser in split |
| ⌘ L | Focus address bar |
| ⌘ [ | Back |
| ⌘ ] | Forward |
| ⌘ R | Reload page |
| ⌥ ⌘ I | Toggle Developer Tools (Safari default) |
| ⌥ ⌘ C | Show JavaScript Console (Safari default) |
| Shortcut | Action |
|---|---|
| ⌘ I | Show notifications panel |
| ⌘ ⇧ U | Jump to latest unread |
| ⌥ ⌘ U | Toggle current item unread state |
| ⌃ ⌘ U | Mark current item as oldest unread and jump to next latest unread |
| — | Mark all notifications read (unbound by default; configure in Settings or cmux.json) |
| — | Clear all notifications (unbound by default; configure in Settings or cmux.json) |
| Shortcut | Action |
|---|---|
| ⌘ F | Find |
| ⌘ ⇧ F | Find in directory |
| ⌘ G / ⌥ ⌘ G | Find next / previous |
| ⌥ ⌘ ⇧ F | Hide find bar |
| ⌘ E | Use selection for find |
| Shortcut | Action |
|---|---|
| ⌘ K | Clear scrollback |
| ⌘ C | Copy (with selection) |
| ⌘ V | Paste |
| ⌘ + / ⌘ - | Increase / decrease font size |
| ⌘ 0 | Reset font size |
| Shortcut | Action |
|---|---|
| ⌘ ⇧ N | New window |
| ⌘ ⇧ O | Reopen previous session |
| ⌘ , | Settings |
| ⌘ ⇧ , | Reload configuration |
| ⌘ Q | Quit |
Download cmux NIGHTLY (universal; updates then switch to your Mac's architecture automatically)
cmux NIGHTLY is a separate app with its own bundle ID, so it runs alongside the stable version. Built automatically from the latest main commit and auto-updates via its own Sparkle feed.
Report nightly bugs on GitHub Issues or in #nightly-bugs on Discord.
Quitting cmux saves the current session. On relaunch, cmux restores app-owned state:
- Window/workspace/pane layout
- Working directories
- Terminal scrollback (best effort)
- Browser URL and navigation history
cmux does not checkpoint arbitrary live process state. Ordinary terminals,
tmux, vim, shells, and unsupported terminal apps reopen as normal terminals.
For live detach/reattach across cmux quit, crashes, and updates, opt in to the
local tmux owner with cmux local-tmux; see docs/local-tmux.md
for its lifecycle and machine-sleep limits. zellij users can use cmux local-zellij
instead; see docs/local-zellij.md.
Supported agent sessions can resume when hooks have saved a native session ID.
Install hooks after installing the agent CLI so its binary is on PATH:
cmux hooks setup cmux hooks setup codex cmux hooks setup --agent opencode
cmux hooks setup installs supported agents it can find and prints a summary
for skipped agents. Supported resume integrations include Claude Code, Codex,
Grok, OpenCode, Pi, Amp, Cursor CLI, Gemini, Rovo Dev, Copilot, CodeBuddy,
Factory, and Qoder. Claude Code is handled by the cmux Claude wrapper when Claude
integration is enabled in Settings.
Advanced users and integrations can attach a custom resume command to the current terminal surface. This is useful for tools with their own durable state, such as tmux sessions or custom agent CLIs:
cmux surface resume set --kind tmux --checkpoint work --shell "tmux attach -t work" cmux surface resume show --json cmux surface resume clear --checkpoint work
The binding stays attached to the cmux surface. Public CLI or socket-created bindings are stored for inspection and manual restore unless you approve a signed command prefix for automatic restore. Approved prefixes are also bound to the working directory and exact environment values, when present. Review or edit approvals in Settings > Terminal > Resume Commands. cmux only auto-runs resume bindings it marks trusted, such as live process-detected tmux bindings or user-approved prefixes. Sensitive environment keys such as tokens, passwords, secrets, and API keys are dropped before a resume binding is stored.
To keep restored agent terminals idle instead of automatically running their resume commands,
turn off Settings > Terminal > Resume Agent Sessions on Reopen or set this in
~/.config/cmux/cmux.json:
{
"terminal": {
"autoResumeAgentSessions": false
}
}This only disables automatic agent resume commands. cmux still restores the saved layout, working directories, scrollback, and browser history.
If you need to reapply the last saved snapshot manually, use:
File > Reopen Previous Session⌘ ⇧ Ocmux restore-session
Each cmux install (stable, nightly, rc, staging, and tagged debug builds) keeps its own saved session. To bring a session from one install into another, for example after trying nightly and switching back to stable, run this from the install you want to open it in:
cmux restore-session --from nightly # or stable, rc, staging, debug:<tag> cmux restore-session --export ~/session.json # write this install's saved session to a file cmux restore-session --export ~/session.json --force # replace an existing export file cmux restore-session --from ~/session.json # reopen an exported file
The imported session opens as additional windows next to the ones you have, like
cmux restore-session; the other install's saved file is only read. Agent resume carries
over because hook session mappings in ~/.cmuxterm/ are shared by every install. Browser
cookies and logins are per install and do not move.
--from <channel> restores another install's own session file with the same trust as your
own session, including automatic agent resume. --from <path> treats the file as untrusted:
layout, working directories, text scrollback, and http(s) browser tabs restore, but nothing in
the file runs automatically. Built-in agents (Claude Code, Codex, Amp, and the rest) resume with
the command cmux builds from the agent kind and session id, ignoring launch arguments stored in
the file, and only when the working directory already exists on this Mac. Custom agent resume
commands, resume bindings, and tmux start commands are kept for manual restore only (approved
resume prefixes never apply to them): the CLI reports how many were held back, and in each
terminal cmux surface resume show shows the command and cmux restore --surface runs it.
Terminal control sequences in the scrollback (clipboard, notifications, links, titles), draft
attachments, non-http(s) browser pages and profiles, SSH/cloud connections, and workspace
environment variables from the file are dropped. A snapshot saved by a newer cmux
(newer session format) is refused with an error; if a downgraded cmux finds one in its own
session file, it keeps a copy next to it as session-<bundle id>.schema-v<N>.json.
Under the hood, cmux writes a versioned snapshot under
~/Library/Application Support/cmux/ and agent hooks write session mappings
under ~/.cmuxterm/. On restore, cmux rebuilds the layout first, then runs the
supported agent's native resume command when automatic agent resume is enabled.
Read the full guide at https://cmux.com/docs/session-restore.
cmux is not a fork of Ghostty. It uses libghostty as a library for terminal rendering, the same way apps use WebKit for web views. Ghostty is a standalone terminal; cmux is a different app built on top of its rendering engine.
macOS only, for now. cmux is a native Swift + AppKit app.
Yes, in beta. Pair your iPhone with your Mac from the Mobile Connect window and attach to your terminals from your phone, with optional forwarding of terminal notifications. It ships on TestFlight as cmux BETA. Early access is included with cmux Pro. See the iOS docs.
All of them. cmux is a terminal, so any agent that runs in a terminal works out of the box: Claude Code, Codex, OpenCode, Gemini CLI, Kiro, Aider, Goose, Amp, Cline, Cursor Agent, and anything else you can launch from the command line.
Yes. When an agent spawns subagents or teammates, cmux turns them into native panes and splits instead of hidden background processes. It supports Claude Code teams and oh-my-opencode multi-model orchestration, so every agent in a run is visible and controllable.
Yes. Open workspaces over SSH and attach to remote tmux sessions, so agents can run on a remote host while you drive them from cmux. See SSH and remote.
When a process needs attention, cmux shows notification rings around panes, unread badges in the sidebar, a notification popover, and a macOS desktop notification. These fire automatically via standard terminal escape sequences (OSC 9/99/777), or you can trigger them with the cmux CLI and agent hooks. Any agent that supports hooks or OSC works, including Claude Code, Codex, OpenCode, and pi.
Yes. Every action is available through the cmux CLI and a Unix socket: create workspaces, open split panes, send input, read screen contents, take screenshots, and drive the in-app browser. See the CLI reference and browser automation docs.
cmux can split a real browser pane next to your terminal, and it is fully programmable: navigate, snapshot the DOM, click, type, evaluate JavaScript, and read console and network activity over the same socket API. Agents use it to verify their own web changes without leaving cmux. See browser automation.
Yes. Skills are reusable workflows you can give any agent running in cmux, for things like CLI control, workspace automation, settings, and browser surfaces. Browse the open collection at cmux-skills, or read the skills docs.
Terminal keybindings are read from your Ghostty config file (~/.config/ghostty/config), including leader sequences and key tables. Ghostty tab actions target cmux workspaces; see the action mapping, precedence, and limitations. cmux-specific shortcuts (workspaces, splits, browser, notifications) can be customized in Settings. See the default shortcuts for a full list.
Yes. Terminal rendering uses your Ghostty config, so themes, fonts, colors, and cursor carry over directly. cmux's own settings in ~/.config/cmux/cmux.json control the sidebar, tab bar, split panes, and behavior, and every keyboard shortcut is editable. See configuration.
cmux restores windows, workspaces, panes, working directories, and best-effort
scrollback when you relaunch. Supported agent integrations can resume from
their saved session IDs. Those are reconstructed app state and resume commands;
they do not keep arbitrary live processes running. Use cmux local-tmux for
live local detach/reattach across cmux quit, crashes, and updates. A local tmux
server cannot survive logout, restart, shutdown, or power loss; use
cmux ssh-tmux, cmux mosh-tmux, or a persistent cloud VM when the owner must
remain online while this Mac is offline. See session restore
and docs/local-tmux.md.
tmux is a terminal multiplexer that runs inside any terminal. cmux is a native macOS app with a GUI: vertical tabs, split panes, an embedded browser, and a socket API, all built in, no config files or prefix keys needed. That said, lots of people happily run cmux with SSH and tmux together, and cmux can attach to your remote tmux sessions natively (beta).
Yes, cmux is free to use. The source code is available on GitHub.
cmux is free and open source, and always will be. If you want to back development and get early access to what's next, including cmux AI, the iOS app, and Cloud VMs, check out cmux Pro.
We want to hear it. Open an issue or pull request on GitHub, or email us.
FAQ
How does it compare to tmux?
tmux is an in-terminal multiplexer, whereas cmux is a native GUI app with tabs, splits, a browser and a socket API built in, although they can be used together.
Can I customize cmux?
cmux's own settings live in ~/.config/cmux/cmux.json for the sidebar, tab bar, splits and behaviour, and every shortcut is editable.
Can I customize keyboard shortcuts?
Terminal bindings are taken from your Ghostty config, and cmux-specific shortcuts can be changed in Settings.
Does cmux have skills?
Yes, skills are reusable workflows you can give any agent inside cmux, with an open collection in the cmux-skills repo.
What can the built-in browser do?
It is a real browser pane driven over the same socket API: navigate, snapshot, click, type, evaluate JavaScript and read console or network activity.
Is cmux programmable?
Yes, every action is available from the CLI over a Unix socket, including creating workspaces and splits, sending input, reading the screen and driving the browser.
How do notifications work?
Alerts show as pane rings, sidebar unread badges, a popover and a macOS notification, triggered automatically by OSC escape sequences or by the CLI and agent hooks.
Can I use cmux with remote machines?
Yes, you can open workspaces over SSH and attach to tmux sessions on the remote host, so agents run there while you drive them from cmux.
Can cmux orchestrate multiple agents and subagents?
Yes, spawned subagents and teammates become real cmux panes and splits rather than invisible background processes.
What coding agents does cmux work with?
Any terminal-based agent works out of the box, including Claude Code, Codex, OpenCode, Gemini CLI, Kiro, Aider, Goose, Amp, Cline and Cursor Agent.
Is there an iOS app?
Yes, a beta TestFlight app that pairs with your Mac through the Mobile Connect window and attaches to your terminals.
How does cmux relate to Ghostty?
cmux is not a fork; it links libghostty as a rendering library the way an app embeds WebKit, so Ghostty and cmux are separate programs.
More in Terminal
CodemanSelf-hosted web dashboard running 11 AI coding agents in tmux sessions, streaming live terminals to any browser with zero-lag input, QR login, and autonomous runs.
C-SSHCross-platform SSH client with terminal, file management, monitoring, and AI. Optional self-hostable Creation Cloud for encrypted config sync.
DesktopCommanderMCPOpen-source, self-hosted MCP server that gives Claude, ChatGPT and other AI clients terminal, file and process control on your own machine.
DumbTermSelf-hosted web terminal with Starship prompt, PIN protection, dark mode, PWA, and pre-installed CLI tools. Deploy via Docker, Compose, or Node.js.
electerm-webelecterm-web is a self-hosted, open-source web terminal and SSH/SFTP client with AI assistance, multi-language support, cloud sync, and responsive mobile design.
IM.codesSelf-hosted open-source messaging and control layer for AI coding agents providing shared memory, remote desktop, supervised execution, and cross-provider audit.
marchatSelf-hosted, open-source terminal chat for developers with real-time WebSocket messaging, optional E2E encryption, plugin system, and SQLite/PostgreSQL/MySQL backends.
MulmoTerminalSelf-hosted browser terminal running multiple AI coding agents in a grid, color-coded by state. Uses tmux for persistence and git worktrees for isolation.
Myrlin WorkbookSelf-hosted workspace manager that unifies Claude Code and Codex sessions with live terminals, scrollback, cost tracking, kanban, and phone UI.
nexus4ccSelf-hosted web terminal bridging browsers to tmux sessions running Claude Code and other AI agents, with project/channel management, file browser, and PWA support.
NoEyesSelf-hosted terminal chat with E2E encryption and a blind-forwarder server that cannot read messages or identify users. For small trusted groups wanting private comms.
Open TerminalA self-hosted, open-source terminal server exposing a real remote shell and file APIs over REST for AI agents and automation; deploy via Docker, pip, or uvx.







0 comments