diff --git a/README.md b/README.md
index 4fd26a5..377e1d7 100644
--- a/README.md
+++ b/README.md
@@ -5,7 +5,7 @@ A tool aimed at enhancing the experience when playing the game on linux through
 
 ## Warning
 
-**This tool is based on patching the game executable through hex-edits. However it is done in a safe and non-destructive way, that ensures the patched executable is never run with EAC enabled. Use at your own risk!** 
+**This tool is based on patching the game executable through hex-edits. However it is done in a safe and non-destructive way, that ensures the patched executable is never run with EAC enabled (unless explicity told to do so). Use at your own risk!**
 
 ## Dependencies
 
@@ -14,37 +14,57 @@ A tool aimed at enhancing the experience when playing the game on linux through
 ## Usage
 
 1. Copy the file `er-patcher` to the game directory.
-2. In steam, set the game launch options to `./er-patcher ARGS -- %command%` See [Features](#features) for available options.
-  - Example: `./er-patcher --all --rate 30 --fix-camera -- %command%`
-  - Example using [MangoHud](https://github.com/flightlessmango/MangoHud) and wine fullscreen FSR: `./er-patcher --rate 144 -uvca -- env WINE_FULLSCREEN_FSR=1 MANGOHUD=1 MANGOHUD_CONFIG=histogram %command%`
+2. In steam, set the game launch options to `python er-patcher ARGS -- %command%` See [Features](#features) for available options.
+  - Example:
+
+    `python er-patcher --all --rate 30 --disable-rune-loss -- %command%`
+
+  - Example using the [Seamless Co-op](https://www.nexusmods.com/eldenring/mods/510) mod:
+
+    `python er-patcher --all --executable ersc_launcher.exe -- %command%`
+
+  - Example using [MangoHud](https://github.com/flightlessmango/MangoHud) and wine fullscreen FSR:
+
+    `python er-patcher --rate 144 -uvca -- env WINE_FULLSCREEN_FSR=1 MANGOHUD=1 MANGOHUD_CONFIG=histogram %command%`
+
+  - Example for enabling HDR using gamescope on Linux (reported to work on Plasma 6.1):
+
+    `ENABLE_GAMESCOPE_WSI=1 DXVK_HDR=1 gamescope -W 3440 -H 1440 -f -r 165 --hdr-enabled -- python er-patcher --all --rate 165 -- %command%`
+    
 3. Launch the game through steam. `er-patcher` automatically launches a patched version of `eldenring.exe` with EAC disabled.
 
+Note: There might be some distros (e.g. older Ubuntu releases) that launch python 2 instead of 3 when running `python`. In that case you'll need to replace `python` with `python3` in the launch option line. 
+
 ## Features
 
-| Argument                                | Description                                                                  |
-| --------------------------------------- | ---------------------------------------------------------------------------- |
-| `-r RATE` or `--rate RATE`              | Set a custom framerate limit (default: 60).                                  |
-| `--fix-camera`                          | Disable camera auto-rotation.                                                |
-| `--all`                                 | Enable all options except `--rate` and<br>gameplay changes like `--fix-camera`. |
-| `-u` or `--ultrawide`                   | Remove black bars.                                                           |
-| `-v` or `--disable-vigniette`           | Remove the vigniette overlay .                                               |
-| `-c` or `--disable-ca`                  | Disable chromatic abberation.                                                |
-| `-a` or `--increase-animation-distance` | Fix low frame rate animations at screen<br>edges or for distant entities.       |
-| `-s` or `--skip-intro`                  | Skip intro logos at game start.                                              |
-| `-f` or `--remove-60hz-fullscreen`      | Remove the 60Hz limit in fullscreen<br>mode (not needed with proton).           |
+| Argument                                | Description                                                                                               |
+| --------------------------------------- | --------------------------------------------------------------------------------------------------------- |
+| `-r RATE` or `--rate RATE`              | Set a custom framerate limit (default: 60).                                                               |
+| `-x EXE` or `--executable EXE`          | The executable to launch, relative to the games folder.<br>Mutually exclusive with `--with-eac`.          |
+| `--with-eac`                            | Run game with EAC (Use it at your own risk).<br>Mutually exclusive with `--executable`.                   |
+| `--disable-rune-loss`                   | Disable losing runes upon death.                                                                          |
+| `--all`                                 | Enable all options except `--rate`, `--executable`, and<br>gameplay changes like `--disable-rune-loss`.   |
+| `-u` or `--ultrawide`                   | Remove black bars.                                                                                        |
+| `-v` or `--disable-vignette`           | Remove the vignette overlay.                                                                             |
+| `-c` or `--disable-ca`                  | Disable chromatic abberation.                                                                             |
+| `-a` or `--increase-animation-distance` | Fix low frame rate animations at screen<br>edges or for distant entities.                                 |
+| `-s` or `--skip-intro`                  | Skip intro logos at game start.                                                                           |
+| `-f` or `--remove-60hz-fullscreen`      | Remove the 60Hz limit in fullscreen<br>mode (not needed with proton).                                     |
 
 
 ## Windows Support
 
-The patcher works just as well on windows. The only difference is that you need to explicitly call python to run the script `er-patcher`. The following launch option line works in case you installed Python from Microsoft Store:
+The patcher works just as well on windows. The following launch option line works in case you e.g. installed Python from Microsoft Store:
 
 > `python er-patcher --rate 165 --all -- %command%`
 
 Note: This spawns a python console which will close by itself after the game has finished running. If you find this annoying you can try using `pythonw` instead. In any case `python` needs to be in PATH for windows to find it.
 
+Note 2: Ensure Vertical Sync is turned off for Elden Ring in Nvidia Control Panel / AMD Radeon Software / Intel Graphics Command Center, otherwise the custom framerate limit feature won't work.
+
 ## How it works
 
-When the game is launched through steam, the tool creates a patched version of `eldenring.exe` in a temporary subdirectory while leaving the original intact. The tool then modifies the steam launch command to launch the patched executable instead of `start_protected_game.exe`. This ensures that the patched exe is never run with EAC enabled. After the game is closed, the patched executable is removed.
+When the game is launched through steam, the tool creates a patched version of `eldenring.exe` in a temporary subdirectory while leaving the original intact. As long the flag `--with-eac` is not set, the tool modifies the steam launch command to launch the patched executable instead of `start_protected_game.exe`, thefore ensuring that the patched exe is never run with EAC enabled. After the game is closed, the patched executable is removed.
 
 ## Credits
 
@@ -52,7 +72,8 @@ When the game is launched through steam, the tool creates a patched version of `
   - frame time limit adjustment
   - black bar removal
 - [Flawless Widescreen](https://www.flawlesswidescreen.org)
-  - vigniette and ca removal
+  - vignette and ca removal
   - animation distance increase
 - [DarkSouls3RemoveIntroScreens](https://github.com/bladecoding/DarkSouls3RemoveIntroScreens): intro logo skip
-- [EldenRingMods](https://github.com/techiew/EldenRingMods) + [EldenRingFpsUnlockAndMore](https://github.com/uberhalit/EldenRingFpsUnlockAndMore): camera fix
+- [EldenRingMods](https://github.com/techiew/EldenRingMods) + [EldenRingFpsUnlockAndMore](https://github.com/uberhalit/EldenRingFpsUnlockAndMore)
+  - disable rune loss
diff --git a/er-patcher b/er-patcher
index 69ce45a..2e51c39 100755
--- a/er-patcher
+++ b/er-patcher
@@ -1,6 +1,5 @@
 #!/usr/bin/env python3
 
-import os
 import sys
 import subprocess
 import argparse
@@ -8,31 +7,53 @@ from pathlib import Path
 import struct
 import re
 from shutil import rmtree
+import os
+import time
 
+def cleanup(game_dir_patched):
+    if game_dir_patched.exists():
+        eldenring_path = game_dir_patched / "eldenring.exe"
+        while eldenring_path.exists():
+            try:
+                os.remove(eldenring_path)
+                break
+            except PermissionError:
+                # eldenring.exe is still running, retry in 3 s
+                time.sleep(3)
+            except Exception as e:
+                print(f"er-patcher: could not delete {eldenring_path}: {e}")
+                break
+        rmtree(game_dir_patched)
 
 if __name__ == "__main__":
 
     patcher_args = sys.argv[1:sys.argv.index("--")]
-    
+
     parser = argparse.ArgumentParser(description="Patch Elden Ring executable and launch it without EAC.")
-    
+
     parser.add_argument("-r", "--rate", type=int, default=60, help="Modify the frame rate limit (e.g. 30, 120, 165 or whatever).")
-    parser.add_argument("--fix-camera", action='store_true', help="Disable camera auto-rotation.")
-    parser.add_argument("--all", action='store_true', help="Enable all options except rate adjustment and gamplay changes like `--fix-camera`.")
+    parser.add_argument("-x", "--executable", action='store', type=str, default="eldenring.exe", help="The executable to launch, relative to the games folder.")
+    parser.add_argument("--with-eac", action='store_true', help="Run game with EAC (Use at own your risk)")
+    parser.add_argument("--disable-rune-loss", action='store_true', help="Disable losing runes upon death.")
+    parser.add_argument("--all", action='store_true', help="Enable all options except rate adjustment and gamplay changes like `--disable-rune-loss`.")
     parser.add_argument("-u", "--ultrawide", action='store_true', help="Removes black bars when using a resolution with an aspect ratio other than 16:9.")
-    parser.add_argument("-v", "--disable-vigniette", action='store_true', help="Disables the vigniette overlay.")
+    parser.add_argument("-v", "--disable-vignette", action='store_true', help="Disables the vignette overlay.")
     parser.add_argument("-c", "--disable-ca", action='store_true', help="Disables chromatic abberation.")
     parser.add_argument("-a", "--increase-animation-distance", action='store_true', help="Increase animation distance.")
     parser.add_argument("-s", "--skip-intro", action='store_true', help="Skip intro logos.")
     parser.add_argument("-f", "--remove-60hz-fullscreen", action='store_true', help="Remove 60hz lock in fullscreen.")
     patch = parser.parse_args(patcher_args)
 
+    if patch.with_eac and patch.executable != "eldenring.exe":
+        print("er-patcher: --with-eac is mutually exclusive with --executable")
+        sys.exit(1)
+
     game_dir = Path(".")
     with open(game_dir / "eldenring.exe", "rb") as f:
         exe_hex = f.read().hex()
 
     if patch.rate != 60 and patch.rate > 0:
-        r_pattern = "c7 43 20 89 88 88 3c eb 43 89 73 18 eb ca 89 73 18".replace(" ", "")
+        r_pattern = "c7 43 1c 89 88 88 3c eb 6d 89 73 18 eb c7 89 73 18".replace(" ", "")
         if (res := re.search(r_pattern, exe_hex)) is not None:
             r_addr = res.span()[0] + 6
             r_patch = struct.pack('<f', 1 / patch.rate).hex()
@@ -40,33 +61,32 @@ if __name__ == "__main__":
         else:
             print("er-patcher: rate pattern scan failed")
 
-    if patch.fix_camera:
-        cf_pattern = '0f 29 a6 .. .. .. .. 41 0f 28 cf'.replace(" ", "")
-        if (res := re.search(cf_pattern, exe_hex)) is not None:
-            cf_addr = res.span()[0]
-            cf_patch = "90 90 90 90 90 90 90".replace(" ", "")
-            exe_hex = exe_hex[:cf_addr] + cf_patch + exe_hex[cf_addr + len(cf_patch):]
+    if patch.disable_rune_loss:
+        rl_pattern = "41 .. 01 48 .. .. e8 .. .. .. .. 48 .. .. .. .. 32 c0".replace(" ", "")
+        if (res := re.search(rl_pattern, exe_hex)) is not None:
+            rl_addr = res.span()[0] + 12
+            rl_patch = "90 90 90 90 90".replace(" ", "")  # NOP
+            exe_hex = exe_hex[:rl_addr] + rl_patch + exe_hex[rl_addr + len(rl_patch):]
         else:
-            print("er-patcher: fix_camera pattern scan failed")
+            print("er-patcher: disable rune loss pattern scan failed")
 
     if patch.ultrawide or patch.all:
-        uw_pattern = "8b 01 85 c0 74 42 44 8b 59 04".replace(" ", "")
+        uw_pattern = "74 4f 45 8b 94 cc".replace(" ", "")
         if (res := re.search(uw_pattern, exe_hex)) is not None:
-            uw_addr = res.span()[0] + 8
+            uw_addr = res.span()[0]
             uw_patch = "eb"
             exe_hex = exe_hex[:uw_addr] + uw_patch + exe_hex[uw_addr + len(uw_patch):]
         else:
             print("er-patcher: ultrawide pattern scan failed")
 
-
-    if patch.disable_vigniette or patch.all:
+    if patch.disable_vignette or patch.all:
         v_pattern = 'f3 0f 10 .. .. f3 0f 59 .. .. .. .. .. e8 .. .. .. .. f3 41 0f .. .. f3 45 0f .. .. 4c 8d .. .. .. .. .. .. 48'.replace(" ", "")
         if (res := re.search(v_pattern, exe_hex)) is not None:
             v_addr = res.span()[0] + 46
             v_patch = "f3 0f 5c c0 90".replace(" ", "")  # SUBSS XMM0,XMM0; NOP;  all NOP does work too
             exe_hex = exe_hex[:v_addr] + v_patch + exe_hex[v_addr + len(v_patch):]
         else:
-            print("er-patcher: disable_vigniette pattern scan failed")
+            print("er-patcher: disable_vignette pattern scan failed")
 
     if patch.disable_ca or patch.all:
         ca_pattern = "0f 11 43 60 48 8d 8b 80 00 00 00 0f 10 87 a0 00 00 00 0f 11 41 f0 48 8d 87 b0 00 00 00 0f 10 08 0f 11 09".replace(" ", "")
@@ -96,17 +116,25 @@ if __name__ == "__main__":
             exe_hex = exe_hex[:si_addr] + si_patch + exe_hex[si_addr + len(si_patch):]
         else:
             print("er-patcher: skip_intro pattern scan failed")
-    
+
     if patch.remove_60hz_fullscreen or patch.all:
-        fs_pattern = "c7 45 ef 3c 00 00 00".replace(" ", "")
+        fs_pattern = "eb .. c7 .. .. 3c 00 00 00 c7 .. .. 01 00 00 00".replace(" ", "")
         if (res := re.search(fs_pattern, exe_hex)) is not None:
-            fs_addr = res.span()[0] + 6
+            fs_addr = res.span()[0] + 10
             fs_patch = "00"
             exe_hex = exe_hex[:fs_addr] + fs_patch + exe_hex[fs_addr + len(fs_patch):]
+            
+            fs_addr_2 = res.span()[0] + 24
+            fs_patch_2 = "00"
+            exe_hex = exe_hex[:fs_addr_2] + fs_patch_2 + exe_hex[fs_addr_2 + len(fs_patch_2):]
         else:
             print("er-patcher: remove_60hz_fullscreen pattern scan failed")
 
     game_dir_patched = Path("er-patcher-tmp")
+
+    # make sure a fresh directory is used
+    cleanup(game_dir_patched)
+
     if not game_dir_patched.is_dir():
         game_dir_patched.mkdir()
 
@@ -121,21 +149,24 @@ if __name__ == "__main__":
         if d == game_dir_patched:
             continue
         if not (game_dir_patched / d).is_dir():
-             (game_dir_patched / d).mkdir(parents=True)
+            (game_dir_patched / d).mkdir(parents=True)
 
     # hard link game files to game_dir_patched; symbolic links would be easier
     # to handle but by default windows 10 doesn't allow them
     game_files = [f for f in game_dir.rglob("*") if f.is_file()]
     for f in game_files:
-        if f.name in ["eldenring.exe", "start_protected_game.exe", "er-patcher"]:
-            continue 
+        if f.name in ["eldenring.exe", "er-patcher"]:
+            continue
         if not (game_dir_patched / f).is_file():
-             f.link_to(game_dir_patched / f)
+            if sys.version_info.minor >= 10:
+                (game_dir_patched / f).hardlink_to(f)
+            else:
+                f.link_to(game_dir_patched / f)
 
     # start patched exe directly to avoid EAC
     steam_cmd = sys.argv[1 + sys.argv.index("--"):]
-    steam_cmd[-1] = Path(steam_cmd[-1]).parent.absolute() / game_dir_patched / "eldenring.exe"
+    steam_cmd[-1] = Path(steam_cmd[-1]).parent.absolute() / game_dir_patched / ("start_protected_game.exe" if patch.with_eac else patch.executable)
     subprocess.run(steam_cmd, cwd=steam_cmd[-1].parent.absolute())
 
-    # cleanup
-    rmtree(game_dir_patched)
+    # try to remove game_dir_patched
+    cleanup(game_dir_patched)