dlssg_for_sm86: The Mod That Makes NVIDIA’s Frame Generation Run Where It Wasn’t Supposed To

A native proxy DLL, custom CUDA kernels, and a careful performance tradeoff let Ampere and Turing cards tap into DLSS Frame Generation without the official RTX 40-series gate.

9 min read • View on GitHub • More from sdli1995

A locked game executable sits on one side of the composition while a slim proxy DLL slides a key-shaped bridge into the lock. Behind it, GPU gears marked SM75 and SM86 turn in sync, and a stream of extra frames pours into a monitor on the far side. The image explains the repo’s core idea: a drop-in DLL intercepts the game’s load path, then routes frame generation through architecture-specific compute.
The project’s trick is not just compatibility. It is a proxy entry point that reaches a native frame-generation path on unsupported NVIDIA hardware.
Key Takeaways

The lock NVIDIA didn’t want you to think about

NVIDIA drew a bright line around DLSS Frame Generation. Officially, the feature belonged to newer silicon. This repo treats that line as a software boundary, not a law of nature.

That is why `sdli1995/dlssg_for_sm86` is interesting. It claims to bring NVIDIA’s own frame-generation path to RTX 30-series and RTX 20-series cards, without translating the feature into FSR3 and without depending on the original shipped DLL.

SM86 route targets RTX 30-series GPUs; SM75 targets RTX 20-series GPUs. Physical validation currently uses RTX 3080 Ti.

sdli1995, Author / Maintainer · dlssg_for_sm86/README.en.md

That distinction matters. A translation layer can be useful, but this repo’s pitch is sharper: make unsupported NVIDIA hardware behave like it belongs on the native NVIDIA path.

From proxy DLL to native runtime

The project started in the familiar modder’s zone: drop in a DLL, intercept what the game loads, and forward the ordinary calls while catching the special ones. But the current implementation is more ambitious than a wrapper around an unpacked vendor binary.

The important shift is from extraction to native routing. The proxy is the door, but PTX and kernel selection are the engine.

The repo’s documentation describes a native host that embeds the qualified kernel replacements, decoder, pair, merge, residual-chain, and image fusions directly. In other words, the project is not simply passing through to a hidden vendor runtime. It is reconstructing enough of the runtime path to stand on its own.

That is the technical leap. It turns a feature gate into an implementation problem.

How the drop-in mod gets into the game

The entry point is the part most users never think about. Games commonly load `version.dll`, and some load other system libraries instead. This repo uses that habit against the platform by placing a proxy DLL in the game directory, where the game loads it before the real system library.

; Typical setup pattern
Game.exe
├─ version.dll        ; proxy entry point
├─ dlssg_sm86.ini     ; routing and performance config
└─ altnative/
   ├─ dxgi.dll
   └─ winhttp.dll

Once the proxy is in place, ordinary Windows calls can be forwarded to the real DLL while DLSSG-specific requests get intercepted and redirected. The same pattern can be adapted for games that do not touch `version.dll`, which is why the repo keeps alternates in `altnative/`.

This is one of the oldest tricks in PC modding, but the interesting part here is what the proxy eventually hands off to: native compute paths tuned for different GPU generations.

Why PTX, routing, and kernel fusion matter

A close-up pipeline splits into two parallel lanes. One lane is a careful exact path made of finely machined gears and a precision gauge. The other is a faster path fed by a polished hardware sampler arm. Both converge into one output frame. The image explains the repository’s performance tradeoff: exactness on one side, speed on the other.
`HardwareBilinear` is the clearest sign that this project is spending GPU time intentionally, not pretending there is no cost.

This is where the repo stops being a neat proxy trick and becomes a compute story. The configuration file points `Router=SM86/SM75` at the right architectural path, and `KernelImage=PTX` tells the driver to JIT-compile the portable intermediate code locally.

That matters because PTX buys flexibility. Instead of shipping a separate binary for every possible driver and GPU combination, the project hands the driver a portable kernel image and lets NVIDIA’s stack do the last-mile compilation work.

The documentation also points to optimized convolutions, decoder, pair, merge, and residual-chain fusions. Those are the sort of low-level changes that usually disappear into a benchmark chart, but here they are the reason the mod can chase real performance instead of just functional parity.

The native host integrates the qualified exact kernel replacements, decoder, pair, merge, residual-chain and image fusions; hardware bilinear is optional.

sdli1995, Author / Maintainer · dlssg_for_sm86/THIRD_PARTY_NOTICES.txt

The speed vs. accuracy bargain

ModeWhat it optimizes forWhat you give upWhy it matters
ExactByte-for-byte fidelityGPU timeBest when you care about matching reference output
Fast with HardwareBilinearThroughputSome exactnessBest when frame generation cost is the bottleneck
Native route without translationNVIDIA’s own runtime pathCompatibility workBest when you want NVIDIA-style output on unsupported cards

The most revealing toggle in the project is `HardwareBilinear`. It is easy to read as a footnote, but it is really the thesis in miniature. One path tries to match the reference output exactly. The other chooses speed by letting the hardware sampler do more of the work.

That is the right kind of compromise for this repo. It does not sell magic. It decides where to spend GPU time, then exposes the choice plainly.

What makes this different from FSR3 unlocks

ProjectTarget hardwareBackendNative NVIDIA runtimeMain tradeoff
Official DLSSGSupported RTX hardwareNVIDIA shipped stackYesHardware gate
dlssg-to-fsr3Wide compatibilityFSR3 translationNoDifferent interpolation model
dlssg_for_sm86RTX 20 and 30 seriesNative NVIDIA pathYes, as implemented by the modTrust, complexity, and unofficial support

This comparison is the real editorial point. `dlssg-to-fsr3` is about translation. `dlssg_for_sm86` is about making NVIDIA’s own stack run where NVIDIA did not officially bless it.

That changes how people evaluate the output. Frame pacing, artifacts, and image character are not generic “frame generation” questions. They depend on which backend is doing the interpolation and how native that backend really is.

What the numbers suggest, and what they do not

The project reports aggressive modes, including 2x, 3x, and 4x generation paths, along with performance numbers that show real gains in frame delivery. That is the appeal, and it is not trivial on Ampere or Turing hardware.

But higher output FPS is not the same thing as lower latency. Frame generation can make motion look smoother while still adding compute overhead, and the repo’s own mode switches make that tradeoff visible rather than hidden.

That honesty is useful. It keeps the article from collapsing into a simple “old GPU good now” story.

The trust problem every reader should notice

A proxy DLL in a game directory is always going to trigger a security reflex, and this repo deserves that reflex. Users are asked to run a modded binary, watch for antivirus alerts, and trust code that sits directly in the game’s load path.

That does not make the project illegitimate. It does mean the engineering story and the trust story are inseparable. For a mod like this, distribution, transparency, and provenance are part of the product.

Your game now supports DLSS multiframegen on your RTX 30 card. Video proof of it running on an RTX 3080 12GB: https://www.youtube.com/watch?v=KNVr5pHAygI

fogoticus, Reddit User / Tester · PSA: RTX 3000 users can finally enable DLSS Framegen

That is the tension at the heart of `dlssg_for_sm86`. It is clever enough to be impressive, and invasive enough to demand skepticism. Both reactions are correct.