Six ways to get sessions and panes on Windows - and what each one actually gives up.
You search for "tmux Windows" expecting a download link and find a decade of workarounds instead. The short version: tmux has never had a native Windows build, but 2026 is the best year yet to want multiplexing on Windows - zellij now ships an installer, Windows Terminal can restore your whole layout, and the terminal you use matters more than the multiplexer you pick.
Here are the six real options, ordered from best fit to last resort: the native multiplexer first, real tmux under WSL next, then the pane-based terminals, and the compatibility-layer fallback at the end.
tmux's official installation guide lists binary packages for Linux distributions and macOS. There is no Windows row in the table. tmux is built on POSIX process handling and the utemp/pty machinery that Unix terminals provide, and Windows doesn't offer those natively - so upstream has never shipped Windows support. What Windows users find instead are two compatibility layers and one honest alternative:
pacman -S tmux), so tmux runs, inside an emulation environment - which means clipboard and font handling pass through that layer rather than talking to Windows directly, and you're maintaining a second toolchain to have a terminal multiplexer.C:\ files, and your Windows clipboard sit outside the session. tmux in WSL is a Linux workstation with a Windows window - great if that's genuinely where you work, the wrong foundation if your day is split across both worlds.Both routes work. Both ask you to run a Unix world next to your Windows world instead of working with it. The options below are ordered by how little of that friction each one leaves you with, ending with the route that keeps the most.
Best for: People who actually want a terminal multiplexer, not a terminal with panes.
Zellij is the modern answer to tmux - sessions, windows, and panes, with a mode-based keybinding system and a UI that surfaces what each mode can do instead of making you memorize a prefix table. It has floating and stacked panes, session resurrection, and a plugin system; its README bills it as a "terminal workspace with batteries included."
Crucially for this article: zellij runs natively on Windows. Starting with v0.44.0 (March 23, 2026), releases ship x86_64-pc-windows-msvc binaries - a .zip and a proper .msi installer. The current v0.46.0 release carries the same Windows assets. No WSL, no Cygwin, no MSYS2: install the MSI and you have a multiplexer that talks to real Windows processes.
Pros: True sessions on native Windows processes; MSI install; tmux-adjacent mental model with a friendlier learning curve; actively developed (the first Windows builds are less than a year old).
Cons: Windows is the newest of its platforms, so it's the least battle-tested target; a different keybinding culture from tmux, so muscle memory doesn't transfer directly.
Best for: Developers whose work already lives in WSL - Linux servers, container-heavy workflows, dotfiles in the home directory.
If your shell is already WSL's bash, nothing changes: sudo apt install tmux (or your distro's equivalent), and you have the tmux you know, with every config file and plugin you already run. Windows Terminal hosts WSL as a profile, so the outside layer is still a good Windows terminal.
Pros: Unmodified tmux; your existing config works; the best performance-per-fidelity of any option here, because there's no emulation - it's Linux.
Cons: Sessions can only hold Linux processes over Linux files; Windows-side work happens in separate tabs outside the multiplexer; two filesystems, two clipboards, one more thing to keep straight. This is the "tmux on Windows" answer that quietly means "tmux, not on Windows."
Best for: Windows-native users who want panes and don't run detachable long-lived sessions.
Windows Terminal (built into Windows 11, free on Windows 10) splits tabs into panes with Alt+Shift+arrow, and since the persistedWindowLayout startup action, it saves the layout of open windows on close and restores all saved windows on starting a new session - the layout is also saved on quit and after crashes. Close your laptop, reopen it, and your panes come back where you left them.
What doesn't come back is what was running. Windows Terminal restores layout, not processes: your shells exit when the pane's host exits, so a long build or a log tail dies with the window. There's no attach command, because there's no session to attach to. Layout restoration narrows the gap; it doesn't close it.
Pros: Already installed; excellent panes and tabs; layout restore; free; wide font and rendering support.
Cons: No session detachment or attach; no remote session management; shells die with the app.
Best for: People who want a modern, AI-assisted terminal with pane workflows on Windows.
Warp ships for macOS, Windows, and Linux, with Windows builds for x64 and ARM64 and a winget installer (winget install Warp.Warp). It brings split panes, blocks, and its AI features to Windows - a multiplexer-like experience in the shell itself, with the caveat that much of Warp's fame was earned on macOS, where it started.
Pros: Native Windows app; panes, blocks, command palette, AI assistance; winget install.
Cons: Like Windows Terminal, it has no detach/attach session model - it's panes in one app, not a session server; parts of the product are cloud-connected, which matters to you if it doesn't.
Best for: Windows developers whose tmux habit is really about two things: not losing work, and managing sessions on remote servers.
Yaw attacks both directly. Locally, split panes, tabs, and search live in the terminal, and sessions launched from yaw restore their panes, tabs, and working directories exactly as they were - you reopen the app and your workspace is there. No prefix keys to learn, no server process to manage.
Remotely is where tmux actually matters, and that's where yaw skips the compatibility question entirely: connect over SSH to your Linux box and run tmux there, where it was born. Two yaw features are built around exactly this workflow:
yaw session bastion # SSH in and auto-attach to an existing tmux/screen sessionThe second is the Remote Sessions panel (Ctrl+Shift+R): list every tmux and screen session on the connected host, attach to one, resume a detached one, or kill it - without memorizing a single tmux command. Your local Windows machine stays Windows; the remote server keeps its tmux.
Pros: Local workspace restore with zero configuration; first-class remote tmux/screen management; encrypted local credentials; free tier that runs on your machine.
Cons: Local panes don't detach the way tmux sessions do (persistence is restore-on-relaunch); the remote session panel is for sessions on SSH hosts, not local ones.
Best for: Minimal setups that specifically need real tmux binaries on Windows without a full WSL distro.
MSYS2's pacman -S tmux gives you tmux running under MSYS2's POSIX emulation, and Cygwin has long packaged tmux as well. This is listed last on purpose: it's real tmux, but you inherit the emulation layer's quirks - path translation between /cygdrive-style mounts and Windows paths, clipboard and font friction, and a second package manager to maintain. Cygwin and MSYS2 are perfectly good tools; they're just a lot of machinery to carry so that one program can run.
| Option | Runs on Windows natively | Sessions detach/attach | Local panes | Remote tmux mgmt | Price |
|---|---|---|---|---|---|
| zellij | Yes (MSI, since v0.44) | Yes | Yes | No | Free |
| tmux in WSL | No (inside WSL) | Yes (Linux processes) | Yes | Partial | Free |
| tmux in MSYS2/Cygwin | Emulated | Yes (emulated) | Yes | Partial | Free |
| Windows Terminal | Yes | No (layout restore only) | Yes | No | Free |
| Warp | Yes | No | Yes | No | Free/Paid |
| yaw | Yes | No (restore on relaunch) | Yes | Yes (panel + auto-attach) | Free |
persistedWindowLayout.No. tmux's official installation guide lists binary packages for Linux distributions and macOS only - there is no Windows entry. Your options are Cygwin or MSYS2 packages (MSYS2 ships tmux as pacman -S tmux), where tmux runs as a POSIX-emulated program rather than a native Windows program, or running tmux inside WSL, where it runs fully but only over Linux files and processes.
Yes, natively. Starting with zellij 0.44.0 (March 23, 2026), releases ship x86_64 Windows binaries as a .zip and an .msi installer, so you can install it like any Windows program - no WSL, Cygwin, or MSYS2 required. Windows is the newest of zellij's platforms, having arrived after its macOS and Linux builds.
For pane layout, partially. Windows Terminal splits tabs into panes and can restore your full window layout on restart when the startup action is set to persistedWindowLayout - the layout is saved when the terminal closes, on quit, and after crashes. What it does not have is tmux-style detachment: your commands live inside each pane's process, so when the terminal closes, the processes end. There is no server keeping sessions alive and no client to re-attach to.
If you want sessions that survive closing the terminal, zellij is the strongest native option - it ships an MSI installer, runs without WSL, and does sessions, panes, and windows like tmux. If your tmux habits are actually about remote servers, keep tmux over SSH and pick a Windows terminal with good panes: Windows Terminal (free), Warp (free), or yaw, which also manages remote tmux sessions from a side panel.
Published by Yaw Labs.