Terminal emulators are one of those tools that most developers configure once and then forget. You pick iTerm2 or Alacritty or WezTerm at some point in your career, copy in your colour scheme and font settings, and then stop thinking about it. Ghostty is the first terminal in a while that’s given a lot of developers a reason to reconsider.

Ghostty 1.0 shipped in December 2024 after a long development period by Mitchell Hashimoto (of HashiCorp and Vagrant fame). By mid-2026 it has settled into being one of the most-recommended terminal emulators for macOS and Linux, with a reputation for being genuinely fast, genuinely native, and genuinely opinionated in the ways that matter.

What Ghostty Actually Is

Ghostty is written in Zig and uses native platform rendering — Metal on macOS, OpenGL on Linux. It’s not a port of a cross-platform rendering layer; it integrates with the platform’s compositor directly. The practical result is that text renders without the slightly-off feel that Electron-based or cross-platform-framework terminals sometimes have, and GPU usage is low and predictable.

The key design principle is that Ghostty should feel like a native application on whatever platform you’re running it. On macOS that means native tabs, native full-screen, native accessibility APIs, and correct rendering of system fonts at any size. On Linux it means proper Wayland support with fractional scaling, which remains a painful edge case for many terminal emulators.

Terminal compatibility is taken seriously. Ghostty supports an extended set of terminal capabilities and ships its own terminfo entries (ghostty and xterm-ghostty) to ensure that applications that inspect terminal capabilities get accurate information. This matters more than it sounds — broken terminfo or incomplete escape sequence support is the reason some terminals still cause rendering glitches in ncurses-based applications or vim with specific colour configurations.

Performance

Raw character rendering throughput is where Ghostty is competitive with the fastest terminals available. In benchmarks involving high-volume output — cat-ing large files, running builds with dense compiler output, or using applications that redraw frequently — Ghostty is in the same tier as Alacritty and Kitty, and faster than iTerm2 or the built-in Terminal.app on macOS.

More relevant for day-to-day use is input latency. Ghostty is optimised for low latency between keypress and character appearance, which is one of those things you don’t consciously notice until you use a terminal that handles it well and then go back to one that doesn’t. On a modern Mac, Ghostty’s keystroke-to-render latency is around 1–2 ms — approximately half of what most cross-platform terminals achieve on the same hardware.

Configuration

Ghostty uses a plain text configuration file at ~/.config/ghostty/config (or the platform-appropriate equivalent). It’s not TOML, JSON, or YAML — it’s its own simple format with key = value pairs and comment lines.

# Ghostty configuration
font-family = "JetBrains Mono"
font-size = 13
theme = "catppuccin-mocha"
background-opacity = 0.95
shell-integration = zsh
copy-on-select = false
window-decoration = true

The configuration surface is deliberately limited relative to something like WezTerm. There are no scripted configurations or Lua-based dynamic configs. What you get is a set of well-chosen options that cover the configurations most developers actually want, without the surface area that becomes a maintenance burden.

Themes are built in — Ghostty ships with a large library of named themes that you can switch with a single config line. There’s no plugin system, which is a deliberate choice: Ghostty’s position is that terminal emulators don’t need to be extensible frameworks, they need to work correctly and get out of the way.

Shell Integration

Ghostty ships built-in shell integration for Bash, Zsh, Fish, and Elvish. Shell integration enables features that require the terminal to understand shell semantics: semantic prompt marks (so you can navigate between command outputs with keyboard shortcuts), working directory reporting (so new tabs and windows open in the same directory as the current tab), and command status reporting (so Ghostty knows whether the last command succeeded or failed).

The shell integration requires no external dependencies and is activated by adding a single line to your shell configuration:

# For zsh, in ~/.zshrc:
eval "$(ghostty +shell-integration zsh)"

Once active, you get jump-to-prompt navigation (Cmd+Shift+Up/Down on macOS), which becomes genuinely useful when you’re scrolling back through dense build output looking for where a specific step started.

Multiplexer vs Native Tabs

Ghostty has native tab and split support, which raises the question of whether to use a multiplexer like tmux or screen alongside it. The answer depends on your workflow.

If you need persistent sessions that survive SSH disconnects, or if you work across remote machines where you need a session that can be attached and detached, tmux is still the right tool and Ghostty works fine with it. If you primarily work locally and want a clean setup without the tmux learning curve or the terminal-within-terminal visual complexity, Ghostty’s native splits and tabs cover the common cases well.

One advantage of native tabs over tmux: Ghostty’s OS window title and dock integration correctly reflect the current session when you have multiple tabs open, which tmux doesn’t provide by default. Small thing, but it makes navigating multiple projects slightly smoother.

macOS vs Linux

Ghostty’s macOS build is the more polished of the two — it was the primary development target, and the macOS-specific features (native menus, Spotlight integration, drag-and-drop) are more complete. The Linux build is fully functional and has been the primary GTK/Wayland target since 1.0, with Wayland fractional scaling working correctly. The Linux build doesn’t have the same level of desktop integration polish as the macOS version, but for terminal use it’s excellent.

There is no Windows build and none is planned. Ghostty’s model is native platform integration, and a Windows build would require a different renderer and platform layer that the project has decided not to invest in.

Who Should Switch

Ghostty is worth trying if you’re on macOS and are currently using iTerm2 out of inertia rather than because you need its specific features. The switch is low-friction — Ghostty reads most of the same font and colour preferences, and the performance difference is immediately noticeable if you do anything that generates dense output.

It’s worth trying on Linux if you’re using a Wayland compositor and have hit fractional scaling issues with Alacritty or Kitty. Ghostty’s native GTK integration handles it correctly.

It’s probably not worth switching if you depend heavily on iTerm2-specific features like its scripting API, AppleScript integration, or its trigger system. Ghostty doesn’t try to replicate that feature set — it’s a different philosophy.

The configuration syntax is one adjustment point. If you have a complex WezTerm Lua configuration that you rely on, porting it to Ghostty’s simpler config format will mean giving up some of the dynamic configuration capability. For most developers, the Ghostty config covers everything they actually need.

Getting Started

Ghostty is available at ghostty.org. macOS installation is via a standard .dmg; Linux packages are available for the major distributions. The documentation is thorough and covers the full configuration reference, including the terminfo setup that’s needed for correct behaviour in remote sessions.

The one setup step that’s worth doing immediately: install the terminfo entry on any remote servers you SSH into, or set TERM=xterm-256color in your SSH config for hosts where you can’t install it. Without it, remote applications that check $TERM for capability negotiation may behave unexpectedly.