spicysharkco/chess-sim2real-benchmark

Chess sim-to-real benchmark: development and final-test renders

Eight development images of one position group, each cropped around the board. Left to right: elevation bands 08_15, 15_25, 25_45, 45_60. Top row a1_dark, bottom row a1_light. The first three columns use the polyhaven pieces. The last column uses omie (top) and lyricsz (bottom).

The 20,000 images of a controlled benchmark for chess-position recognition, 16,000 for development and 4,000 for the final test, built to answer one question: when a perception model is trained on renders and used on a camera, what does synthetic data buy, and what does it cost?

Paper: What Synthetic Data Buys and Costs: A Sim-to-Real Evaluation Case Study in Chess-Position Recognition (Spicy Shark, 2026; PDF: paper/main.pdf). The generator, the manifests, the freeze receipts, the scoring tools and the licence files are in the GitHub repository spicysharkco/chess-sim2real-benchmark: https://github.com/spicysharkco/chess-sim2real-benchmark

Three things the benchmark found

1. A convention confound was mistaken for a domain shift. The public ChessQueries checkpoint produced zero exact boards on our renders under our original colour convention. Flipping one renderer expression, the light/dark assignment of the a1 square, raised per-square accuracy from 54.4 to 85.2 and removed 67.7% of wrong squares, replicated across six piece families.
2. Synthetic adaptation always cost real-photo accuracy here. Low-rank adaptation on 500 rendered positions lifted the same checkpoint from 15.5 to 64.7 exact on standard-convention renders (dark-only arm), and 8,000 positions to 79.7. Every one of ten adapted checkpoints lost 11 to 23 boards on the 2,129-photo ChessReD set, a retention gate fixed before training. The lowest elevation band reaches only 14.5 exact after the largest both-convention budget.
3. Two evaluation failures we made ourselves, and the checks that caught them. A pipeline selected on a private leaderboard scored below its own single member on 16 of 18 controlled splits. Two sets named as holdouts (1,635 and 1,263 images) shared 1,446 and 1,128 image identifiers with the training mixes: 2,398 distinct identifiers, 2,574 counting both sets. An identifier-level leak check found it.

What is here, and what is not

Here: the 48 render shards of benchmark v2. The 35 development shards hold 16,000 cell-images of 400 position groups. The 13 final-test shards hold 4,000 cell-images of the other 100 position groups. Each image is a 1920 x 1080 PNG. Three reference cells deliberately reuse identical scene configurations, so the 16,000 development images have 14,400 distinct PNG hashes and the 4,000 final-test images have 3,600.

The final test is sealed. The GitHub repository has held its manifest rows (positions, seeds, cameras and image hashes) and its hash list since the release. Its images were added here on 2026-10-23 (UTC). The author has not scored any model on it. "Sealed" names this no-scoring rule, not an access control.

Not here:

• The run receipts each render shard wrote (runtime.json, render_summary.json).
• The adaptation-pool renders. Their rows are benchmark_v2/adaptation.jsonl in the GitHub repository.
• ChessQueries code and weights, and the adapter weights trained in this project. ChessQueries is a third-party work under the PolyForm Noncommercial License 1.0.0 and is not redistributed. The adapter weights derive from its release checkpoint and are withheld.
• Photographs. This dataset holds renders only.

Files

README.md                    this card
samples.jpg                  preview grid of 8 development images, not part of a split
renders/
  <shard>/                   e.g. benchmark_dev_polyhaven_000, benchmark_final_test_omie_000
    images/<id>.png          1920 x 1080 PNG
    labels/<id>.txt          the position as a piece-placement FEN, one line
    corners/<id>.txt         the four projected board corners, one "x,y" line each
    metadata.jsonl           one row per image of the shard

• images/<id>.png is the frozen render. Its SHA-256 is the row's image_sha256 and sha256.
• labels/<id>.txt holds the row's fen.
• corners/<id>.txt holds the row's corners_px in image pixels, written with three decimals, in the row's corner_order (clockwise_from_min_x_plus_y).
• metadata.jsonl holds, for each image of the shard, the row with the same id from benchmark_v2/benchmark.jsonl in the GitHub repository, unchanged, plus one key: file_name, the image path relative to the shard folder (for example images/012656.png).

The dataset holds 60,048 files under renders/, 4,073,095,000 bytes in total: 20,000 images, 20,000 label files, 20,000 corner files and 48 metadata.jsonl files. The 35 development shards hold 48,035 of these files (3,235,187,348 bytes), the 13 final-test shards 12,013 (837,907,652 bytes). Apart from this card, samples.jpg and the hub's .gitattributes, nothing sits outside renders/. samples.jpg is a preview grid of 8 development images. It is not part of a split.

Family	Development shards	Development images	Final-test shards	Final-test images
polyhaven	21	10,400	6	2,600
deplorable, killgorack, lyricsz, nailfighter, omie, phuong, pjhanzlik	2 each	800 each	1 each	200 each
Total	35	16,000	13	4,000

Row fields

Each row has these 43 fields of the manifest, in this order, then file_name: id, view_key, benchmark_schema, experiment, fen, piece_count, game_id, ply, seed, position_group, partition, data_usage, factor_axis, factor_level, factor_cell, factors, parity, camera, piece_geometry, board_palette, piece_palette, piece_color_contract, exclusion_policy, repo_commit, excluded_fen_count, excluded_fen_sha256, image_sha256, source_sha256, renderer, a8_image_corner, a8_corner_index, corners_px, corner_order, corner_surface, projection_bounds_max_abs_error, image, sha256, md5, split, corners, corners_sha256, label, label_sha256.

position_group is the SHA-256 of fen. factor_cell names the cell, for example elevation:08_15. parity is a1_dark or a1_light. split is the shard name, not the Hub split. image, label and corners are paths from the root of this dataset; sha256, label_sha256 and corners_sha256 are the SHA-256 of those three files. Commit identifiers in the rows refer to the author's private development history and do not resolve in the public repository.

The adaptation pool in the GitHub repository, benchmark_v2/adaptation.jsonl, numbers its rows separately, so most id strings here also appear there, for different images. Join this dataset to the GitHub manifests on id within benchmark_v2/benchmark.jsonl only. image_sha256 identifies an image, not a row: the three reference cells share images, so a join on it duplicates rows. No image_sha256 here appears in adaptation.jsonl.

Values withheld in the GitHub package are withheld here in the same way. In every row, excluded_fen_sha256 and the source_sha256 entries of render_batch.mjs and of the shard manifest read [redacted: withheld digest]. The GitHub README explains why, and its PACKAGE_INTEGRITY.json binds the shipped manifest.

Loading

The configs block in this card points the loader and the Hub viewer at the PNGs and the metadata.jsonl files.

The block has two configurations. default reads the development shards as the split validation; load_dataset("spicysharkco/chess-sim2real-benchmark") returns that split only. final_test reads the final-test shards as the split test: load_dataset("spicysharkco/chess-sim2real-benchmark", "final_test").

The Hugging Face datasets image-folder loader (tested with version 5.1.0 on a local copy of two development shards and all 13 final-test shards) reads each configuration as one split. It decodes file_name into an image column, which takes the place of the row's image path. It also takes the keys of nested fields from one metadata file. The keys of source_sha256 differ between shards: each row names its shard manifest, and some source files differ between piece families. The loaded source_sha256 field therefore keeps the keys of one shard only. For exact rows, read metadata.jsonl directly. The two partitions are separate configurations for a related reason: within one configuration the loader compares the first metadata file of each split and stops with an error when their keys differ. A development row and a final-test row always differ there, because source_sha256 names each row's own shard manifest.

Factor design

The benchmark varies four elevation bands, eight piece geometries, six non-reference material schemes, two framing ranges, and two board conventions. These settings form factor panels rather than a full Cartesian product: each non-reference level is paired with the appropriate reference scene, and every scene has both convention mates. A palette treatment is a supplied material scheme: it changes board and piece colours and may also change roughness and metalness. It is not an RGB-only intervention. The reference uses the highest elevation band, Poly Haven geometry, standard framing, and the separate reference material scheme. These are contrasts conditional on the reference settings; the design does not estimate all factor interactions.

Factor	Levels	Values
Elevation	4	08_15, 15_25, 25_45, 45_60
Geometry	8	deplorable, killgorack, lyricsz, nailfighter, omie, phuong, pjhanzlik, polyhaven
Palette	6	aubergine_periwinkle, cobalt_porcelain, indigo_lavender, navy_coolrose, plum_mintgreen, wine_iceblue
Framing	2	compact, standard
Convention	2	a1 dark, a1 light

The reference condition makes a1 dark; its paired stress condition makes a1 light while retaining the position, camera, geometry, palette, and framing. This intervention changes the physical checkerboard colours, not the label order or the image orientation.

The manifest stores the position in Forsyth-Edwards Notation, the camera state, the factor assignment, and the projected board corners. Labels therefore come from the scene description rather than from a detector or a recognizer. The labels describe the latent scene state; they do not certify that every occupied square is visually identifiable in a single image under occlusion.

Splits

The design contains 500 independently sampled position groups. A fixed split assigns 400 groups to development and 100 to the sealed final test, with every view of a group kept in the same partition. Applying the 20 factor cells at both conventions yields 20,000 cell-images: 16,000 development images and 4,000 final-test images. Three reference cells deliberately reuse identical scene configurations, so the benchmark contains 18,000 unique PNG hashes. Neither cell-images nor repeated render hashes are independent board samples; the independent sampling unit remains the position group.

Partition	Position groups	Cell-images	Cells (factor cell x convention)	Images per cell	Configuration and split here
dev	400	16,000	40	400	default, validation
final_test	100	4,000	40	100	final_test, test
Total	500	20,000

How to evaluate

Develop on the development partition, the validation split here. The scorer is tools/paper/score_benchmark.py in the GitHub repository. The development-only loader is load_dev in tools/paper/benchmark_v2.py; it has no final-test override.

Use the final test, the configuration final_test and its split test here, only after the model and every evaluation choice are fixed on development data, and report its score apart from development scores. Its labels are the rows' fen values and the labels/<id>.txt files.

The primary benchmark results report exact-board and per-square class accuracy. Exact-board accuracy requires every square label to match the target placement. Pooled benchmark scores give equal weight to the registered cells, including the repeated reference cells, rather than to distinct image hashes. Bootstrap comparisons resample position groups with all their views together; the fixed synthetic population and protocol still limit generalization.

The GitHub README records a CPU procedure that re-renders four frozen development views through the packaged generator, compares their PNG hashes to the freeze and scores the public checkpoint. The recorded exact-image check uses Linux x86-64, Node 24.15.0, Playwright 1.61.0 and its Chromium 149.0.7827.55, CPU SwiftShader, and the packaged Three.js r128.

Check the final-test images against the final-test hash list before scoring them: the final_test_image_hashes field of benchmark_v2/benchmark.complete.json in the GitHub repository (4,000 entries, each an id, an image path and a SHA-256). All 4,000 images here matched it before upload.

Provenance and disjointness

Each group contributes one position from a separately simulated legal random-play game. The generator deliberately mixes dense and sparse positions and biases move selection toward captures. It is not a sample of human game frequencies.

Candidate positions were rejected on exact placement and under the eight dihedral board symmetries against 67 inventoried sources. The exclusion basis contains 6,199,823 distinct placements and includes the 6,100,960-row Lichess puzzle snapshot, prior render cohorts, training pools, and the named public datasets. The benchmark and the separate adaptation pool are mutually exact- and symmetry-disjoint. The audit treats material-only similarity as a descriptive statistic, not as positional leakage. These checks concern canonical piece placement against the supplied inventory. They do not establish coverage of every public dataset, unknown foundation-model pretraining, or the complete historical training lineage. Exact and symmetry checks do not exclude near-duplicate positions or shared opening structure.

Licences

The rendered images and the metadata in this dataset: CC BY-NC 4.0, with the evaluation permission below. In the GitHub repository: generator and renderers under PolyForm Noncommercial 1.0.0 (commercial licence and custom rendered datasets on request: spicysharkco@gmail.com); scoring and diagnostic tools under Apache-2.0; the benchmark data in benchmark_v2/ (manifests, design and freeze records, hash lists) under CC BY-NC 4.0 with the same permission; other receipts, documentation and paper under CC BY-NC 4.0. Piece assets keep their creators' terms; see LICENSE.md and docs/records/BENCHMARK_ATTRIBUTIONS_2026-09-10.md there.

Evaluation permission: in addition to the rights that CC BY-NC 4.0 grants, the copyright holder permits anyone, commercial organisations included, to use these images and metadata to evaluate a model's performance on the benchmark, and to publish the resulting scores, tables and figures in any medium, commercial ones included, with the credit line below. Figures under this permission must not contain benchmark images. This permission does not cover training or fine-tuning a model on the images or metadata, redistributing them, or including them in a product or service. It does not extend the licence of the render generator: rendering the final test yourself is noncommercial use only. Noncommercial uses remain under CC BY-NC 4.0. For commercial uses beyond this permission, contact spicysharkco@gmail.com. The full text is in LICENSE.md in the GitHub repository.

Asset family	Recorded licence	Release qualification	Creator and source
polyhaven	CC0	grant recorded	Riley Queen, https://polyhaven.com/a/chess_set
deplorable	CC0 1.0 Universal	grant recorded	Deplorable Mountaineer, https://deplorablemountaineer.itch.io/chess-board-and-pieces
killgorack	CC0	grant recorded	KillGorack, https://opengameart.org/content/chess-board-pieces
lyricsz	CC0	grant recorded	Lyricsz, https://opengameart.org/content/stylized-chess-pieces
omie	CC0	grant recorded	Omie's Assets, https://omies-assets.itch.io/3d-chesscheckers-set
phuong	CC-BY; credit Phuong2647	credited under CC BY 4.0	Phuong2647, https://blendswap.com/blend/29244
pjhanzlik	CC0	grant recorded	pjhanzlik, https://opengameart.org/content/chess
nailfighter	CC0	grant recorded	Nailfighter, https://nailfighter.itch.io/lowpoly-chess-set

For the benchmark data, cite the paper and credit: "Chess-position recognition benchmark v2 by Spicy Shark, licensed under CC BY-NC 4.0." Images of the phuong piece family must also credit the asset's creator: "Chess set by Phuong2647 (https://blendswap.com/blend/29244), CC-BY". The source page declares CC-BY without a version; this release credits that asset under the CC BY 4.0 attribution terms. The images themselves are CC BY-NC 4.0, like every other image here. Copyright 2026 Spicy Shark.

Citation

@misc{spicyshark2026synthetic,
  title  = {What Synthetic Data Buys and Costs: A Sim-to-Real Evaluation Case Study in Chess-Position Recognition},
  author = {{Spicy Shark}},
  year   = {2026},
  howpublished = {\url{https://github.com/spicysharkco/chess-sim2real-benchmark/blob/main/paper/main.pdf}}
}