Four Decades of Accretion

assembly1-1 named x86-64 as the architecture carrying "four decades of backward-compatible accretion," and cpu8bit1-11 closed its own course by naming the Z80's own richness as a preview, at 1976 scale, of exactly this. This chapter is where that promise gets cashed in — the real lineage from a 1978 chip to the architecture running underneath the device this page is being read on, and the single strangest, most concrete fact about it: the CPU never really let go of anything it used to be.

The Lineage — 8086 to x86-64

The whole story starts with the Intel 8086 (1978) — a 16-bit processor, and the direct ancestor of every chip this course covers. It wasn't binary-compatible with the 8080 the way cpu8bit1-5's own Z80 was, but it was deliberately designed so 8080 assembly programs could be mechanically translated into 8086 assembly — the same 8080 lineage cpu8bit1-5 traced through Zilog, now showing up on Intel's own side of the family tree.

• 80286 (1982) — introduced the first, limited version of protected mode, a genuinely new concept this course previews below and covers fully in assembly2-8.
• 80386 (1985) — the big one: a full 32-bit extension (often called IA-32), with complete protected mode and paging. This chip anchored the dominant x86 era for the better part of two decades — "386" became informal shorthand for the entire 32-bit generation.
• Pentium and its successors (1990s–2000s) — continued the 32-bit era while adding the vector-instruction extensions assembly2-9 previews (MMX, and later SSE).
• AMD64 / x86-64 (2003) — the 64-bit extension this entire course is actually about.

Why AMD, Not Intel

Here's the genuinely surprising part: the 64-bit extension to x86 wasn't Intel's idea. Intel's own answer to 64-bit computing was Itanium (IA-64) — a completely new, non-backward-compatible architecture, built from scratch rather than extended from the existing x86 lineage. AMD took the opposite approach: extend the existing, familiar x86 instruction set with 64-bit capability while keeping everything that already worked, working. AMD's approach — AMD64 — won out commercially, and Intel eventually licensed and adopted AMD's own compatible design, selling it under the name Intel 64 (formerly branded EM64T). This is one of the rare, well-documented moments where AMD, not Intel, set the direction the entire industry actually followed.

Real, Protected, and Long Mode — A First Preview

A modern x86-64 CPU doesn't just run in one mode — it can actually behave like several different, much older CPUs, on demand, because the hardware never removed the old behavior when it added new capability:

• Real mode — the original 16-bit, 8086-compatible mode. Every x86-64 PC, including one built this year, literally boots into real mode first, behaving exactly like a 1978 8086, before the operating system switches it into a newer mode.
• Protected mode — the 32-bit mode introduced by the 80286/80386, with real memory protection.
• Long mode — the 64-bit mode this course is actually about, where the registers, addressing, and instructions covered from assembly2-2 onward actually apply.

That boot-time detour through real mode isn't a quirky edge case — it's "four decades of accretion" made completely literal. The chip can still pretend to be its own 1978 ancestor, on command, because nothing from that era was ever actually deleted.

Why This Matters for the Rest of the Course

Every register name, every addressing mode, every instruction covered from here forward exists inside layers of decisions this lineage produced. cpu8bit1-2 and cpu8bit1-5 traced the 6502 and Z80 back to two clean founding constraints, each a single, coherent story. x86-64 doesn't have one story — it has five decades of stories, each one built on top of the last without erasing it. That's the shape this entire course is going to keep tracing, one concrete feature at a time.

Hands-On Exercises