TL;DR
OpenDLSS is a public Vulkan reimplementation of Nvidia’s DLSS 5 Neural Rendering network, with its project describing byte-for-byte matches at all 75 block boundaries against reference captures. It requires users to provide the model weights and, for the Vulkan version, a recent Nvidia GPU with specific driver extensions; the project is not DLSS Super Resolution. The claims and listed performance figures come from the project, and independent verification is not established in the supplied material.
A GitHub project called OpenDLSS has published a Vulkan reimplementation of Nvidia’s DLSS 5 Neural Rendering network, claiming byte-for-byte agreement with reference outputs at all 75 network block boundaries. The project makes the implementation available for users who provide their own model weights, but it does not include those weights in the described setup, and its compatibility is limited to supported Nvidia GPUs and drivers.
Get the latest gadgets delivered free with Prime
- Fast, free delivery on millions of items
- Prime Video, Amazon Music and more included
- Member-only deals all year
The project describes the model as a 71-block shifted-window transformer with a global vision transformer at its deepest level, spread across six pooling levels. It says the network uses E4M3 FP8 activations with FP16 accumulation and has 141 MiB of weights. OpenDLSS characterizes the system as a generative neural rendering network: it takes a rendered frame and additional inputs, then produces an RGB residual and a temporal-blend logit at the same resolution. It is not an upscaler, according to the project.
OpenDLSS says its Vulkan implementation matches all 75 block boundaries against reference captures, not only the final image. The project also includes a separate browser-based WebGPU implementation, which it says matches the same captures without tensor cores or FP8. These are project-reported results; the supplied source does not identify an independent evaluator or provide outside confirmation.
The project lists minimum whole-network timings on an RTX 4070 SUPER of 2.8 milliseconds at 768×768, 7.8 milliseconds at 1920×1080, 12.6 milliseconds at 2560×1440 and 29.3 milliseconds at 3840×2160. Those figures are the minimum across 40 frames, according to the project, which says GPU clock changes can make medians a few percent higher. The source does not give an independently measured comparison or specify a broader range of hardware results.
What the Vulkan Port Makes Possible
If the reported parity holds up under independent testing, OpenDLSS offers developers and researchers a way to inspect and run a reproduction of a proprietary neural-rendering network outside Nvidia’s own implementation. Its reported matching of intermediate block outputs could make it easier to check calculations stage by stage, while the browser port offers a distinct route that does not rely on tensor cores or FP8 hardware.
The practical reach is narrower than the word “Vulkan” might suggest. The project lists Windows and an Nvidia Ada-generation or newer GPU, along with drivers exposing several specified Vulkan and Nvidia extensions. Users must also supply the model directory. The implementation is therefore a technical project for compatible systems, not a drop-in graphics feature for arbitrary PCs or games.
Products Worth Considering
Apple AirPods Pro 3 Wireless Earbuds with Active Noise Cancellation
Jackery Explorer 2000 v2 Portable Power Station with Two 200W Solar Panels
Apple MacBook Air 15-inch Laptop with M5 Chip, 16GB Memory, 512GB SSD, Midnight
As an affiliate, we earn on qualifying purchases.
DLSS 5 Is Not Super Resolution
The project distinguishes this network from DLSS-SR, Nvidia’s separate super-resolution network, and says DLSS-SR is not implemented. OpenDLSS instead re-renders a frame at its existing resolution, using a low-dynamic-range proxy, three lanes of Gaussian noise, a reprojected prior output and five conditioning values, as described in the project material.
OpenDLSS includes a Vulkan command-line tool, a demo built around the Filament renderer and a browser WebGPU port. The command-line tool processes single frames without temporal history; the demo implements a feedback loop using reprojected history and the network’s blend output. The project describes these as separate parts of its implementation, so the single-frame benchmark timings should not be read as a full assessment of every temporal demo scenario.
““A Vulkan reimplementation of NVIDIA’s DLSS 5 Neural Rendering network, bit-exact against the original.””
— OpenDLSS project description on GitHub
Parity and Practical Limits
The supplied material does not establish whether independent testers have reproduced the reported byte-exact results, nor does it detail the provenance or distribution terms for the reference captures. The project says users must supply model weights, but the source does not explain how readers can obtain them or what licensing terms apply.
Performance figures are limited to minimum timings on one listed GPU, with the project itself noting clock variation. It is unclear how results compare across other supported cards, how performance changes in the temporal demo, or how the project behaves in commercial game engines. OpenDLSS also states that DLSS-SR is outside its scope, so its claims should not be taken as a reproduction of Nvidia’s full DLSS feature set.
Testing the Code and Model
The next step for evaluating the project is for developers to inspect its source, build it on compatible Windows and Nvidia hardware, and test parity using the provided fixture-based tools. OpenDLSS lists commands for benchmarking, profiling and checking output against fixtures, as well as a separate verification tool for examining an early network block kernel by kernel.
Broader confidence will depend on independent reports that identify the model weights and reference data used, the hardware and driver versions tested, and whether results reproduce beyond the project’s own setup. Until those details are available, the bit-exactness and performance figures remain claims made by the project.
Key Questions
What is OpenDLSS?
OpenDLSS is a GitHub project that implements Nvidia’s DLSS 5 Neural Rendering network using Vulkan, with a separate browser-based WebGPU version.
Does it include the model weights?
The project says users must supply a model directory containing the weights. The supplied material does not say where those weights can be obtained or specify their licensing terms.
Is OpenDLSS an upscaler or a replacement for all DLSS features?
No. The project says this network renders at the input frame’s resolution and is not an upscaler. It also says DLSS Super Resolution is a different network and is not implemented.
What hardware does the Vulkan version require?
The project lists Windows, an Nvidia Ada-generation or newer GPU, and a driver exposing several specified Vulkan and Nvidia extensions. Its WebGPU port has different hardware requirements, but the supplied source does not give a general compatibility list.
Have the parity and speed claims been independently confirmed?
Not in the supplied material. The project reports byte-for-byte agreement and gives minimum timings for an RTX 4070 SUPER, but independent confirmation is not established.
Source: hn
