gabrielmaialva33 · October 13, 2026 07:30 · xsetiadi · Oct 1, 2026 · DISOhda · Oct 2, 2026
diff --git a/README.md b/README.md
diff --git a/vkd3d-rtas-prebuild-x8.patch b/vkd3d-rtas-prebuild-x8.patch
 diff --git a/libs/vkd3d/device.c b/libs/vkd3d/device.c
 index 44685730..3b531c9d 100644
 --- a/libs/vkd3d/device.c
 +++ b/libs/vkd3d/device.c
 @@ -7946,6 +7946,25 @@ static void STDMETHODCALLTYPE d3d12_device_GetRaytracingAccelerationStructurePre
         info->UpdateScratchDataSizeInBytes = size_info.updateScratchSize;
     }
 
 +    /* LOCAL WORKAROUND (vkd3d-proton #3226): Witcher 3 RT hangs on NVIDIA 590+ unless the RTAS result and
 +     * scratch sizes reported to the application are inflated. x8 by default;
 +     * VKD3D_RTAS_SIZE_MULT=<n> overrides it at runtime (1 = stock behaviour). */
 +    {
 +        static uint32_t rtas_size_mult;
 +        uint32_t mult = vkd3d_atomic_uint32_load_explicit(&rtas_size_mult, vkd3d_memory_order_relaxed);
 +
 +        if (!mult)
 +        {
 +            mult = max(1u, vkd3d_env_var_as_uint("VKD3D_RTAS_SIZE_MULT", 8));
 +            vkd3d_atomic_uint32_store_explicit(&rtas_size_mult, mult, vkd3d_memory_order_relaxed);
 +            INFO("RTAS prebuild sizes are multiplied by %u (local workaround).\n", mult);
 +        }
 +
 +        info->ResultDataMaxSizeInBytes *= mult;
 +        info->ScratchDataSizeInBytes *= mult;
 +        info->UpdateScratchDataSizeInBytes *= mult;
 +    }
 +
     TRACE("ResultDataMaxSizeInBytes: %"PRIu64".\n", info->ResultDataMaxSizeInBytes);
     TRACE("ScratchDatSizeInBytes: %"PRIu64".\n", info->ScratchDataSizeInBytes);
     TRACE("UpdateScratchDataSizeInBytes: %"PRIu64".\n", info->UpdateScratchDataSizeInBytes);
diff --git a/w3_proton_patch.py b/w3_proton_patch.py
 #!/usr/bin/env python3
 """Re-enable DLSS / DLSS-G (and optionally ray tracing) in The Witcher 3 5.0 under Proton/Wine.

 The Witcher 3 5.0 ("Remastered", DX12) detects Wine through GetProcAddress(ntdll, "wine_get_version") and then
 deliberately skips NVIDIA Streamline (so DLSS SR/RR, DLSS Frame Generation and Reflex are unavailable) and forces
 ray tracing / path tracing off. This script flips those checks in bin/x64_dx12/witcher3.exe. It only accepts the
 exact builds listed in BUILDS below (5.0.0.1041720, the 5.00c hotfix 5.0.0.1044392 and patch 5.01,
 5.0.0.1048522), checked by sha256.

  python3 w3_proton_patch.py [path/to/witcher3.exe]          DLSS SR/RR, Reflex and DLSS-G
  python3 w3_proton_patch.py --rt [path/to/witcher3.exe]     also RT and path tracing (read the README first:
                                                             needs a vkd3d-proton with #3332, or the GPU hangs
                                                             within a minute on NVIDIA 590+)
  python3 w3_proton_patch.py --rt-only [path/to/witcher3.exe] AMD / Intel: RT, path tracing and FSR frame generation,
                                                             without the NVIDIA-only DLSS patches (RADV also needs
                                                             dxil-spirv PR #311 in vkd3d-proton; see the README)
  python3 w3_proton_patch.py --restore [path/to/witcher3.exe] undo every patch (Steam "Verify integrity" also does)
  add --dry-run to only report the current state.

 The DLSS patches are NVIDIA only. Unofficial; use at your own risk. Close the game before running it.
 """
 import argparse
 import hashlib
 import os
 import shutil
 import sys

 DEFAULT_PATH = os.path.expanduser(
    "~/.local/share/Steam/steamapps/common/The Witcher 3/bin/x64_dx12/witcher3.exe")

 # (file offset, original bytes, patched bytes, description). Per build: the same four checks, found in 1044392 by
 # matching the code around each 1041720 site with RIP-relative displacements wildcarded (each matches exactly once,
 # and the instructions around it are unchanged). In 1048522 (5.01) WF and AL matched the same way; SL and DG did
 # not, because a register and a stack frame changed around them, and were found through the wine_get_version
 # string references and the reads of the cached Wine flag, which map one to one between the builds.
 SL = "create the Streamline manager (slInit) under Wine: DLSS SR/RR, Reflex"
 DG = "do not force DLSS-G 'unsupported' on the Wine flag"
 WF = "clear the cached Wine flag: RT, path tracing, FSR FG"
 AL = "keep buffer alignment as under Wine (only needed on vkd3d-proton older than #3308)"
 BUILDS = {
    90832336: {
        "version": "5.0.0.1041720", "steam_build": "25575366",
        "sha256": "c272b2c2e61f84c758e28fab69ab2915944dd1e539dbb435fae9fc67494c7e25",
        "base": [(0x1B709CB, b"\x75\x42", b"\x90\x90", SL), (0x1B759A0, b"\x74", b"\xEB", DG)],
        "rt": [(0x1EE2A53, b"\x75\x0B", b"\x90\x90", WF), (0x1EE09F7, b"\x75", b"\xEB", AL)],
        # Applied by earlier versions of --rt. Not needed with vkd3d-proton #3332 and no longer applied, but still
        # recognised so that --restore undoes it.
        "legacy": [(0x106E0D, b"\x20\x00\x00\x00", b"\x00\x01\x00\x00",
                    "(old --rt, no longer applied) RT BLAS scratch 32 -> 256 MiB")],
    },
    90674640: {
        "version": "5.0.0.1044392", "steam_build": "25646871",
        "sha256": "9406eccc12b68e08920931442ef6a57340e910d3e01f2082e88232487433fe51",
        "base": [(0x1B7169B, b"\x75\x42", b"\x90\x90", SL), (0x1B76620, b"\x74", b"\xEB", DG)],
        "rt": [(0x1EDE8F3, b"\x75\x0B", b"\x90\x90", WF), (0x1EDC897, b"\x75", b"\xEB", AL)],
        "legacy": [],
    },
    90715600: {
        "version": "5.0.0.1048522", "steam_build": "25773555",
        "sha256": "2df765398a3d1f165db418271be7200178320a4466817379f2fa0dc0001fb101",
        "base": [(0x1B77ECB, b"\x75\x42", b"\x90\x90", SL), (0x1B7CE30, b"\x74", b"\xEB", DG)],
        "rt": [(0x1EE4C33, b"\x75\x0B", b"\x90\x90", WF), (0x1EE2BD7, b"\x75", b"\xEB", AL)],
        "legacy": [],
    },
 }


 def has_nvidia_gpu():
    try:
        return any(open(os.path.join("/sys/class/drm", d, "device/vendor")).read().strip() == "0x10de"
                   for d in os.listdir("/sys/class/drm") if d.startswith("card") and "-" not in d)
    except OSError:
        return True  # cannot tell; do not warn


 def state_of(data, patch):
    off, orig, new, _ = patch
    cur = data[off:off + len(orig)]
    return "original" if cur == orig else "patched" if cur == new else "unknown"


 def main():
    ap = argparse.ArgumentParser(
        description="Re-enable DLSS / DLSS-G (and optionally RT) in The Witcher 3 5.0 under Proton/Wine.")
    ap.add_argument("exe", nargs="?", default=DEFAULT_PATH)
    mode = ap.add_mutually_exclusive_group()
    mode.add_argument("--rt", action="store_true", help="also enable ray tracing and path tracing")
    mode.add_argument("--rt-only", action="store_true",
                      help="AMD / Intel: RT, path tracing and FSR frame generation without the DLSS patches")
    mode.add_argument("--restore", action="store_true", help="revert every patch")
    ap.add_argument("--dry-run", action="store_true", help="report only, change nothing")
    args = ap.parse_args()

    path = args.exe
    if not os.path.isfile(path):
        sys.exit(f"not found: {path}")
    data = bytearray(open(path, "rb").read())
    build = BUILDS.get(len(data))
    if build is None:
        sys.exit(f"unexpected size {len(data)}: this script supports witcher3.exe (DX12) "
                 + ", ".join(b["version"] for b in BUILDS.values()) + "; a newer game update needs a script update")
    BASE, RT, LEGACY = build["base"], build["rt"], build["legacy"]
    ALL = BASE + RT + LEGACY
    version = build["version"]

    states = [state_of(data, p) for p in ALL]
    if "unknown" in states:
        sys.exit("unexpected bytes at a patch site: different build or modified exe; nothing changed")

    # Rebuild the original image in memory and check it is exactly the supported build.
    orig = bytearray(data)
    for off, o, _, _ in ALL:
        orig[off:off + len(o)] = o
    if hashlib.sha256(orig).hexdigest() != build["sha256"]:
        sys.exit(f"sha256 mismatch: not witcher3.exe {version} (DX12); nothing changed")
    print(f"witcher3.exe {version} (Steam build {build['steam_build']})")

    print("current state:")
    for p, s in zip(ALL, states):
        print(f"  0x{p[0]:07X}  {s:8}  {p[3]}")

    if not args.restore and not args.rt_only and not has_nvidia_gpu():
        print("WARNING: no NVIDIA GPU found. The DLSS patches are for NVIDIA; on AMD or Intel use --rt-only "
              "(RT and FSR frame generation). See README.")

    if args.restore:
        target = bytes(orig)
    elif args.rt or args.rt_only:
        # Exactly the chosen set, from the original: --rt-only takes out DLSS patches from an earlier run, and both
        # take out the old scratch patch an earlier --rt applied.
        target = bytearray(orig)
        for off, _, new, _ in (RT if args.rt_only else BASE + RT):
            target[off:off + len(new)] = new
        target = bytes(target)
    else:
        target = bytearray(data)
        for off, _, new, _ in BASE:
            target[off:off + len(new)] = new
        target = bytes(target)

    if target == bytes(data):
        print("nothing to do")
        return
    if args.dry_run:
        print("dry run: would write changes")
        return

    backup = path + ".orig-" + version
    if not os.path.exists(backup):
        with open(backup, "wb") as f:
            f.write(bytes(orig))
        print(f"backup of the original: {backup}")
    tmp = path + ".tmp-patch"
    with open(tmp, "wb") as f:
        f.write(target)
    shutil.copymode(path, tmp)
    os.replace(tmp, path)
    if args.restore:
        print("restored the original")
    elif args.rt_only:
        print("patched: RT/path tracing and FSR frame generation only (no DLSS patches)")
    else:
        print("patched: DLSS/DLSS-G" + (" + RT/path tracing" if args.rt else ""))
    if args.rt or args.rt_only:
        print("WARNING: RT under Proton needs a recent vkd3d-proton: with #3332 on NVIDIA 590+ (or the GPU hangs), "
              "and on AMD (RADV) also with dxil-spirv PR #311 (or the game crashes while loading). See README.")


 if __name__ == "__main__":
    main()
You use	Do this	You get
Steam, any GPU	Proton Wineland 11.0-20260930 or newer, original exe	Everything, nothing to patch
Proton Experimental (2026-10-02 or newer)	The `sed` one-liner	Everything
GE-Proton11-7	The script	DLSS SR/RR, Reflex, DLSS-G. RT and path tracing also need a newer vkd3d-proton
AMD / Intel on another Proton	The script with `--rt-only`	RT, path tracing, FSR FG
GOG through Heroic, or Lutris / Faugus	Wineland plus the manual step in #75 / #76 / #77, or the `sed` one-liner if that step doesn't stick (confirmed through Faugus by @micker)	Everything
A laptop, or any PC with the iGPU enabled	Read Hybrid GPUs first
GPU	Run	You get
NVIDIA	default	DLSS SR/RR, Reflex and DLSS-G. Nothing else needed
NVIDIA	`--rt`	The above plus ray tracing and path tracing, which need a recent vkd3d-proton (below)
AMD / Intel	`--rt-only`	Ray tracing, path tracing and FSR frame generation. On AMD, RT also needs the dxil-spirv fix (below)
Symptom	What to do
DLSS still greyed out after patching	Run once with `PROTON_LOG=1` and check that `sl.common.dll` and `sl.dlss.dll` get loaded. If only `sl.interposer.dll` shows up, the exe that actually runs is not the patched one. With a plain Wine runner instead of Proton, also check that dxvk-nvapi is set up.
Crash at startup right after hiding Wine	The vkd3d-proton is older than #3308 (GE-Proton11-7's is). Use a newer one, or the script's `--rt` / `--rt-only`, which keep Wine's buffer alignment.
Crash in `Steam.dll` at startup	The remaster needs `SteamUtils011`, which older proton-cachyos builds (20260703) lack. With an outdated Steam client, recreating a missing `~/.local/share/Steam/steam/games` folder let Steam update itself (@Patola).
Low preset, RT locked, DLSS "not supported", very low FPS	The game picked the iGPU: see Hybrid GPUs.
GOG through Heroic: `witcher3.exe` runs with no window	The GOG update leaves empty folders under `content/` and `dlc/`, and the game hangs on them. From the game folder, `find content dlc -depth -type d -empty -delete` fixed it (Heroic #5941, confirmed by @Ritaku02).
Stutter while signed in to a CDPR account	While signed in, the game checks the connection about 10 times a second, and under Wine each check re-reads the stats of every network adapter; one slow NIC driver is enough (profiled by @ninele7 in Proton#607). Wineland 11.0-20261011 ships a fix for it. On other Protons, signing out of the CDPR account avoids it.
"Frozen" loading screen after dying	Under Proton, "Load last save" from the death screen can take 3–4 minutes, while the same save loads in seconds from the main menu. Reported on Steam Deck and desktop Linux, not on Windows; one report says Proton 11-02 cut it to ~30 s (Steam thread). For now, quit to the main menu and load from there.
Random crash in menus with a live 3D scene (inventory, map, alchemy, character), `witcher3.exe+0x3317E3`	A race in the game itself, much more common under Wine. @p-valentin's fix patches it: for 5.00c, and for 5.01 (the same patch with the 5.01 addresses; @Snuffles20 crashed the unpatched 5.01 within minutes and not since). It needs the unmodified exe: on Wineland just run it; with the `sed` one-liner, apply it first and the `sed` after. It can't be combined with this gist's script.
AMD: crash with Mesa's anti-lag layer on	Add `DISABLE_LAYER_MESA_ANTI_LAG=1` to the launch options (@vharmash).
5.0.0.1041720	5.0.0.1044392 (5.00c)	5.0.0.1048522 (5.01)	Original → new	Effect
`0x1B709CB`	`0x1B7169B`	`0x1B77ECB`	`75 42` → `90 90`	Default and `--rt`: creates the Streamline manager under Wine (DLSS SR/RR, Reflex)
`0x1B759A0`	`0x1B76620`	`0x1B7CE30`	`74` → `EB`	Default and `--rt`: DLSS-G support comes from Streamline instead of the Wine flag
`0x1EE2A53`	`0x1EDE8F3`	`0x1EE4C33`	`75 0B` → `90 90`	`--rt`, `--rt-only`: the Wine flag no longer set (RT, path tracing, FSR FG)
`0x1EE09F7`	`0x1EDC897`	`0x1EE2BD7`	`75` → `EB`	`--rt`, `--rt-only`: keep Wine's buffer alignment (needed only on vkd3d-proton older than #3308)
`0x106E0D`	—	—	`20 00 00 00` → `00 01 00 00`	Old `--rt` only, no longer applied: RT BLAS scratch default 32 → 256 MiB
	diff --git a/libs/vkd3d/device.c b/libs/vkd3d/device.c
	index 44685730..3b531c9d 100644
	--- a/libs/vkd3d/device.c
	+++ b/libs/vkd3d/device.c
	@@ -7946,6 +7946,25 @@ static void STDMETHODCALLTYPE d3d12_device_GetRaytracingAccelerationStructurePre
	info->UpdateScratchDataSizeInBytes = size_info.updateScratchSize;
	}

	+ /* LOCAL WORKAROUND (vkd3d-proton #3226): Witcher 3 RT hangs on NVIDIA 590+ unless the RTAS result and
	+ * scratch sizes reported to the application are inflated. x8 by default;
	+ * VKD3D_RTAS_SIZE_MULT=<n> overrides it at runtime (1 = stock behaviour). */
	+ {
	+ static uint32_t rtas_size_mult;
	+ uint32_t mult = vkd3d_atomic_uint32_load_explicit(&rtas_size_mult, vkd3d_memory_order_relaxed);
	+
	+ if (!mult)
	+ {
	+ mult = max(1u, vkd3d_env_var_as_uint("VKD3D_RTAS_SIZE_MULT", 8));
	+ vkd3d_atomic_uint32_store_explicit(&rtas_size_mult, mult, vkd3d_memory_order_relaxed);
	+ INFO("RTAS prebuild sizes are multiplied by %u (local workaround).\n", mult);
	+ }
	+
	+ info->ResultDataMaxSizeInBytes *= mult;
	+ info->ScratchDataSizeInBytes *= mult;
	+ info->UpdateScratchDataSizeInBytes *= mult;
	+ }
	+
	TRACE("ResultDataMaxSizeInBytes: %"PRIu64".\n", info->ResultDataMaxSizeInBytes);
	TRACE("ScratchDatSizeInBytes: %"PRIu64".\n", info->ScratchDataSizeInBytes);
	TRACE("UpdateScratchDataSizeInBytes: %"PRIu64".\n", info->UpdateScratchDataSizeInBytes);
	#!/usr/bin/env python3
	"""Re-enable DLSS / DLSS-G (and optionally ray tracing) in The Witcher 3 5.0 under Proton/Wine.

	The Witcher 3 5.0 ("Remastered", DX12) detects Wine through GetProcAddress(ntdll, "wine_get_version") and then
	deliberately skips NVIDIA Streamline (so DLSS SR/RR, DLSS Frame Generation and Reflex are unavailable) and forces
	ray tracing / path tracing off. This script flips those checks in bin/x64_dx12/witcher3.exe. It only accepts the
	exact builds listed in BUILDS below (5.0.0.1041720, the 5.00c hotfix 5.0.0.1044392 and patch 5.01,
	5.0.0.1048522), checked by sha256.

	python3 w3_proton_patch.py [path/to/witcher3.exe] DLSS SR/RR, Reflex and DLSS-G
	python3 w3_proton_patch.py --rt [path/to/witcher3.exe] also RT and path tracing (read the README first:
	needs a vkd3d-proton with #3332, or the GPU hangs
	within a minute on NVIDIA 590+)
	python3 w3_proton_patch.py --rt-only [path/to/witcher3.exe] AMD / Intel: RT, path tracing and FSR frame generation,
	without the NVIDIA-only DLSS patches (RADV also needs
	dxil-spirv PR #311 in vkd3d-proton; see the README)
	python3 w3_proton_patch.py --restore [path/to/witcher3.exe] undo every patch (Steam "Verify integrity" also does)
	add --dry-run to only report the current state.

	The DLSS patches are NVIDIA only. Unofficial; use at your own risk. Close the game before running it.
	"""
	import argparse
	import hashlib
	import os
	import shutil
	import sys

	DEFAULT_PATH = os.path.expanduser(
	"~/.local/share/Steam/steamapps/common/The Witcher 3/bin/x64_dx12/witcher3.exe")

	# (file offset, original bytes, patched bytes, description). Per build: the same four checks, found in 1044392 by
	# matching the code around each 1041720 site with RIP-relative displacements wildcarded (each matches exactly once,
	# and the instructions around it are unchanged). In 1048522 (5.01) WF and AL matched the same way; SL and DG did
	# not, because a register and a stack frame changed around them, and were found through the wine_get_version
	# string references and the reads of the cached Wine flag, which map one to one between the builds.
	SL = "create the Streamline manager (slInit) under Wine: DLSS SR/RR, Reflex"
	DG = "do not force DLSS-G 'unsupported' on the Wine flag"
	WF = "clear the cached Wine flag: RT, path tracing, FSR FG"
	AL = "keep buffer alignment as under Wine (only needed on vkd3d-proton older than #3308)"
	BUILDS = {
	90832336: {
	"version": "5.0.0.1041720", "steam_build": "25575366",
	"sha256": "c272b2c2e61f84c758e28fab69ab2915944dd1e539dbb435fae9fc67494c7e25",
	"base": [(0x1B709CB, b"\x75\x42", b"\x90\x90", SL), (0x1B759A0, b"\x74", b"\xEB", DG)],
	"rt": [(0x1EE2A53, b"\x75\x0B", b"\x90\x90", WF), (0x1EE09F7, b"\x75", b"\xEB", AL)],
	# Applied by earlier versions of --rt. Not needed with vkd3d-proton #3332 and no longer applied, but still
	# recognised so that --restore undoes it.
	"legacy": [(0x106E0D, b"\x20\x00\x00\x00", b"\x00\x01\x00\x00",
	"(old --rt, no longer applied) RT BLAS scratch 32 -> 256 MiB")],
	},
	90674640: {
	"version": "5.0.0.1044392", "steam_build": "25646871",
	"sha256": "9406eccc12b68e08920931442ef6a57340e910d3e01f2082e88232487433fe51",
	"base": [(0x1B7169B, b"\x75\x42", b"\x90\x90", SL), (0x1B76620, b"\x74", b"\xEB", DG)],
	"rt": [(0x1EDE8F3, b"\x75\x0B", b"\x90\x90", WF), (0x1EDC897, b"\x75", b"\xEB", AL)],
	"legacy": [],
	},
	90715600: {
	"version": "5.0.0.1048522", "steam_build": "25773555",
	"sha256": "2df765398a3d1f165db418271be7200178320a4466817379f2fa0dc0001fb101",
	"base": [(0x1B77ECB, b"\x75\x42", b"\x90\x90", SL), (0x1B7CE30, b"\x74", b"\xEB", DG)],
	"rt": [(0x1EE4C33, b"\x75\x0B", b"\x90\x90", WF), (0x1EE2BD7, b"\x75", b"\xEB", AL)],
	"legacy": [],
	},
	}


	def has_nvidia_gpu():
	try:
	return any(open(os.path.join("/sys/class/drm", d, "device/vendor")).read().strip() == "0x10de"
	for d in os.listdir("/sys/class/drm") if d.startswith("card") and "-" not in d)
	except OSError:
	return True # cannot tell; do not warn


	def state_of(data, patch):
	off, orig, new, _ = patch
	cur = data[off:off + len(orig)]
	return "original" if cur == orig else "patched" if cur == new else "unknown"


	def main():
	ap = argparse.ArgumentParser(
	description="Re-enable DLSS / DLSS-G (and optionally RT) in The Witcher 3 5.0 under Proton/Wine.")
	ap.add_argument("exe", nargs="?", default=DEFAULT_PATH)
	mode = ap.add_mutually_exclusive_group()
	mode.add_argument("--rt", action="store_true", help="also enable ray tracing and path tracing")
	mode.add_argument("--rt-only", action="store_true",
	help="AMD / Intel: RT, path tracing and FSR frame generation without the DLSS patches")
	mode.add_argument("--restore", action="store_true", help="revert every patch")
	ap.add_argument("--dry-run", action="store_true", help="report only, change nothing")
	args = ap.parse_args()

	path = args.exe
	if not os.path.isfile(path):
	sys.exit(f"not found: {path}")
	data = bytearray(open(path, "rb").read())
	build = BUILDS.get(len(data))
	if build is None:
	sys.exit(f"unexpected size {len(data)}: this script supports witcher3.exe (DX12) "
	+ ", ".join(b["version"] for b in BUILDS.values()) + "; a newer game update needs a script update")
	BASE, RT, LEGACY = build["base"], build["rt"], build["legacy"]
	ALL = BASE + RT + LEGACY
	version = build["version"]

	states = [state_of(data, p) for p in ALL]
	if "unknown" in states:
	sys.exit("unexpected bytes at a patch site: different build or modified exe; nothing changed")

	# Rebuild the original image in memory and check it is exactly the supported build.
	orig = bytearray(data)
	for off, o, _, _ in ALL:
	orig[off:off + len(o)] = o
	if hashlib.sha256(orig).hexdigest() != build["sha256"]:
	sys.exit(f"sha256 mismatch: not witcher3.exe {version} (DX12); nothing changed")
	print(f"witcher3.exe {version} (Steam build {build['steam_build']})")

	print("current state:")
	for p, s in zip(ALL, states):
	print(f" 0x{p[0]:07X} {s:8} {p[3]}")

	if not args.restore and not args.rt_only and not has_nvidia_gpu():
	print("WARNING: no NVIDIA GPU found. The DLSS patches are for NVIDIA; on AMD or Intel use --rt-only "
	"(RT and FSR frame generation). See README.")

	if args.restore:
	target = bytes(orig)
	elif args.rt or args.rt_only:
	# Exactly the chosen set, from the original: --rt-only takes out DLSS patches from an earlier run, and both
	# take out the old scratch patch an earlier --rt applied.
	target = bytearray(orig)
	for off, _, new, _ in (RT if args.rt_only else BASE + RT):
	target[off:off + len(new)] = new
	target = bytes(target)
	else:
	target = bytearray(data)
	for off, _, new, _ in BASE:
	target[off:off + len(new)] = new
	target = bytes(target)

	if target == bytes(data):
	print("nothing to do")
	return
	if args.dry_run:
	print("dry run: would write changes")
	return

	backup = path + ".orig-" + version
	if not os.path.exists(backup):
	with open(backup, "wb") as f:
	f.write(bytes(orig))
	print(f"backup of the original: {backup}")
	tmp = path + ".tmp-patch"
	with open(tmp, "wb") as f:
	f.write(target)
	shutil.copymode(path, tmp)
	os.replace(tmp, path)
	if args.restore:
	print("restored the original")
	elif args.rt_only:
	print("patched: RT/path tracing and FSR frame generation only (no DLSS patches)")
	else:
	print("patched: DLSS/DLSS-G" + (" + RT/path tracing" if args.rt else ""))
	if args.rt or args.rt_only:
	print("WARNING: RT under Proton needs a recent vkd3d-proton: with #3332 on NVIDIA 590+ (or the GPU hangs), "
	"and on AMD (RADV) also with dxil-spirv PR #311 (or the game crashes while loading). See README.")


	if __name__ == "__main__":
	main()
Component	Version
Game	The Witcher 3: Wild Hunt — Remastered, 5.0.0.1041720 (2026-09-29 release, Steam build 25575366)
Executable	`bin/x64_dx12/witcher3.exe`, size 90,832,336 bytes
Executable sha256 (original)	`c272b2c2e61f84c758e28fab69ab2915944dd1e539dbb435fae9fc67494c7e25`
Launcher	Faugus Launcher 2.4.2 (umu-launcher 1.4.4)
Runner	`proton-wineland-11.0-20260930-x86_64` (nanomatters' proton-cachyos)
GPU	AMD RDNA2 (`amdgpu`, PCI id `1002:73df`)
Kernel	7.2.2-1-cachyos-bore-lto
Session	Wayland / KDE Plasma 6
Offset	Original → new	Effect
`0x1EE2A53`	`75 0B` → `90 90`	applied — clears the cached Wine flag: RT, path tracing, FSR FG
`0x1EE09F7`	`75` → `EB`	applied — keeps Wine's buffer alignment (needed only on vkd3d-proton older than #3308; harmless on new ones)
`0x1B709CB`	`75 42` → `90 90`	left original — Streamline manager / DLSS (NVIDIA only)
`0x1B759A0`	`74` → `EB`	left original — DLSS-G (NVIDIA only)
`0x106E0D`	`20 00 00 00` → `00 01 00 00`	left original — legacy RT BLAS scratch patch, no longer applied
Attempt	Result	Why
Default Faugus runner (GE-Proton10-34 selected, combo actually on Wineland)	launched, menu hung	Wineland loads, but the unpatched exe sets the Wine flag → RT/FSR grey. With the `frog` rename instead, Neon→ NVAPI retry loop (Symptom A)
`sed s/wine_get_version/frog_get_version/` (rename)	tight NVAPI retry loop, `raise (22)`	game believes Windows, hard-requires Streamline, probes NVAPI, dxvk-nvapi fails on AMD and retries forever
Restore original exe + `PROTON_DISABLE_NVAPI=1 ENABLE_LAYER_MESA_ANTI_LAG=0`	launches and is stable	correct stopgap, but the Wine flag keeps RT / FSR FG greyed out (Symptom B)
Original exe + `--rt-only` + the two env vars	RT / path tracing / FSR FG selectable	clears the Wine flag; vkd3d-proton in Wineland has the AMD RADV and BLAS fixes