Open-source project
raine/workmux avatar
raine/workmux

workmux: five ways to install it, and the crate that ships without its docs

git worktrees + tmux windows for zero-friction parallel dev

3,046 stars316 forksRustMIT

At a glance

What is it?
A Rust workflow tool that pairs git worktrees with tmux windows so several coding agents can run side by side. Its packaging tells the sharper story: a curl one-liner that installs from main, an include list that omits docs and tests, a release candidate pinned as a dependency, and a quality gate that runs through one external binary.
Who is it for?
workmux is a workflow opinion packaged as a binary, and it earns its place for anyone already living in tmux who wants each task to own a checkout and a window. It is a poor fit for anyone who wants the underlying tools hidden rather than composed, since the project's stated philosophy is to build on tmux, git and your agent rather than replace them.
Can I use it commercially?
Yes. MIT is a permissive licence: you can use, modify and sell software built on it, as long as you keep its copyright and licence notices.
Is it still maintained?
Yes. The repository last received commits 1 day 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.

From daily snapshots

Star history

  • raine/workmux3,046 ★ · +266
Star history
Repository2026-10-042026-11-15
raine/workmux2.8k3k

266 Stars in the last 42 days, measured from the daily GitHub snapshot. Compare with other projects

Editorial analysis

Five install routes, and the first one is named Bash YOLO

The README calls its own first installation method Bash YOLO and hands you a pipe:

bash
curl -fsSL https://raw.githubusercontent.com/raine/workmux/main/scripts/install.sh | bash
brew install raine/workmux/workmux

Note what that URL points at. It reads the install script from the `main` branch, not from a tag, so the one-line path installs whatever that branch currently holds regardless of which release you last read about. The remaining four routes are steadier: a Homebrew tap, `cargo install workmux`, `mise use -g cargo:raine/workmux` and `nix profile install github:raine/workmux`, the last three hidden inside a collapsed details block, plus pre-built binaries linked from the latest release page. The manifest version is 0.1.269, matching the newest tag v0.1.269 published 2026-09-30, after v0.1.268 and v0.1.267, which landed two days apart on 2026-09-26 and 2026-09-25.

The published crate ships skills and Docker assets, not the docs or tests

Cargo.toml carries an explicit include list, so what a user downloads from crates.io or a distro package is decided by hand:

toml
include = [
    "/src/**/*",
    "/skills/**/*",
    "/docker/**/*",
    "/.claude-plugin/**/*",
    "/.grok/**/*",
    "/resources/**/*",
    "/Cargo.toml",
    "/Cargo.lock",
    "/CHANGELOG.md",
    "/LICENSE",
    "/README.md",
]

The repository root also holds docs/, tests/, a justfile, checkle.toml, deny.toml, devbox.json, flake.nix, scripts/ and hooks/, none of which travel with the package. Two similarly named agent directories sit next to each other, and only one of them ships: `.claude-plugin/` is in the list while `.claude/` is not. The manifest also points its documentation field at the repository README anchor, while the README itself sends readers to a separate documentation site, so the packaged crate's own metadata leads nowhere useful.

notify is pinned at a release candidate and there is no async runtime

Two dependency lines deserve attention. The first is `notify = "9.0.0-rc.3"`, a release candidate sitting in the tree of a tool whose releases are numbered in the hundreds; the second is `notify-rust = "4"` right above it, which is the wrapper that consumes it. Pin widths are uneven too: nearly every entry asks for a major or a major.minor, while `nix = { version = "0.31.2" }` asks for three components. What is absent is as informative as what is there. There is no tokio and no async-std anywhere in the dependency list, even though the crate spawns tmux and git, watches the filesystem through notify, and draws a terminal dashboard with ratatui, crossterm and ansi-to-tui. Platform specifics are pushed into the target tables instead, with rustix for Linux filesystem calls and mac-notification-sys for macOS notifications.

Every project check runs through one external binary called checkle

The justfile routes its own quality gate through a single program that is not in Cargo.toml, and checkle.toml sits at the repository root to configure it:

code
check:
    checkle run all

build:
    checkle --label build --mode cargo -- cargo build --all --message-format=json

Formatting, clippy and the unit tests go the same way, as `checkle run format-rust-check`, `checkle run clippy` and `checkle run unit-tests`, and the formatting split has a Python half in a Rust project. A contributor therefore needs that binary on PATH before `just check` means anything, and the recipes are not readable Rust commands but arguments to someone else's runner. The CI variant runs the same check and then refuses to continue if the working tree is dirty, printing that the check caused uncommitted changes. The file also pins its own shell to bash with `set -euo pipefail -c`.

install-dev hardcodes one path while install-release reads three variables

Four install recipes exist and they do not agree on where a binary belongs. The local one is explicit about staying offline:

code
cargo install --offline --path . --locked
cargo build && ln -sf $(pwd)/target/debug/workmux ~/.cargo/bin/workmux

The second line writes a symlink straight into `~/.cargo/bin`, which is the right guess on a default rustup machine and the wrong one anywhere CARGO_HOME points elsewhere, and it does not create that directory first. The release path is more careful: it resolves an install root from CARGO_INSTALL_ROOT, then CARGO_HOME, then `$HOME/.cargo`, exports WORKMUX_INSTALL_DIR and hands off to scripts/install.sh, which is the same script the curl one-liner pipes to bash. Two more recipes install from CI and install Git hook shims through scripts/install-ci and scripts/install-git-hook-shims, which means using the tool can write into your repository's hooks directory.

One page links two documentation domains and the metadata homepage is plain http

The README points at its guides through more than one address. The footnote under the title links kitty, WezTerm and Zellij guides on `workmux.raine.dev`, while the quick start note links the same three backends on `raine.github.io/workmux/guide`, so a reader following the setup path is sent to a different host than the reader following the features list. The repository's own homepage metadata is `http://workmux.raine.dev`, without a scheme upgrade, while the README links the same site over https and the manifest names the GitHub repository as homepage instead. The page also carries an author tip pointing at another project of the same author's, a blog introduction, and nine third-party quotes gathered from Hacker News, two GitHub issues, Threads, X and YouTube, which is more reader reaction than mechanism.

The quick start's second bullet stops mid-word, and the agent surface is four directories wide

The quick start describes what one command does: create a worktree at `<project_root>/../<project_name>__worktrees/new-feature`, copy config files and symlink dependencies when configured, run the post_create setup commands, and open a tmux window named `wm-new-feature` with a configurable prefix. That enumeration is where the text ends, partway through the sentence describing the pane layout step. Configuration is optional and file based, since `workmux init` writes a `.workmux.yaml` covering pane layouts, setup commands and file operations, and the repository ships its own copy at the root. Around that sit the agent features: a dashboard, a sidebar, a `/worktree` skill for delegating tasks, agent status reflected in window names, sandbox agents in containers or VMs, and automatic branch name generation from prompts using an LLM, with skills/, hooks/, .claude-plugin/ and .grok/ in the tree.

Editorial conclusion

workmux is a workflow opinion packaged as a binary, and it earns its place for anyone already living in tmux who wants each task to own a checkout and a window. It is a poor fit for anyone who wants the underlying tools hidden rather than composed, since the project's stated philosophy is to build on tmux, git and your agent rather than replace them. Before installing, decide which channel you trust: the curl one-liner pulls a script from the main branch rather than a tag, and the newest release is v0.1.269 from a cadence that shipped three tags in six days while the package stays on 0.1.x. Check the include list too, because the crate a user downloads carries the agent skill definitions and Docker assets but not the documentation, the tests or the justfile, and the `notify` dependency is still a release candidate.

Frequently asked questions

What is Workmux?

An opinionated Rust workflow tool that pairs git worktrees with tmux windows so each task gets its own checkout, terminal state, editor session, dev server and coding agent. tmux is the default backend and kitty, WezTerm and Zellij are supported alternatives, and the project is MIT licensed with version 0.1.269.

How is workmux installed on macOS or Linux?

Five documented routes: a curl one-liner that pipes scripts/install.sh into bash, brew install raine/workmux/workmux, cargo install workmux, mise use -g cargo:raine/workmux and nix profile install github:raine/workmux. The last three sit in a collapsed block, and pre-built binaries are also linked from the latest release page.

What does workmux add create when given a branch name?

A git worktree at <project_root>/../<project_name>__worktrees/new-feature, copies of config files and symlinks to dependencies when file operations are configured, the post_create setup commands, and a tmux window named wm-new-feature whose prefix is configurable.

Does workmux require tmux to be running first?

The quick start says workmux requires a terminal multiplexer installed and running before you start, naming tmux first and WezTerm, Kitty or Zellij as the other supported backends. The project also publishes guides for setting up each of those.

What files ship inside the published workmux crate?

The manifest's include list covers src, skills, docker, .claude-plugin, .grok and resources, plus Cargo.toml, Cargo.lock, the changelog, the licence and the README. The docs directory, the tests, the justfile and the Nix flake are in the repository but not in the package.

Official sources

  1. License: MIT
  2. Project website
  3. raine/workmux on GitHub
  4. README
  5. Releases
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.

Add this badge to your README

markdown
[![Hysen Labs](https://hysenlabs.com/badge/raine-workmux.svg)](https://hysenlabs.com/projects/raine-workmux)

Star history chart for your README

markdown
[![Star history](https://hysenlabs.com/chart/raine-workmux.svg)](https://hysenlabs.com/projects/raine-workmux)

Was this useful?