Open source expert fully replicates DLSS 5
An open-source expert has completely recreated DLSS 5, and it can even run in a browser, and it also works on the 40 series. When NVIDIA officially announced DLSS 5 in March this year, the official line was that it only supported the RTX 50 series. Now the situation has changed: developer MAAN has open-sourced the OpenDLSS-NR project on GitHub, rewriting the entire neural rendering network of DLSS 5 using Vulkan.
💡 What You Will Learn
An open-source expert has completely recreated DLSS 5, and it can even run in a browser, and it also works on the 40 series. When NVIDIA officially announced DLSS 5 in March this year, the official li
📜 Table of Contents
Open Source Developer Replicated DLSS 5 Entirely, Even Runs in the Browser, Works on 40-Series Too
When NVIDIA officially announced DLSS 5 in March this year, the official line was RTX 50 series only. Now things have changed: developer MAAN has open-sourced the OpenDLSS-NR project on GitHub, rewriting the entire DLSS 5 neural rendering network using Vulkan. According to the repository README, the model corresponds to the 71-layer network in DLSS-NR version 310.8.0, under MIT license, with all code and documentation released.
What Does Byte-for-Byte Identical Mean
First, let's talk about how far this replication goes. DLSS 5's neural rendering network is a 71-block Swin Transformer plus a global ViT structure, with FP8 activation precision, FP16 accumulation, and 141MiB of weights. What MAAN did was align everything from architecture to rounding errors: feed in the same input, get the same final image, and the intermediate outputs at all 75 block boundaries are also byte-for-byte identical.
Matching the final image isn't hard. Matching all intermediate results is. This means everything from network structure, numerical precision, to the rounding behavior of every kernel has been fully reproduced—close to a complete public dissection of NVIDIA's closed-source implementation. Of course, this "consistency" is currently self-verified by the developer; no third party has reproduced it yet.
7.8 Milliseconds on RTX 4070 SUPER
For performance data, let's look at the table directly. All data comes from an RTX 4070 SUPER, running the full network for one frame, taking the minimum of 40 frames:
| Resolution | Time |
|---|---|
| 768×768 | 2.8ms |
| 1920×1080 | 7.8ms |
| 2560×1440 | 12.6ms |
| 3840×2160 | 29.3ms |
1080p only takes 7.8 milliseconds, equivalent to a 128-frame budget, with plenty of headroom. 4K at 29.3 milliseconds is a bit tight, but for a 71-layer neural network it's already quite usable.
Browser Version: Cross-Platform but 27x Slower
More interesting is the WebGPU version in the project: the same network running in a browser, without Tensor Cores or FP8. The cost is speed—512×512 resolution takes 72 milliseconds, while the native implementation only needs 2.7 milliseconds, a 27x difference. The value of the browser version lies in cross-platform support; theoretically, AMD and Intel GPUs can also run this network, which is something NVIDIA's closed-source runtime can't offer.
How to Install: Three Scripts Plus One Weight File
The project is designed for Windows, with the entire build process turned into PowerShell scripts—just follow the README's three steps. First, scripts\fetch_tools.ps1 downloads the entire build toolchain at once, including glslang, Vulkan headers, CMake, and Ninja; second, scripts\build.ps1 compiles shaders, generates PTX kernels, and produces the main program dlss5vk.exe, which comes with subcommands for benchmarking, per-kernel timing analysis, and bit-consistency verification; if you want to see the visual results, run three more Filament-related scripts to build dlss5-demo.exe, a demo renderer you can double-click to open, with a dropdown to select scenes and compare neural rendering on vs. off.
The hardware requirements are strict: the GPU must support Vulkan extensions like VK_KHR_cooperative_matrix and VK_EXT_shader_float8. Currently only newer NVIDIA cards meet these requirements; AMD cards can't run the native version.
After building, one final piece is still missing: the model weights. The program looks for weights in three priority levels: the --model command-line argument, the DLSS5VK_MODEL environment variable, and the models\nr directory next to the README. But the repository itself doesn't include weights—these 141MiB of FP8 parameters must be extracted from NVIDIA's closed-source runtime yourself, which is currently the highest barrier to entry.
Two More Hurdles Before Real Usage
Weights are the first hurdle. As mentioned, you have to extract them from the closed-source runtime yourself, and the repository completely avoids this step for legal safety.
The second hurdle is game integration. It's currently a standalone implementation that can't be installed into games: the demo renderer lets you see the effects, and the DLSS super-resolution part isn't done either. NVIDIA officially planned to bring DLSS 5 to RTX 40 series anyway, and the open-source version is a way to get an early taste. To actually use it in your own games, you'll have to wait for the community to turn it into a mod.
A few days ago I wrote about AMD's paper on using diffusion models to rival DLSS 5, and now it's the open-source community's turn to take on DLSS 5 itself. A closed-source network being reproduced byte-for-byte is good news for researchers and the modding community, but there's still a long way from players actually installing it in games—two major steps remain: weight sourcing and game integration. If you have an RTX 40 series card, will you wait for official support or keep an eye on community mods?
Written by our editorial team; tools listed here are tested or verified against public sources. Links point to official sites or GitHub repos for reference only — no paid placements.