Kitty Terminal: GPU-Accelerated Terminal Guide

Posted: April 14, 2026 to Technology.

Kitty is a GPU-accelerated terminal emulator written in C and Python that offloads rendering to the graphics card via OpenGL, delivering noticeably smoother scrolling, faster output, and richer visual capabilities than traditional CPU-rendered terminals. Created by Kovid Goyal (also the developer behind the Calibre ebook manager), kitty runs on Linux and macOS and provides features that go well beyond basic terminal emulation: an image display protocol, a Python-based plugin system called kittens, remote control via IPC, ligature rendering, and sophisticated layout management within a single window. If your workflow involves AI model training, cybersecurity assessments, or infrastructure management, kitty is built for the kind of heavy terminal use those fields demand.

At Petronella Technology Group, we run kitty on every Linux workstation alongside tiling Wayland compositors like Niri and Hyprland. Our engineers use it for AI development, GPU monitoring, security research, and remote server management across our fleet. This guide documents our production configuration and the workflows we have refined over years of daily use.

What Kitty Is and Why It Exists

Most terminal emulators render text using the CPU. They draw each glyph into a bitmap, composite the result, and push the final image to the display. This approach worked fine when terminals displayed 80 columns of monospaced ASCII, but modern development workflows push terminals far harder. Running cat on a multi-megabyte log file, scrolling through continuous AI training output, or tailing high-throughput application logs all reveal the performance ceiling of CPU rendering. Frames drop, scrolling stutters, and the terminal becomes the bottleneck rather than the process running inside it.

Kitty was built to eliminate that bottleneck. By using OpenGL to render text on the GPU, kitty offloads the entire drawing pipeline to hardware specifically designed for parallel rendering tasks. The result is consistently smooth output regardless of how fast data arrives. Scrolling through 100,000 lines of log output feels the same as scrolling through 100 lines. GPU rendering also enables features that would be impractical on the CPU, most notably kitty's graphics protocol for displaying images directly in the terminal.

Kovid Goyal started kitty in 2017 because no existing terminal emulator met his requirements for performance, extensibility, and correctness. The core rendering engine is written in C for speed, while the configuration layer, plugin system (kittens), and many higher-level features are written in Python for accessibility and rapid iteration. This hybrid approach gives kitty the rendering performance of a C application with the extensibility of a Python one.

Kitty is cross-platform across Linux and macOS. It does not support Windows natively; Windows users typically run kitty inside WSL2 with an X server or Wayland bridge. On Linux, kitty runs natively under both X11 and Wayland, making it compatible with every major compositor and desktop environment. It integrates particularly well with tiling compositors where terminal windows are the primary interface.

Key Features That Set Kitty Apart

GPU-Accelerated Rendering

Kitty uses OpenGL for all text rendering. Each glyph is rasterized once into a texture atlas, and subsequent draws reference the atlas rather than re-rasterizing. This means rendering cost scales with the number of unique glyphs rather than the number of characters on screen. For development workflows where the terminal displays thousands of characters per frame (build output, log tailing, large file browsing), the difference compared to CPU rendering is measurable. Scroll latency drops, frame drops disappear, and high-throughput output no longer freezes the display.

Ligature and Font Rendering

Kitty renders font ligatures natively, which matters for developers using fonts like Nerd Fonts variants of JetBrains Mono, Fira Code, or Cascadia Code. Ligatures combine multi-character sequences like !=, =>, >=, and |> into single visual glyphs, improving code readability. Many terminal emulators either do not support ligatures at all or implement them incorrectly. Kitty handles them through HarfBuzz shaping, the same text shaping engine used by Firefox and Chrome.

Multiple Windows, Tabs, and Layouts

Kitty manages multiple terminal sessions internally without requiring a terminal multiplexer like tmux. A single kitty instance supports multiple OS windows, each containing multiple tabs, each containing multiple splits arranged in configurable layouts. This is not a replacement for tmux in every scenario (tmux provides session persistence across disconnections), but for local development it eliminates the complexity of managing a multiplexer when all you need is split panes and tabs.

Remote Control via IPC

Kitty exposes a rich IPC interface through the kitten @ command (or kitty @ in older versions). You can open new windows, change layouts, send text to specific windows, set window titles, change colors, and query window state, all from scripts or other terminal sessions. This turns kitty into a programmable terminal that integrates with shell scripts, CI pipelines, and monitoring tools.

Extensible via Kittens

Kittens are Python programs that run within kitty's process and can interact with the terminal at a low level. Built-in kittens handle tasks like displaying images, showing diffs, picking URLs from scrollback, and inputting Unicode characters. You can write custom kittens to add any functionality you need. The kitten API has access to screen contents, window management, and input handling.

Installation: Package Managers, Binaries, Source, and NixOS

Linux Package Managers

Kitty is available in the official repositories of every major Linux distribution:

# Arch Linux
sudo pacman -S kitty

# Fedora
sudo dnf install kitty

# Ubuntu / Debian
sudo apt install kitty

# openSUSE
sudo zypper install kitty

Distribution packages sometimes lag behind upstream releases. For the latest version, use the official binary installer.

Official Binary Installer

Kovid Goyal provides a self-updating binary installer that works on any Linux distribution:

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

This installs kitty to ~/.local/kitty.app/ and creates symlinks in ~/.local/bin/. Update to the latest version at any time by running the same command. The binary is statically linked against most dependencies, so it runs on virtually any modern Linux system.

macOS

On macOS, install via Homebrew or the official DMG:

# Homebrew
brew install --cask kitty

# Or download the DMG from:
# https://github.com/kovidgoyal/kitty/releases

NixOS (Declarative Configuration)

On NixOS, kitty integrates into your declarative system configuration. This is our team's preferred approach because it makes terminal configuration reproducible and version-controlled alongside the rest of the system. For more on how we use NixOS, see our NixOS AI infrastructure guide.

# configuration.nix or home.nix
programs.kitty = {
  enable = true;
  font = {
    name = "JetBrainsMono Nerd Font";
    size = 12;
  };
  settings = {
    scrollback_lines = 10000;
    enable_audio_bell = false;
    window_padding_width = 4;
    background_opacity = "0.95";
    confirm_os_window_close = 0;
  };
  theme = "Tokyo Night";
};

Home Manager generates kitty.conf from these Nix expressions, so you never edit the config file directly. Changes apply on home-manager switch or nixos-rebuild switch.

Building from Source

Building kitty from source requires Python 3.8+, a C compiler, and several libraries (librsync, HarfBuzz, OpenGL). The build system is straightforward:

git clone https://github.com/kovidgoyal/kitty.git
cd kitty
python3 setup.py linux-package

The resulting package appears in linux-package/. This approach is useful if you need to patch kitty or test development features before they reach a release.

Configuration Deep Dive: kitty.conf

Kitty reads its configuration from ~/.config/kitty/kitty.conf. The format uses simple key value pairs, one per line. Changes are applied immediately when you reload the config (ctrl+shift+f5 by default) without restarting kitty. The configuration file supports include directives for splitting settings across multiple files, which is useful for separating color themes from functional settings.

Font Configuration

Font selection is one of the most impactful settings in any terminal. Kitty supports specifying different fonts for regular, bold, italic, and bold-italic variants. We recommend Nerd Fonts patched variants because they include icons used by status bars, file managers, and shell prompts like Starship.

# Font settings
font_family      JetBrainsMono Nerd Font
bold_font        JetBrainsMono Nerd Font Bold
italic_font      JetBrainsMono Nerd Font Italic
bold_italic_font JetBrainsMono Nerd Font Bold Italic
font_size 12.0

# Adjust line height and character spacing
adjust_line_height 110%
adjust_column_width 0

# Disable ligatures when cursor is on top of the character
disable_ligatures cursor

The disable_ligatures cursor setting is a practical choice: ligatures render normally during reading but break apart when the cursor touches them, so you can see the individual characters when editing. Other options are never (always show ligatures) and always (never show ligatures).

Color Scheme Setup

Kitty ships with a built-in theme selection tool. Run kitty +kitten themes to browse and preview hundreds of themes interactively. For manual configuration, define colors directly in kitty.conf. Here is a Tokyo Night configuration:

# Tokyo Night color scheme
foreground #a9b1d6
background #1a1b26

# Black
color0  #15161e
color8  #414868

# Red
color1  #f7768e
color9  #f7768e

# Green
color2  #9ece6a
color10 #9ece6a

# Yellow
color3  #e0af68
color11 #e0af68

# Blue
color4  #7aa2f7
color12 #7aa2f7

# Magenta
color5  #bb9af7
color13 #bb9af7

# Cyan
color6  #7dcfff
color14 #7dcfff

# White
color7  #c0caf5
color15 #c0caf5

# Selection and cursor
selection_foreground #a9b1d6
selection_background #33467c
cursor #c0caf5
cursor_text_color #1a1b26

For the Catppuccin Mocha theme, another popular choice among developers:

# Catppuccin Mocha
foreground #cdd6f4
background #1e1e2e
color0  #45475a
color8  #585b70
color1  #f38ba8
color9  #f38ba8
color2  #a6e3a1
color10 #a6e3a1
color3  #f9e2af
color11 #f9e2af
color4  #89b4fa
color12 #89b4fa
color5  #f5c2e7
color13 #f5c2e7
color6  #94e2d5
color14 #94e2d5
color7  #bac2de
color15 #a6adc8

You can also separate your color scheme into its own file (e.g., ~/.config/kitty/themes/tokyo-night.conf) and include it with include themes/tokyo-night.conf. This makes switching themes a one-line change.

Tab and Window Management

Kitty's built-in window management can replace tmux for many local workflows. Configure tabs and windows with these settings:

# Tab bar
tab_bar_edge top
tab_bar_style powerline
tab_powerline_style slanted
tab_title_template "{index}: {title}"
active_tab_foreground   #1a1b26
active_tab_background   #7aa2f7
inactive_tab_foreground #a9b1d6
inactive_tab_background #24283b
tab_bar_background #1a1b26

# Window settings
window_padding_width 4
placement_strategy center
hide_window_decorations yes
confirm_os_window_close 0

# Inactive window dimming
inactive_text_alpha 0.7

Keybindings for Window and Tab Control

# Tab management
map ctrl+shift+t new_tab
map ctrl+shift+q close_tab
map ctrl+shift+right next_tab
map ctrl+shift+left previous_tab
map ctrl+shift+. move_tab_forward
map ctrl+shift+, move_tab_backward

# Window (split) management
map ctrl+shift+enter new_window
map ctrl+shift+w close_window
map ctrl+shift+] next_window
map ctrl+shift+[ previous_window

# Move focus between splits
map ctrl+shift+h neighboring_window left
map ctrl+shift+l neighboring_window right
map ctrl+shift+k neighboring_window up
map ctrl+shift+j neighboring_window down

# Resize windows
map ctrl+shift+r start_resizing_window

Layout Modes

Kitty provides several built-in layout modes for arranging splits within a tab. Each layout determines how windows are positioned when you open new splits:

# Enable specific layouts (order determines cycle order)
enabled_layouts tall,fat,grid,horizontal,vertical,splits,stack

• Tall: One main window on the left, remaining windows stacked on the right. Ideal for code editing with auxiliary terminals.
• Fat: One main window on top, remaining windows arranged along the bottom. Good for monitoring dashboards.
• Grid: Windows arranged in a grid pattern. Scales well when you have four or more windows open.
• Horizontal: All windows side by side in columns. Works well on ultrawide monitors.
• Vertical: All windows stacked in rows. Useful on portrait-oriented displays.
• Splits: Manual splitting similar to tmux, where each split can be horizontal or vertical. Provides the most control over layout.
• Stack: Only one window visible at a time, with keybindings to cycle between them. Useful on small screens or when you need maximum space for a single task.

Cycle between layouts with ctrl+shift+l by default. You can also bind specific layouts directly:

map ctrl+shift+alt+t goto_layout tall
map ctrl+shift+alt+g goto_layout grid
map ctrl+shift+alt+s goto_layout splits

Scrollback Buffer and Pager

Kitty stores terminal output in a scrollback buffer that you can search and browse. Configure the buffer size and pager:

# Scrollback
scrollback_lines 10000
scrollback_pager_history_size 100

# Use less as the scrollback pager (default)
scrollback_pager less --chop-long-lines --RAW-CONTROL-CHARS +INPUT_LINE_NUMBER

# Or use Neovim for scrollback browsing with full search
scrollback_pager bash -c 'nvim -c "set nonumber norelativenumber" -c "map q :q!" -'

The scrollback_pager_history_size controls how many megabytes of scrollback are piped to the pager (in addition to the regular scrollback_lines). Setting it to 100 means up to 100 MB of history is available when you open the scrollback pager. The Neovim pager option is popular because it gives you full Vim keybindings and regex search within your scrollback history.

Kittens: Kitty's Python Plugin System

Kittens are Python programs that extend kitty's functionality. They run within kitty's process and have access to the terminal's internal state, including screen contents, window layout, and input handling. Kitty ships with several built-in kittens, and you can write custom ones for any workflow-specific need.

Built-in Kittens

icat (Image Display): Displays images directly in the terminal using the kitty graphics protocol. This is the most commonly used kitten and one of kitty's signature features.

# Display an image in the terminal
kitty +kitten icat image.png

# Display with a specific width
kitty +kitten icat --place 80x24@0x0 image.png

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

diff: A syntax-highlighted diff viewer for files and directories. Renders diffs in the terminal with color-coded additions, deletions, and context, similar to delta or diff-so-fancy but integrated directly into kitty.

# Compare two files
kitty +kitten diff file_a.py file_b.py

# Compare directories
kitty +kitten diff dir_a/ dir_b/

# Use as git difftool
git config --global diff.tool kitty_diff
git config --global difftool.kitty_diff.cmd 'kitty +kitten diff $LOCAL $REMOTE'

hints: Scans the terminal screen for patterns (URLs, file paths, line numbers, IP addresses, hashes) and lets you select one with a keyboard shortcut. Selected items can be opened, copied to clipboard, or inserted into the terminal.

# Open URL hints
map ctrl+shift+e open_url_with_hints

# Custom hint for selecting file paths
map ctrl+shift+p kitten hints --type path --program -

# Select git commit hashes
map ctrl+shift+g kitten hints --type hash --program -

unicode_input: An interactive Unicode character picker. Press ctrl+shift+u to search for Unicode characters by name and insert them at the cursor position. Useful for inserting special characters, mathematical symbols, or emoji without leaving the terminal.

SSH kitten: A replacement for the standard ssh command that transparently transfers your kitty configuration (shell integration, terminfo, color scheme) to the remote server. This means you get the same terminal experience on remote machines without manually installing kitty or copying config files.

# Use the SSH kitten instead of plain ssh
kitty +kitten ssh user@server

# Or create a shell alias
alias s="kitty +kitten ssh"

The SSH kitten transfers the kitty terminfo entry to the remote host, so programs like Neovim and tmux render correctly without the common "unknown terminal type" errors. It also enables the kitty graphics protocol over SSH, letting you display images from remote servers in your local terminal.

Writing Custom Kittens

Custom kittens are Python scripts placed in ~/.config/kitty/kittens/. A kitten has two entry points: main() for the kitten's own process and an optional handle_result() that runs in kitty's process and can modify terminal state.

# ~/.config/kitty/kittens/quick_note.py
"""A kitten that opens a floating editor for quick notes."""

import subprocess
import tempfile
import os

def main(args):
    """Runs in a subprocess."""
    note_file = os.path.expanduser("~/notes/quick.md")
    os.makedirs(os.path.dirname(note_file), exist_ok=True)
    subprocess.run(["nvim", note_file])
    return note_file

def handle_result(args, result, target_window_id, boss):
    """Runs in kitty's process after main() returns."""
    if result:
        boss.display_notification("Note saved", f"Wrote to {result}")

# Bind the custom kitten to a key in kitty.conf
map ctrl+shift+n kitten kittens/quick_note.py

The kitten API provides access to window management, tab control, screen contents, and more. Consult the kitty documentation at sw.kovidgoyal.net/kitty/kittens/custom/ for the full API reference.

Kitty Graphics Protocol: Images in Your Terminal

The kitty graphics protocol is one of the most significant terminal innovations in recent years. It defines a standard mechanism for terminal applications to display raster images (PNG, JPEG, GIF, BMP) and animations directly within the terminal grid. Unlike older approaches such as Sixel graphics or iTerm2's inline image protocol, the kitty protocol is efficient, well-documented, and has been widely adopted by third-party tools.

How It Works

Applications send images to kitty using special escape sequences. The image data is transmitted as base64-encoded chunks embedded in these escape sequences, or via shared memory for large images. Kitty decodes the image, uploads it to the GPU as a texture, and composites it alongside the text grid. Images occupy a specified rectangular region of the terminal measured in cells or pixels. Multiple images can be displayed simultaneously, and they persist through scrolling and screen updates until explicitly cleared.

Displaying Images with icat

# Basic image display
kitty +kitten icat photo.png

# Display with placement control
kitty +kitten icat --align center --scale-up image.jpg

# Display animated GIFs
kitty +kitten icat animation.gif

# Display in a specific terminal region (WxH@XxY)
kitty +kitten icat --place 40x20@5x3 diagram.png

Tools That Support the Kitty Graphics Protocol

The protocol has been adopted by a growing ecosystem of terminal applications:

• ranger / yazi: File managers that show image previews when browsing directories containing photos, screenshots, or diagrams.
• matplotlib: The Python plotting library can render charts directly in the kitty terminal via the kitty backend, eliminating the need to open a separate window for plots.
• timg: A dedicated terminal image viewer that uses kitty graphics when available.
• chafa: A versatile image renderer that supports multiple terminal protocols including kitty graphics.
• neovim: With plugins like image.nvim, Neovim can display inline images in markdown files, Jupyter notebooks, and documentation.
• viu: A Rust-based terminal image viewer with kitty graphics support.
• Plotext: A Python library for plotting directly in the terminal that leverages kitty graphics for higher resolution output.

Using the Graphics Protocol for AI Development

The graphics protocol is particularly valuable for AI and machine learning workflows. Displaying training loss curves, confusion matrices, model architecture diagrams, and dataset sample images directly in the terminal eliminates the context switch of opening a browser or image viewer. When you are SSH'd into a GPU server training a model, being able to visualize results in the same terminal window where you launched the training run keeps your workflow cohesive.

# Example: Display a matplotlib chart in kitty
import matplotlib
matplotlib.use("module://matplotlib-backend-kitty")
import matplotlib.pyplot as plt

plt.plot([1, 2, 3, 4], [10, 20, 25, 30])
plt.title("Training Loss")
plt.show()  # Renders directly in the kitty terminal

Install the matplotlib kitty backend with pip install matplotlib-backend-kitty. Once configured, any matplotlib plt.show() call renders the chart inline in your terminal session rather than opening a GUI window. This works locally and over SSH when using the kitty SSH kitten.

Kitty for AI Development Workflows

Our engineering team at Petronella uses kitty daily for AI development across local workstations and remote GPU servers. These are the workflow patterns we rely on.

Monitoring Training Runs with Rich Output

During model training, kitty's GPU rendering handles the high-throughput log output without dropping frames or stuttering. Combined with the graphics protocol, you can display training charts inline while tailing log files. Use kitty's layout system to arrange your workspace:

# Session script: ai-training-workspace.sh
#!/bin/bash
# Create a kitty session for AI training monitoring

# Open the training tab with splits
kitty @ launch --type=tab --title="Training" --cwd ~/projects/model
kitty @ launch --type=window --title="GPU Monitor" --cwd ~/projects/model -- watch -n 1 nvidia-smi
kitty @ launch --type=window --title="Logs" --cwd ~/projects/model -- tail -f training.log
kitty @ goto-layout tall

GPU Monitoring with Multiple Layouts

When running multi-GPU training jobs, kitty's grid layout provides an at-a-glance view of all GPUs. For our hardware infrastructure, which includes NVIDIA RTX workstations and data center GPUs, we use a kitty session that monitors each GPU alongside the training process:

# Launch a monitoring grid
kitty @ goto-layout grid
kitty @ launch --title="GPU 0" -- nvidia-smi -i 0 -l 2
kitty @ launch --title="GPU 1" -- nvidia-smi -i 1 -l 2
kitty @ launch --title="GPU 2" -- nvidia-smi -i 2 -l 2
kitty @ launch --title="GPU 3" -- nvidia-smi -i 3 -l 2

Remote Control for Scripting Complex Workflows

Kitty's IPC system allows complete automation of terminal layout and content. You can script your entire development environment setup:

# kitty.session file for AI development
new_tab code
layout splits
cd ~/projects/ml-pipeline
launch nvim .
launch --location=hsplit bash

new_tab monitoring
layout grid
launch watch -n 5 nvidia-smi
launch htop
launch tail -f /var/log/syslog

new_tab remote
launch kitty +kitten ssh gpu-server-1
launch kitty +kitten ssh gpu-server-2

Start kitty with the session file: kitty --session ai-dev.session. Every time you open kitty, your entire workspace is pre-configured with the correct layout, tabs, and running processes.

SSH Kitten for GPU Server Connections

The SSH kitten is essential for remote AI development. When you SSH into a GPU server with the kitty SSH kitten, your color scheme, shell integration, and the graphics protocol all work on the remote machine. You can visualize training results on the remote server and see the images rendered in your local terminal. No X forwarding, no VNC, no Jupyter notebook required for basic visualization.

# Connect to GPU server with full kitty features
kitty +kitten ssh user@gpu-server.internal

# On the remote server, icat works
kitty +kitten icat /results/confusion_matrix.png

# Matplotlib renders to your local terminal
python3 -c "
import matplotlib
matplotlib.use('module://matplotlib-backend-kitty')
import matplotlib.pyplot as plt
plt.plot(loss_history)
plt.show()
"

Kitty for Cybersecurity Workflows

Security assessments generate substantial terminal output: scan results, log analysis, packet captures, and report drafting all happen in the terminal. Kitty's features map directly to these tasks.

Scrollback Search for Log Analysis

During incident response or log analysis, the ability to search through extensive scrollback history is critical. Configure kitty with a generous scrollback buffer and a powerful pager:

# For security work, increase scrollback significantly
scrollback_lines 50000
scrollback_pager_history_size 500

# Use Neovim as pager for regex search capability
scrollback_pager bash -c 'nvim -c "set nonumber norelativenumber" -c "map q :q!" -'

With this configuration, you can press ctrl+shift+h to open the entire scrollback in Neovim, then use Vim's search (/pattern) and regex capabilities to find specific log entries, IP addresses, or error signatures. This is faster and more flexible than piping output through grep after the fact.

Multiple Window Layouts During Assessments

Security assessments require simultaneous visibility into multiple data streams. Use kitty's layout system to arrange your workspace for different phases:

# Reconnaissance layout: wide scanner output, narrow status
kitty @ goto-layout tall
# Main window: nmap, Nessus, or other scanner output
# Side windows: target list, notes, network diagram

# Exploitation layout: side-by-side panes
kitty @ goto-layout vertical
# Top: target shell or Burp output
# Bottom: source code, notes, or documentation

# Reporting layout: full width for documentation
kitty @ goto-layout stack
# Single visible window for report writing

Secure Shell Integration

Kitty's SSH kitten offers security advantages over plain SSH for professional use. It transfers the terminfo database without requiring installation on the target, reduces TERMCAP/TERM-related information leaks, and enables kitty's protocol features on the remote host. For our AI and security infrastructure, the SSH kitten provides a consistent, capable terminal experience across every machine in the fleet.

Comparison: Kitty vs Ghostty vs Alacritty vs WezTerm

The GPU-accelerated terminal space has become competitive. Here is how kitty compares to the major alternatives as of 2026.

When to Choose Each Terminal

Choose kitty if you need the graphics protocol for image display, want a Python plugin system, rely on IPC for automation, or work heavily over SSH with the SSH kitten. Kitty has the most mature feature set among GPU terminals and the largest ecosystem of tools built around its protocol.

Choose Ghostty if you are primarily on macOS and want a terminal that feels native to the platform. Ghostty, created by Mitchell Hashimoto (HashiCorp founder), focuses on native platform integration and rendering correctness. It supports the kitty graphics protocol and has excellent font rendering, but it does not have a plugin system or extensive IPC.

Choose Alacritty if you want the simplest possible GPU terminal with minimal features and maximum predictability. Alacritty deliberately does not include tabs, splits, ligatures, or an image protocol. It does one thing (render a terminal quickly) and delegates everything else to tmux or your window manager. This philosophy appeals to users who find kitty's feature set excessive.

Choose WezTerm if you need cross-platform support including Windows, or if you want Lua scripting for deep configuration customization. WezTerm supports both the iTerm2 and kitty image protocols, provides multiplexer functionality, and runs natively on Windows, macOS, and Linux. Its Lua configuration is more powerful than kitty.conf but has a steeper learning curve.

Performance Tuning

Kitty is fast out of the box, but specific settings can improve performance for edge cases like high-throughput output or resource-constrained environments.

GPU Settings

# Sync to monitor refresh rate (reduces tearing)
sync_to_monitor yes

# Repaint delay in milliseconds (lower = more responsive, higher = less CPU)
repaint_delay 10

# Input delay in milliseconds
input_delay 3

# GPU driver workaround (try if you see rendering glitches on older GPUs)
# force_ltr no

Reducing Latency

For the lowest possible input latency, which matters for interactive applications like Neovim or games in the terminal:

# Minimize delays
repaint_delay 5
input_delay 1

# Disable visual bell (saves a repaint)
enable_audio_bell no
visual_bell_duration 0

# Disable cursor blinking (saves repaints)
cursor_blink_interval 0

Memory Optimization

# Reduce scrollback for lower memory usage
scrollback_lines 2000

# Limit pager history
scrollback_pager_history_size 10

# Close windows that are no longer needed rather than leaving them open
# Kitty's per-window scrollback buffer consumes memory proportional to lines stored

Benchmarking

To measure terminal rendering performance, use standard benchmarks:

# Sequential output throughput test
time seq 1 1000000

# High-frequency update test (renders many frames)
cat /dev/urandom | base64 | head -c 10000000

# Compare results between terminals on the same hardware

On modern hardware with a dedicated GPU, kitty typically renders 2 to 5 times faster than CPU-based terminals on throughput benchmarks. The difference is most noticeable during sustained high-output scenarios like build logs, large file displays, and continuous monitoring output.

Frequently Asked Questions

Does kitty work on Wayland?

Yes. Kitty runs natively on both Wayland and X11. On Wayland, it uses the native Wayland protocol for window management and input. On X11, it uses the X protocol. Detection is automatic; kitty checks for the WAYLAND_DISPLAY environment variable and uses Wayland if available. Kitty works well with every major Wayland compositor including Niri, Hyprland, Sway, GNOME, and KDE.

Can I use kitty without a GPU?

Kitty requires OpenGL 3.3 or later. On systems without a dedicated GPU, kitty uses the integrated graphics (Intel HD, AMD APU) or software rendering via Mesa's LLVMpipe. Most modern CPUs with integrated graphics run kitty without issues. Truly headless servers or systems with no OpenGL support at all cannot run kitty; use a CPU-based terminal like Alacritty (in software mode) or a traditional terminal emulator instead.

How do I make kitty the default terminal on Linux?

Set kitty as the default terminal using your desktop environment's settings or the update-alternatives system. On most distributions:

# Debian/Ubuntu
sudo update-alternatives --set x-terminal-emulator /usr/bin/kitty

# For XDG-compliant environments
export TERMINAL=kitty
# Add to ~/.bashrc, ~/.zshrc, or equivalent

On NixOS with a tiling compositor, set your terminal spawn keybinding to kitty in your compositor configuration.

Does kitty support multiplexing like tmux?

Kitty provides tabs, splits, and layouts that handle many of the same use cases as tmux for local sessions. The key difference is session persistence: if kitty closes, your terminal sessions close with it. Tmux sessions persist independently of the terminal. For local development, kitty's built-in multiplexing is often sufficient. For remote servers where you need sessions to survive network disconnections, use tmux or screen inside kitty. The two work well together.

Why does my scrollback not work in tmux inside kitty?

When running tmux inside kitty, tmux manages its own scrollback buffer and intercepts scroll events. Kitty's scrollback only captures output that reaches kitty directly. To use tmux's scrollback, enter tmux's copy mode (usually ctrl+b [). Alternatively, configure tmux to use kitty's scrollback pager by setting tmux's terminal override to support kitty's extended keyboard protocol.

How do I transfer my kitty config to a new machine?

Copy your ~/.config/kitty/ directory to the new machine. On NixOS, your kitty configuration is part of your system flake, so it deploys automatically when you build the new machine's configuration. For non-NixOS setups, store your kitty config in a dotfiles Git repository and symlink it into place. The SSH kitten handles temporary config transfer for remote sessions automatically.

Is kitty safe for security-sensitive work?

Kitty is open source, actively maintained, and undergoes regular security reviews. The GPU rendering pipeline processes only terminal escape sequences and text; it does not execute arbitrary code. The SSH kitten uses standard SSH for transport and does not weaken the security model. Kitty supports clipboard access controls (configurable via clipboard_control) to prevent terminal applications from silently reading or writing the system clipboard. For compliance-sensitive environments, kitty's transparency and configurability make it a strong choice. Our team uses it for CMMC assessment work and digital forensics at Petronella.

Getting Started

The fastest path to a productive kitty setup: install kitty via your package manager or the official installer, create ~/.config/kitty/kitty.conf using the font and color examples from this guide, and start customizing keybindings for your workflow. Open a second window with ctrl+shift+enter, try the icat kitten with kitty +kitten icat on any image file, and explore the built-in theme picker with kitty +kitten themes. Once you have the basics, set up a session file that launches your complete development environment with a single command.

If your organization needs guidance on building Linux development environments, configuring GPU workstations for AI and machine learning, or deploying secure terminal infrastructure across a team, contact our team at (919) 348-4912 for a consultation.

About the Author: Craig Petronella is the CEO of Petronella Technology Group, a cybersecurity and IT infrastructure firm in Raleigh, NC. With CMMC-RP, CCNA, CWNE, and DFE certifications and over 30 years in IT, Craig’s team runs kitty on NixOS workstations daily for AI development, security assessments, and infrastructure management.