Every so often the underdog in a two-horse race doesn't just win a round. It decides what the race is. That's the story of AMD64.
At the end of the 1990s, everyone agreed the PC needed 64 bits. A 32-bit processor can address 4 GB of memory, and servers were running into that ceiling. Intel had a plan, and it was enormous. AMD had a smaller plan. The smaller plan won, and every x86 server and desktop sold today, Intel's included, runs AMD's design.
Intel's plan: start over
Intel and HP had been working since 1994 on a new architecture, IA-64, sold as Itanium. It was a clean break. Instead of x86's decades of accumulated instructions, it used a design called EPIC, in which the compiler, not the processor, worked out which instructions could run in parallel and bundled them together. In theory that made the hardware simpler and faster. In practice it depended on compilers that never got as good as the theory needed.
Itanium couldn't run x86 software natively either. Early chips had a hardware x86 mode so slow that it was mostly a checkbox, and later chips dropped it for software emulation. Itanium shipped in 2001, late, expensive and slower than promised. The industry press nicknamed it "Itanic."
AMD's plan: extend what works
AMD announced its alternative in 1999 and published the specification in 2000. The idea was almost cheeky in its simplicity: keep x86, and widen it.
- Long mode. A new 64-bit operating mode, with a compatibility submode so 32-bit programs run unmodified, at full speed, under a 64-bit operating system.
- Sixteen general-purpose registers instead of eight. For x86, which had always been starved for registers, this was arguably a bigger performance win than the extra bits. Recompiled code got faster just by keeping more in registers instead of memory.
- 64-bit pointers and a flat address space. The architecture allows 64-bit virtual addresses, though the first chips implemented 48 bits: 256 terabytes, which seemed infinite at the time.
- The NX bit. Memory pages could be marked non-executable, which shut down a whole class of buffer overflow attacks that relied on running code from the stack. AMD marketed it as "Enhanced Virus Protection."
- Cleanup. Segmentation was mostly retired in 64-bit mode, and SSE2 became the baseline for floating point, so compilers could finally stop using the old x87 stack.
The first AMD64 processor, the Opteron server chip, launched on April 22, 2003. The Athlon 64 desktop chip followed that September.
Linux got there first
Linux supported AMD64 before there was any hardware to run it on. SUSE engineers ported the kernel and toolchain in 2001 using a software simulator, so on launch day a 64-bit Linux distribution was ready to install. Microsoft's 64-bit Windows XP Professional x64 Edition didn't ship until April 2005.
That head start mattered. Opteron's first big market was Linux servers and clusters, where buyers could recompile everything and wanted the memory. By the time Windows caught up, AMD64 had already proved itself in data centers.
Intel concedes
The moment the story turned was in 2004, when Intel shipped Xeon processors with an extension it called EM64T. It was AMD64, implemented under a cross-licensing agreement and given a different name. Intel later called it Intel 64. Microsoft had reportedly told Intel it would support one 64-bit x86 extension, not two, and AMD's was already shipping.
Itanium carried on in high-end HP servers for years, kept alive mostly by contracts. Intel shipped the last ones in 2021. Linux removed IA-64 support entirely in kernel 6.7, released this January, after nobody could be found to maintain it.
This is why your Linux distribution calls its x86 packages amd64, even when they run on an Intel chip. Debian named the architecture after its designer, and Debian doesn't rename things to make anyone feel better.
What AMD64 means today
Twenty-one years on, AMD64 is still the instruction set of almost every server, desktop and laptop that isn't ARM. It has grown a lot on top of the 2003 baseline: virtualization extensions, AES instructions, AVX vector units up to 512 bits, and five-level page tables that stretch the address space to 57 bits.
That growth created a practical problem. A binary built for "x86-64" can only assume the 2003 baseline, which leaves most of a modern CPU unused. So in 2020 the major vendors and toolchains agreed on microarchitecture levels:
- x86-64-v1: the original 2003 baseline.
- x86-64-v2: adds SSE4.2, POPCNT and friends, roughly 2009 hardware.
- x86-64-v3: adds AVX2 and FMA, roughly 2013 to 2015 hardware.
- x86-64-v4: adds AVX-512.
Distributions now pick a level. RHEL 9 requires v2, so it won't boot on some old hardware that every other distribution supports. You can check your own machine with /lib64/ld-linux-x86-64.so.2 --help, which lists the levels your CPU supports.
Intel also proposed X86S last year, a slimmed-down x86 that would boot straight into 64-bit mode and drop the 16-bit and 32-bit operating system modes that every PC still carries for compatibility with the 1980s. Whether that happens, and who gets to decide, is an interesting question when the architecture belongs to two companies.
The lesson
Itanium was the better design on paper. AMD64 was the one that ran the software people already had. That's the lesson the industry keeps relearning: compatibility beats elegance almost every time. The other lesson is that one company owning the direction of an architecture is fragile. Its competitor might ship the next version first.
Since then
Added October 2026. The question of who decides got answered quickly. In October 2024 Intel and AMD formed an x86 Ecosystem Advisory Group together with Microsoft, Google, Red Hat and others, and in December Intel dropped X86S. Changes to x86 now go through a joint process. Red Hat Enterprise Linux 10, out in 2025, moved its baseline up to x86-64-v3.