boo is live · free · last verified 8 Nov 2026 · viability monitor
boo
A GNU screen style terminal multiplexer on libghostty with send, peek and wait automation for scripts and AI agents
boo fixes a concrete, annoying failure: screen sessions that redraw wrong after a modern TUI ran detached. Routing every session through libghostty-vt means attach shows what the terminal would actually display. The send/peek/wait trio — with --json output and exit code 4 on timeouts — is what makes it genuinely useful for driving interactive programs from CI or an agent harness rather than just another screen clone.
Verdict generatedVerified 6d ago · liveness 66/100 · cite: rightaichoice.com/tools/boo
- Developers and sysadmins who need sessions that survive disconnects and redraw correctly on reattach
- GNU screen users whose detached output gets mangled by modern TUI programs
- CI/CD pipelines running interactive commands that must fail with a timeout instead of hanging
- Script and AI-agent authors who need predictable, machine-readable terminal reads with --json
- tmux users who need panes, splits and layouts in a single view
- Teams depending on a plugin ecosystem or a heavily customized status bar
- Anyone needing built-in session sharing or pair-programming
We scan live Reddit threads, YouTube comments, X posts, G2 reviews and other communities — and hand you an honest verdict in under a minute.
- Honest verdict, not marketing
- Real pros & cons from real users
- Attributed quotes with receipts
3 free scans · no card needed
Skip boo if your workflow depends on tmux panes, splits, or plugins — boo intentionally ships sessions, a prefix key, and `boo ui` only, with no pane splitting or extension ecosystem.
boo is MIT-licensed and costs $0 — the source, pre-built Linux and macOS binaries, the curl installer, and every automation primitive (send, peek, wait, --json, boo ui) are free. The real cost is engineering time: you're adopting an early-stage 83-commit project as infrastructure and possibly building from source with Zig 0.15.2. Compare against tmux and GNU screen, which are also free but far more battle-tested.
In short
boo — A GNU screen style terminal multiplexer on libghostty with send, peek and wait automation for scripts and AI agents. Best for Developers and sysadmins who need sessions that survive disconnects and redraw correctly on reattach, GNU screen users whose detached output gets mangled by modern TUI programs, CI/CD pipelines running interactive commands that must fail with a timeout instead of hanging. Free to use.
What is boo?
boo — A GNU screen style terminal multiplexer on libghostty with send, peek and wait automation for scripts and AI agents. Best for Developers and sysadmins who need sessions that survive disconnects and redraw correctly on reattach, GNU screen users whose detached output gets mangled by modern TUI programs, CI/CD pipelines running interactive commands that must fail with a timeout instead of hanging. Free to use.
boo is an MIT-licensed terminal multiplexer that keeps GNU screen's model — sessions, a Ctrl-a prefix, nothing else — but replaces screen's decades-old terminal emulator with libghostty-vt, Ghostty's VT core. Every session's output gets parsed through that core, so boo always knows the real screen state: contents, SGR styles, cursor position, scrollback, scrolling regions, window title and terminal modes. That state rehydrates your terminal on attach, answers terminal queries for detached sessions so TUIs don't hang unattended, and lets scripts read the screen the way a human would see it. It's written in Zig. Daily use feels like screen. `boo new work` starts a named session, `boo new work -d -- make` creates one detached running a command, `boo attach work` reattaches, `boo ls` lists, `boo rename` relabels, `boo kill` ends one or `--all`. `boo ui` opens a full-screen session manager with a sidebar for switching, resizing, creating and killing. With no name, sessions default to the current directory, falling back to pid when that name is taken. Keybindings follow screen's defaults, C-x variants included. The departure is automation, and it's the reason boo exists. Everything except attach works without a TTY, so you can create a headless session, drive it with `boo send`, settle output with `boo wait`, and read the rendered screen with `boo peek`. peek reconstructs the screen from terminal state rather than dumping a byte log; `--scrollback` adds history and `--json` adds size, cursor and title. `wait --text` blocks until a string appears, `--idle` fires after two seconds of quiet, and `--timeout` exits 4 instead of hanging. Positioning is deliberate: boo is not tmux and doesn't try to be. No panes, no layouts, no plugin ecosystem. If you live in splits, stay in tmux. If you want screen's one-session-per-task model with an emulator that understands what modern programs emit, boo is the swap worth making.
Key features
- GNU screen style terminal multiplexer built on libghostty (libghostty-vt), written in Zig
- Detach with Ctrl-A d or C-a C-d, reattach with boo attach
- boo ui full-screen session manager with a sidebar for switching, resizing, creating, killing
- Faithful redraws from libghostty terminal state: SGR styles, cursor, scrolling regions, window title, terminal modes
- Headless automation primitives send, peek and wait, all usable without a TTY
- boo wait --text blocks until the screen contains the given text
- boo wait --idle fires after 2 seconds of output quiet
- boo wait --timeout exits 4 instead of hanging (durations like 500ms, 2s, 1m, 4h, 1d)
- boo send --text is literal: no escape processing, no implicit newline
- boo send --enter submits; --key names control keys like Enter, C-c, Up; stdin is binary safe
- boo peek prints the reconstructed screen; --scrollback adds history, --json adds size, cursor, title
- Machine-readable output via boo ls --json and boo peek --json
- Documented exit codes: 0 success, 1 error, 2 usage, 3 no such session, 4 wait timed out
- Terminal queries answered while detached so TUIs don't hang unattended
- Session names default to the current directory, falling back to pid when taken or unusable
Behind the verdict
The pitch that lands with us isn't "screen, but newer." It's that boo treats the terminal screen as structured state you can query, not a stream of bytes you have to tail and hope to parse. peek reconstructs the rendered screen; ls --json and peek --json give you size, cursor and title in a machine-readable shape. For anyone writing an agent harness or a CI step around an interactive program, that changes the job from sleep-and-poll guesswork to a deterministic read. Pick boo when your workflow already resembles screen — one session per task, a prefix key, no fuss — and you've been bitten by detached output that comes back mangled after a TUI ran. Pick it too if you're scripting an interactive CLI: `send --text` is literal, `--key` names control keys, stdin is binary safe, and `wait --idle` or `wait --text` with `--timeout` (durations up to 1d) means a stuck process fails with exit 4 rather than wedging your pipeline. Pass if you need panes, splits and layouts in one view. That's tmux's territory, and boo's author is upfront that it solves a different problem. Pass as well if your team leans on a plugin ecosystem or a customized status bar — there's nothing here to plug into. Session sharing and pair-programming aren't part of the model either. Watch the install path. The supported route is a curl-piped script or a pre-built binary from the releases page; on locked-down machines the pipe-to-shell install will need a policy exception, and you can pin with BOO_VERSION or redirect with BOO_INSTALL_DIR to soften that. Building from source means Zig 0.15.2, and libghostty is fetched and built automatically, so a first build is not instant. Nix users get a flake if that's your normal groove. Where it bites: boo is young — a few dozen commits, a small contributor base,
Limitations
- No tmux-style pane splitting, window layouts, or per-project panes — the intended shape is one session per task plus `boo ui` to juggle them.
- There is no plugin or extension ecosystem, no built-in session sharing or pair-programming, and no customized status bar.
- Pre-built binaries are published only for Linux and macOS; Windows users must build from source. boo is an early-stage project (83 commits, 791 stars, 4 open issues at the time of this scrape), so documentation may lag the CLI — `boo help`, `boo help <command>`, and `boo help --all` are the authoritative references rather than a docs site.
- The install path is a curl-piped script from the repository's install.sh, which some locked-down environments block, and the small open-issue count means behavior in unusual terminal setups is less battle-tested than screen's or tmux's.
as of 2026-10-20
Researching boo? Get your full AI stack in 60 seconds.
Free, no signup — tell us your goal and get tools matched to your budget & existing stack.
Is boo still active?
boo is live · free · last verified 8 Nov 2026 · viability monitor.
Viability score
How well maintained and how widely used is boo? Built from what the vendor actually publishes (docs, changelog, tutorials, integrations, pricing), whether the site is live, and how much real users discuss it. How we calculate this
Last calculated: November 2026
How we score →What do users say about boo?
What people actually say about boo — is it worth it?
We ran a structured research pass across product reviews, community discussions, and post-purchase forum threads to surface the patterns vendors won't publish themselves. Below: the recurring strengths, the hidden costs people mention most, and the cohort that consistently regrets adopting this tool.
ResearchedDiscussed by users across 5 sources (Hacker News, Product Hunt, App Store, Stack Overflow, Lemmy) · researched Oct 16, 2026.
Weighted by the 62 posts each of 5 sources contributed.
- +Keeps GNU screen's session model and C-a bindings, so screen users migrate with almost no relearning
- +Parses every session through libghostty-vt, enabling faithful SGR styles, cursor, and terminal mode redraws
- +Headless send, peek, and wait work without a TTY, making agent scripting practical
- +peek prints reconstructed screen state rather than raw bytes, cutting parsing work for automation
- +wait --text, --idle, and --timeout with exit code 4 give scripts deterministic control flow
- −No corroborated user feedback anywhere — all 62 scraped posts are off-topic name collisions
- −Deliberately drops tmux's panes, plugins, and status-bar customization, limiting workspace layout
- −Name is nearly impossible to search for help, given Boo the language and BOO! video chat
- −No documented integration ecosystem or editor plugins to extend the automation primitives
- −Requires Zig 0.15.2 to build from source, a fast-moving version constraint for contributors
- • No paid support exists, so debugging falls entirely on you or volunteer maintainers
- • Time cost of building from source if no prebuilt binary matches your platform
- • Potential migration cost back to tmux if the project stalls, given no community lock-in
How we verified this
Every listed fact about boo — pricing, features, links, status — is re-read from the vendor's own pages by our verification pipeline and each change is logged with a date; the last pass ran on 8 Nov 2026. Analysis is drafted with AI models and checked against our editorial standards before publishing; see how we verify.
Verification history
We have re-verified boo 17 times since . Each pass re-reads the vendor's own pages and re-checks every listed field against that evidence; passes where nothing had changed are marked as such.
- — changed pricing page, summary, who it suits, pricing tiers, who should skip it, features, description
- — changed pricing tiers, description, summary, our verdict
- — changed pricing page
- — changed description, who it suits, our verdict, summary, features, who should skip it, pricing tiers
- — changed pricing page
- — changed who should skip it, switching out, setup time, pricing fit, features, our verdict, summary, switching in, limitations, description
Showing the 6 most recent of 17 verification passes.
Free to cite with attribution — this page re-verifies continuously.
How much does boo cost in 2026?
boo: Free to use. Pricing last verified 8 Nov 2026.
Plans compared
Every published boo tier, its price as the vendor publishes it, who it fits, and what it adds over the tier below. The 12-month cost projection follows.
| Plan | Price | Billing | Who it's for |
|---|---|---|---|
| Open source (MIT) | Free | — | Individual developers, sysadmins, script authors, and AI-agent builders who want a screen-style multiplexer with headless automation and no license costAdds: The only tier — full source under MIT, pre-built Linux and macOS binaries, the curl installer, and every automation primitive (send, peek, wait, --json, boo ui) included at $0 |
12-month cost
Project the real annual outlay, including the implied monthly cost when only an annual tier is published.
Vendor list price only. Add-on usage, seat overages, and contract minimums are surfaced under Hidden costs & gotchas.
Where the pricing makes sense
The company stage and team size where boo's pricing actually pencils out — and where peers do it cheaper.
boo is MIT-licensed and costs $0 — the source, pre-built Linux and macOS binaries, the curl installer, and every automation primitive (send, peek, wait, --json, boo ui) are free. The real cost is engineering time: you're adopting an early-stage 83-commit project as infrastructure and possibly building from source with Zig 0.15.2. Compare against tmux and GNU screen, which are also free but far more battle-tested.
Has boo's pricing changed?
No plan price for boo has moved since we began logging in Aug 2026; the pricing page is re-read on every verification pass.
Who should pick boo?
Pick boo if you are Developers and sysadmins who need sessions that survive disconnects and redraw correctly on reattach, GNU screen users whose detached output gets mangled by modern TUI programs, CI/CD pipelines running interactive commands that must fail with a timeout instead of hanging, Script and AI-agent authors who need predictable, machine-readable terminal reads with --json.
Look elsewhere if you are tmux users who need panes, splits and layouts in a single view, Teams depending on a plugin ecosystem or a heavily customized status bar, Anyone needing built-in session sharing or pair-programming, Environments where a curl-piped install script is blocked by policy.
Skip it if Skip boo if your workflow depends on tmux panes, splits, or plugins — boo intentionally ships sessions, a prefix key, and `boo ui` only, with no pane splitting or extension ecosystem.
GeneratedReal-world workflow fit
Concrete scenarios for the personas boo actually fits — and what changes day-one when you adopt it.
You start `boo new deploy -d -- ./deploy.sh`, drop the connection mid-run, then come back later and run `boo attach deploy`.
Outcome: Your terminal is rehydrated from libghostty terminal state — SGR styles, cursor, window title all correct — instead of replaying a mangled byte log.
The agent runs `boo new build -d -- bash`, types with `boo send build --text 'make' --enter`, blocks on `boo wait build --idle`, then reads the result with `boo peek build --scrollback --json`.
Outcome: The agent gets the rendered screen plus size, cursor, and title as JSON, with no TTY required and exit code 4 on timeout instead of a hung process.
A pipeline step launches the program inside a detached boo session and guards it with `boo wait --timeout 2m --text 'Ready'`.
Outcome: The job either proceeds when the expected text appears or fails fast with exit code 4 rather than hanging until the runner's global timeout.
Use cases
- Keep terminal sessions alive across network drops and reattach to the exact same screen
- Read a detached session's rendered screen with boo peek instead of parsing a raw byte log
- Drive an interactive program from a script using new -d, send, wait, and documented exit codes
- Build AI agents that create a headless session and poll it with wait --text or wait --idle
- Run CI steps that need a correct terminal state and a hard timeout rather than a hung job
- Manage many sessions from one sidebar with boo ui instead of remembering attach targets
- Get JSON session metadata (size, cursor, title) with boo ls --json and boo peek --json
Setup time & first value
How long it actually takes to get something useful out of boo — broken out by persona, not the marketing-page minute.
One curl command to a working session on Linux or macOS, or grab a pre-built binary from the releases page — under five minutes for the basic attach/detach loop. Budget longer if you're wiring send/peek/wait into a script: you'll want to read `boo help --all` since there's no separate docs site. Windows users should plan for a source build with Zig 0.15.2 or Nix.
Switching to or from boo
How to bring data in from common predecessors and how to get it back out — written for the switcher, not the buyer.
- →From GNU screen: your prefix habits carry over — Ctrl-A d detaches, and the C-a C-d variant works too; recreate sessions with `boo new <name> -d -- <command>`
- →From tmux: move one session per task and manage them with `boo ui`; there are no panes to port, so flatten layouts into separate sessions
- →From raw ssh + nohup: replace backgrounded commands with `boo new <name> -d -- <command>` and read output later with `boo peek <name> --scrollback`
- ↗To tmux: recreate each boo session as a tmux session; expect to rebuild any pane layouts from scratch since boo has none
- ↗To GNU screen: boo's prefix bindings map back directly, but you lose libghostty's state-aware redraw and the peek/wait automation primitives
Resources & guides
Tutorials & Learning
YouTube returned 6 videos for “boo”, and we withheld 6: 6 could not be judged, because “boo” is a single word that other videos use for other things. We are showing none, because we could not prove any of them are about boo.
Official links
What are the best boo alternatives?
The closest alternatives to boo we list are Harness Terminal, Terax Ai and Robotgo. Ranked by direct product-type match, not category overlap.
| Alternative | Pricing | Starts at | Last verified |
|---|---|---|---|
| Harness Terminal | Free | Free | — |
| Terax Ai | Free | Free | — |
| Robotgo | Free | Free | — |
Alternatives to boo
View all
Harness Terminal
Harness is a native Mac terminal for coding agents, with a built-in multiplexer and sessions that keep running after you close the window.
Tools that pair well with boo
Common stack mates teams adopt alongside boo, with the specific reason each pairing earns its keep.
Harness Terminal
Harness is a native Mac terminal for coding agents, with a built-in multiplexer and sessions that keep running after you close the window.
Terax Ai
Terminal-first AI dev workspace: Vim editor, AI agents, Git graph, and live web preview in a 7 MB app
Robotgo
RobotGo: a Go library for desktop automation of mouse, keyboard, screen and windows
boo vs its closest rival
boo's closest head-to-head is with Spider Cloud — These two aren't competitors — a buyer never picks one over the other, because they solve different problems for different people. Spider Cloud is a paid API that turns live web pages into markdown or structured JSON for RAG pipelines and agents; it's the right call if you need rendering, crawling, proxies, and search behind one key. boo is a free MIT terminal multiplexer you install and forget, useful when you need persistent sessions and scriptable screen reads without a TTY. Buy Spider Cloud for web data; adopt boo for terminal plumbing. Verdict generated
Head-to-head comparisons
Boo vs Spider Cloud
These two aren't competitors — a buyer never picks one over the other, because they solve different problems for different people. Spider Cloud is a paid API that turns live web pages into markdown or structured JSON for RAG pipelines and agents; it's the right call if you need rendering, crawling, proxies, and search behind one key. boo is a free MIT terminal multiplexer you install and forget, useful when you need persistent sessions and scriptable screen reads without a TTY. Buy Spider Cloud for web data; adopt boo for terminal plumbing.
GeneratedBoo vs Temporal Ai
These are not competing products, and treating them as a head-to-head would mislead you. Temporal is an orchestration layer you buy (or self-host) when AI agents and multi-step workflows must survive crashes, retries, and abandoned sessions across days or weeks. boo is a free terminal multiplexer you install in seconds when you want screen-style persistent sessions with faithful redraws on modern TUIs. If your problem is durable execution, pick Temporal; if your problem is a mangled terminal or a hung CI job, pick boo. Very few buyers honestly face both choices at once.
GeneratedBoo vs Audioeye
These tools never appear on the same shortlist — one is a free MIT terminal multiplexer you install and script, the other is a paid managed accessibility service you deploy via CMS snippet. If you need persistent detachable sessions with screen-accurate redraws and headless send/peek/wait primitives, pick boo; if you need WCAG 2.2 A/AA coverage, VPAT/ACR paperwork, and expert-written fixes across a large site, pick AudioEye. Not a comparison — a fork in the road.
GeneratedFrequently asked questions
Categories
Best-of guides
Topics
For makers of boo
- Get a Verified Listing for boo ($39): a written decision within 1 working day.
- Free listing for another tool: Free reviews are decided in order, within 3 weeks of the review starting.
Used boo? Help shape our editorial sentiment research.