RMUX: Universal Rust multiplexer for the agentic era

RMUX: Universal Rust multiplexer for the agentic era

A fast, extensible, and inspectable terminal multiplexer designed for long‑lived agents, scriptable workflows, and human workflows alike. RMUX unifies command line ergonomics with a robust Rust foundation, offering a tmux-compatible CLI, a daemon-backed SDK, and a native Ratatui integration. It aims to make terminal automation, orchestration, and inspection feel natural in a world of persistent sessions and agentic tooling.

Introduction: the impetus behind RMUX

RMUX emerges from a simple insight: the traditional tmux workflow has untapped potential when viewed through the lens of modern automation, agents, and persistent sessions. The project was conceived to let you run long‑lived agents over SSH or locally without losing their terminals, while still preserving the ability to inspect, script, and orchestrate everything around those sessions. Built in Rust, RMUX promises blazing speed, strict typing, and a clean separation of concerns among surfaces: a command-line interface, a daemon-backed SDK, and a rich UI widget ecosystem via Ratatui.

What makes RMUX different

• tmux-compatible: RMUX implements all the familiar, tmux-like behaviors you expect, but within a fresh, typed, and scriptable surface. It’s designed to be a drop-in companion for existing tmux users while offering new capabilities that tmux alone can’t deliver.
• Three public surfaces, one protocol: The rmux CLI, the rmux-sdk Rust crate, and the ratatui-rmux widget all talk to the same local daemon using a common protocol. Whatever you can do from the CLI, you can drive from code, and you can render or inspect the same state in a UI.
• Daemon-backed SDK: A persistent, daemon-enabled architecture means you can detach, reconnect, and manage sessions even across network boundaries. This is essential for long-running agents and remote workflows.
• Detachability and inspection: Detach a session, reattach later, and inspect the exact state of panes, layouts, and buffers. This is not just about running commands; it’s about observability and controllability.
• Native UI integration: Ratatui integration brings rich, terminal-native rendering to RMUX workflows, enabling expressive layouts and dashboards that respond to the dynamic state of sessions and panes.
• Cross-platform support: RMUX targets Linux, macOS, and Windows (including Windows Named Pipes), ensuring a consistent experience across environments.

Demos: real-world glimpses of RMUX

RMUX ships with several demonstration stories that illustrate how the tool can orchestrate multiple agents, broadcast tasks, and provide interactive shells or browser mirroring. The demos highlight the power of a single protocol powering multiple surfaces.

• Multi Agents Orchestration

• Preview: a visual depiction of coordinating several agents in a single workspace.

• Demo link: click through to the orchestration demo that showcases how sessions can be created, reused, and combined to run parallel tasks.

• Preview image: Multi Agents Orchestration preview

• Agent Broadcast Arena

• Preview: broadcasting a command or script to a fleet of agents, collecting results, and presenting a unified view.

• Demo link: Agent Broadcast Arena

• Preview image: Agent Broadcast Arena preview

• Mini-Zellij

• Preview: a compact, Zellij-like layout rendered through RMUX’s UI surface.

• Demo link: Mini-Zellij

• Preview image: Mini-Zellij preview

• Terminal Browser Mirroring

• Preview: mirroring a terminal session contents to a browser surface, showcasing RMUX’s ability to bridge terminal and web views.

• Demo link: Terminal browser mirroring

• Preview image: Terminal mirroring preview

• Playwright Testing

• Preview: using Playwright to test terminal-driven interactions within RMUX’s environment.

• Demo link: Playwright Testing

• Preview image: Playwright Testing preview

Install: how to get RMUX running

RMUX ships with a straightforward install path for macOS, Linux, Windows, and Rust-based usage for developers.

• Prebuilt binaries

• macOS and Linux: curl -fsSL https://rmux.io/install.sh | sh

• Windows: powershell -Command "irm https://rmux.io/install.ps1 | iex"

• Direct downloads and SHA256 checksums are available from the v0.2.5 GitHub Release

• From crates.io

• cargo install rmux --locked

• From a local checkout

• cargo install --path . --locked

• For Rust applications

• cargo add rmux-sdk

• cargo add ratatui-rmux

Documentation and learning resources

RMUX provides comprehensive documentation to help you install, configure, and program against the daemon.

• Documentation hub: rmux.io/docs
• Includes installation guides, CLI references, SDK examples, and terminal automation tutorials.
• API documentation, deep dives, and human-friendly configuration guidance are linked from the docs site.
• Human-friendly configuration
• For ergonomic, human-friendly profiles that preserve native terminal selection while extending split bindings and clipboard integration, see docs/human-friendly-config.md.

CLI Quickstart: a taste of day-to-day RMUX

A fast, spartan entry point helps you get hands-on with RMUX quickly.

• Basic session workflow

• rmux new-session -d -s work

• rmux split-window -h -t work

• rmux send-keys -t work 'echo "hello from rmux"'

• Enter

• rmux attach-session -t work

• Getting help locally

• rmux list-commands

• rmux new-session --help

• rmux split-window --help

SDK Quickstart: scripting RMUX in Rust

RMUX provides a daemon-backed SDK that enables you to orchestrate sessions, panes, and commands from Rust code.

• Dependency snippet (Cargo.toml)

• [dependencies] rmux-sdk = "0.2" tokio = { version = "1", features = ["rt-multi-thread", "macros"] }

• A minimal sample

• The code demonstrates connecting or starting the daemon, ensuring a named session, creating a detached configuration, and interacting with a pane to print and capture a snapshot.

• The example prints the current pane dimensions as a final step.

• Practical notes

• The SDK provides high-level abstractions like EnsureSession, SessionName, TerminalSizeSpec, and PaneSnapshot, enabling robust programmatic control of sessions and panes.

• It’s designed to be ergonomic for asynchronous Rust workflows and integrates naturally with Tokio-based applications.

Ratatui Widget: rendering RMUX state in a terminal UI

RMUX includes a Ratatui widget that leverages the PaneSnapshot and PaneState to render a live view of an RMUX-managed pane within a Ratatui-based UI.

• Example snippet

• The snippet shows converting a PaneSnapshot into a PaneState and feeding it into a PaneWidget for rendering.

• Practical use

• This widget enables building rich terminal dashboards that reflect the real-time state of RMUX sessions, panes, and layouts, directly in your own Rust applications.

Architecture: a clean, unified runtime

RMUX is built around a simple, robust architecture that makes it easy to extend and reason about.

• Public surfaces

• rmux: The command-line interface for day-to-day usage and experimentation.

• rmux-sdk: A daemon-backed Rust SDK for programmatic control.

• ratatui-rmux: A Ratatui widget that renders pane state in a UI.

• Shared protocol

• All surfaces talk to a daemon via a single local protocol. This ensures that any capability reachable from the CLI can be driven programmatically or rendered visually in a UI.

• The core crates and their roles

• rmux-types: Shared, platform-neutral value types.

• rmux-proto: Detached IPC DTOs, framing, and wire-safe errors.

• rmux-os: OS boundary helpers.

• rmux-ipc: Local IPC endpoints and transports.

• rmux-sdk: The daemon-backed Rust SDK.

• ratatui-rmux: Ratatui integration widget.

• rmux-pty: PTY allocation, resize, and child process control (support crate).

• rmux-core: Core concepts—sessions, panes, layouts, formats, hooks, buffers (support crate).

• rmux-server: Tokio-based daemon and request dispatch (support crate).

• rmux-client: Local IPC client and attach plumbing (support crate).

• rmux: The CLI and hidden daemon entrypoint (public binary).

• rmux-render-core: Shared snapshot rendering core (workspace-internal).

• Visual: RMUX runtime architecture

• An illustrative image captures the runtime architecture and how the three surfaces coordinate through a shared protocol and a daemon-backed kernel.

• Platform and boundary engineering

• The architecture emphasizes a clear OS boundary separation, with platform-neutral surfaces where possible and platform-specific code isolated to the appropriate crates.

Workspace, platform support, and configuration

RMUX is designed to be portable, yet practical for everyday use. The workspace is composed of multiple crates, each with a defined role and publication status.

• Workspace overview
• A collection of crates that together form the RMUX ecosystem: CLI, SDK, UI widget, PTY management, core session machinery, server daemon, and client libraries.
• Platform support
• Linux and macOS: Unix PTY backends, Unix sockets for IPC, and a default endpoint at /tmp/rmux-{uid}/default.
• Windows: ConPTY for PTY, Named Pipes for IPC, and a per-user named pipe endpoint.
• Configuration and dotfiles
• On Linux and macOS, RMUX reads .rmux.conf from standard system and user locations:
  • /etc/rmux.conf
  • ~/.rmux.conf
  • $XDGCONFIGHOME/rmux/rmux.conf
  • ~/.config/rmux/rmux.conf
• On Windows, RMUX reads .rmux.conf from:
  • %XDGCONFIGHOME%\rmux\rmux.conf
  • %USERPROFILE%.rmux.conf
  • %APPDATA%\rmux\rmux.conf
  • %RMUXCONFIGFILE%
• tmux.conf migration fallback
• When starting with default config discovery and no RMUX config is loaded, RMUX can attempt a filtered import of a tmux.conf as a migration fallback.
• Fallback files are read in a best-effort manner; non-regular files and files larger than 1 MiB are ignored.
• The fallback loading can be disabled entirely with RMUXDISABLETMUX_FALLBACK=1.
• This migration is intentionally narrow: statically supported options and key unbindings are retained; but tmux bindings, environment mutations, plugins, commands, and more are skipped for safety.
• Handling and safety
• RMUX is designed to be strict, with checks and validation to keep the daemon stable and the surface areas predictable for developers and users.

Verification and quality gates

RMUX emphasizes a strong verification regime to keep quality high as a rapidly evolving project.

• Core checks
• cargo fmt --all -- --check
• cargo clippy --workspace --all-targets --locked -- -D warnings
• cargo test --workspace --locked --no-fail-fast
• Additional local checks
• scripts/cfg-check.sh
• scripts/unsafe-check.sh
• scripts/no-network-in-runtime.sh
• scripts/check-platform-neutrality.sh
• scripts/ratatui-rmux-budget.sh
• scripts/verify-package.sh
• Release checks
• scripts/release-local.sh
• scripts/package-unix.sh
• Safety policy
• The codebase uses #![forbid(unsafe_code)] in the upper-level crates, reinforcing safety boundaries and isolating OS and terminal boundary code in the lower-level runtime crates.

Licensing and ecosystem

RMUX is dual-licensed to maximize its adoption and flexibility.

• MIT License
• Apache License 2.0
• You may choose either license when using RMUX in your projects

What to expect in v0.2.x

The current release, v0.2.0, represents a bold public preview released on 18 May 2026. It implements all 90 tmux-compatible commands, but as with any first-class public preview, users should expect bugs and rough edges. The project team invites bug reports and issue filings to improve subsequent releases. The combination of CLI familiarity, daemon-backed SDK, and Ratatui integration makes RMUX a compelling platform for experimentation with agentic terminal workflows, particularly in environments where long-running agents must be managed, inspected, and scripted with confidence.

Why you should try RMUX today

• If you manage long-running processes remotely, RMUX provides a robust way to detach, reconnect, and observe, without losing the terminal state.
• If you want to script complex workflows or coordinate multiple agents from Rust code, RMUX’s SDK unlocks a native, typed interface to panes, sessions, and commands.
• If you enjoy rich terminal dashboards or want to embed RMUX-like rendering into your own tooling, Ratatui integration offers a clean rendering surface that you can customize and extend.
• If cross-platform consistency matters, RMUX’s Windows support via Named Pipes and ConPTY ensures a cohesive experience across environments.

Notes on the current state

• This is a fresh public preview. While the feature set is broad—encompassing the full complement of 90 tmux-like commands—the project is actively evolving.
• The documentation is extensive and intended to guide both new users and developers exploring the SDK and UI widgets.
• If you encounter issues, please file them on the RMUX GitHub repository. The maintainers actively monitor issues and pull requests, aiming to refine the experience through community feedback.

Conclusion: a multiplexer built for the modern terminal era

RMUX represents a thoughtful reimagining of terminal multiplexing for the agentic era. It threads together a fast, reliable CLI, a daemon-backed SDK for programmatic control, and a Ratatui-powered UI surface to render state and interactions in the terminal. With cross-platform support, structured snapshots, detachable sessions, and a shared local protocol across surfaces, RMUX makes it possible to run, inspect, script, and orchestrate terminal-based workflows with a degree of control and visibility previously out of reach.

If you’re exploring persistent agents, remote orchestration, or intricate terminal automation, RMUX is worth a closer look. The project invites you to try the v0.2.0 preview, experiment with demos, and contribute to the ongoing development by filing issues and contributing improvements. The journey toward a more agentic terminal workflow starts with RMUX.

Images referenced in this post

• RMUX header: https://rmux.io/rmux-header.svg
• RMUX runtime architecture: https://rmux.io/rmux-architecture-dark.png
• Demos previews:
• Multi Agents Orchestration: https://rmux.io/demos/demo-orchestration.png
• Agent Broadcast Arena: https://rmux.io/demos/demo-broadcast.png
• Mini-Zellij: https://rmux.io/demos/demo-zellij.png
• Terminal browser mirroring: https://rmux.io/demos/demo-mirroring.png
• Playwright Testing: https://rmux.io/demos/demo-playwright.png
• Terminal session demo GIF: https://rmux.io/rmux-terminal-demo.gif

Appendix: quick reference links

• Official RMUX docs: https://rmux.io/docs
• v0.2.5 release notes: https://github.com/helvesec/rmux/releases/tag/v0.2.5
• GitHub repository: https://github.com/helvesec/rmux
• Demos repository: https://github.com/Helvesec/rmux-demos

Closing thought

RMUX is more than a tool; it’s a framework for thinking about terminals as persistent, scriptable environments. It invites both humans and machines to collaborate through a shared, well-defined protocol, turning the terminal into a first-class platform for agents, automation, and exploration. If you’re curious about a future where your long-running tasks stay alive, remain inspectable, and respond to programmatic orchestration—RMUX is designed with you in mind.