Did a coworker ever ask you what terminal you use? If they have, they were probably referring to a terminal emulator – but what the hell is that anyway? What is the difference between terminals and a terminal emulator? In this blog, post you’ll learn the difference between the two, and we’ll check out the Alacritty, Kitty, and Ghostty terminal emulators and why developers find them useful.
Terminals x Terminal Emulators
All modern computer terminals are terminal emulators, but not all terminals were emulators. Originally, a computer terminal was actually hardware, an example of a terminal from back in the day is the VT100, built by the Digital Equipment Corporation(DEC):
These devices sent commands over serial connections and displayed output as text, but didn’t run pr…
Did a coworker ever ask you what terminal you use? If they have, they were probably referring to a terminal emulator – but what the hell is that anyway? What is the difference between terminals and a terminal emulator? In this blog, post you’ll learn the difference between the two, and we’ll check out the Alacritty, Kitty, and Ghostty terminal emulators and why developers find them useful.
Terminals x Terminal Emulators
All modern computer terminals are terminal emulators, but not all terminals were emulators. Originally, a computer terminal was actually hardware, an example of a terminal from back in the day is the VT100, built by the Digital Equipment Corporation(DEC):
These devices sent commands over serial connections and displayed output as text, but didn’t run programs locally, they were simple input/output devices. They were “Teletype” machines, but the word that stuck was terminal.
As computing evolved and time-sharing systems became common, terminals turned into software programs that emulated those old hardware devices – hence, terminal emulators!
The term tty comes from “Teletype”, and is still used to this day on modern machines, that’s why popular terminal emulators like AlacriTTY, KiTTY and GhosTTY use tty in their names!
When you open a terminal, the terminal itself isn’t what understands the commands you type, it’s just the window that lets you type and see output. What really processes the commands is known as the shell.
A shell in this case is a command-line interpreter, a program that takes the text commands from the terminal and tells the OS what to do with them. Popular examples include:
A shell takes a command as simple as ls -l and:
- Parses the command
- Finds the
lsprogram - Executes it
- Captures the output
- Prints that output back on the terminal
Now the actual shell session to put it simply, is a live interactive instance of a shell you are connected to. So if you use a Bash shell, you are connected to a bash shell session. Simple, right?
Modern Terminal Emulators
So why should you care about what terminal emulator you are using? Are there even any substantial benefits to switching from what you are currently using?
The truth is, terminal emulators vary a lot under the hood, especially when it comes to performance, rendering, configurability and modern features. If you spend hours of your day using the terminal as a developer, sysadmin, or for DevOps, for example, the differences can really impact your workflow.
Now that we’ve covered the basics, let’s see why terminal emulators have evolved so much and why developers obsess over which one to use!
What Makes Terminal Emulators Different
Performance
Modern problems require modern solutions, and modern machines tend to use graphics cards, and this is where terminal emulators turn to increase their performance.
Instead of letting your processor render the output of your terminal they instead offload that rendering to your GPU, making them GPU-accelerated!
“Traditional” terminal emulators like GNOME Terminal, Konsole and xterm rely on the CPU and the system’s windowing toolkit such as GTK and Qt to draw text onto the screen.
This involves rendering each glyph (character) and refreshing parts of the window when output changes. The CPU does most of the heavy lifting, often resulting in some laggy behavior.
GPU-accelerated terminal emulators however, use modern graphics APIs such as OpenGL, Metal or Vulkan to handle text rending and compositing on the GPU.
The terminal still parses the text and such using the CPU, but the actual drawing, the graphical part of things like rendering fonts, characters and colors happens in the GPU, which makes sense, right?!
Rendering Quality
Each terminal emulator handles things like fonts, ligatures and colors differently. Modern terminal emulators like Kitty and Ghostty support True Color(24 bits per pixel – bpp), this allows for a total of 16,777,216 possible color combinations!
Older terminal emulators lacked in this area. If you’ve watched older movies that showcased a hacker’s terminal or dabbled with computers in the not-too-distant past, you’ll remember that they were usually that standard black and green combo.
That nostalgic color combo wasn’t chosen for the shits and giggles, it was due to the times’ hardware limitations! This is no longer an issue with modern terminal emulators, but many still use that traditional color scheme!
Custom Features
Some terminal emulators are lightweight and minimal, while others pack advanced features out of the box. Here are some useful features that modern terminal emulators have:
- Tabs and splits -> Kitty, Ghostty, GNOME Terminal
- GPU rendering -> Alacritty, Kitty, Ghostty
- Image/Graphics Display -> Kitty
- Synchronized scrolling and remote control -> Kitty, Ghostty
Some terminal emulators open up instantly, whereas traditional ones like Konsole and GNOME Terminal take a little longer to start, some developers are crazy about how fast they can open up their terminal instances and shift around in their workflows.
Configuration and Customization
Some terminal emulators can be configured entirely through text files, an example of this being Alacritty’s YAML config, while others provide some built-in GUI for a more casual experience. This affects how easily you can integrate the terminal emulator into your other dev tools. For example, if you use a color scheme for your system, you can configure your terminal with the EXACT color scheme for seamless integration!
Alacritty vs Kitty vs Ghostty – Developers favorite terminal emulators
Ok…but which one is right for you? Let’s compare the “Top 3” that developers have been using these past few years!
Each of them takes a different approach to solving the same problem really: make your terminal fast, look awesome and improve your production!
Alacritty – The no-nonsense speedster
If you’ve ever wanted a terminal that opens up instantly and never laggs, Alacritty might be the one for you!
Do one thing and do it well – draw text as fast as possible
Written in Rust, it is known for its performance first philosophy, alacritty isn’t as feature rich as the other two, but it’s simplicity is more than enough for most people. It doesn’t come with tabs, splits or advanced UI features, but it instead focuses on doing one thing better than its counterparts -> rendering text as quickly and smoothly as possible.
Alacritty uses Rust’s ecosystem for efficient memory handling, and its codebase is known for being clean, focusing most things on text rendering speed and correctness.
| GPU Acceleration | Startup Time | Config Style | Tabs/Splits | Rendering | Use case |
|---|---|---|---|---|---|
| OpenGL | Instant | YAML (alacritty.yml) | None | Supports ligatures and True Color | Devs who want a lightweight minimal terminal |
Many people pair up Alacritty with TMUX or Zellij, terminal multiplexers, allowing multiple terminal instances to be run and make up for the tab/split feature that it lacks, even out performing terminals with native tab/splitting when it comes to speed!
Alacritty doesn’t come with built-in themes, but has a dedicated repository with themes that the community have created here.
In a way, Alacritty is considered the god father of modern terminal emulators, with some people dying on the hill for it when comparing it to the next two!
Kitty – The feature-rich powerhouse
Feature-rich with image rendering!
Written in C + Python, it is alacritty-like with more features, this is how it originally caught peoples attention – but what maintained their attention was it’s extensive configurations!
The core rendering engine is implemented in C, while the high-level features, configuration and scripting logic are handled in Python.
Not only is Kitty GPU accelerated, but it also optimizes the balance between latency while typing to give that smooth feel while scrolling through the terminal by using vector CPU instructions for maximum performance. And better yet, you can tune these features yourself with ease!
Kitty feels powerful but not bloated, it opens quickly, makes multitasking easier with its native splits and tabs, while handling colors and images beautifuly! You can create horizontal, vertical, or even stacked splits using a few keybindings, perfect for whenever you need to run many instances, servers, debugging code and so on.
Kitty comes with built-in themes but also allows you to customize the terminal however you like! From changing font color, highlighting colors, border ratios and more!
Its config file is clean, though it isn’t as easy to read as Alacritty’s YAML file, but still, for developers, it’s not complicated at all, and their documentation is great to help tweak it to your liking! It isn’t as beginner-friendly as our next terminal emulator, but it’s a developer’s perfect playground due to the number of things you can tweak!
| GPU Acceleration | Startup Time | Config Style | Tabs/Splits | Rendering | Extra features | Use case |
|---|---|---|---|---|---|---|
| OpenGL | Very quick, though slightly slower than Alacritty | Text (kitty.conf) | Native support | Supports ligaratures, True Color and emojis | Inline images, remote control, URL hints and copy-on-select | Devs who want powerful built-in features |
Ghostty – The modern cross-platform contender
Jack of all trades, gorgeous speed
The new kid on the block, but it’s already made quite a name for itself amongst developers! Built by Mitchell Hashimoto, the creator of Vagrant, Terraform and more as a passion project – Ghostty combines Alacritty’s performance, Kitty’s features and a cleaner and modern UX.
It’s written in Zig, uses Metal, Vulkan, or DirectX depending on your OS, running natively on macOS, Linux and Windows. Ghostty uses your OS’s native graphics API to provide smooth GPU rendering.
Ghostty also has it’s own spin when it comes to architecture, the core of Ghostty is libghostty, a cross-playform, minimal dependency library that exposes a C API that can be embedded by any application from anywhere!
This makes it a building block for other platforms, from other IDEs to remote build logs. This makes Ghostty awesome for developers who care about consistency and integration possibilities, making it more than a UI app.
Like Kitty, Ghostty is shipped with built-in themes, including dark/light auto-switching. It also provides small quality-of-life touches that developers love like remembering the last working directory per tab, instant resize rendering, and zero input lag while commands are running.
Even though it’s relatively new, Ghostty has the most active open-source community backing it, along with a transparent roadmap, with Hashimoto publicly sharing its progress.
| GPU Acceleration | Startup Time | Config Style | Tabs/Splits | Rendering | Extra features | Use case |
|---|---|---|---|---|---|---|
| Metal/Vulkan/DirectX | Near-instant | Text (ghostty/config) | Native support | Anti-aliased, ligaratures, true color and emojis | Native window shortcuts per OS, smart copy/paste, async startup, Wayland and macOS native-support | Devs who want a modern experience out of the box for any platform |
Now that we’ve looked at what makes each terminal emulator stand out, I want to share a bit of my own experience experimenting with them.
Experiment! My past experiences with different terminal emulators
The reason why I decided to write this blog in the first place is because the sheer amount of options can be daunting when you’re new to this, and I’m here to tell you that it’s fine if you aren’t sure which terminal emulator you should try out.
When I first installed a linux distribution, I went with Arch Linux with GNOME as the desktop environment because a friend had used GNOME before, so the name was familiar to me. The GNOME terminal had a lot of UI options to tweak using the terminals preferences settings or using Gnome Tweaks, a tool that allows you to change themes, fonts icons and some behavior settings using a UI.
I wanted my terminal to “look cool”, but quickly found out that the GNOME terminal, while providing a decent amount of configuration options — was limited to them as well. Safe to say that I didn’t like that, so I started googling alternatives and was blown away at all of the YouTube videos of people ricing their terminals in different ways, there were even some cool-looking GNOME terminals to be honest. But I wanted something different.
That’s when I really first heard of terminal emulators, on my free time I would watch a tutorial or two on how to “rice” terminals and gave Kitty a shot as it had been popping up the most in my searches. I could add slight transparency to it, add background images to give it a little more personality, and so on. For a while I stuck to it but ended up breaking my OS at some point whoops.
If at first you don’t succeed…
After that, I decided to dual boot my computer with arch linux again, but this time using KDE Plasma instead of GNOME again. KDE comes with their native terminal emulator called Konsole and my first impression of it was great, a lot more customizable than GNOME terminal. I liked how seamless it adapted to whatever overall environment theme I changed to. But again, I got caught up in the ricing videos and decided to try a different terminal emulator – this time I went with Alacritty!
Right away, I noticed the difference in speed compared to Konsole and GNOME, especially, enough that I actually thought to myself how much time I had wasted in the past while booting up terminals(pretty exagerated, but at the time I felt that way). I also tried using TMUX at the time to combo with it, it was fun alternativing between terminal windows, but sadly, this didn’t last long. Windows had a security update back in the day that broke my dual boot(those animals!), I was able to fix it after a while but the damn experience traumatized me so much that I decided to install linux to my personal laptop instead of running a dual boot again.
I loved Arch but wanted something new, so this time I went with Manjaro that uses pacman and the AUR(Arch User Repository) and again, I wanted a different experience. I installed a minimal ISO with GNOME, but quickly replaced it with Hyprland — a window tiling manager. This gives so much potential for multitasking out of the box and I wanted my terminal to look clean, so I went with what I knew I could configure to look awesome and installed Kitty again.
Why?
- Fast and pretty lightweight
- Familiarity, easy configuration to match my theme, adjust the terminals padding and add transparency
- With its tabs and splits, I have even more control over my environment, fits really well with Hyprland’s window management
Conclusion
At the end of the day, the best terminal emulator is the one that fits your workflow. Some developers don’t care much about which terminal emulator they use, while others just get used to whatever came with their operating system decades ago and end up vouching for it like crazed sports fans on every social setting imaginable. If you weren’t aware of the three I mentioned in this blog post, I’d recommend trying them all out and then figuring out what works for you!
Whether you want Alacritty’s pure speed, Kitty’s power features, or Ghostty’s modern polish, all three represent how far we’ve come from the days of green-on-black Teletype machines. And to be honest, one isn’t flat out better than the other.
Your terminal is your workspace, and there are dozens of popular alternatives too, explore to your heart’s content before settling, make it your own!
References
- https://grokipedia.com/page/Computer_terminal
- https://alacritty.org/config-alacritty.html
- https://sw.kovidgoyal.net/kitty/
- https://ghostty.org/docs
- https://wezterm.org/index.html
We want to work with you. Check out our Services page!