umux: an open-source terminal workspace manager for Linux, Windows, and macOS

Crystal Studio — Fri, 28 Aug 2026 10:51:03 +0000

TLDR

umux is a free, open-source desktop app that organizes terminal windows into named workspaces (one per project), each holding tabs that split into any number of resizable panels. It runs natively on Linux, Windows, and macOS from one codebase. It also watches the terminal data stream for the signals AI coding tools emit when a long task finishes, and fires a desktop notification — so you can step away while an agent works. Version 1.0.2, released 27 August 2026, is the first release with native Windows and macOS builds alongside Linux. It exists for developers who want the "many terminals, one place" workflow without learning tmux.

Key facts

Platforms: Linux (.deb, .AppImage, .rpm), Windows 10+ (.exe installer), macOS 11+ (universal .dmg — Apple Silicon and Intel in one file)
Current release: v1.0.2, 27 August 2026; nine tagged releases in total, from five dev previews to the 1.0 line
Development timeline: 53 commits between 27 June and 27 August 2026; 42 of them in August — the active build took under a month
Tests: 449 automated tests (115 Rust + 334 frontend), all passing at v1.0.2
Stack: Tauri v2 — a Rust backend, a React + TypeScript frontend, terminals rendered with xterm.js
Licence and cost: MIT; builds are unsigned; infrastructure cost is $0 (GitHub Actions for builds, Cloudflare Pages for the landing page)
Telemetry: exactly one anonymous app-open event, nothing else
Layout model: workspaces → tabs → unlimited split panels per tab, with minimum panel sizes and one-shortcut pane zoom

Key fact: terminal output inside umux is byte-identical whether or not its inspector is running — the inspector reads the stream and never modifies it.

What is umux?

umux is one window where all of a project's terminals live. A developer creates a workspace named after the project — "shop-frontend", "server-migration" — and opens terminal tabs inside it. Any tab's area splits into as many panels as needed, resized by dragging dividers, with a minimum size enforced so nothing collapses to nothing. A keyboard shortcut zooms one panel to fill the tab and restores the exact previous layout afterwards; the covered panels keep running underneath.

The whole arrangement survives a restart. Workspaces, tabs, panel layouts, and working directories are saved to a config file and restored when the app reopens. Each panel runs a real shell — the user's own shell on Linux and macOS, PowerShell on Windows — and renders a genuine terminal: colors, cursor movement, full-screen programs like vim and htop all work.

What problem does it solve?

A working developer's terminal count grows with every project. Today's typical setup: a dev server in one window, an API in another, an SSH session into a remote machine somewhere, plus an AI coding agent churning through a task in a fourth. The windows pile up in the taskbar and the developer loses track — most acutely when an AI agent finishes a ten-minute task and nobody notices for twenty minutes.

Quick answer: umux replaces the window pile-up with one window per project, and it tells you when the AI agent is done instead of making you babysit it.

The classic tool for this is tmux, and it is genuinely excellent — but it is a keyboard-first, text-mode world with its own prefix keys and configuration language. Plenty of good developers never learn it. umux delivers the same outcome (many terminals, one place, organized per project) through a graphical interface.

How does umux work?

umux is one app with two halves, built on Tauri v2.

The Rust backend owns everything that touches the operating system. It creates pseudoterminals (PTYs — the mechanism that makes a program believe it is talking to a real terminal), writes keystrokes into them, resizes them, and closes them cleanly. It also handles SSH connections, desktop notifications, and the config file.

The frontend (React + TypeScript) renders the workspace UI and a real terminal surface per panel using xterm.js. Keystrokes flow from the terminal surface down to the backend; output flows from the PTY back up to the screen.

Key fact: local panels and SSH panels are the same thing to the rest of the app — both are just a PTY behind one interface — so a remote machine's terminal behaves exactly like a local one.

How does umux know when an AI agent finished a task?

Terminals and the tools running inside them communicate through escape sequences — special byte patterns embedded in the normal output stream. AI CLI tools such as Claude Code, Codex, and Aider emit standard OSC escape sequences (OSC 9;9, OSC 99, OSC 777) when a long task completes.

umux feeds every byte of terminal output through a small parser that recognizes these sequences and turns them into events. An event becomes a native desktop notification, and it also drives a per-panel agent status indicator: working while the agent streams, needs-attention when it waits for the user, idle once it exits.

Three properties of this design matter:

No polling. umux never checks whether a process is still running on a timer.
No screen scraping. umux never reads the visible terminal content to guess what is happening.
No mutation. The parser passes every byte through unchanged and only extracts events, so output stays byte-identical whether or not umux inspects it. Detection relies solely on the escape sequences — nothing else.

How does umux compare to tmux, cmux, and Herdr?

Quick answer: pick tmux if you already live in a keyboard-driven terminal workflow; pick umux if you want that outcome in a GUI — with cross-platform builds the others don't all have.

	umux	tmux	cmux	Herdr
Type	desktop app (GUI)	text-mode multiplexer	native macOS app	CLI/TUI multiplexer
Platforms	Linux, Windows, macOS	Unix-like (Windows via WSL)	macOS only	terminal-based
Interface	point-and-click + shortcuts	keyboard prefix, config file	GUI sidebar	keyboard prefix (Ctrl+B)
Agent-finish notifications	yes, from OSC signals	no	yes	agent-aware
Learning curve	install and use	prefix keys, copy mode, config language	install	prefix keys

cmux and Herdr both target the same new audience — developers running AI coding agents — and both are solid tools. The gap umux fills, per its creator: cmux carries more features than he needed and ships only for macOS; Herdr is a terminal-world tool with no desktop app. umux is the middle option — a simple desktop app, three platforms, one codebase.

What are the known limitations?

Agent status is the least polished feature. By the creator's own admission it does not yet work perfectly. The completion notifications it is built on are the solid part.
Builds are unsigned. umux ships without paid signing certificates (a deliberate $0-cost policy), so macOS Gatekeeper and Windows SmartScreen show a one-time first-run warning. The README documents the two-click workaround.
SSH panels run on Linux and macOS today; Windows SSH support is planned for v2.0.
Linux is the reference platform (Ubuntu on Wayland is what gets tested). X11 sessions are untested.

Steps: how to install umux

Download from umux.pages.dev or the GitHub releases page.
Pick the format: Linux — .deb (installs into the system) or .AppImage (portable, no install); macOS — drag the .dmg app to Applications; Windows — run the .exe installer.
First run of an unsigned build: on macOS, right-click the app and choose Open (once); on Windows, SmartScreen → More info → Run anyway (once). The README documents both.
Create a workspace per project, add a tab, split it into panels. The layout, working directories, and shells come back after a restart.

FAQ

Is umux free?

Yes. It is MIT-licensed open source, the builds cost nothing to make (GitHub Actions), and nothing in the toolchain is paid for — including certificates, which is why builds are unsigned and the README documents the first-run steps.

Which operating systems does umux support?

Linux (Ubuntu/Wayland is the reference), Windows 10 and newer, and macOS 11 and newer. The macOS build is universal — one file covers Apple Silicon and Intel. Each platform gets its own native shell: PowerShell on Windows, the user's shell elsewhere.

Do I need to learn keybindings or write a config file?

No. umux is point-and-click first: workspaces are created and renamed in the UI, panels are split and resized by dragging, and a handful of shortcuts (such as pane zoom) speed up daily use. There is no configuration language to learn.

How does umux detect that an AI coding agent finished?

It reads the standard OSC escape sequences (OSC 9;9, OSC 99, OSC 777) that AI CLI tools emit on task completion, straight from the terminal byte stream. No process polling, no screen reading. The same signals drive a per-panel agent status indicator.

Does umux change my terminal output?

No. The inspector sits beside the stream, not in front of it: every byte passes through unchanged, and detection relies solely on the escape sequences. Output is byte-identical whether or not umux is running.

Is umux a tmux replacement?

Not for people already productive in tmux — it does not aim at them. It is an alternative for the larger group that never adopted tmux's keyboard-first world and wants the same organization through a GUI. There is no config file and no modal editing model to learn.

What data does umux collect?

One anonymous app-open event, used to estimate active usage. Nothing else — no terminal content, no file names, no telemetry of any other kind. It can be turned off.

Can umux connect to remote machines?

Yes. An SSH panel opens a shell on a remote machine using the local SSH agent and keys, and behaves identically to a local panel. SSH on Windows is planned for v2.0.

How long did it take to build?

Under a month of active work. The commit record spans 27 June to 27 August 2026 (53 commits), with 42 of them landing in August.

Last updated

2026-08-28

DEV Community: Crystal Studio