Mitchell Hashimoto on Building Ghostty in Zig: Simplicity, Control, and Terminal Performance

Last updated: July 10, 2026

Mitchell Hashimoto built Vagrant, Terraform, Consul, Vault, and Nomad. Now he's building Ghostty, a high-performance terminal emulator written in Zig. A recent interview sparked a 130-comment Hacker News discussion about language choice, terminal development, and whether "culture" should factor into technical decisions.

Why Zig Over Rust#

Hashimoto's reasoning for choosing Zig is practical, not ideological. He needed low-level control for a terminal emulator where milliseconds matter, but wanted to avoid what he calls the "complexity" of Rust.

The key points from the interview:

• Performance and control: Zig provides fine-grained optimization without sacrificing ergonomics. Terminal rendering requires precise control over allocation patterns.
• Faster compile times: Zig compiles significantly faster than Rust, enabling rapid iteration during development.
• Direct C interop: Binding to macOS and Linux system APIs is straightforward. Ghostty uses Metal on macOS and considers Vulkan/OpenGL on Linux.
• Explicit memory management: Developers make intentional choices rather than fighting implicit language decisions.

He also noted Zig's cross-compilation capabilities as essential for supporting macOS and Linux from a single codebase.

What HN Is Saying#

The discussion split into predictable camps, but the meta-conversation about "programming language culture" generated the most heat.

On culture wars in programming:

One commenter wrote that "culture wars are sadly one of the biggest inhibitors of progress throughout all of technology." Another pushed back: "Why does liking something different from you imply there's a war?"

Hashimoto's comments about Zig's community resonated with some and confused others. One skeptic observed that "in 2026, Rust is fully a commodity language" and questioned whether comparing community cultures even makes sense when Zig has "orders of magnitude" fewer users.

On Ghostty itself:

Users who switched from iTerm2 report that Ghostty is "more performant and aesthetically pleasing." One user wrote: "I've used Ghostty on macOS since it was released and have yet to encounter a single bug."

Others find it "way buggier than iTerm with a fraction of the features." The feature gap is intentional - Ghostty prioritizes a smaller, faster codebase over kitchen-sink functionality.

On Hashimoto's track record:

A subset of commenters questioned whether HashiCorp tools were "massively overrated" and whether Ghostty represents the same pattern. One wrote: "I feel this way about most Hashi tools, they just seem massively overrated to me."

Defenders pointed out that "Vault and Terraform are super widely used" and represented "a game changer in a world that had very little."

Technical Architecture#

Ghostty's design philosophy centers on GPU-first rendering. Rather than CPU-rendering text to a bitmap, it uses GPU shaders and geometry to render characters. This enables 60 FPS updates with lower latency than traditional approaches.

The architecture includes:

• Incremental updates: Only redrawing changed portions of the terminal, not the entire screen
• Careful buffer management: Preventing excessive allocations during scrolling or rapid output
• Event-driven I/O: Direct system APIs for terminal handling and window management
• Single-threaded core: With carefully synchronized threading where parallelism provides measurable benefit

One HN commenter noted: "Users notice latency below 50ms; every optimization compounds."

The Zig Ecosystem Question#

Hashimoto acknowledges Zig's challenges openly:

• Smaller ecosystem: Fewer libraries compared to established languages, often requiring custom implementations
• Evolving language: Zig is still pre-1.0, and breaking changes occur
• Community size: Fewer developers and examples to reference

But he frames these as acceptable tradeoffs given Zig's strengths. The language's explicit control model matches his mental model for systems programming, and the compile speed difference versus Rust is substantial for iterative development.

An interesting counterpoint emerged in the thread: Hashimoto recently pushed back on claims that LLMs struggle with Zig code. He wrote that "Ghostty is heavily AI written" and asked whether that constitutes "a strong counter example."

The Rust vs Zig Debate#

Several commenters tried to defuse the tribal framing. One wrote: "Is it a competition? I wonder if the Zig people feel as though it is, because I doubt the Rust people do."

The distinction they drew: Rust's tentpole feature is provable memory safety through the borrow checker. Zig's tentpole is explicit control with manual memory management. These serve different audiences and use cases.

A Rust user who tried contributing to Ghostty described it as "an interesting language that I like the aesthetics of but don't want to use." They preferred Rust's constraints: "I find that very beneficial for myself as someone coming from Python, Javascript, PHP, etc."

From the other side, a commenter noted the "anti-Rust" vibe in the Zig community is a recent phenomenon, "triggered by the Bun rewrite." Historically, "Zig people usually will tell you to use the right tool for the job."

What This Means for Developers#

The interview and discussion highlight a maturing systems programming landscape. Zig is no longer just "the language Andrew Kelley is building." It has a flagship project in Ghostty, growing adoption in build systems (Zig's build system is increasingly used even for non-Zig projects), and a distinct community identity.

For developers evaluating systems languages in 2026:

1. Rust remains the safe choice for teams prioritizing memory safety guarantees and a larger ecosystem
2. Zig appeals to developers who want C-level control with modern ergonomics and faster iteration cycles
3. Neither is going away, and the "war" framing obscures genuine technical tradeoffs

Ghostty itself is worth trying if you spend significant time in a terminal. The source is on GitHub and the project accepts contributions - though you'll need to learn some Zig first.

FAQ#

Why did Mitchell Hashimoto choose Zig over Rust for Ghostty?#

He wanted low-level control for a terminal emulator where milliseconds matter without what he calls the complexity of Rust. He cites performance and control, faster compile times, direct C interop with macOS and Linux system APIs, explicit memory management and cross-compilation.

How does Ghostty render the terminal?#

Ghostty is GPU-first. It uses GPU shaders and geometry to render characters instead of CPU-rendering text to a bitmap, with incremental updates, careful buffer management, event-driven I/O and a single-threaded core with synchronized threading only where it measurably helps.

What are the downsides of building in Zig?#

Hashimoto acknowledges a smaller ecosystem that often requires custom implementations, a pre-1.0 language where breaking changes occur, and a smaller community with fewer examples to reference. He treats these as acceptable tradeoffs.

Should I pick Rust or Zig for a systems project?#

Rust remains the safe choice for teams prioritizing memory safety guarantees and a larger ecosystem. Zig appeals to developers who want C-level control with modern ergonomics and faster iteration. Neither is going away.

Continue Reading#

• Epic Games Releases Lore: A Version Control System Built for Game Development
• F3 Is a Reminder That File Formats Are Becoming Runtime Contracts
• Setting Up the Memory Tool with Fable 5: Persistent Agents That Learn
• Roc's Rust-to-Zig Rewrite: 487 Days, 300K Lines, and What the Numbers Actually Show
• Zig Creator on the Bun-to-Rust Rewrite: What the Controversy Reveals
• Zig's Incremental Compilation: 50ms Rebuilds From a Core Team Deep Dive

Sources#

• Interview with Mitchell Hashimoto - Alex Alejandre
• Hacker News discussion
• Ghostty GitHub repository
• Mitchell Hashimoto on AI and Zig - X/Twitter