Seed Discovery Algorithms

An End Portal frame consists of 12 blocks. Each block has a 10% independent chanceof generating with an Eye of Ender already filled. A "12-eye" portal is one where all 12 frames generate with eyes, activating the portal instantly.

The Mathematics

RNG Implementation (Java)

The game uses the chunk's random seed to determine decoration placement. Here is the decompiled logic responsible for eye generation:

public BlockState getStateForPlacement(BlockPlaceContext context) {
    // ...
    boolean hasEye = false;
    if (Config.configuredStructures) {
        // Use the Chunk RNG, initialized with world seed + chunk coords
        Random random = new Random();
        random.setSeed(chunkX * 341873128712L + chunkZ * 132897987541L + worldSeed + 10387312L);
        
        // precise 10% chance check
        if (random.nextFloat() < 0.1F) {
            hasEye = true;
        }
    }
    return this.getDefaultState().with(HAS_EYE, hasEye);
}

Cacti normally grow 1-3 blocks high. However, during world generation, if a new cactus block attempts to generate on top of an existing one, it simply adds to the height. This can chain recursively due tochunk population order.

The recursive formula

Each extra block of height requires a successful RNG roll anda specific chunk generation order. The probability drops exponentially.

// Simplified probability model per block above 3
P(h) ≈ P(h-1) * (1 / 4096)

// For a 22-block cactus (World Record):
P(22) ≈ (1/4096)¹⁹ ≈ 1.8 × 10⁻⁶⁹

The Kaktwoos Project utilized distributed GPU brute-forcing to check trillions of seeds specifically optimizing for this rare recursive call.

At the heart of Minecraft's seed generation is Java's `java.util.Random`. It is not "truly" random, but a deterministic mathematical sequence. If you know the internal state (seed), you know every future number.

next_seed = (current_seed * 0x5DEECE66DL + 0xBL) & ((1L << 48) - 1)

Reverse Engineering Demo: Try our interactive visualizer below to understand how tools brute-force the lower 48 bits of a seed based on structure coordinates.

Real-World Tools: Because this formula is reversible, tools likeSeedCrackerX can take a sequence of observed events (dungeon floor patterns, emerald ore locations) and mathematically solve for the `world_seed`.

Minecraft's terrain generation has undergone massive shifts. The most significant change occurred inVersion 1.18 (Caves & Cliffs Part 2), which completely replaced the old system.

Legacy Generation (Pre-1.18)

Old worlds were generated using a Layer-Based System. It worked like image processing:

• Islands: Start with a noise map defining ocean vs land (1:4096 scale).
• Zooming: Scale up the map (Zoom x2) and smooth the edges.
• Additions: Sprinkle biomes, rivers, and shores at different zoom levels.
• Final Polish: The map is zoomed to 1:4 scale for the final biome lookup.

This is why older maps often have "continental" shapes and predictable climate zones (hot to cold transitions).

Modern Generation (1.18+)

Modern Minecraft uses Multi-Noise Generation. Instead of layers, the game queries mathematical noise functions for every coordinate (x, y, z) to determine the biome.

This creates more natural transitions and allows for 3D biomes (e.g., Lush Caves under a Jungle), but makes reverse-engineering much harder as you cannot simply "zoom out" to see the full structure easily.

Speedrunners use "Filtered Seeds" (FSG) to practice specific strategies. These seeds are pre-generated to ensure a specific subset of conditions:

• Bastion + Fortress: Within 128 blocks in Nether.
• Blind Travel: Stronghold located exactly at calculated angles.
• Village Entry: Starting with beds and food.

We have now integrated verified seeds from the Minecraft Speedrunning Communityinto our database, allowing you to browse optimal practice worlds.

Structures don't use the full 64-bit world seed. They often rely on the lower 48 bits or even fewer. This generates "Shadow Seeds" - different worlds with identical structure placements.

// Step 1: Divide world into regions (e.g., 16x16 chunks)
int regionX = chunkX / spacing;
int regionZ = chunkZ / spacing;

// Step 2: Initialize RNG with only the lower 48 bits
long structSeed = worldSeed & 0xFFFFFFFFFFFFL;

// Step 3: Mix region coordinates to get unique seed per region
long seed = regionX * 341873128712L + regionZ * 132897987541L + structSeed + uniqueSalt;

// Step 4: Pick random chunk in region
int xOffset = (seed & 0xF); // random 0-15
int zOffset = (seed >> 8) & 0xF; // random 0-15

Quad-Witch Huts: To find 4 witch huts close enough to farm, seed hunters limit the search to the lower 20 bits of the seed (checking only 1 million possibilities instead of quintillions) to find the perfect region layout, then brute-force the upper bits to find a biome match (Swamp).

Much of the data and research presented here is powered by the incredible work of the Minecraft@Home team and the Minecraft Speedrunning Community.

Their distributed computing projects have discovered the tallest cactus, the Pack.png seed, the Title Screen seed, and many other historic worlds. Support their research on GitHub!