Ghostty Terminal: Mitchell Hashimoto's GPU-Accelerated Terminal

Terminal emulators have had a strange recent renaissance. For twenty years the choices on a developer’s laptop were basically “the one that ships with your OS” or “iTerm2 on macOS” — and that was fine. Then Alacritty showed up in 2017 saying terminals could be GPU-accelerated and fast. Then Kitty added images and graphics protocols. Then WezTerm added a scripting language and cross-platform polish. And in late 2024 Ghostty shipped its public release — a new terminal from Mitchell Hashimoto (HashiCorp founder, author of Vagrant and several other tools) that takes a careful, opinionated swing at what a modern terminal should be.

Ghostty’s thesis is simple: a terminal should be fast, native, and configurable without ceremony. No scripting language baked into the config. No half-complete cross-platform compromise. No experimental features masquerading as stable. Just a meticulously engineered terminal that feels like an extension of your OS, renders with the GPU, and gets out of your way.

After a year in the wild, Ghostty has earned a spot in the terminal conversation alongside iTerm2, WezTerm, Kitty, and Alacritty — without quite replacing any of them. This post is a practical look at what Ghostty is, what it’s good at, where it falls short, and how it compares to the rest of the field.

The 30-second pitch

Ghostty is a terminal emulator written in Zig by Mitchell Hashimoto, officially released December 2024 after a long invite-only beta. Its design principles, stated clearly on the project homepage:

• Native. Use the platform’s native UI toolkit on macOS (AppKit) and Linux (GTK 4). Not Electron, not a cross-platform abstraction. The terminal should feel like part of the operating system.
• Fast. GPU-accelerated rendering with Metal on macOS and OpenGL on Linux. Input latency measured and optimized.
• Correct. Adherence to terminal standards (including modern extensions like Kitty keyboard protocol and graphics) over novelty features.
• Configurable but not programmable. Config is a flat text file of key=value pairs. No Lua, no JSON, no YAML. No scripting.

The last point is the defining stylistic choice. WezTerm is programmable (Lua). iTerm2 has hooks and AppleScript. Ghostty says: if you need to script your terminal, run a script. The terminal is for rendering characters on screen.

Installing

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12

# macOS
brew install --cask ghostty

# Linux (official packages for Ubuntu, Arch, Fedora, Nix)
# Ubuntu example:
sudo add-apt-repository ppa:ghostty-project/ghostty
sudo apt install ghostty

# From source (Zig required)
git clone https://github.com/ghostty-org/ghostty
cd ghostty
zig build -Doptimize=ReleaseFast

No Windows build yet. This is an intentional scoping decision — Hashimoto has said a Windows port is possible but not a priority.

Open the app and you get a stock terminal. No config file required. Type ghostty +show-config --default --docs to see every available option with documentation inline.

Configuration: the philosophy

Ghostty’s config lives at $XDG_CONFIG_HOME/ghostty/config (usually ~/.config/ghostty/config). It’s key=value, one per line:

font-family = JetBrains Mono
font-size = 13
theme = Dracula

background-opacity = 0.95
background-blur-radius = 20

window-padding-x = 10
window-padding-y = 10

keybind = ctrl+shift+t=new_tab
keybind = cmd+k=clear_screen_and_history

shell-integration = detect
shell-integration-features = cursor,sudo,title

That’s it. No conditionals, no includes-with-logic, no “config.d” Lua scripts computing values. Include files work (config-file = ./themes/dracula.conf) but only as literal inclusion.

The defaults are strong. Many people use Ghostty with a config file of under 20 lines and are completely satisfied. The contrast with WezTerm — whose default configs often run hundreds of Lua lines — is deliberate.

Speed

Ghostty is fast. This matters less than it used to — most 2020s terminals are fast enough that frame rate isn’t your productivity bottleneck — but it’s a legitimate design point.

Quick observations from daily use:

• Input-to-pixel latency is very low, measurably lower than iTerm2. Typing feels immediate.
• Scrolling is smooth even on 4K displays with high-density content.
• High-output workloads (cat largefile.txt, yes | head -n 10000000, a busy compile log) render without drops or visible jank.
• Animation — if your shell prompt uses animated indicators, spinners, or progress bars, they render smoothly.

Alacritty is the traditional “fast terminal” benchmark king. Ghostty is in the same league; the difference is below perceptual threshold. Both trounce iTerm2 on raw throughput, though iTerm2 has narrowed the gap in recent versions.

More useful than raw speed: Ghostty’s resource usage at idle. A single Ghostty window with a quiet shell uses noticeably less CPU at idle than most competitors, including Alacritty. If you have five terminal windows open sitting idle, the sum matters.

Native integration

This is Ghostty’s most distinctive feature.

On macOS:

• Real traffic-light window controls.
• Native full-screen with the standard animation and menu-bar behavior.
• macOS’s Services menu and standard text-input integration.
• Proper Cmd-key handling out of the box. No “Option as Meta” config trauma.
• Native tab bar (optional) that looks like any other Mac app.
• Transparent background with genuine macOS window blur.
• Supports macOS’s Quick Look (Cmd-Y), text replacement, and emoji picker.

On Linux:

• GTK 4 window with your chosen theme.
• Native GNOME/KDE integration, including decorations, window-manager hints, and clipboard behavior.
• Wayland-first rendering with X11 support where available.
• Proper IME (input method editor) support — working CJK input out of the box, a notoriously hard problem in terminals.

The difference when you use Ghostty on macOS compared to Alacritty or Kitty is immediate. It behaves like a Mac app. Dialogs are native. Window resize animations match the rest of the OS. Opening a file via AppleScript routes correctly. Nothing has the “this was clearly designed for Linux first and macOS as an afterthought” feel.

For people who live in their terminal and find that “almost native” is a constant low-grade annoyance, this is the feature that sells Ghostty over every other cross-platform terminal.

Shell integration

Ghostty has first-class shell integration that enables several useful features automatically:

• Jump to prompt (Cmd-up/down on macOS): navigate between your previous commands. Not just scrolling — jumping by command.
• Highlighted current command (optional): visually distinguishes the command you’re editing from previous output.
• Cursor styling per mode: the cursor can be a bar in insert, block in normal, configurable per shell context.
• sudo password prompt detection: can reformat or visually distinguish sudo prompts.
• Title updates that reflect shell state automatically.
• Working directory inheritance for new tabs: open a new tab and it starts in the same directory as the current one — without a config hack.

Integration works automatically with bash, zsh, fish, and elvish once shell-integration = detect is set (which is the default). Under the hood, Ghostty injects a small shell rc file that sets escape sequences the terminal parses. This is cleaner than the equivalent in most terminals, which rely on the user to source a file manually.

Keyboard protocol: fixing the 40-year-old bug

Terminals have a historical limitation: many keypresses are represented by byte sequences that collide. Ctrl-i and Tab are the same byte. Ctrl-m and Return are the same byte. Modifier combinations like Ctrl-Shift-A often can’t be distinguished from Ctrl-A. This is why your favorite key combo “doesn’t work in the terminal.”

The Kitty keyboard protocol (formalized by the Kitty terminal, now an emerging standard) solves this with a new reporting mode that disambiguates every key combination. Ghostty supports it. Helix, Neovim, and several other applications support it. Together you get what a GUI app has always had: any key combo you want, reliable.

This matters if you’ve ever hit a wall trying to bind Ctrl-; in Neovim. With Ghostty + Neovim + keyboard protocol enabled, it just works.

Graphics and images

Terminals with image support render images inline: kitty +kitten icat image.png shows the image in your shell. This is genuinely useful for viewing diffs, showing graphs from scripts, displaying PDF previews without leaving the terminal.

Ghostty supports:

• Kitty graphics protocol — the de facto modern standard.
• Sixel — older, more universal.
• iTerm2 inline images — the older macOS standard.

Practical uses:

• timg or chafa to view image files.
• jupyter kernels rendering matplotlib in a terminal IDE workflow.
• nvim-tree or similar showing file previews inline.
• image.nvim, kitty-scrollback.nvim, and the growing category of Neovim plugins that lean on terminal graphics.

This puts Ghostty on par with Kitty and WezTerm. iTerm2 has its own protocol; Alacritty supports none.

Theming

Ghostty ships with hundreds of themes and a live-preview command:

ghostty +list-themes
ghostty +show-config --default | grep ^theme

Change theme by name:

theme = Catppuccin Mocha

Per-platform overrides work:

theme = light:catppuccin-latte,dark:catppuccin-mocha

That setting respects your OS dark-mode toggle — switches automatically when the OS does. No config reload, no script.

Theme authors can drop a .conf file into $XDG_CONFIG_HOME/ghostty/themes/ and it becomes selectable.

Tabs and splits

Ghostty has native tabs (platform-native on macOS, GTK tabs on Linux) and splits:

keybind = cmd+t=new_tab
keybind = cmd+d=new_split:right
keybind = cmd+shift+d=new_split:down
keybind = cmd+h=goto_split:left
keybind = cmd+j=goto_split:bottom

The splits are at the terminal level — not at the multiplexer level. This is a philosophical point: tmux or Zellij handle splits at the shell/session level; Ghostty handles them at the window level.

Is that a bug or a feature? It depends. For local dev, terminal-native splits mean you don’t need a multiplexer for basic split-pane work, and splits behave like native macOS/GTK splits (proper resize, proper focus, proper fullscreen interaction). For remote work, a multiplexer is still correct — Ghostty can’t persist a split through an SSH reconnect.

Most users end up with both: Ghostty splits locally, tmux or Zellij on servers.

The comparison table

The headline differences:

• Ghostty vs WezTerm: Ghostty chooses native; WezTerm chooses cross-platform and scripting. WezTerm wins for users who need Windows or want programmable config. Ghostty wins for everyone else who values native-feel.
• Ghostty vs Kitty: Kitty is older, more mature, has the reference implementation of its own graphics protocol, and a “kitten” extension system. Ghostty is newer, faster, more polished UI-wise. Feature parity is close; UX polish goes to Ghostty on macOS.
• Ghostty vs Alacritty: Alacritty is minimal to a fault — no tabs, no splits, YAML config, no image support. Ghostty is what Alacritty might have been if scoped differently. For most users, Ghostty is the better daily driver; Alacritty remains interesting for embedded/minimal setups.
• Ghostty vs iTerm2: iTerm2 has 15 years of features — AppleScript, tmux integration, a settings UI with hundreds of toggles, session restoration, password-manager integration. It is also Objective-C with a GUI that shows its age. Ghostty trades iTerm2’s depth for speed and modern defaults.

Where Ghostty falls short

Being fair:

• No Windows support excludes a significant developer population.
• No scripting means some automation workflows aren’t possible. WezTerm’s Lua can implement arbitrary pane-layout logic, startup hooks, custom key-driven behavior. Ghostty can’t.
• The ecosystem is young. Kitty has years of plugin-style “kittens.” WezTerm has Lua examples everywhere. Ghostty’s community scripts are fewer.
• No SSH-aware mosh integration like iTerm2’s. Can’t automatically reconnect a session.
• The tab UI on Linux is functional but less polished than macOS’s.
• Session restoration (reopening every window you had when you quit) is minimal. iTerm2 excels here.
• Search in scrollback is good but simpler than some competitors’ offerings.

None of these are dealbreakers for most users. If any one is critical to you, stick with your current tool.

Recommended config to start

# ~/.config/ghostty/config
font-family = JetBrains Mono
font-size = 13
font-feature = -calt, -liga

theme = light:catppuccin-latte,dark:catppuccin-mocha

window-padding-x = 12
window-padding-y = 12
window-decoration = true
window-save-state = always

background-opacity = 0.98
macos-titlebar-style = tabs

shell-integration = detect
shell-integration-features = cursor,sudo,title

cursor-style = block
cursor-style-blink = false

copy-on-select = clipboard
mouse-hide-while-typing = true

scrollback-limit = 100000

keybind = super+shift+enter=toggle_fullscreen
keybind = ctrl+shift+t=new_tab
keybind = ctrl+shift+d=new_split:right
keybind = ctrl+shift+e=new_split:down

Open Ghostty, paste this, restart. That’s close to a complete setup for most workflows.

Who should switch to Ghostty?

Switch if:

• You’re on macOS or Linux (no Windows need).
• You want a terminal that feels like a native app.
• You’re tired of scripting your terminal configuration.
• You care about startup time, input latency, and idle resource use.
• You want Kitty-protocol keyboard support and modern image protocols without Kitty’s UI quirks.
• You’ve bounced off WezTerm’s Lua-configurability for being too much.

Stay with your current terminal if:

• You need Windows support (WezTerm, Alacritty, or Windows Terminal).
• Your workflow depends on scripting the terminal itself (WezTerm).
• You rely on iTerm2-specific features (tmux integration, triggers, AppleScript).
• You’re happy with what you have and “good enough” is good enough — no shame in that.

The bigger picture

Ghostty’s arrival shifts the terminal conversation in a specific way. Before 2024, the choice was roughly:

• Fast minimal (Alacritty) — too bare.
• Fast configurable (Kitty) — looks its age on macOS.
• Fast programmable (WezTerm) — asks too much for too many users.
• Polished mature (iTerm2) — only macOS, showing its age.

Ghostty lands in a new quadrant: fast and native and minimal-config. That combination didn’t exist before, and it turns out a lot of developers wanted it. The terminal you never think about because it just works the way your OS does — that’s the Ghostty story.

It’s not the best terminal for everyone, and it’s not trying to be. It is the best default terminal for a macOS or Linux developer in 2026 who wants a modern tool without a hobby project attached. For a lot of us, that’s exactly the right tradeoff.