Otty: A Mac-Native, GPU-Accelerated Terminal Tuned for Code Agents

title: “Otty: A Mac-Native, GPU-Accelerated Terminal Tuned for Code Agents”
tags:

• Otty
• terminal emulator
• macOS
• GPU rendering
• Claude Code
• Codex

• OpenCode

The terminal-app market in 2026 is crowded enough that launching a new one takes either a strong technical hook or a strong community. Otty, which hit Product Hunt this summer, is going for both: it’s a native Mac terminal with GPU-accelerated rendering, but the headline feature is that it’s built from the ground up to live alongside AI coding agents like Claude Code, Codex, and OpenCode. The maker, Abner Lee (also behind Typora), describes the project as a terminal that he himself uses every day — and the design choices all flow from that single constraint.

This article walks through what Otty does differently, who it’s for, and what the actual experience is like — including the trade-offs you accept by adopting a tool that’s still Mac-only and pre-1.0.

What Otty is — and is not

The Otty website opens with a positioning slider: Traditional Terminal on the left, Otty in the middle, Complex ADE (Agent Dev Environment) on the right. That’s the entire pitch in one image.

Most “AI terminals” bolted agent affordances onto an existing terminal and ended up heavier and more cluttered than the terminal they replaced. Otty’s bet is the opposite direction — start from a clean, Ghostty-like terminal experience, then add only the agent affordances you actually reach for, without the panels, buttons, and IDE-style complexity.

Concretely, Otty is:

• A native Mac app (Swift, GPU-accelerated via Metal) — no Electron, no web wrapper.
• Free, with no account required.
• Currently Mac-only. Windows, Linux, and iOS are on the roadmap but not shipping yet.
• Tuned for running multiple Claude Code / Codex / OpenCode sessions side by side.

The rendering pipeline

Otty leans hard on the modern Mac graphics stack. The screenshot below shows the dark theme with a long tab list on the left (nine tabs total, with ⌘1–⌘9 shortcut badges and a small spinner on the fix bug: #2267 tab indicating active work) and fastfetch output in the main pane.

The rendering features that show up in the screenshots:

• Ligatures and Unicode — programming ligatures rendered correctly, full Unicode clusters, multi-codepoint emoji. Not the partial-support-you-have-to-patch-yourself that older terminals deliver.
• True color and rich text styles — 24-bit color, plus bold, italic, underline, strike-through, and reverse video. The agent output blocks use these styles aggressively.
• Inline images — render images directly in scrollback, no separate viewer.
• Interactive links — URLs, file paths, and ls output are clickable.
• Smooth, GPU-accelerated scroll — what you’d expect from a Metal-backed renderer.

Workspace management

The second thing Otty does differently is layout. Tabs live on the left as a vertical sidebar rather than the macOS-default top bar, and each tab carries a small status indicator: an unread dot when new output has arrived, a spinner when an agent is working, and a shortcut badge (⌘1–⌘9).

The light theme view below shows a more complete picture: tabs on the left (including agent sessions like OC | make next plan, files like index.md and code-review-todos.md), a Codex session in the main pane with an update notification, and a file tree on the right showing the ~/Workplace/otty docs/ directory layout.

The sidebar also has a Git panel that can be opened instead of the file tree. The screenshot below shows the Git panel: 12 unstaged files in the main branch with a Commit button and a Fork action for spinning off a new branch.

Free-form splits work the way you’d expect — drag, snap, resize — and session recovery is the headline reliability feature. Close the lid, reopen the laptop, every pane is restored to exactly where it was. The maker has confirmed this works for Claude Code and tmux sessions, which matters because those are the cases where losing a pane means losing an agent’s running context.

Keyboard-first workflow

Otty is opinionated about keeping your hands on the keyboard. Four affordances anchor the workflow:

The Open Quickly overlay is the most distinctive of these. In the screenshot below, typing data brings up a search box with category chips (All, Opened, Recent, Folders, SSH, Agents, Current, Recipes), then results grouped by session type — Codex Sessions on top, Claude Code Sessions below. Each result shows the project path, the time since last activity, and an “Agent” tag indicating which kind of agent created it.

For someone running three or four agent sessions in parallel, this is the difference between “scroll through nine tabs to find the right one” and “type three characters and hit enter”.

Agent integration — the real differentiator

The agent-aware features are where Otty earns its product name. The site demo shows the following workflow:

$ agent run --review socket.rs

● analyzing main-thread hot path…

modified src/ipc/socket.rs
-  self.flush_all_metadata();
+  self.coalesce(&mut pending);
+  if pending.len() > BATCH { flush() }

✓ 3 files · +42 −18 · 1.2s

$ cargo bench socket_meta
main-thread lag 58.3ms ▸ 23.1ms

● watching · 2 agents active

When that agent finishes, the tab badge goes from spinner to a notification dot, and a toast appears:

Agent · review
Coalesced the socket metadata writes — main-thread lag down ~60%. Patch applied & benched.

The result is a tracked chat with an inline code diff showing the coalesce function the agent wrote, plus a linked Pull Request card (PR #209, +42 −18, ✓ 4 checks passed). Click the PR link and you’re in the browser; click “edit socket.rs” and you’re back in the terminal at the diff.

The other agent affordances worth knowing:

• Parallels and monitor tasks — run agents side by side and watch all of them.
• Session history — every conversation is browsable from the same sidebar.
• Fork & branch — take any chat in a new direction without losing the original.
• Composer and prompt queue — draft prompts and queue them to run in order.
• Send to Chat — pipe any terminal output into an agent.

Install — Mac only today

Otty distributes via direct .dmg download from its own CDN:

• macOS Apple Silicon: Otty.dmg
• macOS Intel: Otty-x64.dmg

Open the .dmg, drag Otty to Applications, done. No license key, no account creation, no telemetry prompt. The app is free while in beta.

Windows, Linux, and iOS are all listed as “Coming soon” on the site, with a waitlist link rather than an installer.

Honest trade-offs

Otty is a great tool that makes three specific compromises, and you should know about them upfront:

1. Mac-only. There is no Linux or Windows build, and the official roadmap doesn’t give a date. If you split time between platforms, Otty won’t follow you.
2. Closed source. Unlike the Otty project covered in the previous article, this one is a commercial product. The git history you can see on the Git tab panel is for your projects — Otty itself isn’t open source.
3. Young product. Released in summer 2026, single developer (with a small team), small user base. The agent integrations in particular are evolving quickly; what works today may be different in three months.

What works well:

• The vertical tab bar with status badges is the single best tab UI in any terminal app I’ve used.
• Open Quickly (⌘⇧O) is the right way to navigate between many concurrent agent sessions.
• Session recovery for Claude Code / tmux is the kind of feature you only appreciate once you’ve lost two hours of agent context to a crash.
• The keyboard-first approach is consistent — there’s almost never a reason to reach for the mouse.

Who should try Otty first

If you live on a Mac, you run Claude Code or Codex for a meaningful chunk of your day, and your current terminal is making you feel like you have ten browser tabs and nine terminal tabs and no good way to find any of them — Otty is worth an afternoon. Download it, point it at one project you actually work on, run two agents in parallel, and see whether the vertical tab bar + Open Quickly combo changes how you orient yourself.

If you’re a Linux user, you need cross-platform parity, or you prefer open-source-only tooling, this one isn’t for you yet. Watch the release notes for the Linux build, and in the meantime the Rust-based OTTY project from the previous article is the closest open-source analog.

The broader trend is the interesting part. The terminal app of 2026 is no longer “the shell window” — it’s the surface where you coordinate between your editor, your tests, your git history, and your AI assistants. Otty is one of the most coherent attempts I’ve seen at designing that surface, even if it’s deliberately scoped to a single platform for now.