On February 10th, 1996, a computer program (IBM's Deep Blue) defeated the reigning chess champion (Garry Kasparov) in a game of chess for the first time. Deep Blue would go on to lose the match, but a year later, would get its revenge in a 3.5-2.5 rematch.

In order to achieve this feat, IBM spent several million dollars on research and development building a special-purpose computer specifically for this purpose. Deep Blue itself (the victorious, upgraded version) was powered by 30 P2SC processors each running at roughly 120 MHz, and (most importantly) 480 custom VLSI chess co-processors used to perform chess-specific operations like move generation and position evaluation. When it was built, Deep Blue was the 259th most powerful supercomputer in the world, and could analyze over 200 million chess positions per second.

But was Deep Blue necessary to beat Kasparov? Or could we have gotten away with an off-the-shelf 1996 desktop running a smarter chess engine?

As it turns out, we could easily have beaten Kasparov without building Deep Blue, using only commodity hardware, and it (almost certainly) wouldn't have even been close. I know this because, as I write this very sentence, I have sitting next to me a 200 MHz Intel Pentium Pro (released exactly 31 years ago---November 1st, 1995) with 64MB of RAM running a custom port of Stockfish that plays at an estimated Elo of 3300 ± 87 at classical time controls---far beyond the strength of any human, or indeed Kasparov's Elo of just under 2800. But wait, there's more! I've hooked this machine up to the internet with a Realtek RTL8139C Ethernet card, so you can play it below!

wait, what?! how??

There are three ways to get stronger at chess: you can analyze more moves, analyze better moves, or analyze moves better. Famously, humans improve by doing the latter two: the average chess grandmaster during a classical game will analyze roughly the same number of moves as an amateur player, but they analyze only the most critical moves and do a better job with that analysis. Chess engines like Stockfish, running on silicon instead of our human brains, dominate us at the first of these and analyze millions of positions per second. And because there's not that much room for micro-optimizations on modern engines that will let a given CPU process more positions per second, most progress in chess AI also tends to follow how humans improve and finds better methods for selecting moves and analyzing boards.

Skill in chess is measured by an Elo score. A difference of 200 Elo means that you should expect the stronger player to win three out of every four games, and multiplicatively from there: a 400 Elo gap corresponds to a 90% expected score and a 1000 Elo gap gives a 99.7% expected score. The best chess engines that you could run on commodity 1996 hardware were rated roughly 2300 Elo. Deep Blue was rated 2700. In contrast, modern Stockfish is rated closer to 3700.

This raises the question: how much of the advantage of a modern chess engine comes down to the fact that a modern desktop computer is extremely fast, and how much of the advantage comes down to the fact that we've just gotten better at programming chess engines? As it turns out, the majority of the Elo gains (+720 of the +1335 gained) can be attributed to better programming, and not better hardware.

To test this, I ran two experiments. The first experiment uses Crafty, a competitive engine from 1996 whose source code is now available. On my Pentium Pro, the 1996 build of Crafty version 11.13 has an Elo of 1999 ± 90 at 1 second per move, and 2383 ± 77 at 10 seconds per move. On modern hardware (a Ryzen 7) this engine's Elo jumps massively to 2614 ± 97 at the same 1 second per move. But if I take this engine and slowly start to add all the knowledge we have about how to design better chess engines---adding modern search algorithms like fail-soft, LMR, correction history; adding better quiescence methods; and adding neural-net evals (NNUE)---then you can increase the Elo up to 2718 ± 34 on the Pentium Pro at 1 second per move, and 2974 ± 74 at 10 seconds per move.

In the second experiment I go somewhat further: instead of trying to update Crafty, let's just try to get Stockfish---the best chess engine today---running on 1996 hardware and see how it does. This takes some work and is mainly a matter of rewriting the code so that it uses 32-bit arithmetic (a PPro is a 32-bit machine) and doesn't use more than 64MB of RAM. This naive port has an Elo of roughly 2496 ± 64 at 1 second per move (2940 ± 76 at 10 seconds per move). But we can do better! A modern Stockfish engine is designed to run on a modern CPU. By making a number of adjustments to the algorithm and tuning it to the Pentium, we can increase its Elo to 2846 ± 35 at 1 second per move, 3109 ± 79 at 10 seconds per move, and 3180 ± 80 at 30 seconds per move.

The most concise way to summarize all of the above is just to have them play a match of 100 games against each other. And when I do this, I find that a modern chess engine running on a 1996 Pentium Pro wins 78, draws 17, and loses 5 games against the 1996 Crafty engine running on modern hardware.

The remainder of this article provides the details.

Technical details: Hardware & OS

There's not much to say about the hardware, to be honest. I bought a used ("vintage" said the listing; I feel old.) desktop PC with standard period-appropriate hardware. The desktop is running a 200 MHz Intel Pentium Pro connected to an Intel VS440FX motherboard with 64MB of SIMM RAM clocked at 66 MHz. The operating system boot off of a 1.44MB 3.5 inch floppy disk, and connect to the Internet via a Realtek RTL8139C. I also have a 1MB Trio64V+ graphics card connected over VGA to my monitor, with input coming from a PS/2 keyboard---but I don't much use either of those and instead communicate with it over a serial port connected to my modern desktop.

For those readers who may not be able to appropriately contextualize this hardware, a 200 MHz Pentium Pro sold for $1,325 at launch in November 1995, and four 16 MB SIMMs would have cost about $2,000. Add on the other peripherals, and this machine would likely have gone for about four or five thousand dollars. So it's a nice workstation, but by no means a supercomputer. However, given the rate of depreciation and the exponential rate of improvements to hardware, this same machine in 1997, when the second match occurred, would likely go for just a thousand dollars (because who would want to buy a Pentium Pro when the better-in-almost-every-way Pentium MMX was now available for just $400?)

The interface between the chess engine and the internet is a custom-built "operating system" whose sole job is to spin up the chess engine and connect it directly to the networking card. (Throughout this article, when I say "I wrote", what I really mean is "I asked an LLM to write". I used a combination of Fable 5.1, Opus 5.5, and GPT-6.) It's designed to be as compact as possible: the operating system (which, in fact, is more like a hypervisor, or something) is sitting on a bootable floppy disk. Its sole job is to boot the Pentium Pro into 32-bit protected mode, initialize the networking card, and await further instructions. I can then send it any arbitrary "userspace" guest program that I want into RAM and it'll boot that up and start running it. The chess program I wrote starts up a custom-built HTTP server which waits for incoming HTTP requests with a given position (as a FEN string) and maximum run time, and on each request runs the engine until the timer expires, and returns a response.

Technical details: Software

As mentioned earlier I (again: a language model) actually modified two engines. The stronger of the two is powered by Stockfish adapted to run efficiently on a thirty-year-old processor. It plays at an estimated Elo of 3300 at classical time controls [a] Because I can't run nearly enough games at classical time controls on my single machine to get this number, I've extrapolated it from shorter time controls. I measured 3180 ± 80 at 30 seconds per move, and it gained +70 Elo per tripling of the time between 1 second to 10 seconds and 10 seconds to 30 seconds. Because a classical game gives about six minutes per move (including thinking on the opponent's turn) we should expect an Elo of 3350. Allowing for some diminishing returns, a safe estimate is an Elo of 3300. , high enough above Kasparov's 2800 Elo that we should expect Stockfish-1996 to come out ahead with a score of roughly 9/10. The (only slightly) weaker engine starts with the source code to Crafty 11.13, and is brought forward in time by adding all the lessons we've learned about how to write a better chess engine over the past thirty years.

Updating Crafty 11.13 (1996) with modern tricks

The first engine I (read: my LLM) worked on was Crafty 11.13, its 1996 release. On this engine the LLM had to do the most work to backport ideas we've learned over the last 30 years. Below is a breakdown of where the Elo gains come from, when evaluating either at 1 second per move or 10 seconds per move. [b] Sometimes you'll find the 1s vs 10s improvements disagree. Part of this clearly could be noise---I only ran a few hundred games which leaves a relatively large margin of error---but there is also quite a lot of signal here. Because the 1996 computer is so much slower, at 1s/move it has a very low search depth and so how fast the evaluation runs matters more than how good it is. But at larger search depths, once you stop making tactical blunders, the position evaluation becomes much more important.

Porting Stockfish 17 onto a Pentium Pro

On the second engine, as mentioned above, I did the inverse. I (again, read: my LLM) ported Stockfish to run on 1996 hardware, and then tweaked the parameters so that it would be better suited to lower search depth. The gains here are thus somewhat more modest, because there are no large algorithm wins that remain.

So would this have beaten Kasparov?

I think it's overwhelmingly likely to be the case, but it's actually a little bit more tricky of a situation than you might hope. You see, I've done a bit of sleight of hand throughout this article. The problem is that Elo scores are relative, and I've been comparing my engine's Elo to that of various Stockfish engines that have known strengths on the Computer Chess Rating Lists (CCRL). But because humans don't play against engines very frequently, there can be some small divergences between scores on the FIDE Elo ladder and the CCRL ladder, in the same way a player's FIDE Elo doesn't directly translate to their Elo on online chess. Fortunately, because I've gotten these engines to play at an Elo rating of 3200-3300, and Kasparov was rated just under 2800, there should be more than sufficient buffer to absorb any discrepancy.

But if you happen to know a 2700+ Super GM who wants to try and defeat a 2026 chess engine playing on 1996 hardware, I'd be happy to accept the challenge!

Conclusion

The first time we humans do anything, we rarely do it efficiently. Once we see a path that would clearly work if only we scaled it up, we do just that. Only later, after we've had the time to better understand the problem at hand, do we come to recognize that we could have achieved the same feat much more efficiently by being clever.

I mostly did this for fun, because whether I could have beaten Kasparov with commodity hardware sounded like a fun question to answer, but I also hoped it would provide a tiny bit of insight into the rate of algorithmic progress in "AI". Chess engines in 1997 were already quite advanced; after all, Alan Turing helped write the first chess program nearly fifty years earlier. So I suppose at the time it seemed plausible that maybe there weren't that many more ideas left to find. And with hindsight it's easy to see that's wrong.

Which leads to the question: just how much are we leaving on the table with modern-day "AI"---that is to say, language models. Will the advances we accrue over the next few years from software outpace the advances in hardware scale? Clearly this toy experiment doesn't answer that question definitively, but it does gesture at a potential future. (There's also probably some kind of meta-lesson about using LLMs---"AI"---to speed up our ability to answer weired research questions like this.)

(Also, uh, if anyone has any ideas for projects I could do with a Pentium Pro in a few weeks once I no longer need it to host this chess engine ... do let me know!)