computer chess

Availability and playing strength

In the past, stand-alone chess machines (usually microprocessors running software chess programs; occasionally specialized hardware) were sold. Today, chess engines may be installed as software on ordinary devices like smartphones and PCs, either alone or alongside GUI programs such as Chessbase and the mobile apps for Chess.com and Lichess (both primarily websites). Examples of free and open source engines include Stockfish and Leela Chess Zero (Lc0). Chess.com maintains its own proprietary engine named Torch. Some chess engines, including Stockfish, have web versions made in languages like WebAssembly and JavaScript. Most chess programs and sites offer the ability to analyze positions and games using chess engines, and some offer the ability to play against engines (which can be set to play at custom levels of strength) as though they were normal opponents.

Hardware requirements for chess engines are minimal, but performance will vary with processor speed, and memory, needed to hold large transposition tables.

Most modern chess engines, such as Stockfish, rely on efficiently updatable neural networks, tailored to be run exclusively on CPUs, but Lc0 uses networks reliant on GPU performance. Top engines such as Stockfish can be expected to beat the world's best players reliably, even when running on consumer-grade hardware.

Types and features of chess software

Perhaps the most common type of chess software are programs that simply play chess. A human player makes a move on the board, the AI calculates and plays a subsequent move, and the human and AI alternate turns until the game ends. The chess engine, which calculates the moves, and the graphical user interface (GUI) are sometimes separate programs. Different engines can be connected to the GUI, permitting play against different styles of opponent. Engines often have a simple text command-line interface, while GUIs may offer a variety of piece sets, board styles, or even 3D or animated pieces. Because recent engines are so capable, engines or GUIs may offer some way of handicapping the engine's ability, to improve the odds for a win by the human player. Universal Chess Interface (UCI) engines such as Fritz or Rybka may have a built-in mechanism for reducing the Elo rating of the engine (via UCI's uci_limitstrength and uci_elo parameters). Some versions of Fritz have a Handicap and Fun mode for limiting the current engine or changing the percentage of mistakes it makes or changing its style. Fritz also has a Friend Mode where during the game it tries to match the level of the player.

Chess databases allow users to search through a large library of historical games, analyze them, check statistics, and formulate an opening repertoire. Chessbase (for PC) is a common program for these purposes amongst professional players, but there are alternatives such as Shane's Chess Information Database (Scid) for Windows, Mac or Linux, Chess Assistant for PC, Gerhard Kalab's Chess PGN Master for Android or Giordano Vicoli's Chess-Studio for iOS.

Programs such as Playchess allow players to play against one another over the internet.

Chess training programs teach chess. Chessmaster had playthrough tutorials by IM Josh Waitzkin and GM Larry Christiansen. Stefan Meyer-Kahlen offers Shredder Chess Tutor based on the Step coursebooks of Rob Brunia and Cor Van Wijgerden. Former World Champion Magnus Carlsen's Play Magnus company released a Magnus Trainer app for Android and iOS. Chessbase has Fritz and Chesster for children. Convekta provides a large number of training apps such as CT-ART and its Chess King line based on tutorials by GM Alexander Kalinin and Maxim Blokh.

There is also software for handling chess problems.

Computers versus humans

After discovering refutation screening—the application of alpha–beta pruning to optimizing move evaluation—in 1957, a team at Carnegie Mellon University predicted that a computer would defeat the world human champion by 1967. It did not anticipate the difficulty of determining the right order to evaluate moves. Researchers worked to improve programs' ability to identify killer heuristics, unusually high-scoring moves to reexamine when evaluating other branches, but into the 1970s most top chess players believed that computers would not soon be able to play at a Master level. In 1968, International Master David Levy made a famous bet that no chess computer would be able to beat him within ten years, and in 1976 Senior Master and professor of psychology Eliot Hearst of Indiana University wrote that "the only way a current computer program could ever win a single game against a master player would be for the master, perhaps in a drunken stupor while playing 50 games simultaneously, to commit some once-in-a-year blunder".

In the late 1970s chess programs began defeating highly skilled human players. The year of Hearst's statement, Northwestern University's Chess 4.5 at the Paul Masson American Chess Championship's Class B level became the first to win a human tournament. Levy won his bet in 1978 by beating Chess 4.7, but it achieved the first computer victory against a Master-class player at the tournament level by winning one of the six games. In 1980, Belle began often defeating Masters. By 1982 two programs played at Master level and three were slightly weaker.

The sudden improvement without a theoretical breakthrough was unexpected, as many did not expect that Belle's ability to examine 100,000 positions a second—about eight plies—would be sufficient. The Spracklens, creators of the successful microcomputer program Sargon, estimated that 90% of the improvement came from faster evaluation speed and only 10% from improved evaluations. New Scientist stated in 1982 that computers "play terrible chess ... clumsy, inefficient, diffuse, and just plain ugly", but humans lost to them by making "horrible blunders, astonishing lapses, incomprehensible oversights, gross miscalculations, and the like" much more often than they realized; "in short, computers win primarily through their ability to find and exploit miscalculations in human initiatives".

By 1982, microcomputer chess programs could evaluate up to 1,500 moves a second and were as strong as mainframe chess programs of five years earlier, able to defeat a majority of amateur players. While only able to look ahead one or two plies more than at their debut in the mid-1970s, doing so improved their play more than experts expected; seemingly minor improvements "appear to have allowed the crossing of a psychological threshold, after which a rich harvest of human error becomes accessible", New Scientist wrote. While reviewing SPOC in 1984, BYTE wrote that "Computers—mainframes, minis, and micros—tend to play ugly, inelegant chess", but noted Robert Byrne's statement that "tactically they are freer from error than the average human player". The magazine described SPOC as a "state-of-the-art chess program" for the IBM PC with a "surprisingly high" level of play, and estimated its USCF rating as 1700 (Class B).

Computer methods

Since the era of mechanical machines that played rook and king endings and electrical machines that played other games like hex in the early years of the 20th century, scientists and theoreticians have sought to develop a procedural representation of how humans learn, remember, think and apply knowledge, and the game of chess, because of its daunting complexity, became the "Drosophila of artificial intelligence (AI)". The procedural resolution of complexity became synonymous with thinking, and early computers, even before the chess automaton era, were popularly referred to as "electronic brains". Several different schema were devised starting in the latter half of the 20th century to represent knowledge and thinking, as applied to playing the game of chess (and other games like checkers):

Search based (brute force vs selective search)

Search in search based schema (minimax/alpha-beta, Monte Carlo tree search)

Evaluations in search based schema (machine learning, neural networks, texel tuning, genetic algorithms, gradient descent, reinforcement learning)

Knowledge based (PARADISE, endgame tablebases)

Using "ends-and-means" heuristics a human chess player can intuitively determine optimal outcomes and how to achieve them regardless of the number of moves necessary, but a computer must be systematic in its analysis. Most players agree that looking at least five moves ahead (ten plies) when necessary is required to play well. Normal tournament rules give each player an average of three minutes per move. On average there are more than 30 legal moves per chess position, so a computer must examine a quadrillion possibilities to look ahead ten plies (five full moves); one that could examine a million positions a second would require more than 30 years.

The earliest attempts at procedural representations of playing chess predated the digital electronic age, but it was the stored program digital computer that gave scope to calculating such complexity. Claude Shannon, in 1949, laid out the principles of algorithmic solution of chess. In that paper, the game is represented by a "tree", or digital data structure of choices (branches) corresponding to moves. The nodes of the tree were positions on the board resulting from the choices of move. The impossibility of representing an entire game of chess by constructing a tree from first move to last was immediately apparent: there are an average of 36 moves per position in chess and an average game lasts about 35 moves to resignation (60-80 moves if played to checkmate, stalemate, or other draw). There are 400 positions possible after the first move by each player, about 200,000 after two moves each, and nearly 120 million after just 3 moves each.

Graphical user interface

Computer chess programs usually support a number of common de facto standards. Nearly all of today's programs can read and write game moves as Portable Game Notation (PGN), and can read and write individual positions as Forsyth–Edwards Notation (FEN). Older chess programs often only understood long algebraic notation, but today users expect chess programs to understand standard algebraic chess notation.

Starting in the late 1990s, programmers began to develop separately engines (with a command-line interface which calculates which moves are strongest in a position) or a graphical user interface (GUI) which provides the player with a chessboard they can see, and pieces that can be moved. Engines communicate their moves to the GUI using a protocol such as the Chess Engine Communication Protocol (CECP) or Universal Chess Interface (UCI). By dividing chess programs into these two pieces, developers can write only the user interface, or only the engine, without needing to write both parts of the program. (See also chess engine.)

Developers have to decide whether to connect the engine to an opening book and/or endgame tablebases or leave this to the GUI.

Board representations

The data structure used to represent each chess position is key to the performance of move generation and position evaluation. Methods include pieces stored in an array ("mailbox" and "0x88"), piece positions stored in a list ("piece list"), collections of bit-sets for piece locations ("bitboards"), and huffman coded positions for compact long-term storage.

Search techniques

Computer chess programs consider chess moves as a game tree. In theory, they examine all moves, then all counter-moves to those moves, then all moves countering them, and so on, where each individual move by one player is called a "ply". This evaluation continues until a certain maximum search depth or the program determines that a final "leaf" position has been reached (e.g. checkmate).

One particular type of search algorithm used in computer chess are minimax search algorithms, where at each ply the "best" move by the player is selected; one player is trying to maximize the score, the other to minimize it. By this alternating process, one particular terminal node whose evaluation represents the searched value of the position will be arrived at. Its value is backed up to the root, and that evaluation becomes the valuation of the position on the board. This search process is called minimax.

A naive implementation of the minimax algorithm can only search to a small depth in a practical amount of time, so various methods have been devised to greatly speed the search for good moves. Alpha–beta pruning, a system of defining upper and lower bounds on possible search results and searching until the bounds coincided, is typically used to reduce the search space of the program.

In addition, various selective search heuristics, such as quiescence search, forward pruning, search extensions and search reductions, are also used as well. These heuristics are triggered based on certain conditions in an attempt to weed out obviously bad moves (history moves) or to investigate interesting nodes (e.g. check extensions, passed pawns on seventh rank, etc.). These selective search heuristics have to be used very carefully however. If the program overextends, it wastes too much time looking at uninteresting positions. If too much is pruned or reduced, there is a risk of cutting out interesting nodes.

Monte Carlo tree search (MCTS) is a heuristic search algorithm which expands the search tree based on random sampling of the search space. A version of Monte Carlo tree search commonly used in computer chess is PUCT, Predictor and Upper Confidence bounds applied to Trees.

DeepMind's AlphaZero and Leela Chess Zero uses MCTS instead of minimax. Such engines use batching on graphics processing units in order to calculate their evaluation functions and policy (move selection), and therefore require a parallel search algorithm as calculations on the GPU are inherently parallel. The minimax and alpha-beta pruning algorithms used in computer chess are inherently serial algorithms, so would not work well with batching on the GPU. On the other hand, MCTS is a good alternative, because the random sampling used in Monte Carlo tree search lends itself well to parallel computing, and is why nearly all engines which support calculations on the GPU use MCTS instead of alpha-beta.

Knowledge versus search (processor speed)

In the 1970s, most chess programs ran on super computers like Control Data Cyber 176s or Cray-1s, indicative that during that developmental period for computer chess, processing power was the limiting factor in performance. Most chess programs struggled to search to a depth greater than 3 ply. It was not until the hardware chess machines of the 1980s, that a relationship between processor speed and knowledge encoded in the evaluation function became apparent.

It has been estimated that doubling the computer speed gains approximately fifty to seventy Elo points in playing strength (Levy & Newborn 1991:192).

Leaf evaluation

For most chess positions, computers cannot look ahead to all possible final positions. Instead, they must look ahead a few plies and compare the possible positions, known as leaves. The algorithm that evaluates leaves is termed the "evaluation function", and these algorithms are often vastly different between different chess programs. Evaluation functions typically evaluate positions in hundredths of a pawn (called a centipawn), where by convention, a positive evaluation favors White, and a negative evaluation favors Black. However, some evaluation function output win/draw/loss percentages instead of centipawns.

Historically, handcrafted evaluation functions consider material value along with other factors affecting the strength of each side. When counting up the material for each side, typical values for pieces are 1 point for a pawn, 3 points for a knight or bishop, 5 points for a rook, and 9 points for a queen. (See Chess piece relative value.) The king is sometimes given an arbitrarily high value such as 200 points (Shannon's paper) to ensure that a checkmate outweighs all other factors (Levy & Newborn 1991:45). In addition to points for pieces, most handcrafted evaluation functions take many factors into account, such as pawn structure, the fact that a pair of bishops are usually worth more, centralized pieces are worth more, and so on. The protection of kings is usually considered, as well as the phase of the game (opening, middle or endgame). Machine learning techniques such as Texel turning, stochastic gradient descent, or reinforcement learning are usually used to optimise handcrafted evaluation functions.

Most modern evaluation functions make use of neural networks. The most common evaluation function in use today is the efficiently updatable neural network, which is a shallow neural network whose inputs are piece-square tables. Piece-square tables are a set of 64 values corresponding to the squares of the chessboard, and there typically exists a piece-square table for every piece and colour, resulting in 12 piece-square tables and thus 768 inputs into the neural network. In addition, some engines use deep neural networks in their evaluation function. Neural networks are usually trained using some reinforcement learning algorithm, in conjunction with supervised learning or unsupervised learning.

The output of the evaluation function is a single scalar, quantized in centipawns or other units, which is, in the case of handcrafted evaluation functions, a weighted summation of the various factors described, or in the case of neural network based evaluation functions, the output of the head of the neural network. The evaluation putatively represents or approximates the value of the subtree below the evaluated node as if it had been searched to termination, i.e. the end of the game. During the search, an evaluation is compared against evaluations of other leaves, eliminating nodes that represent bad or poor moves for either side, to yield a node which by convergence, represents the value of the position with best play by both sides.

Endgame tablebases

Endgame play had long been one of the great weaknesses of chess programs because of the depth of search needed. Some otherwise master-level programs were unable to win in positions where even intermediate human players could force a win.

To solve this problem, computers have been used to analyze some chess endgame positions completely, starting with king and pawn against king. Such endgame tablebases are generated in advance using a form of retrograde analysis, starting with positions where the final result is known (e.g., where one side has been mated) and seeing which other positions are one move away from them, then which are one move from those, etc. Ken Thompson was a pioneer in this area.

The results of the computer analysis sometimes surprised people. In 1977 Thompson's Belle chess machine used the endgame tablebase for a king and rook against king and queen and was able to draw that theoretically lost ending against several masters (see Philidor position#Queen versus rook). This was despite not following the usual strategy to delay defeat by keeping the defending king and rook close together for as long as possible. Asked to explain the reasons behind some of the program's moves, Thompson was unable to do so beyond saying the program's database simply returned the best moves.

Most grandmasters declined to play against the computer in the queen versus rook endgame, but Walter Browne accepted the challenge. A queen versus rook position was set up in which the queen can win in thirty moves, with perfect play. Browne was allowed 2½ hours to play fifty moves, otherwise a draw would be claimed under the fifty-move rule. After forty-five moves, Browne agreed to a draw, being unable to force checkmate or win the rook within the next five moves. In the final position, Browne was still seventeen moves away from checkmate, but not quite that far away from winning the rook. Browne studied the endgame, and played the computer again a week later in a different position in which the queen can win in thirty moves. This time, he captured the rook on the fiftieth move, giving him a winning position.

Other positions, long believed to be won, turned out to take more moves against perfect play to actually win than were allowed by chess's fifty-move rule. As a consequence, for some years the official FIDE rules of chess were changed to extend the number of moves allowed in these endings. After a while, the rule reverted to fifty moves in all positions – more such positions were discovered, complicating the rule still further, and it made no difference in human play, as they could not play the positions perfectly.

Opening book

Chess engines, like human beings, may save processing time as well as select variations known to be strong via referencing an opening book stored in a database. Opening books cover the opening moves of a game to variable depth, depending on opening and variation, but usually to the first 10-12 moves (20-24 ply). In the early eras of computer chess, trusting variations studied in-depth by human grandmasters for decades was superior to the weak performance of mid-20th-century engines. And even in the contemporary era, allowing computer engines to extensively analyze various openings at their leisure beforehand, and then simply consult the results when in a game, speeds up their play.

In the 1990s, some theorists believed that chess engines of the day had much of their strength in memorized opening books and knowledge dedicated to known positions, and thus believed a valid anti-computer tactic would be to intentionally play some out-of-book moves in order to force the chess program to think for itself. This seems to have been a dubious assumption even then; Garry Kasparov tried it via using the non-standard Mieses Opening at the 1997 Deep Blue versus Garry Kasparov Game 1 match, but lost. This tactic became even weaker as time passed; the opening books stored in computer databases can be far more extensive than even the best prepared humans, meaning computers will be well-prepared for even rare variations and know the correct play. More generally, the play of engines even in fully unknown situations (as comes up in variants such as Chess960) is still exceptionally strong, so the lack of an opening book isn't even a major disadvantage for tactically sharp chess engines, who can discover strong moves in unfamiliar board variations accurately.

In contemporary engine tournaments, engines are often told to play situations from a variety of openings, including unbalanced ones, to reduce the draw rate and to add more variety to the games.

Computer chess rating lists

CEGT, CSS, SSDF, WBEC, REBEL, FGRL, and IPON maintain rating lists allowing fans to compare the strength of engines. Various versions of Stockfish, Komodo, Leela Chess Zero, and Fat Fritz dominate the rating lists in the early 2020s.

CCRL (Computer Chess Rating Lists) is an organisation that tests computer chess engines' strength by playing the programs against each other. CCRL was founded in 2006 to promote computer-computer competition and tabulate results on a rating list.

The organisation runs three different lists: 40/40 (40 minutes for every 40 moves played), 40/4 (4 minutes for every 40 moves played), and 40/4 FRC (same time control but Chess960). Pondering (or permanent brain) is switched off and timing is adjusted to the AMD64 X2 4600+ (2.4 GHz) CPU by using Crafty 19.17 BH as a benchmark. Generic, neutral opening books are used (as opposed to the engine's own book) up to a limit of 12 moves into the game alongside 4 or 5 man tablebases.

History

Pre-computer age

The idea of creating a chess-playing machine dates back to the eighteenth century. Around 1769, the chess playing automaton called The Turk, created by Hungarian inventor Farkas Kempelen, became famous before being exposed as a hoax. Before the development of digital computing, the only successful implementation of an autonomous chess-playing device was El Ajedrecista (1912), built by the Spanish engineer Leonardo Torres Quevedo. While limited to the king and rook versus king endgame, it has been considered the first decision-making automaton.

Early software age: selective search and Botvinnik

Since then, chess enthusiasts and computer engineers have built, with increasing degrees of seriousness and success, chess-playing machines and computer programs. One of the few chess grandmasters to devote himself seriously to computer chess was former World Chess Champion Mikhail Botvinnik, who wrote several works on the subject. Botvinnik's interest in Computer Chess started in the 50s, favouring chess algorithms based on Shannon's selective type B strategy, as discussed along with Max Euwe 1958 in Dutch Television. Working with relatively primitive hardware available in the Soviet Union in the early 1960s, Botvinnik had no choice but to investigate software move selection techniques; at the time only the most powerful computers could achieve much beyond a three-ply full-width search, and Botvinnik had no such machines. In 1965 Botvinnik was a consultant to the ITEP team in a US-Soviet computer chess match which won a correspondence chess match against the Kotok-McCarthy-Program led by John McCarthy in 1967.(see Kotok-McCarthy). Later he advised the team that created the chess program Kaissa at Moscow's Institute of Control Sciences. Botvinnik had his own ideas to model a Chess Master's Mind. After publishing and discussing his early ideas on attack maps and trajectories at Moscow Central Chess Clubin 1966, he found Vladimir Butenko as supporter and collaborator. Butenko first implemented the 15x15 vector attacks board representation on a M-20 computer, determining trajectories. After Botvinnik introduced the concept of Zones in 1970, Butenko refused further cooperation and began to write his own program, dubbed Eureka. In the 70s and 80s, leading a team around Boris Stilman, Alexander Yudin, Alexander Reznitskiy, Michael Tsfasman and Mikhail Chudakov, Botvinnik worked on his own project 'Pioneer' - which was an Artificial Intelligence-based chess project. In the 90s, Botvinnik already in his 80s, he worked on the new project 'CC Sapiens'.

Later software age: full-width search

One developmental milestone occurred when the team from Northwestern University, which was responsible for the Chess series of programs and won the first three ACM Computer Chess Championships (1970–72), abandoned type B searching in 1973. The resulting program, Chess 4.0, won that year's championship and its successors went on to come in second in both the 1974 ACM Championship and that year's inaugural World Computer Chess Championship, before winning the ACM Championship again in 1975, 1976 and 1977. The type A implementation turned out to be just as fast: in the time it used to take to decide which moves were worthy of being searched, it was possible just to search all of them. In fact, Chess 4.0 set the paradigm that was and still is followed essentially by all modern Chess programs today, and that had been successfully started by the Russian ITEP in 1965.

Rise of chess machines

In 1978, an early rendition of Ken Thompson's hardware chess machine Belle, entered and won the North American Computer Chess Championship over the dominant Northwestern University Chess 4.7.

Microcomputer revolution

Advances in processing power made brute-force search significantly more effective than in the early development of computer chess. As computing capabilities improved, programs that emphasized tactical calculation, supported by limited positional evaluation and pruning techniques, began to compete with top human players. In chess, this approach proved effective by allowing computers to focus on large-scale calculation rather than attempting to model human thought processes. In 1997, IBM's Deep Blue, which could evaluate an estimated 500 million positions per second, defeated reigning World Champion Garry Kasparov in a standard time-control match, marking the first time a computer defeated a sitting world champion under those conditions.

Super-human chess

In 2016, NPR asked experts to characterize the playing style of computer chess engines. Murray Campbell of IBM stated that "Computers don't have any sense of aesthetics... They play what they think is the objectively best move in any position, even if it looks absurd, and they can play any move no matter how ugly it is." Grandmasters Andrew Soltis and Susan Polgar stated that computers are more likely to retreat than humans are.

Neural network revolution

While neural networks have been used in the evaluation functions of chess engines since the late 1980s, with programs such as NeuroChess, Morph, Blondie25, Giraffe, AlphaZero, and MuZero, neural networks did not become widely adopted by chess engines until the arrival of efficiently updatable neural networks in the summer of 2020. Efficiently updatable neural networks were originally developed in computer shogi in 2018 by Yu Nasu, and had to be first ported to a derivative of Stockfish called Stockfish NNUE on 31 May 2020, and integrated into the official Stockfish engine on 6 August 2020, before other chess programmers began to adopt neural networks into their engines.

Some people, such as the Royal Society's Venki Ramakrishnan, believe that AlphaZero led to the widespread adoption of neural networks in chess engines. However, AlphaZero influenced very few engines to begin using neural networks, and those tended to be new experimental engines such as Leela Chess Zero, which began specifically to replicate the AlphaZero paper. The deep neural networks used in AlphaZero's evaluation function required expensive graphics processing units, which were not compatible with existing chess engines. The vast majority of chess engines only use central processing units, and computing and processing information on the GPUs require special libraries in the backend such as Nvidia's CUDA, which none of the engines had access to. Thus the vast majority of chess engines such as Komodo and Stockfish continued to use handcrafted evaluation functions until efficiently updatable neural networks were ported to computer chess from computer shogi in 2020, which did not require either the use of GPUs or libraries like CUDA at all. Even then, the neural networks used in computer chess are fairly shallow, and the deep reinforcement learning methods pioneered by AlphaZero are still extremely rare in computer chess.

Timeline

1769 – Wolfgang von Kempelen builds the Turk. Presented as a chess-playing automaton, it is secretly operated by a human player hidden inside the machine.

1868 – Charles Hooper presents the Ajeeb automaton – which also has a human chess player hidden inside.

1912 – Leonardo Torres Quevedo builds El Ajedrecista, a machine that could play King and Rook versus King endgames.

1941 – Predating comparable work by at least a decade, Konrad Zuse develops computer chess algorithms in his Plankalkül programming formalism. Because of the circumstances of the Second World War, however, they were not published, and did not come to light, until the 1970s.

1948 – Norbert Wiener's book Cybernetics describes how a chess program could be developed using a depth-limited minimax search with an evaluation function.

1950 – Claude Shannon publishes "Programming a Computer for Playing Chess", one of the first papers on the algorithmic methods of computer chess.

1951 – Alan Turing is first to publish a program, developed on paper, that was capable of playing a full game of chess (dubbed Turochamp).

1952 – Dietrich Prinz develops a program that solves chess problems.

1956 – Los Alamos chess is the first program to play a chess-like game, developed by Paul Stein and Mark Wells for the MANIAC I computer.

1956 – John McCarthy invents the alpha–beta search algorithm.

1957 – The first programs that can play a full game of chess are developed, one by Alex Bernstein and one by Russian programmers using a BESM.

Categorizations

Dedicated hardware

These chess playing systems include custom hardware with approx. dates of introduction (excluding dedicated microcomputers):

Belle 1976

Bebe, a strong bit-slice processor 1980

HiTech 1985

ChipTest 1985

Deep Thought 1987

Deep Thought 2 (Deep Blue prototype)~1994

Deep Blue 1996, 1997

Hydra, predecessor was called Brutus 2002

AlphaZero 2017 (used Google's Tensor Processing Units for neural networks, but the hardware is not specific to Chess or games)

MuZero 2019 (similar hardware to its predecessor AlphaZero, non-specific to Chess or e.g. Go), learns the rules of Chess

Commercial dedicated computers

In the late 1970s to early 1990s, there was a competitive market for dedicated chess computers. This market changed in the mid-1990s when computers with dedicated processors could no longer compete with the fast processors in personal computers.

Boris in 1977 and Boris Diplomat in 1979, chess computers including pieces and board, sold by Applied Concepts Inc.

Chess Challenger, a line of chess computers sold by Fidelity Electronics from 1977 to 1992. These models won the first four World Microcomputer Chess Championships.

ChessMachine, an ARM-based dedicated computer, which could run two engines:

"The King", which later became the Chessmaster engine, was also used in the TASC R30 dedicated computer.

Gideon, a version of Rebel, in 1992 became the first microcomputer to win the World Computer Chess Championship.

Excalibur Electronics sells a line of beginner strength units.

Mephisto, a line of chess computers sold by Hegener & Glaser. The units won six consecutive World Microcomputer Chess Championships.

Novag sold a line of tactically strong computers, including the Constellation, Sapphire, and Star Diamond brands.

Phoenix Chess Systems makes limited edition units based around StrongARM and XScale processors running modern engines and emulating classic engines.

Saitek sells mid-range units of intermediate strength. They bought out Hegener & Glaser and its Mephisto brand in 1994.

DOS programs

These programs can be run on MS-DOS, and can be run on 64-bit Windows 10 via emulators such as DOSBox or QEMU:

Chessmaster 2000

Colossus Chess

Fritz 1–3

Kasparov's Gambit

Rebel

Sargon

Socrates II

Notable theorists

Well-known computer chess theorists include:

Georgy Adelson-Velsky, a Soviet and Israeli mathematician and computer scientist

Hans Berliner, American computer scientist and world correspondence chess champion, design supervisor of HiTech (1988)

Mikhail Botvinnik, Soviet electrical engineer and world chess champion, wrote Pioneer

Alexander Brudno, Russian computer scientist, first elaborated the alphabeta pruning algorithm

Feng-hsiung Hsu, the lead developer of Deep Blue (1986–97)

Robert Hyatt developed Cray Blitz and Crafty

Danny Kopec, American Professor of Computer Science and International Chess Master, developed Kopec-Bratko test

Alexander Kronrod, Soviet computer scientist and mathematician

Monroe Newborn, chairman of the computer chess committee for the Association for Computing Machinery

Claude E. Shannon, American computer scientist and mathematician

Alan Turing, English computer scientist and mathematician

Solving chess

The prospects of completely solving chess are generally considered to be rather remote. It is widely conjectured that no computationally inexpensive method to solve chess exists even in the weak sense of determining with certainty the value of the initial position, and hence the idea of solving chess in the stronger sense of obtaining a practically usable description of a strategy for perfect play for either side seems unrealistic today. However, it has not been proven that no computationally cheap way of determining the best move in a chess position exists, nor even that a traditional alpha–beta searcher running on present-day computing hardware could not solve the initial position in an acceptable amount of time. The difficulty in proving the latter lies in the fact that, while the number of board positions that could happen in the course of a chess game is huge (on the order of at least 1043 to 1047), it is hard to rule out with mathematical certainty the possibility that the initial position allows either side to force a mate or a threefold repetition after relatively few moves, in which case the search tree might encompass only a very small subset of the set of possible positions. It has been mathematically proven that generalized chess (chess played with an arbitrarily large number of pieces on an arbitrarily large chessboard) is EXPTIME-complete, meaning that determining the winning side in an arbitrary position of generalized chess provably takes exponential time in the worst case; however, this theoretical result gives no lower bound on the amount of work required to solve ordinary 8x8 chess.

Martin Gardner's Minichess, played on a 5×5 board with approximately 1018 possible board positions, has been solved; its game-theoretic value is 1/2 (i.e. a draw can be forced by either side), and the forcing strategy to achieve that result has been described.

Progress has also been made from the other side: as of 2012, all 7 and fewer pieces (2 kings and up to 5 other pieces) endgames have been solved.

Chess engines

A "chess engine" is software that calculates and orders which moves are the strongest to play in a given position. Engine authors focus on improving the play of their engines, often just importing the engine into a graphical user interface (GUI) developed by someone else. Engines communicate with the GUI by standardized protocols such as the nowadays ubiquitous Universal Chess Interface developed by Stefan Meyer-Kahlen and Franz Huber. There are others, like the Chess Engine Communication Protocol developed by Tim Mann for GNU Chess and Winboard. Chessbase has its own proprietary protocol, and at one time Millennium 2000 had another protocol used for ChessGenius. Engines designed for one operating system and protocol may be ported to other OS's or protocols. Chess engines are regularly matched against each other at dedicated chess engine tournaments.

Chess web apps

In 1997, the Internet Chess Club released its first Java client for playing chess online against other people inside one's webbrowser. This was probably one of the first chess web apps. Free Internet Chess Server followed soon after with a similar client. In 2004, International Correspondence Chess Federation opened up a web server to replace their email-based system. Chess.com started offering Live Chess in 2007. Chessbase/Playchess has long had a downloadable client, and added a web-based client in 2013.

Another popular web app is tactics training. The now defunct Chess Tactics Server opened its site in 2006, followed by Chesstempo the next year, and Chess.com added its Tactics Trainer in 2008. Chessbase added a tactics trainer web app in 2015.

Chessbase took their chess game database online in 1998. Another early chess game databases was Chess Lab, which started in 1999. New In Chess had initially tried to compete with Chessbase by releasing a NICBase program for Windows 3.x, but eventually, decided to give up on software, and instead focus on their online database starting in 2002.

One could play against the engine Shredder online from 2006. In 2015, Chessbase added a play Fritz web app, as well as My Games for storing one's games.

Starting in 2007, Chess.com offered the content of the training program, Chess Mentor, to their customers online. Top GMs such as Sam Shankland and Walter Browne have contributed lessons.

Impact of AI on chess

Revolutionizing chess strategy

The introduction of artificial intelligence transformed the game of chess, particularly at the elite levels. AI greatly influenced defensive strategies. It has the capacity to compute every potential move without concern, unlike human players who are bound to emotional and psychological impacts from factors such as stress or tiredness. As a result, many positions once considered not defensible are now recognized as defensible.

After studying millions of games, chess engines made new analysis and improved the existing theories of opening. These improvements led to the creation of new ideas and changed the way players think throughout all parts of the game. In classical chess, elite players commonly initiate games by making 10 to 15 opening moves that align with established analyses or leading engine recommendations.

Cheating and fair play

Unlike traditional over-the-board tournaments where handheld metal detectors are employed in order to counter players attempts at using electronic assistance, fair-play monitoring in online chess is much more challenging.

During the 2020 European Online Chess Championship, which saw a record participation of nearly 4000 players over 80 participants were disqualified for cheating—most from beginner and youth categories. The event underscored the growing need for advanced detection methods in online competitions.

In response to these issues, chess platforms such as Chess.com developed AI-based statistical models which track improbable moves by a player and compare them to moves that could be made by an engine. Expert examination is conducted for all suspected cases, and the findings are published on a regular basis. FIDE introduced AI behavior-tracking technology to strengthen anti-cheating measures in online events.

AI-based detection systems use a combination of machine learning to track suspicious player actions in different games. This is done by measuring discrepancies between the real moves and the predicted moves derived from the available statistics. Players of unusually high skill level or unusual strategies that can imitate moves characteristic of automated chess systems. Each case is examined by a human expert to ensure that the decision is correct before any actions are made to guarantee fairness and accuracy.

Chess and LLMs

While considered something done more for entertainment than for serious play, people have discovered that large language models (LLMs) of the type created in 2018 and beyond such as GPT-3 can be prompted into producing chess moves given proper language prompts. While inefficient compared to native chess engines, the fact that LLMs can track the board state at all beyond the opening rather than simply recite chess-like phrases in a dreamlike state was considered greatly surprising. LLM play has a number of quirks compared to engine play; for example, engines don't generally "care" how a board state was arrived at. However, LLMs seem to produce different quality moves for a chess position reached via strong play compared to the same board state produced via a set of strange preceding moves (which will generally produce weaker and more random moves).