If x86 Is So Good, Why Hasn't Intel Made x87 Yet?

Level 1: The Joke That Answers Itself

Imagine someone standing in front of a bakery called "Bread 86," loudly asking, "If this bakery is so great, why haven't they opened Bread 87?" — while leaning directly against the front window of Bread 87, which has been open next door for forty-five years. Everyone walking by can see it. That's the whole gag: a question asked with total confidence whose answer is right there, and the fun is watching people in the know smile while everyone else hurries off to look it up.

Level 2: Chips, Coprocessors, and Why Math Was Extra

The pieces, decoded:

• x86: The processor architecture family powering most PCs and servers — the "language" of instructions those CPUs understand, descended from Intel's 8086 chip (1978). The name persists across decades of chips.
• x87: The floating-point extension to that family. Early CPUs could only do whole-number math quickly; decimal-heavy math (3.14159 * 2.5) needed a separate coprocessor chip — the 8087 — you literally bought and plugged in beside the CPU. Spreadsheet users paid extra for fast math.
• FPU (Floating-Point Unit): The circuitry doing decimal math. Since the 486 era it's built into the main CPU, but the old x87 instruction set still lives inside every modern chip for compatibility.
• SSE: The newer (2001+) instruction set that replaced x87 for floating point. Compilers today target SSE by default; x87 is the deprecated undead legacy path.
• The meme format: "If X is so good, why is there no X 2?" — a joke that pretends sequels are the only proof of quality. The punchline here is that the "sequel" predates most people reading the tweet.

If you're early-career, here's the relatable version: it's like asking "if utils.js is so good why is there no utils2.js" at a company where utils2.js was written before you were born, is imported everywhere, and nobody is allowed to delete it.

Level 3: The Sequel That Shipped in 1980

"If x86 is so good why hasnt intel made x87 yet"

The tweet runs on the "if X is so good, why is there no X 2" shitpost template — the format usually deployed against the Bible or World War I — but weaponizes a numbering coincidence: x86's successor-sounding name, x87, already exists and has since the Carter administration. The 107.2K views are the tell that this landed precisely in the sweet spot of meme literacy and instruction-set archaeology.

What experienced engineers savor here is the layered irony. First, x87 isn't a sequel — it's a sidecar, the floating-point companion architecture that x86 has dragged along like a haunted family heirloom. Second, the deadpan "why hasnt intel made" implies Intel has been slacking, when Intel's actual problem is the opposite: it cannot stop making x87. Every new core, every die shrink, every architecture refresh must faithfully reproduce a 1980 coprocessor's stack machine so that some accounting package compiled in 1994 still runs. The meme accidentally states the deepest truth about x86: its dominance and its damnation are the same property — backward compatibility as an unbreakable vow.

Third, there's the naming-scheme comedy. "x86" itself is a retroactive pattern (8086, 80186, 80286, 80386...), so "x87" reads as both "the next x86" and "the 8087 family" simultaneously — the joke only works because Intel's part-numbering created a namespace collision four decades ago. It's the hardware equivalent of asking why there's no library2 when library2 is sitting right there in the dependency tree, deprecated, unremovable, and load-bearing. The shitpost format does what a lecture on ISA evolution never could: it makes ten thousand people google "x87" and discover the FPU skeleton in the closet.

Level 4: Eighty Bits of Regret

The cruelest layer of the joke is that x87 isn't just real — it's a masterclass in how instruction-set decisions calcify into half-century commitments. The Intel 8087 (1980) was a separate coprocessor chip you socketed next to your 8086 to accelerate floating-point math, designed in part by William Kahan, the architect of what became IEEE 754. Its signature choices: a stack-based register model — eight registers ST(0)–ST(7) accessed like a Forth machine, push, pop, operate-on-top — and 80-bit extended precision, computing internally with more bits than the 32/64-bit formats you stored.

Both choices became legendary footguns. The stack architecture made register allocation a compiler-writer's nightmare (you can't just name a register; you choreograph a stack), and FXCH shuffling became its own optimization genre. The 80-bit registers caused the infamous excess-precision nondeterminism: a double kept in a register held 80 bits, but spilling it to memory rounded it to 64 — so the same arithmetic produced different results depending on compiler register pressure, optimization level, or an unrelated code change. Numerical code that compared results across builds, or games doing lockstep simulation across machines, broke in ways that felt supernatural. -ffloat-store, /fp:strict, and a thousand forum threads exist because of this. SSE2 (2001) finally offered flat registers with strict 64-bit semantics, and compilers fled x87 en masse — yet every x86-64 chip Intel ships today still implements the full x87 state, FSAVE layouts and all, because backward compatibility is the one instruction x86 has never deprecated.