Vulkan vs DirectX 12: 2026 Real-World Frame-Time Benchmark

Vulkan can win the average-FPS chart while DirectX 12 feels smoother in the same game. That apparent contradiction is the useful starting point for comparing the two APIs.

Published Red Dead Redemption 2 tests show why. Vulkan led average performance by a few percentage points in some configurations, while DirectX 12 delivered much stronger 1% lows and fewer severe frame-time excursions. The practical lesson is simple: API choice is workload-dependent, and frame-time consistency matters more than a small average-FPS advantage.

What the frame-time data reveals

At 60 FPS, a frame has 16.67 milliseconds to complete. At 120 FPS, the budget drops to 8.33 ms. A game averaging 100 FPS has a nominal 10 ms frame time, but that average hides what happens when one frame takes 30 or 40 ms.

That long frame is the hitch you notice while turning into a crowded street, entering a new area or waiting for a shader to compile.

The most useful question isn't “Which API is faster?” It is:

Which API produces the fewest expensive frames on this GPU, driver, game build and shader-cache state?

The published RDR2 comparisons are a good example. ComputerBase reported a small DirectX 12 average-FPS advantage on an RTX 2070 at 1080p—about 2% in the cited configuration—while its 99.8th-percentile frame-time result favored DirectX 12 by roughly 16%. At 1440p, the reported frame-time difference reached approximately 66%.

KitGuru found a different balance in its own test system. Vulkan led average FPS by as much as about 6% in some scenarios, but DirectX 12 produced better 1% lows:

Sources: ComputerBase’s RDR2 benchmark and KitGuru’s API analysis.

These are published third-party results, not one controlled 2026 lab run. The two reports use different hardware, drivers, game builds, API implementations and presets, so their percentages shouldn't be combined into a single ranking. ComputerBase's cited comparison uses an RTX 2070 for the RDR2 API results; its test pages document the driver, game version and graphics settings. KitGuru likewise lists its own GPU, driver and preset on the linked methodology pages. Those details matter: changing any one of them can move the result.

The percentile terminology also causes unnecessary confusion. A 99th-percentile frame-time value is the boundary for the slowest 1% of frames: if the result is 22 ms, at least the slowest one percent reached roughly 22 ms or more. It is not the same thing as “99th-percentile FPS,” which would invert the measurement and is easy to misread. For frame pacing, higher-percentile frame time is usually worse; lower is better.

Synthetic tests can reverse the ordering. ComputerBase measured Vulkan ahead of DirectX 12 in 3DMark Steel Nomad by about 12% on an RTX 4090 and 10% on an RTX 4080 Super, while Intel's Arc A770 favored DirectX 12 by approximately 11%. That spread comes from the complete stack: GPU architecture, driver quality, shader compiler, command submission, barriers and workload shape. The API name alone doesn't explain it.

Why DirectX 12 may feel smoother

Both APIs expose low-level control over command recording, descriptors, resource states, synchronization and pipeline objects. Neither one automatically prevents shader stutter or poor scheduling.

The difference is often the maturity of the surrounding implementation. DirectX 12 is closely tied to Windows, Microsoft's driver model, PIX and the Xbox toolchain. A Windows release may receive more testing and tuning on its D3D12 path than on its Vulkan backend. That doesn't make D3D12 inherently more efficient; it can simply mean that this game's Windows path has fewer rough edges.

Vulkan gives an engine team broad portability, but it also leaves more decisions in that team's hands. Pipeline creation, descriptor allocation, memory management, barriers and feature negotiation all need to be handled correctly. A poorly maintained Vulkan backend can stutter even when the API has plenty of theoretical headroom.

Shader compilation is especially important. A built-in benchmark may look excellent after all pipelines are prepared, while the first trip through a new district produces a visible hitch. The same game can also show the opposite pattern if one API has a mature cache and the other compiles during traversal.

A useful test therefore has both cold and warm runs:

1. Clear or disable the relevant shader caches and capture the first launch.
2. Repeat the same route after pipelines have been built.
3. Run the built-in benchmark.
4. Capture real gameplay through a streaming-heavy section.

Use a frame-time capture tool such as PresentMon or CapFrameX, and inspect the result in PIX for a native D3D12 build. On Linux, pair MangoHud or Gamescope statistics with a PresentMon-compatible capture where available. A graph that sits near 10 ms and then jumps to 40 ms tells you more than an average of 100 FPS. Mark the spike against the route: shader compilation, asset streaming, CPU submission, simulation or a driver wait.

Driver cache state must be recorded alongside the result. GPU vendor, driver version, operating system and game updates can all change cache behavior. Comparing a warm Vulkan run with a cold D3D12 run is not a meaningful API test.

Microsoft's Work Graphs are relevant to this discussion, but not as a general “D3D12 is faster” switch. Available on supported Windows 11 24H2 and WDDM 3.2 systems, Work Graphs let GPU work generate additional GPU work with less CPU orchestration. That may help a culling or procedural workload that spends too much time building dispatches on the CPU. It won't repair shader stutter, poor barriers or an inefficient renderer, and it requires a workload designed to use the feature.

Native Vulkan, native D3D12 and VKD3D-Proton

On Linux, “Vulkan versus DirectX 12” describes more than two paths:

VKD3D-Proton translates D3D12 concepts into Vulkan. It can perform extremely well, but it isn't native D3D12. Descriptor handling, barriers, pipeline libraries, shader compilation and unsupported edge cases can all affect frame pacing.

That makes the Steam Deck comparison more specific. The useful test is native Vulkan against the game's D3D12 renderer through VKD3D-Proton, with the same resolution, quality settings, power limit, driver and cache state. A well-optimized native Vulkan backend may avoid translation overhead. A mature D3D12 backend through Proton can still win if the native Vulkan path is neglected.

The August 2026 Steam Hardware Survey reported Windows 11 64-bit at 75.53%, Windows 10 64-bit at 24.37% and a DirectX 12-capable GPU category at 91.45%. That 91.45% figure describes reported hardware capability, not actual API usage. It doesn't mean that 91.45% of players are running D3D12, or that every installed game supports it. It does explain why Windows-first studios usually prioritize D3D12.

Vulkan remains strategically important for Linux, Android, handhelds and Proton. An engine that supports only D3D12 has made a platform decision, even if the team thinks of it as a rendering decision.

A benchmark protocol that produces useful answers

For an engine or game team, the minimum useful capture includes:

• GPU, CPU, memory, operating system and driver version
• Game build, API version and graphics preset
• Resolution, upscaling mode and frame limiter
• Cold and warm shader-cache state
• At least three repeated captures of the same route
• Average FPS, GPU time, CPU frame time, 1% low and 99th/99.8th-percentile frame time
• A frame-time graph with spikes annotated

Test at native resolution and at a reduced resolution. If lowering resolution barely changes the result, the bottleneck is probably CPU-side simulation, submission or streaming. If frame time scales strongly with resolution, GPU work dominates and the API gap may narrow.

A practical test matrix looks like this:

Physics belongs in the frame-time report because a fast solver can still create a hitch if rendering waits for it. Broad-phase collision, contact solving, gameplay extraction, animation, networking and render submission may all land on the same frame budget. The renderer isn't isolated from that schedule.

The same applies to platform APIs. Serious Apple support usually means a native Metal backend rather than treating Metal as a thin afterthought. Feature availability varies across Mac, iPhone and iPad GPU families, so a renderer's abstraction has to account for those differences rather than forcing every platform through the same resource and synchronization model.

For product planning, the practical split is clear:

• Prioritize DirectX 12 for Windows- and Xbox-focused games, especially when PIX, ray tracing or Work Graphs are central.
• Prioritize Vulkan when Linux, Android or handheld deployment is a major target.
• Use Metal natively when Apple performance matters.
• Share renderer concepts and asset pipelines, but keep API-specific backends and shader strategies where the platforms require them.

A renderer averaging 100 FPS with repeated 40 ms spikes isn't faster in any player-facing sense than one averaging 95 FPS at a stable 10–11 ms. Capture the ugly moments. Those are the results players remember.