[madebyjordan]

AMD FSR 4.1 as a second upscaler engine, on the frame chain #841 merged for DLSS, next to the FSR 3.1 that #1386 merged. FSR 4 is AMD's machine-learned upscaler and runs AMD's own DLLs; FSR 3.1 is built from AMD's shaders. They are separate options on the same row.

What changed

• Shared frame chain. NVIDIA DLSS, DLAA and Reflex (NGX + Vulkan, Linux and Windows, opt-in) #841's inputs (scene camera and depth, colour, camera + actor motion, in-game camera jitter) aren't DLSS-specific, so they move out of vk_dlss.cpp into vk_temporal.cpp behind a small engine interface. vk_dlss.cpp keeps NGX, the feature and its evaluation, and does the same thing as before perf(vk): DLSS keeps its feature through loading screens (a 44-78 ms stutter at each area entry) #1520's keeping DLSS loaded through loading screens moved with it, so FSR 4 gets it too.
• FSR 4 engine. vk_fsr4.cpp runs FSR 4.x through AMD's FSR API on those same inputs, taking the newest FSR 4 AMD's library offers (never an older FSR in its place). Only AMD's MIT headers are vendored (third_party/fidelityfx); AMD's signed DLLs are the player's.
• Menu. Upscaler row: Game's own, NVIDIA DLSS, NVIDIA DLAA, AMD FSR 3.1 (unchanged, still 3), AMD FSR 4 (4), AMD FSR 4 Native AA (5). It uses AMD FSR 3.1 upscaling and frame generation (split from #1335) #1386's mask of what runs here, so it steps over what can't run. FSR 4 uses the same Render resolution modes. The saved key stays dlss.
• Next to FSR 3.1. RX_VK_FSR stays FSR 3.1's switch; FSR 4's is RX_VK_FSR4. Only one upscaler draws at a time: the shared chain stands aside while FSR 3.1 upscales. FSR 3.1 keeps its own inputs (vk_fsr3_inputs.cpp) and its frame generation works with any upscaler, as merged.
• Opt-in build, like DLSS. make_game.py --fsr / HOOKSHOT_FSR=1 / a Builder tick. Default builds are unchanged.
• Fix for GPUs without cooperative matrices. The 67/58/50/33% Render resolution networks don't translate there (RDNA 2), so their upscale fell back to a linear stretch that no upscaler ever saw. That fallback now offers the frame to the shared chain first.
• CI. The DLSS link-check job also builds FSR 4 and runs when the shared chain changes. The Linux AppImage job builds the back end once more with FSR 4, so its Linux side is compiled too.

Tested

• RX 6700 XT, Windows, FSR 4.1.2 (INT8): it runs at 75%, 67%, 58%, 50% and 33%, and at Native AA; 600 of 600 frames in each status line, the jitter moving, no history resets in play. No blurring or ghosting seen in play.
• Cost on RDNA 2: about 5–7 ms of GPU time per frame (13.7 → 18–21 ms), the same at every Render resolution, because FSR works at the output size. Native AA (no upscale) costs about the same.
• After merging with AMD FSR 3.1 upscaling and frame generation (split from #1335) #1386 (rebased on main at caaee0b): the renderer builds with and without FSR 4, no warnings; tests/run_all.py: 230 pass, and the same 19 fail on plain main here (local tools: Windows symlinks, clang, spirv-val). Not played again since: the play test above was before AMD FSR 3.1 upscaling and frame generation (split from #1335) #1386.
• Not tested here: the DLSS half in play (no RTX card; CI's DLSS job compiles it, and @hckrman101 checked the move against NVIDIA DLSS, DLAA and Reflex (NGX + Vulkan, Linux and Windows, opt-in) #841), Linux in play (CI compiles it), and FSR 3.1 with this PR in play.

Related

• Credits. The shared frame chain is @hckrman101's DLSS work from NVIDIA DLSS, DLAA and Reflex (NGX + Vulkan, Linux and Windows, opt-in) #841, moved, not rewritten (co-author). FSR 4 on Linux is @N3oTraX's (co-author). The readme's credits list both.
• AMD FSR 3.1 upscaling and frame generation (split from #1335) #1386 (FSR 3.1). Its inputs file was written to move onto this chain; that, and giving FSR 3.1 the fixed-share fallback above, are follow-ups.

🤖 Generated with Claude Code

[madebyjordan]

Thanks for the careful read, and for checking the move against your originals. All three are addressed in the new commit:

• Exit: lib() and st() in vk_fsr4.cpp, and the chain's st() in vk_temporal.cpp (its deferred frees can hold an FSR context), are now leaked statics, so nothing of FSR's is destroyed at exit. DLSS's state is unchanged.
• Linux in CI: the Linux AppImage job builds hookshot_vk.so once more with HOOKSHOT_FSR=1, in a copy of its work folder, so the #ifndef _WIN32 parts of vk_fsr4.cpp and the descriptor-buffer feature in vk_main.cpp are compiled. The AppImage itself is unchanged.
• Input size: FSR's inputs now grow to the largest render size its context has had, capped at the output, so a fixed 33% keeps 33%-sized images.

A second pass turned up a few small things, fixed in the same commit:

• RX_VK_DLSS=3 and up mean DLAA again, as main's clamp had it. The split had made them DLSS.
• When AMD's loader is present but fails to load, the log now gives Windows' error instead of saying the file is missing.
• make_game.py --fsr with the AppImage's prebuilt back end now says that back end has no FSR.

Also rebased on current main, which had started conflicting. That includes your #1364: the scene-size rule (scene_size_fits, the output noted from the upscale) moved into vk_temporal.cpp as temporal_scene_size, so FSR gets it too, and the Linux NGX path handling and the DLSS_RUNTIME_NOT_ASCII reason stay in vk_dlss.cpp as you wrote them. test_dlss_checks.py now reads the chain for the size rule. On the other FSR PRs: agreed. FSR 3.1 would fit as a third engine on the TemporalEngine interface, and which FSR 4 path to take is NotRexed's call.

[FrozenGuy7]

I own a 9070 XT and 'd be happy to help testing the FP8/ML FSR 4.1 implementation, just let me know how 🤝

[madebyjordan]

Thanks @FrozenGuy7, a 9070 XT is exactly what this needs: so far it has only run on RDNA 2 (the INT8 model). These steps are for Windows; if you're on Linux, say so and I'll post those.

You need: Hookshot built once with the normal Builder (this reuses its tools, so there's nothing else to install), Git for Windows, your game's .nup, and about 60 GB free.

1. Get AMD's FSR files. From the FidelityFX SDK 2.4 release, take amd_fidelityfx_loader_vk.dll and amd_fidelityfx_upscaler_vk.dll from Kits\FidelityFX\signedbin. Hookshot doesn't include them.

2. Build this PR. Open PowerShell, change the first two lines, then paste the whole block. It builds into a new folder, so your normal install isn't touched, and it takes about as long as a Builder build.

$Nup = "C:\path\to\your-game.nup"     # your game file
$Out = "C:\Games\Hookshot-FSR4"       # a new folder for this test build

$Tools = "$env:LOCALAPPDATA\HookshotBuilder\versions\$((Get-Content "$env:LOCALAPPDATA\HookshotBuilder\versions\current.txt").Trim())\HookshotBuilder\tools"
$Src = "$env:USERPROFILE\hookshot-pr1008"
git clone -c core.longpaths=true --depth 1 -b amd/fsr4 https://github.com/madebyjordan/hookshot-amd.git $Src
Get-ChildItem "$Tools\third_party" -Recurse -File -Include *.dll,*.exe,*.lib,*.sha1 | ForEach-Object {
  $dest = Join-Path "$Src\third_party" $_.FullName.Substring("$Tools\third_party".Length + 1)
  New-Item -ItemType Directory -Force (Split-Path $dest) | Out-Null
  Copy-Item $_.FullName $dest -Force }
Copy-Item "$Tools\work" "$Src\work" -Recurse -Force
$env:RX_CPM = "$Tools\cpm"; $env:WGPU_NATIVE = "$Tools\wgpu-native"; $env:HOOKSHOT_MINGW = "$Tools\llvm-mingw"; $env:EMSDK = "$Tools\emsdk"
Set-Location $Src
& "$Tools\python\python.exe" -I nx2/make_game.py --nup $Nup --out $Out --language en-US --fsr

If you have romfs and exefs folders instead of a .nup, replace --nup $Nup with --romfs "C:\path\romfs" --exefs "C:\path\exefs".

3. Add AMD's files. Copy the two DLLs from step 1 into the new game folder (C:\Games\Hookshot-FSR4).

4. Start it. Run hookshot.exe in that folder. If it offers an update, skip it: that would replace this test build with the release. The first start prepares the shaders, which takes a while. To keep playing your saves, copy the user folder from your normal install into the new folder first.

5. Turn FSR 4 on. In game, press F1, then go to Graphics → Upscaler → AMD FSR 4. Under Render resolution, try Quality, Balanced, Performance and Ultra Performance. Then try AMD FSR 4 Native AA. Gameplay → FPS counter shows your FPS so you can compare with Game's own.

What would help most:

• The vk: AMD FSR 4: lines from hookshot_log.txt in the game folder. They say which FSR 4 AMD's library chose for your card (the FP8 model on RDNA 4 is what we want to confirm). If FSR 4 isn't offered in the menu, these lines say why.
• FPS with Game's own vs FSR 4 at each Render resolution, standing in the same spot.
• Anything that looks wrong, such as shimmering, ghosting, flicker, or trails behind moving characters (some trailing is a known limit for now). Screenshots or a short clip help.
• If it crashes, hookshot_log.txt.

Thanks again!

[FrozenGuy7]

@madebyjordan It works perfectly, I played for a few minutes using FSR4 and was able to play at ~120 FPS for a few minutes but I'm not able to share much right now because I'm busy with work now, sorry about that.

[hookshot_log.txt](https://github.com/user-attachments/files/34643502/hookshot_log.txt)