How Intel, Microsoft, and Linux Took Down the UNIX Server Kingdoms

If you walked into a large company’s data center in 1992, you were looking at machines from Sun Microsystems, IBM, Hewlett-Packard, or Silicon Graphics. Each one sold you a closed stack, their own RISC processor, their own flavor of UNIX, their own support contract. Sun ran SPARC chips and Solaris. IBM ran POWER chips and AIX. HP ran PA-RISC and HP-UX. Silicon Graphics ran MIPS chips and IRIX. These systems ran into the hundreds of thousands of dollars, and once you bought one you were locked in, because moving your software to a rival’s proprietary UNIX was close to impossible. Buy in, get stuck.

These machines were genuinely good, which matters for the whole story. RISC chips, reduced instruction set designs that did fewer things but did them fast, held real performance leads for years. The UNIX variants running on them were mature, scaled to dozens of processors, and ran the databases and transaction systems that banks, airlines, and telecoms could not afford to have fall over. This was not a case of a bad incumbent getting what it deserved. The best engineering in the market was sitting inside these boxes.

That whole arrangement looked permanent. Within about 13 years it was mostly gone. I want to walk through why, because the story has three main characters, Intel, Microsoft, and Linux, and each of them wanted something different out of the same transition. Intel wanted to sell more chips. Microsoft wanted to own the server operating system. Linux wanted nothing, which is part of why it won.

Intel had a playbook and wanted to run it again

Intel had already won the desktop. The way it won matters, because it tried the exact same move on servers. High sales volume on PC chips improved its semiconductor yield. Better yield cut costs, which raised profit, which threw off cash it plowed back into better factories. That flywheel gave Intel a manufacturing lead that AMD and Cyrix could not match. By the mid 1990s Intel looked at the enterprise server market, saw machines selling for 100 times the price of a PC, and decided its volume economics could grind that market down too.

The math behind that confidence is the engine of the whole story. A chip costs a fortune to design and a fortune to build a factory for. After that, each additional chip off the line costs almost nothing. Sun shipped SPARC chips in the tens or hundreds of thousands per year. Intel shipped x86 chips in the tens of millions. Spread those enormous fixed costs over 100 times the units and your per chip cost collapses, which funds the next factory, which widens the lead again. A proprietary RISC vendor could out design Intel on any given year and still lose, because it could never match Intel on cost per transistor. That gap only grew as chips got more expensive to make.

The problem was that Intel made chips, not systems. To get into servers it needed an operating system that ran on its hardware and that corporate buyers trusted. In 1993 that pointed straight at Microsoft and a brand new product called Windows NT.

Windows NT was built from scratch for this

Regular consumer Windows in that era was a graphical shell sitting on top of MS-DOS, held together with tape. NT was different underneath. A team led by Dave Cutler, who had built VMS at Digital, wrote NT from the ground up for workstations and servers. Microsoft sold it on reliability, security, and real multitasking, the things enterprise buyers cared about.

The first version, NT 3.1, shipped in 1993 and ran on the Intel 386. It worked, but it did not light the world on fire. It was immature next to IBM’s OS/2, Novell’s NetWare, and the established UNIX variants, and it demanded 16 megabytes of RAM, which was a lot in 1993. NT Server sold modestly that first year. Microsoft kept grinding, the way it tends to, shipping new features and new versions and slowly wearing the competition down. Sales roughly tripled the next year, still trailing the UNIX incumbents but climbing fast.

The Pentium Pro gave Intel its opening

In late 1995 Intel shipped the chip it actually believed could crack servers, the 32-bit Pentium Pro. It carried 5.5 million transistors and ran around 150 to 200 MHz, a big leap over the original Pentium’s 3.1 million transistors and 60 MHz. What shocked people was that the Pentium Pro beat the fastest RISC chips on some integer benchmarks. The faster RISC parts like the MIPS R10000 caught back up quickly, but the point had been made. A so called desktop architecture was now in the same conversation as the expensive stuff.

Transistor count and clock speed, original Pentium versus Pentium Pro. Source: Pentium Pro, Wikipedia

Pair the Pentium Pro with Windows NT 4.0, which also landed in 1996, and vendors suddenly had a ready made server standard. It matched the performance of some RISC integrated systems at a fraction of the price. Intel started circulating reference boards it called Standard High Volume Servers, basic designs partners could copy to get products out faster. The first generation boards took 1 to 4 Pentium Pros, 1 to 2 gigabytes of memory, and hundreds of gigabytes of storage. At the launch event Intel showed Pentium Pro machines ranging from a $2,600 workstation up to a $20,000 server, which was already an order of magnitude cheaper than the proprietary UNIX boxes.

By 1996 NT 4.0 was growing fast and taking real server market share, according to IDC tracking at the time. Wintel, the Windows plus Intel pairing, was building the same kind of base in servers that it already owned in consumer PCs.

Intel and Microsoft did not actually trust each other

Here is the part that gets left out of the tidy version. Intel knew that chaining its enterprise future to Microsoft was risky, because the two companies fought constantly under the surface. In 1995 Intel pushed a multimedia software standard it called Native Signal Processing, NSP, which offloaded audio and video work onto the CPU through its own APIs. Intel’s logic was simple, make people want faster chips. Microsoft saw NSP as middleware that stepped around Windows and onto its turf, and killed it. Bill Gates emailed Andy Grove to make the displeasure clear, and Microsoft publicly refused to support it. The whole thing resurfaced later during Microsoft’s antitrust trial as an example of how it leaned on partners.

The deeper tension was structural. Intel’s business depends on selling you a new, faster chip every couple of years, so it wants software that exploits every new capability immediately. Microsoft’s business depends on servicing its entire install base, so it moves slowly and guards backward compatibility. Intel shipped a 32-bit chip, the 386, in 1985. Microsoft did not ship a fully 32-bit consumer OS until Windows 95, 10 years later. NT also capped out at 4 to 8 processors per instance in that era, while high end UNIX could scale to 64, which kept NT out of the very top of the market. Intel wanted a partner that would not hold its silicon back. Around 1998, one appeared on the radar.

Where Linux actually came from

To understand why Linux mattered to Intel, you have to back up to the free software movement. In 1983 Richard Stallman, a programmer at the MIT AI Lab, started a project to build a free operating system that followed UNIX’s design without copying its code. He called it GNU, a recursive joke standing for GNU’s Not UNIX. Over several years he and a growing community built the toolchain, the compilers and utilities and shells. One piece kept slipping, the kernel, the part that sits between the OS and the hardware and manages memory, processor time, and storage.

That kernel arrived from an unexpected direction. In August 1991 a Finnish student of 21 named Linus Torvalds posted to a MINIX Usenet group that he was writing a free hobby OS and wanted feature ideas. It drew contributors, grew, and became Linux. Torvalds shifted from coder to maintainer, reviewing other people’s contributions and merging them, a model famously described as a bazaar in Eric Raymond’s essay The Cathedral and the Bazaar. It let Linux ship new code faster than any single company could.

In 1992 Linux adopted Stallman’s GPL license. This turned out to be the thing that saved it. The GPL let anyone read and modify the code as long as they open sourced their changes when distributing. That stopped any company from forking Linux, adding proprietary extras, and selling a closed competitor, which is exactly the fragmentation that had splintered UNIX into 30 incompatible variants. It also reassured companies that work they did on the kernel would benefit everyone and not get locked away. IBM would eventually have hundreds of employees contributing code. Torvalds later called going GPL the best decision he ever made.

The fragmentation point deserves a closer look, because it is why UNIX was vulnerable in a way that looked invisible from inside. UNIX started at Bell Labs in the early 1970s, then spread through universities and companies that each added their own extensions. By the 1990s there were around 30 incompatible flavors, each with its own quirks, its own APIs, its own subtle breakage. Software written for Solaris failed to run on AIX without changes. A vendor selling a database had to port and test against every one of them, which was expensive, so it supported a few and ignored the rest. That splintering was the direct result of everyone being allowed to take the code private and diverge. The GPL made divergence pointless. If you improved Linux and shipped it, your improvement had to come back to everyone, so there was one Linux instead of 30 Linuxes. A database vendor ported once. That single trait, one target instead of many, is a large part of why application makers eventually found Linux cheaper to support than the UNIX zoo.

Distributions turned a kernel into a product

A kernel on its own is a car engine with no car. Fine for enthusiasts, useless for a company that just wants a working server. So people built distributions, bundles that packaged the Linux kernel with the GNU utilities and other free software into something you could actually install. Slackware and Debian came early. So did Red Hat, started by Marc Ewing in 1993 and named after a red and white striped lacrosse cap he wore in college.

Red Hat wrapped Linux in the things a professional product needs, like the RPM package manager for adding, removing, and updating software cleanly. In 1995 Ewing and Bob Young founded Red Hat the company, earning money from selling boxed CDs plus training, support, and services. Young had a line he loved about the business model. Anyone with tomatoes, sugar, and vinegar can make ketchup, yet Heinz owns most of the market. You were not paying for the code, which was free. You were paying for the trust, the packaging, and the phone number to call when something broke.

Linux grew because it was reliable, and cheap helped

By mid 1997 Linux had an estimated 3 to 5 million users worldwide. Tiny next to Windows at around 100 million and the Mac at 50 million plus, but it had come from maybe a few hundred users in early 1992. A Red Hat box retailed around $50. An NT license ran from roughly $150 for a single upgrade to over $1,000 for a 10-seat package. A full UNIX system with hardware ran anywhere from $25,000 to a quarter of a million dollars and up.

Roughly what each option cost to put a server in service in the late 1990s. Log scale, because the spread is enormous. Source: price points cited above, contemporary trade press

Price was not the whole story though. The thing people actually loved about Linux was reliability. One early user called it almost crash proof, which in server terms means uptime, which means money. Sophisticated users loved that they could read and change the source, something Microsoft would never allow with Windows. People ported Linux to a Palm Pilot. Researchers at Los Alamos wired 68 PCs together with it to simulate atomic shock waves, an early taste of the cluster computing that would later define supercomputing.

That clustering thread turned into something big. In 1994 two researchers at NASA Goddard, Thomas Sterling and Donald Becker, wired 16 ordinary PCs together with cheap Ethernet and ran Linux across them, and called it a Beowulf cluster. The idea was simple and a little heretical. Instead of buying one enormous supercomputer, buy a pile of commodity machines and make them act like one. Linux was the natural choice because it was free, you could run it on as many nodes as you wanted without licensing math, and you could read and modify the networking code to make the cluster go faster. This is the same scale out logic that would later eat the server room, showing up first in science labs where budgets were tight and the people running the machines could write their own code.

It had real gaps. There was no good Linux version of Microsoft Office or the business software companies ran on. Support was a question mark unless you paid Red Hat or Caldera. And it carried UNIX’s reputation for being hard to use. A manager might ask how you could possibly run a critical server on free software, and the honest answer was that Linux was probably already running somewhere in their building without anyone in management knowing.

Intel noticed the thing it did not plan for

In early 1998 Intel started getting odd requests from national labs like Fermilab, asking it to port its math libraries to Linux. Before that Intel had barely touched Linux, maybe fixing a bug here and there. When it checked with the OEMs building white box servers for small internet service providers, the picture snapped into focus. Linux adoption was exploding. Close to 20% of public web servers were running it, a surprising share for an OS with basically no desktop presence.

That number went straight to Andy Grove, who made it clear Intel needed to do something. Intel executives sat down with Red Hat and came away baffled, because Red Hat did not own the core product it sold and anyone could get it free. Then the pieces clicked. Intel increasingly felt that betting everything on Windows NT was dangerous, especially with its new 64-bit server chip, Itanium, then codenamed Merced, in development. Intel worried NT would shackle Itanium the way Windows had lagged its 32-bit chips for a decade. Microsoft was not helping its own case, having slipped NT 5.0 from 1998 to 1999 before renaming it Windows 2000. Backing Linux gave Intel a fast moving OS it could tune to its silicon and hold over Microsoft’s head.

The summer of 1998 flipped the enterprise

Several big companies went public on Linux and open source in a few months. In June 1998 IBM, one of the most conservative firms in tech, folded the open source Apache web server into its e-commerce suite. Apache is not Linux, but most Apache instances ran on it, and IBM’s blessing gave open source its first real foothold in the enterprise.

Oracle made the sharpest turn. On 6 July 1998 InfoWorld ran a piece where Oracle, Sybase, and Informix all said they had no plans to port their databases to Linux, citing weak customer demand. Three days later Oracle announced it was porting Oracle8 to Linux. A big reason for the reversal was a panel in Santa Clara that July called the Future of Linux, where over 900 people showed up to see Torvalds and others argue about whether open source was a fad and push vendors to port their software. People later marked that panel as a turning point. By September, Computer Associates, Corel, and Informix all had Linux ports in the works.

Intel put money on the table and Microsoft went ballistic

Intel was at that July panel. Its engineer Sunil Saxena gave a talk calling Linux the OS of choice for internet service providers while naming its weak spots, scalability, high end drivers, and large memory support. He said Intel wanted to help. On 29 September 1998 Intel backed that with cash, joining Netscape and the VC firms Benchmark and Greylock in investing in Red Hat. Intel pledged engineering help and a dedicated liaison to the Linux community, and said it would join Linux International.

One underrated domino fell right after. A Benchmark partner sat on Dell’s board, and through him Red Hat got in front of Michael Dell. Dell invested too, and in early 1999 announced it would preinstall Linux on workstations and servers, the first major vendor to do it. Suddenly Linux stood on the same shelf as Windows and NetWare.

When news of Intel’s Red Hat investment broke, the tech press lost its mind over what it meant for the Intel Microsoft relationship. Red Hat executives later recounted that Microsoft went ballistic, and that Intel took angry weekend calls from its counterparts in Redmond. Before 1998 Microsoft might have been able to pressure Intel out of the deal. It no longer could, because in May 1998 the US government had charged Microsoft with monopolistic conduct over bundling Internet Explorer with Windows. Under that scrutiny Microsoft had to behave, and it even pointed at Red Hat as proof it did not have an OS monopoly.

Internally the mood was different. In late October 1998 a set of leaked Microsoft memos, nicknamed the Halloween documents and published by Eric Raymond, called free software like Linux a credible long term threat to Windows. Microsoft reportedly set up a team to convince customers Linux was not ready, put up a Linux Myths web page picking apart claims about Linux performance and reliability, and in April 1999 sponsored Mindcraft benchmarks that showed NT beating Linux badly as a file and web server. Those benchmarks were real and stung, because the early Linux kernel genuinely did not scale well past 2 processors.

Intel played Switzerland

Intel dodged the fight by declaring itself OS neutral. Linux, NetWare, Solaris, Windows 2000, Intel wanted all of them running well on its chips. It even tried to herd the 30 or so UNIX variants into writing shared drivers for Intel hardware through a Uniform Driver Initiative, which went nowhere. Intel later formalized this as a Port of Choice strategy, though Pat Gelsinger called it a long standing approach as early as 2001. The OS makers had to accept it, because Intel silicon had no real alternative.

The hardware kept advancing. In mid 1998 Intel shipped the Pentium II Xeon with a large 512 KB L2 cache suited to servers. In March 1999 the Pentium III Xeon arrived, and later that year, around August, Intel shipped the Profusion chipset that let vendors glue 8 processors into one box, breaking the old 4-way ceiling that had been choking data centers. That multiprocessor support needed the OS to cooperate, which NT and Windows 2000 could do and early Linux could not yet. High end UNIX still held the very top, where big databases and CAD systems needed more memory than 32-bit x86 could address, but the low and middle ground was now wide open.

The web scaled out, not up

Sun welcomed Linux at first, in line with its open branding, and ported its Java kit to Linux. Its attitude was that it did not care whether a box ran Linux or Solaris as long as it was a SPARC box. That assumption was the mistake. It did not have to be a SPARC box. Serving websites, email, and firewalls is not the same workload as running a giant database, and companies worked out that scaling out with lots of cheap Intel Linux nodes made far more financial sense than scaling up one enormous UNIX machine.

The dotcom crash accelerated everything. Venture money dried up, frugality became the rule, and companies bought second hand gear from dead startups or switched to Linux. Amazon did a major Linux migration in 2001 and told the SEC it cut technology costs by around $17 million in one quarter. An Amazon spokesman, asked how, said the company stayed closed mouthed about back end technology because it was steep tuition and it did not want others going to school on its dime.

Gartner figures for 2002, the year the direction became obvious. Linux server hardware revenue climbing while UNIX fell, even though UNIX was still far larger in absolute dollars. Source: Gartner 2002 server figures, contemporary trade press

An E-Trade case study from that era captured the tradeoff cleanly. A Sun 4500 Enterprise server cost $250,000 and served 300 to 400 users. A Linux Intel box cost $4,000 and served 180. The fix for the capacity gap was obvious, buy more boxes, and you still came out tens of thousands of dollars ahead. Starting in 2001, Linux Intel machines got good enough to steadily replace Sun in everything from airline fares to commodities trading. Sun tried its own low cost scale out play with the Netra, priced as low as $1,000, but commodity x86 still gave more performance per dollar, and Sun never formed a real answer to the shift.

Linux climbed up the ladder

After taking the low end, Linux went after the big machines. In late 2000 IBM announced a roughly $1 billion Linux effort with 1,500 employees dedicated to it, a stunning commitment from the company that had written AIX. In January 2001 Linux 2.4 arrived and closed real performance gaps with high end UNIX and NT. The multiprocessor weakness the Mindcraft tests had exposed got worked on hard, and 2.4 let Linux use 16 or even 32 processors with some effectiveness. It did not beat high end UNIX overnight, but solid 4 and 8 CPU support cleared the path into the middle of the market.

The economics got brutal for the incumbents. A Dell server with 4 Xeons running Red Hat at $24,000 cost half what a comparable Sun Fire UNIX box did and performed just as well. Red Hat and IBM went straight at Sun’s Solaris customers. HP and SGI started offering their own proprietary hardware customers a path to Linux, reasoning it was better to keep the relationship than lose it entirely. In 2002, a hard year for servers overall, Gartner reported Linux server hardware revenue grew sharply while UNIX revenue fell. UNIX was still the bigger number in absolute dollars because the machines cost more, $17 billion against Linux’s $2 billion that year, but the trend line had turned. By 2004 the average selling price of a Sun server had dropped roughly a third in two years.

x86 went 64-bit and the last wall came down

One of the last real advantages UNIX had was memory. A 32-bit x86 machine can address only about 4 gigabytes of RAM, far below what big databases and scientific workloads need to hold in memory. Intel’s bet here was Itanium, a clean break 64-bit architecture. It spun up Project Trillian in 1999 to get Linux ported to Itanium early, and released the IA-64 Linux source in February 2000, a genuine milestone for open source development.

Itanium did not win. The company that kicked off the real 64-bit transition was AMD, not Intel, with the Opteron in April 2003. AMD’s approach, x86–64, extended the existing x86 instruction set to 64-bit while staying backward compatible with all the 32-bit software people already ran. In 2004 Intel swallowed its pride and adopted AMD’s extensions in its Nocona Xeon. Once x86 could address dozens or hundreds of gigabytes of RAM, the last major architectural reason to buy UNIX was gone.

Why Microsoft kept growing anyway

Through all this, plenty of people predicted Linux would take down Microsoft on the server. It did not. Windows Server sales kept climbing. In 2005 Windows server revenue matched UNIX for the first time, and passed it the next year. Linux kept growing too, but its growth came mostly from eating UNIX and from brand new markets where Windows had never had a foothold, supercomputing, high performance compute, the web, and later cloud.

Microsoft’s defense was not a better benchmark. It was lock in through Active Directory, released with Windows 2000, which Ben Thompson of Stratechery has called one of the most valuable free products of all time. Active Directory authenticates and authorizes every user and asset in a Windows network. An admin can onboard a new manager, verify credentials, and grant exactly the right access, all from one place, and users log in to everything with one identity. That turned a pile of random Windows machines into a single managed organization, and it gave Microsoft ownership of identity inside the company. Identity reaches so deep into how an organization runs that ripping it out costs far more than swapping an OS. Microsoft’s real moat was never the kernel.

The pattern underneath, and why it still shows up

Strip the names off this story and you get a shape that repeats across the industry. A high margin incumbent sells an integrated product where the value is bundled together and the price reflects the whole bundle. A challenger commoditizes one layer of that bundle, makes it cheap or free, and the margin drains out of the layer above. Joel Spolsky wrote about this in Strategy Letter V under the phrase commoditize your complement. Make the thing next to yours cheap, and demand for your thing goes up.

Intel wanted the operating system to be a cheap complement to its chips, which is why it funded both Windows alternatives and Linux. A free, good OS running on Intel silicon meant customers spent their money on Intel hardware instead of on a Sun or HP bundle where the margin went to someone else. Linux wanted nothing in return, so it was the perfect complement, there was no vendor on the other side of the table trying to capture value back. IBM spent roughly $1 billion making Linux better not out of charity but because a strong free OS undercut Sun and Microsoft while IBM sold the hardware, services, and consulting around it. Everyone pushing Linux forward was commoditizing someone else’s product to protect or grow their own.

The same move keeps happening. Cloud providers gave away or cheapened the managed database and the operating system so you would rent their compute. Android was handed out free so the hardware and the search box around it would sell. When you see a large company investing heavily in making something free and good, the question to ask is which adjacent thing they actually sell, because that is almost always where the money is going.

Why UNIX actually lost

UNIX never fully died. There are still banking and healthcare systems running Solaris, AIX, or HP-UX today, applications too risky or too expensive to move. But the kingdoms are gone.

I do not think UNIX lost on technology. In raw capability the high end UNIX machines were ahead for years. It lost on business model. The vertically integrated vendor, one company controlling chip, OS, and hardware and charging a fortune for the bundle, worked fine until Intel showed up with volume economics that no single vendor could match on cost. Windows NT hit UNIX first and hard. Linux hit it harder, because it offered everything UNIX had, portability, reliability, the UNIX design, without the lock in or the price. Once Linux got good enough, the UNIX vendors themselves had to make the switch, selling customers the migration off their own platforms. The empire was not conquered so much as undercut, one cheap box at a time.