Paneflow vs cmux

Paneflow’s design is openly inspired by cmux. cmux was the first project to ship a polished agent-first terminal multiplexer for developers running multiple AI coding agents in parallel, and the “workspace per project, panes per agent” mental model came from it.

Paneflow is not a fork. It is an independent Rust codebase that reimplements that mental model with different architectural choices: pure Rust instead of Swift, GPUI instead of AppKit, upstream alacritty_terminal instead of libghostty, and cross-platform from day one instead of macOS-first. Both projects exist in parallel and solve overlapping problems with different tradeoffs - the rest of this page lays them out.

Grouped in three zones - performance & architecture (where Paneflow leads), core agent workspace (where both are equivalent), and the adjacent toolkit (where cmux has shipped more surface).

Performance & architecture

Core agent workspace

Adjacent toolkit

Versions: Paneflow v0.2.16 (May 2026), first release April 2026 (v0.1.0). cmux v0.64.7 (May 19, 2026, also tagged v1.38.1), first release January 2026 (v0.2.0). Pricing: both free. Paneflow MIT; cmux GPL-3.0-or-later with a separate commercial license available.

The honest version: this is a clean either/or for most users. The two bullet lists below capture who each tool is genuinely built for. If you fit neither, you probably want something simpler (raw tmux, WezTerm, iTerm2).

cmux is a native macOS application built on AppKit and SwiftUI. Terminal emulation is delegated to libghostty, the C library that powers the Ghostty terminal emulator, bridged into the Swift app through GhosttyKit.xcframework. Rendering goes through a custom GhosttyMetalLayer subclass of CAMetalLayer (Ghostty drives Metal directly, no MTKView). Pane layout uses Bonsplit, an N-ary tree layout library that exposes adjacency queries (adjacentPane(to:direction:)) and snapshots for session persistence.

Paneflow is built in pure Rust on top of GPUI, the same UI framework Zed uses. In practical terms: there is no language boundary between the UI and the terminal - keystrokes travel through a single pure-Rust pipeline, which is why keystroke-to-pixel latency stays under 4 ms and the app cold-starts in under 200 ms. Terminal emulation is upstream alacritty_terminal0.26 from crates.io - the public, stable Rust VT crate. No fork to maintain, so future Rust ecosystem improvements flow in naturally. The GPU layer is Blade (GPUI’s renderer) over Vulkan on Linux and Metal on macOS. Pane layout is a hand-rolled N-ary tree designed for the four preset layouts (even horizontal, even vertical, main-vertical, tiled).

On the IPC side, both projects expose a Unix socket. cmux runs two protocols in parallel on the same socket: V1 is a space-delimited text protocol (e.g. new-workspace, send-key <args>), V2 is newline-delimited JSON. The dispatcher inspects the first byte of each line to route. Combined surface area is several hundred commands covering windows, panes, sessions, notifications, and remote workspaces. Paneflow ships a single JSON-RPC 2.0 protocol with roughly thirteen methods covering workspaces and panes - smaller surface, faster to learn, far less coverage. Catching up to cmux on the IPC API surface is on the Paneflow roadmap.

Both projects are free to use. The licensing models differ:

• -Paneflow: MIT license, no dual licensing, no commercial tier. Use it however you want, including embedding it inside commercial products.
• -cmux: GPL-3.0 by default with a separate commercial license available for organizations that need non-copyleft terms. Pricing for the commercial license is not publicly listed; contact the maintainers.

You can move most of a cmux setup to Paneflow in about ten minutes. The config schemas are similar JSON shapes; the keystroke notation matches; the AI agent button concept is the same.

• -Config file: copy your ~/.config/cmux/cmux.json to ~/.config/paneflow/paneflow.json on Linux or ~/Library/Application Support/paneflow/paneflow.json on macOS. Rename keys that differ (see the schema reference).
• -Keybindings: defaults match for the core actions (Cmd/Ctrl+Shift+D split horizontal, Cmd/Ctrl+Shift+E split vertical, Alt+Arrow focus, Cmd/Ctrl+1-9 workspace switch). Custom overrides translate directly.
• -Sessions: not portable. On-disk session formats differ; you will need to recreate workspaces on first launch. Branch detection and CWD restoration kick in automatically after that.
• -SSH workflows: no direct migration path. If you depend on cmux ssh user@host, stay on cmux until Paneflow ships remote workspace support.

The honest dealbreakers. If any of the five below matters to you, cmux is the right tool today - no point fighting it:

1. 1.You need SSH remote workspaces. cmux ships an auto-deploying Go daemon (scp + SSH local- forward to a Unix socket) so cmux ssh user@host gives you a remote workspace transparently. Paneflow has no equivalent on the immediate roadmap.
2. 2.You need an embedded browser inside the terminal. cmux’s WKWebView panel imports profiles from Chrome, Firefox, Safari, Brave, Edge, and Arc. Paneflow does not plan a browser surface.
3. 3.You need cloud VMs provisioned from the terminal. cmux ships integrated VM provisioning (cmux vm new) wired to the rest of the workspace. Paneflow has no equivalent.
4. 4.You need a several-hundred-command IPC surface for automation. cmux exposes hundreds of commands over a dual V1 text + V2 JSON socket protocol. Paneflow’s JSON-RPC has thirteen methods today - enough for basic agent control, not enough for heavy automation pipelines.
5. 5.You need production-grade maturity right now. cmux is at v0.64 with months of ground-truth user feedback and active commercial backing. Paneflow is at v0.2.x with a small community. Config and IPC schemas may still shift between minor versions until v1.0.

Ready to try Paneflow? Download the latest release or read the getting-started guide. Curious about cmux instead? cmux is on GitHub and worth a look - it solves a problem the Paneflow team respects deeply.