Computer Chess
Computer chess is the project of making machines play chess well, and of the ideas that project produced.
7 frameworks, from 1950 to today · Chess · Games
Overview
Computer chess is the project of making machines play chess well, and of the ideas that project produced1. It matters beyond the game for two reasons. First, chess was for decades the standard test of machine intelligence: a board small enough to compute over, a game deep enough that brute force alone seemed hopeless, and a rich human tradition against which to measure progress1. Second, the methods developed to play chess—search, evaluation, hardware acceleration, and eventually self-play learning—became templates for artificial intelligence far outside the board. The story runs from a nineteenth-century curiosity about mechanical reasoning to programs that now outplay the strongest humans, and it is a story of competing ideas about how to think.
Mechanical dreams and the first programs
The idea that a machine might play chess is older than the computer1. In 1770 Wolfgang von Kempelen unveiled the Mechanical Turk, a cabinet with a turbaned figure that played strong chess against visitors; it was a celebrated illusion operated by a hidden human, and it set the cultural template of the chess automaton. Real computation arrived with Charles Babbage's designs for mechanical engines in the 1830s, and in 1914 the Spanish engineer Leonardo Torres y Quevedo built an electromechanical device that could play a simple king-and-rook-versus-king endgame automatically, using a mechanical sensing of the board. These were demonstrations of principle, not players.
The founding intellectual document came from Claude Shannon, who in 1950 published "Programming a Computer for Playing Chess."12 Shannon framed the problem precisely: a program must generate legal moves, evaluate resulting positions, and search ahead. Because the full game tree is astronomically large, he proposed two strategies—a brute-force search to a fixed depth, and a selective search that follows only promising lines1. He also proposed a simple evaluation function, a numerical score of a position based on material and piece activity. Almost every later engine descends from this framing. Alan Turing, working around the same period, wrote a hand-simulated chess program (there was no machine to run it) and played games by following its rules on paper, losing to a colleague but demonstrating that the logic worked.
Search and evaluation: the classical engine
The first real programs appeared in the late 1950s1. Alex Bernstein and colleagues at IBM produced a program for the IBM 704 in 1957 that searched a few plies (a ply is one move by one side) and used a crude evaluation. The decisive advance came from the recognition that not every branch of the game tree needs examining. The alpha-beta algorithm, developed independently in the 1950s and 1960s (John McCarthy is often credited with an early formulation), prunes branches that cannot affect the final decision: if a player already has a move good enough to refute a line, the remaining replies need not be searched13. This made deeper search feasible and became the backbone of chess engines for half a century.
The 1960s and 1970s saw the classical search-and-evaluation engine mature. Such an engine combines a fixed-depth search with a hand-crafted evaluation function that scores material, pawn structure, king safety, and piece mobility1. The Greenblatt program, written by Richard Greenblatt and others at MIT in the late 1960s, was the first to play respectably in tournament conditions, winning the first United States Computer Chess Championship in 1970. The Soviet program Kaissa, developed at the Institute of Control Sciences in Moscow under Mikhail Botvinnik's encouragement, won the first World Computer Chess Championship in 1974. These programs established the pattern: search deeply, evaluate carefully, and tune the evaluation by hand.
A crucial refinement was the transposition table, a cache that stores the results of positions already searched so that different move orders reaching the same position are not recomputed1. Coupled with iterative deepening—searching to depth one, then two, then three, reusing earlier results—these techniques let engines search far deeper than naive methods allowed1. The 1980s brought a wave of microcomputer programs, notably Belle, developed by Ken Thompson and Joe Condon at Bell Labs, which in 1980 became the first program to earn a master rating in tournament play.
Hardware acceleration and the brute-force era
Belle pointed toward a second path: build special-purpose hardware. Thompson and Condon designed Belle with dedicated circuitry to generate and evaluate moves, so that the machine could examine positions far faster than a general-purpose computer. This hardware-accelerated approach culminated in Deep Blue, the IBM machine that in 1997 defeated the reigning world champion Garry Kasparov in a six-game match14. Deep Blue combined custom chess chips with a large parallel computer and a substantial opening book and endgame database; it searched roughly 200 million positions per second. Its victory was a landmark, but it was also the high-water mark of the brute-force philosophy: Deep Blue won by searching enormously fast with a hand-tuned evaluation, not by understanding chess in a human way.
Alongside hardware, the 1990s saw the rise of strong software engines running on ordinary PCs. Programs such as Fritz, Hiarcs, and Rebel competed in tournaments and, increasingly, were used by human players for analysis and preparation. The opening book—a stored database of opening moves—became a standard component, letting engines play the first moves instantly and consistently with known theory1. Endgame tablebases, pioneered by Ken Thompson in the 1980s, went further: by exhaustive retrograde analysis, they computed the exact win/draw/loss value of every position with a small number of pieces (three, four, and eventually more), giving engines perfect play in those endings. Thompson's work on five-piece tablebases in the 1990s, and later efforts extending to six and seven pieces, made the endgame a solved region of the game.
Measuring strength and the open-source turn
As engines proliferated, the field needed objective ways to compare them. Engine rating lists, most influentially the one maintained by the Swedish statistician and programmer Martin Sedlak and later the widely used CCRL and SSDF lists, played thousands of games between engines under controlled conditions and computed Elo-style ratings. These lists turned engine development into an empirical science: a change to an evaluation term or search parameter could be tested against a large pool of opponents and its effect measured. This culture of benchmarking—run games, measure, keep what wins—became central to how engines improved.
The 2000s brought open-source engine development to the fore. The program Crafty, by Robert Hyatt, was among the first strong engines distributed with source code, and it seeded a community of developers who shared and modified code. The most consequential was Stockfish, an open-source engine that, through continuous community contribution and relentless tuning, became one of the strongest players in the world5. Open source accelerated progress because ideas could be inspected, tested, and improved by many hands at once, and because the benchmarking culture could be applied at scale.
Humans and machines together
As engines surpassed human strength, a new practice emerged: advanced chess, or human-machine partnership. In this format, a human player uses an engine during the game, and the pair competes against other pairs. The idea, promoted in the late 1990s, was that human judgment and machine calculation might combine to beat either alone. The results were mixed and instructive: strong engines plus weak humans often beat strong humans alone, but the partnership's value lay in how the human selected among engine suggestions and managed the clock. The practice faded as engines became so strong that the human contribution shrank, but it left a lasting mark on how players prepare and analyze.
Neural networks and self-play
The most recent turning point came from outside classical chess programming. In 2017 the team at DeepMind, led by David Silver, published work on AlphaZero, a system that learned to play chess, shogi, and Go from scratch by self-play combined with a neural network and Monte Carlo tree search (MCTS). MCTS is a search method that samples promising lines rather than exhaustively enumerating them, guided by a learned policy that suggests which moves to explore. The neural network, trained by playing millions of games against itself, learned both a policy (which moves look good) and a value function (how favorable a position is). AlphaZero defeated the strongest existing engines in a short match, playing in a style that many commentators found strikingly human—sacrificing material for initiative in ways classical evaluation would not have chosen.
The impact on computer chess was immediate. The open-source engine Leela Chess Zero (LCZero) applied the same self-play and neural-network approach, and the technique spread. Modern top engines increasingly combine classical search with neural-network evaluation, and the boundary between the two traditions has blurred. The old hand-tuned evaluation functions are being replaced or supplemented by learned ones, while the search algorithms—alpha-beta, MCTS, transposition tables—remain the scaffolding.
Where computer chess stands
Today the strongest chess players in the world are machines, and the leading engines use a hybrid of deep search and learned evaluation, often running on consumer hardware1. The classical search-and-evaluation engine, the hardware-accelerated machine, the opening book, the endgame tablebase, and the rating list all remain in use, but the frontier has moved to neural self-play. The open questions are no longer whether machines can play chess well—they can—but how learned evaluation and classical search should be combined, how much of chess understanding can be extracted from self-play alone, and what the resulting play reveals about the game itself. The history of computer chess is, in the end, a history of successive answers to Shannon's question of how to search and how to evaluate, each answer making the next one possible.
References
- Computer chess (introduction, Computer methods, Pre-computer age, Timeline, History, Leaf evaluation, Other optimizations, Computers versus humans, Microcomputer revolution, Opening book, Availability and playing strength), Wikipedia
- Shannon number, Wikipedia
- Alpha–beta pruning (introduction, History), Wikipedia
- Deep Blue (chess computer), Wikipedia
- Stockfish (chess), Wikipedia
The frameworks of Computer Chess
Each framework is a way of working the field has used: when it held, and the question it answers.
- 1950-Present
Search-and-evaluation engine
How can a machine choose good chess moves by searching and scoring positions?
- 1978-2005
Hardware-accelerated chess machines
Can special-purpose hardware make a chess machine play stronger?
- 1980-Present
Opening book and endgame tablebase knowledge
How can stored opening and endgame knowledge improve machine play?
- 1990-Present
Engine rating and benchmarking culture
How can we measure and compare the strength of chess engines?
- 1995-Present
Open-source engine development
How does shared source code accelerate engine improvement?
- 1997-2010
- 2017-Present
AlphaZero
Can a system learn to play chess well from scratch by self-play?
How the ideas connect
Each arrow runs from an earlier idea to the later one it shaped. The list below says what passed between them.
Hardware-accelerated chess machines grew out of Search-and-evaluation engine
Belle, built by Ken Thompson and Joe Condon at Bell Labs, took the search-and-evaluation engine and moved its move generation and evaluation into dedicated hardware, making it the first strong hardware-accelerated chess machine.
Carried by Ken Thompson; Joe Condon; Belle.
AlphaZero reacted against Search-and-evaluation engine
AlphaZero was framed against the classical search-and-evaluation engine: it replaced hand-crafted evaluation and alpha-beta search with a neural network trained by self-play and Monte Carlo tree search, and defeated the strongest classical engines.
Carried by David Silver; DeepMind; AlphaZero.
Opening book and endgame tablebase knowledge grew out of Search-and-evaluation engine
Opening books and endgame tablebases were added to classical search engines as stored knowledge to supplement search: books to play the opening instantly and tablebases to give exact play in small endings.
Carried by Ken Thompson.
Engine rating and benchmarking culture grew out of Search-and-evaluation engine
As classical engines proliferated, rating lists such as SSDF and later CCRL played thousands of games between them to compute Elo-style ratings, turning engine development into an empirical benchmarking science.
Carried by SSDF; CCRL.
Open-source engine development grew out of Search-and-evaluation engine
Crafty, by Robert Hyatt, was among the first strong classical engines distributed with source code, seeding an open-source community that shared and modified search-and-evaluation code.
Carried by Robert Hyatt; Crafty.
Advanced chess influenced by Search-and-evaluation engine
Advanced chess arose once classical engines were strong enough to be useful partners: a human played with an engine during the game, combining human judgment with the engine's search and evaluation.
Carried by Garry Kasparov.
Open-source engine development influenced by Engine rating and benchmarking culture
The benchmarking culture of rating lists—run games, measure, keep what wins—was applied at scale by open-source projects, most notably Stockfish, whose continuous community tuning depended on large-scale engine testing.
Carried by Stockfish.
Advanced chess influenced by Hardware-accelerated chess machines
Deep Blue's 1997 match against Kasparov made the strength of hardware-accelerated machines vivid and prompted the human-machine partnership format in which humans consult engines during play.
Carried by Deep Blue; Garry Kasparov.
Beyond the field
Where Computer Chess's ideas came from in other fields, and what they led to there: the strongest 12 of 22 links.
Search-and-evaluation engine led to Endgame tablebase in Endgame Theory
Endgame tablebases grew out of computer chess's search-and-evaluation engines, replacing heuristic evaluation with exhaustive retrograde search in reduced material. The tablebase is the limiting case of engine search where the tree can be fully solved.
Carried by Ken Thompson.
Search-and-evaluation engine influenced Engine-assisted preparation in Chess
The search-and-evaluation engine architecture, from Shannon's 1950 paper onward, is the technology whose output players began consulting in the 1990s as preparation aid.
Carried by Claude Shannon.
Search-and-evaluation engine influenced Engine-Based Calculation in Middlegame Theory
Engine-based calculation depends on the search-and-evaluation architecture of computer chess engines, which supply the lines and evaluations players calculate with. The method is unthinkable without that engine technology.
Search-and-evaluation engine influenced Self-play in Game Playing Ai
Self-play requires an engine to play both sides, and the search-and-evaluation engine supplied that opponent. Samuel's checkers work pitted his evaluation-learning program against versions of itself using the same search.
Carried by Arthur Samuel.
Search-and-evaluation engine influenced Engine-driven opening analysis in Opening Theory
The alpha-beta search-and-evaluation engines developed from the 1950s onward became strong enough in the 1990s that players began preparing openings by consulting engine output, which is the basis of engine-driven analysis.
Search-and-evaluation engine led to Brute-Force Search and Special-Purpose Hardware in Game Playing Ai
Brute-force search and special-purpose hardware grew out of the search-and-evaluation engine by trading evaluation knowledge for raw speed and depth. The same move generation and value backup were retained while the evaluation was simplified.
Opening book and endgame tablebase knowledge influenced Computer solving and engine analysis in Draughts
Chess endgame tablebases and opening books provided the model of precomputed perfect knowledge that draughts solving adopted, culminating in the Chinook project's complete endgame databases. The technique of retrograde tablebase generation passed directly from computer chess to computer draughts.
AlphaZero influenced by Self-play in Game Playing Ai
AlphaZero's training loop is self-play: the system generates its own games and learns from them. The general self-play idea, used in checkers and other game programs from the late 1950s, supplied the training scheme that AlphaZero scaled with deep networks and MCTS.
Carried by Arthur Samuel.
AlphaZero grew out of AlphaGo in Life And Death
AlphaZero was built directly as a generalisation of AlphaGo Zero, dropping the human game records and Go-specific tuning to handle chess, shogi and Go with one algorithm. The AlphaGo line supplied the architecture, the self-play pipeline and the MCTS-plus-network evaluation that AlphaZero reused.
Carried by AlphaGo Zero (2017); David Silver.
AlphaZero influenced by Monte Carlo tree search in Planning And Search
AlphaZero's search is a Monte Carlo tree search guided by a neural network's policy and value estimates, the same PUCT-style selection used in AlphaGo. MCTS is the planning component without which the system's play would not work.
Carried by Rémi Coulom; AlphaGo (2016).
AlphaZero influenced by Self-play reinforcement learning in Computer Go
AlphaZero is the demonstration that pure self-play reinforcement learning with a neural network can master chess, Go and shogi, extending the approach to the more general self-play framework.
Search-and-evaluation engine influenced by Classical positional school in Chess
The classical positional school's concepts (pawn structure, piece activity, king safety) were the source of the evaluation features that early chess programs such as those of Shannon and Bernstein encoded.
Carried by Claude Shannon.

Computer Chess is a planet in Nousfarer
Its city has a tower for each of these 7 frameworks. Land, walk in, and climb one concept at a time.
Land on Computer ChessRelated fields
Fields its ideas are linked to
- Game Playing Ai 4 links
- Chess 3 links
- Computer Go 3 links
- Shogi 2 links
- Xiangqi 2 links
- Planning And Search 1 link
- Chess Composition 1 link
- Endgame Theory 1 link
- Middlegame Theory 1 link
- Opening Theory 1 link
- Life And Death 1 link
- Backgammon 1 link