The Classic Arrives: Analyzing Minecraft c0.30_01c

Seven months of silence. 181 files. The browser game the world remembers.

On December 21, 2009, Notch released Minecraft Classic c0.30_01c. The last version we analyzed was c0.0.13a_03, from May 21, 2009. Seven months separate them. In software development terms, seven months is a geological epoch. In Minecraft development terms — where Notch was shipping daily builds in May — seven months is an eternity.

The numbers tell the story. c0.0.13a_03 had 44 files and roughly 4,700 lines of code. c0.30_01c has 181 files and approximately 16,500 lines. That is a 3.3x growth in code volume and a 4.1x growth in file count. This is not incremental evolution. This is a different program wearing the same name.

c0.30_01c is Minecraft Classic — the free, browser-playable version that introduced millions of players to the game. It ran as a Java applet in a web browser, connected to multiplayer servers, and let players build with a palette of blocks that included sand, gravel, ores, logs, leaves, sponge, glass, and fourteen colors of wool. If you played Minecraft in a browser in 2009 or 2010, this is what you played.

The Block Explosion

The tile registry in c0.0.13a_03 had 12 block types (IDs 0 through 11). c0.30_01c has over 40. The new blocks fall into several categories.

Natural materials. Sand (ID 12) and gravel (ID 13) are the first blocks with gravity. In the Java source, both have a onBlockAdded check that tests whether the block below is air. If it is, the block converts into a falling entity — a non-block object that obeys gravity, drops through air, and converts back into a block when it lands on something solid. This is Minecraft’s first physics-driven block behavior. Every previous block was static once placed. Sand and gravel move.

Ores. Gold ore (ID 14), iron ore (ID 15), coal ore (ID 16). Three block IDs with distinct textures on the terrain atlas, placed by the terrain generator within stone below a certain depth. They are purely decorative in Classic — there is no smelting, no crafting, no inventory beyond the block palette. But the ore textures are iconic. The dark speckles of coal ore, the tan flecks of gold ore, the salmon-pink of iron ore against grey stone. These textures persist through a decade of updates.

Trees. Log blocks (ID 17) and leaf blocks (ID 18). Logs have per-face textures — the first block in Minecraft to render different textures on different faces. The top and bottom faces show the circular cross-section of a tree trunk. The four side faces show bark. This requires the texture lookup in the chunk mesher to accept a face parameter, breaking the one-texture-per-block assumption that every previous version relied on.

Leaves are transparent. Like glass (ID 20), leaf blocks are rendered with face culling modified so that faces between two leaf blocks are still drawn — unlike solid blocks, where shared faces are hidden. Without this, a tree canopy would be a solid green cube with no interior visible. With it, you can see through gaps in the foliage. Leaves also have a decay mechanic in later versions, but in Classic they are static.

Sponge. Block ID 19. Sponge absorbs water within a radius when placed. In the Java source, placing a sponge removes all water blocks within a 5-block taxicab distance. Removing the sponge does not restore the water. This is Classic’s only block with an active effect on adjacent blocks beyond gravity.

Glass. Block ID 20. Transparent, non-solid for rendering purposes (faces between glass blocks are rendered, not culled), but solid for collision. Glass is the first block that is physically solid but visually transparent. The rendering pipeline must handle this — glass blocks need to be drawn after opaque blocks to avoid depth buffer artifacts, or the transparency will not composite correctly.

Colored wool. Block IDs 21 through 34. Fourteen colors: white, orange, magenta, light blue, yellow, lime, pink, gray, light gray, cyan, purple, blue, brown, green, red, black. Each color is a separate block ID with its own texture index on the terrain atlas. Fourteen block IDs consumed by a single material in different colors. This is the most palette-efficient approach — one ID per color, no metadata system needed — but it is also the most ID-hungry. The wool blocks are why Classic’s block ID space fills up so quickly.

The Mob System

c0.30_01c introduces entities that are not the player. The mob system adds a class hierarchy rooted in Entity, with subclasses for different creature types. The architecture follows the pattern established by the player entity: position, velocity, bounding box, physics update per tick. But mobs add autonomous behavior — movement AI, pathfinding, model rendering, and (for hostile mobs) attack logic.

The mob models are built from cuboid parts. A humanoid mob has a head, body, two arms, and two legs, each a rectangular box with texture-mapped faces. The model is assembled from these parts with joint positions, and animation is achieved by rotating parts around their joints — arms swing, legs walk, heads turn. The model system is Minecraft’s first skeletal animation, primitive by 3D standards but effective at the game’s blocky resolution.

Mobs in Classic are limited. There are no hostile mobs that deal damage. The creatures that exist are primarily visual — they wander, they animate, they populate the world. But the infrastructure for hostile mobs is present: health systems, damage application, death and respawn. Classic is the scaffold on which survival mode will be built.

Sound: Paul Lamb and Vorbis

c0.30_01c adds sound. The audio system uses the Paul Lamb SoundSystem library (paulscode.com), a Java audio library that handles OpenAL and JavaSound backends. Sound files are in Ogg Vorbis format, loaded from the JAR or downloaded from resources.minecraft.net at runtime.

The sound system integrates positional audio — sounds have a source position in 3D space, and the listener position (the player’s camera) determines volume and stereo panning. Block placement makes a sound. Block breaking makes a sound. Footsteps make a sound. The world, which has been silent for every previous version, now has an audio landscape.

The sound infrastructure is substantial: audio buffer management, streaming for long-playing sounds (music), resource downloading, format decoding. It touches the game loop (sounds must be updated per frame), the block interaction code (events trigger sounds), and the entity system (footsteps, mob sounds). It is deeply integrated, not a bolt-on.

Multiplayer

The largest new subsystem by file count is networking. c0.30_01c is a multiplayer game. Players connect to servers, see each other’s block placements in real time, and share a persistent world.

The networking protocol is custom TCP. Packets have type bytes, fixed-length payloads, and cover: player position updates, block change events, chat messages, player join/leave notifications, level data transfer (the server sends the entire level as a gzipped byte array on connect), and server metadata (name, MOTD, player count).

The multiplayer code spans dozens of files: packet definitions, connection management, player list rendering, chat GUI, server browser, authentication against minecraft.net. It is the single largest subsystem in c0.30_01c by volume, and it is entirely absent from every previous version we have ported. This is not an incremental addition. This is a from-scratch networked game architecture layered on top of the existing single-player engine.

Arrows and Items

Arrows exist as entities — projectiles that are created on player input, travel through space with physics (gravity, drag), and embed in blocks on collision. They are the first non-block, non-mob entity. The arrow entity has its own rendering (a thin textured quad oriented along its velocity vector), its own physics (ballistic trajectory with air resistance), and its own collision detection against both blocks and entities.

The item system exists in embryonic form. The player has a block palette — a hotbar of available block types — rather than an inventory. There is no crafting, no item entities on the ground, no equipment. The palette is a fixed set of all available block types, selectable by scrolling or number keys. This is the creative mode interface that will persist through many future versions.

The Terrain Atlas Grows

The terrain.png atlas expands significantly. New texture indices cover every new block type. The atlas layout remains a 16×16 grid of 16×16-pixel tiles, but the occupied cells have grown from roughly a dozen to over forty. Log blocks occupy two texture indices (top and side). Each wool color occupies one index. Ores each have their own index. The atlas is becoming crowded.

By the Numbers

What c0.30_01c Represents

This is the version that defined Minecraft for its first wave of players. Not the survival game with creepers and crafting — that came later. This is the creative sandbox: an infinite palette of blocks, a generated landscape, and the freedom to build anything. It ran in a browser. It was free. It was the entry point.

The seven-month gap between c0.0.13a_03 and c0.30_01c is the gap between a tech demo and a product. The tech demo had terrain, basic blocks, a player, and physics. The product has sound, multiplayer, mobs, dozens of block types, a GUI system, network authentication, and a resource downloading pipeline. Notch did not iterate from one to the other in small steps — or if he did, the intermediate versions are not preserved in the version manifest. What we have is before and after: 44 files and 181 files, 4,700 lines and 16,500 lines, a single-player experiment and a multiplayer game.

For this project, c0.30_01c is the largest single-version jump we have encountered. The 3.3x code growth means the analysis surface has tripled. The three entirely new subsystems (sound, networking, mobs) each represent architectural commitments that will persist through hundreds of future versions. The block type explosion means the tile system must scale from “enumerate every block” to “categorize blocks by behavior.”

Minecraft Classic is here. The browser game that started it all. The codebase has crossed a threshold from “small enough to hold in your head” to “large enough to require architecture.” Everything from here gets bigger.