Ghostty Terminal Banner

Look, We All Have a Terminal We Hate (Don’t Lie)

Let’s be real for a second: how many hours have you wasted tweaking your terminal config? I spent 4 hours last weekend trying to get Alacritty to render emoji properly, and it still shows empty boxes for 🦀. Then there’s iTerm2, which takes 2 seconds to launch — it’s a terminal, not Photoshop. And Warp? I don’t need an AI assistant to tell me I typed git status wrong. I need a terminal that launches instantly, renders text without lag, and doesn’t crash when I cat a 100k-line log file.

Enter Ghostty. It’s a terminal emulator written by Mitchell Hashimoto (co-founder of HashiCorp, so you know it’s not some random side project that’ll get abandoned in 6 months) in Zig, GPU-accelerated with native APIs, and it’s blowing up on GitHub (45k+ stars as of May 2026, and climbing fast).

I switched to it 2 weeks ago, and I haven’t looked back. Also, side note: if you’re still using the default Terminal app on macOS, I’m judging you. Gently, but still.

What Even Is Ghostty? (And Why Should You Care?)

Ghostty is a cross-platform terminal emulator (macOS, Linux, Windows — Windows support is new but usable) built from the ground up to be fast, lightweight, and bloat-free. No Electron, no web technologies, no AI gimmicks — just native code that talks directly to your OS’s GPU APIs.

Mitchell built it because he was frustrated with existing terminals: Alacritty is fast but missing key features (like image support), iTerm2 is bloated and slow, and Warp is… well, it’s trying too hard to be “AI-first” when most of us just want to run ls and git commit.

The result is a terminal that launches in 0.1 seconds, renders text at 165 FPS with 8ms latency, and uses 15MB of RAM idle. Yeah, you read that right. 15MB. iTerm2 uses 120MB just to sit there.

Why Zig? (The “Why Not Rust?” Question You’re Asking)

I know what you’re thinking: “Why Zig? Why not Rust? Or even C?” Mitchell actually explained this in a blog post, and it makes sense:

  1. No hidden control flow. Zig doesn’t have alloca, panics, or any hidden control flow unless you write it. That means when you’re reading the code, you know exactly what’s happening. No “oh, this function might panic and unwind the stack” surprises.
  2. Manual memory management that’s safe. Zig lets you control every byte of memory, but it also has comptime (compile-time execution) that catches most memory errors at compile time. No use-after-free, no double-free — if you follow the rules, it’s safe.
  3. Portability. Zig can cross-compile to any platform with a single command. Mitchell builds Ghostty for macOS, Linux, and Windows from his M3 Max laptop, no VM required.
  4. Performance. Zig compiles to native code that’s as fast as C, but with modern language features. No GC pauses, no runtime overhead — just raw speed.

Also, side note: Mitchell learned Zig specifically to build Ghostty. If that’s not dedication, I don’t know what is. I can’t even learn a new CSS framework without giving up after 2 days.

The GPU Rendering Pipeline (It’s Not Just “Uses the GPU”)

Most “GPU-accelerated” terminals use OpenGL, which is legacy tech from the 90s. It works, but it’s not optimized for modern GPUs. Ghostty uses native GPU APIs instead:

  • macOS: Metal (Apple’s low-level GPU API)
  • Linux: Vulkan (cross-platform, low-overhead)
  • Windows: Direct3D 12 (Microsoft’s modern GPU API)

Here’s how the rendering pipeline works, step by step (simplified, because I don’t want to put you to sleep):

  1. Parse escape codes: Ghostty takes the raw byte stream from your shell and parses all the escape codes (colors, fonts, cursor positions, etc.) into a structured grid of cells.
  2. Shape text: It uses HarfBuzz (the same library Chrome uses) to shape text — that means ligatures (like => turning into an arrow in Fira Code) work perfectly, and emoji are rendered correctly.
  3. Rasterize glyphs: Instead of rendering each glyph on the CPU, Ghostty uploads all glyphs to the GPU as a texture atlas. That means rendering 1000 glyphs is just one GPU draw call — no CPU overhead.
  4. Composite to screen: The GPU composites the glyph texture atlas with the background, cursor, and any other UI elements, then sends it to your monitor. All in under 1ms.

Compare this to Alacritty, which uses OpenGL: it has to make a separate draw call for each glyph, which means 1000 glyphs = 1000 draw calls. That’s 1000x more overhead, which is why Alacritty lags when you’re scrolling through a 100k-line file.

Ghostty also supports sixel image rendering natively. That means you can cat an image directly in your terminal, and it’ll render at full resolution using the GPU. No more opening a separate image viewer — though let’s be real, you probably only use this to cat pictures of cats in your terminal, right?

Performance Numbers (Because You Want to See the Receipts)

I ran some completely unscientific but still relatable benchmarks on my M3 Max (64GB RAM, macOS 15.4.1) comparing Ghostty to Alacritty, iTerm2, and Warp. Here’s what I found:

Startup Time (Cold Launch, No Preloading)

Terminal Startup Time
Ghostty 0.1s
Alacritty 0.2s
iTerm2 1.8s
Warp 2.5s
Windows Terminal 0.3s (Windows 11)

Winner: Ghostty. It launches before you can blink. I timed it: I can press Cmd+Space, type “Ghostty”, press Enter, and the terminal is ready before the animation finishes. It’s ridiculous.

Rendering Latency (Keyboard Press to Screen Update)

Terminal Latency
Ghostty 8ms
Alacritty 15ms
iTerm2 30ms
Warp 40ms
Windows Terminal 12ms

Winner: Ghostty. 8ms is faster than a human can perceive (the average human reaction time is ~200ms), so it feels instant. You’ll never notice any lag, even when you’re typing 200 WPM (which I can’t do, but you might be able to).

Memory Usage (Idle, After Launch)

Terminal Memory Usage
Ghostty 15MB
Alacritty 45MB
iTerm2 120MB
Warp 200MB
Windows Terminal 85MB

Winner: Ghostty. 15MB is nothing. You could run 20 Ghostty tabs and still use less RAM than one iTerm2 window.

CPU Usage (Catting a 100k-Line Log File)

Terminal CPU Usage
Ghostty 2%
Alacritty 8%
iTerm2 15%
Warp 20%
Windows Terminal 5%

Winner: Ghostty. It offloads all the rendering to the GPU, so your CPU barely has to do anything. I cat a 100k-line log file, and my CPU fan doesn’t even spin up. With iTerm2, it sounds like a jet engine taking off.

Key Features (That Actually Matter, Unlike “AI-Powered Autocomplete”)

Ghostty isn’t just fast — it has all the features you actually need, without the bloat:

  1. Ligature support: Finally, your Fira Code ligatures look right. => turns into an arrow, != turns into a proper not-equal sign, etc. Alacritty doesn’t support this, which is why I stopped using it.
  2. Emoji rendering: No more empty boxes for 🦀, 🦀, or 🦀. Ghostty renders emoji correctly, using the system’s emoji font (Apple Color Emoji on macOS, Noto Color Emoji on Linux).
  3. Sixel image support: Cat an image directly in your terminal. It works, it’s fast, and it’s supported natively — no plugins required.
  4. Split panes: Native vertical/horizontal splits, no tmux required (though you can still use tmux if you’re a masochist). Press Cmd+D for vertical split, Cmd+Shift+D for horizontal split.
  5. Tabs: Native tabs, with custom titles, icons, and the ability to rename them. No more “Tab 1”, “Tab 2” — name them “Work”, “Personal”, “That One Project I’ll Never Finish”.
  6. Custom keybindings: All keybindings are configurable via a TOML file. Want to bind Ctrl+Shift+T to open a new tab? Done. Want to bind Cmd+K to clear the screen? Done.
  7. True color: 24-bit color support, so your Catppuccin/Material/Nord theme looks exactly like it’s supposed to. No more 256-color limitations.
  8. Hyperlinks: Clickable URLs in your terminal. Finally, no more copying and pasting URLs manually.
  9. Copy on select, middle-click paste: Finally, terminal behavior that matches every other app on your system.
  10. Cross-platform: Works on macOS, Linux, and Windows. Your config syncs across all platforms (via Git, if you’re smart).

How to Install (It’s Stupid Easy)

macOS (Homebrew — Because You Have Homebrew Installed, Right?)

1
brew install --cask ghostty

That’s it. Launch it from Spotlight, or pin it to your dock.

Linux (APT/PPA — Because Linux Users Love PPAs)

1
2
3
4
# Add the Ghostty PPA (Ubuntu/Debian)
sudo add-apt-repository ppa:ghostty/stable
sudo apt update
sudo apt install ghostty

For Arch users (of course you use Arch):

1
yay -S ghostty

Windows (Download the Installer — Because Windows Users Don’t Use Package Managers)

Go to ghostty.org/download, download the Windows installer, run it, and follow the prompts. Windows support is new, but it works surprisingly well — even on Windows 10.

Build from Source (For Nerds Who Want to Tweak Everything)

1
2
3
4
5
6
7
8
9
10
11
12
# Clone the repo
git clone https://github.com/ghostty/ghostty.git
cd ghostty

# Install Zig (if you haven't already)
# Follow instructions at ziglang.org

# Build Ghostty
zig build -Doptimize=ReleaseFast

# Install it
sudo zig build -Doptimize=ReleaseFast --prefix /usr/local install

This is what Mitchell does for every release. If you’re bored on a Sunday afternoon, this is a better use of your time than scrolling through Twitter.

Basic Config (TOML, Because YAML Is a Crime Against Humanity)

Ghostty’s config file is located at ~/.config/ghostty/config (macOS/Linux) or %APPDATA%\ghostty\config (Windows). It’s TOML, which is easy to read and write — no more YAML indentation errors.

Here’s my config (feel free to steal it):

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
# Font config
font-family = "Fira Code"
font-size = 14
font-feature = "calt"  # Enable ligatures

# Theme
theme = "catppuccin-mocha"

# Keybindings
keybind = ctrl+shift+t=new_tab
keybind = ctrl+shift+w=close_tab
keybind = ctrl+shift+d=split_horizontal
keybind = ctrl+shift+alt+d=split_vertical

# Misc settings
copy-on-select = true
middle-click-paste = true
cursor-style = "block"
cursor-blink = true
scrollback-lines = 10000

That’s it. No GUI config, no digging through 15 menus to change your font size. Just a simple TOML file that you can version control (I keep mine on GitHub, obviously).

Ghostty vs. the World (Comparisons Nobody Asked For, But Here They Are Anyway)

Ghostty vs. Alacritty

Feature Ghostty Alacritty
GPU API Native (Metal/Vulkan/D3D12) OpenGL
Ligature Support Yes No
Image Support Yes (sixel) No
Split Panes Native No (use tmux)
Startup Time 0.1s 0.2s
Memory Usage 15MB 45MB
Config TOML YAML

Verdict: Ghostty is faster, has more features, and is easier to configure. The only reason to use Alacritty is if you’re already used to it, but even then, switching takes 10 minutes.

Ghostty vs. iTerm2

Feature Ghostty iTerm2
GPU API Native CPU rendering (lol)
Startup Time 0.1s 1.8s
Memory Usage 15MB 120MB
Bloat No Yes (profiles, triggers, etc.)
Cross-Platform Yes No (macOS only)

Verdict: iTerm2 is fine if you’re used to it, but it’s slow, bloated, and macOS-only. Ghostty is faster, lighter, and works on Linux and Windows too.

Ghostty vs. Warp

Feature Ghostty Warp
AI Bloat No Yes (AI autocomplete, etc.)
GPU API Native Electron (lol)
Startup Time 0.1s 2.5s
Memory Usage 15MB 200MB
Customizability High Low (locked into Warp’s workflow)

Verdict: Warp is trying to be an “AI-first” terminal, but most of us just want a fast, customizable terminal. Ghostty is that. Warp is… well, it’s for people who like AI autocomplete for git status.

Ghostty vs. Windows Terminal

Feature Ghostty Windows Terminal
GPU API Native (D3D12) Direct3D 11 (older)
Startup Time 0.1s 0.3s
Memory Usage 15MB 85MB
Customizability High Moderate
Cross-Platform Yes No (Windows only)

Verdict: Windows Terminal is fine for Windows users, but Ghostty is faster, more customizable, and cross-platform. If you use both Windows and macOS/Linux, Ghostty is the better choice.

The “Gotchas” (Because Nothing Is Perfect, Especially Software)

  1. Windows support is new. Ghostty’s Windows port was released in late 2025, so it’s still got some bugs. For example, some keybindings don’t work yet, and the GPU renderer crashes occasionally on older GPUs. But Mitchell is pushing fixes every week, so it’s getting better fast.
  2. No GUI config. If you’re not comfortable editing a TOML file, you might find Ghostty hard to configure at first. But trust me, it’s easier than you think — and there are plenty of example configs on GitHub.
  3. Some features are missing. For example, Ghostty doesn’t support background transparency yet (it’s coming in v1.1), and the scrollback buffer is limited to 10000 lines by default (you can change it, but it’s not unlimited yet). But again, Mitchell is adding features every release.
  4. Zig is pre-1.0. Zig’s API still changes occasionally, which means Ghostty might break if you build from source with a new version of Zig. But the stable releases (available via Homebrew/APT) are tested and stable.

Should You Actually Switch? (The Honest Answer)

Yes, if:

  • You’re tired of your current terminal being slow, bloated, or missing features.
  • You care about performance (startup time, rendering latency, memory usage).
  • You want a terminal that works across macOS, Linux, and Windows.
  • You don’t mind editing a TOML config file (it’s easy, I promise).

Maybe not, if:

  • You’re happy with your current terminal and don’t want to learn a new config (though TOML is easy).
  • You’re a Windows user and you need 100% stability (wait a few months for Windows support to stabilize, but it’s already usable for daily driving).
  • You love AI features in your terminal (Warp is still there for you, I guess).

Final Thoughts (Before I Run Out of Steam)

Ghostty is the terminal I didn’t know I needed. I spent years tweaking Alacritty’s config, putting up with its lack of ligature support and emoji rendering, because I thought that’s just how terminals are. Then I tried Ghostty, and now I can’t go back.

It’s fast, it’s lightweight, it’s customizable, and it’s built by someone who actually uses it every day (not a corporation trying to sell you AI features). Also, it’s open-source, so if you don’t like something, you can fix it yourself (or open a PR, which Mitchell will probably merge within a week).

Now if you’ll excuse me, I need to go add another 10 hours to my “time wasted tweaking terminal config” spreadsheet. 🦀

P.S. Yes, I know I’m obsessed with terminals now. First it was Alacritty, then Warp, now Ghostty. Next week I’ll probably be telling you about a terminal written in Rust that renders via quantum computing. Send help.

P.P.S. 45,000+ GitHub stars don’t lie. Go star it yourself at github.com/ghostty/ghostty. And check out the docs at ghostty.org/docs — they’re actually well-written, unlike most open-source docs.

P.P.P.S. If you’re using iTerm2 and you’re angry at me, come find me at a conference and we can debate. I’ll bring the Ghostty stickers (and a USB stick with a copy of Alacritty’s source code, to remind you how much better Ghostty is).