I Rebuilt the Game I Wrote on a PlayStation 2 at Age 14

The PlayStation 2 came with a demo disc, and on that demo disc — tucked in among the trailers and the playable slices — was a programming language called Yabasic. A BASIC dialect, running on a games console, with primitives for drawing shapes and reading the controller. I was fourteen. I had waited the better part of a year for the console to come back into stock. The fact that it shipped with a way to write my own games on it felt, at the time, like a small miracle that nobody else had noticed.

I made several things with it. The one I want to talk about is a puzzle game with no name, played on a grid of coloured gems, where the goal was to remove every black gem from the board.

What 14-year-old me actually built

The rules were simple enough that I could hold all of them in my head as I typed them in. A 1 gem moves one square. A 2 moves two. Three moves three, four moves four. You collect a black gem — the thing you're trying to get rid of — by moving a numbered gem onto it.

So far so trivial. The interesting parts were the three rules that kept the game from collapsing:

• Move a numbered gem to an empty square and it increments. Your useful little 1 becomes a slightly worse 2. Precision is a finite resource.
• Move a gem onto another gem of the same value and they merge — and the result is one lower than either input. Convergence is rewarded, because it's hard.
• Move a gem onto a wall block, and the block becomes a new black gem. Almost always a disaster. Occasionally the only way through.

That is the whole game. Four rules. I built it on a console, with no debugger, no version control, no internet to ask anything of, saving to a memory card I had to share with my brother's save files.

I also wrote a board generator, because hand-designing puzzles is a chore and I wanted infinite of them. I had no idea what procedural generation was as a concept. I just wrote a thing that placed gems and walls and hoped the results were solvable. Testing suggested they mostly were. I had no proof.

The source code situation

I do not have the original .bas files. The memory card adapter you needed to get data off a PS2 was about £50, and at fourteen I was not a £50-on-a-cable kind of person. What I have instead — and I want you to sit with this for a second — is a PDF. Of screenshots. Of my CRT monitor. Showing the source code, page by page, as it scrolled through the Yabasic editor on the console.

A few years ago I paid someone on Fiverr to transcribe the PDF back into runnable code. It did not run. Not close. OCR on screenshotted code on a curved CRT is a bad time for everyone.

I shelved it.

The rebuild

In 2026 I fed the PDF to Claude. Not as text — as the original images. And it produced a working version of the game.

Not a faithful port. A recognisable one. The rules are intact. The generator algorithm is intact. The visual identity has moved on — the gems are gone, replaced by numbered tiles. The black gems are now noughts. Zeros. That's literally what the tile shows. Hence noughtle.com, hence the domain, hence the whole thing. You're trying to clear the noughts.

The thing that's online is more game than my fourteen-year-old version ever was. There's a daily seeded puzzle, so everyone playing on a given day plays the same board. There's a solver. There's an "Enigma" mode that uses the original generator with no solvability guarantee, because those puzzles have a different texture — harder, weirder, occasionally unwinnable — and I didn't want to lose that flavour.

The solver is the part I'm least satisfied with. Brute breadth-first search dies almost immediately; the branching factor is in the same order of magnitude as chess. Depth-first with heuristics did not save it. What got me to ~80% was a layered search: an inner breadth-first pass that solves only for clearing the next nought in the fewest possible moves, then yields up to an outer breadth-first pass that decides which order the noughts get cleared in. The inner pass throws all its move-by-move state away once it succeeds. The outer pass only ever holds the sequence of nought-clearings. Memory stays bounded. Backtracking only happens at the nought level.

It works most of the time. It doesn't work always. I have not been able to prove that all generated boards are solvable, and I have not been able to write a solver that finds the solution when there is one. Both of those feel like they ought to be true, and neither of them is something I've cracked.

What's changed

Three things, and they're worth separating.

The tools have changed. That's the obvious one. The reason this game exists in 2026 and didn't exist in 2024 is not that I got better. It's that a model got good enough to look at PDF screenshots of Yabasic source and reconstruct the program, when a human freelancer with the same input couldn't. I want to be honest about that. The rebuild is a tooling story before it's a craft story.

I've changed. Fourteen-year-old me didn't know the word "heuristic" and would have stared blankly at "branching factor." He also didn't need either of them, because he wasn't trying to write a solver. He was trying to write a game. The thing I added in 2026 — the solver, the daily seed, the layered search — is the thing he couldn't have built. The thing he built, the game itself, is the part I haven't been able to improve.

What's possible has changed. I built that original game and then it died on a memory card. There was no internet to put it on, no app store, no way to hand it to a friend that didn't involve them coming to my house. The game existed for me and approximately four other people. Today the same game gets a domain, a daily puzzle, a solver, analytics, and a global audience the moment I push to main. The interesting thing isn't that the rebuild was possible. It's that the publishing is trivial — the bit that used to be the entire problem.

The bit I keep coming back to: fourteen-year-old me couldn't share this. Now I can. Same game. Same four rules. Different century.

If you can think of a better way to write the solver, or a way to generate boards that are guaranteed solvable without losing the difficulty curve, the comments are open.