How we built Orbit Lab

How we built Orbit Lab

A CognitoRiverDelta builder project by Don Wood. A whim on a Friday morning became a working page before 9 a.m.: a fast cycle.

The dated pairs

The goal

One sentence: help a curious visitor, especially a young one, see why people talk about putting compute in orbit, and what's still hard about it, in under a minute of play.

Who it serves: young builders and curious visitors. How we'll know it works: it loads in under 3 seconds on a phone, it runs at 60 frames per second on a laptop, and at least three young testers can answer "why orbit?" after playing.

The steps we took

1. The spec first. Before any code there was a one-page charter: the goal, who it's for, what's in and what's out (no server, no accounts, no ground vehicles, nothing stored), the names we use, and the measure.
2. A sphere made of hexagons. We start from an icosahedron (20 triangles), cut each triangle into small ones, push every point out onto a sphere, then turn each point into a tile. Most tiles are hexagons, but exactly 12 are always pentagons: you can't cover a ball with hexagons alone. We tinted those 12 gold so you can find them.
3. Land and sea without a map. A few overlapping waves decide where land, sea and ice go. There are no countries and no borders: it's one world.
4. One satellite as a function of time. Each satellite's position is just angle = start + speed × time on a tilted circle. That one idea makes "time speed" a single slider, and it means nothing drifts or piles up errors.
5. Two shells. Green broadband satellites fly low and fast. Purple compute satellites fly higher, and slower, which is Kepler's rule: farther orbits take longer. Their solar panels turn to face the sun and go dark when they pass through the planet's shadow.
6. Laser links. Any two satellites close enough get a glowing line, with a pulse of light riding along it.
7. Launch. The rocket's path is also a function of time: straight up, tilt over, coast. It travels a little faster than the satellites it releases, so each one it lets go of falls neatly behind the last.
8. Beam power to the TeraFab. Every compute satellite that's above the site's horizon and in sunlight beams a little energy down, then hands off to the next one. A small battery covers the gaps. It's speculation, and the page says so.
9. V2 vs V3 compare (the builder's idea, mid-build). It shows the same coverage cone with ten times the beams, then capacity per launch drawn as squares: about 2 for Falcon 9 versus about 60 for Starship. The figures are SpaceX's published plans. Our first try was a 3D view, and the builder said it looked like a cat (two cones over a dome looked like ears), so we turned it into a simple pop-up chart. That's the method: try it, look at it honestly, change it.
10. Fly to the sun. The camera tries a few spots and picks the closest one where both the planet and the sun fit on your screen, wide or tall. When you arrive, a note opens "How much of the sun do we use?": the sun is about 99.86% of the solar system's mass, Earth catches about 1 part in 2 billion of its light, and we turn about 1 in 50,000 of that into electricity. That's headroom, not a limit. It ends with our forecast, labeled as one: AI follows the energy, toward the sun.
11. Cooling in space. A radiator pop-up with a live temperature slider shows why getting rid of heat is one of the three hard problems.
12. Test like a visitor. We clicked every button, used the keyboard shortcuts, measured frames per second, and checked a 375-pixel phone screen. Then we fixed what we found: the title and legend collided on phones, the notes covered the planet (now they fold away), the rocket was too small to follow, and the sun view was tiny on tall screens.

What AI did, and what the builder decided

The builder (Don Wood) decided: the goal and who it serves; the hexagon planet; green broadband and purple compute satellites; the PEZ-style launch; flying to the sun; beaming power down to the TeraFab so a site never runs short; no countries or borders; that it must run free in any browser; the honesty rules (label speculation, say what's hard); and when it's good enough to ship.

AI (Claude, working as a coding partner) did: wrote the code from that spec, explained the math in comments, ran the tests in a browser, measured the frame rate, and proposed fixes. The builder reviewed and steered while it was being built: three of the features above came from the builder mid-build.

The measures (v1, 2026-10-09)

• Frame rate: 60 fps on a MacBook (desktop and phone-size windows), with lasers, shells, a launch and power beaming all on.
• Size: about 670 lines of our own code (one script, one stylesheet, one page), plus the free, open-source Three.js 3D library (MIT license) served from our own site so the page makes no requests to anyone else's servers. No build step.
• Data: none collected. No cookies, no analytics, nothing stored, no third-party requests: everything runs in your browser.
• Real phone: on 2026-10-09 the builder opened the live page on an iPhone. It loaded fast and ran smoothly.
• Still to measure: three young testers ("did you understand why orbit?").

What we'd change next

• The three-tester check ("did you understand why orbit?").
• A "follow the rocket" camera during launch.
• A one-tap "what am I looking at?" label on any satellite you touch.
• A sound-free "orbit period" readout that shows Kepler's rule as numbers.
• Let the visitor choose how many satellites to launch, and watch the beamed power grow.

Build your own

This page is also an Academy project: Build your own orbit simulator, in small stages where you add one thing, test it, then add the next. You need a browser and a text editor. It costs $0.