Ghostty in review: how's the new terminal emulator?

A few months ago, a new terminal emulator was released. It's called ghostty, and it has been a highly anticipated terminal emulator for a while, especially due to the coverage that it received from ThePrimeagen, who had been using for a while, while it was in private beta.

Ghostty was created by Mitchell Hashimoto. Mitchell has co-founded Hashiicorp, the company behind some of the most relevant tools in the cloud-native and DevOps space right now: Terraform, one of the leading solutions for IaC, is from this company, as is Vagrant, one of the most popular tools to quickly manage local development virtual machines. Mitchell has a rock-solid background in software development and DevOps, which are some of the tasks that terminal emulators are used for the most often. This terminal emulator was created by someone who knows what people want out of a terminal emulator, and it shows.

Ghostty is available for Linux and macOS, so, most of you reading should be able to try it out.

User-friendly, customizable and well-integrated

The main appeal of ghostty is that it's a terminal emulator that manages to get a lot of things done well, all at the same time. One of the main goals behind Ghostty was creating a terminal emulator that feels well-integrated with the systems it's targeting. On Linux, it picked GTK for the task to feel exceptionally integrated in GNOME, but it also supports client-side decorations, so it does not look too out of place on KDE Plasma, either. When you run Ghostty on the GNOME desktop, you will be really hard-pressed to find how it differs, cosmetically, from the integrated GNOME terminal. Can you guess which is which just from this screenshot?

If you had a hard time telling a difference, that is the point. Ghostty is supposed to feel like a native application on the ecosystem that it's targeting.

However, it is not this trait that makes it special. It is the fact that, on top of looking like your native Terminal application, it is also blazing-fast, and tremendously customizable.

A terminal for terminal devs

Right off the bat, as soon as you open the hamburger menu on the top bar, you will find an option to use a “Terminal Inspector”. This option will open a new window that contains a wealth of live-updating options for the terminal. According to Mitchell, this feature is the equivalent of what a browser-based dev console is to web applications, but for terminal-based applications.

TUI Applications, which stand for “Terminal User-Interface”, are applications with a graphical interface that, rather than running inside a regular window, run inside a Terminal context. TUIs are amazing for software development workloads, because they allow you to never leave the terminal, and they can live inside a terminal tab or a tmux pane.

While the development experience of TUI apps has been getting easier, thanks to libraries like ratatui for Rust or bubbletea for Go, debugging them at runtime has always been a pain. Thanks to the Terminal inspector, development of these tools is now much easier.

Rich customization

As you keep navigating through the hamburger menu, one thing you will notice is that, unlike on the default GNOME terminal, there is no graphical Settings menu to speak of here. The reason for that is that Ghostty is so customizable that it would have been pretty much impossible to provide a practical GUI to expose all its configuration options: you need the full expressivity of a configuration file for that. We can already start to see why this terminal emulator is so good: within the same terminal emulator, you get both the graphical polish and integration of a native GNOME application, and a similar configurability that you would expect from Kitty or Alacritty.

In order to configure ghostty, you will need to edit its configuration file, located in ~/.config/ghostty/config. Here, you can refine the default configuration in various ways, to configure the terminal emulator to your liking. The configuration format is also really easy to understand, and the reference is well-documented. For example, in my own configuration file, I set the theme to my favorite Rosé Pine colorscheme, made the Ghostty title bar follow the same scheme, set the cursor style to “block”, set some padding around the content, made it so new windows and tabs open in the same path and with the same font size, and set a bunch of keybindings for my own convenience.

If you have no intention of spending any amount of time to configure your terminal, fear not. Ghostty uses a “Zero Configuration Philosophy”: the terminal is designed to ship with great default right outside the box, and it is fully ready to go for most users without the need to add any amount of configuration. It also looks quite modern immediately, with a pretty color scheme that does not have excessive contrast, the amazing Jetbrains Mono font set, and a bunch of pre-applied keybindings.

Nice theming support

If you really like your pretty colors, you're in luck. Themes are a first-class citizen on Ghostty, and you will feel right at home.

While, of course, Ghostty supports installing as many third-party themes as you want or even creating your own, you are very unlikely to need to do so. The terminal ships with a wealth of color schemes that is very likely to contain your favorite one already. You can see a preview of everything that is available running ghostty +list-themes, and just shopping around!

When you have made up your mind, you can then use the Ctrl+, key binding to quickly open the configuration file in your terminal of choice, and add the selected theme to your configuration.

But what if you prefer to use a light theme during the day, and switch to a dark theme when the night comes? That is also a supported use-case. Within the configuration file, you may very well configure the terminal to use a certain theme when the system theme is set to light mode, and switch to a given other theme when it's set to dark. For example, here is how you would configure your terminal to use one Catppuccin Frappé during the day, and switch to the Latte flavor at night.

theme = dark:catppuccin-frappe,light:catppuccin-latte

Splits and tabs!

Another thing that sets this terminal emulator apart from the traditional ones is the fact that — like Kitty — it has full support for tabs and splits. It is possible to split any view using tilable and resizable panes, without needing to use a terminal multiplexer like tmux. Again, this is very comfortable for complex workloads, like development and DevOps, where you might want to see different terminal applications or outputs all at once.

All about graphics: GPU rendering and graphical support

Ghostty supports Kitty's Terminal graphics protocol. This means that — yes, you heard that right — you can render full-resolution pictures in it. This is a really nice perk if you like using TUI applications: for example, the yazi file manager uses this protocol to render previews of pictures and PDF documents right within your terminal.

How this is technically doable is even cooler. Like Kitty, Ghostty is also a GPU-accelerated terminal emulator. The terminal window is actually a hardware-accelerated OpenGL context. This makes Ghostty the first native GTK4 terminal to not use the vte library, making it gain a definite advantage in performance and flexibility over traditional terminal emulators.

If you think it's a gimmick, fear not. You will see the difference in instances where your terminal needs to render a very large amount of output at the same time, while using Neovim motions to scroll through a large document, or when you will see the beautiful font ligatures being rendered as if you were using a graphical IDE.

The future: a modular, embeddable terminal

It does not end there, though. One of the stand-out features of ghostty is that it was not built as a monolith, but, rather, as a combination between libghostty — the core, embeddable “server” component that takes care of the heavy-lifting — and a graphical client that consumes libghostty.

While this feature is not complete on Linux yet, eventually, it will be possible to take the base libghostty component — the one that does the hard part — and build your own custom UI around it.

So far, this has to be my favorite way to make sure every OS and desktop environment is properly supported, with a build that feels native to it, without causing the maintainers to have to support a gigantic number of different builds. When this work is complete, the core project will officially maintain a GUI for macOS, Windows, and GNOME — the most popular Linux desktop environment — leaving the community free to create as many GUIs around Ghostty as they want. For example, the KDE community could come up with a Kirigami wrapper around libghostty, the Cosmic community will create one with iced, et cetera. These graphical clients will not be excessively difficult to maintain either — the main Ghostty feature updates will be shipped as part of the underlying library, making the maintenance work for other communities trivial.

If you use GNOME, you should definitely be giving Ghostty a try. To be completely fair, I did not dislike using it on my other KDE Plasma — based machine either, but it does not feel as “native” yet. One day it will, though: the developments around libghostty are interesting, and absolutely worth following.