↓ Jump to the Table of Contents
⚠️ Careful of fake malicious websites
We got information that some malicious websites were making users download ZIP using similar name as this project, e.g. DLSS5-Feeder-v0.7.0.zip.
The only official release of DLSS 5 Feeder is on this GitHub, so be careful!
Thank to NIGos for the report.
⚠️ Nvidia Driver can cause issues with some addons
Some combinations of driver, NGX runtime and neural consumer do not work — it is usually the
combination, not the game. Check yours in fifteen seconds, with no game running:
host64\dlss5-feed-host64.exe --test (300/300 evaluates succeeded means you are fine). The
scenarios we know about:
| neural consumer |
driver 616.56 |
driver 616.64 |
| (none — DLAA only, no neural pass) |
— |
✅ 300/300 |
| Deep Fried Chicken 1.4.8-alpha |
— |
✅ 300/300 |
renodx-dlss5 v4.55 (classic engine) |
— |
✅ 300/300 |
renodx-dlss5 "latest" (classic engine) |
— |
✅ 300/300 |
renodx-dlss5 v4.6 (lazy-adoption engine) |
— |
❌ 1/300 |
renodx-dlss5 v4.7 (lazy-adoption engine) |
✅ 300/300 |
❌ 0/300 |
Blank cells are combinations nobody has run. Measured with --test on one RTX 5090 through the
64-bit helper. On 616.64+ the evaluate faults inside NVIDIA's own nvngx_dlssnr.dll
(#54) — any one of these works: Deep
Fried Chicken, a classic-engine renodx-dlss5, or driver 616.56.
Use 0.14.0-beta.2 or newer, and run Verify-DLSS5Feeder.ps1 in the game folder before reporting anything.
Description
DLSS 5 neural rendering in games that ship without any DLSS — D3D11, D3D12, Vulkan, OpenGL, 32-bit, even DirectX 10 and DirectX 9.
DLSS 5's neural-rendering add-on only works by hooking a game's own DLSS calls. A game that has no
DLSS never makes those calls, so the add-on sits idle. DLSS5-Feeder makes the calls itself. It
builds a complete DLSS DLAA "contract" out of what ReShade already has — the frame being processed,
the depth buffer, and estimated optical-flow motion vectors — runs a genuine DLSS evaluate, lets the
DLSS 5 neural-rendering add-on hook into that evaluate, and copies the neural result back into the
frame. All inside ReShade's effect chain.
game frame → ReShade effects → [motion vectors] → [DLSS5_Feed] → DLSS5-Feeder:
depth + MV DLSS DLAA + DLSS 5 neural rendering
↓
neural output written back over the frame → later effects → present
↓ Jump to the Contents
Before you install: four things
None of this is hard, and the automated installer verifies most of it for you.
1. You might not need this project at all
If your game is 64-bit and uses DirectX 9, 11 or 12, there is now a simpler option:
ShortFuse's renodx-dlss add-on does the whole job by itself. Use that instead — it is one
add-on rather than two, and there is nothing for this project to add.
| Your game |
What to use |
| 64-bit, DirectX 9 / 11 / 12 |
renodx-dlss on its own — you do not need DLSS5-Feeder |
| 32-bit (any graphics API) |
DLSS5-Feeder |
| Vulkan |
DLSS5-Feeder |
| DirectX 9, and you want the best handling of motion |
DLSS5-Feeder |
renodx-dlss is not on GitHub. It comes from the RenoDX Discord, #DLSS5 channel:
https://discord.com/invite/renodx
Why DLSS5-Feeder is still the only option for those three
- 32-bit games. renodx-dlss is 64-bit only, and NVIDIA ships no 32-bit NGX runtime at all, so
an in-process approach is impossible there by construction. This project's cross-process helper
is the only route.
- Vulkan games. Covered here through the bundled layer.
- Real motion vectors on D3D9. renodx-dlss evaluates only the finished backbuffer there, with
no temporal inputs. This project drives a full temporal evaluate from ReShade motion vectors.
2. You need one neural add-on installed next to this one
DLSS5-Feeder does not sharpen anything by itself. It builds the DLSS request your game never
makes; a second add-on does the actual neural rendering. You install exactly one of them.
Recommended: Deep Fried Chicken, by Alexander, from its Discord:
https://discord.gg/g2v2XGqvR — take 1.4.8 or newer.
Copy its three files next to your game's .exe (or into host64\ for a 32-bit game):
deep-fried-chicken.addon64, deep-fried-chicken-nvngx.dll and deep-fried-chicken.cfg.
Its settings file already arrives set up correctly, so leave it alone for your first run. You
supply nvngx_dlssnr.dll and nvngx_dlss.dll yourself, as always.
Never install two neural add-ons. If Deep Fried Chicken finds RenoDX's add-on or Alex's
Toolkit loaded beside it, it does nothing at all for the whole session — silently, as far as
your eyes are concerned. Pick one. If something looks like it is not working, this is the first
thing to check.
Using Krish's RenoDX add-on instead (the older option, still fully supported)
renodx-dlss5.addon64, the #DLSS5 build, from the RenoDX Discord, #DLSS5 channel:
https://discord.com/invite/renodx. It is what every release
up to now was developed against.
The feeder fingerprints whichever build it finds and adapts, so any recent one works — take the
newest in the channel. Any renodx-dlss5*.addon64 name is recognised (renodx-dlss5-4.7.addon64
included; before 0.11.0-beta.2 only the exact name was, and a versioned file was logged as "not
found" and treated as the classic engine). Keep just one copy — ReShade loads them all.
The feeder writes EnableHooks=2, NeuralUplift=1 and NREnableUpscaling=0 when they are unset,
and in the host64 helper it unbinds the global hotkeys so a gameplay keypress cannot silently
toggle neural rendering in a background process. Every guard is keyed to a marker only the build
that needs it carries. None of this applies to Deep Fried Chicken, which has its own config
file and its own overlay tab.
| Build |
Marker |
What the feeder does about it |
| v4.7 |
NRGlobalTone |
Newest, checked 2026-09-01. Replaces the paper-white codec with a reversible colour bridge (SDR sRGB / linear HDR BT.709 / PQ BT.2020) picked from the contract the feeder already publishes, plus a fenced D3D12 workset pool. Nothing new is required from the feeder; the 32-bit overlay mirrors its renamed sliders and its two new keys. |
| v4.6 |
NRToggleKey |
Global hotkeys, WIP upscaling with a rejection latch, richer decline diagnostics. See the NRStyle=2 note under Smooth Motion below. |
| v45+ |
EnableHooks |
Rescans every present and adopts missed features lazily, so the feeder skips its warm-up re-create. |
| older |
— |
Classic single hook pass; the warm-up re-create stays on. |
Verification status: no game row has verified a v4.6 or v4.7 run end-to-end yet. The
compatibility work is static — marker detection, key defaults, panel mirroring — and both
generations were checked against the shipped binaries.
Careful: renodx-dlss and renodx-dlss5 are two different add-ons
renodx-dlss5 (Krish) is a neural add-on. It works with this project, as the
alternative to Deep Fried Chicken above.renodx-dlss (ShortFuse) replaces this project — it builds the DLSS request itself, so it
neither needs nor tolerates the feeder. One or the other, never both.
3. OptiScaler: only the DLSS-NR fork, and Smooth Motion off on Vulkan
- OptiScaler — a stock OptiScaler must be off. It takes over the very NGX calls this project
makes, upscales them, and never runs a neural pass, so the picture never changes while every log
reads healthy. The one exception is the OptiScaler_DLSSNR fork, which is a supported neural
consumer — see Alternative: OptiScaler DLSS-NR. With it
installed there must be no Deep Fried Chicken and no RenoDX add-on beside it.
- NVIDIA Smooth Motion — turn it off for Vulkan games only. On Vulkan the two cannot work
together, and no future release can fix that. You would see roughly half your frames
unprocessed, which looks like heavy flickering or a picture stuck on an old frame. Nothing is
broken and nothing is crashing; it simply cannot work.
- DirectX 11 and 12 games are fine. Leave Smooth Motion on there if you like it.
To switch it off for Vulkan alone and keep it everywhere else: in NVIDIA Profile Inspector, set
Smooth Motion - Enabled APIs (0xB0CC0875) and clear the Vulkan bit — the value is a sum of
1 for DX12, 2 for DX11 and 4 for Vulkan, so 7 becomes 3.
Why Vulkan cannot work, and how to check whether Smooth Motion is on
Smooth Motion doubles your frame rate by inventing an extra frame between each pair of real ones.
On Vulkan it does that inside the graphics driver — the very last step before the picture
reaches your monitor, past anything ReShade or any add-on can touch.
This project does its work earlier, while the frame is still being built. So the frames the game
really renders get neural rendering applied correctly, but the frames the driver invents are
built from a copy taken before we ran, and carry none of it. Half the frames you see are processed
and half are not. The log will happily report every frame delivered, because from the feeder's
point of view they were.
We tried to close that gap and could not, which is why this is documented rather than fixed.
Across five rebuilds on DOOM 2016 — a game that works perfectly with Smooth Motion off — we
confirmed the feeder's work is correct and complete before the frame is handed over, that it can
finish early enough, and that it can be made structurally identical to a normal game's frame. The
invented frames still never carried our output. The driver simply does not read what we wrote.
Full detail in PLAN-DETROIT.md.
The feeder cannot warn you about this on Vulkan. Its Smooth Motion check looks for a file the
driver only loads for DirectX games, so a silent log does not mean Smooth Motion is off. To be
certain, turn on Smooth Motion - Debug Bars (0xB01B8B02) in Profile Inspector and launch:
coloured bars on screen mean it is running. (0.9.0 and newer also watch for the tell-tale extra
frames and warn when they spot them, but the Debug Bars check is the reliable one.)
| Profile Inspector setting |
ID |
Value |
| Smooth Motion - Enabled APIs |
0xB0CC0875 |
bitfield, default 7: 1 DX12, 2 DX11, 4 Vulkan — clear only the bit for this game |
| Smooth Motion - Enable |
0xB0D384C0 |
0 / 1, per application |
| Smooth Motion - Debug Bars |
0xB01B8B02 |
draws coloured bars on generated frames — use it to check whether the bad frames are the generated ones |
Smooth Motion on DirectX 11 / 12: what changed in 0.11.0-beta.2
It should work from 0.11.0-beta.2 on. Smooth Motion adds its own D3D11 device and an invisible
proxy swapchain (InvisibleWindowClassNvPresent), and ReShade creates an effect runtime on
each — ReShade.ini for one, ReShade2.ini for the other. Until beta.2 the feeder fed
whichever runtime initialised last, which under Smooth Motion was routinely the one without your
preset: the log looked healthy and nothing was neural (issue
#1, Ghost Recon Breakpoint and AC
Syndicate). It now tracks every runtime and feeds the one that actually renders DLSS5_Feed;
dlss5-feed.log lists each runtime with its device and window class, and says which one is bound.
Since 0.8.0 it is also thread-safe against Smooth Motion's extra Present calls.
If the picture still shows no effect with Smooth Motion on, post the log after a minute of play
(not the first seconds) on #1, and say whether your other ReShade effects are visible.
Two other add-ons Smooth Motion is known to crash (neither is this one)
Both crash the game 1–2 s into boot with a null read on the present path, before the feeder feeds
a frame. Found during a Metro 2033 Redux run.
- Luma (
Luma-Metro Redux.addon): reads GetCurrentBackBufferIndex() and passes it to
GetBuffer(), which fails under Smooth Motion's flip-model wrapper; the null back buffer is then
dereferenced. Fix offered upstream to Filoppi/Luma-Framework. Remove the Luma add-on to boot, or
turn Smooth Motion off for that game.
NRStyle=2 (the RenoDX add-on's own setting, v4.6+, from its overlay panel): crashes at the
next boot even without Luma. The feeder warns when it sees it; set NRStyle=0 in ReShade.ini's
[RenoDX.DLSS5] section to recover.
4. What this project actually ships, and antivirus warnings
A release here contains exactly two files: DLSS5-Feeder-<version>.zip and
AUTOMATIC_INSTALLATION_AVAILABLE.txt. Nothing else on the internet is a release of this
project, whatever it is named.
Several third-party installers repackage this project (and ReShade, and the neural consumers)
into their own downloads. That is fine and often convenient — but if Windows Defender flags a
file under someone else's download folder, that file is theirs, not ours, and only they can
get it cleared. Trojan:Win32/Kepavll!rfn on a shaders_*.zip under AppData\Local\<tool>\
is the common shape of this report; the path names the tool that downloaded it.
For a warning on a file that really came from this repository:
- Check it against the SHA-256 published on the release you downloaded it from
(
Get-FileHash <file> in PowerShell). A hash that does not match means you did not get it
from here.
- If it matches and Defender still objects, it is a false positive, and the useful thing to do
is submit it: https://www.microsoft.com/en-us/wdsi/filesubmission. That fixes it for
everyone rather than for one machine.
- One known true-but-harmless case: Deep Fried Chicken hooks NVIDIA's NGX runtime with
Detours, which heuristics dislike. The automated installer
tries the plain install first and only asks about an exclusion if Defender removes it.
This project asks for no exclusion you have not been shown the reason for, and never disables
your antivirus.
Contents
Status
Proven working in seven games covering every supported path:
| Game |
Bitness / API |
Result |
| Metro 2033 Redux |
64-bit D3D11 |
4K DLAA + NR, HDR backbuffer |
| Subnautica |
64-bit D3D11 |
Contributor-verified: 4K DLAA + NR, Generic Depth clear-selection profile |
| The Lord of the Rings: War in the North – Legacy Edition |
64-bit D3D12 |
4K, same-device path, 120 fps |
| Splinter Cell: Blacklist |
32-bit D3D11 |
60 fps, cross-process host |
| BioShock Remastered |
32-bit D3D11 (D3D9→D3D11 wrapper) |
4K, Luma HDR |
| Fable Anniversary |
32-bit D3D9 via dgVoodoo2 |
1440p, 60 fps |
| DOOM (2016) |
64-bit Vulkan |
4K, D3D12 evaluate via cross-API interop |
| Worms Ultimate Mayhem |
32-bit OpenGL |
4K, GL↔D3D12 interop + cross-process host, 0.13 ms/frame |
| Guild Wars Reforged |
32-bit Vulkan via DXVK |
User-reported (#32): 3440x1440, 55 fps on an RTX 4070 (350+ without) |
| World of Warcraft 3.3.5a |
32-bit Vulkan via DXVK |
User-reported (#15): 4K on an RTX 5080/5090; the working dxvk.conf is in the DXVK section |
| Star Wars: KOTOR |
32-bit OpenGL |
User-reported (#31): RTX 2060, fixed in 0.9.0 (capped GL_EXTENSIONS string) |
| MX Bikes |
64-bit OpenGL |
User-reported (#5): the in-process OpenGL path, confirmed working |
In each, the DLSS 5 add-on reports feature 18 created … inline feature 18 evaluation succeeded,
driven entirely by ReShade depth + estimated motion vectors.
It is not game-specific: any D3D11, D3D12, Vulkan or OpenGL game with a working ReShade depth buffer
and a motion vector provider should work — 64-bit directly, 32-bit via a bundled 64-bit helper
process, D3D9 via a wrapper.
Detroit: Become Human (Demo), 64-bit Vulkan — almost certainly the Smooth Motion case above.
The picture holds stale frames while the log reports every frame delivered, which is exactly the
signature described in the Smooth Motion warning. Enabling Smooth Motion in DOOM 2016 reproduces
it in a game that otherwise works, and the feeder cannot detect Smooth Motion on Vulkan, so its
silent log never ruled it out here. If you hit this: check "Smooth Motion - Debug Bars"
(0xB01B8B02), and if the bars appear, turn Smooth Motion off for Vulkan. Eight further tests
(DLSS/NGX, renodx NR, HDR and format detection, cross-API memory coherence, queue-family
ownership) all came back clean — full investigation in PLAN-DETROIT.md.
32-bit Vulkan (DXVK) is implemented and user-confirmed — see the World of Warcraft 3.3.5a row
above (issue #15). The transport is the
same src/feed_vk.h the 64-bit Vulkan path uses, compiled x86, with the host creating the shared
textures the way the OpenGL path already does; the cross-bitness half is proven end-to-end on this
hardware by spike\spike-vkhost64.exe + spike\spike-vkclient32.exe. Treat it as untested in a
real game until a row appears above. See PLAN-VULKAN32.md.
The OpenGL path is verified 32-bit-first, which is the harder of its two halves: Worms Ultimate
Mayhem runs the full cross-process route — the host creates the shared textures (GL memory objects
are import-only), the game imports them raw and answers on a shared D3D12 fence. The 64-bit
in-process OpenGL path shares that same src/feed_gl.h transport, is proven b
DLSS5-Feeder lets NVIDIA's DLSS 5 neural-rendering add-on work in games that ship with no native DLSS support at all, across D3D11, D3D12, Vulkan, OpenGL, 32-bit builds and even DirectX 9/10 titles. It builds a synthetic DLSS DLAA request out of ReShade's depth buffer and estimated motion vectors, runs a genuine DLSS evaluate, lets the neural add-on hook into it, and copies the result back into the frame.