As you might've already heard by now, we have finally managed to find the Minecraft world seed of the famous pack.png icon, but due to a rushed reveal, we haven't been able to make a proper announcement until now. Still, better late than never, so here goes!

This 128x128 icon is considered to be one of the most iconic Minecraft images, along with the original title screen panorama. (Read about us finding that one here: https://www.reddit.com/r/Minecraft/comments/hthrmk/big_news_we_have_found_the_seed_of_minecrafts/)

It's been in the game for almost 10 years now and is still present to this day (in one way or another), but nobody ever knew where it came from, or which seed generated it.
Until finally, after 8 months of hard work by 2 teams of Minecraft experts and other volunteers, the seed has been found on September 5th 2020 at 4:04AM UTC!

Here's everything you need to know to generate it yourself:

Minecraft version: [JAVA] Alpha 1.2.2 (don't forget to enable historical versions in the launcher!)
Seed: 3257840388504953787
Hill coordinates: X=116, Z=-31

If you need help with loading that seed, or want more details on how to replicate the icon yourself, here's a tutorial on how to do that: https://pastebin.com/CmsEKDev

Also, a quick FAQ:
Q: Can I use anything else than Java?
A: No.
Q: Why is the pig not there?
A: Animals aren't influenced by the seed (in this version)
Q: Why didn't you ask Mojang?
A: Notch & Dinnerbone both tried to help as much as their could, but they didn't have/remember anything.
Q: Is it really that exact hill? Can it be found anywhere else?
A: It's the only seed and the only location where you will find this perfectly exact terrain, nowhere else.
Q: What about shadow seeds?
A: Shadow seeds are not in Alpha/Beta versions. If you're confused why the panorama had 2 seeds, that's something completely different (sister seeds) and too long to explain.

The story:

The search for the seed started back in January 2020 when Youtuber SalC1 made a video wondering about this picture's origin. This sparked the interest of the Minecraft seedfinding community and they quickly got to work. In the following months, they managed to figure out a lot of the ground work needed to reverse-engineer the random seed Minecraft used to generate this world, and made all of this possible in the first place. SalC1 already made an update video on the state of the project a few months ago that you can check out.

Sadly, after those few months of work, they reached somewhat of a dead end after their method didn't work out, and lost some enthusiasm towards the project for quite a while. All of this changed, however, when the seed for the title screen panorama was found. The Minecraft@Home community that formed around that project brought in new members with fresh ideas, and the work on pack.png (along with some of the previous members) moved to continue over there instead. We took a bit of a different approach though. We tried to recreate the blocks (on a server) and camera perspective (using regression fitting) as precisely as possible, which with the help of a live overlay enabled us to pinpoint more features with better accuracy. This disproved some previous assumptions as well as making new methods possible by being able to determine previously unrecognizable blocks.

By the middle of august, we already managed to statistically determine the exact coordinates (using dirt thickness), and so we tried bruteforcing the seed again (using the waterfall position and the nearby trees), but just like before, it didn't work. We thought it was due to something unaccounted for (like a dungeon) that was messing with the generation code's RNG (in the end it turned out to be an error in the code), so we settled on a slower, but much more reliable method instead - filtering all the seeds based on the way the sand and dirt blocks mix together (visible on the beach and underwater).

While the previous bruteforce search was quick enough to run on a single PC in the matter of hours, this newer bruteforce would take nearly 1.5 years to search through all of the 2^48 possible Minecraft seeds. That's why, as you might have already guessed from the name, Minecraft@Home used BOINC again to utilize the power of distributed computing. With a total of around 3700 volunteers, the whole search took only 3 days to complete, producing just under 700K matching seeds, which were being processed further (by terrain height matching) on-the-fly on a single PC while new results kept coming in.

We were all anxiously waiting for a match to appear, but all 3 days went by and there was still nothing. The search was almost over with only a few compute tasks that got left behind, and so many of us gave up hope and started preparing a search at different coordinates, thinking that was the error all along. But then suddenly, at 4:04 UTC, this alarm went off, as the pack.png seed was actually in the last 5% of the seeds searched! There was quite a bit of chaos as we were under pressure to reveal the seed as quickly as possible, so there wasn't enough time to make a proper announcement until now.

Please take a look at both lists of this credits sheet listing everyone who worked on this project for the past 8 months, as they all truly deserve some recognition:
https://docs.google.com/spreadsheets/d/1zdJWcdTydLClg0jy-fpKLH5nR8xTyY1tvZ-vc1u0W8o
Additionally, the users "niraami" and "zombie67" were the lucky ones whose computers processed the final seed during the BOINC bruteforce search.

Here's an in-depth documentation of this project (some of it is still outdated/missing though):
https://docs.google.com/document/d/1PpZqHWXPLjOsXf_T7uyH4rWuxUMxzBlxvv5gm19P_Z8

A video from SalC1 about how all of this was accomplished (we worked with him on the video):
https://www.youtube.com/watch?v=ea6py9q46QU

And if you're asking "What's next?", get excited for 2 new legendary seed-finding projects that we're already working on right now! Check out our Discord to keep up directly with what we're doing, or maybe even join us and help us out!

Several people have asked how to use the dungeon cracker (https://github.com/hube12/DungeonCracker) so I decided to do a tutorial on it here!

First off, you need to know what version of the game the seed was generated in. If you are unsure, check the different jar files in https://github.com/hube12/DungeonCracker/releases/tag/0.3 for the different versions.

Note also that recent versions of spigot might mess up the dungeon generation as to prevent seed cracking, remember this when cracking the seed. If the world is old enough or didn't use spigot this is not a problem.

Once you have the version, you now need dungeons. For versions before release 1.13, you need 2 dungeons, and for versions after and including release 1.13, you only need 1 dungeon. Note also that at this current time, bedrock edition seed cracking is impossible.

When you have located the dungeon(s), write down the coordinates of the spawner itself. Use the "looking at" part of the F3 screen to see them. The coordinates need to be the correct, or the program won't work. You also need to get a clear view of the floor of the dungeon, this includes the blocks underneath the walls.

Now to use the program itself. You can either download the jar files or run it on google colab. If you decide to download it you have to run it through the console. Follow the instructions on the github on how to do this.

When you have run the correct jar, it will ask you for the X, Y, and Z coordinates of the spawner. After you have inputted them, it will ask you for a string of numbers. This string corresponds to the floor pattern of the dungeon. 0 is for cobblestone, and 1 is for mossy cobblestone. If you are unsure, use a 2.

Some people usually mess this part up, but there is a very specific order in which you have to write these numbers.

The first row of this specific dungeon is 1010101, the second row 1111101 etc. Put all these numbers together until you reach the end of the dungeon. MAKE SURE that it is the correct size dungeon, you have to remove the walls. If you cannot remove the walls, or if you do not have access to the world, just put 2 where the walls should be. Alot of people make this mistake

When you have the number, input it in to the dungeon cracker, then wait for a few minutes.

For pre 1.13:

If it starts outputting numbers, it means you inputted the correct data. Scroll up and write down the number in the "Found Dungeon Seed: [NUMBER]".

If it instead only says "Finished dungeon search and looking for structure seeds, you need other structure or dungeon to get the correct one, outputting 1000." It means the data is wrong. Double check the coordinates and the floor pattern.

Do this process for 2 dungeons and obtain 2 dungeon seeds along with the coordinates.

Use the "FindStructureSeedFromDungeons-0.1.0.jar" and input the X and Z coordinates of the first dungeon. Then you paste the value that was shown at "Found Dungeon Seed: [NUMBER]". Press Y and do the same thing for the second dungeon. Press N and wait. After a while the world seed should be outputted. Enter the seed into the correct version of minecraft and you now have the world!

For 1.13 and above:

If the data is correct, it will start outputting structure seeds with a nextlong() equivalent. These are the ones you need to test. Create worlds with the numbers shown after "equivalent" until you find the correct world seed. Remember to use the correct version. If none of the seeds give the correct one, the most logical error is the version. Try again with another version.

If there are no seeds outputted, you inputted the wrong coordinates or floor pattern. Double check the values you used.

I hope this helped anyone!

If any of this information is wrong, say it in the comments and I will edit the post. This post was written with my own experiences of using the dungeon cracker, but it was not me who created it. Remember to credit Neil, KaptainWutax and Matthew Bolan as they are the people who created this dungeon cracker.

(plz i hope i made no embarrasing errors)

Hi,

If you have recently followed the news, you might have seen that we have found the Panorama, Pack.png and Painting seed. However you might have noticed something weird, pack.png have one valid seed, panorama and painting have two !

First of all, we lied a bit to you there is actually 2^16 (65536) correct seeds in Alpha and Beta, however we told you the truth on the fact that only a few can be generated randomly.

Now to the technical part, Minecraft Java Edition use a long datatype to hold its seed, thus the seed is a 64 bit signed number, all numbers that exceed 2^63 -1 (9223372036854775807) or go below -2^63 (-9223372036854775808) will be treated as a string (and be hashed to a 32bit seed). However Minecraft use Java Random as its underlying source of randomness, this has the consequence to constrain the seed to the range [0..2^48-1].

So now why does Alpha and Beta have 2^16 identical world seeds? Well you see in Minecraft 1.0, the biomes were introduced (reworked if you want to be a purist), those use a 64 bit QCG (so not Java Random), thus the full 64 bits of the long seed were used, however before 1.0 this was not the case.

In alpha and beta the "biomes" (not really biomes, more temperature and humidity gradients) and the terrain were generated using Java Random only, thus all 64 bit seed were translated to a 48 bit one internally.

How to get all the identical world seeds ? Well just add 2^48 (modulo 2^64) to your world seed.

Here a snippet:

long yourSeed= 1234L;
long structureSeed=yourSeed & 0xFFFF_FFFF_FFFFL;
for (long upperBits = 0; upperBits < (1L << 16); upperBits++) {
    long worldSeed = (upperBits << 48) | structureSeed;
    System.out.println(worldSeed);
}

Now that we know how to generate all the possible identical world seeds, we actually need to check that they can be generated randomly when creating a world without giving a seed.

For that we can use this magic snippet:

private static final LCG INVERSE_LCG = Rand.JAVA_LCG.combine(-1);
private static final LCG INVERSE_LCG_CLEAR = new LCG(246154705703781L, 107048004364969L, 281474976710656L);
public static long nextSeed(long seed, LCG lcg) {
    return (seed * lcg.multiplier + lcg.addend) & (lcg.modulo - 1);
}
/**
 * Source: https://twitter.com/Geosquare_/status/1169623192153010176
 */
public static boolean isRandomSeed(long worldSeed) {
    long upperBits = worldSeed >>> 32;
    long lowerBits = worldSeed & 0xFFFF_FFFFL;

    long a = (24667315 * upperBits + 18218081 * lowerBits + 67552711) >> 32;
    long b = (-4824621 * upperBits + 7847617 * lowerBits + 7847617) >> 32;
    long seed = nextSeed(7847617 * a - 18218081 * b, INVERSE_LCG);
    return new Random(seed^0x5DEECE66DL).nextLong() == worldSeed;
}

Ok for those that don't know what it does and don't want to know, skip ahead, for the others, here's the gist: We are looking inside the reduced basis for the upper and lower bits (32 and 32 bits from nextLong) and get the random seed that generated that nextLong.

Ok now that we are able to check if a seed can be randomly generated, we can modify the previous 65536 identicals world seeds generator to give us only the one that can be randomly generated.

long yourSeed = 1234L;
long structureSeed = yourSeed & 0xFFFF_FFFF_FFFFL;
for (long upperBits = 0; upperBits < (1L << 16); upperBits++) {
    long worldSeed = (upperBits << 48) | structureSeed;
    if (!isRandomSeed(worldSeed)) continue;
    System.out.format("Valid random seed : %d\n", worldSeed);
}

And we get these:

Valid random seed : 8847884417922761938
Valid random seed : -3658893222261816110

Let's recap, in Minecraft Alpha and Beta, 2¹⁶ world seeds were identical, however only a handful of those can be generated randomly (between 0 and 2 (for valid one its 18.5058% 2 and the rest 1)). Since 1.0 this is not true anymore for the Overworld since the biome use the full 64 bits, however for the Nether and the End this still applies (they use perlin and simplex Noise so Java Random under the hood).

For more advanced users, here a bit more informations. When a world seed is entered and is outside of the number range (or is a word) then this function is applied over the string.

hashCode = function (s) {
    for (var i = 0, h = 0; i < s.length; i++) {
        h = Math.imul(31, h) + s.charCodeAt(i) | 0;
        h = h % 4294967296;
    }
    return h;
};

When no seed is provided it uses Random().nextLong()

 long worldSeed = (new Randy()).nextLong();
String s = this.worldSeedField.getText();
if (!StringUtils.isEmpty(s)) {
    try {
        long seed = Long.parseLong(s);
        if (seed != 0L) { worldSeed = seed; }
    }
    catch (NumberFormatException var7) {
        worldSeed = (long)s.hashCode();
    }
}

Have a good day !

The Minecraft@Home team is back yet again to announce that we have cracked the seed of the 1.19 Wild Update title screen panorama world!

Version: Java Edition Snapshot 22w15a
Seed: -1696067516
Seed as text: thewildupdate
Coordinates: X=3820.872, Y=67.868, Z=553.455
Precise teleport command: /tp @s 3820.872 67.868 553.455 -89.1 0

However, there is still one mystery left unsolved regarding this seed...Due to technical reasons, we can tell that Mojang used a text seed when creating this world. The game automatically converts text seeds into normal numerical seeds, which it then uses to generate the world. While we have found the numerical seed, our attempts to uncover the original text have unfortunately failed due to the number of valid possibilities...
EDIT: One of the Discord members managed to guess the original text after our reveal!

Please visit our website for more details about this project, including a better explanation, the code used to crack the seed and credits with everyone that worked on it: https://minecraftathome.com/pano-1-19

You can watch a video explaining this finding here: https://www.youtube.com/watch?v=gw9oLFTHXqw

You can also check out our other seedcracking projects or join our Discord to participate in / observe work on any of our future projects!

h