A six-month side project · Feb → May 2026
A neural network that learned to play Ludo from scratch.
3 million parameters trained over six months and dozens of experiments — now running entirely inside your browser. No server, no API calls, no waiting. Pick up the dice and see if you can beat it.
Inspired by AlphaGo · TD-Gammon · AlphaZero
Where to start
Interactive
Take on the AI in a real game of Ludo. The whole network runs locally in your browser — no backend, no waiting, your moves never leave your machine.
The story
From a naive baseline that couldn't tell its own four tokens apart, through a hand-engineered encoder, all the way to a stripped-back design that beats every earlier attempt.
Inspirations
AlphaGo lit the spark. TD-Gammon wrote the playbook for games with dice. AlphaZero we tried and abandoned. Here's the full reading list.
Interactive demo
You're Green (Player 0). The model is Yellow (Player 2). Click the dice to roll, then click a highlighted token to move.
Behind the model
From a naive baseline that couldn't tell its own four tokens apart, to a 3-million-parameter network that beats every earlier version of itself. The short tour of how we got there — and what didn't work along the way.
From V1 to V13.2
The model saw the board as eight stacked black-and-white maps — but it couldn't tell its own four tokens apart. They all collapsed into one blob, so the AI was guessing which piece to move. It lost a lot.
We started feeding the network "tactical hints" we computed by hand — danger maps, capture opportunities, safe landing squares. It got better, but plateaued at 73–77% wins against scripted opponents and stopped improving.
Added a "token attention" layer — letting the network reason about its four tokens as separate entities, with awareness of how often each had been ignored. First model to consistently win >80% against scripted opponents.
We stripped most of the hand-engineered features back out and gave the network mostly raw board positions. It beats every earlier version of itself. Over 10,000 head-to-head games against the previous best AlphaLudo, this version wins about 52% of the time — a small but statistically real edge. This is the model you play against.
End-to-end
Generate millions of practice games between scripted bots — heuristic, aggressive, defensive, expert. The network learns by watching them play.
The new student network is trained to copy the previous best AlphaLudo's decisions. By the end of this stage it already plays as well as the teacher.
The student plays thousands of games against itself and various opponents, gradually adjusting its strategy to win more. Once it's consistently strong, we add the previous AlphaLudo versions back in as sparring partners.
Watching it play, we noticed specific failure modes — leaving a laggard token at base, walking into capture range. Reward penalties were added to discourage these, then tuned by trial and error.
Win rate against scripted bots saturates around 80%, so it stops being useful as a measure. We compare versions directly — 10,000 games each, head to head. That's the only test that distinguishes the strongest models.
From the journal
An early reward-shaping scheme looked elegant on paper but quietly subtracted a tiny amount of reward every turn. Over a 150-move game it added up to about a fifth of a "loss" — the model became convinced every game was unwinnable. Took 155,000 games to figure out what was happening.
In long games, even tiny systematic biases compound. Always check what the reward looks like end-to-end.
We tried scaling intermediate rewards 5× smaller, reasoning that the final win/loss signal should dominate. Win rate cratered from 67% to 33% over 125,000 games. In a dice game the random variance is so loud that quiet signals just get drowned out.
In stochastic games, intermediate rewards must be loud enough to cut through the dice noise — not just mathematically pretty.
We tried three completely different network designs — one with attention, one pure convolutional, one with no spatial structure at all. All three plateaued at the same 80–83% win rate. Whatever's holding us back, it isn't the shape of the model.
More parameters and fancier layers were never going to help. The ceiling lives somewhere else — probably in the training opponents we have access to.
Inspirations & dead ends
AlphaLudo borrowed liberally — and abandoned an idea or two along the way. Here's the full reading list, in chronological order.
The original "neural net plays a dice game at world-class level" result, written when most of the modern field didn't exist yet. Thirty years later, AlphaLudo rediscovered Tesauro's central lesson the hard way: in dice games, the small rewards along the way matter more than the final win/loss signal. Scale them down too far and learning collapses.
Read on Wikipedia →The natural next thing to try after AlphaGo — but it didn't work for Ludo. AlphaZero's tree search assumes you can simulate the future of the game cleanly, but a dice game branches four ways every turn, so any reasonable amount of search drowns in randomness.
Worth mentioning because the failure was instructive: pure tree-search doesn't survive in games with this much randomness.
Original paper →A 2017 idea that lets a neural network reason about a "set" of things — like the four tokens you control — without caring what order they're in. We used this for one experiment in AlphaLudo, building a much smaller network with no convolutional layers at all. It hit the same ceiling as the bigger models, which is what convinced us the model itself wasn't the limit.
arXiv:1703.06114 →The reinforcement-learning algorithm doing the heavy lifting in every AlphaLudo run. PPO is the workhorse of modern RL — boring, reliable, well-understood. We didn't try to be clever with the optimiser; the interesting part of AlphaLudo is what we feed into it, not how we update the weights.
arXiv:1707.06347 →Project meta
A six-month side project on what it actually takes to learn Ludo from raw self-play. Built end-to-end — engine, training, mech-interp, and this site.
Runtime
Model
By the numbers
Privacy
Nothing. There is no backend. Your moves never leave your browser. The page loads Google Fonts and (on the Lineage page) one YouTube embed via youtube-nocookie.com; that's the only third-party traffic. No analytics, no cookies, no telemetry.
Connect
Built by Sumit Pal as a side project. The full training pipeline — engine, model code, every experiment, the journal — is open-source. Reach out if you want to chat about it.
Ready?
The network is already loaded. Pick up the dice.