feat: fix right stick scancode patching, rename camera labels, and fix windows updater without git

Update README.md
2026-11-09 04:49:43 -10:00 · 2026-10-24 02:06:37 +03:00 · 2026-10-23 00:16:26 +03:00 · 2026-10-22 19:55:57 +03:00 · 2026-10-22 17:16:33 +03:00 · 2026-10-22 15:07:29 +03:00
17 changed files with 3614 additions and 798 deletions
@@ -1,122 +0,0 @@
-name: Build Cross-Platform Launchers
-
-on:
-  push:
-    branches: [ "main" ]
-  pull_request:
-    branches: [ "main" ]
-  workflow_dispatch:
-
-permissions:
-  contents: write
-
-jobs:
-  build-linux:
-    name: Build Linux Launcher
-    runs-on: ubuntu-latest
-    steps:
-      - name: Checkout code
-        uses: actions/checkout@v4
-
-      - name: Setup Rust toolchain
-        uses: dtolnay/rust-toolchain@stable
-
-      - name: Install Linux build dependencies
-        run: |
-          sudo apt-get update
-          sudo apt-get install -y libasound2-dev libudev-dev libwayland-dev libxkbcommon-dev libx11-dev libxcursor-dev libxi-dev libxrandr-dev libgl1-mesa-dev
-
-      - name: Build Linux Launcher (Release)
-        working-directory: launcher
-        run: cargo build --release
-
-      - name: Prepare binary
-        run: |
-          cp launcher/target/release/launcher ./gow3-launcher
-          chmod +x ./gow3-launcher
-
-      - name: Upload Linux Artifact
-        uses: actions/upload-artifact@v4
-        with:
-          name: gow3-launcher-linux
-          path: ./gow3-launcher
-
-  build-windows:
-    name: Build Windows Launcher
-    runs-on: windows-latest
-    steps:
-      - name: Checkout code
-        uses: actions/checkout@v4
-
-      - name: Setup Rust toolchain
-        uses: dtolnay/rust-toolchain@stable
-
-      - name: Build Windows Launcher (Release)
-        working-directory: launcher
-        run: cargo build --release
-
-      - name: Prepare binary
-        run: |
-          Copy-Item launcher/target/release/launcher.exe -Destination ./gow3-launcher-win.exe
-
-      - name: Upload Windows Artifact
-        uses: actions/upload-artifact@v4
-        with:
-          name: gow3-launcher-windows
-          path: ./gow3-launcher-win.exe
-
-  publish-release:
-    name: Publish Release & Sync Windows Binary
-    needs: [build-linux, build-windows]
-    if: github.ref == 'refs/heads/main'
-    runs-on: ubuntu-latest
-    steps:
-      - name: Checkout code
-        uses: actions/checkout@v4
-
-      - name: Download Linux binary
-        uses: actions/download-artifact@v4
-        with:
-          name: gow3-launcher-linux
-          path: ./artifacts/
-
-      - name: Download Windows binary
-        uses: actions/download-artifact@v4
-        with:
-          name: gow3-launcher-windows
-          path: ./artifacts/
-
-      - name: Commit Windows launcher to repo root
-        run: |
-          cp ./artifacts/gow3-launcher-win.exe ./gow3-launcher-win.exe
-          git config --local user.email "[email protected]"
-          git config --local user.name "GitHub Action"
-          git add gow3-launcher-win.exe
-          git diff --quiet && git diff --staged --quiet || (git commit -m "chore(build): sync gow3-launcher-win.exe to repo root [skip ci]" && git push origin main)
-
-      - name: Create or Update GitHub Release
-        uses: softprops/action-gh-release@v2
-        with:
-          tag_name: latest
-          name: "God of War III Native Launcher (Dual-Boot & Cross-Platform)"
-          body: |
-            ## 🚀 God of War III Remastered - Native Launcher (Linux & Windows)
-
-            Aynı klasörde yan yana çalışabilen yerel ikili dosyalar:
-            - 🐧 **Linux**: `gow3-launcher`
-            - 🪟 **Windows / Dual-Boot**: `gow3-launcher-win.exe`
-
-            ### ✨ Özellikler
-            - **Dual-Boot Desteği:** Aynı klasörde hem Windows hem Linux için yan yana bağımsız launcher'lar!
-            - **Modern Kayan Anahtarlar:** Klasik kutucuklar yerine animasyonlu Switch teması
-            - **Kararlı 60 FPS / 120 FPS / 144 FPS / 240 FPS Pacing:** Fizik hızlanma sorunu olmadan akıcı oynanış
-            - **Sinematikleri 'X' Tuşuyla Atlama Yaması:** Ara sahneleri kumandanızın X tuşuyla geçebilme seçeneği
-            - **Sarı Doku Hatası Önleme Yaması (Instant Readbacks):** Karlı ve parlak sahnelerdeki renk bozulmasını engeller
-            - **Dahili Donanım ve Ekran Hz Tespiti:** GPU, VRAM, RAM ve ekran yenileme hızına göre otomatik yapılandırma
-            - **4 Farklı Dil Desteği:** Türkçe 🇹🇷, English 🇬🇧, Deutsch 🇩🇪, Español 🇪🇸
-            - **%100 Rust Uyumlu Self-Updater:** Doğrudan GitHub üzerinden en son sürüme tek tıkla güncelleme
-          files: |
-            ./artifacts/gow3-launcher
-            ./artifacts/gow3-launcher-win.exe
-        env:
-          GITHUB_TOKEN: ${{ secrets.GITHUB_TOKEN }}
@@ -0,0 +1,153 @@
+name: Build & Release Single Executables (AppImage & Portable Exe)
+
+on:
+  push:
+    tags:
+      - 'v*'
+  workflow_dispatch:
+
+permissions:
+  contents: write
+
+jobs:
+  build-linux:
+    name: Build Linux AppImage & Binary
+    runs-on: ubuntu-22.04
+    steps:
+      - name: Checkout repository
+        uses: actions/checkout@v4
+
+      - name: Setup Rust toolchain
+        uses: dtolnay/rust-toolchain@stable
+
+      - name: Install Linux build dependencies
+        run: |
+          sudo apt-get update
+          sudo apt-get install -y libasound2-dev libudev-dev libwayland-dev libxkbcommon-dev libx11-dev libxcursor-dev libxi-dev libxrandr-dev libgl1-mesa-dev wget
+
+      - name: Build Linux Launcher (Release)
+        working-directory: launcher
+        run: cargo build --release
+
+      - name: Build AppImage
+        run: |
+          mkdir -p AppDir/usr/bin
+          mkdir -p AppDir/usr/share/applications
+          mkdir -p AppDir/usr/share/icons/hicolor/256x256/apps
+          cp launcher/target/release/launcher AppDir/usr/bin/gow3-launcher
+          cp gow3.png AppDir/usr/share/icons/hicolor/256x256/apps/gow3.png
+          cp gow3.png AppDir/gow3.png
+
+          cat << 'EOF' > AppDir/gow3-launcher.desktop
+          [Desktop Entry]
+          Name=God of War III Launcher
+          Exec=gow3-launcher
+          Icon=gow3
+          Type=Application
+          Categories=Game;
+          Terminal=false
+          EOF
+          cp AppDir/gow3-launcher.desktop AppDir/usr/share/applications/
+
+          cat << 'EOF' > AppDir/AppRun
+          #!/bin/bash
+          HERE="$(dirname "$(readlink -f "${0}")")"
+          export PATH="${HERE}/usr/bin:${PATH}"
+          exec "${HERE}/usr/bin/gow3-launcher" "$@"
+          EOF
+          chmod +x AppDir/AppRun
+
+          wget -q https://github.com/AppImage/appimagetool/releases/download/continuous/appimagetool-x86_64.AppImage -O appimagetool
+          chmod +x appimagetool
+          ./appimagetool --appimage-extract
+          ARCH=x86_64 ./squashfs-root/AppRun AppDir God_of_War_III_Launcher-x86_64.AppImage
+
+          cp launcher/target/release/launcher ./gow3-launcher
+
+      - name: Upload Linux Artifacts
+        uses: actions/upload-artifact@v4
+        with:
+          name: linux-artifacts
+          path: |
+            God_of_War_III_Launcher-x86_64.AppImage
+            gow3-launcher
+
+  build-windows:
+    name: Build Windows Portable Exe
+    runs-on: windows-latest
+    steps:
+      - name: Checkout repository
+        uses: actions/checkout@v4
+
+      - name: Setup Rust toolchain
+        uses: dtolnay/rust-toolchain@stable
+
+      - name: Build Windows Launcher (Release)
+        working-directory: launcher
+        run: cargo build --release
+
+      - name: Prepare Windows Executables
+        run: |
+          Copy-Item launcher/target/release/launcher.exe -Destination ./gow3-launcher-win.exe
+          Copy-Item launcher/target/release/launcher.exe -Destination ./God_of_War_III_Launcher-Windows.exe
+
+      - name: Upload Windows Artifacts
+        uses: actions/upload-artifact@v4
+        with:
+          name: windows-artifacts
+          path: |
+            gow3-launcher-win.exe
+            God_of_War_III_Launcher-Windows.exe
+
+  publish-release:
+    name: Publish Release with Assets
+    needs: [build-linux, build-windows]
+    runs-on: ubuntu-latest
+    steps:
+      - name: Checkout repository
+        uses: actions/checkout@v4
+
+      - name: Download Linux artifacts
+        uses: actions/download-artifact@v4
+        with:
+          name: linux-artifacts
+          path: ./dist/
+
+      - name: Download Windows artifacts
+        uses: actions/download-artifact@v4
+        with:
+          name: windows-artifacts
+          path: ./dist/
+
+      - name: Create or Update GitHub Release
+        uses: softprops/action-gh-release@v2
+        with:
+          tag_name: ${{ github.ref_name }}
+          name: "God of War III Launcher ${{ github.ref_name }}"
+          draft: false
+          prerelease: false
+          make_latest: true
+          body: |
+            ## 🚀 God of War III Remastered - Single Executable Release
+
+            Tek tıkla çalışan taşınabilir yürütülebilir dosyalar (Single Executables):
+
+            ### 📦 İndirme Seçenekleri:
+            - 🐧 **Linux (AppImage - Tek Dosya Kurulumsuz):** [`God_of_War_III_Launcher-x86_64.AppImage`](./God_of_War_III_Launcher-x86_64.AppImage)
+              - *Kullanım:* İndirin, sağ tıklayıp özelliklerden "Çalıştırılabilir yap" (veya `chmod +x`) deyin ve çift tıklayın!
+            - 🪟 **Windows (Portable Exe - Kurulumsuz):** [`God_of_War_III_Launcher-Windows.exe`](./God_of_War_III_Launcher-Windows.exe) / [`gow3-launcher-win.exe`](./gow3-launcher-win.exe)
+            - 🐧 **Linux (Native ELF):** [`gow3-launcher`](./gow3-launcher)
+
+            ### ✨ Yenilikler (${{ github.ref_name }})
+            - **AppImage Desteği:** Linux üzerinde bağımlılık derdi olmadan tek tıkla çalışan resmi AppImage paketi.
+            - **Windows Portable Exe:** Harici dosyalara ihtiyaç duymadan kendi simgesi ve arayüzüyle açılan taşınabilir Windows sürümü.
+            - **Akıllı Konum & Donanım Tespiti:** Launcher artık doğrudan kendi bulunduğu dizini tanır, taşınabilir çalışır.
+            - **Gelişmiş Oyun Arama:** Disklerde oyun bulunamadığında açıklayıcı modal uyarı penceresi ve anlık doğrulama.
+            - **Otomatik Yama & FPS Ayarları:** 60/120/144/240 Hz pacing, sarı doku önleme ve sinematik atlama.
+          files: |
+            ./dist/God_of_War_III_Launcher-x86_64.AppImage
+            ./dist/God_of_War_III_Launcher-Windows.exe
+            ./dist/gow3-launcher-win.exe
+            ./dist/gow3-launcher
+        env:
+          GITHUB_TOKEN: ${{ secrets.GITHUB_TOKEN }}
@@ -1,11 +1,11 @@
-# gow3_pclauncher
-Launcher for God Of War 3 PC on Linux
+# gow3_launcher
+Launcher for God Of War 3 PC on Linux and Windows

- # ⚡ God of War® III Remastered - Linux Port & Native Launcher                                                                                                                        
+ # ⚡ God of War® III Remastered - Linux-Windows Port & Native Launcher                                                                                                                        
                                                                                                                                                                                          
-   An optimized Linux port and native graphical launcher for **God of War® III Remastered** (*CUSA01623 / CUSA01715*), featuring hardware auto-tuning, 144Hz Delta-Time synchronization, crash diagnostics, and upstream GitHub integration.                                                                                                                                     
+   An optimized Linux-Windows port and native graphical launcher for **God of War® III Remastered** (*CUSA01623 / CUSA01715*), featuring hardware auto-tuning, 144Hz Delta-Time synchronization, crash diagnostics, and upstream GitHub integration.                                                                                                                                     
                                                                                                                                                                                          
-   [![Platform](https://img.shields.io/badge/Platform-Linux%20%7C%20Steam%20Deck-orange.svg)](https://kernel.org)                                                                        
+   [![Platform](https://img.shields.io/badge/Platform-Windows%20%7C%20Linux%20%7C%20Steam%20Deck-orange.svg)](https://kernel.org)                                                                        
   [![Launcher](https://img.shields.io/badge/Launcher-Rust%20%2F%20egui-blue.svg)](https://www.rust-lang.org)                                                                            
   [![Vulkan](https://img.shields.io/badge/Graphics-Vulkan%201.3-red.svg)](https://www.vulkan.org)                                                                                       
   [![License](https://img.shields.io/badge/License-GPLv2-green.svg)](LICENSE)                                                                                                           
@@ -24,19 +24,28 @@ Launcher for God Of War 3 PC on Linux
  directories.                                                                                                                                                                            
    - 🚨 **Crash & Error Diagnostic Assistant:** Automatically analyzes `gow3_log.txt` on exit. If an unexpected crash occurs, it displays a plain-language diagnosis and recommended fix.
    - 🔄 **GitHub Upstream Sync & Auto-Updater:** Checks upstream ([R-V-L/gow3_pc](https://github.com/R-V-L/gow3_pc)) for updates and re-applies all your custom directory paths, 144Hz patches, and VRAM budgets seamlessly.                                                                                                                
-   - 🌐 **Multi-Language Support:** Available in **Turkish 🇹🇷**, **English 🇬🇧**, **German 🇩🇪**, and **Spanish 🇪🇸**.                                                                      
-                                                                                                                                                                                          
+   - 🌐 **Multi-Language Support:** Available in **Turkish 🇹🇷**, **English 🇬🇧**, **German 🇩🇪**, and **Spanish 🇪🇸**.                                                                     
+
                                                                                                                                                                                       
                                                                                                                                                                                          
   ## 📋 System Requirements                                                                                                                                                             
                                                                                                                                                                                          
   | Component | Minimum | Recommended |                                                                                                                                                 
   |---|---|---|                                                                                                                                                                         
-   | **OS** | Linux (Arch, Ubuntu, Fedora, SteamOS, Debian) | Any modern 64-bit Linux distro |                                                                                           
+   | **OS** | Linux (Arch, Ubuntu, Fedora, SteamOS, Debian) and Windows 10-11 | Any modern 64-bit Linux distro |                                                                                         
   | **CPU** | 6-core x86_64 processor | 8-core / 16-thread modern CPU |                                                                                                                 
   | **GPU** | Vulkan 1.3 compatible (4 GB VRAM) | Vulkan 1.3+ (6 GB+ VRAM, Nvidia / AMD) |                                                                                              
   | **RAM** | 8 GB | 16 GB+ |                                                                                                                                                           
-   | **Dependencies** | Python 3, Vulkan drivers | `gamemode` (optional) |                                                                                                               
+   | **Dependencies** | Python 3, Vulkan drivers | `gamemode` (optional) |     
+
+   ## Video
+   
+   You can watch the video for details.
+
+   <p align="center">
+  <a href="https://www.youtube.com/watch?v=-yGAEjdQGzE"><img width="1920" height="1080" alt="vlc_ie5PhePn2o" src="https://github.com/user-attachments/assets/190f531e-55b0-4a4a-b883-440cd615a18a" /></a>
+</p>
+
                                                                                                                                                                                          
                                                                                                                                                                                       
                                                                                                                                                                                          
@@ -46,8 +55,8 @@ Launcher for God Of War 3 PC on Linux
   
   **Option A: Clone with Git**
   ```bash
-   git clone https://github.com/ScreamAngel/gow3_pclauncher.git
-   cd gow3_pclauncher
+   git clone https://github.com/ScreamAngel/gow3_launcher.git
+   cd gow3_launcher
   ```
   - 🐧 **On Linux**: `./gow3-launcher`
   - 🪟 **On Windows**: `gow3-launcher-win.exe`
@@ -55,9 +64,13 @@ Launcher for God Of War 3 PC on Linux
   **Option B: Download Pre-compiled Binaries (GitHub Releases)**
   Download the executables directly from the GitHub Releases tab:
   - **Linux**: `gow3-launcher`
-   - **Windows / Dual-Boot**: `gow3-launcher-win.exe`
+   - **Windows**: `gow3-launcher-win.exe`

   The launcher is completely standalone: it automatically detects your hardware, verifies the game dump, configures settings files, and applies all required patches without requiring external bash scripts.
+
+
+   <img width="1920" height="1016" alt="gow3_launcher_win_BJ42UCuIvf" src="https://github.com/user-attachments/assets/3d57aaed-8869-446e-bdb7-89491275039d" />
+
                                                                                                                                                                                      
                                                                                                                                                                                          
   ### 2. Add Your Game Dump                                                                                                                                                             
@@ -75,6 +88,9 @@ Launcher for God Of War 3 PC on Linux
   .\gow3-launcher-win.exe --play
   ```

+<img width="1920" height="1080" alt="gow3-probe_Hz51yYBACH" src="https://github.com/user-attachments/assets/651de8e7-15b9-454c-ab6d-a09dbd71f44e" />
+
+
   ### 🔄 Dual-Boot Ready
   Both `gow3-launcher` and `gow3-launcher-win.exe` live side-by-side in the same directory. If you dual-boot between Linux and Windows, you can play on either operating system seamlessly while sharing the same game dumps and configurations!
                                                                                                                                                                                          
@@ -115,12 +131,12 @@ Launcher for God Of War 3 PC on Linux
  
   ## 📜 Credits & Acknowledgments                                                                                                                                                       

-   - **Original Project:** https://github.com/FelipePrado0/gow3_pc
+   - **Original Project:** [FelipePrado0](https://github.com/FelipePrado0/gow3_pc)
   - **Upstream Linux Port & Probe:** Developed by [R-V-L](https://github.com/R-V-L/gow3_pc) and community contributors.
   - **Launcher & Hardware Tuner:** Built with Rust, [egui/eframe](https://github.com/emilk/egui).
  
   > **Disclaimer:** God of War is a registered trademark of Sony Interactive Entertainment LLC and Santa Monica Studio. This repository **does not contain any copyrighted game assets, ROMs, or binaries**. Users must supply their own legally obtained game files.
    

-   #Licence
+  ## License
   GNU GPL v2 or later ([LICENSE](https://github.com/R-V-L/gow3_pc/blob/main/LICENSE)). Third-party components keep their own licenses.
@@ -2,6 +2,137 @@ use serde::{Deserialize, Serialize};
 use std::fs;
 use std::path::{Path, PathBuf};

+#[derive(Debug, Clone, Copy, PartialEq, Eq, Serialize, Deserialize, Default)]
+pub enum DisplayMode {
+    #[default]
+    Borderless,
+    Fullscreen,
+    Windowed,
+}
+
+impl DisplayMode {
+    pub fn as_str(&self) -> &'static str {
+        match self {
+            DisplayMode::Borderless => "borderless",
+            DisplayMode::Fullscreen => "fullscreen",
+            DisplayMode::Windowed => "windowed",
+        }
+    }
+
+    pub fn to_toml_mode(&self) -> (&'static str, bool) {
+        match self {
+            DisplayMode::Borderless => ("Borderless", true),
+            DisplayMode::Fullscreen => ("Fullscreen", true),
+            DisplayMode::Windowed => ("Windowed", false),
+        }
+    }
+}
+
+#[derive(Debug, Clone, PartialEq, Eq, Serialize, Deserialize)]
+pub struct KeyboardBindings {
+    // Face buttons
+    pub triangle: String,
+    pub circle: String,
+    pub cross: String,
+    pub square: String,
+
+    // Shoulder buttons
+    pub l1: String,
+    pub r1: String,
+    pub l2: String,
+    pub r2: String,
+    pub l3: String,
+    pub r3: String,
+
+    // System
+    pub options: String,
+    pub touchpad_center: String,
+
+    // D-Pad
+    pub pad_up: String,
+    pub pad_down: String,
+    pub pad_left: String,
+    pub pad_right: String,
+
+    // Left Stick (Movement)
+    pub axis_left_x_minus: String, // Sol (A)
+    pub axis_left_x_plus: String,  // Sağ (D)
+    pub axis_left_y_minus: String, // İleri (W)
+    pub axis_left_y_plus: String,  // Geri (S)
+
+    // Right Stick (Camera)
+    pub axis_right_x_minus: String, // Sol (J)
+    pub axis_right_x_plus: String,  // Sağ (L)
+    pub axis_right_y_minus: String, // Yukarı (I)
+    pub axis_right_y_plus: String,  // Aşağı (K)
+}
+
+impl Default for KeyboardBindings {
+    fn default() -> Self {
+        Self::wasd_cvbn()
+    }
+}
+
+impl KeyboardBindings {
+    pub fn wasd_cvbn() -> Self {
+        Self {
+            triangle: "c".to_string(),
+            circle: "b".to_string(),
+            cross: "n".to_string(),
+            square: "v".to_string(),
+            l1: "q".to_string(),
+            r1: "u".to_string(),
+            l2: "e".to_string(),
+            r2: "o".to_string(),
+            l3: "x".to_string(),
+            r3: "m".to_string(),
+            options: "enter".to_string(),
+            touchpad_center: "space".to_string(),
+            pad_up: "up".to_string(),
+            pad_down: "down".to_string(),
+            pad_left: "left".to_string(),
+            pad_right: "right".to_string(),
+            axis_left_x_minus: "a".to_string(),
+            axis_left_x_plus: "d".to_string(),
+            axis_left_y_minus: "w".to_string(),
+            axis_left_y_plus: "s".to_string(),
+            axis_right_x_minus: "j".to_string(),
+            axis_right_x_plus: "l".to_string(),
+            axis_right_y_minus: "i".to_string(),
+            axis_right_y_plus: "k".to_string(),
+        }
+    }
+
+    pub fn wasd_numpad() -> Self {
+        Self {
+            triangle: "kp8".to_string(),
+            circle: "kp6".to_string(),
+            cross: "kp2".to_string(),
+            square: "kp4".to_string(),
+            l1: "q".to_string(),
+            r1: "u".to_string(),
+            l2: "e".to_string(),
+            r2: "o".to_string(),
+            l3: "x".to_string(),
+            r3: "m".to_string(),
+            options: "enter".to_string(),
+            touchpad_center: "space".to_string(),
+            pad_up: "up".to_string(),
+            pad_down: "down".to_string(),
+            pad_left: "left".to_string(),
+            pad_right: "right".to_string(),
+            axis_left_x_minus: "a".to_string(),
+            axis_left_x_plus: "d".to_string(),
+            axis_left_y_minus: "w".to_string(),
+            axis_left_y_plus: "s".to_string(),
+            axis_right_x_minus: "j".to_string(),
+            axis_right_x_plus: "l".to_string(),
+            axis_right_y_minus: "i".to_string(),
+            axis_right_y_plus: "k".to_string(),
+        }
+    }
+}
+
 #[derive(Debug, Clone, Serialize, Deserialize)]
 pub struct CachedHardware {
    pub gpu_name: String,
@@ -47,6 +178,26 @@ pub struct LauncherConfig {
    pub cached_hardware: CachedHardware,
    #[serde(default = "default_last_commit")]
    pub last_git_commit: String,
+
+    // Display settings
+    #[serde(default)]
+    pub display_mode: DisplayMode,
+    #[serde(default = "default_true")]
+    pub vsync: bool,
+
+    // Controller settings
+    #[serde(default)]
+    pub background_controller_input: bool,
+    #[serde(default = "default_true")]
+    pub is_motion_controls_enabled: bool,
+    #[serde(default = "default_deadzone")]
+    pub deadzone_left: u32,
+    #[serde(default = "default_deadzone")]
+    pub deadzone_right: u32,
+
+    // Keyboard bindings
+    #[serde(default)]
+    pub keyboard_bindings: KeyboardBindings,
 }

 fn default_language() -> String {
@@ -58,6 +209,9 @@ fn default_target_fps() -> u32 {
 fn default_true() -> bool {
    true
 }
+fn default_deadzone() -> u32 {
+    2
+}
 fn default_vram_budget() -> u64 {
    6144
 }
@@ -83,6 +237,13 @@ impl Default for LauncherConfig {
            dmem_mb: default_dmem(),
            cached_hardware: CachedHardware::default(),
            last_git_commit: default_last_commit(),
+            display_mode: DisplayMode::default(),
+            vsync: true,
+            background_controller_input: false,
+            is_motion_controls_enabled: true,
+            deadzone_left: default_deadzone(),
+            deadzone_right: default_deadzone(),
+            keyboard_bindings: KeyboardBindings::default(),
        }
    }
 }
@@ -111,4 +272,165 @@ impl LauncherConfig {
        let content = serde_json::to_string_pretty(self)?;
        fs::write(path, content)
    }
+
+    pub fn build_gow3_key_map(&self) -> String {
+        let b = &self.keyboard_bindings;
+        let to_sdl = |k: &str| -> String {
+            let k_low = k.trim().to_lowercase();
+            match k_low.as_str() {
+                "enter" | "return" => "Return".to_string(),
+                "space" => "Space".to_string(),
+                "escape" | "esc" => "Escape".to_string(),
+                "backspace" => "Backspace".to_string(),
+                "tab" => "Tab".to_string(),
+                "up" => "Up".to_string(),
+                "down" => "Down".to_string(),
+                "left" => "Left".to_string(),
+                "right" => "Right".to_string(),
+                s if s.starts_with("kp") && s.len() == 3 && s[2..].chars().all(|c| c.is_ascii_digit()) => {
+                    format!("Keypad {}", &s[2..])
+                }
+                "shift" | "lshift" => "Left Shift".to_string(),
+                "rshift" => "Right Shift".to_string(),
+                "ctrl" | "lctrl" => "Left Ctrl".to_string(),
+                "rctrl" => "Right Ctrl".to_string(),
+                "alt" | "lalt" => "Left Alt".to_string(),
+                "ralt" => "Right Alt".to_string(),
+                s if s.len() == 1 => s.to_uppercase(),
+                s => s.to_string(),
+            }
+        };
+
+        format!(
+            "triangle={},square={},circle={},cross={},l1={},r1={},l2={},r2={},l3={},r3={},options={},touchpad={},up={},down={},left={},right={}",
+            to_sdl(&b.triangle),
+            to_sdl(&b.square),
+            to_sdl(&b.circle),
+            to_sdl(&b.cross),
+            to_sdl(&b.l1),
+            to_sdl(&b.r1),
+            to_sdl(&b.l2),
+            to_sdl(&b.r2),
+            to_sdl(&b.l3),
+            to_sdl(&b.r3),
+            to_sdl(&b.options),
+            to_sdl(&b.touchpad_center),
+            to_sdl(&b.pad_up),
+            to_sdl(&b.pad_down),
+            to_sdl(&b.pad_left),
+            to_sdl(&b.pad_right),
+        )
+    }
+
+    pub fn build_gow3_pad_map(&self) -> &'static str {
+        "cross=a,circle=b,square=x,triangle=y,l1=leftshoulder,r1=rightshoulder,l3=leftstick,r3=rightstick,options=start,touchpad=back,up=dpup,down=dpdown,left=dpleft,right=dpright"
+    }
+}
+
+pub fn key_to_sdl_scancode(key: &str) -> Option<u8> {
+    let lower = key.trim().to_lowercase();
+    match lower.as_str() {
+        // Letters (SDL_SCANCODE_A = 4 .. SDL_SCANCODE_Z = 29)
+        "a" => Some(4),
+        "b" => Some(5),
+        "c" => Some(6),
+        "d" => Some(7),
+        "e" => Some(8),
+        "f" => Some(9),
+        "g" => Some(10),
+        "h" => Some(11),
+        "i" => Some(12),
+        "j" => Some(13),
+        "k" => Some(14),
+        "l" => Some(15),
+        "m" => Some(16),
+        "n" => Some(17),
+        "o" => Some(18),
+        "p" => Some(19),
+        "q" => Some(20),
+        "r" => Some(21),
+        "s" => Some(22),
+        "t" => Some(23),
+        "u" => Some(24),
+        "v" => Some(25),
+        "w" => Some(26),
+        "x" => Some(27),
+        "y" => Some(28),
+        "z" => Some(29),
+
+        // Number row (SDL_SCANCODE_1 = 30 .. SDL_SCANCODE_0 = 39)
+        "1" => Some(30),
+        "2" => Some(31),
+        "3" => Some(32),
+        "4" => Some(33),
+        "5" => Some(34),
+        "6" => Some(35),
+        "7" => Some(36),
+        "8" => Some(37),
+        "9" => Some(38),
+        "0" => Some(39),
+
+        // Controls
+        "enter" | "return" => Some(40),
+        "escape" | "esc" => Some(41),
+        "backspace" => Some(42),
+        "tab" => Some(43),
+        "space" => Some(44),
+
+        // Function keys (SDL_SCANCODE_F1 = 58 ... F12 = 69)
+        "f1" => Some(58),
+        "f2" => Some(59),
+        "f3" => Some(60),
+        "f4" => Some(61),
+        "f5" => Some(62),
+        "f6" => Some(63),
+        "f7" => Some(64),
+        "f8" => Some(65),
+        "f9" => Some(66),
+        "f10" => Some(67),
+        "f11" => Some(68),
+        "f12" => Some(69),
+
+        // Navigation
+        "insert" => Some(73),
+        "home" => Some(74),
+        "pageup" | "prior" => Some(75),
+        "delete" => Some(76),
+        "end" => Some(77),
+        "pagedown" | "next" => Some(78),
+
+        // Arrow keys
+        "right" => Some(79),
+        "left" => Some(80),
+        "down" => Some(81),
+        "up" => Some(82),
+
+        // Numpad (SDL_SCANCODE_KP_1 = 89 .. SDL_SCANCODE_KP_0 = 98)
+        "kp_divide" | "kpdivide" | "numdivide" => Some(84),
+        "kp_multiply" | "kpmultiply" | "nummultiply" => Some(85),
+        "kp_minus" | "kpminus" | "numminus" => Some(86),
+        "kp_plus" | "kpplus" | "numplus" => Some(87),
+        "kp_enter" | "kpenter" | "numenter" => Some(88),
+        "kp1" | "num1" | "numpad1" | "numpad 1" => Some(89),
+        "kp2" | "num2" | "numpad2" | "numpad 2" => Some(90),
+        "kp3" | "num3" | "numpad3" | "numpad 3" => Some(91),
+        "kp4" | "num4" | "numpad4" | "numpad 4" => Some(92),
+        "kp5" | "num5" | "numpad5" | "numpad 5" => Some(93),
+        "kp6" | "num6" | "numpad6" | "numpad 6" => Some(94),
+        "kp7" | "num7" | "numpad7" | "numpad 7" => Some(95),
+        "kp8" | "num8" | "numpad8" | "numpad 8" => Some(96),
+        "kp9" | "num9" | "numpad9" | "numpad 9" => Some(97),
+        "kp0" | "num0" | "numpad0" | "numpad 0" => Some(98),
+        "kp_period" | "kpperiod" | "kp_decimal" | "kpdecimal" => Some(99),
+
+        // Modifiers
+        "ctrl" | "lctrl" => Some(224),
+        "shift" | "lshift" => Some(225),
+        "alt" | "lalt" => Some(226),
+        "rctrl" => Some(228),
+        "rshift" => Some(229),
+        "ralt" => Some(230),
+
+        _ => None,
+    }
 }
@@ -16,10 +16,10 @@ impl Language {

    pub fn display_name(&self) -> &'static str {
        match self {
-            Language::Turkish => "🇹🇷 Türkçe",
-            Language::English => "🇬🇧 English",
-            Language::German => "🇩🇪 Deutsch",
-            Language::Spanish => "🇪🇸 Español",
+            Language::Turkish => "Türkçe",
+            Language::English => "English",
+            Language::German => "Deutsch",
+            Language::Spanish => "Español",
        }
    }

@@ -47,8 +47,10 @@ pub fn text(lang: Language, key: &str) -> &'static str {
        // Turkish
        (Language::Turkish, "app_title") => "GOD OF WAR® III REMASTERED",
        (Language::Turkish, "app_subtitle") => "Linux & Windows Port Launcher & Donanım Yöneticisi",
-        (Language::Turkish, "sys_hardware") => "🖥️  Sistem Donanımı",
-        (Language::Turkish, "locked_auto") => "🔒 Kilitli (Otomatik Algılandı)",
+        (Language::Turkish, "tab_game_perf") => "Oyun & Performans",
+        (Language::Turkish, "tab_config_controls") => "Yapılandırma & Kontroller",
+        (Language::Turkish, "sys_hardware") => "Sistem Donanımı",
+        (Language::Turkish, "locked_auto") => "Kilitli (Otomatik Algılandı)",
        (Language::Turkish, "gpu") => "Ekran Kartı (GPU)",
        (Language::Turkish, "vram") => "VRAM Kapasitesi",
        (Language::Turkish, "vram_safe") => "Doku bozulmasına karşı güvenli",
@@ -57,14 +59,14 @@ pub fn text(lang: Language, key: &str) -> &'static str {
        (Language::Turkish, "ram_safe") => "Yeterli Bellek",
        (Language::Turkish, "ram_warning") => "Düşük RAM",
        (Language::Turkish, "refresh_rate") => "Monitör Yenileme",
-        (Language::Turkish, "game_location") => "📂  Oyun Konumu",
+        (Language::Turkish, "game_location") => "Oyun Konumu",
        (Language::Turkish, "no_folder_selected") => "Henüz oyun klasörü belirlenmedi",
-        (Language::Turkish, "manual_select") => "📁 Manuel Seç",
-        (Language::Turkish, "auto_scan") => "🔍 Otomatik Tara",
+        (Language::Turkish, "manual_select") => "Manuel Seç",
+        (Language::Turkish, "auto_scan") => "Otomatik Tara",
        (Language::Turkish, "scanning") => "Taranıyor...",
-        (Language::Turkish, "game_valid") => "✅ Geçerli ve eksiksiz God of War III klasörü doğrulandı",
-        (Language::Turkish, "game_invalid") => "❌ Oyun klasörü eksik, bozuk veya 'eboot.bin' bulunamadı!",
-        (Language::Turkish, "patches_header") => "⚙️  Yamalar & Performans Ayarları",
+        (Language::Turkish, "game_valid") => "Geçerli ve eksiksiz God of War III klasörü doğrulandı",
+        (Language::Turkish, "game_invalid") => "Oyun klasörü eksik, bozuk veya 'eboot.bin' bulunamadı!",
+        (Language::Turkish, "patches_header") => "Yamalar & Performans Ayarları",
        (Language::Turkish, "hz_patch") => "Ekran Hızı (Hz) Senkronizasyon Yaması",
        (Language::Turkish, "hz_desc") => "60 FPS orijinal oyun hızını korur. 120/144Hz ekranlarda akıcılık için ekranı 120Hz yapmak veya FreeSync/VRR açmak önerilir.",
        (Language::Turkish, "target_fps") => "Hedef FPS:",
@@ -72,185 +74,413 @@ pub fn text(lang: Language, key: &str) -> &'static str {
        (Language::Turkish, "readback_desc") => "Karlı ve parlak sahnelerde dokuların altın sarısına dönüşmesini önler.",
        (Language::Turkish, "skip_cinematics") => "Sinematikleri 'X' Tuşuyla Atlama Yaması",
        (Language::Turkish, "skip_cinematics_desc") => "Ara sahneleri kumandanızın X tuşuna basarak anında geçmenizi sağlar.",
-        (Language::Turkish, "gamemode_toggle") => "🎮 Feral GameMode (gamemoderun)",
+        (Language::Turkish, "gamemode_toggle") => "Feral GameMode (gamemoderun)",
        (Language::Turkish, "gamemode_desc") => "CPU zamanlayıcısını ve GPU performansını oyun için en yüksek seviyeye ayarlar.",
-        (Language::Turkish, "save_apply") => "💾 Ayarları Kaydet ve Uygula",
-        (Language::Turkish, "view_log") => "📜 Log Dosyasını Görüntüle",
+        (Language::Turkish, "save_apply") => "Ayarları Kaydet ve Uygula",
+        (Language::Turkish, "view_log") => "Log Dosyasını Görüntüle",
        (Language::Turkish, "play_ready") => "OYUNU BAŞLAT",
-        (Language::Turkish, "play_running") => "⏳ OYUN ÇALIŞIYOR...",
-        (Language::Turkish, "play_disabled_warn") => "⚠️ Buton Devre Dışı: Eksiksiz God of War III klasörü bulunamadı!",
+        (Language::Turkish, "play_running") => "OYUN ÇALIŞIYOR...",
+        (Language::Turkish, "force_quit_btn") => "Zorla Kapat",
+        (Language::Turkish, "force_quit_tooltip") => "Oyun kilitlendiğinde veya kapanmadığında süreci anında zorla sonlandırır.",
+        (Language::Turkish, "force_quit_status") => "Oyun süreci zorla sonlandırıldı.",
+        (Language::Turkish, "kill_leftover_btn") => "Süreci Sonlandır",
+        (Language::Turkish, "kill_leftover_tooltip") => "Arka planda takılı kalmış oyun süreçlerini (gow3-probe) temizler.",
+        (Language::Turkish, "play_disabled_warn") => "Buton Devre Dışı: Eksiksiz God of War III klasörü bulunamadı!",
        (Language::Turkish, "play_disabled_help") => "Lütfen yukarıdaki 'Otomatik Tara' veya 'Manuel Seç' butonunu kullanarak oyunu ekleyin.",
        (Language::Turkish, "play_subtitle") => "Tüm optimizasyonlar devrede • İyi oyunlar!",
-        (Language::Turkish, "first_launch_title") => "👋 Hoş Geldiniz - God of War III Kurulumu",
+        (Language::Turkish, "first_launch_title") => "Hoş Geldiniz - God of War III Kurulumu",
        (Language::Turkish, "first_launch_prompt") => "God of War III Launcher ilk kez çalıştırılıyor. Sistem donanımınızı ve disklerdeki oyun klasörünü otomatik olarak tarayıp 144 Hz ve doku yamalarını uygulayalım mı?",
-        (Language::Turkish, "first_launch_auto") => "⚡ Otomatik Tara ve Yapılandır",
-        (Language::Turkish, "first_launch_manual") => "🔧 Manuel Olarak Kendim Ayarlayacağım",
-        (Language::Turkish, "candidates_modal_title") => "🎮 Bulunan God of War III Klasörleri",
+        (Language::Turkish, "first_launch_auto") => "Otomatik Tara ve Yapılandır",
+        (Language::Turkish, "first_launch_manual") => "Manuel Olarak Kendim Ayarlayacağım",
+        (Language::Turkish, "candidates_modal_title") => "Bulunan God of War III Klasörleri",
+        (Language::Turkish, "game_not_found_modal_title") => "Oyun Bulunamadı",
+        (Language::Turkish, "game_not_found_title") => "Sistemde God of War III Yüklü Değil!",
+        (Language::Turkish, "game_not_found_desc") => "Diskleriniz tarandı ancak geçerli bir God of War III Remastered (CUSA01623 / CUSA01715) kurulumu tespit edilemedi.\n\n• Oyun henüz sisteminizde yüklü olmayabilir.\n• Oyun harici bir diskte veya özel bir klasördeyse, lütfen aşağıdaki 'Manuel Seç' butonunu kullanarak 'eboot.bin' dosyasının bulunduğu ana oyun klasörünü seçin.",
+        (Language::Turkish, "scan_not_found_inline") => "Sistemde oyun yüklü değil veya klasör bulunamadı! Lütfen oyunu kurun veya 'Manuel Seç' butonunu kullanın.",
        (Language::Turkish, "select_this") => "Bu Klasörü Kullan",
        (Language::Turkish, "close") => "Kapat",
-        (Language::Turkish, "diagnosis_title") => "🚨 Oyun Kapanma & Hata Teşhis Raporu",
+        (Language::Turkish, "diagnosis_title") => "Oyun Kapanma & Hata Teşhis Raporu",
        (Language::Turkish, "diagnosis_desc") => "Açıklama:",
        (Language::Turkish, "diagnosis_solution") => "Önerilen Çözüm:",
-        (Language::Turkish, "diagnosis_log") => "📋 İlgili Log Çıktısı (gow3_log.txt)",
+        (Language::Turkish, "diagnosis_log") => "İlgili Log Çıktısı (gow3_log.txt)",
        (Language::Turkish, "diagnosis_ack") => "Anladım, Kapat",
-        (Language::Turkish, "check_updates") => "🔄 Güncellemeleri Kontrol Et",
-        (Language::Turkish, "checking_updates") => "⏳ Kontrol ediliyor...",
-        (Language::Turkish, "update_modal_title") => "🚀 God of War III Güncellemesi",
-        (Language::Turkish, "up_to_date_title") => "✅ Sisteminiz Güncel",
-        (Language::Turkish, "update_available_notice") => "GitHub deposunda (ScreamAngel/gow3_pclauncher) yeni bir sürüm bulundu!",
-        (Language::Turkish, "up_to_date_notice") => "Tüm yerel dosyalarınız ve launcher en son sürüm ile birebir eşleşiyor.",
-        (Language::Turkish, "update_backup_info") => "Güncelleme uygulandığında launcher ve yama dosyaları en son sürüme güncellenir. Tüm kişisel ayarlarınız korunur.",
-        (Language::Turkish, "apply_update") => "⚡ Güncellemeyi İndir ve Entegre Et",
-        (Language::Turkish, "force_sync") => "🔄 Dosyaları Yeniden Eşitle & Entegre Et",
-        (Language::Turkish, "latest_commit") => "Son Değişiklik:",
+        (Language::Turkish, "check_updates") => "Güncellemeleri Kontrol Et",
+        (Language::Turkish, "checking_updates") => "Kontrol Ediliyor...",
+        (Language::Turkish, "update_modal_title") => "God of War III Güncellemesi",
+        (Language::Turkish, "up_to_date_title") => "Sistem Güncel",
+        (Language::Turkish, "update_available_notice") => "GitHub üzerinde yeni bir güncelleme tespit edildi (ScreamAngel/gow3_launcher)!",
+        (Language::Turkish, "up_to_date_notice") => "Yerel dosyalarınız ve launcher en son sürümle tamamen senkronize.",
+        (Language::Turkish, "update_backup_info") => "Güncelleme sırasında launcher ve yama dosyalarınız otomatik olarak en son sürüme yükseltilir. Ayarlarınız ve kayıtlarınız korunur.",
+        (Language::Turkish, "apply_update") => "Güncellemeyi İndir ve Entegre Et",
+        (Language::Turkish, "force_sync") => "Yeniden Senkronize Et ve Entegre Et",
+        (Language::Turkish, "latest_commit") => "Son Commit:",
        (Language::Turkish, "commit_date") => "Tarih:",
-        (Language::Turkish, "view_on_github") => "🌐 GitHub'da Görüntüle",
+        (Language::Turkish, "view_on_github") => "GitHub'da Görüntüle",
+        (Language::Turkish, "python_dep") => "Python 3 Bağımlılığı:",
+        (Language::Turkish, "python_ready") => "Yüklü / Hazır",
+        (Language::Turkish, "python_missing") => "Bulunamadı",
+        (Language::Turkish, "python_download") => "Taşınabilir Python 3 İndir (~10 MB, Kurulumsuz)",
+        (Language::Turkish, "python_downloading") => "Python 3 indiriliyor ve ayarlanıyor...",
+        (Language::Turkish, "python_download_success") => "Taşınabilir Python 3 başarıyla kuruldu!",
+        (Language::Turkish, "python_download_err") => "Python 3 indirme hatası: ",
+        (Language::Turkish, "engine_label") => "Oyun Motoru:",
+        (Language::Turkish, "engine_ready") => "Yüklü / Hazır (Vulkan Native)",
+        (Language::Turkish, "engine_missing") => "Bulunamadı / Eksik!",
+        (Language::Turkish, "engine_download") => "Oyun Motorunu İndir (~74 MB)",
+        (Language::Turkish, "engine_downloading") => "Motor indiriliyor ve ayarlanıyor...",
+        (Language::Turkish, "engine_download_success") => "Oyun motoru başarıyla kuruldu!",
+        // Turkish Config Tab
+        (Language::Turkish, "display_header") => "Görüntü Modu & Ekran Ayarları",
+        (Language::Turkish, "display_mode") => "Görüntüleme Modu:",
+        (Language::Turkish, "display_borderless") => "Kenarlıksız Pencereli (Borderless - Önerilen)",
+        (Language::Turkish, "display_fullscreen") => "Tam Ekran (Exclusive Fullscreen)",
+        (Language::Turkish, "display_windowed") => "Pencereli (Windowed)",
+        (Language::Turkish, "display_desc") => "Kenarlıksız Pencereli modu çoklu monitörler ve Alt+Tab geçişleri için en kararlı deneyimi sunar.",
+        (Language::Turkish, "vsync") => "Dikey Senkronizasyon (V-Sync)",
+        (Language::Turkish, "vsync_desc") => "Ekran yırtılmalarını önlemek için kare hızını monitör tazeleme hızına kilitler.",
+        (Language::Turkish, "controller_header") => "Kumanda / Gamepad Ayarları",
+        (Language::Turkish, "bg_input") => "Arka Planda Kumanda Girişi (Background Input)",
+        (Language::Turkish, "bg_input_desc") => "Oyun penceresi odakta değilken bile kumanda girdilerini algılamaya devam eder.",
+        (Language::Turkish, "motion_controls") => "Hareket / Jiroskop Sensörleri (Gyro / Motion)",
+        (Language::Turkish, "motion_controls_desc") => "DualShock 4 / DualSense dahili hareket algılama sensörlerini etkinleştirir.",
+        (Language::Turkish, "deadzone_left") => "Sol Analog Ölü Bölge (Left Stick Deadzone):",
+        (Language::Turkish, "deadzone_right") => "Sağ Analog Ölü Bölge (Right Stick Deadzone):",
+        (Language::Turkish, "deadzone_desc") => "Düşük değer daha hassas kontrol sağlar; analog çubuğunuzda kendi kendine kayma (drift) varsa değeri artırın.",
+        (Language::Turkish, "keyboard_header") => "Klavye Tuş Atamaları (Keyboard Bindings)",
+        (Language::Turkish, "keyboard_desc") => "Değiştirmek istediğiniz tuşa tıklayın ve yeni tuşa basın. İptal etmek için ESC tuşuna basın.",
+        (Language::Turkish, "preset_label") => "Hızlı Tuş Düzeni (Preset):",
+        (Language::Turkish, "preset_standard") => "Standart WASD + CVBN (Önerilen)",
+        (Language::Turkish, "preset_numpad") => "WASD + Numpad (8462)",
+        (Language::Turkish, "reset_defaults") => "Varsayılanlara Sıfırla",
+        (Language::Turkish, "press_any_key") => "[ Bir tuşa basın... / ESC ]",
+        (Language::Turkish, "sec_face_buttons") => "Eylem Tuşları (Saldırı & Zıplama)",
+        (Language::Turkish, "sec_triggers") => "Tetik & Omuz Tuşları (L1/R1/L2/R2/L3/R3)",
+        (Language::Turkish, "sec_dpad_menu") => "Yön Tuşları & Menü (D-Pad / Options / Touchpad)",
+        (Language::Turkish, "sec_analog_sticks") => "Analog Çubuklar (Hareket & Kamera)",
+        (Language::Turkish, "act_triangle") => "Üçgen (Ağır Saldırı)",
+        (Language::Turkish, "act_square") => "Kare (Hafif Saldırı)",
+        (Language::Turkish, "act_circle") => "Daire (Yakalama)",
+        (Language::Turkish, "act_cross") => "Çarpı (Zıplama)",
+        (Language::Turkish, "act_l1") => "L1 (Savunma / Blok)",
+        (Language::Turkish, "act_r1") => "R1 (Kaçınma / Etkileşim)",
+        (Language::Turkish, "act_l2") => "L2 (Büyü Saldırısı)",
+        (Language::Turkish, "act_r2") => "R2 (Özel Eşya)",
+        (Language::Turkish, "act_l3") => "L3 (Sol Stick Tıklama)",
+        (Language::Turkish, "act_r3") => "R3 (Sağ Stick Tıklama)",
+        (Language::Turkish, "act_options") => "Options (Menü / Duraklat)",
+        (Language::Turkish, "act_touchpad") => "Touchpad (Harita / Seçim)",
+        (Language::Turkish, "act_dpad_up") => "D-Pad Yukarı",
+        (Language::Turkish, "act_dpad_down") => "D-Pad Aşağı",
+        (Language::Turkish, "act_dpad_left") => "D-Pad Sol",
+        (Language::Turkish, "act_dpad_right") => "D-Pad Sağ",
+        (Language::Turkish, "act_move_up") => "Sol Analog: İleri Git",
+        (Language::Turkish, "act_move_down") => "Sol Analog: Geri Git",
+        (Language::Turkish, "act_move_left") => "Sol Analog: Sola Git",
+        (Language::Turkish, "act_move_right") => "Sol Analog: Sağa Git",
+        (Language::Turkish, "act_cam_up") => "Sağ Analog: Yukarı",
+        (Language::Turkish, "act_cam_down") => "Sağ Analog: Aşağı",
+        (Language::Turkish, "act_cam_left") => "Sağ Analog: Sol",
+        (Language::Turkish, "act_cam_right") => "Sağ Analog: Sağ",

        // English
        (Language::English, "app_title") => "GOD OF WAR® III REMASTERED",
-        (Language::English, "app_subtitle") => "Linux & Windows Native Port Launcher & Hardware Optimizer",
-        (Language::English, "sys_hardware") => "🖥️  System Hardware",
-        (Language::English, "locked_auto") => "🔒 Locked (Auto-detected)",
+        (Language::English, "app_subtitle") => "Linux & Windows Port Launcher & Hardware Manager",
+        (Language::English, "tab_game_perf") => "Game & Performance",
+        (Language::English, "tab_config_controls") => "Settings & Controls",
+        (Language::English, "sys_hardware") => "System Hardware",
+        (Language::English, "locked_auto") => "Locked (Auto Detected)",
        (Language::English, "gpu") => "Graphics Card (GPU)",
        (Language::English, "vram") => "VRAM Capacity",
-        (Language::English, "vram_safe") => "Safe from texture corruption",
-        (Language::English, "vram_warning") => "Low VRAM (Glitch risk)",
+        (Language::English, "vram_safe") => "Safe against texture corruption",
+        (Language::English, "vram_warning") => "Low VRAM (Corruption risk)",
        (Language::English, "ram") => "System Memory (RAM)",
-        (Language::English, "ram_safe") => "Sufficient RAM",
+        (Language::English, "ram_safe") => "Sufficient Memory",
        (Language::English, "ram_warning") => "Low RAM",
-        (Language::English, "refresh_rate") => "Monitor Refresh",
-        (Language::English, "game_location") => "📂  Game Location",
-        (Language::English, "no_folder_selected") => "No game directory selected yet",
-        (Language::English, "manual_select") => "📁 Browse Folder",
-        (Language::English, "auto_scan") => "🔍 Auto Scan",
+        (Language::English, "refresh_rate") => "Display Refresh",
+        (Language::English, "game_location") => "Game Location",
+        (Language::English, "no_folder_selected") => "No game directory configured yet",
+        (Language::English, "manual_select") => "Browse",
+        (Language::English, "auto_scan") => "Auto Scan",
        (Language::English, "scanning") => "Scanning...",
-        (Language::English, "game_valid") => "✅ Complete and valid God of War III directory verified",
-        (Language::English, "game_invalid") => "❌ Game directory incomplete, corrupted, or 'eboot.bin' missing!",
-        (Language::English, "patches_header") => "⚙️  Patches & Performance Settings",
-        (Language::English, "hz_patch") => "Refresh Rate (Hz) Sync Patch",
-        (Language::English, "hz_desc") => "60 FPS maintains intended game speed. For 144Hz smoothness, set monitor to 120Hz or enable FreeSync/VRR.",
+        (Language::English, "game_valid") => "Valid and complete God of War III directory verified",
+        (Language::English, "game_invalid") => "Missing game folder or 'eboot.bin' not found!",
+        (Language::English, "patches_header") => "Patches & Optimizations",
+        (Language::English, "hz_patch") => "Display Rate (Hz) Sync Patch",
+        (Language::English, "hz_desc") => "Preserves original 60 FPS game speed. On 120/144Hz displays, setting 120Hz or enabling VRR is recommended.",
        (Language::English, "target_fps") => "Target FPS:",
-        (Language::English, "readback_patch") => "Yellow Texture Glitch Fix (Instant Readbacks)",
-        (Language::English, "readback_desc") => "Prevents textures from turning golden-yellow in snowy scenes.",
-        (Language::English, "skip_cinematics") => "Skip Cinematics with 'X' Button",
-        (Language::English, "skip_cinematics_desc") => "Allows skipping in-game cutscenes instantly by pressing the X button.",
-        (Language::English, "gamemode_toggle") => "🎮 Feral GameMode (gamemoderun)",
-        (Language::English, "gamemode_desc") => "Optimizes CPU governor and GPU clocks for peak gaming performance.",
-        (Language::English, "save_apply") => "💾 Save & Apply Settings",
-        (Language::English, "view_log") => "📜 View Log File",
-        (Language::English, "play_ready") => "PLAY GAME",
-        (Language::English, "play_running") => "⏳ GAME RUNNING...",
-        (Language::English, "play_disabled_warn") => "⚠️ Button Disabled: Complete God of War III directory not found!",
-        (Language::English, "play_disabled_help") => "Please use 'Auto Scan' or 'Browse Folder' to locate your game files.",
-        (Language::English, "play_subtitle") => "All optimizations enabled • Enjoy the game!",
-        (Language::English, "first_launch_title") => "👋 Welcome - God of War III Setup",
-        (Language::English, "first_launch_prompt") => "God of War III Launcher opened for the first time. Would you like to automatically scan hardware and game files to apply optimal 144Hz and texture patches?",
-        (Language::English, "first_launch_auto") => "⚡ Auto Scan & Configure",
-        (Language::English, "first_launch_manual") => "🔧 I will configure manually",
-        (Language::English, "candidates_modal_title") => "🎮 Found God of War III Directories",
+        (Language::English, "readback_patch") => "Yellow Texture Corruption Fix (Instant Readbacks)",
+        (Language::English, "readback_desc") => "Prevents textures turning gold/yellow in snowy and bright scenes.",
+        (Language::English, "skip_cinematics") => "Skip Cutscenes with 'X' Button",
+        (Language::English, "skip_cinematics_desc") => "Allows skipping any cutscene immediately by pressing the X button.",
+        (Language::English, "gamemode_toggle") => "Feral GameMode (gamemoderun)",
+        (Language::English, "gamemode_desc") => "Configures CPU governor and GPU clocks for optimal gaming performance.",
+        (Language::English, "save_apply") => "Save & Apply Settings",
+        (Language::English, "view_log") => "View Log File",
+        (Language::English, "play_ready") => "LAUNCH GAME",
+        (Language::English, "play_running") => "GAME IS RUNNING...",
+        (Language::English, "force_quit_btn") => "Force Quit",
+        (Language::English, "force_quit_tooltip") => "Immediately kills the game process if it hangs or freezes.",
+        (Language::English, "force_quit_status") => "Game process was forcefully terminated.",
+        (Language::English, "kill_leftover_btn") => "Kill Process",
+        (Language::English, "kill_leftover_tooltip") => "Kills any hanging or leftover background game processes (gow3-probe).",
+        (Language::English, "play_disabled_warn") => "Button Disabled: Valid God of War III folder not found!",
+        (Language::English, "play_disabled_help") => "Please use 'Auto Scan' or 'Browse' button above to select your game folder.",
+        (Language::English, "play_subtitle") => "All optimizations active • Enjoy playing!",
+        (Language::English, "first_launch_title") => "Welcome - God of War III Setup",
+        (Language::English, "first_launch_prompt") => "God of War III Launcher is running for the first time. Would you like to automatically scan for the game and configure optimal patches?",
+        (Language::English, "first_launch_auto") => "Auto Scan & Configure",
+        (Language::English, "first_launch_manual") => "I Will Configure Manually",
+        (Language::English, "candidates_modal_title") => "Found God of War III Directories",
+        (Language::English, "game_not_found_modal_title") => "Game Not Found",
+        (Language::English, "game_not_found_title") => "God of War III is not installed on this system!",
+        (Language::English, "game_not_found_desc") => "Drives were scanned but no valid God of War III Remastered (CUSA01623 / CUSA01715) installation was detected.\n\n• The game might not be installed on your computer yet.\n• If the game is on an external drive or custom path, please click 'Browse' below and choose the folder containing 'eboot.bin'.",
+        (Language::English, "scan_not_found_inline") => "Game is not installed or folder not found! Please install the game or use 'Browse'.",
        (Language::English, "select_this") => "Use This Folder",
        (Language::English, "close") => "Close",
-        (Language::English, "diagnosis_title") => "🚨 Game Crash & Error Diagnosis Report",
+        (Language::English, "diagnosis_title") => "Crash & Error Diagnosis Report",
        (Language::English, "diagnosis_desc") => "Description:",
-        (Language::English, "diagnosis_solution") => "Recommended Fix:",
-        (Language::English, "diagnosis_log") => "📋 Relevant Log Snippet (gow3_log.txt)",
+        (Language::English, "diagnosis_solution") => "Recommended Solution:",
+        (Language::English, "diagnosis_log") => "Relevant Log Snippet (gow3_log.txt)",
        (Language::English, "diagnosis_ack") => "Understood, Close",
-        (Language::English, "check_updates") => "🔄 Check for Updates",
-        (Language::English, "checking_updates") => "⏳ Checking...",
-        (Language::English, "update_modal_title") => "🚀 God of War III Update",
-        (Language::English, "up_to_date_title") => "✅ System Up to Date",
-        (Language::English, "update_available_notice") => "A new version was found on GitHub (ScreamAngel/gow3_pclauncher)!",
-        (Language::English, "up_to_date_notice") => "Your local launcher and files match the latest release.",
-        (Language::English, "update_backup_info") => "Applying the update will upgrade the launcher and patch files to the latest version. All your settings are preserved.",
-        (Language::English, "apply_update") => "⚡ Download & Integrate Update",
-        (Language::English, "force_sync") => "🔄 Re-sync & Re-integrate Files",
+        (Language::English, "check_updates") => "Check for Updates",
+        (Language::English, "checking_updates") => "Checking...",
+        (Language::English, "update_modal_title") => "God of War III Update",
+        (Language::English, "up_to_date_title") => "System Up to Date",
+        (Language::English, "update_available_notice") => "A new update was found on GitHub (ScreamAngel/gow3_launcher)!",
+        (Language::English, "up_to_date_notice") => "Your local files and launcher are in sync with the latest release.",
+        (Language::English, "update_backup_info") => "Updating will download and apply the newest launcher and patch scripts. Your settings remain untouched.",
+        (Language::English, "apply_update") => "Download & Integrate",
+        (Language::English, "force_sync") => "Re-sync & Integrate",
        (Language::English, "latest_commit") => "Latest Commit:",
        (Language::English, "commit_date") => "Date:",
-        (Language::English, "view_on_github") => "🌐 View on GitHub",
+        (Language::English, "view_on_github") => "View on GitHub",
+        (Language::English, "python_dep") => "Python 3 Dependency:",
+        (Language::English, "python_ready") => "Installed / Ready",
+        (Language::English, "python_missing") => "Missing",
+        (Language::English, "python_download") => "Download Portable Python 3 (~10 MB, No install needed)",
+        (Language::English, "python_downloading") => "Downloading & configuring Python 3...",
+        (Language::English, "python_download_success") => "Portable Python 3 configured successfully!",
+        (Language::English, "python_download_err") => "Python 3 download error: ",
+        (Language::English, "engine_label") => "Game Engine:",
+        (Language::English, "engine_ready") => "Installed / Ready (Vulkan Native)",
+        (Language::English, "engine_missing") => "Not Found / Missing!",
+        (Language::English, "engine_download") => "Download Engine (~74 MB)",
+        (Language::English, "engine_downloading") => "Downloading & configuring game engine...",
+        (Language::English, "engine_download_success") => "Game engine installed successfully!",
+        // English Config Tab
+        (Language::English, "display_header") => "Display Mode & Screen Settings",
+        (Language::English, "display_mode") => "Display Mode:",
+        (Language::English, "display_borderless") => "Borderless Window (Recommended)",
+        (Language::English, "display_fullscreen") => "Exclusive Fullscreen",
+        (Language::English, "display_windowed") => "Windowed",
+        (Language::English, "display_desc") => "Borderless window mode provides the most stable experience for multi-monitor setups and Alt+Tab switching.",
+        (Language::English, "vsync") => "Vertical Sync (V-Sync)",
+        (Language::English, "vsync_desc") => "Synchronizes frame rate with monitor refresh rate to prevent screen tearing.",
+        (Language::English, "controller_header") => "Gamepad & Controller Settings",
+        (Language::English, "bg_input") => "Background Controller Input",
+        (Language::English, "bg_input_desc") => "Allows gamepad inputs even when the game window is not actively focused.",
+        (Language::English, "motion_controls") => "Motion & Gyroscope Controls",
+        (Language::English, "motion_controls_desc") => "Enables DualShock 4 / DualSense internal accelerometer and gyroscope features.",
+        (Language::English, "deadzone_left") => "Left Stick Deadzone:",
+        (Language::English, "deadzone_right") => "Right Stick Deadzone:",
+        (Language::English, "deadzone_desc") => "Lower values provide more responsiveness; increase if your stick suffers from drift.",
+        (Language::English, "keyboard_header") => "Keyboard Bindings",
+        (Language::English, "keyboard_desc") => "Click any button to assign a new key. Press ESC to cancel.",
+        (Language::English, "preset_label") => "Quick Preset:",
+        (Language::English, "preset_standard") => "Standard WASD + CVBN (Recommended)",
+        (Language::English, "preset_numpad") => "WASD + Numpad (8462)",
+        (Language::English, "reset_defaults") => "Reset to Defaults",
+        (Language::English, "press_any_key") => "[ Press key... / ESC ]",
+        (Language::English, "sec_face_buttons") => "Action Buttons (Attacks & Jump)",
+        (Language::English, "sec_triggers") => "Triggers & Shoulder Buttons (L1/R1/L2/R2/L3/R3)",
+        (Language::English, "sec_dpad_menu") => "D-Pad & Menu (Options / Touchpad)",
+        (Language::English, "sec_analog_sticks") => "Analog Sticks (Movement & Camera)",
+        (Language::English, "act_triangle") => "Triangle (Heavy Attack)",
+        (Language::English, "act_square") => "Square (Light Attack)",
+        (Language::English, "act_circle") => "Circle (Grab)",
+        (Language::English, "act_cross") => "Cross (Jump)",
+        (Language::English, "act_l1") => "L1 (Block / Guard)",
+        (Language::English, "act_r1") => "R1 (Evade / Interact)",
+        (Language::English, "act_l2") => "L2 (Magic)",
+        (Language::English, "act_r2") => "R2 (Item)",
+        (Language::English, "act_l3") => "L3 (Left Stick Click)",
+        (Language::English, "act_r3") => "R3 (Right Stick Click)",
+        (Language::English, "act_options") => "Options (Pause / Menu)",
+        (Language::English, "act_touchpad") => "Touchpad (Map / Menu)",
+        (Language::English, "act_dpad_up") => "D-Pad Up",
+        (Language::English, "act_dpad_down") => "D-Pad Down",
+        (Language::English, "act_dpad_left") => "D-Pad Left",
+        (Language::English, "act_dpad_right") => "D-Pad Right",
+        (Language::English, "act_move_up") => "Left Stick: Move Forward",
+        (Language::English, "act_move_down") => "Left Stick: Move Backward",
+        (Language::English, "act_move_left") => "Left Stick: Move Left",
+        (Language::English, "act_move_right") => "Left Stick: Move Right",
+        (Language::English, "act_cam_up") => "Right Stick: Up",
+        (Language::English, "act_cam_down") => "Right Stick: Down",
+        (Language::English, "act_cam_left") => "Right Stick: Left",
+        (Language::English, "act_cam_right") => "Right Stick: Right",

        // German
        (Language::German, "app_title") => "GOD OF WAR® III REMASTERED",
-        (Language::German, "app_subtitle") => "Linux & Windows Nativer Launcher & Hardware-Optimierer",
-        (Language::German, "sys_hardware") => "🖥️  System-Hardware",
-        (Language::German, "locked_auto") => "🔒 Gesperrt (Automatisch erkannt)",
+        (Language::German, "app_subtitle") => "Linux & Windows Port Launcher & Hardware-Manager",
+        (Language::German, "tab_game_perf") => "Spiel & Leistung",
+        (Language::German, "tab_config_controls") => "Konfiguration & Steuerung",
+        (Language::German, "sys_hardware") => "System-Hardware",
+        (Language::German, "locked_auto") => "Gesperrt (Automatisch erkannt)",
        (Language::German, "gpu") => "Grafikkarte (GPU)",
        (Language::German, "vram") => "VRAM-Kapazität",
-        (Language::German, "vram_safe") => "Sicher vor Texturfehlern",
-        (Language::German, "vram_warning") => "Niedriger VRAM (Fehlerrisiko)",
+        (Language::German, "vram_safe") => "Sicher gegen Texturfehler",
+        (Language::German, "vram_warning") => "Wenig VRAM (Fehlerrisiko)",
        (Language::German, "ram") => "Arbeitsspeicher (RAM)",
-        (Language::German, "ram_safe") => "Ausreichend RAM",
-        (Language::German, "ram_warning") => "Niedriger RAM",
+        (Language::German, "ram_safe") => "Ausreichender Speicher",
+        (Language::German, "ram_warning") => "Wenig RAM",
        (Language::German, "refresh_rate") => "Bildwiederholrate",
-        (Language::German, "game_location") => "📂  Spielverzeichnis",
-        (Language::German, "no_folder_selected") => "Noch kein Spielordner ausgewählt",
-        (Language::German, "manual_select") => "📁 Durchsuchen",
-        (Language::German, "auto_scan") => "🔍 Automatisch scannen",
-        (Language::German, "scanning") => "Wird gescannt...",
-        (Language::German, "game_valid") => "✅ Vollständiger God of War III Ordner bestätigt",
-        (Language::German, "game_invalid") => "❌ Spielordner unvollständig oder 'eboot.bin' fehlt!",
-        (Language::German, "patches_header") => "⚙️  Patches & Leistung",
-        (Language::German, "hz_patch") => "Bildwiederholrate (Hz) Sync-Patch",
-        (Language::German, "hz_desc") => "Verhindert 2x Spielbeschleunigung auf 144Hz+ Monitoren.",
+        (Language::German, "game_location") => "Spielverzeichnis",
+        (Language::German, "no_folder_selected") => "Noch kein Spielverzeichnis gewählt",
+        (Language::German, "manual_select") => "Durchsuchen",
+        (Language::German, "auto_scan") => "Auto-Scan",
+        (Language::German, "scanning") => "Scannen...",
+        (Language::German, "game_valid") => "Gültiges God of War III Verzeichnis bestätigt",
+        (Language::German, "game_invalid") => "Spielordner unvollständig oder 'eboot.bin' fehlt!",
+        (Language::German, "patches_header") => "Patches & Optimierungen",
+        (Language::German, "hz_patch") => "Bildwiederholungsrate-Sync-Patch",
+        (Language::German, "hz_desc") => "Verhindert 2x Geschwindigkeitsfehler auf 144Hz+ Monitoren.",
        (Language::German, "target_fps") => "Ziel-FPS:",
-        (Language::German, "readback_patch") => "Gelb-Texturfehler-Korrektur (Instant Readbacks)",
-        (Language::German, "readback_desc") => "Verhindert Gelbfärbung von Texturen in Schneeszenen.",
-        (Language::German, "skip_cinematics") => "Zwischensequenzen mit 'X' überspringen",
+        (Language::German, "readback_patch") => "Gelbe Texturfehler-Behebung (Instant Readbacks)",
+        (Language::German, "readback_desc") => "Verhindert goldgelbe Texturen in Schneeszenen.",
+        (Language::German, "skip_cinematics") => "Zwischensequenzen mit 'X'-Taste überspringen",
        (Language::German, "skip_cinematics_desc") => "Ermöglicht das sofortige Überspringen von Zwischensequenzen mit der X-Taste.",
-        (Language::German, "gamemode_toggle") => "🎮 Feral GameMode (gamemoderun)",
-        (Language::German, "gamemode_desc") => "Optimiert CPU-Taktung und GPU für maximale Gaming-Leistung.",
-        (Language::German, "save_apply") => "💾 Einstellungen speichern & anwenden",
-        (Language::German, "view_log") => "📜 Protokolldatei anzeigen",
+        (Language::German, "gamemode_toggle") => "Feral GameMode (gamemoderun)",
+        (Language::German, "gamemode_desc") => "Optimiert CPU-Governor und GPU für maximale Gaming-Leistung.",
+        (Language::German, "save_apply") => "Einstellungen speichern & anwenden",
+        (Language::German, "view_log") => "Logdatei ansehen",
        (Language::German, "play_ready") => "SPIEL STARTEN",
-        (Language::German, "play_running") => "⏳ SPIEL LÄUFT...",
-        (Language::German, "play_disabled_warn") => "⚠️ Deaktiviert: Vollständiger Ordner nicht gefunden!",
-        (Language::German, "play_disabled_help") => "Bitte scannen Sie oder wählen Sie den Ordner manuell aus.",
+        (Language::German, "play_running") => "SPIEL LÄUFT...",
+        (Language::German, "force_quit_btn") => "Beenden erzwingen",
+        (Language::German, "force_quit_tooltip") => "Beendet den Spielprozess sofort, falls er einfriert oder abstürzt.",
+        (Language::German, "force_quit_status") => "Spielprozess wurde zwangsweise beendet.",
+        (Language::German, "kill_leftover_btn") => "Prozess beenden",
+        (Language::German, "kill_leftover_tooltip") => "Beendet hängende Hintergrundprozesse (gow3-probe).",
+        (Language::German, "play_disabled_warn") => "Button deaktiviert: God of War III nicht gefunden!",
+        (Language::German, "play_disabled_help") => "Bitte nutzen Sie 'Auto-Scan' oder 'Durchsuchen' zum Hinzufügen.",
        (Language::German, "play_subtitle") => "Alle Optimierungen aktiv • Viel Spaß!",
-        (Language::German, "first_launch_title") => "👋 Willkommen - God of War III Einrichtung",
-        (Language::German, "first_launch_prompt") => "Erster Start. Möchten Sie Hardware und Spielordner automatisch scannen und optimieren?",
-        (Language::German, "first_launch_auto") => "⚡ Automatisch scannen & konfigurieren",
-        (Language::German, "first_launch_manual") => "🔧 Manuell konfigurieren",
-        (Language::German, "candidates_modal_title") => "🎮 Gefundene Spielordner",
+        (Language::German, "first_launch_title") => "Willkommen - God of War III Einrichtung",
+        (Language::German, "first_launch_prompt") => "Erster Start. Möchten Sie das Spiel automatisch scannen und konfigurieren?",
+        (Language::German, "first_launch_auto") => "Automatisch scannen & einrichten",
+        (Language::German, "first_launch_manual") => "Manuell konfigurieren",
+        (Language::German, "candidates_modal_title") => "Gefundene Spielordner",
+        (Language::German, "game_not_found_modal_title") => "Spiel nicht gefunden",
+        (Language::German, "game_not_found_title") => "God of War III ist nicht installiert!",
+        (Language::German, "game_not_found_desc") => "Laufwerke wurden durchsucht, aber keine gültige God of War III Installation gefunden.\n\n• Das Spiel ist eventuell noch nicht installiert.\n• Falls es sich auf einem externen Laufwerk befindet, wählen Sie es bitte über 'Durchsuchen' aus.",
+        (Language::German, "scan_not_found_inline") => "Spiel nicht installiert oder Ordner nicht gefunden! Bitte installieren oder 'Durchsuchen' nutzen.",
        (Language::German, "select_this") => "Diesen Ordner wählen",
        (Language::German, "close") => "Schließen",
-        (Language::German, "diagnosis_title") => "🚨 Fehlerdiagnose-Bericht",
+        (Language::German, "diagnosis_title") => "Fehlerdiagnose-Bericht",
        (Language::German, "diagnosis_desc") => "Beschreibung:",
        (Language::German, "diagnosis_solution") => "Empfohlene Lösung:",
-        (Language::German, "diagnosis_log") => "📋 Relevanter Protokollauszug (gow3_log.txt)",
+        (Language::German, "diagnosis_log") => "Relevanter Logauszug (gow3_log.txt)",
        (Language::German, "diagnosis_ack") => "Verstanden, Schließen",
-        (Language::German, "check_updates") => "🔄 Nach Updates suchen",
-        (Language::German, "checking_updates") => "⏳ Wird geprüft...",
-        (Language::German, "update_modal_title") => "🚀 God of War III Aktualisierung",
-        (Language::German, "up_to_date_title") => "✅ Auf dem neuesten Stand",
-        (Language::German, "update_available_notice") => "Eine neue Version wurde auf GitHub gefunden (ScreamAngel/gow3_pclauncher)!",
-        (Language::German, "up_to_date_notice") => "Ihr lokaler Launcher und die Dateien entsprechen der neuesten Version.",
-        (Language::German, "update_backup_info") => "Bei der Aktualisierung werden Launcher und Patch-Dateien auf die neueste Version aktualisiert. Alle Einstellungen bleiben erhalten.",
-        (Language::German, "apply_update") => "⚡ Aktualisieren & Integrieren",
-        (Language::German, "force_sync") => "🔄 Neu synchronisieren",
-        (Language::German, "latest_commit") => "Letzter Commit:",
+        (Language::German, "check_updates") => "Nach Updates suchen",
+        (Language::German, "checking_updates") => "Prüfe...",
+        (Language::German, "update_modal_title") => "God of War III Update",
+        (Language::German, "up_to_date_title") => "System ist aktuell",
+        (Language::German, "update_available_notice") => "Neues Update auf GitHub gefunden (ScreamAngel/gow3_launcher)!",
+        (Language::German, "up_to_date_notice") => "Ihre lokalen Dateien entsprechen der neuesten Version.",
+        (Language::German, "update_backup_info") => "Beim Update werden Launcher und Patches aktualisiert. Ihre Einstellungen bleiben erhalten.",
+        (Language::German, "apply_update") => "Herunterladen & Integrieren",
+        (Language::German, "force_sync") => "Neu synchronisieren & Integrieren",
+        (Language::German, "latest_commit") => "Neuester Commit:",
        (Language::German, "commit_date") => "Datum:",
-        (Language::German, "view_on_github") => "🌐 Auf GitHub ansehen",
+        (Language::German, "view_on_github") => "Auf GitHub ansehen",
+        (Language::German, "python_dep") => "Python 3 Abhängigkeit:",
+        (Language::German, "python_ready") => "Installiert / Bereit",
+        (Language::German, "python_missing") => "Nicht gefunden",
+        (Language::German, "python_download") => "Portables Python 3 herunterladen (~10 MB)",
+        (Language::German, "python_downloading") => "Lade Python 3 herunter...",
+        (Language::German, "python_download_success") => "Portables Python 3 erfolgreich eingerichtet!",
+        (Language::German, "python_download_err") => "Fehler beim Herunterladen von Python 3: ",
+        (Language::German, "engine_label") => "Spiel-Engine:",
+        (Language::German, "engine_ready") => "Installiert / Bereit (Vulkan Native)",
+        (Language::German, "engine_missing") => "Nicht gefunden / Fehlt!",
+        (Language::German, "engine_download") => "Engine herunterladen (~74 MB)",
+        (Language::German, "engine_downloading") => "Lade Spiel-Engine herunter...",
+        (Language::German, "engine_download_success") => "Spiel-Engine erfolgreich installiert!",
+        // German Config Tab
+        (Language::German, "display_header") => "Anzeigemodus & Bildschirmeinstellungen",
+        (Language::German, "display_mode") => "Anzeigemodus:",
+        (Language::German, "display_borderless") => "Randloses Fenster (Empfohlen)",
+        (Language::German, "display_fullscreen") => "Vollbild",
+        (Language::German, "display_windowed") => "Fenster",
+        (Language::German, "display_desc") => "Der randlose Fenstermodus bietet das stabilste Erlebnis für Multi-Monitor-Setups und Alt+Tab.",
+        (Language::German, "vsync") => "Vertikale Synchronisation (V-Sync)",
+        (Language::German, "vsync_desc") => "Synchronisiert die Bildrate mit der Monitor-Bildwiederholfrequenz zur Vermeidung von Tearing.",
+        (Language::German, "controller_header") => "Gamepad- & Controller-Einstellungen",
+        (Language::German, "bg_input") => "Hintergrund-Controller-Eingabe",
+        (Language::German, "bg_input_desc") => "Ermöglicht Gamepad-Eingaben auch wenn das Spielfenster nicht fokussiert ist.",
+        (Language::German, "motion_controls") => "Bewegungs- & Gyrosensoren",
+        (Language::German, "motion_controls_desc") => "Aktiviert interne Beschleunigungsmesser und Gyroskop der DualShock 4 / DualSense Controller.",
+        (Language::German, "deadzone_left") => "Linker Stick Totzone:",
+        (Language::German, "deadzone_right") => "Rechter Stick Totzone:",
+        (Language::German, "deadzone_desc") => "Niedrigere Werte bieten mehr Reaktionsfähigkeit; erhöhen Sie den Wert bei Stick-Drift.",
+        (Language::German, "keyboard_header") => "Tastaturbelegung",
+        (Language::German, "keyboard_desc") => "Klicken Sie auf eine Taste und drücken Sie eine Taste auf der Tastatur. ESC zum Abbrechen.",
+        (Language::German, "preset_label") => "Schnell-Voreinstellung:",
+        (Language::German, "preset_standard") => "Standard WASD + CVBN (Empfohlen)",
+        (Language::German, "preset_numpad") => "WASD + Numpad (8462)",
+        (Language::German, "reset_defaults") => "Auf Standard zurücksetzen",
+        (Language::German, "press_any_key") => "[ Taste drücken... / ESC ]",
+        (Language::German, "sec_face_buttons") => "Aktionstasten (Angriff & Sprung)",
+        (Language::German, "sec_triggers") => "Schultertasten & Trigger (L1/R1/L2/R2/L3/R3)",
+        (Language::German, "sec_dpad_menu") => "Steuerkreuz & Menü (D-Pad / Options / Touchpad)",
+        (Language::German, "sec_analog_sticks") => "Analogsticks (Bewegung & Kamera)",
+        (Language::German, "act_triangle") => "Dreieck (Schwerer Angriff)",
+        (Language::German, "act_square") => "Viereck (Leichter Angriff)",
+        (Language::German, "act_circle") => "Kreis (Greifen)",
+        (Language::German, "act_cross") => "Kreuz (Springen)",
+        (Language::German, "act_l1") => "L1 (Blocken / Parieren)",
+        (Language::German, "act_r1") => "R1 (Ausweichen / Interaktion)",
+        (Language::German, "act_l2") => "L2 (Magie)",
+        (Language::German, "act_r2") => "R2 (Gegenstand)",
+        (Language::German, "act_l3") => "L3 (Linker Stick Klick)",
+        (Language::German, "act_r3") => "R3 (Rechter Stick Klick)",
+        (Language::German, "act_options") => "Options (Pause / Menü)",
+        (Language::German, "act_touchpad") => "Touchpad (Karte / Menü)",
+        (Language::German, "act_dpad_up") => "Steuerkreuz Oben",
+        (Language::German, "act_dpad_down") => "Steuerkreuz Unten",
+        (Language::German, "act_dpad_left") => "Steuerkreuz Links",
+        (Language::German, "act_dpad_right") => "Steuerkreuz Rechts",
+        (Language::German, "act_move_up") => "Linker Stick: Vorwärts",
+        (Language::German, "act_move_down") => "Linker Stick: Rückwärts",
+        (Language::German, "act_move_left") => "Linker Stick: Links",
+        (Language::German, "act_move_right") => "Linker Stick: Rechts",
+        (Language::German, "act_cam_up") => "Rechter Stick: Hoch",
+        (Language::German, "act_cam_down") => "Rechter Stick: Runter",
+        (Language::German, "act_cam_left") => "Rechter Stick: Links",
+        (Language::German, "act_cam_right") => "Rechter Stick: Rechts",

        // Spanish
        (Language::Spanish, "app_title") => "GOD OF WAR® III REMASTERED",
-        (Language::Spanish, "app_subtitle") => "Lanzador y Optimizador para Linux y Windows",
-        (Language::Spanish, "sys_hardware") => "🖥️  Hardware del Sistema",
-        (Language::Spanish, "locked_auto") => "🔒 Bloqueado (Detectado)",
+        (Language::Spanish, "app_subtitle") => "Lanzador de Port Linux y Windows y Gestor de Hardware",
+        (Language::Spanish, "tab_game_perf") => "Juego y Rendimiento",
+        (Language::Spanish, "tab_config_controls") => "Configuración y Controles",
+        (Language::Spanish, "sys_hardware") => "Hardware del Sistema",
+        (Language::Spanish, "locked_auto") => "Bloqueado (Detectado Automáticamente)",
        (Language::Spanish, "gpu") => "Tarjeta Gráfica (GPU)",
        (Language::Spanish, "vram") => "Capacidad VRAM",
-        (Language::Spanish, "vram_safe") => "Seguro contra fallos de textura",
-        (Language::Spanish, "vram_warning") => "VRAM baja (Riesgo de errores)",
+        (Language::Spanish, "vram_safe") => "Protegido contra corrupción de texturas",
+        (Language::Spanish, "vram_warning") => "VRAM baja (Riesgo de corrupción)",
        (Language::Spanish, "ram") => "Memoria del Sistema (RAM)",
-        (Language::Spanish, "ram_safe") => "RAM Suficiente",
-        (Language::Spanish, "ram_warning") => "RAM Baja",
-        (Language::Spanish, "refresh_rate") => "Frecuencia Monitor",
-        (Language::Spanish, "game_location") => "📂  Ubicación del Juego",
-        (Language::Spanish, "no_folder_selected") => "Aún no se ha seleccionado carpeta",
-        (Language::Spanish, "manual_select") => "📁 Explorar",
-        (Language::Spanish, "auto_scan") => "🔍 Escaneo Automático",
+        (Language::Spanish, "ram_safe") => "Memoria suficiente",
+        (Language::Spanish, "ram_warning") => "Memoria RAM baja",
+        (Language::Spanish, "refresh_rate") => "Frecuencia del Monitor",
+        (Language::Spanish, "game_location") => "Ubicación del Juego",
+        (Language::Spanish, "no_folder_selected") => "No se ha seleccionado ninguna carpeta",
+        (Language::Spanish, "manual_select") => "Explorar",
+        (Language::Spanish, "auto_scan") => "Escaneo Automático",
        (Language::Spanish, "scanning") => "Escaneando...",
-        (Language::Spanish, "game_valid") => "✅ Carpeta de God of War III verificada y completa",
-        (Language::Spanish, "game_invalid") => "❌ ¡Carpeta incompleta o falta 'eboot.bin'!",
-        (Language::Spanish, "patches_header") => "⚙️  Parches y Rendimiento",
+        (Language::Spanish, "game_valid") => "Carpeta de God of War III verificada y completa",
+        (Language::Spanish, "game_invalid") => "¡Carpeta incompleta o falta 'eboot.bin'!",
+        (Language::Spanish, "patches_header") => "Parches y Rendimiento",
        (Language::Spanish, "hz_patch") => "Parche de Sincronización Hz",
        (Language::Spanish, "hz_desc") => "Evita la aceleración 2x en pantallas de 144Hz+.",
        (Language::Spanish, "target_fps") => "FPS Objetivo:",
@@ -258,39 +488,113 @@ pub fn text(lang: Language, key: &str) -> &'static str {
        (Language::Spanish, "readback_desc") => "Evita que las texturas se vuelvan amarillas en escenas de nieve.",
        (Language::Spanish, "skip_cinematics") => "Omitir Cinemáticas con el Botón 'X'",
        (Language::Spanish, "skip_cinematics_desc") => "Permite saltar cualquier cinemática o vídeo pulsando el botón X del mando.",
-        (Language::Spanish, "gamemode_toggle") => "🎮 Feral GameMode (gamemoderun)",
+        (Language::Spanish, "gamemode_toggle") => "Feral GameMode (gamemoderun)",
        (Language::Spanish, "gamemode_desc") => "Optimiza la CPU y GPU para máximo rendimiento en juegos.",
-        (Language::Spanish, "save_apply") => "💾 Guardar y Aplicar",
-        (Language::Spanish, "view_log") => "📜 Ver Archivo de Registro",
+        (Language::Spanish, "save_apply") => "Guardar y Aplicar",
+        (Language::Spanish, "view_log") => "Ver Archivo de Registro",
        (Language::Spanish, "play_ready") => "INICIAR JUEGO",
-        (Language::Spanish, "play_running") => "⏳ JUEGO EN EJECUCIÓN...",
-        (Language::Spanish, "play_disabled_warn") => "⚠️ Botón Deshabilitado: ¡Carpeta incompleta!",
+        (Language::Spanish, "play_running") => "JUEGO EN EJECUCIÓN...",
+        (Language::Spanish, "force_quit_btn") => "Forzar Cierre",
+        (Language::Spanish, "force_quit_tooltip") => "Fuerza el cierre inmediato del proceso del juego si se congela o bloquea.",
+        (Language::Spanish, "force_quit_status") => "El proceso del juego fue finalizado a la fuerza.",
+        (Language::Spanish, "kill_leftover_btn") => "Matar Proceso",
+        (Language::Spanish, "kill_leftover_tooltip") => "Elimina procesos colgados en segundo plano (gow3-probe).",
+        (Language::Spanish, "play_disabled_warn") => "Botón Deshabilitado: ¡Carpeta incompleta!",
        (Language::Spanish, "play_disabled_help") => "Use 'Escaneo Automático' o 'Explorar' para seleccionar el juego.",
        (Language::Spanish, "play_subtitle") => "¡Todas las optimizaciones activas • A disfrutar!",
-        (Language::Spanish, "first_launch_title") => "👋 Bienvenido - Configuración de God of War III",
+        (Language::Spanish, "first_launch_title") => "Bienvenido - Configuración de God of War III",
        (Language::Spanish, "first_launch_prompt") => "Primer inicio. ¿Desea escanear y configurar automáticamente?",
-        (Language::Spanish, "first_launch_auto") => "⚡ Escanear y Configurar",
-        (Language::Spanish, "first_launch_manual") => "🔧 Configurar Manualmente",
-        (Language::Spanish, "candidates_modal_title") => "🎮 Carpetas Encontradas",
+        (Language::Spanish, "first_launch_auto") => "Escanear y Configurar",
+        (Language::Spanish, "first_launch_manual") => "Configurar Manualmente",
+        (Language::Spanish, "candidates_modal_title") => "Carpetas Encontradas",
+        (Language::Spanish, "game_not_found_modal_title") => "Juego no encontrado",
+        (Language::Spanish, "game_not_found_title") => "¡God of War III no está instalado!",
+        (Language::Spanish, "game_not_found_desc") => "Se escanearon todas las unidades pero no se encontró una instalación válida de God of War III Remastered (CUSA01623 / CUSA01715).\n\n• Es posible que el juego aún no esté instalado en su sistema.\n• Si el juego está en una unidad externa o carpeta personalizada, use el botón 'Explorar' para seleccionar la carpeta que contiene 'eboot.bin'.",
+        (Language::Spanish, "scan_not_found_inline") => "¡El juego no está instalado en el sistema o no se encontró la carpeta! Por favor instale el juego o use 'Explorar'.",
        (Language::Spanish, "select_this") => "Usar Esta Carpeta",
        (Language::Spanish, "close") => "Cerrar",
-        (Language::Spanish, "diagnosis_title") => "🚨 Informe de Diagnóstico de Error",
+        (Language::Spanish, "diagnosis_title") => "Informe de Diagnóstico de Error",
        (Language::Spanish, "diagnosis_desc") => "Descripción:",
        (Language::Spanish, "diagnosis_solution") => "Solución Recomendada:",
-        (Language::Spanish, "diagnosis_log") => "📋 Registro Relevante (gow3_log.txt)",
+        (Language::Spanish, "diagnosis_log") => "Registro Relevante (gow3_log.txt)",
        (Language::Spanish, "diagnosis_ack") => "Entendido, Cerrar",
-        (Language::Spanish, "check_updates") => "🔄 Buscar Actualizaciones",
-        (Language::Spanish, "checking_updates") => "⏳ Comprobando...",
-        (Language::Spanish, "update_modal_title") => "🚀 Actualización de God of War III",
-        (Language::Spanish, "up_to_date_title") => "✅ Sistema Actualizado",
-        (Language::Spanish, "update_available_notice") => "¡Se encontró una nueva versión en GitHub (ScreamAngel/gow3_pclauncher)!",
+        (Language::Spanish, "check_updates") => "Buscar Actualizaciones",
+        (Language::Spanish, "checking_updates") => "Comprobando...",
+        (Language::Spanish, "update_modal_title") => "Actualización de God of War III",
+        (Language::Spanish, "up_to_date_title") => "Sistema Actualizado",
+        (Language::Spanish, "update_available_notice") => "¡Se encontró una nueva versión en GitHub (ScreamAngel/gow3_launcher)!",
        (Language::Spanish, "up_to_date_notice") => "Sus archivos locales y el lanzador coinciden con la última versión.",
        (Language::Spanish, "update_backup_info") => "Al actualizar, el lanzador y los archivos de parches se actualizarán a la última versión. Se conservan todas sus configuraciones.",
-        (Language::Spanish, "apply_update") => "⚡ Descargar e Integrar",
-        (Language::Spanish, "force_sync") => "🔄 Re-sincronizar e Integrar",
+        (Language::Spanish, "apply_update") => "Descargar e Integrar",
+        (Language::Spanish, "force_sync") => "Re-sincronizar e Integrar",
        (Language::Spanish, "latest_commit") => "Último Commit:",
        (Language::Spanish, "commit_date") => "Fecha:",
-        (Language::Spanish, "view_on_github") => "🌐 Ver en GitHub",
+        (Language::Spanish, "view_on_github") => "Ver en GitHub",
+        (Language::Spanish, "python_dep") => "Dependencia Python 3:",
+        (Language::Spanish, "python_ready") => "Instalado / Listo",
+        (Language::Spanish, "python_missing") => "No encontrado",
+        (Language::Spanish, "python_download") => "Descargar Python 3 portable (~10 MB, Sin instalación)",
+        (Language::Spanish, "python_downloading") => "Descargando y configurando Python 3...",
+        (Language::Spanish, "python_download_success") => "¡Python 3 portable configurado con éxito!",
+        (Language::Spanish, "python_download_err") => "Error al descargar Python 3: ",
+        (Language::Spanish, "engine_label") => "Motor del Juego:",
+        (Language::Spanish, "engine_ready") => "Instalado / Listo (Vulkan Native)",
+        (Language::Spanish, "engine_missing") => "¡No encontrado / Falta!",
+        (Language::Spanish, "engine_download") => "Descargar Motor (~74 MB)",
+        (Language::Spanish, "engine_downloading") => "Descargando y configurando motor de juego...",
+        (Language::Spanish, "engine_download_success") => "¡Motor de juego instalado con éxito!",
+        // Spanish Config Tab
+        (Language::Spanish, "display_header") => "Modo de Pantalla y Configuración",
+        (Language::Spanish, "display_mode") => "Modo de pantalla:",
+        (Language::Spanish, "display_borderless") => "Ventana sin bordes (Recomendado)",
+        (Language::Spanish, "display_fullscreen") => "Pantalla completa",
+        (Language::Spanish, "display_windowed") => "Modo ventana",
+        (Language::Spanish, "display_desc") => "El modo sin bordes ofrece la experiencia más estable para varios monitores y Alt+Tab.",
+        (Language::Spanish, "vsync") => "Sincronización vertical (V-Sync)",
+        (Language::Spanish, "vsync_desc") => "Sincroniza la tasa de cuadros con la tasa de refresco del monitor para evitar cortes de imagen.",
+        (Language::Spanish, "controller_header") => "Ajustes de Mando / Gamepad",
+        (Language::Spanish, "bg_input") => "Entrada de mando en segundo plano",
+        (Language::Spanish, "bg_input_desc") => "Permite entradas del mando incluso cuando la ventana del juego no está activa.",
+        (Language::Spanish, "motion_controls") => "Controles de movimiento y giroscopio",
+        (Language::Spanish, "motion_controls_desc") => "Activa el acelerómetro y giroscopio internos de mandos DualShock 4 / DualSense.",
+        (Language::Spanish, "deadzone_left") => "Zona muerta palanca izquierda:",
+        (Language::Spanish, "deadzone_right") => "Zona muerta palanca derecha:",
+        (Language::Spanish, "deadzone_desc") => "Valores más bajos ofrecen mayor sensibilidad; auméntelo si su palanca sufre de deriva (drift).",
+        (Language::Spanish, "keyboard_header") => "Asignación de Teclas (Keyboard Bindings)",
+        (Language::Spanish, "keyboard_desc") => "Haz clic en cualquier botón y pulsa la nueva tecla. Pulsa ESC para cancelar.",
+        (Language::Spanish, "preset_label") => "Ajuste rápido:",
+        (Language::Spanish, "preset_standard") => "Estándar WASD + CVBN (Recomendado)",
+        (Language::Spanish, "preset_numpad") => "WASD + Teclado Numérico (8462)",
+        (Language::Spanish, "reset_defaults") => "Restablecer por defecto",
+        (Language::Spanish, "press_any_key") => "[ Presiona una tecla... / ESC ]",
+        (Language::Spanish, "sec_face_buttons") => "Botones de acción (Ataques y Salto)",
+        (Language::Spanish, "sec_triggers") => "Gatillos y botones laterales (L1/R1/L2/R2/L3/R3)",
+        (Language::Spanish, "sec_dpad_menu") => "Cruceta y Menú (D-Pad / Opciones / Touchpad)",
+        (Language::Spanish, "sec_analog_sticks") => "Palancas analógicas (Movimiento y Cámara)",
+        (Language::Spanish, "act_triangle") => "Triángulo (Ataque pesado)",
+        (Language::Spanish, "act_square") => "Cuadrado (Ataque ligero)",
+        (Language::Spanish, "act_circle") => "Círculo (Agarrar)",
+        (Language::Spanish, "act_cross") => "Cruz (Saltar)",
+        (Language::Spanish, "act_l1") => "L1 (Bloqueo / Guardia)",
+        (Language::Spanish, "act_r1") => "R1 (Esquivar / Interactuar)",
+        (Language::Spanish, "act_l2") => "L2 (Magia)",
+        (Language::Spanish, "act_r2") => "R2 (Objeto)",
+        (Language::Spanish, "act_l3") => "L3 (Click palanca izquierda)",
+        (Language::Spanish, "act_r3") => "R3 (Click palanca derecha)",
+        (Language::Spanish, "act_options") => "Options (Pausa / Menú)",
+        (Language::Spanish, "act_touchpad") => "Touchpad (Mapa / Menú)",
+        (Language::Spanish, "act_dpad_up") => "Cruceta Arriba",
+        (Language::Spanish, "act_dpad_down") => "Cruceta Abajo",
+        (Language::Spanish, "act_dpad_left") => "Cruceta Izquierda",
+        (Language::Spanish, "act_dpad_right") => "Cruceta Derecha",
+        (Language::Spanish, "act_move_up") => "Palanca Izq: Adelante",
+        (Language::Spanish, "act_move_down") => "Palanca Izq: Atrás",
+        (Language::Spanish, "act_move_left") => "Palanca Izq: Izquierda",
+        (Language::Spanish, "act_move_right") => "Palanca Izq: Derecha",
+        (Language::Spanish, "act_cam_up") => "Palanca Der: Arriba",
+        (Language::Spanish, "act_cam_down") => "Palanca Der: Abajo",
+        (Language::Spanish, "act_cam_left") => "Palanca Der: Izquierda",
+        (Language::Spanish, "act_cam_right") => "Palanca Der: Derecha",

        _ => "",
    }
@@ -13,12 +13,24 @@ use eframe::egui;
 use std::path::PathBuf;

 fn main() -> eframe::Result<()> {
-    // Determine base_dir: If running inside 'launcher' folder, go up to parent, else use current dir
-    let current_dir = std::env::current_dir().unwrap_or_else(|_| PathBuf::from("."));
-    let base_dir = if current_dir.ends_with("launcher") {
-        current_dir.parent().unwrap_or(&current_dir).to_path_buf()
+    // Determine base_dir:
+    // 1. If running as an AppImage, use the directory where the .AppImage file is located
+    // 2. If running as standalone executable, use the folder containing the binary
+    // 3. Fallback to current working directory
+    let base_dir = if let Ok(appimage) = std::env::var("APPIMAGE") {
+        PathBuf::from(appimage).parent().unwrap_or(&PathBuf::from(".")).to_path_buf()
+    } else if let Ok(exe_path) = std::env::current_exe() {
+        let exe_dir = exe_path.parent().unwrap_or(&PathBuf::from(".")).to_path_buf();
+        let cur = std::env::current_dir().unwrap_or_else(|_| PathBuf::from("."));
+        if cur.ends_with("launcher") {
+            cur.parent().unwrap_or(&cur).to_path_buf()
+        } else if exe_dir.ends_with("target/release") || exe_dir.ends_with("target/debug") {
+            cur
+        } else {
+            exe_dir
+        }
    } else {
-        current_dir
+        std::env::current_dir().unwrap_or_else(|_| PathBuf::from("."))
    };

    let args: Vec<String> = std::env::args().collect();
@@ -26,15 +38,8 @@ fn main() -> eframe::Result<()> {
        let config = config::LauncherConfig::load(&base_dir);
        let gamemode_avail = system::is_gamemode_available();
        let use_gamemode = gamemode_avail && config.use_gamemode;
-        let _ = tuner::apply_settings(
-            &base_dir,
-            config.target_fps,
-            config.patch_delta_time,
-            config.patch_readbacks,
-            config.vram_gc_budget_mb,
-            config.dmem_mb,
-        );
-        match runner::launch_gow3(&base_dir, &config, use_gamemode) {
+        let _ = tuner::apply_settings(&base_dir, &config);
+        match runner::launch_gow3(&base_dir, &config, use_gamemode, None) {
            Ok(code) => std::process::exit(code),
            Err(e) => {
                eprintln!("Error launching God of War III: {}", e);
@@ -49,19 +54,23 @@ fn main() -> eframe::Result<()> {
        .with_min_inner_size([650.0, 550.0])
        .with_resizable(true);

-    // Try load window icon
-    let icon_path = base_dir.join("gow3.png");
-    if icon_path.is_file() {
-        if let Ok(img) = image::open(&icon_path) {
-            let width = img.width();
-            let height = img.height();
-            let rgba = img.to_rgba8().into_raw();
-            viewport = viewport.with_icon(egui::IconData {
-                rgba,
-                width,
-                height,
-            });
-        }
+    // Try load window icon: check base_dir first, then fallback to embedded asset
+    let icon_data = if let Ok(img) = image::open(base_dir.join("gow3.png")) {
+        let width = img.width();
+        let height = img.height();
+        let rgba = img.to_rgba8().into_raw();
+        Some(egui::IconData { rgba, width, height })
+    } else if let Ok(img) = image::load_from_memory(include_bytes!("../../gow3.png")) {
+        let width = img.width();
+        let height = img.height();
+        let rgba = img.to_rgba8().into_raw();
+        Some(egui::IconData { rgba, width, height })
+    } else {
+        None
+    };
+
+    if let Some(icon) = icon_data {
+        viewport = viewport.with_icon(icon);
    }

    let native_options = eframe::NativeOptions {
@@ -1,6 +1,8 @@
 use std::fs::{self, File};
 use std::path::{Path, PathBuf};
 use std::process::{Command, Stdio};
+use std::sync::atomic::{AtomicU32, Ordering};
+use std::sync::Arc;

 use crate::config::LauncherConfig;

@@ -71,15 +73,475 @@ pub fn ensure_runtime_assets(base_dir: &Path) -> Result<(PathBuf, PathBuf), Stri
    Ok((scripts_dir, patches_dir))
 }

-pub fn find_python() -> Result<String, String> {
-    for cmd in &["python3", "python", "py"] {
-        if let Ok(out) = Command::new(cmd).arg("--version").output() {
-            if out.status.success() {
-                return Ok(cmd.to_string());
+/// Finds an available Python 3 interpreter (checking local runtime bundle first, then system PATH)
+pub fn find_python(base_dir: &Path) -> Result<String, String> {
+    // 1. Check local runtime python folder (.runtime/python/python.exe or bin/python3)
+    let candidates = [
+        base_dir.join(".runtime/python/python.exe"),
+        base_dir.join(".runtime/python/python"),
+        base_dir.join(".runtime/python/bin/python3"),
+        base_dir.join(".runtime/python/bin/python"),
+        base_dir.join("python/python.exe"),
+    ];
+    for p in &candidates {
+        if p.is_file() {
+            if let Ok(out) = Command::new(p).arg("--version").output() {
+                if out.status.success() {
+                    return Ok(p.to_string_lossy().to_string());
+                }
            }
        }
    }
-    Err("Python 3 bulunamadı. Lütfen sisteminize 'python' kurun.".to_string())
+
+    // 2. Check system-wide Python
+    for cmd in &["python3", "python", "py"] {
+        if let Ok(out) = Command::new(cmd).arg("--version").output() {
+            if out.status.success() {
+                let stdout = String::from_utf8_lossy(&out.stdout);
+                let stderr = String::from_utf8_lossy(&out.stderr);
+                let combined = format!("{} {}", stdout, stderr);
+                if combined.contains("Python 3.") {
+                    return Ok(cmd.to_string());
+                }
+            }
+        }
+    }
+
+    Err("Python 3 bulunamadı. Lütfen taşınabilir Python paketini indirin veya sisteminize kurun.".to_string())
+}
+
+/// Automatically downloads and configures official portable Python 3 runtime into `.runtime/python`
+pub fn download_portable_python(base_dir: &Path) -> Result<String, String> {
+    let runtime_dir = base_dir.join(".runtime");
+    let python_dir = runtime_dir.join("python");
+    let _ = fs::create_dir_all(&python_dir);
+
+    #[cfg(target_os = "windows")]
+    {
+        let ps_code = format!(
+            r#"
+            $ProgressPreference = 'SilentlyContinue';
+            [Net.ServicePointManager]::SecurityProtocol = [Net.SecurityProtocolType]::Tls12;
+            $url = 'https://www.python.org/ftp/python/3.11.9/python-3.11.9-embed-amd64.zip';
+            $zip = Join-Path $env:TEMP 'gow3_python_embed.zip';
+            $dest = '{}';
+            if (Test-Path $zip) {{ Remove-Item $zip -Force }};
+            Write-Host 'Downloading Python 3.11 embed package...';
+            (New-Object System.Net.WebClient).DownloadFile($url, $zip);
+            if (!(Test-Path $dest)) {{ New-Item -ItemType Directory -Path $dest -Force | Out-Null }};
+            Write-Host 'Extracting archive...';
+            Expand-Archive -Path $zip -DestinationPath $dest -Force;
+            Remove-Item $zip -Force;
+            "#,
+            python_dir.to_string_lossy().replace('\'', "''")
+        );
+
+        let status = Command::new("powershell")
+            .args(["-NoProfile", "-ExecutionPolicy", "Bypass", "-Command", &ps_code])
+            .status()
+            .map_err(|e| format!("PowerShell ile Python indirme komutu çalıştırılamadı: {}", e))?;
+
+        if !status.success() {
+            return Err("PowerShell üzerinden Python 3 indirilemedi.".to_string());
+        }
+
+        // Configure python311._pth to enable import site and recognize scripts directory
+        let pth_file = python_dir.join("python311._pth");
+        let pth_content = "python311.zip\n.\n..\n..\\scripts\n..\\..\\scripts\nimport site\n";
+        let _ = fs::write(pth_file, pth_content);
+    }
+
+    #[cfg(not(target_os = "windows"))]
+    {
+        // On Linux / macOS fallback: if curl and unzip exist, download embed (usable with wine or testing)
+        let zip_path = runtime_dir.join("python_embed.zip");
+        let curl_res = Command::new("curl")
+            .args([
+                "-sL",
+                "https://www.python.org/ftp/python/3.11.9/python-3.11.9-embed-amd64.zip",
+                "-o",
+                &zip_path.to_string_lossy(),
+            ])
+            .status();
+
+        if let Ok(st) = curl_res {
+            if st.success() {
+                let _ = Command::new("unzip")
+                    .args(["-o", "-q", &zip_path.to_string_lossy(), "-d", &python_dir.to_string_lossy()])
+                    .status();
+                let _ = fs::remove_file(&zip_path);
+
+                let pth_file = python_dir.join("python311._pth");
+                let pth_content = "python311.zip\n.\n..\nimport site\n";
+                let _ = fs::write(pth_file, pth_content);
+            }
+        }
+    }
+
+    find_python(base_dir).map_err(|_| "Python 3 indirildi ancak doğrulanamadı.".to_string())
+}
+
+/// Ensures Python 3 is available, automatically downloading portable package if missing
+pub fn ensure_python(base_dir: &Path) -> Result<String, String> {
+    if let Ok(py) = find_python(base_dir) {
+        return Ok(py);
+    }
+    download_portable_python(base_dir)
+}
+
+pub fn find_game_engine(base_dir: &Path) -> Option<PathBuf> {
+    #[cfg(target_os = "windows")]
+    let probe_candidates = [
+        base_dir.join("bin/gow3-probe.exe"),
+        base_dir.join("out/gow3-probe.exe"),
+        base_dir.join("gow3-probe.exe"),
+        base_dir.join("bin/gow3.exe"),
+        base_dir.join("gow3.exe"),
+        base_dir.join("God of War III.exe"),
+    ];
+
+    #[cfg(not(target_os = "windows"))]
+    let probe_candidates = [
+        base_dir.join("bin/gow3-probe"),
+        base_dir.join("out/gow3-probe"),
+        base_dir.join("gow3-probe"),
+    ];
+
+    probe_candidates.into_iter().find(|p| p.is_file())
+}
+
+#[allow(dead_code)]
+pub fn download_windows_engine(base_dir: &Path) -> Result<String, String> {
+    let dest_bin = base_dir.join("bin");
+    let _ = fs::create_dir_all(&dest_bin);
+
+    #[cfg(target_os = "windows")]
+    {
+        let ps_code = format!(
+            r#"
+            $ProgressPreference = 'SilentlyContinue';
+            [Net.ServicePointManager]::SecurityProtocol = [Net.SecurityProtocolType]::Tls12;
+            $url = 'https://github.com/FelipePrado0/gow3_pc/releases/download/windows-v2.4.1/gow3-windows.zip';
+            $zip = Join-Path $env:TEMP 'gow3_win_download.zip';
+            $tempDir = Join-Path $env:TEMP 'gow3_win_extracted';
+            if (Test-Path $tempDir) {{ Remove-Item $tempDir -Recurse -Force }};
+            if (Test-Path $zip) {{ Remove-Item $zip -Force }};
+            Write-Host 'Downloading Windows engine package (~74MB)...';
+            (New-Object System.Net.WebClient).DownloadFile($url, $zip);
+            Write-Host 'Extracting Windows package...';
+            Expand-Archive -Path $zip -DestinationPath $tempDir -Force;
+
+            $probe = Get-ChildItem -Path $tempDir -Recurse -Filter "gow3-probe.exe" | Select-Object -First 1;
+            if ($probe) {{
+                $sourceBin = $probe.DirectoryName;
+                $destBin = '{dest_bin}';
+                if (!(Test-Path $destBin)) {{ New-Item -ItemType Directory -Path $destBin -Force | Out-Null }};
+                Copy-Item "$sourceBin\*" -Destination $destBin -Recurse -Force;
+            }} else {{
+                throw "gow3-probe.exe extracted archive icinde bulunamadi!";
+            }}
+
+            $base = '{base_dir}';
+            $scripts = Get-ChildItem -Path $tempDir -Recurse -Directory -Filter "scripts" | Select-Object -First 1;
+            if ($scripts -and !(Test-Path (Join-Path $base 'scripts'))) {{
+                Copy-Item $scripts.FullName -Destination $base -Recurse -Force;
+            }}
+            $patches = Get-ChildItem -Path $tempDir -Recurse -Directory -Filter "patches" | Select-Object -First 1;
+            if ($patches -and !(Test-Path (Join-Path $base 'patches'))) {{
+                Copy-Item $patches.FullName -Destination $base -Recurse -Force;
+            }}
+
+            Remove-Item $tempDir -Recurse -Force;
+            Remove-Item $zip -Force;
+            "#,
+            dest_bin = dest_bin.to_string_lossy().replace('\'', "''"),
+            base_dir = base_dir.to_string_lossy().replace('\'', "''")
+        );
+
+        let status = Command::new("powershell")
+            .args(["-NoProfile", "-ExecutionPolicy", "Bypass", "-Command", &ps_code])
+            .status()
+            .map_err(|e| format!("PowerShell Windows motoru indirme komutu çalıştırılamadı: {}", e))?;
+
+        if !status.success() {
+            return Err("PowerShell üzerinden Windows motor paketi indirilemedi veya açılamadı.".to_string());
+        }
+
+        if find_game_engine(base_dir).is_some() {
+            return Ok("Windows oyun motoru başarıyla kuruldu!".to_string());
+        }
+
+        Err("Windows oyun motoru ('bin/gow3-probe.exe') arşivden çıkarılamadı.".to_string())
+    }
+
+    #[cfg(not(target_os = "windows"))]
+    {
+        Err("Bu fonksiyon yalnızca Windows üzerinde çalışır.".to_string())
+    }
+}
+
+#[allow(dead_code)]
+pub fn download_linux_engine(base_dir: &Path) -> Result<String, String> {
+    let dest_bin = base_dir.join("bin");
+    let _ = fs::create_dir_all(&dest_bin);
+
+    #[cfg(not(target_os = "windows"))]
+    {
+        let url = "https://github.com/FelipePrado0/gow3_pc/releases/download/windows-v2.4.1/gow3-x86_64.AppImage";
+        let temp_dir = std::env::temp_dir().join("gow3_linux_extracted");
+        let _ = fs::remove_dir_all(&temp_dir);
+        let _ = fs::create_dir_all(&temp_dir);
+        let appimage_path = temp_dir.join("gow3-x86_64.AppImage");
+
+        let dl_status = Command::new("curl")
+            .args(["-sL", url, "-o", &appimage_path.to_string_lossy()])
+            .status();
+
+        let success = match dl_status {
+            Ok(s) if s.success() => true,
+            _ => {
+                Command::new("wget")
+                    .args(["-q", url, "-O", &appimage_path.to_string_lossy()])
+                    .status()
+                    .map(|s| s.success())
+                    .unwrap_or(false)
+            }
+        };
+
+        if !success {
+            let _ = fs::remove_dir_all(&temp_dir);
+            return Err("Linux AppImage paketi indirilemedi (curl/wget başarısız oldu).".to_string());
+        }
+
+        let _ = Command::new("chmod")
+            .args(["+x", &appimage_path.to_string_lossy()])
+            .status();
+
+        let ext_status = Command::new(&appimage_path)
+            .arg("--appimage-extract")
+            .current_dir(&temp_dir)
+            .status();
+
+        if let Ok(st) = ext_status {
+            if st.success() {
+                let squash_bin = temp_dir.join("squashfs-root/bin");
+                if squash_bin.is_dir() {
+                    let _ = Command::new("cp")
+                        .args(["-r", &format!("{}/.", squash_bin.to_string_lossy()), &dest_bin.to_string_lossy()])
+                        .status();
+                    let _ = Command::new("chmod")
+                        .args(["+x", &dest_bin.join("gow3-probe").to_string_lossy()])
+                        .status();
+                }
+            }
+        }
+
+        let _ = fs::remove_dir_all(&temp_dir);
+
+        if find_game_engine(base_dir).is_some() {
+            return Ok("Linux oyun motoru başarıyla kuruldu!".to_string());
+        }
+
+        Err("Linux oyun motoru paketten çıkarılamadı.".to_string())
+    }
+
+    #[cfg(target_os = "windows")]
+    {
+        Err("Bu fonksiyon yalnızca Linux üzerinde çalışır.".to_string())
+    }
+}
+
+pub fn download_engine(base_dir: &Path) -> Result<String, String> {
+    #[cfg(target_os = "windows")]
+    {
+        download_windows_engine(base_dir)
+    }
+    #[cfg(not(target_os = "windows"))]
+    {
+        download_linux_engine(base_dir)
+    }
+}
+
+pub fn ensure_game_engine(base_dir: &Path) -> Result<PathBuf, String> {
+    if let Some(p) = find_game_engine(base_dir) {
+        return Ok(p);
+    }
+
+    // Try automatic download if missing
+    let _ = download_engine(base_dir);
+    if let Some(p) = find_game_engine(base_dir) {
+        return Ok(p);
+    }
+
+    #[cfg(target_os = "windows")]
+    {
+        Err("Windows için oyun motoru ('bin/gow3-probe.exe') bulunamadı! Lütfen arayüzdeki '📥 Motoru İndir' butonuna basarak indirin.".to_string())
+    }
+
+    #[cfg(not(target_os = "windows"))]
+    {
+        Err("Linux için oyun motoru ('bin/gow3-probe') bulunamadı! Lütfen arayüzdeki '📥 Motoru İndir' butonuna basarak indirin.".to_string())
+    }
+}
+
+/// Force terminates any running game processes (probe / wine / gamemoderun) on the system.
+pub fn kill_game_processes(pid: u32) {
+    #[cfg(target_os = "windows")]
+    {
+        use std::os::windows::process::CommandExt;
+        const CREATE_NO_WINDOW: u32 = 0x08000000;
+
+        if pid > 0 {
+            let _ = Command::new("taskkill")
+                .args(["/F", "/T", "/PID", &pid.to_string()])
+                .creation_flags(CREATE_NO_WINDOW)
+                .output();
+        }
+        let _ = Command::new("taskkill")
+            .args(["/F", "/T", "/IM", "gow3-probe.exe"])
+            .creation_flags(CREATE_NO_WINDOW)
+            .output();
+        let _ = Command::new("taskkill")
+            .args(["/F", "/T", "/IM", "gow3.exe"])
+            .creation_flags(CREATE_NO_WINDOW)
+            .output();
+    }
+
+    #[cfg(not(target_os = "windows"))]
+    {
+        let my_pid = std::process::id();
+        if pid > 0 && pid != my_pid {
+            let _ = Command::new("kill")
+                .args(["-9", &pid.to_string()])
+                .output();
+            let _ = Command::new("pkill")
+                .args(["-9", "-P", &pid.to_string()])
+                .output();
+        }
+        let _ = Command::new("pkill")
+            .args(["-9", "-x", "gow3-probe"])
+            .output();
+        let _ = Command::new("pkill")
+            .args(["-9", "-f", "gow3-probe"])
+            .output();
+        let _ = Command::new("pkill")
+            .args(["-9", "-f", "gow3-probe.exe"])
+            .output();
+    }
+}
+
+#[cfg(target_os = "windows")]
+pub fn adjust_windows_windowed_mode(target_pid: u32) {
+    std::thread::spawn(move || {
+        use std::ffi::c_void;
+        use std::time::{Duration, Instant};
+
+        #[repr(C)]
+        struct RECT {
+            left: i32,
+            top: i32,
+            right: i32,
+            bottom: i32,
+        }
+
+        struct EnumContext {
+            pid: u32,
+            hwnd: *mut c_void,
+        }
+
+        unsafe extern "system" {
+            fn GetWindowThreadProcessId(hwnd: *mut c_void, lpdwProcessId: *mut u32) -> u32;
+            fn EnumWindows(lpEnumFunc: unsafe extern "system" fn(*mut c_void, isize) -> i32, lParam: isize) -> i32;
+            fn IsWindowVisible(hwnd: *mut c_void) -> i32;
+            fn GetWindowLongPtrA(hWnd: *mut c_void, nIndex: i32) -> isize;
+            fn SetWindowLongPtrA(hWnd: *mut c_void, nIndex: i32, dwNewLong: isize) -> isize;
+            fn SetWindowPos(hWnd: *mut c_void, hWndInsertAfter: *mut c_void, X: i32, Y: i32, cx: i32, cy: i32, uFlags: u32) -> i32;
+            fn ShowWindow(hWnd: *mut c_void, nCmdShow: i32) -> i32;
+            fn SystemParametersInfoA(uiAction: u32, uiParam: u32, pvParam: *mut c_void, fWinIni: u32) -> i32;
+            fn GetSystemMetrics(nIndex: i32) -> i32;
+        }
+
+        unsafe extern "system" fn enum_proc(hwnd: *mut c_void, lparam: isize) -> i32 {
+            unsafe {
+                let ctx = &mut *(lparam as *mut EnumContext);
+                let mut proc_id = 0u32;
+                GetWindowThreadProcessId(hwnd, &mut proc_id);
+                if proc_id == ctx.pid && IsWindowVisible(hwnd) != 0 {
+                    ctx.hwnd = hwnd;
+                    return 0;
+                }
+            }
+            1
+        }
+
+        let start = Instant::now();
+        let mut target_hwnd: *mut c_void = std::ptr::null_mut();
+
+        while start.elapsed() < Duration::from_secs(15) {
+            let mut ctx = EnumContext {
+                pid: target_pid,
+                hwnd: std::ptr::null_mut(),
+            };
+            unsafe {
+                EnumWindows(enum_proc, &mut ctx as *mut _ as isize);
+            }
+            if !ctx.hwnd.is_null() {
+                target_hwnd = ctx.hwnd;
+                break;
+            }
+            std::thread::sleep(Duration::from_millis(150));
+        }
+
+        if target_hwnd.is_null() {
+            return;
+        }
+
+        std::thread::sleep(Duration::from_millis(600));
+
+        unsafe {
+            let mut work_area: RECT = std::mem::zeroed();
+            const SPI_GETWORKAREA: u32 = 0x0030;
+            let ok = SystemParametersInfoA(SPI_GETWORKAREA, 0, &mut work_area as *mut _ as *mut c_void, 0);
+
+            let screen_w = if ok != 0 { work_area.right - work_area.left } else { GetSystemMetrics(0) };
+            let screen_h = if ok != 0 { work_area.bottom - work_area.top } else { GetSystemMetrics(1) };
+
+            let (win_w, win_h) = if screen_w >= 2560 && screen_h >= 1440 {
+                (1920, 1080)
+            } else if screen_w > 1680 && screen_h > 940 {
+                (1600, 900)
+            } else if screen_w > 1360 && screen_h > 760 {
+                (1280, 720)
+            } else {
+                ((screen_w * 85 / 100).max(800), (screen_h * 85 / 100).max(600))
+            };
+
+            let pos_x = work_area.left + ((screen_w - win_w) / 2).max(10);
+            let pos_y = work_area.top + ((screen_h - win_h) / 2).max(10);
+
+            const GWL_STYLE: i32 = -16;
+            const WS_OVERLAPPEDWINDOW: isize = 0x00CF0000;
+            const WS_VISIBLE: isize = 0x10000000;
+            let current_style = GetWindowLongPtrA(target_hwnd, GWL_STYLE);
+            SetWindowLongPtrA(target_hwnd, GWL_STYLE, current_style | WS_OVERLAPPEDWINDOW | WS_VISIBLE);
+
+            const SWP_FRAMECHANGED: u32 = 0x0020;
+            const SWP_SHOWWINDOW: u32 = 0x0040;
+            const SWP_NOZORDER: u32 = 0x0004;
+            const SW_RESTORE: i32 = 9;
+
+            ShowWindow(target_hwnd, SW_RESTORE);
+            SetWindowPos(
+                target_hwnd,
+                std::ptr::null_mut(),
+                pos_x,
+                pos_y,
+                win_w,
+                win_h,
+                SWP_NOZORDER | SWP_FRAMECHANGED | SWP_SHOWWINDOW,
+            );
+        }
+    });
 }

 /// Executes the full God of War III preparation and probe execution natively from Rust.
@@ -87,23 +549,14 @@ pub fn launch_gow3(
    base_dir: &Path,
    config: &LauncherConfig,
    use_gamemode: bool,
+    running_pid: Option<Arc<AtomicU32>>,
 ) -> Result<i32, String> {
    let game_dir = Path::new(&config.game_dir);
    if !game_dir.join("eboot.bin").is_file() {
        return Err("Oyun klasöründe 'eboot.bin' bulunamadı!".to_string());
    }

-    let probe_candidates = [
-        base_dir.join("bin/gow3-probe"),
-        base_dir.join("bin/gow3-probe.exe"),
-        base_dir.join("out/gow3-probe"),
-        base_dir.join("out/gow3-probe.exe"),
-        base_dir.join("gow3-probe.exe"),
-    ];
-    let probe_bin = probe_candidates
-        .into_iter()
-        .find(|p| p.is_file())
-        .ok_or_else(|| "Oyun motoru ('gow3-probe' / 'gow3-probe.exe') bulunamadı!".to_string())?;
+    let probe_bin = ensure_game_engine(base_dir)?;

    let out_dir = base_dir.join("out");
    fs::create_dir_all(&out_dir).map_err(|e| format!("'out' klasörü oluşturulamadı: {}", e))?;
@@ -127,7 +580,7 @@ pub fn launch_gow3(
        .try_clone()
        .map_err(|e| format!("Log dosyası çoğaltılamadı: {}", e))?;

-    let python = find_python()?;
+    let python = ensure_python(base_dir)?;

    // 1. Run mods.py
    let _ = Command::new(&python)
@@ -316,15 +769,69 @@ pub fn launch_gow3(
    cmd.env("GOW3_PATCHES_ONLY", "1");
    cmd.env("GOW3_CONFIG", &config_ini);
    cmd.env("GOW3_GAME_DIR", game_dir);
+    cmd.env(
+        "GOW3_FULLSCREEN",
+        if config.display_mode != crate::config::DisplayMode::Windowed {
+            "1"
+        } else {
+            "0"
+        },
+    );
+
+    // Apply Controller and Keyboard mapping overrides
+    let key_map = config.build_gow3_key_map();
+    let pad_map = config.build_gow3_pad_map();
+    cmd.env("GOW3_KEY_MAP", &key_map);
+    cmd.env("GOW3_PAD_MAP", pad_map);
+    cmd.env(
+        "SDL_JOYSTICK_ALLOW_BACKGROUND_EVENTS",
+        if config.background_controller_input {
+            "1"
+        } else {
+            "0"
+        },
+    );
+    if config.deadzone_left > 0 {
+        let dz = (config.deadzone_left as f32 / 100.0 * 32767.0) as u32;
+        cmd.env("SDL_LINUX_JOYSTICK_DEADZONE", dz.to_string());
+    }
+
+    // Prepend bin directory to PATH so Windows/Linux loaders find bundled libraries
+    let bin_dir = base_dir.join("bin");
+    if bin_dir.is_dir() {
+        if let Some(existing_path) = std::env::var_os("PATH") {
+            let mut paths = vec![bin_dir.clone()];
+            paths.extend(std::env::split_paths(&existing_path));
+            if let Ok(new_path) = std::env::join_paths(paths) {
+                cmd.env("PATH", new_path);
+            }
+        } else {
+            cmd.env("PATH", &bin_dir);
+        }
+    }

    // Pipe stdout & stderr to gow3_log.txt
    cmd.stdout(Stdio::from(log_file));
    cmd.stderr(Stdio::from(log_file_err));

    let mut child = cmd.spawn().map_err(|e| format!("Oyun başlatılamadı: {}", e))?;
-    let exit_status = child.wait().map_err(|e| format!("Oyun beklenirken hata oluştu: {}", e))?;
+    if let Some(ref pid_holder) = running_pid {
+        pid_holder.store(child.id(), Ordering::SeqCst);
+    }

-    Ok(exit_status.code().unwrap_or(-1))
+    #[cfg(target_os = "windows")]
+    if config.display_mode == crate::config::DisplayMode::Windowed {
+        adjust_windows_windowed_mode(child.id());
+    }
+
+    let exit_status = child.wait().map_err(|e| format!("Oyun beklenirken hata oluştu: {}", e));
+
+    if let Some(ref pid_holder) = running_pid {
+        pid_holder.store(0, Ordering::SeqCst);
+    }
+
+    let status = exit_status?;
+    Ok(status.code().unwrap_or(-1))
 }

 #[cfg(test)]
@@ -333,7 +840,7 @@ mod tests {

    #[test]
    fn test_find_python() {
-        let py = find_python();
+        let py = find_python(Path::new("."));
        assert!(py.is_ok(), "Python 3 should be detected on the system");
    }

@@ -15,10 +15,13 @@ pub fn is_valid_game_dir(path: &Path) -> bool {
        return false;
    }

-    let eboot = path.join("eboot.bin");
-    if !eboot.is_file() {
+    let eboot = if path.join("eboot.bin").is_file() {
+        path.join("eboot.bin")
+    } else if path.join("EBOOT.BIN").is_file() {
+        path.join("EBOOT.BIN")
+    } else {
        return false;
-    }
+    };

    // 1. Verify eboot.bin size (genuine God of War III eboot is > 1MB, typically ~4.5MB)
    if let Ok(meta) = fs::metadata(&eboot) {
@@ -30,10 +33,17 @@ pub fn is_valid_game_dir(path: &Path) -> bool {
    }

    // 2. Verify sce_sys/param.sfo exists and has data
-    let sfo = path.join("sce_sys/param.sfo");
-    if !sfo.is_file() {
+    let sfo = if path.join("sce_sys/param.sfo").is_file() {
+        path.join("sce_sys/param.sfo")
+    } else if path.join("sce_sys/PARAM.SFO").is_file() {
+        path.join("sce_sys/PARAM.SFO")
+    } else if path.join("SCE_SYS/param.sfo").is_file() {
+        path.join("SCE_SYS/param.sfo")
+    } else if path.join("SCE_SYS/PARAM.SFO").is_file() {
+        path.join("SCE_SYS/PARAM.SFO")
+    } else {
        return false;
-    }
+    };
    if let Ok(meta) = fs::metadata(&sfo) {
        if meta.len() < 100 {
            return false;
@@ -43,13 +53,13 @@ pub fn is_valid_game_dir(path: &Path) -> bool {
    }

    // 3. Verify at least one essential game directory exists (sce_module, EXEC, or language packs)
-    let has_modules = path.join("sce_module").is_dir();
-    let has_exec = path.join("EXEC").is_dir();
+    let has_modules = path.join("sce_module").is_dir() || path.join("SCE_MODULE").is_dir();
+    let has_exec = path.join("EXEC").is_dir() || path.join("exec").is_dir();
    let has_lang = [
        "ENGLISH", "DUTCH", "FRENCH", "GERMAN", "ITALIAN", "POLISH", "PORTUGUESE", "RUSSIAN", "SPANISH", "data",
    ]
    .iter()
-    .any(|lang| path.join(lang).is_dir());
+    .any(|lang| path.join(lang).is_dir() || path.join(lang.to_lowercase()).is_dir());

    has_modules || has_exec || has_lang
 }
@@ -58,6 +68,10 @@ pub fn scan_for_game() -> Vec<GameCandidate> {
    let mut candidates = Vec::new();
    let mut scan_roots = Vec::new();

+    if let Ok(cur) = std::env::current_dir() {
+        scan_roots.push(cur);
+    }
+
    #[cfg(target_os = "windows")]
    {
        if let Ok(userprofile) = std::env::var("USERPROFILE") {
@@ -179,17 +179,68 @@ fn detect_refresh_rate() -> u32 {

 #[cfg(target_os = "windows")]
 fn detect_gpu() -> (String, u64) {
+    // 1. Try nvidia-smi first (exact VRAM for NVIDIA GPUs, e.g. RTX 4070 Laptop 8GB)
+    if let Ok(output) = Command::new("nvidia-smi")
+        .args(["--query-gpu=name,memory.total", "--format=csv,noheader,nounits"])
+        .output()
+    {
+        if output.status.success() {
+            let text = String::from_utf8_lossy(&output.stdout);
+            if let Some(line) = text.lines().next() {
+                let parts: Vec<&str> = line.split(',').collect();
+                if parts.len() >= 2 {
+                    let name = parts[0].trim().to_string();
+                    let vram = parts[1].trim().parse::<u64>().unwrap_or(0);
+                    if vram > 0 {
+                        return (name, vram);
+                    }
+                }
+            }
+        }
+    }
+
+    // 2. Try Windows Registry for AMD / Intel / NVIDIA (64-bit QWORD qwMemorySize)
+    let ps_script = r#"
+        $g = Get-ItemProperty -Path 'HKLM:\SYSTEM\CurrentControlSet\Control\Class\{4d36e968-e325-11ce-bfc1-08002be10318}\00*' -ErrorAction SilentlyContinue |
+             Where-Object { $_.'HardwareInformation.qwMemorySize' -gt 0 } |
+             Sort-Object 'HardwareInformation.qwMemorySize' -Descending |
+             Select-Object -First 1;
+        if ($g) {
+            $name = if ($g.DriverDesc) { $g.DriverDesc } else { $g.'Device Description' };
+            $vram = [int64]$g.'HardwareInformation.qwMemorySize';
+            [PSCustomObject]@{ Name = $name; VRAM = $vram } | ConvertTo-Json -Compress
+        }
+    "#;
+    if let Ok(output) = Command::new("powershell")
+        .args(["-NoProfile", "-Command", ps_script])
+        .output()
+    {
+        if output.status.success() {
+            let text = String::from_utf8_lossy(&output.stdout);
+            if let Ok(val) = serde_json::from_str::<serde_json::Value>(text.trim()) {
+                let name = val["Name"].as_str().unwrap_or("Windows DirectX/Vulkan GPU").to_string();
+                if let Some(vram_bytes) = val["VRAM"].as_u64() {
+                    let vram_mb = vram_bytes / (1024 * 1024);
+                    if vram_mb >= 1024 {
+                        return (name, vram_mb);
+                    }
+                }
+            }
+        }
+    }
+
+    // 3. Fallback to Win32_VideoController
    if let Ok(output) = Command::new("powershell")
        .args([
            "-NoProfile",
            "-Command",
-            "Get-CimInstance Win32_VideoController | Select-Object -First 1 -Property Name,AdapterRAM | ConvertTo-Json",
+            "Get-CimInstance Win32_VideoController | Sort-Object AdapterRAM -Descending | Select-Object -First 1 -Property Name,AdapterRAM | ConvertTo-Json -Compress",
        ])
        .output()
    {
        if output.status.success() {
            let text = String::from_utf8_lossy(&output.stdout);
-            if let Ok(val) = serde_json::from_str::<serde_json::Value>(&text) {
+            if let Ok(val) = serde_json::from_str::<serde_json::Value>(text.trim()) {
                let name = val["Name"].as_str().unwrap_or("Windows DirectX/Vulkan GPU").to_string();
                let vram_bytes = val["AdapterRAM"].as_u64().unwrap_or(4 * 1024 * 1024 * 1024);
                let vram_mb = vram_bytes / (1024 * 1024);
@@ -197,6 +248,7 @@ fn detect_gpu() -> (String, u64) {
            }
        }
    }
+
    ("Windows DirectX/Vulkan GPU".to_string(), 4096)
 }

@@ -1,20 +1,17 @@
 use std::fs;
-use std::path::Path;
+use std::path::{Path, PathBuf};

-pub fn apply_settings(
-    base_dir: &Path,
-    target_hz: u32,
-    patch_delta_time: bool,
-    patch_readbacks: bool,
-    vram_gc_budget_mb: u64,
-    dmem_mb: u64,
-) -> Result<(), String> {
-    if patch_delta_time {
-        update_xml_patches(base_dir, target_hz)?;
+use crate::config::{key_to_sdl_scancode, DisplayMode, LauncherConfig};
+
+pub fn apply_settings(base_dir: &Path, config: &LauncherConfig) -> Result<(), String> {
+    if config.patch_delta_time {
+        update_xml_patches(base_dir, config.target_fps)?;
    }
-    update_run_sh(base_dir, target_hz, patch_readbacks, vram_gc_budget_mb, dmem_mb)?;
-    update_gow3_ini(base_dir, target_hz, patch_readbacks, vram_gc_budget_mb)?;
-    update_user_config_toml(base_dir, vram_gc_budget_mb)?;
+    update_run_sh(base_dir, config)?;
+    update_gow3_ini(base_dir, config)?;
+    update_user_config_toml(base_dir, config)?;
+    update_user_input_config(base_dir, config)?;
+    let _ = patch_engine_analog_scancodes(base_dir, config);

    Ok(())
 }
@@ -35,10 +32,12 @@ fn update_xml_patches(base_dir: &Path, target_hz: u32) -> Result<(), String> {
    for path in &patch_files {
        if path.is_file() {
            if let Ok(content) = fs::read_to_string(path) {
-                // Update lines with Delta-Time or 120/144 FPS
                let mut new_lines = Vec::new();
                for line in content.lines() {
-                    if (line.contains("Delta-Time") || line.contains("120 FPS") || line.contains("144 FPS") || line.contains("60 FPS"))
+                    if (line.contains("Delta-Time")
+                        || line.contains("120 FPS")
+                        || line.contains("144 FPS")
+                        || line.contains("60 FPS"))
                        && line.contains("value=\"")
                    {
                        if let Some(start) = line.find("value=\"") {
@@ -60,13 +59,7 @@ fn update_xml_patches(base_dir: &Path, target_hz: u32) -> Result<(), String> {
    Ok(())
 }

-fn update_run_sh(
-    base_dir: &Path,
-    target_hz: u32,
-    patch_readbacks: bool,
-    vram_gc_budget_mb: u64,
-    dmem_mb: u64,
-) -> Result<(), String> {
+fn update_run_sh(base_dir: &Path, config: &LauncherConfig) -> Result<(), String> {
    let run_sh = base_dir.join("run.sh");
    if !run_sh.is_file() {
        return Ok(());
@@ -74,40 +67,43 @@ fn update_run_sh(

    let mut content = fs::read_to_string(&run_sh).map_err(|e| e.to_string())?;

-    let patches_str = if target_hz != 60 {
-        format!("Bug Fix - Texture Corruption Fix;Skip Any Video With X Button;Frame Rate Patch - {} FPS", target_hz)
+    let patches_str = if config.target_fps != 60 {
+        format!(
+            "Bug Fix - Texture Corruption Fix;Skip Any Video With X Button;Frame Rate Patch - {} FPS",
+            config.target_fps
+        )
    } else {
        "Bug Fix - Texture Corruption Fix;Skip Any Video With X Button".to_string()
    };

-    // Update GOW3_GC_BUDGET_MB
-    replace_or_insert_env(&mut content, "GOW3_GC_BUDGET_MB", &vram_gc_budget_mb.to_string());
-    // Update GOW3_DMEM_POOL_MB
-    replace_or_insert_env(&mut content, "GOW3_DMEM_POOL_MB", &dmem_mb.to_string());
-    // Update GOW3_DEFAULT_ENGINE_FPS
-    replace_or_insert_env(&mut content, "GOW3_DEFAULT_ENGINE_FPS", &target_hz.to_string());
-    // Update GOW3_FORCE_READBACK
-    replace_or_insert_env(&mut content, "GOW3_FORCE_READBACK", if patch_readbacks { "1" } else { "0" });
-    // Update GOW3_READBACKS
-    replace_or_insert_env(&mut content, "GOW3_READBACKS", if patch_readbacks { "1" } else { "0" });
-    // Update GOW3_READBACK_LINEAR
-    replace_or_insert_env(&mut content, "GOW3_READBACK_LINEAR", if patch_readbacks { "1" } else { "0" });
-    // Update GOW3_FULL_BARRIERS
+    replace_or_insert_env(&mut content, "GOW3_GC_BUDGET_MB", &config.vram_gc_budget_mb.to_string());
+    replace_or_insert_env(&mut content, "GOW3_DMEM_POOL_MB", &config.dmem_mb.to_string());
+    replace_or_insert_env(&mut content, "GOW3_DEFAULT_ENGINE_FPS", &config.target_fps.to_string());
+    replace_or_insert_env(&mut content, "GOW3_FORCE_READBACK", if config.patch_readbacks { "1" } else { "0" });
+    replace_or_insert_env(&mut content, "GOW3_READBACKS", if config.patch_readbacks { "1" } else { "0" });
+    replace_or_insert_env(&mut content, "GOW3_READBACK_LINEAR", if config.patch_readbacks { "1" } else { "0" });
    replace_or_insert_env(&mut content, "GOW3_FULL_BARRIERS", "1");
-    // Update GOW3_FORCE_PATCHES
    replace_or_insert_env(&mut content, "GOW3_FORCE_PATCHES", "1");
-    // Update GOW3_PREBUILT
    replace_or_insert_env(&mut content, "GOW3_PREBUILT", "1");
-    // Update GOW3_STREAM_MEMORY
    replace_or_insert_env(&mut content, "GOW3_STREAM_MEMORY", "cached");
-    // Update GOW3_PATCHES
    replace_or_insert_env(&mut content, "GOW3_PATCHES", &patches_str);
-    // Update GOW3_PATCHES_ONLY
    replace_or_insert_env(&mut content, "GOW3_PATCHES_ONLY", "1");
-    // Update GOW3_DMEM_MB
-    replace_or_insert_env(&mut content, "GOW3_DMEM_MB", &dmem_mb.to_string());
-    // Update GOW3_VBLANK_HZ
-    replace_or_insert_env(&mut content, "GOW3_VBLANK_HZ", &target_hz.to_string());
+    replace_or_insert_env(&mut content, "GOW3_DMEM_MB", &config.dmem_mb.to_string());
+    replace_or_insert_env(&mut content, "GOW3_VBLANK_HZ", &config.target_fps.to_string());
+    replace_or_insert_env(
+        &mut content,
+        "GOW3_FULLSCREEN",
+        if config.display_mode != DisplayMode::Windowed { "1" } else { "0" },
+    );
+    let key_map = config.build_gow3_key_map();
+    let pad_map = config.build_gow3_pad_map();
+    replace_or_insert_env(&mut content, "GOW3_KEY_MAP", &key_map);
+    replace_or_insert_env(&mut content, "GOW3_PAD_MAP", pad_map);
+    replace_or_insert_env(
+        &mut content,
+        "SDL_JOYSTICK_ALLOW_BACKGROUND_EVENTS",
+        if config.background_controller_input { "1" } else { "0" },
+    );

    fs::write(&run_sh, content).map_err(|e| e.to_string())?;
    Ok(())
@@ -128,7 +124,6 @@ fn replace_or_insert_env(content: &mut String, var_name: &str, value: &str) {
        }
    }

-    // Insert before the last launch command if not present
    let insertion = format!("export {}=\"{}\"\n", var_name, value);
    if let Some(idx) = content.find("exec ") {
        content.insert_str(idx, &insertion);
@@ -137,28 +132,39 @@ fn replace_or_insert_env(content: &mut String, var_name: &str, value: &str) {
    }
 }

-fn update_gow3_ini(
-    base_dir: &Path,
-    target_hz: u32,
-    patch_readbacks: bool,
-    vram_gc_budget_mb: u64,
-) -> Result<(), String> {
+fn update_gow3_ini(base_dir: &Path, config: &LauncherConfig) -> Result<(), String> {
    let ini_path = base_dir.join("gow3.ini");
-    if !ini_path.is_file() {
-        return Ok(());
-    }
+    let mut content = if ini_path.is_file() {
+        fs::read_to_string(&ini_path).unwrap_or_default()
+    } else {
+        "# God of War III Remastered settings (auto-tuned)\n\
+         render_resolution=native\n\
+         engine_fps=60\n\
+         fps_limit=60\n\
+         upscaler=off\n\
+         fsr1=0\n\
+         rcas=0\n\
+         display_mode=windowed\n\
+         vsync=1\n\
+         deferred_readback=0\n\
+         stale_readback=0\n\
+         async_shaders=1\n\
+         frames_queued=1\n\
+         readbacks=true\n\
+         readbackLinearImages=true\n\
+         budget=6144\n".to_string()
+    };

-    let mut content = fs::read_to_string(&ini_path).map_err(|e| e.to_string())?;
-
-    let readbacks_val = if patch_readbacks { "true" } else { "false" };
+    let readbacks_val = if config.patch_readbacks { "true" } else { "false" };
    replace_ini_key(&mut content, "readbacks", readbacks_val);
    replace_ini_key(&mut content, "readbackLinearImages", readbacks_val);
    replace_ini_key(&mut content, "stale_readback", "0");
-    replace_ini_key(&mut content, "budget", &vram_gc_budget_mb.to_string());
-    replace_ini_key(&mut content, "engine_fps", &target_hz.to_string());
-    replace_ini_key(&mut content, "fps_limit", &target_hz.to_string());
+    replace_ini_key(&mut content, "budget", &config.vram_gc_budget_mb.to_string());
+    replace_ini_key(&mut content, "engine_fps", &config.target_fps.to_string());
+    replace_ini_key(&mut content, "fps_limit", &config.target_fps.to_string());
    replace_ini_key(&mut content, "frames_queued", "1");
-    replace_ini_key(&mut content, "vsync", "1");
+    replace_ini_key(&mut content, "vsync", if config.vsync { "1" } else { "0" });
+    replace_ini_key(&mut content, "display_mode", config.display_mode.as_str());

    fs::write(&ini_path, content).map_err(|e| e.to_string())?;
    Ok(())
@@ -187,21 +193,453 @@ fn replace_ini_key(content: &mut String, key: &str, val: &str) {
    *content = lines.join("\n");
 }

-fn update_user_config_toml(base_dir: &Path, vram_gc_budget_mb: u64) -> Result<(), String> {
-    let toml_path = base_dir.join("user/config.toml");
-    if !toml_path.is_file() {
-        return Ok(());
+fn update_toml_key_in_section(content: &mut String, section: &str, key: &str, val: &str) {
+    let section_header = format!("[{}]", section);
+    let mut in_section = false;
+    let mut key_replaced = false;
+    let mut new_lines = Vec::new();
+
+    for line in content.lines() {
+        let trimmed = line.trim();
+        if trimmed.starts_with('[') && trimmed.ends_with(']') {
+            if in_section && !key_replaced {
+                new_lines.push(format!("{} = {}", key, val));
+                key_replaced = true;
+            }
+            in_section = trimmed == section_header;
+            new_lines.push(line.to_string());
+            continue;
+        }
+
+        if in_section {
+            if let Some((k, _)) = trimmed.split_once('=') {
+                if k.trim() == key {
+                    new_lines.push(format!("{} = {}", key, val));
+                    key_replaced = true;
+                    continue;
+                }
+            }
+        }
+
+        new_lines.push(line.to_string());
    }

-    let mut content = fs::read_to_string(&toml_path).map_err(|e| e.to_string())?;
+    if in_section && !key_replaced {
+        new_lines.push(format!("{} = {}", key, val));
+    } else if !key_replaced {
+        new_lines.push(String::new());
+        new_lines.push(section_header);
+        new_lines.push(format!("{} = {}", key, val));
+    }
+
+    *content = new_lines.join("\n");
+}
+
+fn update_user_config_toml(base_dir: &Path, config: &LauncherConfig) -> Result<(), String> {
+    let toml_path = base_dir.join("user/config.toml");
+    let mut content = if toml_path.is_file() {
+        fs::read_to_string(&toml_path).unwrap_or_default()
+    } else {
+        let user_dir = base_dir.join("user");
+        let _ = fs::create_dir_all(&user_dir);
+        "[General]\n\
+         [GPU]\n\
+         Fullscreen = false\n\
+         FullscreenMode = \"Windowed\"\n\
+         [Input]\n".to_string()
+    };
+
+    // Update vulkan_gc_budget if present
    if let Some(idx) = content.find("vulkan_gc_budget =") {
        if let Some(end) = content[idx..].find('\n') {
            let prefix = &content[..idx];
            let suffix = &content[idx + end..];
-            content = format!("{}vulkan_gc_budget = {}{}", prefix, vram_gc_budget_mb, suffix);
+            content = format!("{}vulkan_gc_budget = {}{}", prefix, config.vram_gc_budget_mb, suffix);
        }
    }

+    // Update Display / GPU settings
+    let (fullscreen_mode_str, fullscreen_bool) = config.display_mode.to_toml_mode();
+    update_toml_key_in_section(
+        &mut content,
+        "GPU",
+        "Fullscreen",
+        if fullscreen_bool { "true" } else { "false" },
+    );
+    update_toml_key_in_section(
+        &mut content,
+        "GPU",
+        "FullscreenMode",
+        &format!("\"{}\"", fullscreen_mode_str),
+    );
+
+    // Update Input settings
+    update_toml_key_in_section(
+        &mut content,
+        "Input",
+        "backgroundControllerInput",
+        if config.background_controller_input { "true" } else { "false" },
+    );
+    update_toml_key_in_section(
+        &mut content,
+        "Input",
+        "isMotionControlsEnabled",
+        if config.is_motion_controls_enabled { "true" } else { "false" },
+    );
+
    fs::write(&toml_path, content).map_err(|e| e.to_string())?;
    Ok(())
 }
+
+fn update_user_input_config(base_dir: &Path, config: &LauncherConfig) -> Result<(), String> {
+    let input_dir = base_dir.join("user/input_config");
+    let _ = fs::create_dir_all(&input_dir);
+    let ini_path = input_dir.join("default.ini");
+
+    let b = &config.keyboard_bindings;
+    let content = format!(
+        "# God of War III Remastered - Input Configuration\n\
+         # Auto-generated by Launcher\n\n\
+         # Keyboard bindings\n\n\
+         triangle = {triangle}\n\
+         circle = {circle}\n\
+         cross = {cross}\n\
+         square = {square}\n\n\
+         l1 = {l1}\n\
+         r1 = {r1}\n\
+         l2 = {l2}\n\
+         r2 = {r2}\n\
+         l3 = {l3}\n\
+         r3 = {r3}\n\n\
+         options = {options}\n\
+         touchpad_center = {touchpad}\n\n\
+         pad_up = {pad_up}\n\
+         pad_down = {pad_down}\n\
+         pad_left = {pad_left}\n\
+         pad_right = {pad_right}\n\n\
+         axis_left_x_minus = {ax_lx_min}\n\
+         axis_left_x_plus = {ax_lx_plus}\n\
+         axis_left_y_minus = {ax_ly_min}\n\
+         axis_left_y_plus = {ax_ly_plus}\n\n\
+         axis_right_x_minus = {ax_rx_min}\n\
+         axis_right_x_plus = {ax_rx_plus}\n\
+         axis_right_y_minus = {ax_ry_min}\n\
+         axis_right_y_plus = {ax_ry_plus}\n\n\
+         # Controller bindings\n\n\
+         triangle = triangle\n\
+         cross = cross\n\
+         square = square\n\
+         circle = circle\n\n\
+         l1 = l1\n\
+         l2 = l2\n\
+         l3 = l3\n\
+         r1 = r1\n\
+         r2 = r2\n\
+         r3 = r3\n\n\
+         options = options\n\
+         touchpad_center = back\n\n\
+         pad_up = pad_up\n\
+         pad_down = pad_down\n\
+         pad_left = pad_left\n\
+         pad_right = pad_right\n\n\
+         axis_left_x = axis_left_x\n\
+         axis_left_y = axis_left_y\n\
+         axis_right_x = axis_right_x\n\
+         axis_right_y = axis_right_y\n\n\
+         # Range of deadzones: 1 (almost none) to 127 (max)\n\
+         analog_deadzone = leftjoystick, {deadzone_l}, 127\n\
+         analog_deadzone = rightjoystick, {deadzone_r}, 127\n\n\
+         override_controller_color = false, 0, 0, 255\n",
+        triangle = b.triangle,
+        circle = b.circle,
+        cross = b.cross,
+        square = b.square,
+        l1 = b.l1,
+        r1 = b.r1,
+        l2 = b.l2,
+        r2 = b.r2,
+        l3 = b.l3,
+        r3 = b.r3,
+        options = b.options,
+        touchpad = b.touchpad_center,
+        pad_up = b.pad_up,
+        pad_down = b.pad_down,
+        pad_left = b.pad_left,
+        pad_right = b.pad_right,
+        ax_lx_min = b.axis_left_x_minus,
+        ax_lx_plus = b.axis_left_x_plus,
+        ax_ly_min = b.axis_left_y_minus,
+        ax_ly_plus = b.axis_left_y_plus,
+        ax_rx_min = b.axis_right_x_minus,
+        ax_rx_plus = b.axis_right_x_plus,
+        ax_ry_min = b.axis_right_y_minus,
+        ax_ry_plus = b.axis_right_y_plus,
+        deadzone_l = config.deadzone_left,
+        deadzone_r = config.deadzone_right,
+    );
+
+    fs::write(&ini_path, content).map_err(|e| e.to_string())?;
+    Ok(())
+}
+
+/// Patches the 8 hardcoded analog-stick scancodes in gow3-probe (Linux) and gow3-probe.exe (Windows).
+///
+/// The engine binary uses SDL_GetKeyboardState and checks 8 hardcoded 1-byte scancodes:
+///   Left Stick:  +X (right), -X (left), +Y (down), -Y (up)
+///   Right Stick: +X (right), -X (left), +Y (down), -Y (up)
+///
+/// These scancodes are found immediately after a known unique anchor byte sequence
+/// that appears exactly once in each binary.
+fn patch_engine_analog_scancodes(base_dir: &Path, config: &LauncherConfig) -> Result<(), String> {
+    let b = &config.keyboard_bindings;
+
+    // Convert user key strings to SDL scancodes
+    let sc_lx_plus  = key_to_sdl_scancode(&b.axis_left_x_plus);   // Left  +X (move right → D default)
+    let sc_lx_minus = key_to_sdl_scancode(&b.axis_left_x_minus);  // Left  -X (move left  → A default)
+    let sc_ly_plus  = key_to_sdl_scancode(&b.axis_left_y_plus);   // Left  +Y (move down  → S default)
+    let sc_ly_minus = key_to_sdl_scancode(&b.axis_left_y_minus);  // Left  -Y (move up    → W default)
+    let sc_rx_plus  = key_to_sdl_scancode(&b.axis_right_x_plus);  // Right +X (cam right  → Right Arrow default)
+    let sc_rx_minus = key_to_sdl_scancode(&b.axis_right_x_minus); // Right -X (cam left   → Left Arrow default)
+    let sc_ry_plus  = key_to_sdl_scancode(&b.axis_right_y_plus);  // Right +Y (cam down   → Down Arrow default)
+    let sc_ry_minus = key_to_sdl_scancode(&b.axis_right_y_minus); // Right -Y (cam up     → Up Arrow default)
+
+    // ─── Linux binary ──────────────────────────────────────────────────────────
+    // Anchor (unique prefix just before the stick scancode block):
+    //   f6 c4 01 74 06 41 c6 44 24 08 ff  f6 c4 02 74 06 41 c6 44 24 09 ff
+    // Layout after anchor (offsets relative to first byte after anchor):
+    //   +0 : 0f b6 55 [LX+]   +4 : 0f b6 45 [LX-]
+    //   +24: 0f b6 55 [LY+]   +28: 0f b6 45 [LY-]
+    //   +48: 0f b6 55 [RX+]   +52: 0f b6 45 [RX-]
+    //   +72: 0f b6 55 [RY+]   +76: 0f b6 45 [RY-]
+    let mut probe_candidates: Vec<PathBuf> = vec![
+        base_dir.join("bin/gow3-probe"),
+        base_dir.join("out/gow3-probe"),
+        base_dir.join("gow3-probe"),
+    ];
+    if !config.game_dir.is_empty() {
+        let gd = Path::new(&config.game_dir);
+        probe_candidates.push(gd.join("bin/gow3-probe"));
+        probe_candidates.push(gd.join("out/gow3-probe"));
+        probe_candidates.push(gd.join("gow3-probe"));
+    }
+    for probe_path in &probe_candidates {
+        if probe_path.is_file() {
+            patch_binary_linux(
+                probe_path,
+                sc_lx_plus, sc_lx_minus, sc_ly_plus, sc_ly_minus,
+                sc_rx_plus, sc_rx_minus, sc_ry_plus, sc_ry_minus,
+            );
+            break;
+        }
+    }
+
+    // ─── Windows binary ────────────────────────────────────────────────────────
+    // Anchor:
+    //   a9 00 01 00 00 74 04 c6 46 08 ff  a9 00 02 00 00 74 04 c6 46 09 ff
+    // Layout after anchor:
+    //   +0 : 0f b6 47 [LX-]   +4 : 0f b6 4f [LX+]
+    //   +36: 0f b6 4f [LY+]   +40: 0f b6 47 [LY-]
+    //   +72: 0f b6 4f [RX+]   +76: 0f b6 47 [RX-]
+    //   +108:0f b6 4f [RY+]  +112: 0f b6 47 [RY-]
+    let mut probe_exe_candidates: Vec<PathBuf> = vec![
+        base_dir.join("bin/gow3-probe.exe"),
+        base_dir.join("out/gow3-probe.exe"),
+        base_dir.join("gow3-probe.exe"),
+        base_dir.join("bin/gow3.exe"),
+        base_dir.join("gow3.exe"),
+        base_dir.join("God of War III.exe"),
+    ];
+    if !config.game_dir.is_empty() {
+        let gd = Path::new(&config.game_dir);
+        probe_exe_candidates.push(gd.join("bin/gow3-probe.exe"));
+        probe_exe_candidates.push(gd.join("out/gow3-probe.exe"));
+        probe_exe_candidates.push(gd.join("gow3-probe.exe"));
+        probe_exe_candidates.push(gd.join("bin/gow3.exe"));
+        probe_exe_candidates.push(gd.join("gow3.exe"));
+        probe_exe_candidates.push(gd.join("God of War III.exe"));
+    }
+    for probe_path in &probe_exe_candidates {
+        if probe_path.is_file() {
+            patch_binary_windows(
+                probe_path,
+                sc_lx_plus, sc_lx_minus, sc_ly_plus, sc_ly_minus,
+                sc_rx_plus, sc_rx_minus, sc_ry_plus, sc_ry_minus,
+            );
+            break;
+        }
+    }
+
+    Ok(())
+}
+
+fn patch_binary_linux(
+    path: &Path,
+    sc_lx_plus: Option<u8>, sc_lx_minus: Option<u8>,
+    sc_ly_plus: Option<u8>, sc_ly_minus: Option<u8>,
+    sc_rx_plus: Option<u8>, sc_rx_minus: Option<u8>,
+    sc_ry_plus: Option<u8>, sc_ry_minus: Option<u8>,
+) {
+    let anchor: &[u8] = &[
+        0xf6, 0xc4, 0x01, 0x74, 0x06, 0x41, 0xc6, 0x44, 0x24, 0x08, 0xff,
+        0xf6, 0xc4, 0x02, 0x74, 0x06, 0x41, 0xc6, 0x44, 0x24, 0x09, 0xff,
+    ];
+    let Ok(mut data) = fs::read(path) else { return };
+    let Some(pos) = find_bytes(&data, anchor) else { return };
+    let base = pos + anchor.len();
+
+    // Verify expected opcodes at each offset before patching
+    if !check_opcode(&data, base, 0, &[0x0f, 0xb6, 0x55]) { return }
+    if !check_opcode(&data, base, 4, &[0x0f, 0xb6, 0x45]) { return }
+    if !check_opcode(&data, base, 24, &[0x0f, 0xb6, 0x55]) { return }
+    if !check_opcode(&data, base, 28, &[0x0f, 0xb6, 0x45]) { return }
+    if !check_opcode(&data, base, 48, &[0x0f, 0xb6, 0x55]) { return }
+    if !check_opcode(&data, base, 52, &[0x0f, 0xb6, 0x45]) { return }
+    if !check_opcode(&data, base, 72, &[0x0f, 0xb6, 0x55]) { return }
+    if !check_opcode(&data, base, 76, &[0x0f, 0xb6, 0x45]) { return }
+
+    if let Some(v) = sc_lx_plus  { data[base + 3]  = v; }
+    if let Some(v) = sc_lx_minus { data[base + 7]  = v; }
+    if let Some(v) = sc_ly_plus  { data[base + 27] = v; }
+    if let Some(v) = sc_ly_minus { data[base + 31] = v; }
+    if let Some(v) = sc_rx_plus  { data[base + 51] = v; }
+    if let Some(v) = sc_rx_minus { data[base + 55] = v; }
+    if let Some(v) = sc_ry_plus  { data[base + 75] = v; }
+    if let Some(v) = sc_ry_minus { data[base + 79] = v; }
+
+    if let Err(_) = fs::write(path, &data) {
+        let tmp = path.with_extension("tmp_probe_patch");
+        if fs::write(&tmp, &data).is_ok() {
+            let _ = fs::rename(&tmp, path);
+        }
+    }
+    #[cfg(unix)]
+    {
+        use std::os::unix::fs::PermissionsExt;
+        let _ = fs::set_permissions(path, fs::Permissions::from_mode(0o755));
+    }
+    println!("[Input Patch] Analog stick keys patched in {:?}", path);
+}
+
+fn patch_binary_windows(
+    path: &Path,
+    sc_lx_plus: Option<u8>, sc_lx_minus: Option<u8>,
+    sc_ly_plus: Option<u8>, sc_ly_minus: Option<u8>,
+    sc_rx_plus: Option<u8>, sc_rx_minus: Option<u8>,
+    sc_ry_plus: Option<u8>, sc_ry_minus: Option<u8>,
+) {
+    let anchor: &[u8] = &[
+        0xa9, 0x00, 0x01, 0x00, 0x00, 0x74, 0x04, 0xc6, 0x46, 0x08, 0xff,
+        0xa9, 0x00, 0x02, 0x00, 0x00, 0x74, 0x04, 0xc6, 0x46, 0x09, 0xff,
+    ];
+    let Ok(mut data) = fs::read(path) else { return };
+    let Some(pos) = find_bytes(&data, anchor) else { return };
+    let base = pos + anchor.len();
+
+    // Verify expected opcodes at each offset before patching
+    if !check_opcode(&data, base, 0,   &[0x0f, 0xb6, 0x47]) { return }
+    if !check_opcode(&data, base, 4,   &[0x0f, 0xb6, 0x4f]) { return }
+    if !check_opcode(&data, base, 36,  &[0x0f, 0xb6, 0x4f]) { return }
+    if !check_opcode(&data, base, 40,  &[0x0f, 0xb6, 0x47]) { return }
+    if !check_opcode(&data, base, 72,  &[0x0f, 0xb6, 0x4f]) { return }
+    if !check_opcode(&data, base, 76,  &[0x0f, 0xb6, 0x47]) { return }
+    if !check_opcode(&data, base, 108, &[0x0f, 0xb6, 0x4f]) { return }
+    if !check_opcode(&data, base, 112, &[0x0f, 0xb6, 0x47]) { return }
+
+    if let Some(v) = sc_lx_minus { data[base + 3]   = v; }
+    if let Some(v) = sc_lx_plus  { data[base + 7]   = v; }
+    if let Some(v) = sc_ly_plus  { data[base + 39]  = v; }
+    if let Some(v) = sc_ly_minus { data[base + 43]  = v; }
+    if let Some(v) = sc_rx_plus  { data[base + 75]  = v; }
+    if let Some(v) = sc_rx_minus { data[base + 79]  = v; }
+    if let Some(v) = sc_ry_plus  { data[base + 111] = v; }
+    if let Some(v) = sc_ry_minus { data[base + 115] = v; }
+
+    if let Err(_) = fs::write(path, &data) {
+        let tmp = path.with_extension("tmp_probe_patch");
+        if fs::write(&tmp, &data).is_ok() {
+            let _ = fs::rename(&tmp, path);
+        }
+    }
+    #[cfg(unix)]
+    {
+        use std::os::unix::fs::PermissionsExt;
+        let _ = fs::set_permissions(path, fs::Permissions::from_mode(0o755));
+    }
+    println!("[Input Patch] Analog stick keys patched in {:?}", path);
+}
+
+fn find_bytes(haystack: &[u8], needle: &[u8]) -> Option<usize> {
+    haystack.windows(needle.len()).position(|w| w == needle)
+}
+
+fn check_opcode(data: &[u8], base: usize, offset: usize, expected: &[u8]) -> bool {
+    let start = base + offset;
+    if start + expected.len() > data.len() {
+        return false;
+    }
+    &data[start..start + expected.len()] == expected
+}
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+
+    #[test]
+    fn test_patch_analog_scancodes_synthetic() {
+        // Construct a synthetic buffer with the Linux anchor and opcodes
+        let anchor = [
+            0xf6, 0xc4, 0x01, 0x74, 0x06, 0x41, 0xc6, 0x44, 0x24, 0x08, 0xff,
+            0xf6, 0xc4, 0x02, 0x74, 0x06, 0x41, 0xc6, 0x44, 0x24, 0x09, 0xff,
+        ];
+        let mut buf = Vec::new();
+        buf.extend_from_slice(&[0x90; 16]); // nop padding
+        buf.extend_from_slice(&anchor);
+        let base = buf.len();
+
+        // 8 instructions:
+        // +0:  0f b6 55 07 (D)
+        // +4:  0f b6 45 04 (A)
+        // +8..+23: 16 dummy bytes
+        // +24: 0f b6 55 16 (S)
+        // +28: 0f b6 45 1a (W)
+        // +32..+47: 16 dummy bytes
+        // +48: 0f b6 55 4f (Right)
+        // +52: 0f b6 45 50 (Left)
+        // +56..+71: 16 dummy bytes
+        // +72: 0f b6 55 51 (Down)
+        // +76: 0f b6 45 52 (Up)
+        buf.extend_from_slice(&[0x0f, 0xb6, 0x55, 0x07]);
+        buf.extend_from_slice(&[0x0f, 0xb6, 0x45, 0x04]);
+        buf.extend_from_slice(&[0x00; 16]);
+        buf.extend_from_slice(&[0x0f, 0xb6, 0x55, 0x16]);
+        buf.extend_from_slice(&[0x0f, 0xb6, 0x45, 0x1a]);
+        buf.extend_from_slice(&[0x00; 16]);
+        buf.extend_from_slice(&[0x0f, 0xb6, 0x55, 0x4f]);
+        buf.extend_from_slice(&[0x0f, 0xb6, 0x45, 0x50]);
+        buf.extend_from_slice(&[0x00; 16]);
+        buf.extend_from_slice(&[0x0f, 0xb6, 0x55, 0x51]);
+        buf.extend_from_slice(&[0x0f, 0xb6, 0x45, 0x52]);
+        buf.extend_from_slice(&[0x90; 32]);
+
+        let tmp_file = std::env::temp_dir().join("test_gow3_probe_synthetic");
+        fs::write(&tmp_file, &buf).unwrap();
+
+        // Test patching: Left stick unchanged, Right stick -> I(12), K(14), J(13), L(15)
+        patch_binary_linux(
+            &tmp_file,
+            Some(7), Some(4), Some(22), Some(26),
+            Some(15), // RX+ = L
+            Some(13), // RX- = J
+            Some(14), // RY+ = K
+            Some(12), // RY- = I
+        );
+
+        let patched = fs::read(&tmp_file).unwrap();
+        let _ = fs::remove_file(&tmp_file);
+
+        assert_eq!(patched[base + 51], 15); // RX+ = L
+        assert_eq!(patched[base + 55], 13); // RX- = J
+        assert_eq!(patched[base + 75], 14); // RY+ = K
+        assert_eq!(patched[base + 79], 12); // RY- = I
+    }
+}
@@ -5,8 +5,8 @@ use std::process::Command;
 use crate::config::LauncherConfig;
 use crate::tuner::apply_settings;

-pub const GITHUB_REPO: &str = "ScreamAngel/gow3_pclauncher";
-pub const GITHUB_REPO_URL: &str = "https://github.com/ScreamAngel/gow3_pclauncher.git";
+pub const GITHUB_REPO: &str = "ScreamAngel/gow3_launcher";
+pub const GITHUB_REPO_URL: &str = "https://github.com/ScreamAngel/gow3_launcher.git";

 #[derive(Debug, Clone)]
 pub struct UpdateInfo {
@@ -16,52 +16,126 @@ pub struct UpdateInfo {
    pub is_new: bool,
 }

-pub fn check_github_update(current_commit: &str) -> Result<UpdateInfo, String> {
-    // 1. Fetch remote commit SHA using git ls-remote (fast, no GitHub API rate limit)
-    let output = Command::new("git")
-        .args(["ls-remote", GITHUB_REPO_URL, "HEAD"])
-        .output()
-        .map_err(|e| format!("git ls-remote failed: {}", e))?;
+fn is_git_available() -> bool {
+    Command::new("git").arg("--version").output().map(|o| o.status.success()).unwrap_or(false)
+}

-    if !output.status.success() {
-        return Err("GitHub deposuna ulaşılamadı veya internet bağlantısı yok.".to_string());
-    }
-
-    let text = String::from_utf8_lossy(&output.stdout);
-    let remote_sha = text
-        .lines()
-        .next()
-        .and_then(|ln| ln.split_whitespace().next())
-        .ok_or_else(|| "Uzak commit SHA değeri okunamadı.".to_string())?
-        .to_string();
-
-    // 2. Fetch commit details (message and date) via curl from GitHub API if available
-    let mut commit_message = "En son optimizasyonlar ve güncellemeler".to_string();
-    let mut commit_date = String::new();
-
-    let api_url = format!("https://api.github.com/repos/{}/commits/HEAD", GITHUB_REPO);
-    if let Ok(api_out) = Command::new("curl")
-        .args([
-            "-s",
-            "-H",
-            "User-Agent: gow3-launcher",
-            &api_url,
-        ])
+fn http_get_string(url: &str) -> Option<String> {
+    // 1. Try curl (installed on Linux, macOS, and modern Windows 10+)
+    if let Ok(out) = Command::new("curl")
+        .args(["-fsSL", "-H", "User-Agent: gow3-launcher", url])
        .output()
    {
-        if api_out.status.success() {
-            let json_str = String::from_utf8_lossy(&api_out.stdout);
-            if let Ok(val) = serde_json::from_str::<serde_json::Value>(&json_str) {
-                if let Some(msg) = val["commit"]["message"].as_str() {
-                    commit_message = msg.lines().next().unwrap_or(msg).to_string();
-                }
-                if let Some(d) = val["commit"]["committer"]["date"].as_str() {
-                    commit_date = d.split('T').next().unwrap_or(d).to_string();
+        if out.status.success() {
+            let body = String::from_utf8_lossy(&out.stdout).to_string();
+            if !body.trim().is_empty() {
+                return Some(body);
+            }
+        }
+    }
+
+    // 2. Fallback to PowerShell (native on all Windows installations)
+    #[cfg(target_os = "windows")]
+    {
+        let ps_code = format!(
+            "[Net.ServicePointManager]::SecurityProtocol = [Net.SecurityProtocolType]::Tls12; \
+             $wc = New-Object System.Net.WebClient; \
+             $wc.Headers.Add('User-Agent', 'gow3-launcher'); \
+             $wc.DownloadString('{}')",
+            url.replace('\'', "''")
+        );
+        if let Ok(out) = Command::new("powershell")
+            .args(["-NoProfile", "-ExecutionPolicy", "Bypass", "-Command", &ps_code])
+            .output()
+        {
+            if out.status.success() {
+                let body = String::from_utf8_lossy(&out.stdout).to_string();
+                if !body.trim().is_empty() {
+                    return Some(body);
                }
            }
        }
    }

+    None
+}
+
+fn http_download_file(url: &str, dest: &Path) -> Result<(), String> {
+    // 1. Try curl
+    if let Ok(out) = Command::new("curl")
+        .args(["-fsSL", "-H", "User-Agent: gow3-launcher", url, "-o", dest.to_str().unwrap_or("")])
+        .output()
+    {
+        if out.status.success() && dest.is_file() {
+            return Ok(());
+        }
+    }
+
+    // 2. Fallback to PowerShell on Windows
+    #[cfg(target_os = "windows")]
+    {
+        let ps_code = format!(
+            "[Net.ServicePointManager]::SecurityProtocol = [Net.SecurityProtocolType]::Tls12; \
+             $wc = New-Object System.Net.WebClient; \
+             $wc.Headers.Add('User-Agent', 'gow3-launcher'); \
+             $wc.DownloadFile('{}', '{}')",
+            url.replace('\'', "''"),
+            dest.to_string_lossy().replace('\'', "''")
+        );
+        if let Ok(out) = Command::new("powershell")
+            .args(["-NoProfile", "-ExecutionPolicy", "Bypass", "-Command", &ps_code])
+            .output()
+        {
+            if out.status.success() && dest.is_file() {
+                return Ok(());
+            }
+        }
+    }
+
+    Err("Dosya indirilemedi.".to_string())
+}
+
+pub fn check_github_update(current_commit: &str) -> Result<UpdateInfo, String> {
+    let api_url = format!("https://api.github.com/repos/{}/commits/HEAD", GITHUB_REPO);
+
+    let mut remote_sha = String::new();
+    let mut commit_message = "En son optimizasyonlar ve güncellemeler".to_string();
+    let mut commit_date = String::new();
+
+    // Fetch commit info via GitHub API
+    if let Some(json_str) = http_get_string(&api_url) {
+        if let Ok(val) = serde_json::from_str::<serde_json::Value>(&json_str) {
+            if let Some(sha) = val["sha"].as_str() {
+                remote_sha = sha.to_string();
+            }
+            if let Some(msg) = val["commit"]["message"].as_str() {
+                commit_message = msg.lines().next().unwrap_or(msg).to_string();
+            }
+            if let Some(d) = val["commit"]["committer"]["date"].as_str() {
+                commit_date = d.split('T').next().unwrap_or(d).to_string();
+            }
+        }
+    }
+
+    // Fallback: only if GitHub API failed AND git is installed on system
+    if remote_sha.is_empty() && is_git_available() {
+        if let Ok(output) = Command::new("git")
+            .args(["ls-remote", GITHUB_REPO_URL, "HEAD"])
+            .output()
+        {
+            if output.status.success() {
+                let text = String::from_utf8_lossy(&output.stdout);
+                if let Some(sha) = text.lines().next().and_then(|ln| ln.split_whitespace().next()) {
+                    remote_sha = sha.to_string();
+                }
+            }
+        }
+    }
+
+    if remote_sha.is_empty() {
+        return Err("GitHub deposuna ulaşılamadı. İnternet bağlantınızı kontrol edin veya daha sonra tekrar deneyin.".to_string());
+    }
+
    let is_new = current_commit.trim().is_empty() || current_commit.trim() != remote_sha.trim();

    Ok(UpdateInfo {
@@ -78,19 +152,15 @@ pub fn apply_github_update(
    config: &mut LauncherConfig,
 ) -> Result<String, String> {
    let binary_name = if cfg!(target_os = "windows") {
-        if base_dir.join("gow3_launcher_win.exe").is_file() {
-            "gow3_launcher_win.exe"
-        } else {
-            "gow3-launcher-win.exe"
-        }
+        "gow3-launcher-win.exe"
    } else {
        "gow3-launcher"
    };

-    let is_git_repo = base_dir.join(".git").is_dir();
+    let is_git_repo = base_dir.join(".git").is_dir() && is_git_available();

    if is_git_repo {
-        // Path A: User cloned via git, perform git pull
+        // Path A: User cloned via git and git is available on system
        let pull_output = Command::new("git")
            .args(["pull", "origin", "main"])
            .current_dir(base_dir)
@@ -102,7 +172,6 @@ pub fn apply_github_update(
            return Err(format!("Git güncellemesi başarısız oldu: {}", err));
        }

-        // Ensure launcher binary is executable
        let launcher_bin = base_dir.join(binary_name);
        if launcher_bin.is_file() {
            #[cfg(unix)]
@@ -112,7 +181,7 @@ pub fn apply_github_update(
            }
        }
    } else {
-        // Path B: Standalone folder without .git; download latest launcher binary and patch files
+        // Path B: Standalone folder or git not installed; download latest launcher binary and patch files
        let raw_launcher_url = format!(
            "https://raw.githubusercontent.com/{}/main/{}",
            GITHUB_REPO, binary_name
@@ -120,15 +189,8 @@ pub fn apply_github_update(
        let launcher_bin = base_dir.join(binary_name);
        let launcher_tmp = base_dir.join(format!("{}.new", binary_name));

-        let download = Command::new("curl")
-            .args(["-fsSL", &raw_launcher_url, "-o", launcher_tmp.to_str().unwrap()])
-            .output()
-            .map_err(|e| format!("Yeni launcher indirilemedi: {}", e))?;
-
-        if !download.status.success() {
-            let _ = fs::remove_file(&launcher_tmp);
-            return Err("GitHub üzerinden yeni launcher ikili dosyası indirilemedi.".to_string());
-        }
+        http_download_file(&raw_launcher_url, &launcher_tmp)
+            .map_err(|e| format!("Yeni launcher indirilemedi ({}): {}", raw_launcher_url, e))?;

        #[cfg(unix)]
        {
@@ -143,7 +205,6 @@ pub fn apply_github_update(
            let _ = fs::rename(&launcher_bin, &launcher_old);
        }

-        // Atomically replace running binary
        fs::rename(&launcher_tmp, &launcher_bin)
            .map_err(|e| format!("Launcher güncellenemedi: {}", e))?;

@@ -155,22 +216,11 @@ pub fn apply_github_update(
            GITHUB_REPO
        );
        let patch_dest = patches_dir.join("God_of_War_III_Remastered.xml");
-        let _ = Command::new("curl")
-            .args(["-fsSL", &raw_patch_url, "-o", patch_dest.to_str().unwrap()])
-            .output();
+        let _ = http_download_file(&raw_patch_url, &patch_dest);
    }

-    // Re-apply optimizations and settings
-    let _ = apply_settings(
-        base_dir,
-        config.target_fps,
-        config.patch_delta_time,
-        config.patch_readbacks,
-        config.vram_gc_budget_mb,
-        config.dmem_mb,
-    );
+    let _ = apply_settings(base_dir, config);

-    // Update last_git_commit in config
    config.last_git_commit = update.commit_sha.clone();
    let _ = config.save(base_dir);

@@ -1,7 +1,7 @@
 {
  "first_launch_done": true,
  "language": "tr",
-  "game_dir": "/home/screamangel/İndirilenler/GOW3 Emu Linux/CUSA01623",
+  "game_dir": "/home/screamangel/İndirilenler/GOW3 Emu Linux/CUSA01715",
  "target_fps": 60,
  "patch_delta_time": true,
  "patch_readbacks": true,
@@ -15,5 +15,37 @@
    "ram_mb": 15603,
    "refresh_rate_hz": 144
  },
-  "last_git_commit": "c5638d9956002b8a9f09a240028f6793ddf7b2f8"
+  "last_git_commit": "0b4abe07acb711848d1b5d72402a9de8c0ad9844",
+  "display_mode": "Borderless",
+  "vsync": true,
+  "background_controller_input": false,
+  "is_motion_controls_enabled": true,
+  "deadzone_left": 2,
+  "deadzone_right": 2,
+  "keyboard_bindings": {
+    "triangle": "c",
+    "circle": "b",
+    "cross": "n",
+    "square": "v",
+    "l1": "q",
+    "r1": "u",
+    "l2": "e",
+    "r2": "o",
+    "l3": "x",
+    "r3": "m",
+    "options": "enter",
+    "touchpad_center": "space",
+    "pad_up": "up",
+    "pad_down": "down",
+    "pad_left": "left",
+    "pad_right": "right",
+    "axis_left_x_minus": "a",
+    "axis_left_x_plus": "d",
+    "axis_left_y_minus": "w",
+    "axis_left_y_plus": "s",
+    "axis_right_x_minus": "j",
+    "axis_right_x_plus": "l",
+    "axis_right_y_minus": "i",
+    "axis_right_y_plus": "k"
+  }
 }
Author	SHA1	Message	Date
ScreamAngel	5f7e3bb850	feat: fix right stick scancode patching, rename camera labels, and fix windows updater without git	2026-10-24 02:06:37 +03:00
ScreamAngel	67bc336216	Update README.md	2026-10-23 00:16:26 +03:00
ScreamAngel	8e4ebbbcb9	Update README.md	2026-10-22 19:55:57 +03:00
ScreamAngel	1b2e0b566a	Update README.md	2026-10-22 17:16:33 +03:00
ScreamAngel	10a9a95862	fix(ui): replace unicode emojis with vector-drawn PS badges and clean tags to prevent tofu boxes	2026-10-22 15:07:29 +03:00
ScreamAngel	fa50be4b24	feat(ui): modernize launcher with breathing animations, segmented tabs, stat tiles, and PS icons	2026-10-22 14:42:35 +03:00
ScreamAngel	4093ee43c1	feat: add config tab, input settings, force quit fix, and windows windowed mode	2026-10-22 00:06:03 +03:00
ScreamAngel	4f6c6788d0	feat: add AppImage & Windows portable single executable build workflow	2026-10-21 01:04:50 +03:00
ScreamAngel	47437d280b	fix(ui): immediately update top status message when selecting game directory	2026-10-20 20:14:10 +03:00
ScreamAngel	e82257aa27	chore(build): sync newly built Windows binaries with scanner fix	2026-10-20 20:06:58 +03:00
ScreamAngel	5991b03cd0	fix(scanner): show dedicated modal and warning banner when game is not found	2026-10-20 19:55:37 +03:00
ScreamAngel	dc3df87384	ci: remove automated GitHub Actions workflow	2026-10-19 19:52:36 +03:00
ScreamAngel	a9e5233ae7	chore(build): sync gow3-launcher-win.exe to repo root [skip ci]	2026-10-19 00:57:25 +00:00
ScreamAngel	410c5fc0b7	Update README.md	2026-10-19 03:50:19 +03:00
ScreamAngel	e6cec74c96	Update README.md	2026-10-19 03:49:09 +03:00
ScreamAngel	c65f1acb1b	Update README.md	2026-10-19 03:46:23 +03:00
ScreamAngel	f1b3cfae29	Update README.md	2026-10-19 03:45:14 +03:00
ScreamAngel	0614038175	chore(build): sync gow3-launcher-win.exe to repo root [skip ci]	2026-10-18 23:38:27 +00:00
ScreamAngel	66efe4ec0e	Update README.md	2026-10-19 02:32:43 +03:00
ScreamAngel	0a7fb20aa9	chore(build): sync gow3-launcher-win.exe to repo root [skip ci]	2026-10-17 15:21:09 +00:00
ScreamAngel	709845f472	Merge branch 'origin/main' and resolve binary conflicts	2026-10-17 18:12:16 +03:00
ScreamAngel	f90f25f033	feat(engine): add cross-platform auto engine downloader & standalone deployment support	2026-10-17 16:13:11 +03:00
ScreamAngel	08e46e6675	chore(build): sync gow3-launcher-win.exe to repo root [skip ci]	2026-10-17 12:08:20 +00:00
EgEhE	29e57c38e5	Delete gow3_launcher_win.exe This file should be in relases	2026-10-17 15:00:55 +03:00
EgEhE	1ade24e88c	Delete gow3-launcher This file should be in relases	2026-10-17 14:59:02 +03:00
EgEhE	b7e366e893	Delete gow3-launcher-win.exe This file should be in relases	2026-10-17 14:58:19 +03:00
ScreamAngel	1179c01ddf	fix(launcher): resolve Win32 os error 193 & UI stutter, add Windows engine downloader	2026-10-17 14:41:00 +03:00
ScreamAngel	765fa79ecd	chore(build): sync gow3-launcher-win.exe to repo root [skip ci]	2026-10-17 10:41:23 +00:00
ScreamAngel	01771af1d7	fix(windows): resolve VRAM detection cap and add portable Python dependency downloader	2026-10-17 13:34:54 +03:00
ScreamAngel	5d1de303af	chore(build): sync gow3-launcher-win.exe to repo root [skip ci]	2026-10-17 09:45:12 +00:00
ScreamAngel	4326563b9d	README.md	2026-10-17 12:39:50 +03:00
ScreamAngel	bc48a858f0	README.md	2026-10-17 12:38:20 +03:00
ScreamAngel	d96f683944	chore(build): sync gow3-launcher-win.exe to repo root [skip ci]	2026-10-17 09:34:26 +00:00