Skip to main content

Theming

Every colour, radius, elevation and font family in the app resolves to a CSS custom property. A theme is one block of those properties, selected by a data-theme attribute on <html>. Switching themes is a single attribute write: the browser restyles the whole tree itself, and no React component re-renders.

WhereWhat
packages/ui/src/themes.cssThe themes. One block of primitives each, plus a shared alias block.
packages/ui/src/controls.cssThe control primitives — checkbox, radio, switch, input, select — built on those tokens.
packages/core/src/theme.tsThe switch: the theme list, applyTheme, initTheme, and the hooks for JS-side consumers.
packages/core/src/modules/settings/index.tsDeclares the settings.theme setting and one palette command per theme.
apps/web/src/main.tsxCalls initTheme() at boot.

The themes​

midnight is the original look and the default: near-black ground, hairline borders, small radii, essentially no elevation. Structure comes from 1px borders.

studio is built from the Settings Kit design. Same ground and the same accent — it is a sibling, not an inversion — but the surfaces sit much closer together (#1a1d23 on #14161a) and the borders are softer (#23262d), so a card is held apart from the page by radius and shadow rather than by a bright hairline. It also carries editorial serif display type.

That pairing is the whole idea of studio, and it is fragile in one direction: brightening either the raised surface or the border collapses it back into midnight.

The desktop shell added four more, each built around one idea rather than around a hue:

idThe idea
glassTranslucent chrome over the desktop backdrop. Real backdrop-filter blur on the chrome and the status bar, and large radii.
hudTerminal cyberpunk. Near-black, every radius 0, hairline accent borders, mono type in the chrome as well as the content, and a glow instead of a drop shadow — a dark theme's shadow on a dark ground is invisible.
daylightThe light productivity theme: opaque surfaces, a faint cool tint, and elevation you can actually see because the ground is bright.
retroBeveled grey 90s chrome, square corners, hard offset shadows, and a teal desktop.

Three of those are worth pointing at, because each proves a rule rather than just picking colours.

hud sets every radius to 0, which makes it the theme that audits the radius tokens: a component that hardcoded a border-radius is visible there and nowhere else. That audit is now also a test — design-tokens.test.ts fails on a literal border-radius in the shell sheets (styles.css, frame.css, desktop.css, taskbar.css), which is how ~190 of them were found and converted. 50%, 999px and 9999px are exempt: those are circles and pills, a shape rather than a corner treatment. Module CSS is still being converted and is deliberately outside the rule — one that fails on eighty known offenders is one people disable.

daylight and retro set color-scheme: light. That is not decoration — it is what flips native scrollbars, form controls and the caret. Without it a light theme keeps dark scrollbars and looks broken in exactly the places CSS cannot reach. daylight also has to invert --accent-contrast to white: on a light theme the accent is dark, and leaving that token alone is how every primary button loses its label. --bg-inset flips the same way — it is a black wash in the dark themes, and left alone a code block becomes a hole punched in the page.

retro is the reason the OS-chrome bevel pair exists at all; see below.

The OS-chrome tokens​

Group headers, pane boxes and the status bar read only a --win-* / --taskbar-* group (the names are the floating desktop's, kept so existing themes still apply), so a theme restyles the entire shell by redefining tokens and touching no component. packages/ui/src/desktop/desktop.css contains no per-theme branch.

The group is derived once, in the alias block at the bottom of themes.css (--win-bg: var(--bg-raised), --win-radius: var(--radius-lg), and so on). A new theme therefore inherits a coherent desktop for free and overrides only what it actually wants to differ — which is what keeps the group from becoming a second palette every theme has to restate.

Two of them carry more weight than the rest.

--win-border-light / --win-border-dark are a pair. desktop.css always assigns all four window border colours from them. Set them to contrasting values and you get a raised bevel (retro); leave them equal and the bevel vanishes (everything else). One rule, two looks, no conditional anywhere.

That pair is also why nothing may set border-color on a window. The shorthand overrides all four sides at once, which flattens the bevel — and it did, on the focused window, i.e. on the only window the user is looking at. Focus is carried by the titlebar (--win-titlebar-bg-active) and the shadow instead, which is the older and more universal convention anyway.

Window controls are not themeable by placement. Minimize, maximize and close sit at the right end of every window's titlebar in every theme. There was a --win-controls-order token that let glass move them to the left, macOS-style; it was removed so the buttons are always where the user last found them, whatever theme is on.

Selecting one​

Settings → Theme, the tray's ◐ button on the taskbar, the command palette, or the agent (desktop.set_theme, in the lazily-loaded desktop tool group). The choice is the settings.theme setting, so it persists server-side like any other override and follows the user to any browser pointed at the node.

initTheme() runs at boot after loadSettings() and before the first render, so the first paint is already themed rather than flashing the default and correcting itself.

Adding a theme​

  1. Add a :root[data-theme='<id>'] block to themes.css declaring the full primitive set. Copy an existing block — a missing primitive silently falls back to the default theme's value, which reads as a bug rather than as inheritance.
  2. Register it in THEMES in theme.ts. The settings enum, the palette commands, the taskbar's theme menu and the agent's desktop.set_theme catalog are all derived from that array, so there is nothing else to update.
  3. Override only the --win-* / --taskbar-* tokens you want to differ. The rest are derived from your primitives and will already look right.

Do not add a primitive to one theme only. A token that exists in one theme and not another is a component that renders correctly under exactly one setting.

The rules that are load-bearing​

A component never hardcodes a colour. If a component needs a colour that isn't a token, add the token to every theme rather than a literal to that component: a literal is invisible to the switcher and survives unchanged into a theme it was never designed for. This is the same rule fonts.css states for font faces.

:root unqualified carries the default theme. A document with no data-theme — or one naming a theme that no longer exists — still renders in full instead of losing its palette. :root[data-theme='…'] scores 0,2,0 against :root's 0,1,0, so a named theme always wins regardless of source order.

applyTheme refuses an unknown id and writes the default instead. A theme can be removed, or a setting can be restored from a machine that had a plugin theme installed; writing that id through would leave the app on :root's values while the settings page claimed otherwise.

Aliases are declared once and resolve per theme. --surface, --fg, --ok and friends are older spellings still read from ~40 files. They are defined in one block at the bottom of themes.css as var() references to primitives — because that block and the theme blocks both match <html>, an alias resolves against whichever theme is active, so a new theme declares primitives only.

Those aliases were, until this system existed, referenced but never defined anywhere — always as a fallback pair like var(--fg-muted, var(--fg)). With neither half defined the declaration is invalid at computed-value time and the property quietly inherits, so those call sites were styled by accident. Defining the aliases fixes them and brings them under the switcher in one move; they are kept as aliases rather than renamed across 40 files, which is a separate change.

The scale: space, type, elevation, motion​

Colour was tokenised from the start. Space, type, elevation and motion were not — themes.css held a palette, a radius scale and two shadows, and nothing else. With no scale to reach for, all 1,987 inline style={{}} objects in the app picked their own fontSize: 11, gap: 6, padding: '6px 0'. Two panes docked side by side in one frame could not line up: not by accident, by construction. That is what reads as unfinished even when each pane in isolation is carefully made.

GroupTokensNotes
Spacing--space-0 … --space-82px base opening up: 0, 2, 4, 6, 8, 12, 16, 24, 32. --space-4 is the default gutter inside a row
Type--fs-micro --fs-meta --fs-label --fs-body --fs-lead --fs-displayNamed for the job, not the size — a row's identity is --fs-label, its figures --fs-meta
Tracking--tracking-display (0.14em), --tracking-badge (0.1em)The only two non-zero values the house style uses
Weight--fw-regular --fw-medium --fw-bold
Elevation--elev-0 --elev-1 --elev-2Aliases of --shadow-card / --shadow-overlay
Motion--dur-fast --dur-base --dur-slow, --ease-standard --ease-entrance, --stagger-step
Controls--control-h (30px)The one height every input, select and button settles on — see The card

None of these values is invented: they are the ones datalist.css had already settled on, promoted so everything else can use them. Sizes that look oddly precise (10.5px, 12.5px) are measured — rounding them would silently reflow every row.

Unlike colour, the scale is theme-independent. A theme changes how the app looks, not how far apart things sit. --radius-* is the deliberate exception and stays per-theme, because a radius genuinely is part of a theme's character. The scale is deliberately sharp: midnight runs 0/1/2/2 and glass, the softest, only reaches 6px at --radius-xl. The app's look is angular and technical — full-perimeter rounding reads as a generic card stack — and --radius-lg keeping a couple of pixels rather than dropping to 0 is what stops a window corner aliasing against its own drop shadow. hud and retro are square outright.

The notebook module is the first converted end to end, and design-tokens.test.ts holds it there: a literal font-size fails, in CSS and in React style objects alike. See Rendering a cell for the job-to-step table and the two rules that decided its awkward cases.

Elevation has three steps, not five​

--elev-1 and --elev-2 alias the two shadows each theme already declares, rather than introducing a middle step. A ramp with a rung no theme designed is a ramp that looks wrong in five of the six themes.

The card: a list item you fill in​

DataList gave "a record you read" one shape and Primitives gave the controls around a list one shape. Neither covers the third thing the app keeps drawing: an item that is a small form. A registry entry, a marketplace plugin, a downloadable model — each has an identity, some prose, a command you want to read before you commit, two or three inputs, and a pair of buttons. A DataRow cannot hold that without its head line collapsing, so every such feed grew its own <div> with its own padding and its own idea of where the buttons go.

packages/core/src/ResourceCard.tsx is that third primitive.

ExportWhat it is
ResourceCardListThe feed. A <ul>, gutter --space-5 — cards are far taller than rows
ResourceCardOne item: header → body → configuration → footer, in that order and only that order
ControlRowInline fields that line up. An auto-filling grid, so they reflow rather than crush
ControlBarOne subject and the buttons acting on it — a search box and its Search
CodeChipA read-only command, endpoint or parameter. lead colours the runner/protocol
CaptionThe quiet aside. Where a long helper string goes instead of the action bar
StackA vertical stack at the card gutter — one number instead of a margin per child

The type contract is the design, as in the other two files:

The order of the props is the order on screen. A caller cannot put the buttons above the summary, because no prop would do it.

Nothing takes a colour, a size or a style. kind is a meaning, drawn from RowKind — the same vocabulary a row's verdict uses — so ok is the same green in a card as in a row and the reader learns it once.

Every section renders nothing when empty. That is what makes the component survive the conditional cases (an entry with no install options, a remote with no arguments, a card with no snippet) instead of leaving a gap where a border was.

One control height​

--control-h (30px) is imposed in controls.css at the element level for input and select — not only on .hd-field — as well as in primitives.css. Those shapes have different intrinsic heights, so a form row built from a select, a text input and a small button is ragged unless one number is imposed on all of them — and a row of controls that do not share a baseline is the single loudest sign of an unfinished form.

The element-level rule matters because most of this app is not built from the primitives: 701 raw <button> against 74 <Button>, and --control-h was referenced in exactly four places, all inside primitives.css and resourcecard.css. A form built from bare elements therefore had three intrinsic heights in a row and never lined up, which is the mechanism behind the observation that two panes docked side by side never agreed.

It is a fixed height with the vertical padding removed, not a min-height: with padding left in, an input settled at 34px while a <select> settled at 36px (native rendering reserves room for its own arrow), so a row containing both was still 2px ragged — exactly the defect the rule exists to prevent. textarea is the one shape excluded, since it has to grow; it keeps its padding and floors at two control-heights.

The rule covers input:not([type]) as well as the typed selectors, and that is not belt-and-braces. An attribute selector matches the attribute, not the default it stands in for, so <input> with no type= — 114 of them here against 131 typed — matched nothing and kept its UA height of 21px beside a 30px select. That 9px gap is exactly the raggedness this rule exists to remove, and it was invisible because the rule looked like it covered everything. checkbox, radio, range, color and file stay typed-only on purpose: they must keep their intrinsic sizing, and :not([type]) can only ever be a text box.

One rule later in styles.css was quietly undoing the other half. A button, select { padding: 0.35rem 0.75rem } block at equal specificity put 5.6px back above and below every select in the app, leaving a 16.8px content box inside a 30px control — tight enough to fit 0.8rem text and clip anything larger. It now sets padding-block: 0 for the select half. A <button> keeps it: nothing fixes a bare button's height, so for a button the padding is the height.

Never re-add vertical padding to a control in an inline style. The height is fixed, so padding does not grow the box — it eats it. padding: 0.5rem on a 30px select leaves 30 − 16 − 2 = 12px of content box for 12.8px text: the top padding pushes the label down and it clips along the bottom edge. Text inputs survive it looking merely tight, which is what makes it easy to ship; a <select> does not, because it is also reserving room for its arrow, so the dropdowns are where it shows up first. If a control needs to look roomier, it wants a larger --control-h in a scope, not padding. Style horizontal padding only (padding: 0 0.6rem).

packages/core/src/__tests__/control-padding.test.ts is the guard, and it is zero tolerance rather than a ratchet — every occurrence was fixed when it was written, so a new one is always a regression. It reads both shapes the twenty real occurrences used: an inline style object, and a shared const referenced by style={…} (one wrong object in the Clubhouse Voice Agent panel was inherited by fourteen controls at once).

Buttons, and why their rule is scoped​

Buttons get the same 30px, but not from a bare button selector. A live census across seven panes found 322 buttons at 22 distinct heights, with the ordinary actions — Save, Refresh, Copy path, Clear cache, × — landing anywhere from 21px to 34px purely from how each one's font size composed with the shared 0.35rem vertical padding.

An element-wide button { min-height } was tried first and is wrong here. <button> is this codebase's generic interactive element: 47 distinct button classes are rows, chips, tabs, menu items, breadcrumbs, carousel dots or cards. The database sidebar's 55 table rows are buttons, and the element-wide rule grew every one from 25px to 30px — a list half again as tall. Worse, min-height beats height at any specificity, so a component that had already sized itself could not opt out by being more specific: .switch sets height: 26px and was stretched with its pill distorted. That shape needs an exemption list longer than the rule, growing with every new pane.

button:not([class]) inverts it. A button with no class never asked to look like anything in particular — it is relying on the element default, which is exactly the population the standard is about and where Save/Refresh/×/Menu live. Everything that is a row, chip or tab carries a class and is untouched, with no list to maintain. A short list of named action-button classes (.hd-btn, .setting-button, .lib-btn, .dbc-btn, …) joins them. The rule to remember:

A classless button is a standard 30px control. Give it a class if it is something else — and .btn-mini is the opt-in escape hatch for a classless button that is genuinely tiny (the chart-header LIN/LOG and ✕ controls).

Same mechanism as the inputs: min-height with the vertical padding zeroed, never a fixed height. Padding cannot standardise anything on its own — it composes with the font size, which is why one button sat at 34px and another at 21px under the identical declaration. Zeroing it lands every single-line button on exactly 30px whatever its type size, while a classless button holding two lines still grows past it (the settings "Re-probe" wraps to 44px), which a fixed height would have clipped. After the change, 108 buttons sit at exactly 30px against 50 before, and every deliberate shape — dots at 7px, reset links at 15px, tree rows at 20px, window chrome at 22px, tabs at 25px, switches at 26px, cards at 104px — is unchanged.

Width​

select additionally takes min-width: 0. A select sizes to its longest option string unless told otherwise, and min-width: auto is the flex default — which is how the Settings "Model override" select measured 413px inside a 348px pane, escaping its container with no way to scroll to it. Panes here are user-resized down to ~320px, so no control may derive its width from its content.

It sits with the scale rather than with a theme, for the scale's reason: how tall a text box is does not change when you change how the app looks.

Field grew one layout affordance, span="full", and it is deliberately not a width: it says "this field wants the whole line" and leaves the container to decide what a line is. A field that could name its own pixels is a field that will eventually be 260px inside a 200px dock.

ControlRow uses auto-fill rather than auto-fit for the same reason. auto-fit collapses the empty tracks, so a card with a single "Server id" gave that one input the card's entire width — an id field 760px long, which reads as a mistake because it is one.

A chip is a soft pill​

A verdict chip is now a translucent wash of its own colour behind a matching border, rather than a bare outline — an outline alone at --fs-micro reads as a text input, which is the wrong affordance entirely. The wash is color-mixed from the semantic colour, so a new theme gets all four states from its accent and status colours for free.

Its radius is calc(var(--radius-sm) * 4) rather than a hardcoded 999px. A chip is about 20px tall, so that is fully round in midnight and studio while the two themes that deliberately set every radius to 0 keep their square tags. Pinning the pill would have overridden a theme author's decision app-wide, which is the one thing the per-theme radius exists to prevent.

The same reasoning governs the card's own surface: its top-edge inset highlight is mixed from --text, not from white, so it stays a highlight on a dark theme and becomes a soft shadow line on a light one. A hardcoded white inset is invisible on half the themes and wrong on the rest.

The guard​

packages/core/src/__tests__/design-tokens.test.ts fails the build on any var(--token) that resolves to nothing, and asserts the scale groups above still exist.

It exists because the alias problem described in the previous section happened again, unnoticed, at a larger scale: a later audit found 16 undefined tokens across 25 files. --border-dim and --text-primary alone accounted for 14 files each. Every one of those declarations was invalid at computed-value time and fell through to its hardcoded hex fallback, so LocalTrack, Trajectories and parts of games and hassault rendered a fixed GitHub-dark palette in all six themes while appearing, in the source, to be fully themed.

That is the failure mode worth naming: a missing token does not look like a bug. It looks like a theme nobody likes. Nothing throws, nothing warns, the pane just quietly ignores the switcher — and the fallback makes it look deliberate.

The mirror image is worth naming too: var(--token, #hex) where the hex is not the token's value. var(--danger, #e5534b) appeared a dozen times, and #e5534b is no theme's danger — midnight's is #e06c75, hud's #ff3860. Since the guard above guarantees --danger resolves, that fallback is dead code holding a wrong colour: it reads as a considered default, it is never used, and the day someone renames the token it becomes the one thing standing between a broken theme and a visible error. The notebook module now writes var(--danger) bare. A fallback is only honest when it repeats the token's own value, at which point it earns nothing.

The other half: literals​

The token guard cannot see the opposite failure — a literal #161b22 in an inline style object, which names no token at all and so is invisible to the switcher by construction. That half was the larger one. Whole modules were painted in other products' palettes (GitHub Primer dark, Tailwind defaults), and one had hardcoded the app's own midnight values, which is the worst case: it looks correct in the default theme and silently ignores the other five. Switching to daylight rendered one pane light and the pane beside it fully dark.

packages/core/src/__tests__/no-hex-literals.test.ts is the ratchet for it. It counts hex literals in .ts/.tsx across three buckets and fails when any bucket grows:

BucketWhat it is
restCode that is supposed to be theme-driven. The number that should fall.
excludedgames, hassault, clubhouse — held out by an explicit scope decision.
canvasCall sites that genuinely cannot read a custom property.

Two things are worth being honest about. The excluded modules hold the three worst files in the app, so this guard protects new and recently-cleaned code rather than retroactively cleaning them — the ratchet only stops them getting worse. And the canvas bucket is small: "it has to be a literal because it is drawn to a canvas" turns out to explain almost none of the hardcoded colour here.

The guard's mechanics​

The test collects declarations from three spellings, because all three are in use and missing one turns a legitimate local variable into a false failure:

--x: 1px /* CSS */
'--x': value /* inline style */
['--x' as string]: value /* the cast form React/TS needs */

When it fails, the fix is usually to add the name to the alias block — most offenders are another spelling of a token that already exists.

Icons​

packages/core/src/glyphs.tsx is the shared icon set: drawn vectors on a 16x16 box at a 1.5 stroke, inheriting currentColor, sized from --icon-size (13px — the size that sits on the cap height of --fs-label, which is the type an icon almost always appears beside).

DESIGN.md's rule has always been that an in-pane icon is a drawn vector and never a native emoji — the one documented exception being a pane manifest's icon: field, which is the taskbar's own convention. The rule was widely broken for a boring reason: there was nowhere to get an icon from, so every pane reached for the glyph on its keyboard. A rule with no supply is a rule that loses.

It lives in core rather than ui because core modules need it and core -> ui would be an import cycle. Sizing is done in CSS (.hd-icon), not on the width and height attributes: a var() is not valid in an SVG geometry attribute and fails silently to the 300x150 replaced-element default.

Controls​

A theme is not only a palette — it is also the shape of the things you click, so the control primitives live in the theme layer (controls.css) rather than in any one pane. Checkboxes and radios are repainted from the browser's default blue into the theme's own accent, corners follow --radius-sm, focus is one accent ring everywhere, and .switch / .select-wrap are there for the two controls that have no acceptable native form.

Two rules in that file are load-bearing:

The fill is the state, not the glyph. A checked checkbox is a solid accent box whose tick is a bonus. Pseudo-element support on appearance: none inputs is near-universal but not guaranteed by spec, and a control whose only state signal was the tick would silently become unreadable if it ever failed to draw. This way the worst case is a checkbox without a tick, which is still unambiguous.

No data-URI SVG for the tick or the select chevron. An SVG data URI cannot read a custom property, so any icon drawn that way carries a hardcoded colour into every theme. Both are drawn with CSS instead — borders on a rotated box, and a text glyph in a pseudo-element.

Everything is element-level, i.e. a baseline. Panes that already style their own inputs by class (.lib-input, .dbc-field input, …) still win on specificity and are unaffected; they inherit the improvement only where they had no opinion.

.select-wrap is opt-in: a bare <select> keeps its native arrow, so nothing loses its affordance by default.

JavaScript consumers​

A theme is CSS, so almost nothing needs to know it changed. The exception is code that reads token values into JavaScript — an MUI palette, a canvas, anything drawing to a 2D context. None of those can see a CSS variable.

Such a consumer subscribes with useThemeId() and re-reads through readThemeTokens(), which resolves the properties off <html> via getComputedStyle. Resolved, not declared: an alias like --surface is defined as var(--bg-raised), and only the collapsed value is usable by a canvas.

packages/core/src/modules/games/mui-theme.tsx is the reference consumer. Two things there are easy to get wrong:

  • Ordering. initTheme() registers its settings subscriber at boot, and listeners fire in insertion order, so the data-theme attribute is always updated before a component that subscribed on mount re-renders. A consumer that applied the theme itself, later in the list, would read the outgoing theme's values on the render following a switch.
  • shape.borderRadius is a number of pixels, not a CSS length. Passing "16px" straight through yields border-radius: 16pxpx; parse it.

Typography​

Four families ship, as six self-hosted woff2 files (361 KB total) in packages/ui/src/fonts/, bundled by Vite into every web build and desktop installer. Never the Google Fonts CDN — the app is offline-first, so a network dependency for text means unstyled UI on a plane.

FamilyTokenRole
Geist--font-sans in midnightThe UI face of the default theme
DM Sans--font-sans in studio, glass, daylightThe Settings Kit face
Instrument Serif--font-displayThe one editorial face, upright + italic
JetBrains Mono--font-mono, app-wideEvery code surface and every figure, upright + italic

Naming a font is not shipping one​

--font-mono had listed 'JetBrains Mono' since the token existed — fourth in the stack, behind three faces that ship with an operating system. A stack does not choose a font; it chooses whichever font the machine already has. So that entry was only ever reached by a user who had installed JetBrains Mono themselves, and the same editor, diff and log rendered in Cascadia on one box and Menlo on another. The app's code surfaces had no typography of their own at all.

midnight had the same problem one level up: a bare 'Segoe UI', system-ui stack made the default theme the one whose type was whatever the OS supplied, while the three themes that wanted a designed face all had to name DM Sans to get one.

Self-hosting is what makes a font token mean something. The rest of each stack stays as the fallback for the first paint before the woff2 lands.

Every face is variable, and the mono italic is not optional​

Each file covers its whole weight range in one request (Geist 100–900, JetBrains Mono 100–800, DM Sans 100–1000), so font-weight: 500 on a chip and 700 on a heading cost nothing extra. Static faces mean one file per weight, and the weight nobody remembered to ship gets silently synthesised into a smeared fake bold.

The JetBrains Mono italic is a separate file and is load-bearing. Every syntax theme italicises something; with no italic face the browser makes one by shearing the upright, and on a monospace face that changes the advance width — so a line of italic comment stops lining up with the code above it, which is the one thing a monospace font exists to guarantee. Measured after the change: iiiiiiiiii is 96.000px upright and 96.000px italic.

They are the upstream fonts from github.com/google/fonts (ofl/dmsans, ofl/instrumentserif, ofl/geist, ofl/jetbrainsmono), converted TTF → woff2 locally, rather than the files the Google Fonts CSS API serves. The API splits each family into latin and latin-ext subsets paired with unicode-range; taking one file per face from that — which is what fonts.css assumes — silently drops every accented character outside Latin-1, and the failure is invisible until a peer's name or a karaoke title contains one and a single glyph renders in the fallback face. See the provenance note in fonts.css for the conversion command.

All four families are SIL OFL 1.1 and the licences ship beside them as OFL-*.txt, which is what the licence asks of anyone redistributing the binaries.

--font-display is the app's one editorial face and is declared identically in both themes. That is deliberate rather than an oversight: pointing midnight's display face at --font-sans would silently strip the serif from every surface that reads the token — today, the games lobby's hero and ceremony type, which consumes it through --games-display.

--font-mono is deliberately not per-theme. A theme changes how the app looks, not which glyphs line up.