Die besten Terminal-Multiplexer 2026: tmux vs Zellij vs Rex vs Herdr vs Tern vs TuiOS vs Muxy

Die Terminal-Multiplexer-Frage war früher in fünf Sekunden beantwortet: tmux, außer du warst auf einer Box eingeloggt, die so alt war, dass es nur GNU screen gab. Diese Antwort ist etwa Mitte 2026 abgelaufen. KI-Coding-Agenten haben verändert, wozu ein Multiplexer eigentlich da ist. Eine Shell über eine wackelige SSH-Verbindung am Leben zu halten war früher der ganze Job; heute heißt der Job, sechs Agenten über git worktrees hinweg am Leben zu halten, zu wissen, welcher gerade auf einen Permission-Prompt blockiert ist, und das von einem Laptop oder Handy freizugeben, ohne durch zwanzig Panes zu jagen.

Vier ernsthafte Tools konkurrieren jetzt innerhalb deines Terminal-Emulators (tmux, Zellij, Herdr und TuiOS), plus drei weitere (Superlogical Rex, Stencil Tern und Muxy), die argumentieren, der Multiplexer sollte der Terminal-Emulator selbst sein.

Ich habe alle sieben an echten Projekten gefahren und über die meisten eigene Deep Dives geschrieben. Dieser Guide stellt das ganze Feld nebeneinander: wie sich die Architekturen unterscheiden, Install- und Config-Snippets zum heute-Abend-Einfügen, wie jedes mit KI-Agent-Flotten, Remote-SSH- und Handy-Workflows umgeht, eine Keybinding-Übersetzungstabelle und wo jedes Tool immer noch wehtut. Jeder Screenshot unten stammt aus meinem eigenen Setup.

Versionen und GitHub-Star-Zahlen wurden am 2026-10-29 verifiziert (Muxy am 2026-11-01): tmux 3.8 (~49k Stars), Zellij 0.45.1 (~35.7k Stars), Herdr 0.9.3 (~44k Stars), TuiOS 0.11.1 (~5.4k Stars), Rex Public-Testing-Build, Tern 0.9.5 Closed Beta und Muxy 2.1 (~2.3k Stars).

Die Kurzversion

Wenn du nur die Empfehlung vor dem Deep Dive willst:

• tmux: Nimm es, wenn du dich auf Maschinen einloggst, die du nicht administrierst, ein 1,2-MB-Binary willst, das schon installiert ist, oder ein Jahrzehnt .tmux.conf-Muskelgedächtnis hast. Immer noch der richtige Default für normale Server- und Shell-Arbeit.
• Zellij: Nimm es, wenn du tmux’ Job mit modernen Defaults erledigt haben willst: On-Screen-Key-Hints, KDL-Projekt-Layouts, eingebaute Session-Resurrection, First-Class-Nested-Sessions (v0.45+), WebAssembly-Plugins und einen eingebauten Web-Client.
• Herdr: Nimm es, wenn KI-Coding-Agenten das meiste von dem sind, was du fährst. Die Echtzeit-Agent-State-Sidebar (working / blocked / done / idle), die Unix-Socket-API und das Mobile-/Web-Client-Ökosystem sind der Grund, warum es existiert.
• TuiOS: Nimm es, wenn du einen Tiling-Window-Manager in deinem Terminal willst plus die tiefste eingebaute Agent-Inbox (Prompt-Holds, queued Replies, Inline-Diff-Review mit Notizen, fan-Worktree-Runs und einen tmux-Shim) und mit einem schnelllebigen jungen Projekt leben kannst.
• Rex: Nimm es, wenn du auf macOS bist und den Multiplexer in die Terminal-App selbst eingebaut willst, powered by libghostty vom Ghostty-Schöpfer, mit First-Class-Remote-System-Logins.
• Tern: Nimm es, wenn du ein plattformübergreifendes Rust-Terminal willst, in dem Panes auch native Git-Clients, SQLite-Browser, Jupyter-Notebooks, Kanban-Boards und KI-Agent-Blöcke sein können, und dich eine Closed-Beta-Warteliste nicht stört.
• Muxy: Nimm es, wenn du den einzigen Open-Source-Eintrag im Terminal-App-Lager willst: eine Rust-+-GPUI-App auf libghostty (heute macOS, Linux experimentell), deren Server Panes am Leben hält, 12 KI-Coding-Agenten out of the box erkennt und native iOS-/Android-Companions mitbringt.

Alle 7 Terminal-Multiplexer auf einen Blick

Warum sich die Architektur 2026 spaltet: In-Terminal-TUI vs Terminal-als-Multiplexer

Bevor wir uns einzelne Tools anschauen, hilft es, den strukturellen Split in der Tabelle oben zu verstehen. Jedes Tool hier fällt in eines von zwei Lagern:

1. In-Terminal-Multiplexer (tmux, Zellij, Herdr, TuiOS) sitzen zwischen deinem Terminal-Emulator und der Shell: Terminal-App → Multiplexer-Server → PTY → Shell/Agent. Weil der Multiplexer in jedem Terminal-Fenster läuft, muss er seine eigene interne virtuelle Terminal-Zustandsmaschine pflegen, jede ANSI-Escape-Sequenz vom Programm parsen und dann Diffs an dein äußeres Terminal re-emittieren.

   • Der Vorteil: funktioniert über schlichtes SSH auf einem headless $4/Monat-Linux-VPS, funktioniert in Kitty, Ghostty, WezTerm, Alacritty oder einem iPhone-SSH-Client und überlebt den Wechsel von Terminal-Apps.
   • Der Nachteil: jedes Byte wird zweimal geparst. Wenn der interne Parser des Multiplexers langsamer ist als dein GPU-Terminal oder eine neuere Escape-Sequenz nicht versteht (wie Kitty Graphics, bevor Passthrough landete), wird der Multiplexer zum Bottleneck.

2. Terminal-als-Multiplexer-Apps (Rex, Tern, Muxy) eliminieren die Middleman-TUI. Ein Hintergrund-Daemon besitzt die PTYs (lokal oder auf einem Remote-Server), und die Desktop-, Browser- oder Mobile-App ist ein nativer Client, der direkt an diesen Daemon attacht.

   • Der Vorteil: null Doppelparsing, natives GPU-Rendering (libghostty in Rex und Muxy, Rust + WebGPU in Tern), unabhängiges Scrollback pro attached Client und Panes, die gar keine Text-Raster sein müssen.
   • Der Nachteil: du musst ihre Terminal-App (oder ihren Web-/Mobile-Client) nutzen, statt den Multiplexer in dem Terminal-Emulator zu fahren, den du schon hast. Muxy ist die Ausnahme: Es liefert auch eine muxy-Terminal-UI, die an denselben Server aus jedem Terminal attacht.

1. tmux: der Amtsinhaber

tmux 3.x mit einem Drei-Pane-Layout: git log links, htop oben rechts und eine Dateiliste unten rechts, mit der grünen Statusbar

tmux (~49k Stars, C, ISC) ist ein ~1,2-MB-Binary, das auf jedem Server, auf den du dich je einloggst, entweder vorinstalliert ist oder ein apt install tmux entfernt. Ein Hintergrund-Server besitzt deine Sessions, Windows agieren als Tabs, Panes sind Splits innerhalb von Windows, und der Ctrl+b-Prefix ist seit 18 Jahren konsistent geblieben.

Was in tmux 3.7 und 3.8 landete

tmux ist konservativ, nicht tot. Zwei aktuelle Releases modernisierten mehrere raue Kanten:

• Floating Panes (3.7, vervollständigt in 3.8): Ctrl+b * öffnet einen Overlay-Floating-Pane über deinem aktuellen Fenster, ohne dein Split-Layout zu stören, mit Move/Resize-Bindings unter Ctrl+b g.
• Eingebauter Fuzzy-Switcher (3.8): Ctrl+b Tab öffnet einen Fuzzy-Finder über Sessions und Fenster und ersetzt das externe fzf-Popup-Skript nur zum Session-Wechseln.
• Eingebaute Light/Dark-Themes (3.8): tmux erkennt jetzt den Hintergrund deines Terminals und wendet out of the box eine eingebaute Theme-Option an.
• Modus-spezifische Hilfe und Zeilennummern: Ctrl+h im Copy Mode zeigt nur Copy-Mode-Bindings, und set -g copy-mode-line-numbers on fügt Zeilennummern für schnellere Selection-Sprünge hinzu.

Installation und Tagesworkflow

# Debian / Ubuntu
sudo apt update && sudo apt install -y tmux

# RHEL / AlmaLinux / Rocky / Fedora
sudo dnf install -y tmux

brew install tmux
tmux -V   # prints tmux 3.8

# Enable mouse clicks, pane resizing, and wheel scroll
set -g mouse on

# Start window and pane numbering at 1 instead of 0
set -g base-index 1
setw -g pane-base-index 1
set -g renumber-windows on

# 24-bit true color and image passthrough (Kitty/Sixel)
set -g default-terminal "tmux-256color"
set -as terminal-features ",*:RGB"
set -g allow-passthrough on

# Larger scrollback for build and agent logs
set -g history-limit 50000

Der eine Befehl, der sich auf jedem Server als Alias lohnt, ist attach-or-create:

tmux new -A -s dev

Wenn die dev-Session schon existiert, attacht tmux new -A -s dev sie; wenn nicht, erstellt es sie. Kombiniere es mit tmux -CC attach -t dev auf macOS, wenn du iTerm2 nutzt und Remote-tmux-Fenster als native macOS-Tabs gerendert willst.

Wo tmux 2026 wehtut

Für tmux sind Claude Code, das auf eine destruktive Bash-Freigabe wartet, und tail -f /var/log/syslog identisch: Bytes in einem Pane. Es gibt keinen semantischen State, keine Cross-Session-Inbox und keine eingebaute Möglichkeit, Panes von einem Agenten zu orchestrieren, ohne tmux send-keys und tmux capture-pane-Shell-Skripte zusammenzukleben. Reboot-Persistenz erfordert außerdem Drittanbieter-Plugins (tmux-resurrect und tmux-continuum) via TPM, und zwei Clients, die am selben Fenster attacht sind, teilen sich weiterhin eine einzige Scroll-Position, außer du erstellst grouped Sessions.

• Am besten für: unverwaltete Remote-Server, minimale VPS-Setups, Pair Programming über SSH und alle, die eine Config wollen, die in zehn Jahren noch unverändert funktioniert.
• Überspringen, wenn: du auffindbare UI-Controls willst oder fünf KI-Coding-Agenten gleichzeitig beaufsichtigen musst.

Mein tmux-Grundlagen-Guide führt durch Installation, Sessions, Windows, Panes, TPM-Plugins und Troubleshooting von Protokollversions-Mismatches nach Upgrades.

2. Zellij: der freundliche moderne Multiplexer

Zellij 0.45.1 mit drei Panes (git log links, htop oben rechts, Dateiliste unten rechts) plus den charakteristischen Key-Hint-Bars oben und unten im Bildschirm

Zellij (~35.7k Stars, Rust, MIT) ist, wie ein klassischer Terminal-Multiplexer aussieht, wenn er von Grund auf in Rust designed wurde. Statt jeden Befehl hinter einer unsichtbaren Prefix-Taste zu verstecken, rendert Zellij eine kontextuelle Key-Hint-Bar, die exakt die Tasten zeigt, die in deinem aktuellen Modus verfügbar sind (NORMAL, PANE, TAB, RESIZE, MOVE, SEARCH, SESSION oder LOCK). Du kannst Zellij einem Entwickler in die Hand geben, der nie einen Multiplexer benutzt hat, und er splitet, floatet und stackt Panes innerhalb von zwei Minuten.

Was Zellij 0.45.1 hervorhebt

• First-Class-Nested-Sessions (0.45 / 0.45.1): Zellij lokal zu fahren und dich per SSH auf einen Remote-Server zu verbinden, der auch Zellij fährt, war früher ein Keybinding-Albtraum. In 0.45.1 unterscheiden Nested Sessions innere und äußere Statusbars und Keybindings automatisch über SSH, ohne manuelles Environment-Variable-Forwarding.
• Nach Command scrollen: Statt zeilenweise durch 10.000 Zeilen Compiler-Output zu scrollen, kannst du direkt zwischen Shell-Command-Blöcken springen.
• Reproduzierbare KDL-Layouts & Session-Resurrection: Layouts leben in sauberen .kdl-Dateien. Wenn eine Maschine rebootet oder eine Session endet, serialisiert Zellij dein Layout und deine Pane-Commands auf Disk; ein Reattach stellt den exakten Workspace wieder her und legt gefährliche Commands hinter ein „Press ENTER to run”-Safety-Gate.
• WebAssembly-Plugin-System: Plugins kompilieren zu wasm32-wasip1, das heißt, du kannst Plugins in Rust, Go, Zig oder C/C++ schreiben und sie in einer Capability-Sandbox-Runtime laufen lassen, statt Shell-Skripten vollen Zugriff auf deinen User-Account zu geben.
• Eingebauter Browser-Client (zellij web): serviert deine Terminal-Sessions über HTTP/HTTPS mit generierten Login-Tokens und Read-Only-Spectator-Tokens – der einzige klassische Multiplexer mit einem First-Party-Webserver im Hauptbinary.

Installation, KDL-Layout und Tagescommands

# macOS or Linux (Homebrew)
brew install zellij

# Rust cargo (any platform)
cargo install --locked zellij

# Quick launch without installing (Linux/macOS)
bash <(curl -L https://zellij.dev/launch)

# Start or reattach
zellij -s work                        # new named session
zellij attach -c work                 # attach if exists, create if not
zellij attach -c monitor -- htop      # start session running htop directly
zellij web                            # start built-in browser server

layout {
    default_tab_template {
        pane size=1 borderless=true {
            plugin location="zellij:tab-bar"
        }
        children
        pane size=2 borderless=true {
            plugin location="zellij:status-bar"
        }
    }
    tab name="code" focus=true {
        pane split_direction="vertical" {
            pane name="editor" size="60%" command="nvim"
            pane split_direction="horizontal" size="40%" {
                pane name="agent" command="claude"
                pane name="tests"
            }
        }
    }
}

Starte das Layout überall mit zellij --layout dev (oder zellij -n dev, um eine frische Session zu erzwingen).

Wo Zellij zu kurz kommt

Zellij hat denselben blinden Fleck wie tmux bei KI-Agenten: Ein Pane, auf dem Claude Code oder Codex läuft, ist nur ein ANSI-Text-Buffer. Du kannst Panes mit zellij action und zellij run scripten, und Community-WASM-Plugins beginnen mit Agent-Helpers zu experimentieren, aber es gibt keinen eingebauten Agent-State-Detektor oder Approval-Inbox.

• Am besten für: Entwickler, die einen Batteries-included-tmux-Ersatz mit Floating/Stacked Panes, KDL-Projekt-Layouts und einem eingebauten Web-Client wollen.
• Überspringen, wenn: du Zero-Config-KI-Agent-State-Tracking über lokale und Remote-Hosts brauchst.

3. Herdr: die KI-Agent-Control-Plane

Herdr 0.9 mit der Spaces-Sidebar links, die die Session- und Agent-Gruppen auflistet, und drei Panes mit git log, htop und einer Dateiliste

Herdr (~44k Stars, Rust, Apache-2.0) war der erste Multiplexer, der spezifisch um das Multi-Agent-Bottleneck gebaut wurde: Wenn du acht Coding-Agenten über drei Repositories verteilt laufen hast – welcher hängt gerade wartend auf deine Eingabe?

Herdr läuft in deinem bestehenden Terminal-Emulator als einzelnes ~11-MB-Rust-Binary (herdr). Ein Hintergrund-Session-Server besitzt die PTYs, damit Sessions SSH-Abbrüche und Laptop-Sleep überleben wie bei tmux, während die TUI eine linke Spaces-&-Agents-Sidebar ergänzt, die Echtzeit-Semantic-States für jeden Pane aufrollt: working, blocked, done, idle oder unknown.

Wie Herdr Agenten erkennt und orchestriert

Herdr kombiniert out of the box zwei Erkennungsebenen für 14+ Coding-Agenten (Claude Code, Codex, Copilot CLI, Cursor Agent, OpenCode, Gemini CLI, Pi, Amp, Droid, Grok CLI, Hermes Agent, Antigravity CLI, Kimi Code und QoderCLI):

1. Zero-Config-TOML-Screen-Manifeste: Herdr inspiziert den Child-Prozess-Baum und matcht den Live-Bottom-Buffer jedes Panes gegen Per-Agent-Screen-Regeln, um Spinner, Permission-Prompts und Idle-Prompts zu erkennen, ohne die Agent-Config anzufassen.
2. Lifecycle-Hooks (herdr integration): Die Installation der optionalen Integration verdrahtet das native Hook-System des Agenten (wie Claude Codes SessionStart-, PreToolUse- und Stop-Hooks) für exaktes, latenzfreies State-Reporting.

Unter der TUI sitzt eine JSON-Unix-Socket-API (~/.config/herdr/herdr.sock) und CLI, die es einem Lead-Agenten erlaubt, Worker-Panes zu spawnen, Prompts zu übergeben, Sibling-Terminal-Output zu lesen und zu blockieren, bis ein Worker done oder blocked erreicht:

# Install Herdr on Linux or macOS
curl -fsSL https://herdr.dev/install.sh | sh    # or: brew install herdr

# Optional: install exact lifecycle hooks
herdr integration install claude
herdr integration install codex
herdr integration install copilot

# Orchestrate panes and agents from scripts or a lead agent
herdr pane list                                 # JSON list of panes and states
herdr pane split --direction right --focus      # split current pane
herdr agent start reviewer --kind claude        # launch tracked agent in pane
herdr pane run <pane-id> "cargo test"           # run command in target pane

Multi-Machine-Windows und das Client-Ökosystem

Seit v0.9 unterstützt Herdr Multi-Machine-Windows: herdr machine add user@vps oder herdr --remote user@vps lässt dich lokale Panes und Remote-VPS-Sessions in einer einzigen Sidebar sehen, plus eingebautes git-worktree-Management und automatisches Agent-Conversation-Resume nach einem Host-Neustart.

Weil Herdr jede UI nur als Client an seinem Socket behandelt, ist ein ganzes Drittanbieter-Ökosystem darum gewachsen:

• Mobile Kontrolle: Moshi (iOS/Android mit Mosh-Transport und moshi-hook-Lock-Screen-Push-Freigaben) und Heeler.
• Browser- & Desktop-Clients: ColliePWA, devswha/herdr-web-ui, herdrm (natives macOS), Herdr UI und Moshi Desktop.
• Plugin-Marktplatz: ~1.000 indexierte Plugins (herdr-plugin.toml), allerdings laufen Plugins unsandboxed als dein OS-User – installiere Marktplatz-Plugins also nie, ohne vorher ihren Source zu lesen.

Lies unser volles Herdr-Review, den Herdr-Clients-Vergleich und den Guide zu den besten Herdr-Plugins für gehärtete VPS- und Tailscale-Setups.

• Am besten für: 3 bis 15 KI-Coding-Agenten über lokale Maschinen und headless VPS-Boxen fahren, mit Lock-Screen-Handy-Freigaben und einem bewährten Ökosystem.
• Überspringen, wenn: du Floating Panes oder Tiling-Window-Manager-Layouts willst (Herdrs Layout-Modell ist strikt Splits, Tabs, Spaces und Zoom).

4. TuiOS: der Tiling-Window-Manager + tiefste Agent-Inbox

TuiOS 0.11.1 mit drei getilten Fenstern (git log links, htop oben rechts, Dateiliste unten rechts) plus der Dock-Bar oben und dem Session-Rail rechts, der Sessions, Terminals und Dateien auflistet

TuiOS (~5.4k Stars, Go, MIT) steht für Terminal UI Operating System und ist der kühnste neue In-Terminal-Multiplexer des Jahres. Gebaut auf Charms Bubble Tea v2 und Lipgloss v2 mit einem Hintergrund-Daemon, kombiniert es zwei Ideen, die normalerweise in getrennten Tools leben: einen Desktop-artigen Tiling-Window-Manager (BSP-, Master-Stack- und niri-artige Scrolling-Layouts, Floating Windows, Picture-in-Picture, 9 Workspaces pro Session, Top/Bottom-Dock-Bar mit Live-CPU/RAM-Graphen und ein rechtes Session-/Datei-/Agent-Rail) und eine Agent-Orchestrierungs-Engine, die sogar tiefer geht als Herdrs.

Die Inbox, Prompt-Holds und Worktree-Fan-out

Wo Herdr dir eine Status-Sidebar gibt, baut TuiOS den gesamten Human-in-the-Loop-Workflow in seinen Daemon:

1. Die Unified Inbox (Ctrl+b i oder tuios list-attention): sammelt jede blockierte Freigabe, Frage (tuios ask-human), Plan-Review (ExitPlanMode), Fehler und ungelesenen fertigen Turn über jede Session auf deiner Maschine und verlinkten Remote-Hosts.
   • Wenn du [agents.approvals] aktivierst, fängt TuiOS einzeilige Permission-Requests ab (PermissionRequest in Claude Code/Qwen, permission.asked in OpenCode/Kilo) und hält sie in der Inbox. Drück 1 (einmal erlauben), 2 (immer) oder 3 (ablehnen) direkt aus der Inbox, ohne Workspaces zu wechseln.
   • Commands, die Risk Rules matchen (rm -rf, Force-Pushes, curl | sh oder Schreibzugriffe außerhalb des Projekt-Roots des Panes), werden mit einem risk-Badge markiert und erfordern eine zweite Bestätigung.
2. Queued Replies und verifizierte Human-Mail: Wenn ein Agent mitten im Turn beschäftigt ist, hält tuios queue -w worker "run the migration tests next" deinen Prompt fest und tippt ihn automatisch, sobald der Agent zur Ruhe kommt. Agenten können sich auch gegenseitig strukturierte Mail schicken (tuios send-agent-message, tuios ask-agent) oder an human, mit kryptografischem "verified_human": true-Tagging, damit ein Agent einem anderen Pane keine Human-Freigabe vortäuschen kann.
3. Git-Worktree-Fan-out, Verifikation und Inline-Diff-Review: Du kannst mehrere Agenten (sogar über verschiedene Modelle) auf dieselbe Aufgabe in isolierten git worktrees rasen lassen, eine Test-Suite über alle laufen lassen, ihre Diffs mit Zeilennotizen reviewen und den Gewinner shippen:

# Install TuiOS (macOS / Linux)
brew install tuios
# or release script:
curl -fsSL https://raw.githubusercontent.com/Gaurav-Gosain/tuios/main/install.sh | bash

# Fan a prompt across 3 isolated git worktrees using Claude, Codex, and Gemini
tuios fan 3 --agent 'claude,codex --model o5,gemini' 'Add exponential backoff to the HTTP client.'

# Compare line changes and run your test suite across every attempt
tuios fan compare api-fan-add-exponential-backoff
tuios fan verify api-fan-add-exponential-backoff -- go test ./...

# Review an attempt's diff, attach line notes, and send them back to the agent
tuios review api-fan-add-exponential-backoff-2
tuios review note -s api-fan-add-exponential-backoff-2 client/retry.go:42 'log the attempt count here'
tuios review send -s api-fan-add-exponential-backoff-2

# Keep the winning worktree, squash-merge, or open a PR
tuios fan keep api-fan-add-exponential-backoff-2 --merge --squash

Herdr-Socket-Kompatibilität, MCP-Server und der tmux-Shim

Die klügste Engineering-Entscheidung in TuiOS ist, dass es sich weigert, sich von bestehenden Ökosystemen abzuschotten:

• Herdr-Socket- & Plugin-Bridge: Jeder TuiOS-Pane exportiert HERDR_SOCKET_PATH, HERDR_PANE_ID und HERDR_BIN_PATH. TuiOS beantwortet 77 von Herdrs 102 Socket-Methoden nativ und führt aktivierte Herdr-Plugins (terminal-browser, herdr-nvim, herdr-sidebar) hinter einem expliziten Per-Pane-Capability-Grant-System (read, write, respond, fan, admin) aus.
• Der tmux-Shim (tuios tmux-shim): Tools, die tmux-Calls hardcoden (am bekanntesten Claude Codes experimentelle Agent-Teams mit CLAUDE_CODE_EXPERIMENTAL_AGENT_TEAMS=1 und fzf --tmux), funktionieren in TuiOS, ohne tmux zu installieren:

  tuios tmux-shim -- env CLAUDE_CODE_EXPERIMENTAL_AGENT_TEAMS=1 claude

  Jeder gespawnte Teammate öffnet sich als natives TuiOS-Fenster mit eigenem Status auf dem Rail und in der Inbox.
• Nativer MCP-Server (tuios mcp) und headless ACP: tuios mcp exponiert TuiOS über Stdio an jeden MCP-fähigen Agenten, und tuios start-agent --protocol acp 'opencode acp' kann Agenten headless über das Agent Client Protocol fahren.
• Remote-Panes & Mobile: enthält einen eingebauten SSH-Server (tuios ssh --port 2222), Remote-Windows auf einem anderen Host, die in deiner lokalen Session gerendert werden (tuios new-window -s work deploy --host build), SHA-256-verifizierte Cross-Host-Dateikopien (tuios cp), tuios-web, QR-Phone-Pairing (tuios pair) und ntfy/Pushover-Inbox-Push-Benachrichtigungen.

Wo TuiOS wehtut

Alter und Oberfläche. Der erste Commit landete im September 2025, und bei v0.11.1 hat es eine massive Command-Oberfläche (tuios --help listet über 90 Subcommands). Es shipped schnell, was gelegentliche Breaking Changes zwischen Minor-Releases und eine steilere Lernkurve bedeutet, wenn du jedes Feature auf einmal anmachst. (Du kannst [agents] enabled = false in ~/.config/tuios/config.toml setzen, wenn du nur den Tiling-Multiplexer willst.)

• Am besten für: Power-User, die i3/Hyprland-artiges Terminal-Tiling, Multi-Agent-Worktree-Fan-out und eine Inbox wollen, die Prompt-Freigaben und Diff-Reviews nativ handhabt.
• Überspringen, wenn: du ein minimales, langsam bewegliches Tool mit kleiner CLI-Oberfläche willst.

5. Rex: das Terminal, das der Multiplexer ist

Die Rex-macOS-App mit Session-Tabs oben und gesplitteten Panes mit einem Code-Review, einem git diff und einem Spiel

Rex ist Mitchell Hashimotos (HashiCorp, Ghostty) Antwort auf ein Problem, auf das er beim Bauen von Ghostty stieß: Moderne GPU-Terminals wie Ghostty, Kitty und Alacritty können Terminal-I/O bis zu 100x schneller parsen als die internen Terminal-Emulatoren in tmux oder screen. Einen traditionellen Multiplexer vor ein schnelles Terminal zu setzen, bremst die ganze Pipeline auf den Parser des Multiplexers aus.

Also dreht Rex die Architektur um. Du fährst rex nicht in einem anderen Terminal; Rex ist die Terminal-Anwendung.

Wie Rex’ Raw-Byte-Streaming funktioniert

1. Der Server besitzt die PTYs. Wenn ein Rex-Client sich verbindet, pausiert der Server kurz die PTY-Verarbeitung, sendet einen kompakten binären Handshake-Frame (Dimensionen, Cursor, aktueller Screen-State) und entsperrt sofort die Eingabe.
2. Rohe PTY-Bytes, keine Screen-Diffs. Statt Output in ein geteiltes virtuelles Grid zu parsen und Screen-Diffs zu senden, teet der Rex-Server rohe PTY-Byte-Streams an jeden attached Client, genau wie SSH. Jeder Client führt seine eigene eingebettete libghostty-Engine aus und parst mit nativer Geschwindigkeit.
3. Unabhängiges Client-Scrollback. History backfillt im Hintergrund (neueste Chunks zuerst), und weil jeder Client seinen eigenen Viewport besitzt, können zwei Leute, die an derselben Session attacht sind, unabhängig hochscrollen und Logs inspizieren, ohne sich gegenseitig den Screen zu entreißen.

First-Class-Remote-Logins und Lua-Automation

Eine Remote-Maschine aus Rex’ Command Palette hinzuzufügen öffnet nicht nur eine SSH-Pipe in einem lokalen Pane; es führt einen echten OS-Login auf dem Remote-Rex-Server durch (die Session erscheint in who, lädt deine Login-Shell, honoriert PAM/User-Limits und authentifiziert über deine bestehenden SSH-Keys oder Tailscale-Identität, inspizierbar via rex whoami) mit Mosh-inspirierter Responsiveness.

Jedes Rex-Terminal bekommt automatisch rex auf PATH plus REX_SESSION-, REX_BLOCK- und REX_SERVER-Environment-Variablen:

rex ls                              # list sessions (supports --json)
rex session inspect                 # inspect current session details
rex split                           # split current block
rex send -s build -w 2 'make test'  # send command to window 2 of "build"
rex capture -b logs                 # print current screen of block "logs"
rex -S studio ls                    # list sessions on remote host "studio"

-- Keybindings (supports tmux-style prefix chords too)
rex.bind("cmd+d", "pane.split", { direction = "right" })
rex.bind("ctrl+b>c", "window.new")

-- Custom typed action runnable from palette, keybind, or `rex do`
rex.action{
  name  = "scratch",
  title = "Open Scratch Window",
  run   = function(ctx, args)
    rex.session.new_window{
      layout = rex.layout.block{
        flavor = "com.superlogical.terminal.shell",
      },
    }
  end,
}
rex.bind("shift+cmd+n", "scratch")

Wo Rex wehtut

Erstens Plattform-Reichweite: Nur der macOS-Client ist gerade im öffentlichen Test (Linux-, Windows-, iOS- und Browser-Clients existieren intern bei Superlogical, sind aber noch nicht an externe Tester gegangen). Zweitens Layout-Modell: Weil jeder Split eine unabhängige PTY-Verbindung ist, die in einem nativen Container gerendert wird (so wird Rex sich sauber auf iOS und Web anpassen), gibt es keinen verschachtelten In-Window-tmux-Pane-Baum. Drittens ist Rex Closed Source, wenngleich Superlogical verspricht, dass der Rex-Client und -Server „kostenlos ist und immer sein wird”, keinen Account erfordert und vollständig self-hostbar ist.

Wenn du auf macOS bist und ein libghostty-basiertes Terminal mit einer Automations-CLI willst, die schon ohne Warteliste allgemein verfügbar ist, schau dir cmux an. Für den vollen Deep Dive in Rex’ Datenpfad und Exit-Codes, lies mein Superlogical-Rex-Briefing.

• Am besten für: macOS-Entwickler, die native libghostty-Geschwindigkeit, persistente lokale/Remote-Sessions und Lua/CLI-Scriptbarkeit ohne TUI-Wrapper wollen.
• Überspringen, wenn: du heute Linux- oder Windows-Desktop-Clients brauchst oder eingebaute KI-Agent-State-Überwachung willst.

6. Tern: das Terminal, das deinen ganzen Workflow will

Terns Workspace: Ein git-bewusster Files-Pane verfolgt das Projekt links neben einer Shell mit git log

Tern (gebaut von Stencil, dem Team hinter der omp-Coding-Agent-CLI) startet mit derselben Prämisse wie Rex (ein Hintergrund-Daemon tern daemon besitzt persistente Sessions, während Fenster wegwerfbare Ansichten sind) und schiebt sie in volles Workspace-Territorium. Sich selbst „ein Neoterminal für Electron-Müde” nennend, ist Tern eine native Rust-Anwendung (~150 ms Kaltstart bis zum bereiten Prompt), in der eine Terminal-Shell nur eine Art von Block ist.

Native Blöcke über das Tern Surface Protocol

Statt Chromium einzubetten, rendert Tern strukturierte Tools nativ über sein Tern Surface Protocol direkt neben deinen Shell-Splits (oder herausgelöst als Always-on-Top-Picture-in-Picture-Fenster):

• Git-Block (⌥⌘G): Commit-Graph mit Branch-/Tag-Lanes, staged/unstaged Working Tree mit Line-Staging und Context-Folding, git peek, Stashes/Worktrees/Submodules-Ansicht und KI-Commit-Message-Generierung.
• SQLite-Datenbank-Block: Schema-Browser, filterbares Daten-Grid mit Inline-Zell-Editoren (Text, JSON, Hex, Bild), SQL-Query-Tabs mit Completion und Ergebnis-Plotting sowie gestaged „Write Changes” / Revert.
• Kanban-Board-Block (⌥⌘K): verwandelt eine schlichte TODO.md-Datei in deinem Repo in ein Drag-and-Drop-Todo/Doing/Done-Board, das sowohl du als auch deine KI-Coding-Agenten lesen und aktualisieren können.
• Jupyter-Notebook-Block: führt Code- und Markdown-Zellen direkt gegen deinen lokalen Python-Kernel mit einem Variablen-Inspektor aus – kein Jupyter-Server nötig.
• Files-, Editor- & Media-Block (⌘O / tern open): Syntax-highlighted Code-Editor mit git-Gutter-Diffs, gerendertem Markdown-Toggle, SVG/PDF/Image-Viewern und Video-Frame-Strip-Previews (EDITOR='tern open --wait' funktioniert für git commit).
• Browser- (⇧⌘B), Task-Manager- und Canvas-Blöcke: ein inspizierbarer Browser-Block, den Agenten steuern und snapshotten können, ein CPU/RAM/GPU-Prozessbaum und eine freie Zeichen-Canvas.

Native omp-Agent-Blöcke, QUIC-Remoting und CLI-Kontrolle

Weil Stencil omp baut, rendert das Starten eines Agent-Blocks eine native UI mit Model-Picker, Thinking-Toggle, Subagent-Task-Tree und einer 1M-Token-Kontext-Budget-Aufschlüsselung (System-Prompt, Tools, Skills, Messages), während Completion-Alerts und Bell-Events in Terns „Needs attention”-Inbox geroutet werden. Standard-CLI-Agenten (Claude Code, Codex, Devin) laufen in normalen Terminal-Panes, und ein Community-Luau-Plugin für Herdr lässt dich Herdr-Panes in Tern einbetten.

# Tern workspace & automation CLI
tern ls                              # list sessions, tabs, and panes
tern new | split | move | pip | dock # manipulate window layout from scripts
tern run 'make test'                 # execute command in a pane
tern send / capture / wait           # type into, read back, or block on panes
tern events --filter pane_spawned    # stream live daemon events
tern whoami --json                   # inspect user + host identity chain

# Remote hosts, browser client, and headless screenshot harness
tern remote serve                    # expose session daemon over QUIC
tern web serve                       # serve Wasm + WebGPU client in a browser tab
tern shot scenario.kdl               # render offscreen UI captures

Anders als Rex shipped Tern bereits Builds für macOS, Linux, Windows und Android (per QR-Code aus der Hosts-Palette gekoppelt, iOS als Nächstes), plus einen WebAssembly-+-WebGPU-Browser-Client (tern web serve).

Wo Tern wehtut

Tern ist Closed Source, aktuell in geschlossener Beta hinter einer Warteliste (meine hat sich in etwa zwei Tagen geklärt), und Stencil hat noch keine finalen Preise oder kommerziellen Tiers angekündigt. Für eine volle Tour durch jeden Block, siehe mein Tern-Terminal-Praxisreview.

• Am besten für: Entwickler, die Daemon-persistente Sessions, QUIC-Remote-Hosts und native Git/SQLite/Kanban/Notebook-Panes ohne Electron-Overhead wollen.
• Überspringen, wenn: du nur Open-Source-Terminal-Tools adoptierst oder ein leichtes Unix-Utility willst, das eine Sache tut.

7. Muxy: die Open-Source-Terminal-App, die deine Agenten beobachtet

Die Muxy-macOS-App mit der Projekt-Sidebar, die Projekte und git worktrees listet, einer Claude-Code-Session im Haupt-Pane und dem Source-Control-Panel, das 80 geänderte Dateien rechts reviewt

Muxy (~2.3k Stars, Rust + GPUI, MIT) ist der neueste Eintrag im Terminal-als-Multiplexer-Lager und der einzige Open-Source. Wie Rex rendert es Panes über libghostty; wie Tern besitzt ein Hintergrund-Server (muxy-server) die PTYs, damit Sessions das Schließen des Fensters, das Beenden der App oder einen SSH-Abbruch überleben. Was es abhebt, ist, dass es die beste Idee der Agent-Multiplexer borgt: Muxy erkennt ein Dutzend Coding-Agenten (Claude Code, Codex, Copilot, Cursor, OpenCode, Antigravity, Pi und mehr) aus der Prozessliste und dem, was auf dem Screen ist, und markiert jeden als working, waiting oder idle – ohne Hooks oder Per-Agent-Config.

Projekte, Worktrees und Remote-Server in einer Sidebar

Alles in Muxy hängt an der Projekt-Sidebar: Jedes Projekt bekommt einen Eintrag, seine eigenen git worktrees (in der App erstellt oder aus welchen übernommen, die du schon gemacht hast) und seinen eigenen Baum von Splits und Tabs. Ein Agents-Panel (Cmd+Opt+A) rollt jeden Agenten als „needs input”, „working”, „completed” oder „idle” auf, und die App sendet eine macOS-Benachrichtigung, wenn einer Aufmerksamkeit braucht; ein Klick springt direkt zum Pane. Remote-Maschinen gesellen sich in dieselbe Sidebar. Muxy spricht über SSH mit einem muxy-server auf dem anderen Host (es bietet an, ihn für dich zu installieren), und Remote-Terminals laufen nach dem Disconnect weiter, exakt wie lokale.

Composer, Extensions und eine echte CLI

• Composer (Rich Input): lange Prompts mit angehängten Dateien und Bildern entwerfen, dann an den aktiven Pane senden oder an jeden Split in einem Tab broadcasten. Drafts speichern pro Projekt.
• Extension Store und API: Ein dokumentiertes Manifest und eine API (Panels, Bar-Items, Commands, agent.status-Events) treiben das eingebaute Git-Source-Control-Panel, den File-Tree und den Editor an. Jeder kann Extensions veröffentlichen.
• muxy-CLI und eine TUI: muxy und muxy-server installieren ohne die Desktop-App, was Muxy zum einzigen Tool hier macht, das in beiden Lagern funktioniert. muxy auf einer headless Box auszuführen öffnet eine Terminal-UI, die an denselben Server attacht, und muxy --host devbox oder muxy activity list --json steuert Remote-Server und Agent-States aus Skripten.
• Mobile Companions: Die iOS- und Android-Apps verbinden sich mit deinem eigenen muxy-server über LAN oder VPN, um Agenten zu beobachten und ihre Prompts zu beantworten. Sessions berühren nie eine Third-Party-Cloud.

# macOS desktop app
brew install --cask muxy-app/tap/muxy

# Headless CLI + server (what a remote host needs)
brew install muxy-app/tap/muxy-cli
muxy --host devbox              # drive a remote muxy-server over SSH
muxy activity list --json       # agent states and unread alerts

Wo Muxy wehtut

Reichweite und Tiefe. Der polierte Client ist die macOS-App (macOS 14+); Linux-Builds sind experimentell (Ubuntu 24.04 mit Vulkan und WebKitGTK), und es gibt gar keinen Windows-Client. Agent-Support ist Erkennung plus Benachrichtigungen: Es gibt keine Approval-haltende Inbox wie die von TuiOS, keine Risk Rules und keine Lock-Screen-Approve/Deny wie bei Herdr + Moshi. Der Extension Store ist jung, und die ~2.3k Stars zeigen, wie neu die 2.x-Linie ist.

• Am besten für: macOS-Entwickler, die ein Open-Source-libghostty-Terminal mit persistenten lokalen und Remote-Sessions, Projekt-Worktrees, Agent-State-Benachrichtigungen und nativen iOS/Android-Companions wollen.
• Überspringen, wenn: du auf Windows oder Nicht-Ubuntu-Linux bist oder Approval-Queues und Guardrails statt Alerts willst.

KI-Coding-Agent-Orchestrierung im Vergleich

Weil KI-Coding-Agenten der Hauptgrund sind, warum Entwickler 2026 ihren Multiplexer überdenken, hier der Vergleich der sieben Tools speziell bei Agent-Workflows:

Keybinding- und Vokabular-Spickzettel

Der Wechsel zwischen diesen sieben Tools wird viel leichter, sobald du siehst, wie ihre Nomen und Default-Shortcuts einander zugeordnet sind:

Remote-SSH, Handys und Browser im Vergleich

• Am besten für Server, die dir nicht gehören: tmux, und nichts anderes kommt heran. Es ist schon auf fast jedem Kundenserver, Container-Host und jeder BSD-Box installiert.
• Bestes Next-Gen-Remote-Protokoll: Rex (echter System-Login mit Mosh-artiger Responsiveness) und Tern (tern remote serve über QUIC zu Desktop-, WebGPU-Browser- und Android-Clients). TuiOS nimmt den dritten Platz mit seiner Fähigkeit, einen einzelnen Remote-Pane von einem anderen Host direkt in deinen lokalen Workspace zu mounten (tuios new-window --host build). Muxy verdient hier auch eine Erwähnung: SSH zu einem Remote-muxy-server ist das am wenigsten exotische Setup in dieser Gruppe, und die App kann die Serverseite für dich installieren.
• Bestes Handy-Erlebnis heute: Herdr gepaart mit Moshi (Mosh-UDP-Transport + moshi-hook-Lock-Screen-Approve/Deny-Buttons) oder Heeler, mit TuiOS (tuios pair-QR-Code + ntfy/Pushover-Inbox-Push-Benachrichtigungen), Tern (Android-Client) und Muxy (native iOS/Android-Apps, die mit deinem eigenen muxy-server sprechen) direkt dahinter.
• Bestes Browser-Erlebnis: Zellij (zellij web mit eingebauter Auth und Read-only-Tokens) und Tern (tern web serve WebGPU-Client). tuios-web und Herdrs Community-Web-UIs (ColliePWA, herdr-web-ui) sind super über Tailscale. Muxy hat keinen Browser-Client.

Welchen Terminal-Multiplexer solltest du wirklich wählen?

Realwelt-Kombinationen (und die eine Nesting-Regel)

Du musst dich nicht für nur eins entscheiden. Mein eigener Tages-Stack nutzt drei:

1. tmux auf Produktionsservern, die ich einmal im Monat anfasse.
2. Herdr + Moshi auf einem Always-on-Hetzner-VPS, auf dem langlebige Claude-Code- und Codex-Sessions leben.
3. TuiOS (oder Herdr in Tern), wenn ich Worktree-Fan-out (tuios fan) oder native Git/SQLite-Blöcke auf meiner Workstation will.

Nesting funktioniert gut, solange du eine Regel befolgst: Halte eine einzige Multiplexer-Schicht direkt über deinen KI-Coding-Agenten. Herdr in einem Tern-Pane zu fahren funktioniert, weil Tern das äußere Fenster rendert, während Herdr die Agent-PTYs direkt besitzt. tmux zwischen Herdr/TuiOS und deinem Coding-Agenten zu legen, bricht die automatische Prozessbaum-Erkennung (der äußere Multiplexer sieht tmux, nicht claude oder codex). Wenn ein Tool versucht, tmux-Panes unter dir zu spawnen, fahr es stattdessen unter tuios tmux-shim, statt einen echten tmux-Server zu nesten.

FAQ

Fazit

Es gibt hier keinen einzelnen Gewinner, weil sich die Kategorie in drei getrennte Jobs aufgespalten hat:

1. Klassisches Shell-Multiplexing: tmux bleibt unantastbar auf Remote-Servern, die dir nicht gehören, und Zellij ist das beste moderne Upgrade, wenn du KDL-Layouts, Floating Panes, Nested SSH Sessions und On-Screen-Key-Hints willst, ohne ein Wochenende an einer Config-Datei zu verbringen.
2. KI-Agent-Multiplexing: Herdr ist heute der sicherste Pick, um eine Flotte von Coding-Agenten über lokale und Remote-Maschinen zu beaufsichtigen, während TuiOS der ehrgeizigste Herausforderer ist mit seinem Tiling-Window-Manager, der Unified Inbox, Inline-Diff-Review, Worktree-Fan-out und Herdr/tmux-Kompatibilitäts-Shims.
3. Next-Gen-Terminal-Apps: Rex, Tern und Muxy beweisen, dass das Einbacken von Session-Persistenz und Remoting ins Terminal selbst schneller und sauberer ist als eine TUI in einer TUI zu fahren: Rex für libghostty-Puristen auf macOS, Tern für Entwickler, die Git, SQLite, Kanban und Notebooks direkt neben ihrem Prompt wollen, und Muxy für dieselbe Architektur als Open Source (MIT) mit eingebauter Agent-State-Erkennung und iOS/Android-Companions.

Wenn dein Terminal-Tag hauptsächlich aus Shells und Logs besteht, installiere tmux oder Zellij und geh zurück an die Arbeit. Wenn die Hälfte deiner Panes KI-Coding-Agenten sind, wechsle zu einem Multiplexer, der weiß, dass sie drin sind.