This is an old release (2026-10-06.6), 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-06, release 6): the lossy test builds are steadier and sharper in motion, and slightly faster
⚠️ This applies to the
test-lossy…files only, and they CHANGE THE IMAGEThe main DLL and the other test builds are unchanged and still give AMD's image byte for byte.
The lossy builds run FSR 4's model on every other frame and reuse its last result on the frames in between. Up to release 5 that result stayed where the picture was a frame ago, so thin things shimmered while the camera moved. Three changes, all on skipped frames:
- The reused result follows the picture's motion, to the pixel. The prepass stores the motion and nearest depth of each 4x4 block of output pixels; the postpass takes the model's result for each pixel from where that pixel's content was.
- Pixels a moving object has just uncovered take the new frame alone.
- The network's last layers, which sit in the postpass, are no longer rerun. The frame that runs the model saves their result and the skipped frame reads it back. That pays for the two changes above and a little more.
| Moving test scene, 4K Balanced | AMD's shaders | Release 5 | This release |
|---|---|---|---|
| Background against the true image | 49.27 dB | 47.68 dB | 48.60 dB |
| Thin railing against the true image | 41.82 dB | 39.84 dB | 40.73 dB |
| Areas a moving object has just uncovered | 34.48 dB | 32.04 dB | 33.96 dB |
| Fine stripes on a moving block, frame-to-frame change (lower is steadier) | 2.04 | 1.66 | 0.95 |
| Thin railing, frame-to-frame change against AMD's, as if at 30 / 60 / 90 / 120 FPS | 1 | 2.32 / 1.55 / 1.73 / 1.64 times | 1.16 / 1.04 / 0.99 / 1.14 times |
- Speed: Shadow of the Tomb Raider benchmark, 4K Balanced, RX 7800 XT, Linux files, one run each: 2.06 ms upscaler time and 18893 frames, against 2.11 ms and 18850 for release 5; 122 FPS both (AMD's shaders: 97 FPS, 4.16 ms; main files: 109 FPS, 3.05 ms).
- One figure is worse: in the first test scene release 5 happened to hold the railing steadier than AMD's (0.66 against 0.91); this release is back near AMD's (1.02).
- Nothing changes at rest: still scenes are byte-identical to release 5 at five output and render sizes, including Ultra Performance. Fine detail still shimmers about 8% more than with AMD's shaders.
- New dependence: on skipped frames the result now depends on the game's motion vectors. Where they are wrong or missing it can be taken from the wrong place. The test rig's motion vectors are exact, so this is not measured.
- The Windows DLLs give the same output as the Linux folder, byte for byte, in the test rig: the moving scene at two speeds and still scenes in 20 combinations. They were run under Proton only, and their speed on Windows has not been measured. They are about 6 MB larger than before.
- Tested by the author in one game on one RDNA3 card (Linux), and in the test rig. The RDNA2, compact and integrated-GPU builds have not been run on their hardware with this change.
- The names shown in OptiScaler are unchanged, so say which release you used.
- Details:
research/frame-skipand the overview exact and lossy builds compared.
From release dll-2026-10-06.5: the lossy test builds shimmer much less, at the same speed
⚠️ This applies to the
test-lossy…files only, and they CHANGE THE IMAGEThe main DLL and the other test builds are unchanged and still give AMD's image byte for byte.
The lossy builds run FSR 4's model on every other frame. Up to release 4, a skipped frame mixed the new frame in with a weight the model had chosen one frame earlier; that weight sits where the picture used to be, so fine detail shimmered, and straight lines shimmered while the camera moved.
New: a skipped frame now leans on the previous picture moved along with the scene (the reprojected history), limited to the colours of the new frame around each pixel. The new frame's weight is squared on those frames: where the model keeps history, a typical 7% becomes about 0.5%; where the model had asked for the new frame, it still gets it.
| Test scene, 4K Balanced | AMD's shaders | Release 4 | Release 5 |
|---|---|---|---|
| Flicker at rest on fine detail (lower is steadier) | 0.110 | 0.146 (+33%) | 0.119 (+8%) |
| Fine stripes in motion, frame-to-frame change | 2.04 | 2.16 | 1.66 |
| Background in motion, frame-to-frame change | 0.079 | 0.079 | 0.065 |
| Still picture against the true image | 44.31 dB | 43.98 dB | 43.74 dB |
| Areas a moving object has just uncovered | 34.48 dB | 33.13 dB | 32.04 dB |
- Speed is unchanged: Shadow of the Tomb Raider benchmark, 4K Balanced, RX 7800 XT (Linux): 122 FPS and 2.11 ms upscaler time, against 122 FPS and 2.09 ms for release 4 (AMD's shaders: 97 FPS, 4.16 ms; main files: 109 FPS, 3.05 ms).
- What it costs: the still picture is about 0.2 dB softer than in release 4, and just-uncovered areas lose about 1 dB.
- What it does not fix: thin free-standing things moving against a different background (a railing in the test scene) flicker as before, about 1.6 times AMD's at 60 FPS.
- Ultra Performance, where frame skip is off, gives exactly the same output as release 4. The Windows DLLs give the same output as the Linux folder, byte for byte, in the 20 combinations compared under Proton. All 48 postpass versions carry the change.
- Tested by the author in one game on one RDNA3 card, and in the test rig. The RDNA2, compact and integrated-GPU builds have not been run on their hardware with this change.
- The names shown in OptiScaler are unchanged, so say which release you used.
- Details, including an attempt to follow the picture's motion that was measured and not shipped:
research/frame-skip. Overview: exact and lossy builds compared.
From release dll-2026-10-06.4: the lossy test builds smear much less behind moving objects
⚠️ This applies to the
test-lossy…files only, and they CHANGE THE IMAGEThe main DLL and the other test builds still give AMD's image byte for byte.
The lossy builds run FSR 4's model on every other frame. Where a moving object has just uncovered something, a skipped frame reused a model result that still said "keep the history", and the history there was out of date. New: on skipped frames the history is limited to the colour range of the new frame's samples around each pixel, so an outdated value is pulled to a plausible colour before it is mixed in.
| Moving test scene, 4K Balanced: just-uncovered areas against AMD's shaders | Release 3 | This release |
|---|---|---|
| as if at 30 FPS | −12.4 dB | −4.9 dB |
| as if at 60 FPS | −5.7 dB | −0.9 dB |
| as if at 90 FPS | −6.5 dB | −4.3 dB |
| as if at 120 FPS | −2.8 dB | +1.0 dB |
- Thin structures improve too: 1.5 to 2.7 dB below AMD's, from 1.6 to 4.3.
- Nothing is lost at rest: flicker on fine detail and the still picture are the same as in release 3 at the four sizes compared. Fine detail still shimmers about 30% more than with AMD's shaders.
- Speed is unchanged. The shimmer correction, the new clamp and the edge guard now sit in one branch that only skipped frames take; on a frame that runs the model the postpass takes 0.681 ms at 4K against 0.678 ms in release 3 (RX 7800 XT, benchmark tool).
- Frame skip still suits high real frame rates best: at 30 FPS the gap to AMD's remains several dB.
- Ultra Performance output is identical to release 3. The Windows DLLs give the same output as the Linux folder, byte for byte, in the 20 combinations compared under Proton. All 48 postpass versions carry the change.
- Tested by the author in two games on one RDNA3 card (it "looks good"), and in the test rig. The moving-scene figures were measured on one of the two postpass families; the other builds and matches but was not measured. The RDNA2, compact and integrated-GPU builds have not been run on their hardware with this change.
- The names shown in OptiScaler are unchanged, so say which release you used.
- Details:
research/frame-skipand the new overview exact and lossy builds compared.
From release dll-2026-10-06.3: the lossy test builds no longer flash dark bands at the screen edge
⚠️ This applies to the
test-lossy…files only, and they CHANGE THE IMAGEThe main DLL and the other test builds still give AMD's image byte for byte. They never had this problem.
If you use a lossy build from release dll-2026-10-06 or dll-2026-10-06.2, update. A tester saw black bars flash at the edges of the screen while turning the camera (Final Fantasy VII Rebirth, RX 6900 XT). With frame skip, when the camera started to turn on a skipped frame, the strip that scrolled in at the edge was shown at about a tenth of its brightness for that one frame.
Cause: that strip has no history, and the skipped frame reused the model's decision from the frame before, when the camera was still: "mostly history". Fix: on a skipped frame, where the history is far darker than the new frame in every colour channel, the new frame is used alone.
| Test scene: camera starts to turn on a skipped frame | AMD's shaders | Releases dll-2026-10-06, .2
| This release |
|---|---|---|---|
| Brightness of the newly revealed strip against the true image | 100% | 10% | 100% |
- Same result in both directions and at 4K Balanced, 4K Quality, 1440p Quality and 1080p Quality.
- Nothing else changes: flicker at rest and the moving-scene figures are the same as in release 2, Ultra Performance output is identical, and speed is the same.
- The Windows DLLs give the same output as the Linux folder, byte for byte, in the 20 combinations compared under Proton.
- Verified in the test rig only, not yet in the game the report came from.
- The names shown in OptiScaler are unchanged, so say which release you used.
- Details:
research/frame-skip.
From release dll-2026-10-06.2: less shimmer in the lossy test builds
⚠️ This applies to the
test-lossy…files only, and they CHANGE THE IMAGEThe main DLL and the other test builds still give AMD's image byte for byte.
The lossy builds run FSR 4's model on every other frame (frame skip). A tester reported shimmer on distant objects with the previous release, and measurement confirmed it: on a completely still picture, fine detail changed about 55% more from frame to frame than with AMD's shaders.
The cause: on a skipped frame the reused model result was worked out for the previous frame's camera jitter, so it gives too much weight to the new frame in pixels whose nearest sample has moved away.
The correction in this release: the previous frame's jitter is now carried over to the skipped frame, and the postpass lowers the new frame's weight where the nearest sample is farther from the pixel than it was. Frames that run the model are not touched.
| Test scene, 4K Balanced (lossy build) | AMD's shaders | Release dll-2026-10-06
| This release |
|---|---|---|---|
| Frame-to-frame change at rest, fine detail (lower is steadier) | 0.110 | 0.172 (+56%) | 0.145 (+32%) |
| Still picture against the true image | 44.31 dB | 43.75 dB | 44.04 dB |
| Moving scene, background | 49.27 dB | 47.46 dB | 47.80 dB |
| Moving scene, areas just uncovered | 34.48 dB | 30.09 dB | 29.17 dB |
- The shimmer is reduced, not gone: about half of the extra flicker remains.
- It costs about 1 dB in areas that a moving object has just uncovered.
- Speed is unchanged: Shadow of the Tomb Raider benchmark, 4K Balanced, RX 7800 XT (Linux): 2.09 ms upscaler time and 122 FPS, as before (AMD's shaders: 4.16 ms, 97 FPS; main files: 3.05 ms, 109 FPS).
- Flicker falls by a similar share at 4K Quality and Performance, 1440p, 1080p and 5K output in the test scene.
- Ultra Performance, where frame skip is off, gives exactly the same output as the previous release.
- The Windows DLLs give the same output as the Linux folder, byte for byte, in the 20 combinations compared under Proton (4K, 1440p, 1080p and 5K output; all four DLLs).
- Tested in one game and in test scenes, on one GPU. The RDNA2, compact and integrated-GPU lossy builds have not been run on their hardware with this change.
- The names shown in OptiScaler are unchanged (
4.1.1-r3-lossy-cybomanand so on), so a screenshot cannot tell this release's lossy build from the previous one: say which release you used. - What was tried, how it works and the tools:
research/frame-skip.
From release dll-2026-10-06: the lossy test builds skip the model on every other frame
⚠️ This applies to the
test-lossy…files only, and they CHANGE THE IMAGEThe main DLL and the other test builds still give AMD's image byte for byte.
FSR 4's model (twelve passes) is about 60% of its time. The lossy builds now run it on every other frame and reuse its last result on the frames in between.
| Shadow of the Tomb Raider benchmark, 4K Balanced, RX 7800 XT (Linux) | Upscaler time | Average FPS |
|---|---|---|
| AMD's shaders | 4.16 ms | 97 |
| Main files (AMD's image) | 3.05 ms | 109 |
| Lossy test build, as in release 4 | 2.91 ms | 111 |
| Lossy test build, with frame skip | 2.09 ms | 122 |
What it costs, on top of the lossy set's own loss:
- In motion, places where the picture has just changed (the edge behind a moving object) are one frame behind: about 4 dB less accurate there in the test scene. At rest, fine detail shimmers more (see above).
- Frame times alternate: a skipped frame is about 1.7 ms shorter than a normal one on an RX 7800 XT. With a frame cap or normal V-Sync the average is what counts. With low-latency modes or unbuffered V-Sync the longer frames can miss.
Good to know:
- It turns itself off in Ultra Performance (render size under half the output size) and on frames the game marks as a reset.
- It picks frames from the game's camera jitter. With the usual jitter sequence frames alternate strictly; a game with an unusual one may skip unevenly.
- The Windows DLLs give the same output as the Linux folder, byte for byte, in the 20 combinations compared under Proton (4K, 1440p and 1080p output; four presets; all four DLLs).
- Tested in one game and in test scenes, on one GPU. The RDNA2, compact and integrated-GPU lossy builds have not been run on their hardware.
- The names shown in OptiScaler are unchanged (
4.1.1-r3-lossy-cybomanand so on), so a screenshot cannot tell this release's lossy build from the previous one: say which release you used.
How it works and all measurements: research/frame-skip.
From release 4 (2026-10-05): 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.dll4.1.1-r3-cybomandesktop RDNA3 (RX 7000) test-igpu.zip4.1.1-ig-cybomanRDNA3 integrated GPUs (experimental) test-rdna2.zip4.1.1-r2-cybomanRDNA2 (RX 6000) test-rdna2-compact.zip4.1.1-r2c-cybomanRDNA2 and Steam Deck (test build) test-lossy.zip,test-lossy-linux.zip4.1.1-r3-lossy-cybomandesktop RDNA3, opt-in, changes the image (see below) test-lossy-rdna2.zip,test-lossy-rdna2-compact.zip,test-lossy-igpu.zip4.1.1-r2-lossy-cyboman,-r2c-lossy,-ig-lossyother 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 IMAGEThey 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-lossyfiles 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: see the table at the top: 2.09 ms against 3.05 ms with the exact files and 4.16 ms with AMD's (the weight folding alone: 2.91 ms).
- 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
- 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 isd0dcccc74a43c44ba435b7a369b456e0970d8a4464e4bd683119b374f2c9fb46. This DLL replaces that version only. - Rename the original to
amd_fidelityfx_upscaler_dx12.dll.origand keep it. - Put the DLL from this release in its place.
- 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 andtest-rdna2.zipstays 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 release 4). 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 DLLs are built from the set made by research/lossy/build_lossy_dxil.sh with research/frame-skip/frameskip_dxil.py applied to every prepass and model-pass version, and research/frame-skip/skipblend_dxil.py applied to every postpass version before its store rewrite. 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.