In September 2026, a developer known as MAAN released "OpenDLSS-NR," a reimplementation of the neural rendering network used in NVIDIA's DLSS 5. Alongside a Vulkan version that runs on Windows with a GeForce RTX 4070 SUPER, the project also includes a version that runs in a browser using WebGPU. The processing time the author reported at 1080p was 7.8 milliseconds. However, this is not the frame time for an entire game—it's the fastest network-only processing time out of 40 measured frames.
The significance of this release is not that "official DLSS 5 can now be used on unsupported GPUs." Rather than modifying code to call NVIDIA's runtime, the project reconstructs the internal computations of the network—right down to how numbers are rounded—in a form whose intermediate outputs can be checked against recorded reference data. At the same time, the fast Vulkan version depends on NVIDIA-specific extensions and PTX, and the model weights are not distributed with it. Overlooking these two points makes it easy to misread what this implementation actually means.
Reimplementing a 71-block neural rendering network
NVIDIA describes DLSS 5 as a technology that, unlike traditional super resolution or image reconstruction, generates the final on-screen appearance based on images rendered by the game. It takes as input the current frame, motion information, state carried over from the previous frame, and adjustment values specified by developers. In its official form, the feature is used together with data and mask control provided by the game.
What OpenDLSS-NR targets is the 71-block inference network included in DLSS-NR build 310.8.0. According to the author's README, it combines a Transformer that processes images in shifting, configurable windows with a Vision Transformer that handles the entire image, arranged in a U-shaped structure. The model weights total 141MiB.
The inputs include a display-ready image derived from the rendered result, noise, an image of the previous frame's content warped to align with the current frame's positions, and various adjustment values. The outputs are RGB correction values to be added to the original image, and a value that determines how much of the previous frame's information to blend in. The input and output resolutions are the same; this is not a replacement for DLSS Super Resolution.
This distinction also matters when comparing OpenDLSS-NR to existing unofficial methods of enabling DLSS. Techniques that get a game to call NVIDIA's DLL work by rerouting access to the official runtime. OpenDLSS-NR, by contrast, implements the network's computation itself separately.
However, as discussed below, users must still supply the model weights needed for computation themselves. The fact that the source code is public and the fact that the full model set is freely obtainable and distributable are not the same thing.
What does "bit-for-bit match" actually compare?
The author didn't just visually compare final images for similarity—output values were recorded at multiple points during inference and checked against verification data.
Across blocks 0 through 69 plus five intermediate transformation points—75 points in total—the author reports that FP8-format values matched byte-for-byte. For a 512×512 verification dataset, all 57,704,448 bytes reportedly matched.
Meanwhile, for the final 8-bit output image, since it was compared against older recorded data whose rounding method is unknown, the author treats this as a separate check allowing a tolerance of up to one level of difference.
This level of scrutiny is necessary because, even with identical weights, a neural network's final output can change depending on the order of operations and when decimal values are rounded. The technical documentation describes procedures such as rounding to FP16 before converting to FP8, the order in which values are summed in matrix multiplication, and how the attention mechanism is computed.
The author reports confirming that both the GLSL reference implementation and the fast PTX-based implementation produce identical output. In the WebGPU version, since WGSL lacks FP8 types and Tensor Cores, the same rounding behavior is reproduced using integer arithmetic and similar techniques.
However, the recorded NVIDIA reference data used for comparison is not included in the repository. Third parties can examine the published code and verification methodology, but they cannot reproduce every comparison the author performed using only what has been made public.
Additionally, the CPU-based reference implementation does not cover the entire network's processing; for some portions, verification instead relies on cross-checking the two GPU implementations against the recorded data. As such, the phrase "bit-for-bit match" should be understood as a result specific to the particular inputs and recorded data the author prepared.
The Vulkan and WebGPU versions differ in what "working" means
OpenDLSS-NR has three execution paths, all computing the same network. However, the fast Vulkan version depends on NVIDIA-specific PTX and extensions, while the WebGPU version, measured on the same RTX 4070 SUPER at 512×512, takes roughly 27 times longer to process.
| Path | Requirements/method per published materials | Author's measurement on RTX 4070 SUPER |
|---|---|---|
| Vulkan GLSL reference path | Uses FP8 cooperative matrix operations, etc.; serves as a baseline implementation for correctness verification | Speed under the same conditions not disclosed |
| Vulkan PTX fast path | Launches NVIDIA-targeted PTX via VK_NV_cuda_kernel_launch, fusing operations and reducing synchronization overhead |
About 2.7 ms at 512×512 |
| Browser WebGPU path | Reproduces the computation and rounding behavior in WGSL; does not use Tensor Cores, FP8 types, or PTX | 73 ms for one frame after initialization at 512×512, with 451 dispatch calls |
73 divided by 2.7 comes out to roughly 27. Both figures are network-only measurements the author took on the same RTX 4070 SUPER, but they're approximate numbers drawn from different pieces of documentation, and the measurement methods and statistical treatment aren't fully aligned. There has also been no independent third-party verification.
Therefore, these numbers cannot be used to calculate a speed difference from official DLSS 5, nor to estimate the frame rate one would actually get in a real game.
The Vulkan version's README lists requirements including Windows, an Ada-generation or later GPU, and extensions such as VK_KHR_cooperative_matrix, VK_NV_cooperative_matrix2, VK_EXT_shader_float8, and VK_NV_cuda_kernel_launch.
In other words, while it uses the cross-vendor Vulkan API, it relies on NVIDIA-specific features on top of it. Vulkan compatibility alone does not mean this fast version will run on GPUs from AMD, Intel, or other vendors.
The WebGPU version, by contrast, is an attempt to compute the same network by a different method, without relying on NVIDIA-specific matrix operation features. In the author's measurement at 512×512, of the 73 milliseconds total, 44.5 ms went to FP8 matrix multiplication and 16.8 ms to the windowed attention mechanism.
In the browser demo, additional overhead comes from things like data transfer, since the scene is first rendered with WebGL and that data then needs to be handed off to WebGPU. In an approximately 1904×929 example, reading the image back alone reportedly took about 15 ms, and network processing took about 465 ms.
However, since this figure differs in both resolution and scope from the 512×512 network-only measurement, the two cannot be directly compared.
What can be tested with the published code, and what remains to be verified
The repository's code is released under the MIT license. However, it does not include NVIDIA's software, the model weights, headers, or instructions for obtaining the weights, and verification data must be prepared separately.
The README explicitly states that users must confirm for themselves whether they hold the necessary rights to any model data they use. In other words, simply obtaining the code does not put everyone in a position to generate the same images right away.
Official DLSS 5 also comes with its own constraints on scope of use, albeit of a different kind. The support scope NVIDIA announced on September 22 covers desktop and laptop PCs with GeForce RTX 50-series GPUs running NBA 2K27, as well as GeForce NOW Ultimate. Developers can select among models and adjust factors such as the strength of effects on shape and color, plus per-object masks.
Even if OpenDLSS-NR has reproduced the network itself, it has not reproduced this kind of integration with individual games, nor the product-level support that comes with it.
Two things matter for future evaluation.
One is whether third parties other than the author can legitimately obtain the same weights and recorded data and independently re-verify the matching of intermediate outputs and processing speed across multiple resolutions.
The other is how image quality and latency turn out when the system runs continuously, including a game's rendering pipeline, handling of the previous frame, and, for the browser version, data transfer as well.
This release provides a foundation for examining the internal computations performed by DLSS 5's neural rendering. At the same time, successfully reproducing the network is a different matter from actually reproducing the same experience as official DLSS 5 within a real game. Demonstrating the latter would require further data verifying image quality, performance, and stability once integrated into an actual game.