# psmux: a native Windows tmux built in Rust, no WSL required

> psmux is a Windows terminal multiplexer that speaks the tmux command language and reads .tmux.conf, using ConPTY directly instead of a POSIX compatibility layer. The trade-off is that it is a Windows-only tool, and the README is thinner on failure modes than on features.

**psmux/psmux** — Tmux on Windows Powershell - tmux for PowerShell, Windows Terminal, cmd.exe. Includes psmux, pmux, and tmux commands. This is native High-Performance Tmux designed for Windows in Rust 🦀

- Repository: https://github.com/psmux/psmux
- Website: https://psmux.pages.dev/
- Stars: 3,582 · Forks: 215
- Language: PowerShell
- License: MIT
- Published: 2026-09-23 · Updated: 2026-09-23 · Language: en
- Canonical page: https://hysenlabs.com/projects/psmux-psmux

## The gap psmux fills on Windows

Windows has never shipped a multiplexer in the tmux sense. Windows Terminal gives you tabs and panes, but panes die with the window, there is no detach and reattach, and no session survives closing the terminal. The usual workaround is WSL, where you run real tmux inside a Linux userland. That works, but it moves your shell, your paths and your toolchain into a second operating system, and native Windows processes are awkward to reach from inside it.

psmux targets the person who wants to stay in PowerShell. The README states it is a native Windows terminal multiplexer built from the ground up in Rust, using Windows ConPTY directly, speaking the tmux command language, reading .tmux.conf and supporting tmux themes, without WSL, Cygwin or MSYS2. The stated requirement is Windows 10 or Windows 11 with PowerShell 7+ recommended, or cmd.exe. The project also describes first-class support for Claude Code agent teams, where teammate agents spawn in separate panes instead of running in-process.

## Client, server, and one ConPTY per pane

The architecture page in the repository is named docs/architecture.md, and the README describes it as covering how psmux multiplexes natively: client/server, one ConPTY per pane, input and output paths, and a warm pool. That is the whole shape of the design in one line. A client process attaches to a server that owns the sessions; each pane is backed by its own ConPTY, the Windows pseudoconsole API, rather than by a Unix pseudo-terminal. The warm pool is the part worth noting: pre-created resources reduce the cost of opening a new pane, which is the operation that feels slow in multiplexers that spawn a fresh console host each time.

Because the terminal emulation lives in the project rather than in a compatibility shim, the repository carries its own VT parser in crates/vt100-psmux and its own PTY layer in crates/portable-pty-psmux. The integration tests named in Cargo.toml track specific terminal behaviours: OSC 52 clipboard capture, OSC 94 handling, SGR attributes, wide-character rendering, and copy-mode freezes. That test list is the most honest signal in the repository about where the difficulty sits. Terminal emulation on Windows is a long tail of escape sequences, and psmux is maintaining its own implementation of that tail.

## Installing psmux and opening a first session

The README lists five install paths. WinGet is the shortest. Run this in PowerShell and you should end up with the psmux executable on your PATH:

```powershell
winget install psmux
```

Cargo is the option for Rust users, and it is the one that installs all three command names:

```powershell
cargo install psmux
```

According to the README, that command installs psmux, pmux and tmux binaries to your Cargo bin directory. Scoop and Chocolatey are also documented, and there is a zip on GitHub Releases if you prefer to manage PATH yourself. Building from source means cloning the repository, running cargo build --release, and picking up target\release\psmux.exe along with the pmux and tmux binaries next to it.

Once installed, the three command names are identical. Start a named session, detach with the prefix key plus d, then reattach:

```powershell
psmux new-session -s work
psmux ls
psmux attach -t work
```

The README gives exactly these forms: psmux new-session -s work for a named session, psmux ls to list sessions, psmux attach -t work to attach. Running psmux with no arguments starts a new session. If you want to know what the binary accepts before trusting your existing config, psmux list-commands prints every command it handles, and the README says the live list runs past 90 entries. The project also states that your existing .tmux.conf works, so pointing psmux at an existing tmux configuration is the natural second step rather than writing a new one.

## Where psmux is the wrong tool

The constraint is in the requirements list: Windows 10 or Windows 11. There is no documented Linux or macOS build, and the README frames the project as the Windows counterpart to tmux rather than a replacement for it. If you administer a mix of Windows and Linux machines and want one multiplexer configuration to travel with you, psmux only covers half of that.

Compatibility is the second boundary, and it is a boundary by degree rather than a yes or no. The README advertises 90+ tmux-compatible commands, 140+ format variables and 53 vim copy-mode keys, and it points to docs/compatibility.md for a command and config compatibility matrix. A matrix exists because the coverage is not total. The README does not say which commands are missing, and it does not document rollback or downgrade behaviour for the server, so a config that leans on an unlisted feature may fail quietly rather than with a clear error. Treat the matrix as required reading before you move a long-standing tmux setup onto it.

There is also a maturity question that the repository itself answers. The last push to the default branch was on 2026-09-23, and the most recent release listed is v3.3.8 on 2026-08-18. The version number and the frequency of releases suggest a project still absorbing fixes, and the test names in Cargo.toml, which reference specific issue numbers, support that reading. That is normal for a terminal emulator, but it means you should expect to track releases rather than install once and forget.

## psmux compared with tmux under WSL

The realistic alternative for most Windows users is not another Windows multiplexer, it is tmux itself running inside WSL. The difference is architectural. Under WSL, tmux talks to a Linux pseudo-terminal, your panes run Linux processes, and your files live on the Linux side of the filesystem boundary. Everything in the tmux manual applies, because it is tmux. The cost is that native Windows tooling, Windows paths and Windows-only binaries are second-class inside those panes, and you are maintaining a Linux distribution alongside Windows.

psmux inverts that. Your panes are native Windows processes under ConPTY, so pwsh, cmd and Windows executables are the default rather than something you reach across a boundary for. The README also points to docs/multi-shell.md for running pwsh, cmd, Git Bash, WSL and nushell side by side, which suggests WSL is treated as one shell among several rather than as the host environment. The price you pay is that psmux is a reimplementation, not tmux, so the compatibility matrix governs what your existing configuration can do.

Windows Terminal is the other thing people compare it to, and the distinction is session lifetime. Windows Terminal manages windows, tabs and panes inside one process; when that process exits, the layout is gone. psmux is a client/server multiplexer with detach and reattach, which is a different guarantee about what survives.

## Licence, upgrades and the cost of tracking releases

psmux is MIT licensed, stated in both the README and the license field of Cargo.toml. That is a permissive licence, and it is the same licence tmux uses, so mixing the two in one workflow does not create an obvious licensing conflict. This is a description of what the repository declares, not legal advice; if you redistribute psmux inside a product, read the LICENSE file at the repository root yourself.

Upgrade cost depends on your install channel. WinGet, Scoop and Chocolatey each have their own upgrade command, and the README documents installation for all three without documenting the corresponding upgrade path, so check your package manager's own documentation. Cargo users can re-run cargo install psmux to move to a newer published version. From a source checkout, the upgrade is a git pull followed by cargo build --release, which also means you own the Rust toolchain requirement, pinned in the repository by rust-toolchain.toml.

The real maintenance cost is configuration drift. Because psmux reads .tmux.conf, the temptation is to assume full parity and be surprised later. The repository's own answer to that is the compatibility page and the live command list, both of which you can consult without installing anything new.

## Conclusion

Adopt psmux if your daily driver is Windows 10 or 11 and you want tmux keybindings, panes and session persistence without running WSL, Cygwin or MSYS2. Do not adopt it if your work spans Linux and macOS hosts and you need one multiplexer binary everywhere, or if you depend on tmux behaviour that the compatibility matrix in docs/compatibility.md does not list. Before committing, run psmux list-commands on your machine and diff it against the commands your existing .tmux.conf and scripts call, then check the compatibility page for the features you actually use.

## FAQ

### What are the differences between psmux and tmux?

psmux is a native Windows multiplexer written in Rust that uses Windows ConPTY directly and speaks the tmux command language, while tmux is the original Unix multiplexer that runs on Linux and macOS. The README states that psmux reads your .tmux.conf and supports tmux themes, and it points to docs/compatibility.md for the command and config compatibility matrix, so the two are close but not identical in coverage.

### How to install psmux?

The README lists WinGet, Cargo, Scoop, Chocolatey, a zip from GitHub Releases, and building from source. The shortest is winget install psmux, and cargo install psmux installs the psmux, pmux and tmux binaries to your Cargo bin directory.

### how to use psmux

Run psmux with no arguments to start a session, or psmux new-session -s work for a named one. Then psmux ls lists sessions and psmux attach -t work reattaches to one; the README notes that psmux, pmux and tmux are identical commands.

### what is psmux

psmux is a native Windows terminal multiplexer built in Rust that uses Windows ConPTY directly and speaks the tmux command language, reading .tmux.conf without WSL, Cygwin or MSYS2. It requires Windows 10 or Windows 11, with PowerShell 7+ recommended or cmd.exe.

## Sources

- [License: MIT](https://github.com/psmux/psmux/blob/master/LICENSE)
- [Project website](https://psmux.pages.dev/)
- [psmux/psmux on GitHub](https://github.com/psmux/psmux)
- [README](https://github.com/psmux/psmux/blob/master/README.md)
- [Releases](https://github.com/psmux/psmux/releases)

---

Hysen Labs editorial analysis, written from the project's own repository and release notes. Cite the canonical page: https://hysenlabs.com/projects/psmux-psmux