rmux 0.1.1

Universal Rust multiplexer for the agentic era: detachable, scriptable, and inspectable, with a tmux-compatible CLI, daemon-backed SDK, and native Ratatui integration.

[!IMPORTANT] Released on 16 May 2026. All 90 tmux-compatible commands are implemented, but bugs are expected — this is a fresh public preview. Please file issues if you hit one.

What RMUX Provides

• A tmux-style CLI for sessions, windows, panes, buffers, hooks, formats, copy mode, control mode, and common terminal workflows.
• A Rust SDK for creating sessions, splitting panes, sending typed input, reading snapshots, subscribing to pane output, waiting for text or bytes, and shutting down cleanly.
• A ratatui widget that renders pane snapshots into a ratatui::buffer::Buffer without requiring async work in the draw path.
• Native local runtime support: Unix PTYs and Unix sockets on Linux/macOS; ConPTY and named pipes on Windows — no WSL required.
• A small published crate set with internal implementation crates kept out of the public package surface.

Install

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

CLI Quickstart

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

Use command help locally:

rmux list-commands
rmux new-session --help
rmux split-window --help

SDK Quickstart

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

use std::time::Duration;

use rmux_sdk::{
    EnsureSession, EnsureSessionPolicy, ProcessSpec, Rmux, SessionName,
    TerminalSizeSpec,
};

#[tokio::main]
async fn main() -> rmux_sdk::Result<()> {
    let rmux = Rmux::builder()
        .default_timeout(Duration::from_secs(5))
        .connect_or_start()
        .await?;

    let session_name = SessionName::new("work").expect("valid session name");
    let session = rmux
        .ensure_session(
            EnsureSession::named(session_name)
                .policy(EnsureSessionPolicy::CreateOrReuse)
                .detached(true)
                .size(TerminalSizeSpec::new(120, 32))
                .process(ProcessSpec {
                    command: None,
                    environment: None,
                }),
        )
        .await?;

    let pane = session.pane(0, 0);
    pane.send_text("printf 'ready\\n' && sleep 1\n").await?;

    pane.wait_for_text("ready").await?;
    let snapshot = pane.snapshot().await?;
    println!("{}x{}", snapshot.cols, snapshot.rows);

    Ok(())
}

Ratatui Widget

use ratatui::{buffer::Buffer, layout::Rect, widgets::Widget};
use ratatui_rmux::{PaneState, PaneWidget};
use rmux_sdk::PaneSnapshot;

fn render(snapshot: PaneSnapshot, area: Rect, buffer: &mut Buffer) {
    let state = PaneState::from_snapshot(snapshot);
    PaneWidget::new(&state).render(area, buffer);
}

Architecture

Three public surfaces — a rmux CLI, a rmux-sdk Rust crate, and a ratatui-rmux widget — share a single local protocol to talk to the daemon. Anything one surface can do, the others can do too.

Workspace

Platform Support

Configuration

On Linux and macOS, RMUX reads .rmux.conf from the standard system and user locations:

1. /etc/rmux.conf
2. ~/.rmux.conf
3. $XDG_CONFIG_HOME/rmux/rmux.conf
4. ~/.config/rmux/rmux.conf

On Windows, RMUX reads .rmux.conf as well, from the following locations:

1. %XDG_CONFIG_HOME%\rmux\rmux.conf
2. %USERPROFILE%\.rmux.conf
3. %APPDATA%\rmux\rmux.conf
4. %RMUX_CONFIG_FILE%

Verification

The workspace is designed to be checked from source with locked dependencies:

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 artifact checks are driven by:

scripts/release-local.sh
scripts/package-unix.sh

#![forbid(unsafe_code)] is used in the upper-level crates. OS and terminal boundary code is isolated in the lower-level runtime crates.

License

RMUX is dual-licensed under either:

• MIT License
• Apache License 2.0

at your option.