github zgauthier2000/fsr4-shader-performance-overrides dll-2026-10-05.4
Patched FSR 4.1.1 upscaler DLL (2026-10-05, release 4) - superseded by dll-2026-10-06 (same main files; lossy builds gained frame skip)

one month ago

This is an old release (2026-10-05.4), superseded since. The current DLLs are on the latest release page, which always points to the newest one. The text below describes this old release only.

A ready-made copy of AMD's FSR 4.1.1 upscaler DLL (amd_fidelityfx_upscaler_dx12.dll, version 4.1.1.2740) with the faster shaders from this repository built in: the phased postpass and the model pass 11 rewrite, for every output size and preset. Replace the DLL and FSR 4 uses them, with no launch option, add-on or override folder.

New in this release (2026-10-05, fourth release of the day): new names

Only the name each DLL shows in OptiScaler has changed. The GPU tag now comes before "cyboman", so it stays readable in OptiScaler's closed dropdown and in screenshots:

File Shows as In release 3
amd_fidelityfx_upscaler_dx12.dll 4.1.1-r3-cyboman 4.1.1-cyboman-r3
test-rdna2.zip 4.1.1-r2-cyboman 4.1.1-cyboman-r2
test-rdna2-compact.zip 4.1.1-r2c-cyboman 4.1.1-cyboman-r2c
test-igpu.zip 4.1.1-ig-cyboman 4.1.1-cyboman-ig
test-lossy.zip 4.1.1-r3-lossy-cyboman 4.1.1-cyboman-lossy
test-lossy-rdna2.zip 4.1.1-r2-lossy-cyboman 4.1.1-cyboman-r2-lossy
test-lossy-rdna2-compact.zip 4.1.1-r2c-lossy-cyboman 4.1.1-cyboman-r2c-lossy
test-lossy-igpu.zip 4.1.1-ig-lossy-cyboman 4.1.1-cyboman-ig-lossy

The shaders are the same as in release 3. Checked again under Proton on an RX 7800 XT at 4K and 1080p output: the four exact builds give AMD's image byte for byte, and the four lossy builds give the same output as release 3's lossy DLL. test-lossy-linux.zip is unchanged (it uses AMD's own DLL, so OptiScaler shows plain 4.1.1). If you send screenshots, please use these builds so the build can be read from the picture.

Added later on 2026-10-05: test-rdna2-hybrid.zip (RDNA2 test build)

Shows in OptiScaler as 4.1.1-r2h-cyboman. It is test-rdna2.zip with one change: at 1080p output and below it keeps AMD's own postpass (with the dot-product split that fixes the shimmering), and uses this project's rewritten postpass only at 1440p output and above. Everything else is the same, and the image is AMD's byte for byte (checked at six sizes from 720p to 4K under Proton on an RX 7800 XT).

Why: the first timing-kit result from an RDNA2 card (RX 6700M, Linux) shows the rewritten postpass 35% faster than AMD's at 4K but 15% slower at 1080p. The slow stores it removes only appear at large sizes; at small sizes its extra register use is all that is left.

Who should try it: RX 6000 owners who play at 1080p output. Compare it with test-rdna2.zip at the same spot and report the upscaler time of each. At 1440p and 4K the two builds are the same, because FSR 4 uses one set of shader versions for 1440p and 4K, so a DLL cannot treat them differently.

Not known yet: whether the same holds on Windows, where AMD's driver compiles the shaders (the measurement is from Linux). That is what this build is for.

From release 3 (2026-10-05): the prepass rewrite

  • The prepass is rewritten too. The prepass prepares the model's input in blocks of four pixels. In AMD's shader the four threads of a block each compute partial sums, exchange them 32 times, and then one of them rounds and stores everything while three wait. Now each thread fetches the other three pixels' inputs once and computes a quarter of the result on its own, with the same arithmetic in the same order. Under Proton on an RX 7800 XT the prepass goes from 0.50 ms to 0.45 ms at 4K, about 1.7% of FSR 4's whole time.

  • All 90 versions of the prepass are covered (it varies with a game's depth, motion-vector and colour options). The DLLs now replace 183 shaders: 48 postpass, 90 prepass, 6 pass 11 and 39 other model-pass versions.

  • Still byte for byte AMD's image: the main DLL was checked in 24 combinations (four size and model combinations, six option sets that select different prepass versions), the other four DLLs in three each, under Proton on an RX 7800 XT.

  • All builds are rebuilt with it. Names and purposes are unchanged:

    File Name shown in OptiScaler For
    amd_fidelityfx_upscaler_dx12.dll 4.1.1-r3-cyboman desktop RDNA3 (RX 7000)
    test-igpu.zip 4.1.1-ig-cyboman RDNA3 integrated GPUs (experimental)
    test-rdna2.zip 4.1.1-r2-cyboman RDNA2 (RX 6000)
    test-rdna2-compact.zip 4.1.1-r2c-cyboman RDNA2 and Steam Deck (test build)
    test-lossy.zip, test-lossy-linux.zip 4.1.1-r3-lossy-cyboman desktop RDNA3, opt-in, changes the image (see below)
    test-lossy-rdna2.zip, test-lossy-rdna2-compact.zip, test-lossy-igpu.zip 4.1.1-r2-lossy-cyboman, -r2c-lossy, -ig-lossy other GPUs, opt-in, change the image (see below)

    OptiScaler's closed dropdown shows the start of the name, which now includes the GPU tag; the open dropdown shows all of it.

  • All of them have AMD's GPU check lifted. Do not use any of them on RX 9000 (RDNA4) cards: those run a different FSR 4 model (FP8), and with the check lifted both models report support.

  • The prepass rewrite has only run on an RX 7800 XT. It uses the same kind of instructions as AMD's prepass (it only uses fewer of them), but if FSR 4 looks wrong with this release on your card and right with dll-2026-10-05.2, please report it.

  • If you are comparing test builds, compare builds from this release with each other.

Opt-in test build that changes the image (added later on 2026-10-05)

⚠️ WARNING: EVERY test-lossy… FILE CHANGES THE IMAGE

They are NOT the same as the main DLL of this release, and NOT the same as AMD's DLL. The main DLL, the other test builds and the Linux prebuilt folder all produce AMD's image byte for byte. The test-lossy files do not: they give a different, slightly less accurate picture in exchange for speed. Download them only if you want to try that trade. If you want AMD's image, use the main DLL.

  • What it is: the main DLL (and, for Linux, an override folder) with part of the arithmetic removed from nine of FSR 4's model passes. For desktop RX 7000 cards. OptiScaler shows the DLL as 4.1.1-r3-lossy-cyboman.
  • What it gains: in Shadow of the Tomb Raider's benchmark at 4K Balanced on an RX 7800 XT, the upscaler time is 2.91 ms against 3.05 ms with the exact files (and 4.16 ms with AMD's), 111 against 109 FPS. No difference was visible in that run.
  • What it costs: in test scenes it is 0.3 to 0.7 dB less accurate at every output size (4K, 1440p, 1080p), and fine repeating patterns (grilles, fences, fabric) are 17 to 31% less steady in motion at 1440p output. Ultra Performance is left almost untouched.
  • Install: the DLL like the main one. The Linux folder with AMD's original DLL and VKD3D_SHADER_OVERRIDE='Z:/path/to/fsr4-lossy-overrides' %command%. Both give the same output as each other.
  • Useful report: upscaler time with the main files and with this build at the same spot, and whether you see a difference, most of all at 1440p output.

Lossy builds for other GPUs (same warning: they change the image):

File Shows as It is
test-lossy-rdna2.zip 4.1.1-r2-lossy-cyboman test-rdna2.zip (RX 6000) with the lossy model passes
test-lossy-rdna2-compact.zip 4.1.1-r2c-lossy-cyboman test-rdna2-compact.zip (RDNA2 and Steam Deck) with the lossy model passes
test-lossy-igpu.zip 4.1.1-ig-lossy-cyboman test-igpu.zip (RDNA3 integrated GPUs) with the lossy model passes

On an RX 7800 XT their output is byte-identical to test-lossy.zip's. None has been run on the hardware it is for, and the lossy settings were tuned on an RX 7800 XT only, so neither the gain nor the visible cost is known there. Please compare each with the exact build for your GPU and report the upscaler time of both and what you see.

Measurements and tools: research/lossy.

test-rdna2-taps.zip has been removed: testers saw no improvement from it on RDNA2. test-rdna2.zip remains the build for RX 6000 cards.

Install

  1. In the game folder, find amd_fidelityfx_upscaler_dx12.dll (often next to OptiScaler) and check that it is version 4.1.1.2740. Its SHA-256 is d0dcccc74a43c44ba435b7a369b456e0970d8a4464e4bd683119b374f2c9fb46. This DLL replaces that version only.
  2. Rename the original to amd_fidelityfx_upscaler_dx12.dll.orig and keep it.
  3. Put the DLL from this release in its place.
  4. Compare OptiScaler's upscaler time with the original and the patched DLL. In some games that number is only reliable with the frame rate uncapped.

To undo it, put the original back.

Experimental build for RDNA2 (RX 6000)

test-rdna2.zip is for RDNA2 cards on Windows. It differs from the normal DLL in two ways:

  • AMD's GPU check is lifted (AMD's DLL offers this version of FSR 4 only on desktop RDNA3).
  • The postpass's int8 dot products are written as a plain dot product followed by an add, instead of adding onto a running total inside the instruction. The fsr4xyz project found that the postpass ghosts on RDNA2 without this. The result is the same number, so the image is unchanged; this is an independent implementation of that idea, with no code from that project.

It also has this repository's postpass and pass 11 rewrites, in all 54 shader versions. Under Proton on an RX 7800 XT its output is byte-for-byte identical to AMD's DLL in all 48 combinations. Tested on RDNA2 since: it fixes the shimmering in motion. A different idea, keeping the postpass's history weight at 0.8 or more, looked bad in motion and is not included; see research/history-clamp. Its speed there has not been measured. If you try it, the useful comparison is with the fsr4xyz DLL: is the image right (no ghosting), and what is OptiScaler's upscaler time with each (frame rate uncapped, same spot)? Please report both, with your GPU, driver version, game, output resolution and FSR mode. The main DLL does not have the dot-product change and would be expected to shimmer on RDNA2.

Test build: RDNA2 with a smaller pass 11

test-rdna2-compact.zip is test-rdna2.zip with one change: model pass 11 is the compact version from the integrated-GPU build, which keeps AMD's loops and only stores each row of its output together. Compiled for an RX 6000 card or the Steam Deck it is 4.7 KB of code, against 21.4 KB for the unrolled version in test-rdna2.zip (AMD's: 4.4 KB). On an RX 7800 XT the two are almost equally fast (0.24 ms against 0.22 to 0.23 ms; AMD's 0.60 ms).

  • Steam Deck: its chip is RDNA2 and integrated. On RDNA3 integrated GPUs the unrolled pass 11 was what made FSR 4 slower, so the compact one may suit the Deck better. Please try both RDNA2 builds.
  • Desktop RDNA2: first report, RX 6750 XT at 1440p: 2.14 ms against 2.10 ms with test-rdna2.zip, so the compact build is slightly slower there and test-rdna2.zip stays the one to use on RX 6000 cards.

Its output is byte-for-byte identical to AMD's DLL at four output sizes (4K, 1440p, 1080p, 1280x720) under Proton on an RX 7800 XT. It has not been run on RDNA2 or a Steam Deck. Report OptiScaler's upscaler time with each build (frame rate uncapped, same spot), with your GPU, driver, game, output resolution and FSR mode. If it is equal or better on desktop RDNA2, it will replace test-rdna2.zip.

Experimental build for integrated GPUs

On RDNA3 integrated GPUs the normal DLL is reported slower than AMD's, and a tester traced that to the pass 11 rewrite. This build carries a different pass 11, made for integrated GPUs: it keeps AMD's loops, so the pass stays small (6.5 KB of code as compiled for a Radeon 780M, against 6.1 KB for AMD's and 31 KB for the normal rewrite), and only stores each row of its output together, which cuts the memory the pass reads to about a quarter. The postpass rewrite is included as well (reported to make no difference on an integrated GPU).

It is test-igpu.zip. AMD's DLL does not offer this version of FSR 4 on integrated GPUs, so the GPU check is lifted in it.

It gives output byte-for-byte identical to AMD's DLL in the seven test configurations under Proton. One report so far (Radeon 780M, Cyberpunk 2077, 1080p Balanced): 5.04 ms against 5.15 ms with fsr4xyz's 4.1.1b. More reports are welcome. Please compare OptiScaler's upscaler time (frame rate uncapped, same spot) with AMD's original DLL and with this build, and report both numbers with your GPU, Windows or Linux and driver version, game, output resolution and FSR mode. It is built with PASS11=rows (see windows/dxil/build_dxil_overrides.sh); on Linux the same pass 11 comes from PASS11=rows ./build_override.sh <dump>.

The GPU check

AMD's DLL only offers the INT8 version of FSR 4 on desktop RDNA3 (chip family 0x91); it refuses RDNA2 (RX 6000), RDNA3 integrated GPUs (Radeon 780M, 890M) and other vendors. All DLLs in this release make that check always answer yes. The INT8 shaders are plain Direct3D 12 (Shader Model 6.6) and need no RDNA3-only feature, but whether FSR 4 then runs correctly, and how fast, depends on the GPU and its driver: RDNA2 needs the test-rdna2.zip build, and integrated GPUs are untested. Not for RDNA4. See RDNA2 and other GPUs.

What was measured

  • Correctness: AMD's DLL and this one, run under Proton in a small FSR 4 test program at seven output sizes and ratios (4K, 1440p and 1080p output), give byte-identical images; this was repeated for this release. See dll/README.md.
  • Speed: on a Radeon RX 7800 XT under Proton, the postpass takes 0.67 ms at 4K with these shaders, against 2.1 ms for AMD's. In Shadow of the Tomb Raider's benchmark at 4K, the same shaders (as the Linux launch option) brought the upscaler time from 4.16 ms to 3.12 ms and the frame rate from 97 to 108 FPS. See results/phased-postpass.

Things to know

  • Windows: testers with Radeon RX 7000 graphics cards report large improvements with the first version of these rewrites, nearly as large as on Linux, and the phased version (what this DLL contains) has been run on Windows with an RX 7800 XT with about the same result. Measure before and after on your setup.
  • Integrated GPUs (Radeon 780M and similar): a tester found the pass 11 rewrite makes FSR 4 much slower there and the postpass rewrite no faster, so don't use this DLL there. See Integrated GPUs.
  • On Linux with RDNA2, use the DLL. The prebuilt launch-option files do not fit every setup (one RX 6900 XT tester gets a darker image with them and a correct one with files built from their own dump), and on that card the two routes are equally fast.
  • On Linux, the launch option is slightly faster (postpass 0.60 ms against 0.67 ms at 4K), because vkd3d-proton translates the DLL's DXIL into slightly slower code. See the quick start.
  • AMD's digital signature has been removed, because it cannot survive the change. Neither the DLL nor AMD's FidelityFX loader checks it.
  • Game and OptiScaler updates may put the original DLL back.
  • Online games: this is modified code; use your own judgement in games with anti-cheat.

How it was made

python3 dll/patch_upscaler_dll.py --any-gpu --name 4.1.1-r3-cyboman amd_fidelityfx_upscaler_dx12.dll out.dll at commit 4c09524 (the shaders; the names are from this release). Running it on AMD's original produces exactly this file. The others are made the same way with their own names and replacement shaders, built by windows/dxil/build_dxil_overrides.sh with PASS11=rows (integrated GPUs), DOT4=split (RDNA2), both (the compact RDNA2 build). The lossy DLL is built from the set made by research/lossy/build_lossy_dxil.sh (commit f8c2942). Checksums of all files, including the DLLs inside the zips, are in SHA256SUMS.

Licence

This is AMD's DLL with modified shaders. AMD's FidelityFX SDK licence lists the DLL under MIT terms; the shader modifications come from scripts adapted from bbport and are distributed under the GNU GPL v2 or later. NOTICE.md (attached) carries AMD's notice and the details. Not affiliated with or endorsed by AMD.

Don't miss a new fsr4-shader-performance-overrides release

NewReleases is sending notifications on new releases.