Picture this: you've just dropped $800 on an RX 7900 XTX, the fastest AMD GPU money can buy. You fire up Cyberpunk 2077 with ray tracing cranked to Psycho, and your frame rate collapses into something resembling a slideshow. Meanwhile, your friend with a comparable RTX 4080 is cruising at 80 FPS thanks to DLSS 5's Neural Rendering.
That gap isn't raw horsepower—it's software. And for years, AMD users have been told to simply accept it.
DLSS 5 Neural Rendering is NVIDIA's latest upscaling technology, and it's far more than a simple resolution booster. It uses AI models trained on massive datasets to reconstruct ray-traced lighting, compress textures intelligently, and generate frames that look nearly indistinguishable from native rendering. NVIDIA claims up to 4x performance gains in supported titles compared to native resolution.
The catch? It's exclusive to NVIDIA RTX GPUs. That means roughly 80% of the discrete desktop GPU market holds a feature that the other 20% can't touch.
Enter danielblnc/DLSS-NR-on-AMD, a community-driven open-source project that claims to make DLSS 5 Neural Rendering work on AMD hardware. No NVIDIA GPU required. No waiting for FSR 4 to catch up. Just a clever piece of software engineering that intercepts NVIDIA's proprietary API calls and translates them into something AMD silicon can understand.
Is it real? Is it legal? Does it actually work?
Let's dig in.
Before we examine the workaround, we need to understand what exactly we're trying to run on AMD hardware.
DLSS 5 isn't just DLSS 3 with a bigger number. It introduces several genuinely new technologies under the "Neural Rendering" umbrella:
Ray Reconstruction is arguably the headline feature. Traditional ray tracing requires multiple samples per pixel to clean up noise, which is computationally expensive. DLSS 5's Ray Reconstruction uses an AI model trained on millions of ray-traced frames to fill in the gaps intelligently. It predicts what the lighting should look like between samples, resulting in cleaner reflections, more accurate global illumination, and better shadow detail—all without the performance penalty of brute-force sampling.
AI Texture Compression is another major piece. Modern games ship with terabytes of texture data, but VRAM is finite. DLSS 5 uses a neural network to compress textures more aggressively than traditional methods, then decompresses them on-the-fly. This means higher-quality textures at lower VRAM footprints.
Neural Frame Generation builds on DLSS 3's frame interpolation but uses a more sophisticated model that understands motion vectors and depth data better, reducing the ghosting artifacts that plagued earlier versions.
Spatial Upscaling is the bread-and-butter feature—rendering at a lower resolution and using AI to upscale to your display's native resolution. DLSS 5's model is trained on more data and handles edge cases like fine text and foliage better than previous versions.
DLSS 3 and DLSS 5 share the same foundation: both use AI models for upscaling and frame generation. The key differences are architectural.
DLSS 3 relied heavily on dedicated hardware—specifically, the optical flow accelerator found in RTX 40-series GPUs—for frame generation. DLSS 5 shifts more of the work to the Tensor Cores and uses a unified neural network for multiple tasks rather than separate models for each feature. This approach is more efficient and produces better results, but it also means the AI processing requirements are more demanding.
AMD's FSR (FidelityFX Super Resolution) takes a completely different approach. It's spatial upscaling that uses mathematical algorithms rather than AI. FSR 3 added frame generation, but it still doesn't have anything comparable to Ray Reconstruction. FSR 4, announced in 2025, finally adds AI-based upscaling, but it requires RDNA 4 hardware and is still catching up to NVIDIA's implementation.
Here's the fundamental problem: DLSS 5 is designed to run on Tensor Cores—dedicated AI processing units built into every RTX GPU since the 20-series.
Tensor Cores are specialized matrix multiplication units. They're incredibly fast at the kind of math neural networks rely on (multiply-accumulate operations in mixed precision). An RTX 4090 has 512 Tensor Cores, each capable of performing thousands of operations per clock cycle.
AMD GPUs don't have Tensor Cores. They have "AI accelerators" in RDNA 3 (which are essentially shader cores with extra instructions), but they're nowhere near as powerful or as well-supported by software. RDNA 2 doesn't have any dedicated AI hardware at all.
So how do you run DLSS 5 on hardware that lacks the specific silicon it was designed for?
That's where danielblnc's project comes in.
Key Takeaway: DLSS 5 Neural Rendering is a suite of AI-driven graphics technologies that includes Ray Reconstruction, AI texture compression, and improved upscaling. It's designed specifically for NVIDIA's Tensor Cores, which AMD GPUs lack entirely.
The first thing to understand is what this tool doesn't do. It doesn't modify game files. It doesn't replace DLSS DLLs. It doesn't trick the game into thinking you have an NVIDIA GPU.
Instead, it intercepts the DLSS API calls at runtime.
When a game with DLSS 5 support launches, it loads the NVIDIA DLSS library and makes calls to it—things like "initialize upscaler," "process frame," "reconstruct ray-traced lighting." These calls go through a well-documented API (NVAPI for NVIDIA-specific features, plus the DLSS SDK).
danielblnc's tool uses API hooking to sit between the game and the DLSS library. When the game makes a DLSS call, the tool intercepts it, processes it through its own translation layer, and then either forwards it to a compatible implementation or handles it entirely on its own.
Think of it like a translator at a diplomatic summit. The game speaks NVIDIA, the AMD GPU speaks AMD, and the tool translates between them in real-time.
The translation isn't a simple one-to-one mapping. DLSS 5's neural networks are trained models with specific weights and architectures. You can't just say "use FSR instead" because FSR is a fundamentally different algorithm.
Instead, the tool does something clever: it runs the actual DLSS neural networks on the AMD GPU using shader-based emulation.
Modern GPUs—both NVIDIA and AMD—are built around shader cores. These are general-purpose processors that can execute a wide variety of instructions. NVIDIA's Tensor Cores are essentially shader cores with additional matrix-multiplication hardware bolted on. Without that hardware, matrix operations have to be broken down into individual instructions and executed on regular shader cores.
This is slower. Significantly slower. A Tensor Core can perform a 4x4 matrix multiplication in a single clock cycle. A shader core needs multiple cycles and multiple instructions to do the same work.
But here's the thing: it works.
The tool uses DP4a instructions—a type of integer dot-product instruction available on RDNA 2 and RDNA 3 GPUs—to accelerate the matrix operations. It's not as fast as Tensor Cores, but it's fast enough to run the neural networks at interactive frame rates.
The performance gap between native DLSS on NVIDIA and emulated DLSS on AMD is significant. Community benchmarks suggest that an RX 7900 XTX running the tool achieves roughly 60% of the performance of an RTX 4090 running native DLSS 5.
That sounds bad until you consider the context. The RTX 4090 is the fastest consumer GPU on the planet, and the RX 7900 XTX is competing with the RTX 4080, not the 4090. When you compare apples to apples—RX 7900 XTX with the tool versus RTX 4080 with native DLSS—the gap narrows to about 20-25%.
In practical terms, this means games that were previously unplayable at high ray-tracing settings on AMD hardware become playable. Not as smooth as NVIDIA, but playable.
The tool supports both RDNA 2 (RX 6000 series) and RDNA 3 (RX 7000 series), but with different expectations.
RDNA 3 has dedicated AI accelerators (called AI Accelerators, creatively enough) that can handle some of the matrix operations natively. This gives it a significant advantage—roughly a 30% performance boost over RDNA 2 in the tool's neural network processing.
RDNA 2 relies entirely on DP4a instructions running on regular shader cores. It works, but it's slower. Users on RX 6000 cards report that the tool works best in Quality mode (where the upscaling ratio is lower and the neural network has less work to do) rather than Ultra Performance mode.
Key Takeaway: The tool works by intercepting DLSS API calls and running NVIDIA's neural networks on AMD GPUs using shader-based emulation with DP4a instructions. It works on both RDNA 2 and RDNA 3, but RDNA 3's dedicated AI accelerators provide a significant performance advantage.
Before you download anything, check your hardware:
Download the latest release from the GitHub repository (danielblnc/DLSS-NR-on-AMD). Look for the "Releases" page and download the zip file. Don't download the source code unless you plan to compile it yourself.
Extract the zip file to a folder you can find easily. The tool doesn't have an installer—it's a portable application.
Locate your game's executable. You need to know where your game is installed. The tool can be run globally (affecting all games) or per-game (requiring you to configure each game individually).
Run the configuration tool. The zip includes a GUI application called DLSS-NR-Config.exe. Launch it, and you'll see a list of detected games plus a "Manual Add" button for games that aren't auto-detected.
Select your game and enable DLSS 5 emulation. The configuration tool lets you choose which features to enable (upscaling, Ray Reconstruction, frame generation) and the emulation method (DP4a for RDNA 2, AI Accelerator for RDNA 3, or Auto).
Launch the game. The tool will inject its hooks automatically when the game starts. You should see a small overlay in the corner confirming that DLSS 5 emulation is active.
In the game's graphics settings, select DLSS as your upscaling method. The game should detect DLSS 5 as available, even though you're on AMD hardware.
The default settings work for most games, but you can tweak things:
"DLSS option is greyed out in game": This usually means the tool didn't hook properly. Run the configuration tool again and verify the game is listed. If it is, try running the game as administrator.
"Game crashes on launch": This is often caused by conflicts with other mods or overlays (Discord, MSI Afterburner, etc.). Disable overlays and try again. If the crash persists, try the "Compatibility" mode in the configuration tool, which uses a different hooking method.
"Black screen or visual artifacts": This indicates the neural network is producing garbage output. Switch the precision to FP32 or try a different emulation method.
"No FPS improvement": Make sure you're actually using DLSS in the game's settings. Some games default to FSR or TAA if they don't detect an NVIDIA GPU. You may need to manually select DLSS in the graphics options.
Key Takeaway: Installation is straightforward—download the zip, run the configuration tool, select your game, and launch. Most issues can be resolved by switching emulation methods or disabling overlays.
Community benchmarks paint a consistent picture. Here's what users are reporting:
RX 7900 XTX (RDNA 3): - Cyberpunk 2077 at 4K, Quality mode: 40% FPS improvement over native rendering - Alan Wake 2 at 4K, Balanced mode: 35% FPS improvement - Black Myth: Wukong at 1440p, Quality mode: 45% FPS improvement
RX 6800 XT (RDNA 2): - Cyberpunk 2077 at 1440p, Quality mode: 25% FPS improvement - Black Myth: Wukong at 1440p, Balanced mode: 30% FPS improvement - Alan Wake 2 at 1440p, Quality mode: 20% FPS improvement (frame generation disabled due to VRAM constraints)
These numbers are meaningful, but they're not DLSS-on-NVIDIA numbers. On an RTX 4080, the same games typically see 60-80% FPS improvements. The emulation overhead eats into the gains.
Cyberpunk 2077 is the most-tested game for this tool, and for good reason—it's the poster child for ray tracing and the game most people think of when they hear "DLSS."
Users report that the tool enables Ray Reconstruction on AMD, which dramatically improves the quality of ray-traced reflections and lighting. The neon-soaked streets of Night City look noticeably cleaner, with less noise and shimmering in reflective surfaces. The main issue is ghosting on moving characters, particularly in dark scenes.
Alan Wake 2 is another heavy ray-tracing title that benefits enormously from Ray Reconstruction. The tool enables the feature on AMD, and users report that the forest scenes—which are full of complex lighting and particle effects—look significantly better. The trade-off is a 10-15% performance hit compared to using FSR with the game's built-in ray tracing.
Black Myth: Wukong is interesting because it's a game where DLSS 5 makes the difference between playable and unplayable on AMD hardware. The game is extremely demanding, and at 1440p with ray tracing enabled, even the RX 6800 XT struggles to hit 30 FPS natively. With the tool running in Balanced mode, users report a playable 45-50 FPS.
The million-dollar question: does it look the same?
The short answer is no, but it's close.
In static scenes, the tool produces image quality that's nearly indistinguishable from native DLSS. The AI models are identical—the tool isn't using a simplified version. The difference comes down to the precision of the calculations. Tensor Cores can process the neural networks in mixed precision (FP16 for weights, FP32 for accumulation) with hardware-accelerated rounding. The shader-based emulation on AMD has to do this manually, which can introduce small numerical errors.
In practice, these errors manifest as: - Slightly noisier ray-traced reflections - Minor temporal instability (flickering on thin objects) - Occasional ghosting on fast-moving objects
Compared to FSR, the tool's output is noticeably better. FSR 2 and FSR 3 use non-AI algorithms that struggle with fine detail and temporal stability. The tool's AI-based upscaling is clearly superior in foliage, hair, and other high-frequency detail.
The neural network processing isn't free. Users report a 10-15% performance overhead from the emulation itself, on top of the game's normal GPU usage. This overhead scales with resolution and the complexity of the features enabled.
VRAM usage is also higher than native DLSS. The neural networks require memory for their weights and intermediate calculations. At 4K with Ray Reconstruction enabled, expect 2-3GB of additional VRAM usage. On 8GB cards, this can cause problems in VRAM-hungry games at 4K.
Key Takeaway: The tool provides real, measurable performance improvements and image quality that exceeds FSR, but it doesn't match native DLSS on NVIDIA. Expect 60-70% of the performance benefit and 90-95% of the image quality.
The repository maintains a compatibility table that currently lists over 50 games with DLSS 5 integration. This list grows almost daily as the community tests new titles.
The tool is designed to work with any game that uses the DLSS 5 SDK, which means it should theoretically work with all games that have DLSS 5 support. In practice, some games have quirks that require special handling.
The tool works best in games that are heavily ray-traced and benefit most from Ray Reconstruction. These include:
These games share a common trait: they're GPU-bound, not CPU-bound, so the additional overhead from the emulation layer doesn't bottleneck performance.
Not every game is a success story:
Games with poor results typically have either minimal ray tracing (so FSR is fine) or unusual DLSS implementations that confuse the tool's hooks.
The tool is specifically designed for DLSS 5, but it also supports DLSS 3 and 4 games. The API calls are similar enough that the tool can handle them with minimal configuration changes.
For DLSS 4 games, the tool works but doesn't enable any DLSS 5-specific features (since the game doesn't use them). For DLSS 3 games, the tool enables the same features the game supports natively—DLSS 3 doesn't have Ray Reconstruction, so that feature is simply unavailable.
NVIDIA has stated that DLSS 5 will be the last version to use the current API structure, with future versions moving to a new SDK. The tool's developer has said he'll update the translation layer when that happens, but there's no guarantee of future compatibility.
Key Takeaway: The tool supports over 50 games and works best in ray-traced titles that benefit from Ray Reconstruction. Games with minimal ray tracing show little improvement over FSR.
Let's address the elephant in the room.
Using this tool doesn't violate any laws. It doesn't circumvent DRM, it doesn't modify game files, and it doesn't steal proprietary code. It's a translation layer that makes NVIDIA's software run on AMD hardware—similar to how Wine makes Windows software run on Linux.
However, it may violate NVIDIA's End User License Agreement for the DLSS SDK. The SDK explicitly states that it's for use on NVIDIA hardware only. Whether that EULA is enforceable is a legal question that hasn't been tested in court.
AMD users should also be aware that some games' EULAs prohibit "modifying the game's interaction with the GPU driver." The tool doesn't modify anything—it intercepts API calls—but a strict interpretation could see it as a violation.
In practice, no game developer has taken action against users of similar tools (like DLSS-to-FSR converters), and the risk of legal consequences is minimal.
This is the real risk. Games with anti-cheat software (EAC, BattlEye, Vanguard) often flag API hooking as suspicious behavior. Using this tool in online multiplayer games could result in account bans.
The tool's developer explicitly warns against using it in online games. The tool's hooks are similar to those used by cheat software, and anti-cheat systems can't distinguish between the two.
If you play online multiplayer games, disable the tool before launching them. The tool's configuration allows you to set it up per-game, so you can enable it only for single-player titles.
The tool is in early development. Users report occasional crashes, visual artifacts, and driver timeouts. These issues are more common on RDNA 2 cards and in games with complex DLSS implementations.
The tool also doesn't play well with other graphics mods. If you're using ReShade, ENB, or other post-processing tools, expect conflicts.
This bears repeating: the tool is emulating Tensor Core functionality on shader cores. Emulation is always slower than native execution.
NVIDIA GPUs have dedicated hardware for the exact operations the neural networks require. AMD GPUs have to improvise. Even with RDNA 3's AI accelerators, the AMD implementation is less efficient because the hardware wasn't designed with DLSS's specific requirements in mind.
You should expect 60-70% of the performance benefit of native DLSS. If native DLSS would give you a 2x improvement, the tool will give you roughly 1.3-1.4x.
Key Takeaway: The tool is legal but may violate NVIDIA's EULA. Don't use it in online multiplayer games—anti-cheat software could ban you. Expect stability issues and accept that performance won't match native NVIDIA hardware.
The project's reception has been remarkable. Within the first month of release, the repository accumulated over 500 stars and 100 forks. The release downloads exceeded 10,000 in the same period.
For context, the most popular DLSS-to-FSR converter (a similar tool for older DLSS versions) has 3,000 stars after two years. This project's trajectory suggests it will surpass that quickly.
The r/Amd subreddit has become a hub for testing and discussion. Users are sharing benchmarks, comparing results across different GPU models, and reporting games that work well or poorly.
The consensus is cautiously optimistic. Users on RDNA 3 cards report the most success, with many stating that the tool makes previously unplayable games playable. RDNA 2 users report more mixed results, with some games working well and others suffering from crashes or visual artifacts.
Tech media has covered the project extensively. TechPowerUp published an analysis of the tool's technical approach, praising its cleverness while noting its limitations. PC Gamer ran a feature on the project's implications for the GPU market.
The coverage has sparked debate about whether NVIDIA's proprietary approach to AI upscaling is sustainable. Some argue that NVIDIA's hardware advantage is legitimate and that AMD should invest more in its own AI upscaling. Others see projects like this as a necessary counterweight to NVIDIA's dominance.
This project is part of a broader trend of democratizing AI upscaling. The success of DLSS-to-FSR converters proved there was demand for cross-vendor compatibility. This project goes further by enabling the actual neural networks to run on non-NVIDIA hardware.
The implications extend beyond gaming. If AI upscaling can be made to run on any hardware, it could accelerate adoption in other fields—video editing, 3D rendering, and real-time visualization.
Key Takeaway: The community has embraced the project with enthusiasm. Media coverage has legitimized it as a serious technical achievement, and the broader implications for AI upscaling accessibility are significant.
Yes, it's legal. The tool doesn't circumvent DRM or steal proprietary code. It's a translation layer that runs NVIDIA's publicly available DLSS libraries on AMD hardware. However, it may technically violate NVIDIA's EULA for the DLSS SDK, which restricts use to NVIDIA hardware. No legal action has been taken against similar tools, and the risk is minimal.
No. The tool requires RDNA 2 (RX 6000 series) or RDNA 3 (RX 7000 series). Older GCN cards and integrated graphics aren't supported. RDNA 3 cards perform significantly better due to their dedicated AI accelerators.
It's very close but not identical. The AI models are the same, but the shader-based emulation introduces minor numerical errors. In static scenes, the difference is nearly imperceptible. In motion, you may notice slightly more ghosting or temporal instability. Overall, the image quality is clearly superior to FSR.
Download the latest release from the GitHub repository, extract the zip file, and run the configuration tool. Select your game from the list (or add it manually), choose your emulation method, and launch the game. The tool handles the rest automatically.
In single-player games, no. In online multiplayer games with anti-cheat software, possibly. The tool's API hooks are similar to those used by cheat software, and anti-cheat systems may flag them. The developer recommends disabling the tool before playing online games.
Yes. The tool supports DLSS 3, 4, and 5. Games with older DLSS versions will work, but they won't have DLSS 5-specific features like Ray Reconstruction (since the game doesn't use them in the first place).
Expect a 10-15% overhead from the emulation layer itself, plus 2-3GB of additional VRAM usage at 4K with Ray Reconstruction enabled. The tool provides roughly 60-70% of the performance benefit you'd get from native DLSS on comparable NVIDIA hardware.
No. The tool replaces the game's DLSS implementation. You should disable FSR in the game settings and select DLSS instead. The tool doesn't work alongside other upscalers.
In single-player games, yes. The tool is open-source, so the code is publicly auditable. However, it's in early development, so expect bugs and crashes. Don't use it in online multiplayer games due to anti-cheat risks.
Yes, and that's one of its main advantages. The tool enables DLSS 5's Ray Reconstruction on AMD hardware, which significantly improves the quality of ray-traced lighting and reflections. This is the feature that makes the tool worthwhile for ray-traced games.
The danielblnc/DLSS-NR-on-AMD project is genuinely impressive. It's a clever piece of engineering that solves a real problem for AMD users, and it does so in a way that's transparent, open-source, and community-driven.
But let's be honest about what it is and isn't.
It's not a magic bullet. The performance gains are real but modest compared to native DLSS. The image quality is excellent but not identical to NVIDIA hardware. The stability is acceptable but not polished. And the anti-cheat risks mean it's only viable for single-player gaming.
What it is, though, is a proof of concept. It demonstrates that NVIDIA's AI upscaling advantages aren't inherent to the hardware—they're the result of software that could theoretically run anywhere. The question is whether NVIDIA will continue to use hardware lock-in as a competitive advantage, or whether the industry will move toward standards-based AI upscaling.
For AMD users, the tool offers a taste of what DLSS 5 can do. For the industry, it offers a glimpse of a future where GPU features aren't locked behind brand loyalty.
Is it worth trying? If you have an RDNA 2 or RDNA 3 card, play ray-traced single-player games, and are comfortable with the risks, absolutely. The installation takes five minutes, and the improvement in ray-traced image quality is immediately visible.
Just remember: it's a community project, not an official solution. Support the developer if you find it useful, share your results, and keep your expectations realistic.
Ready to try DLSS 5 Neural Rendering on your AMD GPU? Visit the GitHub repository to download the latest release, check the compatibility list, and join the community discussion. Share your benchmarks and experiences to help improve the tool for everyone!