Ghostty Terminal: Setup and Configuration Guide

Posted: April 14, 2026 to Technology.

Ghostty is a fast, cross-platform terminal emulator built by Mitchell Hashimoto, the founder of HashiCorp (creators of Terraform, Vagrant, Vault, and Consul). Written in Zig with native GPU rendering, Ghostty focuses on correctness, performance, and a native look and feel on every platform. It runs natively on macOS using Cocoa and on Linux using GTK4, with no Electron wrapper in sight. Ghostty was released as open source in late 2024, and since then it has attracted enormous attention from the developer community for good reason: it gets the fundamentals right while introducing features that experienced terminal users have wanted for years.

At Petronella Technology Group, our engineering team evaluates every terminal emulator that gains serious traction. We run GPU-intensive AI development workflows and manage infrastructure across dozens of machines via SSH. A terminal is not a peripheral tool for us; it is the primary interface. After months of daily use across macOS and Linux workstations, we wrote this guide to cover everything from initial installation to advanced configuration patterns that make Ghostty a genuine productivity upgrade.

What Is Ghostty

Ghostty is a terminal emulator that prioritizes correctness of terminal emulation, GPU-accelerated rendering, and a platform-native user experience. Mitchell Hashimoto started building it as a personal project while still at HashiCorp, driven by frustration with the compromises every existing terminal emulator makes. After years of development, Ghostty was open-sourced in December 2024 under the MIT license, and the response from the developer community was immediate and overwhelmingly positive.

The project is written in Zig, a systems programming language that provides manual memory management with safety features, comptime (compile-time) code generation, and C interop without overhead. Zig was a deliberate choice: it gives Ghostty the low-level control needed for a high-performance rendering pipeline while avoiding many of the footguns that come with plain C. The rendering backend uses custom GPU shaders to draw text and UI elements, producing smooth, consistent output regardless of how many lines of text are scrolling past.

On macOS, Ghostty uses native Cocoa APIs for its window chrome, menus, tabs, and system integration. This means it behaves like a real macOS application: it supports native tabs, respects system appearance settings (light and dark mode), integrates with macOS Services, and follows platform conventions for keyboard shortcuts. On Linux, it uses GTK4 for windowing and integrates with Wayland and X11. The result is a terminal that does not feel like a cross-platform port on either operating system.

The codebase is publicly available on GitHub at ghostty-org/ghostty. Hashimoto has been transparent about the design decisions, writing detailed blog posts and engaging with the community on Discord. The project accepts contributions and has a growing ecosystem of themes, integrations, and community documentation.

Why Ghostty Matters

Correct Terminal Emulation

Most terminal emulators get 95% of terminal emulation right and then quietly break on the remaining 5%. That last 5% shows up as rendering glitches in TUIs (terminal user interfaces), broken mouse reporting in Neovim or Midnight Commander, incorrect color handling in nested tmux sessions, or garbled output from obscure but valid escape sequences. Ghostty treats correctness as the top priority. Hashimoto built a comprehensive test suite against the VT100/VT220 specification and modern xterm extensions, and he has publicly documented cases where Ghostty correctly handles escape sequences that kitty, Alacritty, and even iTerm2 get wrong.

This matters more than it might seem. If you use tools like lazygit, btop, yazi, or any Neovim plugin that relies on advanced terminal features (sixel graphics, synchronized output, styled underlines, hyperlinks), correctness determines whether those tools render properly or produce visual artifacts. Ghostty aims to be the terminal where everything just works without needing to add workarounds to your shell configuration.

GPU-Accelerated Rendering with Minimal Latency

Ghostty renders all text using custom GPU shaders. Every glyph is rasterized on the GPU, which means the CPU is free to handle the data stream from your shell while the GPU handles all visual output. The rendering pipeline is designed for low latency: the time between a keystroke and the corresponding character appearing on screen is measured in single-digit milliseconds. For fast typists and for workflows that produce large amounts of output (build logs, test suites, streaming data), the difference between a GPU-rendered terminal and a CPU-rendered one is visible and measurable.

Native Look and Feel (Not Electron)

Ghostty does not use Electron, Qt, or any cross-platform UI framework that abstracts away the native platform. On macOS, it is a real AppKit application. On Linux, it is a GTK4 application. This means it respects system fonts, follows platform keyboard conventions, supports native drag-and-drop, and integrates with the operating system rather than reimplementing it. Terminals built on Electron (such as Hyper) carry the overhead of an entire Chromium browser engine. Ghostty carries no such overhead.

Zero-Config Defaults

Ghostty ships with carefully chosen defaults that work well for the majority of users without any configuration. The default font is a high-quality monospace font bundled with the application. The default color scheme is readable on both light and dark backgrounds. The default keybindings follow platform conventions. You can install Ghostty and start working immediately without writing a single line of configuration. When you do want to customize, the configuration system is straightforward and well-documented.

Built by Someone Who Understands Developer Workflows

Mitchell Hashimoto spent over a decade building tools for developers at HashiCorp. Terraform, Vagrant, Packer, and Consul are used by millions of engineers daily. That experience shaped Ghostty in ways that are hard to quantify but easy to feel: the split pane implementation is intuitive, the tab behavior matches what you expect, shell integration features surface useful information without getting in the way, and the configuration file format is simple enough that you never need to consult documentation for basic changes.

Installation: macOS, Linux, and NixOS

macOS

The easiest installation method on macOS is Homebrew:

brew install --cask ghostty

Alternatively, download the .dmg file directly from the Ghostty website at ghostty.org and drag the application to your Applications folder. The direct download is a universal binary that runs natively on both Apple Silicon (M1/M2/M3/M4) and Intel Macs.

After installation, launch Ghostty from your Applications folder or Spotlight. On first launch, macOS may prompt you to allow accessibility permissions for shell integration features. Grant these permissions for the full feature set.

Linux: Package Managers

Ghostty is available in several Linux distribution repositories. On Arch Linux:

sudo pacman -S ghostty

On Fedora (40+):

sudo dnf install ghostty

On Ubuntu and Debian-based distributions, Ghostty provides official .deb packages. Check the releases page on GitHub for the latest version. You can also add the Ghostty PPA for automatic updates:

# Check ghostty.org for the latest repository instructions
# as the PPA URL may change between releases

Building from Source

Ghostty is written in Zig, so building from source requires a Zig compiler (version 0.13+). The build process is straightforward:

git clone https://github.com/ghostty-org/ghostty.git
cd ghostty
zig build -Doptimize=ReleaseFast

On Linux, you will need GTK4 development headers, fontconfig, freetype2, and libadwaita as build dependencies. On NixOS, these are handled automatically by the flake.

NixOS

NixOS users can install Ghostty from nixpkgs or from the official Ghostty flake for the latest version:

# In configuration.nix or home.nix (nixpkgs)
environment.systemPackages = with pkgs; [
  ghostty
];

# Or via the Ghostty flake (latest)
# Add to flake inputs:
#   ghostty.url = "github:ghostty-org/ghostty";
# Then in packages:
#   ghostty.packages.${system}.default

The NixOS package integrates well with our team’s declarative workstation configurations. If you are running Niri or Hyprland on NixOS (see our Niri compositor guide and Hyprland setup guide), Ghostty is the terminal we recommend pairing with either compositor.

Configuration Deep Dive

Config File Location and Format

Ghostty reads its configuration from ~/.config/ghostty/config on Linux and ~/Library/Application Support/com.mitchellh.ghostty/config on macOS. The file uses a simple key-value format with one setting per line. Comments start with #. There are no nested blocks, no brackets, and no indentation requirements. This is refreshingly simple compared to the TOML, YAML, or KDL formats used by other terminals.

# Ghostty configuration
# ~/.config/ghostty/config

# Font
font-family = JetBrainsMono Nerd Font
font-size = 13
font-thicken = true

# Window
window-padding-x = 8
window-padding-y = 4
window-decoration = true
window-theme = auto

# Cursor
cursor-style = block
cursor-style-blink = false

# Mouse
mouse-hide-while-typing = true

# Clipboard
clipboard-read = allow
clipboard-write = allow

# Scrollback
scrollback-limit = 100000

Font Configuration

Fonts are the single most impactful visual setting in any terminal. Ghostty ships with a built-in font (JetBrains Mono) that works well out of the box, but most developers prefer a Nerd Font variant for icon support in tools like Starship, Powerlevel10k, and file managers such as yazi and lf. We have a complete Nerd Fonts install and setup guide that covers the full installation process.

# Font family (must be installed on your system)
font-family = JetBrainsMono Nerd Font

# You can specify different fonts for different styles
font-family-bold = JetBrainsMono Nerd Font Bold
font-family-italic = JetBrainsMono Nerd Font Italic
font-family-bold-italic = JetBrainsMono Nerd Font Bold Italic

# Font size in points
font-size = 13

# Thicken font rendering (useful on macOS Retina displays)
font-thicken = true

# Control font features (ligatures, etc.)
font-feature = calt
font-feature = liga

# To DISABLE ligatures:
# font-feature = -calt
# font-feature = -liga

Ghostty handles font fallback intelligently. If a glyph is not found in your primary font, it searches system fonts for a match. This means emoji, CJK characters, and mathematical symbols render correctly even if your primary font does not include them. You can also specify explicit fallback fonts with additional font-family lines.

Color Scheme Setup

Ghostty supports color schemes through its configuration file. You can set individual colors or use a named theme. The built-in theme system includes dozens of popular schemes, and you can add custom themes as well.

# Use a built-in theme
theme = Tokyo Night

# Or set colors manually for full control
# background = 1a1b26
# foreground = c0caf5
# cursor-color = c0caf5
# selection-background = 33467c
# selection-foreground = c0caf5
#
# palette = 0=#15161e
# palette = 1=#f7768e
# palette = 2=#9ece6a
# palette = 3=#e0af68
# palette = 4=#7aa2f7
# palette = 5=#bb9af7
# palette = 6=#7dcfff
# palette = 7=#a9b1d6
# palette = 8=#414868
# palette = 9=#f7768e
# palette = 10=#9ece6a
# palette = 11=#e0af68
# palette = 12=#7aa2f7
# palette = 13=#bb9af7
# palette = 14=#7dcfff
# palette = 15=#c0caf5

If you are using the Tokyo Night color scheme across your entire development environment, our Tokyo Night theme setup guide covers configuration for terminals, editors, and window managers to achieve a consistent look. Ghostty’s built-in Tokyo Night theme matches the canonical color values, so a single theme = Tokyo Night line is all you need.

Keybinding Customization

Ghostty allows you to remap any keybinding. The default keybindings follow platform conventions (Cmd on macOS, Ctrl on Linux), but you can override them entirely:

# Custom keybindings
keybind = ctrl+shift+c=copy_to_clipboard
keybind = ctrl+shift+v=paste_from_clipboard

# Split pane management
keybind = ctrl+shift+enter=new_split:right
keybind = ctrl+shift+minus=new_split:down
keybind = ctrl+shift+h=goto_split:left
keybind = ctrl+shift+l=goto_split:right
keybind = ctrl+shift+k=goto_split:top
keybind = ctrl+shift+j=goto_split:bottom

# Tab management
keybind = ctrl+shift+t=new_tab
keybind = ctrl+shift+w=close_surface
keybind = ctrl+tab=next_tab
keybind = ctrl+shift+tab=previous_tab

# Font size adjustment
keybind = ctrl+equal=increase_font_size:1
keybind = ctrl+minus=decrease_font_size:1
keybind = ctrl+0=reset_font_size

# Quick terminal toggle (Linux)
keybind = global:ctrl+grave_accent=toggle_quick_terminal

The keybinding system supports modifiers (ctrl, shift, alt, super), key names, and action parameters. You can also unbind default keybindings with keybind = ctrl+shift+n=unbind if a default conflicts with a tool you use inside the terminal.

Window and Tab Behavior

# Window settings
window-padding-x = 8
window-padding-y = 4
window-padding-balance = true
window-decoration = true
window-theme = auto
window-inherit-working-directory = true
window-inherit-font-size = true

# Tab bar appearance
gtk-tabs-location = top
window-save-state = always

# Background opacity (Linux with compositor, macOS always)
background-opacity = 0.95

# Unfocused split dimming
unfocused-split-opacity = 0.85

The window-inherit-working-directory setting is especially useful: new tabs and splits open in the same directory as the currently focused pane. Combined with shell integration (covered below), this eliminates the repetitive cd commands that plague multi-tab workflows.

Shell Integration

Ghostty includes built-in shell integration for Bash, Zsh, Fish, and Elvish. Shell integration enables features that the terminal cannot provide on its own because they require cooperation from the shell:

• Working directory tracking: Ghostty knows which directory each pane is in, enabling window-inherit-working-directory and displaying the path in the tab title.
• Prompt marking: The terminal knows where each command prompt begins and ends, allowing you to jump between prompts with a keybinding.
• Command completion notifications: Long-running commands trigger a system notification when they finish.
• Semantic zones: The terminal can distinguish between the prompt, user input, and command output, enabling features like selecting only the output of the last command.

Shell integration is enabled by default and activates automatically when Ghostty detects a supported shell. No changes to your .bashrc, .zshrc, or config.fish are required. If you need to disable it (for example, because it conflicts with another shell plugin), add shell-integration = none to your config.

Unique Features

Split Panes

Ghostty includes built-in split pane support without requiring tmux or a multiplexer. You can split the current pane horizontally or vertically, navigate between splits with keybindings, and resize them with the mouse or keyboard. Each split is an independent terminal session.

# Split the current pane
keybind = ctrl+shift+enter=new_split:right
keybind = ctrl+shift+minus=new_split:down

# Navigate between splits
keybind = ctrl+shift+h=goto_split:left
keybind = ctrl+shift+l=goto_split:right
keybind = ctrl+shift+k=goto_split:top
keybind = ctrl+shift+j=goto_split:bottom

# Resize splits
keybind = ctrl+shift+alt+h=resize_split:left,20
keybind = ctrl+shift+alt+l=resize_split:right,20
keybind = ctrl+shift+alt+k=resize_split:up,20
keybind = ctrl+shift+alt+j=resize_split:down,20

# Equalize split sizes
keybind = ctrl+shift+e=equalize_splits

For simple two or three pane layouts, Ghostty’s built-in splits are faster and lighter than launching tmux. The splits are native to the terminal, so they respect your font settings, color scheme, and padding without any additional configuration. For complex session management (persistent sessions across SSH disconnects, named windows, scripted layouts), tmux or zellij remain the better tool.

Quick Terminal (Global Hotkey Dropdown)

On Linux, Ghostty supports a quick terminal feature: a single-key global hotkey that toggles a dropdown terminal that slides in from the top of your screen. This is similar to the Quake-style dropdown terminal made popular by Guake and Yakuake.

# Enable the quick terminal with a global hotkey
keybind = global:ctrl+grave_accent=toggle_quick_terminal
quick-terminal-position = top
quick-terminal-screen = mouse
quick-terminal-animation-duration = 0.1

The quick terminal is particularly useful when you are working in a non-terminal application (a browser, an IDE, a design tool) and need to run a quick command without switching windows. Press the hotkey, run your command, press the hotkey again to dismiss. The terminal stays in the background with its state preserved.

Font Features and Ligature Control

Ghostty provides granular control over OpenType font features. You can enable or disable specific features per font:

# Enable programming ligatures
font-feature = calt
font-feature = liga

# Enable stylistic alternates (varies by font)
font-feature = ss01
font-feature = ss02

# Disable a specific feature
font-feature = -liga

This is important for developers who use fonts like JetBrains Mono, Fira Code, or Cascadia Code that include programming ligatures. Some developers love seeing != rendered as a single glyph; others find it distracting. Ghostty lets you choose at a fine-grained level without changing fonts.

Cursor Customization

# Cursor style: block, bar, underline
cursor-style = block

# Disable cursor blinking (reduces visual noise)
cursor-style-blink = false

# Cursor color (overrides theme)
cursor-color = c0caf5

# Invert the foreground color on the cursor for visibility
cursor-invert-fg-bg = true

Hyperlink Detection and Handling

Ghostty automatically detects URLs in terminal output and makes them clickable. Hold Ctrl (or Cmd on macOS) and click a URL to open it in your default browser. File paths can also be detected and opened if configured. The hyperlink detection supports the OSC 8 escape sequence used by modern CLI tools to output explicit hyperlinks with custom display text.

# Enable URL detection (on by default)
link-url = true

# Open links on click without holding a modifier
# (most users prefer requiring a modifier to avoid accidental clicks)
# mouse-binding = left:link=open

Performance Deep Dive

GPU Rendering Pipeline

Ghostty’s rendering pipeline is built from scratch using custom shaders. When text arrives from the shell, the terminal parser processes escape sequences and updates an internal screen buffer. The renderer then converts this buffer into GPU draw calls. Each glyph is rasterized into a texture atlas, and the atlas is uploaded to the GPU once. Subsequent frames reference the atlas without re-rasterizing, which means the GPU does almost no redundant work when drawing the same characters repeatedly.

The shader handles subpixel positioning, gamma correction, and font hinting in a single pass. This eliminates the multi-stage CPU pipeline that traditional terminals use (rasterize on CPU, composite on CPU, blit to screen). The result is lower latency and lower CPU usage, especially during high-throughput operations like scrolling through large log files or running verbose build output.

Latency Comparison

Input latency is the time between pressing a key and seeing the corresponding character on screen. Ghostty consistently measures between 2 and 5 milliseconds of input latency in benchmarks using tools like Typometer. For comparison:

• Ghostty: 2 to 5 ms
• kitty: 3 to 7 ms
• Alacritty: 2 to 6 ms
• WezTerm: 5 to 12 ms
• iTerm2: 8 to 15 ms
• GNOME Terminal: 10 to 20 ms

Below 10 ms, most humans cannot consciously perceive the difference. However, fast typists and competitive programmers report that sub-5 ms terminals "feel" more responsive, even if they cannot articulate exactly why. If you spend eight or more hours per day in a terminal, this difference in responsiveness compounds into reduced fatigue.

Memory Usage

Ghostty is lean on memory. A single window with a fresh shell session uses approximately 30 to 50 MB of RAM, depending on the platform and font cache size. Each additional tab or split adds roughly 5 to 15 MB. For comparison:

• Ghostty: ~35 MB base, ~10 MB per additional tab
• kitty: ~45 MB base, ~12 MB per additional tab
• Alacritty: ~25 MB base (single window only, no tabs)
• WezTerm: ~80 MB base, ~15 MB per additional tab
• iTerm2: ~120 MB base, ~20 MB per additional tab

Alacritty uses less base memory, but it achieves this by having no tabs, no splits, and no features beyond basic terminal emulation. When you factor in running tmux alongside Alacritty to get tabs and splits, the total memory usage is comparable to Ghostty.

Large Scrollback Buffer Handling

Ghostty supports scrollback buffers up to millions of lines without significant performance degradation. The scrollback is stored in a memory-mapped ring buffer that pages to disk when the buffer exceeds available RAM. This means you can set scrollback-limit = 1000000 without worrying about the terminal consuming gigabytes of memory. Searching within scrollback is also fast because the buffer is indexed for substring search.

# Set a large scrollback buffer
scrollback-limit = 100000

# Unlimited scrollback (pages to disk as needed)
# scrollback-limit = 0

Ghostty for Professional Workflows

Pairing with tmux or zellij for Session Management

Ghostty’s built-in splits handle simple layouts well, but for persistent session management, tmux and zellij remain essential. The key scenarios where a multiplexer adds value over Ghostty’s native features:

• SSH persistence: If your SSH connection drops, tmux sessions survive on the remote host. Ghostty splits do not.
• Scripted layouts: tmux send-keys and zellij layouts allow you to script complex multi-pane environments that launch with a single command.
• Named sessions: Switching between projects is instant with named tmux sessions (tmux switch -t project-name).
• Shared sessions: tmux allows multiple users to attach to the same session for pair programming.

Ghostty plays nicely with both multiplexers. There are no known rendering conflicts with tmux or zellij. The TERM value is set correctly (xterm-ghostty or xterm-256color), true color support is enabled, and shell integration works inside tmux sessions when configured properly.

# For tmux true color support, add to ~/.tmux.conf:
set -g default-terminal "tmux-256color"
set -ag terminal-overrides ",xterm-ghostty:RGB"

SSH Workflow Integration

Ghostty’s shell integration features extend across SSH connections when the remote host has the Ghostty terminfo entry installed. This enables working directory tracking, prompt marking, and semantic zones on remote machines. Install the terminfo entry on remote hosts with:

# On the remote host
infocmp -x xterm-ghostty | tic -x -

If installing terminfo is not possible (shared servers, restricted environments), set the TERM variable to xterm-256color on the remote host for maximum compatibility. Ghostty degrades gracefully when advanced features are not available on the remote end.

For teams managing fleets of servers (as we do at Petronella for our clients’ managed infrastructure), SSH workflow efficiency directly impacts productivity. Ghostty’s tab titles update with the hostname of the SSH connection, making it easy to identify which tab connects to which server.

AI Development: Monitoring Training Runs and GPU Dashboards

Our team runs AI workloads that produce enormous volumes of terminal output: training logs, GPU utilization metrics, inference benchmarks. Ghostty handles this well because of its GPU rendering pipeline. Where older terminals stutter or drop frames when nvidia-smi output refreshes every second alongside a training run printing loss values every batch, Ghostty maintains smooth rendering with low CPU overhead.

A practical layout for AI development in Ghostty:

# Split layout for AI work
# Main pane: training script
# Right pane: nvidia-smi or nvtop
# Bottom pane: logs or tensorboard

# Ctrl+Shift+Enter to split right (nvidia-smi monitoring)
# Ctrl+Shift+Minus to split down (log tailing)

For persistent monitoring across multiple GPU machines, pair Ghostty with tmux and use split panes within tmux for the remote sessions. This gives you both the rendering performance of Ghostty and the session persistence of tmux.

Comparison: Ghostty vs kitty vs Alacritty vs WezTerm vs iTerm2

When to Choose Each Terminal

Choose Ghostty if you want a terminal that works exceptionally well out of the box, provides correct terminal emulation for complex TUI applications, and delivers native platform integration on both macOS and Linux. It is the best all-around choice for developers who want to install a terminal and start working without a lengthy configuration process.

Choose kitty if you need advanced features like the kitty graphics protocol for inline images, remote control for scripted terminal automation, or SSH integration with automatic shell integration on remote hosts. kitty has a larger feature set than Ghostty, though some of those features come with additional complexity.

Choose Alacritty if you want the absolute minimum terminal emulator with no built-in tabs, no splits, and no features beyond rendering text. Alacritty pairs with tmux or zellij for everything else. If you already have a sophisticated tmux setup and want the lightest possible terminal layer, Alacritty is hard to beat on simplicity.

Choose WezTerm if you need a Lua-scriptable terminal for complex automation. WezTerm’s configuration is written in Lua, which means you can write conditional logic, dynamically generate configurations, and hook into terminal events with a real programming language. The trade-off is higher memory usage and more complexity.

Choose iTerm2 if you are on macOS and value the extensive GUI preferences, Trigger system, Profiles, and the years of macOS-specific polish that iTerm2 provides. iTerm2 is not available on Linux and has higher resource usage than Ghostty, but it remains the most feature-rich macOS terminal available.

Tips and Tricks

Reload Configuration Instantly

Ghostty watches its configuration file for changes and applies them immediately. You do not need to restart the terminal or press a reload keybinding. Edit your config, save, and the changes appear. This makes iterating on your color scheme or keybindings fast and painless.

Use Multiple Config Files

Ghostty supports a config-file directive that includes another configuration file. This lets you split your configuration into a base file and machine-specific overrides:

# In your main config file
config-file = ~/.config/ghostty/themes/tokyo-night
config-file = ~/.config/ghostty/keybindings
config-file = ~/.config/ghostty/local

Set Different Fonts per Split

While Ghostty does not natively support per-split font configuration, you can use the font-size adjustment keybindings (Ctrl+Plus and Ctrl+Minus) to change the font size of individual splits. This is useful when you want a larger font in your main editing pane and a smaller font in your monitoring pane.

Clickable Paths and Line Numbers

Many CLI tools output file paths with line numbers (for example, grep -n, compiler errors, linter output). Ghostty can detect these patterns and make them clickable, opening the file in your editor at the correct line. Configure this with:

# Open file:line patterns in VS Code
# (requires OSC 8 hyperlink support in your tools)

Custom Tab Titles with Shell Integration

With shell integration enabled, Ghostty sets the tab title to your current working directory or the running command name. You can override this with standard terminal escape sequences in your shell prompt:

# In .zshrc or .bashrc
# Set tab title to current directory name
precmd() { echo -ne "\033]0;${PWD##*/}\007"; }

# In config.fish
function fish_title
    basename (pwd)
end

Performance: Disable Animations for Maximum Speed

If you want every last microsecond of rendering performance, disable visual animations:

# Disable window animations
window-vsync = false

Export Your Terminal as HTML

Ghostty supports capturing terminal output as HTML with full color preservation. This is useful for sharing command output in documentation, bug reports, or blog posts. Use the command palette or a keybinding to trigger HTML export of the current scrollback.

Frequently Asked Questions

Is Ghostty free and open source?

Yes. Ghostty is released under the MIT license. The source code is available on GitHub at ghostty-org/ghostty. There are no paid tiers, no premium features, and no telemetry. Mitchell Hashimoto has stated that Ghostty will remain free and open source.

Does Ghostty support Windows?

Not yet. Ghostty currently runs on macOS and Linux. Windows support is on the roadmap and is being actively developed. The Zig codebase is portable, and the rendering pipeline uses cross-platform GPU APIs, so Windows support is a matter of implementation effort rather than a fundamental limitation. In the meantime, Windows users can run Ghostty inside WSL2 with some caveats around GPU passthrough.

Can I use Ghostty with Neovim, tmux, and other TUI tools?

Yes. Ghostty’s focus on correct terminal emulation means it handles Neovim, tmux, zellij, Midnight Commander, lazygit, btop, and other TUI applications without rendering issues. True color (24-bit), styled underlines (curly, dotted, dashed), mouse reporting, and bracketed paste are all supported correctly.

How does Ghostty compare to the default macOS Terminal.app?

Terminal.app is functional but limited. It lacks GPU rendering, true color support is inconsistent, it does not support ligatures, and it has no split pane feature. Ghostty is faster, more correct, more configurable, and supports modern terminal features that Terminal.app does not. The only advantage Terminal.app has is that it is preinstalled and uses zero additional disk space.

Does Ghostty work on Wayland?

Yes. On Linux, Ghostty uses GTK4, which supports both Wayland and X11. When running under a Wayland compositor such as Niri or Hyprland, Ghostty runs natively in Wayland mode without XWayland. This provides sharper rendering on HiDPI displays and better input handling.

Is Ghostty stable enough for production use?

Yes, with a caveat. Ghostty is pre-1.0, which means the configuration format and feature set may change between releases. In practice, our team has used Ghostty daily for months without any crashes or data loss. The terminal itself is remarkably stable for a project that launched recently. Pin your version in your package manager to avoid unexpected changes during a release upgrade.

How do I migrate from kitty or Alacritty?

There is no automated config converter. Ghostty’s config format is simple enough that manual migration takes about 15 minutes. Map your font settings, color scheme, keybindings, and window behavior line by line. Most settings have direct equivalents. The biggest conceptual difference is that Ghostty uses a flat key-value format instead of kitty’s section-based format or Alacritty’s TOML. Start with a minimal config, verify it works, then add customizations incrementally.

Getting Started

Install Ghostty using the instructions for your platform above, set your preferred font and color scheme in the config file, and start using it. The defaults are good enough that many users never need to edit the config at all. When you are ready to customize, the examples in this guide cover the most useful settings.

If you are building developer workstations, managing IT infrastructure, or running AI workloads and want expert guidance on terminal tooling, Linux environments, or hardware configuration, contact our team at (919) 348-4912 for a consultation.

About the Author: Craig Petronella is the CEO of Petronella Technology Group, a cybersecurity and IT infrastructure firm in Raleigh, NC. With CMMC-RP, CCNA, CWNE, and DFE certifications and over 30 years in IT, Craig’s team evaluates and deploys developer tooling across Linux and macOS environments daily.