DLSS is a technology that increases frame rates without noticeable loss of quality. The video card renders the game at a low resolution, and the trained neural network restores the image to a high resolution, adding details and removing jagged edges on object boundaries.
DLSS is used in demanding computer games with ray tracing, where even powerful video cards struggle to output 60 frames per second at maximum graphics settings. It is utilized in open-world projects, flight simulators, and esports disciplines where smoothness of motion is critical. DLSS requires an NVIDIA RTX series video card and support of a specific title at the software code level.
In early versions, noticeable blurring occurred during motion, causing textures to lose sharpness. In modern games, artifacts sometimes appear as slight flickering of fine details, such as a chain-link fence or wires. The algorithm faces the greatest difficulties when reconstructing fast-flying particles and transparent surfaces, where halos and short-term frame blending with a ghosting effect may appear.
How DLSS works
Unlike spatial upscaling methods (such as FSR 1.0 or bicubic filtering), which work only with a single static frame, DLSS uses temporal data: the neural network analyzes a sequence of frames, taking into account object motion vectors and information from the depth buffer. The model is trained on an NVIDIA supercomputer, where the algorithm is shown ideal 16K images and asked to restore a similar result from a heavily compressed picture. When the trained network is loaded into the driver, the video card’s tensor cores compare the current low-resolution frame in real time with pixel displacement data from previous scenes. The result is the synthesis of a stable image that often surpasses standard rendering with TAA anti-aliasing in sharpness. The technology completely replaces traditional anti-aliasing, as it automatically removes aliasing during the upscaling process and restores fine geometric lines that were lost when reducing the resolution.
DLSS functionality
- Spatial image upscaling. DLSS reconstructs the output high-resolution frame from low-resolution input data using a convolutional neural network trained on pairs of ultra-high-quality reference images.
- Temporal feedback and accumulation. The algorithm analyzes motion vectors and the frame history buffer to extract subpixel details from previous renders, suppressing noise and flickering with minimal input lag.
- Transformer-based autoencoder. The DLSS 4 architecture shifted from convolutional networks to Vision Transformer, allowing parametric aggregation of the global scene context and increased accuracy in recognizing complex geometric structures.
- Replacement of traditional anti-aliasing. The technology completely replaces temporal anti-aliasing in the pipeline, using neural network resolution of pixel coverage conflicts, which eliminates motion blur and ghosting typical of TAA.
- Ray load management. Tensor cores process ray intersections reflected from diffuse surfaces, interpolating missing radiometric data to denoise global illumination without resource-intensive per-pixel tracing.
- Tensor (Multidimensional container for numerical data)
- Direct lighting reconstruction. Ray Reconstruction is trained on noisy tracing inputs, recognizing light flow patterns for instant restoration of physically correct indirect illumination and specular reflections.
- Multiple frame generation. Hardware optical flow analyzes consecutive game frames, after which a convolutional network synthesizes up to three intermediate images, increasing the frame rate without loading the GPU geometry pipeline.
- Optical flow analysis. The specialized Optical Flow Accelerator engine computes per-pixel scene motion at the hardware level, providing displacement vectors for frame interpolation with accuracy down to individual texels.
- Flip Metering for synchronization. The technology adaptively regulates the frame output pace based on display analysis, preventing tearing and framepacing irregularities at variable refresh rates.
- Model pre-training. The network model is pre-trained on an NVIDIA DGX supercomputer using high dynamic range rendering datasets and an iterative denoising method to minimize spatiotemporal smoothing error.
- Specific ray tracing. In DLSS 3.5 mode, the framework integrates directly into the tracing denoiser, recognizing high-frequency ray cutoff artifacts and restoring correct normals for secondary light bounces.
- Static supersampling resolution. DLSR (Deep Learning Super Resolution) is a basic form of the method, where the driver applies a universal upscaling model to any 3D application, limited by the lack of access to motion vectors.
- Execution on tensor cores. DLSS model computations are performed exclusively on the matrix accelerators of the Volta, Turing, Ampere, Ada Lovelace, and Blackwell architectures, minimizing the load on shader multiprocessors.
- Ultra Performance mode. For 8K resolution, the input buffer can be rendered at a 1:9 ratio from the target, and the neural network restores the high-definition texture using statistical prior knowledge of natural images.
- Parameter updates via driver. Weight models are stored in the driver and can be updated with each Game Ready package, allowing iterative improvement in the processing quality of fine alpha textures, wires, and grilles without a game patch.
- Comparative predictive rendering. The algorithm compares the current pixel color with the prediction based on motion vectors; upon detecting disocclusion, a spatial rather than temporal reconstructor is applied to prevent artifacts.
- Particle processing accuracy. The system is trained to recognize stochastic alpha noise from effects such as smoke and fire, preventing excessive smoothing of transparent quads and preserving the voxel structure of volumetric fog.
- Adaptive dynamic resolution. DLSS can work in tandem with buffer scaling, where the input resolution is dynamically reduced in scenes with heavy overdraw, and the upscaler maintains a stable target frame rate.
- Local LOD bias selection. The technology controls the level of detail of MIP textures when rendering at a low resolution, feeding the sharpest maps from the image pyramid into the neural network to prevent blurring of the final frame.
- Anti-aliasing of fine geometry. A specialized network layer detects high-frequency staircase artifacts on polygonal edges and thin linear objects, synthesizing smooth gradients without losing the sharpness of surface micro-details.
Comparisons
- DLSS (CNN) vs DLSS (Transformer). NVIDIA’s transition from convolutional neural networks to the Transformer architecture radically changed image quality. The old CNN version tends to smear fine details in motion and exhibits characteristic shimmer on thin elements. The new Transformer model demonstrates superior temporal stability, restores textures, wires, and small text significantly better, eliminating the parasitic artifacts typical of its predecessor.
- DLSS Super Resolution vs AMD FidelityFX Super Resolution. Both technologies restore resolution, but the implementation is fundamentally different. DLSS uses tensor cores and a machine learning model, giving a sharper image with minimal halos on contrast edges. FSR works on heuristic algorithms without AI, causing a loss of detail on distant objects and noticeable pixel instability (fizzle) on thin structures.
- DLSS Frame Generation vs AMD Fluid Motion Frames. NVIDIA’s frame generator uses optical flow and motion vector data from the game engine, maintaining interface stability. AMD’s AFMF technology operates at the driver level without access to the depth buffer, so it completely disables itself during sharp camera turns to prevent artifacts. The DLSS FG result is significantly cleaner visually, whereas AFMF shows noticeable geometry breaks at UI junctions and in fast scenes.
- DLSS Ray Reconstruction vs Intel XeSS. Ray Reconstruction is an AI-based denoiser that replaces traditional heuristics in ray tracing, critically improving the clarity of reflections and global illumination. Intel XeSS, as a supersampling analogue, has no such function for tracing. In games with intensive ray tracing, the difference is colossal: DLSS delivers noise-free and detailed surfaces, while XeSS only upscales an already noisy image using standard methods.
- XeSS (Intelligent upscaling with frame reconstruction)
- DLSS Frame Generation vs FSR 3 Frame Generation. The main technical difference lies in hardware acceleration. NVIDIA utilizes the Optical Flow Accelerator (OFA) in the Ada Lovelace architecture, reducing the load on shader units and minimizing latency. AMD’s solution relies entirely on compute shaders, creating higher base latency and requiring mandatory use of Anti-Lag to maintain control responsiveness, making the final experience feel less smooth.
OS and driver support
DLSS is implemented through proprietary NVIDIA software interfaces built into the GeForce Game Ready driver, which recognizes the operating system, kernel version, and GPU model to activate tensor cores; support is limited to 64-bit versions of Windows 10 and 11, as well as select Linux distributions via the proprietary driver with Vulkan extensions, where the driver dynamically loads the nvngx.dll dynamic link library, verifying the digital signature and version control before initializing the neural network upscaler in the gameplay.
Security
The DLSS security mechanism is based on cryptographic component verification: the driver performs a hardware integrity check of executable modules through the NVIDIA Signed Firmware and Trusted Application subsystem, the nvngx.dll library undergoes digital certificate validation using a public key embedded in the UEFI image of the video card, and at the frame invocation stage, the neural network executes in an isolated hardware sandbox of the tensor cores, excluding malicious shader injection or user-mode interception of the video buffer.
Logging
DLSS activity logging is carried out through two channels: the driver operation log records initialization events, the GPU serial number, library version, and activation error code into the system Event Tracing for Windows, and the game application optionally captures service status flags (model load success, input-output resolutions, preset type) into its own debug output via the NVIDIA Streamline SDK, where each frame is marked with a timestamp and the identifier of the neural network used.
Limitations
The functional limitations of DLSS are determined by the architecture: the technology requires the mandatory presence of tensor cores starting from the Turing generation (GeForce RTX 20 series) and does not function on GTX GPUs or third-party accelerators; the output image is formed strictly within fixed resolution presets set by the driver, while the neural network is trained on a static NVIDIA reference dataset and does not adapt to a dynamically changing scene in real time, which defines deterministic behavior within a single library version without the possibility of user-side additional training.
History and development
The development of DLSS began in 2018 with the release of the Turing architecture, where the first version used a per-frame neural network trained on per-pixel comparison with reference 16x supersampling for each specific game; version 2.0 in 2020 switched to a generalized temporal model with motion vectors, exposure mask, and a unified training set, implementing reconstruction through feedback gates on tensor cores; DLSS 3.0 added optical flow generation via the hardware Optical Flow Accelerator, computing an intermediate frame based on consecutive images without the involvement of the classical rendering engine, and in 2025 DLSS 4 introduced a transformer architecture with self-attention, replacing the previous convolutional layers, allowing simultaneous upscaling, ray reconstruction, and generation of multiple frames with enhanced detail of geometry and lighting.