Open-source project
Gaurav-Gosain/tuios avatar
Gaurav-Gosain/tuios

TUIOS review: a Go terminal multiplexer with a daemon, BSP tiling and agent panes

Terminal UI OS (Terminal Multiplexer)

6,534 stars322 forksGoMIT

At a glance

What is it?
TUIOS is a terminal multiplexer and window manager written in Go, built on the Charm stack, that adds workspaces, BSP tiling, a session daemon and a JSON control protocol. It is aimed at people who already live in tmux or Zellij and want windows, remote sessions and coding-agent state in the same tool.
Who is it for?
Adopt TUIOS if you want tiling, workspaces and a daemon that survives detach in one binary, and if you are willing to read docs/KEYBINDINGS.md before your first session. Skip it if you need tmux's scripting surface or Zellij's plugin model.
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 received new commits within the last day.
What is it written in?
Mainly Go, 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

  • Gaurav-Gosain/tuios6,534 ★ · +2,819
Star history
Repository2026-09-242026-11-15
Gaurav-Gosain/tuios3.7k6.5k

2,819 Stars in the last 52 days, measured from the daily GitHub snapshot. Compare with other projects

Editorial analysis

What TUIOS solves, and who it is actually for

tmux gives you panes and sessions. It does not give you a command palette or any notion of what the process inside a pane is doing. TUIOS takes that gap as its brief. The README describes it as a terminal multiplexer and window manager that runs inside your existing terminal, with a vim-like modal interface, multiple terminal panes, workspaces, BSP tiling, kitty graphics protocol support and a command palette.

The audience is narrower than "terminal users". The feature list leans toward people running several coding agents at once: agents report their state and message each other, and the Agents docs cover the Inbox, approvals, fleets, other machines, grants and MCP. The daemon also reaches sessions on your other machines. If you run one shell and a text editor, most of this is surface area you will never open.

How TUIOS is put together: PTYs, a daemon and a JSON verb protocol

The mechanism is visible in the repository layout and go.mod. TUIOS is a Go module, github.com/Gaurav-Gosain/tuios, on Go 1.26.8. It depends on charm.land/bubbletea/v2 and charm.land/lipgloss/v2 for the interface, github.com/charmbracelet/x/xpty for pseudo-terminals and charm.land/ssh and charm.land/wish/v2 for the remote side. There is a cmd/ directory, and the Dockerfile builds two binaries from it: ./cmd/tuios and ./cmd/tuios-web.

So the shape is: a TUI client that owns the drawing and input, PTYs underneath it for each pane, and a daemon that keeps sessions alive and can be reached from another machine. The docs folder names a Control Protocol, docs/protocol.md, described as a JSON verb protocol for driving the daemon. That is the piece worth noticing. A daemon with a verb protocol means external programs can drive TUIOS.

The README says the daemon lets the coding agents in your panes report their state and message each other.

Rendering is event-driven, which the README ties to near-zero idle CPU usage. That is a claim from the project, not a measurement.

Installing TUIOS and running a first session

The README lists package managers first. On macOS or Linux with Homebrew, the command is brew install tuios. On Arch, yay -S tuios-bin from the AUR. With Nix, nix run github:Gaurav-Gosain/tuios#tuios. There is also a quick install script, a go install path, a Docker image, and pre-built binaries on the releases page.

The go install route pins nothing, so it takes whatever the latest tagged module is:

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

The Docker route runs the multiplexer as the default entrypoint. The image is built on gcr.io/distroless/static-debian11:nonroot:

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

The same image also contains tuios-web, but the Dockerfile deliberately does not make it the entrypoint. The comment is explicit that tuios-web serves a shell, refuses a non-loopback bind in clear text or with no password on purpose, and refuses --no-auth on a published port, so a container always needs a password (--random-password prints one, --password-file reads one). To run it you name it and pass the host yourself:

bash
docker run --rm -p 7681:7681 --entrypoint /tuios-web <image> \
  --host 0.0.0.0 --auto-tls --random-password

Once installed, the first real use is a session with a pane you can split. The README points to docs/getting-started for install and first session, and to docs/KEYBINDINGS.md for default keys and rebinding. The interface is vim-like and modal, with a command palette.

Updating depends on how you installed. If you used the quick install script or a release binary, tuios update fetches the newest release, and tuios update --check only reports. For every other install, TUIOS detects the package manager and prints the right command rather than overwriting the binary.

The terminal has to cooperate: graphics, true color and where that breaks

Flicker-free kitty image passthrough and kitty graphics protocol support are headline features. On Windows, the built-in console host drops sixel images unless you add conpty.dll and OpenConsole.exe next to tuios.exe.

This is the wrong tool in a few concrete situations. Over a slow ssh link, an event-driven renderer that redraws windows is more to push than a grid of text. Inside a plain xterm or a CI pseudo-terminal, the graphics features have nothing to draw into. And if your work is one long-running process you attach to and detach from, the window manager layer is overhead you will keep ignoring.

There is a second limitation in the Dockerfile itself. tuios-web refuses --no-auth on a published port, so a container always needs a password, and exposing it is a decision the operator makes explicitly on the command line. The project's choice to refuse a non-loopback clear-text bind is a good default, but it also means the web terminal is not something you can casually put behind a port forward and forget.

TUIOS versus tmux and Zellij

The honest comparison is about what each one refuses to do. tmux is a session manager with a scripting language bolted on; you drive it with commands and configuration files, and it has been stable for long enough that its behaviour is predictable across machines. TUIOS inverts that. The window manager is the product, the daemon exists to keep sessions alive and reach them on other machines, and automation arrives through a JSON verb protocol rather than a shell command language. If your existing workflow is a .tmux.conf plus scripts that call tmux send-keys, none of that transfers.

Zellij is the closer comparison, since it also ships a tiling layout, a plugin system and a status bar. The difference in approach: Zellij's extension point is WebAssembly plugins, while TUIOS's is the daemon protocol plus shell hooks (docs/HOOKS.md covers running shell commands on window, session and agent events). Plugins let you build interface inside the multiplexer; hooks and verbs let you react to it from outside. Which one you want depends on whether your customisation is visual or procedural.

Against both, TUIOS's distinctive claim is the agent layer: coding agents in your panes report their state and message each other, with an Inbox, approvals and fleets covered in docs/AGENT_STATE.md.

Maintenance, licence and what an upgrade costs you

TUIOS is MIT licensed, which permits commercial and closed-source use and requires only that the licence and copyright notice travel with copies. That is the whole of the licence implication; anything beyond it is a question for a lawyer, not for this article.

The project is not archived, and the last push was on 2026-11-02. Releases are frequent: v0.11.1 on 2026-10-26, v0.12.0 on 2026-10-30, v0.12.1 on 2026-10-31. The control protocol is documented in the repository (docs/protocol.md).

Upgrade cost is concentrated in two places. Configuration lives in TOML, toml is in the dependency list via github.com/pelletier/go-toml/v2, and docs/CONFIGURATION.md covers keybindings, themes and behaviour; themes can also be custom JSON, per docs/THEMES.md. Any release that renames a config key or a theme field will show up as a broken startup. The second place is the binary itself: if a package manager owns it, tuios update will not touch it, so your upgrade cadence is your package manager's cadence.

Editorial conclusion

Adopt TUIOS if you want tiling, workspaces and a daemon that survives detach in one binary, and if you are willing to read docs/KEYBINDINGS.md before your first session. Skip it if you need tmux's scripting surface or Zellij's plugin model. Verify two things first: that your terminal handles kitty graphics or sixel if you want image passthrough, and which install channel owns your binary, because tuios update refuses to overwrite a package-manager copy and only handles the quick install script or a release binary.

Frequently asked questions

How does TUIOS compare with tmux?

TUIOS is a window manager as well as a multiplexer, with workspaces, BSP tiling and a command palette, while tmux is driven through commands and configuration files. TUIOS automates through a JSON verb protocol for the daemon rather than a shell command language, so existing tmux scripts do not transfer.

How does TUIOS compare with Zellij?

Both offer tiling layouts and a status bar. Zellij extends through WebAssembly plugins, while TUIOS extends through the daemon protocol and shell hooks that run commands on window, session and agent events.

How do I install TUIOS?

The README lists brew install tuios on macOS and Linux, yay -S tuios-bin on Arch, nix run github:Gaurav-Gosain/tuios#tuios with Nix, a quick install script, go install github.com/Gaurav-Gosain/tuios/cmd/tuios@latest, a Docker image, and pre-built binaries on the releases page.

Does TUIOS keep sessions alive after I detach?

The README states that a daemon keeps sessions alive and reaches sessions on your other machines. docs/SESSIONS.md is the reference for daemon mode, attach and detach, other machines, and what survives.

What terminal does TUIOS need?

TUIOS runs inside your existing terminal. The README highlights kitty graphics protocol support and flicker-free kitty image passthrough, and on Windows explains how to let sixel images through by adding conpty.dll and OpenConsole.exe next to tuios.exe.

Official sources

  1. Gaurav-Gosain/tuios on GitHub
  2. License: MIT
  3. Project website
  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/gaurav-gosain-tuios.svg)](https://hysenlabs.com/projects/gaurav-gosain-tuios)

Star history chart for your README

markdown
[![Star history](https://hysenlabs.com/chart/gaurav-gosain-tuios.svg)](https://hysenlabs.com/projects/gaurav-gosain-tuios)

Was this useful?