Ghostty: fast, native, GPU-accelerated terminal emulator

What Ghostty is

Ghostty is a terminal emulator for macOS and Linux that sets out to be fast, feature-rich and native all at once. Its README puts the pitch plainly: many terminal emulators "force you to choose between speed, features, or native UIs", and Ghostty aims to provide all three. The project was started by Mitchell Hashimoto, and its About page describes it as a passion project worked on in contributors' free time rather than as anyone's full-time job.

The project now has two faces. One is the terminal application developers install and use every day. The other is libghostty, a cross-platform, zero-dependency C and Zig library for building terminal emulators or adding terminal functionality, such as escape-sequence parsing and terminal state, to other applications. The README states that Ghostty is "stable and in use by millions of people and machines daily", and five of the six steps on its public roadmap are marked complete.

It is aimed at developers who spend much of their day in a terminal and want a modern one that still behaves like a proper application on their operating system, and at tool builders who want an embeddable terminal engine instead of writing their own parser.

How it works

Ghostty is split into a shared core and platform-specific GUIs. The core, written in Zig, is what the project calls libghostty. On macOS the GUI is written in Swift using AppKit and SwiftUI, renders with Metal and discovers fonts through CoreText. On Linux the GUI is written in Zig against the GTK4 C API and renders with OpenGL. The About page stresses that this is deliberate: tabs, splits and error messages use native UI components instead of custom-drawn text widgets, and each platform gets its own default keyboard shortcuts.

For speed, the README describes a multi-threaded architecture with a dedicated read thread, write thread and render thread for each terminal, and a heavily optimised terminal parser that uses CPU-specific SIMD instructions. On standards, Ghostty defines correct behaviour as (1) the relevant standard where one exists, such as ECMA-48, (2) xterm where the feature exists there, and (3) other popular terminals, in that order. The team ran what it calls a comprehensive xterm audit and built conformance test cases from it.

libghostty is being broken into separate libraries, starting with libghostty-vt, which focuses on parsing terminal sequences and maintaining terminal state. The README says it is usable today from Zig and C on macOS, Linux, Windows and WebAssembly, that its functionality is "extremely stable" because it has powered the Ghostty GUI for a long time, but that API signatures are still in flux and the library has not been given a version tag yet.

Key features

• Windows, tabs and splits: multiple windows, each with tabs and splits, all rendered with native components; the apps also support tab renaming and colouring.
• GPU-accelerated rendering: Metal on macOS and OpenGL on Linux.
• Hundreds of built-in themes: switch with one configuration line, change automatically with the system's light or dark mode, or author your own.
• Zero-configuration defaults: an embedded default font (JetBrains Mono) and built-in Nerd Font symbols, so a fresh install works without a config file.
• Ligatures and font features: ligature fonts render correctly and specific OpenType features can be enabled or disabled.
• Grapheme clustering: multi-codepoint emoji such as flags and skin tones render as single characters, and grapheme clusters in scripts such as Arabic and Hebrew render correctly, though only left-to-right text is supported.
• Modern terminal protocols: the Kitty graphics protocol, Kitty keyboard protocol, clipboard sequences, synchronized rendering, hyperlinks and light/dark mode notifications, which let tools like Neovim and Zellij do more.
• Shell integration: automatic injection for bash, elvish, fish, nushell and zsh, enabling prompt-aware features.
• SSH helpers: automatic terminfo installation and environment forwarding for remote sessions.
• Local crash reports: a built-in crash reporter that writes reports to disk and never sends them anywhere automatically.

Platform-native features

The macOS app is a SwiftUI application with real windowing, menu bars and a settings GUI. Native extras include a Quick Terminal that drops down below the menu bar, an AppleScript dictionary for scripting windows, tabs, terminals and layouts, Apple Shortcuts support through AppIntents, a draggable proxy icon in the title bar, Quick Look lookups with a three-finger tap or force touch, and Secure Keyboard Entry that can be enabled automatically at password prompts, with an animated lock icon showing when it is active. Window state is restored after a restart.

On Linux, the GTK app integrates with systemd where available for features such as an always-on instance, opening new windows in a single process and cgroup isolation. Windows support is described in the features documentation as planned for the future.

Getting started

The Ghostty project only distributes official prebuilt binaries for macOS: a signed and notarized .dmg from the download page. A community-maintained Homebrew cask repackages that same .dmg:

brew install --cask ghostty

On Linux, Ghostty is packaged by distributions rather than by the project. The install docs list commands such as these for Arch Linux (the [extra] repository), Alpine (testing repository), Gentoo and conda-forge via pixi:

pacman -S ghostty
apk add ghostty
emerge -av ghostty
pixi global install ghostty

Building from source requires Zig, and each Ghostty version is only guaranteed to build with one specific Zig version. The build docs' table maps Ghostty 1.2.x to Zig 0.14.1 and 1.3.x and tip to Zig 0.15.2; older or newer compilers may fail. Linux builds also need GTK4 and related development packages, and macOS builds need Xcode with the macOS SDK and Metal toolchain plus gettext. With dependencies in place:

zig build -Doptimize=ReleaseFast
zig build -p $HOME/.local -Doptimize=ReleaseFast

The first command builds in place (on macOS it produces zig-out/Ghostty.app); the second installs into a prefix. The official build environment is defined with Nix, which the docs call the most reliable way to build because CI and release artifacts use it.

Configuration

Ghostty is configured with a plain text file named config.ghostty (called config before version 1.2.3). It is loaded from $XDG_CONFIG_HOME/ghostty/ on all platforms (defaulting to ~/.config), and on macOS also from ~/Library/Application Support/com.mitchellh.ghostty/, with the macOS file loaded last. The syntax is simple key = value pairs:

background = 282c34
foreground = ffffff
keybind = ctrl+z=close_surface
keybind = ctrl+d=new_split:right

Every configuration key also works as a command-line flag, so background can be set with ghostty --background=282c34. A config-file key splits configuration across multiple files, and prefixing the path with ? makes it optional, which helps with machine-specific settings. Configuration reloads at runtime with ctrl+shift+, on Linux or cmd+shift+, on macOS, although some options only apply to new terminals. The full reference is available offline: ghostty +show-config --default --docs prints every option with its documentation, and HTML, Markdown and man-page versions are installed with the app. A native configuration GUI is planned but, for now, the text file is the only way to configure Ghostty.

Shell integration, SSH and terminfo

Shell integration powers several quality-of-life features: no close confirmation when the cursor is at a prompt, new terminals opening in the previous terminal's working directory, prompts that redraw instead of reflowing on resize, selecting a command's output with a modifier plus triple-click, jumping between prompts with the jump_to_prompt keybinding, and moving the cursor with alt/option-click. Ghostty injects the integration automatically for bash, elvish, fish, nushell and zsh, with one caveat: the old Bash shipped as /bin/bash on macOS does not support automatic injection, so the script must be sourced manually or a newer Bash installed.

Ghostty sets TERM to xterm-ghostty. The terminfo docs explain the xterm prefix: too many applications search for "xterm" to guess capabilities, and a pure ghostty value broke them during the private beta. The entry is included in ncurses 6.5-20241228 and later, but many remote servers do not have it yet, which produces errors such as "missing or unsuitable terminal: xterm-ghostty". One documented fix is to copy the entry to the server:

infocmp -x xterm-ghostty | ssh YOUR-SERVER -- tic -x -

Newer releases add ghostty +ssh, a drop-in ssh wrapper that installs the terminfo entry on first connection and forwards COLORTERM, TERM_PROGRAM and TERM_PROGRAM_VERSION (the remote sshd must accept them). The SSH docs say it arrived after the 1.3.x series, in what became 1.4.0. Shell integration can also wrap ssh and sudo automatically, both off by default.

Roadmap and status

The README publishes a short, ordered roadmap. Standards-compliant terminal emulation, competitive performance, rich windowing features (multi-window, tabbing and panes), native platform experiences and a cross-platform libghostty for embeddable terminals are all marked done. The sixth step, Ghostty-only terminal control sequences, is not started. The README explains the hesitation: the team wants terminal applications to be able to do more, but does not want to fragment the ecosystem with sequences that only work in one terminal, so it has so far focused on supporting modern sequences created by other emulators, such as the Kitty protocols, rather than inventing its own.

Crash handling is documented in the same file. Reports are generated the next time Ghostty starts after a crash, saved with a .ghosttycrash extension in the Sentry envelope format, and listed with the ghostty +crash-report CLI command. Because the format is publicly documented, the reports can be inspected with standard tools or uploaded to a personal Sentry account, and the README gives a sentry-cli command for sending one to the Ghostty project voluntarily.

Use cases

• Daily driver terminal on macOS: a native app with Quick Terminal, AppleScript and Shortcuts automation, Secure Keyboard Entry and native tabs and splits, without giving up rendering speed.
• Linux desktops: a GTK4 terminal with systemd integration and the same configuration file and feature set as on the Mac.
• Terminal-heavy editors and multiplexers: tools such as Neovim and Zellij can use the Kitty keyboard and graphics protocols, synchronized rendering and theme-change notifications.
• Embedding a terminal in another app: libghostty-vt gives IDEs, web apps (through WebAssembly) and custom tools a proven parser and state machine; the Ghostling project and the repository's examples directory show how.
• Consistent setups across machines: one text configuration with optional per-machine includes can be checked into a dotfiles repository.

How it compares

The README makes one explicit comparison, which should be read as the project's own claim: Ghostty and Alacritty are "usually within a few percentage points of each other on various benchmarks", and both are described as "something like 100x faster than Terminal.app and iTerm". The README adds that Ghostty is much more feature-rich than Alacritty and has a more native app experience. The About page is more cautious, saying Ghostty only aims to be in the same class as the fastest terminals and is faster in some benchmarks and slower in others. Beyond those statements, the practical differences come down to platform-native UI versus custom-drawn interfaces, built-in tabs and splits versus relying on a multiplexer, and text-file configuration versus a settings GUI.

Things to know before adopting

• Licence: Ghostty is MIT-licensed, which also makes libghostty straightforward to embed in commercial and open-source projects.
• Platform support: official binaries are macOS-only. Linux packages come from distributions and community maintainers, and the project asks users to report packaging problems to their distro first. Windows is planned, not shipped, for the terminal app.
• Configuration is text-only: there is no full settings GUI yet; the docs say native configuration GUIs are planned in addition to the file.
• Zig version pinning: source builds need the exact Zig version for the Ghostty release being built, which can differ from what a distro packages.
• Local builds are not release builds: macOS source builds use a "ReleaseLocal" configuration that disables some security features such as Library Validation; the docs recommend the official binary for full security settings.
• libghostty maturity: functionality is described as stable, but the API is still changing and the library has no version tag yet.
• Crash reports can contain sensitive data: they stay on disk under $XDG_STATE_HOME/ghostty/crash and are never sent automatically, but they include the full stack memory of each thread, so review before sharing.
• Remote hosts: servers without the xterm-ghostty terminfo entry need the entry installed or the SSH helpers enabled.
• Volunteer-run: the About page asks users to remember the project is maintained in contributors' free time.

Project activity

As of November 2026 the repository has about 63,000 stars and roughly 3,800 forks. It was created in March 2022, is written mainly in Zig with Swift for the macOS app, and is released under the MIT licence. Tagged releases include v1.2.x, v1.3.x and v1.4.0, with continuously updated "tip" builds for users who want the development branch. Commits land most days. The source is at github.com/ghostty-org/ghostty, and downloads and documentation are at ghostty.org.

[![Featured on TechLogHub](https://techloghub.com/badge-neutral.svg)](https://techloghub.com/open-source/ghostty?utm_source=techloghub_badge&utm_medium=referral&utm_campaign=readme)