Morozov Balance Index (MBI): methodology

What the index measures

In chess, White moves first. That first move is worth something, and in Chess960 it is worth a different amount in each of the 960 starting setups. The index measures the SIZE of that opening edge — not who is better. In 956 of the 960 positions the engine puts the start at equality or in White's favour; the other four land 2 to 7 centipawns on Black's side, which is less than the search moves between its own iterations — noise around zero, not an advantage for Black. The measure is the distance from zero whichever way it points, so the honest phrasing is "how large is the head start here", and a balanced position is one where that head start is as small as it gets.

MBI is a 0–100 scale. 100 means the smallest measured White edge among all 960 positions — the most balanced start. 0 means the largest measured edge. The index is a rank-based transform of one measured quantity (see below), so it says how a position compares with the other 959, not how many pawns anybody is up.

How each position is evaluated

Every starting position is analysed once by Stockfish from the initial setup, with a fixed budget of search NODES rather than a fixed amount of time. This is the key decision of the whole method: a node budget is machine-independent. A time budget would give a fast computer a deeper search and therefore a different number, and nobody could check the result.

• Engine: Stockfish 17.1, official build, NNUE evaluation embedded in the binary.
• Binary SHA-256: 5f95eaea0d4eb697381989187ce6eb4d6ad59283c34421765ecc73cdb09ba766
• NNUE networks: nn-1c0000000000.nnue, nn-37f18f62d772.nnue
• Search limit: 400 000 000 nodes per position (`go nodes`).
• UCI options: Threads = 1, Hash = 256 MB, UCI_Chess960 = true.
• `ucinewgame` before every position: the hash table is cleared, so positions do not influence each other and the order of computation does not matter.
• The score is always taken from White's point of view, in centipawns (100 cp = one pawn).
• The value and the variation are taken from the last COMPLETED search iteration — a line carrying neither a lower nor an upper bound. An iteration cut short by the node limit reports a bound, not a settled evaluation, and its variation is one or two moves long; using it would publish noise as a result.

Single-threaded search with a fixed hash and a fixed node count is deterministic: the same binary on any machine returns the same centipawn value, bit for bit. That is what makes an independent check possible rather than merely plausible.

From centipawns to the index

Centipawns are not a linear measure of anything human, and the difference between +18 and +22 is not meaningful on its own. The index therefore uses the RANK of a position among all 960, not the raw number:

rank(sp) = position of eval_cp(sp) in the sorted list of all 960 values
          (ascending: smallest White edge first, ties share the mean rank)
MBI(sp)  = round( 100 * (960 - rank(sp)) / (960 - 1) )

Across all 960 positions the engine value runs from +-7 to +83 centipawns, median +26.0.

Validation

An engine evaluation is a claim about a position. To check that the claim predicts actual results, a subset of positions is played out: engine against engine, many games per position, with the seeds fixed and published. If positions the index calls balanced really do score closer to 50% for White, the index measures what it says it measures.

• 60 positions × 50 games = 3000 games, time control 300,000 nodes/move.
• Spearman correlation between the starting evaluation and White’s score: 0.76 (95% CI 0.63…0.85, 10000 bootstrap resamples). MBI is a monotone transform of that evaluation, so the same number describes it.
• Verdict: validated — the ranking predicts self-play results, and the index is published as measured.

Seed base: 20260825. Every game can be replayed exactly.

Limitations — read this before quoting the numbers

• An engine evaluation is not human practice. A position an engine calls balanced can still be uncomfortable, sharp or unfamiliar for a human, and that is not measured here.
• One engine, one evaluation function. A different engine would produce a slightly different ordering. The method is fixed and published so that anyone can repeat it with another engine and compare.
• A fixed node budget is a snapshot at one search depth. Deeper analysis moves individual values; the ranking is far more stable than any single number, which is why the index is rank-based.
• Chess960 has almost no opening theory. In classical chess White's edge is partly a library of prepared lines; here it is only what the pieces do. That makes the measurement cleaner, but it also means these numbers say nothing about the classical start.
• Self-play at a fast time control is a cheap approximation of "real play". It validates the ordering, it does not certify any single position.
• The index is a property of the STARTING position only. It says nothing about who is better after one move.

Reproduce it yourself

Everything needed to recompute the dataset is public: the exact engine build, the budget, the scripts and the raw output. Recomputing one position takes a few minutes on a single core; the whole set is an overnight run.

1. Download the raw data and the scripts from the open-data page. Open data
2. Check one position against the published dataset — this recomputes it from scratch and compares:

   python tools/balance/verify_reproduce.py --sp 518

3. Or recompute the entire set (resumable; it appends to the same file if interrupted):

   python tools/balance/eval_all.py --nodes 400000000 --workers 20

If your value differs, the difference is the finding — the engine build, the node budget or the options will not match. All three are printed above.

Citation and licence

The methodology and the dataset are published under CC BY 4.0: use them for anything, including commercially, with attribution.

Morozov R. Chess960 Balance Index (MBI). ch960.com/balance, 2026. CC BY 4.0.

Balance of all 960 positions · Dataset and raw engine output