SOLO: teaching a neural network to fly — and what I learned building it from scratch

Week 2’s theme was Independence Engines: independence as a mechanic, not a symbol. I took it literally and built a thing that becomes independent of me while you watch.

SOLO is a small game where the ship has a neural network for a brain. You fly it through a course, the network learns from how you fly, and then you cut the cord and it flies on its own.

The whole thing is one HTML file. The network — the forward pass, the backpropagation that trains it, and a separate evolutionary trainer — is written by hand. No TensorFlow, no libraries, no server. You can open the page source and read all of it.

There are three ways to make it learn:

• Fly it yourself, and it copies your style.

• Hit Auto-Teach, and a built-in autopilot demonstrates while the net learns by watching.

• Hit Evolve From Scratch, and there’s no teacher at all: a population of random networks tries to fly, the ones that get furthest survive and mutate, and flying ability appears out of pure trial and error. You can watch just the champion improve, or flip on “Watch the Fleet” and see all 44 pilots fly at once, slowed to real time — clueless at generation one, threading the course a dozen generations later.

A small learning curve in the corner tracks all of this, so you can watch the number climb instead of taking my word for it.

What I actually learned building it:

Imitation learning is fragile in a specific way. Copying my inputs works fine until the ship drifts somewhere I never demonstrated. Then it makes a slightly wrong move, ends up somewhere even less familiar, and the errors snowball until it flies into a wall. The fix that worked was letting you grab the controls mid-flight to correct it. It learns from the correction and needs you a little less each time.

My first progress meter was lying to me. I started by showing “skill” as how closely the network matched my button presses. It would read 45% and still nose straight into a wall, because matching inputs is not the same as flying. I replaced it with an honest test: in the background the network keeps attempting fresh courses, and the meter shows the percentage it actually finishes. The cut-the-cord button only unlocks once it can really complete laps.

The crude method beat the clever one. I assumed gradient-based imitation would be the strong approach. Neuroevolution — mutate a population, keep whatever flies — turned out more reliable. It has no drift problem, it converges in about 15 generations, and it scored higher on courses it had never seen: roughly 95% completion versus 91% for imitation.

Generalization is the test that matters. Memorizing one course is trivial and proves nothing. What I care about is that it clears courses it has never seen. That’s the line between learning to fly and learning a path, and it’s the win condition in the game.

Why I think it’s more than a gimmick: it’s small, but it’s real. The network learns, it generalizes to new courses, you can watch the actual neurons fire as it decides what to do, and you can read every line that makes it work. Nothing is faked or pre-baked.

On the theme: the mechanic is independence itself. The whole game is a handoff of control — the moment the thing you taught no longer needs you, or in evolve mode, never needed anyone.

One competitor nod: Eric’s 8-bit Paul Revere AI video used AI to render a courier. SOLO points the AI the other way. It isn’t the artwork, it’s the pilot, and instead of a finished clip you watch the intelligence form in the open.

Play it and read it:

Live: https://myles-mf.github.io/summer-into-ai-2026/week-2/solo/

Source (one file): https://github.com/myles-mf/summer-into-ai-2026/blob/main/week-2/solo/index.html

Everything I’ve built for the contest: https://myles-mf.github.io/summer-into-ai-2026/

Also written up on my site: https://merlinforge.com/blog/solo-week-2/