Glide vs OpenGL vs Direct3D: The API War That DirectX 9 Ended

Glide was a vendor-locked API that 3dfx wrote for its Voodoo silicon in 1996, OpenGL was an open cross-platform standard descended from SGI's IRIS GL, and Direct3D was Microsoft's Windows-only API that shipped in DirectX 2.0 the same year. Glide lost because Microsoft closed the feature gap by Direct3D 7, hardware transform-and-lighting arrived on GeForce 256 in 1999, and no other GPU vendor was ever going to license a competitor's proprietary API — DirectX 9 in 2002 was the final consolidation.

The 1996-2003 arc, from Voodoo Graphics to DirectX 9 consolidation

The consumer 3D era did not begin in an orderly way. Silicon Graphics had shipped IRIS GL on its workstations since the late 1980s, and the standardised, portable subset — OpenGL 1.0 — reached ratification through the Architecture Review Board in July 1992 and general adoption on Unix workstations by 1994. Microsoft picked up an OpenGL implementation for Windows NT in 1995. But the PC gaming market of 1995 had no consumer 3D hardware to speak of. Software renderers in Quake, Descent and MechWarrior 2 defined the ceiling. Then, in late 1996, 3dfx Interactive shipped Voodoo Graphics — a pass-through PCI card that only did 3D, that had to sit next to a 2D card, and that came with an API of its own called Glide.

That API mattered. Glide was small — a few dozen calls, thin over the actual silicon, designed for the exact 4 MB EDO memory budget of the first Voodoo. Developers loved it because they could reason about performance directly, and because 3dfx supplied Quake and Tomb Raider ports that made the standard 486-and-Pentium software renderers look primitive by comparison. From late 1996 through Voodoo2's launch in March 1998, Glide was effectively the winning API for PC 3D. Microsoft's Direct3D 3.0 was widely mocked for its execute-buffer model and its awkward COM interface. OpenGL on consumer hardware was patchy — most vendors shipped a partial "miniGL" driver aimed only at running Quake. If you owned a 3D card in 1997 or 1998, you almost certainly owned a Voodoo, and you almost certainly played through Glide.

Then Microsoft executed. Direct3D 5 in 1997 tidied the interface. Direct3D 6 in 1998 added multitexturing and matched Voodoo2's headline feature. Direct3D 7 in 1999 arrived alongside NVIDIA's GeForce 256 — the first consumer card with a hardware transform-and-lighting pipeline that offloaded geometry work from the host CPU. Direct3D 8 in 2000 introduced programmable vertex and pixel shaders. Direct3D 9 in December 2002 stabilised the shader model that would define an entire console generation and effectively ended the API war. By the time 3dfx sold its remaining assets to NVIDIA in December 2000, the game was already lost.

Key takeaways

• Glide (1996) was a proprietary 3dfx-only API — small, fast, and locked to Voodoo hardware. Once the hardware stopped leading, the API had no reason to exist.
• OpenGL survived the consumer war because id Software's Quake engines shipped GL renderers, and because it later dominated CAD, scientific visualisation, and eventually Android and WebGL.
• Direct3D started weak but closed the feature gap by version 7, matched hardware transform-and-lighting on GeForce 256, and shipped programmable shaders in version 8 (2000) and 9 (2002).
• DirectX 9 (December 2002) was the consolidation event: shader model 2.0 became a baseline that lasted through the Xbox 360 generation, and no other consumer API mattered for Windows gaming from that point forward.
• In 2026, Glide games run on modern GPUs through wrapper libraries — dgVoodoo2, nGlide, and OpenGlide translate Glide calls into modern Direct3D or OpenGL equivalents. A period-correct rig is a hobby, not a requirement.

Step 0 — identify which API era your target game actually belongs to

Before you touch hardware, wrapper software, or a shopping list, pin down which API the games you actually want to play were shipped against. A 1996 title like Tomb Raider ships a Glide path, a software path, and — often via patches — a barely usable Direct3D 3 path. A 1999 title like Unreal Tournament ships Glide, Direct3D 6 or 7, and OpenGL renderers, any of which will work. A 2001 title like Serious Sam is Direct3D 8 or OpenGL 1.3 and does not care about Glide at all. A 2004 title like Half-Life 2 is squarely Direct3D 9 and cannot be persuaded to run under anything else.

You want a target-year first, hardware second workflow. Otherwise you will end up with a Voodoo2 SLI setup you cannot use for the Deus Ex install that made you nostalgic, because Deus Ex is a June 2000 Direct3D 7 or Glide title that runs beautifully on a GeForce 2 GTS and is oddly cramped on Voodoo2. Or you will build a lavish Athlon XP box for Battlefield 1942 and discover that your carefully sourced Voodoo3 3000 cannot render half the terrain because the game wants hardware T&L that the Voodoo3 refused to include.

Glide: what a vendor-locked API bought 3dfx, and what it cost them

Glide's architectural bet was that a thin abstraction over specific silicon was worth more than portability. Voodoo Graphics had 4 MB of EDO RAM split into a 2 MB framebuffer and a 2 MB texture cache, ran at 50 MHz, and shipped with a fixed-function pipeline of triangle setup, texture mapping, alpha blending and dithering. Glide exposed almost exactly that. There was no abstraction to hide behind — if the hardware could not do trilinear filtering on a single pass (Voodoo1 could not), the API had no polite fiction to paper it over. That directness produced consistently good-looking games and consistently predictable performance.

Voodoo2 in March 1998 doubled down. 12 MB of EDO on a 100 MHz core, dual texture units for single-pass multitexturing, and — through the SLI ribbon connector — support for two cards running scanline-interleaved at 1024x768 (a resolution that stunned reviewers used to 640x480). TechPowerUp's Voodoo2 database entry still lists the exact clock, transistor count, and memory configuration; the fill rate was roughly 90 Mtexels/s from a single card and 180 Mtexels/s from an SLI pair. For 1998, this was enormous.

The cost showed up in 1999. 3dfx acquired STB Systems to make its own boards, which alienated Diamond, Creative and other partners that had been happily selling reference-design Voodoos. The Voodoo3 launched without 32-bit colour output and without a large-texture path — decisions that were defensible in 1997 but were being visibly outclassed by NVIDIA's TNT2 and Matrox G400 by mid-1999. Glide had less to differentiate itself as Direct3D 6 and 7 arrived. VSA-100 and Voodoo5 in 2000 were competitive on paper but arrived late, priced high, and against a GeForce 2 GTS that had hardware transform-and-lighting Glide had no answer for. NVIDIA bought the assets in December 2000.

OpenGL and the miniGL drivers: how id Software kept the standard alive on consumer hardware

OpenGL's consumer PC survival came down to one company. John Carmack shipped GLQuake in January 1997 as an accelerated port of Quake using OpenGL calls. Full OpenGL implementations on consumer 3D cards did not really exist yet, so 3dfx wrote a "miniGL" driver — a partial implementation supporting exactly the subset of OpenGL that Quake needed. Every other vendor followed: PowerVR, Rendition, ATI, and NVIDIA all shipped miniGL drivers whose only job was to run GLQuake acceptably.

Quake II in December 1997 raised the bar. Quake III Arena in December 1999 required a full OpenGL 1.1 implementation with multitexturing. By that point NVIDIA and ATI had complete drivers, and OpenGL 1.2 (1998), 1.3 (2001) and 1.4 (2002) each added the features Direct3D was adding at roughly the same cadence. The Khronos OpenGL history reference walks through the extension mechanism that let vendors expose new hardware features without waiting for the ARB — the same mechanism that made cross-vendor driver quality unpredictable and eventually pushed most Windows game developers toward Direct3D 9 by the mid-2000s.

Direct3D: from widely-mocked early revisions to DirectX 7-9 consolidation

Direct3D 1.0 shipped inside DirectX 2.0 in June 1996 and was largely inherited from a Microsoft acquisition of RenderMorphics. It had two modes — an "immediate mode" that developers hated and a "retained mode" almost nobody used. Direct3D 3.0 in 1996 was the one Chris Hecker wrote his famous open letter about, arguing that OpenGL was better designed. Microsoft did not disagree; it kept iterating.

Direct3D 5 (1997) collapsed the immediate-mode interface into something usable. Direct3D 6 (August 1998) added multitexturing to match Voodoo2. Direct3D 7 (September 1999) added hardware transform-and-lighting support in software so titles could ship a T&L path targeting the GeForce 256 that had just launched. Direct3D 8 (November 2000) introduced programmable vertex shader 1.0 and pixel shader 1.0-1.3, retiring the fixed-function pipeline as the interesting frontier. Direct3D 9 (December 2002) stabilised shader model 2.0, added HLSL as a first-class shading language, and became the baseline that games shipped against for the next decade. Nine successive point releases through DirectX 9.0c (August 2004) refined it enough that Half-Life 2, Doom 3 (which shipped an OpenGL path anyway), Battlefield 2, and every Xbox 360 launch title relied on the shader model 2 and 3 features it carried.

Contemporary technical journalism tracked the API war closely — AnandTech benchmarked every driver revision from 1997 through the GeForce 6 era, and their archive is still the single best source for reproducible period numbers on Voodoo3 versus TNT2, GeForce 2 versus Radeon 7500, and the shader-model-2 GeForce FX 5800 debacle that briefly gave ATI's Radeon 9700 an outright win at DirectX 9's launch.

API support matrix by hardware era

Classic titles, API paths, and which wrapper handles each

Running Glide titles in 2026: dgVoodoo2, nGlide, and OpenGlide compared

In 2026, three mature wrappers cover the Glide catalogue. dgVoodoo2 by Dege translates Glide 2.x and 3.x plus early Direct3D calls into Direct3D 11 or 12. It handles resolution scaling up to 4K, forces MSAA and anisotropic filtering that the original silicon could not run, and covers roughly the whole commercial Glide catalogue. Gotcha: some titles read hardware IDs and refuse to launch — you edit the wrapper's INI and spoof a Voodoo2. nGlide by Zeus Software targets Glide 2.11 and 3.10 with a Direct3D 9 back end and prioritises accuracy over feature-forcing. Older, simpler, and quieter. Gotcha: no shader-based post-processing, and 4K upscaling is on Direct3D 9's terms. OpenGlide is the classic open-source wrapper — mature, portable, but with a smaller compatibility list than dgVoodoo2 in 2026.

Practical order for a new install: try dgVoodoo2 first. If it hitches or corrupts a specific title, drop in nGlide and see if the more conservative translation clears it. Keep OpenGlide as a last resort or when you want a wrapper you can inspect.

Building a period-correct machine — an Intel Core i7-9700K box is not it

A 2019-era Intel Core i7-9700K (B07HHN6KBZ) is a strong host CPU for retro emulation on modern hardware — DOSBox Staging, 86Box, PCem and QEMU all like fast single-thread performance and it has plenty. But it is not a period-correct 1998 CPU, and if you have decided you want a real Voodoo2 rig rather than a wrapper, the shopping list is different.

A period-correct 1998 build wants a Pentium II 400 or 450, 128 MB of 100 MHz SDRAM, a BX440 chipset motherboard with an AGP 2x slot for the 2D card, and a PCI Voodoo2 (single, or two in SLI). The 2D card can be a Matrox G200 or Millennium G400 for razor-sharp 2D over VGA. Storage is where new tooling helps enormously. A CompactFlash-to-IDE adapter with a modern card — a Transcend CompactFlash 4GB (B000VY7HYM) is comfortably era-appropriate — gives you a silent, cool, reliable "hard disk" for a Windows 98 SE install, and you can pull the card, image it in a modern box, and put it back. For handling actual vintage IDE drives that you have inherited, ripped, or bought used, a Unitek SATA/IDE to USB 3.0 adapter (B01NAUIA6G) is the workhorse — it will read 40-pin IDE hard disks and CD/DVD drives over USB on any modern desktop, which makes forensic recovery of an old Windows 98 install tractable.

The i7-9700K stays on the modern side of your desk as the wrapper box, the imaging host, and the general-purpose PC. The Pentium II box sits next to it running Quake II and Unreal Tournament under Glide the way they shipped.

Input and audio for period-correct play

Period-correct input is where most people quietly accept modern conveniences. A PS/2 keyboard and mouse from 1998 will work, but so will a modern USB-to-PS/2 combo. An 8BitDo Pro 2 Bluetooth Controller (B08XY8H9D5) is genuinely useful — it maps cleanly to DirectInput on Windows 98, works over USB with a wired mode toggle, and covers the modern-hardware emulation cases at the same time. A Logitech MK270 wireless keyboard and mouse (B0DHGGRYZ9) does not break the illusion for input either — the unifying receiver reads as a bog-standard USB HID device to Windows 98 SE and gets out of the way. Audio is a separate rabbit hole: a Sound Blaster AWE64 or Live! 5.1 handles both DOS Sound Blaster games and Windows DirectSound with genuine hardware acceleration that modern chipsets no longer implement.

Verdict matrix

Emulate with a wrapper if you want to play the games, you want them at 1440p or 4K with modern filtering, you already own a modern PC, and you do not care about the specific dithering pattern a Voodoo2 produces over VGA.

Build period-correct hardware if the exact frame pacing, the exact 16-bit colour output through an analogue chain, and the specific feel of a CRT with 3dfx dithering are what you are chasing — or if the build itself is the hobby.

Buy a reissue or source port if the title has one — Quakespasm for Quake, KMQuake2 for Quake II, and a growing set of Unreal Engine 1 patches all deliver the game without needing either the wrapper stack or the vintage hardware. Reissues on GOG typically ship with dgVoodoo2 preconfigured.

Bottom line

Glide won 1996-1998 because it was the only serious game in town, and lost 1999-2002 because Direct3D closed the feature gap, OpenGL kept id Software's engines alive, and hardware transform-and-lighting on GeForce 256 changed the workload profile in a way 3dfx had not planned for. DirectX 9 in December 2002 formalised the shader-model baseline that would run PC gaming until Direct3D 10 arrived on Windows Vista in 2007. In 2026, playing the Glide-era catalogue is a solved problem — the wrapper stack is mature, the games are cheap, and the only reason to build period-correct hardware is because you want to.

Related guides

• Retro GPU category
• Voodoo2 buying guide in 2026
• Building a Windows 98 SE gaming PC in 2026
• dgVoodoo2 configuration walkthrough
• CompactFlash-to-IDE builds for retro PCs

Frequently Asked Questions

Why did games look better under Glide than Direct3D at the time?

Glide exposed 3dfx hardware features directly with minimal abstraction, so developers targeted the exact capabilities of the silicon rather than a lowest-common-denominator feature set. Early Direct3D revisions also had a reputation for awkward interfaces that discouraged careful optimization. The visual gap narrowed sharply once Direct3D matured through its seventh and eighth revisions.

Can you run Glide games on modern hardware without a Voodoo card?

Yes. Wrapper libraries translate Glide calls into modern Direct3D or OpenGL equivalents, and the mature ones handle the large majority of the Glide catalogue including resolution and filtering improvements the original hardware could not manage. Compatibility is title-specific, so check a per-game list before assuming a particular release works cleanly.

Is period-correct hardware worth it if wrappers exist?

For accuracy of feel, yes for some people: the original dithering, the sixteen-bit colour output through an analogue chain, and the exact frame pacing are not fully reproduced by translation layers. For simply playing the games, wrappers are easier, cheaper and higher resolution. The build is a hobby in itself rather than the efficient path to playing.

What killed 3dfx as a company?

Multiple compounding decisions rather than one event: acquiring a board manufacturer and alienating the partners who had been selling their chips, delayed product cycles against a competitor executing faster, and a vendor-locked API losing relevance as standards matured. The assets were ultimately absorbed by a competitor. Attributing it to any single cause oversimplifies a multi-year decline.

Which API should a retro build target today?

It depends entirely on the era you are recreating. A 1998 build centres on Glide with OpenGL for id engine titles. A 2001 build wants solid Direct3D 8 support. A 2004 build is squarely DirectX 9. Choosing the target year first, then the graphics card, avoids buying hardware that cannot run the games you actually want.

Citations and sources

• Khronos — History of OpenGL
• TechPowerUp — Voodoo2 GPU database entry
• AnandTech — GPU and driver benchmark archive