I’ve spent enough time testing DLSS 5 to know that it can be both incredibly impressive and incredibly frustrating. The tech has genuinely felt transformative in a lot of games, especially when I used to create free remasters of classic games. However, DLSS 5’s Neural Rendering tech has also brought up some fairly obvious questions about what’s actually going on with the final image. Some of these complaints have really hit home, too, and have been difficult to dismiss.
This time, though, I didn’t fire up another game and throw DLSS 5’s Neural Rendering at it through ReShade or OptiScaler. Instead, I went digging through OpenDLSS-NR, an open-source project that recreates the DLSS 5 Neural Rendering pipeline. Full disclosure — I’m certainly not qualified to explain every line of its implementation, but reading through what the developers have uncovered gave me a rather fascinating perspective on why DLSS 5 behaves the way it does.
Related
DLSS 5 is further proof that rasterization’s days are numbered
For better or worse, rasterization continues to be buried, and it won’t be long until games are unrecognizable
DLSS 5 indeed has a serious performance problem
The numbers make the complaints much easier to understand
Credit: Digital Foundry.
OpenDLSS-NR is an open-source reimplementation of Nvidia’s DLSS 5 Neural Rendering network. It’s been built from reverse-engineered research and designed to reproduce the neural rendering behavior outside of Nvidia’s software stack, which, of course, is closed otherwise. Now, using it does require an Ada Lovelace card or above, but even so, I can’t use it on my own RTX 4070 Ti-powered PC since OpenDLSS doesn’t come with the weights, which users are expected to supply themselves.
However, reading through the entirety of this open-source clone did open my eyes to plenty of “issues” that are part of the DLSS 5 conversation. For starters, there’s a reason the DLSS 5 performance complaints never went away: neural rendering simply isn’t free. The project’s benchmark table makes the problem very easy to see. On an RTX 4070 SUPER, the complete Neural Rendering network takes 29.3 ms at 2160p, across 241 GPU dispatches. That works out to roughly 34 frames per second of neural-rendering work before you account for the game itself. At 1440p, it still needed 12.6 ms.
Related
I put DLSS 5 on my entire desktop, and it showed me neural rendering’s real limits
DLSS 5 Live Flow promised to transform my desktop — here’s what actually happened
The authors measured the network over 40 frames and reported the minimum time, with the 4K workload becoming compute-limited at roughly 133 TFLOPS on the RTX 4070 SUPER. The implementation is actually exercising the hardware rather than describing an abstract cost.
Looking at these numbers really puts into perspective why Nvidia needed an entirely separate RTX 5090 dedicated just to showcase DLSS 5. The timing table showed, clear as day, that the neural pass consumes a meaningful chunk of an entire frame. I may not be able to use OpenDLSS-NR, but using the official DLSS 5 DLL files with The Blood of Dawnwalker halved my frame rate immediately. It wasn’t until I switched the neural rendering layer’s place in the pipeline that I gained performance back.
DLSS 5 really does behave like an “AI filter”
The source code makes the comparison impossible to dismiss
One of the easiest ways to dismiss criticism of DLSS 5 is to call the “AI filter” comparison reductive. Then you read OpenDLSS-NR’s output specification and realize there is a little more substance to it. The network doesn’t simply replace the rendered frame; it produces an RGB residual that gets applied to it.
That residual is essentially a per-pixel instruction for how the existing image should change. The network can leave parts of the original render relatively untouched while altering others, which makes the result fundamentally different from traditional sharpening or reconstruction. The game has already done the rendering, while NR decides what the finished image should become.
The clone also has style controls, and it was particularly interesting to go through them. OpenDLSS-NR comes with a style parameter that influences characteristics like tone, structure, and skin. It’s a direct admission that the network isn’t just concerned with recovering information that the renderer lost. It has learned preferences about how the final picture should look.
So, yes, calling DLSS 5 an Instagram “yassification filter” is technically lazy. But after reading the implementation, I can understand where it came from. There’s a completed image, a neural network that modifies it, and a controllable parameter that determines the character of those modifications. The AI filter criticisms become harder to dismiss, even if I won’t say it makes DLSS 5 outright bad.
Related
Emulation already solved the problem DLSS 5 is selling, and it did it for free years ago
Emulators have been giving out free remasters without halving your FPS
Users have criticized DLSS 5 for hallucinating details
The noise input makes this criticism interesting, though
OpenDLSS-NR feeds the network three lanes of “Gaussian noise” alongside the rendered image and temporal information. Nvidia describes DLSS 5 as a one-step, pixel-space diffusion model, meaning controlled noise is part of how the network generates its final output.
That makes the fear of hallucinated detail considerably easier to understand. A conventional reconstruction algorithm is trying to recover information from evidence already present in the render. A diffusion model has learned what things tend to look like and can synthesize plausible structure from that knowledge. DLSS 5 isn’t randomly inventing pixels, but generation is quite literally part of its job. Calling that hallucination may be imprecise, but pretending the model cannot invent visual information would be even less accurate.
Now, in all fairness, Nvidia does have an answer to this concern. DLSS 5 is conditioned on renderer information, motion vectors and temporal state, while training uses renderer-derived scene attributes to keep the generated result faithful to the developer’s scene. It’s reassuring, yes, but it also does leave one wondering about what happens when the original renderer disagrees with the learned visual knowledge. Who gets the final say in that situation?
Related
I tried out DLSS 5 on my old Wii game collection, and it looks just as weird as you’d imagine
How much neural rendering is too much neural rendering?
The open-source clone has a pretty big blind spot
The part that matters most isn’t actually in the repository
There is one DLSS 5 criticism that OpenDLSS-NR couldn’t quite settle for me — what the model has actually learned. The project provides the architecture and implementation, yes, but not Nvidia’s training corpus or the process used to produce the network’s weights. You can inspect how the machine thinks, but not everything it was taught.
If someone worries that DLSS 5 carries assumptions from its training material into the images it generates, this repository can’t really prove them right or wrong. The most interesting evidence is therefore sitting somewhere you just can’t access. When the question becomes “why did it learn to make that particular decision?”, the source code runs out of road. Clearly, that answer still belongs to Nvidia.
Related
I unlocked RTX 50-series features on my RTX 4070 Ti, and Nvidia’s GPU generations don’t make sense anymore
My old card is gaining new features it isn’t supposed to have
Reading the code changed how I see DLSS 5
Going through the entirety of the open-source clone of DLSS did sort of take away the mysticism behind the magic. All I now know are inputs, layers, weights, compromises, and, of course, an enormous amount of compute, all conspiring to produce an image that looks convincing enough.
Over the last month, however, I’ve grown less convinced of every criticism aimed at DLSS 5. If anything, OpenDLSS-NR leaves me more interested in the arguments surrounding it. We’ve reached a point where rendering technology is increasingly deciding what the pixels that GPUs draw should look like. I find that fascinating, slightly unsettling, and considerably more interesting than another argument about whether the image looks sharper.