TL;DR:

  • Ghostty is a fast, GPU-accelerated terminal built by Mitchell Hashimoto (HashiCorp founder) using Zig, available for macOS and Linux
  • It’s not AI-focused — the appeal is raw performance, native platform integration, and a simple but deep configuration model
  • For developers who find Warp too opinionated and iTerm2 too slow, Ghostty occupies a useful middle ground

Terminal emulators are one of those categories where “good enough” has kept incumbents dominant long past when they should have been replaced. iTerm2 was already years old when developers started complaining about its sluggishness on large outputs. Alacritty was fast but stripped of features. Kitty was fast and featureful but the config model puts off beginners. WezTerm is excellent but written in Rust and carries some rough edges.

Ghostty arrived at the end of 2024 as Mitchell Hashimoto’s answer to this fragmented landscape: a terminal that’s genuinely fast, genuinely native on every platform it supports, and configured through a simple text file rather than layers of GUI preferences.

After nearly a year and a half of production use across a growing developer community, it’s earned a proper assessment.

What Ghostty Actually Is

Ghostty is a terminal emulator written in Zig. It uses GPU acceleration (Metal on macOS, OpenGL/Vulkan on Linux) for rendering, which means text output — even at hundreds of thousands of lines per second — stays smooth. The GPU rendering isn’t a differentiator by itself in 2026; Alacritty, Kitty, WezTerm, and Warp all do GPU rendering. What distinguishes Ghostty is how it achieves GPU performance while maintaining native platform behaviour.

On macOS, Ghostty uses native AppKit for window management, menus, and system integration. This means it respects macOS accessibility features, system font rendering, macOS spell-check and context menus, and the platform’s native tab and window management — things that cross-platform terminals built on Electron or custom window toolkits either miss entirely or implement inconsistently. On Linux, Ghostty uses GTK4 for similar reasons.

The Zig choice also matters in practice. Ghostty has no runtime dependency on a garbage collector, which eliminates the latency spikes that occasionally show up in Go-based or JVM-based terminal tooling. Memory usage is consistently low.

Performance in Practice

The benchmark that matters for terminal performance is how it handles high-output commands — grep on large files, cat of a big log, compilation output scrolling past at speed. Ghostty handles these without stuttering or frame drops on modern hardware, which not all terminals can claim.

More subjectively: the latency from keypress to character appearing on screen (input latency) is perceptibly low. On the same hardware, switching between Ghostty and iTerm2 makes the difference immediately apparent in a way that’s hard to quantify but easy to feel.

For SSH sessions to remote hosts, the low input latency is particularly noticeable. Ghostty supports SSH multiplexing configurations cleanly and doesn’t introduce the occasional dropped-keystroke issues that some GPU-accelerated terminals have exhibited in high-latency connections.

Configuration Model

Ghostty uses a single flat config file at ~/.config/ghostty/config. There’s no YAML, no TOML, no JSON — just key = value lines. This sounds limiting but in practice covers nearly everything you’d want to configure:

# ~/.config/ghostty/config

theme = "catppuccin-mocha"
font-family = "Berkeley Mono"
font-size = 14
background-opacity = 0.95
cursor-style = bar
shell-integration = detect

# Window
window-padding-x = 10
window-padding-y = 10
window-decoration = true

# Keyboard
keybind = ctrl+shift+h>ctrl+shift+h=toggle_quick_terminal
keybind = ctrl+shift+t=new_tab
keybind = ctrl+shift+w=close_surface

# Split panes
keybind = ctrl+shift+d=new_split:right
keybind = ctrl+shift+shift+d=new_split:down

The config reloads without restart when you save it. Changes are live in under 100ms.

What’s deliberately absent: there’s no GUI settings panel, no wizard, no managed profile system. If you want point-and-click configuration, Ghostty is not the right choice. If you keep your dotfiles in a git repo and prefer text-based configuration that can be reproduced on any machine, this is exactly the right model.

Features Worth Knowing About

Quick terminal: A toggleable drop-down terminal (think Quake-style) triggered by a keyboard shortcut. It appears instantly, overlaying your current screen, and disappears just as fast. For quick git status, docker ps, or similar checks without leaving your current context, this is genuinely useful.

Split panes: Horizontal and vertical splits without requiring tmux. The splits are native, snappy, and can be resized by dragging. For developers who want splits but not a full tmux setup, this covers the common case well.

Shell integration: Ghostty includes shell integration scripts for zsh, bash, and fish that enable semantic awareness of command boundaries — so you can navigate between prompt lines with keyboard shortcuts, and get useful features like automatic working directory detection when opening new tabs.

Hyperlinks: URLs in terminal output are clickable (cmd+click on macOS). This sounds basic but is implemented correctly — it handles multi-line URLs, URLs with parentheses (common in markdown), and file:// paths with correct path handling.

Font features: Ghostty has excellent OpenType feature support. If you use a programming font like Berkeley Mono, Iosevka, or JetBrains Mono that includes ligatures or stylistic alternates, they work correctly and are configurable per-font.

What’s Missing

Ghostty has no AI integration. If you want Warp-style command suggestions, AI-generated error explanations, or natural language command search, Ghostty doesn’t do any of that. This is a deliberate design choice — Ghostty is a terminal emulator, not an AI assistant that happens to have a terminal attached.

Multiplayer/collaboration features are also absent. This is a single-user terminal; for pair programming or remote sharing, you’d use tmux or similar.

Windows support does not exist and has not been announced. Ghostty is macOS and Linux only.

Who Should Switch

Ghostty makes most sense for developers who:

  • Are on macOS or Linux (obviously)
  • Want better performance than iTerm2 without Warp’s opinionated workflow
  • Prefer text-based config and keep dotfiles in version control
  • Don’t need AI integration in their terminal specifically (they might use it elsewhere)
  • Value native platform integration over cross-platform uniformity

If you use iTerm2 primarily because you’ve never found a reason to change and performance hasn’t bothered you, the case for switching is less compelling. The configuration migration takes an hour or so and the performance benefits are real but may not be perceptible on your specific workflow.

If you’ve been frustrated with iTerm2’s sluggishness on large outputs, or you tried Alacritty and found it too bare-bones, Ghostty occupies an appealing space in between: fast, native, configurable, and maintained by someone with a track record of building production-quality infrastructure tooling.

The 1.0 release is available at ghostty.org. The source is on GitHub (MIT licensed). There’s no paid tier — it’s free open-source software with no commercial strings attached, which for a developer tool in 2026 is genuinely notable.