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.
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 benchOne 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.
// 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' });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.
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.