Impossible blocks

Minecraft has had its fair share of weird bugs over the years, duplication glitches, random crashes, naturally arising from the human need to break the toys they’re given. But honestly, one of the coolest has to be the block-state corruption in 1.12.2. Instead of just tricking the game logic, this exploit actually messes with how Minecraft stores blocks internally. People figured out how to create blocks you are not supposed to have in survival, pulling stuff like command blocks, barrier blocks and mob spawners out of their ass. And not because the game gave them to you, but because the data itself got corrupted into becoming them.

To describe it in a way, it’s “pulling a rabbit out of a hat along with a bunch of rabbit corpses and skeletons”.

What goes on under the hood

In 1.12, the world is split into chunks, then subchunks (16×16×16), and inside those, block states are compressed using something called a palette. But if you shove too many different block types into a single subchunk (more than 256), the system basically gives up and switches to a registry palette. And that’s where things start getting weird.

In this mode, every block is stored as a 13-bit number. Now here’s the problem: 13 doesn’t divide nicely into 64.

Minecraft stores these values in 64-bit longs, so some block entries end up separated, like cut in half across two different memory locations. Half here, half there. Which already sounds like a bad idea, right? yeah.

Normally, the game handles this fine. But it opens the door to something much more interesting.

Word tearing (aka: things go horribly wrong)

The core bug here is something called word tearing, which is a real thing in computer science, not just a Minecraft bug.

Basically, if two threads try to write to the same piece of memory simultaneously, and there’s no proper synchronization, the writes can overlap in weird ways. Instead of one value or the other, it gets mashed up.

And because some Minecraft block states are split across two longs, you can end up with half of one block, half of another, which then recombines into something completely different.

Why only 1.12 though?

This whole thing only works in 1.12.x, and that’s not a coincidence.

It’s the exact combination of:

(that happened to coincide in 1.12)

Later versions of Minecraft changed how block states are stored, and the conditions for this exploit just don’t exist anymore. This makes BSC a historical bug, but still a very cool historical bug.

Wait, where does the second thread even come from?

Good question, because Minecraft is mostly single-threaded. The answer is, like every weird minecraft behaviour, weird redstone stuff. Or more specifically, redstone setups involving observers and beacons that manipulate the in-game events, coined “threadstone”.

Somehow (and this part still feels a bit cursed), players discovered that certain beacon + stained glass interactions (stained glass, when placed over a beacon, can change the colour of its beam) could trigger asynchronous updates. Meaning a second thread starts touching block data.

Now you’ve got:

And both of them might try to write to the same block at the same time.

If that happens exactly where a 13-bit value is split, a race condition is formed.

Actually pulling it off (good luck)

Doing this in practice is definitel not easy. First you need to force a subchunk into registry palette mode (257+ block states, which is already annoying). Then you have to find the exact coordinate where a block’s data crosses a 64-bit boundary.

Then you build some horrible contraption involving observers, beacons, lag, and probably a bit of luck, and start spamming updates. Eventually, if everything lines up just right, the game writes two different block states at the same time and you get corruption.

To be frank, most of the time you just get garbage. Random blocks, weird states, stuff you didn’t want. It’s very trial-and-error, and also kind of chaotic.

What people managed to get out of it

Despite how messy it is, players have managed to create:

It’s not clean or predictable though. You don’t just press a button and get a command block. It’s more like… run the machine 200 times and hope. But as they say, “any sufficiently advanced technology is indistinguishable from magic”. Maybe we dont understand how it works enough, but hey, it’s 2026, what parts of technology do we truly understand anyway?

Limitations (because of course there are)

This exploit is powerful, but also extremely fragile.

It depends on:

Some setups only work under heavy lag. It’s not exactly practical unless you’re in a controlled technical world.

Also, it often relies on other cursed mechanics like update suppression and chunk weirdness.

Why this is actually kinda important

BSC isn’t a logic bug, it didn’t arise from an oversight in the game’s code. Rather, it is a low-level data corruption issue caused by how bits are stored and written. This is the kind of thing you’d expect in operating systems or databases, not a funny block game.

And yet, here we are. It’s a really good example of how small, seemingly insignificant design decisions (like “let’s pack 13-bit values into 64-bit arrays”) can have massive unintended consequences when combined with concurrency.

Final thoughts

Basically, if you push just right in the right direction, you can make weird shit happen lol and i love minecraft for it