d4r 0.1.3

d4r 0.1.3

This release adds an optional accuracy mode and fixes the GLIBC compatibility failure, DLSS artifacts, and stale output-buffer redirects reported after 0.1.2. Accuracy mode is off by default.

Added

• Prefer accuracy over performance. Set [Kernels] PreferAccuracy = true in d4r/d4r.ini and restart the game. The release includes separate accuracy variants of every native network and texture kernel for all supported RDNA3 and RDNA4 targets, including RDNA4's native FP8 variants.
  • K restores FP16 accumulator rounding after each matrix step. M also restores intermediate FP8 quantization.
  • The accuracy path retains denormal handling, disables relaxed accumulation/fast-math switches, and keeps NGX's synchronization calls. It uses a separate compilation cache.
  • Missing accuracy variants use translated NVIDIA kernels and are logged; the fast native set is never silently substituted.
  • This aims to preserve NVIDIA's arithmetic. It is slower, its FPS cost has not been benchmarked, and 1:1 image quality against RTX DLSS is not proven.
• Reproducible GLIBC 2.41 build environment. A pinned Debian build image and release-build script rebuild ZLUDA/LLVM, the Wine bridge, the Windows DLLs, and both kernel sets. The ZIP includes toolchain details in d4r/source/BUILD_INFO.txt.

Fixed

• GLIBC loader compatibility (#6). The previous release required GLIBC_2.44 from libm.so.6, preventing ZLUDA from loading on systems such as the reporter's Bazzite installation. This release is built in a GLIBC 2.41 environment; the package check rejects any bundled Linux library requiring a newer ABI.
• Cyberpunk 2077 preset-K black artifacts (#5). Preserve FP16/FP64 denormal requirements while limiting the performance optimization to FP32. The fix covers both translated kernels and the rebuilt native texture kernels. Captured-scene replays showed substantially fewer sky artifacts; this is not a guarantee that every scene is artifact-free.
• Stale direct-output redirects after resource destruction (#8). Reused CUDA array handles no longer inherit an earlier feature's output buffer. This addresses the quality-switch corruption reported with preset M in Spider-Man 2.

Improved

• Synchronization diagnostics and an optional blocking output wait. D4R_SHIM_BLOCKING_SYNC=1 yields the CPU while waiting for DLSS output, with a fallback to context synchronization. It is an opt-in mitigation for #7; reduced CPU usage on the reporter's RDNA4 setup still needs confirmation.
• More useful failure logs. Rejected input/output formats and dimensions are now recorded even after startup, with repeated errors rate-limited. Output-wait CPU and wall time are reported separately, and GPU timing queries are deferred until asynchronous work finishes.
• More conservative accuracy texture builds. Strict surface conversions use separate helper functions, avoiding a compiler failure when the original denormal handling is retained.
• Accuracy build safeguards. The builder refuses to label a directory containing older fast binaries as an accuracy set. Configuration tests cover every release target, missing-set fallback, invalid markers, environment precedence, and the default-off behavior.

Also included from 0.1.2

These capabilities remain in the release; they are not newly validated hardware results:

• Experimental RDNA4 builds for gfx1200/gfx1201, with NativeFp8 enabled by default, alongside gfx1100–gfx1103 RDNA3 builds.
• Kernel selection uses the GPU with the most SIMDs when integrated and discrete GPUs coexist; D4R_GPU_ARCH overrides it.
• DLSS 3 matrix-kernel acceleration; M's cached weight preparation, packed FP8 encoding, improved patch-merge/weight loads, and direct output; K's CU-mode layers; wave64 performance texture variants.
• Native texture/output variants for the game's motion-vector resolution, HDR/LDR input and depth direction, compiled offline per GPU target.
• The bundled ROCm 7.2.4 runtime: no separate ROCm installation is required.

The 0.1.2 performance measurements remain historical results. They are not benchmarks of this rebuild or the new accuracy mode.

Install or upgrade

1. Back up your d4r/d4r.ini and OptiScaler.ini if you customized them.
2. Extract d4r-0.1.3.zip into the folder holding the game's main .exe (<Project>/Binaries/Win64 for Unreal Engine games), keeping the ZIP's layout.
3. Restore your settings if needed. Older INIs omit PreferAccuracy, which defaults to off; add it under [Kernels] to enable it.
4. Select GE-Proton 11 in Steam (tested integration: GE-Proton11-3), with:

   PROTON_FORCE_NVAPI=1 DXVK_NVAPI_GPU_ARCH=AD100 %command%
   

5. Select DLSS in the game and restart after changing the accuracy option.

The rebuilt runtime may compile a new kernel cache on first start. sh d4r/d4r-check.sh checks the install. SUPPORTED_GAMES.md lists game-specific setup and known issues.

Validation and limits

• Built in GLIBC 2.41. All eight bundled Linux ELF libraries passed the ABI check; their highest required GLIBC version is 2.38. The packaged ZLUDA library loaded successfully in the 2.41 environment and its CUDA driver API returned success. This also satisfies the GLIBC requirement on the reporter's 2.43 system.
• GPU harness on the RX 7700 XT under SteamLinuxRuntime_4/GE-Proton11-3: E, K and M each completed 16 frames with accuracy off and on (six runs), with finite, nonzero output. These synthetic runs are not game FPS benchmarks or RTX image-quality comparisons.
• All 11 configuration, policy and native-set selection tests passed. The ZIP contains 912 GPU kernels: 57 kernels for each of eight target variants, in both performance and accuracy sets.
• The release contains performance and accuracy kernels for all eight target variants. Configuration tests and sampled CPU-emulated kernel/reference checks cover the new accuracy path; these do not establish full-game or RTX parity.
• RDNA4 remains experimental: emulator/compiler coverage does not prove hardware speed, image quality, or driver stability. The external RX 7900 XTX report is RDNA3, not RDNA4 validation.
• Super Resolution only: Frame Generation, Ray Reconstruction, and DLSS 5 Neural Rendering are unsupported. Keep Ray Reconstruction off.

Licenses

d4r is Apache 2.0. ZLUDA, LLVM, vkd3d-proton, OptiScaler, and the bundled ROCm libraries retain their respective licenses in d4r/licenses; sources and patches are listed in d4r/source. NVIDIA's libraries and texture kernels compiled from its code are not covered by those licenses. d4r is not affiliated with NVIDIA or AMD.

SHA-256 d4r-0.1.3.zip: e3f9bc5c144ec7e20c970d74bdbc5e72ac0e569361cd4016d1559a6405a4981b. The checksum is also attached as a .sha256 file.

d4r 0.1.2

d4r 0.1.2

NVIDIA's own DLSS Super Resolution on AMD Radeon GPUs, in DirectX 12 games under Proton. This release adds experimental RDNA4 (RX 9000 series) builds and native kernels for every RDNA3 chip. It also makes DLSS a little faster and covers more game settings with the fast kernels.

RDNA4 is untested on real hardware. The RDNA4 kernels have been checked with an emulator and a compiler only. If you have an RX 9070 / 9070 XT / 9060 XT or a Radeon AI PRO R9700, please try it and open an issue with your results, good or bad. If bad please attach the d4r_nvngx.log located in the d4r folder and describe the issue and if possible attach screenshots.

What's new

• RDNA4 support (experimental). The zip now includes native DLSS 4 (K) and DLSS 4.5 (M) network kernels for gfx1201 (RX 9070 XT, 9070, 9070 GRE, Radeon AI PRO R9700) and gfx1200 (RX 9060 XT, 9060).

  • On RDNA4, DLSS's FP8 math runs on the GPU's native FP8 matrix units. NativeFp8 in d4r/d4r.ini (default on) controls this; off uses 16-bit math, as on RDNA3.
  • Testing so far: gfx1201 was checked in an emulator and gfx1200 compile-only. Speed, image quality and driver stability on RDNA4 are unknown.

• Native kernels for all RDNA3 chips. Kernels are now built for gfx1100 (RX 7900 series, PRO W7800/W7900), gfx1101, gfx1102 (RX 7600 series) and gfx1103. In 0.1.1, only gfx1101 had them. On the other chips, DLSS 4 (K) lost its transformer and DLSS 4.5 (M) ran at about half speed. Only the RX 7700 XT has been tested.

• Integrated GPUs no longer confuse kernel selection. On systems with both an iGPU and a Radeon card, d4r now picks the GPU with the most compute units. Set D4R_GPU_ARCH to override the choice.

• Faster DLSS on RDNA3. Measured back to back with 0.1.1 at Quality in SILENT HILL Townfall (RX 7700 XT, 1440p):

  Model	0.1.1	0.1.2
  DLSS 3 CNN (E)	71.2 fps	71.9 fps
  DLSS 4 (K)	67.9 fps	68.1 fps
  DLSS 4.5 (M)	48.4 fps	49.3 fps

  The changes behind this:

  • DLSS 3's convolutions now run on the matrix units.
  • M prepares its weights once per weight set instead of on every frame.
  • M writes its result directly into the game's output.
  • Some texture kernels now run with 64 threads per wave.

• More games get the fast kernels. DLSS picks kernel variants by the game's settings: motion-vector resolution, HDR or LDR, and depth direction. Native versions now exist for every variant, not only the ones Townfall uses. Games with other settings run faster than in 0.1.1.

Install

1. Extract d4r-0.1.2.zip into the folder that holds the game's main .exe. For Unreal Engine games that is <Project>/Binaries/Win64. Keep the zip's layout: dxgi.dll, OptiScaler.ini, d3d12.dll and d3d12core.dll go next to the .exe, beside the d4r folder.
2. In Steam, force GE-Proton 11 for the game and set these launch options:

   PROTON_FORCE_NVAPI=1 DXVK_NVAPI_GPU_ARCH=AD100 %command%
   

3. Select DLSS in the game. The first start compiles DLSS's GPU kernels, which takes about a minute and a half. Later starts use the cache in ~/.cache/d4r.

Upgrading from 0.1.0 or 0.1.1: extract over the old files, then restore your d4r/d4r.ini if you changed it. The new NativeFp8 setting has no effect outside RDNA4. sh d4r/d4r-check.sh checks an install.

Requirements

• An AMD RDNA3 (RX 7000) or RDNA4 (RX 9000) GPU. Only the RX 7700 XT has been tested on real hardware.
• The amdgpu kernel driver (/dev/kfd). ROCm is bundled.
• GE-Proton 11 (tested: GE-Proton11-3).

For builders

• The ZLUDA patch series is now 0002–0007:
  • 0006 adds f16 m16n8k8 WMMA, weight-image slots for native prep kernels, and wave64 builds;
  • 0007 adds gfx12 WMMA, native FP8, and an architecture argument for d4r_emit.
• Texture kernels are compiled offline for each target with d4r_emit (D4R_ZLUDA_EMIT), so no GPU of that target is needed. gfx12 targets also get an -fp8 variant (D4R_NATIVE_FP8=1). See docs/building.md.

d4r 0.1.1

d4r 0.1.1

NVIDIA's own DLSS Super Resolution on AMD Radeon RX 7000 (RDNA3) GPUs, in DirectX 12 games under Proton. This release fixes a VRAM leak and two input-format problems, bundles the ROCm runtime, and adds a dozen tested games.

What's new

• No more VRAM growth when changing the DLSS quality setting. Each switch between Quality, Balanced, Performance and so on used to keep about 130 MB of VRAM until the game closed, because of a reference-counting bug in ROCm 7.2's external-memory mapping. d4r now reuses its shared buffers, and VRAM stays flat over repeated switches. It also no longer leaks a file handle per buffer.
• Games that pass 4-channel motion vectors now work. Motion vectors in R16G16B16A16 formats (including TYPELESS, as Dying Light: The Beast uses) used to be rejected, which left the screen black. They are now converted on the GPU and stay on the fast VRAM path.
• Multi-channel exposure textures stay on the VRAM path. Games that pass exposure as an RGBA float texture no longer fall back to the slower copy through system memory, which showed up as reflections lagging behind (Ready or Not).
• ROCm no longer needs to be installed. The zip includes the ROCm 7.2.4 runtime (HIP, HSA, comgr) in d4r/rocm, from AMD's Ubuntu 22.04 packages; it runs under Steam's container runtime on any distribution. RocmDir in d4r/d4r.ini still selects another installation.

Tested games

Radeon RX 7700 XT, GE-Proton 11-3. All three DLSS models (E, K, M) run in each game:

SILENT HILL Townfall, Ghost of Tsushima DIRECTOR'S CUT, Ready or Not, Clair Obscur: Expedition 33, Marvel's Spider-Man: Miles Morales, The Last of Us Part I, Control Ultimate Edition, Cyberpunk 2077, Alan Wake 2, SILENT HILL 2 (2024), Subnautica 2, Horizon Zero Dawn Remastered, Ratchet & Clank: Rift Apart, Dying Light: The Beast.

Several need a small setup step: renaming a file, a launch option, or an OptiScaler.ini setting. SUPPORTED_GAMES.md lists these, along with known image-quality issues per model.

Install

1. Extract d4r-0.1.1.zip into the folder that holds the game's main .exe. For Unreal Engine games that is <Project>/Binaries/Win64. Keep the zip's layout: dxgi.dll, OptiScaler.ini, d3d12.dll and d3d12core.dll go next to the .exe, beside the d4r folder.
2. In Steam, force GE-Proton 11 for the game, and set these launch options:

   PROTON_FORCE_NVAPI=1 DXVK_NVAPI_GPU_ARCH=AD100 %command%
   

3. Select DLSS in the game. The first start compiles DLSS's GPU kernels, which takes about a minute and a half; later starts use the cache in ~/.cache/d4r.

Upgrading from 0.1.0: extract over the old files, then restore your d4r/d4r.ini if you changed it. D4R_README.txt in the zip has the details, and sh d4r/d4r-check.sh checks an install.

Requirements

• An AMD Radeon RX 7000 series GPU. The fast kernels are built for gfx1101 (RX 7700 XT, RX 7800 XT, RX 7700). Other RDNA3 cards run DLSS without them:
  • DLSS 3 (E) at full speed;
  • DLSS 4.5 (M) at about half speed;
  • DLSS 4 (K) without its transformer, with a worse image.
• The amdgpu kernel driver (/dev/kfd).
• GE-Proton 11 (tested: GE-Proton11-3).

Performance

Radeon RX 7700 XT, SILENT HILL Townfall at 2560×1440, average fps over the same 62-second walk:

Mode	DLSS 3 CNN (E)	DLSS 4 (K)	DLSS 4.5 (M)	FSR 4
Quality	72	69	51	76
Balanced	80	76	59	84
Performance	88	82	69	94
Ultra Performance	89	93	90	107

Native 2560×1440 without upscaling (the game's TSR at 100%) runs at 49 fps. This release does not change the per-frame cost of DLSS.

Known limitations

• Only DLSS Super Resolution in DirectX 12 games. There is no Frame Generation or Ray Reconstruction: keep Ray Reconstruction off in games that offer it.
• Use the game's DLSS setting where it exists. Feeding DLSS from FSR or XeSS inputs through OptiScaler can ghost, or show a black screen in some games.
• Saving from the OptiScaler overlay ("Save INI") resets d4r's OptiScaler.ini values to auto, including frame generation. Restore them afterwards.
• Do not use it in games with anti-cheat.
• DLSS 4.5 (M) is much slower than FSR 4 on RDNA3.

Licenses

d4r is Apache 2.0. The zip also contains:

• ZLUDA (Apache 2.0 or MIT);
• vkd3d-proton (LGPL 2.1, patched; the patch is in d4r/source);
• the ROCm 7.2.4 runtime, unmodified: HIP and rocprofiler-register (MIT), ROCr (NCSA), comgr (Apache 2.0), and Ubuntu's libelf and libnuma (LGPL). The license texts are in d4r/licenses;
• OptiScaler 0.9.4 (GPL 3.0, unmodified; source at https://github.com/optiscaler/OptiScaler/tree/v0.9.4).

d4r/source/SOURCES.txt lists where every file comes from.

NVIDIA's files in the zip, and the kernels built from NVIDIA's code, belong to NVIDIA and are not covered by any of these licenses. d4r is not affiliated with NVIDIA, AMD or the OptiScaler project.

SHA-256 d4r-0.1.1.zip: bb57116606cae8e46c997d604c1aae6291714ee642a53f32fcc15ee7be10d7f6

d4r 0.1.0

d4r 0.1.0

NVIDIA's own DLSS Super Resolution on AMD Radeon RX 7000 (RDNA3) GPUs, in DirectX 12 games under Proton. This is the first release packaged as a drop-in zip, to install extract it next to the game's executable and set one line of launch options.

It is an early release, tested on one GPU (RX 7700 XT) in SILENT HILL Townfall and Ghost of Tsushima DIRECTOR'S CUT.

Install

1. Extract d4r-0.1.0.zip into the folder that holds the game's main .exe. For Unreal Engine games that is <Project>/Binaries/Win64.
2. In Steam, force GE-Proton 11 for the game, and set these launch options:

   PROTON_FORCE_NVAPI=1 DXVK_NVAPI_GPU_ARCH=AD100 %command%
   

3. Select DLSS in the game. The first start compiles DLSS's GPU kernels, which takes about a minute and a half; later starts use the cache in ~/.cache/d4r.

D4R_README.txt in the zip has the details, and sh d4r/d4r-check.sh checks an install.

Requirements

• AMD Radeon RX 7000 series. The fast kernels are built for gfx1101 (RX 7700 XT, RX 7800 XT). Other RDNA3 cards run DLSS without them, which is much slower.
• The ROCm HIP runtime 7.x (libamdhip64.so.7), from your distribution. ROCm 7.2 was tested.
• GE-Proton 11 (tested: GE-Proton11-3).

What is in the zip

• d4r: the NGX shim, the Wine CUDA bridge, and hand-written RDNA3 kernels for the DLSS 4 (K) and DLSS 4.5 (M) network layers.
  • Each kernel is used only when the DLSS library's code for it matches the code it was written for. Swapping in another DLSS version therefore still works, only slower.
  • Linear 8-bit colour inputs and outputs can stay in VRAM when Vulkan supports the required blits, fixing the slow staging path seen in Ghost of Tsushima.
  • d4r/d4r.ini holds the settings for that game. The default model is DLSS 4 (K); E (DLSS 3 CNN) and M (DLSS 4.5) are one line away.
• NVIDIA: DLSS 310.7.0 (nvngx_dlss.dll), the NGX runtime from driver 596.36 (_nvngx.dll), and five DLSS kernels built from NVIDIA's code with parts replaced by d4r's.
• ZLUDA with d4r's patches: CUDA on ROCm.
• vkd3d-proton with d4r's patch, so every frame shows its own DLSS result (no added latency).
• OptiScaler 0.9.4, unmodified, set up to hand the game's DLSS calls to d4r.

Nothing in the Proton prefix or the system is changed. Uninstalling means deleting the extracted files.

Performance

Radeon RX 7700 XT, SILENT HILL Townfall at 2560×1440, average fps over the same 62-second walk:

Mode	DLSS 3 CNN (E)	DLSS 4 (K)	DLSS 4.5 (M)	FSR 4
Quality	72	69	51	76
Balanced	80	76	59	84
Performance	88	82	69	94
Ultra Performance	89	93	90	107

Native 2560×1440 without upscaling (the game's TSR at 100%) runs at 49 fps, so DLSS 4 at Quality is 40% faster than native.

The Townfall figures were measured before the 8-bit VRAM conversion update, using the same native kernels. Ghost of Tsushima was checked in a live run with the updated shim; its VRAM path stayed on and gameplay performance improved, but no matched benchmark was recorded.

Known limitations

• Only DLSS Super Resolution in DirectX 12 games. No Frame Generation or Ray Reconstruction.
• Tested with two games. Do not use it in games with anti-cheat.
• DLSS 4.5 (M) is much slower than FSR 4 on RDNA3.

Licenses

d4r is Apache 2.0. The zip also contains ZLUDA (Apache 2.0 or MIT), vkd3d-proton (LGPL 2.1, patched; the patch is in d4r/source) and OptiScaler 0.9.4 (GPL 3.0, unmodified; source at https://github.com/optiscaler/OptiScaler/tree/v0.9.4). d4r/source/SOURCES.txt lists where every file comes from.

NVIDIA's files in the zip, and the kernels built from NVIDIA's code, belong to NVIDIA and are not covered by any of these licenses. d4r is not affiliated with NVIDIA, AMD or the OptiScaler project.

SHA-256 d4r-0.1.0.zip: 487f8c98c0c5617449dddd5f573bfd4b7333c8c2f5a87198d485256673cabdba