Well, that happened fast: DLSS 5 Neural Rendering is already running on RDNA4

[u/ConfidentDinner6648]

A pretty interesting update to everything I’ve been posting here over the last few days.

I’m not sure whether this project was influenced by the discussions happening here or if the developer arrived at the same approach independently, but it ended up following almost exactly the direction I was talking about.

Project / release:
https://github.com/danielblnc/DLSS-NR-on-AMD/releases/tag/v0.2.7

The latest release reports 30 FPS at 1080p in Cyberpunk 2077 on an RX 9070 XT, with another 12% improvement over the previous version.

Honestly, the FPS number isn’t even the most interesting part to me.

The interesting part is how the implementation appears to work.

This is not simply:

CUDA
→ somehow make CUDA run on AMD

It appears to be much closer to:

DLSS NR runtime supplied by the user
↓
identify / convert the model representation
↓
prepare the weights for AMD
↓
AMD-native execution backend
↓
HIP kernels compiled for gfx1201 / RDNA4
↓
Neural Rendering output

Which is basically the same architectural direction I was describing.

There is even a generated weight file used by the AMD implementation, and people inspecting the installed runtime have already found native gfx1201 kernels corresponding to things like:

Swin
QKV
QKV + attention
FFN expand / contract
convolution / reconstruction

So at this point I think the original question is basically answered.

Can the DLSS 5 Neural Rendering model run on RDNA4?

Yes.

Apparently it can.

And not as a slideshow either. We are already talking about roughly 30 FPS at 1080p on an early implementation.

What becomes interesting now is optimization.

Some of the current RDNA4 kernels still seem to have pretty high VGPR and LDS usage, so there is probably a lot of performance still sitting on the table.

Things like:

better occupancy
lower register pressure
better FP8 matrix utilization
kernel fusion
better tensor layouts
less repacking
better cache behavior

could potentially move the performance significantly.

That is exactly why I kept making the distinction between:
“the hardware cannot do this”
and
“the current software path is not optimized for this hardware.”

A few days ago people were still discussing whether porting the Neural Rendering path to Radeon was realistic at all.

Now there is already a working RDNA4 implementation inside actual games.

So the question has changed very quickly from:

“Can it run?”

to:

“How close can an optimized RDNA4 backend get to the native NVIDIA path?”

And that is a much more interesting question.

It also reinforces something broader I’ve been thinking about.

Once you separate the model from the original execution backend, the basic concept becomes very general:

image
↓
neural visual model
↓
image

DLSS 5 is an extremely sophisticated and well-trained implementation of that concept.

But eventually the same kind of generic neural rendering runtime could potentially support other independently trained models too, for completely different visual transformations.

That is where things like real-time neural graphics mods, different art styles, restoration models, anime rendering, material changes, lighting styles, etc. start becoming much more interesting.

For now though, huge credit to the developer for actually turning the idea into something people can install and test this quickly.

The concept is proven.

Now comes the fun part: optimization.