When Stockfish reports +1.35 at depth 22, two very different pieces of machinery produced that number. One is a search that examines millions of positions and decides which deserve a closer look. The other is an evaluation function that scores a single position without looking ahead at all. Knowing how they fit together explains why the score drifts as you wait, why a sacrifice looks terrible and then brilliant, and why the eval bar can be confidently wrong in a few position types.
Search: deciding what to look at
A typical position has around 35 legal moves, so examining every line to depth 20 is out of the question. Stockfish gets around this with alpha-beta search: once it has found one good reply to a move, it can stop examining other replies to that move, because the opponent already has something good enough. With good move ordering this roughly doubles the depth reachable for the same effort, so move ordering gets enormous care: captures, killer moves and hash-table moves are tried first.
On top of alpha-beta sits a stack of pruning and reduction techniques. Null-move pruning asks "if I passed and the opponent still could not hurt me, this position is fine". Late move reductions search moves at the bottom of the ordering list at reduced depth. Extensions go the other way: checks and some forcing recaptures are searched deeper because they are exactly where tactics hide. At the end of every line a quiescence search resolves captures until the position is quiet, so the engine never stops halfway through an exchange and concludes a queen is hanging.
The search runs as iterative deepening: depth 1, then 2, then 3, each iteration reusing the previous one's best move for ordering. That is why the engine can be stopped at any moment with an answer ready, and why the number keeps updating.
What "depth 20" actually means
Depth is the nominal number of plies (half-moves) searched along the main line before the quiescence search takes over. It is not the depth of every line: a move judged unpromising at move three may have been searched six plies deep, while the main line, with extensions, may have been followed thirty. Stockfish reports this second figure as selective depth.
Depth measures effort, not certainty. For a club game, depth 18 to 22 finds every tactical error and nearly every positional one; going to depth 32 takes many times longer and mostly refines the second decimal. The exception is a position where the evaluation is still moving as depth increases: let it run.
Evaluation: NNUE
At the leaves of the search, each position needs a score. Until 2020 Stockfish computed this with a hand-written function: material, piece-square tables, pawn structure, king safety, mobility. In August 2020, Stockfish 12 introduced NNUE, an "efficiently updatable neural network", a technique that originated in computer shogi. The network takes the positions of the pieces relative to each king as input and outputs a score. The "efficiently updatable" part is the trick that makes it fast: when one piece moves, only a small part of the first layer changes, so the network can be updated incrementally millions of times per second rather than recomputed from scratch.
It was so much stronger that the classical function was first kept as a fallback and then removed entirely in Stockfish 16. Current versions ship two networks, a large one used in most positions and a small one used when the material balance is lopsided. The "lite" build of Stockfish 19 that runs in your browser on Chessblood embeds a smaller network than the desktop version. It is weaker than the full engine, though still far stronger than any human, and it downloads in a couple of megabytes rather than close to a hundred.
Centipawns: why +1.00 is not "one pawn"
Engine scores are given in centipawns, hundredths of a pawn, and for decades +1.00 meant roughly "a pawn up". That is no longer literally true. Since Stockfish 15.1, released at the end of 2022, the output is normalized so that an evaluation of +1.00 corresponds to a 50% chance of White winning the game (as opposed to drawing or losing) in the engine's own self-play at a fixed depth. The scale stays close to the old intuition, but the definition is now statistical rather than material.
Chessblood converts scores to win probability for move grading and accuracy using a separate fitted curve, described in what chess accuracy is. Both say the same thing: +1.00 is a healthy edge, +3.00 is close to winning, and beyond about +8.00 the number has stopped meaning anything except "won".
Mate scores
When the search finds a forced checkmate, the centipawn score is replaced by a mate score. M3 means White can force mate in three moves against any defense. -M5 means Black mates in five. Mate is counted in moves, not plies: M3 means White moves three times. A shorter mate outranks a longer one, and any mate outranks any centipawn score, which is why the eval bar jumps to the edge the moment a mate is found.
MultiPV: seeing more than one line
By default an engine shows only its best line (the principal variation). MultiPV asks it to report the best two, three or more moves with a separate evaluation for each. It answers the question a single line cannot: is there one move here, or several? If the top two lines are within a tenth of a pawn, the position is forgiving. If the gap is a full pawn, you were in an only-move situation, which is what the "great" label in a Chessblood review looks for. The cost is speed: with three lines the engine splits its effort three ways, so reaching the same depth takes longer. Chessblood's Stockfish analysis page lets you set MultiPV from one to five.
Why the engine changes its mind
The score drifts with depth for a structural reason: the engine cannot see past its search horizon. A sacrifice that leads to mate in twelve looks like losing a piece at depth 8, dubious at depth 14, and winning at depth 20, when the follow-up finally comes into view. Pruning also means a quiet but strong move can be reduced at low depth and only properly examined later. The number at depth 10 is a guess and the number at depth 25 is a judgment, so before drawing a conclusion about your own move, give the engine time at that position.
Running in a browser
On Chessblood the engine is compiled to WebAssembly and runs in a web worker. Nothing about your game leaves your machine. Hash is the size of the transposition table, where evaluated positions are stored; more helps in long sessions. Threads lets the engine search in parallel on several CPU cores. Multi-threaded WebAssembly requires SharedArrayBuffer, which browsers only enable when the page is served with cross-origin isolation headers. Chessblood sets those headers on its engine pages and falls back to a single-threaded build where the browser does not allow it. A browser engine searches fewer positions per second than a native one, but at depth 20 the verdicts are the same.
Where the engine is still blind
FEN
7k/8/5K1P/8/8/3B4/8/8 w - - 0 1The position above is a dead draw: the bishop does not control h8, the queening square, so Black's king sits in the corner and any attempt to force matters ends in stalemate. The lite network in your browser gives White about +1.0 here even at depth 30. An engine with endgame tablebases knows the result exactly, but the example shows the general weakness: fortresses, positions where one side has more material and no way to use it, are evaluated by static features that reward the material.
Other limits follow from the same structure. The horizon effect means a loss that is 40 plies away is invisible until it is not. The fifty-move rule and repetition are handled in the search, but a fifty-move draw that is forty moves away is invisible. And very closed positions, where nothing happens for thirty moves, give the search little to bite on, so the score can sit at +0.4 while a human sees that the position is a locked draw.
To watch the machinery work, paste a position into the position analysis tool, set MultiPV to three, and watch the lines reorder as the depth climbs. For the bigger picture of what a chess engine is and is not, see Chess AI.