Tabby Terminal Themes in 2026: The Good Ones

Tabby is the terminal people land on when they want a terminal that looks good without compiling anything. It is Electron, it is cross platform, it has a plugin system, and it ships with a genuinely large library of color schemes out of the box.

Which also means most people never get past the built-in dropdown. That is fine, the dropdown is good. But there are two separate theming systems in Tabby, and knowing which is which is the difference between "I picked a scheme" and "this terminal looks like mine."

I have run Tabby as a daily driver in stretches. Here is what works, what I actually use, and where it stops.

Two layers, and people confuse them constantly

Tabby has a color scheme and it has a theme. They are not the same thing.

The color scheme is the terminal palette: background, foreground, cursor, and the sixteen ANSI colors. This is what changes what your shell prompt, your ls output, and Claude Code's TUI look like. Tabby bundles a few hundred of these, imported from the iTerm2 color scheme collection.

The theme is the application chrome: the tab bar, the settings panels, the window frame, the spacing. Tabby ships with a handful (Standard, Compact, Paper) and more come from plugins. This is what changes what the app around the terminal looks like.

Change the color scheme and your text looks different. Change the theme and the furniture looks different. Most "my Tabby looks bad" complaints are actually about the second one while people keep adjusting the first.

Both live in Settings > Appearance in the UI, and both end up in a config file:

• macOS and Linux: ~/.config/tabby/config.yaml
• Windows: %APPDATA%\tabby\config.yaml

Edit that file directly if you want to version control your setup, which you should.

Six color schemes worth your time

I picked these for long sessions specifically. Staring at an agent scroll code for three hours punishes any scheme with poor contrast between the ANSI colors, because diffs, syntax highlighting, and TUI chrome all lean on them.

Dracula

The obvious one, and it earns it. Purple-grey background, high saturation accents, and critically, all sixteen ANSI colors are distinct from each other. That matters more than people think. Plenty of prettier schemes give you two greens you cannot tell apart, and then a git diff becomes a guessing game.

Best for: people who want it to look designed without thinking about it. It is bundled, just pick it.

Nord

Cold, low saturation, blue-grey. The most restful scheme on this list by a distance, and the one I go back to when my eyes are tired.

The tradeoff is real: Nord deliberately compresses its color range, so red and orange are less alarming than they should be. If you rely on red for errors at a glance, you may find it too polite. Bundled in Tabby.

Gruvbox Dark

Warm, retro, brownish. Feels like a nicer version of a 90s terminal. Excellent contrast, and the yellows and oranges are genuinely readable, which is unusual.

Best for: anyone who finds blue-toned schemes cold. There is a light variant that is one of the few light terminal schemes that does not hurt.

One Half Dark

The VS Code One Dark palette, tuned for terminals. The reason to pick it is boring and good: if your editor is One Dark, your terminal matching it removes a small tax you were paying every time your eyes moved between windows. Bundled.

Snazzy

Bright, high contrast, slightly loud. Cyan and pink do a lot of work. The one I recommend to people who say every scheme looks the same. It does not look the same.

Not for everyone. Long sessions on Snazzy can feel like sitting close to a screen at a rave. Great for shorter, focused work.

Catppuccin Mocha

The one that got popular for a reason. Muted pastels on a dark background, with an unusually careful palette. Four flavors exist, Mocha being the darkest. Catppuccin ships a Tabby port, so you may need to add it from their repo rather than finding it in the dropdown, depending on your version.

Best for: people who want something modern that is not Dracula.

Writing your own scheme in config.yaml

Once you know what you want, hand-editing is easier than the UI. A custom scheme in config.yaml looks like this:

terminal:
  colorScheme:
    name: My Scheme
    foreground: '#c8d3f5'
    background: '#1a1b26'
    cursor: '#c8d3f5'
    selection: '#2d3f76'
    colors:
      - '#1b1d2b'   # black
      - '#ff757f'   # red
      - '#c3e88d'   # green
      - '#ffc777'   # yellow
      - '#82aaff'   # blue
      - '#c099ff'   # magenta
      - '#86e1fc'   # cyan
      - '#828bb8'   # white
      - '#444a73'   # bright black
      - '#ff8d94'   # bright red
      - '#c7fb6d'   # bright green
      - '#ffc777'   # bright yellow
      - '#9ab8ff'   # bright blue
      - '#caabff'   # bright magenta
      - '#b4f9f8'   # bright cyan
      - '#c8d3f5'   # bright white

The order is fixed: eight normal colors, then eight bright. Get it wrong and your prompt will look fine while your TUIs look insane, which is a confusing bug to chase.

One rule I would tattoo on people: check bright black against your background. Comments, dimmed text, and half the chrome in TUI apps use it. If it is too close to your background, entire sections of the interface disappear and you will assume the app is broken.

Custom CSS, the part most people skip

Because Tabby is Electron, you can inject CSS into the whole application. Settings > Appearance > Custom CSS, or the css key in config.yaml. This is where the real personalization lives.

A few that earn their keep:

/* Tighter tabs so more fit before they shrink */
tab-header .index { display: none; }
tab-header { padding: 2px 8px; }

/* Make the active tab obvious at a glance */
tab-header.active {
  border-bottom: 2px solid #82aaff;
  background: rgba(130, 170, 255, 0.08);
}

/* Soften the window */
.content { border-radius: 8px; overflow: hidden; }

/* Kill the toolbar if you never use it */
.toolbar { display: none !important; }

Two warnings. Tabby's internal class names are not a public API, so a version bump can break your CSS with no warning. And there is no reload button worth trusting, so keep a copy of anything you like outside the app.

If you want more than CSS can reach, the plugin ecosystem covers a lot. We went through the useful ones in the best Tabby terminal plugins.

Where Tabby theming hits its ceiling

Tabby theming is good. It is also, structurally, recoloring an app that was designed to look like Tabby.

You can change every color, hide the toolbar, round the corners, tighten the tabs. What you cannot do is change what the interface is. There is no layer for widgets. No audio visualizer. No background art. The tab bar is a tab bar, and it can be a differently colored tab bar, but it cannot become something else. Injecting CSS into an app's internal class names is fundamentally a workaround, not a supported extension point, and it breaks when the app changes.

For most terminal use, that ceiling is high enough. If you use a terminal to run commands, Tabby with Catppuccin and forty lines of custom CSS is a genuinely nice place to work, and you should stop reading here.

It starts to bind when the terminal stops being a place you run commands and becomes a place you sit, watching an AI agent work for hours. Then the chrome is not chrome anymore, it is the room. And a good color scheme does not make a room.

What a fully skinnable shell looks like instead

That is the gap MOLTamp was built for, so read the next two paragraphs with the appropriate suspicion.

MOLTamp treats skins as the primary artifact rather than an afterthought. A skin is not a color list, it is CSS over a documented set of contract variables, plus widgets, backgrounds, and layout. The interface is designed to be replaced, so restyling it is supported rather than tolerated, and skins do not break when the app updates because the contract is the API.

Practically, that means things Tabby's model has no room for. Tab badges that pull amber and green straight from your palette when an agent needs input or finishes. Widget slots for music, visualizers, and status. Background layers. Skins you can install from a community gallery instead of pasting CSS from a gist. If you want to see the surface area, the skinning docs list every variable.

It is a different tool for a narrower job, and Tabby is still the better answer if you mainly want a fast, well-built terminal with good defaults.

FAQ

How do I change the theme in Tabby?

Settings > Appearance. The color scheme dropdown changes the terminal palette, the theme dropdown changes the app chrome. They are separate, and most people only touch the first one.

Where is the Tabby config file?

~/.config/tabby/config.yaml on macOS and Linux, %APPDATA%\tabby\config.yaml on Windows. Everything set in the UI ends up there, so it is worth version controlling.

Can I use iTerm2 color schemes in Tabby?

Yes, and most of Tabby's bundled schemes came from that collection originally. You can also translate any scheme by hand into the colorScheme block in config.yaml.

What is the best Tabby color scheme for long sessions?

Nord if you want low eye strain, Gruvbox Dark if you find blue schemes cold, Catppuccin Mocha for a modern middle ground. The real test is whether bright black is readable against your background, since dimmed TUI text depends on it.

Can I customize Tabby's interface beyond colors?

Some. Custom CSS in Settings > Appearance reaches the whole Electron UI, and plugins add real features. But you are styling internal class names that can change between releases, so treat it as a workaround rather than a stable API.

---

Pick Nord or Catppuccin, write twenty lines of custom CSS, and Tabby will look like yours by lunchtime. If you have already done that and it still feels like a terminal wearing a costume, the skinnable alternative is free to try, and Tabby alternatives covers the wider field honestly.