The Art of Subtraction: Analyzing rd-160052

The version where Notch learned that removing features is a feature.

One day after building the largest single-version expansion in Minecraft’s early history — nine new files, 801 new lines, terrain generation, a tile type system, particles, random ticks — Notch shipped a version that was smaller. Twenty-six files instead of twenty-eight. Two thousand four hundred and ninety-four lines instead of two thousand six hundred and sixty-nine. The package name com.mojang.minecraft, adopted with apparent confidence just yesterday, reverted to com.mojang.rubydung.

rd-160052 was released on May 15, 2009, and it is Minecraft’s first contraction. Not a regression, not a rollback. A deliberate paring-down. Features were tried, evaluated, and removed. Parameters were tuned. The codebase got shorter and the game arguably got better. This is the version where Notch demonstrated something that many developers never learn: sometimes the right move is to delete.

What Was Removed

The Bush

Bush (tile ID 6) is gone. Not deprecated, not hidden — deleted. The Bush.java file is removed. The tile registration in Tile.java is removed. The X-shaped cross rendering code in Chunk.java is removed. The key binding that selected bush for placement is removed.

Bush was introduced in rd-20090515 as the game’s first non-solid tile, the first tile with non-standard rendering, and one of only two tiles with tick behavior. It was transparent to light, had no collision box, rendered as two intersecting quads forming an X shape, and died if it was in darkness or not sitting on dirt or grass. It was, architecturally, the most complex tile type in the game.

It was also, apparently, not working well enough to keep.

We do not know exactly why Notch removed it. The decompiled source does not include commit messages or design notes. But we can observe what bush removal accomplishes. With bush gone:

• All non-air tiles are solid. The tile system no longer needs to handle non-solid tiles as a special case.
• All non-air tiles block light. The lighting system no longer needs tile-type-aware light blocking checks.
• All tiles render as standard six-faced cubes. The chunk mesher no longer needs special-case rendering code.
• The only tile with tick behavior is grass. The tile tick dispatch is simpler.

Bush was the outlier in every dimension. Removing it collapses the entire tile system from “six types with one exception in each property” to “five types that are all the same except for grass textures and grass ticks.” The system becomes more uniform, more predictable, and easier to reason about.

This is a pattern worth recognizing. Bush was not a bad idea — non-solid decorative tiles are fundamental to Minecraft as we know it. Flowers, tall grass, saplings, mushrooms, torches, crops: the game would eventually have dozens of non-solid tile types. But bushes in rd-20090515 had problems. Their tick behavior (dying in darkness, dying without soil) interacted with the random tile tick system in ways that made them gradually disappear from the world. Their X-shaped rendering was a custom code path in the chunk mesher. Their transparency required alpha testing in the render pipeline.

Notch would bring non-solid tiles back, eventually. But for now, removing bush lets him focus on the core loop: solid blocks, terrain, entities, particles. Remove the thing that does not work yet. Bring it back when you understand it better.

The Applet Wrapper

MinecraftApplet.java is also deleted. This was a trivial class — maybe twenty lines — that wrapped the game in a Java Applet for browser deployment. The Java browser plugin was the distribution mechanism Notch would eventually use for Minecraft’s initial viral spread on TIGSource and his own site.

The removal might indicate that the applet approach was not yet stable enough to ship, or simply that Notch wanted to simplify the build for this iteration. The applet wrapper would return in later versions when browser distribution became a priority.

The Name

com.mojang.minecraft becomes com.mojang.rubydung again. Minecraft.java becomes RubyDung.java. The game loses the name it gained yesterday.

This is a fascinating reversion. Why rename a project back to its prototype name one day after giving it an identity? The most likely explanation is mundane: Notch may have been working from a branched copy, or the rename may have caused issues with existing tools, save files, or deployment. Or he may simply have decided that the name was premature — that the project was not yet “Minecraft” in a way that justified the name.

Whatever the reason, com.mojang.rubydung will persist for several more versions before com.mojang.minecraft returns permanently. The name matters less than the code.

What Changed

Particle Physics: From Deterministic to Stochastic

The particle system received a significant overhaul in its death mechanics and physics constants.

In rd-20090515, each particle had an age field (incremented every tick) and a lifetime field (randomly determined at spawn, ranging from 4 to 40 ticks). When age >= lifetime, the particle died. This is deterministic: every particle has a fixed expiration date set at birth.

In rd-160052, the age and lifetime fields are gone. Instead, each tick, each particle has a 10% chance of dying (random() < 0.1). This is a geometric distribution with parameter p = 0.1:

• Expected lifetime: 10 ticks (0.5 seconds at 20 TPS)
• Median lifetime: ~6.6 ticks
• Standard deviation: ~9.5 ticks
• 1% survival at: ~44 ticks

The visual difference is subtle but meaningful. With deterministic lifetimes, a burst of 64 particles from block destruction creates a cloud that thins gradually and then vanishes once the longest-lived particle expires. With stochastic death, particles pop out of existence at random intervals. Some die almost immediately. Others linger far longer than expected. The effect is more organic, more like real debris scattering, where some pieces settle quickly and others bounce and roll for a while.

The 10% death rate also eliminates the need for two fields (age, lifetime) and their associated logic. The tick function becomes simpler: roll a random number, maybe die, apply physics. No incrementing, no comparing.

Gravity increased from 0.04 to 0.06 per tick — a 50% increase. Particles now fall noticeably faster, creating a more compact, downward-directed debris pattern. The old gravity produced a floaty, lingering spray. The new gravity produces a sharp, decisive scatter.

Speed changed in two ways:

Horizontal speed nearly doubled (0.4 to 0.7), spreading debris wider. Vertical speed gained no attenuation (1.0 instead of 0.4) and lost the 0.1 upward bias that gave particles a slight fountain effect. The combined result: particles spray outward in a wider cone but do not linger upward. They move faster horizontally, fall faster vertically, and die randomly. The effect is punchier and more immediate.

These are not arbitrary changes. This is parameter tuning. Notch played the game, broke some blocks, watched the particles, and adjusted the numbers until they felt right. The direction of every change — heavier, wider, faster, less floaty — points toward a consistent aesthetic goal: block destruction should look decisive, not ethereal.

HUD Sizing

Two HUD elements grew:

The crosshair expanded from +-4/5 pixels to +-8/9 pixels — approximately doubled. The thin crosshair of rd-20090515 was presumably hard to see, especially now that the game launches fullscreen and the crosshair is a single-pixel-wide line at monitor resolution. Doubling it makes it visible at any resolution.

The block preview (the small isometric block in the corner showing the selected tile type) tripled from scale 16 to scale 48. This makes the preview large enough to identify the block type at a glance, which matters now that there are five placeable types. When there was only one block type, the preview was decoration. With five types, it is information.

Both changes follow the same principle: make the UI elements that convey game state visible enough to be useful. This is basic HUD design, but it is being done iteratively — ship, play, notice the crosshair is too small, make it bigger. Fast iteration on feel.

Fullscreen by Default

FULLSCREEN_MODE changed from false to true. The game now launches fullscreen. This is likely connected to the crosshair and preview size changes — testing in fullscreen reveals that HUD elements sized for a windowed mode are too small. The fullscreen default also suggests Notch was moving toward a more “game-like” presentation rather than a development tool.

Alpha Test Removal

The glAlphaFunc(GL_GREATER, 0.5) call is removed. This OpenGL function was used for alpha testing — discarding fragments with alpha below a threshold. It was necessary for bush rendering, where the bush texture had transparent regions. With bushes removed, the alpha test is unnecessary. Clean removal of a feature means clean removal of its rendering infrastructure.

setupOrthoCamera() Extraction

The orthographic camera setup code for HUD rendering (crosshair, block preview) is extracted into a named method setupOrthoCamera(). This is a cosmetic refactor: the code is identical, just moved into its own function for readability. It suggests Notch was cleaning up the main class as it grew, keeping the render method manageable by extracting coherent sub-operations.

What Did NOT Change

Twenty of the twenty-six files are byte-identical to rd-20090515:

• Level.java — terrain generation, random ticks, tile-aware queries, save/load: all unchanged.
• Entity.java, Player.java, Zombie.java — the entire entity system is unchanged.
• Timer.java — still 20 TPS.
• AABB.java — collision primitives unchanged.
• LevelRenderer.java, DirtyChunkSorter.java, Frustum.java, Tesselator.java — rendering infrastructure unchanged.
• PerlinNoiseFilter.java — terrain generation unchanged.
• GrassTile.java, DirtTile.java — grass spread/death and dirt tile unchanged.
• Vec3.java, Vertex.java, Polygon.java, Cube.java — character model system unchanged.
• HitResult.java, Textures.java, LevelListener.java — utilities unchanged.

The terrain still has Perlin noise hills. Grass still spreads in sunlight and dies in darkness. Zombies still wander the landscape. The 20 TPS tick rate still drives the simulation. Everything that was built yesterday carries forward, minus the pieces that were removed.

The Iteration Principle

rd-160052 is interesting not for what it adds but for what it reveals about Notch’s development process. In three days (May 13-15, 2009), the pattern was:

1. Day 1 (rd-132211, rd-132328): Build the foundation. Block world, player physics, entities.
2. Day 2 (rd-20090515): Expand aggressively. Terrain, tiles, particles, ticks. Nine new files.
3. Day 3 (rd-160052): Contract. Remove what did not work. Tune what did.

This is textbook rapid prototyping. Build fast, evaluate honestly, cut what fails. The bush tile was a reasonable experiment: can we have non-solid decorative blocks? The answer was “yes, but not yet” — the rendering was complex, the tick behavior was fiddly, and the core game loop did not need it. So it went.

The particle tuning tells the same story from a different angle. The age/lifetime system worked correctly but did not look right. The numbers were adjusted until destruction felt better. This is the kind of change that only happens when the developer is playing the game, not just writing the code. Heavier gravity, wider spread, random death: these are not bug fixes. They are aesthetic judgments, implemented as code changes.

The package rename back to com.mojang.rubydung is the most human touch. Yesterday, the project was Minecraft. Today, it is RubyDung again. Maybe the name felt presumptuous. Maybe it caused a technical issue. Maybe Notch just wanted to keep things humble while the code was still in flux. Whatever the reason, it is a reminder that software development is not a monotonic march toward completion. Sometimes you take a step back, look at what you built, and decide that some of it needs to go.

The version after this one will add new things. The version after that will add more. Bush tiles will return in a different form. The name Minecraft will return and stay. But rd-160052 is the version that established a principle: Minecraft would be built not just by addition, but by subtraction. The game that eventually shipped 300 million copies was not the game that kept every feature that was ever tried. It was the game that kept the right ones.

By the Numbers

Negative 175 lines. The game got shorter and arguably better. That is a lesson worth learning.