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.
| Where | What |
|---|---|
packages/ui/src/themes.css | The themes. One block of primitives each, plus a shared alias block. |
packages/ui/src/controls.css | The control primitives — checkbox, radio, switch, input, select — built on those tokens. |
packages/core/src/theme.ts | The switch: the theme list, applyTheme, initTheme, and the hooks for JS-side consumers. |
packages/core/src/modules/settings/index.ts | Declares the settings.theme setting and one palette command per theme. |
apps/web/src/main.tsx | Calls 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:
| id | The idea |
|---|---|
glass | Translucent chrome over the desktop backdrop. Real backdrop-filter blur on the chrome and the status bar, and large radii. |
hud | Terminal 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. |
daylight | The light productivity theme: opaque surfaces, a faint cool tint, and elevation you can actually see because the ground is bright. |
retro | Beveled 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
- Add a
:root[data-theme='<id>']block tothemes.cssdeclaring 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. - Register it in
THEMESintheme.ts. The settings enum, the palette commands, the taskbar's theme menu and the agent'sdesktop.set_themecatalog are all derived from that array, so there is nothing else to update. - 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.
| Group | Tokens | Notes |
|---|---|---|
| Spacing | --space-0 … --space-8 | 2px 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-display | Named 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-2 | Aliases 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.
| Export | What it is |
|---|---|
ResourceCardList | The feed. A <ul>, gutter --space-5 — cards are far taller than rows |
ResourceCard | One item: header → body → configuration → footer, in that order and only that order |
ControlRow | Inline fields that line up. An auto-filling grid, so they reflow rather than crush |
ControlBar | One subject and the buttons acting on it — a search box and its Search |
CodeChip | A read-only command, endpoint or parameter. lead colours the runner/protocol |
Caption | The quiet aside. Where a long helper string goes instead of the action bar |
Stack | A 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-miniis 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:
| Bucket | What it is |
|---|---|
rest | Code that is supposed to be theme-driven. The number that should fall. |
excluded | games, hassault, clubhouse — held out by an explicit scope decision. |
canvas | Call 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 thedata-themeattribute 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.borderRadiusis a number of pixels, not a CSS length. Passing"16px"straight through yieldsborder-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.
| Family | Token | Role |
|---|---|---|
| Geist | --font-sans in midnight | The UI face of the default theme |
| DM Sans | --font-sans in studio, glass, daylight | The Settings Kit face |
| Instrument Serif | --font-display | The one editorial face, upright + italic |
| JetBrains Mono | --font-mono, app-wide | Every 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.