Every few weeks, someone asks me which terminal they should switch to. The question usually arrives shaped like this: “iTerm or tmux or cmux or something else — which is best for a developer in 2026?”
I’ve started giving the same annoying answer: the question is wrong. Not in a clever-internet-person way. Wrong in a useful way — the kind of wrong that, once you see it, changes what you actually install on your machine.
These three tools are not competing for the same slot. iTerm2 is a terminal emulator. tmux is a multiplexer that runs inside any terminal emulator. cmux is a 2026-vintage macOS app built specifically for orchestrating AI coding agents. Picking “the best one” between them is like asking whether Chrome, AdBlock, or your second monitor is the best browsing tool. The answer depends on which problem you’re actually solving.
The Category Confusion Nobody Names
Open any “best terminal 2026” article and you’ll see Ghostty, Warp, iTerm2, Alacritty, WezTerm, and tmux all listed in the same comparison table. That table is lying to you. Specifically:
- Terminal emulators draw text on the screen and talk to your shell. Examples: iTerm2, Ghostty, Warp, Alacritty, Kitty, WezTerm, Terminal.app.
- Terminal multiplexers run inside an emulator and let one terminal window host many sessions. Examples: tmux, GNU Screen, Zellij.
- AI-agent terminal apps are a new 2026 category — native apps that combine emulation, multiplexing, and agent-aware UX (notifications, branch sidebars, embedded browsers). Examples: cmux on macOS, wmux on Windows (cmux port), limux on Linux (Ghostty-based fork), Chloe, Superset.
Putting iTerm2 and tmux on the same list is a genre mistake. You can — and most experienced developers do — run tmux inside iTerm2 and use both at once. That’s not a contradiction. That’s the default setup for anyone who SSHes into servers.
A Quick Map of What Each One Actually Does
Here’s the honest one-line summary I’d give a junior developer asking me cold:
| Tool | What it actually is | When you reach for it |
|---|---|---|
| iTerm2 | Mature macOS terminal emulator with deep customization (Triggers, Profiles, Python API, native tmux integration). Free, GPL v2. | You want a “Swiss Army knife” emulator with 15+ years of polish. |
| Ghostty | Newer GPU-accelerated emulator built on libghostty. Native Metal rendering. Free, MIT. | You want raw speed and a clean, minimal config file. |
| Warp | Rust-based emulator with built-in AI command generation and team-shared “Warp Drive” notebooks. Free tier + paid plans. | You want AI-assisted commands and team workflows, and you’re OK with a sign-in. |
| tmux | Terminal multiplexer. Persists sessions across disconnects. Pane-based layouts. Runs inside any emulator. | You SSH into servers and need detach/reattach. Or you want one window per project on your laptop. |
| Zellij | Modern multiplexer with discoverable keybindings and a plugin system. Same role as tmux. | You want tmux ergonomics without memorizing the prefix-key vocabulary. |
| cmux | Native macOS app (Swift/AppKit + libghostty) for orchestrating AI coding agents. Vertical tabs, embedded browser, OSC notification rings. Free, GPL v3. | You’re running 3+ AI agents in parallel on a Mac and you need agent-aware notifications. |
The first three solve “draw text fast and look good doing it.” The next two solve “let me run multiple sessions inside one window and survive a network blip.” The last one solves “I have five Claude Code sessions going and I need to know when each finishes.”
Pro tip: If you don’t run AI agents in parallel and you don’t SSH to servers, you don’t need a multiplexer or an agent runner. A good emulator alone is fine. Most engineers I know who claim they “live in tmux” are actually using maybe 20% of it — and would be happier with iTerm2’s native panes.
Why cmux Showed Up in February 2026
This is the part most comparison articles skip. cmux didn’t appear because tmux got worse. It appeared because the workload changed.
If your daily work in 2018 looked like “edit code, run tests, commit, push,” then tmux was overkill but harmless. If your daily work in 2026 looks like “kick off Claude Code on feature A, kick off Codex on feature B, supervise the third agent doing a code review while I edit a SwiftUI view,” you have a fundamentally different problem. You need to know — without scanning panes manually — which agent just finished, which one is blocked on input, and which one hit an error.
cmux was built for that workload. It uses libghostty for terminal rendering, reads your existing Ghostty config, and adds vertical tabs with branch-aware metadata, embedded browser panes, and a Unix socket API for scripting. When an agent emits a standard OSC notification escape code, cmux fires a macOS desktop notification and shows a pulsing ring around the relevant pane. tmux can be configured to do something similar with extensive .tmux.conf hacking. cmux ships it as the default.
The same wave produced wmux (Windows port) and limux (Linux fork). The category is real, not a single product fad.
The First-Principles Reset: What Are You Actually Optimizing For?
Forget the brand names for sixty seconds. Here’s the real decision tree:
- Do you want text on your screen to render fast and look right? That’s the emulator question. Ghostty, iTerm2, Warp, Kitty, Alacritty all answer it well. Pick one based on whether you value performance (Ghostty), customization depth (iTerm2), or built-in AI (Warp).
- Do you SSH to servers and need your session to survive a disconnect, or do you want pane layouts that persist across reboots? That’s the multiplexer question. tmux is the universal answer. Zellij is the friendlier modern alternative. If you say no to both, you don’t need a multiplexer.
- Do you run multiple AI coding agents at once and need to know when each one needs you? That’s the agent-runner question. On macOS, cmux is currently the most polished answer. On Windows, wmux. On Linux, limux or a tmux setup with custom OSC handling.
If you’re honest about which of these three problems you actually have, the “which is better” question dissolves. You can answer all three independently, and most senior developers do.
The Aha: The Terminal Stopped Being a Window
Here’s the insight I think most “best terminal” content misses entirely.
For thirty years, “the terminal” meant a window where you typed commands and read output. The mental model was a typewriter. Tools optimized for that model: faster typewriters, prettier typewriters, typewriters with macros. iTerm2 is the apex of that philosophy. tmux extended it by letting one typewriter act like several.
Around 2024, the model changed. Claude Code, Codex, Aider, Cursor’s CLI mode — these don’t just type-and-respond. They run for minutes at a time, produce thousands of lines of output, hit boundaries where they need a human decision, and often run several at once. The unit of attention is no longer “the command I just typed.” It’s “which of my five sessions needs me right now?”
That’s not a typewriter problem. That’s a dashboard problem.
cmux is the first tool I’ve seen that designs explicitly for the dashboard model: notification rings, sidebar metadata, branch-aware tab labels, an embedded browser to keep documentation next to the agent that needs it. It’s not a faster typewriter. It’s a different category.
Everyone else is catching up. Warp’s “Agentic Terminal” blocks point in the same direction. Zellij sessions and floating panes do too. The pattern is clear — and it tells you what to expect from the 2027 versions of these tools.
⚠️ Watch out: Don’t switch to cmux just because it’s trending on Hacker News. If you don’t actually run multiple agents in parallel, the dashboard layer is overhead. iTerm2 plus tmux is still the right answer for a lot of work — especially anything heavy on SSH.
My Actual Setup, and What I’d Change
I should be honest about my own stack rather than pose as a power-user of every tool here. I run on an M2 MacBook Air (16GB), and my daily driver is iTerm2 with zsh plus Starship. I don’t use tmux locally — iTerm2’s native panes cover what I need on a single machine. When I SSH to a server (rare these days), I’ll start a tmux session there.
For SwiftUI work in iOS 26, my window layout is Xcode plus iTerm2 side by side. No multiplexer, no agent dashboard. The work is interactive enough that the typewriter model still fits.
What I’m watching: cmux for the moment my workflow tips over. The day I’m running three Claude Code sessions in parallel on a real project — and that day is coming — I’ll likely move to either Ghostty + tmux with custom OSC handling, or just install cmux directly. If you’re already in that workflow now, I think cmux is worth a serious week-long trial. The brew install is free.
What I won’t do: pay $20/month for Warp. Privacy-first principle — I don’t want a mandatory sign-in on a tool that sees every command I type. Other people make a different tradeoff and that’s fine.
The Inversion: How Does This Stack Fail?
Worth running the failure mode on each layer:
- Emulator failure: You picked an emulator with a bad text rendering pipeline. Symptoms: latency on
git log, stutters onkubectl logs -f. Fix: switch to Ghostty or modern iTerm2. - Multiplexer failure: You’re using tmux for problems it doesn’t solve. Symptoms: you spend more time configuring
.tmux.confthan using it; your panes still don’t survive a Mac reboot (tmux survives SSH disconnects, not laptop reboots). Fix: drop it for local work. Use it only on remotes. - Agent-runner failure: You installed cmux but you only run one agent at a time. Symptoms: you find yourself ignoring the sidebar. Fix: go back to your emulator until you actually have parallel agents.
The biggest mistake I see is layering by FOMO rather than by need. Don’t add a tool until you’ve felt the absence of it.
Honest Assessment
What works: this layered model is durable. Emulators will keep getting faster. Multiplexers will stay essential for SSH. Agent runners are a new permanent category, and the leaders will shift but the category won’t disappear.
What doesn’t work: trying to find one tool that does all three. Warp comes closest by bundling AI into the emulator, but the AI features are tied to a paid plan and a sign-in. cmux comes close from the other direction, but it’s macOS-only today. The “one tool to rule them all” approach hasn’t shipped yet, and probably won’t in 2026.
What I’d do differently if starting from zero today: install Ghostty as my emulator (faster than iTerm2 on every benchmark I trust), keep iTerm2 around for its Triggers and AppleScript hooks, learn just enough tmux to be dangerous on remote boxes, and watch cmux closely for when my agent workload justifies it.
TL;DR
You don’t pick one. You pick a layer for each real problem: an emulator that renders fast, a multiplexer if you live on remote servers, and an agent runner if you orchestrate multiple AI coding sessions. The “iTerm vs cmux vs tmux” question is a category error — and once you stop asking it, the right tools become obvious.
If I had to give one recommendation per developer profile:
- Solo Mac dev, no SSH, no AI agents: iTerm2 or Ghostty. That’s it.
- Mac dev who SSHes regularly: Ghostty/iTerm2 + tmux on remotes.
- Mac dev orchestrating 3+ AI agents: Ghostty/iTerm2 for normal work + cmux for agent sessions.
- Linux dev: Ghostty or Kitty + tmux/Zellij. Watch limux.
- Windows dev: Windows Terminal + WSL2 + tmux. Watch wmux.
Pick the layer, not the brand.
FAQ
Is cmux a replacement for tmux?
Not really. cmux is a native macOS app aimed at AI agent workflows; tmux is a terminal-resident multiplexer that runs anywhere, including over SSH. They overlap on local pane management but solve different primary problems. Most developers who adopt cmux still keep tmux available for remote sessions.
Should I switch from iTerm2 to Ghostty in 2026?
If you have a heavy iTerm2-specific workflow built on Triggers, Profiles, or its Python API, the migration cost is real and probably not worth it. If you’re a casual iTerm2 user who mostly cares about speed and a clean config, Ghostty’s rendering performance is a genuine upgrade and the install is two minutes.
Do I need tmux as an indie iOS or web developer?
Probably not, if you only work on a local Mac. iTerm2 and Ghostty both have native panes and tabs that cover the same use case for a single machine. tmux’s killer feature is session persistence across disconnects, and unless you SSH into servers, you’re paying for power you don’t use.
What’s the difference between Warp and cmux?
Warp is a closed-source, sign-in-required emulator with built-in AI command generation, aimed at a broad developer audience. cmux is an open-source macOS-native app focused specifically on orchestrating multiple AI coding agents in parallel — vertical tabs, branch-aware sidebar, agent notification rings. They both touch “AI in the terminal” but from opposite ends.
