← Back to blog
AiAbout 6 min read

Someone Rewrote Minecraft in Rust and Audited 833 Behaviours Against the Original

Published Nov 14, 2026
Someone Rewrote Minecraft in Rust and Audited 833 Behaviours Against the Original

Horizon is Minecraft: Java Edition 26.3 rewritten in Rust. Zip file, one native binary, no Java. It loads your existing worlds, joins vanilla servers, and runs the same terrain generation.

That description would be unremarkable if rewriting a game were a common hobby. It's not, because the hard part isn't rendering. The hard part is that Minecraft's behaviour is defined by an enormous pile of accumulated special cases, and a rewrite is only correct if it reproduces them, including the ones nobody wrote down.

Horizon's answer to that is the reason this repository is worth an hour of anyone's time.

The port ledger

The project runs a tool called port_ledger.py that reads every method in vanilla 26.3 and checks it against Horizon's code. What comes out is a count of vanilla behaviours a player would notice that Horizon doesn't have yet.

At the time of writing, the README reports 833 of those were found and 0 are open. The breakdown is by area: animals, monsters and bosses, entities and projectiles, items and enchantments, blocks and redstone, world generation and saves, screens and HUD, rendering and models, server-side player handling, mob AI and raids. Each area links to its own issue.

A second tool, parity_gaps.py, tracks the number going down. The claim isn't that Horizon is identical to Minecraft. It's that every difference someone identified has been closed.

A wireframe cube of steel rods on concrete, casting a solid shadow.

What the harnesses actually compare

Then the README does something unusual. It publishes a table of what its automated comparisons cover, scored from 0 to 1, and states plainly that a score of 1 means the harnesses cover and pass that subsystem, not that nothing else differs from vanilla.

A score of 1 on the window, input and game loop subsystem means the loop, options, camera, auto-jump, toggle sprint and sneak and frame limiter all match. Assets and resources reach 1 with item models matching across 196,290 stacks and the resource pack screen tested over 3,000 sessions. Network protocol reaches 1 by joining vanilla servers, matching the dedicated server's files, login, configuration, play and command tree, and testing LAN discovery across 462 cases in offline mode. Chunk storage reaches 1 with client and saves sharing paletted containers identical to vanilla across 266 scenarios. Section meshing reaches 1 with 112 scenes and over a million quads identical to vanilla.

That last one is the number to sit with. A million quads rendering identically rules out a visual approximation. That is the same geometry.

The performance numbers

The benchmarks are specific enough to check. Windows 11, Ryzen 7 9800X3D, RTX 5080, 1280 by 720 in a window, VSync off, three runs per figure, mean of four scenes with the slowest one percent of frames in brackets.

At 8 chunks of render distance, Horizon holds 3,289 frames per second with a 1,327 worst case. Vanilla 26.3 gets 2,437 with 640. Vanilla plus Sodium, Lithium, FerriteCore and ImmediatelyFast gets 2,375 with 709.

At 16 chunks: 2,074 against 1,661 and 1,586. At 32 chunks: 1,207 against 1,031 and 879.

The 1 percent lows are the interesting column. Horizon's worst frames are roughly twice as fast as vanilla's worst frames at every distance, which is the difference between a stutter you notice and one you don't.

Load times go the same way. Title screen in 2.9 to 3.2 seconds, against 7.5 to 7.7 for vanilla and 10.8 to 11.1 for the modded client. Chunks load 2.9 to 3.8 times faster. Playing holds a working set of 1.1 to 1.7 GB, against 1.9 to 2.9 GB.

What ships in the current build

Survival, creative, hardcore and spectator modes. Vanilla world generation in all three dimensions. Mobs, villagers, raids, redstone, every command, the HUD, the recipe book. Saves from 1.8 through 26.2 upgrade on open.

Multiplayer works with vanilla servers in online mode, including LAN worlds and friend invites through a code from the launcher. Resource packs, data packs and shader packs all load. Content mods and native Rust mods install from the launcher. You can host a server from the launcher or run horizon-server on a VPS.

Graphics options that would change the vanilla look are off by default, including distant terrain out to 1,024 chunks, HDR and controller support.

Building it yourself

The build needs Rust 1.90 or newer, Python 3.11 or newer, JDK 25 and, on Linux, libasound2-dev and libudev-dev.

Resource preparation is the part I did not expect. horizon-prepare builds the game's assets from your own copy of Java Edition 26.3, checked against a research-lock.json file, and never downloads them. You play 26.3 once in the official launcher, then point the tool at your .minecraft directory or set HORIZON_MINECRAFT_DIR. The server jar goes in separately.

git clone https://github.com/horizon-rust/horizon.git
cd horizon
cargo run --release -p horizon-prepare -- --prepare --server-jar ~/Downloads/server.jar
cargo run --release -p horizon-prepare -- sounds
cargo run --release -p horizon-client

Before a pull request, contributors run python3 tools/pr_ready.py, which checks formatting, clippy, the touched crates' tests, the Python tests, a public-tree check and the vanilla harnesses affected by the change. The README warns against committing game files, decompiled source or prepared resources.

Why this one is different

Clean-room rewrites of large software are usually interesting for one of two reasons: they're faster, or they're a stunt. Horizon is both, but the transferable lesson is the audit structure.

Most rewrites fail at the same place. The new version looks right, then diverges in a corner nobody tested, and the divergence compounds. Horizon's response was to enumerate the corners first. The ledger reads vanilla method by method and produces a finite list. The harnesses then prove each subsystem from the outside, with counts attached: 196,290 item stacks, 462 LAN cases, 266 save scenarios, 112 scenes.

The scores that read 0.75 or lower are the honest part. A project that published only the perfect scores would look better and tell you less. Publishing the table means you can see which areas the tests don't reach, and decide for yourself how much the number 1 is worth at 8 chunks of render distance with your specific mod list installed.

There's a governance detail that the README treats as routine and isn't. The project has a council, theme groups with named leads, a team and a moderation policy, all documented in a separate file. An unofficial rewrite of a game with hundreds of contributors needs a way to decide whose pull request lands, and the fact that this one wrote down the answer before it needed it is a fair signal about how the 833 gaps got closed.

MIT licensed, unofficial, and you need your own copy of the game. Those three facts are all in the first paragraph of the README, which is where they belong.

Related articles