sdli1995/dlssg_for_sm86

TL;DR

DLSSG for SM86 is a Windows x64 /D3D12 proxy DLL that lets games on RTX 20 (SM75) and RTX 30 (SM86) GPUs use NVIDIA’s DLSS‑G (frame‑generation) technology, even when the game’s original support is limited. It works by intercepting the game’s calls to NVIDIA’s NGX library and feeding them a modified, pre‑packed DLSS‑G runtime. The project ships a version.dll (the proxy) and a small dlssg_sm86.ini configuration file.

---

What it does

• Enables DLSS‑G (frame‑generation) on supported Direct3D 12 games for RTX 20 & RTX 30 cards.
• Provides a proxy/“shim” DLL (version.dll) that forwards NGX calls to the unmodified NVIDIA runtime while applying a custom GPU‑architecture rewrite so the game thinks it runs on an RTX 50, unlocking higher generation factors.
• Supplies pre‑built inference kernels (optimised and optional lossy variants) that match the official NVIDIA output pixel‑for‑pixel, with up to ~8 % speed‑up on RTX 3080 Ti.
• Supports 2×‑6× generation (the latter is NVIDIA’s Dynamic Multi‑Frame Generation, available when the game’s own Streamline plugin also supports it).
• Offers runtime switches via dlssg_sm86.ini:
  • Optimized 0‑3 selects the kernel set (0 = official, 1 = optimised, 2‑3 = lossy but faster).
  • MaxGeneratedFrames controls the upper bound (3 → 4×, 5 → 6× for the 310.9 build).
• Logs detailed diagnostics to dlssg_sm86\logs\ for troubleshooting.

---

Who might use it

• PC gamers with RTX 20/30 GPUs who want to try DLSS‑G in titles that either lack native support or crash with the official NGX implementation.
• Modders and performance enthusiasts who need a drop‑in DLL that does not require the CUDA toolkit or Python.
• Developers testing DLSS‑G on custom engines or benchmarking the GPU cost of frame‑generation.

---

Installation (step‑by‑step)

1. Close the game you want to modify.
2. Navigate to the game’s executable folder (e.g., …\Binaries\Win64\).
3. Copy the two files from the release archive:
   • version.dll
   • dlssg_sm86.ini If a version.dll already exists, back it up first. Some games load a different DLL name; in that case use the same file name the game loads (e.g., winmm.dll, dxgi.dll, dbghelp.dll) from the alternatives\ sub‑folder.
4. Launch the game, go to the graphics settings, enable DLSS and select a generation factor (2×‑4×, or 6× if the game’s Streamline plugin exposes it).
5. Upgrade – just replace version.dll with a newer version; the .ini usually stays the same.
6. Uninstall – restore the original version.dll (or delete it) and remove dlssg_sm86.ini.

---

Key configuration knobs

Setting	Values	Effect
Optimized	0‑3	0 = official NVIDIA kernels (no speed‑up). 1 = optimised kernels, pixel‑perfect, default. 2‑3 = lossy kernels, progressively faster but with a tiny visual quality drop (PSNR ≈ 50 dB).
MaxGeneratedFrames	3 (default) → 4×, 5 → 6× (only in the 310.9 build)	Caps the number of generated frames per real frame.
SkipRepeatedRealCopy	0/1	Controls whether duplicate real‑frame copies are omitted; rarely needed.
Logging level ([Logging] Level)	1 (errors only) – 3 (verbose)	Increases log detail in dlssg_sm86\logs\.

---

Performance snapshot (RTX 3080 Ti, driver 591.86)

The table below shows the GPU compute time per group (one real frame + generated frames) for the official kernels vs. the optimised set. Lower numbers mean less GPU work for frame‑generation.

Resolution	4× factor	Official (ms)	Optimised (ms)	Reduction
1080p	4×	2.641	2.021	23.5 %
1440p	4×	4.163	3.160	24.1 %
4K	4×	5.577	4.442	20.4 %

The numbers are median GPU‑time across many test runs; they do not directly translate to FPS gains because the overall game frame‑time also includes rendering, CPU work, and synchronization.

---

How to estimate FPS gain

1. Measure the baseline FPS (F_off) with DLSS‑G disabled.
2. Convert to frame time: T_base = 1000 / F_off ms.
3. Pick the appropriate T_FG (GPU time for a generation group) from the table above.
4. Compute the group time: T_group = T_base + T_FG.
5. Group rate: G = 1000 / T_group (groups per second).
6. Final FPS ≈ G × M where M is the generation factor (2‑6).

Example (4K, 4×, baseline 50 FPS):

• T_base = 20 ms
• Optimised T_FG = 4.442 ms
• T_group ≈ 24.44 ms → G ≈ 40.9 groups/s
• Estimated FPS ≈ 40.9 × 4 ≈ 163 FPS.

---

Compatibility & Limitations

• Supported GPUs: RTX 20 (Turing, SM75) and RTX 30 (Ampere, SM86). Tested on RTX 2080 Ti, RTX 3070, RTX 3080 Ti.
• OS / API: Windows 10/11, 64‑bit, Direct3D 12 games.
• Driver: NVIDIA drivers with NGX/NVAPI (tested 591.86 and 610.74). Older drivers fall back to PTX JIT for the first frame.
• No CUDA toolkit or Python required – the DLL contains everything needed.
• Vulkan: Not supported in the current release; community patches exist but are not part of the official repo.
• Game‑side support: The game must already load NVIDIA’s Streamline DLSS‑G plugin. If the plugin only offers 4×, the proxy cannot force 6×.
• Potential crashes: Early 0.3.x versions had a bug where the wrong inference kernel could be used after a settings change, causing visual artifacts or driver resets. Fixed in 0.3.5.

---

Safety & Trust

• The DLLs are self‑signed (CN=DLSSG for SM86 (self-signed)). Windows SmartScreen will flag them as “unknown publisher”, but the signature guarantees the file hasn’t been tampered with after release.
• No external binaries are downloaded at runtime; everything is packaged in the release archive.

---

License & Credits

• Source code: GPL‑v3.
• Embedded binaries (nvngx_dlssg.dll, kernel resources) are NVIDIA’s proprietary material and are distributed under NVIDIA’s own terms (see THIRD_PARTY_NOTICES.txt).
• Special thanks to Coldwood1026 for the RTX 20/SM75 adaptation and to NVIDIA for the original DLSS‑G runtime.

---

Bottom line

If you have a compatible RTX GPU and want a relatively painless way to try DLSS frame‑generation in Direct3D 12 titles—especially those that crash with the official NGX implementation—DLSSG for SM86 provides a drop‑in proxy DLL, a few tunable settings, and performance‑optimised kernels, all under an open‑source GPL license.