The Clean Break the Industry Declined

The world it was born into

By the early 1990s Intel’s x86 architecture, dating from 1978, ran most of the world’s personal computers. It was also old and complicated, carrying the accumulated decisions of many generations. Servers and workstations increasingly needed 64-bit processors, able to address large amounts of memory, and that market was served by architectures from other companies, including HP’s own PA-RISC.

Processor designers were wrestling with a fundamental question: how to make processors execute more instructions at once. One approach, used in the most advanced chips, put complex circuitry on the chip to find independent instructions and run them in parallel, reordering them on the fly. Another approach, explored in research including at HP’s laboratories, moved that job to the compiler: the compiler would analyse the program in advance and package instructions explicitly for parallel execution, so that the chip could be simpler and faster. This was known as very long instruction word, or VLIW, design.

The bet

In 1994 Intel and HP announced a partnership to build a new 64-bit architecture based on these ideas. They called the approach explicitly parallel instruction computing (EPIC); the architecture became IA-64 and the processors Itanium. The bet was that a clean design, freed from x86’s legacy and relying on clever compilers, would deliver performance that the old architecture could not match, and would become the industry’s standard for 64-bit computing, first in servers and eventually everywhere.

Much of the industry signed on. Operating system vendors, server makers and software companies announced support. Analysts produced very large forecasts; trade press reports later recalled IDC projections of tens of billions of dollars in annual Itanium server sales.

Why it made sense

The reasoning was respectable. x86’s complexity was real, and many engineers believed it would eventually limit performance. Research results for compiler-driven parallelism were promising. Intel dominated the processor market and HP brought research depth and a server business. Starting fresh was the kind of bold move that had sometimes paid off in computing.

How it lost

The first Itanium shipped in 2001, years after the original target. Its performance was disappointing, and it ran existing x86 software through a compatibility mechanism that was much slower than a real x86 chip. The compiler problem proved harder than hoped: real programs, with unpredictable branches and memory access patterns, gave compilers less parallelism to find than research benchmarks had suggested. Meanwhile, conventional processors that found parallelism in hardware kept improving.

In 1999 AMD, Intel’s much smaller rival, announced a different approach: extend x86 itself to 64 bits, keeping full compatibility with existing software. Its Opteron processor shipped in 2003. It ran old 32-bit software at full speed and new 64-bit software well. Major operating systems added support. Customers who had decades of investment in x86 software could move to 64 bits without leaving anything behind.

In 2004 Intel announced its own compatible 64-bit extension to x86. From then on, Itanium was confined to a niche, mainly high-end HP servers. Software support thinned: Microsoft announced in 2010 that it would end Windows development for Itanium; Oracle’s decision in 2011 to stop developing for it led to a lawsuit that HP won in 2012. Intel took its final orders in 2020 and made its last shipments in 2021. The trade press had long since nicknamed the chip “Itanic”.

Explaining both the same way

It is easy to say the better architecture lost to the compatible one, or that the arrogant leader lost to the nimble follower. A symmetrical account asks what each design optimised for. IA-64 optimised for peak performance from a clean design, assuming that compilers could do the hard work and that customers would recompile. x86-64 optimised for continuity, assuming that customers valued their existing software above all. In the event both assumptions about customers were tested, and continuity won decisively, as it has in almost every platform contest described on this site.

The compiler question also deserves symmetry. Hardware approaches to parallelism won partly because they adapted to programs as they actually ran, while compilers had to guess in advance. The research was not wrong; it was right for some kinds of programs and less right for the messy ones that dominate real workloads.

What the loss teaches

Itanium is the most expensive demonstration on this site of path dependence and the compatibility gravity pattern. A clean break must pay for every customer’s cost of switching, and those costs are almost always larger than the designers estimate.

It also shows how coalitions and forecasts can sustain a commitment past its evidence. Public support from many partners and confident analyst projections made the strategy look stronger than the market data. Once many large companies had committed publicly, each had reasons not to be the first to say otherwise, a structural version of groupthink.

Sources and limitations

Forecast figures are taken from trade press accounts of IDC projections; the original reports were not consulted directly, and the press coverage, especially The Register’s, was critical of Itanium. Technical descriptions draw on Intel and HP’s published architecture paper and standard textbooks. Dates for the end of Itanium are from Intel’s announcements as reported. The judgement that compatibility decided the contest is widely shared among historians of computing, but performance, pricing and delays also mattered.