Before you upgrade, read Breaking changes and migration. The pure Go emulator now reflows lines when a pane changes width.

The full list is at tuios.dev/releases.

Install

brew install tuios                     # Homebrew (macOS, Linux)
yay -S tuios-bin                       # AUR (tuios-web-bin for the web server)
nix run github:Gaurav-Gosain/tuios     # Nix
curl -fsSL https://raw.githubusercontent.com/Gaurav-Gosain/tuios/main/install.sh | bash
go install github.com/Gaurav-Gosain/tuios/cmd/tuios@v0.8.5
docker run -it --rm ghcr.io/gaurav-gosain/tuios:v0.8.5

A binary installed by the script or from an archive updates with tuios update.

New features

• Master position. The master pane can be on the left, right, top or bottom, or in the center (#325). With center, the other panes go to the right and to the left in turn. This closes #321.
  • appearance.master_position sets the side. appearance.master_count sets how many master panes there are (1 to 9).
  • In the layout prefix (Ctrl+B L):
    • o moves the master to the next side.
    • Enter swaps the focused pane with the master.
    • m focuses the master.
    • i and d add and remove a master.
  • tuios set-layout --master-position center --masters 2 changes the current workspace.
  • Each workspace keeps its own side and count, also after a daemon restart.
• herdr plugins. In a pane, herdr's command line now answers through tuios (#328).
  • terminal-browser, terminal-code and the Vim navigation plugins work in a tuios pane.
  • The herdr socket answers 8 more methods: pane.process_info, pane.focus_direction, pane.neighbor, pane.edges, pane.swap, pane.zoom, workspace.focus and agent.start.
  • Every pane gets HERDR_TAB_ID.
  • Each method is held to the grants of the pane that calls it. pane.process_info shows the command line and folder only to a pane that has write.
• Session size. [daemon] window_size sets the size of a session that has more than one client (#330). The values are the values of tmux's window-size option.
  • smallest (the default) works as before.
  • largest uses the biggest client.
  • latest follows the client you typed in last.
  • A client smaller than the session shows the part of the session around the cursor. A mark on the line above the dock says so.
  • tuios set-config daemon.window_size latest -s NAME changes a running session.
  • A read-only tuios-web viewer does not set the size under largest or latest.
• Subagents. A Claude Code agent's rail row shows how many subagents it runs, for example 3 subagents (#307). Thanks to @JakeChop.

Fixes

• Scrollback and resize. Text no longer gets lost when a pane changes size (#331, #333, #323).
  • A narrower pane keeps the end of each line, and a wider pane shows it again.
  • A shorter pane keeps the text below the cursor and the prompt under a full-screen program.
  • A scroll region moves its rows to history.
  • Wide characters stay in history.
  • A daemon restart keeps history rows that are wider than the pane.
• Files list. The sidebar files list now updates when a file is added, removed or renamed (#319, #327). This closes #313.
  • A pane on another machine updates its list when you cd, and when files change on that machine.
  • In a pane that runs ssh, the files section says that the shell is on the other machine.
  • Nothing polls. An idle session stays idle.
• New windows in BSP. A new window now splits the focused pane, on the preselected side when you set one (#349). Before, it always split the last pane, which is the bottom-right one. This answers discussion #347.
  • A preselection now works in daemon sessions too.
  • longest_side reads the size of the pane it splits.
• Zoom in the scrolling layout. Moving to the next column while zoomed no longer shows a gap during the slide (#324).
• Log viewer. The log viewer opens on the newest entry and scrolls to the last entry it draws (#329). Thanks to @davidreuss.
• install.sh on the BSDs. install.sh downloads the right archive on FreeBSD and OpenBSD (#322). Thanks to @fdoving.
• herdr events. A client that subscribes and then acts at once now gets the event (#326).
• Kitty images. An image in a pane started with new-window -- prog no longer disappears when the session state syncs (#343).
• Speed.
  • The terminal emulator reads kitty and sixel image data about 15 times faster (#338).
  • A cropped pane draws about three times faster, and a folder that changes often causes fewer sidebar redraws (#335).

Breaking changes and migration

Reflow

• The pure Go emulator now rewraps the lines on the screen when a pane changes width, as kitty, ghostty and tmux do. Older history keeps the width it was written at.
• On the pure Go emulator, a full-width prompt that is not marked with OSC 133 leaves one extra row each time the pane gets narrower. The ghostty emulator already did this. To stop it, mark the prompt with OSC 133. See the shell recipes in tuios doctor.

herdr

• HERDR_BIN_PATH in a pane now names a link to tuios that answers herdr's command line. Before, it named the tuios binary.
• A herdr plugin that calls $HERDR_BIN_PATH now reaches tuios. To run the real herdr inside a tuios pane, set [agents] herdr_protocol = "agents" as before.

Layout keys

• o, Enter, m, i and d in the layout prefix are new defaults. If your [keybindings.layout_prefix] already binds one of these keys, your binding wins.

Claude Code subagents

• The subagent count needs version 3 of the Claude Code integration. Run tuios integration status. If it reports the integration as out of date, run:

  tuios integration install claude-code
  

Mixed versions

• The session size policy, the herdr command front, the files list for panes on other machines, the subagent count and master positions need a v0.8.5 daemon. To start a v0.8.5 daemon, run tuios kill-server after the upgrade. This closes every pane in every session, so save your work first.
• An older client in a session under latest or largest makes the session use smallest until it leaves.

Contributors

Thank you to everyone who sent a pull request for this release:

• @JakeChop: subagent count on the rail (#307)
• @davidreuss: log viewer scroll (#329)
• @fdoving: install.sh on FreeBSD and OpenBSD (#322)

Thanks to @adamcstephens for the master position request (#321), and to @LovesAsuna for the files list reports (#313) and the BSP report (#347).

Before you upgrade, read Breaking changes and migration. Every pane now gets herdr's variables, and the scratch terminal keys changed.

The full list is at tuios.dev/releases.

Install

brew install tuios                     # Homebrew (macOS, Linux)
yay -S tuios-bin                       # AUR (tuios-web-bin for the web server)
nix run github:Gaurav-Gosain/tuios     # Nix
curl -fsSL https://raw.githubusercontent.com/Gaurav-Gosain/tuios/main/install.sh | bash
go install github.com/Gaurav-Gosain/tuios/cmd/tuios@v0.8.3
docker run -it --rm ghcr.io/gaurav-gosain/tuios:v0.8.3

A binary installed by the script or from an archive updates with tuios update.

New features

• Scratch layouts. The scratch terminal is a small layout of its own (#303). Ctrl+B g shows and hides all of its panes together.
  • Split, move, resize and zoom its panes, as on a workspace. The window keys act inside the box.
  • The mouse acts on the panes inside the box. A click outside the box hides it.
  • Each scratch command key has its own layout. One layout is on the screen at a time.
  • tuios xpanes from a scratch pane opens its panes in the scratch layout.
  • After a daemon restart, each layout comes back hidden, with its panes and their history.
• Picture-in-picture. p in window mode pins the focused pane to a corner of the screen as a small live view (#284). Press p again to unpin it.
  • The view moves to a different corner when the line you type reaches it.
  • A click on the view goes to its pane.
  • tuios pip [window] [--off] pins a pane from a script.
  • [pip] sets width, height and corner.
• Pane history. After a daemon restart or a reboot, a restored pane shows its old history above a dim divider (#274). The new shell starts under it.
  • [daemon] persist_scrollback turns this on or off. The default is true.
  • persist_scrollback_lines (default 1000) and persist_scrollback_kb (default 2048) set the limits for one pane.
• Sixel images. A pane's sixel image shows on the host, cut to the visible part of the pane (#282, #283).
  • Popups, borders and clear act on the image as they act on text.
  • A host with kitty graphics and no sixel gets a kitty image. A host with neither shows a box.
  • A pane is told about sixel only when the host draws it. chafa, timg, lsix and yazi then use their text fallback on other hosts.
  • This works in daemon mode, over tuios ssh and in tuios-web.
• Image paste. Ctrl+B V pastes the image on your clipboard into the focused pane as a file path (#306).
  • tuios saves the image on the machine where the pane runs. This also works for a pane on a host.
  • The paste key does the same when the clipboard holds only an image.
  • tuios deletes a pasted file after one hour.
• xpanes. tuios xpanes opens one pane for each item on a new workspace, with multifocus on (#289, #308).
  • Items come from the arguments or from stdin. -c 'cmd {}' runs a command for each item.
  • -s and -ss are speedy modes, as in tmux-xpanes. --interval waits between panes.
  • -l sets the layout: tiled, even-horizontal or even-vertical.
• Close a workspace. The action close_workspace and tuios close-workspace [N] close every pane on a workspace (#308). The action asks first.
• Copy pipes. appearance.selection.copy_command sends each yank in copy mode through a command (#288).
  • A [[keybindings.copy_pipe]] entry binds a copy mode key to a command.
  • The command gets the selection on stdin. Its output goes to the clipboard.
  • When the command fails, the clipboard gets the selection.
• Tiling scheme. appearance.tiling_scheme sets the BSP scheme of a new workspace (#295).
  • The values are spiral, longest_side, alternate and smart_split. The default is spiral.
  • cycle_tiling_scheme and the set_tiling_scheme_* actions change the scheme of the current workspace. They have no default key.
• herdr socket API. The tuios herdr socket answers herdr's socket API (#301).
  • herdr's CLI, Collie's herdr adapter and other tools for herdr work in a tuios pane.
  • Each method checks the grants of the pane that calls it.
• herdr reports. tuios accepts all of herdr's agent protocol in every pane (#287).
  • A Crush that you start from a shell prompt reports its state.
  • tuios accepts pane.report_metadata and notification.show.
  • An agent that crashes no longer keeps its state. The pane clears when it is back at its shell prompt.
  • When herdr's hook script and tuios's integration report for one agent, tuios's integration wins.
• tmux shim. The tmux shim answers the calls that Collie and other tools make (#298).
  • New commands: load-buffer, set-buffer, paste-buffer, delete-buffer, list-clients, show-options and show-window-options.
  • Control mode (-C and -CC) sends events for sessions, windows and panes.
  • Outside every pane, the shim serves every session.
• Verbs for adapters. These help a tool that drives tuios through the verb socket (#302).
  • capture-pane and list-windows report history_rows and revision.
  • The new verb list-keys lists the key names that send-keys accepts. The new key Comma sends a comma.
  • subscribe sends a workspace-renamed event.
  • A session keeps its id across a daemon restart.
• Command key recipes. KEYBINDINGS.md has five recipes for command keys (#272).

Fixes

• Focus after a close. When you close the focused pane, the focus goes to the pane you used last on that workspace (#286).
• Kitty Unicode placeholders. tuios reads a=T with U=1 as a virtual placement (#300). NTCharts shaders no longer flicker.
• superfile previews. superfile image previews show in the right place (#297). The fix also covers kitten icat with placeholders and hosts with 256 colours.
• Scratch commands. A scratch command key works again on the press after a "stopped with exit code" message (#271).
• set-agent-state. From inside a pane, tuios set-agent-state with no --window marks the pane that runs it (#302).
• Screenshots. A capture file never shows as an empty file while tuios writes it (#296).
• Speed. Panes that print many short lines use less CPU (#276). Each tuios command starts faster (#275).
• tuios-web. The tuios-web binary is about 260 KB smaller (#277).

Breaking changes and migration

herdr

• Every pane now gets HERDR_ENV, HERDR_SOCKET_PATH, HERDR_PANE_ID, HERDR_WORKSPACE_ID and HERDR_BIN_PATH. [agents] herdr_protocol now defaults to always.

• With this default, herdr refuses to start inside a tuios pane. To run herdr in a tuios pane, set this in config.toml:

  [agents]
  herdr_protocol = "agents"
  

• HERDR_PANE_ID now has herdr's form, w<session>:p<window>. A report with the window id still works.

Scratch terminal

• Esc no longer hides the scratch terminal. Press Ctrl+B g to hide it.
• The close key closes a pane of the scratch terminal. When you close the last pane, the scratch terminal ends.
• The window keys act inside the scratch terminal. Before, a move, resize or tile key hid it.

Pane history

• The daemon now saves the history of each pane in the state folder. The files hold what your panes printed, secrets included. To stop this, set persist_scrollback = false in [daemon]. The next daemon start deletes the saved history.

Mixed versions

• Scratch layouts, pane history, image paste, tuios pip and the herdr socket API need a v0.8.3 daemon. To start a v0.8.3 daemon, run tuios kill-server after the upgrade. This closes every pane in every session, so save your work first.
• While a client of an older tuios is attached, the scratch terminal is one pane in a popup, as in v0.8.2.

Contributors

Thank you to everyone who sent a pull request for this release:

• @Tim4c: focus goes to the last used pane after a close (#286)
• @neomantra: kitty Unicode placeholder images (#300)

The full list is at tuios.dev/releases.

Install

brew install tuios                     # Homebrew (macOS, Linux)
yay -S tuios-bin                       # AUR (tuios-web-bin for the web server)
nix run github:Gaurav-Gosain/tuios     # Nix
curl -fsSL https://raw.githubusercontent.com/Gaurav-Gosain/tuios/main/install.sh | bash
go install github.com/Gaurav-Gosain/tuios/cmd/tuios@v0.8.4
docker run -it --rm ghcr.io/gaurav-gosain/tuios:v0.8.4

A binary installed by the script or from an archive updates with tuios update.

Fixes

• xpanes. In v0.8.3, tuios xpanes with no -s typed every command into the first pane, and no command ran (#310).
  • Each command now goes to its own pane.
  • tuios waits for the shell prompt of the pane before it types the command.
  • With -ss, a pane closes when its command ends, also when no client is attached.
• Untrusted text. The untrusted content fence removes every invisible character (#314).
  • This adds the line and paragraph separators, the soft hyphen, the tag characters, the variation selectors and the other format characters.
  • A line or paragraph separator becomes a line break.
  • A zero-width joiner stays only between two emoji.
  • Mail, replies, captures from a host, notifications, agent titles and approval lines use the same rule.
• herdr socket. A caller over the connection limit gets a rate_limited answer. Before, its write sometimes failed with a broken pipe (#315).
• Pane capture. Two waits on one pane no longer race when they read its screen (#315).
• Homebrew. The casks use postflight_steps. Homebrew no longer shows a deprecation warning on install or upgrade (#311).

Upgrade

The fixes to -ss, the fence and the herdr socket are in the daemon. To start a v0.8.4 daemon, run tuios kill-server after the upgrade. This closes every pane in every session, so save your work first.

Thanks

Thanks to @Gsirawan for reporting the invisible characters that passed the fence (#312).

Before you upgrade, read Breaking changes and migration. A session rename now changes the name of the session.

The full list is at tuios.dev/releases.

Install

brew install tuios                     # Homebrew (macOS, Linux)
yay -S tuios-bin                       # AUR (tuios-web-bin for the web server)
nix run github:Gaurav-Gosain/tuios     # Nix
curl -fsSL https://raw.githubusercontent.com/Gaurav-Gosain/tuios/main/install.sh | bash
go install github.com/Gaurav-Gosain/tuios/cmd/tuios@v0.8.2
docker run -it --rm ghcr.io/gaurav-gosain/tuios:v0.8.2

A binary installed by the script or from an archive updates with tuios update.

New features

• Scratch terminal. Ctrl+B g shows a scratch terminal in a popup over the current layout. Press Ctrl+B g again to hide it.
  • Each session has one scratch terminal. The shell keeps running while the terminal is hidden.
  • The shell starts in the folder of the focused pane. The terminal opens on the workspace you are on.
  • The scratch terminal is shown only while it has the focus. A click outside it or a focus on a different pane hides it.
  • Esc in window mode, the close key and the close button hide it. tuios kill-window closes it.
  • The mouse does not move or resize it. Window keys do not act on a different pane from inside it.
  • The dock, the sidebar and the tiled layout do not show it. tuios list-windows --json marks it with "scratch": true.
  • It stays when you detach. After a daemon restart, it comes back hidden with a new shell.
  • [scratch] sets width and height, in cells or percent. The default is 80%.
• Command keys. A [[keybindings.command]] entry binds a key to a command that you write.
  • type is scratch, popup, pane or shell. The default is popup.
  • A scratch entry is a popup that stays, as the scratch terminal does. Each entry has its own popup.
  • A key that starts with prefix+ works after the leader. Any other key works in window mode and in terminal mode.
  • The command runs with sh -c in the folder of the focused pane.
  • The command gets TUIOS_SESSION, TUIOS_SOCKET, TUIOS_ACTIVE_PANE_ID and TUIOS_ACTIVE_PANE_CWD.
  • The command palette lists each entry. tuios keybinds list shows them under Commands.
  • tuios keybinds doctor shows an entry as dead when its key is taken. A command key never takes a key from a tuios action or the leader.
  • When a scratch command stops in its first moments, the dock shows its exit code.
• Hints on all panes. The new action hints_all_panes puts labels on all panes that the workspace shows. It has no default key.
  • The focused pane gets the shortest labels.
  • tuios gives no label to text that you cannot see.
  • Set hints.all_panes = true to make Ctrl+B F put labels on all panes.
• Sidebar file editor. Shift+Enter on a file in the sidebar opens it in a new pane with an editor.
  • Set the editor under Settings, Sidebar, File editor. With no editor set, tuios uses $EDITOR.
  • The context menu of a file has an Edit row.
  • For a session on a different machine, the dock names the editor and the machine.
• File search. Ctrl+B f searches file names below the folder of the focused pane. Ctrl+F searches below the folder that the sidebar shows.
  • Type a name or a relative path and press Enter. The sidebar opens the folder and selects the file.
  • The search skips build folders and stops after a time limit.
• Session rename. The new command tuios rename-session [session] <new-name> changes the name of a session in the daemon.
  • The session picker, the sidebar and the rename key use it too.
  • tuios ls lists the new name. The state file, mail and Inbox items move to the new name.
• Workspace cycling. The actions next_workspace and prev_workspace now work. They have no default key.
  • They skip empty workspaces and wrap at the ends.
  • They also work in terminal mode.
• Attach flags. tuios attach --hold now works for a local session. --terminal-mode starts the client in terminal mode.

Fixes

• Kitty graphics. tuios holds the images of a pane until the pane ends its synchronized update (#247, #249, #250).
  • The Magick Arena demo and terminal-browser do not flicker.
  • A move, resize or zoom of a pane moves its image at once.
  • A hold ends after 1 second or when the pane holds too much data.
• Status reports. A pane answers CSI 5 n with CSI 0 n and CSI ? 5 n with CSI ? 0 n (#257). ratatui-image no longer waits forever.
• Input method text. Text from an input method reaches a pane that uses the kitty keyboard protocol as text (#259). This fixes CJK punctuation, ideographs and emoji in Claude Code.
• OSC 66. A program that sends OSC 66 text sizing, such as opencode, does not break the title bar of its pane (#245).
• OSC 99. Builds with the ghostty backend now show OSC 99 notifications (#242).
• macOS ghostty builds. The release now includes macOS archives with the ghostty backend (#244).
• tuios-web. sip v0.8.3 fixes a race when a web session closes (#246).
• keybinds list-custom. The command finds a rebind in every [keybindings] section (#261). Before, it looked at nine sections only.
• Nested tuios.
  • The daemon answers a kitty frame edit in order with its other replies. The reply no longer reaches a nested shell as keys.
  • The daemon refuses frame edits unless every attached client supports them.
• Popups. A popup command starts at the size of the popup.
• Hints. tuios gives no label to text that a different pane or the screen edge hides.

Breaking changes and migration

Session rename

• The session picker, the sidebar and the rename key now change the name of the session. Before, they changed a display label only.
• A process that runs in a pane keeps the old TUIOS_SESSION. tuios commands with the old name still reach the session.
• tuios attach with the old name fails. The message names the new name.
• tuios set-session-name still sets a display label. tuios ls shows the label beside the name.

Mixed versions

• The scratch terminal, command keys of type scratch and session rename need a v0.8.2 daemon. To start a v0.8.2 daemon, run tuios kill-server after the upgrade. This closes every pane in every session, so save your work first.

Contributors

Thank you to everyone who sent a pull request for this release:

• @alepspizzetti: sidebar file editor and file search (#258)
• @davidreuss: workspace cycling actions (#267)
• @NotAFlightRisk: keybinds list-custom in every section (#261)

The security advisory is GHSA-jf76-3ff5-gjjv. Thanks to JakeChop for reporting the issues.

Before you upgrade, read Breaking changes and migration. Some commands and configs that worked in v0.8.0 are refused now.

Install or upgrade

brew install tuios                     # Homebrew (macOS, Linux)
yay -S tuios-bin                       # AUR (tuios-web-bin for the web server)
nix run github:Gaurav-Gosain/tuios/v0.8.1#tuios
curl -fsSL https://raw.githubusercontent.com/Gaurav-Gosain/tuios/main/install.sh | bash
go install github.com/Gaurav-Gosain/tuios/cmd/tuios@v0.8.1
docker run -it --rm ghcr.io/gaurav-gosain/tuios:v0.8.1

A binary installed by the script or from an archive updates with tuios update. Release binaries are on the GitHub release.

The release has macOS archives of the libghostty-vt build for Apple silicon and Intel (tuios-ghostty_0.8.1_Darwin_*). The v0.8.0 release had none, because the macOS build failed to link.

Security fixes

Remote access

• tuios ssh keys. tuios ssh does not accept a key that has options, such as command=, from= or restrict. tuios cannot apply these options, so it refuses the key. The log names the line of each refused key.
• tuios ssh keys file. tuios ssh reads only ~/.config/tuios/authorized_keys. It does not read ~/.ssh/authorized_keys unless you name that file with --authorized-keys. See tuios ssh.
• tuios-web passwords. tuios-web can ask for a password. Use --random-password, --password-file or the TUIOS_WEB_PASSWORD environment variable. --user sets the user name. The default user name is tuios. See Who can connect.
• Host header. On localhost, tuios-web accepts a session only when the Host header names this machine. Use --allow-host to add the name of a reverse proxy.
• Empty --host. An empty --host listens on every interface. tuios ssh and tuios-web now apply the rules for a network address to it.
• pprof. --pprof :6060 listens on 127.0.0.1 only. To listen on every interface, give 0.0.0.0:6060.
• Worktree patches. tuios worktree pull keeps a patch that did not apply in a new file with a random name. Only you can read the file. The message shows its path.

Pane grants

• More callers check the grants. Pane grants now cover the link sockets, the tmux shim's pane holder, prompts, send-keys, run-command and typing through the client protocol. See What a pane may do.
• Prompts. A pane without the respond grant cannot type into another pane that waits on a prompt. This applies to a pane with admin too.
• send-keys with PREFIX. send-keys with PREFIX from a pane is refused. The message names the commands to use instead.
• Inbox answers. The Inbox refuses answers that send-keys typed. This covers the digit keys, the second press of a risky allow, question answers and the release of held mail.
• Link sockets. A process inside a pane, or a process that the daemon started, cannot connect to a link socket.
• Wider grants wait. A config.toml change that widens [agents.permissions], [hosts] or a link policy waits for tuios config apply. Run it from a terminal outside tuios. A daemon restart also applies it. See Changes that wait.
  • A change that narrows these tables applies at once.
  • The Inbox shows an item when a change waits. tuios pane-grants and the log say so too.
  • A daemon start that finds wider grants than the last run says so in the log, in tuios pane-grants and in the Inbox.
  • A host that you add with "Add a host" on the settings page applies at once.
• ssh_options. A host's ssh_options accepts only safe options, each with one plain value, written as -o Keyword=value. See Rules for ssh_options.
  • tuios drops a host with a refused option. The Inbox and tuios hosts name the reason.
  • ProxyCommand, LocalCommand, the known hosts files, ControlPath and -F are refused.
  • Port forwards (-L, -R, -D) are refused.
  • -J and ProxyJump take host names only. ForwardAgent takes only yes or no.
  • A host addr or command cannot start with a dash.

Pane output

• Clipboard writes. The new option appearance.selection.osc52_write controls what OSC 52 from a pane does. The values are off, ask, focused and on. The default is focused. See Clipboard writes from a pane.
  • With focused, the focused pane sets the host clipboard. A write from another pane shows a message in the dock. Click the message to copy the text.
  • Each pane keeps one clipboard ask. A click copies only the text that the dock shows.
• Control characters. Pastes, notifications, OSC 66 text and link addresses lose their control characters. Tabs and line breaks in a paste stay.
• Clipboard replies. tuios drops a clipboard reply that answers no read request of tuios.
• Kitty graphics files. A kitty graphics file must belong to you, and its path must be absolute. tuios does not read from /proc, /sys or /dev, other than /dev/shm. A t=t file name must hold tty-graphics-protocol.
• "cd here" and layout load. These type a cd only into a pane whose shell is at its prompt. In daemon mode, the daemon does this check.
  • tuios types no cd for a folder whose name holds a quote, a backslash or a control character. The dock says when it did not type.
  • Layout load starts each new window in its folder. It does not type a cd into a new window.

New features

• Hints mode. The leader and F label the copyable text on the focused pane, such as URLs, paths, hashes and IP addresses. Type a label to copy its text. See Hints.
  • Shift and a label also types the text into the pane. Ctrl and a label opens a URL or a local path.
  • The [hints] table sets the patterns, the label alphabet, the open command and the dim.
• Multi copy mode. The copy mode key enters multi copy mode when the focused pane is in a multifocus set of two or more panes. See Multi copy mode.
  • Each pane gets its own cursor and selection. A search moves each pane to its own match.
  • y copies the selection of each pane. Tab cycles the format. Y writes the text to a new file.
  • appearance.selection.multi_format sets the format: plain, markdown or json.
• Multifocus.
  • A paste goes to every pane in the multifocus set.
  • The new actions toggle_multifocus_active and toggle_multifocus_all put panes in the set or take them out. They have no default key.
  • With appearance.dim_unfocused on, panes in the set are not dimmed. Set appearance.dim_multifocus to dim them again.
• Copy mode.
  • Copy mode starts on the terminal cursor. Set appearance.selection.copy_entry = "center" to start on the middle row.
  • / searches forward and ? searches back. n repeats the search in its direction, and N goes the other way.
  • The new actions copy_mode_search_forward and copy_mode_search_backward enter copy mode and open the search. They have no default key.
• Focus with j and k. In window mode, j and k move focus down and up. A config that already binds j or k there keeps its binding.
• Agent mail.
  • The mailbox shows each message body inside an untrusted content fence. Each thread shows its id.
  • n in the mailbox writes a new message to an agent in the session.
  • The new [notifications.mail] table controls mail alerts.
• Other machines.
  • Results from another machine are marked as untrusted. capture-pane takes --json.
  • send-agent-message --attach to a host puts each file in the far session's stash.
• Agents. tuios reports the state of oh-my-pi. The detection commands report the age of their evidence.
• Keyboard layouts. Bindings match the physical key under any keyboard layout, non-Latin layouts too.

Fixes

• Nested attach. tuios refuses to attach a session from inside its own pane, or from a pane of a session that shows it. tuios attach --force skips the check. See Nested attach.
  • A terminal window that you start from a pane can attach.
  • New panes do not get the variables of an outer tuios pane.
• Layout sync. Clients send each change to the BSP tree to the daemon, which applies and numbers it (#230). Two clients that change one layout at the same time now end on the same layout. A v0.8.0 client in the same session still works.
• Focus. The neighbour search steps to a pane that shares only one row with the focused pane. It does not step to a diagonal pane.
• Global sessions.
  • The session switcher switches between sessions on other machines.
  • A machine pick goes to the daemon that can act on it.
  • One link carries more than fifteen remote panes.
• Nix. The Nix package builds again with the correct vendor hash. CI checks the hash on every dependency change.
• Keys.
  • Keypad keys, Begin and F13 and above reach the pane.
  • The leader pressed twice sends the configured leader to the pane.
  • Modifier aliases work in the leader key and in every key entry.
• Web client. The web client gets the last output of a pane.
• Also fixed. The copy sweep runs at the frame rate. The session rail fits narrow rows. Focus survives a stale push from another client.

Breaking changes and migration

tuios ssh

• tuios ssh does not start when there is no keys file. This applies to localhost too. Before, a server on localhost with no keys file let every connection in.
• If your key is only in ~/.ssh/authorized_keys, tuios ssh does not use it now. Do one of these:

  • Add your public key to ~/.config/tuios/authorized_keys:

    mkdir -p ~/.config/tuios
    cat ~/.ssh/id_ed25519.pub >> ~/.config/tuios/authorized_keys
    

    Use your public key file if it has a different name.

  • Start with --authorized-keys ~/.ssh/authorized_keys. tuios does not apply the rules in sshd_config to these keys.

  • Start with --no-auth. Then every user on this machine can connect, or everyone who reaches the port on a network address.

• A key with options in the keys file is not accepted. Add the key again with no options if it must open a tuios session.

tuios-web

• A bind to an address other than localhost needs a password. --auto-tls or --cert alone is not enough, because TLS does not check who connects. Add --random-password or --password-file, or add --no-auth on a network you trust.
• --allow-host needs a password or --no-auth. It works only with a loopback --host. Give the host name with no port.
• On localhost with no password, tuios-web still starts. It prints one line to say that other users on this machine can connect.
• The password file must belong to you, with mode 600 or 400.

Pane grants

• Prompts. A pane that types into another pane's prompt needs the respond grant. admin does not include it. To give it to one pane, use tuios set-pane-grants or --grants.

• send-keys with PREFIX. A script in a pane that sends PREFIX fails now. Use the tuios command for the action instead, such as focus-window, new-window or split-window.

• send-keys with no window. From a pane, send-keys with no window types into the focused pane. tuios does not read these keys as key bindings.

• run-command. From a pane without respond, run-command cannot type or press keys. Use send-keys or send-text with -w.

• Config changes that widen. A change that widens [agents.permissions], [hosts] or a link policy waits. Run this from a terminal outside tuios:

  tuios config apply
  

  tuios hosts add from a pane also waits for it.

ssh_options

• Look in the Inbox or run tuios hosts after the upgrade. A host with a refused option is dropped.
• Move a refused option, such as ProxyCommand or LocalForward, into ~/.ssh/config. Then name that host in addr.
• Keep port forwards (-L, -R, -D) in ~/.ssh/config.
• Write each option as -o Keyword=value, with one value and no quotes.

Clipboard and folders

• OSC 52. A program in a background pane cannot set the host clipboard without a click. To get the v0.8.0 behaviour, set appearance.selection.osc52_write = "on".
• "cd here" and layout load. tuios types no cd into a pane that runs a program. Go back to the shell prompt and try again.
• Mixed versions. A v0.8.1 client with a v0.8.0 daemon types no cd into a daemon pane. To start a v0.8.1 daemon, run tuios kill-server after the upgrade. This closes every pane in every session, so save your work first.

Thanks

Thank you to everyone who sent a pull request for this release:

• @masshirodev: keypad keys, Begin and F13 and above (#195).
• @nathan-poncet: chords read by the key they type (#209).
• @fonnesbeck: oh-my-pi agent state (#223).

Thanks to JakeChop for reporting the security issues.

2,411 commits in the six months since v0.7.0. If you already run tuios, read Install or upgrade first: the daemon must be restarted, some keys changed, and an existing config keeps running without the daemon until you turn it on.

In short

• Agents: a live state for every agent pane, an Inbox for approvals, questions, mail and finished turns, a review of what an agent changed, one prompt fanned out across git worktrees, and grants that limit what a pane may do.
• Sessions come back after a daemon restart or a reboot, and every client of a session sees one layout.
• Other machines: attach a session on another machine, or open a single pane there, over plain ssh.
• The interface: a scrolling layout, a zoom camera, a rail with files and git, a launcher, a keybind manager, the mouse everywhere, and chrome drawn for each colour depth and for light themes.
• Scripting and control: 97 JSON verbs, 167 options you can set live, an event stream, an MCP server and a tmux shim.
• The web client, SSH and project tapes.
• The terminal emulator: a second backend and a conformance suite.
• Faster and smaller, with the measured numbers, and hardening.
• Upgrading from v0.7.0: every change that can break a config, a key or a script.

Install or upgrade

# Homebrew (brew upgrade tuios to update)
brew install tuios

# The install script, which puts the release binary on your PATH
curl -fsSL https://raw.githubusercontent.com/Gaurav-Gosain/tuios/main/install.sh | bash

# Update a release binary, or one the install script put there
tuios update

# Arch Linux (AUR), Nix, Go and Docker
yay -S tuios-bin
nix run github:Gaurav-Gosain/tuios#tuios
go install github.com/Gaurav-Gosain/tuios/cmd/tuios@latest
docker run -it --rm ghcr.io/gaurav-gosain/tuios:latest

Release binaries for Linux, macOS, Windows and FreeBSD are on the GitHub release. tuios update checks the download against the release checksums, and it replaces only a binary that came from a release archive. For any other install it names the command to run instead. Homebrew updates its formula after the release, so brew upgrade can take a day to offer 0.8.0. See Getting started for more.

Then, if you ran v0.7.0:

1. Restart the daemon. Run tuios kill-server, then tuios. The v0.7.0 daemon speaks an older wire protocol and is refused. This ends the programs in its sessions, and v0.7.0 saved no layouts, so note what you want to keep first.
2. Turn on the daemon, if you want it. An existing config file keeps running tuios standalone and floating. Add daemon = true and tiled = true under [startup] to get restore and tiling (details).
3. Install the agent integrations if you run coding agents: tuios integration install --all, then tuios doctor agents to check. If you installed them from a build of main, run the same command again: tuios integration status says which are out of date.
4. Read Upgrading from v0.7.0 for the keys, config keys and script behaviour that changed.

The look

The clips on this page show the default look of v0.8.0: the rail on the right, the dock and the window titles at the top, and zoom at 95 percent so the layout stays in view around a zoomed pane. They were recorded a few days before the release, so a few details of the chrome are newer than the clips: the command palette's category headers, the sectioned which-key menu, the dim behind dialogs, and the Inbox in place of the mail dialog. Defaults lists every default that changed, and how to keep the old look.

Agents

The rail shows what your agents are doing

Every pane running one of 23 recognised agent CLIs (Claude Code, Codex, Gemini CLI, opencode, Copilot, Amp, Cline, Qwen, Crush, goose, pi and more) gets a live state: working, needs input, finished, errored or idle. The rail's agents section lists every agent in every session in four groups: needs you, finished and not yet seen, working, and at rest. Inside a group, rows keep the order the panes were opened in, so a row moves only when its group changes. A blocked agent's row shows the question it asked and how long it has waited. Rows also show the harness, what the agent is doing, and facts it reports such as the model, how full its context is and what it has cost.

1. Every agent in every session is in one list in the rail.
2. Finished work waits for you, marked unread.
3. A blocked agent moves to the top of the list, with its question.
4. @n in the command palette finds the pane that needs you.
5. Answer it, and the agent goes back to work.

• In the command palette (ctrl+p), @n finds panes that need input and @w finds working ones, across every session. ctrl+b j jumps to the pane behind the last alert.
• When a state changes, tuios can tell you with a dock message, an OSC 9 desktop notification (which reaches you over SSH) and an optional sound. The [notifications.agent] table has per-state switches, a settle window so a flapping state does not spam you, and quiet hours.
• Alerts know where you are looking. With notifications.agent.suppress_focused on (the default), an alert about the pane you are looking at is held back. tuios now asks your terminal whether its window has focus, so when you switch to another application the alert fires even for the focused pane. A terminal that does not report focus counts as looking, as before.
• The after-agent-state hook receives the transition in environment variables, never in argv, so an agent's text cannot become shell arguments.
• tuios set-agent-meta -w api model=opus context=41% records facts the rail draws under the row. They never change the state.
• A person who never runs an agent sees none of this. The agent rows in the prefix menu, the palette and the help stay hidden until an agent has been seen.

Hooks, installed for you

tuios integration install claude-code writes tuios's hook entries into Claude Code's settings, so the agent reports its own state instead of tuios reading it off the screen. The hooks run tuios agent-hook <harness>, with no Python. Eighteen harnesses are covered. Claude Code, Codex, Gemini CLI, opencode, Kilo, Amp, Kimi Code CLI, Pi, Copilot, Cursor Agent and Qwen Code report their full state; seven more report the conversation id and leave the state to the screen rules. --all installs every harness whose config directory exists, and uninstall and status undo and check them. tuios doctor agents says, for every harness, whether it is on PATH, whether the integration is installed and current, and which running agent panes lack one.

• Crush reports its state over herdr's pane state protocol, which tuios now speaks. [agents] herdr_protocol (agents by default, always or off) picks which panes are told where to send it.
• A pane that starts Codex directly gets TERM_PROGRAM=WarpTerminal, so Codex sends its notifications as OSC 9 with their text instead of a bell. A shell pane keeps TUIOS.
• goose is recognised where its own installers put it. It has no hook integration yet, and tuios doctor agents says so.

Detection

• State comes from six ranked sources: the agent's own hook report, its transcript, escape codes and window titles (such as Codex's "Action Required"), screen rules that read the prompt, the foreground process, and last of all an output stall. A lower source never overwrites a higher one that is still fresh.
• Agent CLIs are described by TOML manifests, bundled and overridable. tuios explain-agent-detect shows why a pane was or was not recognised. The rules have nested all_of, any_of and none_of groups, enough to carry 128 of herdr's 141 detection rules as written.
• A process is identified by what it calls itself: its name, argv[0], its executable, or the script an interpreter runs. A directory called claude is no longer an agent. An agent started through sh -c, timeout, npx, uvx, mise or nix is found. This works on macOS without cgo.
• The transcript reader reads only the last 128KB, so a 151MB transcript costs 652 microseconds.
• Agents in panes on other machines are detected too.

The Inbox

ctrl+b i opens the Inbox: one list of everything waiting for you, in every session and on every linked machine. Items are grouped under Approvals, Questions, Mail, Errored and Finished, oldest first, and each one closes by itself when what it is about stops being true. ctrl+b o goes to the oldest item that needs you, and pressed again walks the rest. ctrl+b O does the same for finished turns nobody has looked at.

• From the Inbox you can go to the pane, reply to mail with r, dismiss, snooze, undo a dismiss or snooze within ten seconds, and mark a finished turn unread.
• Peek and answer. Space on an approval or a question shows the prompt as the pane draws it, and a digit, a, A or d answers it without leaving the Inbox. A key typed by send-keys, run-command or a tape never answers.
• Approvals held for you. With [agents.approvals] enabled = ["claude-code"] (or opencode, kilo, qwen), the hook holds a permission prompt and puts it in the Inbox, where 1 allows once, 2 always, 3 denies and n denies with a reason the model reads. It is off by default. The hold ends after hold_seconds (120 by default) or when you go to the pane, and then the harness asks in its pane as before. A failure never approves.
• Risk rules. An approval that matches a rule (recursive delete, force push, hard reset, pipe to shell, sudo, a write outside the worktree and others, plus your own in [agents.approvals.risk]) reads risky: and needs a second press to allow. The rules are a speed bump, not a sandbox.
• Plans. Claude Code's plan approval is held as a plan, shown whole, and can be approved only once its last line has been on screen.
• Questions from an agent. tuios ask-human puts a question with up to nine answers in the Inbox and waits. If nobody answers in time, the answer is mailed to the asking pane later.
• The same data is tuios list-attention, and tuios peek-prompt and tuios respond read and answer a blocked prompt from a shell.

See Inbox and Review.

Reviewing what an agent changed

ctrl+b v on a pane, or v on an Inbox item or a rail agent row, opens a full-screen review of the pane's git changes: the files beside the diff, syntax highlighted, in a split layout when there is room. The diff is drawn for your terminal's colour depth, so it reads the same in a truecolor terminal, over mosh and in a 16-colour console. Leave notes on lines and send them to the agent as one message with S. For a pane in a fan, w compares every attempt: agent, state, lines changed and the last check. tuios review prints the same diff, and tuios agent-log shows what an agent has been doing: prompts, tool calls and their results, finished turns, and the commands its shell ran.

Agents can message each other, and you

tuios list-agents                      # every agent pane and its state
tuios send-agent-message -w build 'rebased onto main, please retest'
tuios read-agent-messages              # your own inbox
tuios ask-agent -w review 'which test is flaky?'   # ask and wait

The person at the keyboard has a mailbox called human. An agent writes to it with tuios send-agent-message -w human '...', the dock shows it, and ctrl+b M opens the Inbox on its mail from any pane. r replies, and the agent reads the answer from its own inbox. Mail sent as human is marked verified only when it comes from your own client; anything else is marked as a claim.

Recorded before the Inbox landed. ctrl+b M now opens the Inbox on its mail, and r still replies.

1. Two agents at work. One of them needs a decision.
2. It asks you with tuios send-agent-message.
3. Ctrl+B M opens your mail, from any pane.
4. r replies. The agent gets the reply in its inbox.
5. The agent reads your answer and carries on.

• A message is at most 8KB, with a subject of up to 120 characters and up to eight attachments, sent as paths. A session's mailbox holds 256 messages or 512KB. A sender gets a burst of ten, then thirty messages a minute.
• --reply-to <id> answers a message and joins its thread.
• ask-agent refuses a question that would close a loop of agents waiting on each other, and refuses an agent that is itself blocked on a prompt (--allow-blocked overrides that).
• tuios stash put <file> copies a file into a store owned by the session and prints its path, ready for --attach. The limits are 16MB per file and 256MB per session. stash get copies it back out, also across machines.
• Selectors name many agent panes at once: --select 'harness:codex state:idle,done', needs:you, session:, host: and more. A write to several panes lists them and sends only when you say yes, or with --yes.
• Queued messages. tuios queue holds a message for a busy agent and types it once the agent has been at rest for a second.

See Agent messaging.

One prompt, several worktrees

tuios fan 3 --agent claude 'Add a retry with backoff to the HTTP client.'
tuios fan compare
tuios fan keep api-fan-add-retry-backoff-http-2 --stash

tuios fan creates several git worktrees of the repository you are in, starts the agent in each, and types the prompt once each agent is ready to read it. Each branch is fan/ and the first four words of the prompt that carry meaning, so in a repository called api the prompt above makes the sessions api-fan-add-retry-backoff-http, -2 and -3. --name picks the stem yourself. The rail groups the sessions under their repository. fan keep keeps one and removes the others. It refuses to throw away uncommitted work unless you pass --stash (which puts it in git stash) or --force, and it never deletes a branch.

1. tuios fan starts one agent per git worktree.
2. Ctrl+B ) visits each session. Every agent has its own worktree.
3. tuios worktree diff shows what one of them changed.
4. fan keep keeps one. The others close, and their work goes to git stash.

• --agent takes any program with its arguments ("codex --model o5"), and a comma list cycles several agents across the sessions. --prompt given once per session gives each its own prompt.
• tuios fan compare shows each attempt's agent, state, files and lines changed, and its last check. tuios fan verify <session> -- <command> runs one check in every attempt and records whether it passed.
• tuios start-agent starts one agent in a new pane and returns once it is at its prompt. With --protocol acp or --protocol codex the agent runs headless, over the Agent Client Protocol or the Codex app-server, and the pane shows its turns as a transcript.
• fan, worktree new and start-agent also run on another machine, with --host. The repository is named by its origin URL there.
• tuios worktree new|ls|diff|rm manages single worktrees the same way.

The windows of a fan session open floating, as in the clip; t in window mode tiles them (see Known issues). See Worktrees.

Pane grants

Every pane holds grants that say what it may do through tuios: read, write (type and leave mail in its own session), fan, respond and admin. The daemon checks every call from a pane against them, and it knows a call comes from a pane by reading the caller's process from the socket. With no [agents.permissions] table a pane holds admin, which is what every pane could do before. mode = "strict" gives a pane read, write and fan unless you list others. A pane never gives more than it holds. tuios pane-grants shows what the current pane may do, tuios set-pane-grants changes it, and start-agent, fan and new-window take --grants.

Whatever the grants, a pane cannot act as the person: mail or a question sent as human from inside a pane is refused, and reading your mail from a pane only peeks.

Sessions come back

On a fresh install, a bare tuios starts or joins the daemon, which keeps your sessions running while no client is attached. An existing config file keeps running tuios without the daemon, and so without restore, until you turn it on (see Turn on the daemon). The daemon saves each session's structure under $XDG_STATE_HOME/tuios/sessions and restores it when it starts. A detach loses nothing. A daemon restart or a reboot ends the shells: what comes back is the layout, not the programs.

• Each window comes back with its workspace, its place in the layout, its name and its working directory, on Linux and on macOS. The session keeps its name and colour.
• Each shell is new, started in the old directory. Scrollback and running programs are not saved. Restored shells get TUIOS_RESTORED=1.
• Agent conversations can come back too. When a hook recorded the conversation id and the harness has a resume command (claude --resume <id>, codex resume <id>, opencode --session <id> and others), the restore offers it. daemon.resume_agents picks what happens: ask (the default) puts one Inbox item per pane, answered with y; auto types the command into the new shell; off does neither. A fan's worktree records survive the restart.
• A pane that ran on another machine comes back as a shell on this machine, in the daemon's own directory. Restore runs before the links to other machines are up, so it does not wait for them.
• A state file tuios cannot read is moved aside for two weeks instead of stopping the daemon.
• A burst of resizes when a shell starts is written to the terminal as one, so macOS's /bin/bash 3.2 is no longer killed while it starts up in a restored pane.

tuios daemon --no-restore turns restore off. tuios resurrect lists what is saved, or brings one session back by name. tuios attach starts the daemon instead of refusing. See Sessions and the post Session state was saved every 30 seconds and never read back.

One layout for every client

Two clients on one session used to disagree about pane sizes, because each subtracted its own rail and dock and retiled. Now each client reports how much space it reserves on each edge, the daemon takes the largest reserve per edge, and every client gets one geometry. The same rule covers zoom, the master-stack ratio, the scrolling layout's position, hand-arranged workspaces and BSP trees. Session names and colours are daemon state, so a rename reaches every client. Broadcasts reach each client in the order they were made, and a client that attaches while another one changes the session gets the newer state. Reattaching to a full-screen program such as top no longer draws its rows one blank line apart (#123). The post A PTY has one size explains why.

Other machines

The daemon keeps one ssh link per configured machine, run with BatchMode=yes, so you need to be able to ssh to it without typing anything. Nothing is nested: a remote session is drawn by your local client, with your theme, config and prefix key.

tuios hosts add build gaurav@buildbox   # or: tuios hosts add build --tailnet
tuios hosts                             # every link and its state
tuios attach --host build api           # a session on build, drawn here
tuios new-window deploy --host build    # one pane on build, in this session
tuios new deploy --global               # a session with panes from several machines

• The link finds tuios on the far machine by itself and redials with a backoff when it drops. tuios hosts shows each link as up, connecting, reconnecting, unreachable, no_daemon, no_tuios or incompatible.
• A pane on another machine is laid out here, and its title bar says build:deploy. The rail's files section and agent detection work for it.
• A dropped link no longer ends the pane. The far machine keeps it for a grace period (hosted_grace, 10 minutes by default), with the last 64KB of output, and replays that output when the link is back. Mail to a machine whose link is down waits and is sent in order.
• Each machine decides what a linked machine may do, in [hosts.NAME] or [hosts."*"]: allow lists list, mail, open, write and respond. The default is every one but respond, so a linked machine cannot answer prompts and approvals for you unless you allow it.
• In a global session every new window asks which machine to run on.
• Verbs take host-qualified targets: -s build:api, -w build:api:0. Every pane gets TUIOS_HOST, the name of the machine it runs on.
• The Inbox, the rail's agent counts and tuios list-attention cover every linked machine.
• tuios hosts tailnet lists machines on your tailnet, asking the local tailscaled with no root and no auth key.

See Remote hosts and the post A pane on another machine.

The interface

Tiling, layouts and zoom

A fresh install starts tiled. n opens a window and it takes its place in the layout, ctrl+b z zooms the focused pane, and alt+1 to alt+9 switch workspaces (opt+1 to opt+9 on macOS).

1. n opens a window, Enter types into it.
2. Each new window takes its place in the layout.
3. Ctrl+B z zooms the focused pane.
4. Alt+2 switches to an empty workspace.
5. Alt+1 brings the first one back.

There are three tilers: BSP, master-stack, and a scrolling layout in the style of niri, which puts columns on an endless horizontal strip. All three honour appearance.gap.

1. Pick the scrolling layout from the command palette.
2. Panes are columns on a strip. Alt+Right slides along it.
3. Ctrl+B L 7 makes this column 70% wide.
4. Back to BSP tiling the same way.
5. Alt+N moves the focus from pane to pane.
6. Zoom slides the pane forward, and follows the focus.

• Zoom slides into place instead of cutting. appearance.zoom_size (95 by default) zooms like a camera, with the neighbours visible at the edges, and moving focus hands the zoom to the pane you land on (appearance.zoom_follows_focus). 100 fills the screen.
• Percentage resize. ctrl+b L then 5 to 9 sets the focused pane's width to 50 to 90 percent, and shift with 5 to 9 sets its height.
• Master-stack keeps your resizes across retiles, with a ratio per workspace from 10 to 90 percent.
• Popups. tuios popup -- fzf runs a command in a floating pane over the layout and closes it when the command exits. This is how fzf, gum and other pickers become tuios overlays.
• New windows open where you are, in the focused pane's directory.
• Resize was rebuilt so dragging a shared border moves only the two panes that share it (the post).

See Layout modes.

The rail

The rail is a sidebar of sections: sessions, terminals, files, git and agents. It is on by default, on the right, 24 columns wide. ctrl+b b hides and shows it, and appearance.sidebar.enabled = false keeps it off. Which sections it draws, in what order and how tall, is one string, appearance.sidebar.sections, with an editor on the settings page. The files and git sections follow the focused pane into its directory. tuios reads the directory from the shell's OSC 7 report when the shell sends one, and otherwise from the process itself (see Known issues for one case where that stops).

1. The rail follows the pane into a folder.
2. Ctrl+B e moves the keyboard into the rail.
3. In the file list, a makes a file.
4. The git section counts the new file.
5. d sends it to the trash, after asking.

• Sessions each have a stable colour derived from the name, show their directory and git branch, and can be renamed, dragged into an order, or killed. Sessions on other machines are grouped under their machine.
• Files has six actions: create, rename, delete, copy, cut and paste. Only delete asks first, and it moves the file to the freedesktop trash in $XDG_DATA_HOME/Trash. Paste never overwrites.
• Git shows the branch, how far it is ahead of and behind its upstream, and how many files changed.
• A program can print an OSC 7 escape claiming any directory. When the kernel says the shell is somewhere else, the file actions switch off and the rail says "read only: wrong folder".
• ctrl+b e (or s in window mode) moves the keyboard into the rail.

See Session rail.

Launcher, palette and keys

alt+space (or ctrl+b a) opens a launcher over everything on your PATH, fuzzy-matched and ranked by how often and how recently you run things. Enter runs the program in a new pane. Tab types it into a new pane so you can add arguments. The command palette on ctrl+p finds actions, settings, and panes in every session. With nothing typed it lists commands under category headers; once you type, the best matches come first and the match count sits on the search line.

1. Alt+Space finds any program on your PATH.
2. Tab opens a pane with the program typed out, ready for arguments.
3. tuios popup floats fzf or gum over the layout.
4. The popup closes when the program exits.
5. Ctrl+P finds commands, and panes in every session.

Every key tuios answers to is in one registry, and the keybind manager on ctrl+b k shows it: what is bound, where tuios conflicts with itself, where it conflicts with the program in your pane, and a Record tab that tells you who owns the next key you press.

1. Ctrl+B k lists every binding.
2. Type to search them.
3. Record: press a key, see who owns it.
4. Ctrl+D frees it, so the shell gets it back.
5. One Ctrl+B, then walk the panes with the arrows.

• Give a key back. ctrl+d on the Record tab, or tuios keybinds free <key> from a shell, takes a key off every action so the program in the pane receives it. tuios keybinds doctor and tuios keybinds explain <key> run the same analysis from the CLI.
• Which-key. The menu after ctrl+b is laid out in sections (Windows, Panes, Sessions, Modes, Menus, Tools, and Agents once an agent has been seen) and flows into as many columns as fit. A + marks a key that opens another menu. At 120 by 40 it takes 15 rows, down from 36.
• Prefix repeat. After a command worth repeating, the prefix stays armed for a moment, so ctrl+b then left left left walks three panes. appearance.prefix_repeat_time sets how long, and 0 turns it off.
• Lists all move the same way: the arrows, ctrl+p and ctrl+n, home, end and the page keys, and j, k, g and G where there is no filter. They wrap from the last row to the first (appearance.wrap_lists).
• New keys. N in window mode makes a session, ctrl+b ( and ctrl+b ) switch sessions, b in window mode toggles the spotlight, and alt+n and alt+p move to the next and previous window in terminal mode. Bindings accept f13 to f63 and insert.
• Key hints in footers stay on one line: when there is no room, ctrl+ becomes ^, alt+ becomes M-, then labels and whole hints drop off the end.
• macOS. opt+ bindings on keys that compose no character, such as opt+esc, now fire. When Option+Left arrives as a readline word motion, tuios says so and names the terminal setting to change.

See Keybindings.

The mouse

• Right-click opens a menu for what is under the pointer: a pane, a dock segment, a workspace pill, the desktop, a session row, or a machine heading. Every row is an action from the keybind registry and shows its key.
• Alt and the left button move a pane from anywhere in it. Alt and the right button resize it. Dragging a tiled pane by its title bar swaps it on release.
• The left button selects text and copies on release: double-click for a word, triple-click for a line. A double click on a pane enters terminal mode (appearance.click_to_type).
• Links in a pane (OSC 8 and bare URLs, including wrapped ones) underline under the pointer. Shift and a left click opens one. A plain click does not, so a click on an address still focuses the pane and selects text. A file:// link opens in $EDITOR in a new pane. Under tuios ssh and tuios-web an http link is copied to your clipboard instead.
• Every overlay row highlights under the pointer and acts on a click. Dock pills and rail sessions can be dragged into an order, and the rail's edge can be dragged to change its width.

Look and feel

1. The theme picker is one palette search away.
2. Over 340 themes. The arrows preview each one live.
3. Enter keeps it.
4. Ctrl+B , opens a settings page for every option.
5. Changes show at once and are saved to config.toml.

• Every colour depth. The chrome is designed separately for truecolor, 256 colours and 16 colours, and tuios reads the depth from TERM, COLORTERM and NO_COLOR like any other program. At 256 colours (Apple Terminal, mosh, tmux without Tc) panels sit on the xterm grey ramp, so they no longer turn navy. At 16 colours tuios paints no grounds: panels frame themselves with a line and the selected row is reverse video. Over mosh, which passes truecolor but not COLORTERM, set COLORTERM=truecolor on the far side. See Themes.
• Light themes. Dialogs, the palette, which-key, settings, the Inbox and help are drawn on a ramp built from a light theme's background, where they used to be a dark slab, and text is darkened at its own hue until it reads.
• Your terminal's colours. With no theme and no pane background set, each client asks its own terminal for its background, foreground and 16 colours, and a program in a pane that asks for them (OSC 10, 11 and 4) gets those answers. A local client follows your system's light and dark switch as it happens.
• Themes. 343 built-in themes with a live preview. tuios import-theme converts a kitty, ghostty, alacritty or wezterm scheme. A theme can carry chrome colours for the interface, so the accent can be amber without turning every blue in your panes amber.
• Backgrounds. A cell a program leaves on the default background shows your terminal through it. appearance.pane_background can now paint it: off (the default), theme, or a #RRGGBB colour. The desktop, window chrome, dock and rail have the same option, and appearance.background sets them all.
• Motion. appearance.motion is full (the default), basic (window slides and zoom only) or none. It replaces animations_enabled. With full, dialogs fade in (in truecolor) and a working agent's row carries a slow shimmer. appearance.modal_dim (30 by default, 0 for off) dims what is behind a dialog.
• Settings page on ctrl+b , (or , in window mode) covers every option, with a colour picker, sliders for numbers, an editor for the rail sections and pickers with previews. / searches every row by name, config key, value and description. A row that differs from the default has a dot, backspace resets it, and ctrl+z undoes. Changes apply at once and are saved to config.toml. Editing the file by hand also reaches the running client, and an error is shown on screen instead of being ignored.
• Glyph sets. appearance.glyphs picks the shapes of borders, window controls and rail marks: default, unicode, heavy, ascii, or your own file. With none set, a locale that is not UTF-8 gets ASCII, and the Linux console gets plain Unicode. tuios list-glyphs says what was picked and why.
• Zen mode hides unfocused borders, always or while the mouse is still.
• Copy flash sweeps a band of light over copied text.
• Keycast draws your keypresses in a corner for screen recordings (tuios --show-keys, or from the palette).

1. With spotlight.shake on, a shake of the mouse turns the spotlight on.
2. The beam follows the pointer, and the rest of the screen dims.
3. It lights whatever is under the pointer, panes and the rail alike.
4. Shake again, or press b in window mode, to turn it off.

• Spotlight. b in window mode, or a shake of the mouse with spotlight.shake on, dims everything outside a circle around the mouse or the cursor. The [spotlight] table sets the radius, how dark the rest goes, a hard or soft edge, and what it follows.

1. In window mode, S starts the screen saver.
2. It is made from what is on your screen.
3. All 36 effects, each recorded on the same screen and shown until it puts the screen back together.
4. Any key brings the screen back.

• Screen saver. 36 effects ported from terminaltexteffects, drawn from your real screen. Off until you set screensaver.enabled. S in window mode starts it now, and any key brings the screen back.

Screenshots and graphics

ctrl+b C captures a pane, the whole screen, or a region you drag with the mouse, and shows a preview with the file it wrote. It works while a panel is open too, so the Inbox, the review, the palette or a dialog can be in the picture. On a terminal with kitty graphics the preview shows the picture itself. tuios screenshot does the same from a script. It runs in the daemon from the emulator's cell grid, so it works on a detached session, and writes png, svg, html, ansi or txt in any theme.

1. Programs that speak the kitty graphics protocol, such as chafa, draw images in any pane.
2. Move the pane and the picture goes with it.
3. Ctrl+B C captures a pane, the whole screen or a dragged region.
4. The preview is the PNG it wrote, drawn with kitty graphics.
5. tuios screenshot does the same from a script: PNG, SVG, HTML, ANSI or plain text, in any theme.

• Kitty graphics animation is implemented, sending only the changed regions. One measured page went from 330MB forwarded in 21.6 seconds at 17fps to 22MB at 73fps.
• Unicode placeholders, such as the images in glow's pager, show inside a pane and scroll with the text.
• A window over part of an image crops that part instead of hiding the whole image. Images no longer draw over the rail or the dock, and two panes that both number an image 1 no longer replace each other's picture.
• kitten icat and payloads with line breaks draw now.
• Graphics over SSH follow the connecting client's capabilities.
• Bounded memory. An animated gif under chafa grew tuios to 5.3GB in two minutes. The same run now stays at 189MB.

See Screenshots.

Scripting and control

The daemon speaks 97 verbs over a line-delimited JSON socket. tuios list-verbs lists them with their parameters and every error code they can return. One registry holds 167 options, and each one can be set in a running session.

Recorded when tuios had 156 options. v0.8.0 has 167.

1. set-config changes any option in the running session.
2. subscribe prints each event as a JSON line.
3. wait-for blocks until a pane prints what you are waiting for.
4. Themes too. Every option changes live.

• Strict input. A parameter a verb does not take is refused with the closest spelling, instead of being dropped. set-option refuses a path that does not exist, a bad colour or an unknown theme. run-command refuses a name it does not know (tuios run-command --list).
• tuios run -w NAME -- cmd types one command into a pane, waits for it, prints exactly its output and exits with its status, for a shell that marks its commands with OSC 133. wait-for command-finished waits for one, and capture-pane --last-command reads what the last one printed.
• tuios subscribe prints the daemon's events as JSON lines, and resumes after a disconnect with --after-seq and --boot-id.
• tuios wait-for blocks until a pane prints a pattern, exits, goes idle, or an agent reaches a state, in one session or with --any-session.
• MCP server. tuios mcp serves the control surface as Model Context Protocol tools over stdio. The default tools read, wait and send mail; --write adds typing into panes, answering prompts and fan-out. Each call is held to the pane it came from.
• tmux shim. tuios tmux-shim <command> runs a tool that only knows how to open tmux panes, such as Claude Code's agent teams, with a tmux that answers in your tuios session. It is opt in.
• send-keys -w NAME sends the keys to that window even with a client attached, and says where they went. -w tries a window's id, its index, then its exact name, and only then an id prefix, so a window named db cannot be mistaken for another window whose id starts with db.
• Hooks run in the daemon, so they fire with nobody attached. tuios list-hooks shows each hook's runs, last exit code and last error. A new hook, after-command-finished, fires when a marked command finishes.
• new-session, split-window, set-layout and the other verbs work with no client attached. tuios layout export <name> prints a tape script that tuios tape play runs.
• Errors say what to do. Every CLI failure prints the cause and a fix.
• One daemon per runtime directory. The socket lives under XDG_RUNTIME_DIR, or /tmp/tuios-<uid> without it, and the daemon refuses that directory if it is a symlink or another user owns it. TUIOS_SOCKET in a pane names the daemon the pane belongs to, and a command refuses one that names no running daemon. To run a separate daemon, set XDG_RUNTIME_DIR and XDG_STATE_HOME.
• tuios update replaces the binary, but only when it installed it. It verifies checksums and otherwise names the package manager that owns it.
• tuios --skill prints a short core for an agent driving tuios from a pane, and tuios --skill TOPIC one of thirteen topics. A test checks every command in it against the real command tree.
• The daemon writes a log to $XDG_STATE_HOME/tuios/daemon.log, and a panic in the interface shows a crash report you can copy or file, with no pane contents in it.

See the control protocol and the post The daemon said yes to an option that did not exist.

The web client, SSH and project tapes

• tuios ssh checks keys. See SSH under Upgrading.
• tuios-web over TLS. --auto-tls creates and keeps a certificate for the hostname and every interface address, so you can open a LAN address on your phone. On a phone, a row of tuios commands sits near your thumb, a long press opens the pane menu, and dividers are wide enough to grab.
• The web client shows your theme, takes every interface flag tuios takes, and can shape Arabic and ligatures with HarfBuzz (opt in). The Docker image includes tuios-web.
• tuios in a browser tab. tuios also builds for WebAssembly, with a pretend shell in every pane and no server. That build runs the guided tour at /learn.
• Project tapes. A .tuios.tape in a project describes its session: windows, commands and layout. When a shell cds into the project, tuios offers to run it, like direnv for layouts. You read the file first, and trust is tied to its hash, so any edit asks again. See Project tapes.
• Install. Homebrew core has tuios. The Nix package is repaired and ships tuios-web. scripts/install.sh installs to ~/.local/bin.

The terminal emulator

Behind a ghostty build tag, panes can run on libghostty-vt, Ghostty's emulation core, instead of the pure Go emulator. Package managers install the pure Go build, and so does scripts/install.sh unless you pass ghostty. The GitHub release adds tuios-ghostty archives built with libghostty-vt for Linux and Windows; macOS archives will follow in a later release. tuios --version names the backend. A differential suite feeds both the same bytes and compares the results.

A conformance corpus, a grammar-based fuzzer, differential tests against tmux and two metamorphic checks found bugs that any program in a pane could hit:

• The cursor position report had line and column swapped.
• Under TERM=screen, box drawing came out as lqk.
• OSC 8 hyperlinks had their fields swapped and never worked.
• A scroll region taller than the screen crashed the daemon and every session in it.
• A window title with a Dingbats character, which Claude Code puts in its title, ended early and printed the rest into the pane.
• NEL, DECALN, DECSTR, DECRQSS, REP, DECSED, DECSEL, HPB, VPB, mode 47 and more were missing or wrong.
• Home and End reach a shell that turned on application cursor keys, as zsh does, in the form it binds (#193).
• A session made by a command with no terminal, such as tuios new --detach from a script or CI, gave every pane TERM=dumb for its life. Those panes now get xterm-256color.

Faster and smaller

Every number comes from the commit that made the change or from docs/perf.md in the tuios repository. Each row is a before and after pair measured around one change during this cycle, on the machine and setup that change was measured on. It is not a run of v0.7.0 against v0.8.0.

An idle client schedules no timer renders: with idle shells and the rail open, a 10 second test sees no bytes on the wire and no renders. The motion setting keeps it that way: the clock that drives a fade or a shimmer is never armed when nothing moves. The binary lost 6MB across seven changes, and CI now fails a change that grows the release binary past a budget. The posts 48MB per pane, twice, A fifth of every frame went to changing nothing and Making the binary smaller cover three of these.

Hardening

• Messages the daemon decodes are bounded. A state update or command result nested deeply enough could run the daemon out of stack while it was decoded, which stopped every session. Frames, trees and nested payloads now have limits, checked before decoding.
• Debug logs (TUIOS_DEBUG_INTERNAL=1), one of which records keys typed in terminal mode, are opened privately, and a log file another user planted is refused. They used to be readable by others and to follow symlinks.
• A host whose address starts with - is ignored, so ssh cannot read it as an option.
• A client can no longer overwrite what the daemon owns about a window, such as its agent state or directory.
• The test suite was held to one rule: a unit test stays only when it catches a real bug the end-to-end suite misses. The end-to-end tests, which drive a real tuios binary against real daemons, went from 347 to 423, and the fuzz targets from 22 to 32.

Other fixes

• The last output of a pane, often its prompt, sometimes stayed invisible until the next key. It is drawn at once.
• A pane scrolled back stays on the line you stopped at while output arrives.
• Clipboard copy and paste work on GNOME Terminal and other VTE terminals, and over a loopback SSH connection, using the native clipboard tool.
• Keys typed within 150ms of entering terminal mode are no longer dropped.
• ctrl+d in a pane on another machine closes it at once.
• Two connections accepted in the same microsecond on macOS got one client id, and the second replaced the first.
• The keybind manager reads the foreground program of a pane on macOS.
• Under tmux 3.6 and later, a few cells beside a panel showed the terminal's own background, because the renderer moved the cursor with hard tabs.

The full list is in the changelog on GitHub.

Everything else

The sections above cover what you will notice first. This is the rest, by area.

Agents and the daemon

• A blocked agent's alert includes the question it asked. A state clears when the agent exits back to its shell. get-agent-state and list-agents report a confidence and whether the pane needs you, and list-agents reports human_unread.
• Every state has a word or a mark of its own, so colour is never the only signal. The agents section header counts blocked and finished panes, and a click on the count filters the list. tuios agent-statusline feeds a harness's status line into the row.
• tuios resume-agent answers the resume item a restore puts in the Inbox. i on a rail row opens that pane's mailbox. Mail lives in memory and ends with the daemon.
• wait-for agent-message --thread and read-agent-messages --thread follow one thread. Loop detection in ask-agent needs --from "$TUIOS_PANE_ID".
• tuios popup --wait --capture-stdout hands a picker's choice back to the caller. The Inbox keys are in [keybindings.inbox], [keybindings.inbox_peek] and [keybindings.mail].
• tuios worktree ls and worktree rm list and remove worktrees; a worktree session is named <repo>-<branch>. A fan on another machine can clone the repository with --clone, which accepts only https, ssh and git URLs. tuios queue ls and queue rm list and drop queued messages, and --confirm takes the token list-agents prints for a write to several panes.
• With hold_mail = true in [hosts.NAME], mail from that machine waits in the Inbox for you to pass on with p.
• A pane asked for more than it holds is refused with forbidden. A restored session is marked restored in tuios ls until you first attach, and a window whose shell will not start is dropped rather than restored empty.
• Daemon panes honour appearance.scrollback_lines (the daemon kept 10,000 lines per pane whatever the file said) and appearance.preferred_shell.
• Windows created in a daemon session now tile, where only windows the attached client made used to be placed. BSP and master-stack tiles no longer overlap when panes shrink.

An interactive figure goes here. Open the page to use it.

• tuios daemon --pprof serves profiling data, and tuios set-config daemon.log_level messages raises the log detail without a restart. kill-session deletes a session's saved state, so a session you killed on purpose never comes back.

Other machines

• tuios hosts add writes [hosts.NAME] in config.toml, and the daemon follows the file, so no command here needs a restart. tuios hosts test dials a machine now and says what it found, and where it looked for tuios when it could not find it. tuios hosts add NAME --tailnet takes the address from the tailnet machine of that name. An address is anything ssh understands, and your ~/.ssh/config aliases are offered in completion and on the settings page, which has a Hosts section.
• tuios attach --host keeps a dropped session on screen and tries for three minutes before it returns to the session it left. --ssh runs the far tuios inside this one instead, for a host whose tuios is too old.
• A remote pane that lost its link reads [reconnecting] build:deploy.
• appearance.global_session = false hides the global group in the rail. Making a session asks which machine when more than one is reachable, from N, the + at the start of the dock's session strip, or the palette.
• local: addresses a local session whose name contains a colon. Host targets work for list-windows, capture-pane, send-keys, send-text, wait-for, focus-window, kill-session, session-info, get-agent-state, the mail verbs and the stash. fan, worktree new and start-agent take a HOST:SESSION target too.

The rail and the dock

• The rail is flat sections now, not a tree. spacer may repeat in appearance.sidebar.sections, and the line above a pinned section can be dragged to move the split. Rows scroll when truncated, and the collapsed strip labels the row under the pointer.
• A session with a generated name is labelled by its directory. appearance.session_border = true tints every pane border with its session's colour.
• appearance.sidebar.folder_click decides whether clicking a folder moves the listing, sends a cd to the pane, or both. appearance.sidebar.file_delete = "permanent" skips the trash. A file on another filesystem is refused, and on Windows a delete is permanent and says so. A pasted name that exists gains a number. appearance.git_dirty (on by default) counts changed files.
• The dock is a status line without powerline caps, set by a [dock] table: left, center and right list components, [dock.clock] sets the time format, and a [dock.custom.NAME] entry runs a shell command and shows what it prints, killed with its whole process tree at its timeout. Workspace pills can be dragged into a display order without renumbering the workspaces.

Tiling and the mouse

• A pane can be floated out of a tiled layout, or pinned so it follows you across workspaces. "All windows" in the palette searches every window in every workspace.
• appearance.zoom_animation turns the zoom slide off, and a tiled pane's title bar can carry a zoom button (appearance.window_button_zoom).
• In the scrolling layout, appearance.scroll_column_max (20 to 100, default 90) lets a column fill the screen, and appearance.niri_click_reveals and appearance.niri_hover_reveals bring the whole column on screen. Column widths survive a session switch (the post). appearance.niri_scroll_cells (default 8) sets how far one scroll moves the strip, and sideways trackpad drift no longer walks it.
• tuios popup takes --width and --height in cells or percent (default 80% and 60%), and esc in window mode closes the focused popup. appearance.new_window_inherit_cwd = false opens new windows in your home directory instead.
• Turning tiling on after floating brings back the arrangement you had. Floating windows no longer draw over the clock or the log viewer, and raising one no longer reshuffles the others.
• A click that only focuses a pane no longer resizes it, and a drag that puts a pane back where it was resizes nothing, so your shell no longer reprints its prompt.
• appearance.links picks which links respond: off, marked for OSC 8 only, or all (the default), which adds bare URLs. A file:// directory opens in the rail's file view.

Keys

• The palette and the launcher sit in a [keybindings.global] section that is read in every mode, and any action can be bound there.
• In the keybind manager, ctrl+x on a row frees that key everywhere, and tuios keybinds unbind removes one action from one key. Each finding says how it knows: certain from tuios's own routing, observed from a live pane, or reference from a list of program defaults.
• The launcher shows names and icons from desktop entries where the platform has them. All four search boxes in tuios share one fuzzy matcher.
• appearance.auto_enter_terminal_on_focus can be off (the default), targeted (focus by selection and arrows) or all (including Tab).
• The prefix arrows walk panes, and ctrl+b a opens the launcher. These work on macOS with no terminal settings. Keybindings also accept the lock keys and the other keys Bubble Tea names under the Kitty protocol.

Look and feel

• tuios list-themes lists the built-in themes and your themes directory. An imported theme works without a restart, switching theme recolours every open pane in place, and a theme can describe itself: colours under the contrast floor are named.
• A theme's chrome object takes accent, accent_bright, success, warning, error and info, and chrome.surface sets the colour dialogs are drawn on.
• A custom glyph set is a file that can inherit from a built-in one, and every glyph has its own ASCII fallback.
• The colour picker has a hue strip, a shades grid, HSL and RGB sliders, a hex field, a harmony wheel, and the theme's own colours as slots that follow the theme.
• The backgrounds are appearance.pane_background, desktop_background, window_chrome_background, dock_background and appearance.sidebar.background. Only cells with no colour of their own are painted, a program that asks for the background colour is told the painted one, screenshots use it, and the settings page has a Backgrounds tab.
• The scrollbar has two styles: a single stroke in the pane's own ink, or a track with a half-cell thumb.
• appearance.selection.flash turns the copy flash off, and flash_ms, flash_color and flash_style (diagonal, diagonal-reverse, horizontal, vertical) tune it.
• appearance.zen_mode hides unfocused borders; content never shifts.
• The screen saver starts after screensaver.idle_minutes, with screensaver.effect or random. Effects run at the right speed at any frame rate, and on an unthemed session the saver asks the terminal for its palette.
• The keycast coalesces repeats and remembers whether it is on.

An interactive figure goes here. Open the page to use it.

• Empty lists say why they are empty and show one key. A loading state waits half a second before it shows, so a fast load never flashes.

Graphics and the web client

• On macOS, tuios screenshot finds your fonts without fontconfig, including fonts inside .ttc collections, so Nerd Font icons draw. tuios screenshot -w build captures a window by name from a script.
• Kitty graphics over SSH take the client's capabilities from the connection: TERM, the forwarded environment and the pixel size it reports. A flood of graphics is paced so it cannot starve the keyboard, and an image in a pane's last rows no longer scrolls the whole screen up.
• Unicode placeholders need a host that supports them (kitty, Ghostty, WezTerm), so not tuios-web. appearance.kitty_placeholders forces the choice.
• The web client's text shaping uses sip's WebGL renderer with HarfBuzz. Grapheme widths match a reference terminal, and a freeze where synchronized output was left on is fixed.

An interactive figure goes here. Open the page to use it.

• tuios-web cert inspects or replaces the certificate --auto-tls made. Settings changed from a browser apply to that session only, instead of writing the server's config file. The tab says tuios and has a favicon, and the QUIC and WebTransport libraries moved past several reported vulnerabilities.

Project tapes and startup

A tape runs commands, so nothing happens until you have read it. The review dialog shows the whole file, and you choose Run once, Trust and run, or Never. By default a dock badge and a notification say a tape is there. auto_review opens the review on detection, and autorun = "auto" runs a tape you trusted and have not edited since. Running one builds a session named after the project.

An interactive figure goes here. Open the page to use it.

startup.open_default_window, startup.tiled and startup.start_in_terminal_mode remove the steps every session started with. With all three on, tuios opens tiled with one terminal and your next key goes to the shell. Startup asks the terminal everything in one round trip, which is where the 566ms to 68ms came from.

An interactive figure goes here. Open the page to use it.

The settings page reopens on the tab, row and search you left, 1 to 9 pick a tab, and tuios list-options --search runs its search from a shell.

Scripting

• One registry backs set-option, get-option and list-options. It fixed a dozen settings, from border style to the leader key, that were saved and then read back as defaults, and a boolean turned off that could not be saved.
• Config reload works with editors that save by renaming, such as vim.
• A failing hook logs its exit code and the tail of its stderr.
• The crash report has the build, terminal, layout and last actions. c copies it and g opens a prefilled issue. It never includes pane contents, titles, paths or session names.
• tuios send-keys takes --repeat and no longer pulls a pane you scrolled back to the bottom. tuios new-window --print-id prints the new window's id.
• tuios stash put and stash get print only the path, so path=$(tuios stash put FILE) works.

The terminal emulator

• Under TERM=screen, linux or vt100, SO and SI were unreachable, which is why box drawing came out as lqk.
• A mode map read without its lock, and two captures of one busy pane, could each crash the daemon.
• Insert mode was recorded but ignored, REP repeated the wrong character, and a wide character cut at a margin left half of itself behind.
• A single shift (SS2, SS3) before a multi-byte character leaked into the next one, and invalid bytes in window titles are now dropped.
• Underline and other attributes were dropped on the focused pane's render path.
• DECRQM reported modes 47, 1016 and 2048 as unknown.
• On the ghostty backend, grapheme clustering was off, so a family emoji took eight columns, and scrollback_lines did not hold: a pane asked for 10,000 lines kept about 400 at 207 columns.
• A table of links and clusters in the scrollback was never pruned, so a pane printing a link on every line grew for its whole life.
• The first version of the differential suite passed while the ghostty backend painted ls on hot pink, which is its own post. Where the backends still disagree, the difference is pinned as a known divergence.

Speed and memory

• The render ticker runs at max_fps, which at the default of 60 took an idle client from 1.0% to 0.6% of a core.
• A keystroke over the socket went from 4,009ns and four writes to 967ns and one.
• A pane that falls more than 4MiB behind drops to catch-up rate until it recovers, and a flooding pane sends at most one frame per millisecond once it has sent 4KB in it, instead of one frame per PTY read.
• A workspace switch asks only for rows the client does not have: at four panes, 11.5MB of encoding became 0.6MB.
• Drawing a pane's frame went from 6.53ms to 1.58ms when dirty and from 3.51ms to 62.7us when cached. The rail's rows went from 82,000ns and 178 allocations per frame to 288ns and none.
• Moving the pointer over plain text no longer composes a frame per cell. A truecolor repaint allocates a quarter of what it did, and scrolling short lines costs 65 to 79 percent less CPU.
• The linux/amd64 binary went from 31,559,840 bytes to 25,231,520. The review's diff highlighter carries 88 of chroma's 279 lexers, tailnet discovery runs tailscale status --json instead of linking tailscale's client, and tuios update fetches through curl, which took net/http and crypto/tls out of the binary.
• Scrollback is stored as text with styles marked where they change: a 175-character line went from 4,864 bytes to 216. An empty pane allocates a row only when something is printed on it, and the alternate screen is built on first use. Eight empty panes went from 47.5MiB of heap to 14.9MiB.

More fixes

• Ctrl+P opens the palette even when the terminal reports Num Lock in the key event.
• Quitting a session says "Killed", not "detached", and names the session.
• A grapheme cluster split across two writes renders as one.
• Programs in tuios are told graphics forwarding is available, so image tools stop falling back to blocks.
• The log viewer's copy keys (E for errors, A for all) work.
• Help opened from the leader starts at the top, and q closes it outside a search and can be typed inside one.
• Mouse scroll speed and the window title format are configurable.
• A recorded tape typed escapes such as ‍ as letters on playback.
• PNG screenshots no longer draw a faint notch in every row of a pane border, and draw the Enter key glyph instead of an empty box. Box drawing is aligned to the pixel grid.
• golang.org/x/crypto moved past a denial of service the SSH server reached.
• The unit tests went from 4,282 test functions to 2,870, keeping only the ones that catch a bug the end-to-end suite misses.

Upgrading from v0.7.0

Most of these need nothing from you. The ones that do say what to change. tuios never rewrites your config file: old keys that still mean something are read and translated when the file loads.

Restart the daemon

The wire protocol is version 3, and a version 2 daemon is refused with a message that says which side is newer. Run tuios kill-server and start tuios again. This ends every session the v0.7.0 daemon holds: v0.7.0 saves nothing, so its layouts, window names and working directories are lost along with the programs in its panes. Note what you want to keep before you run it. From v0.8.0 on, a daemon restart brings the layout back. The JSON verb protocol stays at version 1.

Turn on the daemon

A fresh install uses the daemon and starts tiled. An existing config file does not: [startup] has no default for keys the file leaves out, so a file that does not name daemon and tiled reads them as false, and tuios keeps running standalone and floating, with no restore. To get the new behaviour, add this to config.toml:

[startup]
daemon = true
tiled = true

tuios --standalone or TUIOS_NO_DAEMON=1 runs without the daemon. If the daemon will not start, a bare tuios runs standalone for that run and says so.

Defaults

These defaults changed. A key your config file sets keeps its value, so what you get depends on what the file names. The last column is what a config file written by v0.7.0's first run gets.

To keep the v0.7.0 look:

[appearance]
dockbar_position = "bottom"
window_title_position = "bottom"
zoom_size = 100
click_to_type = "single"
window_button_style = "pill"
window_button_position = "right"

[appearance.sidebar]
enabled = false

Each line also works on its own, from the settings page (ctrl+b ,), or live with tuios set-config, for example tuios set-config zoom_size 100. ctrl+b b shows and hides the rail at any time.

Keys and mouse

• Plain ctrl+v goes to the pane, as 0x16, so vim's visual block works. Paste from the host clipboard is ctrl+shift+v, super+v or shift+super+v. To paste on ctrl+v again, bind it:

  [keybindings.terminal_mode]
  terminal_paste_host = ["ctrl+v", "ctrl+shift+v", "super+v", "shift+super+v"]
  

• alt+arrows move focus between panes in terminal mode. They used to reach the shell, where readline, fish and zsh use alt+left and alt+right to move by word. To give one back, run tuios keybinds free alt+left, or set the action to an empty list:

  [keybindings.terminal_mode]
  terminal_focus_left = []
  terminal_focus_right = []
  

  ctrl+b then the arrows still move focus.

• alt+n and alt+p move to the next and previous window in terminal mode, on a fresh config. Free them the same way if your shell uses them.

• esc after the prefix exits prefix mode. It used to detach. Detach is ctrl+b d. A config with the old binding is migrated on load.

• ctrl+b , opens settings. Rename window is ctrl+b r.

• ctrl+b M opens the Inbox on its mail. The mailbox is m from there.

• Multi-select is ctrl+shift+click. It used to be ctrl+click, which now grabs the window: ctrl and a left drag moves it.

• A left drag in a pane selects text and copies it on release. It used to move the window. appearance.copy_on_select = false stops the copy.

• A double click enters terminal mode, where a single click did. appearance.click_to_type = "single" brings that back.

• The mouse wheel scrolls the pane and no longer enters copy mode. Typing returns to the live screen.

• Right-click in window mode opens the pane menu, and a right drag resizes. In terminal mode the right button belongs to the pane: ctrl or shift and a right-click opens the menu, or set appearance.right_click_opens_menu = true.

• Window-mode digits 1 to 4 select windows. Corner snap moved to ctrl+b L then 1 to 4. The old default bindings are migrated on load. With tiling on, h and l focus the pane on that side.

• q and ctrl+b q open a quit menu, with detach as the default row.

• In the layout picker, delete moved from d to ctrl+d.

• Notifications moved from a top-right toast to the dock. Info stays 6 seconds, warnings 8, and errors until dismissed. [notifications] sets the durations.

Scripts

• TERM_PROGRAM is not always TUIOS. It is ghostty when kitty graphics are forwarded, WezTerm when sixel is, and WarpTerminal in a pane that starts Codex directly, so programs turn on what they can do. A shell pane with none of these is still TUIOS. A script that checks for tuios should read TUIOS_ENV (or TUIOS_PANE_ID).
• TMUX and TMUX_PANE are not passed to panes. A tuios started inside tmux used to hand them on, so programs thought they ran in tmux. A pane on another machine gets TUIOS_SESSION_REMOTE instead of TUIOS_SESSION.
• tuios ls with no daemon exits 3. It lists the sessions saved on disk, marked as saved. It used to print an empty list and exit 0.
• Appearance flags are only accepted by commands that draw: a bare tuios, attach, new, ssh and tape playback. Elsewhere they are an error, so tuios ls --theme x now fails. Drop them from other commands.
• Verbs refuse unknown input. An unknown parameter, an unknown set-option path, a bad colour, an unknown theme and an unknown run-command name are errors instead of being ignored.
• TUIOS_SOCKET reports the pane's daemon; it does not choose one. A script that pointed it at a fresh path to get a daemon of its own used to create its sessions in yours. A command now refuses when TUIOS_SOCKET names a socket where no daemon listens. To run a separate daemon, set XDG_RUNTIME_DIR and XDG_STATE_HOME.
• Calls from a pane are checked against its grants. With no [agents.permissions] table a pane holds admin, so nothing changes until you narrow it. A pane can never send as human.
• ask-agent and fan send the prompt as a bracketed paste and one carriage return. ask-agent refuses an agent blocked on a prompt unless you pass --allow-blocked.
• tuios attach with no daemon starts one instead of refusing.
• tuios layout export prints a tape script, not JSON.

Config

• animations_enabled is replaced by appearance.motion. An old file with animations_enabled = false reads as motion = "none", and true changes nothing. Where both are set, motion wins. Move to the new key: motion = "none", "basic" or "full".
• Removed keys: daemon.default_codec (the JSON wire codec is gone), daemon.socket_path (it was never honoured: the socket follows XDG_RUNTIME_DIR) and appearance.focus_follows_mouse_in_terminal. They are ignored. Delete them.
• Removed flag: tuios tape play --visible (-v), which nothing read. Drop it. The hidden tuios man command is gone.
• Removed actions: nav_up, nav_down, nav_left, nav_right, toggle_showkeys and prefix_logs. The top-left key-events overlay is replaced by the keycast.
• appearance.max_fps tops out at 120, the renderer's own ceiling.
• Selection colours are settings under [appearance.selection]: grey selection, amber search, cyan copy cursor, not bold. appearance.selection.bold = true brings bold back.
• The colorshift screen saver effect reads as random.
• Hooks moved to the daemon: after-new-window, after-close-window, after-focus-change, after-workspace-switch and after-agent-state run with the daemon's environment and fire once, not once per client. after-attach, after-detach, after-resize and after-layout-change stay in the client, and after-detach now also fires when an SSH connection or a browser tab goes away.
• Linked machines have a policy. A machine linked to this one gets what [hosts.NAME] allows, by default everything but answering prompts and approvals.

If you ran a build from main during this cycle, a few more apply. v0.7.0 had none of these keys:

• appearance.separator_style is removed. Delete it.
• Sidebar settings moved into an [appearance.sidebar] table. The old appearance.sidebar_* keys are still read, and the table wins.
• appearance.sidebar.show_windows and show_agents are folded into appearance.sidebar.sections when the config loads. Edit sections instead, for example sections = 'sessions,terminals,files,git,agents'.
• Reinstall the agent integrations. Copilot, Cursor Agent and Qwen Code now report their full state, and opencode, Kilo, Amp and Pi hooks changed. tuios integration status marks an old install as out of date. Run tuios integration install --all.

appearance.gap is not removed: an early gap key that did nothing became the working appearance.gap.

SSH

• tuios ssh checks keys. It admits the public keys in ~/.config/tuios/authorized_keys, or in ~/.ssh/authorized_keys when the first file is absent. --authorized-keys FILE names another file. Without keys, a loopback address still runs unauthenticated with a warning, and any other address is refused. --no-auth opens it on a network you trust.
• A connection that names no session gets one called ssh-session when several exist, instead of the first one listed. To reach a session, name it in the username (ssh api@host -p 2222) or run ssh host -p 2222 -t attach api. The usernames tuios, root and anonymous do not count as a name.
• The SSH session picker is removed. v0.7.0 never showed it.

Agents

• Agent state reporting is new in this release. Run tuios integration install --all to install the hooks for every harness you have, then tuios doctor agents.
• The Claude Code hook map changed for anyone who installed hooks from main. SessionStart means idle, Notification is read by its type, StopFailure means errored, and SessionEnd sets nothing. The hooks call tuios agent-hook, and the old Python shim only wraps it.
• Your own harness manifests: an idle screen rule needs a prompt_box region or a regex. argv_path matches whole path components, and only in the script an interpreter runs, not in any argument. A manifest that matches on a bare name shorter than five characters must add a [detect.require] block (for example exe_base = ["node"]) or it is refused. See Agents.

Terminal behaviour

• ED 3 (CSI 3 J) now clears only the scrollback, as in other terminals. It used to clear the screen too.
• Entering the alternate screen (modes 1049 and 1047) keeps the cursor where it is. It used to move it to the top left.
• With no theme, a program that asks for the terminal's colours (OSC 4, 10 and 11) gets your terminal's own answers instead of fixed black and white.

Embedders

pkg/tuios takes a config.Settings per client instead of package globals, many app.OS exports are gone, pkg/tfx is now the tuiffects module, and the SSH module is charm.land/ssh.

Known issues

• Windows in a session made by tuios fan open floating instead of tiled. t in window mode tiles them.
• In a pane whose shell does not send OSC 7, the rail's files and git sections stop following the pane's directory after tuios set-window --name renames the pane. A shell that sends OSC 7 is not affected.
• tuios update on a Homebrew install suggests brew upgrade --cask tuios. That is right for the tap's cask; for the formula in Homebrew core, run brew upgrade tuios.

Numbers

• 2,411 commits between v0.7.0 (29 March 2026) and the release, 2,078 of them not merges. v0.7.0 had 158, 157 of them not merges.
• 653 fixes, 396 features, 412 test commits, 152 docs commits and 91 performance commits, by their conventional-commit prefix.
• 2,429 files changed: 466,372 lines added and 39,887 removed.
• 97 JSON verbs, 167 options you can set live, 23 agent harness manifests, 18 harness integrations, 343 built-in themes, 36 screen saver effects, 4 glyph sets and 3 tilers.
• 30 engineering posts on the blog since June.

Thanks

Eight people besides me sent changes in this release:

• Sebastian Wagner (@SebaWag): percentage resize (#29), zen mode, the dock's workspace tab format, appearance.right_click_opens_menu, the native clipboard fallback for SSH and VTE terminals, the reattach replay fix, resolved colours in capture-pane, and the Nix package repairs.
• Siriwat Uamngamsup: entering terminal mode when keyboard focus moves to another pane (appearance.auto_enter_terminal_on_focus).
• Iain: list-options grouped by section, and the --list-themes warning fix.
• Ronan Arraes Jardim Chagas: chrome.surface in theme files.
• Masshiro: Home and End under application cursor keys (#193).
• @actes2: a resize floor so a vanishing display cannot panic.
• @ethanhawkes-gif: a panic on a wrapped nil colour.
• @FaintFlower: the README star chart.

And thank you to everyone who filed an issue, tried a build from main, or told me what broke.

• Video plays in a pane.
• fish 4.x's kitty keyboard handshake works.
• Copy mode has a scrollbar you can grab.
• A command palette lists every action.

Most of the fixes are the cost of passing another terminal's protocol through a multiplexer: clipping, positioning, flicker, and the gap between what a spec says and what mpv sends.

Changed behaviour

• The mouse wheel now enters copy mode. The separate scrollback mode, which could scroll but not select, is gone.
• The dock's clock, CPU and RAM meters are off by default, and are only polled when shown.
• A new --confirm-quit flag and confirm_quit option always ask before quitting.

Video playback

mpv --vo=kitty plays video in a tuios pane, and so does youterm. Shared memory and base64 modes both work. Use --vo-kitty-use-shm=yes: it sends a file reference per frame instead of streaming megabytes of pixels through the terminal.

Video is the hardest case for graphics passthrough, and most of the fixes were here:

• mpv marks every frame "more data coming" and never sends the final-chunk marker the protocol says to wait for, so passthrough that worked for static images waited forever.
• Each frame used to get a new image ID, forcing a delete and replace with a visible flash. Frames now reuse the host's image ID, so the terminal swaps the data in place.
• File-based frames are forwarded as a path instead of being read, base64 encoded and chunked, which saves about 4MB of allocation per frame at 30fps.
• All graphics output is wrapped in synchronized updates and flushed with the render cycle. Text and graphics arriving as two unsynchronized streams caused the tearing.

Static images got the same care: icat and yazi previews clip at the viewport, hide when their window leaves the screen, and follow the window during a drag.

The keyboard protocol shells expect

The VT emulator implements the kitty keyboard protocol: the full push, pop and query stack, with keys sent in CSI u encoding when a program has the protocol on. fish 4.x turns it on at startup, and before this release capital letters arrived as escape sequences fish ignored. As the spec says, shifted printable keys now send their text, and CSI u is kept for real modifier combinations.

The same work added:

• OSC 4 palette queries and OSC 52 clipboard.
• Modes 2026 (synchronized output) and 2027 (unicode core).
• Sixel in the DA1 reply.
• OSC 66 text sizing, as an experimental passthrough (see Known limitations).

Copy mode

• The mouse wheel drops you into copy mode, so scrolling up and selecting are one gesture. It has full vim navigation, visual and visual-line selection, search and yank.
• The border is a scrollbar, drawn in the theme's border colours and sized to the content. Click it to jump and drag it to scroll.
• Dragging a selection past the edge of the pane keeps scrolling on a timer, so the selection keeps growing while the mouse is still.

A new scrollback browser splits your history into command blocks using OSC 133 markers, with a regex fallback for shells that do not emit them. Each block is a command and its output, navigable with vim keys, and you can yank JSON fragments and file paths out of the output. fish and a configured starship both emit OSC 133.

An interactive figure goes here. Open the page to use it.

Command palette, sessions and layouts

• Command palette on Ctrl+P: every tuios action, fuzzy-searched, with its key shown beside it. A match on the name ranks above a match on the category. It floats at the top of the screen and works in both modes.
• Session switcher on prefix+S lists daemon sessions the same way.
• Layout templates save the BSP tree, each window's working directory (read from /proc), startup commands, and the tiling scheme. Positions scale when you load a template on a different screen size. Loading moves existing windows into place instead of killing them, and minimizes extras. The CLI is tuios layout list, delete, dir and export, and export turns a template into a tape script. The layout submenu is on Ctrl+B L.
• Zoom on z fills the screen with the focused pane. Press it again to restore. The dock shows a Z while zoomed.
• Shared borders. With --shared-borders, tiled windows are drawn without borders and a single line with proper junctions separates them, which saves two columns and two rows per split. It is opt-in because it took several attempts: the feature was reverted and reimplemented three times before the separator overlay stuck.
• Smart split picks the split direction from the focused pane's shape. It is opt-in because as a default it made narrow slices, so spiral stays the default.

An interactive figure goes here. Open the page to use it.

Faster underneath

• Rendering is driven by PTY output instead of a tick. The tick remains only for animations and tape playback, and slows to an idle rate when nothing moves. With the dock meters off by default, idle CPU is near zero.
• Unfocused windows without a selection take a fast path that skips per-cell styling. Windows on other workspaces skip render work, and tuios-web and SSH clients do not even receive their output until you switch to them.
• Base64 image data passes through without a decode and re-encode, which saves about 8MB of memory traffic per 4MB image. /dev/tty is opened once instead of per frame, and only placements that moved are placed again.
• tuios moved to the stable Charm v2 releases: bubbletea, lipgloss, wish and log.

Fixed

Most graphics fixes are described above. The rest, grouped:

Daemon mode

• The daemon's emulator dropped kitty graphics capability queries, so icat and chafa fell back to blocks. The daemon now answers them.
• PTY sizes sync on reattach instead of keeping the previous client's size.
• The client sends its pixel size and graphics capabilities to the daemon at hello.
• The subscriber buffer is 16 times larger, so video frames survive the socket from daemon to client.

Input and mouse

• Mouse motion is only sent to programs that asked for it. kakoune got hundreds of unrequested motion events a second (#78).
• Phantom keypresses from split mouse sequences are suppressed.
• Visual line mode highlights at once instead of on the next cursor move.

Colours and light themes

• Unstyled cells use the terminal's real default foreground instead of white, and SGR 39 and 49 reset to transparent instead of a fixed default. This fixes light themes (#41, #72, #74).

Responsiveness

• Closing a window with exit or ctrl+d no longer waits out a 500ms timeout (now 10ms), and a race that lost the close notification about half the time is gone.
• Background windows no longer show stale content until you touch them.

Other

• Tape scripts send CRLF on Windows, contributed by @dodorz.
• Many smaller fixes to scrollback, tiling toggles and overlay positioning are listed in the full changelog.

Known limitations

• OSC 66 text sizing breaks with scrollback and when a window moves.
• Sixel passthrough exists but is disabled until pixel-level clipping is implemented, so sixel images cannot be cropped to a window. Use kitty graphics.
• The kitty animation protocol (a=f, a=a, a=c) was tried and dropped. It needs image IDs to match between guest and host, and tuios remaps them. Run programs that use it outside tuios for now.
• Video without shared memory can flicker, depending on frame rate.

• Window cycling in terminal mode without the prefix key.
• A real terminal cursor, so vi-mode cursor shapes work.
• Compatibility fixes, several of them contributed.

Images, experimentally

tuios redraws each window's content into its own grid, so an image cannot pass through as is: its graphics commands carry positions that mean nothing to the host terminal. tuios now translates them.

• The VT emulator reads the graphics commands, tuios tracks each placement against its window, and forwards it to the host at the right cell.
• A placement is moved when its window moves, resizes or scrolls, and hidden when it is covered, dragged, or scrolled out of view.
• Shared memory, file and direct transmission all work, with chunking for large images.
• Cell pixel sizes are reported to the PTY, so programs size images correctly.

yazi and kitty icat show real images in tuios windows on a host terminal that supports them: Kitty, WezTerm, Ghostty, iTerm2, Foot or Contour.

Five fixes followed the feature in this cycle: clipping at window borders, placements drifting against scrollback, image ID collisions between windows, images left behind when a program leaves the alternate screen, and virtual placements that assumed a placeholder grid tuios did not have. More edges were found later.

Known limits

• TUIOS_KITTY_GRAPHICS=0 turns graphics off.
• Images wider than the viewport are hidden rather than clipped.
• Sixel is parsed but disabled until raster clipping exists.

Graphics detection by asking

tuios used to guess graphics support from the terminal's name. Now it asks.

• A DA1 query detects sixel, and the kitty graphics query detects the kitty protocol.
• Reads poll with a timeout, so a terminal that never answers cannot hang startup.
• TUIOS_DEBUG_CAPS=1 logs what detection found. TUIOS_KITTY_GRAPHICS and TUIOS_SIXEL_GRAPHICS override it either way.

Cycling without the prefix

Window management used to be three keys away in terminal mode. Now it is one:

• macOS: Opt+Tab and Opt+Shift+Tab cycle windows.
• Linux and Windows: Alt+N and Alt+P, because Alt+Tab belongs to the OS window switcher.
• Opt+Esc or Alt+Esc leaves terminal mode.

The bindings live in a new [keybindings.terminal_mode] section and show in the help menu. This part of the release was contributed.

A real cursor

tuios used to paint its own cursor, a cyan block drawn into the grid. It now moves and styles the real terminal cursor, so cursor shape sequences from programs pass through. A shell in vi mode shows a block in normal mode and a bar in insert mode, blinking included.

Fixed

• Paste works in daemon mode. Pasted text was written into the internal pipe whose responses are discarded, so it vanished.
• Arrow keys work in cmus and other ncurses programs. Programs that turn on application cursor keys mode now get SS3 sequences instead of CSI.
• Fast scrollback no longer crashes in colour comparison. Claude Code's output was fast enough to trigger it. Contributed.
• tuios builds on FreeBSD and OpenBSD.
• macOS terminal handling is split from Linux, because the shared ioctl constants were Linux-only.
• --hide-clock and --window-title-position survive opening new windows instead of being overwritten by the config loader. These two shipped as v0.5.1.
• Animation bookkeeping is skipped when nothing is animating.

Graphics stayed experimental well past this release, with horizontal clipping and sixel still open. TUIOS_KITTY_GRAPHICS=0 restores the old behaviour.

• A daemon keeps sessions alive when the client disconnects.
• More than one client can attach to one session.
• New CLI commands drive a running session from outside.
• BSP tiling, with manual splits.

Underneath, the code moved to the charm.land packages for Bubble Tea v2.

Breaking changes

• Import paths. If you build on tuios as a library, the Charm packages moved from github.com/charmbracelet to charm.land.
• Session state. State from before v0.5.0 does not carry over to the new daemon format.
• CLI. tuios new and tuios attach take the session name as a positional argument. The flags that did the same are gone.

Sessions that survive a disconnect

tuios new work      # create a session backed by a daemon
tuios ls            # list sessions
tuios attach work   # attach again

Detach, close the terminal, or lose the SSH connection, and the session keeps running. Attaching again brings back windows, layouts, BSP trees, screen contents and scrollback. A session lasts as long as the daemon process. The daemon is started in-process.

This works on Windows too. The daemon uses Unix sockets and ConPTY, which Windows has had since Windows 10 build 17063.

In daemon mode there are two VT emulators, the daemon's and the client's, and both answered terminal queries. The extra answers printed as text, such as ^[[?62;1;6;9;15;18;22c on reattach. The first fix dropped every reply, which made fish wait two seconds at startup for a Device Attributes reply that never came. What shipped: the daemon's emulator answers queries, and the client's drops its copies, so programs get their replies and nothing prints twice.

An interactive figure goes here. Open the page to use it.

More than one client

• Several clients can attach to one session and see the same thing. Focus, mode changes, workspace switches and window lifecycle sync in real time.
• The session renders at the smallest attached client's size, so nobody gets a cropped frame.
• The SSH server maps the username to a session, so ssh -p 2222 work@host attaches to work. Connecting without a name shows a session picker.

A typical use is pair debugging: one person creates the session and the other attaches from another machine.

Most of the fixes in this release made this stable. Client teardown, daemon goroutines and window callbacks had races that only show with two clients on one state. They got sync.Once on close, WaitGroup tracking, an atomic flag, a five-second shutdown timeout, and tests under the race detector.

A CLI for a running session

• tuios send-keys sends keys to tuios for window management, or with --literal --raw straight to the focused PTY, one character at a time.
• tuios run-command runs any tape command by name.
• tuios set-config changes configuration at runtime.
• tuios tape exec runs a tape file against the session.
• tuios list-windows, tuios get-window and tuios session-info read daemon state with no TUI attached, with --json for scripts.
• tuios logs tails the daemon.

All of them have shell completion.

BSP tiling

A binary space partitioning layout. New windows follow a spiral, alternating vertical and horizontal splits. When the spiral guesses wrong:

• Ctrl+B - and Ctrl+B | split explicitly.
• Ctrl+B R rotates the split at the focused window.
• Preselection chooses where the next window lands, and the dock shows the direction of the next split.
• An equalize command resets every ratio to 50/50.

Trees are kept per workspace and saved in daemon state, so a layout survives a detach and reattach.

Snapping, appearance and animations

• Dragging a window to a screen edge snaps it: top centre for fullscreen, the left or right edge for a half, corners for quarters. A window has a minimum size, so it cannot be dragged into nothing.
• window_title_position puts titles at the bottom, the top, or nowhere.
• hide_clock removes the clock overlay.
• Titles show the window's custom name or the terminal's own title instead of a default ID.
• Animations can be turned off with --no-animations or with a keybind. Off means off: snap, minimize and restore apply at once instead of playing a zero-length tween that flashes.
• Recorded tapes start with DisableAnimations, so playback looks the same on any machine.

tuios as a library

A first cut: pkg/tuios exposes the app as a Go package, with functional options for theme, shell and animations, and the recommended tea.Program settings for embedding it.

Under the hood

• The module moved to charm.land: Bubble Tea v2.0.0-rc.2, Lipgloss v2, Wish v2, and sip v0.1.11 to match.
• The CLI was split into one module per command.
• The VT emulator synced with upstream: about forty deprecated mode constants renamed, a nil colour panic fix ported, and grapheme width calculation simplified enough to drop two dependencies.
• The layout, pool and theme packages got tests, and staticcheck and go vet run clean.

Fixed

• Swapping windows in tiling mode updates the BSP tree, so a swap no longer snaps back on the next layout pass.
• Shift+Tab reaches the PTY as backtab even when the terminal reports extra modifier bits.
• On macOS, some opt+ bindings were registered as alt+.
• Reattaching to a tiled daemon session sized windows from the stale 80x24 handshake. Tiling now waits for the real size.
• Remote commands send maps and slices correctly, and the inspection commands work with no TUI attached.
• tuios-web got a --no-animations flag, theme setup, and a curl install script. An AUR conflict between tuios and tuios-bin was fixed.

Documentation

Five new guides: BSP tiling, tape recording, the ShowKeys overlay, multi-client sessions, and the library API.

A correction: the GitHub notes for v0.5.0 list tape recording and ShowKeys as new features. Both shipped in v0.4.0. This release added their documentation.

• A web terminal, as the separate tuios-web binary built on the sip library.
• Tape scripting, with a recorder and a manager UI.
• ShowKeys, an overlay that draws your keypresses for screen recordings.

The patch releases fixed resizing in floating mode and made the quit dialog ask only when something is running.

The web terminal

tuios-web serves tuios in a browser. It is a separate binary, so the main tuios binary carries no server code, and people who never use a browser never install one. It is a thin wrapper that hands tuios instances to sip's Handler interface. sip serves any Bubble Tea app in a browser.

It went through three designs before the release. It started as a tuios web subcommand: WebTransport with a WebSocket fallback, xterm.js with WebGL on the client, and a bundled Nerd Font. That embedded about 10MB of web assets in the repository and put an HTTP server in the window manager. The command then became its own binary, and the server moved into sip, taking the 10MB with it.

tuios web was added and removed within this cycle, so no tagged release ever shipped it and there is nothing to migrate.

The rebuilds fixed two defects:

• Web sessions used to start the tuios binary as a subprocess. They now run tuios in-process over pipes, like the SSH server.
• The first frame was drawn at a fixed 80x24 before the browser reported its size, which left artifacts. The session is now created after the browser's first resize, so the first frame has the right size.

Tape scripting

A .tape script drives tuios from a file: open terminals, type into them, manage windows, switch workspaces and modes, and pause between steps.

• tuios tape validate checks a script.
• tuios tape play runs it live with a progress indicator.
• Playback goes through the same Bubble Tea update loop as live input, so a tape and a person at the keyboard run the same code.
• The recorder captures your starting state, window actions, mode switches and workspace switches. Consecutive characters become one Type command, so a recorded tape reads like one written by hand.
• The tape manager on Ctrl+B T m browses, records and manages tapes without leaving the session.

A headless tape run mode existed during development. It never worked properly and was removed rather than shipped.

ShowKeys

tuios can draw your keypresses in the bottom right as you type, inspired by nvzone/showkeys. Turn it on with --show-keys or toggle it with Ctrl+B D k.

• Keys are drawn as pills styled like the window title, with modifiers spelled out.
• Repeats collapse into a count (j ×3).
• Keys stay for three seconds. The first version used one, which was too short to read.

The leader key is now configurable as well. It was fixed at Ctrl+B, and now comes from leader_key in the [keybindings] section. The help menu and every chord follow it, and ShowKeys highlights it so a viewer can spot it in a recording.

An interactive figure goes here. Open the page to use it.

Changed: the patch releases

v0.3.1 to v0.3.4 shipped in the first week of November. Most of it fixed resizing in floating mode.

• During a drag, the window geometry updates at once and the PTY resize waits until release, so the shell no longer gets a stream of resize signals.
• The emulator's size stays in sync with the window's, so content no longer sticks at the old size while the border moves.
• A "Resizing... WxH" indicator shows in the window during a drag. In tiling mode, neighbours pulled along by the drag show it too.
• After a drag, PTY buffers are flushed and polling waits for the shell to redraw its prompt at the new width, which fixed half-drawn prompts.
• If the cursor ends up below the view after a height reduction, the view scrolls to keep the prompt visible.
• Dragging right after a resize no longer freezes the window.

Other changes in the patches:

• Quitting with open terminals shows a confirmation. It asks only when a terminal's foreground process is running something, so quitting idle shells just quits.
• The welcome screen shows on any workspace with no visible windows, not only when the whole session is empty.
• The shell is configurable. This mattered most on Windows, where tuios always started PowerShell.

Fixed

• Decimal durations in tapes parse correctly, so 1.5s no longer rounds.
• The render cache is cleared when leaving resize mode, so the resize indicator disappears at once.
• ShowKeys compares modifiers, so Ctrl+L followed by L shows two keys instead of one pill.

Project

• A contributing guide.
• Package doc comments across all internal packages, a golangci-lint cleanup, and a modernization pass (any over interface{}, slices.Delete, built-in min and max).
• README keybindings use kbd tags.
• tuios.exe is gitignored.

The .tape format introduced here is the one project tapes were later built on.

Breaking changes

• Themes are off by default. v0.2.0 turned them on, and an opaque themed background fights any program that wants to set its own. The terminal background is now transparent and the default theme is none, so you get your terminal's own colours. To get the v0.2.0 look back, add theme = "tokyonight" (or any theme) to your config.

Keys that mean what you typed

tuios moved to Bubble Tea v2.0.0-rc.1 and handles its keyboard enhancement messages. On a terminal that supports the kitty keyboard protocol, tuios detects it and turns it on, with nothing to configure.

A classic terminal cannot tell Shift+Enter from Enter, and cannot report Super+Space at all. With the protocol on, these arrive as separate keys, complex modifier combinations work, international layouts report correctly, and the keys reach the program in the pane unchanged.

In terminal mode, tuios used to catch the tiling resize keys, so you could not type <, >, { or } into a shell. Now only the Ctrl+B prefix is caught in terminal mode, and every other key goes to the PTY.

Tiling you can shape

• The master window ratio is configurable from 30% to 70%.
• Eight new resize operations, with directional variants.
• Each workspace remembers its layout and restores it.

Appearance

These live in a new [appearance] config section, with matching flags.

• The dock can sit at the bottom, at the top, or be hidden. Contributed by Cjreek.
• Nine border styles: rounded, normal, thick, double, hidden, block, ascii, and two half-block variants.
• The window control buttons can be hidden.
• Windows follow the cursor visibility a program asks for, so cmatrix hides the cursor and nvim shows it.

Scrollback

Scrollback moved from a growing slice to a fixed-size ring buffer. The common operations went from O(n) to O(1), which is 10 to 20 times faster once the buffer is full. The size is configurable from 100 to 1,000,000 lines, with a default of 10,000.

Fixed

• Switching workspace during an animation left windows where the animation had reached, sometimes one fullscreen with the rest piled on top. Animations now finish on a switch: the old workspace snaps to its tiled layout at once, and the new one tiles with its usual animation.
• Grid layouts with five or more windows no longer leave dead space at the bottom.
• With the dock at the top, mouse resizing no longer uses boundaries two lines off.
• The parent TERM variable is kept, with xterm-256color as a fallback.
• tuios answers XTWINOPS queries (CSI 14, 16 and 18 t), so programs that ask for the window size in pixels or cells get an answer.
• PTY setup is split into platform-specific files, which fixes the Windows build after Unix-only process attributes broke it.
• Viewport clipping mis-parsed ANSI escapes because of a logical AND that should have been OR.

Project

• Contributor plumbing, mostly from cr2007: issue forms for bugs and feature requests, an auto-labeler, a PR template, a security policy, and README keybindings shown with kbd tags.
• The README notes kitty protocol support, from ShalokShalom.

v0.3.0 was tagged on 5 November 2025. Everything after it builds on the Bubble Tea v2 migration.

Themes

tuios ships over 340 colour themes from bubbletint. Pick one with --theme (the default is tokyonight).

• A theme recolours the programs in your windows too, not only the chrome. A custom SGR handler maps the 16 ANSI colours to the theme's palette, so ls, vim and htop follow it.
• 256-colour and RGB sequences pass through unchanged, so a program that asks for an exact colour still gets it.
• Borders show state: an unfocused window uses the theme's red, a focused window in window mode is bright cyan, and in terminal mode it is bright green.
• --list-themes prints every theme, and --preview-theme shows a theme's 16 ANSI colours with their hex values.

A new PTY layer

Every window runs on a pseudo-terminal, and this release swaps the library that provides it: go-pty out, charmbracelet's xpty in, for a cleaner API and better Windows ConPTY support.

The switch first broke shell startup. Processes no longer got the PTY as their controlling terminal, which shells such as fish need, so windows opened and died at once with exit status 1. The fix, in the same release, sets up the process session and controlling terminal explicitly, as the old library did implicitly.

Changed and fixed

• Windows can no longer be dragged or resized off screen. They stay inside the viewport and out of the dock, which also fixes drawing artifacts at the edges.
• tuios exits cleanly. It handles SIGINT and SIGTERM, and on the way out it turns off mouse tracking, restores the cursor, and leaves the alternate screen, so your shell prompt is intact.
• The README gave two background refresh rates. It now says 30Hz, not 20Hz. Caught by ShalokShalom.
• The Nix packaging workflow now runs on tag pushes, not only on release events, so it runs for every version.

v0.2.0 was tagged on 2 November 2025. Two patch releases followed within days. Their changes are on the v0.3.0 page.

Breaking changes

• The CLI moved from flat flags to subcommands. --ssh became tuios ssh, and the other flags moved the same way.

Scrollback and copy mode

Before this release, text that scrolled off screen was gone, and text on screen could not be copied. Both are fixed.

• Scrollback. Each window keeps 10,000 lines. Enter it with Ctrl+B [ or by scrolling the mouse wheel up, and move with the arrows or vim keys. The upstream VT library had no scrollback, so tuios runs on a fork, and the change was sent upstream as a pull request to charmbracelet/x.
• Copy mode. Vim-style motions: hjkl, word motions, gg and G, count prefixes (10j, 100G), f, F, t and T character search that handles wide characters, / and ? search with highlighted matches, % for bracket matching, and v or V visual selection yanked to the clipboard with y.
• Mouse selection. Click and drag, double-click for a word, triple-click for a line.

Copy mode started as one 2,137-line file and was split into six modules before the tag.

Configuration and the CLI

• A config file. ~/.config/tuios/config.toml is created on first run with comments that document it, and follows XDG. Every keybinding in every mode can be rebound.
• Actions, not code. A key maps to an action name and an action name maps to a handler, so rebinding needs no code change. The help overlay is built from the config, so it shows the keys you actually have.
• Platform defaults. macOS gets opt where Linux gets alt.
• Subcommands. The CLI moved to Cobra, with Fang for help output: tuios runs it, tuios ssh runs the SSH server, and tuios config and tuios keybinds manage the two above. Shell completions and man pages are generated.

The prefix key

Everything hangs off a tmux-style Ctrl+B prefix, which now has submenus:

• w: workspaces (switch to one, or move a window to one)
• m: minimize and restore
• t: window commands
• [: scrollback
• q: quit

A which-key overlay appears after half a second and shows what each submenu offers.

On macOS, Option plus a number types a character such as ¡ or ™ instead of sending a modifier. tuios recognises those characters as workspace switches, and the help text says "Opt" on a Mac and "Alt" elsewhere.

Rendering is 30 times faster

The prototype rendered every cell of every window through a new lipgloss style on every frame. A 13.45-second CPU profile spent 4.85 seconds in renderTerminal. Two changes fixed it:

• A style cache keyed on cell attributes. A hit costs about 99 nanoseconds and no allocations.
• Terminal content is written as ANSI escape codes directly, skipping a style pipeline built for UI boxes. Neighbouring cells with the same style are batched, which cut style renders per frame from about 2,000 to about 50.

After both, renderTerminal took 0.16 seconds in the same profile, and total CPU use fell from 53% to 24%. The input path also stopped clearing the render cache on every keystroke.

An interactive figure goes here. Open the page to use it.

Terminal behaviour

• Mouse events reach programs on the alternate screen, so drag-to-select works in vim, scrolling in less, and clicking in htop.
• Paste works through OSC 52 and bracketed paste, including Cmd+V.
• The alternate screen is detected through VT callbacks instead of guessed.
• nushell no longer clears its own output. The VT library answered cursor position queries with stale coordinates, so tuios now corrects those replies.
• The PTY layer changed twice and ended on charmbracelet/x/xpty, for Windows ConPTY support. The forked VT package is vendored, so plain go install works.
• In tiling mode, swapping, minimizing and retiling only touch windows in the current workspace.

Installing

• GoReleaser builds for Linux, macOS, Windows, FreeBSD and OpenBSD.
• Releases publish to a Homebrew tap and the AUR (tuios-bin), and there is a one-line curl installer.
• The Nix package and devshell were the project's first outside contribution.
• The binary is statically linked, so there is no glibc version to match.
• --ascii-only draws without Nerd Font icons, for machines that do not have one. It was added four days before the tag.

Fixed

• Notifications stayed up for about 17 days instead of 1.5 seconds. A duration already in milliseconds was multiplied by time.Millisecond.
• Comparing cell colours could panic on a nil pointer: a non-nil color.Color interface can hold a nil value. This was the last fix before the tag.
• Typing over SSH did nothing after the restructure, because the input handler was registered for local mode only.
• On macOS, exit did not close the window when the exit message was missed. The tick loop now checks the process directly.
• Visual selection highlighted the empty cells past the end of each line. It now stops at the text.
• Mouse selection in copy mode was off by one row.
• Dragging a window a few pixels no longer corrupts the tiled layout.
• The Windows build compiles again, after resize signalling was split into platform-specific files. Nobody had reported running it there.