The DNA of too.foo

Somewhere in there a habit formed and never switched off: when something is interesting, go all the way down. too.foo is what that habit looks like with a few decades added on. Every app here began as a rabbit hole I could not climb out of, written up so the next curious person can fall in too.

too.foo is a few dozen small web apps under one roof. Some teach: robotics, computer vision, electronics. Some simulate: waves standing still on a metal plate, a flock that finds its own rules. Some are plain tools, and some are just things I wanted to see with my own eyes.

There is no theme except the one underneath all of them. Take curiosity seriously, then build it so you can touch it. Nothing here is a slide deck about an idea. It is the idea, running, with knobs.

You are reading the front door, and it is built from the same parts as everything else, on purpose. If the rest of the site is any good, this page should already feel like it.

Most technical writing makes you choose between two bad options: rigorous but dry, or friendly but shallow. The textbook is correct and unreadable; the blog post is readable and half wrong. I wanted the third thing, and these apps are my attempt at it. There is one method behind all of them.

A book, not a reference

The goal is something you actually want to read, the way you read a good popular-science book and lose an hour without noticing. A reference answers a question you already have. A book hands you questions you did not know to ask. Every lesson is written to be read start to finish, not searched and skimmed.

Intuition before notation

No section opens with an equation. The idea comes first, in plain words, with a picture or an analogy you already own. Only once you can feel why something must be true does the math arrive, and by then every symbol has already earned its place. Math is not the opposite of intuition. It is what intuition becomes once you trust it enough to write it down.

You should be able to touch it

Reading about a control loop is not the same as cranking the gain too high and watching the whole thing shake. So nearly every lesson carries a small simulation you can drive. Tune it, break it, push it past where it was meant to go. The numbers on screen are real, in real units, and they move because you moved them. Understanding usually arrives through your hands a moment before it arrives through your head.

The rabbit holes are the point

Around the core of each lesson sits the other half of the fun: the history, the people who first saw it, the strange facts, the dead ends. These are not decoration. They are what turns a curriculum into a book, and the reason you keep reading past the part you came for.

One question

Behind all of it is a single test, applied to every paragraph, every demo, every image: would I want to read this? If the answer is no, it gets cut or rewritten, however correct it was. That bar is slow and a little ruthless, and it is the whole method.

None of these were picked off a roadmap. Each one is a thing I actually fell into, and kept. Read the list of apps as a list of obsessions, in roughly the order they grabbed me.

The whole collection is below. Tap any app and a popup tells you what pulled me into it, with a look inside.

I think in systems, so the workshop is built like one. None of this is the point of the site, but it is the reason the site can exist: a few dozen apps, kept alive by one person, only works if the machinery is boring and reliable.

One stack, and where it bends

Almost every app is the same deliberately boring stack: Astro, TypeScript, and Tailwind, one Cloudflare Pages project each, all sharing a single set of design tokens. Boring is what lets one person keep dozens of them alive.

A few refuse to fit, and those are the fun ones. When the browser itself has to do real work, a solid-modeling kernel, a circuit simulator, a wave solver, the app drops to Rust compiled to WebAssembly and moves into its own repo: mcad, ecad, chladni, and evolution. Others do the heavy lifting offline and just stream the result, like quantum, whose orbitals are solved on a GPU and served as data. The DNA still holds across all of them: the same look, the same back-link, the same feel, even when the engine underneath is nothing alike.

The fleet

The work runs on a small set of machines on one private network. A tiny always-on box guards the secrets. A workstation with a GPU does the heavy lifting. A few more handle storage, agents, and the occasional rented burst of cloud compute.

sbl0 Raspberry Pi vault · always-on

sbl1 · here Workstation dev · gpu · this box

sbl2 XPS laptop portable dev

sbl3 Server database · storage

sbl4 Mini PC agents · openclaw

sbl5 Cloud GPUs vast.ai · burst

From idea to live

Every change takes the same path. An idea becomes a parallel worktree on its own branch, agents build it there, a throwaway preview proves it in the real browser, and only a merge to main publishes it to its subdomain. The boring path is the safe path.

A team of models

The building itself is done by a team. An operator console dispatches work to several models, each one pointed at the jobs it is best at, the way you would hand tasks to people with different strengths.

Dozens of apps, one organism. They barely share any code that matters. What they share is a genome: the same colors, the same fonts, the same flat surfaces, the same back-link in the same corner, and the same insistence that you should be able to drive the thing rather than just read about it.

Those rules are not a style guide gathering dust. They live in tests, so a rule cannot quietly rot without something going red. That shared genome is the DNA in the name. Every app carries it, which is why a flock simulator and a robotics course somehow feel like they came from the same place.

Every app is just below. Pick one and pull.