Skip to main content
Joshua Briley.
tokenadventure

Case study

I turned the design-token spec into an arcade game.

A Galaga-style coding arcade that teaches the W3C Design Tokens Format spec across eight sectors: from why tokens exist, through groups, aliases, and composite types, to wiring a tokens.json into a real UI and auditing a broken library. It's the companion piece to Rudiment UI.

Live site / The arcade

Insert coin. The whole curriculum is one playable cabinet.

Pick a sector from the star chart, clear the wave, log the intel, and level up your rank. It runs in the browser, so you can press start right now.

token-galaga.netlify.app live Token Adventure: a retro arcade cabinet UI with a pilot dossier, a high score, and a 'Press Start' to begin the design-tokens curriculum
Live sitetoken-galaga.netlify.app

Receipts

Skills proven
  • Interactive learning design
  • Design-token expertise (W3C spec)
  • Frontend product development
  • Game UI & canvas rendering
  • UI/UX Design
  • Finishing a product
Stack
  • Astro
  • HTML Canvas
  • Netlify
Quality
  • Faithful to the W3C token spec
  • Sequenced recruit → expert
  • A finished, playable arcade
Outcomes
  • Eight playable sectors
  • Companion to Rudiment UI
  • Personal project · teaching

On the docket

Token Adventure is a personal project, and the whole point is the framing. The W3C Design Tokens Format is a genuinely useful spec and a genuinely dry read. So instead of writing another explainer, I built the thing I'd actually want to play: a retro arcade where every wave you clear is one more piece of the spec you understand. Nobody asked for it, which meant nobody was around to talk me out of finishing it.

Step 01

Why teach a spec as an arcade

Design tokens are one of those topics that everyone agrees matter and almost nobody enjoys learning. The W3C format is precise, which is exactly what makes it dry: $value, $type, aliases, composite types. Read straight through, it's a reference, not a journey.

A game fixes the part documentation can't. It gives the material stakes and a sequence: a sector you haven't cleared yet, a rank you're working toward, a score that tells you you're getting it. The arcade framing isn't decoration over a quiz. It's the mechanism that turns “I read about aliases” into “I used an alias to clear the wave,” which is the difference between recognizing the spec and actually knowing it.

The usual way

Read the reference

A spec page you skim once and bookmark. Accurate, complete, and almost impossible to learn by heart.

Token Adventure

Play the reference

Each rule becomes a wave you have to clear. You don't move on until you've actually used the concept, not just seen it.

Step 02

Eight sectors, recruit to expert

The eight sectors are a real curriculum wearing a star chart. They're sequenced the way the spec actually has to be learned: you can't reason about aliases until you can name a single token, and you can't audit a broken library until you understand the types it's supposed to honor. Each sector earns the next one.

The arc runs from why tokens exist at all (escaping the hardcoded hellscape) all the way to wiring a tokens.json into CSS custom properties and auditing a library for spec violations: the exact decisions a real design-system engineer makes.

  • 01 Beginner The Hardcoded Hellscape Why design tokens exist
  • 02 Beginner The Registry Awakens tokens.json — $value and $type
  • 03 Beginner Forge a Group Groups, $type inheritance, $description
  • 04 Intermediate Echoes & Aliases Aliases / token references
  • 05 Intermediate Types of the Realm W3C token types & canonical value formats
  • 06 Intermediate Composite Constructs Composite tokens — typography
  • 07 Expert The Translation Pipeline tokens.json → CSS custom properties
  • 08 Expert Audit the Library Spotting & fixing W3C-spec violations
A spec read front to back gives you a reference. Clearing it sector by sector gives you the judgment to use it.

Step 03

A real game, finished end to end

An educational game lives or dies on whether it feels like a real game or a worksheet in a costume. So I sweated the arcade itself: the pixel cabinet, the pilot dossier, the high score, the “insert coin” voice that carries the whole thing. The fiction has to hold, or the learning underneath it never lands.

And it's a true companion to Rudiment UI. Rudiment is the field guide to building a token-driven component library; Token Adventure is where you learn the spec those tokens are written in. Same obsession with design tokens, two very different surfaces, both built for the fun of getting the last ten percent right.

Genuinely playable

A real arcade loop (waves, score, rank), not a quiz with a spaceship sticker on it.

Spec-accurate

Every sector maps to a real part of the W3C Design Tokens Format, taught in the order it has to be learned.

Part of a set

Learn the spec here, then build the library with Rudiment UI. The two are made to be used together.

Product engineering

I make hard things worth finishing.

Token Adventure is what I build when no one's asking: a dry spec turned into a game people actually want to play through. The same instinct (own the idea, sweat the finish) shows up in the products I ship for teams. Let's talk.