Artificial intelligence has transformed the game of chess. This blog explores the current landscape of chess AI, providing insights into building a basic chess AI from scratch and demonstrating how to leverage existing powerful AI engines through free APIs and libraries.

Building a Simple Chess AI from Scratch (Step by Step)

With all this talk of super-engines, you might wonder: how do chess AIs actually work? This section will guide you through creating a very basic chess-playing program. While it won’t rival Stockfish, it’s a fun exercise to learn the fundamentals of chess AI.

Key concepts we’ll need to implement:

• ● Board Representation and Move Generation : This involves representing the chess board and generating all legal moves from a given position. A convenient library for this is python-chess. If implementing from scratch, you’d likely use an 8x8 array or other encoding and write functions for how each piece moves, handle special rules like castling, promotion, etc. Using a library can save a lot of time and avoid rule bugs.

• ● Position Evaluation: This is a function that takes a board position and returns a score estimating how favorable it is for the player. A basic approach—going back to Alan Turing’s 1940s design - is to assign a value to each piece and sum up material. For example, many programs use pawn = 1, knight = 3, bishop = 3, rook = 5, queen = 9 (relative value). The king is often given an arbitrarily large value (like 1000) just to ensure it’s never “sacrificed” in evaluation. We can start with material count as our evaluation. More advanced evaluations add factors like piece square tables (bonus for centralizing pieces, etc.), king safety, pawn structure, mobility, etc., but simple material count is okay for a start.

• ● Minimax Search: This is the algorithm that explores moves to determine the best one. In chess, you and your opponent alternate moves; minimax assumes both sides play optimally (your opponent will try to minimize your advantage). A basic minimax algorithm will recursively simulate moves: at your turn, it picks the move that leads to the maximum score (assuming the opponent then tries to minimize it on their turn). This forms a game tree of possible move sequences. We limit the search to a certain depth (number of plies, or half-moves, ahead) because the tree grows exponentially. At the leaves of this tree (or when depth=0), we evaluate the position with our evaluation function. Then we propagate those scores back up the tree: at opponent nodes we take the minimum child score (assuming the opponent will choose the move worst for us), at our nodes we take the maximum (our best move). This way, by looking ahead a few moves, the AI can plan tactics like “if I go here, they’ll respond with that, then I can do this…”.

• ● Alpha-Beta Pruning (Optimization): One improvement to minimax is alpha-beta pruning, which cuts off branches that cannot possibly influence the final decision. In short, if you find a really good move for yourself, any opponent response that is worse for them than a move you already saw can be pruned (because the opponent would never choose a clearly inferior option). Similarly, if it’s the opponent’s turn and you found a move that’s really bad for you, you can prune other moves of yours that would lead to an even worse outcome. Alpha-beta allows the search to go deeper without exploring every single possibility, dramatically speeding up the algorithm without changing the result. We won’t delve into its code here, but know that all serious engines use it (or similar enhancements).

Here’s a basic Python example using python-chess for convenience in move generation. We’ll implement a simple evaluation and a minimax search.

Python

import chess # pip install chess

# Simple material evaluation: returns a score from White's perspective
piece_values = {chess.PAWN: 1, chess.KNIGHT: 3, chess.BISHOP: 3,
                chess.ROOK: 5, chess.QUEEN: 9, chess.KING: 0}

def evaluate_board(board: chess.Board) -> int:
    if board.is_checkmate():
        # If it's checkmate, return a large positive or negative value
        return 9999 if board.turn == chess.BLACK else -9999
    # Sum up piece values (White positive, Black negative)
    score = 0
    for piece in board.piece_map().values():
        value = piece_values[piece.piece_type]
        score += value if piece.color == chess.WHITE else -value
    return score

# Minimax search (without alpha-beta) to a fixed depth
def minimax(board: chess.Board, depth: int, maximize: bool) -> int:
    if depth == 0 or board.is_game_over():
        return evaluate_board(board)

    if maximize:
        max_eval = -99999
        for move in board.legal_moves:
            board.push(move)
            eval = minimax(board, depth-1, maximize=False)
            board.pop()
            if eval > max_eval:
                max_eval = eval
        return max_eval
    else:
        min_eval = 99999
        for move in board.legal_moves:
            board.push(move)
            eval = minimax(board, depth-1, maximize=True)
            board.pop()
            if eval < min_eval:
                min_eval = eval
        return min_eval

# Function to choose the best move for the current player using minimax
def choose_best_move(board: chess.Board, depth: int) -> chess.Move:
    best_move = None
    if board.turn == chess.WHITE:
        best_value = -99999
        for move in board.legal_moves:
            board.push(move)
            move_val = minimax(board, depth-1, maximize=False)
            board.pop()
            if move_val > best_value:
                best_value = move_val
                best_move = move
    else:
        best_value = 99999
        for move in board.legal_moves:
            board.push(move)
            move_val = minimax(board, depth-1, maximize=True)
            board.pop()
            if move_val < best_value:
                best_value = move_val
                best_move = move
    return best_move

The _minimax_ function takes a board, a depth, and a _maximize_ boolean (True when simulating our turn to maximize score, and False when simulating the opponent). We also handle checkmate as a terminal condition with a large score. You can then call choose_best_move(board, depth=3) to get a move suggestion. It will capture hanging pieces and make simple plans like mating in one if it sees it. If you limit the board

to a few pieces (say endgame scenarios), it will perform better, as there are fewer moves to consider.

This exercise is valuable because it mirrors how classic engines work internally, just without all the optimizations. In fact, a well-known tutorial by programmer Lauri Hartikka walks through building such a chess AI step-by-step - covering move generation, minimax, alpha-beta pruning, and even some positional heuristics. There’s also Sunfish, a remarkable open-source chess engine in Python that fits in just 111 lines of code, yet plays a decent game by using similar techniques (with some clever tweaks). These resources are great if you want to dive deeper into engine programming and experiment with your own chess AI.

Using Powerful Chess Engines via APIs and Libraries

Building from scratch is educational, but if your goal is to play or utilize top-tier chess AI, you don’t need to reinvent the wheel. As we discussed, engines like Stockfish are freely available - and so powerful that it makes more sense to integrate them into your projects than to code your own from the ground up.

The _python-chess_ library provides a convenient way to interface with UCI (Universal Chess Interface) engines like Stockfish. Here’s how you could use it:

Python

import chess, chess.engine

engine = chess.engine.SimpleEngine.popen_uci("/usr/bin/stockfish") # path to your Stockfish binary
board = chess.Board() # starting position
result = engine.play(board, chess.engine.Limit(time=2.0))
print(result.move) # engine’s chosen move after 2 seconds of analysis
engine.quit()

This would launch Stockfish and ask it for the best move in the current position (here the starting position) within a 2-second time limit. Under the hood, the engine is examining thousands of moves and returning a suggestion. Using _engine.analyse(board, Limit(depth=15)) _ you can also get evaluation scores.

For even simpler use, there’s a dedicated Python library for _stockfish_ that wraps the engine and provides a simple interface. Here’s how you could use it:

Python

from stockfish import Stockfish

stockfish = Stockfish() # initialize (uses default bundled engine or specify path)
stockfish.set_position(["e2e4", "e7e5", "g1f3"]) # play some moves
best_move = stockfish.get_best_move()
print("Stockfish recommends:", best_move)

This will output something like “Stockfish recommends: g1f3” (just an example) as the best move in the given position. You can even adjust the engine’s skill level or get multi-line analysis. The key point is that with just a few lines of code, you are leveraging an engine that evaluates millions of positions - a huge win for developers who want to add chess AI to an app or analyze games automatically.

If you prefer not to run an engine locally, you can use free online engine APIs. For instance, the Chess.com API and Lichess API both allow you to fetch engine analysis of games or positions. One particularly neat service is the Chess API (chess-api.com), which provides a simple REST endpoint and even WebSocket streaming for Stockfish 17 analysis. You send it a board position (in FEN or PGN format), and it returns the engine’s evaluations and best moves - essentially “Stockfish in the cloud”. This is great for web developers who want to include analysis on a site without dealing with engine executables. The responses from such an API include details like the best move, the score in centipawns, mate-in-X if applicable, and even the win probability percentage. For example, a single API call can tell you that in a given position the best move is _b2b4_

with evaluation +1.35 (meaning White is ahead by 1.35 pawns) and no forced mate detected. Many community projects use these free resources to create training tools, analyze user games, or even build chess bots.

Finally, it’s worth noting that beyond Stockfish, other engines (Leela Chess Zero, etc.) are also available for integration. Leela, for instance, requires a neural network file and uses a lot of GPU resources for strength, so it’s a bit more involved to set up - but it can also be run via similar interfaces. Most engines support the UCI protocol, so swapping one engine for another in your code is usually just a matter of pointing to a different executable.

Putting Theory into Practice: Our Internal Chess AI Experiment

To celebrate International Chess Day, we at Random Walk organized an internal chess tournament - but with a twist. Alongside the over-the-board matches, we experimented with our own simple chess AI, built using the same principles described above. Using python-chess and a lightweight minimax implementation, we created a bot that could analyze game positions and offer move suggestions in real time. While it wasn’t quite Stockfish, it impressed us with its ability to find tactics, avoid blunders, and even hold its own in casual games.

This hands-on experience not only enriched the event but also reinforced the power of combining learning with play. It showed our team how even a basic AI engine can be demystified and made functional - and how integrating such tools in everyday settings can spark both fun and insight. For anyone curious about chess AI, there's no better way to learn than building and using one yourself - even in friendly competition.

Conclusion

The journey of AI in chess is a fascinating story of human ingenuity. From Turing’s early ideas in 1951 to the dominance of Stockfish and Leela today, AI has not only surpassed human play but also deepened our understanding of the game. Engines have become our tutors, training partners, and competitive benchmarks. And as we discovered firsthand during our internal chess event at Random Walk, even a basic homegrown engine - built with simple tools and ideas - can offer surprising insight and engagement.

Chess remains as rich and intriguing as ever, arguably even more so in the age of AI. For developers, hobbyists, or curious minds, building your own engine or integrating a powerful one like Stockfish isn’t just educational; it’s empowering. Whether you’re creating puzzle solvers, game analyzers, or simply enjoying friendly matches, chess AI offers an exciting way to learn, explore, and contribute.

As AI continues to evolve with neural networks, reinforcement learning, and even quantum computing on the horizon, chess will remain a proving ground for innovation. Like Garry Kasparov, we may find that these engines don’t overshadow us, but instead challenge us to think deeper, play smarter, and appreciate the beauty of the game more fully.