Why Ghostty Is the Greatest Terminal

You live in a terminal now more than you did five years ago.

Not because nostalgia won. Because agents run there. Shells run there. Editors, test runners, git, and half the control plane of modern software run there. The window you keep open for twelve hours is not a browser with a dock icon. It is a grid of panes that refuse to become chrome.

So the terminal has to be great again. Not “pretty.” Not “configurable until it becomes a second operating system.” Great—native, fast, correct, and boring in the ways that let you forget it exists.

Ghostty is the greatest terminal under that definition.

What “greatest” means here

I am not ranking every escape sequence ever implemented. I am not scoring Sixel trivia or remote-mux Olympics.

For people who live in the shell—including people who run coding agents all day—great means:

1. Native where you are. On macOS, it should feel like a macOS app. On Linux, like a real desktop citizen—not a cross-platform skin.
2. Fast by default. You should not notice the terminal under scroll, resize, or a noisy build.
3. Modern terminal correctness. True color, solid Unicode, shell integration, the stuff you only notice when it is broken.
4. A real product. Windows, tabs, splits, menus, settings—not a research renderer duct-taped to a PTY.
5. Architecture that can last. Core that is engineered, not a ball of glue.

Ghostty wins those. That is the claim.

Native is not a theme

Most terminals ship one UI story and paint it on every OS. Ghostty does the harder thing: platform-native UI with a shared core.

On macOS, Ghostty is a real Swift app—windowing, menus, settings, the integration surface you expect from software that belongs on the machine. The renderer talks Metal. Font discovery uses Core Text. That is not a marketing bullet; it is the shortest path from “glyph” to “pixels on an Apple Silicon laptop.”

On Linux, the GUI is its own first-class shell (GTK), with OpenGL acceleration. Same product idea: native shell, shared engine.

The engine is libghostty—a Zig core exposed as a C-ABI library: terminal emulation, fonts, rendering. The apps are consumers of that core. That split is why Ghostty can feel native without forking the entire terminal state machine per platform.

If you have ever used a terminal that almost looks right on a Mac—menus that feel foreign, fonts that feel slightly wrong, GPU path that is “Metal via three translation layers”—you know why this matters. Ghostty is not almost.

Speed is the absence of a feeling

The best terminal performance is invisible. You resize a split and the grid keeps up. You flood the PTY with compiler output and the UI does not become a slide show. You type, and the shell is the bottleneck—not the emulator.

Ghostty is built as a GPU-accelerated terminal from the ground up. Metal on macOS. OpenGL on Linux. A heavily optimized parse path for the firehose of bytes that real work produces. Dedicated rendering architecture instead of “paint when we get around to it.”

You can always find a microbenchmark war online. Lived experience is simpler: when the terminal disappears under load, you keep working. Ghostty is in that class. That is table stakes for anyone who runs agents, watchers, and logs in the same window for hours.

A terminal, not a platform

Some emulators win by becoming everything: remote multiplexer, scripting host, plugin economy, second desktop environment. Power exists there. So does complexity tax.

Ghostty’s bet is different. It is a terminal product—tabs, splits, keybindings, configuration, shell integration, modern protocols—without making “embed a whole programming language in your config” the center of the story. Configuration is first-class. The daily surface stays a terminal.

That restraint is a feature. When your day is already full of agents, editors, and half-finished plans, the host should not demand a second career.

Serious engineering

Ghostty is not a weekend wrapper around someone else’s VT parser with a glow theme.

It is a full-stack terminal project: custom event-loop DNA, a real font stack, platform renderers, a C-API boundary between core and GUI, and a public product that people actually daily-drive. libghostty is the long game—an embeddable modern terminal core so the hard work of emulation and rendering is not re-solved by every app that needs a grid of cells.

You feel that seriousness in the details. Selection behaves. Scrollback holds up. The app shell does not fight the OS. Upstream is active. The project treats the terminal as infrastructure, not as a skin.

Great tools usually look like that: boring competence stacked high enough that it becomes charisma.

What Ghostty is not

Ghostty is not the winner of every checkbox on every platform on every day.

It is not a Windows-first product today—macOS and Linux are the shipping story; Windows is a longer path. It is not trying to replace tmux-over-SSH as a lifestyle. It will not match every graphics protocol or config dialect of every legacy emulator.

If your primary requirement is “one binary, every OS, every protocol, Lua all the way down,” you may pick something else and be happy.

If your requirement is the best place to live in a shell on a modern Mac (or Linux box)—fast, native, correct, product-grade—Ghostty is the bar.

Why this matters more now

Coding agents made the terminal the control plane again.

Claude Code, Codex, Grok, OpenCode, Pi—whatever you actually run—the loop is pane-shaped. Repo in one split. Agent in another. Logs in a third. You need a host that does not flake under that density. You need something that feels like part of the computer, not a guest UI.

Ghostty is the greatest terminal for that life because it gets out of the way without going dumb. Native craft. GPU path. Real app. Serious core. That is the foundation you want under agent chaos.

What we built on top

We did not want to rebuild a great terminal from scratch.

Astrohacker Terminal is built on Ghostty’s model as the host: the same bet on native panes, speed, and a real macOS app shell. What we add is the thing Ghostty is not trying to be—real browser engines in the same window as the shell. Chromium, WebKit, Ladybird; multiple profiles; a page next to the agent that is still working.

If you only need the greatest terminal, use Ghostty.

If you want that foundation with browsers in the panes, install Astrohacker:

brew tap astrohackerlabs/astrohacker
brew trust astrohackerlabs/astrohacker
brew install --cask astrohacker

Docs live at astrohacker.com/docs.

The order is intentional. Ghostty first. Host second. The terminal had to be great before anything else belonged in the window.