Meet the modders porting ringfenced DLSS features to older GPUs

Over recent weeks, we've seen the release of DLSS 5 Neural Rendering in NBA 2K27, followed by its porting to older GPU generations, and the unlocking of DLSS Multi Frame Generation (MFG) for older graphics cards. But how did all of that happen, and who are the people in the modding community unlocking features that Nvidia itself has locked off from users of anything but its latest Blackwell-based GPUs? We sit down with modders Dashdogy and Uncle Burrito to understand how, and why, the modding community has been breaking down Nvidia's software-based locks.

In 2025, during the release of the RTX 5000 series graphics cards, one Australian student was watching a Digital Foundry interview with Nvidia engineers, where the team was showing off Multi Frame Generation (MFG), a feature locked to Blackwell GPUs. During the podcast, the idea of MFG running on older RTX 4000 series hardware was floated, but the feature was never released for Ada Lovelace hardware. “Every few months, I would do a Google search to see if it ever happened or not,” said Dashdogy, a Physics Major studying Mathematics and Space Science.

“A few weeks ago now, the perfect storm arrived. Mid-semester break had just started, and I did the same Google search as I always do. But thought, maybe I’ll look into it. How hard could it be?”

One AWS instance, and a week of late nights later, he unlocked “true” MFG on Ada Lovelace hardware, a feat previously believed to be impossible due to incompatible instructions and a black screen that blocked the progress of modders before them. We’ve tested the mod extensively, and the results stand out. Multi Frame Generation has unofficially arrived for non-Blackwell hardware.

Dashdogy isn’t the only modder that’s been hard at work unlocking features for older-gen GPUs. Several weeks ago, when DLSS5’s Neural Rendering DLL first found its way onto the internet, RTX Remix modder Uncle Burrito set their sights directly on it. “I had no idea of telling [if running DLSS 5 on Ada] was even possible,” they said. Given the previous performance claims of requiring multiple RTX 5090s to run on its initial reveal, Uncle Burrito knew DLSS 5 would be computationally expensive, but that didn’t stop him from trying to get into the DLL itself.

“Once I reverse-engineered it, with the help of Claude, it became obvious that this was possible on Ada. Not only was most of the code compatible, but to me, it looks like Ada support was simply left behind as a work in progress, not as a hard limit.”

And so, less than a day after the DLL had been released in an early access version of NBA 2K27, Uncle Burrito had successfully ported the technology to Ada hardware. In the weeks since the release of Uncle Burrito’s initial unlock for DLSS 5 NR on Ada GPUs, Nvidia has clarified that Neural Rendering would indeed be supported by RTX 4000 series GPUs, lending credence to the idea that implementation on Ada GPUs was merely unfinished in the initial shipping versions of the DLSS 5 DLL.

These two foundational mods by Dashdogy and Uncle Burrito now serve as the baseline for endless numbers of forks and integrations of both Neural Rendering and MFG for older hardware, which have now allowed for ports all the way back to 2018’s Turing architecture, and in DLSS 5 NR’s case, ports to AMD hardware. It’s now as simple as using one of many tools to click-and-install both into hundreds of games.

Unlocking MFG (Dashdogy)

Dashdogy’s experience in modding spans years, having created Stellaris mods while still in High School, making compatibility scripts to patch multiple mods together. But porting DLSS MFG to Ada devices was a different beast entirely. Blackwell and Ada use entirely different ISAs, despite their software similarities. “When this [running Blackwell instructions on Ada] happens, the frames will generate, but the GPU graphs an error and returns a black screen,” he explains.

Underpinning Nvidia’s implementations of DLSS in shipping titles are two pieces of software: a package named Streamline, which usually includes a suite of DLSS software, and is a universal translator that allows games to run various upscaling technologies like DLSS. Used in tandem with Streamline is a Neural Graphics Framework (NGX), Nvidia’s proprietary software that underpins its AI-powered efforts like Super Resolution and Frame Generation. As a game calls for tools, NGX cooks the computation, and Streamline serves them to a given game’s engine.

As Dashdogy explored how to make MFG compatible with Ada, the modder targeted Streamline and NGX directly. “I specifically spoof the Streamline and NGX calls in memory that define how many frames the GPU is allowed to generate.” This approach allowed an Ada-based GPU to think it was allowed to generate more frames than it ordinarily would. “It’s a pretty simple interception, and on 40-series turns 1 into a 5. Now the GPU knows ‘I am a 4080 and I’m allowed to generate five frames,'" which successfully swerved the black frame issue that other earlier modders encountered, thereby unlocking higher frame generation multipliers.

Dashdogy quickly packaged things up as a Cyberpunk 2077 mod, and shipped it off to Nexus Mods. This was the canary in the coal mine for a more mature integration, but things weren’t quite perfect yet. Dashdogy and other modders reported a problem — when using anything more than 2X MFG in Cyberpunk 2077 on Ada, things felt sluggish. Latency wasn’t great, and with the help of another modder, they believed that this was the work of the fabled “Hardware Flip Metering,” which smooths out MFG's outputs, and is a primary reason Nvidia offers as the reason the feature doesn’t work on older graphics cards.

Armed with a cloud instance that uses an RTX 6000 Pro Blackwell GPU, Dashdogy quickly went to work improving the MFG mod. “I conducted a kernel dump whilst the GPU was running MFG.” Dashdogy was also equipped with OpenAI’s Daybreak Blue AI model, a modified version of GPT 5.6-Sol with safeguards adjusted to allow for defensive cybersecurity tasks and vulnerability discovery. Using the model and his know-how, he analyzed the RTX 6000 Pro’s kernel dump to check where things might be going wrong for his MFG mod, directly comparing it to his native RTX 4000 Series integration.

“For 6X frame generation, the GPU will render two real frames, then generate five frames and place them between those two real frames,” he told Tom’s Hardware Premium. Without copying this integration, frame pacing in his existing solution felt odd and disjointed.

“The 40-series-generated frames were all compacted around the middle of the two-frame interval. As you can see [in the image above], what we would expect, and what I measured from the [RTX Pro 6000 Blackwell], was five frames, neatly positioned at separate intervals. However, the 40-series GPU was forcing all of these around the same interval as 2X frame gen would put its one single frame.”

This caused the frame pacing of the MFG frames in the initial mod to feel sluggish, weird, and have poor responsiveness, as frame pacing is crucial in making a title feel smooth, especially when any frame generation tool is involved. “I discovered that the 40-series kernel responsible for motion processing was hardcoded to output a midpoint scaling for 2x only,” Dashdogy described. “With multiple generated frames, that compressed their represented motion toward the middle. With the fix, they spread out much more like the Blackwell reference.”

“The mod can work anywhere normal frame generation is implemented in any game,” Dashdogy told us, with additional telemetry for users to see exactly what’s changing. “The kernel is the same for both 40-series and 50-series; [it’s] just architecture-specific functionality [which blocks MFG on Ada]. 50-series has a number of Blackwell-specific optimizations that I’ve backported as well, and they contribute to better latency overall.”

The modder explains that the frame pacing fix was the most difficult part of the now-universal MFG port to Ada. But after its release, it now sits as a loadable ASI in a game’s directory and controls up to 6X frame generation in supported titles. The project has since been forked by other authors, which plugs the logic Dashdogy wrote into ReShade, a popular graphics mod tool.

Unlocking DLSS 5 NR (Uncle Burrito)

“I’ve been working with 3D art and graphics for many years now,” explains Uncle Burrito, a graphics enthusiast who implemented Path Tracing into Need For Speed Underground 2 using RTX Remix several years ago. “Over the years, I’ve stayed in the RTX Remix community to learn a lot more about real-time rendering and the techniques used for it.”

After hanging out in Nvidia’s RTX Remix Discord channel, news of the emergence of DLSS 5’s nvngX_dlssnr.dll spread like wildfire. According to Uncle Burrito, mods quickly clamped down on discussion of the DLL, and modders flocked to private channels and alternative servers, such as the RenoDX Discord server, to discuss development and integration. The DLL itself was written specifically for Blackwell, but the Ada architecture shares the ability to read FP8 instructions, which is what the DLL uses to load DLSS 5 Neural Rendering’s model weights.

Using that as a starting point, Uncle Burrito quickly went to work. “The model itself is just weights. These weights need code to be executed. The code was only written for Blackwell. CUDA binaries, right?” he explained. But despite this, and the aforementioned difference in ISAs between Blackwell and Ada, certain instructions could not be read by the humbler RTX 4000 series GPUs.

“Four of the 15 CUDA binaries [contained within nvngx_dlssnr.dll] would not run on Ada.” But this wasn’t an impossible task, as Uncle Burrito previously explained. The integration for Ada appeared unfinished and therefore, not entirely impossible. “I simply needed to patch the replacement compiled binaries”, meaning that it only took patching four affected CUDA binaries to get things up and running for RTX 4000 series graphics cards, Uncle Burrito told Tom’s Hardware Premium.

Uncle Burrito, alongside Ghidra, a reverse engineering tool, and an instance of Claude Code, set out to recompile the incompatible binaries to design a patch, but fell into a roadblock made by Claude itself. “I’m not too familiar with reverse engineering myself [...] Claude made the decision to use the incorrect version of the CUDA SDK to compile the replacement [binaries].” And so, the patched DLL ran, but instead output a black screen. “I could see the NR debug banner, and it did affect my framerate, but the output was completely black.”

“This is one of the many pitfalls of vibe coding,” Uncle Burrito said. “You can’t make anything good if you don’t understand what you’re working on. Usually, I don’t give the model any room to gaslight or make a wrong decision. If you don’t know what you’re doing, then don’t expect miracles.”

After realizing the mistake and recompiling with the correct CUDA SDK, the results were quickly posted to the RenoDX Discord server. “Ada performance is about as good as it can get. It has native FP8 support, so the hardware is doing its best. The rest can be attributed to simply not [having] enough horsepower in the chips.”

The simplicity of the patch might appear to be surprising, but the DLL leans on the same information that’s standardized between games and platforms, similar to how Streamline works in most game engines. “Motion vectors and depth buffer are [two] of the few things in graphics programming that we’ve standardized. Almost every modern game produces motion vectors, and rasterization isn’t possible without a depth/z buffer,” Uncle Burrito told us. Therefore, the DLL becomes a drop-in replacement for the officially distributed one, which unlocks the functionality on Ada.

Uncle Burrito’s methodologies were since picked up by RenoDX’s ShortFuse, who then worked on porting the DLSS 5 NR DLL to Ampere and Turing generation graphics cards. That porting work is more involved, since it also includes the translation of the model to be read by FP16 instructions. Following the release of Uncle Burrito’s work, a new DLL has emerged, with universal compatibility between Turing, Ampere, and Ada generations.

Unblocking the software lockouts

Between the MFG unlocker from Dashdogy and the patched Neural Rendering DLL created by Uncle Burrito, the community-made mods both unlock functionality that would not have come to older-generation cards or would have otherwise been added at a later date. According to Dashdogy, “40-series has no excuse” when it comes to support for Multi Frame Generation. “It’s a very small change that allows [the mod] to work,” noting that additional work is being done to recompile things for Turing and Ampere, with the caveat that latency and overheads get higher the further you go back.

“It always comes down to performance,” Uncle Burrito said. “It’s fair for [Nvidia] to not include Ada until they can get the optimization part sorted.” The modder further adds that the situation can be read in both ways, as a method for Nvidia to sell more RTX 5000 series graphics cards, and to have more time to optimize Neural Rendering for older RTX 4000 series GPUs.

Everyone wants to make the most out of their available hardware, especially at a time when consumer graphics pricing has firmly rocketed past the moon, with RTX 5090 GPUs now approaching north of $9,000. “I personally think [the MFG mod] is really important in the current market,” Dashdogy adds. “... many are just getting priced out of the new generation entirely, so giving people the ability to hang on to their GPUs for a little bit longer is going to help a lot of people stay invigorated and connected to the hobby.”

If a single Australian student can unlock DLSS MFG for older GPUs, Nvidia’s claims of hardware exclusivity appear less like a technical limitation and more like artificial lockout. For those unafraid to modify a few simple files within a game, those features are all readily available, albeit unofficially. There’s an irony in how both MFG and Neural Rendering were ported to older GPUs — the development of both mods relied on cutting-edge AI models — powered by the same ecosystem that’s driving Nvidia’s earnings. Now, the very same AI revolution Nvidia champions is being used to tear down its own walled garden.