Raphaël Anjou

Every record board we have is frozen in place. You cannot nudge your way from a great board to a perfect one, and we can prove it.

A safe, portable Rust depth-first backtracker, specialised at runtime by emitting and compiling per-puzzle Rust, taken from 43 to 123 million search-nodes per second on one core. Measured fairly against Peter McGavin's C on the same machine: a tie on hard, deep boards like the real Eternity II, and about 44% of its speed on easy ones. Every rung searches the identical tree; the whole gain is code, not algorithm.

Build a board from nothing, breaking ties by where pieces tend to sit in the strong boards we already have. It reaches a high score with no starting board to copy.

Fifteen solvers, ours and our implementations of the community's two record backtrackers, each run once on ten corner-pinned variants of the official puzzle, single core, 60 seconds per run. The finding: node count is not score.

One constraint-propagation engine, run under a dozen ordering and propagator presets, on the same ten corner-pinned variants as the leaderboard. A study of what each knob buys, kept off the headline board because the best preset reaches less than half a contender's score.

Build a board from scratch, ranking each next piece by three signals learned from past strong boards. Reached 460 in a board family no earlier search had cracked.

A from-scratch reimplementation of Louis Verhaard's eii method, since his own binary ships no source and will not run here. Set-composition swap-annealing under the 2×2-tiling metric; on the real five-clue puzzle it reaches 438 of 480, single core.

A faint compass for a from-scratch search: nudge it to commit the rare pieces early, where they're needed. It doesn't raise the ceiling; it makes the search reliably reach the top of its own range.

Read every strong board to find the habits that quietly hold a board back, then break them. This experiment produced the project's best board: 463 of 480.

Run the same beam search across nine different scan orders, so it lands in different regions instead of always converging to the same one. The zigzag order found a brand-new 458 board.

Rebuild the community's strict 460 boards exactly, and in doing so discover the move ordinary solvers can't make: paying two mismatches at a single cell.

Fix a perfect border, then search the interior with the border's edges treated as hard constraints from the very first cell.

Decide in advance not when a board may break, but where: confine every mismatch to a chosen shape of cells, and search for the best shape.

Throw hundreds of cheap short searches at the board, keep only the deepest starts, and promote the survivors through longer and longer rounds.

Tile the board into small blocks, solve each one to proven optimality, and glue them together, paying for the seams instead of forbidding them. From scratch, with no record to copy, it reaches 448.

Solve a band of rows exactly by meeting in the middle, to find the true best ending and to measure how far ahead an endgame can be decided.

Build the whole board from scratch with no pre-set frame, in stages, letting the border emerge last from whatever pieces are left.

Some Eternity II engines pour their effort into walking the search tree as fast as possible; others spend it on judgement about where to walk. This is the case for the first kind - what raw throughput buys, the three different things people mean by "fast", and why the fastest engine ever built still cannot solve the puzzle.

Every format an Eternity II board or puzzle travels in on this site and in the community: the board_edges letter string and the hints clue list, e2pieces.txt, the puzzle CSV, the site's Puzzle JSON, and the viewer URL, with the exact byte-level rules (how the grey border is encoded in each) and, most of all, what each format can and cannot recover.

Exact counts of how many valid ways a small block can be filled at a given position of the official Eternity II board, under increasingly constrained rules: known-good numbers to check your solver's edge-matching and constraint code against.

The Rust-to-WebAssembly backtracker that runs every live demo and checks every number on this wiki. Not a record machine but a reference engine, ported four times and parity-tested byte-for-byte, built so the claims here can be re-run.

The editorial standard for this open notebook: how a piece of Eternity II research goes from unpublished work to a published page. What kind of contribution it is, whether it publishes, at what tier, and where it lives. One shared standard, built to scale to many authors.

A study in five experiments of one idea: instead of searching Eternity II from first principles, mine the corpus of strong boards already found for structure and feed it back into a search. A position prior, a learned move-vote, a scarce-demand compass, an anti-pattern miner, and a record decode, ordered from the simplest signal to the subtlest, and the one wall all five reach.

The shared engines under Raphaël Anjou's experiments. The named experiments are studies that run on these; this is the apparatus they share. The CSP presets and the Verhaard reimplementation are documented here; the constructive engines are not yet published.

The named search experiments that chase score. Each is a pipeline rather than a single algorithm: it builds a board with one engine, then lifts or finishes it with another. Each records its idea, its best board, and the questions it left open.

The engine behind the DFS study: one composable backtracker where a variant is a declared change over a parent, a shared IO layer every algorithm speaks, and the definitions of every statistic the study raises: node rate, depth, breaks.

The apparatus behind the hint study: a parametric board generator faithful to Eternity II's colour recipe at every size, the family of fill-path backtrackers, the one canonical scorer, and the piece of arithmetic that keeps the count axis meaningful, the pinned-seam floor.

The engine behind the repair study: one composable destroy-and-repair loop where a variant is a declared change over a parent, the shared IO and scorer it sits on with the DFS study, an incrementally-maintained mismatch map, and the definitions of every statistic the study raises.

A notebook of Eternity II search experiments, organised into the shared engines they run on, the combination pipelines that chase the score, three studies that take one search paradigm apart a decision at a time, and exact endgame solves. Each has its idea, its best board, and the questions it left open. The best reaches 463 of 480.

The five comparisons at the heart of the repair study, worked through: blind random destroy wins while every conflict-targeting operator loses; construction sets the floor; simulated annealing is the strongest acceptance rule; and the clever refinements (exact refill, restarts) buy nothing at this budget.

The three comparisons at the heart of the DFS study, worked through: fill order (row-major wins, a bad order is catastrophic), heuristics (MRV rescues border-first but costs throughput; more propagation did not help), and breaks (they smash the depth wall; the break schedule is the lever, not the per-cell cap).

The results, worked through: on these boards the five clue-shaped hints never help a backtracker, they range from a mild cost to a catastrophe, and the fill order decides how much damage they do; the scores are bimodal, not a smooth gradient; and the hint-count question is confounded by a free pinned-seam floor.

One question, asked carefully: among depth-first backtrackers for Eternity II, what does each fill order, each heuristic, and the break mechanism actually buy? A family of from-scratch backtrackers, each one change apart, run on the same ten corner-pinned variants, single core, sixty seconds.

Give a backtracker five correct pieces for free, in the puzzle's own clue geometry. It turns out not to help, and depending on the fill order it can hurt badly, because a pinned piece is a hard constraint a fixed fill order must satisfy on arrival. A family of fill paths, run on the same hinted boards, single core, measured against no hints at all.

The sibling of the DFS study, for the other way people attack Eternity II: destroy part of a board, rebuild it, keep the change if it helps. One question, asked carefully. What does each decision in that loop buy: which region to destroy, how to rebuild it, when to keep a move, when to restart, and what board to start from?

Exact endgame experiments that meet in the middle: enumerate a region from two ends and join on the seam, to find the true best completion with a proof rather than a heuristic's best guess. These measure a small region exactly instead of chasing the whole-board score.