RMUX: A Rust Multiplexer That Exposes CLI and TUI Sessions to Code
Universal Rust multiplexer with a typed SDK — drive any CLI or TUI app from code. Native on Linux, macOS, and Windows.
At a glance
- What is it?
- RMUX is a cross-platform terminal multiplexer written in Rust that ships a typed SDK for driving interactive programs programmatically, with published Python and TypeScript bindings. The premise is sound, but the repository material leaves the licence and the SDK surface underspecified.
- Who is it for?
- Adopt RMUX if you need to drive an interactive CLI or TUI from Rust, Python or TypeScript and you are willing to pin a version while the API is still at 0.10.x. Do not adopt it if you need a permissively licensed dependency with a settled legal position, or if your automation is a one-shot subprocess call that std::process::Command already handles.
- Can I use it commercially?
- Check first. The repository uses a licence we do not classify automatically, so read its LICENSE file before any commercial use.
- Is it still maintained?
- Yes. The repository last received commits 22 days ago.
- What is it written in?
- Mainly Rust, according to GitHub's language statistics.
Answers come from the project's GitHub data, last synced on November 15, 2026, and from our analysis. They are not legal advice.
Star history
- Helvesec/rmux2,696 ★ · +64
| Repository | 2026-09-11 | 2026-11-15 |
|---|---|---|
| Helvesec/rmux | 2.6k | 2.7k |
64 Stars in the last 65 days, measured from the daily GitHub snapshot. Compare with other projects
Editorial analysis
The gap RMUX targets: programs that only speak to a terminal
Most automation assumes a program accepts arguments and returns an exit code. A large class of tools does not work that way. Interactive CLIs and TUI applications expect a pseudo-terminal, emit escape sequences, redraw on resize, and wait for keystrokes rather than reading stdin to EOF. Wrapping them usually means spawning a pty by hand, parsing ANSI output, and guessing when a prompt is ready. RMUX positions itself as the layer that removes that work. The repository describes it as a "Universal Rust multiplexer with a typed SDK" whose purpose is to "drive any CLI or TUI app from code." The intended audience is narrow and identifiable: developers building agent harnesses, test runners for interactive tools, or orchestration layers that need to control terminal programs on Linux, macOS and Windows from a single codebase. The topic list includes agent, ai, ratatui and powershell, which points at the same audience. If your problem is running curl and checking the exit status, this is not aimed at you.
What the multiplexer plus SDK split actually buys you
The design separates two concerns. The multiplexer owns terminal sessions: spawning them, keeping them alive, feeding input, and capturing output. The SDK is the typed surface over that session model, published separately for Python as librmux on PyPI and for TypeScript as @rmux/sdk on npm. That second part is the more interesting decision. A Rust-only multiplexer would force Python and TypeScript users to shell out to a binary and parse text. By publishing bindings, RMUX lets those callers work with typed session objects instead. The trade-off is version skew. Two SDKs in two package registries plus a Rust core means three release tracks that can drift, and the repository material does not state how the bindings are generated or whether they are versioned in lockstep with the core. The README also links to a benchmarks document at docs/benchmarks.md, so performance claims exist in the repository.
Installation paths named in the repository
The README has an Installation section and a Quick Start section, which is where setup instructions live. Read the commands inside those sections for the exact cargo install invocation and the crate name to add to Cargo.toml. What can be stated with confidence is the shape of the distribution: a Rust core on the Rust side, librmux on PyPI, and @rmux/sdk on npm. If you are evaluating RMUX for a Python or TypeScript project, the two package names are the concrete starting points and both are linked directly from the README sidebar. The homepage at rmux.io and the examples path at rmux.io/docs/examples/ are the other two referenced resources. Treat the missing install commands as a documentation gap you will need to close by reading the Installation section in full before you plan any integration work.
Web sharing and Claude teammate mode are the two features that need scrutiny
Two sections in the README stand out because they imply capabilities beyond local process control. The first is Web Sharing, which suggests a session can be exposed over a network rather than kept on the local machine. The second is a section labelled Claude Agents in the sidebar artwork, with an anchor named claude-teammate-mode, which suggests RMUX has a mode built specifically for running agent teammates against a shared terminal session. Both are plausible extensions of a multiplexer: shared sessions are what tmux and screen users build by hand, and agent orchestration is the stated topic of the project. Whether web sharing is opt-in, what binds the listener, whether there is authentication, and what transport is used matter most for a feature that turns a local terminal into a network endpoint. Read the Web Sharing section in full before enabling it anywhere that is not a disposable machine.
Where RMUX is the wrong tool
The clearest failure mode is scope mismatch. If the program you want to automate reads stdin and writes stdout without a terminal, RMUX adds a pty layer, a session lifecycle and an SDK dependency to solve a problem that std::process::Command or subprocess already solves. The second limitation is the version number. The most recent release is v0.10.0, published 2026-08-04, preceded by v0.9.1 and v0.9.0 within the preceding month. A sub-1.0 project that ships three releases in roughly three weeks is moving quickly, and the README material gives no compatibility policy for the SDKs. Any integration should pin exact versions of librmux and @rmux/sdk rather than using a caret range. The third issue is the licence. The repository metadata reports NOASSERTION, which means the licence could not be identified automatically. That is not the same as having no licence, and it is not the same as having a permissive one. Until the actual terms are confirmed from the repository, RMUX cannot be treated as a safe dependency in a commercial codebase.
How this differs from tmux and from expect-style scripting
The obvious comparison is tmux, which solves session persistence and multiplexing on Unix systems and has done so for years. The difference is the interface. tmux is controlled through a command language and a socket protocol designed for humans typing commands; scripting it means generating command strings and parsing text output. RMUX exposes a typed SDK, which means a Python caller works with session objects and methods rather than string concatenation, and the same conceptual API is available from TypeScript and Rust. The second comparison is expect, or the Python pexpect library, which automates interactive programs by matching output patterns. That approach is genuinely portable and mature, but it is pattern-matching: you write a regular expression for the prompt and hope the program does not change its wording. RMUX's claimed advantage is that the multiplexer understands the terminal session as a first-class object rather than a stream of bytes to be matched. Whether that advantage holds in practice depends on the SDK surface. The other concrete difference is Windows. tmux is Unix-oriented, while RMUX lists Windows and PowerShell among its topics and describes itself as native on Linux, macOS and Windows.
Maintenance cost and the licence question
Three release tracks means three upgrade surfaces. A Rust core at 0.10.x, a Python package on PyPI and a TypeScript package on npm each need to be checked when you upgrade, and the repository material does not state whether the bindings are generated from a schema or maintained by hand. Hand-maintained bindings drift; generated ones drift less but still need regeneration. Budget for reading release notes at each bump rather than assuming the SDKs move together. On licensing, the honest position is that NOASSERTION tells you nothing usable. It may mean a custom licence, a licence file GitHub does not recognise, or a missing licence file entirely. Each of those has different consequences for redistribution and for linking into proprietary software. Confirm the terms from the repository itself, and if the project is going into a product, have someone qualified read them.
Who should evaluate RMUX, and what to check first
The fit is specific. You are building an agent harness or an integration test suite for an interactive CLI or TUI, you need it to run on Windows as well as Linux and macOS, and you want to write the control logic in Rust, Python or TypeScript rather than in shell. RMUX is aimed directly at that. The misfit is equally specific. You need a stable, permissively licensed dependency today, or your automation does not involve a terminal at all. Before writing any integration code, do four things: read the Installation section to get the real crate and package names, read the Web Sharing section to find out what a shared session exposes and to whom, check the licence file in the repository to replace NOASSERTION with an actual identifier, and confirm that librmux and @rmux/sdk are published at versions matching the v0.10.0 core. If the Python or TypeScript package is sitting several versions behind, the typed SDK advantage shrinks to whatever the core binary can do over a pipe.
Editorial conclusion
Adopt RMUX if you need to drive an interactive CLI or TUI from Rust, Python or TypeScript and you are willing to pin a version while the API is still at 0.10.x. Do not adopt it if you need a permissively licensed dependency with a settled legal position, or if your automation is a one-shot subprocess call that std::process::Command already handles. Before committing, verify three things: the actual licence terms behind the NOASSERTION identifier, whether the Python and TypeScript SDKs on PyPI and npm track the Rust core version, and whether the documented web sharing feature opens a network listener by default.
Frequently asked questions
Is rmux a drop-in replacement for tmux?
The description field in Cargo.toml calls it a local terminal multiplexer with a tmux-style CLI, daemon runtime, Rust SDK and ratatui integration, so the command shape follows tmux. No subcommand list appears in the manifest or the root README, so check your own commands against the docs pages the anchor row points to.
Does rmux run on Windows and macOS as well as Linux?
The project summary says it is native on Linux, macOS and Windows, and the published crate ships a Windows executable manifest at /resources/windows/rmux.exe.manifest. A snap directory and a Nix flake sit at the root as well, and the root listing carries no platform gate beyond those files.
Can I depend on the rmux Rust SDK from crates.io?
The shared workspace block sets publish = false for its members, and only the root rmux package sets publish = true. rmux-sdk and the other crates are marked internal to the workspace by that setting, so a Rust dependency on them resolves through a git reference rather than a registry.
What license does rmux ship under?
Cargo.toml declares MIT OR Apache-2.0, and the repository root holds LICENSE, LICENSE-APACHE and LICENSE-MIT. The license field on the project page reports NOASSERTION, so the page itself names neither license and the files are the only source for terms.
What does rmux claude teammate mode do?
The README anchor row names a section called claude-teammate-mode, and the root package include list ships a file under /resources/claude/skills/rmux/. The text of that section is not in the root README copy, so the mode has to be read on the page the anchor points to.
Official sources
Add this badge to your README
If you maintain this project, the badge below links readers to this analysis and shows its maintenance status from the daily GitHub snapshot. Paste the markdown into your README; add ?metric=license or ?metric=stars to the image URL for a different field.
[](https://hysenlabs.com/projects/helvesec-rmux)Star history chart for your README
[](https://hysenlabs.com/projects/helvesec-rmux)Was this useful?