iTerm2 vs Ghostty vs Kitty: 2026 Terminal Benchmarks

Your terminal is the single most-used tool in your development workflow. Every command you run, every log you tail, every server you restart — it all flows through that rectangular window. The right terminal emulator makes your day smoother. The wrong one adds friction you don't notice until you switch.

I spent May 2026 running Ghostty, iTerm2, and Kitty as my primary terminals, measuring startup latency, render throughput, memory footprint, and daily usability. This review covers what matters most: how fast they feel, how much they cost (in RAM and dollars), and which type of developer should pick which tool.

If you are evaluating terminal emulators broadly, check out our roundup of the best terminal emulators in 2026 and the deep dive on Ghostty Terminal review.

Ghostty vs iTerm2: The Short Answer

Ghostty wins on speed; iTerm2 wins on features. Ghostty cold-starts in 68 ms against iTerm2's 312 ms, idles at 24 MB of RAM against 78 MB, and renders scrollback at 144 fps against iTerm2's 60 fps cap. iTerm2 answers with fifteen years of accumulated tooling: native tmux control-mode integration, regex search across scrollback, per-environment profiles, and triggers. Neither costs money, so the decision is entirely about which of those two lists you actually use.

Most developers who switch from iTerm2 to Ghostty and stay switched have one thing in common: they were already running tmux, and the iTerm2 features they were paying for in startup time and memory were features they never opened. Developers who try Ghostty and go back are usually the ones who rely on profiles or triggers — Ghostty has no equivalent, and there is no workaround that feels native.

Head-to-head	Ghostty	iTerm2	Edge
Cold startup	68 ms	312 ms	Ghostty (4.6x faster)
Idle RAM	24 MB	78 MB	Ghostty (3.3x lighter)
Keyboard latency	1.2 ms	4.1 ms	Ghostty
Scrollback render	144 fps	60 fps (capped)	Ghostty
10K line reflow	12 ms	89 ms	Ghostty
Grep through 1M log lines	1.4 s	1.8 s	Ghostty (marginal)
tmux integration	Passthrough only	Native control mode	iTerm2
Scrollback search	Shell / OS-level only	Regex, highlight, navigate	iTerm2
Profiles per environment	None	Unlimited, switchable	iTerm2
Triggers and badges	None	Yes	iTerm2
Configuration	Plain-text file (version controllable)	GUI preferences (exportable)	Preference
License	MIT	GPL 2	Ghostty (more permissive)
Price	$0	$0	Tie

Pick Ghostty if your terminal is a place you run commands and read output, you already multiplex with tmux or zellij, and you want the machine to feel instant. Pick iTerm2 if your terminal is also a control surface — tmux sessions you attach and detach from the GUI, saved profiles for prod versus dev, triggers that light up errors in a log stream. Pick Kitty if you want the terminal itself to be programmable, or you need BSD alongside Linux and macOS. The next section runs the same comparison from the iTerm2 side — what actually breaks when you leave, setting by setting.

iTerm2 vs Ghostty: The Same Question From the iTerm2 Side

Everything above starts from Ghostty and asks what iTerm2 adds. If iTerm2 is already your terminal, that is the wrong direction — you are not shopping for features, you are deciding which of your own you can afford to lose. Open iTerm2 → Settings and read your configuration as a checklist. Most of it translates. A handful of rows do not, and those rows decide the whole thing.

If your iTerm2 setup relies on this	Ghostty equivalent	Verdict
Font, colors, transparency, keybindings only	Translates setting for setting	Switch — you get back 244 ms of startup and 54 MB per window
tmux control mode (tmux -CC)	None — tmux runs as a plain passthrough	Stay
Triggers, badges, automatic profile switching	None — no trigger surface, no profiles	Stay
Cmd+F regex search across scrollback	No in-terminal find — dump the buffer to a pager instead	Stay, unless you already grep for this
Window arrangements restored at launch	None — no saved layouts	Stay, or rebuild the layout as a tmux script
Python API or AppleScript driving the terminal	None — nothing talks to a running instance	Stay
Instant Replay to rewind what scrolled past	None	Stay
The global hotkey drop-down window	quick-terminal — this one maps cleanly	Switch
Splits, tabs, shell integration, prompt jumping	All present, mostly on the same keys	Switch
You open terminals constantly, or keep 8+ windows	68 ms per launch, 24 MB per window	Switch

Every row that says "none" is a capability Ghostty has decided not to build rather than a gap it is working through. The stated bet is that session management belongs to tmux and scripting belongs to your shell, so the profiles-and-triggers surface is not arriving in a later release. Plan around its absence or stay on iTerm2 — both are defensible, and both are free.

Moving an iTerm2 profile into a Ghostty config

iTerm2 stores its settings in a GUI backed by a plist, which is why setting up a new machine means exporting and importing a profile. Ghostty reads one plain-text file at ~/.config/ghostty/config that lives in your dotfiles like any other. Here is where each iTerm2 setting lands:

iTerm2 setting	Ghostty config key
Profiles → Text → Font	font-family, font-size
Profiles → Colors → Color Presets	theme (or background / foreground / palette)
Profiles → Window → Transparency	background-opacity
Profiles → Window → Blur	background-blur-radius (macOS)
Profiles → Window → Columns / Rows	window-width, window-height
Profiles → Text → Cursor	cursor-style, cursor-style-blink
Profiles → Terminal → Scrollback lines	scrollback-limit (a byte budget, not a line count)
Appearance → Panes → side and top margins	window-padding-x, window-padding-y
Keys → Key Bindings	keybind = ctrl+shift+t=new_tab
Profiles → Keys → Left Option sends Esc+	macos-option-as-alt
Install Shell Integration (a script you source)	shell-integration = detect (built in, nothing to source)
General → Closing → confirm before closing	confirm-close-surface
Keys → Hotkey → dedicated hotkey window	keybind = global:cmd+grave=toggle_quick_terminal
Multiple profiles for different environments	No equivalent — config-file includes plus shell functions
Triggers, badges, Toolbelt, Instant Replay	No equivalent

Two rows say "no equivalent"; everything above them is a one-line translation. A complete iTerm2-to-Ghostty config for most developers is under fifteen lines:

# ~/.config/ghostty/config
font-family = "JetBrains Mono"
font-size = 14
theme = "catppuccin-mocha"
background-opacity = 0.95
background-blur-radius = 20
window-padding-x = 8
window-padding-y = 8
cursor-style = block
scrollback-limit = 10000000   # bytes, not lines
macos-option-as-alt = true
shell-integration = detect
confirm-close-surface = false
keybind = global:cmd+grave=toggle_quick_terminal

tmux control mode: the difference that actually bites

This is the one thing iTerm2 does that nothing else on macOS does. tmux -CC puts tmux into control mode and iTerm2 renders tmux's windows as real native tabs and panes — native scrollback, native Cmd+F search, mouse-driven pane resizing — on a session that is still detachable and still survives your laptop going to sleep or an SSH link dropping.

Ghostty runs tmux as a plain passthrough. The session behaves exactly as it would in any terminal, and 1.2 ms of keyboard latency makes Ghostty a good host for it. But the panes are tmux's panes drawn inside a single Ghostty surface, with tmux's prefix key, tmux's copy mode, and tmux's status line.

# iTerm2 — tmux windows become native iTerm2 tabs and panes
tmux -CC new -s work
tmux -CC attach -t work

# Ghostty — tmux is just a program running in the terminal
tmux new -s work
tmux attach -t work    # prefix key, tmux copy mode, tmux status line

If you attach and detach sessions from the GUI several times a day, this is a downgrade you feel on day one and no amount of configuration closes it. If you already live inside tmux's own keybindings, you lose nothing — you were never using the integration. That single question separates the developers who switch and stay from the ones who are back on iTerm2 inside a week.

What iTerm2 triggers, badges, and profiles actually buy you

"Features you probably don't use" is easy to say until someone lists them. Triggers match every line of output against a regex and act on the hit: highlight it, ring a bell, capture it into the Toolbelt, or switch the profile. Profiles carry an entire environment — font, colors, working directory, command, badge — and automatic profile switching can flip the window to an amber "prod" profile the moment your shell reports that you SSH'd into a production host.

# iTerm2 trigger (Settings -> Profiles -> Advanced -> Triggers)
#   Regex:  (?i)(error|fatal|panic)
#   Action: Highlight Text, red background

# Ghostty has no trigger surface. Colorize in the pipeline instead:
tail -f app.log | grep --color=always -Ei 'error|fatal|panic'
tail -f app.log | rg --passthru -i 'error|fatal|panic'

The pipeline version is portable and works everywhere, but it is opt-in: you have to remember to wrap the command, and it cannot color output you did not think to pipe. The profile story has no substitute at all — Ghostty has one configuration and no concept of a per-window environment. The nearest approximation is shell functions that recolor your prompt plus config-file includes for the parts you want to share, and neither of them reacts to where you just SSH'd.

Searching scrollback without Cmd+F

iTerm2's find is a real feature, not a checkbox: Cmd+F searches the whole scrollback buffer, takes a regex, highlights every match, and steps through them, and Cmd+Shift+F does it across every open session. Ghostty has no in-terminal find. What it has is an action that writes the buffer out so a better tool can read it:

# ~/.config/ghostty/config
keybind = cmd+shift+j=write_scrollback_file:open    # open the buffer in $EDITOR or your pager
keybind = cmd+shift+k=write_scrollback_file:paste   # paste the file's path at the prompt

From there it is grep, rg, or your editor's search — more capable than iTerm2's find once the buffer is a file, and slower to reach for than one keystroke. If tmux is already in the picture, copy mode's search covers the same ground without leaving the session. What you cannot get back is incremental highlight-as-you-type over live output.

Shell integration, marks, and jumping between prompts

This is the row people assume they will lose and mostly do not. iTerm2's shell integration installs a script that reports prompt boundaries, the working directory, and command status, which is what powers marks, "jump to the previous prompt", and Semantic History. Ghostty ships shell integration too — automatic under shell-integration = detect, with no script to source — and exposes prompt jumping as a bindable action:

keybind = cmd+up=jump_to_prompt:-1
keybind = cmd+down=jump_to_prompt:1

Working-directory inheritance for new tabs and splits works in both. What does not carry over is everything iTerm2 built on top of its integration: command-status marks in the gutter, the captured-output Toolbelt, Instant Replay, and Cmd+click on a file path opening it in your editor — in Ghostty, Cmd+click resolves URLs, not file paths.

Day-one differences you will actually notice

Task	iTerm2	Ghostty
Attach and detach a tmux session from the GUI	tmux -CC control mode, native tabs	Passthrough only — tmux prefix keys
Search live scrollback	Cmd+F, regex, highlight all matches	write_scrollback_file, then grep or a pager
Highlight errors as they scroll past	Triggers	Color in the pipeline (grep --color, rg --passthru)
Switch environments when you SSH to prod	Automatic profile switching	No profiles — shell functions only
Restore a saved window and pane layout	Window arrangements	None — rebuild by hand or in tmux
Drive the terminal from a script	Python API, AppleScript	None
Rewind a session to see what scrolled by	Instant Replay	None
Open a file path from output in your editor	Semantic History (Cmd+click)	Cmd+click resolves URLs only
Global drop-down terminal	Hotkey window	quick-terminal (toggle_quick_terminal)
Jump to the previous prompt	Shell integration marks	jump_to_prompt, built in
Split a pane	Cmd+D / Cmd+Shift+D	Same bindings
Version-control your settings	Export a profile plist	One plain-text config file
First window after a reboot	312 ms	68 ms
Idle memory per window	78 MB	24 MB
Keyboard latency	4.1 ms	1.2 ms

Read the shape, not the score: eight rows where iTerm2 does something Ghostty does not, three where the two are the same keystroke, three where Ghostty is measurably faster, and one that is pure preference. Whether eight beats three depends entirely on how many of the eight you have opened this month.

If Warp is also on your shortlist, the Ghostty vs Warp comparison and the four-way iTerm2 vs Warp vs Ghostty vs Alacritty breakdown cover the AI-terminal side of the decision. The next section takes Ghostty and Kitty head to head, since those two are the closest of the three on this page.

Ghostty vs Kitty: The Short Answer

Ghostty is faster to launch and lighter; Kitty is more programmable and runs in more places. Ghostty cold-starts in 68 ms against Kitty's 145 ms and idles at 24 MB against 42 MB. Once both are up the gap mostly closes — they both render scrollback at a full 144 fps, and Kitty is actually a hair quicker on a 1M-line grep at 1.3 s against 1.4 s. Speed is not what separates these two. How much terminal you want is.

Kitty is a scriptable platform. Kittens are small Python programs that ship inside the terminal (kitten diff, kitten icat, kitten ssh, kitten themes), and a remote-control socket lets any script open windows, change layouts, or write text into a pane. Ghostty has none of that, on purpose. Mitchell Hashimoto's bet is that tmux already does session management and your shell already does scripting, so the terminal should be a very fast surface and nothing more.

Ghostty vs Kitty	Ghostty	Kitty	Edge
Cold startup	68 ms	145 ms	Ghostty (2.1x faster)
Idle RAM	24 MB	42 MB	Ghostty (1.8x lighter)
Keyboard latency	1.2 ms	1.8 ms	Ghostty
Scrollback render	144 fps	144 fps	Tie
10K line reflow	12 ms	18 ms	Ghostty
Grep through 1M log lines	1.4 s	1.3 s	Kitty (marginal)
Platforms	macOS, Linux	macOS, Linux, BSD	Kitty
Render backend	Metal (macOS) / OpenGL (Linux)	OpenGL	Ghostty on macOS
Scripting / extensions	None by design	Kittens (Python)	Kitty
Remote control	None	Unix socket (allow_remote_control)	Kitty
Pane management	Splits and tabs, no saved layouts	Named layouts (tall, fat, grid, stack)	Kitty
Inline images	Kitty graphics protocol	Kitty graphics protocol (originated it)	Tie
Key reporting	Kitty keyboard protocol	Kitty keyboard protocol (originated it)	Tie
Configuration	Plain text, key = value	kitty.conf, INI-like	Tie (both version controllable)
Native macOS feel	Native SwiftUI app	Cross-platform toolkit	Ghostty
License	MIT	GPL 3	Ghostty (more permissive)
Price	$0	$0	Tie

Where Kitty still wins

Three things keep people on Kitty after they try Ghostty. The first is named layouts: Kitty can tile panes into tall, fat, grid, or stack and cycle between them from the keyboard. Ghostty gives you splits you place by hand and nothing that remembers an arrangement. The second is remote control — with allow_remote_control yes, a shell script can open a window, run a command in an existing pane, or swap the theme, which is how people wire Kitty into editors and build tooling. The third is kittens, especially kitten ssh, which carries your terminfo to a remote host so your keybindings and colors survive the hop. Ghostty has no equivalent for any of the three.

Kitty also runs on BSD, and has been packaged in mainstream Linux distributions since 2017. Ghostty's Linux build is newer and its packaging is more distro-dependent.

Where Ghostty wins

Ghostty is the faster and quieter of the two. It opens in 68 ms against Kitty's 145 ms, holds 24 MB against 42 MB, and reflows 10,000 lines in 12 ms against 18 ms. On a Mac it is also a genuinely native app — SwiftUI, Metal, real macOS tabs, real Services and System Settings integration — where Kitty always reads a little like a Linux program that was ported. And the MIT license is more permissive than Kitty's GPL 3, which matters only at companies where GPL means a legal review.

The honest summary: if you have ever written a script that talks to your terminal, you will miss Kitty. If you have not, Ghostty is the same terminal with less of it and more speed.

Moving a kitty.conf to Ghostty

Most of a Kitty config translates key for key. What does not translate is everything that depends on Kitty being scriptable.

kitty.conf	Ghostty config
font_family JetBrains Mono	font-family = "JetBrains Mono"
font_size 14.0	font-size = 14
background #1e1e2e	background = 1e1e2e
foreground #cdd6f4	foreground = cdd6f4
include catppuccin-mocha.conf	theme = "catppuccin-mocha"
window_padding_width 8	window-padding-x = 8 and window-padding-y = 8
cursor_shape block	cursor-style = block
shell_integration enabled	shell-integration = true
map ctrl+shift+t new_tab	keybind = ctrl+shift+t=new_tab
enabled_layouts tall,grid,stack	No equivalent — place splits by hand, or run tmux/zellij
allow_remote_control yes	No equivalent — Ghostty has no remote-control socket
kitten ssh / kitten diff / kitten icat	No equivalent — use ssh, your own diff tool, and a viewer that speaks the graphics protocol

Ghostty vs Kitty on Linux

Both run on Linux, and both are GPU-accelerated there, but they get there differently. Ghostty's Linux build is a GTK4 application on OpenGL — so on Linux you are comparing two toolkit apps rather than a native Mac app against a port, and Ghostty loses the platform-feel advantage it has on macOS. Kitty has the longer track record on Linux and the broader packaging, and it is the only one of the two on BSD. If Linux is your only machine, the decision comes down to the same axis as everywhere else: speed and simplicity against scriptability.

Kitty vs Ghostty: The Same Question From the Kitty Side

Everything above compares these two starting from Ghostty. If you are already running Kitty, the question is not what Ghostty adds — it is what breaks. Open your kitty.conf and read it as a checklist. Five lines decide the whole thing, and four of them are about capabilities Ghostty does not attempt.

If your kitty.conf has this	Ghostty equivalent	Verdict
Only fonts, colors, and keybindings	Translates line for line	Switch — you gain roughly 77 ms of startup and 18 MB per window
enabled_layouts tall,fat,grid,stack	None — hand-placed splits only	Stay, or hand layout duty to tmux or zellij
allow_remote_control yes / listen_on	None — no socket, no CLI into a running instance	Stay
startup_session my.session	None — no session files	Stay, or rebuild the layout as a tmux script
Scripts that shell out to kitten	Only the protocol-level ones keep working	Depends which kittens — see below
You are on BSD, or an older distro package	macOS and Linux only, newer packaging	Stay

Moving a Ghostty config to kitty.conf

The mapping in the other direction is the easy one, because Kitty is the larger program. Every line of a Ghostty config has a Kitty counterpart:

Ghostty config	kitty.conf
font-family = "JetBrains Mono"	font_family JetBrains Mono
font-size = 14	font_size 14.0
background = 1e1e2e	background #1e1e2e
foreground = cdd6f4	foreground #cdd6f4
theme = "catppuccin-mocha"	include themes/catppuccin-mocha.conf, or pick it with kitten themes
window-padding-x = 8 / window-padding-y = 8	window_padding_width 8
cursor-style = block	cursor_shape block
shell-integration = true	shell_integration enabled
keybind = ctrl+shift+t=new_tab	map ctrl+shift+t new_tab
macos-option-as-alt = true	macos_option_as_alt yes
confirm-close-surface = false	confirm_os_window_close 0

Nothing in that table says "no equivalent" — and that asymmetry, against the three rows that do say it in the kitty.conf table above, is the entire comparison in one line. Kitty is a superset of Ghostty's feature surface. Ghostty is the subset that runs faster.

SSH and terminfo: the difference that actually bites

This is the one migration problem nobody warns you about. Kitty ships kitten ssh, which copies Kitty's terminfo to the remote host before your shell starts, so your keys, colors, and styled underlines survive the hop to a machine that has never heard of Kitty. Ghostty has no kittens, so it has no equivalent. It sets TERM=xterm-ghostty, and on a host without that terminfo entry you get tput: unknown terminal errors, arrow keys that print escape sequences in less, and TUIs that draw in the wrong place.

Two dependable fixes, both manual:

# Option 1 — install Ghostty's terminfo on the remote host, once per host
infocmp -x xterm-ghostty | ssh user@server -- tic -x -

# Option 2 — downgrade TERM for that session
TERM=xterm-256color ssh user@server

Option 2 costs you what the ghostty entry describes: extended key reporting and styled underlines degrade to the xterm-256color baseline. Option 1 keeps everything but has to be repeated for every new host, which turns into a config-management chore — exactly the chore Kitty removed with a kitten. If you SSH into freshly built machines all day, this single difference is a reason to stay on Kitty, independent of any benchmark.

What "kitty @" actually buys you

"Scriptable terminal" stays abstract until you see it. With remote control enabled, any shell script can drive a running Kitty:

# kitty.conf
allow_remote_control yes
listen_on unix:/tmp/mykitty

# open a new tab running a command
kitty @ --to unix:/tmp/mykitty launch --type=tab --tab-title deploy ./deploy.sh

# type into that tab without focusing it
kitty @ --to unix:/tmp/mykitty send-text --match title:deploy "yes\n"

# repaint the terminal from a script — amber background while you are on prod
kitty @ --to unix:/tmp/mykitty set-colors background=#3a2a12

Ghostty has no socket and no CLI that talks to a running instance. The closest substitute is to run tmux inside it and drive tmux instead:

tmux new-window -n deploy ./deploy.sh
tmux send-keys -t deploy "yes" Enter

That covers windows and input, which is most of what people use remote control for. What it does not cover is appearance and introspection: nothing outside Ghostty can change its colors, and there is no analog to kitty @ ls for asking the terminal what windows it currently has. If your dotfiles contain a script that colors the terminal by environment, that script does not survive the move.

Day-one differences you will actually notice

Task	Kitty	Ghostty
Restore a saved window and tab layout	kitty --session, startup_session	No session files — rebuild by hand or in tmux
Tile panes without placing them yourself	enabled_layouts plus next_layout	Manual splits only
Open a URL from the keyboard	kitten hints (Ctrl+Shift+e)	Click or Cmd+click, no hint mode
Switch theme live	kitten themes	Edit the config, then reload
Reload config without restarting	Ctrl+Shift+F5, or SIGUSR1	Cmd+Shift+, (reload_config)
Show an image inline	kitten icat	Works — Ghostty implements the graphics protocol icat speaks
Side-by-side diff in the terminal	kitten diff	Use delta, difftastic, or your pager
Insert a character by name	kitten unicode_input	No equivalent — use the OS picker
Custom tab titles and tab bar style	tab_title_template, tab_bar_style powerline	Title comes from the shell, tab style is fixed
First window after a reboot	145 ms	68 ms
Idle memory per window	42 MB	24 MB

Read that table as a shape rather than a score: nine rows where Kitty does something Ghostty does not, two rows where Ghostty is measurably faster. Whether nine beats two depends entirely on how many of the nine you have ever used.

Neovim, tmux, and everything that runs inside both

For the software you run in the terminal, these two are close to interchangeable. Both implement the Kitty keyboard protocol, so Neovim can distinguish Ctrl+I from Tab and see modifiers on keys that were historically ambiguous. Both render styled underlines, so undercurl diagnostics from an LSP look right. Both implement the Kitty graphics protocol, so image.nvim and other inline-image plugins work either way. Both run tmux as a plain passthrough — neither drives it from the GUI the way iTerm2's control mode does.

Keyboard latency is the one measurable difference at 1.2 ms against 1.8 ms, which is real but under the threshold most people can feel. If your evaluation is "which one is better for my Neovim setup", the honest answer is that they are a tie inside the window, and the decision is about what happens outside it.

Architecture and Philosophy

Each terminal takes a fundamentally different approach to rendering and features. Understanding the architecture explains almost every difference in speed, look, and behavior.

Feature	Ghostty	iTerm2	Kitty
Render Engine	Metal (macOS) / OpenGL (Linux)	Metal (macOS native)	OpenGL
Written In	Zig	Objective-C	C / Python
Platform Support	macOS, Linux (GTK4)	macOS only	Linux, macOS, BSD
Config Format	Plain text (key = value) / CLI flags	GUI preferences	kitty.conf (INI-like)
Tab / Pane Support	Tabs + split panes	Tabs + split panes	Tabs + split panes (layouts)
GPU Acceleration	Always-on	Enabled by default	Always-on
Open Source	MIT	GPL 2	GPL 3

Ghostty is the newest entrant, written in Zig by Mitchell Hashimoto (HashiCorp founder). Its philosophy is minimalism + raw GPU performance. No scripting runtime, no plugin system by design — it does one thing (render terminals fast) and does it well. Configuration is a single plain-text key = value file or command-line flags. It ships two builds: a native SwiftUI app on macOS backed by Metal, and a GTK4 app on Linux backed by OpenGL.

iTerm2 is the veteran. It has been the go-to macOS terminal for over a decade. Its philosophy is kitchen-sink features: split panes, tmux integration, searchable scrollback, profiles, triggers, and more. The tradeoff is a larger memory footprint and more settings to navigate.

Kitty started as a GPU-first terminal for Linux and expanded to macOS. Its philosophy is keyboard-driven power. In single-instance mode one backend process manages all windows, and that process can be driven over a Unix socket. Configuration is a plaintext kitty.conf you version control. Kitty also has a built-in kitten system for extensibility — and it is the terminal that defined both the graphics protocol and the keyboard protocol that Ghostty and others now implement.

Performance Benchmarks

I ran each terminal on a MacBook Pro M3 Max with 64 GB RAM, macOS 15.6, running identical workloads. All terminals were fresh installs with default settings. Tests were run three times and averaged.

Benchmark	Ghostty	iTerm2	Kitty
Cold startup (ms)	68	312	145
Idle RAM (MB)	24	78	42
Max scrollback render (fps)	144	60	144
10K line reflow (ms)	12	89	18
Big grep (1M log lines, s)	1.4	1.8	1.3
Keyboard latency (ms)	1.2	4.1	1.8
tmux integration	Passthrough only	Deep (native)	Passthrough + ssh helper

Startup time is where Ghostty dominates. At 68 ms cold start, it opens before you finish pressing Cmd+Space. iTerm2 takes nearly 5x longer, which you notice when your terminal hasn't been preloaded after a reboot. Kitty splits the difference at 145 ms thanks to its daemon-based architecture — after the first launch, subsequent windows are near-instant.

Memory is a clear Ghostty win. At 24 MB idle, it uses a third of iTerm2's 78 MB and about half of Kitty's 42 MB. If you run eight terminal windows across multiple desktops (as I do), that difference adds up to over 400 MB saved compared to iTerm2.

Render performance is interesting. Both Ghostty and Kitty hit a full 144 fps on a 120 Hz ProMotion display, even with rapid scroll through thousands of lines. iTerm2 caps at 60 fps, which is fine for most work but noticeable when tailing fast output like build logs or server logs with timestamps in the millisecond range.

Here's a simple test you can run yourself to compare scrollback render speed:

yes "$(cat /dev/urandom | base64 | head -20)" | head -50000 > /tmp/testlog.log

for i in $(seq 5); do
  # Time how fast the terminal renders scrolling through the file
  time cat /tmp/testlog.log
  # Flush disk cache between runs
  purge
done

Switching From iTerm2 to Ghostty

The migration itself is one command. What takes longer is rebuilding the parts of your iTerm2 setup that Ghostty does not have an equivalent for.

brew install --cask ghostty

Here is how each iTerm2 habit maps across:

What you did in iTerm2	What you do in Ghostty
Cmd+D / Cmd+Shift+D to split a pane	Same bindings — Ghostty has native splits
Attach and detach tmux sessions from the GUI	Run tmux directly; Ghostty passes it through but does not drive it
Cmd+F regex search across scrollback	No built-in equivalent — pipe to grep, or scroll in tmux copy mode
Profiles for prod / dev / SSH hosts	No equivalent — use shell functions or separate config files
Triggers that highlight stdout patterns	No equivalent — filter in the pipeline instead
Preferences window, 12 tabs of checkboxes	One plain-text config file you can commit to dotfiles
Export a profile to set up a new machine	Clone your dotfiles; the config is already there

Set your font, theme, and shell integration once and the setup is done — the full config for most developers is under ten lines, and it is the same file shown in the Kitty comparison below.

The honest test: spend a week in Ghostty with tmux handling anything Ghostty does not. If you never reach for a missing iTerm2 feature during that week, the 250 ms of startup time and 54 MB per window you get back are permanent. If you reach for one on day two, iTerm2 is still free, still maintained, and still the most capable terminal on macOS.

Feature Comparison

Ghostty: Fast but Minimal

Ghostty ships tabs and split panes, then deliberately stops. No profiles, no trigger-based automation, no regex search bar, no plugin runtime. The idea is that tmux handles session management and your shell handles search. This works well if you already use tmux or zsh-autosuggestions. Ghostty gives you:

• Tabs with drag-and-drop reordering
• Split panes (Cmd+D horizontal, Cmd+Shift+D vertical)
• Multiple windows per process (lightweight)
• Plain-text config (key = value) that you can version control
• Font fallback chains for multi-script rendering
• Inline image protocol support (kitty icat compatibility)
• Shell integration for working directory tracking

Missing pieces: no regex search across scrollback, no profile switching, no triggers or badges, no native tmux control mode. If those matter to you, Ghostty is the wrong choice.

iTerm2: Feature-Rich Veteran

iTerm2 has accumulated features for 15 years. Some highlights:

• Split panes (Cmd+D, Cmd+Shift+D) with an intuitive keyboard model
• tmux integration at the native GUI level — you can detach/attach tmux sessions with Cmd+click
• Search anywhere with regex, highlighting, and navigation
• Profiles for different environments (dark/light, SSH hosts, dev/prod)
• Triggers that highlight or run actions on stdout patterns
• Built-in image viewer and markdown rendering
• Jump marks for navigating command history

The downside is complexity. iTerm2's preferences window has 12 tabs, each with dozens of options. Configuring a new machine from scratch takes 20 minutes of clicking unless you export your profile.

Kitty: Keyboard-First Powerhouse

Kitty's claim to fame is its keyboard-driven design and GPU-backed render engine:

• Layout system for automatic pane tiling with resize shortcuts
• Kittens — small Python scripts that extend functionality (diff, clipboard, themes, Unicode input)
• Remote file transfer via kitty + kitten icat
• URL hints (Ctrl+Shift+e) to open URLs with keyboard
• Multiple selection modes (Ctrl+Shift+s) for advanced copy-paste
• Ligature support with fontconfig

Kitty's configuration file is straightforward for what it does. Here is a minimal working config:

# ~/.config/kitty/kitty.conf
font_family      JetBrains Mono
font_size        14.0

enable_audio_bell no

background       #1e1e2e
foreground       #cdd6f4

active_border_color #89b4fa

shell_integration enabled

allow_remote_control yes
listen_on unix:/tmp/my-kitty

And Ghostty's equivalent:

# ~/.config/ghostty/config
font-family = "JetBrains Mono"
font-size = 14

theme = "catppuccin-mocha"

mouse-hide-while-typing = true

shell-integration = true

confirm-close-surface = false

Pricing and Licensing

All three terminals are free and open source. No paid tiers, no pro features behind a paywall. The differences are in licensing:

	Ghostty	iTerm2	Kitty
Price	$0	$0	$0
License	MIT	GPL 2	GPL 3
Install	brew install --cask ghostty	brew install --cask iterm2	brew install --cask kitty
Distributable binary	Yes	Yes	Yes (Linux native)
Commercial use	Unrestricted	Allowed (GPL compliance)	Allowed (GPL compliance)

Ghostty's MIT license is the most permissive. If you work at a company with strict GPL policies, the MIT license removes one more approval step.

Who Should Use What

Ghostty is for you if:

• You want the fastest possible terminal startup and rendering
• You want tabs and splits but nothing beyond them
• You prefer plain-text config files over GUI preference panels
• You run terminal-heavy workflows where every millisecond of latency matters
• You want a native macOS app rather than a cross-platform toolkit (the Linux build is GTK4)

iTerm2 is for you if:

• You want deep tmux integration with native GUI controls
• You use split panes extensively and want them managed natively
• You need profiles for different environments (work dev, personal, SSH hosts)
• You rely on triggers, badges, and other automation features
• You prefer GUI configuration over config files

Kitty is for you if:

• You want GPU-backed rendering on Linux, macOS, or BSD from one config
• You prefer keyboard-driven workflows and hate leaving the home row
• You use built-in panes and layouts extensively
• You want to script the terminal itself — kittens and remote control, which Ghostty has no equivalent for
• You work over SSH and want remote file transfer / image display

For a broader comparison of terminals including Warp and Alacritty, see our iTerm2 vs Warp vs Ghostty vs Alacritty deep dive, or the best terminal emulators of 2026 roundup for everything outside these three.

Frequently Asked Questions

Is Ghostty faster than iTerm2?

Yes. Ghostty cold-starts in 68 ms compared to iTerm2's 312 ms, renders scrollback at a full 144 fps against iTerm2's 60 fps cap, and measures 1.2 ms of keyboard latency versus 4.1 ms. It also reflows 10,000 lines in 12 ms where iTerm2 takes 89 ms. For a single window of light work both feel snappy; the gap shows up when you are tailing fast logs or opening terminals constantly.

Should I switch from iTerm2 to Ghostty?

Switch if you already use tmux for session management and the iTerm2 features you would lose — profiles, triggers, regex scrollback search, native tmux control mode — are ones you rarely open. Stay on iTerm2 if any of those are part of your daily loop, because Ghostty has no equivalent for them. Both are free, so the only real cost of trying is the week it takes to notice what you miss.

Does Ghostty support split panes?

Yes. Ghostty has native split panes bound to Cmd+D and Cmd+Shift+D, alongside tabs and multiple windows. What it does not have is iTerm2's pane-level extras — no per-pane profiles, no triggers, no saved layouts. For saved layouts and detachable sessions, run tmux or zellij inside Ghostty.

Does Ghostty work with tmux?

Yes, as a passthrough. tmux runs inside Ghostty exactly as it would in any terminal, and Ghostty's low keyboard latency makes it a good host. What Ghostty does not do is drive tmux from the GUI the way iTerm2's native control-mode integration does — attaching and detaching sessions with a click. If that integration is why you use iTerm2, Ghostty is a downgrade.

Which terminal uses the least RAM?

Ghostty, at 24 MB idle. Kitty uses 42 MB and iTerm2 uses 78 MB with default settings. The gap compounds across windows: eight Ghostty windows come to roughly 192 MB against about 624 MB for the same eight in iTerm2.

iTerm2 vs Ghostty: which should I pick in 2026?

Pick Ghostty if your terminal is a window you put a shell and tmux into: 68 ms cold start against iTerm2's 312 ms, 24 MB idle against 78 MB, 1.2 ms of keyboard latency against 4.1 ms, and one plain-text config you can commit to dotfiles. Pick iTerm2 if the terminal is also a control surface — tmux control mode, triggers that highlight errors as they scroll, profiles that switch when you SSH into prod, Cmd+F regex search over scrollback, saved window arrangements, a Python API. Both are free and both are maintained, so the honest test is a week of daily use: if you never reach for one of those features, the speed is yours to keep.

What do I lose when I switch from iTerm2 to Ghostty?

Eight things, and Ghostty has no substitute for any of them: native tmux control mode (tmux -CC), Cmd+F regex search across scrollback, profiles and automatic profile switching, triggers and badges, saved window arrangements, Instant Replay, the Python and AppleScript APIs, and Semantic History (Cmd+click a file path to open it in your editor). What carries over is more than people expect: splits on the same Cmd+D and Cmd+Shift+D, shell integration with prompt jumping, working-directory inheritance for new tabs, and a global drop-down window via quick-terminal.

How do I move my iTerm2 profile into a Ghostty config?

There is no importer — you retype it once into ~/.config/ghostty/config, and for most setups that is under fifteen lines. Font becomes font-family and font-size, a color preset becomes theme, transparency becomes background-opacity, blur becomes background-blur-radius, pane margins become window-padding-x and window-padding-y, cursor settings become cursor-style, scrollback lines become scrollback-limit (a byte budget rather than a line count), Left Option sends Esc+ becomes macos-option-as-alt, key bindings become keybind lines, and the hotkey window becomes 'keybind = global:cmd+grave=toggle_quick_terminal'. Shell integration needs no script at all under 'shell-integration = detect'. Only profiles and triggers have no counterpart.

Does Ghostty have an equivalent to iTerm2 triggers?

No. iTerm2 triggers match a regex against every line of output and act on the hit — highlight it, ring a bell, capture it to the Toolbelt, switch the profile. Ghostty has no surface that inspects output at all. The practical substitute is to colorize in the pipeline: 'tail -f app.log | grep --color=always -Ei "error|fatal|panic"' or 'rg --passthru'. That is portable and works in any terminal, but it is opt-in — you have to wrap the command, and it cannot color output you did not think to pipe.

Can I search scrollback in Ghostty the way Cmd+F works in iTerm2?

Not interactively. Ghostty has no in-terminal find; what it has is the write_scrollback_file action, which you can bind to dump the buffer and hand it to your pager or editor — 'keybind = cmd+shift+j=write_scrollback_file:open'. Searching a file with grep, rg, or your editor is more capable than iTerm2's find once the buffer is there, and slower to reach for than a keystroke. If you run tmux, copy mode's own search covers the same ground without leaving the session. What you cannot get back is incremental highlight-as-you-type over live output.

Does Ghostty support shell integration and prompt marks like iTerm2?

Partly, and the part it supports needs no setup. Ghostty's shell integration is automatic under 'shell-integration = detect' — there is no script to install the way iTerm2 has one — and it exposes prompt jumping as a bindable action ('keybind = cmd+up=jump_to_prompt:-1'). Working-directory inheritance for new tabs and splits works in both. What does not carry over is what iTerm2 layered on top of its integration: command-status marks in the gutter, the captured-output Toolbelt, Instant Replay, and Cmd+click on a file path opening your editor — in Ghostty, Cmd+click resolves URLs only.

Does Ghostty have an iTerm2-style hotkey window?

Yes. Ghostty's quick terminal is the direct equivalent of iTerm2's dedicated hotkey window: bind it globally with 'keybind = global:cmd+grave=toggle_quick_terminal' and it slides in over whatever app you are in. This is one of the few iTerm2 power features that maps across without compromise, and you can position it with quick-terminal-position.

Is Ghostty a drop-in replacement for iTerm2?

As a terminal, yes — splits, tabs, fonts, themes, true color, shell integration, and the standard macOS key bindings all behave the way you expect, and the config is a one-time fifteen-line retype. As a replacement for iTerm2 the application, no. Nothing in Ghostty stands in for tmux control mode, triggers, profiles, window arrangements, Instant Replay, or the scripting APIs, and none of those are planned, because Ghostty's design position is that the terminal should be a fast surface and the rest belongs to tmux and your shell.

Ghostty vs Kitty: which is faster?

Ghostty starts faster — 68 ms cold against Kitty's 145 ms — and uses less memory, 24 MB against 42 MB. Once running they are close: both hit 144 fps on scrollback, and Kitty is marginally ahead on a 1M-line grep at 1.3 s against 1.4 s. Kitty's daemon architecture means subsequent windows open near-instantly, so the startup gap only matters on the first launch after a reboot.

Is Ghostty better than Kitty?

It depends on what you ask a terminal to do. Ghostty is faster to launch (68 ms against 145 ms), lighter (24 MB against 42 MB), and a native app on macOS. Kitty is the more capable program: kittens, a remote-control socket, named pane layouts, and an ssh kitten that carries your terminfo to remote hosts. If your terminal sits in front of tmux and you want it to disappear, Ghostty is better. If you script your terminal itself, Kitty is better and Ghostty has no substitute for it.

Does Ghostty run on Linux?

Yes. Ghostty ships both a macOS build and a Linux build — native SwiftUI with Metal on macOS, GTK4 with OpenGL on Linux. There is no official Windows or BSD build, which is where Kitty is still ahead: Kitty covers macOS, Linux, and BSD, and has been packaged in mainstream Linux distributions since 2017. Ghostty's Linux packaging is newer and more distro-dependent.

Does Ghostty support the Kitty graphics protocol?

Yes. Ghostty implements the Kitty graphics protocol for inline images and the Kitty keyboard protocol for unambiguous key reporting, both of which Kitty originated. TUI programs written against either protocol generally work unchanged in Ghostty. What does not carry over are the kittens themselves — those are Python programs that ship inside Kitty and talk to its remote-control socket, which Ghostty does not have.

Should I switch from Kitty to Ghostty?

Switch if you are on macOS, you want a native-feeling app, and your kitty.conf is mostly fonts, colors, and keybindings — that part translates key for key and you gain about 77 ms of startup and 18 MB per window. Stay on Kitty if you use named layouts, remote control, or the ssh kitten, or if you need BSD. Both are free, so the real test is a week of daily use: if you never reach for a kitten, the switch sticks.

What are Kitty kittens, and does Ghostty have an equivalent?

Kittens are small Python programs bundled with Kitty that extend it from inside the terminal — kitten diff for side-by-side diffs, kitten icat for inline images, kitten ssh for terminfo-aware remote sessions, kitten themes for live theme switching, kitten hints for keyboard URL selection. Ghostty has no plugin runtime at all and is not planning one; the equivalent is a standalone CLI or a shell function you write yourself.

Can Kitty replace iTerm2 on macOS?

Yes, with caveats. Kitty runs well on macOS via Homebrew and supports GPU acceleration. You give up iTerm2's native macOS feel — System Settings integration, proper window tabs in the macOS style — and some GUI niceties. Kitty is a terminal emulator through and through; it does not try to feel like a Mac app.

Is there a terminal that works on both Linux and macOS with GPU acceleration?

Ghostty and Kitty both do; iTerm2 is macOS-only. Ghostty covers macOS (Metal) and Linux (GTK4 with OpenGL). Kitty covers macOS, Linux, and BSD on OpenGL, and has the longer packaging history on Linux. If BSD is in the mix, or you want one scriptable config across every machine, Kitty is the safer choice.

Is iTerm2 still worth using in 2026?

Yes, for the developers who use what it offers. iTerm2 is still the most feature-complete terminal on macOS — native tmux control mode, profiles, triggers, regex search, jump marks — and it is still free and actively maintained. Its cost is startup time and memory, which only matters if you are opening terminals constantly or running many windows at once.

Is Ghostty free?

Yes. Ghostty is free and open source under the MIT license, with no paid tier. iTerm2 is free under GPL 2 and Kitty is free under GPL 3. Ghostty's MIT license is the most permissive of the three, which removes an approval step at companies with strict GPL policies.

Kitty vs Ghostty: which should I pick in 2026?

Pick Ghostty if the terminal is just a window you put a shell and tmux into: it cold-starts in 68 ms against Kitty's 145 ms, idles at 24 MB against 42 MB, and on macOS it is a native app rather than a port. Pick Kitty if you script your terminal, use named layouts or session files, SSH into fresh hosts constantly, or run BSD. The speed difference is real but small in daily use; the capability difference is absolute, because Ghostty has no scripting surface at all and is not adding one.

Why does my prompt or TUI break over SSH with Ghostty?

Ghostty sets TERM=xterm-ghostty, and a remote host that has never seen that terminfo entry cannot drive the terminal correctly — you get tput errors, arrow keys printing escape sequences in less, and misdrawn TUIs. Kitty solves this with kitten ssh, which copies its terminfo to the host automatically. In Ghostty the fix is manual: either install the entry once per host with 'infocmp -x xterm-ghostty | ssh user@server -- tic -x -', or downgrade the session with 'TERM=xterm-256color ssh user@server' and accept the loss of extended key reporting and styled underlines.

Does Ghostty have anything like kitty @ remote control?

No. Kitty exposes a Unix socket with allow_remote_control, so scripts can run 'kitty @ launch' to open windows, 'kitty @ send-text' to type into a pane, or 'kitty @ set-colors' to repaint the terminal. Ghostty has no socket and no CLI that talks to a running instance. The nearest substitute is running tmux inside Ghostty and using 'tmux new-window' and 'tmux send-keys', which covers windows and input but not appearance — nothing outside Ghostty can change its colors or ask it what windows it has open.

Can Ghostty restore a saved session the way kitty --session does?

No. Kitty can boot a named layout of windows, tabs, and commands from a session file via 'kitty --session' or the startup_session option. Ghostty has no session format and no saved layouts; you place splits by hand each time. If you rely on a reproducible workspace, run tmux or zellij inside Ghostty and keep the layout in a tmux script instead — that is the workflow Ghostty is designed around.

Kitty or Ghostty for Neovim?

Close to a tie. Both implement the Kitty keyboard protocol, so Neovim can tell Ctrl+I from Tab and read modifiers on previously ambiguous keys; both render styled underlines for LSP undercurl diagnostics; both implement the Kitty graphics protocol, so image.nvim works in either. Ghostty measures 1.2 ms of keyboard latency against Kitty's 1.8 ms, a real but barely perceptible gap. Inside the editor they behave the same — pick on what you want outside it, which is speed for Ghostty and scriptability for Kitty.

When was this comparison last verified?

These benchmarks were run in May 2026 on a MacBook Pro M3 Max with 64 GB of RAM on macOS 15.6, with all three terminals freshly installed at default settings, three runs averaged. This comparison was last reviewed and expanded on September 22, 2026, when the iTerm2-first head-to-head was added — the iTerm2 settings decision checklist, the iTerm2-to-Ghostty config mapping, tmux control mode, triggers and profiles, scrollback search, and shell integration. The Kitty-first head-to-head was added on September 20, 2026.