MangaMode / Editor theme system

Code through
the next arc.

MangaMode is a collection of anime and manga-inspired editor themes designed to keep long coding days readable, expressive, and easy on the eyes.

Preview theme

arcs.ts

import { readFile } from 'node:fs/promises';

type Arc = { title: string; chapters: number[] };

/** Load every arc and keep the ones worth binge-reading. */
export async function longArcs(path: string, min = 30): Promise<Arc[]> {
  const arcs: Arc[] = JSON.parse(await readFile(path, 'utf8'));

  return arcs
    .filter(({ chapters }) => chapters.length >= min)
    .map((arc) => ({
      ...arc,
      title: `${arc.title} (${arc.chapters.length} ch.)`
    }));
}
My role
Visual design, theme system & frontend
Scope
10 themes, a VS Code extension & live previews
Quality standard
AA text contrast; AAA for high contrast; UI-state checks

The brief

Long sessions.
Less visual noise.

I created MangaMode because I wanted editor themes I could comfortably use throughout a full day of coding. Many colorful themes look exciting in a screenshot but become tiring when every hue is bright, every token demands attention, and the interface competes with the code.

The goal was not to remove personality. It was to control it: pair recognizable anime-inspired palettes with low-glare surfaces, restrained saturation, and syntax contrast that stays useful over time.

I held every theme to three constraints:

  • Recognizable. Each palette has to read as its series at a glance.
  • Readable. Every text color passes WCAG AA, and the high-contrast Death Note passes AAA.
  • Complete. Every surface you see day to day gets a theme color, so VS Code’s default blue and grey never leak in.

From palette to proof

Character,
with a system.

Follow one shipped palette from its visual identity to the code it colors and the contrast it has to meet.

Inspiration

Keep the character.

One Piece starts with ocean teals, muted reds, and a deep navy canvas. The recognizable palette lives in the details, while the editor surface gives the code room to breathe.

One Piece / shipped palette

import { readFile } from 'node:fs/promises';

type Arc = { title: string; chapters: number[] };

/** Load every arc and keep the ones worth binge-reading. */
export async function longArcs(path: string, min = 30): Promise<Arc[]> {
  const arcs: Arc[] = JSON.parse(await readFile(path, 'utf8'));

  return arcs
    .filter(({ chapters }) => chapters.length >= min)
    .map((arc) => ({
      ...arc,
      title: `${arc.title} (${arc.chapters.length} ch.)`
    }));
}
Canvas
#0B1B24
Keywords
#DD7074
Functions
#63C8BC
Strings
#8BD5B2

Token system

Give each color a job.

A palette becomes a system when each color has a role. The keyword token paints declarations like export and function; separate tokens carry strings, types, and function names. The preview reads those choices from the same file as the extension.

One Piece / shipped palette

import { readFile } from 'node:fs/promises';

type Arc = { title: string; chapters: number[] };

/** Load every arc and keep the ones worth binge-reading. */
export async function longArcs(path: string, min = 30): Promise<Arc[]> {
  const arcs: Arc[] = JSON.parse(await readFile(path, 'utf8'));

  return arcs
    .filter(({ chapters }) => chapters.length >= min)
    .map((arc) => ({
      ...arc,
      title: `${arc.title} (${arc.chapters.length} ch.)`
    }));
}

From theme file to declaration

{ "scope": "keyword", "settings": { "foreground": "#DD7074" } }

The outlined declaration uses this keyword color.

Contrast validation

Make the decision measurable.

That same keyword color is measured against the editor background. This is one text pair from the shipped theme; the release checks cover the wider palette and UI states. The bench below lets you explore where a color stops passing.

Keyword on canvas: 5.5:1, against a 4.5:1 minimum.

Try the contrast bench

One Piece / shipped palette

import { readFile } from 'node:fs/promises';

type Arc = { title: string; chapters: number[] };

/** Load every arc and keep the ones worth binge-reading. */
export async function longArcs(path: string, min = 30): Promise<Arc[]> {
  const arcs: Arc[] = JSON.parse(await readFile(path, 'utf8'));

  return arcs
    .filter(({ chapters }) => chapters.length >= min)
    .map((arc) => ({
      ...arc,
      title: `${arc.title} (${arc.chapters.length} ch.)`
    }));
}

Keyword on editor background

5.5:1Passes AA · 4.5:1 minimum

#DD7074 on #0B1B24

Decisions

Four calls
that shaped it.

  • Depth, not rainbow

    Three tonal shades of one hue for nested brackets.

    Nesting should read as depth. Six hues added visual noise exactly where code is hardest to follow.

    Alternative considered
    A different hue per nesting level, the common default. MangaMode started with six.
    Evidence
    v1.1.0 cut brackets from 6 hues to 3 shades in every theme.
  • Contrast is a gate

    Automated checks for text on editor and workbench states, with a 4.5:1 floor (7:1 for high contrast) and 3:1 for focus and meaningful UI indicators.

    Checking by eye missed real failures. Inlay hints used a transparent color that put them under 3:1 in every theme.

    Alternative considered
    Checking colors by eye in a few screenshots.
    Evidence
    v1.4.0 checks selections, search matches, layered diffs, inlay hints, and workbench controls. Alpha colors are composited before checking; missing required state colors fail.
  • Hue, not just lightness

    Separate code roles by hue.

    Pokémon's functions and types were both neutral grey, and the cursor shared the keyword color in five themes, so different things looked the same.

    Alternative considered
    Telling roles apart by lightness alone, or reusing one accent for everything.
    Evidence
    v1.3.0 moved Pokémon functions and types to a soft blue and gave the cursor its own color.
  • Darken, don't re-color

    Fix the light theme's contrast by darkening each color and keeping its hue.

    The pastel hues are what make it Sailor Moon. New hues would pass the check and lose the theme.

    Alternative considered
    Swapping in new, stronger hues that pass more easily.
    Evidence
    v1.3.0 darkened syntax, line numbers, inlay hints and inactive tabs to 4.5:1 on cream, hues unchanged.

Try it

Find the
edge.

Pick a theme and a token, then drag its lightness. The bench moves lightness in OKLCH so the hue holds while you drag. The black band marks where the color falls below the selected contrast threshold.

Theme
// Personality, under control.import { defineTheme } from 'mangamode';type Volume = { name: string; issue: number };export function readChapter(vol: Volume, page = 1) {  const panels = vol.issue * 24;  return format(vol.name, [page, panels]);}defineTheme({ glare: 'low', focus: 'high' });
Token

5.5:1

#DD7074 on #0B1B24.

Passes AA, the bar this theme ships at.

Black marks lightness below 4.5:1. The red tick is the shipped color.

The theme file

Every key
has a place.

Point at a block of the theme file to see what it paints. The values are read from the published file of the theme you pick, and the editor beside it is drawn from the same file.

Theme file

themes/one-piece-color-theme.json (excerpt)

{"colors": {},"tokenColors": []}
import { readFile } from 'node:fs/promises';

type Arc = { title: string; chapters: number[] };

/** Load every arc and keep the ones worth binge-reading. */
export async function longArcs(path: string, min = 30): Promise<Arc[]> {
  const arcs: Arc[] = JSON.parse(await readFile(path, 'utf8'));

  return arcs
    .filter(({ chapters }) => chapters.length >= min)
    .map((arc) => ({
      ...arc,
      title: `${arc.title} (${arc.chapters.length} ch.)`
    }));
}

Point at a block of the file to see what it paints.

The system

One file,
four places.

Each theme is a single JSON file. The extension, contrast checks, mangamode.dev, and the editors on this page all read it directly. Marketplace images are generated from the website’s editor renderer, with source and image hashes checked for freshness.

themes/*.json

  • VS Code extensionPackaged on every release.
  • Contrast checkChecks editor and workbench text across UI states, plus focus and meaningful indicators, against their contrast floors.
  • mangamode.devLive editors, contrast tables, tuning controls, and generated Marketplace previews with freshness checks.
  • This pageThe editors, the bench, and the live preview.

Theme lineup

Pick your
mode.

Eight dark themes, including a dedicated high-contrast mode, and two light themes translate familiar worlds into practical editor palettes. Open any of them in the bench or the theme file above to see it drawn from its own file.

  • One Piece

    Ocean teals, muted reds, and a deep navy editor canvas.

  • Dragon Ball

    Bold oranges and deep blues with the brightness kept in check.

  • Pokémon

    Recognizable yellows balanced by soft greys and cool blues.

  • Demon Slayer

    Charcoal foundations with water-blue and fire-red accents.

  • Jujutsu Kaisen

    Dark violets and restrained cyan inspired by Hollow Purple.

  • DanDaDan

    A deliberately strange mix of pink, green, and occult purple.

  • Sailor Moon

    The first light variant, with warm cream and softened pastels.

  • Death Note

    Ink-black, off-white, apple red, and shinigami gold at AAA contrast.

  • The Apothecary Diaries

    Pale celadon surfaces with pine text, jade functions, and plum keywords.

  • Gachiakuta

    Warm soot and chalk with rust accents and yellow-green focus indicators.

Published in two registries

VS Code MarketplaceVS Code
752installs
Open VSXCursor, VSCodium, and Windsurf
754downloads

Version 1.4.0, updated Nov 6, 2026. Open VSX counts downloads, so updates add to its total.

Next steps

What I'd
do next.

  • Evaluate APCA alongside WCAG 2. WCAG 2 ratios misjudge some pairs on dark backgrounds.
  • Validate the palettes in long coding sessions across languages and editor extensions.