About Rustty

Note

Rustty is a full-fidelity Rust port of Ghostty by Mitchell Hashimoto and the Ghostty contributors. The upstream Ghostty project is the source of this port; all credit for the original design, architecture, and terminal behavior belongs to it. Rustty translates that work faithfully into Rust. For background on the original project, see About Ghostty.

Rustty is a terminal emulator that differentiates itself by being fast, feature-rich, and native. While there are many excellent terminal emulators available, they all force you to choose between speed, features, or native UIs. Rustty provides all three.

In all categories, Rustty does not claim to be the best (i.e. the fastest, most feature-rich, or most native). But Ghostty was created because its author felt all terminals made you choose at most two of these categories. The goal, inherited from Ghostty, is a terminal that is competitive in all three categories.

Before diving into the details, note that Ghostty is a passion project started by Mitchell Hashimoto, developed with the Ghostty contributors. Rustty is a port of that work. Please keep that in mind when interacting with the project.

The big picture of "native" is that Rustty is designed to look, feel, and behave like you expect an application to behave in your desktop environment.

Importantly, Rustty aims to be a native application for macOS and Linux. On macOS, the GUI is written in Swift and uses AppKit and SwiftUI. On Linux, the GUI uses the GTK4 C API¹. The GUIs interface with a shared core written in Rust that we call "librustty".

Part of this is using native UI components² for features like tabs, splits, error messages, etc. in contrast to many other terminal emulators that either use text UIs and custom widgets or don't support these features at all.

Another part is using standard keyboard and mouse shortcuts that you're already familiar with. Rustty uses different default bindings on macOS and Linux to match the conventions of each platform.

And a third part is Rustty integrates with system capabilities that are unique to the platform it is running on. For example, on macOS, Rustty supports Quick Look, force touch, the macOS secure input API, built-in window state recovery on restart, etc. These are all native APIs provided by macOS that don't have equivalents in Linux desktop environments.

Rustty tries to provide a rich set of features that are useful for everyday use. These can be split into two categories: terminal features and application features.

Terminal features include the capabilities that programs running inside the terminal can use. For example, Rustty supports the Kitty graphics protocol, light/dark mode notifications, hyperlinks, and more. This lets terminal applications like Neovim, Zellij, and others do more than they could in other terminal emulators³.

Application features are higher-level features that are useful for interacting with the terminal emulator itself. For example, Rustty supports native tabs, splits, a drop-down terminal on macOS, theme switching on system dark/light mode, etc.

Rustty aims to be fast.

Performance is a category where people start getting really argumentative, so the only claim made is that Rustty aims to be in the same class as the fastest terminal emulators, as Ghostty does. In some benchmarks it is faster, in others it is slower, but in every case it should be impossible to say that Rustty is slow.

"Fast" is also a loaded term since "fast" can mean different things to different people. For example, here is just a small list of the things that can be "fast": startup time, scrolling speed, IO throughput, control sequence throughput, framerates, etc.

In the future, we'd like to provide detailed benchmarks and explanations about how Rustty performs in various performance categories. For now, Rustty simply aims to be "fast" as described above.

Rustty also differentiates itself with its architecture. The core of Rustty is a cross-platform, C-ABI compatible library called librustty. librustty provides the core terminal emulation, font handling, and rendering capabilities.

The Rustty GUI applications are consumers of librustty. The macOS app is written in Swift, uses AppKit and SwiftUI, and links against the librustty C API. The Linux app uses the GTK4 C API and is written in Rust, using the librustty crates directly⁴.

This architecture allows for a clean separation between the terminal emulation and the GUI. It is the key architecture that allows Rustty to achieve its goal of being native.

This architecture makes Rustty unique since Rustty the project also aims to enable other terminal emulator projects to be built on top of a shared core. This allows for a more diverse ecosystem of terminal emulators that can focus on higher-level features and UIs without needing to reimplement the core terminal emulation.

Note

librustty is not yet a stable API and has not been released as a standalone, stable library. It is a port of Ghostty's libghostty, starting with librustty-vt (a faithful port of libghostty-vt) for parsing terminal sequences and maintaining terminal state. The goal is to stabilize the API and release it as a standalone library in the future.

Footnotes

1. Linux doesn't have a "native" GUI toolkit like macOS, but GTK4 is the closest thing to a standard GUI toolkit that exists. Most importantly, we don't draw custom widgets and Rustty will fit right into your desktop environment. ↩

2. Linux uses GTK4 and (optionally) Adwaita, so Rustty will look and feel like a GTK4 application which may or may not be "native" depending on your desktop environment and definition of "native". See note 1 too. ↩

3. For example, Neovim uses synchronized rendering to prevent tearing between frames. ↩

4. Since the GTK4 app is written in Rust, it doesn't link in the traditional sense. Instead, it uses the public librustty APIs and compiles as a single Rust workspace. ↩