Every PC gamer has felt the sting of an unsupported feature. You've got an RTX 4070, a library full of older titles, and a nagging sense that the hardware sitting in your case could be doing more. NVIDIA's Deep Learning Super Sampling (DLSS) can transform performance in supported games—doubling frame rates while cleaning up edges—but it only works when a developer explicitly integrates it. For thousands of games, that integration never happened, and it never will.
So when a repository surfaces claiming to feed DLSS into any D3D11, D3D12, or Vulkan game through ReShade depth buffers and "synthetic DLAA contracts," it's easy to see the appeal. The project—attributed to a GitHub user named jlrouzies-fr—promises a universal bridge: capture depth and motion data via ReShade, spin up a private D3D12 device, and hand a fabricated DLAA contract to the DLSS 5 add-on. The result, the claim goes, is DLSS-quality upscaling in titles that never shipped with it.
There are three immediate problems. First, DLSS 5 does not exist. NVIDIA's most recent publicly detailed version is DLSS 3.5 with Ray Reconstruction, announced in August 2023. There is no SDK, no driver branch, and no documentation for a "DLSS 5." Second, the repository itself does not appear in public GitHub search results, archived snapshots, or community references. It may be private, deleted, or simply fictional. Third, and most fundamental: the technical premise—synthesizing motion vectors from depth buffers and feeding them to a proprietary neural network—collides with how DLSS actually works.
This article is a technical autopsy. We'll examine what DLSS is, what the DLSS5-Feeder claims to do, why those claims break down at the API and data level, and what realistic alternatives exist for squeezing better image quality out of unsupported games.
Key Takeaway: The DLSS5-Feeder concept rests on a product that doesn't exist (DLSS 5), a term with no technical definition ("synthetic DLAA contract"), and a data pipeline (depth-derived motion vectors) that produces artifacts DLSS is specifically designed to avoid.
DLSS 1.0 arrived in 2019 with the RTX 20-series. It was trained per-game on supercomputer-rendered reference frames, and the results were mixed—soft textures, ghosting, and a limited game list. DLSS 2.0 (2020) replaced per-game training with a generalized temporal model that used motion vectors, depth, and jittered history buffers. It was the version that made the technology credible. DLSS 3.0 (2022) added Frame Generation, inserting interpolated frames between rendered ones on RTX 40-series hardware. DLSS 3.5 (2023) introduced Ray Reconstruction, a denoiser that replaces hand-tuned denoising in ray-traced workloads.
The through-line is that every DLSS version depends on game-provided data: motion vectors, depth buffers, exposure values, and jitter offsets. The neural network is only as good as the inputs.
DLSS 3.5 is not a new upscaler. It's the same Super Resolution and Frame Generation stack with an added Ray Reconstruction model. Ray Reconstruction uses a larger, more complex network trained on ray-traced ground truth to denoise path-traced and hybrid ray-traced scenes. It requires the game to feed ray-tracing data—not just rasterization buffers—into the DLSS pipeline. This matters for our discussion because it underscores how tightly DLSS is coupled to engine internals. You cannot bolt Ray Reconstruction onto a game that doesn't expose the necessary signals.
As of this writing, NVIDIA has never announced DLSS 5. There is no press release, no developer page, no SDK download, and no driver changelog referencing it. The company's public roadmap and GTC presentations stop at DLSS 3.5. Any project claiming to interface with "the DLSS 5 add-on" is either referring to an internal, unreleased build (implausible for a public GitHub repo) or inventing the target entirely.
DLSS is not a post-process effect. It is a library (nvngx_dlss.dll) that the game loads and calls at specific points in its rendering pipeline. The developer must:
NVIDIA's DLSS SDK license agreement explicitly prohibits reverse engineering and unauthorized use. Integration is a deliberate, documented process—not something that can be injected from the outside.
Key Takeaway: DLSS is a per-game integration, not a universal overlay. The SDK license forbids the kind of unauthorized injection the DLSS5-Feeder proposes.
The DLSS5-Feeder, as described, would operate as a ReShade add-on. ReShade hooks into a game's graphics API and exposes depth buffers, color buffers, and shader resources through its add-on API. The feeder would:
A private D3D12 device means the add-on creates its own ID3D12Device independent of the game's device. This is technically possible—D3D12 supports multiple devices, and Vulkan supports multiple VkDevice instances. The appeal is isolation: the add-on doesn't need to hook the game's command queue or interfere with its resource state.
The problem is resource sharing. Textures and buffers live on a specific device. To use the game's depth buffer on a private device, you must either:
ID3D12Resource with D3D12_HEAP_FLAG_SHARED), which require both devices to support shared resources and demand explicit synchronization.VK_KHR_external_memory), which have their own constraints.None of this is trivial, and none of it is free. Every cross-device copy adds latency, and DLSS is a latency-sensitive, per-frame operation.
ReShade supports D3D9, D3D10, D3D11, D3D12, OpenGL, and Vulkan. Depth buffer access varies by API and game. In D3D11, ReShade can often identify the depth buffer by heuristics (resolution matching, depth format). In D3D12 and Vulkan, the situation is more complex because of explicit resource management and descriptor heaps.
Motion vectors are a different story. ReShade does not expose motion vectors in most games. The engine computes them internally, often in a compute shader or as a byproduct of temporal anti-aliasing (TAA). They are not a standard render target that ReShade can intercept.
The pitch is straightforward: DLSS-like quality in any game. In practice, the benefits would be undermined by inaccurate motion vectors, synchronization overhead, and the absence of a real DLSS 5 target.
Key Takeaway: A private D3D12 device is possible, but sharing per-frame depth and motion data across devices introduces latency and complexity that DLSS cannot tolerate.
ReShade's depth buffer access is a well-documented feature. In many games, ReShade can identify the depth buffer by analyzing shader resource views (SRVs) and render target views (RTVs) for depth formats (D32_FLOAT, D24_UNORM_S8_UINT, etc.). The ReShade API provides reshade::api::effect_runtime and resource tracking that add-ons can query.
Limitations:
Motion vectors encode per-pixel screen-space velocity from the previous frame to the current frame. They are essential for DLSS because they tell the network where to look for historical information. Without accurate motion vectors, DLSS produces ghosting, shimmering, and smearing.
ReShade does not provide motion vectors. The ReShade documentation and community forums confirm that motion vector support is limited to specific titles where add-on authors have reverse-engineered the engine's internal buffers. There is no generic motion vector source.
The DLSS5-Feeder's proposed workaround is to generate motion vectors from depth. This is a known technique in computer vision (optical flow from depth), but it has severe limitations for real-time rendering:
The result is motion vectors that are wrong for exactly the cases where DLSS matters most: fast motion, complex scenes, and dynamic objects.
DLAA (Deep Learning Anti-Aliasing) uses the same neural network as DLSS but at native resolution. It still requires motion vectors, depth, and jitter. It is not a post-process AA like SMAA or FXAA. Feeding it synthetic data would degrade quality below what a simple spatial AA could achieve.
Even if the data were perfect, moving it between devices is expensive. A 4K depth buffer is 3840×2160×4 bytes ≈ 33 MB per frame. At 60 FPS, that's ~2 GB/s of cross-device traffic, plus synchronization overhead. Shared resources in D3D12 require D3D12_RESOURCE_FLAG_ALLOW_SIMULTANEOUS_ACCESS or explicit fences, and Vulkan requires external memory extensions with platform-specific handles.
Key Takeaway: Depth-derived motion vectors cannot capture object motion, transparency, or disocclusion. DLSS and DLAA require engine-provided motion vectors for a reason.
The DLSS SDK license prohibits reverse engineering, modification, and unauthorized distribution. Using the SDK to build a universal injector would violate these terms. NVIDIA has not released a public DLSS 5 SDK, so any project claiming to use one is either using a leaked build (illegal) or fabricating the claim.
Most game EULAs prohibit modification of the game's code or memory. Injecting a renderer that alters the game's output could be construed as a violation, especially if it interferes with anti-cheat systems.
Anti-cheat software (Easy Anti-Cheat, BattlEye, Vanguard) monitors for DLL injection, hooking, and unauthorized memory access. ReShade itself is often whitelisted, but add-ons that create private D3D12 devices or hook rendering pipelines may trigger detection. The risk of a ban is real, particularly in multiplayer games.
Modding for personal use is one thing. Distributing a tool that circumvents developer intent and potentially violates licenses is another. The DLSS5-Feeder, if it existed, would sit in a gray area that NVIDIA and game publishers have shown little tolerance for.
Key Takeaway: The DLSS SDK license forbids unauthorized use, and anti-cheat systems are designed to detect exactly this kind of injection.
In 2021, a modder released a DLSS mod for Cyberpunk 2077 that allowed older DLSS versions to be swapped. This worked because the game already had DLSS integration—the mod only replaced the DLL. It did not add DLSS to a game without it.
Attempts to inject DLSS into unsupported games (e.g., via wrapper DLLs) have generally failed. Reported issues include:
The lesson is clear: DLSS works when the game provides the right data at the right time. External injection cannot replicate the engine's internal state.
Key Takeaway: Successful DLSS mods replace an existing integration. They do not create one from scratch.
No SDK, no support, no documentation.
There is no such thing in NVIDIA's API. DLAA is invoked through the same NVSDK_NGX_DLSS interface as DLSS, with a flag for native resolution.
Depth-derived motion vectors produce ghosting and shimmering, the exact artifacts DLSS is designed to eliminate.
Cross-device resource sharing adds latency and complexity. DLSS is a per-frame, latency-sensitive operation.
The GitHub repository jlrouzies-fr/DLSS5-Feeder does not appear in public search results. It may be private, deleted, or fictional.
Key Takeaway: Every pillar of the DLSS5-Feeder concept—the target API, the data pipeline, the legal basis—fails under scrutiny.
ReShade can add sharpening (CAS, LumaSharpen), SMAA, FXAA, and color grading. These are spatial effects that don't require motion vectors.
NVIDIA Image Scaling (NIS) and AMD FSR 1.0 are spatial upscalers that work at the driver level. They don't match DLSS quality but require no game integration.
Some games have community mods that add DLSS with developer blessing (e.g., via engine plugins). These are rare and game-specific.
The most reliable path is to ask developers to integrate DLSS. NVIDIA's game list and developer resources make this easier than ever.
Key Takeaway: Spatial upscalers and post-processing effects are the realistic options for unsupported games. DLSS injection is not.
The DLSS5-Feeder is a compelling idea wrapped around a nonexistent technology. DLSS 5 does not exist. Synthetic motion vectors cannot replace engine-provided data. Private D3D12 devices introduce more problems than they solve. And the repository itself cannot be verified.
The real story is that DLSS works because of tight collaboration between NVIDIA, game engines, and developers. That collaboration is what makes the magic happen—not a universal injector.
Key Takeaway: Verify claims. Check for official announcements. Understand the data requirements. And when in doubt, ask: does the technology actually exist?
What is DLSS 5? DLSS 5 is not an official NVIDIA product. The latest publicly detailed version is DLSS 3.5 with Ray Reconstruction.
Can DLSS be injected into games that don't support it? No. DLSS requires per-game integration and engine-provided data. Injection attempts fail or produce artifacts.
What is the jlrouzies-fr/DLSS5-Feeder repository? It does not appear in public search results. It may be private, deleted, or fictional.
Can ReShade provide motion vectors for DLSS? No. ReShade does not expose motion vectors in most games. Depth-derived motion vectors are inaccurate.
Is it legal to use DLSS without game developer permission? The DLSS SDK license prohibits unauthorized use. Game EULAs may also prohibit modification.
What is a synthetic DLAA contract? A fictional term. There is no such concept in NVIDIA's API.
Can a private D3D12 device be used to run DLSS? Technically possible, but resource sharing and synchronization make it impractical for real-time upscaling.
What are the risks of using unofficial DLSS injectors? Crashes, visual artifacts, performance regressions, and anti-cheat bans.
If you found this deep-dive informative, share it with fellow gamers and modders. For official DLSS support, check NVIDIA's game list and encourage developers to integrate DLSS properly. Stay tuned for more technical analyses on emerging graphics technologies.