Every Bedrock seed,mapped beforeyou mine.

The pipeline, from bytes to badges

Village placement, climate noise, stronghold rings, the 2% zombie roll: each came back as named code, and each is something you can toggle on the map today. What began as a single-letter export table is now a repository with sentences in it.

One requirement shaped the build: the generation math runs on your machine, and only there. Everything below follows from that single decision, including what the tool refuses to be.

Computation

A WebAssembly module in a pool of web workers. Tile fills and structure scans run off the main thread, so panning and zooming never stutter.

Input

Any Bedrock seed. Numbers are used exactly as typed; words are hashed the way the game hashes text seeds.

Output

The biome map, structure positions with block coordinates, the spawn point, and per-structure detail on click, including a ready-made /tp command.

Dimensions

Overworld, Nether and End, each with its own climate rules and its own structure set, all derived from the same seed.

Servers

None. There is no backend between you and the engine, so there is nowhere for your seed to go.

The same engine answers two opposite questions, so it ships as two tools. Both run entirely in the browser, and both accept the same seeds.

The map answers what is where from above. The flight view drops you into the middle of it: first person, no clip, over terrain built from the engine's own biome and height grids, block for block under you, colored with the map's own palette. The same wasm that paints the flat map extrudes every column you fly past, in your browser, from the seed alone.

VLetter badgePixel iconthe same Village marker in both styles, switched live at the top of the view

Region

Endless. Terrain streams in 128-block sectors around the camera and drops away behind the fog, so the world never ends and memory stays flat however far you fly. The sectors under you carry the game's own block-for-block heights; the far ring keeps the map's coarser grid.

Markers

The map's own letter badges, or its pixel icons, your pick from the Letter / Icon control at the top of the view. The scan ring follows you as you fly.

Controls

W A S D to fly, the mouse to look, Space and Shift for pure verticals, the wheel to scale speed. The arrows steer without a mouse, and touch gets its own flight pad.

The finder answers one seed at a time. The comparison tool puts two worlds on one screen: the engine fills the same neighborhood window for seed A and seed B, paints both biome maps side by side, then walks the grids cell by cell and flags every place they disagree. Spawn-adjacent layouts, biome shares, the exact line where a better seed starts: all three land in one view, computed by the game's own algorithms.

Every color on the map is a decision the engine made. The biome dictionary turns those decisions into a reference: three dimensions, three different rules for picking a biome, and for each biome the full table of who can sit next to it. The numbers quoted below are counted from the engine's own output, never copied from a wiki.

Sources, all recountable: 27,000,000 overworld cells across 12 seeds, 13,500,000 nether cells across 6, and a 12,000,000-trial walk of the climate channels' measured ranges. Every share above is a count of observed border cells.

Every letter badge on the map is the end of a dice chain the engine rolled long before the first block rendered. The structure dictionary turns that chain into a reference: the region grid that fences every placement, the four random number generators behind the rolls, and the gates that keep most candidates empty. The constants below are the engine's own, read out of its C code.

Sources, all recountable: 2,387 lines of reverse-engineered Bedrock 26.50 C; non-dark-forest mansions: 6 specimens + a 20,000-seed census, all pure Lush.

On the map, every structure type is a colored badge with a letter: the engine's own shorthand, drawn exactly where the game's algorithms place it. This is the full legend, 32 types grouped by dimension. Dense underground types (geodes, ravines, dungeons) reveal themselves as you zoom in, which keeps the far view clean.

The engine that draws the map also answers plain HTTP: 20 GET endpoints, no keys, no accounts. One call reads a seed's spawn and surroundings. Another reads a whole block column: the biome, the terrain levels, the cave biomes underneath, the climate that picked it. Another samples all 25 perlin noise channels, another lists every structure near any point with the same detail the map's popups show, and another returns a region as a grid of biome ids. Every answer is JSON, every call is rate limited per IP, and the quota rides along in the response headers so scripts can pace themselves.

1// double village: two DIFFERENT villages, gap <= 180 blocks2const v = seed.structures('village', 0, 0, 512);3if (v.length < 2) return false;4 5let best = Infinity;6for (let i = 0; i < v.length; i++) {7  for (let j = i + 1; j < v.length; j++) {8    const d = Math.hypot(v[i].x - v[j].x, v[i].z - v[j].z);9    if (d < best) best = d;10  }11}12if (best > 180) return false;13return { gap: Math.round(best), villages: v.length };

Behind the editor: biome and structure queries, terrain heights and the floating-terrain column profile, area scans, cave bands, the region grid, climate channels, spawn, slime chunks and the sister-seed walk, the full catalog the map itself answers. Your code runs in a sandboxed worker with no network; hits stream in live and open on the map in one click, for as long as you let the walk run. Thirteen ready hunts ship as templates, a blank canvas starts your own, and the hunts you save stay in your browser; the reference page documents every function.

The map shows a world; the finder hunts one; the judge hands down a verdict. Hand it any seed (or roll the 64-bit dice) and it reads the world's own math within 2,048 blocks of spawn: every biome in the window, the skyline against sea level, sixteen kinds of landmark with distances and bearings, the nether pair off the portal estimate. Five scored categories, one number out of 100, and a commentary that names the strongest and weakest card on every seed. The judgment rules live on the page itself: no cloud AI, no invented numbers, and the same seed always says the same thing.