Kitty
GPU-based terminal emulator
Kitty — Official Website
Quick Take: Kitty
Kitty is the terminal for developers who want speed, configurability, and extensibility in a single package. The GPU rendering is genuinely faster for heavy output. The kittens provide real functionality without a plugin manager. The config file is clean and hot-reloadable. The graphics protocol is the best inline image system available. The tradeoff is the learning curve: you need to be comfortable editing a config file, reading documentation, and accepting that there's no GUI settings panel. If that's you, Kitty is probably your terminal for the next decade.
Best For
- •Developers who want GPU-accelerated rendering and notice the difference
- •Neovim/Vim users who want ligatures, true color, and inline images
- •Power users who prefer config files over GUI preferences
- •Data scientists who want inline charts and plots in the terminal
What is Kitty?
Kitty is a GPU-accelerated terminal emulator that takes the opposite approach from most terminals: instead of being an Electron wrapper or a minimal xterm replacement, Kitty offloads text rendering to your GPU using OpenGL, achieving consistently high frame rates and low latency even during heavy output. Created and maintained by Kovid Goyal (who also built the Calibre e-book manager), Kitty is written in a mix of C and Python, with the performance-critical rendering pipeline in C and the extensibility layer ('kittens') in Python. Kitty's philosophy is that a terminal emulator should be fast by default and extensible without plugins. Everything that most terminals need plugins for—image display, SSH with shell integration, Unicode input, diff viewing, clipboard management—Kitty ships as built-in 'kittens' that you run with `kitty +kitten <name>`. The terminal itself is configured via a single `kitty.conf` text file with hot-reload support: change a font size, save the file, and Kitty updates immediately without restarting your shell session. On macOS, Kitty runs natively on Apple Silicon and uses Metal for rendering (via MoltenVK/OpenGL translation). It supports ligatures, font variations, emoji, and complex scripts. It implements the Kitty Graphics Protocol, which allows programs to display high-resolution images, charts, and plots inline in the terminal—something most other terminals can't do or do poorly. The terminal supports splits and tabs natively, so you can divide your window into panes without tmux. Kitty occupies a specific niche: it's for developers who want a fast, configurable, scriptable terminal and are comfortable editing a config file to set it up. If you want a GUI preferences panel, Kitty isn't for you. If you want a terminal that stays out of your way while being faster than everything else, Kitty is worth the 30 minutes it takes to set up `kitty.conf`.
Install with Homebrew
brew install --cask kittyDeep Dive: Kitty's Config-as-Code Philosophy
Kitty's approach to configuration is deliberate: one file, plain text, version-controllable, and shareable. This is a statement about how developer tools should work.
History & Background
Kitty was first released in 2017. Kovid Goyal created it because existing terminals were either too slow (iTerm2 for heavy output), too minimal (Alacritty without splits/tabs), or too bloated (Hyper with Electron). The key insight was that GPU rendering could make a terminal genuinely faster for the use cases developers actually encounter: scrolling through log files, rendering complex prompts, and displaying Unicode/emoji. The graphics protocol was added later (2018) and has since been adopted by other terminals.
How It Works
Kitty's rendering pipeline is in C for performance. The C code handles text shaping (via HarfBuzz), rasterization (via FreeType), and GPU upload (via OpenGL). The configuration layer and kittens are in Python, which provides the extensibility without compromising rendering speed. This two-language architecture means kittens can be complex Python programs that interact with Kitty's internals, while the hot path of rendering text never touches Python. Memory usage is typically 50-80MB—more than Alacritty (30-40MB) but less than iTerm2 (100-200MB).
Ecosystem & Integrations
Kitty's ecosystem revolves around the graphics protocol and kittens. CLI tools that support the Kitty Graphics Protocol: ranger (file manager with image previews), matplotlib (inline chart rendering), timg (terminal image viewer), viu (image viewer), and neovim plugins like image.nvim. The kitten ecosystem includes built-in kittens (icat, diff, ssh, themes, hints) and community-contributed kittens for various workflows. The Kitty Themes gallery at github.com/kovidgoyal/kitty-themes has hundreds of themes.
Future Development
Kitty development continues at a steady pace with regular releases. Recent improvements have focused on macOS compatibility (each macOS version can break OpenGL behavior), performance optimizations for Apple Silicon, and expanding the graphics protocol. The developer has expressed interest in adding more built-in kittens and improving shell integration. The project doesn't have a formal roadmap—development is guided by the maintainer's priorities and community requests that align with Kitty's philosophy.
Key Features
GPU-Accelerated Rendering
Kitty renders text on the GPU using OpenGL, which means your CPU isn't doing character-by-character drawing. In practice, this matters when you `cat` a large log file, scroll through build output, or run programs that produce heavy terminal output. Where CPU-rendered terminals might stutter or drop frames, Kitty maintains smooth scrolling and consistent frame pacing. On an Apple Silicon Mac with a ProMotion display, Kitty renders at the full 120Hz refresh rate. The difference is most noticeable when you rapidly scroll through tens of thousands of lines—Kitty stays smooth where iTerm2 starts to chug.
kitty.conf — Single-File Configuration
All of Kitty's configuration lives in `~/.config/kitty/kitty.conf`. This is a plain text file with clear key-value pairs: `font_family JetBrains Mono`, `font_size 14`, `background_opacity 0.95`, `cursor_shape beam`. No Lua, no YAML, no JSON—just straightforward directives. The file supports `include` for splitting config across files (handy for separate color scheme files), conditional includes based on OS, and environment variable expansion. Config changes are hot-reloaded when you save the file (press Ctrl+Shift+F5 or set `auto_reload` to `yes`), so you can tweak colors and fonts without restarting your sessions.
Kittens — Built-in Extensibility
Kittens are Python scripts that extend Kitty's functionality. They run as subprocesses with access to Kitty's internal APIs. Built-in kittens include: `icat` (display images inline), `diff` (side-by-side diff viewer), `ssh` (SSH with shell integration and automatic Kitty terminfo), `unicode_input` (browse and insert Unicode characters), `clipboard` (advanced clipboard operations), and `hints` (URL/path/word selection with keyboard). You can write your own kittens in Python to automate terminal tasks. The kitten architecture means Kitty stays lean while offering plugin-level functionality.
Kitty Graphics Protocol
Kitty's graphics protocol is the most capable image display system for terminal emulators. It supports PNG, JPEG, GIF (animated), and raw pixel data. Images can be displayed at specific positions, scaled, and even composited. CLI tools like `matplotlib` (via `kitty` backend), `ranger`, `viu`, and `timg` use this protocol to show images, charts, and previews directly in the terminal. If you work with data visualization or use a file manager that shows thumbnails, the graphics protocol makes the terminal feel surprisingly visual.
Splits and Tabs Without tmux
Kitty has native splits (horizontal and vertical) and tabs. You can split your window into panes with Ctrl+Shift+Enter, navigate between panes with Ctrl+Shift+Arrow, and resize them interactively. Tabs work like browser tabs with Ctrl+Shift+T to create and Ctrl+Shift+Q to close. For many developers, this eliminates the need for tmux entirely. The panes share the same Kitty process, so they're lighter weight than separate terminal windows. The layout system supports stacks, grids, tall, fat, and custom layouts defined in your config.
Font Ligature Support
Kitty supports OpenType font ligatures out of the box. Coding fonts like Fira Code, JetBrains Mono, and Cascadia Code display their ligatures (→, ≠, <=, !=, ->) correctly without additional configuration. You can also disable specific ligatures if you find them distracting. Kitty handles font fallback chains, combining characters, and variable-width characters (CJK, emoji) correctly—an area where many GPU-accelerated terminals have historically struggled.
SSH Kitten with Shell Integration
The SSH kitten (`kitty +kitten ssh user@host`) is more than just running SSH. It automatically copies Kitty's terminfo to the remote server (fixing the common 'unknown terminal type' errors), sets up shell integration on the remote end (command completion, working directory tracking), and can forward the Kitty graphics protocol so you can display images from remote servers in your local terminal. It also supports connection multiplexing for faster subsequent connections. For developers who SSH frequently, this kitten eliminates the most common pain points.
Advanced Scrollback and Hints
Kitty's scrollback buffer is configurable in size and can be piped to external programs for processing. The `hints` kitten lets you use keyboard-driven selection for URLs, file paths, line numbers, IP addresses, and custom regex patterns that appear in the terminal output. Press the hints shortcut, and every URL in the visible output gets a short label—press the label to open the URL. This is faster than double-clicking or using the mouse to select URLs, especially when there are many on screen.
Who Should Use Kitty?
1The Neovim Developer
You run Neovim inside Kitty with Fira Code ligatures, 24-bit true color, and the Kitty graphics protocol for inline image previews in your file manager (ranger or yazi). You use Kitty's splits instead of tmux—three panes for code, terminal, and test output. When you need to SSH into a server, the SSH kitten copies your terminfo automatically so Neovim works correctly on the remote machine. Config changes to kitty.conf hot-reload while your Neovim sessions stay running.
2The Data Scientist
You run Python scripts that generate matplotlib charts. Using the Kitty graphics protocol, those charts render inline in your terminal instead of opening a separate window. You compare two datasets side-by-side using the diff kitten. When processing large CSV files, Kitty's GPU rendering keeps the terminal responsive even when thousands of lines scroll past. You SSH into a GPU server to train models and display training loss charts in your local terminal via the forwarded graphics protocol.
3The DevOps Engineer
You manage multiple servers and switch between SSH sessions constantly. Kitty's tabs organize connections by environment (production, staging, development). The SSH kitten handles terminfo issues that would otherwise break your remote tools. Kitty's hints kitten lets you select IP addresses and file paths from log output without reaching for the mouse. The GPU rendering handles the heavy log output from `kubectl logs` without frame drops.
4The Terminal Customizer
You maintain a dotfiles repo and your kitty.conf is a work of art. You've set up conditional includes for work vs personal machines, custom kittens for frequently-used workflows, a hand-tuned color scheme, and startup layouts that arrange panes exactly how you want them. When someone asks about your terminal, you point them to your dotfiles and a 20-minute setup. Kitty's config-file-as-code philosophy appeals to you because it's version-controlled, shareable, and reproducible.
How to Install Kitty on Mac
Kitty is available via Homebrew with Apple Silicon native support.
Install via Homebrew
Run `brew install --cask kitty` in your current terminal. Kitty installs to /Applications.
Create Your Config File
Run `mkdir -p ~/.config/kitty && touch ~/.config/kitty/kitty.conf`. Open this file in any editor and start configuring. At minimum, set your font: `font_family JetBrains Mono` and `font_size 14`.
Set Up a Color Scheme
Download a theme file (e.g., Catppuccin, Dracula, Tokyo Night) from the Kitty Themes gallery and include it in your config: `include themes/catppuccin-mocha.conf`. Or set colors directly in kitty.conf.
Test Key Features
Try `kitty +kitten icat /path/to/image.png` to test inline image display. Try `kitty +kitten ssh user@host` to test the SSH kitten. Press Ctrl+Shift+Enter to create a split. Press Ctrl+Shift+T to create a tab.
Pro Tips
- • Run `kitty --debug-config` to verify your config loads correctly and see effective values for all settings.
- • Use `kitty +kitten themes` to browse and preview themes interactively.
- • Add `shell_integration enabled` to kitty.conf for shell integration features (command highlighting, scroll to prompt).
Configuration Tips
Set Up a Proper Font Stack
In kitty.conf, set `font_family`, `bold_font`, `italic_font`, and `bold_italic_font` explicitly. For example: `font_family JetBrains Mono`, `bold_font JetBrains Mono Bold`. Also set `symbol_map` for specific Unicode ranges if you use Nerd Font icons: `symbol_map U+e000-U+e00a,U+ea60-U+ebeb Symbols Nerd Font Mono`. This avoids the common issue of missing icons in prompt themes.
Configure Useful Key Mappings
Add mappings like `map cmd+d launch --location=vsplit` (vertical split), `map cmd+shift+d launch --location=hsplit` (horizontal split), and `map cmd+w close_window`. This gives you iTerm2-like split behavior. Map `map cmd+shift+enter toggle_layout stack` to maximize a pane temporarily.
Set Up the SSH Kitten Config
Create `~/.config/kitty/ssh.conf` to configure the SSH kitten. Add `hostname *.example.com` blocks with specific settings per host. The SSH kitten can automatically set environment variables, copy files to remote servers, and configure shell integration on remote machines.
Enable Background Opacity for Aesthetics
Set `background_opacity 0.92` in kitty.conf for a slight transparency effect. Combined with `dynamic_background_opacity yes`, you can adjust transparency on the fly with keyboard shortcuts. This is purely cosmetic but gives your terminal a polished look, especially with a wallpaper visible behind it.
Use Startup Sessions for Workspace Layouts
Create a session file (e.g., `~/.config/kitty/startup.session`) that defines your default layout: tabs, splits, working directories, and commands. Set `startup_session ~/.config/kitty/startup.session` in kitty.conf. Now every time you open Kitty, your workspace is pre-arranged. This replaces the 'tmux session restore' workflow for many developers.
Alternatives to Kitty
The GPU-accelerated terminal space has several strong contenders:
Ghostty
Ghostty uses Metal for rendering and native AppKit for UI, making it feel more like a macOS app than Kitty. It's faster at startup and has a simpler config format. But Kitty has the graphics protocol, kittens, and more mature extensibility. Choose Ghostty for native Mac feel, Kitty for maximum configurability and the graphics protocol.
Alacritty
Alacritty is GPU-accelerated and minimalist—no tabs, no splits, no image display. It's the fastest terminal at raw text rendering but requires tmux for pane management. Kitty is nearly as fast but ships with tabs, splits, images, and kittens. Choose Alacritty for absolute minimalism, Kitty for a more complete terminal.
WezTerm
WezTerm uses Lua for configuration, which gives you a full programming language for config logic. It supports splits, tabs, images, and multiplexing. Kitty's config is simpler (key-value vs Lua scripts), and Kitty's graphics protocol is more widely supported by CLI tools. Choose WezTerm if you want programmable config; choose Kitty if you want simpler config and better graphics.
iTerm2
iTerm2 is the traditional macOS power-user terminal with a GUI preferences panel, profiles, triggers, and deep macOS integration. It's CPU-rendered and slower than Kitty for heavy output. Kitty is faster and more scriptable; iTerm2 is easier to configure and has more macOS-specific features (like tab bar integration and shell integration UI).
Pricing
Kitty is free and open-source under the GPL-3.0 license. There are no paid features, no premium tier, and no donations nag screen. The project is maintained by Kovid Goyal with community contributions. Development costs are covered by the developer personally.
Pros
- ✓GPU-accelerated rendering gives genuinely smoother scrolling than CPU-rendered terminals
- ✓kitty.conf is a clean, readable config format with hot-reload
- ✓Kittens provide plugin-level functionality without a plugin system
- ✓Kitty Graphics Protocol is the best inline image system for terminals
- ✓Native splits and tabs eliminate tmux for many workflows
- ✓Font ligature support works correctly out of the box
- ✓SSH kitten solves terminfo problems and enables remote graphics
- ✓Highly configurable without being overwhelming (one file, clear docs)
- ✓Free and open-source (GPL-3.0)
- ✓Apple Silicon native with Metal rendering
Cons
- ✗No GUI preferences panel—you must edit kitty.conf manually
- ✗The learning curve for config and kittens is steeper than iTerm2 or Terminal.app
- ✗Uses OpenGL/Metal which occasionally conflicts with macOS graphics driver updates
- ✗Not everyone's shell integration works perfectly (some edge cases with fish, zsh plugins)
- ✗The maintainer has strong opinions and occasionally dismisses feature requests bluntly
- ✗No session restore after crashes—splits and tabs don't survive unexpected quits
Community & Development
Kitty has a dedicated community centered around its GitHub repository. The project has over 25,000 stars and a very active issue tracker. The developer, Kovid Goyal, is highly responsive and technically rigorous—issues get detailed responses, often with patches within days. The community contributes themes, kittens, and documentation. There's an active Kitty discussion channel on various platforms. The Kitty Themes gallery has hundreds of community-contributed color schemes. The documentation at sw.kovidgoyal.net/kitty is comprehensive and serves as both a reference manual and a configuration guide. Kitty's FAQ section covers common configuration questions and troubleshooting.
Video Tutorials
Getting Started with Kitty
More Tutorials
NEW TO MAC? Mac Tutorial for Beginners 2025
MacVince • 1.3M views
NEW TO MAC? Watch this 6 Minutes Mac Tutorial
Apple Wale Bhaiya • 515.6K views
Mini Paper MacBook Pro #shorts
linnientt • 1.4M views
Frequently Asked Questions about Kitty
Our Verdict
Kitty is the terminal for developers who want speed, configurability, and extensibility in a single package. The GPU rendering is genuinely faster for heavy output. The kittens provide real functionality without a plugin manager. The config file is clean and hot-reloadable. The graphics protocol is the best inline image system available. The tradeoff is the learning curve: you need to be comfortable editing a config file, reading documentation, and accepting that there's no GUI settings panel. If that's you, Kitty is probably your terminal for the next decade.
About the Author
Related Technologies & Concepts
Related Topics
Sources & References
Key Verified Facts
- Official documentation confirming Kitty is a GPU-accelerated terminal emulator that offloads rendering to the GPU.[cite-1]
- Details Kitty's use of OpenGL to achieve consistently high frame rates and low latency during heavy text output.[cite-2]
- Explains the architectural mix of C for the performance-critical rendering pipeline and Python for extensibility.[cite-3]
- Official documentation showing how Kitty's Python-based extension framework ('kittens') provides deep extensibility.[cite-4]
- Source code repository confirming the primary languages used (C and Python) and active maintenance by Kovid Goyal.[cite-5]
- 1kitty - the fast, feature-rich, GPU based terminal
Accessed May 6, 2026
"Official documentation confirming Kitty is a GPU-accelerated terminal emulator that offloads rendering to the GPU."
- 2kitty Performance
Accessed May 6, 2026
"Details Kitty's use of OpenGL to achieve consistently high frame rates and low latency during heavy text output."
- 3kitty Architecture and Overview
Accessed May 6, 2026
"Explains the architectural mix of C for the performance-critical rendering pipeline and Python for extensibility."
- 4Extending kitty with kittens
Accessed May 6, 2026
"Official documentation showing how Kitty's Python-based extension framework ('kittens') provides deep extensibility."
- 5GitHub - kovidgoyal/kitty: Cross-platform, fast, feature-rich, GPU based terminal
Accessed May 6, 2026
"Source code repository confirming the primary languages used (C and Python) and active maintenance by Kovid Goyal."
- 6GitHub - kovidgoyal/calibre: The comprehensive e-book software
Accessed May 6, 2026
"Confirms that Kovid Goyal, the creator of Kitty, is also the creator and lead developer of the Calibre e-book manager."
- 7The kitty terminal emulator [LWN.net]
Accessed May 6, 2026
"Tech publication article detailing Kitty's opposite approach to Electron wrappers by utilizing raw OpenGL for rendering."
- 8Phoronix: Kitty Is A Promising, GPU-Accelerated Terminal Emulator
Accessed May 6, 2026
"News article highlighting Kitty's OpenGL-based GPU acceleration and high frame rate capabilities."
- 9Terminal Latency - Dan Luu
Accessed Mar 1, 2026
"Comprehensive benchmark analysis on terminal emulators demonstrating the importance of low-latency rendering pipelines similar to Kitty's approach."
- 10Terminal emulator benchmark comparisons
Accessed May 6, 2026
"Community benchmark discussions comparing GPU-accelerated terminals, verifying Kitty's ability to maintain high frame rates under heavy output."