The rebuild

In November 2026 the 1997 program was ported exactly, corrected, and then improved one measured step at a time. This page records each step with its results, including the ones that did not help, of which there were plenty.

I did this work with Claude, an AI model made by Anthropic, which is not a sentence I expected to write when I handed the project in.

The short version: the network that plays on this site is shown only which piece is on which square. It was told the rules and nothing else, and it scores 98% against the network shipped in June 1997 without losing one of 400 games. In 1997 I gave up on the raw board, fell back on hand-written features and blamed the processor. The processor, it turns out, has a reasonable defence.

How it learns

The method is the one from 1997, and no games played by people are involved at any point.

1. There are two copies of the network, a learner and a champion. The champion does not change.
2. They play a batch of training games: 20 now, 10 in 1997. After every move the learner nudges its judgement of the last position toward its judgement of the new one, and at the end of the game toward the result.
3. Then they play a test match with learning switched off: 20 games now, 2 in 1997.
4. If the learner scores enough, 60% now and both games in 1997, the champion is replaced by a copy of it. The learner has been cloned, and its reward is to have to beat itself all over again.

A gate of the same kind turned up twenty years later in a far larger program. AlphaGo Zero, DeepMind's 2017 Go player, also started from nothing but the rules and taught itself by playing itself, and a new network replaced the best one only after winning 55% of a 400-game match against it. Everything else about it is on another scale: a far deeper network, a far deeper search and millions of games. But the gate is the same gate.

How things were measured

One training run on its own says very little. Two runs that differ in nothing but their random seed can finish several points apart, which is exactly the size of difference one is usually hoping to find. So the comparisons from step 6 onwards train each setting from five seeds and give the average, with the standard error after the ± sign.

• Matches. Both players look the same distance ahead, three plies unless noted. Games start with four random plies, in pairs that share an opening with the colours swapped. A score is wins plus half the draws.
• An outside opponent. Simple Checkers by Martin Fierz, a hand-written program that was not trained here. At three plies it beats a player that only counts pieces 72% of the time and the 1997 network 94% of the time.
• Expert moves. How often a player picks the move Marion Tinsley played, over 28,274 positions from 724 of his games where there was a choice. Random play agrees 15.7% of the time, the 1997 network 25.0%, the piece-counter 31.9% and Simple Checkers 44.7%.

Step 1Port it exactly

Before changing anything, the 1997 program was ported line for line, quirks included, and tested against a build of the original C++. From the same seed the port produces the same starting network, the same 38 inputs on 4,000 positions, the same evaluations and the same chosen moves. It then replays the complete 1,200-game tournament from the report: every printed line and all 18 saved networks are identical to the byte.

That was the point of doing it. You cannot say what a program got wrong until you can reproduce exactly what it did, mistakes and all.

Step 2What the port exposed

Reading every line closely enough to reproduce it turned up mistakes in two separate places: in the program that learned from features, which is the one that beat me, and in the option to learn from the raw board, which never worked.

In the program that beat me

• The rules. In draughts you must capture when you can. The 1997 program sometimes played an ordinary move while a capture was available. A multiple jump also followed one fixed route where the rules offer a choice.
• The features. Several were not computed as the report defines them. The three centre-control counts came out one too low, and the first input of two others switched on only for a single value.
• The learning rule. The hidden layer was adjusted using the wrong weight, so it did not follow the true gradient.
• The search. The pruning that makes look-ahead cheap had been commented out for causing "strange errors in judgement", so every line was searched in full. This cost time, not strength.

None of these stopped it. With all four in place it still taught itself to beat its author, which says something for the method and possibly something about the author.

In the raw board, which I gave up on

The report says I tried feeding the network the board itself, got nowhere and fell back on features. As I remember it, this came late in the project and never got the time it needed.

I tried two ways, both chosen to keep the network small, since every extra input was more arithmetic for a processor that already had its hands full. One gave each square three inputs holding a binary code for the piece on it, 96 inputs in all. The other gave each square a single number, from 0 for empty up to 1 for a red king, 32 inputs in all.

Both were broken. The first read 11 of the 32 squares. The second came out as zero for everything except a red king. The network was being asked to learn draughts while looking at about a third of the board, or at nothing but the occasional red king, and it declined. The experiment said nothing about whether the raw board can work.

Was it the processor?

At the time I blamed the hardware. The report says more might have been achieved "if more processing power was available", which is the sort of thing one says. So this was tested.

Three kinds of network were trained the 1997 way, five of each: 12 hidden units, the 1997 settings and 1,000 training games, with the mistakes put right and the one change of method described in step 3. Each then played 400 games against the network shipped in June 1997.

The 1997 program could not be used for the three-input encoding, since its version read only 11 squares. A new one was written in 2026 to the report's description, reading all 32.

So the raw board was within reach in 1997, and with my own way of encoding it. All ten raw-board networks beat the network I shipped. Packing each square into three inputs saved space but cost strength, most likely because the network has to unpick each square before it can use it.

The raw-board networks are about two and a half to three times the size of the feature one, so a run would have taken perhaps that much longer. My other idea, one number per square, has not been tested: the new engine only takes inputs that are on or off.

What the processor did limit was everything around the idea. I got one experiment a night, and I had nobody to work on it with. No one around me was building anything like it, so any mistake I made was mine to find. The same 1,200 games now take under ten seconds, so a mistake that once cost a night to rule out now costs about as long as it takes to wonder about it.

What I wanted to try in 1997

The report and the release notes list what I meant to do next and could not. Some of that was the machine and some of it, in fairness to the machine, was my own programming.

Step 3Redux 97: the original with its mistakes put right

The cleanest test of those fixes changed as little as possible: the same network, the same settings, the same seed and the same 1,200 games, with the rules, the features and the learning rule corrected, and no momentum term.

At first it failed, and thoroughly. The corrected program lost every game to its first clone and ended up worse than random play, which is a difficult thing to achieve on purpose. One change to the method fixed it: learning from both players' positions in each game, not only its own.

With that, Redux 97 scores 76% against the network shipped in June 1997 (218 wins, 174 draws and 8 losses over 400 games), after the same 1,200 training games.

Step 4The raw board

The new network has 128 inputs, one for each piece type on each square, 40 hidden units and the same direct links as in 1997. It is given no features at all.

The first raw-board learner collapsed in the same way. A learner that falls behind its clone sees only defeats, concludes that everything it can see is bad news, its own pieces included, and never recovers. Learning from both colours means every game shows it a winner as well as a loser.

After that the raw-board network beat random play in every game after 2,000 training games, and scored 75 to 80% against the 1997 network after 10,000.

Step 5Learn only from quiet positions

The search never asks the network about a position where a capture is waiting; it plays the exchange out first. Training was changed to match, skipping those positions. Against the piece-counter, a raw-board network after 60,000 games went from about 50% to about 70%.

Lambda, the setting the 1997 report went to some trouble to compare, made no measurable difference anywhere between 0 and 0.5.

Step 6Three outputs and a falling learning rate

In 1997 the network gave one number. Draws are common between well-matched players, and one number cannot tell a dead draw from a position either side might win. The network was given three outputs: the chances of a win, a draw and a loss. The learning rate was also set to halve three times over a run.

This was the largest single gain. Over five seeds and 30,000 games, the three-output networks scored 58% against Simple Checkers where single-output ones scored 49%.

Step 7What did not help

Most ideas after that made no difference to how well it plays, which did not stop them being tried.

• Endgame tables. Every position with up to five pieces was solved exactly, and the learner was taught the true result whenever a game reached one. No gain against Simple Checkers. Teaching every win as certain, however far off, did harm.
• Leaf learning. Correcting the network's view of the position at the end of the line it expects, not the one on the board. No gain alone. With endgame tables it picks Tinsley's move slightly more often.
• Learning from the search. Moving each judgement toward what the next look-ahead finds. Over 100,000 games it scored 64.3 ± 0.8% against Simple Checkers, where plain scored 64.2 ± 1.1%.
• A wider network. 80 hidden units scored 64.7 ± 1.4% where 40 scored 64.2 ± 1.1%, and each training game took about 40% longer.
• Learning from expert games. This failed in 1997 and it failed again, though this time it had the decency to explain itself. Games between experts are level, so a network taught from them alone never learns that pieces matter. Fine-tuning a self-taught network on them made it weaker.

Step 8Train for longer

The plainest change did more than all the clever ones. Taking a run from 30,000 games to 100,000, with the learning rate halving every 30,000, lifted the score against Simple Checkers from 60.5 ± 1.4% to 64.2 ± 1.1%.

The 2026 champion

Ten networks were trained for 100,000 games each. The one that plays on this site was the only one near the top on every count. It has 5,667 weights, was cloned 306 times along the way, and takes about fifteen minutes to train from nothing.

It picks the move Tinsley played 48.1% of the time, ahead of Simple Checkers at 44.7%.

Its limits are plain from the last row. Given two more plies of look-ahead, a simple hand-written program beats it. This is a small network judging positions well for its size. It is nowhere near the strongest draughts programs.

Play against it, or train your own.

1997 and 2026 side by side

The method is the one from 1997: judge the position, nudge the last judgement toward the new one, and make the learner beat its own clone before it moves on. What changed is that the mistakes are gone, it can see the whole board, and it plays more than eighty times as many games. It also no longer takes all night.