The Same 2048 AI Gets Stronger on Bigger Boards

The 2048 game comes in several board sizes — the classic 5×5, 6×6 and 8×8 — and every one of them is driven by the same AI. All the sizes load one shared solver-core.js and call the identical expectimax search with a corner-snake heuristic; only the board dimension changes. That makes an easy experiment: hold the engine fixed, vary the board, and measure. The result is lopsided — and the small board is the hard one.

The numbers

Why the small board is harder

It sounds backwards — surely a bigger board is a bigger problem? For expectimax it is the opposite. The engine's whole strategy is to herd large tiles into a corner and keep empty cells in reserve; its evaluation literally rewards empty space and a clean corner-snake ordering. On a cramped 4×4 that reserve runs out fast, and a single unlucky spawn in the wrong cell can force a merge that unravels the snake — which is why the 2048 tile is reached only about two-thirds of the time. Give the same search a 6×6 or 8×8 board and there is always somewhere to park a stray tile, so it almost never paints itself into a corner. Same heuristic, far more forgiving canvas.

How we measured it

The engine under test is the exact file the game ships. Using LK2048.makeEngine(size, 2048) we built each board and self-played to game over with the shipped adaptive depth (three plies on an open board, up to five as it fills). Tile spawns use a seeded generator, so the run is re-runnable; the search samples empty cells with the same randomness the live engine uses, so a reach-rate is a stable distribution, not a fixed value. Sample sizes are 200 (4×4), 120 (5×5), 60 (6×6) and 20 (8×8) — the larger boards run far slower because a single game is tens of thousands of moves.

One honest caveat: the 6×6 and 8×8 games are so long they hit the harness's 20,000-move safety cap rather than a natural game-over. By that point every game had comfortably reached 32768, so the 100% figures are real — but the true ceiling on those boards is higher than this run measures.

// reach-rate on any board size, straight from the shipped engine
import { readFileSync } from 'node:fs';
import vm from 'node:vm';
vm.runInThisContext(readFileSync('solver-core.js', 'utf8'));   // from lkforge.com/games/2048/

const eng = globalThis.LK2048.makeEngine(6, 2048);            // 6×6 board
let reached = 0;
for (let i = 0; i < 60; i++)
  if (eng.selfPlayGame(Math.random).maxTile >= 2048) reached++;
console.log((100 * reached / 60) + '% reached 2048');

So the board variants aren't just a bigger playground — they quietly turn the AI's hardest game into its easiest. Want the mechanics behind the search itself? Read how the 2048 AI solver works, or how much search depth is worth on the classic board in the expectimax depth benchmark.