Watch a Game AI Think: Minimax and Alpha-Beta, Live
Our Tic-Tac-Toe, Connect 4, Checkers, Othello and Chess opponents all run the same idea: search the game tree, assume the opponent plays their best, and pick the move with the best guaranteed outcome. That idea is minimax, and alpha-beta pruning is what makes it fast. Below you can step through both on a real board and watch the second one skip work the first one wastes.
Squares are positions; the top square is the AI to move (a MAX layer), the next is your reply (a MIN layer), and so on. Leaves score +1 (AI wins), −1 (you win) or 0 (draw). Step to watch each layer take the best (max) or worst-for-the-AI (min) of its children. Turn on alpha-beta and the grayed branches are the ones it proves it can skip — same move, fewer nodes.
The whole algorithm, in two functions
Minimax is the tree walk you just watched. Alpha-beta is the same walk plus two
running bounds — alpha (the best MAX can already guarantee) and
beta (the best MIN can already guarantee) — that let it stop exploring a
branch the moment it cannot change the decision.
function minimax(node, isMax):
if node is terminal:
return score(node) # +1 / -1 / 0
if isMax:
best = -inf
for child in node.moves: # AI's turn
best = max(best, minimax(child, false))
return best
else:
best = +inf
for child in node.moves: # your turn
best = min(best, minimax(child, true))
return bestfunction ab(node, alpha, beta, isMax):
if node is terminal:
return score(node)
if isMax:
best = -inf
for child in node.moves:
best = max(best, ab(child, alpha, beta, false))
alpha = max(alpha, best)
if beta <= alpha: break # prune rest
return best
else:
best = +inf
for child in node.moves:
best = min(best, ab(child, alpha, beta, true))
beta = min(beta, best)
if beta <= alpha: break # prune rest
return bestSame answer, provably — pruning never changes the value at the root, only how many nodes you touch to find it. On full-depth Tic-Tac-Toe that's a 93% cut (549,945 → 36,528 nodes, ~0.3 ms).
Why "just search deeper" gets expensive fast
A search that looks d moves ahead visits roughly bd
nodes, where b is the branching factor — how many moves you typically have.
Drag the depth and switch games to feel it. (Branching factors are approximate
published averages, for illustration.)
That growth is exactly why alpha-beta and the tricks in our real engines matter — and why a deeper search is not always a better one: a shallow tic-tac-toe search still lost 2 of 200 games.
The same idea, five different games
Every opponent on the site is this algorithm with a different board, a different way of scoring a position, and different tricks to search deeper without searching everything.
| Game | Board | Branching (approx.) | How it scores a position | Search tricks | |
|---|---|---|---|---|---|
| Tic-Tac-Toe | 3×3 | ≤ 9 (~4) | Win / lose / draw — solved exactly at full depth | Minimax + alpha-beta, full depth on 3×3 | Play → |
| Connect 4 | 7×6 | ≤ 7 (~4) | Threats, central control, connected pieces | Bitboard negamax + alpha-beta + transposition table + iterative deepening | Play → |
| Checkers | 8×8 | ~2.8 | Material, kings, position | Iterative-deepening negamax + alpha-beta + capture quiescence | Play → |
| Othello | 8×8 | ~10 | Corners, mobility, positional square weights | Iterative-deepening negamax + alpha-beta + exact endgame solve | Play → |
| Chess | 8×8 | ~35 | Material, king safety, pawn structure, open files | Negamax + alpha-beta + null-move + quiescence + check extensions + move ordering | Play → |
Read the actual code
The pseudocode above is the shape; here is a real, unminified engine that runs one of these opponents in your browser — iterative-deepening negamax with alpha-beta pruning and capture-aware quiescence, about 230 lines of vanilla JavaScript: the LK Forge checkers engine on GitHub Gist.
And you don't have to take the node counts on faith. This
self-contained script
runs plain minimax and alpha-beta over the exact Tic-Tac-Toe position above and prints the
counts — 14 nodes down to 10 with pruning — with no
dependencies: node reproduce-minimax.mjs.
Read the rest of the cluster
- Six Games, Three Classic Algorithms — the measured strength numbers and the 93% node cut from pruning.
- Benchmarking Game AI — why "it's minimax, so it's unbeatable" is only true at one depth.
- Real Game AI, Not a Chatbot — why these run on search, not a language model.
- How the Tic-Tac-Toe AI Thinks — the same ideas in prose.