← Back

Phosphor95: Build the Thing First, Then the Design System

I have a 2015 MacBook Air that should have been recycled years ago. Instead, it's the most fun computer in my house.

It runs Ubuntu now. It also looks like Windows 95 got trapped inside a green phosphor monitor. And somewhere along the way, it picked up its own design system.

That design system got built backwards: the thing first, the system after. I'm not saying that's the only way to build a design system, or even the one I'd recommend for most teams. But in this agentic devex world, where agents do a lot of the building, it's definitely a way that works well.

The Linux install

The Air has an i5, 8GB of RAM, and no business running a modern macOS. So I put Ubuntu 26.10 on it, GNOME on Wayland, and started theming. (This is what happens when you have an old laptop and too many ideas.)

Not a little theming. All of it. The theme is called Phosphor-95: Win95 structure (bevels, title bars, square corners, a taskbar with a START button) drawn in CRT green. Chicago95 icons recolored by luminance. Digital rain for a wallpaper. A CRT shader in the terminal you can flip with crt on|off. Even the starship prompt got stripped back to ASCII-only.

It starts before you log in. GRUB and the boot splash get a PHOSPHOR BIOS v4.51 header and POST-style [ OK ] lines, and the lock screen shows a little pixel-art head in profile.

The fonts were the fussy part. PxPlus IBM VGA only looks right at its native size, so the UI runs at 12pt, which is exactly 16 pixels at 96 dpi. Anything else and it goes blurry.

All of it runs off two TOML files and a little Python generator: one for the palette, one for the identity. Change the machine's name, rebuild, and every banner, the boot splash, GRUB, the lock screen and the wallpaper follow.

Is any of this necessary? No. Is it rad? Yes.

TERMINAL-01

The theme is the costume. The point of the machine is terminal01.

terminal01 is the voice and face of my homelab. You say "Hey Terminal" (or hold Space) and it listens. Whisper transcribes locally in under a second. The simple stuff like time, timers, alarms and volume gets handled by 22 plain old rules, no model involved. Anything else goes over a WebSocket to the Brain, the local LLM on my M4 Pro.

It answers in a British voice run through a 1940s radio filter, squelch and all. "Copy. Timer set for 10 minutes." The screen shows a head of about 5,000 green glyphs inside spinning HUD rings. Very Jarvis. If the Brain goes down, the face turns amber and dissolves into static, and the local commands keep working.

It's about 8,000 lines of Rust. Why Rust? Same answer as always: because we can build whatever we want now.

Same principle as The Construct: deterministic first, a model only when you need one. Every utterance logs how it was routed, so I can see what should become a new rule.

Building first, design system after

I didn't start with a design system. No tokens, no Figma file, no principles doc. I built a desktop theme, then I built an app that lives inside it. The design language came out of making things.

Then, on November 4th, I pulled it out into its own repo. One day, four commits. Most of a design system was already in there, just not packaged.

The palette became DTCG tokens: 455 per theme, across four themes (green, amber, white and high contrast). The lock screen avatar, Chicago95's default head recolored green, became the Operator, the persona and logo. The [ OK ] boot lines became a voice guide with rules like "no exclamation marks" and "errors say what, why, and what to do." Six principles fell out of decisions I'd already made, like "structure from bevels, not shadows" and "glow means hot."

From there it went out to every surface I use: a CSS package with Web Components, color schemes for eight terminals, and a Rust crate for ratatui apps.

It also found real problems. The faint green I'd been using for hints measured 2.4:1 against the background. That fails. Now there's a contrast gate with 57 checks per theme, and the build fails if anything regresses.

Then I skipped Phase 4, which would have wired the design system back into the theme and terminal01. They keep their own palettes. The design system describes what works. It doesn't get to go back and boss around the things it came from.

This is backwards from how most of us learned it. Usually the design system comes first, gets approved by committee, and then everyone builds against it. But when building is cheap, you can find the design by making the thing, and then write down what you found.

Try it out

The repo is public: Websites-On-Computers/phosphor95-design-system.

The token build only needs Python 3.11 or newer. No dependencies. The easiest way in is the gallery site, which is built with the system itself:

git clone https://github.com/Websites-On-Computers/phosphor95-design-system
cd phosphor95-design-system
python3 tools/build.py site
python3 -m http.server -d dist/site 8095

Open http://localhost:8095 and you get every component, a theme switcher, the CRT toggle and a command palette. Add ?selftest to the URL to watch it test itself.

If you live in the terminal, grab a color scheme from packages/tui/terminal-themes/. There are versions for eight terminals, from Ghostty to iTerm2. For Ghostty, copy phosphor95-green into ~/.config/ghostty/themes/ and set theme = phosphor95-green.

And if you're building a Rust TUI, the p95-style crate has a gallery too:

cd packages/tui/p95-style
cargo run --example gallery

Press 1 through 4 to switch themes. It drops down to 256 colors, 16 colors or plain mono, and it respects NO_COLOR.

A lingering thought

What strikes me reading the repo is who it's written for. voice.md is a table of "instead of this, write this." Every principle has a Do and a Don't for web and for terminal. The build refuses a broken alias or a contrast regression.

That's not really documentation for a person. That's a spec for an agent.

Design systems were invented to keep a lot of humans consistent. More and more, the thing building the UI is an agent, and unlike most of us, it will actually read the docs.

So maybe the design system isn't the component library anymore. Maybe it's the contract. And maybe the question isn't whether your team follows the design system, but whether your agents can.

--

If any of this sounds fun (or completely unhinged), I'd love to chat. Reach out at matt@matt.computer and let's grab a coffee. I'm always up for talking homelabs, local LLMs, or getting an old laptop back to work.

--

Many thanks to grassmunk and their Chicago95 theme.