The Pass-Through Cable

There is a specific sound that triggers nostalgia for PC gamers of the late 90s: the loud, mechanical CLICK of a relay. This was the sound of a 3dfx Voodoo card taking over.

In 1996, 3D acceleration was a mess. S3, Matrox, and ATI all had “3D decelerators”—cards that claimed to do 3D but were slower and buggier than just using the CPU. Then came 3dfx Interactive. They did something strange: they released a card that only did 3D. It had no 2D core. It couldn’t show your Windows desktop. To use it, you had to keep your existing 2D video card. You plugged your monitor into the Voodoo, and you used a short, thick VGA “pass-through” cable to connect your 2D card to the Voodoo.

When you launched Quake, the Voodoo detected the signal, fired the relay (CLICK), cut off the 2D card, and began driving the monitor directly.

The SST-1 Architecture

The Voodoo Graphics (Voodoo 1) chipset, codenamed SST-1, was a masterclass in pipelining. It consisted of two main chips:

FBI (Frame Buffer Interface): Handled the Z-buffering, Gouraud shading, dithering, and writing to the screen.
TMU (Texture Mapping Unit): Handled reading textures, applying perspective correction, and—crucially—bilinear filtering.

You could actually chain multiple TMUs together (as seen on the Voodoo 2) to draw multiple textures (like a brick wall + a light map) in a single clock cycle.

Bilinear Filtering: The “Vaseline” Look

Before 3dfx, 3D games (like software Quake or Duke3D) looked “crunchy”. When you got close to a wall, you saw giant, blocky pixels (texels). The Voodoo introduced hardware Bilinear Filtering. It took the four nearest texels and blended them smoothly. Suddenly, the world looked soft. Critics called it “blurry” or “smeared with Vaseline,” but compared to the jagged mess of software rendering, it looked like CGI.

Glide: The Secret Weapon

Microsoft’s Direct3D was in its infancy (DirectX 3.0) and it was awful—complex, slow, and hard to program. OpenGL was professional but heavy. 3dfx provided their own API: Glide.

Glide was a thin wrapper around the hardware. It was essentially “C-callable Assembly” for the Voodoo card.

Want to draw a triangle? grDrawTriangle()
Want to load a texture? grTexDownloadMipMap()

It was lightweight and incredibly fast. Because it didn’t have to support every possible graphics card (like Direct3D did), it had zero overhead.

Code Snippet: Initializing Glide

#include <glide.h>

void init_voodoo() {
    GrContext_t context;
    
    // Select the first Voodoo card found
    grSstSelect(0);
    
    // Open the screen: 640x480, 60Hz
    context = grSstWinOpen(
        0, 
        GR_RESOLUTION_640x480, 
        GR_REFRESH_60Hz, 
        GR_COLORFORMAT_ARGB, 
        GR_ORIGIN_UPPER_LEFT, 
        2, // Number of buffers (Double Buffering)
        1  // Number of auxiliary buffers (Z-Buffer)
    );
    
    // Enable Z-Buffering
    grDepthBufferMode(GR_DEPTHBUFFER_ZBUFFER);
    grDepthBufferFunction(GR_CMP_LESS);
    grDepthMask(GR_TRUE);
}

The GLQuake Moment

The turning point was Quake. John Carmack originally wrote Quake for software rendering. But he ported it to OpenGL. 3dfx wrote a “MiniGL” driver—a tiny subset of OpenGL that translated calls to Glide. The result was GLQuake. It ran at 60fps on a Pentium 133, transparent water, colored lighting, and smoothed textures. It was a revelation. It divided the PC era into “Before Voodoo” and “After Voodoo”.

Death of a Titan

3dfx eventually fell. They tried to build their own 2D/3D combo cards (Voodoo 3, 4, 5) but were outpaced by NVIDIA’s rapid 6-month product cycle and the T&L (Transform and Lighting) engine of the GeForce 256. NVIDIA acquired 3dfx’s assets in 2000. But the SLI (Scan-Line Interleave) technology in your modern RTX 4090? That name—and the concept of linking cards together—was born on the Voodoo 2.