Kitty: A GPU-Rendered Terminal That Doesn’t Feel Like a Traditional Terminal

Have you ever done this in a terminal —

cat a log file that’s tens of MB in size, watching the screen scroll line by line, stuttering as it goes?

Or wanted to view an image directly in the terminal, only to find you need to open a separate image viewer?

Or opened a bunch of tmux windows, only to lose track of which split is which?

The answer to these problems might not be a terminal you’ve used for ten years, but a new face called Kitty.

What Makes Kitty Different

Kitty’s core difference boils down to one sentence: its rendering goes through the GPU, not the CPU.

Traditional terminals (GNOME Terminal, Konsole, xterm) do all text rendering on the CPU. This was fine in the 80-column era, but nowadays terminals run tail -f, docker logs, cat application.log — output that can be tens of thousands of lines. CPU rendering of text frames has to recalculate glyphs, composite bitmaps, and push them to the display for every new line. When data volumes get large, the frame rate tanks.

Kitty moves the entire rendering pipeline to the GPU via OpenGL. The result: scrolling through a million lines of logs feels no different from scrolling through a hundred lines — both are buttery smooth.

And GPU rendering has the added benefits of crisp font rendering at any size, perfect ligature display, and emoji that doesn’t turn into a blurry mess.

Who Made Kitty

The author is Kovid Goyal — yes, the same Kovid Goyal who made the Calibre e-book manager.

One person who wrote two widely-used open source software packages, both of extremely high quality. That’s probably the definition of a “genius programmer.”

Kitty is written in a mix of C and Python — the core rendering layer uses C for performance, while the plugin system (called “Kittens”) uses Python for easy extensibility.

Search for kovidgoyal/kitty on GitHub — 26k+ stars and very active.

Features That Make It Hard to Go Back

View Images Directly in the Terminal

Using the built-in icat kitten, you can display images directly in the terminal:

kitty +kitten icat photo.jpg

Supports PNG, JPEG, GIF, and even animated GIFs in the terminal.

What does this mean? You can view charts, screenshots, and even memes in the terminal without leaving the command line.

Built-in Splits and Tabs — No tmux Needed

Kitty has its own full split-screen system supporting multiple layouts:

• Stack — Only one window visible at a time, switch like tabs
• Tall — Main window on the left, narrow pane on the right
• Fat — Main window on top, narrow pane on bottom (opposite of Tall)
• Grid — Evenly arranged

Shortcuts use the Ctrl+Shift combination, which doesn’t conflict with shell shortcuts — Ctrl+C still sends SIGINT, Ctrl+R still does reverse search.

Browser users will find this shortcut scheme familiar — it’s like the browser’s Ctrl+T/Ctrl+W with a Shift added.

Kittens: Kitty’s Plugin System

Kitty’s extensions are called “Kittens,” written in Python. Several useful ones come built-in:

• icat — Display images in the terminal
• diff — In-terminal file diff (much friendlier than git diff)
• ssh — Enhanced SSH client that preserves all of Kitty’s rendering capabilities
• hints — Quickly select URLs or file paths on screen
• clipboard — Clipboard operations

You can also write your own kittens — a dozen lines of Python can make a useful little tool.

Remote Control

Kitty supports IPC control — you can tell Kitty from a script to create new tabs, change font sizes, or retrieve scroll buffer contents.

For example, sending Kitty a command:

kitty @ new-window --title "htop" htop

This is very useful in automated workflows.

Session Management

Kitty supports session files that define which windows to open on startup, their split layout, and what command to run in each window.

Example session file:

# ~/.config/kitty/session.conf
new_tab backend
launch cd ~/project/backend && nvim
launch cd ~/project/backend && npm run dev

new_tab monitor
layout tall
launch htop
launch cd ~/project/logs && tail -f app.log

Load it at startup:

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

This restores your development environment with one command, without having to manually open windows each time.

Installing on Ubuntu

Method 1: APT Install (Simplest, but version may be older)

sudo apt update
sudo apt install kitty

After installation, you can find Kitty in the application menu.

Method 2: Official Script Installation (Recommended, gets the latest version)

curl -L https://sw.kovidgoyal.net/kitty/installer.sh | sh /dev/stdin

This script installs Kitty to ~/.local/kitty.app/ and creates symlinks.

Create Desktop Icon

If Kitty doesn’t appear in the application menu after method 2, create it manually:

sudo ln -s ~/.local/kitty.app/share/applications/kitty.desktop /usr/share/applications/
sudo ln -s ~/.local/kitty.app/share/icons/hicolor/256x256/apps/kitty.png /usr/share/icons/

Launch

Type kitty in the terminal, or search for Kitty in the application menu.

Basic Configuration

Kitty’s configuration file is at ~/.config/kitty/kitty.conf. If it doesn’t exist, just create it.

A recommended configuration for beginners:

# ~/.config/kitty/kitty.conf

# Font
font_family      JetBrains Mono
font_size        12

# Cursor style
cursor_shape     beam
cursor_blink_interval 0

# Scrollback buffer lines
scrollback_lines 10000

# Disable annoying beep
enable_audio_bell no

# Tab bar style
tab_bar_style    powerline
tab_powerline_style slanted

# Background transparency 0.95 (requires window manager support)
background_opacity 0.95

# Shell integration
shell_integration enabled

No need to restart Kitty after configuration — it supports hot-reloading, so changes take effect as soon as you save.

Comparison with Other GPU Terminals

If all you want is a “pure speed” terminal, Alacritty might suit you better — it’s even lighter than Kitty.

But if what you want is a terminal that can “display images, do splits, write plugins, and be remotely controlled,” Kitty’s feature set currently has no rival.

Summary

Kitty is the terminal I’ve used that strikes the best balance between “performance and features.”

It’s not as minimalist as Alacritty, but it adds image display, built-in splits, and the Kitten plugin system — things that genuinely boost productivity. It’s not as bloated as Terminator, but with GPU acceleration, scrolling through a million lines of logs is buttery smooth.

If you’re still using Ubuntu’s built-in GNOME Terminal, or you find tmux splits too cumbersome, spend ten minutes installing Kitty and give it a try — maybe it’s the terminal you’ve been looking for all along.