Mitchell Hashimoto on Ghostty, Zig, and Engineering Beyond the Legacy PTY Protocol
HashiCorp founder Mitchell Hashimoto discusses the technical motivations behind his terminal emulator, Ghostty, and his shift from distributed systems to single-node optimization. The interview highlights planned terminal protocols, the constraints of in-band signaling, and a philosophy of minimalist open-source API design.
Technical Genesis: From Distributed Systems to Single-Node Optimization
After fifteen years of building distributed infrastructure tools at HashiCorp, Mitchell Hashimoto shifted his focus toward low-level desktop programming. Where distributed systems development is structurally dominated by network latency, single-node systems programming requires rigorous attention to cache locality, vector operations, and GPU utilization.
Hashimoto chose to build Ghostty to satisfy three goals: mastering pre-AI GPU programming, targeting single-node desktop architectures, and building in the Zig programming language. While his original intent was to construct a minimal terminal emulator to run Vim and self-compile before discarding the codebase, the project transitioned into a production-grade application to fill an unaddressed niche: a fast, highly performant, and natively cross-platform terminal emulator.
The Architectural Limits of Terminal Emulation
Hashimoto maintains a conservative stance on expanding the capabilities of the terminal. While the terminal can theoretically serve as a full application runtime—much like a web browser or a Java runtime—converting it into an all-encompassing platform with video, microphone, and responsive layout access compromises its core utility. The strength of text-based, monospaced-grid applications lies in rapid implementation, ease of programmatic interaction, and a highly predictable security model.
The primary bottleneck in modern terminal environments is the pseudoterminal (PTY) dependency on in-band signaling, which relies on parsing an unstructured byte stream embedded with escape sequences. While projects like Nushell attempt to solve this via layered abstractions, and Microsoft's PowerShell addresses it via structured data, a clean, foundational solution has yet to be standardized.
In designing new protocols for Ghostty, Hashimoto rejects inventing custom solutions without analyzing existing paradigms. For features requiring modern desktop capabilities, such as clipboard management with multiple MIME types and images, his design workflow starts with analyzing the established APIs of AppKit, Cocoa, Win32, GTK, and Qt.
Proposed Protocols: N-Screen and Persistent Buttons
Rather than introducing arbitrary custom protocols, Hashimoto is developing two specific specifications to resolve long-standing terminal layout and interaction issues.
The first is an n-screen API designed to replace the rigid primary-and-alternate screen paradigm. Currently, terminal emulators support only a scrollable main screen or a full-screen alternate screen (used by interactive tools like Neovim). The proposed n-screen specification allows applications to instantiate and populate an unlimited number of background screens with independent grid sizes. The terminal emulator manages line wrapping, mouse routing, and selection. This design would allow a terminal emulator to render separate screens as standalone windows outside of the main grid, enabling paradigms like mapping Neovim tabs to native operating system window tabs.
The second is a standardized button protocol modeled after the OSC 8 hyperlink specification. Current mouse protocols only track interactions within the active screen grid, meaning click events lose context once text scrolls into the history buffer. The proposed button protocol embeds a programmatic ID with a region of text. When clicked—even within scrollback history—the terminal emulator transmits a specific structured message back to the application. This is particularly useful for interactive main-screen command-line applications that require persistent interactive targets in their output history.
Standardizing the User Space
The lack of a centralized standards body remains a challenge for modern terminal development. Over the past two decades, terminal behavior has been standardized ad-hoc by the feature sets of the most popular implementations, creating a fragmented landscape of legacy behaviors.
Hashimoto experimented with replacing the entire PTY protocol with Wayland, treating the terminal emulator strictly as a windowing server managing local window widgets. Although the protocol proved capable, the experiment was ultimately shelved.
Regarding open-source project management, Hashimoto emphasizes that maintainers carry zero warranty obligations to users. To avoid architectural stagnation and feature creep, he advocates for consolidating user-submitted feature requests into clean, unified abstractions rather than accepting fragmented pull requests. High-quality system design requires identifying a single, elegant mechanism that natively resolves multiple distinct problems.