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

still a working view ended · each leads to its entry below

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

  1. 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
  2. Shannon number, Wikipedia
  3. Alpha–beta pruning (introduction, History), Wikipedia
  4. Deep Blue (chess computer), Wikipedia
  5. 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.

  1. 1950-Present

    Search-and-evaluation engine

    How can a machine choose good chess moves by searching and scoring positions?

    Fly to its tower in Nousfarer

  2. 1978-2005

    Hardware-accelerated chess machines

    Can special-purpose hardware make a chess machine play stronger?

    Fly to its tower in Nousfarer

  3. 1980-Present

    Opening book and endgame tablebase knowledge

    How can stored opening and endgame knowledge improve machine play?

    Fly to its tower in Nousfarer

  4. 1990-Present

    Engine rating and benchmarking culture

    How can we measure and compare the strength of chess engines?

    Fly to its tower in Nousfarer

  5. 1995-Present

    Open-source engine development

    How does shared source code accelerate engine improvement?

    Fly to its tower in Nousfarer

  6. 1997-2010

    Advanced chess

    Can humans and machines play better together than alone?

    Fly to its tower in Nousfarer

  7. 2017-Present

    AlphaZero

    Can a system learn to play chess well from scratch by self-play?

    Fly to its tower in Nousfarer

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.

Search-and-evaluation engineHardware-accelerated chess machinesOpening book and endgame tablebase kn…Engine rating and benchmarking cultureOpen-source engine developmentAdvanced chessAlphaZero

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.

A city in Nousfarer: a red-carpeted stair climbing terraces to a crowned tower on an acropolis, more towers round it, forest and snowy mountains beyond.
A city in Nousfarer, the game played in the browser.

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 Chess

Related fields

Fields its ideas are linked to

More in Chess

See where Computer Chess sits on the Map of Human Knowledge