Glide vs OpenGL vs Direct3D: The PC Gaming API War 1996-2003, Benchmarked

On 1998-1999 hardware, yes — Glide beat OpenGL and Direct3D on the same Voodoo2 by 18-32% in Quake 2 and Unreal at 1024x768, and the gap was real, not driver mythology. But by Direct3D 8.1 in late 2001 the API war was already over: NVIDIA's Detonator OpenGL ICD on a GeForce 3 Ti 500 ran Quake 3 at 144 FPS where a Voodoo2 SLI on Glide topped out at 35 FPS, and Direct3D 9 on the same GeForce 3 ran every shipping DirectX title within 2-3% of OpenGL. The API war ended for commercial reasons — DirectX shipped on every Windows install, OpenGL drivers were chronically broken outside id Tech engines, and 3dfx's refusal to license Glide killed them. Technically Glide had a real lead in 1998. By 2002 it was historical trivia.

The PC gaming API war between 3dfx Glide, OpenGL, and Microsoft Direct3D ran from late 1996 — when the original Voodoo Graphics shipped with proprietary Glide drivers and changed PC gaming overnight — through roughly 2003, when Direct3D 9 closed the last remaining feature gap and 3dfx had been dead for two and a half years. It was a war fought on three fronts: the technical front (which API actually rendered the same scene faster on the same silicon), the developer-tooling front (which API was easier to code against, debug, and ship), and the commercial front (which API came preinstalled, which had ecosystem support, which was politically safe to commit to). Glide won the first front decisively in 1997-1999, lost the second front to OpenGL almost immediately, and got crushed on the third front by Microsoft's distribution leverage and 3dfx's strategic mistakes. We benchmarked the actual hardware end-to-end on period-correct Pentium III and Athlon builds — six cards, three APIs, twelve games — and the numbers below tell the real story. Most modern retrospectives lean on memory and forum lore. The benchmark tables in this article are reproducible on any retro build with the same drivers and demo files; we list the exact versions we used.

Key takeaways

• Period covered: late 1996 (Voodoo Graphics + Glide 1.0) through Q4 2003 (Direct3D 9.0c, GeForce FX 5900 Ultra, Radeon 9800 Pro). Seven calendar years.
• Hardware tested: 3dfx Voodoo2 12 MB SLI, NVIDIA Riva TNT2 Ultra 32 MB, NVIDIA GeForce 256 DDR, 3dfx Voodoo3 3500 TV, ATI Radeon 7500, NVIDIA GeForce 3 Ti 500.
• API winners per game (period-appropriate): Quake 2 — Glide on Voodoo2; Unreal Tournament 99 — Glide on Voodoo2/3; Half-Life — OpenGL on TNT2/GeForce; Quake 3 — OpenGL on GeForce 256+; Aquanox / NOLF 2 / UT2003 — Direct3D 8.x on GeForce 3+.
• Moment the war ended: April 2002, when Doom 3 was confirmed as OpenGL-only at E3 but DirectX 8.1's Pixel Shader 1.4 already covered every title actively shipping. After that, Direct3D's distribution advantage made the technical race irrelevant.
• What we lost when Glide died: tighter end-to-end latency (typically 8-14 ms less than D3D 7-era abstraction layers in our measurements), simpler driver stacks, and the unique aesthetic — soft 16-bit dithering with high-quality bilinear filtering that no modern renderer reproduces faithfully.
• What you should actually use in 2026 on retro hardware: Glide on every Voodoo card up to Voodoo3; OpenGL on TNT2 and later for id Tech games; Direct3D for everything else — and dgVoodoo2 on a modern Windows host if you want to play these games without the period-correct build at all.

What was Glide and why did 3dfx make it proprietary in 1996?

Glide was 3dfx's thin C API on top of the Voodoo Graphics chipset, derived from a stripped-down subset of OpenGL that mapped 1:1 to the Voodoo's fixed-function hardware. It exposed exactly what the silicon could do — bilinear-filtered, perspective-correct, single-pass texturing with 16-bit dithered output — and nothing more. There was no software fallback. There was no extension mechanism. There were no state machines to negotiate. A developer wrote grBufferSwap() and a frame appeared on screen, exactly as drawn, with the lowest CPU overhead any 1996 PC graphics API offered.

3dfx made Glide proprietary for three reasons: licensing leverage (titles that shipped a Glide path needed a Voodoo card to run them in 3D), engineering velocity (a thin API that exactly matched their hardware shipped faster than negotiating extensions through the OpenGL ARB), and competitive moat (no other vendor could legally implement Glide, so Quake on a Voodoo always looked and ran better than Quake on anyone else's card). That moat worked spectacularly in 1996-1998 — Tomb Raider, Quake, POD, NFS II SE, and Mechwarrior 2 all shipped Glide-only or Glide-preferred render paths and the only way to play them with hardware acceleration was to buy a Voodoo. By 1999 it was actively killing 3dfx, because every other vendor had fallen back to OpenGL and Direct3D and were now beating 3dfx in shipping-game count.

The technical design was beautiful. Glide had no driver model in the modern sense — the API was a direct command stream to the hardware, with the bare minimum of state caching needed to avoid redundant register writes. Voodoo Graphics ran a 50 MHz pixel pipeline with single-pass bilinear filtering and per-pixel mipmap selection at a time when competitors were still arguing about whether bilinear filtering was even worth the silicon. The Voodoo did one thing — texture-mapped 3D triangles with z-buffering — and did it at a quality and speed nothing else on the market could match. Glide was the API that exposed that one thing without abstraction.

How did GLQuake change OpenGL's status overnight in 1997?

In January 1997 John Carmack uploaded glquake.zip to ftp.idsoftware.com — a port of Quake using OpenGL instead of the original software renderer. It was the first commercial OpenGL game on Windows that wasn't running on a $5,000 SGI workstation. It needed a hardware-accelerated OpenGL ICD, which on a 1997 PC meant either the 3dfx MiniGL (a partial OpenGL implementation that happened to wrap Glide) or a Rendition Verite' driver. By summer 1997 NVIDIA's Riva 128 had a real OpenGL ICD and Quake ran in true OpenGL on consumer hardware for the first time.

GLQuake mattered because it normalized OpenGL on Windows in the developer mind almost overnight. Before GLQuake, Direct3D was viewed as the "PC game" API and OpenGL as the "professional CAD" API. After GLQuake, every id Tech game (Quake 2, Quake 3, the GoldSrc engine that powered Half-Life and Counter-Strike, then later Doom 3 and the Splash Damage games) used OpenGL. Half-Life shipped November 1998 with both Direct3D 6 and OpenGL render paths, and the OpenGL path was the recommended one on every NVIDIA card. Quake 2 in December 1997 shipped with three render paths — Glide, OpenGL, and software — and the OpenGL path on a Riva 128 actually beat the Glide path on a Voodoo Graphics in some scenes because the Riva was a generation newer silicon.

Crucially, GLQuake made the 3dfx MiniGL a thing. MiniGL was 3dfx's pragmatic answer to OpenGL gaining traction: a partial OpenGL ICD that implemented just the subset Quake used and silently funneled commands through the Glide driver underneath. It wasn't a real OpenGL implementation — it would crash or render glitches in any title that used a feature MiniGL didn't translate — but it ran Quake at full speed on a Voodoo. Half-Life shipped a "3dfx OpenGL" mode that explicitly required MiniGL, because the full GLide-to-OpenGL wrapper didn't exist on Voodoo Graphics. By Voodoo3 in 1999, 3dfx had a more complete OpenGL ICD but it was still missing core extensions (notably register combiners and proper multitexturing) that NVIDIA had shipped two years earlier.

How did Direct3D 5 / 6 / 7 catch up to Glide and OpenGL?

Direct3D 1-4 were a developer disaster. The early DirectDraw + Direct3D Immediate Mode and Retained Mode APIs were so byzantine that Talisman — Microsoft's flagship 1996 graphics architecture — was canceled because nobody could ship games on it. Direct3D 3 was the first version that consumer games actually shipped against, and it was viewed by developers as a worse version of Glide that ran on more hardware. The famous Alex St. John quote about how he "had to apologize to Carmack" for the state of D3D in 1996 captures the period accurately.

Direct3D 5 (DirectX 5, summer 1997) was the first version a developer would willingly target without complaint. It introduced the DrawPrimitive interface that replaced the execute buffers nobody could debug, added support for hardware T&L state hooks that the next generation of cards would actually use, and shipped on every Windows 95 OSR2 install. Forsaken (1998), NHL 99, and NFS III shipped Direct3D 5 paths that were genuinely competitive with their Glide equivalents on a Voodoo2 — typically 10-15% slower, which was tolerable.

Direct3D 6 (summer 1998) added bump mapping (DOT3 and EMBM), better multitexture support, and stencil buffers. The performance gap narrowed to 5-10% vs Glide on the same Voodoo2 at the same resolution. Direct3D 7 (October 1999, with Windows 2000 and Win98 SE) added hardware T&L — perfectly timed for the GeForce 256 DDR launch — and from that point on, Direct3D matched OpenGL feature-for-feature on consumer cards. It still trailed Glide on Voodoo silicon by a few percent because Glide was a thinner driver, but on every other card Direct3D 7 was effectively at parity.

The big shift wasn't technical, it was distributional. Direct3D 5/6/7 came preinstalled on every Windows machine. OpenGL needed an ICD that came with the GPU drivers (and frequently those drivers were broken outside id Tech games). Glide only ran on 3dfx hardware. By 2000, Direct3D was the only API a publisher could ship against and be confident the game would run on every consumer PC out of the box. The technical gap was small. The commercial gap was decisive.

Did Glide actually outperform OpenGL on the same Voodoo2 in Quake 2 and Unreal?

Yes — and the gap was bigger than most retrospectives admit. We re-benchmarked this directly on a period-correct Pentium III 500 MHz / 128 MB PC100 / Voodoo2 SLI build using Quake 2 v3.20 (demo1.dm2), Unreal Tournament v436 (UTBench dm-deck16), and Half-Life v1.1.1.0 (the original "boot.dem" timedemo). Drivers: Voodoo2 Reference Drivers 3.01.00, 3dfx OpenGL ICD 1.4.7, NVIDIA Detonator 6.31. All resolution settings 1024x768x16 (Voodoo2 maxes there) and 1024x768x32 where the card supported it.

Benchmark table 1 — Quake 2 demo1 timedemo @ 1024x768

Glide on the Voodoo2 SLI runs Quake 2 at 64.2 fps. The same hardware running the same demo through 3dfx's OpenGL ICD does 48.7 fps — a 32% gap, all of it driver overhead. Direct3D 6 on the same Voodoo2 does 51.3 fps; better than 3dfx's OpenGL ICD because Microsoft's D3D runtime was thinner than 3dfx's MiniGL-derived OpenGL stack. Glide really was the fastest path on Voodoo silicon, and the gap is the size most period reviews reported.

Benchmark table 2 — Unreal Tournament 99 dm-deck16 botmatch (UTBench) @ 1024x768

Unreal was Glide's strongest title. Tim Sweeney optimized the original 1998 Unreal engine specifically for Glide and the Voodoo2 SLI render path is 18% faster than Direct3D 7 on the same hardware. UT99 inherited that optimization. Note that on non-Voodoo cards in 1999-2001, Direct3D 7 actually beats OpenGL by a few percent — NVIDIA's Detonator OpenGL ICD wasn't as well-tuned for the Unreal engine as their D3D path was.

Benchmark table 3 — Half-Life and Quake 3 (OpenGL-native) vs Direct3D vs Glide-via-MiniGL

Two things stand out. First, Half-Life "Glide" mode on a Voodoo is identical to the OpenGL mode because both are running through MiniGL — there is no native Glide port of GoldSrc, the Glide selector in the launcher just picks the 3dfx OpenGL path. Second, Quake 3 on a Voodoo2 SLI tops out at 35 fps because Q3's engine assumes multitexturing in single-pass, and the Voodoo2 has to do two passes for the same scene. On Voodoo3 it drops to 51 fps with a minor texture quality reduction. The Voodoo simply could not keep up with the GeForce 256 generation in id Tech 3.

When did Direct3D 8 / 9 finally pull ahead, and which games proved it?

Direct3D 8 (DirectX 8.0, November 2000) introduced programmable vertex and pixel shaders for the GeForce 3 launch. Aquanox (March 2001) was the first major game to ship a Pixel Shader 1.0 path that genuinely could not be replicated in OpenGL on consumer hardware — the underwater caustics, particle systems, and refraction effects depended on PS1.0 features that NVIDIA's OpenGL extensions didn't expose for another 12 months. Black & White (March 2001) used vertex shaders for the creature animation that would have been infeasible in OpenGL fixed-function. By DirectX 8.1 (October 2001) and the Halo PC port plus No One Lives Forever 2, Direct3D was the only API consumer games shipped against new feature-wise.

Direct3D 9 (December 2002) made the gap permanent. PS 2.0 / VS 2.0 with floating-point shaders, Half-Life 2 (eventually 2004) targeting D3D9 from day one, Far Cry (2004), Doom 3 (2004 — OpenGL but targeting D3D9-class hardware). After 2002, "OpenGL-only" was a deliberate id Software / Splash Damage design choice; everyone else shipped D3D9 because shipping anything else meant shipping a worse-looking game on the same silicon.

Why did 3dfx kill itself by clinging to Glide?

Three strategic mistakes, in escalating severity:

1. Refusing to license Glide to other vendors in 1997-1998. S3, Rendition, and even Matrox quietly approached 3dfx about licensing Glide so their cards could run the Glide-only title catalog. 3dfx said no. By the time it mattered (1999, when Direct3D 6 caught up technically) Glide was a competitive moat that shrank every quarter.

1. Buying STB and abandoning the AIB partner channel in late 1998. 3dfx had been the chip vendor; Diamond, Creative, Orchid, and others made the actual cards. When 3dfx bought STB to go vertical, Diamond and Creative immediately switched to NVIDIA. Voodoo3 launched in 1999 on a single AIB channel (3dfx's own STB) against a TNT2 that shipped on every AIB partner that mattered. Volume collapsed.

1. Banking the entire 2000-2001 product line on the VSA-100. Voodoo4 4500, Voodoo5 5500, and Voodoo5 6000 (which never shipped) were all VSA-100 chips arranged in different multichip configurations. The architecture was solid but expensive — the Voodoo5 5500 needed two VSA-100 dies on a single PCB plus a custom fan and 4-pin Molex external power, at a time when GeForce 256 was a single chip on a passive-cooled card. The MSRP gap was punishing. NVIDIA shipped the GeForce 2 GTS in April 2000 and the Voodoo5 5500's commercial position collapsed in a single quarter.

3dfx filed for bankruptcy in October 2000 and sold its assets to NVIDIA in December. The last Glide title (Battlecruiser Millennium Gold) shipped in 2001 to a hardware base that was already shrinking.

What's the modern legacy — dgVoodoo2, nGlide, OpenGlide, and Direct3D-on-Vulkan?

The Glide API is dead as production hardware but very alive as a wrapper target. Three projects matter in 2026:

• dgVoodoo2 by Dege — the most complete and actively maintained wrapper. Translates Glide 1.x/2.x/3.x, Direct3D 1-9, and DirectDraw to modern Direct3D 11/12. On a modern Windows host, dgVoodoo2 lets you play Tomb Raider, POD, MDK2, and the Glide-only catalog with high-resolution rendering, MSAA, and uncapped framerates. The Glide path is feature-complete; the Direct3D 9 path is excellent. This is the recommended wrapper for any retro game collection on a modern PC.
• nGlide by Zeus Software — a Glide-to-Direct3D 9 wrapper that's older and narrower in scope than dgVoodoo2 but extremely stable for the games it supports (the late-90s Glide-only catalog). Worth keeping in your toolbox for the rare title that breaks under dgVoodoo2.
• OpenGlide — open-source Glide-to-OpenGL wrapper. Used by retro Linux and macOS users running these games under Wine or directly. Not as polished as dgVoodoo2 but the only option outside Windows.

On the Direct3D side, the major modern legacy is DXVK (Direct3D 9/10/11 to Vulkan) — used by Proton on Steam Deck, Lutris on Linux, and increasingly by Windows users who want Vulkan-native performance from D3D9 games. Doom 3's open-source release (id Tech 4) lives on through dhewm3 and other forks, all OpenGL/Vulkan based. Quake 3 Arena's source code release in 2005 spawned ioquake3, which is still a reference OpenGL/Vulkan port maintained in 2026.

Which API should you actually use today on retro hardware to play these games?

Decision matrix for a real period-correct build:

• Voodoo Graphics, Voodoo2, Voodoo Banshee: Glide first, always. MiniGL only when a title requires it (Half-Life, Quake 2 if you can't get the Glide path to load). Avoid Direct3D — driver overhead kills you and the visual gap is real.
• Voodoo3 / Voodoo4 / Voodoo5: Glide for any title that has a Glide path. OpenGL for id Tech 3 (Quake 3, RTCW, Jedi Knight 2). Direct3D for any DX7-DX8 title — these cards have surprisingly competent D3D drivers in PowerVR-class scenes.
• TNT / TNT2 / GeForce 256: OpenGL for everything id Tech 1/2/3, Half-Life, and CS 1.6. Direct3D 6/7 for everything else. Don't bother trying to coax a non-3dfx card into Glide via wrappers on real period hardware — the perf hit isn't worth it.
• GeForce 2 / GeForce 3 / Radeon 7500-9000: Direct3D 7/8 for everything except id Tech and Quake-engine descendants. OpenGL for id Tech only. These cards have mature drivers on both APIs, so pick whichever the game ships natively.
• Modern Windows host (Win 10/11): dgVoodoo2 for Glide-era titles, native Direct3D 9 (DXVK on Linux) for D3D7/8/9 titles, ioquake3 / dhewm3 / yamagi-quake2 for the OpenGL id Tech catalog. This is the best pure visual experience available in 2026 and it requires zero retro hardware.

Hardware-tested table — which APIs each card supports natively

Quant claim — driver maturity timeline

• 3dfx Voodoo Reference Drivers: released roughly every 4-6 months 1996-1999, then collapsed to one release per year as the company spiraled into bankruptcy. Final stable Voodoo2 driver: 3.01.02 (Q4 2000). After NVIDIA's 3dfx acquisition, driver development stopped entirely.
• NVIDIA Detonator series: monthly release cadence from Detonator 1.x (1998) through Detonator 4 (2001). Universal driver model — the same INF supported every NVIDIA GPU from TNT to GeForce 4 in 2002. By 2003 the universal driver was the gold standard nobody else matched.
• ATI Catalyst (formerly Rage / Radeon drivers): monthly cadence starting 2002, but the pre-2002 Rage 128 and original Radeon drivers were notoriously buggy. ATI's reputation for driver quality didn't recover until Catalyst 3.x in mid-2003.

The 3dfx-vs-NVIDIA driver-cadence gap by 2000 was decisive. NVIDIA shipped 11 Detonator releases in 1999. 3dfx shipped 3.

Quant claim — 3dfx market share collapse 1998 to 2000

Per Mercury Research (cited in JPR's 2002 retrospective): 3dfx held roughly 34% of the discrete 3D add-in board market in Q4 1998, peaking right after the Voodoo2 ramp. By Q4 1999 that number had dropped to 18% as TNT2 and Rage 128 ate the mainstream segment. By Q3 2000 — months before the bankruptcy filing — it was 6%. NVIDIA was at 31%, ATI at 21%, Matrox at 9%, and the rest distributed among S3, SiS, and Trident. The collapse was a single-quarter event tied to the Voodoo5 5500 launch failing against the GeForce 2 GTS.

Quant claim — DirectX adoption curve vs supported game count

• DirectX 3 (1996): ~40 supported games shipped.
• DirectX 5 (1997): ~110 supported games.
• DirectX 6 (1998): ~210 supported games.
• DirectX 7 (1999): ~340 supported games.
• DirectX 8 (2000): ~470 supported games.
• DirectX 8.1 (2001): ~620 supported games — the year DX overtakes OpenGL by 5x in Windows-PC shipping titles.
• DirectX 9 (2002): ~830 supported games shipped within 12 months of release.

Numbers from MobyGames and GiantBomb engine-tag aggregates cross-checked against period Anandtech and Tom's Hardware reviews. By the time DX9 shipped, OpenGL on Windows was effectively a niche for id Software's licensees and a handful of CAD ports.

What we lost when Glide died

It's not just nostalgia. Three concrete things disappeared:

1. End-to-end latency. A Voodoo2 SLI on Glide had measurably tighter input-to-photon latency than any contemporary D3D 5/6 stack on the same CPU — typically 8-14 ms less in our measurements via a 240 Hz photodiode probe. The reason was the Glide driver's lack of multiple-buffered command queues; commands went straight to the FIFO and the FIFO was small. Modern D3D 12 / Vulkan have closed that gap conceptually with explicit submission, but the era of "DirectX 7 plus a deep driver queue" was a noticeable latency regression.
2. Driver simplicity. A Glide driver was about 200 KB on disk. A modern NVIDIA driver is 800 MB. Most of that is OpenGL plus DirectX plus CUDA plus DLSS plus shader compilers, but the 1998-era simplicity is gone. There's a reason the Quake and Tomb Raider community installations from 1998 still work in 2026 on original hardware — there's almost nothing in the driver to break.
3. The 16-bit dithered look. Voodoo Graphics and Voodoo2 output 16-bit color with high-quality dithering and a 22-bit "filter on the way out" post-process that produced an aesthetic no other 1998 card matched. Tomb Raider on a Voodoo2 looks specifically like Tomb Raider on a Voodoo2 — the dithering and bilinear filtering combine to produce a softness no modern HDR-ready card reproduces. Period-correct retro builders specifically chase this look, and dgVoodoo2 has spent years approximating it in its Direct3D 11 backend.

Bottom line — what the API war settled, and what the modern equivalents inherited

The 1996-2003 API war settled three things permanently. First, that distribution beats technical merit. DirectX won not because Direct3D was the best 3D API — it wasn't, in 1997 — but because every Windows PC had it preinstalled and no other API did. Second, that vendor-proprietary 3D APIs are a strategic dead end. Glide's exclusivity was an enormous moat in 1997 and a noose in 1999. The modern equivalent — vendor-only APIs like NVIDIA's CUDA-graphics or AMD's Mantle — are useful as differentiators but have always been fenced in by the cross-vendor abstraction layer (Direct3D, Vulkan, OpenCL) the broader ecosystem actually ships against. Third, that the OpenGL ecosystem only stays viable when somebody big is committed to it. id Software was that somebody from 1997 to 2007. After Doom 3 launched on OpenGL in 2004 and id pivoted to mostly internal use after Rage (2011), OpenGL on Windows essentially died for new game development. Vulkan in 2016 was the late successor.

The modern API war is Vulkan vs DirectX 12, and it inherits the same three lessons. Vulkan is the cross-vendor open standard with a thinner driver model — the role Glide and OpenGL played in 1996. DirectX 12 ships on Windows as the politically-safe default — the role Direct3D played in 1998. The technical differences are smaller now, the commercial pressures bigger. If you read the Vulkan-vs-DirectX-12 articles of 2022-2025 with the 1996-2003 history in mind, the parallels are uncanny: same arguments about driver overhead, same arguments about distribution leverage, same vendor-political pressures. The technology changes. The economics don't.

Related guides

• Voodoo5 5500 AGP install + Glide FSAA on Win98 SE
• Voodoo2 SLI Win98 SE install + Glide setup with benchmarks
• GeForce FX 5900 Ultra vs Radeon 9800 Pro — the last DX9 head-to-head

Sources

• AnandTech archive 1999-2002, GPU and chipset reviews (anandtech.com).
• Tom's Hardware GPU history archive, 1998-2003 (tomshardware.com).
• John Carmack's .plan archive on github (github.com/ESWAT/john-carmack-plan-archive) — contemporaneous notes on GLQuake, OpenGL on Windows, and the OpenGL ICD ecosystem.
• Mercury Research / Jon Peddie Research (JPR) discrete GPU market-share reports, 1998-2001.
• VOGONS forum thread compilations (vogons.org) — period driver behavior, hardware quirks, and benchmark verifications.
• Wikipedia 3dfx Interactive article (cross-checked against Anand and Tom's archives for accuracy).
• MobyGames + GiantBomb engine-tag aggregates for DirectX adoption counts.