Ghostty
GPU-accelerated terminal emulator written in Zig
Ghostty — Official Website
Quick Take: Ghostty
Ghostty is the best terminal emulator for macOS in 2026. It solved the problem that plagued Mac terminals for years: you couldn't have GPU-accelerated rendering AND native macOS integration in the same app. Ghostty delivers both. The Metal renderer is as fast as Alacritty, the AppKit UI feels like a first-party Apple app, and the Zig codebase keeps the binary small and the memory usage low. If you edit a text config file to set up your tools—and most developers do—Ghostty is the terminal to switch to. The only reasons not to are if you specifically need iTerm2's trigger system, or if you want the AI features that Warp provides.
Best For
- •Neovim and Tmux Power Users
- •Developers Who Want Speed Without Sacrificing Native macOS Feel
- •Anyone Switching from iTerm2 or Alacritty
What is Ghostty?
Ghostty is a terminal emulator written in Zig by Mitchell Hashimoto, the founder of HashiCorp (Terraform, Vagrant, Packer, Consul). It went public as a 1.0 release in December 2024 and within weeks became the most-installed terminal on Homebrew, surpassing iTerm2 in new installations. That trajectory hasn't slowed down. What makes Ghostty different from every other modern terminal is that it's GPU-accelerated AND natively integrated with macOS. Previous terminals made you choose: Alacritty and Kitty render fast via OpenGL/Metal but feel foreign on macOS (no native tabs, no proper window management). iTerm2 feels native but uses CPU rendering that stutters on 5K displays and heavy output. Ghostty uses Metal for rendering at 120Hz+ with sub-millisecond input latency, while using native AppKit for tabs, splits, window chrome, and accessibility. When you Cmd+Tab, use Mission Control, or snap windows with Stage Manager, Ghostty behaves like a first-party Apple app. But when you cat a 50,000-line log file, it renders without dropping a single frame. The terminal itself is a clean, focused tool. No AI assistant, no block-based UI, no collaboration features, no account required. You configure it with a simple key-value text file at ~/.config/ghostty/config, and it reloads changes live when you save. The shell integration feature (for Zsh, Bash, and Fish) adds intelligent prompt detection, clickable URLs, and native macOS notifications when long-running commands complete. Ghostty's binary is a few megabytes—no Electron, no Python, no Node.js runtime bundled. On an M-series Mac it uses about 30-50MB of RAM with a dozen tabs open.
Install with Homebrew
brew install --cask ghosttyDeep Dive: How Ghostty Beat iTerm2
The technical decisions behind Ghostty's performance, why Zig was chosen over Rust, and the libghostty architecture that enables cross-platform support.
History & Background
Ghostty started as Mitchell Hashimoto's side project in early 2023, during his sabbatical from HashiCorp. Hashimoto chose Zig over Rust because Zig's explicit memory management and C ABI compatibility made interfacing with macOS system libraries (AppKit, Metal, CoreText) straightforward—no bindgen, no FFI wrappers, just direct C interop. The project stayed invite-only throughout 2024, building enormous anticipation. Early testers compared notes on Hacker News and Twitter, generating a waitlist of thousands. The public 1.0 release in December 2024 hit #1 on Hacker News, accumulated 20,000+ GitHub stars in the first month, and became the most-installed Homebrew cask for terminal emulators within weeks.
How It Works
Ghostty separates terminal emulation from platform rendering via libghostty, a C-compatible library that handles VT parsing, grid management, and text layout. The macOS frontend is a native Swift + AppKit app that calls libghostty for terminal logic and uses Metal shaders for text rasterization. On Linux, a separate GTK4 frontend calls the same libghostty for identical terminal behavior. This architecture means adding a new platform (Windows, for example) requires only a new frontend—the terminal emulation core is shared. The Metal renderer uses custom shaders optimized for text: glyph caching, subpixel positioning, and gamma-correct blending. The result is frame times under 1ms even on 6K displays with heavy output.
Ecosystem & Integrations
The Ghostty ecosystem is centered on configuration sharing and themes. The ghostty-themes repository hosts hundreds of community-contributed color schemes. Shell integration scripts (Zsh, Bash, Fish) are maintained as first-party components. Third-party integrations include tmux-ghostty for deeper tmux integration, and Neovim plugins that detect Ghostty to enable terminal-specific features (like image rendering via the Kitty protocol). The community tends toward experienced developers—the Discord and GitHub Discussions are notably technical and low-noise.
Future Development
Ghostty's 2026 roadmap includes Sixel protocol support (for broader image compatibility), session persistence (restoring terminal state after app restarts—distinct from tmux session restoration), tighter macOS Shortcuts integration for automation, and further performance optimization of the Metal renderer. The team is also exploring WebGPU as a future rendering backend for platforms without Metal. Mitchell Hashimoto has publicly stated that Ghostty will remain focused on being a terminal emulator—no AI features, no collaboration tools, no scope creep.
Key Features
Metal-Accelerated Rendering
Ghostty renders text using Apple's Metal API with custom shaders. The result: smooth 120Hz scrolling on ProMotion displays, zero tearing on external monitors, and input latency measured in fractions of a millisecond. Cat a massive log file and the output streams at full speed without the stuttering you'd see in iTerm2. Run a complex Neovim colorscheme with 50 highlight groups and the rendering doesn't flinch. On 5K and 6K displays (Apple Studio Display, Pro Display XDR), text is crisp because the renderer handles high-DPI scaling natively rather than relying on macOS's text scaling layer.
Native AppKit UI
Ghostty's tabs, splits, and window chrome use macOS's native AppKit APIs. This means tabs look and behave exactly like Safari tabs. Split panes (Cmd+D for vertical, Cmd+Shift+D for horizontal) resize smoothly with native animations. The app appears correctly in Mission Control, supports Stage Manager, respects Reduce Motion accessibility settings, and integrates with the macOS Accessibility framework for VoiceOver. It's the only GPU-accelerated terminal that passes the 'show it to someone who doesn't know what a terminal is, and they think it's a normal Mac app' test.
Kitty Graphics Protocol
Ghostty implements the Kitty Graphics Protocol, which lets applications display images, plots, and diagrams inline in the terminal. If you use tools like timg, viu, or Neovim with image.nvim, you can view PNG, JPEG, and GIF images directly in your terminal window. This is especially useful for data scientists viewing matplotlib plots via a CLI, or developers previewing image assets without opening a separate app. The protocol support also enables Neovim plugins that display file type icons and image previews in file explorers.
Shell Integration
Ghostty includes shell integration scripts for Zsh, Bash, and Fish that inject metadata into your terminal session. With shell integration enabled, Ghostty can detect where each command prompt starts (enabling Cmd+click to jump between prompts), highlight the current command block, and send a native macOS notification when a long-running command finishes. Run `make build` (takes 3 minutes), switch to your browser, and a macOS notification tells you when it's done. This feature alone justifies the switch for developers who run long builds or test suites.
Simple Configuration
The config file at ~/.config/ghostty/config is plain text with key = value syntax. No TOML, no YAML, no Lua. Set your font: `font-family = JetBrains Mono`. Set the theme: `theme = catppuccin-mocha`. Enable background blur: `background-opacity = 0.9` and `background-blur-radius = 20`. The config reloads when you save it—no restart required. Every available option can be listed by running `ghostty +list-config --default`, which outputs the complete config reference with descriptions and defaults. The simplicity is intentional: the config should be readable by humans and diff-friendly in Git.
Zig-Powered Binary
Ghostty is written in Zig, a systems language designed for manual memory management without the footguns of C. The result is a small binary (a few MB), fast startup (under 100ms on M-series Macs), and low memory usage (30-50MB with a dozen tabs). There's no garbage collector pausing mid-render, no JIT warmup, no Electron browser engine spinning up. The choice of Zig also means Ghostty has excellent C interop, which is how it talks directly to macOS's AppKit and Metal APIs without FFI overhead.
Who Should Use Ghostty?
1The Neovim Power User
A developer who lives in Neovim all day with a complex config—Tree-sitter for syntax highlighting, LSP for IntelliSense, oil.nvim for file management, and image.nvim for inline image previews. They run Neovim inside Tmux with 3-4 panes visible at once. In iTerm2, heavy Neovim rendering with transparent backgrounds caused visible lag. In Ghostty, the Metal renderer handles complex colorschemes, transparency with blur, and the Kitty Graphics Protocol for image previews without any frame drops. The input latency difference is the clincher—keystrokes feel instant in a way they didn't before.
2The DevOps Engineer with Too Many Tabs
An SRE managing production infrastructure has 20+ tabs open: SSH sessions to different servers, local development, Docker logs, kubectl watches. Each tab has a different purpose and some run long-lived processes (Ansible playbooks, Terraform applies). Ghostty's native tabs keep memory usage manageable (50-70MB total), the shell integration sends macOS notifications when long commands finish, and the quick terminal feature (bound to a global hotkey) provides instant access to a drop-down terminal for quick one-off commands without disrupting the main window.
3The Font Nerd
A developer who cares deeply about typography switches between coding fonts regularly—JetBrains Mono, Berkeley Mono, Monaspace Neon, Iosevka. Ghostty's text shaping engine (built on HarfBuzz) handles ligatures correctly for every font, renders contextual alternates, and supports font features via the config (`font-feature = calt`). The `font-thicken = true` option adds weight on high-DPI displays where thin fonts can look washed out. Running `ghostty +list-fonts` shows exactly which fonts are detected, eliminating the guesswork of 'why isn't this font rendering.'
How to Install Ghostty on Mac
Ghostty installs via Homebrew Cask. It requires macOS 13 (Ventura) or later.
Install via Homebrew
Run `brew install --cask ghostty` in your current terminal. This downloads the signed binary from Ghostty's official distribution and installs it to /Applications.
Launch and Grant Permissions
Open Ghostty from Applications. macOS will ask for Accessibility permissions on first launch—grant them so Ghostty can manage windows properly. The app may also request Full Disk Access depending on your shell configuration.
Create Your Config File
Create ~/.config/ghostty/config (the directory and file don't exist by default). Start with the basics: `font-family = JetBrains Mono`, `font-size = 14`, `theme = catppuccin-mocha`. See the full config reference with `ghostty +list-config --default`.
Enable Shell Integration
Add the shell integration snippet to your ~/.zshrc (or ~/.bashrc or ~/.config/fish/config.fish). The snippet is available in Ghostty's Help menu or by running `ghostty +show-config --shell-integration`. This enables prompt detection, command notifications, and clickable URLs.
Pro Tips
- • Run `ghostty +list-fonts` to see all detected fonts before configuring font-family.
- • Set `window-save-state = always` to restore all tabs and splits when Ghostty relaunches after a restart or update.
- • Use `keybind = global:cmd+grave_accent=toggle_quick_terminal` for a Quake-style drop-down terminal accessible from any app.
Configuration Tips
Optimize Font Rendering for Retina Displays
Add `font-thicken = true` to your config for bolder, more readable text on high-DPI screens. If your coding font has ligatures you don't like (like != rendering as ≠), disable specific features: `font-feature = -calt`. For fonts with stylistic alternates (like Monaspace Neon), enable them: `font-feature = ss01`. The `font-size-step = 1` setting gives finer control over Cmd+Plus/Minus zoom—the default step of 2 is too coarse for some users.
Set Up Quick Terminal (Quake-Style Drop-Down)
Add this to your config: `keybind = global:cmd+grave_accent=toggle_quick_terminal`. This creates a terminal that drops down from the top of your screen when you press Cmd+` from any app. It stays resident in memory for instant access. It's the same concept as iTerm2's Hotkey Window or the old Visor plugin for Terminal.app. The quick terminal uses its own independent state, so it doesn't interfere with your main Ghostty window.
Alternatives to Ghostty
Ghostty occupies a specific niche: fast, native, focused. These alternatives serve different philosophies.
iTerm2
iTerm2 has been the default Mac terminal for over a decade. It has a GUI preferences pane, a massive feature set (triggers, profiles, badges, tmux integration mode), and a long track record. But it uses CPU rendering, which makes it noticeably sluggish on high-DPI displays and heavy output. If you depend on specific iTerm2 features (like its proprietary tmux integration or Trigger system), stay. If you want speed and native feel without the legacy bloat, switch to Ghostty.
Alacritty
Alacritty pioneered GPU-accelerated terminals. It's marginally faster than Ghostty in raw rendering benchmarks (by 1-2ms). But Alacritty has no tabs, no splits, no native macOS UI—it renders its own window decoration and expects you to use tmux for everything. Ghostty gives you Alacritty's speed with native macOS tabs and splits. If you're already committed to tmux for everything and want the absolute fastest renderer, Alacritty works. For everyone else, Ghostty is the better macOS experience.
Warp
Warp is a different category—it's an AI-powered terminal with blocks, collaboration, and a built-in coding agent. It requires an account, collects usage data (they're transparent about this), and costs $20/month for full AI features. If you want AI assistance in your terminal, use Warp. If you want a pure, fast, private terminal that just runs your shell, use Ghostty. Many developers use both: Ghostty as their daily driver and Warp when they need AI help.
Pricing
Ghostty is free and open-source under the MIT License. There are no paid features, no subscription, no telemetry, no account required. The project is maintained by Mitchell Hashimoto with community contributions. Pre-built binaries are distributed for free via Homebrew and the official website. You can also build from source via the Zig build system if you want to inspect or modify the code.
Pros
- ✓Metal GPU rendering with sub-millisecond input latency and 120Hz scrolling
- ✓Native macOS UI (tabs, splits, window management, Mission Control, Stage Manager)
- ✓Tiny binary (few MB), low RAM usage (30-50MB), instant startup (<100ms)
- ✓Simple key-value config file with live reload
- ✓Shell integration with command notifications and prompt detection
- ✓Full Kitty Graphics Protocol support for inline images
- ✓HarfBuzz text shaping for correct ligatures and font features
- ✓Free, open-source, no telemetry, no account
Cons
- ✗No GUI settings—everything is config file only
- ✗Extension/plugin ecosystem doesn't exist (it's intentionally just a terminal)
- ✗No built-in AI features (by design—use a separate tool)
- ✗Themes must be installed manually (copy to config directory)
- ✗Younger project than iTerm2—some edge cases in VT100 compatibility remain
Community & Support
Ghostty's community is technical and active. The primary channels are the GitHub repository (nikitabobko/ghostty), GitHub Discussions for feature requests and configuration help, and a Discord server where the maintainers respond directly. The documentation is generated from the source code using `ghostty +list-config`, so it's always in sync with the current release. Community-contributed themes are shared via the ghostty-themes repository, with popular palettes like Catppuccin, Dracula, Tokyo Night, Gruvbox, and Nord available. Because Ghostty is written in Zig, the contributor base tends toward systems programmers who submit high-quality pull requests and detailed bug reports.
Video Tutorials
Getting Started with Ghostty
More Tutorials
Ghostty Terminal: A Complete Setup Guide for Modern Mac Development
WEBdoze • 27.4K views
My New Terminal for 2025 — setup, neovim, and TMUX, oh my!
chantastic • 35.3K views
Ghostty - The BEST Terminal!?
Better Stack • 112.2K views
Frequently Asked Questions about Ghostty
Our Verdict
Ghostty is the best terminal emulator for macOS in 2026. It solved the problem that plagued Mac terminals for years: you couldn't have GPU-accelerated rendering AND native macOS integration in the same app. Ghostty delivers both. The Metal renderer is as fast as Alacritty, the AppKit UI feels like a first-party Apple app, and the Zig codebase keeps the binary small and the memory usage low. If you edit a text config file to set up your tools—and most developers do—Ghostty is the terminal to switch to. The only reasons not to are if you specifically need iTerm2's trigger system, or if you want the AI features that Warp provides.
About the Author
Related Technologies & Concepts
Related Topics
Sources & References
Fact-CheckedLast verified: Feb 23, 2026
- 1Ghostty Official Website
Accessed Feb 23, 2026
- 2Ghostty GitHub Repository
Accessed Feb 23, 2026
Research queries: Ghostty terminal Mac 2026