Chapter 2: Microsoft's Trojan Horse — DirectX
In 2024, a game engineer who graduated two years ago is preparing to launch his first indie game. He wrote it in Unity, targeting six platforms: Windows, Mac, Linux, iOS, Android, and Switch. Behind each platform runs a different graphics API—DirectX, Metal, Vulkan, plus the console manufacturers' own proprietary interfaces—each with its own quirks, its own bugs, and its own debugging tools. He has to tune the exact same shader logic so that it runs correctly on every API before he can consider the job done.
In his mind, he feels this is perfectly natural. It's a Graphics API; naturally, every company has its own set. Windows uses DirectX, Apple uses Metal, Linux uses Vulkan—that's just how it is.
Wrong.
In 1996, the entire PC 3D graphics world ran on a single API. It was called OpenGL, established by a company named Silicon Graphics. It was an open standard, cross-platform, and fully documented. John Carmack used it to write Quake; Hollywood visual effects workstations used it; CAD software used it to draw engineering blueprints.
It could have become the HTTP of the graphics world—a single, shared underlying river upon which a hundred flowers could bloom.
But it didn't.
Between 1997 and 1999, it was slowly strangled by a company that had never competed with it head-on. The killer left no fingerprints. The victim, SGI, even signed its own death certificate right before it died.
What this chapter aims to reconstruct is the scene of that crime. Because this case was not closed in 1999. Its stolen goods are still being divided up today—every engineer who has to write both Vulkan and Metal, every game company that has to maintain multiple platform teams simultaneously, every user who wants to leave Windows but gives up because the cost is too high—they are all families of the victim.
I. Motive for the Crime
To understand why Microsoft absolutely had to kill OpenGL, you first have to understand what the fear in Redmond was during the summer of 1994.
Windows 95 was about to ship. 32-bit, memory protection, unified APIs—these were the selling points Microsoft had spent five years talking their mouths dry over to enterprise clients, CIOs, and the Fortune 500. Everything seemed to be sailing smoothly, until an engineer named Alex St. John did something very simple: he installed the best-selling DOS games of the time and tried to run them on Windows 95.
Wolfenstein 3D dropped to 30% of its framerate. Doom crashed intermittently. SimCity 2000 couldn't even output sound.
St. John wrote an internal memo, and the final sentence was very blunt: "If we ship like this, Windows 95 will be the most embarrassing gaming platform in consumer history."
The memo was handed directly to Gates' office.
On the surface, this scenario was a technical problem—the operating system's abstraction layers were eating up too many CPU cycles, and games couldn't run smoothly. But Gates didn't see a technical problem; he saw a crack that directly threatened the foundation of Windows' monopoly.
The crack was this: A huge portion of the people buying home PCs at the time weren't doing it to run Excel; they were doing it to play games. If Windows 95 couldn't run games, these consumers would just stay on DOS, or worse—they would go buy a Mac, a PlayStation, or an Amiga. And once this demographic of young users left Windows, when they walked into offices ten years later, they would no longer be natural advocates for Windows.
In other words, the gaming market looked like a low-margin, high-hassle, annoying-customer downstream market. But it was the entry ramp to the entire Windows empire. If this ramp collapsed, the moat for Office and Windows Server might still be there, but water would start seeping in.
Gates didn't say that much. He just allocated St. John a windowless conference room, a small team, and one sentence: "Whatever resources you need, come directly to me."
II. Forging the Weapon
St. John had two engineers under him, Craig Eisler and Eric Engstrom. The three of them were half-jokingly, half-reverently called the Beastie Boys inside the company—because they all had long hair, wore T-shirts, and carried an aura that skirted the edges of the Microsoft dress code. What they had to do was technically very simple: Write a set of APIs that would allow game programmers to bypass the operating system and converse directly with the hardware.
This set of APIs was divided into several subsystems. DirectDraw handled 2D graphics, DirectSound handled audio mixing, DirectInput handled joysticks and mice, and Direct3D handled 3D rendering. Packaged together, it was externally known as DirectX. The first version was released in September 1995, intentionally kept low-profile, even named the Game SDK—they didn't dare be too flashy, because they knew perfectly well: technology was only half the battle.
The other half was persuading the game studios that fundamentally distrusted Windows. Especially the crowd at id Software.
We need to pause here—because this pattern will repeat itself in every subsequent chapter of this book.
Microsoft never won on technology. The first few versions of DirectX were poorly written, poorly documented, thread-unsafe, and had atrocious memory management. Carmack posted an open letter in his personal .plan file, tearing down Direct3D's design flaws point by point, ending by saying, "I will continue to use OpenGL." When this piece was published, every self-respecting 3D engineer at the time nodded in agreement.
But Microsoft held a card that OpenGL didn't have—it controlled the operating system itself.
What this card meant was: Microsoft could decide which API ran smoothly on Windows, which one required you to write your own drivers, and which one could be included in the OS's default installation package. It could decide which graphics card manufacturers received priority technical support, and which had to fend for themselves. It could decide when the next version of DirectX would be released, and how quickly graphics card manufacturers had to support it after release.
This card was useless for fighting a frontal war. But for slowly constricting an ecosystem, it was a lethal weapon.
III. Co-optation
The Beastie Boys' first target was id Software—the technical totem of the PC gaming world at the time. The idea was simple: If even id is willing to come over to Windows, what reason do other studios have not to follow?
The person Microsoft sent to negotiate was a young product manager then working inside the Windows 95 project group. The deal he brought to id was very straightforward: id ports Doom to Windows 95, Microsoft provides all the engineering resources, and id pockets all the money from the sales.
Carmack agreed. He didn't do it himself—he sent his deputy Dave Taylor to work with the Microsoft engineers—but he agreed.
In 1996, Doom 95 launched. It ran almost as smoothly on Windows as the DOS version. Running underneath was exactly that thin, almost invisible API layer of DirectX.
On the surface, Microsoft lost this deal—they expended engineering resources and didn't take a cent in royalties. But in reality, Microsoft won something money couldn't buy: a symbol.
From that day on, every time Microsoft knocked on a game studio's door—Sierra, LucasArts, Blizzard—they could say the exact same line: "Even id came over."
Once the conversation reached that point, there was nothing left to argue about.
(As an aside, that young product manager who flew to Texas to negotiate left Microsoft in 1996 and founded a company called Valve. His name was Gabe Newell. Over a decade later, he would do something covered in Chapter 6 of this book—personally dismantling this wall Microsoft had built. But that is a story for later.)
Here, the first cost begins to manifest:
The success of Doom 95 made the id engine the default choice for the industry. Every subsequent generation—Quake, Quake II, Quake III—used Direct3D as its primary rendering path, with Microsoft engineers assisting in deep optimization. When these engines were licensed to third-party studios, they became the underlying skeletons for Half-Life, Medal of Honor, and Quake III Arena.
The endpoint of this supply chain was that by around 2001, the vast majority of PC first-person shooters on the market had engines optimized for Direct3D underneath.
You want to make a similar game using OpenGL? Sure. But you have to write the engine from scratch.
IV. Faking Death
The guardian of OpenGL was SGI—Silicon Graphics. In the mid-nineties, SGI was the god of the graphics world. Hollywood visual effects, military simulators, medical imaging, CAD workstations—almost all of them were running on SGI's IRIX workstations in the background. One machine cost tens of thousands of dollars. OpenGL had been running on these machines for nearly a decade; the architecture was mature, fully documented, and cross-platform.
When Carmack used OpenGL to write Quake in 1996, he pushed PC 3D graphics to an unprecedented height within a few months. With this battle, OpenGL transformed overnight in the PC gaming circle from "stuff used on workstations" to "stuff you can actually use to make games."
If Microsoft had fought a frontal war with SGI in 1996, Microsoft would have lost—because Direct3D really couldn't win at that time.
So Microsoft chose another path.
In December 1997, Microsoft and SGI jointly announced a partnership called Fahrenheit. The press release read beautifully: the two companies would jointly develop the next-generation graphics API, unifying the futures of Direct3D and OpenGL. Fahrenheit was divided into three layers—the low level close to Direct3D, the high level close to OpenGL, and a middle level responsible for scene management. The external narrative was that this would be the next-generation standard shared by game developers, workstation users, and CAD engineers.
The calculation of SGI's upper management at the time made sense. OpenGL could no longer clash head-on with a company that controlled the operating system on Windows. If Fahrenheit could bring the spirit of OpenGL into Windows, SGI was essentially securing its technical legacy through a soft approach. And the fact that Microsoft was willing to cooperate proved that Microsoft also recognized the value of OpenGL. A win-win.
Based on this judgment, SGI made a fatal decision: it suspended further investment in OpenGL on Windows. Fahrenheit was coming anyway, so there was no point in duplicating efforts.
Two years later, Fahrenheit quietly disappeared. No usable product was released. No press conference announced its termination. It just slowly evaporated from the roadmaps of SGI and Microsoft.
The official explanation was "changing market conditions."
The reality was this—during the two years that Fahrenheit existed, OpenGL driver support on Windows stagnated. Graphics card manufacturers (3dfx, ATI, NVIDIA, Matrox at the time) started picking up on Microsoft's hints and tilted their engineering resources toward Direct3D optimization. Game engine developers felt the wind shifting and began pivoting from dual-API support to a Direct3D-first approach. A generation of new developers who might have wanted to try OpenGL had no new tools, no new documentation, and no new examples for two years, so they naturally defected to Direct3D.
Fahrenheit wasn't the only reason OpenGL was killed. OpenGL's committee governance model inherently couldn't iterate as fast as Direct3D's single-decision-maker model; Microsoft's control over Windows driver quality was also a long-term structural advantage. But Fahrenheit accomplished one thing that other factors couldn't—it made SGI voluntarily stop in its tracks. And that two-year window was exactly the critical period when Direct3D went from a chaser to the leader.
By the time SGI snapped out of it and realized Fahrenheit wasn't shipping—
Direct3D was no longer the API Carmack had mocked in 1996. DirectX 5, 6, 7, and 8 were released one after another, rapidly catching up in features with the full cooperation of graphics card manufacturers; by the time DirectX 8 introduced programmable shaders and DirectX 9 introduced the HLSL shading language, the center of gravity of the entire PC graphics ecosystem had irreversibly tilted toward Microsoft. Carmack still retained an OpenGL path in his own engines—from Doom 3 (2004) to Rage (2011), he was one of the few in the entire industry who insisted on not using Direct3D. But one man's insistence cannot stop the tide of an entire ecosystem.
SGI itself began massive layoffs in 2001, filed for Chapter 11 bankruptcy protection for the first time in 2006, and the entire company was acquired in 2009. The former god of graphics was left as nothing but a name.
The Fahrenheit deal would be written into the case studies of all business schools thereafter—not as a successful partnership, but as a textbook example of a feigning death strategy. If you want to kill an opponent stronger than you, you don't fight them. You say, "Let's work together," and then you use two years waiting for them to stop in their tracks on their own.
V. Closing Arguments
In October 1996, Microsoft held a launch event for DirectX 2.0 on Alcatraz Island in the San Francisco Bay—the former federal penitentiary that housed America's worst criminals. The event was called Judgment Day. Hundreds of game studio representatives and media were bussed onto the island. Old jail cells were converted into showrooms, each holding a game soon to be released on DirectX. St. John printed a "Death Certificate" and handed it to every attendee; in the deceased column, it read "DOS Games."
This party was later deemed too extravagant in internal reviews, and St. John was asked to leave the company in 1997 due to a series of similar incidents.
But what he left behind securely defended Microsoft for the next thirty years.
Here, the core argument of this chapter needs to be drawn clearly—why is DirectX a Trojan horse, rather than a gift?
The gift is for the players. Players no longer had to edit CONFIG.SYS, no longer had to debug IRQ conflicts, no longer had to do it themselves. Install, press Enter, play. The "hardware hell" of the DOS era vanished overnight.
The Trojan horse is for the developers. An engine written over two or three years using DirectX, if ported to other platforms, essentially has to be written from scratch. A studio that bets its entire fortune on Direct3D will no longer do cross-platform development, because the costs are too high and the marginal returns are too low. The moment this decision is made, it officially transitions from a "PC game company" to a "Windows game company"—the distance between those two terms is Microsoft's moat.
And once the developers are locked in, the consumers are indirectly locked in. Because what consumers buy is not the operating system, but the software running on the operating system. When your fifty favorite games all only run on Windows, you will continue to buy Windows, no matter how cheap a Mac gets or how open Linux is.
This pattern—first using convenience to attract a batch of downstream users, then using the lock-in effect to bind the midstream developers, and finally inversely locking in the upstream consumers—will be seen again in every subsequent chapter of this book.
- NVIDIA's CUDA first gave gamers more beautiful graphics, then locked in AI researchers, until finally tech companies worldwide had to buy NVIDIA GPUs to do AI (Chapter 7).
- Apple's iOS App Store first gave users convenient apps, then locked in developers—iOS forbids sideloading, Apple takes a 30% cut—until finally users couldn't switch phones (a case outside this book, but the exact same pattern).
- Console SoCs first gave players an affordable 4K gaming experience, then tied AMD to a decade-long semi-custom chip contract, and finally TSMC's large-die manufacturing experience inversely shaped the foundation of the entire AI chip industry (Chapter 8).
DirectX is the prototype case of this pattern in consumer tech history. Every platform lock-in that followed has been a variation on it.
VI. The Loot is Still Being Divided
Back to the indie game engineer in 2024 from the beginning.
He has to handle different graphics backends for every platform. The historical root of this task is buried in that unsigned Fahrenheit contract from 1997. If OpenGL had continued to develop back then, the world in 2024 might be—one API, all platforms. He writes his game once, and Windows, Mac, Linux, and Switch can all run it. His studio wouldn't need to maintain multiple QA teams, wouldn't need to endure the platform quirks of shaders, and wouldn't need to fix driver bugs across platforms all over again with every major version update.
What could he do with the time he saved? He could make two more games. He could sell the game a bit cheaper. He could compete more fiercely with big companies, because the platform tax wouldn't be so high.
But this world didn't happen.
Replacing it is the world of today: every graphics API belongs to one company, every company uses this API to bind its own platform, and every indie developer has to pay rent to multiple landlords.
This world is not an accident. It is the logical consequence of a series of decisions—that windowless conference room in Redmond in 1994, that Judgment Day on Alcatraz in 1996, and that feigned-death Fahrenheit contract in 1997.
Microsoft won this battle. But they won this battle so cleanly, so thoroughly, that its side effects wouldn't begin to manifest until twenty years later. While DirectX locked the PC gaming ecosystem into Windows, it also locked Windows itself into an increasingly closed cycle—every new layer of abstraction was designed to protect the commercial interests of the previous layer, rather than to allow developers to touch the hardware. People who needed freedom—scientific research engineers, server administrators, those who would later become AI researchers—naturally gravitated toward Linux. Not because they held a grudge against Microsoft, but because Windows was structurally no longer suited for their way of working.
By the moment AlexNet ignited the deep learning revolution in 2012, the entire ecosystem of AI—from the CUDA toolchain to the PyTorch framework to data center operating systems—had already grown in the soil of Linux. The Windows moat that Microsoft spent thirty years building was bypassed in the AI era.
That story is the subject of Chapter 5.
But before we get to that chapter, we first have to go to Tokyo. Because at the exact same time Redmond was celebrating the victory of DirectX, across the Pacific, a Japanese company was planning something that would keep Gates up at night—
They were going to turn a living room console into the shape of a computer.
And this computer would run Linux.
