Quake: The Engine That Ate the Industry

Quake is a worse game than Doom. I’ve believed this for twenty-five years and I’ve never met a persuasive counter-argument. The levels are murkier and less legible, the enemy roster is thinner, the weapons have less personality, the fiction is an incoherent pile of Lovecraft and medieval stonework and military bases that never resolves into a place, and it is brown in a way that even 1996 noticed.

It is also, by a distance, the most consequential thing id Software ever shipped. That gap — a mediocre game carrying a world-altering piece of software — is the whole story, and it’s why Quake is worth revisiting as an object lesson rather than an evening’s entertainment.

The game id didn’t make

The record here is unusually well documented, because the people involved have talked about it for decades. Quake was supposed to be something else: an ambitious action-RPG built around a character with a hammer, a big open thing, the game id’s designers had been describing to the press for two years. What shipped in June 1996 was a first-person shooter with four episodes, because the engine work consumed the schedule and the team scaled the design back to something the technology and the calendar could actually deliver.

You can feel the retreat in the finished product. The four episodes have no relationship to each other. Sandy Petersen’s Lovecraftian material — he wrote the Call of Cthulhu tabletop game, so this was his home turf — sits next to base corridors that look like a different project entirely. There’s a hub with slipgates, which is a structural device that exists to explain why the levels don’t connect. Romero left id after it shipped.

So: a compromised game. And then the compromise turned out to be irrelevant, because of what was underneath.

What Carmack actually built

Three things, and they each ate a piece of the industry.

True 3D. Doom’s engine was a floorplan with heights — no room over room, no looking up. Quake is genuine polygonal geometry with six degrees of freedom. You can look up. You can jump. Rooms can stack. The immediate cost was legibility: designers lost the readable floorplan overnight and spent the next decade rediscovering how to make a 3D space navigable without it. The immediate gain was that every shooter after 1996 had to be this or be a period piece.

Precomputed lighting and visibility. The parts nobody outside the trade talks about and the parts that made it run. Lightmaps baked the lighting into the level at compile time, which is why Quake’s rooms have soft shadow gradients that no real-time technique of the era could touch. Potentially visible sets precomputed, for every region of the map, which other regions could possibly be seen from it — so the renderer could discard most of the world before it drew a triangle. That combination is why a 1996 Pentium could hold a framerate in a fully three-dimensional space, and the approach outlived the engine by twenty years.

Client-side prediction. Quake shipped with internet play that was, over a modem, close to unusable — every input had to round-trip to the server before your own character moved. QuakeWorld arrived at the end of 1996 and changed the model: your client predicts your movement locally and reconciles with the server afterwards. That single idea is the foundation of every online action game since. Everything you know about netcode, lag compensation and rollback descends from it.

QuakeC is the real bomb

Here’s the part I’d put above all of it. id had already shipped an open level format with Doom, which is why the community map scene exists — the argument in the shareware model and how Doom spread. Quake went further and shipped QuakeC: an interpreted scripting language, running in a VM, that controlled the game’s actual logic. Weapons, monster behaviour, physics rules, the win conditions. All of it, editable, by anyone, with no compiler and no source licence.

Nobody had done this. Modding before Quake meant new levels and new sprites — new content inside somebody else’s rules. QuakeC meant new rules. And what came out of it inside eighteen months is genuinely absurd: Threewave CTF, which invented the modern flag mode; and Team Fortress, built by a few Australians as a QuakeC mod, which invented the class-based shooter and eventually turned into a Valve franchise and a business model.

Think about the mechanism there. id gave away the game’s design as an editable text file, and the community used it to invent two entire genres that id itself had not thought of, for free, on a fan’s timescale. That’s the argument for open toolchains in its most extreme form, and the industry’s response over the following twenty years was to gradually take the toolchain away again.

The rocket jump, and physics as expression

The other thing Quake accidentally gave away was its physics.

Rockets do splash damage. Splash damage applies force. Force applies to you. Therefore: fire a rocket at your own feet, take the damage, and go somewhere the level designer did not intend. Nobody wrote that. It’s a consequence of three rules interacting, and within months it was the defining skill of competitive play — a whole movement vocabulary, then strafe-jumping and bunny-hopping on top of it, all of them emergent from a physics implementation that was arguably slightly wrong.

id’s decision, which I think is the single most tasteful call in the game’s history, was to leave it in. They looked at players exploiting an unintended interaction to do something beautiful and difficult, and declined to patch it. The entire arena-shooter lineage runs from that restraint, and the demoscene-adjacent culture that grew up around it — the speedruns, the movement recordings, the competitive replays traded as files — is the same energy the demoscene’s long shadow over game design tracks in the European scene.

GLQuake sold the graphics card

One more consequence, and it reshaped an entire hardware market. Quake shipped with a software renderer — Carmack and Michael Abrash grinding assembly to make a Pentium draw a 3D world. Then in early 1997 id released GLQuake, an OpenGL build, and the difference on a 3dfx Voodoo card was not subtle. Bilinear filtering instead of chunky texels, coloured lighting, a clean framerate at a resolution the software renderer couldn’t dream about.

What that did commercially is the part worth noticing. Consumer 3D accelerators existed before GLQuake and nobody could explain to a normal person why they’d want one. GLQuake was the explanation. It was free, it ran a game everyone already had, and the improvement was visible from across a room. A generation of people bought their first graphics card to run one id build better, and the add-in 3D board went from an enthusiast curiosity to a standard PC component in about two years.

That’s a game developer setting hardware strategy for an industry that hadn’t asked. It kept happening for a decade.

The licensees

The engine got sold, and the list of what came out of it is the actual thesis of this piece.

Raven built Hexen II on it. Valve licensed it, rebuilt large parts, and shipped GoldSrc — which is to say Half-Life, the game that took id’s technology and used it to make an argument id had no interest in making, and then became the foundation of Steam. The Quake II engine went out to a dozen studios. id Tech 3 followed and ended up, through a chain of licences and derivations, underneath a substantial chunk of the military shooters that dominated the next fifteen years.

And then id open-sourced the lot — Quake’s engine in 1999, Quake II’s in 2001 — which is why source ports still exist, why the game runs on your phone, and why a 1996 codebase is still a teaching text.

That’s what I mean by eating the industry. Quake the game is a curiosity. Quake the platform is the substrate a decade of the medium was built on.

Where to play it

The 2021 remaster is the right entry point: it’s the original with the compatibility solved, the expansions and some new episodes included, and it’s on everything. If you want the historical artefact, a source port with the original WADs is trivial to set up and closer to what 1996 looked like.

Play episode one, play some deathmatch on the old maps if you can find bodies, and pay attention to the lighting rather than the brown. The shadows are the thing that made people’s jaws drop, and they still read.

Spoilers below

The story, such as it is: you’re Ranger, sent through a slipgate to stop an enemy codenamed Quake. Four episodes, four runes, one final door.

The boss is where the compromise becomes visible to the naked eye. Shub-Niggurath — Petersen’s Lovecraft import, an enormous pulsing mass in a chamber at the end of the game — cannot be shot. Your entire arsenal does nothing. The solution is to wait for a telefragger pad to activate, step into the teleporter at the right moment, and get teleported into Shub-Niggurath, which kills her via the telefrag rule: two entities in one space, one dies.

I have a lot of affection for this and I won’t pretend it’s good. The final encounter of the most technologically important game of the decade is solved by exploiting an edge case in the multiplayer collision code. You never really fight her. There’s a timing puzzle, a rules technicality, and then a text screen.

But look at what it reveals. Even id’s own designers, at the end of a brutal schedule, reached for the physics rather than authoring a set-piece — because the physics was the only part of Quake that was finished. The ending is the whole game in miniature: a thin piece of design sitting on top of a system so strong that people would spend a decade finding better uses for it than its authors did.

Doom was a game. Quake was infrastructure with a game attached, and the infrastructure is what we’re all still standing on.