7 Things Kitty Can Do That Will Make You Forget iTerm2 Existed

Inline images, AI-powered commands, live theme switching, and more — all built in or under 20 lines of Python.

Mar 20, 2026

I switched from iTerm2 to Kitty last month. The migration itself took under 10 minutes of AI execution time — that story is

here. What I didn’t expect was what came next: discovering what Kitty could actually do once it was running.

Most of these features are either built in or require a single Python file. None need a plugin manager, a third-party package, or anything beyond what ships with Kitty and a standard macOS dev setup. Kitty’s extension model — called kittens — lets you write short Python scripts that have direct access to the running terminal’s windows, tabs, and layout. That’s what makes features 5 and 7 possible without any external framework. Here’s what I’ve been using.

Thanks for reading Olko - Tech/Engineering! This post is public so feel free to share it.

1. Inline Images — See Your Output, Not Just Text

What it does: Display images, charts, screenshots, and anything ImageMagick can read directly in the terminal window. The image renders where the cursor is, inline with your text. No viewer, no browser tab, no context switch.

This is Kitty’s GPU graphics protocol — the same infrastructure that makes the terminal fast is what makes this possible. It works over SSH when you connect with kitty +kitten ssh, which forwards the protocol transparently. iTerm2 has a similar feature, but the SSH forwarding is what makes Kitty’s version worth knowing about.

Setup: Nothing. icat ships with Kitty.

Usage:

kitty +kitten icat screenshot.png
kitty +kitten icat --align center chart.jpg
kitty +kitten icat https://example.com/image.png   # auto-downloads

Demo: I use this to preview AI-generated images from the command line before committing them to a project. One command, image inline, back to the code. The whole review takes five seconds. It also works with SVGs via ImageMagick conversion and with animated GIFs — the animation plays inline. If you’re generating diagrams, charts, or assets during development, this removes one full context-switch from your loop. The URL variant is especially useful: kitty +kitten icat https://... fetches and displays in one step, no curl to a temp file required.

2. Hints Kitten — Keyboard-Select Anything on Screen

What it does: Press a keybinding and every URL, file path, and file:line reference visible on screen gets a keyboard label. Press the label and it opens, copies, or jumps — no mouse.

Three keybindings cover the main cases:

map ctrl+shift+p kitten hints
map ctrl+shift+f kitten hints --type path --program -
map ctrl+shift+n kitten hints --type linenum --linenum-action launch --action-alias linenum=cursor --goto-line {line} {file}

ctrl+shift+p overlays letters on every URL — press the letter, it opens in your default browser. ctrl+shift+f targets file paths and inserts the selected path at the cursor. ctrl+shift+n finds file:123 references and opens the file at that exact line in Cursor.

The demo that sold me: run a failing test, get a stack trace with src/components/button.tsx:47, press ctrl+shift+n, and the editor opens with the cursor on line 47. Terminal to editor in one keystroke. The same workflow applies to TypeScript compiler errors, ESLint output, and any tool that emits file:line references — which is nearly all of them. Once you’ve used it, reaching for the mouse to click an error feels slow.

The hints kitten also supports custom hint types, so you can pattern-match commit hashes, issue numbers, or anything else your workflow generates. Built-in, zero config beyond the keybindings.

3. Quake Dropdown — One Key to Surface Kitty from Anywhere

What it does: A single global hotkey summons Kitty from anywhere on macOS — mid-browser, mid-meeting notes, mid-anything. Same key hides it. The Quake console UX from 1996, for your terminal in 2026.

Setup: Two parts. Add to your shell config:

alias kitty-bg='open -a kitty --args --single-instance'

Then in Shortcuts.app → New Shortcut → Run AppleScript:

tell application "System Events"
  if exists (processes where name is "kitty") then
    if frontmost of process "kitty" is true then
      set visible of process "kitty" to false
    else
      tell application "kitty" to activate
    end if
  else
    tell application "kitty" to activate
  end if
end tell

Set the keyboard shortcut to ctrl+`. Enable it in System Settings → Privacy & Security → Accessibility.

Note: use set visible of process "kitty" to false to hide — not keystroke "h". The keystroke approach requires Input Monitoring permissions that Shortcuts can’t obtain.

No Karabiner. No skhd. macOS Shortcuts has supported global AppleScript actions since Ventura — most people don’t know about it. The AppleScript checks whether Kitty is frontmost before toggling, which means you can use the same key to both summon and dismiss without any additional state tracking. If Kitty isn’t running yet, the script activates it normally, so the hotkey doubles as a launcher.

Usage: ctrl+` → Kitty surfaces. ctrl+` again → Kitty hides. Kitty needs to be running first — add it to Login Items or run kitty-bg on startup. If you want Kitty to launch at login without showing a window, set hide_window_decorations yes and pair it with the kitty-bg alias — it opens in the background and waits for the hotkey.

4. Live Theme Switching — Browse 250+ Themes with Instant Preview

What it does: cmd+shift+t opens an fzf-style picker with every official Kitty theme — Catppuccin, Dracula, Nord, Solarized, Tokyo Night, and ~240 others. As you navigate the list, the terminal colors update live. Select one and it applies instantly across all open windows.

Setup: One line:

map cmd+shift+t kitten themes --reload-in=all

--reload-in=all propagates the color change to every open Kitty window immediately. No restart.

Demo: The live preview is what makes this usable. You’re not guessing from a hex palette — you’re seeing your actual terminal, with your actual content, in each theme as you arrow through. Most theme names from the iTerm2/terminal ecosystem are here. Catppuccin Mocha, Tokyo Night, and Dracula are first-class entries — no manual hex-copying needed. The picker fuzzy-searches by name, so typing “cat” filters to all Catppuccin variants immediately. When you confirm a selection, Kitty writes the theme colors into your kitty.conf automatically, so the choice persists across restarts without any manual editing.

No repo to clone, no theme manager to install. kitty +kitten themes manages everything since Kitty 0.37.

5. Project Switcher — Jump Between Projects in Two Keystrokes

What it does: cmd+p opens an fzf picker of your projects. Select one, and a new Kitty tab opens with that project as the working directory and the project name as the tab title. No cd commands.

This is a custom Python kitten — 20 lines. Kittens are Kitty’s extension system: Python scripts that can interact with the running Kitty process directly, using the same API Kitty uses internally. Two functions: main() runs the fzf UI and returns the selection, handle_result() gets the boss API and opens the tab.

# ~/.config/kitty/kittens/project_switcher.py
import os, subprocess

def main(args):
    with open(os.path.expanduser('~/.config/kitty/projects.txt')) as f:
        projects = [l.strip() for l in f if l.strip()]
    proc = subprocess.Popen(['fzf', '--prompt', 'Project > '],
        stdin=subprocess.PIPE, stdout=subprocess.PIPE)
    stdout, _ = proc.communicate('\n'.join(projects).encode())
    return stdout.decode().strip() or None

def handle_result(args, answer, target_window_id, boss):
    if answer:
        path = os.path.expanduser(answer)
        boss.new_tab(cwd=path, tab_title=os.path.basename(path))

In kitty.conf: map cmd+p kitten project_switcher

Add your project paths to ~/.config/kitty/projects.txt, one per line.

Demo: cmd+p, type “mond”, Enter. New tab: mondial, cwd: the repo. Two keystrokes, no navigation.

6. Remote Control — Drive Kitty from a Script

What it does: Two shell functions that treat Kitty as an API. krun sends a command to a named tab. kdev opens a 3-pane development layout for any project directory. Both work from any shell, including scripts and other terminals.

This uses Kitty’s remote control protocol — the same two config lines that are already in a well-configured kitty.conf:

allow_remote_control yes
listen_on unix:/tmp/kitty-socket

Add to your shell config:

krun() {
  local title="$1"; shift
  kitten @ --to unix:/tmp/kitty-socket send-text --match "title:$title" "$(printf '%s\n' "$*")"
}

kdev() {
  local project="${1:-$PWD}"
  local name="${project##*/}"
  kitten @ --to unix:/tmp/kitty-socket launch --type=tab --tab-title="$name" --cwd="$project"
  kitten @ --to unix:/tmp/kitty-socket launch --location=vsplit --cwd="$project"
  kitten @ --to unix:/tmp/kitty-socket launch --location=hsplit --cwd="$project"
}

Demo: kdev ~/projects/mondial → tab opens, 3 panes, all in the right directory. krun "mondial" "pnpm dev" from anywhere — even from a CI script — and the dev server starts in that tab. I have a workspace script that calls kdev three times in sequence: one tab for each active project, each with the 3-pane layout and the right cwd. One command in the morning and the full workspace is ready. The remote control socket also means you can pipe commands from other tools — a git hook, a Makefile target, or a background job notifier can all write directly to your terminal.

This is what “programmable terminal” looks like in practice.

7. AI-to-Shell Kitten — Describe What You Want, Get the Command

What it does: ctrl+shift+a opens an overlay where you describe a shell command in plain English. It calls Claude Code, shows you the result, and pastes it into the terminal on confirmation. One keystroke from intent to command.

This is a ~50-line Python kitten. main() handles the UI — prompt, Claude call, confirmation. handle_result() pastes the command via the Kitty boss API. The confirmation step is non-optional: the kitten always shows you the command before pasting it. Press Enter to use it, Escape to cancel.

Three demos that actually work:

“kill the process on port 3000” → lsof -ti:3000 | xargs kill
“find all node_modules and show their sizes” → find . -name node_modules -prune -exec du -sh {} \;
“git log as a graph for the last 20 commits” → git log --oneline --graph --decorate -20

The kitten calls claude -p with a prompt instructing it to return only a raw shell command — no explanation, no markdown, no code fences. The output is stripped of any formatting that slips through, and the first non-empty line is used.

The key design choice: the kitten never executes. It pastes. You still press Enter. This is copilot for your shell, not autopilot. The model used is claude -p, which hits the API with no conversation history — each invocation is stateless and fast. You can swap the model by changing the shell call inside the kitten. The whole thing is ~50 lines, which means it’s fully auditable and easy to modify: add a --model flag, swap in a local LLM endpoint, or change the confirmation UI to suit your preferences.

None of these required more than 20 lines of Python or a single config line. The project switcher and AI kitten are custom — everything else ships with Kitty or is a single map entry.

The full updated kitty.conf is at gist.github.com/oleg-koval/77ff6d4332ee3c382ab24003f519afca. It includes all the keybindings above, the remote control setup, and the iTerm2-matched color scheme.

Discussion about this post

Ready for more?