Alacritty, Kitty, and WezTerm all deliver 60 fps at 2 ms latency — the choice comes down to architecture

April 2026. Alacritty 0.17.0 ships with TOML 1.1 support and incremental window resizing on Wayland. July 2026. Kitty 0.48.1 lands a bugfix release hot on the heels of 0.48.0, which introduced background window rendering. February 2024. WezTerm publishes its last stable tag — and has been shipping daily nightly builds through GitHub Actions ever since, with zero breakage in practice.

Three terminals, three philosophies, one settled promise: 60 frames per second and sub-2-millisecond keyboard-to-screen latency. In 2026, the GPU rendering war is over — everyone won. What remains is the architectural question.

Why your terminal is using your graphics card

A classical terminal — GNOME Terminal, Konsole, xterm — draws every character on the CPU, line by line, and sends the resulting bitmap to the X server or Wayland compositor. When you scroll through a 10,000-line file in less, the CPU recomputes and redraws the entire character grid on every refresh.

A GPU terminal inverts this logic: each glyph is cached in VRAM, and rendering is delegated to the GPU via OpenGL. Instead of redrawing 80×40 cells per frame, the terminal only sends the handful of cells that actually changed. The result: a cat /dev/urandom that pegged a CPU core at 100% on xterm now barely registers at 5% on any GPU terminal.

All three terminals in this article share this architecture. How they treat it is where they diverge.

Alacritty — purposeful minimalism

Alacritty is written in Rust, maintained by Christian Duerr and the community, with 2,489 commits and 65,100 GitHub stars to its name. Its philosophy is captured in a single line from the README: « Alacritty doesn’t implement tabs or splits — those are best left to a window manager or terminal multiplexer. »

This is not a missing feature. It is an architectural decision. Alacritty is a terminal, full stop. Not a multiplexer. Not a session manager. Just an OpenGL rendering surface for your shell.

That minimalism has two practical consequences.

First, configuration is trivial. A single TOML file (alacritty.toml) controls colors, fonts, key bindings, and window behavior. No scripting language, no hooks, no plugins. You want JetBrains Mono with ligatures? Install the font on your OS and reference it in the config — Alacritty uses FreeType like everyone else, not a custom font renderer. It is slightly slower than Kitty’s in-house engine for complex ligatures, but it avoids rendering surprises.

Second, you need tmux. Without native splits, you manage panes through tmux or your window manager (i3, Sway, Hyprland). This seems like a drawback until you realize that tmux brings session persistence for free — close Alacritty, reopen it, tmux attach restores everything. With Kitty or WezTerm, persistence depends on the built-in daemon, which can crash or lose state.

Alacritty is the choice for people who want one tool per function and are already fluent in tmux. It is also the lightest of the three in memory footprint: roughly 40 MB idle, versus 80-120 MB for Kitty and WezTerm.

Kitty — the Swiss Army terminal

Kitty is the personal project of Kovid Goyal (creator of calibre), written in C and Python, with 18,593 commits and 34,100 stars. If Alacritty is a terminal, Kitty is a platform: GPU rendering, native splits, tabs, a custom font engine with ligature support, a graphics protocol for displaying images and animations, Python extensions called kittens, shell integration, named sessions, and a remote control protocol.

The number that matters: 134.55 MB/s average throughput on the built-in benchmark (kitten __benchmark__), more than double the second-place finisher (GNOME Terminal at 61.83 MB/s). Alacritty scores 54.05 MB/s, WezTerm 48.5 MB/s. Kitty uses SIMD vector instructions to parse the incoming byte stream — an implementation detail that becomes measurable when you cat a 2 GB SQL dump.

Keyboard-to-screen latency is also best in class. With input_delay 0 and sync_to_monitor no, Kitty drops below 1 ms on recent hardware — measured both by Typometer on Linux and by dedicated hardware test rigs on macOS. It is the most responsive terminal you can install in 2026.

Kittens are the real differentiator. A kitten is a Python script that interacts with Kitty through its internal API. kitten ssh replaces the standard SSH client with a tunnel that preserves Kitty’s graphics capabilities on the remote machine. kitten themes lets you pick a color scheme interactively. kitten diff renders colored diffs. kitten icat displays an image directly in the terminal — no external viewer needed. These tools ship with Kitty; no separate installation required.

The catch: Kitty is a vertical ecosystem. Kittens are written for Kitty and only work with Kitty. The graphics protocol is a custom extension — no other terminal implements it. If you build your workflow around Kitty-exclusive features, you are locked in.

WezTerm — the programmable terminal

WezTerm is written in Rust by Wez Furlong (formerly Facebook/Meta), with 8,630 commits and 28,000 stars. Its last stable tag dates back to February 2024, but the project publishes nightlies daily through GitHub Actions — and the community runs them in production without issue.

WezTerm’s proposition is unique: it is a terminal + a multiplexer + a Lua runtime, all in a single binary.

The built-in multiplexer (wezterm-mux-server) is the killer feature. It does exactly what tmux does, minus tmux. You run wezterm on your desktop, SSH into a server, open splits and tabs — and if your SSH connection drops, your sessions survive server-side. Reconnect, and everything is exactly where you left it. WezTerm is the only one of the three that handles this scenario natively, with zero configuration.

Lua configuration is the other pillar. Your wezterm.lua file is a real program, not a souped-up INI file. You can:

-- Dynamically switch color scheme based on time of day
local wezterm = require 'wezterm'
local config = {}
config.color_scheme = wezterm.time.now():hour() > 18 and 'Tokyo Night' or 'Solarized Light'
return config

This programmability appeals to users who want a terminal that adapts to their context without offloading logic into shell scripts. Want to run a specific command when opening a new tab inside a Git repository? A Lua function in wezterm.lua. Want a live Git branch indicator in your status bar? Lua. Want to switch fonts when you plug in an external monitor? Lua.

The price of this flexibility: the documentation. WezTerm has exhaustive reference documentation, but it assumes you already know which component to look for. The learning curve is real — budget an evening to configure your first productive setup.

Cross-platform strength is another decisive advantage. WezTerm runs on Linux, macOS, Windows, and FreeBSD with the exact same Lua config. If you work on a Linux desktop at the office and a Windows laptop on the road, you copy your wezterm.lua over and everything works — fonts, colors, key bindings, multiplexer. Neither Alacritty nor Kitty offers this portability without manual adjustments.

Comparison table

The verdict

GPU rendering has leveled the raw performance playing field. All three terminals are smooth, responsive, and pleasant to use. What distinguishes them is the answer to a single question: how do you want to manage complexity?

Pick Alacritty if you already have a working tmux workflow and do not want a terminal to reinvent what your multiplexer already does well. It is the lightest, the simplest to configure, and the least risky — it breaks nothing because it does almost nothing beyond rendering.

Pick Kitty if you live in the terminal and want maximum features with zero external dependencies. The kittens, raw throughput, and graphics protocol turn it into a platform you will not give up once you adopt it. The lock-in is real, but the productivity gain justifies it.

Pick WezTerm if you work across multiple operating systems, if terminal programmability matters to you, or if you want a built-in multiplexer that survives SSH disconnects without extra configuration. It is the heaviest in resources, but it is also the only one that replaces your terminal, your multiplexer, and your configuration shell scripts all at once.

In 2026, there are no bad GPU terminals. There are only architectural choices. Yours depends on what you are willing to delegate to your terminal — and what you prefer to keep under your own control.

References

• Alacritty v0.17.0 release notes — April 6, 2026
• Kitty performance benchmarks — accessed July 1, 2026
• Kitty v0.48.1 release — July 24, 2026
• WezTerm documentation — accessed July 1, 2026
• WezTerm GitHub — 28,000 stars, accessed July 1, 2026
• Alacritty features documentation — accessed July 1, 2026
• Kitty keyboard protocol — accessed July 1, 2026