Glide vs OpenGL vs Direct3D: The API War That Shaped Modern GPUs

The short answer, as of 2026: 3dfx's Glide won 1996 through 1998 by making PC games look like arcade games. Direct3D won 1999 through 2003 by being good enough plus owned by Microsoft. OpenGL survived as a Linux and macOS API until Vulkan arrived. Every argument about Vulkan versus DirectX 12 today is the same argument, just with different logos.

1996: three APIs, one problem

In 1995, PC gaming was software-rendered. Doom, Duke Nukem 3D, and Quake ran on the CPU, wrote pixels directly into video memory, and produced convincing 3D at 320×240 by cheating on the math. A serious 3D API for consumer PCs did not exist. Silicon Graphics workstations ran OpenGL over $50,000 hardware; nobody had a $200 3D card in their tower.

Three answers arrived in 1996:

• Glide, from 3dfx Interactive, launched with the Voodoo Graphics card ($299). A small, tight API that exposed exactly what the Voodoo hardware did well.
• Direct3D, from Microsoft as part of DirectX 3. Complicated, buggy, but bundled with every Windows 95 install and cross-vendor from day one.
• OpenGL for Windows, backed by Silicon Graphics workstations. Powerful, mature, but slow on consumer cards.

Games shipped for all three. Sometimes one game shipped for all three: id Software's Quake released with GL Quake (OpenGL), Quake Direct3D (D3D5), and 3dfx Mini-GL (a Glide wrapper). Each looked different. Each ran at different speeds. Nobody had won yet.

Why Glide looked better in 1996

Per Wikipedia's Glide API article, Glide was intentionally small. It exposed hardware features 3dfx knew Voodoo was fast at — texture filtering, alpha blending, MIP-mapping — and did not attempt to abstract features Voodoo did not have. That meant:

• Games ran fast because the API did not paper over hardware limits.
• Textures were bilinear-filtered by default, which killed the pixel-crawl of software rendering.
• Alpha blending was cheap, so transparent water, glass, and smoke suddenly looked convincing.
• The API was tight enough that experienced programmers could squeeze extra performance.

Games written for Glide targeted the Voodoo hardware directly. GLQuake at 640×480 on a Voodoo Graphics card ran at 30+ fps on a Pentium 200. Software-rendered Quake at the same settings ran at 8 fps. The Voodoo was such a leap that the term "3D accelerator" entered the popular vocabulary in 1996 largely because of it.

What Direct3D got wrong at first

Direct3D 3 (1996) was famously awkward. It used execute buffers — batches of API calls that the app packaged and submitted — which nobody liked. Microsoft's own Flight Simulator team publicly complained. John Carmack of id Software wrote a widely-quoted rant favoring OpenGL over Direct3D on technical grounds. Developers who cared about API elegance chose OpenGL or Glide.

Microsoft learned. Per Wikipedia's Direct3D article, Direct3D 5 (1997) and Direct3D 6 (1998) simplified the API dramatically. Direct3D 7 (1999) added T&L (transform and lighting) hardware support, which the GeForce 256 was designed to accelerate. Direct3D 8 (2000) added programmable shaders. By 2001, Direct3D was competitive with Glide and OpenGL on features and rapidly ahead on driver quality.

Why OpenGL stayed alive

Per the Khronos OpenGL page, OpenGL had SGI's workstation lineage — the API was polished by 1996 because it had been shipping on real hardware for years. That mattered for professional 3D artists, and it mattered for developers who wanted portability. Two forces kept OpenGL alive on Windows through 2003:

• id Software. John Carmack's engines used OpenGL. Quake II, Quake III Arena, RTCW, and Doom 3 all shipped with OpenGL as the primary API. Every game licensee who used id Tech engines used OpenGL. That kept OpenGL driver quality on Windows high because NVIDIA and ATI could not afford to ship broken OpenGL if it broke Quake III.
• Cross-platform reach. OpenGL ran on Linux, macOS (via Apple's port), Sun Solaris, and IRIX. Anybody targeting more than Windows needed OpenGL.

OpenGL on Windows died slowly. Vista's initial 2007 implementation forced OpenGL calls through a compatibility layer that added latency; Microsoft's decision was widely read as anti-OpenGL. NVIDIA and ATI eventually shipped drivers that worked around it, but the message was clear.

The 1998–1999 turning point

Three things happened between 1998 and 1999 that ended the war:

1. RIVA TNT and TNT2 shipped. NVIDIA's 1998 and 1999 cards offered features that matched or beat Voodoo 2, at similar prices, on standard APIs (Direct3D and OpenGL) instead of Glide. Developers stopped feeling that they had to write Glide-specific paths to get pretty graphics on customer hardware.
2. Direct3D 6 and 7 fixed the API's reputation. Games written for Direct3D 7 (Half-Life, Age of Empires II, Baldur's Gate) shipped on time, ran fast, and looked good.
3. 3dfx bet wrong on Voodoo 3 and Voodoo 5. 32-bit color, larger textures, and hardware T&L — all missing from Voodoo — became table-stakes in 1999.

By late 1999, Glide was dying. 3dfx acquired STB in 1998 and stopped licensing its cards to Diamond, ELSA, and Guillemot — a decision that alienated the board vendors who had helped Voodoo win. Voodoo 5 shipped late in 2000 to a market that had moved on. NVIDIA acquired 3dfx's assets in December 2000.

What Direct3D actually won

Direct3D was not just a graphics API. DirectX bundled:

• Direct3D for 3D graphics.
• DirectSound for audio.
• DirectInput for controllers, keyboards, and mice.
• DirectPlay for multiplayer networking.
• DirectShow for video playback.

Developers who used DirectX got everything they needed in one library. OpenGL was graphics only — you still had to solve audio, input, and networking separately. Glide was graphics only, and only for one brand of card. Direct3D's bundling was decisive.

What this looks like on original hardware

Running Glide games on real 1998 hardware in 2026 is a collector project. A period-correct Pentium III at 550 MHz, a Transcend CompactFlash 4GB as an IDE-emulating boot drive via a compact-flash-to-IDE adapter, and a Unitek SATA/IDE to USB 3.0 Adapter to shuttle files between the retro PC and a modern workstation — that is the practical shape of a retro-build stack. Glide-era Voodoo cards are eBay-only and increasingly expensive.

Or use dgVoodoo2 on a modern PC. It translates Glide calls to Direct3D 11 or Vulkan, runs the games at 4K, and adds anti-aliasing the original hardware could not do. For most players, this is the practical way to revisit Glide-era titles.

The through-line to Vulkan versus DirectX 12

Every argument in 2026 about Vulkan versus DirectX 12 rehearses the Glide era:

• Vulkan is cross-platform, open standard, technically strong. So was OpenGL. Cross-platform matters until the incumbent (Microsoft or Apple) makes its proprietary alternative good enough.
• DirectX 12 is Microsoft-owned, less portable, but well-supported and consistently updated. So was Direct3D 7 through 9. Platform ownership plus consistent evolution beats technical superiority in isolation.
• Metal is proprietary, one-vendor, deeply optimized for one platform. So was Glide. Metal wins on Apple platforms because Apple owns the platform end-to-end.

Modern GPUs like the MSI RTX 3060 Ventus 3X 12G or GIGABYTE RTX 3060 Gaming OC 12G run all three APIs. Their drivers are far more mature than any 1998 driver stack. But the underlying arguments about API ownership, portability, and platform incentives are the same.

Timeline

What we learned

Four lessons that carry through:

1. Being technically better is not enough. Glide was technically better than Direct3D 3 in 1996. It lost anyway.
2. Platform ownership beats API design. Direct3D won because Microsoft owned Windows.
3. Vendor lock-in works until it does not. 3dfx's Glide monopoly generated the money that built the Voodoo brand and killed the company when the market rebalanced.
4. Open standards need incumbent muscle. OpenGL survived on Windows only because id Software forced NVIDIA and ATI to ship good drivers. Vulkan survives today because Valve, Steam Deck, and Android need it.

Common misreadings

• "Glide was inferior technology." Not in 1996. It was superior for the hardware it targeted.
• "OpenGL was always worse than Direct3D on Windows." False from 1996 to 1999.
• "3dfx died because they were slow." They died because they alienated board vendors, missed 32-bit color, and mispriced Voodoo 5.
• "Direct3D always shipped with Windows." It shipped as part of DirectX 3 in 1996, not with Windows 95 originally.
• "Vulkan is a spiritual successor to Glide." Only in that both are small, tight, hardware-close APIs. Vulkan is a spiritual successor to Mantle and OpenGL Next.

The demoscene footnote

Glide's small, tight API made it a favorite of the demoscene — the community of programmers who wrote graphical demos for competitive events. Some of the most influential 1998–1999 demos targeted Voodoo hardware directly through Glide. When Direct3D and OpenGL improved and 3dfx died, the demoscene migrated but kept technical influences from the Glide era: single-pass rendering approaches, aggressive texture packing, and math-heavy pixel effects.

Some Glide-era demos still run under dgVoodoo2 wrappers on modern hardware. They look surreal at 4K resolution on RGB LED monitors — visual designs meant for 640×480 CRTs, quadrupled, still holding their ideas together.

3dfx's cultural legacy at NVIDIA

When NVIDIA acquired 3dfx's IP and hired many of its engineers in 2000–2001, the company absorbed both technology and design sensibilities. Several 3dfx concepts made it into subsequent NVIDIA cards:

• Multi-GPU rendering — SLI as a brand name came from 3dfx's Scan-Line Interleave.
• Anti-aliasing philosophy — 3dfx had aggressive AA on Voodoo 5; NVIDIA's later AA implementations echoed the approach.
• Driver-level game profiles — the practice of shipping per-game optimizations dates back to Glide-era 3dfx drivers.

The Voodoo name is dormant, but the DNA is not.

Bottom line

The Glide vs OpenGL vs Direct3D fight was the first three-way API war in consumer PC graphics. Glide won on quality in 1996–1998. Direct3D won on ownership and evolution in 1999–2003. OpenGL survived on Linux and macOS until Vulkan arrived.

The template still applies. Whenever a hardware vendor writes a proprietary API to expose their card's best feature, they are running the 3dfx play. Whenever Microsoft or Apple ties graphics to their platform, they are running the Direct3D play. Whenever an open standard organizes vendors around cross-platform code, it is running the OpenGL play. The names change; the fight does not.

What we learned about hardware design

The API war also drove hardware design decisions still visible in 2026:

• Unified shader architecture. Modern GPUs (starting with the GeForce 8800 GTX in 2006) treat vertex, pixel, and geometry work as identical shader operations. This was in part a response to Direct3D 10's programmable-pipeline demands. It has held for two decades.
• Command buffer submission. Vulkan and DirectX 12 both use pre-recorded command buffers that the GPU consumes in order. This idea traces to Direct3D 3's execute buffers — which developers hated for the design but the concept turned out to be right; it just needed a decade for the API to catch up.
• Immediate-mode versus retained-mode. OpenGL immediate mode (glBegin/glEnd) was killed by DirectX 10 and dropped from OpenGL core profiles by 3.1 (2009). Every modern API is retained-mode. Glide never used immediate mode.
• Command list reuse. Modern game engines pre-record renderer commands and replay them, a technique that only makes sense with retained-mode APIs. This is why Vulkan and DirectX 12 game engines look so different in code from the OpenGL and Direct3D 9 engines of the 2000s.

If you have ever wondered why the API you write against today feels the way it does, the answer usually traces to a lesson learned in the Glide era.

Related guides

• Someone Got Linux Booting on a Sega Mega Drive
• RTX 3060 12GB vs RTX 4060 for 1080p Gaming: Which Wins in 2026?

Citations and sources

• Wikipedia — Glide API article
• Wikipedia — Direct3D article
• Khronos — OpenGL homepage

This piece is editorial synthesis based on publicly available information. No independent first-party benchmarking is reported.