Wezterm vs Alacritty vs Kitty: Modern Terminals

Your Terminal Is Probably Fine. Switch Anyway.

Honest truth: your current terminal emulator is good enough. xterm, gnome-terminal, iTerm2 — they all run bash. They all display text. Nobody has ever shipped worse software because they were using the wrong terminal.

But “good enough” is a coward’s answer, and if you’re reading a blog called SumGuy’s Ramblings, you’re not here for “good enough.” You’re here because you spend eight hours a day in a terminal and you want it to be fast, configurable, and — let’s be honest — kind of sick-looking.

So let’s talk about the three GPU-accelerated terminal emulators that actually matter in 2026: WezTerm, Alacritty, and Kitty. All three are fast. All three are open source. All three have been bench-tested to within 5% of each other in real workloads, so anyone claiming one is dramatically faster is selling something.

The real differences are philosophy, features, and how much Lua you’re willing to write.

The Contenders

WezTerm — The Everything Emulator

WezTerm (currently at 20240203-110809 stable) is written in Rust and built by Wez Furlong, who apparently decided that if he was going to write a terminal, he was going to write the terminal. Tabs, splits, multiplexer built right in — no tmux dependency needed. SSH client baked in. Multiple image protocols (Kitty graphics, iTerm2, Sixel). Lua-scripted configuration. Remote mux support so you can detach and reattach sessions across SSH.

It’s the “I want one tool to do everything” terminal.

Alacritty — The Terminal That Refuses to Have Features

Alacritty (v0.14.x as of 2026) is the philosophical opposite. Written in Rust, GPU-accelerated, configured via TOML, and deliberately, intentionally, aggressively minimal. No tabs. No multiplexer. No image support. No ligatures by default. The maintainers will close your feature request if it can be done in tmux or zellij.

That’s not a bug. That’s the whole point. Alacritty does one thing — render text fast — and everything else is your problem. If you already use tmux or zellij, this pairs with them perfectly.

Kitty — The Extensible One

Kitty (v0.35.x) is written in C with Python for the extension layer. It’s fast, it has tabs and windows, and it invented the Kitty Graphics Protocol — the standard that WezTerm and others eventually adopted. It has “kittens,” which are mini scripts/extensions you can write to add behavior. Remote control via socket. SSH integration. Shell integration that tracks prompt zones so you can jump between commands.

Kitty is what happens when a developer decided the terminal needed an API.

Speed: The Benchmark That Doesn’t Matter (But We’re Doing It Anyway)

All three use GPU rendering. All three will feel fast compared to whatever you’re using now. In real workloads — scrolling logs, running cat on a big file, doing git log --oneline -1000 — they’re within 5% of each other. The GPU does the heavy lifting and all three GPU renderers are mature at this point.

Stop benchmarking terminals. Use the one with the features you want. If you genuinely need the absolute fastest terminal for some critical pipeline, you’re in the wrong conversation entirely.

Configuration: Pick Your Poison

This is where the real personality differences show up.

WezTerm: Lua All the Way Down

WezTerm uses a wezterm.lua file. Yes, an actual scripting language, not just a config format. This means you can do logic, loops, conditionals, call external programs. It’s incredibly powerful and also means your config can get weird fast.

-- ~/.config/wezterm/wezterm.lua
local wezterm = require 'wezterm'
local config = wezterm.config_builder()

config.font = wezterm.font('JetBrains Mono', { weight = 'Regular' })
config.font_size = 13.0
config.color_scheme = 'Catppuccin Mocha'
config.window_background_opacity = 0.95
config.hide_tab_bar_if_only_one_tab = true

-- Split pane with Ctrl+Shift+D
config.keys = {
  {
    key = 'd',
    mods = 'CTRL|SHIFT',
    action = wezterm.action.SplitHorizontal { domain = 'CurrentPaneDomain' },
  },
  {
    key = 'd',
    mods = 'CTRL|SHIFT|ALT',
    action = wezterm.action.SplitVertical { domain = 'CurrentPaneDomain' },
  },
}

config.default_prog = { '/usr/bin/zsh', '-l' }

return config

WezTerm reloads config on save by default. No restart needed.

Alacritty: TOML and Nothing Else

Alacritty uses alacritty.toml. It’s clean. It’s straightforward. There’s no scripting because there’s nothing to script — the terminal has no features.

[font]
size = 13.0

[font.normal]
family = "JetBrains Mono"
style = "Regular"

[colors.primary]
background = "#1e1e2e"
foreground = "#cdd6f4"

[window]
opacity = 0.95
padding = { x = 8, y = 8 }

[keyboard]
bindings = [
  { key = "Return", mods = "Shift", action = "ToggleFullscreen" },
]

That’s it. That’s the whole config. If you want tabs, open another terminal window. If you want splits, open tmux. This is Alacritty’s entire answer to feature requests.

Kitty: Plain Text with Power

Kitty uses kitty.conf, which looks like an .ini file but has more semantic depth than it lets on.

font_family      JetBrains Mono
font_size        13.0
background_opacity 0.95

# Tab bar
tab_bar_style    powerline
tab_powerline_style angled

# Shell integration
shell_integration enabled

# Map Ctrl+Shift+D to new split
map ctrl+shift+d launch --location=vsplit

# Remote control via socket
allow_remote_control socket-only
listen_on unix:/tmp/kitty

# Image protocol
term xterm-kitty

Kitty’s config is dense but readable. You can also extend it heavily with kittens — Python scripts that live in ~/.config/kitty/ and can hook into terminal events.

Multiplexer: Who Needs tmux?

WezTerm: Built-In Mux That’s Actually Good

WezTerm has a full multiplexer. Tabs, splits, and — the killer feature — remote mux over SSH. You can attach a WezTerm client to a WezTerm mux server running on a remote host:

# On the remote server, start wezterm mux
wezterm start --daemonize

# On local machine, connect to it
wezterm connect ssh://user@remotehost

This is tmux for people who hate tmux syntax. Your splits, tabs, and session state live on the remote host. Disconnect, reconnect, everything’s still there. And since it’s WezTerm-native, you get proper font rendering, image support, and all the other features on the remote session.

For former tmux users, this is the migration path. Same mental model, better integration.

Kitty: Windows and Sessions

Kitty has tabs and window splits natively. It also has sessions, which let you define a layout in a file and restore it:

new_tab editor
cd ~/projects/myapp
launch nvim .

new_tab server
cd ~/projects/myapp
launch zsh

new_tab logs
cd ~/projects/myapp
launch zsh

kitty --session ~/.config/kitty/sessions/dev.conf

Not quite tmux persistence (it doesn’t survive disconnects), but for local dev workflows it’s solid.

Alacritty: ¯_(ツ)_/¯

Alacritty has no multiplexer. Use tmux. Use zellij. The maintainers are not sorry.

Image Support: The Protocol Wars

This is where it gets genuinely interesting.

The Kitty Graphics Protocol was designed by Kitty’s author and is now the de facto standard for inline terminal images. WezTerm also supports it, plus iTerm2 protocol and Sixel. Alacritty supports none of them.

Kitty: icat

# Display an image inline
kitty +kitten icat /path/to/image.png

# Display from URL
kitty +kitten icat https://example.com/image.jpg

# Works great with tools like ranger, yazi

Kitty’s icat kitten is the gold standard for terminal image display. Pixel-perfect, GPU-rendered, scrolls correctly. If you work with images in the terminal — data science, image processing, file managers — Kitty is the obvious choice.

WezTerm: imgcat

# WezTerm has its own imgcat command
wezterm imgcat /path/to/image.png

# Or use the sixel output from tools that support it
# viu, chafa, etc. work great

WezTerm’s image support is broader — it supports Kitty protocol, iTerm2 protocol, and Sixel — which means more tools work out of the box. Great for compatibility across different image-rendering scripts.

Alacritty: Nothing

No. If you need inline images, Alacritty is not your terminal.

Remote Control API

Kitty: First-Class Remote Control

# List windows
kitty @ ls

# Send text to a specific window
kitty @ send-text --match id:1 "echo hello\r"

# Focus a window
kitty @ focus-window --match id:2

# Create a new window
kitty @ new-window --title "logs"

Kitty’s remote control API is legitimately useful for scripting terminal layouts from external tools or shell scripts. The --match syntax is flexible — match by title, id, or current working directory.

WezTerm: CLI Interface

# List panes and tabs
wezterm cli list

# Spawn a new pane
wezterm cli spawn --pane-id 1 -- htop

# Send text
wezterm cli send-text --pane-id 1 "echo hi\n"

WezTerm’s CLI is a bit less ergonomic than Kitty’s but covers the important bases. Useful for scripting complex layouts.

Alacritty: Still No

No remote control. Start from scratch each time. This is a feature.

Shell Integration and Font Rendering

Both WezTerm and Kitty support OSC 133 shell integration, which marks prompt zones in the terminal output. This unlocks:

• Jump to previous/next prompt (Ctrl+Shift+Up/Down in Kitty)
• Select the output of the last command
• Automatic title bar updates with current directory

# Enable in zsh (add to .zshrc)
# Kitty
if [[ "$TERM" == "xterm-kitty" ]]; then
  source <(kitty + complete setup zsh)
fi

# WezTerm
if [[ "$TERM_PROGRAM" == "WezTerm" ]]; then
  source <(wezterm shell-integration zsh)
fi

Alacritty doesn’t have shell integration because it has no awareness of prompt zones. Your multiplexer handles it.

Ligatures: WezTerm and Kitty both support font ligatures (→, ≠, ≤, etc.) natively. Alacritty does not — though this is less relevant now that most people have accepted that => is just two characters.

Font rendering: All three support FreeType/HarfBuzz on Linux, CoreText on macOS. WezTerm’s font fallback and emoji rendering are arguably the most polished of the three.

Installing All Three

# WezTerm
# Debian/Ubuntu
curl -fsSL https://apt.fury.io/wez/gpg.key | sudo gpg --dearmor -o /etc/apt/trusted.gpg.d/wezterm.gpg
echo 'deb https://apt.fury.io/wez/ * *' | sudo tee /etc/apt/sources.list.d/wezterm.list
sudo apt update && sudo apt install wezterm

# macOS
brew install --cask wezterm

# Cargo (all platforms)
cargo install wezterm

# Alacritty
# Debian/Ubuntu (via cargo, no official deb)
cargo install alacritty

# macOS
brew install --cask alacritty

# Scoop (Windows)
scoop install alacritty

# Kitty
# Linux (official installer)
curl -L https://sw.kovidgoyal.net/kitty/installer.sh | sh /dev/stdin

# macOS
brew install --cask kitty

# Debian/Ubuntu
sudo apt install kitty

The Bottom Line

Here’s the honest breakdown by use case:

Switch to WezTerm if:

• You currently use tmux and want to eliminate the dependency
• You SSH into remote boxes a lot and want session persistence without installing tmux everywhere
• You want one tool that does everything: tabs, splits, images, multiplexing, remote sessions
• You don’t mind writing a bit of Lua

Switch to Alacritty if:

• You already use tmux or zellij and you’re religious about separation of concerns
• You want the simplest possible config that will never surprise you
• You’re on a system where you want zero overhead from terminal features
• “My terminal shouldn’t have opinions” is a philosophy you agree with

Switch to Kitty if:

• You work with images in the terminal (data science, file managers like yazi/ranger, sixel art)
• You want powerful remote control scripting
• You like the idea of extending your terminal with Python kittens
• You want session layouts without fully committing to a multiplexer

All three are genuinely excellent in 2026. The honest answer is that you’ll be happy with any of them, but you’ll be really happy with the one that matches how you already work.

Your 2 AM debugging session will thank you for picking one and actually configuring it instead of reading another comparison article.

Pick one. Configure it properly. Ship something.

Related Reading

• Difftastic: Structural Diff That Makes Sense
• gitui vs lazygit: Two Git TUIs Compared
• Mise Deep Dive: Tasks, Tools, Env Vars
• Yazi: The Terminal File Manager Replacing Ranger
• Atuin: Shell History That Actually Works Across Machines