github zgauthier2000/fsr4-shader-performance-overrides timing-kit-2026-10-05
FSR 4 timing kits up to 2026-10-12.2 - newer kits: timing-kit-2026-10-12.3

pre-releaseone month ago

Superseded: this is an older timing kit. The newest are Windows (2026-11-11) and Linux and Steam Deck (2026-11-11). The text below describes this release only.

Newer kits are here: timing-kit-2026-10-12.3 (Windows 2026-10-12.3, Linux 2026-10-12.2). The files below are the versions before them and are kept because earlier release notes link here.


Two kits, both updated on 2026-10-12. If you have an earlier archive, please download and run again. The Windows kit carries the DLLs of release dll-2026-10-11.5.

  • fsr4-timing-kit-windows.zip (EXPERIMENTAL, 190 MB, version 2026-10-12.2): for Windows. Unpack, close games and browsers, double-click fsr4time.exe, wait 15 to 20 minutes (an estimate; see below). It times the whole FSR 4.1.1 upscaler, as a game runs it, with AMD's shaders and with this project's exact and lossy DLLs at 1080p, 1440p and 4K output, and offers to send the summary. It should run on any graphics chip with DirectX 12 and Shader Model 6.6 (Radeon, GeForce, Intel Arc); not for RX 9000. The program is not signed, so Windows will warn about it. Source: timing-kit/windows/fsr4time.c in the repository.
    • 2026-10-12.2:
      • Two more DLLs show which part of the exact DLL saves time on your card: AMD's shaders with only the rewritten last shader (the postpass), and AMD's shaders with every other rewrite of the exact DLL. Under Proton on an RX 7800 XT at 4K the first takes 32% off AMD's time, the second 5%, the exact DLL with both 34% (one run of the kit). Both give AMD's picture there, byte for byte, in the project's test rig too (1080p and 4K moving, 1440p still).
      • Every DLL is timed twice, all in order and then all in reverse order. The summary gives the mean of the two, and both figures where they differ by more than 3%. fsr4time.exe --once times each once, as before.
      • Any FSR 4 DLL can be put into a new folder under dlls, not only 4.1.1, and a DLL that offers several FSR 4 versions is timed with each. (Tested only by listing 4.1.1's one version twice.)
      • The run is longer for all this. The kit before took about seven minutes with seven DLLs timed once; this one makes 18 runs, so 15 to 20 minutes is an estimate, not a measurement under Windows. Under Proton here the whole run takes two minutes.
    • 2026-10-12.1: the summary gives a fingerprint of the moving scene's picture as well as the still one, so one run shows whether two DLLs give the same picture in motion too. To compare another FSR 4.1.1 DLL (the community's 4.1.1b file, for one), make a new folder for it under dlls and put its amd_fidelityfx_upscaler_dx12.dll there.
    • Archive replaced later on 2026-10-12, same version: only its README.txt changed (it now says where to put the 4.1.1b file, and its status line is up to date). The program and the DLLs are the same files as before.
    • 2026-10-11.6: its lossy DLLs are those of release dll-2026-10-11.5 (no shimmer in bright flat areas with auto exposure on).
    • 2026-10-11.5: its lossy DLLs were those of release dll-2026-10-11.4 (steadier and more accurate at rest).
    • Since 2026-10-11.3: when you send your result, the kit asks whether you would like to be named on the project's thank-you page. Optional; a name is sent only if you type one.
    • 2026-10-11.2: its lossy DLLs are those of release dll-2026-10-11.2 (the wire and particle changes of dll-2026-10-11, plus the test fix for a ghost behind still objects over fast-moving ground).
    • Since 2026-10-10.1: the summary prints a fingerprint of each DLL's still picture and names the first DLL that gave the same one. Two more reference DLLs are included for RX 6000 cards, where AMD's own shaders show ghosting under Windows: AMD's shaders with only the last shader's dot products split, and AMD's shaders with all three changes of the community's 4.1.1b fix (rebuilt by this project from AMD's shaders; not that project's file). Reports from three RX 6000 cards have confirmed that the exact DLLs give exactly the fixed picture there.
  • fsr4-timing-kit.tar.gz (version 2026-10-12.1): for Linux and the Steam Deck.
    • 2026-10-12.1: a shorter run. Three tests whose question is settled are gone: the two forms of the dot product on RX 6000 (no card showed a difference), the earlier postpass candidates and the eight old postpass versions. On an RX 7800 XT the full run now takes 16 minutes, bash run.sh quick 10 minutes and bash run.sh postpass half a minute (one run each).
    • The summary says how the card is connected: the PCIe link speed and width of the card and of the ports above it, and the size of its first memory window. On two cards so far (RX 6600, RX 6600M) the kit's readings were unusable because writes to memory took far too long; this is there to find out why.
    • A busy GPU: the load is now read from the card that is tested (it was averaged over all GPUs), and when that card stays busy the script asks you to close what is using it, or to type go to run anyway.
    • Since 2026-10-11.3 it asks the same optional question about the thank-you page.
    • The lossy shaders are those of release dll-2026-10-11.4, which are the same in dll-2026-10-11.5 (that release changed only the lossy prepass, which this kit does not time): the skipped-frame probes, and the one model pass that build still changes slightly (pass 10), timed and listed in the summary.
    • Since 2026-10-10.1 the output check of the model passes means something. Earlier kits filled the small buffer that holds each pass's output scales and offsets with random bytes, which drove nearly every output to its limits, so a pass with different arithmetic was still reported as identical. The kit carries that buffer as FSR 4 fills it (128 KB, from AMD's DLL like the shaders). The prepass and postpass checks were not affected.
    • From 2026-10-09.1: the 12 model passes also timed in sequence, a whole-frame figure, an estimate for the lossy build's skipped frames, a warning when a run looks unlike what games do, and one optional question about what a game showed.

Instructions for both: https://github.com/zgauthier2000/fsr4-shader-performance-overrides/tree/main/timing-kit


The description of the Linux kit as first published, with its version history:

A folder you download and run on Linux (or a Steam Deck in desktop mode). It times each of FSR 4.1.1's shader passes on your GPU with AMD's shaders, this repository's rewrites and the lossy test versions, and writes the readings to a results folder. No game, OptiScaler or DLL is involved.

Updated to version 2026-10-06.3. If you have an earlier archive, download again.

  • New in 2026-10-06.3: bash run.sh on its own now runs the full set (about 20 minutes on an RX 7800 XT): every pass at 1080p, 1440p and 4K, the postpass comparison with its candidates, the pass 11 and postpass versions, the store probes and compiler statistics. The two-minute postpass test is now bash run.sh postpass; bash run.sh quick (about 12 minutes) and bash run.sh traffic (the full set plus the memory-traffic capture) remain.

  • Since 2026-10-06.2: three new postpass candidates (AMD's postpass, the shipped rewrite and a leaner rewrite, each with branch-free neighbourhood reads) replace the two earlier ones, which the first RX 6000 results showed do not help. All three give AMD's output byte for byte. RX 6000 owners on Linux: bash run.sh times them in about two minutes. The summary now names any candidate whose output differs from AMD's.

  • Since 2026-10-06.1: a test for RX 6000-series (RDNA2) GPUs. On RDNA2, Mesa compiles nearly all of FSR 4's int8 dot products as the two-operand v_dot4c_i32_i8; a community member reports the three-operand v_dot4_i32_i8 is faster there. The default run now times model passes 1 and 12 and the postpass both ways with the bundled driver build. RX 6000 owners on Linux: bash run.sh (about two minutes on a desktop card) answers it.

  • Since 2026-10-05.9: a second candidate postpass (the first one with leaner flush code) is timed alongside the first. The postpass test still takes about a minute.

  • From 2026-10-05.8 to 2026-10-06.2, bash run.sh on its own ran only the short postpass test; that is now bash run.sh postpass.

  • Since 2026-10-05.7: a candidate postpass for the smaller GPUs (RX 6000, Steam Machine, Steam Deck, integrated GPUs). It needs fewer registers, so it should run more threads at once there than the shipped one; its output is byte-for-byte AMD's. bash run.sh times it against AMD's and the shipped version at 1080p, 1440p and 4K in about a minute. Owners of those GPUs: this is the run that helps most right now.

  • Since 2026-10-05.6: a closer look at the postpass, the pass where GPUs differ most. At 1080p, 1440p and 4K it times AMD's postpass several times, the shipped rewrite, and AMD's with its stores removed (the floor a rewrite can reach). This is what bash run.sh runs when given no option.

  • Steadier postpass readings: warm-up runs are not counted, and the script checks whether something else is using the GPU before it starts.

  • The memory-traffic step (bash run.sh traffic) now works on any CPU.

  • Since 2026-10-05.5: the summary flags unsteady postpass readings. AMD's postpass does not always give a steady time at 4K, most of all when something else is using the GPU, so close games, browsers and video before a run.

  • Since 2026-10-05.4: times 1440p output as well as 1080p and 4K (quick now takes about 12 minutes on an RX 7800 XT).

  • Since 2026-10-05.3: fixes CPU ISA level is lower than required: the earlier archives only started on CPUs with AVX-512 (Ryzen 7000 and newer). The programs now run on any 64-bit CPU.

  • On a machine with two GPUs the discrete one is tested and the summary names the GPU used; KIT_GPU=integrated bash run.sh quick tests the integrated one.

  • Since 2026-10-05.2: the prepass and postpass of the 1080p and 4K sets run on real inputs (in the first archive their times were wrong), and results can be sent at the end.

New and lightly tested: it has run on five machines (RX 7800 XT, Steam Machine, RX 6700M, RX 6800 XT, RX 6600); see the results so far. It has not yet run on an integrated GPU or a Steam Deck.

Use

  1. Download fsr4-timing-kit.tar.gz and unpack it.
  2. In a terminal in that folder: bash run.sh (about 20 minutes on an RX 7800 XT; longer on slower GPUs. bash run.sh postpass is a two-minute version).
  3. At the end it shows a short summary and asks whether to send it to the project's Discord results channel (no account needed; only that summary is sent, and answering N sends nothing). It also prints a link for sending the same summary as a GitHub issue.

Nothing is installed or changed on the machine and no root access is needed. On a Windows machine, boot a live Linux USB stick first.

Full instructions, what it measures and how to read the output: timing-kit/README.md.

Notes

  • Needs Linux with an AMD GPU on the Mesa (RADV) driver.
  • The times are per pass on made-up inputs. They rank shader versions reliably but are not game times.
  • The archive contains AMD's FSR 4.1.1 shaders as vkd3d-proton translates them, modified versions of them, and a build of Mesa's RADV driver; see NOTICE.txt inside. Not affiliated with or endorsed by AMD.

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

NewReleases is sending notifications on new releases.