Could a modern chess engine on a Pentium have defeated Kasparov in 1996?

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
, 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.

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!)