It started with a problem.

3D gaming in the late 1990s was a war against hardware. Developers at id Software — the studio behind Doom, Quake, and some of the most technically ambitious games ever made — were constantly running into the same wall. The CPUs and GPUs of the era simply couldn't keep up with what game engines demanded.

Quake III Arena, released in 1999, was pushing real-time 3D rendering further than anything before it. Smooth surfaces. Dynamic lighting. Fast, fluid movement at framerates that felt impossible on the hardware of the time.

To render a 3D world convincingly, an engine needs to calculate how light bounces off surfaces millions of times per second. That requires a specific mathematical operation — the inverse square root. Simple in theory. Brutally slow in practice, at least on late 90s silicon.

The traditional method worked. It just wasn't fast enough.

Then someone wrote this.

When id Software open-sourced the Quake III engine in 2005, developers and mathematicians got their first look inside one of the most celebrated game engines ever built. Buried in the code was this:

// what the f***?

Nobody knew where 0x5f3759df came from. Nobody could fully explain why it worked. And yet it produced an approximation of the inverse square root that was accurate enough for real-time rendering — and three to four times faster than anything Intel's own math library could manage at the time.

"The gaming world ran on it for years without fully understanding it."

The mystery of the magic number.

The number 0x5f3759df is written in hexadecimal — the numerical language of computer processors. Convert it to decimal and you get 1,597,463,007. It appears arbitrary. It isn't.

What the code does is exploit the way floating point numbers are stored in memory — a format defined by the IEEE 754 standard. By reinterpreting the binary representation of a floating point number as an integer, performing a bit shift and a subtraction with this specific constant, and then reinterpreting the result back as a float, the code produces a remarkably close approximation of the answer in a single pass.

It then runs one iteration of Newton's method — a classical mathematical refinement technique — to clean up the approximation further.

The result is fast enough to run millions of times per frame. Accurate enough to make lighting look right. And elegant enough that mathematicians spent years reverse-engineering exactly why that constant was chosen.

The best explanation, worked out years after the fact, is that 0x5f3759df is the closest integer approximation to a specific mathematical constant derived from the properties of the IEEE 754 format itself. Whoever chose it either derived it analytically — which would be extraordinary — or found it through empirical testing, tweaking values until the error was minimised.

We still don't know which.

Who wrote it?

This is where the story gets murky. When the Quake III source code went public, the function was attributed to id Software — but nobody inside id claimed to have written it. John Carmack, id's legendary lead programmer, said it wasn't his. Others pointed to a developer named Terje Mathisen, who had written something similar years earlier. Some traced it further back to Gary Tarolli at 3dfx.

The true origin has never been definitively confirmed. It remains one of the most debated questions in computing history — a piece of code so clever that nobody wanted to take credit for it, or perhaps nobody remembered writing it.

What we know is that it shipped in one of the most important game engines ever built. And it worked.

Why it still matters.

Modern GPUs handle inverse square root calculations in dedicated hardware. The hack is no longer necessary — your graphics card does in silicon what this code did in software, and it does it faster.

But the Fast Inverse Square Root endures as something more than a technical curiosity. It represents a particular kind of engineering thinking — one that refuses to accept hardware limitations as fixed, that looks for unconventional solutions when the obvious path is too slow, and that prioritises performance with an almost obsessive precision.

That thinking built the foundation of modern PC gaming. The framerates, the visual fidelity, the responsiveness that enthusiasts demand from their setups today — it has roots in moments like this one. A line of code, a mysterious constant, and a comment that asked the only reasonable question.

What the f**?*