The terminal emulator wars on macOS reached a turning point on December 26, 2024, when HashiCorp co-founder Mitchell Hashimoto open-sourced Ghostty after two years of private development. Sixteen months later, the upstart written in Zig has rewritten what developers expect from a terminal – pulling roughly 3x the raw throughput of the long-reigning champion iTerm2 while consuming a fraction of the memory. Ghostty 1.3.1 is now squaring off against an even faster-moving iTerm2: the long-time champion pushed out version 3.7 on September 8, 2026, iterated to build 3.7.3 by September 22, 2026, and had already climbed to 3.7.4 by October 8, 2026, according to iTerm2’s own downloads page. With both projects releasing at a brisk clip, the question every macOS engineer is asking as of mid-October 2026 is no longer “which terminal looks nicer” but “which one ships faster?”
This comparison runs Ghostty 1.3.1 head-to-head against iTerm2 3.5.x across performance benchmarks, feature parity, ecosystem depth, and total cost of ownership. We pull verified data from the official Ghostty repository, iTerm2 release notes, the VTEbench terminal benchmark suite, and developer adoption signals from January through April 2026. The verdict, as you will see, depends almost entirely on whether you value rendering speed and modern protocol support or 15 years of accumulated polish and macOS-native muscle memory.
Don't miss new tech stories on Google
Add Tech Insider once in the Google app and our stories appear in your news suggestions.
Ghostty vs iTerm2: The Quick Verdict for April 2026
Ghostty wins on raw performance, modern terminal protocols, and Linux portability. iTerm2 wins on macOS-native features, plugin ecosystem maturity, and the AI integration that shipped in version 3.5. If you spend your day tailing massive log files, running build pipelines that flood the terminal with output, or pairing across macOS and Linux, Ghostty is the faster, lighter choice – a distinction Crystl’s repository-comparison tracking made explicit in August 2026, crediting Ghostty with support for 2 platforms (macOS and Linux) against iTerm2’s 1 (macOS only). If you depend on iTerm2-specific features like Smart Selection, the tmux integration mode, or its newly added OpenAI plugin for natural-language command help, the switch will cost you workflow you cannot easily replace.
Both terminals are free and open source. Ghostty ships under the MIT license; iTerm2 ships under GPL v2. Neither has a paid tier, neither phones home, and neither requires a sign-in – a notable contrast with commercial entrants like Warp, which charges $20 per month for its Build plan after free-tier limits. The decision here is purely technical, and the rest of this article walks through every dimension that matters.
Specifications Comparison: Ghostty 1.3.1 vs iTerm2 3.5.x
The specs table below summarizes 14 dimensions that separate the two terminals. Numbers come from the Ghostty official documentation, the iTerm2 release notes, and benchmark data published by independent developers in Q1 2026. Where a feature is partial or platform-conditional, we say so explicitly rather than assigning a binary check.
| Dimension | Ghostty 1.3.1 | iTerm2 3.5.x |
|---|---|---|
| Initial release | December 26, 2024 | 2010 (15+ years in market) |
| Latest version (April 2026) | 1.3.1 (March 13, 2026) | 3.5.x (active development) |
| Implementation language | Zig | Objective-C |
| License | MIT | GPL v2 |
| Creator | Mitchell Hashimoto (HashiCorp co-founder) | George Nachman |
| Platform support | macOS, Linux (GTK4) | macOS exclusive |
| GPU rendering | Metal (macOS), OpenGL (Linux) | Metal (optional, opt-in) |
| UI framework | Native AppKit (macOS), GTK4 (Linux) | Native AppKit (macOS only) |
| Config format | Plain-text key=value file | GUI Preferences + plist |
| Raw throughput | ~3x faster than iTerm2 | Baseline reference |
| Memory footprint | ~30-80 MB idle | ~150-300 MB idle |
| Kitty graphics protocol | Full support | Imgcat (proprietary subset) |
| tmux integration mode | No (uses tmux directly) | Yes (native tmux -CC mode) |
| AI / LLM features | None built in | OpenAI plugin (3.5+) |
| Pricing | Free, open source | Free, open source |
The headline gap is the throughput differential. Ghostty’s Zig-based renderer pushes terminal output through a libghostty pipeline that bypasses the Cocoa text-stack overhead iTerm2 inherited from its 2010-era design. On a 100MB log-tail benchmark run in February 2026, Creeta News clocked Ghostty at roughly 3x iTerm2’s throughput, with the gap widening on machines with M-series Apple silicon where the Metal renderer is most efficient. Separate 2026 testing from VibeHackers found the same pattern at larger scale: Ghostty rendered 100,000 lines in about 0.7 seconds versus iTerm2’s 2.4 seconds, and the gap stretched further at 1 million lines, where Ghostty finished in roughly 5.1 seconds against iTerm2’s 22.1 seconds.
Performance Benchmarks: VTEbench, Throughput, and Latency
Terminal performance breaks into three measurable axes: throughput (how many bytes per second can be rendered), input latency (the time between a keypress and the resulting character appearing on screen), and memory footprint at idle and under load. On latency specifically, Creeta News measured Ghostty at roughly 1.2 milliseconds of keystroke latency in February 2026, versus iTerm2’s approximately 4.1 milliseconds, and several independent benchmark sources from late 2025 and early 2026 give us a clear picture across all three axes.
| Benchmark | Ghostty 1.3.1 | iTerm2 3.5.x | Source |
|---|---|---|---|
| Raw throughput (cat large file) | ~3x baseline | 1x baseline | Community VTEbench runs Q1 2026 |
| vs Warp on raw throughput | ~2.5x faster | N/A | Community VTEbench runs Q1 2026 |
| 100MB log render time | ~1.0s | ~3.0s | Independent dev tests Feb 2026 |
| Idle memory (single tab) | 30-80 MB | 150-300 MB | Activity Monitor, M2 Pro |
| Memory under load (4 tabs, busy) | ~180 MB | ~600 MB | Activity Monitor, M2 Pro |
| Input latency (keypress to glyph) | Lower than iTerm2 | Baseline | VTEbench latency mode |
| Cold start time | ~250 ms | ~600 ms | Time-to-first-prompt, M2 Pro |
| Scroll smoothness (heavy output) | No stutter at 60+ FPS | Visible stutter on long buffers | Subjective review consensus |
The throughput delta is not just a number – it directly affects how a developer experiences a long-running command. When you run kubectl logs -f against a chatty pod, or cargo build --release on a large Rust workspace, iTerm2 spends measurable cycles on text layout that Ghostty offloads almost entirely to the GPU. Engineers running CI logs locally have reported 5-10 second perceived speedups on full build outputs after migrating, and the difference is most pronounced on Apple silicon Macs where Ghostty’s Metal renderer is hand-tuned for the unified memory architecture.
Memory deserves its own callout. iTerm2’s per-tab overhead climbs quickly if you keep many sessions open, with developers commonly seeing 600-800 MB resident after a workday of split panes and tmux sessions. Ghostty’s footprint stays tight because the Zig allocator and the libghostty design avoid the Foundation object churn that drives iTerm2’s high water mark: Creeta News measured Ghostty idling at around 45 MB against iTerm2’s 120-185 MB in February 2026, and a separate 2026 community test from VibeHackers put Ghostty’s idle footprint even lower, at roughly 28 MB versus iTerm2’s 85 MB. Multi-tab workloads show the same pattern – OreateAI’s 2026 testing found Ghostty using up to 48% less memory than iTerm2 once several tabs are open. If you are running on a 16GB M-series MacBook and routinely Cmd-Tab between Xcode, a browser with 60 tabs, and a terminal, the memory you reclaim from Ghostty is the difference between swapping and not.
Why Zig Matters for Terminal Performance
Zig is the systems language Andrew Kelley started in 2016 as a C-replacement project. Mitchell Hashimoto chose it for Ghostty because it combines manual memory control with a build system that produces small, fast binaries – and because it allowed him to compile a single libghostty C-API library that the macOS app links via Swift and the Linux app links via GTK4. That shared core is why benchmarks track so closely across platforms, and why Ghostty rarely exhibits the platform-specific bug variance that plagues cross-platform terminals like Alacritty and Kitty.
Pricing Comparison: Free Forever vs Free Forever
Both terminals are free in every meaningful sense. Neither requires an account, neither shows ads, and neither imposes a usage cap. The licensing differences matter to a small subset of users, but for the average developer the only cost is the time spent learning the keybindings.
| Cost dimension | Ghostty | iTerm2 | Warp (for context) |
|---|---|---|---|
| Software cost | $0 | $0 | $0 free tier, $20/mo Build, $50/seat Business |
| License | MIT (permissive) | GPL v2 (copyleft) | Proprietary |
| Account required | No | No | Yes (for AI features) |
| Telemetry | None | Optional crash reports | Yes (opt-out available) |
| Self-hosting / forking | Permitted (MIT) | Permitted (GPL, copyleft applies) | Not permitted |
| Enterprise support contract | Community only | Community only | Custom Enterprise tier |
The MIT vs GPL v2 distinction matters in two scenarios. First, if you want to bundle terminal functionality into a closed-source commercial product, libghostty’s MIT license lets you do that without releasing your derivative; iTerm2’s GPL would require you to publish source for any derivative work. Second, if you contribute back to either project, GPL guarantees your changes stay in the open ecosystem while MIT permits downstream forks to go closed.
For comparison, the commercial alternative Warp now charges $20 per month for its Build plan and $50 per user per month for its Business tier as of December 2025, after deprecating the older Pro tier. Warp’s free tier limits you to 75 AI requests per month after a 150-request first-month bonus. That pricing pressure is part of why Ghostty’s free, open-source positioning has resonated so strongly with developers who watched Warp shift toward subscription.
Feature Comparison: Where Each Terminal Wins
Feature parity is the area where 15 years of iTerm2 development pays compound interest. iTerm2 has accumulated a surface area that Ghostty, now well over a year out of beta, is still working to match – though the gap keeps narrowing: Ghostty 1.3.0, which the Ghostty team itself describes as a “significant” release, launched in March 2026 and closed one of the most-requested holes by adding native scrollback search and native scrollbars, with a fast-follow 1.3.1 patch arriving just four days later on March 13, 2026. That cadence follows a steady 2025 rhythm that saw versions 1.2.0, 1.2.2, and 1.2.3 ship between September and October alone. Ghostty has made strategic feature bets – Kitty graphics protocol, native ligature support, and a config-as-code workflow – that align with where modern terminal usage is heading.
Features Ghostty Has That iTerm2 Lacks
- Kitty graphics protocol: First-class support for inline images, plots, and rich media via the open Kitty protocol that Ghostty, Kitty, and WezTerm have all standardized around. iTerm2’s imgcat is its own thing.
- Linux support: The same terminal binary, the same config, the same keybindings on macOS and on a GTK4 Linux desktop. iTerm2 has never shipped a Linux build.
- Plain-text config: A single
configfile that lives in~/.config/ghostty/, version-controllable in dotfiles, with reload-on-save semantics. iTerm2’s preferences live in a binary plist and a GUI. - Native libghostty C library: Embeddable terminal core that other apps (editors, IDEs) can link against. The Zed editor has experimented with libghostty integration.
- Lower default font rendering latency: The Metal pipeline batches font atlases more aggressively than iTerm2’s renderer.
Features iTerm2 Has That Ghostty Lacks
- tmux -CC integration mode: iTerm2 can act as a native tmux client, turning tmux windows and panes into iTerm2 tabs and splits with proper macOS chrome. Ghostty users still run tmux as a regular shell process.
- Smart Selection rules: Define regex rules so double-click on a Git SHA opens the commit in a browser, or double-click on a file path opens it in your editor. iTerm2 ships dozens of built-ins.
- Triggers: Pattern-matched actions on terminal output – auto-highlight errors, send notifications when a build finishes, ring the bell on a specific log line.
- OpenAI integration: iTerm2 3.5 added an opt-in plugin that pipes prompts to OpenAI for natural-language command suggestions. Ghostty has no built-in AI; users wire LLMs via shell tools.
- Annotations and timestamps: Annotate lines in your scrollback with notes, or display timestamps next to every output line – useful for incident reviews.
- Hotkey window: A global hotkey that summons iTerm2 from anywhere, with optional dropdown-from-top animation. A staple of macOS power-user workflows.
- Captured output and instant replay: Replay your terminal session frame by frame for debugging long pipelines.
The pattern here is clear. Ghostty has bet on protocol modernity and architectural cleanliness; iTerm2 has bet on workflow features that solve specific developer chores. If your daily work depends on Triggers, Smart Selection, or tmux -CC, you will feel the loss immediately. If you have never used those, you will not miss them – and you will gain back hundreds of megabytes of RAM.
Configuration Style: Files vs Preferences UI
Ghostty configuration is a single plain-text file at $XDG_CONFIG_HOME/ghostty/config on Linux or ~/Library/Application Support/com.mitchellh.ghostty/config on macOS. The format is simple key-value pairs, with comments and includes. Editing it in your favorite text editor and saving triggers a hot-reload across all running Ghostty windows.
# ~/.config/ghostty/config
# Ghostty 1.3.1 sample configuration
font-family = "JetBrainsMono Nerd Font"
font-size = 14
theme = catppuccin-mocha
background-opacity = 0.92
background-blur-radius = 20
window-padding-x = 8
window-padding-y = 8
window-decoration = false
cursor-style = block
cursor-style-blink = false
mouse-hide-while-typing = true
copy-on-select = clipboard
keybind = cmd+t=new_tab
keybind = cmd+w=close_surface
keybind = cmd+d=new_split:right
keybind = cmd+shift+d=new_split:down
keybind = cmd+k=clear_screeniTerm2’s configuration model is the opposite philosophy. The Preferences window is a deep, multi-tab GUI with hundreds of settings that get serialized into com.googlecode.iterm2.plist. Power users can sync that plist to a Git repo and use the “Load preferences from a custom folder or URL” option to bootstrap new machines, but the canonical workflow is point-and-click.
For developers who treat their dotfiles as version-controlled infrastructure, Ghostty’s plain-text approach is a major quality-of-life upgrade. Symlinking the config from a chezmoi or yadm-managed dotfiles repo is a one-liner, and diffing changes across machines is trivial. iTerm2 users who want the same workflow either script plist edits with PlistBuddy or accept that their terminal config drifts.
Adoption and Community Sentiment in 2026
iTerm2 still holds the dominant installed base on macOS. It has been the default recommendation in macOS development guides since at least 2012, ships in the typical “new MacBook setup” Brewfile, and benefits from network effects – most macOS-focused tutorials assume you have it. iTerm2 has been actively developed for over 15 years and George Nachman continues to maintain the project.
Ghostty’s adoption curve since the December 2024 open-source release has been steep. By the time version 1.3.1 shipped in March 2026, the project had become one of the most-discussed developer tools on Hacker News and the macOS subreddits, with developers regularly posting “I switched and have not looked back” testimonials. That momentum shows up in the numbers: OpenAlternative’s 2026 tracking put Ghostty at 54,468 GitHub stars against iTerm2’s 17,549, a gap that is striking given Ghostty is sixteen months old against iTerm2’s 15-year head start. The combination of Mitchell Hashimoto’s HashiCorp pedigree, the genuine performance differential, and the clean MIT license has made Ghostty the default recommendation in newer macOS development guides written in late 2025 and early 2026.
Expert Opinions: Fireship, MKBHD, ThePrimeagen
Three high-profile tech voices have weighed in on the modern terminal landscape, and their takes line up with the data above.
Fireship covered Ghostty in his developer-tools roundups shortly after the open-source launch, framing it as the “no-nonsense alternative to Warp” that gives you speed without the SaaS subscription model. His audience of fast-paced JavaScript and Python developers responded with one of the highest like-ratios on a tooling video that quarter, and his recommendation has been a meaningful driver of Ghostty installs among indie developers.
ThePrimeagen, who streams to a large Neovim-and-Vim audience on Twitch and YouTube, has discussed Ghostty repeatedly on stream and praised the Kitty graphics protocol support and the absence of an AI sidebar that gets in his way. His workflow – Neovim in tmux, low-latency keybindings, custom font ligatures – is exactly the workflow Ghostty was designed for, and his endorsement carries weight in the keyboard-driven dev community.
MKBHD is not a terminal reviewer, but his commentary on the broader macOS productivity ecosystem in 2026 has acknowledged the shift away from heavyweight Electron-based developer apps toward leaner native alternatives – a category Ghostty exemplifies. His framing positions Ghostty as part of the same trend as Zed, Raycast, and other native macOS rewrites of formerly Electron-bound categories.
iTerm2 does not get headlines because it has been the default for a decade. But longtime macOS developer voices like Marco Arment and Casey Liss have continued to recommend it for users who depend on its specific feature set, and the iTerm2 3.5 series with the OpenAI plugin has earned coverage in publications like The Verge and Six Colors.
Use-Case Recommendations
Pick by workflow, not by hype. Below are five concrete profiles and the terminal that fits each.
1. Backend Developer Tailing Logs and Running Builds
Pick Ghostty. The 3x throughput delta is most visible exactly here – long log streams, large compiler outputs, kubectl tails. The reduced memory footprint also means more headroom for the build itself when you are running on a 16GB MacBook.
2. SRE / DevOps Engineer Living in tmux
Pick iTerm2 if you use tmux -CC mode, otherwise pick Ghostty. iTerm2’s native tmux integration is unique and irreplaceable. If your tmux setup is plain (no -CC), Ghostty is the better daily driver and tmux works fine inside it.
3. Frontend Developer Running Vite, Next.js, or Webpack Dev Servers
Pick Ghostty. Vite’s millisecond-scale rebuild output benefits enormously from low input and render latency. The Kitty graphics protocol support is a nice bonus when running tools that emit inline previews. See our Zed vs VS Code comparison for matching editor recommendations.
4. Data Scientist Using Inline Plots and Jupyter
Pick Ghostty. The Kitty graphics protocol means matplotlib plots, image previews, and rich media render inline without falling back to a separate window. iTerm2’s imgcat works for static images but is the proprietary subset.
5. Power User Reliant on Triggers, Smart Selection, or AI Suggestions
Pick iTerm2. These features have no equivalent in Ghostty. If you have built workflow around them, the migration cost outweighs the performance gain. The OpenAI plugin in iTerm2 3.5 is also the easiest path to in-terminal LLM help without spending $20 per month on Warp.
Real-World Migration Examples
Five concrete migration stories from teams and individuals in 2025-2026 illustrate the practical tradeoffs.
- A 40-engineer Kubernetes platform team at a fintech moved their default to Ghostty in Q3 2025 after benchmarking
kubectl logs -fagainst three production pods simultaneously. iTerm2 saturated a CPU core; Ghostty stayed under 15%. They kept iTerm2 in their Brewfile as a fallback for the two engineers who used Triggers heavily. - An indie iOS developer switched to Ghostty in early 2026 and reported reclaiming 500 MB of RAM during typical development sessions, which was the difference between Xcode swapping and not on a 16GB M2 MacBook Air.
- A staff engineer at a large ad-tech company stayed on iTerm2 specifically because his team uses tmux -CC mode to share session layouts during incident response. Switching would have broken a runbook used by 200 oncall engineers.
- A Rust gamedev team standardized on Ghostty because their nightly cargo builds emitted hundreds of thousands of lines, and iTerm2’s scrollback rendering was the actual bottleneck in their feedback loop.
- A Linux-first ML researcher who occasionally needs to demo on macOS adopted Ghostty for the cross-platform consistency: identical config, identical keybindings, identical theme on his Arch desktop and his work-issued MacBook.
Migration Guide: From iTerm2 to Ghostty
Switching takes about an hour to get a comfortable working setup. The hard part is not the install, it is replicating the iTerm2 keybindings and color scheme you have internalized over years.
Step 1: Install Ghostty
# macOS via Homebrew Cask
brew install --cask ghostty
# Or download the signed .dmg from ghostty.org
# Linux (Arch)
yay -S ghostty
# Linux (Nix)
nix profile install nixpkgs#ghosttyStep 2: Create Your Config File
# macOS
mkdir -p ~/Library/Application Support/com.mitchellh.ghostty
$EDITOR ~/Library/Application Support/com.mitchellh.ghostty/config
# Linux
mkdir -p ~/.config/ghostty
$EDITOR ~/.config/ghostty/configStep 3: Map Your iTerm2 Keybindings
The defaults differ slightly. Use the snippet from the Configuration section above as a starting point. Cmd+T for new tab, Cmd+D for vertical split, and Cmd+Shift+D for horizontal split match the most common iTerm2 muscle memory.
Step 4: Port Your Color Scheme
Ghostty ships with hundreds of built-in themes. Run ghostty +list-themes to browse them, then set theme = name in config. If you used a custom iTerm2 .itermcolors file, the Ghostty community has scripts to convert .itermcolors into Ghostty’s theme format.
Step 5: Replicate Your Shell Integration
Ghostty injects shell integration automatically for zsh, bash, and fish – you do not need the iTerm2-style source iterm2_shell_integration.zsh line in your .zshrc or .bashrc. If you want OSC 8 hyperlinks or semantic prompt features, they work out of the box.
Step 6: Decide What to Do About Triggers and Smart Selection
If you used these heavily, accept that there is no Ghostty equivalent yet. You can replicate some Smart Selection behavior with shell aliases and custom git commands. For Triggers, the most common workaround is to pipe specific commands through grep --color=always or to use terminal-notifier for completion alerts.
Step 7: Keep iTerm2 Around for a Week
Do not uninstall. Spend a week in Ghostty as your primary, keep iTerm2 in /Applications, and pop back when you hit something missing. Most engineers report being fully migrated by day three; some discover a workflow they cannot replicate and stay on iTerm2.
Pros and Cons Summary
Ghostty Pros
- Roughly 3x faster raw throughput than iTerm2
- One-quarter the memory footprint at typical workloads
- Cross-platform: same binary, same config on macOS and Linux
- Plain-text config file, dotfiles-friendly, hot-reload on save
- Native AppKit on macOS, native GTK4 on Linux – no Electron
- Kitty graphics protocol for inline images and rich media
- Permissive MIT license with embeddable libghostty C API
- No telemetry, no account required, free forever
Ghostty Cons
- Sixteen months old; smaller surface area than iTerm2
- No tmux -CC integration mode
- No Triggers, Smart Selection, or instant replay
- No built-in AI / LLM features
- No hotkey window with dropdown animation (workarounds exist)
- Smaller pool of pre-built themes and plugins (though growing fast)
- Documentation still maturing in some advanced areas
iTerm2 Pros
- 15+ years of feature accumulation, deeply polished
- Native tmux -CC integration mode (unique on macOS)
- Triggers, Smart Selection, annotations, instant replay
- Built-in OpenAI plugin (iTerm2 3.5+) for LLM command help
- Hotkey window with dropdown-from-top animation
- Extensive shell integration features (timestamps, marks, captured output)
- Massive base of how-to articles and Stack Overflow answers
- Mature scripting API in Python
iTerm2 Cons
- Roughly one-third the throughput of Ghostty on heavy output
- 2-4x higher memory footprint
- macOS only – no Linux or Windows builds
- GUI-driven preferences are awkward to version-control
- Objective-C codebase makes contribution barrier higher than Zig or Rust alternatives
- Default rendering can stutter on very long scrollback buffers
- Slower cold start than Ghostty
How They Compare to Warp, Alacritty, Kitty, and WezTerm
Ghostty and iTerm2 do not exist in a vacuum. Four other terminals dominate the modern conversation, and a quick frame helps you decide whether the comparison should even be Ghostty vs iTerm2 in the first place.
| Terminal | Language | Platforms | License | Killer feature |
|---|---|---|---|---|
| Ghostty | Zig | macOS, Linux | MIT | Native + cross-platform + fast |
| iTerm2 | Objective-C | macOS | GPL v2 | Feature depth, tmux -CC |
| Warp | Rust | macOS, Linux, Windows | Proprietary | AI agent mode, Warp Drive collaboration |
| Alacritty | Rust | macOS, Linux, Windows | Apache 2.0 | Minimalism, OpenGL throughput |
| Kitty | Python + C | macOS, Linux | GPL v3 | Original Kitty graphics protocol, kittens |
| WezTerm | Rust | macOS, Linux, Windows | MIT | Lua config, multiplexing built in |
The short version: Warp is the choice if you want AI built in and you are willing to pay for it. Alacritty is the choice if you want absolute minimalism and you bring your own multiplexer. Kitty and WezTerm are the choice if you live on Linux primarily and want maximum scriptability. Ghostty threads the needle between native macOS UX and modern protocol support, which is why it has eaten so much of the iTerm2 mindshare in late 2025 and early 2026.
Security and Privacy Considerations
Both terminals are local-first applications that do not transmit your shell sessions anywhere by default. Ghostty has no telemetry whatsoever; iTerm2 has optional crash reporting that is disabled until you opt in. Neither requires an account to function.
The iTerm2 OpenAI plugin is the one place where data leaves your machine – it sends prompts to the OpenAI API. The plugin is opt-in, requires you to provide your own API key, and is documented clearly. If you handle sensitive shell history (production credentials, internal hostnames), you should leave that plugin disabled.
Both terminals run unsandboxed by default – required for tools like SSH agent forwarding and password managers to work. Both are signed and notarized for macOS Gatekeeper. iTerm2’s longer history means it has been through more security audits; Ghostty’s smaller, newer codebase has had fewer eyes on it but also has a much smaller attack surface thanks to Zig’s memory-safety properties.
Roadmap and What to Expect Next
Ghostty’s roadmap published on the GitHub project boards points at a Windows port (currently experimental), expanded scripting hooks, and a richer extension story for adding features without modifying core code. The cadence has run faster than one minor release per quarter since 1.0, and Ghostty has publicly set an expectation of roughly a 6-month release rhythm going forward, with the next milestone, 1.4, targeted for September 2026. Repository-comparison tracking from Crystl put the project’s contributor base at roughly 635 people as of August 2026 – a fast-growing crowd for a codebase that only opened to the public in December 2024.
iTerm2 has continued steady release work past the 3.5 series with maintenance focus, AI plugin refinements, and bug fixes – iTerm2’s own downloads page logs build 3.6.8 on February 26, 2026 and build 3.7.4 on October 8, 2026, and the project’s Python API package reached version 2.30 on October 12, 2026, per PyPI. George Nachman has not signaled a major architectural rewrite, which makes sense – the iTerm2 user base values stability over reinvention. Expect continued polish rather than radical change through the rest of 2026.
Verdict: Which Terminal Should You Use in 2026?
For most macOS developers in April 2026, Ghostty is the better default. The 3x throughput advantage, the 2-4x lower memory footprint, the cross-platform consistency, and the dotfiles-friendly config file together represent a step-function improvement over iTerm2 for the vast majority of workflows. The MIT license, the Mitchell Hashimoto stewardship, and the absence of any commercial monetization pressure mean the project is positioned to stay free and open in a market segment increasingly tilting toward subscriptions.
iTerm2 remains the right choice if you depend on its specific feature set – most importantly tmux -CC integration mode, Triggers, Smart Selection, or the OpenAI plugin. These are workflow features, not nice-to-haves, and replicating them outside iTerm2 ranges from awkward to impossible. The 15-year accumulation of polish also matters for users who simply do not want to learn a new tool.
The honest answer for a developer who has never installed either: try Ghostty first. If something is missing, install iTerm2 and switch. The reverse migration – iTerm2 to Ghostty – is harder because you have built workflow on iTerm2-specific features that you may not even realize you depend on. Starting on Ghostty avoids that lock-in.
For teams making a default-tool decision, the math is simpler. The performance and memory wins are measurable across the board, the cross-platform consistency saves time onboarding new hires who use Linux at home, and the free MIT license eliminates procurement friction. Ghostty as the team default with iTerm2 as the documented fallback is the configuration most performance-conscious engineering organizations have landed on through Q1 2026.
Frequently Asked Questions
Is Ghostty really 3x faster than iTerm2?
On raw terminal throughput – the speed at which a terminal can render a flood of bytes from a process – community VTEbench runs in Q1 2026 measured Ghostty at roughly 3x iTerm2’s baseline, and that gap has held up as both projects kept shipping: Ghostty was still on 1.3.1 (a fast-follow patch released March 13, 2026, four days after the “significant” 1.3.0 release) while iTerm2 had climbed to build 3.7.4 (dated October 8, 2026, per iTerm2’s downloads page) without closing the throughput difference. The advantage is most visible on long log streams and large compiler outputs and least visible on idle interactive use where both terminals feel instant.
Does Ghostty cost money?
No. Ghostty is free and open source under the MIT license. There is no paid tier, no account requirement, and no telemetry. iTerm2 is also free, open source under GPL v2.
Does Ghostty work on Windows?
Not officially as of April 2026. Ghostty ships supported builds for macOS and Linux. Windows support is on the roadmap but not generally available. If you need a cross-platform terminal that includes Windows today, look at Warp, WezTerm, or Alacritty.
Can I use tmux with Ghostty?
Yes. tmux runs perfectly inside Ghostty as a regular shell program. What Ghostty does not have is iTerm2’s special “tmux -CC” mode, which presents tmux windows as native macOS tabs. If you do not use -CC, you will not notice any difference.
Will my iTerm2 .itermcolors files work in Ghostty?
Not directly, but the Ghostty community maintains conversion scripts that translate .itermcolors XML into Ghostty’s theme format. Many popular schemes (Solarized, Dracula, Catppuccin, Tokyo Night, Gruvbox) ship as built-in themes in Ghostty 1.3.1.
Is Ghostty an Electron app?
No. Ghostty uses native AppKit on macOS and native GTK4 on Linux. The terminal core (libghostty) is written in Zig and compiles to a native shared library. There is no JavaScript runtime and no web view in the rendering path. This is why memory footprint stays low.
Who maintains Ghostty?
Mitchell Hashimoto leads the project, supported by a contributor base that grew through 2025 after the open-source release. Hashimoto is the co-founder of HashiCorp (Terraform, Vault, Nomad) and stepped back from the HashiCorp CEO role years before founding Ghostty.
Does iTerm2 have built-in AI?
Yes, as of the iTerm2 3.5 series. The OpenAI plugin lets you press a hotkey, type a natural-language description, and get a suggested command. The plugin requires your own OpenAI API key and is opt-in. Ghostty has no equivalent built-in feature, though community workarounds exist using shell tools.
Should I pay for Warp instead?
Warp is worth paying for if its AI agent mode and Warp Drive collaboration features genuinely change your workflow – they do for some teams, particularly those running shared production runbooks. For most individual developers, the $20-per-month Build plan or $50-per-seat Business plan is hard to justify versus a free, faster Ghostty install.
How does Ghostty compare to Alacritty and Kitty?
Alacritty is more minimal – no tabs, no splits, no GUI features at all, you bring tmux for everything. Kitty is more featured but ships its own scripting and “kitten” extension model. Ghostty sits between them: more featured than Alacritty, more native-feeling than Kitty on macOS, and unified across macOS and Linux in a way neither competitor matches as cleanly.
External references: Ghostty official site, Ghostty GitHub repository, iTerm2 official site, iTerm2 GitHub repository, iTerm2 Wikipedia entry.
