Direct3D vs OpenGL vs Glide: The API War That Shaped PC Gaming

What was the difference between Direct3D, OpenGL, and Glide?

Direct3D was Microsoft's Windows-only 3D graphics API bundled in DirectX from 1995. OpenGL was the open, cross-platform standard from Silicon Graphics that shipped on Windows, Mac, Irix, and Linux. Glide was 3dfx's proprietary API that only ran on Voodoo cards. Glide was thinner, faster, and easier to code against on Voodoo hardware, which is why every big 1996-1999 game shipped a Glide renderer. Direct3D and OpenGL both improved fast enough, and 3dfx collapsed hard enough, that by 2001 Glide was a compatibility problem, not a competitive advantage.

Why the 1996-2003 API war still echoes in every GPU launch

If you built a PC gaming rig between 1996 and 2001 you did not just pick a graphics card, you picked an API. A Voodoo card in the machine meant Glide-first, and the same Quake II, Unreal, Half-Life, or Descent 3 disc could look meaningfully different depending on the renderer path the game auto-selected. NVIDIA and ATI were fighting for the Direct3D crown, id Software's John Carmack was pushing OpenGL forward each engine generation, and 3dfx was leaning on Glide as the moat that would keep Voodoo relevant. Every one of those wars ended by 2003, but the language we still use to describe modern GPUs — vendor extensions, feature levels, driver-level shader compilation, closed-source proprietary paths — was minted right there.

The pattern we see in 2026 with CUDA, ROCm, DLSS 4, and vendor-locked upscalers is not new. It is a rerun of Glide vs Direct3D vs OpenGL with different letters. NVIDIA's CUDA moat is the modern Glide moat: proprietary, faster than open alternatives on the vendor's silicon, and defended by the switching cost of a decade of published code. AMD's ROCm plays the OpenGL role: open standard, cross-platform, forever chasing the leader. Vulkan and DirectX 12 share the Direct3D lane: cross-vendor, standardized, and shaped by the platform holder more than any single silicon vendor.

Rebuilding a period-correct Voodoo rig in 2026 is how you feel that history through your fingertips. Boot Windows 98, launch Unreal, watch the Glide splash flicker, and the whole story of the API war compresses into 10 seconds of dithered translucent water.

Key takeaways

• Glide dominated 1996-1999 because it was thin, fast, and Voodoo-only, and every marquee 3D title shipped a Glide renderer.
• Direct3D caught up in versions 5, 6, and 7 with hardware T&L and better driver-level features, then overtook Glide by 2000.
• OpenGL anchored id Software's Quake, Quake II, and Quake III engines, and remained the professional CAD and workstation choice through the same period.
• 3dfx bought Gigapixel in 1999, cancelled the STB reseller model, and went bankrupt in October 2000. NVIDIA bought the corpse and the patents in December of that year.
• Modern Glide wrappers like dgVoodoo2 and nGlide translate Glide 2.x/3.x calls to Direct3D 11/12 or Vulkan, letting you run Glide-only games on any current GPU.
• A period-correct rig for authentic native Glide needs a Voodoo card, a Pentium II/III or K6-3 CPU, Windows 98 SE, and a small IDE-compatible boot volume.
• CompactFlash cards with IDE adapters have replaced spinning drives for retro builds because they are silent, cool, and imageable from any modern PC.

Why did Glide dominate the early Voodoo era?

3dfx launched the Voodoo Graphics (Voodoo 1) chipset in October 1996 as a 3D-only add-in card that ran alongside a separate 2D VGA card, connected by a VGA passthrough cable. That split-card design let 3dfx spend every gate on 3D throughput while the 2D card handled Windows. On paper the Voodoo 1 was a modest 50 MHz part with 4 MB of EDO RAM. In practice it played real-time 3D at 640×480 with bilinear filtering and 16-bit color at a time when the best software renderers on Pentium 90s were locked to 320×200 with no filtering at all.

Glide was 3dfx's answer to a real developer problem in 1996: Direct3D 3 was slow, unstable, and painful to code against, and OpenGL drivers on consumer Windows PCs were unusable outside of Quake's proprietary mini-driver hack. Glide gave developers a thin, deterministic interface that mapped almost one-to-one onto Voodoo hardware. A Glide port took a weekend for a competent engine team; a good Direct3D port took a month. The result was that every marquee 3D title of the era shipped Glide as the default renderer, with Direct3D and software renderers as fallbacks.

Titles that were meaningfully better on Glide included Unreal, Unreal Tournament, Descent II and III, Need for Speed III, Tomb Raider II and III, and the entire GLQuake and Quake II mini-GL family. Half-Life shipped a Glide back-end that outran its Direct3D path on Voodoo hardware. Diablo II's Glide renderer was so much smoother than its Direct3D or software path that a decade later community patches kept the Glide code alive on modern OSes through nGlide. Retro nostalgia rankings from communities like VOGONS still route through these titles.

The moat was not just performance. It was that Glide was Voodoo-exclusive. If you wanted the definitive Unreal experience in 1998 you bought a Voodoo 2, full stop, because Unreal's Direct3D path had visible seams in the water shader that the Glide path did not. The moat closed a lot of purchase decisions before the customer even reached the store.

How did Direct3D and OpenGL eventually overtake Glide?

Direct3D 5 in 1997 fixed the ergonomics that had made D3D 3 unusable, and D3D 6 in 1998 added multi-texture and other Glide-like features. D3D 7 in 1999 added hardware transform and lighting, which NVIDIA's GeForce 256 was purpose-built to accelerate. The T&L transition mattered because 3dfx's Voodoo 3 did not have hardware T&L. Games written for T&L ran faster on GeForce than on Voodoo 3 for the first time in the API war, and the marketing shifted overnight from "does it run Glide" to "does it support hardware T&L."

OpenGL held its ground through the same period as the API of choice for id Software, the workstation CAD market, and every Unix or Mac cross-platform target. Carmack's public tech notes about the Quake engine convinced a generation of engine programmers that OpenGL was the serious 3D API. Half-Life 2's engine, based on the Quake and Quake II lineage, kept OpenGL relevant into the mid-2000s. The Khronos Group history of OpenGL documents the specification-level competition against Microsoft's push through those years.

3dfx made three fatal decisions between 1999 and 2000. First, they bought STB Systems and cancelled every third-party Voodoo reseller relationship, which cost them the ASUS, Diamond, Creative, and Guillemot channel almost overnight. Second, they refused to license Glide to their competitors, which meant NVIDIA and ATI would never write Glide drivers. Third, they missed the hardware T&L transition and the AGP 4x bus by about a year. By late 2000 3dfx was in bankruptcy, and NVIDIA bought the technology and patents in December of that year. Glide's fate was sealed by the acquisition — 3dfx's engineers folded into NVIDIA, but Glide as an API stopped receiving updates almost immediately.

By 2001 Microsoft's DirectX 8 shipped programmable pixel and vertex shaders through Direct3D 8, and OpenGL's ARB extensions caught up soon after. Programmable shading was the feature that killed fixed-function 3D APIs, and Glide had no answer for it because 3dfx no longer existed to write one.

Which classic games are locked to which API, and how do wrappers help today?

Most late-1990s and early-2000s games shipped multiple renderers, but a meaningful set of titles look and play meaningfully better in Glide than in their Direct3D or software fallback. The community-preserved list is long, but the tent-pole examples are:

• Unreal 1 and Unreal Tournament (1998-1999) — Glide's translucent water, colored lighting, and volumetric effects were much cleaner than the D3D path.
• Diablo II Classic and its Lord of Destruction expansion (2000-2001) — Glide is the smoothest and most stable renderer on any hardware, and the nGlide wrapper is how the community keeps Glide alive on modern PCs.
• Need for Speed III and High Stakes (1998-1999) — Glide was the only path with 30+ FPS on Voodoo 2, and the reflections look different.
• Descent 3 (1999) — Glide was the shipping recommended renderer through the Interplay-era patches.
• Tomb Raider II and III (1997-1998) — Glide colored-lighting looked notably better than D3D on Voodoo hardware.
• Half-Life 1 and its Blue Shift and Opposing Force expansions (1998-1999) — Glide back-end runs faster on Voodoo than D3D or the OpenGL mini-driver.

For modern hardware, two wrappers dominate the compatibility story:

• dgVoodoo2 — translates DirectX 1-9 and Glide 2.x/3.x calls to modern Direct3D 11 or 12. It is the general-purpose wrapper of choice because it does not require the game to know it is being wrapped. Drop the DLLs next to the game executable and boot.
• nGlide — translates Glide 2.x and 3.x specifically to modern Direct3D or Vulkan. It is the highest-fidelity Glide-only wrapper, and Diablo II Classic through the current community patches ships nGlide bindings out of the box.

Both wrappers let you run resolution scaling that was physically impossible on Voodoo silicon. A Glide-native title clamped to 640×480 in 1998 can render at 4K through dgVoodoo2 on a modern GPU while preserving the original rendering feel. That trade-off — authenticity versus convenience — is why most retro-PC hobbyists keep one period-correct rig for the native feel and use wrappers for everyday revisits.

Timeline and spec table

The compression on Direct3D between versions 3 and 7 is what killed Glide's ergonomic advantage. By the time Direct3D 7 shipped, coding against D3D was no longer painful, so Glide's "easy to target" moat evaporated even before its "faster on Voodoo" moat did.

Compatibility table: notable late-90s/early-2000s games vs preferred API and patch

The pattern is that games with active community patches — Unreal, Diablo II, Deus Ex, System Shock 2 — have converged on modern D3D11 renderers written from scratch. Games without active patches still rely on wrappers.

What you'll need: building a period-correct rig to revisit Glide in 2026

A minimum period-correct rig to run Glide 2.x and 3.x titles natively looks like:

The Voodoo 2 SLI pair is the flagship build for Unreal-era Glide. Two 12 MB cards pass frames alternately through a ribbon cable, doubling fill rate and letting you run 800×600 or 1024×768 in 1998-era titles that were engineered around 640×480. On a period-correct Windows 98 SE install with the Microsoft Direct3D docs as reference material for compatibility settings, a Voodoo 2 SLI pair still feels like the peak Glide experience.

If your goal is casual retro nostalgia without soldering ancient hardware, the more accessible entry point is a plug-and-play era console. The Nintendo Super NES Classic Edition is not a Glide machine, but it captures the same 1996-1999 living-room feel with a modern HDMI output. Many enthusiasts run both — a Voodoo build on the desk for Glide, an SNES Classic on the TV for couch nostalgia.

How do you image and boot a vintage drive from CompactFlash today?

Spinning IDE drives from 1998 are the single most common failure point in retro builds in 2026. Bearings dry, platters develop bad sectors, and the ancient IDE firmware sometimes negotiates the wrong DMA mode at boot. The industry-standard workaround for the last decade has been to replace the spindle with a CompactFlash card in a passive CF-to-IDE adapter. CF cards speak the same PATA electrical protocol as IDE drives, so the motherboard sees a CF card as just another IDE device with no BIOS changes.

The workflow that works reliably in 2026 is:

1. Pick a CF card in the 4-8 GB range with MLC NAND and DMA mode 4 support. The Transcend CF133 4GB CompactFlash is the community reference — it is one of the last new-old-stock cards that honors the DMA modes vintage BIOSes expect.
2. Plug the CF into a modern PC through a USB-connected CF reader. Windows 10 or 11 will mount it as a removable drive.
3. Image a known-good Windows 98 SE install onto the CF card. Vogons and archive.org host community-curated images with the Voodoo drivers, DirectX 8.1, and the KernelEx patch pre-installed. Total install size lands around 700 MB, so a 4 GB card leaves plenty of headroom for period-correct games.
4. Move the CF card into a passive CF-to-IDE adapter and drop the adapter into your vintage build's primary IDE slot. Boot.
5. For iterative development, keep the Unitek SATA/IDE to USB 3.0 Adapter on your modern desk. When you brick a boot with an experimental driver install, pop the CF out, re-image from your golden Win98 SE snapshot in 30 seconds, and drop it back in.
6. If you keep any period-correct spindle drives — say, a Quantum Fireball for authenticity — the 3.5" IDE support on the FIDECO SATA/IDE to USB 3.0 Adapter covers off the imaging side without moving the mechanical drive.

The whole workflow costs under $100 in 2026 for the adapters and CF card, versus $60-$200 for a working period-correct IDE drive with unknown remaining life. Every serious retro builder we know has converged on CF-plus-adapter as the standard boot volume.

Bottom line: the API war's lasting legacy

Glide won the graphics API war for three years, then lost the next three, then vanished with 3dfx in a single quarter. Direct3D won because Microsoft owned Windows and iterated fast enough after Direct3D 5 to catch up. OpenGL survived because id Software's engines and the workstation market kept it commercially load-bearing. Every modern GPU launch, every closed-source upscaler moat, every "our API is 40% faster on our silicon" NVIDIA slide is a rerun of Glide's 1996-1999 pitch.

For a retro builder in 2026, the practical takeaway is that Glide is a museum piece worth revisiting on the original hardware once, then leaning on dgVoodoo2 and nGlide for the day-to-day. The API war is worth revisiting because it teaches you what happens when a proprietary API moat crumbles: the vendor collapses, the standard wins, and the next decade of hardware is designed around the winning cross-vendor API. That has already happened with Vulkan and DirectX 12 unseating vendor-specific paths; it will happen again with whatever comes after CUDA.

Related guides

• Sound Blaster's monopoly and the DOS audio wars
• Voodoo 2 SLI: the definitive Unreal 1 build in 2026
• Building a period-correct Windows 98 rig in 2026

Sources

• VOGONS — Very Old Games On New Systems — community reference for period-correct retro-PC hardware and software compatibility.
• Khronos Group — History of OpenGL — canonical timeline of OpenGL versions, extensions, and vendor participation from 1992 forward.
• Microsoft — Direct3D reference (Windows Win32) — first-party documentation for the entire Direct3D API family.