2048

How high can 2048 go?

A tile 2^k only appears when two 2^k−1 tiles meet, and the second of those has to be built while the first one is already sitting on a square. So the number of squares it takes to ever build 2^k is one more than for 2^k−1. The chain starts at 4, which the game can spawn directly in a single square. That gives squares(2^k) = k − 1:

The board has 16 squares, so 131072 (2¹⁷) is the ceiling and 262144 can never exist. The ceiling is only reachable through the game's 10% chance of spawning a 4: the other 15 squares must hold exactly 4, 8, 16, …, 65536, laid out so that each pair can merge in turn, and the last empty square must receive a 4 rather than a 2. If the game only ever spawned 2s, the cap would be 65536. Playing the whole chain out, the highest possible score is 3,932,100 (OEIS A244056). Nobody, human or program, has reached 131072 without undo; the highest tile that has actually been built in a fair game is 65536.

Why the climb gets harder with every doubling

• Moves. Every move adds one tile worth 2 or 4, on average 2.2 points of board sum, and the sum never goes down. Building 2^k therefore takes at least about 2^k / 2.2 moves: roughly 900 moves for 2048, 15,000 for 32768, 30,000 for 65536 and 60,000 for 131072. Score grows like (k − 1)·2^k: 20 thousand for 2048, 459 thousand for 32768, 983 thousand for 65536.
• Room. The big tiles have to be parked in a monotone chain (the “snake”) along an edge while the next one is built in whatever squares are left. Just before 32768 is formed, the board already carries 16384, 8192, …, 4, and the working area is two or three squares. One 4 spawned where a 2 was needed, or one tile that cannot reach its partner, blocks the chain for dozens of moves.
• Survival. Each doubling means surviving twice as many random spawns in a tighter board. That is why even the best programs fall off a cliff: about 99% reach 16384, 70–80% reach 32768, 3% reach 65536.

What has actually been achieved

Rates are the authors' own, measured under their settings. All of these play the standard game: 90% twos, 10% fours, no undo.

The algorithm on this page

The spawn is random, not hostile, so this page uses expectimax, the family behind every strong 2048 player above. Minimax (ovolve's choice) prepares for a 4 in the worst square every single move, which is far more pessimistic than the game and makes the player timid and wrong about probabilities. Expectimax maximises the expected value instead: our move picks the best child; the game's move averages over every empty square with weights 0.9 for a 2 and 0.1 for a 4.

1. Bitboard. Each square is a 5-bit exponent, each row a 20-bit integer. All four slides, the points they score and the row's heuristic value are precomputed once in 2²⁰-entry tables, so a move is four table reads (vertical moves transpose first). Five bits per square is what lets the board represent 65536 and 131072; the classic 4-bit layout stops at 32768.
2. Evaluation (nneonneo's, applied to the four rows and the four columns): +270 per empty square, +700 per pair of equal neighbours, −47 times the monotonicity penalty ∑|rank_i⁴ − rank_i+1⁴| in the better of the two directions, and −11 times ∑ rank^3.5, which pushes the big tiles into a corner-anchored chain. A dead board is worth 0 against a baseline of 200,000 per line.
3. Search. A transposition table of 2²⁰ entries, a cutoff that evaluates any branch whose cumulative probability falls under 10⁻⁴, and iterative deepening: depth 2 is always finished, then the search goes deeper while the per-move thinking budget lasts. Quiet boards with many empty squares get shallow trees; cramped end-game boards get deep ones, which is where depth matters.
4. Threads. The engine runs in a Web Worker so the tiles keep animating while it thinks. In this browser it searches roughly ten million nodes per second, so “Strong” reaches depth 6–8 on a crowded board.

What it does not have is the learned n-tuple evaluation or macroxue's end-game tables, which is what the 65536 results rest on. Those need hundreds of megabytes to gigabytes of weights or tables, more than a page can carry.

Measured. Twenty headless games of this engine at the Balanced setting (60 ms per move, same code as the page, Apple M4 Pro, Node) reached 8192 in 19 of 20, 16384 in 14 of 20 and 32768 in 3 of 20, with an average score of 330,168 and a best of 630,208 over about 12,500 moves per game. Twenty more at 50 ms with a slightly greedier time control reached 16384 in 17 of 20 and 32768 in 2 of 20 (average 355,861). Four games at the Strong setting (250 ms, average depth 6.8) reached 32768 twice, with scores of 743,140 and 711,988, and 16384 twice. Expect 8192 and 16384 routinely, 32768 some of the time, and more of it on the deeper settings; 65536 would take hours of luck on top of that.

Playing

Run AI plays until the board is dead, then starts over when auto-restart is on. Hint shows the move the search would make, Step plays it. Arrow keys, WASD and swipes move manually and pause the AI. Space toggles the AI.

• The engine runs ahead. It plays in a worker thread up to 400 moves in front of the display and buffers them, so what you see is paced for watching, not by thinking time. The thinking budget itself adapts to the position: a sparse board with nothing above 1024 gets a one-ply glance, a crowded board with big tiles gets the full budget you chose.
• Adaptive display speed. The pace follows how crowded the board is and max(largest tile, 1024): about 2000 moves per second on an easy board, down to one move per second when big tiles crowd the grid, with a short pause after a top-tile merge. Pick a fixed pace instead if you prefer.
• Look back, never undo. Drag the slider under the board, or use the arrow buttons, to see any earlier position of the current game. This is a replay of the recorded moves and nothing else: the game is not rewound, no tile is re-rolled, no decision changes, and the live game keeps running underneath while you look. Back to live returns to the present. Finished games keep their move list, so Replay in the list opens them in the same viewer.
• Nothing is lost. The live game, its full move list and the AI's running state are saved in this browser after every move, so closing the tab by accident just means reopening it: the game is restored at the same move and, if the AI was running, it carries on. A hidden tab keeps playing without drawing frames.

References

• ovolve, 2048-AI (the page this one is modelled on) and its source
• Nie, Hou, An, “AI Plays 2048”, Stanford CS229 2016
• nneonneo, 2048-ai and the Stack Overflow write-up with the heuristic and the 100-game statistics
• Jaśkowski, “Mastering 2048 with Delayed Temporal Coherence Learning…”, IEEE TCIAIG 2018
• Guei, Chen, Wu, “Optimistic Temporal Difference Learning for 2048”, IEEE ToG 2021
• macroxue, 2048-ai (65536 in 3.5% of games)
• OEIS A244056, maximum score of 2048 on an n×n board
• Gabriele Cirulli, 2048, whose game rules, look and feel this page reuses (MIT)