Jim Wright

Snake with NEAT: benchmarking changes to an evolutionary algorithm

Mon, 07 Sep 2026 00:00:00 +0000

Every number in the last five posts is a comparison, and comparisons on an evolutionary algorithm are much harder than they look. This post is about the experimental setup, which took me longer to get right than any of the code it was measuring.

Snake with NEAT: a hunger input to break stalemates

Sun, 06 Sep 2026 00:00:00 +0000

I had a network that scored 94.5 of 99 after thirty-five thousand generations, and it had stopped improving. More generations, bigger populations, more games per genome - nothing.

So I stopped trying to make it better and went to find out what it was actually losing to.

Snake with NEAT: training runs and checkpoints

Sat, 05 Sep 2026 00:00:00 +0000

The network is shown eighteen numbers and paid for eating. What is left is running the thing: how many networks, for how long, on what boards, and - the part I got wrong first - which one you keep at the end.

Snake with NEAT: designing the fitness function

Fri, 04 Sep 2026 00:00:00 +0000

Evolution keeps whatever scores highest, so the fitness function is not a scoring rule - it is the entire specification of the problem. Anything you leave out, you are asking for.

Snake looks like it should be one line: fitness is the score. It is not, and the reasons are more interesting than the fix.

Snake with NEAT: designing the network's inputs

Thu, 03 Sep 2026 00:00:00 +0000

The board is a hundred tiles and a network takes a fixed number of floats, so something has to decide what to throw away. That decision is called the encoding, and on this problem it mattered more than anything I did to the algorithm.

Eighteen numbers go in each move.

Snake in Go: evolving a neural network with NEAT

Wed, 02 Sep 2026 00:00:00 +0000

Every player so far is my idea of how to play snake, written down. The greedy one is “go towards the fruit”. The safe one is “keep your tail in sight”. They are as good as the rule I thought of.

The last player in this series was given no rule at all. It is a small neural network, and its weights and its shape were arrived at by evolution: a population of near-empty networks, the ones that happen to play better kept and mutated, over and over.

Snake in Go: building a Hamiltonian cycle with search

Tue, 01 Sep 2026 00:00:00 +0000

The zig-zag tour is laid out by hand, which works because a rectangle is easy to walk. The other way to get a tour is to search for one on the board in front of you.

This player is the most fragile thing in the series and the most instructive, because almost all of its score comes from two decisions that have nothing to do with the search.

Snake in Go: safe shortcuts along the tour

Mon, 31 Aug 2026 00:00:00 +0000

The zig-zag tour wins every game and takes twenty-five moves per fruit doing it, because it walks past ninety-nine tiles it does not want to reach the one it does.

Most of that is waste you can prove is waste. The snake is one tile long for the first fruit and the whole tour is empty behind it; there is no reason to walk all of it.

Snake in Go: a fixed Hamiltonian tour

Sun, 30 Aug 2026 00:00:00 +0000

The safe player never dies but stalls in nearly every game, because working move by move it eventually cannot prove any route to the fruit is survivable.

There is a way to win every single game, and it has been sitting there the whole time. Stop deciding, and follow a fixed route that covers every tile on the board.

Snake in Go: a tail-reachability safety check

Sat, 29 Aug 2026 00:00:00 +0000

Everything so far dies. The search players die at about 28 of 99, and they die because a shortest route and a survivable route are different things.

This one does not die. Not once in two thousand games, and it scores 90.8.

Snake in Go: stretching the longest path

Fri, 28 Aug 2026 00:00:00 +0000

The two search players die because a short route leaves the snake coiled up next to itself. The obvious opposite idea is to take the longest route you can, so that by the time you arrive the tail has had time to get out of the way.

It scores worse than walking straight at the fruit. It is also the single most useful piece of machinery in this series, because it is how you grow a route into a tour of the whole board.

Snake in Go: A* search instead of BFS

Thu, 27 Aug 2026 00:00:00 +0000

Breadth first search expands in rings, so by the time it reaches a fruit four tiles away it has also visited everything four tiles in the opposite direction. A* keeps the same guarantee and skips most of that.

This post is not really about playing snake - the two players score the same - it is about the search.

Snake in Go: shortest path with breadth-first search

Wed, 26 Aug 2026 00:00:00 +0000

The greedy player measures the distance to the fruit in a straight line, which stops being true the moment there is a snake in the way. The fix is to stop guessing and search for a real route through the board as it actually is.

This is the first player with a search in it, and the first one to share machinery with the rest of the series.

Snake in Go: a greedy player

Tue, 25 Aug 2026 00:00:00 +0000

The random player scores six because it does not know where the fruit is. The obvious fix is to tell it: of the moves that do not kill me this tick, take the one that ends up nearest the fruit.

That is the whole of the greedy player. There is no search and no lookahead, and it is worth three and a half times as much as random.

Snake in Go: a random-move baseline

Mon, 24 Aug 2026 00:00:00 +0000

The first player I wrote does not know where the fruit is. It looks one tile ahead, throws away the moves that would kill it this tick, and picks from whatever is left at random.

That sounds like a waste of a post, but it is the number every other player is measured against, and it turns out to be worth understanding why it scores what it does.

Eleven ways to play snake in Go, from random to NEAT

Sun, 23 Aug 2026 00:00:00 +0000

I wanted a problem small enough to hold in my head and awkward enough to stay interesting. Snake is that. The rules fit in a sentence, and playing it well turns out to be a problem about not building a wall out of yourself.

So I wrote a snake, and then I wrote eleven different ways of playing it. This series is one post per player, starting with the one that moves at random and ending on a neural network that was evolved rather than written.

NEAT in Go: the evolution loop and reproducible runs

Sat, 22 Aug 2026 00:00:00 +0000

Every piece is built. This is the loop around them, the parallelism, and the thing that mattered more than any of it: making a stochastic algorithm repeat exactly.

NEAT in Go: deterministic parallel reproduction with goroutines

Thu, 20 Aug 2026 00:00:00 +0000

Every species knows how many offspring it is owed. This is the part that produces them - which is where the expensive work is, and where the temptation to parallelise it runs straight into the requirement that a seeded run be reproducible.

NEAT in Go: fitness sharing and culling

Tue, 18 Aug 2026 00:00:00 +0000

Species exist so that a genome competes mainly against genomes like itself. This is the part that cashes that in: deciding how many offspring each species gets, which members are allowed to produce them, and which species do not get to continue at all.

It is five short functions and I got three of them subtly wrong first.

NEAT in Go: speciation with compatibility distance

Sun, 16 Aug 2026 00:00:00 +0000

A genome that has just grown a new node is worse than it was. It has an untuned bias, two untuned weights and no idea what the node is for, and in a straight fight with the rest of the population it loses and is gone.

Speciation is the answer: genomes compete mainly against genomes like themselves, so new structure gets a few generations to prove itself.

NEAT in Go: crossover aligned by innovation ID

Fri, 14 Aug 2026 00:00:00 +0000

Historical markings exist so that this post is short. Once both parents’ genes carry stable IDs, combining them is bookkeeping.

NEAT in Go: add-node and add-connection mutations

Wed, 12 Aug 2026 00:00:00 +0000

This is the half of mutation that NEAT is named after: the part that grows the topology. Four mutations, all of them rare.

func (b *Breeder) mutateStructure(genome Genome) Genome {
	genome = b.mutateAddNode(genome)
	genome = b.mutateDeleteNode(genome)
	genome = b.mutateAddConnection(genome)
	genome = b.mutateDeleteConnection(genome)
	return genome
}

NEAT in Go: mutating weights and other parameters

Mon, 10 Aug 2026 00:00:00 +0000

Mutation comes in two halves, and they are kept apart deliberately.

func (b *Breeder) mutateGenome(genome Genome) Genome {
	return b.mutateStructure(b.mutateParameters(genome))
}

This post is the first half: the mutations that change existing genes without adding or removing any.

NEAT in Go: innovation IDs and historical markings

Sat, 08 Aug 2026 00:00:00 +0000

If you take one idea away from NEAT, take this one. It is a page of code and it is what makes everything else possible.

NEAT in Go: the genome, starting minimal

Thu, 06 Aug 2026 00:00:00 +0000

A genome is a description of a network that has not been built yet. It is what mutation edits, what crossover combines, and what gets written to disk when a run finds something worth keeping.

NEAT in Go: compiling a network into a flat loop

Tue, 04 Aug 2026 00:00:00 +0000

Before there is anything to evolve there has to be something to run. The network package takes a list of nodes and a list of connections and turns them into something that activates fast, and it knows nothing at all about evolution.

NEAT in Go: seeded randomness and generic helpers

Mon, 03 Aug 2026 00:00:00 +0000

Before any of the algorithm, a handful of helpers for drawing random numbers and poking at slices. They are eight short functions and it would be fair to skip them - except that two of them encode decisions that everything else in the series depends on.

NEAT in Go: neuroevolution, built a piece at a time

Sun, 02 Aug 2026 00:00:00 +0000

Most neural network training holds the shape of the network fixed and moves the weights. NEAT moves both. A run starts from the smallest network that could possibly answer the question - every input wired straight to every output, nothing in between - and grows hidden nodes and connections one at a time, keeping whatever happens to help.

I have wanted to build one properly for years. This series is that: neatgo, a piece at a time.

What is `this` in JavaScript? The binding rules explained

Thu, 16 Mar 2017 00:00:00 +0000

Working on Nodejs at work recently made me remember how confusing javascript can be. There are a lot of quirks that make it a powerful language, but for developers coming from a more strict OOP background they can seem broken. In this post I’m going to talk about this in javascript.

About me

Mon, 01 Jan 0001 00:00:00 +0000

I’m a senior/staff software engineer with a decade of experience building and operating the infrastructure behind large-scale, real-time systems. I’ve led cloud migrations and platform teams at Cisco ThousandEyes and SamKnows, and I independently design and ship complete products end to end, from backend architecture through billing and release engineering.

I started out making games in Flash and writing an IRC client to earn a Trials2 achievement, went on to study Computing (BSc, 2:1) at Canterbury Christ Church University, and have worked across the stack ever since.