Merge pull request #1 from auser1337/test

wahhhh
2025-04-22 04:24:44 +00:00 · 2024-10-05 23:25:16 -07:00 · 2024-10-05 23:25:16 -07:00 · 53d936f5fa
commit 53d936f5fa
parent a805653061 8d6afc98a8
340 changed files with 65079 additions and 28462 deletions
--- a/.github/FUNDING.yml
+++ b/.github/FUNDING.yml
@ -0,0 +1 @@
+ko_fi: shadps4
--- a/.github/linux-appimage-qt.sh
+++ b/.github/linux-appimage-qt.sh
@ -19,12 +19,13 @@ chmod a+x linuxdeploy-x86_64.AppImage
 chmod a+x linuxdeploy-plugin-qt-x86_64.AppImage
 chmod a+x linuxdeploy-plugin-checkrt-x86_64.sh

-
 # Build AppImage
 ./linuxdeploy-x86_64.AppImage --appdir AppDir
 ./linuxdeploy-plugin-checkrt-x86_64.sh --appdir AppDir

 cp -a "$GITHUB_WORKSPACE/build/translations" AppDir/usr/bin

-./linuxdeploy-x86_64.AppImage --appdir AppDir -d "$GITHUB_WORKSPACE"/.github/shadps4.desktop  -e "$GITHUB_WORKSPACE"/build/shadps4 -i "$GITHUB_WORKSPACE"/.github/shadps4.png --plugin qt --output appimage
+./linuxdeploy-x86_64.AppImage --appdir AppDir -d "$GITHUB_WORKSPACE"/.github/shadps4.desktop  -e "$GITHUB_WORKSPACE"/build/shadps4 -i "$GITHUB_WORKSPACE"/.github/shadps4.png --plugin qt 
+rm AppDir/usr/plugins/multimedia/libgstreamermediaplugin.so
+./linuxdeploy-x86_64.AppImage --appdir AppDir --output appimage
 mv Shadps4-x86_64.AppImage Shadps4-qt.AppImage
--- a/.github/workflows/build.yml
+++ b/.github/workflows/build.yml
@ -0,0 +1,481 @@
+# SPDX-FileCopyrightText: 2024 shadPS4 Emulator Project
+# SPDX-License-Identifier: GPL-2.0-or-later
+
+name: Build and Release
+
+on: [push, pull_request]
+
+concurrency:
+  group: ci-${{ github.event_name }}-${{ github.ref }}
+  cancel-in-progress: ${{ github.event_name == 'push' }}
+
+env:
+  BUILD_TYPE: Release
+
+jobs:
+  reuse:
+    runs-on: ubuntu-latest
+    continue-on-error: true
+    steps:
+    - uses: actions/checkout@v4
+    - uses: fsfe/reuse-action@v4
+
+  clang-format:
+    runs-on: ubuntu-latest
+    continue-on-error: true
+    steps:
+    - uses: actions/checkout@v4
+      with:
+        fetch-depth: 0
+    - name: Install
+      run: |
+        wget -O - https://apt.llvm.org/llvm-snapshot.gpg.key | sudo apt-key add -
+        sudo add-apt-repository 'deb http://apt.llvm.org/jammy/ llvm-toolchain-jammy-17 main'
+        sudo apt update
+        sudo apt install clang-format-17
+    - name: Build
+      env:
+        COMMIT_RANGE: ${{ github.event.pull_request.base.sha }}..${{ github.event.pull_request.head.sha }}
+      run: ./.ci/clang-format.sh
+      
+  get-info:
+    runs-on: ubuntu-latest
+    outputs:
+      date: ${{ steps.vars.outputs.date }}
+      shorthash: ${{ steps.vars.outputs.shorthash }}
+    steps:
+    - uses: actions/checkout@v4
+    - name: Get date and git hash
+      id: vars
+      run: |
+        echo "date=$(date +'%Y-%m-%d')" >> $GITHUB_ENV
+        echo "shorthash=$(git rev-parse --short HEAD)" >> $GITHUB_ENV
+        echo "date=$(date +'%Y-%m-%d')" >> $GITHUB_OUTPUT
+        echo "shorthash=$(git rev-parse --short HEAD)" >> $GITHUB_OUTPUT
+
+  windows-sdl:
+    runs-on: windows-latest
+    needs: get-info
+    steps:
+    - uses: actions/checkout@v4
+      with:
+        submodules: recursive
+
+    - name: Cache CMake Configuration
+      uses: actions/cache@v4
+      env:
+          cache-name: ${{ runner.os }}-sdl-ninja-cache-cmake-configuration
+      with:
+          path: | 
+            ${{github.workspace}}/build
+          key: ${{ env.cache-name }}-${{ hashFiles('**/CMakeLists.txt', 'cmake/**') }}
+          restore-keys: |
+            ${{ env.cache-name }}-
+
+    - name: Cache CMake Build
+      uses: hendrikmuhs/ccache-action@v1.2.14
+      env:
+          cache-name: ${{ runner.os }}-sdl-cache-cmake-build
+      with:
+        append-timestamp: false
+        key: ${{ env.cache-name }}-${{ hashFiles('**/CMakeLists.txt', 'cmake/**') }}
+
+    - name: Setup VS Environment
+      uses: ilammy/msvc-dev-cmd@v1.13.0
+      with:
+        arch: amd64
+
+    - name: Configure CMake
+      run: cmake --fresh -G Ninja -B ${{github.workspace}}/build -DCMAKE_BUILD_TYPE=${{env.BUILD_TYPE}} -DCMAKE_C_COMPILER=clang-cl -DCMAKE_CXX_COMPILER=clang-cl -DCMAKE_C_COMPILER_LAUNCHER=ccache -DCMAKE_CXX_COMPILER_LAUNCHER=ccache
+
+    - name: Build
+      run: cmake --build ${{github.workspace}}/build --config ${{env.BUILD_TYPE}} --parallel
+
+    - name: Upload Windows SDL artifact
+      uses: actions/upload-artifact@v4
+      with:
+        name: shadps4-win64-sdl-${{ needs.get-info.outputs.date }}-${{ needs.get-info.outputs.shorthash }}
+        path: ${{github.workspace}}/build/shadPS4.exe
+
+  windows-qt:
+    runs-on: windows-latest
+    needs: get-info
+    steps:
+    - uses: actions/checkout@v4
+      with:
+        submodules: recursive
+
+    - name: Setup Qt
+      uses: jurplel/install-qt-action@v4
+      with:
+        version: 6.7.3
+        host: windows
+        target: desktop
+        arch: win64_msvc2019_64
+        archives: qtbase qttools
+        modules: qtmultimedia
+
+    - name: Cache CMake Configuration
+      uses: actions/cache@v4
+      env:
+          cache-name: ${{ runner.os }}-qt-ninja-cache-cmake-configuration
+      with:
+          path: | 
+            ${{github.workspace}}/build
+          key: ${{ env.cache-name }}-${{ hashFiles('**/CMakeLists.txt', 'cmake/**') }}
+          restore-keys: |
+            ${{ env.cache-name }}-
+
+    - name: Cache CMake Build
+      uses: hendrikmuhs/ccache-action@v1.2.14
+      env:
+          cache-name: ${{ runner.os }}-qt-cache-cmake-build
+      with:
+        append-timestamp: false
+        key: ${{ env.cache-name }}-${{ hashFiles('**/CMakeLists.txt', 'cmake/**') }}
+
+    - name: Setup VS Environment
+      uses: ilammy/msvc-dev-cmd@v1.13.0
+      with:
+        arch: amd64
+
+    - name: Configure CMake
+      run: cmake --fresh -G Ninja -B ${{github.workspace}}/build -DCMAKE_BUILD_TYPE=${{env.BUILD_TYPE}} -DENABLE_QT_GUI=ON -DCMAKE_C_COMPILER=clang-cl -DCMAKE_CXX_COMPILER=clang-cl -DCMAKE_C_COMPILER_LAUNCHER=ccache -DCMAKE_CXX_COMPILER_LAUNCHER=ccache
+
+    - name: Build
+      run: cmake --build ${{github.workspace}}/build --config ${{env.BUILD_TYPE}} --parallel
+
+    - name: Deploy and Package
+      run: |
+        mkdir upload
+        move build/shadPS4.exe upload
+        windeployqt --no-compiler-runtime --no-system-d3d-compiler --no-system-dxc-compiler --dir upload upload/shadPS4.exe
+        Compress-Archive -Path upload/* -DestinationPath shadps4-win64-qt-${{ needs.get-info.outputs.date }}-${{ needs.get-info.outputs.shorthash }}.zip
+
+    - name: Upload Windows Qt artifact
+      uses: actions/upload-artifact@v4
+      with:
+        name: shadps4-win64-qt-${{ needs.get-info.outputs.date }}-${{ needs.get-info.outputs.shorthash }}
+        path: upload/
+
+  macos-sdl:
+    runs-on: macos-latest
+    needs: get-info
+    steps:
+    - uses: actions/checkout@v4
+      with:
+        submodules: recursive
+
+    - name: Setup latest Xcode
+      uses: maxim-lobanov/setup-xcode@v1
+      with:
+        xcode-version: latest
+
+    - name: Install MoltenVK
+      run: |
+        arch -x86_64 /bin/bash -c "$(curl -fsSL https://raw.githubusercontent.com/Homebrew/install/HEAD/install.sh)"
+        arch -x86_64 /usr/local/bin/brew install molten-vk
+
+    - name: Cache CMake Configuration
+      uses: actions/cache@v4 
+      env: 
+          cache-name: ${{ runner.os }}-sdl-cache-cmake-configuration
+      with: 
+          path: |  
+            ${{github.workspace}}/build 
+          key: ${{ env.cache-name }}-${{ hashFiles('**/CMakeLists.txt', 'cmake/**') }} 
+          restore-keys: | 
+            ${{ env.cache-name }}- 
+
+    - name: Cache CMake Build
+      uses: hendrikmuhs/ccache-action@v1.2.14
+      env:
+          cache-name: ${{runner.os}}-sdl-cache-cmake-build
+      with:
+        append-timestamp: false
+        create-symlink: true
+        key: ${{env.cache-name}}-${{ hashFiles('**/CMakeLists.txt', 'cmake/**') }}
+        variant: sccache
+
+    - name: Configure CMake
+      run: cmake --fresh -B ${{github.workspace}}/build -DCMAKE_BUILD_TYPE=${{env.BUILD_TYPE}} -DCMAKE_OSX_ARCHITECTURES=x86_64 -DCMAKE_C_COMPILER_LAUNCHER=sccache -DCMAKE_CXX_COMPILER_LAUNCHER=sccache
+
+    - name: Build
+      run: cmake --build ${{github.workspace}}/build --config ${{env.BUILD_TYPE}} --parallel $(sysctl -n hw.ncpu)
+
+    - name: Package and Upload macOS SDL artifact
+      run: |
+        mkdir upload
+        mv ${{github.workspace}}/build/shadps4 upload
+        cp $(arch -x86_64 /usr/local/bin/brew --prefix)/opt/molten-vk/lib/libMoltenVK.dylib upload
+        tar cf shadps4-macos-sdl.tar.gz -C upload .
+    - uses: actions/upload-artifact@v4
+      with:
+        name: shadps4-macos-sdl-${{ needs.get-info.outputs.date }}-${{ needs.get-info.outputs.shorthash }}
+        path: shadps4-macos-sdl.tar.gz
+
+  macos-qt:
+    runs-on: macos-latest
+    needs: get-info
+    steps:
+    - uses: actions/checkout@v4
+      with:
+        submodules: recursive
+
+    - name: Setup latest Xcode
+      uses: maxim-lobanov/setup-xcode@v1
+      with:
+        xcode-version: latest
+
+    - name: Install MoltenVK and Setup Qt
+      run: |
+        arch -x86_64 /bin/bash -c "$(curl -fsSL https://raw.githubusercontent.com/Homebrew/install/HEAD/install.sh)"
+        arch -x86_64 /usr/local/bin/brew install molten-vk
+    - uses: jurplel/install-qt-action@v4
+      with:
+        version: 6.7.3
+        host: mac
+        target: desktop
+        arch: clang_64
+        archives: qtbase qttools
+        modules: qtmultimedia
+        
+    - name: Cache CMake Configuration
+      uses: actions/cache@v4 
+      env: 
+          cache-name: ${{ runner.os }}-qt-cache-cmake-configuration
+      with: 
+          path: |  
+            ${{github.workspace}}/build 
+          key: ${{ env.cache-name }}-${{ hashFiles('**/CMakeLists.txt', 'cmake/**') }} 
+          restore-keys: | 
+            ${{ env.cache-name }}- 
+
+    - name: Cache CMake Build
+      uses: hendrikmuhs/ccache-action@v1.2.14
+      env:
+          cache-name: ${{runner.os}}-qt-cache-cmake-build
+      with:
+        append-timestamp: false
+        create-symlink: true
+        key: ${{env.cache-name}}-${{ hashFiles('**/CMakeLists.txt', 'cmake/**') }}
+        variant: sccache
+
+    - name: Configure CMake
+      run: cmake --fresh -B ${{github.workspace}}/build -DCMAKE_BUILD_TYPE=${{env.BUILD_TYPE}} -DCMAKE_OSX_ARCHITECTURES=x86_64 -DENABLE_QT_GUI=ON -DCMAKE_C_COMPILER_LAUNCHER=sccache -DCMAKE_CXX_COMPILER_LAUNCHER=sccache
+
+    - name: Build
+      run: cmake --build ${{github.workspace}}/build --config ${{env.BUILD_TYPE}} --parallel $(sysctl -n hw.ncpu)
+
+    - name: Package and Upload macOS Qt artifact
+      run: |
+        mkdir upload
+        mv ${{github.workspace}}/build/shadps4.app upload
+        macdeployqt upload/shadps4.app
+        tar cf shadps4-macos-qt.tar.gz -C upload .
+    - uses: actions/upload-artifact@v4
+      with:
+        name: shadps4-macos-qt-${{ needs.get-info.outputs.date }}-${{ needs.get-info.outputs.shorthash }}
+        path: shadps4-macos-qt.tar.gz
+
+  linux-sdl:
+    runs-on: ubuntu-24.04
+    needs: get-info
+    steps:
+    - uses: actions/checkout@v4
+      with:
+        submodules: recursive
+
+    - name: Install dependencies
+      run: sudo apt-get update && sudo apt install -y libx11-dev libxext-dev libwayland-dev libfuse2 clang build-essential libasound2-dev libpulse-dev libopenal-dev
+
+    - name: Cache CMake Configuration
+      uses: actions/cache@v4 
+      env: 
+          cache-name: ${{ runner.os }}-sdl-cache-cmake-configuration
+      with: 
+          path: |  
+            ${{github.workspace}}/build 
+          key: ${{ env.cache-name }}-${{ hashFiles('**/CMakeLists.txt', 'cmake/**') }} 
+          restore-keys: | 
+            ${{ env.cache-name }}- 
+
+    - name: Cache CMake Build
+      uses: hendrikmuhs/ccache-action@v1.2.14
+      env:
+          cache-name: ${{ runner.os }}-sdl-cache-cmake-build
+      with:
+        append-timestamp: false
+        key: ${{ env.cache-name }}-${{ hashFiles('**/CMakeLists.txt', 'cmake/**') }}
+
+    - name: Configure CMake
+      run: cmake --fresh -B ${{github.workspace}}/build -DCMAKE_BUILD_TYPE=${{env.BUILD_TYPE}} -DCMAKE_C_COMPILER=clang -DCMAKE_CXX_COMPILER=clang++ -DCMAKE_C_COMPILER_LAUNCHER=ccache -DCMAKE_CXX_COMPILER_LAUNCHER=ccache
+
+    - name: Build
+      run: cmake --build ${{github.workspace}}/build --config ${{env.BUILD_TYPE}} --parallel
+  
+    - name: Package and Upload Linux(ubuntu64) SDL artifact 
+      run: |
+        ls -la ${{ github.workspace }}/build/shadps4
+    
+    - uses: actions/upload-artifact@v4
+      with:
+        name: shadps4-ubuntu64-${{ needs.get-info.outputs.date }}-${{ needs.get-info.outputs.shorthash }}
+        path: ${{ github.workspace }}/build/shadps4
+
+    - name: Run AppImage packaging script
+      run:  ./.github/linux-appimage-sdl.sh
+      
+    - name: Package and Upload Linux SDL artifact
+      run: |
+        tar cf shadps4-linux-sdl.tar.gz -C ${{github.workspace}}/build shadps4
+    - uses: actions/upload-artifact@v4
+      with:
+        name: shadps4-linux-sdl-${{ needs.get-info.outputs.date }}-${{ needs.get-info.outputs.shorthash }}
+        path: Shadps4-sdl.AppImage
+
+  linux-qt:
+    runs-on: ubuntu-24.04
+    needs: get-info
+    steps:
+    - uses: actions/checkout@v4
+      with:
+        submodules: recursive
+
+    - name: Install dependencies
+      run: sudo apt-get update && sudo apt install -y libx11-dev libxext-dev libwayland-dev libfuse2 clang build-essential qt6-base-dev qt6-tools-dev qt6-multimedia-dev libasound2-dev libpulse-dev libopenal-dev
+
+    - name: Cache CMake Configuration
+      uses: actions/cache@v4 
+      env: 
+          cache-name: ${{ runner.os }}-qt-cache-cmake-configuration
+      with: 
+          path: |  
+            ${{github.workspace}}/build 
+          key: ${{ env.cache-name }}-${{ hashFiles('**/CMakeLists.txt', 'cmake/**') }} 
+          restore-keys: | 
+            ${{ env.cache-name }}- 
+
+    - name: Cache CMake Build
+      uses: hendrikmuhs/ccache-action@v1.2.14
+      env:
+          cache-name: ${{ runner.os }}-qt-cache-cmake-build
+      with:
+        append-timestamp: false
+        key: ${{ env.cache-name }}-${{ hashFiles('**/CMakeLists.txt', 'cmake/**') }}
+
+    - name: Configure CMake
+      run: cmake --fresh -B ${{github.workspace}}/build -DCMAKE_BUILD_TYPE=${{env.BUILD_TYPE}} -DCMAKE_C_COMPILER=clang -DCMAKE_CXX_COMPILER=clang++ -DENABLE_QT_GUI=ON -DCMAKE_C_COMPILER_LAUNCHER=ccache -DCMAKE_CXX_COMPILER_LAUNCHER=ccache
+
+    - name: Build
+      run: cmake --build ${{github.workspace}}/build --config ${{env.BUILD_TYPE}} --parallel
+
+    - name: Run AppImage packaging script
+      run:  ./.github/linux-appimage-qt.sh
+
+    - name: Package and Upload Linux Qt artifact
+      run: |
+        tar cf shadps4-linux-qt.tar.gz -C ${{github.workspace}}/build shadps4
+    - uses: actions/upload-artifact@v4
+      with:
+        name: shadps4-linux-qt-${{ needs.get-info.outputs.date }}-${{ needs.get-info.outputs.shorthash }}
+        path: Shadps4-qt.AppImage
+
+  pre-release:
+    if: github.ref == 'refs/heads/main' && github.repository == 'shadps4-emu/shadPS4' && github.event_name == 'push'
+    needs: [get-info, windows-sdl, windows-qt, macos-sdl, macos-qt, linux-sdl, linux-qt]
+    runs-on: ubuntu-latest
+    steps:
+    - name: Download all artifacts
+      uses: actions/download-artifact@v4
+      with:
+        path: ./artifacts
+  
+    - name: Compress individual directories (without parent directory)
+      run: |
+        cd ./artifacts
+        for dir in */; do
+          if [ -d "$dir" ]; then
+            dir_name=${dir%/}
+            echo "Creating zip for $dir_name"
+            (cd "$dir_name" && zip -r "../${dir_name}.zip" .)
+          fi
+        done
+  
+    - name: Get latest release information
+      id: get_latest_release
+      env:
+        GITHUB_TOKEN: ${{ secrets.SHADPS4_TOKEN_REPO }}
+      run: |
+        api_url="https://api.github.com/repos/${{ github.repository }}"
+        latest_release_info=$(curl -H "Authorization: token $GITHUB_TOKEN" "$api_url/releases/latest")
+        echo "last_release_tag=$(echo "$latest_release_info" | jq -r '.tag_name')" >> $GITHUB_ENV
+
+    - name: Create Pre-Release on GitHub
+      id: create_release
+      uses: ncipollo/release-action@v1
+      with:
+        token: ${{ secrets.SHADPS4_TOKEN_REPO }}
+        name: "Pre-release-shadPS4-${{ needs.get-info.outputs.date }}-${{ needs.get-info.outputs.shorthash }}"
+        tag: "Pre-release-shadPS4-${{ needs.get-info.outputs.date }}-${{ needs.get-info.outputs.shorthash }}"
+        draft: false
+        prerelease: true
+        body: "Full Changelog: [${{ env.last_release_tag }}...${{ needs.get-info.outputs.shorthash }}](https://github.com/shadps4-emu/shadPS4/compare/${{ env.last_release_tag }}...${{ needs.get-info.outputs.shorthash }})"
+        artifacts: ./artifacts/*.zip
+    
+    - name: Get current pre-release information
+      env:
+        GITHUB_TOKEN: ${{ secrets.SHADPS4_TOKEN_REPO }}
+      run: |
+        api_url="https://api.github.com/repos/${{ github.repository }}/releases"
+        
+        # Get all releases (sorted by date)
+        releases=$(curl -H "Authorization: token $GITHUB_TOKEN" "$api_url")
+        
+        # Capture the most recent pre-release (assuming the first one is the latest)
+        current_release=$(echo "$releases" | jq -c '.[] | select(.prerelease == true) | .published_at' | sort -r | head -n 1)
+        
+        # Remove extra quotes from captured date
+        current_release=$(echo $current_release | tr -d '"')
+                
+        # Export the current published_at to be available for the next step
+        echo "CURRENT_PUBLISHED_AT=$current_release" >> $GITHUB_ENV
+    
+    - name: Delete old pre-releases and tags
+      env:
+        GITHUB_TOKEN: ${{ secrets.SHADPS4_TOKEN_REPO }}
+      run: |
+        api_url="https://api.github.com/repos/${{ github.repository }}/releases"
+        
+        # Get current pre-releases
+        releases=$(curl -H "Authorization: token $GITHUB_TOKEN" "$api_url")
+                
+        # Remove extra quotes from captured date
+        CURRENT_PUBLISHED_AT=$(echo $CURRENT_PUBLISHED_AT | tr -d '"')
+        
+        # Convert CURRENT_PUBLISHED_AT para timestamp Unix
+        current_published_ts=$(date -d "$CURRENT_PUBLISHED_AT" +%s)
+        
+        # Identify pre-releases
+        echo "$releases" | jq -c '.[] | select(.prerelease == true)' | while read -r release; do
+          release_date=$(echo "$release" | jq -r '.published_at')
+          release_id=$(echo "$release" | jq -r '.id')
+          release_tag=$(echo "$release" | jq -r '.tag_name')
+          
+          # Remove extra quotes from captured date
+          release_date=$(echo $release_date | tr -d '"')
+          
+          # Convert release_date para timestamp Unix
+          release_date_ts=$(date -d "$release_date" +%s)
+                    
+          # Compare timestamps and delete old pre-releases
+          if [[ "$release_date_ts" -lt "$current_published_ts" ]]; then
+            echo "Deleting old pre-release: $release_id from $release_date with tag: $release_tag"
+            # Delete the pre-release
+            curl -X DELETE -H "Authorization: token $GITHUB_TOKEN" "$api_url/$release_id"
+            # Delete the tag
+            curl -X DELETE -H "Authorization: token $GITHUB_TOKEN" "https://api.github.com/repos/${{ github.repository }}/git/refs/tags/$release_tag"
+          else
+            echo "Skipping pre-release: $release_id (newer or same date)"
+          fi
+        done
--- a/.github/workflows/ci.yml
+++ b/.github/workflows/ci.yml
@ -1,17 +0,0 @@
-# SPDX-FileCopyrightText: 2021 yuzu Emulator Project
-# SPDX-License-Identifier: GPL-2.0-or-later
-
-name: Reuse
-
-on:
-  push:
-    branches: [ main ]
-    tags: [ "*" ]
-  pull_request:
-    branches: [ main ]
-jobs:
-  reuse:
-    runs-on: ubuntu-latest
-    steps:
-    - uses: actions/checkout@v4
-    - uses: fsfe/reuse-action@v4
--- a/.github/workflows/format.yml
+++ b/.github/workflows/format.yml
@ -1,28 +0,0 @@
-# SPDX-FileCopyrightText: 2024 shadPS4 Emulator Project
-# SPDX-License-Identifier: GPL-2.0-or-later
-
-name: Clang Format
-
-on:
-  push:
-    branches: [ "*" ]
-  pull_request:
-    branches: [ main ]
-
-jobs:
-  clang-format:
-    runs-on: ubuntu-latest
-    steps:
-      - uses: actions/checkout@v4
-        with:
-          fetch-depth: 0
-      - name: Install
-        run: |
-          wget -O - https://apt.llvm.org/llvm-snapshot.gpg.key | sudo apt-key add -
-          sudo add-apt-repository 'deb http://apt.llvm.org/jammy/ llvm-toolchain-jammy-17 main'
-          sudo apt update
-          sudo apt install clang-format-17
-      - name: Build
-        env:
-          COMMIT_RANGE: ${{ github.event.pull_request.base.sha }}..${{ github.event.pull_request.head.sha }}
-        run: ./.ci/clang-format.sh
--- a/.github/workflows/linux-qt.yml
+++ b/.github/workflows/linux-qt.yml
@ -1,66 +0,0 @@
-# SPDX-FileCopyrightText: 2024 shadPS4 Emulator Project
-# SPDX-License-Identifier: GPL-2.0-or-later
-
-name: Linux-Qt
-
-on:
-  push:
-    branches: [ "main" ]
-  pull_request:
-    branches: [ "main" ]
-
-env:
-  BUILD_TYPE: Release
-
-jobs:
-  build:
-    runs-on: ubuntu-24.04
-
-    steps:
-    - uses: actions/checkout@v4
-      with:
-        submodules: recursive
-
-    - name: Install misc packages
-      run: >
-       sudo apt-get update && sudo apt install libx11-dev libxext-dev libwayland-dev libfuse2 clang build-essential qt6-base-dev qt6-tools-dev
-
-    - name: Cache CMake dependency source code
-      uses: actions/cache@v4
-      env:
-          cache-name: ${{ runner.os }}-qt-cache-cmake-dependency-sources
-      with:
-          path: | 
-            ${{github.workspace}}/build
-          key: ${{ env.cache-name }}-${{ hashFiles('**/CMakeLists.txt', 'cmake/**') }}
-          restore-keys: |
-            ${{ env.cache-name }}-
-
-    - name: Cache CMake dependency build objects
-      uses: hendrikmuhs/ccache-action@v1.2.14
-      env:
-          cache-name: ${{ runner.os }}-qt-cache-cmake-dependency-builds
-      with:
-        append-timestamp: false
-        key: ${{ env.cache-name }}-${{ hashFiles('**/CMakeLists.txt', 'cmake/**') }}
-
-    - name: Configure CMake
-      run: cmake -B ${{github.workspace}}/build -DCMAKE_BUILD_TYPE=${{env.BUILD_TYPE}} -DCMAKE_C_COMPILER=clang -DCMAKE_CXX_COMPILER=clang++ -DENABLE_QT_GUI=ON -DCMAKE_C_COMPILER_LAUNCHER=ccache -DCMAKE_CXX_COMPILER_LAUNCHER=ccache
-
-    - name: Build
-      run: cmake --build ${{github.workspace}}/build --config ${{env.BUILD_TYPE}} --parallel
-
-    - name: Run AppImage packaging script
-      run:  ./.github/linux-appimage-qt.sh
-
-    - name: Get date and git hash
-      id: vars
-      run: |
-        echo "date=$(date +'%Y-%m-%d')" >> $GITHUB_OUTPUT
-        echo "shorthash=$(git rev-parse --short HEAD)" >> $GITHUB_OUTPUT
-
-    - name: Upload executable
-      uses: actions/upload-artifact@v4
-      with:
-        name: shadps4-linux-qt-${{ steps.vars.outputs.date }}-${{ steps.vars.outputs.shorthash }}
-        path: Shadps4-qt.AppImage
--- a/.github/workflows/linux.yml
+++ b/.github/workflows/linux.yml
@ -1,73 +0,0 @@
-# SPDX-FileCopyrightText: 2024 shadPS4 Emulator Project
-# SPDX-License-Identifier: GPL-2.0-or-later
-
-name: Linux
-
-on:
-  push:
-    branches: [ "main" ]
-  pull_request:
-    branches: [ "main" ]
-
-env:
-  BUILD_TYPE: Release
-
-jobs:
-  build:
-    runs-on: ubuntu-24.04
-
-    steps:
-    - uses: actions/checkout@v4
-      with:
-        submodules: recursive
-
-    - name: Install misc packages
-      run: >
-       sudo apt-get update && sudo apt install libx11-dev libxext-dev libwayland-dev libfuse2 clang build-essential
-
-    - name: Cache CMake dependency source code
-      uses: actions/cache@v4
-      env:
-          cache-name: ${{ runner.os }}-sdl-cache-cmake-dependency-sources
-      with:
-          path: | 
-            ${{github.workspace}}/build
-          key: ${{ env.cache-name }}-${{ hashFiles('**/CMakeLists.txt', 'cmake/**') }}
-          restore-keys: |
-            ${{ env.cache-name }}-
-
-    - name: Cache CMake dependency build objects
-      uses: hendrikmuhs/ccache-action@v1.2.14
-      env:
-          cache-name: ${{ runner.os }}-sdl-cache-cmake-dependency-builds
-      with:
-        append-timestamp: false
-        key: ${{ env.cache-name }}-${{ hashFiles('**/CMakeLists.txt', 'cmake/**') }}
-
-    - name: Configure CMake
-      run: cmake -B ${{github.workspace}}/build -DCMAKE_BUILD_TYPE=${{env.BUILD_TYPE}} -DCMAKE_C_COMPILER=clang -DCMAKE_CXX_COMPILER=clang++ -DCMAKE_C_COMPILER_LAUNCHER=ccache -DCMAKE_CXX_COMPILER_LAUNCHER=ccache
-
-    - name: Build
-      run: cmake --build ${{github.workspace}}/build --config ${{env.BUILD_TYPE}} --parallel
-
-    - name: Get date and git hash
-      id: vars
-      run: |
-        echo "date=$(date +'%Y-%m-%d')" >> $GITHUB_OUTPUT
-        echo "shorthash=$(git rev-parse --short HEAD)" >> $GITHUB_OUTPUT
-
-    - name: Upload executable
-      uses: actions/upload-artifact@v4
-      with:
-        name: shadps4-ubuntu64-${{ steps.vars.outputs.date }}-${{ steps.vars.outputs.shorthash }}
-        path: |
-          ${{github.workspace}}/build/shadps4
-
-    - name: Run AppImage packaging script
-      run:  ./.github/linux-appimage-sdl.sh
-
-    - name: Upload executable
-      uses: actions/upload-artifact@v4
-      with:
-        name: shadps4-sdl-appimage-${{ steps.vars.outputs.date }}-${{ steps.vars.outputs.shorthash }}
-        path: Shadps4-sdl.AppImage
--- a/.github/workflows/macos-qt.yml
+++ b/.github/workflows/macos-qt.yml
@ -1,88 +0,0 @@
-# SPDX-FileCopyrightText: 2024 shadPS4 Emulator Project
-# SPDX-License-Identifier: GPL-2.0-or-later
-
-name: macOS-Qt
-
-on:
-  push:
-    branches: [ "main" ]
-  pull_request:
-    branches: [ "main" ]
-
-env:
-  BUILD_TYPE: Release
-
-jobs:
-  build:
-    runs-on: macos-latest
-
-    steps:
-    - uses: actions/checkout@v4
-      with:
-        submodules: recursive
-
-    - name: Setup latest Xcode
-      uses: maxim-lobanov/setup-xcode@v1
-      with:
-        xcode-version: latest
-
-    - name: Install MoltenVK
-      run: |
-        arch -x86_64 /bin/bash -c "$(curl -fsSL https://raw.githubusercontent.com/Homebrew/install/HEAD/install.sh)"
-        arch -x86_64 /usr/local/bin/brew install molten-vk
-
-    - name: Setup Qt
-      uses: jurplel/install-qt-action@v4
-      with:
-        version: 6.7.2
-        host: mac
-        target: desktop
-        arch: clang_64
-        archives: qtbase qttools
-
-    - name: Cache CMake dependency source code
-      uses: actions/cache@v4
-      env:
-          cache-name: ${{ runner.os }}-qt-cache-cmake-dependency-sources
-      with:
-          path: | 
-            ${{github.workspace}}/build
-          key: ${{ env.cache-name }}-${{ hashFiles('**/CMakeLists.txt', 'cmake/**') }}
-          restore-keys: |
-            ${{ env.cache-name }}-
-
-    - name: Cache CMake dependency build objects
-      uses: hendrikmuhs/ccache-action@v1.2.14
-      env:
-          cache-name: ${{runner.os}}-qt-cache-cmake-dependency-builds
-      with:
-        append-timestamp: false
-        create-symlink: true
-        key: ${{env.cache-name}}-${{ hashFiles('**/CMakeLists.txt', 'cmake/**') }}
-        variant: sccache
-
-    - name: Configure CMake
-      run: cmake -B ${{github.workspace}}/build -DCMAKE_BUILD_TYPE=${{env.BUILD_TYPE}} -DCMAKE_OSX_ARCHITECTURES=x86_64 -DENABLE_QT_GUI=ON -DCMAKE_C_COMPILER_LAUNCHER=sccache -DCMAKE_CXX_COMPILER_LAUNCHER=sccache
-
-    - name: Build
-      run: cmake --build ${{github.workspace}}/build --config ${{env.BUILD_TYPE}} --parallel $(sysctl -n hw.ncpu)
-
-    - name: Package
-      run: |
-        mkdir upload
-        mv ${{github.workspace}}/build/shadps4.app upload
-        macdeployqt upload/shadps4.app
-        tar cf shadps4-macos-qt.tar.gz -C upload .
-
-    - name: Get date and git hash
-      id: vars
-      run: |
-        echo "date=$(date +'%Y-%m-%d')" >> $GITHUB_OUTPUT
-        echo "shorthash=$(git rev-parse --short HEAD)" >> $GITHUB_OUTPUT
-
-
-    - name: Upload executable
-      uses: actions/upload-artifact@v4
-      with:
-        name: shadps4-macos-qt-${{ steps.vars.outputs.date }}-${{ steps.vars.outputs.shorthash }}
-        path: shadps4-macos-qt.tar.gz
--- a/.github/workflows/macos.yml
+++ b/.github/workflows/macos.yml
@ -1,79 +0,0 @@
-# SPDX-FileCopyrightText: 2024 shadPS4 Emulator Project
-# SPDX-License-Identifier: GPL-2.0-or-later
-
-name: macOS
-
-on:
-  push:
-    branches: [ "main" ]
-  pull_request:
-    branches: [ "main" ]
-
-env:
-  BUILD_TYPE: Release
-
-jobs:
-  build:
-    runs-on: macos-latest
-
-    steps:
-    - uses: actions/checkout@v4
-      with:
-        submodules: recursive
-
-    - name: Setup latest Xcode
-      uses: maxim-lobanov/setup-xcode@v1
-      with:
-        xcode-version: latest
-
-    - name: Install MoltenVK
-      run: |
-        arch -x86_64 /bin/bash -c "$(curl -fsSL https://raw.githubusercontent.com/Homebrew/install/HEAD/install.sh)"
-        arch -x86_64 /usr/local/bin/brew install molten-vk
-
-    - name: Cache CMake dependency source code
-      uses: actions/cache@v4
-      env:
-          cache-name: ${{ runner.os }}-sdl-cache-cmake-dependency-sources
-      with:
-          path: | 
-            ${{github.workspace}}/build
-          key: ${{ env.cache-name }}-${{ hashFiles('**/CMakeLists.txt', 'cmake/**') }}
-          restore-keys: |
-            ${{ env.cache-name }}-
-
-    - name: Cache CMake dependency build objects
-      uses: hendrikmuhs/ccache-action@v1.2.14
-      env:
-          cache-name: ${{runner.os}}-sdl-cache-cmake-dependency-builds
-      with:
-        append-timestamp: false
-        create-symlink: true
-        key: ${{env.cache-name}}-${{ hashFiles('**/CMakeLists.txt', 'cmake/**') }}
-        variant: sccache
-
-    - name: Configure CMake
-      run: cmake -B ${{github.workspace}}/build -DCMAKE_BUILD_TYPE=${{env.BUILD_TYPE}} -DCMAKE_OSX_ARCHITECTURES=x86_64 -DCMAKE_C_COMPILER_LAUNCHER=sccache -DCMAKE_CXX_COMPILER_LAUNCHER=sccache
-
-    - name: Build
-      run: cmake --build ${{github.workspace}}/build --config ${{env.BUILD_TYPE}} --parallel $(sysctl -n hw.ncpu)
-
-    - name: Package
-      run: |
-        mkdir upload
-        mv ${{github.workspace}}/build/shadps4 upload
-        cp $(arch -x86_64 /usr/local/bin/brew --prefix)/opt/molten-vk/lib/libMoltenVK.dylib upload
-        install_name_tool -add_rpath "@loader_path" upload/shadps4
-        tar cf shadps4-macos-sdl.tar.gz -C upload .
-
-    - name: Get date and git hash
-      id: vars
-      run: |
-        echo "date=$(date +'%Y-%m-%d')" >> $GITHUB_OUTPUT
-        echo "shorthash=$(git rev-parse --short HEAD)" >> $GITHUB_OUTPUT
-
-    - name: Upload executable
-      uses: actions/upload-artifact@v4
-      with:
-        name: shadps4-macos-sdl-${{ steps.vars.outputs.date }}-${{ steps.vars.outputs.shorthash }}
-        path: shadps4-macos-sdl.tar.gz
--- a/.github/workflows/windows-qt.yml
+++ b/.github/workflows/windows-qt.yml
@ -1,67 +0,0 @@
-# SPDX-FileCopyrightText: 2024 shadPS4 Emulator Project
-# SPDX-License-Identifier: GPL-2.0-or-later
-
-name: Windows-Qt
-
-on:
-  push:
-    branches: [ "main" ]
-  pull_request:
-    branches: [ "main" ]
-
-env:
-  BUILD_TYPE: Release
-
-jobs:
-  build:
-    runs-on: windows-latest
-
-    steps:
-    - uses: actions/checkout@v4
-      with:
-          submodules: recursive
-
-    - name: Setup Qt
-      uses: jurplel/install-qt-action@v4
-      with:
-        version: 6.7.2
-        host: windows
-        target: desktop
-        arch: win64_msvc2019_64
-        archives: qtbase qttools
-
-    - name: Cache CMake dependency source code
-      uses: actions/cache@v4
-      env:
-          cache-name: ${{ runner.os }}-qt-cache-cmake-dependency-sources
-      with:
-          path: | 
-            ${{github.workspace}}/build
-          key: ${{ env.cache-name }}-${{ hashFiles('**/CMakeLists.txt', 'cmake/**') }}
-          restore-keys: |
-            ${{ env.cache-name }}-
-
-    - name: Configure CMake
-      run: cmake -B ${{github.workspace}}/build -DCMAKE_BUILD_TYPE=${{env.BUILD_TYPE}} -T ClangCL -DENABLE_QT_GUI=ON
-
-    - name: Build
-      run: cmake --build ${{github.workspace}}/build --config ${{env.BUILD_TYPE}} --parallel
-
-    - name: Deploy
-      run: |
-        mkdir upload
-        move build/Release/shadPS4.exe upload
-        windeployqt --dir upload upload/shadPS4.exe
-        
-    - name: Get date and git hash
-      id: vars
-      shell: pwsh
-      run: |
-        echo "date=$(Get-Date -Format 'yyyy-MM-dd')" >> $env:GITHUB_OUTPUT
-        echo "shorthash=$(git rev-parse --short HEAD)" >> $env:GITHUB_OUTPUT
-
-    - name: Upload executable
-      uses: actions/upload-artifact@v4
-      with:
-        name: shadps4-win64-qt-${{ steps.vars.outputs.date }}-${{ steps.vars.outputs.shorthash }}
-        path: upload
--- a/.github/workflows/windows.yml
+++ b/.github/workflows/windows.yml
@ -1,52 +0,0 @@
-# SPDX-FileCopyrightText: 2024 shadPS4 Emulator Project
-# SPDX-License-Identifier: GPL-2.0-or-later
-
-name: Windows
-
-on:
-  push:
-    branches: [ "main" ]
-  pull_request:
-    branches: [ "main" ]
-
-env:
-  BUILD_TYPE: Release
-
-jobs:
-  build:
-    runs-on: windows-latest
-    steps:
-    - uses: actions/checkout@v4
-      with:
-          submodules: recursive
-
-    - name: Cache CMake dependency source code
-      uses: actions/cache@v4
-      env:
-          cache-name: ${{ runner.os }}-sdl-cache-cmake-dependency-sources
-      with:
-          path: | 
-            ${{github.workspace}}/build
-          key: ${{ env.cache-name }}-${{ hashFiles('**/CMakeLists.txt', 'cmake/**') }}
-          restore-keys: |
-            ${{ env.cache-name }}-
-
-    - name: Configure CMake
-      run: cmake -B ${{github.workspace}}/build -DCMAKE_BUILD_TYPE=${{env.BUILD_TYPE}} -T ClangCL
-
-    - name: Build
-      run: cmake --build ${{github.workspace}}/build --config ${{env.BUILD_TYPE}} --parallel
-
-    - name: Get date and git hash
-      id: vars
-      shell: pwsh
-      run: |
-        echo "date=$(Get-Date -Format 'yyyy-MM-dd')" >> $env:GITHUB_OUTPUT
-        echo "shorthash=$(git rev-parse --short HEAD)" >> $env:GITHUB_OUTPUT
-
-    - name: Upload executable
-      uses: actions/upload-artifact@v4
-      with:
-        name: shadps4-win64-sdl-${{ steps.vars.outputs.date }}-${{ steps.vars.outputs.shorthash }}
-        path: |
-          ${{github.workspace}}/build/Release/shadPS4.exe
--- a/.gitignore
+++ b/.gitignore
@ -387,6 +387,8 @@ FodyWeavers.xsd
 !.vscode/launch.json
 !.vscode/extensions.json
 *.code-workspace
+/CMakeUserPresets.json
+/compile_commands.json

 # Local History for Visual Studio Code
 .history/
@ -409,6 +411,6 @@ FodyWeavers.xsd
 /out/*
 /third-party/out/*
 /src/common/scm_rev.cpp
-
+
 # for macOS
-**/.DS_Store
+**/.DS_Store
--- a/.gitmodules
+++ b/.gitmodules
@ -85,11 +85,16 @@
 [submodule "externals/half"]
 	path = externals/half
 	url = https://github.com/ROCm/half.git
+	shallow = true
 [submodule "externals/dear_imgui"]
 	path = externals/dear_imgui
 	url = https://github.com/shadps4-emu/ext-imgui.git
 	shallow = true
 	branch = docking
+[submodule "externals/pugixml"]
+	path = externals/pugixml
+	url = https://github.com/zeux/pugixml.git
+	shallow = true
 [submodule "externals/LibAtrac9"]
 	path = externals/LibAtrac9
-	url = https://github.com/Vita3K/LibAtrac9
+	url = https://github.com/Vita3K/LibAtrac9
--- a/.reuse/dep5
+++ b/.reuse/dep5
@ -1,60 +0,0 @@
-Format: https://www.debian.org/doc/packaging-manuals/copyright-format/1.0/
-Comment: It is best to use this file to record copyright information about
-         generated, binary and third party files
-
-Files: CMakeSettings.json
-       .github/shadps4.desktop
-       .github/shadps4.png
-       .gitmodules
-       documents/changelog.txt
-       documents/readme.txt
-       documents/Quickstart/1.png
-       documents/Quickstart/2.png
-       documents/Screenshots/Bloodborne.png
-       documents/Screenshots/Sonic Mania.png
-       documents/Screenshots/Undertale.png
-       documents/Screenshots/We are DOOMED.png
-       scripts/ps4_names.txt
-       src/images/about_icon.png
-       src/images/controller_icon.png
-       src/images/exit_icon.png
-       src/images/file_icon.png
-       src/images/flag_china.png
-       src/images/flag_eu.png
-       src/images/flag_jp.png
-       src/images/flag_unk.png
-       src/images/flag_us.png
-       src/images/flag_world.png
-       src/images/folder_icon.png
-       src/images/grid_icon.png
-       src/images/iconsize_icon.png
-       src/images/list_icon.png
-       src/images/list_mode_icon.png
-       src/images/pause_icon.png
-       src/images/play_icon.png
-       src/images/refresh_icon.png
-       src/images/settings_icon.png
-       src/images/stop_icon.png
-       src/images/shadPS4.icns
-       src/images/shadps4.ico
-       src/images/themes_icon.png
-       src/shadps4.qrc
-       src/shadps4.rc
-Copyright: shadPS4 Emulator Project
-License: GPL-2.0-or-later
-
-Files: externals/cmake-modules/*
-Copyright: 2009-2010 Iowa State University
-License: BSL-1.0
-
-Files: externals/renderdoc/*
-Copyright: 2019-2024 Baldur Karlsson
-License: MIT
-
-Files: externals/stb_image.h
-Copyright: 2017 Sean Barrett
-License: MIT
-
-Files: externals/tracy/*
-Copyright: 2017-2024 Bartosz Taudul <wolf@nereid.pl>
-License: BSD-3-Clause
--- a/CMakeLists.txt
+++ b/CMakeLists.txt
@ -8,7 +8,7 @@ set(CMAKE_CXX_STANDARD_REQUIRED True)

 if(APPLE)
    enable_language(OBJC)
-    set(CMAKE_OSX_DEPLOYMENT_TARGET 11)
+    set(CMAKE_OSX_DEPLOYMENT_TARGET 14)
 endif()

 if (NOT CMAKE_BUILD_TYPE)
@ -47,6 +47,11 @@ else()
    message(FATAL_ERROR "Unsupported CPU architecture: ${BASE_ARCHITECTURE}")
 endif()

+if (APPLE AND ARCHITECTURE STREQUAL "x86_64")
+    # Exclude ARM homebrew path to avoid conflicts when cross compiling.
+    list(APPEND CMAKE_IGNORE_PREFIX_PATH "/opt/homebrew")
+endif()
+
 # This function should be passed a list of all files in a target. It will automatically generate file groups
 # following the directory hierarchy, so that the layout of the files in IDEs matches the one in the filesystem.
 function(create_target_directory_groups target_name)
@ -90,6 +95,7 @@ include(GetGitRevisionDescription)
 get_git_head_revision(GIT_REF_SPEC GIT_REV)
 git_describe(GIT_DESC --always --long --dirty)
 git_branch_name(GIT_BRANCH)
+string(TIMESTAMP BUILD_DATE "%Y-%m-%d %H:%M:%S")

 configure_file("${CMAKE_CURRENT_SOURCE_DIR}/src/common/scm_rev.cpp.in" "${CMAKE_CURRENT_SOURCE_DIR}/src/common/scm_rev.cpp" @ONLY)

@ -108,6 +114,7 @@ find_package(xbyak 7.07 CONFIG)
 find_package(xxHash 0.8.2 MODULE)
 find_package(zlib-ng 2.1.7 MODULE)
 find_package(Zydis 5.0.0 CONFIG)
+find_package(pugixml 1.14 CONFIG)

 if (NOT CMAKE_CXX_COMPILER_ID STREQUAL "Clang" OR NOT MSVC)
    find_package(cryptopp 8.9.0 MODULE)
@ -137,7 +144,7 @@ add_subdirectory(externals)
 include_directories(src)

 if(ENABLE_QT_GUI)
-    find_package(Qt6 REQUIRED COMPONENTS Widgets Concurrent LinguistTools Network)
+    find_package(Qt6 REQUIRED COMPONENTS Widgets Concurrent LinguistTools Network Multimedia)
    qt_standard_project_setup()
    set(CMAKE_AUTORCC ON)
    set(CMAKE_AUTOMOC ON)
@ -215,6 +222,9 @@ set(NETWORK_LIBS src/core/libraries/network/http.cpp
                 src/core/libraries/network/net.cpp
                 src/core/libraries/network/netctl.cpp
                 src/core/libraries/network/netctl.h
+                 src/core/libraries/network/net_ctl_obj.cpp
+                 src/core/libraries/network/net_ctl_obj.h
+                 src/core/libraries/network/net_ctl_codes.h
                 src/core/libraries/network/net.h
                 src/core/libraries/network/ssl.cpp
                 src/core/libraries/network/ssl.h
@ -227,11 +237,18 @@ set(SYSTEM_LIBS src/core/libraries/system/commondialog.cpp
                src/core/libraries/system/msgdialog_ui.cpp
                src/core/libraries/system/posix.cpp
                src/core/libraries/system/posix.h
-                src/core/libraries/save_data/error_codes.h
+                src/core/libraries/save_data/save_backup.cpp
+                src/core/libraries/save_data/save_backup.h
+                src/core/libraries/save_data/save_instance.cpp
+                src/core/libraries/save_data/save_instance.h
+                src/core/libraries/save_data/save_memory.cpp
+                src/core/libraries/save_data/save_memory.h
                src/core/libraries/save_data/savedata.cpp
                src/core/libraries/save_data/savedata.h
-                src/core/libraries/system/savedatadialog.cpp
-                src/core/libraries/system/savedatadialog.h
+                src/core/libraries/save_data/dialog/savedatadialog.cpp
+                src/core/libraries/save_data/dialog/savedatadialog.h
+                src/core/libraries/save_data/dialog/savedatadialog_ui.cpp
+                src/core/libraries/save_data/dialog/savedatadialog_ui.h
                src/core/libraries/system/sysmodule.cpp
                src/core/libraries/system/sysmodule.h
                src/core/libraries/system/systemservice.cpp
@ -317,12 +334,27 @@ set(NP_LIBS src/core/libraries/np_manager/np_manager.cpp
            src/core/libraries/np_score/np_score.h
            src/core/libraries/np_trophy/np_trophy.cpp
            src/core/libraries/np_trophy/np_trophy.h
+            src/core/libraries/np_trophy/trophy_ui.cpp
+            src/core/libraries/np_trophy/trophy_ui.h
 )

 set(MISC_LIBS  src/core/libraries/screenshot/screenshot.cpp
               src/core/libraries/screenshot/screenshot.h
 )

+set(DEV_TOOLS src/core/devtools/layer.cpp
+              src/core/devtools/layer.h
+              src/core/devtools/gcn/gcn_context_regs.cpp
+              src/core/devtools/gcn/gcn_op_names.cpp
+              src/core/devtools/gcn/gcn_shader_regs.cpp
+              src/core/devtools/widget/cmd_list.cpp
+              src/core/devtools/widget/cmd_list.h
+              src/core/devtools/widget/frame_dump.cpp
+              src/core/devtools/widget/frame_dump.h
+              src/core/devtools/widget/frame_graph.cpp
+              src/core/devtools/widget/frame_graph.h
+)
+
 set(COMMON src/common/logging/backend.cpp
           src/common/logging/backend.h
           src/common/logging/filter.cpp
@ -342,9 +374,11 @@ set(COMMON src/common/logging/backend.cpp
           src/common/concepts.h
           src/common/config.cpp
           src/common/config.h
+           src/common/cstring.h
           src/common/debug.h
-           src/common/disassembler.cpp
-           src/common/disassembler.h
+           src/common/decoder.cpp
+           src/common/decoder.h
+           src/common/elf_info.h
           src/common/endian.h
           src/common/enum.h
           src/common/io_file.cpp
@ -362,6 +396,8 @@ set(COMMON src/common/logging/backend.cpp
           src/common/polyfill_thread.h
           src/common/rdtsc.cpp
           src/common/rdtsc.h
+           src/common/signal_context.h
+           src/common/signal_context.cpp
           src/common/singleton.h
           src/common/slot_vector.h
           src/common/string_util.cpp
@ -374,6 +410,8 @@ set(COMMON src/common/logging/backend.cpp
           src/common/version.h
           src/common/ntapi.h
           src/common/ntapi.cpp
+           src/common/memory_patcher.h
+           src/common/memory_patcher.cpp
           src/common/scm_rev.cpp
           src/common/scm_rev.h
 )
@ -428,6 +466,9 @@ set(CORE src/core/aerolib/stubs.cpp
         ${USBD_LIB}
         ${MISC_LIBS}
         ${DIALOGS_LIB}
+         ${DEV_TOOLS}
+         src/core/debug_state.cpp
+         src/core/debug_state.h
         src/core/linker.cpp
         src/core/linker.h
         src/core/memory.cpp
@ -435,6 +476,8 @@ set(CORE src/core/aerolib/stubs.cpp
         src/core/module.cpp
         src/core/module.h
         src/core/platform.h
+         src/core/signals.cpp
+         src/core/signals.h
         src/core/tls.cpp
         src/core/tls.h
         src/core/virtual_memory.cpp
@ -455,6 +498,7 @@ set(SHADER_RECOMPILER src/shader_recompiler/exception.h
                      src/shader_recompiler/params.h
                      src/shader_recompiler/runtime_info.h
                      src/shader_recompiler/specialization.h
+                      src/shader_recompiler/backend/bindings.h
                      src/shader_recompiler/backend/spirv/emit_spirv.cpp
                      src/shader_recompiler/backend/spirv/emit_spirv.h
                      src/shader_recompiler/backend/spirv/emit_spirv_atomic.cpp
@ -478,6 +522,7 @@ set(SHADER_RECOMPILER src/shader_recompiler/exception.h
                      src/shader_recompiler/frontend/translate/data_share.cpp
                      src/shader_recompiler/frontend/translate/export.cpp
                      src/shader_recompiler/frontend/translate/scalar_alu.cpp
+                      src/shader_recompiler/frontend/translate/scalar_flow.cpp
                      src/shader_recompiler/frontend/translate/scalar_memory.cpp
                      src/shader_recompiler/frontend/translate/translate.cpp
                      src/shader_recompiler/frontend/translate/translate.h
@ -486,6 +531,8 @@ set(SHADER_RECOMPILER src/shader_recompiler/exception.h
                      src/shader_recompiler/frontend/translate/vector_memory.cpp
                      src/shader_recompiler/frontend/control_flow_graph.cpp
                      src/shader_recompiler/frontend/control_flow_graph.h
+                      src/shader_recompiler/frontend/copy_shader.cpp
+                      src/shader_recompiler/frontend/copy_shader.h
                      src/shader_recompiler/frontend/decode.cpp
                      src/shader_recompiler/frontend/decode.h
                      src/shader_recompiler/frontend/fetch_shader.cpp
@ -502,6 +549,7 @@ set(SHADER_RECOMPILER src/shader_recompiler/exception.h
                      src/shader_recompiler/ir/passes/ir_passes.h
                      src/shader_recompiler/ir/passes/lower_shared_mem_to_registers.cpp
                      src/shader_recompiler/ir/passes/resource_tracking_pass.cpp
+                      src/shader_recompiler/ir/passes/ring_access_elimination.cpp
                      src/shader_recompiler/ir/passes/shader_info_collection_pass.cpp
                      src/shader_recompiler/ir/passes/ssa_rewrite_pass.cpp
                      src/shader_recompiler/ir/abstract_syntax_list.h
@ -534,6 +582,7 @@ set(VIDEO_CORE src/video_core/amdgpu/liverpool.cpp
               src/video_core/amdgpu/pm4_cmds.h
               src/video_core/amdgpu/pm4_opcodes.h
               src/video_core/amdgpu/resource.h
+               src/video_core/amdgpu/types.h
               src/video_core/amdgpu/default_context.cpp
               src/video_core/buffer_cache/buffer.cpp
               src/video_core/buffer_cache/buffer.h
@ -560,6 +609,8 @@ set(VIDEO_CORE src/video_core/amdgpu/liverpool.cpp
               src/video_core/renderer_vulkan/vk_master_semaphore.h
               src/video_core/renderer_vulkan/vk_pipeline_cache.cpp
               src/video_core/renderer_vulkan/vk_pipeline_cache.h
+               src/video_core/renderer_vulkan/vk_pipeline_common.cpp
+               src/video_core/renderer_vulkan/vk_pipeline_common.h
               src/video_core/renderer_vulkan/vk_platform.cpp
               src/video_core/renderer_vulkan/vk_platform.h
               src/video_core/renderer_vulkan/vk_rasterizer.cpp
@ -596,14 +647,15 @@ set(VIDEO_CORE src/video_core/amdgpu/liverpool.cpp
 set(IMGUI src/imgui/imgui_config.h
          src/imgui/imgui_layer.h
          src/imgui/imgui_std.h
-          src/imgui/layer/video_info.cpp
-          src/imgui/layer/video_info.h
+          src/imgui/imgui_texture.h
          src/imgui/renderer/imgui_core.cpp
          src/imgui/renderer/imgui_core.h
          src/imgui/renderer/imgui_impl_sdl3.cpp
          src/imgui/renderer/imgui_impl_sdl3.h
          src/imgui/renderer/imgui_impl_vulkan.cpp
          src/imgui/renderer/imgui_impl_vulkan.h
+          src/imgui/renderer/texture_manager.cpp
+          src/imgui/renderer/texture_manager.h
 )

 set(INPUT src/input/controller.cpp
@ -624,10 +676,12 @@ qt_add_resources(RESOURCE_FILES src/shadps4.qrc)
 set(QT_GUI src/qt_gui/about_dialog.cpp
           src/qt_gui/about_dialog.h
           src/qt_gui/about_dialog.ui
+           src/qt_gui/background_music_player.cpp
+           src/qt_gui/background_music_player.h
           src/qt_gui/cheats_patches.cpp
           src/qt_gui/cheats_patches.h
-           src/qt_gui/memory_patcher.cpp
-           src/qt_gui/memory_patcher.h
+           src/qt_gui/check_update.cpp
+           src/qt_gui/check_update.h
           src/qt_gui/main_window_ui.h
           src/qt_gui/main_window.cpp
           src/qt_gui/main_window.h
@ -692,8 +746,8 @@ endif()

 create_target_directory_groups(shadps4)

-target_link_libraries(shadps4 PRIVATE magic_enum::magic_enum fmt::fmt toml11::toml11 tsl::robin_map xbyak::xbyak Tracy::TracyClient RenderDoc::API FFmpeg::ffmpeg Dear_ImGui LibAtrac9)
-target_link_libraries(shadps4 PRIVATE Boost::headers GPUOpen::VulkanMemoryAllocator sirit Vulkan::Headers xxHash::xxhash Zydis::Zydis glslang::SPIRV glslang::glslang SDL3::SDL3)
+target_link_libraries(shadps4 PRIVATE magic_enum::magic_enum fmt::fmt toml11::toml11 tsl::robin_map xbyak::xbyak Tracy::TracyClient RenderDoc::API FFmpeg::ffmpeg Dear_ImGui LibAtrac9 gcn)
+target_link_libraries(shadps4 PRIVATE Boost::headers GPUOpen::VulkanMemoryAllocator sirit Vulkan::Headers xxHash::xxhash Zydis::Zydis glslang::SPIRV glslang::glslang SDL3::SDL3 pugixml::pugixml)

 target_compile_definitions(shadps4 PRIVATE IMGUI_USER_CONFIG="imgui/imgui_config.h")
 target_compile_definitions(Dear_ImGui PRIVATE IMGUI_USER_CONFIG="${PROJECT_SOURCE_DIR}/src/imgui/imgui_config.h")
@ -731,7 +785,7 @@ else()
 endif()

 if (ENABLE_QT_GUI)
-   target_link_libraries(shadps4 PRIVATE Qt6::Widgets Qt6::Concurrent Qt6::Network)
+   target_link_libraries(shadps4 PRIVATE Qt6::Widgets Qt6::Concurrent Qt6::Network Qt6::Multimedia)
   add_definitions(-DENABLE_QT_GUI)
 endif()

@ -787,6 +841,11 @@ add_subdirectory(${HOST_SHADERS_INCLUDE})
 add_dependencies(shadps4 host_shaders)
 target_include_directories(shadps4 PRIVATE ${HOST_SHADERS_INCLUDE})

+# ImGui resources
+add_subdirectory(${CMAKE_CURRENT_SOURCE_DIR}/src/imgui/renderer)
+add_dependencies(shadps4 ImGui_Resources)
+target_include_directories(shadps4 PRIVATE ${IMGUI_RESOURCES_INCLUDE})
+
 if (ENABLE_QT_GUI)
    set_target_properties(shadps4 PROPERTIES
 #       WIN32_EXECUTABLE ON
@ -802,4 +861,4 @@ if (UNIX AND NOT APPLE)
        find_package(OpenSSL REQUIRED)
        target_link_libraries(shadps4 PRIVATE ${OPENSSL_LIBRARIES})
    endif()
-endif()
+endif()
--- a/CMakeSettings.json
+++ b/CMakeSettings.json
@ -9,7 +9,8 @@
      "cmakeCommandArgs": "",
      "buildCommandArgs": "",
      "ctestCommandArgs": "",
-      "inheritEnvironments": [ "clang_cl_x64_x64" ]
+      "inheritEnvironments": [ "clang_cl_x64_x64" ],
+      "intelliSenseMode": "windows-clang-x64"
    },
    {
      "name": "x64-Clang-Debug",
@ -20,7 +21,8 @@
      "cmakeCommandArgs": "",
      "buildCommandArgs": "",
      "ctestCommandArgs": "",
-      "inheritEnvironments": [ "clang_cl_x64_x64" ]
+      "inheritEnvironments": [ "clang_cl_x64_x64" ],
+      "intelliSenseMode": "windows-clang-x64"
    },
    {
      "name": "x64-Clang-RelWithDebInfo",
@ -31,7 +33,8 @@
      "cmakeCommandArgs": "",
      "buildCommandArgs": "",
      "ctestCommandArgs": "",
-      "inheritEnvironments": [ "clang_cl_x64_x64" ]
+      "inheritEnvironments": [ "clang_cl_x64_x64" ],
+      "intelliSenseMode": "windows-clang-x64"
    }
  ]
 }
--- a/LICENSES/OFL-1.1.txt
+++ b/LICENSES/OFL-1.1.txt
@ -0,0 +1,43 @@
+SIL OPEN FONT LICENSE
+
+Version 1.1 - 26 February 2007
+
+PREAMBLE
+
+The goals of the Open Font License (OFL) are to stimulate worldwide development of collaborative font projects, to support the font creation efforts of academic and linguistic communities, and to provide a free and open framework in which fonts may be shared and improved in partnership with others.
+
+The OFL allows the licensed fonts to be used, studied, modified and redistributed freely as long as they are not sold by themselves. The fonts, including any derivative works, can be bundled, embedded, redistributed and/or sold with any software provided that any reserved names are not used by derivative works. The fonts and derivatives, however, cannot be released under any other type of license. The requirement for fonts to remain under this license does not apply to any document created using the fonts or their derivatives.
+
+DEFINITIONS
+
+"Font Software" refers to the set of files released by the Copyright Holder(s) under this license and clearly marked as such. This may include source files, build scripts and documentation.
+
+"Reserved Font Name" refers to any names specified as such after the copyright statement(s).
+
+"Original Version" refers to the collection of Font Software components as distributed by the Copyright Holder(s).
+
+"Modified Version" refers to any derivative made by adding to, deleting, or substituting — in part or in whole — any of the components of the Original Version, by changing formats or by porting the Font Software to a new environment.
+
+"Author" refers to any designer, engineer, programmer, technical writer or other person who contributed to the Font Software.
+
+PERMISSION & CONDITIONS
+
+Permission is hereby granted, free of charge, to any person obtaining a copy of the Font Software, to use, study, copy, merge, embed, modify, redistribute, and sell modified and unmodified copies of the Font Software, subject to the following conditions:
+
+1) Neither the Font Software nor any of its individual components, in Original or Modified Versions, may be sold by itself.
+
+2) Original or Modified Versions of the Font Software may be bundled, redistributed and/or sold with any software, provided that each copy contains the above copyright notice and this license. These can be included either as stand-alone text files, human-readable headers or in the appropriate machine-readable metadata fields within text or binary files as long as those fields can be easily viewed by the user.
+
+3) No Modified Version of the Font Software may use the Reserved Font Name(s) unless explicit written permission is granted by the corresponding Copyright Holder. This restriction only applies to the primary font name as presented to the users.
+
+4) The name(s) of the Copyright Holder(s) or the Author(s) of the Font Software shall not be used to promote, endorse or advertise any Modified Version, except to acknowledge the contribution(s) of the Copyright Holder(s) and the Author(s) or with their explicit written permission.
+
+5) The Font Software, modified or unmodified, in part or in whole, must be distributed entirely under this license, and must not be distributed under any other license. The requirement for fonts to remain under this license does not apply to any document created using the Font Software.
+
+TERMINATION
+
+This license becomes null and void if any of the above conditions are not met.
+
+DISCLAIMER
+
+THE FONT SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO ANY WARRANTIES OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT OF COPYRIGHT, PATENT, TRADEMARK, OR OTHER RIGHT. IN NO EVENT SHALL THE COPYRIGHT HOLDER BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, INCLUDING ANY GENERAL, SPECIAL, INDIRECT, INCIDENTAL, OR CONSEQUENTIAL DAMAGES, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF THE USE OR INABILITY TO USE THE FONT SOFTWARE OR FROM OTHER DEALINGS IN THE FONT SOFTWARE.
--- a/README.md
+++ b/README.md
@ -12,7 +12,7 @@ SPDX-License-Identifier: GPL-2.0-or-later
 </h1>

 <h1 align="center">
- <a href="https://discord.gg/MyZRaBngxA">
+ <a href="https://discord.gg/bFJxfftGW6">
        <img src="https://img.shields.io/discord/1080089157554155590?color=5865F2&label=shadPS4 Discord&logo=Discord&logoColor=white" width="240">
 <a href="https://github.com/shadps4-emu/shadPS4/releases/latest">
        <img src="https://img.shields.io/github/downloads/shadps4-emu/shadPS4/total.svg" width="140">
@ -26,30 +26,32 @@ SPDX-License-Identifier: GPL-2.0-or-later

 <p align="center">
  <a href="https://shadps4.net/">
-  <img src="https://github.com/shadps4-emu/shadPS4/blob/main/documents/Screenshots/Sonic Mania.png" width="400">
-  <img src="https://github.com/shadps4-emu/shadPS4/blob/main/documents/Screenshots/Bloodborne.png" width="400">
-  <img src="https://github.com/shadps4-emu/shadPS4/blob/main/documents/Screenshots/Undertale.png" width="400">
-  <img src="https://github.com/shadps4-emu/shadPS4/blob/main/documents/Screenshots/We are DOOMED.png" width="400">
+  <img src="https://github.com/shadps4-emu/shadPS4/blob/main/documents/Screenshots/1.png" width="400">
+  <img src="https://github.com/shadps4-emu/shadPS4/blob/main/documents/Screenshots/2.png" width="400">
+  <img src="https://github.com/shadps4-emu/shadPS4/blob/main/documents/Screenshots/3.png" width="400">
+  <img src="https://github.com/shadps4-emu/shadPS4/blob/main/documents/Screenshots/4.png" width="400">
 </p>

 # General information

-shadPS4 is an early **PlayStation 4** emulator for **Windows**, **Linux** and **macOS** written in C++.
+**shadPS4** is an early **PlayStation 4** emulator for **Windows**, **Linux** and **macOS** written in C++.

 If you encounter problems or have doubts, do not hesitate to look at the [**Quickstart**](https://github.com/shadps4-emu/shadPS4/blob/main/documents/Quickstart/Quickstart.md).

 To verify that a game works, you can look at [**shadPS4 Game Compatibility**](https://github.com/shadps4-emu/shadps4-game-compatibility).

-To discuss shadPS4 development, suggest ideas or to ask for help, join our [**Discord server**](https://discord.gg/MyZRaBngxA).
+To discuss shadPS4 development, suggest ideas or to ask for help, join our [**Discord server**](https://discord.gg/bFJxfftGW6).

 To get the latest news, go to our [**X (Twitter)**](https://x.com/shadps4) or our [**website**](https://shadps4.net/).

+For those who'd like to donate to the project, we now have a [**Kofi page**](https://ko-fi.com/shadps4)!
+
 # Status

 > [!IMPORTANT]
 > shadPS4 is early in development, don't expect a flawless experience.

-Currently, the emulator successfully runs small games like [**Sonic Mania**](https://www.youtube.com/watch?v=AAHoNzhHyCU), [**Undertale**](https://youtu.be/5zIvdy65Ro4) and it can even *somewhat* run [**Bloodborne**](https://www.youtube.com/watch?v=wC6s0avpQRE).
+Currently, the emulator successfully runs small games like [**Sonic Mania**](https://www.youtube.com/watch?v=AAHoNzhHyCU), [**Undertale**](https://youtu.be/5zIvdy65Ro4) and it can even run [**Bloodborne**](https://www.youtube.com/watch?v=wC6s0avpQRE).

 # Why

@ -69,40 +71,12 @@ Check the build instructions for [**Linux**](https://github.com/shadps4-emu/shad

 Check the build instructions for [**macOS**](https://github.com/shadps4-emu/shadPS4/blob/main/documents/building-macos.md).

-Note that macOS users need at least macOS 15 on an Apple Silicon Mac, or at least macOS 11 on an Intel Mac.
-
-## Building status
-
-<details>
-<summary><b>Windows</b></summary>
-
-| Windows | Build status |
-|--------|--------|
-|Windows SDL Build|[![Windows-sdl](https://github.com/shadps4-emu/shadPS4/actions/workflows/windows.yml/badge.svg)](https://github.com/shadps4-emu/shadPS4/actions/workflows/windows.yml)
-|Windows Qt Build|[![Windows-qt](https://github.com/shadps4-emu/shadPS4/actions/workflows/windows-qt.yml/badge.svg)](https://github.com/shadps4-emu/shadPS4/actions/workflows/windows-qt.yml)
-</details>
-
-<details>
-<summary><b>Linux</b></summary>
-
-| Linux | Build status |
-|--------|--------|
-|Linux SDL Build|[![Linux-sdl](https://github.com/shadps4-emu/shadPS4/actions/workflows/linux.yml/badge.svg)](https://github.com/shadps4-emu/shadPS4/actions/workflows/linux.yml)
-|Linux Qt Build|[![Linux-qt](https://github.com/shadps4-emu/shadPS4/actions/workflows/linux-qt.yml/badge.svg)](https://github.com/shadps4-emu/shadPS4/actions/workflows/linux-qt.yml)
-</details>
-
-<details>
-<summary><b>macOS</b></summary>
-
-| macOS | Build status |
-|--------|--------|
-|macOS SDL Build|[![macOS-sdl](https://github.com/shadps4-emu/shadPS4/actions/workflows/macos.yml/badge.svg)](https://github.com/shadps4-emu/shadPS4/actions/workflows/macos.yml)
-|macOS Qt Build|[![macOS-qt](https://github.com/shadps4-emu/shadPS4/actions/workflows/macos-qt.yml/badge.svg)](https://github.com/shadps4-emu/shadPS4/actions/workflows/macos-qt.yml)
-</details>
+> [!IMPORTANT]
+> macOS users need at least macOS 15 on Apple Silicon-based Mac devices and at least macOS 14 on Intel-based Mac devices.

 # Debugging and reporting issues

-For more information on how to test, debug and report issues with the emulator or games, read the [Debugging documentation](https://github.com/shadps4-emu/shadPS4/blob/main/documents/Debugging/Debugging.md).
+For more information on how to test, debug and report issues with the emulator or games, read the [**Debugging documentation**](https://github.com/shadps4-emu/shadPS4/blob/main/documents/Debugging/Debugging.md).

 # Keyboard mapping

@ -172,12 +146,6 @@ A few noteworthy teams/projects who've helped us along the way are:

 - [**hydra**](https://github.com/hydra-emu/hydra): A multisystem, multiplatform emulator (chip-8, GB, NES, N64) from Paris.

-
-# Sister Projects
-
- [**Panda3DS**](https://github.com/wheremyfoodat/Panda3DS): A multiplatform 3DS emulator from our co-author wheremyfoodat.
- [**hydra**](https://github.com/hydra-emu/hydra): A multisystem, multiplatform emulator (chip-8, GB, NES, N64) from Paris.
-
 # License

 - [**GPL-2.0 license**](https://github.com/shadps4-emu/shadPS4/blob/main/LICENSE)
--- a/REUSE.toml
+++ b/REUSE.toml
@ -0,0 +1,87 @@
+version = 1
+
+[[annotations]]
+path = [
+    "REUSE.toml",
+    "CMakeSettings.json",
+    ".github/FUNDING.yml",
+    ".github/shadps4.desktop",
+    ".github/shadps4.png",
+    ".gitmodules",
+    "documents/changelog.txt",
+    "documents/Quickstart/2.png",
+    "documents/Screenshots/*",
+    "scripts/ps4_names.txt",
+    "src/images/about_icon.png",
+    "src/images/controller_icon.png",
+    "src/images/dump_icon.png",
+    "src/images/exit_icon.png",
+    "src/images/file_icon.png",
+    "src/images/flag_china.png",
+    "src/images/flag_eu.png",
+    "src/images/flag_jp.png",
+    "src/images/flag_unk.png",
+    "src/images/flag_us.png",
+    "src/images/flag_world.png",
+    "src/images/folder_icon.png",
+    "src/images/grid_icon.png",
+    "src/images/iconsize_icon.png",
+    "src/images/list_icon.png",
+    "src/images/list_mode_icon.png",
+    "src/images/pause_icon.png",
+    "src/images/play_icon.png",
+    "src/images/refresh_icon.png",
+    "src/images/settings_icon.png",
+    "src/images/stop_icon.png",
+    "src/images/shadPS4.icns",
+    "src/images/shadps4.ico",
+    "src/images/themes_icon.png",
+    "src/images/update_icon.png",
+    "src/shadps4.qrc",
+    "src/shadps4.rc",
+]
+precedence = "aggregate"
+SPDX-FileCopyrightText = "shadPS4 Emulator Project"
+SPDX-License-Identifier = "GPL-2.0-or-later"
+
+[[annotations]]
+path = "externals/cmake-modules/**"
+precedence = "aggregate"
+SPDX-FileCopyrightText = "2009-2010 Iowa State University"
+SPDX-License-Identifier = "BSL-1.0"
+
+[[annotations]]
+path = "externals/renderdoc/**"
+precedence = "aggregate"
+SPDX-FileCopyrightText = "2019-2024 Baldur Karlsson"
+SPDX-License-Identifier = "MIT"
+
+[[annotations]]
+path = "externals/stb_image.h"
+precedence = "aggregate"
+SPDX-FileCopyrightText = "2017 Sean Barrett"
+SPDX-License-Identifier = "MIT"
+
+[[annotations]]
+path = "externals/tracy/**"
+precedence = "aggregate"
+SPDX-FileCopyrightText = "2017-2024 Bartosz Taudul <wolf@nereid.pl>"
+SPDX-License-Identifier = "BSD-3-Clause"
+
+[[annotations]]
+path = "src/imgui/renderer/fonts/NotoSansJP-Regular.ttf"
+precedence = "aggregate"
+SPDX-FileCopyrightText = "2012 Google Inc. All Rights Reserved."
+SPDX-License-Identifier = "OFL-1.1"
+
+[[annotations]]
+path = "src/imgui/renderer/fonts/ProggyVector-Regular.ttf"
+precedence = "aggregate"
+SPDX-FileCopyrightText = "Copyright (c) 2004, 2005 Tristan Grimmer"
+SPDX-License-Identifier = "MIT"
+
+[[annotations]]
+path = "externals/gcn/include/**"
+SPDX-FileCopyrightText = "NONE"
+SPDX-License-Identifier = "CC0-1.0"
+
--- a/documents/Quickstart/Quickstart.md
+++ b/documents/Quickstart/Quickstart.md
@ -39,16 +39,12 @@ SPDX-License-Identifier: GPL-2.0-or-later

 ## How to run the latest Work-in-Progress builds of ShadPS4

-1. Go to <https://github.com/shadps4-emu/shadPS4/actions> and make sure you are logged into your GitHub account (important!)
-2. On the left side of the page, select your operating system of choice (the "**qt**" versions have a user interface, which is probably the one you want. The others are SDL versions, which can only be run via command line). ![image](https://github.com/user-attachments/assets/43f01bbf-236c-4d6d-98ac-f5a5badd4ce8)
+1. Go to <https://github.com/shadps4-emu/shadPS4/releases> In the release identified as 'pre-release' click on the down arrow(Assets), select your operating system of choice (the "**qt**" versions have a user interface, which is probably the one you want. The others are SDL versions, which can only be run via command line).
+![image](https://github.com/user-attachments/assets/af520c77-797c-41a0-8f67-d87f5de3e3df)

-3. In the workflow list, select the latest entry with a green :white_check_mark: icon in front of it. (or the latest entry for whatever pull request you wish to test). ![image](https://github.com/user-attachments/assets/6365f407-867c-44ae-bf00-944f8d84a349)
+2. Once downloaded, extract to its own folder, and run ShadPS4's executable from the extracted folder.

-4. On the bottom of this page, select the name of the file, and it should start downloading. (If there is no file here, double check that you are indeed logged into a GitHub account, and that there is a green :white_check_mark: icon. ![image](https://github.com/user-attachments/assets/97924500-3911-4f90-ab63-ffae7e52700b)
-
-5. Once downloaded, extract to its own folder, and run ShadPS4's executable from the extracted folder.
-
-6. Upon first launch, ShadPS4 will prompt you to select a folder to store your installed games in. Select "Browse" and then select a folder that ShadPS4 can use to install your PKG files to.
+3. Upon first launch, ShadPS4 will prompt you to select a folder to store your installed games in. Select "Browse" and then select a folder that ShadPS4 can use to install your PKG files to.

 ## Install PKG files

@ -78,4 +74,4 @@ Here's a list of configuration entries that are worth changing:
      - If you'd like to mute everything, but still want to receive messages from Vulkan rendering: `*:Error Render.Vulkan:Info`
    
 - `[GPU]`
-  - `screenWidth` and `screenHeight`: Configures the game window width and height.
+  - `screenWidth` and `screenHeight`: Configures the game window width and height.
--- a/documents/Screenshots/1.png
+++ b/documents/Screenshots/1.png
--- a/documents/Screenshots/2.png
+++ b/documents/Screenshots/2.png
--- a/documents/Screenshots/3.png
+++ b/documents/Screenshots/3.png
--- a/documents/Screenshots/4.png
+++ b/documents/Screenshots/4.png
--- a/documents/Screenshots/Bloodborne.png
+++ b/documents/Screenshots/Bloodborne.png
--- a/documents/Screenshots/Sonic
+++ b/documents/Screenshots/Sonic
--- a/documents/Screenshots/Undertale.png
+++ b/documents/Screenshots/Undertale.png
--- a/documents/Screenshots/We
+++ b/documents/Screenshots/We
--- a/documents/building-linux.md
+++ b/documents/building-linux.md
@ -3,28 +3,28 @@ SPDX-FileCopyrightText: 2024 shadPS4 Emulator Project
 SPDX-License-Identifier: GPL-2.0-or-later
 -->

-## Build shadPS4 for Linux
+## Build shadPS4 for Linux                                      

 ### Install the necessary tools to build shadPS4:

 #### Debian & Ubuntu
 ```
-sudo apt-get install build-essential libasound2-dev libpulse-dev libopenal-dev zlib1g-dev libedit-dev libvulkan-dev libudev-dev git libevdev-dev libsdl2-2.0 libsdl2-dev libjack-dev libsndio-dev qt6-base-dev qt6-tools-dev
+sudo apt install build-essential clang git cmake libasound2-dev libpulse-dev libopenal-dev libssl-dev zlib1g-dev libedit-dev libudev-dev libevdev-dev libsdl2-dev libjack-dev libsndio-dev qt6-base-dev qt6-tools-dev qt6-multimedia-dev libvulkan-dev vulkan-validationlayers
 ```

 #### Fedora
 ```
-sudo dnf install alsa-lib-devel cmake libatomic libevdev-devel libudev-devel openal-devel qt6-qtbase-devel qt6-qtbase-private-devel vulkan-devel pipewire-jack-audio-connection-kit-devel qt6-qtmultimedia-devel qt6-qtsvg-devel
+sudo dnf install clang git cmake libatomic alsa-lib-devel pipewire-jack-audio-connection-kit-devel openal-devel openssl-devel libevdev-devel libudev-devel libXext-devel qt6-qtbase-devel qt6-qtbase-private-devel qt6-qtmultimedia-devel qt6-qtsvg-devel qt6-qttools-devel vulkan-devel vulkan-validation-layers
 ```

 #### Arch Linux
 ```
-sudo pacman -S openal cmake vulkan-validation-layers qt6-base qt6-declarative qt6-multimedia sdl2 sndio jack2 base-devel
+sudo pacman -S base-devel clang git cmake sndio jack2 openal qt6-base qt6-declarative qt6-multimedia sdl2 vulkan-validation-layers
 ```

 #### OpenSUSE
 ```
-sudo zypper install git cmake libasound2 libpulse-devel openal-soft-devel zlib-devel libedit-devel vulkan-devel libudev-devel libqt6-qtbase-devel libqt6-qtmultimedia-devel libqt6-qtsvg-devel libQt6Gui-private-headers-devel libevdev-devel libsndio7_1 libjack-devel
+sudo zypper install clang git cmake libasound2 libpulse-devel libsndio7 libjack-devel openal-soft-devel libopenssl-devel zlib-devel libedit-devel systemd-devel libevdev-devel qt6-base-devel qt6-multimedia-devel qt6-svg-devel qt6-linguist-devel qt6-gui-private-devel vulkan-devel vulkan-validationlayers
 ```
 ### Cloning and compiling:

@ -34,9 +34,11 @@ git clone --recursive https://github.com/shadps4-emu/shadPS4.git
 cd shadPS4
 ```

-Generate the build directory in the shadPS4 directory. To enable the QT GUI, pass the ```-DENABLE_QT_GUI=ON``` flag:
+Generate the build directory in the shadPS4 directory. To disable the QT GUI, remove the ```-DENABLE_QT_GUI=ON``` flag:
+
+**Note**: Clang is the compiler used for official builds and CI. If you build with GCC, you might encounter issues—please report any you find. If you choose to use GCC, we recommend building with Clang at least once before submitting a pull request.
 ```
-cmake -S . -B build/ -DENABLE_QT_GUI=ON
+cmake -S . -B build/ -DENABLE_QT_GUI=ON -DCMAKE_C_COMPILER=clang -DCMAKE_CXX_COMPILER=clang++
 ```

 Enter the directory:
--- a/documents/building-windows.md
+++ b/documents/building-windows.md
@ -80,7 +80,7 @@ Normal x86-based computers, follow:
 1. Open "MSYS2 MINGW64" from your new applications
 2. Run `pacman -Syu`, let it complete;
 3. Run `pacman -S --needed git mingw-w64-x86_64-binutils mingw-w64-x86_64-clang mingw-w64-x86_64-cmake mingw-w64-x86_64-ninja mingw-w64-x86_64-ffmpeg`
-   1. Optional (Qt only): run `pacman -S --needed mingw-w64-x86_64-qt6-base mingw-w64-x86_64-qt6-tools`
+   1. Optional (Qt only): run `pacman -S --needed mingw-w64-x86_64-qt6-base mingw-w64-x86_64-qt6-tools mingw-w64-x86_64-qt6-multimedia`
 4. Run `git clone --depth 1 --recursive https://github.com/shadps4-emu/shadPS4`
 5. Run `cd shadPS4`
 6. Run `cmake -S . -B build -DCMAKE_C_COMPILER="clang.exe" -DCMAKE_CXX_COMPILER="clang++.exe" -DCMAKE_CXX_FLAGS="-O2 -march=native"`
@ -94,7 +94,7 @@ ARM64-based computers, follow:
 1. Open "MSYS2 CLANGARM64" from your new applications
 2. Run `pacman -Syu`, let it complete;
 3. Run `pacman -S --needed git mingw-w64-clang-aarch64-binutils mingw-w64-clang-aarch64-clang mingw-w64-clang-aarch64-cmake mingw-w64-clang-aarch64-ninja mingw-w64-clang-aarch64-ffmpeg`
-   1. Optional (Qt only): run `pacman -S --needed mingw-w64-clang-aarch64-qt6-base mingw-w64-clang-aarch64-qt6-tools`
+   1. Optional (Qt only): run `pacman -S --needed mingw-w64-clang-aarch64-qt6-base mingw-w64-clang-aarch64-qt6-tools mingw-w64-clang-aarch64-qt6-multimedia`
 4. Run `git clone --depth 1 --recursive https://github.com/shadps4-emu/shadPS4`
 5. Run `cd shadPS4`
 6. Run `cmake -S . -B build -DCMAKE_C_COMPILER="clang.exe" -DCMAKE_CXX_COMPILER="clang++.exe" -DCMAKE_CXX_FLAGS="-O2 -march=native"`
--- a/documents/changelog.txt
+++ b/documents/changelog.txt
@ -1,3 +1,14 @@
+v0.3.0 23/09/2024 - codename broamic
+=================
+
+- Cheat/Patching support
+- DLC support
+- New translations support (26 languages)
+- Support for unlocking trophies
+- Support for more controllers (Dualshock and Xbox)
+- Many GUI imporovements
+- AVplayer
+
 v0.2.0 15/08/2024 - codename validptr
 =================
 - Adding macOS support
--- a/externals/CMakeLists.txt
+++ b/externals/CMakeLists.txt
@ -187,3 +187,11 @@ option(TRACY_NO_SAMPLING "" ON)
 option(TRACY_ONLY_LOCALHOST "" ON)
 option(TRACY_NO_CONTEXT_SWITCH "" ON)
 add_subdirectory(tracy)
+
+# pugixml
+if (NOT TARGET pugixml::pugixml)
+    add_subdirectory(pugixml)
+endif()
+
+# GCN Headers
+add_subdirectory(gcn)
--- a/externals/date
+++ b/externals/date
@ -1 +1 @@
-Subproject commit 1ead6715dec030d340a316c927c877a3c4e5a00c
+Subproject commit 51ce7e131079c061533d741be5fe7cca57f2faac
--- a/externals/fmt
+++ b/externals/fmt
@ -1 +1 @@
-Subproject commit c98518351efd5a46f5d448e947e0b7242d197d07
+Subproject commit 8ee89546ffcf046309d1f0d38c0393f02fde56c8
--- a/externals/gcn/CMakeLists.txt
+++ b/externals/gcn/CMakeLists.txt
@ -0,0 +1,8 @@
+# SPDX-FileCopyrightText: Copyright 2024 shadPS4 Emulator Project
+# SPDX-License-Identifier: GPL-2.0-or-later
+
+project(gcn LANGUAGES CXX)
+
+add_library(gcn dummy.cpp)
+
+target_include_directories(gcn INTERFACE include)
--- a/externals/gcn/dummy.cpp
+++ b/externals/gcn/dummy.cpp
@ -0,0 +1,2 @@
+//  SPDX-FileCopyrightText: Copyright 2024 shadPS4 Emulator Project
+//  SPDX-License-Identifier: GPL-2.0-or-later
--- a/externals/gcn/include/gcn/si_ci_vi_merged_offset.h
+++ b/externals/gcn/include/gcn/si_ci_vi_merged_offset.h
--- a/externals/gcn/include/gcn/si_ci_vi_merged_pm4_it_opcodes.h
+++ b/externals/gcn/include/gcn/si_ci_vi_merged_pm4_it_opcodes.h
@ -0,0 +1,117 @@
+/*
+ ***********************************************************************************************************************
+ *
+ *  Copyright (c) 2015-2021 Advanced Micro Devices, Inc. All Rights Reserved.
+ *
+ *  Permission is hereby granted, free of charge, to any person obtaining a copy
+ *  of this software and associated documentation files (the "Software"), to deal
+ *  in the Software without restriction, including without limitation the rights
+ *  to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+ *  copies of the Software, and to permit persons to whom the Software is
+ *  furnished to do so, subject to the following conditions:
+ *
+ *  The above copyright notice and this permission notice shall be included in all
+ *  copies or substantial portions of the Software.
+ *
+ *  THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+ *  IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+ *  FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+ *  AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+ *  LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+ *  OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+ *  SOFTWARE.
+ *
+ **********************************************************************************************************************/
+
+#ifndef PM4_IT_OPCODES_H
+#define PM4_IT_OPCODES_H
+
+enum IT_OpCodeType {
+    IT_NOP                               = 0x10,
+    IT_SET_BASE                          = 0x11,
+    IT_CLEAR_STATE                       = 0x12,
+    IT_INDEX_BUFFER_SIZE                 = 0x13,
+    IT_DISPATCH_DIRECT                   = 0x15,
+    IT_DISPATCH_INDIRECT                 = 0x16,
+    IT_ATOMIC_GDS                        = 0x1D,
+    IT_ATOMIC                            = 0x1E,
+    IT_OCCLUSION_QUERY                   = 0x1F,
+    IT_SET_PREDICATION                   = 0x20,
+    IT_REG_RMW                           = 0x21,
+    IT_COND_EXEC                         = 0x22,
+    IT_PRED_EXEC                         = 0x23,
+    IT_DRAW_INDIRECT                     = 0x24,
+    IT_DRAW_INDEX_INDIRECT               = 0x25,
+    IT_INDEX_BASE                        = 0x26,
+    IT_DRAW_INDEX_2                      = 0x27,
+    IT_CONTEXT_CONTROL                   = 0x28,
+    IT_INDEX_TYPE                        = 0x2A,
+    IT_DRAW_INDIRECT_MULTI               = 0x2C,
+    IT_DRAW_INDEX_AUTO                   = 0x2D,
+    IT_NUM_INSTANCES                     = 0x2F,
+    IT_DRAW_INDEX_MULTI_AUTO             = 0x30,
+    IT_INDIRECT_BUFFER_CNST              = 0x33,
+    IT_STRMOUT_BUFFER_UPDATE             = 0x34,
+    IT_DRAW_INDEX_OFFSET_2               = 0x35,
+    IT_WRITE_DATA                        = 0x37,
+    IT_DRAW_INDEX_INDIRECT_MULTI         = 0x38,
+    IT_MEM_SEMAPHORE                     = 0x39,
+    IT_COPY_DW__SI__CI                   = 0x3B,
+    IT_WAIT_REG_MEM                      = 0x3C,
+    IT_INDIRECT_BUFFER                   = 0x3F,
+    IT_COND_INDIRECT_BUFFER              = 0x3F,
+    IT_COPY_DATA                         = 0x40,
+    IT_CP_DMA                            = 0x41,
+    IT_PFP_SYNC_ME                       = 0x42,
+    IT_SURFACE_SYNC                      = 0x43,
+    IT_COND_WRITE                        = 0x45,
+    IT_EVENT_WRITE                       = 0x46,
+    IT_EVENT_WRITE_EOP                   = 0x47,
+    IT_EVENT_WRITE_EOS                   = 0x48,
+    IT_PREAMBLE_CNTL                     = 0x4A,
+    IT_CONTEXT_REG_RMW                   = 0x51,
+    IT_LOAD_SH_REG                       = 0x5F,
+    IT_LOAD_CONFIG_REG                   = 0x60,
+    IT_LOAD_CONTEXT_REG                  = 0x61,
+    IT_SET_CONFIG_REG                    = 0x68,
+    IT_SET_CONTEXT_REG                   = 0x69,
+    IT_SET_CONTEXT_REG_INDIRECT          = 0x73,
+    IT_SET_SH_REG                        = 0x76,
+    IT_SET_SH_REG_OFFSET                 = 0x77,
+    IT_SCRATCH_RAM_WRITE                 = 0x7D,
+    IT_SCRATCH_RAM_READ                  = 0x7E,
+    IT_LOAD_CONST_RAM                    = 0x80,
+    IT_WRITE_CONST_RAM                   = 0x81,
+    IT_DUMP_CONST_RAM                    = 0x83,
+    IT_INCREMENT_CE_COUNTER              = 0x84,
+    IT_INCREMENT_DE_COUNTER              = 0x85,
+    IT_WAIT_ON_CE_COUNTER                = 0x86,
+    IT_WAIT_ON_DE_COUNTER__SI            = 0x87,
+    IT_WAIT_ON_DE_COUNTER_DIFF           = 0x88,
+    IT_SWITCH_BUFFER                     = 0x8B,
+    IT_DRAW_PREAMBLE__CI__VI             = 0x36,
+    IT_RELEASE_MEM__CI__VI               = 0x49,
+    IT_DMA_DATA__CI__VI                  = 0x50,
+    IT_ACQUIRE_MEM__CI__VI               = 0x58,
+    IT_REWIND__CI__VI                    = 0x59,
+    IT_LOAD_UCONFIG_REG__CI__VI          = 0x5E,
+    IT_SET_QUEUE_REG__CI__VI             = 0x78,
+    IT_SET_UCONFIG_REG__CI__VI           = 0x79,
+    IT_INDEX_ATTRIBUTES_INDIRECT__CI__VI = 0x91,
+    IT_SET_SH_REG_INDEX__CI__VI          = 0x9B,
+    IT_SET_RESOURCES__CI__VI             = 0xA0,
+    IT_MAP_PROCESS__CI__VI               = 0xA1,
+    IT_MAP_QUEUES__CI__VI                = 0xA2,
+    IT_UNMAP_QUEUES__CI__VI              = 0xA3,
+    IT_QUERY_STATUS__CI__VI              = 0xA4,
+    IT_RUN_LIST__CI__VI                  = 0xA5,
+    IT_LOAD_SH_REG_INDEX__VI             = 0x63,
+    IT_LOAD_CONTEXT_REG_INDEX__VI        = 0x9F,
+    IT_DUMP_CONST_RAM_OFFSET__VI         = 0x9E,
+};
+
+#define PM4_TYPE_0 0
+#define PM4_TYPE_2 2
+#define PM4_TYPE_3 3
+
+#endif
--- a/externals/glslang
+++ b/externals/glslang
@ -1 +1 @@
-Subproject commit 12cbda959b6df2af119a76a73ff906c2bed36884
+Subproject commit 46ef757e048e760b46601e6e77ae0cb72c97bd2f
--- a/externals/magic_enum
+++ b/externals/magic_enum
@ -1 +1 @@
-Subproject commit dae6bbf16c363e9ead4e628a47fdb02956a634f3
+Subproject commit 126539e13cccdc2e75ce770e94f3c26403099fa5
--- a/externals/pugixml
+++ b/externals/pugixml
@ -0,0 +1 @@
+Subproject commit 3b17184379fcaaeb7f1fbe08018b7fedf2640b3b
--- a/externals/robin-map
+++ b/externals/robin-map
@ -1 +1 @@
-Subproject commit 2c48a1a50203bbaf1e3d0d64c5d726d56f8d3bb3
+Subproject commit fe845fd7852ef541c5479ae23b3d36b57f8608ee
--- a/externals/sdl3
+++ b/externals/sdl3
@ -1 +1 @@
-Subproject commit 4cc3410dce50cefce98d3cf3cf1bc8eca83b862a
+Subproject commit 0548050fc5a4edf1f47c3633c2cd06d8762b5532
--- a/externals/toml11
+++ b/externals/toml11
@ -1 +1 @@
-Subproject commit 4b740127230472779c4a4d71e1a75aaa3a367a2d
+Subproject commit d050c6b137199666cae75c2628a75d63b49b1c22
--- a/externals/vma
+++ b/externals/vma
@ -1 +1 @@
-Subproject commit e1bdbca9baf4d682fb6066b380f4aa4a7bdbb58a
+Subproject commit 1c35ba99ce775f8342d87a83a3f0f696f99c2a39
--- a/externals/vulkan-headers
+++ b/externals/vulkan-headers
@ -1 +1 @@
-Subproject commit d205aff40b4e15d4c568523ee6a26f85138126d9
+Subproject commit 29f979ee5aa58b7b005f805ea8df7a855c39ff37
--- a/externals/xxhash
+++ b/externals/xxhash
@ -1 +1 @@
-Subproject commit dbea33e47e7c0fe0b7c8592cd931c7430c1f130d
+Subproject commit 3e321b4407318ac1348c0b80fb6fbae8c81ad5fa
--- a/scripts/file_formats/sfo.hexpat
+++ b/scripts/file_formats/sfo.hexpat
@ -0,0 +1,52 @@
+// SPDX-FileCopyrightText: Copyright 2024 shadPS4 Emulator Project
+// SPDX-License-Identifier: GPL-2.0-or-later
+
+import std.io;
+import std.sys;
+
+struct Header {
+    u32 magic;
+    u32 version;
+    u32 key_table_offset;
+    u32 data_table_offset;
+    u32 index_table_entries;
+};
+
+struct KeyEntry {
+    char name[];
+} [[inline]];
+
+struct DataEntry<auto fmt, auto size> {
+    if (fmt == 0x0404) {
+        u32 int_value;
+    } else if(fmt == 0x0004) {
+		char bin_value[size];
+	} else if(fmt == 0x0204) {
+        char str_value[size];
+    } else {
+        std::warning("unknown fmt type");
+    }
+} [[inline]];
+
+struct IndexEntry {
+    u16 key_offset;
+    u16 param_fmt;
+    u32 param_len;
+    u32 param_max_len;
+    u32 data_offset;
+};
+
+struct Entry<auto KeyTableOffset, auto DataTableOffset> {
+    u64 begin = $;
+    IndexEntry index;
+    KeyEntry key @ KeyTableOffset + index.key_offset;
+    DataEntry<index.param_fmt, index.param_len> data @ DataTableOffset + index.data_offset;
+	u8 data_empty[index.param_max_len - index.param_len] @ DataTableOffset + index.data_offset + index.param_len;
+    $ = begin + sizeof(IndexEntry);
+};
+
+Header header @ 0;
+std::assert(header.magic == 0x46535000, "Miss match magic");
+std::assert(header.version == 0x00000101, "Miss match version");
+
+Entry<header.key_table_offset, header.data_table_offset> list[header.index_table_entries] @ 0x14;
--- a/src/audio_core/sdl_audio.cpp
+++ b/src/audio_core/sdl_audio.cpp
@ -14,7 +14,9 @@

 namespace Audio {

-int SDLAudio::AudioOutOpen(int type, u32 samples_num, u32 freq,
+constexpr int AUDIO_STREAM_BUFFER_THRESHOLD = 65536; // Define constant for buffer threshold
+
+s32 SDLAudio::AudioOutOpen(int type, u32 samples_num, u32 freq,
                           Libraries::AudioOut::OrbisAudioOutParamFormat format) {
    using Libraries::AudioOut::OrbisAudioOutParamFormat;
    std::unique_lock lock{m_mutex};
@ -80,7 +82,7 @@ int SDLAudio::AudioOutOpen(int type, u32 samples_num, u32 freq,
            SDL_zero(fmt);
            fmt.format = sampleFormat;
            fmt.channels = port.channels_num;
-            fmt.freq = 48000;
+            fmt.freq = freq; // Set frequency from the argument
            port.stream =
                SDL_OpenAudioDeviceStream(SDL_AUDIO_DEVICE_DEFAULT_PLAYBACK, &fmt, NULL, NULL);
            SDL_ResumeAudioDevice(SDL_GetAudioStreamDevice(port.stream));
@ -88,7 +90,8 @@ int SDLAudio::AudioOutOpen(int type, u32 samples_num, u32 freq,
        }
    }

-    return -1; // all ports are used
+    LOG_ERROR(Lib_AudioOut, "Audio ports are full");
+    return ORBIS_AUDIO_OUT_ERROR_PORT_FULL; // all ports are used
 }

 s32 SDLAudio::AudioOutOutput(s32 handle, const void* ptr) {
@ -97,27 +100,28 @@ s32 SDLAudio::AudioOutOutput(s32 handle, const void* ptr) {
    if (!port.isOpen) {
        return ORBIS_AUDIO_OUT_ERROR_INVALID_PORT;
    }
-    if (ptr == nullptr) {
-        return 0;
-    }
-    // TODO mixing channels
-    int result = SDL_PutAudioStreamData(port.stream, ptr,
-                                        port.samples_num * port.sample_size * port.channels_num);
-    // TODO find a correct value 8192 is estimated
-    while (SDL_GetAudioStreamAvailable(port.stream) > 65536) {
+
+    const size_t data_size = port.samples_num * port.sample_size * port.channels_num;
+
+    SDL_bool result = SDL_PutAudioStreamData(port.stream, ptr, data_size);
+
+    lock.unlock(); // Unlock only after necessary operations
+
+    while (SDL_GetAudioStreamAvailable(port.stream) > AUDIO_STREAM_BUFFER_THRESHOLD) {
        SDL_Delay(0);
    }

-    return result;
+    return result ? ORBIS_OK : -1;
 }

-bool SDLAudio::AudioOutSetVolume(s32 handle, s32 bitflag, s32* volume) {
+s32 SDLAudio::AudioOutSetVolume(s32 handle, s32 bitflag, s32* volume) {
    using Libraries::AudioOut::OrbisAudioOutParamFormat;
    std::shared_lock lock{m_mutex};
    auto& port = portsOut[handle - 1];
    if (!port.isOpen) {
        return ORBIS_AUDIO_OUT_ERROR_INVALID_PORT;
    }
+
    for (int i = 0; i < port.channels_num; i++, bitflag >>= 1u) {
        auto bit = bitflag & 0x1u;

@ -147,16 +151,16 @@ bool SDLAudio::AudioOutSetVolume(s32 handle, s32 bitflag, s32* volume) {
        }
    }

-    return true;
+    return ORBIS_OK;
 }

-bool SDLAudio::AudioOutGetStatus(s32 handle, int* type, int* channels_num) {
+s32 SDLAudio::AudioOutGetStatus(s32 handle, int* type, int* channels_num) {
    std::shared_lock lock{m_mutex};
    auto& port = portsOut[handle - 1];
    *type = port.type;
    *channels_num = port.channels_num;

-    return true;
+    return ORBIS_OK;
 }

 } // namespace Audio
--- a/src/audio_core/sdl_audio.h
+++ b/src/audio_core/sdl_audio.h
@ -14,11 +14,11 @@ public:
    SDLAudio() = default;
    virtual ~SDLAudio() = default;

-    int AudioOutOpen(int type, u32 samples_num, u32 freq,
+    s32 AudioOutOpen(int type, u32 samples_num, u32 freq,
                     Libraries::AudioOut::OrbisAudioOutParamFormat format);
    s32 AudioOutOutput(s32 handle, const void* ptr);
-    bool AudioOutSetVolume(s32 handle, s32 bitflag, s32* volume);
-    bool AudioOutGetStatus(s32 handle, int* type, int* channels_num);
+    s32 AudioOutSetVolume(s32 handle, s32 bitflag, s32* volume);
+    s32 AudioOutGetStatus(s32 handle, int* type, int* channels_num);

 private:
    struct PortOut {
@ -33,8 +33,7 @@ private:
        bool isOpen = false;
    };
    std::shared_mutex m_mutex;
-    std::array<PortOut, 22> portsOut; // main up to 8 ports , BGM 1 port , voice up to 4 ports ,
-                                      // personal up to 4 ports , padspk up to 5 ports , aux 1 port
+    std::array<PortOut, Libraries::AudioOut::SCE_AUDIO_OUT_NUM_PORTS> portsOut;
 };

 } // namespace Audio
--- a/src/common/alignment.h
+++ b/src/common/alignment.h
@ -28,4 +28,16 @@ template <typename T>
    return (value & 0x3FFF) == 0;
 }

+template <typename T>
+    requires std::is_integral_v<T>
+[[nodiscard]] constexpr bool Is64KBAligned(T value) {
+    return (value & 0xFFFF) == 0;
+}
+
+template <typename T>
+    requires std::is_integral_v<T>
+[[nodiscard]] constexpr bool Is2MBAligned(T value) {
+    return (value & 0x1FFFFF) == 0;
+}
+
 } // namespace Common
--- a/src/common/config.cpp
+++ b/src/common/config.cpp
@ -3,28 +3,52 @@

 #include <fstream>
 #include <string>
+#include <common/version.h>
 #include <fmt/core.h>
+#include <fmt/xchar.h> // for wstring support
 #include <toml.hpp>
+#include "common/logging/formatter.h"
+#include "common/path_util.h"
 #include "config.h"

+namespace toml {
+template <typename TC, typename K>
+std::filesystem::path find_fs_path_or(const basic_value<TC>& v, const K& ky,
+                                      std::filesystem::path opt) {
+    try {
+        auto str = find<std::string>(v, ky);
+        if (str.empty()) {
+            return opt;
+        }
+        std::u8string u8str{(char8_t*)&str.front(), (char8_t*)&str.back() + 1};
+        return std::filesystem::path{u8str};
+    } catch (...) {
+        return opt;
+    }
+}
+} // namespace toml
+
 namespace Config {

 static bool isNeo = false;
 static bool isFullscreen = false;
+static bool playBGM = false;
+static int BGMvolume = 50;
 static u32 screenWidth = 1280;
 static u32 screenHeight = 720;
 static s32 gpuId = -1; // Vulkan physical device index. Set to negative for auto select
 static std::string logFilter;
 static std::string logType = "async";
 static std::string userName = "shadPS4";
+static std::string updateChannel;
 static bool useSpecialPad = false;
 static int specialPadClass = 1;
 static bool isDebugDump = false;
 static bool isShowSplash = false;
+static bool isAutoUpdate = false;
 static bool isNullGpu = false;
 static bool shouldCopyGPUBuffers = false;
 static bool shouldDumpShaders = false;
-static bool shouldDumpPM4 = false;
 static u32 vblankDivider = 1;
 static bool vkValidation = false;
 static bool vkValidationSync = false;
@ -34,7 +58,8 @@ static bool vkMarkers = false;
 static bool vkCrashDiagnostic = false;

 // Gui
-std::string settings_install_dir = "";
+std::filesystem::path settings_install_dir = {};
+std::filesystem::path settings_addon_install_dir = {};
 u32 main_window_geometry_x = 400;
 u32 main_window_geometry_y = 400;
 u32 main_window_geometry_w = 1280;
@ -62,6 +87,14 @@ bool isFullscreenMode() {
    return isFullscreen;
 }

+bool getPlayBGM() {
+    return playBGM;
+}
+
+int getBGMvolume() {
+    return BGMvolume;
+}
+
 u32 getScreenWidth() {
    return screenWidth;
 }
@ -86,6 +119,10 @@ std::string getUserName() {
    return userName;
 }

+std::string getUpdateChannel() {
+    return updateChannel;
+}
+
 bool getUseSpecialPad() {
    return useSpecialPad;
 }
@ -102,6 +139,10 @@ bool showSplash() {
    return isShowSplash;
 }

+bool autoUpdate() {
+    return isAutoUpdate;
+}
+
 bool nullGpu() {
    return isNullGpu;
 }
@ -114,10 +155,6 @@ bool dumpShaders() {
    return shouldDumpShaders;
 }

-bool dumpPM4() {
-    return shouldDumpPM4;
-}
-
 bool isRdocEnabled() {
    return rdocEnable;
 }
@ -170,6 +207,10 @@ void setShowSplash(bool enable) {
    isShowSplash = enable;
 }

+void setAutoUpdate(bool enable) {
+    isAutoUpdate = enable;
+}
+
 void setNullGpu(bool enable) {
    isNullGpu = enable;
 }
@ -182,10 +223,6 @@ void setDumpShaders(bool enable) {
    shouldDumpShaders = enable;
 }

-void setDumpPM4(bool enable) {
-    shouldDumpPM4 = enable;
-}
-
 void setVkValidation(bool enable) {
    vkValidation = enable;
 }
@ -206,6 +243,14 @@ void setFullscreenMode(bool enable) {
    isFullscreen = enable;
 }

+void setPlayBGM(bool enable) {
+    playBGM = enable;
+}
+
+void setBGMvolume(int volume) {
+    BGMvolume = volume;
+}
+
 void setLanguage(u32 language) {
    m_language = language;
 }
@ -226,6 +271,10 @@ void setUserName(const std::string& type) {
    userName = type;
 }

+void setUpdateChannel(const std::string& type) {
+    updateChannel = type;
+}
+
 void setUseSpecialPad(bool use) {
    useSpecialPad = use;
 }
@ -240,9 +289,12 @@ void setMainWindowGeometry(u32 x, u32 y, u32 w, u32 h) {
    main_window_geometry_w = w;
    main_window_geometry_h = h;
 }
-void setGameInstallDir(const std::string& dir) {
+void setGameInstallDir(const std::filesystem::path& dir) {
    settings_install_dir = dir;
 }
+void setAddonInstallDir(const std::filesystem::path& dir) {
+    settings_addon_install_dir = dir;
+}
 void setMainWindowTheme(u32 theme) {
    mw_themes = theme;
 }
@ -296,9 +348,16 @@ u32 getMainWindowGeometryW() {
 u32 getMainWindowGeometryH() {
    return main_window_geometry_h;
 }
-std::string getGameInstallDir() {
+std::filesystem::path getGameInstallDir() {
    return settings_install_dir;
 }
+std::filesystem::path getAddonInstallDir() {
+    if (settings_addon_install_dir.empty()) {
+        // Default for users without a config file or a config file from before this option existed
+        return Common::FS::GetUserPath(Common::FS::PathType::UserDir) / "addcont";
+    }
+    return settings_addon_install_dir;
+}
 u32 getMainWindowTheme() {
    return mw_themes;
 }
@ -351,7 +410,10 @@ void load(const std::filesystem::path& path) {
    toml::value data;

    try {
-        data = toml::parse(path);
+        std::ifstream ifs;
+        ifs.exceptions(std::ifstream::failbit | std::ifstream::badbit);
+        ifs.open(path, std::ios_base::binary);
+        data = toml::parse(ifs, std::string{fmt::UTF(path.filename().u8string()).data});
    } catch (std::exception& ex) {
        fmt::print("Got exception trying to load config file. Exception: {}\n", ex.what());
        return;
@ -361,10 +423,18 @@ void load(const std::filesystem::path& path) {

        isNeo = toml::find_or<bool>(general, "isPS4Pro", false);
        isFullscreen = toml::find_or<bool>(general, "Fullscreen", false);
+        playBGM = toml::find_or<bool>(general, "playBGM", false);
+        BGMvolume = toml::find_or<int>(general, "BGMvolume", 50);
        logFilter = toml::find_or<std::string>(general, "logFilter", "");
        logType = toml::find_or<std::string>(general, "logType", "sync");
        userName = toml::find_or<std::string>(general, "userName", "shadPS4");
+        if (Common::isRelease) {
+            updateChannel = toml::find_or<std::string>(general, "updateChannel", "Release");
+        } else {
+            updateChannel = toml::find_or<std::string>(general, "updateChannel", "Nightly");
+        }
        isShowSplash = toml::find_or<bool>(general, "showSplash", true);
+        isAutoUpdate = toml::find_or<bool>(general, "autoUpdate", false);
    }

    if (data.contains("Input")) {
@ -382,7 +452,6 @@ void load(const std::filesystem::path& path) {
        isNullGpu = toml::find_or<bool>(gpu, "nullGpu", false);
        shouldCopyGPUBuffers = toml::find_or<bool>(gpu, "copyGPUBuffers", false);
        shouldDumpShaders = toml::find_or<bool>(gpu, "dumpShaders", false);
-        shouldDumpPM4 = toml::find_or<bool>(gpu, "dumpPM4", false);
        vblankDivider = toml::find_or<int>(gpu, "vblankDivider", 1);
    }

@ -414,7 +483,8 @@ void load(const std::filesystem::path& path) {
        mw_themes = toml::find_or<int>(gui, "theme", 0);
        m_window_size_W = toml::find_or<int>(gui, "mw_width", 0);
        m_window_size_H = toml::find_or<int>(gui, "mw_height", 0);
-        settings_install_dir = toml::find_or<std::string>(gui, "installDir", "");
+        settings_install_dir = toml::find_fs_path_or(gui, "installDir", {});
+        settings_addon_install_dir = toml::find_fs_path_or(gui, "addonInstallDir", {});
        main_window_geometry_x = toml::find_or<int>(gui, "geometry_x", 0);
        main_window_geometry_y = toml::find_or<int>(gui, "geometry_y", 0);
        main_window_geometry_w = toml::find_or<int>(gui, "geometry_w", 0);
@ -438,25 +508,31 @@ void save(const std::filesystem::path& path) {
    std::error_code error;
    if (std::filesystem::exists(path, error)) {
        try {
-            data = toml::parse(path);
+            std::ifstream ifs;
+            ifs.exceptions(std::ifstream::failbit | std::ifstream::badbit);
+            ifs.open(path, std::ios_base::binary);
+            data = toml::parse(ifs, std::string{fmt::UTF(path.filename().u8string()).data});
        } catch (const std::exception& ex) {
            fmt::print("Exception trying to parse config file. Exception: {}\n", ex.what());
            return;
        }
    } else {
        if (error) {
-            fmt::print("Filesystem error accessing {} (error: {})\n", path.string(),
-                       error.message().c_str());
+            fmt::print("Filesystem error: {}\n", error.message());
        }
-        fmt::print("Saving new configuration file {}\n", path.string());
+        fmt::print("Saving new configuration file {}\n", fmt::UTF(path.u8string()));
    }

    data["General"]["isPS4Pro"] = isNeo;
    data["General"]["Fullscreen"] = isFullscreen;
+    data["General"]["playBGM"] = playBGM;
+    data["General"]["BGMvolume"] = BGMvolume;
    data["General"]["logFilter"] = logFilter;
    data["General"]["logType"] = logType;
    data["General"]["userName"] = userName;
+    data["General"]["updateChannel"] = updateChannel;
    data["General"]["showSplash"] = isShowSplash;
+    data["General"]["autoUpdate"] = isAutoUpdate;
    data["Input"]["useSpecialPad"] = useSpecialPad;
    data["Input"]["specialPadClass"] = specialPadClass;
    data["GPU"]["screenWidth"] = screenWidth;
@ -464,7 +540,6 @@ void save(const std::filesystem::path& path) {
    data["GPU"]["nullGpu"] = isNullGpu;
    data["GPU"]["copyGPUBuffers"] = shouldCopyGPUBuffers;
    data["GPU"]["dumpShaders"] = shouldDumpShaders;
-    data["GPU"]["dumpPM4"] = shouldDumpPM4;
    data["GPU"]["vblankDivider"] = vblankDivider;
    data["Vulkan"]["gpuId"] = gpuId;
    data["Vulkan"]["validation"] = vkValidation;
@ -482,7 +557,9 @@ void save(const std::filesystem::path& path) {
    data["GUI"]["gameTableMode"] = m_table_mode;
    data["GUI"]["mw_width"] = m_window_size_W;
    data["GUI"]["mw_height"] = m_window_size_H;
-    data["GUI"]["installDir"] = settings_install_dir;
+    data["GUI"]["installDir"] = std::string{fmt::UTF(settings_install_dir.u8string()).data};
+    data["GUI"]["addonInstallDir"] =
+        std::string{fmt::UTF(settings_addon_install_dir.u8string()).data};
    data["GUI"]["geometry_x"] = main_window_geometry_x;
    data["GUI"]["geometry_y"] = main_window_geometry_y;
    data["GUI"]["geometry_w"] = main_window_geometry_w;
@ -502,18 +579,25 @@ void save(const std::filesystem::path& path) {
 void setDefaultValues() {
    isNeo = false;
    isFullscreen = false;
+    playBGM = false;
+    BGMvolume = 50;
    screenWidth = 1280;
    screenHeight = 720;
    logFilter = "";
    logType = "async";
    userName = "shadPS4";
+    if (Common::isRelease) {
+        updateChannel = "Release";
+    } else {
+        updateChannel = "Nightly";
+    }
    useSpecialPad = false;
    specialPadClass = 1;
    isDebugDump = false;
    isShowSplash = false;
+    isAutoUpdate = false;
    isNullGpu = false;
    shouldDumpShaders = false;
-    shouldDumpPM4 = false;
    vblankDivider = 1;
    vkValidation = false;
    vkValidationSync = false;
--- a/src/common/config.h
+++ b/src/common/config.h
@ -13,9 +13,13 @@ void save(const std::filesystem::path& path);

 bool isNeoMode();
 bool isFullscreenMode();
+bool getPlayBGM();
+int getBGMvolume();
+
 std::string getLogFilter();
 std::string getLogType();
 std::string getUserName();
+std::string getUpdateChannel();

 bool getUseSpecialPad();
 int getSpecialPadClass();
@ -26,27 +30,30 @@ s32 getGpuId();

 bool debugDump();
 bool showSplash();
+bool autoUpdate();
 bool nullGpu();
 bool copyGPUCmdBuffers();
 bool dumpShaders();
-bool dumpPM4();
 bool isRdocEnabled();
 u32 vblankDiv();

 void setDebugDump(bool enable);
 void setShowSplash(bool enable);
+void setAutoUpdate(bool enable);
 void setNullGpu(bool enable);
 void setCopyGPUCmdBuffers(bool enable);
 void setDumpShaders(bool enable);
-void setDumpPM4(bool enable);
 void setVblankDiv(u32 value);
 void setGpuId(s32 selectedGpuId);
 void setScreenWidth(u32 width);
 void setScreenHeight(u32 height);
 void setFullscreenMode(bool enable);
+void setPlayBGM(bool enable);
+void setBGMvolume(int volume);
 void setLanguage(u32 language);
 void setNeoMode(bool enable);
 void setUserName(const std::string& type);
+void setUpdateChannel(const std::string& type);

 void setUseSpecialPad(bool use);
 void setSpecialPadClass(int type);
@ -66,7 +73,8 @@ bool vkCrashDiagnosticEnabled();

 // Gui
 void setMainWindowGeometry(u32 x, u32 y, u32 w, u32 h);
-void setGameInstallDir(const std::string& dir);
+void setGameInstallDir(const std::filesystem::path& dir);
+void setAddonInstallDir(const std::filesystem::path& dir);
 void setMainWindowTheme(u32 theme);
 void setIconSize(u32 size);
 void setIconSizeGrid(u32 size);
@ -84,7 +92,8 @@ u32 getMainWindowGeometryX();
 u32 getMainWindowGeometryY();
 u32 getMainWindowGeometryW();
 u32 getMainWindowGeometryH();
-std::string getGameInstallDir();
+std::filesystem::path getGameInstallDir();
+std::filesystem::path getAddonInstallDir();
 u32 getMainWindowTheme();
 u32 getIconSize();
 u32 getIconSizeGrid();
--- a/src/common/cstring.h
+++ b/src/common/cstring.h
@ -0,0 +1,157 @@
+// SPDX-FileCopyrightText: Copyright 2024 shadPS4 Emulator Project
+// SPDX-License-Identifier: GPL-2.0-or-later
+
+#pragma once
+
+#include <string_view>
+
+#include "assert.h"
+
+namespace Common {
+
+#pragma clang diagnostic push
+#pragma clang diagnostic ignored "-Wtautological-undefined-compare"
+
+/**
+ * @brief A null-terminated string with a fixed maximum length
+ *        This class is not meant to be used as a general-purpose string class
+ *        It is meant to be used as `char[N]` where memory layout is fixed
+ * @tparam N Maximum length of the string
+ * @tparam T Type of character
+ */
+template <size_t N, typename T = char>
+class CString {
+    T data[N]{};
+
+public:
+    class Iterator;
+
+    CString() = default;
+
+    template <size_t M>
+    explicit CString(const CString<M>& other)
+        requires(M <= N)
+    {
+        if (this == nullptr) {
+            return;
+        }
+        std::ranges::copy(other.begin(), other.end(), data);
+    }
+
+    void FromString(const std::basic_string_view<T>& str) {
+        if (this == nullptr) {
+            return;
+        }
+        size_t p = str.copy(data, N - 1);
+        data[p] = '\0';
+    }
+
+    void Zero() {
+        if (this == nullptr) {
+            return;
+        }
+        std::ranges::fill(data, 0);
+    }
+
+    explicit(false) operator std::basic_string_view<T>() const {
+        if (this == nullptr) {
+            return {};
+        }
+        return std::basic_string_view<T>{data};
+    }
+
+    explicit operator std::basic_string<T>() const {
+        if (this == nullptr) {
+            return {};
+        }
+        return std::basic_string<T>{data};
+    }
+
+    std::basic_string<T> to_string() const {
+        if (this == nullptr) {
+            return {};
+        }
+        return std::basic_string<T>{data};
+    }
+
+    std::basic_string_view<T> to_view() const {
+        if (this == nullptr) {
+            return {};
+        }
+        return std::basic_string_view<T>{data};
+    }
+
+    char* begin() {
+        if (this == nullptr) {
+            return nullptr;
+        }
+        return data;
+    }
+
+    const char* begin() const {
+        if (this == nullptr) {
+            return nullptr;
+        }
+        return data;
+    }
+
+    char* end() {
+        if (this == nullptr) {
+            return nullptr;
+        }
+        return data + N;
+    }
+
+    const char* end() const {
+        if (this == nullptr) {
+            return nullptr;
+        }
+        return data + N;
+    }
+
+    T& operator[](size_t idx) {
+        return data[idx];
+    }
+
+    const T& operator[](size_t idx) const {
+        return data[idx];
+    }
+
+    class Iterator {
+        T* ptr;
+        T* end;
+
+    public:
+        using difference_type = std::ptrdiff_t;
+        using value_type = T;
+        using pointer = T*;
+        using reference = T&;
+        using iterator_category = std::random_access_iterator_tag;
+
+        Iterator() = default;
+        explicit Iterator(T* ptr) : ptr(ptr), end(ptr + N) {}
+
+        Iterator& operator++() {
+            ++ptr;
+            return *this;
+        }
+
+        Iterator operator++(int) {
+            Iterator tmp = *this;
+            ++ptr;
+            return tmp;
+        }
+
+        operator T*() {
+            ASSERT_MSG(ptr >= end, "CString iterator out of bounds");
+            return ptr;
+        }
+    };
+};
+
+static_assert(sizeof(CString<13>) == sizeof(char[13])); // Ensure size still matches a simple array
+static_assert(std::weakly_incrementable<CString<13>::Iterator>);
+
+#pragma clang diagnostic pop
+
+} // namespace Common
--- a/src/common/disassembler.cpp
+++ b/src/common/disassembler.cpp
@ -2,18 +2,18 @@
 // SPDX-License-Identifier: GPL-2.0-or-later

 #include <fmt/format.h>
-#include "common/disassembler.h"
+#include "common/decoder.h"

 namespace Common {

-Disassembler::Disassembler() {
+DecoderImpl::DecoderImpl() {
    ZydisDecoderInit(&m_decoder, ZYDIS_MACHINE_MODE_LONG_64, ZYDIS_STACK_WIDTH_64);
    ZydisFormatterInit(&m_formatter, ZYDIS_FORMATTER_STYLE_INTEL);
 }

-Disassembler::~Disassembler() = default;
+DecoderImpl::~DecoderImpl() = default;

-void Disassembler::printInstruction(void* code, u64 address) {
+void DecoderImpl::printInstruction(void* code, u64 address) {
    ZydisDecodedInstruction instruction;
    ZydisDecodedOperand operands[ZYDIS_MAX_OPERAND_COUNT_VISIBLE];
    ZyanStatus status =
@ -25,8 +25,8 @@ void Disassembler::printInstruction(void* code, u64 address) {
    }
 }

-void Disassembler::printInst(ZydisDecodedInstruction& inst, ZydisDecodedOperand* operands,
-                             u64 address) {
+void DecoderImpl::printInst(ZydisDecodedInstruction& inst, ZydisDecodedOperand* operands,
+                            u64 address) {
    const int bufLen = 256;
    char szBuffer[bufLen];
    ZydisFormatterFormatInstruction(&m_formatter, &inst, operands, inst.operand_count_visible,
@ -34,4 +34,9 @@ void Disassembler::printInst(ZydisDecodedInstruction& inst, ZydisDecodedOperand*
    fmt::print("instruction: {}\n", szBuffer);
 }

+ZyanStatus DecoderImpl::decodeInstruction(ZydisDecodedInstruction& inst,
+                                          ZydisDecodedOperand* operands, void* data, u64 size) {
+    return ZydisDecoderDecodeFull(&m_decoder, data, size, &inst, operands);
+}
+
 } // namespace Common
--- a/src/common/disassembler.h
+++ b/src/common/disassembler.h
@ -4,21 +4,26 @@
 #pragma once

 #include <Zydis/Zydis.h>
+#include "common/singleton.h"
 #include "common/types.h"

 namespace Common {

-class Disassembler {
+class DecoderImpl {
 public:
-    Disassembler();
-    ~Disassembler();
+    DecoderImpl();
+    ~DecoderImpl();

    void printInst(ZydisDecodedInstruction& inst, ZydisDecodedOperand* operands, u64 address);
    void printInstruction(void* code, u64 address);
+    ZyanStatus decodeInstruction(ZydisDecodedInstruction& inst, ZydisDecodedOperand* operands,
+                                 void* data, u64 size = 15);

 private:
    ZydisDecoder m_decoder;
    ZydisFormatter m_formatter;
 };

+using Decoder = Common::Singleton<DecoderImpl>;
+
 } // namespace Common
--- a/src/common/elf_info.h
+++ b/src/common/elf_info.h
@ -0,0 +1,72 @@
+// SPDX-FileCopyrightText: Copyright 2024 shadPS4 Emulator Project
+// SPDX-License-Identifier: GPL-2.0-or-later
+
+#pragma once
+
+#include <string>
+#include <string_view>
+
+#include "assert.h"
+#include "singleton.h"
+#include "types.h"
+
+namespace Core {
+class Emulator;
+}
+
+namespace Common {
+
+class ElfInfo {
+    friend class Core::Emulator;
+
+    bool initialized = false;
+
+    std::string game_serial{};
+    std::string title{};
+    std::string app_ver{};
+    u32 firmware_ver = 0;
+    u32 raw_firmware_ver = 0;
+
+public:
+    static constexpr u32 FW_15 = 0x1500000;
+    static constexpr u32 FW_16 = 0x1600000;
+    static constexpr u32 FW_17 = 0x1700000;
+    static constexpr u32 FW_20 = 0x2000000;
+    static constexpr u32 FW_25 = 0x2500000;
+    static constexpr u32 FW_30 = 0x3000000;
+    static constexpr u32 FW_40 = 0x4000000;
+    static constexpr u32 FW_45 = 0x4500000;
+    static constexpr u32 FW_50 = 0x5000000;
+    static constexpr u32 FW_80 = 0x8000000;
+
+    static ElfInfo& Instance() {
+        return *Singleton<ElfInfo>::Instance();
+    }
+
+    [[nodiscard]] std::string_view GameSerial() const {
+        ASSERT(initialized);
+        return Instance().game_serial;
+    }
+
+    [[nodiscard]] std::string_view Title() const {
+        ASSERT(initialized);
+        return title;
+    }
+
+    [[nodiscard]] std::string_view AppVer() const {
+        ASSERT(initialized);
+        return app_ver;
+    }
+
+    [[nodiscard]] u32 FirmwareVer() const {
+        ASSERT(initialized);
+        return firmware_ver;
+    }
+
+    [[nodiscard]] u32 RawFirmwareVer() const {
+        ASSERT(initialized);
+        return raw_firmware_ver;
+    }
+};
+
+} // namespace Common
--- a/src/common/io_file.cpp
+++ b/src/common/io_file.cpp
@ -192,8 +192,9 @@ int IOFile::Open(const fs::path& path, FileAccessMode mode, FileType type, FileS
 #endif

    if (!IsOpen()) {
-        LOG_ERROR(Common_Filesystem, "Failed to open the file at path={}",
-                  PathToUTF8String(file_path));
+        const auto ec = std::error_code{result, std::generic_category()};
+        LOG_ERROR(Common_Filesystem, "Failed to open the file at path={}, error_message={}",
+                  PathToUTF8String(file_path), ec.message());
    }

    return result;
@ -372,6 +373,18 @@ bool IOFile::Seek(s64 offset, SeekOrigin origin) const {
        return false;
    }

+    u64 size = GetSize();
+    if (origin == SeekOrigin::CurrentPosition && Tell() + offset > size) {
+        LOG_ERROR(Common_Filesystem, "Seeking past the end of the file");
+        return false;
+    } else if (origin == SeekOrigin::SetOrigin && (u64)offset > size) {
+        LOG_ERROR(Common_Filesystem, "Seeking past the end of the file");
+        return false;
+    } else if (origin == SeekOrigin::End && offset > 0) {
+        LOG_ERROR(Common_Filesystem, "Seeking past the end of the file");
+        return false;
+    }
+
    errno = 0;

    const auto seek_result = fseeko(file, offset, ToSeekOrigin(origin)) == 0;
@ -396,4 +409,18 @@ s64 IOFile::Tell() const {
    return ftello(file);
 }

+u64 GetDirectorySize(const std::filesystem::path& path) {
+    if (!fs::exists(path)) {
+        return 0;
+    }
+
+    u64 total = 0;
+    for (const auto& entry : fs::recursive_directory_iterator(path)) {
+        if (fs::is_regular_file(entry.path())) {
+            total += fs::file_size(entry.path());
+        }
+    }
+    return total;
+}
+
 } // namespace Common::FS
--- a/src/common/io_file.h
+++ b/src/common/io_file.h
@ -205,9 +205,9 @@ public:
        return WriteSpan(string);
    }

-    static void WriteBytes(const std::filesystem::path path, std::span<const u8> data) {
+    static size_t WriteBytes(const std::filesystem::path path, std::span<const u8> data) {
        IOFile out(path, FileAccessMode::Write);
-        out.Write(data);
+        return out.Write(data);
    }

 private:
@ -219,4 +219,6 @@ private:
    uintptr_t file_mapping = 0;
 };

+u64 GetDirectorySize(const std::filesystem::path& path);
+
 } // namespace Common::FS
--- a/src/common/logging/backend.cpp
+++ b/src/common/logging/backend.cpp
@ -144,6 +144,10 @@ public:
        initialization_in_progress_suppress_logging = false;
    }

+    static bool IsActive() {
+        return instance != nullptr;
+    }
+
    static void Start() {
        instance->StartBackendThread();
    }
@ -275,6 +279,10 @@ void Initialize(std::string_view log_file) {
    Impl::Initialize(log_file.empty() ? LOG_FILE : log_file);
 }

+bool IsActive() {
+    return Impl::IsActive();
+}
+
 void Start() {
    Impl::Start();
 }
--- a/src/common/logging/backend.h
+++ b/src/common/logging/backend.h
@ -13,6 +13,8 @@ class Filter;
 /// Initializes the logging system. This should be the first thing called in main.
 void Initialize(std::string_view log_file = "");

+bool IsActive();
+
 /// Starts the logging threads.
 void Start();

--- a/src/common/logging/formatter.h
+++ b/src/common/logging/formatter.h
@ -19,3 +19,24 @@ struct fmt::formatter<T, std::enable_if_t<std::is_enum_v<T>, char>>
    }
 };
 #endif
+
+namespace fmt {
+template <typename T = std::string_view>
+struct UTF {
+    T data;
+
+    explicit UTF(const std::u8string_view view) {
+        data = view.empty() ? T{} : T{(const char*)&view.front(), (const char*)&view.back() + 1};
+    }
+
+    explicit UTF(const std::u8string& str) : UTF(std::u8string_view{str}) {}
+};
+} // namespace fmt
+
+template <>
+struct fmt::formatter<fmt::UTF<std::string_view>, char> : formatter<std::string_view> {
+    template <typename FormatContext>
+    auto format(const UTF<std::string_view>& wrapper, FormatContext& ctx) const {
+        return formatter<std::string_view>::format(wrapper.data, ctx);
+    }
+};
--- a/src/common/memory_patcher.cpp
+++ b/src/common/memory_patcher.cpp
@ -2,14 +2,20 @@
 // SPDX-License-Identifier: GPL-2.0-or-later

 #include <algorithm>
+#include <codecvt>
+#include <sstream>
 #include <string>
+#include <pugixml.hpp>
+#ifdef ENABLE_QT_GUI
 #include <QFile>
 #include <QJsonArray>
 #include <QJsonDocument>
 #include <QJsonObject>
 #include <QListView>
 #include <QMessageBox>
+#include <QString>
 #include <QXmlStreamReader>
+#endif
 #include "common/logging/log.h"
 #include "common/path_util.h"
 #include "memory_patcher.h"
@ -17,81 +23,172 @@
 namespace MemoryPatcher {

 uintptr_t g_eboot_address;
-u64 g_eboot_image_size;
+uint64_t g_eboot_image_size;
 std::string g_game_serial;
+std::string patchFile;
 std::vector<patchInfo> pending_patches;

-QString toHex(unsigned long long value, size_t byteSize) {
+std::string toHex(unsigned long long value, size_t byteSize) {
    std::stringstream ss;
    ss << std::hex << std::setfill('0') << std::setw(byteSize * 2) << value;
-    return QString::fromStdString(ss.str());
+    return ss.str();
 }

-QString convertValueToHex(const QString& type, const QString& valueStr) {
-    QString result;
-    std::string typeStr = type.toStdString();
-    std::string valueStrStd = valueStr.toStdString();
+std::string convertValueToHex(const std::string type, const std::string valueStr) {
+    std::string result;

-    if (typeStr == "byte") {
-        unsigned int value = std::stoul(valueStrStd, nullptr, 16);
+    if (type == "byte") {
+        unsigned int value = std::stoul(valueStr, nullptr, 16);
        result = toHex(value, 1);
-    } else if (typeStr == "bytes16") {
-        unsigned int value = std::stoul(valueStrStd, nullptr, 16);
+    } else if (type == "bytes16") {
+        unsigned int value = std::stoul(valueStr, nullptr, 16);
        result = toHex(value, 2);
-    } else if (typeStr == "bytes32") {
-        unsigned long value = std::stoul(valueStrStd, nullptr, 16);
+    } else if (type == "bytes32") {
+        unsigned long value = std::stoul(valueStr, nullptr, 16);
        result = toHex(value, 4);
-    } else if (typeStr == "bytes64") {
-        unsigned long long value = std::stoull(valueStrStd, nullptr, 16);
+    } else if (type == "bytes64") {
+        unsigned long long value = std::stoull(valueStr, nullptr, 16);
        result = toHex(value, 8);
-    } else if (typeStr == "float32") {
+    } else if (type == "float32") {
        union {
            float f;
            uint32_t i;
        } floatUnion;
-        floatUnion.f = std::stof(valueStrStd);
+        floatUnion.f = std::stof(valueStr);
        result = toHex(floatUnion.i, sizeof(floatUnion.i));
-    } else if (typeStr == "float64") {
+    } else if (type == "float64") {
        union {
            double d;
            uint64_t i;
        } doubleUnion;
-        doubleUnion.d = std::stod(valueStrStd);
+        doubleUnion.d = std::stod(valueStr);
        result = toHex(doubleUnion.i, sizeof(doubleUnion.i));
-    } else if (typeStr == "utf8") {
-        QByteArray byteArray = QString::fromStdString(valueStrStd).toUtf8();
-        byteArray.append('\0');
+    } else if (type == "utf8") {
+        std::vector<unsigned char> byteArray =
+            std::vector<unsigned char>(valueStr.begin(), valueStr.end());
+        byteArray.push_back('\0');
        std::stringstream ss;
        for (unsigned char c : byteArray) {
            ss << std::hex << std::setfill('0') << std::setw(2) << static_cast<int>(c);
        }
-        result = QString::fromStdString(ss.str());
-    } else if (typeStr == "utf16") {
-        QByteArray byteArray(
-            reinterpret_cast<const char*>(QString::fromStdString(valueStrStd).utf16()),
-            QString::fromStdString(valueStrStd).size() * 2);
-        byteArray.append('\0');
-        byteArray.append('\0');
-        std::stringstream ss;
-        for (unsigned char c : byteArray) {
-            ss << std::hex << std::setfill('0') << std::setw(2) << static_cast<int>(c);
+        result = ss.str();
+    } else if (type == "utf16") {
+        std::wstring wide_str(valueStr.size(), L'\0');
+        std::mbstowcs(&wide_str[0], valueStr.c_str(), valueStr.size());
+        wide_str.resize(std::wcslen(wide_str.c_str()));
+
+        std::u16string valueStringU16;
+
+        for (wchar_t wc : wide_str) {
+            if (wc <= 0xFFFF) {
+                valueStringU16.push_back(static_cast<char16_t>(wc));
+            } else {
+                wc -= 0x10000;
+                valueStringU16.push_back(static_cast<char16_t>(0xD800 | (wc >> 10)));
+                valueStringU16.push_back(static_cast<char16_t>(0xDC00 | (wc & 0x3FF)));
+            }
        }
-        result = QString::fromStdString(ss.str());
-    } else if (typeStr == "bytes") {
+
+        std::vector<unsigned char> byteArray;
+        // convert to little endian
+        for (char16_t ch : valueStringU16) {
+            unsigned char low_byte = static_cast<unsigned char>(ch & 0x00FF);
+            unsigned char high_byte = static_cast<unsigned char>((ch >> 8) & 0x00FF);
+
+            byteArray.push_back(low_byte);
+            byteArray.push_back(high_byte);
+        }
+        byteArray.push_back('\0');
+        byteArray.push_back('\0');
+        std::stringstream ss;
+
+        for (unsigned char ch : byteArray) {
+            ss << std::hex << std::setw(2) << std::setfill('0') << static_cast<int>(ch);
+        }
+        result = ss.str();
+    } else if (type == "bytes") {
        result = valueStr;
-    } else if (typeStr == "mask" || typeStr == "mask_jump32") {
+    } else if (type == "mask" || type == "mask_jump32") {
        result = valueStr;
    } else {
-        LOG_INFO(Loader, "Error applying Patch, unknown type: {}", typeStr);
+        LOG_INFO(Loader, "Error applying Patch, unknown type: {}", type);
    }
    return result;
 }

 void OnGameLoaded() {

+    if (!patchFile.empty()) {
+        std::filesystem::path patchDir = Common::FS::GetUserPath(Common::FS::PathType::PatchesDir);
+
+        auto filePath = (patchDir / patchFile).native();
+
+        pugi::xml_document doc;
+        pugi::xml_parse_result result = doc.load_file(filePath.c_str());
+
+        if (result) {
+            auto patchXML = doc.child("Patch");
+            for (pugi::xml_node_iterator it = patchXML.children().begin();
+                 it != patchXML.children().end(); ++it) {
+
+                if (std::string(it->name()) == "Metadata") {
+                    if (std::string(it->attribute("isEnabled").value()) == "true") {
+                        auto patchList = it->first_child();
+
+                        std::string currentPatchName = it->attribute("Name").value();
+
+                        for (pugi::xml_node_iterator patchLineIt = patchList.children().begin();
+                             patchLineIt != patchList.children().end(); ++patchLineIt) {
+
+                            std::string type = patchLineIt->attribute("Type").value();
+                            std::string address = patchLineIt->attribute("Address").value();
+                            std::string patchValue = patchLineIt->attribute("Value").value();
+                            std::string maskOffsetStr = patchLineIt->attribute("type").value();
+
+                            patchValue = convertValueToHex(type, patchValue);
+
+                            bool littleEndian = false;
+
+                            if (type == "bytes16") {
+                                littleEndian = true;
+                            } else if (type == "bytes32") {
+                                littleEndian = true;
+                            } else if (type == "bytes64") {
+                                littleEndian = true;
+                            }
+
+                            MemoryPatcher::PatchMask patchMask = MemoryPatcher::PatchMask::None;
+                            int maskOffsetValue = 0;
+
+                            if (type == "mask") {
+                                patchMask = MemoryPatcher::PatchMask::Mask;
+
+                                // im not sure if this works, there is no games to test the mask
+                                // offset on yet
+                                if (!maskOffsetStr.empty())
+                                    maskOffsetValue = std::stoi(maskOffsetStr, 0, 10);
+                            }
+
+                            if (type == "mask_jump32")
+                                patchMask = MemoryPatcher::PatchMask::Mask_Jump32;
+
+                            MemoryPatcher::PatchMemory(currentPatchName, address, patchValue, false,
+                                                       littleEndian, patchMask);
+                        }
+                    }
+                }
+            }
+        } else
+            LOG_ERROR(Loader, "couldnt patch parse xml : {}", result.description());
+
+        ApplyPendingPatches();
+        return;
+    }
+
+#ifdef ENABLE_QT_GUI
    // We use the QT headers for the xml and json parsing, this define is only true on QT builds
-    QString patchDir =
-        QString::fromStdString(Common::FS::GetUserPath(Common::FS::PathType::PatchesDir).string());
+    QString patchDir;
+    Common::FS::PathToQString(patchDir, Common::FS::GetUserPath(Common::FS::PathType::PatchesDir));
    QString repositories[] = {"GoldHEN", "shadPS4"};

    for (const QString& repository : repositories) {
@ -190,7 +287,8 @@ void OnGameLoaded() {
                            QString patchValue = lineObject["Value"].toString();
                            QString maskOffsetStr = lineObject["Offset"].toString();

-                            patchValue = convertValueToHex(type, patchValue);
+                            patchValue = QString::fromStdString(
+                                convertValueToHex(type.toStdString(), patchValue.toStdString()));

                            bool littleEndian = false;

@ -233,6 +331,7 @@ void OnGameLoaded() {
        }
        ApplyPendingPatches();
    }
+#endif
 }

 void AddPatchToQueue(patchInfo patchToAdd) {
--- a/src/common/memory_patcher.h
+++ b/src/common/memory_patcher.h
@ -5,13 +5,13 @@
 #include <cstring>
 #include <string>
 #include <vector>
-#include <QString>

 namespace MemoryPatcher {

 extern uintptr_t g_eboot_address;
-extern u64 g_eboot_image_size;
+extern uint64_t g_eboot_image_size;
 extern std::string g_game_serial;
+extern std::string patchFile;

 enum PatchMask : uint8_t {
    None,
@ -32,7 +32,7 @@ struct patchInfo {

 extern std::vector<patchInfo> pending_patches;

-QString convertValueToHex(const QString& type, const QString& valueStr);
+std::string convertValueToHex(const std::string type, const std::string valueStr);

 void OnGameLoaded();
 void AddPatchToQueue(patchInfo patchToAdd);
--- a/src/common/path_util.cpp
+++ b/src/common/path_util.cpp
@ -22,6 +22,10 @@
 #endif
 #endif

+#ifdef ENABLE_QT_GUI
+#include <QString>
+#endif
+
 namespace Common::FS {

 namespace fs = std::filesystem;
@ -106,7 +110,6 @@ static auto UserPaths = [] {
    create_path(PathType::LogDir, user_dir / LOG_DIR);
    create_path(PathType::ScreenshotsDir, user_dir / SCREENSHOTS_DIR);
    create_path(PathType::ShaderDir, user_dir / SHADER_DIR);
-    create_path(PathType::PM4Dir, user_dir / PM4_DIR);
    create_path(PathType::SaveDataDir, user_dir / SAVEDATA_DIR);
    create_path(PathType::GameDataDir, user_dir / GAMEDATA_DIR);
    create_path(PathType::TempDataDir, user_dir / TEMPDATA_DIR);
@ -115,7 +118,6 @@ static auto UserPaths = [] {
    create_path(PathType::CapturesDir, user_dir / CAPTURES_DIR);
    create_path(PathType::CheatsDir, user_dir / CHEATS_DIR);
    create_path(PathType::PatchesDir, user_dir / PATCHES_DIR);
-    create_path(PathType::AddonsDir, user_dir / ADDONS_DIR);
    create_path(PathType::MetaDataDir, user_dir / METADATA_DIR);

    return paths;
@ -165,4 +167,22 @@ void SetUserPath(PathType shad_path, const fs::path& new_path) {
    UserPaths.insert_or_assign(shad_path, new_path);
 }

+#ifdef ENABLE_QT_GUI
+void PathToQString(QString& result, const std::filesystem::path& path) {
+#ifdef _WIN32
+    result = QString::fromStdWString(path.wstring());
+#else
+    result = QString::fromStdString(path.string());
+#endif
+}
+
+std::filesystem::path PathFromQString(const QString& path) {
+#ifdef _WIN32
+    return std::filesystem::path(path.toStdWString());
+#else
+    return std::filesystem::path(path.toStdString());
+#endif
+}
+#endif
+
 } // namespace Common::FS
--- a/src/common/path_util.h
+++ b/src/common/path_util.h
@ -6,6 +6,10 @@
 #include <filesystem>
 #include <vector>

+#ifdef ENABLE_QT_GUI
+class QString; // to avoid including <QString> in this header
+#endif
+
 namespace Common::FS {

 enum class PathType {
@ -13,7 +17,6 @@ enum class PathType {
    LogDir,         // Where log files are stored.
    ScreenshotsDir, // Where screenshots are stored.
    ShaderDir,      // Where shaders are stored.
-    PM4Dir,         // Where command lists are stored.
    SaveDataDir,    // Where guest save data is stored.
    TempDataDir,    // Where game temp data is stored.
    GameDataDir,    // Where game data is stored.
@ -22,7 +25,6 @@ enum class PathType {
    CapturesDir,    // Where rdoc captures are stored.
    CheatsDir,      // Where cheats are stored.
    PatchesDir,     // Where patches are stored.
-    AddonsDir,      // Where additional content is stored.
    MetaDataDir,    // Where game metadata (e.g. trophies and menu backgrounds) is stored.
 };

@ -32,7 +34,6 @@ constexpr auto PORTABLE_DIR = "user";
 constexpr auto LOG_DIR = "log";
 constexpr auto SCREENSHOTS_DIR = "screenshots";
 constexpr auto SHADER_DIR = "shader";
-constexpr auto PM4_DIR = "pm4";
 constexpr auto SAVEDATA_DIR = "savedata";
 constexpr auto GAMEDATA_DIR = "data";
 constexpr auto TEMPDATA_DIR = "temp";
@ -41,7 +42,6 @@ constexpr auto DOWNLOAD_DIR = "download";
 constexpr auto CAPTURES_DIR = "captures";
 constexpr auto CHEATS_DIR = "cheats";
 constexpr auto PATCHES_DIR = "patches";
-constexpr auto ADDONS_DIR = "addcont";
 constexpr auto METADATA_DIR = "game_data";

 // Filenames
@ -96,4 +96,23 @@ constexpr auto LOG_FILE = "shad_log.txt";
 */
 void SetUserPath(PathType user_path, const std::filesystem::path& new_path);

+#ifdef ENABLE_QT_GUI
+/**
+ * Converts an std::filesystem::path to a QString.
+ * The native underlying string of a path is wstring on Windows and string on POSIX.
+ *
+ * @param result The resulting QString
+ * @param path The path to convert
+ */
+void PathToQString(QString& result, const std::filesystem::path& path);
+
+/**
+ * Converts a QString to an std::filesystem::path.
+ * The native underlying string of a path is wstring on Windows and string on POSIX.
+ *
+ * @param path The path to convert
+ */
+[[nodiscard]] std::filesystem::path PathFromQString(const QString& path);
+#endif
+
 } // namespace Common::FS
--- a/src/common/scm_rev.cpp.in
+++ b/src/common/scm_rev.cpp.in
@ -6,12 +6,14 @@
 #define GIT_REV      "@GIT_REV@"
 #define GIT_BRANCH   "@GIT_BRANCH@"
 #define GIT_DESC     "@GIT_DESC@"
+#define BUILD_DATE   "@BUILD_DATE@"

 namespace Common {

 const char g_scm_rev[]      = GIT_REV;
 const char g_scm_branch[]   = GIT_BRANCH;
 const char g_scm_desc[]     = GIT_DESC;
+const char g_scm_date[]     = BUILD_DATE;

 } // namespace

--- a/src/common/scm_rev.h
+++ b/src/common/scm_rev.h
@ -8,5 +8,6 @@ namespace Common {
 extern const char g_scm_rev[];
 extern const char g_scm_branch[];
 extern const char g_scm_desc[];
+extern const char g_scm_date[];

 } // namespace Common
--- a/src/common/signal_context.cpp
+++ b/src/common/signal_context.cpp
@ -0,0 +1,92 @@
+// SPDX-FileCopyrightText: Copyright 2024 shadPS4 Emulator Project
+// SPDX-License-Identifier: GPL-2.0-or-later
+
+#include "common/arch.h"
+#include "common/assert.h"
+#include "common/signal_context.h"
+
+#ifdef _WIN32
+#include <windows.h>
+#else
+#include <sys/ucontext.h>
+#endif
+
+namespace Common {
+
+void* GetXmmPointer(void* ctx, u8 index) {
+#if defined(_WIN32)
+#define CASE(index)                                                                                \
+    case index:                                                                                    \
+        return (void*)(&((EXCEPTION_POINTERS*)ctx)->ContextRecord->Xmm##index.Low)
+#elif defined(__APPLE__)
+#define CASE(index)                                                                                \
+    case index:                                                                                    \
+        return (void*)(&((ucontext_t*)ctx)->uc_mcontext->__fs.__fpu_xmm##index);
+#else
+#define CASE(index)                                                                                \
+    case index:                                                                                    \
+        return (void*)(&((ucontext_t*)ctx)->uc_mcontext.fpregs->_xmm[index].element[0])
+#endif
+    switch (index) {
+        CASE(0);
+        CASE(1);
+        CASE(2);
+        CASE(3);
+        CASE(4);
+        CASE(5);
+        CASE(6);
+        CASE(7);
+        CASE(8);
+        CASE(9);
+        CASE(10);
+        CASE(11);
+        CASE(12);
+        CASE(13);
+        CASE(14);
+        CASE(15);
+    default: {
+        UNREACHABLE_MSG("Invalid XMM register index: {}", index);
+        return nullptr;
+    }
+    }
+#undef CASE
+}
+
+void* GetRip(void* ctx) {
+#if defined(_WIN32)
+    return (void*)((EXCEPTION_POINTERS*)ctx)->ContextRecord->Rip;
+#elif defined(__APPLE__)
+    return (void*)((ucontext_t*)ctx)->uc_mcontext->__ss.__rip;
+#else
+    return (void*)((ucontext_t*)ctx)->uc_mcontext.gregs[REG_RIP];
+#endif
+}
+
+void IncrementRip(void* ctx, u64 length) {
+#if defined(_WIN32)
+    ((EXCEPTION_POINTERS*)ctx)->ContextRecord->Rip += length;
+#elif defined(__APPLE__)
+    ((ucontext_t*)ctx)->uc_mcontext->__ss.__rip += length;
+#else
+    ((ucontext_t*)ctx)->uc_mcontext.gregs[REG_RIP] += length;
+#endif
+}
+
+bool IsWriteError(void* ctx) {
+#if defined(_WIN32)
+    return ((EXCEPTION_POINTERS*)ctx)->ExceptionRecord->ExceptionInformation[0] == 1;
+#elif defined(__APPLE__)
+#if defined(ARCH_X86_64)
+    return ((ucontext_t*)ctx)->uc_mcontext->__es.__err & 0x2;
+#elif defined(ARCH_ARM64)
+    return ((ucontext_t*)ctx)->uc_mcontext->__es.__esr & 0x40;
+#endif
+#else
+#if defined(ARCH_X86_64)
+    return ((ucontext_t*)ctx)->uc_mcontext.gregs[REG_ERR] & 0x2;
+#else
+#error "Unsupported architecture"
+#endif
+#endif
+}
+} // namespace Common
--- a/src/common/signal_context.h
+++ b/src/common/signal_context.h
@ -0,0 +1,18 @@
+// SPDX-FileCopyrightText: Copyright 2024 shadPS4 Emulator Project
+// SPDX-License-Identifier: GPL-2.0-or-later
+
+#pragma once
+
+#include "common/types.h"
+
+namespace Common {
+
+void* GetXmmPointer(void* ctx, u8 index);
+
+void* GetRip(void* ctx);
+
+void IncrementRip(void* ctx, u64 length);
+
+bool IsWriteError(void* ctx);
+
+} // namespace Common
--- a/src/common/string_util.cpp
+++ b/src/common/string_util.cpp
@ -14,12 +14,17 @@

 namespace Common {

-std::string ToLower(std::string str) {
-    std::transform(str.begin(), str.end(), str.begin(),
-                   [](unsigned char c) { return static_cast<char>(std::tolower(c)); });
+std::string ToLower(std::string_view input) {
+    std::string str;
+    str.resize(input.size());
+    std::ranges::transform(input, str.begin(), tolower);
    return str;
 }

+void ToLowerInPlace(std::string& str) {
+    std::ranges::transform(str, str.begin(), tolower);
+}
+
 std::vector<std::string> SplitString(const std::string& str, char delimiter) {
    std::istringstream iss(str);
    std::vector<std::string> output(1);
--- a/src/common/string_util.h
+++ b/src/common/string_util.h
@ -10,7 +10,9 @@
 namespace Common {

 /// Make a string lowercase
-[[nodiscard]] std::string ToLower(std::string str);
+[[nodiscard]] std::string ToLower(std::string_view str);
+
+void ToLowerInPlace(std::string& str);

 std::vector<std::string> SplitString(const std::string& str, char delimiter);

--- a/src/common/thread.cpp
+++ b/src/common/thread.cpp
@ -3,12 +3,15 @@
 // SPDX-License-Identifier: GPL-2.0-or-later

 #include <string>
+#include <thread>

 #include "common/error.h"
 #include "common/logging/log.h"
 #include "common/thread.h"
+#include "ntapi.h"
 #ifdef __APPLE__
 #include <mach/mach.h>
+#include <mach/mach_time.h>
 #include <pthread.h>
 #elif defined(_WIN32)
 #include <windows.h>
@ -31,6 +34,48 @@

 namespace Common {

+#ifdef __APPLE__
+
+void SetCurrentThreadRealtime(const std::chrono::nanoseconds period_ns) {
+    // CPU time to grant.
+    const std::chrono::nanoseconds computation_ns = period_ns / 2;
+
+    // Determine the timebase for converting time to ticks.
+    struct mach_timebase_info timebase {};
+    mach_timebase_info(&timebase);
+    const auto ticks_per_ns =
+        static_cast<double>(timebase.denom) / static_cast<double>(timebase.numer);
+
+    const auto period_ticks =
+        static_cast<u32>(static_cast<double>(period_ns.count()) * ticks_per_ns);
+    const auto computation_ticks =
+        static_cast<u32>(static_cast<double>(computation_ns.count()) * ticks_per_ns);
+
+    thread_time_constraint_policy policy = {
+        .period = period_ticks,
+        .computation = computation_ticks,
+        // Should not matter since preemptible is false, but needs to be >= computation regardless.
+        .constraint = computation_ticks,
+        .preemptible = false,
+    };
+
+    int ret = thread_policy_set(
+        pthread_mach_thread_np(pthread_self()), THREAD_TIME_CONSTRAINT_POLICY,
+        reinterpret_cast<thread_policy_t>(&policy), THREAD_TIME_CONSTRAINT_POLICY_COUNT);
+    if (ret != KERN_SUCCESS) {
+        LOG_ERROR(Common, "Could not set thread to real-time with period {} ns: {}",
+                  period_ns.count(), ret);
+    }
+}
+
+#else
+
+void SetCurrentThreadRealtime(const std::chrono::nanoseconds period_ns) {
+    // Not implemented
+}
+
+#endif
+
 #ifdef _WIN32

 void SetCurrentThreadPriority(ThreadPriority new_priority) {
@ -59,6 +104,16 @@ void SetCurrentThreadPriority(ThreadPriority new_priority) {
    SetThreadPriority(handle, windows_priority);
 }

+static void AccurateSleep(std::chrono::nanoseconds duration) {
+    LARGE_INTEGER interval{
+        .QuadPart = -1 * (duration.count() / 100u),
+    };
+    HANDLE timer = ::CreateWaitableTimer(NULL, TRUE, NULL);
+    SetWaitableTimer(timer, &interval, 0, NULL, NULL, 0);
+    WaitForSingleObject(timer, INFINITE);
+    ::CloseHandle(timer);
+}
+
 #else

 void SetCurrentThreadPriority(ThreadPriority new_priority) {
@ -79,6 +134,10 @@ void SetCurrentThreadPriority(ThreadPriority new_priority) {
    pthread_setschedparam(this_thread, scheduling_type, &params);
 }

+static void AccurateSleep(std::chrono::nanoseconds duration) {
+    std::this_thread::sleep_for(duration);
+}
+
 #endif

 #ifdef _MSC_VER
@ -121,4 +180,22 @@ void SetCurrentThreadName(const char*) {

 #endif

+AccurateTimer::AccurateTimer(std::chrono::nanoseconds target_interval)
+    : target_interval(target_interval) {}
+
+void AccurateTimer::Start() {
+    auto begin_sleep = std::chrono::high_resolution_clock::now();
+    if (total_wait.count() > 0) {
+        AccurateSleep(total_wait);
+    }
+    start_time = std::chrono::high_resolution_clock::now();
+    total_wait -= std::chrono::duration_cast<std::chrono::nanoseconds>(start_time - begin_sleep);
+}
+
+void AccurateTimer::End() {
+    auto now = std::chrono::high_resolution_clock::now();
+    total_wait +=
+        target_interval - std::chrono::duration_cast<std::chrono::nanoseconds>(now - start_time);
+}
+
 } // namespace Common
--- a/src/common/thread.h
+++ b/src/common/thread.h
@ -4,6 +4,7 @@

 #pragma once

+#include <chrono>
 #include "common/types.h"

 namespace Common {
@ -16,8 +17,24 @@ enum class ThreadPriority : u32 {
    Critical = 4,
 };

+void SetCurrentThreadRealtime(std::chrono::nanoseconds period_ns);
+
 void SetCurrentThreadPriority(ThreadPriority new_priority);

 void SetCurrentThreadName(const char* name);

+class AccurateTimer {
+    std::chrono::nanoseconds target_interval{};
+    std::chrono::nanoseconds total_wait{};
+
+    std::chrono::high_resolution_clock::time_point start_time;
+
+public:
+    explicit AccurateTimer(std::chrono::nanoseconds target_interval);
+
+    void Start();
+
+    void End();
+};
+
 } // namespace Common
--- a/src/common/version.h
+++ b/src/common/version.h
@ -8,7 +8,7 @@

 namespace Common {

-constexpr char VERSION[] = "0.2.1 WIP";
+constexpr char VERSION[] = "0.3.1 WIP";
 constexpr bool isRelease = false;

 } // namespace Common
--- a/src/core/address_space.cpp
+++ b/src/core/address_space.cpp
@ -72,7 +72,8 @@ struct AddressSpace::Impl {
            }
            reduction += ReductionOnFail;
        }
-        ASSERT_MSG(virtual_base, "Unable to reserve virtual address space!");
+        ASSERT_MSG(virtual_base, "Unable to reserve virtual address space: {}",
+                   Common::GetLastErrorMsg());

        // Take the reduction off of the system managed area, and leave the others unchanged.
        system_managed_base = virtual_base;
--- a/src/core/cpu_patches.cpp
+++ b/src/core/cpu_patches.cpp
@ -1,12 +1,20 @@
 // SPDX-FileCopyrightText: Copyright 2024 shadPS4 Emulator Project
 // SPDX-License-Identifier: GPL-2.0-or-later

+#include <map>
 #include <memory>
 #include <mutex>
+#include <set>
 #include <Zydis/Zydis.h>
 #include <xbyak/xbyak.h>
+#include <xbyak/xbyak_util.h>
+#include "common/alignment.h"
+#include "common/arch.h"
 #include "common/assert.h"
+#include "common/decoder.h"
+#include "common/signal_context.h"
 #include "common/types.h"
+#include "core/signals.h"
 #include "core/tls.h"
 #include "cpu_patches.h"

@ -22,6 +30,16 @@

 using namespace Xbyak::util;

+#define MAYBE_AVX(OPCODE, ...)                                                                     \
+    [&] {                                                                                          \
+        Cpu cpu;                                                                                   \
+        if (cpu.has(Cpu::tAVX)) {                                                                  \
+            c.v##OPCODE(__VA_ARGS__);                                                              \
+        } else {                                                                                   \
+            c.OPCODE(__VA_ARGS__);                                                                 \
+        }                                                                                          \
+    }()
+
 namespace Core {

 static Xbyak::Reg ZydisToXbyakRegister(const ZydisRegister reg) {
@ -534,7 +552,7 @@ static bool FilterRosetta2Only(const ZydisDecodedOperand*) {
    return ret;
 }

-#endif // __APPLE__
+#else // __APPLE__

 static bool FilterTcbAccess(const ZydisDecodedOperand* operands) {
    const auto& dst_op = operands[0];
@ -580,6 +598,275 @@ static void GenerateTcbAccess(const ZydisDecodedOperand* operands, Xbyak::CodeGe
 #endif
 }

+#endif // __APPLE__
+
+static bool FilterNoSSE4a(const ZydisDecodedOperand*) {
+    Cpu cpu;
+    return !cpu.has(Cpu::tSSE4a);
+}
+
+static void GenerateEXTRQ(const ZydisDecodedOperand* operands, Xbyak::CodeGenerator& c) {
+    bool immediateForm = operands[1].type == ZYDIS_OPERAND_TYPE_IMMEDIATE &&
+                         operands[2].type == ZYDIS_OPERAND_TYPE_IMMEDIATE;
+
+    ASSERT_MSG(operands[0].type == ZYDIS_OPERAND_TYPE_REGISTER, "operand 0 must be a register");
+
+    const auto dst = ZydisToXbyakRegisterOperand(operands[0]);
+
+    ASSERT_MSG(dst.isXMM(), "operand 0 must be an XMM register");
+
+    Xbyak::Xmm xmm_dst = *reinterpret_cast<const Xbyak::Xmm*>(&dst);
+
+    if (immediateForm) {
+        u8 length = operands[1].imm.value.u & 0x3F;
+        u8 index = operands[2].imm.value.u & 0x3F;
+
+        LOG_DEBUG(Core, "Patching immediate form EXTRQ, length: {}, index: {}", length, index);
+
+        const Xbyak::Reg64 scratch1 = rax;
+        const Xbyak::Reg64 scratch2 = rcx;
+
+        // Set rsp to before red zone and save scratch registers
+        c.lea(rsp, ptr[rsp - 128]);
+        c.pushfq();
+        c.push(scratch1);
+        c.push(scratch2);
+
+        u64 mask;
+        if (length == 0) {
+            length = 64; // for the check below
+            mask = 0xFFFF'FFFF'FFFF'FFFF;
+        } else {
+            mask = (1ULL << length) - 1;
+        }
+
+        ASSERT_MSG(length + index <= 64, "length + index must be less than or equal to 64.");
+
+        // Get lower qword from xmm register
+        MAYBE_AVX(movq, scratch1, xmm_dst);
+
+        if (index != 0) {
+            c.shr(scratch1, index);
+        }
+
+        // We need to move mask to a register because we can't use all the possible
+        // immediate values with `and reg, imm32`
+        c.mov(scratch2, mask);
+        c.and_(scratch1, scratch2);
+
+        // Writeback to xmm register, extrq instruction says top 64-bits are undefined so we don't
+        // care to preserve them
+        MAYBE_AVX(movq, xmm_dst, scratch1);
+
+        c.pop(scratch2);
+        c.pop(scratch1);
+        c.popfq();
+        c.lea(rsp, ptr[rsp + 128]);
+    } else {
+        ASSERT_MSG(operands[0].type == ZYDIS_OPERAND_TYPE_REGISTER &&
+                       operands[1].type == ZYDIS_OPERAND_TYPE_REGISTER &&
+                       operands[0].reg.value >= ZYDIS_REGISTER_XMM0 &&
+                       operands[0].reg.value <= ZYDIS_REGISTER_XMM15 &&
+                       operands[1].reg.value >= ZYDIS_REGISTER_XMM0 &&
+                       operands[1].reg.value <= ZYDIS_REGISTER_XMM15,
+                   "Unexpected operand types for EXTRQ instruction");
+
+        const auto src = ZydisToXbyakRegisterOperand(operands[1]);
+
+        ASSERT_MSG(src.isXMM(), "operand 1 must be an XMM register");
+
+        Xbyak::Xmm xmm_src = *reinterpret_cast<const Xbyak::Xmm*>(&src);
+
+        const Xbyak::Reg64 scratch1 = rax;
+        const Xbyak::Reg64 scratch2 = rcx;
+        const Xbyak::Reg64 mask = rdx;
+
+        Xbyak::Label length_zero, end;
+
+        c.lea(rsp, ptr[rsp - 128]);
+        c.pushfq();
+        c.push(scratch1);
+        c.push(scratch2);
+        c.push(mask);
+
+        // Construct the mask out of the length that resides in bottom 6 bits of source xmm
+        MAYBE_AVX(movq, scratch1, xmm_src);
+        c.mov(scratch2, scratch1);
+        c.and_(scratch2, 0x3F);
+        c.jz(length_zero);
+
+        // mask = (1ULL << length) - 1
+        c.mov(mask, 1);
+        c.shl(mask, cl);
+        c.dec(mask);
+        c.jmp(end);
+
+        c.L(length_zero);
+        c.mov(mask, 0xFFFF'FFFF'FFFF'FFFF);
+
+        c.L(end);
+
+        // Get the shift amount and store it in scratch2
+        c.shr(scratch1, 8);
+        c.and_(scratch1, 0x3F);
+        c.mov(scratch2, scratch1); // cl now contains the shift amount
+
+        MAYBE_AVX(movq, scratch1, xmm_dst);
+        c.shr(scratch1, cl);
+        c.and_(scratch1, mask);
+        MAYBE_AVX(movq, xmm_dst, scratch1);
+
+        c.pop(mask);
+        c.pop(scratch2);
+        c.pop(scratch1);
+        c.popfq();
+        c.lea(rsp, ptr[rsp + 128]);
+    }
+}
+
+static void GenerateINSERTQ(const ZydisDecodedOperand* operands, Xbyak::CodeGenerator& c) {
+    bool immediateForm = operands[2].type == ZYDIS_OPERAND_TYPE_IMMEDIATE &&
+                         operands[3].type == ZYDIS_OPERAND_TYPE_IMMEDIATE;
+
+    ASSERT_MSG(operands[0].type == ZYDIS_OPERAND_TYPE_REGISTER &&
+                   operands[1].type == ZYDIS_OPERAND_TYPE_REGISTER,
+               "operands 0 and 1 must be registers.");
+
+    const auto dst = ZydisToXbyakRegisterOperand(operands[0]);
+    const auto src = ZydisToXbyakRegisterOperand(operands[1]);
+
+    ASSERT_MSG(dst.isXMM() && src.isXMM(), "operands 0 and 1 must be xmm registers.");
+
+    Xbyak::Xmm xmm_dst = *reinterpret_cast<const Xbyak::Xmm*>(&dst);
+    Xbyak::Xmm xmm_src = *reinterpret_cast<const Xbyak::Xmm*>(&src);
+
+    if (immediateForm) {
+        u8 length = operands[2].imm.value.u & 0x3F;
+        u8 index = operands[3].imm.value.u & 0x3F;
+
+        const Xbyak::Reg64 scratch1 = rax;
+        const Xbyak::Reg64 scratch2 = rcx;
+        const Xbyak::Reg64 mask = rdx;
+
+        // Set rsp to before red zone and save scratch registers
+        c.lea(rsp, ptr[rsp - 128]);
+        c.pushfq();
+        c.push(scratch1);
+        c.push(scratch2);
+        c.push(mask);
+
+        u64 mask_value;
+        if (length == 0) {
+            length = 64; // for the check below
+            mask_value = 0xFFFF'FFFF'FFFF'FFFF;
+        } else {
+            mask_value = (1ULL << length) - 1;
+        }
+
+        ASSERT_MSG(length + index <= 64, "length + index must be less than or equal to 64.");
+
+        MAYBE_AVX(movq, scratch1, xmm_src);
+        MAYBE_AVX(movq, scratch2, xmm_dst);
+        c.mov(mask, mask_value);
+
+        // src &= mask
+        c.and_(scratch1, mask);
+
+        // src <<= index
+        c.shl(scratch1, index);
+
+        // dst &= ~(mask << index)
+        mask_value = ~(mask_value << index);
+        c.mov(mask, mask_value);
+        c.and_(scratch2, mask);
+
+        // dst |= src
+        c.or_(scratch2, scratch1);
+
+        // Insert scratch2 into low 64 bits of dst, upper 64 bits are unaffected
+        Cpu cpu;
+        if (cpu.has(Cpu::tAVX)) {
+            c.vpinsrq(xmm_dst, xmm_dst, scratch2, 0);
+        } else {
+            c.pinsrq(xmm_dst, scratch2, 0);
+        }
+
+        c.pop(mask);
+        c.pop(scratch2);
+        c.pop(scratch1);
+        c.popfq();
+        c.lea(rsp, ptr[rsp + 128]);
+    } else {
+        ASSERT_MSG(operands[2].type == ZYDIS_OPERAND_TYPE_UNUSED &&
+                       operands[3].type == ZYDIS_OPERAND_TYPE_UNUSED,
+                   "operands 2 and 3 must be unused for register form.");
+
+        const Xbyak::Reg64 scratch1 = rax;
+        const Xbyak::Reg64 scratch2 = rcx;
+        const Xbyak::Reg64 index = rdx;
+        const Xbyak::Reg64 mask = rbx;
+
+        Xbyak::Label length_zero, end;
+
+        c.lea(rsp, ptr[rsp - 128]);
+        c.pushfq();
+        c.push(scratch1);
+        c.push(scratch2);
+        c.push(index);
+        c.push(mask);
+
+        // Get upper 64 bits of src and copy it to mask and index
+        MAYBE_AVX(pextrq, index, xmm_src, 1);
+        c.mov(mask, index);
+
+        // When length is 0, set it to 64
+        c.and_(mask, 0x3F); // mask now holds the length
+        c.jz(length_zero);  // Check if length is 0 and set mask to all 1s if it is
+
+        // Create a mask out of the length
+        c.mov(cl, mask.cvt8());
+        c.mov(mask, 1);
+        c.shl(mask, cl);
+        c.dec(mask);
+        c.jmp(end);
+
+        c.L(length_zero);
+        c.mov(mask, 0xFFFF'FFFF'FFFF'FFFF);
+
+        c.L(end);
+        // Get index to insert at
+        c.shr(index, 8);
+        c.and_(index, 0x3F);
+
+        // src &= mask
+        MAYBE_AVX(movq, scratch1, xmm_src);
+        c.and_(scratch1, mask);
+
+        // mask = ~(mask << index)
+        c.mov(cl, index.cvt8());
+        c.shl(mask, cl);
+        c.not_(mask);
+
+        // src <<= index
+        c.shl(scratch1, cl);
+
+        // dst = (dst & mask) | src
+        MAYBE_AVX(movq, scratch2, xmm_dst);
+        c.and_(scratch2, mask);
+        c.or_(scratch2, scratch1);
+
+        // Upper 64 bits are undefined in insertq
+        MAYBE_AVX(movq, xmm_dst, scratch2);
+
+        c.pop(mask);
+        c.pop(index);
+        c.pop(scratch2);
+        c.pop(scratch1);
+        c.popfq();
+        c.lea(rsp, ptr[rsp + 128]);
+    }
+}
+
 using PatchFilter = bool (*)(const ZydisDecodedOperand*);
 using InstructionGenerator = void (*)(const ZydisDecodedOperand*, Xbyak::CodeGenerator&);
 struct PatchInfo {
@ -601,6 +888,9 @@ static const std::unordered_map<ZydisMnemonic, PatchInfo> Patches = {
    {ZYDIS_MNEMONIC_MOV, {FilterTcbAccess, GenerateTcbAccess, false}},
 #endif

+    {ZYDIS_MNEMONIC_EXTRQ, {FilterNoSSE4a, GenerateEXTRQ, true}},
+    {ZYDIS_MNEMONIC_INSERTQ, {FilterNoSSE4a, GenerateINSERTQ, true}},
+
 #ifdef __APPLE__
    // Patches for instruction sets not supported by Rosetta 2.
    // BMI1
@ -615,64 +905,338 @@ static const std::unordered_map<ZydisMnemonic, PatchInfo> Patches = {
 #endif
 };

-void PatchInstructions(u64 segment_addr, u64 segment_size, Xbyak::CodeGenerator& c) {
-    if (Patches.empty()) {
-        // Nothing to patch on this platform.
+static std::once_flag init_flag;
+
+struct PatchModule {
+    /// Mutex controlling access to module code regions.
+    std::mutex mutex{};
+
+    /// Start of the module.
+    u8* start;
+
+    /// End of the module.
+    u8* end;
+
+    /// Tracker for patched code locations.
+    std::set<u8*> patched;
+
+    /// Code generator for patching the module.
+    Xbyak::CodeGenerator patch_gen;
+
+    /// Code generator for writing trampoline patches.
+    Xbyak::CodeGenerator trampoline_gen;
+
+    PatchModule(u8* module_ptr, const u64 module_size, u8* trampoline_ptr,
+                const u64 trampoline_size)
+        : start(module_ptr), end(module_ptr + module_size), patch_gen(module_size, module_ptr),
+          trampoline_gen(trampoline_size, trampoline_ptr) {}
+};
+static std::map<u64, PatchModule> modules;
+
+static PatchModule* GetModule(const void* ptr) {
+    auto upper_bound = modules.upper_bound(reinterpret_cast<u64>(ptr));
+    if (upper_bound == modules.begin()) {
+        return nullptr;
+    }
+    return &(std::prev(upper_bound)->second);
+}
+
+/// Returns a boolean indicating whether the instruction was patched, and the offset to advance past
+/// whatever is at the current code pointer.
+static std::pair<bool, u64> TryPatch(u8* code, PatchModule* module) {
+    ZydisDecodedInstruction instruction;
+    ZydisDecodedOperand operands[ZYDIS_MAX_OPERAND_COUNT];
+    const auto status = Common::Decoder::Instance()->decodeInstruction(instruction, operands, code,
+                                                                       module->end - code);
+    if (!ZYAN_SUCCESS(status)) {
+        return std::make_pair(false, 1);
+    }
+
+    if (Patches.contains(instruction.mnemonic)) {
+        const auto& patch_info = Patches.at(instruction.mnemonic);
+        bool needs_trampoline = patch_info.trampoline;
+        if (patch_info.filter(operands)) {
+            auto& patch_gen = module->patch_gen;
+
+            if (needs_trampoline && instruction.length < 5) {
+                // Trampoline is needed but instruction is too short to patch.
+                // Return false and length to fall back to the illegal instruction handler,
+                // or to signal to AOT compilation that this instruction should be skipped and
+                // handled at runtime.
+                return std::make_pair(false, instruction.length);
+            }
+
+            // Reset state and move to current code position.
+            patch_gen.reset();
+            patch_gen.setSize(code - patch_gen.getCode());
+
+            if (needs_trampoline) {
+                auto& trampoline_gen = module->trampoline_gen;
+                const auto trampoline_ptr = trampoline_gen.getCurr();
+
+                patch_info.generator(operands, trampoline_gen);
+
+                // Return to the following instruction at the end of the trampoline.
+                trampoline_gen.jmp(code + instruction.length);
+
+                // Replace instruction with near jump to the trampoline.
+                patch_gen.jmp(trampoline_ptr, Xbyak::CodeGenerator::LabelType::T_NEAR);
+            } else {
+                patch_info.generator(operands, patch_gen);
+            }
+
+            const auto patch_size = patch_gen.getCurr() - code;
+            if (patch_size > 0) {
+                ASSERT_MSG(instruction.length >= patch_size,
+                           "Instruction {} with length {} is too short to replace at: {}",
+                           ZydisMnemonicGetString(instruction.mnemonic), instruction.length,
+                           fmt::ptr(code));
+
+                // Fill remaining space with nops.
+                patch_gen.nop(instruction.length - patch_size);
+
+                module->patched.insert(code);
+                LOG_DEBUG(Core, "Patched instruction '{}' at: {}",
+                          ZydisMnemonicGetString(instruction.mnemonic), fmt::ptr(code));
+                return std::make_pair(true, instruction.length);
+            }
+        }
+    }
+
+    return std::make_pair(false, instruction.length);
+}
+
+#if defined(ARCH_X86_64)
+
+static bool TryExecuteIllegalInstruction(void* ctx, void* code_address) {
+    ZydisDecodedInstruction instruction;
+    ZydisDecodedOperand operands[ZYDIS_MAX_OPERAND_COUNT];
+    const auto status =
+        Common::Decoder::Instance()->decodeInstruction(instruction, operands, code_address);
+
+    switch (instruction.mnemonic) {
+    case ZYDIS_MNEMONIC_EXTRQ: {
+        bool immediateForm = operands[1].type == ZYDIS_OPERAND_TYPE_IMMEDIATE &&
+                             operands[2].type == ZYDIS_OPERAND_TYPE_IMMEDIATE;
+        if (immediateForm) {
+            LOG_CRITICAL(Core, "EXTRQ immediate form should have been patched at code address: {}",
+                         fmt::ptr(code_address));
+            return false;
+        } else {
+            ASSERT_MSG(operands[0].type == ZYDIS_OPERAND_TYPE_REGISTER &&
+                           operands[1].type == ZYDIS_OPERAND_TYPE_REGISTER &&
+                           operands[0].reg.value >= ZYDIS_REGISTER_XMM0 &&
+                           operands[0].reg.value <= ZYDIS_REGISTER_XMM15 &&
+                           operands[1].reg.value >= ZYDIS_REGISTER_XMM0 &&
+                           operands[1].reg.value <= ZYDIS_REGISTER_XMM15,
+                       "Unexpected operand types for EXTRQ instruction");
+
+            const auto dstIndex = operands[0].reg.value - ZYDIS_REGISTER_XMM0;
+            const auto srcIndex = operands[1].reg.value - ZYDIS_REGISTER_XMM0;
+
+            const auto dst = Common::GetXmmPointer(ctx, dstIndex);
+            const auto src = Common::GetXmmPointer(ctx, srcIndex);
+
+            u64 lowQWordSrc;
+            memcpy(&lowQWordSrc, src, sizeof(lowQWordSrc));
+
+            u64 lowQWordDst;
+            memcpy(&lowQWordDst, dst, sizeof(lowQWordDst));
+
+            u64 length = lowQWordSrc & 0x3F;
+            u64 mask;
+            if (length == 0) {
+                length = 64; // for the check below
+                mask = 0xFFFF'FFFF'FFFF'FFFF;
+            } else {
+                mask = (1ULL << length) - 1;
+            }
+
+            u64 index = (lowQWordSrc >> 8) & 0x3F;
+            if (length + index > 64) {
+                // Undefined behavior if length + index is bigger than 64 according to the spec,
+                // we'll warn and continue execution.
+                LOG_WARNING(Core,
+                            "extrq at {} with length {} and index {} is bigger than 64, "
+                            "undefined behavior",
+                            fmt::ptr(code_address), length, index);
+            }
+
+            lowQWordDst >>= index;
+            lowQWordDst &= mask;
+
+            memcpy(dst, &lowQWordDst, sizeof(lowQWordDst));
+
+            Common::IncrementRip(ctx, instruction.length);
+
+            return true;
+        }
+        break;
+    }
+    case ZYDIS_MNEMONIC_INSERTQ: {
+        bool immediateForm = operands[2].type == ZYDIS_OPERAND_TYPE_IMMEDIATE &&
+                             operands[3].type == ZYDIS_OPERAND_TYPE_IMMEDIATE;
+        if (immediateForm) {
+            LOG_CRITICAL(Core,
+                         "INSERTQ immediate form should have been patched at code address: {}",
+                         fmt::ptr(code_address));
+            return false;
+        } else {
+            ASSERT_MSG(operands[2].type == ZYDIS_OPERAND_TYPE_UNUSED &&
+                           operands[3].type == ZYDIS_OPERAND_TYPE_UNUSED,
+                       "operands 2 and 3 must be unused for register form.");
+
+            ASSERT_MSG(operands[0].type == ZYDIS_OPERAND_TYPE_REGISTER &&
+                           operands[1].type == ZYDIS_OPERAND_TYPE_REGISTER,
+                       "operands 0 and 1 must be registers.");
+
+            const auto dstIndex = operands[0].reg.value - ZYDIS_REGISTER_XMM0;
+            const auto srcIndex = operands[1].reg.value - ZYDIS_REGISTER_XMM0;
+
+            const auto dst = Common::GetXmmPointer(ctx, dstIndex);
+            const auto src = Common::GetXmmPointer(ctx, srcIndex);
+
+            u64 lowQWordSrc, highQWordSrc;
+            memcpy(&lowQWordSrc, src, sizeof(lowQWordSrc));
+            memcpy(&highQWordSrc, (u8*)src + 8, sizeof(highQWordSrc));
+
+            u64 lowQWordDst;
+            memcpy(&lowQWordDst, dst, sizeof(lowQWordDst));
+
+            u64 length = highQWordSrc & 0x3F;
+            u64 mask;
+            if (length == 0) {
+                length = 64; // for the check below
+                mask = 0xFFFF'FFFF'FFFF'FFFF;
+            } else {
+                mask = (1ULL << length) - 1;
+            }
+
+            u64 index = (highQWordSrc >> 8) & 0x3F;
+            if (length + index > 64) {
+                // Undefined behavior if length + index is bigger than 64 according to the spec,
+                // we'll warn and continue execution.
+                LOG_WARNING(Core,
+                            "insertq at {} with length {} and index {} is bigger than 64, "
+                            "undefined behavior",
+                            fmt::ptr(code_address), length, index);
+            }
+
+            lowQWordSrc &= mask;
+            lowQWordDst &= ~(mask << index);
+            lowQWordDst |= lowQWordSrc << index;
+
+            memcpy(dst, &lowQWordDst, sizeof(lowQWordDst));
+
+            Common::IncrementRip(ctx, instruction.length);
+
+            return true;
+        }
+        break;
+    }
+    default: {
+        LOG_ERROR(Core, "Unhandled illegal instruction at code address {}: {}",
+                  fmt::ptr(code_address), ZydisMnemonicGetString(instruction.mnemonic));
+        return false;
+    }
+    }
+
+    UNREACHABLE();
+}
+#elif defined(ARCH_ARM64)
+// These functions shouldn't be needed for ARM as it will use a JIT so there's no need to patch
+// instructions.
+static bool TryExecuteIllegalInstruction(void*, void*) {
+    return false;
+}
+#else
+#error "Unsupported architecture"
+#endif
+
+static bool TryPatchJit(void* code_address) {
+    auto* code = static_cast<u8*>(code_address);
+    auto* module = GetModule(code);
+    if (module == nullptr) {
+        return false;
+    }
+
+    std::unique_lock lock{module->mutex};
+
+    // Return early if already patched, in case multiple threads signaled at the same time.
+    if (std::ranges::find(module->patched, code) != module->patched.end()) {
+        return true;
+    }
+
+    return TryPatch(code, module).first;
+}
+
+static void TryPatchAot(void* code_address, u64 code_size) {
+    auto* code = static_cast<u8*>(code_address);
+    auto* module = GetModule(code);
+    if (module == nullptr) {
        return;
    }

-    ZydisDecoder instr_decoder;
-    ZydisDecodedInstruction instruction;
-    ZydisDecodedOperand operands[ZYDIS_MAX_OPERAND_COUNT];
-    ZydisDecoderInit(&instr_decoder, ZYDIS_MACHINE_MODE_LONG_64, ZYDIS_STACK_WIDTH_64);
+    std::unique_lock lock{module->mutex};

-    u8* code = reinterpret_cast<u8*>(segment_addr);
-    u8* end = code + segment_size;
+    const auto* end = code + code_size;
    while (code < end) {
-        ZyanStatus status =
-            ZydisDecoderDecodeFull(&instr_decoder, code, end - code, &instruction, operands);
-        if (!ZYAN_SUCCESS(status)) {
-            code++;
-            continue;
-        }
-
-        if (Patches.contains(instruction.mnemonic)) {
-            auto patch_info = Patches.at(instruction.mnemonic);
-            if (patch_info.filter(operands)) {
-                auto patch_gen = Xbyak::CodeGenerator(instruction.length, code);
-
-                if (patch_info.trampoline) {
-                    const auto trampoline_ptr = c.getCurr();
-
-                    patch_info.generator(operands, c);
-
-                    // Return to the following instruction at the end of the trampoline.
-                    c.jmp(code + instruction.length);
-
-                    // Replace instruction with near jump to the trampoline.
-                    patch_gen.jmp(trampoline_ptr, Xbyak::CodeGenerator::LabelType::T_NEAR);
-                } else {
-                    patch_info.generator(operands, patch_gen);
-                }
-
-                const auto patch_size = patch_gen.getCurr() - code;
-                if (patch_size > 0) {
-                    ASSERT_MSG(instruction.length >= patch_size,
-                               "Instruction {} with length {} is too short to replace at: {}",
-                               ZydisMnemonicGetString(instruction.mnemonic), instruction.length,
-                               fmt::ptr(code));
-
-                    // Fill remaining space with nops.
-                    patch_gen.nop(instruction.length - patch_size);
-
-                    LOG_DEBUG(Core, "Patched instruction '{}' at: {}",
-                              ZydisMnemonicGetString(instruction.mnemonic), fmt::ptr(code));
-                }
-            }
-        }
-
-        code += instruction.length;
+        code += TryPatch(code, module).second;
    }
 }

+static bool PatchesAccessViolationHandler(void* context, void* /* fault_address */) {
+    return TryPatchJit(Common::GetRip(context));
+}
+
+static bool PatchesIllegalInstructionHandler(void* context) {
+    void* code_address = Common::GetRip(context);
+    if (!TryPatchJit(code_address)) {
+        return TryExecuteIllegalInstruction(context, code_address);
+    }
+    return true;
+}
+
+static void PatchesInit() {
+    if (!Patches.empty()) {
+        auto* signals = Signals::Instance();
+        // Should be called last.
+        constexpr auto priority = std::numeric_limits<u32>::max();
+        signals->RegisterAccessViolationHandler(PatchesAccessViolationHandler, priority);
+        signals->RegisterIllegalInstructionHandler(PatchesIllegalInstructionHandler, priority);
+    }
+}
+
+void RegisterPatchModule(void* module_ptr, u64 module_size, void* trampoline_area_ptr,
+                         u64 trampoline_area_size) {
+    std::call_once(init_flag, PatchesInit);
+
+    const auto module_addr = reinterpret_cast<u64>(module_ptr);
+    modules.emplace(std::piecewise_construct, std::forward_as_tuple(module_addr),
+                    std::forward_as_tuple(static_cast<u8*>(module_ptr), module_size,
+                                          static_cast<u8*>(trampoline_area_ptr),
+                                          trampoline_area_size));
+}
+
+void PrePatchInstructions(u64 segment_addr, u64 segment_size) {
+#if defined(__APPLE__)
+    // HACK: For some reason patching in the signal handler at the start of a page does not work
+    // under Rosetta 2. Patch any instructions at the start of a page ahead of time.
+    if (!Patches.empty()) {
+        auto* code_page = reinterpret_cast<u8*>(Common::AlignUp(segment_addr, 0x1000));
+        const auto* end_page = code_page + Common::AlignUp(segment_size, 0x1000);
+        while (code_page < end_page) {
+            TryPatchJit(code_page);
+            code_page += 0x1000;
+        }
+    }
+#elif !defined(_WIN32)
+    // Linux and others have an FS segment pointing to valid memory, so continue to do full
+    // ahead-of-time patching for now until a better solution is worked out.
+    if (!Patches.empty()) {
+        TryPatchAot(reinterpret_cast<void*>(segment_addr), segment_size);
+    }
+#endif
+}
+
 } // namespace Core
--- a/src/core/cpu_patches.h
+++ b/src/core/cpu_patches.h
@ -3,10 +3,6 @@

 #pragma once

-namespace Xbyak {
-class CodeGenerator;
-}
-
 namespace Core {

 /// Initializes a stack for the current thread for use by patch implementations.
@ -15,7 +11,11 @@ void InitializeThreadPatchStack();
 /// Cleans up the patch stack for the current thread.
 void CleanupThreadPatchStack();

-/// Patches CPU instructions that cannot run as-is on the host.
-void PatchInstructions(u64 segment_addr, u64 segment_size, Xbyak::CodeGenerator& c);
+/// Registers a module for patching, providing an area to generate trampoline code.
+void RegisterPatchModule(void* module_ptr, u64 module_size, void* trampoline_area_ptr,
+                         u64 trampoline_area_size);
+
+/// Applies CPU patches that need to be done before beginning executions.
+void PrePatchInstructions(u64 segment_addr, u64 segment_size);

 } // namespace Core
--- a/src/core/debug_state.cpp
+++ b/src/core/debug_state.cpp
@ -0,0 +1,102 @@
+// SPDX-FileCopyrightText: Copyright 2024 shadPS4 Emulator Project
+// SPDX-License-Identifier: GPL-2.0-or-later
+
+#include "common/assert.h"
+#include "common/native_clock.h"
+#include "common/singleton.h"
+#include "debug_state.h"
+#include "libraries/kernel/event_queues.h"
+#include "libraries/kernel/time_management.h"
+#include "libraries/system/msgdialog.h"
+
+using namespace DebugStateType;
+
+DebugStateImpl& DebugState = *Common::Singleton<DebugStateImpl>::Instance();
+
+static ThreadID ThisThreadID() {
+#ifdef _WIN32
+    return GetCurrentThreadId();
+#else
+    return pthread_self();
+#endif
+}
+
+static void PauseThread(ThreadID id) {
+#ifdef _WIN32
+    auto handle = OpenThread(THREAD_SUSPEND_RESUME, FALSE, id);
+    SuspendThread(handle);
+    CloseHandle(handle);
+#else
+    pthread_kill(id, SIGUSR1);
+#endif
+}
+
+static void ResumeThread(ThreadID id) {
+#ifdef _WIN32
+    auto handle = OpenThread(THREAD_SUSPEND_RESUME, FALSE, id);
+    ResumeThread(handle);
+    CloseHandle(handle);
+#else
+    pthread_kill(id, SIGUSR1);
+#endif
+}
+
+void DebugStateImpl::AddCurrentThreadToGuestList() {
+    std::lock_guard lock{guest_threads_mutex};
+    const ThreadID id = ThisThreadID();
+    guest_threads.push_back(id);
+}
+
+void DebugStateImpl::RemoveCurrentThreadFromGuestList() {
+    std::lock_guard lock{guest_threads_mutex};
+    const ThreadID id = ThisThreadID();
+    std::erase_if(guest_threads, [&](const ThreadID& v) { return v == id; });
+}
+
+void DebugStateImpl::PauseGuestThreads() {
+    using namespace Libraries::MsgDialog;
+    std::unique_lock lock{guest_threads_mutex};
+    if (is_guest_threads_paused) {
+        return;
+    }
+    if (ShouldPauseInSubmit()) {
+        waiting_submit_pause = false;
+        should_show_frame_dump = true;
+    }
+    bool self_guest = false;
+    ThreadID self_id = ThisThreadID();
+    for (const auto& id : guest_threads) {
+        if (id == self_id) {
+            self_guest = true;
+        } else {
+            PauseThread(id);
+        }
+    }
+    pause_time = Libraries::Kernel::Dev::GetClock()->GetUptime();
+    is_guest_threads_paused = true;
+    lock.unlock();
+    if (self_guest) {
+        PauseThread(self_id);
+    }
+}
+
+void DebugStateImpl::ResumeGuestThreads() {
+    std::lock_guard lock{guest_threads_mutex};
+    if (!is_guest_threads_paused) {
+        return;
+    }
+
+    u64 delta_time = Libraries::Kernel::Dev::GetClock()->GetUptime() - pause_time;
+    Libraries::Kernel::Dev::GetInitialPtc() += delta_time;
+    for (const auto& id : guest_threads) {
+        ResumeThread(id);
+    }
+    is_guest_threads_paused = false;
+}
+
+void DebugStateImpl::RequestFrameDump(s32 count) {
+    gnm_frame_dump_request_count = count;
+    frame_dump_list.clear();
+    frame_dump_list.resize(count);
+    waiting_submit_pause = true;
+}
--- a/src/core/debug_state.h
+++ b/src/core/debug_state.h
@ -0,0 +1,126 @@
+// SPDX-FileCopyrightText: Copyright 2024 shadPS4 Emulator Project
+// SPDX-License-Identifier: GPL-2.0-or-later
+
+#pragma once
+
+#include <atomic>
+#include <mutex>
+#include <vector>
+#include <queue>
+
+#include "common/types.h"
+
+#ifdef _WIN32
+#ifndef WIN32_LEAN_AND_MEAN
+#define WIN32_LEAN_AND_MEAN 1
+#endif
+#include <Windows.h>
+using ThreadID = DWORD;
+#else
+#include <pthread.h>
+#include <signal.h>
+using ThreadID = pthread_t;
+#endif
+
+namespace Core::Devtools {
+class Layer;
+namespace Widget {
+class FrameGraph;
+}
+} // namespace Core::Devtools
+
+namespace DebugStateType {
+
+enum class QueueType {
+    acb,
+    dcb,
+    ccb,
+};
+
+struct QueueDump {
+    QueueType type;
+    u32 submit_num;
+    u32 num2; // acb: queue_num; else: buffer_in_submit
+    std::vector<u32> data;
+};
+
+struct FrameDump {
+    std::vector<QueueDump> queues;
+};
+
+class DebugStateImpl {
+    friend class Core::Devtools::Layer;
+    friend class Core::Devtools::Widget::FrameGraph;
+
+    std::mutex guest_threads_mutex{};
+    std::vector<ThreadID> guest_threads{};
+    std::atomic_bool is_guest_threads_paused = false;
+    u64 pause_time{};
+
+    std::atomic_int32_t flip_frame_count = 0;
+    std::atomic_int32_t gnm_frame_count = 0;
+
+    s32 gnm_frame_dump_request_count = -1;
+    bool waiting_submit_pause = false;
+    bool should_show_frame_dump = false;
+
+    std::mutex frame_dump_list_mutex;
+    std::vector<FrameDump> frame_dump_list{};
+
+    std::queue<std::string> debug_message_popup;
+
+public:
+    void AddCurrentThreadToGuestList();
+
+    void RemoveCurrentThreadFromGuestList();
+
+    void PauseGuestThreads();
+
+    void ResumeGuestThreads();
+
+    bool IsGuestThreadsPaused() const {
+        return is_guest_threads_paused;
+    }
+
+    void IncFlipFrameNum() {
+        ++flip_frame_count;
+    }
+
+    void IncGnmFrameNum() {
+        ++gnm_frame_count;
+        --gnm_frame_dump_request_count;
+    }
+
+    u32 GetFrameNum() const {
+        return flip_frame_count;
+    }
+
+    bool DumpingCurrentFrame() const {
+        return gnm_frame_dump_request_count > 0;
+    }
+
+    bool ShouldPauseInSubmit() const {
+        return waiting_submit_pause && gnm_frame_dump_request_count == 0;
+    }
+
+    void RequestFrameDump(s32 count = 1);
+
+    FrameDump& GetFrameDump() {
+        return frame_dump_list[frame_dump_list.size() - gnm_frame_dump_request_count];
+    }
+
+    void PushQueueDump(QueueDump dump) {
+        std::unique_lock lock{frame_dump_list_mutex};
+        GetFrameDump().queues.push_back(std::move(dump));
+    }
+
+    void ShowDebugMessage(std::string message) {
+        if (message.empty()) {
+            return;
+        }
+        debug_message_popup.push(std::move(message));
+    }
+};
+} // namespace DebugStateType
+
+extern DebugStateType::DebugStateImpl& DebugState;
--- a/src/core/devtools/gcn/gcn_context_regs.cpp
+++ b/src/core/devtools/gcn/gcn_context_regs.cpp
@ -0,0 +1,297 @@
+//  SPDX-FileCopyrightText: Copyright 2024 shadPS4 Emulator Project
+//  SPDX-License-Identifier: GPL-2.0-or-later
+
+// Credits to https://github.com/psucien/tlg-emu-tools/
+
+#include "common/types.h"
+#include "gcn/si_ci_vi_merged_offset.h"
+
+using namespace Pal::Gfx6;
+
+namespace Core::Devtools::Gcn {
+const char* GetContextRegName(u32 reg_offset) {
+    switch (reg_offset) {
+    case mmDB_SHADER_CONTROL:
+        return "mmDB_SHADER_CONTROL";
+    case mmCB_SHADER_MASK:
+        return "mmCB_SHADER_MASK";
+    case mmPA_CL_CLIP_CNTL:
+        return "mmPA_CL_CLIP_CNTL";
+    case mmVGT_INSTANCE_STEP_RATE_0:
+        return "mmVGT_INSTANCE_STEP_RATE_0";
+    case mmVGT_INSTANCE_STEP_RATE_1:
+        return "mmVGT_INSTANCE_STEP_RATE_1";
+    case mmVGT_INDX_OFFSET:
+        return "mmVGT_INDX_OFFSET";
+    case mmVGT_SHADER_STAGES_EN:
+        return "mmVGT_SHADER_STAGES_EN";
+    case mmVGT_GS_MODE:
+        return "mmVGT_GS_MODE";
+    case mmVGT_STRMOUT_CONFIG:
+        return "mmVGT_STRMOUT_CONFIG";
+    case mmVGT_OUT_DEALLOC_CNTL:
+        return "mmVGT_OUT_DEALLOC_CNTL";
+    case mmVGT_VTX_CNT_EN:
+        return "mmVGT_VTX_CNT_EN";
+    case mmVGT_MAX_VTX_INDX:
+        return "mmVGT_MAX_VTX_INDX";
+    case mmVGT_MULTI_PRIM_IB_RESET_INDX:
+        return "mmVGT_MULTI_PRIM_IB_RESET_INDX";
+    case mmVGT_OUTPUT_PATH_CNTL:
+        return "mmVGT_OUTPUT_PATH_CNTL";
+    case mmVGT_GS_PER_ES:
+        return "mmVGT_GS_PER_ES";
+    case mmVGT_ES_PER_GS:
+        return "mmVGT_ES_PER_GS";
+    case mmVGT_GS_PER_VS:
+        return "mmVGT_GS_PER_VS";
+    case mmCB_COLOR0_BASE:
+        return "mmCB_COLOR0_BASE";
+    case mmCB_COLOR0_INFO:
+        return "mmCB_COLOR0_INFO";
+    case mmCB_COLOR0_CMASK_SLICE:
+        return "mmCB_COLOR0_CMASK_SLICE";
+    case mmCB_COLOR0_CLEAR_WORD0:
+        return "mmCB_COLOR0_CLEAR_WORD0";
+    case mmCB_COLOR0_CLEAR_WORD1:
+        return "mmCB_COLOR0_CLEAR_WORD1";
+    case mmCB_COLOR0_PITCH:
+        return "mmCB_COLOR0_PITCH";
+    case mmCB_COLOR0_SLICE:
+        return "mmCB_COLOR0_SLICE";
+    case mmCB_COLOR0_VIEW:
+        return "mmCB_COLOR0_VIEW";
+    case mmCB_COLOR0_DCC_CONTROL__VI:
+        return "mmCB_COLOR0_DCC_CONTROL";
+    case mmCB_COLOR0_CMASK:
+        return "mmCB_COLOR0_CMASK";
+    case mmCB_COLOR0_FMASK_SLICE:
+        return "mmCB_COLOR0_FMASK_SLICE";
+    case mmCB_COLOR0_FMASK:
+        return "mmCB_COLOR0_FMASK";
+    case mmCB_COLOR0_DCC_BASE__VI:
+        return "mmCB_COLOR0_DCC_BASE";
+    case mmCB_COLOR0_ATTRIB:
+        return "mmCB_COLOR0_ATTRIB";
+    case mmCB_COLOR1_BASE:
+        return "mmCB_COLOR1_BASE";
+    case mmCB_COLOR1_INFO:
+        return "mmCB_COLOR1_INFO";
+    case mmCB_COLOR1_ATTRIB:
+        return "mmCB_COLOR1_ATTRIB";
+    case mmCB_COLOR1_CMASK_SLICE:
+        return "mmCB_COLOR1_CMASK_SLICE";
+    case mmCB_COLOR1_CLEAR_WORD0:
+        return "mmCB_COLOR1_CLEAR_WORD0";
+    case mmCB_COLOR1_CLEAR_WORD1:
+        return "mmCB_COLOR1_CLEAR_WORD1";
+    case mmCB_COLOR1_PITCH:
+        return "mmCB_COLOR1_PITCH";
+    case mmCB_COLOR1_VIEW:
+        return "mmCB_COLOR1_VIEW";
+    case mmCB_COLOR2_INFO:
+        return "mmCB_COLOR2_INFO";
+    case mmCB_COLOR2_ATTRIB:
+        return "mmCB_COLOR2_ATTRIB";
+    case mmCB_COLOR2_CMASK_SLICE:
+        return "mmCB_COLOR2_CMASK_SLICE";
+    case mmCB_COLOR2_CLEAR_WORD0:
+        return "mmCB_COLOR2_CLEAR_WORD0";
+    case mmCB_COLOR2_CLEAR_WORD1:
+        return "mmCB_COLOR2_CLEAR_WORD1";
+    case mmCB_COLOR2_PITCH:
+        return "mmCB_COLOR2_PITCH";
+    case mmCB_COLOR2_VIEW:
+        return "mmCB_COLOR2_VIEW";
+    case mmCB_COLOR3_INFO:
+        return "mmCB_COLOR3_INFO";
+    case mmCB_COLOR3_CMASK_SLICE:
+        return "mmCB_COLOR3_CMASK_SLICE";
+    case mmCB_COLOR4_INFO:
+        return "mmCB_COLOR4_INFO";
+    case mmCB_COLOR5_INFO:
+        return "mmCB_COLOR5_INFO";
+    case mmCB_COLOR6_INFO:
+        return "mmCB_COLOR6_INFO";
+    case mmCB_COLOR7_INFO:
+        return "mmCB_COLOR7_INFO";
+    case mmDB_SRESULTS_COMPARE_STATE0:
+        return "mmDB_SRESULTS_COMPARE_STATE0";
+    case mmDB_SRESULTS_COMPARE_STATE1:
+        return "mmDB_SRESULTS_COMPARE_STATE1";
+    case mmDB_DEPTH_CONTROL:
+        return "mmDB_DEPTH_CONTROL";
+    case mmDB_EQAA:
+        return "mmDB_EQAA";
+    case mmPA_SU_POINT_SIZE:
+        return "mmPA_SU_POINT_SIZE";
+    case mmPA_SU_POINT_MINMAX:
+        return "mmPA_SU_POINT_MINMAX";
+    case mmPA_SU_SC_MODE_CNTL:
+        return "mmPA_SU_SC_MODE_CNTL";
+    case mmPA_SU_POLY_OFFSET_DB_FMT_CNTL:
+        return "mmPA_SU_POLY_OFFSET_DB_FMT_CNTL";
+    case mmPA_SC_CLIPRECT_RULE:
+        return "mmPA_SC_CLIPRECT_RULE";
+    case mmPA_SC_MODE_CNTL_0:
+        return "mmPA_SC_MODE_CNTL_0";
+    case mmPA_SC_MODE_CNTL_1:
+        return "mmPA_SC_MODE_CNTL_1";
+    case mmPA_SC_AA_SAMPLE_LOCS_PIXEL_X0Y0_0:
+        return "mmPA_SC_AA_SAMPLE_LOCS_PIXEL_X0Y0_0";
+    case mmPA_SC_AA_SAMPLE_LOCS_PIXEL_X0Y1_0:
+        return "mmPA_SC_AA_SAMPLE_LOCS_PIXEL_X0Y1_0";
+    case mmPA_SC_AA_SAMPLE_LOCS_PIXEL_X1Y0_0:
+        return "mmPA_SC_AA_SAMPLE_LOCS_PIXEL_X1Y0_0";
+    case mmPA_SC_AA_MASK_X0Y0_X1Y0:
+        return "mmPA_SC_AA_MASK_X0Y0_X1Y0";
+    case mmPA_SC_AA_MASK_X0Y1_X1Y1:
+        return "mmPA_SC_AA_MASK_X0Y1_X1Y1";
+    case mmPA_SC_CENTROID_PRIORITY_0:
+        return "mmPA_SC_CENTROID_PRIORITY_0";
+    case mmPA_SC_CENTROID_PRIORITY_1:
+        return "mmPA_SC_CENTROID_PRIORITY_1";
+    case mmPA_SC_AA_CONFIG:
+        return "mmPA_SC_AA_CONFIG";
+    case mmDB_RENDER_CONTROL:
+        return "mmDB_RENDER_CONTROL";
+    case mmDB_STENCIL_CONTROL:
+        return "mmDB_STENCIL_CONTROL";
+    case mmDB_STENCILREFMASK:
+        return "mmDB_STENCILREFMASK";
+    case mmDB_STENCILREFMASK_BF:
+        return "mmDB_STENCILREFMASK_BF";
+    case mmDB_STENCIL_CLEAR:
+        return "mmDB_STENCIL_CLEAR";
+    case mmDB_DEPTH_CLEAR:
+        return "mmDB_DEPTH_CLEAR";
+    case mmCB_TARGET_MASK:
+        return "mmCB_TARGET_MASK";
+    case mmDB_Z_INFO:
+        return "mmDB_Z_INFO";
+    case mmDB_STENCIL_INFO:
+        return "mmDB_STENCIL_INFO";
+    case mmDB_Z_READ_BASE:
+        return "mmDB_Z_READ_BASE";
+    case mmDB_STENCIL_READ_BASE:
+        return "mmDB_STENCIL_READ_BASE";
+    case mmDB_Z_WRITE_BASE:
+        return "mmDB_Z_WRITE_BASE";
+    case mmDB_STENCIL_WRITE_BASE:
+        return "mmDB_STENCIL_WRITE_BASE";
+    case mmDB_DEPTH_INFO:
+        return "mmDB_DEPTH_INFO";
+    case mmDB_DEPTH_VIEW:
+        return "mmDB_DEPTH_VIEW";
+    case mmDB_DEPTH_SLICE:
+        return "mmDB_DEPTH_SLICE";
+    case mmDB_DEPTH_SIZE:
+        return "mmDB_DEPTH_SIZE";
+    case mmTA_BC_BASE_ADDR:
+        return "mmTA_BC_BASE_ADDR";
+    case mmCB_BLEND_RED:
+        return "mmCB_BLEND_RED";
+    case mmCB_BLEND_GREEN:
+        return "mmCB_BLEND_GREEN";
+    case mmCB_BLEND_BLUE:
+        return "mmCB_BLEND_BLUE";
+    case mmDB_ALPHA_TO_MASK:
+        return "mmDB_ALPHA_TO_MASK";
+    case mmCB_BLEND0_CONTROL:
+        return "mmCB_BLEND0_CONTROL";
+    case mmCB_BLEND1_CONTROL:
+        return "mmCB_BLEND1_CONTROL";
+    case mmCB_BLEND2_CONTROL:
+        return "mmCB_BLEND2_CONTROL";
+    case mmCB_BLEND3_CONTROL:
+        return "mmCB_BLEND3_CONTROL";
+    case mmCB_BLEND4_CONTROL:
+        return "mmCB_BLEND4_CONTROL";
+    case mmCB_BLEND5_CONTROL:
+        return "mmCB_BLEND5_CONTROL";
+    case mmCB_BLEND6_CONTROL:
+        return "mmCB_BLEND6_CONTROL";
+    case mmCB_BLEND7_CONTROL:
+        return "mmCB_BLEND7_CONTROL";
+    case mmDB_HTILE_DATA_BASE:
+        return "mmDB_HTILE_DATA_BASE";
+    case mmDB_HTILE_SURFACE:
+        return "mmDB_HTILE_SURFACE";
+    case mmPA_SU_LINE_CNTL:
+        return "mmPA_SU_LINE_CNTL";
+    case mmPA_SC_VPORT_ZMIN_0:
+        return "mmPA_SC_VPORT_ZMIN_0";
+    case mmPA_SC_VPORT_ZMAX_0:
+        return "mmPA_SC_VPORT_ZMAX_0";
+    case mmPA_SC_VPORT_SCISSOR_0_TL:
+        return "mmPA_SC_VPORT_SCISSOR_0_TL";
+    case mmPA_SC_VPORT_SCISSOR_0_BR:
+        return "mmPA_SC_VPORT_SCISSOR_0_BR";
+    case mmPA_SC_GENERIC_SCISSOR_TL:
+        return "mmPA_SC_GENERIC_SCISSOR_TL";
+    case mmPA_SC_GENERIC_SCISSOR_BR:
+        return "mmPA_SC_GENERIC_SCISSOR_BR";
+    case mmPA_CL_VPORT_XSCALE:
+        return "mmPA_CL_VPORT_XSCALE";
+    case mmPA_CL_VPORT_YSCALE:
+        return "mmPA_CL_VPORT_YSCALE";
+    case mmPA_CL_VPORT_ZSCALE:
+        return "mmPA_CL_VPORT_ZSCALE";
+    case mmPA_CL_VPORT_XOFFSET:
+        return "mmPA_CL_VPORT_XOFFSET";
+    case mmPA_CL_VPORT_YOFFSET:
+        return "mmPA_CL_VPORT_YOFFSET";
+    case mmPA_CL_VPORT_ZOFFSET:
+        return "mmPA_CL_VPORT_ZOFFSET";
+    case mmPA_CL_VTE_CNTL:
+        return "mmPA_CL_VTE_CNTL";
+    case mmPA_SC_SCREEN_SCISSOR_TL:
+        return "mmPA_SC_SCREEN_SCISSOR_TL";
+    case mmPA_SC_SCREEN_SCISSOR_BR:
+        return "mmPA_SC_SCREEN_SCISSOR_BR";
+    case mmPA_SU_HARDWARE_SCREEN_OFFSET:
+        return "mmPA_SU_HARDWARE_SCREEN_OFFSET";
+    case mmPA_SU_VTX_CNTL:
+        return "mmPA_SU_VTX_CNTL";
+    case mmPA_CL_GB_VERT_CLIP_ADJ:
+        return "mmPA_CL_GB_VERT_CLIP_ADJ";
+    case mmPA_CL_GB_HORZ_CLIP_ADJ:
+        return "mmPA_CL_GB_HORZ_CLIP_ADJ";
+    case mmPA_CL_GB_VERT_DISC_ADJ:
+        return "mmPA_CL_GB_VERT_DISC_ADJ";
+    case mmPA_CL_GB_HORZ_DISC_ADJ:
+        return "mmPA_CL_GB_HORZ_DISC_ADJ";
+    case mmCB_COLOR_CONTROL:
+        return "mmCB_COLOR_CONTROL";
+    case mmSPI_SHADER_Z_FORMAT:
+        return "mmSPI_SHADER_Z_FORMAT";
+    case mmSPI_SHADER_COL_FORMAT:
+        return "mmSPI_SHADER_COL_FORMAT";
+    case mmPA_CL_VS_OUT_CNTL:
+        return "mmPA_CL_VS_OUT_CNTL";
+    case mmSPI_VS_OUT_CONFIG:
+        return "mmSPI_VS_OUT_CONFIG";
+    case mmSPI_SHADER_POS_FORMAT:
+        return "mmSPI_SHADER_POS_FORMAT";
+    case mmSPI_PS_INPUT_ENA:
+        return "mmSPI_PS_INPUT_ENA";
+    case mmSPI_PS_INPUT_ADDR:
+        return "mmSPI_PS_INPUT_ADDR";
+    case mmSPI_PS_IN_CONTROL:
+        return "mmSPI_PS_IN_CONTROL";
+    case mmSPI_BARYC_CNTL:
+        return "mmSPI_BARYC_CNTL";
+    case mmSPI_PS_INPUT_CNTL_0:
+        return "mmSPI_PS_INPUT_CNTL_0";
+    case mmSPI_PS_INPUT_CNTL_1:
+        return "mmSPI_PS_INPUT_CNTL_1";
+    case mmSPI_PS_INPUT_CNTL_2:
+        return "mmSPI_PS_INPUT_CNTL_2";
+    case mmSPI_PS_INPUT_CNTL_3:
+        return "mmSPI_PS_INPUT_CNTL_3";
+    default:
+        break;
+    }
+    return "<UNK>";
+}
+} // namespace Core::Devtools::Gcn
--- a/src/core/devtools/gcn/gcn_op_names.cpp
+++ b/src/core/devtools/gcn/gcn_op_names.cpp
@ -0,0 +1,118 @@
+//  SPDX-FileCopyrightText: Copyright 2024 shadPS4 Emulator Project
+//  SPDX-License-Identifier: GPL-2.0-or-later
+
+// Credits to https://github.com/psucien/tlg-emu-tools/
+
+#include "common/types.h"
+#include "gcn/si_ci_vi_merged_pm4_it_opcodes.h"
+
+namespace Core::Devtools::Gcn {
+const char* GetOpCodeName(u32 op) {
+    switch (op) {
+    case IT_NOP:
+        return "IT_NOP";
+    case IT_SET_BASE:
+        return "IT_SET_BASE";
+    case IT_INDEX_BUFFER_SIZE:
+        return "IT_INDEX_BUFFER_SIZE";
+    case IT_SET_PREDICATION:
+        return "IT_SET_PREDICATION";
+    case IT_COND_EXEC:
+        return "IT_COND_EXEC";
+    case IT_INDEX_BASE:
+        return "IT_INDEX_BASE";
+    case IT_INDEX_TYPE:
+        return "IT_INDEX_TYPE";
+    case IT_NUM_INSTANCES:
+        return "IT_NUM_INSTANCES";
+    case IT_STRMOUT_BUFFER_UPDATE:
+        return "IT_STRMOUT_BUFFER_UPDATE";
+    case IT_WRITE_DATA:
+        return "IT_WRITE_DATA";
+    case IT_MEM_SEMAPHORE:
+        return "IT_MEM_SEMAPHORE";
+    case IT_WAIT_REG_MEM:
+        return "IT_WAIT_REG_MEM";
+    case IT_INDIRECT_BUFFER:
+        return "IT_INDIRECT_BUFFER";
+    case IT_PFP_SYNC_ME:
+        return "IT_PFP_SYNC_ME";
+    case IT_EVENT_WRITE:
+        return "IT_EVENT_WRITE";
+    case IT_EVENT_WRITE_EOP:
+        return "IT_EVENT_WRITE_EOP";
+    case IT_EVENT_WRITE_EOS:
+        return "IT_EVENT_WRITE_EOS";
+    case IT_DMA_DATA__CI__VI:
+        return "IT_DMA_DATA";
+    case IT_ACQUIRE_MEM__CI__VI:
+        return "IT_ACQUIRE_MEM";
+    case IT_REWIND__CI__VI:
+        return "IT_REWIND";
+    case IT_SET_CONFIG_REG:
+        return "IT_SET_CONFIG_REG";
+    case IT_SET_CONTEXT_REG:
+        return "IT_SET_CONTEXT_REG";
+    case IT_SET_SH_REG:
+        return "IT_SET_SH_REG";
+    case IT_SET_UCONFIG_REG__CI__VI:
+        return "IT_SET_UCONFIG_REG";
+    case IT_INCREMENT_DE_COUNTER:
+        return "IT_INCREMENT_DE_COUNTER";
+    case IT_WAIT_ON_CE_COUNTER:
+        return "IT_WAIT_ON_CE_COUNTER";
+    case IT_DISPATCH_DIRECT:
+        return "IT_DISPATCH_DIRECT";
+    case IT_DISPATCH_INDIRECT:
+        return "IT_DISPATCH_INDIRECT";
+    case IT_OCCLUSION_QUERY:
+        return "IT_OCCLUSION_QUERY";
+    case IT_REG_RMW:
+        return "IT_REG_RMW";
+    case IT_PRED_EXEC:
+        return "IT_PRED_EXEC";
+    case IT_DRAW_INDIRECT:
+        return "IT_DRAW_INDIRECT";
+    case IT_DRAW_INDEX_INDIRECT:
+        return "IT_DRAW_INDEX_INDIRECT";
+    case IT_DRAW_INDEX_2:
+        return "IT_DRAW_INDEX_2";
+    case IT_DRAW_INDEX_OFFSET_2:
+        return "IT_DRAW_INDEX_OFFSET_2";
+    case IT_CONTEXT_CONTROL:
+        return "IT_CONTEXT_CONTROL";
+    case IT_DRAW_INDIRECT_MULTI:
+        return "IT_DRAW_INDIRECT_MULTI";
+    case IT_DRAW_INDEX_AUTO:
+        return "IT_DRAW_INDEX_AUTO";
+    case IT_DRAW_INDEX_MULTI_AUTO:
+        return "IT_DRAW_INDEX_MULTI_AUTO";
+    case IT_COPY_DATA:
+        return "IT_COPY_DATA";
+    case IT_CP_DMA:
+        return "IT_CP_DMA";
+    case IT_SURFACE_SYNC:
+        return "IT_SURFACE_SYNC";
+    case IT_COND_WRITE:
+        return "IT_COND_WRITE";
+    case IT_RELEASE_MEM__CI__VI:
+        return "IT_RELEASE_MEM";
+    case IT_WRITE_CONST_RAM:
+        return "IT_WRITE_CONST_RAM"; // used in CCB
+    case IT_WAIT_ON_DE_COUNTER_DIFF:
+        return "IT_WAIT_ON_DE_COUNTER_DIFF"; // used in CCB
+    case IT_DUMP_CONST_RAM:
+        return "IT_DUMP_CONST_RAM"; // used in CCB
+    case IT_INCREMENT_CE_COUNTER:
+        return "IT_INCREMENT_CE_COUNTER"; // used in CCB
+    case IT_CLEAR_STATE:
+        return "IT_CLEAR_STATE";
+    case 0xFF:
+        return "<STUB (TMP)>";
+    default:
+        break;
+    }
+
+    return "<UNK>";
+}
+} // namespace Core::Devtools::Gcn
--- a/src/core/devtools/gcn/gcn_shader_regs.cpp
+++ b/src/core/devtools/gcn/gcn_shader_regs.cpp
@ -0,0 +1,171 @@
+//  SPDX-FileCopyrightText: Copyright 2024 shadPS4 Emulator Project
+//  SPDX-License-Identifier: GPL-2.0-or-later
+
+// Credits to https://github.com/psucien/tlg-emu-tools/
+
+#include "common/types.h"
+#include "gcn/si_ci_vi_merged_offset.h"
+
+using namespace Pal::Gfx6;
+
+namespace Core::Devtools::Gcn {
+const char* GetShaderRegName(u32 reg_offset) {
+    switch (reg_offset) {
+    case mmSPI_SHADER_PGM_LO_VS:
+        return "mmSPI_SHADER_PGM_LO_VS";
+    case mmSPI_SHADER_PGM_HI_VS:
+        return "mmSPI_SHADER_PGM_HI_VS";
+    case mmSPI_SHADER_PGM_LO_PS:
+        return "mmSPI_SHADER_PGM_LO_PS";
+    case mmSPI_SHADER_PGM_HI_PS:
+        return "mmSPI_SHADER_PGM_HI_PS";
+    case mmSPI_SHADER_PGM_RSRC1_VS:
+        return "mmSPI_SHADER_PGM_RSRC1_VS";
+    case mmSPI_SHADER_PGM_RSRC2_VS:
+        return "mmSPI_SHADER_PGM_RSRC2_VS";
+    case mmSPI_SHADER_PGM_RSRC3_VS__CI__VI:
+        return "mmSPI_SHADER_PGM_RSRC3_VS__CI__VI";
+    case mmSPI_SHADER_PGM_RSRC1_PS:
+        return "mmSPI_SHADER_PGM_RSRC1_PS";
+    case mmSPI_SHADER_PGM_RSRC2_PS:
+        return "mmSPI_SHADER_PGM_RSRC2_PS";
+    case mmSPI_SHADER_PGM_RSRC3_PS__CI__VI:
+        return "mmSPI_SHADER_PGM_RSRC3_PS__CI__VI";
+    case mmSPI_SHADER_USER_DATA_PS_0:
+        return "mmSPI_SHADER_USER_DATA_PS_0";
+    case mmSPI_SHADER_USER_DATA_PS_1:
+        return "mmSPI_SHADER_USER_DATA_PS_1";
+    case mmSPI_SHADER_USER_DATA_PS_2:
+        return "mmSPI_SHADER_USER_DATA_PS_2";
+    case mmSPI_SHADER_USER_DATA_PS_3:
+        return "mmSPI_SHADER_USER_DATA_PS_3";
+    case mmSPI_SHADER_USER_DATA_PS_4:
+        return "mmSPI_SHADER_USER_DATA_PS_4";
+    case mmSPI_SHADER_USER_DATA_PS_5:
+        return "mmSPI_SHADER_USER_DATA_PS_5";
+    case mmSPI_SHADER_USER_DATA_PS_6:
+        return "mmSPI_SHADER_USER_DATA_PS_6";
+    case mmSPI_SHADER_USER_DATA_PS_7:
+        return "mmSPI_SHADER_USER_DATA_PS_7";
+    case mmSPI_SHADER_USER_DATA_PS_8:
+        return "mmSPI_SHADER_USER_DATA_PS_8";
+    case mmSPI_SHADER_USER_DATA_PS_9:
+        return "mmSPI_SHADER_USER_DATA_PS_9";
+    case mmSPI_SHADER_USER_DATA_PS_10:
+        return "mmSPI_SHADER_USER_DATA_PS_10";
+    case mmSPI_SHADER_USER_DATA_PS_11:
+        return "mmSPI_SHADER_USER_DATA_PS_11";
+    case mmSPI_SHADER_USER_DATA_PS_12:
+        return "mmSPI_SHADER_USER_DATA_PS_12";
+    case mmSPI_SHADER_USER_DATA_PS_13:
+        return "mmSPI_SHADER_USER_DATA_PS_13";
+    case mmSPI_SHADER_USER_DATA_PS_14:
+        return "mmSPI_SHADER_USER_DATA_PS_14";
+    case mmSPI_SHADER_USER_DATA_PS_15:
+        return "mmSPI_SHADER_USER_DATA_PS_15";
+    case mmCOMPUTE_TMPRING_SIZE:
+        return "mmCOMPUTE_TMPRING_SIZE";
+    case mmCOMPUTE_PGM_LO:
+        return "mmCOMPUTE_PGM_LO";
+    case mmCOMPUTE_PGM_HI:
+        return "mmCOMPUTE_PGM_HI";
+    case mmCOMPUTE_PGM_RSRC1:
+        return "mmCOMPUTE_PGM_RSRC1";
+    case mmCOMPUTE_PGM_RSRC2:
+        return "mmCOMPUTE_PGM_RSRC2";
+    case mmCOMPUTE_USER_DATA_0:
+        return "mmCOMPUTE_USER_DATA_0";
+    case mmCOMPUTE_USER_DATA_1:
+        return "mmCOMPUTE_USER_DATA_1";
+    case mmCOMPUTE_USER_DATA_2:
+        return "mmCOMPUTE_USER_DATA_2";
+    case mmCOMPUTE_USER_DATA_3:
+        return "mmCOMPUTE_USER_DATA_3";
+    case mmCOMPUTE_USER_DATA_4:
+        return "mmCOMPUTE_USER_DATA_4";
+    case mmCOMPUTE_USER_DATA_5:
+        return "mmCOMPUTE_USER_DATA_5";
+    case mmCOMPUTE_USER_DATA_6:
+        return "mmCOMPUTE_USER_DATA_6";
+    case mmCOMPUTE_USER_DATA_7:
+        return "mmCOMPUTE_USER_DATA_7";
+    case mmCOMPUTE_USER_DATA_8:
+        return "mmCOMPUTE_USER_DATA_8";
+    case mmCOMPUTE_USER_DATA_9:
+        return "mmCOMPUTE_USER_DATA_9";
+    case mmCOMPUTE_USER_DATA_10:
+        return "mmCOMPUTE_USER_DATA_10";
+    case mmCOMPUTE_USER_DATA_11:
+        return "mmCOMPUTE_USER_DATA_11";
+    case mmCOMPUTE_USER_DATA_12:
+        return "mmCOMPUTE_USER_DATA_12";
+    case mmCOMPUTE_USER_DATA_13:
+        return "mmCOMPUTE_USER_DATA_13";
+    case mmCOMPUTE_USER_DATA_14:
+        return "mmCOMPUTE_USER_DATA_14";
+    case mmCOMPUTE_USER_DATA_15:
+        return "mmCOMPUTE_USER_DATA_15";
+    case mmCOMPUTE_NUM_THREAD_X:
+        return "mmCOMPUTE_NUM_THREAD_X";
+    case mmCOMPUTE_NUM_THREAD_Y:
+        return "mmCOMPUTE_NUM_THREAD_Y";
+    case mmCOMPUTE_NUM_THREAD_Z:
+        return "mmCOMPUTE_NUM_THREAD_Z";
+    case mmCOMPUTE_STATIC_THREAD_MGMT_SE0:
+        return "mmCOMPUTE_STATIC_THREAD_MGMT_SE0";
+    case mmCOMPUTE_STATIC_THREAD_MGMT_SE1:
+        return "mmCOMPUTE_STATIC_THREAD_MGMT_SE1";
+    case mmCOMPUTE_RESOURCE_LIMITS:
+        return "mmCOMPUTE_RESOURCE_LIMITS";
+    case mmSPI_SHADER_USER_DATA_VS_0:
+        return "mmSPI_SHADER_USER_DATA_VS_0";
+    case mmSPI_SHADER_USER_DATA_VS_1:
+        return "mmSPI_SHADER_USER_DATA_VS_1";
+    case mmSPI_SHADER_USER_DATA_VS_2:
+        return "mmSPI_SHADER_USER_DATA_VS_2";
+    case mmSPI_SHADER_USER_DATA_VS_3:
+        return "mmSPI_SHADER_USER_DATA_VS_3";
+    case mmSPI_SHADER_USER_DATA_VS_4:
+        return "mmSPI_SHADER_USER_DATA_VS_4";
+    case mmSPI_SHADER_USER_DATA_VS_5:
+        return "mmSPI_SHADER_USER_DATA_VS_5";
+    case mmSPI_SHADER_USER_DATA_VS_6:
+        return "mmSPI_SHADER_USER_DATA_VS_6";
+    case mmSPI_SHADER_USER_DATA_VS_7:
+        return "mmSPI_SHADER_USER_DATA_VS_7";
+    case mmSPI_SHADER_USER_DATA_VS_8:
+        return "mmSPI_SHADER_USER_DATA_VS_8";
+    case mmSPI_SHADER_USER_DATA_VS_9:
+        return "mmSPI_SHADER_USER_DATA_VS_9";
+    case mmSPI_SHADER_USER_DATA_VS_10:
+        return "mmSPI_SHADER_USER_DATA_VS_10";
+    case mmSPI_SHADER_USER_DATA_VS_11:
+        return "mmSPI_SHADER_USER_DATA_VS_11";
+    case mmSPI_SHADER_USER_DATA_VS_12:
+        return "mmSPI_SHADER_USER_DATA_VS_12";
+    case mmSPI_SHADER_USER_DATA_VS_13:
+        return "mmSPI_SHADER_USER_DATA_VS_13";
+    case mmSPI_SHADER_USER_DATA_VS_14:
+        return "mmSPI_SHADER_USER_DATA_VS_14";
+    case mmSPI_SHADER_USER_DATA_VS_15:
+        return "mmSPI_SHADER_USER_DATA_VS_15";
+    case mmSPI_SHADER_USER_DATA_HS_0:
+        return "mmSPI_SHADER_USER_DATA_HS_0";
+    case mmSPI_SHADER_USER_DATA_HS_1:
+        return "mmSPI_SHADER_USER_DATA_HS_1";
+    case mmSPI_SHADER_USER_DATA_HS_9:
+        return "mmSPI_SHADER_USER_DATA_HS_9";
+    case mmSPI_SHADER_PGM_RSRC3_GS__CI__VI:
+        return "mmSPI_SHADER_PGM_RSRC3_GS__CI__VI";
+    case mmSPI_SHADER_PGM_RSRC3_ES__CI__VI:
+        return "mmSPI_SHADER_PGM_RSRC3_ES__CI__VI";
+    case mmSPI_SHADER_PGM_RSRC3_LS__CI__VI:
+        return "mmSPI_SHADER_PGM_RSRC3_LS__CI__VI";
+    case mmSPI_SHADER_LATE_ALLOC_VS__CI__VI:
+        return "mmSPI_SHADER_LATE_ALLOC_VS__CI__VI";
+    default:
+        break;
+    }
+    return "<UNK>";
+}
+} // namespace Core::Devtools::Gcn
--- a/src/core/devtools/layer.cpp
+++ b/src/core/devtools/layer.cpp
@ -0,0 +1,231 @@
+// SPDX-FileCopyrightText: Copyright 2024 shadPS4 Emulator Project
+// SPDX-License-Identifier: GPL-2.0-or-later
+
+#include <imgui.h>
+
+#include "common/config.h"
+#include "common/singleton.h"
+#include "common/types.h"
+#include "core/debug_state.h"
+#include "imgui/imgui_std.h"
+#include "imgui_internal.h"
+#include "layer.h"
+#include "widget/frame_dump.h"
+#include "widget/frame_graph.h"
+
+using namespace ImGui;
+using namespace Core::Devtools;
+using L = Core::Devtools::Layer;
+
+static bool show_simple_fps = false;
+static float fps_scale = 1.0f;
+
+static bool show_advanced_debug = false;
+
+static int dump_frame_count = 1;
+
+static Widget::FrameGraph frame_graph;
+static std::vector<Widget::FrameDumpViewer> frame_viewers;
+
+static float debug_popup_timing = 3.0f;
+
+void L::DrawMenuBar() {
+    const auto& ctx = *GImGui;
+    const auto& io = ctx.IO;
+
+    auto isSystemPaused = DebugState.IsGuestThreadsPaused();
+
+    if (BeginMainMenuBar()) {
+        if (BeginMenu("Options")) {
+            if (MenuItemEx("Emulator Paused", nullptr, nullptr, isSystemPaused)) {
+                if (isSystemPaused) {
+                    DebugState.ResumeGuestThreads();
+                } else {
+                    DebugState.PauseGuestThreads();
+                }
+            }
+            ImGui::EndMenu();
+        }
+        if (BeginMenu("GPU Tools")) {
+            MenuItem("Show frame info", nullptr, &frame_graph.is_open);
+            if (BeginMenu("Dump frames")) {
+                SliderInt("Count", &dump_frame_count, 1, 5);
+                if (MenuItem("Dump", "Ctrl+Alt+F9", nullptr, !DebugState.DumpingCurrentFrame())) {
+                    DebugState.RequestFrameDump(dump_frame_count);
+                }
+                ImGui::EndMenu();
+            }
+            ImGui::EndMenu();
+        }
+        EndMainMenuBar();
+    }
+
+    if (IsKeyPressed(ImGuiKey_F9, false)) {
+        if (io.KeyCtrl && io.KeyAlt) {
+            if (!DebugState.ShouldPauseInSubmit()) {
+                DebugState.RequestFrameDump(dump_frame_count);
+            }
+        }
+        if (!io.KeyCtrl && !io.KeyAlt) {
+            if (isSystemPaused) {
+                DebugState.ResumeGuestThreads();
+            } else {
+                DebugState.PauseGuestThreads();
+            }
+        }
+    }
+}
+
+void L::DrawAdvanced() {
+    DrawMenuBar();
+
+    const auto& ctx = *GImGui;
+    const auto& io = ctx.IO;
+
+    auto isSystemPaused = DebugState.IsGuestThreadsPaused();
+
+    frame_graph.Draw();
+
+    if (isSystemPaused) {
+        GetForegroundDrawList(GetMainViewport())
+            ->AddText({10.0f, io.DisplaySize.y - 40.0f}, IM_COL32_WHITE, "Emulator paused");
+    }
+
+    if (DebugState.should_show_frame_dump) {
+        DebugState.should_show_frame_dump = false;
+        std::unique_lock lock{DebugState.frame_dump_list_mutex};
+        while (!DebugState.frame_dump_list.empty()) {
+            auto frame_dump = std::move(DebugState.frame_dump_list.back());
+            DebugState.frame_dump_list.pop_back();
+            frame_viewers.emplace_back(frame_dump);
+        }
+    }
+
+    for (auto it = frame_viewers.begin(); it != frame_viewers.end();) {
+        if (it->is_open) {
+            it->Draw();
+            ++it;
+        } else {
+            it = frame_viewers.erase(it);
+        }
+    }
+
+    if (!DebugState.debug_message_popup.empty()) {
+        if (debug_popup_timing > 0.0f) {
+            debug_popup_timing -= io.DeltaTime;
+            if (Begin("##devtools_msg", nullptr,
+                      ImGuiWindowFlags_NoDecoration | ImGuiWindowFlags_NoSavedSettings |
+                          ImGuiWindowFlags_NoInputs | ImGuiWindowFlags_NoMove)) {
+                BringWindowToDisplayFront(GetCurrentWindow());
+                const auto display_size = io.DisplaySize;
+                const auto& msg = DebugState.debug_message_popup.front();
+                const auto padding = GetStyle().WindowPadding;
+                const auto txt_size = CalcTextSize(&msg.front(), &msg.back() + 1, false, 250.0f);
+                SetWindowPos({display_size.x - padding.x * 2.0f - txt_size.x, 50.0f});
+                SetWindowSize({txt_size.x + padding.x * 2.0f, txt_size.y + padding.y * 2.0f});
+                PushTextWrapPos(250.0f);
+                TextEx(&msg.front(), &msg.back() + 1);
+                PopTextWrapPos();
+            }
+            End();
+        } else {
+            DebugState.debug_message_popup.pop();
+            debug_popup_timing = 3.0f;
+        }
+    }
+}
+
+void L::DrawSimple() {
+    const auto io = GetIO();
+    Text("Frame time: %.3f ms (%.1f FPS)", 1000.0f / io.Framerate, io.Framerate);
+}
+
+void L::SetupSettings() {
+    frame_graph.is_open = true;
+
+    ImGuiSettingsHandler handler{};
+    handler.TypeName = "DevtoolsLayer";
+    handler.TypeHash = ImHashStr(handler.TypeName);
+    handler.ReadOpenFn = [](ImGuiContext*, ImGuiSettingsHandler*, const char* name) {
+        return std::string_view("Data") == name ? (void*)1 : nullptr;
+    };
+    handler.ReadLineFn = [](ImGuiContext*, ImGuiSettingsHandler*, void*, const char* line) {
+        int v;
+        float f;
+        if (sscanf(line, "fps_scale=%f", &f) == 1) {
+            fps_scale = f;
+        } else if (sscanf(line, "show_advanced_debug=%d", &v) == 1) {
+            show_advanced_debug = v != 0;
+        } else if (sscanf(line, "show_frame_graph=%d", &v) == 1) {
+            frame_graph.is_open = v != 0;
+        } else if (sscanf(line, "dump_frame_count=%d", &v) == 1) {
+            dump_frame_count = v;
+        }
+    };
+    handler.WriteAllFn = [](ImGuiContext*, ImGuiSettingsHandler* handler, ImGuiTextBuffer* buf) {
+        buf->appendf("[%s][Data]\n", handler->TypeName);
+        buf->appendf("fps_scale=%f\n", fps_scale);
+        buf->appendf("show_advanced_debug=%d\n", show_advanced_debug);
+        buf->appendf("show_frame_graph=%d\n", frame_graph.is_open);
+        buf->appendf("dump_frame_count=%d\n", dump_frame_count);
+        buf->append("\n");
+    };
+    AddSettingsHandler(&handler);
+
+    const ImGuiID dock_id = ImHashStr("FrameDumpDock");
+    DockBuilderAddNode(dock_id, 0);
+    DockBuilderSetNodePos(dock_id, ImVec2{50.0, 50.0});
+    DockBuilderFinish(dock_id);
+}
+
+void L::Draw() {
+    const auto io = GetIO();
+    PushID("DevtoolsLayer");
+
+    if (!DebugState.IsGuestThreadsPaused()) {
+        const auto fn = DebugState.flip_frame_count.load();
+        frame_graph.AddFrame(fn, io.DeltaTime);
+    }
+
+    if (IsKeyPressed(ImGuiKey_F10, false)) {
+        if (io.KeyCtrl) {
+            show_advanced_debug = !show_advanced_debug;
+        } else {
+            show_simple_fps = !show_simple_fps;
+        }
+    }
+
+    if (show_simple_fps) {
+        if (Begin("Video Info", nullptr,
+                  ImGuiWindowFlags_NoNav | ImGuiWindowFlags_NoDecoration |
+                      ImGuiWindowFlags_AlwaysAutoResize | ImGuiWindowFlags_NoDocking)) {
+            SetWindowPos("Video Info", {999999.0f, 0.0f}, ImGuiCond_FirstUseEver);
+            if (BeginPopupContextWindow()) {
+#define M(label, value)                                                                            \
+    if (MenuItem(label, nullptr, fps_scale == value))                                              \
+    fps_scale = value
+                M("0.5x", 0.5f);
+                M("1.0x", 1.0f);
+                M("1.5x", 1.5f);
+                M("2.0x", 2.0f);
+                M("2.5x", 2.5f);
+                EndPopup();
+#undef M
+            }
+            KeepWindowInside();
+            SetWindowFontScale(fps_scale);
+            DrawSimple();
+        }
+        End();
+    }
+
+    if (show_advanced_debug) {
+        PushFont(io.Fonts->Fonts[IMGUI_FONT_MONO]);
+        PushID("DevtoolsLayer");
+        DrawAdvanced();
+        PopID();
+        PopFont();
+    }
+
+    PopID();
+}
--- a/src/core/devtools/layer.h
+++ b/src/core/devtools/layer.h
@ -0,0 +1,24 @@
+// SPDX-FileCopyrightText: Copyright 2024 shadPS4 Emulator Project
+// SPDX-License-Identifier: GPL-2.0-or-later
+
+#pragma once
+
+#include "imgui/imgui_layer.h"
+
+namespace Core::Devtools {
+
+class Layer final : public ImGui::Layer {
+
+    static void DrawMenuBar();
+
+    static void DrawAdvanced();
+
+    static void DrawSimple();
+
+public:
+    static void SetupSettings();
+
+    void Draw() override;
+};
+
+} // namespace Core::Devtools
--- a/src/core/devtools/widget/cmd_list.cpp
+++ b/src/core/devtools/widget/cmd_list.cpp
--- a/src/core/devtools/widget/cmd_list.h
+++ b/src/core/devtools/widget/cmd_list.h
@ -0,0 +1,63 @@
+//  SPDX-FileCopyrightText: Copyright 2024 shadPS4 Emulator Project
+//  SPDX-License-Identifier: GPL-2.0-or-later
+
+// Credits to https://github.com/psucien/tlg-emu-tools/
+
+#pragma once
+
+#include <vector>
+
+#include "common/types.h"
+#include "video_core/buffer_cache/buffer_cache.h"
+
+namespace AmdGpu {
+union PM4Type3Header;
+enum class PM4ItOpcode : u32;
+} // namespace AmdGpu
+
+namespace Core::Devtools::Widget {
+
+class FrameDumpViewer;
+
+class CmdListViewer {
+    /*
+     * Generic PM4 header
+     */
+    union PM4Header {
+        struct {
+            u32 reserved : 16;
+            u32 count : 14;
+            u32 type : 2; // PM4_TYPE
+        };
+        u32 u32All;
+    };
+    struct BatchInfo {
+        std::string marker{};
+        size_t start_addr;
+        size_t end_addr;
+        size_t command_addr;
+        AmdGpu::PM4ItOpcode type;
+        bool bypass{false};
+    };
+
+    FrameDumpViewer* parent;
+    std::vector<BatchInfo> batches{};
+    uintptr_t cmdb_addr;
+    size_t cmdb_size;
+
+    int batch_bp{-1};
+    int vqid{255};
+
+    void OnNop(AmdGpu::PM4Type3Header const* header, u32 const* body);
+    void OnSetBase(AmdGpu::PM4Type3Header const* header, u32 const* body);
+    void OnSetContextReg(AmdGpu::PM4Type3Header const* header, u32 const* body);
+    void OnSetShReg(AmdGpu::PM4Type3Header const* header, u32 const* body);
+    void OnDispatch(AmdGpu::PM4Type3Header const* header, u32 const* body);
+
+public:
+    explicit CmdListViewer(FrameDumpViewer* parent, const std::vector<u32>& cmd_list);
+
+    void Draw();
+};
+
+} // namespace Core::Devtools::Widget
--- a/src/core/devtools/widget/frame_dump.cpp
+++ b/src/core/devtools/widget/frame_dump.cpp
@ -0,0 +1,191 @@
+//  SPDX-FileCopyrightText: Copyright 2024 shadPS4 Emulator Project
+//  SPDX-License-Identifier: GPL-2.0-or-later
+
+#include <cstdio>
+#include <fmt/chrono.h>
+#include <imgui.h>
+#include <magic_enum.hpp>
+
+#include "common/io_file.h"
+#include "frame_dump.h"
+#include "imgui_internal.h"
+#include "imgui_memory_editor.h"
+
+using namespace ImGui;
+using namespace DebugStateType;
+
+#define C_V(label, value, var, out)                                                                \
+    if (Selectable(label, var == value)) {                                                         \
+        var = value;                                                                               \
+        selected_cmd = -1;                                                                         \
+        out = true;                                                                                \
+    }
+
+// 00 to 99
+static std::array<char, 3> small_int_to_str(const s32 i) {
+    std::array<char, 3> label{};
+    if (i == -1) {
+        label[0] = 'N';
+        label[1] = 'A';
+    } else {
+        label[0] = i / 10 + '0';
+        label[1] = i % 10 + '0';
+    }
+    return label;
+}
+
+namespace Core::Devtools::Widget {
+
+FrameDumpViewer::FrameDumpViewer(FrameDump _frame_dump) : frame_dump(std::move(_frame_dump)) {
+    static int unique_id = 0;
+    id = unique_id++;
+
+    selected_queue_type = QueueType::dcb;
+    selected_submit_num = 0;
+    selected_queue_num2 = 0;
+
+    cmd_list_viewer.reserve(frame_dump.queues.size());
+    for (const auto& cmd : frame_dump.queues) {
+        cmd_list_viewer.emplace_back(this, cmd.data);
+        if (cmd.type == QueueType::dcb && cmd.submit_num == selected_submit_num &&
+            cmd.num2 == selected_queue_num2) {
+            selected_cmd = cmd_list_viewer.size() - 1;
+        }
+    }
+
+    cmdb_view.Open = false;
+    cmdb_view.ReadOnly = true;
+}
+
+FrameDumpViewer::~FrameDumpViewer() {}
+
+void FrameDumpViewer::Draw() {
+    if (!is_open) {
+        return;
+    }
+
+    char name[32];
+    snprintf(name, sizeof(name), "Frame #%d dump", id);
+    static ImGuiID dock_id = ImHashStr("FrameDumpDock");
+    SetNextWindowDockID(dock_id, ImGuiCond_Appearing);
+    if (Begin(name, &is_open, ImGuiWindowFlags_NoSavedSettings)) {
+        if (IsWindowAppearing()) {
+            auto window = GetCurrentWindow();
+            SetWindowSize(window, ImVec2{470.0f, 600.0f});
+        }
+        BeginGroup();
+        TextEx("Queue type");
+        SameLine();
+        if (BeginCombo("##select_queue_type", magic_enum::enum_name(selected_queue_type).data(),
+                       ImGuiComboFlags_WidthFitPreview)) {
+            bool selected = false;
+#define COMBO(x) C_V(magic_enum::enum_name(x).data(), x, selected_queue_type, selected)
+            COMBO(QueueType::acb)
+            COMBO(QueueType::dcb);
+            COMBO(QueueType::ccb);
+            if (selected) {
+                selected_submit_num = selected_queue_num2 = -1;
+            }
+            EndCombo();
+        }
+        SameLine();
+        TextEx("Submit num");
+        SameLine();
+        if (BeginCombo("##select_submit_num", small_int_to_str(selected_submit_num).data(),
+                       ImGuiComboFlags_WidthFitPreview)) {
+            std::array<bool, 32> available_submits{};
+            for (const auto& cmd : frame_dump.queues) {
+                if (cmd.type == selected_queue_type) {
+                    available_submits[cmd.submit_num] = true;
+                }
+            }
+            bool selected = false;
+            for (int i = 0; i < available_submits.size(); ++i) {
+                if (available_submits[i]) {
+                    char label[3]{};
+                    label[0] = i / 10 + '0';
+                    label[1] = i % 10 + '0';
+                    C_V(label, i, selected_submit_num, selected);
+                }
+            }
+            if (selected) {
+                selected_queue_num2 = -1;
+            }
+            EndCombo();
+        }
+        SameLine();
+        TextEx(selected_queue_type == QueueType::acb ? "Queue num" : "Buffer num");
+        SameLine();
+        if (BeginCombo("##select_queue_num2", small_int_to_str(selected_queue_num2).data(),
+                       ImGuiComboFlags_WidthFitPreview)) {
+            std::array<bool, 32> available_queues{};
+            for (const auto& cmd : frame_dump.queues) {
+                if (cmd.type == selected_queue_type && cmd.submit_num == selected_submit_num) {
+                    available_queues[cmd.num2] = true;
+                }
+            }
+            bool selected = false;
+            for (int i = 0; i < available_queues.size(); ++i) {
+                if (available_queues[i]) {
+                    char label[3]{};
+                    label[0] = i / 10 + '0';
+                    label[1] = i % 10 + '0';
+                    C_V(label, i, selected_queue_num2, selected);
+                }
+            }
+            if (selected) {
+                const auto it = std::ranges::find_if(frame_dump.queues, [&](const auto& cmd) {
+                    return cmd.type == selected_queue_type &&
+                           cmd.submit_num == selected_submit_num && cmd.num2 == selected_queue_num2;
+                });
+                if (it != frame_dump.queues.end()) {
+                    selected_cmd = std::distance(frame_dump.queues.begin(), it);
+                }
+            }
+            EndCombo();
+        }
+        SameLine();
+        BeginDisabled(selected_cmd == -1);
+        if (SmallButton("Dump cmd")) {
+            auto now_time = fmt::localtime(std::time(nullptr));
+            const auto fname = fmt::format("{:%F %H-%M-%S} {}_{}_{}.bin", now_time,
+                                           magic_enum::enum_name(selected_queue_type),
+                                           selected_submit_num, selected_queue_num2);
+            Common::FS::IOFile file(fname, Common::FS::FileAccessMode::Write);
+            auto& data = frame_dump.queues[selected_cmd].data;
+            if (file.IsOpen()) {
+                DebugState.ShowDebugMessage(fmt::format("Dumping cmd as {}", fname));
+                file.Write(data);
+            } else {
+                DebugState.ShowDebugMessage(fmt::format("Failed to save {}", fname));
+                LOG_ERROR(Core, "Failed to open file {}", fname);
+            }
+        }
+        EndDisabled();
+        EndGroup();
+
+        if (selected_cmd != -1) {
+            cmd_list_viewer[selected_cmd].Draw();
+        }
+    }
+    End();
+
+    if (cmdb_view.Open && selected_cmd != -1) {
+        auto& cmd = frame_dump.queues[selected_cmd].data;
+        auto cmd_size = cmd.size() * sizeof(u32);
+        MemoryEditor::Sizes s;
+        cmdb_view.CalcSizes(s, cmd_size, (size_t)cmd.data());
+        SetNextWindowSizeConstraints(ImVec2(0.0f, 0.0f), ImVec2(s.WindowWidth, FLT_MAX));
+
+        char name[64];
+        snprintf(name, sizeof(name), "[GFX] Command buffer %d###cmdbuf_hex_%d", id, id);
+        if (Begin(name, &cmdb_view.Open, ImGuiWindowFlags_NoScrollbar)) {
+            cmdb_view.DrawContents(cmd.data(), cmd_size, (size_t)cmd.data());
+        }
+        End();
+    }
+}
+
+} // namespace Core::Devtools::Widget
+
+#undef C_V
--- a/src/core/devtools/widget/frame_dump.h
+++ b/src/core/devtools/widget/frame_dump.h
@ -0,0 +1,41 @@
+//  SPDX-FileCopyrightText: Copyright 2024 shadPS4 Emulator Project
+//  SPDX-License-Identifier: GPL-2.0-or-later
+
+#pragma once
+
+#include <memory>
+#include <vector>
+
+#include "cmd_list.h"
+#include "core/debug_state.h"
+#include "imgui_memory_editor.h"
+
+namespace Core::Devtools::Widget {
+
+class CmdListViewer;
+
+class FrameDumpViewer {
+    friend class CmdListViewer;
+
+    DebugStateType::FrameDump frame_dump;
+    int id;
+
+    std::vector<CmdListViewer> cmd_list_viewer;
+    MemoryEditor cmdb_view;
+
+    DebugStateType::QueueType selected_queue_type;
+    s32 selected_submit_num;
+    s32 selected_queue_num2;
+    s32 selected_cmd = -1;
+
+public:
+    bool is_open = true;
+
+    explicit FrameDumpViewer(DebugStateType::FrameDump frame_dump);
+
+    ~FrameDumpViewer();
+
+    void Draw();
+};
+
+} // namespace Core::Devtools::Widget
--- a/src/core/devtools/widget/frame_graph.cpp
+++ b/src/core/devtools/widget/frame_graph.cpp
@ -0,0 +1,99 @@
+//  SPDX-FileCopyrightText: Copyright 2024 shadPS4 Emulator Project
+//  SPDX-License-Identifier: GPL-2.0-or-later
+
+#include "frame_graph.h"
+
+#include "common/config.h"
+#include "common/singleton.h"
+#include "core/debug_state.h"
+#include "imgui.h"
+#include "imgui_internal.h"
+
+using namespace ImGui;
+
+namespace Core::Devtools::Widget {
+
+constexpr float TARGET_FPS = 60.0f;
+constexpr float BAR_WIDTH_MULT = 1.4f;
+constexpr float BAR_HEIGHT_MULT = 1.25f;
+constexpr float FRAME_GRAPH_PADDING_Y = 3.0f;
+constexpr static float FRAME_GRAPH_HEIGHT = 50.0f;
+
+void FrameGraph::Draw() {
+    if (!is_open) {
+        return;
+    }
+    SetNextWindowSize({340.0, 185.0f}, ImGuiCond_FirstUseEver);
+    if (Begin("Video debug info", &is_open)) {
+        const auto& ctx = *GImGui;
+        const auto& io = ctx.IO;
+        const auto& window = *ctx.CurrentWindow;
+        auto& draw_list = *window.DrawList;
+
+        auto isSystemPaused = DebugState.IsGuestThreadsPaused();
+
+        static float deltaTime;
+        static float frameRate;
+
+        if (!isSystemPaused) {
+            deltaTime = io.DeltaTime * 1000.0f;
+            frameRate = 1000.0f / deltaTime;
+        }
+
+        Text("Frame time: %.3f ms (%.1f FPS)", deltaTime, frameRate);
+        Text("Flip frame: %d Gnm submit frame: %d", DebugState.flip_frame_count.load(),
+             DebugState.gnm_frame_count.load());
+        SeparatorText("Frame graph");
+
+        const float full_width = GetContentRegionAvail().x;
+        // Frame graph - inspired by
+        // https://asawicki.info/news_1758_an_idea_for_visualization_of_frame_times
+        auto pos = GetCursorScreenPos();
+        const ImVec2 size{full_width, FRAME_GRAPH_HEIGHT + FRAME_GRAPH_PADDING_Y * 2.0f};
+        ItemSize(size);
+        if (!ItemAdd({pos, pos + size}, GetID("FrameGraph"))) {
+            return;
+        }
+
+        float target_dt = 1.0f / (TARGET_FPS * (float)Config::vblankDiv());
+        float cur_pos_x = pos.x + full_width;
+        pos.y += FRAME_GRAPH_PADDING_Y;
+        const float final_pos_y = pos.y + FRAME_GRAPH_HEIGHT;
+
+        draw_list.AddRectFilled({pos.x, pos.y - FRAME_GRAPH_PADDING_Y},
+                                {pos.x + full_width, final_pos_y + FRAME_GRAPH_PADDING_Y},
+                                IM_COL32(0x33, 0x33, 0x33, 0xFF));
+        draw_list.PushClipRect({pos.x, pos.y}, {pos.x + full_width, final_pos_y}, true);
+        for (u32 i = 0; i < FRAME_BUFFER_SIZE; ++i) {
+            const auto& frame_info = frame_list[(DebugState.GetFrameNum() - i) % FRAME_BUFFER_SIZE];
+            const float dt_factor = target_dt / frame_info.delta;
+
+            const float width = std::ceil(BAR_WIDTH_MULT / dt_factor);
+            const float height =
+                std::min(std::log2(BAR_HEIGHT_MULT / dt_factor) / 3.0f, 1.0f) * FRAME_GRAPH_HEIGHT;
+
+            ImU32 color;
+            if (dt_factor >= 0.95f) { // BLUE
+                color = IM_COL32(0x33, 0x33, 0xFF, 0xFF);
+            } else if (dt_factor >= 0.5f) { // GREEN <> YELLOW
+                float t = 1.0f - (dt_factor - 0.5f) * 2.0f;
+                int r = (int)(0xFF * t);
+                color = IM_COL32(r, 0xFF, 0, 0xFF);
+            } else { // YELLOW <> RED
+                float t = dt_factor * 2.0f;
+                int g = (int)(0xFF * t);
+                color = IM_COL32(0xFF, g, 0, 0xFF);
+            }
+            draw_list.AddRectFilled({cur_pos_x - width, final_pos_y - height},
+                                    {cur_pos_x, final_pos_y}, color);
+            cur_pos_x -= width;
+            if (cur_pos_x < width) {
+                break;
+            }
+        }
+        draw_list.PopClipRect();
+    }
+    End();
+}
+
+} // namespace Core::Devtools::Widget
--- a/src/core/devtools/widget/frame_graph.h
+++ b/src/core/devtools/widget/frame_graph.h
@ -0,0 +1,29 @@
+//  SPDX-FileCopyrightText: Copyright 2024 shadPS4 Emulator Project
+//  SPDX-License-Identifier: GPL-2.0-or-later
+
+#pragma once
+
+#include "common/types.h"
+
+namespace Core::Devtools::Widget {
+
+class FrameGraph {
+    static constexpr u32 FRAME_BUFFER_SIZE = 1024;
+    struct FrameInfo {
+        u32 num;
+        float delta;
+    };
+
+    std::array<FrameInfo, FRAME_BUFFER_SIZE> frame_list{};
+
+public:
+    bool is_open = true;
+
+    void Draw();
+
+    void AddFrame(u32 num, float delta) {
+        frame_list[num % FRAME_BUFFER_SIZE] = FrameInfo{num, delta};
+    }
+};
+
+} // namespace Core::Devtools::Widget
--- a/src/core/devtools/widget/imgui_memory_editor.h
+++ b/src/core/devtools/widget/imgui_memory_editor.h
@ -0,0 +1,942 @@
+//  SPDX-FileCopyrightText: 2024 Dear ImGui Club Contributors
+//  SPDX-License-Identifier: MIT
+
+// Mini memory editor for Dear ImGui (to embed in your game/tools)
+// Get latest version at http://www.github.com/ocornut/imgui_club
+// Licensed under The MIT License (MIT)
+
+// Right-click anywhere to access the Options menu!
+// You can adjust the keyboard repeat delay/rate in ImGuiIO.
+// The code assume a mono-space font for simplicity!
+// If you don't use the default font, use ImGui::PushFont()/PopFont() to switch to a mono-space font
+// before calling this.
+//
+// Usage:
+//   // Create a window and draw memory editor inside it:
+//   static MemoryEditor mem_edit_1;
+//   static char data[0x10000];
+//   size_t data_size = 0x10000;
+//   mem_edit_1.DrawWindow("Memory Editor", data, data_size);
+//
+// Usage:
+//   // If you already have a window, use DrawContents() instead:
+//   static MemoryEditor mem_edit_2;
+//   ImGui::Begin("MyWindow")
+//   mem_edit_2.DrawContents(this, sizeof(*this), (size_t)this);
+//   ImGui::End();
+//
+// Changelog:
+// - v0.10: initial version
+// - v0.23 (2017/08/17): added to github. fixed right-arrow triggering a byte write.
+// - v0.24 (2018/06/02): changed DragInt("Rows" to use a %d data format (which is desirable since
+// imgui 1.61).
+// - v0.25 (2018/07/11): fixed wording: all occurrences of "Rows" renamed to "Columns".
+// - v0.26 (2018/08/02): fixed clicking on hex region
+// - v0.30 (2018/08/02): added data preview for common data types
+// - v0.31 (2018/10/10): added OptUpperCaseHex option to select lower/upper casing display
+// [@samhocevar]
+// - v0.32 (2018/10/10): changed signatures to use void* instead of unsigned char*
+// - v0.33 (2018/10/10): added OptShowOptions option to hide all the interactive option setting.
+// - v0.34 (2019/05/07): binary preview now applies endianness setting [@nicolasnoble]
+// - v0.35 (2020/01/29): using ImGuiDataType available since Dear ImGui 1.69.
+// - v0.36 (2020/05/05): minor tweaks, minor refactor.
+// - v0.40 (2020/10/04): fix misuse of ImGuiListClipper API, broke with Dear ImGui 1.79. made cursor
+// position appears on left-side of edit box. option popup appears on mouse release. fix MSVC
+// warnings where _CRT_SECURE_NO_WARNINGS wasn't working in recent versions.
+// - v0.41 (2020/10/05): fix when using with keyboard/gamepad navigation enabled.
+// - v0.42 (2020/10/14): fix for . character in ASCII view always being greyed out.
+// - v0.43 (2021/03/12): added OptFooterExtraHeight to allow for custom drawing at the bottom of the
+// editor [@leiradel]
+// - v0.44 (2021/03/12): use ImGuiInputTextFlags_AlwaysOverwrite in 1.82 + fix hardcoded width.
+// - v0.50 (2021/11/12): various fixes for recent dear imgui versions (fixed misuse of clipper,
+// relying on SetKeyboardFocusHere() handling scrolling from 1.85). added default size.
+// - v0.51 (2024/02/22): fix for layout change in 1.89 when using IMGUI_DISABLE_OBSOLETE_FUNCTIONS.
+// (#34)
+// - v0.52 (2024/03/08): removed unnecessary GetKeyIndex() calls, they are a no-op since 1.87.
+// - v0.53 (2024/05/27): fixed right-click popup from not appearing when using DrawContents().
+// warning fixes. (#35)
+// - v0.54 (2024/07/29): allow ReadOnly mode to still select and preview data. (#46) [@DeltaGW2])
+// - v0.55 (2024/08/19): added BgColorFn to allow setting background colors independently from
+// highlighted selection. (#27) [@StrikerX3]
+//                       added MouseHoveredAddr public readable field. (#47, #27) [@StrikerX3]
+//                       fixed a data preview crash with 1.91.0 WIP. fixed contiguous highlight
+//                       color when using data preview. *BREAKING* added UserData field passed to
+//                       all optional function handlers: ReadFn, WriteFn, HighlightFn, BgColorFn.
+//                       (#50) [@silverweed]
+//
+// TODO:
+// - This is generally old/crappy code, it should work but isn't very good.. to be rewritten some
+// day.
+// - PageUp/PageDown are not supported because we use _NoNav. This is a good test scenario for
+// working out idioms of how to mix natural nav and our own...
+// - Arrows are being sent to the InputText() about to disappear which for LeftArrow makes the text
+// cursor appear at position 1 for one frame.
+// - Using InputText() is awkward and maybe overkill here, consider implementing something custom.
+
+#pragma once
+
+#include <stdint.h> // uint8_t, etc.
+#include <stdio.h>  // sprintf, scanf
+
+#if defined(_MSC_VER) || defined(_UCRT)
+#define _PRISizeT "I"
+#define ImSnprintf _snprintf
+#else
+#define _PRISizeT "z"
+#define ImSnprintf snprintf
+#endif
+
+#if defined(_MSC_VER) || defined(_UCRT)
+#pragma warning(push)
+#pragma warning(                                                                                   \
+    disable : 4996) // warning C4996: 'sprintf': This function or variable may be unsafe.
+#endif
+
+struct MemoryEditor {
+    enum DataFormat {
+        DataFormat_Bin = 0,
+        DataFormat_Dec = 1,
+        DataFormat_Hex = 2,
+        DataFormat_COUNT
+    };
+
+    // Settings
+    bool Open;     // = true   // set to false when DrawWindow() was closed. ignore if not using
+                   // DrawWindow().
+    bool ReadOnly; // = false  // disable any editing.
+    int Cols;      // = 16     // number of columns to display.
+    bool OptShowOptions; // = true   // display options button/context menu. when disabled, options
+                         // will be locked unless you provide your own UI for them.
+    bool OptShowDataPreview; // = false  // display a footer previewing the decimal/binary/hex/float
+                             // representation of the currently selected bytes.
+    bool OptShowHexII;      // = false  // display values in HexII representation instead of regular
+                            // hexadecimal: hide null/zero bytes, ascii values as ".X".
+    bool OptShowAscii;      // = true   // display ASCII representation on the right side.
+    bool OptGreyOutZeroes;  // = true   // display null/zero bytes using the TextDisabled color.
+    bool OptUpperCaseHex;   // = true   // display hexadecimal values as "FF" instead of "ff".
+    int OptMidColsCount;    // = 8      // set to 0 to disable extra spacing between every mid-cols.
+    int OptAddrDigitsCount; // = 0      // number of addr digits to display (default calculated
+                            // based on maximum displayed addr).
+    float OptFooterExtraHeight; // = 0      // space to reserve at the bottom of the widget to add
+                                // custom widgets
+    ImU32 HighlightColor;       //          // background color of highlighted bytes.
+
+    // Function handlers
+    ImU8 (*ReadFn)(const ImU8* mem, size_t off,
+                   void* user_data); // = 0      // optional handler to read bytes.
+    void (*WriteFn)(ImU8* mem, size_t off, ImU8 d,
+                    void* user_data); // = 0      // optional handler to write bytes.
+    bool (*HighlightFn)(const ImU8* mem, size_t off,
+                        void* user_data); // = 0      // optional handler to return Highlight
+                                          // property (to support non-contiguous highlighting).
+    ImU32 (*BgColorFn)(const ImU8* mem, size_t off,
+                       void* user_data); // = 0      // optional handler to return custom background
+                                         // color of individual bytes.
+    void* UserData;                      // = NULL   // user data forwarded to the function handlers
+
+    // Public read-only data
+    bool MouseHovered;       // set when mouse is hovering a value.
+    size_t MouseHoveredAddr; // the address currently being hovered if MouseHovered is set.
+
+    // [Internal State]
+    bool ContentsWidthChanged;
+    size_t DataPreviewAddr;
+    size_t DataEditingAddr;
+    bool DataEditingTakeFocus;
+    char DataInputBuf[32];
+    char AddrInputBuf[32];
+    size_t GotoAddr;
+    size_t HighlightMin, HighlightMax;
+    int PreviewEndianness;
+    ImGuiDataType PreviewDataType;
+
+    MemoryEditor() {
+        // Settings
+        Open = true;
+        ReadOnly = false;
+        Cols = 16;
+        OptShowOptions = true;
+        OptShowDataPreview = false;
+        OptShowHexII = false;
+        OptShowAscii = true;
+        OptGreyOutZeroes = true;
+        OptUpperCaseHex = true;
+        OptMidColsCount = 8;
+        OptAddrDigitsCount = 0;
+        OptFooterExtraHeight = 0.0f;
+        HighlightColor = IM_COL32(255, 255, 255, 50);
+        ReadFn = nullptr;
+        WriteFn = nullptr;
+        HighlightFn = nullptr;
+        BgColorFn = nullptr;
+        UserData = nullptr;
+
+        // State/Internals
+        ContentsWidthChanged = false;
+        DataPreviewAddr = DataEditingAddr = (size_t)-1;
+        DataEditingTakeFocus = false;
+        memset(DataInputBuf, 0, sizeof(DataInputBuf));
+        memset(AddrInputBuf, 0, sizeof(AddrInputBuf));
+        GotoAddr = (size_t)-1;
+        MouseHovered = false;
+        MouseHoveredAddr = 0;
+        HighlightMin = HighlightMax = (size_t)-1;
+        PreviewEndianness = 0;
+        PreviewDataType = ImGuiDataType_S32;
+    }
+
+    void GotoAddrAndHighlight(size_t addr_min, size_t addr_max) {
+        GotoAddr = addr_min;
+        HighlightMin = addr_min;
+        HighlightMax = addr_max;
+    }
+
+    struct Sizes {
+        int AddrDigitsCount;
+        float LineHeight;
+        float GlyphWidth;
+        float HexCellWidth;
+        float SpacingBetweenMidCols;
+        float PosHexStart;
+        float PosHexEnd;
+        float PosAsciiStart;
+        float PosAsciiEnd;
+        float WindowWidth;
+
+        Sizes() {
+            memset(this, 0, sizeof(*this));
+        }
+    };
+
+    void CalcSizes(Sizes& s, size_t mem_size, size_t base_display_addr) {
+        ImGuiStyle& style = ImGui::GetStyle();
+        s.AddrDigitsCount = OptAddrDigitsCount;
+        if (s.AddrDigitsCount == 0)
+            for (size_t n = base_display_addr + mem_size - 1; n > 0; n >>= 4)
+                s.AddrDigitsCount++;
+        s.LineHeight = ImGui::GetTextLineHeight();
+        s.GlyphWidth = ImGui::CalcTextSize("F").x + 1; // We assume the font is mono-space
+        s.HexCellWidth =
+            (float)(int)(s.GlyphWidth * 2.5f); // "FF " we include trailing space in the width to
+                                               // easily catch clicks everywhere
+        s.SpacingBetweenMidCols =
+            (float)(int)(s.HexCellWidth *
+                         0.25f); // Every OptMidColsCount columns we add a bit of extra spacing
+        s.PosHexStart = (s.AddrDigitsCount + 2) * s.GlyphWidth;
+        s.PosHexEnd = s.PosHexStart + (s.HexCellWidth * Cols);
+        s.PosAsciiStart = s.PosAsciiEnd = s.PosHexEnd;
+        if (OptShowAscii) {
+            s.PosAsciiStart = s.PosHexEnd + s.GlyphWidth * 1;
+            if (OptMidColsCount > 0)
+                s.PosAsciiStart += (float)((Cols + OptMidColsCount - 1) / OptMidColsCount) *
+                                   s.SpacingBetweenMidCols;
+            s.PosAsciiEnd = s.PosAsciiStart + Cols * s.GlyphWidth;
+        }
+        s.WindowWidth =
+            s.PosAsciiEnd + style.ScrollbarSize + style.WindowPadding.x * 2 + s.GlyphWidth;
+    }
+
+    // Standalone Memory Editor window
+    void DrawWindow(const char* title, void* mem_data, size_t mem_size,
+                    size_t base_display_addr = 0x0000) {
+        Sizes s;
+        CalcSizes(s, mem_size, base_display_addr);
+        ImGui::SetNextWindowSize(ImVec2(s.WindowWidth, s.WindowWidth * 0.60f),
+                                 ImGuiCond_FirstUseEver);
+        ImGui::SetNextWindowSizeConstraints(ImVec2(0.0f, 0.0f), ImVec2(s.WindowWidth, FLT_MAX));
+
+        Open = true;
+        if (ImGui::Begin(title, &Open, ImGuiWindowFlags_NoScrollbar)) {
+            DrawContents(mem_data, mem_size, base_display_addr);
+            if (ContentsWidthChanged) {
+                CalcSizes(s, mem_size, base_display_addr);
+                ImGui::SetWindowSize(ImVec2(s.WindowWidth, ImGui::GetWindowSize().y));
+            }
+        }
+        ImGui::End();
+    }
+
+    // Memory Editor contents only
+    void DrawContents(void* mem_data_void, size_t mem_size, size_t base_display_addr = 0x0000) {
+        if (Cols < 1)
+            Cols = 1;
+
+        ImU8* mem_data = (ImU8*)mem_data_void;
+        Sizes s;
+        CalcSizes(s, mem_size, base_display_addr);
+        ImGuiStyle& style = ImGui::GetStyle();
+
+        const ImVec2 contents_pos_start = ImGui::GetCursorScreenPos();
+
+        // We begin into our scrolling region with the 'ImGuiWindowFlags_NoMove' in order to prevent
+        // click from moving the window. This is used as a facility since our main click detection
+        // code doesn't assign an ActiveId so the click would normally be caught as a window-move.
+        const float height_separator = style.ItemSpacing.y;
+        float footer_height = OptFooterExtraHeight;
+        if (OptShowOptions)
+            footer_height += height_separator + ImGui::GetFrameHeightWithSpacing() * 1;
+        if (OptShowDataPreview)
+            footer_height += height_separator + ImGui::GetFrameHeightWithSpacing() * 1 +
+                             ImGui::GetTextLineHeightWithSpacing() * 3;
+        ImGui::BeginChild("##scrolling", ImVec2(-FLT_MIN, -footer_height), ImGuiChildFlags_None,
+                          ImGuiWindowFlags_NoMove | ImGuiWindowFlags_NoNav);
+        ImDrawList* draw_list = ImGui::GetWindowDrawList();
+
+        ImGui::PushStyleVar(ImGuiStyleVar_FramePadding, ImVec2(0, 0));
+        ImGui::PushStyleVar(ImGuiStyleVar_ItemSpacing, ImVec2(0, 0));
+
+        // We are not really using the clipper API correctly here, because we rely on
+        // visible_start_addr/visible_end_addr for our scrolling function.
+        const int line_total_count = (int)((mem_size + Cols - 1) / Cols);
+        ImGuiListClipper clipper;
+        clipper.Begin(line_total_count, s.LineHeight);
+
+        bool data_next = false;
+
+        if (DataEditingAddr >= mem_size)
+            DataEditingAddr = (size_t)-1;
+        if (DataPreviewAddr >= mem_size)
+            DataPreviewAddr = (size_t)-1;
+
+        size_t preview_data_type_size = OptShowDataPreview ? DataTypeGetSize(PreviewDataType) : 0;
+
+        size_t data_editing_addr_next = (size_t)-1;
+        if (DataEditingAddr != (size_t)-1) {
+            // Move cursor but only apply on next frame so scrolling with be synchronized (because
+            // currently we can't change the scrolling while the window is being rendered)
+            if (ImGui::IsKeyPressed(ImGuiKey_UpArrow) &&
+                (ptrdiff_t)DataEditingAddr >= (ptrdiff_t)Cols) {
+                data_editing_addr_next = DataEditingAddr - Cols;
+            } else if (ImGui::IsKeyPressed(ImGuiKey_DownArrow) &&
+                       (ptrdiff_t)DataEditingAddr < (ptrdiff_t)mem_size - Cols) {
+                data_editing_addr_next = DataEditingAddr + Cols;
+            } else if (ImGui::IsKeyPressed(ImGuiKey_LeftArrow) &&
+                       (ptrdiff_t)DataEditingAddr > (ptrdiff_t)0) {
+                data_editing_addr_next = DataEditingAddr - 1;
+            } else if (ImGui::IsKeyPressed(ImGuiKey_RightArrow) &&
+                       (ptrdiff_t)DataEditingAddr < (ptrdiff_t)mem_size - 1) {
+                data_editing_addr_next = DataEditingAddr + 1;
+            }
+        }
+
+        // Draw vertical separator
+        ImVec2 window_pos = ImGui::GetWindowPos();
+        if (OptShowAscii)
+            draw_list->AddLine(
+                ImVec2(window_pos.x + s.PosAsciiStart - s.GlyphWidth, window_pos.y),
+                ImVec2(window_pos.x + s.PosAsciiStart - s.GlyphWidth, window_pos.y + 9999),
+                ImGui::GetColorU32(ImGuiCol_Border));
+
+        const ImU32 color_text = ImGui::GetColorU32(ImGuiCol_Text);
+        const ImU32 color_disabled =
+            OptGreyOutZeroes ? ImGui::GetColorU32(ImGuiCol_TextDisabled) : color_text;
+
+        const char* format_address =
+            OptUpperCaseHex ? "%0*" _PRISizeT "X: " : "%0*" _PRISizeT "x: ";
+        const char* format_data = OptUpperCaseHex ? "%0*" _PRISizeT "X" : "%0*" _PRISizeT "x";
+        const char* format_byte = OptUpperCaseHex ? "%02X" : "%02x";
+        const char* format_byte_space = OptUpperCaseHex ? "%02X " : "%02x ";
+
+        MouseHovered = false;
+        MouseHoveredAddr = 0;
+
+        while (clipper.Step())
+            for (int line_i = clipper.DisplayStart; line_i < clipper.DisplayEnd;
+                 line_i++) // display only visible lines
+            {
+                size_t addr = (size_t)line_i * Cols;
+                ImGui::Text(format_address, s.AddrDigitsCount, base_display_addr + addr);
+
+                // Draw Hexadecimal
+                for (int n = 0; n < Cols && addr < mem_size; n++, addr++) {
+                    float byte_pos_x = s.PosHexStart + s.HexCellWidth * n;
+                    if (OptMidColsCount > 0)
+                        byte_pos_x += (float)(n / OptMidColsCount) * s.SpacingBetweenMidCols;
+                    ImGui::SameLine(byte_pos_x);
+
+                    // Draw highlight or custom background color
+                    const bool is_highlight_from_user_range =
+                        (addr >= HighlightMin && addr < HighlightMax);
+                    const bool is_highlight_from_user_func =
+                        (HighlightFn && HighlightFn(mem_data, addr, UserData));
+                    const bool is_highlight_from_preview =
+                        (addr >= DataPreviewAddr &&
+                         addr < DataPreviewAddr + preview_data_type_size);
+
+                    ImU32 bg_color = 0;
+                    bool is_next_byte_highlighted = false;
+                    if (is_highlight_from_user_range || is_highlight_from_user_func ||
+                        is_highlight_from_preview) {
+                        is_next_byte_highlighted =
+                            (addr + 1 < mem_size) &&
+                            ((HighlightMax != (size_t)-1 && addr + 1 < HighlightMax) ||
+                             (HighlightFn && HighlightFn(mem_data, addr + 1, UserData)) ||
+                             (addr + 1 < DataPreviewAddr + preview_data_type_size));
+                        bg_color = HighlightColor;
+                    } else if (BgColorFn != nullptr) {
+                        is_next_byte_highlighted =
+                            (addr + 1 < mem_size) &&
+                            ((BgColorFn(mem_data, addr + 1, UserData) & IM_COL32_A_MASK) != 0);
+                        bg_color = BgColorFn(mem_data, addr, UserData);
+                    }
+                    if (bg_color != 0) {
+                        float bg_width = s.GlyphWidth * 2;
+                        if (is_next_byte_highlighted || (n + 1 == Cols)) {
+                            bg_width = s.HexCellWidth;
+                            if (OptMidColsCount > 0 && n > 0 && (n + 1) < Cols &&
+                                ((n + 1) % OptMidColsCount) == 0)
+                                bg_width += s.SpacingBetweenMidCols;
+                        }
+                        ImVec2 pos = ImGui::GetCursorScreenPos();
+                        draw_list->AddRectFilled(
+                            pos, ImVec2(pos.x + bg_width, pos.y + s.LineHeight), bg_color);
+                    }
+
+                    if (DataEditingAddr == addr) {
+                        // Display text input on current byte
+                        bool data_write = false;
+                        ImGui::PushID((void*)addr);
+                        if (DataEditingTakeFocus) {
+                            ImGui::SetKeyboardFocusHere(0);
+                            ImSnprintf(AddrInputBuf, 32, format_data, s.AddrDigitsCount,
+                                       base_display_addr + addr);
+                            ImSnprintf(DataInputBuf, 32, format_byte,
+                                       ReadFn ? ReadFn(mem_data, addr, UserData) : mem_data[addr]);
+                        }
+                        struct InputTextUserData {
+                            // FIXME: We should have a way to retrieve the text edit cursor position
+                            // more easily in the API, this is rather tedious. This is such a ugly
+                            // mess we may be better off not using InputText() at all here.
+                            static int Callback(ImGuiInputTextCallbackData* data) {
+                                InputTextUserData* user_data = (InputTextUserData*)data->UserData;
+                                if (!data->HasSelection())
+                                    user_data->CursorPos = data->CursorPos;
+#if IMGUI_VERSION_NUM < 19102
+                                if (data->Flags & ImGuiInputTextFlags_ReadOnly)
+                                    return 0;
+#endif
+                                if (data->SelectionStart == 0 &&
+                                    data->SelectionEnd == data->BufTextLen) {
+                                    // When not editing a byte, always refresh its InputText content
+                                    // pulled from underlying memory data (this is a bit tricky,
+                                    // since InputText technically "owns" the master copy of the
+                                    // buffer we edit it in there)
+                                    data->DeleteChars(0, data->BufTextLen);
+                                    data->InsertChars(0, user_data->CurrentBufOverwrite);
+                                    data->SelectionStart = 0;
+                                    data->SelectionEnd = 2;
+                                    data->CursorPos = 0;
+                                }
+                                return 0;
+                            }
+                            char CurrentBufOverwrite[3]; // Input
+                            int CursorPos;               // Output
+                        };
+                        InputTextUserData input_text_user_data;
+                        input_text_user_data.CursorPos = -1;
+                        ImSnprintf(input_text_user_data.CurrentBufOverwrite, 3, format_byte,
+                                   ReadFn ? ReadFn(mem_data, addr, UserData) : mem_data[addr]);
+                        ImGuiInputTextFlags flags = ImGuiInputTextFlags_CharsHexadecimal |
+                                                    ImGuiInputTextFlags_EnterReturnsTrue |
+                                                    ImGuiInputTextFlags_AutoSelectAll |
+                                                    ImGuiInputTextFlags_NoHorizontalScroll |
+                                                    ImGuiInputTextFlags_CallbackAlways;
+                        if (ReadOnly)
+                            flags |= ImGuiInputTextFlags_ReadOnly;
+                        flags |=
+                            ImGuiInputTextFlags_AlwaysOverwrite; // was
+                                                                 // ImGuiInputTextFlags_AlwaysInsertMode
+                        ImGui::SetNextItemWidth(s.GlyphWidth * 2);
+                        if (ImGui::InputText("##data", DataInputBuf, IM_ARRAYSIZE(DataInputBuf),
+                                             flags, InputTextUserData::Callback,
+                                             &input_text_user_data))
+                            data_write = data_next = true;
+                        else if (!DataEditingTakeFocus && !ImGui::IsItemActive())
+                            DataEditingAddr = data_editing_addr_next = (size_t)-1;
+                        DataEditingTakeFocus = false;
+                        if (input_text_user_data.CursorPos >= 2)
+                            data_write = data_next = true;
+                        if (data_editing_addr_next != (size_t)-1)
+                            data_write = data_next = false;
+                        unsigned int data_input_value = 0;
+                        if (!ReadOnly && data_write &&
+                            sscanf(DataInputBuf, "%X", &data_input_value) == 1) {
+                            if (WriteFn)
+                                WriteFn(mem_data, addr, (ImU8)data_input_value, UserData);
+                            else
+                                mem_data[addr] = (ImU8)data_input_value;
+                        }
+                        ImGui::PopID();
+                    } else {
+                        // NB: The trailing space is not visible but ensure there's no gap that the
+                        // mouse cannot click on.
+                        ImU8 b = ReadFn ? ReadFn(mem_data, addr, UserData) : mem_data[addr];
+
+                        if (OptShowHexII) {
+                            if ((b >= 32 && b < 128))
+                                ImGui::Text(".%c ", b);
+                            else if (b == 0xFF && OptGreyOutZeroes)
+                                ImGui::TextDisabled("## ");
+                            else if (b == 0x00)
+                                ImGui::Text("   ");
+                            else
+                                ImGui::Text(format_byte_space, b);
+                        } else {
+                            if (b == 0 && OptGreyOutZeroes)
+                                ImGui::TextDisabled("00 ");
+                            else
+                                ImGui::Text(format_byte_space, b);
+                        }
+                        if (ImGui::IsItemHovered()) {
+                            MouseHovered = true;
+                            MouseHoveredAddr = addr;
+                            if (ImGui::IsMouseClicked(0)) {
+                                DataEditingTakeFocus = true;
+                                data_editing_addr_next = addr;
+                            }
+                        }
+                    }
+                }
+
+                if (OptShowAscii) {
+                    // Draw ASCII values
+                    ImGui::SameLine(s.PosAsciiStart);
+                    ImVec2 pos = ImGui::GetCursorScreenPos();
+                    addr = (size_t)line_i * Cols;
+
+                    const float mouse_off_x = ImGui::GetIO().MousePos.x - pos.x;
+                    const size_t mouse_addr =
+                        (mouse_off_x >= 0.0f && mouse_off_x < s.PosAsciiEnd - s.PosAsciiStart)
+                            ? addr + (size_t)(mouse_off_x / s.GlyphWidth)
+                            : (size_t)-1;
+
+                    ImGui::PushID(line_i);
+                    if (ImGui::InvisibleButton(
+                            "ascii", ImVec2(s.PosAsciiEnd - s.PosAsciiStart, s.LineHeight))) {
+                        DataEditingAddr = DataPreviewAddr = mouse_addr;
+                        DataEditingTakeFocus = true;
+                    }
+                    if (ImGui::IsItemHovered()) {
+                        MouseHovered = true;
+                        MouseHoveredAddr = mouse_addr;
+                    }
+                    ImGui::PopID();
+                    for (int n = 0; n < Cols && addr < mem_size; n++, addr++) {
+                        if (addr == DataEditingAddr) {
+                            draw_list->AddRectFilled(
+                                pos, ImVec2(pos.x + s.GlyphWidth, pos.y + s.LineHeight),
+                                ImGui::GetColorU32(ImGuiCol_FrameBg));
+                            draw_list->AddRectFilled(
+                                pos, ImVec2(pos.x + s.GlyphWidth, pos.y + s.LineHeight),
+                                ImGui::GetColorU32(ImGuiCol_TextSelectedBg));
+                        } else if (BgColorFn) {
+                            draw_list->AddRectFilled(
+                                pos, ImVec2(pos.x + s.GlyphWidth, pos.y + s.LineHeight),
+                                BgColorFn(mem_data, addr, UserData));
+                        }
+                        unsigned char c =
+                            ReadFn ? ReadFn(mem_data, addr, UserData) : mem_data[addr];
+                        char display_c = (c < 32 || c >= 128) ? '.' : c;
+                        draw_list->AddText(pos, (display_c == c) ? color_text : color_disabled,
+                                           &display_c, &display_c + 1);
+                        pos.x += s.GlyphWidth;
+                    }
+                }
+            }
+        ImGui::PopStyleVar(2);
+        const float child_width = ImGui::GetWindowSize().x;
+        ImGui::EndChild();
+
+        // Notify the main window of our ideal child content size (FIXME: we are missing an API to
+        // get the contents size from the child)
+        ImGui::SetCursorPosX(s.WindowWidth);
+        ImGui::Dummy(ImVec2(0.0f, 0.0f));
+
+        if (data_next && DataEditingAddr + 1 < mem_size) {
+            DataEditingAddr = DataPreviewAddr = DataEditingAddr + 1;
+            DataEditingTakeFocus = true;
+        } else if (data_editing_addr_next != (size_t)-1) {
+            DataEditingAddr = DataPreviewAddr = data_editing_addr_next;
+            DataEditingTakeFocus = true;
+        }
+
+        const bool lock_show_data_preview = OptShowDataPreview;
+        if (OptShowOptions) {
+            ImGui::Separator();
+            DrawOptionsLine(s, mem_data, mem_size, base_display_addr);
+        }
+
+        if (lock_show_data_preview) {
+            ImGui::Separator();
+            DrawPreviewLine(s, mem_data, mem_size, base_display_addr);
+        }
+
+        const ImVec2 contents_pos_end(contents_pos_start.x + child_width,
+                                      ImGui::GetCursorScreenPos().y);
+        // ImGui::GetForegroundDrawList()->AddRect(contents_pos_start, contents_pos_end,
+        // IM_COL32(255, 0, 0, 255));
+        if (OptShowOptions)
+            if (ImGui::IsMouseHoveringRect(contents_pos_start, contents_pos_end))
+                if (ImGui::IsWindowHovered(ImGuiHoveredFlags_ChildWindows) &&
+                    ImGui::IsMouseReleased(ImGuiMouseButton_Right))
+                    ImGui::OpenPopup("OptionsPopup");
+
+        if (ImGui::BeginPopup("OptionsPopup")) {
+            ImGui::SetNextItemWidth(s.GlyphWidth * 7 + style.FramePadding.x * 2.0f);
+            if (ImGui::DragInt("##cols", &Cols, 0.2f, 4, 32, "%d cols")) {
+                ContentsWidthChanged = true;
+                if (Cols < 1)
+                    Cols = 1;
+            }
+            ImGui::Checkbox("Show Data Preview", &OptShowDataPreview);
+            ImGui::Checkbox("Show HexII", &OptShowHexII);
+            if (ImGui::Checkbox("Show Ascii", &OptShowAscii)) {
+                ContentsWidthChanged = true;
+            }
+            ImGui::Checkbox("Grey out zeroes", &OptGreyOutZeroes);
+            ImGui::Checkbox("Uppercase Hex", &OptUpperCaseHex);
+
+            ImGui::EndPopup();
+        }
+    }
+
+    void DrawOptionsLine(const Sizes& s, void* mem_data, size_t mem_size,
+                         size_t base_display_addr) {
+        IM_UNUSED(mem_data);
+        ImGuiStyle& style = ImGui::GetStyle();
+        const char* format_range = OptUpperCaseHex ? "Range %0*" _PRISizeT "X..%0*" _PRISizeT "X"
+                                                   : "Range %0*" _PRISizeT "x..%0*" _PRISizeT "x";
+
+        // Options menu
+        if (ImGui::Button("Options"))
+            ImGui::OpenPopup("OptionsPopup");
+
+        ImGui::SameLine();
+        ImGui::Text(format_range, s.AddrDigitsCount, base_display_addr, s.AddrDigitsCount,
+                    base_display_addr + mem_size - 1);
+        ImGui::SameLine();
+        ImGui::SetNextItemWidth((s.AddrDigitsCount + 1) * s.GlyphWidth +
+                                style.FramePadding.x * 2.0f);
+        if (ImGui::InputText("##addr", AddrInputBuf, IM_ARRAYSIZE(AddrInputBuf),
+                             ImGuiInputTextFlags_CharsHexadecimal |
+                                 ImGuiInputTextFlags_EnterReturnsTrue)) {
+            size_t goto_addr;
+            if (sscanf(AddrInputBuf, "%" _PRISizeT "X", &goto_addr) == 1) {
+                GotoAddr = goto_addr - base_display_addr;
+                HighlightMin = HighlightMax = (size_t)-1;
+            }
+        }
+
+        if (GotoAddr != (size_t)-1) {
+            if (GotoAddr < mem_size) {
+                ImGui::BeginChild("##scrolling");
+                ImGui::SetScrollFromPosY(ImGui::GetCursorStartPos().y +
+                                         (GotoAddr / Cols) * ImGui::GetTextLineHeight());
+                ImGui::EndChild();
+                DataEditingAddr = DataPreviewAddr = GotoAddr;
+                DataEditingTakeFocus = true;
+            }
+            GotoAddr = (size_t)-1;
+        }
+
+        // if (MouseHovered)
+        //{
+        //     ImGui::SameLine();
+        //     ImGui::Text("Hovered: %p", MouseHoveredAddr);
+        // }
+    }
+
+    void DrawPreviewLine(const Sizes& s, void* mem_data_void, size_t mem_size,
+                         size_t base_display_addr) {
+        IM_UNUSED(base_display_addr);
+        ImU8* mem_data = (ImU8*)mem_data_void;
+        ImGuiStyle& style = ImGui::GetStyle();
+        ImGui::AlignTextToFramePadding();
+        ImGui::Text("Preview as:");
+        ImGui::SameLine();
+        ImGui::SetNextItemWidth((s.GlyphWidth * 10.0f) + style.FramePadding.x * 2.0f +
+                                style.ItemInnerSpacing.x);
+
+        static const ImGuiDataType supported_data_types[] = {
+            ImGuiDataType_S8,    ImGuiDataType_U8,    ImGuiDataType_S16, ImGuiDataType_U16,
+            ImGuiDataType_S32,   ImGuiDataType_U32,   ImGuiDataType_S64, ImGuiDataType_U64,
+            ImGuiDataType_Float, ImGuiDataType_Double};
+        if (ImGui::BeginCombo("##combo_type", DataTypeGetDesc(PreviewDataType),
+                              ImGuiComboFlags_HeightLargest)) {
+            for (int n = 0; n < IM_ARRAYSIZE(supported_data_types); n++) {
+                ImGuiDataType data_type = supported_data_types[n];
+                if (ImGui::Selectable(DataTypeGetDesc(data_type), PreviewDataType == data_type))
+                    PreviewDataType = data_type;
+            }
+            ImGui::EndCombo();
+        }
+        ImGui::SameLine();
+        ImGui::SetNextItemWidth((s.GlyphWidth * 6.0f) + style.FramePadding.x * 2.0f +
+                                style.ItemInnerSpacing.x);
+        ImGui::Combo("##combo_endianness", &PreviewEndianness, "LE\0BE\0\0");
+
+        char buf[128] = "";
+        float x = s.GlyphWidth * 6.0f;
+        bool has_value = DataPreviewAddr != (size_t)-1;
+        if (has_value)
+            DrawPreviewData(DataPreviewAddr, mem_data, mem_size, PreviewDataType, DataFormat_Dec,
+                            buf, (size_t)IM_ARRAYSIZE(buf));
+        ImGui::Text("Dec");
+        ImGui::SameLine(x);
+        ImGui::TextUnformatted(has_value ? buf : "N/A");
+        if (has_value)
+            DrawPreviewData(DataPreviewAddr, mem_data, mem_size, PreviewDataType, DataFormat_Hex,
+                            buf, (size_t)IM_ARRAYSIZE(buf));
+        ImGui::Text("Hex");
+        ImGui::SameLine(x);
+        ImGui::TextUnformatted(has_value ? buf : "N/A");
+        if (has_value)
+            DrawPreviewData(DataPreviewAddr, mem_data, mem_size, PreviewDataType, DataFormat_Bin,
+                            buf, (size_t)IM_ARRAYSIZE(buf));
+        buf[IM_ARRAYSIZE(buf) - 1] = 0;
+        ImGui::Text("Bin");
+        ImGui::SameLine(x);
+        ImGui::TextUnformatted(has_value ? buf : "N/A");
+    }
+
+    // Utilities for Data Preview (since we don't access imgui_internal.h)
+    // FIXME: This technically depends on ImGuiDataType order.
+    const char* DataTypeGetDesc(ImGuiDataType data_type) const {
+        const char* descs[] = {"Int8",   "Uint8", "Int16",  "Uint16", "Int32",
+                               "Uint32", "Int64", "Uint64", "Float",  "Double"};
+        IM_ASSERT(data_type >= 0 && data_type < IM_ARRAYSIZE(descs));
+        return descs[data_type];
+    }
+
+    size_t DataTypeGetSize(ImGuiDataType data_type) const {
+        const size_t sizes[] = {1, 1, 2, 2, 4, 4, 8, 8, sizeof(float), sizeof(double)};
+        IM_ASSERT(data_type >= 0 && data_type < IM_ARRAYSIZE(sizes));
+        return sizes[data_type];
+    }
+
+    const char* DataFormatGetDesc(DataFormat data_format) const {
+        const char* descs[] = {"Bin", "Dec", "Hex"};
+        IM_ASSERT(data_format >= 0 && data_format < DataFormat_COUNT);
+        return descs[data_format];
+    }
+
+    bool IsBigEndian() const {
+        uint16_t x = 1;
+        char c[2];
+        memcpy(c, &x, 2);
+        return c[0] != 0;
+    }
+
+    static void* EndiannessCopyBigEndian(void* _dst, void* _src, size_t s, int is_little_endian) {
+        if (is_little_endian) {
+            uint8_t* dst = (uint8_t*)_dst;
+            uint8_t* src = (uint8_t*)_src + s - 1;
+            for (int i = 0, n = (int)s; i < n; ++i)
+                memcpy(dst++, src--, 1);
+            return _dst;
+        } else {
+            return memcpy(_dst, _src, s);
+        }
+    }
+
+    static void* EndiannessCopyLittleEndian(void* _dst, void* _src, size_t s,
+                                            int is_little_endian) {
+        if (is_little_endian) {
+            return memcpy(_dst, _src, s);
+        } else {
+            uint8_t* dst = (uint8_t*)_dst;
+            uint8_t* src = (uint8_t*)_src + s - 1;
+            for (int i = 0, n = (int)s; i < n; ++i)
+                memcpy(dst++, src--, 1);
+            return _dst;
+        }
+    }
+
+    void* EndiannessCopy(void* dst, void* src, size_t size) const {
+        static void* (*fp)(void*, void*, size_t, int) = nullptr;
+        if (fp == nullptr)
+            fp = IsBigEndian() ? EndiannessCopyBigEndian : EndiannessCopyLittleEndian;
+        return fp(dst, src, size, PreviewEndianness);
+    }
+
+    const char* FormatBinary(const uint8_t* buf, int width) const {
+        IM_ASSERT(width <= 64);
+        size_t out_n = 0;
+        static char out_buf[64 + 8 + 1];
+        int n = width / 8;
+        for (int j = n - 1; j >= 0; --j) {
+            for (int i = 0; i < 8; ++i)
+                out_buf[out_n++] = (buf[j] & (1 << (7 - i))) ? '1' : '0';
+            out_buf[out_n++] = ' ';
+        }
+        IM_ASSERT(out_n < IM_ARRAYSIZE(out_buf));
+        out_buf[out_n] = 0;
+        return out_buf;
+    }
+
+    // [Internal]
+    void DrawPreviewData(size_t addr, const ImU8* mem_data, size_t mem_size,
+                         ImGuiDataType data_type, DataFormat data_format, char* out_buf,
+                         size_t out_buf_size) const {
+        uint8_t buf[8];
+        size_t elem_size = DataTypeGetSize(data_type);
+        size_t size = addr + elem_size > mem_size ? mem_size - addr : elem_size;
+        if (ReadFn)
+            for (int i = 0, n = (int)size; i < n; ++i)
+                buf[i] = ReadFn(mem_data, addr + i, UserData);
+        else
+            memcpy(buf, mem_data + addr, size);
+
+        if (data_format == DataFormat_Bin) {
+            uint8_t binbuf[8];
+            EndiannessCopy(binbuf, buf, size);
+            ImSnprintf(out_buf, out_buf_size, "%s", FormatBinary(binbuf, (int)size * 8));
+            return;
+        }
+
+        out_buf[0] = 0;
+        switch (data_type) {
+        case ImGuiDataType_S8: {
+            int8_t data = 0;
+            EndiannessCopy(&data, buf, size);
+            if (data_format == DataFormat_Dec) {
+                ImSnprintf(out_buf, out_buf_size, "%hhd", data);
+                return;
+            }
+            if (data_format == DataFormat_Hex) {
+                ImSnprintf(out_buf, out_buf_size, "0x%02x", data & 0xFF);
+                return;
+            }
+            break;
+        }
+        case ImGuiDataType_U8: {
+            uint8_t data = 0;
+            EndiannessCopy(&data, buf, size);
+            if (data_format == DataFormat_Dec) {
+                ImSnprintf(out_buf, out_buf_size, "%hhu", data);
+                return;
+            }
+            if (data_format == DataFormat_Hex) {
+                ImSnprintf(out_buf, out_buf_size, "0x%02x", data & 0XFF);
+                return;
+            }
+            break;
+        }
+        case ImGuiDataType_S16: {
+            int16_t data = 0;
+            EndiannessCopy(&data, buf, size);
+            if (data_format == DataFormat_Dec) {
+                ImSnprintf(out_buf, out_buf_size, "%hd", data);
+                return;
+            }
+            if (data_format == DataFormat_Hex) {
+                ImSnprintf(out_buf, out_buf_size, "0x%04x", data & 0xFFFF);
+                return;
+            }
+            break;
+        }
+        case ImGuiDataType_U16: {
+            uint16_t data = 0;
+            EndiannessCopy(&data, buf, size);
+            if (data_format == DataFormat_Dec) {
+                ImSnprintf(out_buf, out_buf_size, "%hu", data);
+                return;
+            }
+            if (data_format == DataFormat_Hex) {
+                ImSnprintf(out_buf, out_buf_size, "0x%04x", data & 0xFFFF);
+                return;
+            }
+            break;
+        }
+        case ImGuiDataType_S32: {
+            int32_t data = 0;
+            EndiannessCopy(&data, buf, size);
+            if (data_format == DataFormat_Dec) {
+                ImSnprintf(out_buf, out_buf_size, "%d", data);
+                return;
+            }
+            if (data_format == DataFormat_Hex) {
+                ImSnprintf(out_buf, out_buf_size, "0x%08x", data);
+                return;
+            }
+            break;
+        }
+        case ImGuiDataType_U32: {
+            uint32_t data = 0;
+            EndiannessCopy(&data, buf, size);
+            if (data_format == DataFormat_Dec) {
+                ImSnprintf(out_buf, out_buf_size, "%u", data);
+                return;
+            }
+            if (data_format == DataFormat_Hex) {
+                ImSnprintf(out_buf, out_buf_size, "0x%08x", data);
+                return;
+            }
+            break;
+        }
+        case ImGuiDataType_S64: {
+            int64_t data = 0;
+            EndiannessCopy(&data, buf, size);
+            if (data_format == DataFormat_Dec) {
+                ImSnprintf(out_buf, out_buf_size, "%lld", (long long)data);
+                return;
+            }
+            if (data_format == DataFormat_Hex) {
+                ImSnprintf(out_buf, out_buf_size, "0x%016llx", (long long)data);
+                return;
+            }
+            break;
+        }
+        case ImGuiDataType_U64: {
+            uint64_t data = 0;
+            EndiannessCopy(&data, buf, size);
+            if (data_format == DataFormat_Dec) {
+                ImSnprintf(out_buf, out_buf_size, "%llu", (long long)data);
+                return;
+            }
+            if (data_format == DataFormat_Hex) {
+                ImSnprintf(out_buf, out_buf_size, "0x%016llx", (long long)data);
+                return;
+            }
+            break;
+        }
+        case ImGuiDataType_Float: {
+            float data = 0.0f;
+            EndiannessCopy(&data, buf, size);
+            if (data_format == DataFormat_Dec) {
+                ImSnprintf(out_buf, out_buf_size, "%f", data);
+                return;
+            }
+            if (data_format == DataFormat_Hex) {
+                ImSnprintf(out_buf, out_buf_size, "%a", data);
+                return;
+            }
+            break;
+        }
+        case ImGuiDataType_Double: {
+            double data = 0.0;
+            EndiannessCopy(&data, buf, size);
+            if (data_format == DataFormat_Dec) {
+                ImSnprintf(out_buf, out_buf_size, "%f", data);
+                return;
+            }
+            if (data_format == DataFormat_Hex) {
+                ImSnprintf(out_buf, out_buf_size, "%a", data);
+                return;
+            }
+            break;
+        }
+        default:
+        case ImGuiDataType_COUNT:
+            break;
+        }             // Switch
+        IM_ASSERT(0); // Shouldn't reach
+    }
+};
+
+#undef _PRISizeT
+#undef ImSnprintf
+
+#ifdef _MSC_VER
+#pragma warning(pop)
+#endif
--- a/src/core/file_format/pkg.cpp
+++ b/src/core/file_format/pkg.cpp
@ -44,7 +44,7 @@ PKG::PKG() = default;

 PKG::~PKG() = default;

-bool PKG::Open(const std::filesystem::path& filepath) {
+bool PKG::Open(const std::filesystem::path& filepath, std::string& failreason) {
    Common::FS::IOFile file(filepath, Common::FS::FileAccessMode::Read);
    if (!file.IsOpen()) {
        return false;
@ -70,7 +70,11 @@ bool PKG::Open(const std::filesystem::path& filepath) {
    u32 offset = pkgheader.pkg_table_entry_offset;
    u32 n_files = pkgheader.pkg_table_entry_count;

-    file.Seek(offset);
+    if (!file.Seek(offset)) {
+        failreason = "Failed to seek to PKG table entry offset";
+        return false;
+    }
+
    for (int i = 0; i < n_files; i++) {
        PKGEntry entry{};
        file.Read(entry.id);
@ -85,7 +89,10 @@ bool PKG::Open(const std::filesystem::path& filepath) {
        const auto name = GetEntryNameByType(entry.id);
        if (name == "param.sfo") {
            sfo.clear();
-            file.Seek(entry.offset);
+            if (!file.Seek(entry.offset)) {
+                failreason = "Failed to seek to param.sfo offset";
+                return false;
+            }
            sfo.resize(entry.size);
            file.ReadRaw<u8>(sfo.data(), entry.size);
        }
@ -127,7 +134,11 @@ bool PKG::Extract(const std::filesystem::path& filepath, const std::filesystem::
    std::array<std::array<u8, 256>, 7> key1;
    std::array<u8, 256> imgkeydata;

-    file.Seek(offset);
+    if (!file.Seek(offset)) {
+        failreason = "Failed to seek to PKG table entry offset";
+        return false;
+    }
+
    for (int i = 0; i < n_files; i++) {
        PKGEntry entry{};
        file.Read(entry.id);
@ -149,7 +160,10 @@ bool PKG::Extract(const std::filesystem::path& filepath, const std::filesystem::
            // Just print with id
            Common::FS::IOFile out(extract_path / "sce_sys" / std::to_string(entry.id),
                                   Common::FS::FileAccessMode::Write);
-            file.Seek(entry.offset);
+            if (!file.Seek(entry.offset)) {
+                failreason = "Failed to seek to PKG entry offset";
+                return false;
+            }

            std::vector<u8> data;
            data.resize(entry.size);
@ -195,7 +209,10 @@ bool PKG::Extract(const std::filesystem::path& filepath, const std::filesystem::
        }

        Common::FS::IOFile out(extract_path / "sce_sys" / name, Common::FS::FileAccessMode::Write);
-        file.Seek(entry.offset);
+        if (!file.Seek(entry.offset)) {
+            failreason = "Failed to seek to PKG entry offset";
+            return false;
+        }

        std::vector<u8> data;
        data.resize(entry.size);
@ -207,7 +224,10 @@ bool PKG::Extract(const std::filesystem::path& filepath, const std::filesystem::
        if (entry.id == 0x400 || entry.id == 0x401 || entry.id == 0x402 ||
            entry.id == 0x403) { // somehow 0x401 is not decrypting
            decNp.resize(entry.size);
-            file.Seek(entry.offset);
+            if (!file.Seek(entry.offset)) {
+                failreason = "Failed to seek to PKG entry offset";
+                return false;
+            }

            std::vector<u8> data;
            data.resize(entry.size);
@ -229,15 +249,12 @@ bool PKG::Extract(const std::filesystem::path& filepath, const std::filesystem::
        file.Seek(currentPos);
    }

-    // Extract trophy files
-    if (!trp.Extract(extract_path)) {
-        // Do nothing some pkg come with no trp file.
-        // return false;
-    }
-
    // Read the seed
    std::array<u8, 16> seed;
-    file.Seek(pkgheader.pfs_image_offset + 0x370);
+    if (!file.Seek(pkgheader.pfs_image_offset + 0x370)) {
+        failreason = "Failed to seek to PFS image offset";
+        return false;
+    }
    file.Read(seed);

    // Get data and tweak keys.
@ -371,8 +388,7 @@ bool PKG::Extract(const std::filesystem::path& filepath, const std::filesystem::
                if (table.type == PFS_CURRENT_DIR) {
                    current_dir = extractPaths[table.inode];
                }
-                extractPaths[table.inode] =
-                    current_dir.string() / std::filesystem::path(table.name);
+                extractPaths[table.inode] = current_dir / std::filesystem::path(table.name);

                if (table.type == PFS_FILE || table.type == PFS_DIR) {
                    if (table.type == PFS_DIR) { // Create dirs.
@ -402,7 +418,7 @@ void PKG::ExtractFiles(const int index) {
        int bsize = iNodeBuf[inode_number].Size;

        Common::FS::IOFile inflated;
-        inflated.Open(extractPaths[inode_number].string(), Common::FS::FileAccessMode::Write);
+        inflated.Open(extractPaths[inode_number], Common::FS::FileAccessMode::Write);

        Common::FS::IOFile pkgFile; // Open the file for each iteration to avoid conflict.
        pkgFile.Open(pkgpath, Common::FS::FileAccessMode::Read);
--- a/src/core/file_format/pkg.h
+++ b/src/core/file_format/pkg.h
@ -103,7 +103,7 @@ public:
    PKG();
    ~PKG();

-    bool Open(const std::filesystem::path& filepath);
+    bool Open(const std::filesystem::path& filepath, std::string& failreason);
    void ExtractFiles(const int index);
    bool Extract(const std::filesystem::path& filepath, const std::filesystem::path& extract,
                 std::string& failreason);
--- a/src/core/file_format/psf.cpp
+++ b/src/core/file_format/psf.cpp
@ -2,61 +2,280 @@
 // SPDX-License-Identifier: GPL-2.0-or-later

 #include <cstring>
+
+#include "common/assert.h"
 #include "common/io_file.h"
+#include "common/logging/log.h"
 #include "core/file_format/psf.h"

-PSF::PSF() = default;
+static const std::unordered_map<std::string_view, u32> psf_known_max_sizes = {
+    {"ACCOUNT_ID", 8},  {"CATEGORY", 4},  {"DETAIL", 1024},       {"FORMAT", 4},
+    {"MAINTITLE", 128}, {"PARAMS", 1024}, {"SAVEDATA_BLOCKS", 8}, {"SAVEDATA_DIRECTORY", 32},
+    {"SUBTITLE", 128},  {"TITLE_ID", 12},
+};
+static inline u32 get_max_size(std::string_view key, u32 default_value) {
+    if (const auto& v = psf_known_max_sizes.find(key); v != psf_known_max_sizes.end()) {
+        return v->second;
+    }
+    return default_value;
+}

-PSF::~PSF() = default;
-
-bool PSF::open(const std::string& filepath, const std::vector<u8>& psfBuffer) {
-    if (!psfBuffer.empty()) {
-        psf.resize(psfBuffer.size());
-        psf = psfBuffer;
-    } else {
-        Common::FS::IOFile file(filepath, Common::FS::FileAccessMode::Read);
-        if (!file.IsOpen()) {
-            return false;
-        }
-
-        const u64 psfSize = file.GetSize();
-        psf.resize(psfSize);
-        file.Seek(0);
-        file.Read(psf);
-        file.Close();
+bool PSF::Open(const std::filesystem::path& filepath) {
+    if (std::filesystem::exists(filepath)) {
+        last_write = std::filesystem::last_write_time(filepath);
    }

-    // Parse file contents
-    PSFHeader header;
-    std::memcpy(&header, psf.data(), sizeof(header));
-    for (u32 i = 0; i < header.index_table_entries; i++) {
-        PSFEntry entry;
-        std::memcpy(&entry, &psf[sizeof(PSFHeader) + i * sizeof(PSFEntry)], sizeof(entry));
+    Common::FS::IOFile file(filepath, Common::FS::FileAccessMode::Read);
+    if (!file.IsOpen()) {
+        return false;
+    }

-        const std::string key = (char*)&psf[header.key_table_offset + entry.key_offset];
-        if (entry.param_fmt == PSFEntry::Fmt::TextRaw ||
-            entry.param_fmt == PSFEntry::Fmt::TextNormal) {
-            map_strings[key] = (char*)&psf[header.data_table_offset + entry.data_offset];
-        }
-        if (entry.param_fmt == PSFEntry::Fmt::Integer) {
-            u32 value;
-            std::memcpy(&value, &psf[header.data_table_offset + entry.data_offset], sizeof(value));
-            map_integers[key] = value;
+    const u64 psfSize = file.GetSize();
+    std::vector<u8> psf(psfSize);
+    file.Seek(0);
+    file.Read(psf);
+    file.Close();
+    return Open(psf);
+}
+
+bool PSF::Open(const std::vector<u8>& psf_buffer) {
+    const u8* psf_data = psf_buffer.data();
+
+    entry_list.clear();
+    map_binaries.clear();
+    map_strings.clear();
+    map_integers.clear();
+
+    // Parse file contents
+    PSFHeader header{};
+    std::memcpy(&header, psf_data, sizeof(header));
+
+    if (header.magic != PSF_MAGIC) {
+        LOG_ERROR(Core, "Invalid PSF magic number");
+        return false;
+    }
+    if (header.version != PSF_VERSION_1_1 && header.version != PSF_VERSION_1_0) {
+        LOG_ERROR(Core, "Unsupported PSF version: 0x{:08x}", header.version);
+        return false;
+    }
+
+    for (u32 i = 0; i < header.index_table_entries; i++) {
+        PSFRawEntry raw_entry{};
+        std::memcpy(&raw_entry, psf_data + sizeof(PSFHeader) + i * sizeof(PSFRawEntry),
+                    sizeof(raw_entry));
+
+        Entry& entry = entry_list.emplace_back();
+        entry.key = std::string{(char*)(psf_data + header.key_table_offset + raw_entry.key_offset)};
+        entry.param_fmt = static_cast<PSFEntryFmt>(raw_entry.param_fmt.Raw());
+        entry.max_len = raw_entry.param_max_len;
+
+        const u8* data = psf_data + header.data_table_offset + raw_entry.data_offset;
+
+        switch (entry.param_fmt) {
+        case PSFEntryFmt::Binary: {
+            std::vector<u8> value(raw_entry.param_len);
+            std::memcpy(value.data(), data, raw_entry.param_len);
+            map_binaries.emplace(i, std::move(value));
+        } break;
+        case PSFEntryFmt::Text: {
+            std::string c_str{reinterpret_cast<const char*>(data)};
+            map_strings.emplace(i, std::move(c_str));
+        } break;
+        case PSFEntryFmt::Integer: {
+            ASSERT_MSG(raw_entry.param_len == sizeof(s32), "PSF integer entry size mismatch");
+            s32 integer = *(s32*)data;
+            map_integers.emplace(i, integer);
+        } break;
+        default:
+            UNREACHABLE_MSG("Unknown PSF entry format");
        }
    }
    return true;
 }

-std::string PSF::GetString(const std::string& key) {
-    if (map_strings.find(key) != map_strings.end()) {
-        return map_strings.at(key);
+bool PSF::Encode(const std::filesystem::path& filepath) const {
+    Common::FS::IOFile file(filepath, Common::FS::FileAccessMode::Write);
+    if (!file.IsOpen()) {
+        return false;
    }
-    return "";
+
+    last_write = std::filesystem::file_time_type::clock::now();
+
+    const auto psf_buffer = Encode();
+    const size_t written = file.Write(psf_buffer);
+    if (written != psf_buffer.size()) {
+        LOG_ERROR(Core, "Failed to write PSF file. Written {} Expected {}", written,
+                  psf_buffer.size());
+    }
+    return written == psf_buffer.size();
 }

-u32 PSF::GetInteger(const std::string& key) {
-    if (map_integers.find(key) != map_integers.end()) {
-        return map_integers.at(key);
-    }
-    return -1;
+std::vector<u8> PSF::Encode() const {
+    std::vector<u8> psf_buffer;
+    Encode(psf_buffer);
+    return psf_buffer;
+}
+
+void PSF::Encode(std::vector<u8>& psf_buffer) const {
+    psf_buffer.resize(sizeof(PSFHeader) + sizeof(PSFRawEntry) * entry_list.size());
+
+    {
+        auto& header = *(PSFHeader*)psf_buffer.data();
+        header.magic = PSF_MAGIC;
+        header.version = PSF_VERSION_1_1;
+        header.index_table_entries = entry_list.size();
+    }
+
+    const size_t key_table_offset = psf_buffer.size();
+    ((PSFHeader*)psf_buffer.data())->key_table_offset = key_table_offset;
+    for (size_t i = 0; i < entry_list.size(); i++) {
+        auto& raw_entry = ((PSFRawEntry*)(psf_buffer.data() + sizeof(PSFHeader)))[i];
+        const Entry& entry = entry_list[i];
+        raw_entry.key_offset = psf_buffer.size() - key_table_offset;
+        raw_entry.param_fmt.FromRaw(static_cast<u16>(entry.param_fmt));
+        raw_entry.param_max_len = entry.max_len;
+        std::ranges::copy(entry.key, std::back_inserter(psf_buffer));
+        psf_buffer.push_back(0); // NULL terminator
+    }
+
+    const size_t data_table_offset = psf_buffer.size();
+    ((PSFHeader*)psf_buffer.data())->data_table_offset = data_table_offset;
+    for (size_t i = 0; i < entry_list.size(); i++) {
+        if (psf_buffer.size() % 4 != 0) {
+            std::ranges::fill_n(std::back_inserter(psf_buffer), 4 - psf_buffer.size() % 4, 0);
+        }
+        auto& raw_entry = ((PSFRawEntry*)(psf_buffer.data() + sizeof(PSFHeader)))[i];
+        const Entry& entry = entry_list[i];
+        raw_entry.data_offset = psf_buffer.size() - data_table_offset;
+
+        s32 additional_padding = s32(raw_entry.param_max_len);
+
+        switch (entry.param_fmt) {
+        case PSFEntryFmt::Binary: {
+            const auto& value = map_binaries.at(i);
+            raw_entry.param_len = value.size();
+            additional_padding -= s32(raw_entry.param_len);
+            std::ranges::copy(value, std::back_inserter(psf_buffer));
+        } break;
+        case PSFEntryFmt::Text: {
+            const auto& value = map_strings.at(i);
+            raw_entry.param_len = value.size() + 1;
+            additional_padding -= s32(raw_entry.param_len);
+            std::ranges::copy(value, std::back_inserter(psf_buffer));
+            psf_buffer.push_back(0); // NULL terminator
+        } break;
+        case PSFEntryFmt::Integer: {
+            const auto& value = map_integers.at(i);
+            raw_entry.param_len = sizeof(s32);
+            additional_padding -= s32(raw_entry.param_len);
+            const auto value_bytes = reinterpret_cast<const u8*>(&value);
+            std::ranges::copy(value_bytes, value_bytes + sizeof(s32),
+                              std::back_inserter(psf_buffer));
+        } break;
+        default:
+            UNREACHABLE_MSG("Unknown PSF entry format");
+        }
+        ASSERT_MSG(additional_padding >= 0, "PSF entry max size mismatch");
+        std::ranges::fill_n(std::back_inserter(psf_buffer), additional_padding, 0);
+    }
+}
+
+std::optional<std::span<const u8>> PSF::GetBinary(std::string_view key) const {
+    const auto& [it, index] = FindEntry(key);
+    if (it == entry_list.end()) {
+        return {};
+    }
+    ASSERT(it->param_fmt == PSFEntryFmt::Binary);
+    return std::span{map_binaries.at(index)};
+}
+
+std::optional<std::string_view> PSF::GetString(std::string_view key) const {
+    const auto& [it, index] = FindEntry(key);
+    if (it == entry_list.end()) {
+        return {};
+    }
+    ASSERT(it->param_fmt == PSFEntryFmt::Text);
+    return std::string_view{map_strings.at(index)};
+}
+
+std::optional<s32> PSF::GetInteger(std::string_view key) const {
+    const auto& [it, index] = FindEntry(key);
+    if (it == entry_list.end()) {
+        return {};
+    }
+    ASSERT(it->param_fmt == PSFEntryFmt::Integer);
+    return map_integers.at(index);
+}
+
+void PSF::AddBinary(std::string key, std::vector<u8> value, bool update) {
+    auto [it, index] = FindEntry(key);
+    bool exist = it != entry_list.end();
+    if (exist && !update) {
+        LOG_ERROR(Core, "PSF: Tried to add binary key that already exists: {}", key);
+        return;
+    }
+    if (exist) {
+        ASSERT_MSG(it->param_fmt == PSFEntryFmt::Binary, "PSF: Change format is not supported");
+        it->max_len = get_max_size(key, value.size());
+        map_binaries.at(index) = std::move(value);
+        return;
+    }
+    Entry& entry = entry_list.emplace_back();
+    entry.max_len = get_max_size(key, value.size());
+    entry.key = std::move(key);
+    entry.param_fmt = PSFEntryFmt::Binary;
+    map_binaries.emplace(entry_list.size() - 1, std::move(value));
+}
+
+void PSF::AddString(std::string key, std::string value, bool update) {
+    auto [it, index] = FindEntry(key);
+    bool exist = it != entry_list.end();
+    if (exist && !update) {
+        LOG_ERROR(Core, "PSF: Tried to add string key that already exists: {}", key);
+        return;
+    }
+    if (exist) {
+        ASSERT_MSG(it->param_fmt == PSFEntryFmt::Text, "PSF: Change format is not supported");
+        it->max_len = get_max_size(key, value.size() + 1);
+        map_strings.at(index) = std::move(value);
+        return;
+    }
+    Entry& entry = entry_list.emplace_back();
+    entry.max_len = get_max_size(key, value.size() + 1);
+    entry.key = std::move(key);
+    entry.param_fmt = PSFEntryFmt::Text;
+    map_strings.emplace(entry_list.size() - 1, std::move(value));
+}
+
+void PSF::AddInteger(std::string key, s32 value, bool update) {
+    auto [it, index] = FindEntry(key);
+    bool exist = it != entry_list.end();
+    if (exist && !update) {
+        LOG_ERROR(Core, "PSF: Tried to add integer key that already exists: {}", key);
+        return;
+    }
+    if (exist) {
+        ASSERT_MSG(it->param_fmt == PSFEntryFmt::Integer, "PSF: Change format is not supported");
+        it->max_len = sizeof(s32);
+        map_integers.at(index) = value;
+        return;
+    }
+    Entry& entry = entry_list.emplace_back();
+    entry.key = std::move(key);
+    entry.param_fmt = PSFEntryFmt::Integer;
+    entry.max_len = sizeof(s32);
+    map_integers.emplace(entry_list.size() - 1, value);
+}
+
+std::pair<std::vector<PSF::Entry>::iterator, size_t> PSF::FindEntry(std::string_view key) {
+    auto entry =
+        std::ranges::find_if(entry_list, [&](const auto& entry) { return entry.key == key; });
+    return {entry, std::distance(entry_list.begin(), entry)};
+}
+
+std::pair<std::vector<PSF::Entry>::const_iterator, size_t> PSF::FindEntry(
+    std::string_view key) const {
+    auto entry =
+        std::ranges::find_if(entry_list, [&](const auto& entry) { return entry.key == key; });
+    return {entry, std::distance(entry_list.begin(), entry)};
 }
--- a/src/core/file_format/psf.h
+++ b/src/core/file_format/psf.h
@ -3,11 +3,18 @@

 #pragma once

+#include <filesystem>
+#include <span>
 #include <string>
+#include <string_view>
 #include <unordered_map>
 #include <vector>
 #include "common/endian.h"

+constexpr u32 PSF_MAGIC = 0x00505346;
+constexpr u32 PSF_VERSION_1_1 = 0x00000101;
+constexpr u32 PSF_VERSION_1_0 = 0x00000100;
+
 struct PSFHeader {
    u32_be magic;
    u32_le version;
@ -15,34 +22,72 @@ struct PSFHeader {
    u32_le data_table_offset;
    u32_le index_table_entries;
 };
+static_assert(sizeof(PSFHeader) == 0x14);

-struct PSFEntry {
-    enum Fmt : u16 {
-        TextRaw = 0x0400,    // String in UTF-8 format and not NULL terminated
-        TextNormal = 0x0402, // String in UTF-8 format and NULL terminated
-        Integer = 0x0404,    // Unsigned 32-bit integer
-    };
-
+struct PSFRawEntry {
    u16_le key_offset;
    u16_be param_fmt;
    u32_le param_len;
    u32_le param_max_len;
    u32_le data_offset;
 };
+static_assert(sizeof(PSFRawEntry) == 0x10);
+
+enum class PSFEntryFmt : u16 {
+    Binary = 0x0004,  // Binary data
+    Text = 0x0204,    // String in UTF-8 format and NULL terminated
+    Integer = 0x0404, // Signed 32-bit integer
+};

 class PSF {
+    struct Entry {
+        std::string key;
+        PSFEntryFmt param_fmt;
+        u32 max_len;
+    };
+
 public:
-    PSF();
-    ~PSF();
+    PSF() = default;
+    ~PSF() = default;

-    bool open(const std::string& filepath, const std::vector<u8>& psfBuffer);
+    PSF(const PSF& other) = default;
+    PSF(PSF&& other) noexcept = default;
+    PSF& operator=(const PSF& other) = default;
+    PSF& operator=(PSF&& other) noexcept = default;

-    std::string GetString(const std::string& key);
-    u32 GetInteger(const std::string& key);
+    bool Open(const std::filesystem::path& filepath);
+    bool Open(const std::vector<u8>& psf_buffer);

-    std::unordered_map<std::string, std::string> map_strings;
-    std::unordered_map<std::string, u32> map_integers;
+    [[nodiscard]] std::vector<u8> Encode() const;
+    void Encode(std::vector<u8>& buf) const;
+    bool Encode(const std::filesystem::path& filepath) const;
+
+    std::optional<std::span<const u8>> GetBinary(std::string_view key) const;
+    std::optional<std::string_view> GetString(std::string_view key) const;
+    std::optional<s32> GetInteger(std::string_view key) const;
+
+    void AddBinary(std::string key, std::vector<u8> value, bool update = false);
+    void AddString(std::string key, std::string value, bool update = false);
+    void AddInteger(std::string key, s32 value, bool update = false);
+
+    [[nodiscard]] std::filesystem::file_time_type GetLastWrite() const {
+        return last_write;
+    }
+
+    [[nodiscard]] const std::vector<Entry>& GetEntries() const {
+        return entry_list;
+    }

 private:
-    std::vector<u8> psf;
+    mutable std::filesystem::file_time_type last_write;
+
+    std::vector<Entry> entry_list;
+
+    std::unordered_map<size_t, std::vector<u8>> map_binaries;
+    std::unordered_map<size_t, std::string> map_strings;
+    std::unordered_map<size_t, s32> map_integers;
+
+    [[nodiscard]] std::pair<std::vector<Entry>::iterator, size_t> FindEntry(std::string_view key);
+    [[nodiscard]] std::pair<std::vector<Entry>::const_iterator, size_t> FindEntry(
+        std::string_view key) const;
 };
--- a/src/core/file_format/splash.cpp
+++ b/src/core/file_format/splash.cpp
@ -12,8 +12,8 @@
 #define STBI_NO_STDIO
 #include "externals/stb_image.h"

-bool Splash::Open(const std::string& filepath) {
-    ASSERT_MSG(filepath.ends_with(".png"), "Unexpected file format passed");
+bool Splash::Open(const std::filesystem::path& filepath) {
+    ASSERT_MSG(filepath.stem().string() != "png", "Unexpected file format passed");

    Common::FS::IOFile file(filepath, Common::FS::FileAccessMode::Read);
    if (!file.IsOpen()) {
--- a/src/core/file_format/splash.h
+++ b/src/core/file_format/splash.h
@ -3,6 +3,7 @@

 #pragma once

+#include <filesystem>
 #include <string>
 #include <vector>
 #include "common/types.h"
@ -22,7 +23,7 @@ public:
    Splash() = default;
    ~Splash() = default;

-    bool Open(const std::string& filepath);
+    bool Open(const std::filesystem::path& filepath);
    [[nodiscard]] bool IsLoaded() const {
        return img_data.size();
    }
--- a/src/core/file_format/trp.cpp
+++ b/src/core/file_format/trp.cpp
@ -1,6 +1,7 @@
 // SPDX-FileCopyrightText: Copyright 2024 shadPS4 Emulator Project
 // SPDX-License-Identifier: GPL-2.0-or-later

+#include "common/logging/log.h"
 #include "common/path_util.h"
 #include "trp.h"

@ -11,9 +12,13 @@ void TRP::GetNPcommID(const std::filesystem::path& trophyPath, int index) {
    std::filesystem::path trpPath = trophyPath / "sce_sys/npbind.dat";
    Common::FS::IOFile npbindFile(trpPath, Common::FS::FileAccessMode::Read);
    if (!npbindFile.IsOpen()) {
+        LOG_CRITICAL(Common_Filesystem, "Failed to open npbind.dat file");
+        return;
+    }
+    if (!npbindFile.Seek(0x84 + (index * 0x180))) {
+        LOG_CRITICAL(Common_Filesystem, "Failed to seek to NPbind offset");
        return;
    }
-    npbindFile.Seek(0x84 + (index * 0x180));
    npbindFile.ReadRaw<u8>(np_comm_id.data(), 12);
    std::fill(np_comm_id.begin() + 12, np_comm_id.end(), 0); // fill with 0, we need 16 bytes.
 }
@ -28,10 +33,10 @@ static void removePadding(std::vector<u8>& vec) {
    }
 }

-bool TRP::Extract(const std::filesystem::path& trophyPath) {
-    std::string title = trophyPath.filename().string();
+bool TRP::Extract(const std::filesystem::path& trophyPath, const std::string titleId) {
    std::filesystem::path gameSysDir = trophyPath / "sce_sys/trophy/";
    if (!std::filesystem::exists(gameSysDir)) {
+        LOG_CRITICAL(Common_Filesystem, "Game sce_sys directory doesn't exist");
        return false;
    }
    for (int index = 0; const auto& it : std::filesystem::directory_iterator(gameSysDir)) {
@ -40,42 +45,57 @@ bool TRP::Extract(const std::filesystem::path& trophyPath) {

            Common::FS::IOFile file(it.path(), Common::FS::FileAccessMode::Read);
            if (!file.IsOpen()) {
+                LOG_CRITICAL(Common_Filesystem, "Unable to open trophy file for read");
                return false;
            }

            TrpHeader header;
            file.Read(header);
-            if (header.magic != 0xDCA24D00)
+            if (header.magic != 0xDCA24D00) {
+                LOG_CRITICAL(Common_Filesystem, "Wrong trophy magic number");
                return false;
+            }

            s64 seekPos = sizeof(TrpHeader);
            std::filesystem::path trpFilesPath(
-                Common::FS::GetUserPath(Common::FS::PathType::MetaDataDir) / title / "TrophyFiles" /
-                it.path().stem());
+                Common::FS::GetUserPath(Common::FS::PathType::MetaDataDir) / titleId /
+                "TrophyFiles" / it.path().stem());
            std::filesystem::create_directories(trpFilesPath / "Icons");
            std::filesystem::create_directory(trpFilesPath / "Xml");

            for (int i = 0; i < header.entry_num; i++) {
-                file.Seek(seekPos);
+                if (!file.Seek(seekPos)) {
+                    LOG_CRITICAL(Common_Filesystem, "Failed to seek to TRP entry offset");
+                    return false;
+                }
                seekPos += (s64)header.entry_size;
                TrpEntry entry;
                file.Read(entry);
                std::string_view name(entry.entry_name);
                if (entry.flag == 0 && name.find("TROP") != std::string::npos) { // PNG
-                    file.Seek(entry.entry_pos);
+                    if (!file.Seek(entry.entry_pos)) {
+                        LOG_CRITICAL(Common_Filesystem, "Failed to seek to TRP entry offset");
+                        return false;
+                    }
                    std::vector<u8> icon(entry.entry_len);
                    file.Read(icon);
                    Common::FS::IOFile::WriteBytes(trpFilesPath / "Icons" / name, icon);
                }
                if (entry.flag == 3 && np_comm_id[0] == 'N' &&
                    np_comm_id[1] == 'P') { // ESFM, encrypted.
-                    file.Seek(entry.entry_pos);
+                    if (!file.Seek(entry.entry_pos)) {
+                        LOG_CRITICAL(Common_Filesystem, "Failed to seek to TRP entry offset");
+                        return false;
+                    }
                    file.Read(esfmIv); // get iv key.
                    // Skip the first 16 bytes which are the iv key on every entry as we want a
                    // clean xml file.
                    std::vector<u8> ESFM(entry.entry_len - iv_len);
                    std::vector<u8> XML(entry.entry_len - iv_len);
-                    file.Seek(entry.entry_pos + iv_len);
+                    if (!file.Seek(entry.entry_pos + iv_len)) {
+                        LOG_CRITICAL(Common_Filesystem, "Failed to seek to TRP entry + iv offset");
+                        return false;
+                    }
                    file.Read(ESFM);
                    crypto.decryptEFSM(np_comm_id, esfmIv, ESFM, XML); // decrypt
                    removePadding(XML);
@ -83,7 +103,14 @@ bool TRP::Extract(const std::filesystem::path& trophyPath) {
                    size_t pos = xml_name.find("ESFM");
                    if (pos != std::string::npos)
                        xml_name.replace(pos, xml_name.length(), "XML");
-                    Common::FS::IOFile::WriteBytes(trpFilesPath / "Xml" / xml_name, XML);
+                    std::filesystem::path path = trpFilesPath / "Xml" / xml_name;
+                    size_t written = Common::FS::IOFile::WriteBytes(path, XML);
+                    if (written != XML.size()) {
+                        LOG_CRITICAL(
+                            Common_Filesystem,
+                            "Trophy XML {} write failed, wanted to write {} bytes, wrote {}",
+                            fmt::UTF(path.u8string()), XML.size(), written);
+                    }
                }
            }
        }
--- a/src/core/file_format/trp.h
+++ b/src/core/file_format/trp.h
@ -33,7 +33,7 @@ class TRP {
 public:
    TRP();
    ~TRP();
-    bool Extract(const std::filesystem::path& trophyPath);
+    bool Extract(const std::filesystem::path& trophyPath, const std::string titleId);
    void GetNPcommID(const std::filesystem::path& trophyPath, int index);

 private:
--- a/Show more
+++ b/Show more
				`@ -0,0 +1 @@`
				`Subproject commit 3b17184379fcaaeb7f1fbe08018b7fedf2640b3b`