Direct3D

• 1. Introduction

  ›

  Direct3D is the graphics programming interface that sits between Windows software and the raw power of a graphics card. For most of computing history, getting a program to draw a triangle on screen meant writing different code for every brand of hardware. Direct3D changed that bargain. It promised a single interface that could talk to any graphics card, offloading the heavy lifting of three-dimensional rendering to dedicated silicon.

  Three questions follow from that promise. How did a small startup's medical imaging tool end up as the backbone of PC gaming? Why did game developers nearly reject it in favor of a rival API before it was even finished? And how does a piece of software that began as a thin translation layer eventually grow to manage everything from pixel shading to raytracing, from desktop PCs to Xbox consoles? The answers run through more than three decades of graphics hardware history and a few pivotal decisions that could easily have gone the other way.

• 2. From Medical Imaging to DirectX

  ›

  In 1992, Servan Keondjian, Doug Rabson, and Kate Seekings founded a company called RenderMorphics. Their product, a 3D graphics API named Reality Lab, was built for medical imaging and CAD software, not for games. Microsoft bought RenderMorphics in February 1995, bringing the entire staff on board to build a 3D graphics engine for Windows 95.

  The first version of Direct3D shipped with DirectX 2.0 on the 2nd of June, 1996, and then again with DirectX 3.0 on the 26th of September, 1996. Those early releases carried forward the architecture RenderMorphics had already built. Direct3D offered both an "immediate mode" low-level API and a "retained mode" scene graph API, both derived from Reality Lab's second release.

  The retained mode turned out to be a poor fit for game developers. Only two games that sold a significant volume, Lego Island and Lego Rock Raiders, were ever built on it. Game developers wanted direct control over hardware; the retained mode stood in the way. Microsoft dropped further retained mode updates after DirectX 3.0.

• 3. The Execute Buffer Controversy

  ›

  Direct3D's early immediate mode used a programming model called the execute buffer. Microsoft hoped hardware vendors would process these buffers directly, allocating them in video memory and letting the GPU parse and execute them without CPU involvement. The idea was forward-looking, but the reality was that execute buffers were considered extremely awkward to program.

  The friction was serious enough that developers called on Microsoft to abandon Direct3D entirely and adopt OpenGL as the official 3D API for games, as it already was for workstation applications. Microsoft declined. Rather than switch to OpenGL, the team chose to keep improving their own API, partly to compete with OpenGL and partly to take on proprietary alternatives like 3dfx's Glide.

  The answer came in December 1996, when a team in Redmond took over the immediate mode while the original London-based RenderMorphics team continued work on retained mode. The Redmond team introduced the DrawPrimitive API, which eliminated the need for execute buffers entirely and made Direct3D feel much more like Glide or OpenGL to write. The first beta of DrawPrimitive shipped in February 1997, and the finished version arrived with DirectX 5.0 in August 1997.

• 4. Building the Feature Set

  ›

  DirectX 6.0, released in August 1998, added multitexturing, stencil buffers, and optimized geometry pipelines for x87, SSE, and 3DNow! instructions. It also introduced a licensing arrangement where Microsoft included vendor-specific hardware features in the API in exchange for an early market advantage for the contributing vendor. S3 texture compression entered the API this way, renamed DXTC for the purpose. A bump mapping technique from TriTech came in through the same route.

  DirectX 7.0 arrived in September 1999 and introduced the .dds texture format along with hardware transform and lighting acceleration, a capability first available on PC hardware with Nvidia's GeForce 256. Hardware vertex buffers represented, by the source's account, the first substantive improvement over OpenGL in DirectX history. Even so, the fixed-function multitexture pipeline had grown so complicated to program that the team recognized a new model was needed.

  DirectX 8.0, released in November 2000, provided it. Programmable vertex and pixel shaders let developers write code that ran directly on the GPU without worrying about the underlying hardware state. It was the first major departure from the OpenGL-style fixed-function model, where drawing is controlled by a complicated state machine. DirectX 8.0 also absorbed the last remaining DirectDraw API calls, making Direct3D the single rendering API across the platform.

• 5. The Shader Era and Vista's Gamble

  ›

  Direct3D 9.0 arrived in December 2002, adding the High Level Shader Language for floating-point texture formats, Multiple Render Targets, and texture lookups inside vertex shaders. It became one of the longest-lived versions in the API's history, remaining the baseline for games well into the following decade.

  The jump to Direct3D 10 was bound to Windows Vista and introduced a fundamental shift in how hardware compatibility worked. Earlier versions tracked supported features through "capability bits," a vendor-by-vendor list of what each card could do. Direct3D 10 replaced that with a mandatory minimum standard: if a card called itself Direct3D 10 compatible, it had to support the full feature set, no exceptions. The geometry shader stage was new, allowing geometry to be generated entirely on the GPU rather than handed in from the CPU.

  The timing caused friction. Direct3D 10 hardware was rare when Vista launched, and the massive existing base of older graphics cards meant the first Direct3D 10 games still shipped with Direct3D 9 fallback paths. Games such as Company of Heroes, Hellgate: London, and Crysis all carried both render paths. The DirectX 10 SDK became available in February 2007, and Direct3D 10.1 followed with its runtime shipping alongside Windows Vista SP1 in mid-March 2008. By June 2008, the only Direct3D 10.1 hardware available was ATI's Radeon HD 3000 and HD 4000 series.

• 6. Direct3D 11 and the Threading Problem

  ›

  Direct3D 11 was released as part of Windows 7. Microsoft first presented it at Gamefest on the 22nd of July, 2008, and demonstrated it at the Nvision 08 technical conference on the 26th of August, 2008. AMD previewed working DirectX 11 hardware at Computex on the 3rd of June, 2009.

  The headline addition was tessellation, a technique for subdividing low-detail geometry into finer meshes at runtime, increasing visible polygon counts without requiring artists to store high-polygon assets. But the more lasting engineering change was multithreaded rendering. For the first time, developers could submit rendering work to the same Direct3D device from multiple CPU threads simultaneously, letting multi-core processors drive the GPU more efficiently.

• 7. Direct3D 12 and Console-Level Control

  ›

  Direct3D 12 lowered the abstraction layer further than any previous version. Its lead developer Max McMullen described the goal as achieving "console-level efficiency" and improved CPU parallelism. The mechanism was a shift in responsibility: instead of the driver managing GPU resources on the application's behalf, developers now controlled memory allocation, resource binding, and command submission directly.

  In Direct3D 11, commands traveled from CPU to GPU one by one in sequence, bottlenecked by the speed at which the CPU could issue them. Direct3D 12 replaced that model with command lists, self-contained packages of work that the GPU could consume without waiting on additional CPU input. Bundles within those lists could be reused across frames, reducing redundant work. Descriptor heaps and tables let developers pre-allocate frequently used resources for fast GPU access.

  DirectX Raytracing arrived with Windows 10 version 1809, the October 2018 Update. Shader Model 6.0 shipped with the Windows 10 Creators Update in April 2017, and DirectX 12 Ultimate, which bundled raytracing, mesh shaders, variable-rate shading, and sampler feedback into a single tier called 12_2, came with Windows 10 version 2004 in 2020. Microsoft also released experimental Direct3D 12 support for Windows 7 SP1 in 2019, delivered as a NuGet package.

• 8. Running on Linux

  ›

  Direct3D was designed for Windows, but a parallel ecosystem grew to run it elsewhere. DXVK is an open-source Vulkan-based translation layer for Direct3D 8 through 11 that enables Windows games to run on Linux via Wine. Valve's Proton project, which powers game compatibility on the Steam Deck, uses DXVK as a core component.

  Several DXVK forks addressed earlier API versions: D7VK covered Direct3D 3, 5, 6, and 7, while D8VK added Direct3D 8 support before being merged into the main DXVK project with version 2.4, released on the 10th of July, 2024. D9VK brought Direct3D 9 support and was folded into DXVK on the 16th of December, 2019. For Direct3D 9 specifically, Gallium Nine offers a different approach, running Direct3D 9 applications on Linux without any translation layer at all, aiming for near-native performance.

  For Direct3D 12, the vkd3d library translates calls to Vulkan and is included in Valve's Proton. The Wine project also maintains WineD3D, which translates Direct3D to OpenGL and can run on Windows itself under certain conditions. Taken together, this ecosystem means that a game written against Direct3D's various versions can run on hardware and operating systems its designers never anticipated.