How DirectSR Unifies Super Resolution in DirectX

Microsoft’s DirectSR (Direct Super Resolution) is an API designed to streamline the integration of upscaling technologies into modern video games. By establishing a unified interface between game engines and hardware-specific upscalers like NVIDIA DLSS, AMD FidelityFX Super Resolution (FSR), and Intel XeSS, DirectSR eliminates the need for developers to write and maintain separate codebases for each vendor. This article explains how DirectSR abstracts temporal upscaling inputs, coordinates with GPU vendor drivers, and delivers a consistent super-resolution pipeline within DirectX 12.

Standardizing the Input Pipeline

Temporal super-resolution technologies share a core set of graphical requirements to reconstruct a high-resolution frame from a lower-resolution render. Previously, each vendor SDK expected these parameters in slightly different formats, conventions, or coordinate spaces.

DirectSR resolves this fragmentation by establishing a single, standardized set of engine inputs:

  • Color Buffers: Both the low-resolution render target and the high-resolution output destination.
  • Depth Buffers: Geometric depth data to determine pixel occlusion and distance.
  • Motion Vectors: Per-pixel velocity vectors that track how surfaces move across successive frames.
  • Camera Jitter Offsets: Sub-pixel offsets applied during rendering to sample different points of the scene across frames.
  • Exposure and Reactive Masks: Optional helper textures used to preserve dynamic elements like user interfaces, particles, or rapid lighting shifts.

Because developers provide these parameters to DirectSR once, the API automatically converts, maps, and packages the data to match the precise expectations of the active upscaling provider.

The Driver and Plugin Architecture

DirectSR acts as an abstraction layer positioned between the game engine and the underlying hardware. Instead of compiling vendor-specific SDK binaries directly into the game's executable, DirectSR relies on a modular architecture:

  1. Vendor Driver Implementations: GPU manufacturers (NVIDIA, AMD, and Intel) implement DirectSR support directly within their graphics drivers or via dedicated runtime plugins. When DirectSR initializes, it queries the system to detect which technologies the installed hardware supports.
  2. Built-in Fallbacks: To ensure wide compatibility across systems without specific driver-level variants, DirectSR includes native support for common algorithms—such as AMD FSR 2.2—directly within the DirectX 12 Agility SDK runtime. This guarantees that even without specialized hardware, games can provide temporal upscaling.

Runtime Execution Flow

During gameplay, the application interacts with DirectSR through a common set of DirectX 12 command-list calls:

  • Initialization and Capability Querying: The game engine queries DirectSR to determine the available upscaling variants (e.g., DLSS on GeForce hardware, XeSS on Arc, or FSR across general hardware). The game can then present these options to the player or select the optimal path automatically.
  • Resource Allocation: DirectSR manages the internal scratch buffers and historical frame data required for temporal reconstruction, reducing manual memory management for the developer.
  • Dispatch: At the end of the rendering pipeline, the game records a DirectSR dispatch command onto the standard DirectX 12 command list. DirectSR routes the workload through the active vendor backend, outputting the reconstructed, anti-aliased image at native display resolution.

By shifting upscaling from isolated, proprietary implementations into a core platform feature of DirectX, DirectSR allows developers to target a single interface while ensuring players retain access to hardware-tailored performance and image fidelity.