calsee_themes

Endless generated themes for Flutter. Users swipe and get a new look: new colours, shapes, fonts, key press motion and backdrop. Every theme belongs to one of twelve visual families.

The themes come from the Calsee calculator. This package lets any app use them on any screen: your widgets and logic stay as they are, and the package handles how they look.

Picture a kids' maths game where a swipe gives the number pad a new look. Each one passes the contrast checks, so every look stays easy to read.

Swiping between generated themes on a kids' maths game

The same maths game in twelve theme families

Features

An endless feed of themes. It's seeded and bit-exact: a given seed shows the same themes on every device. Swipe forward for a new theme, or back for the exact previous one.
Twelve families: Claymorphism, Liquid Glass, NeoPOP, Retro, Cyberpunk, Paper & Ink, Neumorphism, Y2K Aero, Vaporwave, Neo-brutalism, Material 3 Expressive and Bauhaus.
Drop-in widgets. Themed keys and buttons with each family's spring press (Clay squishes, NeoPOP extrudes, Glass inflates), form controls (checkboxes, radios, switches, segmented buttons, sliders, dropdowns, expandable sections and text fields), plus backdrops with ambient artwork, display panels and display text.
Steerable. Describe a look (colours, light or dark, how colourful) and the feed generates endless variations on it. Pair it with an on-device model to turn "playful greenery" into themes.
Readable by construction. Every generated theme passes contrast guardrails, including colour-blindness checks. There's an accessible mode with stricter contrast, and the widgets follow High Contrast, Reduce Motion and Bold Text.
No setup. The fonts are bundled (all SIL OFL), it works fully offline, and it supports Flutter 3.35 and newer.

Install

dependencies:
  calsee_themes: ^2.0.0

import 'package:calsee_themes/calsee_themes.dart';

Quick start

Wrap a screen in a CalseeScope, then build it from the themed widgets:

CalseeScope(
  child: CalseeBackdrop(
    child: Column(
      children: [
        // Swipe the sum for a new theme.
        Expanded(
          child: CalseeSwipeArea(
            child: Center(
              child: CalseeDisplayPanel(
                child: CalseeReadout('7 + 5 = ?', size: 64),
              ),
            ),
          ),
        ),
        SizedBox(
          height: 64,
          child: CalseeKey.text('OK', role: KeyRole.equals, onPressed: check),
        ),
        // ...a grid of CalseeKey.text('1', role: KeyRole.digit, ...)
      ],
    ),
  ),
)

Only what's below the scope is themed, so you can add themes to a single screen of an existing app. Your handlers (check, onKey) stay exactly as they are.

Theming an existing screen

Swap each visual piece for its themed version and keep your callbacks.

Your widget	Themed version
Screen background	`CalseeBackdrop`
Number keys	`CalseeKey.text(d, role: KeyRole.digit)`
`.` key	`CalseeKey.text('.', role: KeyRole.decimal)`
Backspace	`CalseeKey.icon(..., role: KeyRole.backspace)`
Primary action (OK, Submit)	`CalseeKey.text(..., role: KeyRole.equals)` (the theme's accent)
Secondary actions	`KeyRole.operator` or `KeyRole.function`
Amount, score or timer	`CalseeDisplayPanel` + `CalseeReadout`
Cards and tiles that aren't buttons	`CalseeSurface`
Checkbox, radio button, switch	`CalseeCheckbox`, `CalseeRadio`, `CalseeSwitch`
Segmented buttons, slider	`CalseeSegmented`, `CalseeSlider`
Dropdown, expandable section	`CalseeDropdown`, `CalseeExpandable`
Text input	`CalseeTextField`
Other text	`CalseeTextColors.of(context)` (`primary`, `secondary`)

For any other colour, font or shape, read the theme directly with CalcTheme.of(context).

The example app is a complete kids' maths game built this way.

Drawing themed UI covers every element with a snippet and its full source. The live gallery runs each example in your browser, in every family but Bauhaus.

Keeping the user's theme

The feed is a small JSON object. Save it whenever it changes and restore it at launch:

CalseeScope(
  savedState: prefs.getString('theme') == null
      ? null
      : jsonDecode(prefs.getString('theme')!),
  onChanged: (state) => prefs.setString('theme', jsonEncode(state)),
  child: ...,
)

To change themes from your own UI (buttons, a menu, a timer), use the controller:

final themes = CalseeScope.of(context);
themes.next();
themes.previous();
themes.spec.name; // e.g. "Tide Gumdrop"

Choosing families

CalseeScope(
  families: const [
    ThemeFamily.claymorphism,
    ThemeFamily.liquidGlass,
    ThemeFamily.retro,
  ],
  child: ...,
)

Two families reshape keys by role: Material 3 Expressive (blob and pentagon shapes) and Bauhaus (circles and triangles). On screens where one button must always look like a plain button, such as a checkout or sign-in button, leave those two out.

Steering themes from words

A ThemeIntent describes the look you want. Every field is optional:

final themes = CalseeThemeController(
  intent: ThemeIntent(
    brightness: ThemeBrightness.light,
    colors: const [IntentColor.green, IntentColor.lime],
    chroma: IntentChroma.vivid,
    harmony: HarmonyScheme.analogous,
    name: 'Playful Greenery',
  ),
);
// Later: themes.intent = …; or null for the normal feed.

The feed then shows endless variations on the intent, starting with the one closest to its centre. Every theme still passes the contrast guardrails. Every family follows the colours and keeps its own look: "red" Cyberpunk is red neon, "green" Bauhaus has green and a second strong accent. The first colour goes on the operators (Claymorphism: its body), the second on =, the third on the function keys. intent.reportFor(family) lists the hints a family can't follow, for example "light" for NeoPOP, which is dark-only.

To turn a user's words into an intent, give a model the format and parse what it returns:

final prompt = ThemeIntent.promptFragment(); // or ThemeIntent.jsonSchema()
final result = ThemeIntent.parse(modelOutput); // never throws
themes.intent = result.intent; // result.dropped lists what was ignored

ThemeIntent.vocabulary has every field and value, each with a one-line description, so you can build your own prompt or schema. The package never sees the user's words, and nothing leaves the device unless your app sends it.

Accessibility

Every theme passes contrast guardrails for text, keys and the display. The checks include colour-blindness simulation.
CalseeThemeController(accessible: true) shows only themes that pass stricter contrast. You can also set controller.accessible at runtime.
When the platform's High Contrast setting is on, the scope resolves themes in high contrast.
Reduce Motion turns off spring presses and ambient animation, and Bold Text makes key labels heavier.

themeOfTheDay(DateTime.now()) gives every user the same theme on a given day. Show it with controller.jumpTo(...).
Share codes (FeedEntry.shareCode, decodeShareCode, FeedEntry.fromSharePayload) let users send each other a theme. Steered themes get a longer code that carries the intent.
CalcThemeData (from CalcTheme.of) exposes the colours, fonts, springs and renderers behind every widget here.

App size

Adding the package to a release build costs about 3.4 MB on Android and 4.5 MB on iOS:

Release build	Without	With	Added	Dart code	Fonts
Android APK (arm64)	14.3 MB	17.7 MB	+3.4 MB	+1.4 MB	+1.7 MB
iOS `Runner.app`	13.3 MB	17.8 MB	+4.5 MB	+1.5 MB	+2.9 MB

The figures compare two minimal apps built with Flutter 3.47.6: a screen with a readout and four keys, made once from plain widgets and once from CalseeScope with all twelve families. The APK figures are compressed sizes. The iOS figures are the unpacked app bundle, so the App Store download is smaller. Most of the remaining 0.3 MB on Android is the dynamic_color plugin's Java code and resources.

Fonts and licence

The package is MIT-licensed. Its fonts are bundled under the SIL Open Font License 1.1: Roboto Flex, Space Grotesk, Nunito, Open Sans, Newsreader, Oxanium, Anybody, Jost, Patrick Hand, Noto Sans Devanagari and Calsee Symbols. Sources and checksums are in fonts/README.md. Together they take 2.9 MB uncompressed (1.7 MB compressed in an APK).

Libraries

accessible_text
calc_theme
calc_theme_data
calsee_themes: Infinite, seeded themes from the Calsee calculator: an endless feed of generated themes in a dozen visual families (Claymorphism, Liquid Glass, NeoPOP, Retro, Cyberpunk, ...), with key, backdrop and display renderers that draw them.
chrome_style: Per-family Material chrome: the settings, history, dialogs and sheets around the calculator take their family's type, shapes, edges and surfaces, not just its colours.
contrast
display_face: The display-style seam (docs/m4-design.md §B): how a theme draws the calculator display's glyphs and the panel behind them.
engine/bauhaus: The Bauhaus family (id 15): the Weimar / Dessau poster and the workshop toy — only red, yellow and blue plus black and cream (sometimes ochre), only primitives (block, disc, quarter-disc, half-disc, triangle, bar), flat opaque colour, no shadow, gradient, outline, texture or glow. Pure Dart: part of the generator, so every constant here is part of the family's engine-v3 definition and must not change once it ships.
engine/bauhaus_heroes: Hand-crafted Bauhaus heroes (≥ 3 per family), spread into heroThemes (heroes.dart).
engine/bitexact_math: Bit-exact maths for theme generation (research theme-engine.md §2.5, Recommendation 10).
engine/claymorphism: The Claymorphism family (spec §5.3 #7; motion brief §2.3 "Claymorphism"; design: inflated, matte, soft-touch plasticine). Pure Dart: part of the generator, so every constant here is part of the family's engine-v3 definition and must not change without a version bump.
engine/claymorphism_heroes: Hand-crafted Claymorphism heroes (≥ 3 per family), spread into heroThemes (heroes.dart).
engine/contrast: WCAG 2.2 contrast on 8-bit ARGB and OKLCH-lightness repair (research theme-engine.md §4, Recommendations 3–4).
engine/cvd: Colour-vision-deficiency simulation and distinctness (research theme-engine.md §6, Recommendation 6).
engine/cyberpunk: The Cyberpunk family (new family, id 13; heroes 130–132): a night-city HUD keypad. Pure Dart: part of the generator, so every constant here is part of the family's engine-v3 definition and must not change without a version bump once v3 ships with it.
engine/cyberpunk_heroes: Hand-crafted Cyberpunk heroes (≥ 3 per family), spread into heroThemes (heroes.dart).
engine/families: Theme families (spec §5.3) and what each may generate (spec §5.2): allowed shapes, styles, fonts, backgrounds and effects with integer weights, harmony schemes, OKLCH role ranges for dark and light themes (research theme-engine.md §5.3) and motion tokens plus their seeded ranges (motion brief §2.3, §2.5).
engine/generator: The theme generator (spec §5.2; research theme-engine.md Recommendations 5–8, 11 and §12; motion brief §2.5).
engine/guardrails: Theme guardrails (spec §5.4; docs/m3-theme-engine-design.md "Rules"; research theme-engine.md §4, §6.2, §12): validate a ThemeSpec on its final quantised ARGB values, and repair failures by OKLCH lightness bisection.
engine/heroes: Hand-crafted hero themes (spec §5.2: "every ~8–12 swipes, inject a hand-crafted hero theme"; design doc: ≥ 3 per enabled family).
engine/liquid_glass: The Liquid Glass family (spec §5.3 #2; motion brief §2.3 "Liquid Glass"): translucent keys over a vivid, slowly drifting mesh-gradient background, with specular highlights, a refraction hint and a jelly press. Glass is for the controls: the display sits on a solid-enough backing panel.
engine/liquid_glass_heroes: Hand-crafted Liquid Glass heroes (design doc: ≥ 3 per family), spread into heroThemes (heroes.dart).
engine/names: Deterministic procedural theme names (research theme-engine.md §10, Recommendation 12): Colour Material, Mood Colour, Colour Time/Place and Material Mood-noun.
engine/neo_brutalism: The Neo-brutalism family (spec §5.3 #6; motion brief §2.3 "Neo-brutalism"): thick black outlines, offset hard shadows, saturated flat fills and chunky grotesque type. Pure Dart: part of the generator, so every constant here is part of the family's engine-v2 definition and must not change without a version bump.
engine/neo_brutalism_heroes: Hand-crafted Neo-brutalism heroes (≥ 3 per family), spread into heroThemes (heroes.dart).
engine/neumorphism: The Neumorphism (Soft UI) palette builder (spec §5.3 #4; docs/m4-design.md §C; research theme-engine.md recommendation 7 and §7.2). Pure Dart: part of the generator, so every value here is part of the family's engine-v2 definition and must not change without a version bump.
engine/neumorphism_heroes: Hand-crafted Neumorphism (Soft UI) heroes (docs/m4-design.md §C: ≥ 3 per family), spread into heroThemes (heroes.dart).
engine/oklab: OKLab / OKLCH ↔ linear sRGB ↔ 8-bit ARGB, and gamut mapping (research theme-engine.md §2–3, Recommendations 1–2).
engine/paper_ink: The Paper & ink family (spec §5.3 #11; motion brief §2.3 "Paper & ink"): stationery and editorial print. Pure Dart: part of the generator, so every constant here is part of the family's engine-v3 definition and must not change once a build ships it.
engine/paper_ink_heroes: Hand-picked Paper & ink heroes (≥ 3 per family), spread into heroThemes (heroes.dart).
engine/retro: The Retro hardware family's palette builder (spec §5.3 #5; motion brief §2.3 "Retro hardware"; docs/m4-design.md §B): a 90s desk or pocket calculator.
engine/retro_heroes: Hand-crafted Retro hardware heroes (docs/m4-design.md §B: ≥ 3 per family), spread into heroThemes (heroes.dart).
engine/rng: Seeded, platform-identical pseudo-random numbers for theme generation (research theme-engine.md §9, Recommendation 9).
engine/share_code: Share codes and deep links (research theme-engine.md §11, Recommendation 13).
engine/srgb_tables.g
engine/steering: How a ThemeIntent narrows one generator attempt (engine v4). Internal: the generator and the family builders call it; hosts use ThemeIntent.
engine/theme_feed: The swipe feed (spec §5.2, §6.1, §6.2; design doc theme_feed.dart): a history stack where back returns the exact previous theme, next / previous, a hero every 8–12 new themes (seeded), a family filter, a 3-ahead prefetch hook, the lock, and the theme of the day.
engine/theme_intent: Steering hints for generated themes (engine v4): a small, bounded, JSON-friendly description of the look a host wants ("playful greenery" → light, green and lime, vivid, analogous).
engine/theme_spec: The theme data model (spec §5.1; docs/m3-theme-engine-design.md).
engine/vaporwave: The Vaporwave family (family id 14): late-night mall-soft and outrun. A striped retro sun sinking into a neon perspective-grid floor under a sunset sky, with a floating Windows-95-era window for the display and chunky bevelled buttons in pastel periwinkle, lavender, lilac or baby pink (function keys also peach), plus hot-pink, magenta, violet or coral and cyan or aqua accents. Pure Dart: part of the generator, so every constant here is part of the family's engine-v3 definition and must not change without a version bump once a build ships it.
engine/vaporwave_heroes: Hand-picked Vaporwave heroes (ids 140–142), spread into heroThemes (heroes.dart).
engine/y2k_aero: The Y2K / Frutiger Aero family (spec §5.3 #10, enum y2kChrome, chip label "Y2K Aero"; motion brief §2.3 "Y2K / chrome"): 2001–2008 glossy optimism. Pure Dart: part of the generator, so every constant here is part of the family's engine-v3 definition and must not change without a version bump.
engine/y2k_aero_heroes: Hand-crafted Y2K / Frutiger Aero heroes (≥ 3 per family), spread into heroThemes (heroes.dart).
key_face
key_press_motion
key_role
live_key: Key pieces that follow the per-frame theme of a transition by repainting only (design doc "60 fps budget: keys repaint without relayout"): the face painter, the label tint, the press scale and the focus ring read CalcTheme.liveOf at paint time, so a theme morph never rebuilds a key or re-runs its label-sizing layout.
plain_theme
render/ambient_drift: Ambient background drift (motion brief §4.13: the Liquid Glass family's "vivid animated background", spec §5.3 #2).
render/background_painter: Calculator backgrounds from a BackgroundSpec (spec §5.1 Background): solid, linear/radial gradients and overlay patterns.
render/bauhaus/bauhaus_display_face: Bauhaus's display (DisplayFace): an opaque sheet (palette surface) with a thick rule down its left edge (shadow: ink on paper and ochre, the field's ink on grid, cream on the night sheet, red on the negative variant's cream sheet — whatever stands out from both the sheet and the ground it hangs into) and a quarter-disc in the = primary (highlight, or the operator / rule colour when the = would blend into the sheet) on its top-right corner — the result key echoed on the sheet. Every glyph is Jost at the theme's display weight on the wght axis (the display's generic path would set only fontWeight), so layout, fitting and semantics are exactly the font's.
render/bauhaus/bauhaus_faces: Bauhaus renderer factories (registered in theme_resolver.dart).
render/bauhaus/bauhaus_key_face: Bauhaus key faces: flat primitives in flat colour — no outline, no shadow, no gradient, no texture.
render/bauhaus/bauhaus_scene: Bauhaus background scene (BackgroundKind.bauhausComposition): a flat poster ground, the grid variant's ink field behind the keypad, a small masthead of primitives in the toolbar and, where the screen has margins beside the calculator column (tablets, desktop), a poster composition in them.
render/claymorphism/clay_display_face: Claymorphism's display (DisplayFace): a puffy pillow card in the opaque surface colour — a soft drop shadow, a lit top-left rim and a shaded bottom-right rim as wide as a key's (≈ 9 dp, 11 dp at the bottom), with its edge lined up with the key faces below. (The recessed tray is retired: it read as an LCD well or a Neumorphism inset.) Display text is set in rounded heavy Nunito (TypeSpec.displayWeight on the wght axis); Nunito lacks ˣ ʸ ₓ ⁻ ∛, which fall back to the platform font.
render/claymorphism/clay_key_face: Claymorphism key faces (spec §5.3 #7; motion brief §2.3 "Claymorphism"): big puffy squircles of opaque, matte plasticine.
render/claymorphism/claymorphism_faces: Claymorphism renderer factories (registered in theme_resolver.dart).
render/claymorphism/claymorphism_scene: Claymorphism background scene (BackgroundKind.claySoft): a soft pastel (or night-clay) wash with two matte clay spheres.
render/cyberpunk/cyber_display_face: Cyberpunk's display (DisplayFace): a recessed black HUD screen — the palette surface as an opaque chamfered plate (top-left and bottom-right cut, like the keys) with faint static lighter scanlines (palette.shadow, snapped to device pixels; none under the Accessible lock), a soft neon glow (dark themes, full effects tier), a 1 dp neon frame (behind a 2 dp rim of the panel's own black on Hazard, as on the Hazard plates), a tick ruler hanging from the top frame line, HUD corner brackets and a segmented status rule on the bottom frame line. None of it carries data, and all of it stays in the 2–6 dp band along the frame, clear of display text. The font (Oxanium) draws every glyph at the theme's display weight on the wght axis, so layout, fitting and semantics are exactly the font's.
render/cyberpunk/cyber_geometry: Cyberpunk key geometry: the chamfered plate (top-left and bottom-right cut), its edge line, HUD ticks, bloom bands, the lite-tier glow ring and the blurred halo image, built once per key size and kept in small static LRUs (CyberKeyGeometry.cached, CyberKeyGeometry.transient, CyberHalo.forPlate) so the per-frame painter recreation of a theme transition never rebuilds them.
render/cyberpunk/cyber_key_face: Cyberpunk key faces: dark chamfered plates (top-left and bottom-right cut, HUD ticks at the other two corners) traced by a neon edge line that bleeds a halo onto the body; operators and = are solid neon slabs with dark labels and a hot rim (a black boundary on the light Hazard body, which has no halo).
render/cyberpunk/cyberpunk_faces: ThemeSpec → Cyberpunk renderers (registered in theme_resolver.dart).
render/cyberpunk/cyberpunk_scene: Cyberpunk background scene (BackgroundKind.cyberGrid): a static circuit board at night.
render/fonts
render/glass/glass_display_face: Liquid Glass's display backing (spec §5.3 #2: "glass is for the controls; keep the display readable with a solid-enough backing").
render/glass/glass_faces: ThemeSpec → Liquid Glass renderers (the resolver's family entries).
render/glass/glass_key_face: Liquid Glass key faces (spec §5.3 #2; motion brief §2.3 "Liquid Glass", §6.5–6.6).
render/glass/glass_rendering: How glass surfaces render on this device (motion brief §6.1 outputs glassMode and effectsTier; spec §4.4 Reduce Transparency, §5.4 graceful degradation). Resolved by motionPreferencesProvider and fed to the theme resolver, so renderers get it at construction and never read platform state while painting.
render/glass/mesh_painter: The mesh-gradient background (BackgroundKind.meshGradient; Liquid Glass's "vivid animated background", spec §5.3 #2): the base colour plus a soft radial blob per further colour, laid out by the spec's angle and drifting on its period (motion brief §4.13, ≥ 40 s).
render/key_face: Shared pieces of the ThemeSpec key renderers (M3 Expressive, NeoPOP and every later family): the ThemedKeyFace base with bundled-font labels, press/state-layer helpers, the long-press fill and PressTranslate (a label that follows the press by repainting, never rebuilding).
render/m3e/m3e_key_face: Material 3 Expressive key faces (motion brief §2.3 row 1).
render/m3e/wallpaper_seed: "Match my wallpaper" (M3 Expressive variant; spec §5.3 #1): reads the Android 12+ wallpaper colour through dynamic_color and hands it to the generator as the seed hue; the generator re-runs every guardrail.
render/neo_brutalism/neo_brutal_display_face: Neo-brutalism's display (DisplayFace): an outlined card in the panel colour (palette surface) sitting on the same offset hard shadow as the keys, with every glyph set in a heavy, wide cut of the display font (TypeSpec.displayWeight on the wght axis, TypeSpec.widthPermille on wdth where the font has one). The font draws every glyph, so layout, fitting and semantics are exactly the font's.
render/neo_brutalism/neo_brutal_key_face: Neo-brutalism key faces (spec §5.3 #6; motion brief §2.3 "Neo-brutalism"): a flat face with a thick ink outline sitting on an offset hard shadow — CSS box-shadow: s s 0 ink, Duolingo's lip.
render/neopop/neopop_key_face: NeoPOP key faces (motion brief §2.3 row 3; CRED look), drawn in-house (no neopop package).
render/neumorphism/neumorphic_key_face: Neumorphism / Soft UI key faces (motion brief §2.3 row 4; docs/m4-design.md §C; research theme-engine.md §7).
render/paper_ink/paper_display_face: Paper & ink's display (DisplayFace): the display is a paper panel in the sheet's ink — a ruled ledger on ruled sheets, a torn index card otherwise — with the serif display face drawing every glyph.
render/paper_ink/paper_grain: Paper & ink's textures: the paper grain tile (flecks, fibres, chalk dust) shared by the sheet, every key slip and the display card, and the sheet's line tiles (ruled, graph, dot grid).
render/paper_ink/paper_ink_faces: Paper & ink renderer factories (registered in theme_resolver.dart): PaperKeyFace keys and the PaperDisplayFace ledger / index card.
render/paper_ink/paper_ink_scene: Paper & ink background scene (BackgroundKind.paperSheet): a sheet of stationery that never moves.
render/paper_ink/paper_key_art: Paper & ink key artwork: hand-drawn fineliner outlines, the operator hatch, the = rubber stamp and the ink-wash blot, built once per (art seed, key size, kind) and cached (PaperArtCache).
render/paper_ink/paper_key_face: Paper & ink key faces (spec §5.3 #11; motion brief §2.3 "Paper & ink"): paper slips outlined by hand with a fineliner, operators in a hatched ink frame, = a rubber stamp.
render/retro/lcd_display_face: Retro's display (DisplayFace): a 7-segment LCD or VFD panel (docs/m4-design.md §B; motion brief §2.3 "Retro hardware", §4.4).
render/retro/retro_key_face: Retro hardware keycaps (motion brief §2.3 "Retro hardware"; docs/m4-design.md §B), drawn in-house.
render/retro/seven_segment: An in-house 7-segment glyph painter (docs/m4-design.md §B: "7-segment LCD display drawn with an in-house segment painter, no font download").
render/shapes: Key shapes as material_new_shapes polygons, and FlatMorph for per-frame morphing (motion brief §6.3; motion-flutter §3.2).
render/theme_resolver: ThemeSpec → CalcThemeData: colours, key renderer, background, fonts and motion springs from the integer tokens (docs/m3-theme-engine-design.md "Layers": theme_resolver.dart).
render/vaporwave/vaporwave_bevel: Vaporwave's hard two-tone Win95 bevel: four tones derived in OKLCH from a face colour at paint time (so per-frame label repair and lerped fills always get matching bevels), memoised in a small static LRU.
render/vaporwave/vaporwave_display_face: Vaporwave's display (DisplayFace): a floating Windows-95 window. A 1 dp ink frame, a raised two-tone bevel, a body in the "3D face" colour the buttons share, a titleless gradient title bar with a mini striped sun and minimise / maximise / close caption buttons (no ×: they do nothing), and a sunken client panel (Palette.surface, opaque) that holds every display glyph.
render/vaporwave/vaporwave_faces: Vaporwave renderer factories (registered in theme_resolver.dart).
render/vaporwave/vaporwave_key_face: Vaporwave key faces: a square Windows-95 button. A 1 dp ink line, a hard two-tone bevel (light top-left, dark bottom-right; the classic Win95 joins, where the shade wins the top-right and bottom-left corners) and a flat face in KeyStyle.fill that never moves.
render/vaporwave/vaporwave_scene: Vaporwave background scene (BackgroundKind.vaporSunset): a sunset sky, a striped retro sun sinking into the horizon and a neon perspective grid floor whose cross lines drift slowly toward the viewer.
render/y2k_aero/y2k_aero_faces: Y2K / Frutiger Aero renderer factories (registered in theme_resolver.dart): ThemeSpec → Y2kAeroKeyFace / Y2kChromeKeyFace keys and the Y2kDisplayFace panel.
render/y2k_aero/y2k_aero_scene: Y2K / Frutiger Aero background scenes (BackgroundKind.aeroSky / BackgroundKind.chromeHolo; registered in backgroundScenePainters).
render/y2k_aero/y2k_display_face: Y2K / Frutiger Aero's display (DisplayFace): a glossy panel in the palette surface — AERO a pale sky-tinted glass card with a soft rim and an inner white edge (light) or a smoked-aqua glass slab with a darker rim (dark), CHROME an ice or lilac LCD (light) or a black LCD (dark) recessed in a light–dark–light chrome bezel — with a white gloss lens over its top 30 % (at most 96 dp) and a catch-light along the top edge that fades out down the sides. The font draws every glyph (Open Sans on the wght axis; CHROME with a slashed zero).
render/y2k_aero/y2k_key_face: Y2K / Frutiger Aero key faces (spec §5.3 #10; motion brief §2.3 "Y2K / chrome"): opaque gel orbs (AERO, Y2kAeroKeyFace) or satin-metal chiclets in a chrome bezel (CHROME, Y2kChromeKeyFace) with a hard white specular cap.
widgets/calsee_controls
widgets/calsee_key
widgets/calsee_scope
widgets/calsee_surfaces