TUIOS: A Terminal Multiplexer That Thinks It's a Window Manager

You've probably spent years bouncing between tmux and your desktop window manager, wishing the two could just get along. You want tiling, workspaces, and vim-like keybindings—but you also want to stay in the terminal. TUIOS is a Go-based terminal multiplexer that tries to give you both, and it's worth a look if you've ever felt cramped by the traditional tmux workflow.

Built on the Charm stack (Bubble Tea v2 and Lipgloss v2), TUIOS brings a modal interface to terminal multiplexing. It's not just a tmux clone—it's a window manager that happens to live inside your terminal.

What It Does

TUIOS is a terminal multiplexer and window manager written entirely in Go. It runs inside your existing terminal and gives you multiple terminal panes, nine independent workspaces, and a modal interface that'll feel familiar if you've ever used vim.

The core idea is that you have two modes: a Window Management mode for arranging panes and a Terminal mode for actually typing in them. You get BSP tiling (binary space partitioning, if you're not familiar—it's the same tiling algorithm used by i3 and similar window managers), plus a command palette that's fuzzy-searchable via Ctrl+P.

Under the hood, it's event-driven rendering rather than the traditional redraw-everything approach. That means near-zero idle CPU usage, which is a big deal if you're someone who keeps a terminal multiplexer running for days at a time. It also supports the kitty graphics protocol for flicker-free image passthrough, so if you're working with images in the terminal (or just want a nicer preview experience), that's handled.

There's a daemon mode too, which means you can attach and detach from sessions, and even have multiple clients connected to the same session. There's a JSON control protocol for driving the daemon programmatically, and a scripting system called Tape for automating workflows.

Why It's Cool

The vim-inspired modal approach is the standout feature here. Instead of remembering a dozen prefix-key combinations like you do with tmux, you switch between modes. It's a fundamentally different mental model, and if you're already comfortable with vim's modal editing, it feels natural almost immediately.

• BSP tiling with preselection - You can preselect where a new pane will go before it appears, which gives you the kind of control you'd expect from a desktop tiling window manager. The docs cover split control and tiling in detail, so there's real depth here.

• Nine workspaces with instant switching - Workspace isolation is a killer feature if you juggle multiple projects. Being able to flip between isolated environments without losing context is something tmux handles poorly and TUIOS does as a first-class feature.

• Layout modes beyond just BSP - The README mentions master-stack and scrolling layouts, plus an aggregate view and multifocus. That's more flexibility than most terminal multiplexers offer out of the box.

• Event-driven rendering - This is the kind of engineering detail that matters in practice. Near-zero idle CPU usage means you can leave TUIOS running without it draining your laptop battery or spinning up your fans.

• Extensive theming and hooks - You can customize keybindings, themes, and behavior via configuration. There are built-in themes and custom theme JSON support. Hooks let you run shell commands on window and session events, which opens up automation possibilities.

• Full documentation - This is rarer than it should be in open source. There are dedicated docs for sessions, multi-client setups, the control protocol, and even the architecture. That's a project that takes its user experience seriously.

How to Try It

Getting started is straightforward. If you're on macOS or Linux with Homebrew:

brew install tuios

On Arch, there's an AUR package:

yay -S tuios-bin

Nix users can run it directly:

nix run github:Gaurav-Gosain/tuios#tuios

There's also a quick install script, a Go install option, and a Docker image if you want to test it in isolation:

# Quick install script (Linux/macOS)
curl -fsSL https://raw.githubusercontent.com/Gaurav-Gosain/tuios/main/install.sh | bash

# Go install
go install github.com/Gaurav-Gosain/tuios/cmd/tuios@latest

# Docker
docker run -it --rm ghcr.io/gaurav-gosain/tuios:latest

One thing to check before you dive in: TUIOS requires a terminal with true color support. Kitty graphics and sixel support are recommended, so Ghostty, Kitty, and WezTerm are the sweet spots. If you're still on a basic terminal emulator, you might want to upgrade first.

The full documentation is at tuios.gaurav.zip, and the repository is at github.com/Gaurav-Gosain/tuios. The keybindings doc is a good place to start once you've got it installed.

Final Thoughts

TUIOS is a genuinely interesting take on terminal multiplexing. It's not trying to be a drop-in tmux replacement—it's trying to bring desktop window manager concepts into the terminal, and it largely succeeds. The Go implementation and Charm stack foundation mean it's fast and well-architected, and the event-driven rendering is a thoughtful touch that shows the developers care about the details that matter.

If you're a vim user who's always felt a little friction with tmux's prefix-key model, or if you've wanted proper tiling in your terminal without switching to a terminal-based desktop environment, this is worth a weekend experiment. It's at version 0.7.0, so it's still maturing, but the feature set is already substantial. The docs are thorough enough that you won't be left guessing, and the multi-client and scripting support suggest a project with a solid roadmap ahead.

Follow @githubprojects for more developer tools and open source projects.