v1.0 · Linux, macOS, Windows · MIT

Split the terminal.
Keep it running.

A terminal multiplexer written in Go: tiling panes, tabs and workspaces in one window, and shells that keep running after you close it. New in 1.0 — every pane can be driven from outside, so a script or a coding agent can start work, wait for it, and read what it printed.

Install slatRead the source
88×16

Not a screenshot: slat's own layout engine, ported to the page. Press the keys.

$ slat

One window, however many shells

It does the multiplexer things, and gets out of the way. No plugin manager, no server config, no second language to learn.

Sessions outlive the window
The shells run in a background daemon. Close the terminal, lose the SSH connection, come back with slat — the output is still there.
Panes, tabs and workspaces
Split a pane either way, move between them by direction, walk a pane around the layout, zoom one to full size, group tabs into named workspaces.
Scroll back, search, copy
Every pane keeps its own history, with vim keys and smart-case search. Select with v or V and press y — it copies over ssh too, because the clipboard asked for is yours, not the remote machine's.
Only what changed is drawn
slat paints from its own terminal emulator and sends the difference, so half a million lines of output arrive in about a third of a second.
One binary, no runtime
Static Go, nothing to install alongside it. The config file is optional — and a mistake in it is reported when you start, never ignored.
Windows, properly
Panes run on a ConPTY and the socket is an AF_UNIX socket, so the same session model works there. The test suite runs on all three platforms.

$ slat # in a real terminal

Here it is, actually running

Splitting, running two things at once, scrolling back through the output, then detaching and picking the session up again with everything still alive.

$ slat wait 4 --for idle --timeout 10m

A terminal an agent can drive

Agents are good at running commands and bad at watching them. 1.0 gives slat a command line of its own, so anything outside the terminal can open a pane, start the work, wait for it, and read the result — with exit codes instead of guesswork.

  • slat lsevery pane, and what each one is doing
  • slat pane new --cmd Copen a pane running C, without taking your focus
  • slat run PANE …type a command into a pane and press Enter
  • slat wait PANE --for …block until idle, input, exit, or text=REGEX matches
  • slat capture PANEread a pane's text, screen or scrollback
  • slat send PANE --key ctrl-canswer a prompt, or interrupt

Four things a pane can be

idle
the pane's own shell has the terminal: the command finished
working
a program is running
input
something stopped to ask a human — the tab is marked
exited
the pane's program is gone

Exit codes are the contract

0
it happened
1
the command was wrong
2
timed out
3
that pane is gone

Add --json to any command for one object with a schema field.

88×14

A build that stops on Overwrite? [y/N] is neither finished nor working. slat calls that input, marks the tab with a ?, and can run a command to tell you. Waiting for idle wakes on it too, so an agent never sleeps through a question.

Shell builtins count: read -p is caught even though the shell itself is the foreground process.

Nothing leaves the machine. slat has no network code — the commands talk to the session over its own socket, readable only by you.

$ $EDITOR ~/.config/slat/config.toml

Make it yours

Colour, shape and motion all belong to whoever runs it: five palettes or your own, six border styles or your own glyphs, a status bar written as a format string, and animation timing per event. Pick two and watch the session change.

theme

borders

88×16
[theme]
name = "default"

[borders]
style = "sharp"

[status]
left  = " {workspace} │ {tabs}"
right = "{badge} pane {pane}/{panes} "
tab   = " {index}:{name}{alert} "

[animation]
split  = "90ms"
move   = "120ms"
easing = "out-cubic"

A theme colours what slat draws — the bar, the borders, its overlays. Programs in your panes keep their own colours, and fonts belong to your terminal, not to slat.

Every key is rebindable, and a mistake anywhere — an unknown colour, a glyph two columns wide, a placeholder that doesn't exist — is refused when slat starts instead of drawn badly later.

Four finished setups live in docs/rices, including one that is ASCII and sixteen colours for a bare console. Send yours.

$ sudo apt install slat

Install it

One static binary, and a first run that needs no configuration. Type slat to start a session; type it again from anywhere to get that session back.

$ curl -fsSL https://noturbob.github.io/slat/apt/key.gpg | sudo tee /usr/share/keyrings/slat.gpg > /dev/null # trust the signing key
$ echo "deb [signed-by=/usr/share/keyrings/slat.gpg] https://noturbob.github.io/slat/apt stable main" | sudo tee /etc/apt/sources.list.d/slat.list
$ sudo apt update && sudo apt install slat

slat is also on its way into Debian itself, sponsored through the usual review.

slat turns one this October, and 1.0 is tagged for the occasion. Until then the packages above install the current release, and building from main gets you everything on this page.

$ slat --help

Everything is a keystroke away

Press the prefix — Ctrl-S by default — then one key. Press it twice to send it through to the program. Every binding below can be changed, and two commands can never end up fighting over the same key.

Panes

  • C-s v hsplit left / right, top / bottom
  • C-s k j H Lfocus the pane above, below, left, right (or the arrows)
  • C-s mmove mode: walk the pane around with hjkl, q leaves
  • C-s < > K Jmove the pane left, right, up, down
  • C-s sswap with the next pane
  • C-s + - =grow, shrink, equalize
  • C-s zzoom the pane to full size
  • C-s xclose the pane
  • C-s [scroll back, search, select and copy (v, V, y)

Tabs, workspaces, session

  • C-s c n pnew tab, next, previous
  • C-s , Xrename the tab, close it
  • C-s W w Pnew workspace, next, previous
  • C-s $rename the workspace
  • C-s ddetach — everything keeps running
  • C-s qquit
  • C-s ?show every binding