# RMUX

> A universal Rust terminal multiplexer with a tmux-compatible CLI, daemon-backed SDK, and native Ratatui integration — built for agentic and headless terminal automation.

RMUX is an open-source terminal multiplexer written entirely in Rust, developed by Helvesec and published under a dual MIT/Apache-2.0 license. It targets both human terminal users and AI agents that need to drive CLI or TUI applications programmatically, offering persistent sessions, structured pane snapshots, and a typed async SDK alongside a tmux-compatible command surface. The project reached its first public preview release (v0.2.0) on 18 May 2026.

## What It Is

RMUX is a terminal session manager and automation engine that replaces or supplements tmux, particularly for workflows where code — rather than a human — is the primary user. It exposes three coordinated surfaces: a `rmux` CLI binary with 90 tmux-compatible commands, a `rmux-sdk` Rust crate for async programmatic control, and a `ratatui-rmux` widget for embedding live pane snapshots inside Ratatui TUI applications. All three surfaces share a single local IPC protocol backed by a persistent daemon process.

## Architecture and Workspace

The project is structured as a multi-crate Rust workspace. Public-facing crates include `rmux-types` (shared value types), `rmux-proto` (IPC DTOs and framing), `rmux-ipc` (local transport endpoints), `rmux-sdk` (the async Rust SDK), `ratatui-rmux` (the Ratatui widget), and the `rmux` CLI binary itself. Internal support crates handle PTY allocation (`rmux-pty`), session/pane/layout management (`rmux-core`), the Tokio daemon (`rmux-server`), and IPC client plumbing (`rmux-client`). The upper-level crates enforce `#![forbid(unsafe_code)]`, with OS and terminal boundary code isolated in lower-level runtime crates.

Platform support spans all three major desktop operating systems:
- **Linux**: Unix PTY backend, Unix socket IPC
- **macOS**: Unix PTY backend, Unix socket IPC
- **Windows**: ConPTY backend, Named Pipe IPC — no WSL required

## Agentic and Automation Workflow

The SDK's async API lets code create sessions, split panes, send keystrokes, wait for specific text output, and capture structured snapshots — a pattern the project compares to Playwright-style automation but for terminal applications. The published demo set includes multi-agent orchestration (Claude directing Codex, Gemini, and Grok through rmux panes), an agent broadcast arena that fans a single prompt out to multiple AI CLIs, terminal-to-browser mirroring, and Playwright-based terminal testing. These demos range from roughly 500 to over 2,000 lines of source code and are available in a companion `rmux-demos` repository.

## tmux Compatibility and Differentiation

RMUX implements the same 90 tmux commands and aims for behavioral parity, so existing tmux muscle memory and scripts transfer with minimal changes. The project's own comparison table highlights key differences: native Windows support without WSL, a typed Rust SDK with async handles, terminal-native locators and structured snapshots (versus tmux's plain-text capture), and streamed output with line events. The trade-off noted is that tmux remains the native choice when keyboard interaction is the primary use case.

## Update: v0.2.0 Public Preview

The current release is **v0.2.0**, published on **18 May 2026**. The GitHub README explicitly notes that all 90 tmux-compatible commands are implemented but that bugs are expected, describing this as a "fresh public preview." The repository was created on 15 May 2026 and had accumulated 423 stars and 10 forks as of the last recorded update on 21 May 2026. Configuration is read from standard locations on all three platforms (`.rmux.conf`, XDG paths, and Windows `%APPDATA%` paths), and release artifacts include SHA256 checksums for verification.

## Features
- tmux-compatible CLI with 90 commands
- Daemon-backed async Rust SDK (rmux-sdk)
- Native Ratatui widget (ratatui-rmux)
- Persistent detachable terminal sessions
- Structured pane snapshots
- Playwright-style terminal automation
- Wait-for-text and line event streaming
- Native Windows support via ConPTY and Named Pipes (no WSL)
- Multi-agent orchestration demos
- Unix socket IPC on Linux/macOS
- Dual MIT/Apache-2.0 license
- Single local IPC protocol shared across CLI, SDK, and widget

## Integrations
Ratatui, Tokio, Cargo/crates.io, Claude, Codex, Gemini, Grok, Playwright

## Platforms
WINDOWS, MACOS, LINUX, API, DEVELOPER_SDK, CLI

## Pricing
Open Source

## Version
0.2.0

## Links
- Website: https://rmux.io
- Documentation: https://rmux.io/docs/
- Repository: https://github.com/Helvesec/rmux
- EveryDev.ai: https://www.everydev.ai/tools/rmux