0.0.6

Release notes (since 0.0.4.3)

New: the 310.9.16 small model, and a rebase onto upstream 0.0.6-linux-preview

The 310.9.16 nvngx_dlssnr.dll holds a second, smaller network (31 blocks and 76 layers instead of 71 and 152) and uses it by default. This build runs it on RDNA3 by adopting upstream's own small-model support, which works here without shader changes.

• The installer makes dlssnr-small.bin from the 310.9.16 DLL, installs both models and sets [Network] Model in dlssnr-amd.ini (small by default, original for the 310.8.0 model; applied after a game restart). --new-model and --old-model choose at install.
• There is no int4 mixed for the small model; int4 stays on the 310.8.0 model.
• It matches NVIDIA's own output of the 310.9.16 DLL: 49.36 / 49.45 / 50.58 dB at 1080p / 1440p / 4K, against 49.15 / 49.40 / 50.59 dB on RDNA4. Our earlier standalone lighter-network build scored 45.67 dB at 1080p because it padded 1080 to 1088; upstream pads to 1152, as the DLL does.
• The small model's history blend weight (0x3A23) is now its own, not the 310.8.0 model's.
• One plain layer with a folded downsample or upsample now runs as a persistent kernel, which the small model needs. It is about 10% faster than our earlier lighter build.

Also from upstream (0.0.5 and 0.0.6-linux-preview):

• the RenoDX style option and the NR Control menu
• faster ReShade routes (one-pass build, motion vectors read in place at full resolution)
• history restart fixes
• an optional per-frame noise seed (NoiseEveryFrame)
• reshade routes renamed reshade-feeder, reshade-feeder-vulkan and reshade-feeder-dx9

Performance (RX 7900 XTX, network time per frame, one pass)

PSNR is against NVIDIA's own output of the same model. There is no NVIDIA output at 720p, so that column is time only.

	720p	1080p	1440p	4K
310.8.0 model	9.10 ms (110 fps)	15.76 ms (63 fps)	25.95 ms (39 fps)	55.93 ms (18 fps)
PSNR	–	45.47 dB	47.71 dB	49.02 dB
310.8.0 + int4 mixed	8.11 ms (123 fps)	14.15 ms (71 fps)	23.65 ms (42 fps)	51.10 ms (20 fps)
PSNR	–	41.92 dB	43.36 dB	43.62 dB
vs 310.8.0 model	−11 %	−10 %	−9 %	−9 %
Small model (new default)	5.33 ms (188 fps)	9.62 ms (104 fps)	15.31 ms (65 fps)	32.33 ms (31 fps)
PSNR	–	49.36 dB	49.45 dB	50.58 dB
vs 310.8.0 model	−41 %	−39 %	−41 %	−42 %

fps is 1000 divided by the network time. The game's own frame cost is on top. The small model is both the fastest and the closest to NVIDIA; int4 mixed trades 3.5–5.4 dB for 9–11 % less time.

Today's figures are about 6% higher than the ones quoted in earlier notes (1080p was 14.8 ms for the 310.8.0 model). I timed the 0.0.4.3 code against this build on the same model in the same session, and they match within noise (15.4–15.6 ms against 15.6 ms), so this is the machine's state today, not a regression. Compare rows from the same table, not across releases.

Fixes

• Upstream's stand-alone nr_graph.cpp didn't compile: main used vit_first/vit_last without declaring them. It is fixed here, and the layer-hash checks that use that tool work again.
• The test scripts read the verification frames from docs/ngx-verification/310.8.0 after upstream moved them.

For developers

• linux/test/check_rdna3_small.py checks the small model, like the existing checks do for the others. check_rdna3.py and check_rdna3_int4.py still pass EXACT.
• bash fetch_deps.sh now also fetches Slang 2026.19 and the OptiScaler-NR source (both pinned by checksum), which the RenoDX shader build needs.

Upgrading

Re-run install.sh, with --dll pointing at the 310.9.16 nvngx_dlssnr.dll if you want the small model. Use --old-model to keep the 310.8.0 model; int4 mixed needs it. Your dlssnr-amd.ini settings are kept.

0.0.4.3

Two bug fixes, no changes to the network or its picture.

Fixed: ReShade route crashed the game right after the network build started (seen in Steep)
With ReShade as dxgi.dll over DXVK, ReShade loads the add-on for the game's first probe device, unloads it, and loads it again at another address. The add-on's Vulkan device watch was installed in the first copy. Something else hooked one of its detours, and later wrote its saved bytes back at that address, which then lay inside the second copy's code. A later call into that code jumped to an unmapped address, so the game crashed.

The watch is now installed only when ReShade runs as the Vulkan layer (ReShade64.dll or ReShade32.dll). The DXVK route takes its Vulkan handles from DXVK and never used the watch. The Vulkan-layer route is unchanged.

Fixed: "Skip the network on every Nth frame" switched itself off (issue #1)
Temporal reuse was tied to the first NGX feature that used it and was never released. OptiScaler rebuilds its feature when a setting changes, so after any tweak the new feature never got reuse. The network then ran on every frame, fps dropped and the rendering-time bar stopped flickering.

Reuse is now released with its feature, and the next feature takes over. The first frame after the change runs the network, and skipping resumes from the next one.

Upgrading

• Re-run install.sh over your existing install. Settings in dlssnr-amd.ini are kept, including ReuseEvery.

int4 mixed on RDNA3

New: int4 mixed (optional)

The main project's second network, now on RDNA3: the heavy matrices of the ViT, of the C=512 attention and of the
C=256 and C=128 Swin runs are computed in int4, and the Swin MLP uses a hard-swish folded into the next weights.
It is faster and its picture is not the default network's. The installer asks (--int4 or --no-int4; Enter is
no); without it you get the default network, unchanged and bit-identical to the previous build.

RX 7900 XTX, network time per frame and score against NVIDIA's own output:

	1080p	1440p	4K
Default network	14.8 ms, 45.47 dB	25.2 ms, 47.71 dB	56.1 ms, 49.02 dB
int4 mixed	13.3 ms, 41.92 dB	22.8 ms, 43.36 dB	50.8 ms, 43.62 dB

7 to 10 % less time for 3.5 to 5.4 dB less. At 50 % model resolution at 4K: 13.7 ms instead of 15.0.

How it works here: RDNA3 has an int4 matrix instruction that runs at twice the rate of the int8 and FP16 ones
(249 against 131 to 134 TOPS), but only for 16 values at a time and reading half of an int8 operand. Vulkan has no
int4 matrix type, so the shaders multiply int8 fragments that hold two nibbles each, twice, and the host rewrites
the multiplies in the pipeline binary (VK_KHR_pipeline_binary). The tables are calibrated on the FP8 network,
whose values this build reproduces, so the weights the installer makes from your model are the same ones as on
RDNA4 (same SHA-256, checked at install).

• The installer prints two extra Steam launch options for the Vulkan layer that int4 mixed needs
  (VK_ADD_LAYER_PATH, VK_INSTANCE_LAYERS); copy the whole line. Without the layer the game keeps the default
  network and the log says why.
• Ctrl+F11 in game switches between the two networks; settings are [Int4Mixed] in dlssnr-amd.ini.
• The first start takes longer: the rewritten pipelines are built and cached in dlssnr-amd/int4.
• int4 mixed needs the persistent kernels (as on RDNA4) and VK_KHR_pipeline_binary on the game's device.

0.0.4.1: faster reduced model resolution, OptiScaler-NR 0.8.91

Based on upstream 0.0.4

Faster below 100 % model resolution

The frame is now kept in its own format and read and written in place, instead of being
converted to RGBA32F and back. The picture is identical to the previous release, bit for
bit, at 75, 50 and 25 %. Network and route time per frame at 4K (RX 7900 XTX):

Model resolution	0.0.3.3	Now	Saved	% Saved
75 %	33.2 ms	32.1 ms	1.1 ms	3.3 %
50 %	16.1 ms	14.8 ms	1.3 ms	8.1 %
37.5 %	10.8 ms	9.8 ms	1.0 ms	9.3 %
25 %	7.6 ms	6.4 ms	1.2 ms	15.8 %

At 100 % model resolution nothing changes:

	720p	1080p	1440p	4K
0.0.3.3	8.3 ms	14.6 ms	25.0 ms	55.8 ms
Now	8.3 ms	14.6 ms	24.8 ms	55.4 ms

Other changes from upstream

• OptiScaler-NR 0.8.91 (was 0.8.4). The installer sets [DlssNr] WhitePointSource=1.
• The network's pipelines are compiled without robust buffer and image access. Games
  running through DXVK or vkd3d-proton create their device with robustBufferAccess2;
  upstream measured about 4 % on its card. Not measured on RDNA3 here.
• ReShade routes: a Transfer setting chooses how a result below 100 % is enlarged
  (matched residual, edge-aware lighting and colour, or classic with bilinear, catmullrom,
  lanczos3 or AMD FSR 1). The default's output is unchanged.
• The installer writes dlssnr-amd.ini on every route, with [Preprocess], [Log] and
  [Reuse].
• Fixes for 32-bit games (staging capped at 16 MB, host-memory failures retried),
  scRGB highlights, and a network being freed too early on the OptiScaler route.

Still off by default

Skipping the network on every Nth frame (0.0.3.3) stays off: [Reuse] Every = 0.

Install

bash install.sh "<folder with the game's exe>" <route> --dll <nvngx_dlssnr.dll or zip>.
The installer rewrites OptiScaler's files and settings; back up your OptiScaler.ini and
any replaced DLLs first.

Choosing a route

• optiscaler: games with a DLSS, FSR or XeSS option.
• reshade: D3D10/11/12 games without one.
• vulkan: Vulkan and D3D9 games.

0.0.3.3

New: skip the network on every Nth frame

The network's edit is small and low-frequency, so it survives being carried across frames by motion vectors.
With temporal reuse on, the network runs on every Nth frame only. A frame in between is built from its own
input plus the stored edit, moved where the accumulated motion says each pixel went. Off by default.

• ReShade route: ReuseEvery and ReuseGate on the add-on's page, or a [Reuse] section with Every and Gate.
• OptiScaler route: the [Reuse] section of dlssnr-amd.ini (Every = 2). Changing it from 0 to 2 or more the
  first time rebuilds the network once.
• Works from the game's motion vectors, or from the runtime's own motion estimator when the game gives none.
• A frame is never skipped when the recent motion times the frames to carry exceeds the gate (default 40 px of a
  1080p-wide frame); a motion that jumps fades the edit out instead of showing a wrong one. A reset always runs
  the network. The periodic log line reports frames that ran the network, frames that skipped it, the gate's
  trips, and the mean and peak motion, so the gate can be set from what a game does.

Measured offline on a captured 1080p sequence: a skipped frame costs 0.6 to 0.8 ms against
14.4 ms for a network frame, an average of 7.6 ms at N = 2 and 5.3 ms at N = 3. Skipped frames score 37 to 43 dB
against running the network every frame at about 17 px of motion a frame. From the motion estimator alone they
score 38.8 and 40.4 dB (32.9 and 35.8 dB in a faster window).

Faster

Network time per frame, one pass, 100 % model resolution (RX 7900 XTX):

	720p	1080p	1440p	4K
Now	8.3 ms	14.6 ms	25.0 ms	55.8 ms
0.0.3-31	8.7 ms	15.2 ms	26.5 ms	57.7 ms

About 3 to 6 % less time: the e4m3 rounding constant no longer carries the sign of the value, register operands are
built with every k pair swapped, and the ViT FFN expand runs on eight waves with no register spill. The picture is
bit-identical to the previous builds. Score against NVIDIA's single-frame outputs: 45.47 dB at 1080p, 47.71 dB at
1440p, 49.02 dB at 4K.

Install

bash install.sh "<folder with the game's exe>" <route> --dll <nvngx_dlssnr.dll or zip>.

Choosing a route

• optiscaler: games with a DLSS, FSR or XeSS option.
• reshade: D3D10/11/12 games without one (Call to Arms: Ostfront).
• vulkan: Vulkan and D3D9 games.

0.0.3-34-g2c4f404

Network time per frame (RX 7900 XTX, 100 % model resolution)	Before	Now
720p	8.7 ms	8.5 ms
1080p	15.2 ms	14.8 ms
1440p	26.5 ms	25.9 ms
4K	57.7 ms	56.5 ms

About 2 % faster at every resolution. The picture is bit-identical, and the score against NVIDIA is unchanged.

0.0.3-31-g238c3a3

The OptiScaler route works on RDNA3. Games that offer DLSS, FSR or XeSS and go through OptiScaler
showed a green tint with a flickering bottom edge, froze the GPU a second after NR was enabled, or ran NR
with no visible change. The cause was in how the in-place path read the game's images: it bound the wrong
buffers on RDNA3, so the network read and wrote its data in the wrong format and overwrote its own
counters. All three symptoms were that one bug. It is fixed, and a regression test now covers it.
Checked in Mount & Blade II: Bannerlord (no green tint, no freeze; NR before the upscaler takes 16.3 ms at a
1080p render resolution, about 40 fps with FSR 4.1.1 Performance at 4K output).

Better quality at lower model resolution. A network run below the frame's size makes an edit that is
too strong. It is now scaled by a fitted gain. Score against NVIDIA's full-resolution output at 4K:

Model resolution	Before	Now
75 %	38.4 dB	39.4 dB
50 %	32.9 dB	35.3 dB
37.5 %	30.9 dB	33.8 dB
25 %	29.2 dB	32.7 dB

No change in speed, and nothing changes at 100 %.

Speed (RX 7900 XTX, network only)

	1080p	1440p	4K
100 % model resolution	16 ms	27 ms	58 ms

Native 4K at 100 % is about 15 fps whatever the game is. NR before the upscaler (OptiScaler's "Generate model before upscale") makes its cost follow the render resolution.

Initial RDNA3 Linux release

These are the network times, from initial port to what it is now on a 7900xtx:

Frame	First working version	Now	Saved	Speedup
720p		9.2 ms
1080p	30 ms	16.2 ms	46%	1.9×
1440p	54 ms	27.3 ms	49%	2.0×
4K	116 ms	58.4 ms	50%	2.0×

Still too slow to play on 4k, but you might be able to do 1080p or lower resolution scales.

Only tested with ReShade, using it with opsticaler will likely cause crashes. You can try NR_TCHAIN=0 env in the launch options in case of a hang/crash.