d4r/docs/windows-local-package.md

Local gfx1101 drop-in package

Current local development package: v14 (2026-10-17)

build/d4r-windows-gfx1101-local-v14.zip, 133,240,107 bytes, SHA256 2f88dec3b4086371efefa8fbfa316c3f7b86fb7858ca1c1bdee63146056f7edf. Every manifest hash and the exact ZIP entry set verify. It adds strict DS lane exchange in all eleven K objects and FSR-only RGBA32F output with temporal format switching. The original FSR denoiser payload is unchanged; compiler/subgroup/rounding trials produced no reliable gain. v13 and older packages remain preserved.

Actual fresh extraction, architecture loader and player INI: K control/candidate/candidate/control passes 64 exact frames per size. Warmed CPU interop medians are 3.900 -> 3.3915 ms at 1080p and 5.4015 -> 4.820 ms at 1440p, about 13%/11% faster. These include CPU synchronization/copies/NGX and are separate from standalone HIP GPU timestamps (1.812/2.885 ms). The HIP runner/private model is not in the ZIP.

FSR-only test through the fresh loader passes 24 moving-camera frames with alternating float guides and half/float output, typeless D32S8 and preserved stencil. Every output component equals the same-frame composed half result, widened independently where needed. FSR+SR dynamic regression passes another 24 frames, retained resources and minimum-bound rejections. Native RR passes six exact camera/reset frames with contracts and enhanced/inherited states. Evidence: build/k-ds-local-v14-{1080,1440}-v1/, build/fsr-local-v14-format-switch-v1/, build/fsr-local-v14-dynamic-sr-v1/, build/rr-native-local-v14-regression-v1/.

All execution is synthetic on gfx1101. Full install.bat was not rerun, and no game, driver/security/GPU setting, commit, branch, PR or publication was involved. Linux targets, FSR denoiser speed, broader encodings/alpha/reference quality and the original remaining parity gaps are not declared complete. This ends the user's narrowed pass.

Preserved v13 package evidence

build/d4r-windows-gfx1101-local-v13.zip, 133,239,594 bytes, SHA256 b2ff1157e27b9353afcf287fa8df011c7efa119ac4e26ab7746166ff87b05b34. Every manifest hash verifies. This is v12 plus FSR/SR dynamic render-size support within the loaded SR library's queried bounds. Below-minimum sizes reject before command recording. The three fixed K objects remain included; the HIP standalone K engine/model is still outside the package. All older packages remain preserved.

Fresh-extracted architecture loader/INI passes 24 moving-camera dynamic FSR+SR frames, including both below-minimum axis rejections, retained input resources and all SR submissions (build/fsr-rr-local-v13-dynamic-bounds-v1/). Native RR regression passes six exact camera/reset frames with contracts and enhanced/inherited states (build/rr-native-local-v13-dynamic-regression-v1/). These are synthetic tests with separately staged dependencies.

Full install.bat was not rerun: the NGX core is absent from the download cache and would require the 945 MiB driver archive. No driver runs, game interaction, commit or publication occurred. See windows-fsr-rr.md and the newest checklist entry for exact synthetic coverage and remaining limits. Real-game/reference-quality and Linux performance parity remain unverified.

Preserved v8 package evidence

build/d4r-windows-gfx1101-local-v8.zip is 130,975,742 bytes; SHA256 962530d1a914268cc6f9d2ec908185f8e4d9e5baafca6800d77ebc3281a647fe. It adds GPU RGBA32F RR output conversion and temporal RGBA16F/RGBA32F output switching to v7 coverage. Packaged loader/INI E passes 12 exact evaluations across two live features, inverted D32S8 and unchanged stencil. Float32 results match widened standalone half output; this is synthetic engine consistency, not NVIDIA reference quality or game/timing parity.

Installer still installs pinned SR, RR DLL and NGX core through bundled Python, with optional D/E model generation/deployment. No NVIDIA DLL, private K override or generated model is bundled. Every ZIP manifest hash verifies. Evidence: build/d4r-windows-gfx1101-local-v8.validation.json and build/rr-ngx-local-v8-output-switch-e-v1/summary.json. Other output encodings, external exposure, FSR execution, K timing parity and original engine gaps remain.

Preserved v7 package evidence

build/d4r-windows-gfx1101-local-v7.zip is 130,973,094 bytes; SHA256 b7c68e6f6148c648b6e8e6f47362e0d5f0f6c6796d651d1e762a80d8f07e8d54. It retains the v6 native Python installer/clean portable tools and adds native RR dynamic render-size handling. NVIDIA SR/RR/core DLLs still download locally; no NVIDIA binary, private K override or RR model is bundled. All final manifest hashes verify. Older ZIPs are preserved.

Native RR supports per-frame render dimensions from 64 pixels through creation size, with fixed output size and implicit history reset on dimension changes. Model weights/pipelines and the shared packet/fence remain loaded. Packaged loader/INI E tests pass 16 exact evaluations across two live features and changing sizes, both with resized input textures and retained creation-sized textures. Six static D depth/format-switch frames also pass. These are synthetic engine consistency checks, not NVIDIA reference quality, real-game RR or timing parity. See windows-rr-interop.md for coverage and limitations. Evidence: build/d4r-windows-gfx1101-local-v7.validation.json and build/rr-ngx-local-v7-dynamic-two-e-v1/, build/rr-ngx-local-v7-max-dynamic-two-e-v1/, and build/rr-ngx-local-v7-static-regression-v2/.

Preserved v6 package evidence

build/d4r-windows-gfx1101-local-v6.zip is 130,970,436 bytes; SHA256 a144185823af334483543d4989584d65cfa0418049e56fb8e58410b91ae8700b. It adds the pristine portable-tools v2 inputs and native Python dependency installer to the verified runtime. Every ZIP manifest hash verifies. No NVIDIA DLL, private K override or generated RR model is bundled. All earlier ZIPs, including intermediate v5, remain preserved. V5 lacks the final README update; use v6 for the documented installer flow.

Extract beside the game executable and run install.bat. The batch wrapper uses bundled isolated Python, without PowerShell, system Python or Git Bash. It installs pinned SR 310.9.1 at d4r/dlss/nvngx_dlss.dll, RR 310.9.1 at d4r/rr/nvngx_dlssd.dll, and 617.14 core at d4r/ngx/_nvngx.dll. Driver archive is only extracted, never executed. The Python installer retains the exact existing PowerShell installer URLs and SHA256 pins. Hash identity excludes old 596.36 core fixtures.

Choose N to retain existing RR settings. Optional D/E selection builds and enables a private exact gfx1101 model. Tool inputs copy by manifest into the external cache; generated products remain there and in a versioned private runtime model directory. Existing models remain intact. Configuration selection preserves comments/BOM/newlines and creates an exact external INI backup. Model failure leaves verified DLLs installed and does not select an incomplete model. Automatic RR building currently requires a gfx1101-only package.

DLL replacement first stages and verifies all changes and external original backups. Replacement failure rolls back applied entries; concurrent edits are preserved. Reruns skip matching DLLs and reuse only verified model products. install.bat --yes --offline --cache-root PATH --backup-root PATH supports preverified DLL caches. Add --rr-preset D or E and --enable-rr for model generation/selection without the interactive prompts. Cache and backups must stay outside the game directory.

Validation uses ignored mock game folders only:

• Eight CPU tests cover preservation, rollback including newly created files, concurrent edits, cache rejection, pin parity and manifest-only tool copying.
• Actual v5 batch wrapper builds/deploys D in 48 steps, verifies 66 model products, exact DLL/INI backups, unrelated-file preservation and an unchanged repeat. E also completes its actual 48-step installer path.
• Actual v6 ZIP interactive default installs all three pinned DLLs while declining model generation leaves INI unchanged. E cache reuse/deployment, repeat safety and tampered-tool rejection with unchanged runtime hashes pass.
• Native downloader fetches verified official 7-Zip, reuses the hash-verified 617.14 driver archive and extracts a core matching its exact pin. No driver runs.
• Installer-deployed E selected solely through INI passes six exact synthetic NGX hardware-depth frames through the packaged architecture loader, with optional guides, enhanced/inherited access and stencil preservation. This is engine consistency, not NVIDIA quality reference or real-game RR evidence.

Evidence: build/native-installer-v1/validation.json, build/native-installer-v2/validation.json, build/native-installer-download-v1/validation.json, build/rr-ngx-native-installer-e-v1/summary.json, and build/d4r-windows-gfx1101-local-v6.validation.json. The final v6 fixture also passes the same six exact E frames: build/rr-ngx-local-v6-installer-e-v1/summary.json. Modified PowerShell release packager passed static parser validation; its fixture suite was not rerun under the recorded script policy. No policy bypass, game access, commit, publication or system setting change occurred. FSR execution, broad game/quality validation, K timing parity and remaining original engine requirements remain open.

Preserved v4 package evidence

build/d4r-windows-gfx1101-local-v4.zip is 90,720,715 bytes; SHA256 74fbb4c78dba3e616b9bbba7dc1fe4cddf0a17855968b174f8ea69968d873dfc. It refreshes the verified v3 package with the current native-RR shim, player INI, README, checker and installer sources. Every manifest file hash verifies against the final ZIP. Exact local modified-build provenance and base ZIP hash are recorded; no clean source commit is asserted. Existing ZIPs remain unchanged.

The package contains no NVIDIA binaries, private optimized kernels, or RR models. RR defaults off. A locally generated D/E model can be selected through [RayReconstruction] Backend = native and ModelDir in d4r.ini. Auto selects d4r/engine/rr-d; relative paths resolve beside d4r.ini. The installer does not generate that model yet, and FSR RR remains unavailable. This is a gfx1101-only development package with synthetic RR coverage, not verified game RR support.

The refreshed target shim passed six exact RR hardware-depth frames through the packaged architecture loader using player INI selection without launcher path overrides. The staged test supplied the pinned SR/core dependencies separately and used a separate local RR model. It covered capability/negative contracts, optional guides, enhanced/inherited state, inverted D32S8, unchanged stencil and Release-before-submit. Evidence: build/rr-ngx-local-v4-loader-v1/summary.json. ZIP verification: build/d4r-windows-gfx1101-local-v4.validation.json. The installer itself was not rerun for v4 under the current script policy; no policy bypass or system change was used. No game was touched or release published.

The refresh helper is tools/windows/refresh_local_package.py. It accepts only the pinned verified v3 base and fresh destinations under ignored build/, verifies every base/output manifest hash, and marks output as local modified provenance.

Preserved v3 package evidence

Local development ZIP: build/d4r-windows-gfx1101-local-v3.zip (92,158,725 bytes). This package targets gfx1101, including this machine's RX 7700 XT. It is not a multi-GPU public release, and it does not implement Windows game RR or FSR RR.

Extract its contents beside the game's main executable, then run install.bat and accept the dependency download prompt. Start the game normally afterward. The ZIP contains the shim, architecture loader, OptiScaler, native K/M objects, HIP/ZLUDA runtime, configuration, installer and licenses. NVIDIA binaries are excluded; the installer fetches pinned official SR/RR/core DLLs locally. It does not install the NVIDIA driver. See the ZIP's WINDOWS_README.txt for placement and existing-install handling.

Validation completed without touching a game:

• Every ZIP entry listed in the manifest matches its recorded SHA256.
• No NVIDIA SR, RR or core binary is bundled; d4r/_nvngx.dll is d4r's loader.
• Extracted the real ZIP into an ignored mock game folder and ran its installer with the verified local download cache. All three installed DLL hashes match the current pins. The installed checker passed on RX 7700 XT.
• The packaged architecture loader and target shim passed 32 synthetic K Quality frames at 1280x720 to 1920x1080. Outputs were finite, nonuniform and identical between control/batched-input runs. This is synthetic execution, not a game or image-quality claim.
• V3 adds NativeDir configuration for locally generated complete native directories. The exact new target shim passed eight additional synthetic player-mode frames through the architecture loader at 256x144 to 512x288. Its log confirms selection of the generated private K output override. Checker fixtures pass 20/20; release package fixtures pass 6/6.

The input package is explicitly marked as a local modified build. Its clean binary source commit is not asserted; exact file hashes are authoritative. The dependency commits are inherited from the earlier package's provenance. No source commit or public upload was created.

Evidence: build/windows-drop-in-v3-validation.json and build/player-private-native-output/validation.json. Earlier package validation remains in build/windows-drop-in-validation.json.

ZIP SHA256: e93be288f4013616cc2229be0132b40395d5031d8733bfa63886ba75ce1389ca.

Optional private K output optimization

Generate a complete private directory in this source workspace:

./scripts/windows/prepare-k-native-cache.ps1 `
  -DlssDll build/got-k-test/isolated-sr/sr/nvngx_dlss.dll `
  -NativeDirectory build/got-k-test/work/package-gfx1101-current/d4r/native `
  -OutputDirectory build/my-private-k-cache

This uses the locally built emitter and TheRock compiler. It verifies the input target and pinned DLL, builds the selected output variant, combines the baseline K/M objects, regenerates the native manifest and records hashes. It never edits a game or configuration. Select the complete native subfolder with [Paths] NativeDirin the new shim'sd4r.iniafter validation. Relative paths resolve besided4r.ini; auto` uses packaged kernels. Missing or wrong-target private objects are rejected. The default variant currently optimized is LDR, regular depth and high-resolution motion vectors; other variants retain the normal path.

The workflow output under build/k-native-cache-workflow/native is byte-identical to the previously validated 17-object candidate. The new player-mode smoke loaded that directory. These NVIDIA-derived objects stay local and are absent from V3.

Local v9: experimental FSR RR payload (2026-10-17)

build/d4r-windows-gfx1101-local-v9.zip, 133,200,126 bytes, SHA256 332719443a9b050e6a5b479816a81fb4d3e482a8956e2c20f2596904f7f6152d. Built by tools/windows/refresh_local_package.py from the verified v8 ZIP (--fsr-payload build/fsr-payload-v1); all manifest hashes verified; v2-v8 preserved.

Added over v8: the shim with the FSR RR backend and its Super Sampling stage (d4r/_nvngx_gfx1101.dll); d4r/fsr/d4r_vkd3d_core.dll (vkd3d-proton built by tools/windows/build_fsr_payload.py, LGPL-2.1, source offer and patches in d4r/fsr/SOURCE.txt and d4r/fsr/patches/) and d4r/fsr/amdxc64.dll (d4r's capability shim, not AMD software); vkd3d-proton, dxil-spirv and dxbc-spirv licence texts in d4r/licenses/; install.bat with an [F]SR choice and install-dependencies.py --enable-fsr / --install-fsr (AMD's denoiser, SHA256 48f1e588..., is downloaded hash-verified, backed up and rolled back like the NVIDIA DLLs, and Backend = fsr is written to d4r.ini with an external backup); d4r.ini key [RayReconstruction] FsrDenoiser; README text.

Still not bundled: NVIDIA DLLs, any RR/K model, AMD's denoiser. FSR RR is off by default.

Verification (synthetic only, no game): ZIP extracted fresh and test_fsr_rr_ngx.py run against the extracted files (build/fsr-rr-ngx-upscale-v9-v1: PASS, SR used, RMSE 0.289 vs 0.581 noisy input); release-package test PASS cases=7 including FSR payload accept/reject cases (build/release-package-fsr-v1); installer unit tests 12 OK; player-config test PASS cases=2; installer FSR path run for real on the extracted copy (AMD DLL downloaded, hash matched, installed, single Backend line changed, backup equals original, second run changes nothing). A full install.bat run was not repeated: the NGX core is not in the local download cache and would pull the 945 MiB driver archive. The new K work (HIP network, authentic K model) is NOT in v9.

Local v11: v9 plus FSR tuning, GPU timing and dynamic-size refusal (2026-10-17)

build/d4r-windows-gfx1101-local-v11.zip, 133,236,207 bytes, SHA256 ba91dd6cc178865244c9903a461f213cdcacf38bcf6905e919ba5e8ee652b228; built the same way as v9 (verified v8 base, --fsr-payload build/fsr-payload-v1), all hashes verified. v9 and an intermediate v10 are preserved but superseded. Differences from v9: d4r.ini keys FsrStabilityBias (default auto) and FsrDetail; the shim's GPU-timestamp log (D4R_FSR_RR_LOG), motion/depth dump diagnostic, tuning keys, exposure handled by the SR stage, and a clean refusal of render sizes below the creation size. Validated from a fresh extraction with test_fsr_rr_ngx.py: static same-size 0.127 (noisy 0.485), moving 640x360 -> 1280x720 0.2135 (noisy 0.554), moving same-size 0.1069 (noisy 0.486); all use SR. Synthetic only, no game. The HIP K network and authentic K model are NOT in this package.