OTTY: A Terminal-Centric Workspace for Developers Who Live in the Shell

title: “OTTY: A Terminal-Centric Workspace for Developers Who Live in the Shell”
tags:

• OTTY
• terminal emulator
• Rust
• developer tools

• Linux

Most terminal emulators are still doing one job: render a shell. OTTY, an open-source project on GitHub, takes a different stance — the terminal should be the primary surface for development and operations, not just a window into one. The team explicitly says they’re “not building another blazing-fast terminal emulator” — they’re building a workspace where the shell stays in sync with the files you edit, the commands you run, and the SSH targets you actually use day to day.

The project lives at github.com/otty-shell/otty, is written in Rust (the workspace has eight crates: otty, otty-escape, otty-libterm, otty-pty, otty-surface, otty-ui, otty-vte, plus otty-cli), and is still labelled “WORK IN PROGRESS” in its README — but the artifact releases are already usable on Linux and macOS. Below is what OTTY looks like, what it’s good at today, and where the rough edges still show.

What OTTY actually is

Strip away the README hype, and OTTY is a native terminal emulator with three opinionated extras bolted onto the rendering pipeline:

1. A file explorer sidebar that lives next to the shell.
2. A Quick Launch for saved commands and SSH connections.
3. A block-based terminal UI that groups each command and its output into an atomic unit.

That last point is the one that took me a moment to get. In a normal terminal, the scrollback is one continuous stream — git status, then cargo build, then a stack trace from three minutes ago, all blended together. OTTY treats each command as a discrete block, with its prompt, its output, and its exit status visually contained. Once you see it, scrolling through a long build session feels very different — your eye snaps to the block you want, not the line.

The screenshot below is taken straight from the project repo. You can see the four tabs across the top (Claude Code, Settings, htop, AGENTS.md), the explorer on the left synced to the workspace root, the editor pane on the right showing Cargo.toml, and htop running in the bottom-right pane. The blocks are visible in the central terminal area.

A quick tour of the three flagship features

Explorer that stays in sync

The left sidebar isn’t a static tree view. It’s wired to the current working directory of the active terminal session. When you cd into a subproject, the explorer follows. When you switch tabs, the explorer re-anchors to that tab’s directory.

For anyone who jumps between a handful of repos a day, this single decision eliminates a lot of tree and ls invocations. For Rust workspaces specifically, you can see the eight otty-* crates surfaced as siblings under the workspace root — exactly how Cargo.toml defines them, with AGENTS.md, Cargo.lock, and .github all visible at the top level.

Quick Launch

Quick Launch is OTTY’s name for the bookmark manager over your shell history and SSH inventory. Saved commands get short aliases; saved SSH connections become one-keystroke launches with the right working directory, the right user, and the right key pre-loaded.

The README doesn’t go deeper than that on the public page — there isn’t a settings UI tour yet — but the feature is wired into the menus, and it shows up in the screenshot as one of the sidebars.

Block-based terminal UI

This is the most distinctive visual choice. Each block carries:

• The prompt line(s) at the top.
• The output below.
• An implicit exit status (success/failure) indicated visually at the block’s edge.

The effect is closer to a Jupyter notebook than a traditional xterm. If you have a long-running job in one block and want to re-run it, you can target that block specifically without losing your place in the scrollback.

The stack under the hood

OTTY is Rust end-to-end. The workspace has eight crates, and they’re not just renamed files — each one has a clear responsibility:

That’s not a toy architecture. A separate escape-sequence parser, a separate grid surface, and a separate UI layer is roughly the shape of a small commercial terminal app. The fact that all of it ships as a single Rust workspace also means cargo is the only build tool you need.

Install

The README points straight at GitHub Releases. As of this writing there are prebuilt artifacts for:

• Linux: .deb and .rpm packages
• macOS: .dmg for both Intel (x86_64) and Apple Silicon (aarch64)

There is no Windows build today, and there is no apt repo or Homebrew tap to add — it’s download-the-artifact-and-install. For Debian/Ubuntu the path is:

# Latest release URL — replace version as needed
curl -L -o otty.deb https://github.com/otty-shell/otty/releases/latest/download/otty-amd64.deb
sudo apt install ./otty.deb

For Fedora/RHEL:

sudo dnf install https://github.com/otty-shell/otty/releases/latest/download/otty-x86_64.rpm

For macOS:

# Apple Silicon
curl -L -o otty.dmg https://github.com/otty-shell/otty/releases/latest/download/otty-aarch64.dmg
open otty.dmg

From-source on any platform needs only the Rust toolchain:

git clone https://github.com/otty-shell/otty
cd otty
cargo build --release
./target/release/otty

Where OTTY stands today — honest assessment

The README’s self-description includes a candid “WORK IN PROGRESS” header, and that shows through in a few places:

• No Windows build. The platform support table lists Linux and macOS only. If you’re on Windows + WSL, the WSLg side of things works, but native Windows is not on the roadmap yet.
• Sparse docs. The README is the entire documentation surface right now. There’s no user guide beyond the bullet points, no changelog beyond git history.
• Young project. The repo has a small number of commits and a small number of contributors. The risk profile for early adopters is “things will move under you”, not “this will be abandoned in six months”.

What works well:

• The block-based terminal UI genuinely changes how you scan a long session.
• The file-explorer-follows-cwd behavior is the kind of thing you stop noticing after a day because it just feels correct.
• The Rust architecture is clean enough that anyone familiar with the codebase could plausibly contribute a small feature.

Who should try OTTY first

If you spend most of your day inside a shell, jump between a handful of projects, and you’re tired of the same tmux + wezterm + nvim setup you’ve had since 2021 — OTTY is worth an hour of your time. Download the artifact, point it at your busiest repo, and see whether the block-based output and the synced explorer change how you work. They probably will.

If you need a battle-tested terminal with a polished settings UI, a real extension ecosystem, and a Windows build, OTTY isn’t there yet. Stay on Ghostty, WezTerm, or Kitty and watch this project for another six months.

Either way, the direction is interesting. The terminal has been “just a window” for thirty years. OTTY is one of the small handful of projects actively asking what it should be instead.