diff --git a/.clang-format b/.clang-format
new file mode 100644
index 00000000..0cef9ae4
--- /dev/null
+++ b/.clang-format
@@ -0,0 +1,66 @@
+AlignAfterOpenBracket: Align
+AlignConsecutiveAssignments: false
+AlignConsecutiveDeclarations: false
+AlignEscapedNewlinesLeft: false
+AlignOperands: true
+AlignTrailingComments: true
+AllowShortBlocksOnASingleLine: Empty
+AllowShortCaseLabelsOnASingleLine: false
+AllowShortEnumsOnASingleLine: true
+AllowShortFunctionsOnASingleLine: Empty
+AllowShortIfStatementsOnASingleLine: false
+AllowShortLambdasOnASingleLine: Inline
+AlwaysBreakTemplateDeclarations: true
+BinPackArguments: true
+BinPackParameters: true
+BraceWrapping:
+  AfterCaseLabel: true
+  AfterClass: true
+  AfterControlStatement: Always
+  AfterEnum: true
+  AfterExternBlock: true
+  AfterFunction: true
+  AfterNamespace: true
+  AfterStruct: true
+  AfterUnion: true
+  BeforeElse: true
+  BeforeWhile: true
+  SplitEmptyFunction: false
+BreakBeforeBraces: Custom
+BreakBeforeTernaryOperators: true
+ColumnLimit: 0
+ConstructorInitializerAllOnOneLineOrOnePerLine: false
+ConstructorInitializerIndentWidth: 4
+ContinuationIndentWidth: 4
+Cpp11BracedListStyle: true
+IndentWidth: 4
+KeepEmptyLinesAtTheStartOfBlocks: false
+Language: Cpp
+MaxEmptyLinesToKeep: 1
+NamespaceIndentation: All
+ObjCSpaceAfterProperty: false
+PointerAlignment: Left
+ReflowComments: true
+SortIncludes: false
+SortUsingDeclarations: true
+SpaceAfterCStyleCast: false
+SpaceBeforeCtorInitializerColon: true
+SpaceAfterLogicalNot: false
+SpaceAfterTemplateKeyword: false
+SpaceBeforeAssignmentOperators: true
+SpaceBeforeCaseColon: false
+SpaceBeforeParens: ControlStatements
+SpaceBeforeRangeBasedForLoopColon: true
+SpaceBeforeSquareBrackets: false
+SpaceInEmptyBlock: false
+SpaceInEmptyParentheses: false
+SpacesBeforeTrailingComments: 1
+SpacesInAngles: false
+SpacesInCStyleCastParentheses: false
+SpacesInConditionalStatement: false
+SpacesInContainerLiterals: true
+SpacesInParentheses: false
+SpacesInSquareBrackets: false
+Standard: Latest
+TabWidth: 4
+UseTab: Always
diff --git a/.github/ISSUE_TEMPLATE/bug-report-feature-request.md b/.github/ISSUE_TEMPLATE/bug-report-feature-request.md
deleted file mode 100644
index 05eebe54..00000000
--- a/.github/ISSUE_TEMPLATE/bug-report-feature-request.md
+++ /dev/null
@@ -1,34 +0,0 @@
----
-name: Bug Report / Feature Request
-about: Tech support does not belong here. You should only file an issue here if you think you have experienced an actual bug with Cemu or you are requesting a feature you believe would make Cemu better.
-title: ''
-labels: ''
-assignees: ''
-
----
-
-<!---
-Please keep in mind Cemu is EXPERIMENTAL SOFTWARE.
-
-Please read the FAQ:
-https://cemu.info/faq.html/
-
-THIS IS NOT A SUPPORT FORUM, FOR SUPPORT GO TO:
-https://discord.com/invite/5psYsup/
-
-If the FAQ does not answer your question, please go to:
-https://discord.com/invite/5psYsup/
-
-When submitting an issue, please check the following:
-
-- You have read the above.
-- You have provided the version (commit hash) of Cemu you are using.
-- You have provided sufficient detail for the issue to be reproduced.
-- You have provided system specs (if relevant).
-- Please also provide:
-  - For any issues, a log file
-  - For crashes, a backtrace.
-  - For graphical issues, comparison screenshots with real hardware.
-  - For emulation inaccuracies, a test-case (if able).
-
--->
diff --git a/.github/ISSUE_TEMPLATE/config.yml b/.github/ISSUE_TEMPLATE/config.yml
index d33d87ed..d71e22d0 100644
--- a/.github/ISSUE_TEMPLATE/config.yml
+++ b/.github/ISSUE_TEMPLATE/config.yml
@@ -2,4 +2,4 @@ blank_issues_enabled: false
 contact_links:
   - name: Cemu Discord
     url: https://discord.com/invite/5psYsup
-    about: If you are experiencing an issue with Cemu, and you need tech support, or if you have a general question, try asking in the official Cemu Discord linked here. Piracy is not allowed.
+    about: If you need technical support with Cemu or have other questions the best place to ask is on the official Cemu Discord linked here
diff --git a/.github/ISSUE_TEMPLATE/emulation_bug_report.yaml b/.github/ISSUE_TEMPLATE/emulation_bug_report.yaml
new file mode 100644
index 00000000..75928607
--- /dev/null
+++ b/.github/ISSUE_TEMPLATE/emulation_bug_report.yaml
@@ -0,0 +1,69 @@
+# Docs - https://docs.github.com/en/communities/using-templates-to-encourage-useful-issues-and-pull-requests/syntax-for-githubs-form-schema
+name: Bug Report
+description: Report an issue with Cemu emulator
+title: "Enter a title for the bug report here"
+labels: bug
+body:
+  - type: markdown
+    id: md_readme
+    attributes:
+      value: |
+        ## Important: Read First
+        
+        If you discovered a bug you can report it here. Please make sure of the following first:
+        - That you are using the latest version of Cemu
+        - Only report something if you are sure it's a bug and not any technical issue on your end. For troubleshooting help see the [links page](https://github.com/cemu-project/Cemu#links)
+        - Problems specific to a single game should be reported on the [compatibility wiki](https://wiki.cemu.info/wiki/Main_Page) instead
+        - Verify that your problem isn't already mentioned on the [issue tracker](https://github.com/cemu-project/Cemu/issues)
+        
+        Additionally, be aware that graphic packs can also causes issues. There is a separate issue tracker for graphic pack bugs over at the [graphic pack repository](https://github.com/cemu-project/cemu_graphic_packs)
+  - type: textarea
+    id: current_behavior
+    attributes:
+      label: Current Behavior
+      description: "What the bug is, in a brief description"
+    validations:
+      required: true
+  - type: textarea
+    id: expected_behavior
+    attributes:
+      label: Expected Behavior
+      description: "What did you expect to happen?"
+    validations:
+      required: true
+
+  - type: textarea
+    id: steps_to_reproduce
+    attributes:
+      label: Steps to Reproduce
+      description: "How to reproduce the issue"
+    validations:
+      required: true
+  - type: textarea
+    id: sys_info
+    attributes:
+      label: System Info (Optional)
+      description: "Your PC specifications. Usually only the operating system and graphics card is important. But feel free to add more info."
+      placeholder: |
+        Info        
+        OS: Windows 10
+        GPU: NVIDIA GeForce RTX 4090
+      value: |
+        OS: 
+        GPU: 
+  - type: textarea
+    id: emulation_settings
+    attributes:
+      label: Emulation Settings (Optional)
+      description: |
+        Any non-default settings. You can leave this empty if you didn't change anything other than input settings.
+    validations:
+      required: false
+  - type: textarea
+    id: logs_files
+    attributes:
+      label: "Logs (Optional)"
+      description: |
+        "Attach `log.txt` from your Cemu folder (*File > Open Cemu folder*)".
+    validations:
+      required: false
diff --git a/.github/ISSUE_TEMPLATE/feature_report.yaml b/.github/ISSUE_TEMPLATE/feature_report.yaml
new file mode 100644
index 00000000..a5d8705c
--- /dev/null
+++ b/.github/ISSUE_TEMPLATE/feature_report.yaml
@@ -0,0 +1,28 @@
+# Docs - https://docs.github.com/en/communities/using-templates-to-encourage-useful-issues-and-pull-requests/syntax-for-githubs-form-schema
+name: Feature suggestion
+description: Suggest a new feature
+title: "Enter a title for the suggestion here"
+labels: feature request
+body:
+  - type: markdown
+    id: md_readme
+    attributes:
+      value: |
+        ## Important: Read First
+        
+        While we appreciate suggestions, it is important to note that we are a very small team and there are already many more ideas than we could ever implement in the near future. Therefore, please only suggest something if you believe it is a great addition and the idea is reasonably unique.
+        
+        *Avoid* to create suggestions for:
+        - Overly obvious features ("Game xyz does not work and should be fixed", "Wiimote support should be improved", "You should add an Android port", "Copy feature xyz from another emulator", "A button to pause/stop emulation")
+        - Niche features which are only interesting to a tiny percentage of users
+        - Large scale features ("Add a Metal backend for MacOS", "Add ARM support", "Add savestates")
+         
+        Note that this doesn't mean we aren't interested in these ideas, but rather we likely have them planned anyway and it's mostly up to finding the time to implement them.
+        If you believe your idea is worthwhile even if it doesn't meet all the criteria above, you can still try suggesting it but we might close it.        
+  - type: textarea
+    id: idea_suggestion
+    attributes:
+      label: Your suggestion
+      description: "Describe what your suggestion is in as much detail as possible"
+    validations:
+      required: true
diff --git a/.github/getversion.cpp b/.github/getversion.cpp
deleted file mode 100644
index 469a796e..00000000
--- a/.github/getversion.cpp
+++ /dev/null
@@ -1,9 +0,0 @@
-#include <stdio.h>
-#include "./../src/Common/version.h"
-
-// output current Cemu version for CI workflow. Do not modify
-int main()
-{
-   printf("%d.%d", EMULATOR_VERSION_LEAD, EMULATOR_VERSION_MAJOR);
-   return 0;
-}
diff --git a/.github/workflows/build.yml b/.github/workflows/build.yml
index 362cf3bc..e798c1a7 100644
--- a/.github/workflows/build.yml
+++ b/.github/workflows/build.yml
@@ -3,10 +3,10 @@ name: Build Cemu
 on:
   workflow_call:
     inputs:
-      deploymode:
+      next_version_major:
         required: false
         type: string
-      experimentalversion:
+      next_version_minor:
         required: false
         type: string
 
@@ -16,40 +16,40 @@ env:
 
 jobs:
   build-ubuntu:
-    runs-on: ubuntu-20.04
+    runs-on: ubuntu-22.04
     steps:
     - name: "Checkout repo"
-      uses: actions/checkout@v3
+      uses: actions/checkout@v4
       with:
         submodules: "recursive"
-        
-    - name: Setup release mode parameters (for deploy)
-      if: ${{ inputs.deploymode == 'release' }}
+        fetch-depth: 0
+
+    - name: Setup release mode parameters
       run: |
         echo "BUILD_MODE=release" >> $GITHUB_ENV
-        echo "BUILD_FLAGS=-DPUBLIC_RELEASE=ON" >> $GITHUB_ENV
-        echo "Build mode is release"
-    - name: Setup debug mode parameters (for continous build)
-      if: ${{ inputs.deploymode != 'release' }}
-      run: |
-        echo "BUILD_MODE=debug" >> $GITHUB_ENV
         echo "BUILD_FLAGS=" >> $GITHUB_ENV
-        echo "Build mode is debug"
-        
-    - name: Setup version for experimental
-      if: ${{ inputs.experimentalversion != '' }}
+        echo "Build mode is release"
+
+    - name: Setup build flags for version
+      if: ${{ inputs.next_version_major != '' }}
       run: |
-        echo "[INFO] Experimental version ${{ inputs.experimentalversion }}"
-        echo "BUILD_FLAGS=${{ env.BUILD_FLAGS }} -DEXPERIMENTAL_VERSION=${{ inputs.experimentalversion }}" >> $GITHUB_ENV
-        
+        echo "[INFO] Version ${{ inputs.next_version_major }}.${{ inputs.next_version_minor }}"
+        echo "BUILD_FLAGS=${{ env.BUILD_FLAGS }} -DEMULATOR_VERSION_MAJOR=${{ inputs.next_version_major }} -DEMULATOR_VERSION_MINOR=${{ inputs.next_version_minor }}" >> $GITHUB_ENV
+
     - name: "Install system dependencies"
       run: |
         sudo apt update -qq
-        sudo apt install -y ninja-build cmake libgtk-3-dev libsecret-1-dev libgcrypt20-dev libsystemd-dev freeglut3-dev clang-12 nasm
+        sudo apt install -y clang-15 cmake freeglut3-dev libgcrypt20-dev libglm-dev libgtk-3-dev libpulse-dev libsecret-1-dev libsystemd-dev libudev-dev nasm ninja-build libbluetooth-dev
+
+    - name: "Setup cmake"
+      uses: jwlawson/actions-setup-cmake@v2
+      with:
+        cmake-version: '3.29.0'
+
     - name: "Bootstrap vcpkg"
       run: |
         bash ./dependencies/vcpkg/bootstrap-vcpkg.sh
-        
+
     - name: 'Setup NuGet Credentials for vcpkg'
       shell: 'bash'
       run: |
@@ -66,89 +66,74 @@ jobs:
         
     - name: "cmake"
       run: |
-        mkdir -p build
-        cd build
-        cmake .. ${{ env.BUILD_FLAGS }} -DCMAKE_BUILD_TYPE=${{ env.BUILD_MODE }} -DCMAKE_C_COMPILER=/usr/bin/clang-12 -DCMAKE_CXX_COMPILER=/usr/bin/clang++-12 -G Ninja -DCMAKE_MAKE_PROGRAM=/usr/bin/ninja
+        cmake -S . -B build ${{ env.BUILD_FLAGS }} -DCMAKE_BUILD_TYPE=${{ env.BUILD_MODE }} -DCMAKE_C_COMPILER=/usr/bin/clang-15 -DCMAKE_CXX_COMPILER=/usr/bin/clang++-15 -G Ninja -DCMAKE_MAKE_PROGRAM=/usr/bin/ninja
         
     - name: "Build Cemu"
       run: |
-        cd build
-        ninja
-
+        cmake --build build
+        
     - name: Prepare artifact
-      if: ${{ inputs.deploymode == 'release' }}
       run: mv bin/Cemu_release bin/Cemu
               
     - name: Upload artifact
-      uses: actions/upload-artifact@v3
-      if: ${{ inputs.deploymode == 'release' }}
+      uses: actions/upload-artifact@v4
       with:
         name: cemu-bin-linux-x64
         path: ./bin/Cemu
-        
-        
+
+  build-appimage:
+    runs-on: ubuntu-22.04
+    needs: build-ubuntu
+    steps:
+    - name: Checkout Upstream Repo
+      uses: actions/checkout@v4
+
+    - uses: actions/download-artifact@v4
+      with:
+        name: cemu-bin-linux-x64
+        path: bin
+
+    - name: "Install system dependencies"
+      run: |
+        sudo apt update -qq
+        sudo apt install -y clang-15 cmake freeglut3-dev libgcrypt20-dev libglm-dev libgtk-3-dev libpulse-dev libsecret-1-dev libsystemd-dev nasm ninja-build appstream libbluetooth-dev
+
+    - name: "Build AppImage"
+      run: |
+        export LD_LIBRARY_PATH="/usr/local/lib:$LD_LIBRARY_PATH"
+        export DEPLOY_GTK_VERSION=3
+        dist/linux/appimage.sh
+
+    - name: Upload artifact
+      uses: actions/upload-artifact@v4
+      with:
+        name: cemu-appimage-x64
+        path: artifacts
+
   build-windows:
     runs-on: windows-2022
     steps:
     - name: "Checkout repo"
-      uses: actions/checkout@v3
+      uses: actions/checkout@v4
       with:
         submodules: "recursive"
-        
-    - name: Setup release mode parameters (for deploy)
-      if: ${{ inputs.deploymode == 'release' }}
+
+    - name: Setup release mode parameters
       run: |
         echo "BUILD_MODE=release" | Out-File -FilePath $Env:GITHUB_ENV -Encoding utf8 -Append
-        echo "BUILD_FLAGS=-DPUBLIC_RELEASE=ON" | Out-File -FilePath $Env:GITHUB_ENV -Encoding utf8 -Append
-        echo "Build mode is release"
-        
-    - name: Setup debug mode parameters (for continous build)
-      if: ${{ inputs.deploymode != 'release' }}
-      run: |
-        echo "BUILD_MODE=debug" | Out-File -FilePath $Env:GITHUB_ENV -Encoding utf8 -Append
         echo "BUILD_FLAGS=" | Out-File -FilePath $Env:GITHUB_ENV -Encoding utf8 -Append
-        echo "Build mode is debug"
-    - name: Setup version for experimental
-      if: ${{ inputs.experimentalversion != '' }}
+        echo "Build mode is release"
+
+    - name: Setup build flags for version
+      if: ${{ inputs.next_version_major != '' }}
       run: |
-        echo "[INFO] Experimental version ${{ inputs.experimentalversion }}"
-        echo "BUILD_FLAGS=${{ env.BUILD_FLAGS }} -DEXPERIMENTAL_VERSION=${{ inputs.experimentalversion }}" | Out-File -FilePath $Env:GITHUB_ENV -Encoding utf8 -Append
-    
-    - name: Workaround
-      run: |
-        Set-Location "C:\Program Files (x86)\Microsoft Visual Studio\Installer\"
-        $InstallPath = "C:\Program Files\Microsoft Visual Studio\2022\Enterprise"
-        $componentsToRemove= @(
-          "Microsoft.VisualStudio.Component.VC.14.32.17.2.ARM"
-          "Microsoft.VisualStudio.Component.VC.14.32.17.2.ARM.Spectre"
-          "Microsoft.VisualStudio.Component.VC.14.32.17.2.ARM64"
-          "Microsoft.VisualStudio.Component.VC.14.32.17.2.ARM64.Spectre"
-          "Microsoft.VisualStudio.Component.VC.14.32.17.2.x86.x64"
-          "Microsoft.VisualStudio.Component.VC.14.32.17.2.x86.x64.Spectre"
-          "Microsoft.VisualStudio.Component.VC.14.32.17.2.ATL"
-          "Microsoft.VisualStudio.Component.VC.14.32.17.2.ATL.Spectre"
-          "Microsoft.VisualStudio.Component.VC.14.32.17.2.ATL.ARM"
-          "Microsoft.VisualStudio.Component.VC.14.32.17.2.ATL.ARM.Spectre"
-          "Microsoft.VisualStudio.Component.VC.14.32.17.2.ATL.ARM64"
-          "Microsoft.VisualStudio.Component.VC.14.32.17.2.ATL.ARM64.Spectre"
-          "Microsoft.VisualStudio.Component.VC.14.32.17.2.MFC"
-          "Microsoft.VisualStudio.Component.VC.14.32.17.2.MFC.Spectre"
-          "Microsoft.VisualStudio.Component.VC.14.32.17.2.MFC.ARM"
-          "Microsoft.VisualStudio.Component.VC.14.32.17.2.MFC.ARM.Spectre"
-          "Microsoft.VisualStudio.Component.VC.14.32.17.2.MFC.ARM64"
-          "Microsoft.VisualStudio.Component.VC.14.32.17.2.MFC.ARM64.Spectre"
-        )
-        [string]$workloadArgs = $componentsToRemove | ForEach-Object {" --remove " +  $_}
-        $Arguments = ('/c', "vs_installer.exe", 'modify', '--installPath', "`"$InstallPath`"",$workloadArgs, '--quiet', '--norestart', '--nocache')
-        # should be run twice
-        $process = Start-Process -FilePath cmd.exe -ArgumentList $Arguments -Wait -PassThru -WindowStyle Hidden
-        $process = Start-Process -FilePath cmd.exe -ArgumentList $Arguments -Wait -PassThru -WindowStyle Hidden
-    - name: Configure MSVC
-      uses: ilammy/msvc-dev-cmd@v1
+        echo "[INFO] Version ${{ inputs.next_version_major }}.${{ inputs.next_version_minor }}"
+        echo "BUILD_FLAGS=${{ env.BUILD_FLAGS }} -DEMULATOR_VERSION_MAJOR=${{ inputs.next_version_major }} -DEMULATOR_VERSION_MINOR=${{ inputs.next_version_minor }}" | Out-File -FilePath $Env:GITHUB_ENV -Encoding utf8 -Append
+
+    - name: "Setup cmake"
+      uses: jwlawson/actions-setup-cmake@v2
       with:
-        arch: amd64
-        toolset: 14.33.31629
-        spectre: false
+        cmake-version: '3.29.0'
 
     - name: "Bootstrap vcpkg"
       run: |
@@ -174,20 +159,108 @@ jobs:
         cd build
         echo "[INFO] BUILD_FLAGS: ${{ env.BUILD_FLAGS }}"
         echo "[INFO] BUILD_MODE: ${{ env.BUILD_MODE }}"
-        cmake .. ${{ env.BUILD_FLAGS }} -DCMAKE_BUILD_TYPE=${{ env.BUILD_MODE }}
+        cmake .. ${{ env.BUILD_FLAGS }} -DCMAKE_BUILD_TYPE=${{ env.BUILD_MODE }} -DVCPKG_INSTALL_OPTIONS="--clean-after-build"
         
     - name: "Build Cemu"
       run: |
         cd build
-        cmake --build . --config ${{ env.BUILD_MODE }} -j 2
+        cmake --build . --config ${{ env.BUILD_MODE }}
 
     - name: Prepare artifact
-      if: ${{ inputs.deploymode == 'release' }}
       run: Rename-Item bin/Cemu_release.exe Cemu.exe
       
     - name: Upload artifact
-      uses: actions/upload-artifact@v3
-      if: ${{ inputs.deploymode == 'release' }}
+      uses: actions/upload-artifact@v4
       with:
         name: cemu-bin-windows-x64
         path: ./bin/Cemu.exe
+
+  build-macos:
+    runs-on: macos-14
+    strategy:
+      matrix:
+        arch: [x86_64, arm64]
+    steps:
+    - name: "Checkout repo"
+      uses: actions/checkout@v4
+      with:
+        submodules: "recursive"
+        
+    - name: Setup release mode parameters
+      run: |
+        echo "BUILD_MODE=release" >> $GITHUB_ENV
+        echo "BUILD_FLAGS=" >> $GITHUB_ENV
+        echo "Build mode is release"
+
+    - name: Setup build flags for version
+      if: ${{ inputs.next_version_major != '' }}
+      run: |
+        echo "[INFO] Version ${{ inputs.next_version_major }}.${{ inputs.next_version_minor }}"
+        echo "BUILD_FLAGS=${{ env.BUILD_FLAGS }} -DEMULATOR_VERSION_MAJOR=${{ inputs.next_version_major }} -DEMULATOR_VERSION_MINOR=${{ inputs.next_version_minor }}" >> $GITHUB_ENV
+        
+    - name: "Install system dependencies"
+      run: |
+        brew update
+        brew install ninja nasm automake libtool
+
+    - name: "Install molten-vk"
+      run: |
+        curl -L -O https://github.com/KhronosGroup/MoltenVK/releases/download/v1.3.0/MoltenVK-macos.tar
+        tar xf MoltenVK-macos.tar
+        sudo mkdir -p /usr/local/lib
+        sudo cp MoltenVK/MoltenVK/dynamic/dylib/macOS/libMoltenVK.dylib /usr/local/lib
+
+    - name: "Setup cmake"
+      uses: jwlawson/actions-setup-cmake@v2
+      with:
+        cmake-version: '3.29.0'
+
+    - name: "Bootstrap vcpkg"
+      run: |
+        bash ./dependencies/vcpkg/bootstrap-vcpkg.sh
+        
+    - name: 'Setup NuGet Credentials for vcpkg'
+      shell: 'bash'
+      run: |
+        mono `./dependencies/vcpkg/vcpkg fetch nuget | tail -n 1` \
+        sources add \
+        -source "https://nuget.pkg.github.com/${{ github.repository_owner }}/index.json" \
+        -storepasswordincleartext \
+        -name "GitHub" \
+        -username "${{ github.repository_owner }}" \
+        -password "${{ secrets.GITHUB_TOKEN }}"
+        mono `./dependencies/vcpkg/vcpkg fetch nuget | tail -n 1` \
+        setapikey "${{ secrets.GITHUB_TOKEN }}" \
+        -source "https://nuget.pkg.github.com/${{ github.repository_owner }}/index.json"
+        
+    - name: "cmake"
+      run: |
+        mkdir build
+        cd build
+        cmake .. ${{ env.BUILD_FLAGS }} \
+        -DCMAKE_BUILD_TYPE=${{ env.BUILD_MODE }} \
+        -DCMAKE_OSX_ARCHITECTURES=${{ matrix.arch }} \
+        -DMACOS_BUNDLE=ON \
+        -G Ninja
+        
+    - name: "Build Cemu"
+      run: |
+        cmake --build build
+
+    - name: Prepare artifact
+      run: |
+        mkdir bin/Cemu_app
+        mv bin/Cemu_release.app bin/Cemu_app/Cemu.app
+        mv bin/Cemu_app/Cemu.app/Contents/MacOS/Cemu_release bin/Cemu_app/Cemu.app/Contents/MacOS/Cemu
+        sed -i '' 's/Cemu_release/Cemu/g' bin/Cemu_app/Cemu.app/Contents/Info.plist
+        chmod a+x bin/Cemu_app/Cemu.app/Contents/MacOS/{Cemu,update.sh}
+        ln -s /Applications bin/Cemu_app/Applications
+        hdiutil create ./bin/tmp.dmg -ov -volname "Cemu" -fs HFS+ -srcfolder "./bin/Cemu_app"
+        hdiutil convert ./bin/tmp.dmg -format UDZO -o bin/Cemu.dmg
+        rm bin/tmp.dmg
+              
+    - name: Upload artifact
+      uses: actions/upload-artifact@v4
+      with:
+        name: cemu-bin-macos-${{ matrix.arch }}
+        path: ./bin/Cemu.dmg
diff --git a/.github/workflows/build_check.yml b/.github/workflows/build_check.yml
index 49ef79e9..5d24b0c6 100644
--- a/.github/workflows/build_check.yml
+++ b/.github/workflows/build_check.yml
@@ -16,6 +16,3 @@ on:
 jobs:
   build:
     uses: ./.github/workflows/build.yml
-    with:
-      deploymode: release
-      experimentalversion: 999999
diff --git a/.github/workflows/deploy_experimental_release.yml b/.github/workflows/deploy_experimental_release.yml
deleted file mode 100644
index afe3dee7..00000000
--- a/.github/workflows/deploy_experimental_release.yml
+++ /dev/null
@@ -1,66 +0,0 @@
-name: Deploy experimental release
-on: 
-  workflow_dispatch:
-
-jobs:
-  call-release-build:
-    uses: ./.github/workflows/build.yml
-    with:
-      deploymode: release
-      experimentalversion: ${{ github.run_number }}
-  deploy:
-    name: Deploy experimental release
-    runs-on: ubuntu-20.04
-    needs: call-release-build
-    steps:
-      - uses: actions/checkout@v2
- 
-      - uses: actions/download-artifact@v3
-        with:
-          name: cemu-bin-linux-x64
-          path: cemu-bin-linux-x64
-
-      - uses: actions/download-artifact@v3
-        with:
-          name: cemu-bin-windows-x64
-          path: cemu-bin-windows-x64
-
-      - name: Initialize
-        run: |
-          mkdir upload
-          sudo apt install zip
-          
-      - name: Get version
-        run: |
-          echo "Experimental version: ${{ github.run_number }}"
-          ls
-          gcc -o getversion .github/getversion.cpp
-          ./getversion
-          echo "Cemu CI version: $(./getversion)"
-          echo "CEMU_FOLDER_NAME=Cemu_$(./getversion)-${{ github.run_number }}" >> $GITHUB_ENV
-          echo "CEMU_VERSION=$(./getversion)-${{ github.run_number }}" >> $GITHUB_ENV
-
-      - name: Create release from windows-bin
-        run: |
-          ls ./
-          ls ./bin/
-          cp -R ./bin ./${{ env.CEMU_FOLDER_NAME }}
-          mv cemu-bin-windows-x64/Cemu.exe ./${{ env.CEMU_FOLDER_NAME }}/Cemu.exe
-          zip -9 -r upload/cemu-${{ env.CEMU_VERSION }}-windows-x64.zip ${{ env.CEMU_FOLDER_NAME }}
-          rm -r ./${{ env.CEMU_FOLDER_NAME }}
-          
-      - name: Create release from linux-bin
-        run: |
-          ls ./
-          ls ./bin/
-          cp -R ./bin ./${{ env.CEMU_FOLDER_NAME }}
-          mv cemu-bin-linux-x64/Cemu ./${{ env.CEMU_FOLDER_NAME }}/Cemu
-          zip -9 -r upload/cemu-${{ env.CEMU_VERSION }}-ubuntu-20.04-x64.zip ${{ env.CEMU_FOLDER_NAME }}
-          rm -r ./${{ env.CEMU_FOLDER_NAME }}
-  
-      - name: Create release
-        run: |
-          wget -O ghr.tar.gz https://github.com/tcnksm/ghr/releases/download/v0.15.0/ghr_v0.15.0_linux_amd64.tar.gz
-          tar xvzf ghr.tar.gz; rm ghr.tar.gz
-          echo "[INFO] Release tag: v${{ env.CEMU_VERSION }}"
-          ghr_v0.15.0_linux_amd64/ghr -prerelease -t ${{ secrets.GITHUB_TOKEN }} -n "Cemu ${{ env.CEMU_VERSION }} (Experimental)" -b "Cemu experimental release - [changelog](https://cemu.info/changelog.html)" "v${{ env.CEMU_VERSION }}" ./upload
diff --git a/.github/workflows/deploy_release.yml b/.github/workflows/deploy_release.yml
new file mode 100644
index 00000000..2b9ee491
--- /dev/null
+++ b/.github/workflows/deploy_release.yml
@@ -0,0 +1,151 @@
+name: Deploy release
+on: 
+  workflow_dispatch:
+    inputs:
+      changelog0:
+        description: 'Enter the changelog lines for this release. Each line is a feature / bullet point. Do not use dash.'
+        required: true
+        type: string
+      changelog1:
+        description: 'Feature 2'
+        required: false
+        type: string
+      changelog2:
+        description: 'Feature 3'
+        required: false
+        type: string
+      changelog3:
+        description: 'Feature 4'
+        required: false
+        type: string
+      changelog4:
+        description: 'Feature 5'
+        required: false
+        type: string
+      changelog5:
+        description: 'Feature 6'
+        required: false
+        type: string
+      changelog6:
+        description: 'Feature 7'
+        required: false
+        type: string
+      changelog7:
+        description: 'Feature 8'
+        required: false
+        type: string
+      changelog8:
+        description: 'Feature 9'
+        required: false
+        type: string
+      changelog9:
+        description: 'Feature 10'
+        required: false
+        type: string
+
+jobs:
+  calculate-version:
+    name: Calculate Version
+    uses: ./.github/workflows/determine_release_version.yml
+  call-release-build:
+    uses: ./.github/workflows/build.yml
+    needs: calculate-version
+    with:
+      next_version_major: ${{ needs.calculate-version.outputs.next_version_major }}
+      next_version_minor: ${{ needs.calculate-version.outputs.next_version_minor }}
+  deploy:
+    name: Deploy release
+    runs-on: ubuntu-22.04
+    needs: [call-release-build, calculate-version]
+    steps:
+      - uses: actions/checkout@v4
+        with:
+          fetch-depth: 0
+
+      - name: Generate changelog
+        id: generate_changelog
+        run: |
+          CHANGELOG=""
+          if [ -n "${{ github.event.inputs.changelog0 }}" ]; then CHANGELOG="$CHANGELOG- ${{ github.event.inputs.changelog0 }}\n"; fi
+          if [ -n "${{ github.event.inputs.changelog1 }}" ]; then CHANGELOG="$CHANGELOG- ${{ github.event.inputs.changelog1 }}\n"; fi
+          if [ -n "${{ github.event.inputs.changelog2 }}" ]; then CHANGELOG="$CHANGELOG- ${{ github.event.inputs.changelog2 }}\n"; fi
+          if [ -n "${{ github.event.inputs.changelog3 }}" ]; then CHANGELOG="$CHANGELOG- ${{ github.event.inputs.changelog3 }}\n"; fi
+          if [ -n "${{ github.event.inputs.changelog4 }}" ]; then CHANGELOG="$CHANGELOG- ${{ github.event.inputs.changelog4 }}\n"; fi
+          if [ -n "${{ github.event.inputs.changelog5 }}" ]; then CHANGELOG="$CHANGELOG- ${{ github.event.inputs.changelog5 }}\n"; fi
+          if [ -n "${{ github.event.inputs.changelog6 }}" ]; then CHANGELOG="$CHANGELOG- ${{ github.event.inputs.changelog6 }}\n"; fi
+          if [ -n "${{ github.event.inputs.changelog7 }}" ]; then CHANGELOG="$CHANGELOG- ${{ github.event.inputs.changelog7 }}\n"; fi
+          if [ -n "${{ github.event.inputs.changelog8 }}" ]; then CHANGELOG="$CHANGELOG- ${{ github.event.inputs.changelog8 }}\n"; fi
+          if [ -n "${{ github.event.inputs.changelog9 }}" ]; then CHANGELOG="$CHANGELOG- ${{ github.event.inputs.changelog9 }}\n"; fi
+          echo -e "$CHANGELOG"
+          echo "RELEASE_BODY=$CHANGELOG" >> $GITHUB_ENV
+      - uses: actions/download-artifact@v4
+        with:
+          name: cemu-bin-linux-x64
+          path: cemu-bin-linux-x64
+
+      - uses: actions/download-artifact@v4
+        with:
+          name: cemu-appimage-x64
+          path: cemu-appimage-x64
+
+      - uses: actions/download-artifact@v4
+        with:
+          name: cemu-bin-windows-x64
+          path: cemu-bin-windows-x64
+
+      - uses: actions/download-artifact@v4
+        with:
+          name: cemu-bin-macos-x64
+          path: cemu-bin-macos-x64
+
+      - name: Initialize
+        run: |
+          mkdir upload
+          sudo apt install zip
+          
+      - name: Set version dependent vars
+        run: |
+          echo "Version: ${{ needs.calculate-version.outputs.next_version }}"
+          echo "CEMU_FOLDER_NAME=Cemu_${{ needs.calculate-version.outputs.next_version }}"
+          echo "CEMU_VERSION=${{ needs.calculate-version.outputs.next_version }}"
+          echo "CEMU_FOLDER_NAME=Cemu_${{ needs.calculate-version.outputs.next_version }}" >> $GITHUB_ENV
+          echo "CEMU_VERSION=${{ needs.calculate-version.outputs.next_version }}" >> $GITHUB_ENV
+
+      - name: Create release from windows-bin
+        run: |
+          ls ./
+          ls ./bin/
+          cp -R ./bin ./${{ env.CEMU_FOLDER_NAME }}
+          mv cemu-bin-windows-x64/Cemu.exe ./${{ env.CEMU_FOLDER_NAME }}/Cemu.exe
+          zip -9 -r upload/cemu-${{ env.CEMU_VERSION }}-windows-x64.zip ${{ env.CEMU_FOLDER_NAME }}
+          rm -r ./${{ env.CEMU_FOLDER_NAME }}
+
+      - name: Create appimage
+        run: |
+          VERSION=${{ env.CEMU_VERSION }}
+          echo "Cemu Version is $VERSION"
+          ls cemu-appimage-x64
+          mv cemu-appimage-x64/Cemu-*-x86_64.AppImage upload/Cemu-$VERSION-x86_64.AppImage
+        
+      - name: Create release from linux-bin
+        run: |
+          ls ./
+          ls ./bin/
+          cp -R ./bin ./${{ env.CEMU_FOLDER_NAME }}
+          mv cemu-bin-linux-x64/Cemu ./${{ env.CEMU_FOLDER_NAME }}/Cemu
+          zip -9 -r upload/cemu-${{ env.CEMU_VERSION }}-ubuntu-22.04-x64.zip ${{ env.CEMU_FOLDER_NAME }}
+          rm -r ./${{ env.CEMU_FOLDER_NAME }}
+          
+      - name: Create release from macos-bin
+        run: cp cemu-bin-macos-x64/Cemu.dmg upload/cemu-${{ env.CEMU_VERSION }}-macos-12-x64.dmg
+
+      - name: Create release
+        run: |
+          wget -O ghr.tar.gz https://github.com/tcnksm/ghr/releases/download/v0.15.0/ghr_v0.15.0_linux_amd64.tar.gz
+          tar xvzf ghr.tar.gz; rm ghr.tar.gz
+          echo "[INFO] Release tag: v${{ env.CEMU_VERSION }}"
+          CHANGELOG_UNESCAPED=$(printf "%s\n" "${{ env.RELEASE_BODY }}" | sed 's/\\n/\n/g')          
+          RELEASE_BODY=$(printf "%s\n%s" \
+            "**Changelog:**" \
+            "$CHANGELOG_UNESCAPED")
+          ghr_v0.15.0_linux_amd64/ghr -draft -t ${{ secrets.GITHUB_TOKEN }} -n "Cemu ${{ env.CEMU_VERSION }}" -b "$RELEASE_BODY" "v${{ env.CEMU_VERSION }}" ./upload
diff --git a/.github/workflows/deploy_stable_release.yml b/.github/workflows/deploy_stable_release.yml
deleted file mode 100644
index 7167dcbe..00000000
--- a/.github/workflows/deploy_stable_release.yml
+++ /dev/null
@@ -1,69 +0,0 @@
-name: Create new release
-on: 
-  workflow_dispatch:
-    inputs:
-      PlaceholderInput:
-        description: PlaceholderInput
-        required: false
-jobs:
-  call-release-build:
-    uses: ./.github/workflows/build.yml
-    with:
-      deploymode: release
-  deploy:
-    name: Deploy release
-    runs-on: ubuntu-20.04
-    needs: call-release-build
-    steps:
-      - uses: actions/checkout@v2
- 
-      - uses: actions/download-artifact@v3
-        with:
-          name: cemu-bin-linux-x64
-          path: cemu-bin-linux-x64
-
-      - uses: actions/download-artifact@v3
-        with:
-          name: cemu-bin-windows-x64
-          path: cemu-bin-windows-x64
-
-      - name: Initialize
-        run: |
-          mkdir upload
-          sudo apt update -qq
-          sudo apt install -y zip
-          
-      - name: Get Cemu release version
-        run: |
-          gcc -o getversion .github/getversion.cpp
-          echo "Cemu CI version: $(./getversion)"
-          echo "CEMU_FOLDER_NAME=Cemu_$(./getversion)" >> $GITHUB_ENV
-          echo "CEMU_VERSION=$(./getversion)" >> $GITHUB_ENV
-
-      - name: Create appimage
-        run: |
-          echo "to do"
-
-      - name: Create release from windows-bin
-        run: |
-          ls ./
-          ls ./bin/
-          cp -R ./bin ./${{ env.CEMU_FOLDER_NAME }}
-          mv cemu-bin-windows-x64/Cemu.exe ./${{ env.CEMU_FOLDER_NAME }}/Cemu.exe
-          zip -9 -r upload/cemu-${{ env.CEMU_VERSION }}-windows-x64.zip ${{ env.CEMU_FOLDER_NAME }}
-          rm -r ./${{ env.CEMU_FOLDER_NAME }}
-          
-      - name: Create release from ubuntu-bin
-        run: |
-          ls ./
-          ls ./bin/
-          cp -R ./bin ./${{ env.CEMU_FOLDER_NAME }}
-          mv cemu-bin-linux-x64/Cemu ./${{ env.CEMU_FOLDER_NAME }}/Cemu
-          zip -9 -r upload/cemu-${{ env.CEMU_VERSION }}-ubuntu-20.04-x64.zip ${{ env.CEMU_FOLDER_NAME }}
-          rm -r ./${{ env.CEMU_FOLDER_NAME }}
-  
-      - name: Create release
-        run: |
-          wget -O ghr.tar.gz https://github.com/tcnksm/ghr/releases/download/v0.15.0/ghr_v0.15.0_linux_amd64.tar.gz
-          tar xvzf ghr.tar.gz; rm ghr.tar.gz
-          ghr_v0.15.0_linux_amd64/ghr -t ${{ secrets.GITHUB_TOKEN }} -n "Cemu ${{ env.CEMU_VERSION }}" -b "Changelog:" v${{ env.CEMU_VERSION }} ./upload
diff --git a/.github/workflows/determine_release_version.yml b/.github/workflows/determine_release_version.yml
new file mode 100644
index 00000000..be606941
--- /dev/null
+++ b/.github/workflows/determine_release_version.yml
@@ -0,0 +1,74 @@
+name: Calculate Next Version from release history
+
+on:
+  workflow_dispatch:
+  workflow_call:
+    outputs:
+      next_version:
+        description: "The next semantic version"
+        value: ${{ jobs.calculate-version.outputs.next_version }}
+      next_version_major:
+        description: "The next semantic version (major)"
+        value: ${{ jobs.calculate-version.outputs.next_version_major }}
+      next_version_minor:
+        description: "The next semantic version (minor)"
+        value: ${{ jobs.calculate-version.outputs.next_version_minor }}
+
+jobs:
+  calculate-version:
+    runs-on: ubuntu-latest
+    outputs:
+      next_version: ${{ steps.calculate_next_version.outputs.next_version }}
+      next_version_major: ${{ steps.calculate_next_version.outputs.next_version_major }}
+      next_version_minor: ${{ steps.calculate_next_version.outputs.next_version_minor }}      
+    steps:
+      - name: Checkout code
+        uses: actions/checkout@v2
+
+      - name: Get all releases
+        id: get_all_releases
+        run: |
+          # Fetch all releases and check for API errors
+          RESPONSE=$(curl -s -o response.json -w "%{http_code}" "https://api.github.com/repos/${{ github.repository }}/releases?per_page=100")
+          if [ "$RESPONSE" -ne 200 ]; then
+            echo "Failed to fetch releases. HTTP status: $RESPONSE"
+            cat response.json
+            exit 1
+          fi
+          
+          # Extract and sort tags
+          ALL_TAGS=$(jq -r '.[].tag_name' response.json | grep -E '^v[0-9]+\.[0-9]+(-[0-9]+)?$' | sed 's/-.*//' | sort -V | tail -n 1)
+
+          # Exit if no tags were found
+          if [ -z "$ALL_TAGS" ]; then
+            echo "No valid tags found."
+            exit 1
+          fi
+
+          echo "::set-output name=tag::$ALL_TAGS"
+          # echo "tag=$ALL_TAGS" >> $GITHUB_STATE
+
+      - name: Calculate next semver minor
+        id: calculate_next_version
+        run: |
+          LATEST_VERSION=${{ steps.get_all_releases.outputs.tag }}
+
+          # strip 'v' prefix and split into major.minor
+          LATEST_VERSION=${LATEST_VERSION//v/}
+          IFS='.' read -r -a VERSION_PARTS <<< "$LATEST_VERSION"
+
+          MAJOR=${VERSION_PARTS[0]}
+          MINOR=${VERSION_PARTS[1]}
+
+          # increment the minor version
+          MINOR=$((MINOR + 1))
+
+          NEXT_VERSION="${MAJOR}.${MINOR}"
+
+          echo "Major: $MAJOR"
+          echo "Minor: $MINOR"
+
+          echo "Next version: $NEXT_VERSION"
+          echo "::set-output name=next_version::$NEXT_VERSION"
+          echo "::set-output name=next_version_major::$MAJOR"
+          echo "::set-output name=next_version_minor::$MINOR"          
\ No newline at end of file
diff --git a/.github/workflows/generate_pot.yml b/.github/workflows/generate_pot.yml
index f2675574..b057d441 100644
--- a/.github/workflows/generate_pot.yml
+++ b/.github/workflows/generate_pot.yml
@@ -29,13 +29,13 @@ jobs:
       - name: "Generate POT file using xgettext"
         run: >
           find src -name *.cpp -o -name *.hpp -o -name *.h | 
-          xargs xgettext --from-code=utf-8
-          -k_ -kwxTRANSLATE -w 100
+          xargs xgettext --from-code=utf-8 -w 100
+          --keyword="_" --keyword="wxTRANSLATE" --keyword="wxPLURAL:1,2"
           --check=space-ellipsis --omit-header
           -o cemu.pot
 
       - name: Upload artifact
-        uses: actions/upload-artifact@v3
+        uses: actions/upload-artifact@v4
         with:
           name: POT file
           path: ./cemu.pot
diff --git a/.gitignore b/.gitignore
index 293864a8..67a268aa 100644
--- a/.gitignore
+++ b/.gitignore
@@ -13,9 +13,11 @@
 *.out
 *.app
 .vs
+.vscode
 .idea/
 
 build/
+cmake-build-*/
 out/
 .cache/
 bin/Cemu_*
@@ -30,9 +32,15 @@ bin/Cemu_*.ilk
 bin/Cemu.exe.backup
 bin/mlc01/*
 bin/settings.xml
+bin/network_services.xml
 bin/title_list_cache.xml
 bin/debugger/*
 bin/sdcard/*
+bin/screenshots/*
+bin/dump/*
+bin/cafeLibs/*
+bin/portable/*
+bin/keys.txt
 
 !bin/shaderCache/info.txt
 bin/shaderCache/*
@@ -43,3 +51,6 @@ bin/controllerProfiles/*
 bin/gameProfiles/*
 
 bin/graphicPacks/*
+
+# Ignore Finder view option files created by OS X
+.DS_Store
\ No newline at end of file
diff --git a/.gitmodules b/.gitmodules
index dd32088b..8f9772d3 100644
--- a/.gitmodules
+++ b/.gitmodules
@@ -9,7 +9,15 @@
 [submodule "dependencies/vcpkg"]
 	path = dependencies/vcpkg
 	url = https://github.com/microsoft/vcpkg
-	shallow = true
+	shallow = false
 [submodule "dependencies/Vulkan-Headers"]
 	path = dependencies/Vulkan-Headers
 	url = https://github.com/KhronosGroup/Vulkan-Headers
+	shallow = true
+[submodule "dependencies/imgui"]
+	path = dependencies/imgui
+	url = https://github.com/ocornut/imgui
+	shallow = true
+[submodule "dependencies/xbyak_aarch64"]
+	path = dependencies/xbyak_aarch64
+	url = https://github.com/fujitsu/xbyak_aarch64
diff --git a/BUILD.md b/BUILD.md
index 67f55a94..31c26531 100644
--- a/BUILD.md
+++ b/BUILD.md
@@ -1,59 +1,232 @@
-# Build instructions
+# Build Instructions
+
+## Table of Contents
+
+- [Windows](#windows)
+- [Linux](#linux)
+   - [Dependencies](#dependencies)
+      - [For Arch and derivatives:](#for-arch-and-derivatives)
+      - [For Debian, Ubuntu and derivatives](#for-debian-ubuntu-and-derivatives)
+      - [For Fedora and derivatives:](#for-fedora-and-derivatives)
+   - [Build Cemu](#build-cemu)
+      - [CMake and Clang](#cmake-and-clang)
+      - [GCC](#gcc)
+      - [Debug Build](#debug-build)
+      - [Troubleshooting Steps](#troubleshooting-steps)
+         - [Compiling Errors](#compiling-errors)
+         - [Building Errors](#building-errors)
+- [macOS](#macos)
+   - [Installing brew](#installing-brew)
+   - [Installing Tool Dependencies](#installing-tool-dependencies)
+   - [Installing Library Dependencies](#installing-library-dependencies)
+   - [Build Cemu using CMake](#build-cemu-using-cmake)
+- [Updating Cemu and source code](#updating-cemu-and-source-code)
 
 ## Windows
 
 Prerequisites:
-- A recent version of Visual Studio 2022 (recommended but not required) with the following additional components:
-  - C++ CMake tools for Windows
-  - Windows 10/11 SDK
 - git
+- A recent version of Visual Studio 2022 with the following additional components:
+   - C++ CMake tools for Windows
+   - Windows 10/11 SDK
 
-Instructions:
+Instructions for Visual Studio 2022:
 
 1. Run `git clone --recursive https://github.com/cemu-project/Cemu`
-2. Launch `Cemu/generate_vs_solution.bat`.
-    - If you installed VS to a custom location or use VS 2019, you may need to manually change the path inside the .bat file
-3. Wait until it's done, then open `Cemu/build/Cemu.sln` in Visual Studio
-4. Then build the solution and once finished you can run and debug it, or build it and check the /bin folder for the final Cemu_release.exe.
+2. Open the newly created Cemu directory in Visual Studio using the "Open a local folder" option
+3. In the menu select Project -> Configure CMake. Wait until it is done, this may take a long time
+4. You can now build, run and debug Cemu
 
-You can also skip steps 3-5 and open the root folder of the cloned repo directly in Visual Studio (as a folder) and use the built-in cmake support but be warned that cmake support in VS can be a bit finicky.
+Any other IDE should also work as long as it has CMake and MSVC support. CLion and Visual Studio Code have been confirmed to work.
 
 ## Linux
 
-To compile Cemu, a recent enough compiler and STL with C++20 support is required! clang-12 or higher is what we recommend.
+To compile Cemu, a recent enough compiler and STL with C++20 support is required! Clang-15 or higher is what we recommend.
 
-### Installing dependencies
-
-#### For Ubuntu and derivatives:
-`sudo apt install -y git curl cmake ninja-build nasm libgtk-3-dev libsecret-1-dev libgcrypt20-dev libsystemd-dev freeglut3-dev libpulse-dev`  
-Additionally, for ubuntu 20.04 only:
- - `sudo apt install -y clang-12`
- - At step 3 while building, use  
-   `cmake -S . -B build -DCMAKE_BUILD_TYPE=release -DCMAKE_C_COMPILER=/usr/bin/clang-12 -DCMAKE_CXX_COMPILER=/usr/bin/clang++-12 -G Ninja -DCMAKE_MAKE_PROGRAM=/usr/bin/ninja`
+### Dependencies
 
 #### For Arch and derivatives:
-`sudo pacman -S git cmake clang ninja nasm base-devel linux-headers gtk3 libsecret libgcrypt systemd freeglut zip libpulse`
+`sudo pacman -S --needed base-devel bluez-libs clang cmake freeglut git glm gtk3 libgcrypt libpulse libsecret linux-headers llvm nasm ninja systemd unzip zip`
+
+#### For Debian, Ubuntu and derivatives:
+`sudo apt install -y cmake curl clang-15 freeglut3-dev git libbluetooth-dev libgcrypt20-dev libglm-dev libgtk-3-dev libpulse-dev libsecret-1-dev libsystemd-dev libtool nasm ninja-build`
+
+You may also need to install `libusb-1.0-0-dev` as a workaround for an issue with the vcpkg hidapi package.
+
+At Step 3 in [Build Cemu using cmake and clang](#build-cemu-using-cmake-and-clang), use the following command instead:
+   `cmake -S . -B build -DCMAKE_BUILD_TYPE=release -DCMAKE_C_COMPILER=/usr/bin/clang-15 -DCMAKE_CXX_COMPILER=/usr/bin/clang++-15 -G Ninja -DCMAKE_MAKE_PROGRAM=/usr/bin/ninja`
 
 #### For Fedora and derivatives:
-`sudo dnf install git cmake clang ninja-build nasm kernel-headers gtk3-devel libsecret-devel libgcrypt-devel systemd-devel freeglut-devel perl-core zlib-devel cubeb-devel`
+`sudo dnf install bluez-libs-devel clang cmake cubeb-devel freeglut-devel git glm-devel gtk3-devel kernel-headers libgcrypt-devel libsecret-devel libtool libusb1-devel llvm nasm ninja-build perl-core systemd-devel wayland-protocols-devel zlib-devel zlib-static`
+
+### Build Cemu
+
+#### CMake and Clang
+
+```
+git clone --recursive https://github.com/cemu-project/Cemu
+cd Cemu
+cmake -S . -B build -DCMAKE_BUILD_TYPE=release -DCMAKE_C_COMPILER=/usr/bin/clang -DCMAKE_CXX_COMPILER=/usr/bin/clang++ -G Ninja
+cmake --build build
+```
+
+#### GCC
+
+If you are building using GCC, make sure you have g++ installed:
+- Installation for Arch and derivatives: `sudo pacman -S gcc`
+- Installation for Debian, Ubuntu and derivatives: `sudo apt install g++`
+- Installation for Fedora and derivatives: `sudo dnf install gcc-c++`
+
+```
+git clone --recursive https://github.com/cemu-project/Cemu
+cd Cemu
+cmake -S . -B build -DCMAKE_BUILD_TYPE=release -DCMAKE_C_COMPILER=/usr/bin/gcc -DCMAKE_CXX_COMPILER=/usr/bin/g++ -G Ninja
+cmake --build build
+```
+
+#### Debug Build
+
+```
+git clone --recursive https://github.com/cemu-project/Cemu
+cd Cemu
+cmake -S . -B build -DCMAKE_BUILD_TYPE=debug -DCMAKE_C_COMPILER=/usr/bin/clang -DCMAKE_CXX_COMPILER=/usr/bin/clang++ -G Ninja
+cmake --build build
+```
+
+If you are using GCC, replace `cmake -S . -B build -DCMAKE_BUILD_TYPE=debug -DCMAKE_C_COMPILER=/usr/bin/clang -DCMAKE_CXX_COMPILER=/usr/bin/clang++ -G Ninja` with `cmake -S . -B build -DCMAKE_BUILD_TYPE=debug -DCMAKE_C_COMPILER=/usr/bin/gcc -DCMAKE_CXX_COMPILER=/usr/bin/g++ -G Ninja`
+
+#### Troubleshooting Steps
+
+##### Compiling Errors
+
+This section refers to running `cmake -S...` (truncated).
+
+* `vcpkg install failed`
+   * Run the following in the root directory and try running the command again (don't forget to change directories afterwards):
+      * `cd dependencies/vcpkg && git fetch --unshallow`
+* `Please ensure you're using the latest port files with git pull and vcpkg update.`
+   * Either:
+      * Update vcpkg by running by the following command:
+         * `git submodule update --remote dependencies/vcpkg`
+      * If you are sure vcpkg is up to date, check the following logs:
+         * `Cemu/dependencies/vcpkg/buildtrees/wxwidgets/config-x64-linux-out.log`
+         * `Cemu/dependencies/vcpkg/buildtrees/libsystemd/config-x64-linux-dbg-meson-log.txt.log`
+         * `Cemu/dependencies/vcpkg/buildtrees/libsystemd/config-x64-linux-dbg-out.log`
+* Not able to find Ninja.
+   * Add the following and try running the command again:
+      * `-DCMAKE_MAKE_PROGRAM=/usr/bin/ninja`
+* Compiling failed during the boost-build dependency.
+   * It means you don't have a working/good standard library installation. Check the integrity of your system headers and making sure that C++ related packages are installed and intact.
+* Compiling failed during rebuild after `git pull` with an error that mentions RPATH
+   * Add the following and try running the command again:
+      * `-DCMAKE_BUILD_WITH_INSTALL_RPATH=ON`
+* Environment variable `VCPKG_FORCE_SYSTEM_BINARIES` must be set.
+   * Execute the folowing and then try running the command again:
+      * `export VCPKG_FORCE_SYSTEM_BINARIES=1`
+* If you are getting a random error, read the [package-name-and-platform]-out.log and [package-name-and-platform]-err.log for the actual reason to see if you might be lacking the headers from a dependency.
+
+
+If you are getting a different error than any of the errors listed above, you may either open an issue in this repo or try using [GCC](#gcc). Make sure your standard library and compilers are updated since Cemu uses a lot of modern features!
+
+
+##### Building Errors
+
+This section refers to running `cmake --build build`.
+
+* `main.cpp.o: in function 'std::__cxx11::basic_string...`
+   * You likely are experiencing a clang-14 issue. This can only be fixed by either lowering the clang version or using GCC, see [GCC](#gcc).
+* `fatal error: 'span' file not found`
+   *  You're either missing `libstdc++` or are using a version that's too old. Install at least v10 with your package manager, eg `sudo apt install libstdc++-10-dev`. See [#644](https://github.com/cemu-project/Cemu/issues/644).
+* `undefined libdecor_xx`
+   * You are likely experiencing an issue with sdl2 package that comes with vcpkg. Delete sdl2 from vcpkg.json in source file and recompile.
+
+If you are getting a different error than any of the errors listed above, you may either open an issue in this repo or try using [GCC](#gcc). Make sure your standard library and compilers are updated since Cemu uses a lot of modern features!
+
+## macOS
+
+To compile Cemu, a recent enough compiler and STL with C++20 support is required! LLVM 13 and below
+don't support the C++20 feature set required, so either install LLVM from Homebrew or make sure that
+you have a recent enough version of Xcode. Xcode 15 is known to work. The OpenGL graphics API isn't
+supported on macOS, so Vulkan must be used through the Molten-VK compatibility layer.
+
+### Installing brew
+
+1. `/bin/bash -c "$(curl -fsSL https://raw.githubusercontent.com/Homebrew/install/HEAD/install.sh)"`
+2. Set up the Homebrew shell environment:
+   1. **On an Intel Mac:** `eval "$(/usr/local/Homebrew/bin/brew shellenv)"`
+   2. **On an Apple Silicon Mac:** eval `"$(/opt/homebrew/bin/brew shellenv)"`
+
+### Installing Tool Dependencies
+
+The native versions of these can be used regardless of what type of Mac you have.
+
+`brew install git cmake ninja nasm automake libtool`
+
+### Installing Library Dependencies
+
+**On Apple Silicon Macs, Rosetta 2 and the x86_64 version of Homebrew must be used to install these dependencies:**
+1. `softwareupdate --install-rosetta` # Install Rosetta 2 if you don't have it. This only has to be done once
+2. `arch -x86_64 zsh` # run an x64 shell
+3. `/bin/bash -c "$(curl -fsSL https://raw.githubusercontent.com/Homebrew/install/HEAD/install.sh)"`
+4. `eval "$(/usr/local/Homebrew/bin/brew shellenv)"`
+
+Then install the dependencies:
+
+`brew install boost molten-vk`
+
+### Build Cemu using CMake
 
-### Build Cemu using cmake and clang
 1. `git clone --recursive https://github.com/cemu-project/Cemu`
 2. `cd Cemu`
-3. `cmake -S . -B build -DCMAKE_BUILD_TYPE=release -DCMAKE_C_COMPILER=/usr/bin/clang -DCMAKE_CXX_COMPILER=/usr/bin/clang++ -G Ninja`
+3. `cmake -S . -B build -DCMAKE_BUILD_TYPE=release -DCMAKE_OSX_ARCHITECTURES=x86_64 -G Ninja`
 4. `cmake --build build`
 5. You should now have a Cemu executable file in the /bin folder, which you can run using `./bin/Cemu_release`.
 
-#### Using GCC
-While we use and test Cemu using clang, using GCC might work better with your distro (they should be fairly similar performance/issues wise and should only be considered if compilation is the issue).  
-You can use it by replacing the step 3 with the following:
-`cmake -S . -B build -DCMAKE_BUILD_TYPE=release -DCMAKE_C_COMPILER=/usr/bin/gcc -DCMAKE_CXX_COMPILER=/usr/bin/g++ -G Ninja`
-
 #### Troubleshooting steps
- - If step 3 gives you an error about not being able to find ninja, try appending `-DCMAKE_MAKE_PROGRAM=/usr/bin/ninja` to the command and running it again.
- - If step 3 fails while compiling the boost-build dependency, it means you don't have a working/good standard library installation. Check the integrity of your system headers and making sure that C++ related packages are installed and intact.
- - If step 3 gives a random error, read the `[package-name-and-platform]-out.log` and `[package-name-and-platform]-err.log` for the actual reason to see if you might be lacking the headers from a dependency.
- - If step 3 is still failing or if you're not able to find the cause, please make an issue on our Github about it!
- - If step 4 gives you an error that contains something like `main.cpp.o: in function 'std::__cxx11::basic_string...`, you likely are experiencing a clang-14 issue. This can only be fixed by either lowering the clang version or using GCC, see below.
- - If step 4 gives you a different error, you could report it to this repo or try using GCC. Just make sure your standard library and compilers are updated since Cemu uses a lot of modern features!
-- If step 4 gives you undefined libdecor_xx, you are likely experiencing an issue with sdl2 package that comes with vcpkg. Delete sdl2 from vcpkg.json in source file and recompile
+- If step 3 gives you an error about not being able to find ninja, try appending `-DCMAKE_MAKE_PROGRAM=/usr/local/bin/ninja` to the command and running it again.
+
+## Updating Cemu and source code
+1. To update your Cemu local repository, use the command `git pull --recurse-submodules` (run this command on the Cemu root).
+    - This should update your local copy of Cemu and all of its dependencies.
+2. Then, you can rebuild Cemu using the steps listed above, according to whether you use Linux or Windows.
+
+If CMake complains about Cemu already being compiled or another similar error, try deleting the `CMakeCache.txt` file inside the `build` folder and retry building.
+
+## CMake configure flags
+Some flags can be passed during CMake configure to customise which features are enabled on build.
+
+Example usage: `cmake -S . -B build -DCMAKE_BUILD_TYPE=release -DENABLE_SDL=ON -DENABLE_VULKAN=OFF`
+
+### All platforms
+| Flag               |   | Description                                                                 | Default | Note               |
+|--------------------|:--|-----------------------------------------------------------------------------|---------|--------------------|
+| ALLOW_PORTABLE     |   | Allow Cemu to use the `portable` directory to store configs and data        | ON      |                    |
+| CEMU_CXX_FLAGS     |   | Flags passed straight to the compiler, e.g. `-march=native`, `-Wall`, `/W3` | ""      |                    |
+| ENABLE_CUBEB       |   | Enable cubeb audio backend                                                  | ON      |                    |
+| ENABLE_DISCORD_RPC |   | Enable Discord Rich presence support                                        | ON      |                    |
+| ENABLE_OPENGL      |   | Enable OpenGL graphics backend                                              | ON      | Currently required |
+| ENABLE_HIDAPI      |   | Enable HIDAPI (used for Wiimote controller API)                             | ON      |                    |
+| ENABLE_SDL         |   | Enable SDLController controller API                                         | ON      | Currently required |
+| ENABLE_VCPKG       |   | Use VCPKG package manager to obtain dependencies                            | ON      |                    |
+| ENABLE_VULKAN      |   | Enable the Vulkan graphics backend                                          | ON      |                    |
+| ENABLE_WXWIDGETS   |   | Enable wxWidgets UI                                                         | ON      | Currently required |
+
+### Windows
+| Flag               | Description                       | Default | Note               |
+|--------------------|-----------------------------------|---------|--------------------|
+| ENABLE_DIRECTAUDIO | Enable DirectAudio audio backend  | ON      | Currently required |
+| ENABLE_DIRECTINPUT | Enable DirectInput controller API | ON      | Currently required |
+| ENABLE_XAUDIO      | Enable XAudio audio backend       | ON      |                    |
+| ENABLE_XINPUT      | Enable XInput controller API      | ON      |                    |
+
+### Linux
+| Flag                  | Description                                        | Default |
+|-----------------------|----------------------------------------------------|---------|
+| ENABLE_BLUEZ          | Build with Bluez (used for Wiimote controller API) | ON      |
+| ENABLE_FERAL_GAMEMODE | Enable Feral Interactive GameMode support          | ON      |
+| ENABLE_WAYLAND        | Enable Wayland support                             | ON      |
+
+### macOS
+| Flag         | Description                                    | Default |
+|--------------|------------------------------------------------|---------|
+| MACOS_BUNDLE | MacOS executable will be an application bundle | OFF     |
diff --git a/CMakeLists.txt b/CMakeLists.txt
index e9f7458e..aa491b9e 100644
--- a/CMakeLists.txt
+++ b/CMakeLists.txt
@@ -1,15 +1,48 @@
 cmake_minimum_required(VERSION 3.21.1)
 
-option(PUBLIC_RELEASE "Compile with debug asserts disabled and no console" OFF)
 option(ENABLE_VCPKG "Enable the vcpkg package manager" ON)
-set(EXPERIMENTAL_VERSION "" CACHE STRING "") # used by CI script to set experimental version
+option(MACOS_BUNDLE "The executable when built on macOS will be created as an application bundle" OFF)
+option(ALLOW_PORTABLE "Allow Cemu to be run in portable mode" ON)
 
-if (EXPERIMENTAL_VERSION)
-  add_definitions(-DEMULATOR_VERSION_MINOR=${EXPERIMENTAL_VERSION})
-endif()
+# used by CI script to set version:
+set(EMULATOR_VERSION_MAJOR "0" CACHE STRING "")
+set(EMULATOR_VERSION_MINOR "0" CACHE STRING "")
+set(EMULATOR_VERSION_PATCH "0" CACHE STRING "")
+
+execute_process(
+		COMMAND git log --format=%h -1
+		WORKING_DIRECTORY ${CMAKE_CURRENT_LIST_DIR}
+		OUTPUT_VARIABLE GIT_HASH
+		OUTPUT_STRIP_TRAILING_WHITESPACE
+)
+add_definitions(-DEMULATOR_HASH=${GIT_HASH})
 
 if (ENABLE_VCPKG)
-	set(VCPKG_OVERLAY_PORTS "${CMAKE_CURRENT_LIST_DIR}/dependencies/vcpkg_overlay_ports")
+	# check if vcpkg is shallow and unshallow it if necessary
+	execute_process(
+	COMMAND git rev-parse --is-shallow-repository
+	WORKING_DIRECTORY ${CMAKE_SOURCE_DIR}/dependencies/vcpkg
+	OUTPUT_VARIABLE is_vcpkg_shallow
+	OUTPUT_STRIP_TRAILING_WHITESPACE
+    )
+	
+	if(is_vcpkg_shallow STREQUAL "true")
+		message(STATUS "vcpkg is shallow. Unshallowing it now...")
+		execute_process(
+			COMMAND git fetch --unshallow
+			WORKING_DIRECTORY "${CMAKE_SOURCE_DIR}/dependencies/vcpkg"
+			RESULT_VARIABLE result
+			OUTPUT_VARIABLE output
+		)
+	endif()
+
+	if(UNIX AND NOT APPLE)
+		set(VCPKG_OVERLAY_PORTS "${CMAKE_CURRENT_LIST_DIR}/dependencies/vcpkg_overlay_ports_linux")
+	elseif(APPLE)
+		set(VCPKG_OVERLAY_PORTS "${CMAKE_CURRENT_LIST_DIR}/dependencies/vcpkg_overlay_ports_mac")
+	else()
+		set(VCPKG_OVERLAY_PORTS "${CMAKE_CURRENT_LIST_DIR}/dependencies/vcpkg_overlay_ports")
+	endif()
 	set(CMAKE_TOOLCHAIN_FILE "${CMAKE_CURRENT_SOURCE_DIR}/dependencies/vcpkg/scripts/buildsystems/vcpkg.cmake"
 		CACHE STRING "Vcpkg toolchain file")
 	# Set this so that all the various find_package() calls don't need an explicit
@@ -20,7 +53,7 @@ if (ENABLE_VCPKG)
 	endif()
 endif()
 
-project(Cemu VERSION 2.0)
+project(Cemu VERSION 2.0.0)
 
 list(APPEND CMAKE_MODULE_PATH "${PROJECT_SOURCE_DIR}/cmake")
 
@@ -29,13 +62,18 @@ set(CMAKE_CXX_STANDARD_REQUIRED ON)
 
 set(CMAKE_EXPORT_COMPILE_COMMANDS ON)
 
-if (PUBLIC_RELEASE)
-	add_compile_definitions(PUBLIC_RELEASE)
-	set(CMAKE_INTERPROCEDURAL_OPTIMIZATION TRUE) # enable LTO
-endif()
+add_compile_definitions($<$<CONFIG:Debug>:CEMU_DEBUG_ASSERT>) # if build type is debug, set CEMU_DEBUG_ASSERT
+
+add_definitions(-DEMULATOR_VERSION_MAJOR=${EMULATOR_VERSION_MAJOR})
+add_definitions(-DEMULATOR_VERSION_MINOR=${EMULATOR_VERSION_MINOR})
+add_definitions(-DEMULATOR_VERSION_PATCH=${EMULATOR_VERSION_PATCH})
 
 set_property(GLOBAL PROPERTY USE_FOLDERS ON)
 
+# enable link time optimization for release builds
+set(CMAKE_INTERPROCEDURAL_OPTIMIZATION_RELEASE ON)
+set(CMAKE_INTERPROCEDURAL_OPTIMIZATION_RELWITHDEBINFO ON)
+
 if (MSVC)
 	set_property(DIRECTORY ${CMAKE_CURRENT_SOURCE_DIR} PROPERTY VS_STARTUP_PROJECT CemuBin)
 	# floating point model: precise, fiber safe optimizations
@@ -48,22 +86,35 @@ if (MSVC)
   	else()
 	  add_compile_options(/GT)
 	endif()
-	if (PUBLIC_RELEASE)
-		message(STATUS "Using additional optimization flags for MSVC")
-		add_compile_options(/Oi /Ot) # enable intrinsic functions, favor speed
-	endif()
+	# enable additional optimization flags for release builds
+	add_compile_options($<$<CONFIG:Release,RelWithDebInfo>:/Oi>) # enable intrinsic functions
+	add_compile_options($<$<CONFIG:Release,RelWithDebInfo>:/Ot>) # favor speed
+endif()
+
+if (APPLE)
+    enable_language(OBJC OBJCXX)
+    set(CMAKE_OSX_DEPLOYMENT_TARGET "12.0")
+endif()
+
+if (UNIX AND NOT APPLE)
+	option(ENABLE_WAYLAND "Build with Wayland support" ON)
+	option(ENABLE_FERAL_GAMEMODE "Enables Feral Interactive GameMode Support" ON)
+	option(ENABLE_BLUEZ "Build with Bluez support" ON)
 endif()
 
 option(ENABLE_OPENGL "Enables the OpenGL backend" ON)
 option(ENABLE_VULKAN "Enables the Vulkan backend" ON)
 option(ENABLE_DISCORD_RPC "Enables the Discord Rich Presence feature" ON)
 
+
 # input backends
 if (WIN32)
 	option(ENABLE_XINPUT "Enables the usage of XInput" ON)
 	option(ENABLE_DIRECTINPUT "Enables the usage of DirectInput" ON)
 	add_compile_definitions(HAS_DIRECTINPUT)
 endif()
+
+option(ENABLE_HIDAPI "Build with HIDAPI" ON)
 option(ENABLE_SDL "Enables the SDLController backend" ON)
 
 # audio backends
@@ -80,7 +131,6 @@ find_package(Threads REQUIRED)
 find_package(SDL2 REQUIRED)
 find_package(CURL REQUIRED)
 find_package(pugixml REQUIRED)
-find_package(imgui REQUIRED)
 find_package(RapidJSON REQUIRED)
 find_package(Boost COMPONENTS program_options filesystem nowide REQUIRED)
 find_package(libzip REQUIRED)
@@ -89,7 +139,7 @@ find_package(ZLIB REQUIRED)
 find_package(zstd MODULE REQUIRED) # MODULE so that zstd::zstd is available
 find_package(OpenSSL COMPONENTS Crypto SSL REQUIRED)
 find_package(glm REQUIRED)
-find_package(fmt 9.1.0 REQUIRED)
+find_package(fmt 9 REQUIRED)
 find_package(PNG REQUIRED)
 
 # glslang versions older than 11.11.0 define targets without a namespace
@@ -99,6 +149,27 @@ endif()
 
 if (UNIX AND NOT APPLE)
 	find_package(X11 REQUIRED)
+	if (ENABLE_WAYLAND)
+		find_package(Wayland REQUIRED Client)
+		find_package(WaylandScanner REQUIRED)
+		find_package(WaylandProtocols 1.15 REQUIRED)
+
+		ecm_add_wayland_client_protocol(WAYLAND_PROTOCOL_SRCS
+			PROTOCOL "${WaylandProtocols_DATADIR}/stable/viewporter/viewporter.xml"
+			BASENAME viewporter)
+		add_library(CemuWaylandProtocols STATIC ${WAYLAND_PROTOCOL_SRCS})
+		target_include_directories(CemuWaylandProtocols PUBLIC "${CMAKE_CURRENT_BINARY_DIR}")
+
+		add_compile_definitions(HAS_WAYLAND)
+	endif()
+	find_package(GTK3 REQUIRED)
+
+	if(ENABLE_BLUEZ)
+		find_package(bluez REQUIRED)
+		set(SUPPORTS_WIIMOTE ON)
+		add_compile_definitions(HAS_BLUEZ)
+	endif()
+
 endif()
 
 if (ENABLE_VULKAN)
@@ -115,18 +186,34 @@ if (ENABLE_DISCORD_RPC)
 	target_include_directories(discord-rpc INTERFACE ./dependencies/discord-rpc/include)
 endif()
 
+if (ENABLE_HIDAPI)
+	find_package(hidapi REQUIRED)
+	set(SUPPORTS_WIIMOTE ON)
+	add_compile_definitions(HAS_HIDAPI)
+endif ()
+
+if(UNIX AND NOT APPLE)
+	if(ENABLE_FERAL_GAMEMODE)
+		add_compile_definitions(ENABLE_FERAL_GAMEMODE)
+		add_subdirectory(dependencies/gamemode EXCLUDE_FROM_ALL)
+		target_include_directories(gamemode INTERFACE ./dependencies/gamemode/lib)
+	endif()
+endif()
+
 if (ENABLE_WXWIDGETS)
 	find_package(wxWidgets 3.2 REQUIRED COMPONENTS base core gl propgrid xrc)
 endif()
 
 if (ENABLE_CUBEB)
+	if (NOT ENABLE_VCPKG)
 	find_package(cubeb)
+	endif()
 	if (NOT cubeb_FOUND)
 		option(BUILD_TESTS "" OFF)
 		option(BUILD_TOOLS "" OFF)
 		option(BUNDLE_SPEEX "" OFF)
 		set(USE_WINMM OFF CACHE BOOL "")
-		add_subdirectory("dependencies/cubeb" EXCLUDE_FROM_ALL)
+		add_subdirectory("dependencies/cubeb" EXCLUDE_FROM_ALL SYSTEM)
 		set_property(TARGET cubeb PROPERTY MSVC_RUNTIME_LIBRARY "MultiThreaded$<$<CONFIG:Debug>:Debug>")
 		add_library(cubeb::cubeb ALIAS cubeb)
 	endif()
@@ -135,9 +222,18 @@ endif()
 
 add_subdirectory("dependencies/ih264d" EXCLUDE_FROM_ALL)
 
+if (CMAKE_OSX_ARCHITECTURES)
+	set(CEMU_ARCHITECTURE ${CMAKE_OSX_ARCHITECTURES})
+else()
+	set(CEMU_ARCHITECTURE ${CMAKE_SYSTEM_PROCESSOR})
+endif()
+if(CEMU_ARCHITECTURE MATCHES "(aarch64)|(AARCH64)|(arm64)|(ARM64)")
+	add_subdirectory("dependencies/xbyak_aarch64" EXCLUDE_FROM_ALL)
+endif()
+
 find_package(ZArchive)
 if (NOT ZArchive_FOUND)
 	add_subdirectory("dependencies/ZArchive" EXCLUDE_FROM_ALL)
 endif()
 
-add_subdirectory(src)
+add_subdirectory(src)
\ No newline at end of file
diff --git a/CMakeSettings.json b/CMakeSettings.json
index f7f9fe6e..0927e98b 100644
--- a/CMakeSettings.json
+++ b/CMakeSettings.json
@@ -1,7 +1,7 @@
 {
   "configurations": [
     {
-      "name": "Release",
+      "name": "RelWithDebInfo",
       "configurationType": "RelWithDebInfo",
       "generator": "Ninja",
       "inheritEnvironments": [ "msvc_x64_x64" ],
@@ -9,13 +9,12 @@
       "installRoot": "${projectDir}\\out\\install\\${name}"
     },
     {
-      "name": "Public Release",
-      "configurationType": "RelWithDebInfo",
+      "name": "Release",
+      "configurationType": "Release",
       "generator": "Ninja",
       "inheritEnvironments": [ "msvc_x64_x64" ],
       "buildRoot": "${projectDir}\\out\\build\\${name}",
-      "installRoot": "${projectDir}\\out\\install\\${name}",
-      "cmakeCommandArgs": "-DPUBLIC_RELEASE=ON"
+      "installRoot": "${projectDir}\\out\\install\\${name}"
     },
     {
       "name": "Debug",
diff --git a/CODING_STYLE.md b/CODING_STYLE.md
new file mode 100644
index 00000000..39e1d342
--- /dev/null
+++ b/CODING_STYLE.md
@@ -0,0 +1,99 @@
+
+# Coding style guidelines for Cemu
+
+This document describes the latest version of our coding-style guidelines. Since we did not use this style from the beginning, older code may not adhere to these guidelines. Nevertheless, use these rules even if the surrounding code does not match. 
+
+Cemu comes with a `.clang-format` file which is supported by most IDEs for formatting. Avoid auto-reformatting whole files, PRs with a lot of formatting changes are difficult to review.
+
+## Names for variables, functions and classes
+
+- Always prefix class member variables with `m_`
+- Always prefix static class variables with `s_`
+- For variable names: Camel case, starting with a lower case letter after the prefix. Examples: `m_option`, `s_audioVolume`
+- For functions/class names: Use camel case starting with a capital letter. Examples: `MyClass`, `SetActive`
+- Avoid underscores in variable names after the prefix. Use `m_myVariable` instead of `m_my_variable`
+
+## About types
+
+Cemu provides its own set of basic fixed-width types. They are:
+`uint8`, `sint8`, `uint16`, `sint16`, `uint32`, `sint32`, `uint64`, `sint64`. Always use these types over something like `uint32_t`. Using `size_t` is also acceptable where suitable. Avoid C types like `int` or `long`. The only exception is when interacting with external libraries which expect these types as parameters.
+
+## When and where to put brackets
+
+Always put curly-brackets (`{ }`) on their own line. Example:
+
+```
+void FooBar()
+{
+   if (m_hasFoo)
+   {
+       ...
+   }
+}
+```
+As an exception, you can put short lambdas onto the same line:
+```
+SomeFunc([]() { .... });
+```
+You can skip brackets for single-statement `if`. Example:
+```
+if (cond)
+    action();
+```
+
+## Printing
+
+Avoid sprintf and similar C-style formatting API. Use `fmt::format()`.  
+In UI related code you can use `formatWxString`, but be aware that number formatting with this function will be locale dependent!
+
+## Strings and encoding
+
+We use UTF-8 encoded `std::string` where possible. Some conversions need special handling and we have helper functions for those:
+```cpp
+// std::filesystem::path <-> std::string (in precompiled.h)
+std::string _pathToUtf8(const fs::path& path);
+fs::path _utf8ToPath(std::string_view input);
+
+// wxString <-> std::string
+wxString wxString::FromUTF8(const std::string& s)
+wxString to_wxString(std::string_view str); // in gui/helpers.h
+std::string wxString::utf8_string();
+
+```
+
+## Logging
+
+If you want to write to log.txt use `cemuLog_log()`. The log type parameter should be mostly self-explanatory. Use `LogType::Force` if you always want to log something. For example:  
+`cemuLog_log(LogType::Force, "The value is {}", 123);`
+
+## HLE and endianness
+
+A pretty large part of Cemu's code base are re-implementations of various Cafe OS modules (e.g. `coreinit.rpl`, `gx2.rpl`...). These generally run in the context of the emulated process, thus special care has to be taken to use types with the correct size and endianness when interacting with memory.
+
+Keep in mind that the emulated Espresso CPU is 32bit big-endian, while the host architectures targeted by Cemu are 64bit little-endian! 
+
+To keep code simple and remove the need for manual endian-swapping, Cemu has templates and aliases of the basic types with explicit endian-ness.
+For big-endian types add the suffix `be`. Example: `uint32be`
+
+When you need to store a pointer in the guest's memory. Use `MEMPTR<T>`. It will automatically store any pointer as 32bit big-endian. The pointer you store must point to memory that is within the guest address space.
+
+## HLE interfaces
+
+The implementation for each HLE module is inside a namespace with a matching name. E.g. `coreinit.rpl` functions go into `coreinit` namespace.
+
+To expose a new function as callable from within the emulated machine, use `cafeExportRegister` or `cafeExportRegisterFunc`. Here is a short example:
+```cpp
+namespace coreinit
+{
+	uint32 OSGetCoreCount()
+	{
+		return Espresso::CORE_COUNT;
+	}
+	
+	void Init()
+	{
+		cafeExportRegister("coreinit", OSGetCoreCount, LogType::CoreinitThread);
+	}
+}
+```
+You may also see some code which uses `osLib_addFunction` directly. This is a deprecated way of registering functions.
\ No newline at end of file
diff --git a/README.md b/README.md
index 14682b41..dfd35791 100644
--- a/README.md
+++ b/README.md
@@ -2,38 +2,39 @@
 
 [![Build Process](https://github.com/cemu-project/Cemu/actions/workflows/build.yml/badge.svg)](https://github.com/cemu-project/Cemu/actions/workflows/build.yml)
 [![Discord](https://img.shields.io/discord/286429969104764928?label=Cemu&logo=discord&logoColor=FFFFFF)](https://discord.gg/5psYsup)
-[![Matrix Server](https://img.shields.io/matrix/dev:cemu.info?server_fqdn=matrix.cemu.info&label=dev:cemu.info&logo=matrix&logoColor=FFFFFF)](https://matrix.to/#/#dev:cemu.info)
+[![Matrix Server](https://img.shields.io/matrix/cemu:cemu.info?server_fqdn=matrix.cemu.info&label=cemu:cemu.info&logo=matrix&logoColor=FFFFFF)](https://matrix.to/#/#cemu:cemu.info)
 
 This is the code repository of Cemu, a Wii U emulator that is able to run most Wii U games and homebrew in a playable state.
-It's written in C/C++ and is being actively developed with new features and fixes to increase compatibility, convenience and usability.
+It's written in C/C++ and is being actively developed with new features and fixes.
 
-Cemu is currently only available for 64-bit Windows and Linux devices.
+Cemu is currently only available for 64-bit Windows, Linux & macOS devices.
 
 ### Links:
- - [Original 2.0 announcement post](https://www.reddit.com/r/cemu/comments/wwa22c/cemu_20_announcement_linux_builds_opensource_and/)
+ - [Open Source Announcement](https://www.reddit.com/r/cemu/comments/wwa22c/cemu_20_announcement_linux_builds_opensource_and/)
  - [Official Website](https://cemu.info)
  - [Compatibility List/Wiki](https://wiki.cemu.info/wiki/Main_Page)
  - [Official Subreddit](https://reddit.com/r/Cemu)
  - [Official Discord](https://discord.gg/5psYsup)
- - [Unofficial Setup Guide](https://cemu.cfw.guide)
+ - [Official Matrix Server](https://matrix.to/#/#cemu:cemu.info)
+ - [Setup Guide](https://cemu.cfw.guide)
 
 #### Other relevant repositories:
  - [Cemu-Language](https://github.com/cemu-project/Cemu-Language)
- - [Cemu's Community Graphic Packs](https://github.com/ActualMandM/cemu_graphic_packs)
+ - [Cemu's Community Graphic Packs](https://github.com/cemu-project/cemu_graphic_packs)
 
 ## Download
 
-You can download the latest Cemu releases from the [GitHub Releases](https://github.com/cemu-project/Cemu/releases/) or from [Cemu's website](https://cemu.info).
+You can download the latest Cemu releases for Windows, Linux and Mac from the [GitHub Releases](https://github.com/cemu-project/Cemu/releases/). For Linux you can also find Cemu on [flathub](https://flathub.org/apps/info.cemu.Cemu).
 
-Cemu is currently only available in a portable format so no installation is required besides extracting it in a safe place.
+On Windows Cemu is currently only available in a portable format so no installation is required besides extracting it in a safe place.
 
-See [Current State Of Linux builds](https://github.com/cemu-project/Cemu/issues/1) for information on using Cemu natively on Linux.
+The native macOS build is currently purely experimental and should not be considered stable or ready for issue-free gameplay. There are also known issues with degraded performance due to the use of MoltenVK and Rosetta for ARM Macs. We appreciate your patience while we improve Cemu for macOS.
 
 Pre-2.0 releases can be found on Cemu's [changelog page](https://cemu.info/changelog.html).
 
 ## Build Instructions
 
-To compile Cemu yourself on Windows or Linux, view the [BUILD.md file](/BUILD.md).
+To compile Cemu yourself on Windows, Linux or macOS, view [BUILD.md](/BUILD.md).
 
 ## Issues
 
@@ -42,11 +43,12 @@ The old bug tracker can be found at [bugs.cemu.info](https://bugs.cemu.info) and
 
 ## Contributing
 
-Pull requests are very welcome. For easier coordination you can visit the developer discussion channel on Discord: [https://discord.gg/5psYsup](https://discord.gg/5psYsup).
+Pull requests are very welcome. For easier coordination you can visit the developer discussion channel on [Discord](https://discord.gg/5psYsup) or alternatively the [Matrix Server](https://matrix.to/#/#cemu:cemu.info).
+Before submitting a pull request, please read and follow our code style guidelines listed in [CODING_STYLE.md](/CODING_STYLE.md).
 
 If coding isn't your thing, testing games and making detailed bug reports or updating the (usually outdated) compatibility wiki is also appreciated!
 
-Questions about Cemu's software architecture can also be answered on Discord. Alternative communication channels (like IRC) are being considered.
+Questions about Cemu's software architecture can also be answered on Discord (or through the Matrix bridge).
 
 ## License
 Cemu is licensed under [Mozilla Public License 2.0](/LICENSE.txt). Exempt from this are all files in the dependencies directory for which the licenses of the original code apply as well as some individual files in the src folder, as specified in those file headers respectively.
diff --git a/bin/gameProfiles/default/0005000010101a00.ini b/bin/gameProfiles/default/0005000010101a00.ini
index dc63ccb5..1123343a 100644
--- a/bin/gameProfiles/default/0005000010101a00.ini
+++ b/bin/gameProfiles/default/0005000010101a00.ini
@@ -1,7 +1 @@
-# LEGO City Undercover (USA)
-
-[General]
-loadSharedLibraries = false
-
-[Graphics]
-GPUBufferCacheAccuracy = 0
\ No newline at end of file
+# LEGO City Undercover (USA)
\ No newline at end of file
diff --git a/bin/gameProfiles/default/0005000010101b00.ini b/bin/gameProfiles/default/0005000010101b00.ini
index 21aded1d..f3749d47 100644
--- a/bin/gameProfiles/default/0005000010101b00.ini
+++ b/bin/gameProfiles/default/0005000010101b00.ini
@@ -1,7 +1 @@
-# LEGO City Undercover (EUR)
-
-[General]
-loadSharedLibraries = false
-
-[Graphics]
-GPUBufferCacheAccuracy = 0
\ No newline at end of file
+# LEGO City Undercover (EUR)
\ No newline at end of file
diff --git a/bin/gameProfiles/default/0005000010104d00.ini b/bin/gameProfiles/default/0005000010104d00.ini
index 50a9fa48..dc8bebaf 100644
--- a/bin/gameProfiles/default/0005000010104d00.ini
+++ b/bin/gameProfiles/default/0005000010104d00.ini
@@ -1,5 +1,4 @@
 # Monster Hunter 3(tri-)GHD Ver. (JPN)
 
 [Graphics]
-GPUBufferCacheAccuracy = 1
 streamoutBufferCacheSize = 48
\ No newline at end of file
diff --git a/bin/gameProfiles/default/0005000010106100.ini b/bin/gameProfiles/default/0005000010106100.ini
index 77e7c399..9aa38072 100644
--- a/bin/gameProfiles/default/0005000010106100.ini
+++ b/bin/gameProfiles/default/0005000010106100.ini
@@ -1,7 +1,4 @@
 # Super Mario 3D World (JPN)
 
-[CPU]
-
 [Graphics]
 accurateShaderMul = false
-GPUBufferCacheAccuracy = 2
\ No newline at end of file
diff --git a/bin/gameProfiles/default/000500001010EB00.ini b/bin/gameProfiles/default/000500001010EB00.ini
index e4b30b16..782398b5 100644
--- a/bin/gameProfiles/default/000500001010EB00.ini
+++ b/bin/gameProfiles/default/000500001010EB00.ini
@@ -1,7 +1 @@
-# Mario Kart 8 (JPN)
-
-[CPU]
-cpuMode = Singlecore-Recompiler
-
-[Graphics]
-GPUBufferCacheAccuracy = 2
\ No newline at end of file
+# Mario Kart 8 (JPN)
\ No newline at end of file
diff --git a/bin/gameProfiles/default/000500001010F900.ini b/bin/gameProfiles/default/000500001010F900.ini
index 4772db75..e22770bf 100644
--- a/bin/gameProfiles/default/000500001010F900.ini
+++ b/bin/gameProfiles/default/000500001010F900.ini
@@ -1,7 +1 @@
-# Scribblenauts Unlimited (EUR)
-
-[General]
-loadSharedLibraries = true
-
-[Graphics]
-GPUBufferCacheAccuracy = 0
\ No newline at end of file
+# Scribblenauts Unlimited (EUR)
\ No newline at end of file
diff --git a/bin/gameProfiles/default/000500001010ac00.ini b/bin/gameProfiles/default/000500001010ac00.ini
index 7df76e2f..9852538c 100644
--- a/bin/gameProfiles/default/000500001010ac00.ini
+++ b/bin/gameProfiles/default/000500001010ac00.ini
@@ -1,7 +1 @@
-# Ben 10 Omniverse (USA)
-
-[General]
-loadSharedLibraries = false
-
-[Graphics]
-GPUBufferCacheAccuracy = 0
\ No newline at end of file
+# Ben 10 Omniverse (USA)
\ No newline at end of file
diff --git a/bin/gameProfiles/default/000500001010b100.ini b/bin/gameProfiles/default/000500001010b100.ini
index e2215587..0741b39f 100644
--- a/bin/gameProfiles/default/000500001010b100.ini
+++ b/bin/gameProfiles/default/000500001010b100.ini
@@ -1,4 +1 @@
-# Rayman Legends (USA)
-
-[Graphics]
-GPUBufferCacheAccuracy = 0
\ No newline at end of file
+# Rayman Legends (USA)
\ No newline at end of file
diff --git a/bin/gameProfiles/default/000500001010b200.ini b/bin/gameProfiles/default/000500001010b200.ini
index d47b4060..22d51c39 100644
--- a/bin/gameProfiles/default/000500001010b200.ini
+++ b/bin/gameProfiles/default/000500001010b200.ini
@@ -1,7 +1 @@
-# Scribblenauts Unlimited (US)
-
-[General]
-loadSharedLibraries = true
-
-[Graphics]
-GPUBufferCacheAccuracy = 0
\ No newline at end of file
+# Scribblenauts Unlimited (US)
\ No newline at end of file
diff --git a/bin/gameProfiles/default/000500001010dc00.ini b/bin/gameProfiles/default/000500001010dc00.ini
index 11d0fd68..ffed75ea 100644
--- a/bin/gameProfiles/default/000500001010dc00.ini
+++ b/bin/gameProfiles/default/000500001010dc00.ini
@@ -1,4 +1 @@
-# Mass Effect 3 Special Edition (USA)
-
-[Graphics]
-GPUBufferCacheAccuracy = 0
\ No newline at end of file
+# Mass Effect 3 Special Edition (USA)
\ No newline at end of file
diff --git a/bin/gameProfiles/default/000500001010dd00.ini b/bin/gameProfiles/default/000500001010dd00.ini
index 5a0620da..2e74d7e0 100644
--- a/bin/gameProfiles/default/000500001010dd00.ini
+++ b/bin/gameProfiles/default/000500001010dd00.ini
@@ -1,4 +1 @@
-# ZombiU (US)
-
-[Graphics]
-GPUBufferCacheAccuracy = 0
\ No newline at end of file
+# ZombiU (US)
\ No newline at end of file
diff --git a/bin/gameProfiles/default/000500001010e600.ini b/bin/gameProfiles/default/000500001010e600.ini
index dc351608..01dc0e7a 100644
--- a/bin/gameProfiles/default/000500001010e600.ini
+++ b/bin/gameProfiles/default/000500001010e600.ini
@@ -1,4 +1 @@
-# 007 Legends (US)
-
-[Graphics]
-GPUBufferCacheAccuracy = 0
\ No newline at end of file
+# 007 Legends (US)
\ No newline at end of file
diff --git a/bin/gameProfiles/default/000500001010e700.ini b/bin/gameProfiles/default/000500001010e700.ini
index ea118074..a926c9d4 100644
--- a/bin/gameProfiles/default/000500001010e700.ini
+++ b/bin/gameProfiles/default/000500001010e700.ini
@@ -1,7 +1 @@
-# Cabela's Dangerous Hunts 2013 (USA)
-
-[General]
-loadSharedLibraries = false
-
-[Graphics]
-GPUBufferCacheAccuracy = 0
\ No newline at end of file
+# Cabela's Dangerous Hunts 2013 (USA)
\ No newline at end of file
diff --git a/bin/gameProfiles/default/000500001010ec00.ini b/bin/gameProfiles/default/000500001010ec00.ini
index babaf249..5d2dc9d8 100644
--- a/bin/gameProfiles/default/000500001010ec00.ini
+++ b/bin/gameProfiles/default/000500001010ec00.ini
@@ -1,7 +1 @@
-# Mario Kart 8 (USA)
-
-[CPU]
-cpuMode = Singlecore-Recompiler
-
-[Graphics]
-GPUBufferCacheAccuracy = 2
\ No newline at end of file
+# Mario Kart 8 (USA)
\ No newline at end of file
diff --git a/bin/gameProfiles/default/000500001010ed00.ini b/bin/gameProfiles/default/000500001010ed00.ini
index 7935ea37..dc1f4d52 100644
--- a/bin/gameProfiles/default/000500001010ed00.ini
+++ b/bin/gameProfiles/default/000500001010ed00.ini
@@ -1,7 +1 @@
-# Mario Kart 8 (EUR)
-
-[CPU]
-cpuMode = Singlecore-Recompiler
-
-[Graphics]
-GPUBufferCacheAccuracy = 2
\ No newline at end of file
+# Mario Kart 8 (EUR)
\ No newline at end of file
diff --git a/bin/gameProfiles/default/000500001010ef00.ini b/bin/gameProfiles/default/000500001010ef00.ini
index 005ba84b..dbadd2b1 100644
--- a/bin/gameProfiles/default/000500001010ef00.ini
+++ b/bin/gameProfiles/default/000500001010ef00.ini
@@ -1,4 +1 @@
-# ZombiU (EUR)
-
-[Graphics]
-GPUBufferCacheAccuracy = 0
\ No newline at end of file
+# ZombiU (EUR)
\ No newline at end of file
diff --git a/bin/gameProfiles/default/000500001010f100.ini b/bin/gameProfiles/default/000500001010f100.ini
index c557498c..025e3e70 100644
--- a/bin/gameProfiles/default/000500001010f100.ini
+++ b/bin/gameProfiles/default/000500001010f100.ini
@@ -1,7 +1 @@
-# Rise of the Guardians: The Video Game (EUR)
-
-[General]
-loadSharedLibraries = false
-
-[Graphics]
-GPUBufferCacheAccuracy = 0
\ No newline at end of file
+# Rise of the Guardians: The Video Game (EUR)
\ No newline at end of file
diff --git a/bin/gameProfiles/default/000500001010f200.ini b/bin/gameProfiles/default/000500001010f200.ini
index 055fda32..507b374b 100644
--- a/bin/gameProfiles/default/000500001010f200.ini
+++ b/bin/gameProfiles/default/000500001010f200.ini
@@ -1,7 +1 @@
-# Rise of the Guardians: The Video Game (USA)
-
-[General]
-loadSharedLibraries = false
-
-[Graphics]
-GPUBufferCacheAccuracy = 0
\ No newline at end of file
+# Rise of the Guardians: The Video Game (USA)
\ No newline at end of file
diff --git a/bin/gameProfiles/default/000500001010f500.ini b/bin/gameProfiles/default/000500001010f500.ini
index e1a86417..e598f517 100644
--- a/bin/gameProfiles/default/000500001010f500.ini
+++ b/bin/gameProfiles/default/000500001010f500.ini
@@ -1,4 +1 @@
-# Mass Effect 3 Special Edition (EUR)
-
-[Graphics]
-GPUBufferCacheAccuracy = 0
\ No newline at end of file
+# Mass Effect 3 Special Edition (EUR)
\ No newline at end of file
diff --git a/bin/gameProfiles/default/000500001011000.ini b/bin/gameProfiles/default/000500001011000.ini
deleted file mode 100644
index 85ebf4c6..00000000
--- a/bin/gameProfiles/default/000500001011000.ini
+++ /dev/null
@@ -1,7 +0,0 @@
-# Ben 10 Omniverse (EUR)
-
-[General]
-loadSharedLibraries = false
-
-[Graphics]
-GPUBufferCacheAccuracy = 0
\ No newline at end of file
diff --git a/bin/gameProfiles/default/0005000010110100.ini b/bin/gameProfiles/default/0005000010110100.ini
index 69b988cf..d46267b0 100644
--- a/bin/gameProfiles/default/0005000010110100.ini
+++ b/bin/gameProfiles/default/0005000010110100.ini
@@ -1,4 +1 @@
-# Nano Assault Neo (USA)
-
-[Graphics]
-GPUBufferCacheAccuracy = 2
\ No newline at end of file
+# Nano Assault Neo (USA)
\ No newline at end of file
diff --git a/bin/gameProfiles/default/0005000010110600.ini b/bin/gameProfiles/default/0005000010110600.ini
index fb19b607..bc0a0552 100644
--- a/bin/gameProfiles/default/0005000010110600.ini
+++ b/bin/gameProfiles/default/0005000010110600.ini
@@ -1,4 +1 @@
-# Nano Assault Neo (EUR)
-
-[Graphics]
-GPUBufferCacheAccuracy = 2
\ No newline at end of file
+# Nano Assault Neo (EUR)
\ No newline at end of file
diff --git a/bin/gameProfiles/default/0005000010110700.ini b/bin/gameProfiles/default/0005000010110700.ini
index e2d361c4..4e88d406 100644
--- a/bin/gameProfiles/default/0005000010110700.ini
+++ b/bin/gameProfiles/default/0005000010110700.ini
@@ -1,4 +1 @@
-# 007 Legends (EUR)
-
-[Graphics]
-GPUBufferCacheAccuracy = 0
\ No newline at end of file
+# 007 Legends (EUR)
\ No newline at end of file
diff --git a/bin/gameProfiles/default/0005000010110E00.ini b/bin/gameProfiles/default/0005000010110E00.ini
index 3064350f..6c56910f 100644
--- a/bin/gameProfiles/default/0005000010110E00.ini
+++ b/bin/gameProfiles/default/0005000010110E00.ini
@@ -5,4 +5,3 @@ cpuMode = Singlecore-Recompiler
 
 [Graphics]
 streamoutBufferCacheSize = 48
-GPUBufferCacheAccuracy = 2
\ No newline at end of file
diff --git a/bin/gameProfiles/default/0005000010111000.ini b/bin/gameProfiles/default/0005000010111000.ini
new file mode 100644
index 00000000..8c34cbab
--- /dev/null
+++ b/bin/gameProfiles/default/0005000010111000.ini
@@ -0,0 +1 @@
+# Ben 10 Omniverse (EUR)
\ No newline at end of file
diff --git a/bin/gameProfiles/default/0005000010111400.ini b/bin/gameProfiles/default/0005000010111400.ini
index 7fee0ed1..baa50914 100644
--- a/bin/gameProfiles/default/0005000010111400.ini
+++ b/bin/gameProfiles/default/0005000010111400.ini
@@ -1,4 +1 @@
-# Rayman Legends (EUR)
-
-[Graphics]
-GPUBufferCacheAccuracy = 0
\ No newline at end of file
+# Rayman Legends (EUR)
\ No newline at end of file
diff --git a/bin/gameProfiles/default/0005000010111600.ini b/bin/gameProfiles/default/0005000010111600.ini
index 6b433160..f1c13f22 100644
--- a/bin/gameProfiles/default/0005000010111600.ini
+++ b/bin/gameProfiles/default/0005000010111600.ini
@@ -1,7 +1 @@
-# Fast And Furious Showdown (USA)
-
-[General]
-loadSharedLibraries = false
-
-[Graphics]
-GPUBufferCacheAccuracy = 0
\ No newline at end of file
+# Fast And Furious Showdown (USA)
\ No newline at end of file
diff --git a/bin/gameProfiles/default/0005000010112000.ini b/bin/gameProfiles/default/0005000010112000.ini
index 853fc36b..3c7710d9 100644
--- a/bin/gameProfiles/default/0005000010112000.ini
+++ b/bin/gameProfiles/default/0005000010112000.ini
@@ -1,4 +1 @@
-# The Croods: Prehistoric Party! (USA)
-
-[Graphics]
-GPUBufferCacheAccuracy = 0
\ No newline at end of file
+# The Croods: Prehistoric Party! (USA)
\ No newline at end of file
diff --git a/bin/gameProfiles/default/0005000010112300.ini b/bin/gameProfiles/default/0005000010112300.ini
index 5fe50f24..37d8050f 100644
--- a/bin/gameProfiles/default/0005000010112300.ini
+++ b/bin/gameProfiles/default/0005000010112300.ini
@@ -1,4 +1 @@
-# ZombiU (JPN)
-
-[Graphics]
-GPUBufferCacheAccuracy = 0
\ No newline at end of file
+# ZombiU (JPN)
\ No newline at end of file
diff --git a/bin/gameProfiles/default/0005000010113000.ini b/bin/gameProfiles/default/0005000010113000.ini
index 30330b89..6c023330 100644
--- a/bin/gameProfiles/default/0005000010113000.ini
+++ b/bin/gameProfiles/default/0005000010113000.ini
@@ -1,4 +1 @@
-# Mass Effect 3 Special Edition (JPN)
-
-[Graphics]
-GPUBufferCacheAccuracy = 0
\ No newline at end of file
+# Mass Effect 3 Special Edition (JPN)
\ No newline at end of file
diff --git a/bin/gameProfiles/default/0005000010113300.ini b/bin/gameProfiles/default/0005000010113300.ini
index af55851d..5118d05f 100644
--- a/bin/gameProfiles/default/0005000010113300.ini
+++ b/bin/gameProfiles/default/0005000010113300.ini
@@ -1,4 +1 @@
-# The Smurfs 2 (USA)
-
-[Graphics]
-GPUBufferCacheAccuracy = 0
\ No newline at end of file
+# The Smurfs 2 (USA)
\ No newline at end of file
diff --git a/bin/gameProfiles/default/0005000010113d00.ini b/bin/gameProfiles/default/0005000010113d00.ini
index 51369705..afb42bf8 100644
--- a/bin/gameProfiles/default/0005000010113d00.ini
+++ b/bin/gameProfiles/default/0005000010113d00.ini
@@ -1,4 +1 @@
-# Rapala Pro Bass Fishing (US)
-
-[Graphics]
-GPUBufferCacheAccuracy = 0
\ No newline at end of file
+# Rapala Pro Bass Fishing (US)
\ No newline at end of file
diff --git a/bin/gameProfiles/default/0005000010115d00.ini b/bin/gameProfiles/default/0005000010115d00.ini
index 5a00554b..84bb9fad 100644
--- a/bin/gameProfiles/default/0005000010115d00.ini
+++ b/bin/gameProfiles/default/0005000010115d00.ini
@@ -1,4 +1 @@
-# The Smurfs 2 (EUR)
-
-[Graphics]
-GPUBufferCacheAccuracy = 0
\ No newline at end of file
+# The Smurfs 2 (EUR)
\ No newline at end of file
diff --git a/bin/gameProfiles/default/0005000010116100.ini b/bin/gameProfiles/default/0005000010116100.ini
index 8f01e5fa..465d3dc3 100644
--- a/bin/gameProfiles/default/0005000010116100.ini
+++ b/bin/gameProfiles/default/0005000010116100.ini
@@ -5,4 +5,3 @@ cpuMode = Singlecore-Recompiler
 
 [Graphics]
 accurateShaderMul = false
-GPUBufferCacheAccuracy = 2
\ No newline at end of file
diff --git a/bin/gameProfiles/default/0005000010117200.ini b/bin/gameProfiles/default/0005000010117200.ini
index e802c38e..4000f79f 100644
--- a/bin/gameProfiles/default/0005000010117200.ini
+++ b/bin/gameProfiles/default/0005000010117200.ini
@@ -1,5 +1,4 @@
 # Monster Hunter 3 Ultimate (EUR)
 
 [Graphics]
-GPUBufferCacheAccuracy = 1
 streamoutBufferCacheSize = 48
\ No newline at end of file
diff --git a/bin/gameProfiles/default/0005000010118300.ini b/bin/gameProfiles/default/0005000010118300.ini
index 4ba8d937..e69a6b95 100644
--- a/bin/gameProfiles/default/0005000010118300.ini
+++ b/bin/gameProfiles/default/0005000010118300.ini
@@ -1,5 +1,4 @@
 # Monster Hunter 3 Ultimate (USA)
 
 [Graphics]
-GPUBufferCacheAccuracy = 1
 streamoutBufferCacheSize = 48
\ No newline at end of file
diff --git a/bin/gameProfiles/default/000500001011a600.ini b/bin/gameProfiles/default/000500001011a600.ini
index 7c673d05..454aaf08 100644
--- a/bin/gameProfiles/default/000500001011a600.ini
+++ b/bin/gameProfiles/default/000500001011a600.ini
@@ -1,7 +1 @@
-# Cabela's Dangerous Hunts 2013 (EUR)
-
-[General]
-loadSharedLibraries = false
-
-[Graphics]
-GPUBufferCacheAccuracy = 0
\ No newline at end of file
+# Cabela's Dangerous Hunts 2013 (EUR)
\ No newline at end of file
diff --git a/bin/gameProfiles/default/000500001011af00.ini b/bin/gameProfiles/default/000500001011af00.ini
index c7bc4826..73c8f567 100644
--- a/bin/gameProfiles/default/000500001011af00.ini
+++ b/bin/gameProfiles/default/000500001011af00.ini
@@ -1,4 +1 @@
-# BIT.TRIP Presents... Runner2: Future Legend of Rhythm Alien (USA)
-
-[Graphics]
-GPUBufferCacheAccuracy = 0
\ No newline at end of file
+# BIT.TRIP Presents... Runner2: Future Legend of Rhythm Alien (USA)
\ No newline at end of file
diff --git a/bin/gameProfiles/default/000500001011b200.ini b/bin/gameProfiles/default/000500001011b200.ini
index 64edf0af..4a576434 100644
--- a/bin/gameProfiles/default/000500001011b200.ini
+++ b/bin/gameProfiles/default/000500001011b200.ini
@@ -1,7 +1,4 @@
 # Little Inferno (US)
 
-[CPU]
-extendedTextureReadback = true
-
 [Graphics]
-GPUBufferCacheAccuracy = 0
\ No newline at end of file
+extendedTextureReadback = true
\ No newline at end of file
diff --git a/bin/gameProfiles/default/0005000010128600.ini b/bin/gameProfiles/default/0005000010128600.ini
index 467f0014..cd6c1b18 100644
--- a/bin/gameProfiles/default/0005000010128600.ini
+++ b/bin/gameProfiles/default/0005000010128600.ini
@@ -1,5 +1,4 @@
 # Little Inferno (EUR)
 
-[CPU]
+[Graphics]
 extendedTextureReadback = true
-GPUBufferCacheAccuracy = 0
\ No newline at end of file
diff --git a/bin/gameProfiles/default/0005000010129000.ini b/bin/gameProfiles/default/0005000010129000.ini
index e1a9d9c5..93403c3c 100644
--- a/bin/gameProfiles/default/0005000010129000.ini
+++ b/bin/gameProfiles/default/0005000010129000.ini
@@ -4,5 +4,4 @@
 cpuMode = Singlecore-Recompiler
 
 [Graphics]
-GPUBufferCacheAccuracy = 0
 streamoutBufferCacheSize = 48
\ No newline at end of file
diff --git a/bin/gameProfiles/default/0005000010129200.ini b/bin/gameProfiles/default/0005000010129200.ini
index 33c2f21a..8705ce00 100644
--- a/bin/gameProfiles/default/0005000010129200.ini
+++ b/bin/gameProfiles/default/0005000010129200.ini
@@ -4,5 +4,4 @@
 cpuMode = Singlecore-Recompiler
 
 [Graphics]
-GPUBufferCacheAccuracy = 0
 streamoutBufferCacheSize = 48
\ No newline at end of file
diff --git a/bin/gameProfiles/default/000500001012BC00.ini b/bin/gameProfiles/default/000500001012BC00.ini
index c7adb846..0b4f6b6d 100644
--- a/bin/gameProfiles/default/000500001012BC00.ini
+++ b/bin/gameProfiles/default/000500001012BC00.ini
@@ -1,8 +1,4 @@
 # Pikmin 3 (JPN)
 
-
-
 [Graphics]
-
 extendedTextureReadback = true
-GPUBufferCacheAccuracy = 2
\ No newline at end of file
diff --git a/bin/gameProfiles/default/000500001012BD00.ini b/bin/gameProfiles/default/000500001012BD00.ini
index 8ab10175..cd27ff77 100644
--- a/bin/gameProfiles/default/000500001012BD00.ini
+++ b/bin/gameProfiles/default/000500001012BD00.ini
@@ -1,8 +1,4 @@
 # Pikmin 3 (USA)
 
-
-
 [Graphics]
-
 extendedTextureReadback = true
-GPUBufferCacheAccuracy = 2
\ No newline at end of file
diff --git a/bin/gameProfiles/default/000500001012F000.ini b/bin/gameProfiles/default/000500001012F000.ini
index af1229e6..6b1a3f95 100644
--- a/bin/gameProfiles/default/000500001012F000.ini
+++ b/bin/gameProfiles/default/000500001012F000.ini
@@ -2,6 +2,3 @@
 
 [CPU]
 cpuMode = Singlecore-Recompiler
-
-[Graphics]
-GPUBufferCacheAccuracy = 1
\ No newline at end of file
diff --git a/bin/gameProfiles/default/000500001012b200.ini b/bin/gameProfiles/default/000500001012b200.ini
index b00c1a04..9f3733ff 100644
--- a/bin/gameProfiles/default/000500001012b200.ini
+++ b/bin/gameProfiles/default/000500001012b200.ini
@@ -4,6 +4,5 @@
 loadSharedLibraries = false
 
 [Graphics]
-GPUBufferCacheAccuracy = 0
 extendedTextureReadback = true
 streamoutBufferCacheSize = 48
\ No newline at end of file
diff --git a/bin/gameProfiles/default/000500001012ba00.ini b/bin/gameProfiles/default/000500001012ba00.ini
index 7e94a7fd..efab660e 100644
--- a/bin/gameProfiles/default/000500001012ba00.ini
+++ b/bin/gameProfiles/default/000500001012ba00.ini
@@ -4,6 +4,5 @@
 loadSharedLibraries = false
 
 [Graphics]
-GPUBufferCacheAccuracy = 0
 extendedTextureReadback = true
 streamoutBufferCacheSize = 48
\ No newline at end of file
diff --git a/bin/gameProfiles/default/000500001012be00.ini b/bin/gameProfiles/default/000500001012be00.ini
index 2987dd1e..64a38b0d 100644
--- a/bin/gameProfiles/default/000500001012be00.ini
+++ b/bin/gameProfiles/default/000500001012be00.ini
@@ -1,7 +1,4 @@
 # Pikmin 3 (EU)
 
-
-
 [Graphics]
-
 extendedTextureReadback = true
\ No newline at end of file
diff --git a/bin/gameProfiles/default/000500001012c500.ini b/bin/gameProfiles/default/000500001012c500.ini
index 9badd49e..e4cc6690 100644
--- a/bin/gameProfiles/default/000500001012c500.ini
+++ b/bin/gameProfiles/default/000500001012c500.ini
@@ -1,4 +1 @@
-# The Croods: Prehistoric Party! (EUR)
-
-[Graphics]
-GPUBufferCacheAccuracy = 0
\ No newline at end of file
+# The Croods: Prehistoric Party! (EUR)
\ No newline at end of file
diff --git a/bin/gameProfiles/default/000500001012da00.ini b/bin/gameProfiles/default/000500001012da00.ini
index 4f478ace..8812e297 100644
--- a/bin/gameProfiles/default/000500001012da00.ini
+++ b/bin/gameProfiles/default/000500001012da00.ini
@@ -1,7 +1 @@
-# Fast And Furious Showdown (EUR)
-
-[General]
-loadSharedLibraries = false
-
-[Graphics]
-GPUBufferCacheAccuracy = 0
\ No newline at end of file
+# Fast And Furious Showdown (EUR)
\ No newline at end of file
diff --git a/bin/gameProfiles/default/0005000010131F00.ini b/bin/gameProfiles/default/0005000010131F00.ini
index 9b2dde57..b484aa82 100644
--- a/bin/gameProfiles/default/0005000010131F00.ini
+++ b/bin/gameProfiles/default/0005000010131F00.ini
@@ -1,4 +1 @@
-# Yoshi's Woolly World (JPN)
-
-[Graphics]
-GPUBufferCacheAccuracy = 2
\ No newline at end of file
+# Yoshi's Woolly World (JPN)
\ No newline at end of file
diff --git a/bin/gameProfiles/default/0005000010132c00.ini b/bin/gameProfiles/default/0005000010132c00.ini
index 00e83b4c..ff554b6e 100644
--- a/bin/gameProfiles/default/0005000010132c00.ini
+++ b/bin/gameProfiles/default/0005000010132c00.ini
@@ -1,4 +1 @@
-# Scribblenauts Unmasked: A DC Comics Adventure (US)
-
-[Graphics]
-GPUBufferCacheAccuracy = 0
\ No newline at end of file
+# Scribblenauts Unmasked: A DC Comics Adventure (US)
\ No newline at end of file
diff --git a/bin/gameProfiles/default/0005000010132d00.ini b/bin/gameProfiles/default/0005000010132d00.ini
index d516cd8f..3655b674 100644
--- a/bin/gameProfiles/default/0005000010132d00.ini
+++ b/bin/gameProfiles/default/0005000010132d00.ini
@@ -1,4 +1 @@
-# Scribblenauts Unmasked: A DC Comics Adventure (EUR)
-
-[Graphics]
-GPUBufferCacheAccuracy = 0
\ No newline at end of file
+# Scribblenauts Unmasked: A DC Comics Adventure (EUR)
\ No newline at end of file
diff --git a/bin/gameProfiles/default/0005000010133b00.ini b/bin/gameProfiles/default/0005000010133b00.ini
index 465ef364..ae2c8a48 100644
--- a/bin/gameProfiles/default/0005000010133b00.ini
+++ b/bin/gameProfiles/default/0005000010133b00.ini
@@ -1,4 +1 @@
-# Sniper Elite V2 (EUR)
-
-[Graphics]
-GPUBufferCacheAccuracy = 1
\ No newline at end of file
+# Sniper Elite V2 (EUR)
\ No newline at end of file
diff --git a/bin/gameProfiles/default/0005000010134e00.ini b/bin/gameProfiles/default/0005000010134e00.ini
index e04cdd74..99ff8b41 100644
--- a/bin/gameProfiles/default/0005000010134e00.ini
+++ b/bin/gameProfiles/default/0005000010134e00.ini
@@ -1,4 +1 @@
-# Sniper Elite V2 (USA)
-
-[Graphics]
-GPUBufferCacheAccuracy = 1
\ No newline at end of file
+# Sniper Elite V2 (USA)
\ No newline at end of file
diff --git a/bin/gameProfiles/default/0005000010135500.ini b/bin/gameProfiles/default/0005000010135500.ini
index cc008930..71f1c152 100644
--- a/bin/gameProfiles/default/0005000010135500.ini
+++ b/bin/gameProfiles/default/0005000010135500.ini
@@ -1,7 +1 @@
-# LEGO Batman 2: DC Super Heroes (EUR)
-
-[General]
-loadSharedLibraries = false
-
-[Graphics]
-GPUBufferCacheAccuracy = 0
\ No newline at end of file
+# LEGO Batman 2: DC Super Heroes (EUR)
\ No newline at end of file
diff --git a/bin/gameProfiles/default/0005000010135e00.ini b/bin/gameProfiles/default/0005000010135e00.ini
index ea135acc..1319dfe5 100644
--- a/bin/gameProfiles/default/0005000010135e00.ini
+++ b/bin/gameProfiles/default/0005000010135e00.ini
@@ -1,5 +1 @@
-# LEGO Batman 2: DC Super Heroes (USA)
-
-[General]
-loadSharedLibraries = false
-GPUBufferCacheAccuracy = 0
\ No newline at end of file
+# LEGO Batman 2: DC Super Heroes (USA)
\ No newline at end of file
diff --git a/bin/gameProfiles/default/0005000010136300.ini b/bin/gameProfiles/default/0005000010136300.ini
index 19e3176f..b37053e0 100644
--- a/bin/gameProfiles/default/0005000010136300.ini
+++ b/bin/gameProfiles/default/0005000010136300.ini
@@ -1,4 +1 @@
-# BIT.TRIP Presents... Runner2: Future Legend of Rhythm Alien (EUR)
-
-[Graphics]
-GPUBufferCacheAccuracy = 0
\ No newline at end of file
+# BIT.TRIP Presents... Runner2: Future Legend of Rhythm Alien (EUR)
\ No newline at end of file
diff --git a/bin/gameProfiles/default/0005000010136c00.ini b/bin/gameProfiles/default/0005000010136c00.ini
index 8d9d5448..427a45fe 100644
--- a/bin/gameProfiles/default/0005000010136c00.ini
+++ b/bin/gameProfiles/default/0005000010136c00.ini
@@ -4,5 +4,4 @@
 cpuMode = Singlecore-Recompiler
 
 [Graphics]
-GPUBufferCacheAccuracy = 0
 streamoutBufferCacheSize = 48
\ No newline at end of file
diff --git a/bin/gameProfiles/default/0005000010137F00.ini b/bin/gameProfiles/default/0005000010137F00.ini
index c9cddecc..151d5394 100644
--- a/bin/gameProfiles/default/0005000010137F00.ini
+++ b/bin/gameProfiles/default/0005000010137F00.ini
@@ -1,4 +1 @@
-# DKC: Tropical Freeze (USA)
-
-[Graphics]
-GPUBufferCacheAccuracy = 0
\ No newline at end of file
+# DKC: Tropical Freeze (USA)
\ No newline at end of file
diff --git a/bin/gameProfiles/default/0005000010137c00.ini b/bin/gameProfiles/default/0005000010137c00.ini
index db36989b..88fff6e7 100644
--- a/bin/gameProfiles/default/0005000010137c00.ini
+++ b/bin/gameProfiles/default/0005000010137c00.ini
@@ -4,5 +4,4 @@
 cpuMode = Singlecore-Recompiler
 
 [Graphics]
-GPUBufferCacheAccuracy = 0
 streamoutBufferCacheSize = 48
\ No newline at end of file
diff --git a/bin/gameProfiles/default/0005000010138300.ini b/bin/gameProfiles/default/0005000010138300.ini
index 4385df2e..d992cb24 100644
--- a/bin/gameProfiles/default/0005000010138300.ini
+++ b/bin/gameProfiles/default/0005000010138300.ini
@@ -1,4 +1 @@
-# DKC: Tropical Freeze (EUR)
-
-[Graphics]
-GPUBufferCacheAccuracy = 0
\ No newline at end of file
+# DKC: Tropical Freeze (EUR)
\ No newline at end of file
diff --git a/bin/gameProfiles/default/0005000010138a00.ini b/bin/gameProfiles/default/0005000010138a00.ini
index 8a4f621e..26318009 100644
--- a/bin/gameProfiles/default/0005000010138a00.ini
+++ b/bin/gameProfiles/default/0005000010138a00.ini
@@ -1,4 +1 @@
-# Angry Birds Trilogy  (USA)
-
-[Graphics]
-GPUBufferCacheAccuracy = 0
\ No newline at end of file
+# Angry Birds Trilogy  (USA)
\ No newline at end of file
diff --git a/bin/gameProfiles/default/0005000010138f00.ini b/bin/gameProfiles/default/0005000010138f00.ini
index df1f79ea..1f46d11d 100644
--- a/bin/gameProfiles/default/0005000010138f00.ini
+++ b/bin/gameProfiles/default/0005000010138f00.ini
@@ -1,5 +1,4 @@
 # Devil's Third (JPN)
 
 [Graphics]
-GPUBufferCacheAccuracy = 0
 streamoutBufferCacheSize = 48
\ No newline at end of file
diff --git a/bin/gameProfiles/default/0005000010140000.ini b/bin/gameProfiles/default/0005000010140000.ini
index 9afff7f4..347a4481 100644
--- a/bin/gameProfiles/default/0005000010140000.ini
+++ b/bin/gameProfiles/default/0005000010140000.ini
@@ -1,4 +1 @@
-# Angry Birds Trilogy  (EUR)
-
-[Graphics]
-GPUBufferCacheAccuracy = 0
\ No newline at end of file
+# Angry Birds Trilogy  (EUR)
\ No newline at end of file
diff --git a/bin/gameProfiles/default/0005000010143200.ini b/bin/gameProfiles/default/0005000010143200.ini
new file mode 100644
index 00000000..7085a558
--- /dev/null
+++ b/bin/gameProfiles/default/0005000010143200.ini
@@ -0,0 +1 @@
+# Cabela's Big Game Hunter: Pro Hunts (USA)
\ No newline at end of file
diff --git a/bin/gameProfiles/default/0005000010143500.ini b/bin/gameProfiles/default/0005000010143500.ini
index a9266121..c8b93998 100644
--- a/bin/gameProfiles/default/0005000010143500.ini
+++ b/bin/gameProfiles/default/0005000010143500.ini
@@ -1,6 +1 @@
-# TLoZ: Wind Waker HD (USA)
-
-[CPU]
-
-[Graphics]
-GPUBufferCacheAccuracy = 2
\ No newline at end of file
+# TLoZ: Wind Waker HD (USA)
\ No newline at end of file
diff --git a/bin/gameProfiles/default/0005000010143600.ini b/bin/gameProfiles/default/0005000010143600.ini
index 6ba5a4c0..6414c25d 100644
--- a/bin/gameProfiles/default/0005000010143600.ini
+++ b/bin/gameProfiles/default/0005000010143600.ini
@@ -1,6 +1 @@
-# TLoZ: Wind Waker HD (EUR)
-
-[CPU]
-
-[Graphics]
-GPUBufferCacheAccuracy = 2
\ No newline at end of file
+# TLoZ: Wind Waker HD (EUR)
\ No newline at end of file
diff --git a/bin/gameProfiles/default/0005000010144800.ini b/bin/gameProfiles/default/0005000010144800.ini
index 55a4e962..80721cd0 100644
--- a/bin/gameProfiles/default/0005000010144800.ini
+++ b/bin/gameProfiles/default/0005000010144800.ini
@@ -1,4 +1 @@
-# DKC: Tropical Freeze (JPN)
-
-[Graphics]
-GPUBufferCacheAccuracy = 0
\ No newline at end of file
+# DKC: Tropical Freeze (JPN)
\ No newline at end of file
diff --git a/bin/gameProfiles/default/0005000010144f00.ini b/bin/gameProfiles/default/0005000010144f00.ini
index 6bbc9e28..c2fce59a 100644
--- a/bin/gameProfiles/default/0005000010144f00.ini
+++ b/bin/gameProfiles/default/0005000010144f00.ini
@@ -5,4 +5,3 @@ cpuMode = Singlecore-Recompiler
 
 [Graphics]
 streamoutBufferCacheSize = 48
-GPUBufferCacheAccuracy = 2
\ No newline at end of file
diff --git a/bin/gameProfiles/default/0005000010145000.ini b/bin/gameProfiles/default/0005000010145000.ini
index f286269f..ace52dba 100644
--- a/bin/gameProfiles/default/0005000010145000.ini
+++ b/bin/gameProfiles/default/0005000010145000.ini
@@ -5,4 +5,3 @@ cpuMode = Singlecore-Recompiler
 
 [Graphics]
 streamoutBufferCacheSize = 48
-GPUBufferCacheAccuracy = 2
\ No newline at end of file
diff --git a/bin/gameProfiles/default/0005000010145c00.ini b/bin/gameProfiles/default/0005000010145c00.ini
index b82867e4..0be65fcc 100644
--- a/bin/gameProfiles/default/0005000010145c00.ini
+++ b/bin/gameProfiles/default/0005000010145c00.ini
@@ -1,7 +1,4 @@
 # Super Mario 3D World (USA)
 
-[CPU]
-
 [Graphics]
-accurateShaderMul = false
-GPUBufferCacheAccuracy = 2
\ No newline at end of file
+accurateShaderMul = false
\ No newline at end of file
diff --git a/bin/gameProfiles/default/0005000010145d00.ini b/bin/gameProfiles/default/0005000010145d00.ini
index 99c70dfe..3525edd8 100644
--- a/bin/gameProfiles/default/0005000010145d00.ini
+++ b/bin/gameProfiles/default/0005000010145d00.ini
@@ -1,7 +1,4 @@
 # Super Mario 3D World (EUR)
 
-[CPU]
-
 [Graphics]
-accurateShaderMul = false
-GPUBufferCacheAccuracy = 2
\ No newline at end of file
+accurateShaderMul = false
\ No newline at end of file
diff --git a/bin/gameProfiles/default/0005000010147e00.ini b/bin/gameProfiles/default/0005000010147e00.ini
index f5f73b9c..62109cc9 100644
--- a/bin/gameProfiles/default/0005000010147e00.ini
+++ b/bin/gameProfiles/default/0005000010147e00.ini
@@ -1,4 +1 @@
-# Hello Kitty Kruisers (USA)
-
-[Graphics]
-GPUBufferCacheAccuracy = 0
\ No newline at end of file
+# Hello Kitty Kruisers (USA)
\ No newline at end of file
diff --git a/bin/gameProfiles/default/000500001014c100.ini b/bin/gameProfiles/default/000500001014c100.ini
index da5f4d3a..64add666 100644
--- a/bin/gameProfiles/default/000500001014c100.ini
+++ b/bin/gameProfiles/default/000500001014c100.ini
@@ -1,4 +1 @@
-# Transformers: Rise of the Dark Spark (USA)
-
-[Graphics]
-GPUBufferCacheAccuracy = 0
\ No newline at end of file
+# Transformers: Rise of the Dark Spark (USA)
\ No newline at end of file
diff --git a/bin/gameProfiles/default/000500001014c600.ini b/bin/gameProfiles/default/000500001014c600.ini
index d83ea1d8..ff80f137 100644
--- a/bin/gameProfiles/default/000500001014c600.ini
+++ b/bin/gameProfiles/default/000500001014c600.ini
@@ -1,4 +1 @@
-# Giana Sisters Twisted Dreams (EUR)
-
-[Graphics]
-GPUBufferCacheAccuracy = 0
\ No newline at end of file
+# Giana Sisters Twisted Dreams (EUR)
\ No newline at end of file
diff --git a/bin/gameProfiles/default/000500001014cb00.ini b/bin/gameProfiles/default/000500001014cb00.ini
index 24e6e8d9..3ab3829e 100644
--- a/bin/gameProfiles/default/000500001014cb00.ini
+++ b/bin/gameProfiles/default/000500001014cb00.ini
@@ -1,4 +1 @@
-# Giana Sisters Twisted Dreams (USA)
-
-[Graphics]
-GPUBufferCacheAccuracy = 0
\ No newline at end of file
+# Giana Sisters Twisted Dreams (USA)
\ No newline at end of file
diff --git a/bin/gameProfiles/default/000500001014d900.ini b/bin/gameProfiles/default/000500001014d900.ini
index b3fae051..d234ff8a 100644
--- a/bin/gameProfiles/default/000500001014d900.ini
+++ b/bin/gameProfiles/default/000500001014d900.ini
@@ -1,4 +1 @@
-# PUYO PUYO TETRIS (JPN)
-
-[Graphics]
-GPUBufferCacheAccuracy = 0
\ No newline at end of file
+# PUYO PUYO TETRIS (JPN)
\ No newline at end of file
diff --git a/bin/gameProfiles/default/0005000010154600.ini b/bin/gameProfiles/default/0005000010154600.ini
index 8bdd8b98..d5af6dc0 100644
--- a/bin/gameProfiles/default/0005000010154600.ini
+++ b/bin/gameProfiles/default/0005000010154600.ini
@@ -4,5 +4,4 @@
 cpuMode = Singlecore-Recompiler
 
 [Graphics]
-GPUBufferCacheAccuracy = 0
 streamoutBufferCacheSize = 48
\ No newline at end of file
diff --git a/bin/gameProfiles/default/000500001015b200.ini b/bin/gameProfiles/default/000500001015b200.ini
index fd7aad16..a3872d6f 100644
--- a/bin/gameProfiles/default/000500001015b200.ini
+++ b/bin/gameProfiles/default/000500001015b200.ini
@@ -1,4 +1 @@
-# Child of Light (USA)
-
-[Graphics]
-GPUBufferCacheAccuracy = 1
\ No newline at end of file
+# Child of Light (USA)
\ No newline at end of file
diff --git a/bin/gameProfiles/default/0005000010161a00.ini b/bin/gameProfiles/default/0005000010161a00.ini
index 8bd28664..88e02890 100644
--- a/bin/gameProfiles/default/0005000010161a00.ini
+++ b/bin/gameProfiles/default/0005000010161a00.ini
@@ -1,4 +1 @@
-# How to Train Your Dragon 2 (USA)
-
-[Graphics]
-GPUBufferCacheAccuracy = 0
\ No newline at end of file
+# How to Train Your Dragon 2 (USA)
\ No newline at end of file
diff --git a/bin/gameProfiles/default/0005000010162200.ini b/bin/gameProfiles/default/0005000010162200.ini
index 70e5edf4..66363dfe 100644
--- a/bin/gameProfiles/default/0005000010162200.ini
+++ b/bin/gameProfiles/default/0005000010162200.ini
@@ -1,4 +1 @@
-# Monkey Pirates (EUR)
-
-[Graphics]
-GPUBufferCacheAccuracy = 0
\ No newline at end of file
+# Monkey Pirates (EUR)
\ No newline at end of file
diff --git a/bin/gameProfiles/default/0005000010162a00.ini b/bin/gameProfiles/default/0005000010162a00.ini
index e20011d0..3df87ebb 100644
--- a/bin/gameProfiles/default/0005000010162a00.ini
+++ b/bin/gameProfiles/default/0005000010162a00.ini
@@ -1,4 +1 @@
-# How to Train Your Dragon 2 (EUR)
-
-[Graphics]
-GPUBufferCacheAccuracy = 0
\ No newline at end of file
+# How to Train Your Dragon 2 (EUR)
\ No newline at end of file
diff --git a/bin/gameProfiles/default/0005000010162b00.ini b/bin/gameProfiles/default/0005000010162b00.ini
index 9802ca1d..8a50f6f6 100644
--- a/bin/gameProfiles/default/0005000010162b00.ini
+++ b/bin/gameProfiles/default/0005000010162b00.ini
@@ -1,6 +1 @@
-# Splatoon (JPN)
-
-[CPU]
-
-[Graphics]
-GPUBufferCacheAccuracy = 2
\ No newline at end of file
+# Splatoon (JPN)
\ No newline at end of file
diff --git a/bin/gameProfiles/default/000500001016a200.ini b/bin/gameProfiles/default/000500001016a200.ini
index da6a7805..655bc980 100644
--- a/bin/gameProfiles/default/000500001016a200.ini
+++ b/bin/gameProfiles/default/000500001016a200.ini
@@ -1,4 +1 @@
-# Bombing Bastards (EUR)
-
-[Graphics]
-GPUBufferCacheAccuracy = 0
\ No newline at end of file
+# Bombing Bastards (EUR)
\ No newline at end of file
diff --git a/bin/gameProfiles/default/000500001016ab00.ini b/bin/gameProfiles/default/000500001016ab00.ini
index 0090ca58..594d783c 100644
--- a/bin/gameProfiles/default/000500001016ab00.ini
+++ b/bin/gameProfiles/default/000500001016ab00.ini
@@ -1,4 +1 @@
-# Bombing Bastards (USA)
-
-[Graphics]
-GPUBufferCacheAccuracy = 0
\ No newline at end of file
+# Bombing Bastards (USA)
\ No newline at end of file
diff --git a/bin/gameProfiles/default/000500001016b200.ini b/bin/gameProfiles/default/000500001016b200.ini
index 9dd87948..4db2bc79 100644
--- a/bin/gameProfiles/default/000500001016b200.ini
+++ b/bin/gameProfiles/default/000500001016b200.ini
@@ -6,6 +6,3 @@ useRDTSC = false
 [CPU]
 cpuTimer = cycleCounter
 cpuMode = Singlecore-Interpreter
-
-[Graphics]
-GPUBufferCacheAccuracy = 0
\ No newline at end of file
diff --git a/bin/gameProfiles/default/000500001016d400.ini b/bin/gameProfiles/default/000500001016d400.ini
index 74f031ec..56c1c0f8 100644
--- a/bin/gameProfiles/default/000500001016d400.ini
+++ b/bin/gameProfiles/default/000500001016d400.ini
@@ -1,4 +1 @@
-# Stick It to the Man (EUR)
-
-[Graphics]
-GPUBufferCacheAccuracy = 0
\ No newline at end of file
+# Stick It to the Man (EUR)
\ No newline at end of file
diff --git a/bin/gameProfiles/default/000500001016d800.ini b/bin/gameProfiles/default/000500001016d800.ini
index 3cd2b3d0..6a8a95b8 100644
--- a/bin/gameProfiles/default/000500001016d800.ini
+++ b/bin/gameProfiles/default/000500001016d800.ini
@@ -1,4 +1 @@
-# Child of Light (JPN)
-
-[Graphics]
-GPUBufferCacheAccuracy = 0
\ No newline at end of file
+# Child of Light (JPN)
\ No newline at end of file
diff --git a/bin/gameProfiles/default/000500001016da00.ini b/bin/gameProfiles/default/000500001016da00.ini
index 105b4406..d54f4f50 100644
--- a/bin/gameProfiles/default/000500001016da00.ini
+++ b/bin/gameProfiles/default/000500001016da00.ini
@@ -2,6 +2,3 @@
 
 [CPU]
 cpuMode = Singlecore-Interpreter
-
-[Graphics]
-GPUBufferCacheAccuracy = 0
\ No newline at end of file
diff --git a/bin/gameProfiles/default/000500001016e000.ini b/bin/gameProfiles/default/000500001016e000.ini
index 871da06e..c9ef12e2 100644
--- a/bin/gameProfiles/default/000500001016e000.ini
+++ b/bin/gameProfiles/default/000500001016e000.ini
@@ -1,4 +1 @@
-# Stick It to the Man (USA)
-
-[Graphics]
-GPUBufferCacheAccuracy = 0
\ No newline at end of file
+# Stick It to the Man (USA)
\ No newline at end of file
diff --git a/bin/gameProfiles/default/000500001016e800.ini b/bin/gameProfiles/default/000500001016e800.ini
index 13482456..4e578c17 100644
--- a/bin/gameProfiles/default/000500001016e800.ini
+++ b/bin/gameProfiles/default/000500001016e800.ini
@@ -6,6 +6,3 @@ useRDTSC = false
 [CPU]
 cpuTimer = cycleCounter
 cpuMode = Singlecore-Interpreter
-
-[Graphics]
-GPUBufferCacheAccuracy = 0
\ No newline at end of file
diff --git a/bin/gameProfiles/default/000500001016ea00.ini b/bin/gameProfiles/default/000500001016ea00.ini
index 6d72c2a2..50723312 100644
--- a/bin/gameProfiles/default/000500001016ea00.ini
+++ b/bin/gameProfiles/default/000500001016ea00.ini
@@ -1,4 +1 @@
-# Child of Light (EUR)
-
-[Graphics]
-GPUBufferCacheAccuracy = 1
\ No newline at end of file
+# Child of Light (EUR)
\ No newline at end of file
diff --git a/bin/gameProfiles/default/000500001016fc00.ini b/bin/gameProfiles/default/000500001016fc00.ini
index edd44103..9ac3ba4b 100644
--- a/bin/gameProfiles/default/000500001016fc00.ini
+++ b/bin/gameProfiles/default/000500001016fc00.ini
@@ -1,5 +1,4 @@
 # Aqua Moto Racing Utopia (USA)
 
-[GPU]
-GPUBufferCacheAccuracy = 0
+[Graphics]
 streamoutBufferCacheSize = 48
\ No newline at end of file
diff --git a/bin/gameProfiles/default/0005000010170100.ini b/bin/gameProfiles/default/0005000010170100.ini
index 848f53ff..3de1dd34 100644
--- a/bin/gameProfiles/default/0005000010170100.ini
+++ b/bin/gameProfiles/default/0005000010170100.ini
@@ -1,4 +1 @@
-# Monkey Pirates (USA)
-
-[Graphics]
-GPUBufferCacheAccuracy = 0
\ No newline at end of file
+# Monkey Pirates (USA)
\ No newline at end of file
diff --git a/bin/gameProfiles/default/0005000010172900.ini b/bin/gameProfiles/default/0005000010172900.ini
index 0414258a..5ed40dd0 100644
--- a/bin/gameProfiles/default/0005000010172900.ini
+++ b/bin/gameProfiles/default/0005000010172900.ini
@@ -1,5 +1,4 @@
 # Aqua Moto Racing Utopia (EUR)
 
-[GPU]
-GPUBufferCacheAccuracy = 0
+[Graphics]
 streamoutBufferCacheSize = 48
\ No newline at end of file
diff --git a/bin/gameProfiles/default/0005000010173400.ini b/bin/gameProfiles/default/0005000010173400.ini
index 99995af4..c4062977 100644
--- a/bin/gameProfiles/default/0005000010173400.ini
+++ b/bin/gameProfiles/default/0005000010173400.ini
@@ -1,4 +1 @@
-# Transformers: Rise of the Dark Spark (EUR)
-
-[Graphics]
-GPUBufferCacheAccuracy = 0
\ No newline at end of file
+# Transformers: Rise of the Dark Spark (EUR)
\ No newline at end of file
diff --git a/bin/gameProfiles/default/0005000010176300.ini b/bin/gameProfiles/default/0005000010176300.ini
index c8e0861c..30305418 100644
--- a/bin/gameProfiles/default/0005000010176300.ini
+++ b/bin/gameProfiles/default/0005000010176300.ini
@@ -1,5 +1,4 @@
 # Little Inferno (JPN)
 
-[CPU]
+[Graphics]
 extendedTextureReadback = true
-GPUBufferCacheAccuracy = 0
\ No newline at end of file
diff --git a/bin/gameProfiles/default/0005000010176900.ini b/bin/gameProfiles/default/0005000010176900.ini
index d6d36fb8..852c383a 100644
--- a/bin/gameProfiles/default/0005000010176900.ini
+++ b/bin/gameProfiles/default/0005000010176900.ini
@@ -1,6 +1 @@
-# Splatoon (USA)
-
-[CPU]
-
-[Graphics]
-GPUBufferCacheAccuracy = 2
\ No newline at end of file
+# Splatoon (USA)
\ No newline at end of file
diff --git a/bin/gameProfiles/default/0005000010176a00.ini b/bin/gameProfiles/default/0005000010176a00.ini
index f52d1658..e1dc631b 100644
--- a/bin/gameProfiles/default/0005000010176a00.ini
+++ b/bin/gameProfiles/default/0005000010176a00.ini
@@ -1,6 +1 @@
-# Splatoon (EUR)
-
-[CPU]
-
-[Graphics]
-GPUBufferCacheAccuracy = 2
\ No newline at end of file
+# Splatoon (EUR)
\ No newline at end of file
diff --git a/bin/gameProfiles/default/0005000010177000.ini b/bin/gameProfiles/default/0005000010177000.ini
index 1c47b1dc..bc7eebf4 100644
--- a/bin/gameProfiles/default/0005000010177000.ini
+++ b/bin/gameProfiles/default/0005000010177000.ini
@@ -1,4 +1 @@
-# Hello Kitty Kruisers (EUR)
-
-[Graphics]
-GPUBufferCacheAccuracy = 0
\ No newline at end of file
+# Hello Kitty Kruisers (EUR)
\ No newline at end of file
diff --git a/bin/gameProfiles/default/0005000010177500.ini b/bin/gameProfiles/default/0005000010177500.ini
index 74a0a58e..90be1c63 100644
--- a/bin/gameProfiles/default/0005000010177500.ini
+++ b/bin/gameProfiles/default/0005000010177500.ini
@@ -2,6 +2,3 @@
 
 [CPU]
 cpuMode = Singlecore-Interpreter
-
-[Graphics]
-GPUBufferCacheAccuracy = 0
\ No newline at end of file
diff --git a/bin/gameProfiles/default/0005000010177600.ini b/bin/gameProfiles/default/0005000010177600.ini
index 05792513..d1b955f1 100644
--- a/bin/gameProfiles/default/0005000010177600.ini
+++ b/bin/gameProfiles/default/0005000010177600.ini
@@ -1,5 +1,4 @@
 # Devil's Third (USA)
 
 [Graphics]
-GPUBufferCacheAccuracy = 0
 streamoutBufferCacheSize = 48
\ No newline at end of file
diff --git a/bin/gameProfiles/default/0005000010177700.ini b/bin/gameProfiles/default/0005000010177700.ini
index 072db711..e311f0ba 100644
--- a/bin/gameProfiles/default/0005000010177700.ini
+++ b/bin/gameProfiles/default/0005000010177700.ini
@@ -1,5 +1,4 @@
 # Devil's Third (EUR)
 
 [Graphics]
-GPUBufferCacheAccuracy = 0
 streamoutBufferCacheSize = 48
\ No newline at end of file
diff --git a/bin/gameProfiles/default/000500001017da00.ini b/bin/gameProfiles/default/000500001017da00.ini
index 6fc7282a..09b07927 100644
--- a/bin/gameProfiles/default/000500001017da00.ini
+++ b/bin/gameProfiles/default/000500001017da00.ini
@@ -1,4 +1 @@
-# Costume Quest 2 (USA)
-
-[Graphics]
-GPUBufferCacheAccuracy = 0
\ No newline at end of file
+# Costume Quest 2 (USA)
\ No newline at end of file
diff --git a/bin/gameProfiles/default/000500001017e400.ini b/bin/gameProfiles/default/000500001017e400.ini
index 562aa77a..723a374c 100644
--- a/bin/gameProfiles/default/000500001017e400.ini
+++ b/bin/gameProfiles/default/000500001017e400.ini
@@ -1,4 +1 @@
-# Chasing Dead (USA)
-
-[Graphics]
-GPUBufferCacheAccuracy = 0
+# Chasing Dead (USA)
\ No newline at end of file
diff --git a/bin/gameProfiles/default/0005000010180500.ini b/bin/gameProfiles/default/0005000010180500.ini
index d9258613..87ea51b5 100644
--- a/bin/gameProfiles/default/0005000010180500.ini
+++ b/bin/gameProfiles/default/0005000010180500.ini
@@ -1,7 +1,4 @@
 # Captain Toad: Treasure Tracker (JPN)
 
-[CPU]
-
 [Graphics]
 accurateShaderMul = false
-GPUBufferCacheAccuracy = 2
\ No newline at end of file
diff --git a/bin/gameProfiles/default/0005000010180600.ini b/bin/gameProfiles/default/0005000010180600.ini
index e7d7e325..8b2528e3 100644
--- a/bin/gameProfiles/default/0005000010180600.ini
+++ b/bin/gameProfiles/default/0005000010180600.ini
@@ -1,7 +1,4 @@
 # Captain Toad: Treasure Tracker (USA)
 
-[CPU]
-
 [Graphics]
 accurateShaderMul = false
-GPUBufferCacheAccuracy = 2
\ No newline at end of file
diff --git a/bin/gameProfiles/default/0005000010180700.ini b/bin/gameProfiles/default/0005000010180700.ini
index d0b7d792..3a7a8fe6 100644
--- a/bin/gameProfiles/default/0005000010180700.ini
+++ b/bin/gameProfiles/default/0005000010180700.ini
@@ -1,7 +1,4 @@
 # Captain Toad: Treasure Tracker (EUR)
 
-[CPU]
-
 [Graphics]
 accurateShaderMul = false
-GPUBufferCacheAccuracy = 2
\ No newline at end of file
diff --git a/bin/gameProfiles/default/0005000010183000.ini b/bin/gameProfiles/default/0005000010183000.ini
index 5b79f8a9..4b1c07cf 100644
--- a/bin/gameProfiles/default/0005000010183000.ini
+++ b/bin/gameProfiles/default/0005000010183000.ini
@@ -1,7 +1 @@
-# Runbow (USA)
-
-
-
-[Graphics]
-
-GPUBufferCacheAccuracy = 0
\ No newline at end of file
+# Runbow (USA)
\ No newline at end of file
diff --git a/bin/gameProfiles/default/0005000010184900.ini b/bin/gameProfiles/default/0005000010184900.ini
index 8c4d5b59..c3aac8e8 100644
--- a/bin/gameProfiles/default/0005000010184900.ini
+++ b/bin/gameProfiles/default/0005000010184900.ini
@@ -1,4 +1 @@
-# Slender: The Arrival (USA)
-
-[Graphics]
-GPUBufferCacheAccuracy = 0
\ No newline at end of file
+# Slender: The Arrival (USA)
\ No newline at end of file
diff --git a/bin/gameProfiles/default/0005000010184E00.ini b/bin/gameProfiles/default/0005000010184E00.ini
index 3ca24eda..4b282824 100644
--- a/bin/gameProfiles/default/0005000010184E00.ini
+++ b/bin/gameProfiles/default/0005000010184E00.ini
@@ -1,6 +1 @@
-# Yoshi's Woolly World (EUR)
-
-[CPU]
-
-[Graphics]
-GPUBufferCacheAccuracy = 2
\ No newline at end of file
+# Yoshi's Woolly World (EUR)
\ No newline at end of file
diff --git a/bin/gameProfiles/default/0005000010184d00.ini b/bin/gameProfiles/default/0005000010184d00.ini
index 83a64a5e..b1bb76a7 100644
--- a/bin/gameProfiles/default/0005000010184d00.ini
+++ b/bin/gameProfiles/default/0005000010184d00.ini
@@ -1,6 +1 @@
-# Yoshi's Woolly World (USA)
-
-[CPU]
-
-[Graphics]
-GPUBufferCacheAccuracy = 0
\ No newline at end of file
+# Yoshi's Woolly World (USA)
\ No newline at end of file
diff --git a/bin/gameProfiles/default/0005000010185400.ini b/bin/gameProfiles/default/0005000010185400.ini
index c69416ee..efd26cbb 100644
--- a/bin/gameProfiles/default/0005000010185400.ini
+++ b/bin/gameProfiles/default/0005000010185400.ini
@@ -1,6 +1 @@
-# TLoZ: Wind Waker HD (JPN)
-
-[CPU]
-
-[Graphics]
-GPUBufferCacheAccuracy = 2
\ No newline at end of file
+# TLoZ: Wind Waker HD (JPN)
\ No newline at end of file
diff --git a/bin/gameProfiles/default/0005000010189f00.ini b/bin/gameProfiles/default/0005000010189f00.ini
index a88c6891..ae998084 100644
--- a/bin/gameProfiles/default/0005000010189f00.ini
+++ b/bin/gameProfiles/default/0005000010189f00.ini
@@ -2,6 +2,3 @@
 
 [CPU]
 cpuTimer = hostBased
-
-[Graphics]
-GPUBufferCacheAccuracy = 0
\ No newline at end of file
diff --git a/bin/gameProfiles/default/000500001018ab00.ini b/bin/gameProfiles/default/000500001018ab00.ini
index 9eeef2ff..cd66a1a3 100644
--- a/bin/gameProfiles/default/000500001018ab00.ini
+++ b/bin/gameProfiles/default/000500001018ab00.ini
@@ -1,4 +1 @@
-# Affordable Space Adventures (USA)
-
-[Graphics]
-GPUBufferCacheAccuracy = 0
+# Affordable Space Adventures (USA)
\ No newline at end of file
diff --git a/bin/gameProfiles/default/000500001018d800.ini b/bin/gameProfiles/default/000500001018d800.ini
index 0e311245..196b4aba 100644
--- a/bin/gameProfiles/default/000500001018d800.ini
+++ b/bin/gameProfiles/default/000500001018d800.ini
@@ -1,4 +1 @@
-# SteamWorld Dig (EUR)
-
-[Graphics]
-GPUBufferCacheAccuracy = 0
\ No newline at end of file
+# SteamWorld Dig (EUR)
\ No newline at end of file
diff --git a/bin/gameProfiles/default/000500001018d900.ini b/bin/gameProfiles/default/000500001018d900.ini
index 4e8d8ead..779035e1 100644
--- a/bin/gameProfiles/default/000500001018d900.ini
+++ b/bin/gameProfiles/default/000500001018d900.ini
@@ -2,6 +2,3 @@
 
 [General]
 loadSharedLibraries = false
-
-[Graphics]
-GPUBufferCacheAccuracy = 0
\ No newline at end of file
diff --git a/bin/gameProfiles/default/000500001018f100.ini b/bin/gameProfiles/default/000500001018f100.ini
index 1a3c5fba..46ffcf0e 100644
--- a/bin/gameProfiles/default/000500001018f100.ini
+++ b/bin/gameProfiles/default/000500001018f100.ini
@@ -1,4 +1 @@
-# SteamWorld Dig (USA)
-
-[Graphics]
-GPUBufferCacheAccuracy = 0
\ No newline at end of file
+# SteamWorld Dig (USA)
\ No newline at end of file
diff --git a/bin/gameProfiles/default/000500001018f400.ini b/bin/gameProfiles/default/000500001018f400.ini
index ecf014cf..a22052e4 100644
--- a/bin/gameProfiles/default/000500001018f400.ini
+++ b/bin/gameProfiles/default/000500001018f400.ini
@@ -1,4 +1 @@
-# Angry Video Game Nerd Adventures (USA)
-
-[Graphics]
-GPUBufferCacheAccuracy = 0
\ No newline at end of file
+# Angry Video Game Nerd Adventures (USA)
\ No newline at end of file
diff --git a/bin/gameProfiles/default/000500001018fd00.ini b/bin/gameProfiles/default/000500001018fd00.ini
index 119e00c4..eaef68fe 100644
--- a/bin/gameProfiles/default/000500001018fd00.ini
+++ b/bin/gameProfiles/default/000500001018fd00.ini
@@ -1,4 +1 @@
-# The Penguins of Madagascar (USA)
-
-[Graphics]
-GPUBufferCacheAccuracy = 0
\ No newline at end of file
+# The Penguins of Madagascar (USA)
\ No newline at end of file
diff --git a/bin/gameProfiles/default/0005000010190300.ini b/bin/gameProfiles/default/0005000010190300.ini
index b9a41d4f..fe197295 100644
--- a/bin/gameProfiles/default/0005000010190300.ini
+++ b/bin/gameProfiles/default/0005000010190300.ini
@@ -5,7 +5,4 @@ useRDTSC = false
 
 [CPU]
 cpuMode = Singlecore-Recompiler
-cpuTimer = cycleCounter
-
-[Graphics]
-GPUBufferCacheAccuracy = 1
\ No newline at end of file
+cpuTimer = cycleCounter
\ No newline at end of file
diff --git a/bin/gameProfiles/default/0005000010193f00.ini b/bin/gameProfiles/default/0005000010193f00.ini
index 9d7f8a63..104a88ca 100644
--- a/bin/gameProfiles/default/0005000010193f00.ini
+++ b/bin/gameProfiles/default/0005000010193f00.ini
@@ -1,4 +1 @@
-# The Penguins of Madagascar (EUR)
-
-[Graphics]
-GPUBufferCacheAccuracy = 0
\ No newline at end of file
+# The Penguins of Madagascar (EUR)
\ No newline at end of file
diff --git a/bin/gameProfiles/default/0005000010195e00.ini b/bin/gameProfiles/default/0005000010195e00.ini
index 23d72923..23585737 100644
--- a/bin/gameProfiles/default/0005000010195e00.ini
+++ b/bin/gameProfiles/default/0005000010195e00.ini
@@ -1,4 +1 @@
-# Rock Zombie (US)
-
-[Graphics]
-GPUBufferCacheAccuracy = 0
\ No newline at end of file
+# Rock Zombie (US)
\ No newline at end of file
diff --git a/bin/gameProfiles/default/0005000010197300.ini b/bin/gameProfiles/default/0005000010197300.ini
index e15f1c7d..6f2dfa48 100644
--- a/bin/gameProfiles/default/0005000010197300.ini
+++ b/bin/gameProfiles/default/0005000010197300.ini
@@ -1,4 +1 @@
-# Electronic Super Joy Groove City (USA)
-
-[Graphics]
-GPUBufferCacheAccuracy = 0
\ No newline at end of file
+# Electronic Super Joy Groove City (USA)
\ No newline at end of file
diff --git a/bin/gameProfiles/default/0005000010197800.ini b/bin/gameProfiles/default/0005000010197800.ini
index 92839df2..2af2ef33 100644
--- a/bin/gameProfiles/default/0005000010197800.ini
+++ b/bin/gameProfiles/default/0005000010197800.ini
@@ -1,4 +1 @@
-# Costume Quest 2 (EUR)
-
-[Graphics]
-GPUBufferCacheAccuracy = 0
\ No newline at end of file
+# Costume Quest 2 (EUR)
\ No newline at end of file
diff --git a/bin/gameProfiles/default/0005000010199e00.ini b/bin/gameProfiles/default/0005000010199e00.ini
index 12c31235..01e1f2d5 100644
--- a/bin/gameProfiles/default/0005000010199e00.ini
+++ b/bin/gameProfiles/default/0005000010199e00.ini
@@ -1,4 +1 @@
-# High Strangeness (US)
-
-[Graphics]
-GPUBufferCacheAccuracy = 0
\ No newline at end of file
+# High Strangeness (US)
\ No newline at end of file
diff --git a/bin/gameProfiles/default/000500001019ab00.ini b/bin/gameProfiles/default/000500001019ab00.ini
index 12c31235..01e1f2d5 100644
--- a/bin/gameProfiles/default/000500001019ab00.ini
+++ b/bin/gameProfiles/default/000500001019ab00.ini
@@ -1,4 +1 @@
-# High Strangeness (US)
-
-[Graphics]
-GPUBufferCacheAccuracy = 0
\ No newline at end of file
+# High Strangeness (US)
\ No newline at end of file
diff --git a/bin/gameProfiles/default/000500001019b000.ini b/bin/gameProfiles/default/000500001019b000.ini
index 23e77a87..c458883f 100644
--- a/bin/gameProfiles/default/000500001019b000.ini
+++ b/bin/gameProfiles/default/000500001019b000.ini
@@ -1,4 +1 @@
-# Tachyon Project (USA)
-
-[Graphics]
-GPUBufferCacheAccuracy = 0
\ No newline at end of file
+# Tachyon Project (USA)
\ No newline at end of file
diff --git a/bin/gameProfiles/default/000500001019b200.ini b/bin/gameProfiles/default/000500001019b200.ini
index 6790a314..3e893f12 100644
--- a/bin/gameProfiles/default/000500001019b200.ini
+++ b/bin/gameProfiles/default/000500001019b200.ini
@@ -1,4 +1 @@
-# Tachyon Project (EUR)
-
-[Graphics]
-GPUBufferCacheAccuracy = 0
\ No newline at end of file
+# Tachyon Project (EUR)
\ No newline at end of file
diff --git a/bin/gameProfiles/default/000500001019ca00.ini b/bin/gameProfiles/default/000500001019ca00.ini
index 9187ed88..f79dd190 100644
--- a/bin/gameProfiles/default/000500001019ca00.ini
+++ b/bin/gameProfiles/default/000500001019ca00.ini
@@ -1,4 +1 @@
-# Rock Zombie (EUR)
-
-[Graphics]
-GPUBufferCacheAccuracy = 0
\ No newline at end of file
+# Rock Zombie (EUR)
\ No newline at end of file
diff --git a/bin/gameProfiles/default/000500001019e500.ini b/bin/gameProfiles/default/000500001019e500.ini
index 0ee89ea1..eec28dc9 100644
--- a/bin/gameProfiles/default/000500001019e500.ini
+++ b/bin/gameProfiles/default/000500001019e500.ini
@@ -1,6 +1 @@
-# TLoZ: Twilight Princess (US)
-
-[CPU]
-
-[Graphics]
-GPUBufferCacheAccuracy = 0
\ No newline at end of file
+# TLoZ: Twilight Princess (US)
\ No newline at end of file
diff --git a/bin/gameProfiles/default/000500001019e600.ini b/bin/gameProfiles/default/000500001019e600.ini
index 4f3aeecb..47380cbe 100644
--- a/bin/gameProfiles/default/000500001019e600.ini
+++ b/bin/gameProfiles/default/000500001019e600.ini
@@ -1,6 +1 @@
-# TLoZ: Twilight Princess (EU)
-
-[CPU]
-
-[Graphics]
-GPUBufferCacheAccuracy = 0
\ No newline at end of file
+# TLoZ: Twilight Princess (EU)
\ No newline at end of file
diff --git a/bin/gameProfiles/default/000500001019ea00.ini b/bin/gameProfiles/default/000500001019ea00.ini
index f69c7740..49250a19 100644
--- a/bin/gameProfiles/default/000500001019ea00.ini
+++ b/bin/gameProfiles/default/000500001019ea00.ini
@@ -1,4 +1 @@
-# Zombeer (USA)
-
-[Graphics]
-GPUBufferCacheAccuracy = 0
\ No newline at end of file
+# Zombeer (USA)
\ No newline at end of file
diff --git a/bin/gameProfiles/default/000500001019ee00.ini b/bin/gameProfiles/default/000500001019ee00.ini
index accf6993..958d2f84 100644
--- a/bin/gameProfiles/default/000500001019ee00.ini
+++ b/bin/gameProfiles/default/000500001019ee00.ini
@@ -1,4 +1 @@
-# Zombie Defense (USA)
-
-[Graphics]
-GPUBufferCacheAccuracy = 0
\ No newline at end of file
+# Zombie Defense (USA)
\ No newline at end of file
diff --git a/bin/gameProfiles/default/00050000101C9300.ini b/bin/gameProfiles/default/00050000101C9300.ini
index f3c94e8f..09f0706d 100644
--- a/bin/gameProfiles/default/00050000101C9300.ini
+++ b/bin/gameProfiles/default/00050000101C9300.ini
@@ -3,4 +3,3 @@
 [Graphics]
 disableGPUFence = false
 accurateShaderMul = true
-GPUBufferCacheAccuracy = 2
\ No newline at end of file
diff --git a/bin/gameProfiles/default/00050000101E4100.ini b/bin/gameProfiles/default/00050000101E4100.ini
index 71176e83..8b8165b1 100644
--- a/bin/gameProfiles/default/00050000101E4100.ini
+++ b/bin/gameProfiles/default/00050000101E4100.ini
@@ -2,6 +2,3 @@
 
 [CPU]
 cpuMode = Singlecore-Recompiler
-
-[Graphics]
-GPUBufferCacheAccuracy = 1
\ No newline at end of file
diff --git a/bin/gameProfiles/default/00050000101a1200.ini b/bin/gameProfiles/default/00050000101a1200.ini
index 76b1207a..4ff51799 100644
--- a/bin/gameProfiles/default/00050000101a1200.ini
+++ b/bin/gameProfiles/default/00050000101a1200.ini
@@ -1,5 +1 @@
-# Affordable Space Adventures (EUR)
-
-[Graphics]
-GPUBufferCacheAccuracy = 0
-
+# Affordable Space Adventures (EUR)
\ No newline at end of file
diff --git a/bin/gameProfiles/default/00050000101a1800.ini b/bin/gameProfiles/default/00050000101a1800.ini
index 94c50e45..56dd856c 100644
--- a/bin/gameProfiles/default/00050000101a1800.ini
+++ b/bin/gameProfiles/default/00050000101a1800.ini
@@ -1,4 +1 @@
-# Zombie Defense (EUR)
-
-[Graphics]
-GPUBufferCacheAccuracy = 0
\ No newline at end of file
+# Zombie Defense (EUR)
\ No newline at end of file
diff --git a/bin/gameProfiles/default/00050000101a3b00.ini b/bin/gameProfiles/default/00050000101a3b00.ini
index 2efa5016..44ec4fcb 100644
--- a/bin/gameProfiles/default/00050000101a3b00.ini
+++ b/bin/gameProfiles/default/00050000101a3b00.ini
@@ -1,4 +1 @@
-# Life of Pixel (USA)
-
-[Graphics]
-GPUBufferCacheAccuracy = 0
\ No newline at end of file
+# Life of Pixel (USA)
\ No newline at end of file
diff --git a/bin/gameProfiles/default/00050000101a4300.ini b/bin/gameProfiles/default/00050000101a4300.ini
index 1c49a9ab..80c72ed3 100644
--- a/bin/gameProfiles/default/00050000101a4300.ini
+++ b/bin/gameProfiles/default/00050000101a4300.ini
@@ -1,4 +1 @@
-# Beatbuddy (USA)
-
-[Graphics]
-GPUBufferCacheAccuracy = 0
\ No newline at end of file
+# Beatbuddy (USA)
\ No newline at end of file
diff --git a/bin/gameProfiles/default/00050000101a4800.ini b/bin/gameProfiles/default/00050000101a4800.ini
index bb446c86..64e552e9 100644
--- a/bin/gameProfiles/default/00050000101a4800.ini
+++ b/bin/gameProfiles/default/00050000101a4800.ini
@@ -2,6 +2,3 @@
 
 [General]
 loadSharedLibraries = false
-
-[Graphics]
-GPUBufferCacheAccuracy = 0
\ No newline at end of file
diff --git a/bin/gameProfiles/default/00050000101a4900.ini b/bin/gameProfiles/default/00050000101a4900.ini
index 74fedef3..3bb54df4 100644
--- a/bin/gameProfiles/default/00050000101a4900.ini
+++ b/bin/gameProfiles/default/00050000101a4900.ini
@@ -1,4 +1 @@
-# Life of Pixel (EUR)
-
-[Graphics]
-GPUBufferCacheAccuracy = 0
\ No newline at end of file
+# Life of Pixel (EUR)
\ No newline at end of file
diff --git a/bin/gameProfiles/default/00050000101a7f00.ini b/bin/gameProfiles/default/00050000101a7f00.ini
index 35f91d55..be575b52 100644
--- a/bin/gameProfiles/default/00050000101a7f00.ini
+++ b/bin/gameProfiles/default/00050000101a7f00.ini
@@ -1,4 +1 @@
-# Shiftlings (USA)
-
-[Graphics]
-GPUBufferCacheAccuracy = 0
\ No newline at end of file
+# Shiftlings (USA)
\ No newline at end of file
diff --git a/bin/gameProfiles/default/00050000101a9c00.ini b/bin/gameProfiles/default/00050000101a9c00.ini
index 651c8c01..6df3d13a 100644
--- a/bin/gameProfiles/default/00050000101a9c00.ini
+++ b/bin/gameProfiles/default/00050000101a9c00.ini
@@ -1,4 +1 @@
-# Chompy Chomp Chomp Party (EUR)
-
-[Graphics]
-GPUBufferCacheAccuracy = 0
\ No newline at end of file
+# Chompy Chomp Chomp Party (EUR)
\ No newline at end of file
diff --git a/bin/gameProfiles/default/00050000101a9e00.ini b/bin/gameProfiles/default/00050000101a9e00.ini
index 5fbd157c..a8853119 100644
--- a/bin/gameProfiles/default/00050000101a9e00.ini
+++ b/bin/gameProfiles/default/00050000101a9e00.ini
@@ -1,4 +1 @@
-# Chompy Chomp Chomp Party (USA)
-
-[Graphics]
-GPUBufferCacheAccuracy = 0
\ No newline at end of file
+# Chompy Chomp Chomp Party (USA)
\ No newline at end of file
diff --git a/bin/gameProfiles/default/00050000101acc00.ini b/bin/gameProfiles/default/00050000101acc00.ini
index d94071ac..6dae9607 100644
--- a/bin/gameProfiles/default/00050000101acc00.ini
+++ b/bin/gameProfiles/default/00050000101acc00.ini
@@ -1,4 +1 @@
-# Shiftlings (EUR)
-
-[Graphics]
-GPUBufferCacheAccuracy = 0
\ No newline at end of file
+# Shiftlings (EUR)
\ No newline at end of file
diff --git a/bin/gameProfiles/default/00050000101b0100.ini b/bin/gameProfiles/default/00050000101b0100.ini
index ed2f7bf9..1599daed 100644
--- a/bin/gameProfiles/default/00050000101b0100.ini
+++ b/bin/gameProfiles/default/00050000101b0100.ini
@@ -1,4 +1 @@
-# Funk of Titans (USA)
-
-[Graphics]
-GPUBufferCacheAccuracy = 0
\ No newline at end of file
+# Funk of Titans (USA)
\ No newline at end of file
diff --git a/bin/gameProfiles/default/00050000101b4e00.ini b/bin/gameProfiles/default/00050000101b4e00.ini
index 38642cbe..a0b90655 100644
--- a/bin/gameProfiles/default/00050000101b4e00.ini
+++ b/bin/gameProfiles/default/00050000101b4e00.ini
@@ -1,4 +1 @@
-# Funk of Titans (EUR)
-
-[Graphics]
-GPUBufferCacheAccuracy = 0
\ No newline at end of file
+# Funk of Titans (EUR)
\ No newline at end of file
diff --git a/bin/gameProfiles/default/00050000101b9900.ini b/bin/gameProfiles/default/00050000101b9900.ini
index ae410226..2e83fe40 100644
--- a/bin/gameProfiles/default/00050000101b9900.ini
+++ b/bin/gameProfiles/default/00050000101b9900.ini
@@ -2,6 +2,3 @@
 
 [General]
 loadSharedLibraries = false
-
-[Graphics]
-GPUBufferCacheAccuracy = 0
\ No newline at end of file
diff --git a/bin/gameProfiles/default/00050000101bc300.ini b/bin/gameProfiles/default/00050000101bc300.ini
index c7ec1da5..e880a0f1 100644
--- a/bin/gameProfiles/default/00050000101bc300.ini
+++ b/bin/gameProfiles/default/00050000101bc300.ini
@@ -1,4 +1 @@
-# Beatbuddy (EUR)
-
-[Graphics]
-GPUBufferCacheAccuracy = 0
\ No newline at end of file
+# Beatbuddy (EUR)
\ No newline at end of file
diff --git a/bin/gameProfiles/default/00050000101c3100.ini b/bin/gameProfiles/default/00050000101c3100.ini
index d7c2e293..c6f5c569 100644
--- a/bin/gameProfiles/default/00050000101c3100.ini
+++ b/bin/gameProfiles/default/00050000101c3100.ini
@@ -1,4 +1 @@
-# Freedom Planet (USA)
-
-[Graphics]
-GPUBufferCacheAccuracy = 0
\ No newline at end of file
+# Freedom Planet (USA)
\ No newline at end of file
diff --git a/bin/gameProfiles/default/00050000101c4200.ini b/bin/gameProfiles/default/00050000101c4200.ini
index 203ce9a7..c12944a3 100644
--- a/bin/gameProfiles/default/00050000101c4200.ini
+++ b/bin/gameProfiles/default/00050000101c4200.ini
@@ -1,4 +1 @@
-# The Peanuts Movie: Snoopy's Grand Adventure (USA)
-
-[Graphics]
-GPUBufferCacheAccuracy = 0
\ No newline at end of file
+# The Peanuts Movie: Snoopy's Grand Adventure (USA)
\ No newline at end of file
diff --git a/bin/gameProfiles/default/00050000101c4300.ini b/bin/gameProfiles/default/00050000101c4300.ini
index a2a79f38..549984d4 100644
--- a/bin/gameProfiles/default/00050000101c4300.ini
+++ b/bin/gameProfiles/default/00050000101c4300.ini
@@ -2,6 +2,3 @@
 
 [CPU]
 cpuMode = Singlecore-Recompiler
-
-[Graphics]
-GPUBufferCacheAccuracy = 0
\ No newline at end of file
diff --git a/bin/gameProfiles/default/00050000101c4c00.ini b/bin/gameProfiles/default/00050000101c4c00.ini
index 6e8fd71f..08ad5e5b 100644
--- a/bin/gameProfiles/default/00050000101c4c00.ini
+++ b/bin/gameProfiles/default/00050000101c4c00.ini
@@ -5,4 +5,3 @@ cpuMode = Singlecore-Recompiler
 
 [Graphics]
 accurateShaderMul = false
-GPUBufferCacheAccuracy = 2
\ No newline at end of file
diff --git a/bin/gameProfiles/default/00050000101c4d00.ini b/bin/gameProfiles/default/00050000101c4d00.ini
index 83301c0d..a1db58b0 100644
--- a/bin/gameProfiles/default/00050000101c4d00.ini
+++ b/bin/gameProfiles/default/00050000101c4d00.ini
@@ -5,4 +5,3 @@ cpuMode = Singlecore-Recompiler
 
 [Graphics]
 accurateShaderMul = false
-GPUBufferCacheAccuracy = 2
\ No newline at end of file
diff --git a/bin/gameProfiles/default/00050000101c6c00.ini b/bin/gameProfiles/default/00050000101c6c00.ini
index da9dd712..ff16d037 100644
--- a/bin/gameProfiles/default/00050000101c6c00.ini
+++ b/bin/gameProfiles/default/00050000101c6c00.ini
@@ -1,4 +1 @@
-# Typoman (USA)
-
-[Graphics]
-GPUBufferCacheAccuracy = 0
\ No newline at end of file
+# Typoman (USA)
\ No newline at end of file
diff --git a/bin/gameProfiles/default/00050000101c7600.ini b/bin/gameProfiles/default/00050000101c7600.ini
index 14128c7b..599520e4 100644
--- a/bin/gameProfiles/default/00050000101c7600.ini
+++ b/bin/gameProfiles/default/00050000101c7600.ini
@@ -1,4 +1 @@
-# Pumped BMX + (EUR)
-
-[Graphics]
-GPUBufferCacheAccuracy = 0
\ No newline at end of file
+# Pumped BMX + (EUR)
\ No newline at end of file
diff --git a/bin/gameProfiles/default/00050000101c7b00.ini b/bin/gameProfiles/default/00050000101c7b00.ini
index 7350d0b5..9b764f96 100644
--- a/bin/gameProfiles/default/00050000101c7b00.ini
+++ b/bin/gameProfiles/default/00050000101c7b00.ini
@@ -1,4 +1 @@
-# Chronicles of Teddy: Harmony of Exidus (USA)
-
-[Graphics]
-GPUBufferCacheAccuracy = 0
\ No newline at end of file
+# Chronicles of Teddy: Harmony of Exidus (USA)
\ No newline at end of file
diff --git a/bin/gameProfiles/default/00050000101c7d00.ini b/bin/gameProfiles/default/00050000101c7d00.ini
index 45ce4448..60a0dd23 100644
--- a/bin/gameProfiles/default/00050000101c7d00.ini
+++ b/bin/gameProfiles/default/00050000101c7d00.ini
@@ -1,4 +1 @@
-# Pumped BMX + (USA)
-
-[Graphics]
-GPUBufferCacheAccuracy = 0
\ No newline at end of file
+# Pumped BMX + (USA)
\ No newline at end of file
diff --git a/bin/gameProfiles/default/00050000101c9400.ini b/bin/gameProfiles/default/00050000101c9400.ini
index 86c1b839..585a9e6f 100644
--- a/bin/gameProfiles/default/00050000101c9400.ini
+++ b/bin/gameProfiles/default/00050000101c9400.ini
@@ -3,4 +3,3 @@
 [Graphics]
 disableGPUFence = false
 accurateShaderMul = true
-GPUBufferCacheAccuracy = 2
\ No newline at end of file
diff --git a/bin/gameProfiles/default/00050000101c9500.ini b/bin/gameProfiles/default/00050000101c9500.ini
index 4f326b32..71485002 100644
--- a/bin/gameProfiles/default/00050000101c9500.ini
+++ b/bin/gameProfiles/default/00050000101c9500.ini
@@ -3,4 +3,3 @@
 [Graphics]
 disableGPUFence = false
 accurateShaderMul = true
-GPUBufferCacheAccuracy = 2
\ No newline at end of file
diff --git a/bin/gameProfiles/default/00050000101c9a00.ini b/bin/gameProfiles/default/00050000101c9a00.ini
index 0cc7525b..026e593f 100644
--- a/bin/gameProfiles/default/00050000101c9a00.ini
+++ b/bin/gameProfiles/default/00050000101c9a00.ini
@@ -2,6 +2,3 @@
 
 [CPU]
 cpuMode = Singlecore-Recompiler
-
-[Graphics]
-GPUBufferCacheAccuracy = 0
\ No newline at end of file
diff --git a/bin/gameProfiles/default/00050000101cc900.ini b/bin/gameProfiles/default/00050000101cc900.ini
index dded48b2..ceaa7e67 100644
--- a/bin/gameProfiles/default/00050000101cc900.ini
+++ b/bin/gameProfiles/default/00050000101cc900.ini
@@ -1,4 +1 @@
-# Freedom Planet (EUR)
-
-[Graphics]
-GPUBufferCacheAccuracy = 0
\ No newline at end of file
+# Freedom Planet (EUR)
\ No newline at end of file
diff --git a/bin/gameProfiles/default/00050000101ccf00.ini b/bin/gameProfiles/default/00050000101ccf00.ini
index e71dfd8f..d3d497f1 100644
--- a/bin/gameProfiles/default/00050000101ccf00.ini
+++ b/bin/gameProfiles/default/00050000101ccf00.ini
@@ -1,4 +1 @@
-# Never Alone (Kisima Ingitchuna) (USA)
-
-[Graphics]
-GPUBufferCacheAccuracy = 0
\ No newline at end of file
+# Never Alone (Kisima Ingitchuna) (USA)
\ No newline at end of file
diff --git a/bin/gameProfiles/default/00050000101ce000.ini b/bin/gameProfiles/default/00050000101ce000.ini
index 69aa9dae..30a271e8 100644
--- a/bin/gameProfiles/default/00050000101ce000.ini
+++ b/bin/gameProfiles/default/00050000101ce000.ini
@@ -1,4 +1 @@
-# Typoman (EUR)
-
-[Graphics]
-GPUBufferCacheAccuracy = 0
\ No newline at end of file
+# Typoman (EUR)
\ No newline at end of file
diff --git a/bin/gameProfiles/default/00050000101ce800.ini b/bin/gameProfiles/default/00050000101ce800.ini
index 2cc75f8e..902e8e23 100644
--- a/bin/gameProfiles/default/00050000101ce800.ini
+++ b/bin/gameProfiles/default/00050000101ce800.ini
@@ -1,4 +1 @@
-# Never Alone (Kisima Ingitchuna) (EUR)
-
-[Graphics]
-GPUBufferCacheAccuracy = 0
\ No newline at end of file
+# Never Alone (Kisima Ingitchuna) (EUR)
\ No newline at end of file
diff --git a/bin/gameProfiles/default/00050000101d2100.ini b/bin/gameProfiles/default/00050000101d2100.ini
index caac5cdc..830f5f81 100644
--- a/bin/gameProfiles/default/00050000101d2100.ini
+++ b/bin/gameProfiles/default/00050000101d2100.ini
@@ -1,5 +1,4 @@
 # Little Inferno (US)
 
-[CPU]
+[Graphics]
 extendedTextureReadback = true
-GPUBufferCacheAccuracy = 0
\ No newline at end of file
diff --git a/bin/gameProfiles/default/00050000101d4500.ini b/bin/gameProfiles/default/00050000101d4500.ini
index 8ae9fc73..c8244324 100644
--- a/bin/gameProfiles/default/00050000101d4500.ini
+++ b/bin/gameProfiles/default/00050000101d4500.ini
@@ -1,4 +1 @@
-# Grumpy Reaper (USA)
-
-[Graphics]
-GPUBufferCacheAccuracy = 0
\ No newline at end of file
+# Grumpy Reaper (USA)
\ No newline at end of file
diff --git a/bin/gameProfiles/default/00050000101d4d00.ini b/bin/gameProfiles/default/00050000101d4d00.ini
index 5df2ddbb..23887c1f 100644
--- a/bin/gameProfiles/default/00050000101d4d00.ini
+++ b/bin/gameProfiles/default/00050000101d4d00.ini
@@ -1,4 +1 @@
-# Joe's Diner (EUR)
-
-[Graphics]
-GPUBufferCacheAccuracy = 0
\ No newline at end of file
+# Joe's Diner (EUR)
\ No newline at end of file
diff --git a/bin/gameProfiles/default/00050000101d5000.ini b/bin/gameProfiles/default/00050000101d5000.ini
index 2e1b8356..4cff3852 100644
--- a/bin/gameProfiles/default/00050000101d5000.ini
+++ b/bin/gameProfiles/default/00050000101d5000.ini
@@ -1,4 +1 @@
-# The Peanuts Movie: Snoopy's Grand Adventure (EUR)
-
-[Graphics]
-GPUBufferCacheAccuracy = 0
\ No newline at end of file
+# The Peanuts Movie: Snoopy's Grand Adventure (EUR)
\ No newline at end of file
diff --git a/bin/gameProfiles/default/00050000101d5500.ini b/bin/gameProfiles/default/00050000101d5500.ini
index 81bcef30..2e1f7542 100644
--- a/bin/gameProfiles/default/00050000101d5500.ini
+++ b/bin/gameProfiles/default/00050000101d5500.ini
@@ -1,4 +1 @@
-# Joe's Diner (USA)
-
-[Graphics]
-GPUBufferCacheAccuracy = 0
\ No newline at end of file
+# Joe's Diner (USA)
\ No newline at end of file
diff --git a/bin/gameProfiles/default/00050000101d6000.ini b/bin/gameProfiles/default/00050000101d6000.ini
index 129477c2..09ff9c3c 100644
--- a/bin/gameProfiles/default/00050000101d6000.ini
+++ b/bin/gameProfiles/default/00050000101d6000.ini
@@ -2,6 +2,3 @@
 
 [CPU]
 cpuMode = Singlecore-Recompiler
-
-[Graphics]
-GPUBufferCacheAccuracy = 1
\ No newline at end of file
diff --git a/bin/gameProfiles/default/00050000101d6d00.ini b/bin/gameProfiles/default/00050000101d6d00.ini
index 0bf677ba..a04e39c7 100644
--- a/bin/gameProfiles/default/00050000101d6d00.ini
+++ b/bin/gameProfiles/default/00050000101d6d00.ini
@@ -1,7 +1 @@
-# Runbow (EUR)
-
-
-
-[Graphics]
-
-GPUBufferCacheAccuracy = 0
\ No newline at end of file
+# Runbow (EUR)
\ No newline at end of file
diff --git a/bin/gameProfiles/default/00050000101d7500.ini b/bin/gameProfiles/default/00050000101d7500.ini
index 8707efcd..992b00cc 100644
--- a/bin/gameProfiles/default/00050000101d7500.ini
+++ b/bin/gameProfiles/default/00050000101d7500.ini
@@ -2,6 +2,3 @@
 
 [General]
 loadSharedLibraries = false
-
-[Graphics]
-GPUBufferCacheAccuracy = 0
\ No newline at end of file
diff --git a/bin/gameProfiles/default/00050000101d8900.ini b/bin/gameProfiles/default/00050000101d8900.ini
index 29b9698f..aaf7d122 100644
--- a/bin/gameProfiles/default/00050000101d8900.ini
+++ b/bin/gameProfiles/default/00050000101d8900.ini
@@ -1,4 +1 @@
-# Slender: The Arrival (EUR)
-
-[Graphics]
-GPUBufferCacheAccuracy = 0
\ No newline at end of file
+# Slender: The Arrival (EUR)
\ No newline at end of file
diff --git a/bin/gameProfiles/default/00050000101d8d00.ini b/bin/gameProfiles/default/00050000101d8d00.ini
index 864c446b..0b61b998 100644
--- a/bin/gameProfiles/default/00050000101d8d00.ini
+++ b/bin/gameProfiles/default/00050000101d8d00.ini
@@ -1,4 +1 @@
-# Rock 'N Racing Off Road DX (USA)
-
-[Graphics]
-GPUBufferCacheAccuracy = 1
\ No newline at end of file
+# Rock 'N Racing Off Road DX (USA)
\ No newline at end of file
diff --git a/bin/gameProfiles/default/00050000101d9600.ini b/bin/gameProfiles/default/00050000101d9600.ini
index c2c62b6a..aa4f9a10 100644
--- a/bin/gameProfiles/default/00050000101d9600.ini
+++ b/bin/gameProfiles/default/00050000101d9600.ini
@@ -1,4 +1 @@
-# Rock 'N Racing Off Road DX (EUR)
-
-[Graphics]
-GPUBufferCacheAccuracy = 1
\ No newline at end of file
+# Rock 'N Racing Off Road DX (EUR)
\ No newline at end of file
diff --git a/bin/gameProfiles/default/00050000101d9d00.ini b/bin/gameProfiles/default/00050000101d9d00.ini
index dc54dea2..30d07833 100644
--- a/bin/gameProfiles/default/00050000101d9d00.ini
+++ b/bin/gameProfiles/default/00050000101d9d00.ini
@@ -2,6 +2,3 @@
 
 [General]
 loadSharedLibraries = false
-
-[Graphics]
-GPUBufferCacheAccuracy = 0
\ No newline at end of file
diff --git a/bin/gameProfiles/default/00050000101dac00.ini b/bin/gameProfiles/default/00050000101dac00.ini
index 1780613f..bb988dac 100644
--- a/bin/gameProfiles/default/00050000101dac00.ini
+++ b/bin/gameProfiles/default/00050000101dac00.ini
@@ -1,4 +1 @@
-# Swap Fire
-
-[GPU]
-GPUBufferCacheAccuracy = 0
\ No newline at end of file
+# Swap Fire
\ No newline at end of file
diff --git a/bin/gameProfiles/default/00050000101daf00.ini b/bin/gameProfiles/default/00050000101daf00.ini
index 2c8bef7b..3ebc182e 100644
--- a/bin/gameProfiles/default/00050000101daf00.ini
+++ b/bin/gameProfiles/default/00050000101daf00.ini
@@ -1,4 +1 @@
-# Chronicles of Teddy: Harmony of Exidus (EUR)
-
-[Graphics]
-GPUBufferCacheAccuracy = 0
\ No newline at end of file
+# Chronicles of Teddy: Harmony of Exidus (EUR)
\ No newline at end of file
diff --git a/bin/gameProfiles/default/00050000101db000.ini b/bin/gameProfiles/default/00050000101db000.ini
index 94736dbb..fafb6333 100644
--- a/bin/gameProfiles/default/00050000101db000.ini
+++ b/bin/gameProfiles/default/00050000101db000.ini
@@ -1,4 +1 @@
-# Oddworld New 'n' Tasty (US)
-
-[Graphics]
-GPUBufferCacheAccuracy = 0
\ No newline at end of file
+# Oddworld New 'n' Tasty (US)
\ No newline at end of file
diff --git a/bin/gameProfiles/default/00050000101dbb00.ini b/bin/gameProfiles/default/00050000101dbb00.ini
index 092b54ec..7e08923d 100644
--- a/bin/gameProfiles/default/00050000101dbb00.ini
+++ b/bin/gameProfiles/default/00050000101dbb00.ini
@@ -1,4 +1 @@
-# Oddworld New 'n' Tasty (EUR)
-
-[Graphics]
-GPUBufferCacheAccuracy = 0
\ No newline at end of file
+# Oddworld New 'n' Tasty (EUR)
\ No newline at end of file
diff --git a/bin/gameProfiles/default/00050000101dbc00.ini b/bin/gameProfiles/default/00050000101dbc00.ini
index 98c41e22..94808fc1 100644
--- a/bin/gameProfiles/default/00050000101dbc00.ini
+++ b/bin/gameProfiles/default/00050000101dbc00.ini
@@ -1,4 +1 @@
-# Star Ghost (EUR)
-
-[Graphics]
-GPUBufferCacheAccuracy = 0
\ No newline at end of file
+# Star Ghost (EUR)
\ No newline at end of file
diff --git a/bin/gameProfiles/default/00050000101dbe00.ini b/bin/gameProfiles/default/00050000101dbe00.ini
index 66ec5de9..0145c649 100644
--- a/bin/gameProfiles/default/00050000101dbe00.ini
+++ b/bin/gameProfiles/default/00050000101dbe00.ini
@@ -1,7 +1,4 @@
 # Minecraft: Wii U Edition (JPN)
 
 [General]
-loadSharedLibraries = false
-
-[Graphics]
-GPUBufferCacheAccuracy = 0
\ No newline at end of file
+loadSharedLibraries = false
\ No newline at end of file
diff --git a/bin/gameProfiles/default/00050000101dbf00.ini b/bin/gameProfiles/default/00050000101dbf00.ini
index 6f32b59d..6cab37ad 100644
--- a/bin/gameProfiles/default/00050000101dbf00.ini
+++ b/bin/gameProfiles/default/00050000101dbf00.ini
@@ -1,4 +1 @@
-# Angry Video Game Nerd Adventures (EUR)
-
-[Graphics]
-GPUBufferCacheAccuracy = 0
\ No newline at end of file
+# Angry Video Game Nerd Adventures (EUR)
\ No newline at end of file
diff --git a/bin/gameProfiles/default/00050000101dc000.ini b/bin/gameProfiles/default/00050000101dc000.ini
index b4b8717c..8734af28 100644
--- a/bin/gameProfiles/default/00050000101dc000.ini
+++ b/bin/gameProfiles/default/00050000101dc000.ini
@@ -1,4 +1 @@
-# Vektor Wars (USA)
-
-[Graphics]
-GPUBufferCacheAccuracy = 0
\ No newline at end of file
+# Vektor Wars (USA)
\ No newline at end of file
diff --git a/bin/gameProfiles/default/00050000101dc200.ini b/bin/gameProfiles/default/00050000101dc200.ini
index 0cec8b6d..eebe3ac5 100644
--- a/bin/gameProfiles/default/00050000101dc200.ini
+++ b/bin/gameProfiles/default/00050000101dc200.ini
@@ -1,4 +1 @@
-# Vektor Wars (EUR)
-
-[Graphics]
-GPUBufferCacheAccuracy = 0
\ No newline at end of file
+# Vektor Wars (EUR)
\ No newline at end of file
diff --git a/bin/gameProfiles/default/00050000101dd000.ini b/bin/gameProfiles/default/00050000101dd000.ini
index 8f275d8c..33caf468 100644
--- a/bin/gameProfiles/default/00050000101dd000.ini
+++ b/bin/gameProfiles/default/00050000101dd000.ini
@@ -1,4 +1 @@
-# Star Ghost (USA)
-
-[Graphics]
-GPUBufferCacheAccuracy = 0
\ No newline at end of file
+# Star Ghost (USA)
\ No newline at end of file
diff --git a/bin/gameProfiles/default/00050000101dd600.ini b/bin/gameProfiles/default/00050000101dd600.ini
index 7b180555..1a17ec4b 100644
--- a/bin/gameProfiles/default/00050000101dd600.ini
+++ b/bin/gameProfiles/default/00050000101dd600.ini
@@ -1,4 +1 @@
-# BIT.TRIP Presents... Runner2: Future Legend of Rhythm Alien (JPN)
-
-[Graphics]
-GPUBufferCacheAccuracy = 0
\ No newline at end of file
+# BIT.TRIP Presents... Runner2: Future Legend of Rhythm Alien (JPN)
\ No newline at end of file
diff --git a/bin/gameProfiles/default/00050000101dd700.ini b/bin/gameProfiles/default/00050000101dd700.ini
index 57b3a897..fbefda0e 100644
--- a/bin/gameProfiles/default/00050000101dd700.ini
+++ b/bin/gameProfiles/default/00050000101dd700.ini
@@ -1,7 +1 @@
-# Runbow (JPN)
-
-
-
-[Graphics]
-
-GPUBufferCacheAccuracy = 0
\ No newline at end of file
+# Runbow (JPN)
\ No newline at end of file
diff --git a/bin/gameProfiles/default/00050000101ddf00.ini b/bin/gameProfiles/default/00050000101ddf00.ini
index a3adf2fc..5c802484 100644
--- a/bin/gameProfiles/default/00050000101ddf00.ini
+++ b/bin/gameProfiles/default/00050000101ddf00.ini
@@ -1,4 +1 @@
-# Hive Jump (USA)
-
-[Graphics]
-GPUBufferCacheAccuracy = 0
\ No newline at end of file
+# Hive Jump (USA)
\ No newline at end of file
diff --git a/bin/gameProfiles/default/00050000101e0100.ini b/bin/gameProfiles/default/00050000101e0100.ini
index 13f74180..738553d8 100644
--- a/bin/gameProfiles/default/00050000101e0100.ini
+++ b/bin/gameProfiles/default/00050000101e0100.ini
@@ -1,6 +1 @@
-#  Minecraft: Story Mode (USA)
-
-
-
-[Graphics]
-GPUBufferCacheAccuracy = 0
\ No newline at end of file
+#  Minecraft: Story Mode (USA)
\ No newline at end of file
diff --git a/bin/gameProfiles/default/00050000101e1800.ini b/bin/gameProfiles/default/00050000101e1800.ini
index bf35ca87..a372c127 100644
--- a/bin/gameProfiles/default/00050000101e1800.ini
+++ b/bin/gameProfiles/default/00050000101e1800.ini
@@ -1,4 +1 @@
-# Human Resource Machine (USA)
-
-[Graphics]
-GPUBufferCacheAccuracy = 0
\ No newline at end of file
+# Human Resource Machine (USA)
\ No newline at end of file
diff --git a/bin/gameProfiles/default/00050000101e1a00.ini b/bin/gameProfiles/default/00050000101e1a00.ini
index 23dca6a5..a90125c4 100644
--- a/bin/gameProfiles/default/00050000101e1a00.ini
+++ b/bin/gameProfiles/default/00050000101e1a00.ini
@@ -1,4 +1 @@
-# Human Resource Machine (EUR)
-
-[Graphics]
-GPUBufferCacheAccuracy = 0
\ No newline at end of file
+# Human Resource Machine (EUR)
\ No newline at end of file
diff --git a/bin/gameProfiles/default/00050000101e1b00.ini b/bin/gameProfiles/default/00050000101e1b00.ini
index 5675969a..88e9b456 100644
--- a/bin/gameProfiles/default/00050000101e1b00.ini
+++ b/bin/gameProfiles/default/00050000101e1b00.ini
@@ -2,6 +2,3 @@
 
 [CPU]
 cpuTimer = hostBased
-
-[Graphics]
-GPUBufferCacheAccuracy = 0
\ No newline at end of file
diff --git a/bin/gameProfiles/default/00050000101e3800.ini b/bin/gameProfiles/default/00050000101e3800.ini
index 4e6f4859..fdfa2cdf 100644
--- a/bin/gameProfiles/default/00050000101e3800.ini
+++ b/bin/gameProfiles/default/00050000101e3800.ini
@@ -1,7 +1 @@
-# Dual Core (USA)
-
-[General]
-loadSharedLibraries = false
-
-[Graphics]
-GPUBufferCacheAccuracy = 0
\ No newline at end of file
+# Dual Core (USA)
\ No newline at end of file
diff --git a/bin/gameProfiles/default/00050000101e4200.ini b/bin/gameProfiles/default/00050000101e4200.ini
index 9e6a983b..ef94b291 100644
--- a/bin/gameProfiles/default/00050000101e4200.ini
+++ b/bin/gameProfiles/default/00050000101e4200.ini
@@ -6,6 +6,3 @@ useRDTSC = false
 [CPU]
 cpuTimer = cycleCounter
 cpuMode = Singlecore-Interpreter
-
-[Graphics]
-GPUBufferCacheAccuracy = 0
\ No newline at end of file
diff --git a/bin/gameProfiles/default/00050000101e5300.ini b/bin/gameProfiles/default/00050000101e5300.ini
index c6f6674a..c04cd6b6 100644
--- a/bin/gameProfiles/default/00050000101e5300.ini
+++ b/bin/gameProfiles/default/00050000101e5300.ini
@@ -6,6 +6,3 @@ useRDTSC = false
 [CPU]
 cpuMode = Singlecore-Recompiler
 cpuTimer = cycleCounter
-
-[Graphics]
-GPUBufferCacheAccuracy = 1
\ No newline at end of file
diff --git a/bin/gameProfiles/default/00050000101e5400.ini b/bin/gameProfiles/default/00050000101e5400.ini
index 299c9e40..221a23ed 100644
--- a/bin/gameProfiles/default/00050000101e5400.ini
+++ b/bin/gameProfiles/default/00050000101e5400.ini
@@ -6,6 +6,3 @@ useRDTSC = false
 [CPU]
 cpuMode = Singlecore-Recompiler
 cpuTimer = cycleCounter
-
-[Graphics]
-GPUBufferCacheAccuracy = 1
\ No newline at end of file
diff --git a/bin/gameProfiles/default/00050000101e5e00.ini b/bin/gameProfiles/default/00050000101e5e00.ini
index 2736143b..ab9fc348 100644
--- a/bin/gameProfiles/default/00050000101e5e00.ini
+++ b/bin/gameProfiles/default/00050000101e5e00.ini
@@ -1,4 +1 @@
-# Chasing Dead (EUR)
-
-[Graphics]
-GPUBufferCacheAccuracy = 0
+# Chasing Dead (EUR)
\ No newline at end of file
diff --git a/bin/gameProfiles/default/00050000101e7300.ini b/bin/gameProfiles/default/00050000101e7300.ini
index de2d9ace..092720b8 100644
--- a/bin/gameProfiles/default/00050000101e7300.ini
+++ b/bin/gameProfiles/default/00050000101e7300.ini
@@ -1,4 +1 @@
-# The Deer God (USA)
-
-[Graphics]
-GPUBufferCacheAccuracy = 0
\ No newline at end of file
+# The Deer God (USA)
\ No newline at end of file
diff --git a/bin/gameProfiles/default/00050000101e7400.ini b/bin/gameProfiles/default/00050000101e7400.ini
index 38a64064..e8644aa7 100644
--- a/bin/gameProfiles/default/00050000101e7400.ini
+++ b/bin/gameProfiles/default/00050000101e7400.ini
@@ -1,4 +1 @@
-# Grumpy Reaper (EUR)
-
-[Graphics]
-GPUBufferCacheAccuracy = 0
\ No newline at end of file
+# Grumpy Reaper (EUR)
\ No newline at end of file
diff --git a/bin/gameProfiles/default/00050000101e9300.ini b/bin/gameProfiles/default/00050000101e9300.ini
index a88c29bc..24c0dad8 100644
--- a/bin/gameProfiles/default/00050000101e9300.ini
+++ b/bin/gameProfiles/default/00050000101e9300.ini
@@ -1,4 +1 @@
-# Gear Gauntlet (USA)
-
-[Graphics]
-GPUBufferCacheAccuracy = 0
\ No newline at end of file
+# Gear Gauntlet (USA)
\ No newline at end of file
diff --git a/bin/gameProfiles/default/00050000101e9400.ini b/bin/gameProfiles/default/00050000101e9400.ini
index 6f914578..6b78201e 100644
--- a/bin/gameProfiles/default/00050000101e9400.ini
+++ b/bin/gameProfiles/default/00050000101e9400.ini
@@ -1,4 +1 @@
-# Gear Gauntlet (EUR)
-
-[Graphics]
-GPUBufferCacheAccuracy = 0
\ No newline at end of file
+# Gear Gauntlet (EUR)
\ No newline at end of file
diff --git a/bin/gameProfiles/default/00050000101eb300.ini b/bin/gameProfiles/default/00050000101eb300.ini
index e5b62760..66c8dcb4 100644
--- a/bin/gameProfiles/default/00050000101eb300.ini
+++ b/bin/gameProfiles/default/00050000101eb300.ini
@@ -1,4 +1 @@
-# The Beggar's Ride (USA)
-
-[Graphics]
-GPUBufferCacheAccuracy = 0
\ No newline at end of file
+# The Beggar's Ride (USA)
\ No newline at end of file
diff --git a/bin/gameProfiles/default/00050000101ec700.ini b/bin/gameProfiles/default/00050000101ec700.ini
index 27e0f560..7dd85123 100644
--- a/bin/gameProfiles/default/00050000101ec700.ini
+++ b/bin/gameProfiles/default/00050000101ec700.ini
@@ -1,4 +1 @@
-# The Beggar's Ride (EUR)
-
-[Graphics]
-GPUBufferCacheAccuracy = 0
\ No newline at end of file
+# The Beggar's Ride (EUR)
\ No newline at end of file
diff --git a/bin/gameProfiles/default/00050000101ecf00.ini b/bin/gameProfiles/default/00050000101ecf00.ini
index 3191607c..e3b80181 100644
--- a/bin/gameProfiles/default/00050000101ecf00.ini
+++ b/bin/gameProfiles/default/00050000101ecf00.ini
@@ -1,4 +1 @@
-# Buddy & Me Dream Edition (USA)
-
-[Graphics]
-GPUBufferCacheAccuracy = 0
\ No newline at end of file
+# Buddy & Me Dream Edition (USA)
\ No newline at end of file
diff --git a/bin/gameProfiles/default/00050000101f1300.ini b/bin/gameProfiles/default/00050000101f1300.ini
index 3b17b3a5..85683631 100644
--- a/bin/gameProfiles/default/00050000101f1300.ini
+++ b/bin/gameProfiles/default/00050000101f1300.ini
@@ -1,4 +1 @@
-# Armikrog (USA)
-
-[Graphics]
-GPUBufferCacheAccuracy = 0
\ No newline at end of file
+# Armikrog (USA)
\ No newline at end of file
diff --git a/bin/gameProfiles/default/00050000101f2800.ini b/bin/gameProfiles/default/00050000101f2800.ini
index 65c08d62..a8d455dd 100644
--- a/bin/gameProfiles/default/00050000101f2800.ini
+++ b/bin/gameProfiles/default/00050000101f2800.ini
@@ -1,7 +1,4 @@
 # 8Bit Hero (USA)
 
-[Graphics]
-GPUBufferCacheAccuracy = 0
-
 [CPU]
 cpuMode = Singlecore-Interpreter
\ No newline at end of file
diff --git a/bin/gameProfiles/default/00050000101f4a00.ini b/bin/gameProfiles/default/00050000101f4a00.ini
index 2d9432da..e0ca60b7 100644
--- a/bin/gameProfiles/default/00050000101f4a00.ini
+++ b/bin/gameProfiles/default/00050000101f4a00.ini
@@ -1,4 +1 @@
-# Buddy & Me Dream Edition (EUR)
-
-[Graphics]
-GPUBufferCacheAccuracy = 0
\ No newline at end of file
+# Buddy & Me Dream Edition (EUR)
\ No newline at end of file
diff --git a/bin/gameProfiles/default/00050000101f5700.ini b/bin/gameProfiles/default/00050000101f5700.ini
index a2d5119f..c0c98988 100644
--- a/bin/gameProfiles/default/00050000101f5700.ini
+++ b/bin/gameProfiles/default/00050000101f5700.ini
@@ -1,4 +1 @@
-# Jotun Valhalla Edition (USA)
-
-[Graphics]
-GPUBufferCacheAccuracy = 0
\ No newline at end of file
+# Jotun Valhalla Edition (USA)
\ No newline at end of file
diff --git a/bin/gameProfiles/default/00050000101f6f00.ini b/bin/gameProfiles/default/00050000101f6f00.ini
index 92bf8b9e..4a590788 100644
--- a/bin/gameProfiles/default/00050000101f6f00.ini
+++ b/bin/gameProfiles/default/00050000101f6f00.ini
@@ -1,4 +1 @@
-# Jotun Valhalla Edition (EUR)
-
-[Graphics]
-GPUBufferCacheAccuracy = 0
\ No newline at end of file
+# Jotun Valhalla Edition (EUR)
\ No newline at end of file
diff --git a/bin/gameProfiles/default/00050000101f7600.ini b/bin/gameProfiles/default/00050000101f7600.ini
index 88e55d2a..bbe32dff 100644
--- a/bin/gameProfiles/default/00050000101f7600.ini
+++ b/bin/gameProfiles/default/00050000101f7600.ini
@@ -1,7 +1 @@
-# Dual Core (EUR)
-
-[General]
-loadSharedLibraries = false
-
-[Graphics]
-GPUBufferCacheAccuracy = 0
\ No newline at end of file
+# Dual Core (EUR)
\ No newline at end of file
diff --git a/bin/gameProfiles/default/00050000101f9700.ini b/bin/gameProfiles/default/00050000101f9700.ini
index 34c46581..a36f67a1 100644
--- a/bin/gameProfiles/default/00050000101f9700.ini
+++ b/bin/gameProfiles/default/00050000101f9700.ini
@@ -1,4 +1 @@
-# Darksiders Warmastered Edition (EUR)
-
-[Graphics]
-GPUBufferCacheAccuracy = 0
\ No newline at end of file
+# Darksiders Warmastered Edition (EUR)
\ No newline at end of file
diff --git a/bin/gameProfiles/default/00050000101fa600.ini b/bin/gameProfiles/default/00050000101fa600.ini
index 89ab8ade..653531f9 100644
--- a/bin/gameProfiles/default/00050000101fa600.ini
+++ b/bin/gameProfiles/default/00050000101fa600.ini
@@ -1,4 +1 @@
-# Darksiders Warmastered Edition (USA)
-
-[Graphics]
-GPUBufferCacheAccuracy = 0
\ No newline at end of file
+# Darksiders Warmastered Edition (USA)
\ No newline at end of file
diff --git a/bin/gameProfiles/default/00050000101fd100.ini b/bin/gameProfiles/default/00050000101fd100.ini
index 6ce5a608..a0f02db2 100644
--- a/bin/gameProfiles/default/00050000101fd100.ini
+++ b/bin/gameProfiles/default/00050000101fd100.ini
@@ -1,4 +1 @@
-# Grumpy Reaper (JPN)
-
-[Graphics]
-GPUBufferCacheAccuracy = 0
\ No newline at end of file
+# Grumpy Reaper (JPN)
\ No newline at end of file
diff --git a/bin/gameProfiles/default/00050000101ff200.ini b/bin/gameProfiles/default/00050000101ff200.ini
index 54e13b65..13b5470b 100644
--- a/bin/gameProfiles/default/00050000101ff200.ini
+++ b/bin/gameProfiles/default/00050000101ff200.ini
@@ -1,4 +1 @@
-# Exile's End (USA)
-
-[Graphics]
-GPUBufferCacheAccuracy = 0
\ No newline at end of file
+# Exile's End (USA)
\ No newline at end of file
diff --git a/bin/gameProfiles/default/00050000101ffc00.ini b/bin/gameProfiles/default/00050000101ffc00.ini
index e01c407c..4d6850ae 100644
--- a/bin/gameProfiles/default/00050000101ffc00.ini
+++ b/bin/gameProfiles/default/00050000101ffc00.ini
@@ -1,5 +1,4 @@
 # Ghost Blade HD (USA)
 
 [Graphics]
-GPUBufferCacheAccuracy = 0
 streamoutBufferCacheSize = 48
\ No newline at end of file
diff --git a/bin/gameProfiles/default/00050000101ffe00.ini b/bin/gameProfiles/default/00050000101ffe00.ini
index 9225f393..123cc4b9 100644
--- a/bin/gameProfiles/default/00050000101ffe00.ini
+++ b/bin/gameProfiles/default/00050000101ffe00.ini
@@ -1,4 +1 @@
-# Tetrimos (USA)
-
-[Graphics]
-GPUBufferCacheAccuracy = 0
\ No newline at end of file
+# Tetrimos (USA)
\ No newline at end of file
diff --git a/bin/gameProfiles/default/0005000010200300.ini b/bin/gameProfiles/default/0005000010200300.ini
index 47600923..b62d3c32 100644
--- a/bin/gameProfiles/default/0005000010200300.ini
+++ b/bin/gameProfiles/default/0005000010200300.ini
@@ -1,4 +1 @@
-# Armikrog (EUR)
-
-[Graphics]
-GPUBufferCacheAccuracy = 0
\ No newline at end of file
+# Armikrog (EUR)
\ No newline at end of file
diff --git a/bin/gameProfiles/default/0005000010200b00.ini b/bin/gameProfiles/default/0005000010200b00.ini
index 8fc9da4b..7a6469b5 100644
--- a/bin/gameProfiles/default/0005000010200b00.ini
+++ b/bin/gameProfiles/default/0005000010200b00.ini
@@ -1,4 +1 @@
-# Tetrimos (EUR)
-
-[Graphics]
-GPUBufferCacheAccuracy = 0
\ No newline at end of file
+# Tetrimos (EUR)
\ No newline at end of file
diff --git a/bin/gameProfiles/default/0005000010204a00.ini b/bin/gameProfiles/default/0005000010204a00.ini
index 8a0285c3..e0d9db5a 100644
--- a/bin/gameProfiles/default/0005000010204a00.ini
+++ b/bin/gameProfiles/default/0005000010204a00.ini
@@ -1,4 +1 @@
-# Exile's End (EUR)
-
-[Graphics]
-GPUBufferCacheAccuracy = 0
\ No newline at end of file
+# Exile's End (EUR)
\ No newline at end of file
diff --git a/bin/gameProfiles/default/0005000010207300.ini b/bin/gameProfiles/default/0005000010207300.ini
index c678e7d6..56d9a42f 100644
--- a/bin/gameProfiles/default/0005000010207300.ini
+++ b/bin/gameProfiles/default/0005000010207300.ini
@@ -1,4 +1 @@
-# Koi DX (EUR)
-
-[Graphics]
-GPUBufferCacheAccuracy = 0
\ No newline at end of file
+# Koi DX (EUR)
\ No newline at end of file
diff --git a/bin/gameProfiles/default/0005000010207500.ini b/bin/gameProfiles/default/0005000010207500.ini
index 090be3f2..1a4ab56d 100644
--- a/bin/gameProfiles/default/0005000010207500.ini
+++ b/bin/gameProfiles/default/0005000010207500.ini
@@ -1,4 +1 @@
-# Koi DX (USA)
-
-[Graphics]
-GPUBufferCacheAccuracy = 0
\ No newline at end of file
+# Koi DX (USA)
\ No newline at end of file
diff --git a/bin/gameProfiles/default/000500001020a200.ini b/bin/gameProfiles/default/000500001020a200.ini
index bef0c82e..6960a967 100644
--- a/bin/gameProfiles/default/000500001020a200.ini
+++ b/bin/gameProfiles/default/000500001020a200.ini
@@ -1,5 +1 @@
-#  Minecraft: Story Mode (EUR)
-
-
-[Graphics]
-GPUBufferCacheAccuracy = 0
\ No newline at end of file
+#  Minecraft: Story Mode (EUR)
\ No newline at end of file
diff --git a/bin/gameProfiles/default/000500001020b600.ini b/bin/gameProfiles/default/000500001020b600.ini
index 74528c38..46e4c8da 100644
--- a/bin/gameProfiles/default/000500001020b600.ini
+++ b/bin/gameProfiles/default/000500001020b600.ini
@@ -1,5 +1,4 @@
 # Ghost Blade HD (EUR)
 
 [Graphics]
-GPUBufferCacheAccuracy = 0
 streamoutBufferCacheSize = 48
\ No newline at end of file
diff --git a/bin/gameProfiles/default/0005000010211b00.ini b/bin/gameProfiles/default/0005000010211b00.ini
index 69534194..7e82f408 100644
--- a/bin/gameProfiles/default/0005000010211b00.ini
+++ b/bin/gameProfiles/default/0005000010211b00.ini
@@ -1,4 +1 @@
-# Sphere Slice (EUR)
-
-[Graphics]
-GPUBufferCacheAccuracy = 0
\ No newline at end of file
+# Sphere Slice (EUR)
\ No newline at end of file
diff --git a/bin/gameProfiles/default/0005000C1012BC00.ini b/bin/gameProfiles/default/0005000C1012BC00.ini
index 5c2c09d4..5f699eb6 100644
--- a/bin/gameProfiles/default/0005000C1012BC00.ini
+++ b/bin/gameProfiles/default/0005000C1012BC00.ini
@@ -1,8 +1,4 @@
 # Pikmin 3 (JAP)
 
-
-
 [Graphics]
-
 extendedTextureReadback = true
-GPUBufferCacheAccuracy = 2
\ No newline at end of file
diff --git a/bin/gameProfiles/default/0005000C1012BD00.ini b/bin/gameProfiles/default/0005000C1012BD00.ini
index 8ab10175..cd27ff77 100644
--- a/bin/gameProfiles/default/0005000C1012BD00.ini
+++ b/bin/gameProfiles/default/0005000C1012BD00.ini
@@ -1,8 +1,4 @@
 # Pikmin 3 (USA)
 
-
-
 [Graphics]
-
 extendedTextureReadback = true
-GPUBufferCacheAccuracy = 2
\ No newline at end of file
diff --git a/bin/gameProfiles/default/0005000C1012BE00.ini b/bin/gameProfiles/default/0005000C1012BE00.ini
index e7226ef4..6be6a929 100644
--- a/bin/gameProfiles/default/0005000C1012BE00.ini
+++ b/bin/gameProfiles/default/0005000C1012BE00.ini
@@ -1,8 +1,4 @@
 # Pikmin 3 (EU)
 
-
-
 [Graphics]
-
 extendedTextureReadback = true
-GPUBufferCacheAccuracy = 2
\ No newline at end of file
diff --git a/bin/gameProfiles/default/0005000e1019c800.ini b/bin/gameProfiles/default/0005000e1019c800.ini
index 8c47898c..81adc4c9 100644
--- a/bin/gameProfiles/default/0005000e1019c800.ini
+++ b/bin/gameProfiles/default/0005000e1019c800.ini
@@ -1,4 +1 @@
-# TLoZ: Twilight Princess (JPN)
-
-[Graphics]
-GPUBufferCacheAccuracy = 0
\ No newline at end of file
+# TLoZ: Twilight Princess (JPN)
\ No newline at end of file
diff --git a/bin/resources/ar/‏‏cemu.mo b/bin/resources/ar/‏‏cemu.mo
new file mode 100644
index 00000000..4062628b
Binary files /dev/null and b/bin/resources/ar/‏‏cemu.mo differ
diff --git a/bin/resources/ca/cemu.mo b/bin/resources/ca/cemu.mo
index 7930c426..55640215 100644
Binary files a/bin/resources/ca/cemu.mo and b/bin/resources/ca/cemu.mo differ
diff --git a/bin/resources/de/cemu.mo b/bin/resources/de/cemu.mo
index 47d6a964..cd9edd3c 100644
Binary files a/bin/resources/de/cemu.mo and b/bin/resources/de/cemu.mo differ
diff --git a/bin/resources/es/cemu.mo b/bin/resources/es/cemu.mo
index 93d8f7e5..a43d4a1d 100644
Binary files a/bin/resources/es/cemu.mo and b/bin/resources/es/cemu.mo differ
diff --git a/bin/resources/fr/cemu.mo b/bin/resources/fr/cemu.mo
index 09bcd9f2..f3f3b498 100644
Binary files a/bin/resources/fr/cemu.mo and b/bin/resources/fr/cemu.mo differ
diff --git a/bin/resources/he/cemu.mo b/bin/resources/he/cemu.mo
new file mode 100644
index 00000000..072e48c6
Binary files /dev/null and b/bin/resources/he/cemu.mo differ
diff --git a/bin/resources/hu/cemu.mo b/bin/resources/hu/cemu.mo
index c66dd9d7..51b00d08 100644
Binary files a/bin/resources/hu/cemu.mo and b/bin/resources/hu/cemu.mo differ
diff --git a/bin/resources/it/cemu.mo b/bin/resources/it/cemu.mo
index a417f089..20d5bb93 100644
Binary files a/bin/resources/it/cemu.mo and b/bin/resources/it/cemu.mo differ
diff --git a/bin/resources/ja/cemu.mo b/bin/resources/ja/cemu.mo
index 5044fc61..ff2fadd8 100644
Binary files a/bin/resources/ja/cemu.mo and b/bin/resources/ja/cemu.mo differ
diff --git a/bin/resources/ko/cemu.mo b/bin/resources/ko/cemu.mo
index 27e63d6e..5ea5e1da 100644
Binary files a/bin/resources/ko/cemu.mo and b/bin/resources/ko/cemu.mo differ
diff --git a/bin/resources/nb/cemu.mo b/bin/resources/nb/cemu.mo
index 6b87f8c0..21149d82 100644
Binary files a/bin/resources/nb/cemu.mo and b/bin/resources/nb/cemu.mo differ
diff --git a/bin/resources/nl/cemu.mo b/bin/resources/nl/cemu.mo
index 5cbe532f..f9fcc226 100644
Binary files a/bin/resources/nl/cemu.mo and b/bin/resources/nl/cemu.mo differ
diff --git a/bin/resources/pl/cemu.mo b/bin/resources/pl/cemu.mo
index 4ff064f9..2d86b139 100644
Binary files a/bin/resources/pl/cemu.mo and b/bin/resources/pl/cemu.mo differ
diff --git a/bin/resources/pt/cemu.mo b/bin/resources/pt/cemu.mo
index 3b79163c..8ff9b167 100644
Binary files a/bin/resources/pt/cemu.mo and b/bin/resources/pt/cemu.mo differ
diff --git a/bin/resources/ru/cemu.mo b/bin/resources/ru/cemu.mo
index 46583b20..eb8f372f 100644
Binary files a/bin/resources/ru/cemu.mo and b/bin/resources/ru/cemu.mo differ
diff --git a/bin/resources/sv/cemu.mo b/bin/resources/sv/cemu.mo
index 13a4e827..c8fd68ee 100644
Binary files a/bin/resources/sv/cemu.mo and b/bin/resources/sv/cemu.mo differ
diff --git a/bin/resources/tr/cemu.mo b/bin/resources/tr/cemu.mo
index 0a4c3c63..5b9b47ba 100644
Binary files a/bin/resources/tr/cemu.mo and b/bin/resources/tr/cemu.mo differ
diff --git a/bin/resources/uk/cemu.mo b/bin/resources/uk/cemu.mo
new file mode 100644
index 00000000..c8f6d461
Binary files /dev/null and b/bin/resources/uk/cemu.mo differ
diff --git a/bin/resources/zh/cemu.mo b/bin/resources/zh/cemu.mo
index a07eb370..3e636971 100644
Binary files a/bin/resources/zh/cemu.mo and b/bin/resources/zh/cemu.mo differ
diff --git a/bin/shaderCache/info.txt b/bin/shaderCache/info.txt
deleted file mode 100644
index 962cf88b..00000000
--- a/bin/shaderCache/info.txt
+++ /dev/null
@@ -1 +0,0 @@
-If you plan to transfer the shader cache to a different PC or Cemu installation you only need to copy the 'transferable' directory.
\ No newline at end of file
diff --git a/boost.natvis b/boost.natvis
new file mode 100644
index 00000000..2781a585
--- /dev/null
+++ b/boost.natvis
@@ -0,0 +1,26 @@
+<?xml version='1.0' encoding='utf-8'?>
+<AutoVisualizer xmlns="http://schemas.microsoft.com/vstudio/debugger/natvis/2010">
+
+    <Type Name="boost::container::small_vector&lt;*&gt;">
+        <Expand>
+            <Item Name="[size]">m_holder.m_size</Item>
+            <ArrayItems>
+                <Size>m_holder.m_size</Size>
+                <ValuePointer>m_holder.m_start</ValuePointer>
+            </ArrayItems>
+        </Expand>
+    </Type>
+
+	<Type Name="boost::container::static_vector&lt;*&gt;">
+	<DisplayString>{{ size={m_holder.m_size} }}</DisplayString>
+	<Expand>
+	  <Item Name="[size]" ExcludeView="simple">m_holder.m_size</Item>
+	  <Item Name="[capacity]" ExcludeView="simple">static_capacity</Item>
+	  <ArrayItems>
+		<Size>m_holder.m_size</Size>
+		<ValuePointer>($T1*)m_holder.storage.data</ValuePointer>
+	  </ArrayItems>
+	</Expand>
+	</Type>
+
+</AutoVisualizer>
diff --git a/cmake/ECMFindModuleHelpers.cmake b/cmake/ECMFindModuleHelpers.cmake
new file mode 100644
index 00000000..a4837403
--- /dev/null
+++ b/cmake/ECMFindModuleHelpers.cmake
@@ -0,0 +1,279 @@
+# SPDX-FileCopyrightText: 2014 Alex Merry <alex.merry@kde.org>
+#
+# SPDX-License-Identifier: BSD-3-Clause
+
+#[=======================================================================[.rst:
+ECMFindModuleHelpers
+--------------------
+
+Helper macros for find modules: ``ecm_find_package_version_check()``,
+``ecm_find_package_parse_components()`` and
+``ecm_find_package_handle_library_components()``.
+
+::
+
+  ecm_find_package_version_check(<name>)
+
+Prints warnings if the CMake version or the project's required CMake version
+is older than that required by extra-cmake-modules.
+
+::
+
+  ecm_find_package_parse_components(<name>
+      RESULT_VAR <variable>
+      KNOWN_COMPONENTS <component1> [<component2> [...]]
+      [SKIP_DEPENDENCY_HANDLING])
+
+This macro will populate <variable> with a list of components found in
+<name>_FIND_COMPONENTS, after checking that all those components are in the
+list of ``KNOWN_COMPONENTS``; if there are any unknown components, it will print
+an error or warning (depending on the value of <name>_FIND_REQUIRED) and call
+``return()``.
+
+The order of components in <variable> is guaranteed to match the order they
+are listed in the ``KNOWN_COMPONENTS`` argument.
+
+If ``SKIP_DEPENDENCY_HANDLING`` is not set, for each component the variable
+<name>_<component>_component_deps will be checked for dependent components.
+If <component> is listed in <name>_FIND_COMPONENTS, then all its (transitive)
+dependencies will also be added to <variable>.
+
+::
+
+  ecm_find_package_handle_library_components(<name>
+      COMPONENTS <component> [<component> [...]]
+      [SKIP_DEPENDENCY_HANDLING])
+      [SKIP_PKG_CONFIG])
+
+Creates an imported library target for each component.  The operation of this
+macro depends on the presence of a number of CMake variables.
+
+The <name>_<component>_lib variable should contain the name of this library,
+and <name>_<component>_header variable should contain the name of a header
+file associated with it (whatever relative path is normally passed to
+'#include'). <name>_<component>_header_subdir variable can be used to specify
+which subdirectory of the include path the headers will be found in.
+``ecm_find_package_components()`` will then search for the library
+and include directory (creating appropriate cache variables) and create an
+imported library target named <name>::<component>.
+
+Additional variables can be used to provide additional information:
+
+If ``SKIP_PKG_CONFIG``, the <name>_<component>_pkg_config variable is set, and
+pkg-config is found, the pkg-config module given by
+<name>_<component>_pkg_config will be searched for and used to help locate the
+library and header file.  It will also be used to set
+<name>_<component>_VERSION.
+
+Note that if version information is found via pkg-config,
+<name>_<component>_FIND_VERSION can be set to require a particular version
+for each component.
+
+If ``SKIP_DEPENDENCY_HANDLING`` is not set, the ``INTERFACE_LINK_LIBRARIES`` property
+of the imported target for <component> will be set to contain the imported
+targets for the components listed in <name>_<component>_component_deps.
+<component>_FOUND will also be set to ``FALSE`` if any of the components in
+<name>_<component>_component_deps are not found.  This requires the components
+in <name>_<component>_component_deps to be listed before <component> in the
+``COMPONENTS`` argument.
+
+The following variables will be set:
+
+``<name>_TARGETS``
+  the imported targets
+``<name>_LIBRARIES``
+  the found libraries
+``<name>_INCLUDE_DIRS``
+  the combined required include directories for the components
+``<name>_DEFINITIONS``
+  the "other" CFLAGS provided by pkg-config, if any
+``<name>_VERSION``
+  the value of ``<name>_<component>_VERSION`` for the first component that
+  has this variable set (note that components are searched for in the order
+  they are passed to the macro), although if it is already set, it will not
+  be altered
+
+.. note::
+  These variables are never cleared, so if
+  ``ecm_find_package_handle_library_components()`` is called multiple times with
+  different components (typically because of multiple ``find_package()`` calls) then
+  ``<name>_TARGETS``, for example, will contain all the targets found in any
+  call (although no duplicates).
+
+Since pre-1.0.0.
+#]=======================================================================]
+
+include(CMakeParseArguments)
+
+macro(ecm_find_package_version_check module_name)
+    if(CMAKE_VERSION VERSION_LESS 3.16.0)
+        message(FATAL_ERROR "CMake 3.16.0 is required by Find${module_name}.cmake")
+    endif()
+    if(CMAKE_MINIMUM_REQUIRED_VERSION VERSION_LESS 3.16.0)
+        message(AUTHOR_WARNING "Your project should require at least CMake 3.16.0 to use Find${module_name}.cmake")
+    endif()
+endmacro()
+
+macro(ecm_find_package_parse_components module_name)
+    set(ecm_fppc_options SKIP_DEPENDENCY_HANDLING)
+    set(ecm_fppc_oneValueArgs RESULT_VAR)
+    set(ecm_fppc_multiValueArgs KNOWN_COMPONENTS DEFAULT_COMPONENTS)
+    cmake_parse_arguments(ECM_FPPC "${ecm_fppc_options}" "${ecm_fppc_oneValueArgs}" "${ecm_fppc_multiValueArgs}" ${ARGN})
+
+    if(ECM_FPPC_UNPARSED_ARGUMENTS)
+        message(FATAL_ERROR "Unexpected arguments to ecm_find_package_parse_components: ${ECM_FPPC_UNPARSED_ARGUMENTS}")
+    endif()
+    if(NOT ECM_FPPC_RESULT_VAR)
+        message(FATAL_ERROR "Missing RESULT_VAR argument to ecm_find_package_parse_components")
+    endif()
+    if(NOT ECM_FPPC_KNOWN_COMPONENTS)
+        message(FATAL_ERROR "Missing KNOWN_COMPONENTS argument to ecm_find_package_parse_components")
+    endif()
+    if(NOT ECM_FPPC_DEFAULT_COMPONENTS)
+        set(ECM_FPPC_DEFAULT_COMPONENTS ${ECM_FPPC_KNOWN_COMPONENTS})
+    endif()
+
+    if(${module_name}_FIND_COMPONENTS)
+        set(ecm_fppc_requestedComps ${${module_name}_FIND_COMPONENTS})
+
+        if(NOT ECM_FPPC_SKIP_DEPENDENCY_HANDLING)
+            # Make sure deps are included
+            foreach(ecm_fppc_comp ${ecm_fppc_requestedComps})
+                foreach(ecm_fppc_dep_comp ${${module_name}_${ecm_fppc_comp}_component_deps})
+                    list(FIND ecm_fppc_requestedComps "${ecm_fppc_dep_comp}" ecm_fppc_index)
+                    if("${ecm_fppc_index}" STREQUAL "-1")
+                        if(NOT ${module_name}_FIND_QUIETLY)
+                            message(STATUS "${module_name}: ${ecm_fppc_comp} requires ${${module_name}_${ecm_fppc_comp}_component_deps}")
+                        endif()
+                        list(APPEND ecm_fppc_requestedComps "${ecm_fppc_dep_comp}")
+                    endif()
+                endforeach()
+            endforeach()
+        else()
+            message(STATUS "Skipping dependency handling for ${module_name}")
+        endif()
+        list(REMOVE_DUPLICATES ecm_fppc_requestedComps)
+
+        # This makes sure components are listed in the same order as
+        # KNOWN_COMPONENTS (potentially important for inter-dependencies)
+        set(${ECM_FPPC_RESULT_VAR})
+        foreach(ecm_fppc_comp ${ECM_FPPC_KNOWN_COMPONENTS})
+            list(FIND ecm_fppc_requestedComps "${ecm_fppc_comp}" ecm_fppc_index)
+            if(NOT "${ecm_fppc_index}" STREQUAL "-1")
+                list(APPEND ${ECM_FPPC_RESULT_VAR} "${ecm_fppc_comp}")
+                list(REMOVE_AT ecm_fppc_requestedComps ${ecm_fppc_index})
+            endif()
+        endforeach()
+        # if there are any left, they are unknown components
+        if(ecm_fppc_requestedComps)
+            set(ecm_fppc_msgType STATUS)
+            if(${module_name}_FIND_REQUIRED)
+                set(ecm_fppc_msgType FATAL_ERROR)
+            endif()
+            if(NOT ${module_name}_FIND_QUIETLY)
+                message(${ecm_fppc_msgType} "${module_name}: requested unknown components ${ecm_fppc_requestedComps}")
+            endif()
+            return()
+        endif()
+    else()
+        set(${ECM_FPPC_RESULT_VAR} ${ECM_FPPC_DEFAULT_COMPONENTS})
+    endif()
+endmacro()
+
+macro(ecm_find_package_handle_library_components module_name)
+    set(ecm_fpwc_options SKIP_PKG_CONFIG SKIP_DEPENDENCY_HANDLING)
+    set(ecm_fpwc_oneValueArgs)
+    set(ecm_fpwc_multiValueArgs COMPONENTS)
+    cmake_parse_arguments(ECM_FPWC "${ecm_fpwc_options}" "${ecm_fpwc_oneValueArgs}" "${ecm_fpwc_multiValueArgs}" ${ARGN})
+
+    if(ECM_FPWC_UNPARSED_ARGUMENTS)
+        message(FATAL_ERROR "Unexpected arguments to ecm_find_package_handle_components: ${ECM_FPWC_UNPARSED_ARGUMENTS}")
+    endif()
+    if(NOT ECM_FPWC_COMPONENTS)
+        message(FATAL_ERROR "Missing COMPONENTS argument to ecm_find_package_handle_components")
+    endif()
+
+    include(FindPackageHandleStandardArgs)
+    find_package(PkgConfig QUIET)
+    foreach(ecm_fpwc_comp ${ECM_FPWC_COMPONENTS})
+        set(ecm_fpwc_dep_vars)
+        set(ecm_fpwc_dep_targets)
+        if(NOT SKIP_DEPENDENCY_HANDLING)
+            foreach(ecm_fpwc_dep ${${module_name}_${ecm_fpwc_comp}_component_deps})
+                list(APPEND ecm_fpwc_dep_vars "${module_name}_${ecm_fpwc_dep}_FOUND")
+                list(APPEND ecm_fpwc_dep_targets "${module_name}::${ecm_fpwc_dep}")
+            endforeach()
+        endif()
+
+        if(NOT ECM_FPWC_SKIP_PKG_CONFIG AND ${module_name}_${ecm_fpwc_comp}_pkg_config)
+            pkg_check_modules(PKG_${module_name}_${ecm_fpwc_comp} QUIET
+                              ${${module_name}_${ecm_fpwc_comp}_pkg_config})
+        endif()
+
+        find_path(${module_name}_${ecm_fpwc_comp}_INCLUDE_DIR
+            NAMES ${${module_name}_${ecm_fpwc_comp}_header}
+            HINTS ${PKG_${module_name}_${ecm_fpwc_comp}_INCLUDE_DIRS}
+            PATH_SUFFIXES ${${module_name}_${ecm_fpwc_comp}_header_subdir}
+        )
+        find_library(${module_name}_${ecm_fpwc_comp}_LIBRARY
+            NAMES ${${module_name}_${ecm_fpwc_comp}_lib}
+            HINTS ${PKG_${module_name}_${ecm_fpwc_comp}_LIBRARY_DIRS}
+        )
+
+        set(${module_name}_${ecm_fpwc_comp}_VERSION "${PKG_${module_name}_${ecm_fpwc_comp}_VERSION}")
+        if(NOT ${module_name}_VERSION)
+            set(${module_name}_VERSION ${${module_name}_${ecm_fpwc_comp}_VERSION})
+        endif()
+
+        set(FPHSA_NAME_MISMATCHED 1)
+        find_package_handle_standard_args(${module_name}_${ecm_fpwc_comp}
+            FOUND_VAR
+                ${module_name}_${ecm_fpwc_comp}_FOUND
+            REQUIRED_VARS
+                ${module_name}_${ecm_fpwc_comp}_LIBRARY
+                ${module_name}_${ecm_fpwc_comp}_INCLUDE_DIR
+                ${ecm_fpwc_dep_vars}
+            VERSION_VAR
+                ${module_name}_${ecm_fpwc_comp}_VERSION
+            )
+        unset(FPHSA_NAME_MISMATCHED)
+
+        mark_as_advanced(
+            ${module_name}_${ecm_fpwc_comp}_LIBRARY
+            ${module_name}_${ecm_fpwc_comp}_INCLUDE_DIR
+        )
+
+        if(${module_name}_${ecm_fpwc_comp}_FOUND)
+            list(APPEND ${module_name}_LIBRARIES
+                        "${${module_name}_${ecm_fpwc_comp}_LIBRARY}")
+            list(APPEND ${module_name}_INCLUDE_DIRS
+                        "${${module_name}_${ecm_fpwc_comp}_INCLUDE_DIR}")
+            set(${module_name}_DEFINITIONS
+                    ${${module_name}_DEFINITIONS}
+                    ${PKG_${module_name}_${ecm_fpwc_comp}_DEFINITIONS})
+            if(NOT TARGET ${module_name}::${ecm_fpwc_comp})
+                add_library(${module_name}::${ecm_fpwc_comp} UNKNOWN IMPORTED)
+                set_target_properties(${module_name}::${ecm_fpwc_comp} PROPERTIES
+                    IMPORTED_LOCATION "${${module_name}_${ecm_fpwc_comp}_LIBRARY}"
+                    INTERFACE_COMPILE_OPTIONS "${PKG_${module_name}_${ecm_fpwc_comp}_DEFINITIONS}"
+                    INTERFACE_INCLUDE_DIRECTORIES "${${module_name}_${ecm_fpwc_comp}_INCLUDE_DIR}"
+                    INTERFACE_LINK_LIBRARIES "${ecm_fpwc_dep_targets}"
+                )
+            endif()
+            list(APPEND ${module_name}_TARGETS
+                        "${module_name}::${ecm_fpwc_comp}")
+        endif()
+    endforeach()
+    if(${module_name}_LIBRARIES)
+        list(REMOVE_DUPLICATES ${module_name}_LIBRARIES)
+    endif()
+    if(${module_name}_INCLUDE_DIRS)
+        list(REMOVE_DUPLICATES ${module_name}_INCLUDE_DIRS)
+    endif()
+    if(${module_name}_DEFINITIONS)
+        list(REMOVE_DUPLICATES ${module_name}_DEFINITIONS)
+    endif()
+    if(${module_name}_TARGETS)
+        list(REMOVE_DUPLICATES ${module_name}_TARGETS)
+    endif()
+endmacro()
diff --git a/cmake/ECMFindModuleHelpersStub.cmake b/cmake/ECMFindModuleHelpersStub.cmake
new file mode 100644
index 00000000..acc8c804
--- /dev/null
+++ b/cmake/ECMFindModuleHelpersStub.cmake
@@ -0,0 +1 @@
+include(${CMAKE_CURRENT_LIST_DIR}/ECMFindModuleHelpers.cmake)
diff --git a/cmake/FindGTK3.cmake b/cmake/FindGTK3.cmake
new file mode 100644
index 00000000..06f6c18e
--- /dev/null
+++ b/cmake/FindGTK3.cmake
@@ -0,0 +1,16 @@
+# SPDX-FileCopyrightText: 2022 Andrea Pappacoda <andrea@pappacoda.it>
+# SPDX-License-Identifier: ISC
+
+include(FindPackageHandleStandardArgs)
+
+find_package(PkgConfig)
+if (PKG_CONFIG_FOUND)
+    pkg_search_module(GTK3 IMPORTED_TARGET gtk+-3.0)
+    if (GTK3_FOUND)
+        add_library(GTK3::gtk ALIAS PkgConfig::GTK3)
+    endif()
+    find_package_handle_standard_args(GTK3
+            REQUIRED_VARS GTK3_LINK_LIBRARIES
+            VERSION_VAR GTK3_VERSION
+    )
+endif()
diff --git a/cmake/FindWayland.cmake b/cmake/FindWayland.cmake
new file mode 100644
index 00000000..926fd485
--- /dev/null
+++ b/cmake/FindWayland.cmake
@@ -0,0 +1,137 @@
+# SPDX-FileCopyrightText: 2014 Alex Merry <alex.merry@kde.org>
+# SPDX-FileCopyrightText: 2014 Martin Gräßlin <mgraesslin@kde.org>
+#
+# SPDX-License-Identifier: BSD-3-Clause
+
+#[=======================================================================[.rst:
+FindWayland
+-----------
+
+Try to find Wayland.
+
+This is a component-based find module, which makes use of the COMPONENTS
+and OPTIONAL_COMPONENTS arguments to find_module.  The following components
+are available::
+
+  Client  Server  Cursor  Egl
+
+If no components are specified, this module will act as though all components
+were passed to OPTIONAL_COMPONENTS.
+
+This module will define the following variables, independently of the
+components searched for or found:
+
+``Wayland_FOUND``
+    TRUE if (the requested version of) Wayland is available
+``Wayland_VERSION``
+    Found Wayland version
+``Wayland_TARGETS``
+    A list of all targets imported by this module (note that there may be more
+    than the components that were requested)
+``Wayland_LIBRARIES``
+    This can be passed to target_link_libraries() instead of the imported
+    targets
+``Wayland_INCLUDE_DIRS``
+    This should be passed to target_include_directories() if the targets are
+    not used for linking
+``Wayland_DEFINITIONS``
+    This should be passed to target_compile_options() if the targets are not
+    used for linking
+``Wayland_DATADIR``
+    The core wayland protocols data directory
+    Since 5.73.0
+
+For each searched-for components, ``Wayland_<component>_FOUND`` will be set to
+TRUE if the corresponding Wayland library was found, and FALSE otherwise.  If
+``Wayland_<component>_FOUND`` is TRUE, the imported target
+``Wayland::<component>`` will be defined.  This module will also attempt to
+determine ``Wayland_*_VERSION`` variables for each imported target, although
+``Wayland_VERSION`` should normally be sufficient.
+
+In general we recommend using the imported targets, as they are easier to use
+and provide more control.  Bear in mind, however, that if any target is in the
+link interface of an exported library, it must be made available by the
+package config file.
+
+Since pre-1.0.0.
+#]=======================================================================]
+
+include(${CMAKE_CURRENT_LIST_DIR}/ECMFindModuleHelpersStub.cmake)
+
+ecm_find_package_version_check(Wayland)
+
+set(Wayland_known_components
+    Client
+    Server
+    Cursor
+    Egl
+)
+foreach(_comp ${Wayland_known_components})
+    string(TOLOWER "${_comp}" _lc_comp)
+    set(Wayland_${_comp}_component_deps)
+    set(Wayland_${_comp}_pkg_config "wayland-${_lc_comp}")
+    set(Wayland_${_comp}_lib "wayland-${_lc_comp}")
+    set(Wayland_${_comp}_header "wayland-${_lc_comp}.h")
+endforeach()
+set(Wayland_Egl_component_deps Client)
+
+ecm_find_package_parse_components(Wayland
+    RESULT_VAR Wayland_components
+    KNOWN_COMPONENTS ${Wayland_known_components}
+)
+ecm_find_package_handle_library_components(Wayland
+    COMPONENTS ${Wayland_components}
+)
+
+# If pkg-config didn't provide us with version information,
+# try to extract it from wayland-version.h
+# (Note that the version from wayland-egl.pc will probably be
+# the Mesa version, rather than the Wayland version, but that
+# version will be ignored as we always find wayland-client.pc
+# first).
+if(NOT Wayland_VERSION)
+    find_file(Wayland_VERSION_HEADER
+        NAMES wayland-version.h
+        HINTS ${Wayland_INCLUDE_DIRS}
+    )
+    mark_as_advanced(Wayland_VERSION_HEADER)
+    if(Wayland_VERSION_HEADER)
+        file(READ ${Wayland_VERSION_HEADER} _wayland_version_header_contents)
+        string(REGEX REPLACE
+            "^.*[ \t]+WAYLAND_VERSION[ \t]+\"([0-9.]*)\".*$"
+            "\\1"
+            Wayland_VERSION
+            "${_wayland_version_header_contents}"
+        )
+        unset(_wayland_version_header_contents)
+    endif()
+endif()
+
+find_package_handle_standard_args(Wayland
+    FOUND_VAR
+        Wayland_FOUND
+    REQUIRED_VARS
+        Wayland_LIBRARIES
+    VERSION_VAR
+        Wayland_VERSION
+    HANDLE_COMPONENTS
+)
+
+pkg_get_variable(Wayland_DATADIR wayland-scanner pkgdatadir)
+if (CMAKE_CROSSCOMPILING AND (NOT EXISTS "${Wayland_DATADIR}/wayland.xml"))
+    # PKG_CONFIG_SYSROOT_DIR only applies to -I and -L flags, so pkg-config
+    # does not prepend CMAKE_SYSROOT when cross-compiling unless you pass
+    # --define-prefix explicitly. Therefore we have to  manually do prepend
+    # it here when cross-compiling.
+    # See https://gitlab.kitware.com/cmake/cmake/-/issues/16647#note_844761
+    set(Wayland_DATADIR ${CMAKE_SYSROOT}${Wayland_DATADIR})
+endif()
+if (NOT EXISTS "${Wayland_DATADIR}/wayland.xml")
+    message(WARNING "Could not find wayland.xml in ${Wayland_DATADIR}")
+endif()
+
+include(FeatureSummary)
+set_package_properties(Wayland PROPERTIES
+    URL "https://wayland.freedesktop.org/"
+    DESCRIPTION "C library implementation of the Wayland protocol: a protocol for a compositor to talk to its clients"
+)
diff --git a/cmake/FindWaylandProtocols.cmake b/cmake/FindWaylandProtocols.cmake
new file mode 100644
index 00000000..a4449885
--- /dev/null
+++ b/cmake/FindWaylandProtocols.cmake
@@ -0,0 +1,38 @@
+# SPDX-FileCopyrightText: 2019 Vlad Zahorodnii <vlad.zahorodnii@kde.org>
+#
+# SPDX-License-Identifier: BSD-3-Clause
+
+#[=======================================================================[.rst:
+FindWaylandProtocols
+--------------------
+
+Try to find wayland-protocols on a Unix system.
+
+This will define the following variables:
+
+``WaylandProtocols_FOUND``
+    True if (the requested version of) wayland-protocols is available
+``WaylandProtocols_VERSION``
+    The version of wayland-protocols
+``WaylandProtocols_DATADIR``
+    The wayland protocols data directory
+#]=======================================================================]
+
+find_package(PkgConfig QUIET)
+pkg_check_modules(PKG_wayland_protocols QUIET wayland-protocols)
+
+set(WaylandProtocols_VERSION ${PKG_wayland_protocols_VERSION})
+pkg_get_variable(WaylandProtocols_DATADIR wayland-protocols pkgdatadir)
+
+include(FindPackageHandleStandardArgs)
+find_package_handle_standard_args(WaylandProtocols
+    FOUND_VAR WaylandProtocols_FOUND
+    REQUIRED_VARS WaylandProtocols_DATADIR
+    VERSION_VAR WaylandProtocols_VERSION
+)
+
+include(FeatureSummary)
+set_package_properties(WaylandProtocols PROPERTIES
+    DESCRIPTION "Specifications of extended Wayland protocols"
+    URL "https://wayland.freedesktop.org/"
+)
diff --git a/cmake/FindWaylandScanner.cmake b/cmake/FindWaylandScanner.cmake
new file mode 100644
index 00000000..f8495800
--- /dev/null
+++ b/cmake/FindWaylandScanner.cmake
@@ -0,0 +1,162 @@
+# SPDX-FileCopyrightText: 2012-2014 Pier Luigi Fiorini <pierluigi.fiorini@gmail.com>
+#
+# SPDX-License-Identifier: BSD-3-Clause
+
+#[=======================================================================[.rst:
+FindWaylandScanner
+------------------
+
+Try to find wayland-scanner.
+
+If the wayland-scanner executable is not in your PATH, you can provide
+an alternative name or full path location with the ``WaylandScanner_EXECUTABLE``
+variable.
+
+This will define the following variables:
+
+``WaylandScanner_FOUND``
+    True if wayland-scanner is available.
+
+``WaylandScanner_EXECUTABLE``
+    The wayland-scanner executable.
+
+If ``WaylandScanner_FOUND`` is TRUE, it will also define the following imported
+target:
+
+``Wayland::Scanner``
+    The wayland-scanner executable.
+
+This module provides the following functions to generate C protocol
+implementations:
+
+  - ``ecm_add_wayland_client_protocol``
+  - ``ecm_add_wayland_server_protocol``
+
+::
+
+  ecm_add_wayland_client_protocol(<target>
+                                  PROTOCOL <xmlfile>
+                                  BASENAME <basename>)
+
+  ecm_add_wayland_client_protocol(<source_files_var>
+                                  PROTOCOL <xmlfile>
+                                  BASENAME <basename>)
+
+Generate Wayland client protocol files from ``<xmlfile>`` XML
+definition for the ``<basename>`` interface and append those files
+to ``<source_files_var>`` or ``<target>``.
+
+::
+
+  ecm_add_wayland_server_protocol(<target>
+                                  PROTOCOL <xmlfile>
+                                  BASENAME <basename>)
+
+  ecm_add_wayland_server_protocol(<source_files_var>
+                                  PROTOCOL <xmlfile>
+                                  BASENAME <basename>)
+
+Generate Wayland server protocol files from ``<xmlfile>`` XML
+definition for the ``<basename>`` interface and append those files
+to ``<source_files_var>`` or ``<target>``.
+
+Since 1.4.0.
+#]=======================================================================]
+
+include(${CMAKE_CURRENT_LIST_DIR}/ECMFindModuleHelpersStub.cmake)
+
+ecm_find_package_version_check(WaylandScanner)
+
+# Find wayland-scanner
+find_program(WaylandScanner_EXECUTABLE NAMES wayland-scanner)
+
+include(FindPackageHandleStandardArgs)
+find_package_handle_standard_args(WaylandScanner
+    FOUND_VAR
+        WaylandScanner_FOUND
+    REQUIRED_VARS
+        WaylandScanner_EXECUTABLE
+)
+
+mark_as_advanced(WaylandScanner_EXECUTABLE)
+
+if(NOT TARGET Wayland::Scanner AND WaylandScanner_FOUND)
+    add_executable(Wayland::Scanner IMPORTED)
+    set_target_properties(Wayland::Scanner PROPERTIES
+        IMPORTED_LOCATION "${WaylandScanner_EXECUTABLE}"
+    )
+endif()
+
+include(FeatureSummary)
+set_package_properties(WaylandScanner PROPERTIES
+    URL "https://wayland.freedesktop.org/"
+    DESCRIPTION "Executable that converts XML protocol files to C code"
+)
+
+
+include(CMakeParseArguments)
+
+function(ecm_add_wayland_client_protocol target_or_sources_var)
+    # Parse arguments
+    set(oneValueArgs PROTOCOL BASENAME)
+    cmake_parse_arguments(ARGS "" "${oneValueArgs}" "" ${ARGN})
+
+    if(ARGS_UNPARSED_ARGUMENTS)
+        message(FATAL_ERROR "Unknown keywords given to ecm_add_wayland_client_protocol(): \"${ARGS_UNPARSED_ARGUMENTS}\"")
+    endif()
+
+    get_filename_component(_infile ${ARGS_PROTOCOL} ABSOLUTE)
+    set(_client_header "${CMAKE_CURRENT_BINARY_DIR}/wayland-${ARGS_BASENAME}-client-protocol.h")
+    set(_code "${CMAKE_CURRENT_BINARY_DIR}/wayland-${ARGS_BASENAME}-protocol.c")
+
+    set_source_files_properties(${_client_header} GENERATED)
+    set_source_files_properties(${_code} GENERATED)
+    set_property(SOURCE ${_client_header} ${_code} PROPERTY SKIP_AUTOMOC ON)
+
+    add_custom_command(OUTPUT "${_client_header}"
+        COMMAND ${WaylandScanner_EXECUTABLE} client-header ${_infile} ${_client_header}
+        DEPENDS ${_infile} VERBATIM)
+
+    add_custom_command(OUTPUT "${_code}"
+        COMMAND ${WaylandScanner_EXECUTABLE} public-code ${_infile} ${_code}
+        DEPENDS ${_infile} ${_client_header} VERBATIM)
+
+    if (TARGET ${target_or_sources_var})
+        target_sources(${target_or_sources_var} PRIVATE "${_client_header}" "${_code}")
+    else()
+        list(APPEND ${target_or_sources_var} "${_client_header}" "${_code}")
+        set(${target_or_sources_var} ${${target_or_sources_var}} PARENT_SCOPE)
+    endif()
+endfunction()
+
+
+function(ecm_add_wayland_server_protocol target_or_sources_var)
+    # Parse arguments
+    set(oneValueArgs PROTOCOL BASENAME)
+    cmake_parse_arguments(ARGS "" "${oneValueArgs}" "" ${ARGN})
+
+    if(ARGS_UNPARSED_ARGUMENTS)
+        message(FATAL_ERROR "Unknown keywords given to ecm_add_wayland_server_protocol(): \"${ARGS_UNPARSED_ARGUMENTS}\"")
+    endif()
+
+    ecm_add_wayland_client_protocol(${target_or_sources_var}
+                                    PROTOCOL ${ARGS_PROTOCOL}
+                                    BASENAME ${ARGS_BASENAME})
+
+    get_filename_component(_infile ${ARGS_PROTOCOL} ABSOLUTE)
+    set(_server_header "${CMAKE_CURRENT_BINARY_DIR}/wayland-${ARGS_BASENAME}-server-protocol.h")
+    set(_server_code "${CMAKE_CURRENT_BINARY_DIR}/wayland-${ARGS_BASENAME}-protocol.c")
+    set_property(SOURCE ${_server_header} ${_server_code} PROPERTY SKIP_AUTOMOC ON)
+    set_source_files_properties(${_server_header} GENERATED)
+
+    add_custom_command(OUTPUT "${_server_header}"
+        COMMAND ${WaylandScanner_EXECUTABLE} server-header ${_infile} ${_server_header}
+        DEPENDS ${_infile} VERBATIM)
+
+    if (TARGET ${target_or_sources_var})
+        target_sources(${target_or_sources_var} PRIVATE "${_server_header}")
+    else()
+        list(APPEND ${target_or_sources_var} "${_server_header}")
+        set(${target_or_sources_var} ${${target_or_sources_var}} PARENT_SCOPE)
+    endif()
+endfunction()
diff --git a/cmake/Findbluez.cmake b/cmake/Findbluez.cmake
new file mode 100644
index 00000000..007cdac9
--- /dev/null
+++ b/cmake/Findbluez.cmake
@@ -0,0 +1,20 @@
+# SPDX-FileCopyrightText: 2022 Andrea Pappacoda <andrea@pappacoda.it>
+# SPDX-License-Identifier: ISC
+
+find_package(bluez CONFIG)
+if (NOT bluez_FOUND)
+  find_package(PkgConfig)
+  if (PKG_CONFIG_FOUND)
+    pkg_search_module(bluez IMPORTED_TARGET GLOBAL bluez-1.0 bluez)
+    if (bluez_FOUND)
+      add_library(bluez::bluez ALIAS PkgConfig::bluez)
+    endif ()
+  endif ()
+endif ()
+
+find_package_handle_standard_args(bluez
+    REQUIRED_VARS
+    bluez_LINK_LIBRARIES
+    bluez_FOUND
+    VERSION_VAR bluez_VERSION
+)
diff --git a/cmake/Findlibusb.cmake b/cmake/Findlibusb.cmake
new file mode 100644
index 00000000..85da6736
--- /dev/null
+++ b/cmake/Findlibusb.cmake
@@ -0,0 +1,20 @@
+# SPDX-FileCopyrightText: 2022 Andrea Pappacoda <andrea@pappacoda.it>
+# SPDX-License-Identifier: ISC
+
+find_package(libusb CONFIG)
+if (NOT libusb_FOUND)
+    find_package(PkgConfig)
+    if (PKG_CONFIG_FOUND)
+        pkg_search_module(libusb IMPORTED_TARGET GLOBAL libusb-1.0 libusb)
+        if (libusb_FOUND)
+            add_library(libusb::libusb ALIAS PkgConfig::libusb)
+        endif ()
+    endif ()
+endif ()
+
+find_package_handle_standard_args(libusb
+        REQUIRED_VARS
+        libusb_LINK_LIBRARIES
+        libusb_FOUND
+        VERSION_VAR libusb_VERSION
+)
diff --git a/dependencies/Vulkan-Headers b/dependencies/Vulkan-Headers
index 71567370..9b9fd871 160000
--- a/dependencies/Vulkan-Headers
+++ b/dependencies/Vulkan-Headers
@@ -1 +1 @@
-Subproject commit 715673702f5b18ffb8e5832e67cf731468d32ac6
+Subproject commit 9b9fd871b08110cd8f0b74e721b03213d9cc3081
diff --git a/dependencies/ZArchive b/dependencies/ZArchive
index 48914a07..d2c71773 160000
--- a/dependencies/ZArchive
+++ b/dependencies/ZArchive
@@ -1 +1 @@
-Subproject commit 48914a07df3c213333c580bb5e5bb3393442ca5b
+Subproject commit d2c717730092c7bf8cbb033b12fd4001b7c4d932
diff --git a/dependencies/cubeb b/dependencies/cubeb
index dc511c6b..2071354a 160000
--- a/dependencies/cubeb
+++ b/dependencies/cubeb
@@ -1 +1 @@
-Subproject commit dc511c6b3597b6384d28949285b9289e009830ea
+Subproject commit 2071354a69aca7ed6df3b4222e305746c2113f60
diff --git a/dependencies/gamemode/CMakeLists.txt b/dependencies/gamemode/CMakeLists.txt
new file mode 100644
index 00000000..78275174
--- /dev/null
+++ b/dependencies/gamemode/CMakeLists.txt
@@ -0,0 +1,4 @@
+project( gamemode LANGUAGES C )
+add_library (gamemode
+        "lib/gamemode_client.h"
+        "lib/client_loader.c")
\ No newline at end of file
diff --git a/dependencies/gamemode/lib/client_loader.c b/dependencies/gamemode/lib/client_loader.c
new file mode 100644
index 00000000..08c86d06
--- /dev/null
+++ b/dependencies/gamemode/lib/client_loader.c
@@ -0,0 +1,35 @@
+/*
+
+Copyright (c) 2017-2019, Feral Interactive
+All rights reserved.
+
+Redistribution and use in source and binary forms, with or without
+modification, are permitted provided that the following conditions are met:
+
+ * Redistributions of source code must retain the above copyright notice,
+   this list of conditions and the following disclaimer.
+ * Redistributions in binary form must reproduce the above copyright
+   notice, this list of conditions and the following disclaimer in the
+   documentation and/or other materials provided with the distribution.
+ * Neither the name of Feral Interactive nor the names of its contributors
+   may be used to endorse or promote products derived from this software
+   without specific prior written permission.
+
+THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
+AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
+IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
+ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR CONTRIBUTORS BE
+LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
+CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
+SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
+INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
+CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
+ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
+POSSIBILITY OF SUCH DAMAGE.
+
+ */
+
+// Simply include the header with GAMEMODE_AUTO set
+// This will ensure it calls the functions when it's loaded
+#define GAMEMODE_AUTO
+#include "gamemode_client.h"
diff --git a/dependencies/gamemode/lib/gamemode_client.h b/dependencies/gamemode/lib/gamemode_client.h
new file mode 100644
index 00000000..b9f64fe4
--- /dev/null
+++ b/dependencies/gamemode/lib/gamemode_client.h
@@ -0,0 +1,376 @@
+/*
+
+Copyright (c) 2017-2019, Feral Interactive
+All rights reserved.
+
+Redistribution and use in source and binary forms, with or without
+modification, are permitted provided that the following conditions are met:
+
+ * Redistributions of source code must retain the above copyright notice,
+   this list of conditions and the following disclaimer.
+ * Redistributions in binary form must reproduce the above copyright
+   notice, this list of conditions and the following disclaimer in the
+   documentation and/or other materials provided with the distribution.
+ * Neither the name of Feral Interactive nor the names of its contributors
+   may be used to endorse or promote products derived from this software
+   without specific prior written permission.
+
+THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
+AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
+IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
+ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR CONTRIBUTORS BE
+LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
+CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
+SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
+INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
+CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
+ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
+POSSIBILITY OF SUCH DAMAGE.
+
+ */
+#ifndef CLIENT_GAMEMODE_H
+#define CLIENT_GAMEMODE_H
+/*
+ * GameMode supports the following client functions
+ * Requests are refcounted in the daemon
+ *
+ * int gamemode_request_start() - Request gamemode starts
+ *   0 if the request was sent successfully
+ *   -1 if the request failed
+ *
+ * int gamemode_request_end() - Request gamemode ends
+ *   0 if the request was sent successfully
+ *   -1 if the request failed
+ *
+ * GAMEMODE_AUTO can be defined to make the above two functions apply during static init and
+ * destruction, as appropriate. In this configuration, errors will be printed to stderr
+ *
+ * int gamemode_query_status() - Query the current status of gamemode
+ *   0 if gamemode is inactive
+ *   1 if gamemode is active
+ *   2 if gamemode is active and this client is registered
+ *   -1 if the query failed
+ *
+ * int gamemode_request_start_for(pid_t pid) - Request gamemode starts for another process
+ *   0 if the request was sent successfully
+ *   -1 if the request failed
+ *   -2 if the request was rejected
+ *
+ * int gamemode_request_end_for(pid_t pid) - Request gamemode ends for another process
+ *   0 if the request was sent successfully
+ *   -1 if the request failed
+ *   -2 if the request was rejected
+ *
+ * int gamemode_query_status_for(pid_t pid) - Query status of gamemode for another process
+ *   0 if gamemode is inactive
+ *   1 if gamemode is active
+ *   2 if gamemode is active and this client is registered
+ *   -1 if the query failed
+ *
+ * const char* gamemode_error_string() - Get an error string
+ *   returns a string describing any of the above errors
+ *
+ * Note: All the above requests can be blocking - dbus requests can and will block while the daemon
+ * handles the request. It is not recommended to make these calls in performance critical code
+ */
+
+#include <stdbool.h>
+#include <stdio.h>
+
+#include <dlfcn.h>
+#include <string.h>
+
+#include <assert.h>
+
+#include <sys/types.h>
+
+static char internal_gamemode_client_error_string[512] = { 0 };
+
+/**
+ * Load libgamemode dynamically to dislodge us from most dependencies.
+ * This allows clients to link and/or use this regardless of runtime.
+ * See SDL2 for an example of the reasoning behind this in terms of
+ * dynamic versioning as well.
+ */
+static volatile int internal_libgamemode_loaded = 1;
+
+/* Typedefs for the functions to load */
+typedef int (*api_call_return_int)(void);
+typedef const char *(*api_call_return_cstring)(void);
+typedef int (*api_call_pid_return_int)(pid_t);
+
+/* Storage for functors */
+static api_call_return_int REAL_internal_gamemode_request_start = NULL;
+static api_call_return_int REAL_internal_gamemode_request_end = NULL;
+static api_call_return_int REAL_internal_gamemode_query_status = NULL;
+static api_call_return_cstring REAL_internal_gamemode_error_string = NULL;
+static api_call_pid_return_int REAL_internal_gamemode_request_start_for = NULL;
+static api_call_pid_return_int REAL_internal_gamemode_request_end_for = NULL;
+static api_call_pid_return_int REAL_internal_gamemode_query_status_for = NULL;
+
+/**
+ * Internal helper to perform the symbol binding safely.
+ *
+ * Returns 0 on success and -1 on failure
+ */
+__attribute__((always_inline)) static inline int internal_bind_libgamemode_symbol(
+    void *handle, const char *name, void **out_func, size_t func_size, bool required)
+{
+	void *symbol_lookup = NULL;
+	char *dl_error = NULL;
+
+	/* Safely look up the symbol */
+	symbol_lookup = dlsym(handle, name);
+	dl_error = dlerror();
+	if (required && (dl_error || !symbol_lookup)) {
+		snprintf(internal_gamemode_client_error_string,
+		         sizeof(internal_gamemode_client_error_string),
+		         "dlsym failed - %s",
+		         dl_error);
+		return -1;
+	}
+
+	/* Have the symbol correctly, copy it to make it usable */
+	memcpy(out_func, &symbol_lookup, func_size);
+	return 0;
+}
+
+/**
+ * Loads libgamemode and needed functions
+ *
+ * Returns 0 on success and -1 on failure
+ */
+__attribute__((always_inline)) static inline int internal_load_libgamemode(void)
+{
+	/* We start at 1, 0 is a success and -1 is a fail */
+	if (internal_libgamemode_loaded != 1) {
+		return internal_libgamemode_loaded;
+	}
+
+	/* Anonymous struct type to define our bindings */
+	struct binding {
+		const char *name;
+		void **functor;
+		size_t func_size;
+		bool required;
+	} bindings[] = {
+		{ "real_gamemode_request_start",
+		  (void **)&REAL_internal_gamemode_request_start,
+		  sizeof(REAL_internal_gamemode_request_start),
+		  true },
+		{ "real_gamemode_request_end",
+		  (void **)&REAL_internal_gamemode_request_end,
+		  sizeof(REAL_internal_gamemode_request_end),
+		  true },
+		{ "real_gamemode_query_status",
+		  (void **)&REAL_internal_gamemode_query_status,
+		  sizeof(REAL_internal_gamemode_query_status),
+		  false },
+		{ "real_gamemode_error_string",
+		  (void **)&REAL_internal_gamemode_error_string,
+		  sizeof(REAL_internal_gamemode_error_string),
+		  true },
+		{ "real_gamemode_request_start_for",
+		  (void **)&REAL_internal_gamemode_request_start_for,
+		  sizeof(REAL_internal_gamemode_request_start_for),
+		  false },
+		{ "real_gamemode_request_end_for",
+		  (void **)&REAL_internal_gamemode_request_end_for,
+		  sizeof(REAL_internal_gamemode_request_end_for),
+		  false },
+		{ "real_gamemode_query_status_for",
+		  (void **)&REAL_internal_gamemode_query_status_for,
+		  sizeof(REAL_internal_gamemode_query_status_for),
+		  false },
+	};
+
+	void *libgamemode = NULL;
+
+	/* Try and load libgamemode */
+	libgamemode = dlopen("libgamemode.so.0", RTLD_NOW);
+	if (!libgamemode) {
+		/* Attempt to load unversioned library for compatibility with older
+		 * versions (as of writing, there are no ABI changes between the two -
+		 * this may need to change if ever ABI-breaking changes are made) */
+		libgamemode = dlopen("libgamemode.so", RTLD_NOW);
+		if (!libgamemode) {
+			snprintf(internal_gamemode_client_error_string,
+			         sizeof(internal_gamemode_client_error_string),
+			         "dlopen failed - %s",
+			         dlerror());
+			internal_libgamemode_loaded = -1;
+			return -1;
+		}
+	}
+
+	/* Attempt to bind all symbols */
+	for (size_t i = 0; i < sizeof(bindings) / sizeof(bindings[0]); i++) {
+		struct binding *binder = &bindings[i];
+
+		if (internal_bind_libgamemode_symbol(libgamemode,
+		                                     binder->name,
+		                                     binder->functor,
+		                                     binder->func_size,
+		                                     binder->required)) {
+			internal_libgamemode_loaded = -1;
+			return -1;
+		};
+	}
+
+	/* Success */
+	internal_libgamemode_loaded = 0;
+	return 0;
+}
+
+/**
+ * Redirect to the real libgamemode
+ */
+__attribute__((always_inline)) static inline const char *gamemode_error_string(void)
+{
+	/* If we fail to load the system gamemode, or we have an error string already, return our error
+	 * string instead of diverting to the system version */
+	if (internal_load_libgamemode() < 0 || internal_gamemode_client_error_string[0] != '\0') {
+		return internal_gamemode_client_error_string;
+	}
+
+	/* Assert for static analyser that the function is not NULL */
+	assert(REAL_internal_gamemode_error_string != NULL);
+
+	return REAL_internal_gamemode_error_string();
+}
+
+/**
+ * Redirect to the real libgamemode
+ * Allow automatically requesting game mode
+ * Also prints errors as they happen.
+ */
+#ifdef GAMEMODE_AUTO
+__attribute__((constructor))
+#else
+__attribute__((always_inline)) static inline
+#endif
+int gamemode_request_start(void)
+{
+	/* Need to load gamemode */
+	if (internal_load_libgamemode() < 0) {
+#ifdef GAMEMODE_AUTO
+		fprintf(stderr, "gamemodeauto: %s\n", gamemode_error_string());
+#endif
+		return -1;
+	}
+
+	/* Assert for static analyser that the function is not NULL */
+	assert(REAL_internal_gamemode_request_start != NULL);
+
+	if (REAL_internal_gamemode_request_start() < 0) {
+#ifdef GAMEMODE_AUTO
+		fprintf(stderr, "gamemodeauto: %s\n", gamemode_error_string());
+#endif
+		return -1;
+	}
+
+	return 0;
+}
+
+/* Redirect to the real libgamemode */
+#ifdef GAMEMODE_AUTO
+__attribute__((destructor))
+#else
+__attribute__((always_inline)) static inline
+#endif
+int gamemode_request_end(void)
+{
+	/* Need to load gamemode */
+	if (internal_load_libgamemode() < 0) {
+#ifdef GAMEMODE_AUTO
+		fprintf(stderr, "gamemodeauto: %s\n", gamemode_error_string());
+#endif
+		return -1;
+	}
+
+	/* Assert for static analyser that the function is not NULL */
+	assert(REAL_internal_gamemode_request_end != NULL);
+
+	if (REAL_internal_gamemode_request_end() < 0) {
+#ifdef GAMEMODE_AUTO
+		fprintf(stderr, "gamemodeauto: %s\n", gamemode_error_string());
+#endif
+		return -1;
+	}
+
+	return 0;
+}
+
+/* Redirect to the real libgamemode */
+__attribute__((always_inline)) static inline int gamemode_query_status(void)
+{
+	/* Need to load gamemode */
+	if (internal_load_libgamemode() < 0) {
+		return -1;
+	}
+
+	if (REAL_internal_gamemode_query_status == NULL) {
+		snprintf(internal_gamemode_client_error_string,
+		         sizeof(internal_gamemode_client_error_string),
+		         "gamemode_query_status missing (older host?)");
+		return -1;
+	}
+
+	return REAL_internal_gamemode_query_status();
+}
+
+/* Redirect to the real libgamemode */
+__attribute__((always_inline)) static inline int gamemode_request_start_for(pid_t pid)
+{
+	/* Need to load gamemode */
+	if (internal_load_libgamemode() < 0) {
+		return -1;
+	}
+
+	if (REAL_internal_gamemode_request_start_for == NULL) {
+		snprintf(internal_gamemode_client_error_string,
+		         sizeof(internal_gamemode_client_error_string),
+		         "gamemode_request_start_for missing (older host?)");
+		return -1;
+	}
+
+	return REAL_internal_gamemode_request_start_for(pid);
+}
+
+/* Redirect to the real libgamemode */
+__attribute__((always_inline)) static inline int gamemode_request_end_for(pid_t pid)
+{
+	/* Need to load gamemode */
+	if (internal_load_libgamemode() < 0) {
+		return -1;
+	}
+
+	if (REAL_internal_gamemode_request_end_for == NULL) {
+		snprintf(internal_gamemode_client_error_string,
+		         sizeof(internal_gamemode_client_error_string),
+		         "gamemode_request_end_for missing (older host?)");
+		return -1;
+	}
+
+	return REAL_internal_gamemode_request_end_for(pid);
+}
+
+/* Redirect to the real libgamemode */
+__attribute__((always_inline)) static inline int gamemode_query_status_for(pid_t pid)
+{
+	/* Need to load gamemode */
+	if (internal_load_libgamemode() < 0) {
+		return -1;
+	}
+
+	if (REAL_internal_gamemode_query_status_for == NULL) {
+		snprintf(internal_gamemode_client_error_string,
+		         sizeof(internal_gamemode_client_error_string),
+		         "gamemode_query_status_for missing (older host?)");
+		return -1;
+	}
+
+	return REAL_internal_gamemode_query_status_for(pid);
+}
+
+#endif // CLIENT_GAMEMODE_H
diff --git a/dependencies/ih264d/CMakeLists.txt b/dependencies/ih264d/CMakeLists.txt
index 4f538f69..64ac0931 100644
--- a/dependencies/ih264d/CMakeLists.txt
+++ b/dependencies/ih264d/CMakeLists.txt
@@ -2,14 +2,6 @@
 
 project ("ih264d")
 
-set(LIBAVCDEC_X86_INCLUDES "common/x86" "decoder/x86")
-
-include_directories("common/" "decoder/" ${LIBAVCDEC_X86_INCLUDES})
-
-if((CMAKE_C_COMPILER_ID MATCHES "GNU") OR (CMAKE_C_COMPILER_ID MATCHES "Clang"))
-	add_compile_options(-mssse3 -mavx2)
-endif()
-
 add_library (ih264d 
 "common/ih264_buf_mgr.c"
 "common/ih264_buf_mgr.h"
@@ -57,21 +49,6 @@ add_library (ih264d
 "common/ih264_weighted_pred.h"
 "common/ithread.c"
 "common/ithread.h"
-"common/x86/ih264_chroma_intra_pred_filters_ssse3.c"
-"common/x86/ih264_deblk_chroma_ssse3.c"
-"common/x86/ih264_deblk_luma_ssse3.c"
-"common/x86/ih264_ihadamard_scaling_sse42.c"
-"common/x86/ih264_ihadamard_scaling_ssse3.c"
-"common/x86/ih264_inter_pred_filters_ssse3.c"
-"common/x86/ih264_iquant_itrans_recon_dc_ssse3.c"
-"common/x86/ih264_iquant_itrans_recon_sse42.c"
-"common/x86/ih264_iquant_itrans_recon_ssse3.c"
-"common/x86/ih264_luma_intra_pred_filters_ssse3.c"
-"common/x86/ih264_mem_fns_ssse3.c"
-"common/x86/ih264_padding_ssse3.c"
-"common/x86/ih264_platform_macros.h"
-"common/x86/ih264_resi_trans_quant_sse42.c"
-"common/x86/ih264_weighted_pred_sse42.c"
 "decoder/ih264d.h"
 "decoder/ih264d_api.c"
 "decoder/ih264d_bitstrm.c"
@@ -138,11 +115,87 @@ add_library (ih264d
 "decoder/ih264d_vui.h"
 "decoder/iv.h"
 "decoder/ivd.h"
+)
+
+if (CMAKE_OSX_ARCHITECTURES)
+set(IH264D_ARCHITECTURE ${CMAKE_OSX_ARCHITECTURES})
+else()
+set(IH264D_ARCHITECTURE ${CMAKE_SYSTEM_PROCESSOR})
+endif()
+
+if (IH264D_ARCHITECTURE STREQUAL "x86_64" OR IH264D_ARCHITECTURE STREQUAL "amd64" OR IH264D_ARCHITECTURE STREQUAL "AMD64")
+set(LIBAVCDEC_X86_INCLUDES "common/x86" "decoder/x86")
+include_directories("common/" "decoder/" ${LIBAVCDEC_X86_INCLUDES})
+target_sources(ih264d PRIVATE
+"common/x86/ih264_chroma_intra_pred_filters_ssse3.c"
+"common/x86/ih264_deblk_chroma_ssse3.c"
+"common/x86/ih264_deblk_luma_ssse3.c"
+"common/x86/ih264_ihadamard_scaling_sse42.c"
+"common/x86/ih264_ihadamard_scaling_ssse3.c"
+"common/x86/ih264_inter_pred_filters_ssse3.c"
+"common/x86/ih264_iquant_itrans_recon_dc_ssse3.c"
+"common/x86/ih264_iquant_itrans_recon_sse42.c"
+"common/x86/ih264_iquant_itrans_recon_ssse3.c"
+"common/x86/ih264_luma_intra_pred_filters_ssse3.c"
+"common/x86/ih264_mem_fns_ssse3.c"
+"common/x86/ih264_padding_ssse3.c"
+"common/x86/ih264_platform_macros.h"
+"common/x86/ih264_resi_trans_quant_sse42.c"
+"common/x86/ih264_weighted_pred_sse42.c"
 "decoder/x86/ih264d_function_selector.c"
 "decoder/x86/ih264d_function_selector_sse42.c"
 "decoder/x86/ih264d_function_selector_ssse3.c"
 )
+elseif(IH264D_ARCHITECTURE STREQUAL "aarch64" OR IH264D_ARCHITECTURE STREQUAL "arm64")
+enable_language( C CXX ASM )
+set(LIBAVCDEC_ARM_INCLUDES "common/armv8" "decoder/arm")
+include_directories("common/" "decoder/" ${LIBAVCDEC_ARM_INCLUDES})
+target_sources(ih264d PRIVATE
+"common/armv8/ih264_deblk_chroma_av8.s"
+"common/armv8/ih264_deblk_luma_av8.s"
+"common/armv8/ih264_default_weighted_pred_av8.s"
+"common/armv8/ih264_ihadamard_scaling_av8.s"
+"common/armv8/ih264_inter_pred_chroma_av8.s"
+"common/armv8/ih264_inter_pred_filters_luma_horz_av8.s"
+"common/armv8/ih264_inter_pred_filters_luma_vert_av8.s"
+"common/armv8/ih264_inter_pred_luma_copy_av8.s"
+"common/armv8/ih264_inter_pred_luma_horz_hpel_vert_hpel_av8.s"
+"common/armv8/ih264_inter_pred_luma_horz_hpel_vert_qpel_av8.s"
+"common/armv8/ih264_inter_pred_luma_horz_qpel_av8.s"
+"common/armv8/ih264_inter_pred_luma_horz_qpel_vert_hpel_av8.s"
+"common/armv8/ih264_inter_pred_luma_horz_qpel_vert_qpel_av8.s"
+"common/armv8/ih264_inter_pred_luma_vert_qpel_av8.s"
+"common/armv8/ih264_intra_pred_chroma_av8.s"
+"common/armv8/ih264_intra_pred_luma_16x16_av8.s"
+"common/armv8/ih264_intra_pred_luma_4x4_av8.s"
+"common/armv8/ih264_intra_pred_luma_8x8_av8.s"
+"common/armv8/ih264_iquant_itrans_recon_av8.s"
+"common/armv8/ih264_iquant_itrans_recon_dc_av8.s"
+"common/armv8/ih264_mem_fns_neon_av8.s"
+"common/armv8/ih264_neon_macros.s"
+"common/armv8/ih264_padding_neon_av8.s"
+"common/armv8/ih264_platform_macros.h"
+"common/armv8/ih264_resi_trans_quant_av8.s"
+"common/armv8/ih264_weighted_bi_pred_av8.s"
+"common/armv8/ih264_weighted_pred_av8.s"
+"decoder/arm/ih264d_function_selector_a9q.c"
+"decoder/arm/ih264d_function_selector_av8.c"
+"decoder/arm/ih264d_function_selector.c"
+)
+target_compile_options(ih264d PRIVATE -DARMV8)
+if(APPLE)
+    target_sources(ih264d PRIVATE "common/armv8/macos_arm_symbol_aliases.s")
+endif()
+else()
+message(FATAL_ERROR "ih264d unknown architecture: ${IH264D_ARCHITECTURE}")
+endif()
 
 if(MSVC)
 set_property(TARGET ih264d PROPERTY MSVC_RUNTIME_LIBRARY "MultiThreaded$<$<CONFIG:Debug>:Debug>")
+
+# tune settings for slightly better performance
+target_compile_options(ih264d PRIVATE $<$<CONFIG:Release,RelWithDebInfo>:/Oi>) # enable intrinsic functions
+target_compile_options(ih264d PRIVATE $<$<CONFIG:Release,RelWithDebInfo>:/Ot>) # favor speed
+target_compile_options(ih264d PRIVATE "/GS-") # disable runtime checks
+
 endif()
diff --git a/dependencies/ih264d/common/armv8/ih264_intra_pred_chroma_av8.s b/dependencies/ih264d/common/armv8/ih264_intra_pred_chroma_av8.s
index 39c02560..c0d9cf99 100644
--- a/dependencies/ih264d/common/armv8/ih264_intra_pred_chroma_av8.s
+++ b/dependencies/ih264d/common/armv8/ih264_intra_pred_chroma_av8.s
@@ -429,8 +429,13 @@ ih264_intra_pred_chroma_8x8_mode_plane_av8:
     rev64     v7.4h, v2.4h
     ld1       {v3.2s}, [x10]
     sub       x5, x3, #8
+#ifdef __APPLE__
+    adrp      x12, _ih264_gai1_intrapred_chroma_plane_coeffs1@GOTPAGE
+    ldr       x12, [x12, _ih264_gai1_intrapred_chroma_plane_coeffs1@GOTPAGEOFF]
+#else
     adrp      x12, :got:ih264_gai1_intrapred_chroma_plane_coeffs1
     ldr       x12, [x12, #:got_lo12:ih264_gai1_intrapred_chroma_plane_coeffs1]
+#endif
     usubl     v10.8h, v5.8b, v1.8b
     ld1       {v8.8b, v9.8b}, [x12]     // Load multiplication factors 1 to 8 into D3
     mov       v8.d[1], v9.d[0]
@@ -484,10 +489,13 @@ ih264_intra_pred_chroma_8x8_mode_plane_av8:
     zip1      v1.8h, v0.8h, v2.8h
     zip2      v2.8h, v0.8h, v2.8h
     mov       v0.16b, v1.16b
-
+#ifdef __APPLE__
+    adrp      x12, _ih264_gai1_intrapred_chroma_plane_coeffs2@GOTPAGE
+    ldr       x12, [x12, _ih264_gai1_intrapred_chroma_plane_coeffs2@GOTPAGEOFF]
+#else
     adrp      x12, :got:ih264_gai1_intrapred_chroma_plane_coeffs2
     ldr       x12, [x12, #:got_lo12:ih264_gai1_intrapred_chroma_plane_coeffs2]
-
+#endif
     ld1       {v8.2s, v9.2s}, [x12]
     mov       v8.d[1], v9.d[0]
     mov       v10.16b, v8.16b
diff --git a/dependencies/ih264d/common/armv8/ih264_intra_pred_luma_16x16_av8.s b/dependencies/ih264d/common/armv8/ih264_intra_pred_luma_16x16_av8.s
index fa19c121..2422d8cd 100644
--- a/dependencies/ih264d/common/armv8/ih264_intra_pred_luma_16x16_av8.s
+++ b/dependencies/ih264d/common/armv8/ih264_intra_pred_luma_16x16_av8.s
@@ -431,10 +431,13 @@ ih264_intra_pred_luma_16x16_mode_plane_av8:
     mov       x10, x1                   //top_left
     mov       x4, #-1
     ld1       {v2.2s}, [x1], x8
-
+#ifdef __APPLE__
+    adrp      x7, _ih264_gai1_intrapred_luma_plane_coeffs@GOTPAGE
+    ldr       x7, [x7, _ih264_gai1_intrapred_luma_plane_coeffs@GOTPAGEOFF]
+#else
     adrp      x7, :got:ih264_gai1_intrapred_luma_plane_coeffs
     ldr       x7, [x7, #:got_lo12:ih264_gai1_intrapred_luma_plane_coeffs]
-
+#endif
     ld1       {v0.2s}, [x1]
     rev64     v2.8b, v2.8b
     ld1       {v6.2s, v7.2s}, [x7]
diff --git a/dependencies/ih264d/common/armv8/ih264_intra_pred_luma_8x8_av8.s b/dependencies/ih264d/common/armv8/ih264_intra_pred_luma_8x8_av8.s
index 273aa81b..6fa31ded 100644
--- a/dependencies/ih264d/common/armv8/ih264_intra_pred_luma_8x8_av8.s
+++ b/dependencies/ih264d/common/armv8/ih264_intra_pred_luma_8x8_av8.s
@@ -1029,9 +1029,13 @@ ih264_intra_pred_luma_8x8_mode_horz_u_av8:
     mov       v3.d[0], v2.d[1]
     ext       v4.16b, v2.16b , v2.16b , #1
     mov       v5.d[0], v4.d[1]
-
+#ifdef __APPLE__
+    adrp      x12, _ih264_gai1_intrapred_luma_8x8_horz_u@GOTPAGE
+    ldr       x12, [x12, _ih264_gai1_intrapred_luma_8x8_horz_u@GOTPAGEOFF]
+#else
     adrp      x12, :got:ih264_gai1_intrapred_luma_8x8_horz_u
     ldr       x12, [x12, #:got_lo12:ih264_gai1_intrapred_luma_8x8_horz_u]
+#endif
     uaddl     v20.8h, v0.8b, v2.8b
     uaddl     v22.8h, v1.8b, v3.8b
     uaddl     v24.8h, v2.8b, v4.8b
diff --git a/dependencies/ih264d/common/armv8/ih264_weighted_bi_pred_av8.s b/dependencies/ih264d/common/armv8/ih264_weighted_bi_pred_av8.s
index 475f690e..8d6aa995 100644
--- a/dependencies/ih264d/common/armv8/ih264_weighted_bi_pred_av8.s
+++ b/dependencies/ih264d/common/armv8/ih264_weighted_bi_pred_av8.s
@@ -142,14 +142,22 @@ ih264_weighted_bi_pred_luma_av8:
     sxtw      x4, w4
     sxtw      x5, w5
     stp       x19, x20, [sp, #-16]!
+#ifndef __APPLE__
     ldr       w8, [sp, #80]             //Load wt2 in w8
     ldr       w9, [sp, #88]             //Load ofst1 in w9
-    add       w6, w6, #1                //w6  = log_WD + 1
-    neg       w10, w6                   //w10 = -(log_WD + 1)
-    dup       v0.8h, w10                //Q0  = -(log_WD + 1) (32-bit)
     ldr       w10, [sp, #96]            //Load ofst2 in w10
     ldr       w11, [sp, #104]           //Load ht in w11
     ldr       w12, [sp, #112]           //Load wd in w12
+#else
+    ldr       w8, [sp, #80]             //Load wt2 in w8
+    ldr       w9, [sp, #84]             //Load ofst1 in w9
+    ldr       w10, [sp, #88]            //Load ofst2 in w10
+    ldr       w11,  [sp, #92]           //Load ht in w11
+    ldr       w12,  [sp, #96]           //Load wd in w12
+#endif
+    add       w6, w6, #1                //w6  = log_WD + 1
+    neg       w10, w6                   //w10 = -(log_WD + 1)
+    dup       v0.8h, w10                //Q0  = -(log_WD + 1) (32-bit)
     add       w9, w9, #1                //w9 = ofst1 + 1
     add       w9, w9, w10               //w9 = ofst1 + ofst2 + 1
     mov       v2.s[0], w7
@@ -424,17 +432,24 @@ ih264_weighted_bi_pred_chroma_av8:
     sxtw      x5, w5
     stp       x19, x20, [sp, #-16]!
 
-
+#ifndef __APPLE__
     ldr       w8, [sp, #80]             //Load wt2 in w8
+    ldr       w9, [sp, #88]             //Load ofst1 in w9
+    ldr       w10, [sp, #96]            //Load ofst2 in w10
+    ldr       w11, [sp, #104]           //Load ht in w11
+    ldr       w12, [sp, #112]           //Load wd in w12
+#else
+    ldr       w8, [sp, #80]             //Load wt2 in w8
+    ldr       w9, [sp, #84]             //Load ofst1 in w9
+    ldr       w10, [sp, #88]            //Load ofst2 in w10
+    ldr       w11,  [sp, #92]           //Load ht in w11
+    ldr       w12,  [sp, #96]           //Load wd in w12
+#endif
     dup       v4.4s, w8                 //Q2 = (wt2_u, wt2_v) (32-bit)
     dup       v2.4s, w7                 //Q1 = (wt1_u, wt1_v) (32-bit)
     add       w6, w6, #1                //w6  = log_WD + 1
-    ldr       w9, [sp, #88]             //Load ofst1 in w9
-    ldr       w10, [sp, #96]            //Load ofst2 in w10
     neg       w20, w6                   //w20 = -(log_WD + 1)
     dup       v0.8h, w20                //Q0  = -(log_WD + 1) (16-bit)
-    ldr       w11, [sp, #104]           //Load ht in x11
-    ldr       w12, [sp, #112]           //Load wd in x12
     dup       v20.8h, w9                //0ffset1
     dup       v21.8h, w10               //0ffset2
     srhadd    v6.8b, v20.8b, v21.8b
diff --git a/dependencies/ih264d/common/armv8/macos_arm_symbol_aliases.s b/dependencies/ih264d/common/armv8/macos_arm_symbol_aliases.s
new file mode 100644
index 00000000..3639f1b3
--- /dev/null
+++ b/dependencies/ih264d/common/armv8/macos_arm_symbol_aliases.s
@@ -0,0 +1,185 @@
+// macOS clang compilers append preceding underscores to function names, this is to prevent
+// mismatches with the assembly function names and the C functions as defined in the header.
+
+.global _ih264_deblk_chroma_horz_bs4_av8
+_ih264_deblk_chroma_horz_bs4_av8 = ih264_deblk_chroma_horz_bs4_av8
+
+.global _ih264_deblk_chroma_horz_bslt4_av8
+_ih264_deblk_chroma_horz_bslt4_av8 = ih264_deblk_chroma_horz_bslt4_av8
+
+.global _ih264_deblk_chroma_vert_bs4_av8
+_ih264_deblk_chroma_vert_bs4_av8 = ih264_deblk_chroma_vert_bs4_av8
+
+.global _ih264_deblk_chroma_vert_bslt4_av8
+_ih264_deblk_chroma_vert_bslt4_av8 = ih264_deblk_chroma_vert_bslt4_av8
+
+.global _ih264_deblk_luma_horz_bs4_av8
+_ih264_deblk_luma_horz_bs4_av8 = ih264_deblk_luma_horz_bs4_av8
+
+.global _ih264_deblk_luma_horz_bslt4_av8
+_ih264_deblk_luma_horz_bslt4_av8 = ih264_deblk_luma_horz_bslt4_av8
+
+.global _ih264_deblk_luma_vert_bs4_av8
+_ih264_deblk_luma_vert_bs4_av8 = ih264_deblk_luma_vert_bs4_av8
+
+.global _ih264_deblk_luma_vert_bslt4_av8
+_ih264_deblk_luma_vert_bslt4_av8 = ih264_deblk_luma_vert_bslt4_av8
+
+.global _ih264_default_weighted_pred_chroma_av8
+_ih264_default_weighted_pred_chroma_av8 = ih264_default_weighted_pred_chroma_av8
+
+.global _ih264_default_weighted_pred_luma_av8
+_ih264_default_weighted_pred_luma_av8 = ih264_default_weighted_pred_luma_av8
+
+.global _ih264_ihadamard_scaling_4x4_av8
+_ih264_ihadamard_scaling_4x4_av8 = ih264_ihadamard_scaling_4x4_av8
+
+.global _ih264_inter_pred_chroma_av8
+_ih264_inter_pred_chroma_av8 = ih264_inter_pred_chroma_av8
+
+.global _ih264_inter_pred_luma_copy_av8
+_ih264_inter_pred_luma_copy_av8 = ih264_inter_pred_luma_copy_av8
+
+.global _ih264_inter_pred_luma_horz_av8
+_ih264_inter_pred_luma_horz_av8 = ih264_inter_pred_luma_horz_av8
+
+.global _ih264_inter_pred_luma_horz_hpel_vert_hpel_av8
+_ih264_inter_pred_luma_horz_hpel_vert_hpel_av8 = ih264_inter_pred_luma_horz_hpel_vert_hpel_av8
+
+.global _ih264_inter_pred_luma_horz_hpel_vert_qpel_av8
+_ih264_inter_pred_luma_horz_hpel_vert_qpel_av8 = ih264_inter_pred_luma_horz_hpel_vert_qpel_av8
+
+.global _ih264_inter_pred_luma_horz_qpel_av8
+_ih264_inter_pred_luma_horz_qpel_av8 = ih264_inter_pred_luma_horz_qpel_av8
+
+.global _ih264_inter_pred_luma_horz_qpel_vert_hpel_av8
+_ih264_inter_pred_luma_horz_qpel_vert_hpel_av8 = ih264_inter_pred_luma_horz_qpel_vert_hpel_av8
+
+.global _ih264_inter_pred_luma_horz_qpel_vert_qpel_av8
+_ih264_inter_pred_luma_horz_qpel_vert_qpel_av8 = ih264_inter_pred_luma_horz_qpel_vert_qpel_av8
+
+.global _ih264_inter_pred_luma_vert_av8
+_ih264_inter_pred_luma_vert_av8 = ih264_inter_pred_luma_vert_av8
+
+.global _ih264_inter_pred_luma_vert_qpel_av8
+_ih264_inter_pred_luma_vert_qpel_av8 = ih264_inter_pred_luma_vert_qpel_av8
+
+.global _ih264_intra_pred_chroma_8x8_mode_horz_av8
+_ih264_intra_pred_chroma_8x8_mode_horz_av8 = ih264_intra_pred_chroma_8x8_mode_horz_av8
+
+.global _ih264_intra_pred_chroma_8x8_mode_plane_av8
+_ih264_intra_pred_chroma_8x8_mode_plane_av8 = ih264_intra_pred_chroma_8x8_mode_plane_av8
+
+.global _ih264_intra_pred_chroma_8x8_mode_vert_av8
+_ih264_intra_pred_chroma_8x8_mode_vert_av8 = ih264_intra_pred_chroma_8x8_mode_vert_av8
+
+.global _ih264_intra_pred_luma_16x16_mode_dc_av8
+_ih264_intra_pred_luma_16x16_mode_dc_av8 = ih264_intra_pred_luma_16x16_mode_dc_av8
+
+.global _ih264_intra_pred_luma_16x16_mode_horz_av8
+_ih264_intra_pred_luma_16x16_mode_horz_av8 = ih264_intra_pred_luma_16x16_mode_horz_av8
+
+.global _ih264_intra_pred_luma_16x16_mode_plane_av8
+_ih264_intra_pred_luma_16x16_mode_plane_av8 = ih264_intra_pred_luma_16x16_mode_plane_av8
+
+.global _ih264_intra_pred_luma_16x16_mode_vert_av8
+_ih264_intra_pred_luma_16x16_mode_vert_av8 = ih264_intra_pred_luma_16x16_mode_vert_av8
+
+.global _ih264_intra_pred_luma_4x4_mode_dc_av8
+_ih264_intra_pred_luma_4x4_mode_dc_av8 = ih264_intra_pred_luma_4x4_mode_dc_av8
+
+.global _ih264_intra_pred_luma_4x4_mode_diag_dl_av8
+_ih264_intra_pred_luma_4x4_mode_diag_dl_av8 = ih264_intra_pred_luma_4x4_mode_diag_dl_av8
+
+.global _ih264_intra_pred_luma_4x4_mode_diag_dr_av8
+_ih264_intra_pred_luma_4x4_mode_diag_dr_av8 = ih264_intra_pred_luma_4x4_mode_diag_dr_av8
+
+.global _ih264_intra_pred_luma_4x4_mode_horz_av8
+_ih264_intra_pred_luma_4x4_mode_horz_av8 = ih264_intra_pred_luma_4x4_mode_horz_av8
+
+.global _ih264_intra_pred_luma_4x4_mode_horz_d_av8
+_ih264_intra_pred_luma_4x4_mode_horz_d_av8 = ih264_intra_pred_luma_4x4_mode_horz_d_av8
+
+.global _ih264_intra_pred_luma_4x4_mode_horz_u_av8
+_ih264_intra_pred_luma_4x4_mode_horz_u_av8 = ih264_intra_pred_luma_4x4_mode_horz_u_av8
+
+.global _ih264_intra_pred_luma_4x4_mode_vert_av8
+_ih264_intra_pred_luma_4x4_mode_vert_av8 = ih264_intra_pred_luma_4x4_mode_vert_av8
+
+.global _ih264_intra_pred_luma_4x4_mode_vert_l_av8
+_ih264_intra_pred_luma_4x4_mode_vert_l_av8 = ih264_intra_pred_luma_4x4_mode_vert_l_av8
+
+.global _ih264_intra_pred_luma_4x4_mode_vert_r_av8
+_ih264_intra_pred_luma_4x4_mode_vert_r_av8 = ih264_intra_pred_luma_4x4_mode_vert_r_av8
+
+.global _ih264_intra_pred_luma_8x8_mode_dc_av8
+_ih264_intra_pred_luma_8x8_mode_dc_av8 = ih264_intra_pred_luma_8x8_mode_dc_av8
+
+.global _ih264_intra_pred_luma_8x8_mode_diag_dl_av8
+_ih264_intra_pred_luma_8x8_mode_diag_dl_av8 = ih264_intra_pred_luma_8x8_mode_diag_dl_av8
+
+.global _ih264_intra_pred_luma_8x8_mode_diag_dr_av8
+_ih264_intra_pred_luma_8x8_mode_diag_dr_av8 = ih264_intra_pred_luma_8x8_mode_diag_dr_av8
+
+.global _ih264_intra_pred_luma_8x8_mode_horz_av8
+_ih264_intra_pred_luma_8x8_mode_horz_av8 = ih264_intra_pred_luma_8x8_mode_horz_av8
+
+.global _ih264_intra_pred_luma_8x8_mode_horz_d_av8
+_ih264_intra_pred_luma_8x8_mode_horz_d_av8 = ih264_intra_pred_luma_8x8_mode_horz_d_av8
+
+.global _ih264_intra_pred_luma_8x8_mode_horz_u_av8
+_ih264_intra_pred_luma_8x8_mode_horz_u_av8 = ih264_intra_pred_luma_8x8_mode_horz_u_av8
+
+.global _ih264_intra_pred_luma_8x8_mode_vert_av8
+_ih264_intra_pred_luma_8x8_mode_vert_av8 = ih264_intra_pred_luma_8x8_mode_vert_av8
+
+.global _ih264_intra_pred_luma_8x8_mode_vert_l_av8
+_ih264_intra_pred_luma_8x8_mode_vert_l_av8 = ih264_intra_pred_luma_8x8_mode_vert_l_av8
+
+.global _ih264_intra_pred_luma_8x8_mode_vert_r_av8
+_ih264_intra_pred_luma_8x8_mode_vert_r_av8 = ih264_intra_pred_luma_8x8_mode_vert_r_av8
+
+.global _ih264_iquant_itrans_recon_4x4_av8
+_ih264_iquant_itrans_recon_4x4_av8 = ih264_iquant_itrans_recon_4x4_av8
+
+.global _ih264_iquant_itrans_recon_4x4_dc_av8
+_ih264_iquant_itrans_recon_4x4_dc_av8 = ih264_iquant_itrans_recon_4x4_dc_av8
+
+.global _ih264_iquant_itrans_recon_8x8_av8
+_ih264_iquant_itrans_recon_8x8_av8 = ih264_iquant_itrans_recon_8x8_av8
+
+.global _ih264_iquant_itrans_recon_8x8_dc_av8
+_ih264_iquant_itrans_recon_8x8_dc_av8 = ih264_iquant_itrans_recon_8x8_dc_av8
+
+.global _ih264_iquant_itrans_recon_chroma_4x4_av8
+_ih264_iquant_itrans_recon_chroma_4x4_av8 = ih264_iquant_itrans_recon_chroma_4x4_av8
+
+.global _ih264_iquant_itrans_recon_chroma_4x4_dc_av8
+_ih264_iquant_itrans_recon_chroma_4x4_dc_av8 = ih264_iquant_itrans_recon_chroma_4x4_dc_av8
+
+.global _ih264_pad_left_chroma_av8
+_ih264_pad_left_chroma_av8 = ih264_pad_left_chroma_av8
+
+.global _ih264_pad_left_luma_av8
+_ih264_pad_left_luma_av8 = ih264_pad_left_luma_av8
+
+.global _ih264_pad_right_chroma_av8
+_ih264_pad_right_chroma_av8 = ih264_pad_right_chroma_av8
+
+.global _ih264_pad_right_luma_av8
+_ih264_pad_right_luma_av8 = ih264_pad_right_luma_av8
+
+.global _ih264_pad_top_av8
+_ih264_pad_top_av8 = ih264_pad_top_av8
+
+.global _ih264_weighted_bi_pred_chroma_av8
+_ih264_weighted_bi_pred_chroma_av8 = ih264_weighted_bi_pred_chroma_av8
+
+.global _ih264_weighted_bi_pred_luma_av8
+_ih264_weighted_bi_pred_luma_av8 = ih264_weighted_bi_pred_luma_av8
+
+.global _ih264_weighted_pred_chroma_av8
+_ih264_weighted_pred_chroma_av8 = ih264_weighted_pred_chroma_av8
+
+.global _ih264_weighted_pred_luma_av8
+_ih264_weighted_pred_luma_av8 = ih264_weighted_pred_luma_av8
\ No newline at end of file
diff --git a/dependencies/ih264d/common/ithread.c b/dependencies/ih264d/common/ithread.c
index d710e323..2c25bdb0 100644
--- a/dependencies/ih264d/common/ithread.c
+++ b/dependencies/ih264d/common/ithread.c
@@ -85,28 +85,59 @@ UWORD32 ithread_get_mutex_lock_size(void)
 	return sizeof(CRITICAL_SECTION);
 }
 
+struct _ithread_launch_param
+{
+	void (*startFunc)(void* argument);
+	void* argument;
+};
+
+DWORD WINAPI _ithread_WinThreadStartRoutine(LPVOID lpThreadParameter)
+{
+	struct _ithread_launch_param* param = (struct _ithread_launch_param*)lpThreadParameter;
+	typedef void *(*ThreadStartRoutineType)(void *);
+	ThreadStartRoutineType pfnThreadRoutine = (ThreadStartRoutineType)param->startFunc;
+	void* arg = param->argument;
+	free(param);
+	pfnThreadRoutine(arg);
+	return 0;
+}
+
 WORD32 ithread_create(void* thread_handle, void* attribute, void* strt, void* argument)
 {
-	//UNUSED(attribute);
-	//return pthread_create((pthread_t*)thread_handle, NULL, (void* (*)(void*)) strt, argument);
-	__debugbreak();
+	UNUSED(attribute);
+	struct _ithread_launch_param* param = malloc(sizeof(struct _ithread_launch_param));
+	param->startFunc = (void (*)(void*))strt;
+	param->argument = argument;
+	HANDLE *handle = (HANDLE*)thread_handle;
+	*handle = CreateThread(NULL, 0, _ithread_WinThreadStartRoutine, param, 0, NULL);
+	if(*handle == NULL)
+	{
+		return -1;
+	}
 	return 0;
 }
 
 WORD32 ithread_join(void* thread_handle, void** val_ptr)
 {
 	//UNUSED(val_ptr);
-	//pthread_t* pthread_handle = (pthread_t*)thread_handle;
-	//return pthread_join(*pthread_handle, NULL);
-
-	__debugbreak();
-	return 0;
+	HANDLE *handle = (HANDLE*)thread_handle;
+	DWORD result = WaitForSingleObject(*handle, INFINITE);
+	if(result == WAIT_OBJECT_0)
+	{
+		CloseHandle(*handle);
+		return 0;
+	}
+	else
+	{
+		return -1;
+	}
 }
 
 WORD32 ithread_get_mutex_struct_size(void)
 {
 	return sizeof(CRITICAL_SECTION);
 }
+
 WORD32 ithread_mutex_init(void* mutex)
 {
 	InitializeCriticalSection((LPCRITICAL_SECTION)mutex);
@@ -153,7 +184,6 @@ UWORD32 ithread_get_sem_struct_size(void)
 	//return(sizeof(sem_t));
 }
 
-
 WORD32 ithread_sem_init(void* sem, WORD32 pshared, UWORD32 value)
 {
 	__debugbreak();
@@ -168,7 +198,6 @@ WORD32 ithread_sem_post(void* sem)
 	//return sem_post((sem_t*)sem);
 }
 
-
 WORD32 ithread_sem_wait(void* sem)
 {
 	__debugbreak();
@@ -176,7 +205,6 @@ WORD32 ithread_sem_wait(void* sem)
 	//return sem_wait((sem_t*)sem);
 }
 
-
 WORD32 ithread_sem_destroy(void* sem)
 {
 	__debugbreak();
diff --git a/dependencies/ih264d/common/x86/ih264_chroma_intra_pred_filters_ssse3.c b/dependencies/ih264d/common/x86/ih264_chroma_intra_pred_filters_ssse3.c
index d43ce207..502420b1 100644
--- a/dependencies/ih264d/common/x86/ih264_chroma_intra_pred_filters_ssse3.c
+++ b/dependencies/ih264d/common/x86/ih264_chroma_intra_pred_filters_ssse3.c
@@ -56,6 +56,11 @@
 #include "ih264_platform_macros.h"
 #include "ih264_intra_pred_filters.h"
 
+#ifdef __GNUC__
+#define ATTRIBUTE_SSSE3 __attribute__((target("ssse3")))
+#else
+#define ATTRIBUTE_SSSE3
+#endif
 
 /*****************************************************************************/
 /* Chroma Intra prediction 8x8 filters                                       */
@@ -93,6 +98,8 @@
 *
 ******************************************************************************
 */
+
+ATTRIBUTE_SSSE3
 void ih264_intra_pred_chroma_8x8_mode_horz_ssse3(UWORD8 *pu1_src,
                                                  UWORD8 *pu1_dst,
                                                  WORD32 src_strd,
@@ -169,6 +176,8 @@ void ih264_intra_pred_chroma_8x8_mode_horz_ssse3(UWORD8 *pu1_src,
 *
 *******************************************************************************
 */
+
+ATTRIBUTE_SSSE3
 void ih264_intra_pred_chroma_8x8_mode_vert_ssse3(UWORD8 *pu1_src,
                                                  UWORD8 *pu1_dst,
                                                  WORD32 src_strd,
@@ -237,6 +246,8 @@ void ih264_intra_pred_chroma_8x8_mode_vert_ssse3(UWORD8 *pu1_src,
 *
 ******************************************************************************
 */
+
+ATTRIBUTE_SSSE3
 void ih264_intra_pred_chroma_8x8_mode_plane_ssse3(UWORD8 *pu1_src,
                                                   UWORD8 *pu1_dst,
                                                   WORD32 src_strd,
diff --git a/dependencies/ih264d/common/x86/ih264_deblk_chroma_ssse3.c b/dependencies/ih264d/common/x86/ih264_deblk_chroma_ssse3.c
index a36447a2..d73d9d35 100644
--- a/dependencies/ih264d/common/x86/ih264_deblk_chroma_ssse3.c
+++ b/dependencies/ih264d/common/x86/ih264_deblk_chroma_ssse3.c
@@ -53,6 +53,12 @@
 #include "ih264_deblk_edge_filters.h"
 #include "ih264_macros.h"
 
+#ifdef __GNUC__
+#define ATTRIBUTE_SSSE3 __attribute__((target("ssse3")))
+#else
+#define ATTRIBUTE_SSSE3
+#endif
+
 /*****************************************************************************/
 /* Function Definitions                                                      */
 /*****************************************************************************/
@@ -91,6 +97,8 @@
 /*         12 02 2015   Naveen Kumar P  Initial version                      */
 /*                                                                           */
 /*****************************************************************************/
+
+ATTRIBUTE_SSSE3
 void ih264_deblk_chroma_vert_bs4_ssse3(UWORD8 *pu1_src,
                                        WORD32 src_strd,
                                        WORD32 alpha_cb,
@@ -274,6 +282,8 @@ void ih264_deblk_chroma_vert_bs4_ssse3(UWORD8 *pu1_src,
 /*         12 02 2015   Naveen Kumar P  Initial version                      */
 /*                                                                           */
 /*****************************************************************************/
+
+ATTRIBUTE_SSSE3
 void ih264_deblk_chroma_horz_bs4_ssse3(UWORD8 *pu1_src,
                                        WORD32 src_strd,
                                        WORD32 alpha_cb,
@@ -424,6 +434,8 @@ void ih264_deblk_chroma_horz_bs4_ssse3(UWORD8 *pu1_src,
 /*         12 02 2015   Naveen Kumar P  Initial version                      */
 /*                                                                           */
 /*****************************************************************************/
+
+ATTRIBUTE_SSSE3
 void ih264_deblk_chroma_vert_bslt4_ssse3(UWORD8 *pu1_src,
                                          WORD32 src_strd,
                                          WORD32 alpha_cb,
@@ -645,6 +657,8 @@ void ih264_deblk_chroma_vert_bslt4_ssse3(UWORD8 *pu1_src,
 /*         12 02 2015   Naveen Kumar P  Initial version                      */
 /*                                                                           */
 /*****************************************************************************/
+
+ATTRIBUTE_SSSE3
 void ih264_deblk_chroma_horz_bslt4_ssse3(UWORD8 *pu1_src,
                                          WORD32 src_strd,
                                          WORD32 alpha_cb,
@@ -829,6 +843,8 @@ void ih264_deblk_chroma_horz_bslt4_ssse3(UWORD8 *pu1_src,
 /*         12 02 2015   Naveen Kumar P  Initial version                      */
 /*                                                                           */
 /*****************************************************************************/
+
+ATTRIBUTE_SSSE3
 void ih264_deblk_chroma_vert_bs4_mbaff_ssse3(UWORD8 *pu1_src,
                                              WORD32 src_strd,
                                              WORD32 alpha_cb,
@@ -963,6 +979,8 @@ void ih264_deblk_chroma_vert_bs4_mbaff_ssse3(UWORD8 *pu1_src,
 /*         12 02 2015   Naveen Kumar P  Initial version                      */
 /*                                                                           */
 /*****************************************************************************/
+
+ATTRIBUTE_SSSE3
 void ih264_deblk_chroma_vert_bslt4_mbaff_ssse3(UWORD8 *pu1_src,
                                                WORD32 src_strd,
                                                WORD32 alpha_cb,
diff --git a/dependencies/ih264d/common/x86/ih264_deblk_luma_ssse3.c b/dependencies/ih264d/common/x86/ih264_deblk_luma_ssse3.c
index e29bebbe..c135f6b6 100644
--- a/dependencies/ih264d/common/x86/ih264_deblk_luma_ssse3.c
+++ b/dependencies/ih264d/common/x86/ih264_deblk_luma_ssse3.c
@@ -53,6 +53,12 @@
 #include "ih264_deblk_edge_filters.h"
 #include "ih264_macros.h"
 
+#ifdef __GNUC__
+#define ATTRIBUTE_SSSE3 __attribute__((target("ssse3")))
+#else
+#define ATTRIBUTE_SSSE3
+#endif
+
 /*****************************************************************************/
 /* Function Definitions                                                      */
 /*****************************************************************************/
@@ -87,6 +93,7 @@
 /*         12 02 2015   Naveen Kumar P  Initial version                      */
 /*                                                                           */
 /*****************************************************************************/
+ATTRIBUTE_SSSE3
 void ih264_deblk_luma_vert_bs4_ssse3(UWORD8 *pu1_src,
                                      WORD32 src_strd,
                                      WORD32 alpha,
@@ -508,6 +515,7 @@ void ih264_deblk_luma_vert_bs4_ssse3(UWORD8 *pu1_src,
 /*         12 02 2015   Naveen Kumar P  Initial version                      */
 /*                                                                           */
 /*****************************************************************************/
+ATTRIBUTE_SSSE3
 void ih264_deblk_luma_horz_bs4_ssse3(UWORD8 *pu1_src,
                                      WORD32 src_strd,
                                      WORD32 alpha,
@@ -847,6 +855,7 @@ void ih264_deblk_luma_horz_bs4_ssse3(UWORD8 *pu1_src,
 /*         12 02 2015   Naveen Kumar P  Initial version                      */
 /*                                                                           */
 /*****************************************************************************/
+ATTRIBUTE_SSSE3
 void ih264_deblk_luma_vert_bslt4_ssse3(UWORD8 *pu1_src,
                                        WORD32 src_strd,
                                        WORD32 alpha,
@@ -1142,6 +1151,7 @@ void ih264_deblk_luma_vert_bslt4_ssse3(UWORD8 *pu1_src,
 /*         12 02 2015   Naveen Kumar P  Initial version                      */
 /*                                                                           */
 /*****************************************************************************/
+ATTRIBUTE_SSSE3
 void ih264_deblk_luma_horz_bslt4_ssse3(UWORD8 *pu1_src,
                                        WORD32 src_strd,
                                        WORD32 alpha,
@@ -1439,6 +1449,7 @@ void ih264_deblk_luma_horz_bslt4_ssse3(UWORD8 *pu1_src,
 /*         12 02 2015   Naveen Kumar P  Initial version                      */
 /*                                                                           */
 /*****************************************************************************/
+ATTRIBUTE_SSSE3
 void ih264_deblk_luma_vert_bs4_mbaff_ssse3(UWORD8 *pu1_src,
                                            WORD32 src_strd,
                                            WORD32 alpha,
@@ -1758,6 +1769,7 @@ void ih264_deblk_luma_vert_bs4_mbaff_ssse3(UWORD8 *pu1_src,
 /*         12 02 2015   Naveen Kumar P  Initial version                      */
 /*                                                                           */
 /*****************************************************************************/
+ATTRIBUTE_SSSE3
 void ih264_deblk_luma_vert_bslt4_mbaff_ssse3(UWORD8 *pu1_src,
                                              WORD32 src_strd,
                                              WORD32 alpha,
diff --git a/dependencies/ih264d/common/x86/ih264_ihadamard_scaling_sse42.c b/dependencies/ih264d/common/x86/ih264_ihadamard_scaling_sse42.c
index 3c4bb1c6..bf8e88ed 100644
--- a/dependencies/ih264d/common/x86/ih264_ihadamard_scaling_sse42.c
+++ b/dependencies/ih264d/common/x86/ih264_ihadamard_scaling_sse42.c
@@ -52,6 +52,12 @@
 #include <immintrin.h>
 #include <smmintrin.h>
 
+#ifdef __GNUC__
+#define ATTRIBUTE_SSE42 __attribute__((target("sse4.2")))
+#else
+#define ATTRIBUTE_SSE42
+#endif
+
 /*
  ********************************************************************************
  *
@@ -87,6 +93,7 @@
  *
  *******************************************************************************
  */
+ATTRIBUTE_SSE42
 void ih264_ihadamard_scaling_4x4_sse42(WORD16* pi2_src,
                                        WORD16* pi2_out,
                                        const UWORD16 *pu2_iscal_mat,
@@ -202,6 +209,7 @@ void ih264_ihadamard_scaling_4x4_sse42(WORD16* pi2_src,
     _mm_storeu_si128((__m128i *) (&pi2_out[8]), src_r2_r3);
 }
 
+ATTRIBUTE_SSE42
 void ih264_ihadamard_scaling_2x2_uv_sse42(WORD16* pi2_src,
                                           WORD16* pi2_out,
                                           const UWORD16 *pu2_iscal_mat,
diff --git a/dependencies/ih264d/common/x86/ih264_ihadamard_scaling_ssse3.c b/dependencies/ih264d/common/x86/ih264_ihadamard_scaling_ssse3.c
index b4d483f1..4dc6d827 100644
--- a/dependencies/ih264d/common/x86/ih264_ihadamard_scaling_ssse3.c
+++ b/dependencies/ih264d/common/x86/ih264_ihadamard_scaling_ssse3.c
@@ -50,6 +50,12 @@
 #include "ih264_trans_quant_itrans_iquant.h"
 #include <immintrin.h>
 
+#ifdef __GNUC__
+#define ATTRIBUTE_SSSE3 __attribute__((target("ssse3")))
+#else
+#define ATTRIBUTE_SSSE3
+#endif
+
 /*
  ********************************************************************************
  *
@@ -85,6 +91,7 @@
  *
  *******************************************************************************
  */
+ATTRIBUTE_SSSE3
 void ih264_ihadamard_scaling_4x4_ssse3(WORD16* pi2_src,
                                        WORD16* pi2_out,
                                        const UWORD16 *pu2_iscal_mat,
diff --git a/dependencies/ih264d/common/x86/ih264_inter_pred_filters_ssse3.c b/dependencies/ih264d/common/x86/ih264_inter_pred_filters_ssse3.c
index 480a8c7c..7927eeb6 100644
--- a/dependencies/ih264d/common/x86/ih264_inter_pred_filters_ssse3.c
+++ b/dependencies/ih264d/common/x86/ih264_inter_pred_filters_ssse3.c
@@ -54,6 +54,12 @@
 #include "ih264_platform_macros.h"
 #include "ih264_inter_pred_filters.h"
 
+#ifdef __GNUC__
+#define ATTRIBUTE_SSSE3 __attribute__((target("ssse3")))
+#else
+#define ATTRIBUTE_SSSE3
+#endif
+
 /*****************************************************************************/
 /* Constant Data variables                                                   */
 /*****************************************************************************/
@@ -87,6 +93,7 @@
 /*                      Senthoor                                             */
 /*                                                                           */
 /*****************************************************************************/
+ATTRIBUTE_SSSE3
 void ih264_inter_pred_luma_copy_ssse3(UWORD8 *pu1_src,
                                       UWORD8 *pu1_dst,
                                       WORD32 src_strd,
@@ -213,6 +220,7 @@ void ih264_inter_pred_luma_copy_ssse3(UWORD8 *pu1_src,
 /*                      Senthoor                                             */
 /*                                                                           */
 /*****************************************************************************/
+ATTRIBUTE_SSSE3
 void ih264_inter_pred_luma_horz_ssse3(UWORD8 *pu1_src,
                                       UWORD8 *pu1_dst,
                                       WORD32 src_strd,
@@ -478,6 +486,7 @@ void ih264_inter_pred_luma_horz_ssse3(UWORD8 *pu1_src,
 /*                      Senthoor                                             */
 /*                                                                           */
 /*****************************************************************************/
+ATTRIBUTE_SSSE3
 void ih264_inter_pred_luma_vert_ssse3(UWORD8 *pu1_src,
                                       UWORD8 *pu1_dst,
                                       WORD32 src_strd,
@@ -764,6 +773,7 @@ void ih264_inter_pred_luma_vert_ssse3(UWORD8 *pu1_src,
 /*                      Senthoor                                             */
 /*                                                                           */
 /*****************************************************************************/
+ATTRIBUTE_SSSE3
 void ih264_inter_pred_luma_horz_hpel_vert_hpel_ssse3(UWORD8 *pu1_src,
                                                      UWORD8 *pu1_dst,
                                                      WORD32 src_strd,
@@ -1488,6 +1498,7 @@ void ih264_inter_pred_luma_horz_hpel_vert_hpel_ssse3(UWORD8 *pu1_src,
 /*                      Senthoor                                             */
 /*                                                                           */
 /*****************************************************************************/
+ATTRIBUTE_SSSE3
 void ih264_inter_pred_luma_horz_qpel_ssse3(UWORD8 *pu1_src,
                                            UWORD8 *pu1_dst,
                                            WORD32 src_strd,
@@ -1782,6 +1793,7 @@ void ih264_inter_pred_luma_horz_qpel_ssse3(UWORD8 *pu1_src,
 /*                      Senthoor                                             */
 /*                                                                           */
 /*****************************************************************************/
+ATTRIBUTE_SSSE3
 void ih264_inter_pred_luma_vert_qpel_ssse3(UWORD8 *pu1_src,
                                            UWORD8 *pu1_dst,
                                            WORD32 src_strd,
@@ -2107,6 +2119,7 @@ void ih264_inter_pred_luma_vert_qpel_ssse3(UWORD8 *pu1_src,
 /*                      Senthoor                                             */
 /*                                                                           */
 /*****************************************************************************/
+ATTRIBUTE_SSSE3
 void ih264_inter_pred_luma_horz_qpel_vert_qpel_ssse3(UWORD8 *pu1_src,
                                                      UWORD8 *pu1_dst,
                                                      WORD32 src_strd,
@@ -2675,6 +2688,7 @@ void ih264_inter_pred_luma_horz_qpel_vert_qpel_ssse3(UWORD8 *pu1_src,
 /*                      Senthoor                                             */
 /*                                                                           */
 /*****************************************************************************/
+ATTRIBUTE_SSSE3
 void ih264_inter_pred_luma_horz_qpel_vert_hpel_ssse3(UWORD8 *pu1_src,
                                                      UWORD8 *pu1_dst,
                                                      WORD32 src_strd,
@@ -3285,6 +3299,7 @@ void ih264_inter_pred_luma_horz_qpel_vert_hpel_ssse3(UWORD8 *pu1_src,
 /*                      Senthoor                                             */
 /*                                                                           */
 /*****************************************************************************/
+ATTRIBUTE_SSSE3
 void ih264_inter_pred_luma_horz_hpel_vert_qpel_ssse3(UWORD8 *pu1_src,
                                                      UWORD8 *pu1_dst,
                                                      WORD32 src_strd,
@@ -3991,6 +4006,7 @@ void ih264_inter_pred_luma_horz_hpel_vert_qpel_ssse3(UWORD8 *pu1_src,
 /*                      Senthoor                                             */
 /*                                                                           */
 /*****************************************************************************/
+ATTRIBUTE_SSSE3
 void ih264_inter_pred_chroma_ssse3(UWORD8 *pu1_src,
                                    UWORD8 *pu1_dst,
                                    WORD32 src_strd,
diff --git a/dependencies/ih264d/common/x86/ih264_iquant_itrans_recon_dc_ssse3.c b/dependencies/ih264d/common/x86/ih264_iquant_itrans_recon_dc_ssse3.c
index bcfe503f..10dd2647 100644
--- a/dependencies/ih264d/common/x86/ih264_iquant_itrans_recon_dc_ssse3.c
+++ b/dependencies/ih264d/common/x86/ih264_iquant_itrans_recon_dc_ssse3.c
@@ -50,6 +50,12 @@
 #include "ih264_trans_quant_itrans_iquant.h"
 #include <immintrin.h>
 
+#ifdef __GNUC__
+#define ATTRIBUTE_SSSE3 __attribute__((target("ssse3")))
+#else
+#define ATTRIBUTE_SSSE3
+#endif
+
 /*
  ********************************************************************************
  *
@@ -98,6 +104,7 @@
  *
  *******************************************************************************
  */
+ATTRIBUTE_SSSE3
 void ih264_iquant_itrans_recon_4x4_dc_ssse3(WORD16 *pi2_src,
                                    UWORD8 *pu1_pred,
                                    UWORD8 *pu1_out,
@@ -224,6 +231,7 @@ void ih264_iquant_itrans_recon_4x4_dc_ssse3(WORD16 *pi2_src,
  *******************************************************************************
  */
 
+ATTRIBUTE_SSSE3
 void ih264_iquant_itrans_recon_8x8_dc_ssse3 (WORD16 *pi2_src,
                                          UWORD8 *pu1_pred,
                                          UWORD8 *pu1_out,
@@ -385,6 +393,7 @@ void ih264_iquant_itrans_recon_8x8_dc_ssse3 (WORD16 *pi2_src,
  *
  *******************************************************************************
  */
+ATTRIBUTE_SSSE3
 void ih264_iquant_itrans_recon_chroma_4x4_dc_ssse3(WORD16 *pi2_src,
                                    UWORD8 *pu1_pred,
                                    UWORD8 *pu1_out,
diff --git a/dependencies/ih264d/common/x86/ih264_iquant_itrans_recon_sse42.c b/dependencies/ih264d/common/x86/ih264_iquant_itrans_recon_sse42.c
index a7b9e824..e97ca4d0 100644
--- a/dependencies/ih264d/common/x86/ih264_iquant_itrans_recon_sse42.c
+++ b/dependencies/ih264d/common/x86/ih264_iquant_itrans_recon_sse42.c
@@ -50,6 +50,12 @@
 #include "ih264_trans_quant_itrans_iquant.h"
 #include <immintrin.h>
 
+#ifdef __GNUC__
+#define ATTRIBUTE_SSE42 __attribute__((target("sse4.2")))
+#else
+#define ATTRIBUTE_SSE42
+#endif
+
 /*
  ********************************************************************************
  *
@@ -97,6 +103,7 @@
  *
  *******************************************************************************
  */
+ATTRIBUTE_SSE42
 void ih264_iquant_itrans_recon_4x4_sse42(WORD16 *pi2_src,
                                    UWORD8 *pu1_pred,
                                    UWORD8 *pu1_out,
@@ -348,6 +355,7 @@ void ih264_iquant_itrans_recon_4x4_sse42(WORD16 *pi2_src,
  *
  *******************************************************************************
  */
+ATTRIBUTE_SSE42
 void ih264_iquant_itrans_recon_chroma_4x4_sse42(WORD16 *pi2_src,
                                    UWORD8 *pu1_pred,
                                    UWORD8 *pu1_out,
diff --git a/dependencies/ih264d/common/x86/ih264_iquant_itrans_recon_ssse3.c b/dependencies/ih264d/common/x86/ih264_iquant_itrans_recon_ssse3.c
index 506be495..96773253 100644
--- a/dependencies/ih264d/common/x86/ih264_iquant_itrans_recon_ssse3.c
+++ b/dependencies/ih264d/common/x86/ih264_iquant_itrans_recon_ssse3.c
@@ -50,6 +50,12 @@
 #include "ih264_trans_quant_itrans_iquant.h"
 #include <immintrin.h>
 
+#ifdef __GNUC__
+#define ATTRIBUTE_SSSE3 __attribute__((target("ssse3")))
+#else
+#define ATTRIBUTE_SSSE3
+#endif
+
 /*
  ********************************************************************************
  *
@@ -97,6 +103,7 @@
  *
  *******************************************************************************
  */
+ATTRIBUTE_SSSE3
 void ih264_iquant_itrans_recon_4x4_ssse3(WORD16 *pi2_src,
                                          UWORD8 *pu1_pred,
                                          UWORD8 *pu1_out,
@@ -366,6 +373,7 @@ void ih264_iquant_itrans_recon_4x4_ssse3(WORD16 *pi2_src,
  *******************************************************************************
  */
 
+ATTRIBUTE_SSSE3
 void ih264_iquant_itrans_recon_8x8_ssse3(WORD16 *pi2_src,
                                          UWORD8 *pu1_pred,
                                          UWORD8 *pu1_out,
diff --git a/dependencies/ih264d/common/x86/ih264_luma_intra_pred_filters_ssse3.c b/dependencies/ih264d/common/x86/ih264_luma_intra_pred_filters_ssse3.c
index a1721d52..417e986b 100644
--- a/dependencies/ih264d/common/x86/ih264_luma_intra_pred_filters_ssse3.c
+++ b/dependencies/ih264d/common/x86/ih264_luma_intra_pred_filters_ssse3.c
@@ -75,6 +75,12 @@
 #include "ih264_platform_macros.h"
 #include "ih264_intra_pred_filters.h"
 
+#ifdef __GNUC__
+#define ATTRIBUTE_SSSE3 __attribute__((target("ssse3")))
+#else
+#define ATTRIBUTE_SSSE3
+#endif
+
 
 
 /*******************    LUMA INTRAPREDICTION    *******************/
@@ -114,6 +120,7 @@
  *
  *******************************************************************************
  */
+ATTRIBUTE_SSSE3
 void ih264_intra_pred_luma_4x4_mode_vert_ssse3(UWORD8 *pu1_src,
                                                UWORD8 *pu1_dst,
                                                WORD32 src_strd,
@@ -173,6 +180,7 @@ void ih264_intra_pred_luma_4x4_mode_vert_ssse3(UWORD8 *pu1_src,
  *
  *******************************************************************************
  */
+ATTRIBUTE_SSSE3
 void ih264_intra_pred_luma_4x4_mode_horz_ssse3(UWORD8 *pu1_src,
                                                UWORD8 *pu1_dst,
                                                WORD32 src_strd,
@@ -238,6 +246,7 @@ void ih264_intra_pred_luma_4x4_mode_horz_ssse3(UWORD8 *pu1_src,
  *  None
  *
  *******************************************************************************/
+ATTRIBUTE_SSSE3
 void ih264_intra_pred_luma_4x4_mode_dc_ssse3(UWORD8 *pu1_src,
                                              UWORD8 *pu1_dst,
                                              WORD32 src_strd,
@@ -316,6 +325,7 @@ void ih264_intra_pred_luma_4x4_mode_dc_ssse3(UWORD8 *pu1_src,
  *  None
  *
  *******************************************************************************/
+ATTRIBUTE_SSSE3
 void ih264_intra_pred_luma_4x4_mode_diag_dl_ssse3(UWORD8 *pu1_src,
                                                   UWORD8 *pu1_dst,
                                                   WORD32 src_strd,
@@ -400,6 +410,7 @@ void ih264_intra_pred_luma_4x4_mode_diag_dl_ssse3(UWORD8 *pu1_src,
  *  None
  *
  *******************************************************************************/
+ATTRIBUTE_SSSE3
 void ih264_intra_pred_luma_4x4_mode_diag_dr_ssse3(UWORD8 *pu1_src,
                                                   UWORD8 *pu1_dst,
                                                   WORD32 src_strd,
@@ -487,6 +498,7 @@ void ih264_intra_pred_luma_4x4_mode_diag_dr_ssse3(UWORD8 *pu1_src,
  *  None
  *
  *******************************************************************************/
+ATTRIBUTE_SSSE3
 void ih264_intra_pred_luma_4x4_mode_vert_r_ssse3(UWORD8 *pu1_src,
                                                  UWORD8 *pu1_dst,
                                                  WORD32 src_strd,
@@ -579,6 +591,7 @@ void ih264_intra_pred_luma_4x4_mode_vert_r_ssse3(UWORD8 *pu1_src,
  *  None
  *
  *******************************************************************************/
+ATTRIBUTE_SSSE3
 void ih264_intra_pred_luma_4x4_mode_horz_d_ssse3(UWORD8 *pu1_src,
                                            UWORD8 *pu1_dst,
                                            WORD32 src_strd,
@@ -675,6 +688,7 @@ void ih264_intra_pred_luma_4x4_mode_horz_d_ssse3(UWORD8 *pu1_src,
  *  None
  *
  *******************************************************************************/
+ATTRIBUTE_SSSE3
 void ih264_intra_pred_luma_4x4_mode_vert_l_ssse3(UWORD8 *pu1_src,
                                                  UWORD8 *pu1_dst,
                                                  WORD32 src_strd,
@@ -764,6 +778,7 @@ void ih264_intra_pred_luma_4x4_mode_vert_l_ssse3(UWORD8 *pu1_src,
  *  None
  *
  *******************************************************************************/
+ATTRIBUTE_SSSE3
 void ih264_intra_pred_luma_4x4_mode_horz_u_ssse3(UWORD8 *pu1_src,
                                                  UWORD8 *pu1_dst,
                                                  WORD32 src_strd,
@@ -864,6 +879,7 @@ void ih264_intra_pred_luma_4x4_mode_horz_u_ssse3(UWORD8 *pu1_src,
  *
  *******************************************************************************
  */
+ATTRIBUTE_SSSE3
 void ih264_intra_pred_luma_8x8_mode_vert_ssse3(UWORD8 *pu1_src,
                                                UWORD8 *pu1_dst,
                                                WORD32 src_strd,
@@ -921,6 +937,7 @@ void ih264_intra_pred_luma_8x8_mode_vert_ssse3(UWORD8 *pu1_src,
  *
  *******************************************************************************
  */
+ATTRIBUTE_SSSE3
 void ih264_intra_pred_luma_8x8_mode_horz_ssse3(UWORD8 *pu1_src,
                                                UWORD8 *pu1_dst,
                                                WORD32 src_strd,
@@ -985,6 +1002,7 @@ void ih264_intra_pred_luma_8x8_mode_horz_ssse3(UWORD8 *pu1_src,
  *  None
  *
  *******************************************************************************/
+ATTRIBUTE_SSSE3
 void ih264_intra_pred_luma_8x8_mode_dc_ssse3(UWORD8 *pu1_src,
                                              UWORD8 *pu1_dst,
                                              WORD32 src_strd,
@@ -1078,6 +1096,7 @@ void ih264_intra_pred_luma_8x8_mode_dc_ssse3(UWORD8 *pu1_src,
  *  None
  *
  *******************************************************************************/
+ATTRIBUTE_SSSE3
 void ih264_intra_pred_luma_8x8_mode_diag_dl_ssse3(UWORD8 *pu1_src,
                                                   UWORD8 *pu1_dst,
                                                   WORD32 src_strd,
@@ -1176,6 +1195,7 @@ void ih264_intra_pred_luma_8x8_mode_diag_dl_ssse3(UWORD8 *pu1_src,
  *  None
  *
  *******************************************************************************/
+ATTRIBUTE_SSSE3
 void ih264_intra_pred_luma_8x8_mode_diag_dr_ssse3(UWORD8 *pu1_src,
                                                   UWORD8 *pu1_dst,
                                                   WORD32 src_strd,
@@ -1278,6 +1298,7 @@ void ih264_intra_pred_luma_8x8_mode_diag_dr_ssse3(UWORD8 *pu1_src,
  *  None
  *
  *******************************************************************************/
+ATTRIBUTE_SSSE3
 void ih264_intra_pred_luma_8x8_mode_vert_r_ssse3(UWORD8 *pu1_src,
                                                  UWORD8 *pu1_dst,
                                                  WORD32 src_strd,
@@ -1398,6 +1419,7 @@ void ih264_intra_pred_luma_8x8_mode_vert_r_ssse3(UWORD8 *pu1_src,
  *  None
  *
  *******************************************************************************/
+ATTRIBUTE_SSSE3
 void ih264_intra_pred_luma_8x8_mode_horz_d_ssse3(UWORD8 *pu1_src,
                                                  UWORD8 *pu1_dst,
                                                  WORD32 src_strd,
@@ -1502,6 +1524,7 @@ void ih264_intra_pred_luma_8x8_mode_horz_d_ssse3(UWORD8 *pu1_src,
  *
  *******************************************************************************/
 
+ATTRIBUTE_SSSE3
 void ih264_intra_pred_luma_8x8_mode_vert_l_ssse3(UWORD8 *pu1_src,
                                                  UWORD8 *pu1_dst,
                                                  WORD32 src_strd,
@@ -1598,6 +1621,7 @@ void ih264_intra_pred_luma_8x8_mode_vert_l_ssse3(UWORD8 *pu1_src,
  *  None
  *
  *******************************************************************************/
+ATTRIBUTE_SSSE3
 void ih264_intra_pred_luma_8x8_mode_horz_u_ssse3(UWORD8 *pu1_src,
                                                  UWORD8 *pu1_dst,
                                                  WORD32 src_strd,
@@ -1699,6 +1723,7 @@ void ih264_intra_pred_luma_8x8_mode_horz_u_ssse3(UWORD8 *pu1_src,
  *  None
  *
  *******************************************************************************/
+ATTRIBUTE_SSSE3
 void ih264_intra_pred_luma_16x16_mode_vert_ssse3(UWORD8 *pu1_src,
                                                  UWORD8 *pu1_dst,
                                                  WORD32 src_strd,
@@ -1778,6 +1803,7 @@ void ih264_intra_pred_luma_16x16_mode_vert_ssse3(UWORD8 *pu1_src,
  *  None
  *
  *******************************************************************************/
+ATTRIBUTE_SSSE3
 void ih264_intra_pred_luma_16x16_mode_horz_ssse3(UWORD8 *pu1_src,
                                                  UWORD8 *pu1_dst,
                                                  WORD32 src_strd,
@@ -1875,6 +1901,7 @@ void ih264_intra_pred_luma_16x16_mode_horz_ssse3(UWORD8 *pu1_src,
  *  None
  *
  *******************************************************************************/
+ATTRIBUTE_SSSE3
 void ih264_intra_pred_luma_16x16_mode_dc_ssse3(UWORD8 *pu1_src,
                                                UWORD8 *pu1_dst,
                                                WORD32 src_strd,
@@ -1998,6 +2025,7 @@ void ih264_intra_pred_luma_16x16_mode_dc_ssse3(UWORD8 *pu1_src,
  *  None
  *
  *******************************************************************************/
+ATTRIBUTE_SSSE3
 void ih264_intra_pred_luma_16x16_mode_plane_ssse3(UWORD8 *pu1_src,
                                                   UWORD8 *pu1_dst,
                                                   WORD32 src_strd,
diff --git a/dependencies/ih264d/common/x86/ih264_mem_fns_ssse3.c b/dependencies/ih264d/common/x86/ih264_mem_fns_ssse3.c
index 8ca1f3e5..be3d622c 100644
--- a/dependencies/ih264d/common/x86/ih264_mem_fns_ssse3.c
+++ b/dependencies/ih264d/common/x86/ih264_mem_fns_ssse3.c
@@ -50,6 +50,12 @@
 
 #include <immintrin.h>
 
+#ifdef __GNUC__
+#define ATTRIBUTE_SSSE3 __attribute__((target("ssse3")))
+#else
+#define ATTRIBUTE_SSSE3
+#endif
+
 /**
  *******************************************************************************
  *
@@ -78,6 +84,7 @@
 
 
 
+ATTRIBUTE_SSSE3
 void ih264_memcpy_mul_8_ssse3(UWORD8 *pu1_dst, UWORD8 *pu1_src, UWORD32 num_bytes)
 {
     int col;
@@ -117,6 +124,7 @@ void ih264_memcpy_mul_8_ssse3(UWORD8 *pu1_dst, UWORD8 *pu1_src, UWORD32 num_byte
  */
 
 
+ATTRIBUTE_SSSE3
 void ih264_memset_mul_8_ssse3(UWORD8 *pu1_dst, UWORD8 value, UWORD32 num_bytes)
 {
     int col;
diff --git a/dependencies/ih264d/common/x86/ih264_padding_ssse3.c b/dependencies/ih264d/common/x86/ih264_padding_ssse3.c
index 43ded8e7..d2aa368a 100644
--- a/dependencies/ih264d/common/x86/ih264_padding_ssse3.c
+++ b/dependencies/ih264d/common/x86/ih264_padding_ssse3.c
@@ -49,6 +49,12 @@
 
 #include <immintrin.h>
 
+#ifdef __GNUC__
+#define ATTRIBUTE_SSSE3 __attribute__((target("ssse3")))
+#else
+#define ATTRIBUTE_SSSE3
+#endif
+
 
 /**
 *******************************************************************************
@@ -89,6 +95,7 @@
 *******************************************************************************
 */
 
+ATTRIBUTE_SSSE3
 void ih264_pad_left_luma_ssse3(UWORD8 *pu1_src,
                                WORD32 src_strd,
                                WORD32 ht,
@@ -156,6 +163,7 @@ void ih264_pad_left_luma_ssse3(UWORD8 *pu1_src,
 *******************************************************************************
 */
 
+ATTRIBUTE_SSSE3
 void ih264_pad_left_chroma_ssse3(UWORD8 *pu1_src,
                                  WORD32 src_strd,
                                  WORD32 ht,
@@ -222,6 +230,7 @@ void ih264_pad_left_chroma_ssse3(UWORD8 *pu1_src,
 *******************************************************************************
 */
 
+ATTRIBUTE_SSSE3
 void ih264_pad_right_luma_ssse3(UWORD8 *pu1_src,
                                 WORD32 src_strd,
                                 WORD32 ht,
@@ -289,6 +298,7 @@ void ih264_pad_right_luma_ssse3(UWORD8 *pu1_src,
 *******************************************************************************
 */
 
+ATTRIBUTE_SSSE3
 void ih264_pad_right_chroma_ssse3(UWORD8 *pu1_src,
                                   WORD32 src_strd,
                                   WORD32 ht,
diff --git a/dependencies/ih264d/common/x86/ih264_platform_macros.h b/dependencies/ih264d/common/x86/ih264_platform_macros.h
index ebc1b106..22de33d6 100644
--- a/dependencies/ih264d/common/x86/ih264_platform_macros.h
+++ b/dependencies/ih264d/common/x86/ih264_platform_macros.h
@@ -79,10 +79,8 @@
 static inline int __builtin_clz(unsigned x)
 {
 	unsigned long n;
-	if (x == 0)
-		return 32;
 	_BitScanReverse(&n, x);
-	return 31 - n;
+	return n ^ 31;
 }
 
 static inline int __builtin_ctz(unsigned x) {
diff --git a/dependencies/ih264d/common/x86/ih264_resi_trans_quant_sse42.c b/dependencies/ih264d/common/x86/ih264_resi_trans_quant_sse42.c
index f4f5cbfa..fa3442f0 100644
--- a/dependencies/ih264d/common/x86/ih264_resi_trans_quant_sse42.c
+++ b/dependencies/ih264d/common/x86/ih264_resi_trans_quant_sse42.c
@@ -51,6 +51,12 @@
 #include "ih264_structs.h"
 #include "ih264_trans_quant_itrans_iquant.h"
 #include <immintrin.h>
+
+#ifdef __GNUC__
+#define ATTRIBUTE_SSE42 __attribute__((target("sse4.2")))
+#else
+#define ATTRIBUTE_SSE42
+#endif
 /**
  *******************************************************************************
  *
@@ -103,6 +109,7 @@
  *
  *******************************************************************************
  */
+ATTRIBUTE_SSE42
 void ih264_resi_trans_quant_4x4_sse42(UWORD8 *pu1_src, UWORD8 *pu1_pred,
                                       WORD16 *pi2_out, WORD32 src_strd, WORD32 pred_strd,
                                       const UWORD16 *pu2_scale_matrix, const UWORD16 *pu2_threshold_matrix,
@@ -376,6 +383,7 @@ void ih264_resi_trans_quant_4x4_sse42(UWORD8 *pu1_src, UWORD8 *pu1_pred,
  *
  *******************************************************************************
  */
+ATTRIBUTE_SSE42
 void ih264_resi_trans_quant_chroma_4x4_sse42(UWORD8 *pu1_src,UWORD8 *pu1_pred,WORD16 *pi2_out,
                                             WORD32 src_strd,WORD32 pred_strd,
                                             const UWORD16 *pu2_scale_matrix,
@@ -663,6 +671,7 @@ void ih264_resi_trans_quant_chroma_4x4_sse42(UWORD8 *pu1_src,UWORD8 *pu1_pred,WO
  *
  */
 
+ATTRIBUTE_SSE42
 void ih264_hadamard_quant_4x4_sse42(WORD16 *pi2_src, WORD16 *pi2_dst,
                           const UWORD16 *pu2_scale_matrix,
                           const UWORD16 *pu2_threshold_matrix, UWORD32 u4_qbits,
@@ -892,6 +901,7 @@ void ih264_hadamard_quant_4x4_sse42(WORD16 *pi2_src, WORD16 *pi2_dst,
  *
  */
 
+ATTRIBUTE_SSE42
 void ih264_hadamard_quant_2x2_uv_sse42(WORD16 *pi2_src, WORD16 *pi2_dst,
                             const UWORD16 *pu2_scale_matrix,
                             const UWORD16 *pu2_threshold_matrix, UWORD32 u4_qbits,
diff --git a/dependencies/ih264d/common/x86/ih264_weighted_pred_sse42.c b/dependencies/ih264d/common/x86/ih264_weighted_pred_sse42.c
index 48f1f542..8e10db28 100644
--- a/dependencies/ih264d/common/x86/ih264_weighted_pred_sse42.c
+++ b/dependencies/ih264d/common/x86/ih264_weighted_pred_sse42.c
@@ -50,6 +50,12 @@
 #include "ih264_platform_macros.h"
 #include "ih264_weighted_pred.h"
 
+#ifdef __GNUC__
+#define ATTRIBUTE_SSE42 __attribute__((target("sse4.2")))
+#else
+#define ATTRIBUTE_SSE42
+#endif
+
 /*****************************************************************************/
 /*  Function definitions .                                                   */
 /*****************************************************************************/
@@ -82,6 +88,7 @@
 /*                      Senthoor                                             */
 /*                                                                           */
 /*****************************************************************************/
+ATTRIBUTE_SSE42
 void ih264_default_weighted_pred_luma_sse42(UWORD8 *pu1_src1,
                                             UWORD8 *pu1_src2,
                                             UWORD8 *pu1_dst,
@@ -245,6 +252,7 @@ void ih264_default_weighted_pred_luma_sse42(UWORD8 *pu1_src1,
 /*                      Senthoor                                             */
 /*                                                                           */
 /*****************************************************************************/
+ATTRIBUTE_SSE42
 void ih264_default_weighted_pred_chroma_sse42(UWORD8 *pu1_src1,
                                               UWORD8 *pu1_src2,
                                               UWORD8 *pu1_dst,
@@ -375,6 +383,7 @@ void ih264_default_weighted_pred_chroma_sse42(UWORD8 *pu1_src1,
 /*                      Senthoor                                             */
 /*                                                                           */
 /*****************************************************************************/
+ATTRIBUTE_SSE42
 void ih264_weighted_pred_luma_sse42(UWORD8 *pu1_src,
                                     UWORD8 *pu1_dst,
                                     WORD32 src_strd,
@@ -605,6 +614,7 @@ void ih264_weighted_pred_luma_sse42(UWORD8 *pu1_src,
 /*                      Senthoor                                             */
 /*                                                                           */
 /*****************************************************************************/
+ATTRIBUTE_SSE42
 void ih264_weighted_pred_chroma_sse42(UWORD8 *pu1_src,
                                       UWORD8 *pu1_dst,
                                       WORD32 src_strd,
@@ -814,6 +824,7 @@ void ih264_weighted_pred_chroma_sse42(UWORD8 *pu1_src,
 /*                      Senthoor                                             */
 /*                                                                           */
 /*****************************************************************************/
+ATTRIBUTE_SSE42
 void ih264_weighted_bi_pred_luma_sse42(UWORD8 *pu1_src1,
                                        UWORD8 *pu1_src2,
                                        UWORD8 *pu1_dst,
@@ -1101,6 +1112,7 @@ void ih264_weighted_bi_pred_luma_sse42(UWORD8 *pu1_src1,
 /*                      Senthoor                                             */
 /*                                                                           */
 /*****************************************************************************/
+ATTRIBUTE_SSE42
 void ih264_weighted_bi_pred_chroma_sse42(UWORD8 *pu1_src1,
                                          UWORD8 *pu1_src2,
                                          UWORD8 *pu1_dst,
diff --git a/dependencies/ih264d/decoder/x86/ih264d_function_selector_sse42.c b/dependencies/ih264d/decoder/x86/ih264d_function_selector_sse42.c
index 0c493d22..c7636f38 100644
--- a/dependencies/ih264d/decoder/x86/ih264d_function_selector_sse42.c
+++ b/dependencies/ih264d/decoder/x86/ih264d_function_selector_sse42.c
@@ -60,6 +60,12 @@
 
 #include "ih264d_structs.h"
 
+#ifdef __GNUC__
+#define ATTRIBUTE_SSE42 __attribute__((target("sse4.2")))
+#else
+#define ATTRIBUTE_SSE42
+#endif
+
 
 /**
 *******************************************************************************
@@ -79,6 +85,7 @@
 *
 *******************************************************************************
 */
+ATTRIBUTE_SSE42
 void ih264d_init_function_ptr_sse42(dec_struct_t *ps_codec)
 {
     ps_codec->pf_default_weighted_pred_luma = ih264_default_weighted_pred_luma_sse42;
diff --git a/dependencies/ih264d/decoder/x86/ih264d_function_selector_ssse3.c b/dependencies/ih264d/decoder/x86/ih264d_function_selector_ssse3.c
index 17862139..cd8043c6 100644
--- a/dependencies/ih264d/decoder/x86/ih264d_function_selector_ssse3.c
+++ b/dependencies/ih264d/decoder/x86/ih264d_function_selector_ssse3.c
@@ -60,6 +60,12 @@
 
 #include "ih264d_structs.h"
 
+#ifdef __GNUC__
+#define ATTRIBUTE_SSSE3 __attribute__((target("ssse3")))
+#else
+#define ATTRIBUTE_SSSE3
+#endif
+
 
 /**
 *******************************************************************************
@@ -79,6 +85,7 @@
 *
 *******************************************************************************
 */
+ATTRIBUTE_SSSE3
 void ih264d_init_function_ptr_ssse3(dec_struct_t *ps_codec)
 {
 
diff --git a/dependencies/imgui b/dependencies/imgui
new file mode 160000
index 00000000..f65bcf48
--- /dev/null
+++ b/dependencies/imgui
@@ -0,0 +1 @@
+Subproject commit f65bcf481ab34cd07d3909aab1479f409fa79f2f
diff --git a/dependencies/vcpkg b/dependencies/vcpkg
index 1b0252ca..533a5fda 160000
--- a/dependencies/vcpkg
+++ b/dependencies/vcpkg
@@ -1 +1 @@
-Subproject commit 1b0252ca70ca2244a711535462c7f981eb439e83
+Subproject commit 533a5fda5c0646d1771345fb572e759283444d5f
diff --git a/src/util/ThreadPool/ThreadPool.cpp b/dependencies/vcpkg_overlay_ports/.gitkeep
similarity index 100%
rename from src/util/ThreadPool/ThreadPool.cpp
rename to dependencies/vcpkg_overlay_ports/.gitkeep
diff --git a/dependencies/vcpkg_overlay_ports/fmt/fix-warning4189.patch b/dependencies/vcpkg_overlay_ports/fmt/fix-warning4189.patch
deleted file mode 100644
index 0efab0f1..00000000
--- a/dependencies/vcpkg_overlay_ports/fmt/fix-warning4189.patch
+++ /dev/null
@@ -1,12 +0,0 @@
-diff --git a/include/fmt/format.h b/include/fmt/format.h
-index 4e96539..0f1d179 100644
---- a/include/fmt/format.h
-+++ b/include/fmt/format.h
-@@ -33,6 +33,7 @@
- #ifndef FMT_FORMAT_H_
- #define FMT_FORMAT_H_
- 
-+#pragma warning(disable:4189)
- #include <algorithm>
- #include <cerrno>
- #include <cmath>
diff --git a/dependencies/vcpkg_overlay_ports/fmt/portfile.cmake b/dependencies/vcpkg_overlay_ports/fmt/portfile.cmake
deleted file mode 100644
index e3edc0f6..00000000
--- a/dependencies/vcpkg_overlay_ports/fmt/portfile.cmake
+++ /dev/null
@@ -1,65 +0,0 @@
-vcpkg_from_github(
-    OUT_SOURCE_PATH SOURCE_PATH
-    REPO fmtlib/fmt
-    REF a33701196adfad74917046096bf5a2aa0ab0bb50 # v9.1.0
-    SHA512 0faf00e99b332fcb3d9fc50cc9649ddc004ca9035f3652c1a001facee725dab09f67b65a9dfcce0aedb47e76c74c45a9262a1fd6e250a9e9a27c7d021c8ee6b8
-    HEAD_REF master
-    # PATCHES fix-warning4189.patch
-)
-
-vcpkg_cmake_configure(
-    SOURCE_PATH ${SOURCE_PATH}
-    DISABLE_PARALLEL_CONFIGURE # with MSBuild (on UWP), fmt writes into the source directory
-    OPTIONS
-        -DFMT_CMAKE_DIR=share/fmt
-        -DFMT_TEST=OFF
-        -DFMT_DOC=OFF
-)
-
-vcpkg_cmake_install()
-file(INSTALL ${SOURCE_PATH}/LICENSE.rst DESTINATION ${CURRENT_PACKAGES_DIR}/share/${PORT} RENAME copyright)
-if(VCPKG_LIBRARY_LINKAGE STREQUAL dynamic)
-    if(VCPKG_TARGET_IS_WINDOWS)
-        if(NOT DEFINED VCPKG_BUILD_TYPE OR VCPKG_BUILD_TYPE STREQUAL "debug")
-            if(EXISTS "${CURRENT_PACKAGES_DIR}/debug/lib/fmtd.dll")
-                file(MAKE_DIRECTORY ${CURRENT_PACKAGES_DIR}/debug/bin)
-                file(RENAME ${CURRENT_PACKAGES_DIR}/debug/lib/fmtd.dll ${CURRENT_PACKAGES_DIR}/debug/bin/fmtd.dll)
-            endif()
-        endif()
-        if(NOT DEFINED VCPKG_BUILD_TYPE OR VCPKG_BUILD_TYPE STREQUAL "release")
-            if(EXISTS "${CURRENT_PACKAGES_DIR}/lib/fmt.dll")
-                file(MAKE_DIRECTORY ${CURRENT_PACKAGES_DIR}/bin)
-                file(RENAME ${CURRENT_PACKAGES_DIR}/lib/fmt.dll ${CURRENT_PACKAGES_DIR}/bin/fmt.dll)
-            endif()
-        endif()
-    endif()
-
-    vcpkg_replace_string(${CURRENT_PACKAGES_DIR}/include/fmt/core.h
-        "defined(FMT_SHARED)"
-        "1"
-    )
-endif()
-file(REMOVE_RECURSE ${CURRENT_PACKAGES_DIR}/debug/include)
-
-vcpkg_cmake_config_fixup()
-vcpkg_fixup_pkgconfig()
-
-if(VCPKG_TARGET_IS_WINDOWS)
-    if(NOT DEFINED VCPKG_BUILD_TYPE OR VCPKG_BUILD_TYPE STREQUAL "debug")
-        vcpkg_replace_string(${CURRENT_PACKAGES_DIR}/share/fmt/fmt-targets-debug.cmake
-            "lib/fmtd.dll"
-            "bin/fmtd.dll"
-        )
-    endif()
-    if(NOT DEFINED VCPKG_BUILD_TYPE OR VCPKG_BUILD_TYPE STREQUAL "release")
-        vcpkg_replace_string(${CURRENT_PACKAGES_DIR}/share/fmt/fmt-targets-release.cmake
-            "lib/fmt.dll"
-            "bin/fmt.dll"
-        )
-    endif()
-endif()
-file(REMOVE_RECURSE ${CURRENT_PACKAGES_DIR}/debug/share)
-
-# Handle post-build CMake instructions
-vcpkg_copy_pdbs()
-file(INSTALL ${CMAKE_CURRENT_LIST_DIR}/usage DESTINATION ${CURRENT_PACKAGES_DIR}/share/${PORT})
diff --git a/dependencies/vcpkg_overlay_ports/fmt/usage b/dependencies/vcpkg_overlay_ports/fmt/usage
deleted file mode 100644
index c9988aa7..00000000
--- a/dependencies/vcpkg_overlay_ports/fmt/usage
+++ /dev/null
@@ -1,7 +0,0 @@
-The package fmt provides CMake targets:
-
-    find_package(fmt CONFIG REQUIRED)
-    target_link_libraries(main PRIVATE fmt::fmt)
-
-    # Or use the header-only version
-    target_link_libraries(main PRIVATE fmt::fmt-header-only)
diff --git a/dependencies/vcpkg_overlay_ports/fmt/vcpkg.json b/dependencies/vcpkg_overlay_ports/fmt/vcpkg.json
deleted file mode 100644
index 880adf38..00000000
--- a/dependencies/vcpkg_overlay_ports/fmt/vcpkg.json
+++ /dev/null
@@ -1,17 +0,0 @@
-{
-  "name": "fmt",
-  "version": "7.1.3",
-  "port-version": 2,
-  "description": "Formatting library for C++. It can be used as a safe alternative to printf or as a fast alternative to IOStreams.",
-  "homepage": "https://github.com/fmtlib/fmt",
-  "dependencies": [
-    {
-      "name": "vcpkg-cmake",
-      "host": true
-    },
-    {
-      "name": "vcpkg-cmake-config",
-      "host": true
-    }
-  ]
-}
diff --git a/dependencies/vcpkg_overlay_ports/wxwidgets/example/CMakeLists.txt b/dependencies/vcpkg_overlay_ports/wxwidgets/example/CMakeLists.txt
deleted file mode 100644
index 229b7107..00000000
--- a/dependencies/vcpkg_overlay_ports/wxwidgets/example/CMakeLists.txt
+++ /dev/null
@@ -1,31 +0,0 @@
-cmake_minimum_required(VERSION 3.7)
-
-project(wxwidgets-example)
-
-add_executable(main WIN32 popup.cpp)
-
-find_package(wxWidgets REQUIRED)
-target_compile_definitions(main PRIVATE ${wxWidgets_DEFINITIONS} "$<$<CONFIG:DEBUG>:${wxWidgets_DEFINITIONS_DEBUG}>")
-target_include_directories(main PRIVATE ${wxWidgets_INCLUDE_DIRS})
-target_link_libraries(main PRIVATE ${wxWidgets_LIBRARIES})
-
-add_executable(main2 WIN32 popup.cpp)
-
-find_package(wxWidgets CONFIG REQUIRED)
-target_link_libraries(main2 PRIVATE wx::core wx::base)
-
-option(USE_WXRC "Use the wxrc resource compiler" ON)
-if(USE_WXRC)
-    execute_process(
-        COMMAND "${wxWidgets_wxrc_EXECUTABLE}" --help
-        RESULTS_VARIABLE error_result
-    )
-    if(error_result)
-        message(FATAL_ERROR "Failed to run wxWidgets_wxrc_EXECUTABLE (${wxWidgets_wxrc_EXECUTABLE})")
-    endif()
-endif()
-
-set(PRINT_VARS "" CACHE STRING "Variables to print at the end of configuration")
-foreach(var IN LISTS PRINT_VARS)
-    message(STATUS "${var}:=${${var}}")
-endforeach()
diff --git a/dependencies/vcpkg_overlay_ports/wxwidgets/fix-libs-export.patch b/dependencies/vcpkg_overlay_ports/wxwidgets/fix-libs-export.patch
deleted file mode 100644
index 064c3a7e..00000000
--- a/dependencies/vcpkg_overlay_ports/wxwidgets/fix-libs-export.patch
+++ /dev/null
@@ -1,21 +0,0 @@
-diff --git a/build/cmake/config.cmake b/build/cmake/config.cmake
-index 52ae69d3f6..f261d5d262 100644
---- a/build/cmake/config.cmake
-+++ b/build/cmake/config.cmake
-@@ -39,8 +39,14 @@ macro(wx_get_dependencies var lib)
-             else()
-                 # For the value like $<$<CONFIG:DEBUG>:LIB_PATH>
-                 # Or $<$<NOT:$<CONFIG:DEBUG>>:LIB_PATH>
--                string(REGEX REPLACE "^.+>:(.+)>$" "\\1" dep_name ${dep})
--                if (NOT dep_name)
-+                if(dep MATCHES "^(.+>):(.+)>$")
-+                    if(CMAKE_BUILD_TYPE STREQUAL "Debug" AND CMAKE_MATCH_1 STREQUAL [[$<$<NOT:$<CONFIG:DEBUG>>]])
-+                        continue()
-+                    elseif(CMAKE_BUILD_TYPE STREQUAL "Release" AND CMAKE_MATCH_1 STREQUAL [[$<$<CONFIG:DEBUG>]])
-+                        continue()
-+                    endif()
-+                    set(dep_name "${CMAKE_MATCH_2}")
-+                else()
-                     set(dep_name ${dep})
-                 endif()
-             endif()
diff --git a/dependencies/vcpkg_overlay_ports/wxwidgets/fix-pcre2.patch b/dependencies/vcpkg_overlay_ports/wxwidgets/fix-pcre2.patch
deleted file mode 100644
index 20063f44..00000000
--- a/dependencies/vcpkg_overlay_ports/wxwidgets/fix-pcre2.patch
+++ /dev/null
@@ -1,23 +0,0 @@
-diff --git a/build/cmake/modules/FindPCRE2.cmake b/build/cmake/modules/FindPCRE2.cmake
-index a27693a..455675a 100644
---- a/build/cmake/modules/FindPCRE2.cmake
-+++ b/build/cmake/modules/FindPCRE2.cmake
-@@ -24,7 +24,10 @@ set(PCRE2_CODE_UNIT_WIDTH_USED "${PCRE2_CODE_UNIT_WIDTH}" CACHE INTERNAL "")
- 
- find_package(PkgConfig QUIET)
- pkg_check_modules(PC_PCRE2 QUIET libpcre2-${PCRE2_CODE_UNIT_WIDTH})
-+set(PCRE2_LIBRARIES ${PC_PCRE2_LINK_LIBRARIES})
-+set(PCRE2_INCLUDE_DIRS ${PC_PCRE2_INCLUDE_DIRS})
- 
-+if (0)
- find_path(PCRE2_INCLUDE_DIRS
-     NAMES pcre2.h
-     HINTS ${PC_PCRE2_INCLUDEDIR}
-@@ -36,6 +39,7 @@ find_library(PCRE2_LIBRARIES
-     HINTS ${PC_PCRE2_LIBDIR}
-           ${PC_PCRE2_LIBRARY_DIRS}
- )
-+endif()
- 
- include(FindPackageHandleStandardArgs)
- FIND_PACKAGE_HANDLE_STANDARD_ARGS(PCRE2 REQUIRED_VARS PCRE2_LIBRARIES PCRE2_INCLUDE_DIRS VERSION_VAR PC_PCRE2_VERSION)
diff --git a/dependencies/vcpkg_overlay_ports/wxwidgets/gtk3-link-libraries.patch b/dependencies/vcpkg_overlay_ports/wxwidgets/gtk3-link-libraries.patch
deleted file mode 100644
index fe2736b2..00000000
--- a/dependencies/vcpkg_overlay_ports/wxwidgets/gtk3-link-libraries.patch
+++ /dev/null
@@ -1,12 +0,0 @@
-diff --git a/build/cmake/modules/FindGTK3.cmake b/build/cmake/modules/FindGTK3.cmake
-index d2939a1..daf33fe 100644
---- a/build/cmake/modules/FindGTK3.cmake
-+++ b/build/cmake/modules/FindGTK3.cmake
-@@ -47,6 +47,7 @@ include(CheckSymbolExists)
- set(CMAKE_REQUIRED_INCLUDES ${GTK3_INCLUDE_DIRS})
- check_symbol_exists(GDK_WINDOWING_WAYLAND "gdk/gdk.h" wxHAVE_GDK_WAYLAND)
- check_symbol_exists(GDK_WINDOWING_X11 "gdk/gdk.h" wxHAVE_GDK_X11)
-+set(GTK3_LIBRARIES "${GTK3_LINK_LIBRARIES}" CACHE INTERNAL "")
- include(FindPackageHandleStandardArgs)
- FIND_PACKAGE_HANDLE_STANDARD_ARGS(GTK3 DEFAULT_MSG GTK3_INCLUDE_DIRS GTK3_LIBRARIES VERSION_OK)
- 
diff --git a/dependencies/vcpkg_overlay_ports/wxwidgets/install-layout.patch b/dependencies/vcpkg_overlay_ports/wxwidgets/install-layout.patch
deleted file mode 100644
index e55381d3..00000000
--- a/dependencies/vcpkg_overlay_ports/wxwidgets/install-layout.patch
+++ /dev/null
@@ -1,52 +0,0 @@
-diff --git a/build/cmake/functions.cmake b/build/cmake/functions.cmake
-index 32bd959..74f31ed 100644
---- a/build/cmake/functions.cmake
-+++ b/build/cmake/functions.cmake
-@@ -418,7 +418,7 @@ macro(wx_add_library name)
-         set_target_properties(${name} PROPERTIES PROJECT_LABEL ${name_short})
- 
-         # Setup install
--        set(runtime_dir "lib")
-+        set(runtime_dir "bin")
-         if(WIN32 AND NOT WIN32_MSVC_NAMING)
-             # configure puts the .dll in the bin directory
-             set(runtime_dir "bin")
-diff --git a/build/cmake/init.cmake b/build/cmake/init.cmake
-index 3ff14ab..7bd00d3 100644
---- a/build/cmake/init.cmake
-+++ b/build/cmake/init.cmake
-@@ -146,7 +146,7 @@ if(WIN32)
-     endif()
- endif()
- 
--if(WIN32_MSVC_NAMING)
-+if(0)
-     if(wxBUILD_SHARED)
-         set(lib_suffix "_dll")
-     else()
-diff --git a/build/cmake/install.cmake b/build/cmake/install.cmake
-index 84cb9f5..e2f460a 100644
---- a/build/cmake/install.cmake
-+++ b/build/cmake/install.cmake
-@@ -48,7 +48,7 @@ else()
- 
-     install(DIRECTORY DESTINATION "bin")
-     install(CODE "execute_process( \
--        COMMAND ${CMAKE_COMMAND} -E create_symlink \
-+        COMMAND ${CMAKE_COMMAND} -E copy \
-         ${CMAKE_INSTALL_PREFIX}/lib/wx/config/${wxBUILD_FILE_ID} \
-         ${CMAKE_INSTALL_PREFIX}/bin/wx-config \
-         )"
-diff --git a/build/cmake/utils/CMakeLists.txt b/build/cmake/utils/CMakeLists.txt
-index d6b3465..870897b 100644
---- a/build/cmake/utils/CMakeLists.txt
-+++ b/build/cmake/utils/CMakeLists.txt
-@@ -38,7 +38,7 @@ if(wxUSE_XRC)
-         endif()
- 
-         wx_install(CODE "execute_process( \
--            COMMAND ${CMAKE_COMMAND} -E create_symlink \
-+            COMMAND ${CMAKE_COMMAND} -E copy \
-             ${CMAKE_INSTALL_PREFIX}/bin/${wxrc_output_name}${EXE_SUFFIX} \
-             ${CMAKE_INSTALL_PREFIX}/bin/wxrc${EXE_SUFFIX} \
-             )"
diff --git a/dependencies/vcpkg_overlay_ports/wxwidgets/nanosvg-ext-depend.patch b/dependencies/vcpkg_overlay_ports/wxwidgets/nanosvg-ext-depend.patch
deleted file mode 100644
index 029b8c70..00000000
--- a/dependencies/vcpkg_overlay_ports/wxwidgets/nanosvg-ext-depend.patch
+++ /dev/null
@@ -1,42 +0,0 @@
-diff --git a/build/cmake/lib/nanosvg.cmake b/build/cmake/lib/nanosvg.cmake
-index 401bf48..b9e4b57 100644
---- a/build/cmake/lib/nanosvg.cmake
-+++ b/build/cmake/lib/nanosvg.cmake
-@@ -16,9 +16,9 @@ elseif(wxUSE_NANOSVG)
-     set(NANOSVG_INCLUDE_DIRS )
-     set(wxUSE_NANOSVG_EXTERNAL_ENABLE_IMPL TRUE)
- 
--    find_package(NanoSVG REQUIRED)
-+    find_package(unofficial-nanosvg CONFIG REQUIRED)
- 
--    foreach(TARGETNAME NanoSVG::nanosvg NanoSVG::nanosvgrast unofficial::nanosvg)
-+    foreach(TARGETNAME unofficial::nanosvg::nanosvg)
-         if(NOT TARGET ${TARGETNAME})
-             continue()
-         endif()
-diff --git a/build/cmake/options.cmake b/build/cmake/options.cmake
-index 49c536a..5630526 100644
---- a/build/cmake/options.cmake
-+++ b/build/cmake/options.cmake
-@@ -114,7 +114,7 @@ wx_add_thirdparty_library(wxUSE_EXPAT EXPAT "use expat for XML parsing" DEFAULT_
- wx_add_thirdparty_library(wxUSE_LIBJPEG JPEG "use libjpeg (JPEG file format)")
- wx_add_thirdparty_library(wxUSE_LIBPNG PNG "use libpng (PNG image format)")
- wx_add_thirdparty_library(wxUSE_LIBTIFF TIFF "use libtiff (TIFF file format)")
--wx_add_thirdparty_library(wxUSE_NANOSVG NanoSVG "use NanoSVG for rasterizing SVG")
-+wx_add_thirdparty_library(wxUSE_NANOSVG unofficial-nanosvg "use NanoSVG for rasterizing SVG")
- 
- wx_option(wxUSE_LIBLZMA "use LZMA compression" OFF)
- set(wxTHIRD_PARTY_LIBRARIES ${wxTHIRD_PARTY_LIBRARIES} wxUSE_LIBLZMA "use liblzma for LZMA compression")
-diff --git a/build/cmake/wxWidgetsConfig.cmake.in b/build/cmake/wxWidgetsConfig.cmake.in
-index 6ef5a6e..248a701 100644
---- a/build/cmake/wxWidgetsConfig.cmake.in
-+++ b/build/cmake/wxWidgetsConfig.cmake.in
-@@ -1,5 +1,8 @@
- @PACKAGE_INIT@
- 
-+include(CMakeFindDependencyMacro)
-+find_dependency(unofficial-nanosvg CONFIG)
-+
- # determine target from compiler, platform and library type
- if(WIN32 AND NOT CYGWIN AND NOT MSYS)
-     if(${CMAKE_CXX_COMPILER_ID} STREQUAL MSVC)
diff --git a/dependencies/vcpkg_overlay_ports/wxwidgets/portfile.cmake b/dependencies/vcpkg_overlay_ports/wxwidgets/portfile.cmake
deleted file mode 100644
index 984fc083..00000000
--- a/dependencies/vcpkg_overlay_ports/wxwidgets/portfile.cmake
+++ /dev/null
@@ -1,236 +0,0 @@
-vcpkg_from_github(
-    OUT_SOURCE_PATH SOURCE_PATH
-    REPO wxWidgets/wxWidgets
-    REF v3.2.0
-    SHA512 0bb40ccab51f5e83a38feeaf462c9d1852f821d19592328327f829890d89a3abb2a991c43cdbac55da8f5ee40aab8bd5fea6abcd052198302770292f92f9f9ad
-    HEAD_REF master
-    PATCHES
-        install-layout.patch
-        relocatable-wx-config.patch
-        fix-libs-export.patch
-        fix-pcre2.patch
-        gtk3-link-libraries.patch
-)
-
-if(VCPKG_TARGET_IS_LINUX)
-    message(WARNING [[
-Port wxwidgets currently requires the following packages from the system package manager:
-    pkg-config
-    GTK 3
-    libsecret
-    libgcrypt
-    libsystemd
-These development packages can be installed on Ubuntu systems via
-    sudo apt-get install pkg-config libgtk-3-dev libsecret-1-dev libgcrypt20-dev libsystemd-dev
-]])
-    foreach(conflicting_port IN ITEMS freetype glib)
-        if(EXISTS "${CURRENT_INSTALLED_DIR}/share/${conflicting_port}/copyright")
-            message(FATAL_ERROR "Port ${conflicting_port} must not be installed when building ${PORT}:${TARGET_TRIPLET}.")
-        endif()
-    endforeach()
-endif()
-
-vcpkg_check_features(
-    OUT_FEATURE_OPTIONS FEATURE_OPTIONS
-    FEATURES
-        sound   wxUSE_SOUND
-        fonts   wxUSE_PRIVATE_FONTS
-)
-
-set(OPTIONS_RELEASE "")
-if(NOT "debug-support" IN_LIST FEATURES)
-    list(APPEND OPTIONS_RELEASE "-DwxBUILD_DEBUG_LEVEL=0")
-endif()
-
-set(OPTIONS "")
-if(VCPKG_TARGET_IS_WINDOWS AND (VCPKG_TARGET_ARCHITECTURE STREQUAL "arm64" OR VCPKG_TARGET_ARCHITECTURE STREQUAL "arm"))
-    list(APPEND OPTIONS
-        -DwxUSE_OPENGL=OFF
-        -DwxUSE_STACKWALKER=OFF
-    )
-endif()
-
-if(VCPKG_TARGET_IS_WINDOWS OR VCPKG_TARGET_IS_OSX)
-    list(APPEND OPTIONS -DwxUSE_WEBREQUEST_CURL=OFF)
-else()
-    list(APPEND OPTIONS -DwxUSE_WEBREQUEST_CURL=ON)
-endif()
-
-if(DEFINED ENV{PKG_CONFIG})
-    set(PKGCONFIG "$ENV{PKG_CONFIG}")
-elseif(VCPKG_TARGET_IS_LINUX AND NOT VCPKG_CROSSCOMPILING)
-    # wxWidgets on Linux currently needs to find the system's `gtk+-3.0.pc`.
-    # vcpkg's port pkgconf would prevent this lookup.
-    find_program(system_pkg_config NAMES pkg-config)
-    if(system_pkg_config)
-        set(PKGCONFIG "${system_pkg_config}")
-    endif()
-    if(VCPKG_LIBRARY_LINKAGE STREQUAL "static")
-        list(APPEND OPTIONS -DPKG_CONFIG_ARGN=--static)
-    endif()
-endif()
-vcpkg_find_acquire_program(PKGCONFIG)
-
-# This may be set to ON by users in a custom triplet.
-# The use of 'wxUSE_STL' and 'WXWIDGETS_USE_STD_CONTAINERS' (ON or OFF) are not API compatible
-# which is why they must be set in a custom triplet rather than a port feature.
-if(NOT DEFINED WXWIDGETS_USE_STL)
-    #set(WXWIDGETS_USE_STL OFF)
-endif()
-
-if(NOT DEFINED WXWIDGETS_USE_STD_CONTAINERS)
-    set(WXWIDGETS_USE_STD_CONTAINERS OFF)
-endif()
-
-vcpkg_cmake_configure(
-    SOURCE_PATH "${SOURCE_PATH}"
-    OPTIONS
-        ${FEATURE_OPTIONS}
-        -DwxUSE_REGEX=sys
-        -DwxUSE_ZLIB=sys
-        -DwxUSE_EXPAT=sys
-        -DwxUSE_LIBJPEG=sys
-        -DwxUSE_LIBPNG=sys
-        -DwxUSE_LIBTIFF=sys
-        -DwxUSE_SECRETSTORE=FALSE
-        -DwxUSE_STL=ON
-        -DwxUSE_STD_CONTAINERS=${WXWIDGETS_USE_STD_CONTAINERS}
-		-DwxBUILD_DISABLE_PLATFORM_LIB_DIR=ON
-		-DwxUSE_LIBLZMA=OFF
-		-DwxUSE_JOYSTICK=OFF
-		-DwxUSE_SOCKETS=OFF
-		-DwxUSE_IPV6=OFF
-		-DwxUSE_FS_ZIP=OFF
-		-DwxUSE_FS_ARCHIVE=OFF
-		-DwxUSE_FS_INET=OFF
-		-DwxUSE_ARCHIVE_STREAMS=OFF
-		-DwxUSE_ZIPSTREAM=OFF
-		-DwxUSE_TARSTREAM=OFF
-		-DwxUSE_PROTOCOL=OFF
-		-DwxUSE_PROTOCOL_FTP=OFF
-		-DwxUSE_PROTOCOL_HTTP=OFF
-		-DwxUSE_URL=OFF
-		-DwxUSE_SOUND=OFF
-		-DwxUSE_WEBVIEW=OFF
-		-DwxUSE_RICHTEXT=OFF
-		-DwxUSE_SVG=OFF
-		-DwxUSE_GIF=OFF
-		-DwxUSE_PNM=OFF
-		-DwxUSE_PCX=OFF
-		-DwxUSE_WEBREQUEST=OFF
-		-DwxUSE_ACTIVEX=OFF
-		-DwxUSE_REGEX=OFF
-		-DwxUSE_NANOSVG=OFF
-		-DwxUSE_NANOSVG_EXTERNAL=OFF
-        ${OPTIONS}
-        "-DPKG_CONFIG_EXECUTABLE=${PKGCONFIG}"
-        # The minimum cmake version requirement for Cotire is 2.8.12.
-        # however, we need to declare that the minimum cmake version requirement is at least 3.1 to use CMAKE_PREFIX_PATH as the path to find .pc.
-        -DPKG_CONFIG_USE_CMAKE_PREFIX_PATH=ON
-    OPTIONS_RELEASE
-        ${OPTIONS_RELEASE}
-)
-
-vcpkg_cmake_install()
-vcpkg_cmake_config_fixup(CONFIG_PATH lib/cmake/wxWidgets)
-
-# The CMake export is not ready for use: It lacks a config file.
-file(REMOVE_RECURSE
-    ${CURRENT_PACKAGES_DIR}/lib/cmake
-    ${CURRENT_PACKAGES_DIR}/debug/lib/cmake
-)
-
-set(tools wxrc)
-if(NOT VCPKG_TARGET_IS_WINDOWS OR NOT VCPKG_HOST_IS_WINDOWS)
-    list(APPEND tools wxrc-3.2)
-    file(MAKE_DIRECTORY "${CURRENT_PACKAGES_DIR}/tools/${PORT}")
-    file(RENAME "${CURRENT_PACKAGES_DIR}/bin/wx-config" "${CURRENT_PACKAGES_DIR}/tools/${PORT}/wx-config")
-    if(NOT VCPKG_BUILD_TYPE)
-        file(MAKE_DIRECTORY "${CURRENT_PACKAGES_DIR}/tools/${PORT}/debug")
-        file(RENAME "${CURRENT_PACKAGES_DIR}/debug/bin/wx-config" "${CURRENT_PACKAGES_DIR}/tools/${PORT}/debug/wx-config")
-    endif()
-endif()
-vcpkg_copy_tools(TOOL_NAMES ${tools} AUTO_CLEAN)
-
-# do the copy pdbs now after the dlls got moved to the expected /bin folder above
-vcpkg_copy_pdbs()
-
-file(REMOVE_RECURSE "${CURRENT_PACKAGES_DIR}/include/msvc")
-file(REMOVE_RECURSE "${CURRENT_PACKAGES_DIR}/debug/include")
-file(GLOB_RECURSE INCLUDES "${CURRENT_PACKAGES_DIR}/include/*.h")
-if(EXISTS "${CURRENT_PACKAGES_DIR}/lib/mswu/wx/setup.h")
-    list(APPEND INCLUDES "${CURRENT_PACKAGES_DIR}/lib/mswu/wx/setup.h")
-endif()
-if(EXISTS "${CURRENT_PACKAGES_DIR}/debug/lib/mswud/wx/setup.h")
-    list(APPEND INCLUDES "${CURRENT_PACKAGES_DIR}/debug/lib/mswud/wx/setup.h")
-endif()
-foreach(INC IN LISTS INCLUDES)
-    file(READ "${INC}" _contents)
-    if(VCPKG_LIBRARY_LINKAGE STREQUAL "static")
-        string(REPLACE "defined(WXUSINGDLL)" "0" _contents "${_contents}")
-    else()
-        string(REPLACE "defined(WXUSINGDLL)" "1" _contents "${_contents}")
-    endif()
-    # Remove install prefix from setup.h to ensure package is relocatable
-    string(REGEX REPLACE "\n#define wxINSTALL_PREFIX [^\n]*" "\n#define wxINSTALL_PREFIX \"\"" _contents "${_contents}")
-    file(WRITE "${INC}" "${_contents}")
-endforeach()
-
-if(NOT EXISTS "${CURRENT_PACKAGES_DIR}/include/wx/setup.h")
-    file(GLOB_RECURSE WX_SETUP_H_FILES_DBG "${CURRENT_PACKAGES_DIR}/debug/lib/*.h")
-    file(GLOB_RECURSE WX_SETUP_H_FILES_REL "${CURRENT_PACKAGES_DIR}/lib/*.h")
-
-    if(NOT DEFINED VCPKG_BUILD_TYPE OR VCPKG_BUILD_TYPE STREQUAL "release")
-        vcpkg_replace_string("${WX_SETUP_H_FILES_REL}" "${CURRENT_PACKAGES_DIR}" "")
-
-        string(REPLACE "${CURRENT_PACKAGES_DIR}/lib/" "" WX_SETUP_H_FILES_REL "${WX_SETUP_H_FILES_REL}")
-        string(REPLACE "/setup.h" "" WX_SETUP_H_REL_RELATIVE "${WX_SETUP_H_FILES_REL}")
-    endif()
-    if(NOT DEFINED VCPKG_BUILD_TYPE OR VCPKG_BUILD_TYPE STREQUAL "debug")
-        vcpkg_replace_string("${WX_SETUP_H_FILES_DBG}" "${CURRENT_PACKAGES_DIR}" "")
-
-        string(REPLACE "${CURRENT_PACKAGES_DIR}/debug/lib/" "" WX_SETUP_H_FILES_DBG "${WX_SETUP_H_FILES_DBG}")
-        string(REPLACE "/setup.h" "" WX_SETUP_H_DBG_RELATIVE "${WX_SETUP_H_FILES_DBG}")
-    endif()
-
-    configure_file("${CMAKE_CURRENT_LIST_DIR}/setup.h.in" "${CURRENT_PACKAGES_DIR}/include/wx/setup.h" @ONLY)
-endif()
-
-file(GLOB configs LIST_DIRECTORIES false "${CURRENT_PACKAGES_DIR}/lib/wx/config/*" "${CURRENT_PACKAGES_DIR}/tools/${PORT}/wx-config")
-foreach(config IN LISTS configs)
-    vcpkg_replace_string("${config}" "${CURRENT_INSTALLED_DIR}" [[${prefix}]])
-endforeach()
-file(GLOB configs LIST_DIRECTORIES false "${CURRENT_PACKAGES_DIR}/debug/lib/wx/config/*" "${CURRENT_PACKAGES_DIR}/tools/${PORT}/debug/wx-config")
-foreach(config IN LISTS configs)
-    vcpkg_replace_string("${config}" "${CURRENT_INSTALLED_DIR}/debug" [[${prefix}]])
-endforeach()
-
-# For CMake multi-config in connection with wrapper
-if(EXISTS "${CURRENT_PACKAGES_DIR}/debug/lib/mswud/wx/setup.h")
-    file(INSTALL "${CURRENT_PACKAGES_DIR}/debug/lib/mswud/wx/setup.h"
-        DESTINATION "${CURRENT_PACKAGES_DIR}/lib/mswud/wx"
-    )
-endif()
-
-if(NOT "debug-support" IN_LIST FEATURES)
-    if(VCPKG_TARGET_IS_WINDOWS AND VCPKG_HOST_IS_WINDOWS)
-        vcpkg_replace_string("${CURRENT_PACKAGES_DIR}/include/wx/debug.h" "#define wxDEBUG_LEVEL 1" "#define wxDEBUG_LEVEL 0")
-    else()
-        vcpkg_replace_string("${CURRENT_PACKAGES_DIR}/include/wx-3.2/wx/debug.h" "#define wxDEBUG_LEVEL 1" "#define wxDEBUG_LEVEL 0")
-    endif()
-endif()
-
-if("example" IN_LIST FEATURES)
-    file(INSTALL
-        "${CMAKE_CURRENT_LIST_DIR}/example/CMakeLists.txt"
-        "${SOURCE_PATH}/samples/popup/popup.cpp"
-        "${SOURCE_PATH}/samples/sample.xpm"
-        DESTINATION "${CURRENT_PACKAGES_DIR}/share/${PORT}/example"
-    )
-    vcpkg_replace_string("${CURRENT_PACKAGES_DIR}/share/${PORT}/example/popup.cpp" "../sample.xpm" "sample.xpm")
-endif()
-
-configure_file("${CMAKE_CURRENT_LIST_DIR}/vcpkg-cmake-wrapper.cmake" "${CURRENT_PACKAGES_DIR}/share/${PORT}/vcpkg-cmake-wrapper.cmake" @ONLY)
-
-file(INSTALL "${CMAKE_CURRENT_LIST_DIR}/usage" DESTINATION "${CURRENT_PACKAGES_DIR}/share/${PORT}")
-file(INSTALL "${SOURCE_PATH}/docs/licence.txt" DESTINATION "${CURRENT_PACKAGES_DIR}/share/${PORT}" RENAME copyright)
diff --git a/dependencies/vcpkg_overlay_ports/wxwidgets/relocatable-wx-config.patch b/dependencies/vcpkg_overlay_ports/wxwidgets/relocatable-wx-config.patch
deleted file mode 100644
index 8a5e7c4d..00000000
--- a/dependencies/vcpkg_overlay_ports/wxwidgets/relocatable-wx-config.patch
+++ /dev/null
@@ -1,49 +0,0 @@
-diff --git a/wx-config.in b/wx-config.in
-index 441f88c..b326867 100755
---- a/wx-config.in
-+++ b/wx-config.in
-@@ -91,7 +91,7 @@ EOF
- 
- 
- # Contentious tools determined by configure.
--EGREP="@EGREP@"
-+EGREP="grep -E" # no absolute path from host
- 
- 
- # For the people who know what they want, or think they do:
-@@ -402,8 +402,23 @@ is_cross()  { [ "x@cross_compiling@" = "xyes" ]; }
- 
- 
- # Determine the base directories we require.
--prefix=${input_option_prefix-${this_prefix:-@prefix@}}
--exec_prefix=${input_option_exec_prefix-${input_option_prefix-${this_exec_prefix:-@exec_prefix@}}}
-+vcpkg_prefix=$(CDPATH= cd -- "$(dirname -- "$0")" && pwd -P)
-+case "$vcpkg_prefix" in
-+    */lib/wx/config)
-+        vcpkg_prefix=${vcpkg_prefix%/*/*/*}
-+        ;;
-+    */tools/wxwidgets/debug)
-+        vcpkg_prefix=${vcpkg_prefix%/*/*/*}/debug
-+        ;;
-+    */tools/wxwidgets)
-+        vcpkg_prefix=${vcpkg_prefix%/*/*}
-+        ;;
-+esac
-+if [ -n "@MINGW@" -a -n "@CMAKE_HOST_WIN32@" ]; then
-+    vcpkg_prefix=$(cygpath -m "$vcpkg_prefix")
-+fi
-+prefix=${input_option_prefix-${this_prefix:-$vcpkg_prefix}}
-+exec_prefix=${input_option_exec_prefix-${input_option_prefix-${this_exec_prefix:-$prefix}}}
- wxconfdir="@libdir@/wx/config"
- 
- installed_configs=`cd "$wxconfdir" 2> /dev/null && ls | grep -v "^inplace-"`
-@@ -940,6 +949,9 @@ prefix=${this_prefix-$prefix}
- exec_prefix=${this_exec_prefix-$exec_prefix}
- 
- includedir="@includedir@"
-+if [ "@CMAKE_BUILD_TYPE@" = "Debug" ] ; then
-+    includedir="${includedir%/debug/include}/include"
-+fi
- libdir="@libdir@"
- bindir="@bindir@"
- 
diff --git a/dependencies/vcpkg_overlay_ports/wxwidgets/setup.h.in b/dependencies/vcpkg_overlay_ports/wxwidgets/setup.h.in
deleted file mode 100644
index b927735b..00000000
--- a/dependencies/vcpkg_overlay_ports/wxwidgets/setup.h.in
+++ /dev/null
@@ -1,5 +0,0 @@
-#ifdef _DEBUG
-#include "../../debug/lib/@WX_SETUP_H_DBG_RELATIVE@/setup.h"
-#else
-#include "../../lib/@WX_SETUP_H_REL_RELATIVE@/setup.h"
-#endif
diff --git a/dependencies/vcpkg_overlay_ports/wxwidgets/usage b/dependencies/vcpkg_overlay_ports/wxwidgets/usage
deleted file mode 100644
index bf1043e8..00000000
--- a/dependencies/vcpkg_overlay_ports/wxwidgets/usage
+++ /dev/null
@@ -1,4 +0,0 @@
-The package wxwidgets provides CMake targets:
-
-    find_package(wxWidgets CONFIG REQUIRED)
-    target_link_libraries(main PRIVATE wx::core wx::base)
diff --git a/dependencies/vcpkg_overlay_ports/wxwidgets/vcpkg-cmake-wrapper.cmake b/dependencies/vcpkg_overlay_ports/wxwidgets/vcpkg-cmake-wrapper.cmake
deleted file mode 100644
index b605525a..00000000
--- a/dependencies/vcpkg_overlay_ports/wxwidgets/vcpkg-cmake-wrapper.cmake
+++ /dev/null
@@ -1,77 +0,0 @@
-cmake_policy(PUSH)
-cmake_policy(SET CMP0012 NEW)
-cmake_policy(SET CMP0054 NEW)
-
-get_filename_component(_vcpkg_wx_root "${CMAKE_CURRENT_LIST_DIR}/../.." ABSOLUTE)
-set(wxWidgets_ROOT_DIR "${_vcpkg_wx_root}" CACHE INTERNAL "")
-set(WX_ROOT_DIR "${_vcpkg_wx_root}" CACHE INTERNAL "")
-unset(_vcpkg_wx_root)
-
-if(WIN32 AND CMAKE_HOST_WIN32)
-    # Find all libs with "32" infix which is unknown to FindwxWidgets.cmake
-    function(z_vcpkg_wxwidgets_find_base_library BASENAME)
-        find_library(WX_${BASENAME}d wx${BASENAME}32ud NAMES wx${BASENAME}d PATHS "${wxWidgets_ROOT_DIR}/debug/lib" NO_DEFAULT_PATH)
-        find_library(WX_${BASENAME}  wx${BASENAME}32u  NAMES wx${BASENAME}  PATHS "${wxWidgets_ROOT_DIR}/lib" NO_DEFAULT_PATH REQUIRED)
-    endfunction()
-    function(z_vcpkg_wxwidgets_find_suffix_library BASENAME)
-        foreach(lib IN LISTS ARGN)
-            find_library(WX_${lib}d NAMES wx${BASENAME}32ud_${lib} PATHS "${wxWidgets_ROOT_DIR}/debug/lib" NO_DEFAULT_PATH)
-            find_library(WX_${lib}  NAMES wx${BASENAME}32u_${lib}  PATHS "${wxWidgets_ROOT_DIR}/lib" NO_DEFAULT_PATH)
-        endforeach()
-    endfunction()
-    z_vcpkg_wxwidgets_find_base_library(base)
-    z_vcpkg_wxwidgets_find_suffix_library(base net odbc xml)
-    z_vcpkg_wxwidgets_find_suffix_library(msw core adv aui html media xrc dbgrid gl qa richtext stc ribbon propgrid webview)
-    if(WX_stc AND "@VCPKG_LIBRARY_LINKAGE@" STREQUAL "static")
-        z_vcpkg_wxwidgets_find_base_library(scintilla)
-    endif()
-    # Force FindwxWidgets.cmake win32 mode for all windows targets built on windows
-    set(_vcpkg_wxwidgets_backup_crosscompiling "${CMAKE_CROSSCOMPILING}")
-    set(CMAKE_CROSSCOMPILING 0)
-    set(wxWidgets_LIB_DIR "${wxWidgets_ROOT_DIR}/lib" CACHE INTERNAL "")
-else()
-    # FindwxWidgets.cmake unix mode, single-config
-    if(MINGW)
-        # Force FindwxWidgets.cmake unix mode for mingw cross builds
-        set(_vcpkg_wxwidgets_backup_crosscompiling "${CMAKE_CROSSCOMPILING}")
-        set(CMAKE_CROSSCOMPILING 1)
-    endif()
-    set(_vcpkg_wxconfig "")
-    if(CMAKE_BUILD_TYPE STREQUAL "Debug" OR "Debug" IN_LIST MAP_IMPORTED_CONFIG_${CMAKE_BUILD_TYPE})
-        # Debug
-        set(wxWidgets_LIB_DIR "${wxWidgets_ROOT_DIR}/debug/lib" CACHE INTERNAL "")
-        file(GLOB _vcpkg_wxconfig LIST_DIRECTORIES false "${wxWidgets_LIB_DIR}/wx/config/*")
-    endif()
-    if(NOT _vcpkg_wxconfig)
-        # Release or fallback
-        set(wxWidgets_LIB_DIR "${wxWidgets_ROOT_DIR}/lib" CACHE INTERNAL "")
-        file(GLOB _vcpkg_wxconfig LIST_DIRECTORIES false "${wxWidgets_LIB_DIR}/wx/config/*")
-    endif()
-    set(wxWidgets_CONFIG_EXECUTABLE "${_vcpkg_wxconfig}" CACHE INTERNAL "")
-    unset(_vcpkg_wxconfig)
-endif()
-set(WX_LIB_DIR "${wxWidgets_LIB_DIR}" CACHE INTERNAL "")
-
-_find_package(${ARGS})
-
-if(DEFINED _vcpkg_wxwidgets_backup_crosscompiling)
-    set(CMAKE_CROSSCOMPILING "${_vcpkg_wxwidgets_backup_crosscompiling}")
-    unset(_vcpkg_wxwidgets_backup_crosscompiling)
-endif()
-
-if(WIN32 AND CMAKE_HOST_WIN32 AND "@VCPKG_LIBRARY_LINKAGE@" STREQUAL "static" AND NOT "wx::core" IN_LIST wxWidgets_LIBRARIES)
-    find_package(EXPAT QUIET)
-    find_package(JPEG QUIET)
-    find_package(PNG QUIET)
-    find_package(TIFF QUIET)
-    find_package(ZLIB QUIET)
-    list(APPEND wxWidgets_LIBRARIES
-        ${EXPAT_LIBRARIES}
-        ${JPEG_LIBRARIES}
-        ${PNG_LIBRARIES}
-        ${TIFF_LIBRARIES}
-        ${ZLIB_LIBRARIES}
-    )
-endif()
-
-cmake_policy(POP)
diff --git a/dependencies/vcpkg_overlay_ports/wxwidgets/vcpkg.json b/dependencies/vcpkg_overlay_ports/wxwidgets/vcpkg.json
deleted file mode 100644
index 3f04aece..00000000
--- a/dependencies/vcpkg_overlay_ports/wxwidgets/vcpkg.json
+++ /dev/null
@@ -1,67 +0,0 @@
-{
-  "name": "wxwidgets",
-  "version": "3.2.0",
-  "port-version": 1,
-  "description": [
-    "Widget toolkit and tools library for creating graphical user interfaces (GUIs) for cross-platform applications. ",
-    "Set WXWIDGETS_USE_STL in a custom triplet to build with the wxUSE_STL build option.",
-    "Set WXWIDGETS_USE_STD_CONTAINERS in a custom triplet to build with the wxUSE_STD_CONTAINERS build option."
-  ],
-  "homepage": "https://github.com/wxWidgets/wxWidgets",
-  "license": "LGPL-2.0-or-later WITH WxWindows-exception-3.1",
-  "supports": "!uwp",
-  "dependencies": [
-    {
-      "name": "curl",
-      "default-features": false,
-      "platform": "!windows & !osx"
-    },
-    "expat",
-    "libpng",
-    "tiff",
-    {
-      "name": "vcpkg-cmake",
-      "host": true
-    },
-    {
-      "name": "vcpkg-cmake-config",
-      "host": true
-    },
-    "zlib"
-  ],
-  "default-features": [
-    "debug-support",
-    "sound"
-  ],
-  "features": {
-    "debug-support": {
-      "description": "Enable wxWidgets debugging support hooks even for release builds (wxDEBUG_LEVEL 1)"
-    },
-    "example": {
-      "description": "Example source code and CMake project"
-    },
-    "fonts": {
-      "description": "Enable to use the font functionality of wxWidgets",
-      "dependencies": [
-        {
-          "name": "fontconfig",
-          "platform": "!windows & !osx"
-        },
-        {
-          "name": "pango",
-          "platform": "!windows & !osx"
-        }
-      ]
-    },
-    "sound": {
-      "description": "Build wxSound support",
-      "dependencies": [
-        {
-          "name": "sdl2",
-          "default-features": false,
-          "platform": "!windows & !osx"
-        }
-      ]
-    }
-  }
-}
diff --git a/dependencies/vcpkg_overlay_ports_linux/.gitkeep b/dependencies/vcpkg_overlay_ports_linux/.gitkeep
new file mode 100644
index 00000000..e69de29b
diff --git a/dependencies/vcpkg_overlay_ports_linux/cairo/portfile.cmake b/dependencies/vcpkg_overlay_ports_linux/cairo/portfile.cmake
new file mode 100644
index 00000000..065116c2
--- /dev/null
+++ b/dependencies/vcpkg_overlay_ports_linux/cairo/portfile.cmake
@@ -0,0 +1 @@
+set(VCPKG_POLICY_EMPTY_PACKAGE enabled)
diff --git a/dependencies/vcpkg_overlay_ports_linux/cairo/vcpkg.json b/dependencies/vcpkg_overlay_ports_linux/cairo/vcpkg.json
new file mode 100644
index 00000000..6d520494
--- /dev/null
+++ b/dependencies/vcpkg_overlay_ports_linux/cairo/vcpkg.json
@@ -0,0 +1,8 @@
+{
+  "name": "cairo",
+  "version": "1.17.8",
+  "description": "Cairo is a 2D graphics library with support for multiple output devices. Currently supported output targets include the X Window System (via both Xlib and XCB), Quartz, Win32, image buffers, PostScript, PDF, and SVG file output. Experimental backends include OpenGL, BeOS, OS/2, and DirectFB.",
+  "homepage": "https://cairographics.org",
+  "license": "MPL-1.1",
+  "port-version": 2
+}
diff --git a/dependencies/vcpkg_overlay_ports_linux/glm/portfile.cmake b/dependencies/vcpkg_overlay_ports_linux/glm/portfile.cmake
new file mode 100644
index 00000000..065116c2
--- /dev/null
+++ b/dependencies/vcpkg_overlay_ports_linux/glm/portfile.cmake
@@ -0,0 +1 @@
+set(VCPKG_POLICY_EMPTY_PACKAGE enabled)
diff --git a/dependencies/vcpkg_overlay_ports_linux/glm/vcpkg.json b/dependencies/vcpkg_overlay_ports_linux/glm/vcpkg.json
new file mode 100644
index 00000000..17f5fb1d
--- /dev/null
+++ b/dependencies/vcpkg_overlay_ports_linux/glm/vcpkg.json
@@ -0,0 +1,8 @@
+{
+  "name": "glm",
+  "version": "0.9.9.8",
+  "port-version": 3,
+  "description": "OpenGL Mathematics (GLM)",
+  "homepage": "https://glm.g-truc.net",
+  "license": "MIT"
+}
diff --git a/dependencies/vcpkg_overlay_ports_linux/gtk3/portfile.cmake b/dependencies/vcpkg_overlay_ports_linux/gtk3/portfile.cmake
new file mode 100644
index 00000000..065116c2
--- /dev/null
+++ b/dependencies/vcpkg_overlay_ports_linux/gtk3/portfile.cmake
@@ -0,0 +1 @@
+set(VCPKG_POLICY_EMPTY_PACKAGE enabled)
diff --git a/dependencies/vcpkg_overlay_ports_linux/gtk3/vcpkg.json b/dependencies/vcpkg_overlay_ports_linux/gtk3/vcpkg.json
new file mode 100644
index 00000000..c160ac00
--- /dev/null
+++ b/dependencies/vcpkg_overlay_ports_linux/gtk3/vcpkg.json
@@ -0,0 +1,8 @@
+{
+  "name": "gtk3",
+  "version": "3.24.34",
+  "port-version": 5,
+  "description": "Portable library for creating graphical user interfaces.",
+  "homepage": "https://www.gtk.org/",
+  "license": null
+}
diff --git a/dependencies/vcpkg_overlay_ports_linux/libpng/portfile.cmake b/dependencies/vcpkg_overlay_ports_linux/libpng/portfile.cmake
new file mode 100644
index 00000000..065116c2
--- /dev/null
+++ b/dependencies/vcpkg_overlay_ports_linux/libpng/portfile.cmake
@@ -0,0 +1 @@
+set(VCPKG_POLICY_EMPTY_PACKAGE enabled)
diff --git a/dependencies/vcpkg_overlay_ports_linux/libpng/vcpkg.json b/dependencies/vcpkg_overlay_ports_linux/libpng/vcpkg.json
new file mode 100644
index 00000000..8c54781c
--- /dev/null
+++ b/dependencies/vcpkg_overlay_ports_linux/libpng/vcpkg.json
@@ -0,0 +1,8 @@
+{
+  "name": "libpng",
+  "version": "1.6.39",
+  "port-version": 2,
+  "description": "libpng is a library implementing an interface for reading and writing PNG (Portable Network Graphics) format files",
+  "homepage": "https://github.com/glennrp/libpng",
+  "license": "libpng-2.0"
+}
diff --git a/dependencies/vcpkg_overlay_ports_mac/.gitkeep b/dependencies/vcpkg_overlay_ports_mac/.gitkeep
new file mode 100644
index 00000000..e69de29b
diff --git a/dependencies/vcpkg_overlay_ports_mac/libusb/portfile.cmake b/dependencies/vcpkg_overlay_ports_mac/libusb/portfile.cmake
new file mode 100644
index 00000000..7b76bba0
--- /dev/null
+++ b/dependencies/vcpkg_overlay_ports_mac/libusb/portfile.cmake
@@ -0,0 +1,71 @@
+set(VCPKG_LIBRARY_LINKAGE dynamic)
+
+if(VCPKG_TARGET_IS_LINUX)
+    message("${PORT} currently requires the following tools and libraries from the system package manager:\n    autoreconf\n    libudev\n\nThese can be installed on Ubuntu systems via apt-get install autoconf libudev-dev")
+endif()
+
+set(VERSION 1.0.26)
+vcpkg_from_github(
+    OUT_SOURCE_PATH SOURCE_PATH
+    REPO libusb/libusb
+    REF fcf0c710ef5911ae37fbbf1b39d48a89f6f14e8a # v1.0.26.11791 2023-03-12
+    SHA512 0aa6439f7988487adf2a3bff473fec80b5c722a47f117a60696d2aa25c87cc3f20fb6aaca7c66e49be25db6a35eb0bb5f71ed7b211d1b8ee064c5d7f1b985c73
+    HEAD_REF master
+)
+
+if(VCPKG_TARGET_IS_WINDOWS AND NOT VCPKG_TARGET_IS_MINGW)
+
+  if(VCPKG_LIBRARY_LINKAGE STREQUAL "dynamic")
+      set(LIBUSB_PROJECT_TYPE dll)
+  else()
+      set(LIBUSB_PROJECT_TYPE static)
+  endif()
+
+  # The README.md file in the archive is a symlink to README
+  # which causes issues with the windows MSBUILD process
+  file(REMOVE "${SOURCE_PATH}/README.md")
+
+  vcpkg_msbuild_install(
+      SOURCE_PATH "${SOURCE_PATH}"
+      PROJECT_SUBPATH msvc/libusb_${LIBUSB_PROJECT_TYPE}.vcxproj
+  )
+
+  file(INSTALL "${SOURCE_PATH}/libusb/libusb.h"  DESTINATION "${CURRENT_PACKAGES_DIR}/include/libusb-1.0")
+  set(prefix "")
+  set(exec_prefix [[${prefix}]])
+  set(libdir [[${prefix}/lib]])
+  set(includedir [[${prefix}/include]])  
+  configure_file("${SOURCE_PATH}/libusb-1.0.pc.in" "${CURRENT_PACKAGES_DIR}/lib/pkgconfig/libusb-1.0.pc" @ONLY)
+  vcpkg_replace_string("${CURRENT_PACKAGES_DIR}/lib/pkgconfig/libusb-1.0.pc" " -lusb-1.0" " -llibusb-1.0")
+  if(NOT VCPKG_BUILD_TYPE)
+      set(includedir [[${prefix}/../include]])  
+      configure_file("${SOURCE_PATH}/libusb-1.0.pc.in" "${CURRENT_PACKAGES_DIR}/debug/lib/pkgconfig/libusb-1.0.pc" @ONLY)
+      vcpkg_replace_string("${CURRENT_PACKAGES_DIR}/debug/lib/pkgconfig/libusb-1.0.pc" " -lusb-1.0" " -llibusb-1.0")
+  endif()
+else()
+    vcpkg_list(SET MAKE_OPTIONS)
+    vcpkg_list(SET LIBUSB_LINK_LIBRARIES)
+    if(VCPKG_TARGET_IS_EMSCRIPTEN)
+        vcpkg_list(APPEND MAKE_OPTIONS BUILD_TRIPLET --host=wasm32)
+    endif()
+    if("udev" IN_LIST FEATURES)
+        vcpkg_list(APPEND MAKE_OPTIONS "--enable-udev")
+        vcpkg_list(APPEND LIBUSB_LINK_LIBRARIES udev)
+    else()
+        vcpkg_list(APPEND MAKE_OPTIONS "--disable-udev")
+    endif()
+    vcpkg_configure_make(
+        SOURCE_PATH "${SOURCE_PATH}"
+        AUTOCONFIG
+        OPTIONS 
+            ${MAKE_OPTIONS}
+            "--enable-examples-build=no"
+            "--enable-tests-build=no"
+    )
+    vcpkg_install_make()
+endif()
+
+vcpkg_fixup_pkgconfig()
+
+file(INSTALL "${CMAKE_CURRENT_LIST_DIR}/usage" DESTINATION "${CURRENT_PACKAGES_DIR}/share/${PORT}")
+vcpkg_install_copyright(FILE_LIST "${SOURCE_PATH}/COPYING")
diff --git a/dependencies/vcpkg_overlay_ports_mac/libusb/usage b/dependencies/vcpkg_overlay_ports_mac/libusb/usage
new file mode 100644
index 00000000..87e6e860
--- /dev/null
+++ b/dependencies/vcpkg_overlay_ports_mac/libusb/usage
@@ -0,0 +1,5 @@
+libusb can be imported via CMake FindPkgConfig module:
+    find_package(PkgConfig REQUIRED)
+    pkg_check_modules(libusb REQUIRED IMPORTED_TARGET libusb-1.0)
+
+    target_link_libraries(main PRIVATE PkgConfig::libusb)
diff --git a/dependencies/vcpkg_overlay_ports_mac/libusb/vcpkg.json b/dependencies/vcpkg_overlay_ports_mac/libusb/vcpkg.json
new file mode 100644
index 00000000..efc70f3d
--- /dev/null
+++ b/dependencies/vcpkg_overlay_ports_mac/libusb/vcpkg.json
@@ -0,0 +1,8 @@
+{
+  "name": "libusb",
+  "version": "1.0.26.11791",
+  "port-version": 7,
+  "description": "a cross-platform library to access USB devices",
+  "homepage": "https://github.com/libusb/libusb",
+  "license": "LGPL-2.1-or-later"
+}
diff --git a/dependencies/xbyak_aarch64 b/dependencies/xbyak_aarch64
new file mode 160000
index 00000000..904b8923
--- /dev/null
+++ b/dependencies/xbyak_aarch64
@@ -0,0 +1 @@
+Subproject commit 904b8923457f3ec0d6f82ea2d6832a792851194d
diff --git a/dist/linux/appimage.sh b/dist/linux/appimage.sh
new file mode 100755
index 00000000..b66326d7
--- /dev/null
+++ b/dist/linux/appimage.sh
@@ -0,0 +1,57 @@
+#!/bin/bash
+
+if [[ -z "${GITHUB_WORKSPACE}" ]]; then
+	export GITHUB_WORKSPACE="."
+fi
+
+curl -sSfLO "https://github.com/linuxdeploy/linuxdeploy/releases/download/continuous/linuxdeploy-x86_64.AppImage"
+chmod a+x linuxdeploy*.AppImage
+curl -sSfL https://github.com"$(curl https://github.com/probonopd/go-appimage/releases/expanded_assets/continuous | grep "mkappimage-.*-x86_64.AppImage" | head -n 1 | cut -d '"' -f 2)" -o mkappimage.AppImage
+chmod a+x mkappimage.AppImage
+curl -sSfLO "https://raw.githubusercontent.com/linuxdeploy/linuxdeploy-plugin-gtk/master/linuxdeploy-plugin-gtk.sh"
+chmod a+x linuxdeploy-plugin-gtk.sh
+curl -sSfLO "https://github.com/darealshinji/linuxdeploy-plugin-checkrt/releases/download/continuous/linuxdeploy-plugin-checkrt.sh"
+chmod a+x linuxdeploy-plugin-checkrt.sh
+
+if [[ ! -e /usr/lib/x86_64-linux-gnu ]]; then
+	sed -i 's#lib\/x86_64-linux-gnu#lib64#g' linuxdeploy-plugin-gtk.sh
+fi
+
+mkdir -p AppDir/usr/bin
+mkdir -p AppDir/usr/share/Cemu
+mkdir -p AppDir/usr/share/applications
+mkdir -p AppDir/usr/share/icons/hicolor/128x128/apps
+mkdir -p AppDir/usr/share/metainfo
+mkdir -p AppDir/usr/lib
+
+cp dist/linux/info.cemu.Cemu.{desktop,png} AppDir/
+cp dist/linux/info.cemu.Cemu.metainfo.xml AppDir/usr/share/metainfo/info.cemu.Cemu.appdata.xml
+
+cp -r bin/* AppDir/usr/share/Cemu
+
+mv AppDir/usr/share/Cemu/Cemu AppDir/usr/bin/
+chmod +x AppDir/usr/bin/Cemu
+
+cp /usr/lib/x86_64-linux-gnu/{libsepol.so.1,libffi.so.7,libpcre.so.3,libGLU.so.1,libthai.so.0} AppDir/usr/lib
+
+export UPD_INFO="gh-releases-zsync|cemu-project|Cemu|ci|Cemu.AppImage.zsync"
+export NO_STRIP=1
+./linuxdeploy-x86_64.AppImage --appimage-extract-and-run \
+  --appdir="${GITHUB_WORKSPACE}"/AppDir/ \
+  -d "${GITHUB_WORKSPACE}"/AppDir/info.cemu.Cemu.desktop \
+  -i "${GITHUB_WORKSPACE}"/AppDir/info.cemu.Cemu.png \
+  -e "${GITHUB_WORKSPACE}"/AppDir/usr/bin/Cemu \
+  --plugin gtk \
+  --plugin checkrt
+
+if ! GITVERSION="$(git rev-parse --short HEAD 2>/dev/null)"; then
+	GITVERSION=experimental
+fi
+echo "Cemu Version Cemu-${GITVERSION}"
+
+rm AppDir/usr/lib/libwayland-client.so.0
+echo -e "export LC_ALL=C\nexport FONTCONFIG_PATH=/etc/fonts" >> AppDir/apprun-hooks/linuxdeploy-plugin-gtk.sh
+VERSION="${GITVERSION}" ./mkappimage.AppImage --appimage-extract-and-run "${GITHUB_WORKSPACE}"/AppDir
+
+mkdir -p "${GITHUB_WORKSPACE}"/artifacts/
+mv Cemu-"${GITVERSION}"-x86_64.AppImage "${GITHUB_WORKSPACE}"/artifacts/
diff --git a/dist/linux/info.cemu.Cemu.desktop b/dist/linux/info.cemu.Cemu.desktop
index 1a25b665..6eeb0120 100644
--- a/dist/linux/info.cemu.Cemu.desktop
+++ b/dist/linux/info.cemu.Cemu.desktop
@@ -3,7 +3,7 @@ Name=Cemu
 Type=Application
 Terminal=false
 Icon=info.cemu.Cemu
-Exec=cemu
+Exec=Cemu
 GenericName=Wii U Emulator
 GenericName[fi]=Wii U -emulaattori
 GenericName[el]=Πρόγραμμα προσομοίωσης Wii U
@@ -24,3 +24,4 @@ Comment[it]=Software per emulare giochi e applicazioni per Wii U su PC
 Categories=Game;Emulator;
 Keywords=Nintendo;
 MimeType=application/x-wii-u-rom;
+StartupWMClass=Cemu
diff --git a/dist/linux/info.cemu.Cemu.metainfo.xml b/dist/linux/info.cemu.Cemu.metainfo.xml
index d270a8ab..ef59427f 100644
--- a/dist/linux/info.cemu.Cemu.metainfo.xml
+++ b/dist/linux/info.cemu.Cemu.metainfo.xml
@@ -3,15 +3,15 @@
   <!--Created with jdAppdataEdit 4.2-->
   <id>info.cemu.Cemu</id>
   <name>Cemu</name>
-  <summary>Software to emulate Wii U games and applications on PC</summary>
-  <summary xml:lang="de">Software zum emulieren von Wii U Spielen und Anwendungen auf dem PC</summary>
-  <summary xml:lang="fr">Application pour émuler des jeux et applications Wii U sur PC</summary>
-  <summary xml:lang="nl">Applicatie om Wii U spellen en applicaties te emuleren op PC</summary>
-  <summary xml:lang="el">Πρόγραμμα προσομοίωσης παιχνιδιών και εφαρμογών Wii U στον υπολογιστή</summary>
-  <summary xml:lang="es">Software para emular juegos y aplicaciones de Wii U en PC</summary>
-  <summary xml:lang="pt_BR">Software para emular jogos e aplicativos de Wii U no PC</summary>
-  <summary xml:lang="it">Software per emulare giochi e applicazioni per Wii U su PC</summary>
-  <summary xml:lang="fi">Ojelmisto Wii U -pelien ja -sovellusten emulointiin PC:llä</summary>
+  <summary>Nintendo Wii U Emulator</summary>
+  <summary xml:lang="de">Nintendo Wii U Emulator</summary>
+  <summary xml:lang="fr">Émulateur Nintendo Wii U</summary>
+  <summary xml:lang="nl">Nintendo Wii U Emulator</summary>
+  <summary xml:lang="el">Εξομοιωτής Nintendo Wii U</summary>
+  <summary xml:lang="es">Emulador de Nintendo Wii U</summary>
+  <summary xml:lang="pt_BR">Emulador Nintendo Wii U</summary>
+  <summary xml:lang="it">Emulatore Nintendo Wii U</summary>
+  <summary xml:lang="fi">Nintendo Wii U Emulaattori</summary>
   <developer_name>Cemu Project</developer_name>
   <launchable type="desktop-id">info.cemu.Cemu.desktop</launchable>
   <metadata_license>CC0-1.0</metadata_license>
@@ -52,7 +52,7 @@
     </screenshot>
   </screenshots>
   <releases>
-    <release version="v2.0" date="2022-08-22" type="stable">
+    <release version="2.0" date="2022-08-22" type="stable">
       <url>https://github.com/cemu-project/Cemu/releases/tag/v2.0</url>
     </release>
   </releases>
@@ -60,14 +60,11 @@
   <url type="bugtracker">https://github.com/cemu-project/Cemu/issues</url>
   <url type="faq">https://cemu.info/faq.html</url>
   <url type="help">https://wiki.cemu.info</url>
-  <url type="vcs-browser">https://github.com/cemu-project/Cemu</url>
+  <!-- <url type="vcs-browser">https://github.com/cemu-project/Cemu</url> -->
   <categories>
     <category>Game</category>
     <category>Emulator</category>
   </categories>
-  <requires>
-    <memory>4096</memory>
-  </requires>
   <recommends>
     <memory>8192</memory>
   </recommends>
diff --git a/dist/linux/info.cemu.Cemu.png b/dist/linux/info.cemu.Cemu.png
new file mode 100644
index 00000000..6f655072
Binary files /dev/null and b/dist/linux/info.cemu.Cemu.png differ
diff --git a/dist/network_services.xml b/dist/network_services.xml
new file mode 100644
index 00000000..0c0f2e3e
--- /dev/null
+++ b/dist/network_services.xml
@@ -0,0 +1,17 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<content>
+    <networkname>CustomExample</networkname>
+    <disablesslverification>0</disablesslverification>
+    <urls>
+        <act>https://account.nintendo.net</act>
+        <ecs>https://ecs.wup.shop.nintendo.net/ecs/services/ECommerceSOAP</ecs>
+        <nus>https://nus.wup.shop.nintendo.net/nus/services/NetUpdateSOAP</nus>
+        <ias>https://ias.wup.shop.nintendo.net/ias/services/IdentityAuthenticationSOAP</ias>
+        <ccsu>https://ccs.wup.shop.nintendo.net/ccs/download</ccsu>
+        <ccs>http://ccs.cdn.wup.shop.nintendo.net/ccs/download</ccs>
+        <idbe>https://idbe-wup.cdn.nintendo.net/icondata</idbe>
+        <boss>https://npts.app.nintendo.net/p01/tasksheet</boss>
+        <tagaya>https://tagaya.wup.shop.nintendo.net/tagaya/versionlist</tagaya>
+        <olv>https://discovery.olv.nintendo.net/v1/endpoint</olv>
+    </urls>
+</content>
\ No newline at end of file
diff --git a/dist/windows/Cemu.manifest b/dist/windows/Cemu.manifest
new file mode 100644
index 00000000..5ff952b1
--- /dev/null
+++ b/dist/windows/Cemu.manifest
@@ -0,0 +1,16 @@
+<?xml version="1.0" encoding="UTF-8" standalone="yes"?>
+<assembly xmlns="urn:schemas-microsoft-com:asm.v1" manifestVersion="1.0">
+    <dependency>
+        <dependentAssembly>
+            <assemblyIdentity type="win32" name="Microsoft.Windows.Common-Controls" version="6.0.0.0" processorArchitecture="amd64" publicKeyToken="6595b64144ccf1df" language="*"></assemblyIdentity>
+        </dependentAssembly>
+    </dependency>
+    <trustInfo xmlns="urn:schemas-microsoft-com:asm.v3"><security><requestedPrivileges>
+        <requestedExecutionLevel level="asInvoker" uiAccess="false"></requestedExecutionLevel></requestedPrivileges></security>
+    </trustInfo>
+    <application xmlns="urn:schemas-microsoft-com:asm.v3">
+        <windowsSettings>
+            <dpiAware xmlns="http://schemas.microsoft.com/SMI/2005/WindowsSettings">True/PM</dpiAware>
+        </windowsSettings>
+    </application>
+</assembly>
\ No newline at end of file
diff --git a/generate_vs_solution.bat b/generate_vs_solution.bat
deleted file mode 100644
index 21060027..00000000
--- a/generate_vs_solution.bat
+++ /dev/null
@@ -1,2 +0,0 @@
-"C:\PROGRAM FILES\MICROSOFT VISUAL STUDIO\2022\COMMUNITY\COMMON7\IDE\COMMONEXTENSIONS\MICROSOFT\CMAKE\CMake\bin\cmake.exe" -B build/
-pause
\ No newline at end of file
diff --git a/src/CMakeLists.txt b/src/CMakeLists.txt
index d3bf8aec..04b6dfdd 100644
--- a/src/CMakeLists.txt
+++ b/src/CMakeLists.txt
@@ -11,11 +11,6 @@ endif()
 
 if(MSVC)
 	add_compile_definitions(WIN32_LEAN_AND_MEAN CURL_STATICLIB)
-	#add_compile_definitions(VK_USE_PLATFORM_WIN32_KHR)
-	# _CRT_SECURE_NO_WARNINGS
-	# _WINSOCK_DEPRECATED_NO_WARNINGS
-	# _SILENCE_CXX17_CODECVT_HEADER_DEPRECATION_WARNING
-	# _SILENCE_ALL_CXX17_DEPRECATION_WARNINGS
 elseif(UNIX)
 	if(APPLE)
 		add_compile_definitions(
@@ -28,8 +23,10 @@ elseif(UNIX)
 			VK_USE_PLATFORM_XLIB_KHR # legacy. Do we need to support XLIB surfaces?
 			VK_USE_PLATFORM_XCB_KHR
 		)
+		if (ENABLE_WAYLAND)
+			add_compile_definitions(VK_USE_PLATFORM_WAYLAND_KHR)
+		endif()
 	endif()
-	add_compile_options(-maes)
 	# warnings
 	if(CMAKE_C_COMPILER_ID STREQUAL "Clang")
 		add_compile_options(-Wno-ambiguous-reversed-operator)
@@ -52,33 +49,84 @@ add_subdirectory(audio)
 add_subdirectory(util)
 add_subdirectory(imgui)
 add_subdirectory(resource)
-add_subdirectory(asm)
 
-if(PUBLIC_RELEASE)
-	add_executable(CemuBin WIN32
-		main.cpp
-		mainLLE.cpp
-	)
-else()
-	add_executable(CemuBin
-		main.cpp
-		mainLLE.cpp
-	)
+add_executable(CemuBin
+	main.cpp
+	mainLLE.cpp
+)
+
+if(MSVC AND MSVC_VERSION EQUAL 1940)
+	# workaround for an msvc issue on VS 17.10 where generated ILK files are too large
+	# see https://developercommunity.visualstudio.com/t/After-updating-to-VS-1710-the-size-of-/10665511
+	set_target_properties(CemuBin PROPERTIES LINK_FLAGS "/INCREMENTAL:NO")
 endif()
 
 if(WIN32)
 	target_sources(CemuBin PRIVATE
 	resource/cemu.rc
-)
+	../dist/windows/cemu.manifest
+	)
 endif()
 
 set_property(TARGET CemuBin PROPERTY MSVC_RUNTIME_LIBRARY "MultiThreaded$<$<CONFIG:Debug>:Debug>")
+set_property(TARGET CemuBin PROPERTY WIN32_EXECUTABLE $<NOT:$<CONFIG:Debug>>)
+set(OUTPUT_NAME "Cemu_$<LOWER_CASE:$<CONFIG>>")
+
+if (MACOS_BUNDLE)
+	set_property(TARGET CemuBin PROPERTY MACOSX_BUNDLE_INFO_PLIST "${CMAKE_CURRENT_SOURCE_DIR}/resource/MacOSXBundleInfo.plist.in")
+
+	set(RESOURCE_FILES "${CMAKE_SOURCE_DIR}/src/resource/cemu.icns")
+	target_sources(CemuBin PRIVATE "${RESOURCE_FILES}")
+
+	set(MACOSX_BUNDLE_ICON_FILE "cemu.icns")
+	set(MACOSX_BUNDLE_GUI_IDENTIFIER "info.cemu.Cemu")
+	set(MACOSX_BUNDLE_BUNDLE_NAME "Cemu")
+	set(MACOSX_BUNDLE_SHORT_VERSION_STRING "${EMULATOR_VERSION_MAJOR}.${EMULATOR_VERSION_MINOR}.${EMULATOR_VERSION_PATCH}")
+	set(MACOSX_BUNDLE_BUNDLE_VERSION "${EMULATOR_VERSION_MAJOR}.${EMULATOR_VERSION_MINOR}.${EMULATOR_VERSION_PATCH}")
+	set(MACOSX_BUNDLE_COPYRIGHT "Copyright © 2024 Cemu Project")
+
+	set(MACOSX_BUNDLE_CATEGORY "public.app-category.games")
+ 	set(MACOSX_MINIMUM_SYSTEM_VERSION "12.0")
+  	set(MACOSX_BUNDLE_TYPE_EXTENSION "wua")
+
+	set_target_properties(CemuBin PROPERTIES
+		MACOSX_BUNDLE true
+		RESOURCE "${RESOURCE_FILES}"
+	)
+
+	set(FOLDERS gameProfiles resources)
+	foreach(folder ${FOLDERS})
+		add_custom_command (TARGET CemuBin POST_BUILD
+			COMMAND ${CMAKE_COMMAND} ARGS -E copy_directory "${CMAKE_SOURCE_DIR}/bin/${folder}" "${CMAKE_SOURCE_DIR}/bin/${OUTPUT_NAME}.app/Contents/SharedSupport/${folder}")
+	endforeach(folder)
+
+	if(CMAKE_BUILD_TYPE STREQUAL "Debug")
+	    set(LIBUSB_PATH "${CMAKE_BINARY_DIR}/vcpkg_installed/${VCPKG_TARGET_TRIPLET}/debug/lib/libusb-1.0.0.dylib")
+	else()
+	    set(LIBUSB_PATH "${CMAKE_BINARY_DIR}/vcpkg_installed/${VCPKG_TARGET_TRIPLET}/lib/libusb-1.0.0.dylib")
+	endif()
+
+	if (EXISTS "/usr/local/lib/libMoltenVK.dylib")
+		set(MOLTENVK_PATH "/usr/local/lib/libMoltenVK.dylib")
+	elseif (EXISTS "/opt/homebrew/lib/libMoltenVK.dylib")
+		set(MOLTENVK_PATH "/opt/homebrew/lib/libMoltenVK.dylib")
+	else()
+		message(FATAL_ERROR "failed to find libMoltenVK.dylib")
+	endif ()
+
+	add_custom_command (TARGET CemuBin POST_BUILD
+		COMMAND ${CMAKE_COMMAND} ARGS -E copy "${MOLTENVK_PATH}" "${CMAKE_SOURCE_DIR}/bin/${OUTPUT_NAME}.app/Contents/Frameworks/libMoltenVK.dylib"
+		COMMAND ${CMAKE_COMMAND} ARGS -E copy "${LIBUSB_PATH}" "${CMAKE_SOURCE_DIR}/bin/${OUTPUT_NAME}.app/Contents/Frameworks/libusb-1.0.0.dylib"
+		COMMAND ${CMAKE_COMMAND} ARGS -E copy "${CMAKE_SOURCE_DIR}/src/resource/update.sh" "${CMAKE_SOURCE_DIR}/bin/${OUTPUT_NAME}.app/Contents/MacOS/update.sh"
+		COMMAND bash -c "install_name_tool -add_rpath @executable_path/../Frameworks ${CMAKE_SOURCE_DIR}/bin/${OUTPUT_NAME}.app/Contents/MacOS/${OUTPUT_NAME}"
+		COMMAND bash -c "install_name_tool -change ${LIBUSB_PATH} @executable_path/../Frameworks/libusb-1.0.0.dylib ${CMAKE_SOURCE_DIR}/bin/${OUTPUT_NAME}.app/Contents/MacOS/${OUTPUT_NAME}")
+endif()
 
 set_target_properties(CemuBin PROPERTIES
 	# multi-configuration generators will add a config subdirectory to RUNTIME_OUTPUT_DIRECTORY if no generator expression is used
 	# to get the same behavior everywhere we append an empty generator expression
 	RUNTIME_OUTPUT_DIRECTORY "${CMAKE_CURRENT_SOURCE_DIR}/../bin/$<1:>"
-	OUTPUT_NAME "Cemu_$<LOWER_CASE:$<CONFIG>>"
+	OUTPUT_NAME "${OUTPUT_NAME}"
 )
 
 target_link_libraries(CemuBin PRIVATE
@@ -94,6 +142,15 @@ target_link_libraries(CemuBin PRIVATE
 	SDL2::SDL2
 )
 
+if(UNIX AND NOT APPLE)
+	# due to nasm output some linkers will make stack executable
+	# cemu does not require this so we explicity disable it
+	target_link_options(CemuBin PRIVATE -z noexecstack)
+	# some residual debug info from boost/discord-rpc is normally included
+	# most likely not helpful in debugging problems with cemu code
+	target_link_options(CemuBin PRIVATE "$<$<CONFIG:Release>:-Xlinker;--strip-debug>")
+endif()
+
 if (ENABLE_WXWIDGETS)
 	target_link_libraries(CemuBin PRIVATE wx::base wx::core)
 endif()
diff --git a/src/Cafe/Account/Account.cpp b/src/Cafe/Account/Account.cpp
index 2cf424f1..d022b604 100644
--- a/src/Cafe/Account/Account.cpp
+++ b/src/Cafe/Account/Account.cpp
@@ -1,14 +1,13 @@
 #include "Account.h"
 #include "util/helpers/helpers.h"
-#include "gui/CemuApp.h"
 #include "util/helpers/SystemException.h"
-
+#include "util/helpers/StringHelpers.h"
 #include "config/ActiveSettings.h"
 #include "Cafe/IOSU/legacy/iosu_crypto.h"
 #include "Common/FileStream.h"
+#include <boost/random/uniform_int.hpp>
 
 #include <random>
-#include <boost/random/uniform_int.hpp>
 
 std::vector<Account> Account::s_account_list;
 
@@ -168,14 +167,14 @@ std::error_code Account::Load()
 	}
 	catch(const std::exception& ex)
 	{
-		forceLog_printf("handled error in Account::Load: %s", ex.what());
+		cemuLog_log(LogType::Force, "handled error in Account::Load: {}", ex.what());
 		return AccountErrc::ParseError;
 	}
 }
 
 std::error_code Account::Save()
 {
-	fs::path path = CemuApp::GetMLCPath(fmt::format(L"usr/save/system/act/{:08x}", m_persistent_id)).ToStdWstring();
+	fs::path path = ActiveSettings::GetMlcPath(fmt::format(L"usr/save/system/act/{:08x}", m_persistent_id));
 	if (!fs::exists(path))
 	{
 		std::error_code ec;
@@ -184,7 +183,7 @@ std::error_code Account::Save()
 			return ec;
 	}
 		
-	path /= L"account.dat";
+	path /= "account.dat";
 
 	try
 	{
@@ -302,7 +301,7 @@ void Account::SetMiiName(std::wstring_view name)
 const std::vector<Account>& Account::RefreshAccounts()
 {
 	std::vector<Account> result;
-	const fs::path path = CemuApp::GetMLCPath(L"usr/save/system/act").ToStdWstring();
+	const fs::path path = ActiveSettings::GetMlcPath("usr/save/system/act");
 	if (fs::exists(path))
 	{
 		for (const auto& it : fs::directory_iterator(path))
@@ -349,7 +348,7 @@ void Account::UpdatePersisidDat()
 		f.close();
 	}
 	else
-		forceLog_printf("Unable to save persisid.dat");
+		cemuLog_log(LogType::Force, "Unable to save persisid.dat");
 }
 
 bool Account::HasFreeAccountSlots()
@@ -417,14 +416,14 @@ fs::path Account::GetFileName(uint32 persistent_id)
 	if (persistent_id < kMinPersistendId)
 		throw std::invalid_argument(fmt::format("persistent id {:#x} is invalid", persistent_id));
 	
-	return CemuApp::GetMLCPath(fmt::format(L"usr/save/system/act/{:08x}/account.dat", persistent_id)).ToStdWstring();
+	return ActiveSettings::GetMlcPath(fmt::format("usr/save/system/act/{:08x}/account.dat", persistent_id));
 }
 
 OnlineValidator Account::ValidateOnlineFiles() const
 {
 	OnlineValidator result{};
 	
-	const auto otp = ActiveSettings::GetPath("otp.bin");
+	const auto otp = ActiveSettings::GetUserDataPath("otp.bin");
 	if (!fs::exists(otp))
 		result.otp = OnlineValidator::FileState::Missing;
 	else if (fs::file_size(otp) != 1024)
@@ -432,7 +431,7 @@ OnlineValidator Account::ValidateOnlineFiles() const
 	else
 		result.otp = OnlineValidator::FileState::Ok;
 	
-	const auto seeprom = ActiveSettings::GetPath("seeprom.bin");
+	const auto seeprom = ActiveSettings::GetUserDataPath("seeprom.bin");
 	if (!fs::exists(seeprom))
 		result.seeprom = OnlineValidator::FileState::Missing;
 	else if (fs::file_size(seeprom) != 512)
@@ -462,15 +461,14 @@ OnlineValidator Account::ValidateOnlineFiles() const
 
 void Account::ParseFile(class FileStream* file)
 {
-	std::vector<std::string> buffer;
-	
-	std::string tmp;
-	while (file->readLine(tmp))
-		buffer.emplace_back(tmp);
-	for (const auto& s : buffer)
+	std::vector<uint8> buffer;
+	buffer.resize(file->GetSize());
+	if( file->readData(buffer.data(), buffer.size()) != buffer.size())
+		throw std::system_error(AccountErrc::ParseError);
+	for (const auto& s : StringHelpers::StringLineIterator(buffer))
 	{
 		std::string_view view = s;
-		const auto find = view.find(L'=');
+		const auto find = view.find('=');
 		if (find == std::string_view::npos)
 			continue;
 
diff --git a/src/Cafe/Account/Account.h b/src/Cafe/Account/Account.h
index 63eb5082..da196e42 100644
--- a/src/Cafe/Account/Account.h
+++ b/src/Cafe/Account/Account.h
@@ -16,22 +16,6 @@ enum class OnlineAccountError
 	kPasswordCacheEmpty,
 	kNoPrincipalId,
 };
-template <>
-struct fmt::formatter<OnlineAccountError> : formatter<string_view> {
-	template <typename FormatContext>
-	auto format(const OnlineAccountError v, FormatContext& ctx) {
-		switch (v)
-		{
-		case OnlineAccountError::kNoAccountId: return formatter<string_view>::format("AccountId missing (The account is not connected to a NNID)", ctx);
-		case OnlineAccountError::kNoPasswordCached: return formatter<string_view>::format("IsPasswordCacheEnabled is set to false (The remember password option on your Wii U must be enabled for this account before dumping it)", ctx);
-		case OnlineAccountError::kPasswordCacheEmpty: return formatter<string_view>::format("AccountPasswordCache is empty (The remember password option on your Wii U must be enabled for this account before dumping it)", ctx);
-		case OnlineAccountError::kNoPrincipalId: return formatter<string_view>::format("PrincipalId missing", ctx);
-		default: break;
-		}
-		return formatter<string_view>::format("no error", ctx);
-	}
-};
-
 
 struct OnlineValidator
 {
diff --git a/src/Cafe/CMakeLists.txt b/src/Cafe/CMakeLists.txt
index c012f18a..2900059b 100644
--- a/src/Cafe/CMakeLists.txt
+++ b/src/Cafe/CMakeLists.txt
@@ -1,21 +1,561 @@
-project(CemuCafe)
-
-file(GLOB_RECURSE CPP_FILES *.cpp)
-file(GLOB_RECURSE H_FILES *.h)
+add_library(CemuCafe
+  Account/Account.cpp
+  Account/AccountError.h
+  Account/Account.h
+  CafeSystem.cpp
+  CafeSystem.h
+  Filesystem/fsc.cpp
+  Filesystem/fscDeviceHostFS.cpp
+  Filesystem/fscDeviceHostFS.h
+  Filesystem/fscDeviceRedirect.cpp
+  Filesystem/fscDeviceWua.cpp
+  Filesystem/fscDeviceWud.cpp
+  Filesystem/fscDeviceWuhb.cpp
+  Filesystem/fsc.h
+  Filesystem/FST/FST.cpp
+  Filesystem/FST/FST.h
+  Filesystem/FST/fstUtil.h
+  Filesystem/FST/KeyCache.cpp
+  Filesystem/FST/KeyCache.h
+  Filesystem/WUD/wud.cpp
+  Filesystem/WUD/wud.h
+  Filesystem/WUHB/RomFSStructs.h
+  Filesystem/WUHB/WUHBReader.cpp
+  Filesystem/WUHB/WUHBReader.h
+  GamePatch.cpp
+  GamePatch.h
+  GameProfile/GameProfile.cpp
+  GameProfile/GameProfile.h
+  GraphicPack/GraphicPack2.cpp
+  GraphicPack/GraphicPack2.h
+  GraphicPack/GraphicPack2PatchesApply.cpp
+  GraphicPack/GraphicPack2Patches.cpp
+  GraphicPack/GraphicPack2Patches.h
+  GraphicPack/GraphicPack2PatchesParser.cpp
+  GraphicPack/GraphicPackError.h
+  HW/ACR/ACR.cpp
+  HW/AI/AI.cpp
+  HW/AI/AI.h
+  HW/Common/HwReg.h
+  HW/Espresso/Const.h
+  HW/Espresso/Debugger/Debugger.cpp
+  HW/Espresso/Debugger/Debugger.h
+  HW/Espresso/Debugger/DebugSymbolStorage.cpp
+  HW/Espresso/Debugger/DebugSymbolStorage.h
+  HW/Espresso/Debugger/GDBStub.h
+  HW/Espresso/Debugger/GDBStub.cpp
+  HW/Espresso/Debugger/GDBBreakpoints.cpp
+  HW/Espresso/Debugger/GDBBreakpoints.h
+  HW/Espresso/EspressoISA.h
+  HW/Espresso/Interpreter/PPCInterpreterALU.hpp
+  HW/Espresso/Interpreter/PPCInterpreterFPU.cpp
+  HW/Espresso/Interpreter/PPCInterpreterHelper.h
+  HW/Espresso/Interpreter/PPCInterpreterHLE.cpp
+  HW/Espresso/Interpreter/PPCInterpreterImpl.cpp
+  HW/Espresso/Interpreter/PPCInterpreterInternal.h
+  HW/Espresso/Interpreter/PPCInterpreterLoadStore.hpp
+  HW/Espresso/Interpreter/PPCInterpreterMain.cpp
+  HW/Espresso/Interpreter/PPCInterpreterOPC.cpp
+  HW/Espresso/Interpreter/PPCInterpreterOPC.hpp
+  HW/Espresso/Interpreter/PPCInterpreterPS.cpp
+  HW/Espresso/Interpreter/PPCInterpreterSPR.hpp
+  HW/Espresso/PPCCallback.h
+  HW/Espresso/PPCScheduler.cpp
+  HW/Espresso/PPCSchedulerLLE.cpp
+  HW/Espresso/PPCState.h
+  HW/Espresso/PPCTimer.cpp
+  HW/Espresso/Recompiler/PPCFunctionBoundaryTracker.h
+  HW/Espresso/Recompiler/PPCRecompiler.cpp
+  HW/Espresso/Recompiler/PPCRecompiler.h
+  HW/Espresso/Recompiler/IML/IML.h
+  HW/Espresso/Recompiler/IML/IMLSegment.cpp
+  HW/Espresso/Recompiler/IML/IMLSegment.h
+  HW/Espresso/Recompiler/IML/IMLInstruction.cpp
+  HW/Espresso/Recompiler/IML/IMLInstruction.h
+  HW/Espresso/Recompiler/IML/IMLDebug.cpp
+  HW/Espresso/Recompiler/IML/IMLAnalyzer.cpp
+  HW/Espresso/Recompiler/IML/IMLOptimizer.cpp
+  HW/Espresso/Recompiler/IML/IMLRegisterAllocator.cpp
+  HW/Espresso/Recompiler/IML/IMLRegisterAllocator.h
+  HW/Espresso/Recompiler/IML/IMLRegisterAllocatorRanges.cpp
+  HW/Espresso/Recompiler/IML/IMLRegisterAllocatorRanges.h
+  HW/Espresso/Recompiler/PPCRecompilerImlGen.cpp
+  HW/Espresso/Recompiler/PPCRecompilerImlGenFPU.cpp
+  HW/Espresso/Recompiler/PPCRecompilerIml.h
+  HW/Espresso/Recompiler/PPCRecompilerIntermediate.cpp
+  HW/Espresso/Recompiler/BackendX64/BackendX64AVX.cpp
+  HW/Espresso/Recompiler/BackendX64/BackendX64BMI.cpp
+  HW/Espresso/Recompiler/BackendX64/BackendX64.cpp
+  HW/Espresso/Recompiler/BackendX64/BackendX64FPU.cpp
+  HW/Espresso/Recompiler/BackendX64/BackendX64Gen.cpp
+  HW/Espresso/Recompiler/BackendX64/BackendX64GenFPU.cpp
+  HW/Espresso/Recompiler/BackendX64/BackendX64.h
+  HW/Espresso/Recompiler/BackendX64/X64Emit.hpp
+  HW/Espresso/Recompiler/BackendX64/x86Emitter.h
+  HW/Latte/Common/RegisterSerializer.cpp
+  HW/Latte/Common/RegisterSerializer.h
+  HW/Latte/Common/ShaderSerializer.cpp
+  HW/Latte/Common/ShaderSerializer.h
+  HW/Latte/Core/FetchShader.cpp
+  HW/Latte/Core/FetchShader.h
+  HW/Latte/Core/LatteAsyncCommands.cpp
+  HW/Latte/Core/LatteAsyncCommands.h
+  HW/Latte/Core/LatteBufferCache.cpp
+  HW/Latte/Core/LatteBufferCache.h
+  HW/Latte/Core/LatteBufferData.cpp
+  HW/Latte/Core/LatteCachedFBO.h
+  HW/Latte/Core/LatteCommandProcessor.cpp
+  HW/Latte/Core/LatteConst.h
+  HW/Latte/Core/LatteDefaultShaders.cpp
+  HW/Latte/Core/LatteDefaultShaders.h
+  HW/Latte/Core/LatteDraw.h
+  HW/Latte/Core/LatteGSCopyShaderParser.cpp
+  HW/Latte/Core/Latte.h
+  HW/Latte/Core/LatteIndices.cpp
+  HW/Latte/Core/LatteIndices.h
+  HW/Latte/Core/LatteOverlay.cpp
+  HW/Latte/Core/LatteOverlay.h
+  HW/Latte/Core/LattePerformanceMonitor.cpp
+  HW/Latte/Core/LattePerformanceMonitor.h
+  HW/Latte/Core/LattePM4.h
+  HW/Latte/Core/LatteQuery.cpp
+  HW/Latte/Core/LatteQueryObject.h
+  HW/Latte/Core/LatteRenderTarget.cpp
+  HW/Latte/Core/LatteRingBuffer.cpp
+  HW/Latte/Core/LatteRingBuffer.h
+  HW/Latte/Core/LatteShaderAssembly.h
+  HW/Latte/Core/LatteShaderCache.cpp
+  HW/Latte/Core/LatteShaderCache.h
+  HW/Latte/Core/LatteShader.cpp
+  HW/Latte/Core/LatteShaderGL.cpp
+  HW/Latte/Core/LatteShader.h
+  HW/Latte/Core/LatteSoftware.cpp
+  HW/Latte/Core/LatteSoftware.h
+  HW/Latte/Core/LatteStreamoutGPU.cpp
+  HW/Latte/Core/LatteSurfaceCopy.cpp
+  HW/Latte/Core/LatteTextureCache.cpp
+  HW/Latte/Core/LatteTexture.cpp
+  HW/Latte/Core/LatteTexture.h
+  HW/Latte/Core/LatteTextureLegacy.cpp
+  HW/Latte/Core/LatteTextureLoader.cpp
+  HW/Latte/Core/LatteTextureLoader.h
+  HW/Latte/Core/LatteTextureReadback.cpp
+  HW/Latte/Core/LatteTextureReadbackInfo.h
+  HW/Latte/Core/LatteTextureView.cpp
+  HW/Latte/Core/LatteTextureView.h
+  HW/Latte/Core/LatteThread.cpp
+  HW/Latte/Core/LatteTiming.cpp
+  HW/Latte/Core/LatteTiming.h
+  HW/Latte/ISA/LatteInstructions.h
+  HW/Latte/ISA/LatteReg.h
+  HW/Latte/ISA/RegDefines.h
+  HW/Latte/LatteAddrLib/AddrLibFastDecode.h
+  HW/Latte/LatteAddrLib/LatteAddrLib_Coord.cpp
+  HW/Latte/LatteAddrLib/LatteAddrLib.cpp
+  HW/Latte/LatteAddrLib/LatteAddrLib.h
+  HW/Latte/LegacyShaderDecompiler/LatteDecompilerAnalyzer.cpp
+  HW/Latte/LegacyShaderDecompiler/LatteDecompiler.cpp
+  HW/Latte/LegacyShaderDecompiler/LatteDecompilerEmitGLSLAttrDecoder.cpp
+  HW/Latte/LegacyShaderDecompiler/LatteDecompilerEmitGLSL.cpp
+  HW/Latte/LegacyShaderDecompiler/LatteDecompilerEmitGLSLHeader.hpp
+  HW/Latte/LegacyShaderDecompiler/LatteDecompiler.h
+  HW/Latte/LegacyShaderDecompiler/LatteDecompilerInstructions.h
+  HW/Latte/LegacyShaderDecompiler/LatteDecompilerInternal.h
+  HW/Latte/LegacyShaderDecompiler/LatteDecompilerRegisterDataTypeTracker.cpp
+  HW/Latte/Renderer/OpenGL/CachedFBOGL.h
+  HW/Latte/Renderer/OpenGL/LatteTextureGL.cpp
+  HW/Latte/Renderer/OpenGL/LatteTextureGL.h
+  HW/Latte/Renderer/OpenGL/LatteTextureViewGL.cpp
+  HW/Latte/Renderer/OpenGL/LatteTextureViewGL.h
+  HW/Latte/Renderer/OpenGL/OpenGLQuery.cpp
+  HW/Latte/Renderer/OpenGL/OpenGLRendererCore.cpp
+  HW/Latte/Renderer/OpenGL/OpenGLRenderer.cpp
+  HW/Latte/Renderer/OpenGL/OpenGLRenderer.h
+  HW/Latte/Renderer/OpenGL/OpenGLRendererStreamout.cpp
+  HW/Latte/Renderer/OpenGL/OpenGLRendererUniformData.cpp
+  HW/Latte/Renderer/OpenGL/OpenGLSurfaceCopy.cpp
+  HW/Latte/Renderer/OpenGL/OpenGLTextureReadback.h
+  HW/Latte/Renderer/OpenGL/RendererShaderGL.cpp
+  HW/Latte/Renderer/OpenGL/RendererShaderGL.h
+  HW/Latte/Renderer/OpenGL/TextureReadbackGL.cpp
+  HW/Latte/Renderer/Renderer.cpp
+  HW/Latte/Renderer/Renderer.h
+  HW/Latte/Renderer/RendererOuputShader.cpp
+  HW/Latte/Renderer/RendererOuputShader.h
+  HW/Latte/Renderer/RendererShader.cpp
+  HW/Latte/Renderer/RendererShader.h
+  HW/Latte/Renderer/Vulkan/CachedFBOVk.cpp
+  HW/Latte/Renderer/Vulkan/CachedFBOVk.h
+  HW/Latte/Renderer/Vulkan/CocoaSurface.h
+  HW/Latte/Renderer/Vulkan/LatteTextureViewVk.cpp
+  HW/Latte/Renderer/Vulkan/LatteTextureViewVk.h
+  HW/Latte/Renderer/Vulkan/LatteTextureVk.cpp
+  HW/Latte/Renderer/Vulkan/LatteTextureVk.h
+  HW/Latte/Renderer/Vulkan/RendererShaderVk.cpp
+  HW/Latte/Renderer/Vulkan/RendererShaderVk.h
+  HW/Latte/Renderer/Vulkan/SwapchainInfoVk.cpp
+  HW/Latte/Renderer/Vulkan/SwapchainInfoVk.h
+  HW/Latte/Renderer/Vulkan/TextureReadbackVk.cpp
+  HW/Latte/Renderer/Vulkan/VKRBase.h
+  HW/Latte/Renderer/Vulkan/VKRMemoryManager.cpp
+  HW/Latte/Renderer/Vulkan/VKRMemoryManager.h
+  HW/Latte/Renderer/Vulkan/VKRPipelineInfo.cpp
+  HW/Latte/Renderer/Vulkan/VsyncDriver.cpp
+  HW/Latte/Renderer/Vulkan/VsyncDriver.h
+  HW/Latte/Renderer/Vulkan/VulkanAPI.cpp
+  HW/Latte/Renderer/Vulkan/VulkanAPI.h
+  HW/Latte/Renderer/Vulkan/VulkanPipelineCompiler.cpp
+  HW/Latte/Renderer/Vulkan/VulkanPipelineCompiler.h
+  HW/Latte/Renderer/Vulkan/VulkanPipelineStableCache.cpp
+  HW/Latte/Renderer/Vulkan/VulkanPipelineStableCache.h
+  HW/Latte/Renderer/Vulkan/VulkanQuery.cpp
+  HW/Latte/Renderer/Vulkan/VulkanRendererCore.cpp
+  HW/Latte/Renderer/Vulkan/VulkanRenderer.cpp
+  HW/Latte/Renderer/Vulkan/VulkanRenderer.h
+  HW/Latte/Renderer/Vulkan/VulkanSurfaceCopy.cpp
+  HW/Latte/Renderer/Vulkan/VulkanTextureReadback.h
+  HW/Latte/ShaderInfo/ShaderDescription.cpp
+  HW/Latte/ShaderInfo/ShaderInfo.h
+  HW/Latte/ShaderInfo/ShaderInstanceInfo.cpp
+  HW/Latte/Transcompiler/LatteTC.cpp
+  HW/Latte/Transcompiler/LatteTCGenIR.cpp
+  HW/Latte/Transcompiler/LatteTC.h
+  HW/MMU/MMU.cpp
+  HW/MMU/MMU.h
+  HW/SI/SI.cpp
+  HW/SI/si.h
+  HW/VI/VI.cpp
+  IOSU/ccr_nfc/iosu_ccr_nfc.cpp
+  IOSU/ccr_nfc/iosu_ccr_nfc.h
+  IOSU/fsa/fsa_types.h
+  IOSU/fsa/iosu_fsa.cpp
+  IOSU/fsa/iosu_fsa.h
+  IOSU/iosu_ipc_common.h
+  IOSU/iosu_types_common.h
+  IOSU/kernel/iosu_kernel.cpp
+  IOSU/kernel/iosu_kernel.h
+  IOSU/legacy/iosu_acp.cpp
+  IOSU/legacy/iosu_acp.h
+  IOSU/legacy/iosu_act.cpp
+  IOSU/legacy/iosu_act.h
+  IOSU/legacy/iosu_boss.cpp
+  IOSU/legacy/iosu_boss.h
+  IOSU/legacy/iosu_crypto.cpp
+  IOSU/legacy/iosu_crypto.h
+  IOSU/legacy/iosu_fpd.cpp
+  IOSU/legacy/iosu_fpd.h
+  IOSU/legacy/iosu_ioctl.cpp
+  IOSU/legacy/iosu_ioctl.h
+  IOSU/legacy/iosu_mcp.cpp
+  IOSU/legacy/iosu_mcp.h
+  IOSU/legacy/iosu_nim.cpp
+  IOSU/legacy/iosu_nim.h
+  IOSU/nn/iosu_nn_service.cpp
+  IOSU/nn/iosu_nn_service.h
+  IOSU/PDM/iosu_pdm.cpp
+  IOSU/PDM/iosu_pdm.h
+  IOSU/ODM/iosu_odm.cpp
+  IOSU/ODM/iosu_odm.h
+  OS/common/OSCommon.cpp
+  OS/common/OSCommon.h
+  OS/common/OSUtil.h
+  OS/common/PPCConcurrentQueue.h
+  OS/libs/avm/avm.cpp
+  OS/libs/avm/avm.h
+  OS/libs/camera/camera.cpp
+  OS/libs/camera/camera.h
+  OS/libs/coreinit/coreinit_Alarm.cpp
+  OS/libs/coreinit/coreinit_Alarm.h
+  OS/libs/coreinit/coreinit_Atomic.cpp
+  OS/libs/coreinit/coreinit_Atomic.h
+  OS/libs/coreinit/coreinit_BSP.cpp
+  OS/libs/coreinit/coreinit_BSP.h
+  OS/libs/coreinit/coreinit_Callbacks.cpp
+  OS/libs/coreinit/coreinit_CodeGen.cpp
+  OS/libs/coreinit/coreinit_CodeGen.h
+  OS/libs/coreinit/coreinit_Coroutine.cpp
+  OS/libs/coreinit/coreinit_Coroutine.h
+  OS/libs/coreinit/coreinit.cpp
+  OS/libs/coreinit/coreinit_DynLoad.cpp
+  OS/libs/coreinit/coreinit_DynLoad.h
+  OS/libs/coreinit/coreinit_FG.cpp
+  OS/libs/coreinit/coreinit_FG.h
+  OS/libs/coreinit/coreinit_FS.cpp
+  OS/libs/coreinit/coreinit_FS.h
+  OS/libs/coreinit/coreinit_GHS.cpp
+  OS/libs/coreinit/coreinit_GHS.h
+  OS/libs/coreinit/coreinit.h
+  OS/libs/coreinit/coreinit_HWInterface.cpp
+  OS/libs/coreinit/coreinit_HWInterface.h
+  OS/libs/coreinit/coreinit_IM.cpp
+  OS/libs/coreinit/coreinit_IM.h
+  OS/libs/coreinit/coreinit_Init.cpp
+  OS/libs/coreinit/coreinit_IOS.cpp
+  OS/libs/coreinit/coreinit_IOS.h
+  OS/libs/coreinit/coreinit_IPCBuf.cpp
+  OS/libs/coreinit/coreinit_IPCBuf.h
+  OS/libs/coreinit/coreinit_IPC.cpp
+  OS/libs/coreinit/coreinit_IPC.h
+  OS/libs/coreinit/coreinit_LockedCache.cpp
+  OS/libs/coreinit/coreinit_LockedCache.h
+  OS/libs/coreinit/coreinit_MCP.cpp
+  OS/libs/coreinit/coreinit_MCP.h
+  OS/libs/coreinit/coreinit_MEM_BlockHeap.cpp
+  OS/libs/coreinit/coreinit_MEM_BlockHeap.h
+  OS/libs/coreinit/coreinit_MEM.cpp
+  OS/libs/coreinit/coreinit_MEM_ExpHeap.cpp
+  OS/libs/coreinit/coreinit_MEM_ExpHeap.h
+  OS/libs/coreinit/coreinit_MEM_FrmHeap.cpp
+  OS/libs/coreinit/coreinit_MEM_FrmHeap.h
+  OS/libs/coreinit/coreinit_MEM.h
+  OS/libs/coreinit/coreinit_Memory.cpp
+  OS/libs/coreinit/coreinit_Memory.h
+  OS/libs/coreinit/coreinit_MemoryMapping.cpp
+  OS/libs/coreinit/coreinit_MemoryMapping.h
+  OS/libs/coreinit/coreinit_MEM_UnitHeap.cpp
+  OS/libs/coreinit/coreinit_MEM_UnitHeap.h
+  OS/libs/coreinit/coreinit_MessageQueue.cpp
+  OS/libs/coreinit/coreinit_MessageQueue.h
+  OS/libs/coreinit/coreinit_Misc.cpp
+  OS/libs/coreinit/coreinit_Misc.h
+  OS/libs/coreinit/coreinit_MPQueue.cpp
+  OS/libs/coreinit/coreinit_MPQueue.h
+  OS/libs/coreinit/coreinit_OSScreen.cpp
+  OS/libs/coreinit/coreinit_OSScreen_font.h
+  OS/libs/coreinit/coreinit_OSScreen.h
+  OS/libs/coreinit/coreinit_OverlayArena.cpp
+  OS/libs/coreinit/coreinit_OverlayArena.h
+  OS/libs/coreinit/coreinit_Scheduler.cpp
+  OS/libs/coreinit/coreinit_Scheduler.h
+  OS/libs/coreinit/coreinit_Spinlock.cpp
+  OS/libs/coreinit/coreinit_Spinlock.h
+  OS/libs/coreinit/coreinit_Synchronization.cpp
+  OS/libs/coreinit/coreinit_SysHeap.cpp
+  OS/libs/coreinit/coreinit_SysHeap.h
+  OS/libs/coreinit/coreinit_SystemInfo.cpp
+  OS/libs/coreinit/coreinit_SystemInfo.h
+  OS/libs/coreinit/coreinit_Thread.cpp
+  OS/libs/coreinit/coreinit_Thread.h
+  OS/libs/coreinit/coreinit_ThreadQueue.cpp
+  OS/libs/coreinit/coreinit_Time.cpp
+  OS/libs/coreinit/coreinit_Time.h
+  OS/libs/dmae/dmae.cpp
+  OS/libs/dmae/dmae.h
+  OS/libs/drmapp/drmapp.cpp
+  OS/libs/drmapp/drmapp.h
+  OS/libs/erreula/erreula.cpp
+  OS/libs/erreula/erreula.h
+  OS/libs/gx2/GX2_AddrTest.cpp
+  OS/libs/gx2/GX2_Blit.cpp
+  OS/libs/gx2/GX2_Blit.h
+  OS/libs/gx2/GX2_Command.cpp
+  OS/libs/gx2/GX2_Command.h
+  OS/libs/gx2/GX2_ContextState.cpp
+  OS/libs/gx2/GX2.cpp
+  OS/libs/gx2/GX2_Draw.cpp
+  OS/libs/gx2/GX2_Draw.h
+  OS/libs/gx2/GX2_Event.cpp
+  OS/libs/gx2/GX2_Event.h
+  OS/libs/gx2/GX2.h
+  OS/libs/gx2/GX2_Memory.cpp
+  OS/libs/gx2/GX2_Memory.h
+  OS/libs/gx2/GX2_Misc.cpp
+  OS/libs/gx2/GX2_Misc.h
+  OS/libs/gx2/GX2_Query.cpp
+  OS/libs/gx2/GX2_Query.h
+  OS/libs/gx2/GX2_RenderTarget.cpp
+  OS/libs/gx2/GX2_Resource.cpp
+  OS/libs/gx2/GX2_Resource.h
+  OS/libs/gx2/GX2_Shader.cpp
+  OS/libs/gx2/GX2_Shader.h
+  OS/libs/gx2/GX2_shader_legacy.cpp
+  OS/libs/gx2/GX2_State.cpp
+  OS/libs/gx2/GX2_State.h
+  OS/libs/gx2/GX2_Streamout.cpp
+  OS/libs/gx2/GX2_Streamout.h
+  OS/libs/gx2/GX2_Surface_Copy.cpp
+  OS/libs/gx2/GX2_Surface_Copy.h
+  OS/libs/gx2/GX2_Surface.cpp
+  OS/libs/gx2/GX2_Surface.h
+  OS/libs/gx2/GX2_Texture.cpp
+  OS/libs/gx2/GX2_Texture.h
+  OS/libs/gx2/GX2_TilingAperture.cpp
+  OS/libs/h264_avc/H264Dec.cpp
+  OS/libs/h264_avc/H264DecBackendAVC.cpp
+  OS/libs/h264_avc/h264dec.h
+  OS/libs/h264_avc/H264DecInternal.h
+  OS/libs/h264_avc/parser
+  OS/libs/h264_avc/parser/H264Parser.cpp
+  OS/libs/h264_avc/parser/H264Parser.h
+  OS/libs/mic/mic.cpp
+  OS/libs/mic/mic.h
+  OS/libs/nfc/ndef.cpp
+  OS/libs/nfc/ndef.h
+  OS/libs/nfc/nfc.cpp
+  OS/libs/nfc/nfc.h
+  OS/libs/nfc/stream.cpp
+  OS/libs/nfc/stream.h
+  OS/libs/nfc/TagV0.cpp
+  OS/libs/nfc/TagV0.h
+  OS/libs/nfc/TLV.cpp
+  OS/libs/nfc/TLV.h
+  OS/libs/nlibcurl/nlibcurl.cpp
+  OS/libs/nlibcurl/nlibcurlDebug.hpp
+  OS/libs/nlibcurl/nlibcurl.h
+  OS/libs/nlibnss/nlibnss.cpp
+  OS/libs/nlibnss/nlibnss.h
+  OS/libs/nn_ac/nn_ac.cpp
+  OS/libs/nn_ac/nn_ac.h
+  OS/libs/nn_acp/nn_acp.cpp
+  OS/libs/nn_acp/nn_acp.h
+  OS/libs/nn_act/nn_act.cpp
+  OS/libs/nn_act/nn_act.h
+  OS/libs/nn_aoc/nn_aoc.cpp
+  OS/libs/nn_aoc/nn_aoc.h
+  OS/libs/nn_boss/nn_boss.cpp
+  OS/libs/nn_boss/nn_boss.h
+  OS/libs/nn_ccr/nn_ccr.cpp
+  OS/libs/nn_ccr/nn_ccr.h
+  OS/libs/nn_cmpt/nn_cmpt.cpp
+  OS/libs/nn_cmpt/nn_cmpt.h
+  OS/libs/nn_common.h
+  OS/libs/nn_ec/nn_ec.cpp
+  OS/libs/nn_ec/nn_ec.h
+  OS/libs/nn_fp/nn_fp.cpp
+  OS/libs/nn_fp/nn_fp.h
+  OS/libs/nn_idbe/nn_idbe.cpp
+  OS/libs/nn_idbe/nn_idbe.h
+  OS/libs/nn_ndm/nn_ndm.cpp
+  OS/libs/nn_ndm/nn_ndm.h
+  OS/libs/nn_spm/nn_spm.cpp
+  OS/libs/nn_spm/nn_spm.h
+  OS/libs/nn_sl/nn_sl.cpp
+  OS/libs/nn_sl/nn_sl.h
+  OS/libs/nn_nfp/AmiiboCrypto.h
+  OS/libs/nn_nfp/nn_nfp.cpp
+  OS/libs/nn_nfp/nn_nfp.h
+  OS/libs/nn_nim/nn_nim.cpp
+  OS/libs/nn_nim/nn_nim.h
+  OS/libs/nn_olv/nn_olv.cpp
+  OS/libs/nn_olv/nn_olv.h
+  OS/libs/nn_olv/nn_olv_Common.cpp
+  OS/libs/nn_olv/nn_olv_Common.h
+  OS/libs/nn_olv/nn_olv_InitializeTypes.cpp
+  OS/libs/nn_olv/nn_olv_InitializeTypes.h
+  OS/libs/nn_olv/nn_olv_DownloadCommunityTypes.cpp
+  OS/libs/nn_olv/nn_olv_DownloadCommunityTypes.h
+  OS/libs/nn_olv/nn_olv_UploadCommunityTypes.cpp
+  OS/libs/nn_olv/nn_olv_UploadCommunityTypes.h
+  OS/libs/nn_olv/nn_olv_UploadFavoriteTypes.cpp
+  OS/libs/nn_olv/nn_olv_UploadFavoriteTypes.h
+  OS/libs/nn_olv/nn_olv_PostTypes.cpp
+  OS/libs/nn_olv/nn_olv_PostTypes.h
+  OS/libs/nn_olv/nn_olv_OfflineDB.cpp
+  OS/libs/nn_olv/nn_olv_OfflineDB.h
+  OS/libs/nn_pdm/nn_pdm.cpp
+  OS/libs/nn_pdm/nn_pdm.h
+  OS/libs/nn_save/nn_save.cpp
+  OS/libs/nn_save/nn_save.h
+  OS/libs/nn_temp/nn_temp.cpp
+  OS/libs/nn_temp/nn_temp.h
+  OS/libs/nn_uds/nn_uds.cpp
+  OS/libs/nn_uds/nn_uds.h
+  OS/libs/nsyshid/nsyshid.cpp
+  OS/libs/nsyshid/nsyshid.h
+  OS/libs/nsyshid/Backend.h
+  OS/libs/nsyshid/AttachDefaultBackends.cpp
+  OS/libs/nsyshid/Whitelist.cpp
+  OS/libs/nsyshid/Whitelist.h
+  OS/libs/nsyshid/BackendEmulated.cpp
+  OS/libs/nsyshid/BackendEmulated.h
+  OS/libs/nsyshid/BackendLibusb.cpp
+  OS/libs/nsyshid/BackendLibusb.h
+  OS/libs/nsyshid/Dimensions.cpp
+  OS/libs/nsyshid/Dimensions.h
+  OS/libs/nsyshid/Infinity.cpp
+  OS/libs/nsyshid/Infinity.h
+  OS/libs/nsyshid/Skylander.cpp
+  OS/libs/nsyshid/Skylander.h
+  OS/libs/nsyshid/SkylanderXbox360.cpp
+  OS/libs/nsyshid/SkylanderXbox360.h
+  OS/libs/nsyshid/g721/g721.cpp
+  OS/libs/nsyshid/g721/g721.h
+  OS/libs/nsyskbd/nsyskbd.cpp
+  OS/libs/nsyskbd/nsyskbd.h
+  OS/libs/nsysnet/nsysnet.cpp
+  OS/libs/nsysnet/nsysnet.h
+  OS/libs/ntag/ntag.cpp
+  OS/libs/ntag/ntag.h
+  OS/libs/padscore/padscore.cpp
+  OS/libs/padscore/padscore.h
+  OS/libs/proc_ui/proc_ui.cpp
+  OS/libs/proc_ui/proc_ui.h
+  OS/libs/snd_core/ax_aux.cpp
+  OS/libs/snd_core/ax_exports.cpp
+  OS/libs/snd_core/ax.h
+  OS/libs/snd_core/ax_internal.h
+  OS/libs/snd_core/ax_ist.cpp
+  OS/libs/snd_core/ax_mix.cpp
+  OS/libs/snd_core/ax_multivoice.cpp
+  OS/libs/snd_core/ax_out.cpp
+  OS/libs/snd_core/ax_voice.cpp
+  OS/libs/snd_user/snd_user.cpp
+  OS/libs/snd_user/snd_user.h
+  OS/libs/swkbd/swkbd.cpp
+  OS/libs/swkbd/swkbd.h
+  OS/libs/sysapp/sysapp.cpp
+  OS/libs/sysapp/sysapp.h
+  OS/libs/TCL/TCL.cpp
+  OS/libs/TCL/TCL.h
+  OS/libs/vpad/vpad.cpp
+  OS/libs/vpad/vpad.h
+  OS/libs/zlib125
+  OS/libs/zlib125/zlib125.cpp
+  OS/libs/zlib125/zlib125.h
+  OS/RPL/elf.cpp
+  OS/RPL/rpl.cpp
+  OS/RPL/rpl_debug_symbols.cpp
+  OS/RPL/rpl_debug_symbols.h
+  OS/RPL/rpl.h
+  OS/RPL/rpl_structs.h
+  OS/RPL/rpl_symbol_storage.cpp
+  OS/RPL/rpl_symbol_storage.h
+  TitleList/GameInfo.h
+  TitleList/ParsedMetaXml.h
+  TitleList/SaveInfo.cpp
+  TitleList/SaveInfo.h
+  TitleList/SaveList.cpp
+  TitleList/SaveList.h
+  TitleList/TitleId.h
+  TitleList/TitleInfo.cpp
+  TitleList/TitleInfo.h
+  TitleList/TitleList.cpp
+  TitleList/TitleList.h
+)
 
 if(APPLE)
-	file(GLOB_RECURSE MM_FILES *.mm)
-	add_library(CemuCafe ${CPP_FILES} ${MM_FILES} ${H_FILES})
-else()
-	add_library(CemuCafe ${CPP_FILES} ${H_FILES})
+	target_sources(CemuCafe PRIVATE "HW/Latte/Renderer/Vulkan/CocoaSurface.mm")
+endif()
+
+if(CEMU_ARCHITECTURE MATCHES "(aarch64)|(AARCH64)|(arm64)|(ARM64)")
+  target_sources(CemuCafe PRIVATE
+    HW/Espresso/Recompiler/BackendAArch64/BackendAArch64.cpp
+    HW/Espresso/Recompiler/BackendAArch64/BackendAArch64.h
+  )
+  target_link_libraries(CemuCafe PRIVATE xbyak_aarch64)
 endif()
 
 set_property(TARGET CemuCafe PROPERTY MSVC_RUNTIME_LIBRARY "MultiThreaded$<$<CONFIG:Debug>:Debug>")
 
 target_include_directories(CemuCafe PUBLIC "../")
 
+if (glslang_VERSION VERSION_LESS "15.0.0")
+	set(glslang_target "glslang::SPIRV")
+else()
+	set(glslang_target "glslang::glslang")
+endif()
+
 target_link_libraries(CemuCafe PRIVATE
-	CemuAsm
 	CemuAudio
 	CemuCommon
 	CemuComponents
@@ -29,9 +569,8 @@ target_link_libraries(CemuCafe PRIVATE
 	Boost::nowide
 	CURL::libcurl
 	fmt::fmt
-	glslang::SPIRV
+	${glslang_target}
 	ih264d
-	imgui::imgui
 	OpenSSL::Crypto
 	OpenSSL::SSL
 	PNG::PNG
@@ -41,6 +580,23 @@ target_link_libraries(CemuCafe PRIVATE
 	zstd::zstd
 )
 
+if (ENABLE_WAYLAND)
+	# PUBLIC because wayland-client.h is included in VulkanAPI.h
+  target_link_libraries(CemuCafe PUBLIC Wayland::Client)
+endif()
+
+if (ENABLE_VCPKG)
+  if(WIN32)
+    set(PKG_CONFIG_EXECUTABLE "${VCPKG_INSTALLED_DIR}/x64-windows/tools/pkgconf/pkgconf.exe")
+  endif()
+  find_package(PkgConfig REQUIRED)
+  pkg_check_modules(libusb REQUIRED IMPORTED_TARGET libusb-1.0)
+  target_link_libraries(CemuCafe PRIVATE PkgConfig::libusb)
+else ()
+  find_package(libusb MODULE REQUIRED)
+  target_link_libraries(CemuCafe PRIVATE libusb::libusb)
+endif ()
+
 if (ENABLE_WXWIDGETS)
 	target_link_libraries(CemuCafe PRIVATE wx::base wx::core)
 endif()
diff --git a/src/Cafe/CafeSystem.cpp b/src/Cafe/CafeSystem.cpp
index 8ec6ff0a..d20ccd9d 100644
--- a/src/Cafe/CafeSystem.cpp
+++ b/src/Cafe/CafeSystem.cpp
@@ -4,16 +4,17 @@
 #include "Cafe/GameProfile/GameProfile.h"
 #include "Cafe/HW/Espresso/Interpreter/PPCInterpreterInternal.h"
 #include "Cafe/HW/Espresso/Recompiler/PPCRecompiler.h"
-#include "audio/IAudioAPI.h"
 #include "Cafe/HW/Espresso/Debugger/Debugger.h"
-
+#include "Cafe/OS/RPL/rpl_symbol_storage.h"
+#include "audio/IAudioAPI.h"
+#include "audio/IAudioInputAPI.h"
 #include "config/ActiveSettings.h"
+#include "config/LaunchSettings.h"
 #include "Cafe/TitleList/GameInfo.h"
-#include "util/helpers/SystemException.h"
 #include "Cafe/GraphicPack/GraphicPack2.h"
-
+#include "util/helpers/SystemException.h"
+#include "Common/cpu_features.h"
 #include "input/InputManager.h"
-
 #include "Cafe/CafeSystem.h"
 #include "Cafe/TitleList/TitleList.h"
 #include "Cafe/TitleList/GameInfo.h"
@@ -21,14 +22,10 @@
 #include "Cafe/OS/libs/snd_core/ax.h"
 #include "Cafe/OS/RPL/rpl.h"
 #include "Cafe/HW/Latte/Core/Latte.h"
-
 #include "Cafe/Filesystem/FST/FST.h"
-
 #include "Common/FileStream.h"
-
 #include "GamePatch.h"
-
-#include <time.h>
+#include "HW/Espresso/Debugger/GDBStub.h"
 
 #include "Cafe/IOSU/legacy/iosu_ioctl.h"
 #include "Cafe/IOSU/legacy/iosu_act.h"
@@ -39,12 +36,14 @@
 #include "Cafe/IOSU/legacy/iosu_boss.h"
 #include "Cafe/IOSU/legacy/iosu_nim.h"
 #include "Cafe/IOSU/PDM/iosu_pdm.h"
+#include "Cafe/IOSU/ccr_nfc/iosu_ccr_nfc.h"
 
 // IOSU initializer functions
 #include "Cafe/IOSU/kernel/iosu_kernel.h"
 #include "Cafe/IOSU/fsa/iosu_fsa.h"
+#include "Cafe/IOSU/ODM/iosu_odm.h"
 
-// Cafe OS initializer functions
+// Cafe OS initializer and shutdown functions
 #include "Cafe/OS/libs/avm/avm.h"
 #include "Cafe/OS/libs/drmapp/drmapp.h"
 #include "Cafe/OS/libs/TCL/TCL.h"
@@ -54,11 +53,14 @@
 #include "Cafe/OS/libs/gx2/GX2.h"
 #include "Cafe/OS/libs/gx2/GX2_Misc.h"
 #include "Cafe/OS/libs/mic/mic.h"
+#include "Cafe/OS/libs/nfc/nfc.h"
+#include "Cafe/OS/libs/ntag/ntag.h"
 #include "Cafe/OS/libs/nn_aoc/nn_aoc.h"
 #include "Cafe/OS/libs/nn_pdm/nn_pdm.h"
 #include "Cafe/OS/libs/nn_cmpt/nn_cmpt.h"
 #include "Cafe/OS/libs/nn_ccr/nn_ccr.h"
 #include "Cafe/OS/libs/nn_temp/nn_temp.h"
+#include "Cafe/OS/libs/nn_save/nn_save.h"
 
 // HW interfaces
 #include "Cafe/HW/SI/si.h"
@@ -66,6 +68,15 @@
 // dependency to be removed
 #include "gui/guiWrapper.h"
 
+#include <time.h>
+
+#if BOOST_OS_LINUX
+#include <sys/sysinfo.h>
+#elif BOOST_OS_MACOS
+#include <sys/types.h>
+#include <sys/sysctl.h>
+#endif
+
 std::string _pathToExecutable;
 std::string _pathToBaseExecutable;
 
@@ -131,7 +142,7 @@ void LoadMainExecutable()
 		// otherwise search for first file with .rpx extension in the code folder
 		if (!ScanForRPX())
 		{
-			forceLog_printf("Unable to find RPX executable");
+			cemuLog_log(LogType::Force, "Unable to find RPX executable");
 			cemuLog_waitForFlush();
 			cemu_assert(false);
 		}
@@ -141,7 +152,7 @@ void LoadMainExecutable()
 	uint8* rpxData = fsc_extractFile(_pathToExecutable.c_str(), &rpxSize);
 	if (rpxData == nullptr)
 	{
-		forceLog_printf("Failed to load \"%s\"", _pathToExecutable.c_str());
+		cemuLog_log(LogType::Force, "Failed to load \"{}\"", _pathToExecutable);
 		cemuLog_waitForFlush();
 		cemu_assert(false);
 	}
@@ -158,7 +169,7 @@ void LoadMainExecutable()
 	{
 		// RPX
 		RPLLoader_AddDependency(_pathToExecutable.c_str());
-		applicationRPX = rpl_loadFromMem(rpxData, rpxSize, (char*)_pathToExecutable.c_str());
+		applicationRPX = RPLLoader_LoadFromMemory(rpxData, rpxSize, (char*)_pathToExecutable.c_str());
 		if (!applicationRPX)
 		{
 			wxMessageBox(_("Failed to run this title because the executable is damaged"));
@@ -209,7 +220,7 @@ void InfoLog_TitleLoaded()
 	fs::path effectiveSavePath = getTitleSavePath();
 	std::error_code ec;
 	const bool saveDirExists = fs::exists(effectiveSavePath, ec);
-	cemuLog_force("Save path:   {}{}", _pathToUtf8(effectiveSavePath), saveDirExists ? "" : " (not present)");
+	cemuLog_log(LogType::Force, "Save path:   {}{}", _pathToUtf8(effectiveSavePath), saveDirExists ? "" : " (not present)");
 
 	// log shader cache name
 	cemuLog_log(LogType::Force, "Shader cache file: shaderCache/transferable/{:016x}.bin", titleId);
@@ -230,28 +241,21 @@ void InfoLog_TitleLoaded()
 void InfoLog_PrintActiveSettings()
 {
 	const auto& config = GetConfig();
-	forceLog_printf("------- Active settings -------");
+	cemuLog_log(LogType::Force, "------- Active settings -------");
 
 	// settings to log:
-	forceLog_printf("CPU-Mode: %s%s", fmt::format("{}", ActiveSettings::GetCPUMode()).c_str(), g_current_game_profile->GetCPUMode().has_value() ? " (gameprofile)" : "");
-	forceLog_printf("Load shared libraries: %s%s", ActiveSettings::LoadSharedLibrariesEnabled() ? "true" : "false", g_current_game_profile->ShouldLoadSharedLibraries().has_value() ? " (gameprofile)" : "");
-	forceLog_printf("Use precompiled shaders: %s%s", fmt::format("{}", ActiveSettings::GetPrecompiledShadersOption()).c_str(), g_current_game_profile->GetPrecompiledShadersState().has_value() ? " (gameprofile)" : "");
-	forceLog_printf("Full sync at GX2DrawDone: %s", ActiveSettings::WaitForGX2DrawDoneEnabled() ? "true" : "false");
+	cemuLog_log(LogType::Force, "CPU-Mode: {}{}", fmt::format("{}", ActiveSettings::GetCPUMode()).c_str(), g_current_game_profile->GetCPUMode().has_value() ? " (gameprofile)" : "");
+	cemuLog_log(LogType::Force, "Load shared libraries: {}{}", ActiveSettings::LoadSharedLibrariesEnabled() ? "true" : "false", g_current_game_profile->ShouldLoadSharedLibraries().has_value() ? " (gameprofile)" : "");
+	cemuLog_log(LogType::Force, "Use precompiled shaders: {}{}", fmt::format("{}", ActiveSettings::GetPrecompiledShadersOption()), g_current_game_profile->GetPrecompiledShadersState().has_value() ? " (gameprofile)" : "");
+	cemuLog_log(LogType::Force, "Full sync at GX2DrawDone: {}", ActiveSettings::WaitForGX2DrawDoneEnabled() ? "true" : "false");
+	cemuLog_log(LogType::Force, "Strict shader mul: {}", g_current_game_profile->GetAccurateShaderMul() == AccurateShaderMulOption::True ? "true" : "false");
 	if (ActiveSettings::GetGraphicsAPI() == GraphicAPI::kVulkan)
 	{
-		forceLog_printf("Async compile: %s", GetConfig().async_compile.GetValue() ? "true" : "false");
+		cemuLog_log(LogType::Force, "Async compile: {}", GetConfig().async_compile.GetValue() ? "true" : "false");
 		if(!GetConfig().vk_accurate_barriers.GetValue())
-			forceLog_printf("Accurate barriers are disabled!");
+			cemuLog_log(LogType::Force, "Accurate barriers are disabled!");
 	}
-
-	forceLog_printf("Console language: %s", fmt::format("{}", config.console_language).c_str());
-}
-
-void PPCCore_setupSPR(PPCInterpreter_t* hCPU, uint32 coreIndex)
-{
-	hCPU->sprExtended.PVR = 0x70010001;
-	hCPU->spr.UPIR = coreIndex;
-	hCPU->sprExtended.msr |= MSR_FP; // enable floating point
+	cemuLog_log(LogType::Force, "Console language: {}", stdx::to_underlying(config.console_language.GetValue()));
 }
 
 struct SharedDataEntry
@@ -282,14 +286,14 @@ struct
 
 static_assert(sizeof(SharedDataEntry) == 0x1C);
 
-uint32 loadSharedData()
+uint32 LoadSharedData()
 {
 	// check if font files are dumped
 	bool hasAllShareddataFiles = true;
 	for (sint32 i = 0; i < sizeof(shareddataDef) / sizeof(shareddataDef[0]); i++)
 	{
 		bool existsInMLC = fs::exists(ActiveSettings::GetMlcPath(shareddataDef[i].mlcPath));
-		bool existsInResources = fs::exists(ActiveSettings::GetPath(shareddataDef[i].resourcePath));
+		bool existsInResources = fs::exists(ActiveSettings::GetDataPath(shareddataDef[i].resourcePath));
 
 		if (!existsInMLC && !existsInResources)
 		{
@@ -314,7 +318,7 @@ uint32 loadSharedData()
 			// alternatively fall back to our shared fonts
 			if (!fontFile)
 			{
-				path = ActiveSettings::GetPath(shareddataDef[i].resourcePath);
+				path = ActiveSettings::GetDataPath(shareddataDef[i].resourcePath);
 				fontFile = FileStream::openFile2(path);
 			}
 			if (!fontFile)
@@ -336,11 +340,11 @@ uint32 loadSharedData()
 			// advance write offset and pad to 16 byte alignment
 			dataWritePtr += ((fileSize + 15) & ~15);
 		}
-		forceLog_printfW(L"COS: System fonts found. Generated shareddata (%dKB)", (uint32)(dataWritePtr - (uint8*)shareddataTable) / 1024);
+		cemuLog_log(LogType::Force, "COS: System fonts found. Generated shareddata ({}KB)", (uint32)(dataWritePtr - (uint8*)shareddataTable) / 1024);
 		return memory_getVirtualOffsetFromPointer(dataWritePtr);
 	}
 	// alternative method: load RAM dump
-	const auto path = ActiveSettings::GetPath("shareddata.bin");
+	const auto path = ActiveSettings::GetUserDataPath("shareddata.bin");
 	FileStream* ramDumpFile = FileStream::openFile2(path);
 	if (ramDumpFile)
 	{
@@ -381,7 +385,7 @@ void cemu_initForGame()
 	RPLLoader_Link();
 	RPLLoader_NotifyControlPassedToApplication();
 	uint32 linkTime = GetTickCount() - linkTimeStart;
-	forceLog_printf("RPL link time: %dms", linkTime);
+	cemuLog_log(LogType::Force, "RPL link time: {}ms", linkTime);
 	// for HBL ELF: Setup OS-specifics struct
 	if (isLaunchTypeELF)
 	{
@@ -393,17 +397,24 @@ void cemu_initForGame()
 		// replace any known function signatures with our HLE implementations and patch bugs in the games
 		GamePatch_scan();
 	}
+	LatteGPUState.isDRCPrimary = ActiveSettings::DisplayDRCEnabled();
 	InfoLog_PrintActiveSettings();
 	Latte_Start();
 	// check for debugger entrypoint bp
+    if (g_gdbstub)
+    {
+        g_gdbstub->HandleEntryStop(_entryPoint);
+        g_gdbstub->Initialize();
+    }
 	debugger_handleEntryBreakpoint(_entryPoint);
 	// load graphic packs
-	forceLog_printf("------- Activate graphic packs -------");
+	cemuLog_log(LogType::Force, "------- Activate graphic packs -------");
 	GraphicPack2::ActivateForCurrentTitle();
 	// print audio log
 	IAudioAPI::PrintLogging();
+	IAudioInputAPI::PrintLogging();
 	// everything initialized
-	forceLog_printf("------- Run title -------");
+	cemuLog_log(LogType::Force, "------- Run title -------");
 	// wait till GPU thread is initialized
 	while (g_isGPUInitFinished == false) std::this_thread::sleep_for(std::chrono::milliseconds(50));
 	// init initial thread
@@ -412,61 +423,162 @@ void cemu_initForGame()
 	coreinit::OSRunThread(initialThread, PPCInterpreter_makeCallableExportDepr(coreinit_start), 0, nullptr);
 	// init AX and start AX I/O thread
 	snd_core::AXOut_init();
-	// init ppc recompiler
-	PPCRecompiler_init();
-}
-
-void cemu_deinitForGame()
-{
-	// reset audio
-	snd_core::AXOut_reset();
-	snd_core::reset();
-	// reset alarms
-	coreinit::OSAlarm_resetAll();
-	// delete all threads
-	PPCCore_deleteAllThreads();
-	// reset mount paths
-	fsc_unmountAll();
-	// reset RPL loader
-	RPLLoader_ResetState();
-	// reset GX2
-	GX2::_GX2DriverReset();
 }
 
 namespace CafeSystem
 {
 	void InitVirtualMlcStorage();
 	void MlcStorageMountTitle(TitleInfo& titleInfo);
+    void MlcStorageUnmountAllTitles();
 
-	bool sLaunchModeIsStandalone = false;
+    static bool s_initialized = false;
+	static SystemImplementation* s_implementation{nullptr};
+    bool sLaunchModeIsStandalone = false;
+	std::optional<std::vector<std::string>> s_overrideArgs;
 
 	bool sSystemRunning = false;
 	TitleId sForegroundTitleId = 0;
 
 	GameInfo2 sGameInfo_ForegroundTitle;
 
+
+	static void _CheckForWine()
+	{
+		#if BOOST_OS_WINDOWS
+		const HMODULE hmodule = GetModuleHandleA("ntdll.dll");
+		if (!hmodule)
+			return;
+
+		const auto pwine_get_version = (const char*(__cdecl*)())GetProcAddress(hmodule, "wine_get_version");
+		if (pwine_get_version)
+		{
+			cemuLog_log(LogType::Force, "Wine version: {}", pwine_get_version());
+		}
+		#endif
+	}
+
+	void logCPUAndMemoryInfo()
+	{
+		std::string cpuName = g_CPUFeatures.GetCPUName();
+		if (!cpuName.empty())
+			cemuLog_log(LogType::Force, "CPU: {}", cpuName);
+		#if BOOST_OS_WINDOWS
+		MEMORYSTATUSEX statex;
+		statex.dwLength = sizeof(statex);
+		GlobalMemoryStatusEx(&statex);
+		uint32 memoryInMB = (uint32)(statex.ullTotalPhys / 1024LL / 1024LL);
+		cemuLog_log(LogType::Force, "RAM: {}MB", memoryInMB);
+		#elif BOOST_OS_LINUX
+		struct sysinfo info {};
+		sysinfo(&info);
+		cemuLog_log(LogType::Force, "RAM: {}MB", ((static_cast<uint64_t>(info.totalram) * info.mem_unit) / 1024LL / 1024LL));
+		#elif BOOST_OS_MACOS
+		int64_t totalRam;
+		size_t size = sizeof(totalRam);
+		int result = sysctlbyname("hw.memsize", &totalRam, &size, NULL, 0);
+		if (result == 0)
+			cemuLog_log(LogType::Force, "RAM: {}MB", (totalRam / 1024LL / 1024LL));
+		#endif
+	}
+
+	#if BOOST_OS_WINDOWS
+	std::string GetWindowsNamedVersion(uint32& buildNumber)
+	{
+		char productName[256];
+		HKEY hKey;
+		DWORD dwType = REG_SZ;
+		DWORD dwSize = sizeof(productName);
+		if (RegOpenKeyExA(HKEY_LOCAL_MACHINE, "SOFTWARE\\Microsoft\\Windows NT\\CurrentVersion", 0, KEY_QUERY_VALUE, &hKey) == ERROR_SUCCESS)
+		{
+			if (RegQueryValueExA(hKey, "ProductName", NULL, &dwType, (LPBYTE)productName, &dwSize) != ERROR_SUCCESS)
+				strcpy(productName, "Windows");
+			RegCloseKey(hKey);
+		}
+		OSVERSIONINFO osvi;
+		ZeroMemory(&osvi, sizeof(OSVERSIONINFO));
+		osvi.dwOSVersionInfoSize = sizeof(OSVERSIONINFO);
+		GetVersionEx(&osvi);
+		buildNumber = osvi.dwBuildNumber;
+		return std::string(productName);
+	}
+	#endif
+
+	void logPlatformInfo()
+	{
+		std::string buffer;
+		const char* platform = NULL;
+		#if BOOST_OS_WINDOWS
+		uint32 buildNumber;
+		std::string windowsVersionName = GetWindowsNamedVersion(buildNumber);
+		buffer = fmt::format("{} (Build {})", windowsVersionName, buildNumber);
+		platform = buffer.c_str();
+		#elif BOOST_OS_LINUX
+		if (getenv ("APPIMAGE"))
+			platform = "Linux (AppImage)";
+		else if (getenv ("SNAP"))
+			platform = "Linux (Snap)";
+		else if (platform = getenv ("container"))
+		{
+			if (strcmp (platform, "flatpak") == 0)
+				platform = "Linux (Flatpak)";
+		}
+		else
+			platform = "Linux";
+		#elif BOOST_OS_MACOS
+		platform = "MacOS";
+		#endif
+		cemuLog_log(LogType::Force, "Platform: {}", platform);
+	}
+
+	static std::vector<IOSUModule*> s_iosuModules =
+	{
+		// entries in this list are ordered by initialization order. Shutdown in reverse order
+		iosu::kernel::GetModule(),
+		iosu::acp::GetModule(),
+		iosu::fpd::GetModule(),
+		iosu::pdm::GetModule(),
+		iosu::ccr_nfc::GetModule(),
+	};
+
+	// initialize all subsystems which are persistent and don't depend on a game running
 	void Initialize()
 	{
-		static bool s_initialized = false;
 		if (s_initialized)
 			return;
 		s_initialized = true;
+		// init core systems
+		cemuLog_log(LogType::Force, "------- Init {} -------", BUILD_VERSION_WITH_NAME_STRING);
+		fsc_init();
+		memory_init();
+		cemuLog_log(LogType::Force, "Init Wii U memory space (base: 0x{:016x})", (size_t)memory_base);
+		PPCCore_init();
+		RPLLoader_InitState();
+		cemuLog_log(LogType::Force, "mlc01 path: {}", _pathToUtf8(ActiveSettings::GetMlcPath()));
+		_CheckForWine();
+		// CPU and RAM info
+		logCPUAndMemoryInfo();
+		logPlatformInfo();
+		cemuLog_log(LogType::Force, "Used CPU extensions: {}", g_CPUFeatures.GetCommaSeparatedExtensionList());
+		// misc systems
+		rplSymbolStorage_init();
 		// allocate memory for all SysAllocators
-		// must happen before all COS modules, but also before iosu::kernel::Init()
+		// must happen before COS module init, but also before iosu::kernel::Initialize()
 		SysAllocatorContainer::GetInstance().Initialize();
-		// init IOSU
-		iosu::kernel::Initialize();
+		// init IOSU modules
+		for(auto& module : s_iosuModules)
+			module->SystemLaunch();
+		// init IOSU (deprecated manual init)
+		iosuCrypto_init();
 		iosu::fsa::Initialize();
 		iosuIoctl_init();
 		iosuAct_init_depr();
 		iosu::act::Initialize();
-		iosu::fpd::Initialize();
 		iosu::iosuMcp_init();
 		iosu::mcp::Init();
 		iosu::iosuAcp_init();
 		iosu::boss_init();
 		iosu::nim::Initialize();
-		iosu::pdm::Initialize();
+		iosu::odm::Initialize();
 		// init Cafe OS
 		avm::Initialize();
 		drmapp::Initialize();
@@ -480,49 +592,86 @@ namespace CafeSystem
 		H264::Initialize();
 		snd_core::Initialize();
 		mic::Initialize();
+		nfc::Initialize();
+		ntag::Initialize();
 		// init hardware register interfaces
 		HW_SI::Initialize();
 	}
 
+	void SetImplementation(SystemImplementation* impl)
+	{
+		s_implementation = impl;
+	}
+
+    void Shutdown()
+    {
+        cemu_assert_debug(s_initialized);
+        // if a title is running, shut it down
+        if (sSystemRunning)
+            ShutdownTitle();
+        // shutdown persistent subsystems (deprecated manual shutdown)
+		iosu::odm::Shutdown();
+		iosu::act::Stop();
+        iosu::mcp::Shutdown();
+        iosu::fsa::Shutdown();
+		// shutdown IOSU modules
+		for(auto it = s_iosuModules.rbegin(); it != s_iosuModules.rend(); ++it)
+			(*it)->SystemExit();
+        s_initialized = false;
+    }
+
 	std::string GetInternalVirtualCodeFolder()
 	{
 		return "/internal/current_title/code/";
 	}
 
-	STATUS_CODE LoadAndMountForegroundTitle(TitleId titleId)
+    void MountBaseDirectories()
+    {
+        const auto mlc = ActiveSettings::GetMlcPath();
+        FSCDeviceHostFS_Mount("/cemuBossStorage/", _pathToUtf8(mlc / "usr/boss/"), FSC_PRIORITY_BASE);
+        FSCDeviceHostFS_Mount("/vol/storage_mlc01/", _pathToUtf8(mlc / ""), FSC_PRIORITY_BASE);
+    }
+
+    void UnmountBaseDirectories()
+    {
+        fsc_unmount("/vol/storage_mlc01/", FSC_PRIORITY_BASE);
+        fsc_unmount("/cemuBossStorage/", FSC_PRIORITY_BASE);
+    }
+
+	PREPARE_STATUS_CODE LoadAndMountForegroundTitle(TitleId titleId)
 	{
-		cemuLog_log(LogType::Force, "Mounting title {:016x}", (uint64)titleId);
+        cemuLog_log(LogType::Force, "Mounting title {:016x}", (uint64)titleId);
 		sGameInfo_ForegroundTitle = CafeTitleList::GetGameInfo(titleId);
 		if (!sGameInfo_ForegroundTitle.IsValid())
 		{
 			cemuLog_log(LogType::Force, "Mounting failed: Game meta information is either missing, inaccessible or not valid (missing or invalid .xml files in code and meta folder)");
-			return STATUS_CODE::UNABLE_TO_MOUNT;
+			return PREPARE_STATUS_CODE::UNABLE_TO_MOUNT;
 		}
 		// check base
 		TitleInfo& titleBase = sGameInfo_ForegroundTitle.GetBase();
 		if (!titleBase.IsValid())
-			return STATUS_CODE::UNABLE_TO_MOUNT;
+			return PREPARE_STATUS_CODE::UNABLE_TO_MOUNT;
 		if(!titleBase.ParseXmlInfo())
-			return STATUS_CODE::UNABLE_TO_MOUNT;
+			return PREPARE_STATUS_CODE::UNABLE_TO_MOUNT;
 		cemuLog_log(LogType::Force, "Base: {}", titleBase.GetPrintPath());
 		// mount base
 		if (!titleBase.Mount("/vol/content", "content", FSC_PRIORITY_BASE) || !titleBase.Mount(GetInternalVirtualCodeFolder(), "code", FSC_PRIORITY_BASE))
 		{
 			cemuLog_log(LogType::Force, "Mounting failed");
-			return STATUS_CODE::UNABLE_TO_MOUNT;
+			return PREPARE_STATUS_CODE::UNABLE_TO_MOUNT;
 		}
 		// check update
 		TitleInfo& titleUpdate = sGameInfo_ForegroundTitle.GetUpdate();
 		if (titleUpdate.IsValid())
 		{
 			if (!titleUpdate.ParseXmlInfo())
-				return STATUS_CODE::UNABLE_TO_MOUNT;
+				return PREPARE_STATUS_CODE::UNABLE_TO_MOUNT;
 			cemuLog_log(LogType::Force, "Update: {}", titleUpdate.GetPrintPath());
 			// mount update
 			if (!titleUpdate.Mount("/vol/content", "content", FSC_PRIORITY_PATCH) || !titleUpdate.Mount(GetInternalVirtualCodeFolder(), "code", FSC_PRIORITY_PATCH))
 			{
 				cemuLog_log(LogType::Force, "Mounting failed");
-				return STATUS_CODE::UNABLE_TO_MOUNT;
+				return PREPARE_STATUS_CODE::UNABLE_TO_MOUNT;
 			}
 		}
 		else
@@ -534,26 +683,49 @@ namespace CafeSystem
 			// todo - support for multi-title AOC
 			TitleInfo& titleAOC = aocList[0];
 			if (!titleAOC.ParseXmlInfo())
-				return STATUS_CODE::UNABLE_TO_MOUNT;
+				return PREPARE_STATUS_CODE::UNABLE_TO_MOUNT;
 			cemu_assert_debug(titleAOC.IsValid());
 			cemuLog_log(LogType::Force, "DLC: {}", titleAOC.GetPrintPath());
 			// mount AOC
 			if (!titleAOC.Mount(fmt::format("/vol/aoc{:016x}", titleAOC.GetAppTitleId()), "content", FSC_PRIORITY_PATCH))
 			{
 				cemuLog_log(LogType::Force, "Mounting failed");
-				return STATUS_CODE::UNABLE_TO_MOUNT;
+				return PREPARE_STATUS_CODE::UNABLE_TO_MOUNT;
 			}
 		}
 		else
 			cemuLog_log(LogType::Force, "DLC: Not present");
 		sForegroundTitleId = titleId;
-		return STATUS_CODE::SUCCESS;
+		return PREPARE_STATUS_CODE::SUCCESS;
 	}
 
-	STATUS_CODE SetupExecutable()
+    void UnmountForegroundTitle()
+    {
+        if(sLaunchModeIsStandalone)
+            return;
+        cemu_assert_debug(sGameInfo_ForegroundTitle.IsValid()); // unmounting title which was never mounted?
+        if (!sGameInfo_ForegroundTitle.IsValid())
+            return;
+        sGameInfo_ForegroundTitle.GetBase().Unmount("/vol/content");
+        sGameInfo_ForegroundTitle.GetBase().Unmount(GetInternalVirtualCodeFolder());
+        if (sGameInfo_ForegroundTitle.HasUpdate())
+        {
+            if(auto& update = sGameInfo_ForegroundTitle.GetUpdate(); update.IsValid())
+            {
+                update.Unmount("/vol/content");
+                update.Unmount(GetInternalVirtualCodeFolder());
+            }
+        }
+        auto aocList = sGameInfo_ForegroundTitle.GetAOC();
+        if (!aocList.empty())
+        {
+            TitleInfo& titleAOC = aocList[0];
+            titleAOC.Unmount(fmt::format("/vol/aoc{:016x}", titleAOC.GetAppTitleId()));
+        }
+    }
+
+	PREPARE_STATUS_CODE SetupExecutable()
 	{
-		// mount mlc directories
-		fscDeviceHostFS_mapBaseDirectories_deprecated();
 		// set rpx path from cos.xml if available
 		_pathToBaseExecutable = _pathToExecutable;
 		if (!sLaunchModeIsStandalone)
@@ -577,42 +749,53 @@ namespace CafeSystem
 					const auto file = fsc_open(rpxPath.c_str(), FSC_ACCESS_FLAG::OPEN_FILE | FSC_ACCESS_FLAG::READ_PERMISSION, &status);
 					if (file)
 					{
-						_pathToExecutable = rpxPath;
+						_pathToExecutable = std::move(rpxPath);
 						fsc_close(file);
 					}
 				}
 			}
 		}
 		LoadMainExecutable();
-		gameProfile_load();
-		return STATUS_CODE::SUCCESS;
+		return PREPARE_STATUS_CODE::SUCCESS;
 	}
 
-	STATUS_CODE PrepareForegroundTitle(TitleId titleId)
+    void SetupMemorySpace()
+    {
+        memory_mapForCurrentTitle();
+        LoadSharedData();
+    }
+
+    void DestroyMemorySpace()
+    {
+        memory_unmapForCurrentTitle();
+    }
+
+	PREPARE_STATUS_CODE PrepareForegroundTitle(TitleId titleId)
 	{
 		CafeTitleList::WaitForMandatoryScan();
 		sLaunchModeIsStandalone = false;
+        _pathToExecutable.clear();
 		TitleIdParser tip(titleId);
 		if (tip.GetType() == TitleIdParser::TITLE_TYPE::AOC || tip.GetType() == TitleIdParser::TITLE_TYPE::BASE_TITLE_UPDATE)
 			cemuLog_log(LogType::Force, "Launched titleId is not the base of a title");
-
-		// mount title folders
-		STATUS_CODE r = LoadAndMountForegroundTitle(titleId);
-		if (r != STATUS_CODE::SUCCESS)
+        // mount mlc storage
+        MountBaseDirectories();
+        // mount title folders
+		PREPARE_STATUS_CODE r = LoadAndMountForegroundTitle(titleId);
+		if (r != PREPARE_STATUS_CODE::SUCCESS)
 			return r;
-		// map memory
-		memory_mapForCurrentTitle();
-		// load RPX
-		r = SetupExecutable();
-		if (r != STATUS_CODE::SUCCESS)
+		gameProfile_load();
+		// setup memory space and PPC recompiler
+        SetupMemorySpace();
+        PPCRecompiler_init();
+		r = SetupExecutable(); // load RPX
+		if (r != PREPARE_STATUS_CODE::SUCCESS)
 			return r;
-
-		loadSharedData();
 		InitVirtualMlcStorage();
-		return STATUS_CODE::SUCCESS;
+		return PREPARE_STATUS_CODE::SUCCESS;
 	}
 
-	STATUS_CODE PrepareForegroundTitleFromStandaloneRPX(const fs::path& path)
+	PREPARE_STATUS_CODE PrepareForegroundTitleFromStandaloneRPX(const fs::path& path)
 	{
 		sLaunchModeIsStandalone = true;
 		cemuLog_log(LogType::Force, "Launching executable in standalone mode due to incorrect layout or missing meta files");
@@ -630,7 +813,7 @@ namespace CafeSystem
 				if (!r)
 				{
 					cemuLog_log(LogType::Force, "Failed to mount {}", _pathToUtf8(contentPath));
-					return STATUS_CODE::UNABLE_TO_MOUNT;
+					return PREPARE_STATUS_CODE::UNABLE_TO_MOUNT;
 				}
 			}
 		}
@@ -642,28 +825,29 @@ namespace CafeSystem
 		// since a lot of systems (including save folder location) rely on a TitleId, we derive a placeholder id from the executable hash
 		auto execData = fsc_extractFile(_pathToExecutable.c_str());
 		if (!execData)
-			return STATUS_CODE::INVALID_RPX;
+			return PREPARE_STATUS_CODE::INVALID_RPX;
 		uint32 h = generateHashFromRawRPXData(execData->data(), execData->size());
 		sForegroundTitleId = 0xFFFFFFFF00000000ULL | (uint64)h;
 		cemuLog_log(LogType::Force, "Generated placeholder TitleId: {:016x}", sForegroundTitleId);
-		// load executable
-		memory_mapForCurrentTitle();
-		SetupExecutable();
-		loadSharedData();
+		// setup memory space and ppc recompiler
+        SetupMemorySpace();
+        PPCRecompiler_init();
+        // load executable
+        SetupExecutable();
 		InitVirtualMlcStorage();
-		return STATUS_CODE::SUCCESS;
+		return PREPARE_STATUS_CODE::SUCCESS;
 	}
 
 	void _LaunchTitleThread()
 	{
-		// init
+		for(auto& module : s_iosuModules)
+			module->TitleStart();
 		cemu_initForGame();
 		// enter scheduler
-		if (ActiveSettings::GetCPUMode() == CPUMode::MulticoreRecompiler)
+		if ((ActiveSettings::GetCPUMode() == CPUMode::MulticoreRecompiler || LaunchSettings::ForceMultiCoreInterpreter()) && !LaunchSettings::ForceInterpreter())
 			coreinit::OSSchedulerBegin(3);
 		else
 			coreinit::OSSchedulerBegin(1);
-		iosu::pdm::StartTrackingTime(GetForegroundTitleId());
 	}
 
 	void LaunchForegroundTitle()
@@ -694,6 +878,13 @@ namespace CafeSystem
 		return sGameInfo_ForegroundTitle.GetVersion();
 	}
 
+	uint32 GetForegroundTitleSDKVersion()
+	{
+		if (sLaunchModeIsStandalone)
+			return 999999;
+		return sGameInfo_ForegroundTitle.GetSDKVersion();
+	}
+
 	CafeConsoleRegion GetForegroundTitleRegion()
 	{
 		if (sLaunchModeIsStandalone)
@@ -704,9 +895,21 @@ namespace CafeSystem
 	std::string GetForegroundTitleName()
 	{
 		if (sLaunchModeIsStandalone)
-			return "Missing meta data";
-		// todo - use language based on Cemu console language
-		return sGameInfo_ForegroundTitle.GetBase().GetMetaInfo()->GetShortName(CafeConsoleLanguage::EN);
+			return "Unknown Game";
+		std::string applicationName;
+		applicationName = sGameInfo_ForegroundTitle.GetBase().GetMetaInfo()->GetShortName(GetConfig().console_language);
+		if (applicationName.empty()) //Try to get the English Title
+			applicationName = sGameInfo_ForegroundTitle.GetBase().GetMetaInfo()->GetShortName(CafeConsoleLanguage::EN);
+		if (applicationName.empty()) //Unknown Game
+			applicationName = "Unknown Game";
+		return applicationName;
+	}
+
+	uint32 GetForegroundTitleOlvAccesskey()
+	{
+		if (sLaunchModeIsStandalone)
+			return -1;
+		return sGameInfo_ForegroundTitle.GetBase().GetMetaInfo()->GetOlvAccesskey();
 	}
 
 	std::string GetForegroundTitleArgStr()
@@ -719,6 +922,47 @@ namespace CafeSystem
 		return sGameInfo_ForegroundTitle.GetBase().GetArgStr();
 	}
 
+	CosCapabilityBits GetForegroundTitleCosCapabilities(CosCapabilityGroup group)
+	{
+		if (sLaunchModeIsStandalone)
+			return CosCapabilityBits::All;
+		auto& update = sGameInfo_ForegroundTitle.GetUpdate();
+		if (update.IsValid())
+		{
+			ParsedCosXml* cosXml = update.GetCosInfo();
+			if (cosXml)
+				return cosXml->GetCapabilityBits(group);
+		}
+		auto& base = sGameInfo_ForegroundTitle.GetBase();
+		if(base.IsValid())
+		{
+			ParsedCosXml* cosXml = base.GetCosInfo();
+			if (cosXml)
+				return cosXml->GetCapabilityBits(group);
+		}
+		return CosCapabilityBits::All;
+	}
+
+	// when switching titles custom parameters can be passed, returns true if override args are used
+	bool GetOverrideArgStr(std::vector<std::string>& args)
+	{
+		args.clear();
+		if(!s_overrideArgs)
+			return false;
+		args = *s_overrideArgs;
+		return true;
+	}
+
+	void SetOverrideArgs(std::span<std::string> args)
+	{
+		s_overrideArgs = std::vector<std::string>(args.begin(), args.end());
+	}
+
+	void UnsetOverrideArgs()
+	{
+		s_overrideArgs = std::nullopt;
+	}
+
 	// pick platform region based on title region
 	CafeConsoleRegion GetPlatformRegion()
 	{
@@ -735,39 +979,32 @@ namespace CafeSystem
 
 	void UnmountCurrentTitle()
 	{
-		TitleInfo& titleBase = sGameInfo_ForegroundTitle.GetBase();
-		if (titleBase.IsValid())
-			titleBase.UnmountAll();
-		if (sGameInfo_ForegroundTitle.HasUpdate())
-		{
-			TitleInfo& titleUpdate = sGameInfo_ForegroundTitle.GetUpdate();
-			if (titleUpdate.IsValid())
-				titleUpdate.UnmountAll();
-		}
-		if (sGameInfo_ForegroundTitle.HasAOC())
-		{
-			auto titleInfoList = sGameInfo_ForegroundTitle.GetAOC();
-			for(auto& it : titleInfoList)
-			{ 
-				if (it.IsValid())
-					it.UnmountAll();
-			}
-		}
-		fsc_unmount("/internal/code/", FSC_PRIORITY_BASE);
+        UnmountForegroundTitle();
+        fsc_unmount("/internal/code/", FSC_PRIORITY_BASE);
 	}
 
 	void ShutdownTitle()
 	{
 		if(!sSystemRunning)
 			return;
-		coreinit::OSSchedulerEnd();
-		Latte_Stop();
-		iosu::pdm::Stop();
-		iosu::act::Stop();
-		iosu::mcp::Shutdown();
-		iosu::fsa::Shutdown();
-		GraphicPack2::Reset();
-		UnmountCurrentTitle();
+        coreinit::OSSchedulerEnd();
+        Latte_Stop();
+        // reset Cafe OS userspace modules
+        snd_core::reset();
+        coreinit::OSAlarm_Shutdown();
+        GX2::_GX2DriverReset();
+        nn::save::ResetToDefaultState();
+        coreinit::__OSDeleteAllActivePPCThreads();
+        RPLLoader_ResetState();
+		for(auto it = s_iosuModules.rbegin(); it != s_iosuModules.rend(); ++it)
+			(*it)->TitleStop();
+        // reset Cemu subsystems
+        PPCRecompiler_Shutdown();
+        GraphicPack2::Reset();
+        UnmountCurrentTitle();
+        MlcStorageUnmountAllTitles();
+        UnmountBaseDirectories();
+        DestroyMemorySpace();
 		sSystemRunning = false;
 	}
 
@@ -817,10 +1054,7 @@ namespace CafeSystem
 		}
 		TitleId titleId = titleInfo.GetAppTitleId();
 		if (m_mlcMountedTitles.find(titleId) != m_mlcMountedTitles.end())
-		{
-			cemu_assert_suspicious(); // already mounted
 			return;
-		}
 		std::string mlcStoragePath = GetMlcStoragePath(titleId);
 		TitleInfo* mountTitleInfo = new TitleInfo(titleInfo);
 		if (!mountTitleInfo->Mount(mlcStoragePath, "", FSC_PRIORITY_BASE))
@@ -847,6 +1081,16 @@ namespace CafeSystem
 			MlcStorageMountTitle(it);
 	}
 
+    void MlcStorageUnmountAllTitles()
+    {
+        for(auto& it : m_mlcMountedTitles)
+        {
+            std::string mlcStoragePath = GetMlcStoragePath(it.first);
+            it.second->Unmount(mlcStoragePath);
+        }
+        m_mlcMountedTitles.clear();
+    }
+
 	uint32 GetRPXHashBase()
 	{
 		return currentBaseApplicationHash;
@@ -857,4 +1101,9 @@ namespace CafeSystem
 		return currentUpdatedApplicationHash;
 	}
 
-}
\ No newline at end of file
+	void RequestRecreateCanvas()
+	{
+		s_implementation->CafeRecreateCanvas();
+	}
+
+}
diff --git a/src/Cafe/CafeSystem.h b/src/Cafe/CafeSystem.h
index dce0b940..e9de8d7d 100644
--- a/src/Cafe/CafeSystem.h
+++ b/src/Cafe/CafeSystem.h
@@ -4,28 +4,46 @@
 #include "Cafe/TitleList/TitleId.h"
 #include "config/CemuConfig.h"
 
+enum class CosCapabilityBits : uint64;
+enum class CosCapabilityGroup : uint32;
+
 namespace CafeSystem
 {
-	enum class STATUS_CODE
+	class SystemImplementation
+	{
+	public:
+		virtual void CafeRecreateCanvas() = 0;
+	};
+
+	enum class PREPARE_STATUS_CODE
 	{
 		SUCCESS,
 		INVALID_RPX,
 		UNABLE_TO_MOUNT, // failed to mount through TitleInfo (most likely caused by an invalid or outdated path)
-		//BAD_META_DATA, - the title list only stores titles with valid meta, so this error code is impossible
 	};
 
 	void Initialize();
-	STATUS_CODE PrepareForegroundTitle(TitleId titleId);
-	STATUS_CODE PrepareForegroundTitleFromStandaloneRPX(const fs::path& path);
+	void SetImplementation(SystemImplementation* impl);
+    void Shutdown();
+
+	PREPARE_STATUS_CODE PrepareForegroundTitle(TitleId titleId);
+	PREPARE_STATUS_CODE PrepareForegroundTitleFromStandaloneRPX(const fs::path& path);
 	void LaunchForegroundTitle();
 	bool IsTitleRunning();
 
+	bool GetOverrideArgStr(std::vector<std::string>& args);
+	void SetOverrideArgs(std::span<std::string> args);
+	void UnsetOverrideArgs();
+
 	TitleId GetForegroundTitleId();
 	uint16 GetForegroundTitleVersion();
+	uint32 GetForegroundTitleSDKVersion();
 	CafeConsoleRegion GetForegroundTitleRegion();
 	CafeConsoleRegion GetPlatformRegion();
 	std::string GetForegroundTitleName();
 	std::string GetForegroundTitleArgStr();
+	uint32 GetForegroundTitleOlvAccesskey();
+	CosCapabilityBits GetForegroundTitleCosCapabilities(CosCapabilityGroup group);
 
 	void ShutdownTitle();
 
@@ -36,6 +54,8 @@ namespace CafeSystem
 
 	uint32 GetRPXHashBase();
 	uint32 GetRPXHashUpdated();
+
+	void RequestRecreateCanvas();
 };
 
 extern RPLModule* applicationRPX;
diff --git a/src/Cafe/Filesystem/FST/FST.cpp b/src/Cafe/Filesystem/FST/FST.cpp
index a4bbfeed..ec112b9a 100644
--- a/src/Cafe/Filesystem/FST/FST.cpp
+++ b/src/Cafe/Filesystem/FST/FST.cpp
@@ -3,8 +3,7 @@
 #include "Cemu/ncrypto/ncrypto.h"
 #include "Cafe/Filesystem/WUD/wud.h"
 #include "util/crypto/aes128.h"
-#include "openssl/evp.h" /* EVP_Digest */
-#include "openssl/sha.h" /* SHA1 / SHA256_DIGEST_LENGTH */
+#include "openssl/sha.h" /* SHA1 / SHA256 */
 #include "fstUtil.h"
 
 #include "FST.h"
@@ -12,6 +11,10 @@
 
 #include "boost/range/adaptor/reversed.hpp"
 
+#define SET_FST_ERROR(__code) 	if (errorCodeOut) *errorCodeOut = ErrorCode::__code
+
+static_assert(sizeof(NCrypto::AesIv) == 16); // make sure IV is actually 16 bytes
+
 class FSTDataSource
 {
 public:
@@ -139,7 +142,7 @@ struct DiscPartitionTableHeader
 	static constexpr uint32 MAGIC_VALUE = 0xCCA6E67B;
 
 	/* +0x00 */ uint32be magic;
-	/* +0x04 */ uint32be sectorSize; // must be 0x8000?
+	/* +0x04 */ uint32be blockSize; // must be 0x8000?
 	/* +0x08 */ uint8 partitionTableHash[20]; // hash of the data range at +0x800 to end of sector (0x8000)
 	/* +0x1C */ uint32be numPartitions;
 };
@@ -162,10 +165,10 @@ struct DiscPartitionHeader
 	static constexpr uint32 MAGIC_VALUE = 0xCC93A4F5;
 
 	/* +0x00 */ uint32be magic;
-	/* +0x04 */ uint32be sectorSize; // must match DISC_SECTOR_SIZE
+	/* +0x04 */ uint32be sectorSize; // must match DISC_SECTOR_SIZE for hashed blocks
 
 	/* +0x08 */ uint32be ukn008;
-	/* +0x0C */ uint32be ukn00C;
+	/* +0x0C */ uint32be ukn00C; // h3 array size?
 	/* +0x10 */ uint32be h3HashNum;
 	/* +0x14 */ uint32be fstSize; // in bytes
 	/* +0x18 */ uint32be fstSector; // relative to partition start
@@ -176,13 +179,15 @@ struct DiscPartitionHeader
 	/* +0x24 */ uint8 fstHashType;
 	/* +0x25 */ uint8 fstEncryptionType; // purpose of this isn't really understood. Maybe it controls which key is being used? (1 -> disc key, 2 -> partition key)
 
-	/* +0x26 */ uint8 versionA;
-	/* +0x27 */ uint8 ukn027; // also a version field?
+	/* +0x26 */ uint8be versionA;
+	/* +0x27 */ uint8be ukn027; // also a version field?
 
 	// there is an array at +0x40 ? Related to H3 list. Also related to value at +0x0C and h3HashNum
+	/* +0x28 */ uint8be _uknOrPadding028[0x18];
+	/* +0x40 */ uint8be h3HashArray[32]; // dynamic size. Only present if fstHashType != 0
 };
 
-static_assert(sizeof(DiscPartitionHeader) == 0x28);
+static_assert(sizeof(DiscPartitionHeader) == 0x40+0x20);
 
 bool FSTVolume::FindDiscKey(const fs::path& path, NCrypto::AesKey& discTitleKey)
 {
@@ -215,23 +220,22 @@ bool FSTVolume::FindDiscKey(const fs::path& path, NCrypto::AesKey& discTitleKey)
 
 // open WUD image using key cache
 // if no matching key is found then keyFound will return false
-FSTVolume* FSTVolume::OpenFromDiscImage(const fs::path& path, bool* keyFound)
+FSTVolume* FSTVolume::OpenFromDiscImage(const fs::path& path, ErrorCode* errorCodeOut)
 {
+	SET_FST_ERROR(UNKNOWN_ERROR);
 	KeyCache_Prepare();
 	NCrypto::AesKey discTitleKey;
 	if (!FindDiscKey(path, discTitleKey))
 	{
-		if(keyFound)
-			*keyFound = false;
+		SET_FST_ERROR(DISC_KEY_MISSING);
 		return nullptr;
 	}
-	if(keyFound)
-		*keyFound = true;
-	return OpenFromDiscImage(path, discTitleKey);
+	return OpenFromDiscImage(path, discTitleKey, errorCodeOut);
 }
 
 // open WUD image
-FSTVolume* FSTVolume::OpenFromDiscImage(const fs::path& path, NCrypto::AesKey& discTitleKey)
+FSTVolume* FSTVolume::OpenFromDiscImage(const fs::path& path, NCrypto::AesKey& discTitleKey, ErrorCode* errorCodeOut)
+
 {
 	// WUD images support multiple partitions, each with their own key and FST
 	// the process for loading game data FSTVolume from a WUD image is as follows:
@@ -240,6 +244,7 @@ FSTVolume* FSTVolume::OpenFromDiscImage(const fs::path& path, NCrypto::AesKey& d
 	// 3) find main GM partition
 	// 4) use SI information to get titleKey for GM partition
 	// 5) Load FST for GM
+	SET_FST_ERROR(UNKNOWN_ERROR);
 	std::unique_ptr<FSTDataSourceWUD> dataSource(FSTDataSourceWUD::Open(path));
 	if (!dataSource)
 		return nullptr;
@@ -267,7 +272,7 @@ FSTVolume* FSTVolume::OpenFromDiscImage(const fs::path& path, NCrypto::AesKey& d
 		cemuLog_log(LogType::Force, "Disc image rejected because decryption failed");
 		return nullptr;
 	}
-	if (partitionHeader->sectorSize != DISC_SECTOR_SIZE)
+	if (partitionHeader->blockSize != DISC_SECTOR_SIZE)
 	{
 		cemuLog_log(LogType::Force, "Disc image rejected because partition sector size is invalid");
 		return nullptr;
@@ -334,6 +339,9 @@ FSTVolume* FSTVolume::OpenFromDiscImage(const fs::path& path, NCrypto::AesKey& d
 	cemu_assert_debug(partitionHeaderSI.fstEncryptionType == 1);
 	// todo - check other fields?
 
+	if(partitionHeaderSI.fstHashType == 0 && partitionHeaderSI.h3HashNum != 0)
+		cemuLog_log(LogType::Force, "FST: Partition uses unhashed blocks but stores a non-zero amount of H3 hashes");
+
 	// GM partition
 	DiscPartitionHeader partitionHeaderGM{};
 	if (!readPartitionHeader(partitionHeaderGM, gmPartitionIndex))
@@ -347,9 +355,10 @@ FSTVolume* FSTVolume::OpenFromDiscImage(const fs::path& path, NCrypto::AesKey& d
 	// if decryption is necessary
 	// load SI FST
 	dataSource->SetBaseOffset((uint64)partitionArray[siPartitionIndex].partitionAddress * DISC_SECTOR_SIZE);
-	auto siFST = OpenFST(dataSource.get(), (uint64)partitionHeaderSI.fstSector * DISC_SECTOR_SIZE, partitionHeaderSI.fstSize, &discTitleKey, static_cast<FSTVolume::ClusterHashMode>(partitionHeaderSI.fstHashType));
+	auto siFST = OpenFST(dataSource.get(), (uint64)partitionHeaderSI.fstSector * DISC_SECTOR_SIZE, partitionHeaderSI.fstSize, &discTitleKey, static_cast<FSTVolume::ClusterHashMode>(partitionHeaderSI.fstHashType), nullptr);
 	if (!siFST)
 		return nullptr;
+	cemu_assert_debug(!(siFST->HashIsDisabled() && partitionHeaderSI.h3HashNum != 0)); // if hash is disabled, no H3 data may be present
 	// load ticket file for partition that we want to decrypt
 	NCrypto::ETicketParser ticketParser;
 	std::vector<uint8> ticketData = siFST->ExtractFile(fmt::format("{:02x}/title.tik", gmPartitionIndex));
@@ -358,18 +367,38 @@ FSTVolume* FSTVolume::OpenFromDiscImage(const fs::path& path, NCrypto::AesKey& d
 		cemuLog_log(LogType::Force, "Disc image ticket file is invalid");
 		return nullptr;
 	}
+#if 0
+	// each SI partition seems to contain a title.tmd that we could parse and which should have information about the associated GM partition
+	// but the console seems to ignore this file for disc images, at least when mounting, so we shouldn't rely on it either
+	std::vector<uint8> tmdData = siFST->ExtractFile(fmt::format("{:02x}/title.tmd", gmPartitionIndex));
+	if (tmdData.empty())
+	{
+		cemuLog_log(LogType::Force, "Disc image TMD file is missing");
+		return nullptr;
+	}
+	// parse TMD
+	NCrypto::TMDParser tmdParser;
+	if (!tmdParser.parse(tmdData.data(), tmdData.size()))
+	{
+		cemuLog_log(LogType::Force, "Disc image TMD file is invalid");
+		return nullptr;
+	}
+#endif
 	delete siFST;
-
 	NCrypto::AesKey gmTitleKey;
 	ticketParser.GetTitleKey(gmTitleKey);
-
 	// load GM partition
 	dataSource->SetBaseOffset((uint64)partitionArray[gmPartitionIndex].partitionAddress * DISC_SECTOR_SIZE);
-	return OpenFST(std::move(dataSource), (uint64)partitionHeaderGM.fstSector * DISC_SECTOR_SIZE, partitionHeaderGM.fstSize, &gmTitleKey, static_cast<FSTVolume::ClusterHashMode>(partitionHeaderGM.fstHashType));
+	FSTVolume* r = OpenFST(std::move(dataSource), (uint64)partitionHeaderGM.fstSector * DISC_SECTOR_SIZE, partitionHeaderGM.fstSize, &gmTitleKey, static_cast<FSTVolume::ClusterHashMode>(partitionHeaderGM.fstHashType), nullptr);
+	if (r)
+		SET_FST_ERROR(OK);
+	cemu_assert_debug(!(r->HashIsDisabled() && partitionHeaderGM.h3HashNum != 0)); // if hash is disabled, no H3 data may be present
+	return r;
 }
 
-FSTVolume* FSTVolume::OpenFromContentFolder(fs::path folderPath)
+FSTVolume* FSTVolume::OpenFromContentFolder(fs::path folderPath, ErrorCode* errorCodeOut)
 {
+	SET_FST_ERROR(UNKNOWN_ERROR);
 	// load TMD
 	FileStream* tmdFile = FileStream::openFile2(folderPath / "title.tmd");
 	if (!tmdFile)
@@ -379,17 +408,26 @@ FSTVolume* FSTVolume::OpenFromContentFolder(fs::path folderPath)
 	delete tmdFile;
 	NCrypto::TMDParser tmdParser;
 	if (!tmdParser.parse(tmdData.data(), tmdData.size()))
+	{
+		SET_FST_ERROR(BAD_TITLE_TMD);
 		return nullptr;
+	}
 	// load ticket
 	FileStream* ticketFile = FileStream::openFile2(folderPath / "title.tik");
 	if (!ticketFile)
+	{
+		SET_FST_ERROR(TITLE_TIK_MISSING);
 		return nullptr;
+	}
 	std::vector<uint8> ticketData;
 	ticketFile->extract(ticketData);
 	delete ticketFile;
 	NCrypto::ETicketParser ticketParser;
 	if (!ticketParser.parse(ticketData.data(), ticketData.size()))
+	{
+		SET_FST_ERROR(BAD_TITLE_TIK);
 		return nullptr;
+	}
 	NCrypto::AesKey titleKey;
 	ticketParser.GetTitleKey(titleKey);
 	// open data source
@@ -411,13 +449,15 @@ FSTVolume* FSTVolume::OpenFromContentFolder(fs::path folderPath)
 	}
 	// load FST
 	// fstSize = size of first cluster?
-	FSTVolume* fstVolume = FSTVolume::OpenFST(std::move(dataSource), 0, fstSize, &titleKey, fstHashMode);
+	FSTVolume* fstVolume = FSTVolume::OpenFST(std::move(dataSource), 0, fstSize, &titleKey, fstHashMode, &tmdParser);
+	if (fstVolume)
+		SET_FST_ERROR(OK);
 	return fstVolume;
 }
 
-FSTVolume* FSTVolume::OpenFST(FSTDataSource* dataSource, uint64 fstOffset, uint32 fstSize, NCrypto::AesKey* partitionTitleKey, ClusterHashMode fstHashMode)
+FSTVolume* FSTVolume::OpenFST(FSTDataSource* dataSource, uint64 fstOffset, uint32 fstSize, NCrypto::AesKey* partitionTitleKey, ClusterHashMode fstHashMode, NCrypto::TMDParser* optionalTMD)
 {
-	cemu_assert_debug(fstHashMode != ClusterHashMode::RAW || fstHashMode != ClusterHashMode::RAW2);
+	cemu_assert_debug(fstHashMode != ClusterHashMode::RAW || fstHashMode != ClusterHashMode::RAW_STREAM);
 	if (fstSize < sizeof(FSTHeader))
 		return nullptr;
 	constexpr uint64 FST_CLUSTER_OFFSET = 0;
@@ -448,6 +488,34 @@ FSTVolume* FSTVolume::OpenFST(FSTDataSource* dataSource, uint64 fstOffset, uint3
 		clusterTable[i].offset = clusterDataTable[i].offset;
 		clusterTable[i].size = clusterDataTable[i].size;
 		clusterTable[i].hashMode = static_cast<FSTVolume::ClusterHashMode>((uint8)clusterDataTable[i].hashMode);
+		clusterTable[i].hasContentHash = false; // from the TMD file (H4?)
+	}
+	// if the TMD is available (when opening .app files) we can use the extra info from it to validate unhashed clusters
+	// each content entry in the TMD corresponds to one cluster used by the FST
+	if(optionalTMD)
+	{
+		if(numCluster != optionalTMD->GetContentList().size())
+		{
+			cemuLog_log(LogType::Force, "FST: Number of clusters does not match TMD content list");
+			return nullptr;
+		}
+		auto& contentList = optionalTMD->GetContentList();
+		for(size_t i=0; i<contentList.size(); i++)
+		{
+			auto& cluster = clusterTable[i];
+			auto& content = contentList[i];
+			cluster.hasContentHash = true;
+			cluster.contentHashIsSHA1 = HAS_FLAG(contentList[i].contentFlags, NCrypto::TMDParser::TMDContentFlags::FLAG_SHA1);
+			cluster.contentSize = content.size;
+			static_assert(sizeof(content.hash32) == sizeof(cluster.contentHash32));
+			memcpy(cluster.contentHash32, content.hash32, sizeof(cluster.contentHash32));
+			// if unhashed mode, then initialize the hash context
+			if(cluster.hashMode == ClusterHashMode::RAW || cluster.hashMode == ClusterHashMode::RAW_STREAM)
+			{
+				cluster.singleHashCtx.reset(EVP_MD_CTX_new());
+				EVP_DigestInit_ex(cluster.singleHashCtx.get(), cluster.contentHashIsSHA1 ? EVP_sha1() : EVP_sha256(), nullptr);
+			}
+		}
 	}
 	// preprocess FST table
 	FSTHeader_FileEntry* fileTable = (FSTHeader_FileEntry*)(clusterDataTable + numCluster);
@@ -474,16 +542,17 @@ FSTVolume* FSTVolume::OpenFST(FSTDataSource* dataSource, uint64 fstOffset, uint3
 	fstVolume->m_offsetFactor = fstHeader->offsetFactor;
 	fstVolume->m_sectorSize = DISC_SECTOR_SIZE;
 	fstVolume->m_partitionTitlekey = *partitionTitleKey;
-	std::swap(fstVolume->m_cluster, clusterTable);
-	std::swap(fstVolume->m_entries, fstEntries);
-	std::swap(fstVolume->m_nameStringTable, nameStringTable);
+	fstVolume->m_hashIsDisabled = fstHeader->hashIsDisabled != 0;
+	fstVolume->m_cluster = std::move(clusterTable);
+	fstVolume->m_entries = std::move(fstEntries);
+	fstVolume->m_nameStringTable = std::move(nameStringTable);
 	return fstVolume;
 }
 
-FSTVolume* FSTVolume::OpenFST(std::unique_ptr<FSTDataSource> dataSource, uint64 fstOffset, uint32 fstSize, NCrypto::AesKey* partitionTitleKey, ClusterHashMode fstHashMode)
+FSTVolume* FSTVolume::OpenFST(std::unique_ptr<FSTDataSource> dataSource, uint64 fstOffset, uint32 fstSize, NCrypto::AesKey* partitionTitleKey, ClusterHashMode fstHashMode, NCrypto::TMDParser* optionalTMD)
 {
 	FSTDataSource* ds = dataSource.release();
-	FSTVolume* fstVolume = OpenFST(ds, fstOffset, fstSize, partitionTitleKey, fstHashMode);
+	FSTVolume* fstVolume = OpenFST(ds, fstOffset, fstSize, partitionTitleKey, fstHashMode, optionalTMD);
 	if (!fstVolume)
 	{
 		delete ds;
@@ -669,25 +738,25 @@ bool FSTVolume::OpenFile(std::string_view path, FSTFileHandle& fileHandleOut, bo
 	return true;
 }
 
-bool FSTVolume::IsDirectory(FSTFileHandle& fileHandle) const
+bool FSTVolume::IsDirectory(const FSTFileHandle& fileHandle) const
 {
 	cemu_assert_debug(fileHandle.m_fstIndex < m_entries.size());
 	return m_entries[fileHandle.m_fstIndex].GetType() == FSTEntry::TYPE::DIRECTORY;
 };
 
-bool FSTVolume::IsFile(FSTFileHandle& fileHandle) const
+bool FSTVolume::IsFile(const FSTFileHandle& fileHandle) const
 {
 	cemu_assert_debug(fileHandle.m_fstIndex < m_entries.size());
 	return m_entries[fileHandle.m_fstIndex].GetType() == FSTEntry::TYPE::FILE;
 };
 
-bool FSTVolume::HasLinkFlag(FSTFileHandle& fileHandle) const
+bool FSTVolume::HasLinkFlag(const FSTFileHandle& fileHandle) const
 {
 	cemu_assert_debug(fileHandle.m_fstIndex < m_entries.size());
 	return HAS_FLAG(m_entries[fileHandle.m_fstIndex].GetFlags(), FSTEntry::FLAGS::FLAG_LINK);
 };
 
-std::string_view FSTVolume::GetName(FSTFileHandle& fileHandle) const
+std::string_view FSTVolume::GetName(const FSTFileHandle& fileHandle) const
 {
 	if (fileHandle.m_fstIndex > m_entries.size())
 		return "";
@@ -695,7 +764,7 @@ std::string_view FSTVolume::GetName(FSTFileHandle& fileHandle) const
 	return entryName;
 }
 
-std::string FSTVolume::GetPath(FSTFileHandle& fileHandle) const
+std::string FSTVolume::GetPath(const FSTFileHandle& fileHandle) const
 {
 	std::string path;
 	auto& entry = m_entries[fileHandle.m_fstIndex];
@@ -726,7 +795,7 @@ std::string FSTVolume::GetPath(FSTFileHandle& fileHandle) const
 	return path;
 }
 
-uint32 FSTVolume::GetFileSize(FSTFileHandle& fileHandle) const
+uint32 FSTVolume::GetFileSize(const FSTFileHandle& fileHandle) const
 {
 	if (m_entries[fileHandle.m_fstIndex].GetType() != FSTEntry::TYPE::FILE)
 		return 0;
@@ -740,7 +809,7 @@ uint32 FSTVolume::ReadFile(FSTFileHandle& fileHandle, uint32 offset, uint32 size
 		return 0;
 	cemu_assert_debug(!HAS_FLAG(entry.GetFlags(), FSTEntry::FLAGS::FLAG_LINK));
 	FSTCluster& cluster = m_cluster[entry.fileInfo.clusterIndex];
-	if (cluster.hashMode == ClusterHashMode::RAW || cluster.hashMode == ClusterHashMode::RAW2)
+	if (cluster.hashMode == ClusterHashMode::RAW || cluster.hashMode == ClusterHashMode::RAW_STREAM)
 		return ReadFile_HashModeRaw(entry.fileInfo.clusterIndex, entry, offset, size, dataOut);
 	else if (cluster.hashMode == ClusterHashMode::HASH_INTERLEAVED)
 		return ReadFile_HashModeHashed(entry.fileInfo.clusterIndex, entry, offset, size, dataOut);
@@ -748,87 +817,15 @@ uint32 FSTVolume::ReadFile(FSTFileHandle& fileHandle, uint32 offset, uint32 size
 	return 0;
 }
 
-uint32 FSTVolume::ReadFile_HashModeRaw(uint32 clusterIndex, FSTEntry& entry, uint32 readOffset, uint32 readSize, void* dataOut)
-{
-	const uint32 readSizeInput = readSize;
-	uint8* dataOutU8 = (uint8*)dataOut;
-	if (readOffset >= entry.fileInfo.fileSize)
-		return 0;
-	else if ((readOffset + readSize) >= entry.fileInfo.fileSize)
-		readSize = (entry.fileInfo.fileSize - readOffset);
-
-	const FSTCluster& cluster = m_cluster[clusterIndex];
-	uint64 clusterOffset = (uint64)cluster.offset * m_sectorSize;
-	uint64 absFileOffset = entry.fileInfo.fileOffset * m_offsetFactor + readOffset;
-
-	// make sure the raw range we read is aligned to AES block size (16)
-	uint64 readAddrStart = absFileOffset & ~0xF;
-	uint64 readAddrEnd = (absFileOffset + readSize + 0xF) & ~0xF;
-
-	bool usesInitialIV = readOffset < 16;
-	if (!usesInitialIV)
-		readAddrStart -= 16; // read previous AES block since we require it for the IV
-	uint32 prePadding = (uint32)(absFileOffset - readAddrStart); // number of extra bytes we read before readOffset (for AES alignment and IV calculation)
-	uint32 postPadding = (uint32)(readAddrEnd - (absFileOffset + readSize));
-
-	uint8 readBuffer[64 * 1024];
-	// read first chunk
-	// if file read offset (readOffset) is within the first AES-block then use initial IV calculated from cluster index
-	// otherwise read previous AES-block is the IV (AES-CBC)
-	uint64 readAddrCurrent = readAddrStart;
-	uint32 rawBytesToRead = (uint32)std::min((readAddrEnd - readAddrStart), (uint64)sizeof(readBuffer));
-	if (m_dataSource->readData(clusterIndex, clusterOffset, readAddrCurrent, readBuffer, rawBytesToRead) != rawBytesToRead)
-	{
-		cemuLog_log(LogType::Force, "FST read error in raw content");
-		return 0;
-	}
-	readAddrCurrent += rawBytesToRead;
-
-	uint8 iv[16]{};
-	if (usesInitialIV)
-	{
-		// for the first AES block, the IV is initialized from cluster index
-		iv[0] = (uint8)(clusterIndex >> 8);
-		iv[1] = (uint8)(clusterIndex >> 0);
-		AES128_CBC_decrypt_updateIV(readBuffer, readBuffer, rawBytesToRead, m_partitionTitlekey.b, iv);
-		std::memcpy(dataOutU8, readBuffer + prePadding, rawBytesToRead - prePadding - postPadding);
-		dataOutU8 += (rawBytesToRead - prePadding - postPadding);
-		readSize -= (rawBytesToRead - prePadding - postPadding);
-	}
-	else
-	{
-		// IV is initialized from previous AES block (AES-CBC)
-		std::memcpy(iv, readBuffer, 16);
-		AES128_CBC_decrypt_updateIV(readBuffer + 16, readBuffer + 16, rawBytesToRead - 16, m_partitionTitlekey.b, iv);
-		std::memcpy(dataOutU8, readBuffer + prePadding, rawBytesToRead - prePadding - postPadding);
-		dataOutU8 += (rawBytesToRead - prePadding - postPadding);
-		readSize -= (rawBytesToRead - prePadding - postPadding);
-	}
-
-	// read remaining chunks
-	while (readSize > 0)
-	{
-		uint32 bytesToRead = (uint32)std::min((uint32)sizeof(readBuffer), readSize);
-		uint32 alignedBytesToRead = (bytesToRead + 15) & ~0xF;
-		if (m_dataSource->readData(clusterIndex, clusterOffset, readAddrCurrent, readBuffer, alignedBytesToRead) != alignedBytesToRead)
-		{
-			cemuLog_log(LogType::Force, "FST read error in raw content");
-			return 0;
-		}
-		AES128_CBC_decrypt_updateIV(readBuffer, readBuffer, alignedBytesToRead, m_partitionTitlekey.b, iv);
-		std::memcpy(dataOutU8, readBuffer, bytesToRead);
-		dataOutU8 += bytesToRead;
-		readSize -= bytesToRead;
-		readAddrCurrent += alignedBytesToRead;
-	}
-
-	return readSizeInput - readSize;
-}
-
 constexpr size_t BLOCK_SIZE = 0x10000;
 constexpr size_t BLOCK_HASH_SIZE = 0x0400;
 constexpr size_t BLOCK_FILE_SIZE = 0xFC00;
 
+struct FSTRawBlock
+{
+	std::vector<uint8> rawData; // unhashed block size depends on sector size field in partition header
+};
+
 struct FSTHashedBlock
 {
 	uint8 rawData[BLOCK_SIZE];
@@ -870,12 +867,160 @@ struct FSTHashedBlock
 
 static_assert(sizeof(FSTHashedBlock) == BLOCK_SIZE);
 
+struct FSTCachedRawBlock
+{
+	FSTRawBlock blockData;
+	NCrypto::AesIv ivForNextBlock;
+	uint64 lastAccess;
+};
+
 struct FSTCachedHashedBlock 
 {
 	FSTHashedBlock blockData;
 	uint64 lastAccess;
 };
 
+// Checks cache fill state and if necessary drops least recently accessed block from the cache. Optionally allows to recycle the released cache entry to cut down cost of memory allocation and clearing
+void FSTVolume::TrimCacheIfRequired(FSTCachedRawBlock** droppedRawBlock, FSTCachedHashedBlock** droppedHashedBlock)
+{
+	// calculate size used by cache
+	size_t cacheSize = 0;
+	for (auto& itr : m_cacheDecryptedRawBlocks)
+		cacheSize += itr.second->blockData.rawData.size();
+	for (auto& itr : m_cacheDecryptedHashedBlocks)
+		cacheSize += sizeof(FSTCachedHashedBlock) + sizeof(FSTHashedBlock);
+	// only trim if cache is full (larger than 2MB)
+	if (cacheSize < 2*1024*1024) // 2MB
+		return;
+	// scan both cache lists to find least recently accessed block to drop
+	auto dropRawItr = std::min_element(m_cacheDecryptedRawBlocks.begin(), m_cacheDecryptedRawBlocks.end(), [](const auto& a, const auto& b) -> bool
+										{ return a.second->lastAccess < b.second->lastAccess; });
+	auto dropHashedItr = std::min_element(m_cacheDecryptedHashedBlocks.begin(), m_cacheDecryptedHashedBlocks.end(), [](const auto& a, const auto& b) -> bool
+										{ return a.second->lastAccess < b.second->lastAccess; });
+	uint64 lastAccess = std::numeric_limits<uint64>::max();
+	if(dropRawItr != m_cacheDecryptedRawBlocks.end())
+		lastAccess = dropRawItr->second->lastAccess;
+	if(dropHashedItr != m_cacheDecryptedHashedBlocks.end())
+		lastAccess = std::min<uint64>(lastAccess, dropHashedItr->second->lastAccess);
+	if(dropRawItr != m_cacheDecryptedRawBlocks.end() && dropRawItr->second->lastAccess == lastAccess)
+	{
+		if (droppedRawBlock)
+			*droppedRawBlock = dropRawItr->second;
+		else
+			delete dropRawItr->second;
+		m_cacheDecryptedRawBlocks.erase(dropRawItr);
+		return;
+	}
+	else if(dropHashedItr != m_cacheDecryptedHashedBlocks.end() && dropHashedItr->second->lastAccess == lastAccess)
+	{
+		if (droppedHashedBlock)
+			*droppedHashedBlock = dropHashedItr->second;
+		else
+			delete dropHashedItr->second;
+		m_cacheDecryptedHashedBlocks.erase(dropHashedItr);
+	}
+}
+
+void FSTVolume::DetermineUnhashedBlockIV(uint32 clusterIndex, uint32 blockIndex, NCrypto::AesIv& ivOut)
+{
+	ivOut = {};
+	if(blockIndex == 0)
+	{
+		ivOut.iv[0] = (uint8)(clusterIndex >> 8);
+		ivOut.iv[1] = (uint8)(clusterIndex >> 0);
+	}
+	else
+	{
+		// the last 16 encrypted bytes of the previous block are the IV (AES CBC)
+		// if the previous block is cached we can grab the IV from there. Otherwise we have to read the 16 bytes from the data source
+		uint32 prevBlockIndex = blockIndex - 1;
+		uint64 cacheBlockId = ((uint64)clusterIndex << (64 - 16)) | (uint64)prevBlockIndex;
+		auto itr = m_cacheDecryptedRawBlocks.find(cacheBlockId);
+		if (itr != m_cacheDecryptedRawBlocks.end())
+		{
+			ivOut = itr->second->ivForNextBlock;
+		}
+		else
+		{
+			cemu_assert(m_sectorSize >= NCrypto::AesIv::SIZE);
+			uint64 clusterOffset = (uint64)m_cluster[clusterIndex].offset * m_sectorSize;
+			NCrypto::AesIv prevIV{};
+			if (m_dataSource->readData(clusterIndex, clusterOffset, blockIndex * m_sectorSize - NCrypto::AesIv::SIZE, prevIV.iv, NCrypto::AesIv::SIZE) != NCrypto::AesIv::SIZE)
+			{
+				cemuLog_log(LogType::Force, "Failed to read IV for raw FST block");
+				m_detectedCorruption = true;
+				return;
+			}
+			ivOut = prevIV;
+		}
+	}
+}
+
+FSTCachedRawBlock* FSTVolume::GetDecryptedRawBlock(uint32 clusterIndex, uint32 blockIndex)
+{
+	FSTCluster& cluster = m_cluster[clusterIndex];
+	uint64 clusterOffset = (uint64)cluster.offset * m_sectorSize;
+	// generate id for cache
+	uint64 cacheBlockId = ((uint64)clusterIndex << (64 - 16)) | (uint64)blockIndex;
+	// lookup block in cache
+	FSTCachedRawBlock* block = nullptr;
+	auto itr = m_cacheDecryptedRawBlocks.find(cacheBlockId);
+	if (itr != m_cacheDecryptedRawBlocks.end())
+	{
+		block = itr->second;
+		block->lastAccess = ++m_cacheAccessCounter;
+		return block;
+	}
+	// if cache already full, drop least recently accessed block and recycle FSTCachedRawBlock object if possible
+	TrimCacheIfRequired(&block, nullptr);
+	if (!block)
+		block = new FSTCachedRawBlock();
+	block->blockData.rawData.resize(m_sectorSize);
+	// block not cached, read new
+	block->lastAccess = ++m_cacheAccessCounter;
+	if (m_dataSource->readData(clusterIndex, clusterOffset, blockIndex * m_sectorSize, block->blockData.rawData.data(), m_sectorSize) != m_sectorSize)
+	{
+		cemuLog_log(LogType::Force, "Failed to read raw FST block");
+		delete block;
+		m_detectedCorruption = true;
+		return nullptr;
+	}
+	// decrypt hash data
+	NCrypto::AesIv iv{};
+	DetermineUnhashedBlockIV(clusterIndex, blockIndex, iv);
+	std::copy(block->blockData.rawData.data() + m_sectorSize - NCrypto::AesIv::SIZE, block->blockData.rawData.data() + m_sectorSize, block->ivForNextBlock.iv);
+	AES128_CBC_decrypt(block->blockData.rawData.data(), block->blockData.rawData.data(), m_sectorSize, m_partitionTitlekey.b, iv.iv);
+	// if this is the next block, then hash it
+	if(cluster.hasContentHash)
+	{
+		if(cluster.singleHashNumBlocksHashed == blockIndex)
+		{
+			cemu_assert_debug(!(cluster.contentSize % m_sectorSize)); // size should be multiple of sector size? Regardless, the hashing code below can handle non-aligned sizes
+			bool isLastBlock = blockIndex == (std::max<uint32>(cluster.contentSize / m_sectorSize, 1) - 1);
+			uint32 hashSize = m_sectorSize;
+			if(isLastBlock)
+				hashSize = cluster.contentSize - (uint64)blockIndex*m_sectorSize;
+			EVP_DigestUpdate(cluster.singleHashCtx.get(), block->blockData.rawData.data(), hashSize);
+			cluster.singleHashNumBlocksHashed++;
+			if(isLastBlock)
+			{
+				uint8 hash[32];
+				EVP_DigestFinal_ex(cluster.singleHashCtx.get(), hash, nullptr);
+				if(memcmp(hash, cluster.contentHash32, cluster.contentHashIsSHA1 ? 20 : 32) != 0)
+				{
+					cemuLog_log(LogType::Force, "FST: Raw section hash mismatch");
+					delete block;
+					m_detectedCorruption = true;
+					return nullptr;
+				}
+			}
+		}
+	}
+	// register in cache
+	m_cacheDecryptedRawBlocks.emplace(cacheBlockId, block);
+	return block;
+}
+
 FSTCachedHashedBlock* FSTVolume::GetDecryptedHashedBlock(uint32 clusterIndex, uint32 blockIndex)
 {
 	const FSTCluster& cluster = m_cluster[clusterIndex];
@@ -891,22 +1036,17 @@ FSTCachedHashedBlock* FSTVolume::GetDecryptedHashedBlock(uint32 clusterIndex, ui
 		block->lastAccess = ++m_cacheAccessCounter;
 		return block;
 	}
-	// if cache already full, drop least recently accessed block (but recycle the FSTHashedBlock* object)
-	if (m_cacheDecryptedHashedBlocks.size() >= 16)
-	{
-		auto dropItr = std::min_element(m_cacheDecryptedHashedBlocks.begin(), m_cacheDecryptedHashedBlocks.end(), [](const auto& a, const auto& b) -> bool
-		{ return a.second->lastAccess < b.second->lastAccess; });
-		block = dropItr->second;
-		m_cacheDecryptedHashedBlocks.erase(dropItr);
-	}
-	else
+	// if cache already full, drop least recently accessed block and recycle FSTCachedHashedBlock object if possible
+	TrimCacheIfRequired(nullptr, &block);
+	if (!block)
 		block = new FSTCachedHashedBlock();
 	// block not cached, read new
 	block->lastAccess = ++m_cacheAccessCounter;
 	if (m_dataSource->readData(clusterIndex, clusterOffset, blockIndex * BLOCK_SIZE, block->blockData.rawData, BLOCK_SIZE) != BLOCK_SIZE)
 	{
-		cemuLog_log(LogType::Force, "Failed to read FST block");
+		cemuLog_log(LogType::Force, "Failed to read hashed FST block");
 		delete block;
+		m_detectedCorruption = true;
 		return nullptr;
 	}
 	// decrypt hash data
@@ -914,11 +1054,46 @@ FSTCachedHashedBlock* FSTVolume::GetDecryptedHashedBlock(uint32 clusterIndex, ui
 	AES128_CBC_decrypt(block->blockData.getHashData(), block->blockData.getHashData(), BLOCK_HASH_SIZE, m_partitionTitlekey.b, iv);
 	// decrypt file data
 	AES128_CBC_decrypt(block->blockData.getFileData(), block->blockData.getFileData(), BLOCK_FILE_SIZE, m_partitionTitlekey.b, block->blockData.getH0Hash(blockIndex%16));
+	// compare with H0 to verify data integrity
+	NCrypto::CHash160 h0;
+	SHA1(block->blockData.getFileData(), BLOCK_FILE_SIZE, h0.b);
+	uint32 h0Index = (blockIndex % 4096);
+	if (memcmp(h0.b, block->blockData.getH0Hash(h0Index & 0xF), sizeof(h0.b)) != 0)
+	{
+		cemuLog_log(LogType::Force, "FST: Hash H0 mismatch in hashed block (section {} index {})", clusterIndex, blockIndex);
+		delete block;
+		m_detectedCorruption = true;
+		return nullptr;
+	}
 	// register in cache
 	m_cacheDecryptedHashedBlocks.emplace(cacheBlockId, block);
 	return block;
 }
 
+uint32 FSTVolume::ReadFile_HashModeRaw(uint32 clusterIndex, FSTEntry& entry, uint32 readOffset, uint32 readSize, void* dataOut)
+{
+	uint8* dataOutU8 = (uint8*)dataOut;
+	if (readOffset >= entry.fileInfo.fileSize)
+		return 0;
+	else if ((readOffset + readSize) >= entry.fileInfo.fileSize)
+		readSize = (entry.fileInfo.fileSize - readOffset);
+	uint64 absFileOffset = entry.fileInfo.fileOffset * m_offsetFactor + readOffset;
+	uint32 remainingReadSize = readSize;
+	while (remainingReadSize > 0)
+	{
+		const FSTCachedRawBlock* rawBlock = this->GetDecryptedRawBlock(clusterIndex, absFileOffset/m_sectorSize);
+		if (!rawBlock)
+			break;
+		uint32 blockOffset = (uint32)(absFileOffset % m_sectorSize);
+		uint32 bytesToRead = std::min<uint32>(remainingReadSize, m_sectorSize - blockOffset);
+		std::memcpy(dataOutU8, rawBlock->blockData.rawData.data() + blockOffset, bytesToRead);
+		dataOutU8 += bytesToRead;
+		remainingReadSize -= bytesToRead;
+		absFileOffset += bytesToRead;
+	}
+	return readSize - remainingReadSize;
+}
+
 uint32 FSTVolume::ReadFile_HashModeHashed(uint32 clusterIndex, FSTEntry& entry, uint32 readOffset, uint32 readSize, void* dataOut)
 {
 	/*
@@ -949,7 +1124,6 @@ uint32 FSTVolume::ReadFile_HashModeHashed(uint32 clusterIndex, FSTEntry& entry,
 	*/
 
 	const FSTCluster& cluster = m_cluster[clusterIndex];
-	uint64 clusterBaseOffset = (uint64)cluster.offset * m_sectorSize;
 	uint64 fileReadOffset = entry.fileInfo.fileOffset * m_offsetFactor + readOffset;
 	uint32 blockIndex = (uint32)(fileReadOffset / BLOCK_FILE_SIZE);
 	uint32 bytesRemaining = readSize;
@@ -977,6 +1151,7 @@ bool FSTVolume::OpenDirectoryIterator(std::string_view path, FSTDirectoryIterato
 	if (!IsDirectory(fileHandle))
 		return false;
 	auto const& fstEntry = m_entries[fileHandle.m_fstIndex];
+	directoryIteratorOut.dirHandle = fileHandle;
 	directoryIteratorOut.startIndex = fileHandle.m_fstIndex + 1;
 	directoryIteratorOut.endIndex = fstEntry.dirInfo.endIndex;
 	directoryIteratorOut.currentIndex = directoryIteratorOut.startIndex;
@@ -1001,6 +1176,8 @@ bool FSTVolume::Next(FSTDirectoryIterator& directoryIterator, FSTFileHandle& fil
 
 FSTVolume::~FSTVolume()
 {
+	for (auto& itr : m_cacheDecryptedRawBlocks)
+		delete itr.second;
 	for (auto& itr : m_cacheDecryptedHashedBlocks)
 		delete itr.second;
 	if (m_sourceIsOwned)
@@ -1097,4 +1274,4 @@ bool FSTVerifier::VerifyHashedContentFile(FileStream* fileContent, const NCrypto
 void FSTVolumeTest()
 {
 	FSTPathUnitTest();
-}
\ No newline at end of file
+}
diff --git a/src/Cafe/Filesystem/FST/FST.h b/src/Cafe/Filesystem/FST/FST.h
index 3f59152f..26201c32 100644
--- a/src/Cafe/Filesystem/FST/FST.h
+++ b/src/Cafe/Filesystem/FST/FST.h
@@ -1,5 +1,6 @@
 #pragma once
 #include "Cemu/ncrypto/ncrypto.h"
+#include "openssl/evp.h"
 
 struct FSTFileHandle
 {
@@ -11,7 +12,13 @@ private:
 struct FSTDirectoryIterator
 {
 	friend class FSTVolume;
+
+	const FSTFileHandle& GetDirHandle() const
+	{
+		return dirHandle;
+	}
 private:
+    FSTFileHandle dirHandle;
 	uint32 startIndex;
 	uint32 endIndex;
 	uint32 currentIndex;
@@ -20,28 +27,39 @@ private:
 class FSTVolume
 {
 public:
+	enum class ErrorCode
+  	{
+		OK = 0,
+		UNKNOWN_ERROR = 1,
+	  	DISC_KEY_MISSING = 2,
+	  	TITLE_TIK_MISSING = 3,
+	    BAD_TITLE_TMD = 4,
+	    BAD_TITLE_TIK = 5,
+  	};
+
 	static bool FindDiscKey(const fs::path& path, NCrypto::AesKey& discTitleKey);
 
-	static FSTVolume* OpenFromDiscImage(const fs::path& path, NCrypto::AesKey& discTitleKey);
-	static FSTVolume* OpenFromDiscImage(const fs::path& path, bool* keyFound = nullptr);
-	static FSTVolume* OpenFromContentFolder(fs::path folderPath);
+	static FSTVolume* OpenFromDiscImage(const fs::path& path, NCrypto::AesKey& discTitleKey, ErrorCode* errorCodeOut = nullptr);
+	static FSTVolume* OpenFromDiscImage(const fs::path& path, ErrorCode* errorCodeOut = nullptr);
+	static FSTVolume* OpenFromContentFolder(fs::path folderPath, ErrorCode* errorCodeOut = nullptr);
 
 	~FSTVolume();
 
 	uint32 GetFileCount() const;
+	bool HasCorruption() const { return m_detectedCorruption; }
 
 	bool OpenFile(std::string_view path, FSTFileHandle& fileHandleOut, bool openOnlyFiles = false);
 
 	// file and directory functions
-	bool IsDirectory(FSTFileHandle& fileHandle) const;
-	bool IsFile(FSTFileHandle& fileHandle) const;
-	bool HasLinkFlag(FSTFileHandle& fileHandle) const;
+	bool IsDirectory(const FSTFileHandle& fileHandle) const;
+	bool IsFile(const FSTFileHandle& fileHandle) const;
+	bool HasLinkFlag(const FSTFileHandle& fileHandle) const;
 
-	std::string_view GetName(FSTFileHandle& fileHandle) const;
-	std::string GetPath(FSTFileHandle& fileHandle) const;
+	std::string_view GetName(const FSTFileHandle& fileHandle) const;
+	std::string GetPath(const FSTFileHandle& fileHandle) const;
 
 	// file functions
-	uint32 GetFileSize(FSTFileHandle& fileHandle) const;
+	uint32 GetFileSize(const FSTFileHandle& fileHandle) const;
 	uint32 ReadFile(FSTFileHandle& fileHandle, uint32 offset, uint32 size, void* dataOut);
 
 	// directory iterator
@@ -65,20 +83,29 @@ public:
 	}
 
 private:
-
 	/* FST data (in memory) */
 	enum class ClusterHashMode : uint8
 	{
 		RAW = 0, // raw data + encryption, no hashing?
-		RAW2 = 1, // raw data + encryption, with hash stored in tmd?
+	  	RAW_STREAM = 1, // raw data + encryption, with hash stored in tmd?
 		HASH_INTERLEAVED = 2, // hashes + raw interleaved in 0x10000 blocks (0x400 bytes of hashes at the beginning, followed by 0xFC00 bytes of data)
 	};
 
 	struct FSTCluster
 	{
+		FSTCluster() : singleHashCtx(nullptr, &EVP_MD_CTX_free) {}
+
 		uint32 offset;
 		uint32 size;
 		ClusterHashMode hashMode;
+		// extra data if TMD is available
+		bool hasContentHash;
+		uint8 contentHash32[32];
+		bool contentHashIsSHA1; // if true then it's SHA1 (with extra bytes zeroed out), otherwise it's SHA256
+		uint64 contentSize; // size of the content (in blocks)
+		// hash context for single hash mode (content hash must be available)
+		std::unique_ptr<EVP_MD_CTX, decltype(&EVP_MD_CTX_free)> singleHashCtx; // unique_ptr to make this move-only
+		uint32 singleHashNumBlocksHashed{0};
 	};
 
 	struct FSTEntry
@@ -148,17 +175,30 @@ private:
 	bool m_sourceIsOwned{};
 	uint32 m_sectorSize{}; // for cluster offsets
 	uint32 m_offsetFactor{}; // for file offsets
+	bool m_hashIsDisabled{}; // disables hash verification (for all clusters of this volume?)
 	std::vector<FSTCluster> m_cluster;
 	std::vector<FSTEntry> m_entries;
 	std::vector<char> m_nameStringTable;
 	NCrypto::AesKey m_partitionTitlekey;
+	bool m_detectedCorruption{false};
 
-	/* Cache for decrypted hashed blocks */
+	bool HashIsDisabled() const
+	{
+		return m_hashIsDisabled;
+	}
+
+	/* Cache for decrypted raw and hashed blocks */
+	std::unordered_map<uint64, struct FSTCachedRawBlock*> m_cacheDecryptedRawBlocks;
 	std::unordered_map<uint64, struct FSTCachedHashedBlock*> m_cacheDecryptedHashedBlocks;
 	uint64 m_cacheAccessCounter{};
 
+	void DetermineUnhashedBlockIV(uint32 clusterIndex, uint32 blockIndex, NCrypto::AesIv& ivOut);
+
+	struct FSTCachedRawBlock* GetDecryptedRawBlock(uint32 clusterIndex, uint32 blockIndex);
 	struct FSTCachedHashedBlock* GetDecryptedHashedBlock(uint32 clusterIndex, uint32 blockIndex);
 
+	void TrimCacheIfRequired(struct FSTCachedRawBlock** droppedRawBlock, struct FSTCachedHashedBlock** droppedHashedBlock);
+
 	/* File reading */
 	uint32 ReadFile_HashModeRaw(uint32 clusterIndex, FSTEntry& entry, uint32 readOffset, uint32 readSize, void* dataOut);
 	uint32 ReadFile_HashModeHashed(uint32 clusterIndex, FSTEntry& entry, uint32 readOffset, uint32 readSize, void* dataOut);
@@ -169,7 +209,10 @@ private:
 		/* +0x00 */ uint32be magic;
 		/* +0x04 */ uint32be offsetFactor;
 		/* +0x08 */ uint32be numCluster;
-		/* +0x0C */ uint32be ukn0C;
+		/* +0x0C */ uint8be hashIsDisabled;
+		/* +0x0D */ uint8be ukn0D;
+		/* +0x0E */ uint8be ukn0E;
+		/* +0x0F */ uint8be ukn0F;
 		/* +0x10 */ uint32be ukn10;
 		/* +0x14 */ uint32be ukn14;
 		/* +0x18 */ uint32be ukn18;
@@ -246,8 +289,8 @@ private:
 
 	static_assert(sizeof(FSTHeader_FileEntry) == 0x10);
 
-	static FSTVolume* OpenFST(FSTDataSource* dataSource, uint64 fstOffset, uint32 fstSize, NCrypto::AesKey* partitionTitleKey, ClusterHashMode fstHashMode);
-	static FSTVolume* OpenFST(std::unique_ptr<FSTDataSource> dataSource, uint64 fstOffset, uint32 fstSize, NCrypto::AesKey* partitionTitleKey, ClusterHashMode fstHashMode);
+	static FSTVolume* OpenFST(FSTDataSource* dataSource, uint64 fstOffset, uint32 fstSize, NCrypto::AesKey* partitionTitleKey, ClusterHashMode fstHashMode, NCrypto::TMDParser* optionalTMD);
+	static FSTVolume* OpenFST(std::unique_ptr<FSTDataSource> dataSource, uint64 fstOffset, uint32 fstSize, NCrypto::AesKey* partitionTitleKey, ClusterHashMode fstHashMode, NCrypto::TMDParser* optionalTMD);
 	static bool ProcessFST(FSTHeader_FileEntry* fileTable, uint32 numFileEntries, uint32 numCluster, std::vector<char>& nameStringTable, std::vector<FSTEntry>& fstEntries);
 
 	bool MatchFSTEntryName(FSTEntry& entry, std::string_view comparedName)
diff --git a/src/Cafe/Filesystem/FST/KeyCache.cpp b/src/Cafe/Filesystem/FST/KeyCache.cpp
index 587a5dd6..29903e84 100644
--- a/src/Cafe/Filesystem/FST/KeyCache.cpp
+++ b/src/Cafe/Filesystem/FST/KeyCache.cpp
@@ -1,5 +1,6 @@
 #include <wx/msgdlg.h>
 #include <mutex>
+#include <gui/helpers/wxHelpers.h>
 
 #include "config/ActiveSettings.h"
 #include "util/crypto/aes128.h"
@@ -59,7 +60,7 @@ void KeyCache_Prepare()
 	sKeyCachePrepared = true;
 	g_keyCache.clear();
 	// load keys
-	auto keysPath = ActiveSettings::GetPath("keys.txt");
+	auto keysPath = ActiveSettings::GetUserDataPath("keys.txt");
 	FileStream* fs_keys = FileStream::openFile2(keysPath);
 	if( !fs_keys )
 	{
@@ -74,7 +75,7 @@ void KeyCache_Prepare()
 		}
 		else
 		{
-			wxMessageBox("Unable to create file keys.txt\nThis can happen if Cemu does not have write permission to it's own directory, the disk is full or if anti-virus software is blocking Cemu.", "Error", wxOK | wxCENTRE | wxICON_ERROR);
+			wxMessageBox(_("Unable to create file keys.txt\nThis can happen if Cemu does not have write permission to its own directory, the disk is full or if anti-virus software is blocking Cemu."), _("Error"), wxOK | wxCENTRE | wxICON_ERROR);
 		}
 		mtxKeyCache.unlock();
 		return;
@@ -107,10 +108,8 @@ void KeyCache_Prepare()
 			continue;
 		if( strishex(line) == false )
 		{
-			// show error message
-			char errorMsg[512];
-			sprintf(errorMsg, "Error in keys.txt in line %d\n", lineNumber);
-			wxMessageBox(errorMsg, "Error", wxOK | wxCENTRE | wxICON_ERROR);
+			auto errorMsg = formatWxString(_("Error in keys.txt at line {}"), lineNumber);
+			wxMessageBox(errorMsg, _("Error"), wxOK | wxCENTRE | wxICON_ERROR);
 			continue;
 		}
 		if(line.size() == 32 )
diff --git a/src/Cafe/Filesystem/FST/fstUtil.h b/src/Cafe/Filesystem/FST/fstUtil.h
index 4ea9465d..a432cc95 100644
--- a/src/Cafe/Filesystem/FST/fstUtil.h
+++ b/src/Cafe/Filesystem/FST/fstUtil.h
@@ -3,6 +3,8 @@
 
 #include <boost/container/small_vector.hpp>
 
+#include "../fsc.h"
+
 // path parser and utility class for Wii U paths
 // optimized to be allocation-free for common path lengths
 class FSCPath
@@ -28,6 +30,8 @@ class FSCPath
 	{
 		if (m_names.size() > 0xFFFF)
 			return;
+		if (nameLen == 1 && *name == '.')
+			return;
 		m_nodes.emplace_back((uint16)m_names.size(), nameLen);
 		m_names.insert(m_names.end(), name, name + nameLen);
 	}
@@ -117,9 +121,7 @@ public:
 template<typename F>
 class FSAFileTree
 {
-public:
-
-private:
+  private:
 
 	enum NODETYPE : uint8
 	{
@@ -131,6 +133,7 @@ private:
 	{
 		std::string name;
 		std::vector<node_t*> subnodes;
+		size_t fileSize;
 		F* custom;
 		NODETYPE type;
 	};
@@ -177,13 +180,54 @@ private:
 		return newNode;
 	}
 
+	class DirectoryIterator : public FSCVirtualFile
+	{
+	  public:
+		DirectoryIterator(node_t* node)
+			: m_node(node), m_subnodeIndex(0)
+		{
+		}
+
+		sint32 fscGetType() override
+		{
+			return FSC_TYPE_DIRECTORY;
+		}
+
+		bool fscDirNext(FSCDirEntry* dirEntry) override
+		{
+			if (m_subnodeIndex >= m_node->subnodes.size())
+				return false;
+
+			const node_t* subnode = m_node->subnodes[m_subnodeIndex];
+
+			strncpy(dirEntry->path, subnode->name.c_str(), sizeof(dirEntry->path) - 1);
+			dirEntry->path[sizeof(dirEntry->path) - 1] = '\0';
+			dirEntry->isDirectory = subnode->type == FSAFileTree::NODETYPE_DIRECTORY;
+			dirEntry->isFile = subnode->type == FSAFileTree::NODETYPE_FILE;
+			dirEntry->fileSize = subnode->type == FSAFileTree::NODETYPE_FILE ? subnode->fileSize : 0;
+
+			++m_subnodeIndex;
+			return true;
+		}
+
+		bool fscRewindDir() override
+		{
+			m_subnodeIndex = 0;
+			return true;
+		}
+
+	  private:
+		node_t* m_node;
+		size_t m_subnodeIndex;
+	};
+
 public:
 	FSAFileTree()
 	{
 		rootNode.type = NODETYPE_DIRECTORY;
 	}
 
-	bool addFile(std::string_view path, F* custom)
+	bool addFile(std::string_view path, size_t fileSize, F* custom)
 	{
 		FSCPath p(path);
 		if (p.GetNodeCount() == 0)
@@ -194,6 +238,7 @@ public:
 			return false; // node already exists
 		// add file node
 		node_t* fileNode = newNode(directoryNode, NODETYPE_FILE, p.GetNodeName(p.GetNodeCount() - 1));
+		fileNode->fileSize = fileSize;
 		fileNode->custom = custom;
 		return true;
 	}
@@ -212,6 +257,20 @@ public:
 		return true;
 	}
 
+	bool getDirectory(std::string_view path, FSCVirtualFile*& dirIterator)
+	{
+		FSCPath p(path);
+		if (p.GetNodeCount() == 0)
+			return false;
+		node_t* node = getByNodePath(p, p.GetNodeCount(), false);
+		if (node == nullptr)
+			return false;
+		if (node->type != NODETYPE_DIRECTORY)
+			return false;
+		dirIterator = new DirectoryIterator(node);
+		return true;
+	}
+
 	bool removeFile(std::string_view path)
 	{
 		FSCPath p(path);
@@ -297,6 +356,12 @@ static void FSTPathUnitTest()
 	cemu_assert_debug(p6.GetNodeCount() == 0);
 	p6 = FSCPath("/////////////");
 	cemu_assert_debug(p6.GetNodeCount() == 0);
+	// test 7 - periods in path
+	FSCPath p7("/vol/content/./..");
+	cemu_assert_debug(p7.GetNodeCount() == 3);
+	cemu_assert_debug(p7.MatchNodeName(0, "vol"));
+	cemu_assert_debug(p7.MatchNodeName(1, "content"));
+	cemu_assert_debug(p7.MatchNodeName(2, ".."));
 }
 
 
diff --git a/src/Cafe/Filesystem/WUHB/RomFSStructs.h b/src/Cafe/Filesystem/WUHB/RomFSStructs.h
new file mode 100644
index 00000000..59ef503f
--- /dev/null
+++ b/src/Cafe/Filesystem/WUHB/RomFSStructs.h
@@ -0,0 +1,40 @@
+#pragma once
+
+struct romfs_header_t
+{
+	uint32 header_magic;
+	uint32be header_size;
+	uint64be dir_hash_table_ofs;
+	uint64be dir_hash_table_size;
+	uint64be dir_table_ofs;
+	uint64be dir_table_size;
+	uint64be file_hash_table_ofs;
+	uint64be file_hash_table_size;
+	uint64be file_table_ofs;
+	uint64be file_table_size;
+	uint64be file_partition_ofs;
+};
+
+struct romfs_direntry_t
+{
+	uint32be parent;
+	uint32be listNext;	   // offset to next directory entry in linked list of parent directory (aka "sibling")
+	uint32be dirListHead;  // offset to first entry in linked list of directory entries (aka "child")
+	uint32be fileListHead; // offset to first entry in linked list of file entries (aka "file")
+	uint32be hash;
+	uint32be name_size;
+	std::string name;
+};
+
+struct romfs_fentry_t
+{
+	uint32be parent;
+	uint32be listNext; // offset to next file entry in linked list of parent directory (aka "sibling")
+	uint64be offset;
+	uint64be size;
+	uint32be hash;
+	uint32be name_size;
+	std::string name;
+};
+
+#define ROMFS_ENTRY_EMPTY 0xFFFFFFFF
diff --git a/src/Cafe/Filesystem/WUHB/WUHBReader.cpp b/src/Cafe/Filesystem/WUHB/WUHBReader.cpp
new file mode 100644
index 00000000..e7a4c9be
--- /dev/null
+++ b/src/Cafe/Filesystem/WUHB/WUHBReader.cpp
@@ -0,0 +1,224 @@
+#include "WUHBReader.h"
+WUHBReader* WUHBReader::FromPath(const fs::path& path)
+{
+	FileStream* fileIn{FileStream::openFile2(path)};
+	if (!fileIn)
+		return nullptr;
+
+	WUHBReader* ret = new WUHBReader(fileIn);
+	if (!ret->CheckMagicValue())
+	{
+		delete ret;
+		return nullptr;
+	}
+
+	if (!ret->ReadHeader())
+	{
+		delete ret;
+		return nullptr;
+	}
+
+	return ret;
+}
+
+static const romfs_direntry_t fallbackDirEntry{
+	.parent = ROMFS_ENTRY_EMPTY,
+	.listNext = ROMFS_ENTRY_EMPTY,
+	.dirListHead = ROMFS_ENTRY_EMPTY,
+	.fileListHead = ROMFS_ENTRY_EMPTY,
+	.hash = ROMFS_ENTRY_EMPTY,
+	.name_size = 0,
+	.name = ""
+};
+static const romfs_fentry_t fallbackFileEntry{
+	.parent = ROMFS_ENTRY_EMPTY,
+	.listNext = ROMFS_ENTRY_EMPTY,
+	.offset = 0,
+	.size = 0,
+	.hash = ROMFS_ENTRY_EMPTY,
+	.name_size = 0,
+	.name = ""
+};
+template<bool File>
+const WUHBReader::EntryType<File>& WUHBReader::GetFallback()
+{
+	if constexpr (File)
+		return fallbackFileEntry;
+	else
+		return fallbackDirEntry;
+}
+
+template<bool File>
+WUHBReader::EntryType<File> WUHBReader::GetEntry(uint32 offset) const
+{
+	auto fallback = GetFallback<File>();
+	if(offset == ROMFS_ENTRY_EMPTY)
+		return fallback;
+
+	const char* typeName = File ? "fentry" : "direntry";
+	EntryType<File> ret;
+	if (offset >= (File ? m_header.file_table_size : m_header.dir_table_size))
+	{
+		cemuLog_log(LogType::Force, "WUHB {} offset exceeds table size declared in header", typeName);
+		return fallback;
+	}
+
+	// read the entry
+	m_fileIn->SetPosition((File ? m_header.file_table_ofs : m_header.dir_table_ofs) + offset);
+	auto read = m_fileIn->readData(&ret, offsetof(EntryType<File>, name));
+	if (read != offsetof(EntryType<File>, name))
+	{
+		cemuLog_log(LogType::Force, "failed to read WUHB {} at offset: {}", typeName, offset);
+		return fallback;
+	}
+
+	// read the name
+	ret.name.resize(ret.name_size);
+	read = m_fileIn->readData(ret.name.data(), ret.name_size);
+	if (read != ret.name_size)
+	{
+		cemuLog_log(LogType::Force, "failed to read WUHB {} name", typeName);
+		return fallback;
+	}
+
+	return ret;
+}
+
+romfs_direntry_t WUHBReader::GetDirEntry(uint32 offset) const
+{
+	return GetEntry<false>(offset);
+}
+romfs_fentry_t WUHBReader::GetFileEntry(uint32 offset) const
+{
+	return GetEntry<true>(offset);
+}
+
+uint64 WUHBReader::GetFileSize(uint32 entryOffset) const
+{
+	return GetFileEntry(entryOffset).size;
+}
+
+uint64 WUHBReader::ReadFromFile(uint32 entryOffset, uint64 fileOffset, uint64 length, void* buffer) const
+{
+	const auto fileEntry = GetFileEntry(entryOffset);
+	if (fileOffset >= fileEntry.size)
+		return 0;
+	const uint64 readAmount = std::min(length, fileEntry.size - fileOffset);
+	const uint64 wuhbOffset = m_header.file_partition_ofs + fileEntry.offset + fileOffset;
+	m_fileIn->SetPosition(wuhbOffset);
+	return m_fileIn->readData(buffer, readAmount);
+}
+
+uint32 WUHBReader::GetHashTableEntryOffset(uint32 hash, bool isFile) const
+{
+	const uint64 hash_table_size = (isFile ? m_header.file_hash_table_size : m_header.dir_hash_table_size);
+	const uint64 hash_table_ofs = (isFile ? m_header.file_hash_table_ofs : m_header.dir_hash_table_ofs);
+
+	const uint64 hash_table_entry_count = hash_table_size / sizeof(uint32);
+	const uint64 hash_table_entry_offset = hash_table_ofs + (hash % hash_table_entry_count) * sizeof(uint32);
+
+	m_fileIn->SetPosition(hash_table_entry_offset);
+	uint32 tableOffset;
+	if (!m_fileIn->readU32(tableOffset))
+	{
+		cemuLog_log(LogType::Force, "failed to read WUHB hash table entry at file offset: {}", hash_table_entry_offset);
+		return ROMFS_ENTRY_EMPTY;
+	}
+
+	return uint32be::from_bevalue(tableOffset);
+}
+
+template<bool T>
+bool WUHBReader::SearchHashList(uint32& entryOffset, const fs::path& targetName) const
+{
+	for (;;)
+	{
+		if (entryOffset == ROMFS_ENTRY_EMPTY)
+			return false;
+		auto entry = GetEntry<T>(entryOffset);
+
+		if (entry.name == targetName)
+			return true;
+		entryOffset = entry.hash;
+	}
+	return false;
+}
+
+uint32 WUHBReader::Lookup(const std::filesystem::path& path, bool isFile) const
+{
+	uint32 currentEntryOffset = 0;
+	auto look = [&](const fs::path& part, bool lookInFileHT) {
+		const auto partString = part.string();
+		currentEntryOffset = GetHashTableEntryOffset(CalcPathHash(currentEntryOffset, partString.c_str(), 0, partString.size()), lookInFileHT);
+		if (lookInFileHT)
+			return SearchHashList<true>(currentEntryOffset, part);
+		else
+			return SearchHashList<false>(currentEntryOffset, part);
+	};
+	// look for the root entry
+	if (!look("", false))
+		return ROMFS_ENTRY_EMPTY;
+
+	auto it = path.begin();
+	while (it != path.end())
+	{
+		fs::path part = *it;
+		++it;
+		// no need to recurse after trailing forward slash (e.g. directory/)
+		if (part.empty() && !isFile)
+			break;
+		// skip leading forward slash
+		if (part == "/")
+			continue;
+
+		// if the lookup target is a file and this is the last iteration, look in the file hash table instead.
+		if (!look(part, it == path.end() && isFile))
+			return ROMFS_ENTRY_EMPTY;
+	}
+	return currentEntryOffset;
+}
+bool WUHBReader::CheckMagicValue() const
+{
+	uint8 magic[4];
+	m_fileIn->SetPosition(0);
+	int read = m_fileIn->readData(magic, 4);
+	if (read != 4)
+	{
+		cemuLog_log(LogType::Force, "Failed to read WUHB magic numbers");
+		return false;
+	}
+	static_assert(sizeof(magic) == s_headerMagicValue.size());
+	return std::memcmp(&magic, s_headerMagicValue.data(), sizeof(magic)) == 0;
+}
+bool WUHBReader::ReadHeader()
+{
+	m_fileIn->SetPosition(0);
+	auto read = m_fileIn->readData(&m_header, sizeof(m_header));
+	auto readSuccess = read == sizeof(m_header);
+	if (!readSuccess)
+		cemuLog_log(LogType::Force, "Failed to read WUHB header");
+	return readSuccess;
+}
+unsigned char WUHBReader::NormalizeChar(unsigned char c)
+{
+	if (c >= 'a' && c <= 'z')
+	{
+		return c + 'A' - 'a';
+	}
+	else
+	{
+		return c;
+	}
+}
+uint32 WUHBReader::CalcPathHash(uint32 parent, const char* path, uint32 start, size_t path_len)
+{
+	cemu_assert(path != nullptr || path_len == 0);
+	uint32 hash = parent ^ 123456789;
+	for (uint32 i = 0; i < path_len; i++)
+	{
+		hash = (hash >> 5) | (hash << 27);
+		hash ^= NormalizeChar(path[start + i]);
+	}
+
+	return hash;
+}
diff --git a/src/Cafe/Filesystem/WUHB/WUHBReader.h b/src/Cafe/Filesystem/WUHB/WUHBReader.h
new file mode 100644
index 00000000..9187f05a
--- /dev/null
+++ b/src/Cafe/Filesystem/WUHB/WUHBReader.h
@@ -0,0 +1,45 @@
+#pragma once
+#include <Common/FileStream.h>
+#include "RomFSStructs.h"
+class WUHBReader
+{
+  public:
+	static WUHBReader* FromPath(const fs::path& path);
+
+	romfs_direntry_t GetDirEntry(uint32 offset) const;
+	romfs_fentry_t GetFileEntry(uint32 offset) const;
+
+	uint64 GetFileSize(uint32 entryOffset) const;
+
+	uint64 ReadFromFile(uint32 entryOffset, uint64 fileOffset, uint64 length, void* buffer) const;
+
+	uint32 Lookup(const std::filesystem::path& path, bool isFile) const;
+
+  private:
+	WUHBReader(FileStream* file)
+		: m_fileIn(file)
+	{
+		cemu_assert_debug(file != nullptr);
+	};
+	WUHBReader() = delete;
+
+	romfs_header_t m_header;
+	std::unique_ptr<FileStream> m_fileIn;
+	constexpr static std::string_view s_headerMagicValue = "WUHB";
+	bool ReadHeader();
+	bool CheckMagicValue() const;
+
+	static inline unsigned char NormalizeChar(unsigned char c);
+	static uint32 CalcPathHash(uint32 parent, const char* path, uint32 start, size_t path_len);
+
+	template<bool File>
+	using EntryType = std::conditional_t<File, romfs_fentry_t, romfs_direntry_t>;
+	template<bool File>
+	static const EntryType<File>& GetFallback();
+	template<bool File>
+	EntryType<File> GetEntry(uint32 offset) const;
+
+	template<bool T>
+	bool SearchHashList(uint32& entryOffset, const fs::path& targetName) const;
+	uint32 GetHashTableEntryOffset(uint32 hash, bool isFile) const;
+};
diff --git a/src/Cafe/Filesystem/fsc.cpp b/src/Cafe/Filesystem/fsc.cpp
index d7d9971f..031f2fb2 100644
--- a/src/Cafe/Filesystem/fsc.cpp
+++ b/src/Cafe/Filesystem/fsc.cpp
@@ -6,7 +6,7 @@ struct FSCMountPathNode
 	std::string path;
 	std::vector<FSCMountPathNode*> subnodes;
 	FSCMountPathNode* parent;
-	// device target and path (if subnodes is empty)
+	// associated device target and path
 	fscDeviceC* device{ nullptr };
 	void* ctx{ nullptr };
 	std::string deviceTargetPath; // the destination base path for the device, utf8
@@ -17,6 +17,25 @@ struct FSCMountPathNode
 	{
 	}
 
+    void AssignDevice(fscDeviceC* device, void* ctx, std::string_view deviceBasePath)
+    {
+        this->device = device;
+        this->ctx = ctx;
+        this->deviceTargetPath = deviceBasePath;
+    }
+
+    void UnassignDevice()
+    {
+        this->device = nullptr;
+        this->ctx = nullptr;
+        this->deviceTargetPath.clear();
+    }
+
+    bool IsRootNode() const
+    {
+        return !parent;
+    }
+
 	~FSCMountPathNode()
 	{
 		for (auto& itr : subnodes)
@@ -141,9 +160,7 @@ sint32 fsc_mount(std::string_view mountPath, std::string_view targetPath, fscDev
 		fscLeave();
 		return FSC_STATUS_INVALID_PATH;
 	}
-	node->device = fscDevice;
-	node->ctx = ctx;
-	node->deviceTargetPath = targetPathWithSlash;
+    node->AssignDevice(fscDevice, ctx, targetPathWithSlash);
 	fscLeave();
 	return FSC_STATUS_OK;
 }
@@ -160,14 +177,13 @@ bool fsc_unmount(std::string_view mountPath, sint32 priority)
 	}
 	cemu_assert(mountPathNode->priority == priority);
 	cemu_assert(mountPathNode->device);
-	// delete node
-	while (mountPathNode && mountPathNode->parent)
+    // unassign device
+    mountPathNode->UnassignDevice();
+	// prune empty branch
+	while (mountPathNode && !mountPathNode->IsRootNode() && mountPathNode->subnodes.empty() && !mountPathNode->device)
 	{
 		FSCMountPathNode* parent = mountPathNode->parent;
-		cemu_assert(!(!mountPathNode->subnodes.empty() && mountPathNode->device));
-		if (!mountPathNode->subnodes.empty())
-			break;
-		parent->subnodes.erase(std::find(parent->subnodes.begin(), parent->subnodes.end(), mountPathNode));
+        std::erase(parent->subnodes, mountPathNode);
 		delete mountPathNode;
 		mountPathNode = parent;
 	}
@@ -302,6 +318,15 @@ public:
 		return true;
 	}
 
+	bool fscRewindDir() override
+	{
+		if (!dirIterator)
+			return true;
+
+		dirIterator->index  = 0;
+		return true;
+	}
+
 	void addUniqueDirEntry(const FSCDirEntry& dirEntry)
 	{
 		// skip if already in list
@@ -378,6 +403,7 @@ FSCVirtualFile* fsc_open(const char* path, FSC_ACCESS_FLAG accessFlags, sint32*
 				{
 					// return first found file
 					cemu_assert_debug(HAS_FLAG(accessFlags, FSC_ACCESS_FLAG::OPEN_FILE));
+					fscVirtualFile->m_isAppend = HAS_FLAG(accessFlags, FSC_ACCESS_FLAG::IS_APPEND);
 					fscLeave();
 					return fscVirtualFile;
 				}				
@@ -441,7 +467,7 @@ bool fsc_nextDir(FSCVirtualFile* fscFile, FSCDirEntry* dirEntry)
 /*
  * Create directory
  */
-bool fsc_createDir(char* path, sint32* fscStatus)
+bool fsc_createDir(const char* path, sint32* fscStatus)
 {
 	fscDeviceC* fscDevice = NULL;
 	*fscStatus = FSC_STATUS_UNDEFINED;
@@ -461,7 +487,7 @@ bool fsc_createDir(char* path, sint32* fscStatus)
 /*
  * Rename file or directory
  */
-bool fsc_rename(char* srcPath, char* dstPath, sint32* fscStatus)
+bool fsc_rename(const char* srcPath, const char* dstPath, sint32* fscStatus)
 {
 	std::string srcDevicePath;
 	std::string dstDevicePath;
@@ -481,7 +507,7 @@ bool fsc_rename(char* srcPath, char* dstPath, sint32* fscStatus)
 /*
  * Delete file or subdirectory
  */
-bool fsc_remove(char* path, sint32* fscStatus)
+bool fsc_remove(const char* path, sint32* fscStatus)
 {
 	std::string devicePath;
 	fscDeviceC* fscDevice = NULL;
@@ -541,7 +567,7 @@ void fsc_setFileLength(FSCVirtualFile* fscFile, uint32 newEndOffset)
 	uint32 fileSize = fsc_getFileSize(fscFile);
 	if (!fsc_isWritable(fscFile))
 	{
-		cemuLog_force("TruncateFile called on read-only file");
+		cemuLog_log(LogType::Force, "TruncateFile called on read-only file");
 	}
 	else
 	{
@@ -598,6 +624,9 @@ uint32 fsc_writeFile(FSCVirtualFile* fscFile, void* buffer, uint32 size)
 		fscLeave();
 		return 0;
 	}
+	if (fscFile->m_isAppend)
+		fsc_setFileSeek(fscFile, fsc_getFileSize(fscFile));
+
 	uint32 fscStatus = fscFile->fscWriteData(buffer, size);
 	fscLeave();
 	return fscStatus;
diff --git a/src/Cafe/Filesystem/fsc.h b/src/Cafe/Filesystem/fsc.h
index 9420d69d..8b8ed5ef 100644
--- a/src/Cafe/Filesystem/fsc.h
+++ b/src/Cafe/Filesystem/fsc.h
@@ -24,7 +24,10 @@ enum class FSC_ACCESS_FLAG : uint8
 	// which types can be opened
 	// invalid operation if neither is set
 	OPEN_DIR = (1 << 4), 
-	OPEN_FILE = (1 << 5)
+	OPEN_FILE = (1 << 5),
+
+	// Writing seeks to the end of the file if set
+	IS_APPEND = (1 << 6)
 };
 DEFINE_ENUM_FLAG_OPERATORS(FSC_ACCESS_FLAG);
 
@@ -149,7 +152,15 @@ struct FSCVirtualFile
 		return false;
 	}
 
+	virtual bool fscRewindDir()
+	{
+		cemu_assert_unimplemented();
+		return false;
+	}
+
 	FSCDirIteratorState* dirIterator{};
+
+	bool m_isAppend{ false };
 };
 
 #define FSC_PRIORITY_BASE				(0)
@@ -167,9 +178,9 @@ void fsc_unmountAll();
 
 FSCVirtualFile* fsc_open(const char* path, FSC_ACCESS_FLAG accessFlags, sint32* fscStatus, sint32 maxPriority=FSC_PRIORITY_MAX);
 FSCVirtualFile* fsc_openDirIterator(const char* path, sint32* fscStatus);
-bool fsc_createDir(char* path, sint32* fscStatus);
-bool fsc_rename(char* srcPath, char* dstPath, sint32* fscStatus);
-bool fsc_remove(char* path, sint32* fscStatus);
+bool fsc_createDir(const char* path, sint32* fscStatus);
+bool fsc_rename(const char* srcPath, const char* dstPath, sint32* fscStatus);
+bool fsc_remove(const char* path, sint32* fscStatus);
 bool fsc_nextDir(FSCVirtualFile* fscFile, FSCDirEntry* dirEntry);
 void fsc_close(FSCVirtualFile* fscFile);
 uint32 fsc_getFileSize(FSCVirtualFile* fscFile);
@@ -193,10 +204,12 @@ bool FSCDeviceWUD_Mount(std::string_view mountPath, std::string_view destination
 // wua device
 bool FSCDeviceWUA_Mount(std::string_view mountPath, std::string_view destinationBaseDir, class ZArchiveReader* archive, sint32 priority);
 
+// wuhb device
+bool FSCDeviceWUHB_Mount(std::string_view mountPath, std::string_view destinationBaseDir, class WUHBReader* wuhbReader, sint32 priority);
+
 // hostFS device
-void fscDeviceHostFS_mapBaseDirectories_deprecated();
 bool FSCDeviceHostFS_Mount(std::string_view mountPath, std::string_view hostTargetPath, sint32 priority);
 
 // redirect device
 void fscDeviceRedirect_map();
-void fscDeviceRedirect_add(std::string_view virtualSourcePath, const fs::path& targetFilePath, sint32 priority);
+void fscDeviceRedirect_add(std::string_view virtualSourcePath, size_t fileSize, const fs::path& targetFilePath, sint32 priority);
diff --git a/src/Cafe/Filesystem/fscDeviceHostFS.cpp b/src/Cafe/Filesystem/fscDeviceHostFS.cpp
index da28700d..85a04afe 100644
--- a/src/Cafe/Filesystem/fscDeviceHostFS.cpp
+++ b/src/Cafe/Filesystem/fscDeviceHostFS.cpp
@@ -113,7 +113,7 @@ void FSCVirtualFile_Host::fscSetFileLength(uint64 endOffset)
 	m_fileSize = m_seek;
 	m_fs->SetPosition(m_seek);
 	if (!r)
-		cemuLog_force("fscSetFileLength: Failed to set size to 0x{:x}", endOffset);
+		cemuLog_log(LogType::Force, "fscSetFileLength: Failed to set size to 0x{:x}", endOffset);
 }
 
 bool FSCVirtualFile_Host::fscDirNext(FSCDirEntry* dirEntry)
@@ -127,7 +127,7 @@ bool FSCVirtualFile_Host::fscDirNext(FSCDirEntry* dirEntry)
 		m_dirIterator.reset(new fs::directory_iterator(*m_path));
 		if (!m_dirIterator)
 		{
-			cemuLog_force("Failed to iterate directory: {}", _pathToUtf8(*m_path));
+			cemuLog_log(LogType::Force, "Failed to iterate directory: {}", _pathToUtf8(*m_path));
 			return false;
 		}
 	}
@@ -175,14 +175,14 @@ FSCVirtualFile* FSCVirtualFile_Host::OpenFile(const fs::path& path, FSC_ACCESS_F
 				cemu_assert_debug(writeAccessRequested);
 				fs = FileStream::createFile2(path);
 				if (!fs)
-					cemuLog_force("FSC: File create failed for {}", _pathToUtf8(path));
+					cemuLog_log(LogType::Force, "FSC: File create failed for {}", _pathToUtf8(path));
 			}
 		}
 		else if (HAS_FLAG(accessFlags, FSC_ACCESS_FLAG::FILE_ALWAYS_CREATE))
 		{
 			fs = FileStream::createFile2(path);
 			if (!fs)
-				cemuLog_force("FSC: File create failed for {}", _pathToUtf8(path));
+				cemuLog_log(LogType::Force, "FSC: File create failed for {}", _pathToUtf8(path));
 		}
 		else
 		{
@@ -235,14 +235,14 @@ public:
 		if (fs::exists(dirPath))
 		{
 			if (!fs::is_directory(dirPath))
-				cemuLog_force("CreateDir: {} already exists but is not a directory", path);
+				cemuLog_log(LogType::Force, "CreateDir: {} already exists but is not a directory", path);
 			*fscStatus = FSC_STATUS_ALREADY_EXISTS;
 			return false;
 		}
 		std::error_code ec;
 		bool r = fs::create_directories(dirPath, ec);
 		if (!r)
-			cemuLog_force("CreateDir: Failed to create {}", path);
+			cemuLog_log(LogType::Force, "CreateDir: Failed to create {}", path);
 		*fscStatus = FSC_STATUS_OK;
 		return true;
 	}
@@ -262,7 +262,6 @@ public:
 			cemu_assert_unimplemented(); // return correct error (e.g. if directory is non-empty)
 			*fscStatus = FSC_STATUS_FILE_NOT_FOUND;
 		}
-		*fscStatus = FSC_STATUS_FILE_NOT_FOUND;
 		return true;
 	}
 
@@ -290,13 +289,6 @@ public:
 	}
 };
 
-void fscDeviceHostFS_mapBaseDirectories_deprecated()
-{
-	const auto mlc = ActiveSettings::GetMlcPath();
-	fsc_mount("/cemuBossStorage/", _pathToUtf8(mlc / "usr/boss/"), &fscDeviceHostFSC::instance(), NULL, FSC_PRIORITY_BASE);
-	fsc_mount("/vol/storage_mlc01/", _pathToUtf8(mlc / ""), &fscDeviceHostFSC::instance(), NULL, FSC_PRIORITY_BASE);
-}
-
 bool FSCDeviceHostFS_Mount(std::string_view mountPath, std::string_view hostTargetPath, sint32 priority)
 {
 	return fsc_mount(mountPath, hostTargetPath, &fscDeviceHostFSC::instance(), nullptr, priority) == FSC_STATUS_OK;
diff --git a/src/Cafe/Filesystem/fscDeviceRedirect.cpp b/src/Cafe/Filesystem/fscDeviceRedirect.cpp
index d25bff86..9c62d37a 100644
--- a/src/Cafe/Filesystem/fscDeviceRedirect.cpp
+++ b/src/Cafe/Filesystem/fscDeviceRedirect.cpp
@@ -11,7 +11,7 @@ struct RedirectEntry
 
 FSAFileTree<RedirectEntry> redirectTree;
 
-void fscDeviceRedirect_add(std::string_view virtualSourcePath, const fs::path& targetFilePath, sint32 priority)
+void fscDeviceRedirect_add(std::string_view virtualSourcePath, size_t fileSize, const fs::path& targetFilePath, sint32 priority)
 {
 	// check if source already has a redirection
 	RedirectEntry* existingEntry;
@@ -24,7 +24,7 @@ void fscDeviceRedirect_add(std::string_view virtualSourcePath, const fs::path& t
 		delete existingEntry;
 	}
 	RedirectEntry* entry = new RedirectEntry(targetFilePath, priority);
-	redirectTree.addFile(virtualSourcePath, entry);
+	redirectTree.addFile(virtualSourcePath, fileSize, entry);
 }
 
 class fscDeviceTypeRedirect : public fscDeviceC
@@ -32,8 +32,15 @@ class fscDeviceTypeRedirect : public fscDeviceC
 	FSCVirtualFile* fscDeviceOpenByPath(std::string_view path, FSC_ACCESS_FLAG accessFlags, void* ctx, sint32* fscStatus) override
 	{
 		RedirectEntry* redirectionEntry;
-		if (redirectTree.getFile(path, redirectionEntry))
+
+		if (HAS_FLAG(accessFlags, FSC_ACCESS_FLAG::OPEN_FILE) && redirectTree.getFile(path, redirectionEntry))
 			return FSCVirtualFile_Host::OpenFile(redirectionEntry->dstPath, accessFlags, *fscStatus);
+
+		FSCVirtualFile* dirIterator;
+
+		if (HAS_FLAG(accessFlags, FSC_ACCESS_FLAG::OPEN_DIR) && redirectTree.getDirectory(path, dirIterator))
+			return dirIterator;
+
 		return nullptr;
 	}
 
diff --git a/src/Cafe/Filesystem/fscDeviceWud.cpp b/src/Cafe/Filesystem/fscDeviceWud.cpp
index bf43bf3e..517c8573 100644
--- a/src/Cafe/Filesystem/fscDeviceWud.cpp
+++ b/src/Cafe/Filesystem/fscDeviceWud.cpp
@@ -128,7 +128,7 @@ class fscDeviceWUDC : public fscDeviceC
 		if (HAS_FLAG(accessFlags, FSC_ACCESS_FLAG::OPEN_FILE))
 		{
 			FSTFileHandle fstFileHandle;
-			if (mountedVolume->OpenFile(path, fstFileHandle, true))
+			if (mountedVolume->OpenFile(path, fstFileHandle, true) && !mountedVolume->HasLinkFlag(fstFileHandle))
 			{
 				*fscStatus = FSC_STATUS_OK;
 				return new FSCDeviceWudFileCtx(mountedVolume, fstFileHandle);
@@ -137,7 +137,7 @@ class fscDeviceWUDC : public fscDeviceC
 		if (HAS_FLAG(accessFlags, FSC_ACCESS_FLAG::OPEN_DIR))
 		{
 			FSTDirectoryIterator dirIterator;
-			if (mountedVolume->OpenDirectoryIterator(path, dirIterator))
+			if (mountedVolume->OpenDirectoryIterator(path, dirIterator) && !mountedVolume->HasLinkFlag(dirIterator.GetDirHandle()))
 			{
 				*fscStatus = FSC_STATUS_OK;
 				return new FSCDeviceWudFileCtx(mountedVolume, dirIterator);
diff --git a/src/Cafe/Filesystem/fscDeviceWuhb.cpp b/src/Cafe/Filesystem/fscDeviceWuhb.cpp
new file mode 100644
index 00000000..5e8e6484
--- /dev/null
+++ b/src/Cafe/Filesystem/fscDeviceWuhb.cpp
@@ -0,0 +1,151 @@
+#include "Filesystem/WUHB/WUHBReader.h"
+#include "Cafe/Filesystem/fsc.h"
+#include "Cafe/Filesystem/FST/FST.h"
+
+class FSCDeviceWuhbFileCtx : public FSCVirtualFile
+{
+  public:
+	FSCDeviceWuhbFileCtx(WUHBReader* reader, uint32 entryOffset, uint32 fscType)
+		: m_wuhbReader(reader), m_entryOffset(entryOffset), m_fscType(fscType)
+	{
+		cemu_assert(entryOffset != ROMFS_ENTRY_EMPTY);
+		if (fscType == FSC_TYPE_DIRECTORY)
+		{
+			romfs_direntry_t entry = reader->GetDirEntry(entryOffset);
+			m_dirIterOffset = entry.dirListHead;
+			m_fileIterOffset = entry.fileListHead;
+		}
+	}
+	sint32 fscGetType() override
+	{
+		return m_fscType;
+	}
+	uint64 fscQueryValueU64(uint32 id) override
+	{
+		if (m_fscType == FSC_TYPE_FILE)
+		{
+			if (id == FSC_QUERY_SIZE)
+				return m_wuhbReader->GetFileSize(m_entryOffset);
+			else if (id == FSC_QUERY_WRITEABLE)
+				return 0; // WUHB images are read-only
+			else
+				cemu_assert_error();
+		}
+		else
+		{
+			cemu_assert_unimplemented();
+		}
+		return 0;
+	}
+	uint32 fscWriteData(void* buffer, uint32 size) override
+	{
+		cemu_assert_error();
+		return 0;
+	}
+	uint32 fscReadData(void* buffer, uint32 size) override
+	{
+		if (m_fscType != FSC_TYPE_FILE)
+			return 0;
+		auto read = m_wuhbReader->ReadFromFile(m_entryOffset, m_seek, size, buffer);
+		m_seek += read;
+		return read;
+	}
+	void fscSetSeek(uint64 seek) override
+	{
+		m_seek = seek;
+	}
+	uint64 fscGetSeek() override
+	{
+		if (m_fscType != FSC_TYPE_FILE)
+			return 0;
+		return m_seek;
+	}
+	void fscSetFileLength(uint64 endOffset) override
+	{
+		cemu_assert_error();
+	}
+	bool fscDirNext(FSCDirEntry* dirEntry) override
+	{
+		if (m_dirIterOffset != ROMFS_ENTRY_EMPTY)
+		{
+			romfs_direntry_t entry = m_wuhbReader->GetDirEntry(m_dirIterOffset);
+			m_dirIterOffset = entry.listNext;
+			if(entry.name_size > 0)
+			{
+				dirEntry->isDirectory = true;
+				dirEntry->isFile = false;
+				dirEntry->fileSize = 0;
+				std::strncpy(dirEntry->path, entry.name.c_str(), FSC_MAX_DIR_NAME_LENGTH);
+				return true;
+			}
+		}
+		if (m_fileIterOffset != ROMFS_ENTRY_EMPTY)
+		{
+			romfs_fentry_t entry = m_wuhbReader->GetFileEntry(m_fileIterOffset);
+			m_fileIterOffset = entry.listNext;
+			if(entry.name_size > 0)
+			{
+				dirEntry->isDirectory = false;
+				dirEntry->isFile = true;
+				dirEntry->fileSize = entry.size;
+				std::strncpy(dirEntry->path, entry.name.c_str(), FSC_MAX_DIR_NAME_LENGTH);
+				return true;
+			}
+		}
+
+		return false;
+	}
+
+  private:
+	WUHBReader* m_wuhbReader{};
+	uint32 m_fscType;
+	uint32 m_entryOffset = ROMFS_ENTRY_EMPTY;
+	uint32 m_dirIterOffset = ROMFS_ENTRY_EMPTY;
+	uint32 m_fileIterOffset = ROMFS_ENTRY_EMPTY;
+	uint64 m_seek = 0;
+};
+
+class fscDeviceWUHB : public fscDeviceC
+{
+	FSCVirtualFile* fscDeviceOpenByPath(std::string_view path, FSC_ACCESS_FLAG accessFlags, void* ctx, sint32* fscStatus) override
+	{
+		WUHBReader* reader = (WUHBReader*)ctx;
+		cemu_assert_debug(!HAS_FLAG(accessFlags, FSC_ACCESS_FLAG::WRITE_PERMISSION)); // writing to WUHB is not supported
+
+		bool isFile;
+		uint32 table_offset = ROMFS_ENTRY_EMPTY;
+
+		if (table_offset == ROMFS_ENTRY_EMPTY && HAS_FLAG(accessFlags, FSC_ACCESS_FLAG::OPEN_DIR))
+		{
+			table_offset = reader->Lookup(path, false);
+			isFile = false;
+		}
+		if (table_offset == ROMFS_ENTRY_EMPTY && HAS_FLAG(accessFlags, FSC_ACCESS_FLAG::OPEN_FILE))
+		{
+			table_offset = reader->Lookup(path, true);
+			isFile = true;
+		}
+
+		if (table_offset == ROMFS_ENTRY_EMPTY)
+		{
+			*fscStatus = FSC_STATUS_FILE_NOT_FOUND;
+			return nullptr;
+		}
+
+		*fscStatus = FSC_STATUS_OK;
+		return new FSCDeviceWuhbFileCtx(reader, table_offset, isFile ? FSC_TYPE_FILE : FSC_TYPE_DIRECTORY);
+	}
+
+	// singleton
+  public:
+	static fscDeviceWUHB& instance()
+	{
+		static fscDeviceWUHB _instance;
+		return _instance;
+	}
+};
+
+bool FSCDeviceWUHB_Mount(std::string_view mountPath, std::string_view destinationBaseDir, WUHBReader* wuhbReader, sint32 priority)
+{
+	return fsc_mount(mountPath, destinationBaseDir, &fscDeviceWUHB::instance(), wuhbReader, priority) == FSC_STATUS_OK;
+}
diff --git a/src/Cafe/GamePatch.cpp b/src/Cafe/GamePatch.cpp
index e5a67d98..77eaff32 100644
--- a/src/Cafe/GamePatch.cpp
+++ b/src/Cafe/GamePatch.cpp
@@ -52,7 +52,7 @@ typedef struct
 void hleExport_xcx_enterCriticalSection(PPCInterpreter_t* hCPU)
 {
 	ppcDefineParamStructPtr(xcxCS, xcxCS_t, 0);
-	uint32 threadId = coreinitThread_getCurrentThreadMPTRDepr(hCPU);
+	uint32 threadId = MEMPTR<OSThread_t>(coreinit::OSGetCurrentThread()).GetMPTR();
 	cemu_assert_debug(xcxCS->ukn08 != 0);
 	cemu_assert_debug(threadId);
 	if (xcxCS->ownerThreadId == (uint32be)threadId)
@@ -83,7 +83,7 @@ void hleExport_xcx_enterCriticalSection(PPCInterpreter_t* hCPU)
 				osLib_returnFromFunction(hCPU, 0);
 				return;
 			}
-			_mm_pause();
+            _mm_pause();
 		}
 		PPCCore_switchToScheduler();
 	}
@@ -139,7 +139,7 @@ void hle_scan(uint8* data, sint32 dataLength, char* hleFunctionName)
 			uint32 offset = (uint32)(scanCurrent - scanStart) + 0x01000000;
 			debug_printf("HLE signature for '%s' found at 0x%08x\n", hleFunctionName, offset);
 			uint32 opcode = (1<<26)|(functionIndex+0x1000); // opcode for HLE: 0x1000 + FunctionIndex
-			memory_writeU32Direct(offset, opcode);
+			memory_write<uint32>(offset, opcode);
 			break;
 		}
 		scanCurrent += 4;
@@ -199,7 +199,7 @@ MPTR hle_locate(uint8* data, uint8* mask, sint32 dataLength)
 		}
 		else
 		{
-#ifndef PUBLIC_RELEASE
+#ifdef CEMU_DEBUG_ASSERT
 			if (mask[0] != 0xFF)
 				assert_dbg();
 #endif
@@ -299,8 +299,8 @@ void GamePatch_scan()
 	hleAddr = hle_locate(xcx_gpuHangDetection_degradeFramebuffer, NULL, sizeof(xcx_gpuHangDetection_degradeFramebuffer));
 	if( hleAddr )
 	{
-#ifndef PUBLIC_RELEASE
-		forceLog_printf("HLE: XCX GPU hang detection");
+#ifdef CEMU_DEBUG_ASSERT
+		cemuLog_log(LogType::Force, "HLE: XCX GPU hang detection");
 #endif
 		// remove the ADDI r25, r25, 1 instruction
 		memory_writeU32(hleAddr, memory_readU32(hleAddr+4));
@@ -309,8 +309,8 @@ void GamePatch_scan()
 	hleAddr = hle_locate(xcx_framebufferReductionSignature, xcx_framebufferReductionMask, sizeof(xcx_framebufferReductionSignature));
 	if( hleAddr )
 	{
-#ifndef PUBLIC_RELEASE
-		forceLog_printf("HLE: Prevent XCX rendertarget reduction");
+#ifdef CEMU_DEBUG_ASSERT
+		cemuLog_log(LogType::Force, "HLE: Prevent XCX rendertarget reduction");
 #endif
 		uint32 bl = memory_readU32(hleAddr+0x14);
 		uint32 func_isReductionBuffer = hleAddr + 0x14 + (bl&0x3FFFFFC);
@@ -325,23 +325,23 @@ void GamePatch_scan()
 	hleAddr = hle_locate(botw_busyLoopSignature, botw_busyLoopMask, sizeof(botw_busyLoopSignature));
 	if (hleAddr)
 	{
-#ifndef PUBLIC_RELEASE
-		forceLog_printf("HLE: Patch BotW busy loop 1 at 0x%08x", hleAddr);
+#ifdef CEMU_DEBUG_ASSERT
+		cemuLog_log(LogType::Force, "HLE: Patch BotW busy loop 1 at 0x{:08x}", hleAddr);
 #endif
 		sint32 functionIndex = hleIndex_h000000001;
 		uint32 opcode = (1 << 26) | (functionIndex); // opcode for HLE: 0x1000 + FunctionIndex
-		memory_writeU32Direct(hleAddr - 4, opcode);
+		memory_write<uint32>(hleAddr - 4, opcode);
 	}
 	hleIndex_h000000002 = osLib_getFunctionIndex("hle", "h000000002");
 	hleAddr = hle_locate(botw_busyLoopSignature2, botw_busyLoopMask2, sizeof(botw_busyLoopSignature2));
 	if (hleAddr)
 	{
-#ifndef PUBLIC_RELEASE
-		forceLog_printf("HLE: Patch BotW busy loop 2 at 0x%08x", hleAddr);
+#ifdef CEMU_DEBUG_ASSERT
+		cemuLog_log(LogType::Force, "HLE: Patch BotW busy loop 2 at 0x{:08x}", hleAddr);
 #endif
 		sint32 functionIndex = hleIndex_h000000002;
 		uint32 opcode = (1 << 26) | (functionIndex); // opcode for HLE: 0x1000 + FunctionIndex
-		memory_writeU32Direct(hleAddr - 4, opcode);
+		memory_write<uint32>(hleAddr - 4, opcode);
 	}
 
 	// FFL library float array endian conversion
@@ -350,17 +350,17 @@ void GamePatch_scan()
 	hleAddr = hle_locate(ffl_floatArrayEndianSwap, NULL, sizeof(ffl_floatArrayEndianSwap));
 	if (hleAddr)
 	{
-		forceLogDebug_printf("HLE: Hook FFL float array endian swap function at 0x%08x", hleAddr);
+		cemuLog_logDebug(LogType::Force, "HLE: Hook FFL float array endian swap function at 0x{:08x}", hleAddr);
 		sint32 functionIndex = hleIndex_h000000003;
 		uint32 opcode = (1 << 26) | (functionIndex); // opcode for HLE: 0x1000 + FunctionIndex
-		memory_writeU32Direct(hleAddr, opcode);
+		memory_write<uint32>(hleAddr, opcode);
 	}
 
 	// XCX freeze workaround
 	//hleAddr = hle_locate(xcx_enterCriticalSectionSignature, xcx_enterCriticalSectionMask, sizeof(xcx_enterCriticalSectionSignature));
 	//if (hleAddr)
 	//{
-	//	forceLogDebug_printf("HLE: Hook XCX enterCriticalSection function at 0x%08x", hleAddr);
+	//	cemuLog_logDebug(LogType::Force, "HLE: Hook XCX enterCriticalSection function at 0x{:08x}", hleAddr);
 	//	hleIndex_h000000004 = osLib_getFunctionIndex("hle", "h000000004");
 	//	sint32 functionIndex = hleIndex_h000000004;
 	//	uint32 opcode = (1 << 26) | (functionIndex); // opcode for HLE: 0x1000 + FunctionIndex
@@ -372,7 +372,7 @@ void GamePatch_scan()
 	if (hleAddr)
 	{
 		uint32 patchAddr = hleAddr + 0x10;
-		forceLog_printf("HLE: Patch MH3U race condition candidate at 0x%08x", patchAddr);
+		cemuLog_log(LogType::Force, "HLE: Patch MH3U race condition candidate at 0x{:08x}", patchAddr);
 		uint32 funcAddr = PPCInterpreter_makeCallableExportDepr(hleExport_mh3u_raceConditionWorkaround);
 		// set absolute jump
 		uint32 opc = 0x48000000;
@@ -387,7 +387,7 @@ void GamePatch_scan()
 	hleAddr = hle_locate(smash4_softlockFixV0Signature, smash4_softlockFixV0Mask, sizeof(smash4_softlockFixV0Signature));
 	if (hleAddr)
 	{
-		forceLogDebug_printf("Smash softlock fix: 0x%08x", hleAddr);
+		cemuLog_logDebug(LogType::Force, "Smash softlock fix: 0x{:08x}", hleAddr);
 		memory_writeU32(hleAddr+0x20, memory_readU32(hleAddr+0x1C));
 	}
 
@@ -396,7 +396,7 @@ void GamePatch_scan()
 	hleAddr = hle_locate(pmcs_yellowPaintStarCrashV0Signature, nullptr, sizeof(pmcs_yellowPaintStarCrashV0Signature));
 	if (hleAddr)
 	{
-		forceLogDebug_printf("Color Splash crash fix: 0x%08x", hleAddr);
+		cemuLog_logDebug(LogType::Force, "Color Splash crash fix: 0x{:08x}", hleAddr);
 		uint32 funcAddr = PPCInterpreter_makeCallableExportDepr(hleExport_pmcs_yellowPaintStarCrashWorkaround);
 		// set absolute jump
 		uint32 opc = 0x48000000;
@@ -411,7 +411,7 @@ void GamePatch_scan()
 	if (hleAddr)
 	{
 		// replace CMPL with CMP
-		forceLog_printf("Patching Bayonetta 2 audio bug at: 0x%08x", hleAddr+0x34);
+		cemuLog_log(LogType::Force, "Patching Bayonetta 2 audio bug at: 0x{:08x}", hleAddr+0x34);
 		uint32 opc = memory_readU32(hleAddr + 0x34);
 		opc &= ~(0x3FF << 1); // turn CMPL to CMP
 		memory_writeU32(hleAddr + 0x34, opc);
@@ -444,7 +444,7 @@ void GamePatch_scan()
 	hleAddr = hle_locate(sm3dw_dynFrameBufferResScale, nullptr, sizeof(sm3dw_dynFrameBufferResScale));
 	if (hleAddr)
 	{
-		forceLog_printf("Patching SM3DW dynamic resolution scaling at: 0x%08x", hleAddr);
+		cemuLog_log(LogType::Force, "Patching SM3DW dynamic resolution scaling at: 0x{:08x}", hleAddr);
 		memory_writeU32(hleAddr, 0x4E800020); // BLR
 	}
 
@@ -453,7 +453,7 @@ void GamePatch_scan()
 	hleAddr = hle_locate(tww_waitFunc, nullptr, sizeof(tww_waitFunc));
 	if (hleAddr)
 	{
-		forceLog_printf("Patching TWW race conditon at: 0x%08x", hleAddr);
+		cemuLog_log(LogType::Force, "Patching TWW race conditon at: 0x{:08x}", hleAddr);
 		// NOP calls to Lock/Unlock mutex
 		memory_writeU32(hleAddr + 0x34, 0x60000000);
 		memory_writeU32(hleAddr + 0x48, 0x60000000);
@@ -462,7 +462,7 @@ void GamePatch_scan()
 	}
 
 	uint32 hleInstallEnd = GetTickCount();
-	forceLog_printf("HLE scan time: %dms", hleInstallEnd-hleInstallStart);
+	cemuLog_log(LogType::Force, "HLE scan time: {}ms", hleInstallEnd-hleInstallStart);
 }
 
 RunAtCemuBoot _loadGamePatchAPI([]()
diff --git a/src/Cafe/GameProfile/GameProfile.cpp b/src/Cafe/GameProfile/GameProfile.cpp
index 9f2550c2..ea303226 100644
--- a/src/Cafe/GameProfile/GameProfile.cpp
+++ b/src/Cafe/GameProfile/GameProfile.cpp
@@ -43,7 +43,7 @@ bool gameProfile_loadBooleanOption(IniParser* iniParser, char* optionName, gameP
 		return true;
 	}
 	else
-		cemuLog_force("Unknown value '{}' for option '{}' in game profile", *option_value, optionName);
+		cemuLog_log(LogType::Force, "Unknown value '{}' for option '{}' in game profile", *option_value, optionName);
 	return false;
 }
 
@@ -64,7 +64,7 @@ bool gameProfile_loadBooleanOption2(IniParser& iniParser, const char* optionName
 		return true;
 	}
 	else
-		cemuLog_force("Unknown value '{}' for option '{}' in game profile", *option_value, optionName);
+		cemuLog_log(LogType::Force, "Unknown value '{}' for option '{}' in game profile", *option_value, optionName);
 	return false;
 }
 
@@ -94,7 +94,7 @@ bool gameProfile_loadIntegerOption(IniParser* iniParser, const char* optionName,
 	sint32 val = StringHelpers::ToInt(*option_value, defaultValue);
 	if (val < minVal || val > maxVal)
 	{
-		cemuLog_force("Value '{}' is out of range for option '{}' in game profile", *option_value, optionName);
+		cemuLog_log(LogType::Force, "Value '{}' is out of range for option '{}' in game profile", *option_value, optionName);
 		option->value = defaultValue;
 		return false;
 	}
@@ -116,7 +116,7 @@ bool gameProfile_loadIntegerOption(IniParser& iniParser, const char* optionName,
 		T val = ConvertString<T>(*option_value);
 		if (val < minVal || val > maxVal)
 		{
-			cemuLog_force("Value '{}' is out of range for option '{}' in game profile", *option_value, optionName);
+			cemuLog_log(LogType::Force, "Value '{}' is out of range for option '{}' in game profile", *option_value, optionName);
 			return false;
 		}
 
@@ -125,7 +125,7 @@ bool gameProfile_loadIntegerOption(IniParser& iniParser, const char* optionName,
 	}
 	catch(std::exception&)
 	{
-		cemuLog_force("Value '{}' is out of range for option '{}' in game profile", *option_value, optionName);
+		cemuLog_log(LogType::Force, "Value '{}' is out of range for option '{}' in game profile", *option_value, optionName);
 		return false;
 	}	
 }
@@ -140,7 +140,7 @@ bool gameProfile_loadEnumOption(IniParser& iniParser, const char* optionName, T&
 	for(const T& v : T())
 	{
 		// test integer option
-		if (boost::iequals(fmt::format("{}", static_cast<typename std::underlying_type<T>::type>(v)), *option_value))
+		if (boost::iequals(fmt::format("{}", fmt::underlying(v)), *option_value))
 		{
 			option = v;
 			return true;
@@ -175,17 +175,17 @@ void gameProfile_load()
 	ppcThreadQuantum = g_current_game_profile->GetThreadQuantum();
 
 	if (ppcThreadQuantum != GameProfile::kThreadQuantumDefault)
-		cemuLog_force("Thread quantum set to {}", ppcThreadQuantum);
+		cemuLog_log(LogType::Force, "Thread quantum set to {}", ppcThreadQuantum);
 }
 
 bool GameProfile::Load(uint64_t title_id)
 {
-	auto gameProfilePath = ActiveSettings::GetPath("gameProfiles/{:016x}.ini", title_id);
+	auto gameProfilePath = ActiveSettings::GetConfigPath("gameProfiles/{:016x}.ini", title_id);
 
 	std::optional<std::vector<uint8>> profileContents = FileStream::LoadIntoMemory(gameProfilePath);
 	if (!profileContents)
 	{
-		gameProfilePath = ActiveSettings::GetPath("gameProfiles/default/{:016x}.ini", title_id);
+		gameProfilePath = ActiveSettings::GetDataPath("gameProfiles/default/{:016x}.ini", title_id);
 		profileContents = FileStream::LoadIntoMemory(gameProfilePath);
 		if (!profileContents)
 			return false;
@@ -209,7 +209,7 @@ bool GameProfile::Load(uint64_t title_id)
 		m_gameName = std::string(game_name.begin(), game_name.end());
 		trim(m_gameName.value());
 	}
-	IniParser iniParser(*profileContents, gameProfilePath.string());
+	IniParser iniParser(*profileContents, _pathToUtf8(gameProfilePath));
 	// parse ini
 	while (iniParser.NextSection())
 	{
@@ -276,11 +276,14 @@ bool GameProfile::Load(uint64_t title_id)
 
 void GameProfile::Save(uint64_t title_id)
 {
-	auto gameProfilePath = ActiveSettings::GetPath("gameProfiles/{:016x}.ini", title_id);
+	auto gameProfileDir = ActiveSettings::GetConfigPath("gameProfiles");
+	if (std::error_code ex_ec; !fs::exists(gameProfileDir, ex_ec)) 
+		fs::create_directories(gameProfileDir, ex_ec);
+	auto gameProfilePath = gameProfileDir / fmt::format("{:016x}.ini", title_id);
 	FileStream* fs = FileStream::createFile2(gameProfilePath);
 	if (!fs)
 	{
-		cemuLog_force("Failed to write game profile");
+		cemuLog_log(LogType::Force, "Failed to write game profile");
 		return;
 	}
 
@@ -304,16 +307,11 @@ void GameProfile::Save(uint64_t title_id)
 	fs->writeLine("");
 
 	fs->writeLine("[Graphics]");
-	//WRITE_OPTIONAL_ENTRY(gpuBufferCacheAccuracy);
 	WRITE_ENTRY(accurateShaderMul);
 	WRITE_OPTIONAL_ENTRY(precompiledShaders);
 	WRITE_OPTIONAL_ENTRY(graphics_api);
 	fs->writeLine("");
 
-	/*stream_writeLine(stream_gameProfile, "[Audio]");
-	WRITE_ENTRY(disableAudio);
-	stream_writeLine(stream_gameProfile, "");*/
-
 	fs->writeLine("[Controller]");
 	for (int i = 0; i < 8; ++i)
 	{
diff --git a/src/Cafe/GraphicPack/GraphicPack2.cpp b/src/Cafe/GraphicPack/GraphicPack2.cpp
index 808536d5..6ae05c5b 100644
--- a/src/Cafe/GraphicPack/GraphicPack2.cpp
+++ b/src/Cafe/GraphicPack/GraphicPack2.cpp
@@ -11,6 +11,7 @@
 #include "util/IniParser/IniParser.h"
 #include "util/helpers/StringHelpers.h"
 #include "Cafe/CafeSystem.h"
+#include <cinttypes>
 
 std::vector<GraphicPackPtr> GraphicPack2::s_graphic_packs;
 std::vector<GraphicPackPtr> GraphicPack2::s_active_graphic_packs;
@@ -27,16 +28,16 @@ void GraphicPack2::LoadGraphicPack(fs::path graphicPackPath)
 		return;
 	std::vector<uint8> rulesData;
 	fs_rules->extract(rulesData);
-	IniParser iniParser(rulesData, rulesPath.string());
+	IniParser iniParser(rulesData, _pathToUtf8(rulesPath));
 
 	if (!iniParser.NextSection())
 	{
-		cemuLog_force("{}: Does not contain any sections", _pathToUtf8(rulesPath));
+		cemuLog_log(LogType::Force, "{}: Does not contain any sections", _pathToUtf8(rulesPath));
 		return;
 	}
 	if (!boost::iequals(iniParser.GetCurrentSectionName(), "Definition"))
 	{
-		cemuLog_force("{}: [Definition] must be the first section", _pathToUtf8(rulesPath));
+		cemuLog_log(LogType::Force, "{}: [Definition] must be the first section", _pathToUtf8(rulesPath));
 		return;
 	}
 
@@ -47,23 +48,22 @@ void GraphicPack2::LoadGraphicPack(fs::path graphicPackPath)
 		auto [ptr, ec] = std::from_chars(option_version->data(), option_version->data() + option_version->size(), versionNum);
 		if (ec != std::errc{})
 		{
-			cemuLog_force("{}: Unable to parse version", _pathToUtf8(rulesPath));
+			cemuLog_log(LogType::Force, "{}: Unable to parse version", _pathToUtf8(rulesPath));
 			return;
 		}
-
 		if (versionNum > GP_LEGACY_VERSION)
 		{
-			GraphicPack2::LoadGraphicPack(rulesPath.generic_wstring(), iniParser);
+			GraphicPack2::LoadGraphicPack(rulesPath, iniParser);
 			return;
 		}
 	}
-	cemuLog_force("{}: Outdated graphic pack", _pathToUtf8(rulesPath));
+	cemuLog_log(LogType::Force, "{}: Outdated graphic pack", _pathToUtf8(rulesPath));
 }
 
 void GraphicPack2::LoadAll()
 {
 	std::error_code ec;
-	fs::path basePath = ActiveSettings::GetPath("graphicPacks");
+	fs::path basePath = ActiveSettings::GetUserDataPath("graphicPacks");
 	for (fs::recursive_directory_iterator it(basePath, ec); it != end(it); ++it)
 	{
 		if (!it->is_directory(ec))
@@ -78,22 +78,22 @@ void GraphicPack2::LoadAll()
 	}
 }
 
-bool GraphicPack2::LoadGraphicPack(const std::wstring& filename, IniParser& rules)
+bool GraphicPack2::LoadGraphicPack(const fs::path& rulesPath, IniParser& rules)
 {
 	try
 	{
-		auto gp = std::make_shared<GraphicPack2>(filename, rules);
+		auto gp = std::make_shared<GraphicPack2>(rulesPath, rules);
 
 		// check if enabled and preset set
 		const auto& config_entries = g_config.data().graphic_pack_entries;
 
 		// legacy absolute path checking for not breaking compatibility
-		auto file = gp->GetFilename2();
+		auto file = gp->GetRulesPath();
 		auto it = config_entries.find(file.lexically_normal());
 		if (it == config_entries.cend())
 		{
 			// check for relative path
-			it = config_entries.find(MakeRelativePath(gp->GetFilename2()).lexically_normal());
+			it = config_entries.find(_utf8ToPath(gp->GetNormalizedPathString()));
 		}
 
 		if (it != config_entries.cend())
@@ -144,7 +144,7 @@ bool GraphicPack2::DeactivateGraphicPack(const std::shared_ptr<GraphicPack2>& gr
 	const auto it = std::find_if(s_active_graphic_packs.begin(), s_active_graphic_packs.end(), 
 		[graphic_pack](const GraphicPackPtr& gp)
 	{
-		return gp->GetFilename() == graphic_pack->GetFilename();
+		return gp->GetNormalizedPathString() == graphic_pack->GetNormalizedPathString();
 	}
 	);
 
@@ -172,12 +172,12 @@ void GraphicPack2::ActivateForCurrentTitle()
 		{
 			if (gp->GetPresets().empty())
 			{
-				forceLog_printf("Activate graphic pack: %s", gp->GetPath().c_str());
+				cemuLog_log(LogType::Force, "Activate graphic pack: {}", gp->GetVirtualPath());
 			}
 			else
 			{
 				std::string logLine;
-				logLine.assign(fmt::format("Activate graphic pack: {} [Presets: ", gp->GetPath()));
+				logLine.assign(fmt::format("Activate graphic pack: {} [Presets: ", gp->GetVirtualPath()));
 				bool isFirst = true;
 				for (auto& itr : gp->GetPresets())
 				{
@@ -215,12 +215,6 @@ void GraphicPack2::WaitUntilReady()
 		std::this_thread::sleep_for(std::chrono::milliseconds(5));
 }
 
-GraphicPack2::GraphicPack2(std::wstring filename)
-	: m_filename(std::move(filename))
-{
-	// unused for now
-}
-
 std::unordered_map<std::string, GraphicPack2::PresetVar> GraphicPack2::ParsePresetVars(IniParser& rules) const
 {
 	ExpressionParser parser;
@@ -254,8 +248,8 @@ std::unordered_map<std::string, GraphicPack2::PresetVar> GraphicPack2::ParsePres
 	return vars;
 }
 
-GraphicPack2::GraphicPack2(std::wstring filename, IniParser& rules)
-	: m_filename(std::move(filename))
+GraphicPack2::GraphicPack2(fs::path rulesPath, IniParser& rules)
+	: m_rulesPath(std::move(rulesPath))
 {
 	// we're already in [Definition]
 	auto option_version = rules.FindOption("version");
@@ -264,7 +258,7 @@ GraphicPack2::GraphicPack2(std::wstring filename, IniParser& rules)
 	m_version = StringHelpers::ToInt(*option_version, -1);
 	if (m_version < 0)
 	{
-		cemuLog_force(L"{}: Invalid version", m_filename);
+		cemuLog_log(LogType::Force, "{}: Invalid version", _pathToUtf8(m_rulesPath));
 		throw std::exception();
 	}
 
@@ -276,7 +270,7 @@ GraphicPack2::GraphicPack2(std::wstring filename, IniParser& rules)
 		else if (boost::iequals(*option_rendererFilter, "opengl"))
 			m_renderer_api = RendererAPI::OpenGL;
 		else
-			cemuLog_force("Unknown value '{}' for rendererFilter option", *option_rendererFilter);
+			cemuLog_log(LogType::Force, "Unknown value '{}' for rendererFilter option", *option_rendererFilter);
 	}
 
 	auto option_defaultEnabled = rules.FindOption("default");
@@ -286,6 +280,10 @@ GraphicPack2::GraphicPack2(std::wstring filename, IniParser& rules)
 		m_enabled = m_default_enabled;
 	}
 
+	auto option_allowRendertargetSizeOptimization = rules.FindOption("colorbufferOptimizationAware");
+	if (option_allowRendertargetSizeOptimization)
+		m_allowRendertargetSizeOptimization = boost::iequals(*option_allowRendertargetSizeOptimization, "true") || boost::iequals(*option_allowRendertargetSizeOptimization, "1");
+
 	auto option_vendorFilter = rules.FindOption("vendorFilter");
 	if (option_vendorFilter)
 	{
@@ -300,17 +298,17 @@ GraphicPack2::GraphicPack2(std::wstring filename, IniParser& rules)
 		else if (boost::iequals(*option_vendorFilter, "apple"))
 			m_gfx_vendor = GfxVendor::Apple;
 		else
-			cemuLog_force("Unknown value '{}' for vendorFilter", *option_vendorFilter);
+			cemuLog_log(LogType::Force, "Unknown value '{}' for vendorFilter", *option_vendorFilter);
 	}
 
 	auto option_path = rules.FindOption("path");
 	if (!option_path)
 	{
 		auto gp_name_log = rules.FindOption("name");
-		cemuLog_force("[Definition] section from '{}' graphic pack must contain option: path", gp_name_log.has_value() ? *gp_name_log : "Unknown");
+		cemuLog_log(LogType::Force, "[Definition] section from '{}' graphic pack must contain option: path", gp_name_log.has_value() ? *gp_name_log : "Unknown");
 		throw std::exception();
 	}
-	m_path = *option_path;
+	m_virtualPath = *option_path;
 
 	auto option_gp_name = rules.FindOption("name");
 	if (option_gp_name)
@@ -347,7 +345,7 @@ GraphicPack2::GraphicPack2(std::wstring filename, IniParser& rules)
 			const auto preset_name = rules.FindOption("name");
 			if (!preset_name)
 			{
-				cemuLog_force("Graphic pack \"{}\": Preset in line {} skipped because it has no name option defined", m_name, rules.GetCurrentSectionLineNumber());
+				cemuLog_log(LogType::Force, "Graphic pack \"{}\": Preset in line {} skipped because it has no name option defined", GetNormalizedPathString(), rules.GetCurrentSectionLineNumber());
 				continue;
 			}
 			
@@ -371,7 +369,7 @@ GraphicPack2::GraphicPack2(std::wstring filename, IniParser& rules)
 			}
 			catch (const std::exception & ex)
 			{
-				cemuLog_force("Graphic pack \"{}\": Can't parse preset \"{}\": {}", m_name, *preset_name, ex.what());
+				cemuLog_log(LogType::Force, "Graphic pack \"{}\": Can't parse preset \"{}\": {}", GetNormalizedPathString(), *preset_name, ex.what());
 			}
 		}
 		else if (boost::iequals(currentSectionName, "RAM"))
@@ -385,7 +383,7 @@ GraphicPack2::GraphicPack2(std::wstring filename, IniParser& rules)
 				{
 					if (m_version <= 5)
 					{
-						cemuLog_force("Graphic pack \"{}\": [RAM] options are only available for graphic pack version 6 or higher", m_name, optionNameBuf);
+						cemuLog_log(LogType::Force, "Graphic pack \"{}\": [RAM] options are only available for graphic pack version 6 or higher", GetNormalizedPathString(), optionNameBuf);
 						throw std::exception();
 					}
 
@@ -395,12 +393,12 @@ GraphicPack2::GraphicPack2(std::wstring filename, IniParser& rules)
 					{
 						if (addrEnd <= addrStart)
 						{
-							cemuLog_force("Graphic pack \"{}\": start address (0x{:08x}) must be greater than end address (0x{:08x}) for {}", m_name, addrStart, addrEnd, optionNameBuf);
+							cemuLog_log(LogType::Force, "Graphic pack \"{}\": start address (0x{:08x}) must be greater than end address (0x{:08x}) for {}", GetNormalizedPathString(), addrStart, addrEnd, optionNameBuf);
 							throw std::exception();
 						}
 						else if ((addrStart & 0xFFF) != 0 || (addrEnd & 0xFFF) != 0)
 						{
-							cemuLog_force("Graphic pack \"{}\": addresses for %s are not aligned to 0x1000", m_name, optionNameBuf);
+							cemuLog_log(LogType::Force, "Graphic pack \"{}\": addresses for %s are not aligned to 0x1000", GetNormalizedPathString(), optionNameBuf);
 							throw std::exception();
 						}
 						else
@@ -410,7 +408,7 @@ GraphicPack2::GraphicPack2(std::wstring filename, IniParser& rules)
 					}
 					else
 					{
-						cemuLog_force("Graphic pack \"{}\": has invalid syntax for option {}", m_name, optionNameBuf);
+						cemuLog_log(LogType::Force, "Graphic pack \"{}\": has invalid syntax for option {}", GetNormalizedPathString(), optionNameBuf);
 						throw std::exception();
 					}
 				}
@@ -424,24 +422,32 @@ GraphicPack2::GraphicPack2(std::wstring filename, IniParser& rules)
 		std::unordered_map<std::string, std::vector<PresetPtr>> tmp_map;
 		
 		// all vars must be defined in the default preset vars before
-		for (const auto& entry : m_presets)
+		std::vector<std::pair<std::string, std::string>> mismatchingPresetVars;
+		for (const auto& presetEntry : m_presets)
 		{
-			tmp_map[entry->category].emplace_back(entry);
+			tmp_map[presetEntry->category].emplace_back(presetEntry);
 			
-			for (auto& kv : entry->variables)
+			for (auto& presetVar : presetEntry->variables)
 			{
-				const auto it = m_preset_vars.find(kv.first);
+				const auto it = m_preset_vars.find(presetVar.first);
 				if (it == m_preset_vars.cend())
 				{
-					cemuLog_force("Graphic pack: \"{}\" contains preset variables which are not defined in the default section", m_name);
-					throw std::exception();
+					mismatchingPresetVars.emplace_back(presetEntry->name, presetVar.first);
+					continue;
 				}
-
 				// overwrite var type with default var type
-				kv.second.first = it->second.first;
+				presetVar.second.first = it->second.first;
 			}
 		}
 
+		if(!mismatchingPresetVars.empty())
+		{
+			cemuLog_log(LogType::Force, "Graphic pack \"{}\" contains preset variables which are not defined in the [Default] section:", GetNormalizedPathString());
+			for (const auto& [presetName, varName] : mismatchingPresetVars)
+				cemuLog_log(LogType::Force, "Preset: {} Variable: {}", presetName, varName);
+			throw std::exception();
+		}
+
 		// have first entry be default active for every category if no default= is set
 		for(auto entry : get_values(tmp_map))
 		{
@@ -471,7 +477,7 @@ GraphicPack2::GraphicPack2(std::wstring filename, IniParser& rules)
 				auto& p2 = kv.second[i + 1];
 				if (p1->variables.size() != p2->variables.size())
 				{
-					cemuLog_force("Graphic pack: \"{}\" contains inconsistent preset variables", m_name);
+					cemuLog_log(LogType::Force, "Graphic pack: \"{}\" contains inconsistent preset variables", GetNormalizedPathString());
 					throw std::exception();
 				}
 
@@ -479,14 +485,14 @@ GraphicPack2::GraphicPack2(std::wstring filename, IniParser& rules)
 				std::set<std::string> keys2(get_keys(p2->variables).begin(), get_keys(p2->variables).end());
 				if (keys1 != keys2)
 				{
-					cemuLog_force("Graphic pack: \"{}\" contains inconsistent preset variables", m_name);
+					cemuLog_log(LogType::Force, "Graphic pack: \"{}\" contains inconsistent preset variables", GetNormalizedPathString());
 					throw std::exception();
 				}
 
 				if(p1->is_default)
 				{
 					if(has_default)
-						cemuLog_force("Graphic pack: \"{}\" has more than one preset with the default key set for the same category \"{}\"", m_name, p1->name);
+						cemuLog_log(LogType::Force, "Graphic pack: \"{}\" has more than one preset with the default key set for the same category \"{}\"", GetNormalizedPathString(), p1->name);
 					p1->active = true;
 					has_default = true;
 				}
@@ -499,12 +505,25 @@ GraphicPack2::GraphicPack2(std::wstring filename, IniParser& rules)
 	}
 }
 
+// returns true if enabling, disabling (changeEnableState) or changing presets (changePreset) for the graphic pack requires restarting if the game is already running
+bool GraphicPack2::RequiresRestart(bool changeEnableState, bool changePreset)
+{
+	if (!GetTextureRules().empty())
+		return true;
+	return false;
+}
+
 bool GraphicPack2::Reload()
 {
 	Deactivate();
 	return Activate();
 }
 
+std::string GraphicPack2::GetNormalizedPathString() const
+{
+	return _pathToUtf8(MakeRelativePath(ActiveSettings::GetUserDataPath(), GetRulesPath()).lexically_normal());
+}
+
 bool GraphicPack2::ContainsTitleId(uint64_t title_id) const
 {
 	const auto it = std::find_if(m_title_ids.begin(), m_title_ids.end(), [title_id](uint64 id) { return id == title_id; });
@@ -647,7 +666,7 @@ bool GraphicPack2::SetActivePreset(std::string_view category, std::string_view n
 
 void GraphicPack2::LoadShaders()
 {
-	fs::path path(m_filename);
+	fs::path path = GetRulesPath();
 	for (auto& it : fs::directory_iterator(path.remove_filename()))
 	{
 		if (!is_regular_file(it))
@@ -660,7 +679,7 @@ void GraphicPack2::LoadShaders()
 			uint64 shader_base_hash = 0;
 			uint64 shader_aux_hash = 0;
 			wchar_t shader_type[256]{};
-			if (filename.size() < 256 && swscanf(filename.c_str(), L"%I64x_%I64x_%ls", &shader_base_hash, &shader_aux_hash, shader_type) == 3)
+			if (filename.size() < 256 && swscanf(filename.c_str(), L"%" SCNx64 "_%" SCNx64 "_%ls", &shader_base_hash, &shader_aux_hash, shader_type) == 3)
 			{
 				if (shader_type[0] == 'p' && shader_type[1] == 's')
 					m_custom_shaders.emplace_back(LoadShader(p, shader_base_hash, shader_aux_hash, GP_SHADER_TYPE::PIXEL));
@@ -673,7 +692,7 @@ void GraphicPack2::LoadShaders()
 			{
 				std::ifstream file(p);
 				if (!file.is_open())
-					throw std::runtime_error(fmt::format("can't open graphic pack file: {}", p.filename().string()).c_str());
+					throw std::runtime_error(fmt::format("can't open graphic pack file: {}", _pathToUtf8(p.filename())));
 
 				file.seekg(0, std::ios::end);
 				m_output_shader_source.reserve(file.tellg());
@@ -686,7 +705,7 @@ void GraphicPack2::LoadShaders()
 			{
 				std::ifstream file(p);
 				if (!file.is_open())
-					throw std::runtime_error(fmt::format("can't open graphic pack file: {}", p.filename().string()).c_str());
+					throw std::runtime_error(fmt::format("can't open graphic pack file: {}", _pathToUtf8(p.filename())));
 
 				file.seekg(0, std::ios::end);
 				m_upscaling_shader_source.reserve(file.tellg());
@@ -699,7 +718,7 @@ void GraphicPack2::LoadShaders()
 			{
 				std::ifstream file(p);
 				if (!file.is_open())
-					throw std::runtime_error(fmt::format("can't open graphic pack file: {}", p.filename().string()).c_str());
+					throw std::runtime_error(fmt::format("can't open graphic pack file: {}", _pathToUtf8(p.filename())));
 
 				file.seekg(0, std::ios::end);
 				m_downscaling_shader_source.reserve(file.tellg());
@@ -711,7 +730,7 @@ void GraphicPack2::LoadShaders()
 		}
 		catch (const std::exception& ex)
 		{
-			forceLog_printf("graphicPack: error while loading custom shader: %s", ex.what());
+			cemuLog_log(LogType::Force, "graphicPack: error while loading custom shader: {}", ex.what());
 		}
 	}
 }
@@ -734,7 +753,7 @@ bool GraphicPack2::IsPresetVisible(const PresetPtr& preset) const
 	}
 	catch (const std::exception& ex)
 	{
-		forceLog_printf("error when trying to check visiblity of preset: %s", ex.what());
+		cemuLog_log(LogType::Force, "error when trying to check visiblity of preset: {}", ex.what());
 		return false;
 	}
 }
@@ -802,7 +821,7 @@ void GraphicPack2::AddConstantsForCurrentPreset(ExpressionParser& ep)
 	}
 }
 
-void GraphicPack2::_iterateReplacedFiles(const fs::path& currentPath, std::wstring& internalPath, bool isAOC)
+void GraphicPack2::_iterateReplacedFiles(const fs::path& currentPath, bool isAOC, const char* virtualMountBase)
 {
 	uint64 currentTitleId = CafeSystem::GetForegroundTitleId();
 	uint64 aocTitleId = (currentTitleId & 0xFFFFFFFFull) | 0x0005000c00000000ull;
@@ -817,9 +836,9 @@ void GraphicPack2::_iterateReplacedFiles(const fs::path& currentPath, std::wstri
 			}
 			else
 			{
-				virtualMountPath = fs::path("vol/content/") / virtualMountPath;
+				virtualMountPath = fs::path(virtualMountBase) / virtualMountPath;
 			}
-			fscDeviceRedirect_add(virtualMountPath.generic_string(), it.path().generic_string(), m_fs_priority);
+			fscDeviceRedirect_add(virtualMountPath.generic_string(), it.file_size(), it.path().generic_string(), m_fs_priority);
 		}		
 	}
 }
@@ -830,7 +849,7 @@ void GraphicPack2::LoadReplacedFiles()
 		return;
 	m_patchedFilesLoaded = true;
 
-	fs::path gfxPackPath(m_filename.c_str());
+	fs::path gfxPackPath = GetRulesPath();
 	gfxPackPath = gfxPackPath.remove_filename();
 
 	// /content/
@@ -840,10 +859,9 @@ void GraphicPack2::LoadReplacedFiles()
 	std::error_code ec;
 	if (fs::exists(contentPath, ec))
 	{
-		std::wstring internalPath(L"/vol/content/");
 		// setup redirections	
 		fscDeviceRedirect_map();
-		_iterateReplacedFiles(contentPath, internalPath, false);
+		_iterateReplacedFiles(contentPath, false, "vol/content/");
 	}
 	// /aoc/
 	fs::path aocPath(gfxPackPath);
@@ -854,13 +872,20 @@ void GraphicPack2::LoadReplacedFiles()
 		uint64 aocTitleId = CafeSystem::GetForegroundTitleId();
 		aocTitleId = aocTitleId & 0xFFFFFFFFULL;
 		aocTitleId |= 0x0005000c00000000ULL;
-		wchar_t internalAocPath[128];
-		swprintf(internalAocPath, sizeof(internalAocPath)/sizeof(wchar_t), L"/aoc/%016llx/", aocTitleId);
-
-		std::wstring internalPath(internalAocPath);
 		// setup redirections	
 		fscDeviceRedirect_map();
-		_iterateReplacedFiles(aocPath, internalPath, true);
+		_iterateReplacedFiles(aocPath, true, nullptr);
+	}
+	
+	// /code/
+	fs::path codePath(gfxPackPath);
+	codePath.append("code");
+	
+	if (fs::exists(codePath, ec))
+	{
+	    // setup redirections
+		fscDeviceRedirect_map();
+		_iterateReplacedFiles(codePath, false, CafeSystem::GetInternalVirtualCodeFolder().c_str());
 	}
 }
 
@@ -876,21 +901,18 @@ bool GraphicPack2::Activate()
 	if (m_gfx_vendor.has_value())
 	{
 		auto vendor = g_renderer->GetVendor();
-		if (vendor == GfxVendor::IntelLegacy || vendor == GfxVendor::IntelNoLegacy)
-			vendor = GfxVendor::Intel;
-		
 		if (m_gfx_vendor.value() != vendor)
 			return false;
 	}
 
-	FileStream* fs_rules = FileStream::openFile2({ m_filename });
+	FileStream* fs_rules = FileStream::openFile2(m_rulesPath);
 	if (!fs_rules)
 		return false;
 	std::vector<uint8> rulesData;
 	fs_rules->extract(rulesData);
 	delete fs_rules;
 
-	IniParser rules({ (char*)rulesData.data(), rulesData.size()}, boost::nowide::narrow(m_filename));
+	IniParser rules({ (char*)rulesData.data(), rulesData.size()}, GetNormalizedPathString());
 
 	// load rules
 	try
@@ -944,7 +966,7 @@ bool GraphicPack2::Activate()
 					else if (anisotropyValue == 16)
 						rule.overwrite_settings.anistropic_value = 4;
 					else
-						cemuLog_log(LogType::Force, fmt::format(L"Invalid value {} for overwriteAnisotropy in graphic pack {}. Only the values 1, 2, 4, 8 or 16 are allowed.", anisotropyValue, m_filename));
+						cemuLog_log(LogType::Force, "Invalid value {} for overwriteAnisotropy in graphic pack {}. Only the values 1, 2, 4, 8 or 16 are allowed.", anisotropyValue, GetNormalizedPathString());
 				}
 				m_texture_rules.emplace_back(rule);
 			}
@@ -957,7 +979,7 @@ bool GraphicPack2::Activate()
 				auto option_upscale = rules.FindOption("upscaleMagFilter");
 				if(option_upscale && boost::iequals(*option_upscale, "NearestNeighbor"))
 					m_output_settings.upscale_filter = LatteTextureView::MagFilter::kNearestNeighbor;
-				auto option_downscale = rules.FindOption("NearestNeighbor");
+				auto option_downscale = rules.FindOption("downscaleMinFilter");
 				if (option_downscale && boost::iequals(*option_downscale, "NearestNeighbor"))
 					m_output_settings.downscale_filter = LatteTextureView::MagFilter::kNearestNeighbor;
 			}
@@ -965,7 +987,7 @@ bool GraphicPack2::Activate()
 	}
 	catch(const std::exception& ex)
 	{
-		forceLog_printf((char*)ex.what());
+		cemuLog_log(LogType::Force, ex.what());
 		return false;
 	}
 
@@ -989,11 +1011,11 @@ bool GraphicPack2::Activate()
 		if (LatteTiming_getCustomVsyncFrequency(globalCustomVsyncFreq))
 		{
 			if (customVsyncFreq != globalCustomVsyncFreq)
-				forceLog_printf("rules.txt error: Mismatching vsync frequency %d in graphic pack \'%s\'", customVsyncFreq, GetPath().c_str());
+				cemuLog_log(LogType::Force, "rules.txt error: Mismatching vsync frequency {} in graphic pack \'{}\'", customVsyncFreq, GetVirtualPath());
 		}
 		else
 		{
-			forceLog_printf("Set vsync frequency to %d (graphic pack %s)", customVsyncFreq, GetPath().c_str());
+			cemuLog_log(LogType::Force, "Set vsync frequency to {} (graphic pack {})", customVsyncFreq, GetVirtualPath());
 			LatteTiming_setCustomVsyncFrequency(customVsyncFreq);
 		}
 	}
@@ -1020,9 +1042,9 @@ bool GraphicPack2::Deactivate()
 	m_upscaling_shader_ud.reset();
 	m_downscaling_shader_ud.reset();
 
-	m_output_shader_source = "";
-	m_upscaling_shader_source = "";
-	m_downscaling_shader_source = "";
+	m_output_shader_source.clear();
+	m_upscaling_shader_source.clear();
+	m_downscaling_shader_source.clear();
 	
 	if (HasCustomVSyncFrequency())
 	{
@@ -1178,7 +1200,7 @@ std::vector<uint64> GraphicPack2::ParseTitleIds(IniParser& rules, const char* op
 void GraphicPack2::ApplyShaderPresets(std::string& shader_source) const
 {
 	const auto active_presets = GetActivePresets();
-	const std::regex regex(R"(\$[a-zA-Z\_0-9]+)");
+	const std::regex regex(R"(\$[a-zA-Z_0-9]+)");
 
 	std::smatch match;
 	size_t offset = 0;
@@ -1246,4 +1268,4 @@ std::vector<std::pair<MPTR, MPTR>> GraphicPack2::GetActiveRAMMappings()
 			return a.first < b.first;
 		});
 	return v;
-}
\ No newline at end of file
+}
diff --git a/src/Cafe/GraphicPack/GraphicPack2.h b/src/Cafe/GraphicPack/GraphicPack2.h
index 4c18b5c6..fc9603cd 100644
--- a/src/Cafe/GraphicPack/GraphicPack2.h
+++ b/src/Cafe/GraphicPack/GraphicPack2.h
@@ -97,22 +97,23 @@ public:
 	};
 	using PresetPtr = std::shared_ptr<Preset>;
 
-	GraphicPack2(std::wstring filename);
-	GraphicPack2(std::wstring filename, IniParser& rules);
+	GraphicPack2(fs::path rulesPath, IniParser& rules);
 
 	bool IsEnabled() const { return m_enabled; }
 	bool IsActivated() const { return m_activated; }
 	sint32 GetVersion() const { return m_version; }
-	const std::wstring& GetFilename() const { return m_filename; }
-	const fs::path GetFilename2() const { return fs::path(m_filename); }
+	const fs::path GetRulesPath() const { return m_rulesPath; }
+	std::string GetNormalizedPathString() const;
+	bool RequiresRestart(bool changeEnableState, bool changePreset);
 	bool Reload();
 
 	bool HasName() const { return !m_name.empty();  }
 
-	const std::string& GetName() const { return m_name.empty() ? m_path : m_name; }
-	const std::string& GetPath() const { return m_path; }
+	const std::string& GetName() const { return m_name.empty() ? m_virtualPath : m_name; }
+	const std::string& GetVirtualPath() const { return m_virtualPath; } // returns the path in the gfx tree hierarchy
 	const std::string& GetDescription() const { return m_description; }
 	bool IsDefaultEnabled() const {	return m_default_enabled; }
+	bool AllowRendertargetSizeOptimization() const { return m_allowRendertargetSizeOptimization; }
 
 	void SetEnabled(bool state) { m_enabled = state; }
 
@@ -164,7 +165,7 @@ public:
 	static const std::vector<std::shared_ptr<GraphicPack2>>& GetGraphicPacks() { return s_graphic_packs; }
 	static const std::vector<std::shared_ptr<GraphicPack2>>& GetActiveGraphicPacks() { return s_active_graphic_packs; }
 	static void LoadGraphicPack(fs::path graphicPackPath);
-	static bool LoadGraphicPack(const std::wstring& filename, class IniParser& rules);
+	static bool LoadGraphicPack(const fs::path& rulesPath, class IniParser& rules);
 	static bool ActivateGraphicPack(const std::shared_ptr<GraphicPack2>& graphic_pack);
 	static bool DeactivateGraphicPack(const std::shared_ptr<GraphicPack2>& graphic_pack);
 	static void ClearGraphicPacks();
@@ -172,6 +173,7 @@ public:
 
 	static void ActivateForCurrentTitle();
 	static void Reset();
+
 private:
 	bool Activate();
 	bool Deactivate();
@@ -207,15 +209,17 @@ private:
 			parser.TryAddConstant(var.first, (TType)var.second.second);
 	}
 
-	std::wstring m_filename;
+	fs::path m_rulesPath;
 
 	sint32 m_version;
 	std::string m_name;
-	std::string m_path;
+	std::string m_virtualPath;
 	std::string m_description;
 
 	bool m_default_enabled = false;
 
+	bool m_allowRendertargetSizeOptimization = false; // gfx pack supports framebuffers with non-padded sizes, which is an optional optimization introduced with Cemu 2.0-74
+
 	// filter
 	std::optional<RendererAPI> m_renderer_api;
 	std::optional<GfxVendor> m_gfx_vendor;
@@ -256,7 +260,7 @@ private:
 	CustomShader LoadShader(const fs::path& path, uint64 shader_base_hash, uint64 shader_aux_hash, GP_SHADER_TYPE shader_type) const;
 	void ApplyShaderPresets(std::string& shader_source) const;
 	void LoadReplacedFiles();
-	void _iterateReplacedFiles(const fs::path& currentPath, std::wstring& internalPath, bool isAOC);
+	void _iterateReplacedFiles(const fs::path& currentPath, bool isAOC, const char* virtualMountBase);
 
 	// ram mappings
 	std::vector<std::pair<MPTR, MPTR>> m_ramMappings;
diff --git a/src/Cafe/GraphicPack/GraphicPack2Patches.cpp b/src/Cafe/GraphicPack/GraphicPack2Patches.cpp
index 5a3c85b9..2c067484 100644
--- a/src/Cafe/GraphicPack/GraphicPack2Patches.cpp
+++ b/src/Cafe/GraphicPack/GraphicPack2Patches.cpp
@@ -6,6 +6,7 @@
 #include "boost/algorithm/string.hpp"
 
 #include "gui/wxgui.h" // for wxMessageBox
+#include "gui/helpers/wxHelpers.h"
 
 // error handler
 void PatchErrorHandler::printError(class PatchGroup* patchGroup, sint32 lineNumber, std::string_view errorMsg)
@@ -33,27 +34,29 @@ void PatchErrorHandler::printError(class PatchGroup* patchGroup, sint32 lineNumb
 	cemuLog_writeLineToLog(msg, true, true);
 	m_anyErrorTriggered = true;
 
-	if (cafeLog_isLoggingFlagEnabled(LOG_TYPE_PATCHES))
+	if (cemuLog_isLoggingEnabled(LogType::Patches))
 		errorMessages.emplace_back(msg);
 }
 
 void PatchErrorHandler::showStageErrorMessageBox()
 {
-	std::string errorMsg;
+	wxString errorMsg;
 	if (m_gp)
 	{
 		if (m_stage == STAGE::PARSER)
-			errorMsg.assign(fmt::format("Failed to load patches for graphic pack \'{}\'", m_gp->GetName()));
+			errorMsg.assign(formatWxString(_("Failed to load patches for graphic pack \'{}\'"), m_gp->GetName()));
 		else
-			errorMsg.assign(fmt::format("Failed to apply patches for graphic pack \'{}\'", m_gp->GetName()));
+			errorMsg.assign(formatWxString(_("Failed to apply patches for graphic pack \'{}\'"), m_gp->GetName()));
 	}
 	else
 	{
 		cemu_assert_debug(false); // graphic pack should always be set
 	}
-	if (cafeLog_isLoggingFlagEnabled(LOG_TYPE_PATCHES))
+	if (cemuLog_isLoggingEnabled(LogType::Patches))
 	{
-		errorMsg.append("\n \nDetails:\n");
+		errorMsg.append("\n \n")
+			.append(_("Details:"))
+			.append("\n");
 		for (auto& itr : errorMessages)
 		{
 			errorMsg.append(itr);
@@ -61,26 +64,15 @@ void PatchErrorHandler::showStageErrorMessageBox()
 		}
 	}
 
-	wxMessageBox(errorMsg, "Graphic pack error");
+	wxMessageBox(errorMsg, _("Graphic pack error"));
 }
 
 // loads Cemu-style patches (patch_<anything>.asm)
 // returns true if at least one file was found even if it could not be successfully parsed
 bool GraphicPack2::LoadCemuPatches()
 {
-	// todo - once we have updated to C++20 we can replace these with the new std::string functions
-	auto startsWith = [](const std::wstring& str, const std::wstring& prefix)
-	{
-		return str.size() >= prefix.size() && 0 == str.compare(0, prefix.size(), prefix);
-	};
-
-	auto endsWith = [](const std::wstring& str, const std::wstring& suffix)
-	{
-		return str.size() >= suffix.size() && 0 == str.compare(str.size() - suffix.size(), suffix.size(), suffix);
-	};
-
 	bool foundPatches = false;
-	fs::path path(m_filename);
+	fs::path path(m_rulesPath);
 	path.remove_filename();
 	for (auto& p : fs::directory_iterator(path))
 	{
@@ -88,10 +80,10 @@ bool GraphicPack2::LoadCemuPatches()
 		if (fs::is_regular_file(p.status()) && path.has_filename())
 		{
 			// check if filename matches
-			std::wstring filename = path.filename().generic_wstring();
-			if (boost::istarts_with(filename, L"patch_") && boost::iends_with(filename, L".asm"))
+			std::string filename = _pathToUtf8(path.filename());
+			if (boost::istarts_with(filename, "patch_") && boost::iends_with(filename, ".asm"))
 			{
-				FileStream* patchFile = FileStream::openFile(path.generic_wstring().c_str());
+				FileStream* patchFile = FileStream::openFile2(path);
 				if (patchFile)
 				{
 					// read file
@@ -102,14 +94,14 @@ bool GraphicPack2::LoadCemuPatches()
 					// load Cemu style patch file
 					if (!ParseCemuPatchesTxtInternal(patchesStream))
 					{
-						forceLog_printfW(L"Error while processing \"%s\". No patches for this graphic pack will be applied.", path.c_str());
+						cemuLog_log(LogType::Force, "Error while processing \"{}\". No patches for this graphic pack will be applied.", _pathToUtf8(path));
 						cemu_assert_debug(list_patchGroups.empty());
 						return true; // return true since a .asm patch was found even if we could not parse it
 					}
 				}
 				else
 				{
-					forceLog_printfW(L"Unable to load patch file \"%s\"", path.c_str());
+					cemuLog_log(LogType::Force, "Unable to load patch file \"{}\"", _pathToUtf8(path));
 				}
 				foundPatches = true;
 			}
@@ -121,33 +113,22 @@ bool GraphicPack2::LoadCemuPatches()
 void GraphicPack2::LoadPatchFiles()
 {
 	// order of loading patches:
-	// 1) If Cemuhook is loaded:
-	//    1.1) Check if patches.txt exists and if it does, stop here and do nothing (Cemuhook takes over patching)
-	//    1.2) Load Cemu-style patches (patch_<name>.asm)
-	// 2) If Cemuhook is not loaded:
-	//    1.1) Load Cemu-style patches (patch_<name>.asm), stop here if at least one patch file exists
-	//    1.2) Load Cemuhook patches.txt
-
-	// update: As of 1.20.2b Cemu always takes over patching since Cemuhook patching broke due to other internal changes (memory allocation changed and some reordering on when graphic packs get loaded)
+	// 1) Load Cemu-style patches (patch_<name>.asm), stop here if at least one patch file exists
+	// 2) Load Cemuhook patches.txt
 	if (LoadCemuPatches())
 		return; // exit if at least one Cemu style patch file was found
 	// fall back to Cemuhook patches.txt to guarantee backward compatibility
-	fs::path path(m_filename);
+	fs::path path(m_rulesPath);
 	path.remove_filename();
 	path.append("patches.txt");
-
-	FileStream* patchFile = FileStream::openFile(path.generic_wstring().c_str());
-
+	FileStream* patchFile = FileStream::openFile2(path);
 	if (patchFile == nullptr)
 		return;
-
 	// read file
 	std::vector<uint8> fileData;
 	patchFile->extract(fileData);
 	delete patchFile;
-
 	cemu_assert_debug(list_patchGroups.empty());
-
 	// parse
 	MemStreamReader patchesStream(fileData.data(), (sint32)fileData.size());
 	ParseCemuhookPatchesTxtInternal(patchesStream);
diff --git a/src/Cafe/GraphicPack/GraphicPack2PatchesApply.cpp b/src/Cafe/GraphicPack/GraphicPack2PatchesApply.cpp
index 98a5b693..b6af542d 100644
--- a/src/Cafe/GraphicPack/GraphicPack2PatchesApply.cpp
+++ b/src/Cafe/GraphicPack/GraphicPack2PatchesApply.cpp
@@ -353,7 +353,7 @@ PATCH_RESOLVE_RESULT PatchEntryInstruction::resolveReloc(PatchContext_t& ctx, PP
 				// absolute
 				if (result >= 0x3FFFFFC)
 				{
-					forceLog_printf("Target \'%s\' for branch at line %d out of range", reloc->m_expression.c_str(), m_lineNumber);
+					cemuLog_log(LogType::Force, "Target \'{}\' for branch at line {} out of range", reloc->m_expression, m_lineNumber);
 					return PATCH_RESOLVE_RESULT::VALUE_ERROR;
 				}
 				opcode &= ~0x3FFFFFC;
@@ -438,7 +438,7 @@ PATCH_RESOLVE_RESULT PatchEntryInstruction::resolve(PatchContext_t& ctx)
 	{
 		if (_relocateAddress(resolverState.currentGroup, &ctx, m_addr, m_relocatedAddr) == false)
 		{
-			forceLog_printf("Patches: Address 0x%08x (line %d) is not within code cave or any module section", this->getAddr(), this->m_lineNumber);
+			cemuLog_log(LogType::Force, "Patches: Address 0x{:08x} (line {}) is not within code cave or any module section", this->getAddr(), this->m_lineNumber);
 			cemu_assert_debug(false);
 			return PATCH_RESOLVE_RESULT::INVALID_ADDRESS;
 		}
@@ -639,12 +639,12 @@ void GraphicPack2::ApplyPatchGroups(std::vector<PatchGroup*>& groups, const RPLM
 		if (patchGroup->codeCaveSize > 0)
 		{
 			auto codeCaveMem = RPLLoader_AllocateCodeCaveMem(256, patchGroup->codeCaveSize);
-			forceLog_printf("Applying patch group \'%s\' (Codecave: %08x-%08x)", patchGroup->name.c_str(), codeCaveMem.GetMPTR(), codeCaveMem.GetMPTR() + patchGroup->codeCaveSize);
+			cemuLog_log(LogType::Force, "Applying patch group \'{}\' (Codecave: {:08x}-{:08x})", patchGroup->name, codeCaveMem.GetMPTR(), codeCaveMem.GetMPTR() + patchGroup->codeCaveSize);
 			patchGroup->codeCaveMem = codeCaveMem;
 		}
 		else
 		{
-			forceLog_printf("Applying patch group \'%s\'", patchGroup->name.c_str());
+			cemuLog_log(LogType::Force, "Applying patch group \'{}\'", patchGroup->name);
 			patchGroup->codeCaveMem = nullptr;
 		}
 	}
@@ -738,7 +738,7 @@ void GraphicPack2::UndoPatchGroups(std::vector<PatchGroup*>& groups, const RPLMo
 
 void GraphicPack2::NotifyModuleLoaded(const RPLModule* rpl)
 {
-	cemuLog_force("Loaded module \'{}\' with checksum 0x{:08x}", rpl->moduleName2, rpl->patchCRC);
+	cemuLog_log(LogType::Force, "Loaded module \'{}\' with checksum 0x{:08x}", rpl->moduleName2, rpl->patchCRC);
 
 	std::lock_guard<std::recursive_mutex> lock(mtx_patches);
 	list_modules.emplace_back(rpl);
diff --git a/src/Cafe/GraphicPack/GraphicPack2PatchesParser.cpp b/src/Cafe/GraphicPack/GraphicPack2PatchesParser.cpp
index 12f97ef7..05f8c696 100644
--- a/src/Cafe/GraphicPack/GraphicPack2PatchesParser.cpp
+++ b/src/Cafe/GraphicPack/GraphicPack2PatchesParser.cpp
@@ -25,7 +25,7 @@ sint32 GraphicPack2::GetLengthWithoutComment(const char* str, size_t length)
 
 void GraphicPack2::LogPatchesSyntaxError(sint32 lineNumber, std::string_view errorMsg)
 {
-	cemuLog_log(LogType::Force, fmt::format(L"Syntax error while parsing patch for graphic pack '{}':", this->GetFilename()));
+	cemuLog_log(LogType::Force, "Syntax error while parsing patch for graphic pack '{}':", _pathToUtf8(this->GetRulesPath()));
 	if(lineNumber >= 0)
 		cemuLog_log(LogType::Force, fmt::format("Line {0}: {1}", lineNumber, errorMsg));
 	else
@@ -68,7 +68,7 @@ void GraphicPack2::AddPatchGroup(PatchGroup* group)
 	if (group->list_patches.size() < (numEstimatedCodeCaveInstr / 8))
 	{
 		// if less than 1/8th of the code cave is filled print a warning
-		forceLog_printf("Graphic pack patches: Code cave for group [%s] in gfx pack \"%s\" ranges from 0 to 0x%x but has only few instructions. Is this intentional?", group->name.c_str(), this->m_name.c_str(), codeCaveMaxAddr);
+		cemuLog_log(LogType::Force, "Graphic pack patches: Code cave for group [{}] in gfx pack \"{}\" ranges from 0 to 0x{:x} but has only few instructions. Is this intentional?", group->name, this->m_name, codeCaveMaxAddr);
 	}
 	group->codeCaveSize = codeCaveMaxAddr;
 	list_patchGroups.emplace_back(group);
diff --git a/src/Cafe/HW/ACR/ACR.cpp b/src/Cafe/HW/ACR/ACR.cpp
index b8a48a8a..362aef5a 100644
--- a/src/Cafe/HW/ACR/ACR.cpp
+++ b/src/Cafe/HW/ACR/ACR.cpp
@@ -25,13 +25,13 @@ namespace HW_ACR
 	/* 0x0D00021C | Accesses VI register currently selected by VIADDR */
 	HWREG::ACR_VI_DATA ACR_VIDATA_R32(PAddr addr)
 	{
-		forceLogDebug_printf("ACR_VIDATA read with selected reg %08x", g_acr.viAddr.get_ADDR());
+		cemuLog_logDebug(LogType::Force, "ACR_VIDATA read with selected reg {:08x}", g_acr.viAddr.get_ADDR());
 		return HWREG::ACR_VI_DATA();
 	}
 
 	void ACR_VIDATA_W32(PAddr addr, HWREG::ACR_VI_DATA newValue)
 	{
-		forceLogDebug_printf("ACR_VIDATA write %08x with selected reg %08x", newValue.get_DATA(), g_acr.viAddr.get_ADDR());
+		cemuLog_logDebug(LogType::Force, "ACR_VIDATA write {:08x} with selected reg {:08x}", newValue.get_DATA(), g_acr.viAddr.get_ADDR());
 	}
 
 	/* 0x0D000224 | Controls the selected VI register? */
diff --git a/src/Cafe/HW/Espresso/Const.h b/src/Cafe/HW/Espresso/Const.h
index 88a1a9de..06959bb0 100644
--- a/src/Cafe/HW/Espresso/Const.h
+++ b/src/Cafe/HW/Espresso/Const.h
@@ -8,4 +8,5 @@ namespace Espresso
 	constexpr inline uint64 BUS_CLOCK = 248625000;
 	constexpr inline uint64 TIMER_CLOCK = BUS_CLOCK / 4;
 
+	constexpr inline uint32 MEM_PAGE_SIZE = 0x20000;
 };
\ No newline at end of file
diff --git a/src/Cafe/HW/Espresso/Debugger/DebugSymbolStorage.h b/src/Cafe/HW/Espresso/Debugger/DebugSymbolStorage.h
index 0d7b7d49..0a46951d 100644
--- a/src/Cafe/HW/Espresso/Debugger/DebugSymbolStorage.h
+++ b/src/Cafe/HW/Espresso/Debugger/DebugSymbolStorage.h
@@ -24,40 +24,45 @@ class DebugSymbolStorage
 public:
 	static void StoreDataType(MPTR address, DEBUG_SYMBOL_TYPE type)
 	{
-		s_lock.acquire();
+		s_lock.lock();
 		s_typeStorage[address] = type;
-		s_lock.release();
+		s_lock.unlock();
 	}
 
 	static DEBUG_SYMBOL_TYPE GetDataType(MPTR address)
 	{
-		s_lock.acquire();
+		s_lock.lock();
 		auto itr = s_typeStorage.find(address);
 		if (itr == s_typeStorage.end())
 		{
-			s_lock.release();
+			s_lock.unlock();
 			return DEBUG_SYMBOL_TYPE::UNDEFINED;
 		}
 		DEBUG_SYMBOL_TYPE t = itr->second;
-		s_lock.release();
+		s_lock.unlock();
 		return t;
 	}
 
 	static void ClearRange(MPTR address, uint32 length)
 	{
-		s_lock.acquire();
-		while (length > 0)
+		if (length == 0)
+			return;
+		s_lock.lock();
+		for (;;)
 		{
 			auto itr = s_typeStorage.find(address);
 			if (itr != s_typeStorage.end())
 				s_typeStorage.erase(itr);
+			
+			if (length <= 4)
+				break;
 			address += 4;
 			length -= 4;
 		}
-		s_lock.release();
+		s_lock.unlock();
 	}
 
 private:
 	static FSpinlock s_lock;
 	static std::unordered_map<MPTR, DEBUG_SYMBOL_TYPE> s_typeStorage;
-};
\ No newline at end of file
+};
diff --git a/src/Cafe/HW/Espresso/Debugger/Debugger.cpp b/src/Cafe/HW/Espresso/Debugger/Debugger.cpp
index fc015285..e84c9fda 100644
--- a/src/Cafe/HW/Espresso/Debugger/Debugger.cpp
+++ b/src/Cafe/HW/Espresso/Debugger/Debugger.cpp
@@ -1,5 +1,6 @@
 #include "gui/guiWrapper.h"
 #include "Debugger.h"
+#include "Cafe/OS/RPL/rpl_structs.h"
 #include "Cemu/PPCAssembler/ppcAssembler.h"
 #include "Cafe/HW/Espresso/Recompiler/PPCRecompiler.h"
 #include "Cemu/ExpressionParser/ExpressionParser.h"
@@ -7,6 +8,7 @@
 #include "gui/debugger/DebuggerWindow2.h"
 
 #include "Cafe/OS/libs/coreinit/coreinit.h"
+#include "util/helpers/helpers.h"
 
 #if BOOST_OS_WINDOWS
 #include <Windows.h>
@@ -74,7 +76,7 @@ uint32 debugger_getAddressOriginalOpcode(uint32 address)
 	auto bpItr = debugger_getFirstBP(address);
 	while (bpItr)
 	{
-		if (bpItr->bpType == DEBUGGER_BP_T_NORMAL || bpItr->bpType == DEBUGGER_BP_T_ONE_SHOT)
+		if (bpItr->isExecuteBP())
 			return bpItr->originalOpcodeValue;
 		bpItr = bpItr->next;
 	}
@@ -103,7 +105,7 @@ void debugger_updateExecutionBreakpoint(uint32 address, bool forceRestore)
 			if (bpItr->enabled && forceRestore == false)
 			{
 				// write TW instruction to memory
-				debugger_updateMemoryU32(address, (31 << 26) | (4 << 1));
+				debugger_updateMemoryU32(address, DEBUGGER_BP_T_DEBUGGER_TW);
 				return;
 			}
 			else
@@ -121,30 +123,16 @@ void debugger_updateExecutionBreakpoint(uint32 address, bool forceRestore)
 	}
 }
 
-void debugger_createExecuteBreakpoint(uint32 address)
+void debugger_createCodeBreakpoint(uint32 address, uint8 bpType)
 {
 	// check if breakpoint already exists
 	auto existingBP = debugger_getFirstBP(address);
-	if (existingBP && debuggerBPChain_hasType(existingBP, DEBUGGER_BP_T_NORMAL))
+	if (existingBP && debuggerBPChain_hasType(existingBP, bpType))
 		return; // breakpoint already exists
 	// get original opcode at address
 	uint32 originalOpcode = debugger_getAddressOriginalOpcode(address);
 	// init breakpoint object
-	DebuggerBreakpoint* bp = new DebuggerBreakpoint(address, originalOpcode, DEBUGGER_BP_T_NORMAL, true);
-	debuggerBPChain_add(address, bp);
-	debugger_updateExecutionBreakpoint(address);
-}
-
-void debugger_createSingleShotExecuteBreakpoint(uint32 address)
-{
-	// check if breakpoint already exists
-	auto existingBP = debugger_getFirstBP(address);
-	if (existingBP && debuggerBPChain_hasType(existingBP, DEBUGGER_BP_T_ONE_SHOT))
-		return; // breakpoint already exists
-	// get original opcode at address
-	uint32 originalOpcode = debugger_getAddressOriginalOpcode(address);
-	// init breakpoint object
-	DebuggerBreakpoint* bp = new DebuggerBreakpoint(address, originalOpcode, DEBUGGER_BP_T_ONE_SHOT, true);
+	DebuggerBreakpoint* bp = new DebuggerBreakpoint(address, originalOpcode, bpType, true);
 	debuggerBPChain_add(address, bp);
 	debugger_updateExecutionBreakpoint(address);
 }
@@ -171,14 +159,25 @@ void debugger_updateMemoryBreakpoint(DebuggerBreakpoint* bp)
 		{
 			ctx.Dr0 = (DWORD64)memory_getPointerFromVirtualOffset(bp->address);
 			ctx.Dr1 = (DWORD64)memory_getPointerFromVirtualOffset(bp->address);
-			ctx.Dr7 = 1 | (1 << 16) | (3 << 18); // enable dr0, track write, 4 byte length
-			ctx.Dr7 |= (4 | (3 << 20) | (3 << 22)); // enable dr1, track read+write, 4 byte length
+			// breakpoint 0
+			SetBits(ctx.Dr7, 0, 1, 1);  // breakpoint #0 enabled: true
+			SetBits(ctx.Dr7, 16, 2, 1); // breakpoint #0 condition: 1 (write)
+			SetBits(ctx.Dr7, 18, 2, 3); // breakpoint #0 length: 3 (4 bytes)
+			// breakpoint 1
+			SetBits(ctx.Dr7, 2, 1, 1);  // breakpoint #1 enabled: true
+			SetBits(ctx.Dr7, 20, 2, 3); // breakpoint #1 condition: 3 (read & write)
+			SetBits(ctx.Dr7, 22, 2, 3); // breakpoint #1 length: 3 (4 bytes)
 		}
 		else
 		{
-			ctx.Dr0 = (DWORD64)0;
-			ctx.Dr1 = (DWORD64)0;
-			ctx.Dr7 = 0; // disable dr0
+			// breakpoint 0
+			SetBits(ctx.Dr7, 0, 1, 0);  // breakpoint #0 enabled: false
+			SetBits(ctx.Dr7, 16, 2, 0); // breakpoint #0 condition: 1 (write)
+			SetBits(ctx.Dr7, 18, 2, 0); // breakpoint #0 length: 3 (4 bytes)
+			// breakpoint 1
+			SetBits(ctx.Dr7, 2, 1, 0);  // breakpoint #1 enabled: false
+			SetBits(ctx.Dr7, 20, 2, 0); // breakpoint #1 condition: 3 (read & write)
+			SetBits(ctx.Dr7, 22, 2, 0); // breakpoint #1 length: 3 (4 bytes)
 		}
 		SetThreadContext(hThread, &ctx);
 		ResumeThread(hThread);
@@ -188,10 +187,10 @@ void debugger_updateMemoryBreakpoint(DebuggerBreakpoint* bp)
 	#endif
 }
 
-void debugger_handleSingleStepException(uint32 drMask)
+void debugger_handleSingleStepException(uint64 dr6)
 {
-	bool triggeredDR0 = (drMask & (1 << 0)) != 0; // write
-	bool triggeredDR1 = (drMask & (1 << 1)) != 0; // read
+	bool triggeredDR0 = GetBits(dr6, 0, 1); // write
+	bool triggeredDR1 = GetBits(dr6, 1, 1); // read and write
 	bool catchBP = false;
 	if (triggeredDR0 && triggeredDR1)
 	{
@@ -207,7 +206,8 @@ void debugger_handleSingleStepException(uint32 drMask)
 	}
 	if (catchBP)
 	{
-		debugger_createSingleShotExecuteBreakpoint(ppcInterpreterCurrentInstance->instructionPointer + 4);
+		PPCInterpreter_t* hCPU = PPCInterpreter_getCurrentInstance();
+		debugger_createCodeBreakpoint(hCPU->instructionPointer + 4, DEBUGGER_BP_T_ONE_SHOT);
 	}
 }
 
@@ -239,7 +239,7 @@ void debugger_handleEntryBreakpoint(uint32 address)
 	if (!debuggerState.breakOnEntry)
 		return;
 
-	debugger_createExecuteBreakpoint(address);
+	debugger_createCodeBreakpoint(address, DEBUGGER_BP_T_NORMAL);
 }
 
 void debugger_deleteBreakpoint(DebuggerBreakpoint* bp)
@@ -287,10 +287,27 @@ void debugger_toggleExecuteBreakpoint(uint32 address)
 	{ 
 		// delete existing breakpoint
 		debugger_deleteBreakpoint(existingBP);
-		return;
 	}
-	// create new
-	debugger_createExecuteBreakpoint(address);
+	else
+	{
+		// create new execution breakpoint
+		debugger_createCodeBreakpoint(address, DEBUGGER_BP_T_NORMAL);
+	}
+}
+
+void debugger_toggleLoggingBreakpoint(uint32 address)
+{
+	auto existingBP = debugger_getFirstBP(address, DEBUGGER_BP_T_LOGGING);
+	if (existingBP)
+	{
+		// delete existing breakpoint
+		debugger_deleteBreakpoint(existingBP);
+	}
+	else
+	{
+		// create new logging breakpoint
+		debugger_createCodeBreakpoint(address, DEBUGGER_BP_T_LOGGING);
+	}
 }
 
 void debugger_forceBreak()
@@ -316,7 +333,7 @@ void debugger_toggleBreakpoint(uint32 address, bool state, DebuggerBreakpoint* b
 	{
 		if (bpItr == bp)
 		{
-			if (bpItr->bpType == DEBUGGER_BP_T_NORMAL)
+			if (bpItr->bpType == DEBUGGER_BP_T_NORMAL || bpItr->bpType == DEBUGGER_BP_T_LOGGING)
 			{
 				bp->enabled = state;
 				debugger_updateExecutionBreakpoint(address);
@@ -441,6 +458,34 @@ bool debugger_hasPatch(uint32 address)
 	return false;
 }
 
+void debugger_removePatch(uint32 address)
+{
+	for (sint32 i = 0; i < debuggerState.patches.size(); i++)
+	{
+		auto& patch = debuggerState.patches[i];
+		if (address < patch->address || address >= (patch->address + patch->length))
+			continue;
+		MPTR startAddress = patch->address;
+		MPTR endAddress = patch->address + patch->length;
+		// remove any breakpoints overlapping with the patch
+		for (auto& bp : debuggerState.breakpoints)
+		{
+			if (bp->address + 4 > startAddress && bp->address < endAddress)
+			{
+				bp->enabled = false;
+				debugger_updateExecutionBreakpoint(bp->address);
+			}
+		}
+		// restore original data
+		memcpy(MEMPTR<void>(startAddress).GetPtr(), patch->origData.data(), patch->length);
+		PPCRecompiler_invalidateRange(startAddress, endAddress);
+		// remove patch
+		delete patch;
+		debuggerState.patches.erase(debuggerState.patches.begin() + i);
+		return;
+	}
+}
+
 void debugger_stepInto(PPCInterpreter_t* hCPU, bool updateDebuggerWindow = true)
 {
 	bool isRecEnabled = ppcRecompilerEnabled;
@@ -475,7 +520,7 @@ bool debugger_stepOver(PPCInterpreter_t* hCPU)
 		return false;
 	}
 	// create one-shot breakpoint at next instruction
-	debugger_createSingleShotExecuteBreakpoint(initialIP +4);
+	debugger_createCodeBreakpoint(initialIP + 4, DEBUGGER_BP_T_ONE_SHOT);
 	// step over current instruction (to avoid breakpoint)
 	debugger_stepInto(hCPU);
 	debuggerWindow_moveIP();
@@ -497,8 +542,78 @@ void debugger_createPPCStateSnapshot(PPCInterpreter_t* hCPU)
 
 void debugger_enterTW(PPCInterpreter_t* hCPU)
 {
+	// handle logging points
+	DebuggerBreakpoint* bp = debugger_getFirstBP(hCPU->instructionPointer);
+	bool shouldBreak = debuggerBPChain_hasType(bp, DEBUGGER_BP_T_NORMAL) || debuggerBPChain_hasType(bp, DEBUGGER_BP_T_ONE_SHOT);
+	while (bp)
+	{
+		if (bp->bpType == DEBUGGER_BP_T_LOGGING && bp->enabled)
+		{
+			std::string comment = !bp->comment.empty() ? boost::nowide::narrow(bp->comment) : fmt::format("Breakpoint at 0x{:08X} (no comment)", bp->address);
+
+			auto replacePlaceholders = [&](const std::string& prefix, const auto& formatFunc)
+			{
+				size_t pos = 0;
+				while ((pos = comment.find(prefix, pos)) != std::string::npos)
+				{
+					size_t endPos = comment.find('}', pos);
+					if (endPos == std::string::npos)
+						break;
+
+					try
+					{
+						if (int regNum = ConvertString<int>(comment.substr(pos + prefix.length(), endPos - pos - prefix.length())); regNum >= 0 && regNum < 32)
+						{
+							std::string replacement = formatFunc(regNum);
+							comment.replace(pos, endPos - pos + 1, replacement);
+							pos += replacement.length();
+						}
+						else
+						{
+							pos = endPos + 1;
+						}
+					}
+					catch (...)
+					{
+						pos = endPos + 1;
+					}
+				}
+			};
+
+			// Replace integer register placeholders {rX}
+			replacePlaceholders("{r", [&](int regNum) {
+				return fmt::format("0x{:08X}", hCPU->gpr[regNum]);
+			});
+
+			// Replace floating point register placeholders {fX}
+			replacePlaceholders("{f", [&](int regNum) {
+				return fmt::format("{}", hCPU->fpr[regNum].fpr);
+			});
+
+			std::string logName = "Breakpoint '" + comment + "'";
+			std::string logContext = fmt::format("Thread: {:08x} LR: 0x{:08x}", MEMPTR<OSThread_t>(coreinit::OSGetCurrentThread()).GetMPTR(), hCPU->spr.LR, cemuLog_advancedPPCLoggingEnabled() ? " Stack Trace:" : "");
+			cemuLog_log(LogType::Force, "[Debugger] {} was executed! {}", logName, logContext);
+			if (cemuLog_advancedPPCLoggingEnabled())
+				DebugLogStackTrace(coreinit::OSGetCurrentThread(), hCPU->gpr[1]);
+			break;
+		}
+		bp = bp->next;
+	}
+
+	// return early if it's only a non-pausing logging breakpoint to prevent a modified debugger state and GUI updates
+	if (!shouldBreak)
+	{
+		uint32 backupIP = debuggerState.debugSession.instructionPointer;
+		debuggerState.debugSession.instructionPointer = hCPU->instructionPointer;
+		debugger_stepInto(hCPU, false);
+		PPCInterpreterSlim_executeInstruction(hCPU);
+		debuggerState.debugSession.instructionPointer = backupIP;
+		return;
+	}
+
+	// handle breakpoints
 	debuggerState.debugSession.isTrapped = true;
-	debuggerState.debugSession.debuggedThreadMPTR = coreinitThread_getCurrentThreadMPTRDepr(hCPU);
+	debuggerState.debugSession.debuggedThreadMPTR = MEMPTR<OSThread_t>(coreinit::OSGetCurrentThread()).GetMPTR();
 	debuggerState.debugSession.instructionPointer = hCPU->instructionPointer;
 	debuggerState.debugSession.hCPU = hCPU;
 	debugger_createPPCStateSnapshot(hCPU);
@@ -512,7 +627,7 @@ void debugger_enterTW(PPCInterpreter_t* hCPU)
 	debuggerState.debugSession.stepInto = false;
 	debuggerState.debugSession.stepOver = false;
 	debuggerState.debugSession.run = false;
-	while (true)
+	while (debuggerState.debugSession.isTrapped)
 	{
 		std::this_thread::sleep_for(std::chrono::milliseconds(1));
 		// check for step commands
@@ -568,6 +683,20 @@ void debugger_shouldBreak(PPCInterpreter_t* hCPU)
 
 void debugger_addParserSymbols(class ExpressionParser& ep)
 {
+	const auto module_count = RPLLoader_GetModuleCount();
+	const auto module_list = RPLLoader_GetModuleList();
+
+	std::vector<double> module_tmp(module_count);
+	for (int i = 0; i < module_count; i++)
+	{
+		const auto module = module_list[i];
+		if (module)
+		{
+			module_tmp[i] = (double)module->regionMappingBase_text.GetMPTR();
+			ep.AddConstant(module->moduleName2, module_tmp[i]);
+		}
+	}
+
 	for (sint32 i = 0; i < 32; i++)
 		ep.AddConstant(fmt::format("r{}", i), debuggerState.debugSession.ppcSnapshot.gpr[i]);
 }
\ No newline at end of file
diff --git a/src/Cafe/HW/Espresso/Debugger/Debugger.h b/src/Cafe/HW/Espresso/Debugger/Debugger.h
index 3bb90bea..c220eb8a 100644
--- a/src/Cafe/HW/Espresso/Debugger/Debugger.h
+++ b/src/Cafe/HW/Espresso/Debugger/Debugger.h
@@ -3,19 +3,18 @@
 #include <set>
 #include "Cafe/HW/Espresso/PPCState.h"
 
-//#define DEBUGGER_BP_TYPE_NORMAL			(1<<0) // normal breakpoint
-//#define DEBUGGER_BP_TYPE_ONE_SHOT		(1<<1) // normal breakpoint
-//#define DEBUGGER_BP_TYPE_MEMORY_READ	(1<<2) // memory breakpoint
-//#define DEBUGGER_BP_TYPE_MEMORY_WRITE	(1<<3) // memory breakpoint
-
 #define DEBUGGER_BP_T_NORMAL		0 // normal breakpoint
 #define DEBUGGER_BP_T_ONE_SHOT		1 // normal breakpoint, deletes itself after trigger (used for stepping)
 #define DEBUGGER_BP_T_MEMORY_READ	2 // memory breakpoint
 #define DEBUGGER_BP_T_MEMORY_WRITE	3 // memory breakpoint
+#define DEBUGGER_BP_T_LOGGING		4 // logging breakpoint, prints the breakpoint comment and stack trace whenever hit
 
 #define DEBUGGER_BP_T_GDBSTUB		1 // breakpoint created by GDBStub
 #define DEBUGGER_BP_T_DEBUGGER		2 // breakpoint created by Cemu's debugger
 
+#define DEBUGGER_BP_T_GDBSTUB_TW    0x7C010008
+#define DEBUGGER_BP_T_DEBUGGER_TW   0x7C020008
+
 
 struct DebuggerBreakpoint
 {
@@ -44,7 +43,7 @@ struct DebuggerBreakpoint
 
 	bool isExecuteBP() const
 	{
-		return bpType == DEBUGGER_BP_T_NORMAL || bpType == DEBUGGER_BP_T_ONE_SHOT;
+		return bpType == DEBUGGER_BP_T_NORMAL || bpType == DEBUGGER_BP_T_LOGGING || bpType == DEBUGGER_BP_T_ONE_SHOT;
 	}
 
 	bool isMemBP() const
@@ -100,8 +99,9 @@ extern debuggerState_t debuggerState;
 
 // new API
 DebuggerBreakpoint* debugger_getFirstBP(uint32 address);
+void debugger_createCodeBreakpoint(uint32 address, uint8 bpType);
 void debugger_toggleExecuteBreakpoint(uint32 address); // create/remove execute breakpoint
-void debugger_createExecuteBreakpoint(uint32 address);
+void debugger_toggleLoggingBreakpoint(uint32 address); // create/remove logging breakpoint
 void debugger_toggleBreakpoint(uint32 address, bool state, DebuggerBreakpoint* bp);
 
 void debugger_createMemoryBreakpoint(uint32 address, bool onRead, bool onWrite);
@@ -114,6 +114,7 @@ void debugger_updateExecutionBreakpoint(uint32 address, bool forceRestore = fals
 
 void debugger_createPatch(uint32 address, std::span<uint8> patchData);
 bool debugger_hasPatch(uint32 address);
+void debugger_removePatch(uint32 address);
 
 void debugger_forceBreak(); // force breakpoint at the next possible instruction
 bool debugger_isTrapped();
diff --git a/src/Cafe/HW/Espresso/Debugger/GDBBreakpoints.cpp b/src/Cafe/HW/Espresso/Debugger/GDBBreakpoints.cpp
new file mode 100644
index 00000000..675050d3
--- /dev/null
+++ b/src/Cafe/HW/Espresso/Debugger/GDBBreakpoints.cpp
@@ -0,0 +1,304 @@
+#include "GDBBreakpoints.h"
+#include "Debugger.h"
+#include "Cafe/HW/Espresso/Recompiler/PPCRecompiler.h"
+
+#if defined(ARCH_X86_64) && BOOST_OS_LINUX
+#include <sys/ptrace.h>
+#include <sys/wait.h>
+#include <sys/user.h>
+
+DRType _GetDR(pid_t tid, int drIndex)
+{
+	size_t drOffset = offsetof(struct user, u_debugreg) + drIndex * sizeof(user::u_debugreg[0]);
+
+	long v;
+	v = ptrace(PTRACE_PEEKUSER, tid, drOffset, nullptr);
+	if (v == -1)
+		perror("ptrace(PTRACE_PEEKUSER)");
+
+	return (DRType)v;
+}
+
+void _SetDR(pid_t tid, int drIndex, DRType newValue)
+{
+	size_t drOffset = offsetof(struct user, u_debugreg) + drIndex * sizeof(user::u_debugreg[0]);
+
+	long rc = ptrace(PTRACE_POKEUSER, tid, drOffset, newValue);
+	if (rc == -1)
+		perror("ptrace(PTRACE_POKEUSER)");
+}
+
+DRType _ReadDR6()
+{
+	pid_t tid = gettid();
+
+	// linux doesn't let us attach to the current thread / threads in the current thread group
+	// we have to create a child process which then modifies the debug registers and quits
+	pid_t child = fork();
+	if (child == -1)
+	{
+		perror("fork");
+		return 0;
+	}
+
+	if (child == 0)
+	{
+		if (ptrace(PTRACE_ATTACH, tid, nullptr, nullptr))
+		{
+			perror("attach");
+			_exit(0);
+		}
+
+		waitpid(tid, NULL, 0);
+
+		uint64_t dr6 = _GetDR(tid, 6);
+
+		if (ptrace(PTRACE_DETACH, tid, nullptr, nullptr))
+			perror("detach");
+
+		// since the status code only uses the lower 8 bits, we have to discard the rest of DR6
+		// this should be fine though, since the lower 4 bits of DR6 contain all the bp conditions
+		_exit(dr6 & 0xff);
+	}
+
+	// wait for child process
+	int wstatus;
+	waitpid(child, &wstatus, 0);
+
+	return (DRType)WEXITSTATUS(wstatus);
+}
+#endif
+
+GDBServer::ExecutionBreakpoint::ExecutionBreakpoint(MPTR address, BreakpointType type, bool visible, std::string reason)
+	: m_address(address), m_removedAfterInterrupt(false), m_reason(std::move(reason))
+{
+	if (type == BreakpointType::BP_SINGLE)
+	{
+		this->m_pauseThreads = true;
+		this->m_restoreAfterInterrupt = false;
+		this->m_deleteAfterAnyInterrupt = false;
+		this->m_pauseOnNextInterrupt = false;
+		this->m_visible = visible;
+	}
+	else if (type == BreakpointType::BP_PERSISTENT)
+	{
+		this->m_pauseThreads = true;
+		this->m_restoreAfterInterrupt = true;
+		this->m_deleteAfterAnyInterrupt = false;
+		this->m_pauseOnNextInterrupt = false;
+		this->m_visible = visible;
+	}
+	else if (type == BreakpointType::BP_RESTORE_POINT)
+	{
+		this->m_pauseThreads = false;
+		this->m_restoreAfterInterrupt = false;
+		this->m_deleteAfterAnyInterrupt = false;
+		this->m_pauseOnNextInterrupt = false;
+		this->m_visible = false;
+	}
+	else if (type == BreakpointType::BP_STEP_POINT)
+	{
+		this->m_pauseThreads = false;
+		this->m_restoreAfterInterrupt = false;
+		this->m_deleteAfterAnyInterrupt = true;
+		this->m_pauseOnNextInterrupt = true;
+		this->m_visible = false;
+	}
+
+	this->m_origOpCode = memory_readU32(address);
+	memory_writeU32(address, DEBUGGER_BP_T_GDBSTUB_TW);
+	PPCRecompiler_invalidateRange(address, address + 4);
+}
+
+GDBServer::ExecutionBreakpoint::~ExecutionBreakpoint()
+{
+	memory_writeU32(this->m_address, this->m_origOpCode);
+	PPCRecompiler_invalidateRange(this->m_address, this->m_address + 4);
+}
+
+uint32 GDBServer::ExecutionBreakpoint::GetVisibleOpCode() const
+{
+	if (this->m_visible)
+		return memory_readU32(this->m_address);
+	else
+		return this->m_origOpCode;
+}
+
+void GDBServer::ExecutionBreakpoint::RemoveTemporarily()
+{
+	memory_writeU32(this->m_address, this->m_origOpCode);
+	PPCRecompiler_invalidateRange(this->m_address, this->m_address + 4);
+	this->m_restoreAfterInterrupt = true;
+}
+
+void GDBServer::ExecutionBreakpoint::Restore()
+{
+	memory_writeU32(this->m_address, DEBUGGER_BP_T_GDBSTUB_TW);
+	PPCRecompiler_invalidateRange(this->m_address, this->m_address + 4);
+	this->m_restoreAfterInterrupt = false;
+}
+
+namespace coreinit
+{
+#if BOOST_OS_LINUX
+	std::vector<pid_t>& OSGetSchedulerThreadIds();
+#endif
+
+	std::vector<std::thread::native_handle_type>& OSGetSchedulerThreads();
+}
+
+GDBServer::AccessBreakpoint::AccessBreakpoint(MPTR address, AccessPointType type)
+	: m_address(address), m_type(type)
+{
+#if defined(ARCH_X86_64) && BOOST_OS_WINDOWS
+	for (auto& hThreadNH : coreinit::OSGetSchedulerThreads())
+	{
+		HANDLE hThread = (HANDLE)hThreadNH;
+		CONTEXT ctx{};
+		ctx.ContextFlags = CONTEXT_DEBUG_REGISTERS;
+		SuspendThread(hThread);
+		GetThreadContext(hThread, &ctx);
+
+		// use BP 2/3 for gdb stub since cemu's internal debugger uses BP 0/1 already
+		ctx.Dr2 = (DWORD64)memory_getPointerFromVirtualOffset(address);
+		ctx.Dr3 = (DWORD64)memory_getPointerFromVirtualOffset(address);
+		// breakpoint 2
+		SetBits(ctx.Dr7, 4, 1, 1);	// breakpoint #3 enabled: true
+		SetBits(ctx.Dr7, 24, 2, 1); // breakpoint #3 condition: 1 (write)
+		SetBits(ctx.Dr7, 26, 2, 3); // breakpoint #3 length: 3 (4 bytes)
+		// breakpoint 3
+		SetBits(ctx.Dr7, 6, 1, 1);	// breakpoint #4 enabled: true
+		SetBits(ctx.Dr7, 28, 2, 3); // breakpoint #4 condition: 3 (read & write)
+		SetBits(ctx.Dr7, 30, 2, 3); // breakpoint #4 length: 3 (4 bytes)
+
+		SetThreadContext(hThread, &ctx);
+		ResumeThread(hThread);
+	}
+#elif defined(ARCH_X86_64) && BOOST_OS_LINUX
+	// linux doesn't let us attach to threads which are in the same thread group as our current thread
+	// we have to create a child process which then modifies the debug registers and quits
+	pid_t child = fork();
+	if (child == -1)
+	{
+		perror("fork");
+		return;
+	}
+
+	if (child == 0)
+	{
+		for (pid_t tid : coreinit::OSGetSchedulerThreadIds())
+		{
+			long rc = ptrace(PTRACE_ATTACH, tid, nullptr, nullptr);
+			if (rc == -1)
+				perror("ptrace(PTRACE_ATTACH)");
+
+			waitpid(tid, nullptr, 0);
+
+			DRType dr7 = _GetDR(tid, 7);
+			// use BP 2/3 for gdb stub since cemu's internal debugger uses BP 0/1 already
+			DRType dr2 = (uint64)memory_getPointerFromVirtualOffset(address);
+			DRType dr3 = (uint64)memory_getPointerFromVirtualOffset(address);
+			// breakpoint 2
+			SetBits(dr7, 4, 1, 1);  // breakpoint #3 enabled: true
+			SetBits(dr7, 24, 2, 1); // breakpoint #3 condition: 1 (write)
+			SetBits(dr7, 26, 2, 3); // breakpoint #3 length: 3 (4 bytes)
+			// breakpoint 3
+			SetBits(dr7, 6, 1, 1);  // breakpoint #4 enabled: true
+			SetBits(dr7, 28, 2, 3); // breakpoint #4 condition: 3 (read & write)
+			SetBits(dr7, 30, 2, 3); // breakpoint #4 length: 3 (4 bytes)
+
+			_SetDR(tid, 2, dr2);
+			_SetDR(tid, 3, dr3);
+			_SetDR(tid, 7, dr7);
+
+			rc = ptrace(PTRACE_DETACH, tid, nullptr, nullptr);
+			if (rc == -1)
+				perror("ptrace(PTRACE_DETACH)");
+		}
+
+		// exit child process
+		_exit(0);
+	}
+
+	// wait for child process
+	waitpid(child, nullptr, 0);
+#else
+	cemuLog_log(LogType::Force, "Debugger read/write breakpoints are not supported on non-x86 CPUs yet.");
+#endif
+}
+
+GDBServer::AccessBreakpoint::~AccessBreakpoint()
+{
+#if defined(ARCH_X86_64) && BOOST_OS_WINDOWS
+	for (auto& hThreadNH : coreinit::OSGetSchedulerThreads())
+	{
+		HANDLE hThread = (HANDLE)hThreadNH;
+		CONTEXT ctx{};
+		ctx.ContextFlags = CONTEXT_DEBUG_REGISTERS;
+		SuspendThread(hThread);
+		GetThreadContext(hThread, &ctx);
+
+		// reset BP 2/3 to zero
+		ctx.Dr2 = (DWORD64)0;
+		ctx.Dr3 = (DWORD64)0;
+		// breakpoint 2
+		SetBits(ctx.Dr7, 4, 1, 0);
+		SetBits(ctx.Dr7, 24, 2, 0);
+		SetBits(ctx.Dr7, 26, 2, 0);
+		// breakpoint 3
+		SetBits(ctx.Dr7, 6, 1, 0);
+		SetBits(ctx.Dr7, 28, 2, 0);
+		SetBits(ctx.Dr7, 30, 2, 0);
+		SetThreadContext(hThread, &ctx);
+		ResumeThread(hThread);
+	}
+#elif defined(ARCH_X86_64) && BOOST_OS_LINUX
+	// linux doesn't let us attach to threads which are in the same thread group as our current thread
+	// we have to create a child process which then modifies the debug registers and quits
+	pid_t child = fork();
+	if (child == -1)
+	{
+		perror("fork");
+		return;
+	}
+
+	if (child == 0)
+	{
+		for (pid_t tid : coreinit::OSGetSchedulerThreadIds())
+		{
+			long rc = ptrace(PTRACE_ATTACH, tid, nullptr, nullptr);
+			if (rc == -1)
+				perror("ptrace(PTRACE_ATTACH)");
+
+			waitpid(tid, nullptr, 0);
+
+			DRType dr7 = _GetDR(tid, 7);
+			// reset BP 2/3 to zero
+			DRType dr2 = 0;
+			DRType dr3 = 0;
+			// breakpoint 2
+			SetBits(dr7, 4, 1, 0);
+			SetBits(dr7, 24, 2, 0);
+			SetBits(dr7, 26, 2, 0);
+			// breakpoint 3
+			SetBits(dr7, 6, 1, 0);
+			SetBits(dr7, 28, 2, 0);
+			SetBits(dr7, 30, 2, 0);
+
+			_SetDR(tid, 2, dr2);
+			_SetDR(tid, 3, dr3);
+			_SetDR(tid, 7, dr7);
+
+			rc = ptrace(PTRACE_DETACH, tid, nullptr, nullptr);
+			if (rc == -1)
+				perror("ptrace(PTRACE_DETACH)");
+		}
+
+		// exit child process
+		_exit(0);
+	}
+
+	// wait for child process
+	waitpid(child, nullptr, 0);
+#endif
+}
diff --git a/src/Cafe/HW/Espresso/Debugger/GDBBreakpoints.h b/src/Cafe/HW/Espresso/Debugger/GDBBreakpoints.h
new file mode 100644
index 00000000..f94365c2
--- /dev/null
+++ b/src/Cafe/HW/Espresso/Debugger/GDBBreakpoints.h
@@ -0,0 +1,106 @@
+#pragma once
+#include "GDBStub.h"
+#include <utility>
+
+#if defined(ARCH_X86_64) && BOOST_OS_LINUX
+#include <sys/types.h>
+
+// helpers for accessing debug register
+typedef unsigned long DRType;
+
+DRType _GetDR(pid_t tid, int drIndex);
+void _SetDR(pid_t tid, int drIndex, DRType newValue);
+DRType _ReadDR6();
+#endif
+
+enum class BreakpointType
+{
+	BP_SINGLE,
+	BP_PERSISTENT,
+	BP_RESTORE_POINT,
+	BP_STEP_POINT
+};
+
+class GDBServer::ExecutionBreakpoint {
+public:
+	ExecutionBreakpoint(MPTR address, BreakpointType type, bool visible, std::string reason);
+	~ExecutionBreakpoint();
+
+	[[nodiscard]] uint32 GetVisibleOpCode() const;
+	[[nodiscard]] bool ShouldBreakThreads() const
+	{
+		return this->m_pauseThreads;
+	};
+	[[nodiscard]] bool ShouldBreakThreadsOnNextInterrupt()
+	{
+		bool shouldPause = this->m_pauseOnNextInterrupt;
+		this->m_pauseOnNextInterrupt = false;
+		return shouldPause;
+	};
+	[[nodiscard]] bool IsPersistent() const
+	{
+		return this->m_restoreAfterInterrupt;
+	};
+	[[nodiscard]] bool IsSkipBreakpoint() const
+	{
+		return this->m_deleteAfterAnyInterrupt;
+	};
+	[[nodiscard]] bool IsRemoved() const
+	{
+		return this->m_removedAfterInterrupt;
+	};
+	[[nodiscard]] std::string GetReason() const
+	{
+		return m_reason;
+	};
+
+	void RemoveTemporarily();
+	void Restore();
+	void PauseOnNextInterrupt()
+	{
+		this->m_pauseOnNextInterrupt = true;
+	};
+
+	void WriteNewOpCode(uint32 newOpCode)
+	{
+		this->m_origOpCode = newOpCode;
+	};
+
+private:
+	const MPTR m_address;
+	std::string m_reason;
+	uint32 m_origOpCode;
+	bool m_visible;
+	bool m_pauseThreads;
+	// type
+	bool m_pauseOnNextInterrupt;
+	bool m_restoreAfterInterrupt;
+	bool m_deleteAfterAnyInterrupt;
+	bool m_removedAfterInterrupt;
+};
+
+enum class AccessPointType
+{
+	BP_WRITE = 2,
+	BP_READ = 3,
+	BP_BOTH = 4
+};
+
+class GDBServer::AccessBreakpoint {
+public:
+	AccessBreakpoint(MPTR address, AccessPointType type);
+	~AccessBreakpoint();
+
+	MPTR GetAddress() const
+	{
+		return m_address;
+	};
+	AccessPointType GetType() const
+	{
+		return m_type;
+	};
+
+private:
+	const MPTR m_address;
+	const AccessPointType m_type;
+};
diff --git a/src/Cafe/HW/Espresso/Debugger/GDBStub.cpp b/src/Cafe/HW/Espresso/Debugger/GDBStub.cpp
new file mode 100644
index 00000000..e54fae1b
--- /dev/null
+++ b/src/Cafe/HW/Espresso/Debugger/GDBStub.cpp
@@ -0,0 +1,988 @@
+#include "GDBStub.h"
+#include "Debugger.h"
+#include "Cafe/HW/Espresso/Recompiler/PPCRecompiler.h"
+#include "GDBBreakpoints.h"
+#include "util/helpers/helpers.h"
+#include "util/ThreadPool/ThreadPool.h"
+#include "Cafe/OS/RPL/rpl.h"
+#include "Cafe/OS/RPL/rpl_structs.h"
+#include "Cafe/OS/libs/coreinit/coreinit_Scheduler.h"
+#include "Cafe/OS/libs/coreinit/coreinit_Thread.h"
+#include "Cafe/HW/Espresso/Interpreter/PPCInterpreterInternal.h"
+#include "Cafe/HW/Espresso/EspressoISA.h"
+#include "Common/socket.h"
+
+#define GET_THREAD_ID(threadPtr) memory_getVirtualOffsetFromPointer(threadPtr)
+#define GET_THREAD_BY_ID(threadId) (OSThread_t*)memory_getPointerFromPhysicalOffset(threadId)
+
+static std::vector<MPTR> findNextInstruction(MPTR currAddress, uint32 lr, uint32 ctr)
+{
+	using namespace Espresso;
+
+	uint32 nextInstr = memory_readU32(currAddress);
+	if (GetPrimaryOpcode(nextInstr) == PrimaryOpcode::B)
+	{
+		uint32 LI;
+		bool AA, LK;
+		decodeOp_B(nextInstr, LI, AA, LK);
+		if (!AA)
+			LI += currAddress;
+		return {LI};
+	}
+	if (GetPrimaryOpcode(nextInstr) == PrimaryOpcode::BC)
+	{
+		uint32 BD, BI;
+		BOField BO{};
+		bool AA, LK;
+		decodeOp_BC(nextInstr, BD, BO, BI, AA, LK);
+		if (!LK)
+			BD += currAddress;
+		return {currAddress + 4, BD};
+	}
+	if (GetPrimaryOpcode(nextInstr) == PrimaryOpcode::GROUP_19 && GetGroup19Opcode(nextInstr) == Opcode19::BCLR)
+	{
+		return {currAddress + 4, lr};
+	}
+	if (GetPrimaryOpcode(nextInstr) == PrimaryOpcode::GROUP_19 && GetGroup19Opcode(nextInstr) == Opcode19::BCCTR)
+	{
+		return {currAddress + 4, ctr};
+	}
+	return {currAddress + 4};
+}
+
+template<typename F>
+static void selectThread(sint64 selectorId, F&& action_for_thread)
+{
+	__OSLockScheduler();
+	cemu_assert_debug(activeThreadCount != 0);
+
+	if (selectorId == -1)
+	{
+		for (sint32 i = 0; i < activeThreadCount; i++)
+		{
+			action_for_thread(GET_THREAD_BY_ID(activeThread[i]));
+		}
+	}
+	else if (selectorId == 0)
+	{
+		// Use first thread if attempted to be stopped
+		// todo: would this work better if it used main?
+		action_for_thread(coreinit::OSGetDefaultThread(1));
+	}
+	else if (selectorId > 0)
+	{
+		for (sint32 i = 0; i < activeThreadCount; i++)
+		{
+			auto* thread = GET_THREAD_BY_ID(activeThread[i]);
+			if (GET_THREAD_ID(thread) == selectorId)
+			{
+				action_for_thread(thread);
+				break;
+			}
+		}
+	}
+	__OSUnlockScheduler();
+}
+
+template<typename F>
+static void selectAndBreakThread(sint64 selectorId, F&& action_for_thread)
+{
+	__OSLockScheduler();
+	cemu_assert_debug(activeThreadCount != 0);
+
+	std::vector<OSThread_t*> pausedThreads;
+	if (selectorId == -1)
+	{
+		for (sint32 i = 0; i < activeThreadCount; i++)
+		{
+			coreinit::__OSSuspendThreadNolock(GET_THREAD_BY_ID(activeThread[i]));
+			pausedThreads.emplace_back(GET_THREAD_BY_ID(activeThread[i]));
+		}
+	}
+	else if (selectorId == 0)
+	{
+		// Use first thread if attempted to be stopped
+		OSThread_t* thread = GET_THREAD_BY_ID(activeThread[0]);
+		for (sint32 i = 0; i < activeThreadCount; i++)
+		{
+			if (GET_THREAD_ID(GET_THREAD_BY_ID(activeThread[i])) < GET_THREAD_ID(thread))
+			{
+				thread = GET_THREAD_BY_ID(activeThread[i]);
+			}
+		}
+		coreinit::__OSSuspendThreadNolock(thread);
+		pausedThreads.emplace_back(thread);
+	}
+	else if (selectorId > 0)
+	{
+		for (sint32 i = 0; i < activeThreadCount; i++)
+		{
+			auto* thread = GET_THREAD_BY_ID(activeThread[i]);
+			if (GET_THREAD_ID(thread) == selectorId)
+			{
+				coreinit::__OSSuspendThreadNolock(thread);
+				pausedThreads.emplace_back(thread);
+				break;
+			}
+		}
+	}
+	__OSUnlockScheduler();
+
+	for (OSThread_t* thread : pausedThreads)
+	{
+		while (coreinit::OSIsThreadRunning(thread))
+			std::this_thread::sleep_for(std::chrono::milliseconds(50));
+		action_for_thread(thread);
+	}
+}
+
+static void selectAndResumeThread(sint64 selectorId)
+{
+	__OSLockScheduler();
+	cemu_assert_debug(activeThreadCount != 0);
+
+	if (selectorId == -1)
+	{
+		for (sint32 i = 0; i < activeThreadCount; i++)
+		{
+			coreinit::__OSResumeThreadInternal(GET_THREAD_BY_ID(activeThread[i]), 4);
+		}
+	}
+	else if (selectorId == 0)
+	{
+		// Use first thread if attempted to be stopped
+		coreinit::__OSResumeThreadInternal(coreinit::OSGetDefaultThread(1), 1);
+	}
+	else if (selectorId > 0)
+	{
+		for (sint32 i = 0; i < activeThreadCount; i++)
+		{
+			auto* thread = GET_THREAD_BY_ID(activeThread[i]);
+			if (GET_THREAD_ID(thread) == selectorId)
+			{
+				coreinit::__OSResumeThreadInternal(thread, 1);
+				break;
+			}
+		}
+	}
+	__OSUnlockScheduler();
+}
+
+static void waitForBrokenThreads(std::unique_ptr<GDBServer::CommandContext> context, std::string_view reason)
+{
+	// This should pause all threads except trapped thread
+	// It should however wait for the trapped thread
+	// The trapped thread should be paused by the trap word instruction handler (aka the running thread)
+	std::vector<OSThread_t*> threadsList;
+	__OSLockScheduler();
+	for (sint32 i = 0; i < activeThreadCount; i++)
+	{
+		threadsList.emplace_back(GET_THREAD_BY_ID(activeThread[i]));
+	}
+	__OSUnlockScheduler();
+
+	for (OSThread_t* thread : threadsList)
+	{
+		while (coreinit::OSIsThreadRunning(thread))
+			std::this_thread::sleep_for(std::chrono::milliseconds(50));
+	}
+
+	context->QueueResponse(reason);
+}
+
+static void breakThreads(sint64 trappedThread)
+{
+	__OSLockScheduler();
+	cemu_assert_debug(activeThreadCount != 0);
+
+	// First, break other threads
+	OSThread_t* mainThread = nullptr;
+	for (sint32 i = 0; i < activeThreadCount; i++)
+	{
+		if (GET_THREAD_ID(GET_THREAD_BY_ID(activeThread[i])) == trappedThread)
+		{
+			mainThread = GET_THREAD_BY_ID(activeThread[i]);
+		}
+		else
+		{
+			coreinit::__OSSuspendThreadNolock(GET_THREAD_BY_ID(activeThread[i]));
+		}
+	}
+
+	// Second, break trapped thread itself which should also pause execution of this handler
+	// This will temporarily lift the scheduler lock until it's resumed from its suspension
+	coreinit::__OSSuspendThreadNolock(mainThread);
+
+	__OSUnlockScheduler();
+}
+
+std::unique_ptr<GDBServer> g_gdbstub;
+
+GDBServer::GDBServer(uint16 port)
+	: m_port(port)
+{
+#if BOOST_OS_WINDOWS
+	WSADATA wsa;
+	WSAStartup(MAKEWORD(2, 2), &wsa);
+#endif
+}
+
+GDBServer::~GDBServer()
+{
+	if (m_client_socket != INVALID_SOCKET)
+	{
+		// close socket from other thread to forcefully stop accept() call
+		closesocket(m_client_socket);
+		m_client_socket = INVALID_SOCKET;
+	}
+
+	if (m_server_socket != INVALID_SOCKET)
+	{
+		closesocket(m_server_socket);
+	}
+#if BOOST_OS_WINDOWS
+	WSACleanup();
+#endif
+
+	m_stopRequested = false;
+	m_thread.join();
+}
+
+bool GDBServer::Initialize()
+{
+	cemuLog_createLogFile(false);
+
+	if (m_server_socket = socket(PF_INET, SOCK_STREAM, 0); m_server_socket == SOCKET_ERROR)
+		return false;
+
+	int reuseEnabled = TRUE;
+	if (setsockopt(m_server_socket, SOL_SOCKET, SO_REUSEADDR, (char*)&reuseEnabled, sizeof(reuseEnabled)) == SOCKET_ERROR)
+	{
+		closesocket(m_server_socket);
+		m_server_socket = INVALID_SOCKET;
+		return false;
+	}
+
+	int nodelayEnabled = TRUE;
+	if (setsockopt(m_server_socket, IPPROTO_TCP, TCP_NODELAY, (char*)&nodelayEnabled, sizeof(nodelayEnabled)) == SOCKET_ERROR)
+	{
+		closesocket(m_server_socket);
+		m_server_socket = INVALID_SOCKET;
+		return false;
+	}
+
+	memset(&m_server_addr, 0, sizeof(m_server_addr));
+	m_server_addr.sin_family = AF_INET;
+	m_server_addr.sin_addr.s_addr = htonl(INADDR_ANY);
+	m_server_addr.sin_port = htons(m_port);
+
+	if (bind(m_server_socket, (sockaddr*)&m_server_addr, sizeof(m_server_addr)) == SOCKET_ERROR)
+	{
+		closesocket(m_server_socket);
+		m_server_socket = INVALID_SOCKET;
+		return false;
+	}
+
+	if (listen(m_server_socket, s_maxGDBClients) == SOCKET_ERROR)
+	{
+		closesocket(m_server_socket);
+		m_server_socket = INVALID_SOCKET;
+		return false;
+	}
+
+	m_thread = std::thread(std::bind(&GDBServer::ThreadFunc, this));
+
+	return true;
+}
+
+void GDBServer::ThreadFunc()
+{
+	SetThreadName("GDBServer");
+
+	while (!m_stopRequested)
+	{
+		if (!m_client_connected)
+		{
+			cemuLog_logDebug(LogType::Force, "[GDBStub] Waiting for client to connect on port {}...", m_port);
+			socklen_t client_addr_size = sizeof(m_client_addr);
+			m_client_socket = accept(m_server_socket, (struct sockaddr*)&m_client_addr, &client_addr_size);
+			m_client_connected = m_client_socket != SOCKET_ERROR;
+		}
+		else
+		{
+			auto receiveMessage = [&](char* buffer, const int32_t length) -> bool {
+				if (recv(m_client_socket, buffer, length, 0) != SOCKET_ERROR)
+					return false;
+				return true;
+			};
+
+			auto readChar = [&]() -> char {
+				char ret = 0;
+				recv(m_client_socket, &ret, 1, 0);
+				return ret;
+			};
+
+			char packetPrefix = readChar();
+
+			switch (packetPrefix)
+			{
+			case '+':
+			case '-':
+				break;
+			case '\x03':
+			{
+				cemuLog_logDebug(LogType::Force, "[GDBStub] Received interrupt (pressed CTRL+C?) from client!");
+				selectAndBreakThread(-1, [](OSThread_t* thread) {
+				});
+				auto thread_status = fmt::format("T05thread:{:08X};", GET_THREAD_ID(coreinit::OSGetDefaultThread(1)));
+				if (this->m_resumed_context)
+				{
+					this->m_resumed_context->QueueResponse(thread_status);
+					this->m_resumed_context.reset();
+				}
+				else
+				{
+					auto response_full = fmt::format("+${}#{:02x}", thread_status, CommandContext::CalculateChecksum(thread_status));
+					send(m_client_socket, response_full.c_str(), (int)response_full.size(), 0);
+				}
+				break;
+			}
+			case '$':
+			{
+				std::string message;
+				uint8 checkedSum = 0;
+				for (uint32_t i = 1;; i++)
+				{
+					char c = readChar();
+					if (c == '#')
+						break;
+					checkedSum += static_cast<uint8>(c);
+					message.push_back(c);
+
+					if (i >= s_maxPacketSize)
+						cemuLog_logDebug(LogType::Force, "[GDBStub] Received too big of a buffer: {}", message);
+				}
+				char checkSumStr[2];
+				receiveMessage(checkSumStr, 2);
+				uint32_t checkSum = std::stoi(std::string(checkSumStr, sizeof(checkSumStr)), nullptr, 16);
+				assert((checkedSum & 0xFF) == checkSum);
+
+				HandleCommand(message);
+				break;
+			}
+			default:
+				// cemuLog_logDebug(LogType::Force, "[GDBStub] Unknown packet start: {}", packetPrefix);
+				break;
+			}
+		}
+	}
+
+	if (m_client_socket != INVALID_SOCKET)
+		closesocket(m_client_socket);
+}
+
+void GDBServer::HandleCommand(const std::string& command_str)
+{
+	auto context = std::make_unique<CommandContext>(this, command_str);
+
+	if (context->IsValid())
+	{
+		// cemuLog_logDebug(LogType::Force, "[GDBStub] Extracted Command {}", fmt::join(context->GetArgs(), ","));
+	}
+
+	switch (context->GetType())
+	{
+	// Extended commands
+	case CMDType::QUERY_GET:
+	case CMDType::QUERY_SET:
+		return HandleQuery(context);
+	case CMDType::VCONT:
+		return HandleVCont(context);
+	// Regular commands
+	case CMDType::IS_THREAD_RUNNING:
+		return CMDIsThreadActive(context);
+	case CMDType::SET_ACTIVE_THREAD:
+		return CMDSetActiveThread(context);
+	case CMDType::ACTIVE_THREAD_STATUS:
+		return CMDGetThreadStatus(context);
+	case CMDType::CONTINUE:
+		return CMDContinue(context);
+	case CMDType::ACTIVE_THREAD_STEP:
+		break;
+	case CMDType::REGISTER_READ:
+		return CMDReadRegister(context);
+	case CMDType::REGISTER_SET:
+		return CMDWriteRegister(context);
+	case CMDType::REGISTERS_READ:
+		return CMDReadRegisters(context);
+	case CMDType::REGISTERS_WRITE:
+		return CMDWriteRegisters(context);
+	case CMDType::MEMORY_READ:
+		return CMDReadMemory(context);
+	case CMDType::MEMORY_WRITE:
+		return CMDWriteMemory(context);
+	case CMDType::BREAKPOINT_SET:
+		return CMDInsertBreakpoint(context);
+	case CMDType::BREAKPOINT_REMOVE:
+		return CMDDeleteBreakpoint(context);
+	case CMDType::INVALID:
+	default:
+		return CMDNotFound(context);
+	}
+
+	CMDNotFound(context);
+}
+
+void GDBServer::HandleQuery(std::unique_ptr<CommandContext>& context) const
+{
+	if (!context->IsValid())
+		return context->QueueResponse(RESPONSE_EMPTY);
+
+	const auto& query_cmd = context->GetArgs()[0];
+	const auto& query_args = context->GetArgs().begin() + 1;
+
+	if (query_cmd == "qSupported")
+	{
+		context->QueueResponse(s_supportedFeatures);
+	}
+	else if (query_cmd == "qAttached")
+	{
+		context->QueueResponse("1");
+	}
+	else if (query_cmd == "qRcmd")
+	{
+	}
+	else if (query_cmd == "qC")
+	{
+		context->QueueResponse("QC");
+		context->QueueResponse(std::to_string(m_activeThreadContinueSelector));
+	}
+	else if (query_cmd == "qOffsets")
+	{
+		const auto module_count = RPLLoader_GetModuleCount();
+		const auto module_list = RPLLoader_GetModuleList();
+		for (sint32 i = 0; i < module_count; i++)
+		{
+			const RPLModule* rpl = module_list[i];
+			if (rpl->entrypoint == m_entry_point)
+			{
+				context->QueueResponse(fmt::format("TextSeg={:08X};DataSeg={:08X}", rpl->regionMappingBase_text.GetMPTR(), rpl->regionMappingBase_data));
+			}
+		}
+	}
+	else if (query_cmd == "qfThreadInfo")
+	{
+		std::vector<std::string> threadIds;
+		selectThread(-1, [&threadIds](OSThread_t* thread) {
+			threadIds.emplace_back(fmt::format("{:08X}", memory_getVirtualOffsetFromPointer(thread)));
+		});
+		context->QueueResponse(fmt::format("m{}", fmt::join(threadIds, ",")));
+	}
+	else if (query_cmd == "qsThreadInfo")
+	{
+		context->QueueResponse("l");
+	}
+	else if (query_cmd == "qXfer")
+	{
+		auto& type = query_args[0];
+
+		if (type == "features")
+		{
+			auto& annex = query_args[1];
+			sint64 read_offset = std::stoul(query_args[2], nullptr, 16);
+			sint64 read_length = std::stoul(query_args[3], nullptr, 16);
+			if (annex == "target.xml")
+			{
+				if (read_offset >= GDBTargetXML.size())
+					context->QueueResponse("l");
+				else
+				{
+					auto paginated_str = GDBTargetXML.substr(read_offset, read_length);
+					context->QueueResponse((paginated_str.size() == read_length) ? "m" : "l");
+					context->QueueResponse(paginated_str);
+				}
+			}
+			else
+				cemuLog_logDebug(LogType::Force, "[GDBStub] qXfer:features:read:{} isn't a known feature document", annex);
+		}
+		else if (type == "threads")
+		{
+			sint64 read_offset = std::stoul(query_args[1], nullptr, 16);
+			sint64 read_length = std::stoul(query_args[2], nullptr, 16);
+
+			std::string threads_res;
+			threads_res += R"(<?xml version="1.0"?>)";
+			threads_res += "<threads>";
+			// note: clion seems to default to the first thread
+			std::map<sint64, std::string> threads_list;
+			selectThread(-1, [&threads_list](OSThread_t* thread) {
+				std::string entry;
+				entry += fmt::format(R"(<thread id="{:x}" core="{}")", GET_THREAD_ID(thread), thread->context.upir.value());
+				if (!thread->threadName.IsNull())
+					entry += fmt::format(R"( name="{}")", CommandContext::EscapeXMLString(thread->threadName.GetPtr()));
+				// todo: could add a human-readable description of the thread here
+				entry += fmt::format("></thread>");
+				threads_list.emplace(GET_THREAD_ID(thread), entry);
+			});
+			for (auto& entry : threads_list)
+			{
+				threads_res += entry.second;
+			}
+			threads_res += "</threads>";
+
+			if (read_offset >= threads_res.size())
+				context->QueueResponse("l");
+			else
+			{
+				auto paginated_str = threads_res.substr(read_offset, read_length);
+				context->QueueResponse((paginated_str.size() == read_length) ? "m" : "l");
+				context->QueueResponse(paginated_str);
+			}
+		}
+		else if (type == "libraries")
+		{
+			sint64 read_offset = std::stoul(query_args[1], nullptr, 16);
+			sint64 read_length = std::stoul(query_args[2], nullptr, 16);
+
+			std::string library_list;
+			library_list += R"(<?xml version="1.0"?>)";
+			library_list += "<library-list>";
+
+			const auto module_count = RPLLoader_GetModuleCount();
+			const auto module_list = RPLLoader_GetModuleList();
+			for (sint32 i = 0; i < module_count; i++)
+			{
+				library_list += fmt::format(R"(<library name="{}"><segment address="{:#x}"/></library>)", CommandContext::EscapeXMLString(module_list[i]->moduleName2), module_list[i]->regionMappingBase_text.GetMPTR());
+			}
+			library_list += "</library-list>";
+
+			if (read_offset >= library_list.size())
+				context->QueueResponse("l");
+			else
+			{
+				auto paginated_str = library_list.substr(read_offset, read_length);
+				context->QueueResponse((paginated_str.size() == read_length) ? "m" : "l");
+				context->QueueResponse(paginated_str);
+			}
+		}
+		else
+		{
+			context->QueueResponse(RESPONSE_EMPTY);
+		}
+	}
+	else
+	{
+		context->QueueResponse(RESPONSE_EMPTY);
+	}
+}
+
+void GDBServer::HandleVCont(std::unique_ptr<CommandContext>& context)
+{
+	if (!context->IsValid())
+	{
+		cemuLog_logDebug(LogType::Force, "[GDBStub] Received unsupported vCont command: {}", context->GetCommand());
+		// cemu_assert_unimplemented();
+		return context->QueueResponse(RESPONSE_EMPTY);
+	}
+
+	const std::string& vcont_cmd = context->GetArgs()[0];
+	if (vcont_cmd == "vCont?")
+		return context->QueueResponse("vCont;c;C;s;S");
+
+	else if (vcont_cmd != "vCont;")
+		return context->QueueResponse(RESPONSE_EMPTY);
+
+	m_resumed_context = std::move(context);
+
+	bool resumedNoThreads = true;
+	for (const auto operation : TokenizeView(m_resumed_context->GetArgs()[1], ';'))
+	{
+		// todo: this might have issues with the signal versions (C/S)
+		// todo: test whether this works with multiple vCont;c:123123;c:123123
+		std::string_view operationType = operation.substr(0, operation.find(':'));
+		sint64 threadSelector = operationType.size() == operation.size() ? -1 : std::stoll(std::string(operation.substr(operationType.size() + 1)), nullptr, 16);
+
+		if (operationType == "c" || operationType.starts_with("C"))
+		{
+			selectAndResumeThread(threadSelector);
+			resumedNoThreads = false;
+		}
+		else if (operationType == "s" || operationType.starts_with("S"))
+		{
+			selectThread(threadSelector, [this](OSThread_t* thread) {
+				auto nextInstructions = findNextInstruction(thread->context.srr0, thread->context.lr, thread->context.ctr);
+				for (MPTR nextInstr : nextInstructions)
+				{
+					auto bpIt = m_patchedInstructions.find(nextInstr);
+					if (bpIt == m_patchedInstructions.end())
+						this->m_patchedInstructions.try_emplace(nextInstr, nextInstr, BreakpointType::BP_STEP_POINT, false, "swbreak:;");
+					else
+						bpIt->second.PauseOnNextInterrupt();
+				}
+			});
+		}
+	}
+
+	if (resumedNoThreads)
+	{
+		selectAndResumeThread(-1);
+		cemuLog_logDebug(LogType::Force, "[GDBStub] Resumed all threads after skip instructions");
+	}
+}
+
+void GDBServer::CMDContinue(std::unique_ptr<CommandContext>& context)
+{
+	m_resumed_context = std::move(context);
+	selectAndResumeThread(m_activeThreadContinueSelector);
+}
+
+void GDBServer::CMDNotFound(std::unique_ptr<CommandContext>& context)
+{
+	return context->QueueResponse(RESPONSE_EMPTY);
+}
+
+void GDBServer::CMDIsThreadActive(std::unique_ptr<CommandContext>& context)
+{
+	sint64 threadSelector = std::stoll(context->GetArgs()[1], nullptr, 16);
+	bool foundThread = false;
+	selectThread(threadSelector, [&foundThread](OSThread_t* thread) {
+		foundThread = true;
+	});
+
+	if (foundThread)
+		return context->QueueResponse(RESPONSE_OK);
+	else
+		return context->QueueResponse(RESPONSE_ERROR);
+}
+
+void GDBServer::CMDSetActiveThread(std::unique_ptr<CommandContext>& context)
+{
+	sint64 threadSelector = std::stoll(context->GetArgs()[2], nullptr, 16);
+	if (threadSelector >= 0)
+	{
+		bool foundThread = false;
+		selectThread(threadSelector, [&foundThread](OSThread_t* thread) {
+			foundThread = true;
+		});
+		if (!foundThread)
+			return context->QueueResponse(RESPONSE_ERROR);
+	}
+	if (context->GetArgs()[1] == "c")
+		m_activeThreadContinueSelector = threadSelector;
+	else
+		m_activeThreadSelector = threadSelector;
+	return context->QueueResponse(RESPONSE_OK);
+}
+
+void GDBServer::CMDGetThreadStatus(std::unique_ptr<CommandContext>& context)
+{
+	selectThread(0, [&context](OSThread_t* thread) {
+		context->QueueResponse(fmt::format("T05thread:{:08X};", memory_getVirtualOffsetFromPointer(thread)));
+	});
+}
+
+void GDBServer::CMDReadRegister(std::unique_ptr<CommandContext>& context) const
+{
+	sint32 reg = std::stoi(context->GetArgs()[1], nullptr, 16);
+	selectThread(m_activeThreadSelector, [reg, &context](OSThread_t* thread) {
+		auto& cpu = thread->context;
+		if (reg >= RegisterID::R0_START && reg <= RegisterID::R31_END)
+		{
+			return context->QueueResponse(fmt::format("{:08X}", CPU_swapEndianU32(cpu.gpr[reg])));
+		}
+		else if (reg >= RegisterID::F0_START && reg <= RegisterID::F31_END)
+		{
+			return context->QueueResponse(fmt::format("{:016X}", cpu.fp_ps0[reg - RegisterID::F0_START].value()));
+		}
+		else if (reg == RegisterID::FPSCR)
+		{
+			return context->QueueResponse(fmt::format("{:08X}", cpu.fpscr.fpscr.value()));
+		}
+		else
+		{
+			switch (reg)
+			{
+			case RegisterID::PC: return context->QueueResponse(fmt::format("{:08X}", cpu.srr0));
+			case RegisterID::MSR: return context->QueueResponse("xxxxxxxx");
+			case RegisterID::CR: return context->QueueResponse(fmt::format("{:08X}", cpu.cr));
+			case RegisterID::LR: return context->QueueResponse(fmt::format("{:08X}", CPU_swapEndianU32(cpu.lr)));
+			case RegisterID::CTR: return context->QueueResponse(fmt::format("{:08X}", cpu.ctr));
+			case RegisterID::XER: return context->QueueResponse(fmt::format("{:08X}", cpu.xer));
+			default: break;
+			}
+		}
+	});
+}
+
+void GDBServer::CMDWriteRegister(std::unique_ptr<CommandContext>& context) const
+{
+	sint32 reg = std::stoi(context->GetArgs()[1], nullptr, 16);
+	uint64 value = std::stoll(context->GetArgs()[2], nullptr, 16);
+	selectThread(m_activeThreadSelector, [reg, value, &context](OSThread_t* thread) {
+		auto& cpu = thread->context;
+		if (reg >= RegisterID::R0_START && reg <= RegisterID::R31_END)
+		{
+			cpu.gpr[reg] = CPU_swapEndianU32(value);
+			return context->QueueResponse(RESPONSE_OK);
+		}
+		else if (reg >= RegisterID::F0_START && reg <= RegisterID::F31_END)
+		{
+			// todo: figure out how to properly write to paired single registers
+			cpu.fp_ps0[reg - RegisterID::F0_START] = uint64be{value};
+			return context->QueueResponse(RESPONSE_OK);
+		}
+		else if (reg == RegisterID::FPSCR)
+		{
+			cpu.fpscr.fpscr = uint32be{(uint32)value};
+			return context->QueueResponse(RESPONSE_OK);
+		}
+		else
+		{
+			switch (reg)
+			{
+			case RegisterID::PC:
+				cpu.srr0 = value;
+				return context->QueueResponse(RESPONSE_OK);
+			case RegisterID::MSR:
+				return context->QueueResponse(RESPONSE_ERROR);
+			case RegisterID::CR:
+				cpu.cr = value;
+				return context->QueueResponse(RESPONSE_OK);
+			case RegisterID::LR:
+				cpu.lr = CPU_swapEndianU32(value);
+				return context->QueueResponse(RESPONSE_OK);
+			case RegisterID::CTR:
+				cpu.ctr = value;
+				return context->QueueResponse(RESPONSE_OK);
+			case RegisterID::XER:
+				cpu.xer = value;
+				return context->QueueResponse(RESPONSE_OK);
+			default:
+				return context->QueueResponse(RESPONSE_ERROR);
+			}
+		}
+	});
+}
+
+void GDBServer::CMDReadRegisters(std::unique_ptr<CommandContext>& context) const
+{
+	selectThread(m_activeThreadSelector, [&context](OSThread_t* thread) {
+		for (uint32& reg : thread->context.gpr)
+		{
+			context->QueueResponse(fmt::format("{:08X}", CPU_swapEndianU32(reg)));
+		}
+	});
+}
+
+void GDBServer::CMDWriteRegisters(std::unique_ptr<CommandContext>& context) const
+{
+	selectThread(m_activeThreadSelector, [&context](OSThread_t* thread) {
+		auto& registers = context->GetArgs()[1];
+		for (uint32 i = 0; i < 32; i++)
+		{
+			thread->context.gpr[i] = CPU_swapEndianU32(std::stoi(registers.substr(i * 2, 2), nullptr, 16));
+		}
+	});
+}
+
+void GDBServer::CMDReadMemory(std::unique_ptr<CommandContext>& context)
+{
+	sint64 addr = std::stoul(context->GetArgs()[1], nullptr, 16);
+	sint64 length = std::stoul(context->GetArgs()[2], nullptr, 16);
+
+	// todo: handle cross-mmu-range memory requests
+	if (!memory_isAddressRangeAccessible(addr, length))
+		return context->QueueResponse(RESPONSE_ERROR);
+
+	std::string memoryRepr;
+	uint8* values = memory_getPointerFromVirtualOffset(addr);
+	for (sint64 i = 0; i < length; i++)
+	{
+		memoryRepr += fmt::format("{:02X}", values[i]);
+	}
+
+	auto patchesRange = m_patchedInstructions.lower_bound(addr);
+	while (patchesRange != m_patchedInstructions.end() && patchesRange->first < (addr + length))
+	{
+		auto replStr = fmt::format("{:02X}", patchesRange->second.GetVisibleOpCode());
+		memoryRepr[(patchesRange->first - addr) * 2] = replStr[0];
+		memoryRepr[(patchesRange->first - addr) * 2 + 1] = replStr[1];
+		patchesRange++;
+	}
+	return context->QueueResponse(memoryRepr);
+}
+
+void GDBServer::CMDWriteMemory(std::unique_ptr<CommandContext>& context)
+{
+	sint64 addr = std::stoul(context->GetArgs()[1], nullptr, 16);
+	sint64 length = std::stoul(context->GetArgs()[2], nullptr, 16);
+	auto source = context->GetArgs()[3];
+
+	// todo: handle cross-mmu-range memory requests
+	if (!memory_isAddressRangeAccessible(addr, length))
+		return context->QueueResponse(RESPONSE_ERROR);
+
+	uint8* values = memory_getPointerFromVirtualOffset(addr);
+	for (sint64 i = 0; i < length; i++)
+	{
+		uint8 hexValue;
+		const std::from_chars_result result = std::from_chars(source.data() + (i * 2), (source.data() + (i * 2) + 2), hexValue, 16);
+		if (result.ec == std::errc::invalid_argument || result.ec == std::errc::result_out_of_range)
+			return context->QueueResponse(RESPONSE_ERROR);
+
+		if (auto it = m_patchedInstructions.find(addr + i); it != m_patchedInstructions.end())
+		{
+			uint32 newOpCode = it->second.GetVisibleOpCode();
+			uint32 byteIndex = 3 - ((addr + i) % 4);			// inverted because of big endian, so address 0 is the highest byte
+			newOpCode &= ~(0xFF << (byteIndex * 8));			// mask out the byte
+			newOpCode |= ((uint32)hexValue << (byteIndex * 8)); // set new byte with OR
+			it->second.WriteNewOpCode(newOpCode);
+		}
+		else
+		{
+			values[i] = hexValue;
+		}
+	}
+	return context->QueueResponse(RESPONSE_OK);
+}
+
+void GDBServer::CMDInsertBreakpoint(std::unique_ptr<CommandContext>& context)
+{
+	auto type = std::stoul(context->GetArgs()[1], nullptr, 16);
+	MPTR addr = static_cast<MPTR>(std::stoul(context->GetArgs()[2], nullptr, 16));
+
+	if (type == 0 || type == 1)
+	{
+		auto bp = this->m_patchedInstructions.find(addr);
+		if (bp != this->m_patchedInstructions.end())
+			this->m_patchedInstructions.erase(bp);
+		this->m_patchedInstructions.try_emplace(addr, addr, BreakpointType::BP_PERSISTENT, type == 0, type == 0 ? "swbreak:;" : "hwbreak:;");
+	}
+	else if (type == 2 || type == 3 || type == 4)
+	{
+		if (this->m_watch_point)
+			return context->QueueResponse(RESPONSE_ERROR);
+
+		this->m_watch_point = std::make_unique<AccessBreakpoint>(addr, (AccessPointType)type);
+	}
+
+	return context->QueueResponse(RESPONSE_OK);
+}
+
+void GDBServer::CMDDeleteBreakpoint(std::unique_ptr<CommandContext>& context)
+{
+	auto type = std::stoul(context->GetArgs()[1], nullptr, 16);
+	MPTR addr = static_cast<MPTR>(std::stoul(context->GetArgs()[2], nullptr, 16));
+
+	if (type == 0 || type == 1)
+	{
+		auto bp = this->m_patchedInstructions.find(addr);
+		if (bp == this->m_patchedInstructions.end() || !bp->second.ShouldBreakThreads())
+			return context->QueueResponse(RESPONSE_ERROR);
+		else
+			this->m_patchedInstructions.erase(bp);
+	}
+	else if (type == 2 || type == 3 || type == 4)
+	{
+		if (!this->m_watch_point || this->m_watch_point->GetAddress() != addr)
+			return context->QueueResponse(RESPONSE_ERROR);
+
+		this->m_watch_point.reset();
+	}
+
+	return context->QueueResponse(RESPONSE_OK);
+}
+
+// Internal functions for control
+void GDBServer::HandleTrapInstruction(PPCInterpreter_t* hCPU)
+{
+	// First, restore any removed breakpoints
+	for (auto& bp : m_patchedInstructions)
+	{
+		if (bp.second.IsRemoved())
+			bp.second.Restore();
+	}
+
+	auto patchedBP = m_patchedInstructions.find(hCPU->instructionPointer);
+	if (patchedBP == m_patchedInstructions.end())
+		return cemu_assert_suspicious();
+
+	// Secondly, delete one-shot breakpoints but also temporarily delete patched instruction to run original instruction
+	OSThread_t* currThread = coreinit::OSGetCurrentThread();
+	std::string pauseReason = fmt::format("T05thread:{:08X};core:{:02X};{}", GET_THREAD_ID(currThread), PPCInterpreter_getCoreIndex(hCPU), patchedBP->second.GetReason());
+	bool pauseThreads = patchedBP->second.ShouldBreakThreads() || patchedBP->second.ShouldBreakThreadsOnNextInterrupt();
+	if (patchedBP->second.IsPersistent())
+	{
+		// Insert new restore breakpoints at next possible instructions which restores breakpoints but won't pause the CPU
+		std::vector<MPTR> nextInstructions = findNextInstruction(hCPU->instructionPointer, hCPU->spr.LR, hCPU->spr.CTR);
+		for (MPTR nextInstr : nextInstructions)
+		{
+			if (!m_patchedInstructions.contains(nextInstr))
+				this->m_patchedInstructions.try_emplace(nextInstr, nextInstr, BreakpointType::BP_STEP_POINT, false, "");
+		}
+		patchedBP->second.RemoveTemporarily();
+	}
+	else
+	{
+		m_patchedInstructions.erase(patchedBP);
+	}
+
+	// Thirdly, delete any instructions that were generated by a skip instruction
+	for (auto it = m_patchedInstructions.cbegin(), next_it = it; it != m_patchedInstructions.cend(); it = next_it)
+	{
+		++next_it;
+		if (it->second.IsSkipBreakpoint())
+		{
+			m_patchedInstructions.erase(it);
+		}
+	}
+
+	// Fourthly, the stub can insert breakpoints that are just meant to restore patched instructions, in which case we just want to continue
+	if (pauseThreads)
+	{
+		cemuLog_logDebug(LogType::Force, "[GDBStub] Got trapped by a breakpoint!");
+		if (m_resumed_context)
+		{
+			// Spin up thread to signal when another GDB stub trap is found
+			ThreadPool::FireAndForget(&waitForBrokenThreads, std::move(m_resumed_context), pauseReason);
+		}
+
+		breakThreads(GET_THREAD_ID(coreinit::OSGetCurrentThread()));
+		cemuLog_logDebug(LogType::Force, "[GDBStub] Resumed from a breakpoint!");
+	}
+}
+
+void GDBServer::HandleAccessException(uint64 dr6)
+{
+	bool triggeredWrite = GetBits(dr6, 2, 1);
+	bool triggeredReadWrite = GetBits(dr6, 3, 1);
+
+	std::string response;
+	if (m_watch_point->GetType() == AccessPointType::BP_WRITE && triggeredWrite)
+		response = fmt::format("watch:{:08X};", m_watch_point->GetAddress());
+	else if (m_watch_point->GetType() == AccessPointType::BP_READ && triggeredReadWrite && !triggeredWrite)
+		response = fmt::format("rwatch:{:08X};", m_watch_point->GetAddress());
+	else if (m_watch_point->GetType() == AccessPointType::BP_BOTH && triggeredReadWrite)
+		response = fmt::format("awatch:{:08X};", m_watch_point->GetAddress());
+
+	if (!response.empty())
+	{
+		PPCInterpreter_t* hCPU = PPCInterpreter_getCurrentInstance();
+		cemuLog_logDebug(LogType::Force, "Received matching breakpoint exception: {}", response);
+		auto nextInstructions = findNextInstruction(hCPU->instructionPointer, hCPU->spr.LR, hCPU->spr.CTR);
+		for (MPTR nextInstr : nextInstructions)
+		{
+			auto bpIt = m_patchedInstructions.find(nextInstr);
+			if (bpIt == m_patchedInstructions.end())
+				this->m_patchedInstructions.try_emplace(nextInstr, nextInstr, BreakpointType::BP_STEP_POINT, false, response);
+			else
+				bpIt->second.PauseOnNextInterrupt();
+		}
+	}
+}
+
+void GDBServer::HandleEntryStop(uint32 entryAddress)
+{
+	this->m_patchedInstructions.try_emplace(entryAddress, entryAddress, BreakpointType::BP_SINGLE, false, "");
+	m_entry_point = entryAddress;
+}
\ No newline at end of file
diff --git a/src/Cafe/HW/Espresso/Debugger/GDBStub.h b/src/Cafe/HW/Espresso/Debugger/GDBStub.h
new file mode 100644
index 00000000..e198604d
--- /dev/null
+++ b/src/Cafe/HW/Espresso/Debugger/GDBStub.h
@@ -0,0 +1,316 @@
+#pragma once
+
+#include "Common/precompiled.h"
+#include "Common/socket.h"
+#include "Cafe/OS/libs/coreinit/coreinit_Thread.h"
+
+#include <numeric>
+
+class GDBServer {
+public:
+	explicit GDBServer(uint16 port);
+	~GDBServer();
+
+	bool Initialize();
+	bool IsConnected()
+	{
+		return m_client_connected;
+	}
+
+	void HandleEntryStop(uint32 entryAddress);
+	void HandleTrapInstruction(PPCInterpreter_t* hCPU);
+	void HandleAccessException(uint64 dr6);
+
+	enum class CMDType : char
+	{
+		INVALID = '\0',
+		// Extended commands
+		QUERY_GET = 'q',
+		QUERY_SET = 'Q',
+		VCONT = 'v',
+		// Normal commands
+		CONTINUE = 'c',
+		IS_THREAD_RUNNING = 'T',
+		SET_ACTIVE_THREAD = 'H',
+		ACTIVE_THREAD_STATUS = '?',
+		ACTIVE_THREAD_STEP = 's',
+		REGISTER_READ = 'p',
+		REGISTER_SET = 'P',
+		REGISTERS_READ = 'g',
+		REGISTERS_WRITE = 'G',
+		MEMORY_READ = 'm',
+		MEMORY_WRITE = 'M',
+		BREAKPOINT_SET = 'Z',
+		BREAKPOINT_REMOVE = 'z',
+	};
+
+	class CommandContext {
+	public:
+		CommandContext(const GDBServer* server, const std::string& command)
+			: m_server(server), m_command(command)
+		{
+			std::smatch matches;
+			std::regex_match(command, matches, m_regex);
+			for (size_t i = 1; i < matches.size(); i++)
+			{
+				auto matchStr = matches[i].str();
+				if (!matchStr.empty())
+					m_args.emplace_back(std::move(matchStr));
+			}
+			// send acknowledgement ahead of response
+			send(m_server->m_client_socket, RESPONSE_ACK.data(), (int)RESPONSE_ACK.size(), 0);
+		};
+		~CommandContext()
+		{
+			// cemuLog_logDebug(LogType::Force, "[GDBStub] Received: {}", m_command);
+			// cemuLog_logDebug(LogType::Force, "[GDBStub] Responded: +{}", m_response);
+			auto response_data = EscapeMessage(m_response);
+			auto response_full = fmt::format("${}#{:02x}", response_data, CalculateChecksum(response_data));
+			send(m_server->m_client_socket, response_full.c_str(), (int)response_full.size(), 0);
+		}
+		CommandContext(const CommandContext&) = delete;
+
+		[[nodiscard]] const std::string& GetCommand() const
+		{
+			return m_command;
+		};
+		[[nodiscard]] const std::vector<std::string>& GetArgs() const
+		{
+			return m_args;
+		};
+		[[nodiscard]] bool IsValid() const
+		{
+			return !m_args.empty();
+		};
+		[[nodiscard]] CMDType GetType() const
+		{
+			return static_cast<CMDType>(m_command[0]);
+		};
+
+		// Respond Utils
+		static uint8 CalculateChecksum(std::string_view message_data)
+		{
+			return std::accumulate(message_data.begin(), message_data.end(), (uint8)0, std::plus<>());
+		}
+		static std::string EscapeXMLString(std::string_view xml_data)
+		{
+			std::string escaped;
+			escaped.reserve(xml_data.size());
+			for (char c : xml_data)
+			{
+				switch (c)
+				{
+				case '<': escaped += "&lt;"; break;
+				case '>': escaped += "&gt;"; break;
+				case '&': escaped += "&amp;"; break;
+				case '"': escaped += "&quot;"; break;
+				case '\'': escaped += "&apos;"; break;
+				default: escaped += c; break;
+				}
+			}
+			return escaped;
+		}
+		static std::string EscapeMessage(std::string_view message)
+		{
+			std::string escaped;
+			escaped.reserve(message.size());
+			for (char c : message)
+			{
+				if (c == '#' || c == '$' || c == '}' || c == '*')
+				{
+					escaped.push_back('}');
+					escaped.push_back((char)(c ^ 0x20));
+				}
+				else
+					escaped.push_back(c);
+			}
+			return escaped;
+		}
+		void QueueResponse(std::string_view data)
+		{
+			m_response += data;
+		}
+
+	private:
+		const std::regex m_regex{
+			R"((?:)"
+			R"((\?))"
+			R"(|(vCont\?))"
+			R"(|(vCont;)([a-zA-Z0-9-+=,\+:;]+))"
+			R"(|(qAttached))"
+			R"(|(qSupported):([a-zA-Z0-9-+=,\+;]+))"
+			R"(|(qTStatus))"
+			R"(|(qC))"
+			R"(|(qXfer):((?:features)|(?:threads)|(?:libraries)):read:([\w\.]*):([0-9a-zA-Z]+),([0-9a-zA-Z]+))"
+			R"(|(qfThreadInfo))"
+			R"(|(qsThreadInfo))"
+			R"(|(T)((?:-1)|(?:[0-9A-Fa-f]+)))"
+			R"(|(D))"											  // Detach
+			R"(|(H)(c|g)((?:-1)|(?:[0-9A-Fa-f]+)))"				  // Set active thread for other operations (not c)
+			R"(|(c)([0-9A-Fa-f]+)?)"							  // (Legacy, supported by vCont) Continue all for active thread
+			R"(|([Zz])([0-4]),([0-9A-Fa-f]+),([0-9]))"			  // Insert/delete breakpoints
+			R"(|(g))"											  // Read registers for active thread
+			R"(|(G)([0-9A-Fa-f]+))"								  // Write registers for active thread
+			R"(|(p)([0-9A-Fa-f]+))"								  // Read register for active thread
+			R"(|(P)([0-9A-Fa-f]+)=([0-9A-Fa-f]+))"				  // Write register for active thread
+			R"(|(m)([0-9A-Fa-f]+),([0-9A-Fa-f]+))"				  // Read memory
+			R"(|(M)([0-9A-Fa-f]+),([0-9A-Fa-f]+):([0-9A-Fa-f]+))" // Write memory
+			// R"(|(X)([0-9A-Fa-f]+),([0-9A-Fa-f]+):([0-9A-Fa-f]+))" // Write memory
+			R"())"};
+		const GDBServer* m_server;
+		const std::string m_command;
+		std::vector<std::string> m_args;
+		std::string m_response;
+	};
+
+	class ExecutionBreakpoint;
+	std::map<MPTR, ExecutionBreakpoint> m_patchedInstructions;
+
+	class AccessBreakpoint;
+	std::unique_ptr<AccessBreakpoint> m_watch_point;
+
+private:
+	static constexpr int s_maxGDBClients = 1;
+	static constexpr std::string_view s_supportedFeatures = "PacketSize=4096;qXfer:features:read+;qXfer:threads:read+;qXfer:libraries:read+;swbreak+;hwbreak+;vContSupported+";
+	static constexpr size_t s_maxPacketSize = 1024 * 4;
+	const uint16 m_port;
+
+	enum RegisterID
+	{
+		R0_START = 0,
+		R31_END = R0_START + 31,
+		PC = 64,
+		MSR = 65,
+		CR = 66,
+		LR = 67,
+		CTR = 68,
+		XER = 69,
+		F0_START = 71,
+		F31_END = F0_START + 31,
+		FPSCR = 103
+	};
+
+	static constexpr std::string_view RESPONSE_EMPTY = "";
+	static constexpr std::string_view RESPONSE_ACK = "+";
+	static constexpr std::string_view RESPONSE_NACK = "-";
+	static constexpr std::string_view RESPONSE_OK = "OK";
+	static constexpr std::string_view RESPONSE_ERROR = "E01";
+
+	void ThreadFunc();
+	std::atomic_bool m_stopRequested;
+	void HandleCommand(const std::string& command_str);
+	void HandleQuery(std::unique_ptr<CommandContext>& context) const;
+	void HandleVCont(std::unique_ptr<CommandContext>& context);
+
+	// Commands
+	sint64 m_activeThreadSelector = 0;
+	sint64 m_activeThreadContinueSelector = 0;
+	void CMDContinue(std::unique_ptr<CommandContext>& context);
+	void CMDNotFound(std::unique_ptr<CommandContext>& context);
+	void CMDIsThreadActive(std::unique_ptr<CommandContext>& context);
+	void CMDSetActiveThread(std::unique_ptr<CommandContext>& context);
+	void CMDGetThreadStatus(std::unique_ptr<CommandContext>& context);
+
+	void CMDReadRegister(std::unique_ptr<CommandContext>& context) const;
+	void CMDWriteRegister(std::unique_ptr<CommandContext>& context) const;
+	void CMDReadRegisters(std::unique_ptr<CommandContext>& context) const;
+	void CMDWriteRegisters(std::unique_ptr<CommandContext>& context) const;
+	void CMDReadMemory(std::unique_ptr<CommandContext>& context);
+	void CMDWriteMemory(std::unique_ptr<CommandContext>& context);
+	void CMDInsertBreakpoint(std::unique_ptr<CommandContext>& context);
+	void CMDDeleteBreakpoint(std::unique_ptr<CommandContext>& context);
+
+	std::thread m_thread;
+	std::atomic_bool m_resume_startup = false;
+	MPTR m_entry_point{};
+	std::unique_ptr<CommandContext> m_resumed_context;
+
+	std::atomic_bool m_client_connected;
+	SOCKET m_server_socket = INVALID_SOCKET;
+	sockaddr_in m_server_addr{};
+	SOCKET m_client_socket = INVALID_SOCKET;
+	sockaddr_in m_client_addr{};
+};
+
+static constexpr std::string_view GDBTargetXML = R"(<?xml version="1.0"?>
+<!DOCTYPE target SYSTEM "gdb-target.dtd">
+<target version="1.0">
+    <architecture>powerpc:common</architecture>
+    <feature name="org.gnu.gdb.power.core">
+        <reg name="r0" bitsize="32" type="uint32"/>
+        <reg name="r1" bitsize="32" type="uint32"/>
+        <reg name="r2" bitsize="32" type="uint32"/>
+        <reg name="r3" bitsize="32" type="uint32"/>
+        <reg name="r4" bitsize="32" type="uint32"/>
+        <reg name="r5" bitsize="32" type="uint32"/>
+        <reg name="r6" bitsize="32" type="uint32"/>
+        <reg name="r7" bitsize="32" type="uint32"/>
+        <reg name="r8" bitsize="32" type="uint32"/>
+        <reg name="r9" bitsize="32" type="uint32"/>
+        <reg name="r10" bitsize="32" type="uint32"/>
+        <reg name="r11" bitsize="32" type="uint32"/>
+        <reg name="r12" bitsize="32" type="uint32"/>
+        <reg name="r13" bitsize="32" type="uint32"/>
+        <reg name="r14" bitsize="32" type="uint32"/>
+        <reg name="r15" bitsize="32" type="uint32"/>
+        <reg name="r16" bitsize="32" type="uint32"/>
+        <reg name="r17" bitsize="32" type="uint32"/>
+        <reg name="r18" bitsize="32" type="uint32"/>
+        <reg name="r19" bitsize="32" type="uint32"/>
+        <reg name="r20" bitsize="32" type="uint32"/>
+        <reg name="r21" bitsize="32" type="uint32"/>
+        <reg name="r22" bitsize="32" type="uint32"/>
+        <reg name="r23" bitsize="32" type="uint32"/>
+        <reg name="r24" bitsize="32" type="uint32"/>
+        <reg name="r25" bitsize="32" type="uint32"/>
+        <reg name="r26" bitsize="32" type="uint32"/>
+        <reg name="r27" bitsize="32" type="uint32"/>
+        <reg name="r28" bitsize="32" type="uint32"/>
+        <reg name="r29" bitsize="32" type="uint32"/>
+        <reg name="r30" bitsize="32" type="uint32"/>
+        <reg name="r31" bitsize="32" type="uint32"/>
+        <reg name="pc" bitsize="32" type="code_ptr" regnum="64"/>
+        <reg name="msr" bitsize="32" type="uint32"/>
+        <reg name="cr" bitsize="32" type="uint32"/>
+        <reg name="lr" bitsize="32" type="code_ptr"/>
+        <reg name="ctr" bitsize="32" type="uint32"/>
+        <reg name="xer" bitsize="32" type="uint32"/>
+    </feature>
+    <feature name="org.gnu.gdb.power.fpu">
+        <reg name="f0" bitsize="64" type="ieee_double" regnum="71"/>
+        <reg name="f1" bitsize="64" type="ieee_double"/>
+        <reg name="f2" bitsize="64" type="ieee_double"/>
+        <reg name="f3" bitsize="64" type="ieee_double"/>
+        <reg name="f4" bitsize="64" type="ieee_double"/>
+        <reg name="f5" bitsize="64" type="ieee_double"/>
+        <reg name="f6" bitsize="64" type="ieee_double"/>
+        <reg name="f7" bitsize="64" type="ieee_double"/>
+        <reg name="f8" bitsize="64" type="ieee_double"/>
+        <reg name="f9" bitsize="64" type="ieee_double"/>
+        <reg name="f10" bitsize="64" type="ieee_double"/>
+        <reg name="f11" bitsize="64" type="ieee_double"/>
+        <reg name="f12" bitsize="64" type="ieee_double"/>
+        <reg name="f13" bitsize="64" type="ieee_double"/>
+        <reg name="f14" bitsize="64" type="ieee_double"/>
+        <reg name="f15" bitsize="64" type="ieee_double"/>
+        <reg name="f16" bitsize="64" type="ieee_double"/>
+        <reg name="f17" bitsize="64" type="ieee_double"/>
+        <reg name="f18" bitsize="64" type="ieee_double"/>
+        <reg name="f19" bitsize="64" type="ieee_double"/>
+        <reg name="f20" bitsize="64" type="ieee_double"/>
+        <reg name="f21" bitsize="64" type="ieee_double"/>
+        <reg name="f22" bitsize="64" type="ieee_double"/>
+        <reg name="f23" bitsize="64" type="ieee_double"/>
+        <reg name="f24" bitsize="64" type="ieee_double"/>
+        <reg name="f25" bitsize="64" type="ieee_double"/>
+        <reg name="f26" bitsize="64" type="ieee_double"/>
+        <reg name="f27" bitsize="64" type="ieee_double"/>
+        <reg name="f28" bitsize="64" type="ieee_double"/>
+        <reg name="f29" bitsize="64" type="ieee_double"/>
+        <reg name="f30" bitsize="64" type="ieee_double"/>
+        <reg name="f31" bitsize="64" type="ieee_double"/>
+        <reg name="fpscr" bitsize="32" group="float"/>
+    </feature>
+</target>)";
+
+extern std::unique_ptr<GDBServer> g_gdbstub;
diff --git a/src/Cafe/HW/Espresso/EspressoISA.h b/src/Cafe/HW/Espresso/EspressoISA.h
index 4c630e4c..5e09763b 100644
--- a/src/Cafe/HW/Espresso/EspressoISA.h
+++ b/src/Cafe/HW/Espresso/EspressoISA.h
@@ -10,6 +10,18 @@ namespace Espresso
 		CR_BIT_INDEX_SO = 3,
 	};
 
+	enum class PSQ_LOAD_TYPE
+	{
+		TYPE_F32 = 0,
+		TYPE_UNUSED1 = 1,
+		TYPE_UNUSED2 = 2,
+		TYPE_UNUSED3 = 3,
+		TYPE_U8 = 4,
+		TYPE_U16 = 5,
+		TYPE_S8 = 6,
+		TYPE_S16 = 7,
+	};
+
 	enum class PrimaryOpcode
 	{
 		// underscore at the end of the name means that this instruction always updates CR0 (as if RC bit is set)
@@ -91,17 +103,19 @@ namespace Espresso
 		BCCTR = 528
 	};
 
-	enum class OPCODE_31
+	enum class Opcode31
 	{
-
+		TW = 4,
+		MFTB = 371,
 	};
 
 	inline PrimaryOpcode GetPrimaryOpcode(uint32 opcode) { return (PrimaryOpcode)(opcode >> 26); };
 	inline Opcode19 GetGroup19Opcode(uint32 opcode) { return (Opcode19)((opcode >> 1) & 0x3FF); };
+	inline Opcode31 GetGroup31Opcode(uint32 opcode) { return (Opcode31)((opcode >> 1) & 0x3FF); };
 
 	struct BOField 
 	{
-		BOField() {};
+		BOField() = default;
 		BOField(uint8 bo) : bo(bo) {};
 
 		bool conditionInverted() const
@@ -132,6 +146,12 @@ namespace Espresso
 		uint8 bo;
 	};
 
+	// returns true if LK bit is set, only valid for branch instructions
+	inline bool DecodeLK(uint32 opcode)
+	{
+		return (opcode & 1) != 0;
+	}
+
 	inline void _decodeForm_I(uint32 opcode, uint32& LI, bool& AA, bool& LK)
 	{
 		LI = opcode & 0x3fffffc;
@@ -183,13 +203,7 @@ namespace Espresso
 		_decodeForm_D_branch(opcode, BD, BO, BI, AA, LK);
 	}
 
-	inline void decodeOp_BCLR(uint32 opcode, BOField& BO, uint32& BI, bool& LK)
-	{
-		// form XL (with BD field expected to be zero)
-		_decodeForm_XL(opcode, BO, BI, LK);
-	}
-
-	inline void decodeOp_BCCTR(uint32 opcode, BOField& BO, uint32& BI, bool& LK)
+	inline void decodeOp_BCSPR(uint32 opcode, BOField& BO, uint32& BI, bool& LK) // BCLR and BCSPR
 	{
 		// form XL (with BD field expected to be zero)
 		_decodeForm_XL(opcode, BO, BI, LK);
diff --git a/src/Cafe/HW/Espresso/Interpreter/PPCInterpreterALU.hpp b/src/Cafe/HW/Espresso/Interpreter/PPCInterpreterALU.hpp
index a3e45679..2fe07509 100644
--- a/src/Cafe/HW/Espresso/Interpreter/PPCInterpreterALU.hpp
+++ b/src/Cafe/HW/Espresso/Interpreter/PPCInterpreterALU.hpp
@@ -3,18 +3,17 @@ static void PPCInterpreter_setXerOV(PPCInterpreter_t* hCPU, bool hasOverflow)
 {
 	if (hasOverflow)
 	{
-		hCPU->spr.XER |= XER_SO;
-		hCPU->spr.XER |= XER_OV;
+		hCPU->xer_so = 1;
+		hCPU->xer_ov = 1;
 	}
 	else
 	{
-		hCPU->spr.XER &= ~XER_OV;
+		hCPU->xer_ov = 0;
 	}
 }
 
 static bool checkAdditionOverflow(uint32 x, uint32 y, uint32 r)
 {
-	// todo - update remaining *O instructions to use this function
 
 	/*
 		x	y	r	result	(has overflow)
@@ -42,19 +41,11 @@ static void PPCInterpreter_ADD(PPCInterpreter_t* hCPU, uint32 opcode)
 
 static void PPCInterpreter_ADDO(PPCInterpreter_t* hCPU, uint32 opcode)
 {
-	// untested (Don't Starve Giant Edition uses this instruction + BSO)
+	// Don't Starve Giant Edition uses this instruction + BSO
 	PPC_OPC_TEMPL3_XO();
-	uint64 result = (uint64)hCPU->gpr[rA] + (uint64)hCPU->gpr[rB];
+	uint32 result = hCPU->gpr[rA] + hCPU->gpr[rB];
+	PPCInterpreter_setXerOV(hCPU, checkAdditionOverflow(hCPU->gpr[rA], hCPU->gpr[rB], result));
 	hCPU->gpr[rD] = (uint32)result;
-	if (result >= 0x100000000ULL)
-	{
-		hCPU->spr.XER |= XER_SO;
-		hCPU->spr.XER |= XER_OV;
-	}
-	else
-	{
-		hCPU->spr.XER &= ~XER_OV;
-	}
 	if (opHasRC())
 		ppc_update_cr0(hCPU, hCPU->gpr[rD]);
 	PPCInterpreter_nextInstruction(hCPU);
@@ -85,13 +76,7 @@ static void PPCInterpreter_ADDCO(PPCInterpreter_t* hCPU, uint32 opcode)
 	else
 		hCPU->xer_ca = 0;
 	// set SO/OV
-	if (hCPU->gpr[rD] < a)
-	{
-		hCPU->spr.XER |= XER_OV;
-		hCPU->spr.XER |= XER_SO;
-	}
-	else
-		hCPU->spr.XER &= ~XER_OV;
+	PPCInterpreter_setXerOV(hCPU, checkAdditionOverflow(a, b, hCPU->gpr[rD]));
 	if (opHasRC())
 		ppc_update_cr0(hCPU, hCPU->gpr[rD]);
 	PPCInterpreter_nextInstruction(hCPU);
@@ -128,7 +113,6 @@ static void PPCInterpreter_ADDEO(PPCInterpreter_t* hCPU, uint32 opcode)
 	else
 		hCPU->xer_ca = 0;
 	PPCInterpreter_setXerOV(hCPU, checkAdditionOverflow(a, b, hCPU->gpr[rD]));
-	// update CR
 	if (opHasRC())
 		ppc_update_cr0(hCPU, hCPU->gpr[rD]);
 	PPCInterpreter_nextInstruction(hCPU);
@@ -145,7 +129,7 @@ static void PPCInterpreter_ADDI(PPCInterpreter_t* hCPU, uint32 opcode)
 
 static void PPCInterpreter_ADDIC(PPCInterpreter_t* hCPU, uint32 opcode)
 {
-	int rD, rA;
+	sint32 rD, rA;
 	uint32 imm;
 	PPC_OPC_TEMPL_D_SImm(opcode, rD, rA, imm);
 	uint32 a = hCPU->gpr[rA];
@@ -160,7 +144,7 @@ static void PPCInterpreter_ADDIC(PPCInterpreter_t* hCPU, uint32 opcode)
 
 static void PPCInterpreter_ADDIC_(PPCInterpreter_t* hCPU, uint32 opcode)
 {
-	int rD, rA;
+	sint32 rD, rA;
 	uint32 imm;
 	PPC_OPC_TEMPL_D_SImm(opcode, rD, rA, imm);
 	uint32 a = hCPU->gpr[rA];
@@ -170,14 +154,13 @@ static void PPCInterpreter_ADDIC_(PPCInterpreter_t* hCPU, uint32 opcode)
 		hCPU->xer_ca = 1;
 	else
 		hCPU->xer_ca = 0;
-	// update cr0 flags
 	ppc_update_cr0(hCPU, hCPU->gpr[rD]);
 	PPCInterpreter_nextInstruction(hCPU);
 }
 
 static void PPCInterpreter_ADDIS(PPCInterpreter_t* hCPU, uint32 opcode)
 {
-	int rD, rA;
+	sint32 rD, rA;
 	uint32 imm;
 	PPC_OPC_TEMPL_D_Shift16(opcode, rD, rA, imm);
 	hCPU->gpr[rD] = (rA ? hCPU->gpr[rA] : 0) + imm;
@@ -200,6 +183,23 @@ static void PPCInterpreter_ADDZE(PPCInterpreter_t* hCPU, uint32 opcode)
 	PPCInterpreter_nextInstruction(hCPU);
 }
 
+static void PPCInterpreter_ADDZEO(PPCInterpreter_t* hCPU, uint32 opcode)
+{
+	PPC_OPC_TEMPL3_XO();
+	PPC_ASSERT(rB == 0);
+	uint32 a = hCPU->gpr[rA];
+	uint32 ca = hCPU->xer_ca;
+	hCPU->gpr[rD] = a + ca;
+	PPCInterpreter_setXerOV(hCPU, checkAdditionOverflow(a, 0, hCPU->gpr[rD]));
+	if ((a == 0xffffffff) && ca)
+		hCPU->xer_ca = 1;
+	else
+		hCPU->xer_ca = 0;
+	if (opHasRC())
+		ppc_update_cr0(hCPU, hCPU->gpr[rD]);
+	PPCInterpreter_nextInstruction(hCPU);
+}
+
 static void PPCInterpreter_ADDME(PPCInterpreter_t* hCPU, uint32 opcode)
 {
 	PPC_OPC_TEMPL3_XO();
@@ -216,6 +216,23 @@ static void PPCInterpreter_ADDME(PPCInterpreter_t* hCPU, uint32 opcode)
 	PPCInterpreter_nextInstruction(hCPU);
 }
 
+static void PPCInterpreter_ADDMEO(PPCInterpreter_t* hCPU, uint32 opcode)
+{
+	PPC_OPC_TEMPL3_XO();
+	PPC_ASSERT(rB == 0);
+	uint32 a = hCPU->gpr[rA];
+	uint32 ca = hCPU->xer_ca;
+	hCPU->gpr[rD] = a + ca + 0xffffffff;
+	PPCInterpreter_setXerOV(hCPU, checkAdditionOverflow(a, 0xffffffff, hCPU->gpr[rD]));
+	if (a || ca)
+		hCPU->xer_ca = 1;
+	else
+		hCPU->xer_ca = 0;
+	if (opHasRC())
+		ppc_update_cr0(hCPU, hCPU->gpr[rD]);
+	PPCInterpreter_nextInstruction(hCPU);
+}
+
 static void PPCInterpreter_SUBF(PPCInterpreter_t* hCPU, uint32 opcode)
 {
 	PPC_OPC_TEMPL3_XO();
@@ -227,11 +244,12 @@ static void PPCInterpreter_SUBF(PPCInterpreter_t* hCPU, uint32 opcode)
 
 static void PPCInterpreter_SUBFO(PPCInterpreter_t* hCPU, uint32 opcode)
 {
-	// untested (Don't Starve Giant Edition uses this)
+	// Seen in Don't Starve Giant Edition and Teslagrad
 	// also used by DS Virtual Console (Super Mario 64 DS)
 	PPC_OPC_TEMPL3_XO();
-	hCPU->gpr[rD] = ~hCPU->gpr[rA] + hCPU->gpr[rB] + 1;
-	PPCInterpreter_setXerOV(hCPU, checkAdditionOverflow(~hCPU->gpr[rA], hCPU->gpr[rB], hCPU->gpr[rD]));
+	uint32 result = ~hCPU->gpr[rA] + hCPU->gpr[rB] + 1;
+	PPCInterpreter_setXerOV(hCPU, checkAdditionOverflow(~hCPU->gpr[rA], hCPU->gpr[rB], result));
+	hCPU->gpr[rD] = result;
 	if (opHasRC())
 		ppc_update_cr0(hCPU, hCPU->gpr[rD]);
 	PPCInterpreter_nextInstruction(hCPU);
@@ -260,21 +278,13 @@ static void PPCInterpreter_SUBFCO(PPCInterpreter_t* hCPU, uint32 opcode)
 	uint32 a = hCPU->gpr[rA];
 	uint32 b = hCPU->gpr[rB];
 	hCPU->gpr[rD] = ~a + b + 1;
-	// update xer
+	// update carry
 	if (ppc_carry_3(~a, b, 1))
 		hCPU->xer_ca = 1;
 	else
 		hCPU->xer_ca = 0;
 	// update xer SO/OV
-	if (checkAdditionOverflow(~a, b, hCPU->gpr[rD]))
-	{
-		hCPU->spr.XER |= XER_SO;
-		hCPU->spr.XER |= XER_OV;
-	}
-	else
-	{
-		hCPU->spr.XER &= ~XER_OV;
-	}
+	PPCInterpreter_setXerOV(hCPU, checkAdditionOverflow(~a, b, hCPU->gpr[rD]));
 	if (opHasRC())
 		ppc_update_cr0(hCPU, hCPU->gpr[rD]);
 	PPCInterpreter_nextInstruction(hCPU);
@@ -282,7 +292,7 @@ static void PPCInterpreter_SUBFCO(PPCInterpreter_t* hCPU, uint32 opcode)
 
 static void PPCInterpreter_SUBFIC(PPCInterpreter_t* hCPU, uint32 opcode)
 {
-	int rD, rA;
+	sint32 rD, rA;
 	uint32 imm;
 	PPC_OPC_TEMPL_D_SImm(opcode, rD, rA, imm);
 	uint32 a = hCPU->gpr[rA];
@@ -306,7 +316,6 @@ static void PPCInterpreter_SUBFE(PPCInterpreter_t* hCPU, uint32 opcode)
 		hCPU->xer_ca = 1;
 	else
 		hCPU->xer_ca = 0;
-	// update cr0
 	if (opHasRC())
 		ppc_update_cr0(hCPU, hCPU->gpr[rD]);
 	PPCInterpreter_nextInstruction(hCPU);
@@ -325,16 +334,7 @@ static void PPCInterpreter_SUBFEO(PPCInterpreter_t* hCPU, uint32 opcode)
 		hCPU->xer_ca = 1;
 	else
 		hCPU->xer_ca = 0;
-	if (checkAdditionOverflow(~a, b, result))
-	{
-		hCPU->spr.XER |= XER_SO;
-		hCPU->spr.XER |= XER_OV;
-	}
-	else
-	{
-		hCPU->spr.XER &= ~XER_OV;
-	}
-	// update cr0
+	PPCInterpreter_setXerOV(hCPU, checkAdditionOverflow(~a, b, result));
 	if (opHasRC())
 		ppc_update_cr0(hCPU, hCPU->gpr[rD]);
 	PPCInterpreter_nextInstruction(hCPU);
@@ -356,9 +356,25 @@ static void PPCInterpreter_SUBFZE(PPCInterpreter_t* hCPU, uint32 opcode)
 	PPCInterpreter_nextInstruction(hCPU);
 }
 
+static void PPCInterpreter_SUBFZEO(PPCInterpreter_t* hCPU, uint32 opcode)
+{
+	PPC_OPC_TEMPL3_XO();
+	PPC_ASSERT(rB == 0);
+	uint32 a = hCPU->gpr[rA];
+	uint32 ca = hCPU->xer_ca;
+	hCPU->gpr[rD] = ~a + ca;
+	PPCInterpreter_setXerOV(hCPU, checkAdditionOverflow(~a, 0, hCPU->gpr[rD]));
+	if (a == 0 && ca)
+		hCPU->xer_ca = 1;
+	else
+		hCPU->xer_ca = 0;
+	if (opHasRC())
+		ppc_update_cr0(hCPU, hCPU->gpr[rD]);
+	PPCInterpreter_nextInstruction(hCPU);
+}
+
 static void PPCInterpreter_SUBFME(PPCInterpreter_t* hCPU, uint32 opcode)
 {
-	// untested
 	PPC_OPC_TEMPL3_XO();
 	PPC_ASSERT(rB == 0);
 	uint32 a = hCPU->gpr[rA];
@@ -369,7 +385,24 @@ static void PPCInterpreter_SUBFME(PPCInterpreter_t* hCPU, uint32 opcode)
 		hCPU->xer_ca = 1;
 	else
 		hCPU->xer_ca = 0;
-	// update cr0
+	if (opcode & PPC_OPC_RC)
+		ppc_update_cr0(hCPU, hCPU->gpr[rD]);
+	PPCInterpreter_nextInstruction(hCPU);
+}
+
+static void PPCInterpreter_SUBFMEO(PPCInterpreter_t* hCPU, uint32 opcode)
+{
+	PPC_OPC_TEMPL3_XO();
+	PPC_ASSERT(rB == 0);
+	uint32 a = hCPU->gpr[rA];
+	uint32 ca = hCPU->xer_ca;
+	hCPU->gpr[rD] = ~a + 0xFFFFFFFF + ca;
+	PPCInterpreter_setXerOV(hCPU, checkAdditionOverflow(~a, 0xFFFFFFFF, hCPU->gpr[rD]));
+	// update xer carry
+	if (ppc_carry_3(~a, 0xFFFFFFFF, ca))
+		hCPU->xer_ca = 1;
+	else
+		hCPU->xer_ca = 0;
 	if (opcode & PPC_OPC_RC)
 		ppc_update_cr0(hCPU, hCPU->gpr[rD]);
 	PPCInterpreter_nextInstruction(hCPU);
@@ -382,13 +415,8 @@ static void PPCInterpreter_MULHW_(PPCInterpreter_t* hCPU, uint32 opcode)
 	sint64 b = (sint32)hCPU->gpr[rB];
 	sint64 c = a * b;
 	hCPU->gpr[rD] = ((uint64)c) >> 32;
-	if (opcode & PPC_OPC_RC) {
-		// update cr0 flags
-#ifndef PUBLIC_RELEASE
-		assert_dbg();
-#endif
+	if (opHasRC())
 		ppc_update_cr0(hCPU, hCPU->gpr[rD]);
-	}
 	PPCInterpreter_nextInstruction(hCPU);
 }
 
@@ -419,17 +447,9 @@ static void PPCInterpreter_MULLWO(PPCInterpreter_t* hCPU, uint32 opcode)
 	// Don't Starve Giant Edition uses this instruction + BSO
 	// also used by FullBlast when a save file exists + it uses mfxer to access overflow result
 	PPC_OPC_TEMPL3_XO();
-	sint64 result = (sint64)hCPU->gpr[rA] * (sint64)hCPU->gpr[rB];
+	sint64 result = (sint64)(sint32)hCPU->gpr[rA] * (sint64)(sint32)hCPU->gpr[rB];
 	hCPU->gpr[rD] = (uint32)result;
-	if (result < -0x80000000ll && result > 0x7FFFFFFFLL)
-	{
-		hCPU->spr.XER |= XER_SO;
-		hCPU->spr.XER |= XER_OV;
-	}
-	else
-	{
-		hCPU->spr.XER &= ~XER_OV;
-	}
+	PPCInterpreter_setXerOV(hCPU, result < -0x80000000ll || result > 0x7FFFFFFFLL);
 	if (opHasRC())
 		ppc_update_cr0(hCPU, hCPU->gpr[rD]);
 	PPCInterpreter_nextInstruction(hCPU);
@@ -447,14 +467,14 @@ static void PPCInterpreter_MULLI(PPCInterpreter_t* hCPU, uint32 opcode)
 static void PPCInterpreter_DIVW(PPCInterpreter_t* hCPU, uint32 opcode)
 {
 	PPC_OPC_TEMPL3_XO();
-	sint32 a = hCPU->gpr[rA];
-	sint32 b = hCPU->gpr[rB];
+	sint32 a = (sint32)hCPU->gpr[rA];
+	sint32 b = (sint32)hCPU->gpr[rB];
 	if (b == 0)
-	{
-		forceLogDebug_printf("Error: Division by zero! [%08X]\n", (uint32)hCPU->instructionPointer);
-		b++;
-	}
-	hCPU->gpr[rD] = a / b;
+		hCPU->gpr[rD] = a < 0 ? 0xFFFFFFFF : 0;
+	else if (a == 0x80000000 && b == 0xFFFFFFFF)
+		hCPU->gpr[rD] = 0xFFFFFFFF;
+	else
+		hCPU->gpr[rD] = a / b;
 	if (opHasRC())
 		ppc_update_cr0(hCPU, hCPU->gpr[rD]);
 	PPCInterpreter_nextInstruction(hCPU);
@@ -463,19 +483,23 @@ static void PPCInterpreter_DIVW(PPCInterpreter_t* hCPU, uint32 opcode)
 static void PPCInterpreter_DIVWO(PPCInterpreter_t* hCPU, uint32 opcode)
 {
 	PPC_OPC_TEMPL3_XO();
-	sint32 a = hCPU->gpr[rA];
-	sint32 b = hCPU->gpr[rB];
+	sint32 a = (sint32)hCPU->gpr[rA];
+	sint32 b = (sint32)hCPU->gpr[rB];
 	if (b == 0)
 	{
-		if (opcode & PPC_OPC_OE)
-			hCPU->spr.XER |= XER_OV;
-		PPCInterpreter_nextInstruction(hCPU);
-		return;
+		PPCInterpreter_setXerOV(hCPU, true);
+		hCPU->gpr[rD] = a < 0 ? 0xFFFFFFFF : 0;
+	}
+	else if(a == 0x80000000 && b == 0xFFFFFFFF)
+	{
+		PPCInterpreter_setXerOV(hCPU, true);
+		hCPU->gpr[rD] = 0xFFFFFFFF;
+	}
+	else
+	{
+		hCPU->gpr[rD] = a / b;
+		PPCInterpreter_setXerOV(hCPU, false);
 	}
-	hCPU->gpr[rD] = a / b;
-	if (opcode & PPC_OPC_OE)
-		hCPU->spr.XER &= ~XER_OV;
-	// todo: Handle SO
 	if (opHasRC())
 		ppc_update_cr0(hCPU, hCPU->gpr[rD]);
 	PPCInterpreter_nextInstruction(hCPU);
@@ -484,12 +508,14 @@ static void PPCInterpreter_DIVWO(PPCInterpreter_t* hCPU, uint32 opcode)
 static void PPCInterpreter_DIVWU(PPCInterpreter_t* hCPU, uint32 opcode)
 {
 	PPC_OPC_TEMPL3_XO();
-	if (hCPU->gpr[rB] == 0)
-	{
-		PPCInterpreter_nextInstruction(hCPU);
-		return;
-	}
-	hCPU->gpr[rD] = hCPU->gpr[rA] / hCPU->gpr[rB];
+	uint32 a = hCPU->gpr[rA];
+	uint32 b = hCPU->gpr[rB];
+	if (b == 0)
+		hCPU->gpr[rD] = 0;
+	else if (a == 0x80000000 && b == 0xFFFFFFFF)
+		hCPU->gpr[rD] = 0;
+	else
+		hCPU->gpr[rD] = a / b;
 	if (opHasRC())
 		ppc_update_cr0(hCPU, hCPU->gpr[rD]);
 	PPCInterpreter_nextInstruction(hCPU);
@@ -498,17 +524,23 @@ static void PPCInterpreter_DIVWU(PPCInterpreter_t* hCPU, uint32 opcode)
 static void PPCInterpreter_DIVWUO(PPCInterpreter_t* hCPU, uint32 opcode)
 {
 	PPC_OPC_TEMPL3_XO();
-	if (hCPU->gpr[rB] == 0)
+	uint32 a = hCPU->gpr[rA];
+	uint32 b = hCPU->gpr[rB];
+	if (b == 0)
 	{
-		if (opcode & PPC_OPC_OE)
-			hCPU->spr.XER |= XER_OV;
-		PPCInterpreter_nextInstruction(hCPU);
-		return;
+		PPCInterpreter_setXerOV(hCPU, true);
+		hCPU->gpr[rD] = 0;
+	}
+	else if(a == 0x80000000 && b == 0xFFFFFFFF)
+	{
+		PPCInterpreter_setXerOV(hCPU, false);
+		hCPU->gpr[rD] = 0;
+	}
+	else
+	{
+		hCPU->gpr[rD] = a / b;
+		PPCInterpreter_setXerOV(hCPU, false);
 	}
-	hCPU->gpr[rD] = hCPU->gpr[rA] / hCPU->gpr[rB];
-	if (opcode & PPC_OPC_OE)
-		hCPU->spr.XER &= ~XER_OV;
-	// todo: Handle SO 
 	if (opHasRC())
 		ppc_update_cr0(hCPU, hCPU->gpr[rD]);
 	PPCInterpreter_nextInstruction(hCPU);
@@ -535,6 +567,13 @@ static void PPCInterpreter_CRANDC(PPCInterpreter_t* hCPU, uint32 opcode)
 	PPCInterpreter_nextInstruction(hCPU);
 }
 
+static void PPCInterpreter_CRNAND(PPCInterpreter_t* hCPU, uint32 opcode)
+{
+	PPC_OPC_TEMPL_X_CR();
+	ppc_setCRBit(hCPU, crD, (ppc_getCRBit(hCPU, crA)&ppc_getCRBit(hCPU, crB)) ^ 1);
+	PPCInterpreter_nextInstruction(hCPU);
+}
+
 static void PPCInterpreter_CROR(PPCInterpreter_t* hCPU, uint32 opcode)
 {
 	PPC_OPC_TEMPL_X_CR();
@@ -577,15 +616,7 @@ static void PPCInterpreter_NEGO(PPCInterpreter_t* hCPU, uint32 opcode)
 {
 	PPC_OPC_TEMPL3_XO();
 	PPC_ASSERT(rB == 0);
-	if (hCPU->gpr[rA] == 0x80000000)
-	{
-		hCPU->spr.XER |= XER_SO;
-		hCPU->spr.XER |= XER_OV;
-	}
-	else
-	{
-		hCPU->spr.XER &= ~XER_OV;
-	}
+	PPCInterpreter_setXerOV(hCPU, hCPU->gpr[rA] == 0x80000000);
 	hCPU->gpr[rD] = (uint32)-((sint32)hCPU->gpr[rA]);
 	if (opHasRC())
 		ppc_update_cr0(hCPU, hCPU->gpr[rD]);
@@ -900,8 +931,7 @@ static void PPCInterpreter_CMP(PPCInterpreter_t* hCPU, uint32 opcode)
 		hCPU->cr[cr * 4 + CR_BIT_GT] = 1;
 	else 
 		hCPU->cr[cr * 4 + CR_BIT_EQ] = 1;
-	if ((hCPU->spr.XER & XER_SO) != 0)
-		hCPU->cr[cr * 4 + CR_BIT_SO] = 1;
+	hCPU->cr[cr * 4 + CR_BIT_SO] = hCPU->xer_so;
 	PPCInterpreter_nextInstruction(hCPU);
 }
 
@@ -923,8 +953,7 @@ static void PPCInterpreter_CMPL(PPCInterpreter_t* hCPU, uint32 opcode)
 		hCPU->cr[cr * 4 + CR_BIT_GT] = 1;
 	else
 		hCPU->cr[cr * 4 + CR_BIT_EQ] = 1;
-	if ((hCPU->spr.XER & XER_SO) != 0)
-		hCPU->cr[cr * 4 + CR_BIT_SO] = 1;
+	hCPU->cr[cr * 4 + CR_BIT_SO] = hCPU->xer_so;
 	PPCInterpreter_nextInstruction(hCPU);
 }
 
@@ -947,8 +976,7 @@ static void PPCInterpreter_CMPI(PPCInterpreter_t* hCPU, uint32 opcode)
 		hCPU->cr[cr * 4 + CR_BIT_GT] = 1;
 	else 
 		hCPU->cr[cr * 4 + CR_BIT_EQ] = 1;
-	if (hCPU->spr.XER & XER_SO)
-		hCPU->cr[cr * 4 + CR_BIT_SO] = 1;
+	hCPU->cr[cr * 4 + CR_BIT_SO] = hCPU->xer_so;
 	PPCInterpreter_nextInstruction(hCPU);
 }
 
@@ -971,8 +999,7 @@ static void PPCInterpreter_CMPLI(PPCInterpreter_t* hCPU, uint32 opcode)
 		hCPU->cr[cr * 4 + CR_BIT_GT] = 1;
 	else
 		hCPU->cr[cr * 4 + CR_BIT_EQ] = 1;
-	if (hCPU->spr.XER & XER_SO)
-		hCPU->cr[cr * 4 + CR_BIT_SO] = 1;
+	hCPU->cr[cr * 4 + CR_BIT_SO] = hCPU->xer_so;
 	PPCInterpreter_nextInstruction(hCPU);
 }
 
diff --git a/src/Cafe/HW/Espresso/Interpreter/PPCInterpreterFPU.cpp b/src/Cafe/HW/Espresso/Interpreter/PPCInterpreterFPU.cpp
index a33a1be6..2c99b84c 100644
--- a/src/Cafe/HW/Espresso/Interpreter/PPCInterpreterFPU.cpp
+++ b/src/Cafe/HW/Espresso/Interpreter/PPCInterpreterFPU.cpp
@@ -32,7 +32,7 @@ espresso_frsqrte_entry_t frsqrteLookupTable[32] =
 	{0x20c1000, 0x35e},{0x1f12000, 0x332},{0x1d79000, 0x30a},{0x1bf4000, 0x2e6},
 };
 
-double frsqrte_espresso(double input)
+ATTR_MS_ABI double frsqrte_espresso(double input)
 {
 	unsigned long long x = *(unsigned long long*)&input;
 
@@ -111,7 +111,7 @@ espresso_fres_entry_t fresLookupTable[32] =
 	{0x88400, 0x11a},	{0x65000, 0x11a},	{0x41c00, 0x108},	{0x20c00, 0x106}
 };
 
-double fres_espresso(double input)
+ATTR_MS_ABI double fres_espresso(double input)
 {
 	// based on testing we know that fres uses only the first 15 bits of the mantissa
 	// seee eeee eeee mmmm mmmm mmmm mmmx xxxx ....		(s = sign, e = exponent, m = mantissa, x = not used)
@@ -515,7 +515,7 @@ void PPCInterpreter_MTFSF(PPCInterpreter_t* hCPU, uint32 Opcode)
 	static bool logFPSCRWriteOnce = false;
 	if( logFPSCRWriteOnce == false )
 	{
-		forceLog_printf("Unsupported write to FPSCR\n");
+		cemuLog_log(LogType::Force, "Unsupported write to FPSCR");
 		logFPSCRWriteOnce = true;
 	}
 	PPCInterpreter_nextInstruction(hCPU);
@@ -697,4 +697,4 @@ void PPCInterpreter_FCMPU(PPCInterpreter_t* hCPU, uint32 Opcode)
 	fcmpu_espresso(hCPU, crfD, hCPU->fpr[frA].fp0, hCPU->fpr[frB].fp0);
 
 	PPCInterpreter_nextInstruction(hCPU);
-}
\ No newline at end of file
+}
diff --git a/src/Cafe/HW/Espresso/Interpreter/PPCInterpreterHLE.cpp b/src/Cafe/HW/Espresso/Interpreter/PPCInterpreterHLE.cpp
index 6aa1fcfa..cf7ba195 100644
--- a/src/Cafe/HW/Espresso/Interpreter/PPCInterpreterHLE.cpp
+++ b/src/Cafe/HW/Espresso/Interpreter/PPCInterpreterHLE.cpp
@@ -2,62 +2,70 @@
 #include "PPCInterpreterInternal.h"
 #include "PPCInterpreterHelper.h"
 
-std::unordered_set<std::string> sUnsupportedHLECalls;
+std::unordered_set<std::string> s_unsupportedHLECalls;
 
 void PPCInterpreter_handleUnsupportedHLECall(PPCInterpreter_t* hCPU)
 {
 	const char* libFuncName = (char*)memory_getPointerFromVirtualOffset(hCPU->instructionPointer + 8);
 	std::string tempString = fmt::format("Unsupported lib call: {}", libFuncName);
-	if (sUnsupportedHLECalls.find(tempString) == sUnsupportedHLECalls.end())
+	if (s_unsupportedHLECalls.find(tempString) == s_unsupportedHLECalls.end())
 	{
 		cemuLog_log(LogType::UnsupportedAPI, "{}", tempString);
-		sUnsupportedHLECalls.emplace(tempString);
+		s_unsupportedHLECalls.emplace(tempString);
 	}
 	hCPU->gpr[3] = 0;
 	PPCInterpreter_nextInstruction(hCPU);
 }
 
-std::vector<void(*)(PPCInterpreter_t* hCPU)>* sPPCHLETable{};
+static constexpr size_t HLE_TABLE_CAPACITY = 0x4000;
+HLECALL s_ppcHleTable[HLE_TABLE_CAPACITY]{};
+sint32 s_ppcHleTableWriteIndex = 0;
+std::mutex s_ppcHleTableMutex;
 
-HLEIDX PPCInterpreter_registerHLECall(HLECALL hleCall)
+HLEIDX PPCInterpreter_registerHLECall(HLECALL hleCall, std::string hleName)
 {
-	if (!sPPCHLETable)
-		sPPCHLETable = new std::vector<void(*)(PPCInterpreter_t* hCPU)>();
-	for (sint32 i = 0; i < sPPCHLETable->size(); i++)
+	std::unique_lock _l(s_ppcHleTableMutex);
+	if (s_ppcHleTableWriteIndex >= HLE_TABLE_CAPACITY)
 	{
-		if ((*sPPCHLETable)[i] == hleCall)
-			return i;
+		cemuLog_log(LogType::Force, "HLE table is full");
+		cemu_assert(false);
 	}
-	HLEIDX newFuncIndex = (sint32)sPPCHLETable->size();
-	sPPCHLETable->resize(sPPCHLETable->size() + 1);
-	(*sPPCHLETable)[newFuncIndex] = hleCall;
-	return newFuncIndex;
+	for (sint32 i = 0; i < s_ppcHleTableWriteIndex; i++)
+	{
+		if (s_ppcHleTable[i] == hleCall)
+		{
+			return i;
+		}
+	}
+	cemu_assert(s_ppcHleTableWriteIndex < HLE_TABLE_CAPACITY);
+	s_ppcHleTable[s_ppcHleTableWriteIndex] = hleCall;
+	HLEIDX funcIndex = s_ppcHleTableWriteIndex;
+	s_ppcHleTableWriteIndex++;
+	return funcIndex;
 }
 
 HLECALL PPCInterpreter_getHLECall(HLEIDX funcIndex)
 {
-	if (funcIndex < 0 || funcIndex >= sPPCHLETable->size())
+	if (funcIndex < 0 || funcIndex >= HLE_TABLE_CAPACITY)
 		return nullptr;
-	return sPPCHLETable->data()[funcIndex];
+	return s_ppcHleTable[funcIndex];
 }
 
-std::mutex g_hleLogMutex;
+std::mutex s_hleLogMutex;
 
 void PPCInterpreter_virtualHLE(PPCInterpreter_t* hCPU, unsigned int opcode)
 {
 	uint32 hleFuncId = opcode & 0xFFFF;
-	if (hleFuncId == 0xFFD0)
+	if (hleFuncId == 0xFFD0) [[unlikely]]
 	{
-		g_hleLogMutex.lock();
+		s_hleLogMutex.lock();
 		PPCInterpreter_handleUnsupportedHLECall(hCPU);
-		g_hleLogMutex.unlock();
-		return;
+		s_hleLogMutex.unlock();
 	}
 	else
 	{
 		// os lib function
-		cemu_assert(hleFuncId < sPPCHLETable->size());
-		auto hleCall = (*sPPCHLETable)[hleFuncId];
+		auto hleCall = PPCInterpreter_getHLECall(hleFuncId);
 		cemu_assert(hleCall);
 		hleCall(hCPU);
 	}
diff --git a/src/Cafe/HW/Espresso/Interpreter/PPCInterpreterImpl.cpp b/src/Cafe/HW/Espresso/Interpreter/PPCInterpreterImpl.cpp
index 6e3de535..547472ab 100644
--- a/src/Cafe/HW/Espresso/Interpreter/PPCInterpreterImpl.cpp
+++ b/src/Cafe/HW/Espresso/Interpreter/PPCInterpreterImpl.cpp
@@ -1,6 +1,7 @@
 #include "PPCInterpreterInternal.h"
 #include "PPCInterpreterHelper.h"
 #include "Cafe/HW/Espresso/Debugger/Debugger.h"
+#include "Cafe/HW/Espresso/Debugger/GDBStub.h"
 
 class PPCItpCafeOSUsermode
 {
@@ -139,7 +140,7 @@ public:
 			return vAddr;
 		}
 
-#ifndef PUBLIC_RELEASE
+#ifdef CEMU_DEBUG_ASSERT
 		if (hCPU->memoryException)
 			assert_dbg(); // should not be set anymore
 #endif
@@ -236,7 +237,7 @@ public:
 			lookupHash = ~lookupHash;
 		}
 
-		forceLogDebug_printf("DSI exception at 0x%08x LR 0x%08x DataAddress %08x", hCPU->instructionPointer, hCPU->spr.LR, vAddr);
+		cemuLog_logDebug(LogType::Force, "DSI exception at 0x{:08x} DataAddress {:08x}", hCPU->instructionPointer, vAddr);
 
 		generateDSIException(hCPU, vAddr);
 
@@ -377,12 +378,12 @@ public:
 		if (pAddr >= 0x01FFF000 && pAddr < 0x02000000)
 		{
 			debug_printf("Access u32 boot param block 0x%08x IP %08x LR %08x\n", pAddr, hCPU->instructionPointer, hCPU->spr.LR);
-			forceLogDebug_printf("Access u32 boot param block 0x%08x (org %08x) IP %08x LR %08x\n", pAddr, address, hCPU->instructionPointer, hCPU->spr.LR);
+			cemuLog_logDebug(LogType::Force, "Access u32 boot param block 0x{:08x} (org {:08x}) IP {:08x}", pAddr, address, hCPU->instructionPointer);
 		}
 		if (pAddr >= 0xFFEB73B0 && pAddr < (0xFFEB73B0+0x40C))
 		{
 			debug_printf("Access cached u32 boot param block 0x%08x IP %08x LR %08x\n", pAddr, hCPU->instructionPointer, hCPU->spr.LR);
-			forceLogDebug_printf("Access cached u32 boot param block 0x%08x (org %08x) IP %08x LR %08x\n", pAddr, address, hCPU->instructionPointer, hCPU->spr.LR);
+			cemuLog_logDebug(LogType::Force, "Access cached u32 boot param block 0x{:08x} (org {:08x}) IP {:08x}", pAddr, address, hCPU->instructionPointer);
 		}
 
 		if (pAddr >= 0x0c000000 && pAddr < 0x0d100000)
@@ -427,9 +428,6 @@ public:
 	}
 };
 
-uint32 testIP[100];
-uint32 testIPC = 0;
-
 template <typename ppcItpCtrl>
 class PPCInterpreterContainer
 {
@@ -456,7 +454,7 @@ public:
 		{
 		case 0:
 			debug_printf("ZERO[NOP] | 0x%08X\n", (unsigned int)hCPU->instructionPointer);
-	#ifndef PUBLIC_RELEASE		
+	#ifdef CEMU_DEBUG_ASSERT		
 			assert_dbg();
 			while (true) std::this_thread::sleep_for(std::chrono::seconds(1));
 	#endif
@@ -465,6 +463,10 @@ public:
 		case 1: // virtual HLE
 			PPCInterpreter_virtualHLE(hCPU, opcode);
 			break;
+		case 3:
+			cemuLog_logDebug(LogType::Force, "Unsupported TWI instruction executed at {:08x}", hCPU->instructionPointer);
+			PPCInterpreter_nextInstruction(hCPU);
+			break;
 		case 4:
 			switch (PPC_getBits(opcode, 30, 5))
 			{
@@ -481,8 +483,9 @@ public:
 					PPCInterpreter_PS_CMPU1(hCPU, opcode);
 					break;
 				default:
-					debug_printf("Unknown execute %04X as [4->0] at %08X\n", PPC_getBits(opcode, 25, 5), hCPU->instructionPointer);
+					cemuLog_logDebug(LogType::Force, "Unknown execute {:04x} as [4->0] at {:08x}", PPC_getBits(opcode, 25, 5), hCPU->instructionPointer);
 					cemu_assert_unimplemented();
+					hCPU->instructionPointer += 4;
 					break;
 				}
 				break;
@@ -508,8 +511,9 @@ public:
 					PPCInterpreter_PS_ABS(hCPU, opcode);
 					break;
 				default:
-					debug_printf("Unknown execute %04X as [4->8] at %08X\n", PPC_getBits(opcode, 25, 5), hCPU->instructionPointer);
+					cemuLog_logDebug(LogType::Force, "Unknown execute {:04x} as [4->8] at {:08x}", PPC_getBits(opcode, 25, 5), hCPU->instructionPointer);
 					cemu_assert_unimplemented();
+					hCPU->instructionPointer += 4;
 					break;
 				}
 				break;
@@ -547,8 +551,9 @@ public:
 					PPCInterpreter_PS_MERGE11(hCPU, opcode);
 					break;
 				default:
-					debug_printf("Unknown execute %04X as [4->16] at %08X\n", PPC_getBits(opcode, 25, 5), hCPU->instructionPointer);
-					debugBreakpoint();
+					cemuLog_logDebug(LogType::Force, "Unknown execute {:04x} as [4->16] at {:08x}", PPC_getBits(opcode, 25, 5), hCPU->instructionPointer);
+					cemu_assert_unimplemented();
+					hCPU->instructionPointer += 4;
 					break;
 				}
 				break;
@@ -589,8 +594,9 @@ public:
 				PPCInterpreter_PS_NMADD(hCPU, opcode);
 				break;
 			default:
-				debug_printf("Unknown execute %04X as [4] at %08X\n", PPC_getBits(opcode, 30, 5), hCPU->instructionPointer);
+				cemuLog_logDebug(LogType::Force, "Unknown execute {:04x} as [4] at {:08x}", PPC_getBits(opcode, 30, 5), hCPU->instructionPointer);
 				cemu_assert_unimplemented();
+				hCPU->instructionPointer += 4;
 				break;
 			}
 			break;
@@ -622,12 +628,15 @@ public:
 			PPCInterpreter_BCX(hCPU, opcode);
 			break;
 		case 17:
-			if (PPC_getBits(opcode, 30, 1) == 1) {
+			if (PPC_getBits(opcode, 30, 1) == 1)
+			{
 				PPCInterpreter_SC(hCPU, opcode);
 			}
-			else {
-				debug_printf("Unsupported Opcode [0x17 --> 0x0]\n");
+			else
+			{
+				cemuLog_logDebug(LogType::Force, "Unsupported Opcode [0x17 --> 0x0]");
 				cemu_assert_unimplemented();
+				hCPU->instructionPointer += 4;
 			}
 			break;
 		case 18:
@@ -657,6 +666,9 @@ public:
 			case 193:
 				PPCInterpreter_CRXOR(hCPU, opcode);
 				break;
+			case 225:
+				PPCInterpreter_CRNAND(hCPU, opcode);
+				break;
 			case 257:
 				PPCInterpreter_CRAND(hCPU, opcode);
 				break;
@@ -673,8 +685,9 @@ public:
 				PPCInterpreter_BCCTR(hCPU, opcode);
 				break;
 			default:
-				debug_printf("Unknown execute %04X as [19] at %08X\n", PPC_getBits(opcode, 30, 10), hCPU->instructionPointer);
+				cemuLog_logDebug(LogType::Force, "Unknown execute {:04x} as [19] at {:08x}\n", PPC_getBits(opcode, 30, 10), hCPU->instructionPointer);
 				cemu_assert_unimplemented();
+				hCPU->instructionPointer += 4;
 				break;
 			}
 			break;
@@ -712,9 +725,6 @@ public:
 				PPCInterpreter_CMP(hCPU, opcode);
 				break;
 			case 4:
-	#ifndef PUBLIC_RELEASE
-				debug_printf("TW instruction executed at %08x\n", hCPU->instructionPointer);
-	#endif
 				PPCInterpreter_TW(hCPU, opcode);
 				break;
 			case 8:
@@ -894,6 +904,12 @@ public:
 			case 522:
 				PPCInterpreter_ADDCO(hCPU, opcode);
 				break;
+			case 523: // 11 | OE
+				PPCInterpreter_MULHWU_(hCPU, opcode); // OE is ignored
+				break;
+			case 533:
+				PPCInterpreter_LSWX(hCPU, opcode);
+				break;
 			case 534:
 				PPCInterpreter_LWBRX(hCPU, opcode);
 				break;
@@ -912,6 +928,9 @@ public:
 			case 567:
 				PPCInterpreter_LFSUX(hCPU, opcode);
 				break;
+			case 587: // 75 | OE
+				PPCInterpreter_MULHW_(hCPU, opcode); // OE is ignored for MULHW
+				break;
 			case 595:
 				PPCInterpreter_MFSR(hCPU, opcode);
 				break;
@@ -942,15 +961,30 @@ public:
 			case 663:
 				PPCInterpreter_STFSX(hCPU, opcode);
 				break;
+			case 661:
+				PPCInterpreter_STSWX(hCPU, opcode);
+				break;
 			case 695:
 				PPCInterpreter_STFSUX(hCPU, opcode);
 				break;
+			case 712: // 200 | OE
+				PPCInterpreter_SUBFZEO(hCPU, opcode);
+				break;
+			case 714: // 202 | OE
+				PPCInterpreter_ADDZEO(hCPU, opcode);
+				break;
 			case 725:
 				PPCInterpreter_STSWI(hCPU, opcode);
 				break;
 			case 727:
 				PPCInterpreter_STFDX(hCPU, opcode);
 				break;
+			case 744: // 232 | OE
+				PPCInterpreter_SUBFMEO(hCPU, opcode);
+				break;
+			case 746: // 234 | OE
+				PPCInterpreter_ADDMEO(hCPU, opcode);
+				break;
 			case 747:
 				PPCInterpreter_MULLWO(hCPU, opcode);
 				break;
@@ -997,10 +1031,8 @@ public:
 				PPCInterpreter_DCBZ(hCPU, opcode);
 				break;
 			default:
-				debug_printf("Unknown execute %04X as [31] at %08X\n", PPC_getBits(opcode, 30, 10), hCPU->instructionPointer);
-	#ifndef PUBLIC_RELEASE
-				assert_dbg();
-	#endif
+				cemuLog_logDebug(LogType::Force, "Unknown execute {:04x} as [31] at {:08x}\n", PPC_getBits(opcode, 30, 10), hCPU->instructionPointer);
+				cemu_assert_unimplemented();
 				hCPU->instructionPointer += 4;
 				break;
 			}
@@ -1083,7 +1115,7 @@ public:
 		case 57:
 			PPCInterpreter_PSQ_LU(hCPU, opcode);
 			break;
-		case 59: //Opcode category
+		case 59: // opcode category
 			switch (PPC_getBits(opcode, 30, 5))
 			{
 			case 18:
@@ -1114,8 +1146,9 @@ public:
 				PPCInterpreter_FNMADDS(hCPU, opcode);
 				break;
 			default:
-				debug_printf("Unknown execute %04X as [59] at %08X\n", PPC_getBits(opcode, 30, 10), hCPU->instructionPointer);
+				cemuLog_logDebug(LogType::Force, "Unknown execute {:04x} as [59] at {:08x}\n", PPC_getBits(opcode, 30, 10), hCPU->instructionPointer);
 				cemu_assert_unimplemented();
+				hCPU->instructionPointer += 4;
 				break;
 			}
 			break;
@@ -1194,18 +1227,19 @@ public:
 				case 583:
 					PPCInterpreter_MFFS(hCPU, opcode);
 					break;
-				case 711: // IBM documentation has this wrong as 771?
+				case 711:
 					PPCInterpreter_MTFSF(hCPU, opcode);
 					break;
 				default:
-					debug_printf("Unknown execute %04X as [63] at %08X\n", PPC_getBits(opcode, 30, 10), hCPU->instructionPointer);
+					cemuLog_logDebug(LogType::Force, "Unknown execute {:04x} as [63] at {:08x}\n", PPC_getBits(opcode, 30, 10), hCPU->instructionPointer);
 					cemu_assert_unimplemented();
+					PPCInterpreter_nextInstruction(hCPU);
 					break;
 				}
 			}
 			break;
 		default:
-			debug_printf("Unknown execute %04X at %08X\n", PPC_getBits(opcode, 5, 6), (unsigned int)hCPU->instructionPointer);
+			cemuLog_logDebug(LogType::Force, "Unknown execute {:04x} at {:08x}\n", PPC_getBits(opcode, 5, 6), (unsigned int)hCPU->instructionPointer);
 			cemu_assert_unimplemented();
 		}
 	}
diff --git a/src/Cafe/HW/Espresso/Interpreter/PPCInterpreterInternal.h b/src/Cafe/HW/Espresso/Interpreter/PPCInterpreterInternal.h
index bc8458d9..896fd21c 100644
--- a/src/Cafe/HW/Espresso/Interpreter/PPCInterpreterInternal.h
+++ b/src/Cafe/HW/Espresso/Interpreter/PPCInterpreterInternal.h
@@ -50,9 +50,9 @@
 #define CR_BIT_EQ	2
 #define CR_BIT_SO	3
 
-#define XER_SO			(1<<31)	// summary overflow bit
-#define XER_OV			(1<<30)	// overflow bit
 #define XER_BIT_CA		(29)	// carry bit index. To accelerate frequent access, this bit is stored as a separate uint8
+#define XER_BIT_SO		(31)	// summary overflow, counterpart to CR SO
+#define XER_BIT_OV		(30)
 
 // FPSCR
 #define FPSCR_VXSNAN	(1<<24)
@@ -118,7 +118,8 @@
 
 static inline void ppc_update_cr0(PPCInterpreter_t* hCPU, uint32 r)
 {
-	hCPU->cr[CR_BIT_SO] = (hCPU->spr.XER&XER_SO) ? 1 : 0;
+	cemu_assert_debug(hCPU->xer_so <= 1);
+	hCPU->cr[CR_BIT_SO] = hCPU->xer_so;
 	hCPU->cr[CR_BIT_LT] = ((r != 0) ? 1 : 0) & ((r & 0x80000000) ? 1 : 0);
 	hCPU->cr[CR_BIT_EQ] = (r == 0);
 	hCPU->cr[CR_BIT_GT] = hCPU->cr[CR_BIT_EQ] ^ hCPU->cr[CR_BIT_LT] ^ 1;  // this works because EQ and LT can never be set at the same time. So the only case where GT becomes 1 is when LT=0 and EQ=0
@@ -190,8 +191,8 @@ inline double roundTo25BitAccuracy(double d)
 	return *(double*)&v;
 }
 
-double fres_espresso(double input);
-double frsqrte_espresso(double input);
+ATTR_MS_ABI double fres_espresso(double input);
+ATTR_MS_ABI double frsqrte_espresso(double input);
 
 void fcmpu_espresso(PPCInterpreter_t* hCPU, int crfD, double a, double b);
 
diff --git a/src/Cafe/HW/Espresso/Interpreter/PPCInterpreterLoadStore.hpp b/src/Cafe/HW/Espresso/Interpreter/PPCInterpreterLoadStore.hpp
index 694e05e6..ea7bb038 100644
--- a/src/Cafe/HW/Espresso/Interpreter/PPCInterpreterLoadStore.hpp
+++ b/src/Cafe/HW/Espresso/Interpreter/PPCInterpreterLoadStore.hpp
@@ -31,7 +31,7 @@ static void PPCInterpreter_STW(PPCInterpreter_t* hCPU, uint32 Opcode)
 
 static void PPCInterpreter_STWU(PPCInterpreter_t* hCPU, uint32 Opcode)
 {
-	int rA, rS;
+	sint32 rA, rS;
 	uint32 imm;
 	PPC_OPC_TEMPL_D_SImm(Opcode, rS, rA, imm);
 	ppcItpCtrl::ppcMem_writeDataU32(hCPU, hCPU->gpr[rA] + imm, hCPU->gpr[rS]);
@@ -42,7 +42,7 @@ static void PPCInterpreter_STWU(PPCInterpreter_t* hCPU, uint32 Opcode)
 
 static void PPCInterpreter_STWX(PPCInterpreter_t* hCPU, uint32 Opcode)
 {
-	int rA, rS, rB;
+	sint32 rA, rS, rB;
 	PPC_OPC_TEMPL_X(Opcode, rS, rA, rB);
 	ppcItpCtrl::ppcMem_writeDataU32(hCPU, (rA ? hCPU->gpr[rA] : 0) + hCPU->gpr[rB], hCPU->gpr[rS]);
 	PPCInterpreter_nextInstruction(hCPU);
@@ -85,7 +85,8 @@ static void PPCInterpreter_STWCX(PPCInterpreter_t* hCPU, uint32 Opcode)
 			ppc_setCRBit(hCPU, CR_BIT_GT, 0);
 			ppc_setCRBit(hCPU, CR_BIT_EQ, 1);
 		}
-		ppc_setCRBit(hCPU, CR_BIT_SO, (hCPU->spr.XER&XER_SO) != 0 ? 1 : 0);
+		cemu_assert_debug(hCPU->xer_so <= 1);
+		ppc_setCRBit(hCPU, CR_BIT_SO, hCPU->xer_so);
 		// remove reservation
 		hCPU->reservedMemAddr = 0;
 		hCPU->reservedMemValue = 0;
@@ -102,7 +103,7 @@ static void PPCInterpreter_STWCX(PPCInterpreter_t* hCPU, uint32 Opcode)
 
 static void PPCInterpreter_STWUX(PPCInterpreter_t* hCPU, uint32 Opcode)
 {
-	int rA, rS, rB;
+	sint32 rA, rS, rB;
 	PPC_OPC_TEMPL_X(Opcode, rS, rA, rB);
 	ppcItpCtrl::ppcMem_writeDataU32(hCPU, (rA ? hCPU->gpr[rA] : 0) + hCPU->gpr[rB], hCPU->gpr[rS]);
 	if (rA)
@@ -112,7 +113,7 @@ static void PPCInterpreter_STWUX(PPCInterpreter_t* hCPU, uint32 Opcode)
 
 static void PPCInterpreter_STWBRX(PPCInterpreter_t* hCPU, uint32 Opcode)
 {
-	int rA, rS, rB;
+	sint32 rA, rS, rB;
 	PPC_OPC_TEMPL_X(Opcode, rS, rA, rB);
 	ppcItpCtrl::ppcMem_writeDataU32(hCPU, (rA ? hCPU->gpr[rA] : 0) + hCPU->gpr[rB], _swapEndianU32(hCPU->gpr[rS]));
 	PPCInterpreter_nextInstruction(hCPU);
@@ -120,7 +121,7 @@ static void PPCInterpreter_STWBRX(PPCInterpreter_t* hCPU, uint32 Opcode)
 
 static void PPCInterpreter_STMW(PPCInterpreter_t* hCPU, uint32 Opcode)
 {
-	int rS, rA;
+	sint32 rS, rA;
 	uint32 imm;
 	PPC_OPC_TEMPL_D_SImm(Opcode, rS, rA, imm);
 	uint32 ea = (rA ? hCPU->gpr[rA] : 0) + imm;
@@ -135,7 +136,7 @@ static void PPCInterpreter_STMW(PPCInterpreter_t* hCPU, uint32 Opcode)
 
 static void PPCInterpreter_STH(PPCInterpreter_t* hCPU, uint32 Opcode)
 {
-	int rA, rS;
+	sint32 rA, rS;
 	uint32 imm;
 	PPC_OPC_TEMPL_D_SImm(Opcode, rS, rA, imm);
 	ppcItpCtrl::ppcMem_writeDataU16(hCPU, (rA ? hCPU->gpr[rA] : 0) + imm, (uint16)hCPU->gpr[rS]);
@@ -144,7 +145,7 @@ static void PPCInterpreter_STH(PPCInterpreter_t* hCPU, uint32 Opcode)
 
 static void PPCInterpreter_STHU(PPCInterpreter_t* hCPU, uint32 Opcode)
 {
-	int rA, rS;
+	sint32 rA, rS;
 	uint32 imm;
 	PPC_OPC_TEMPL_D_SImm(Opcode, rS, rA, imm);
 	ppcItpCtrl::ppcMem_writeDataU16(hCPU, (rA ? hCPU->gpr[rA] : 0) + imm, (uint16)hCPU->gpr[rS]);
@@ -155,7 +156,7 @@ static void PPCInterpreter_STHU(PPCInterpreter_t* hCPU, uint32 Opcode)
 
 static void PPCInterpreter_STHX(PPCInterpreter_t* hCPU, uint32 Opcode)
 {
-	int rA, rS, rB;
+	sint32 rA, rS, rB;
 	PPC_OPC_TEMPL_X(Opcode, rS, rA, rB);
 	ppcItpCtrl::ppcMem_writeDataU16(hCPU, (rA ? hCPU->gpr[rA] : 0) + hCPU->gpr[rB], (uint16)hCPU->gpr[rS]);
 	PPCInterpreter_nextInstruction(hCPU);
@@ -163,7 +164,7 @@ static void PPCInterpreter_STHX(PPCInterpreter_t* hCPU, uint32 Opcode)
 
 static void PPCInterpreter_STHUX(PPCInterpreter_t* hCPU, uint32 Opcode)
 {
-	int rA, rS, rB;
+	sint32 rA, rS, rB;
 	PPC_OPC_TEMPL_X(Opcode, rS, rA, rB);
 	ppcItpCtrl::ppcMem_writeDataU16(hCPU, (rA ? hCPU->gpr[rA] : 0) + hCPU->gpr[rB], (uint16)hCPU->gpr[rS]);
 	if (rA)
@@ -173,7 +174,7 @@ static void PPCInterpreter_STHUX(PPCInterpreter_t* hCPU, uint32 Opcode)
 
 static void PPCInterpreter_STHBRX(PPCInterpreter_t* hCPU, uint32 Opcode)
 {
-	int rA, rS, rB;
+	sint32 rA, rS, rB;
 	PPC_OPC_TEMPL_X(Opcode, rS, rA, rB);
 	ppcItpCtrl::ppcMem_writeDataU16(hCPU, (rA ? hCPU->gpr[rA] : 0) + hCPU->gpr[rB], _swapEndianU16((uint16)hCPU->gpr[rS]));
 	PPCInterpreter_nextInstruction(hCPU);
@@ -181,7 +182,7 @@ static void PPCInterpreter_STHBRX(PPCInterpreter_t* hCPU, uint32 Opcode)
 
 static void PPCInterpreter_STB(PPCInterpreter_t* hCPU, uint32 Opcode)
 {
-	int rA, rS;
+	sint32 rA, rS;
 	uint32 imm;
 	PPC_OPC_TEMPL_D_SImm(Opcode, rS, rA, imm);
 	ppcItpCtrl::ppcMem_writeDataU8(hCPU, (rA ? hCPU->gpr[rA] : 0) + imm, (uint8)hCPU->gpr[rS]);
@@ -190,7 +191,7 @@ static void PPCInterpreter_STB(PPCInterpreter_t* hCPU, uint32 Opcode)
 
 static void PPCInterpreter_STBU(PPCInterpreter_t* hCPU, uint32 Opcode)
 {
-	int rA, rS;
+	sint32 rA, rS;
 	uint32 imm;
 	PPC_OPC_TEMPL_D_SImm(Opcode, rS, rA, imm);
 	ppcItpCtrl::ppcMem_writeDataU8(hCPU, hCPU->gpr[rA] + imm, (uint8)hCPU->gpr[rS]);
@@ -200,7 +201,7 @@ static void PPCInterpreter_STBU(PPCInterpreter_t* hCPU, uint32 Opcode)
 
 static void PPCInterpreter_STBX(PPCInterpreter_t* hCPU, uint32 Opcode)
 {
-	int rA, rS, rB;
+	sint32 rA, rS, rB;
 	PPC_OPC_TEMPL_X(Opcode, rS, rA, rB);
 	ppcItpCtrl::ppcMem_writeDataU8(hCPU, (rA ? hCPU->gpr[rA] : 0) + hCPU->gpr[rB], (uint8)hCPU->gpr[rS]);
 	PPCInterpreter_nextInstruction(hCPU);
@@ -208,7 +209,7 @@ static void PPCInterpreter_STBX(PPCInterpreter_t* hCPU, uint32 Opcode)
 
 static void PPCInterpreter_STBUX(PPCInterpreter_t* hCPU, uint32 Opcode)
 {
-	int rA, rS, rB;
+	sint32 rA, rS, rB;
 	PPC_OPC_TEMPL_X(Opcode, rS, rA, rB);
 	ppcItpCtrl::ppcMem_writeDataU8(hCPU, (rA ? hCPU->gpr[rA] : 0) + hCPU->gpr[rB], (uint8)hCPU->gpr[rS]);
 	if (rA)
@@ -218,7 +219,7 @@ static void PPCInterpreter_STBUX(PPCInterpreter_t* hCPU, uint32 Opcode)
 
 static void PPCInterpreter_STSWI(PPCInterpreter_t* hCPU, uint32 Opcode)
 {
-	int rA, rS, nb;
+	sint32 rA, rS, nb;
 	PPC_OPC_TEMPL_X(Opcode, rS, rA, nb);
 	if (nb == 0) nb = 32;
 	uint32 ea = rA ? hCPU->gpr[rA] : 0;
@@ -228,7 +229,39 @@ static void PPCInterpreter_STSWI(PPCInterpreter_t* hCPU, uint32 Opcode)
 	{
 		if (i == 0)
 		{
-			r = hCPU->gpr[rS];
+			r = rS < 32 ? hCPU->gpr[rS] : 0; // what happens if rS is out of bounds?
+			rS++;
+			rS %= 32;
+			i = 4;
+		}
+		ppcItpCtrl::ppcMem_writeDataU8(hCPU, ea, (r >> 24));
+		r <<= 8;
+		ea++;
+		i--;
+		nb--;
+	}
+	PPCInterpreter_nextInstruction(hCPU);
+}
+
+static void PPCInterpreter_STSWX(PPCInterpreter_t* hCPU, uint32 Opcode)
+{
+	sint32 rA, rS, rB;
+	PPC_OPC_TEMPL_X(Opcode, rS, rA, rB);
+	sint32 nb = hCPU->spr.XER&0x7F;
+	if (nb == 0)
+	{
+		PPCInterpreter_nextInstruction(hCPU);
+		return;
+	}
+	uint32 ea = rA ? hCPU->gpr[rA] : 0;
+	ea += hCPU->gpr[rB];
+	uint32 r = 0;
+	int i = 0;
+	while (nb > 0)
+	{
+		if (i == 0)
+		{
+			r = rS < 32 ? hCPU->gpr[rS] : 0; // what happens if rS is out of bounds?
 			rS++;
 			rS %= 32;
 			i = 4;
@@ -459,7 +492,6 @@ static void PPCInterpreter_LSWI(PPCInterpreter_t* hCPU, uint32 Opcode)
 	PPC_OPC_TEMPL_X(Opcode, rD, rA, nb);
 	if (nb == 0)
 		nb = 32;
-
 	uint32 ea = rA ? hCPU->gpr[rA] : 0;
 	uint32 r = 0;
 	int i = 4;
@@ -469,7 +501,8 @@ static void PPCInterpreter_LSWI(PPCInterpreter_t* hCPU, uint32 Opcode)
 		if (i == 0)
 		{
 			i = 4;
-			hCPU->gpr[rD] = r;
+			if(rD < 32)
+				hCPU->gpr[rD] = r;
 			rD++;
 			rD %= 32;
 			r = 0;
@@ -486,7 +519,52 @@ static void PPCInterpreter_LSWI(PPCInterpreter_t* hCPU, uint32 Opcode)
 		r <<= 8;
 		i--;
 	}
-	hCPU->gpr[rD] = r;
+	if(rD < 32)
+		hCPU->gpr[rD] = r;
+	PPCInterpreter_nextInstruction(hCPU);
+}
+
+static void PPCInterpreter_LSWX(PPCInterpreter_t* hCPU, uint32 Opcode)
+{
+	sint32 rA, rD, rB;
+	PPC_OPC_TEMPL_X(Opcode, rD, rA, rB);
+	// byte count comes from XER
+	uint32 nb = (hCPU->spr.XER>>0)&0x7F;
+	if (nb == 0)
+	{
+		PPCInterpreter_nextInstruction(hCPU);
+		return; // no-op
+	}
+	uint32 ea = rA ? hCPU->gpr[rA] : 0;
+	ea += hCPU->gpr[rB];
+	uint32 r = 0;
+	int i = 4;
+	uint8 v;
+	while (nb>0)
+	{
+		if (i == 0)
+		{
+			i = 4;
+			if(rD < 32)
+				hCPU->gpr[rD] = r;
+			rD++;
+			rD %= 32;
+			r = 0;
+		}
+		v = ppcItpCtrl::ppcMem_readDataU8(hCPU, ea);
+		r <<= 8;
+		r |= v;
+		ea++;
+		i--;
+		nb--;
+	}
+	while (i)
+	{
+		r <<= 8;
+		i--;
+	}
+	if(rD < 32)
+		hCPU->gpr[rD] = r;
 	PPCInterpreter_nextInstruction(hCPU);
 }
 
diff --git a/src/Cafe/HW/Espresso/Interpreter/PPCInterpreterMain.cpp b/src/Cafe/HW/Espresso/Interpreter/PPCInterpreterMain.cpp
index 2d808fef..4449f135 100644
--- a/src/Cafe/HW/Espresso/Interpreter/PPCInterpreterMain.cpp
+++ b/src/Cafe/HW/Espresso/Interpreter/PPCInterpreterMain.cpp
@@ -6,7 +6,6 @@
 thread_local PPCInterpreter_t* ppcInterpreterCurrentInstance;
 
 // main thread instruction counter and timing
-volatile uint64 ppcMainThreadCycleCounter = 0;
 uint64 ppcMainThreadDECCycleValue = 0; // value that was set to dec register
 uint64 ppcMainThreadDECCycleStart = 0; // at which cycle the dec register was set, if == 0 -> dec is 0
 uint64 ppcCyclesSince2000 = 0;
@@ -29,11 +28,16 @@ PPCInterpreter_t* PPCInterpreter_createInstance(unsigned int Entrypoint)
 	return pData;
 }
 
-PPCInterpreter_t* PPCInterpreter_getCurrentInstance()
+TLS_WORKAROUND_NOINLINE PPCInterpreter_t* PPCInterpreter_getCurrentInstance()
 {
 	return ppcInterpreterCurrentInstance;
 }
 
+TLS_WORKAROUND_NOINLINE void PPCInterpreter_setCurrentInstance(PPCInterpreter_t* hCPU)
+{
+	ppcInterpreterCurrentInstance = hCPU;
+}
+
 uint64 PPCInterpreter_getMainCoreCycleCounter()
 {
 	return PPCTimer_getFromRDTSC();
@@ -59,16 +63,25 @@ void PPCInterpreter_setDEC(PPCInterpreter_t* hCPU, uint32 newValue)
 uint32 PPCInterpreter_getXER(PPCInterpreter_t* hCPU)
 {
 	uint32 xerValue = hCPU->spr.XER;
-	xerValue &= ~(1<<XER_BIT_CA);
-	if( hCPU->xer_ca )
-		xerValue |= (1<<XER_BIT_CA);
+	xerValue &= ~(1 << XER_BIT_CA);
+	xerValue &= ~(1 << XER_BIT_SO);
+	xerValue &= ~(1 << XER_BIT_OV);
+	if (hCPU->xer_ca)
+		xerValue |= (1 << XER_BIT_CA);
+	if (hCPU->xer_so)
+		xerValue |= (1 << XER_BIT_SO);
+	if (hCPU->xer_ov)
+		xerValue |= (1 << XER_BIT_OV);
 	return xerValue;
 }
 
 void PPCInterpreter_setXER(PPCInterpreter_t* hCPU, uint32 v)
 {
-	hCPU->spr.XER = v;
-	hCPU->xer_ca = (v>>XER_BIT_CA)&1;
+	const uint32 XER_MASK = 0xE0FFFFFF; // some bits are masked out. Figure out which ones exactly
+	hCPU->spr.XER = v & XER_MASK;
+	hCPU->xer_ca = (v >> XER_BIT_CA) & 1;
+	hCPU->xer_so = (v >> XER_BIT_SO) & 1;
+	hCPU->xer_ov = (v >> XER_BIT_OV) & 1;
 }
 
 uint32 PPCInterpreter_getCoreIndex(PPCInterpreter_t* hCPU)
@@ -78,24 +91,25 @@ uint32 PPCInterpreter_getCoreIndex(PPCInterpreter_t* hCPU)
 
 uint32 PPCInterpreter_getCurrentCoreIndex()
 {
-	return ppcInterpreterCurrentInstance->spr.UPIR;
+	return PPCInterpreter_getCurrentInstance()->spr.UPIR;
 };
 
 uint8* PPCInterpreterGetStackPointer()
 {
-	return memory_getPointerFromVirtualOffset(ppcInterpreterCurrentInstance->gpr[1]);
+	return memory_getPointerFromVirtualOffset(PPCInterpreter_getCurrentInstance()->gpr[1]);
 }
 
-uint8* PPCInterpreterGetAndModifyStackPointer(sint32 offset)
+uint8* PPCInterpreter_PushAndReturnStackPointer(sint32 offset)
 {
-	uint8* result = memory_getPointerFromVirtualOffset(ppcInterpreterCurrentInstance->gpr[1] - offset);
-	ppcInterpreterCurrentInstance->gpr[1] -= offset;
+	PPCInterpreter_t* hCPU = PPCInterpreter_getCurrentInstance();
+	uint8* result = memory_getPointerFromVirtualOffset(hCPU->gpr[1] - offset);
+	hCPU->gpr[1] -= offset;
 	return result;
 }
 
 void PPCInterpreterModifyStackPointer(sint32 offset)
 {
-	ppcInterpreterCurrentInstance->gpr[1] -= offset;
+	PPCInterpreter_getCurrentInstance()->gpr[1] -= offset;
 }
 
 uint32 RPLLoader_MakePPCCallable(void(*ppcCallableExport)(PPCInterpreter_t* hCPU));
diff --git a/src/Cafe/HW/Espresso/Interpreter/PPCInterpreterOPC.cpp b/src/Cafe/HW/Espresso/Interpreter/PPCInterpreterOPC.cpp
index 7178eaeb..7809a01d 100644
--- a/src/Cafe/HW/Espresso/Interpreter/PPCInterpreterOPC.cpp
+++ b/src/Cafe/HW/Espresso/Interpreter/PPCInterpreterOPC.cpp
@@ -5,14 +5,13 @@
 #include "Cafe/OS/libs/coreinit/coreinit_CodeGen.h"
 
 #include "../Recompiler/PPCRecompiler.h"
-#include "../Recompiler/PPCRecompilerX64.h"
 
 #include <float.h>
 #include "Cafe/HW/Latte/Core/LatteBufferCache.h"
 
 void PPCInterpreter_MFMSR(PPCInterpreter_t* hCPU, uint32 Opcode)
 {
-	forceLogDebug_printf("Rare instruction: MFMSR");
+	cemuLog_logDebug(LogType::Force, "Rare instruction: MFMSR");
 	if (hCPU->sprExtended.msr & MSR_PR)
 	{
 		PPC_ASSERT(true);
@@ -28,7 +27,7 @@ void PPCInterpreter_MFMSR(PPCInterpreter_t* hCPU, uint32 Opcode)
 
 void PPCInterpreter_MTMSR(PPCInterpreter_t* hCPU, uint32 Opcode)
 {
-	forceLogDebug_printf("Rare instruction: MTMSR");
+	cemuLog_logDebug(LogType::Force, "Rare instruction: MTMSR");
 	if (hCPU->sprExtended.msr & MSR_PR)
 	{
 		PPC_ASSERT(true);
@@ -43,7 +42,7 @@ void PPCInterpreter_MTMSR(PPCInterpreter_t* hCPU, uint32 Opcode)
 
 void PPCInterpreter_MTFSB1X(PPCInterpreter_t* hCPU, uint32 Opcode)
 {
-	forceLogDebug_printf("Rare instruction: MTFSB1X");
+	cemuLog_logDebug(LogType::Force, "Rare instruction: MTFSB1X");
 	int crbD, n1, n2;
 	PPC_OPC_TEMPL_X(Opcode, crbD, n1, n2);
 	if (crbD != 1 && crbD != 2) 
@@ -94,7 +93,6 @@ void PPCInterpreter_MTCRF(PPCInterpreter_t* hCPU, uint32 Opcode)
 {
 	// frequently used by GCC compiled code (e.g. SM64 port)
 	// tested
-
 	uint32 rS;
 	uint32 crfMask;
 	PPC_OPC_TEMPL_XFX(Opcode, rS, crfMask);
@@ -212,7 +210,7 @@ void PPCInterpreter_BCLRX(PPCInterpreter_t* hCPU, uint32 Opcode)
 		if (hCPU->spr.CTR == 0)
 		{
 			PPC_ASSERT(true);
-			forceLogDebug_printf("Decrementer underflow!\n");
+			cemuLog_logDebug(LogType::Force, "Decrementer underflow!");
 		}
 		hCPU->spr.CTR--;
 	}
@@ -331,7 +329,7 @@ void PPCInterpreter_EIEIO(PPCInterpreter_t* hCPU, uint32 Opcode)
 
 void PPCInterpreter_SC(PPCInterpreter_t* hCPU, uint32 Opcode)
 {
-	forceLogDebug_printf("SC executed at 0x%08x", hCPU->instructionPointer);
+	cemuLog_logDebug(LogType::Force, "SC executed at 0x{:08x}", hCPU->instructionPointer);
 	// next instruction
 	PPCInterpreter_nextInstruction(hCPU);
 }
@@ -352,7 +350,7 @@ void PPCInterpreter_ISYNC(PPCInterpreter_t* hCPU, uint32 Opcode)
 
 void PPCInterpreter_RFI(PPCInterpreter_t* hCPU, uint32 Opcode)
 {
-	forceLogDebug_printf("RFI");
+	cemuLog_logDebug(LogType::Force, "RFI");
 	hCPU->sprExtended.msr &= ~(0x87C0FF73 | 0x00040000);
 	hCPU->sprExtended.msr |= hCPU->sprExtended.srr1 & 0x87c0ff73;
 	hCPU->sprExtended.msr |= MSR_RI;
diff --git a/src/Cafe/HW/Espresso/Interpreter/PPCInterpreterOPC.hpp b/src/Cafe/HW/Espresso/Interpreter/PPCInterpreterOPC.hpp
index 4da41590..9bfcd53d 100644
--- a/src/Cafe/HW/Espresso/Interpreter/PPCInterpreterOPC.hpp
+++ b/src/Cafe/HW/Espresso/Interpreter/PPCInterpreterOPC.hpp
@@ -65,9 +65,14 @@ static void PPCInterpreter_MFTB(PPCInterpreter_t* hCPU, uint32 opcode)
 static void PPCInterpreter_TW(PPCInterpreter_t* hCPU, uint32 opcode)
 {
 	sint32 to, rA, rB;
-	PPC_OPC_TEMPL_X(opcode, to, rB, rA);
+	PPC_OPC_TEMPL_X(opcode, to, rA, rB);
 
 	cemu_assert_debug(to == 0);
+	if(to != 0)
+		PPCInterpreter_nextInstruction(hCPU);
 
-	debugger_enterTW(hCPU);
+    if (rA == DEBUGGER_BP_T_DEBUGGER)
+	    debugger_enterTW(hCPU);
+    else if (rA == DEBUGGER_BP_T_GDBSTUB)
+        g_gdbstub->HandleTrapInstruction(hCPU);
 }
diff --git a/src/Cafe/HW/Espresso/Interpreter/PPCInterpreterSPR.hpp b/src/Cafe/HW/Espresso/Interpreter/PPCInterpreterSPR.hpp
index 819f317a..2d38e728 100644
--- a/src/Cafe/HW/Espresso/Interpreter/PPCInterpreterSPR.hpp
+++ b/src/Cafe/HW/Espresso/Interpreter/PPCInterpreterSPR.hpp
@@ -559,7 +559,7 @@ static void PPCSprSupervisor_set(PPCInterpreter_t* hCPU, uint32 spr, uint32 newV
 		break;
 	default:
 		debug_printf("[C%d] Set unhandled SPR 0x%x to %08x (supervisor mode)\n", hCPU->spr.UPIR, spr, newValue);
-#ifndef PUBLIC_RELEASE
+#ifdef CEMU_DEBUG_ASSERT
 		assert_dbg();
 #endif
 		break;
@@ -598,7 +598,7 @@ static void PPCSpr_set(PPCInterpreter_t* hCPU, uint32 spr, uint32 newValue)
 		break;
 	default:
 		debug_printf("[C%d] Set unhandled SPR %d to %08x\n", hCPU->spr.UPIR, spr, newValue);
-#ifndef PUBLIC_RELEASE
+#ifdef CEMU_DEBUG_ASSERT
 		assert_dbg();
 #endif
 		break;
@@ -782,7 +782,7 @@ static uint32 PPCSprSupervisor_get(PPCInterpreter_t* hCPU, uint32 spr)
 		break;
 	default:
 		debug_printf("[C%d] Get unhandled SPR %d\n", hCPU->spr.UPIR, spr);
-#ifndef PUBLIC_RELEASE
+#ifdef CEMU_DEBUG_ASSERT
 		assert_dbg();
 #endif
 		break;
@@ -840,7 +840,7 @@ static uint32 PPCSpr_get(PPCInterpreter_t* hCPU, uint32 spr)
 		break;
 	default:
 		debug_printf("[C%d] Get unhandled SPR %d\n", hCPU->spr.UPIR, spr);
-#ifndef PUBLIC_RELEASE
+#ifdef CEMU_DEBUG_ASSERT
 		assert_dbg();
 #endif
 		break;
diff --git a/src/Cafe/HW/Espresso/PPCCallback.h b/src/Cafe/HW/Espresso/PPCCallback.h
index 0771020d..3d5393b1 100644
--- a/src/Cafe/HW/Espresso/PPCCallback.h
+++ b/src/Cafe/HW/Espresso/PPCCallback.h
@@ -5,8 +5,28 @@ struct PPCCoreCallbackData_t
 {
 	sint32 gprCount = 0;
 	sint32 floatCount = 0;
+	sint32 stackCount = 0;
 };
 
+inline void _PPCCoreCallback_writeGPRArg(PPCCoreCallbackData_t& data, PPCInterpreter_t* hCPU, uint32 value)
+{
+	if (data.gprCount < 8)
+	{
+		hCPU->gpr[3 + data.gprCount] = value;
+		data.gprCount++;
+	}
+	else
+	{
+		uint32 stackOffset = 8 + data.stackCount * 4;
+
+		// PPCCore_executeCallbackInternal does -16*4 to save the current stack area
+		stackOffset -= 16 * 4;
+
+		memory_writeU32(hCPU->gpr[1] + stackOffset, value);
+		data.stackCount++;
+	}
+}
+
 // callback functions
 inline uint32 PPCCoreCallback(MPTR function, const PPCCoreCallbackData_t& data)
 {
@@ -16,44 +36,42 @@ inline uint32 PPCCoreCallback(MPTR function, const PPCCoreCallbackData_t& data)
 template <typename T, typename... TArgs>
 uint32 PPCCoreCallback(MPTR function, PPCCoreCallbackData_t& data, T currentArg, TArgs... args)
 {
-	cemu_assert_debug(data.gprCount <= 8);
-	cemu_assert_debug(data.floatCount <= 8);
+	// TODO float arguments on stack
+	cemu_assert_debug(data.floatCount < 8);
+
+	PPCInterpreter_t* hCPU = PPCInterpreter_getCurrentInstance();
 	if constexpr (std::is_pointer_v<T>)
 	{
-		ppcInterpreterCurrentInstance->gpr[3 + data.gprCount] = MEMPTR(currentArg).GetMPTR();
-		data.gprCount++;
+		_PPCCoreCallback_writeGPRArg(data, hCPU, MEMPTR(currentArg).GetMPTR());
 	}
 	else if constexpr (std::is_base_of_v<MEMPTRBase, std::remove_reference_t<T>>)
 	{
-		ppcInterpreterCurrentInstance->gpr[3 + data.gprCount] = currentArg.GetMPTR();
-		data.gprCount++;
+		_PPCCoreCallback_writeGPRArg(data, hCPU, currentArg.GetMPTR());
 	}
 	else if constexpr (std::is_reference_v<T>)
 	{
-		ppcInterpreterCurrentInstance->gpr[3 + data.gprCount] = MEMPTR(&currentArg).GetMPTR();
-		data.gprCount++;
+		_PPCCoreCallback_writeGPRArg(data, hCPU, MEMPTR(&currentArg).GetMPTR());
 	}
 	else if constexpr(std::is_enum_v<T>)
 	{
 		using TEnum = typename std::underlying_type<T>::type;
-		return PPCCoreCallback<TEnum>(function, data, (TEnum)currentArg, std::forward(args)...);
+		return PPCCoreCallback<TEnum>(function, data, (TEnum)currentArg, std::forward<TArgs>(args)...);
 	}
 	else if constexpr (std::is_floating_point_v<T>)
 	{
-		ppcInterpreterCurrentInstance->fpr[1 + data.floatCount].fpr = (double)currentArg;
+		hCPU->fpr[1 + data.floatCount].fpr = (double)currentArg;
 		data.floatCount++;
 	}
 	else if constexpr (std::is_integral_v<T> && sizeof(T) == sizeof(uint64))
 	{
-		ppcInterpreterCurrentInstance->gpr[3 + data.gprCount] = (uint32)(currentArg >> 32); // high
-		ppcInterpreterCurrentInstance->gpr[3 + data.gprCount + 1] = (uint32)currentArg; // low
+		hCPU->gpr[3 + data.gprCount] = (uint32)(currentArg >> 32); // high
+		hCPU->gpr[3 + data.gprCount + 1] = (uint32)currentArg; // low
 
 		data.gprCount += 2;
 	}
 	else
 	{
-		ppcInterpreterCurrentInstance->gpr[3 + data.gprCount] = (uint32)currentArg;
-		data.gprCount++;
+		_PPCCoreCallback_writeGPRArg(data, hCPU, (uint32)currentArg);
 	}
 	
 	return PPCCoreCallback(function, data, args...);
diff --git a/src/Cafe/HW/Espresso/PPCScheduler.cpp b/src/Cafe/HW/Espresso/PPCScheduler.cpp
index ab662150..a4c04aaa 100644
--- a/src/Cafe/HW/Espresso/PPCScheduler.cpp
+++ b/src/Cafe/HW/Espresso/PPCScheduler.cpp
@@ -11,21 +11,24 @@ uint32 ppcThreadQuantum = 45000; // execute 45000 instructions before thread res
 
 void PPCInterpreter_relinquishTimeslice()
 {
-	if( ppcInterpreterCurrentInstance->remainingCycles >= 0 )
+	PPCInterpreter_t* hCPU = PPCInterpreter_getCurrentInstance();
+	if( hCPU->remainingCycles >= 0 )
 	{
-		ppcInterpreterCurrentInstance->skippedCycles = ppcInterpreterCurrentInstance->remainingCycles + 1;
-		ppcInterpreterCurrentInstance->remainingCycles = -1;
+		hCPU->skippedCycles = hCPU->remainingCycles + 1;
+		hCPU->remainingCycles = -1;
 	}
 }
 
 void PPCCore_boostQuantum(sint32 numCycles)
 {
-	ppcInterpreterCurrentInstance->remainingCycles += numCycles;
+	PPCInterpreter_t* hCPU = PPCInterpreter_getCurrentInstance();
+	hCPU->remainingCycles += numCycles;
 }
 
 void PPCCore_deboostQuantum(sint32 numCycles)
 {
-	ppcInterpreterCurrentInstance->remainingCycles -= numCycles;
+	PPCInterpreter_t* hCPU = PPCInterpreter_getCurrentInstance();
+	hCPU->remainingCycles -= numCycles;
 }
 
 namespace coreinit
@@ -36,7 +39,7 @@ namespace coreinit
 void PPCCore_switchToScheduler()
 {
 	cemu_assert_debug(__OSHasSchedulerLock() == false); // scheduler lock must not be hold past thread time slice
-	cemu_assert_debug(ppcInterpreterCurrentInstance->coreInterruptMask != 0 || CafeSystem::GetForegroundTitleId() == 0x000500001019e600);
+	cemu_assert_debug(PPCInterpreter_getCurrentInstance()->coreInterruptMask != 0 || CafeSystem::GetForegroundTitleId() == 0x000500001019e600);
 	__OSLockScheduler();
 	coreinit::__OSThreadSwitchToNext();
 	__OSUnlockScheduler();
@@ -45,7 +48,7 @@ void PPCCore_switchToScheduler()
 void PPCCore_switchToSchedulerWithLock()
 {
 	cemu_assert_debug(__OSHasSchedulerLock() == true); // scheduler lock must be hold
-	cemu_assert_debug(ppcInterpreterCurrentInstance->coreInterruptMask != 0 || CafeSystem::GetForegroundTitleId() == 0x000500001019e600);
+	cemu_assert_debug(PPCInterpreter_getCurrentInstance()->coreInterruptMask != 0 || CafeSystem::GetForegroundTitleId() == 0x000500001019e600);
 	coreinit::__OSThreadSwitchToNext();
 }
 
@@ -58,7 +61,7 @@ void _PPCCore_callbackExit(PPCInterpreter_t* hCPU)
 PPCInterpreter_t* PPCCore_executeCallbackInternal(uint32 functionMPTR)
 {
 	cemu_assert_debug(functionMPTR != 0);
-	PPCInterpreter_t* hCPU = ppcInterpreterCurrentInstance;
+	PPCInterpreter_t* hCPU = PPCInterpreter_getCurrentInstance();
 	// remember LR and instruction pointer
 	uint32 lr = hCPU->spr.LR;
 	uint32 ip = hCPU->instructionPointer;
@@ -100,11 +103,6 @@ PPCInterpreter_t* PPCCore_executeCallbackInternal(uint32 functionMPTR)
 	return hCPU;
 }
 
-void PPCCore_deleteAllThreads()
-{
-	assert_dbg();
-}
-
 void PPCCore_init()
 {
 }
diff --git a/src/Cafe/HW/Espresso/PPCSchedulerLLE.cpp b/src/Cafe/HW/Espresso/PPCSchedulerLLE.cpp
index 4732586a..bb4bf9ff 100644
--- a/src/Cafe/HW/Espresso/PPCSchedulerLLE.cpp
+++ b/src/Cafe/HW/Espresso/PPCSchedulerLLE.cpp
@@ -163,7 +163,7 @@ void smdpArea_processCommand(smdpArea_t* smdpArea, smdpCommand_t* cmd)
 	{
 		cmd->ukn08 = 1;
 		// cmd->ukn2C ?
-		forceLogDebug_printf("SMDP command received - todo");
+		cemuLog_logDebug(LogType::Force, "SMDP command received - todo");
 		smdpArea_pushResult(smdpArea, memory_getVirtualOffsetFromPointer(cmd));
 	}
 	else
@@ -220,7 +220,7 @@ void PPCCoreLLE_startSingleCoreScheduler(uint32 entrypoint)
 		for (uint32 coreIndex = 0; coreIndex < 3; coreIndex++)
 		{
 			PPCInterpreter_t* hCPU = cpuContext->cores+coreIndex;
-			ppcInterpreterCurrentInstance = hCPU;
+			PPCInterpreter_setCurrentInstance(hCPU);
 			if (coreIndex == 1)
 			{
 				// check SCR core 1 enable bit
@@ -242,4 +242,4 @@ void PPCCoreLLE_startSingleCoreScheduler(uint32 entrypoint)
 		}
 	}
 	assert_dbg();
-}
\ No newline at end of file
+}
diff --git a/src/Cafe/HW/Espresso/PPCState.h b/src/Cafe/HW/Espresso/PPCState.h
index 540bbd4e..fd943d39 100644
--- a/src/Cafe/HW/Espresso/PPCState.h
+++ b/src/Cafe/HW/Espresso/PPCState.h
@@ -49,12 +49,12 @@ struct PPCInterpreter_t
 	uint32 fpscr;
 	uint8 cr[32]; // 0 -> bit not set, 1 -> bit set (upper 7 bits of each byte must always be zero) (cr0 starts at index 0, cr1 at index 4 ..)
 	uint8 xer_ca;  // carry from xer
-	uint8 LSQE;
-	uint8 PSE;
+	uint8 xer_so;
+	uint8 xer_ov;
 	// thread remaining cycles
 	sint32 remainingCycles; // if this value goes below zero, the next thread is scheduled
 	sint32 skippedCycles; // number of skipped cycles
-	struct  
+	struct
 	{
 		uint32 LR;
 		uint32 CTR;
@@ -65,12 +65,12 @@ struct PPCInterpreter_t
 	// LWARX and STWCX
 	uint32 reservedMemAddr;
 	uint32 reservedMemValue;
-	/* Note: Everything above is potentially hardcoded into Cemuhook. Do not touch anything or it will risk breaking compatibility */
 	// temporary storage for recompiler
 	FPR_t temporaryFPR[8];
-	uint32 temporaryGPR[4];
+	uint32 temporaryGPR[4]; // deprecated, refactor backend dependency on this away
+	uint32 temporaryGPR_reg[4];
 	// values below this are not used by Cafe OS usermode
-	struct  
+	struct
 	{
 		uint32 fpecr; // is this the same register as fpscr ?
 		uint32 DEC;
@@ -85,7 +85,7 @@ struct PPCInterpreter_t
 		// DMA
 		uint32 dmaU;
 		uint32 dmaL;
-		// MMU 
+		// MMU
 		uint32 dbatU[8];
 		uint32 dbatL[8];
 		uint32 ibatU[8];
@@ -93,6 +93,8 @@ struct PPCInterpreter_t
 		uint32 sr[16];
 		uint32 sdr1;
 	}sprExtended;
+	uint8 LSQE;
+	uint8 PSE;
 	// global CPU values
 	PPCInterpreterGlobal_t* global;
 	// interpreter control
@@ -150,6 +152,7 @@ static uint64 PPCInterpreter_getCallParamU64(PPCInterpreter_t* hCPU, uint32 inde
 
 PPCInterpreter_t* PPCInterpreter_createInstance(unsigned int Entrypoint);
 PPCInterpreter_t* PPCInterpreter_getCurrentInstance();
+void PPCInterpreter_setCurrentInstance(PPCInterpreter_t* hCPU);
 
 uint64 PPCInterpreter_getMainCoreCycleCounter();
 
@@ -193,7 +196,6 @@ uint32 PPCInterpreter_getCurrentCoreIndex();
 void PPCInterpreter_setDEC(PPCInterpreter_t* hCPU, uint32 newValue);
 
 // timing for main processor
-extern volatile uint64 ppcMainThreadCycleCounter;
 extern uint64 ppcCyclesSince2000; // on init this is set to the cycles that passed since 1.1.2000
 extern uint64 ppcCyclesSince2000TimerClock; // on init this is set to the cycles that passed since 1.1.2000 / 20
 extern uint64 ppcCyclesSince2000_UTC;
@@ -204,7 +206,6 @@ extern uint64 ppcMainThreadDECCycleStart; // at which cycle the dec register was
 void PPCTimer_init();
 void PPCTimer_waitForInit();
 uint64 PPCTimer_getFromRDTSC();
-bool PPCTimer_hasInvariantRDTSCSupport();
 
 uint64 PPCTimer_microsecondsToTsc(uint64 us);
 uint64 PPCTimer_tscToMicroseconds(uint64 us);
@@ -215,8 +216,7 @@ void PPCTimer_start();
 // core info and control
 extern uint32 ppcThreadQuantum;
 
-extern thread_local PPCInterpreter_t *ppcInterpreterCurrentInstance;
-uint8* PPCInterpreterGetAndModifyStackPointer(sint32 offset);
+uint8* PPCInterpreter_PushAndReturnStackPointer(sint32 offset);
 uint8* PPCInterpreterGetStackPointer();
 void PPCInterpreterModifyStackPointer(sint32 offset);
 
@@ -230,15 +230,14 @@ static inline float flushDenormalToZero(float f)
 
 // HLE interface
 
-typedef void(*HLECALL)(PPCInterpreter_t* hCPU);
+using HLECALL = void(*)(PPCInterpreter_t*);
+using HLEIDX = sint32;
 
-typedef sint32 HLEIDX;
-HLEIDX PPCInterpreter_registerHLECall(HLECALL hleCall);
+HLEIDX PPCInterpreter_registerHLECall(HLECALL hleCall, std::string hleName);
 HLECALL PPCInterpreter_getHLECall(HLEIDX funcIndex);
 
 // HLE scheduler
 
-void PPCCore_deleteAllThreads();
 void PPCInterpreter_relinquishTimeslice();
 
 void PPCCore_boostQuantum(sint32 numCycles);
diff --git a/src/Cafe/HW/Espresso/PPCTimer.cpp b/src/Cafe/HW/Espresso/PPCTimer.cpp
index 36198dac..257973a6 100644
--- a/src/Cafe/HW/Espresso/PPCTimer.cpp
+++ b/src/Cafe/HW/Espresso/PPCTimer.cpp
@@ -1,9 +1,13 @@
 #include "Cafe/HW/Espresso/Const.h"
-#include <immintrin.h>
-#include "asm/x64util.h"
 #include "config/ActiveSettings.h"
 #include "util/helpers/fspinlock.h"
 #include "util/highresolutiontimer/HighResolutionTimer.h"
+#include "Common/cpu_features.h"
+
+#if defined(ARCH_X86_64)
+#include <immintrin.h>
+#pragma intrinsic(__rdtsc)
+#endif
 
 uint64 _rdtscLastMeasure = 0;
 uint64 _rdtscFrequency = 0;
@@ -18,8 +22,6 @@ static_assert(sizeof(uint128_t) == 16);
 
 uint128_t _rdtscAcc{};
 
-#pragma intrinsic(__rdtsc)
-
 uint64 muldiv64(uint64 a, uint64 b, uint64 d)
 {
 	uint64 diva = a / d;
@@ -29,17 +31,12 @@ uint64 muldiv64(uint64 a, uint64 b, uint64 d)
 	return diva * b + moda * divb + moda * modb / d;
 }
 
-bool PPCTimer_hasInvariantRDTSCSupport()
-{
-	uint32 cpuv[4];
-	cpuid((int*)cpuv, 0x80000007);
-	return ((cpuv[3] >> 8) & 1);
-}
-
 uint64 PPCTimer_estimateRDTSCFrequency()
 {
-	if (PPCTimer_hasInvariantRDTSCSupport() == false)
-		forceLog_printf("Invariant TSC not supported");
+    #if defined(ARCH_X86_64)
+	if (!g_CPUFeatures.x86.invariant_tsc)
+		cemuLog_log(LogType::Force, "Invariant TSC not supported");
+    #endif
 
 	_mm_mfence();
 	uint64 tscStart = __rdtsc();
@@ -62,12 +59,12 @@ uint64 PPCTimer_estimateRDTSCFrequency()
 	uint64 tsc_freq = muldiv64(tsc_diff, hrtFreq, hrtDiff);
 
 	// uint64 freqMultiplier = tsc_freq / hrtFreq;
-	//forceLog_printf("RDTSC measurement test:");
-	//forceLog_printf("TSC-diff:   0x%016llx", tsc_diff);
-	//forceLog_printf("TSC-freq:   0x%016llx", tsc_freq);
-	//forceLog_printf("HPC-diff:   0x%016llx", qpc_diff);
-	//forceLog_printf("HPC-freq:   0x%016llx", (uint64)qpc_freq.QuadPart);
-	//forceLog_printf("Multiplier: 0x%016llx", freqMultiplier);
+	//cemuLog_log(LogType::Force, "RDTSC measurement test:");
+	//cemuLog_log(LogType::Force, "TSC-diff:   0x{:016x}", tsc_diff);
+	//cemuLog_log(LogType::Force, "TSC-freq:   0x{:016x}", tsc_freq);
+	//cemuLog_log(LogType::Force, "HPC-diff:   0x{:016x}", qpc_diff);
+	//cemuLog_log(LogType::Force, "HPC-freq:   0x{:016x}", (uint64)qpc_freq.QuadPart);
+	//cemuLog_log(LogType::Force, "Multiplier: 0x{:016x}", freqMultiplier);
 
 	return tsc_freq;
 }
@@ -129,7 +126,7 @@ FSpinlock sTimerSpinlock;
 // thread safe
 uint64 PPCTimer_getFromRDTSC()
 {
-	sTimerSpinlock.acquire();
+	sTimerSpinlock.lock();
 	_mm_mfence();
 	uint64 rdtscCurrentMeasure = __rdtsc();
 	uint64 rdtscDif = rdtscCurrentMeasure - _rdtscLastMeasure;
@@ -165,6 +162,6 @@ uint64 PPCTimer_getFromRDTSC()
 
 	_tickSummary += elapsedTick;
 
-	sTimerSpinlock.release();
+	sTimerSpinlock.unlock();
 	return _tickSummary;
 }
diff --git a/src/Cafe/HW/Espresso/Recompiler/BackendAArch64/BackendAArch64.cpp b/src/Cafe/HW/Espresso/Recompiler/BackendAArch64/BackendAArch64.cpp
new file mode 100644
index 00000000..728460a4
--- /dev/null
+++ b/src/Cafe/HW/Espresso/Recompiler/BackendAArch64/BackendAArch64.cpp
@@ -0,0 +1,1695 @@
+#include "BackendAArch64.h"
+
+#pragma push_macro("CSIZE")
+#undef CSIZE
+#include <xbyak_aarch64.h>
+#pragma pop_macro("CSIZE")
+#include <xbyak_aarch64_util.h>
+
+#include <cstddef>
+
+#include "../PPCRecompiler.h"
+#include "Common/precompiled.h"
+#include "Common/cpu_features.h"
+#include "HW/Espresso/Interpreter/PPCInterpreterInternal.h"
+#include "HW/Espresso/Interpreter/PPCInterpreterHelper.h"
+#include "HW/Espresso/PPCState.h"
+
+using namespace Xbyak_aarch64;
+
+constexpr uint32 TEMP_GPR_1_ID = 25;
+constexpr uint32 TEMP_GPR_2_ID = 26;
+constexpr uint32 PPC_RECOMPILER_INSTANCE_DATA_REG_ID = 27;
+constexpr uint32 MEMORY_BASE_REG_ID = 28;
+constexpr uint32 HCPU_REG_ID = 29;
+
+constexpr uint32 TEMP_FPR_ID = 31;
+
+struct FPReg
+{
+	explicit FPReg(size_t index)
+		: index(index), VReg(index), QReg(index), DReg(index), SReg(index), HReg(index), BReg(index)
+	{
+	}
+	const size_t index;
+	const VReg VReg;
+	const QReg QReg;
+	const DReg DReg;
+	const SReg SReg;
+	const HReg HReg;
+	const BReg BReg;
+};
+
+struct GPReg
+{
+	explicit GPReg(size_t index)
+		: index(index), XReg(index), WReg(index)
+	{
+	}
+	const size_t index;
+	const XReg XReg;
+	const WReg WReg;
+};
+
+static const XReg HCPU_REG{HCPU_REG_ID}, PPC_REC_INSTANCE_REG{PPC_RECOMPILER_INSTANCE_DATA_REG_ID}, MEM_BASE_REG{MEMORY_BASE_REG_ID};
+static const GPReg TEMP_GPR1{TEMP_GPR_1_ID};
+static const GPReg TEMP_GPR2{TEMP_GPR_2_ID};
+static const GPReg LR{TEMP_GPR_2_ID};
+
+static const FPReg TEMP_FPR{TEMP_FPR_ID};
+
+static const util::Cpu s_cpu;
+
+class AArch64Allocator : public Allocator
+{
+  private:
+#ifdef XBYAK_USE_MMAP_ALLOCATOR
+	inline static MmapAllocator s_allocator;
+#else
+	inline static Allocator s_allocator;
+#endif
+	Allocator* m_allocatorImpl;
+	bool m_freeDisabled = false;
+
+  public:
+	AArch64Allocator()
+		: m_allocatorImpl(reinterpret_cast<Allocator*>(&s_allocator)) {}
+
+	uint32* alloc(size_t size) override
+	{
+		return m_allocatorImpl->alloc(size);
+	}
+
+	void setFreeDisabled(bool disabled)
+	{
+		m_freeDisabled = disabled;
+	}
+
+	void free(uint32* p) override
+	{
+		if (!m_freeDisabled)
+			m_allocatorImpl->free(p);
+	}
+
+	[[nodiscard]] bool useProtect() const override
+	{
+		return !m_freeDisabled && m_allocatorImpl->useProtect();
+	}
+};
+
+struct UnconditionalJumpInfo
+{
+	IMLSegment* target;
+};
+
+struct ConditionalRegJumpInfo
+{
+	IMLSegment* target;
+	WReg regBool;
+	bool mustBeTrue;
+};
+
+struct NegativeRegValueJumpInfo
+{
+	IMLSegment* target;
+	WReg regValue;
+};
+
+using JumpInfo = std::variant<
+	UnconditionalJumpInfo,
+	ConditionalRegJumpInfo,
+	NegativeRegValueJumpInfo>;
+
+struct AArch64GenContext_t : CodeGenerator
+{
+	explicit AArch64GenContext_t(Allocator* allocator = nullptr);
+	void enterRecompilerCode();
+	void leaveRecompilerCode();
+
+	void r_name(IMLInstruction* imlInstruction);
+	void name_r(IMLInstruction* imlInstruction);
+	bool r_s32(IMLInstruction* imlInstruction);
+	bool r_r(IMLInstruction* imlInstruction);
+	bool r_r_s32(IMLInstruction* imlInstruction);
+	bool r_r_s32_carry(IMLInstruction* imlInstruction);
+	bool r_r_r(IMLInstruction* imlInstruction);
+	bool r_r_r_carry(IMLInstruction* imlInstruction);
+	void compare(IMLInstruction* imlInstruction);
+	void compare_s32(IMLInstruction* imlInstruction);
+	bool load(IMLInstruction* imlInstruction, bool indexed);
+	bool store(IMLInstruction* imlInstruction, bool indexed);
+	void atomic_cmp_store(IMLInstruction* imlInstruction);
+	bool macro(IMLInstruction* imlInstruction);
+	void call_imm(IMLInstruction* imlInstruction);
+	bool fpr_load(IMLInstruction* imlInstruction, bool indexed);
+	bool fpr_store(IMLInstruction* imlInstruction, bool indexed);
+	void fpr_r_r(IMLInstruction* imlInstruction);
+	void fpr_r_r_r(IMLInstruction* imlInstruction);
+	void fpr_r_r_r_r(IMLInstruction* imlInstruction);
+	void fpr_r(IMLInstruction* imlInstruction);
+	void fpr_compare(IMLInstruction* imlInstruction);
+	void cjump(IMLInstruction* imlInstruction, IMLSegment* imlSegment);
+	void jump(IMLSegment* imlSegment);
+	void conditionalJumpCycleCheck(IMLSegment* imlSegment);
+
+	static constexpr size_t MAX_JUMP_INSTR_COUNT = 2;
+	std::list<std::pair<size_t, JumpInfo>> jumps;
+	void prepareJump(JumpInfo&& jumpInfo)
+	{
+		jumps.emplace_back(getSize(), jumpInfo);
+		for (int i = 0; i < MAX_JUMP_INSTR_COUNT; ++i)
+			nop();
+	}
+
+	std::map<IMLSegment*, size_t> segmentStarts;
+	void storeSegmentStart(IMLSegment* imlSegment)
+	{
+		segmentStarts[imlSegment] = getSize();
+	}
+
+	bool processAllJumps()
+	{
+		for (auto jump : jumps)
+		{
+			auto jumpStart = jump.first;
+			auto jumpInfo = jump.second;
+			bool success = std::visit(
+				[&, this](const auto& jump) {
+					setSize(jumpStart);
+					sint64 targetAddress = segmentStarts.at(jump.target);
+					sint64 addressOffset = targetAddress - jumpStart;
+					return handleJump(addressOffset, jump);
+				},
+				jumpInfo);
+			if (!success)
+			{
+				return false;
+			}
+		}
+		return true;
+	}
+
+	bool handleJump(sint64 addressOffset, const UnconditionalJumpInfo& jump)
+	{
+		// in +/-128MB
+		if (-0x8000000 <= addressOffset && addressOffset <= 0x7ffffff)
+		{
+			b(addressOffset);
+			return true;
+		}
+
+		cemu_assert_suspicious();
+
+		return false;
+	}
+
+	bool handleJump(sint64 addressOffset, const ConditionalRegJumpInfo& jump)
+	{
+		bool mustBeTrue = jump.mustBeTrue;
+
+		// in +/-32KB
+		if (-0x8000 <= addressOffset && addressOffset <= 0x7fff)
+		{
+			if (mustBeTrue)
+				tbnz(jump.regBool, 0, addressOffset);
+			else
+				tbz(jump.regBool, 0, addressOffset);
+			return true;
+		}
+
+		// in +/-1MB
+		if (-0x100000 <= addressOffset && addressOffset <= 0xfffff)
+		{
+			if (mustBeTrue)
+				cbnz(jump.regBool, addressOffset);
+			else
+				cbz(jump.regBool, addressOffset);
+			return true;
+		}
+
+		Label skipJump;
+		if (mustBeTrue)
+			tbz(jump.regBool, 0, skipJump);
+		else
+			tbnz(jump.regBool, 0, skipJump);
+		addressOffset -= 4;
+
+		// in +/-128MB
+		if (-0x8000000 <= addressOffset && addressOffset <= 0x7ffffff)
+		{
+			b(addressOffset);
+			L(skipJump);
+			return true;
+		}
+
+		cemu_assert_suspicious();
+
+		return false;
+	}
+
+	bool handleJump(sint64 addressOffset, const NegativeRegValueJumpInfo& jump)
+	{
+		// in +/-32KB
+		if (-0x8000 <= addressOffset && addressOffset <= 0x7fff)
+		{
+			tbnz(jump.regValue, 31, addressOffset);
+			return true;
+		}
+
+		// in +/-1MB
+		if (-0x100000 <= addressOffset && addressOffset <= 0xfffff)
+		{
+			tst(jump.regValue, 0x80000000);
+			addressOffset -= 4;
+			bne(addressOffset);
+			return true;
+		}
+
+		Label skipJump;
+		tbz(jump.regValue, 31, skipJump);
+		addressOffset -= 4;
+
+		// in +/-128MB
+		if (-0x8000000 <= addressOffset && addressOffset <= 0x7ffffff)
+		{
+			b(addressOffset);
+			L(skipJump);
+			return true;
+		}
+
+		cemu_assert_suspicious();
+
+		return false;
+	}
+};
+
+template<std::derived_from<VRegSc> T>
+T fpReg(const IMLReg& imlReg)
+{
+	cemu_assert_debug(imlReg.GetRegFormat() == IMLRegFormat::F64);
+	auto regId = imlReg.GetRegID();
+	cemu_assert_debug(regId >= IMLArchAArch64::PHYSREG_FPR_BASE && regId < IMLArchAArch64::PHYSREG_FPR_BASE + IMLArchAArch64::PHYSREG_FPR_COUNT);
+	return T(regId - IMLArchAArch64::PHYSREG_FPR_BASE);
+}
+
+template<std::derived_from<RReg> T>
+T gpReg(const IMLReg& imlReg)
+{
+	auto regFormat = imlReg.GetRegFormat();
+	if (std::is_same_v<T, WReg>)
+		cemu_assert_debug(regFormat == IMLRegFormat::I32);
+	else if (std::is_same_v<T, XReg>)
+		cemu_assert_debug(regFormat == IMLRegFormat::I64);
+	else
+		cemu_assert_unimplemented();
+
+	auto regId = imlReg.GetRegID();
+	cemu_assert_debug(regId >= IMLArchAArch64::PHYSREG_GPR_BASE && regId < IMLArchAArch64::PHYSREG_GPR_BASE + IMLArchAArch64::PHYSREG_GPR_COUNT);
+	return T(regId - IMLArchAArch64::PHYSREG_GPR_BASE);
+}
+
+template<std::derived_from<VRegSc> To, std::derived_from<VRegSc> From>
+To aliasAs(const From& reg)
+{
+	return To(reg.getIdx());
+}
+
+template<std::derived_from<RReg> To, std::derived_from<RReg> From>
+To aliasAs(const From& reg)
+{
+	return To(reg.getIdx());
+}
+
+AArch64GenContext_t::AArch64GenContext_t(Allocator* allocator)
+	: CodeGenerator(DEFAULT_MAX_CODE_SIZE, AutoGrow, allocator)
+{
+}
+
+constexpr uint64 ones(uint32 size)
+{
+	return (size == 64) ? 0xffffffffffffffff : ((uint64)1 << size) - 1;
+}
+
+constexpr bool isAdrImmValidFPR(sint32 imm, uint32 bits)
+{
+	uint32 times = bits / 8;
+	uint32 sh = std::countr_zero(times);
+	return (0 <= imm && imm <= 4095 * times) && ((uint64)imm & ones(sh)) == 0;
+}
+
+constexpr bool isAdrImmValidGPR(sint32 imm, uint32 bits = 32)
+{
+	uint32 size = std::countr_zero(bits / 8u);
+	sint32 times = 1 << size;
+	return (0 <= imm && imm <= 4095 * times) && ((uint64)imm & ones(size)) == 0;
+}
+
+constexpr bool isAdrImmRangeValid(sint32 rangeStart, sint32 rangeOffset, sint32 bits, std::invocable<sint32, uint32> auto check)
+{
+	for (sint32 i = rangeStart; i <= rangeStart + rangeOffset; i += bits / 8)
+		if (!check(i, bits))
+			return false;
+	return true;
+}
+
+constexpr bool isAdrImmRangeValidGPR(sint32 rangeStart, sint32 rangeOffset, sint32 bits = 32)
+{
+	return isAdrImmRangeValid(rangeStart, rangeOffset, bits, isAdrImmValidGPR);
+}
+
+constexpr bool isAdrImmRangeValidFpr(sint32 rangeStart, sint32 rangeOffset, sint32 bits)
+{
+	return isAdrImmRangeValid(rangeStart, rangeOffset, bits, isAdrImmValidFPR);
+}
+
+// Verify that all of the offsets for the PPCInterpreter_t members that we use in r_name/name_r have a valid imm value for AdrUimm
+static_assert(isAdrImmRangeValidGPR(offsetof(PPCInterpreter_t, gpr), sizeof(uint32) * 31));
+static_assert(isAdrImmValidGPR(offsetof(PPCInterpreter_t, spr.LR)));
+static_assert(isAdrImmValidGPR(offsetof(PPCInterpreter_t, spr.CTR)));
+static_assert(isAdrImmValidGPR(offsetof(PPCInterpreter_t, spr.XER)));
+static_assert(isAdrImmRangeValidGPR(offsetof(PPCInterpreter_t, spr.UGQR), sizeof(PPCInterpreter_t::spr.UGQR[0]) * (SPR_UGQR7 - SPR_UGQR0)));
+static_assert(isAdrImmRangeValidGPR(offsetof(PPCInterpreter_t, temporaryGPR_reg), sizeof(uint32) * 3));
+static_assert(isAdrImmValidGPR(offsetof(PPCInterpreter_t, xer_ca), 8));
+static_assert(isAdrImmValidGPR(offsetof(PPCInterpreter_t, xer_so), 8));
+static_assert(isAdrImmRangeValidGPR(offsetof(PPCInterpreter_t, cr), PPCREC_NAME_CR_LAST - PPCREC_NAME_CR, 8));
+static_assert(isAdrImmValidGPR(offsetof(PPCInterpreter_t, reservedMemAddr)));
+static_assert(isAdrImmValidGPR(offsetof(PPCInterpreter_t, reservedMemValue)));
+static_assert(isAdrImmRangeValidFpr(offsetof(PPCInterpreter_t, fpr), sizeof(FPR_t) * 63, 64));
+static_assert(isAdrImmRangeValidFpr(offsetof(PPCInterpreter_t, temporaryFPR), sizeof(FPR_t) * 7, 128));
+
+void AArch64GenContext_t::r_name(IMLInstruction* imlInstruction)
+{
+	uint32 name = imlInstruction->op_r_name.name;
+
+	if (imlInstruction->op_r_name.regR.GetBaseFormat() == IMLRegFormat::I64)
+	{
+		XReg regRXReg = gpReg<XReg>(imlInstruction->op_r_name.regR);
+		WReg regR = aliasAs<WReg>(regRXReg);
+		if (name >= PPCREC_NAME_R0 && name < PPCREC_NAME_R0 + 32)
+		{
+			ldr(regR, AdrUimm(HCPU_REG, offsetof(PPCInterpreter_t, gpr) + sizeof(uint32) * (name - PPCREC_NAME_R0)));
+		}
+		else if (name >= PPCREC_NAME_SPR0 && name < PPCREC_NAME_SPR0 + 999)
+		{
+			uint32 sprIndex = (name - PPCREC_NAME_SPR0);
+			if (sprIndex == SPR_LR)
+				ldr(regR, AdrUimm(HCPU_REG, offsetof(PPCInterpreter_t, spr.LR)));
+			else if (sprIndex == SPR_CTR)
+				ldr(regR, AdrUimm(HCPU_REG, offsetof(PPCInterpreter_t, spr.CTR)));
+			else if (sprIndex == SPR_XER)
+				ldr(regR, AdrUimm(HCPU_REG, offsetof(PPCInterpreter_t, spr.XER)));
+			else if (sprIndex >= SPR_UGQR0 && sprIndex <= SPR_UGQR7)
+				ldr(regR, AdrUimm(HCPU_REG, offsetof(PPCInterpreter_t, spr.UGQR) + sizeof(PPCInterpreter_t::spr.UGQR[0]) * (sprIndex - SPR_UGQR0)));
+			else
+				cemu_assert_suspicious();
+		}
+		else if (name >= PPCREC_NAME_TEMPORARY && name < PPCREC_NAME_TEMPORARY + 4)
+		{
+			ldr(regR, AdrUimm(HCPU_REG, offsetof(PPCInterpreter_t, temporaryGPR_reg) + sizeof(uint32) * (name - PPCREC_NAME_TEMPORARY)));
+		}
+		else if (name == PPCREC_NAME_XER_CA)
+		{
+			ldrb(regR, AdrUimm(HCPU_REG, offsetof(PPCInterpreter_t, xer_ca)));
+		}
+		else if (name == PPCREC_NAME_XER_SO)
+		{
+			ldrb(regR, AdrUimm(HCPU_REG, offsetof(PPCInterpreter_t, xer_so)));
+		}
+		else if (name >= PPCREC_NAME_CR && name <= PPCREC_NAME_CR_LAST)
+		{
+			ldrb(regR, AdrUimm(HCPU_REG, offsetof(PPCInterpreter_t, cr) + (name - PPCREC_NAME_CR)));
+		}
+		else if (name == PPCREC_NAME_CPU_MEMRES_EA)
+		{
+			ldr(regR, AdrUimm(HCPU_REG, offsetof(PPCInterpreter_t, reservedMemAddr)));
+		}
+		else if (name == PPCREC_NAME_CPU_MEMRES_VAL)
+		{
+			ldr(regR, AdrUimm(HCPU_REG, offsetof(PPCInterpreter_t, reservedMemValue)));
+		}
+		else
+		{
+			cemu_assert_suspicious();
+		}
+	}
+	else if (imlInstruction->op_r_name.regR.GetBaseFormat() == IMLRegFormat::F64)
+	{
+		auto imlRegR = imlInstruction->op_r_name.regR;
+
+		if (name >= PPCREC_NAME_FPR_HALF && name < (PPCREC_NAME_FPR_HALF + 64))
+		{
+			uint32 regIndex = (name - PPCREC_NAME_FPR_HALF) / 2;
+			uint32 pairIndex = (name - PPCREC_NAME_FPR_HALF) % 2;
+			uint32 offset = offsetof(PPCInterpreter_t, fpr) + sizeof(FPR_t) * regIndex + (pairIndex ? sizeof(double) : 0);
+			ldr(fpReg<DReg>(imlRegR), AdrUimm(HCPU_REG, offset));
+		}
+		else if (name >= PPCREC_NAME_TEMPORARY_FPR0 && name < (PPCREC_NAME_TEMPORARY_FPR0 + 8))
+		{
+			ldr(fpReg<QReg>(imlRegR), AdrUimm(HCPU_REG, offsetof(PPCInterpreter_t, temporaryFPR) + sizeof(FPR_t) * (name - PPCREC_NAME_TEMPORARY_FPR0)));
+		}
+		else
+		{
+			cemu_assert_suspicious();
+		}
+	}
+	else
+	{
+		cemu_assert_suspicious();
+	}
+}
+
+void AArch64GenContext_t::name_r(IMLInstruction* imlInstruction)
+{
+	uint32 name = imlInstruction->op_r_name.name;
+
+	if (imlInstruction->op_r_name.regR.GetBaseFormat() == IMLRegFormat::I64)
+	{
+		XReg regRXReg = gpReg<XReg>(imlInstruction->op_r_name.regR);
+		WReg regR = aliasAs<WReg>(regRXReg);
+		if (name >= PPCREC_NAME_R0 && name < PPCREC_NAME_R0 + 32)
+		{
+			str(regR, AdrUimm(HCPU_REG, offsetof(PPCInterpreter_t, gpr) + sizeof(uint32) * (name - PPCREC_NAME_R0)));
+		}
+		else if (name >= PPCREC_NAME_SPR0 && name < PPCREC_NAME_SPR0 + 999)
+		{
+			uint32 sprIndex = (name - PPCREC_NAME_SPR0);
+			if (sprIndex == SPR_LR)
+				str(regR, AdrUimm(HCPU_REG, offsetof(PPCInterpreter_t, spr.LR)));
+			else if (sprIndex == SPR_CTR)
+				str(regR, AdrUimm(HCPU_REG, offsetof(PPCInterpreter_t, spr.CTR)));
+			else if (sprIndex == SPR_XER)
+				str(regR, AdrUimm(HCPU_REG, offsetof(PPCInterpreter_t, spr.XER)));
+			else if (sprIndex >= SPR_UGQR0 && sprIndex <= SPR_UGQR7)
+				str(regR, AdrUimm(HCPU_REG, offsetof(PPCInterpreter_t, spr.UGQR) + sizeof(PPCInterpreter_t::spr.UGQR[0]) * (sprIndex - SPR_UGQR0)));
+			else
+				cemu_assert_suspicious();
+		}
+		else if (name >= PPCREC_NAME_TEMPORARY && name < PPCREC_NAME_TEMPORARY + 4)
+		{
+			str(regR, AdrUimm(HCPU_REG, offsetof(PPCInterpreter_t, temporaryGPR_reg) + sizeof(uint32) * (name - PPCREC_NAME_TEMPORARY)));
+		}
+		else if (name == PPCREC_NAME_XER_CA)
+		{
+			strb(regR, AdrUimm(HCPU_REG, offsetof(PPCInterpreter_t, xer_ca)));
+		}
+		else if (name == PPCREC_NAME_XER_SO)
+		{
+			strb(regR, AdrUimm(HCPU_REG, offsetof(PPCInterpreter_t, xer_so)));
+		}
+		else if (name >= PPCREC_NAME_CR && name <= PPCREC_NAME_CR_LAST)
+		{
+			strb(regR, AdrUimm(HCPU_REG, offsetof(PPCInterpreter_t, cr) + (name - PPCREC_NAME_CR)));
+		}
+		else if (name == PPCREC_NAME_CPU_MEMRES_EA)
+		{
+			str(regR, AdrUimm(HCPU_REG, offsetof(PPCInterpreter_t, reservedMemAddr)));
+		}
+		else if (name == PPCREC_NAME_CPU_MEMRES_VAL)
+		{
+			str(regR, AdrUimm(HCPU_REG, offsetof(PPCInterpreter_t, reservedMemValue)));
+		}
+		else
+		{
+			cemu_assert_suspicious();
+		}
+	}
+	else if (imlInstruction->op_r_name.regR.GetBaseFormat() == IMLRegFormat::F64)
+	{
+		auto imlRegR = imlInstruction->op_r_name.regR;
+		if (name >= PPCREC_NAME_FPR_HALF && name < (PPCREC_NAME_FPR_HALF + 64))
+		{
+			uint32 regIndex = (name - PPCREC_NAME_FPR_HALF) / 2;
+			uint32 pairIndex = (name - PPCREC_NAME_FPR_HALF) % 2;
+			sint32 offset = offsetof(PPCInterpreter_t, fpr) + sizeof(FPR_t) * regIndex + pairIndex * sizeof(double);
+			str(fpReg<DReg>(imlRegR), AdrUimm(HCPU_REG, offset));
+		}
+		else if (name >= PPCREC_NAME_TEMPORARY_FPR0 && name < (PPCREC_NAME_TEMPORARY_FPR0 + 8))
+		{
+			str(fpReg<QReg>(imlRegR), AdrUimm(HCPU_REG, offsetof(PPCInterpreter_t, temporaryFPR) + sizeof(FPR_t) * (name - PPCREC_NAME_TEMPORARY_FPR0)));
+		}
+		else
+		{
+			cemu_assert_suspicious();
+		}
+	}
+	else
+	{
+		cemu_assert_suspicious();
+	}
+}
+
+bool AArch64GenContext_t::r_r(IMLInstruction* imlInstruction)
+{
+	WReg regR = gpReg<WReg>(imlInstruction->op_r_r.regR);
+	WReg regA = gpReg<WReg>(imlInstruction->op_r_r.regA);
+
+	if (imlInstruction->operation == PPCREC_IML_OP_ASSIGN)
+	{
+		mov(regR, regA);
+	}
+	else if (imlInstruction->operation == PPCREC_IML_OP_ENDIAN_SWAP)
+	{
+		rev(regR, regA);
+	}
+	else if (imlInstruction->operation == PPCREC_IML_OP_ASSIGN_S8_TO_S32)
+	{
+		sxtb(regR, regA);
+	}
+	else if (imlInstruction->operation == PPCREC_IML_OP_ASSIGN_S16_TO_S32)
+	{
+		sxth(regR, regA);
+	}
+	else if (imlInstruction->operation == PPCREC_IML_OP_NOT)
+	{
+		mvn(regR, regA);
+	}
+	else if (imlInstruction->operation == PPCREC_IML_OP_NEG)
+	{
+		neg(regR, regA);
+	}
+	else if (imlInstruction->operation == PPCREC_IML_OP_CNTLZW)
+	{
+		clz(regR, regA);
+	}
+	else
+	{
+		cemuLog_log(LogType::Recompiler, "PPCRecompilerAArch64Gen_imlInstruction_r_r(): Unsupported operation {:x}", imlInstruction->operation);
+		return false;
+	}
+	return true;
+}
+
+bool AArch64GenContext_t::r_s32(IMLInstruction* imlInstruction)
+{
+	sint32 imm32 = imlInstruction->op_r_immS32.immS32;
+	WReg reg = gpReg<WReg>(imlInstruction->op_r_immS32.regR);
+
+	if (imlInstruction->operation == PPCREC_IML_OP_ASSIGN)
+	{
+		mov(reg, imm32);
+	}
+	else if (imlInstruction->operation == PPCREC_IML_OP_LEFT_ROTATE)
+	{
+		ror(reg, reg, 32 - (imm32 & 0x1f));
+	}
+	else
+	{
+		cemuLog_log(LogType::Recompiler, "PPCRecompilerAArch64Gen_imlInstruction_r_s32(): Unsupported operation {:x}", imlInstruction->operation);
+		return false;
+	}
+	return true;
+}
+
+bool AArch64GenContext_t::r_r_s32(IMLInstruction* imlInstruction)
+{
+	WReg regR = gpReg<WReg>(imlInstruction->op_r_r_s32.regR);
+	WReg regA = gpReg<WReg>(imlInstruction->op_r_r_s32.regA);
+	sint32 immS32 = imlInstruction->op_r_r_s32.immS32;
+
+	if (imlInstruction->operation == PPCREC_IML_OP_ADD)
+	{
+		add_imm(regR, regA, immS32, TEMP_GPR1.WReg);
+	}
+	else if (imlInstruction->operation == PPCREC_IML_OP_SUB)
+	{
+		sub_imm(regR, regA, immS32, TEMP_GPR1.WReg);
+	}
+	else if (imlInstruction->operation == PPCREC_IML_OP_AND)
+	{
+		mov(TEMP_GPR1.WReg, immS32);
+		and_(regR, regA, TEMP_GPR1.WReg);
+	}
+	else if (imlInstruction->operation == PPCREC_IML_OP_OR)
+	{
+		mov(TEMP_GPR1.WReg, immS32);
+		orr(regR, regA, TEMP_GPR1.WReg);
+	}
+	else if (imlInstruction->operation == PPCREC_IML_OP_XOR)
+	{
+		mov(TEMP_GPR1.WReg, immS32);
+		eor(regR, regA, TEMP_GPR1.WReg);
+	}
+	else if (imlInstruction->operation == PPCREC_IML_OP_MULTIPLY_SIGNED)
+	{
+		mov(TEMP_GPR1.WReg, immS32);
+		mul(regR, regA, TEMP_GPR1.WReg);
+	}
+	else if (imlInstruction->operation == PPCREC_IML_OP_LEFT_SHIFT)
+	{
+		lsl(regR, regA, (uint32)immS32 & 0x1f);
+	}
+	else if (imlInstruction->operation == PPCREC_IML_OP_RIGHT_SHIFT_U)
+	{
+		lsr(regR, regA, (uint32)immS32 & 0x1f);
+	}
+	else if (imlInstruction->operation == PPCREC_IML_OP_RIGHT_SHIFT_S)
+	{
+		asr(regR, regA, (uint32)immS32 & 0x1f);
+	}
+	else
+	{
+		cemuLog_log(LogType::Recompiler, "PPCRecompilerAArch64Gen_imlInstruction_r_r_s32(): Unsupported operation {:x}", imlInstruction->operation);
+		cemu_assert_suspicious();
+		return false;
+	}
+	return true;
+}
+
+bool AArch64GenContext_t::r_r_s32_carry(IMLInstruction* imlInstruction)
+{
+	WReg regR = gpReg<WReg>(imlInstruction->op_r_r_s32_carry.regR);
+	WReg regA = gpReg<WReg>(imlInstruction->op_r_r_s32_carry.regA);
+	WReg regCarry = gpReg<WReg>(imlInstruction->op_r_r_s32_carry.regCarry);
+
+	sint32 immS32 = imlInstruction->op_r_r_s32_carry.immS32;
+	if (imlInstruction->operation == PPCREC_IML_OP_ADD)
+	{
+		adds_imm(regR, regA, immS32, TEMP_GPR1.WReg);
+		cset(regCarry, Cond::CS);
+	}
+	else if (imlInstruction->operation == PPCREC_IML_OP_ADD_WITH_CARRY)
+	{
+		mov(TEMP_GPR1.WReg, immS32);
+		cmp(regCarry, 1);
+		adcs(regR, regA, TEMP_GPR1.WReg);
+		cset(regCarry, Cond::CS);
+	}
+	else
+	{
+		cemu_assert_suspicious();
+		return false;
+	}
+
+	return true;
+}
+
+bool AArch64GenContext_t::r_r_r(IMLInstruction* imlInstruction)
+{
+	WReg regResult = gpReg<WReg>(imlInstruction->op_r_r_r.regR);
+	XReg reg64Result = aliasAs<XReg>(regResult);
+	WReg regOperand1 = gpReg<WReg>(imlInstruction->op_r_r_r.regA);
+	WReg regOperand2 = gpReg<WReg>(imlInstruction->op_r_r_r.regB);
+
+	if (imlInstruction->operation == PPCREC_IML_OP_ADD)
+	{
+		add(regResult, regOperand1, regOperand2);
+	}
+	else if (imlInstruction->operation == PPCREC_IML_OP_SUB)
+	{
+		sub(regResult, regOperand1, regOperand2);
+	}
+	else if (imlInstruction->operation == PPCREC_IML_OP_OR)
+	{
+		orr(regResult, regOperand1, regOperand2);
+	}
+	else if (imlInstruction->operation == PPCREC_IML_OP_AND)
+	{
+		and_(regResult, regOperand1, regOperand2);
+	}
+	else if (imlInstruction->operation == PPCREC_IML_OP_XOR)
+	{
+		eor(regResult, regOperand1, regOperand2);
+	}
+	else if (imlInstruction->operation == PPCREC_IML_OP_MULTIPLY_SIGNED)
+	{
+		mul(regResult, regOperand1, regOperand2);
+	}
+	else if (imlInstruction->operation == PPCREC_IML_OP_SLW)
+	{
+		tst(regOperand2, 32);
+		lsl(regResult, regOperand1, regOperand2);
+		csel(regResult, regResult, wzr, Cond::EQ);
+	}
+	else if (imlInstruction->operation == PPCREC_IML_OP_SRW)
+	{
+		tst(regOperand2, 32);
+		lsr(regResult, regOperand1, regOperand2);
+		csel(regResult, regResult, wzr, Cond::EQ);
+	}
+	else if (imlInstruction->operation == PPCREC_IML_OP_LEFT_ROTATE)
+	{
+		neg(TEMP_GPR1.WReg, regOperand2);
+		ror(regResult, regOperand1, TEMP_GPR1.WReg);
+	}
+	else if (imlInstruction->operation == PPCREC_IML_OP_RIGHT_SHIFT_S)
+	{
+		asr(regResult, regOperand1, regOperand2);
+	}
+	else if (imlInstruction->operation == PPCREC_IML_OP_RIGHT_SHIFT_U)
+	{
+		lsr(regResult, regOperand1, regOperand2);
+	}
+	else if (imlInstruction->operation == PPCREC_IML_OP_LEFT_SHIFT)
+	{
+		lsl(regResult, regOperand1, regOperand2);
+	}
+	else if (imlInstruction->operation == PPCREC_IML_OP_DIVIDE_SIGNED)
+	{
+		sdiv(regResult, regOperand1, regOperand2);
+	}
+	else if (imlInstruction->operation == PPCREC_IML_OP_DIVIDE_UNSIGNED)
+	{
+		udiv(regResult, regOperand1, regOperand2);
+	}
+	else if (imlInstruction->operation == PPCREC_IML_OP_MULTIPLY_HIGH_SIGNED)
+	{
+		smull(reg64Result, regOperand1, regOperand2);
+		lsr(reg64Result, reg64Result, 32);
+	}
+	else if (imlInstruction->operation == PPCREC_IML_OP_MULTIPLY_HIGH_UNSIGNED)
+	{
+		umull(reg64Result, regOperand1, regOperand2);
+		lsr(reg64Result, reg64Result, 32);
+	}
+	else
+	{
+		cemuLog_log(LogType::Recompiler, "PPCRecompilerAArch64Gen_imlInstruction_r_r_r(): Unsupported operation {:x}", imlInstruction->operation);
+		return false;
+	}
+	return true;
+}
+
+bool AArch64GenContext_t::r_r_r_carry(IMLInstruction* imlInstruction)
+{
+	WReg regR = gpReg<WReg>(imlInstruction->op_r_r_r_carry.regR);
+	WReg regA = gpReg<WReg>(imlInstruction->op_r_r_r_carry.regA);
+	WReg regB = gpReg<WReg>(imlInstruction->op_r_r_r_carry.regB);
+	WReg regCarry = gpReg<WReg>(imlInstruction->op_r_r_r_carry.regCarry);
+
+	if (imlInstruction->operation == PPCREC_IML_OP_ADD)
+	{
+		adds(regR, regA, regB);
+		cset(regCarry, Cond::CS);
+	}
+	else if (imlInstruction->operation == PPCREC_IML_OP_ADD_WITH_CARRY)
+	{
+		cmp(regCarry, 1);
+		adcs(regR, regA, regB);
+		cset(regCarry, Cond::CS);
+	}
+	else
+	{
+		cemu_assert_suspicious();
+		return false;
+	}
+
+	return true;
+}
+
+Cond ImlCondToArm64Cond(IMLCondition condition)
+{
+	switch (condition)
+	{
+	case IMLCondition::EQ:
+		return Cond::EQ;
+	case IMLCondition::NEQ:
+		return Cond::NE;
+	case IMLCondition::UNSIGNED_GT:
+		return Cond::HI;
+	case IMLCondition::UNSIGNED_LT:
+		return Cond::LO;
+	case IMLCondition::SIGNED_GT:
+		return Cond::GT;
+	case IMLCondition::SIGNED_LT:
+		return Cond::LT;
+	default:
+	{
+		cemu_assert_suspicious();
+		return Cond::EQ;
+	}
+	}
+}
+
+void AArch64GenContext_t::compare(IMLInstruction* imlInstruction)
+{
+	WReg regR = gpReg<WReg>(imlInstruction->op_compare.regR);
+	WReg regA = gpReg<WReg>(imlInstruction->op_compare.regA);
+	WReg regB = gpReg<WReg>(imlInstruction->op_compare.regB);
+	Cond cond = ImlCondToArm64Cond(imlInstruction->op_compare.cond);
+	cmp(regA, regB);
+	cset(regR, cond);
+}
+
+void AArch64GenContext_t::compare_s32(IMLInstruction* imlInstruction)
+{
+	WReg regR = gpReg<WReg>(imlInstruction->op_compare.regR);
+	WReg regA = gpReg<WReg>(imlInstruction->op_compare.regA);
+	sint32 imm = imlInstruction->op_compare_s32.immS32;
+	auto cond = ImlCondToArm64Cond(imlInstruction->op_compare.cond);
+	cmp_imm(regA, imm, TEMP_GPR1.WReg);
+	cset(regR, cond);
+}
+
+void AArch64GenContext_t::cjump(IMLInstruction* imlInstruction, IMLSegment* imlSegment)
+{
+	auto regBool = gpReg<WReg>(imlInstruction->op_conditional_jump.registerBool);
+	prepareJump(ConditionalRegJumpInfo{
+		.target = imlSegment->nextSegmentBranchTaken,
+		.regBool = regBool,
+		.mustBeTrue = imlInstruction->op_conditional_jump.mustBeTrue,
+	});
+}
+
+void AArch64GenContext_t::jump(IMLSegment* imlSegment)
+{
+	prepareJump(UnconditionalJumpInfo{.target = imlSegment->nextSegmentBranchTaken});
+}
+
+void AArch64GenContext_t::conditionalJumpCycleCheck(IMLSegment* imlSegment)
+{
+	ldr(TEMP_GPR1.WReg, AdrUimm(HCPU_REG, offsetof(PPCInterpreter_t, remainingCycles)));
+	prepareJump(NegativeRegValueJumpInfo{
+		.target = imlSegment->nextSegmentBranchTaken,
+		.regValue = TEMP_GPR1.WReg,
+	});
+}
+
+void* PPCRecompiler_virtualHLE(PPCInterpreter_t* ppcInterpreter, uint32 hleFuncId)
+{
+	void* prevRSPTemp = ppcInterpreter->rspTemp;
+	if (hleFuncId == 0xFFD0)
+	{
+		ppcInterpreter->remainingCycles -= 500; // let subtract about 500 cycles for each HLE call
+		ppcInterpreter->gpr[3] = 0;
+		PPCInterpreter_nextInstruction(ppcInterpreter);
+		return PPCInterpreter_getCurrentInstance();
+	}
+	else
+	{
+		auto hleCall = PPCInterpreter_getHLECall(hleFuncId);
+		cemu_assert(hleCall != nullptr);
+		hleCall(ppcInterpreter);
+	}
+	ppcInterpreter->rspTemp = prevRSPTemp;
+	return PPCInterpreter_getCurrentInstance();
+}
+
+bool AArch64GenContext_t::macro(IMLInstruction* imlInstruction)
+{
+	if (imlInstruction->operation == PPCREC_IML_MACRO_B_TO_REG)
+	{
+		WReg branchDstReg = gpReg<WReg>(imlInstruction->op_macro.paramReg);
+
+		mov(TEMP_GPR1.WReg, offsetof(PPCRecompilerInstanceData_t, ppcRecompilerDirectJumpTable));
+		add(TEMP_GPR1.WReg, TEMP_GPR1.WReg, branchDstReg, ShMod::LSL, 1);
+		ldr(TEMP_GPR1.XReg, AdrExt(PPC_REC_INSTANCE_REG, TEMP_GPR1.WReg, ExtMod::UXTW));
+		mov(LR.WReg, branchDstReg);
+		br(TEMP_GPR1.XReg);
+		return true;
+	}
+	else if (imlInstruction->operation == PPCREC_IML_MACRO_BL)
+	{
+		uint32 newLR = imlInstruction->op_macro.param + 4;
+
+		mov(TEMP_GPR1.WReg, newLR);
+		str(TEMP_GPR1.WReg, AdrUimm(HCPU_REG, offsetof(PPCInterpreter_t, spr.LR)));
+
+		uint32 newIP = imlInstruction->op_macro.param2;
+		uint64 lookupOffset = (uint64)offsetof(PPCRecompilerInstanceData_t, ppcRecompilerDirectJumpTable) + (uint64)newIP * 2ULL;
+		mov(TEMP_GPR1.XReg, lookupOffset);
+		ldr(TEMP_GPR1.XReg, AdrReg(PPC_REC_INSTANCE_REG, TEMP_GPR1.XReg));
+		mov(LR.WReg, newIP);
+		br(TEMP_GPR1.XReg);
+		return true;
+	}
+	else if (imlInstruction->operation == PPCREC_IML_MACRO_B_FAR)
+	{
+		uint32 newIP = imlInstruction->op_macro.param2;
+		uint64 lookupOffset = (uint64)offsetof(PPCRecompilerInstanceData_t, ppcRecompilerDirectJumpTable) + (uint64)newIP * 2ULL;
+		mov(TEMP_GPR1.XReg, lookupOffset);
+		ldr(TEMP_GPR1.XReg, AdrReg(PPC_REC_INSTANCE_REG, TEMP_GPR1.XReg));
+		mov(LR.WReg, newIP);
+		br(TEMP_GPR1.XReg);
+		return true;
+	}
+	else if (imlInstruction->operation == PPCREC_IML_MACRO_LEAVE)
+	{
+		uint32 currentInstructionAddress = imlInstruction->op_macro.param;
+		mov(TEMP_GPR1.XReg, (uint64)offsetof(PPCRecompilerInstanceData_t, ppcRecompilerDirectJumpTable)); // newIP = 0 special value for recompiler exit
+		ldr(TEMP_GPR1.XReg, AdrReg(PPC_REC_INSTANCE_REG, TEMP_GPR1.XReg));
+		mov(LR.WReg, currentInstructionAddress);
+		br(TEMP_GPR1.XReg);
+		return true;
+	}
+	else if (imlInstruction->operation == PPCREC_IML_MACRO_DEBUGBREAK)
+	{
+		brk(0xf000);
+		return true;
+	}
+	else if (imlInstruction->operation == PPCREC_IML_MACRO_COUNT_CYCLES)
+	{
+		uint32 cycleCount = imlInstruction->op_macro.param;
+		AdrUimm adrCycles = AdrUimm(HCPU_REG, offsetof(PPCInterpreter_t, remainingCycles));
+		ldr(TEMP_GPR1.WReg, adrCycles);
+		sub_imm(TEMP_GPR1.WReg, TEMP_GPR1.WReg, cycleCount, TEMP_GPR2.WReg);
+		str(TEMP_GPR1.WReg, adrCycles);
+		return true;
+	}
+	else if (imlInstruction->operation == PPCREC_IML_MACRO_HLE)
+	{
+		uint32 ppcAddress = imlInstruction->op_macro.param;
+		uint32 funcId = imlInstruction->op_macro.param2;
+		Label cyclesLeftLabel;
+
+		// update instruction pointer
+		mov(TEMP_GPR1.WReg, ppcAddress);
+		str(TEMP_GPR1.WReg, AdrUimm(HCPU_REG, offsetof(PPCInterpreter_t, instructionPointer)));
+		// set parameters
+		str(x30, AdrPreImm(sp, -16));
+
+		mov(x0, HCPU_REG);
+		mov(w1, funcId);
+		// call HLE function
+
+		mov(TEMP_GPR1.XReg, (uint64)PPCRecompiler_virtualHLE);
+		blr(TEMP_GPR1.XReg);
+
+		mov(HCPU_REG, x0);
+
+		ldr(x30, AdrPostImm(sp, 16));
+
+		// check if cycles where decreased beyond zero, if yes -> leave recompiler
+		ldr(TEMP_GPR1.WReg, AdrUimm(HCPU_REG, offsetof(PPCInterpreter_t, remainingCycles)));
+		tbz(TEMP_GPR1.WReg, 31, cyclesLeftLabel); // check if negative
+
+		mov(TEMP_GPR1.XReg, offsetof(PPCRecompilerInstanceData_t, ppcRecompilerDirectJumpTable));
+		ldr(TEMP_GPR1.XReg, AdrReg(PPC_REC_INSTANCE_REG, TEMP_GPR1.XReg));
+		ldr(LR.WReg, AdrUimm(HCPU_REG, offsetof(PPCInterpreter_t, instructionPointer)));
+		// branch to recompiler exit
+		br(TEMP_GPR1.XReg);
+
+		L(cyclesLeftLabel);
+		// check if instruction pointer was changed
+		// assign new instruction pointer to LR.WReg
+		ldr(LR.WReg, AdrUimm(HCPU_REG, offsetof(PPCInterpreter_t, instructionPointer)));
+		mov(TEMP_GPR1.XReg, offsetof(PPCRecompilerInstanceData_t, ppcRecompilerDirectJumpTable));
+		add(TEMP_GPR1.XReg, TEMP_GPR1.XReg, LR.XReg, ShMod::LSL, 1);
+		ldr(TEMP_GPR1.XReg, AdrReg(PPC_REC_INSTANCE_REG, TEMP_GPR1.XReg));
+		// branch to [ppcRecompilerDirectJumpTable + PPCInterpreter_t::instructionPointer * 2]
+		br(TEMP_GPR1.XReg);
+		return true;
+	}
+	else
+	{
+		cemuLog_log(LogType::Recompiler, "Unknown recompiler macro operation %d\n", imlInstruction->operation);
+		cemu_assert_suspicious();
+	}
+	return false;
+}
+
+bool AArch64GenContext_t::load(IMLInstruction* imlInstruction, bool indexed)
+{
+	cemu_assert_debug(imlInstruction->op_storeLoad.registerData.GetRegFormat() == IMLRegFormat::I32);
+	cemu_assert_debug(imlInstruction->op_storeLoad.registerMem.GetRegFormat() == IMLRegFormat::I32);
+	if (indexed)
+		cemu_assert_debug(imlInstruction->op_storeLoad.registerMem2.GetRegFormat() == IMLRegFormat::I32);
+
+	sint32 memOffset = imlInstruction->op_storeLoad.immS32;
+	bool signExtend = imlInstruction->op_storeLoad.flags2.signExtend;
+	bool switchEndian = imlInstruction->op_storeLoad.flags2.swapEndian;
+	WReg memReg = gpReg<WReg>(imlInstruction->op_storeLoad.registerMem);
+	WReg dataReg = gpReg<WReg>(imlInstruction->op_storeLoad.registerData);
+
+	add_imm(TEMP_GPR1.WReg, memReg, memOffset, TEMP_GPR1.WReg);
+	if (indexed)
+		add(TEMP_GPR1.WReg, TEMP_GPR1.WReg, gpReg<WReg>(imlInstruction->op_storeLoad.registerMem2));
+
+	auto adr = AdrExt(MEM_BASE_REG, TEMP_GPR1.WReg, ExtMod::UXTW);
+	if (imlInstruction->op_storeLoad.copyWidth == 32)
+	{
+		ldr(dataReg, adr);
+		if (switchEndian)
+			rev(dataReg, dataReg);
+	}
+	else if (imlInstruction->op_storeLoad.copyWidth == 16)
+	{
+		if (switchEndian)
+		{
+			ldrh(dataReg, adr);
+			rev(dataReg, dataReg);
+			if (signExtend)
+				asr(dataReg, dataReg, 16);
+			else
+				lsr(dataReg, dataReg, 16);
+		}
+		else
+		{
+			if (signExtend)
+				ldrsh(dataReg, adr);
+			else
+				ldrh(dataReg, adr);
+		}
+	}
+	else if (imlInstruction->op_storeLoad.copyWidth == 8)
+	{
+		if (signExtend)
+			ldrsb(dataReg, adr);
+		else
+			ldrb(dataReg, adr);
+	}
+	else
+	{
+		return false;
+	}
+	return true;
+}
+
+bool AArch64GenContext_t::store(IMLInstruction* imlInstruction, bool indexed)
+{
+	cemu_assert_debug(imlInstruction->op_storeLoad.registerData.GetRegFormat() == IMLRegFormat::I32);
+	cemu_assert_debug(imlInstruction->op_storeLoad.registerMem.GetRegFormat() == IMLRegFormat::I32);
+	if (indexed)
+		cemu_assert_debug(imlInstruction->op_storeLoad.registerMem2.GetRegFormat() == IMLRegFormat::I32);
+
+	WReg dataReg = gpReg<WReg>(imlInstruction->op_storeLoad.registerData);
+	WReg memReg = gpReg<WReg>(imlInstruction->op_storeLoad.registerMem);
+	sint32 memOffset = imlInstruction->op_storeLoad.immS32;
+	bool swapEndian = imlInstruction->op_storeLoad.flags2.swapEndian;
+
+	add_imm(TEMP_GPR1.WReg, memReg, memOffset, TEMP_GPR1.WReg);
+	if (indexed)
+		add(TEMP_GPR1.WReg, TEMP_GPR1.WReg, gpReg<WReg>(imlInstruction->op_storeLoad.registerMem2));
+	AdrExt adr = AdrExt(MEM_BASE_REG, TEMP_GPR1.WReg, ExtMod::UXTW);
+	if (imlInstruction->op_storeLoad.copyWidth == 32)
+	{
+		if (swapEndian)
+		{
+			rev(TEMP_GPR2.WReg, dataReg);
+			str(TEMP_GPR2.WReg, adr);
+		}
+		else
+		{
+			str(dataReg, adr);
+		}
+	}
+	else if (imlInstruction->op_storeLoad.copyWidth == 16)
+	{
+		if (swapEndian)
+		{
+			rev(TEMP_GPR2.WReg, dataReg);
+			lsr(TEMP_GPR2.WReg, TEMP_GPR2.WReg, 16);
+			strh(TEMP_GPR2.WReg, adr);
+		}
+		else
+		{
+			strh(dataReg, adr);
+		}
+	}
+	else if (imlInstruction->op_storeLoad.copyWidth == 8)
+	{
+		strb(dataReg, adr);
+	}
+	else
+	{
+		return false;
+	}
+	return true;
+}
+
+void AArch64GenContext_t::atomic_cmp_store(IMLInstruction* imlInstruction)
+{
+	WReg outReg = gpReg<WReg>(imlInstruction->op_atomic_compare_store.regBoolOut);
+	WReg eaReg = gpReg<WReg>(imlInstruction->op_atomic_compare_store.regEA);
+	WReg valReg = gpReg<WReg>(imlInstruction->op_atomic_compare_store.regWriteValue);
+	WReg cmpValReg = gpReg<WReg>(imlInstruction->op_atomic_compare_store.regCompareValue);
+
+	if (s_cpu.isAtomicSupported())
+	{
+		mov(TEMP_GPR2.WReg, cmpValReg);
+		add(TEMP_GPR1.XReg, MEM_BASE_REG, eaReg, ExtMod::UXTW);
+		casal(TEMP_GPR2.WReg, valReg, AdrNoOfs(TEMP_GPR1.XReg));
+		cmp(TEMP_GPR2.WReg, cmpValReg);
+		cset(outReg, Cond::EQ);
+	}
+	else
+	{
+		Label notEqual;
+		Label storeFailed;
+
+		add(TEMP_GPR1.XReg, MEM_BASE_REG, eaReg, ExtMod::UXTW);
+		L(storeFailed);
+		ldaxr(TEMP_GPR2.WReg, AdrNoOfs(TEMP_GPR1.XReg));
+		cmp(TEMP_GPR2.WReg, cmpValReg);
+		bne(notEqual);
+		stlxr(TEMP_GPR2.WReg, valReg, AdrNoOfs(TEMP_GPR1.XReg));
+		cbnz(TEMP_GPR2.WReg, storeFailed);
+
+		L(notEqual);
+		cset(outReg, Cond::EQ);
+	}
+}
+
+bool AArch64GenContext_t::fpr_load(IMLInstruction* imlInstruction, bool indexed)
+{
+	const IMLReg& dataReg = imlInstruction->op_storeLoad.registerData;
+	SReg dataSReg = fpReg<SReg>(dataReg);
+	DReg dataDReg = fpReg<DReg>(dataReg);
+	WReg realRegisterMem = gpReg<WReg>(imlInstruction->op_storeLoad.registerMem);
+	WReg indexReg = indexed ? gpReg<WReg>(imlInstruction->op_storeLoad.registerMem2) : wzr;
+	sint32 adrOffset = imlInstruction->op_storeLoad.immS32;
+	uint8 mode = imlInstruction->op_storeLoad.mode;
+
+	if (mode == PPCREC_FPR_LD_MODE_SINGLE)
+	{
+		add_imm(TEMP_GPR1.WReg, realRegisterMem, adrOffset, TEMP_GPR1.WReg);
+		if (indexed)
+			add(TEMP_GPR1.WReg, TEMP_GPR1.WReg, indexReg);
+		ldr(TEMP_GPR2.WReg, AdrExt(MEM_BASE_REG, TEMP_GPR1.WReg, ExtMod::UXTW));
+		rev(TEMP_GPR2.WReg, TEMP_GPR2.WReg);
+		fmov(dataSReg, TEMP_GPR2.WReg);
+
+		if (imlInstruction->op_storeLoad.flags2.notExpanded)
+		{
+			// leave value as single
+		}
+		else
+		{
+			fcvt(dataDReg, dataSReg);
+		}
+	}
+	else if (mode == PPCREC_FPR_LD_MODE_DOUBLE)
+	{
+		add_imm(TEMP_GPR1.WReg, realRegisterMem, adrOffset, TEMP_GPR1.WReg);
+		if (indexed)
+			add(TEMP_GPR1.WReg, TEMP_GPR1.WReg, indexReg);
+		ldr(TEMP_GPR2.XReg, AdrExt(MEM_BASE_REG, TEMP_GPR1.WReg, ExtMod::UXTW));
+		rev(TEMP_GPR2.XReg, TEMP_GPR2.XReg);
+		fmov(dataDReg, TEMP_GPR2.XReg);
+	}
+	else
+	{
+		return false;
+	}
+	return true;
+}
+
+// store to memory
+bool AArch64GenContext_t::fpr_store(IMLInstruction* imlInstruction, bool indexed)
+{
+	const IMLReg& dataImlReg = imlInstruction->op_storeLoad.registerData;
+	DReg dataDReg = fpReg<DReg>(dataImlReg);
+	SReg dataSReg = fpReg<SReg>(dataImlReg);
+	WReg memReg = gpReg<WReg>(imlInstruction->op_storeLoad.registerMem);
+	WReg indexReg = indexed ? gpReg<WReg>(imlInstruction->op_storeLoad.registerMem2) : wzr;
+	sint32 memOffset = imlInstruction->op_storeLoad.immS32;
+	uint8 mode = imlInstruction->op_storeLoad.mode;
+
+	if (mode == PPCREC_FPR_ST_MODE_SINGLE)
+	{
+		add_imm(TEMP_GPR1.WReg, memReg, memOffset, TEMP_GPR1.WReg);
+		if (indexed)
+			add(TEMP_GPR1.WReg, TEMP_GPR1.WReg, indexReg);
+
+		if (imlInstruction->op_storeLoad.flags2.notExpanded)
+		{
+			// value is already in single format
+			fmov(TEMP_GPR2.WReg, dataSReg);
+		}
+		else
+		{
+			fcvt(TEMP_FPR.SReg, dataDReg);
+			fmov(TEMP_GPR2.WReg, TEMP_FPR.SReg);
+		}
+		rev(TEMP_GPR2.WReg, TEMP_GPR2.WReg);
+		str(TEMP_GPR2.WReg, AdrExt(MEM_BASE_REG, TEMP_GPR1.WReg, ExtMod::UXTW));
+	}
+	else if (mode == PPCREC_FPR_ST_MODE_DOUBLE)
+	{
+		add_imm(TEMP_GPR1.WReg, memReg, memOffset, TEMP_GPR1.WReg);
+		if (indexed)
+			add(TEMP_GPR1.WReg, TEMP_GPR1.WReg, indexReg);
+		fmov(TEMP_GPR2.XReg, dataDReg);
+		rev(TEMP_GPR2.XReg, TEMP_GPR2.XReg);
+		str(TEMP_GPR2.XReg, AdrExt(MEM_BASE_REG, TEMP_GPR1.WReg, ExtMod::UXTW));
+	}
+	else if (mode == PPCREC_FPR_ST_MODE_UI32_FROM_PS0)
+	{
+		add_imm(TEMP_GPR1.WReg, memReg, memOffset, TEMP_GPR1.WReg);
+		if (indexed)
+			add(TEMP_GPR1.WReg, TEMP_GPR1.WReg, indexReg);
+		fmov(TEMP_GPR2.WReg, dataSReg);
+		rev(TEMP_GPR2.WReg, TEMP_GPR2.WReg);
+		str(TEMP_GPR2.WReg, AdrExt(MEM_BASE_REG, TEMP_GPR1.WReg, ExtMod::UXTW));
+	}
+	else
+	{
+		cemu_assert_suspicious();
+		cemuLog_log(LogType::Recompiler, "PPCRecompilerAArch64Gen_imlInstruction_fpr_store(): Unsupported mode %d\n", mode);
+		return false;
+	}
+	return true;
+}
+
+// FPR op FPR
+void AArch64GenContext_t::fpr_r_r(IMLInstruction* imlInstruction)
+{
+	auto imlRegR = imlInstruction->op_fpr_r_r.regR;
+	auto imlRegA = imlInstruction->op_fpr_r_r.regA;
+
+	if (imlInstruction->operation == PPCREC_IML_OP_FPR_FLOAT_TO_INT)
+	{
+		fcvtzs(gpReg<WReg>(imlRegR), fpReg<DReg>(imlRegA));
+		return;
+	}
+	else if (imlInstruction->operation == PPCREC_IML_OP_FPR_INT_TO_FLOAT)
+	{
+		scvtf(fpReg<DReg>(imlRegR), gpReg<WReg>(imlRegA));
+		return;
+	}
+	else if (imlInstruction->operation == PPCREC_IML_OP_FPR_BITCAST_INT_TO_FLOAT)
+	{
+		cemu_assert_debug(imlRegR.GetRegFormat() == IMLRegFormat::F64); // assuming target is always F64 for now
+		// exact operation depends on size of types. Floats are automatically promoted to double if the target is F64
+		DReg regFprDReg = fpReg<DReg>(imlRegR);
+		SReg regFprSReg = fpReg<SReg>(imlRegR);
+		if (imlRegA.GetRegFormat() == IMLRegFormat::I32)
+		{
+			fmov(regFprSReg, gpReg<WReg>(imlRegA));
+			// float to double
+			fcvt(regFprDReg, regFprSReg);
+		}
+		else if (imlRegA.GetRegFormat() == IMLRegFormat::I64)
+		{
+			fmov(regFprDReg, gpReg<XReg>(imlRegA));
+		}
+		else
+		{
+			cemu_assert_unimplemented();
+		}
+		return;
+	}
+
+	DReg regR = fpReg<DReg>(imlRegR);
+	DReg regA = fpReg<DReg>(imlRegA);
+
+	if (imlInstruction->operation == PPCREC_IML_OP_FPR_ASSIGN)
+	{
+		fmov(regR, regA);
+	}
+	else if (imlInstruction->operation == PPCREC_IML_OP_FPR_MULTIPLY)
+	{
+		fmul(regR, regR, regA);
+	}
+	else if (imlInstruction->operation == PPCREC_IML_OP_FPR_DIVIDE)
+	{
+		fdiv(regR, regR, regA);
+	}
+	else if (imlInstruction->operation == PPCREC_IML_OP_FPR_ADD)
+	{
+		fadd(regR, regR, regA);
+	}
+	else if (imlInstruction->operation == PPCREC_IML_OP_FPR_SUB)
+	{
+		fsub(regR, regR, regA);
+	}
+	else if (imlInstruction->operation == PPCREC_IML_OP_FPR_FCTIWZ)
+	{
+		fcvtzs(regR, regA);
+	}
+	else
+	{
+		cemu_assert_suspicious();
+	}
+}
+
+void AArch64GenContext_t::fpr_r_r_r(IMLInstruction* imlInstruction)
+{
+	DReg regR = fpReg<DReg>(imlInstruction->op_fpr_r_r_r.regR);
+	DReg regA = fpReg<DReg>(imlInstruction->op_fpr_r_r_r.regA);
+	DReg regB = fpReg<DReg>(imlInstruction->op_fpr_r_r_r.regB);
+
+	if (imlInstruction->operation == PPCREC_IML_OP_FPR_MULTIPLY)
+	{
+		fmul(regR, regA, regB);
+	}
+	else if (imlInstruction->operation == PPCREC_IML_OP_FPR_ADD)
+	{
+		fadd(regR, regA, regB);
+	}
+	else if (imlInstruction->operation == PPCREC_IML_OP_FPR_SUB)
+	{
+		fsub(regR, regA, regB);
+	}
+	else
+	{
+		cemu_assert_suspicious();
+	}
+}
+
+/*
+ * FPR = op (fprA, fprB, fprC)
+ */
+void AArch64GenContext_t::fpr_r_r_r_r(IMLInstruction* imlInstruction)
+{
+	DReg regR = fpReg<DReg>(imlInstruction->op_fpr_r_r_r_r.regR);
+	DReg regA = fpReg<DReg>(imlInstruction->op_fpr_r_r_r_r.regA);
+	DReg regB = fpReg<DReg>(imlInstruction->op_fpr_r_r_r_r.regB);
+	DReg regC = fpReg<DReg>(imlInstruction->op_fpr_r_r_r_r.regC);
+
+	if (imlInstruction->operation == PPCREC_IML_OP_FPR_SELECT)
+	{
+		fcmp(regA, 0.0);
+		fcsel(regR, regC, regB, Cond::GE);
+	}
+	else
+	{
+		cemu_assert_suspicious();
+	}
+}
+
+void AArch64GenContext_t::fpr_r(IMLInstruction* imlInstruction)
+{
+	DReg regRDReg = fpReg<DReg>(imlInstruction->op_fpr_r.regR);
+	SReg regRSReg = fpReg<SReg>(imlInstruction->op_fpr_r.regR);
+
+	if (imlInstruction->operation == PPCREC_IML_OP_FPR_NEGATE)
+	{
+		fneg(regRDReg, regRDReg);
+	}
+	else if (imlInstruction->operation == PPCREC_IML_OP_FPR_LOAD_ONE)
+	{
+		fmov(regRDReg, 1.0);
+	}
+	else if (imlInstruction->operation == PPCREC_IML_OP_FPR_ABS)
+	{
+		fabs(regRDReg, regRDReg);
+	}
+	else if (imlInstruction->operation == PPCREC_IML_OP_FPR_NEGATIVE_ABS)
+	{
+		fabs(regRDReg, regRDReg);
+		fneg(regRDReg, regRDReg);
+	}
+	else if (imlInstruction->operation == PPCREC_IML_OP_FPR_ROUND_TO_SINGLE_PRECISION_BOTTOM)
+	{
+		// convert to 32bit single
+		fcvt(regRSReg, regRDReg);
+		// convert back to 64bit double
+		fcvt(regRDReg, regRSReg);
+	}
+	else if (imlInstruction->operation == PPCREC_IML_OP_FPR_EXPAND_F32_TO_F64)
+	{
+		// convert bottom to 64bit double
+		fcvt(regRDReg, regRSReg);
+	}
+	else
+	{
+		cemu_assert_unimplemented();
+	}
+}
+
+Cond ImlFPCondToArm64Cond(IMLCondition cond)
+{
+	switch (cond)
+	{
+	case IMLCondition::UNORDERED_GT:
+		return Cond::GT;
+	case IMLCondition::UNORDERED_LT:
+		return Cond::MI;
+	case IMLCondition::UNORDERED_EQ:
+		return Cond::EQ;
+	case IMLCondition::UNORDERED_U:
+		return Cond::VS;
+	default:
+	{
+		cemu_assert_suspicious();
+		return Cond::EQ;
+	}
+	}
+}
+
+void AArch64GenContext_t::fpr_compare(IMLInstruction* imlInstruction)
+{
+	WReg regR = gpReg<WReg>(imlInstruction->op_fpr_compare.regR);
+	DReg regA = fpReg<DReg>(imlInstruction->op_fpr_compare.regA);
+	DReg regB = fpReg<DReg>(imlInstruction->op_fpr_compare.regB);
+	auto cond = ImlFPCondToArm64Cond(imlInstruction->op_fpr_compare.cond);
+	fcmp(regA, regB);
+	cset(regR, cond);
+}
+
+void AArch64GenContext_t::call_imm(IMLInstruction* imlInstruction)
+{
+	str(x30, AdrPreImm(sp, -16));
+	mov(TEMP_GPR1.XReg, imlInstruction->op_call_imm.callAddress);
+	blr(TEMP_GPR1.XReg);
+	ldr(x30, AdrPostImm(sp, 16));
+}
+
+bool PPCRecompiler_generateAArch64Code(struct PPCRecFunction_t* PPCRecFunction, struct ppcImlGenContext_t* ppcImlGenContext)
+{
+	AArch64Allocator allocator;
+	AArch64GenContext_t aarch64GenContext{&allocator};
+
+	// generate iml instruction code
+	bool codeGenerationFailed = false;
+	for (IMLSegment* segIt : ppcImlGenContext->segmentList2)
+	{
+		if (codeGenerationFailed)
+			break;
+		segIt->x64Offset = aarch64GenContext.getSize();
+
+		aarch64GenContext.storeSegmentStart(segIt);
+
+		for (size_t i = 0; i < segIt->imlList.size(); i++)
+		{
+			IMLInstruction* imlInstruction = segIt->imlList.data() + i;
+			if (imlInstruction->type == PPCREC_IML_TYPE_R_NAME)
+			{
+				aarch64GenContext.r_name(imlInstruction);
+			}
+			else if (imlInstruction->type == PPCREC_IML_TYPE_NAME_R)
+			{
+				aarch64GenContext.name_r(imlInstruction);
+			}
+			else if (imlInstruction->type == PPCREC_IML_TYPE_R_R)
+			{
+				if (!aarch64GenContext.r_r(imlInstruction))
+					codeGenerationFailed = true;
+			}
+			else if (imlInstruction->type == PPCREC_IML_TYPE_R_S32)
+			{
+				if (!aarch64GenContext.r_s32(imlInstruction))
+					codeGenerationFailed = true;
+			}
+			else if (imlInstruction->type == PPCREC_IML_TYPE_R_R_S32)
+			{
+				if (!aarch64GenContext.r_r_s32(imlInstruction))
+					codeGenerationFailed = true;
+			}
+			else if (imlInstruction->type == PPCREC_IML_TYPE_R_R_S32_CARRY)
+			{
+				if (!aarch64GenContext.r_r_s32_carry(imlInstruction))
+					codeGenerationFailed = true;
+			}
+			else if (imlInstruction->type == PPCREC_IML_TYPE_R_R_R)
+			{
+				if (!aarch64GenContext.r_r_r(imlInstruction))
+					codeGenerationFailed = true;
+			}
+			else if (imlInstruction->type == PPCREC_IML_TYPE_R_R_R_CARRY)
+			{
+				if (!aarch64GenContext.r_r_r_carry(imlInstruction))
+					codeGenerationFailed = true;
+			}
+			else if (imlInstruction->type == PPCREC_IML_TYPE_COMPARE)
+			{
+				aarch64GenContext.compare(imlInstruction);
+			}
+			else if (imlInstruction->type == PPCREC_IML_TYPE_COMPARE_S32)
+			{
+				aarch64GenContext.compare_s32(imlInstruction);
+			}
+			else if (imlInstruction->type == PPCREC_IML_TYPE_CONDITIONAL_JUMP)
+			{
+				aarch64GenContext.cjump(imlInstruction, segIt);
+			}
+			else if (imlInstruction->type == PPCREC_IML_TYPE_JUMP)
+			{
+				aarch64GenContext.jump(segIt);
+			}
+			else if (imlInstruction->type == PPCREC_IML_TYPE_CJUMP_CYCLE_CHECK)
+			{
+				aarch64GenContext.conditionalJumpCycleCheck(segIt);
+			}
+			else if (imlInstruction->type == PPCREC_IML_TYPE_MACRO)
+			{
+				if (!aarch64GenContext.macro(imlInstruction))
+					codeGenerationFailed = true;
+			}
+			else if (imlInstruction->type == PPCREC_IML_TYPE_LOAD)
+			{
+				if (!aarch64GenContext.load(imlInstruction, false))
+					codeGenerationFailed = true;
+			}
+			else if (imlInstruction->type == PPCREC_IML_TYPE_LOAD_INDEXED)
+			{
+				if (!aarch64GenContext.load(imlInstruction, true))
+					codeGenerationFailed = true;
+			}
+			else if (imlInstruction->type == PPCREC_IML_TYPE_STORE)
+			{
+				if (!aarch64GenContext.store(imlInstruction, false))
+					codeGenerationFailed = true;
+			}
+			else if (imlInstruction->type == PPCREC_IML_TYPE_STORE_INDEXED)
+			{
+				if (!aarch64GenContext.store(imlInstruction, true))
+					codeGenerationFailed = true;
+			}
+			else if (imlInstruction->type == PPCREC_IML_TYPE_ATOMIC_CMP_STORE)
+			{
+				aarch64GenContext.atomic_cmp_store(imlInstruction);
+			}
+			else if (imlInstruction->type == PPCREC_IML_TYPE_CALL_IMM)
+			{
+				aarch64GenContext.call_imm(imlInstruction);
+			}
+			else if (imlInstruction->type == PPCREC_IML_TYPE_NO_OP)
+			{
+				// no op
+			}
+			else if (imlInstruction->type == PPCREC_IML_TYPE_FPR_LOAD)
+			{
+				if (!aarch64GenContext.fpr_load(imlInstruction, false))
+					codeGenerationFailed = true;
+			}
+			else if (imlInstruction->type == PPCREC_IML_TYPE_FPR_LOAD_INDEXED)
+			{
+				if (!aarch64GenContext.fpr_load(imlInstruction, true))
+					codeGenerationFailed = true;
+			}
+			else if (imlInstruction->type == PPCREC_IML_TYPE_FPR_STORE)
+			{
+				if (!aarch64GenContext.fpr_store(imlInstruction, false))
+					codeGenerationFailed = true;
+			}
+			else if (imlInstruction->type == PPCREC_IML_TYPE_FPR_STORE_INDEXED)
+			{
+				if (!aarch64GenContext.fpr_store(imlInstruction, true))
+					codeGenerationFailed = true;
+			}
+			else if (imlInstruction->type == PPCREC_IML_TYPE_FPR_R_R)
+			{
+				aarch64GenContext.fpr_r_r(imlInstruction);
+			}
+			else if (imlInstruction->type == PPCREC_IML_TYPE_FPR_R_R_R)
+			{
+				aarch64GenContext.fpr_r_r_r(imlInstruction);
+			}
+			else if (imlInstruction->type == PPCREC_IML_TYPE_FPR_R_R_R_R)
+			{
+				aarch64GenContext.fpr_r_r_r_r(imlInstruction);
+			}
+			else if (imlInstruction->type == PPCREC_IML_TYPE_FPR_R)
+			{
+				aarch64GenContext.fpr_r(imlInstruction);
+			}
+			else if (imlInstruction->type == PPCREC_IML_TYPE_FPR_COMPARE)
+			{
+				aarch64GenContext.fpr_compare(imlInstruction);
+			}
+			else
+			{
+				codeGenerationFailed = true;
+				cemu_assert_suspicious();
+				cemuLog_log(LogType::Recompiler, "PPCRecompiler_generateAArch64Code(): Unsupported iml type {}", imlInstruction->type);
+			}
+		}
+	}
+
+	// handle failed code generation
+	if (codeGenerationFailed)
+	{
+		return false;
+	}
+
+	if (!aarch64GenContext.processAllJumps())
+	{
+		cemuLog_log(LogType::Recompiler, "PPCRecompiler_generateAArch64Code(): some jumps exceeded the +/-128MB offset.");
+		return false;
+	}
+
+	aarch64GenContext.readyRE();
+
+	// set code
+	PPCRecFunction->x86Code = aarch64GenContext.getCode<void*>();
+	PPCRecFunction->x86Size = aarch64GenContext.getMaxSize();
+	// set free disabled to skip freeing the code from the CodeGenerator destructor
+	allocator.setFreeDisabled(true);
+	return true;
+}
+
+void PPCRecompiler_cleanupAArch64Code(void* code, size_t size)
+{
+	AArch64Allocator allocator;
+	if (allocator.useProtect())
+		CodeArray::protect(code, size, CodeArray::PROTECT_RW);
+	allocator.free(static_cast<uint32*>(code));
+}
+
+void AArch64GenContext_t::enterRecompilerCode()
+{
+	constexpr size_t STACK_SIZE = 160 /* x19 .. x30 + v8.d[0] .. v15.d[0] */;
+	static_assert(STACK_SIZE % 16 == 0);
+	sub(sp, sp, STACK_SIZE);
+	mov(x9, sp);
+
+	stp(x19, x20, AdrPostImm(x9, 16));
+	stp(x21, x22, AdrPostImm(x9, 16));
+	stp(x23, x24, AdrPostImm(x9, 16));
+	stp(x25, x26, AdrPostImm(x9, 16));
+	stp(x27, x28, AdrPostImm(x9, 16));
+	stp(x29, x30, AdrPostImm(x9, 16));
+	st4((v8.d - v11.d)[0], AdrPostImm(x9, 32));
+	st4((v12.d - v15.d)[0], AdrPostImm(x9, 32));
+	mov(HCPU_REG, x1); // call argument 2
+	mov(PPC_REC_INSTANCE_REG, (uint64)ppcRecompilerInstanceData);
+	mov(MEM_BASE_REG, (uint64)memory_base);
+
+	// branch to recFunc
+	blr(x0); // call argument 1
+
+	mov(x9, sp);
+	ldp(x19, x20, AdrPostImm(x9, 16));
+	ldp(x21, x22, AdrPostImm(x9, 16));
+	ldp(x23, x24, AdrPostImm(x9, 16));
+	ldp(x25, x26, AdrPostImm(x9, 16));
+	ldp(x27, x28, AdrPostImm(x9, 16));
+	ldp(x29, x30, AdrPostImm(x9, 16));
+	ld4((v8.d - v11.d)[0], AdrPostImm(x9, 32));
+	ld4((v12.d - v15.d)[0], AdrPostImm(x9, 32));
+
+	add(sp, sp, STACK_SIZE);
+
+	ret();
+}
+
+void AArch64GenContext_t::leaveRecompilerCode()
+{
+	str(LR.WReg, AdrUimm(HCPU_REG, offsetof(PPCInterpreter_t, instructionPointer)));
+	ret();
+}
+
+bool initializedInterfaceFunctions = false;
+AArch64GenContext_t enterRecompilerCode_ctx{};
+
+AArch64GenContext_t leaveRecompilerCode_unvisited_ctx{};
+AArch64GenContext_t leaveRecompilerCode_visited_ctx{};
+void PPCRecompilerAArch64Gen_generateRecompilerInterfaceFunctions()
+{
+	if (initializedInterfaceFunctions)
+		return;
+	initializedInterfaceFunctions = true;
+
+	enterRecompilerCode_ctx.enterRecompilerCode();
+	enterRecompilerCode_ctx.readyRE();
+	PPCRecompiler_enterRecompilerCode = enterRecompilerCode_ctx.getCode<decltype(PPCRecompiler_enterRecompilerCode)>();
+
+	leaveRecompilerCode_unvisited_ctx.leaveRecompilerCode();
+	leaveRecompilerCode_unvisited_ctx.readyRE();
+	PPCRecompiler_leaveRecompilerCode_unvisited = leaveRecompilerCode_unvisited_ctx.getCode<decltype(PPCRecompiler_leaveRecompilerCode_unvisited)>();
+
+	leaveRecompilerCode_visited_ctx.leaveRecompilerCode();
+	leaveRecompilerCode_visited_ctx.readyRE();
+	PPCRecompiler_leaveRecompilerCode_visited = leaveRecompilerCode_visited_ctx.getCode<decltype(PPCRecompiler_leaveRecompilerCode_visited)>();
+}
diff --git a/src/Cafe/HW/Espresso/Recompiler/BackendAArch64/BackendAArch64.h b/src/Cafe/HW/Espresso/Recompiler/BackendAArch64/BackendAArch64.h
new file mode 100644
index 00000000..b610ee04
--- /dev/null
+++ b/src/Cafe/HW/Espresso/Recompiler/BackendAArch64/BackendAArch64.h
@@ -0,0 +1,18 @@
+#pragma once
+
+#include "HW/Espresso/Recompiler/IML/IMLInstruction.h"
+#include "../PPCRecompiler.h"
+
+bool PPCRecompiler_generateAArch64Code(struct PPCRecFunction_t* PPCRecFunction, struct ppcImlGenContext_t* ppcImlGenContext);
+void PPCRecompiler_cleanupAArch64Code(void* code, size_t size);
+
+void PPCRecompilerAArch64Gen_generateRecompilerInterfaceFunctions();
+
+// architecture specific constants
+namespace IMLArchAArch64
+{
+	static constexpr int PHYSREG_GPR_BASE = 0;
+	static constexpr int PHYSREG_GPR_COUNT = 25;
+	static constexpr int PHYSREG_FPR_BASE = PHYSREG_GPR_COUNT;
+	static constexpr int PHYSREG_FPR_COUNT = 31;
+}; // namespace IMLArchAArch64
\ No newline at end of file
diff --git a/src/Cafe/HW/Espresso/Recompiler/BackendX64/BackendX64.cpp b/src/Cafe/HW/Espresso/Recompiler/BackendX64/BackendX64.cpp
new file mode 100644
index 00000000..eadb80fb
--- /dev/null
+++ b/src/Cafe/HW/Espresso/Recompiler/BackendX64/BackendX64.cpp
@@ -0,0 +1,1672 @@
+#include "Cafe/HW/Espresso/PPCState.h"
+#include "Cafe/HW/Espresso/Interpreter/PPCInterpreterInternal.h"
+#include "Cafe/HW/Espresso/Interpreter/PPCInterpreterHelper.h"
+#include "../PPCRecompiler.h"
+#include "../PPCRecompilerIml.h"
+#include "BackendX64.h"
+#include "Cafe/OS/libs/coreinit/coreinit_Time.h"
+#include "util/MemMapper/MemMapper.h"
+#include "Common/cpu_features.h"
+#include <boost/container/static_vector.hpp>
+
+static x86Assembler64::GPR32 _reg32(IMLReg physReg)
+{
+	cemu_assert_debug(physReg.GetRegFormat() == IMLRegFormat::I32);
+	IMLRegID regId = physReg.GetRegID();
+	cemu_assert_debug(regId < 16);
+	return (x86Assembler64::GPR32)regId;
+}
+
+static uint32 _reg64(IMLReg physReg)
+{
+	cemu_assert_debug(physReg.GetRegFormat() == IMLRegFormat::I64);
+	IMLRegID regId = physReg.GetRegID();
+	cemu_assert_debug(regId < 16);
+	return regId;
+}
+
+uint32 _regF64(IMLReg physReg)
+{
+	cemu_assert_debug(physReg.GetRegFormat() == IMLRegFormat::F64);
+	IMLRegID regId = physReg.GetRegID();
+	cemu_assert_debug(regId >= IMLArchX86::PHYSREG_FPR_BASE && regId < IMLArchX86::PHYSREG_FPR_BASE+16);
+	regId -= IMLArchX86::PHYSREG_FPR_BASE;
+	return regId;
+}
+
+static x86Assembler64::GPR8_REX _reg8(IMLReg physReg)
+{
+	cemu_assert_debug(physReg.GetRegFormat() == IMLRegFormat::I32); // for now these are represented as 32bit
+	return (x86Assembler64::GPR8_REX)physReg.GetRegID();
+}
+
+static x86Assembler64::GPR32 _reg32_from_reg8(x86Assembler64::GPR8_REX regId)
+{
+	return (x86Assembler64::GPR32)regId;
+}
+
+static x86Assembler64::GPR8_REX _reg8_from_reg32(x86Assembler64::GPR32 regId)
+{
+	return (x86Assembler64::GPR8_REX)regId;
+}
+
+static x86Assembler64::GPR8_REX _reg8_from_reg64(uint32 regId)
+{
+	return (x86Assembler64::GPR8_REX)regId;
+}
+
+static x86Assembler64::GPR64 _reg64_from_reg32(x86Assembler64::GPR32 regId)
+{
+	return (x86Assembler64::GPR64)regId;
+}
+
+X86Cond _x86Cond(IMLCondition imlCond)
+{
+	switch (imlCond)
+	{
+	case IMLCondition::EQ:
+		return X86_CONDITION_Z;
+	case IMLCondition::NEQ:
+		return X86_CONDITION_NZ;
+	case IMLCondition::UNSIGNED_GT:
+		return X86_CONDITION_NBE;
+	case IMLCondition::UNSIGNED_LT:
+		return X86_CONDITION_B;
+	case IMLCondition::SIGNED_GT:
+		return X86_CONDITION_NLE;
+	case IMLCondition::SIGNED_LT:
+		return X86_CONDITION_L;
+	default:
+		break;
+	}
+	cemu_assert_suspicious();
+	return X86_CONDITION_Z;
+}
+
+X86Cond _x86CondInverted(IMLCondition imlCond)
+{
+	switch (imlCond)
+	{
+	case IMLCondition::EQ:
+		return X86_CONDITION_NZ;
+	case IMLCondition::NEQ:
+		return X86_CONDITION_Z;
+	case IMLCondition::UNSIGNED_GT:
+		return X86_CONDITION_BE;
+	case IMLCondition::UNSIGNED_LT:
+		return X86_CONDITION_NB;
+	case IMLCondition::SIGNED_GT:
+		return X86_CONDITION_LE;
+	case IMLCondition::SIGNED_LT:
+		return X86_CONDITION_NL;
+	default:
+		break;
+	}
+	cemu_assert_suspicious();
+	return X86_CONDITION_Z;
+}
+
+X86Cond _x86Cond(IMLCondition imlCond, bool condIsInverted)
+{
+	if (condIsInverted)
+		return _x86CondInverted(imlCond);
+	return _x86Cond(imlCond);
+}
+
+/*
+* Remember current instruction output offset for reloc
+* The instruction generated after this method has been called will be adjusted
+*/
+void PPCRecompilerX64Gen_rememberRelocatableOffset(x64GenContext_t* x64GenContext, void* extraInfo = nullptr)
+{
+	x64GenContext->relocateOffsetTable2.emplace_back(x64GenContext->emitter->GetWriteIndex(), extraInfo);
+}
+
+void PPCRecompilerX64Gen_redirectRelativeJump(x64GenContext_t* x64GenContext, sint32 jumpInstructionOffset, sint32 destinationOffset)
+{
+	uint8* instructionData = x64GenContext->emitter->GetBufferPtr() + jumpInstructionOffset;
+	if (instructionData[0] == 0x0F && (instructionData[1] >= 0x80 && instructionData[1] <= 0x8F))
+	{
+		// far conditional jump
+		*(uint32*)(instructionData + 2) = (destinationOffset - (jumpInstructionOffset + 6));
+	}
+	else if (instructionData[0] >= 0x70 && instructionData[0] <= 0x7F)
+	{
+		// short conditional jump
+		sint32 distance = (sint32)((destinationOffset - (jumpInstructionOffset + 2)));
+		cemu_assert_debug(distance >= -128 && distance <= 127);
+		*(uint8*)(instructionData + 1) = (uint8)distance;
+	}
+	else if (instructionData[0] == 0xE9)
+	{
+		*(uint32*)(instructionData + 1) = (destinationOffset - (jumpInstructionOffset + 5));
+	}
+	else if (instructionData[0] == 0xEB)
+	{
+		sint32 distance = (sint32)((destinationOffset - (jumpInstructionOffset + 2)));
+		cemu_assert_debug(distance >= -128 && distance <= 127);
+		*(uint8*)(instructionData + 1) = (uint8)distance;
+	}
+	else
+	{
+		assert_dbg();
+	}
+}
+
+void* ATTR_MS_ABI PPCRecompiler_virtualHLE(PPCInterpreter_t* hCPU, uint32 hleFuncId)
+{
+	void* prevRSPTemp = hCPU->rspTemp;
+	if( hleFuncId == 0xFFD0 )
+	{
+		hCPU->remainingCycles -= 500; // let subtract about 500 cycles for each HLE call
+		hCPU->gpr[3] = 0;
+		PPCInterpreter_nextInstruction(hCPU);
+		return hCPU;
+	}
+	else
+	{
+		auto hleCall = PPCInterpreter_getHLECall(hleFuncId);
+		cemu_assert(hleCall != nullptr);
+		hleCall(hCPU);
+	}
+	hCPU->rspTemp = prevRSPTemp;
+	return PPCInterpreter_getCurrentInstance();
+}
+
+bool PPCRecompilerX64Gen_imlInstruction_macro(PPCRecFunction_t* PPCRecFunction, ppcImlGenContext_t* ppcImlGenContext, x64GenContext_t* x64GenContext, IMLInstruction* imlInstruction)
+{
+	if (imlInstruction->operation == PPCREC_IML_MACRO_B_TO_REG)
+	{
+		//x64Gen_int3(x64GenContext);
+		uint32 branchDstReg = _reg32(imlInstruction->op_macro.paramReg);
+		if(X86_REG_RDX != branchDstReg)
+			x64Gen_mov_reg64_reg64(x64GenContext, X86_REG_RDX, branchDstReg);
+		// potential optimization: Use branchDstReg directly if possible instead of moving to RDX/EDX
+		// JMP [offset+RDX*(8/4)+R15]
+		x64Gen_writeU8(x64GenContext, 0x41);
+		x64Gen_writeU8(x64GenContext, 0xFF);
+		x64Gen_writeU8(x64GenContext, 0xA4);
+		x64Gen_writeU8(x64GenContext, 0x57);
+		x64Gen_writeU32(x64GenContext, (uint32)offsetof(PPCRecompilerInstanceData_t, ppcRecompilerDirectJumpTable));
+		return true;
+	}
+	else if( imlInstruction->operation == PPCREC_IML_MACRO_BL )
+	{
+		// MOV DWORD [SPR_LinkRegister], newLR
+		uint32 newLR = imlInstruction->op_macro.param + 4;
+		x64Gen_mov_mem32Reg64_imm32(x64GenContext, REG_RESV_HCPU, offsetof(PPCInterpreter_t, spr.LR), newLR);
+		// remember new instruction pointer in RDX
+		uint32 newIP = imlInstruction->op_macro.param2;
+		x64Gen_mov_reg64Low32_imm32(x64GenContext, X86_REG_RDX, newIP);
+		// since RDX is constant we can use JMP [R15+const_offset] if jumpTableOffset+RDX*2 does not exceed the 2GB boundary
+		uint64 lookupOffset = (uint64)offsetof(PPCRecompilerInstanceData_t, ppcRecompilerDirectJumpTable) + (uint64)newIP * 2ULL;
+		if (lookupOffset >= 0x80000000ULL)
+		{
+			// JMP [offset+RDX*(8/4)+R15]
+			x64Gen_writeU8(x64GenContext, 0x41);
+			x64Gen_writeU8(x64GenContext, 0xFF);
+			x64Gen_writeU8(x64GenContext, 0xA4);
+			x64Gen_writeU8(x64GenContext, 0x57);
+			x64Gen_writeU32(x64GenContext, (uint32)offsetof(PPCRecompilerInstanceData_t, ppcRecompilerDirectJumpTable));
+		}
+		else
+		{
+			x64Gen_writeU8(x64GenContext, 0x41);
+			x64Gen_writeU8(x64GenContext, 0xFF);
+			x64Gen_writeU8(x64GenContext, 0xA7);
+			x64Gen_writeU32(x64GenContext, (uint32)lookupOffset);
+		}
+		return true;
+	}
+	else if( imlInstruction->operation == PPCREC_IML_MACRO_B_FAR )
+	{
+		// remember new instruction pointer in RDX
+		uint32 newIP = imlInstruction->op_macro.param2;
+		x64Gen_mov_reg64Low32_imm32(x64GenContext, X86_REG_RDX, newIP);
+		// Since RDX is constant we can use JMP [R15+const_offset] if jumpTableOffset+RDX*2 does not exceed the 2GB boundary
+		uint64 lookupOffset = (uint64)offsetof(PPCRecompilerInstanceData_t, ppcRecompilerDirectJumpTable) + (uint64)newIP * 2ULL;
+		if (lookupOffset >= 0x80000000ULL)
+		{
+			// JMP [offset+RDX*(8/4)+R15]
+			x64Gen_writeU8(x64GenContext, 0x41);
+			x64Gen_writeU8(x64GenContext, 0xFF);
+			x64Gen_writeU8(x64GenContext, 0xA4);
+			x64Gen_writeU8(x64GenContext, 0x57);
+			x64Gen_writeU32(x64GenContext, (uint32)offsetof(PPCRecompilerInstanceData_t, ppcRecompilerDirectJumpTable));
+		}
+		else
+		{
+			x64Gen_writeU8(x64GenContext, 0x41);
+			x64Gen_writeU8(x64GenContext, 0xFF);
+			x64Gen_writeU8(x64GenContext, 0xA7);
+			x64Gen_writeU32(x64GenContext, (uint32)lookupOffset);
+		}
+		return true;
+	}
+	else if( imlInstruction->operation == PPCREC_IML_MACRO_LEAVE )
+	{
+		uint32 currentInstructionAddress = imlInstruction->op_macro.param;
+		// remember PC value in REG_EDX
+		x64Gen_mov_reg64Low32_imm32(x64GenContext, X86_REG_RDX, currentInstructionAddress);
+
+		uint32 newIP = 0; // special value for recompiler exit
+		uint64 lookupOffset = (uint64)&(((PPCRecompilerInstanceData_t*)NULL)->ppcRecompilerDirectJumpTable) + (uint64)newIP * 2ULL;
+		// JMP [R15+offset]
+		x64Gen_writeU8(x64GenContext, 0x41);
+		x64Gen_writeU8(x64GenContext, 0xFF);
+		x64Gen_writeU8(x64GenContext, 0xA7);
+		x64Gen_writeU32(x64GenContext, (uint32)lookupOffset);
+		return true;
+	}
+	else if( imlInstruction->operation == PPCREC_IML_MACRO_DEBUGBREAK )
+	{
+		x64Gen_mov_reg64Low32_imm32(x64GenContext, REG_RESV_TEMP, imlInstruction->op_macro.param2);
+		x64Gen_int3(x64GenContext);
+		return true;
+	}
+	else if( imlInstruction->operation == PPCREC_IML_MACRO_COUNT_CYCLES )
+	{
+		uint32 cycleCount = imlInstruction->op_macro.param;
+		x64Gen_sub_mem32reg64_imm32(x64GenContext, REG_RESV_HCPU, offsetof(PPCInterpreter_t, remainingCycles), cycleCount);
+		return true;
+	}
+	else if( imlInstruction->operation == PPCREC_IML_MACRO_HLE )
+	{
+		uint32 ppcAddress = imlInstruction->op_macro.param;
+		uint32 funcId = imlInstruction->op_macro.param2;
+		// update instruction pointer
+		x64Gen_mov_mem32Reg64_imm32(x64GenContext, REG_RESV_HCPU, offsetof(PPCInterpreter_t, instructionPointer), ppcAddress);
+		// set parameters
+		x64Gen_mov_reg64_reg64(x64GenContext, X86_REG_RCX, REG_RESV_HCPU);
+		x64Gen_mov_reg64_imm64(x64GenContext, X86_REG_RDX, funcId);
+		// restore stackpointer from hCPU->rspTemp
+		x64Emit_mov_reg64_mem64(x64GenContext, X86_REG_RSP, REG_RESV_HCPU, offsetof(PPCInterpreter_t, rspTemp));
+		// reserve space on stack for call parameters
+		x64Gen_sub_reg64_imm32(x64GenContext, X86_REG_RSP, 8*11); // must be uneven number in order to retain stack 0x10 alignment
+		x64Gen_mov_reg64_imm64(x64GenContext, X86_REG_RBP, 0);
+		// call HLE function
+		x64Gen_mov_reg64_imm64(x64GenContext, X86_REG_RAX, (uint64)PPCRecompiler_virtualHLE);
+		x64Gen_call_reg64(x64GenContext, X86_REG_RAX);
+		// restore RSP to hCPU (from RAX, result of PPCRecompiler_virtualHLE)
+		x64Gen_mov_reg64_reg64(x64GenContext, REG_RESV_HCPU, X86_REG_RAX);
+		// MOV R15, ppcRecompilerInstanceData
+		x64Gen_mov_reg64_imm64(x64GenContext, REG_RESV_RECDATA, (uint64)ppcRecompilerInstanceData);
+		// MOV R13, memory_base
+		x64Gen_mov_reg64_imm64(x64GenContext, REG_RESV_MEMBASE, (uint64)memory_base);
+		// check if cycles where decreased beyond zero, if yes -> leave recompiler
+		x64Gen_bt_mem8(x64GenContext, REG_RESV_HCPU, offsetof(PPCInterpreter_t, remainingCycles), 31); // check if negative
+		sint32 jumpInstructionOffset1 = x64GenContext->emitter->GetWriteIndex();
+		x64Gen_jmpc_near(x64GenContext, X86_CONDITION_NOT_CARRY, 0);
+
+		x64Emit_mov_reg64_mem32(x64GenContext, X86_REG_RDX, REG_RESV_HCPU, offsetof(PPCInterpreter_t, instructionPointer));
+		// set EAX to 0 (we assume that ppcRecompilerDirectJumpTable[0] will be a recompiler escape function)
+		x64Gen_xor_reg32_reg32(x64GenContext, X86_REG_RAX, X86_REG_RAX);
+		// ADD RAX, REG_RESV_RECDATA
+		x64Gen_add_reg64_reg64(x64GenContext, X86_REG_RAX, REG_RESV_RECDATA);
+		// JMP [recompilerCallTable+EAX/4*8]
+		x64Gen_jmp_memReg64(x64GenContext, X86_REG_RAX, (uint32)offsetof(PPCRecompilerInstanceData_t, ppcRecompilerDirectJumpTable));
+		PPCRecompilerX64Gen_redirectRelativeJump(x64GenContext, jumpInstructionOffset1, x64GenContext->emitter->GetWriteIndex());
+		// check if instruction pointer was changed
+		// assign new instruction pointer to EAX
+		x64Emit_mov_reg64_mem32(x64GenContext, X86_REG_RAX, REG_RESV_HCPU, offsetof(PPCInterpreter_t, instructionPointer));
+		// remember instruction pointer in REG_EDX
+		x64Gen_mov_reg64_reg64(x64GenContext, X86_REG_RDX, X86_REG_RAX);
+		// EAX *= 2
+		x64Gen_add_reg64_reg64(x64GenContext, X86_REG_RAX, X86_REG_RAX);
+		// ADD RAX, REG_RESV_RECDATA
+		x64Gen_add_reg64_reg64(x64GenContext, X86_REG_RAX, REG_RESV_RECDATA);
+		// JMP [ppcRecompilerDirectJumpTable+RAX/4*8]
+		x64Gen_jmp_memReg64(x64GenContext, X86_REG_RAX, (uint32)offsetof(PPCRecompilerInstanceData_t, ppcRecompilerDirectJumpTable));
+		return true;
+	}
+	else
+	{
+		debug_printf("Unknown recompiler macro operation %d\n", imlInstruction->operation);
+		assert_dbg();
+	}
+	return false;
+}
+
+/*
+* Load from memory
+*/
+bool PPCRecompilerX64Gen_imlInstruction_load(PPCRecFunction_t* PPCRecFunction, ppcImlGenContext_t* ppcImlGenContext, x64GenContext_t* x64GenContext, IMLInstruction* imlInstruction, bool indexed)
+{
+	cemu_assert_debug(imlInstruction->op_storeLoad.registerData.GetRegFormat() == IMLRegFormat::I32);
+	cemu_assert_debug(imlInstruction->op_storeLoad.registerMem.GetRegFormat() == IMLRegFormat::I32);
+	if (indexed)
+		cemu_assert_debug(imlInstruction->op_storeLoad.registerMem2.GetRegFormat() == IMLRegFormat::I32);
+
+	IMLRegID realRegisterData = imlInstruction->op_storeLoad.registerData.GetRegID();
+	IMLRegID realRegisterMem = imlInstruction->op_storeLoad.registerMem.GetRegID();
+	IMLRegID realRegisterMem2 = PPC_REC_INVALID_REGISTER;
+	if( indexed )
+		realRegisterMem2 = imlInstruction->op_storeLoad.registerMem2.GetRegID();
+	if( indexed && realRegisterMem == realRegisterMem2 )
+	{
+		return false;
+	}
+	if( indexed && realRegisterData == realRegisterMem2 )
+	{
+		// for indexed memory access realRegisterData must not be the same register as the second memory register,
+		// this can easily be worked around by swapping realRegisterMem and realRegisterMem2
+		std::swap(realRegisterMem, realRegisterMem2);
+	}
+
+	bool signExtend = imlInstruction->op_storeLoad.flags2.signExtend;
+	bool switchEndian = imlInstruction->op_storeLoad.flags2.swapEndian;
+	if( imlInstruction->op_storeLoad.copyWidth == 32 )
+	{
+		if (indexed)
+		{
+			x64Gen_lea_reg64Low32_reg64Low32PlusReg64Low32(x64GenContext, REG_RESV_TEMP, realRegisterMem, realRegisterMem2);
+		}
+		if( g_CPUFeatures.x86.movbe && switchEndian )
+		{
+			if (indexed)
+			{
+				x64Gen_movBEZeroExtend_reg64_mem32Reg64PlusReg64(x64GenContext, realRegisterData, REG_RESV_MEMBASE, REG_RESV_TEMP, imlInstruction->op_storeLoad.immS32);
+			}
+			else
+			{
+				x64Gen_movBEZeroExtend_reg64_mem32Reg64PlusReg64(x64GenContext, realRegisterData, REG_RESV_MEMBASE, realRegisterMem, imlInstruction->op_storeLoad.immS32);
+			}
+		}
+		else
+		{
+			if (indexed)
+			{
+				x64Emit_mov_reg32_mem32(x64GenContext, realRegisterData, REG_RESV_MEMBASE, REG_RESV_TEMP, imlInstruction->op_storeLoad.immS32);
+				if (switchEndian)
+					x64Gen_bswap_reg64Lower32bit(x64GenContext, realRegisterData);
+			}
+			else
+			{
+				x64Emit_mov_reg32_mem32(x64GenContext, realRegisterData, REG_RESV_MEMBASE, realRegisterMem, imlInstruction->op_storeLoad.immS32);
+				if (switchEndian)
+					x64Gen_bswap_reg64Lower32bit(x64GenContext, realRegisterData);
+			}
+		}
+	}
+	else if( imlInstruction->op_storeLoad.copyWidth == 16 )
+	{
+		if (indexed)
+		{
+			x64Gen_add_reg64Low32_reg64Low32(x64GenContext, realRegisterMem, realRegisterMem2);
+		}			
+		if(g_CPUFeatures.x86.movbe && switchEndian )
+		{
+			x64Gen_movBEZeroExtend_reg64Low16_mem16Reg64PlusReg64(x64GenContext, realRegisterData, REG_RESV_MEMBASE, realRegisterMem, imlInstruction->op_storeLoad.immS32);
+			if( indexed && realRegisterMem != realRegisterData )
+				x64Gen_sub_reg64Low32_reg64Low32(x64GenContext, realRegisterMem, realRegisterMem2);
+		}
+		else
+		{
+			x64Gen_movZeroExtend_reg64Low16_mem16Reg64PlusReg64(x64GenContext, realRegisterData, REG_RESV_MEMBASE, realRegisterMem, imlInstruction->op_storeLoad.immS32);
+			if( indexed && realRegisterMem != realRegisterData )
+				x64Gen_sub_reg64Low32_reg64Low32(x64GenContext, realRegisterMem, realRegisterMem2);
+			if( switchEndian )
+				x64Gen_rol_reg64Low16_imm8(x64GenContext, realRegisterData, 8);
+		}
+		if( signExtend )
+			x64Gen_movSignExtend_reg64Low32_reg64Low16(x64GenContext, realRegisterData, realRegisterData);
+		else
+			x64Gen_movZeroExtend_reg64Low32_reg64Low16(x64GenContext, realRegisterData, realRegisterData);
+	}
+	else if( imlInstruction->op_storeLoad.copyWidth == 8 )
+	{
+		if( indexed )
+			x64Gen_add_reg64Low32_reg64Low32(x64GenContext, realRegisterMem, realRegisterMem2);
+		if( signExtend )
+			x64Gen_movSignExtend_reg64Low32_mem8Reg64PlusReg64(x64GenContext, realRegisterData, REG_RESV_MEMBASE, realRegisterMem, imlInstruction->op_storeLoad.immS32);
+		else
+			x64Emit_movZX_reg32_mem8(x64GenContext, realRegisterData, REG_RESV_MEMBASE, realRegisterMem, imlInstruction->op_storeLoad.immS32);
+		if( indexed && realRegisterMem != realRegisterData )
+			x64Gen_sub_reg64Low32_reg64Low32(x64GenContext, realRegisterMem, realRegisterMem2);
+	}
+	else
+		return false;
+	return true;
+}
+
+/*
+* Write to memory
+*/
+bool PPCRecompilerX64Gen_imlInstruction_store(PPCRecFunction_t* PPCRecFunction, ppcImlGenContext_t* ppcImlGenContext, x64GenContext_t* x64GenContext, IMLInstruction* imlInstruction, bool indexed)
+{
+	cemu_assert_debug(imlInstruction->op_storeLoad.registerData.GetRegFormat() == IMLRegFormat::I32);
+	cemu_assert_debug(imlInstruction->op_storeLoad.registerMem.GetRegFormat() == IMLRegFormat::I32);
+	if (indexed)
+		cemu_assert_debug(imlInstruction->op_storeLoad.registerMem2.GetRegFormat() == IMLRegFormat::I32);
+
+	IMLRegID realRegisterData = imlInstruction->op_storeLoad.registerData.GetRegID();
+	IMLRegID realRegisterMem = imlInstruction->op_storeLoad.registerMem.GetRegID();
+	IMLRegID realRegisterMem2 = PPC_REC_INVALID_REGISTER;
+	if (indexed)
+		realRegisterMem2 = imlInstruction->op_storeLoad.registerMem2.GetRegID();
+
+	if (indexed && realRegisterMem == realRegisterMem2)
+	{
+		return false;
+	}
+	if (indexed && realRegisterData == realRegisterMem2)
+	{
+		// for indexed memory access realRegisterData must not be the same register as the second memory register,
+		// this can easily be worked around by swapping realRegisterMem and realRegisterMem2
+		std::swap(realRegisterMem, realRegisterMem2);
+	}
+
+	bool signExtend = imlInstruction->op_storeLoad.flags2.signExtend;
+	bool swapEndian = imlInstruction->op_storeLoad.flags2.swapEndian;
+	if (imlInstruction->op_storeLoad.copyWidth == 32)
+	{
+		uint32 valueRegister;
+		if ((swapEndian == false || g_CPUFeatures.x86.movbe) && realRegisterMem != realRegisterData)
+		{
+			valueRegister = realRegisterData;
+		}
+		else
+		{
+			x64Gen_mov_reg64_reg64(x64GenContext, REG_RESV_TEMP, realRegisterData);
+			valueRegister = REG_RESV_TEMP;
+		}
+		if (!g_CPUFeatures.x86.movbe && swapEndian)
+			x64Gen_bswap_reg64Lower32bit(x64GenContext, valueRegister);
+		if (indexed)
+			x64Gen_add_reg64Low32_reg64Low32(x64GenContext, realRegisterMem, realRegisterMem2);
+		if (g_CPUFeatures.x86.movbe && swapEndian)
+			x64Gen_movBETruncate_mem32Reg64PlusReg64_reg64(x64GenContext, REG_RESV_MEMBASE, realRegisterMem, imlInstruction->op_storeLoad.immS32, valueRegister);
+		else
+			x64Gen_movTruncate_mem32Reg64PlusReg64_reg64(x64GenContext, REG_RESV_MEMBASE, realRegisterMem, imlInstruction->op_storeLoad.immS32, valueRegister);
+		if (indexed)
+			x64Gen_sub_reg64Low32_reg64Low32(x64GenContext, realRegisterMem, realRegisterMem2);
+	}
+	else if (imlInstruction->op_storeLoad.copyWidth == 16)
+	{
+		x64Gen_mov_reg64_reg64(x64GenContext, REG_RESV_TEMP, realRegisterData);
+		if (swapEndian)
+			x64Gen_rol_reg64Low16_imm8(x64GenContext, REG_RESV_TEMP, 8);
+		if (indexed)
+			x64Gen_add_reg64Low32_reg64Low32(x64GenContext, realRegisterMem, realRegisterMem2);
+		x64Gen_movTruncate_mem16Reg64PlusReg64_reg64(x64GenContext, REG_RESV_MEMBASE, realRegisterMem, imlInstruction->op_storeLoad.immS32, REG_RESV_TEMP);
+		if (indexed)
+			x64Gen_sub_reg64Low32_reg64Low32(x64GenContext, realRegisterMem, realRegisterMem2);
+		// todo: Optimize this, e.g. by using MOVBE
+	}
+	else if (imlInstruction->op_storeLoad.copyWidth == 8)
+	{
+		if (indexed && realRegisterMem == realRegisterData)
+		{
+			x64Gen_mov_reg64_reg64(x64GenContext, REG_RESV_TEMP, realRegisterData);
+			realRegisterData = REG_RESV_TEMP;
+		}
+		if (indexed)
+			x64Gen_add_reg64Low32_reg64Low32(x64GenContext, realRegisterMem, realRegisterMem2);
+		x64Gen_movTruncate_mem8Reg64PlusReg64_reg64(x64GenContext, REG_RESV_MEMBASE, realRegisterMem, imlInstruction->op_storeLoad.immS32, realRegisterData);
+		if (indexed)
+			x64Gen_sub_reg64Low32_reg64Low32(x64GenContext, realRegisterMem, realRegisterMem2);
+	}
+	else
+		return false;
+	return true;
+}
+
+void PPCRecompilerX64Gen_imlInstruction_atomic_cmp_store(PPCRecFunction_t* PPCRecFunction, ppcImlGenContext_t* ppcImlGenContext, x64GenContext_t* x64GenContext, IMLInstruction* imlInstruction)
+{
+	auto regBoolOut = _reg32_from_reg8(_reg8(imlInstruction->op_atomic_compare_store.regBoolOut));
+	auto regEA = _reg32(imlInstruction->op_atomic_compare_store.regEA);
+	auto regVal = _reg32(imlInstruction->op_atomic_compare_store.regWriteValue);
+	auto regCmp = _reg32(imlInstruction->op_atomic_compare_store.regCompareValue);
+
+	cemu_assert_debug(regBoolOut == X86_REG_EAX);
+	cemu_assert_debug(regEA != X86_REG_EAX);
+	cemu_assert_debug(regVal != X86_REG_EAX);
+	cemu_assert_debug(regCmp != X86_REG_EAX);
+
+	x64GenContext->emitter->MOV_dd(X86_REG_EAX, regCmp);
+	x64GenContext->emitter->LockPrefix();
+	x64GenContext->emitter->CMPXCHG_dd_l(REG_RESV_MEMBASE, 0, _reg64_from_reg32(regEA), 1, regVal);
+	x64GenContext->emitter->SETcc_b(X86Cond::X86_CONDITION_Z, regBoolOut);
+	x64GenContext->emitter->AND_di32(regBoolOut, 1); // SETcc doesn't clear the upper bits so we do it manually here
+}
+
+void PPCRecompilerX64Gen_imlInstruction_call_imm(PPCRecFunction_t* PPCRecFunction, ppcImlGenContext_t* ppcImlGenContext, x64GenContext_t* x64GenContext, IMLInstruction* imlInstruction)
+{
+	// the register allocator takes care of spilling volatile registers and moving parameters to the right registers, so we don't need to do any special handling here
+	x64GenContext->emitter->SUB_qi8(X86_REG_RSP, 0x20); // reserve enough space for any parameters while keeping stack alignment of 16 intact
+	x64GenContext->emitter->MOV_qi64(X86_REG_RAX, imlInstruction->op_call_imm.callAddress);
+	x64GenContext->emitter->CALL_q(X86_REG_RAX);
+	x64GenContext->emitter->ADD_qi8(X86_REG_RSP, 0x20);
+	// a note about the stack pointer:
+	// currently the code generated by generateEnterRecompilerCode makes sure the stack is 16 byte aligned, so we don't need to fix it up here
+}
+
+bool PPCRecompilerX64Gen_imlInstruction_r_r(PPCRecFunction_t* PPCRecFunction, ppcImlGenContext_t* ppcImlGenContext, x64GenContext_t* x64GenContext, IMLInstruction* imlInstruction)
+{
+	auto regR = _reg32(imlInstruction->op_r_r.regR);
+	auto regA = _reg32(imlInstruction->op_r_r.regA);
+
+	if (imlInstruction->operation == PPCREC_IML_OP_ASSIGN)
+	{
+		// registerResult = registerA
+		if (regR != regA)
+			x64Gen_mov_reg64Low32_reg64Low32(x64GenContext, regR, regA);
+	}
+	else if (imlInstruction->operation == PPCREC_IML_OP_ENDIAN_SWAP)
+	{
+		if (regA != regR)
+			x64Gen_mov_reg64Low32_reg64Low32(x64GenContext, regR, regA); // if movbe is available we can move and swap in a single instruction?
+		x64Gen_bswap_reg64Lower32bit(x64GenContext, regR);
+	}
+	else if( imlInstruction->operation == PPCREC_IML_OP_ASSIGN_S8_TO_S32 )
+	{
+		x64Gen_movSignExtend_reg64Low32_reg64Low8(x64GenContext, regR, regA);
+	}
+	else if (imlInstruction->operation == PPCREC_IML_OP_ASSIGN_S16_TO_S32)
+	{
+		x64Gen_movSignExtend_reg64Low32_reg64Low16(x64GenContext, regR, reg32ToReg16(regA));
+	}
+	else if( imlInstruction->operation == PPCREC_IML_OP_NOT )
+	{
+		// copy register content if different registers
+		if( regR != regA )
+			x64Gen_mov_reg64_reg64(x64GenContext, regR, regA);
+		x64Gen_not_reg64Low32(x64GenContext, regR);
+	}
+	else if (imlInstruction->operation == PPCREC_IML_OP_NEG)
+	{
+		// copy register content if different registers
+		if (regR != regA)
+			x64Gen_mov_reg64_reg64(x64GenContext, regR, regA);
+		x64Gen_neg_reg64Low32(x64GenContext, regR);
+	}
+	else if( imlInstruction->operation == PPCREC_IML_OP_CNTLZW )
+	{
+		// count leading zeros
+		// LZCNT instruction (part of SSE4, CPUID.80000001H:ECX.ABM[Bit 5])
+		if(g_CPUFeatures.x86.lzcnt)
+		{
+			x64Gen_lzcnt_reg64Low32_reg64Low32(x64GenContext, regR, regA);
+		}
+		else
+		{
+			x64Gen_test_reg64Low32_reg64Low32(x64GenContext, regA, regA);
+			sint32 jumpInstructionOffset1 = x64GenContext->emitter->GetWriteIndex();
+			x64Gen_jmpc_near(x64GenContext, X86_CONDITION_EQUAL, 0);
+			x64Gen_bsr_reg64Low32_reg64Low32(x64GenContext, regR, regA);
+			x64Gen_neg_reg64Low32(x64GenContext, regR);
+			x64Gen_add_reg64Low32_imm32(x64GenContext, regR, 32-1);
+			sint32 jumpInstructionOffset2 = x64GenContext->emitter->GetWriteIndex();
+			x64Gen_jmpc_near(x64GenContext, X86_CONDITION_NONE, 0);
+			PPCRecompilerX64Gen_redirectRelativeJump(x64GenContext, jumpInstructionOffset1, x64GenContext->emitter->GetWriteIndex());
+			x64Gen_mov_reg64Low32_imm32(x64GenContext, regR, 32);
+			PPCRecompilerX64Gen_redirectRelativeJump(x64GenContext, jumpInstructionOffset2, x64GenContext->emitter->GetWriteIndex());
+		}
+	}
+	else if( imlInstruction->operation == PPCREC_IML_OP_X86_CMP)
+	{
+		x64GenContext->emitter->CMP_dd(regR, regA);
+	}
+	else
+	{
+		cemuLog_logDebug(LogType::Force, "PPCRecompilerX64Gen_imlInstruction_r_r(): Unsupported operation 0x%x\n", imlInstruction->operation);
+		return false;
+	}
+	return true;
+}
+
+bool PPCRecompilerX64Gen_imlInstruction_r_s32(PPCRecFunction_t* PPCRecFunction, ppcImlGenContext_t* ppcImlGenContext, x64GenContext_t* x64GenContext, IMLInstruction* imlInstruction)
+{
+	auto regR = _reg32(imlInstruction->op_r_immS32.regR);
+
+	if( imlInstruction->operation == PPCREC_IML_OP_ASSIGN )
+	{
+		x64Gen_mov_reg64Low32_imm32(x64GenContext, regR, (uint32)imlInstruction->op_r_immS32.immS32);
+	}
+	else if( imlInstruction->operation == PPCREC_IML_OP_LEFT_ROTATE )
+	{
+		cemu_assert_debug((imlInstruction->op_r_immS32.immS32 & 0x80) == 0);
+		x64Gen_rol_reg64Low32_imm8(x64GenContext, regR, (uint8)imlInstruction->op_r_immS32.immS32);
+	}
+	else if( imlInstruction->operation == PPCREC_IML_OP_X86_CMP)
+	{
+		sint32 imm = imlInstruction->op_r_immS32.immS32;
+		x64GenContext->emitter->CMP_di32(regR, imm);
+	}
+	else
+	{
+		cemuLog_logDebug(LogType::Force, "PPCRecompilerX64Gen_imlInstruction_r_s32(): Unsupported operation 0x%x\n", imlInstruction->operation);
+		return false;
+	}
+	return true;
+}
+
+bool PPCRecompilerX64Gen_imlInstruction_r_r_r(PPCRecFunction_t* PPCRecFunction, ppcImlGenContext_t* ppcImlGenContext, x64GenContext_t* x64GenContext, IMLInstruction* imlInstruction)
+{
+	auto rRegResult = _reg32(imlInstruction->op_r_r_r.regR);
+	auto rRegOperand1 = _reg32(imlInstruction->op_r_r_r.regA);
+	auto rRegOperand2 = _reg32(imlInstruction->op_r_r_r.regB);
+
+	if (imlInstruction->operation == PPCREC_IML_OP_ADD)
+	{
+		// registerResult = registerOperand1 + registerOperand2
+		if( (rRegResult == rRegOperand1) || (rRegResult == rRegOperand2) )
+		{
+			// be careful not to overwrite the operand before we use it
+			if( rRegResult == rRegOperand1 )
+				x64Gen_add_reg64Low32_reg64Low32(x64GenContext, rRegResult, rRegOperand2);
+			else
+				x64Gen_add_reg64Low32_reg64Low32(x64GenContext, rRegResult, rRegOperand1);
+		}
+		else
+		{
+			// copy operand1 to destination register before doing addition
+			x64Gen_mov_reg64_reg64(x64GenContext, rRegResult, rRegOperand1);
+			x64Gen_add_reg64Low32_reg64Low32(x64GenContext, rRegResult, rRegOperand2);
+		}
+	}
+	else if( imlInstruction->operation == PPCREC_IML_OP_SUB )
+	{
+		if( rRegOperand1 == rRegOperand2 )
+		{
+			// result = operand1 - operand1 -> 0
+			x64Gen_sub_reg64Low32_reg64Low32(x64GenContext, rRegResult, rRegResult);
+		}
+		else if( rRegResult == rRegOperand1 )
+		{
+			// result = result - operand2
+			x64Gen_sub_reg64Low32_reg64Low32(x64GenContext, rRegResult, rRegOperand2);
+		}
+		else if ( rRegResult == rRegOperand2 )
+		{
+			// result = operand1 - result
+			x64Gen_neg_reg64Low32(x64GenContext, rRegResult);
+			x64Gen_add_reg64Low32_reg64Low32(x64GenContext, rRegResult, rRegOperand1);
+		}
+		else
+		{
+			x64Gen_mov_reg64_reg64(x64GenContext, rRegResult, rRegOperand1);
+			x64Gen_sub_reg64Low32_reg64Low32(x64GenContext, rRegResult, rRegOperand2);
+		}
+	}
+	else if (imlInstruction->operation == PPCREC_IML_OP_OR || imlInstruction->operation == PPCREC_IML_OP_AND || imlInstruction->operation == PPCREC_IML_OP_XOR)
+	{
+		if (rRegResult == rRegOperand2)
+			std::swap(rRegOperand1, rRegOperand2);
+
+		if (rRegResult != rRegOperand1)
+			x64Gen_mov_reg64_reg64(x64GenContext, rRegResult, rRegOperand1);
+
+		if (imlInstruction->operation == PPCREC_IML_OP_OR)
+			x64Gen_or_reg64Low32_reg64Low32(x64GenContext, rRegResult, rRegOperand2);
+		else if (imlInstruction->operation == PPCREC_IML_OP_AND)
+			x64Gen_and_reg64Low32_reg64Low32(x64GenContext, rRegResult, rRegOperand2);
+		else
+			x64Gen_xor_reg64Low32_reg64Low32(x64GenContext, rRegResult, rRegOperand2);
+	}
+	else if( imlInstruction->operation == PPCREC_IML_OP_MULTIPLY_SIGNED )
+	{
+		// registerResult = registerOperand1 * registerOperand2
+		if( (rRegResult == rRegOperand1) || (rRegResult == rRegOperand2) )
+		{
+			// be careful not to overwrite the operand before we use it
+			if( rRegResult == rRegOperand1 )
+				x64Gen_imul_reg64Low32_reg64Low32(x64GenContext, rRegResult, rRegOperand2);
+			else
+				x64Gen_imul_reg64Low32_reg64Low32(x64GenContext, rRegResult, rRegOperand1);
+		}
+		else
+		{
+			// copy operand1 to destination register before doing multiplication
+			x64Gen_mov_reg64_reg64(x64GenContext, rRegResult, rRegOperand1);
+			// add operand2
+			x64Gen_imul_reg64Low32_reg64Low32(x64GenContext, rRegResult, rRegOperand2);
+		}
+	}
+	else if( imlInstruction->operation == PPCREC_IML_OP_SLW || imlInstruction->operation == PPCREC_IML_OP_SRW )
+	{
+		// registerResult = registerOperand1(rA) >> registerOperand2(rB) (up to 63 bits)
+
+		if (g_CPUFeatures.x86.bmi2 && imlInstruction->operation == PPCREC_IML_OP_SRW)
+		{
+			// use BMI2 SHRX if available
+			x64Gen_shrx_reg64_reg64_reg64(x64GenContext, rRegResult, rRegOperand1, rRegOperand2);
+		}
+		else if (g_CPUFeatures.x86.bmi2 && imlInstruction->operation == PPCREC_IML_OP_SLW)
+		{
+			// use BMI2 SHLX if available
+			x64Gen_shlx_reg64_reg64_reg64(x64GenContext, rRegResult, rRegOperand1, rRegOperand2);
+			x64Gen_and_reg64Low32_reg64Low32(x64GenContext, rRegResult, rRegResult); // trim result to 32bit
+		}
+		else
+		{
+			// lazy and slow way to do shift by register without relying on ECX/CL or BMI2
+			x64Gen_mov_reg64_reg64(x64GenContext, REG_RESV_TEMP, rRegOperand1);
+			for (sint32 b = 0; b < 6; b++)
+			{
+				x64Gen_test_reg64Low32_imm32(x64GenContext, rRegOperand2, (1 << b));
+				sint32 jumpInstructionOffset = x64GenContext->emitter->GetWriteIndex();
+				x64Gen_jmpc_near(x64GenContext, X86_CONDITION_EQUAL, 0); // jump if bit not set
+				if (b == 5)
+				{
+					x64Gen_xor_reg64Low32_reg64Low32(x64GenContext, REG_RESV_TEMP, REG_RESV_TEMP);
+				}
+				else
+				{
+					if (imlInstruction->operation == PPCREC_IML_OP_SLW)
+						x64Gen_shl_reg64Low32_imm8(x64GenContext, REG_RESV_TEMP, (1 << b));
+					else
+						x64Gen_shr_reg64Low32_imm8(x64GenContext, REG_RESV_TEMP, (1 << b));
+				}
+				PPCRecompilerX64Gen_redirectRelativeJump(x64GenContext, jumpInstructionOffset, x64GenContext->emitter->GetWriteIndex());
+			}
+			x64Gen_mov_reg64_reg64(x64GenContext, rRegResult, REG_RESV_TEMP);
+		}
+	}
+	else if( imlInstruction->operation == PPCREC_IML_OP_LEFT_ROTATE )
+	{
+		// todo: Use BMI2 rotate if available
+		// check if CL/ECX/RCX is available
+		if( rRegResult != X86_REG_RCX && rRegOperand1 != X86_REG_RCX && rRegOperand2 != X86_REG_RCX )
+		{
+			// swap operand 2 with RCX
+			x64Gen_xchg_reg64_reg64(x64GenContext, X86_REG_RCX, rRegOperand2);
+			// move operand 1 to temp register
+			x64Gen_mov_reg64_reg64(x64GenContext, REG_RESV_TEMP, rRegOperand1);
+			// rotate
+			x64Gen_rol_reg64Low32_cl(x64GenContext, REG_RESV_TEMP);
+			// undo swap operand 2 with RCX
+			x64Gen_xchg_reg64_reg64(x64GenContext, X86_REG_RCX, rRegOperand2);
+			// copy to result register
+			x64Gen_mov_reg64_reg64(x64GenContext, rRegResult, REG_RESV_TEMP);
+		}
+		else
+		{
+			x64Gen_mov_reg64_reg64(x64GenContext, REG_RESV_TEMP, rRegOperand1);
+			// lazy and slow way to do shift by register without relying on ECX/CL
+			for(sint32 b=0; b<5; b++)
+			{
+				x64Gen_test_reg64Low32_imm32(x64GenContext, rRegOperand2, (1<<b));
+				sint32 jumpInstructionOffset = x64GenContext->emitter->GetWriteIndex();
+				x64Gen_jmpc_near(x64GenContext, X86_CONDITION_EQUAL, 0); // jump if bit not set
+				x64Gen_rol_reg64Low32_imm8(x64GenContext, REG_RESV_TEMP, (1<<b));
+				PPCRecompilerX64Gen_redirectRelativeJump(x64GenContext, jumpInstructionOffset, x64GenContext->emitter->GetWriteIndex());
+			}
+			x64Gen_mov_reg64_reg64(x64GenContext, rRegResult, REG_RESV_TEMP);
+		}
+	}
+	else if (imlInstruction->operation == PPCREC_IML_OP_RIGHT_SHIFT_S ||
+		imlInstruction->operation == PPCREC_IML_OP_RIGHT_SHIFT_U ||
+		imlInstruction->operation == PPCREC_IML_OP_LEFT_SHIFT)
+	{
+		if(g_CPUFeatures.x86.bmi2)
+		{
+			if (imlInstruction->operation == PPCREC_IML_OP_RIGHT_SHIFT_S)
+				x64Gen_sarx_reg32_reg32_reg32(x64GenContext, rRegResult, rRegOperand1, rRegOperand2);
+			else if (imlInstruction->operation == PPCREC_IML_OP_RIGHT_SHIFT_U)
+				x64Gen_shrx_reg32_reg32_reg32(x64GenContext, rRegResult, rRegOperand1, rRegOperand2);
+			else if (imlInstruction->operation == PPCREC_IML_OP_LEFT_SHIFT)
+				x64Gen_shlx_reg32_reg32_reg32(x64GenContext, rRegResult, rRegOperand1, rRegOperand2);
+		}
+		else
+		{
+			cemu_assert_debug(rRegOperand2 == X86_REG_ECX);
+			bool useTempReg = rRegResult == X86_REG_ECX && rRegOperand1 != X86_REG_ECX;
+			auto origRegResult = rRegResult;
+			if(useTempReg)
+			{
+				x64GenContext->emitter->MOV_dd(REG_RESV_TEMP, rRegOperand1);
+				rRegResult = REG_RESV_TEMP;
+			}
+			if(rRegOperand1 != rRegResult)
+				x64Gen_mov_reg64_reg64(x64GenContext, rRegResult, rRegOperand1);
+			if (imlInstruction->operation == PPCREC_IML_OP_RIGHT_SHIFT_S)
+				x64GenContext->emitter->SAR_d_CL(rRegResult);
+			else if (imlInstruction->operation == PPCREC_IML_OP_RIGHT_SHIFT_U)
+				x64GenContext->emitter->SHR_d_CL(rRegResult);
+			else if (imlInstruction->operation == PPCREC_IML_OP_LEFT_SHIFT)
+				x64GenContext->emitter->SHL_d_CL(rRegResult);
+			if(useTempReg)
+				x64GenContext->emitter->MOV_dd(origRegResult, REG_RESV_TEMP);
+		}
+	}
+	else if( imlInstruction->operation == PPCREC_IML_OP_DIVIDE_SIGNED || imlInstruction->operation == PPCREC_IML_OP_DIVIDE_UNSIGNED )
+	{
+		x64Emit_mov_mem32_reg32(x64GenContext, REG_RESV_HCPU, (uint32)offsetof(PPCInterpreter_t, temporaryGPR[0]), X86_REG_EAX);
+		x64Emit_mov_mem32_reg32(x64GenContext, REG_RESV_HCPU, (uint32)offsetof(PPCInterpreter_t, temporaryGPR[1]), X86_REG_EDX);
+		// mov operand 2 to temp register
+		x64Gen_mov_reg64_reg64(x64GenContext, REG_RESV_TEMP, rRegOperand2);
+		// mov operand1 to EAX
+		x64Gen_mov_reg64Low32_reg64Low32(x64GenContext, X86_REG_EAX, rRegOperand1);
+		// sign or zero extend EAX to EDX:EAX based on division sign mode
+		if( imlInstruction->operation == PPCREC_IML_OP_DIVIDE_SIGNED )
+			x64Gen_cdq(x64GenContext);
+		else
+			x64Gen_xor_reg64Low32_reg64Low32(x64GenContext, X86_REG_EDX, X86_REG_EDX);
+		// make sure we avoid division by zero
+		x64Gen_test_reg64Low32_reg64Low32(x64GenContext, REG_RESV_TEMP, REG_RESV_TEMP);
+		x64Gen_jmpc_near(x64GenContext, X86_CONDITION_EQUAL, 3);
+		// divide
+		if( imlInstruction->operation == PPCREC_IML_OP_DIVIDE_SIGNED )
+			x64Gen_idiv_reg64Low32(x64GenContext, REG_RESV_TEMP);
+		else
+			x64Gen_div_reg64Low32(x64GenContext, REG_RESV_TEMP);
+		// result of division is now stored in EAX, move it to result register
+		if( rRegResult != X86_REG_EAX )
+			x64Gen_mov_reg64_reg64(x64GenContext, rRegResult, X86_REG_EAX);
+		// restore EAX / EDX
+		if( rRegResult != X86_REG_RAX )
+			x64Emit_mov_reg64_mem32(x64GenContext, X86_REG_EAX, REG_RESV_HCPU, (uint32)offsetof(PPCInterpreter_t, temporaryGPR[0]));
+		if( rRegResult != X86_REG_RDX )
+			x64Emit_mov_reg64_mem32(x64GenContext, X86_REG_EDX, REG_RESV_HCPU, (uint32)offsetof(PPCInterpreter_t, temporaryGPR[1]));
+	}
+	else if( imlInstruction->operation == PPCREC_IML_OP_MULTIPLY_HIGH_SIGNED || imlInstruction->operation == PPCREC_IML_OP_MULTIPLY_HIGH_UNSIGNED )
+	{
+		x64Emit_mov_mem32_reg32(x64GenContext, REG_RESV_HCPU, (uint32)offsetof(PPCInterpreter_t, temporaryGPR[0]), X86_REG_EAX);
+		x64Emit_mov_mem32_reg32(x64GenContext, REG_RESV_HCPU, (uint32)offsetof(PPCInterpreter_t, temporaryGPR[1]), X86_REG_EDX);
+		// mov operand 2 to temp register
+		x64Gen_mov_reg64_reg64(x64GenContext, REG_RESV_TEMP, rRegOperand2);
+		// mov operand1 to EAX
+		x64Gen_mov_reg64Low32_reg64Low32(x64GenContext, X86_REG_EAX, rRegOperand1);
+		if( imlInstruction->operation == PPCREC_IML_OP_MULTIPLY_HIGH_SIGNED )
+		{
+			// zero extend EAX to EDX:EAX
+			x64Gen_xor_reg64Low32_reg64Low32(x64GenContext, X86_REG_EDX, X86_REG_EDX);
+		}
+		else
+		{
+			// sign extend EAX to EDX:EAX
+			x64Gen_cdq(x64GenContext);
+		}
+		// multiply
+		if( imlInstruction->operation == PPCREC_IML_OP_MULTIPLY_HIGH_SIGNED )
+			x64Gen_imul_reg64Low32(x64GenContext, REG_RESV_TEMP);
+		else
+			x64Gen_mul_reg64Low32(x64GenContext, REG_RESV_TEMP);
+		// result of multiplication is now stored in EDX:EAX, move it to result register
+		if( rRegResult != X86_REG_EDX )
+			x64Gen_mov_reg64_reg64(x64GenContext, rRegResult, X86_REG_EDX);
+		// restore EAX / EDX
+		if( rRegResult != X86_REG_RAX )
+			x64Emit_mov_reg64_mem32(x64GenContext, X86_REG_EAX, REG_RESV_HCPU, (uint32)offsetof(PPCInterpreter_t, temporaryGPR[0]));
+		if( rRegResult != X86_REG_RDX )
+			x64Emit_mov_reg64_mem32(x64GenContext, X86_REG_EDX, REG_RESV_HCPU, (uint32)offsetof(PPCInterpreter_t, temporaryGPR[1]));
+	}
+	else
+	{
+		cemuLog_logDebug(LogType::Force, "PPCRecompilerX64Gen_imlInstruction_r_r_r(): Unsupported operation 0x%x\n", imlInstruction->operation);
+		return false;
+	}
+	return true;
+}
+
+bool PPCRecompilerX64Gen_imlInstruction_r_r_r_carry(PPCRecFunction_t* PPCRecFunction, ppcImlGenContext_t* ppcImlGenContext, x64GenContext_t* x64GenContext, IMLInstruction* imlInstruction)
+{
+	auto regR = _reg32(imlInstruction->op_r_r_r_carry.regR);
+	auto regA = _reg32(imlInstruction->op_r_r_r_carry.regA);
+	auto regB = _reg32(imlInstruction->op_r_r_r_carry.regB);
+	auto regCarry = _reg32(imlInstruction->op_r_r_r_carry.regCarry);
+	bool carryRegIsShared = regCarry == regA || regCarry == regB;
+	cemu_assert_debug(regCarry != regR); // two outputs sharing the same register is undefined behavior
+
+	switch (imlInstruction->operation)
+	{
+	case PPCREC_IML_OP_ADD:
+		if (regB == regR)
+			std::swap(regB, regA);
+		if (regR != regA)
+			x64GenContext->emitter->MOV_dd(regR, regA);
+		if(!carryRegIsShared)
+			x64GenContext->emitter->XOR_dd(regCarry, regCarry);
+		x64GenContext->emitter->ADD_dd(regR, regB);
+		x64GenContext->emitter->SETcc_b(X86_CONDITION_B, _reg8_from_reg32(regCarry)); // below condition checks carry flag
+		if(carryRegIsShared)
+			x64GenContext->emitter->AND_di8(regCarry, 1); // clear upper bits
+		break;
+	case PPCREC_IML_OP_ADD_WITH_CARRY:
+		// assumes that carry is already correctly initialized as 0 or 1
+		if (regB == regR)
+			std::swap(regB, regA);
+		if (regR != regA)
+			x64GenContext->emitter->MOV_dd(regR, regA);
+		x64GenContext->emitter->BT_du8(regCarry, 0); // copy carry register to x86 carry flag
+		x64GenContext->emitter->ADC_dd(regR, regB);
+		x64GenContext->emitter->SETcc_b(X86_CONDITION_B, _reg8_from_reg32(regCarry));
+		break;
+	default:
+		cemu_assert_unimplemented();
+		return false;
+	}
+	return true;
+}
+
+bool PPCRecompilerX64Gen_IsSameCompare(IMLInstruction* imlInstructionA, IMLInstruction* imlInstructionB)
+{
+	if(imlInstructionA->type != imlInstructionB->type)
+		return false;
+	if(imlInstructionA->type == PPCREC_IML_TYPE_COMPARE)
+		return imlInstructionA->op_compare.regA == imlInstructionB->op_compare.regA && imlInstructionA->op_compare.regB == imlInstructionB->op_compare.regB;
+	else if(imlInstructionA->type == PPCREC_IML_TYPE_COMPARE_S32)
+		return imlInstructionA->op_compare_s32.regA == imlInstructionB->op_compare_s32.regA && imlInstructionA->op_compare_s32.immS32 == imlInstructionB->op_compare_s32.immS32;
+	return false;
+}
+
+bool PPCRecompilerX64Gen_imlInstruction_compare_x(PPCRecFunction_t* PPCRecFunction, ppcImlGenContext_t* ppcImlGenContext, x64GenContext_t* x64GenContext, IMLInstruction* imlInstruction, sint32& extraInstructionsProcessed)
+{
+	extraInstructionsProcessed = 0;
+	boost::container::static_vector<IMLInstruction*, 4> compareInstructions;
+	compareInstructions.push_back(imlInstruction);
+	for(sint32 i=1; i<4; i++)
+	{
+		IMLInstruction* nextIns = x64GenContext->GetNextInstruction(i);
+		if(!nextIns || !PPCRecompilerX64Gen_IsSameCompare(imlInstruction, nextIns))
+			break;
+		compareInstructions.push_back(nextIns);
+	}
+	auto OperandOverlapsWithR = [&](IMLInstruction* ins) -> bool
+	{
+		cemu_assert_debug(ins->type == PPCREC_IML_TYPE_COMPARE || ins->type == PPCREC_IML_TYPE_COMPARE_S32);
+		if(ins->type == PPCREC_IML_TYPE_COMPARE)
+			return _reg32_from_reg8(_reg8(ins->op_compare.regR)) == _reg32(ins->op_compare.regA) || _reg32_from_reg8(_reg8(ins->op_compare.regR)) == _reg32(ins->op_compare.regB);
+		else /* PPCREC_IML_TYPE_COMPARE_S32 */
+			return _reg32_from_reg8(_reg8(ins->op_compare_s32.regR)) == _reg32(ins->op_compare_s32.regA);
+	};
+	auto GetRegR = [](IMLInstruction* insn)
+	{
+		return insn->type == PPCREC_IML_TYPE_COMPARE ? _reg32_from_reg8(_reg8(insn->op_compare.regR)) : _reg32_from_reg8(_reg8(insn->op_compare_s32.regR));
+	};
+	// prefer XOR method for zeroing out registers if possible
+	for(auto& it : compareInstructions)
+	{
+		if(OperandOverlapsWithR(it))
+			continue;
+		auto regR = GetRegR(it);
+		x64GenContext->emitter->XOR_dd(regR, regR); // zero bytes unaffected by SETcc
+	}
+	// emit the compare instruction
+	if(imlInstruction->type == PPCREC_IML_TYPE_COMPARE)
+	{
+		auto regA = _reg32(imlInstruction->op_compare.regA);
+		auto regB = _reg32(imlInstruction->op_compare.regB);
+		x64GenContext->emitter->CMP_dd(regA, regB);
+	}
+	else if(imlInstruction->type == PPCREC_IML_TYPE_COMPARE_S32)
+	{
+		auto regA = _reg32(imlInstruction->op_compare_s32.regA);
+		sint32 imm = imlInstruction->op_compare_s32.immS32;
+		x64GenContext->emitter->CMP_di32(regA, imm);
+	}
+	// emit the SETcc instructions
+	for(auto& it : compareInstructions)
+	{
+		auto regR = _reg8(it->op_compare.regR);
+		X86Cond cond = _x86Cond(it->op_compare.cond);
+		if(OperandOverlapsWithR(it))
+			x64GenContext->emitter->MOV_di32(_reg32_from_reg8(regR), 0);
+		x64GenContext->emitter->SETcc_b(cond, regR);
+	}
+	extraInstructionsProcessed = (sint32)compareInstructions.size() - 1;
+	return true;
+}
+
+bool PPCRecompilerX64Gen_imlInstruction_cjump2(PPCRecFunction_t* PPCRecFunction, ppcImlGenContext_t* ppcImlGenContext, x64GenContext_t* x64GenContext, IMLInstruction* imlInstruction, IMLSegment* imlSegment)
+{
+	auto regBool = _reg8(imlInstruction->op_conditional_jump.registerBool);
+	bool mustBeTrue = imlInstruction->op_conditional_jump.mustBeTrue;
+	x64GenContext->emitter->TEST_bb(regBool, regBool);
+	PPCRecompilerX64Gen_rememberRelocatableOffset(x64GenContext, imlSegment->nextSegmentBranchTaken);
+	x64GenContext->emitter->Jcc_j32(mustBeTrue ? X86_CONDITION_NZ : X86_CONDITION_Z, 0);
+	return true;
+}
+
+void PPCRecompilerX64Gen_imlInstruction_x86_eflags_jcc(PPCRecFunction_t* PPCRecFunction, ppcImlGenContext_t* ppcImlGenContext, x64GenContext_t* x64GenContext, IMLInstruction* imlInstruction, IMLSegment* imlSegment)
+{
+	X86Cond cond = _x86Cond(imlInstruction->op_x86_eflags_jcc.cond, imlInstruction->op_x86_eflags_jcc.invertedCondition);
+	PPCRecompilerX64Gen_rememberRelocatableOffset(x64GenContext, imlSegment->nextSegmentBranchTaken);
+	x64GenContext->emitter->Jcc_j32(cond, 0);
+}
+
+bool PPCRecompilerX64Gen_imlInstruction_jump2(PPCRecFunction_t* PPCRecFunction, ppcImlGenContext_t* ppcImlGenContext, x64GenContext_t* x64GenContext, IMLInstruction* imlInstruction, IMLSegment* imlSegment)
+{
+	PPCRecompilerX64Gen_rememberRelocatableOffset(x64GenContext, imlSegment->nextSegmentBranchTaken);
+	x64GenContext->emitter->JMP_j32(0);
+	return true;
+}
+
+bool PPCRecompilerX64Gen_imlInstruction_r_r_s32(PPCRecFunction_t* PPCRecFunction, ppcImlGenContext_t* ppcImlGenContext, x64GenContext_t* x64GenContext, IMLInstruction* imlInstruction)
+{
+	auto regR = _reg32(imlInstruction->op_r_r_s32.regR);
+	auto regA = _reg32(imlInstruction->op_r_r_s32.regA);
+	uint32 immS32 = imlInstruction->op_r_r_s32.immS32;
+
+	if( imlInstruction->operation == PPCREC_IML_OP_ADD )
+	{
+		uint32 immU32 = (uint32)imlInstruction->op_r_r_s32.immS32;
+		if(regR != regA)
+			x64Gen_mov_reg64Low32_reg64Low32(x64GenContext, regR, regA);
+		x64Gen_add_reg64Low32_imm32(x64GenContext, regR, (uint32)immU32);
+	}
+	else if (imlInstruction->operation == PPCREC_IML_OP_SUB)
+	{
+		if (regR != regA)
+			x64Gen_mov_reg64Low32_reg64Low32(x64GenContext, regR, regA);
+		x64Gen_sub_reg64Low32_imm32(x64GenContext, regR, immS32);
+	}
+	else if (imlInstruction->operation == PPCREC_IML_OP_AND || 
+		imlInstruction->operation == PPCREC_IML_OP_OR ||
+		imlInstruction->operation == PPCREC_IML_OP_XOR)
+	{
+		if (regR != regA)
+			x64Gen_mov_reg64Low32_reg64Low32(x64GenContext, regR, regA);
+		if (imlInstruction->operation == PPCREC_IML_OP_AND)
+			x64Gen_and_reg64Low32_imm32(x64GenContext, regR, immS32);
+		else if (imlInstruction->operation == PPCREC_IML_OP_OR)
+			x64Gen_or_reg64Low32_imm32(x64GenContext, regR, immS32);
+		else // XOR
+			x64Gen_xor_reg64Low32_imm32(x64GenContext, regR, immS32);
+	}
+	else if( imlInstruction->operation == PPCREC_IML_OP_MULTIPLY_SIGNED )
+	{
+		// registerResult = registerOperand * immS32
+		sint32 immS32 = (uint32)imlInstruction->op_r_r_s32.immS32;
+		x64Gen_mov_reg64_imm64(x64GenContext, REG_RESV_TEMP, (sint64)immS32); // todo: Optimize
+		if( regR != regA )
+			x64Gen_mov_reg64Low32_reg64Low32(x64GenContext, regR, regA);
+		x64Gen_imul_reg64Low32_reg64Low32(x64GenContext, regR, REG_RESV_TEMP);
+	}
+	else if (imlInstruction->operation == PPCREC_IML_OP_LEFT_SHIFT ||
+		imlInstruction->operation == PPCREC_IML_OP_RIGHT_SHIFT_U ||
+		imlInstruction->operation == PPCREC_IML_OP_RIGHT_SHIFT_S)
+	{
+		if( regA != regR )
+			x64Gen_mov_reg64Low32_reg64Low32(x64GenContext, regR, regA);
+		if (imlInstruction->operation == PPCREC_IML_OP_LEFT_SHIFT)
+			x64Gen_shl_reg64Low32_imm8(x64GenContext, regR, imlInstruction->op_r_r_s32.immS32);
+		else if (imlInstruction->operation == PPCREC_IML_OP_RIGHT_SHIFT_U)
+			x64Gen_shr_reg64Low32_imm8(x64GenContext, regR, imlInstruction->op_r_r_s32.immS32);
+		else // RIGHT_SHIFT_S
+			x64Gen_sar_reg64Low32_imm8(x64GenContext, regR, imlInstruction->op_r_r_s32.immS32);
+	}
+	else
+	{
+		debug_printf("PPCRecompilerX64Gen_imlInstruction_r_r_s32(): Unsupported operation 0x%x\n", imlInstruction->operation);
+		return false;
+	}
+	return true;
+}
+
+bool PPCRecompilerX64Gen_imlInstruction_r_r_s32_carry(PPCRecFunction_t* PPCRecFunction, ppcImlGenContext_t* ppcImlGenContext, x64GenContext_t* x64GenContext, IMLInstruction* imlInstruction)
+{
+	auto regR = _reg32(imlInstruction->op_r_r_s32_carry.regR);
+	auto regA = _reg32(imlInstruction->op_r_r_s32_carry.regA);
+	sint32 immS32 = imlInstruction->op_r_r_s32_carry.immS32;
+	auto regCarry = _reg32(imlInstruction->op_r_r_s32_carry.regCarry);
+	cemu_assert_debug(regCarry != regR); // we dont allow two different outputs sharing the same register
+
+	bool delayCarryInit = regCarry == regA;
+
+	switch (imlInstruction->operation)
+	{
+	case PPCREC_IML_OP_ADD:
+		if(!delayCarryInit)
+			x64GenContext->emitter->XOR_dd(regCarry, regCarry);
+		if (regR != regA)
+			x64GenContext->emitter->MOV_dd(regR, regA);
+		x64GenContext->emitter->ADD_di32(regR, immS32);
+		if(delayCarryInit)
+			x64GenContext->emitter->MOV_di32(regCarry, 0);
+		x64GenContext->emitter->SETcc_b(X86_CONDITION_B, _reg8_from_reg32(regCarry));
+		break;
+	case PPCREC_IML_OP_ADD_WITH_CARRY:
+		// assumes that carry is already correctly initialized as 0 or 1
+		cemu_assert_debug(regCarry != regR);
+		if (regR != regA)
+			x64GenContext->emitter->MOV_dd(regR, regA);
+		x64GenContext->emitter->BT_du8(regCarry, 0); // copy carry register to x86 carry flag
+		x64GenContext->emitter->ADC_di32(regR, immS32);
+		x64GenContext->emitter->SETcc_b(X86_CONDITION_B, _reg8_from_reg32(regCarry));
+		break;
+	default:
+		cemu_assert_unimplemented();
+		return false;
+	}
+	return true;
+}
+
+bool PPCRecompilerX64Gen_imlInstruction_conditionalJumpCycleCheck(PPCRecFunction_t* PPCRecFunction, ppcImlGenContext_t* ppcImlGenContext, x64GenContext_t* x64GenContext, IMLInstruction* imlInstruction)
+{
+	// some tests (all performed on a i7-4790K)
+	// 1) DEC [mem] + JNS has significantly worse performance than BT + JNC (probably due to additional memory write and direct dependency)
+	// 2) CMP [mem], 0 + JG has about equal (or slightly worse) performance than BT + JNC
+
+	// BT
+	x64Gen_bt_mem8(x64GenContext, REG_RESV_HCPU, offsetof(PPCInterpreter_t, remainingCycles), 31); // check if negative
+	cemu_assert_debug(x64GenContext->currentSegment->GetBranchTaken());
+	PPCRecompilerX64Gen_rememberRelocatableOffset(x64GenContext, x64GenContext->currentSegment->GetBranchTaken());
+	x64Gen_jmpc_far(x64GenContext, X86_CONDITION_CARRY, 0);
+	return true;
+}
+
+void PPCRecompilerX64Gen_imlInstruction_r_name(PPCRecFunction_t* PPCRecFunction, ppcImlGenContext_t* ppcImlGenContext, x64GenContext_t* x64GenContext, IMLInstruction* imlInstruction)
+{
+	uint32 name = imlInstruction->op_r_name.name;
+	if (imlInstruction->op_r_name.regR.GetBaseFormat() == IMLRegFormat::I64)
+	{
+		auto regR = _reg64(imlInstruction->op_r_name.regR);
+		if (name >= PPCREC_NAME_R0 && name < PPCREC_NAME_R0 + 32)
+		{
+			x64Emit_mov_reg64_mem32(x64GenContext, regR, REG_RESV_HCPU, offsetof(PPCInterpreter_t, gpr) + sizeof(uint32) * (name - PPCREC_NAME_R0));
+		}
+		else if (name >= PPCREC_NAME_SPR0 && name < PPCREC_NAME_SPR0 + 999)
+		{
+			sint32 sprIndex = (name - PPCREC_NAME_SPR0);
+			if (sprIndex == SPR_LR)
+				x64Emit_mov_reg64_mem32(x64GenContext, regR, REG_RESV_HCPU, offsetof(PPCInterpreter_t, spr.LR));
+			else if (sprIndex == SPR_CTR)
+				x64Emit_mov_reg64_mem32(x64GenContext, regR, REG_RESV_HCPU, offsetof(PPCInterpreter_t, spr.CTR));
+			else if (sprIndex == SPR_XER)
+				x64Emit_mov_reg64_mem32(x64GenContext, regR, REG_RESV_HCPU, offsetof(PPCInterpreter_t, spr.XER));
+			else if (sprIndex >= SPR_UGQR0 && sprIndex <= SPR_UGQR7)
+			{
+				sint32 memOffset = offsetof(PPCInterpreter_t, spr.UGQR) + sizeof(PPCInterpreter_t::spr.UGQR[0]) * (sprIndex - SPR_UGQR0);
+				x64Emit_mov_reg64_mem32(x64GenContext, regR, REG_RESV_HCPU, memOffset);
+			}
+			else
+				assert_dbg();
+		}
+		else if (name >= PPCREC_NAME_TEMPORARY && name < PPCREC_NAME_TEMPORARY + 4)
+		{
+			x64Emit_mov_reg64_mem32(x64GenContext, regR, REG_RESV_HCPU, offsetof(PPCInterpreter_t, temporaryGPR_reg) + sizeof(uint32) * (name - PPCREC_NAME_TEMPORARY));
+		}
+		else if (name == PPCREC_NAME_XER_CA)
+		{
+			x64Emit_movZX_reg64_mem8(x64GenContext, regR, REG_RESV_HCPU, offsetof(PPCInterpreter_t, xer_ca));
+		}
+		else if (name == PPCREC_NAME_XER_SO)
+		{
+			x64Emit_movZX_reg64_mem8(x64GenContext, regR, REG_RESV_HCPU, offsetof(PPCInterpreter_t, xer_so));
+		}
+		else if (name >= PPCREC_NAME_CR && name <= PPCREC_NAME_CR_LAST)
+		{
+			x64Emit_movZX_reg64_mem8(x64GenContext, regR, REG_RESV_HCPU, offsetof(PPCInterpreter_t, cr) + (name - PPCREC_NAME_CR));
+		}
+		else if (name == PPCREC_NAME_CPU_MEMRES_EA)
+		{
+			x64Emit_mov_reg64_mem32(x64GenContext, regR, REG_RESV_HCPU, offsetof(PPCInterpreter_t, reservedMemAddr));
+		}
+		else if (name == PPCREC_NAME_CPU_MEMRES_VAL)
+		{
+			x64Emit_mov_reg64_mem32(x64GenContext, regR, REG_RESV_HCPU, offsetof(PPCInterpreter_t, reservedMemValue));
+		}
+		else
+			assert_dbg();
+	}
+	else if (imlInstruction->op_r_name.regR.GetBaseFormat() == IMLRegFormat::F64)
+	{
+		auto regR = _regF64(imlInstruction->op_r_name.regR);
+		if (name >= PPCREC_NAME_FPR_HALF && name < (PPCREC_NAME_FPR_HALF + 64))
+		{
+			sint32 regIndex = (name - PPCREC_NAME_FPR_HALF) / 2;
+			sint32 pairIndex = (name - PPCREC_NAME_FPR_HALF) % 2;
+			x64Gen_movsd_xmmReg_memReg64(x64GenContext, regR, REG_RESV_HCPU, offsetof(PPCInterpreter_t, fpr) + sizeof(FPR_t) * regIndex + pairIndex * sizeof(double));
+		}
+		else if (name >= PPCREC_NAME_TEMPORARY_FPR0 || name < (PPCREC_NAME_TEMPORARY_FPR0 + 8))
+		{
+			x64Gen_movupd_xmmReg_memReg128(x64GenContext, regR, REG_RESV_HCPU, offsetof(PPCInterpreter_t, temporaryFPR) + sizeof(FPR_t) * (name - PPCREC_NAME_TEMPORARY_FPR0));
+		}
+		else
+		{
+			cemu_assert_debug(false);
+		}
+	}
+	else
+		DEBUG_BREAK;
+
+}
+
+void PPCRecompilerX64Gen_imlInstruction_name_r(PPCRecFunction_t* PPCRecFunction, ppcImlGenContext_t* ppcImlGenContext, x64GenContext_t* x64GenContext, IMLInstruction* imlInstruction)
+{
+	uint32 name = imlInstruction->op_r_name.name;
+	
+	if (imlInstruction->op_r_name.regR.GetBaseFormat() == IMLRegFormat::I64)
+	{
+		auto regR = _reg64(imlInstruction->op_r_name.regR);
+		if (name >= PPCREC_NAME_R0 && name < PPCREC_NAME_R0 + 32)
+		{
+			x64Emit_mov_mem32_reg64(x64GenContext, REG_RESV_HCPU, offsetof(PPCInterpreter_t, gpr) + sizeof(uint32) * (name - PPCREC_NAME_R0), regR);
+		}
+		else if (name >= PPCREC_NAME_SPR0 && name < PPCREC_NAME_SPR0 + 999)
+		{
+			uint32 sprIndex = (name - PPCREC_NAME_SPR0);
+			if (sprIndex == SPR_LR)
+				x64Emit_mov_mem32_reg64(x64GenContext, REG_RESV_HCPU, offsetof(PPCInterpreter_t, spr.LR), regR);
+			else if (sprIndex == SPR_CTR)
+				x64Emit_mov_mem32_reg64(x64GenContext, REG_RESV_HCPU, offsetof(PPCInterpreter_t, spr.CTR), regR);
+			else if (sprIndex == SPR_XER)
+				x64Emit_mov_mem32_reg64(x64GenContext, REG_RESV_HCPU, offsetof(PPCInterpreter_t, spr.XER), regR);
+			else if (sprIndex >= SPR_UGQR0 && sprIndex <= SPR_UGQR7)
+			{
+				sint32 memOffset = offsetof(PPCInterpreter_t, spr.UGQR) + sizeof(PPCInterpreter_t::spr.UGQR[0]) * (sprIndex - SPR_UGQR0);
+				x64Emit_mov_mem32_reg64(x64GenContext, REG_RESV_HCPU, memOffset, regR);
+			}
+			else
+				assert_dbg();
+		}
+		else if (name >= PPCREC_NAME_TEMPORARY && name < PPCREC_NAME_TEMPORARY + 4)
+		{
+			x64Emit_mov_mem32_reg64(x64GenContext, REG_RESV_HCPU, offsetof(PPCInterpreter_t, temporaryGPR_reg) + sizeof(uint32) * (name - PPCREC_NAME_TEMPORARY), regR);
+		}
+		else if (name == PPCREC_NAME_XER_CA)
+		{
+			x64GenContext->emitter->MOV_bb_l(REG_RESV_HCPU, offsetof(PPCInterpreter_t, xer_ca), X86_REG_NONE, 0, _reg8_from_reg64(regR));
+		}
+		else if (name == PPCREC_NAME_XER_SO)
+		{
+			x64GenContext->emitter->MOV_bb_l(REG_RESV_HCPU, offsetof(PPCInterpreter_t, xer_so), X86_REG_NONE, 0, _reg8_from_reg64(regR));
+		}
+		else if (name >= PPCREC_NAME_CR && name <= PPCREC_NAME_CR_LAST)
+		{
+			x64GenContext->emitter->MOV_bb_l(REG_RESV_HCPU, offsetof(PPCInterpreter_t, cr) + (name - PPCREC_NAME_CR), X86_REG_NONE, 0, _reg8_from_reg64(regR));
+		}
+		else if (name == PPCREC_NAME_CPU_MEMRES_EA)
+		{
+			x64Emit_mov_mem32_reg64(x64GenContext, REG_RESV_HCPU, offsetof(PPCInterpreter_t, reservedMemAddr), regR);
+		}
+		else if (name == PPCREC_NAME_CPU_MEMRES_VAL)
+		{
+			x64Emit_mov_mem32_reg64(x64GenContext, REG_RESV_HCPU, offsetof(PPCInterpreter_t, reservedMemValue), regR);
+		}
+		else
+			assert_dbg();
+	}
+	else if (imlInstruction->op_r_name.regR.GetBaseFormat() == IMLRegFormat::F64)
+	{
+		auto regR = _regF64(imlInstruction->op_r_name.regR);
+		uint32 name = imlInstruction->op_r_name.name;
+		if (name >= PPCREC_NAME_FPR_HALF && name < (PPCREC_NAME_FPR_HALF + 64))
+		{
+			sint32 regIndex = (name - PPCREC_NAME_FPR_HALF) / 2;
+			sint32 pairIndex = (name - PPCREC_NAME_FPR_HALF) % 2;
+			x64Gen_movsd_memReg64_xmmReg(x64GenContext, regR, REG_RESV_HCPU, offsetof(PPCInterpreter_t, fpr) + sizeof(FPR_t) * regIndex + (pairIndex ? sizeof(double) : 0));
+		}
+		else if (name >= PPCREC_NAME_TEMPORARY_FPR0 && name < (PPCREC_NAME_TEMPORARY_FPR0 + 8))
+		{
+			x64Gen_movupd_memReg128_xmmReg(x64GenContext, regR, REG_RESV_HCPU, offsetof(PPCInterpreter_t, temporaryFPR) + sizeof(FPR_t) * (name - PPCREC_NAME_TEMPORARY_FPR0));
+		}
+		else
+		{
+			cemu_assert_debug(false);
+		}
+	}
+	else
+		DEBUG_BREAK;
+
+
+}
+
+uint8* codeMemoryBlock = nullptr;
+sint32 codeMemoryBlockIndex = 0;
+sint32 codeMemoryBlockSize = 0;
+
+std::mutex mtx_allocExecutableMemory;
+
+uint8* PPCRecompilerX86_allocateExecutableMemory(sint32 size)
+{
+	std::lock_guard<std::mutex> lck(mtx_allocExecutableMemory);
+	if( codeMemoryBlockIndex+size > codeMemoryBlockSize )
+	{
+		// allocate new block
+		codeMemoryBlockSize = std::max(1024*1024*4, size+1024); // 4MB (or more if the function is larger than 4MB)
+		codeMemoryBlockIndex = 0;
+		codeMemoryBlock = (uint8*)MemMapper::AllocateMemory(nullptr, codeMemoryBlockSize, MemMapper::PAGE_PERMISSION::P_RWX);
+	}
+	uint8* codeMem = codeMemoryBlock + codeMemoryBlockIndex;
+	codeMemoryBlockIndex += size;
+	// pad to 4 byte alignment
+	while (codeMemoryBlockIndex & 3)
+	{
+		codeMemoryBlock[codeMemoryBlockIndex] = 0x90;
+		codeMemoryBlockIndex++;
+	}
+	return codeMem;
+}
+
+bool PPCRecompiler_generateX64Code(PPCRecFunction_t* PPCRecFunction, ppcImlGenContext_t* ppcImlGenContext)
+{
+	x64GenContext_t x64GenContext{};
+
+	// generate iml instruction code
+	bool codeGenerationFailed = false;
+	for (IMLSegment* segIt : ppcImlGenContext->segmentList2)
+	{
+		x64GenContext.currentSegment = segIt;
+		segIt->x64Offset = x64GenContext.emitter->GetWriteIndex();
+		for(size_t i=0; i<segIt->imlList.size(); i++)
+		{
+			x64GenContext.m_currentInstructionEmitIndex = i;
+			IMLInstruction* imlInstruction = segIt->imlList.data() + i;
+
+			if( imlInstruction->type == PPCREC_IML_TYPE_R_NAME )
+			{
+				PPCRecompilerX64Gen_imlInstruction_r_name(PPCRecFunction, ppcImlGenContext, &x64GenContext, imlInstruction);
+			}
+			else if( imlInstruction->type == PPCREC_IML_TYPE_NAME_R )
+			{
+				PPCRecompilerX64Gen_imlInstruction_name_r(PPCRecFunction, ppcImlGenContext, &x64GenContext, imlInstruction);
+			}
+			else if( imlInstruction->type == PPCREC_IML_TYPE_R_R )
+			{
+				if( PPCRecompilerX64Gen_imlInstruction_r_r(PPCRecFunction, ppcImlGenContext, &x64GenContext, imlInstruction) == false )
+					codeGenerationFailed = true;
+			}
+			else if (imlInstruction->type == PPCREC_IML_TYPE_R_S32)
+			{
+				if (PPCRecompilerX64Gen_imlInstruction_r_s32(PPCRecFunction, ppcImlGenContext, &x64GenContext, imlInstruction) == false)
+					codeGenerationFailed = true;
+			}
+			else if (imlInstruction->type == PPCREC_IML_TYPE_R_R_S32)
+			{
+				if (PPCRecompilerX64Gen_imlInstruction_r_r_s32(PPCRecFunction, ppcImlGenContext, &x64GenContext, imlInstruction) == false)
+					codeGenerationFailed = true;
+			}
+			else if (imlInstruction->type == PPCREC_IML_TYPE_R_R_S32_CARRY)
+			{
+				if (PPCRecompilerX64Gen_imlInstruction_r_r_s32_carry(PPCRecFunction, ppcImlGenContext, &x64GenContext, imlInstruction) == false)
+					codeGenerationFailed = true;
+			}
+			else if (imlInstruction->type == PPCREC_IML_TYPE_R_R_R)
+			{
+				if (PPCRecompilerX64Gen_imlInstruction_r_r_r(PPCRecFunction, ppcImlGenContext, &x64GenContext, imlInstruction) == false)
+					codeGenerationFailed = true;
+			}
+			else if (imlInstruction->type == PPCREC_IML_TYPE_R_R_R_CARRY)
+			{
+				if (PPCRecompilerX64Gen_imlInstruction_r_r_r_carry(PPCRecFunction, ppcImlGenContext, &x64GenContext, imlInstruction) == false)
+					codeGenerationFailed = true;
+			}
+			else if (imlInstruction->type == PPCREC_IML_TYPE_COMPARE || imlInstruction->type == PPCREC_IML_TYPE_COMPARE_S32)
+			{
+				sint32 extraInstructionsProcessed;
+				PPCRecompilerX64Gen_imlInstruction_compare_x(PPCRecFunction, ppcImlGenContext, &x64GenContext, imlInstruction, extraInstructionsProcessed);
+				i += extraInstructionsProcessed;
+			}
+			else if (imlInstruction->type == PPCREC_IML_TYPE_CONDITIONAL_JUMP)
+			{
+				if (PPCRecompilerX64Gen_imlInstruction_cjump2(PPCRecFunction, ppcImlGenContext, &x64GenContext, imlInstruction, segIt) == false)
+					codeGenerationFailed = true;
+			}
+			else if(imlInstruction->type == PPCREC_IML_TYPE_X86_EFLAGS_JCC)
+			{
+				PPCRecompilerX64Gen_imlInstruction_x86_eflags_jcc(PPCRecFunction, ppcImlGenContext, &x64GenContext, imlInstruction, segIt);
+			}
+			else if (imlInstruction->type == PPCREC_IML_TYPE_JUMP)
+			{
+				if (PPCRecompilerX64Gen_imlInstruction_jump2(PPCRecFunction, ppcImlGenContext, &x64GenContext, imlInstruction, segIt) == false)
+					codeGenerationFailed = true;
+			}
+			else if( imlInstruction->type == PPCREC_IML_TYPE_CJUMP_CYCLE_CHECK )
+			{
+				PPCRecompilerX64Gen_imlInstruction_conditionalJumpCycleCheck(PPCRecFunction, ppcImlGenContext, &x64GenContext, imlInstruction);
+			}
+			else if( imlInstruction->type == PPCREC_IML_TYPE_MACRO )
+			{
+				if( PPCRecompilerX64Gen_imlInstruction_macro(PPCRecFunction, ppcImlGenContext, &x64GenContext, imlInstruction) == false )
+				{
+					codeGenerationFailed = true;
+				}
+			}
+			else if( imlInstruction->type == PPCREC_IML_TYPE_LOAD )
+			{
+				if( PPCRecompilerX64Gen_imlInstruction_load(PPCRecFunction, ppcImlGenContext, &x64GenContext, imlInstruction, false) == false )
+				{
+					codeGenerationFailed = true;
+				}
+			}
+			else if( imlInstruction->type == PPCREC_IML_TYPE_LOAD_INDEXED )
+			{
+				if( PPCRecompilerX64Gen_imlInstruction_load(PPCRecFunction, ppcImlGenContext, &x64GenContext, imlInstruction, true) == false )
+				{
+					codeGenerationFailed = true;
+				}
+			}
+			else if( imlInstruction->type == PPCREC_IML_TYPE_STORE )
+			{
+				if( PPCRecompilerX64Gen_imlInstruction_store(PPCRecFunction, ppcImlGenContext, &x64GenContext, imlInstruction, false) == false )
+				{
+					codeGenerationFailed = true;
+				}
+			}
+			else if( imlInstruction->type == PPCREC_IML_TYPE_STORE_INDEXED )
+			{
+				if( PPCRecompilerX64Gen_imlInstruction_store(PPCRecFunction, ppcImlGenContext, &x64GenContext, imlInstruction, true) == false )
+				{
+					codeGenerationFailed = true;
+				}
+			}
+			else if (imlInstruction->type == PPCREC_IML_TYPE_ATOMIC_CMP_STORE)
+			{
+				PPCRecompilerX64Gen_imlInstruction_atomic_cmp_store(PPCRecFunction, ppcImlGenContext, &x64GenContext, imlInstruction);
+			}
+			else if (imlInstruction->type == PPCREC_IML_TYPE_CALL_IMM)
+			{
+				PPCRecompilerX64Gen_imlInstruction_call_imm(PPCRecFunction, ppcImlGenContext, &x64GenContext, imlInstruction);
+			}
+			else if( imlInstruction->type == PPCREC_IML_TYPE_NO_OP )
+			{
+				// no op
+			}
+			else if( imlInstruction->type == PPCREC_IML_TYPE_FPR_LOAD )
+			{
+				if( PPCRecompilerX64Gen_imlInstruction_fpr_load(PPCRecFunction, ppcImlGenContext, &x64GenContext, imlInstruction, false) == false )
+				{
+					codeGenerationFailed = true;
+				}
+			}
+			else if( imlInstruction->type == PPCREC_IML_TYPE_FPR_LOAD_INDEXED )
+			{
+				if( PPCRecompilerX64Gen_imlInstruction_fpr_load(PPCRecFunction, ppcImlGenContext, &x64GenContext, imlInstruction, true) == false )
+				{
+					codeGenerationFailed = true;
+				}
+			}
+			else if( imlInstruction->type == PPCREC_IML_TYPE_FPR_STORE )
+			{
+				if( PPCRecompilerX64Gen_imlInstruction_fpr_store(PPCRecFunction, ppcImlGenContext, &x64GenContext, imlInstruction, false) == false )
+				{
+					codeGenerationFailed = true;
+				}
+			}
+			else if( imlInstruction->type == PPCREC_IML_TYPE_FPR_STORE_INDEXED )
+			{
+				if( PPCRecompilerX64Gen_imlInstruction_fpr_store(PPCRecFunction, ppcImlGenContext, &x64GenContext, imlInstruction, true) == false )
+				{
+					codeGenerationFailed = true;
+				}
+			}
+			else if( imlInstruction->type == PPCREC_IML_TYPE_FPR_R_R )
+			{
+				PPCRecompilerX64Gen_imlInstruction_fpr_r_r(PPCRecFunction, ppcImlGenContext, &x64GenContext, imlInstruction);		
+			}
+			else if( imlInstruction->type == PPCREC_IML_TYPE_FPR_R_R_R )
+			{
+				PPCRecompilerX64Gen_imlInstruction_fpr_r_r_r(PPCRecFunction, ppcImlGenContext, &x64GenContext, imlInstruction);		
+			}
+			else if( imlInstruction->type == PPCREC_IML_TYPE_FPR_R_R_R_R )
+			{
+				PPCRecompilerX64Gen_imlInstruction_fpr_r_r_r_r(PPCRecFunction, ppcImlGenContext, &x64GenContext, imlInstruction);		
+			}
+			else if( imlInstruction->type == PPCREC_IML_TYPE_FPR_R )
+			{
+				PPCRecompilerX64Gen_imlInstruction_fpr_r(PPCRecFunction, ppcImlGenContext, &x64GenContext, imlInstruction);		
+			}
+			else if (imlInstruction->type == PPCREC_IML_TYPE_FPR_COMPARE)
+			{
+				PPCRecompilerX64Gen_imlInstruction_fpr_compare(PPCRecFunction, ppcImlGenContext, &x64GenContext, imlInstruction);
+			}
+			else
+			{
+				debug_printf("PPCRecompiler_generateX64Code(): Unsupported iml type 0x%x\n", imlInstruction->type);
+				assert_dbg();
+			}
+		}
+	}
+	// handle failed code generation
+	if( codeGenerationFailed )
+	{
+		return false;
+	}
+	// allocate executable memory
+	uint8* executableMemory = PPCRecompilerX86_allocateExecutableMemory(x64GenContext.emitter->GetBuffer().size_bytes());
+	size_t baseAddress = (size_t)executableMemory;
+	// fix relocs
+	for(auto& relocIt : x64GenContext.relocateOffsetTable2)
+	{
+		// search for segment that starts with this offset
+		uint32 ppcOffset = (uint32)(size_t)relocIt.extraInfo;
+		uint32 x64Offset = 0xFFFFFFFF;
+
+		IMLSegment* destSegment = (IMLSegment*)relocIt.extraInfo;
+		x64Offset = destSegment->x64Offset;
+
+		uint32 relocBase = relocIt.offset;
+		uint8* relocInstruction = x64GenContext.emitter->GetBufferPtr()+relocBase;
+		if( relocInstruction[0] == 0x0F && (relocInstruction[1] >= 0x80 && relocInstruction[1] <= 0x8F) )
+		{
+			// Jcc relativeImm32
+			sint32 distanceNearJump = (sint32)((baseAddress + x64Offset) - (baseAddress + relocBase + 2));
+			if (distanceNearJump >= -128 && distanceNearJump < 127) // disabled
+			{
+				// convert to near Jcc
+				*(uint8*)(relocInstruction + 0) = (uint8)(relocInstruction[1]-0x80 + 0x70);
+				// patch offset
+				*(uint8*)(relocInstruction + 1) = (uint8)distanceNearJump;
+				// replace unused 4 bytes with NOP instruction
+				relocInstruction[2] = 0x0F;
+				relocInstruction[3] = 0x1F;
+				relocInstruction[4] = 0x40;
+				relocInstruction[5] = 0x00;
+			}
+			else
+			{
+				// patch offset
+				*(uint32*)(relocInstruction + 2) = (uint32)((baseAddress + x64Offset) - (baseAddress + relocBase + 6));
+			}
+		}
+		else if( relocInstruction[0] == 0xE9 )
+		{
+			// JMP relativeImm32
+			*(uint32*)(relocInstruction+1) = (uint32)((baseAddress+x64Offset)-(baseAddress+relocBase+5));
+		}
+		else
+			assert_dbg();
+	}
+
+	// copy code to executable memory
+	std::span<uint8> codeBuffer = x64GenContext.emitter->GetBuffer();
+	memcpy(executableMemory, codeBuffer.data(), codeBuffer.size_bytes());
+	// set code
+	PPCRecFunction->x86Code = executableMemory;
+	PPCRecFunction->x86Size = codeBuffer.size_bytes();
+	return true;
+}
+
+void PPCRecompilerX64Gen_generateEnterRecompilerCode()
+{
+	x64GenContext_t x64GenContext{};
+
+	// start of recompiler entry function (15 regs)
+	x64Gen_push_reg64(&x64GenContext, X86_REG_RAX);
+	x64Gen_push_reg64(&x64GenContext, X86_REG_RCX);
+	x64Gen_push_reg64(&x64GenContext, X86_REG_RDX);
+	x64Gen_push_reg64(&x64GenContext, X86_REG_RBX);
+	x64Gen_push_reg64(&x64GenContext, X86_REG_RBP);
+	x64Gen_push_reg64(&x64GenContext, X86_REG_RDI);
+	x64Gen_push_reg64(&x64GenContext, X86_REG_RSI);
+	x64Gen_push_reg64(&x64GenContext, X86_REG_R8);
+	x64Gen_push_reg64(&x64GenContext, X86_REG_R9);
+	x64Gen_push_reg64(&x64GenContext, X86_REG_R10);
+	x64Gen_push_reg64(&x64GenContext, X86_REG_R11);
+	x64Gen_push_reg64(&x64GenContext, X86_REG_R12);
+	x64Gen_push_reg64(&x64GenContext, X86_REG_R13);
+	x64Gen_push_reg64(&x64GenContext, X86_REG_R14);
+	x64Gen_push_reg64(&x64GenContext, X86_REG_R15);
+
+	// 000000007775EF04 | E8 00 00 00 00                      call +0x00
+	x64Gen_writeU8(&x64GenContext, 0xE8);
+	x64Gen_writeU8(&x64GenContext, 0x00);
+	x64Gen_writeU8(&x64GenContext, 0x00);
+	x64Gen_writeU8(&x64GenContext, 0x00);
+	x64Gen_writeU8(&x64GenContext, 0x00);
+	//000000007775EF09 | 48 83 04 24 05                       add qword ptr ss:[rsp],5
+	x64Gen_writeU8(&x64GenContext, 0x48);
+	x64Gen_writeU8(&x64GenContext, 0x83);
+	x64Gen_writeU8(&x64GenContext, 0x04);
+	x64Gen_writeU8(&x64GenContext, 0x24);
+	uint32 jmpPatchOffset = x64GenContext.emitter->GetWriteIndex();
+	x64Gen_writeU8(&x64GenContext, 0); // skip the distance until after the JMP
+	x64Emit_mov_mem64_reg64(&x64GenContext, X86_REG_RDX, offsetof(PPCInterpreter_t, rspTemp), X86_REG_RSP);
+
+	// MOV RSP, RDX (ppc interpreter instance)
+	x64Gen_mov_reg64_reg64(&x64GenContext, REG_RESV_HCPU, X86_REG_RDX);
+	// MOV R15, ppcRecompilerInstanceData
+	x64Gen_mov_reg64_imm64(&x64GenContext, REG_RESV_RECDATA, (uint64)ppcRecompilerInstanceData);
+	// MOV R13, memory_base
+	x64Gen_mov_reg64_imm64(&x64GenContext, REG_RESV_MEMBASE, (uint64)memory_base);
+
+	//JMP recFunc
+	x64Gen_jmp_reg64(&x64GenContext, X86_REG_RCX); // call argument 1
+
+	x64GenContext.emitter->GetBuffer()[jmpPatchOffset] = (x64GenContext.emitter->GetWriteIndex() -(jmpPatchOffset-4));
+
+	//recompilerExit1:
+	x64Gen_pop_reg64(&x64GenContext, X86_REG_R15);
+	x64Gen_pop_reg64(&x64GenContext, X86_REG_R14);
+	x64Gen_pop_reg64(&x64GenContext, X86_REG_R13);
+	x64Gen_pop_reg64(&x64GenContext, X86_REG_R12);
+	x64Gen_pop_reg64(&x64GenContext, X86_REG_R11);
+	x64Gen_pop_reg64(&x64GenContext, X86_REG_R10);
+	x64Gen_pop_reg64(&x64GenContext, X86_REG_R9);
+	x64Gen_pop_reg64(&x64GenContext, X86_REG_R8);
+	x64Gen_pop_reg64(&x64GenContext, X86_REG_RSI);
+	x64Gen_pop_reg64(&x64GenContext, X86_REG_RDI);
+	x64Gen_pop_reg64(&x64GenContext, X86_REG_RBP);
+	x64Gen_pop_reg64(&x64GenContext, X86_REG_RBX);
+	x64Gen_pop_reg64(&x64GenContext, X86_REG_RDX);
+	x64Gen_pop_reg64(&x64GenContext, X86_REG_RCX);
+	x64Gen_pop_reg64(&x64GenContext, X86_REG_RAX);
+	// RET
+	x64Gen_ret(&x64GenContext);
+
+	uint8* executableMemory = PPCRecompilerX86_allocateExecutableMemory(x64GenContext.emitter->GetBuffer().size_bytes());
+	// copy code to executable memory
+	memcpy(executableMemory, x64GenContext.emitter->GetBuffer().data(), x64GenContext.emitter->GetBuffer().size_bytes());
+	PPCRecompiler_enterRecompilerCode = (void ATTR_MS_ABI (*)(uint64,uint64))executableMemory;
+}
+
+
+void* PPCRecompilerX64Gen_generateLeaveRecompilerCode()
+{
+	x64GenContext_t x64GenContext{};
+
+	// update instruction pointer
+	// LR is in EDX
+	x64Emit_mov_mem32_reg32(&x64GenContext, REG_RESV_HCPU, offsetof(PPCInterpreter_t, instructionPointer), X86_REG_EDX);
+	// MOV RSP, [hCPU->rspTemp]
+	x64Emit_mov_reg64_mem64(&x64GenContext, X86_REG_RSP, REG_RESV_HCPU, offsetof(PPCInterpreter_t, rspTemp));
+	// RET
+	x64Gen_ret(&x64GenContext);
+
+	uint8* executableMemory = PPCRecompilerX86_allocateExecutableMemory(x64GenContext.emitter->GetBuffer().size_bytes());
+	// copy code to executable memory
+	memcpy(executableMemory, x64GenContext.emitter->GetBuffer().data(), x64GenContext.emitter->GetBuffer().size_bytes());
+	return executableMemory;
+}
+
+void PPCRecompilerX64Gen_generateRecompilerInterfaceFunctions()
+{
+	PPCRecompilerX64Gen_generateEnterRecompilerCode();
+	PPCRecompiler_leaveRecompilerCode_unvisited = (void ATTR_MS_ABI (*)())PPCRecompilerX64Gen_generateLeaveRecompilerCode();
+	PPCRecompiler_leaveRecompilerCode_visited = (void ATTR_MS_ABI (*)())PPCRecompilerX64Gen_generateLeaveRecompilerCode();
+	cemu_assert_debug(PPCRecompiler_leaveRecompilerCode_unvisited != PPCRecompiler_leaveRecompilerCode_visited);
+}
+
diff --git a/src/Cafe/HW/Espresso/Recompiler/PPCRecompilerX64.h b/src/Cafe/HW/Espresso/Recompiler/BackendX64/BackendX64.h
similarity index 81%
rename from src/Cafe/HW/Espresso/Recompiler/PPCRecompilerX64.h
rename to src/Cafe/HW/Espresso/Recompiler/BackendX64/BackendX64.h
index 1d37a77e..de415ca9 100644
--- a/src/Cafe/HW/Espresso/Recompiler/PPCRecompilerX64.h
+++ b/src/Cafe/HW/Espresso/Recompiler/BackendX64/BackendX64.h
@@ -1,104 +1,56 @@
 
-typedef struct  
+#include "../PPCRecompiler.h" // todo - get rid of dependency
+
+#include "x86Emitter.h"
+
+struct x64RelocEntry_t
 {
+	x64RelocEntry_t(uint32 offset, void* extraInfo) : offset(offset), extraInfo(extraInfo) {};
+
 	uint32 offset;
-	uint8  type;
 	void*  extraInfo;
-}x64RelocEntry_t;
+};
 
-typedef struct  
+struct x64GenContext_t
 {
-	uint8* codeBuffer;
-	sint32 codeBufferIndex;
-	sint32 codeBufferSize;
-	// cr state
-	sint32 activeCRRegister; // current x86 condition flags reflect this cr* register
-	sint32 activeCRState; // describes the way in which x86 flags map to the cr register (signed / unsigned)
+	IMLSegment* currentSegment{};
+	x86Assembler64* emitter;
+	sint32 m_currentInstructionEmitIndex;
+
+	x64GenContext_t()
+	{
+		emitter = new x86Assembler64();
+	}
+
+	~x64GenContext_t()
+	{
+		delete emitter;
+	}
+
+	IMLInstruction* GetNextInstruction(sint32 relativeIndex = 1)
+	{
+		sint32 index = m_currentInstructionEmitIndex + relativeIndex;
+		if(index < 0 || index >= (sint32)currentSegment->imlList.size())
+			return nullptr;
+		return currentSegment->imlList.data() + index;
+	}
+
 	// relocate offsets
-	x64RelocEntry_t* relocateOffsetTable;
-	sint32 relocateOffsetTableSize;
-	sint32 relocateOffsetTableCount;
-}x64GenContext_t;
-
-// Some of these are defined by winnt.h and gnu headers
-#undef REG_EAX
-#undef REG_ECX
-#undef REG_EDX
-#undef REG_EBX
-#undef REG_ESP
-#undef REG_EBP
-#undef REG_ESI
-#undef REG_EDI
-#undef REG_NONE
-#undef REG_RAX
-#undef REG_RCX
-#undef REG_RDX
-#undef REG_RBX
-#undef REG_RSP
-#undef REG_RBP
-#undef REG_RSI
-#undef REG_RDI
-#undef REG_R8
-#undef REG_R9
-#undef REG_R10
-#undef REG_R11
-#undef REG_R12
-#undef REG_R13
-#undef REG_R14
-#undef REG_R15
-
-#define REG_EAX		0
-#define REG_ECX		1
-#define REG_EDX		2
-#define REG_EBX		3
-#define REG_ESP		4	// reserved for low half of hCPU pointer
-#define REG_EBP		5
-#define REG_ESI		6
-#define REG_EDI		7
-#define REG_NONE	-1
-
-#define REG_RAX		0
-#define REG_RCX		1
-#define REG_RDX		2
-#define REG_RBX		3
-#define REG_RSP		4	// reserved for hCPU pointer
-#define REG_RBP		5
-#define REG_RSI		6
-#define REG_RDI		7
-#define REG_R8		8
-#define REG_R9		9
-#define REG_R10		10
-#define REG_R11		11
-#define REG_R12		12
-#define REG_R13		13 // reserved to hold pointer to memory base? (Not decided yet)
-#define REG_R14		14 // reserved as temporary register
-#define REG_R15		15 // reserved for pointer to ppcRecompilerInstanceData
-
-#define REG_AL		0
-#define REG_CL		1
-#define REG_DL		2
-#define REG_BL		3
-#define REG_AH		4
-#define REG_CH		5
-#define REG_DH		6
-#define REG_BH		7
+	std::vector<x64RelocEntry_t> relocateOffsetTable2;
+};
 
 // reserved registers
-#define REG_RESV_TEMP		(REG_R14)
-#define REG_RESV_HCPU		(REG_RSP)
-#define REG_RESV_MEMBASE	(REG_R13)
-#define REG_RESV_RECDATA	(REG_R15)
+#define REG_RESV_TEMP		(X86_REG_R14)
+#define REG_RESV_HCPU		(X86_REG_RSP)
+#define REG_RESV_MEMBASE	(X86_REG_R13)
+#define REG_RESV_RECDATA	(X86_REG_R15)
 
 // reserved floating-point registers
 #define REG_RESV_FPR_TEMP	(15)
 
+#define reg32ToReg16(__x)	(__x) // deprecated
 
-extern sint32 x64Gen_registerMap[12];
-
-#define tempToRealRegister(__x) (x64Gen_registerMap[__x])
-#define tempToRealFPRRegister(__x) (__x)
-#define reg32ToReg16(__x)	(__x)
-
+// deprecated condition flags
 enum
 {
 	X86_CONDITION_EQUAL, // or zero
@@ -119,36 +71,23 @@ enum
 	X86_CONDITION_NONE, // no condition, jump always
 };
 
-#define PPCREC_CR_TEMPORARY							(8)		// never stored
-#define PPCREC_CR_STATE_TYPE_UNSIGNED_ARITHMETIC	(0)		// for signed arithmetic operations (ADD, CMPI)
-#define PPCREC_CR_STATE_TYPE_SIGNED_ARITHMETIC		(1)		// for unsigned arithmetic operations (ADD, CMPI)
-#define PPCREC_CR_STATE_TYPE_LOGICAL				(2)		// for unsigned operations (CMPLI)
-
-#define X86_RELOC_MAKE_RELATIVE				(0)		// make code imm relative to instruction
-#define X64_RELOC_LINK_TO_PPC				(1)		// translate from ppc address to x86 offset 
-#define X64_RELOC_LINK_TO_SEGMENT			(2)		// link to beginning of segment
-
-#define PPC_X64_GPR_USABLE_REGISTERS		(16-4)
-#define PPC_X64_FPR_USABLE_REGISTERS		(16-1) // Use XMM0 - XMM14, XMM15 is the temp register
-
-
-bool PPCRecompiler_generateX64Code(PPCRecFunction_t* PPCRecFunction, ppcImlGenContext_t* ppcImlGenContext);
-
-void PPCRecompilerX64Gen_crConditionFlags_forget(PPCRecFunction_t* PPCRecFunction, ppcImlGenContext_t* ppcImlGenContext, x64GenContext_t* x64GenContext);
+bool PPCRecompiler_generateX64Code(struct PPCRecFunction_t* PPCRecFunction, ppcImlGenContext_t* ppcImlGenContext);
 
 void PPCRecompilerX64Gen_redirectRelativeJump(x64GenContext_t* x64GenContext, sint32 jumpInstructionOffset, sint32 destinationOffset);
 
 void PPCRecompilerX64Gen_generateRecompilerInterfaceFunctions();
 
-void PPCRecompilerX64Gen_imlInstruction_fpr_r_name(PPCRecFunction_t* PPCRecFunction, ppcImlGenContext_t* ppcImlGenContext, x64GenContext_t* x64GenContext, PPCRecImlInstruction_t* imlInstruction);
-void PPCRecompilerX64Gen_imlInstruction_fpr_name_r(PPCRecFunction_t* PPCRecFunction, ppcImlGenContext_t* ppcImlGenContext, x64GenContext_t* x64GenContext, PPCRecImlInstruction_t* imlInstruction);
-bool PPCRecompilerX64Gen_imlInstruction_fpr_load(PPCRecFunction_t* PPCRecFunction, ppcImlGenContext_t* ppcImlGenContext, x64GenContext_t* x64GenContext, PPCRecImlInstruction_t* imlInstruction, bool indexed);
-bool PPCRecompilerX64Gen_imlInstruction_fpr_store(PPCRecFunction_t* PPCRecFunction, ppcImlGenContext_t* ppcImlGenContext, x64GenContext_t* x64GenContext, PPCRecImlInstruction_t* imlInstruction, bool indexed);
+void PPCRecompilerX64Gen_imlInstruction_fpr_r_name(PPCRecFunction_t* PPCRecFunction, ppcImlGenContext_t* ppcImlGenContext, x64GenContext_t* x64GenContext, IMLInstruction* imlInstruction);
+void PPCRecompilerX64Gen_imlInstruction_fpr_name_r(PPCRecFunction_t* PPCRecFunction, ppcImlGenContext_t* ppcImlGenContext, x64GenContext_t* x64GenContext, IMLInstruction* imlInstruction);
+bool PPCRecompilerX64Gen_imlInstruction_fpr_load(PPCRecFunction_t* PPCRecFunction, ppcImlGenContext_t* ppcImlGenContext, x64GenContext_t* x64GenContext, IMLInstruction* imlInstruction, bool indexed);
+bool PPCRecompilerX64Gen_imlInstruction_fpr_store(PPCRecFunction_t* PPCRecFunction, ppcImlGenContext_t* ppcImlGenContext, x64GenContext_t* x64GenContext, IMLInstruction* imlInstruction, bool indexed);
 
-void PPCRecompilerX64Gen_imlInstruction_fpr_r_r(PPCRecFunction_t* PPCRecFunction, ppcImlGenContext_t* ppcImlGenContext, x64GenContext_t* x64GenContext, PPCRecImlInstruction_t* imlInstruction);
-void PPCRecompilerX64Gen_imlInstruction_fpr_r_r_r(PPCRecFunction_t* PPCRecFunction, ppcImlGenContext_t* ppcImlGenContext, x64GenContext_t* x64GenContext, PPCRecImlInstruction_t* imlInstruction);
-void PPCRecompilerX64Gen_imlInstruction_fpr_r_r_r_r(PPCRecFunction_t* PPCRecFunction, ppcImlGenContext_t* ppcImlGenContext, x64GenContext_t* x64GenContext, PPCRecImlInstruction_t* imlInstruction);
-void PPCRecompilerX64Gen_imlInstruction_fpr_r(PPCRecFunction_t* PPCRecFunction, ppcImlGenContext_t* ppcImlGenContext, x64GenContext_t* x64GenContext, PPCRecImlInstruction_t* imlInstruction);
+void PPCRecompilerX64Gen_imlInstruction_fpr_r_r(PPCRecFunction_t* PPCRecFunction, ppcImlGenContext_t* ppcImlGenContext, x64GenContext_t* x64GenContext, IMLInstruction* imlInstruction);
+void PPCRecompilerX64Gen_imlInstruction_fpr_r_r_r(PPCRecFunction_t* PPCRecFunction, ppcImlGenContext_t* ppcImlGenContext, x64GenContext_t* x64GenContext, IMLInstruction* imlInstruction);
+void PPCRecompilerX64Gen_imlInstruction_fpr_r_r_r_r(PPCRecFunction_t* PPCRecFunction, ppcImlGenContext_t* ppcImlGenContext, x64GenContext_t* x64GenContext, IMLInstruction* imlInstruction);
+void PPCRecompilerX64Gen_imlInstruction_fpr_r(PPCRecFunction_t* PPCRecFunction, ppcImlGenContext_t* ppcImlGenContext, x64GenContext_t* x64GenContext, IMLInstruction* imlInstruction);
+
+void PPCRecompilerX64Gen_imlInstruction_fpr_compare(PPCRecFunction_t* PPCRecFunction, ppcImlGenContext_t* ppcImlGenContext, x64GenContext_t* x64GenContext, IMLInstruction* imlInstruction);
 
 // ASM gen
 void x64Gen_writeU8(x64GenContext_t* x64GenContext, uint8 v);
@@ -196,9 +135,6 @@ void x64Gen_or_reg64Low8_mem8Reg64(x64GenContext_t* x64GenContext, sint32 dstReg
 void x64Gen_and_reg64Low8_mem8Reg64(x64GenContext_t* x64GenContext, sint32 dstRegister, sint32 memRegister64, sint32 memImmS32);
 void x64Gen_mov_mem8Reg64_reg64Low8(x64GenContext_t* x64GenContext, sint32 dstRegister, sint32 memRegister64, sint32 memImmS32);
 
-void x64Gen_lock_cmpxchg_mem32Reg64PlusReg64_reg64(x64GenContext_t* x64GenContext, sint32 memRegisterA64, sint32 memRegisterB64, sint32 memImmS32, sint32 srcRegister);
-void x64Gen_lock_cmpxchg_mem32Reg64_reg64(x64GenContext_t* x64GenContext, sint32 memRegister64, sint32 memImmS32, sint32 srcRegister);
-
 void x64Gen_add_reg64_reg64(x64GenContext_t* x64GenContext, sint32 destRegister, sint32 srcRegister);
 void x64Gen_add_reg64Low32_reg64Low32(x64GenContext_t* x64GenContext, sint32 destRegister, sint32 srcRegister);
 void x64Gen_add_reg64_imm32(x64GenContext_t* x64GenContext, sint32 srcRegister, uint32 immU32);
@@ -207,9 +143,6 @@ void x64Gen_sub_reg64Low32_reg64Low32(x64GenContext_t* x64GenContext, sint32 des
 void x64Gen_sub_reg64Low32_imm32(x64GenContext_t* x64GenContext, sint32 srcRegister, uint32 immU32);
 void x64Gen_sub_reg64_imm32(x64GenContext_t* x64GenContext, sint32 srcRegister, uint32 immU32);
 void x64Gen_sub_mem32reg64_imm32(x64GenContext_t* x64GenContext, sint32 memRegister, sint32 memImmS32, uint64 immU32);
-void x64Gen_sbb_reg64Low32_reg64Low32(x64GenContext_t* x64GenContext, sint32 destRegister, sint32 srcRegister);
-void x64Gen_adc_reg64Low32_reg64Low32(x64GenContext_t* x64GenContext, sint32 destRegister, sint32 srcRegister);
-void x64Gen_adc_reg64Low32_imm32(x64GenContext_t* x64GenContext, sint32 srcRegister, uint32 immU32);
 void x64Gen_dec_mem32(x64GenContext_t* x64GenContext, sint32 memoryRegister, uint32 memoryImmU32);
 void x64Gen_imul_reg64Low32_reg64Low32(x64GenContext_t* x64GenContext, sint32 destRegister, sint32 operandRegister);
 void x64Gen_idiv_reg64Low32(x64GenContext_t* x64GenContext, sint32 operandRegister);
@@ -241,9 +174,7 @@ void x64Gen_not_reg64Low32(x64GenContext_t* x64GenContext, sint32 destRegister);
 void x64Gen_neg_reg64Low32(x64GenContext_t* x64GenContext, sint32 destRegister);
 void x64Gen_cdq(x64GenContext_t* x64GenContext);
 
-void x64Gen_bswap_reg64(x64GenContext_t* x64GenContext, sint32 destRegister);
 void x64Gen_bswap_reg64Lower32bit(x64GenContext_t* x64GenContext, sint32 destRegister);
-void x64Gen_bswap_reg64Lower16bit(x64GenContext_t* x64GenContext, sint32 destRegister);
 
 void x64Gen_lzcnt_reg64Low32_reg64Low32(x64GenContext_t* x64GenContext, sint32 destRegister, sint32 srcRegister);
 void x64Gen_bsr_reg64Low32_reg64Low32(x64GenContext_t* x64GenContext, sint32 destRegister, sint32 srcRegister);
@@ -274,6 +205,7 @@ void x64Gen_movddup_xmmReg_xmmReg(x64GenContext_t* x64GenContext, sint32 xmmRegi
 void x64Gen_movhlps_xmmReg_xmmReg(x64GenContext_t* x64GenContext, sint32 xmmRegisterDest, sint32 xmmRegisterSrc);
 void x64Gen_movsd_xmmReg_xmmReg(x64GenContext_t* x64GenContext, sint32 xmmRegisterDest, sint32 xmmRegisterSrc);
 void x64Gen_movsd_memReg64_xmmReg(x64GenContext_t* x64GenContext, sint32 xmmRegister, sint32 memRegister, uint32 memImmU32);
+void x64Gen_movsd_xmmReg_memReg64(x64GenContext_t* x64GenContext, sint32 xmmRegister, sint32 memRegister, uint32 memImmU32);
 void x64Gen_movlpd_xmmReg_memReg64(x64GenContext_t* x64GenContext, sint32 xmmRegister, sint32 memRegister, uint32 memImmU32);
 void x64Gen_unpcklpd_xmmReg_xmmReg(x64GenContext_t* x64GenContext, sint32 xmmRegisterDest, sint32 xmmRegisterSrc);
 void x64Gen_unpckhpd_xmmReg_xmmReg(x64GenContext_t* x64GenContext, sint32 xmmRegisterDest, sint32 xmmRegisterSrc);
@@ -299,6 +231,7 @@ void x64Gen_andps_xmmReg_xmmReg(x64GenContext_t* x64GenContext, sint32 xmmRegist
 void x64Gen_pcmpeqd_xmmReg_mem128Reg64(x64GenContext_t* x64GenContext, sint32 xmmRegisterDest, uint32 memReg, uint32 memImmS32);
 void x64Gen_cvttpd2dq_xmmReg_xmmReg(x64GenContext_t* x64GenContext, sint32 xmmRegisterDest, sint32 xmmRegisterSrc);
 void x64Gen_cvttsd2si_xmmReg_xmmReg(x64GenContext_t* x64GenContext, sint32 registerDest, sint32 xmmRegisterSrc);
+void x64Gen_cvtsi2sd_xmmReg_xmmReg(x64GenContext_t* x64GenContext, sint32 xmmRegisterDest, sint32 registerSrc);
 void x64Gen_cvtsd2ss_xmmReg_xmmReg(x64GenContext_t* x64GenContext, sint32 xmmRegisterDest, sint32 xmmRegisterSrc);
 void x64Gen_cvtpd2ps_xmmReg_xmmReg(x64GenContext_t* x64GenContext, sint32 xmmRegisterDest, sint32 xmmRegisterSrc);
 void x64Gen_cvtss2sd_xmmReg_xmmReg(x64GenContext_t* x64GenContext, sint32 xmmRegisterDest, sint32 xmmRegisterSrc);
@@ -329,4 +262,8 @@ void x64Gen_movBEZeroExtend_reg64Low16_mem16Reg64PlusReg64(x64GenContext_t* x64G
 void x64Gen_movBETruncate_mem32Reg64PlusReg64_reg64(x64GenContext_t* x64GenContext, sint32 memRegisterA64, sint32 memRegisterB64, sint32 memImmS32, sint32 srcRegister);
 
 void x64Gen_shrx_reg64_reg64_reg64(x64GenContext_t* x64GenContext, sint32 registerDst, sint32 registerA, sint32 registerB);
-void x64Gen_shlx_reg64_reg64_reg64(x64GenContext_t* x64GenContext, sint32 registerDst, sint32 registerA, sint32 registerB);
\ No newline at end of file
+void x64Gen_shrx_reg32_reg32_reg32(x64GenContext_t* x64GenContext, sint32 registerDst, sint32 registerA, sint32 registerB);
+void x64Gen_sarx_reg64_reg64_reg64(x64GenContext_t* x64GenContext, sint32 registerDst, sint32 registerA, sint32 registerB);
+void x64Gen_sarx_reg32_reg32_reg32(x64GenContext_t* x64GenContext, sint32 registerDst, sint32 registerA, sint32 registerB);
+void x64Gen_shlx_reg64_reg64_reg64(x64GenContext_t* x64GenContext, sint32 registerDst, sint32 registerA, sint32 registerB);
+void x64Gen_shlx_reg32_reg32_reg32(x64GenContext_t* x64GenContext, sint32 registerDst, sint32 registerA, sint32 registerB);
\ No newline at end of file
diff --git a/src/Cafe/HW/Espresso/Recompiler/PPCRecompilerX64AVX.cpp b/src/Cafe/HW/Espresso/Recompiler/BackendX64/BackendX64AVX.cpp
similarity index 92%
rename from src/Cafe/HW/Espresso/Recompiler/PPCRecompilerX64AVX.cpp
rename to src/Cafe/HW/Espresso/Recompiler/BackendX64/BackendX64AVX.cpp
index 619c3985..b0ef8640 100644
--- a/src/Cafe/HW/Espresso/Recompiler/PPCRecompilerX64AVX.cpp
+++ b/src/Cafe/HW/Espresso/Recompiler/BackendX64/BackendX64AVX.cpp
@@ -1,5 +1,4 @@
-#include "PPCRecompiler.h"
-#include "PPCRecompilerX64.h"
+#include "BackendX64.h"
 
 void _x64Gen_writeMODRMDeprecated(x64GenContext_t* x64GenContext, sint32 dataRegister, sint32 memRegisterA64, sint32 memRegisterB64, sint32 memImmS32);
 
@@ -21,11 +20,10 @@ void _x64Gen_vex128_nds(x64GenContext_t* x64GenContext, uint8 opcodeMap, uint8 a
 	x64Gen_writeU8(x64GenContext, opcode);
 }
 
-#define VEX_PP_0F		0 // guessed
+#define VEX_PP_0F		0
 #define VEX_PP_66_0F	1
-#define VEX_PP_F3_0F	2 // guessed
-#define VEX_PP_F2_0F	3 // guessed
-
+#define VEX_PP_F3_0F	2
+#define VEX_PP_F2_0F	3
 
 void x64Gen_avx_VPUNPCKHQDQ_xmm_xmm_xmm(x64GenContext_t* x64GenContext, sint32 dstRegister, sint32 srcRegisterA, sint32 srcRegisterB)
 {
diff --git a/src/Cafe/HW/Espresso/Recompiler/PPCRecompilerX64BMI.cpp b/src/Cafe/HW/Espresso/Recompiler/BackendX64/BackendX64BMI.cpp
similarity index 67%
rename from src/Cafe/HW/Espresso/Recompiler/PPCRecompilerX64BMI.cpp
rename to src/Cafe/HW/Espresso/Recompiler/BackendX64/BackendX64BMI.cpp
index 5a71e93d..bbb707e0 100644
--- a/src/Cafe/HW/Espresso/Recompiler/PPCRecompilerX64BMI.cpp
+++ b/src/Cafe/HW/Espresso/Recompiler/BackendX64/BackendX64BMI.cpp
@@ -1,5 +1,4 @@
-#include "PPCRecompiler.h"
-#include "PPCRecompilerX64.h"
+#include "BackendX64.h"
 
 void _x64Gen_writeMODRMDeprecated(x64GenContext_t* x64GenContext, sint32 dataRegister, sint32 memRegisterA64, sint32 memRegisterB64, sint32 memImmS32);
 
@@ -69,6 +68,34 @@ void x64Gen_shrx_reg64_reg64_reg64(x64GenContext_t* x64GenContext, sint32 regist
 	x64Gen_writeU8(x64GenContext, 0xC0 + (registerDst & 7) * 8 + (registerA & 7));
 }
 
+void x64Gen_shrx_reg32_reg32_reg32(x64GenContext_t* x64GenContext, sint32 registerDst, sint32 registerA, sint32 registerB)
+{
+	x64Gen_writeU8(x64GenContext, 0xC4);
+	x64Gen_writeU8(x64GenContext, 0xE2 - ((registerDst >= 8) ? 0x80 : 0) - ((registerA >= 8) ? 0x20 : 0));
+	x64Gen_writeU8(x64GenContext, 0x7B - registerB * 8);
+	x64Gen_writeU8(x64GenContext, 0xF7);
+	x64Gen_writeU8(x64GenContext, 0xC0 + (registerDst & 7) * 8 + (registerA & 7));
+}
+
+void x64Gen_sarx_reg64_reg64_reg64(x64GenContext_t* x64GenContext, sint32 registerDst, sint32 registerA, sint32 registerB)
+{
+	// SARX reg64, reg64, reg64
+	x64Gen_writeU8(x64GenContext, 0xC4);
+	x64Gen_writeU8(x64GenContext, 0xE2 - ((registerDst >= 8) ? 0x80 : 0) - ((registerA >= 8) ? 0x20 : 0));
+	x64Gen_writeU8(x64GenContext, 0xFA - registerB * 8);
+	x64Gen_writeU8(x64GenContext, 0xF7);
+	x64Gen_writeU8(x64GenContext, 0xC0 + (registerDst & 7) * 8 + (registerA & 7));
+}
+
+void x64Gen_sarx_reg32_reg32_reg32(x64GenContext_t* x64GenContext, sint32 registerDst, sint32 registerA, sint32 registerB)
+{
+	x64Gen_writeU8(x64GenContext, 0xC4);
+	x64Gen_writeU8(x64GenContext, 0xE2 - ((registerDst >= 8) ? 0x80 : 0) - ((registerA >= 8) ? 0x20 : 0));
+	x64Gen_writeU8(x64GenContext, 0x7A - registerB * 8);
+	x64Gen_writeU8(x64GenContext, 0xF7);
+	x64Gen_writeU8(x64GenContext, 0xC0 + (registerDst & 7) * 8 + (registerA & 7));
+}
+
 void x64Gen_shlx_reg64_reg64_reg64(x64GenContext_t* x64GenContext, sint32 registerDst, sint32 registerA, sint32 registerB)
 {
 	// SHLX reg64, reg64, reg64
@@ -77,4 +104,13 @@ void x64Gen_shlx_reg64_reg64_reg64(x64GenContext_t* x64GenContext, sint32 regist
 	x64Gen_writeU8(x64GenContext, 0xF9 - registerB * 8);
 	x64Gen_writeU8(x64GenContext, 0xF7);
 	x64Gen_writeU8(x64GenContext, 0xC0 + (registerDst & 7) * 8 + (registerA & 7));
+}
+
+void x64Gen_shlx_reg32_reg32_reg32(x64GenContext_t* x64GenContext, sint32 registerDst, sint32 registerA, sint32 registerB)
+{
+	x64Gen_writeU8(x64GenContext, 0xC4);
+	x64Gen_writeU8(x64GenContext, 0xE2 - ((registerDst >= 8) ? 0x80 : 0) - ((registerA >= 8) ? 0x20 : 0));
+	x64Gen_writeU8(x64GenContext, 0x79 - registerB * 8);
+	x64Gen_writeU8(x64GenContext, 0xF7);
+	x64Gen_writeU8(x64GenContext, 0xC0 + (registerDst & 7) * 8 + (registerA & 7));
 }
\ No newline at end of file
diff --git a/src/Cafe/HW/Espresso/Recompiler/BackendX64/BackendX64FPU.cpp b/src/Cafe/HW/Espresso/Recompiler/BackendX64/BackendX64FPU.cpp
new file mode 100644
index 00000000..6a8b1b97
--- /dev/null
+++ b/src/Cafe/HW/Espresso/Recompiler/BackendX64/BackendX64FPU.cpp
@@ -0,0 +1,469 @@
+#include "../PPCRecompiler.h"
+#include "../IML/IML.h"
+#include "BackendX64.h"
+#include "Common/cpu_features.h"
+
+uint32 _regF64(IMLReg physReg);
+
+uint32 _regI32(IMLReg r)
+{
+	cemu_assert_debug(r.GetRegFormat() == IMLRegFormat::I32);
+	return (uint32)r.GetRegID();
+}
+
+static x86Assembler64::GPR32 _reg32(sint8 physRegId)
+{
+	return (x86Assembler64::GPR32)physRegId;
+}
+
+static x86Assembler64::GPR8_REX _reg8(IMLReg r)
+{
+	cemu_assert_debug(r.GetRegFormat() == IMLRegFormat::I32); // currently bool regs are implemented as 32bit registers
+	return (x86Assembler64::GPR8_REX)r.GetRegID();
+}
+
+static x86Assembler64::GPR32 _reg32_from_reg8(x86Assembler64::GPR8_REX regId)
+{
+	return (x86Assembler64::GPR32)regId;
+}
+
+static x86Assembler64::GPR8_REX _reg8_from_reg32(x86Assembler64::GPR32 regId)
+{
+	return (x86Assembler64::GPR8_REX)regId;
+}
+
+// load from memory
+bool PPCRecompilerX64Gen_imlInstruction_fpr_load(PPCRecFunction_t* PPCRecFunction, ppcImlGenContext_t* ppcImlGenContext, x64GenContext_t* x64GenContext, IMLInstruction* imlInstruction, bool indexed)
+{
+	sint32 realRegisterXMM =  _regF64(imlInstruction->op_storeLoad.registerData);
+	sint32 realRegisterMem = _regI32(imlInstruction->op_storeLoad.registerMem);
+	sint32 realRegisterMem2 = PPC_REC_INVALID_REGISTER;
+	if( indexed )
+		realRegisterMem2 = _regI32(imlInstruction->op_storeLoad.registerMem2);
+	uint8 mode = imlInstruction->op_storeLoad.mode;
+
+	if( mode == PPCREC_FPR_LD_MODE_SINGLE )
+	{
+		// load byte swapped single into temporary FPR
+		if( indexed )
+		{
+			x64Gen_mov_reg64Low32_reg64Low32(x64GenContext, REG_RESV_TEMP, realRegisterMem2);
+			x64Gen_add_reg64Low32_reg64Low32(x64GenContext, REG_RESV_TEMP, realRegisterMem);
+			if(g_CPUFeatures.x86.movbe)
+				x64Gen_movBEZeroExtend_reg64_mem32Reg64PlusReg64(x64GenContext, REG_RESV_TEMP, REG_RESV_MEMBASE, REG_RESV_TEMP, imlInstruction->op_storeLoad.immS32);
+			else
+				x64Emit_mov_reg32_mem32(x64GenContext, REG_RESV_TEMP, REG_RESV_MEMBASE, REG_RESV_TEMP, imlInstruction->op_storeLoad.immS32);
+		}
+		else
+		{
+			if(g_CPUFeatures.x86.movbe)
+				x64Gen_movBEZeroExtend_reg64_mem32Reg64PlusReg64(x64GenContext, REG_RESV_TEMP, REG_RESV_MEMBASE, realRegisterMem, imlInstruction->op_storeLoad.immS32);
+			else
+				x64Emit_mov_reg32_mem32(x64GenContext, REG_RESV_TEMP, REG_RESV_MEMBASE, realRegisterMem, imlInstruction->op_storeLoad.immS32);
+		}
+		if(g_CPUFeatures.x86.movbe == false )
+			x64Gen_bswap_reg64Lower32bit(x64GenContext, REG_RESV_TEMP);
+		x64Gen_movd_xmmReg_reg64Low32(x64GenContext, realRegisterXMM, REG_RESV_TEMP);
+
+		if (imlInstruction->op_storeLoad.flags2.notExpanded)
+		{
+			// leave value as single
+		}
+		else
+		{
+			x64Gen_cvtss2sd_xmmReg_xmmReg(x64GenContext, realRegisterXMM, realRegisterXMM);
+		}
+	}
+	else if( mode == PPCREC_FPR_LD_MODE_DOUBLE )
+	{
+		if( g_CPUFeatures.x86.avx )
+		{
+			if( indexed )
+			{
+				// calculate offset
+				x64Gen_mov_reg64Low32_reg64Low32(x64GenContext, REG_RESV_TEMP, realRegisterMem);
+				x64Gen_add_reg64Low32_reg64Low32(x64GenContext, REG_RESV_TEMP, realRegisterMem2);
+				// load value
+				x64Emit_mov_reg64_mem64(x64GenContext, REG_RESV_TEMP, REG_RESV_MEMBASE, REG_RESV_TEMP, imlInstruction->op_storeLoad.immS32+0);
+				x64GenContext->emitter->BSWAP_q(REG_RESV_TEMP);
+				x64Gen_movq_xmmReg_reg64(x64GenContext, REG_RESV_FPR_TEMP, REG_RESV_TEMP);
+				x64Gen_movsd_xmmReg_xmmReg(x64GenContext, realRegisterXMM, REG_RESV_FPR_TEMP);
+			}
+			else
+			{
+				x64Emit_mov_reg64_mem64(x64GenContext, REG_RESV_TEMP, REG_RESV_MEMBASE, realRegisterMem, imlInstruction->op_storeLoad.immS32+0);
+				x64GenContext->emitter->BSWAP_q(REG_RESV_TEMP);
+				x64Gen_movq_xmmReg_reg64(x64GenContext, REG_RESV_FPR_TEMP, REG_RESV_TEMP);
+				x64Gen_movsd_xmmReg_xmmReg(x64GenContext, realRegisterXMM, REG_RESV_FPR_TEMP);
+			}
+		}
+		else
+		{
+			if( indexed )
+			{
+				// calculate offset
+				x64Gen_mov_reg64Low32_reg64Low32(x64GenContext, REG_RESV_TEMP, realRegisterMem);
+				x64Gen_add_reg64Low32_reg64Low32(x64GenContext, REG_RESV_TEMP, realRegisterMem2);
+				// load double low part to temporaryFPR
+				x64Emit_mov_reg32_mem32(x64GenContext, REG_RESV_TEMP, REG_RESV_MEMBASE, REG_RESV_TEMP, imlInstruction->op_storeLoad.immS32+0);
+				x64Gen_bswap_reg64Lower32bit(x64GenContext, REG_RESV_TEMP);
+				x64Emit_mov_mem32_reg64(x64GenContext, REG_RESV_HCPU, offsetof(PPCInterpreter_t, temporaryFPR)+4, REG_RESV_TEMP);
+				// calculate offset again
+				x64Gen_mov_reg64Low32_reg64Low32(x64GenContext, REG_RESV_TEMP, realRegisterMem);
+				x64Gen_add_reg64Low32_reg64Low32(x64GenContext, REG_RESV_TEMP, realRegisterMem2);
+				// load double high part to temporaryFPR
+				x64Emit_mov_reg32_mem32(x64GenContext, REG_RESV_TEMP, REG_RESV_MEMBASE, REG_RESV_TEMP, imlInstruction->op_storeLoad.immS32+4);
+				x64Gen_bswap_reg64Lower32bit(x64GenContext, REG_RESV_TEMP);
+				x64Emit_mov_mem32_reg64(x64GenContext, REG_RESV_HCPU, offsetof(PPCInterpreter_t, temporaryFPR)+0, REG_RESV_TEMP);
+				// load double from temporaryFPR
+				x64Gen_movlpd_xmmReg_memReg64(x64GenContext, realRegisterXMM, REG_RESV_HCPU, offsetof(PPCInterpreter_t, temporaryFPR));
+			}
+			else
+			{
+				// load double low part to temporaryFPR
+				x64Emit_mov_reg32_mem32(x64GenContext, REG_RESV_TEMP, REG_RESV_MEMBASE, realRegisterMem, imlInstruction->op_storeLoad.immS32+0);
+				x64Gen_bswap_reg64Lower32bit(x64GenContext, REG_RESV_TEMP);
+				x64Emit_mov_mem32_reg64(x64GenContext, REG_RESV_HCPU, offsetof(PPCInterpreter_t, temporaryFPR)+4, REG_RESV_TEMP);
+				// load double high part to temporaryFPR
+				x64Emit_mov_reg32_mem32(x64GenContext, REG_RESV_TEMP, REG_RESV_MEMBASE, realRegisterMem, imlInstruction->op_storeLoad.immS32+4);
+				x64Gen_bswap_reg64Lower32bit(x64GenContext, REG_RESV_TEMP);
+				x64Emit_mov_mem32_reg64(x64GenContext, REG_RESV_HCPU, offsetof(PPCInterpreter_t, temporaryFPR)+0, REG_RESV_TEMP);
+				// load double from temporaryFPR
+				x64Gen_movlpd_xmmReg_memReg64(x64GenContext, realRegisterXMM, REG_RESV_HCPU, offsetof(PPCInterpreter_t, temporaryFPR));
+			}
+		}
+	}
+	else
+	{
+		return false;
+	}
+	return true;
+}
+
+// store to memory
+bool PPCRecompilerX64Gen_imlInstruction_fpr_store(PPCRecFunction_t* PPCRecFunction, ppcImlGenContext_t* ppcImlGenContext, x64GenContext_t* x64GenContext, IMLInstruction* imlInstruction, bool indexed)
+{
+	sint32 realRegisterXMM = _regF64(imlInstruction->op_storeLoad.registerData);
+	sint32 realRegisterMem = _regI32(imlInstruction->op_storeLoad.registerMem);
+	sint32 realRegisterMem2 = PPC_REC_INVALID_REGISTER;
+	if( indexed )
+		realRegisterMem2 = _regI32(imlInstruction->op_storeLoad.registerMem2);
+	uint8 mode = imlInstruction->op_storeLoad.mode;
+	if( mode == PPCREC_FPR_ST_MODE_SINGLE )
+	{
+		if (imlInstruction->op_storeLoad.flags2.notExpanded)
+		{
+			// value is already in single format
+			x64Gen_movd_reg64Low32_xmmReg(x64GenContext, REG_RESV_TEMP, realRegisterXMM);
+		}
+		else
+		{
+			x64Gen_cvtsd2ss_xmmReg_xmmReg(x64GenContext, REG_RESV_FPR_TEMP, realRegisterXMM);
+			x64Gen_movd_reg64Low32_xmmReg(x64GenContext, REG_RESV_TEMP, REG_RESV_FPR_TEMP);
+		}
+		if(g_CPUFeatures.x86.movbe == false )
+			x64Gen_bswap_reg64Lower32bit(x64GenContext, REG_RESV_TEMP);
+		if( indexed )
+		{
+			if( realRegisterMem == realRegisterMem2 )
+				assert_dbg();
+			x64Gen_add_reg64Low32_reg64Low32(x64GenContext, realRegisterMem, realRegisterMem2);
+		}
+		if(g_CPUFeatures.x86.movbe)
+			x64Gen_movBETruncate_mem32Reg64PlusReg64_reg64(x64GenContext, REG_RESV_MEMBASE, realRegisterMem, imlInstruction->op_storeLoad.immS32, REG_RESV_TEMP);
+		else
+			x64Gen_movTruncate_mem32Reg64PlusReg64_reg64(x64GenContext, REG_RESV_MEMBASE, realRegisterMem, imlInstruction->op_storeLoad.immS32, REG_RESV_TEMP);
+		if( indexed )
+		{
+			x64Gen_sub_reg64Low32_reg64Low32(x64GenContext, realRegisterMem, realRegisterMem2);
+		}
+	}
+	else if( mode == PPCREC_FPR_ST_MODE_DOUBLE )
+	{
+		if( indexed )
+		{
+			if( realRegisterMem == realRegisterMem2 )
+				assert_dbg();
+			x64Gen_add_reg64Low32_reg64Low32(x64GenContext, realRegisterMem, realRegisterMem2);
+		}
+		x64Gen_movsd_memReg64_xmmReg(x64GenContext, realRegisterXMM, REG_RESV_HCPU, offsetof(PPCInterpreter_t, temporaryFPR));
+		// store double low part	
+		x64Emit_mov_reg64_mem32(x64GenContext, REG_RESV_TEMP, REG_RESV_HCPU, offsetof(PPCInterpreter_t, temporaryFPR)+0);
+		x64Gen_bswap_reg64Lower32bit(x64GenContext, REG_RESV_TEMP);
+		x64Gen_movTruncate_mem32Reg64PlusReg64_reg64(x64GenContext, REG_RESV_MEMBASE, realRegisterMem, imlInstruction->op_storeLoad.immS32+4, REG_RESV_TEMP);
+		// store double high part	
+		x64Emit_mov_reg64_mem32(x64GenContext, REG_RESV_TEMP, REG_RESV_HCPU, offsetof(PPCInterpreter_t, temporaryFPR)+4);
+		x64Gen_bswap_reg64Lower32bit(x64GenContext, REG_RESV_TEMP);
+		x64Gen_movTruncate_mem32Reg64PlusReg64_reg64(x64GenContext, REG_RESV_MEMBASE, realRegisterMem, imlInstruction->op_storeLoad.immS32+0, REG_RESV_TEMP);
+		if( indexed )
+		{
+			x64Gen_sub_reg64Low32_reg64Low32(x64GenContext, realRegisterMem, realRegisterMem2);
+		}
+	}
+	else if( mode == PPCREC_FPR_ST_MODE_UI32_FROM_PS0 )
+	{
+		x64Gen_movd_reg64Low32_xmmReg(x64GenContext, REG_RESV_TEMP, realRegisterXMM);
+		x64Gen_bswap_reg64Lower32bit(x64GenContext, REG_RESV_TEMP);
+		if( indexed )
+		{
+			cemu_assert_debug(realRegisterMem == realRegisterMem2);
+			x64Gen_add_reg64Low32_reg64Low32(x64GenContext, realRegisterMem, realRegisterMem2);
+			x64Gen_movTruncate_mem32Reg64PlusReg64_reg64(x64GenContext, REG_RESV_MEMBASE, realRegisterMem, imlInstruction->op_storeLoad.immS32, REG_RESV_TEMP);
+			x64Gen_sub_reg64Low32_reg64Low32(x64GenContext, realRegisterMem, realRegisterMem2);
+		}
+		else
+		{
+			x64Gen_movTruncate_mem32Reg64PlusReg64_reg64(x64GenContext, REG_RESV_MEMBASE, realRegisterMem, imlInstruction->op_storeLoad.immS32, REG_RESV_TEMP);
+		}
+	}
+	else
+	{
+		debug_printf("PPCRecompilerX64Gen_imlInstruction_fpr_store(): Unsupported mode %d\n", mode);
+		return false;
+	}
+	return true;
+}
+
+// FPR op FPR
+void PPCRecompilerX64Gen_imlInstruction_fpr_r_r(PPCRecFunction_t* PPCRecFunction, ppcImlGenContext_t* ppcImlGenContext, x64GenContext_t* x64GenContext, IMLInstruction* imlInstruction)
+{
+	if( imlInstruction->operation == PPCREC_IML_OP_FPR_FLOAT_TO_INT )
+	{
+		uint32 regGpr = _regI32(imlInstruction->op_fpr_r_r.regR);
+		uint32 regFpr = _regF64(imlInstruction->op_fpr_r_r.regA);
+		x64Gen_cvttsd2si_reg64Low_xmmReg(x64GenContext, regGpr, regFpr);
+		return;
+	}
+	else if( imlInstruction->operation == PPCREC_IML_OP_FPR_INT_TO_FLOAT )
+	{
+		uint32 regFpr = _regF64(imlInstruction->op_fpr_r_r.regR);
+		uint32 regGpr = _regI32(imlInstruction->op_fpr_r_r.regA);
+		x64Gen_cvtsi2sd_xmmReg_xmmReg(x64GenContext, regFpr, regGpr);
+		return;
+	}
+	else if (imlInstruction->operation == PPCREC_IML_OP_FPR_BITCAST_INT_TO_FLOAT)
+	{
+		cemu_assert_debug(imlInstruction->op_fpr_r_r.regR.GetRegFormat() == IMLRegFormat::F64); // assuming target is always F64 for now
+		cemu_assert_debug(imlInstruction->op_fpr_r_r.regA.GetRegFormat() == IMLRegFormat::I32); // supporting only 32bit floats as input for now
+		// exact operation depends on size of types. Floats are automatically promoted to double if the target is F64
+		uint32 regFpr = _regF64(imlInstruction->op_fpr_r_r.regR);
+		if (imlInstruction->op_fpr_r_r.regA.GetRegFormat() == IMLRegFormat::I32)
+		{
+			uint32 regGpr = _regI32(imlInstruction->op_fpr_r_r.regA);
+			x64Gen_movq_xmmReg_reg64(x64GenContext, regFpr, regGpr); // using reg32 as reg64 param here is ok. We'll refactor later
+			// float to double
+			x64Gen_cvtss2sd_xmmReg_xmmReg(x64GenContext, regFpr, regFpr);
+		}
+		else
+		{
+			cemu_assert_unimplemented();
+		}
+		return;
+	}
+
+	uint32 regR = _regF64(imlInstruction->op_fpr_r_r.regR);
+	uint32 regA = _regF64(imlInstruction->op_fpr_r_r.regA);
+	if( imlInstruction->operation == PPCREC_IML_OP_FPR_ASSIGN )
+	{
+		x64Gen_movsd_xmmReg_xmmReg(x64GenContext, regR, regA);
+	}
+	else if( imlInstruction->operation == PPCREC_IML_OP_FPR_MULTIPLY )
+	{
+		x64Gen_mulsd_xmmReg_xmmReg(x64GenContext, regR, regA);
+	}
+	else if( imlInstruction->operation == PPCREC_IML_OP_FPR_DIVIDE )
+	{
+		x64Gen_divsd_xmmReg_xmmReg(x64GenContext, regR, regA);
+	}
+	else if( imlInstruction->operation == PPCREC_IML_OP_FPR_ADD )
+	{
+		x64Gen_addsd_xmmReg_xmmReg(x64GenContext, regR, regA);
+	}
+	else if( imlInstruction->operation == PPCREC_IML_OP_FPR_SUB )
+	{
+		x64Gen_subsd_xmmReg_xmmReg(x64GenContext, regR, regA);
+	}
+	else if( imlInstruction->operation == PPCREC_IML_OP_FPR_FCTIWZ )
+	{
+		x64Gen_cvttsd2si_xmmReg_xmmReg(x64GenContext, REG_RESV_TEMP, regA);
+		x64Gen_mov_reg64Low32_reg64Low32(x64GenContext, REG_RESV_TEMP, REG_RESV_TEMP);
+		// move to FPR register
+		x64Gen_movq_xmmReg_reg64(x64GenContext, regR, REG_RESV_TEMP);
+	}
+	else
+	{
+		assert_dbg();
+	}
+}
+
+/*
+ * FPR = op (fprA, fprB)
+ */
+void PPCRecompilerX64Gen_imlInstruction_fpr_r_r_r(PPCRecFunction_t* PPCRecFunction, ppcImlGenContext_t* ppcImlGenContext, x64GenContext_t* x64GenContext, IMLInstruction* imlInstruction)
+{
+	uint32 regR = _regF64(imlInstruction->op_fpr_r_r_r.regR);
+	uint32 regA = _regF64(imlInstruction->op_fpr_r_r_r.regA);
+	uint32 regB = _regF64(imlInstruction->op_fpr_r_r_r.regB);
+
+	if (imlInstruction->operation == PPCREC_IML_OP_FPR_MULTIPLY)
+	{
+		if (regR == regA)
+		{
+			x64Gen_mulsd_xmmReg_xmmReg(x64GenContext, regR, regB);
+		}
+		else if (regR == regB)
+		{
+			x64Gen_mulsd_xmmReg_xmmReg(x64GenContext, regR, regA);
+		}
+		else
+		{
+			x64Gen_movsd_xmmReg_xmmReg(x64GenContext, regR, regA);
+			x64Gen_mulsd_xmmReg_xmmReg(x64GenContext, regR, regB);
+		}
+	}
+	else if (imlInstruction->operation == PPCREC_IML_OP_FPR_ADD)
+	{
+		// todo: Use AVX 3-operand VADDSD if available
+		if (regR == regA)
+		{
+			x64Gen_addsd_xmmReg_xmmReg(x64GenContext, regR, regB);
+		}
+		else if (regR == regB)
+		{
+			x64Gen_addsd_xmmReg_xmmReg(x64GenContext, regR, regA);
+		}
+		else
+		{
+			x64Gen_movaps_xmmReg_xmmReg(x64GenContext, regR, regA);
+			x64Gen_addsd_xmmReg_xmmReg(x64GenContext, regR, regB);
+		}
+	}
+	else if( imlInstruction->operation == PPCREC_IML_OP_FPR_SUB )
+	{
+		if( regR == regA )
+		{
+			x64Gen_subsd_xmmReg_xmmReg(x64GenContext, regR, regB);
+		}
+		else if( regR == regB )
+		{
+			x64Gen_movsd_xmmReg_xmmReg(x64GenContext, REG_RESV_FPR_TEMP, regA);
+			x64Gen_subsd_xmmReg_xmmReg(x64GenContext, REG_RESV_FPR_TEMP, regB);
+			x64Gen_movsd_xmmReg_xmmReg(x64GenContext, regR, REG_RESV_FPR_TEMP);
+		}
+		else
+		{
+			x64Gen_movsd_xmmReg_xmmReg(x64GenContext, regR, regA);
+			x64Gen_subsd_xmmReg_xmmReg(x64GenContext, regR, regB);
+		}
+	}
+	else
+		assert_dbg();
+}
+
+/*
+ * FPR = op (fprA, fprB, fprC)
+ */
+void PPCRecompilerX64Gen_imlInstruction_fpr_r_r_r_r(PPCRecFunction_t* PPCRecFunction, ppcImlGenContext_t* ppcImlGenContext, x64GenContext_t* x64GenContext, IMLInstruction* imlInstruction)
+{
+	uint32 regR = _regF64(imlInstruction->op_fpr_r_r_r_r.regR);
+	uint32 regA = _regF64(imlInstruction->op_fpr_r_r_r_r.regA);
+	uint32 regB = _regF64(imlInstruction->op_fpr_r_r_r_r.regB);
+	uint32 regC = _regF64(imlInstruction->op_fpr_r_r_r_r.regC);
+
+	if( imlInstruction->operation == PPCREC_IML_OP_FPR_SELECT )
+	{
+		x64Gen_comisd_xmmReg_mem64Reg64(x64GenContext, regA, REG_RESV_RECDATA, offsetof(PPCRecompilerInstanceData_t, _x64XMM_constDouble0_0));
+		sint32 jumpInstructionOffset1 = x64GenContext->emitter->GetWriteIndex();
+		x64Gen_jmpc_near(x64GenContext, X86_CONDITION_UNSIGNED_BELOW, 0);
+		// select C
+		x64Gen_movsd_xmmReg_xmmReg(x64GenContext, regR, regC);
+		sint32 jumpInstructionOffset2 = x64GenContext->emitter->GetWriteIndex();
+		x64Gen_jmpc_near(x64GenContext, X86_CONDITION_NONE, 0);
+		// select B
+		PPCRecompilerX64Gen_redirectRelativeJump(x64GenContext, jumpInstructionOffset1, x64GenContext->emitter->GetWriteIndex());
+		x64Gen_movsd_xmmReg_xmmReg(x64GenContext, regR, regB);
+		// end
+		PPCRecompilerX64Gen_redirectRelativeJump(x64GenContext, jumpInstructionOffset2, x64GenContext->emitter->GetWriteIndex());
+	}
+	else
+		assert_dbg();
+}
+
+void PPCRecompilerX64Gen_imlInstruction_fpr_r(PPCRecFunction_t* PPCRecFunction, ppcImlGenContext_t* ppcImlGenContext, x64GenContext_t* x64GenContext, IMLInstruction* imlInstruction)
+{
+	uint32 regR = _regF64(imlInstruction->op_fpr_r.regR);
+
+	if( imlInstruction->operation == PPCREC_IML_OP_FPR_NEGATE )
+	{
+		x64Gen_xorps_xmmReg_mem128Reg64(x64GenContext, regR, REG_RESV_RECDATA, offsetof(PPCRecompilerInstanceData_t, _x64XMM_xorNegateMaskBottom));
+	}
+	else if( imlInstruction->operation == PPCREC_IML_OP_FPR_LOAD_ONE )
+	{
+		x64Gen_movsd_xmmReg_memReg64(x64GenContext, regR, REG_RESV_RECDATA, offsetof(PPCRecompilerInstanceData_t, _x64XMM_constDouble1_1));
+	}
+	else if( imlInstruction->operation == PPCREC_IML_OP_FPR_ABS )
+	{
+		x64Gen_andps_xmmReg_mem128Reg64(x64GenContext, regR, REG_RESV_RECDATA, offsetof(PPCRecompilerInstanceData_t, _x64XMM_andAbsMaskBottom));
+	}
+	else if( imlInstruction->operation == PPCREC_IML_OP_FPR_NEGATIVE_ABS )
+	{
+		x64Gen_orps_xmmReg_mem128Reg64(x64GenContext, regR, REG_RESV_RECDATA, offsetof(PPCRecompilerInstanceData_t, _x64XMM_xorNegateMaskBottom));
+	}
+	else if( imlInstruction->operation == PPCREC_IML_OP_FPR_ROUND_TO_SINGLE_PRECISION_BOTTOM )
+	{
+		// convert to 32bit single
+		x64Gen_cvtsd2ss_xmmReg_xmmReg(x64GenContext, regR, regR);
+		// convert back to 64bit double
+		x64Gen_cvtss2sd_xmmReg_xmmReg(x64GenContext, regR, regR);
+	}
+	else if (imlInstruction->operation == PPCREC_IML_OP_FPR_EXPAND_F32_TO_F64)
+	{
+		// convert bottom to 64bit double
+		x64Gen_cvtss2sd_xmmReg_xmmReg(x64GenContext, regR, regR);
+	}
+	else
+	{
+		cemu_assert_unimplemented();
+	}
+}
+
+void PPCRecompilerX64Gen_imlInstruction_fpr_compare(PPCRecFunction_t* PPCRecFunction, ppcImlGenContext_t* ppcImlGenContext, x64GenContext_t* x64GenContext, IMLInstruction* imlInstruction)
+{
+	auto regR = _reg8(imlInstruction->op_fpr_compare.regR);
+	auto regA = _regF64(imlInstruction->op_fpr_compare.regA);
+	auto regB = _regF64(imlInstruction->op_fpr_compare.regB);
+
+	x64GenContext->emitter->XOR_dd(_reg32_from_reg8(regR), _reg32_from_reg8(regR));
+	x64Gen_ucomisd_xmmReg_xmmReg(x64GenContext, regA, regB);
+
+	if (imlInstruction->op_fpr_compare.cond == IMLCondition::UNORDERED_GT)
+	{
+		// GT case can be covered with a single SETnbe which checks CF==0 && ZF==0 (unordered sets both)
+		x64GenContext->emitter->SETcc_b(X86Cond::X86_CONDITION_NBE, regR);
+		return;
+	}
+	else if (imlInstruction->op_fpr_compare.cond == IMLCondition::UNORDERED_U)
+	{
+		// unordered case can be checked via PF
+		x64GenContext->emitter->SETcc_b(X86Cond::X86_CONDITION_PE, regR);
+		return;
+	}
+
+	// remember unordered state
+	auto regTmp = _reg32_from_reg8(_reg32(REG_RESV_TEMP));
+	x64GenContext->emitter->SETcc_b(X86Cond::X86_CONDITION_PO, regTmp); // by reversing the parity we can avoid having to XOR the value for masking the LT/EQ conditions
+
+	X86Cond x86Cond;
+	switch (imlInstruction->op_fpr_compare.cond)
+	{
+	case IMLCondition::UNORDERED_LT:
+		x64GenContext->emitter->SETcc_b(X86Cond::X86_CONDITION_B, regR);
+		break;
+	case IMLCondition::UNORDERED_EQ:
+		x64GenContext->emitter->SETcc_b(X86Cond::X86_CONDITION_Z, regR);
+		break;
+	default:
+		cemu_assert_unimplemented();
+	}
+	x64GenContext->emitter->AND_bb(_reg8_from_reg32(regR), _reg8_from_reg32(regTmp)); // if unordered (PF=1) then force LT/GT/EQ to zero 
+}
\ No newline at end of file
diff --git a/src/Cafe/HW/Espresso/Recompiler/PPCRecompilerX64Gen.cpp b/src/Cafe/HW/Espresso/Recompiler/BackendX64/BackendX64Gen.cpp
similarity index 90%
rename from src/Cafe/HW/Espresso/Recompiler/PPCRecompilerX64Gen.cpp
rename to src/Cafe/HW/Espresso/Recompiler/BackendX64/BackendX64Gen.cpp
index 19327f46..efe929d0 100644
--- a/src/Cafe/HW/Espresso/Recompiler/PPCRecompilerX64Gen.cpp
+++ b/src/Cafe/HW/Espresso/Recompiler/BackendX64/BackendX64Gen.cpp
@@ -1,62 +1,31 @@
-#include "PPCRecompiler.h"
-#include "PPCRecompilerIml.h"
-#include "PPCRecompilerX64.h"
+#include "BackendX64.h"
 
 // x86/x64 extension opcodes that could be useful:
 // ANDN
 // mulx, rorx, sarx, shlx, shrx
 // PDEP, PEXT
 
-void x64Gen_checkBuffer(x64GenContext_t* x64GenContext)
-{
-	// todo
-}
-
 void x64Gen_writeU8(x64GenContext_t* x64GenContext, uint8 v)
 {
-	if( x64GenContext->codeBufferIndex+1 > x64GenContext->codeBufferSize )
-	{
-		x64GenContext->codeBufferSize *= 2;
-		x64GenContext->codeBuffer = (uint8*)realloc(x64GenContext->codeBuffer, x64GenContext->codeBufferSize);
-	}
-	*(uint8*)(x64GenContext->codeBuffer+x64GenContext->codeBufferIndex) = v;
-	x64GenContext->codeBufferIndex++;
+	x64GenContext->emitter->_emitU8(v);
 }
 
 void x64Gen_writeU16(x64GenContext_t* x64GenContext, uint32 v)
 {
-	if( x64GenContext->codeBufferIndex+2 > x64GenContext->codeBufferSize )
-	{
-		x64GenContext->codeBufferSize *= 2;
-		x64GenContext->codeBuffer = (uint8*)realloc(x64GenContext->codeBuffer, x64GenContext->codeBufferSize);
-	}
-	*(uint16*)(x64GenContext->codeBuffer+x64GenContext->codeBufferIndex) = v;
-	x64GenContext->codeBufferIndex += 2;
+	x64GenContext->emitter->_emitU16(v);
 }
 
 void x64Gen_writeU32(x64GenContext_t* x64GenContext, uint32 v)
 {
-	if( x64GenContext->codeBufferIndex+4 > x64GenContext->codeBufferSize )
-	{
-		x64GenContext->codeBufferSize *= 2;
-		x64GenContext->codeBuffer = (uint8*)realloc(x64GenContext->codeBuffer, x64GenContext->codeBufferSize);
-	}
-	*(uint32*)(x64GenContext->codeBuffer+x64GenContext->codeBufferIndex) = v;
-	x64GenContext->codeBufferIndex += 4;
+	x64GenContext->emitter->_emitU32(v);
 }
 
 void x64Gen_writeU64(x64GenContext_t* x64GenContext, uint64 v)
 {
-	if( x64GenContext->codeBufferIndex+8 > x64GenContext->codeBufferSize )
-	{
-		x64GenContext->codeBufferSize *= 2;
-		x64GenContext->codeBuffer = (uint8*)realloc(x64GenContext->codeBuffer, x64GenContext->codeBufferSize);
-	}
-	*(uint64*)(x64GenContext->codeBuffer+x64GenContext->codeBufferIndex) = v;
-	x64GenContext->codeBufferIndex += 8;
+	x64GenContext->emitter->_emitU64(v);
 }
 
-#include "x64Emit.hpp"
+#include "X64Emit.hpp"
 
 void _x64Gen_writeMODRMDeprecated(x64GenContext_t* x64GenContext, sint32 dataRegister, sint32 memRegisterA64, sint32 memRegisterB64, sint32 memImmS32)
 {
@@ -67,7 +36,7 @@ void _x64Gen_writeMODRMDeprecated(x64GenContext_t* x64GenContext, sint32 dataReg
 		forceUseOffset = true;
 	}
 
-	if (memRegisterB64 == REG_NONE)
+	if (memRegisterB64 == X86_REG_NONE)
 	{
 		// memRegisterA64 + memImmS32
 		uint8 modRM = (dataRegister & 7) * 8 + (memRegisterA64 & 7);
@@ -352,7 +321,7 @@ void x64Gen_mov_mem32Reg64_imm32(x64GenContext_t* x64GenContext, sint32 memRegis
 void x64Gen_mov_mem64Reg64_imm32(x64GenContext_t* x64GenContext, sint32 memRegister, uint32 memImmU32, uint32 dataImmU32)
 {
 	// MOV QWORD [<memReg>+<memImmU32>], dataImmU32
-	if( memRegister == REG_R14 )
+	if( memRegister == X86_REG_R14 )
 	{
 		sint32 memImmS32 = (sint32)memImmU32;
 		if( memImmS32 == 0 )
@@ -384,7 +353,7 @@ void x64Gen_mov_mem64Reg64_imm32(x64GenContext_t* x64GenContext, sint32 memRegis
 void x64Gen_mov_mem8Reg64_imm8(x64GenContext_t* x64GenContext, sint32 memRegister, uint32 memImmU32, uint8 dataImmU8)
 {
 	// MOV BYTE [<memReg64>+<memImmU32>], dataImmU8
-	if( memRegister == REG_RSP )
+	if( memRegister == X86_REG_RSP )
 	{
 		sint32 memImmS32 = (sint32)memImmU32;
 		if( memImmS32 >= -128 && memImmS32 <= 127 )
@@ -625,7 +594,7 @@ void _x64_op_reg64Low_mem8Reg64(x64GenContext_t* x64GenContext, sint32 dstRegist
 	if (memRegister64 >= 8)
 		x64Gen_writeU8(x64GenContext, 0x41);
 	x64Gen_writeU8(x64GenContext, opByte);
-	_x64Gen_writeMODRMDeprecated(x64GenContext, dstRegister, memRegister64, REG_NONE, memImmS32);
+	_x64Gen_writeMODRMDeprecated(x64GenContext, dstRegister, memRegister64, X86_REG_NONE, memImmS32);
 }
 
 void x64Gen_or_reg64Low8_mem8Reg64(x64GenContext_t* x64GenContext, sint32 dstRegister, sint32 memRegister64, sint32 memImmS32)
@@ -643,40 +612,6 @@ void x64Gen_mov_mem8Reg64_reg64Low8(x64GenContext_t* x64GenContext, sint32 dstRe
 	_x64_op_reg64Low_mem8Reg64(x64GenContext, dstRegister, memRegister64, memImmS32, 0x88);
 }
 
-void x64Gen_lock_cmpxchg_mem32Reg64PlusReg64_reg64(x64GenContext_t* x64GenContext, sint32 memRegisterA64, sint32 memRegisterB64, sint32 memImmS32, sint32 srcRegister)
-{
-	// LOCK CMPXCHG DWORD [<reg64> + <reg64> + <imm64>], <srcReg64> (low dword)
-	x64Gen_writeU8(x64GenContext, 0xF0); // LOCK prefix
-
-	if( srcRegister >= 8 || memRegisterA64 >= 8|| memRegisterB64 >= 8 )
-		x64Gen_writeU8(x64GenContext, 0x40+((srcRegister>=8)?4:0)+((memRegisterA64>=8)?1:0)+((memRegisterB64>=8)?2:0));
-
-	x64Gen_writeU8(x64GenContext, 0x0F);
-	x64Gen_writeU8(x64GenContext, 0xB1);
-
-	_x64Gen_writeMODRMDeprecated(x64GenContext, srcRegister, memRegisterA64, memRegisterB64, memImmS32);
-}
-
-void x64Gen_lock_cmpxchg_mem32Reg64_reg64(x64GenContext_t* x64GenContext, sint32 memRegister64, sint32 memImmS32, sint32 srcRegister)
-{
-	// LOCK CMPXCHG DWORD [<reg64> + <imm64>], <srcReg64> (low dword)
-	x64Gen_writeU8(x64GenContext, 0xF0); // LOCK prefix
-
-	if( srcRegister >= 8 || memRegister64 >= 8 )
-		x64Gen_writeU8(x64GenContext, 0x40+((srcRegister>=8)?4:0)+((memRegister64>=8)?1:0));
-
-	x64Gen_writeU8(x64GenContext, 0x0F);
-	x64Gen_writeU8(x64GenContext, 0xB1);
-
-	if( memImmS32 == 0 )
-	{
-		x64Gen_writeU8(x64GenContext, 0x45+(srcRegister&7)*8);
-		x64Gen_writeU8(x64GenContext, 0x00);
-	}
-	else
-		assert_dbg();
-}
-
 void x64Gen_add_reg64_reg64(x64GenContext_t* x64GenContext, sint32 destRegister, sint32 srcRegister)
 {
 	// ADD <destReg>, <srcReg>
@@ -732,7 +667,7 @@ void x64Gen_add_reg64Low32_imm32(x64GenContext_t* x64GenContext, sint32 srcRegis
 	}
 	else
 	{
-		if( srcRegister == REG_RAX )
+		if( srcRegister == X86_REG_RAX )
 		{
 			// special EAX short form
 			x64Gen_writeU8(x64GenContext, 0x05);
@@ -772,7 +707,7 @@ void x64Gen_sub_reg64Low32_imm32(x64GenContext_t* x64GenContext, sint32 srcRegis
 	}
 	else
 	{
-		if( srcRegister == REG_RAX )
+		if( srcRegister == X86_REG_RAX )
 		{
 			// special EAX short form
 			x64Gen_writeU8(x64GenContext, 0x2D);
@@ -811,7 +746,7 @@ void x64Gen_sub_mem32reg64_imm32(x64GenContext_t* x64GenContext, sint32 memRegis
 {
 	// SUB <mem32_memReg64>, <imm32>
 	sint32 immS32 = (sint32)immU32;
-	if( memRegister == REG_RSP )
+	if( memRegister == X86_REG_RSP )
 	{
 		if( memImmS32 >= 128 )
 		{
@@ -843,64 +778,11 @@ void x64Gen_sub_mem32reg64_imm32(x64GenContext_t* x64GenContext, sint32 memRegis
 	}
 }
 
-void x64Gen_sbb_reg64Low32_reg64Low32(x64GenContext_t* x64GenContext, sint32 destRegister, sint32 srcRegister)
-{
-	// SBB <destReg64_low32>, <srcReg64_low32>
-	if( destRegister >= 8 && srcRegister >= 8 )
-		x64Gen_writeU8(x64GenContext, 0x45);
-	else if( srcRegister >= 8 )
-		x64Gen_writeU8(x64GenContext, 0x44);
-	else if( destRegister >= 8 )
-		x64Gen_writeU8(x64GenContext, 0x41);
-	x64Gen_writeU8(x64GenContext, 0x19);
-	x64Gen_writeU8(x64GenContext, 0xC0+(srcRegister&7)*8+(destRegister&7));
-}
-
-void x64Gen_adc_reg64Low32_reg64Low32(x64GenContext_t* x64GenContext, sint32 destRegister, sint32 srcRegister)
-{
-	// ADC <destReg64_low32>, <srcReg64_low32>
-	if( destRegister >= 8 && srcRegister >= 8 )
-		x64Gen_writeU8(x64GenContext, 0x45);
-	else if( srcRegister >= 8 )
-		x64Gen_writeU8(x64GenContext, 0x44);
-	else if( destRegister >= 8 )
-		x64Gen_writeU8(x64GenContext, 0x41);
-	x64Gen_writeU8(x64GenContext, 0x11);
-	x64Gen_writeU8(x64GenContext, 0xC0+(srcRegister&7)*8+(destRegister&7));
-}
-
-void x64Gen_adc_reg64Low32_imm32(x64GenContext_t* x64GenContext, sint32 srcRegister, uint32 immU32)
-{
-	sint32 immS32 = (sint32)immU32;
-	if( srcRegister >= 8 )
-		x64Gen_writeU8(x64GenContext, 0x41);
-	if( immS32 >= -128 && immS32 <= 127 )
-	{
-		x64Gen_writeU8(x64GenContext, 0x83);
-		x64Gen_writeU8(x64GenContext, 0xD0+(srcRegister&7));
-		x64Gen_writeU8(x64GenContext, (uint8)immS32);
-	}
-	else
-	{
-		if( srcRegister == REG_RAX )
-		{
-			// special EAX short form
-			x64Gen_writeU8(x64GenContext, 0x15);
-		}
-		else
-		{
-			x64Gen_writeU8(x64GenContext, 0x81);
-			x64Gen_writeU8(x64GenContext, 0xD0+(srcRegister&7));
-		}
-		x64Gen_writeU32(x64GenContext, immU32);
-	}
-}
-
 void x64Gen_dec_mem32(x64GenContext_t* x64GenContext, sint32 memoryRegister, uint32 memoryImmU32)
 {
 	// DEC dword [<reg64>+imm]
 	sint32 memoryImmS32 = (sint32)memoryImmU32;
-	if (memoryRegister != REG_RSP)
+	if (memoryRegister != X86_REG_RSP)
 		assert_dbg(); // not supported yet
 	if (memoryImmS32 >= -128 && memoryImmS32 <= 127)
 	{
@@ -981,7 +863,7 @@ void x64Gen_and_reg64Low32_imm32(x64GenContext_t* x64GenContext, sint32 srcRegis
 	}
 	else
 	{
-		if( srcRegister == REG_RAX )
+		if( srcRegister == X86_REG_RAX )
 		{
 			// special EAX short form
 			x64Gen_writeU8(x64GenContext, 0x25);
@@ -1026,7 +908,7 @@ void x64Gen_test_reg64Low32_imm32(x64GenContext_t* x64GenContext, sint32 srcRegi
 	sint32 immS32 = (sint32)immU32;
 	if( srcRegister >= 8 )
 		x64Gen_writeU8(x64GenContext, 0x41);
-	if( srcRegister == REG_RAX )
+	if( srcRegister == X86_REG_RAX )
 	{
 		// special EAX short form
 		x64Gen_writeU8(x64GenContext, 0xA9);
@@ -1052,7 +934,7 @@ void x64Gen_cmp_reg64Low32_imm32(x64GenContext_t* x64GenContext, sint32 srcRegis
 	}
 	else
 	{
-		if( srcRegister == REG_RAX )
+		if( srcRegister == X86_REG_RAX )
 		{
 			// special RAX short form
 			x64Gen_writeU8(x64GenContext, 0x3D);
@@ -1082,7 +964,7 @@ void x64Gen_cmp_reg64Low32_reg64Low32(x64GenContext_t* x64GenContext, sint32 des
 void x64Gen_cmp_reg64Low32_mem32reg64(x64GenContext_t* x64GenContext, sint32 destRegister, sint32 memRegister, sint32 memImmS32)
 {
 	// CMP <destReg64_lowDWORD>, DWORD [<memRegister>+<immS32>]
-	if( memRegister == REG_RSP )
+	if( memRegister == X86_REG_RSP )
 	{
 		if( memImmS32 >= -128 && memImmS32 <= 127 )
 			assert_dbg(); // todo -> Shorter instruction form
@@ -1112,7 +994,7 @@ void x64Gen_or_reg64Low32_imm32(x64GenContext_t* x64GenContext, sint32 srcRegist
 	}
 	else
 	{
-		if( srcRegister == REG_RAX )
+		if( srcRegister == X86_REG_RAX )
 		{
 			// special EAX short form
 			x64Gen_writeU8(x64GenContext, 0x0D);
@@ -1172,7 +1054,7 @@ void x64Gen_xor_reg64Low32_imm32(x64GenContext_t* x64GenContext, sint32 srcRegis
 	}
 	else
 	{
-		if( srcRegister == REG_RAX )
+		if( srcRegister == X86_REG_RAX )
 		{
 			// special EAX short form
 			x64Gen_writeU8(x64GenContext, 0x35);
@@ -1326,16 +1208,6 @@ void x64Gen_cdq(x64GenContext_t* x64GenContext)
 	x64Gen_writeU8(x64GenContext, 0x99);
 }
 
-void x64Gen_bswap_reg64(x64GenContext_t* x64GenContext, sint32 destRegister)
-{
-	if( destRegister >= 8 )
-		x64Gen_writeU8(x64GenContext, 0x41|8);
-	else
-		x64Gen_writeU8(x64GenContext, 0x40|8);
-	x64Gen_writeU8(x64GenContext, 0x0F);
-	x64Gen_writeU8(x64GenContext, 0xC8+(destRegister&7));
-}
-
 void x64Gen_bswap_reg64Lower32bit(x64GenContext_t* x64GenContext, sint32 destRegister)
 {
 	if( destRegister >= 8 )
@@ -1344,16 +1216,6 @@ void x64Gen_bswap_reg64Lower32bit(x64GenContext_t* x64GenContext, sint32 destReg
 	x64Gen_writeU8(x64GenContext, 0xC8+(destRegister&7));
 }
 
-void x64Gen_bswap_reg64Lower16bit(x64GenContext_t* x64GenContext, sint32 destRegister)
-{
-	assert_dbg(); // do not use this instruction, it's result is always undefined. Instead use ROL <reg16>, 8
-	//x64Gen_writeU8(x64GenContext, 0x66);
-	//if( destRegister >= 8 )
-	//	x64Gen_writeU8(x64GenContext, 0x41);
-	//x64Gen_writeU8(x64GenContext, 0x0F);
-	//x64Gen_writeU8(x64GenContext, 0xC8+(destRegister&7));
-}
-
 void x64Gen_lzcnt_reg64Low32_reg64Low32(x64GenContext_t* x64GenContext, sint32 destRegister, sint32 srcRegister)
 {
 	// SSE4
@@ -1388,7 +1250,7 @@ void x64Gen_setcc_mem8(x64GenContext_t* x64GenContext, sint32 conditionType, sin
 {
 	// SETcc [<reg64>+imm]
 	sint32 memoryImmS32 = (sint32)memoryImmU32;
-	if( memoryRegister != REG_RSP )
+	if( memoryRegister != X86_REG_RSP )
 		assert_dbg(); // not supported
 	if( memoryRegister >= 8 )
 		assert_dbg(); // not supported
@@ -1627,7 +1489,7 @@ void x64Gen_bt_mem8(x64GenContext_t* x64GenContext, sint32 memoryRegister, uint3
 {
 	// BT [<reg64>+imm], bitIndex	(bit test)
 	sint32 memoryImmS32 = (sint32)memoryImmU32;
-	if( memoryRegister != REG_RSP )
+	if( memoryRegister != X86_REG_RSP )
 		assert_dbg(); // not supported yet
 	if( memoryImmS32 >= -128 && memoryImmS32 <= 127 )
 	{
@@ -1662,7 +1524,7 @@ void x64Gen_jmp_imm32(x64GenContext_t* x64GenContext, uint32 destImm32)
 
 void x64Gen_jmp_memReg64(x64GenContext_t* x64GenContext, sint32 memRegister, uint32 immU32)
 {
-	if( memRegister == REG_NONE )
+	if( memRegister == X86_REG_NONE )
 	{
 		assert_dbg();
 	}
diff --git a/src/Cafe/HW/Espresso/Recompiler/PPCRecompilerX64GenFPU.cpp b/src/Cafe/HW/Espresso/Recompiler/BackendX64/BackendX64GenFPU.cpp
similarity index 92%
rename from src/Cafe/HW/Espresso/Recompiler/PPCRecompilerX64GenFPU.cpp
rename to src/Cafe/HW/Espresso/Recompiler/BackendX64/BackendX64GenFPU.cpp
index 92289d68..4bbcc025 100644
--- a/src/Cafe/HW/Espresso/Recompiler/PPCRecompilerX64GenFPU.cpp
+++ b/src/Cafe/HW/Espresso/Recompiler/BackendX64/BackendX64GenFPU.cpp
@@ -1,6 +1,4 @@
-#include "PPCRecompiler.h"
-#include "PPCRecompilerIml.h"
-#include "PPCRecompilerX64.h"
+#include "BackendX64.h"
 
 void x64Gen_genSSEVEXPrefix2(x64GenContext_t* x64GenContext, sint32 xmmRegister1, sint32 xmmRegister2, bool use64BitMode)
 {
@@ -44,7 +42,7 @@ void x64Gen_movupd_xmmReg_memReg128(x64GenContext_t* x64GenContext, sint32 xmmRe
 	// SSE2
 	// move two doubles from memory into xmm register
 	// MOVUPD <xmm>, [<reg>+<imm>]
-	if( memRegister == REG_ESP )
+	if( memRegister == X86_REG_ESP )
 	{
 		// todo: Short form of instruction if memImmU32 is 0 or in -128 to 127 range
 		// 66 0F 10 84 E4 23 01 00 00
@@ -56,7 +54,7 @@ void x64Gen_movupd_xmmReg_memReg128(x64GenContext_t* x64GenContext, sint32 xmmRe
 		x64Gen_writeU8(x64GenContext, 0xE4);
 		x64Gen_writeU32(x64GenContext, memImmU32);
 	}
-	else if( memRegister == REG_NONE )
+	else if( memRegister == X86_REG_NONE )
 	{
 		assert_dbg();
 		//x64Gen_writeU8(x64GenContext, 0x66);
@@ -76,7 +74,7 @@ void x64Gen_movupd_memReg128_xmmReg(x64GenContext_t* x64GenContext, sint32 xmmRe
 	// SSE2
 	// move two doubles from memory into xmm register
 	// MOVUPD [<reg>+<imm>], <xmm>
-	if( memRegister == REG_ESP )
+	if( memRegister == X86_REG_ESP )
 	{
 		// todo: Short form of instruction if memImmU32 is 0 or in -128 to 127 range
 		x64Gen_writeU8(x64GenContext, 0x66);
@@ -87,7 +85,7 @@ void x64Gen_movupd_memReg128_xmmReg(x64GenContext_t* x64GenContext, sint32 xmmRe
 		x64Gen_writeU8(x64GenContext, 0xE4);
 		x64Gen_writeU32(x64GenContext, memImmU32);
 	}
-	else if( memRegister == REG_NONE )
+	else if( memRegister == X86_REG_NONE )
 	{
 		assert_dbg();
 		//x64Gen_writeU8(x64GenContext, 0x66);
@@ -106,7 +104,7 @@ void x64Gen_movddup_xmmReg_memReg64(x64GenContext_t* x64GenContext, sint32 xmmRe
 {
 	// SSE3
 	// move one double from memory into lower and upper half of a xmm register
-	if( memRegister == REG_RSP )
+	if( memRegister == X86_REG_RSP )
 	{
 		// MOVDDUP <xmm>, [<reg>+<imm>]
 		// todo: Short form of instruction if memImmU32 is 0 or in -128 to 127 range
@@ -119,7 +117,7 @@ void x64Gen_movddup_xmmReg_memReg64(x64GenContext_t* x64GenContext, sint32 xmmRe
 		x64Gen_writeU8(x64GenContext, 0xE4);
 		x64Gen_writeU32(x64GenContext, memImmU32);
 	}
-	else if( memRegister == REG_R15 )
+	else if( memRegister == X86_REG_R15 )
 	{
 		// MOVDDUP <xmm>, [<reg>+<imm>]
 		// todo: Short form of instruction if memImmU32 is 0 or in -128 to 127 range
@@ -131,7 +129,7 @@ void x64Gen_movddup_xmmReg_memReg64(x64GenContext_t* x64GenContext, sint32 xmmRe
 		x64Gen_writeU8(x64GenContext, 0x87+(xmmRegister&7)*8);
 		x64Gen_writeU32(x64GenContext, memImmU32);
 	}
-	else if( memRegister == REG_NONE )
+	else if( memRegister == X86_REG_NONE )
 	{
 		// MOVDDUP <xmm>, [<imm>]
 		// 36 F2 0F 12 05 - 00 00 00 00
@@ -185,7 +183,7 @@ void x64Gen_movsd_memReg64_xmmReg(x64GenContext_t* x64GenContext, sint32 xmmRegi
 {
 	// SSE2
 	// move lower 64bits (double) of xmm register to memory location
-	if( memRegister == REG_NONE )
+	if( memRegister == X86_REG_NONE )
 	{
 		// MOVSD [<imm>], <xmm>
 		// F2 0F 11 05 - 45 23 01 00
@@ -197,7 +195,7 @@ void x64Gen_movsd_memReg64_xmmReg(x64GenContext_t* x64GenContext, sint32 xmmRegi
 		//x64Gen_writeU8(x64GenContext, 0x05+xmmRegister*8);
 		//x64Gen_writeU32(x64GenContext, memImmU32);
 	}
-	else if( memRegister == REG_RSP )
+	else if( memRegister == X86_REG_RSP )
 	{
 		// MOVSD [RSP+<imm>], <xmm>
 		// F2 0F 11 84 24 - 33 22 11 00
@@ -215,11 +213,42 @@ void x64Gen_movsd_memReg64_xmmReg(x64GenContext_t* x64GenContext, sint32 xmmRegi
 	}
 }
 
+void x64Gen_movsd_xmmReg_memReg64(x64GenContext_t* x64GenContext, sint32 xmmRegister, sint32 memRegister, uint32 memImmU32)
+{
+	// SSE2
+	if( memRegister == X86_REG_RSP )
+	{
+		// MOVSD <xmm>, [RSP+<imm>]
+		x64Gen_writeU8(x64GenContext, 0xF2);
+		x64Gen_genSSEVEXPrefix2(x64GenContext, 0, xmmRegister, false);
+		x64Gen_writeU8(x64GenContext, 0x0F);
+		x64Gen_writeU8(x64GenContext, 0x10);
+		x64Gen_writeU8(x64GenContext, 0x84+(xmmRegister&7)*8);
+		x64Gen_writeU8(x64GenContext, 0x24);
+		x64Gen_writeU32(x64GenContext, memImmU32);
+	}
+	else if( memRegister == 15 )
+	{
+		// MOVSD <xmm>, [R15+<imm>]
+		x64Gen_writeU8(x64GenContext, 0x36);
+		x64Gen_writeU8(x64GenContext, 0xF2);
+		x64Gen_genSSEVEXPrefix2(x64GenContext, memRegister, xmmRegister, false);
+		x64Gen_writeU8(x64GenContext, 0x0F);
+		x64Gen_writeU8(x64GenContext, 0x10);
+		x64Gen_writeU8(x64GenContext, 0x87+(xmmRegister&7)*8);
+		x64Gen_writeU32(x64GenContext, memImmU32);
+	}
+	else
+	{
+		assert_dbg();
+	}
+}
+
 void x64Gen_movlpd_xmmReg_memReg64(x64GenContext_t* x64GenContext, sint32 xmmRegister, sint32 memRegister, uint32 memImmU32)
 {
 	// SSE3
 	// move one double from memory into lower half of a xmm register, leave upper half unchanged(?)
-	if( memRegister == REG_NONE )
+	if( memRegister == X86_REG_NONE )
 	{
 		// MOVLPD <xmm>, [<imm>]
 		//x64Gen_writeU8(x64GenContext, 0x66);
@@ -229,7 +258,7 @@ void x64Gen_movlpd_xmmReg_memReg64(x64GenContext_t* x64GenContext, sint32 xmmReg
 		//x64Gen_writeU32(x64GenContext, memImmU32);
 		assert_dbg();
 	}
-	else if( memRegister == REG_RSP )
+	else if( memRegister == X86_REG_RSP )
 	{
 		// MOVLPD <xmm>, [<reg64>+<imm>]
 		// 66 0F 12 84 24 - 33 22 11 00
@@ -348,11 +377,11 @@ void x64Gen_mulpd_xmmReg_xmmReg(x64GenContext_t* x64GenContext, sint32 xmmRegist
 void x64Gen_mulpd_xmmReg_memReg128(x64GenContext_t* x64GenContext, sint32 xmmRegister, sint32 memRegister, uint32 memImmU32)
 {
 	// SSE2
-	if (memRegister == REG_NONE)
+	if (memRegister == X86_REG_NONE)
 	{
 		assert_dbg();
 	}
-	else if (memRegister == REG_R14)
+	else if (memRegister == X86_REG_R14)
 	{
 		x64Gen_writeU8(x64GenContext, 0x66);
 		x64Gen_writeU8(x64GenContext, (xmmRegister < 8) ? 0x41 : 0x45);
@@ -404,7 +433,7 @@ void x64Gen_comisd_xmmReg_mem64Reg64(x64GenContext_t* x64GenContext, sint32 xmmR
 {
 	// SSE2
 	// compare bottom double with double from memory location
-	if( memoryReg == REG_R15 )
+	if( memoryReg == X86_REG_R15 )
 	{
 		x64Gen_writeU8(x64GenContext, 0x66);
 		x64Gen_genSSEVEXPrefix1(x64GenContext, xmmRegisterDest, true);
@@ -432,7 +461,7 @@ void x64Gen_comiss_xmmReg_mem64Reg64(x64GenContext_t* x64GenContext, sint32 xmmR
 {
 	// SSE2
 	// compare bottom float with float from memory location
-	if (memoryReg == REG_R15)
+	if (memoryReg == X86_REG_R15)
 	{
 		x64Gen_genSSEVEXPrefix1(x64GenContext, xmmRegisterDest, true);
 		x64Gen_writeU8(x64GenContext, 0x0F);
@@ -448,7 +477,7 @@ void x64Gen_orps_xmmReg_mem128Reg64(x64GenContext_t* x64GenContext, sint32 xmmRe
 {
 	// SSE2
 	// and xmm register with 128 bit value from memory
-	if( memReg == REG_R15 )
+	if( memReg == X86_REG_R15 )
 	{
 		x64Gen_genSSEVEXPrefix2(x64GenContext, memReg, xmmRegisterDest, false);
 		x64Gen_writeU8(x64GenContext, 0x0F);
@@ -464,7 +493,7 @@ void x64Gen_xorps_xmmReg_mem128Reg64(x64GenContext_t* x64GenContext, sint32 xmmR
 {
 	// SSE2
 	// xor xmm register with 128 bit value from memory
-	if( memReg == REG_R15 )
+	if( memReg == X86_REG_R15 )
 	{
 		x64Gen_genSSEVEXPrefix1(x64GenContext, xmmRegisterDest, true); // todo: should be x64Gen_genSSEVEXPrefix2() with memReg?
 		x64Gen_writeU8(x64GenContext, 0x0F);
@@ -479,11 +508,11 @@ void x64Gen_xorps_xmmReg_mem128Reg64(x64GenContext_t* x64GenContext, sint32 xmmR
 void x64Gen_andpd_xmmReg_memReg128(x64GenContext_t* x64GenContext, sint32 xmmRegister, sint32 memRegister, uint32 memImmU32)
 {
 	// SSE2
-	if (memRegister == REG_NONE)
+	if (memRegister == X86_REG_NONE)
 	{
 		assert_dbg();
 	}
-	else if (memRegister == REG_R14)
+	else if (memRegister == X86_REG_R14)
 	{
 		x64Gen_writeU8(x64GenContext, 0x66);
 		x64Gen_writeU8(x64GenContext, (xmmRegister < 8) ? 0x41 : 0x45);
@@ -502,7 +531,7 @@ void x64Gen_andps_xmmReg_mem128Reg64(x64GenContext_t* x64GenContext, sint32 xmmR
 {
 	// SSE2
 	// and xmm register with 128 bit value from memory
-	if( memReg == REG_R15 )
+	if( memReg == X86_REG_R15 )
 	{
 		x64Gen_genSSEVEXPrefix1(x64GenContext, xmmRegisterDest, true); // todo: should be x64Gen_genSSEVEXPrefix2() with memReg?
 		x64Gen_writeU8(x64GenContext, 0x0F);
@@ -528,7 +557,7 @@ void x64Gen_pcmpeqd_xmmReg_mem128Reg64(x64GenContext_t* x64GenContext, sint32 xm
 {
 	// SSE2
 	// doubleword integer compare
-	if( memReg == REG_R15 )
+	if( memReg == X86_REG_R15 )
 	{
 		x64Gen_writeU8(x64GenContext, 0x66);
 		x64Gen_genSSEVEXPrefix1(x64GenContext, xmmRegisterDest, true);
@@ -563,6 +592,16 @@ void x64Gen_cvttsd2si_xmmReg_xmmReg(x64GenContext_t* x64GenContext, sint32 regis
 	x64Gen_writeU8(x64GenContext, 0xC0+(registerDest&7)*8+(xmmRegisterSrc&7));
 }
 
+void x64Gen_cvtsi2sd_xmmReg_xmmReg(x64GenContext_t* x64GenContext, sint32 xmmRegisterDest, sint32 registerSrc)
+{
+	// SSE2
+	x64Gen_writeU8(x64GenContext, 0xF2);
+	x64Gen_genSSEVEXPrefix2(x64GenContext, registerSrc, xmmRegisterDest, false);
+	x64Gen_writeU8(x64GenContext, 0x0F);
+	x64Gen_writeU8(x64GenContext, 0x2A);
+	x64Gen_writeU8(x64GenContext, 0xC0+(xmmRegisterDest&7)*8+(registerSrc&7));
+}
+
 void x64Gen_cvtsd2ss_xmmReg_xmmReg(x64GenContext_t* x64GenContext, sint32 xmmRegisterDest, sint32 xmmRegisterSrc)
 {
 	// SSE2
@@ -610,7 +649,7 @@ void x64Gen_cvtpi2pd_xmmReg_mem64Reg64(x64GenContext_t* x64GenContext, sint32 xm
 {
 	// SSE2
 	// converts two signed 32bit integers to two doubles
-	if( memReg == REG_RSP )
+	if( memReg == X86_REG_RSP )
 	{
 		x64Gen_writeU8(x64GenContext, 0x66);
 		x64Gen_genSSEVEXPrefix1(x64GenContext, xmmRegisterDest, false);
@@ -684,7 +723,7 @@ void x64Gen_rcpss_xmmReg_xmmReg(x64GenContext_t* x64GenContext, sint32 xmmRegist
 void x64Gen_mulss_xmmReg_memReg64(x64GenContext_t* x64GenContext, sint32 xmmRegister, sint32 memRegister, uint32 memImmU32)
 {
 	// SSE2
-	if( memRegister == REG_NONE )
+	if( memRegister == X86_REG_NONE )
 	{
 		assert_dbg();
 	}
diff --git a/src/Cafe/HW/Espresso/Recompiler/x64Emit.hpp b/src/Cafe/HW/Espresso/Recompiler/BackendX64/X64Emit.hpp
similarity index 99%
rename from src/Cafe/HW/Espresso/Recompiler/x64Emit.hpp
rename to src/Cafe/HW/Espresso/Recompiler/BackendX64/X64Emit.hpp
index e936f1d8..b4021931 100644
--- a/src/Cafe/HW/Espresso/Recompiler/x64Emit.hpp
+++ b/src/Cafe/HW/Espresso/Recompiler/BackendX64/X64Emit.hpp
@@ -203,7 +203,6 @@ template<class opcodeBytes, typename TA, typename TB>
 void _x64Gen_writeMODRM_internal(x64GenContext_t* x64GenContext, TA opA, TB opB)
 {
 	static_assert(TA::getType() == MODRM_OPR_TYPE::REG);
-	x64Gen_checkBuffer(x64GenContext);
 	// REX prefix
 	// 0100 WRXB
 	if constexpr (TA::getType() == MODRM_OPR_TYPE::REG && TB::getType() == MODRM_OPR_TYPE::REG)
diff --git a/src/Cafe/HW/Espresso/Recompiler/BackendX64/x86Emitter.h b/src/Cafe/HW/Espresso/Recompiler/BackendX64/x86Emitter.h
new file mode 100644
index 00000000..eae3835d
--- /dev/null
+++ b/src/Cafe/HW/Espresso/Recompiler/BackendX64/x86Emitter.h
@@ -0,0 +1,4335 @@
+#pragma once
+
+// x86-64 assembler/emitter
+// auto generated. Do not edit this file manually
+
+typedef unsigned long long u64;
+typedef unsigned int u32;
+typedef unsigned short u16;
+typedef unsigned char u8;
+typedef signed long long s64;
+typedef signed int s32;
+typedef signed short s16;
+typedef signed char s8;
+
+enum X86Reg : sint8
+{
+	X86_REG_NONE = -1,
+	X86_REG_EAX = 0,
+	X86_REG_ECX = 1,
+	X86_REG_EDX = 2,
+	X86_REG_EBX = 3,
+	X86_REG_ESP = 4,
+	X86_REG_EBP = 5,
+	X86_REG_ESI = 6,
+	X86_REG_EDI = 7,
+	X86_REG_R8D = 8,
+	X86_REG_R9D = 9,
+	X86_REG_R10D = 10,
+	X86_REG_R11D = 11,
+	X86_REG_R12D = 12,
+	X86_REG_R13D = 13,
+	X86_REG_R14D = 14,
+	X86_REG_R15D = 15,
+	X86_REG_RAX = 0,
+	X86_REG_RCX = 1,
+	X86_REG_RDX = 2,
+	X86_REG_RBX = 3,
+	X86_REG_RSP = 4,
+	X86_REG_RBP = 5,
+	X86_REG_RSI = 6,
+	X86_REG_RDI = 7,
+	X86_REG_R8 = 8,
+	X86_REG_R9 = 9,
+	X86_REG_R10 = 10,
+	X86_REG_R11 = 11,
+	X86_REG_R12 = 12,
+	X86_REG_R13 = 13,
+	X86_REG_R14 = 14,
+	X86_REG_R15 = 15
+};
+
+enum X86Cond : u8
+{
+	X86_CONDITION_O = 0,
+	X86_CONDITION_NO = 1,
+	X86_CONDITION_B = 2,
+	X86_CONDITION_NB = 3,
+	X86_CONDITION_Z = 4,
+	X86_CONDITION_NZ = 5,
+	X86_CONDITION_BE = 6,
+	X86_CONDITION_NBE = 7,
+	X86_CONDITION_S = 8,
+	X86_CONDITION_NS = 9,
+	X86_CONDITION_PE = 10,
+	X86_CONDITION_PO = 11,
+	X86_CONDITION_L = 12,
+	X86_CONDITION_NL = 13,
+	X86_CONDITION_LE = 14,
+	X86_CONDITION_NLE = 15
+};
+class x86Assembler64
+{
+private:
+	std::vector<u8> m_buffer;
+
+public:
+	u8* GetBufferPtr() { return m_buffer.data(); };
+	std::span<u8> GetBuffer() { return m_buffer; };
+	u32 GetWriteIndex() { return (u32)m_buffer.size(); };
+	void _emitU8(u8 v) { m_buffer.emplace_back(v); };
+	void _emitU16(u16 v) { size_t writeIdx = m_buffer.size(); m_buffer.resize(writeIdx + 2); *(u16*)(m_buffer.data() + writeIdx) = v; };
+	void _emitU32(u32 v) { size_t writeIdx = m_buffer.size(); m_buffer.resize(writeIdx + 4); *(u32*)(m_buffer.data() + writeIdx) = v; };
+	void _emitU64(u64 v) { size_t writeIdx = m_buffer.size(); m_buffer.resize(writeIdx + 8); *(u64*)(m_buffer.data() + writeIdx) = v; };
+	using GPR64 = X86Reg;
+	using GPR32 = X86Reg;
+	using GPR8_REX = X86Reg;
+	void LockPrefix() { _emitU8(0xF0); };
+	void ADD_bb(GPR8_REX dst, GPR8_REX src)
+	{
+		if ((src >= 4) || (dst >= 4))
+		{
+			_emitU8(0x40 | ((dst & 8) >> 3) | ((src & 8) >> 1));
+		}
+		_emitU8(0x00);
+		_emitU8((3 << 6) | ((src & 7) << 3) | (dst & 7));
+	}
+	void ADD_bb_l(GPR64 memReg, sint32 offset, GPR64 index, uint8 scaler, GPR8_REX src)
+	{
+		uint8 mod;
+		if (offset == 0 && (memReg & 7) != 5) mod = 0;
+		else if (offset == (s32)(s8)offset) mod = 1;
+		else mod = 2;
+		bool sib_use = (scaler != 0 && index != X86_REG_NONE);
+		if ((memReg & 7) == 4)
+		{
+			cemu_assert_debug(index == X86_REG_NONE);
+			index = memReg;
+			sib_use = true;
+		}
+		if (sib_use)
+		{
+			if ((src >= 4) || (memReg & 8) || ((index != X86_REG_NONE) && (index & 8)))
+				_emitU8(0x40 | ((src & 8) >> 1) | ((memReg & 8) >> 3) | ((index & 8) >> 2));
+		}
+		else
+		{
+			if ((src >= 4) || (memReg & 8))
+				_emitU8(0x40 | ((src & 8) >> 1) | ((memReg & 8) >> 1));
+		}
+		_emitU8(0x00);
+		_emitU8((mod << 6) | ((src & 7) << 3) | (sib_use ? 4 : (memReg & 7)));
+		if (sib_use)
+		{
+			_emitU8((0 << 6) | ((memReg & 7)) | ((index & 7) << 3));
+		}
+		if (mod == 1) _emitU8((u8)offset);
+		else if (mod == 2) _emitU32((u32)offset);
+	}
+	void ADD_bb_r(GPR8_REX dst, GPR64 memReg, sint32 offset, GPR64 index, uint8 scaler)
+	{
+		uint8 mod;
+		if (offset == 0 && (memReg & 7) != 5) mod = 0;
+		else if (offset == (s32)(s8)offset) mod = 1;
+		else mod = 2;
+		bool sib_use = (scaler != 0 && index != X86_REG_NONE);
+		if ((memReg & 7) == 4)
+		{
+			cemu_assert_debug(index == X86_REG_NONE);
+			index = memReg;
+			sib_use = true;
+		}
+		if (sib_use)
+		{
+			if ((dst >= 4) || (memReg & 8) || ((index != X86_REG_NONE) && (index & 8)))
+				_emitU8(0x40 | ((dst & 8) >> 1) | ((memReg & 8) >> 3) | ((index & 8) >> 2));
+		}
+		else
+		{
+			if ((dst >= 4) || (memReg & 8))
+				_emitU8(0x40 | ((dst & 8) >> 1) | ((memReg & 8) >> 1));
+		}
+		_emitU8(0x02);
+		_emitU8((mod << 6) | ((dst & 7) << 3) | (sib_use ? 4 : (memReg & 7)));
+		if (sib_use)
+		{
+			_emitU8((0 << 6) | ((memReg & 7)) | ((index & 7) << 3));
+		}
+		if (mod == 1) _emitU8((u8)offset);
+		else if (mod == 2) _emitU32((u32)offset);
+	}
+	void ADD_dd(GPR32 dst, GPR32 src)
+	{
+		if (((src & 8) != 0) || ((dst & 8) != 0))
+		{
+			_emitU8(0x40 | ((dst & 8) >> 3) | ((src & 8) >> 1));
+		}
+		_emitU8(0x01);
+		_emitU8((3 << 6) | ((src & 7) << 3) | (dst & 7));
+	}
+	void ADD_qq(GPR64 dst, GPR64 src)
+	{
+		_emitU8(0x48 | ((dst & 8) >> 3) | ((src & 8) >> 1));
+		_emitU8(0x01);
+		_emitU8((3 << 6) | ((src & 7) << 3) | (dst & 7));
+	}
+	void ADD_dd_l(GPR64 memReg, sint32 offset, GPR64 index, uint8 scaler, GPR32 src)
+	{
+		uint8 mod;
+		if (offset == 0 && (memReg & 7) != 5) mod = 0;
+		else if (offset == (s32)(s8)offset) mod = 1;
+		else mod = 2;
+		bool sib_use = (scaler != 0 && index != X86_REG_NONE);
+		if ((memReg & 7) == 4)
+		{
+			cemu_assert_debug(index == X86_REG_NONE);
+			index = memReg;
+			sib_use = true;
+		}
+		if (sib_use)
+		{
+			if ((src & 8) || (memReg & 8) || ((index != X86_REG_NONE) && (index & 8)))
+				_emitU8(0x40 | ((src & 8) >> 1) | ((memReg & 8) >> 3) | ((index & 8) >> 2));
+		}
+		else
+		{
+			if ((src & 8) || (memReg & 8))
+				_emitU8(0x40 | ((src & 8) >> 1) | ((memReg & 8) >> 1));
+		}
+		_emitU8(0x01);
+		_emitU8((mod << 6) | ((src & 7) << 3) | (sib_use ? 4 : (memReg & 7)));
+		if (sib_use)
+		{
+			_emitU8((0 << 6) | ((memReg & 7)) | ((index & 7) << 3));
+		}
+		if (mod == 1) _emitU8((u8)offset);
+		else if (mod == 2) _emitU32((u32)offset);
+	}
+	void ADD_qq_l(GPR64 memReg, sint32 offset, GPR64 index, uint8 scaler, GPR64 src)
+	{
+		uint8 mod;
+		if (offset == 0 && (memReg & 7) != 5) mod = 0;
+		else if (offset == (s32)(s8)offset) mod = 1;
+		else mod = 2;
+		bool sib_use = (scaler != 0 && index != X86_REG_NONE);
+		if ((memReg & 7) == 4)
+		{
+			cemu_assert_debug(index == X86_REG_NONE);
+			index = memReg;
+			sib_use = true;
+		}
+		if (sib_use)
+		{
+			_emitU8(0x40 | ((src & 8) >> 1) | ((memReg & 8) >> 3) | ((index & 8) >> 2) | 0x08);
+		}
+		else
+		{
+			_emitU8(0x40 | ((src & 8) >> 1) | ((memReg & 8) >> 1) | 0x08);
+		}
+		_emitU8(0x01);
+		_emitU8((mod << 6) | ((src & 7) << 3) | (sib_use ? 4 : (memReg & 7)));
+		if (sib_use)
+		{
+			_emitU8((0 << 6) | ((memReg & 7)) | ((index & 7) << 3));
+		}
+		if (mod == 1) _emitU8((u8)offset);
+		else if (mod == 2) _emitU32((u32)offset);
+	}
+	void ADD_dd_r(GPR32 dst, GPR64 memReg, sint32 offset, GPR64 index, uint8 scaler)
+	{
+		uint8 mod;
+		if (offset == 0 && (memReg & 7) != 5) mod = 0;
+		else if (offset == (s32)(s8)offset) mod = 1;
+		else mod = 2;
+		bool sib_use = (scaler != 0 && index != X86_REG_NONE);
+		if ((memReg & 7) == 4)
+		{
+			cemu_assert_debug(index == X86_REG_NONE);
+			index = memReg;
+			sib_use = true;
+		}
+		if (sib_use)
+		{
+			if ((dst & 8) || (memReg & 8) || ((index != X86_REG_NONE) && (index & 8)))
+				_emitU8(0x40 | ((dst & 8) >> 1) | ((memReg & 8) >> 3) | ((index & 8) >> 2));
+		}
+		else
+		{
+			if ((dst & 8) || (memReg & 8))
+				_emitU8(0x40 | ((dst & 8) >> 1) | ((memReg & 8) >> 1));
+		}
+		_emitU8(0x03);
+		_emitU8((mod << 6) | ((dst & 7) << 3) | (sib_use ? 4 : (memReg & 7)));
+		if (sib_use)
+		{
+			_emitU8((0 << 6) | ((memReg & 7)) | ((index & 7) << 3));
+		}
+		if (mod == 1) _emitU8((u8)offset);
+		else if (mod == 2) _emitU32((u32)offset);
+	}
+	void ADD_qq_r(GPR64 dst, GPR64 memReg, sint32 offset, GPR64 index, uint8 scaler)
+	{
+		uint8 mod;
+		if (offset == 0 && (memReg & 7) != 5) mod = 0;
+		else if (offset == (s32)(s8)offset) mod = 1;
+		else mod = 2;
+		bool sib_use = (scaler != 0 && index != X86_REG_NONE);
+		if ((memReg & 7) == 4)
+		{
+			cemu_assert_debug(index == X86_REG_NONE);
+			index = memReg;
+			sib_use = true;
+		}
+		if (sib_use)
+		{
+			_emitU8(0x40 | ((dst & 8) >> 1) | ((memReg & 8) >> 3) | ((index & 8) >> 2) | 0x08);
+		}
+		else
+		{
+			_emitU8(0x40 | ((dst & 8) >> 1) | ((memReg & 8) >> 1) | 0x08);
+		}
+		_emitU8(0x03);
+		_emitU8((mod << 6) | ((dst & 7) << 3) | (sib_use ? 4 : (memReg & 7)));
+		if (sib_use)
+		{
+			_emitU8((0 << 6) | ((memReg & 7)) | ((index & 7) << 3));
+		}
+		if (mod == 1) _emitU8((u8)offset);
+		else if (mod == 2) _emitU32((u32)offset);
+	}
+	void OR_bb(GPR8_REX dst, GPR8_REX src)
+	{
+		if ((src >= 4) || (dst >= 4))
+		{
+			_emitU8(0x40 | ((dst & 8) >> 3) | ((src & 8) >> 1));
+		}
+		_emitU8(0x08);
+		_emitU8((3 << 6) | ((src & 7) << 3) | (dst & 7));
+	}
+	void OR_bb_l(GPR64 memReg, sint32 offset, GPR64 index, uint8 scaler, GPR8_REX src)
+	{
+		uint8 mod;
+		if (offset == 0 && (memReg & 7) != 5) mod = 0;
+		else if (offset == (s32)(s8)offset) mod = 1;
+		else mod = 2;
+		bool sib_use = (scaler != 0 && index != X86_REG_NONE);
+		if ((memReg & 7) == 4)
+		{
+			cemu_assert_debug(index == X86_REG_NONE);
+			index = memReg;
+			sib_use = true;
+		}
+		if (sib_use)
+		{
+			if ((src >= 4) || (memReg & 8) || ((index != X86_REG_NONE) && (index & 8)))
+				_emitU8(0x40 | ((src & 8) >> 1) | ((memReg & 8) >> 3) | ((index & 8) >> 2));
+		}
+		else
+		{
+			if ((src >= 4) || (memReg & 8))
+				_emitU8(0x40 | ((src & 8) >> 1) | ((memReg & 8) >> 1));
+		}
+		_emitU8(0x08);
+		_emitU8((mod << 6) | ((src & 7) << 3) | (sib_use ? 4 : (memReg & 7)));
+		if (sib_use)
+		{
+			_emitU8((0 << 6) | ((memReg & 7)) | ((index & 7) << 3));
+		}
+		if (mod == 1) _emitU8((u8)offset);
+		else if (mod == 2) _emitU32((u32)offset);
+	}
+	void OR_bb_r(GPR8_REX dst, GPR64 memReg, sint32 offset, GPR64 index, uint8 scaler)
+	{
+		uint8 mod;
+		if (offset == 0 && (memReg & 7) != 5) mod = 0;
+		else if (offset == (s32)(s8)offset) mod = 1;
+		else mod = 2;
+		bool sib_use = (scaler != 0 && index != X86_REG_NONE);
+		if ((memReg & 7) == 4)
+		{
+			cemu_assert_debug(index == X86_REG_NONE);
+			index = memReg;
+			sib_use = true;
+		}
+		if (sib_use)
+		{
+			if ((dst >= 4) || (memReg & 8) || ((index != X86_REG_NONE) && (index & 8)))
+				_emitU8(0x40 | ((dst & 8) >> 1) | ((memReg & 8) >> 3) | ((index & 8) >> 2));
+		}
+		else
+		{
+			if ((dst >= 4) || (memReg & 8))
+				_emitU8(0x40 | ((dst & 8) >> 1) | ((memReg & 8) >> 1));
+		}
+		_emitU8(0x0a);
+		_emitU8((mod << 6) | ((dst & 7) << 3) | (sib_use ? 4 : (memReg & 7)));
+		if (sib_use)
+		{
+			_emitU8((0 << 6) | ((memReg & 7)) | ((index & 7) << 3));
+		}
+		if (mod == 1) _emitU8((u8)offset);
+		else if (mod == 2) _emitU32((u32)offset);
+	}
+	void OR_dd(GPR32 dst, GPR32 src)
+	{
+		if (((src & 8) != 0) || ((dst & 8) != 0))
+		{
+			_emitU8(0x40 | ((dst & 8) >> 3) | ((src & 8) >> 1));
+		}
+		_emitU8(0x09);
+		_emitU8((3 << 6) | ((src & 7) << 3) | (dst & 7));
+	}
+	void OR_qq(GPR64 dst, GPR64 src)
+	{
+		_emitU8(0x48 | ((dst & 8) >> 3) | ((src & 8) >> 1));
+		_emitU8(0x09);
+		_emitU8((3 << 6) | ((src & 7) << 3) | (dst & 7));
+	}
+	void OR_dd_l(GPR64 memReg, sint32 offset, GPR64 index, uint8 scaler, GPR32 src)
+	{
+		uint8 mod;
+		if (offset == 0 && (memReg & 7) != 5) mod = 0;
+		else if (offset == (s32)(s8)offset) mod = 1;
+		else mod = 2;
+		bool sib_use = (scaler != 0 && index != X86_REG_NONE);
+		if ((memReg & 7) == 4)
+		{
+			cemu_assert_debug(index == X86_REG_NONE);
+			index = memReg;
+			sib_use = true;
+		}
+		if (sib_use)
+		{
+			if ((src & 8) || (memReg & 8) || ((index != X86_REG_NONE) && (index & 8)))
+				_emitU8(0x40 | ((src & 8) >> 1) | ((memReg & 8) >> 3) | ((index & 8) >> 2));
+		}
+		else
+		{
+			if ((src & 8) || (memReg & 8))
+				_emitU8(0x40 | ((src & 8) >> 1) | ((memReg & 8) >> 1));
+		}
+		_emitU8(0x09);
+		_emitU8((mod << 6) | ((src & 7) << 3) | (sib_use ? 4 : (memReg & 7)));
+		if (sib_use)
+		{
+			_emitU8((0 << 6) | ((memReg & 7)) | ((index & 7) << 3));
+		}
+		if (mod == 1) _emitU8((u8)offset);
+		else if (mod == 2) _emitU32((u32)offset);
+	}
+	void OR_qq_l(GPR64 memReg, sint32 offset, GPR64 index, uint8 scaler, GPR64 src)
+	{
+		uint8 mod;
+		if (offset == 0 && (memReg & 7) != 5) mod = 0;
+		else if (offset == (s32)(s8)offset) mod = 1;
+		else mod = 2;
+		bool sib_use = (scaler != 0 && index != X86_REG_NONE);
+		if ((memReg & 7) == 4)
+		{
+			cemu_assert_debug(index == X86_REG_NONE);
+			index = memReg;
+			sib_use = true;
+		}
+		if (sib_use)
+		{
+			_emitU8(0x40 | ((src & 8) >> 1) | ((memReg & 8) >> 3) | ((index & 8) >> 2) | 0x08);
+		}
+		else
+		{
+			_emitU8(0x40 | ((src & 8) >> 1) | ((memReg & 8) >> 1) | 0x08);
+		}
+		_emitU8(0x09);
+		_emitU8((mod << 6) | ((src & 7) << 3) | (sib_use ? 4 : (memReg & 7)));
+		if (sib_use)
+		{
+			_emitU8((0 << 6) | ((memReg & 7)) | ((index & 7) << 3));
+		}
+		if (mod == 1) _emitU8((u8)offset);
+		else if (mod == 2) _emitU32((u32)offset);
+	}
+	void OR_dd_r(GPR32 dst, GPR64 memReg, sint32 offset, GPR64 index, uint8 scaler)
+	{
+		uint8 mod;
+		if (offset == 0 && (memReg & 7) != 5) mod = 0;
+		else if (offset == (s32)(s8)offset) mod = 1;
+		else mod = 2;
+		bool sib_use = (scaler != 0 && index != X86_REG_NONE);
+		if ((memReg & 7) == 4)
+		{
+			cemu_assert_debug(index == X86_REG_NONE);
+			index = memReg;
+			sib_use = true;
+		}
+		if (sib_use)
+		{
+			if ((dst & 8) || (memReg & 8) || ((index != X86_REG_NONE) && (index & 8)))
+				_emitU8(0x40 | ((dst & 8) >> 1) | ((memReg & 8) >> 3) | ((index & 8) >> 2));
+		}
+		else
+		{
+			if ((dst & 8) || (memReg & 8))
+				_emitU8(0x40 | ((dst & 8) >> 1) | ((memReg & 8) >> 1));
+		}
+		_emitU8(0x0b);
+		_emitU8((mod << 6) | ((dst & 7) << 3) | (sib_use ? 4 : (memReg & 7)));
+		if (sib_use)
+		{
+			_emitU8((0 << 6) | ((memReg & 7)) | ((index & 7) << 3));
+		}
+		if (mod == 1) _emitU8((u8)offset);
+		else if (mod == 2) _emitU32((u32)offset);
+	}
+	void OR_qq_r(GPR64 dst, GPR64 memReg, sint32 offset, GPR64 index, uint8 scaler)
+	{
+		uint8 mod;
+		if (offset == 0 && (memReg & 7) != 5) mod = 0;
+		else if (offset == (s32)(s8)offset) mod = 1;
+		else mod = 2;
+		bool sib_use = (scaler != 0 && index != X86_REG_NONE);
+		if ((memReg & 7) == 4)
+		{
+			cemu_assert_debug(index == X86_REG_NONE);
+			index = memReg;
+			sib_use = true;
+		}
+		if (sib_use)
+		{
+			_emitU8(0x40 | ((dst & 8) >> 1) | ((memReg & 8) >> 3) | ((index & 8) >> 2) | 0x08);
+		}
+		else
+		{
+			_emitU8(0x40 | ((dst & 8) >> 1) | ((memReg & 8) >> 1) | 0x08);
+		}
+		_emitU8(0x0b);
+		_emitU8((mod << 6) | ((dst & 7) << 3) | (sib_use ? 4 : (memReg & 7)));
+		if (sib_use)
+		{
+			_emitU8((0 << 6) | ((memReg & 7)) | ((index & 7) << 3));
+		}
+		if (mod == 1) _emitU8((u8)offset);
+		else if (mod == 2) _emitU32((u32)offset);
+	}
+	void ADC_bb(GPR8_REX dst, GPR8_REX src)
+	{
+		if ((src >= 4) || (dst >= 4))
+		{
+			_emitU8(0x40 | ((dst & 8) >> 3) | ((src & 8) >> 1));
+		}
+		_emitU8(0x10);
+		_emitU8((3 << 6) | ((src & 7) << 3) | (dst & 7));
+	}
+	void ADC_bb_l(GPR64 memReg, sint32 offset, GPR64 index, uint8 scaler, GPR8_REX src)
+	{
+		uint8 mod;
+		if (offset == 0 && (memReg & 7) != 5) mod = 0;
+		else if (offset == (s32)(s8)offset) mod = 1;
+		else mod = 2;
+		bool sib_use = (scaler != 0 && index != X86_REG_NONE);
+		if ((memReg & 7) == 4)
+		{
+			cemu_assert_debug(index == X86_REG_NONE);
+			index = memReg;
+			sib_use = true;
+		}
+		if (sib_use)
+		{
+			if ((src >= 4) || (memReg & 8) || ((index != X86_REG_NONE) && (index & 8)))
+				_emitU8(0x40 | ((src & 8) >> 1) | ((memReg & 8) >> 3) | ((index & 8) >> 2));
+		}
+		else
+		{
+			if ((src >= 4) || (memReg & 8))
+				_emitU8(0x40 | ((src & 8) >> 1) | ((memReg & 8) >> 1));
+		}
+		_emitU8(0x10);
+		_emitU8((mod << 6) | ((src & 7) << 3) | (sib_use ? 4 : (memReg & 7)));
+		if (sib_use)
+		{
+			_emitU8((0 << 6) | ((memReg & 7)) | ((index & 7) << 3));
+		}
+		if (mod == 1) _emitU8((u8)offset);
+		else if (mod == 2) _emitU32((u32)offset);
+	}
+	void ADC_bb_r(GPR8_REX dst, GPR64 memReg, sint32 offset, GPR64 index, uint8 scaler)
+	{
+		uint8 mod;
+		if (offset == 0 && (memReg & 7) != 5) mod = 0;
+		else if (offset == (s32)(s8)offset) mod = 1;
+		else mod = 2;
+		bool sib_use = (scaler != 0 && index != X86_REG_NONE);
+		if ((memReg & 7) == 4)
+		{
+			cemu_assert_debug(index == X86_REG_NONE);
+			index = memReg;
+			sib_use = true;
+		}
+		if (sib_use)
+		{
+			if ((dst >= 4) || (memReg & 8) || ((index != X86_REG_NONE) && (index & 8)))
+				_emitU8(0x40 | ((dst & 8) >> 1) | ((memReg & 8) >> 3) | ((index & 8) >> 2));
+		}
+		else
+		{
+			if ((dst >= 4) || (memReg & 8))
+				_emitU8(0x40 | ((dst & 8) >> 1) | ((memReg & 8) >> 1));
+		}
+		_emitU8(0x12);
+		_emitU8((mod << 6) | ((dst & 7) << 3) | (sib_use ? 4 : (memReg & 7)));
+		if (sib_use)
+		{
+			_emitU8((0 << 6) | ((memReg & 7)) | ((index & 7) << 3));
+		}
+		if (mod == 1) _emitU8((u8)offset);
+		else if (mod == 2) _emitU32((u32)offset);
+	}
+	void ADC_dd(GPR32 dst, GPR32 src)
+	{
+		if (((src & 8) != 0) || ((dst & 8) != 0))
+		{
+			_emitU8(0x40 | ((dst & 8) >> 3) | ((src & 8) >> 1));
+		}
+		_emitU8(0x11);
+		_emitU8((3 << 6) | ((src & 7) << 3) | (dst & 7));
+	}
+	void ADC_qq(GPR64 dst, GPR64 src)
+	{
+		_emitU8(0x48 | ((dst & 8) >> 3) | ((src & 8) >> 1));
+		_emitU8(0x11);
+		_emitU8((3 << 6) | ((src & 7) << 3) | (dst & 7));
+	}
+	void ADC_dd_l(GPR64 memReg, sint32 offset, GPR64 index, uint8 scaler, GPR32 src)
+	{
+		uint8 mod;
+		if (offset == 0 && (memReg & 7) != 5) mod = 0;
+		else if (offset == (s32)(s8)offset) mod = 1;
+		else mod = 2;
+		bool sib_use = (scaler != 0 && index != X86_REG_NONE);
+		if ((memReg & 7) == 4)
+		{
+			cemu_assert_debug(index == X86_REG_NONE);
+			index = memReg;
+			sib_use = true;
+		}
+		if (sib_use)
+		{
+			if ((src & 8) || (memReg & 8) || ((index != X86_REG_NONE) && (index & 8)))
+				_emitU8(0x40 | ((src & 8) >> 1) | ((memReg & 8) >> 3) | ((index & 8) >> 2));
+		}
+		else
+		{
+			if ((src & 8) || (memReg & 8))
+				_emitU8(0x40 | ((src & 8) >> 1) | ((memReg & 8) >> 1));
+		}
+		_emitU8(0x11);
+		_emitU8((mod << 6) | ((src & 7) << 3) | (sib_use ? 4 : (memReg & 7)));
+		if (sib_use)
+		{
+			_emitU8((0 << 6) | ((memReg & 7)) | ((index & 7) << 3));
+		}
+		if (mod == 1) _emitU8((u8)offset);
+		else if (mod == 2) _emitU32((u32)offset);
+	}
+	void ADC_qq_l(GPR64 memReg, sint32 offset, GPR64 index, uint8 scaler, GPR64 src)
+	{
+		uint8 mod;
+		if (offset == 0 && (memReg & 7) != 5) mod = 0;
+		else if (offset == (s32)(s8)offset) mod = 1;
+		else mod = 2;
+		bool sib_use = (scaler != 0 && index != X86_REG_NONE);
+		if ((memReg & 7) == 4)
+		{
+			cemu_assert_debug(index == X86_REG_NONE);
+			index = memReg;
+			sib_use = true;
+		}
+		if (sib_use)
+		{
+			_emitU8(0x40 | ((src & 8) >> 1) | ((memReg & 8) >> 3) | ((index & 8) >> 2) | 0x08);
+		}
+		else
+		{
+			_emitU8(0x40 | ((src & 8) >> 1) | ((memReg & 8) >> 1) | 0x08);
+		}
+		_emitU8(0x11);
+		_emitU8((mod << 6) | ((src & 7) << 3) | (sib_use ? 4 : (memReg & 7)));
+		if (sib_use)
+		{
+			_emitU8((0 << 6) | ((memReg & 7)) | ((index & 7) << 3));
+		}
+		if (mod == 1) _emitU8((u8)offset);
+		else if (mod == 2) _emitU32((u32)offset);
+	}
+	void ADC_dd_r(GPR32 dst, GPR64 memReg, sint32 offset, GPR64 index, uint8 scaler)
+	{
+		uint8 mod;
+		if (offset == 0 && (memReg & 7) != 5) mod = 0;
+		else if (offset == (s32)(s8)offset) mod = 1;
+		else mod = 2;
+		bool sib_use = (scaler != 0 && index != X86_REG_NONE);
+		if ((memReg & 7) == 4)
+		{
+			cemu_assert_debug(index == X86_REG_NONE);
+			index = memReg;
+			sib_use = true;
+		}
+		if (sib_use)
+		{
+			if ((dst & 8) || (memReg & 8) || ((index != X86_REG_NONE) && (index & 8)))
+				_emitU8(0x40 | ((dst & 8) >> 1) | ((memReg & 8) >> 3) | ((index & 8) >> 2));
+		}
+		else
+		{
+			if ((dst & 8) || (memReg & 8))
+				_emitU8(0x40 | ((dst & 8) >> 1) | ((memReg & 8) >> 1));
+		}
+		_emitU8(0x13);
+		_emitU8((mod << 6) | ((dst & 7) << 3) | (sib_use ? 4 : (memReg & 7)));
+		if (sib_use)
+		{
+			_emitU8((0 << 6) | ((memReg & 7)) | ((index & 7) << 3));
+		}
+		if (mod == 1) _emitU8((u8)offset);
+		else if (mod == 2) _emitU32((u32)offset);
+	}
+	void ADC_qq_r(GPR64 dst, GPR64 memReg, sint32 offset, GPR64 index, uint8 scaler)
+	{
+		uint8 mod;
+		if (offset == 0 && (memReg & 7) != 5) mod = 0;
+		else if (offset == (s32)(s8)offset) mod = 1;
+		else mod = 2;
+		bool sib_use = (scaler != 0 && index != X86_REG_NONE);
+		if ((memReg & 7) == 4)
+		{
+			cemu_assert_debug(index == X86_REG_NONE);
+			index = memReg;
+			sib_use = true;
+		}
+		if (sib_use)
+		{
+			_emitU8(0x40 | ((dst & 8) >> 1) | ((memReg & 8) >> 3) | ((index & 8) >> 2) | 0x08);
+		}
+		else
+		{
+			_emitU8(0x40 | ((dst & 8) >> 1) | ((memReg & 8) >> 1) | 0x08);
+		}
+		_emitU8(0x13);
+		_emitU8((mod << 6) | ((dst & 7) << 3) | (sib_use ? 4 : (memReg & 7)));
+		if (sib_use)
+		{
+			_emitU8((0 << 6) | ((memReg & 7)) | ((index & 7) << 3));
+		}
+		if (mod == 1) _emitU8((u8)offset);
+		else if (mod == 2) _emitU32((u32)offset);
+	}
+	void SBB_bb(GPR8_REX dst, GPR8_REX src)
+	{
+		if ((src >= 4) || (dst >= 4))
+		{
+			_emitU8(0x40 | ((dst & 8) >> 3) | ((src & 8) >> 1));
+		}
+		_emitU8(0x18);
+		_emitU8((3 << 6) | ((src & 7) << 3) | (dst & 7));
+	}
+	void SBB_bb_l(GPR64 memReg, sint32 offset, GPR64 index, uint8 scaler, GPR8_REX src)
+	{
+		uint8 mod;
+		if (offset == 0 && (memReg & 7) != 5) mod = 0;
+		else if (offset == (s32)(s8)offset) mod = 1;
+		else mod = 2;
+		bool sib_use = (scaler != 0 && index != X86_REG_NONE);
+		if ((memReg & 7) == 4)
+		{
+			cemu_assert_debug(index == X86_REG_NONE);
+			index = memReg;
+			sib_use = true;
+		}
+		if (sib_use)
+		{
+			if ((src >= 4) || (memReg & 8) || ((index != X86_REG_NONE) && (index & 8)))
+				_emitU8(0x40 | ((src & 8) >> 1) | ((memReg & 8) >> 3) | ((index & 8) >> 2));
+		}
+		else
+		{
+			if ((src >= 4) || (memReg & 8))
+				_emitU8(0x40 | ((src & 8) >> 1) | ((memReg & 8) >> 1));
+		}
+		_emitU8(0x18);
+		_emitU8((mod << 6) | ((src & 7) << 3) | (sib_use ? 4 : (memReg & 7)));
+		if (sib_use)
+		{
+			_emitU8((0 << 6) | ((memReg & 7)) | ((index & 7) << 3));
+		}
+		if (mod == 1) _emitU8((u8)offset);
+		else if (mod == 2) _emitU32((u32)offset);
+	}
+	void SBB_bb_r(GPR8_REX dst, GPR64 memReg, sint32 offset, GPR64 index, uint8 scaler)
+	{
+		uint8 mod;
+		if (offset == 0 && (memReg & 7) != 5) mod = 0;
+		else if (offset == (s32)(s8)offset) mod = 1;
+		else mod = 2;
+		bool sib_use = (scaler != 0 && index != X86_REG_NONE);
+		if ((memReg & 7) == 4)
+		{
+			cemu_assert_debug(index == X86_REG_NONE);
+			index = memReg;
+			sib_use = true;
+		}
+		if (sib_use)
+		{
+			if ((dst >= 4) || (memReg & 8) || ((index != X86_REG_NONE) && (index & 8)))
+				_emitU8(0x40 | ((dst & 8) >> 1) | ((memReg & 8) >> 3) | ((index & 8) >> 2));
+		}
+		else
+		{
+			if ((dst >= 4) || (memReg & 8))
+				_emitU8(0x40 | ((dst & 8) >> 1) | ((memReg & 8) >> 1));
+		}
+		_emitU8(0x1a);
+		_emitU8((mod << 6) | ((dst & 7) << 3) | (sib_use ? 4 : (memReg & 7)));
+		if (sib_use)
+		{
+			_emitU8((0 << 6) | ((memReg & 7)) | ((index & 7) << 3));
+		}
+		if (mod == 1) _emitU8((u8)offset);
+		else if (mod == 2) _emitU32((u32)offset);
+	}
+	void SBB_dd(GPR32 dst, GPR32 src)
+	{
+		if (((src & 8) != 0) || ((dst & 8) != 0))
+		{
+			_emitU8(0x40 | ((dst & 8) >> 3) | ((src & 8) >> 1));
+		}
+		_emitU8(0x19);
+		_emitU8((3 << 6) | ((src & 7) << 3) | (dst & 7));
+	}
+	void SBB_qq(GPR64 dst, GPR64 src)
+	{
+		_emitU8(0x48 | ((dst & 8) >> 3) | ((src & 8) >> 1));
+		_emitU8(0x19);
+		_emitU8((3 << 6) | ((src & 7) << 3) | (dst & 7));
+	}
+	void SBB_dd_l(GPR64 memReg, sint32 offset, GPR64 index, uint8 scaler, GPR32 src)
+	{
+		uint8 mod;
+		if (offset == 0 && (memReg & 7) != 5) mod = 0;
+		else if (offset == (s32)(s8)offset) mod = 1;
+		else mod = 2;
+		bool sib_use = (scaler != 0 && index != X86_REG_NONE);
+		if ((memReg & 7) == 4)
+		{
+			cemu_assert_debug(index == X86_REG_NONE);
+			index = memReg;
+			sib_use = true;
+		}
+		if (sib_use)
+		{
+			if ((src & 8) || (memReg & 8) || ((index != X86_REG_NONE) && (index & 8)))
+				_emitU8(0x40 | ((src & 8) >> 1) | ((memReg & 8) >> 3) | ((index & 8) >> 2));
+		}
+		else
+		{
+			if ((src & 8) || (memReg & 8))
+				_emitU8(0x40 | ((src & 8) >> 1) | ((memReg & 8) >> 1));
+		}
+		_emitU8(0x19);
+		_emitU8((mod << 6) | ((src & 7) << 3) | (sib_use ? 4 : (memReg & 7)));
+		if (sib_use)
+		{
+			_emitU8((0 << 6) | ((memReg & 7)) | ((index & 7) << 3));
+		}
+		if (mod == 1) _emitU8((u8)offset);
+		else if (mod == 2) _emitU32((u32)offset);
+	}
+	void SBB_qq_l(GPR64 memReg, sint32 offset, GPR64 index, uint8 scaler, GPR64 src)
+	{
+		uint8 mod;
+		if (offset == 0 && (memReg & 7) != 5) mod = 0;
+		else if (offset == (s32)(s8)offset) mod = 1;
+		else mod = 2;
+		bool sib_use = (scaler != 0 && index != X86_REG_NONE);
+		if ((memReg & 7) == 4)
+		{
+			cemu_assert_debug(index == X86_REG_NONE);
+			index = memReg;
+			sib_use = true;
+		}
+		if (sib_use)
+		{
+			_emitU8(0x40 | ((src & 8) >> 1) | ((memReg & 8) >> 3) | ((index & 8) >> 2) | 0x08);
+		}
+		else
+		{
+			_emitU8(0x40 | ((src & 8) >> 1) | ((memReg & 8) >> 1) | 0x08);
+		}
+		_emitU8(0x19);
+		_emitU8((mod << 6) | ((src & 7) << 3) | (sib_use ? 4 : (memReg & 7)));
+		if (sib_use)
+		{
+			_emitU8((0 << 6) | ((memReg & 7)) | ((index & 7) << 3));
+		}
+		if (mod == 1) _emitU8((u8)offset);
+		else if (mod == 2) _emitU32((u32)offset);
+	}
+	void SBB_dd_r(GPR32 dst, GPR64 memReg, sint32 offset, GPR64 index, uint8 scaler)
+	{
+		uint8 mod;
+		if (offset == 0 && (memReg & 7) != 5) mod = 0;
+		else if (offset == (s32)(s8)offset) mod = 1;
+		else mod = 2;
+		bool sib_use = (scaler != 0 && index != X86_REG_NONE);
+		if ((memReg & 7) == 4)
+		{
+			cemu_assert_debug(index == X86_REG_NONE);
+			index = memReg;
+			sib_use = true;
+		}
+		if (sib_use)
+		{
+			if ((dst & 8) || (memReg & 8) || ((index != X86_REG_NONE) && (index & 8)))
+				_emitU8(0x40 | ((dst & 8) >> 1) | ((memReg & 8) >> 3) | ((index & 8) >> 2));
+		}
+		else
+		{
+			if ((dst & 8) || (memReg & 8))
+				_emitU8(0x40 | ((dst & 8) >> 1) | ((memReg & 8) >> 1));
+		}
+		_emitU8(0x1b);
+		_emitU8((mod << 6) | ((dst & 7) << 3) | (sib_use ? 4 : (memReg & 7)));
+		if (sib_use)
+		{
+			_emitU8((0 << 6) | ((memReg & 7)) | ((index & 7) << 3));
+		}
+		if (mod == 1) _emitU8((u8)offset);
+		else if (mod == 2) _emitU32((u32)offset);
+	}
+	void SBB_qq_r(GPR64 dst, GPR64 memReg, sint32 offset, GPR64 index, uint8 scaler)
+	{
+		uint8 mod;
+		if (offset == 0 && (memReg & 7) != 5) mod = 0;
+		else if (offset == (s32)(s8)offset) mod = 1;
+		else mod = 2;
+		bool sib_use = (scaler != 0 && index != X86_REG_NONE);
+		if ((memReg & 7) == 4)
+		{
+			cemu_assert_debug(index == X86_REG_NONE);
+			index = memReg;
+			sib_use = true;
+		}
+		if (sib_use)
+		{
+			_emitU8(0x40 | ((dst & 8) >> 1) | ((memReg & 8) >> 3) | ((index & 8) >> 2) | 0x08);
+		}
+		else
+		{
+			_emitU8(0x40 | ((dst & 8) >> 1) | ((memReg & 8) >> 1) | 0x08);
+		}
+		_emitU8(0x1b);
+		_emitU8((mod << 6) | ((dst & 7) << 3) | (sib_use ? 4 : (memReg & 7)));
+		if (sib_use)
+		{
+			_emitU8((0 << 6) | ((memReg & 7)) | ((index & 7) << 3));
+		}
+		if (mod == 1) _emitU8((u8)offset);
+		else if (mod == 2) _emitU32((u32)offset);
+	}
+	void AND_bb(GPR8_REX dst, GPR8_REX src)
+	{
+		if ((src >= 4) || (dst >= 4))
+		{
+			_emitU8(0x40 | ((dst & 8) >> 3) | ((src & 8) >> 1));
+		}
+		_emitU8(0x20);
+		_emitU8((3 << 6) | ((src & 7) << 3) | (dst & 7));
+	}
+	void AND_bb_l(GPR64 memReg, sint32 offset, GPR64 index, uint8 scaler, GPR8_REX src)
+	{
+		uint8 mod;
+		if (offset == 0 && (memReg & 7) != 5) mod = 0;
+		else if (offset == (s32)(s8)offset) mod = 1;
+		else mod = 2;
+		bool sib_use = (scaler != 0 && index != X86_REG_NONE);
+		if ((memReg & 7) == 4)
+		{
+			cemu_assert_debug(index == X86_REG_NONE);
+			index = memReg;
+			sib_use = true;
+		}
+		if (sib_use)
+		{
+			if ((src >= 4) || (memReg & 8) || ((index != X86_REG_NONE) && (index & 8)))
+				_emitU8(0x40 | ((src & 8) >> 1) | ((memReg & 8) >> 3) | ((index & 8) >> 2));
+		}
+		else
+		{
+			if ((src >= 4) || (memReg & 8))
+				_emitU8(0x40 | ((src & 8) >> 1) | ((memReg & 8) >> 1));
+		}
+		_emitU8(0x20);
+		_emitU8((mod << 6) | ((src & 7) << 3) | (sib_use ? 4 : (memReg & 7)));
+		if (sib_use)
+		{
+			_emitU8((0 << 6) | ((memReg & 7)) | ((index & 7) << 3));
+		}
+		if (mod == 1) _emitU8((u8)offset);
+		else if (mod == 2) _emitU32((u32)offset);
+	}
+	void AND_bb_r(GPR8_REX dst, GPR64 memReg, sint32 offset, GPR64 index, uint8 scaler)
+	{
+		uint8 mod;
+		if (offset == 0 && (memReg & 7) != 5) mod = 0;
+		else if (offset == (s32)(s8)offset) mod = 1;
+		else mod = 2;
+		bool sib_use = (scaler != 0 && index != X86_REG_NONE);
+		if ((memReg & 7) == 4)
+		{
+			cemu_assert_debug(index == X86_REG_NONE);
+			index = memReg;
+			sib_use = true;
+		}
+		if (sib_use)
+		{
+			if ((dst >= 4) || (memReg & 8) || ((index != X86_REG_NONE) && (index & 8)))
+				_emitU8(0x40 | ((dst & 8) >> 1) | ((memReg & 8) >> 3) | ((index & 8) >> 2));
+		}
+		else
+		{
+			if ((dst >= 4) || (memReg & 8))
+				_emitU8(0x40 | ((dst & 8) >> 1) | ((memReg & 8) >> 1));
+		}
+		_emitU8(0x22);
+		_emitU8((mod << 6) | ((dst & 7) << 3) | (sib_use ? 4 : (memReg & 7)));
+		if (sib_use)
+		{
+			_emitU8((0 << 6) | ((memReg & 7)) | ((index & 7) << 3));
+		}
+		if (mod == 1) _emitU8((u8)offset);
+		else if (mod == 2) _emitU32((u32)offset);
+	}
+	void AND_dd(GPR32 dst, GPR32 src)
+	{
+		if (((src & 8) != 0) || ((dst & 8) != 0))
+		{
+			_emitU8(0x40 | ((dst & 8) >> 3) | ((src & 8) >> 1));
+		}
+		_emitU8(0x21);
+		_emitU8((3 << 6) | ((src & 7) << 3) | (dst & 7));
+	}
+	void AND_qq(GPR64 dst, GPR64 src)
+	{
+		_emitU8(0x48 | ((dst & 8) >> 3) | ((src & 8) >> 1));
+		_emitU8(0x21);
+		_emitU8((3 << 6) | ((src & 7) << 3) | (dst & 7));
+	}
+	void AND_dd_l(GPR64 memReg, sint32 offset, GPR64 index, uint8 scaler, GPR32 src)
+	{
+		uint8 mod;
+		if (offset == 0 && (memReg & 7) != 5) mod = 0;
+		else if (offset == (s32)(s8)offset) mod = 1;
+		else mod = 2;
+		bool sib_use = (scaler != 0 && index != X86_REG_NONE);
+		if ((memReg & 7) == 4)
+		{
+			cemu_assert_debug(index == X86_REG_NONE);
+			index = memReg;
+			sib_use = true;
+		}
+		if (sib_use)
+		{
+			if ((src & 8) || (memReg & 8) || ((index != X86_REG_NONE) && (index & 8)))
+				_emitU8(0x40 | ((src & 8) >> 1) | ((memReg & 8) >> 3) | ((index & 8) >> 2));
+		}
+		else
+		{
+			if ((src & 8) || (memReg & 8))
+				_emitU8(0x40 | ((src & 8) >> 1) | ((memReg & 8) >> 1));
+		}
+		_emitU8(0x21);
+		_emitU8((mod << 6) | ((src & 7) << 3) | (sib_use ? 4 : (memReg & 7)));
+		if (sib_use)
+		{
+			_emitU8((0 << 6) | ((memReg & 7)) | ((index & 7) << 3));
+		}
+		if (mod == 1) _emitU8((u8)offset);
+		else if (mod == 2) _emitU32((u32)offset);
+	}
+	void AND_qq_l(GPR64 memReg, sint32 offset, GPR64 index, uint8 scaler, GPR64 src)
+	{
+		uint8 mod;
+		if (offset == 0 && (memReg & 7) != 5) mod = 0;
+		else if (offset == (s32)(s8)offset) mod = 1;
+		else mod = 2;
+		bool sib_use = (scaler != 0 && index != X86_REG_NONE);
+		if ((memReg & 7) == 4)
+		{
+			cemu_assert_debug(index == X86_REG_NONE);
+			index = memReg;
+			sib_use = true;
+		}
+		if (sib_use)
+		{
+			_emitU8(0x40 | ((src & 8) >> 1) | ((memReg & 8) >> 3) | ((index & 8) >> 2) | 0x08);
+		}
+		else
+		{
+			_emitU8(0x40 | ((src & 8) >> 1) | ((memReg & 8) >> 1) | 0x08);
+		}
+		_emitU8(0x21);
+		_emitU8((mod << 6) | ((src & 7) << 3) | (sib_use ? 4 : (memReg & 7)));
+		if (sib_use)
+		{
+			_emitU8((0 << 6) | ((memReg & 7)) | ((index & 7) << 3));
+		}
+		if (mod == 1) _emitU8((u8)offset);
+		else if (mod == 2) _emitU32((u32)offset);
+	}
+	void AND_dd_r(GPR32 dst, GPR64 memReg, sint32 offset, GPR64 index, uint8 scaler)
+	{
+		uint8 mod;
+		if (offset == 0 && (memReg & 7) != 5) mod = 0;
+		else if (offset == (s32)(s8)offset) mod = 1;
+		else mod = 2;
+		bool sib_use = (scaler != 0 && index != X86_REG_NONE);
+		if ((memReg & 7) == 4)
+		{
+			cemu_assert_debug(index == X86_REG_NONE);
+			index = memReg;
+			sib_use = true;
+		}
+		if (sib_use)
+		{
+			if ((dst & 8) || (memReg & 8) || ((index != X86_REG_NONE) && (index & 8)))
+				_emitU8(0x40 | ((dst & 8) >> 1) | ((memReg & 8) >> 3) | ((index & 8) >> 2));
+		}
+		else
+		{
+			if ((dst & 8) || (memReg & 8))
+				_emitU8(0x40 | ((dst & 8) >> 1) | ((memReg & 8) >> 1));
+		}
+		_emitU8(0x23);
+		_emitU8((mod << 6) | ((dst & 7) << 3) | (sib_use ? 4 : (memReg & 7)));
+		if (sib_use)
+		{
+			_emitU8((0 << 6) | ((memReg & 7)) | ((index & 7) << 3));
+		}
+		if (mod == 1) _emitU8((u8)offset);
+		else if (mod == 2) _emitU32((u32)offset);
+	}
+	void AND_qq_r(GPR64 dst, GPR64 memReg, sint32 offset, GPR64 index, uint8 scaler)
+	{
+		uint8 mod;
+		if (offset == 0 && (memReg & 7) != 5) mod = 0;
+		else if (offset == (s32)(s8)offset) mod = 1;
+		else mod = 2;
+		bool sib_use = (scaler != 0 && index != X86_REG_NONE);
+		if ((memReg & 7) == 4)
+		{
+			cemu_assert_debug(index == X86_REG_NONE);
+			index = memReg;
+			sib_use = true;
+		}
+		if (sib_use)
+		{
+			_emitU8(0x40 | ((dst & 8) >> 1) | ((memReg & 8) >> 3) | ((index & 8) >> 2) | 0x08);
+		}
+		else
+		{
+			_emitU8(0x40 | ((dst & 8) >> 1) | ((memReg & 8) >> 1) | 0x08);
+		}
+		_emitU8(0x23);
+		_emitU8((mod << 6) | ((dst & 7) << 3) | (sib_use ? 4 : (memReg & 7)));
+		if (sib_use)
+		{
+			_emitU8((0 << 6) | ((memReg & 7)) | ((index & 7) << 3));
+		}
+		if (mod == 1) _emitU8((u8)offset);
+		else if (mod == 2) _emitU32((u32)offset);
+	}
+	void SUB_bb(GPR8_REX dst, GPR8_REX src)
+	{
+		if ((src >= 4) || (dst >= 4))
+		{
+			_emitU8(0x40 | ((dst & 8) >> 3) | ((src & 8) >> 1));
+		}
+		_emitU8(0x28);
+		_emitU8((3 << 6) | ((src & 7) << 3) | (dst & 7));
+	}
+	void SUB_bb_l(GPR64 memReg, sint32 offset, GPR64 index, uint8 scaler, GPR8_REX src)
+	{
+		uint8 mod;
+		if (offset == 0 && (memReg & 7) != 5) mod = 0;
+		else if (offset == (s32)(s8)offset) mod = 1;
+		else mod = 2;
+		bool sib_use = (scaler != 0 && index != X86_REG_NONE);
+		if ((memReg & 7) == 4)
+		{
+			cemu_assert_debug(index == X86_REG_NONE);
+			index = memReg;
+			sib_use = true;
+		}
+		if (sib_use)
+		{
+			if ((src >= 4) || (memReg & 8) || ((index != X86_REG_NONE) && (index & 8)))
+				_emitU8(0x40 | ((src & 8) >> 1) | ((memReg & 8) >> 3) | ((index & 8) >> 2));
+		}
+		else
+		{
+			if ((src >= 4) || (memReg & 8))
+				_emitU8(0x40 | ((src & 8) >> 1) | ((memReg & 8) >> 1));
+		}
+		_emitU8(0x28);
+		_emitU8((mod << 6) | ((src & 7) << 3) | (sib_use ? 4 : (memReg & 7)));
+		if (sib_use)
+		{
+			_emitU8((0 << 6) | ((memReg & 7)) | ((index & 7) << 3));
+		}
+		if (mod == 1) _emitU8((u8)offset);
+		else if (mod == 2) _emitU32((u32)offset);
+	}
+	void SUB_bb_r(GPR8_REX dst, GPR64 memReg, sint32 offset, GPR64 index, uint8 scaler)
+	{
+		uint8 mod;
+		if (offset == 0 && (memReg & 7) != 5) mod = 0;
+		else if (offset == (s32)(s8)offset) mod = 1;
+		else mod = 2;
+		bool sib_use = (scaler != 0 && index != X86_REG_NONE);
+		if ((memReg & 7) == 4)
+		{
+			cemu_assert_debug(index == X86_REG_NONE);
+			index = memReg;
+			sib_use = true;
+		}
+		if (sib_use)
+		{
+			if ((dst >= 4) || (memReg & 8) || ((index != X86_REG_NONE) && (index & 8)))
+				_emitU8(0x40 | ((dst & 8) >> 1) | ((memReg & 8) >> 3) | ((index & 8) >> 2));
+		}
+		else
+		{
+			if ((dst >= 4) || (memReg & 8))
+				_emitU8(0x40 | ((dst & 8) >> 1) | ((memReg & 8) >> 1));
+		}
+		_emitU8(0x2a);
+		_emitU8((mod << 6) | ((dst & 7) << 3) | (sib_use ? 4 : (memReg & 7)));
+		if (sib_use)
+		{
+			_emitU8((0 << 6) | ((memReg & 7)) | ((index & 7) << 3));
+		}
+		if (mod == 1) _emitU8((u8)offset);
+		else if (mod == 2) _emitU32((u32)offset);
+	}
+	void SUB_dd(GPR32 dst, GPR32 src)
+	{
+		if (((src & 8) != 0) || ((dst & 8) != 0))
+		{
+			_emitU8(0x40 | ((dst & 8) >> 3) | ((src & 8) >> 1));
+		}
+		_emitU8(0x29);
+		_emitU8((3 << 6) | ((src & 7) << 3) | (dst & 7));
+	}
+	void SUB_qq(GPR64 dst, GPR64 src)
+	{
+		_emitU8(0x48 | ((dst & 8) >> 3) | ((src & 8) >> 1));
+		_emitU8(0x29);
+		_emitU8((3 << 6) | ((src & 7) << 3) | (dst & 7));
+	}
+	void SUB_dd_l(GPR64 memReg, sint32 offset, GPR64 index, uint8 scaler, GPR32 src)
+	{
+		uint8 mod;
+		if (offset == 0 && (memReg & 7) != 5) mod = 0;
+		else if (offset == (s32)(s8)offset) mod = 1;
+		else mod = 2;
+		bool sib_use = (scaler != 0 && index != X86_REG_NONE);
+		if ((memReg & 7) == 4)
+		{
+			cemu_assert_debug(index == X86_REG_NONE);
+			index = memReg;
+			sib_use = true;
+		}
+		if (sib_use)
+		{
+			if ((src & 8) || (memReg & 8) || ((index != X86_REG_NONE) && (index & 8)))
+				_emitU8(0x40 | ((src & 8) >> 1) | ((memReg & 8) >> 3) | ((index & 8) >> 2));
+		}
+		else
+		{
+			if ((src & 8) || (memReg & 8))
+				_emitU8(0x40 | ((src & 8) >> 1) | ((memReg & 8) >> 1));
+		}
+		_emitU8(0x29);
+		_emitU8((mod << 6) | ((src & 7) << 3) | (sib_use ? 4 : (memReg & 7)));
+		if (sib_use)
+		{
+			_emitU8((0 << 6) | ((memReg & 7)) | ((index & 7) << 3));
+		}
+		if (mod == 1) _emitU8((u8)offset);
+		else if (mod == 2) _emitU32((u32)offset);
+	}
+	void SUB_qq_l(GPR64 memReg, sint32 offset, GPR64 index, uint8 scaler, GPR64 src)
+	{
+		uint8 mod;
+		if (offset == 0 && (memReg & 7) != 5) mod = 0;
+		else if (offset == (s32)(s8)offset) mod = 1;
+		else mod = 2;
+		bool sib_use = (scaler != 0 && index != X86_REG_NONE);
+		if ((memReg & 7) == 4)
+		{
+			cemu_assert_debug(index == X86_REG_NONE);
+			index = memReg;
+			sib_use = true;
+		}
+		if (sib_use)
+		{
+			_emitU8(0x40 | ((src & 8) >> 1) | ((memReg & 8) >> 3) | ((index & 8) >> 2) | 0x08);
+		}
+		else
+		{
+			_emitU8(0x40 | ((src & 8) >> 1) | ((memReg & 8) >> 1) | 0x08);
+		}
+		_emitU8(0x29);
+		_emitU8((mod << 6) | ((src & 7) << 3) | (sib_use ? 4 : (memReg & 7)));
+		if (sib_use)
+		{
+			_emitU8((0 << 6) | ((memReg & 7)) | ((index & 7) << 3));
+		}
+		if (mod == 1) _emitU8((u8)offset);
+		else if (mod == 2) _emitU32((u32)offset);
+	}
+	void SUB_dd_r(GPR32 dst, GPR64 memReg, sint32 offset, GPR64 index, uint8 scaler)
+	{
+		uint8 mod;
+		if (offset == 0 && (memReg & 7) != 5) mod = 0;
+		else if (offset == (s32)(s8)offset) mod = 1;
+		else mod = 2;
+		bool sib_use = (scaler != 0 && index != X86_REG_NONE);
+		if ((memReg & 7) == 4)
+		{
+			cemu_assert_debug(index == X86_REG_NONE);
+			index = memReg;
+			sib_use = true;
+		}
+		if (sib_use)
+		{
+			if ((dst & 8) || (memReg & 8) || ((index != X86_REG_NONE) && (index & 8)))
+				_emitU8(0x40 | ((dst & 8) >> 1) | ((memReg & 8) >> 3) | ((index & 8) >> 2));
+		}
+		else
+		{
+			if ((dst & 8) || (memReg & 8))
+				_emitU8(0x40 | ((dst & 8) >> 1) | ((memReg & 8) >> 1));
+		}
+		_emitU8(0x2b);
+		_emitU8((mod << 6) | ((dst & 7) << 3) | (sib_use ? 4 : (memReg & 7)));
+		if (sib_use)
+		{
+			_emitU8((0 << 6) | ((memReg & 7)) | ((index & 7) << 3));
+		}
+		if (mod == 1) _emitU8((u8)offset);
+		else if (mod == 2) _emitU32((u32)offset);
+	}
+	void SUB_qq_r(GPR64 dst, GPR64 memReg, sint32 offset, GPR64 index, uint8 scaler)
+	{
+		uint8 mod;
+		if (offset == 0 && (memReg & 7) != 5) mod = 0;
+		else if (offset == (s32)(s8)offset) mod = 1;
+		else mod = 2;
+		bool sib_use = (scaler != 0 && index != X86_REG_NONE);
+		if ((memReg & 7) == 4)
+		{
+			cemu_assert_debug(index == X86_REG_NONE);
+			index = memReg;
+			sib_use = true;
+		}
+		if (sib_use)
+		{
+			_emitU8(0x40 | ((dst & 8) >> 1) | ((memReg & 8) >> 3) | ((index & 8) >> 2) | 0x08);
+		}
+		else
+		{
+			_emitU8(0x40 | ((dst & 8) >> 1) | ((memReg & 8) >> 1) | 0x08);
+		}
+		_emitU8(0x2b);
+		_emitU8((mod << 6) | ((dst & 7) << 3) | (sib_use ? 4 : (memReg & 7)));
+		if (sib_use)
+		{
+			_emitU8((0 << 6) | ((memReg & 7)) | ((index & 7) << 3));
+		}
+		if (mod == 1) _emitU8((u8)offset);
+		else if (mod == 2) _emitU32((u32)offset);
+	}
+	void XOR_bb(GPR8_REX dst, GPR8_REX src)
+	{
+		if ((src >= 4) || (dst >= 4))
+		{
+			_emitU8(0x40 | ((dst & 8) >> 3) | ((src & 8) >> 1));
+		}
+		_emitU8(0x30);
+		_emitU8((3 << 6) | ((src & 7) << 3) | (dst & 7));
+	}
+	void XOR_bb_l(GPR64 memReg, sint32 offset, GPR64 index, uint8 scaler, GPR8_REX src)
+	{
+		uint8 mod;
+		if (offset == 0 && (memReg & 7) != 5) mod = 0;
+		else if (offset == (s32)(s8)offset) mod = 1;
+		else mod = 2;
+		bool sib_use = (scaler != 0 && index != X86_REG_NONE);
+		if ((memReg & 7) == 4)
+		{
+			cemu_assert_debug(index == X86_REG_NONE);
+			index = memReg;
+			sib_use = true;
+		}
+		if (sib_use)
+		{
+			if ((src >= 4) || (memReg & 8) || ((index != X86_REG_NONE) && (index & 8)))
+				_emitU8(0x40 | ((src & 8) >> 1) | ((memReg & 8) >> 3) | ((index & 8) >> 2));
+		}
+		else
+		{
+			if ((src >= 4) || (memReg & 8))
+				_emitU8(0x40 | ((src & 8) >> 1) | ((memReg & 8) >> 1));
+		}
+		_emitU8(0x30);
+		_emitU8((mod << 6) | ((src & 7) << 3) | (sib_use ? 4 : (memReg & 7)));
+		if (sib_use)
+		{
+			_emitU8((0 << 6) | ((memReg & 7)) | ((index & 7) << 3));
+		}
+		if (mod == 1) _emitU8((u8)offset);
+		else if (mod == 2) _emitU32((u32)offset);
+	}
+	void XOR_bb_r(GPR8_REX dst, GPR64 memReg, sint32 offset, GPR64 index, uint8 scaler)
+	{
+		uint8 mod;
+		if (offset == 0 && (memReg & 7) != 5) mod = 0;
+		else if (offset == (s32)(s8)offset) mod = 1;
+		else mod = 2;
+		bool sib_use = (scaler != 0 && index != X86_REG_NONE);
+		if ((memReg & 7) == 4)
+		{
+			cemu_assert_debug(index == X86_REG_NONE);
+			index = memReg;
+			sib_use = true;
+		}
+		if (sib_use)
+		{
+			if ((dst >= 4) || (memReg & 8) || ((index != X86_REG_NONE) && (index & 8)))
+				_emitU8(0x40 | ((dst & 8) >> 1) | ((memReg & 8) >> 3) | ((index & 8) >> 2));
+		}
+		else
+		{
+			if ((dst >= 4) || (memReg & 8))
+				_emitU8(0x40 | ((dst & 8) >> 1) | ((memReg & 8) >> 1));
+		}
+		_emitU8(0x32);
+		_emitU8((mod << 6) | ((dst & 7) << 3) | (sib_use ? 4 : (memReg & 7)));
+		if (sib_use)
+		{
+			_emitU8((0 << 6) | ((memReg & 7)) | ((index & 7) << 3));
+		}
+		if (mod == 1) _emitU8((u8)offset);
+		else if (mod == 2) _emitU32((u32)offset);
+	}
+	void XOR_dd(GPR32 dst, GPR32 src)
+	{
+		if (((src & 8) != 0) || ((dst & 8) != 0))
+		{
+			_emitU8(0x40 | ((dst & 8) >> 3) | ((src & 8) >> 1));
+		}
+		_emitU8(0x31);
+		_emitU8((3 << 6) | ((src & 7) << 3) | (dst & 7));
+	}
+	void XOR_qq(GPR64 dst, GPR64 src)
+	{
+		_emitU8(0x48 | ((dst & 8) >> 3) | ((src & 8) >> 1));
+		_emitU8(0x31);
+		_emitU8((3 << 6) | ((src & 7) << 3) | (dst & 7));
+	}
+	void XOR_dd_l(GPR64 memReg, sint32 offset, GPR64 index, uint8 scaler, GPR32 src)
+	{
+		uint8 mod;
+		if (offset == 0 && (memReg & 7) != 5) mod = 0;
+		else if (offset == (s32)(s8)offset) mod = 1;
+		else mod = 2;
+		bool sib_use = (scaler != 0 && index != X86_REG_NONE);
+		if ((memReg & 7) == 4)
+		{
+			cemu_assert_debug(index == X86_REG_NONE);
+			index = memReg;
+			sib_use = true;
+		}
+		if (sib_use)
+		{
+			if ((src & 8) || (memReg & 8) || ((index != X86_REG_NONE) && (index & 8)))
+				_emitU8(0x40 | ((src & 8) >> 1) | ((memReg & 8) >> 3) | ((index & 8) >> 2));
+		}
+		else
+		{
+			if ((src & 8) || (memReg & 8))
+				_emitU8(0x40 | ((src & 8) >> 1) | ((memReg & 8) >> 1));
+		}
+		_emitU8(0x31);
+		_emitU8((mod << 6) | ((src & 7) << 3) | (sib_use ? 4 : (memReg & 7)));
+		if (sib_use)
+		{
+			_emitU8((0 << 6) | ((memReg & 7)) | ((index & 7) << 3));
+		}
+		if (mod == 1) _emitU8((u8)offset);
+		else if (mod == 2) _emitU32((u32)offset);
+	}
+	void XOR_qq_l(GPR64 memReg, sint32 offset, GPR64 index, uint8 scaler, GPR64 src)
+	{
+		uint8 mod;
+		if (offset == 0 && (memReg & 7) != 5) mod = 0;
+		else if (offset == (s32)(s8)offset) mod = 1;
+		else mod = 2;
+		bool sib_use = (scaler != 0 && index != X86_REG_NONE);
+		if ((memReg & 7) == 4)
+		{
+			cemu_assert_debug(index == X86_REG_NONE);
+			index = memReg;
+			sib_use = true;
+		}
+		if (sib_use)
+		{
+			_emitU8(0x40 | ((src & 8) >> 1) | ((memReg & 8) >> 3) | ((index & 8) >> 2) | 0x08);
+		}
+		else
+		{
+			_emitU8(0x40 | ((src & 8) >> 1) | ((memReg & 8) >> 1) | 0x08);
+		}
+		_emitU8(0x31);
+		_emitU8((mod << 6) | ((src & 7) << 3) | (sib_use ? 4 : (memReg & 7)));
+		if (sib_use)
+		{
+			_emitU8((0 << 6) | ((memReg & 7)) | ((index & 7) << 3));
+		}
+		if (mod == 1) _emitU8((u8)offset);
+		else if (mod == 2) _emitU32((u32)offset);
+	}
+	void XOR_dd_r(GPR32 dst, GPR64 memReg, sint32 offset, GPR64 index, uint8 scaler)
+	{
+		uint8 mod;
+		if (offset == 0 && (memReg & 7) != 5) mod = 0;
+		else if (offset == (s32)(s8)offset) mod = 1;
+		else mod = 2;
+		bool sib_use = (scaler != 0 && index != X86_REG_NONE);
+		if ((memReg & 7) == 4)
+		{
+			cemu_assert_debug(index == X86_REG_NONE);
+			index = memReg;
+			sib_use = true;
+		}
+		if (sib_use)
+		{
+			if ((dst & 8) || (memReg & 8) || ((index != X86_REG_NONE) && (index & 8)))
+				_emitU8(0x40 | ((dst & 8) >> 1) | ((memReg & 8) >> 3) | ((index & 8) >> 2));
+		}
+		else
+		{
+			if ((dst & 8) || (memReg & 8))
+				_emitU8(0x40 | ((dst & 8) >> 1) | ((memReg & 8) >> 1));
+		}
+		_emitU8(0x33);
+		_emitU8((mod << 6) | ((dst & 7) << 3) | (sib_use ? 4 : (memReg & 7)));
+		if (sib_use)
+		{
+			_emitU8((0 << 6) | ((memReg & 7)) | ((index & 7) << 3));
+		}
+		if (mod == 1) _emitU8((u8)offset);
+		else if (mod == 2) _emitU32((u32)offset);
+	}
+	void XOR_qq_r(GPR64 dst, GPR64 memReg, sint32 offset, GPR64 index, uint8 scaler)
+	{
+		uint8 mod;
+		if (offset == 0 && (memReg & 7) != 5) mod = 0;
+		else if (offset == (s32)(s8)offset) mod = 1;
+		else mod = 2;
+		bool sib_use = (scaler != 0 && index != X86_REG_NONE);
+		if ((memReg & 7) == 4)
+		{
+			cemu_assert_debug(index == X86_REG_NONE);
+			index = memReg;
+			sib_use = true;
+		}
+		if (sib_use)
+		{
+			_emitU8(0x40 | ((dst & 8) >> 1) | ((memReg & 8) >> 3) | ((index & 8) >> 2) | 0x08);
+		}
+		else
+		{
+			_emitU8(0x40 | ((dst & 8) >> 1) | ((memReg & 8) >> 1) | 0x08);
+		}
+		_emitU8(0x33);
+		_emitU8((mod << 6) | ((dst & 7) << 3) | (sib_use ? 4 : (memReg & 7)));
+		if (sib_use)
+		{
+			_emitU8((0 << 6) | ((memReg & 7)) | ((index & 7) << 3));
+		}
+		if (mod == 1) _emitU8((u8)offset);
+		else if (mod == 2) _emitU32((u32)offset);
+	}
+	void CMP_bb(GPR8_REX dst, GPR8_REX src)
+	{
+		if ((src >= 4) || (dst >= 4))
+		{
+			_emitU8(0x40 | ((dst & 8) >> 3) | ((src & 8) >> 1));
+		}
+		_emitU8(0x38);
+		_emitU8((3 << 6) | ((src & 7) << 3) | (dst & 7));
+	}
+	void CMP_bb_l(GPR64 memReg, sint32 offset, GPR64 index, uint8 scaler, GPR8_REX src)
+	{
+		uint8 mod;
+		if (offset == 0 && (memReg & 7) != 5) mod = 0;
+		else if (offset == (s32)(s8)offset) mod = 1;
+		else mod = 2;
+		bool sib_use = (scaler != 0 && index != X86_REG_NONE);
+		if ((memReg & 7) == 4)
+		{
+			cemu_assert_debug(index == X86_REG_NONE);
+			index = memReg;
+			sib_use = true;
+		}
+		if (sib_use)
+		{
+			if ((src >= 4) || (memReg & 8) || ((index != X86_REG_NONE) && (index & 8)))
+				_emitU8(0x40 | ((src & 8) >> 1) | ((memReg & 8) >> 3) | ((index & 8) >> 2));
+		}
+		else
+		{
+			if ((src >= 4) || (memReg & 8))
+				_emitU8(0x40 | ((src & 8) >> 1) | ((memReg & 8) >> 1));
+		}
+		_emitU8(0x38);
+		_emitU8((mod << 6) | ((src & 7) << 3) | (sib_use ? 4 : (memReg & 7)));
+		if (sib_use)
+		{
+			_emitU8((0 << 6) | ((memReg & 7)) | ((index & 7) << 3));
+		}
+		if (mod == 1) _emitU8((u8)offset);
+		else if (mod == 2) _emitU32((u32)offset);
+	}
+	void CMP_bb_r(GPR8_REX dst, GPR64 memReg, sint32 offset, GPR64 index, uint8 scaler)
+	{
+		uint8 mod;
+		if (offset == 0 && (memReg & 7) != 5) mod = 0;
+		else if (offset == (s32)(s8)offset) mod = 1;
+		else mod = 2;
+		bool sib_use = (scaler != 0 && index != X86_REG_NONE);
+		if ((memReg & 7) == 4)
+		{
+			cemu_assert_debug(index == X86_REG_NONE);
+			index = memReg;
+			sib_use = true;
+		}
+		if (sib_use)
+		{
+			if ((dst >= 4) || (memReg & 8) || ((index != X86_REG_NONE) && (index & 8)))
+				_emitU8(0x40 | ((dst & 8) >> 1) | ((memReg & 8) >> 3) | ((index & 8) >> 2));
+		}
+		else
+		{
+			if ((dst >= 4) || (memReg & 8))
+				_emitU8(0x40 | ((dst & 8) >> 1) | ((memReg & 8) >> 1));
+		}
+		_emitU8(0x3a);
+		_emitU8((mod << 6) | ((dst & 7) << 3) | (sib_use ? 4 : (memReg & 7)));
+		if (sib_use)
+		{
+			_emitU8((0 << 6) | ((memReg & 7)) | ((index & 7) << 3));
+		}
+		if (mod == 1) _emitU8((u8)offset);
+		else if (mod == 2) _emitU32((u32)offset);
+	}
+	void CMP_dd(GPR32 dst, GPR32 src)
+	{
+		if (((src & 8) != 0) || ((dst & 8) != 0))
+		{
+			_emitU8(0x40 | ((dst & 8) >> 3) | ((src & 8) >> 1));
+		}
+		_emitU8(0x39);
+		_emitU8((3 << 6) | ((src & 7) << 3) | (dst & 7));
+	}
+	void CMP_qq(GPR64 dst, GPR64 src)
+	{
+		_emitU8(0x48 | ((dst & 8) >> 3) | ((src & 8) >> 1));
+		_emitU8(0x39);
+		_emitU8((3 << 6) | ((src & 7) << 3) | (dst & 7));
+	}
+	void CMP_dd_l(GPR64 memReg, sint32 offset, GPR64 index, uint8 scaler, GPR32 src)
+	{
+		uint8 mod;
+		if (offset == 0 && (memReg & 7) != 5) mod = 0;
+		else if (offset == (s32)(s8)offset) mod = 1;
+		else mod = 2;
+		bool sib_use = (scaler != 0 && index != X86_REG_NONE);
+		if ((memReg & 7) == 4)
+		{
+			cemu_assert_debug(index == X86_REG_NONE);
+			index = memReg;
+			sib_use = true;
+		}
+		if (sib_use)
+		{
+			if ((src & 8) || (memReg & 8) || ((index != X86_REG_NONE) && (index & 8)))
+				_emitU8(0x40 | ((src & 8) >> 1) | ((memReg & 8) >> 3) | ((index & 8) >> 2));
+		}
+		else
+		{
+			if ((src & 8) || (memReg & 8))
+				_emitU8(0x40 | ((src & 8) >> 1) | ((memReg & 8) >> 1));
+		}
+		_emitU8(0x39);
+		_emitU8((mod << 6) | ((src & 7) << 3) | (sib_use ? 4 : (memReg & 7)));
+		if (sib_use)
+		{
+			_emitU8((0 << 6) | ((memReg & 7)) | ((index & 7) << 3));
+		}
+		if (mod == 1) _emitU8((u8)offset);
+		else if (mod == 2) _emitU32((u32)offset);
+	}
+	void CMP_qq_l(GPR64 memReg, sint32 offset, GPR64 index, uint8 scaler, GPR64 src)
+	{
+		uint8 mod;
+		if (offset == 0 && (memReg & 7) != 5) mod = 0;
+		else if (offset == (s32)(s8)offset) mod = 1;
+		else mod = 2;
+		bool sib_use = (scaler != 0 && index != X86_REG_NONE);
+		if ((memReg & 7) == 4)
+		{
+			cemu_assert_debug(index == X86_REG_NONE);
+			index = memReg;
+			sib_use = true;
+		}
+		if (sib_use)
+		{
+			_emitU8(0x40 | ((src & 8) >> 1) | ((memReg & 8) >> 3) | ((index & 8) >> 2) | 0x08);
+		}
+		else
+		{
+			_emitU8(0x40 | ((src & 8) >> 1) | ((memReg & 8) >> 1) | 0x08);
+		}
+		_emitU8(0x39);
+		_emitU8((mod << 6) | ((src & 7) << 3) | (sib_use ? 4 : (memReg & 7)));
+		if (sib_use)
+		{
+			_emitU8((0 << 6) | ((memReg & 7)) | ((index & 7) << 3));
+		}
+		if (mod == 1) _emitU8((u8)offset);
+		else if (mod == 2) _emitU32((u32)offset);
+	}
+	void CMP_dd_r(GPR32 dst, GPR64 memReg, sint32 offset, GPR64 index, uint8 scaler)
+	{
+		uint8 mod;
+		if (offset == 0 && (memReg & 7) != 5) mod = 0;
+		else if (offset == (s32)(s8)offset) mod = 1;
+		else mod = 2;
+		bool sib_use = (scaler != 0 && index != X86_REG_NONE);
+		if ((memReg & 7) == 4)
+		{
+			cemu_assert_debug(index == X86_REG_NONE);
+			index = memReg;
+			sib_use = true;
+		}
+		if (sib_use)
+		{
+			if ((dst & 8) || (memReg & 8) || ((index != X86_REG_NONE) && (index & 8)))
+				_emitU8(0x40 | ((dst & 8) >> 1) | ((memReg & 8) >> 3) | ((index & 8) >> 2));
+		}
+		else
+		{
+			if ((dst & 8) || (memReg & 8))
+				_emitU8(0x40 | ((dst & 8) >> 1) | ((memReg & 8) >> 1));
+		}
+		_emitU8(0x3b);
+		_emitU8((mod << 6) | ((dst & 7) << 3) | (sib_use ? 4 : (memReg & 7)));
+		if (sib_use)
+		{
+			_emitU8((0 << 6) | ((memReg & 7)) | ((index & 7) << 3));
+		}
+		if (mod == 1) _emitU8((u8)offset);
+		else if (mod == 2) _emitU32((u32)offset);
+	}
+	void CMP_qq_r(GPR64 dst, GPR64 memReg, sint32 offset, GPR64 index, uint8 scaler)
+	{
+		uint8 mod;
+		if (offset == 0 && (memReg & 7) != 5) mod = 0;
+		else if (offset == (s32)(s8)offset) mod = 1;
+		else mod = 2;
+		bool sib_use = (scaler != 0 && index != X86_REG_NONE);
+		if ((memReg & 7) == 4)
+		{
+			cemu_assert_debug(index == X86_REG_NONE);
+			index = memReg;
+			sib_use = true;
+		}
+		if (sib_use)
+		{
+			_emitU8(0x40 | ((dst & 8) >> 1) | ((memReg & 8) >> 3) | ((index & 8) >> 2) | 0x08);
+		}
+		else
+		{
+			_emitU8(0x40 | ((dst & 8) >> 1) | ((memReg & 8) >> 1) | 0x08);
+		}
+		_emitU8(0x3b);
+		_emitU8((mod << 6) | ((dst & 7) << 3) | (sib_use ? 4 : (memReg & 7)));
+		if (sib_use)
+		{
+			_emitU8((0 << 6) | ((memReg & 7)) | ((index & 7) << 3));
+		}
+		if (mod == 1) _emitU8((u8)offset);
+		else if (mod == 2) _emitU32((u32)offset);
+	}
+	void ADD_di32(GPR32 dst, s32 imm)
+	{
+		if (((dst & 8) != 0))
+		{
+			_emitU8(0x40 | ((dst & 8) >> 3));
+		}
+		_emitU8(0x81);
+		_emitU8((3 << 6) | ((0 & 7) << 3) | (dst & 7));
+		_emitU32((u32)imm);
+	}
+	void ADD_qi32(GPR64 dst, s32 imm)
+	{
+		_emitU8(0x48 | ((dst & 8) >> 3));
+		_emitU8(0x81);
+		_emitU8((3 << 6) | ((0 & 7) << 3) | (dst & 7));
+		_emitU32((u32)imm);
+	}
+	void ADD_di32_l(GPR64 memReg, sint32 offset, GPR64 index, uint8 scaler, s32 imm)
+	{
+		uint8 mod;
+		if (offset == 0 && (memReg & 7) != 5) mod = 0;
+		else if (offset == (s32)(s8)offset) mod = 1;
+		else mod = 2;
+		bool sib_use = (scaler != 0 && index != X86_REG_NONE);
+		if ((memReg & 7) == 4)
+		{
+			cemu_assert_debug(index == X86_REG_NONE);
+			index = memReg;
+			sib_use = true;
+		}
+		if (sib_use)
+		{
+			if ((memReg & 8) || ((index != X86_REG_NONE) && (index & 8)))
+				_emitU8(0x40 | ((memReg & 8) >> 3) | ((index & 8) >> 2));
+		}
+		else
+		{
+			if ((memReg & 8))
+				_emitU8(0x40 | ((memReg & 8) >> 1));
+		}
+		_emitU8(0x81);
+		_emitU8((mod << 6) | ((0 & 7) << 3) | (sib_use ? 4 : (memReg & 7)));
+		if (sib_use)
+		{
+			_emitU8((0 << 6) | ((memReg & 7)) | ((index & 7) << 3));
+		}
+		if (mod == 1) _emitU8((u8)offset);
+		else if (mod == 2) _emitU32((u32)offset);
+		_emitU32((u32)imm);
+	}
+	void ADD_qi32_l(GPR64 memReg, sint32 offset, GPR64 index, uint8 scaler, s32 imm)
+	{
+		uint8 mod;
+		if (offset == 0 && (memReg & 7) != 5) mod = 0;
+		else if (offset == (s32)(s8)offset) mod = 1;
+		else mod = 2;
+		bool sib_use = (scaler != 0 && index != X86_REG_NONE);
+		if ((memReg & 7) == 4)
+		{
+			cemu_assert_debug(index == X86_REG_NONE);
+			index = memReg;
+			sib_use = true;
+		}
+		if (sib_use)
+		{
+			_emitU8(0x40 | ((memReg & 8) >> 3) | ((index & 8) >> 2) | 0x08);
+		}
+		else
+		{
+			_emitU8(0x40 | ((memReg & 8) >> 1) | 0x08);
+		}
+		_emitU8(0x81);
+		_emitU8((mod << 6) | ((0 & 7) << 3) | (sib_use ? 4 : (memReg & 7)));
+		if (sib_use)
+		{
+			_emitU8((0 << 6) | ((memReg & 7)) | ((index & 7) << 3));
+		}
+		if (mod == 1) _emitU8((u8)offset);
+		else if (mod == 2) _emitU32((u32)offset);
+		_emitU32((u32)imm);
+	}
+	void OR_di32(GPR32 dst, s32 imm)
+	{
+		if (((dst & 8) != 0))
+		{
+			_emitU8(0x40 | ((dst & 8) >> 3));
+		}
+		_emitU8(0x81);
+		_emitU8((3 << 6) | ((1 & 7) << 3) | (dst & 7));
+		_emitU32((u32)imm);
+	}
+	void OR_qi32(GPR64 dst, s32 imm)
+	{
+		_emitU8(0x48 | ((dst & 8) >> 3));
+		_emitU8(0x81);
+		_emitU8((3 << 6) | ((1 & 7) << 3) | (dst & 7));
+		_emitU32((u32)imm);
+	}
+	void OR_di32_l(GPR64 memReg, sint32 offset, GPR64 index, uint8 scaler, s32 imm)
+	{
+		uint8 mod;
+		if (offset == 0 && (memReg & 7) != 5) mod = 0;
+		else if (offset == (s32)(s8)offset) mod = 1;
+		else mod = 2;
+		bool sib_use = (scaler != 0 && index != X86_REG_NONE);
+		if ((memReg & 7) == 4)
+		{
+			cemu_assert_debug(index == X86_REG_NONE);
+			index = memReg;
+			sib_use = true;
+		}
+		if (sib_use)
+		{
+			if ((memReg & 8) || ((index != X86_REG_NONE) && (index & 8)))
+				_emitU8(0x40 | ((memReg & 8) >> 3) | ((index & 8) >> 2));
+		}
+		else
+		{
+			if ((memReg & 8))
+				_emitU8(0x40 | ((memReg & 8) >> 1));
+		}
+		_emitU8(0x81);
+		_emitU8((mod << 6) | ((1 & 7) << 3) | (sib_use ? 4 : (memReg & 7)));
+		if (sib_use)
+		{
+			_emitU8((0 << 6) | ((memReg & 7)) | ((index & 7) << 3));
+		}
+		if (mod == 1) _emitU8((u8)offset);
+		else if (mod == 2) _emitU32((u32)offset);
+		_emitU32((u32)imm);
+	}
+	void OR_qi32_l(GPR64 memReg, sint32 offset, GPR64 index, uint8 scaler, s32 imm)
+	{
+		uint8 mod;
+		if (offset == 0 && (memReg & 7) != 5) mod = 0;
+		else if (offset == (s32)(s8)offset) mod = 1;
+		else mod = 2;
+		bool sib_use = (scaler != 0 && index != X86_REG_NONE);
+		if ((memReg & 7) == 4)
+		{
+			cemu_assert_debug(index == X86_REG_NONE);
+			index = memReg;
+			sib_use = true;
+		}
+		if (sib_use)
+		{
+			_emitU8(0x40 | ((memReg & 8) >> 3) | ((index & 8) >> 2) | 0x08);
+		}
+		else
+		{
+			_emitU8(0x40 | ((memReg & 8) >> 1) | 0x08);
+		}
+		_emitU8(0x81);
+		_emitU8((mod << 6) | ((1 & 7) << 3) | (sib_use ? 4 : (memReg & 7)));
+		if (sib_use)
+		{
+			_emitU8((0 << 6) | ((memReg & 7)) | ((index & 7) << 3));
+		}
+		if (mod == 1) _emitU8((u8)offset);
+		else if (mod == 2) _emitU32((u32)offset);
+		_emitU32((u32)imm);
+	}
+	void ADC_di32(GPR32 dst, s32 imm)
+	{
+		if (((dst & 8) != 0))
+		{
+			_emitU8(0x40 | ((dst & 8) >> 3));
+		}
+		_emitU8(0x81);
+		_emitU8((3 << 6) | ((2 & 7) << 3) | (dst & 7));
+		_emitU32((u32)imm);
+	}
+	void ADC_qi32(GPR64 dst, s32 imm)
+	{
+		_emitU8(0x48 | ((dst & 8) >> 3));
+		_emitU8(0x81);
+		_emitU8((3 << 6) | ((2 & 7) << 3) | (dst & 7));
+		_emitU32((u32)imm);
+	}
+	void ADC_di32_l(GPR64 memReg, sint32 offset, GPR64 index, uint8 scaler, s32 imm)
+	{
+		uint8 mod;
+		if (offset == 0 && (memReg & 7) != 5) mod = 0;
+		else if (offset == (s32)(s8)offset) mod = 1;
+		else mod = 2;
+		bool sib_use = (scaler != 0 && index != X86_REG_NONE);
+		if ((memReg & 7) == 4)
+		{
+			cemu_assert_debug(index == X86_REG_NONE);
+			index = memReg;
+			sib_use = true;
+		}
+		if (sib_use)
+		{
+			if ((memReg & 8) || ((index != X86_REG_NONE) && (index & 8)))
+				_emitU8(0x40 | ((memReg & 8) >> 3) | ((index & 8) >> 2));
+		}
+		else
+		{
+			if ((memReg & 8))
+				_emitU8(0x40 | ((memReg & 8) >> 1));
+		}
+		_emitU8(0x81);
+		_emitU8((mod << 6) | ((2 & 7) << 3) | (sib_use ? 4 : (memReg & 7)));
+		if (sib_use)
+		{
+			_emitU8((0 << 6) | ((memReg & 7)) | ((index & 7) << 3));
+		}
+		if (mod == 1) _emitU8((u8)offset);
+		else if (mod == 2) _emitU32((u32)offset);
+		_emitU32((u32)imm);
+	}
+	void ADC_qi32_l(GPR64 memReg, sint32 offset, GPR64 index, uint8 scaler, s32 imm)
+	{
+		uint8 mod;
+		if (offset == 0 && (memReg & 7) != 5) mod = 0;
+		else if (offset == (s32)(s8)offset) mod = 1;
+		else mod = 2;
+		bool sib_use = (scaler != 0 && index != X86_REG_NONE);
+		if ((memReg & 7) == 4)
+		{
+			cemu_assert_debug(index == X86_REG_NONE);
+			index = memReg;
+			sib_use = true;
+		}
+		if (sib_use)
+		{
+			_emitU8(0x40 | ((memReg & 8) >> 3) | ((index & 8) >> 2) | 0x08);
+		}
+		else
+		{
+			_emitU8(0x40 | ((memReg & 8) >> 1) | 0x08);
+		}
+		_emitU8(0x81);
+		_emitU8((mod << 6) | ((2 & 7) << 3) | (sib_use ? 4 : (memReg & 7)));
+		if (sib_use)
+		{
+			_emitU8((0 << 6) | ((memReg & 7)) | ((index & 7) << 3));
+		}
+		if (mod == 1) _emitU8((u8)offset);
+		else if (mod == 2) _emitU32((u32)offset);
+		_emitU32((u32)imm);
+	}
+	void SBB_di32(GPR32 dst, s32 imm)
+	{
+		if (((dst & 8) != 0))
+		{
+			_emitU8(0x40 | ((dst & 8) >> 3));
+		}
+		_emitU8(0x81);
+		_emitU8((3 << 6) | ((3 & 7) << 3) | (dst & 7));
+		_emitU32((u32)imm);
+	}
+	void SBB_qi32(GPR64 dst, s32 imm)
+	{
+		_emitU8(0x48 | ((dst & 8) >> 3));
+		_emitU8(0x81);
+		_emitU8((3 << 6) | ((3 & 7) << 3) | (dst & 7));
+		_emitU32((u32)imm);
+	}
+	void SBB_di32_l(GPR64 memReg, sint32 offset, GPR64 index, uint8 scaler, s32 imm)
+	{
+		uint8 mod;
+		if (offset == 0 && (memReg & 7) != 5) mod = 0;
+		else if (offset == (s32)(s8)offset) mod = 1;
+		else mod = 2;
+		bool sib_use = (scaler != 0 && index != X86_REG_NONE);
+		if ((memReg & 7) == 4)
+		{
+			cemu_assert_debug(index == X86_REG_NONE);
+			index = memReg;
+			sib_use = true;
+		}
+		if (sib_use)
+		{
+			if ((memReg & 8) || ((index != X86_REG_NONE) && (index & 8)))
+				_emitU8(0x40 | ((memReg & 8) >> 3) | ((index & 8) >> 2));
+		}
+		else
+		{
+			if ((memReg & 8))
+				_emitU8(0x40 | ((memReg & 8) >> 1));
+		}
+		_emitU8(0x81);
+		_emitU8((mod << 6) | ((3 & 7) << 3) | (sib_use ? 4 : (memReg & 7)));
+		if (sib_use)
+		{
+			_emitU8((0 << 6) | ((memReg & 7)) | ((index & 7) << 3));
+		}
+		if (mod == 1) _emitU8((u8)offset);
+		else if (mod == 2) _emitU32((u32)offset);
+		_emitU32((u32)imm);
+	}
+	void SBB_qi32_l(GPR64 memReg, sint32 offset, GPR64 index, uint8 scaler, s32 imm)
+	{
+		uint8 mod;
+		if (offset == 0 && (memReg & 7) != 5) mod = 0;
+		else if (offset == (s32)(s8)offset) mod = 1;
+		else mod = 2;
+		bool sib_use = (scaler != 0 && index != X86_REG_NONE);
+		if ((memReg & 7) == 4)
+		{
+			cemu_assert_debug(index == X86_REG_NONE);
+			index = memReg;
+			sib_use = true;
+		}
+		if (sib_use)
+		{
+			_emitU8(0x40 | ((memReg & 8) >> 3) | ((index & 8) >> 2) | 0x08);
+		}
+		else
+		{
+			_emitU8(0x40 | ((memReg & 8) >> 1) | 0x08);
+		}
+		_emitU8(0x81);
+		_emitU8((mod << 6) | ((3 & 7) << 3) | (sib_use ? 4 : (memReg & 7)));
+		if (sib_use)
+		{
+			_emitU8((0 << 6) | ((memReg & 7)) | ((index & 7) << 3));
+		}
+		if (mod == 1) _emitU8((u8)offset);
+		else if (mod == 2) _emitU32((u32)offset);
+		_emitU32((u32)imm);
+	}
+	void AND_di32(GPR32 dst, s32 imm)
+	{
+		if (((dst & 8) != 0))
+		{
+			_emitU8(0x40 | ((dst & 8) >> 3));
+		}
+		_emitU8(0x81);
+		_emitU8((3 << 6) | ((4 & 7) << 3) | (dst & 7));
+		_emitU32((u32)imm);
+	}
+	void AND_qi32(GPR64 dst, s32 imm)
+	{
+		_emitU8(0x48 | ((dst & 8) >> 3));
+		_emitU8(0x81);
+		_emitU8((3 << 6) | ((4 & 7) << 3) | (dst & 7));
+		_emitU32((u32)imm);
+	}
+	void AND_di32_l(GPR64 memReg, sint32 offset, GPR64 index, uint8 scaler, s32 imm)
+	{
+		uint8 mod;
+		if (offset == 0 && (memReg & 7) != 5) mod = 0;
+		else if (offset == (s32)(s8)offset) mod = 1;
+		else mod = 2;
+		bool sib_use = (scaler != 0 && index != X86_REG_NONE);
+		if ((memReg & 7) == 4)
+		{
+			cemu_assert_debug(index == X86_REG_NONE);
+			index = memReg;
+			sib_use = true;
+		}
+		if (sib_use)
+		{
+			if ((memReg & 8) || ((index != X86_REG_NONE) && (index & 8)))
+				_emitU8(0x40 | ((memReg & 8) >> 3) | ((index & 8) >> 2));
+		}
+		else
+		{
+			if ((memReg & 8))
+				_emitU8(0x40 | ((memReg & 8) >> 1));
+		}
+		_emitU8(0x81);
+		_emitU8((mod << 6) | ((4 & 7) << 3) | (sib_use ? 4 : (memReg & 7)));
+		if (sib_use)
+		{
+			_emitU8((0 << 6) | ((memReg & 7)) | ((index & 7) << 3));
+		}
+		if (mod == 1) _emitU8((u8)offset);
+		else if (mod == 2) _emitU32((u32)offset);
+		_emitU32((u32)imm);
+	}
+	void AND_qi32_l(GPR64 memReg, sint32 offset, GPR64 index, uint8 scaler, s32 imm)
+	{
+		uint8 mod;
+		if (offset == 0 && (memReg & 7) != 5) mod = 0;
+		else if (offset == (s32)(s8)offset) mod = 1;
+		else mod = 2;
+		bool sib_use = (scaler != 0 && index != X86_REG_NONE);
+		if ((memReg & 7) == 4)
+		{
+			cemu_assert_debug(index == X86_REG_NONE);
+			index = memReg;
+			sib_use = true;
+		}
+		if (sib_use)
+		{
+			_emitU8(0x40 | ((memReg & 8) >> 3) | ((index & 8) >> 2) | 0x08);
+		}
+		else
+		{
+			_emitU8(0x40 | ((memReg & 8) >> 1) | 0x08);
+		}
+		_emitU8(0x81);
+		_emitU8((mod << 6) | ((4 & 7) << 3) | (sib_use ? 4 : (memReg & 7)));
+		if (sib_use)
+		{
+			_emitU8((0 << 6) | ((memReg & 7)) | ((index & 7) << 3));
+		}
+		if (mod == 1) _emitU8((u8)offset);
+		else if (mod == 2) _emitU32((u32)offset);
+		_emitU32((u32)imm);
+	}
+	void SUB_di32(GPR32 dst, s32 imm)
+	{
+		if (((dst & 8) != 0))
+		{
+			_emitU8(0x40 | ((dst & 8) >> 3));
+		}
+		_emitU8(0x81);
+		_emitU8((3 << 6) | ((5 & 7) << 3) | (dst & 7));
+		_emitU32((u32)imm);
+	}
+	void SUB_qi32(GPR64 dst, s32 imm)
+	{
+		_emitU8(0x48 | ((dst & 8) >> 3));
+		_emitU8(0x81);
+		_emitU8((3 << 6) | ((5 & 7) << 3) | (dst & 7));
+		_emitU32((u32)imm);
+	}
+	void SUB_di32_l(GPR64 memReg, sint32 offset, GPR64 index, uint8 scaler, s32 imm)
+	{
+		uint8 mod;
+		if (offset == 0 && (memReg & 7) != 5) mod = 0;
+		else if (offset == (s32)(s8)offset) mod = 1;
+		else mod = 2;
+		bool sib_use = (scaler != 0 && index != X86_REG_NONE);
+		if ((memReg & 7) == 4)
+		{
+			cemu_assert_debug(index == X86_REG_NONE);
+			index = memReg;
+			sib_use = true;
+		}
+		if (sib_use)
+		{
+			if ((memReg & 8) || ((index != X86_REG_NONE) && (index & 8)))
+				_emitU8(0x40 | ((memReg & 8) >> 3) | ((index & 8) >> 2));
+		}
+		else
+		{
+			if ((memReg & 8))
+				_emitU8(0x40 | ((memReg & 8) >> 1));
+		}
+		_emitU8(0x81);
+		_emitU8((mod << 6) | ((5 & 7) << 3) | (sib_use ? 4 : (memReg & 7)));
+		if (sib_use)
+		{
+			_emitU8((0 << 6) | ((memReg & 7)) | ((index & 7) << 3));
+		}
+		if (mod == 1) _emitU8((u8)offset);
+		else if (mod == 2) _emitU32((u32)offset);
+		_emitU32((u32)imm);
+	}
+	void SUB_qi32_l(GPR64 memReg, sint32 offset, GPR64 index, uint8 scaler, s32 imm)
+	{
+		uint8 mod;
+		if (offset == 0 && (memReg & 7) != 5) mod = 0;
+		else if (offset == (s32)(s8)offset) mod = 1;
+		else mod = 2;
+		bool sib_use = (scaler != 0 && index != X86_REG_NONE);
+		if ((memReg & 7) == 4)
+		{
+			cemu_assert_debug(index == X86_REG_NONE);
+			index = memReg;
+			sib_use = true;
+		}
+		if (sib_use)
+		{
+			_emitU8(0x40 | ((memReg & 8) >> 3) | ((index & 8) >> 2) | 0x08);
+		}
+		else
+		{
+			_emitU8(0x40 | ((memReg & 8) >> 1) | 0x08);
+		}
+		_emitU8(0x81);
+		_emitU8((mod << 6) | ((5 & 7) << 3) | (sib_use ? 4 : (memReg & 7)));
+		if (sib_use)
+		{
+			_emitU8((0 << 6) | ((memReg & 7)) | ((index & 7) << 3));
+		}
+		if (mod == 1) _emitU8((u8)offset);
+		else if (mod == 2) _emitU32((u32)offset);
+		_emitU32((u32)imm);
+	}
+	void XOR_di32(GPR32 dst, s32 imm)
+	{
+		if (((dst & 8) != 0))
+		{
+			_emitU8(0x40 | ((dst & 8) >> 3));
+		}
+		_emitU8(0x81);
+		_emitU8((3 << 6) | ((6 & 7) << 3) | (dst & 7));
+		_emitU32((u32)imm);
+	}
+	void XOR_qi32(GPR64 dst, s32 imm)
+	{
+		_emitU8(0x48 | ((dst & 8) >> 3));
+		_emitU8(0x81);
+		_emitU8((3 << 6) | ((6 & 7) << 3) | (dst & 7));
+		_emitU32((u32)imm);
+	}
+	void XOR_di32_l(GPR64 memReg, sint32 offset, GPR64 index, uint8 scaler, s32 imm)
+	{
+		uint8 mod;
+		if (offset == 0 && (memReg & 7) != 5) mod = 0;
+		else if (offset == (s32)(s8)offset) mod = 1;
+		else mod = 2;
+		bool sib_use = (scaler != 0 && index != X86_REG_NONE);
+		if ((memReg & 7) == 4)
+		{
+			cemu_assert_debug(index == X86_REG_NONE);
+			index = memReg;
+			sib_use = true;
+		}
+		if (sib_use)
+		{
+			if ((memReg & 8) || ((index != X86_REG_NONE) && (index & 8)))
+				_emitU8(0x40 | ((memReg & 8) >> 3) | ((index & 8) >> 2));
+		}
+		else
+		{
+			if ((memReg & 8))
+				_emitU8(0x40 | ((memReg & 8) >> 1));
+		}
+		_emitU8(0x81);
+		_emitU8((mod << 6) | ((6 & 7) << 3) | (sib_use ? 4 : (memReg & 7)));
+		if (sib_use)
+		{
+			_emitU8((0 << 6) | ((memReg & 7)) | ((index & 7) << 3));
+		}
+		if (mod == 1) _emitU8((u8)offset);
+		else if (mod == 2) _emitU32((u32)offset);
+		_emitU32((u32)imm);
+	}
+	void XOR_qi32_l(GPR64 memReg, sint32 offset, GPR64 index, uint8 scaler, s32 imm)
+	{
+		uint8 mod;
+		if (offset == 0 && (memReg & 7) != 5) mod = 0;
+		else if (offset == (s32)(s8)offset) mod = 1;
+		else mod = 2;
+		bool sib_use = (scaler != 0 && index != X86_REG_NONE);
+		if ((memReg & 7) == 4)
+		{
+			cemu_assert_debug(index == X86_REG_NONE);
+			index = memReg;
+			sib_use = true;
+		}
+		if (sib_use)
+		{
+			_emitU8(0x40 | ((memReg & 8) >> 3) | ((index & 8) >> 2) | 0x08);
+		}
+		else
+		{
+			_emitU8(0x40 | ((memReg & 8) >> 1) | 0x08);
+		}
+		_emitU8(0x81);
+		_emitU8((mod << 6) | ((6 & 7) << 3) | (sib_use ? 4 : (memReg & 7)));
+		if (sib_use)
+		{
+			_emitU8((0 << 6) | ((memReg & 7)) | ((index & 7) << 3));
+		}
+		if (mod == 1) _emitU8((u8)offset);
+		else if (mod == 2) _emitU32((u32)offset);
+		_emitU32((u32)imm);
+	}
+	void CMP_di32(GPR32 dst, s32 imm)
+	{
+		if (((dst & 8) != 0))
+		{
+			_emitU8(0x40 | ((dst & 8) >> 3));
+		}
+		_emitU8(0x81);
+		_emitU8((3 << 6) | ((7 & 7) << 3) | (dst & 7));
+		_emitU32((u32)imm);
+	}
+	void CMP_qi32(GPR64 dst, s32 imm)
+	{
+		_emitU8(0x48 | ((dst & 8) >> 3));
+		_emitU8(0x81);
+		_emitU8((3 << 6) | ((7 & 7) << 3) | (dst & 7));
+		_emitU32((u32)imm);
+	}
+	void CMP_di32_l(GPR64 memReg, sint32 offset, GPR64 index, uint8 scaler, s32 imm)
+	{
+		uint8 mod;
+		if (offset == 0 && (memReg & 7) != 5) mod = 0;
+		else if (offset == (s32)(s8)offset) mod = 1;
+		else mod = 2;
+		bool sib_use = (scaler != 0 && index != X86_REG_NONE);
+		if ((memReg & 7) == 4)
+		{
+			cemu_assert_debug(index == X86_REG_NONE);
+			index = memReg;
+			sib_use = true;
+		}
+		if (sib_use)
+		{
+			if ((memReg & 8) || ((index != X86_REG_NONE) && (index & 8)))
+				_emitU8(0x40 | ((memReg & 8) >> 3) | ((index & 8) >> 2));
+		}
+		else
+		{
+			if ((memReg & 8))
+				_emitU8(0x40 | ((memReg & 8) >> 1));
+		}
+		_emitU8(0x81);
+		_emitU8((mod << 6) | ((7 & 7) << 3) | (sib_use ? 4 : (memReg & 7)));
+		if (sib_use)
+		{
+			_emitU8((0 << 6) | ((memReg & 7)) | ((index & 7) << 3));
+		}
+		if (mod == 1) _emitU8((u8)offset);
+		else if (mod == 2) _emitU32((u32)offset);
+		_emitU32((u32)imm);
+	}
+	void CMP_qi32_l(GPR64 memReg, sint32 offset, GPR64 index, uint8 scaler, s32 imm)
+	{
+		uint8 mod;
+		if (offset == 0 && (memReg & 7) != 5) mod = 0;
+		else if (offset == (s32)(s8)offset) mod = 1;
+		else mod = 2;
+		bool sib_use = (scaler != 0 && index != X86_REG_NONE);
+		if ((memReg & 7) == 4)
+		{
+			cemu_assert_debug(index == X86_REG_NONE);
+			index = memReg;
+			sib_use = true;
+		}
+		if (sib_use)
+		{
+			_emitU8(0x40 | ((memReg & 8) >> 3) | ((index & 8) >> 2) | 0x08);
+		}
+		else
+		{
+			_emitU8(0x40 | ((memReg & 8) >> 1) | 0x08);
+		}
+		_emitU8(0x81);
+		_emitU8((mod << 6) | ((7 & 7) << 3) | (sib_use ? 4 : (memReg & 7)));
+		if (sib_use)
+		{
+			_emitU8((0 << 6) | ((memReg & 7)) | ((index & 7) << 3));
+		}
+		if (mod == 1) _emitU8((u8)offset);
+		else if (mod == 2) _emitU32((u32)offset);
+		_emitU32((u32)imm);
+	}
+	void ADD_di8(GPR32 dst, s8 imm)
+	{
+		if (((dst & 8) != 0))
+		{
+			_emitU8(0x40 | ((dst & 8) >> 3));
+		}
+		_emitU8(0x83);
+		_emitU8((3 << 6) | ((0 & 7) << 3) | (dst & 7));
+		_emitU8((u8)imm);
+	}
+	void ADD_qi8(GPR64 dst, s8 imm)
+	{
+		_emitU8(0x48 | ((dst & 8) >> 3));
+		_emitU8(0x83);
+		_emitU8((3 << 6) | ((0 & 7) << 3) | (dst & 7));
+		_emitU8((u8)imm);
+	}
+	void ADD_di8_l(GPR64 memReg, sint32 offset, GPR64 index, uint8 scaler, s8 imm)
+	{
+		uint8 mod;
+		if (offset == 0 && (memReg & 7) != 5) mod = 0;
+		else if (offset == (s32)(s8)offset) mod = 1;
+		else mod = 2;
+		bool sib_use = (scaler != 0 && index != X86_REG_NONE);
+		if ((memReg & 7) == 4)
+		{
+			cemu_assert_debug(index == X86_REG_NONE);
+			index = memReg;
+			sib_use = true;
+		}
+		if (sib_use)
+		{
+			if ((memReg & 8) || ((index != X86_REG_NONE) && (index & 8)))
+				_emitU8(0x40 | ((memReg & 8) >> 3) | ((index & 8) >> 2));
+		}
+		else
+		{
+			if ((memReg & 8))
+				_emitU8(0x40 | ((memReg & 8) >> 1));
+		}
+		_emitU8(0x83);
+		_emitU8((mod << 6) | ((0 & 7) << 3) | (sib_use ? 4 : (memReg & 7)));
+		if (sib_use)
+		{
+			_emitU8((0 << 6) | ((memReg & 7)) | ((index & 7) << 3));
+		}
+		if (mod == 1) _emitU8((u8)offset);
+		else if (mod == 2) _emitU32((u32)offset);
+		_emitU8((u8)imm);
+	}
+	void ADD_qi8_l(GPR64 memReg, sint32 offset, GPR64 index, uint8 scaler, s8 imm)
+	{
+		uint8 mod;
+		if (offset == 0 && (memReg & 7) != 5) mod = 0;
+		else if (offset == (s32)(s8)offset) mod = 1;
+		else mod = 2;
+		bool sib_use = (scaler != 0 && index != X86_REG_NONE);
+		if ((memReg & 7) == 4)
+		{
+			cemu_assert_debug(index == X86_REG_NONE);
+			index = memReg;
+			sib_use = true;
+		}
+		if (sib_use)
+		{
+			_emitU8(0x40 | ((memReg & 8) >> 3) | ((index & 8) >> 2) | 0x08);
+		}
+		else
+		{
+			_emitU8(0x40 | ((memReg & 8) >> 1) | 0x08);
+		}
+		_emitU8(0x83);
+		_emitU8((mod << 6) | ((0 & 7) << 3) | (sib_use ? 4 : (memReg & 7)));
+		if (sib_use)
+		{
+			_emitU8((0 << 6) | ((memReg & 7)) | ((index & 7) << 3));
+		}
+		if (mod == 1) _emitU8((u8)offset);
+		else if (mod == 2) _emitU32((u32)offset);
+		_emitU8((u8)imm);
+	}
+	void OR_di8(GPR32 dst, s8 imm)
+	{
+		if (((dst & 8) != 0))
+		{
+			_emitU8(0x40 | ((dst & 8) >> 3));
+		}
+		_emitU8(0x83);
+		_emitU8((3 << 6) | ((1 & 7) << 3) | (dst & 7));
+		_emitU8((u8)imm);
+	}
+	void OR_qi8(GPR64 dst, s8 imm)
+	{
+		_emitU8(0x48 | ((dst & 8) >> 3));
+		_emitU8(0x83);
+		_emitU8((3 << 6) | ((1 & 7) << 3) | (dst & 7));
+		_emitU8((u8)imm);
+	}
+	void OR_di8_l(GPR64 memReg, sint32 offset, GPR64 index, uint8 scaler, s8 imm)
+	{
+		uint8 mod;
+		if (offset == 0 && (memReg & 7) != 5) mod = 0;
+		else if (offset == (s32)(s8)offset) mod = 1;
+		else mod = 2;
+		bool sib_use = (scaler != 0 && index != X86_REG_NONE);
+		if ((memReg & 7) == 4)
+		{
+			cemu_assert_debug(index == X86_REG_NONE);
+			index = memReg;
+			sib_use = true;
+		}
+		if (sib_use)
+		{
+			if ((memReg & 8) || ((index != X86_REG_NONE) && (index & 8)))
+				_emitU8(0x40 | ((memReg & 8) >> 3) | ((index & 8) >> 2));
+		}
+		else
+		{
+			if ((memReg & 8))
+				_emitU8(0x40 | ((memReg & 8) >> 1));
+		}
+		_emitU8(0x83);
+		_emitU8((mod << 6) | ((1 & 7) << 3) | (sib_use ? 4 : (memReg & 7)));
+		if (sib_use)
+		{
+			_emitU8((0 << 6) | ((memReg & 7)) | ((index & 7) << 3));
+		}
+		if (mod == 1) _emitU8((u8)offset);
+		else if (mod == 2) _emitU32((u32)offset);
+		_emitU8((u8)imm);
+	}
+	void OR_qi8_l(GPR64 memReg, sint32 offset, GPR64 index, uint8 scaler, s8 imm)
+	{
+		uint8 mod;
+		if (offset == 0 && (memReg & 7) != 5) mod = 0;
+		else if (offset == (s32)(s8)offset) mod = 1;
+		else mod = 2;
+		bool sib_use = (scaler != 0 && index != X86_REG_NONE);
+		if ((memReg & 7) == 4)
+		{
+			cemu_assert_debug(index == X86_REG_NONE);
+			index = memReg;
+			sib_use = true;
+		}
+		if (sib_use)
+		{
+			_emitU8(0x40 | ((memReg & 8) >> 3) | ((index & 8) >> 2) | 0x08);
+		}
+		else
+		{
+			_emitU8(0x40 | ((memReg & 8) >> 1) | 0x08);
+		}
+		_emitU8(0x83);
+		_emitU8((mod << 6) | ((1 & 7) << 3) | (sib_use ? 4 : (memReg & 7)));
+		if (sib_use)
+		{
+			_emitU8((0 << 6) | ((memReg & 7)) | ((index & 7) << 3));
+		}
+		if (mod == 1) _emitU8((u8)offset);
+		else if (mod == 2) _emitU32((u32)offset);
+		_emitU8((u8)imm);
+	}
+	void ADC_di8(GPR32 dst, s8 imm)
+	{
+		if (((dst & 8) != 0))
+		{
+			_emitU8(0x40 | ((dst & 8) >> 3));
+		}
+		_emitU8(0x83);
+		_emitU8((3 << 6) | ((2 & 7) << 3) | (dst & 7));
+		_emitU8((u8)imm);
+	}
+	void ADC_qi8(GPR64 dst, s8 imm)
+	{
+		_emitU8(0x48 | ((dst & 8) >> 3));
+		_emitU8(0x83);
+		_emitU8((3 << 6) | ((2 & 7) << 3) | (dst & 7));
+		_emitU8((u8)imm);
+	}
+	void ADC_di8_l(GPR64 memReg, sint32 offset, GPR64 index, uint8 scaler, s8 imm)
+	{
+		uint8 mod;
+		if (offset == 0 && (memReg & 7) != 5) mod = 0;
+		else if (offset == (s32)(s8)offset) mod = 1;
+		else mod = 2;
+		bool sib_use = (scaler != 0 && index != X86_REG_NONE);
+		if ((memReg & 7) == 4)
+		{
+			cemu_assert_debug(index == X86_REG_NONE);
+			index = memReg;
+			sib_use = true;
+		}
+		if (sib_use)
+		{
+			if ((memReg & 8) || ((index != X86_REG_NONE) && (index & 8)))
+				_emitU8(0x40 | ((memReg & 8) >> 3) | ((index & 8) >> 2));
+		}
+		else
+		{
+			if ((memReg & 8))
+				_emitU8(0x40 | ((memReg & 8) >> 1));
+		}
+		_emitU8(0x83);
+		_emitU8((mod << 6) | ((2 & 7) << 3) | (sib_use ? 4 : (memReg & 7)));
+		if (sib_use)
+		{
+			_emitU8((0 << 6) | ((memReg & 7)) | ((index & 7) << 3));
+		}
+		if (mod == 1) _emitU8((u8)offset);
+		else if (mod == 2) _emitU32((u32)offset);
+		_emitU8((u8)imm);
+	}
+	void ADC_qi8_l(GPR64 memReg, sint32 offset, GPR64 index, uint8 scaler, s8 imm)
+	{
+		uint8 mod;
+		if (offset == 0 && (memReg & 7) != 5) mod = 0;
+		else if (offset == (s32)(s8)offset) mod = 1;
+		else mod = 2;
+		bool sib_use = (scaler != 0 && index != X86_REG_NONE);
+		if ((memReg & 7) == 4)
+		{
+			cemu_assert_debug(index == X86_REG_NONE);
+			index = memReg;
+			sib_use = true;
+		}
+		if (sib_use)
+		{
+			_emitU8(0x40 | ((memReg & 8) >> 3) | ((index & 8) >> 2) | 0x08);
+		}
+		else
+		{
+			_emitU8(0x40 | ((memReg & 8) >> 1) | 0x08);
+		}
+		_emitU8(0x83);
+		_emitU8((mod << 6) | ((2 & 7) << 3) | (sib_use ? 4 : (memReg & 7)));
+		if (sib_use)
+		{
+			_emitU8((0 << 6) | ((memReg & 7)) | ((index & 7) << 3));
+		}
+		if (mod == 1) _emitU8((u8)offset);
+		else if (mod == 2) _emitU32((u32)offset);
+		_emitU8((u8)imm);
+	}
+	void SBB_di8(GPR32 dst, s8 imm)
+	{
+		if (((dst & 8) != 0))
+		{
+			_emitU8(0x40 | ((dst & 8) >> 3));
+		}
+		_emitU8(0x83);
+		_emitU8((3 << 6) | ((3 & 7) << 3) | (dst & 7));
+		_emitU8((u8)imm);
+	}
+	void SBB_qi8(GPR64 dst, s8 imm)
+	{
+		_emitU8(0x48 | ((dst & 8) >> 3));
+		_emitU8(0x83);
+		_emitU8((3 << 6) | ((3 & 7) << 3) | (dst & 7));
+		_emitU8((u8)imm);
+	}
+	void SBB_di8_l(GPR64 memReg, sint32 offset, GPR64 index, uint8 scaler, s8 imm)
+	{
+		uint8 mod;
+		if (offset == 0 && (memReg & 7) != 5) mod = 0;
+		else if (offset == (s32)(s8)offset) mod = 1;
+		else mod = 2;
+		bool sib_use = (scaler != 0 && index != X86_REG_NONE);
+		if ((memReg & 7) == 4)
+		{
+			cemu_assert_debug(index == X86_REG_NONE);
+			index = memReg;
+			sib_use = true;
+		}
+		if (sib_use)
+		{
+			if ((memReg & 8) || ((index != X86_REG_NONE) && (index & 8)))
+				_emitU8(0x40 | ((memReg & 8) >> 3) | ((index & 8) >> 2));
+		}
+		else
+		{
+			if ((memReg & 8))
+				_emitU8(0x40 | ((memReg & 8) >> 1));
+		}
+		_emitU8(0x83);
+		_emitU8((mod << 6) | ((3 & 7) << 3) | (sib_use ? 4 : (memReg & 7)));
+		if (sib_use)
+		{
+			_emitU8((0 << 6) | ((memReg & 7)) | ((index & 7) << 3));
+		}
+		if (mod == 1) _emitU8((u8)offset);
+		else if (mod == 2) _emitU32((u32)offset);
+		_emitU8((u8)imm);
+	}
+	void SBB_qi8_l(GPR64 memReg, sint32 offset, GPR64 index, uint8 scaler, s8 imm)
+	{
+		uint8 mod;
+		if (offset == 0 && (memReg & 7) != 5) mod = 0;
+		else if (offset == (s32)(s8)offset) mod = 1;
+		else mod = 2;
+		bool sib_use = (scaler != 0 && index != X86_REG_NONE);
+		if ((memReg & 7) == 4)
+		{
+			cemu_assert_debug(index == X86_REG_NONE);
+			index = memReg;
+			sib_use = true;
+		}
+		if (sib_use)
+		{
+			_emitU8(0x40 | ((memReg & 8) >> 3) | ((index & 8) >> 2) | 0x08);
+		}
+		else
+		{
+			_emitU8(0x40 | ((memReg & 8) >> 1) | 0x08);
+		}
+		_emitU8(0x83);
+		_emitU8((mod << 6) | ((3 & 7) << 3) | (sib_use ? 4 : (memReg & 7)));
+		if (sib_use)
+		{
+			_emitU8((0 << 6) | ((memReg & 7)) | ((index & 7) << 3));
+		}
+		if (mod == 1) _emitU8((u8)offset);
+		else if (mod == 2) _emitU32((u32)offset);
+		_emitU8((u8)imm);
+	}
+	void AND_di8(GPR32 dst, s8 imm)
+	{
+		if (((dst & 8) != 0))
+		{
+			_emitU8(0x40 | ((dst & 8) >> 3));
+		}
+		_emitU8(0x83);
+		_emitU8((3 << 6) | ((4 & 7) << 3) | (dst & 7));
+		_emitU8((u8)imm);
+	}
+	void AND_qi8(GPR64 dst, s8 imm)
+	{
+		_emitU8(0x48 | ((dst & 8) >> 3));
+		_emitU8(0x83);
+		_emitU8((3 << 6) | ((4 & 7) << 3) | (dst & 7));
+		_emitU8((u8)imm);
+	}
+	void AND_di8_l(GPR64 memReg, sint32 offset, GPR64 index, uint8 scaler, s8 imm)
+	{
+		uint8 mod;
+		if (offset == 0 && (memReg & 7) != 5) mod = 0;
+		else if (offset == (s32)(s8)offset) mod = 1;
+		else mod = 2;
+		bool sib_use = (scaler != 0 && index != X86_REG_NONE);
+		if ((memReg & 7) == 4)
+		{
+			cemu_assert_debug(index == X86_REG_NONE);
+			index = memReg;
+			sib_use = true;
+		}
+		if (sib_use)
+		{
+			if ((memReg & 8) || ((index != X86_REG_NONE) && (index & 8)))
+				_emitU8(0x40 | ((memReg & 8) >> 3) | ((index & 8) >> 2));
+		}
+		else
+		{
+			if ((memReg & 8))
+				_emitU8(0x40 | ((memReg & 8) >> 1));
+		}
+		_emitU8(0x83);
+		_emitU8((mod << 6) | ((4 & 7) << 3) | (sib_use ? 4 : (memReg & 7)));
+		if (sib_use)
+		{
+			_emitU8((0 << 6) | ((memReg & 7)) | ((index & 7) << 3));
+		}
+		if (mod == 1) _emitU8((u8)offset);
+		else if (mod == 2) _emitU32((u32)offset);
+		_emitU8((u8)imm);
+	}
+	void AND_qi8_l(GPR64 memReg, sint32 offset, GPR64 index, uint8 scaler, s8 imm)
+	{
+		uint8 mod;
+		if (offset == 0 && (memReg & 7) != 5) mod = 0;
+		else if (offset == (s32)(s8)offset) mod = 1;
+		else mod = 2;
+		bool sib_use = (scaler != 0 && index != X86_REG_NONE);
+		if ((memReg & 7) == 4)
+		{
+			cemu_assert_debug(index == X86_REG_NONE);
+			index = memReg;
+			sib_use = true;
+		}
+		if (sib_use)
+		{
+			_emitU8(0x40 | ((memReg & 8) >> 3) | ((index & 8) >> 2) | 0x08);
+		}
+		else
+		{
+			_emitU8(0x40 | ((memReg & 8) >> 1) | 0x08);
+		}
+		_emitU8(0x83);
+		_emitU8((mod << 6) | ((4 & 7) << 3) | (sib_use ? 4 : (memReg & 7)));
+		if (sib_use)
+		{
+			_emitU8((0 << 6) | ((memReg & 7)) | ((index & 7) << 3));
+		}
+		if (mod == 1) _emitU8((u8)offset);
+		else if (mod == 2) _emitU32((u32)offset);
+		_emitU8((u8)imm);
+	}
+	void SUB_di8(GPR32 dst, s8 imm)
+	{
+		if (((dst & 8) != 0))
+		{
+			_emitU8(0x40 | ((dst & 8) >> 3));
+		}
+		_emitU8(0x83);
+		_emitU8((3 << 6) | ((5 & 7) << 3) | (dst & 7));
+		_emitU8((u8)imm);
+	}
+	void SUB_qi8(GPR64 dst, s8 imm)
+	{
+		_emitU8(0x48 | ((dst & 8) >> 3));
+		_emitU8(0x83);
+		_emitU8((3 << 6) | ((5 & 7) << 3) | (dst & 7));
+		_emitU8((u8)imm);
+	}
+	void SUB_di8_l(GPR64 memReg, sint32 offset, GPR64 index, uint8 scaler, s8 imm)
+	{
+		uint8 mod;
+		if (offset == 0 && (memReg & 7) != 5) mod = 0;
+		else if (offset == (s32)(s8)offset) mod = 1;
+		else mod = 2;
+		bool sib_use = (scaler != 0 && index != X86_REG_NONE);
+		if ((memReg & 7) == 4)
+		{
+			cemu_assert_debug(index == X86_REG_NONE);
+			index = memReg;
+			sib_use = true;
+		}
+		if (sib_use)
+		{
+			if ((memReg & 8) || ((index != X86_REG_NONE) && (index & 8)))
+				_emitU8(0x40 | ((memReg & 8) >> 3) | ((index & 8) >> 2));
+		}
+		else
+		{
+			if ((memReg & 8))
+				_emitU8(0x40 | ((memReg & 8) >> 1));
+		}
+		_emitU8(0x83);
+		_emitU8((mod << 6) | ((5 & 7) << 3) | (sib_use ? 4 : (memReg & 7)));
+		if (sib_use)
+		{
+			_emitU8((0 << 6) | ((memReg & 7)) | ((index & 7) << 3));
+		}
+		if (mod == 1) _emitU8((u8)offset);
+		else if (mod == 2) _emitU32((u32)offset);
+		_emitU8((u8)imm);
+	}
+	void SUB_qi8_l(GPR64 memReg, sint32 offset, GPR64 index, uint8 scaler, s8 imm)
+	{
+		uint8 mod;
+		if (offset == 0 && (memReg & 7) != 5) mod = 0;
+		else if (offset == (s32)(s8)offset) mod = 1;
+		else mod = 2;
+		bool sib_use = (scaler != 0 && index != X86_REG_NONE);
+		if ((memReg & 7) == 4)
+		{
+			cemu_assert_debug(index == X86_REG_NONE);
+			index = memReg;
+			sib_use = true;
+		}
+		if (sib_use)
+		{
+			_emitU8(0x40 | ((memReg & 8) >> 3) | ((index & 8) >> 2) | 0x08);
+		}
+		else
+		{
+			_emitU8(0x40 | ((memReg & 8) >> 1) | 0x08);
+		}
+		_emitU8(0x83);
+		_emitU8((mod << 6) | ((5 & 7) << 3) | (sib_use ? 4 : (memReg & 7)));
+		if (sib_use)
+		{
+			_emitU8((0 << 6) | ((memReg & 7)) | ((index & 7) << 3));
+		}
+		if (mod == 1) _emitU8((u8)offset);
+		else if (mod == 2) _emitU32((u32)offset);
+		_emitU8((u8)imm);
+	}
+	void XOR_di8(GPR32 dst, s8 imm)
+	{
+		if (((dst & 8) != 0))
+		{
+			_emitU8(0x40 | ((dst & 8) >> 3));
+		}
+		_emitU8(0x83);
+		_emitU8((3 << 6) | ((6 & 7) << 3) | (dst & 7));
+		_emitU8((u8)imm);
+	}
+	void XOR_qi8(GPR64 dst, s8 imm)
+	{
+		_emitU8(0x48 | ((dst & 8) >> 3));
+		_emitU8(0x83);
+		_emitU8((3 << 6) | ((6 & 7) << 3) | (dst & 7));
+		_emitU8((u8)imm);
+	}
+	void XOR_di8_l(GPR64 memReg, sint32 offset, GPR64 index, uint8 scaler, s8 imm)
+	{
+		uint8 mod;
+		if (offset == 0 && (memReg & 7) != 5) mod = 0;
+		else if (offset == (s32)(s8)offset) mod = 1;
+		else mod = 2;
+		bool sib_use = (scaler != 0 && index != X86_REG_NONE);
+		if ((memReg & 7) == 4)
+		{
+			cemu_assert_debug(index == X86_REG_NONE);
+			index = memReg;
+			sib_use = true;
+		}
+		if (sib_use)
+		{
+			if ((memReg & 8) || ((index != X86_REG_NONE) && (index & 8)))
+				_emitU8(0x40 | ((memReg & 8) >> 3) | ((index & 8) >> 2));
+		}
+		else
+		{
+			if ((memReg & 8))
+				_emitU8(0x40 | ((memReg & 8) >> 1));
+		}
+		_emitU8(0x83);
+		_emitU8((mod << 6) | ((6 & 7) << 3) | (sib_use ? 4 : (memReg & 7)));
+		if (sib_use)
+		{
+			_emitU8((0 << 6) | ((memReg & 7)) | ((index & 7) << 3));
+		}
+		if (mod == 1) _emitU8((u8)offset);
+		else if (mod == 2) _emitU32((u32)offset);
+		_emitU8((u8)imm);
+	}
+	void XOR_qi8_l(GPR64 memReg, sint32 offset, GPR64 index, uint8 scaler, s8 imm)
+	{
+		uint8 mod;
+		if (offset == 0 && (memReg & 7) != 5) mod = 0;
+		else if (offset == (s32)(s8)offset) mod = 1;
+		else mod = 2;
+		bool sib_use = (scaler != 0 && index != X86_REG_NONE);
+		if ((memReg & 7) == 4)
+		{
+			cemu_assert_debug(index == X86_REG_NONE);
+			index = memReg;
+			sib_use = true;
+		}
+		if (sib_use)
+		{
+			_emitU8(0x40 | ((memReg & 8) >> 3) | ((index & 8) >> 2) | 0x08);
+		}
+		else
+		{
+			_emitU8(0x40 | ((memReg & 8) >> 1) | 0x08);
+		}
+		_emitU8(0x83);
+		_emitU8((mod << 6) | ((6 & 7) << 3) | (sib_use ? 4 : (memReg & 7)));
+		if (sib_use)
+		{
+			_emitU8((0 << 6) | ((memReg & 7)) | ((index & 7) << 3));
+		}
+		if (mod == 1) _emitU8((u8)offset);
+		else if (mod == 2) _emitU32((u32)offset);
+		_emitU8((u8)imm);
+	}
+	void CMP_di8(GPR32 dst, s8 imm)
+	{
+		if (((dst & 8) != 0))
+		{
+			_emitU8(0x40 | ((dst & 8) >> 3));
+		}
+		_emitU8(0x83);
+		_emitU8((3 << 6) | ((7 & 7) << 3) | (dst & 7));
+		_emitU8((u8)imm);
+	}
+	void CMP_qi8(GPR64 dst, s8 imm)
+	{
+		_emitU8(0x48 | ((dst & 8) >> 3));
+		_emitU8(0x83);
+		_emitU8((3 << 6) | ((7 & 7) << 3) | (dst & 7));
+		_emitU8((u8)imm);
+	}
+	void CMP_di8_l(GPR64 memReg, sint32 offset, GPR64 index, uint8 scaler, s8 imm)
+	{
+		uint8 mod;
+		if (offset == 0 && (memReg & 7) != 5) mod = 0;
+		else if (offset == (s32)(s8)offset) mod = 1;
+		else mod = 2;
+		bool sib_use = (scaler != 0 && index != X86_REG_NONE);
+		if ((memReg & 7) == 4)
+		{
+			cemu_assert_debug(index == X86_REG_NONE);
+			index = memReg;
+			sib_use = true;
+		}
+		if (sib_use)
+		{
+			if ((memReg & 8) || ((index != X86_REG_NONE) && (index & 8)))
+				_emitU8(0x40 | ((memReg & 8) >> 3) | ((index & 8) >> 2));
+		}
+		else
+		{
+			if ((memReg & 8))
+				_emitU8(0x40 | ((memReg & 8) >> 1));
+		}
+		_emitU8(0x83);
+		_emitU8((mod << 6) | ((7 & 7) << 3) | (sib_use ? 4 : (memReg & 7)));
+		if (sib_use)
+		{
+			_emitU8((0 << 6) | ((memReg & 7)) | ((index & 7) << 3));
+		}
+		if (mod == 1) _emitU8((u8)offset);
+		else if (mod == 2) _emitU32((u32)offset);
+		_emitU8((u8)imm);
+	}
+	void CMP_qi8_l(GPR64 memReg, sint32 offset, GPR64 index, uint8 scaler, s8 imm)
+	{
+		uint8 mod;
+		if (offset == 0 && (memReg & 7) != 5) mod = 0;
+		else if (offset == (s32)(s8)offset) mod = 1;
+		else mod = 2;
+		bool sib_use = (scaler != 0 && index != X86_REG_NONE);
+		if ((memReg & 7) == 4)
+		{
+			cemu_assert_debug(index == X86_REG_NONE);
+			index = memReg;
+			sib_use = true;
+		}
+		if (sib_use)
+		{
+			_emitU8(0x40 | ((memReg & 8) >> 3) | ((index & 8) >> 2) | 0x08);
+		}
+		else
+		{
+			_emitU8(0x40 | ((memReg & 8) >> 1) | 0x08);
+		}
+		_emitU8(0x83);
+		_emitU8((mod << 6) | ((7 & 7) << 3) | (sib_use ? 4 : (memReg & 7)));
+		if (sib_use)
+		{
+			_emitU8((0 << 6) | ((memReg & 7)) | ((index & 7) << 3));
+		}
+		if (mod == 1) _emitU8((u8)offset);
+		else if (mod == 2) _emitU32((u32)offset);
+		_emitU8((u8)imm);
+	}
+	void TEST_bb(GPR8_REX dst, GPR8_REX src)
+	{
+		if ((src >= 4) || (dst >= 4))
+		{
+			_emitU8(0x40 | ((dst & 8) >> 3) | ((src & 8) >> 1));
+		}
+		_emitU8(0x84);
+		_emitU8((3 << 6) | ((src & 7) << 3) | (dst & 7));
+	}
+	void TEST_bb_l(GPR64 memReg, sint32 offset, GPR64 index, uint8 scaler, GPR8_REX src)
+	{
+		uint8 mod;
+		if (offset == 0 && (memReg & 7) != 5) mod = 0;
+		else if (offset == (s32)(s8)offset) mod = 1;
+		else mod = 2;
+		bool sib_use = (scaler != 0 && index != X86_REG_NONE);
+		if ((memReg & 7) == 4)
+		{
+			cemu_assert_debug(index == X86_REG_NONE);
+			index = memReg;
+			sib_use = true;
+		}
+		if (sib_use)
+		{
+			if ((src >= 4) || (memReg & 8) || ((index != X86_REG_NONE) && (index & 8)))
+				_emitU8(0x40 | ((src & 8) >> 1) | ((memReg & 8) >> 3) | ((index & 8) >> 2));
+		}
+		else
+		{
+			if ((src >= 4) || (memReg & 8))
+				_emitU8(0x40 | ((src & 8) >> 1) | ((memReg & 8) >> 1));
+		}
+		_emitU8(0x84);
+		_emitU8((mod << 6) | ((src & 7) << 3) | (sib_use ? 4 : (memReg & 7)));
+		if (sib_use)
+		{
+			_emitU8((0 << 6) | ((memReg & 7)) | ((index & 7) << 3));
+		}
+		if (mod == 1) _emitU8((u8)offset);
+		else if (mod == 2) _emitU32((u32)offset);
+	}
+	void TEST_dd(GPR32 dst, GPR32 src)
+	{
+		if (((src & 8) != 0) || ((dst & 8) != 0))
+		{
+			_emitU8(0x40 | ((dst & 8) >> 3) | ((src & 8) >> 1));
+		}
+		_emitU8(0x85);
+		_emitU8((3 << 6) | ((src & 7) << 3) | (dst & 7));
+	}
+	void TEST_qq(GPR64 dst, GPR64 src)
+	{
+		_emitU8(0x48 | ((dst & 8) >> 3) | ((src & 8) >> 1));
+		_emitU8(0x85);
+		_emitU8((3 << 6) | ((src & 7) << 3) | (dst & 7));
+	}
+	void TEST_dd_l(GPR64 memReg, sint32 offset, GPR64 index, uint8 scaler, GPR32 src)
+	{
+		uint8 mod;
+		if (offset == 0 && (memReg & 7) != 5) mod = 0;
+		else if (offset == (s32)(s8)offset) mod = 1;
+		else mod = 2;
+		bool sib_use = (scaler != 0 && index != X86_REG_NONE);
+		if ((memReg & 7) == 4)
+		{
+			cemu_assert_debug(index == X86_REG_NONE);
+			index = memReg;
+			sib_use = true;
+		}
+		if (sib_use)
+		{
+			if ((src & 8) || (memReg & 8) || ((index != X86_REG_NONE) && (index & 8)))
+				_emitU8(0x40 | ((src & 8) >> 1) | ((memReg & 8) >> 3) | ((index & 8) >> 2));
+		}
+		else
+		{
+			if ((src & 8) || (memReg & 8))
+				_emitU8(0x40 | ((src & 8) >> 1) | ((memReg & 8) >> 1));
+		}
+		_emitU8(0x85);
+		_emitU8((mod << 6) | ((src & 7) << 3) | (sib_use ? 4 : (memReg & 7)));
+		if (sib_use)
+		{
+			_emitU8((0 << 6) | ((memReg & 7)) | ((index & 7) << 3));
+		}
+		if (mod == 1) _emitU8((u8)offset);
+		else if (mod == 2) _emitU32((u32)offset);
+	}
+	void TEST_qq_l(GPR64 memReg, sint32 offset, GPR64 index, uint8 scaler, GPR64 src)
+	{
+		uint8 mod;
+		if (offset == 0 && (memReg & 7) != 5) mod = 0;
+		else if (offset == (s32)(s8)offset) mod = 1;
+		else mod = 2;
+		bool sib_use = (scaler != 0 && index != X86_REG_NONE);
+		if ((memReg & 7) == 4)
+		{
+			cemu_assert_debug(index == X86_REG_NONE);
+			index = memReg;
+			sib_use = true;
+		}
+		if (sib_use)
+		{
+			_emitU8(0x40 | ((src & 8) >> 1) | ((memReg & 8) >> 3) | ((index & 8) >> 2) | 0x08);
+		}
+		else
+		{
+			_emitU8(0x40 | ((src & 8) >> 1) | ((memReg & 8) >> 1) | 0x08);
+		}
+		_emitU8(0x85);
+		_emitU8((mod << 6) | ((src & 7) << 3) | (sib_use ? 4 : (memReg & 7)));
+		if (sib_use)
+		{
+			_emitU8((0 << 6) | ((memReg & 7)) | ((index & 7) << 3));
+		}
+		if (mod == 1) _emitU8((u8)offset);
+		else if (mod == 2) _emitU32((u32)offset);
+	}
+	void XCHG_bb(GPR8_REX dst, GPR8_REX src)
+	{
+		if ((dst >= 4) || (src >= 4))
+		{
+			_emitU8(0x40 | ((src & 8) >> 3) | ((dst & 8) >> 1));
+		}
+		_emitU8(0x86);
+		_emitU8((3 << 6) | ((dst & 7) << 3) | (src & 7));
+	}
+	void XCHG_bb_r(GPR8_REX dst, GPR64 memReg, sint32 offset, GPR64 index, uint8 scaler)
+	{
+		uint8 mod;
+		if (offset == 0 && (memReg & 7) != 5) mod = 0;
+		else if (offset == (s32)(s8)offset) mod = 1;
+		else mod = 2;
+		bool sib_use = (scaler != 0 && index != X86_REG_NONE);
+		if ((memReg & 7) == 4)
+		{
+			cemu_assert_debug(index == X86_REG_NONE);
+			index = memReg;
+			sib_use = true;
+		}
+		if (sib_use)
+		{
+			if ((dst >= 4) || (memReg & 8) || ((index != X86_REG_NONE) && (index & 8)))
+				_emitU8(0x40 | ((dst & 8) >> 1) | ((memReg & 8) >> 3) | ((index & 8) >> 2));
+		}
+		else
+		{
+			if ((dst >= 4) || (memReg & 8))
+				_emitU8(0x40 | ((dst & 8) >> 1) | ((memReg & 8) >> 1));
+		}
+		_emitU8(0x86);
+		_emitU8((mod << 6) | ((dst & 7) << 3) | (sib_use ? 4 : (memReg & 7)));
+		if (sib_use)
+		{
+			_emitU8((0 << 6) | ((memReg & 7)) | ((index & 7) << 3));
+		}
+		if (mod == 1) _emitU8((u8)offset);
+		else if (mod == 2) _emitU32((u32)offset);
+	}
+	void XCHG_dd(GPR32 dst, GPR32 src)
+	{
+		if (((dst & 8) != 0) || ((src & 8) != 0))
+		{
+			_emitU8(0x40 | ((src & 8) >> 3) | ((dst & 8) >> 1));
+		}
+		_emitU8(0x87);
+		_emitU8((3 << 6) | ((dst & 7) << 3) | (src & 7));
+	}
+	void XCHG_qq(GPR64 dst, GPR64 src)
+	{
+		_emitU8(0x48 | ((src & 8) >> 3) | ((dst & 8) >> 1));
+		_emitU8(0x87);
+		_emitU8((3 << 6) | ((dst & 7) << 3) | (src & 7));
+	}
+	void XCHG_dd_r(GPR32 dst, GPR64 memReg, sint32 offset, GPR64 index, uint8 scaler)
+	{
+		uint8 mod;
+		if (offset == 0 && (memReg & 7) != 5) mod = 0;
+		else if (offset == (s32)(s8)offset) mod = 1;
+		else mod = 2;
+		bool sib_use = (scaler != 0 && index != X86_REG_NONE);
+		if ((memReg & 7) == 4)
+		{
+			cemu_assert_debug(index == X86_REG_NONE);
+			index = memReg;
+			sib_use = true;
+		}
+		if (sib_use)
+		{
+			if ((dst & 8) || (memReg & 8) || ((index != X86_REG_NONE) && (index & 8)))
+				_emitU8(0x40 | ((dst & 8) >> 1) | ((memReg & 8) >> 3) | ((index & 8) >> 2));
+		}
+		else
+		{
+			if ((dst & 8) || (memReg & 8))
+				_emitU8(0x40 | ((dst & 8) >> 1) | ((memReg & 8) >> 1));
+		}
+		_emitU8(0x87);
+		_emitU8((mod << 6) | ((dst & 7) << 3) | (sib_use ? 4 : (memReg & 7)));
+		if (sib_use)
+		{
+			_emitU8((0 << 6) | ((memReg & 7)) | ((index & 7) << 3));
+		}
+		if (mod == 1) _emitU8((u8)offset);
+		else if (mod == 2) _emitU32((u32)offset);
+	}
+	void XCHG_qq_r(GPR64 dst, GPR64 memReg, sint32 offset, GPR64 index, uint8 scaler)
+	{
+		uint8 mod;
+		if (offset == 0 && (memReg & 7) != 5) mod = 0;
+		else if (offset == (s32)(s8)offset) mod = 1;
+		else mod = 2;
+		bool sib_use = (scaler != 0 && index != X86_REG_NONE);
+		if ((memReg & 7) == 4)
+		{
+			cemu_assert_debug(index == X86_REG_NONE);
+			index = memReg;
+			sib_use = true;
+		}
+		if (sib_use)
+		{
+			_emitU8(0x40 | ((dst & 8) >> 1) | ((memReg & 8) >> 3) | ((index & 8) >> 2) | 0x08);
+		}
+		else
+		{
+			_emitU8(0x40 | ((dst & 8) >> 1) | ((memReg & 8) >> 1) | 0x08);
+		}
+		_emitU8(0x87);
+		_emitU8((mod << 6) | ((dst & 7) << 3) | (sib_use ? 4 : (memReg & 7)));
+		if (sib_use)
+		{
+			_emitU8((0 << 6) | ((memReg & 7)) | ((index & 7) << 3));
+		}
+		if (mod == 1) _emitU8((u8)offset);
+		else if (mod == 2) _emitU32((u32)offset);
+	}
+	void MOV_bb(GPR8_REX dst, GPR8_REX src)
+	{
+		if ((src >= 4) || (dst >= 4))
+		{
+			_emitU8(0x40 | ((dst & 8) >> 3) | ((src & 8) >> 1));
+		}
+		_emitU8(0x88);
+		_emitU8((3 << 6) | ((src & 7) << 3) | (dst & 7));
+	}
+	void MOV_bb_l(GPR64 memReg, sint32 offset, GPR64 index, uint8 scaler, GPR8_REX src)
+	{
+		uint8 mod;
+		if (offset == 0 && (memReg & 7) != 5) mod = 0;
+		else if (offset == (s32)(s8)offset) mod = 1;
+		else mod = 2;
+		bool sib_use = (scaler != 0 && index != X86_REG_NONE);
+		if ((memReg & 7) == 4)
+		{
+			cemu_assert_debug(index == X86_REG_NONE);
+			index = memReg;
+			sib_use = true;
+		}
+		if (sib_use)
+		{
+			if ((src >= 4) || (memReg & 8) || ((index != X86_REG_NONE) && (index & 8)))
+				_emitU8(0x40 | ((src & 8) >> 1) | ((memReg & 8) >> 3) | ((index & 8) >> 2));
+		}
+		else
+		{
+			if ((src >= 4) || (memReg & 8))
+				_emitU8(0x40 | ((src & 8) >> 1) | ((memReg & 8) >> 1));
+		}
+		_emitU8(0x88);
+		_emitU8((mod << 6) | ((src & 7) << 3) | (sib_use ? 4 : (memReg & 7)));
+		if (sib_use)
+		{
+			_emitU8((0 << 6) | ((memReg & 7)) | ((index & 7) << 3));
+		}
+		if (mod == 1) _emitU8((u8)offset);
+		else if (mod == 2) _emitU32((u32)offset);
+	}
+	void MOV_bb_r(GPR8_REX dst, GPR64 memReg, sint32 offset, GPR64 index, uint8 scaler)
+	{
+		uint8 mod;
+		if (offset == 0 && (memReg & 7) != 5) mod = 0;
+		else if (offset == (s32)(s8)offset) mod = 1;
+		else mod = 2;
+		bool sib_use = (scaler != 0 && index != X86_REG_NONE);
+		if ((memReg & 7) == 4)
+		{
+			cemu_assert_debug(index == X86_REG_NONE);
+			index = memReg;
+			sib_use = true;
+		}
+		if (sib_use)
+		{
+			if ((dst >= 4) || (memReg & 8) || ((index != X86_REG_NONE) && (index & 8)))
+				_emitU8(0x40 | ((dst & 8) >> 1) | ((memReg & 8) >> 3) | ((index & 8) >> 2));
+		}
+		else
+		{
+			if ((dst >= 4) || (memReg & 8))
+				_emitU8(0x40 | ((dst & 8) >> 1) | ((memReg & 8) >> 1));
+		}
+		_emitU8(0x8a);
+		_emitU8((mod << 6) | ((dst & 7) << 3) | (sib_use ? 4 : (memReg & 7)));
+		if (sib_use)
+		{
+			_emitU8((0 << 6) | ((memReg & 7)) | ((index & 7) << 3));
+		}
+		if (mod == 1) _emitU8((u8)offset);
+		else if (mod == 2) _emitU32((u32)offset);
+	}
+	void MOV_dd(GPR32 dst, GPR32 src)
+	{
+		if (((src & 8) != 0) || ((dst & 8) != 0))
+		{
+			_emitU8(0x40 | ((dst & 8) >> 3) | ((src & 8) >> 1));
+		}
+		_emitU8(0x89);
+		_emitU8((3 << 6) | ((src & 7) << 3) | (dst & 7));
+	}
+	void MOV_qq(GPR64 dst, GPR64 src)
+	{
+		_emitU8(0x48 | ((dst & 8) >> 3) | ((src & 8) >> 1));
+		_emitU8(0x89);
+		_emitU8((3 << 6) | ((src & 7) << 3) | (dst & 7));
+	}
+	void MOV_dd_l(GPR64 memReg, sint32 offset, GPR64 index, uint8 scaler, GPR32 src)
+	{
+		uint8 mod;
+		if (offset == 0 && (memReg & 7) != 5) mod = 0;
+		else if (offset == (s32)(s8)offset) mod = 1;
+		else mod = 2;
+		bool sib_use = (scaler != 0 && index != X86_REG_NONE);
+		if ((memReg & 7) == 4)
+		{
+			cemu_assert_debug(index == X86_REG_NONE);
+			index = memReg;
+			sib_use = true;
+		}
+		if (sib_use)
+		{
+			if ((src & 8) || (memReg & 8) || ((index != X86_REG_NONE) && (index & 8)))
+				_emitU8(0x40 | ((src & 8) >> 1) | ((memReg & 8) >> 3) | ((index & 8) >> 2));
+		}
+		else
+		{
+			if ((src & 8) || (memReg & 8))
+				_emitU8(0x40 | ((src & 8) >> 1) | ((memReg & 8) >> 1));
+		}
+		_emitU8(0x89);
+		_emitU8((mod << 6) | ((src & 7) << 3) | (sib_use ? 4 : (memReg & 7)));
+		if (sib_use)
+		{
+			_emitU8((0 << 6) | ((memReg & 7)) | ((index & 7) << 3));
+		}
+		if (mod == 1) _emitU8((u8)offset);
+		else if (mod == 2) _emitU32((u32)offset);
+	}
+	void MOV_qq_l(GPR64 memReg, sint32 offset, GPR64 index, uint8 scaler, GPR64 src)
+	{
+		uint8 mod;
+		if (offset == 0 && (memReg & 7) != 5) mod = 0;
+		else if (offset == (s32)(s8)offset) mod = 1;
+		else mod = 2;
+		bool sib_use = (scaler != 0 && index != X86_REG_NONE);
+		if ((memReg & 7) == 4)
+		{
+			cemu_assert_debug(index == X86_REG_NONE);
+			index = memReg;
+			sib_use = true;
+		}
+		if (sib_use)
+		{
+			_emitU8(0x40 | ((src & 8) >> 1) | ((memReg & 8) >> 3) | ((index & 8) >> 2) | 0x08);
+		}
+		else
+		{
+			_emitU8(0x40 | ((src & 8) >> 1) | ((memReg & 8) >> 1) | 0x08);
+		}
+		_emitU8(0x89);
+		_emitU8((mod << 6) | ((src & 7) << 3) | (sib_use ? 4 : (memReg & 7)));
+		if (sib_use)
+		{
+			_emitU8((0 << 6) | ((memReg & 7)) | ((index & 7) << 3));
+		}
+		if (mod == 1) _emitU8((u8)offset);
+		else if (mod == 2) _emitU32((u32)offset);
+	}
+	void MOV_dd_r(GPR32 dst, GPR64 memReg, sint32 offset, GPR64 index, uint8 scaler)
+	{
+		uint8 mod;
+		if (offset == 0 && (memReg & 7) != 5) mod = 0;
+		else if (offset == (s32)(s8)offset) mod = 1;
+		else mod = 2;
+		bool sib_use = (scaler != 0 && index != X86_REG_NONE);
+		if ((memReg & 7) == 4)
+		{
+			cemu_assert_debug(index == X86_REG_NONE);
+			index = memReg;
+			sib_use = true;
+		}
+		if (sib_use)
+		{
+			if ((dst & 8) || (memReg & 8) || ((index != X86_REG_NONE) && (index & 8)))
+				_emitU8(0x40 | ((dst & 8) >> 1) | ((memReg & 8) >> 3) | ((index & 8) >> 2));
+		}
+		else
+		{
+			if ((dst & 8) || (memReg & 8))
+				_emitU8(0x40 | ((dst & 8) >> 1) | ((memReg & 8) >> 1));
+		}
+		_emitU8(0x8b);
+		_emitU8((mod << 6) | ((dst & 7) << 3) | (sib_use ? 4 : (memReg & 7)));
+		if (sib_use)
+		{
+			_emitU8((0 << 6) | ((memReg & 7)) | ((index & 7) << 3));
+		}
+		if (mod == 1) _emitU8((u8)offset);
+		else if (mod == 2) _emitU32((u32)offset);
+	}
+	void MOV_qq_r(GPR64 dst, GPR64 memReg, sint32 offset, GPR64 index, uint8 scaler)
+	{
+		uint8 mod;
+		if (offset == 0 && (memReg & 7) != 5) mod = 0;
+		else if (offset == (s32)(s8)offset) mod = 1;
+		else mod = 2;
+		bool sib_use = (scaler != 0 && index != X86_REG_NONE);
+		if ((memReg & 7) == 4)
+		{
+			cemu_assert_debug(index == X86_REG_NONE);
+			index = memReg;
+			sib_use = true;
+		}
+		if (sib_use)
+		{
+			_emitU8(0x40 | ((dst & 8) >> 1) | ((memReg & 8) >> 3) | ((index & 8) >> 2) | 0x08);
+		}
+		else
+		{
+			_emitU8(0x40 | ((dst & 8) >> 1) | ((memReg & 8) >> 1) | 0x08);
+		}
+		_emitU8(0x8b);
+		_emitU8((mod << 6) | ((dst & 7) << 3) | (sib_use ? 4 : (memReg & 7)));
+		if (sib_use)
+		{
+			_emitU8((0 << 6) | ((memReg & 7)) | ((index & 7) << 3));
+		}
+		if (mod == 1) _emitU8((u8)offset);
+		else if (mod == 2) _emitU32((u32)offset);
+	}
+	void MOV_di32(GPR32 dst, s32 imm)
+	{
+		if (((dst & 8) != 0))
+		{
+			_emitU8(0x40 | ((dst & 8) >> 3));
+		}
+		_emitU8(0xb8 | ((dst) & 7));
+		_emitU32((u32)imm);
+	}
+	void MOV_qi64(GPR64 dst, s64 imm)
+	{
+		_emitU8(0x48 | ((dst & 8) >> 3));
+		_emitU8(0xb8 | ((dst) & 7));
+		_emitU64((u64)imm);
+	}
+	void CALL_q(GPR64 dst)
+	{
+		if (((dst & 8) != 0))
+		{
+			_emitU8(0x40 | ((dst & 8) >> 3));
+		}
+		_emitU8(0xff);
+		_emitU8((3 << 6) | ((2 & 7) << 3) | (dst & 7));
+	}
+	void CALL_q_l(GPR64 memReg, sint32 offset, GPR64 index, uint8 scaler)
+	{
+		uint8 mod;
+		if (offset == 0 && (memReg & 7) != 5) mod = 0;
+		else if (offset == (s32)(s8)offset) mod = 1;
+		else mod = 2;
+		bool sib_use = (scaler != 0 && index != X86_REG_NONE);
+		if ((memReg & 7) == 4)
+		{
+			cemu_assert_debug(index == X86_REG_NONE);
+			index = memReg;
+			sib_use = true;
+		}
+		if (sib_use)
+		{
+			if ((memReg & 8) || ((index != X86_REG_NONE) && (index & 8)))
+				_emitU8(0x40 | ((memReg & 8) >> 3) | ((index & 8) >> 2));
+		}
+		else
+		{
+			if ((memReg & 8))
+				_emitU8(0x40 | ((memReg & 8) >> 1));
+		}
+		_emitU8(0xff);
+		_emitU8((mod << 6) | ((2 & 7) << 3) | (sib_use ? 4 : (memReg & 7)));
+		if (sib_use)
+		{
+			_emitU8((0 << 6) | ((memReg & 7)) | ((index & 7) << 3));
+		}
+		if (mod == 1) _emitU8((u8)offset);
+		else if (mod == 2) _emitU32((u32)offset);
+	}
+	void IMUL_ddi32(GPR32 dst, GPR32 src, s32 imm)
+	{
+		if (((dst & 8) != 0) || ((src & 8) != 0))
+		{
+			_emitU8(0x40 | ((src & 8) >> 3) | ((dst & 8) >> 1));
+		}
+		_emitU8(0x69);
+		_emitU8((3 << 6) | ((dst & 7) << 3) | (src & 7));
+		_emitU32((u32)imm);
+	}
+	void IMUL_qqi32(GPR64 dst, GPR64 src, s32 imm)
+	{
+		_emitU8(0x48 | ((src & 8) >> 3) | ((dst & 8) >> 1));
+		_emitU8(0x69);
+		_emitU8((3 << 6) | ((dst & 7) << 3) | (src & 7));
+		_emitU32((u32)imm);
+	}
+	void IMUL_ddi32_r(GPR32 dst, GPR64 memReg, sint32 offset, GPR64 index, uint8 scaler, s32 imm)
+	{
+		uint8 mod;
+		if (offset == 0 && (memReg & 7) != 5) mod = 0;
+		else if (offset == (s32)(s8)offset) mod = 1;
+		else mod = 2;
+		bool sib_use = (scaler != 0 && index != X86_REG_NONE);
+		if ((memReg & 7) == 4)
+		{
+			cemu_assert_debug(index == X86_REG_NONE);
+			index = memReg;
+			sib_use = true;
+		}
+		if (sib_use)
+		{
+			if ((dst & 8) || (memReg & 8) || ((index != X86_REG_NONE) && (index & 8)))
+				_emitU8(0x40 | ((dst & 8) >> 1) | ((memReg & 8) >> 3) | ((index & 8) >> 2));
+		}
+		else
+		{
+			if ((dst & 8) || (memReg & 8))
+				_emitU8(0x40 | ((dst & 8) >> 1) | ((memReg & 8) >> 1));
+		}
+		_emitU8(0x69);
+		_emitU8((mod << 6) | ((dst & 7) << 3) | (sib_use ? 4 : (memReg & 7)));
+		if (sib_use)
+		{
+			_emitU8((0 << 6) | ((memReg & 7)) | ((index & 7) << 3));
+		}
+		if (mod == 1) _emitU8((u8)offset);
+		else if (mod == 2) _emitU32((u32)offset);
+		_emitU32((u32)imm);
+	}
+	void IMUL_qqi32_r(GPR64 dst, GPR64 memReg, sint32 offset, GPR64 index, uint8 scaler, s32 imm)
+	{
+		uint8 mod;
+		if (offset == 0 && (memReg & 7) != 5) mod = 0;
+		else if (offset == (s32)(s8)offset) mod = 1;
+		else mod = 2;
+		bool sib_use = (scaler != 0 && index != X86_REG_NONE);
+		if ((memReg & 7) == 4)
+		{
+			cemu_assert_debug(index == X86_REG_NONE);
+			index = memReg;
+			sib_use = true;
+		}
+		if (sib_use)
+		{
+			_emitU8(0x40 | ((dst & 8) >> 1) | ((memReg & 8) >> 3) | ((index & 8) >> 2) | 0x08);
+		}
+		else
+		{
+			_emitU8(0x40 | ((dst & 8) >> 1) | ((memReg & 8) >> 1) | 0x08);
+		}
+		_emitU8(0x69);
+		_emitU8((mod << 6) | ((dst & 7) << 3) | (sib_use ? 4 : (memReg & 7)));
+		if (sib_use)
+		{
+			_emitU8((0 << 6) | ((memReg & 7)) | ((index & 7) << 3));
+		}
+		if (mod == 1) _emitU8((u8)offset);
+		else if (mod == 2) _emitU32((u32)offset);
+		_emitU32((u32)imm);
+	}
+	void IMUL_ddi8(GPR32 dst, GPR32 src, s8 imm)
+	{
+		if (((dst & 8) != 0) || ((src & 8) != 0))
+		{
+			_emitU8(0x40 | ((src & 8) >> 3) | ((dst & 8) >> 1));
+		}
+		_emitU8(0x6b);
+		_emitU8((3 << 6) | ((dst & 7) << 3) | (src & 7));
+		_emitU8((u8)imm);
+	}
+	void IMUL_qqi8(GPR64 dst, GPR64 src, s8 imm)
+	{
+		_emitU8(0x48 | ((src & 8) >> 3) | ((dst & 8) >> 1));
+		_emitU8(0x6b);
+		_emitU8((3 << 6) | ((dst & 7) << 3) | (src & 7));
+		_emitU8((u8)imm);
+	}
+	void IMUL_ddi8_r(GPR32 dst, GPR64 memReg, sint32 offset, GPR64 index, uint8 scaler, s8 imm)
+	{
+		uint8 mod;
+		if (offset == 0 && (memReg & 7) != 5) mod = 0;
+		else if (offset == (s32)(s8)offset) mod = 1;
+		else mod = 2;
+		bool sib_use = (scaler != 0 && index != X86_REG_NONE);
+		if ((memReg & 7) == 4)
+		{
+			cemu_assert_debug(index == X86_REG_NONE);
+			index = memReg;
+			sib_use = true;
+		}
+		if (sib_use)
+		{
+			if ((dst & 8) || (memReg & 8) || ((index != X86_REG_NONE) && (index & 8)))
+				_emitU8(0x40 | ((dst & 8) >> 1) | ((memReg & 8) >> 3) | ((index & 8) >> 2));
+		}
+		else
+		{
+			if ((dst & 8) || (memReg & 8))
+				_emitU8(0x40 | ((dst & 8) >> 1) | ((memReg & 8) >> 1));
+		}
+		_emitU8(0x6b);
+		_emitU8((mod << 6) | ((dst & 7) << 3) | (sib_use ? 4 : (memReg & 7)));
+		if (sib_use)
+		{
+			_emitU8((0 << 6) | ((memReg & 7)) | ((index & 7) << 3));
+		}
+		if (mod == 1) _emitU8((u8)offset);
+		else if (mod == 2) _emitU32((u32)offset);
+		_emitU8((u8)imm);
+	}
+	void IMUL_qqi8_r(GPR64 dst, GPR64 memReg, sint32 offset, GPR64 index, uint8 scaler, s8 imm)
+	{
+		uint8 mod;
+		if (offset == 0 && (memReg & 7) != 5) mod = 0;
+		else if (offset == (s32)(s8)offset) mod = 1;
+		else mod = 2;
+		bool sib_use = (scaler != 0 && index != X86_REG_NONE);
+		if ((memReg & 7) == 4)
+		{
+			cemu_assert_debug(index == X86_REG_NONE);
+			index = memReg;
+			sib_use = true;
+		}
+		if (sib_use)
+		{
+			_emitU8(0x40 | ((dst & 8) >> 1) | ((memReg & 8) >> 3) | ((index & 8) >> 2) | 0x08);
+		}
+		else
+		{
+			_emitU8(0x40 | ((dst & 8) >> 1) | ((memReg & 8) >> 1) | 0x08);
+		}
+		_emitU8(0x6b);
+		_emitU8((mod << 6) | ((dst & 7) << 3) | (sib_use ? 4 : (memReg & 7)));
+		if (sib_use)
+		{
+			_emitU8((0 << 6) | ((memReg & 7)) | ((index & 7) << 3));
+		}
+		if (mod == 1) _emitU8((u8)offset);
+		else if (mod == 2) _emitU32((u32)offset);
+		_emitU8((u8)imm);
+	}
+	void SHL_b_CL(GPR8_REX dst)
+	{
+		if ((dst >= 4))
+		{
+			_emitU8(0x40 | ((dst & 8) >> 3));
+		}
+		_emitU8(0xd2);
+		_emitU8((3 << 6) | ((4 & 7) << 3) | (dst & 7));
+	}
+	void SHL_b_CL_l(GPR64 memReg, sint32 offset, GPR64 index, uint8 scaler)
+	{
+		uint8 mod;
+		if (offset == 0 && (memReg & 7) != 5) mod = 0;
+		else if (offset == (s32)(s8)offset) mod = 1;
+		else mod = 2;
+		bool sib_use = (scaler != 0 && index != X86_REG_NONE);
+		if ((memReg & 7) == 4)
+		{
+			cemu_assert_debug(index == X86_REG_NONE);
+			index = memReg;
+			sib_use = true;
+		}
+		if (sib_use)
+		{
+			if ((memReg & 8) || ((index != X86_REG_NONE) && (index & 8)))
+				_emitU8(0x40 | ((memReg & 8) >> 3) | ((index & 8) >> 2));
+		}
+		else
+		{
+			if ((memReg & 8))
+				_emitU8(0x40 | ((memReg & 8) >> 1));
+		}
+		_emitU8(0xd2);
+		_emitU8((mod << 6) | ((4 & 7) << 3) | (sib_use ? 4 : (memReg & 7)));
+		if (sib_use)
+		{
+			_emitU8((0 << 6) | ((memReg & 7)) | ((index & 7) << 3));
+		}
+		if (mod == 1) _emitU8((u8)offset);
+		else if (mod == 2) _emitU32((u32)offset);
+	}
+	void SHR_b_CL(GPR8_REX dst)
+	{
+		if ((dst >= 4))
+		{
+			_emitU8(0x40 | ((dst & 8) >> 3));
+		}
+		_emitU8(0xd2);
+		_emitU8((3 << 6) | ((5 & 7) << 3) | (dst & 7));
+	}
+	void SHR_b_CL_l(GPR64 memReg, sint32 offset, GPR64 index, uint8 scaler)
+	{
+		uint8 mod;
+		if (offset == 0 && (memReg & 7) != 5) mod = 0;
+		else if (offset == (s32)(s8)offset) mod = 1;
+		else mod = 2;
+		bool sib_use = (scaler != 0 && index != X86_REG_NONE);
+		if ((memReg & 7) == 4)
+		{
+			cemu_assert_debug(index == X86_REG_NONE);
+			index = memReg;
+			sib_use = true;
+		}
+		if (sib_use)
+		{
+			if ((memReg & 8) || ((index != X86_REG_NONE) && (index & 8)))
+				_emitU8(0x40 | ((memReg & 8) >> 3) | ((index & 8) >> 2));
+		}
+		else
+		{
+			if ((memReg & 8))
+				_emitU8(0x40 | ((memReg & 8) >> 1));
+		}
+		_emitU8(0xd2);
+		_emitU8((mod << 6) | ((5 & 7) << 3) | (sib_use ? 4 : (memReg & 7)));
+		if (sib_use)
+		{
+			_emitU8((0 << 6) | ((memReg & 7)) | ((index & 7) << 3));
+		}
+		if (mod == 1) _emitU8((u8)offset);
+		else if (mod == 2) _emitU32((u32)offset);
+	}
+	void SAR_b_CL(GPR8_REX dst)
+	{
+		if ((dst >= 4))
+		{
+			_emitU8(0x40 | ((dst & 8) >> 3));
+		}
+		_emitU8(0xd2);
+		_emitU8((3 << 6) | ((7 & 7) << 3) | (dst & 7));
+	}
+	void SAR_b_CL_l(GPR64 memReg, sint32 offset, GPR64 index, uint8 scaler)
+	{
+		uint8 mod;
+		if (offset == 0 && (memReg & 7) != 5) mod = 0;
+		else if (offset == (s32)(s8)offset) mod = 1;
+		else mod = 2;
+		bool sib_use = (scaler != 0 && index != X86_REG_NONE);
+		if ((memReg & 7) == 4)
+		{
+			cemu_assert_debug(index == X86_REG_NONE);
+			index = memReg;
+			sib_use = true;
+		}
+		if (sib_use)
+		{
+			if ((memReg & 8) || ((index != X86_REG_NONE) && (index & 8)))
+				_emitU8(0x40 | ((memReg & 8) >> 3) | ((index & 8) >> 2));
+		}
+		else
+		{
+			if ((memReg & 8))
+				_emitU8(0x40 | ((memReg & 8) >> 1));
+		}
+		_emitU8(0xd2);
+		_emitU8((mod << 6) | ((7 & 7) << 3) | (sib_use ? 4 : (memReg & 7)));
+		if (sib_use)
+		{
+			_emitU8((0 << 6) | ((memReg & 7)) | ((index & 7) << 3));
+		}
+		if (mod == 1) _emitU8((u8)offset);
+		else if (mod == 2) _emitU32((u32)offset);
+	}
+	void SHL_d_CL(GPR32 dst)
+	{
+		if (((dst & 8) != 0))
+		{
+			_emitU8(0x40 | ((dst & 8) >> 3));
+		}
+		_emitU8(0xd3);
+		_emitU8((3 << 6) | ((4 & 7) << 3) | (dst & 7));
+	}
+	void SHL_q_CL(GPR64 dst)
+	{
+		_emitU8(0x48 | ((dst & 8) >> 3));
+		_emitU8(0xd3);
+		_emitU8((3 << 6) | ((4 & 7) << 3) | (dst & 7));
+	}
+	void SHL_d_CL_l(GPR64 memReg, sint32 offset, GPR64 index, uint8 scaler)
+	{
+		uint8 mod;
+		if (offset == 0 && (memReg & 7) != 5) mod = 0;
+		else if (offset == (s32)(s8)offset) mod = 1;
+		else mod = 2;
+		bool sib_use = (scaler != 0 && index != X86_REG_NONE);
+		if ((memReg & 7) == 4)
+		{
+			cemu_assert_debug(index == X86_REG_NONE);
+			index = memReg;
+			sib_use = true;
+		}
+		if (sib_use)
+		{
+			if ((memReg & 8) || ((index != X86_REG_NONE) && (index & 8)))
+				_emitU8(0x40 | ((memReg & 8) >> 3) | ((index & 8) >> 2));
+		}
+		else
+		{
+			if ((memReg & 8))
+				_emitU8(0x40 | ((memReg & 8) >> 1));
+		}
+		_emitU8(0xd3);
+		_emitU8((mod << 6) | ((4 & 7) << 3) | (sib_use ? 4 : (memReg & 7)));
+		if (sib_use)
+		{
+			_emitU8((0 << 6) | ((memReg & 7)) | ((index & 7) << 3));
+		}
+		if (mod == 1) _emitU8((u8)offset);
+		else if (mod == 2) _emitU32((u32)offset);
+	}
+	void SHL_q_CL_l(GPR64 memReg, sint32 offset, GPR64 index, uint8 scaler)
+	{
+		uint8 mod;
+		if (offset == 0 && (memReg & 7) != 5) mod = 0;
+		else if (offset == (s32)(s8)offset) mod = 1;
+		else mod = 2;
+		bool sib_use = (scaler != 0 && index != X86_REG_NONE);
+		if ((memReg & 7) == 4)
+		{
+			cemu_assert_debug(index == X86_REG_NONE);
+			index = memReg;
+			sib_use = true;
+		}
+		if (sib_use)
+		{
+			_emitU8(0x40 | ((memReg & 8) >> 3) | ((index & 8) >> 2) | 0x08);
+		}
+		else
+		{
+			_emitU8(0x40 | ((memReg & 8) >> 1) | 0x08);
+		}
+		_emitU8(0xd3);
+		_emitU8((mod << 6) | ((4 & 7) << 3) | (sib_use ? 4 : (memReg & 7)));
+		if (sib_use)
+		{
+			_emitU8((0 << 6) | ((memReg & 7)) | ((index & 7) << 3));
+		}
+		if (mod == 1) _emitU8((u8)offset);
+		else if (mod == 2) _emitU32((u32)offset);
+	}
+	void SHR_d_CL(GPR32 dst)
+	{
+		if (((dst & 8) != 0))
+		{
+			_emitU8(0x40 | ((dst & 8) >> 3));
+		}
+		_emitU8(0xd3);
+		_emitU8((3 << 6) | ((5 & 7) << 3) | (dst & 7));
+	}
+	void SHR_q_CL(GPR64 dst)
+	{
+		_emitU8(0x48 | ((dst & 8) >> 3));
+		_emitU8(0xd3);
+		_emitU8((3 << 6) | ((5 & 7) << 3) | (dst & 7));
+	}
+	void SHR_d_CL_l(GPR64 memReg, sint32 offset, GPR64 index, uint8 scaler)
+	{
+		uint8 mod;
+		if (offset == 0 && (memReg & 7) != 5) mod = 0;
+		else if (offset == (s32)(s8)offset) mod = 1;
+		else mod = 2;
+		bool sib_use = (scaler != 0 && index != X86_REG_NONE);
+		if ((memReg & 7) == 4)
+		{
+			cemu_assert_debug(index == X86_REG_NONE);
+			index = memReg;
+			sib_use = true;
+		}
+		if (sib_use)
+		{
+			if ((memReg & 8) || ((index != X86_REG_NONE) && (index & 8)))
+				_emitU8(0x40 | ((memReg & 8) >> 3) | ((index & 8) >> 2));
+		}
+		else
+		{
+			if ((memReg & 8))
+				_emitU8(0x40 | ((memReg & 8) >> 1));
+		}
+		_emitU8(0xd3);
+		_emitU8((mod << 6) | ((5 & 7) << 3) | (sib_use ? 4 : (memReg & 7)));
+		if (sib_use)
+		{
+			_emitU8((0 << 6) | ((memReg & 7)) | ((index & 7) << 3));
+		}
+		if (mod == 1) _emitU8((u8)offset);
+		else if (mod == 2) _emitU32((u32)offset);
+	}
+	void SHR_q_CL_l(GPR64 memReg, sint32 offset, GPR64 index, uint8 scaler)
+	{
+		uint8 mod;
+		if (offset == 0 && (memReg & 7) != 5) mod = 0;
+		else if (offset == (s32)(s8)offset) mod = 1;
+		else mod = 2;
+		bool sib_use = (scaler != 0 && index != X86_REG_NONE);
+		if ((memReg & 7) == 4)
+		{
+			cemu_assert_debug(index == X86_REG_NONE);
+			index = memReg;
+			sib_use = true;
+		}
+		if (sib_use)
+		{
+			_emitU8(0x40 | ((memReg & 8) >> 3) | ((index & 8) >> 2) | 0x08);
+		}
+		else
+		{
+			_emitU8(0x40 | ((memReg & 8) >> 1) | 0x08);
+		}
+		_emitU8(0xd3);
+		_emitU8((mod << 6) | ((5 & 7) << 3) | (sib_use ? 4 : (memReg & 7)));
+		if (sib_use)
+		{
+			_emitU8((0 << 6) | ((memReg & 7)) | ((index & 7) << 3));
+		}
+		if (mod == 1) _emitU8((u8)offset);
+		else if (mod == 2) _emitU32((u32)offset);
+	}
+	void SAR_d_CL(GPR32 dst)
+	{
+		if (((dst & 8) != 0))
+		{
+			_emitU8(0x40 | ((dst & 8) >> 3));
+		}
+		_emitU8(0xd3);
+		_emitU8((3 << 6) | ((7 & 7) << 3) | (dst & 7));
+	}
+	void SAR_q_CL(GPR64 dst)
+	{
+		_emitU8(0x48 | ((dst & 8) >> 3));
+		_emitU8(0xd3);
+		_emitU8((3 << 6) | ((7 & 7) << 3) | (dst & 7));
+	}
+	void SAR_d_CL_l(GPR64 memReg, sint32 offset, GPR64 index, uint8 scaler)
+	{
+		uint8 mod;
+		if (offset == 0 && (memReg & 7) != 5) mod = 0;
+		else if (offset == (s32)(s8)offset) mod = 1;
+		else mod = 2;
+		bool sib_use = (scaler != 0 && index != X86_REG_NONE);
+		if ((memReg & 7) == 4)
+		{
+			cemu_assert_debug(index == X86_REG_NONE);
+			index = memReg;
+			sib_use = true;
+		}
+		if (sib_use)
+		{
+			if ((memReg & 8) || ((index != X86_REG_NONE) && (index & 8)))
+				_emitU8(0x40 | ((memReg & 8) >> 3) | ((index & 8) >> 2));
+		}
+		else
+		{
+			if ((memReg & 8))
+				_emitU8(0x40 | ((memReg & 8) >> 1));
+		}
+		_emitU8(0xd3);
+		_emitU8((mod << 6) | ((7 & 7) << 3) | (sib_use ? 4 : (memReg & 7)));
+		if (sib_use)
+		{
+			_emitU8((0 << 6) | ((memReg & 7)) | ((index & 7) << 3));
+		}
+		if (mod == 1) _emitU8((u8)offset);
+		else if (mod == 2) _emitU32((u32)offset);
+	}
+	void SAR_q_CL_l(GPR64 memReg, sint32 offset, GPR64 index, uint8 scaler)
+	{
+		uint8 mod;
+		if (offset == 0 && (memReg & 7) != 5) mod = 0;
+		else if (offset == (s32)(s8)offset) mod = 1;
+		else mod = 2;
+		bool sib_use = (scaler != 0 && index != X86_REG_NONE);
+		if ((memReg & 7) == 4)
+		{
+			cemu_assert_debug(index == X86_REG_NONE);
+			index = memReg;
+			sib_use = true;
+		}
+		if (sib_use)
+		{
+			_emitU8(0x40 | ((memReg & 8) >> 3) | ((index & 8) >> 2) | 0x08);
+		}
+		else
+		{
+			_emitU8(0x40 | ((memReg & 8) >> 1) | 0x08);
+		}
+		_emitU8(0xd3);
+		_emitU8((mod << 6) | ((7 & 7) << 3) | (sib_use ? 4 : (memReg & 7)));
+		if (sib_use)
+		{
+			_emitU8((0 << 6) | ((memReg & 7)) | ((index & 7) << 3));
+		}
+		if (mod == 1) _emitU8((u8)offset);
+		else if (mod == 2) _emitU32((u32)offset);
+	}
+	void JMP_j32(s32 imm)
+	{
+		_emitU8(0xe9);
+		_emitU32((u32)imm);
+	}
+	void Jcc_j32(X86Cond cond, s32 imm)
+	{
+		_emitU8(0x0f);
+		_emitU8(0x80 | (u8)cond);
+		_emitU32((u32)imm);
+	}
+	void SETcc_b(X86Cond cond, GPR8_REX dst)
+	{
+		if ((dst >= 4))
+		{
+			_emitU8(0x40 | ((dst & 8) >> 3));
+		}
+		_emitU8(0x0f);
+		_emitU8(0x90 | (u8)cond);
+		_emitU8((3 << 6) | (dst & 7));
+	}
+	void SETcc_b_l(X86Cond cond, GPR64 memReg, sint32 offset, GPR64 index, uint8 scaler)
+	{
+		uint8 mod;
+		if (offset == 0 && (memReg & 7) != 5) mod = 0;
+		else if (offset == (s32)(s8)offset) mod = 1;
+		else mod = 2;
+		bool sib_use = (scaler != 0 && index != X86_REG_NONE);
+		if ((memReg & 7) == 4)
+		{
+			cemu_assert_debug(index == X86_REG_NONE);
+			index = memReg;
+			sib_use = true;
+		}
+		if (sib_use)
+		{
+			if ((memReg & 8) || ((index != X86_REG_NONE) && (index & 8)))
+				_emitU8(0x40 | ((memReg & 8) >> 3) | ((index & 8) >> 2));
+		}
+		else
+		{
+			if ((memReg & 8))
+				_emitU8(0x40 | ((memReg & 8) >> 1));
+		}
+		_emitU8(0x0f);
+		_emitU8(0x90);
+		_emitU8((mod << 6) | (sib_use ? 4 : (memReg & 7)));
+		if (sib_use)
+		{
+			_emitU8((0 << 6) | ((memReg & 7)) | ((index & 7) << 3));
+		}
+		if (mod == 1) _emitU8((u8)offset);
+		else if (mod == 2) _emitU32((u32)offset);
+	}
+	void CMPXCHG_dd(GPR32 dst, GPR32 src)
+	{
+		if (((src & 8) != 0) || ((dst & 8) != 0))
+		{
+			_emitU8(0x40 | ((dst & 8) >> 3) | ((src & 8) >> 1));
+		}
+		_emitU8(0x0f);
+		_emitU8(0xb1);
+		_emitU8((3 << 6) | ((src & 7) << 3) | (dst & 7));
+	}
+	void CMPXCHG_qq(GPR64 dst, GPR64 src)
+	{
+		_emitU8(0x48 | ((dst & 8) >> 3) | ((src & 8) >> 1));
+		_emitU8(0x0f);
+		_emitU8(0xb1);
+		_emitU8((3 << 6) | ((src & 7) << 3) | (dst & 7));
+	}
+	void CMPXCHG_dd_l(GPR64 memReg, sint32 offset, GPR64 index, uint8 scaler, GPR32 src)
+	{
+		uint8 mod;
+		if (offset == 0 && (memReg & 7) != 5) mod = 0;
+		else if (offset == (s32)(s8)offset) mod = 1;
+		else mod = 2;
+		bool sib_use = (scaler != 0 && index != X86_REG_NONE);
+		if ((memReg & 7) == 4)
+		{
+			cemu_assert_debug(index == X86_REG_NONE);
+			index = memReg;
+			sib_use = true;
+		}
+		if (sib_use)
+		{
+			if ((src & 8) || (memReg & 8) || ((index != X86_REG_NONE) && (index & 8)))
+				_emitU8(0x40 | ((src & 8) >> 1) | ((memReg & 8) >> 3) | ((index & 8) >> 2));
+		}
+		else
+		{
+			if ((src & 8) || (memReg & 8))
+				_emitU8(0x40 | ((src & 8) >> 1) | ((memReg & 8) >> 1));
+		}
+		_emitU8(0x0f);
+		_emitU8(0xb1);
+		_emitU8((mod << 6) | ((src & 7) << 3) | (sib_use ? 4 : (memReg & 7)));
+		if (sib_use)
+		{
+			_emitU8((0 << 6) | ((memReg & 7)) | ((index & 7) << 3));
+		}
+		if (mod == 1) _emitU8((u8)offset);
+		else if (mod == 2) _emitU32((u32)offset);
+	}
+	void CMPXCHG_qq_l(GPR64 memReg, sint32 offset, GPR64 index, uint8 scaler, GPR64 src)
+	{
+		uint8 mod;
+		if (offset == 0 && (memReg & 7) != 5) mod = 0;
+		else if (offset == (s32)(s8)offset) mod = 1;
+		else mod = 2;
+		bool sib_use = (scaler != 0 && index != X86_REG_NONE);
+		if ((memReg & 7) == 4)
+		{
+			cemu_assert_debug(index == X86_REG_NONE);
+			index = memReg;
+			sib_use = true;
+		}
+		if (sib_use)
+		{
+			_emitU8(0x40 | ((src & 8) >> 1) | ((memReg & 8) >> 3) | ((index & 8) >> 2) | 0x08);
+		}
+		else
+		{
+			_emitU8(0x40 | ((src & 8) >> 1) | ((memReg & 8) >> 1) | 0x08);
+		}
+		_emitU8(0x0f);
+		_emitU8(0xb1);
+		_emitU8((mod << 6) | ((src & 7) << 3) | (sib_use ? 4 : (memReg & 7)));
+		if (sib_use)
+		{
+			_emitU8((0 << 6) | ((memReg & 7)) | ((index & 7) << 3));
+		}
+		if (mod == 1) _emitU8((u8)offset);
+		else if (mod == 2) _emitU32((u32)offset);
+	}
+	void BSWAP_d(GPR32 dst)
+	{
+		if (((dst & 8) != 0))
+		{
+			_emitU8(0x40 | ((dst & 8) >> 3));
+		}
+		_emitU8(0x0f);
+		_emitU8(0xc8 | ((dst) & 7));
+	}
+	void BSWAP_q(GPR64 dst)
+	{
+		_emitU8(0x48 | ((dst & 8) >> 3));
+		_emitU8(0x0f);
+		_emitU8(0xc8 | ((dst) & 7));
+	}
+	void BT_du8(GPR32 dst, u8 imm)
+	{
+		if (((dst & 8) != 0))
+		{
+			_emitU8(0x40 | ((dst & 8) >> 3));
+		}
+		_emitU8(0x0f);
+		_emitU8(0xba);
+		_emitU8((3 << 6) | ((4 & 7) << 3) | (dst & 7));
+		_emitU8((u8)imm);
+	}
+	void BT_qu8(GPR64 dst, u8 imm)
+	{
+		_emitU8(0x48 | ((dst & 8) >> 3));
+		_emitU8(0x0f);
+		_emitU8(0xba);
+		_emitU8((3 << 6) | ((4 & 7) << 3) | (dst & 7));
+		_emitU8((u8)imm);
+	}
+	void BT_du8_l(GPR64 memReg, sint32 offset, GPR64 index, uint8 scaler, u8 imm)
+	{
+		uint8 mod;
+		if (offset == 0 && (memReg & 7) != 5) mod = 0;
+		else if (offset == (s32)(s8)offset) mod = 1;
+		else mod = 2;
+		bool sib_use = (scaler != 0 && index != X86_REG_NONE);
+		if ((memReg & 7) == 4)
+		{
+			cemu_assert_debug(index == X86_REG_NONE);
+			index = memReg;
+			sib_use = true;
+		}
+		if (sib_use)
+		{
+			if ((memReg & 8) || ((index != X86_REG_NONE) && (index & 8)))
+				_emitU8(0x40 | ((memReg & 8) >> 3) | ((index & 8) >> 2));
+		}
+		else
+		{
+			if ((memReg & 8))
+				_emitU8(0x40 | ((memReg & 8) >> 1));
+		}
+		_emitU8(0x0f);
+		_emitU8(0xba);
+		_emitU8((mod << 6) | ((4 & 7) << 3) | (sib_use ? 4 : (memReg & 7)));
+		if (sib_use)
+		{
+			_emitU8((0 << 6) | ((memReg & 7)) | ((index & 7) << 3));
+		}
+		if (mod == 1) _emitU8((u8)offset);
+		else if (mod == 2) _emitU32((u32)offset);
+		_emitU8((u8)imm);
+	}
+	void BT_qu8_l(GPR64 memReg, sint32 offset, GPR64 index, uint8 scaler, u8 imm)
+	{
+		uint8 mod;
+		if (offset == 0 && (memReg & 7) != 5) mod = 0;
+		else if (offset == (s32)(s8)offset) mod = 1;
+		else mod = 2;
+		bool sib_use = (scaler != 0 && index != X86_REG_NONE);
+		if ((memReg & 7) == 4)
+		{
+			cemu_assert_debug(index == X86_REG_NONE);
+			index = memReg;
+			sib_use = true;
+		}
+		if (sib_use)
+		{
+			_emitU8(0x40 | ((memReg & 8) >> 3) | ((index & 8) >> 2) | 0x08);
+		}
+		else
+		{
+			_emitU8(0x40 | ((memReg & 8) >> 1) | 0x08);
+		}
+		_emitU8(0x0f);
+		_emitU8(0xba);
+		_emitU8((mod << 6) | ((4 & 7) << 3) | (sib_use ? 4 : (memReg & 7)));
+		if (sib_use)
+		{
+			_emitU8((0 << 6) | ((memReg & 7)) | ((index & 7) << 3));
+		}
+		if (mod == 1) _emitU8((u8)offset);
+		else if (mod == 2) _emitU32((u32)offset);
+		_emitU8((u8)imm);
+	}
+};
diff --git a/src/Cafe/HW/Espresso/Recompiler/IML/IML.h b/src/Cafe/HW/Espresso/Recompiler/IML/IML.h
new file mode 100644
index 00000000..bc0c27c5
--- /dev/null
+++ b/src/Cafe/HW/Espresso/Recompiler/IML/IML.h
@@ -0,0 +1,16 @@
+#pragma once 
+
+#include "IMLInstruction.h"
+#include "IMLSegment.h"
+
+// optimizer passes
+void IMLOptimizer_OptimizeDirectFloatCopies(struct ppcImlGenContext_t* ppcImlGenContext);
+void IMLOptimizer_OptimizeDirectIntegerCopies(struct ppcImlGenContext_t* ppcImlGenContext);
+void PPCRecompiler_optimizePSQLoadAndStore(struct ppcImlGenContext_t* ppcImlGenContext);
+
+void IMLOptimizer_StandardOptimizationPass(ppcImlGenContext_t& ppcImlGenContext);
+
+// debug
+void IMLDebug_DisassembleInstruction(const IMLInstruction& inst, std::string& disassemblyLineOut);
+void IMLDebug_DumpSegment(struct ppcImlGenContext_t* ctx, IMLSegment* imlSegment, bool printLivenessRangeInfo = false);
+void IMLDebug_Dump(struct ppcImlGenContext_t* ppcImlGenContext, bool printLivenessRangeInfo = false);
diff --git a/src/Cafe/HW/Espresso/Recompiler/IML/IMLAnalyzer.cpp b/src/Cafe/HW/Espresso/Recompiler/IML/IMLAnalyzer.cpp
new file mode 100644
index 00000000..6ae4b591
--- /dev/null
+++ b/src/Cafe/HW/Espresso/Recompiler/IML/IMLAnalyzer.cpp
@@ -0,0 +1,5 @@
+#include "IML.h"
+//#include "PPCRecompilerIml.h"
+#include "util/helpers/fixedSizeList.h"
+
+#include "Cafe/HW/Espresso/Interpreter/PPCInterpreterInternal.h"
diff --git a/src/Cafe/HW/Espresso/Recompiler/IML/IMLDebug.cpp b/src/Cafe/HW/Espresso/Recompiler/IML/IMLDebug.cpp
new file mode 100644
index 00000000..cd269869
--- /dev/null
+++ b/src/Cafe/HW/Espresso/Recompiler/IML/IMLDebug.cpp
@@ -0,0 +1,561 @@
+#include "IML.h"
+#include "IMLInstruction.h"
+#include "IMLSegment.h"
+#include "IMLRegisterAllocatorRanges.h"
+#include "util/helpers/StringBuf.h"
+
+#include "../PPCRecompiler.h"
+
+const char* IMLDebug_GetOpcodeName(const IMLInstruction* iml)
+{
+	static char _tempOpcodename[32];
+	uint32 op = iml->operation;
+	if (op == PPCREC_IML_OP_ASSIGN)
+		return "MOV";
+	else if (op == PPCREC_IML_OP_ADD)
+		return "ADD";
+	else if (op == PPCREC_IML_OP_ADD_WITH_CARRY)
+		return "ADC";
+	else if (op == PPCREC_IML_OP_SUB)
+		return "SUB";
+	else if (op == PPCREC_IML_OP_OR)
+		return "OR";
+	else if (op == PPCREC_IML_OP_AND)
+		return "AND";
+	else if (op == PPCREC_IML_OP_XOR)
+		return "XOR";
+	else if (op == PPCREC_IML_OP_LEFT_SHIFT)
+		return "LSH";
+	else if (op == PPCREC_IML_OP_RIGHT_SHIFT_U)
+		return "RSH";
+	else if (op == PPCREC_IML_OP_RIGHT_SHIFT_S)
+		return "ARSH";
+	else if (op == PPCREC_IML_OP_LEFT_ROTATE)
+		return "LROT";
+	else if (op == PPCREC_IML_OP_MULTIPLY_SIGNED)
+		return "MULS";
+	else if (op == PPCREC_IML_OP_DIVIDE_SIGNED)
+		return "DIVS";
+	else if (op == PPCREC_IML_OP_FPR_ASSIGN)
+		return "FMOV";
+	else if (op == PPCREC_IML_OP_FPR_ADD)
+		return "FADD";
+	else if (op == PPCREC_IML_OP_FPR_SUB)
+		return "FSUB";
+	else if (op == PPCREC_IML_OP_FPR_MULTIPLY)
+		return "FMUL";
+	else if (op == PPCREC_IML_OP_FPR_DIVIDE)
+		return "FDIV";
+	else if (op == PPCREC_IML_OP_FPR_EXPAND_F32_TO_F64)
+		return "F32TOF64";
+	else if (op == PPCREC_IML_OP_FPR_ABS)
+		return "FABS";
+	else if (op == PPCREC_IML_OP_FPR_NEGATE)
+		return "FNEG";
+	else if (op == PPCREC_IML_OP_FPR_NEGATIVE_ABS)
+		return "FNABS";
+	else if (op == PPCREC_IML_OP_FPR_FLOAT_TO_INT)
+		return "F2I";
+	else if (op == PPCREC_IML_OP_FPR_INT_TO_FLOAT)
+		return "I2F";
+	else if (op == PPCREC_IML_OP_FPR_BITCAST_INT_TO_FLOAT)
+		return "BITMOVE";
+
+	sprintf(_tempOpcodename, "OP0%02x_T%d", iml->operation, iml->type);
+	return _tempOpcodename;
+}
+
+std::string IMLDebug_GetRegName(IMLReg r)
+{
+	std::string regName;
+	uint32 regId = r.GetRegID();
+	switch (r.GetRegFormat())
+	{
+	case IMLRegFormat::F32:
+		regName.append("f");
+		break;
+	case IMLRegFormat::F64:
+		regName.append("fd");
+		break;
+	case IMLRegFormat::I32:
+		regName.append("i");
+		break;
+	case IMLRegFormat::I64:
+		regName.append("r");
+		break;
+	default:
+		DEBUG_BREAK;
+	}
+	regName.append(fmt::format("{}", regId));
+	return regName;
+}
+
+void IMLDebug_AppendRegisterParam(StringBuf& strOutput, IMLReg virtualRegister, bool isLast = false)
+{
+	strOutput.add(IMLDebug_GetRegName(virtualRegister));
+	if (!isLast)
+		strOutput.add(", ");
+}
+
+void IMLDebug_AppendS32Param(StringBuf& strOutput, sint32 val, bool isLast = false)
+{
+	if (val < 0)
+	{
+		strOutput.add("-");
+		val = -val;
+	}
+	strOutput.addFmt("0x{:08x}", val);
+	if (!isLast)
+		strOutput.add(", ");
+}
+
+void IMLDebug_PrintLivenessRangeInfo(StringBuf& currentLineText, IMLSegment* imlSegment, sint32 offset)
+{
+	// pad to 70 characters
+	sint32 index = currentLineText.getLen();
+	while (index < 70)
+	{
+		currentLineText.add(" ");
+		index++;
+	}
+	raLivenessRange* subrangeItr = imlSegment->raInfo.linkedList_allSubranges;
+	while (subrangeItr)
+	{
+		if (subrangeItr->interval.start.GetInstructionIndexEx() == offset)
+		{
+			if(subrangeItr->interval.start.IsInstructionIndex() && !subrangeItr->interval.start.IsOnInputEdge())
+				currentLineText.add(".");
+			else
+				currentLineText.add("|");
+
+			currentLineText.addFmt("{:<4}", subrangeItr->GetVirtualRegister());
+		}
+		else if (subrangeItr->interval.end.GetInstructionIndexEx() == offset)
+		{
+			if(subrangeItr->interval.end.IsInstructionIndex() && !subrangeItr->interval.end.IsOnOutputEdge())
+				currentLineText.add("*    ");
+			else
+				currentLineText.add("|    ");
+		}
+		else if (subrangeItr->interval.ContainsInstructionIndexEx(offset))
+		{
+			currentLineText.add("|    ");
+		}
+		else
+		{
+			currentLineText.add("     ");
+		}
+		index += 5;
+		// next
+		subrangeItr = subrangeItr->link_allSegmentRanges.next;
+	}
+}
+
+std::string IMLDebug_GetSegmentName(ppcImlGenContext_t* ctx, IMLSegment* seg)
+{
+	if (!ctx)
+	{
+		return "<NoNameWithoutCtx>";
+	}
+	// find segment index
+	for (size_t i = 0; i < ctx->segmentList2.size(); i++)
+	{
+		if (ctx->segmentList2[i] == seg)
+		{
+			return fmt::format("Seg{:04x}", i);
+		}
+	}
+	return "<SegmentNotInCtx>";
+}
+
+std::string IMLDebug_GetConditionName(IMLCondition cond)
+{
+	switch (cond)
+	{
+	case IMLCondition::EQ:
+		return "EQ";
+	case IMLCondition::NEQ:
+		return "NEQ";
+	case IMLCondition::UNSIGNED_GT:
+		return "UGT";
+	case IMLCondition::UNSIGNED_LT:
+		return "ULT";
+	case IMLCondition::SIGNED_GT:
+		return "SGT";
+	case IMLCondition::SIGNED_LT:
+		return "SLT";
+	default:
+		cemu_assert_unimplemented();
+	}
+	return "ukn";
+}
+
+void IMLDebug_DisassembleInstruction(const IMLInstruction& inst, std::string& disassemblyLineOut)
+{
+	const sint32 lineOffsetParameters = 10;//18;
+
+	StringBuf strOutput(1024);
+	strOutput.reset();
+	if (inst.type == PPCREC_IML_TYPE_R_NAME || inst.type == PPCREC_IML_TYPE_NAME_R)
+	{
+		if (inst.type == PPCREC_IML_TYPE_R_NAME)
+			strOutput.add("R_NAME");
+		else
+			strOutput.add("NAME_R");
+		while ((sint32)strOutput.getLen() < lineOffsetParameters)
+			strOutput.add(" ");
+
+		if(inst.type == PPCREC_IML_TYPE_R_NAME)
+			IMLDebug_AppendRegisterParam(strOutput, inst.op_r_name.regR);
+
+		strOutput.add("name_");
+		if (inst.op_r_name.name >= PPCREC_NAME_R0 && inst.op_r_name.name < (PPCREC_NAME_R0 + 999))
+		{
+			strOutput.addFmt("r{}", inst.op_r_name.name - PPCREC_NAME_R0);
+		}
+		if (inst.op_r_name.name >= PPCREC_NAME_FPR_HALF && inst.op_r_name.name < (PPCREC_NAME_FPR_HALF + 32*2))
+		{
+			strOutput.addFmt("f{}", inst.op_r_name.name - ((PPCREC_NAME_FPR_HALF - inst.op_r_name.name)/2));
+			if ((inst.op_r_name.name-PPCREC_NAME_FPR_HALF)&1)
+				strOutput.add(".ps1");
+			else
+				strOutput.add(".ps0");
+		}
+		else if (inst.op_r_name.name >= PPCREC_NAME_SPR0 && inst.op_r_name.name < (PPCREC_NAME_SPR0 + 999))
+		{
+			strOutput.addFmt("spr{}", inst.op_r_name.name - PPCREC_NAME_SPR0);
+		}
+		else if (inst.op_r_name.name >= PPCREC_NAME_CR && inst.op_r_name.name <= PPCREC_NAME_CR_LAST)
+			strOutput.addFmt("cr{}", inst.op_r_name.name - PPCREC_NAME_CR);
+		else if (inst.op_r_name.name == PPCREC_NAME_XER_CA)
+			strOutput.add("xer.ca");
+		else if (inst.op_r_name.name == PPCREC_NAME_XER_SO)
+			strOutput.add("xer.so");
+		else if (inst.op_r_name.name == PPCREC_NAME_XER_OV)
+			strOutput.add("xer.ov");
+		else if (inst.op_r_name.name == PPCREC_NAME_CPU_MEMRES_EA)
+			strOutput.add("cpuReservation.ea");
+		else if (inst.op_r_name.name == PPCREC_NAME_CPU_MEMRES_VAL)
+			strOutput.add("cpuReservation.value");
+		else
+		{
+			strOutput.addFmt("name_ukn{}", inst.op_r_name.name);
+		}
+		if (inst.type != PPCREC_IML_TYPE_R_NAME)
+		{
+			strOutput.add(", ");
+			IMLDebug_AppendRegisterParam(strOutput, inst.op_r_name.regR, true);
+		}
+
+	}
+	else if (inst.type == PPCREC_IML_TYPE_R_R)
+	{
+		strOutput.addFmt("{}", IMLDebug_GetOpcodeName(&inst));
+		while ((sint32)strOutput.getLen() < lineOffsetParameters)
+			strOutput.add(" ");
+		IMLDebug_AppendRegisterParam(strOutput, inst.op_r_r.regR);
+		IMLDebug_AppendRegisterParam(strOutput, inst.op_r_r.regA, true);
+	}
+	else if (inst.type == PPCREC_IML_TYPE_R_R_R)
+	{
+		strOutput.addFmt("{}", IMLDebug_GetOpcodeName(&inst));
+		while ((sint32)strOutput.getLen() < lineOffsetParameters)
+			strOutput.add(" ");
+		IMLDebug_AppendRegisterParam(strOutput, inst.op_r_r_r.regR);
+		IMLDebug_AppendRegisterParam(strOutput, inst.op_r_r_r.regA);
+		IMLDebug_AppendRegisterParam(strOutput, inst.op_r_r_r.regB, true);
+	}
+	else if (inst.type == PPCREC_IML_TYPE_R_R_R_CARRY)
+	{
+		strOutput.addFmt("{}", IMLDebug_GetOpcodeName(&inst));
+		while ((sint32)strOutput.getLen() < lineOffsetParameters)
+			strOutput.add(" ");
+		IMLDebug_AppendRegisterParam(strOutput, inst.op_r_r_r_carry.regR);
+		IMLDebug_AppendRegisterParam(strOutput, inst.op_r_r_r_carry.regA);
+		IMLDebug_AppendRegisterParam(strOutput, inst.op_r_r_r_carry.regB);
+		IMLDebug_AppendRegisterParam(strOutput, inst.op_r_r_r_carry.regCarry, true);
+	}
+	else if (inst.type == PPCREC_IML_TYPE_COMPARE)
+	{
+		strOutput.add("CMP ");
+		while ((sint32)strOutput.getLen() < lineOffsetParameters)
+			strOutput.add(" ");
+		IMLDebug_AppendRegisterParam(strOutput, inst.op_compare.regA);
+		IMLDebug_AppendRegisterParam(strOutput, inst.op_compare.regB);
+		strOutput.addFmt("{}", IMLDebug_GetConditionName(inst.op_compare.cond));
+		strOutput.add(" -> ");
+		IMLDebug_AppendRegisterParam(strOutput, inst.op_compare.regR, true);
+	}
+	else if (inst.type == PPCREC_IML_TYPE_COMPARE_S32)
+	{
+		strOutput.add("CMP ");
+		while ((sint32)strOutput.getLen() < lineOffsetParameters)
+			strOutput.add(" ");
+		IMLDebug_AppendRegisterParam(strOutput, inst.op_compare_s32.regA);
+		strOutput.addFmt("{}", inst.op_compare_s32.immS32);
+		strOutput.addFmt(", {}", IMLDebug_GetConditionName(inst.op_compare_s32.cond));
+		strOutput.add(" -> ");
+		IMLDebug_AppendRegisterParam(strOutput, inst.op_compare_s32.regR, true);
+	}
+	else if (inst.type == PPCREC_IML_TYPE_CONDITIONAL_JUMP)
+	{
+		strOutput.add("CJUMP ");
+		while ((sint32)strOutput.getLen() < lineOffsetParameters)
+			strOutput.add(" ");
+		IMLDebug_AppendRegisterParam(strOutput, inst.op_conditional_jump.registerBool, true);
+		if (!inst.op_conditional_jump.mustBeTrue)
+			strOutput.add("(inverted)");
+	}
+	else if (inst.type == PPCREC_IML_TYPE_JUMP)
+	{
+		strOutput.add("JUMP");
+	}
+	else if (inst.type == PPCREC_IML_TYPE_R_R_S32)
+	{
+		strOutput.addFmt("{}", IMLDebug_GetOpcodeName(&inst));
+		while ((sint32)strOutput.getLen() < lineOffsetParameters)
+			strOutput.add(" ");
+
+		IMLDebug_AppendRegisterParam(strOutput, inst.op_r_r_s32.regR);
+		IMLDebug_AppendRegisterParam(strOutput, inst.op_r_r_s32.regA);
+		IMLDebug_AppendS32Param(strOutput, inst.op_r_r_s32.immS32, true);
+	}
+	else if (inst.type == PPCREC_IML_TYPE_R_R_S32_CARRY)
+	{
+		strOutput.addFmt("{}", IMLDebug_GetOpcodeName(&inst));
+		while ((sint32)strOutput.getLen() < lineOffsetParameters)
+			strOutput.add(" ");
+
+		IMLDebug_AppendRegisterParam(strOutput, inst.op_r_r_s32_carry.regR);
+		IMLDebug_AppendRegisterParam(strOutput, inst.op_r_r_s32_carry.regA);
+		IMLDebug_AppendS32Param(strOutput, inst.op_r_r_s32_carry.immS32);
+		IMLDebug_AppendRegisterParam(strOutput, inst.op_r_r_s32_carry.regCarry, true);
+	}
+	else if (inst.type == PPCREC_IML_TYPE_R_S32)
+	{
+		strOutput.addFmt("{}", IMLDebug_GetOpcodeName(&inst));
+		while ((sint32)strOutput.getLen() < lineOffsetParameters)
+			strOutput.add(" ");
+
+		IMLDebug_AppendRegisterParam(strOutput, inst.op_r_immS32.regR);
+		IMLDebug_AppendS32Param(strOutput, inst.op_r_immS32.immS32, true);
+	}
+	else if (inst.type == PPCREC_IML_TYPE_LOAD || inst.type == PPCREC_IML_TYPE_STORE ||
+			 inst.type == PPCREC_IML_TYPE_LOAD_INDEXED || inst.type == PPCREC_IML_TYPE_STORE_INDEXED)
+	{
+		if (inst.type == PPCREC_IML_TYPE_LOAD || inst.type == PPCREC_IML_TYPE_LOAD_INDEXED)
+			strOutput.add("LD_");
+		else
+			strOutput.add("ST_");
+
+		if (inst.op_storeLoad.flags2.signExtend)
+			strOutput.add("S");
+		else
+			strOutput.add("U");
+		strOutput.addFmt("{}", inst.op_storeLoad.copyWidth);
+
+		while ((sint32)strOutput.getLen() < lineOffsetParameters)
+			strOutput.add(" ");
+
+		IMLDebug_AppendRegisterParam(strOutput, inst.op_storeLoad.registerData);
+
+		if (inst.type == PPCREC_IML_TYPE_LOAD_INDEXED || inst.type == PPCREC_IML_TYPE_STORE_INDEXED)
+			strOutput.addFmt("[{}+{}]", IMLDebug_GetRegName(inst.op_storeLoad.registerMem), IMLDebug_GetRegName(inst.op_storeLoad.registerMem2));
+		else
+			strOutput.addFmt("[{}+{}]", IMLDebug_GetRegName(inst.op_storeLoad.registerMem), inst.op_storeLoad.immS32);
+	}
+	else if (inst.type == PPCREC_IML_TYPE_ATOMIC_CMP_STORE)
+	{
+		strOutput.add("ATOMIC_ST_U32");
+
+		while ((sint32)strOutput.getLen() < lineOffsetParameters)
+			strOutput.add(" ");
+
+		IMLDebug_AppendRegisterParam(strOutput, inst.op_atomic_compare_store.regEA);
+		IMLDebug_AppendRegisterParam(strOutput, inst.op_atomic_compare_store.regCompareValue);
+		IMLDebug_AppendRegisterParam(strOutput, inst.op_atomic_compare_store.regWriteValue);
+		IMLDebug_AppendRegisterParam(strOutput, inst.op_atomic_compare_store.regBoolOut, true);
+	}
+	else if (inst.type == PPCREC_IML_TYPE_NO_OP)
+	{
+		strOutput.add("NOP");
+	}
+	else if (inst.type == PPCREC_IML_TYPE_MACRO)
+	{
+		if (inst.operation == PPCREC_IML_MACRO_B_TO_REG)
+		{
+			strOutput.addFmt("MACRO B_TO_REG {}", IMLDebug_GetRegName(inst.op_macro.paramReg));
+		}
+		else if (inst.operation == PPCREC_IML_MACRO_BL)
+		{
+			strOutput.addFmt("MACRO BL 0x{:08x} -> 0x{:08x} cycles (depr): {}", inst.op_macro.param, inst.op_macro.param2, (sint32)inst.op_macro.paramU16);
+		}
+		else if (inst.operation == PPCREC_IML_MACRO_B_FAR)
+		{
+			strOutput.addFmt("MACRO B_FAR 0x{:08x} -> 0x{:08x} cycles (depr): {}", inst.op_macro.param, inst.op_macro.param2, (sint32)inst.op_macro.paramU16);
+		}
+		else if (inst.operation == PPCREC_IML_MACRO_LEAVE)
+		{
+			strOutput.addFmt("MACRO LEAVE ppc: 0x{:08x}", inst.op_macro.param);
+		}
+		else if (inst.operation == PPCREC_IML_MACRO_HLE)
+		{
+			strOutput.addFmt("MACRO HLE ppcAddr: 0x{:08x} funcId: 0x{:08x}", inst.op_macro.param, inst.op_macro.param2);
+		}
+		else if (inst.operation == PPCREC_IML_MACRO_COUNT_CYCLES)
+		{
+			strOutput.addFmt("MACRO COUNT_CYCLES cycles: {}", inst.op_macro.param);
+		}
+		else
+		{
+			strOutput.addFmt("MACRO ukn operation {}", inst.operation);
+		}
+	}
+	else if (inst.type == PPCREC_IML_TYPE_FPR_LOAD)
+	{
+		strOutput.addFmt("{} = ", IMLDebug_GetRegName(inst.op_storeLoad.registerData));
+		if (inst.op_storeLoad.flags2.signExtend)
+			strOutput.add("S");
+		else
+			strOutput.add("U");
+		strOutput.addFmt("{} [{}+{}] mode {}", inst.op_storeLoad.copyWidth / 8, IMLDebug_GetRegName(inst.op_storeLoad.registerMem), inst.op_storeLoad.immS32, inst.op_storeLoad.mode);
+		if (inst.op_storeLoad.flags2.notExpanded)
+		{
+			strOutput.addFmt(" <No expand>");
+		}
+	}
+	else if (inst.type == PPCREC_IML_TYPE_FPR_STORE)
+	{
+		if (inst.op_storeLoad.flags2.signExtend)
+			strOutput.add("S");
+		else
+			strOutput.add("U");
+		strOutput.addFmt("{} [t{}+{}]", inst.op_storeLoad.copyWidth / 8, inst.op_storeLoad.registerMem.GetRegID(), inst.op_storeLoad.immS32);
+		strOutput.addFmt(" = {} mode {}", IMLDebug_GetRegName(inst.op_storeLoad.registerData), inst.op_storeLoad.mode);
+	}
+	else if (inst.type == PPCREC_IML_TYPE_FPR_R)
+	{
+		strOutput.addFmt("{:<6} ", IMLDebug_GetOpcodeName(&inst));
+		strOutput.addFmt("{}", IMLDebug_GetRegName(inst.op_fpr_r.regR));
+	}
+	else if (inst.type == PPCREC_IML_TYPE_FPR_R_R)
+	{
+		strOutput.addFmt("{:<6} ", IMLDebug_GetOpcodeName(&inst));
+		strOutput.addFmt("{}, {}", IMLDebug_GetRegName(inst.op_fpr_r_r.regR), IMLDebug_GetRegName(inst.op_fpr_r_r.regA));
+	}
+	else if (inst.type == PPCREC_IML_TYPE_FPR_R_R_R_R)
+	{
+		strOutput.addFmt("{:<6} ", IMLDebug_GetOpcodeName(&inst));
+		strOutput.addFmt("{}, {}, {}, {}", IMLDebug_GetRegName(inst.op_fpr_r_r_r_r.regR), IMLDebug_GetRegName(inst.op_fpr_r_r_r_r.regA), IMLDebug_GetRegName(inst.op_fpr_r_r_r_r.regB), IMLDebug_GetRegName(inst.op_fpr_r_r_r_r.regC));
+	}
+	else if (inst.type == PPCREC_IML_TYPE_FPR_R_R_R)
+	{
+		strOutput.addFmt("{:<6} ", IMLDebug_GetOpcodeName(&inst));
+		strOutput.addFmt("{}, {}, {}", IMLDebug_GetRegName(inst.op_fpr_r_r_r.regR), IMLDebug_GetRegName(inst.op_fpr_r_r_r.regA), IMLDebug_GetRegName(inst.op_fpr_r_r_r.regB));
+	}
+	else if (inst.type == PPCREC_IML_TYPE_CJUMP_CYCLE_CHECK)
+	{
+		strOutput.addFmt("CYCLE_CHECK");
+	}
+	else if (inst.type == PPCREC_IML_TYPE_X86_EFLAGS_JCC)
+	{
+		strOutput.addFmt("X86_JCC {}", IMLDebug_GetConditionName(inst.op_x86_eflags_jcc.cond));
+	}
+	else
+	{
+		strOutput.addFmt("Unknown iml type {}", inst.type);
+	}
+	disassemblyLineOut.assign(strOutput.c_str());
+}
+
+void IMLDebug_DumpSegment(ppcImlGenContext_t* ctx, IMLSegment* imlSegment, bool printLivenessRangeInfo)
+{
+	StringBuf strOutput(4096);
+
+	strOutput.addFmt("SEGMENT {} | PPC=0x{:08x} Loop-depth {}", IMLDebug_GetSegmentName(ctx, imlSegment), imlSegment->ppcAddress, imlSegment->loopDepth);
+	if (imlSegment->isEnterable)
+	{
+		strOutput.addFmt(" ENTERABLE (0x{:08x})", imlSegment->enterPPCAddress);
+	}
+	if (imlSegment->deadCodeEliminationHintSeg)
+	{
+		strOutput.addFmt(" InheritOverwrite: {}", IMLDebug_GetSegmentName(ctx, imlSegment->deadCodeEliminationHintSeg));
+	}
+	cemuLog_log(LogType::Force, "{}", strOutput.c_str());
+
+	if (printLivenessRangeInfo)
+	{
+		strOutput.reset();
+		IMLDebug_PrintLivenessRangeInfo(strOutput, imlSegment, RA_INTER_RANGE_START);
+		cemuLog_log(LogType::Force, "{}", strOutput.c_str());
+	}
+	//debug_printf("\n");
+	strOutput.reset();
+
+	std::string disassemblyLine;
+	for (sint32 i = 0; i < imlSegment->imlList.size(); i++)
+	{
+		const IMLInstruction& inst = imlSegment->imlList[i];
+		// don't log NOP instructions
+		if (inst.type == PPCREC_IML_TYPE_NO_OP)
+			continue;
+		strOutput.reset();
+		strOutput.addFmt("{:02x} ", i);
+		//cemuLog_log(LogType::Force, "{:02x} ", i);
+		disassemblyLine.clear();
+		IMLDebug_DisassembleInstruction(inst, disassemblyLine);
+		strOutput.add(disassemblyLine);
+		if (printLivenessRangeInfo)
+		{
+			IMLDebug_PrintLivenessRangeInfo(strOutput, imlSegment, i);
+		}
+		cemuLog_log(LogType::Force, "{}", strOutput.c_str());
+	}
+	// all ranges
+	if (printLivenessRangeInfo)
+	{
+		strOutput.reset();
+		strOutput.add("Ranges-VirtReg                                                        ");
+		raLivenessRange* subrangeItr = imlSegment->raInfo.linkedList_allSubranges;
+		while (subrangeItr)
+		{
+			strOutput.addFmt("v{:<4}", (uint32)subrangeItr->GetVirtualRegister());
+			subrangeItr = subrangeItr->link_allSegmentRanges.next;
+		}
+		cemuLog_log(LogType::Force, "{}", strOutput.c_str());
+		strOutput.reset();
+		strOutput.add("Ranges-PhysReg                                                        ");
+		subrangeItr = imlSegment->raInfo.linkedList_allSubranges;
+		while (subrangeItr)
+		{
+			strOutput.addFmt("p{:<4}", subrangeItr->GetPhysicalRegister());
+			subrangeItr = subrangeItr->link_allSegmentRanges.next;
+		}
+		cemuLog_log(LogType::Force, "{}", strOutput.c_str());
+	}
+	// branch info
+	strOutput.reset();
+	strOutput.add("Links from: ");
+	for (sint32 i = 0; i < imlSegment->list_prevSegments.size(); i++)
+	{
+		if (i)
+			strOutput.add(", ");
+		strOutput.addFmt("{}", IMLDebug_GetSegmentName(ctx, imlSegment->list_prevSegments[i]).c_str());
+	}
+	cemuLog_log(LogType::Force, "{}", strOutput.c_str());
+	if (imlSegment->nextSegmentBranchNotTaken)
+		cemuLog_log(LogType::Force, "BranchNotTaken: {}", IMLDebug_GetSegmentName(ctx, imlSegment->nextSegmentBranchNotTaken).c_str());
+	if (imlSegment->nextSegmentBranchTaken)
+		cemuLog_log(LogType::Force, "BranchTaken: {}", IMLDebug_GetSegmentName(ctx, imlSegment->nextSegmentBranchTaken).c_str());
+	if (imlSegment->nextSegmentIsUncertain)
+		cemuLog_log(LogType::Force, "Dynamic target");
+}
+
+void IMLDebug_Dump(ppcImlGenContext_t* ppcImlGenContext, bool printLivenessRangeInfo)
+{
+	for (size_t i = 0; i < ppcImlGenContext->segmentList2.size(); i++)
+	{
+		IMLDebug_DumpSegment(ppcImlGenContext, ppcImlGenContext->segmentList2[i], printLivenessRangeInfo);
+		cemuLog_log(LogType::Force, "");
+	}
+}
diff --git a/src/Cafe/HW/Espresso/Recompiler/IML/IMLInstruction.cpp b/src/Cafe/HW/Espresso/Recompiler/IML/IMLInstruction.cpp
new file mode 100644
index 00000000..997de4e9
--- /dev/null
+++ b/src/Cafe/HW/Espresso/Recompiler/IML/IMLInstruction.cpp
@@ -0,0 +1,536 @@
+#include "IMLInstruction.h"
+#include "IML.h"
+
+#include "../PPCRecompiler.h"
+#include "../PPCRecompilerIml.h"
+
+// return true if an instruction has side effects on top of just reading and writing registers
+bool IMLInstruction::HasSideEffects() const
+{
+	bool hasSideEffects = true;
+	if(type == PPCREC_IML_TYPE_R_R || type == PPCREC_IML_TYPE_R_R_S32 || type == PPCREC_IML_TYPE_COMPARE || type == PPCREC_IML_TYPE_COMPARE_S32)
+		hasSideEffects = false;
+	// todo - add more cases
+	return hasSideEffects;
+}
+
+void IMLInstruction::CheckRegisterUsage(IMLUsedRegisters* registersUsed) const
+{
+	registersUsed->readGPR1 = IMLREG_INVALID;
+	registersUsed->readGPR2 = IMLREG_INVALID;
+	registersUsed->readGPR3 = IMLREG_INVALID;
+	registersUsed->readGPR4 = IMLREG_INVALID;
+	registersUsed->writtenGPR1 = IMLREG_INVALID;
+	registersUsed->writtenGPR2 = IMLREG_INVALID;
+	if (type == PPCREC_IML_TYPE_R_NAME)
+	{
+		registersUsed->writtenGPR1 = op_r_name.regR;
+	}
+	else if (type == PPCREC_IML_TYPE_NAME_R)
+	{
+		registersUsed->readGPR1 = op_r_name.regR;
+	}
+	else if (type == PPCREC_IML_TYPE_R_R)
+	{
+		if (operation == PPCREC_IML_OP_X86_CMP)
+		{
+			// both operands are read only
+			registersUsed->readGPR1 = op_r_r.regR;
+			registersUsed->readGPR2 = op_r_r.regA;
+		}
+		else if (
+			operation == PPCREC_IML_OP_ASSIGN ||
+			operation == PPCREC_IML_OP_ENDIAN_SWAP ||
+			operation == PPCREC_IML_OP_CNTLZW ||
+			operation == PPCREC_IML_OP_NOT ||
+			operation == PPCREC_IML_OP_NEG ||
+			operation == PPCREC_IML_OP_ASSIGN_S16_TO_S32 ||
+			operation == PPCREC_IML_OP_ASSIGN_S8_TO_S32)
+		{
+			// result is written, operand is read
+			registersUsed->writtenGPR1 = op_r_r.regR;
+			registersUsed->readGPR1 = op_r_r.regA;
+		}
+		else
+			cemu_assert_unimplemented();
+	}
+	else if (type == PPCREC_IML_TYPE_R_S32)
+	{
+		cemu_assert_debug(operation != PPCREC_IML_OP_ADD &&
+			operation != PPCREC_IML_OP_SUB &&
+			operation != PPCREC_IML_OP_AND &&
+			operation != PPCREC_IML_OP_OR &&
+			operation != PPCREC_IML_OP_XOR); // deprecated, use r_r_s32 for these
+
+		if (operation == PPCREC_IML_OP_LEFT_ROTATE)
+		{
+			// register operand is read and write
+			registersUsed->readGPR1 = op_r_immS32.regR;
+			registersUsed->writtenGPR1 = op_r_immS32.regR;
+		}
+		else if (operation == PPCREC_IML_OP_X86_CMP)
+		{
+			// register operand is read only
+			registersUsed->readGPR1 = op_r_immS32.regR;
+		}
+		else
+		{
+			// register operand is write only
+			// todo - use explicit lists, avoid default cases
+			registersUsed->writtenGPR1 = op_r_immS32.regR;
+		}
+	}
+	else if (type == PPCREC_IML_TYPE_R_R_S32)
+	{
+		registersUsed->writtenGPR1 = op_r_r_s32.regR;
+		registersUsed->readGPR1 = op_r_r_s32.regA;
+	}
+	else if (type == PPCREC_IML_TYPE_R_R_S32_CARRY)
+	{
+		registersUsed->writtenGPR1 = op_r_r_s32_carry.regR;
+		registersUsed->readGPR1 = op_r_r_s32_carry.regA;
+		// some operations read carry
+		switch (operation)
+		{
+		case PPCREC_IML_OP_ADD_WITH_CARRY:
+			registersUsed->readGPR2 = op_r_r_s32_carry.regCarry;
+			break;
+		case PPCREC_IML_OP_ADD:
+			break;
+		default:
+			cemu_assert_unimplemented();
+		}
+		// carry is always written
+		registersUsed->writtenGPR2 = op_r_r_s32_carry.regCarry;
+	}
+	else if (type == PPCREC_IML_TYPE_R_R_R)
+	{
+		// in all cases result is written and other operands are read only
+		// with the exception of XOR, where if regA == regB then all bits are zeroed out. So we don't consider it a read
+		registersUsed->writtenGPR1 = op_r_r_r.regR;
+		if(!(operation == PPCREC_IML_OP_XOR && op_r_r_r.regA == op_r_r_r.regB))
+		{
+			registersUsed->readGPR1 = op_r_r_r.regA;
+			registersUsed->readGPR2 = op_r_r_r.regB;
+		}
+	}
+	else if (type == PPCREC_IML_TYPE_R_R_R_CARRY)
+	{
+		registersUsed->writtenGPR1 = op_r_r_r_carry.regR;
+		registersUsed->readGPR1 = op_r_r_r_carry.regA;
+		registersUsed->readGPR2 = op_r_r_r_carry.regB;
+		// some operations read carry
+		switch (operation)
+		{
+		case PPCREC_IML_OP_ADD_WITH_CARRY:
+			registersUsed->readGPR3 = op_r_r_r_carry.regCarry;
+			break;
+		case PPCREC_IML_OP_ADD:
+			break;
+		default:
+			cemu_assert_unimplemented();
+		}
+		// carry is always written
+		registersUsed->writtenGPR2 = op_r_r_r_carry.regCarry;
+	}
+	else if (type == PPCREC_IML_TYPE_CJUMP_CYCLE_CHECK)
+	{
+		// no effect on registers
+	}
+	else if (type == PPCREC_IML_TYPE_NO_OP)
+	{
+		// no effect on registers
+	}
+	else if (type == PPCREC_IML_TYPE_MACRO)
+	{
+		if (operation == PPCREC_IML_MACRO_BL || operation == PPCREC_IML_MACRO_B_FAR || operation == PPCREC_IML_MACRO_LEAVE || operation == PPCREC_IML_MACRO_DEBUGBREAK || operation == PPCREC_IML_MACRO_COUNT_CYCLES || operation == PPCREC_IML_MACRO_HLE)
+		{
+			// no effect on registers
+		}
+		else if (operation == PPCREC_IML_MACRO_B_TO_REG)
+		{
+			cemu_assert_debug(op_macro.paramReg.IsValid());
+			registersUsed->readGPR1 = op_macro.paramReg;
+		}
+		else
+			cemu_assert_unimplemented();
+	}
+	else if (type == PPCREC_IML_TYPE_COMPARE)
+	{
+		registersUsed->readGPR1 = op_compare.regA;
+		registersUsed->readGPR2 = op_compare.regB;
+		registersUsed->writtenGPR1 = op_compare.regR;
+	}
+	else if (type == PPCREC_IML_TYPE_COMPARE_S32)
+	{
+		registersUsed->readGPR1 = op_compare_s32.regA;
+		registersUsed->writtenGPR1 = op_compare_s32.regR;
+	}
+	else if (type == PPCREC_IML_TYPE_CONDITIONAL_JUMP)
+	{
+		registersUsed->readGPR1 = op_conditional_jump.registerBool;
+	}
+	else if (type == PPCREC_IML_TYPE_JUMP)
+	{
+		// no registers affected
+	}
+	else if (type == PPCREC_IML_TYPE_LOAD)
+	{
+		registersUsed->writtenGPR1 = op_storeLoad.registerData;
+		if (op_storeLoad.registerMem.IsValid())
+			registersUsed->readGPR1 = op_storeLoad.registerMem;
+	}
+	else if (type == PPCREC_IML_TYPE_LOAD_INDEXED)
+	{
+		registersUsed->writtenGPR1 = op_storeLoad.registerData;
+		if (op_storeLoad.registerMem.IsValid())
+			registersUsed->readGPR1 = op_storeLoad.registerMem;
+		if (op_storeLoad.registerMem2.IsValid())
+			registersUsed->readGPR2 = op_storeLoad.registerMem2;
+	}
+	else if (type == PPCREC_IML_TYPE_STORE)
+	{
+		registersUsed->readGPR1 = op_storeLoad.registerData;
+		if (op_storeLoad.registerMem.IsValid())
+			registersUsed->readGPR2 = op_storeLoad.registerMem;
+	}
+	else if (type == PPCREC_IML_TYPE_STORE_INDEXED)
+	{
+		registersUsed->readGPR1 = op_storeLoad.registerData;
+		if (op_storeLoad.registerMem.IsValid())
+			registersUsed->readGPR2 = op_storeLoad.registerMem;
+		if (op_storeLoad.registerMem2.IsValid())
+			registersUsed->readGPR3 = op_storeLoad.registerMem2;
+	}
+	else if (type == PPCREC_IML_TYPE_ATOMIC_CMP_STORE)
+	{
+		registersUsed->readGPR1 = op_atomic_compare_store.regEA;
+		registersUsed->readGPR2 = op_atomic_compare_store.regCompareValue;
+		registersUsed->readGPR3 = op_atomic_compare_store.regWriteValue;
+		registersUsed->writtenGPR1 = op_atomic_compare_store.regBoolOut;
+	}
+	else if (type == PPCREC_IML_TYPE_CALL_IMM)
+	{
+		if (op_call_imm.regParam0.IsValid())
+			registersUsed->readGPR1 = op_call_imm.regParam0;
+		if (op_call_imm.regParam1.IsValid())
+			registersUsed->readGPR2 = op_call_imm.regParam1;
+		if (op_call_imm.regParam2.IsValid())
+			registersUsed->readGPR3 = op_call_imm.regParam2;
+		registersUsed->writtenGPR1 = op_call_imm.regReturn;
+	}
+	else if (type == PPCREC_IML_TYPE_FPR_LOAD)
+	{
+		// fpr load operation
+		registersUsed->writtenGPR1 = op_storeLoad.registerData;
+		// address is in gpr register
+		if (op_storeLoad.registerMem.IsValid())
+			registersUsed->readGPR1 = op_storeLoad.registerMem;
+	}
+	else if (type == PPCREC_IML_TYPE_FPR_LOAD_INDEXED)
+	{
+		// fpr load operation
+		registersUsed->writtenGPR1 = op_storeLoad.registerData;
+		// address is in gpr registers
+		if (op_storeLoad.registerMem.IsValid())
+			registersUsed->readGPR1 = op_storeLoad.registerMem;
+		if (op_storeLoad.registerMem2.IsValid())
+			registersUsed->readGPR2 = op_storeLoad.registerMem2;
+	}
+	else if (type == PPCREC_IML_TYPE_FPR_STORE)
+	{
+		// fpr store operation
+		registersUsed->readGPR1 = op_storeLoad.registerData;
+		if (op_storeLoad.registerMem.IsValid())
+			registersUsed->readGPR2 = op_storeLoad.registerMem;
+	}
+	else if (type == PPCREC_IML_TYPE_FPR_STORE_INDEXED)
+	{
+		// fpr store operation
+		registersUsed->readGPR1 = op_storeLoad.registerData;
+		// address is in gpr registers
+		if (op_storeLoad.registerMem.IsValid())
+			registersUsed->readGPR2 = op_storeLoad.registerMem;
+		if (op_storeLoad.registerMem2.IsValid())
+			registersUsed->readGPR3 = op_storeLoad.registerMem2;
+	}
+	else if (type == PPCREC_IML_TYPE_FPR_R_R)
+	{
+		// fpr operation
+		if (
+			operation == PPCREC_IML_OP_FPR_ASSIGN ||
+			operation == PPCREC_IML_OP_FPR_EXPAND_F32_TO_F64 ||
+			operation == PPCREC_IML_OP_FPR_FCTIWZ
+			)
+		{
+			registersUsed->readGPR1 = op_fpr_r_r.regA;
+			registersUsed->writtenGPR1 = op_fpr_r_r.regR;
+		}
+		else if (operation == PPCREC_IML_OP_FPR_MULTIPLY ||
+			operation == PPCREC_IML_OP_FPR_DIVIDE ||
+			operation == PPCREC_IML_OP_FPR_ADD ||
+			operation == PPCREC_IML_OP_FPR_SUB)
+		{
+			registersUsed->readGPR1 = op_fpr_r_r.regA;
+			registersUsed->readGPR2 = op_fpr_r_r.regR;
+			registersUsed->writtenGPR1 = op_fpr_r_r.regR;
+
+		}
+		else if (operation == PPCREC_IML_OP_FPR_FLOAT_TO_INT ||
+			operation == PPCREC_IML_OP_FPR_INT_TO_FLOAT ||
+			operation == PPCREC_IML_OP_FPR_BITCAST_INT_TO_FLOAT)
+		{
+			registersUsed->writtenGPR1 = op_fpr_r_r.regR;
+			registersUsed->readGPR1 = op_fpr_r_r.regA;
+		}
+		else
+			cemu_assert_unimplemented();
+	}
+	else if (type == PPCREC_IML_TYPE_FPR_R_R_R)
+	{
+		// fpr operation
+		registersUsed->readGPR1 = op_fpr_r_r_r.regA;
+		registersUsed->readGPR2 = op_fpr_r_r_r.regB;
+		registersUsed->writtenGPR1 = op_fpr_r_r_r.regR;
+	}
+	else if (type == PPCREC_IML_TYPE_FPR_R_R_R_R)
+	{
+		// fpr operation
+		registersUsed->readGPR1 = op_fpr_r_r_r_r.regA;
+		registersUsed->readGPR2 = op_fpr_r_r_r_r.regB;
+		registersUsed->readGPR3 = op_fpr_r_r_r_r.regC;
+		registersUsed->writtenGPR1 = op_fpr_r_r_r_r.regR;
+	}
+	else if (type == PPCREC_IML_TYPE_FPR_R)
+	{
+		// fpr operation
+		if (operation == PPCREC_IML_OP_FPR_NEGATE ||
+			operation == PPCREC_IML_OP_FPR_ABS ||
+			operation == PPCREC_IML_OP_FPR_NEGATIVE_ABS ||
+			operation == PPCREC_IML_OP_FPR_EXPAND_F32_TO_F64 ||
+			operation == PPCREC_IML_OP_FPR_ROUND_TO_SINGLE_PRECISION_BOTTOM)
+		{
+			registersUsed->readGPR1 = op_fpr_r.regR;
+			registersUsed->writtenGPR1 = op_fpr_r.regR;
+		}
+		else if (operation == PPCREC_IML_OP_FPR_LOAD_ONE)
+		{
+			registersUsed->writtenGPR1 = op_fpr_r.regR;
+		}
+		else
+			cemu_assert_unimplemented();
+	}
+	else if (type == PPCREC_IML_TYPE_FPR_COMPARE)
+	{
+		registersUsed->writtenGPR1 = op_fpr_compare.regR;
+		registersUsed->readGPR1 = op_fpr_compare.regA;
+		registersUsed->readGPR2 = op_fpr_compare.regB;
+	}
+	else if (type == PPCREC_IML_TYPE_X86_EFLAGS_JCC)
+	{
+		// no registers read or written (except for the implicit eflags)
+	}
+	else
+	{
+		cemu_assert_unimplemented();
+	}
+}
+
+IMLReg replaceRegisterIdMultiple(IMLReg reg, const std::unordered_map<IMLRegID, IMLRegID>& translationTable)
+{
+	if (reg.IsInvalid())
+		return reg;
+	const auto& it = translationTable.find(reg.GetRegID());
+	cemu_assert_debug(it != translationTable.cend());
+	IMLReg alteredReg = reg;
+	alteredReg.SetRegID(it->second);
+	return alteredReg;
+}
+
+void IMLInstruction::RewriteGPR(const std::unordered_map<IMLRegID, IMLRegID>& translationTable)
+{
+	if (type == PPCREC_IML_TYPE_R_NAME)
+	{
+		op_r_name.regR = replaceRegisterIdMultiple(op_r_name.regR, translationTable);
+	}
+	else if (type == PPCREC_IML_TYPE_NAME_R)
+	{
+		op_r_name.regR = replaceRegisterIdMultiple(op_r_name.regR, translationTable);
+	}
+	else if (type == PPCREC_IML_TYPE_R_R)
+	{
+		op_r_r.regR = replaceRegisterIdMultiple(op_r_r.regR, translationTable);
+		op_r_r.regA = replaceRegisterIdMultiple(op_r_r.regA, translationTable);
+	}
+	else if (type == PPCREC_IML_TYPE_R_S32)
+	{
+		op_r_immS32.regR = replaceRegisterIdMultiple(op_r_immS32.regR, translationTable);
+	}
+	else if (type == PPCREC_IML_TYPE_R_R_S32)
+	{
+		op_r_r_s32.regR = replaceRegisterIdMultiple(op_r_r_s32.regR, translationTable);
+		op_r_r_s32.regA = replaceRegisterIdMultiple(op_r_r_s32.regA, translationTable);
+	}
+	else if (type == PPCREC_IML_TYPE_R_R_S32_CARRY)
+	{
+		op_r_r_s32_carry.regR = replaceRegisterIdMultiple(op_r_r_s32_carry.regR, translationTable);
+		op_r_r_s32_carry.regA = replaceRegisterIdMultiple(op_r_r_s32_carry.regA, translationTable);
+		op_r_r_s32_carry.regCarry = replaceRegisterIdMultiple(op_r_r_s32_carry.regCarry, translationTable);
+	}
+	else if (type == PPCREC_IML_TYPE_R_R_R)
+	{
+		op_r_r_r.regR = replaceRegisterIdMultiple(op_r_r_r.regR, translationTable);
+		op_r_r_r.regA = replaceRegisterIdMultiple(op_r_r_r.regA, translationTable);
+		op_r_r_r.regB = replaceRegisterIdMultiple(op_r_r_r.regB, translationTable);
+	}
+	else if (type == PPCREC_IML_TYPE_R_R_R_CARRY)
+	{
+		op_r_r_r_carry.regR = replaceRegisterIdMultiple(op_r_r_r_carry.regR, translationTable);
+		op_r_r_r_carry.regA = replaceRegisterIdMultiple(op_r_r_r_carry.regA, translationTable);
+		op_r_r_r_carry.regB = replaceRegisterIdMultiple(op_r_r_r_carry.regB, translationTable);
+		op_r_r_r_carry.regCarry = replaceRegisterIdMultiple(op_r_r_r_carry.regCarry, translationTable);
+	}
+	else if (type == PPCREC_IML_TYPE_COMPARE)
+	{
+		op_compare.regR = replaceRegisterIdMultiple(op_compare.regR, translationTable);
+		op_compare.regA = replaceRegisterIdMultiple(op_compare.regA, translationTable);
+		op_compare.regB = replaceRegisterIdMultiple(op_compare.regB, translationTable);
+	}
+	else if (type == PPCREC_IML_TYPE_COMPARE_S32)
+	{
+		op_compare_s32.regR = replaceRegisterIdMultiple(op_compare_s32.regR, translationTable);
+		op_compare_s32.regA = replaceRegisterIdMultiple(op_compare_s32.regA, translationTable);
+	}
+	else if (type == PPCREC_IML_TYPE_CONDITIONAL_JUMP)
+	{
+		op_conditional_jump.registerBool = replaceRegisterIdMultiple(op_conditional_jump.registerBool, translationTable);
+	}
+	else if (type == PPCREC_IML_TYPE_CJUMP_CYCLE_CHECK || type == PPCREC_IML_TYPE_JUMP)
+	{
+		// no effect on registers
+	}
+	else if (type == PPCREC_IML_TYPE_NO_OP)
+	{
+		// no effect on registers
+	}
+	else if (type == PPCREC_IML_TYPE_MACRO)
+	{
+		if (operation == PPCREC_IML_MACRO_BL || operation == PPCREC_IML_MACRO_B_FAR || operation == PPCREC_IML_MACRO_LEAVE || operation == PPCREC_IML_MACRO_DEBUGBREAK || operation == PPCREC_IML_MACRO_HLE || operation == PPCREC_IML_MACRO_COUNT_CYCLES)
+		{
+			// no effect on registers
+		}
+		else if (operation == PPCREC_IML_MACRO_B_TO_REG)
+		{
+			op_macro.paramReg = replaceRegisterIdMultiple(op_macro.paramReg, translationTable);
+		}
+		else
+		{
+			cemu_assert_unimplemented();
+		}
+	}
+	else if (type == PPCREC_IML_TYPE_LOAD)
+	{
+		op_storeLoad.registerData = replaceRegisterIdMultiple(op_storeLoad.registerData, translationTable);
+		if (op_storeLoad.registerMem.IsValid())
+		{
+			op_storeLoad.registerMem = replaceRegisterIdMultiple(op_storeLoad.registerMem, translationTable);
+		}
+	}
+	else if (type == PPCREC_IML_TYPE_LOAD_INDEXED)
+	{
+		op_storeLoad.registerData = replaceRegisterIdMultiple(op_storeLoad.registerData, translationTable);
+		if (op_storeLoad.registerMem.IsValid())
+			op_storeLoad.registerMem = replaceRegisterIdMultiple(op_storeLoad.registerMem, translationTable);
+		if (op_storeLoad.registerMem2.IsValid())
+			op_storeLoad.registerMem2 = replaceRegisterIdMultiple(op_storeLoad.registerMem2, translationTable);
+	}
+	else if (type == PPCREC_IML_TYPE_STORE)
+	{
+		op_storeLoad.registerData = replaceRegisterIdMultiple(op_storeLoad.registerData, translationTable);
+		if (op_storeLoad.registerMem.IsValid())
+			op_storeLoad.registerMem = replaceRegisterIdMultiple(op_storeLoad.registerMem, translationTable);
+	}
+	else if (type == PPCREC_IML_TYPE_STORE_INDEXED)
+	{
+		op_storeLoad.registerData = replaceRegisterIdMultiple(op_storeLoad.registerData, translationTable);
+		if (op_storeLoad.registerMem.IsValid())
+			op_storeLoad.registerMem = replaceRegisterIdMultiple(op_storeLoad.registerMem, translationTable);
+		if (op_storeLoad.registerMem2.IsValid())
+			op_storeLoad.registerMem2 = replaceRegisterIdMultiple(op_storeLoad.registerMem2, translationTable);
+	}
+	else if (type == PPCREC_IML_TYPE_ATOMIC_CMP_STORE)
+	{
+		op_atomic_compare_store.regEA = replaceRegisterIdMultiple(op_atomic_compare_store.regEA, translationTable);
+		op_atomic_compare_store.regCompareValue = replaceRegisterIdMultiple(op_atomic_compare_store.regCompareValue, translationTable);
+		op_atomic_compare_store.regWriteValue = replaceRegisterIdMultiple(op_atomic_compare_store.regWriteValue, translationTable);
+		op_atomic_compare_store.regBoolOut = replaceRegisterIdMultiple(op_atomic_compare_store.regBoolOut, translationTable);
+	}
+	else if (type == PPCREC_IML_TYPE_CALL_IMM)
+	{
+		op_call_imm.regReturn = replaceRegisterIdMultiple(op_call_imm.regReturn, translationTable);
+		if (op_call_imm.regParam0.IsValid())
+			op_call_imm.regParam0 = replaceRegisterIdMultiple(op_call_imm.regParam0, translationTable);
+		if (op_call_imm.regParam1.IsValid())
+			op_call_imm.regParam1 = replaceRegisterIdMultiple(op_call_imm.regParam1, translationTable);
+		if (op_call_imm.regParam2.IsValid())
+			op_call_imm.regParam2 = replaceRegisterIdMultiple(op_call_imm.regParam2, translationTable);
+	}
+	else if (type == PPCREC_IML_TYPE_FPR_LOAD)
+	{
+		op_storeLoad.registerData = replaceRegisterIdMultiple(op_storeLoad.registerData, translationTable);
+		op_storeLoad.registerMem = replaceRegisterIdMultiple(op_storeLoad.registerMem, translationTable);
+	}
+	else if (type == PPCREC_IML_TYPE_FPR_LOAD_INDEXED)
+	{
+		op_storeLoad.registerData = replaceRegisterIdMultiple(op_storeLoad.registerData, translationTable);
+		op_storeLoad.registerMem = replaceRegisterIdMultiple(op_storeLoad.registerMem, translationTable);
+		op_storeLoad.registerMem2 = replaceRegisterIdMultiple(op_storeLoad.registerMem2, translationTable);
+	}
+	else if (type == PPCREC_IML_TYPE_FPR_STORE)
+	{
+		op_storeLoad.registerData = replaceRegisterIdMultiple(op_storeLoad.registerData, translationTable);
+		op_storeLoad.registerMem = replaceRegisterIdMultiple(op_storeLoad.registerMem, translationTable);
+	}
+	else if (type == PPCREC_IML_TYPE_FPR_STORE_INDEXED)
+	{
+		op_storeLoad.registerData = replaceRegisterIdMultiple(op_storeLoad.registerData, translationTable);
+		op_storeLoad.registerMem = replaceRegisterIdMultiple(op_storeLoad.registerMem, translationTable);
+		op_storeLoad.registerMem2 = replaceRegisterIdMultiple(op_storeLoad.registerMem2, translationTable);
+	}
+	else if (type == PPCREC_IML_TYPE_FPR_R)
+	{
+		op_fpr_r.regR = replaceRegisterIdMultiple(op_fpr_r.regR, translationTable);
+	}
+	else if (type == PPCREC_IML_TYPE_FPR_R_R)
+	{
+		op_fpr_r_r.regR = replaceRegisterIdMultiple(op_fpr_r_r.regR, translationTable);
+		op_fpr_r_r.regA = replaceRegisterIdMultiple(op_fpr_r_r.regA, translationTable);
+	}
+	else if (type == PPCREC_IML_TYPE_FPR_R_R_R)
+	{
+		op_fpr_r_r_r.regR = replaceRegisterIdMultiple(op_fpr_r_r_r.regR, translationTable);
+		op_fpr_r_r_r.regA = replaceRegisterIdMultiple(op_fpr_r_r_r.regA, translationTable);
+		op_fpr_r_r_r.regB = replaceRegisterIdMultiple(op_fpr_r_r_r.regB, translationTable);
+	}
+	else if (type == PPCREC_IML_TYPE_FPR_R_R_R_R)
+	{
+		op_fpr_r_r_r_r.regR = replaceRegisterIdMultiple(op_fpr_r_r_r_r.regR, translationTable);
+		op_fpr_r_r_r_r.regA = replaceRegisterIdMultiple(op_fpr_r_r_r_r.regA, translationTable);
+		op_fpr_r_r_r_r.regB = replaceRegisterIdMultiple(op_fpr_r_r_r_r.regB, translationTable);
+		op_fpr_r_r_r_r.regC = replaceRegisterIdMultiple(op_fpr_r_r_r_r.regC, translationTable);
+	}
+	else if (type == PPCREC_IML_TYPE_FPR_COMPARE)
+	{
+		op_fpr_compare.regA = replaceRegisterIdMultiple(op_fpr_compare.regA, translationTable);
+		op_fpr_compare.regB = replaceRegisterIdMultiple(op_fpr_compare.regB, translationTable);
+		op_fpr_compare.regR = replaceRegisterIdMultiple(op_fpr_compare.regR, translationTable);
+	}
+	else if (type == PPCREC_IML_TYPE_X86_EFLAGS_JCC)
+	{
+		// no registers read or written (except for the implicit eflags)
+	}
+	else
+	{
+		cemu_assert_unimplemented();
+	}
+}
diff --git a/src/Cafe/HW/Espresso/Recompiler/IML/IMLInstruction.h b/src/Cafe/HW/Espresso/Recompiler/IML/IMLInstruction.h
new file mode 100644
index 00000000..4df2a666
--- /dev/null
+++ b/src/Cafe/HW/Espresso/Recompiler/IML/IMLInstruction.h
@@ -0,0 +1,826 @@
+#pragma once
+
+using IMLRegID = uint16; // 16 bit ID
+using IMLPhysReg = sint32; // arbitrary value that is up to the architecture backend, usually this will be the register index. A value of -1 is reserved and means not assigned
+
+// format of IMLReg:
+// 0-15		(16 bit)	IMLRegID
+// 19-23	(5 bit)		Offset				In elements, for SIMD registers
+// 24-27	(4 bit)		IMLRegFormat		RegFormat
+// 28-31	(4 bit)		IMLRegFormat		BaseFormat
+
+enum class IMLRegFormat : uint8
+{
+	INVALID_FORMAT,
+	I64,
+	I32,
+	I16,
+	I8,
+	// I1 ?
+	F64,
+	F32,
+	TYPE_COUNT,
+};
+
+class IMLReg
+{
+public:
+	IMLReg()
+	{
+		m_raw = 0; // 0 is invalid
+	}
+
+	IMLReg(IMLRegFormat baseRegFormat, IMLRegFormat regFormat, uint8 viewOffset, IMLRegID regId)
+	{
+		m_raw = 0;
+		m_raw |= ((uint8)baseRegFormat << 28);
+		m_raw |= ((uint8)regFormat << 24);
+		m_raw |= (uint32)regId;
+	}
+
+	IMLReg(IMLReg&& baseReg, IMLRegFormat viewFormat, uint8 viewOffset, IMLRegID regId)
+	{
+		DEBUG_BREAK;
+		//m_raw = 0;
+		//m_raw |= ((uint8)baseRegFormat << 28);
+		//m_raw |= ((uint8)viewFormat << 24);
+		//m_raw |= (uint32)regId;
+	}
+
+	IMLReg(const IMLReg& other) : m_raw(other.m_raw) {}
+
+	IMLRegFormat GetBaseFormat() const
+	{
+		return (IMLRegFormat)((m_raw >> 28) & 0xF);
+	}
+
+	IMLRegFormat GetRegFormat() const
+	{
+		return (IMLRegFormat)((m_raw >> 24) & 0xF);
+	}
+
+	IMLRegID GetRegID() const
+	{
+		cemu_assert_debug(GetBaseFormat() != IMLRegFormat::INVALID_FORMAT);
+		cemu_assert_debug(GetRegFormat() != IMLRegFormat::INVALID_FORMAT);
+		return (IMLRegID)(m_raw & 0xFFFF);
+	}
+
+	void SetRegID(IMLRegID regId)
+	{
+		cemu_assert_debug(regId <= 0xFFFF);
+		m_raw &= ~0xFFFF;
+		m_raw |= (uint32)regId;
+	}
+
+	bool IsInvalid() const
+	{
+		return GetBaseFormat() == IMLRegFormat::INVALID_FORMAT;
+	}
+
+	bool IsValid() const
+	{
+		return GetBaseFormat() != IMLRegFormat::INVALID_FORMAT;
+	}
+
+	bool IsValidAndSameRegID(IMLRegID regId) const
+	{
+		return IsValid() && GetRegID() == regId;
+	}
+
+	// compare all fields
+	bool operator==(const IMLReg& other) const
+	{
+		return m_raw == other.m_raw;
+	}
+
+private:
+	uint32 m_raw;
+};
+
+static const IMLReg IMLREG_INVALID(IMLRegFormat::INVALID_FORMAT, IMLRegFormat::INVALID_FORMAT, 0, 0);
+static const IMLRegID IMLRegID_INVALID(0xFFFF);
+
+using IMLName = uint32;
+
+enum
+{
+	PPCREC_IML_OP_ASSIGN,			// '=' operator
+	PPCREC_IML_OP_ENDIAN_SWAP,		// '=' operator with 32bit endian swap
+	PPCREC_IML_OP_MULTIPLY_SIGNED,  // '*' operator (signed multiply)
+	PPCREC_IML_OP_MULTIPLY_HIGH_UNSIGNED, // unsigned 64bit multiply, store only high 32bit-word of result
+	PPCREC_IML_OP_MULTIPLY_HIGH_SIGNED, // signed 64bit multiply, store only high 32bit-word of result
+	PPCREC_IML_OP_DIVIDE_SIGNED,	// '/' operator (signed divide)
+	PPCREC_IML_OP_DIVIDE_UNSIGNED,	// '/' operator (unsigned divide)
+
+	// binary operation
+	PPCREC_IML_OP_OR,				// '|' operator
+	PPCREC_IML_OP_AND,				// '&' operator
+	PPCREC_IML_OP_XOR,				// '^' operator
+	PPCREC_IML_OP_LEFT_ROTATE,		// left rotate operator
+	PPCREC_IML_OP_LEFT_SHIFT,		// shift left operator
+	PPCREC_IML_OP_RIGHT_SHIFT_U,	// right shift operator (unsigned)
+	PPCREC_IML_OP_RIGHT_SHIFT_S,	// right shift operator (signed)
+	// ppc
+	PPCREC_IML_OP_SLW,				// SLW (shift based on register by up to 63 bits)
+	PPCREC_IML_OP_SRW,				// SRW (shift based on register by up to 63 bits)
+	PPCREC_IML_OP_CNTLZW,
+	// FPU
+	PPCREC_IML_OP_FPR_ASSIGN,
+	PPCREC_IML_OP_FPR_LOAD_ONE, // load constant 1.0 into register
+	PPCREC_IML_OP_FPR_ADD,
+	PPCREC_IML_OP_FPR_SUB,
+	PPCREC_IML_OP_FPR_MULTIPLY,
+	PPCREC_IML_OP_FPR_DIVIDE,
+	PPCREC_IML_OP_FPR_EXPAND_F32_TO_F64, // expand f32 to f64 in-place
+	PPCREC_IML_OP_FPR_NEGATE,
+	PPCREC_IML_OP_FPR_ABS, // abs(fpr)
+	PPCREC_IML_OP_FPR_NEGATIVE_ABS, // -abs(fpr)
+	PPCREC_IML_OP_FPR_ROUND_TO_SINGLE_PRECISION_BOTTOM, // round 64bit double to 64bit double with 32bit float precision (in bottom half of xmm register)
+	PPCREC_IML_OP_FPR_FCTIWZ,
+	PPCREC_IML_OP_FPR_SELECT, // selectively copy bottom value from operand B or C based on value in operand A
+	// Conversion (FPR_R_R)
+	PPCREC_IML_OP_FPR_INT_TO_FLOAT, // convert integer value in gpr to floating point value in fpr
+	PPCREC_IML_OP_FPR_FLOAT_TO_INT, // convert floating point value in fpr to integer value in gpr
+
+	// Bitcast (FPR_R_R)
+	PPCREC_IML_OP_FPR_BITCAST_INT_TO_FLOAT,
+
+	// R_R_R + R_R_S32
+	PPCREC_IML_OP_ADD, // also R_R_R_CARRY
+	PPCREC_IML_OP_SUB,
+
+	// R_R only
+	PPCREC_IML_OP_NOT,
+	PPCREC_IML_OP_NEG,
+	PPCREC_IML_OP_ASSIGN_S16_TO_S32,
+	PPCREC_IML_OP_ASSIGN_S8_TO_S32,
+
+	// R_R_R_carry
+	PPCREC_IML_OP_ADD_WITH_CARRY, // similar to ADD but also adds carry bit (0 or 1)
+
+	// X86 extension
+	PPCREC_IML_OP_X86_CMP, // R_R and R_S32
+
+	PPCREC_IML_OP_INVALID
+};
+
+#define PPCREC_IML_OP_FPR_COPY_PAIR (PPCREC_IML_OP_ASSIGN)
+
+enum
+{
+	PPCREC_IML_MACRO_B_TO_REG,		// branch to PPC address in register (used for BCCTR, BCLR)
+
+	PPCREC_IML_MACRO_BL,			// call to different function (can be within same function)
+	PPCREC_IML_MACRO_B_FAR,			// branch to different function
+	PPCREC_IML_MACRO_COUNT_CYCLES,	// decrease current remaining thread cycles by a certain amount
+	PPCREC_IML_MACRO_HLE,			// HLE function call
+	PPCREC_IML_MACRO_LEAVE,			// leaves recompiler and switches to interpeter
+	// debugging
+	PPCREC_IML_MACRO_DEBUGBREAK,	// throws a debugbreak
+};
+
+enum class IMLCondition : uint8
+{
+	EQ,
+	NEQ,
+	SIGNED_GT,
+	SIGNED_LT,
+	UNSIGNED_GT,
+	UNSIGNED_LT,
+
+	// floating point conditions
+	UNORDERED_GT, // a > b, false if either is NaN
+	UNORDERED_LT, // a < b, false if either is NaN
+	UNORDERED_EQ, // a == b, false if either is NaN
+	UNORDERED_U, // unordered (true if either operand is NaN)
+
+	ORDERED_GT,
+	ORDERED_LT,
+	ORDERED_EQ,
+	ORDERED_U
+};
+
+enum
+{
+	PPCREC_IML_TYPE_NONE,
+	PPCREC_IML_TYPE_NO_OP,				// no-op instruction
+	PPCREC_IML_TYPE_R_R,				// r* = (op) *r			(can also be r* (op) *r) 
+	PPCREC_IML_TYPE_R_R_R,				// r* = r* (op) r*
+	PPCREC_IML_TYPE_R_R_R_CARRY,		// r* = r* (op) r*		(reads and/or updates carry)
+	PPCREC_IML_TYPE_R_R_S32,			// r* = r* (op) s32*
+	PPCREC_IML_TYPE_R_R_S32_CARRY,		// r* = r* (op) s32*	(reads and/or updates carry)
+	PPCREC_IML_TYPE_LOAD,				// r* = [r*+s32*]
+	PPCREC_IML_TYPE_LOAD_INDEXED,		// r* = [r*+r*]
+	PPCREC_IML_TYPE_STORE,				// [r*+s32*] = r*
+	PPCREC_IML_TYPE_STORE_INDEXED,		// [r*+r*] = r*
+	PPCREC_IML_TYPE_R_NAME,				// r* = name
+	PPCREC_IML_TYPE_NAME_R,				// name* = r*
+	PPCREC_IML_TYPE_R_S32,				// r* (op) imm
+	PPCREC_IML_TYPE_MACRO,
+	PPCREC_IML_TYPE_CJUMP_CYCLE_CHECK,	// jumps only if remaining thread cycles < 0
+
+	// conditions and branches
+	PPCREC_IML_TYPE_COMPARE,			// r* = r* CMP[cond] r*
+	PPCREC_IML_TYPE_COMPARE_S32,		// r* = r* CMP[cond] imm
+	PPCREC_IML_TYPE_JUMP,				// jump always
+	PPCREC_IML_TYPE_CONDITIONAL_JUMP,	// jump conditionally based on boolean value in register
+
+	// atomic
+	PPCREC_IML_TYPE_ATOMIC_CMP_STORE,
+
+	// function call
+	PPCREC_IML_TYPE_CALL_IMM,			// call to fixed immediate address
+
+	// FPR
+	PPCREC_IML_TYPE_FPR_LOAD,			// r* = (bitdepth) [r*+s32*] (single or paired single mode)
+	PPCREC_IML_TYPE_FPR_LOAD_INDEXED,	// r* = (bitdepth) [r*+r*] (single or paired single mode)
+	PPCREC_IML_TYPE_FPR_STORE,			// (bitdepth) [r*+s32*] = r* (single or paired single mode)
+	PPCREC_IML_TYPE_FPR_STORE_INDEXED,	// (bitdepth) [r*+r*] = r* (single or paired single mode)
+	PPCREC_IML_TYPE_FPR_R_R,
+	PPCREC_IML_TYPE_FPR_R_R_R,
+	PPCREC_IML_TYPE_FPR_R_R_R_R,
+	PPCREC_IML_TYPE_FPR_R,
+
+	PPCREC_IML_TYPE_FPR_COMPARE,		// r* = r* CMP[cond] r*
+
+	// X86 specific
+	PPCREC_IML_TYPE_X86_EFLAGS_JCC,
+};
+
+enum // IMLName
+{
+	PPCREC_NAME_NONE,
+	PPCREC_NAME_TEMPORARY = 1000,
+	PPCREC_NAME_R0 = 2000,
+	PPCREC_NAME_SPR0 = 3000,
+	PPCREC_NAME_FPR_HALF = 4800, // Counts PS0 and PS1 separately. E.g. fp3.ps1 is at offset 3 * 2 + 1
+	PPCREC_NAME_TEMPORARY_FPR0 = 5000, // 0 to 7
+	PPCREC_NAME_XER_CA = 6000, // carry bit from XER
+	PPCREC_NAME_XER_OV = 6001, // overflow bit from XER
+	PPCREC_NAME_XER_SO = 6002, // summary overflow bit from XER
+	PPCREC_NAME_CR = 7000, // CR register bits (31 to 0)
+	PPCREC_NAME_CR_LAST = PPCREC_NAME_CR+31,
+	PPCREC_NAME_CPU_MEMRES_EA = 8000,
+	PPCREC_NAME_CPU_MEMRES_VAL = 8001
+};
+
+#define PPC_REC_INVALID_REGISTER	0xFF	// deprecated. Use IMLREG_INVALID instead
+
+enum
+{
+	// fpr load
+	PPCREC_FPR_LD_MODE_SINGLE,
+	PPCREC_FPR_LD_MODE_DOUBLE,
+
+	// fpr store
+	PPCREC_FPR_ST_MODE_SINGLE,
+	PPCREC_FPR_ST_MODE_DOUBLE,
+
+	PPCREC_FPR_ST_MODE_UI32_FROM_PS0, // store raw low-32bit of PS0
+};
+
+struct IMLUsedRegisters
+{
+	IMLUsedRegisters() {};
+
+	bool IsWrittenByRegId(IMLRegID regId) const
+	{
+		if (writtenGPR1.IsValid() && writtenGPR1.GetRegID() == regId)
+			return true;
+		if (writtenGPR2.IsValid() && writtenGPR2.GetRegID() == regId)
+			return true;
+		return false;
+	}
+
+	bool IsBaseGPRWritten(IMLReg imlReg) const
+	{
+		cemu_assert_debug(imlReg.IsValid());
+		auto regId = imlReg.GetRegID();
+		return IsWrittenByRegId(regId);
+	}
+
+	template<typename Fn>
+	void ForEachWrittenGPR(Fn F) const
+	{
+		if (writtenGPR1.IsValid())
+			F(writtenGPR1);
+		if (writtenGPR2.IsValid())
+			F(writtenGPR2);
+	}
+
+	template<typename Fn>
+	void ForEachReadGPR(Fn F) const
+	{
+		if (readGPR1.IsValid())
+			F(readGPR1);
+		if (readGPR2.IsValid())
+			F(readGPR2);
+		if (readGPR3.IsValid())
+			F(readGPR3);
+		if (readGPR4.IsValid())
+			F(readGPR4);
+	}
+
+	template<typename Fn>
+	void ForEachAccessedGPR(Fn F) const
+	{
+		// GPRs
+		if (readGPR1.IsValid())
+			F(readGPR1, false);
+		if (readGPR2.IsValid())
+			F(readGPR2, false);
+		if (readGPR3.IsValid())
+			F(readGPR3, false);
+		if (readGPR4.IsValid())
+			F(readGPR4, false);
+		if (writtenGPR1.IsValid())
+			F(writtenGPR1, true);
+		if (writtenGPR2.IsValid())
+			F(writtenGPR2, true);
+	}
+
+	IMLReg readGPR1;
+	IMLReg readGPR2;
+	IMLReg readGPR3;
+	IMLReg readGPR4;
+	IMLReg writtenGPR1;
+	IMLReg writtenGPR2;
+};
+
+struct IMLInstruction
+{
+	IMLInstruction() {}
+	IMLInstruction(const IMLInstruction& other) 
+	{
+		memcpy(this, &other, sizeof(IMLInstruction));
+	}
+
+	uint8 type;
+	uint8 operation;
+	union
+	{
+		struct
+		{
+			uint8 _padding[7];
+		}padding;
+		struct
+		{
+			IMLReg regR;
+			IMLReg regA;
+		}op_r_r;
+		struct
+		{
+			IMLReg regR;
+			IMLReg regA;
+			IMLReg regB;
+		}op_r_r_r;
+		struct
+		{
+			IMLReg regR;
+			IMLReg regA;
+			IMLReg regB;
+			IMLReg regCarry;
+		}op_r_r_r_carry;
+		struct
+		{
+			IMLReg regR;
+			IMLReg regA;
+			sint32 immS32;
+		}op_r_r_s32;
+		struct
+		{
+			IMLReg regR;
+			IMLReg regA;
+			IMLReg regCarry;
+			sint32 immS32;
+		}op_r_r_s32_carry;
+		struct
+		{
+			IMLReg regR;
+			IMLName name;
+		}op_r_name; // alias op_name_r
+		struct
+		{
+			IMLReg regR;
+			sint32 immS32;
+		}op_r_immS32;
+		struct
+		{
+			uint32 param;
+			uint32 param2;
+			uint16 paramU16;
+			IMLReg paramReg;
+		}op_macro;
+		struct
+		{
+			IMLReg registerData;
+			IMLReg registerMem;
+			IMLReg registerMem2;
+			uint8 copyWidth;
+			struct
+			{
+				bool swapEndian : 1;
+				bool signExtend : 1;
+				bool notExpanded : 1; // for floats
+			}flags2;
+			uint8 mode; // transfer mode
+			sint32 immS32;
+		}op_storeLoad;
+		struct
+		{
+			uintptr_t callAddress;
+			IMLReg regParam0;
+			IMLReg regParam1;
+			IMLReg regParam2;
+			IMLReg regReturn;
+		}op_call_imm;
+		struct
+		{
+			IMLReg regR;
+			IMLReg regA;
+		}op_fpr_r_r;
+		struct
+		{
+			IMLReg regR;
+			IMLReg regA;
+			IMLReg regB;
+		}op_fpr_r_r_r;
+		struct
+		{
+			IMLReg regR;
+			IMLReg regA;
+			IMLReg regB;
+			IMLReg regC;
+		}op_fpr_r_r_r_r;
+		struct
+		{
+			IMLReg regR;
+		}op_fpr_r;
+		struct
+		{
+			IMLReg regR; // stores the boolean result of the comparison
+			IMLReg regA;
+			IMLReg regB;
+			IMLCondition cond;
+		}op_fpr_compare;
+		struct
+		{
+			IMLReg regR; // stores the boolean result of the comparison
+			IMLReg regA;
+			IMLReg regB;
+			IMLCondition cond;
+		}op_compare;
+		struct
+		{
+			IMLReg regR; // stores the boolean result of the comparison
+			IMLReg regA;
+			sint32 immS32;
+			IMLCondition cond;
+		}op_compare_s32;
+		struct
+		{
+			IMLReg registerBool;
+			bool mustBeTrue;
+		}op_conditional_jump;
+		struct  
+		{
+			IMLReg regEA;
+			IMLReg regCompareValue;
+			IMLReg regWriteValue;
+			IMLReg regBoolOut;
+		}op_atomic_compare_store;
+		// conditional operations (emitted if supported by target platform)
+		struct
+		{
+			// r_s32
+			IMLReg regR;
+			sint32 immS32;
+			// condition
+			uint8 crRegisterIndex;
+			uint8 crBitIndex;
+			bool  bitMustBeSet;
+		}op_conditional_r_s32;
+		// X86 specific
+		struct
+		{
+			IMLCondition cond;
+			bool invertedCondition;
+		}op_x86_eflags_jcc;
+	};
+
+	bool IsSuffixInstruction() const
+	{
+		if (type == PPCREC_IML_TYPE_MACRO && operation == PPCREC_IML_MACRO_BL ||
+			type == PPCREC_IML_TYPE_MACRO && operation == PPCREC_IML_MACRO_B_FAR ||
+			type == PPCREC_IML_TYPE_MACRO && operation == PPCREC_IML_MACRO_B_TO_REG ||
+			type == PPCREC_IML_TYPE_MACRO && operation == PPCREC_IML_MACRO_LEAVE ||
+			type == PPCREC_IML_TYPE_MACRO && operation == PPCREC_IML_MACRO_HLE ||
+			type == PPCREC_IML_TYPE_CJUMP_CYCLE_CHECK ||
+			type == PPCREC_IML_TYPE_JUMP ||
+			type == PPCREC_IML_TYPE_CONDITIONAL_JUMP ||
+			type == PPCREC_IML_TYPE_X86_EFLAGS_JCC)
+			return true;
+		return false;
+	}
+
+	// instruction setters
+	void make_no_op()
+	{
+		type = PPCREC_IML_TYPE_NO_OP;
+		operation = 0;
+	}
+
+	void make_r_name(IMLReg regR, IMLName name)
+	{
+		cemu_assert_debug(regR.GetBaseFormat() == regR.GetRegFormat()); // for name load/store instructions the register must match the base format
+		type = PPCREC_IML_TYPE_R_NAME;
+		operation = PPCREC_IML_OP_ASSIGN;
+		op_r_name.regR = regR;
+		op_r_name.name = name;
+	}
+
+	void make_name_r(IMLName name, IMLReg regR)
+	{
+		cemu_assert_debug(regR.GetBaseFormat() == regR.GetRegFormat()); // for name load/store instructions the register must match the base format
+		type = PPCREC_IML_TYPE_NAME_R;
+		operation = PPCREC_IML_OP_ASSIGN;
+		op_r_name.regR = regR;
+		op_r_name.name = name;
+	}
+
+	void make_debugbreak(uint32 currentPPCAddress = 0)
+	{
+		make_macro(PPCREC_IML_MACRO_DEBUGBREAK, 0, currentPPCAddress, 0, IMLREG_INVALID);
+	}
+
+	void make_macro(uint32 macroId, uint32 param, uint32 param2, uint16 paramU16, IMLReg regParam)
+	{
+		this->type = PPCREC_IML_TYPE_MACRO;
+		this->operation = macroId;
+		this->op_macro.param = param;
+		this->op_macro.param2 = param2;
+		this->op_macro.paramU16 = paramU16;
+		this->op_macro.paramReg = regParam;
+	}
+
+	void make_cjump_cycle_check()
+	{
+		this->type = PPCREC_IML_TYPE_CJUMP_CYCLE_CHECK;
+		this->operation = 0;
+	}
+
+	void make_r_r(uint32 operation, IMLReg regR, IMLReg regA)
+	{
+		this->type = PPCREC_IML_TYPE_R_R;
+		this->operation = operation;
+		this->op_r_r.regR = regR;
+		this->op_r_r.regA = regA;
+	}
+
+	void make_r_s32(uint32 operation, IMLReg regR, sint32 immS32)
+	{
+		this->type = PPCREC_IML_TYPE_R_S32;
+		this->operation = operation;
+		this->op_r_immS32.regR = regR;
+		this->op_r_immS32.immS32 = immS32;
+	}
+
+	void make_r_r_r(uint32 operation, IMLReg regR, IMLReg regA, IMLReg regB)
+	{
+		this->type = PPCREC_IML_TYPE_R_R_R;
+		this->operation = operation;
+		this->op_r_r_r.regR = regR;
+		this->op_r_r_r.regA = regA;
+		this->op_r_r_r.regB = regB;
+	}
+
+	void make_r_r_r_carry(uint32 operation, IMLReg regR, IMLReg regA, IMLReg regB, IMLReg regCarry)
+	{
+		this->type = PPCREC_IML_TYPE_R_R_R_CARRY;
+		this->operation = operation;
+		this->op_r_r_r_carry.regR = regR;
+		this->op_r_r_r_carry.regA = regA;
+		this->op_r_r_r_carry.regB = regB;
+		this->op_r_r_r_carry.regCarry = regCarry;
+	}
+
+	void make_r_r_s32(uint32 operation, IMLReg regR, IMLReg regA, sint32 immS32)
+	{
+		this->type = PPCREC_IML_TYPE_R_R_S32;
+		this->operation = operation;
+		this->op_r_r_s32.regR = regR;
+		this->op_r_r_s32.regA = regA;
+		this->op_r_r_s32.immS32 = immS32;
+	}
+
+	void make_r_r_s32_carry(uint32 operation, IMLReg regR, IMLReg regA, sint32 immS32, IMLReg regCarry)
+	{
+		this->type = PPCREC_IML_TYPE_R_R_S32_CARRY;
+		this->operation = operation;
+		this->op_r_r_s32_carry.regR = regR;
+		this->op_r_r_s32_carry.regA = regA;
+		this->op_r_r_s32_carry.immS32 = immS32;
+		this->op_r_r_s32_carry.regCarry = regCarry;
+	}
+
+	void make_compare(IMLReg regA, IMLReg regB, IMLReg regR, IMLCondition cond)
+	{
+		this->type = PPCREC_IML_TYPE_COMPARE;
+		this->operation = PPCREC_IML_OP_INVALID;
+		this->op_compare.regR = regR;
+		this->op_compare.regA = regA;
+		this->op_compare.regB = regB;
+		this->op_compare.cond = cond;
+	}
+
+	void make_compare_s32(IMLReg regA, sint32 immS32, IMLReg regR, IMLCondition cond)
+	{
+		this->type = PPCREC_IML_TYPE_COMPARE_S32;
+		this->operation = PPCREC_IML_OP_INVALID;
+		this->op_compare_s32.regR = regR;
+		this->op_compare_s32.regA = regA;
+		this->op_compare_s32.immS32 = immS32;
+		this->op_compare_s32.cond = cond;
+	}
+
+	void make_conditional_jump(IMLReg regBool, bool mustBeTrue)
+	{
+		this->type = PPCREC_IML_TYPE_CONDITIONAL_JUMP;
+		this->operation = PPCREC_IML_OP_INVALID;
+		this->op_conditional_jump.registerBool = regBool;
+		this->op_conditional_jump.mustBeTrue = mustBeTrue;
+	}
+
+	void make_jump()
+	{
+		this->type = PPCREC_IML_TYPE_JUMP;
+		this->operation = PPCREC_IML_OP_INVALID;
+	}
+
+	// load from memory
+	void make_r_memory(IMLReg regD, IMLReg regMem, sint32 immS32, uint32 copyWidth, bool signExtend, bool switchEndian)
+	{
+		this->type = PPCREC_IML_TYPE_LOAD;
+		this->operation = 0;
+		this->op_storeLoad.registerData = regD;
+		this->op_storeLoad.registerMem = regMem;
+		this->op_storeLoad.immS32 = immS32;
+		this->op_storeLoad.copyWidth = copyWidth;
+		this->op_storeLoad.flags2.swapEndian = switchEndian;
+		this->op_storeLoad.flags2.signExtend = signExtend;
+	}
+
+	// store to memory
+	void make_memory_r(IMLReg regS, IMLReg regMem, sint32 immS32, uint32 copyWidth, bool switchEndian)
+	{
+		this->type = PPCREC_IML_TYPE_STORE;
+		this->operation = 0;
+		this->op_storeLoad.registerData = regS;
+		this->op_storeLoad.registerMem = regMem;
+		this->op_storeLoad.immS32 = immS32;
+		this->op_storeLoad.copyWidth = copyWidth;
+		this->op_storeLoad.flags2.swapEndian = switchEndian;
+		this->op_storeLoad.flags2.signExtend = false;
+	}
+
+	void make_atomic_cmp_store(IMLReg regEA, IMLReg regCompareValue, IMLReg regWriteValue, IMLReg regSuccessOutput)
+	{
+		this->type = PPCREC_IML_TYPE_ATOMIC_CMP_STORE;
+		this->operation = 0;
+		this->op_atomic_compare_store.regEA = regEA;
+		this->op_atomic_compare_store.regCompareValue = regCompareValue;
+		this->op_atomic_compare_store.regWriteValue = regWriteValue;
+		this->op_atomic_compare_store.regBoolOut = regSuccessOutput;
+	}
+
+	void make_call_imm(uintptr_t callAddress, IMLReg param0, IMLReg param1, IMLReg param2, IMLReg regReturn)
+	{
+		this->type = PPCREC_IML_TYPE_CALL_IMM;
+		this->operation = 0;
+		this->op_call_imm.callAddress = callAddress;
+		this->op_call_imm.regParam0 = param0;
+		this->op_call_imm.regParam1 = param1;
+		this->op_call_imm.regParam2 = param2;
+		this->op_call_imm.regReturn = regReturn;
+	}
+
+	// FPR
+
+	// load from memory
+	void make_fpr_r_memory(IMLReg registerDestination, IMLReg registerMemory, sint32 immS32, uint32 mode, bool switchEndian)
+	{
+		this->type = PPCREC_IML_TYPE_FPR_LOAD;
+		this->operation = 0;
+		this->op_storeLoad.registerData = registerDestination;
+		this->op_storeLoad.registerMem = registerMemory;
+		this->op_storeLoad.immS32 = immS32;
+		this->op_storeLoad.mode = mode;
+		this->op_storeLoad.flags2.swapEndian = switchEndian;
+	}
+
+	void make_fpr_r_memory_indexed(IMLReg registerDestination, IMLReg registerMemory1, IMLReg registerMemory2, uint32 mode, bool switchEndian)
+	{
+		this->type = PPCREC_IML_TYPE_FPR_LOAD_INDEXED;
+		this->operation = 0;
+		this->op_storeLoad.registerData = registerDestination;
+		this->op_storeLoad.registerMem = registerMemory1;
+		this->op_storeLoad.registerMem2 = registerMemory2;
+		this->op_storeLoad.immS32 = 0;
+		this->op_storeLoad.mode = mode;
+		this->op_storeLoad.flags2.swapEndian = switchEndian;
+	}
+
+	// store to memory
+	void make_fpr_memory_r(IMLReg registerSource, IMLReg registerMemory, sint32 immS32, uint32 mode, bool switchEndian)
+	{
+		this->type = PPCREC_IML_TYPE_FPR_STORE;
+		this->operation = 0;
+		this->op_storeLoad.registerData = registerSource;
+		this->op_storeLoad.registerMem = registerMemory;
+		this->op_storeLoad.immS32 = immS32;
+		this->op_storeLoad.mode = mode;
+		this->op_storeLoad.flags2.swapEndian = switchEndian;
+	}
+
+	void make_fpr_memory_r_indexed(IMLReg registerSource, IMLReg registerMemory1, IMLReg registerMemory2, sint32 immS32, uint32 mode, bool switchEndian)
+	{
+		this->type = PPCREC_IML_TYPE_FPR_STORE_INDEXED;
+		this->operation = 0;
+		this->op_storeLoad.registerData = registerSource;
+		this->op_storeLoad.registerMem = registerMemory1;
+		this->op_storeLoad.registerMem2 = registerMemory2;
+		this->op_storeLoad.immS32 = immS32;
+		this->op_storeLoad.mode = mode;
+		this->op_storeLoad.flags2.swapEndian = switchEndian;
+	}
+
+	void make_fpr_compare(IMLReg regA, IMLReg regB, IMLReg regR, IMLCondition cond)
+	{
+		this->type = PPCREC_IML_TYPE_FPR_COMPARE;
+		this->operation = -999;
+		this->op_fpr_compare.regR = regR;
+		this->op_fpr_compare.regA = regA;
+		this->op_fpr_compare.regB = regB;
+		this->op_fpr_compare.cond = cond;
+	}
+
+	void make_fpr_r(sint32 operation, IMLReg registerResult)
+	{
+		// OP (fpr)
+		this->type = PPCREC_IML_TYPE_FPR_R;
+		this->operation = operation;
+		this->op_fpr_r.regR = registerResult;
+	}
+
+	void make_fpr_r_r(sint32 operation, IMLReg registerResult, IMLReg registerOperand, sint32 crRegister=PPC_REC_INVALID_REGISTER)
+	{
+		// fpr OP fpr
+		this->type = PPCREC_IML_TYPE_FPR_R_R;
+		this->operation = operation;
+		this->op_fpr_r_r.regR = registerResult;
+		this->op_fpr_r_r.regA = registerOperand;
+	}
+
+	void make_fpr_r_r_r(sint32 operation, IMLReg registerResult, IMLReg registerOperand1, IMLReg registerOperand2, sint32 crRegister=PPC_REC_INVALID_REGISTER)
+	{
+		// fpr = OP (fpr,fpr)
+		this->type = PPCREC_IML_TYPE_FPR_R_R_R;
+		this->operation = operation;
+		this->op_fpr_r_r_r.regR = registerResult;
+		this->op_fpr_r_r_r.regA = registerOperand1;
+		this->op_fpr_r_r_r.regB = registerOperand2;
+	}
+
+	void make_fpr_r_r_r_r(sint32 operation, IMLReg registerResult, IMLReg registerOperandA, IMLReg registerOperandB, IMLReg registerOperandC, sint32 crRegister=PPC_REC_INVALID_REGISTER)
+	{
+		// fpr = OP (fpr,fpr,fpr)
+		this->type = PPCREC_IML_TYPE_FPR_R_R_R_R;
+		this->operation = operation;
+		this->op_fpr_r_r_r_r.regR = registerResult;
+		this->op_fpr_r_r_r_r.regA = registerOperandA;
+		this->op_fpr_r_r_r_r.regB = registerOperandB;
+		this->op_fpr_r_r_r_r.regC = registerOperandC;
+	}
+
+	/* X86 specific */
+	void make_x86_eflags_jcc(IMLCondition cond, bool invertedCondition)
+	{
+		this->type = PPCREC_IML_TYPE_X86_EFLAGS_JCC;
+		this->operation = -999;
+		this->op_x86_eflags_jcc.cond = cond;
+		this->op_x86_eflags_jcc.invertedCondition = invertedCondition;
+	}
+
+	void CheckRegisterUsage(IMLUsedRegisters* registersUsed) const;
+	bool HasSideEffects() const; // returns true if the instruction has side effects beyond just reading and writing registers. Dead code elimination uses this to know if an instruction can be dropped when the regular register outputs are not used
+
+	void RewriteGPR(const std::unordered_map<IMLRegID, IMLRegID>& translationTable);
+};
+
+// architecture specific constants
+namespace IMLArchX86
+{
+	static constexpr int PHYSREG_GPR_BASE = 0;
+	static constexpr int PHYSREG_FPR_BASE = 16;
+};
\ No newline at end of file
diff --git a/src/Cafe/HW/Espresso/Recompiler/IML/IMLOptimizer.cpp b/src/Cafe/HW/Espresso/Recompiler/IML/IMLOptimizer.cpp
new file mode 100644
index 00000000..7671a163
--- /dev/null
+++ b/src/Cafe/HW/Espresso/Recompiler/IML/IMLOptimizer.cpp
@@ -0,0 +1,719 @@
+#include "Cafe/HW/Espresso/Interpreter/PPCInterpreterInternal.h"
+#include "Cafe/HW/Espresso/Recompiler/IML/IML.h"
+#include "Cafe/HW/Espresso/Recompiler/IML/IMLInstruction.h"
+
+#include "../PPCRecompiler.h"
+#include "../PPCRecompilerIml.h"
+#include "../BackendX64/BackendX64.h"
+
+#include "Common/FileStream.h"
+
+#include <boost/container/static_vector.hpp>
+#include <boost/container/small_vector.hpp>
+
+IMLReg _FPRRegFromID(IMLRegID regId)
+{
+	return IMLReg(IMLRegFormat::F64, IMLRegFormat::F64, 0, regId);
+}
+
+void PPCRecompiler_optimizeDirectFloatCopiesScanForward(ppcImlGenContext_t* ppcImlGenContext, IMLSegment* imlSegment, sint32 imlIndexLoad, IMLReg fprReg)
+{
+	IMLRegID fprIndex = fprReg.GetRegID();
+
+	IMLInstruction* imlInstructionLoad = imlSegment->imlList.data() + imlIndexLoad;
+	if (imlInstructionLoad->op_storeLoad.flags2.notExpanded)
+		return;
+	boost::container::static_vector<sint32, 4> trackedMoves; // only track up to 4 copies
+	IMLUsedRegisters registersUsed;
+	sint32 scanRangeEnd = std::min<sint32>(imlIndexLoad + 25, imlSegment->imlList.size()); // don't scan too far (saves performance and also the chances we can merge the load+store become low at high distances)
+	bool foundMatch = false;
+	sint32 lastStore = -1;
+	for (sint32 i = imlIndexLoad + 1; i < scanRangeEnd; i++)
+	{
+		IMLInstruction* imlInstruction = imlSegment->imlList.data() + i;
+		if (imlInstruction->IsSuffixInstruction())
+			break;
+		// check if FPR is stored
+		if ((imlInstruction->type == PPCREC_IML_TYPE_FPR_STORE && imlInstruction->op_storeLoad.mode == PPCREC_FPR_ST_MODE_SINGLE) ||
+			(imlInstruction->type == PPCREC_IML_TYPE_FPR_STORE_INDEXED && imlInstruction->op_storeLoad.mode == PPCREC_FPR_ST_MODE_SINGLE))
+		{
+			if (imlInstruction->op_storeLoad.registerData.GetRegID() == fprIndex)
+			{
+				if (foundMatch == false)
+				{
+					// flag the load-single instruction as "don't expand" (leave single value as-is)
+					imlInstructionLoad->op_storeLoad.flags2.notExpanded = true;
+				}
+				// also set the flag for the store instruction
+				IMLInstruction* imlInstructionStore = imlInstruction;
+				imlInstructionStore->op_storeLoad.flags2.notExpanded = true;
+
+				foundMatch = true;
+				lastStore = i + 1;
+
+				continue;
+			}
+		}
+		// if the FPR is copied then keep track of it. We can expand the copies instead of the original
+		if (imlInstruction->type == PPCREC_IML_TYPE_FPR_R_R && imlInstruction->operation == PPCREC_IML_OP_FPR_ASSIGN && imlInstruction->op_fpr_r_r.regA.GetRegID() == fprIndex)
+		{
+			if (imlInstruction->op_fpr_r_r.regR.GetRegID() == fprIndex)
+			{
+				// unexpected no-op
+				break;
+			}
+			if (trackedMoves.size() >= trackedMoves.capacity())
+			{
+				// we cant track any more moves, expand here
+				lastStore = i;
+				break;
+			}
+			trackedMoves.push_back(i);
+			continue;
+		}
+		// check if FPR is overwritten
+		imlInstruction->CheckRegisterUsage(&registersUsed);
+		if (registersUsed.writtenGPR1.IsValidAndSameRegID(fprIndex) || registersUsed.writtenGPR2.IsValidAndSameRegID(fprIndex))
+			break;
+		if (registersUsed.readGPR1.IsValidAndSameRegID(fprIndex))
+			break;
+		if (registersUsed.readGPR2.IsValidAndSameRegID(fprIndex))
+			break;
+		if (registersUsed.readGPR3.IsValidAndSameRegID(fprIndex))
+			break;
+		if (registersUsed.readGPR4.IsValidAndSameRegID(fprIndex))
+			break;
+	}
+
+	if (foundMatch)
+	{
+		// insert expand instructions for each target register of a move
+		sint32 positionBias = 0;
+		for (auto& trackedMove : trackedMoves)
+		{
+			sint32 realPosition = trackedMove + positionBias;
+			IMLInstruction* imlMoveInstruction = imlSegment->imlList.data() + realPosition;
+			if (realPosition >= lastStore)
+				break; // expand is inserted before this move
+			else
+				lastStore++;
+
+			cemu_assert_debug(imlMoveInstruction->type == PPCREC_IML_TYPE_FPR_R_R && imlMoveInstruction->op_fpr_r_r.regA.GetRegID() == fprIndex);
+			cemu_assert_debug(imlMoveInstruction->op_fpr_r_r.regA.GetRegFormat() == IMLRegFormat::F64);
+			auto dstReg = imlMoveInstruction->op_fpr_r_r.regR;
+			IMLInstruction* newExpand = PPCRecompiler_insertInstruction(imlSegment, realPosition+1); // one after the move
+			newExpand->make_fpr_r(PPCREC_IML_OP_FPR_EXPAND_F32_TO_F64, dstReg);
+			positionBias++;
+		}
+		// insert expand instruction after store
+		IMLInstruction* newExpand = PPCRecompiler_insertInstruction(imlSegment, lastStore);
+		newExpand->make_fpr_r(PPCREC_IML_OP_FPR_EXPAND_F32_TO_F64, _FPRRegFromID(fprIndex));
+	}
+}
+
+/*
+* Scans for patterns:
+* <Load sp float into register f>
+* <Random unrelated instructions>
+* <Store sp float from register f>
+* For these patterns the store and load is modified to work with un-extended values (float remains as float, no double conversion)
+* The float->double extension is then executed later
+* Advantages:
+* Keeps denormals and other special float values intact
+* Slightly improves performance
+*/
+void IMLOptimizer_OptimizeDirectFloatCopies(ppcImlGenContext_t* ppcImlGenContext)
+{
+	for (IMLSegment* segIt : ppcImlGenContext->segmentList2)
+	{
+		for (sint32 i = 0; i < segIt->imlList.size(); i++)
+		{
+			IMLInstruction* imlInstruction = segIt->imlList.data() + i;
+			if (imlInstruction->type == PPCREC_IML_TYPE_FPR_LOAD && imlInstruction->op_storeLoad.mode == PPCREC_FPR_LD_MODE_SINGLE)
+			{
+				PPCRecompiler_optimizeDirectFloatCopiesScanForward(ppcImlGenContext, segIt, i, imlInstruction->op_storeLoad.registerData);
+			}
+			else if (imlInstruction->type == PPCREC_IML_TYPE_FPR_LOAD_INDEXED && imlInstruction->op_storeLoad.mode == PPCREC_FPR_LD_MODE_SINGLE)
+			{
+				PPCRecompiler_optimizeDirectFloatCopiesScanForward(ppcImlGenContext, segIt, i, imlInstruction->op_storeLoad.registerData);
+			}
+		}
+	}
+}
+
+void PPCRecompiler_optimizeDirectIntegerCopiesScanForward(ppcImlGenContext_t* ppcImlGenContext, IMLSegment* imlSegment, sint32 imlIndexLoad, IMLReg gprReg)
+{
+	cemu_assert_debug(gprReg.GetBaseFormat() == IMLRegFormat::I64); // todo - proper handling required for non-standard sizes
+	cemu_assert_debug(gprReg.GetRegFormat() == IMLRegFormat::I32);
+
+	IMLRegID gprIndex = gprReg.GetRegID();
+	IMLInstruction* imlInstructionLoad = imlSegment->imlList.data() + imlIndexLoad;
+	if ( imlInstructionLoad->op_storeLoad.flags2.swapEndian == false )
+		return;
+	bool foundMatch = false;
+	IMLUsedRegisters registersUsed;
+	sint32 scanRangeEnd = std::min<sint32>(imlIndexLoad + 25, imlSegment->imlList.size()); // don't scan too far (saves performance and also the chances we can merge the load+store become low at high distances)
+	sint32 i = imlIndexLoad + 1;
+	for (; i < scanRangeEnd; i++)
+	{
+		IMLInstruction* imlInstruction = imlSegment->imlList.data() + i;
+		if (imlInstruction->IsSuffixInstruction())
+			break;
+		// check if GPR is stored
+		if ((imlInstruction->type == PPCREC_IML_TYPE_STORE && imlInstruction->op_storeLoad.copyWidth == 32 ) )
+		{
+			if (imlInstruction->op_storeLoad.registerMem.GetRegID() == gprIndex)
+				break;
+			if (imlInstruction->op_storeLoad.registerData.GetRegID() == gprIndex)
+			{
+				IMLInstruction* imlInstructionStore = imlInstruction;
+				if (foundMatch == false)
+				{
+					// switch the endian swap flag for the load instruction
+					imlInstructionLoad->op_storeLoad.flags2.swapEndian = !imlInstructionLoad->op_storeLoad.flags2.swapEndian;
+					foundMatch = true;
+				}
+				// switch the endian swap flag for the store instruction
+				imlInstructionStore->op_storeLoad.flags2.swapEndian = !imlInstructionStore->op_storeLoad.flags2.swapEndian;
+				// keep scanning
+				continue;
+			}
+		}
+		// check if GPR is accessed
+		imlInstruction->CheckRegisterUsage(&registersUsed);
+		if (registersUsed.readGPR1.IsValidAndSameRegID(gprIndex) ||
+			registersUsed.readGPR2.IsValidAndSameRegID(gprIndex) ||
+			registersUsed.readGPR3.IsValidAndSameRegID(gprIndex))
+		{
+			break;
+		}
+		if (registersUsed.IsBaseGPRWritten(gprReg))
+			return; // GPR overwritten, we don't need to byte swap anymore
+	}
+	if (foundMatch)
+	{
+		PPCRecompiler_insertInstruction(imlSegment, i)->make_r_r(PPCREC_IML_OP_ENDIAN_SWAP, gprReg, gprReg);
+	}
+}
+
+/*
+* Scans for patterns:
+* <Load sp integer into register r>
+* <Random unrelated instructions>
+* <Store sp integer from register r>
+* For these patterns the store and load is modified to work with non-swapped values
+* The big_endian->little_endian conversion is then executed later
+* Advantages:
+* Slightly improves performance
+*/
+void IMLOptimizer_OptimizeDirectIntegerCopies(ppcImlGenContext_t* ppcImlGenContext)
+{
+	for (IMLSegment* segIt : ppcImlGenContext->segmentList2)
+	{
+		for (sint32 i = 0; i < segIt->imlList.size(); i++)
+		{
+			IMLInstruction* imlInstruction = segIt->imlList.data() + i;
+			if (imlInstruction->type == PPCREC_IML_TYPE_LOAD && imlInstruction->op_storeLoad.copyWidth == 32 && imlInstruction->op_storeLoad.flags2.swapEndian )
+			{
+				PPCRecompiler_optimizeDirectIntegerCopiesScanForward(ppcImlGenContext, segIt, i, imlInstruction->op_storeLoad.registerData);
+			}
+		}
+	}
+}
+
+IMLName PPCRecompilerImlGen_GetRegName(ppcImlGenContext_t* ppcImlGenContext, IMLReg reg);
+
+sint32 _getGQRIndexFromRegister(ppcImlGenContext_t* ppcImlGenContext, IMLReg gqrReg)
+{
+	if (gqrReg.IsInvalid())
+		return -1;
+	sint32 namedReg = PPCRecompilerImlGen_GetRegName(ppcImlGenContext, gqrReg);
+	if (namedReg >= (PPCREC_NAME_SPR0 + SPR_UGQR0) && namedReg <= (PPCREC_NAME_SPR0 + SPR_UGQR7))
+	{
+		return namedReg - (PPCREC_NAME_SPR0 + SPR_UGQR0);
+	}
+	else
+	{
+		cemu_assert_suspicious();
+	}
+	return -1;
+}
+
+bool PPCRecompiler_isUGQRValueKnown(ppcImlGenContext_t* ppcImlGenContext, sint32 gqrIndex, uint32& gqrValue)
+{
+	// the default configuration is:
+	// UGQR0 = 0x00000000
+	// UGQR2 = 0x00040004
+	// UGQR3 = 0x00050005
+	// UGQR4 = 0x00060006
+	// UGQR5 = 0x00070007
+	// but games are free to modify UGQR2 to UGQR7 it seems.
+	// no game modifies UGQR0 so it's safe enough to optimize for the default value
+	// Ideally we would do some kind of runtime tracking and second recompilation to create fast paths for PSQ_L/PSQ_ST but thats todo
+	if (gqrIndex == 0)
+		gqrValue = 0x00000000;
+	else
+		return false;
+	return true;
+}
+
+// analyses register dependencies across the entire function
+// per segment this will generate information about which registers need to be preserved and which ones don't (e.g. are overwritten)
+class IMLOptimizerRegIOAnalysis
+{
+  public:
+	// constructor with segment pointer list as span
+	IMLOptimizerRegIOAnalysis(std::span<IMLSegment*> segmentList, uint32 maxRegId) : m_segmentList(segmentList), m_maxRegId(maxRegId)
+	{
+		m_segRegisterInOutList.resize(segmentList.size());
+	}
+
+	struct IMLSegmentRegisterInOut
+	{
+		// todo - since our register ID range is usually pretty small (<64) we could use integer bitmasks to accelerate this? There is a helper class used in RA code already
+		std::unordered_set<IMLRegID> regWritten; // registers which are modified in this segment
+		std::unordered_set<IMLRegID> regImported; // registers which are read in this segment before they are written (importing value from previous segments)
+		std::unordered_set<IMLRegID> regForward; // registers which are not read or written in this segment, but are imported into a later segment (propagated info)
+	};
+
+	// calculate which registers are imported (read-before-written) and forwarded (read-before-written by a later segment) per segment
+	// then in a second step propagate the dependencies across linked segments
+	void ComputeDepedencies()
+	{
+		std::vector<IMLSegmentRegisterInOut>& segRegisterInOutList = m_segRegisterInOutList;
+		IMLSegmentRegisterInOut* segIO = segRegisterInOutList.data();
+		uint32 index = 0;
+		for(auto& seg : m_segmentList)
+		{
+			seg->momentaryIndex = index;
+			index++;
+			for(auto& instr : seg->imlList)
+			{
+				IMLUsedRegisters registerUsage;
+				instr.CheckRegisterUsage(&registerUsage);
+				// registers are considered imported if they are read before being written in this seg
+				registerUsage.ForEachReadGPR([&](IMLReg gprReg) {
+					IMLRegID gprId = gprReg.GetRegID();
+					if (!segIO->regWritten.contains(gprId))
+					{
+						segIO->regImported.insert(gprId);
+					}
+				});
+				registerUsage.ForEachWrittenGPR([&](IMLReg gprReg) {
+					IMLRegID gprId = gprReg.GetRegID();
+					segIO->regWritten.insert(gprId);
+				});
+			}
+			segIO++;
+		}
+		// for every exit segment, import all registers
+		for(auto& seg : m_segmentList)
+		{
+			if (!seg->nextSegmentIsUncertain)
+				continue;
+			if(seg->deadCodeEliminationHintSeg)
+				continue;
+			IMLSegmentRegisterInOut& segIO = segRegisterInOutList[seg->momentaryIndex];
+			for(uint32 i=0; i<=m_maxRegId; i++)
+			{
+				segIO.regImported.insert((IMLRegID)i);
+			}
+		}
+		// broadcast dependencies across segment chains
+		std::unordered_set<uint32> segIdsWhichNeedUpdate;
+		for (uint32 i = 0; i < m_segmentList.size(); i++)
+		{
+			segIdsWhichNeedUpdate.insert(i);
+		}
+		while(!segIdsWhichNeedUpdate.empty())
+		{
+			auto firstIt = segIdsWhichNeedUpdate.begin();
+			uint32 segId = *firstIt;
+			segIdsWhichNeedUpdate.erase(firstIt);
+			// forward regImported and regForward to earlier segments into their regForward, unless the register is written
+			auto& curSeg = m_segmentList[segId];
+			IMLSegmentRegisterInOut& curSegIO = segRegisterInOutList[segId];
+			for(auto& prevSeg : curSeg->list_prevSegments)
+			{
+				IMLSegmentRegisterInOut& prevSegIO = segRegisterInOutList[prevSeg->momentaryIndex];
+				bool prevSegChanged = false;
+				for(auto& regId : curSegIO.regImported)
+				{
+					if (!prevSegIO.regWritten.contains(regId))
+						prevSegChanged |= prevSegIO.regForward.insert(regId).second;
+				}
+				for(auto& regId : curSegIO.regForward)
+				{
+					if (!prevSegIO.regWritten.contains(regId))
+						prevSegChanged |= prevSegIO.regForward.insert(regId).second;
+				}
+				if(prevSegChanged)
+					segIdsWhichNeedUpdate.insert(prevSeg->momentaryIndex);
+			}
+			// same for hint links
+			for(auto& prevSeg : curSeg->list_deadCodeHintBy)
+			{
+				IMLSegmentRegisterInOut& prevSegIO = segRegisterInOutList[prevSeg->momentaryIndex];
+				bool prevSegChanged = false;
+				for(auto& regId : curSegIO.regImported)
+				{
+					if (!prevSegIO.regWritten.contains(regId))
+						prevSegChanged |= prevSegIO.regForward.insert(regId).second;
+				}
+				for(auto& regId : curSegIO.regForward)
+				{
+					if (!prevSegIO.regWritten.contains(regId))
+						prevSegChanged |= prevSegIO.regForward.insert(regId).second;
+				}
+				if(prevSegChanged)
+					segIdsWhichNeedUpdate.insert(prevSeg->momentaryIndex);
+			}
+		}
+	}
+
+	std::unordered_set<IMLRegID> GetRegistersNeededAtEndOfSegment(IMLSegment& seg)
+	{
+		std::unordered_set<IMLRegID> regsNeeded;
+		if(seg.nextSegmentIsUncertain)
+		{
+			if(seg.deadCodeEliminationHintSeg)
+			{
+				auto& nextSegIO = m_segRegisterInOutList[seg.deadCodeEliminationHintSeg->momentaryIndex];
+				regsNeeded.insert(nextSegIO.regImported.begin(), nextSegIO.regImported.end());
+				regsNeeded.insert(nextSegIO.regForward.begin(), nextSegIO.regForward.end());
+			}
+			else
+			{
+				// add all regs
+				for(uint32 i = 0; i <= m_maxRegId; i++)
+					regsNeeded.insert(i);
+			}
+			return regsNeeded;
+		}
+		if(seg.nextSegmentBranchTaken)
+		{
+			auto& nextSegIO = m_segRegisterInOutList[seg.nextSegmentBranchTaken->momentaryIndex];
+			regsNeeded.insert(nextSegIO.regImported.begin(), nextSegIO.regImported.end());
+			regsNeeded.insert(nextSegIO.regForward.begin(), nextSegIO.regForward.end());
+		}
+		if(seg.nextSegmentBranchNotTaken)
+		{
+			auto& nextSegIO = m_segRegisterInOutList[seg.nextSegmentBranchNotTaken->momentaryIndex];
+			regsNeeded.insert(nextSegIO.regImported.begin(), nextSegIO.regImported.end());
+			regsNeeded.insert(nextSegIO.regForward.begin(), nextSegIO.regForward.end());
+		}
+		return regsNeeded;
+	}
+
+	bool IsRegisterNeededAtEndOfSegment(IMLSegment& seg, IMLRegID regId)
+	{
+		if(seg.nextSegmentIsUncertain)
+		{
+			if(!seg.deadCodeEliminationHintSeg)
+				return true;
+			auto& nextSegIO = m_segRegisterInOutList[seg.deadCodeEliminationHintSeg->momentaryIndex];
+			if(nextSegIO.regImported.contains(regId))
+				return true;
+			if(nextSegIO.regForward.contains(regId))
+				return true;
+			return false;
+		}
+		if(seg.nextSegmentBranchTaken)
+		{
+			auto& nextSegIO = m_segRegisterInOutList[seg.nextSegmentBranchTaken->momentaryIndex];
+			if(nextSegIO.regImported.contains(regId))
+				return true;
+			if(nextSegIO.regForward.contains(regId))
+				return true;
+		}
+		if(seg.nextSegmentBranchNotTaken)
+		{
+			auto& nextSegIO = m_segRegisterInOutList[seg.nextSegmentBranchNotTaken->momentaryIndex];
+			if(nextSegIO.regImported.contains(regId))
+				return true;
+			if(nextSegIO.regForward.contains(regId))
+				return true;
+		}
+		return false;
+	}
+
+  private:
+	std::span<IMLSegment*> m_segmentList;
+	uint32 m_maxRegId;
+
+	std::vector<IMLSegmentRegisterInOut> m_segRegisterInOutList;
+
+};
+
+// scan backwards starting from index and return the index of the first found instruction which writes to the given register (by id)
+sint32 IMLUtil_FindInstructionWhichWritesRegister(IMLSegment& seg, sint32 startIndex, IMLReg reg, sint32 maxScanDistance = -1)
+{
+	sint32 endIndex = std::max<sint32>(startIndex - maxScanDistance, 0);
+	for (sint32 i = startIndex; i >= endIndex; i--)
+	{
+		IMLInstruction& imlInstruction = seg.imlList[i];
+		IMLUsedRegisters registersUsed;
+		imlInstruction.CheckRegisterUsage(&registersUsed);
+		if (registersUsed.IsBaseGPRWritten(reg))
+			return i;
+	}
+	return -1;
+}
+
+// returns true if the instruction can safely be moved while keeping ordering constraints and data dependencies intact
+// initialIndex is inclusive, targetIndex is exclusive
+bool IMLUtil_CanMoveInstructionTo(IMLSegment& seg, sint32 initialIndex, sint32 targetIndex)
+{
+	boost::container::static_vector<IMLRegID, 8> regsWritten;
+	boost::container::static_vector<IMLRegID, 8> regsRead;
+	// get list of read and written registers
+	IMLUsedRegisters registersUsed;
+	seg.imlList[initialIndex].CheckRegisterUsage(&registersUsed);
+	registersUsed.ForEachAccessedGPR([&](IMLReg reg, bool isWritten) {
+		if (isWritten)
+			regsWritten.push_back(reg.GetRegID());
+		else
+			regsRead.push_back(reg.GetRegID());
+	});
+	// check all the instructions inbetween
+	if(initialIndex < targetIndex)
+	{
+		sint32 scanStartIndex = initialIndex+1; // +1 to skip the moving instruction itself
+		sint32 scanEndIndex = targetIndex;
+		for (sint32 i = scanStartIndex; i < scanEndIndex; i++)
+		{
+			IMLUsedRegisters registersUsed;
+			seg.imlList[i].CheckRegisterUsage(&registersUsed);
+			// in order to be able to move an instruction past another instruction, any of the read registers must not be modified (written)
+			// and any of it's written registers must not be read
+			bool canMove = true;
+			registersUsed.ForEachAccessedGPR([&](IMLReg reg, bool isWritten) {
+				IMLRegID regId = reg.GetRegID();
+				if (!isWritten)
+					canMove = canMove && std::find(regsWritten.begin(), regsWritten.end(), regId) == regsWritten.end();
+				else
+					canMove = canMove && std::find(regsRead.begin(), regsRead.end(), regId) == regsRead.end();
+			});
+			if(!canMove)
+				return false;
+		}
+	}
+	else
+	{
+		cemu_assert_unimplemented(); // backwards scan is todo
+		return false;
+	}
+	return true;
+}
+
+sint32 IMLUtil_CountRegisterReadsInRange(IMLSegment& seg, sint32 scanStartIndex, sint32 scanEndIndex, IMLRegID regId)
+{
+	cemu_assert_debug(scanStartIndex <= scanEndIndex);
+	cemu_assert_debug(scanEndIndex < seg.imlList.size());
+	sint32 count = 0;
+	for (sint32 i = scanStartIndex; i <= scanEndIndex; i++)
+	{
+		IMLUsedRegisters registersUsed;
+		seg.imlList[i].CheckRegisterUsage(&registersUsed);
+		registersUsed.ForEachReadGPR([&](IMLReg reg) {
+			if (reg.GetRegID() == regId)
+				count++;
+		});
+	}
+	return count;
+}
+
+// move instruction from one index to another
+// instruction will be inserted before the instruction at targetIndex
+// returns the new instruction index of the moved instruction
+sint32 IMLUtil_MoveInstructionTo(IMLSegment& seg, sint32 initialIndex, sint32 targetIndex)
+{
+	cemu_assert_debug(initialIndex != targetIndex);
+	IMLInstruction temp = seg.imlList[initialIndex];
+	if (initialIndex < targetIndex)
+	{
+		cemu_assert_debug(targetIndex > 0);
+		targetIndex--;
+		for(size_t i=initialIndex; i<targetIndex; i++)
+			seg.imlList[i] = seg.imlList[i+1];
+		seg.imlList[targetIndex] = temp;
+		return targetIndex;
+	}
+	else
+	{
+		cemu_assert_unimplemented(); // testing needed
+		std::copy(seg.imlList.begin() + targetIndex, seg.imlList.begin() + initialIndex, seg.imlList.begin() + targetIndex + 1);
+		seg.imlList[targetIndex] = temp;
+		return targetIndex;
+	}
+}
+
+// x86 specific
+bool IMLOptimizerX86_ModifiesEFlags(IMLInstruction& inst)
+{
+	// this is a very conservative implementation. There are more cases but this is good enough for now
+	if(inst.type == PPCREC_IML_TYPE_NAME_R || inst.type == PPCREC_IML_TYPE_R_NAME)
+		return false;
+	if((inst.type == PPCREC_IML_TYPE_R_R || inst.type == PPCREC_IML_TYPE_R_S32) && inst.operation == PPCREC_IML_OP_ASSIGN)
+		return false;
+	return true; // if we dont know for sure, assume it does
+}
+
+void IMLOptimizer_DebugPrintSeg(ppcImlGenContext_t& ppcImlGenContext, IMLSegment& seg)
+{
+	printf("----------------\n");
+	IMLDebug_DumpSegment(&ppcImlGenContext, &seg);
+	fflush(stdout);
+}
+
+void IMLOptimizer_RemoveDeadCodeFromSegment(IMLOptimizerRegIOAnalysis& regIoAnalysis, IMLSegment& seg)
+{
+	// algorithm works like this:
+	// Calculate which registers need to be preserved at the end of each segment
+	// Then for each segment:
+	// - Iterate instructions backwards
+	// - Maintain a list of registers which are read at a later point (initially this is the list from the first step)
+	// - If an instruction only modifies registers which are not in the read list and has no side effects, then it is dead code and can be replaced with a no-op
+
+	std::unordered_set<IMLRegID> regsNeeded = regIoAnalysis.GetRegistersNeededAtEndOfSegment(seg);
+
+	// start with suffix instruction
+	if(seg.HasSuffixInstruction())
+	{
+		IMLInstruction& imlInstruction = seg.imlList[seg.GetSuffixInstructionIndex()];
+		IMLUsedRegisters registersUsed;
+		imlInstruction.CheckRegisterUsage(&registersUsed);
+		registersUsed.ForEachWrittenGPR([&](IMLReg reg) {
+			regsNeeded.erase(reg.GetRegID());
+		});
+		registersUsed.ForEachReadGPR([&](IMLReg reg) {
+			regsNeeded.insert(reg.GetRegID());
+		});
+	}
+	// iterate instructions backwards
+	for (sint32 i = seg.imlList.size() - (seg.HasSuffixInstruction() ? 2:1); i >= 0; i--)
+	{
+		IMLInstruction& imlInstruction = seg.imlList[i];
+		IMLUsedRegisters registersUsed;
+		imlInstruction.CheckRegisterUsage(&registersUsed);
+		// register read -> remove from overwritten list
+		// register written -> add to overwritten list
+
+		// check if this instruction only writes registers which will never be read
+		bool onlyWritesRedundantRegisters = true;
+		registersUsed.ForEachWrittenGPR([&](IMLReg reg) {
+			if (regsNeeded.contains(reg.GetRegID()))
+				onlyWritesRedundantRegisters = false;
+		});
+		// check if any of the written registers are read after this point
+		registersUsed.ForEachWrittenGPR([&](IMLReg reg) {
+			regsNeeded.erase(reg.GetRegID());
+		});
+		registersUsed.ForEachReadGPR([&](IMLReg reg) {
+			regsNeeded.insert(reg.GetRegID());
+		});
+		if(!imlInstruction.HasSideEffects() && onlyWritesRedundantRegisters)
+		{
+			imlInstruction.make_no_op();
+		}
+	}
+}
+
+void IMLOptimizerX86_SubstituteCJumpForEflagsJump(IMLOptimizerRegIOAnalysis& regIoAnalysis, IMLSegment& seg)
+{
+	// convert and optimize bool condition jumps to eflags condition jumps
+	// - Moves eflag setter (e.g. cmp) closer to eflags consumer (conditional jump) if necessary. If not possible but required then exit early
+	// - Since we only rely on eflags, the boolean register can be optimized out if DCE considers it unused
+	// - Further detect and optimize patterns like DEC + CMP + JCC into fused ops (todo)
+
+	// check if this segment ends with a conditional jump
+	if(!seg.HasSuffixInstruction())
+		return;
+	sint32 cjmpInstIndex = seg.GetSuffixInstructionIndex();
+	if(cjmpInstIndex < 0)
+		return;
+	IMLInstruction& cjumpInstr = seg.imlList[cjmpInstIndex];
+	if( cjumpInstr.type != PPCREC_IML_TYPE_CONDITIONAL_JUMP )
+		return;
+	IMLReg regCondBool = cjumpInstr.op_conditional_jump.registerBool;
+	bool invertedCondition = !cjumpInstr.op_conditional_jump.mustBeTrue;
+	// find the instruction which sets the bool
+	sint32 cmpInstrIndex = IMLUtil_FindInstructionWhichWritesRegister(seg, cjmpInstIndex-1, regCondBool, 20);
+	if(cmpInstrIndex < 0)
+		return;
+	// check if its an instruction combo which can be optimized (currently only cmp + cjump) and get the condition
+	IMLInstruction& condSetterInstr = seg.imlList[cmpInstrIndex];
+	IMLCondition cond;
+	if(condSetterInstr.type == PPCREC_IML_TYPE_COMPARE)
+		cond = condSetterInstr.op_compare.cond;
+	else if(condSetterInstr.type == PPCREC_IML_TYPE_COMPARE_S32)
+		cond = condSetterInstr.op_compare_s32.cond;
+	else
+		return;
+	// check if instructions inbetween modify eflags
+	sint32 indexEflagsSafeStart = -1; // index of the first instruction which does not modify eflags up to cjump
+	for(sint32 i = cjmpInstIndex-1; i > cmpInstrIndex; i--)
+	{
+		if(IMLOptimizerX86_ModifiesEFlags(seg.imlList[i]))
+		{
+			indexEflagsSafeStart = i+1;
+			break;
+		}
+	}
+	if(indexEflagsSafeStart >= 0)
+	{
+		cemu_assert(indexEflagsSafeStart > 0);
+		// there are eflags-modifying instructions inbetween the bool setter and cjump
+		// try to move the eflags setter close enough to the cjump (to indexEflagsSafeStart)
+		bool canMove = IMLUtil_CanMoveInstructionTo(seg, cmpInstrIndex, indexEflagsSafeStart);
+		if(!canMove)
+		{
+			return;
+		}
+		else
+		{
+			cmpInstrIndex = IMLUtil_MoveInstructionTo(seg, cmpInstrIndex, indexEflagsSafeStart);
+		}
+	}
+	// we can turn the jump into an eflags jump
+	cjumpInstr.make_x86_eflags_jcc(cond, invertedCondition);
+
+	if (IMLUtil_CountRegisterReadsInRange(seg, cmpInstrIndex, cjmpInstIndex, regCondBool.GetRegID()) > 1 || regIoAnalysis.IsRegisterNeededAtEndOfSegment(seg, regCondBool.GetRegID()))
+		return; // bool register is used beyond the CMP, we can't drop it
+
+	auto& cmpInstr = seg.imlList[cmpInstrIndex];
+	cemu_assert_debug(cmpInstr.type == PPCREC_IML_TYPE_COMPARE || cmpInstr.type == PPCREC_IML_TYPE_COMPARE_S32);
+	if(cmpInstr.type == PPCREC_IML_TYPE_COMPARE)
+	{
+		IMLReg regA = cmpInstr.op_compare.regA;
+		IMLReg regB = cmpInstr.op_compare.regB;
+		seg.imlList[cmpInstrIndex].make_r_r(PPCREC_IML_OP_X86_CMP, regA, regB);
+	}
+	else
+	{
+		IMLReg regA = cmpInstr.op_compare_s32.regA;
+		sint32 val = cmpInstr.op_compare_s32.immS32;
+		seg.imlList[cmpInstrIndex].make_r_s32(PPCREC_IML_OP_X86_CMP, regA, val);
+	}
+
+}
+
+void IMLOptimizer_StandardOptimizationPassForSegment(IMLOptimizerRegIOAnalysis& regIoAnalysis, IMLSegment& seg)
+{
+	IMLOptimizer_RemoveDeadCodeFromSegment(regIoAnalysis, seg);
+
+#ifdef ARCH_X86_64
+	// x86 specific optimizations
+	IMLOptimizerX86_SubstituteCJumpForEflagsJump(regIoAnalysis, seg); // this pass should be applied late since it creates invisible eflags dependencies (which would break further register dependency analysis)
+#endif
+}
+
+void IMLOptimizer_StandardOptimizationPass(ppcImlGenContext_t& ppcImlGenContext)
+{
+	IMLOptimizerRegIOAnalysis regIoAnalysis(ppcImlGenContext.segmentList2, ppcImlGenContext.GetMaxRegId());
+	regIoAnalysis.ComputeDepedencies();
+	for (IMLSegment* segIt : ppcImlGenContext.segmentList2)
+	{
+		IMLOptimizer_StandardOptimizationPassForSegment(regIoAnalysis, *segIt);
+	}
+}
diff --git a/src/Cafe/HW/Espresso/Recompiler/IML/IMLRegisterAllocator.cpp b/src/Cafe/HW/Espresso/Recompiler/IML/IMLRegisterAllocator.cpp
new file mode 100644
index 00000000..935e61ac
--- /dev/null
+++ b/src/Cafe/HW/Espresso/Recompiler/IML/IMLRegisterAllocator.cpp
@@ -0,0 +1,2204 @@
+#include "IML.h"
+
+#include "../PPCRecompiler.h"
+#include "../PPCRecompilerIml.h"
+#include "IMLRegisterAllocator.h"
+#include "IMLRegisterAllocatorRanges.h"
+
+#include "../BackendX64/BackendX64.h"
+#ifdef __aarch64__
+#include "../BackendAArch64/BackendAArch64.h"
+#endif
+
+#include <boost/container/static_vector.hpp>
+#include <boost/container/small_vector.hpp>
+
+#include "Common/cpu_features.h"
+
+#define DEBUG_RA_EXTRA_VALIDATION 0	// if set to non-zero, additional expensive validation checks will be performed
+#define DEBUG_RA_INSTRUCTION_GEN 0
+
+struct IMLRARegAbstractLiveness // preliminary liveness info. One entry per register and segment
+{
+	IMLRARegAbstractLiveness(IMLRegFormat regBaseFormat, sint32 usageStart, sint32 usageEnd)
+		: regBaseFormat(regBaseFormat), usageStart(usageStart), usageEnd(usageEnd) {};
+
+	void TrackInstruction(sint32 index)
+	{
+		usageStart = std::min<sint32>(usageStart, index);
+		usageEnd = std::max<sint32>(usageEnd, index + 1); // exclusive index
+	}
+
+	sint32 usageStart;
+	sint32 usageEnd;
+	bool isProcessed{false};
+	IMLRegFormat regBaseFormat;
+};
+
+struct IMLRegisterAllocatorContext
+{
+	IMLRegisterAllocatorParameters* raParam;
+	ppcImlGenContext_t* deprGenContext; // deprecated. Try to decouple IMLRA from other parts of IML/PPCRec
+
+	std::unordered_map<IMLRegID, IMLRegFormat> regIdToBaseFormat;
+	// first pass
+	std::vector<std::unordered_map<IMLRegID, IMLRARegAbstractLiveness>> perSegmentAbstractRanges;
+
+	// helper methods
+	inline std::unordered_map<IMLRegID, IMLRARegAbstractLiveness>& GetSegmentAbstractRangeMap(IMLSegment* imlSegment)
+	{
+		return perSegmentAbstractRanges[imlSegment->momentaryIndex];
+	}
+
+	inline IMLRegFormat GetBaseFormatByRegId(IMLRegID regId) const
+	{
+		auto it = regIdToBaseFormat.find(regId);
+		cemu_assert_debug(it != regIdToBaseFormat.cend());
+		return it->second;
+	}
+};
+
+struct IMLFixedRegisters
+{
+	struct Entry
+	{
+		Entry(IMLReg reg, IMLPhysRegisterSet physRegSet)
+			: reg(reg), physRegSet(physRegSet) {}
+
+		IMLReg reg;
+		IMLPhysRegisterSet physRegSet;
+	};
+	boost::container::small_vector<Entry, 4> listInput;	 // fixed register requirements for instruction input edge
+	boost::container::small_vector<Entry, 4> listOutput; // fixed register requirements for instruction output edge
+};
+
+static void SetupCallingConvention(const IMLInstruction* instruction, IMLFixedRegisters& fixedRegs, const IMLPhysReg intParamToPhysReg[3], const IMLPhysReg floatParamToPhysReg[3], const IMLPhysReg intReturnPhysReg, const IMLPhysReg floatReturnPhysReg, IMLPhysRegisterSet volatileRegisters)
+{
+	sint32 numIntParams = 0, numFloatParams = 0;
+
+	auto AddParameterMapping = [&](IMLReg reg) {
+		if (!reg.IsValid())
+			return;
+		if (reg.GetBaseFormat() == IMLRegFormat::I64)
+		{
+			IMLPhysRegisterSet ps;
+			ps.SetAvailable(intParamToPhysReg[numIntParams]);
+			fixedRegs.listInput.emplace_back(reg, ps);
+			numIntParams++;
+		}
+		else if (reg.GetBaseFormat() == IMLRegFormat::F64)
+		{
+			IMLPhysRegisterSet ps;
+			ps.SetAvailable(floatParamToPhysReg[numFloatParams]);
+			fixedRegs.listInput.emplace_back(reg, ps);
+			numFloatParams++;
+		}
+		else
+		{
+			cemu_assert_suspicious();
+		}
+	};
+	AddParameterMapping(instruction->op_call_imm.regParam0);
+	AddParameterMapping(instruction->op_call_imm.regParam1);
+	AddParameterMapping(instruction->op_call_imm.regParam2);
+	// return value
+	if (instruction->op_call_imm.regReturn.IsValid())
+	{
+		IMLRegFormat returnFormat = instruction->op_call_imm.regReturn.GetBaseFormat();
+		bool isIntegerFormat = returnFormat == IMLRegFormat::I64 || returnFormat == IMLRegFormat::I32 || returnFormat == IMLRegFormat::I16 || returnFormat == IMLRegFormat::I8;
+		IMLPhysRegisterSet ps;
+		if (isIntegerFormat)
+		{
+			ps.SetAvailable(intReturnPhysReg);
+			volatileRegisters.SetReserved(intReturnPhysReg);
+		}
+		else
+		{
+			ps.SetAvailable(floatReturnPhysReg);
+			volatileRegisters.SetReserved(floatReturnPhysReg);
+		}
+		fixedRegs.listOutput.emplace_back(instruction->op_call_imm.regReturn, ps);
+	}
+	// block volatile registers from being used on the output edge, this makes the register allocator store them during the call
+	fixedRegs.listOutput.emplace_back(IMLREG_INVALID, volatileRegisters);
+}
+
+#if defined(__aarch64__)
+// aarch64
+static void GetInstructionFixedRegisters(IMLInstruction* instruction, IMLFixedRegisters& fixedRegs)
+{
+	fixedRegs.listInput.clear();
+	fixedRegs.listOutput.clear();
+
+	// The purpose of GetInstructionFixedRegisters() is to constraint virtual registers to specific physical registers for instructions which need it
+	// on x86 this is used for instructions like SHL <reg>, CL where the CL register is hardwired. On aarch it's probably only necessary for setting up the calling convention
+	if (instruction->type == PPCREC_IML_TYPE_CALL_IMM)
+	{
+		const IMLPhysReg intParamToPhysReg[3] = {IMLArchAArch64::PHYSREG_GPR_BASE + 0, IMLArchAArch64::PHYSREG_GPR_BASE + 1, IMLArchAArch64::PHYSREG_GPR_BASE + 2};
+		const IMLPhysReg floatParamToPhysReg[3] = {IMLArchAArch64::PHYSREG_FPR_BASE + 0, IMLArchAArch64::PHYSREG_FPR_BASE + 1, IMLArchAArch64::PHYSREG_FPR_BASE + 2};
+		IMLPhysRegisterSet volatileRegs;
+		for (int i = 0; i <= 17; i++) // x0 to x17 are volatile
+			volatileRegs.SetAvailable(IMLArchAArch64::PHYSREG_GPR_BASE + i);
+		// v0-v7 & v16-v31 are volatile. For v8-v15 only the high 64 bits are volatile.
+		for (int i = 0; i <= 7; i++)
+			volatileRegs.SetAvailable(IMLArchAArch64::PHYSREG_FPR_BASE + i);
+		for (int i = 16; i <= 31; i++)
+			volatileRegs.SetAvailable(IMLArchAArch64::PHYSREG_FPR_BASE + i);
+		SetupCallingConvention(instruction, fixedRegs, intParamToPhysReg, floatParamToPhysReg, IMLArchAArch64::PHYSREG_GPR_BASE + 0, IMLArchAArch64::PHYSREG_FPR_BASE + 0, volatileRegs);
+	}
+}
+#else
+// x86-64
+static void GetInstructionFixedRegisters(IMLInstruction* instruction, IMLFixedRegisters& fixedRegs)
+{
+	fixedRegs.listInput.clear();
+	fixedRegs.listOutput.clear();
+
+	if (instruction->type == PPCREC_IML_TYPE_R_R_R)
+	{
+		if (instruction->operation == PPCREC_IML_OP_LEFT_SHIFT || instruction->operation == PPCREC_IML_OP_RIGHT_SHIFT_S || instruction->operation == PPCREC_IML_OP_RIGHT_SHIFT_U)
+		{
+			if(!g_CPUFeatures.x86.bmi2)
+			{
+				IMLPhysRegisterSet ps;
+				ps.SetAvailable(IMLArchX86::PHYSREG_GPR_BASE + X86_REG_ECX);
+				fixedRegs.listInput.emplace_back(instruction->op_r_r_r.regB, ps);
+			}
+		}
+	}
+	else if (instruction->type == PPCREC_IML_TYPE_ATOMIC_CMP_STORE)
+	{
+		IMLPhysRegisterSet ps;
+		ps.SetAvailable(IMLArchX86::PHYSREG_GPR_BASE + X86_REG_EAX);
+		fixedRegs.listInput.emplace_back(IMLREG_INVALID, ps); // none of the inputs may use EAX
+		fixedRegs.listOutput.emplace_back(instruction->op_atomic_compare_store.regBoolOut, ps); // but we output to EAX
+	}
+	else if (instruction->type == PPCREC_IML_TYPE_CALL_IMM)
+	{
+		const IMLPhysReg intParamToPhysReg[3] = {IMLArchX86::PHYSREG_GPR_BASE + X86_REG_RCX, IMLArchX86::PHYSREG_GPR_BASE + X86_REG_RDX, IMLArchX86::PHYSREG_GPR_BASE + X86_REG_R8};
+		const IMLPhysReg floatParamToPhysReg[3] = {IMLArchX86::PHYSREG_FPR_BASE + 0, IMLArchX86::PHYSREG_FPR_BASE + 1, IMLArchX86::PHYSREG_FPR_BASE + 2};
+		IMLPhysRegisterSet volatileRegs;
+		volatileRegs.SetAvailable(IMLArchX86::PHYSREG_GPR_BASE + X86_REG_RAX);
+		volatileRegs.SetAvailable(IMLArchX86::PHYSREG_GPR_BASE + X86_REG_RCX);
+		volatileRegs.SetAvailable(IMLArchX86::PHYSREG_GPR_BASE + X86_REG_RDX);
+		volatileRegs.SetAvailable(IMLArchX86::PHYSREG_GPR_BASE + X86_REG_R8);
+		volatileRegs.SetAvailable(IMLArchX86::PHYSREG_GPR_BASE + X86_REG_R9);
+		volatileRegs.SetAvailable(IMLArchX86::PHYSREG_GPR_BASE + X86_REG_R10);
+		volatileRegs.SetAvailable(IMLArchX86::PHYSREG_GPR_BASE + X86_REG_R11);
+		// YMM0-YMM5 are volatile
+		for (int i = 0; i <= 5; i++)
+			volatileRegs.SetAvailable(IMLArchX86::PHYSREG_FPR_BASE + i);
+		// for YMM6-YMM15 only the upper 128 bits are volatile which we dont use
+		SetupCallingConvention(instruction, fixedRegs, intParamToPhysReg, floatParamToPhysReg, IMLArchX86::PHYSREG_GPR_BASE + X86_REG_EAX, IMLArchX86::PHYSREG_FPR_BASE + 0, volatileRegs);
+	}
+}
+#endif
+
+uint32 IMLRA_GetNextIterationIndex()
+{
+	static uint32 recRACurrentIterationIndex = 0;
+	recRACurrentIterationIndex++;
+	return recRACurrentIterationIndex;
+}
+
+bool _detectLoop(IMLSegment* currentSegment, sint32 depth, uint32 iterationIndex, IMLSegment* imlSegmentLoopBase)
+{
+	if (currentSegment == imlSegmentLoopBase)
+		return true;
+	if (currentSegment->raInfo.lastIterationIndex == iterationIndex)
+		return currentSegment->raInfo.isPartOfProcessedLoop;
+	if (depth >= 9)
+		return false;
+	currentSegment->raInfo.lastIterationIndex = iterationIndex;
+	currentSegment->raInfo.isPartOfProcessedLoop = false;
+
+	if (currentSegment->nextSegmentIsUncertain)
+		return false;
+	if (currentSegment->nextSegmentBranchNotTaken)
+	{
+		if (currentSegment->nextSegmentBranchNotTaken->momentaryIndex > currentSegment->momentaryIndex)
+		{
+			currentSegment->raInfo.isPartOfProcessedLoop |= _detectLoop(currentSegment->nextSegmentBranchNotTaken, depth + 1, iterationIndex, imlSegmentLoopBase);
+		}
+	}
+	if (currentSegment->nextSegmentBranchTaken)
+	{
+		if (currentSegment->nextSegmentBranchTaken->momentaryIndex > currentSegment->momentaryIndex)
+		{
+			currentSegment->raInfo.isPartOfProcessedLoop |= _detectLoop(currentSegment->nextSegmentBranchTaken, depth + 1, iterationIndex, imlSegmentLoopBase);
+		}
+	}
+	if (currentSegment->raInfo.isPartOfProcessedLoop)
+		currentSegment->loopDepth++;
+	return currentSegment->raInfo.isPartOfProcessedLoop;
+}
+
+void IMLRA_DetectLoop(ppcImlGenContext_t* ppcImlGenContext, IMLSegment* imlSegmentLoopBase)
+{
+	uint32 iterationIndex = IMLRA_GetNextIterationIndex();
+	imlSegmentLoopBase->raInfo.lastIterationIndex = iterationIndex;
+	if (_detectLoop(imlSegmentLoopBase->nextSegmentBranchTaken, 0, iterationIndex, imlSegmentLoopBase))
+	{
+		imlSegmentLoopBase->loopDepth++;
+	}
+}
+
+void IMLRA_IdentifyLoop(ppcImlGenContext_t* ppcImlGenContext, IMLSegment* imlSegment)
+{
+	if (imlSegment->nextSegmentIsUncertain)
+		return;
+	// check if this segment has a branch that links to itself (tight loop)
+	if (imlSegment->nextSegmentBranchTaken == imlSegment)
+	{
+		// segment loops over itself
+		imlSegment->loopDepth++;
+		return;
+	}
+	// check if this segment has a branch that goes backwards (potential complex loop)
+	if (imlSegment->nextSegmentBranchTaken && imlSegment->nextSegmentBranchTaken->momentaryIndex < imlSegment->momentaryIndex)
+	{
+		IMLRA_DetectLoop(ppcImlGenContext, imlSegment);
+	}
+}
+
+#define SUBRANGE_LIST_SIZE (128)
+
+sint32 IMLRA_CountDistanceUntilNextUse(raLivenessRange* subrange, raInstructionEdge startPosition)
+{
+	for (sint32 i = 0; i < subrange->list_accessLocations.size(); i++)
+	{
+		if (subrange->list_accessLocations[i].pos >= startPosition)
+		{
+			auto& it = subrange->list_accessLocations[i];
+			cemu_assert_debug(it.IsRead() != it.IsWrite()); // an access location can be either read or write
+			cemu_assert_debug(!startPosition.ConnectsToPreviousSegment() && !startPosition.ConnectsToNextSegment());
+			return it.pos.GetRaw() - startPosition.GetRaw();
+		}
+	}
+	cemu_assert_debug(subrange->imlSegment->imlList.size() < 10000);
+	return 10001 * 2;
+}
+
+// returns -1 if there is no fixed register requirement on or after startPosition
+sint32 IMLRA_CountDistanceUntilFixedRegUsageInRange(IMLSegment* imlSegment, raLivenessRange* range, raInstructionEdge startPosition, sint32 physRegister, bool& hasFixedAccess)
+{
+	hasFixedAccess = false;
+	cemu_assert_debug(startPosition.IsInstructionIndex());
+	for (auto& fixedReqEntry : range->list_fixedRegRequirements)
+	{
+		if (fixedReqEntry.pos < startPosition)
+			continue;
+		if (fixedReqEntry.allowedReg.IsAvailable(physRegister))
+		{
+			hasFixedAccess = true;
+			return fixedReqEntry.pos.GetRaw() - startPosition.GetRaw();
+		}
+	}
+	cemu_assert_debug(range->interval.end.IsInstructionIndex());
+	return range->interval.end.GetRaw() - startPosition.GetRaw();
+}
+
+sint32 IMLRA_CountDistanceUntilFixedRegUsage(IMLSegment* imlSegment, raInstructionEdge startPosition, sint32 maxDistance, IMLRegID ourRegId, sint32 physRegister)
+{
+	cemu_assert_debug(startPosition.IsInstructionIndex());
+	raInstructionEdge lastPos2;
+	lastPos2.Set(imlSegment->imlList.size(), false);
+
+	raInstructionEdge endPos;
+	endPos = startPosition + maxDistance;
+	if (endPos > lastPos2)
+		endPos = lastPos2;
+	IMLFixedRegisters fixedRegs;
+	if (startPosition.IsOnOutputEdge())
+		GetInstructionFixedRegisters(imlSegment->imlList.data() + startPosition.GetInstructionIndex(), fixedRegs);
+	for (raInstructionEdge currentPos = startPosition; currentPos <= endPos; ++currentPos)
+	{
+		if (currentPos.IsOnInputEdge())
+		{
+			GetInstructionFixedRegisters(imlSegment->imlList.data() + currentPos.GetInstructionIndex(), fixedRegs);
+		}
+		auto& fixedRegAccess = currentPos.IsOnInputEdge() ? fixedRegs.listInput : fixedRegs.listOutput;
+		for (auto& fixedRegLoc : fixedRegAccess)
+		{
+			if (fixedRegLoc.reg.IsInvalid() || fixedRegLoc.reg.GetRegID() != ourRegId)
+			{
+				cemu_assert_debug(fixedRegLoc.reg.IsInvalid() || fixedRegLoc.physRegSet.HasExactlyOneAvailable()); // this whole function only makes sense when there is only one fixed register, otherwise there are extra permutations to consider. Except for IMLREG_INVALID which is used to indicate reserved registers
+				if (fixedRegLoc.physRegSet.IsAvailable(physRegister))
+					return currentPos.GetRaw() - startPosition.GetRaw();
+			}
+		}
+	}
+	return endPos.GetRaw() - startPosition.GetRaw();
+}
+
+// count how many instructions there are until physRegister is used by any subrange or reserved for any fixed register requirement (returns 0 if register is in use at startIndex)
+sint32 PPCRecRA_countDistanceUntilNextLocalPhysRegisterUse(IMLSegment* imlSegment, raInstructionEdge startPosition, sint32 physRegister)
+{
+	cemu_assert_debug(startPosition.IsInstructionIndex());
+	sint32 minDistance = (sint32)imlSegment->imlList.size() * 2 - startPosition.GetRaw();
+	// next
+	raLivenessRange* subrangeItr = imlSegment->raInfo.linkedList_allSubranges;
+	while (subrangeItr)
+	{
+		if (subrangeItr->GetPhysicalRegister() != physRegister)
+		{
+			subrangeItr = subrangeItr->link_allSegmentRanges.next;
+			continue;
+		}
+		if (subrangeItr->interval.ContainsEdge(startPosition))
+			return 0;
+		if (subrangeItr->interval.end < startPosition)
+		{
+			subrangeItr = subrangeItr->link_allSegmentRanges.next;
+			continue;
+		}
+		cemu_assert_debug(startPosition <= subrangeItr->interval.start);
+		sint32 currentDist = subrangeItr->interval.start.GetRaw() - startPosition.GetRaw();
+		minDistance = std::min(minDistance, currentDist);
+		subrangeItr = subrangeItr->link_allSegmentRanges.next;
+	}
+	return minDistance;
+}
+
+struct IMLRALivenessTimeline
+{
+	IMLRALivenessTimeline()
+	{
+	}
+
+	// manually add an active range
+	void AddActiveRange(raLivenessRange* subrange)
+	{
+		activeRanges.emplace_back(subrange);
+	}
+
+	void ExpireRanges(raInstructionEdge expireUpTo)
+	{
+		expiredRanges.clear();
+		size_t count = activeRanges.size();
+		for (size_t f = 0; f < count; f++)
+		{
+			raLivenessRange* liverange = activeRanges[f];
+			if (liverange->interval.end < expireUpTo) // this was <= but since end is not inclusive we need to use <
+			{
+#ifdef CEMU_DEBUG_ASSERT
+				if (!expireUpTo.ConnectsToNextSegment() && (liverange->subrangeBranchTaken || liverange->subrangeBranchNotTaken))
+					assert_dbg(); // infinite subranges should not expire
+#endif
+				expiredRanges.emplace_back(liverange);
+				// remove entry
+				activeRanges[f] = activeRanges[count - 1];
+				f--;
+				count--;
+			}
+		}
+		if (count != activeRanges.size())
+			activeRanges.resize(count);
+	}
+
+	std::span<raLivenessRange*> GetExpiredRanges()
+	{
+		return {expiredRanges.data(), expiredRanges.size()};
+	}
+
+	std::span<raLivenessRange*> GetActiveRanges()
+	{
+		return {activeRanges.data(), activeRanges.size()};
+	}
+
+	raLivenessRange* GetActiveRangeByVirtualRegId(IMLRegID regId)
+	{
+		for (auto& it : activeRanges)
+			if (it->virtualRegister == regId)
+				return it;
+		return nullptr;
+	}
+
+	raLivenessRange* GetActiveRangeByPhysicalReg(sint32 physReg)
+	{
+		cemu_assert_debug(physReg >= 0);
+		for (auto& it : activeRanges)
+			if (it->physicalRegister == physReg)
+				return it;
+		return nullptr;
+	}
+
+	boost::container::small_vector<raLivenessRange*, 64> activeRanges;
+
+  private:
+	boost::container::small_vector<raLivenessRange*, 16> expiredRanges;
+};
+
+// mark occupied registers by any overlapping range as unavailable in physRegSet
+void PPCRecRA_MaskOverlappingPhysRegForGlobalRange(raLivenessRange* range2, IMLPhysRegisterSet& physRegSet)
+{
+	auto clusterRanges = range2->GetAllSubrangesInCluster();
+	for (auto& subrange : clusterRanges)
+	{
+		IMLSegment* imlSegment = subrange->imlSegment;
+		raLivenessRange* subrangeItr = imlSegment->raInfo.linkedList_allSubranges;
+		while (subrangeItr)
+		{
+			if (subrange == subrangeItr)
+			{
+				// next
+				subrangeItr = subrangeItr->link_allSegmentRanges.next;
+				continue;
+			}
+			if (subrange->interval.IsOverlapping(subrangeItr->interval))
+			{
+				if (subrangeItr->GetPhysicalRegister() >= 0)
+					physRegSet.SetReserved(subrangeItr->GetPhysicalRegister());
+			}
+			// next
+			subrangeItr = subrangeItr->link_allSegmentRanges.next;
+		}
+	}
+}
+
+bool _livenessRangeStartCompare(raLivenessRange* lhs, raLivenessRange* rhs)
+{
+	return lhs->interval.start < rhs->interval.start;
+}
+
+void _sortSegmentAllSubrangesLinkedList(IMLSegment* imlSegment)
+{
+	raLivenessRange* subrangeList[4096 + 1];
+	sint32 count = 0;
+	// disassemble linked list
+	raLivenessRange* subrangeItr = imlSegment->raInfo.linkedList_allSubranges;
+	while (subrangeItr)
+	{
+		cemu_assert(count < 4096);
+		subrangeList[count] = subrangeItr;
+		count++;
+		// next
+		subrangeItr = subrangeItr->link_allSegmentRanges.next;
+	}
+	if (count == 0)
+	{
+		imlSegment->raInfo.linkedList_allSubranges = nullptr;
+		return;
+	}
+	// sort
+	std::sort(subrangeList, subrangeList + count, _livenessRangeStartCompare);
+	// reassemble linked list
+	subrangeList[count] = nullptr;
+	imlSegment->raInfo.linkedList_allSubranges = subrangeList[0];
+	subrangeList[0]->link_allSegmentRanges.prev = nullptr;
+	subrangeList[0]->link_allSegmentRanges.next = subrangeList[1];
+	for (sint32 i = 1; i < count; i++)
+	{
+		subrangeList[i]->link_allSegmentRanges.prev = subrangeList[i - 1];
+		subrangeList[i]->link_allSegmentRanges.next = subrangeList[i + 1];
+	}
+	// validate list
+#if DEBUG_RA_EXTRA_VALIDATION
+	sint32 count2 = 0;
+	subrangeItr = imlSegment->raInfo.linkedList_allSubranges;
+	raInstructionEdge currentStartPosition;
+	currentStartPosition.SetRaw(RA_INTER_RANGE_START);
+	while (subrangeItr)
+	{
+		count2++;
+		if (subrangeItr->interval2.start < currentStartPosition)
+			assert_dbg();
+		currentStartPosition = subrangeItr->interval2.start;
+		// next
+		subrangeItr = subrangeItr->link_allSegmentRanges.next;
+	}
+	if (count != count2)
+		assert_dbg();
+#endif
+}
+
+std::unordered_map<IMLRegID, raLivenessRange*>& IMLRA_GetSubrangeMap(IMLSegment* imlSegment)
+{
+	return imlSegment->raInfo.linkedList_perVirtualRegister;
+}
+
+raLivenessRange* IMLRA_GetSubrange(IMLSegment* imlSegment, IMLRegID regId)
+{
+	auto it = imlSegment->raInfo.linkedList_perVirtualRegister.find(regId);
+	if (it == imlSegment->raInfo.linkedList_perVirtualRegister.end())
+		return nullptr;
+	return it->second;
+}
+
+struct raFixedRegRequirementWithVGPR
+{
+	raFixedRegRequirementWithVGPR(raInstructionEdge pos, IMLPhysRegisterSet allowedReg, IMLRegID regId)
+		: pos(pos), allowedReg(allowedReg), regId(regId) {}
+
+	raInstructionEdge pos;
+	IMLPhysRegisterSet allowedReg;
+	IMLRegID regId;
+};
+
+std::vector<raFixedRegRequirementWithVGPR> IMLRA_BuildSegmentInstructionFixedRegList(IMLSegment* imlSegment)
+{
+	std::vector<raFixedRegRequirementWithVGPR> frrList;
+	size_t index = 0;
+	while (index < imlSegment->imlList.size())
+	{
+		IMLFixedRegisters fixedRegs;
+		GetInstructionFixedRegisters(&imlSegment->imlList[index], fixedRegs);
+		raInstructionEdge pos;
+		pos.Set(index, true);
+		for (auto& fixedRegAccess : fixedRegs.listInput)
+		{
+			frrList.emplace_back(pos, fixedRegAccess.physRegSet, fixedRegAccess.reg.IsValid() ? fixedRegAccess.reg.GetRegID() : IMLRegID_INVALID);
+		}
+		pos = pos + 1;
+		for (auto& fixedRegAccess : fixedRegs.listOutput)
+		{
+			frrList.emplace_back(pos, fixedRegAccess.physRegSet, fixedRegAccess.reg.IsValid() ? fixedRegAccess.reg.GetRegID() : IMLRegID_INVALID);
+		}
+		index++;
+	}
+	return frrList;
+}
+
+boost::container::small_vector<raLivenessRange*, 8> IMLRA_GetRangeWithFixedRegReservationOverlappingPos(IMLSegment* imlSegment, raInstructionEdge pos, IMLPhysReg physReg)
+{
+	boost::container::small_vector<raLivenessRange*, 8> rangeList;
+	for (raLivenessRange* currentRange = imlSegment->raInfo.linkedList_allSubranges; currentRange; currentRange = currentRange->link_allSegmentRanges.next)
+	{
+		if (!currentRange->interval.ContainsEdge(pos))
+			continue;
+		IMLPhysRegisterSet allowedRegs;
+		if (!currentRange->GetAllowedRegistersEx(allowedRegs))
+			continue;
+		if (allowedRegs.IsAvailable(physReg))
+			rangeList.emplace_back(currentRange);
+	}
+	return rangeList;
+}
+
+void IMLRA_HandleFixedRegisters(ppcImlGenContext_t* ppcImlGenContext, IMLSegment* imlSegment)
+{
+	// first pass - iterate over all ranges with fixed register requirements and split them if they cross the segment border
+	// todo - this pass currently creates suboptimal results by splitting all ranges that cross the segment border if they have any fixed register requirement. This can be avoided in some cases
+	for (raLivenessRange* currentRange = imlSegment->raInfo.linkedList_allSubranges; currentRange;)
+	{
+		IMLPhysRegisterSet allowedRegs;
+		if(currentRange->list_fixedRegRequirements.empty())
+		{
+			currentRange = currentRange->link_allSegmentRanges.next;
+			continue; // since we run this pass for every segment we dont need to do global checks here for clusters which may not even have fixed register requirements
+		}
+		if (!currentRange->GetAllowedRegistersEx(allowedRegs))
+		{
+			currentRange = currentRange->link_allSegmentRanges.next;
+			continue;
+		}
+		if (currentRange->interval.ExtendsPreviousSegment() || currentRange->interval.ExtendsIntoNextSegment())
+		{
+			raLivenessRange* nextRange = currentRange->link_allSegmentRanges.next;
+			IMLRA_ExplodeRangeCluster(ppcImlGenContext, currentRange);
+			currentRange = nextRange;
+			continue;
+		}
+		currentRange = currentRange->link_allSegmentRanges.next;
+	}
+	// second pass - look for ranges with conflicting fixed register requirements and split these too (locally)
+	for (raLivenessRange* currentRange = imlSegment->raInfo.linkedList_allSubranges; currentRange; currentRange = currentRange->link_allSegmentRanges.next)
+	{
+		IMLPhysRegisterSet allowedRegs;
+		if (currentRange->list_fixedRegRequirements.empty())
+			continue; // we dont need to check whole clusters because the pass above guarantees that there are no ranges with fixed register requirements that extend outside of this segment
+		if (!currentRange->GetAllowedRegistersEx(allowedRegs))
+			continue;
+		if (allowedRegs.HasAnyAvailable())
+			continue;
+		cemu_assert_unimplemented();
+	}
+	// third pass - assign fixed registers, split ranges if needed
+	std::vector<raFixedRegRequirementWithVGPR> frr = IMLRA_BuildSegmentInstructionFixedRegList(imlSegment);
+	std::unordered_map<IMLPhysReg, IMLRegID> lastVGPR;
+	for (size_t i = 0; i < frr.size(); i++)
+	{
+		raFixedRegRequirementWithVGPR& entry = frr[i];
+		// we currently only handle fixed register requirements with a single register
+		// with one exception: When regId is IMLRegID_INVALID then the entry acts as a list of reserved registers
+		cemu_assert_debug(entry.regId == IMLRegID_INVALID || entry.allowedReg.HasExactlyOneAvailable());
+		for (IMLPhysReg physReg = entry.allowedReg.GetFirstAvailableReg(); physReg >= 0; physReg = entry.allowedReg.GetNextAvailableReg(physReg + 1))
+		{
+			// check if the assigned vGPR has changed
+			bool vgprHasChanged = false;
+			auto it = lastVGPR.find(physReg);
+			if (it != lastVGPR.end())
+				vgprHasChanged = it->second != entry.regId;
+			else
+				vgprHasChanged = true;
+			lastVGPR[physReg] = entry.regId;
+
+			if (!vgprHasChanged)
+				continue;
+
+			boost::container::small_vector<raLivenessRange*, 8> overlappingRanges = IMLRA_GetRangeWithFixedRegReservationOverlappingPos(imlSegment, entry.pos, physReg);
+			if (entry.regId != IMLRegID_INVALID)
+				cemu_assert_debug(!overlappingRanges.empty()); // there should always be at least one range that overlaps corresponding to the fixed register requirement, except for IMLRegID_INVALID which is used to indicate reserved registers
+
+			for (auto& range : overlappingRanges)
+			{
+				if (range->interval.start < entry.pos)
+				{
+					IMLRA_SplitRange(ppcImlGenContext, range, entry.pos, true);
+				}
+			}
+		}
+	}
+	// finally iterate ranges and assign fixed registers
+	for (raLivenessRange* currentRange = imlSegment->raInfo.linkedList_allSubranges; currentRange; currentRange = currentRange->link_allSegmentRanges.next)
+	{
+		IMLPhysRegisterSet allowedRegs;
+		if (currentRange->list_fixedRegRequirements.empty())
+			continue; // we dont need to check whole clusters because the pass above guarantees that there are no ranges with fixed register requirements that extend outside of this segment
+		if (!currentRange->GetAllowedRegistersEx(allowedRegs))
+		{
+			cemu_assert_debug(currentRange->list_fixedRegRequirements.empty());
+			continue;
+		}
+		cemu_assert_debug(allowedRegs.HasExactlyOneAvailable());
+		currentRange->SetPhysicalRegister(allowedRegs.GetFirstAvailableReg());
+	}
+	// DEBUG - check for collisions and make sure all ranges with fixed register requirements got their physical register assigned
+#if DEBUG_RA_EXTRA_VALIDATION
+	for (raLivenessRange* currentRange = imlSegment->raInfo.linkedList_allSubranges; currentRange; currentRange = currentRange->link_allSegmentRanges.next)
+	{
+		IMLPhysRegisterSet allowedRegs;
+		if (!currentRange->HasPhysicalRegister())
+			continue;
+		for (raLivenessRange* currentRange2 = imlSegment->raInfo.linkedList_allSubranges; currentRange2; currentRange2 = currentRange2->link_allSegmentRanges.next)
+		{
+			if (currentRange == currentRange2)
+				continue;
+			if (currentRange->interval2.IsOverlapping(currentRange2->interval2))
+			{
+				cemu_assert_debug(currentRange->GetPhysicalRegister() != currentRange2->GetPhysicalRegister());
+			}
+		}
+	}
+#endif
+}
+
+// we should not split ranges on instructions with tied registers (i.e. where a register encoded as a single parameter is both input and output)
+// otherwise the RA algorithm has to assign both ranges the same physical register (not supported yet) and the point of splitting to fit another range is nullified
+void IMLRA_MakeSafeSplitPosition(IMLSegment* imlSegment, raInstructionEdge& pos)
+{
+	// we ignore the instruction for now and just always make it a safe split position
+	cemu_assert_debug(pos.IsInstructionIndex());
+	if (pos.IsOnOutputEdge())
+		pos = pos - 1;
+}
+
+// convenience wrapper for IMLRA_MakeSafeSplitPosition
+void IMLRA_MakeSafeSplitDistance(IMLSegment* imlSegment, raInstructionEdge startPos, sint32& distance)
+{
+	cemu_assert_debug(startPos.IsInstructionIndex());
+	cemu_assert_debug(distance >= 0);
+	raInstructionEdge endPos = startPos + distance;
+	IMLRA_MakeSafeSplitPosition(imlSegment, endPos);
+	if (endPos < startPos)
+	{
+		distance = 0;
+		return;
+	}
+	distance = endPos.GetRaw() - startPos.GetRaw();
+}
+
+static void DbgVerifyAllRanges(IMLRegisterAllocatorContext& ctx);
+
+class RASpillStrategy
+{
+  public:
+	virtual void Apply(ppcImlGenContext_t* ctx, IMLSegment* imlSegment, raLivenessRange* currentRange) = 0;
+
+	sint32 GetCost()
+	{
+		return strategyCost;
+	}
+
+  protected:
+	void ResetCost()
+	{
+		strategyCost = INT_MAX;
+	}
+
+	sint32 strategyCost;
+};
+
+class RASpillStrategy_LocalRangeHoleCutting : public RASpillStrategy
+{
+  public:
+	void Reset()
+	{
+		localRangeHoleCutting.distance = -1;
+		localRangeHoleCutting.largestHoleSubrange = nullptr;
+		ResetCost();
+	}
+
+	void Evaluate(IMLSegment* imlSegment, raLivenessRange* currentRange, const IMLRALivenessTimeline& timeline, const IMLPhysRegisterSet& allowedRegs)
+	{
+		raInstructionEdge currentRangeStart = currentRange->interval.start;
+		sint32 requiredSize2 = currentRange->interval.GetPreciseDistance();
+		cemu_assert_debug(localRangeHoleCutting.distance == -1);
+		cemu_assert_debug(strategyCost == INT_MAX);
+		if (!currentRangeStart.ConnectsToPreviousSegment())
+		{
+			cemu_assert_debug(currentRangeStart.GetRaw() >= 0);
+			for (auto candidate : timeline.activeRanges)
+			{
+				if (candidate->interval.ExtendsIntoNextSegment())
+					continue;
+				// new checks (Oct 2024):
+				if (candidate == currentRange)
+					continue;
+				if (candidate->GetPhysicalRegister() < 0)
+					continue;
+				if (!allowedRegs.IsAvailable(candidate->GetPhysicalRegister()))
+					continue;
+
+				sint32 distance2 = IMLRA_CountDistanceUntilNextUse(candidate, currentRangeStart);
+				IMLRA_MakeSafeSplitDistance(imlSegment, currentRangeStart, distance2);
+				if (distance2 < 2)
+					continue;
+				cemu_assert_debug(currentRangeStart.IsInstructionIndex());
+				distance2 = std::min<sint32>(distance2, imlSegment->imlList.size() * 2 - currentRangeStart.GetRaw()); // limit distance to end of segment
+				// calculate split cost of candidate
+				sint32 cost = IMLRA_CalculateAdditionalCostAfterSplit(candidate, currentRangeStart + distance2);
+				// calculate additional split cost of currentRange if hole is not large enough
+				if (distance2 < requiredSize2)
+				{
+					cost += IMLRA_CalculateAdditionalCostAfterSplit(currentRange, currentRangeStart + distance2);
+					// we also slightly increase cost in relation to the remaining length (in order to make the algorithm prefer larger holes)
+					cost += (requiredSize2 - distance2) / 10;
+				}
+				// compare cost with previous candidates
+				if (cost < strategyCost)
+				{
+					strategyCost = cost;
+					localRangeHoleCutting.distance = distance2;
+					localRangeHoleCutting.largestHoleSubrange = candidate;
+				}
+			}
+		}
+	}
+
+	void Apply(ppcImlGenContext_t* ctx, IMLSegment* imlSegment, raLivenessRange* currentRange) override
+	{
+		cemu_assert_debug(strategyCost != INT_MAX);
+		sint32 requiredSize2 = currentRange->interval.GetPreciseDistance();
+		raInstructionEdge currentRangeStart = currentRange->interval.start;
+
+		raInstructionEdge holeStartPosition = currentRangeStart;
+		raInstructionEdge holeEndPosition = currentRangeStart + localRangeHoleCutting.distance;
+		raLivenessRange* collisionRange = localRangeHoleCutting.largestHoleSubrange;
+
+		if (collisionRange->interval.start < holeStartPosition)
+		{
+			collisionRange = IMLRA_SplitRange(nullptr, collisionRange, holeStartPosition, true);
+			cemu_assert_debug(!collisionRange || collisionRange->interval.start >= holeStartPosition); // verify if splitting worked at all, tail must be on or after the split point
+			cemu_assert_debug(!collisionRange || collisionRange->interval.start >= holeEndPosition);	// also verify that the trimmed hole is actually big enough
+		}
+		else
+		{
+			cemu_assert_unimplemented(); // we still need to trim?
+		}
+		// we may also have to cut the current range to fit partially into the hole
+		if (requiredSize2 > localRangeHoleCutting.distance)
+		{
+			raLivenessRange* tailRange = IMLRA_SplitRange(nullptr, currentRange, currentRangeStart + localRangeHoleCutting.distance, true);
+			if (tailRange)
+			{
+				cemu_assert_debug(tailRange->list_fixedRegRequirements.empty()); // we are not allowed to unassign fixed registers
+				tailRange->UnsetPhysicalRegister();
+			}
+		}
+		// verify that the hole is large enough
+		if (collisionRange)
+		{
+			cemu_assert_debug(!collisionRange->interval.IsOverlapping(currentRange->interval));
+		}
+	}
+
+  private:
+	struct
+	{
+		sint32 distance;
+		raLivenessRange* largestHoleSubrange;
+	} localRangeHoleCutting;
+};
+
+class RASpillStrategy_AvailableRegisterHole : public RASpillStrategy
+{
+	// split current range (this is generally only a good choice when the current range is long but has few usages)
+  public:
+	void Reset()
+	{
+		ResetCost();
+		availableRegisterHole.distance = -1;
+		availableRegisterHole.physRegister = -1;
+	}
+
+	void Evaluate(IMLSegment* imlSegment, raLivenessRange* currentRange, const IMLRALivenessTimeline& timeline, const IMLPhysRegisterSet& localAvailableRegsMask, const IMLPhysRegisterSet& allowedRegs)
+	{
+		sint32 requiredSize2 = currentRange->interval.GetPreciseDistance();
+
+		raInstructionEdge currentRangeStart = currentRange->interval.start;
+		cemu_assert_debug(strategyCost == INT_MAX);
+		availableRegisterHole.distance = -1;
+		availableRegisterHole.physRegister = -1;
+		if (currentRangeStart.GetRaw() >= 0)
+		{
+			if (localAvailableRegsMask.HasAnyAvailable())
+			{
+				sint32 physRegItr = -1;
+				while (true)
+				{
+					physRegItr = localAvailableRegsMask.GetNextAvailableReg(physRegItr + 1);
+					if (physRegItr < 0)
+						break;
+					if (!allowedRegs.IsAvailable(physRegItr))
+						continue;
+					// get size of potential hole for this register
+					sint32 distance = PPCRecRA_countDistanceUntilNextLocalPhysRegisterUse(imlSegment, currentRangeStart, physRegItr);
+
+					// some instructions may require the same register for another range, check the distance here
+					sint32 distUntilFixedReg = IMLRA_CountDistanceUntilFixedRegUsage(imlSegment, currentRangeStart, distance, currentRange->GetVirtualRegister(), physRegItr);
+					if (distUntilFixedReg < distance)
+						distance = distUntilFixedReg;
+
+					IMLRA_MakeSafeSplitDistance(imlSegment, currentRangeStart, distance);
+					if (distance < 2)
+						continue;
+					// calculate additional cost due to split
+					cemu_assert_debug(distance < requiredSize2); // should always be true otherwise previous step would have selected this register?
+					sint32 cost = IMLRA_CalculateAdditionalCostAfterSplit(currentRange, currentRangeStart + distance);
+					// add small additional cost for the remaining range (prefer larger holes)
+					cost += ((requiredSize2 - distance) / 2) / 10;
+					if (cost < strategyCost)
+					{
+						strategyCost = cost;
+						availableRegisterHole.distance = distance;
+						availableRegisterHole.physRegister = physRegItr;
+					}
+				}
+			}
+		}
+	}
+
+	void Apply(ppcImlGenContext_t* ctx, IMLSegment* imlSegment, raLivenessRange* currentRange) override
+	{
+		cemu_assert_debug(strategyCost != INT_MAX);
+		raInstructionEdge currentRangeStart = currentRange->interval.start;
+		// use available register
+		raLivenessRange* tailRange = IMLRA_SplitRange(nullptr, currentRange, currentRangeStart + availableRegisterHole.distance, true);
+		if (tailRange)
+		{
+			cemu_assert_debug(tailRange->list_fixedRegRequirements.empty()); // we are not allowed to unassign fixed registers
+			tailRange->UnsetPhysicalRegister();
+		}
+	}
+
+  private:
+	struct
+	{
+		sint32 physRegister;
+		sint32 distance; // size of hole
+	} availableRegisterHole;
+};
+
+class RASpillStrategy_ExplodeRange : public RASpillStrategy
+{
+  public:
+	void Reset()
+	{
+		ResetCost();
+		explodeRange.range = nullptr;
+		explodeRange.distance = -1;
+	}
+
+	void Evaluate(IMLSegment* imlSegment, raLivenessRange* currentRange, const IMLRALivenessTimeline& timeline, const IMLPhysRegisterSet& allowedRegs)
+	{
+		raInstructionEdge currentRangeStart = currentRange->interval.start;
+		if (currentRangeStart.ConnectsToPreviousSegment())
+			currentRangeStart.Set(0, true);
+		sint32 requiredSize2 = currentRange->interval.GetPreciseDistance();
+		cemu_assert_debug(strategyCost == INT_MAX);
+		explodeRange.range = nullptr;
+		explodeRange.distance = -1;
+		for (auto candidate : timeline.activeRanges)
+		{
+			if (!candidate->interval.ExtendsIntoNextSegment())
+				continue;
+			// new checks (Oct 2024):
+			if (candidate == currentRange)
+				continue;
+			if (candidate->GetPhysicalRegister() < 0)
+				continue;
+			if (!allowedRegs.IsAvailable(candidate->GetPhysicalRegister()))
+				continue;
+
+			sint32 distance = IMLRA_CountDistanceUntilNextUse(candidate, currentRangeStart);
+			IMLRA_MakeSafeSplitDistance(imlSegment, currentRangeStart, distance);
+			if (distance < 2)
+				continue;
+			sint32 cost = IMLRA_CalculateAdditionalCostOfRangeExplode(candidate);
+			// if the hole is not large enough, add cost of splitting current subrange
+			if (distance < requiredSize2)
+			{
+				cost += IMLRA_CalculateAdditionalCostAfterSplit(currentRange, currentRangeStart + distance);
+				// add small additional cost for the remaining range (prefer larger holes)
+				cost += ((requiredSize2 - distance) / 2) / 10;
+			}
+			// compare with current best candidate for this strategy
+			if (cost < strategyCost)
+			{
+				strategyCost = cost;
+				explodeRange.distance = distance;
+				explodeRange.range = candidate;
+			}
+		}
+	}
+
+	void Apply(ppcImlGenContext_t* ctx, IMLSegment* imlSegment, raLivenessRange* currentRange) override
+	{
+		raInstructionEdge currentRangeStart = currentRange->interval.start;
+		if (currentRangeStart.ConnectsToPreviousSegment())
+			currentRangeStart.Set(0, true);
+		sint32 requiredSize2 = currentRange->interval.GetPreciseDistance();
+		// explode range
+		IMLRA_ExplodeRangeCluster(nullptr, explodeRange.range);
+		// split current subrange if necessary
+		if (requiredSize2 > explodeRange.distance)
+		{
+			raLivenessRange* tailRange = IMLRA_SplitRange(nullptr, currentRange, currentRangeStart + explodeRange.distance, true);
+			if (tailRange)
+			{
+				cemu_assert_debug(tailRange->list_fixedRegRequirements.empty()); // we are not allowed to unassign fixed registers
+				tailRange->UnsetPhysicalRegister();
+			}
+		}
+	}
+
+  private:
+	struct
+	{
+		raLivenessRange* range;
+		sint32 distance; // size of hole
+		// note: If we explode a range, we still have to check the size of the hole that becomes available, if too small then we need to add cost of splitting local subrange
+	} explodeRange;
+};
+
+class RASpillStrategy_ExplodeRangeInter : public RASpillStrategy
+{
+  public:
+	void Reset()
+	{
+		ResetCost();
+		explodeRange.range = nullptr;
+		explodeRange.distance = -1;
+	}
+
+	void Evaluate(IMLSegment* imlSegment, raLivenessRange* currentRange, const IMLRALivenessTimeline& timeline, const IMLPhysRegisterSet& allowedRegs)
+	{
+		// explode the range with the least cost
+		cemu_assert_debug(strategyCost == INT_MAX);
+		cemu_assert_debug(explodeRange.range == nullptr && explodeRange.distance == -1);
+		for (auto candidate : timeline.activeRanges)
+		{
+			if (!candidate->interval.ExtendsIntoNextSegment())
+				continue;
+			// only select candidates that clash with current subrange
+			if (candidate->GetPhysicalRegister() < 0 && candidate != currentRange)
+				continue;
+			// and also filter any that dont meet fixed register requirements
+			if (!allowedRegs.IsAvailable(candidate->GetPhysicalRegister()))
+				continue;
+			sint32 cost;
+			cost = IMLRA_CalculateAdditionalCostOfRangeExplode(candidate);
+			// compare with current best candidate for this strategy
+			if (cost < strategyCost)
+			{
+				strategyCost = cost;
+				explodeRange.distance = INT_MAX;
+				explodeRange.range = candidate;
+			}
+		}
+		// add current range as a candidate too
+		sint32 ownCost;
+		ownCost = IMLRA_CalculateAdditionalCostOfRangeExplode(currentRange);
+		if (ownCost < strategyCost)
+		{
+			strategyCost = ownCost;
+			explodeRange.distance = INT_MAX;
+			explodeRange.range = currentRange;
+		}
+	}
+
+	void Apply(ppcImlGenContext_t* ctx, IMLSegment* imlSegment, raLivenessRange* currentRange) override
+	{
+		cemu_assert_debug(strategyCost != INT_MAX);
+		IMLRA_ExplodeRangeCluster(ctx, explodeRange.range);
+	}
+
+  private:
+	struct
+	{
+		raLivenessRange* range;
+		sint32 distance; // size of hole
+		// note: If we explode a range, we still have to check the size of the hole that becomes available, if too small then we need to add cost of splitting local subrange
+	}explodeRange;
+};
+
+// filter any registers from candidatePhysRegSet which cannot be used by currentRange due to fixed register requirements within the range that it occupies
+void IMLRA_FilterReservedFixedRegisterRequirementsForSegment(IMLRegisterAllocatorContext& ctx, raLivenessRange* currentRange, IMLPhysRegisterSet& candidatePhysRegSet)
+{
+	IMLSegment* seg = currentRange->imlSegment;
+	if (seg->imlList.empty())
+		return; // there can be no fixed register requirements if there are no instructions
+
+	raInstructionEdge firstPos = currentRange->interval.start;
+	if (currentRange->interval.start.ConnectsToPreviousSegment())
+		firstPos.SetRaw(0);
+	else if (currentRange->interval.start.ConnectsToNextSegment())
+		firstPos.Set(seg->imlList.size() - 1, false);
+
+	raInstructionEdge lastPos = currentRange->interval.end;
+	if (currentRange->interval.end.ConnectsToPreviousSegment())
+		lastPos.SetRaw(0);
+	else if (currentRange->interval.end.ConnectsToNextSegment())
+		lastPos.Set(seg->imlList.size() - 1, false);
+	cemu_assert_debug(firstPos <= lastPos);
+
+	IMLRegID ourRegId = currentRange->GetVirtualRegister();
+
+	IMLFixedRegisters fixedRegs;
+	if (firstPos.IsOnOutputEdge())
+		GetInstructionFixedRegisters(seg->imlList.data() + firstPos.GetInstructionIndex(), fixedRegs);
+	for (raInstructionEdge currentPos = firstPos; currentPos <= lastPos; ++currentPos)
+	{
+		if (currentPos.IsOnInputEdge())
+		{
+			GetInstructionFixedRegisters(seg->imlList.data() + currentPos.GetInstructionIndex(), fixedRegs);
+		}
+		auto& fixedRegAccess = currentPos.IsOnInputEdge() ? fixedRegs.listInput : fixedRegs.listOutput;
+		for (auto& fixedRegLoc : fixedRegAccess)
+		{
+			if (fixedRegLoc.reg.IsInvalid() || fixedRegLoc.reg.GetRegID() != ourRegId)
+				candidatePhysRegSet.RemoveRegisters(fixedRegLoc.physRegSet);
+		}
+	}
+}
+
+// filter out any registers along the range cluster
+void IMLRA_FilterReservedFixedRegisterRequirementsForCluster(IMLRegisterAllocatorContext& ctx, IMLSegment* imlSegment, raLivenessRange* currentRange, IMLPhysRegisterSet& candidatePhysRegSet)
+{
+	cemu_assert_debug(currentRange->imlSegment == imlSegment);
+	if (currentRange->interval.ExtendsPreviousSegment() || currentRange->interval.ExtendsIntoNextSegment())
+	{
+		auto clusterRanges = currentRange->GetAllSubrangesInCluster();
+		for (auto& rangeIt : clusterRanges)
+		{
+			IMLRA_FilterReservedFixedRegisterRequirementsForSegment(ctx, rangeIt, candidatePhysRegSet);
+			if (!candidatePhysRegSet.HasAnyAvailable())
+				break;
+		}
+		return;
+	}
+	IMLRA_FilterReservedFixedRegisterRequirementsForSegment(ctx, currentRange, candidatePhysRegSet);
+}
+
+bool IMLRA_AssignSegmentRegisters(IMLRegisterAllocatorContext& ctx, ppcImlGenContext_t* ppcImlGenContext, IMLSegment* imlSegment)
+{
+	// sort subranges ascending by start index
+	_sortSegmentAllSubrangesLinkedList(imlSegment);
+
+	IMLRALivenessTimeline livenessTimeline;
+	raLivenessRange* subrangeItr = imlSegment->raInfo.linkedList_allSubranges;
+	raInstructionEdge lastInstructionEdge;
+	lastInstructionEdge.SetRaw(RA_INTER_RANGE_END);
+
+	struct
+	{
+		RASpillStrategy_LocalRangeHoleCutting localRangeHoleCutting;
+		RASpillStrategy_AvailableRegisterHole availableRegisterHole;
+		RASpillStrategy_ExplodeRange explodeRange;
+		// for ranges that connect to follow up segments:
+		RASpillStrategy_ExplodeRangeInter explodeRangeInter;
+	} strategy;
+
+	while (subrangeItr)
+	{
+		raInstructionEdge currentRangeStart = subrangeItr->interval.start; // used to be currentIndex before refactor
+		PPCRecRA_debugValidateSubrange(subrangeItr);
+
+		livenessTimeline.ExpireRanges((currentRangeStart > lastInstructionEdge) ? lastInstructionEdge : currentRangeStart); // expire up to currentIndex (inclusive), but exclude infinite ranges
+
+		// if subrange already has register assigned then add it to the active list and continue
+		if (subrangeItr->GetPhysicalRegister() >= 0)
+		{
+			// verify if register is actually available
+#if DEBUG_RA_EXTRA_VALIDATION
+			for (auto& liverangeItr : livenessTimeline.activeRanges)
+			{
+				// check for register mismatch
+				cemu_assert_debug(liverangeItr->GetPhysicalRegister() != subrangeItr->GetPhysicalRegister());
+			}
+#endif
+			livenessTimeline.AddActiveRange(subrangeItr);
+			subrangeItr = subrangeItr->link_allSegmentRanges.next;
+			continue;
+		}
+		// ranges with fixed register requirements should already have a phys register assigned
+		if (!subrangeItr->list_fixedRegRequirements.empty())
+		{
+			cemu_assert_debug(subrangeItr->HasPhysicalRegister());
+		}
+		// find free register for current subrangeItr and segment
+		IMLRegFormat regBaseFormat = ctx.GetBaseFormatByRegId(subrangeItr->GetVirtualRegister());
+		IMLPhysRegisterSet candidatePhysRegSet = ctx.raParam->GetPhysRegPool(regBaseFormat);
+		cemu_assert_debug(candidatePhysRegSet.HasAnyAvailable()); // no valid pool provided for this register type
+
+		IMLPhysRegisterSet allowedRegs = subrangeItr->GetAllowedRegisters(candidatePhysRegSet);
+		cemu_assert_debug(allowedRegs.HasAnyAvailable()); // if zero regs are available, then this range needs to be split to avoid mismatching register requirements (do this in the initial pass to keep the code here simpler)
+		candidatePhysRegSet &= allowedRegs;
+
+		for (auto& liverangeItr : livenessTimeline.activeRanges)
+		{
+			cemu_assert_debug(liverangeItr->GetPhysicalRegister() >= 0);
+			candidatePhysRegSet.SetReserved(liverangeItr->GetPhysicalRegister());
+		}
+		// check intersections with other ranges and determine allowed registers
+		IMLPhysRegisterSet localAvailableRegsMask = candidatePhysRegSet; // mask of registers that are currently not used (does not include range checks in other segments)
+		if (candidatePhysRegSet.HasAnyAvailable())
+		{
+			// check for overlaps on a global scale (subrangeItr can be part of a larger range cluster across multiple segments)
+			PPCRecRA_MaskOverlappingPhysRegForGlobalRange(subrangeItr, candidatePhysRegSet);
+		}
+		// some target instructions may enforce specific registers (e.g. common on X86 where something like SHL <reg>, CL forces CL as the count register)
+		// we determine the list of allowed registers here
+		// this really only works if we assume single-register requirements (otherwise its better not to filter out early and instead allow register corrections later but we don't support this yet)
+		if (candidatePhysRegSet.HasAnyAvailable())
+		{
+			IMLRA_FilterReservedFixedRegisterRequirementsForCluster(ctx, imlSegment, subrangeItr, candidatePhysRegSet);
+		}
+		if (candidatePhysRegSet.HasAnyAvailable())
+		{
+			// use free register
+			subrangeItr->SetPhysicalRegisterForCluster(candidatePhysRegSet.GetFirstAvailableReg());
+			livenessTimeline.AddActiveRange(subrangeItr);
+			subrangeItr = subrangeItr->link_allSegmentRanges.next; // next
+			continue;
+		}
+		// there is no free register for the entire range
+		// evaluate different strategies of splitting ranges to free up another register or shorten the current range
+		strategy.localRangeHoleCutting.Reset();
+		strategy.availableRegisterHole.Reset();
+		strategy.explodeRange.Reset();
+		// cant assign register
+		// there might be registers available, we just can't use them due to range conflicts
+		RASpillStrategy* selectedStrategy = nullptr;
+		auto SelectStrategyIfBetter = [&selectedStrategy](RASpillStrategy& newStrategy) {
+			if (newStrategy.GetCost() == INT_MAX)
+				return;
+			if (selectedStrategy == nullptr || newStrategy.GetCost() < selectedStrategy->GetCost())
+				selectedStrategy = &newStrategy;
+		};
+
+		if (!subrangeItr->interval.ExtendsIntoNextSegment())
+		{
+			// range ends in current segment, use local strategies
+			// evaluate strategy: Cut hole into local subrange
+			strategy.localRangeHoleCutting.Evaluate(imlSegment, subrangeItr, livenessTimeline, allowedRegs);
+			SelectStrategyIfBetter(strategy.localRangeHoleCutting);
+			// evaluate strategy: Split current range to fit in available holes
+			// todo - are checks required to avoid splitting on the suffix instruction?
+			strategy.availableRegisterHole.Evaluate(imlSegment, subrangeItr, livenessTimeline, localAvailableRegsMask, allowedRegs);
+			SelectStrategyIfBetter(strategy.availableRegisterHole);
+			// evaluate strategy: Explode inter-segment ranges
+			strategy.explodeRange.Evaluate(imlSegment, subrangeItr, livenessTimeline, allowedRegs);
+			SelectStrategyIfBetter(strategy.explodeRange);
+		}
+		else // if subrangeItr->interval2.ExtendsIntoNextSegment()
+		{
+			strategy.explodeRangeInter.Reset();
+			strategy.explodeRangeInter.Evaluate(imlSegment, subrangeItr, livenessTimeline, allowedRegs);
+			SelectStrategyIfBetter(strategy.explodeRangeInter);
+		}
+		// choose strategy
+		if (selectedStrategy)
+		{
+			selectedStrategy->Apply(ppcImlGenContext, imlSegment, subrangeItr);
+		}
+		else
+		{
+			// none of the evulated strategies can be applied, this should only happen if the segment extends into the next segment(s) for which we have no good strategy
+			cemu_assert_debug(subrangeItr->interval.ExtendsPreviousSegment());
+			// alternative strategy if we have no other choice: explode current range
+			IMLRA_ExplodeRangeCluster(ppcImlGenContext, subrangeItr);
+		}
+		return false;
+	}
+	return true;
+}
+
+void IMLRA_AssignRegisters(IMLRegisterAllocatorContext& ctx, ppcImlGenContext_t* ppcImlGenContext)
+{
+	// start with frequently executed segments first
+	sint32 maxLoopDepth = 0;
+	for (IMLSegment* segIt : ppcImlGenContext->segmentList2)
+	{
+		maxLoopDepth = std::max(maxLoopDepth, segIt->loopDepth);
+	}
+	// assign fixed registers first
+	for (IMLSegment* segIt : ppcImlGenContext->segmentList2)
+		IMLRA_HandleFixedRegisters(ppcImlGenContext, segIt);
+#if DEBUG_RA_EXTRA_VALIDATION
+	// fixed registers are currently handled per-segment, but here we validate that they are assigned correctly on a global scope as well
+	for (IMLSegment* imlSegment : ppcImlGenContext->segmentList2)
+	{
+		for (raLivenessRange* currentRange = imlSegment->raInfo.linkedList_allSubranges; currentRange; currentRange = currentRange->link_allSegmentRanges.next)
+		{
+			IMLPhysRegisterSet allowedRegs;
+			if (!currentRange->GetAllowedRegistersEx(allowedRegs))
+			{
+				cemu_assert_debug(currentRange->list_fixedRegRequirements.empty());
+				continue;
+			}
+			cemu_assert_debug(currentRange->HasPhysicalRegister() && allowedRegs.IsAvailable(currentRange->GetPhysicalRegister()));
+		}
+	}
+#endif
+
+	while (true)
+	{
+		bool done = false;
+		for (sint32 d = maxLoopDepth; d >= 0; d--)
+		{
+			for (IMLSegment* segIt : ppcImlGenContext->segmentList2)
+			{
+				if (segIt->loopDepth != d)
+					continue;
+				done = IMLRA_AssignSegmentRegisters(ctx, ppcImlGenContext, segIt);
+				if (done == false)
+					break;
+			}
+			if (done == false)
+				break;
+		}
+		if (done)
+			break;
+	}
+}
+
+void IMLRA_ReshapeForRegisterAllocation(ppcImlGenContext_t* ppcImlGenContext)
+{
+	// insert empty segments after every non-taken branch if the linked segment has more than one input
+	// this gives the register allocator more room to create efficient spill code
+	size_t segmentIndex = 0;
+	while (segmentIndex < ppcImlGenContext->segmentList2.size())
+	{
+		IMLSegment* imlSegment = ppcImlGenContext->segmentList2[segmentIndex];
+		if (imlSegment->nextSegmentIsUncertain)
+		{
+			segmentIndex++;
+			continue;
+		}
+		if (imlSegment->nextSegmentBranchTaken == nullptr || imlSegment->nextSegmentBranchNotTaken == nullptr)
+		{
+			segmentIndex++;
+			continue;
+		}
+		if (imlSegment->nextSegmentBranchNotTaken->list_prevSegments.size() <= 1)
+		{
+			segmentIndex++;
+			continue;
+		}
+		if (imlSegment->nextSegmentBranchNotTaken->isEnterable)
+		{
+			segmentIndex++;
+			continue;
+		}
+		PPCRecompilerIml_insertSegments(ppcImlGenContext, segmentIndex + 1, 1);
+		IMLSegment* imlSegmentP0 = ppcImlGenContext->segmentList2[segmentIndex + 0];
+		IMLSegment* imlSegmentP1 = ppcImlGenContext->segmentList2[segmentIndex + 1];
+		IMLSegment* nextSegment = imlSegment->nextSegmentBranchNotTaken;
+		IMLSegment_RemoveLink(imlSegmentP0, nextSegment);
+		IMLSegment_SetLinkBranchNotTaken(imlSegmentP1, nextSegment);
+		IMLSegment_SetLinkBranchNotTaken(imlSegmentP0, imlSegmentP1);
+		segmentIndex++;
+	}
+	// detect loops
+	for (size_t s = 0; s < ppcImlGenContext->segmentList2.size(); s++)
+	{
+		IMLSegment* imlSegment = ppcImlGenContext->segmentList2[s];
+		imlSegment->momentaryIndex = s;
+	}
+	for (size_t s = 0; s < ppcImlGenContext->segmentList2.size(); s++)
+	{
+		IMLSegment* imlSegment = ppcImlGenContext->segmentList2[s];
+		IMLRA_IdentifyLoop(ppcImlGenContext, imlSegment);
+	}
+}
+
+IMLRARegAbstractLiveness* _GetAbstractRange(IMLRegisterAllocatorContext& ctx, IMLSegment* imlSegment, IMLRegID regId)
+{
+	auto& segMap = ctx.GetSegmentAbstractRangeMap(imlSegment);
+	auto it = segMap.find(regId);
+	return it != segMap.end() ? &it->second : nullptr;
+}
+
+// scan instructions and establish register usage range for segment
+void IMLRA_CalculateSegmentMinMaxAbstractRanges(IMLRegisterAllocatorContext& ctx, IMLSegment* imlSegment)
+{
+	size_t instructionIndex = 0;
+	IMLUsedRegisters gprTracking;
+	auto& segDistMap = ctx.GetSegmentAbstractRangeMap(imlSegment);
+	while (instructionIndex < imlSegment->imlList.size())
+	{
+		imlSegment->imlList[instructionIndex].CheckRegisterUsage(&gprTracking);
+		gprTracking.ForEachAccessedGPR([&](IMLReg gprReg, bool isWritten) {
+			IMLRegID gprId = gprReg.GetRegID();
+			auto it = segDistMap.find(gprId);
+			if (it == segDistMap.end())
+			{
+				segDistMap.try_emplace(gprId, gprReg.GetBaseFormat(), (sint32)instructionIndex, (sint32)instructionIndex + 1);
+				ctx.regIdToBaseFormat.try_emplace(gprId, gprReg.GetBaseFormat());
+			}
+			else
+			{
+				it->second.TrackInstruction(instructionIndex);
+#ifdef CEMU_DEBUG_ASSERT
+				cemu_assert_debug(ctx.regIdToBaseFormat[gprId] == gprReg.GetBaseFormat()); // the base type per register always has to be the same
+#endif
+			}
+		});
+		instructionIndex++;
+	}
+}
+
+void IMLRA_CalculateLivenessRanges(IMLRegisterAllocatorContext& ctx)
+{
+	// for each register calculate min/max index of usage range within each segment
+	size_t dbgIndex = 0;
+	for (IMLSegment* segIt : ctx.deprGenContext->segmentList2)
+	{
+		cemu_assert_debug(segIt->momentaryIndex == dbgIndex);
+		IMLRA_CalculateSegmentMinMaxAbstractRanges(ctx, segIt);
+		dbgIndex++;
+	}
+}
+
+raLivenessRange* PPCRecRA_convertToMappedRanges(IMLRegisterAllocatorContext& ctx, IMLSegment* imlSegment, IMLRegID vGPR, IMLName name)
+{
+	IMLRARegAbstractLiveness* abstractRange = _GetAbstractRange(ctx, imlSegment, vGPR);
+	if (!abstractRange)
+		return nullptr;
+	if (abstractRange->isProcessed)
+	{
+		// return already existing segment
+		raLivenessRange* existingRange = IMLRA_GetSubrange(imlSegment, vGPR);
+		cemu_assert_debug(existingRange);
+		return existingRange;
+	}
+	abstractRange->isProcessed = true;
+	// create subrange
+	cemu_assert_debug(IMLRA_GetSubrange(imlSegment, vGPR) == nullptr);
+	cemu_assert_debug(
+		(abstractRange->usageStart == abstractRange->usageEnd && (abstractRange->usageStart == RA_INTER_RANGE_START || abstractRange->usageStart == RA_INTER_RANGE_END)) ||
+		abstractRange->usageStart < abstractRange->usageEnd); // usageEnd is exclusive so it should always be larger
+	sint32 inclusiveEnd = abstractRange->usageEnd;
+	if (inclusiveEnd != RA_INTER_RANGE_START && inclusiveEnd != RA_INTER_RANGE_END)
+		inclusiveEnd--; // subtract one, because usageEnd is exclusive, but the end value of the interval passed to createSubrange is inclusive
+	raInterval interval;
+	interval.SetInterval(abstractRange->usageStart, true, inclusiveEnd, true);
+	raLivenessRange* subrange = IMLRA_CreateRange(ctx.deprGenContext, imlSegment, vGPR, name, interval.start, interval.end);
+	// traverse forward
+	if (abstractRange->usageEnd == RA_INTER_RANGE_END)
+	{
+		if (imlSegment->nextSegmentBranchTaken)
+		{
+			IMLRARegAbstractLiveness* branchTakenRange = _GetAbstractRange(ctx, imlSegment->nextSegmentBranchTaken, vGPR);
+			if (branchTakenRange && branchTakenRange->usageStart == RA_INTER_RANGE_START)
+			{
+				subrange->subrangeBranchTaken = PPCRecRA_convertToMappedRanges(ctx, imlSegment->nextSegmentBranchTaken, vGPR, name);
+				subrange->subrangeBranchTaken->previousRanges.push_back(subrange);
+				cemu_assert_debug(subrange->subrangeBranchTaken->interval.ExtendsPreviousSegment());
+			}
+		}
+		if (imlSegment->nextSegmentBranchNotTaken)
+		{
+			IMLRARegAbstractLiveness* branchNotTakenRange = _GetAbstractRange(ctx, imlSegment->nextSegmentBranchNotTaken, vGPR);
+			if (branchNotTakenRange && branchNotTakenRange->usageStart == RA_INTER_RANGE_START)
+			{
+				subrange->subrangeBranchNotTaken = PPCRecRA_convertToMappedRanges(ctx, imlSegment->nextSegmentBranchNotTaken, vGPR, name);
+				subrange->subrangeBranchNotTaken->previousRanges.push_back(subrange);
+				cemu_assert_debug(subrange->subrangeBranchNotTaken->interval.ExtendsPreviousSegment());
+			}
+		}
+	}
+	// traverse backward
+	if (abstractRange->usageStart == RA_INTER_RANGE_START)
+	{
+		for (auto& it : imlSegment->list_prevSegments)
+		{
+			IMLRARegAbstractLiveness* prevRange = _GetAbstractRange(ctx, it, vGPR);
+			if (!prevRange)
+				continue;
+			if (prevRange->usageEnd == RA_INTER_RANGE_END)
+				PPCRecRA_convertToMappedRanges(ctx, it, vGPR, name);
+		}
+	}
+	return subrange;
+}
+
+void IMLRA_UpdateOrAddSubrangeLocation(raLivenessRange* subrange, raInstructionEdge pos)
+{
+	if (subrange->list_accessLocations.empty())
+	{
+		subrange->list_accessLocations.emplace_back(pos);
+		return;
+	}
+	if(subrange->list_accessLocations.back().pos == pos)
+		return;
+	cemu_assert_debug(subrange->list_accessLocations.back().pos < pos);
+	subrange->list_accessLocations.emplace_back(pos);
+}
+
+// take abstract range data and create LivenessRanges
+void IMLRA_ConvertAbstractToLivenessRanges(IMLRegisterAllocatorContext& ctx, IMLSegment* imlSegment)
+{
+	const std::unordered_map<IMLRegID, raLivenessRange*>& regToSubrange = IMLRA_GetSubrangeMap(imlSegment);
+
+	auto AddOrUpdateFixedRegRequirement = [&](IMLRegID regId, sint32 instructionIndex, bool isInput, const IMLPhysRegisterSet& physRegSet) {
+		raLivenessRange* subrange = regToSubrange.find(regId)->second;
+		cemu_assert_debug(subrange);
+		raFixedRegRequirement tmp;
+		tmp.pos.Set(instructionIndex, isInput);
+		tmp.allowedReg = physRegSet;
+		if (subrange->list_fixedRegRequirements.empty() || subrange->list_fixedRegRequirements.back().pos != tmp.pos)
+			subrange->list_fixedRegRequirements.push_back(tmp);
+	};
+
+	// convert abstract min-max ranges to liveness range objects
+	auto& segMap = ctx.GetSegmentAbstractRangeMap(imlSegment);
+	for (auto& it : segMap)
+	{
+		if (it.second.isProcessed)
+			continue;
+		IMLRegID regId = it.first;
+		PPCRecRA_convertToMappedRanges(ctx, imlSegment, regId, ctx.raParam->regIdToName.find(regId)->second);
+	}
+	// fill created ranges with read/write location indices
+	// note that at this point there is only one range per register per segment
+	// and the algorithm below relies on this
+	size_t index = 0;
+	IMLUsedRegisters gprTracking;
+	while (index < imlSegment->imlList.size())
+	{
+		imlSegment->imlList[index].CheckRegisterUsage(&gprTracking);
+		raInstructionEdge pos((sint32)index, true);
+		gprTracking.ForEachReadGPR([&](IMLReg gprReg) {
+			IMLRegID gprId = gprReg.GetRegID();
+			raLivenessRange* subrange = regToSubrange.find(gprId)->second;
+			IMLRA_UpdateOrAddSubrangeLocation(subrange, pos);
+		});
+		pos = {(sint32)index, false};
+		gprTracking.ForEachWrittenGPR([&](IMLReg gprReg) {
+			IMLRegID gprId = gprReg.GetRegID();
+			raLivenessRange* subrange = regToSubrange.find(gprId)->second;
+			IMLRA_UpdateOrAddSubrangeLocation(subrange, pos);
+		});
+		// check fixed register requirements
+		IMLFixedRegisters fixedRegs;
+		GetInstructionFixedRegisters(&imlSegment->imlList[index], fixedRegs);
+		for (auto& fixedRegAccess : fixedRegs.listInput)
+		{
+			if (fixedRegAccess.reg != IMLREG_INVALID)
+				AddOrUpdateFixedRegRequirement(fixedRegAccess.reg.GetRegID(), index, true, fixedRegAccess.physRegSet);
+		}
+		for (auto& fixedRegAccess : fixedRegs.listOutput)
+		{
+			if (fixedRegAccess.reg != IMLREG_INVALID)
+				AddOrUpdateFixedRegRequirement(fixedRegAccess.reg.GetRegID(), index, false, fixedRegAccess.physRegSet);
+		}
+		index++;
+	}
+}
+
+void IMLRA_extendAbstractRangeToEndOfSegment(IMLRegisterAllocatorContext& ctx, IMLSegment* imlSegment, IMLRegID regId)
+{
+	auto& segDistMap = ctx.GetSegmentAbstractRangeMap(imlSegment);
+	auto it = segDistMap.find(regId);
+	if (it == segDistMap.end())
+	{
+		sint32 startIndex;
+		if (imlSegment->HasSuffixInstruction())
+			startIndex = imlSegment->GetSuffixInstructionIndex();
+		else
+			startIndex = RA_INTER_RANGE_END;
+		segDistMap.try_emplace((IMLRegID)regId, IMLRegFormat::INVALID_FORMAT, startIndex, RA_INTER_RANGE_END);
+	}
+	else
+	{
+		it->second.usageEnd = RA_INTER_RANGE_END;
+	}
+}
+
+void IMLRA_extendAbstractRangeToBeginningOfSegment(IMLRegisterAllocatorContext& ctx, IMLSegment* imlSegment, IMLRegID regId)
+{
+	auto& segDistMap = ctx.GetSegmentAbstractRangeMap(imlSegment);
+	auto it = segDistMap.find(regId);
+	if (it == segDistMap.end())
+	{
+		segDistMap.try_emplace((IMLRegID)regId, IMLRegFormat::INVALID_FORMAT, RA_INTER_RANGE_START, RA_INTER_RANGE_START);
+	}
+	else
+	{
+		it->second.usageStart = RA_INTER_RANGE_START;
+	}
+	// propagate backwards
+	for (auto& it : imlSegment->list_prevSegments)
+	{
+		IMLRA_extendAbstractRangeToEndOfSegment(ctx, it, regId);
+	}
+}
+
+void IMLRA_connectAbstractRanges(IMLRegisterAllocatorContext& ctx, IMLRegID regId, IMLSegment** route, sint32 routeDepth)
+{
+#ifdef CEMU_DEBUG_ASSERT
+	if (routeDepth < 2)
+		assert_dbg();
+#endif
+	// extend starting range to end of segment
+	IMLRA_extendAbstractRangeToEndOfSegment(ctx, route[0], regId);
+	// extend all the connecting segments in both directions
+	for (sint32 i = 1; i < (routeDepth - 1); i++)
+	{
+		IMLRA_extendAbstractRangeToEndOfSegment(ctx, route[i], regId);
+		IMLRA_extendAbstractRangeToBeginningOfSegment(ctx, route[i], regId);
+	}
+	// extend the final segment towards the beginning
+	IMLRA_extendAbstractRangeToBeginningOfSegment(ctx, route[routeDepth - 1], regId);
+}
+
+void _IMLRA_checkAndTryExtendRange(IMLRegisterAllocatorContext& ctx, IMLSegment* currentSegment, IMLRegID regID, sint32 distanceLeft, IMLSegment** route, sint32 routeDepth)
+{
+	if (routeDepth >= 64)
+	{
+		cemuLog_logDebug(LogType::Force, "Recompiler RA route maximum depth exceeded\n");
+		return;
+	}
+	route[routeDepth] = currentSegment;
+
+	IMLRARegAbstractLiveness* range = _GetAbstractRange(ctx, currentSegment, regID);
+
+	if (!range)
+	{
+		// measure distance over entire segment
+		distanceLeft -= (sint32)currentSegment->imlList.size();
+		if (distanceLeft > 0)
+		{
+			if (currentSegment->nextSegmentBranchNotTaken)
+				_IMLRA_checkAndTryExtendRange(ctx, currentSegment->nextSegmentBranchNotTaken, regID, distanceLeft, route, routeDepth + 1);
+			if (currentSegment->nextSegmentBranchTaken)
+				_IMLRA_checkAndTryExtendRange(ctx, currentSegment->nextSegmentBranchTaken, regID, distanceLeft, route, routeDepth + 1);
+		}
+		return;
+	}
+	else
+	{
+		// measure distance to range
+		if (range->usageStart == RA_INTER_RANGE_END)
+		{
+			if (distanceLeft < (sint32)currentSegment->imlList.size())
+				return; // range too far away
+		}
+		else if (range->usageStart != RA_INTER_RANGE_START && range->usageStart > distanceLeft)
+			return; // out of range
+		// found close range -> connect ranges
+		IMLRA_connectAbstractRanges(ctx, regID, route, routeDepth + 1);
+	}
+}
+
+void PPCRecRA_checkAndTryExtendRange(IMLRegisterAllocatorContext& ctx, IMLSegment* currentSegment, IMLRARegAbstractLiveness* range, IMLRegID regID)
+{
+	cemu_assert_debug(range->usageEnd >= 0);
+	// count instructions to end of initial segment
+	sint32 instructionsUntilEndOfSeg;
+	if (range->usageEnd == RA_INTER_RANGE_END)
+		instructionsUntilEndOfSeg = 0;
+	else
+		instructionsUntilEndOfSeg = (sint32)currentSegment->imlList.size() - range->usageEnd;
+	cemu_assert_debug(instructionsUntilEndOfSeg >= 0);
+	sint32 remainingScanDist = 45 - instructionsUntilEndOfSeg;
+	if (remainingScanDist <= 0)
+		return; // can't reach end
+
+	IMLSegment* route[64];
+	route[0] = currentSegment;
+	if (currentSegment->nextSegmentBranchNotTaken)
+		_IMLRA_checkAndTryExtendRange(ctx, currentSegment->nextSegmentBranchNotTaken, regID, remainingScanDist, route, 1);
+	if (currentSegment->nextSegmentBranchTaken)
+		_IMLRA_checkAndTryExtendRange(ctx, currentSegment->nextSegmentBranchTaken, regID, remainingScanDist, route, 1);
+}
+
+void PPCRecRA_mergeCloseRangesForSegmentV2(IMLRegisterAllocatorContext& ctx, IMLSegment* imlSegment)
+{
+	auto& segMap = ctx.GetSegmentAbstractRangeMap(imlSegment);
+	for (auto& it : segMap)
+	{
+		PPCRecRA_checkAndTryExtendRange(ctx, imlSegment, &(it.second), it.first);
+	}
+#ifdef CEMU_DEBUG_ASSERT
+	if (imlSegment->list_prevSegments.empty() == false && imlSegment->isEnterable)
+		assert_dbg();
+	if ((imlSegment->nextSegmentBranchNotTaken != nullptr || imlSegment->nextSegmentBranchTaken != nullptr) && imlSegment->nextSegmentIsUncertain)
+		assert_dbg();
+#endif
+}
+
+void PPCRecRA_followFlowAndExtendRanges(IMLRegisterAllocatorContext& ctx, IMLSegment* imlSegment)
+{
+	std::vector<IMLSegment*> list_segments;
+	std::vector<bool> list_processedSegment;
+	size_t segmentCount = ctx.deprGenContext->segmentList2.size();
+	list_segments.reserve(segmentCount + 1);
+	list_processedSegment.resize(segmentCount);
+
+	auto markSegProcessed = [&list_processedSegment](IMLSegment* seg) {
+		list_processedSegment[seg->momentaryIndex] = true;
+	};
+	auto isSegProcessed = [&list_processedSegment](IMLSegment* seg) -> bool {
+		return list_processedSegment[seg->momentaryIndex];
+	};
+	markSegProcessed(imlSegment);
+
+	sint32 index = 0;
+	list_segments.push_back(imlSegment);
+	while (index < list_segments.size())
+	{
+		IMLSegment* currentSegment = list_segments[index];
+		PPCRecRA_mergeCloseRangesForSegmentV2(ctx, currentSegment);
+		// follow flow
+		if (currentSegment->nextSegmentBranchNotTaken && !isSegProcessed(currentSegment->nextSegmentBranchNotTaken))
+		{
+			markSegProcessed(currentSegment->nextSegmentBranchNotTaken);
+			list_segments.push_back(currentSegment->nextSegmentBranchNotTaken);
+		}
+		if (currentSegment->nextSegmentBranchTaken && !isSegProcessed(currentSegment->nextSegmentBranchTaken))
+		{
+			markSegProcessed(currentSegment->nextSegmentBranchTaken);
+			list_segments.push_back(currentSegment->nextSegmentBranchTaken);
+		}
+		index++;
+	}
+}
+
+void IMLRA_MergeCloseAbstractRanges(IMLRegisterAllocatorContext& ctx)
+{
+	for (size_t s = 0; s < ctx.deprGenContext->segmentList2.size(); s++)
+	{
+		IMLSegment* imlSegment = ctx.deprGenContext->segmentList2[s];
+		if (!imlSegment->list_prevSegments.empty())
+			continue; // not an entry/standalone segment
+		PPCRecRA_followFlowAndExtendRanges(ctx, imlSegment);
+	}
+}
+
+void IMLRA_ExtendAbstractRangesOutOfLoops(IMLRegisterAllocatorContext& ctx)
+{
+	for (size_t s = 0; s < ctx.deprGenContext->segmentList2.size(); s++)
+	{
+		IMLSegment* imlSegment = ctx.deprGenContext->segmentList2[s];
+		auto localLoopDepth = imlSegment->loopDepth;
+		if (localLoopDepth <= 0)
+			continue; // not inside a loop
+		// look for loop exit
+		bool hasLoopExit = false;
+		if (imlSegment->nextSegmentBranchTaken && imlSegment->nextSegmentBranchTaken->loopDepth < localLoopDepth)
+		{
+			hasLoopExit = true;
+		}
+		if (imlSegment->nextSegmentBranchNotTaken && imlSegment->nextSegmentBranchNotTaken->loopDepth < localLoopDepth)
+		{
+			hasLoopExit = true;
+		}
+		if (hasLoopExit == false)
+			continue;
+
+		// extend looping ranges into all exits (this allows the data flow analyzer to move stores out of the loop)
+		auto& segMap = ctx.GetSegmentAbstractRangeMap(imlSegment);
+		for (auto& it : segMap)
+		{
+			if (it.second.usageEnd != RA_INTER_RANGE_END)
+				continue;
+			if (imlSegment->nextSegmentBranchTaken)
+				IMLRA_extendAbstractRangeToBeginningOfSegment(ctx, imlSegment->nextSegmentBranchTaken, it.first);
+			if (imlSegment->nextSegmentBranchNotTaken)
+				IMLRA_extendAbstractRangeToBeginningOfSegment(ctx, imlSegment->nextSegmentBranchNotTaken, it.first);
+		}
+	}
+}
+
+void IMLRA_ProcessFlowAndCalculateLivenessRanges(IMLRegisterAllocatorContext& ctx)
+{
+	IMLRA_MergeCloseAbstractRanges(ctx);
+	// extra pass to move register loads and stores out of loops
+	IMLRA_ExtendAbstractRangesOutOfLoops(ctx);
+	// calculate liveness ranges
+	for (auto& segIt : ctx.deprGenContext->segmentList2)
+		IMLRA_ConvertAbstractToLivenessRanges(ctx, segIt);
+}
+
+void IMLRA_AnalyzeSubrangeDataDependency(raLivenessRange* subrange)
+{
+	bool isRead = false;
+	bool isWritten = false;
+	bool isOverwritten = false;
+	for (auto& location : subrange->list_accessLocations)
+	{
+		if (location.IsRead())
+		{
+			isRead = true;
+		}
+		if (location.IsWrite())
+		{
+			if (isRead == false)
+				isOverwritten = true;
+			isWritten = true;
+		}
+	}
+	subrange->_noLoad = isOverwritten;
+	subrange->hasStore = isWritten;
+
+	if (subrange->interval.ExtendsPreviousSegment())
+		subrange->_noLoad = true;
+}
+
+struct subrangeEndingInfo_t
+{
+	raLivenessRange* subrangeList[SUBRANGE_LIST_SIZE];
+	sint32 subrangeCount;
+
+	bool hasUndefinedEndings;
+};
+
+void _findSubrangeWriteEndings(raLivenessRange* subrange, uint32 iterationIndex, sint32 depth, subrangeEndingInfo_t* info)
+{
+	if (depth >= 30)
+	{
+		info->hasUndefinedEndings = true;
+		return;
+	}
+	if (subrange->lastIterationIndex == iterationIndex)
+		return; // already processed
+	subrange->lastIterationIndex = iterationIndex;
+	if (subrange->hasStoreDelayed)
+		return; // no need to traverse this subrange
+	IMLSegment* imlSegment = subrange->imlSegment;
+	if (!subrange->interval.ExtendsIntoNextSegment())
+	{
+		// ending segment
+		if (info->subrangeCount >= SUBRANGE_LIST_SIZE)
+		{
+			info->hasUndefinedEndings = true;
+			return;
+		}
+		else
+		{
+			info->subrangeList[info->subrangeCount] = subrange;
+			info->subrangeCount++;
+		}
+		return;
+	}
+
+	// traverse next subranges in flow
+	if (imlSegment->nextSegmentBranchNotTaken)
+	{
+		if (subrange->subrangeBranchNotTaken == nullptr)
+		{
+			info->hasUndefinedEndings = true;
+		}
+		else
+		{
+			_findSubrangeWriteEndings(subrange->subrangeBranchNotTaken, iterationIndex, depth + 1, info);
+		}
+	}
+	if (imlSegment->nextSegmentBranchTaken)
+	{
+		if (subrange->subrangeBranchTaken == nullptr)
+		{
+			info->hasUndefinedEndings = true;
+		}
+		else
+		{
+			_findSubrangeWriteEndings(subrange->subrangeBranchTaken, iterationIndex, depth + 1, info);
+		}
+	}
+}
+
+static void IMLRA_AnalyzeRangeDataFlow(raLivenessRange* subrange)
+{
+	if (!subrange->interval.ExtendsIntoNextSegment())
+		return;
+	// analyze data flow across segments (if this segment has writes)
+	if (subrange->hasStore)
+	{
+		subrangeEndingInfo_t writeEndingInfo;
+		writeEndingInfo.subrangeCount = 0;
+		writeEndingInfo.hasUndefinedEndings = false;
+		_findSubrangeWriteEndings(subrange, IMLRA_GetNextIterationIndex(), 0, &writeEndingInfo);
+		if (writeEndingInfo.hasUndefinedEndings == false)
+		{
+			// get cost of delaying store into endings
+			sint32 delayStoreCost = 0;
+			bool alreadyStoredInAllEndings = true;
+			for (sint32 i = 0; i < writeEndingInfo.subrangeCount; i++)
+			{
+				raLivenessRange* subrangeItr = writeEndingInfo.subrangeList[i];
+				if (subrangeItr->hasStore)
+					continue; // this ending already stores, no extra cost
+				alreadyStoredInAllEndings = false;
+				sint32 storeCost = IMLRA_GetSegmentReadWriteCost(subrangeItr->imlSegment);
+				delayStoreCost = std::max(storeCost, delayStoreCost);
+			}
+			if (alreadyStoredInAllEndings)
+			{
+				subrange->hasStore = false;
+				subrange->hasStoreDelayed = true;
+			}
+			else if (delayStoreCost <= IMLRA_GetSegmentReadWriteCost(subrange->imlSegment))
+			{
+				subrange->hasStore = false;
+				subrange->hasStoreDelayed = true;
+				for (sint32 i = 0; i < writeEndingInfo.subrangeCount; i++)
+				{
+					raLivenessRange* subrangeItr = writeEndingInfo.subrangeList[i];
+					subrangeItr->hasStore = true;
+				}
+			}
+		}
+	}
+}
+
+void IMLRA_AnalyzeRangeDataFlow(ppcImlGenContext_t* ppcImlGenContext)
+{
+	// this function is called after _AssignRegisters(), which means that all liveness ranges are already final and must not be modified anymore
+	// track read/write dependencies per segment
+	for (auto& seg : ppcImlGenContext->segmentList2)
+	{
+		raLivenessRange* subrange = seg->raInfo.linkedList_allSubranges;
+		while (subrange)
+		{
+			IMLRA_AnalyzeSubrangeDataDependency(subrange);
+			subrange = subrange->link_allSegmentRanges.next;
+		}
+	}
+	// propagate information across segment boundaries
+	for (auto& seg : ppcImlGenContext->segmentList2)
+	{
+		raLivenessRange* subrange = seg->raInfo.linkedList_allSubranges;
+		while (subrange)
+		{
+			IMLRA_AnalyzeRangeDataFlow(subrange);
+			subrange = subrange->link_allSegmentRanges.next;
+		}
+	}
+}
+
+/* Generate move instructions */
+
+inline IMLReg _MakeNativeReg(IMLRegFormat baseFormat, IMLRegID regId)
+{
+	return IMLReg(baseFormat, baseFormat, 0, regId);
+}
+
+// prepass for IMLRA_GenerateSegmentMoveInstructions which updates all virtual registers to their physical counterparts
+void IMLRA_RewriteRegisters(IMLRegisterAllocatorContext& ctx, IMLSegment* imlSegment)
+{
+	std::unordered_map<IMLRegID, IMLRegID> virtId2PhysReg;
+	boost::container::small_vector<raLivenessRange*, 64> activeRanges;
+	raLivenessRange* currentRange = imlSegment->raInfo.linkedList_allSubranges;
+	raInstructionEdge currentEdge;
+	for (size_t i = 0; i < imlSegment->imlList.size(); i++)
+	{
+		currentEdge.Set(i, false); // set to instruction index on output edge
+		// activate ranges which begin before or during this instruction
+		while (currentRange && currentRange->interval.start <= currentEdge)
+		{
+			cemu_assert_debug(virtId2PhysReg.find(currentRange->GetVirtualRegister()) == virtId2PhysReg.end() || virtId2PhysReg[currentRange->GetVirtualRegister()] == currentRange->GetPhysicalRegister()); // check for register conflict
+
+			virtId2PhysReg[currentRange->GetVirtualRegister()] = currentRange->GetPhysicalRegister();
+			activeRanges.push_back(currentRange);
+			currentRange = currentRange->link_allSegmentRanges.next;
+		}
+		// rewrite registers
+		imlSegment->imlList[i].RewriteGPR(virtId2PhysReg);
+		// deactivate ranges which end during this instruction
+		auto it = activeRanges.begin();
+		while (it != activeRanges.end())
+		{
+			if ((*it)->interval.end <= currentEdge)
+			{
+				virtId2PhysReg.erase((*it)->GetVirtualRegister());
+				it = activeRanges.erase(it);
+			}
+			else
+				++it;
+		}
+	}
+}
+
+void IMLRA_GenerateSegmentMoveInstructions2(IMLRegisterAllocatorContext& ctx, IMLSegment* imlSegment)
+{
+	IMLRA_RewriteRegisters(ctx, imlSegment);
+
+#if DEBUG_RA_INSTRUCTION_GEN
+	cemuLog_log(LogType::Force, "");
+	cemuLog_log(LogType::Force, "[Seg before RA]");
+	IMLDebug_DumpSegment(nullptr, imlSegment, true);
+#endif
+
+	bool hadSuffixInstruction = imlSegment->HasSuffixInstruction();
+
+	std::vector<IMLInstruction> rebuiltInstructions;
+	sint32 numInstructionsWithoutSuffix = (sint32)imlSegment->imlList.size() - (imlSegment->HasSuffixInstruction() ? 1 : 0);
+
+	if (imlSegment->imlList.empty())
+	{
+		// empty segments need special handling (todo - look into merging this with the core logic below eventually)
+		// store all ranges
+		raLivenessRange* currentRange = imlSegment->raInfo.linkedList_allSubranges;
+		while (currentRange)
+		{
+			if (currentRange->hasStore)
+				rebuiltInstructions.emplace_back().make_name_r(currentRange->GetName(), _MakeNativeReg(ctx.regIdToBaseFormat[currentRange->GetVirtualRegister()], currentRange->GetPhysicalRegister()));
+			currentRange = currentRange->link_allSegmentRanges.next;
+		}
+		// load ranges
+		currentRange = imlSegment->raInfo.linkedList_allSubranges;
+		while (currentRange)
+		{
+			if (!currentRange->_noLoad)
+			{
+				cemu_assert_debug(currentRange->interval.ExtendsIntoNextSegment());
+				rebuiltInstructions.emplace_back().make_r_name(_MakeNativeReg(ctx.regIdToBaseFormat[currentRange->GetVirtualRegister()], currentRange->GetPhysicalRegister()), currentRange->GetName());
+			}
+			currentRange = currentRange->link_allSegmentRanges.next;
+		}
+		imlSegment->imlList = std::move(rebuiltInstructions);
+		return;
+	}
+
+	// make sure that no range exceeds the suffix instruction input edge except if they need to be loaded for the next segment (todo - for those, set the start point accordingly?)
+	{
+		raLivenessRange* currentRange = imlSegment->raInfo.linkedList_allSubranges;
+		raInstructionEdge edge;
+		if (imlSegment->HasSuffixInstruction())
+			edge.Set(numInstructionsWithoutSuffix, true);
+		else
+			edge.Set(numInstructionsWithoutSuffix - 1, false);
+
+		while (currentRange)
+		{
+			if (!currentRange->interval.IsNextSegmentOnly() && currentRange->interval.end > edge)
+			{
+				currentRange->interval.SetEnd(edge);
+			}
+			currentRange = currentRange->link_allSegmentRanges.next;
+		}
+	}
+
+#if DEBUG_RA_INSTRUCTION_GEN
+	cemuLog_log(LogType::Force, "");
+	cemuLog_log(LogType::Force, "--- Intermediate liveness info ---");
+	{
+		raLivenessRange* dbgRange = imlSegment->raInfo.linkedList_allSubranges;
+		while (dbgRange)
+		{
+			cemuLog_log(LogType::Force, "Range i{}: {}-{}", dbgRange->GetVirtualRegister(), dbgRange->interval2.start.GetDebugString(), dbgRange->interval2.end.GetDebugString());
+			dbgRange = dbgRange->link_allSegmentRanges.next;
+		}
+	}
+#endif
+
+	boost::container::small_vector<raLivenessRange*, 64> activeRanges;
+	// first we add all the ranges that extend from the previous segment, some of these will end immediately at the first instruction so we might need to store them early
+	raLivenessRange* currentRange = imlSegment->raInfo.linkedList_allSubranges;
+	// make all ranges active that start on RA_INTER_RANGE_START
+	while (currentRange && currentRange->interval.start.ConnectsToPreviousSegment())
+	{
+		activeRanges.push_back(currentRange);
+		currentRange = currentRange->link_allSegmentRanges.next;
+	}
+	// store all ranges that end before the first output edge (includes RA_INTER_RANGE_START)
+	auto it = activeRanges.begin();
+	raInstructionEdge firstOutputEdge;
+	firstOutputEdge.Set(0, false);
+	while (it != activeRanges.end())
+	{
+		if ((*it)->interval.end < firstOutputEdge)
+		{
+			raLivenessRange* storedRange = *it;
+			if (storedRange->hasStore)
+				rebuiltInstructions.emplace_back().make_name_r(storedRange->GetName(), _MakeNativeReg(ctx.regIdToBaseFormat[storedRange->GetVirtualRegister()], storedRange->GetPhysicalRegister()));
+			it = activeRanges.erase(it);
+			continue;
+		}
+		++it;
+	}
+
+	sint32 numInstructions = (sint32)imlSegment->imlList.size();
+	for (sint32 i = 0; i < numInstructions; i++)
+	{
+		raInstructionEdge curEdge;
+		// input edge
+		curEdge.SetRaw(i * 2 + 1); // +1 to include ranges that start at the output of the instruction
+		while (currentRange && currentRange->interval.start <= curEdge)
+		{
+			if (!currentRange->_noLoad)
+			{
+				rebuiltInstructions.emplace_back().make_r_name(_MakeNativeReg(ctx.regIdToBaseFormat[currentRange->GetVirtualRegister()], currentRange->GetPhysicalRegister()), currentRange->GetName());
+			}
+			activeRanges.push_back(currentRange);
+			currentRange = currentRange->link_allSegmentRanges.next;
+		}
+		// copy instruction
+		rebuiltInstructions.push_back(imlSegment->imlList[i]);
+		// output edge
+		curEdge.SetRaw(i * 2 + 1 + 1);
+		// also store ranges that end on the next input edge, we handle this by adding an extra 1 above
+		auto it = activeRanges.begin();
+		while (it != activeRanges.end())
+		{
+			if ((*it)->interval.end <= curEdge)
+			{
+				// range expires
+				// todo - check hasStore
+				raLivenessRange* storedRange = *it;
+				if (storedRange->hasStore)
+				{
+					cemu_assert_debug(i != numInstructionsWithoutSuffix); // not allowed to emit after suffix
+					rebuiltInstructions.emplace_back().make_name_r(storedRange->GetName(), _MakeNativeReg(ctx.regIdToBaseFormat[storedRange->GetVirtualRegister()], storedRange->GetPhysicalRegister()));
+				}
+				it = activeRanges.erase(it);
+				continue;
+			}
+			++it;
+		}
+	}
+	// if there is no suffix instruction we currently need to handle the final loads here
+	cemu_assert_debug(hadSuffixInstruction == imlSegment->HasSuffixInstruction());
+	if (imlSegment->HasSuffixInstruction())
+	{
+		if (currentRange)
+		{
+			cemuLog_logDebug(LogType::Force, "[DEBUG] GenerateSegmentMoveInstructions() hit suffix path with non-null currentRange. Segment: {:08x}", imlSegment->ppcAddress);
+		}
+		for (auto& remainingRange : activeRanges)
+		{
+			cemu_assert_debug(!remainingRange->hasStore);
+		}
+	}
+	else
+	{
+		for (auto& remainingRange : activeRanges)
+		{
+			cemu_assert_debug(!remainingRange->hasStore); // this range still needs to be stored
+		}
+		while (currentRange)
+		{
+			cemu_assert_debug(currentRange->interval.IsNextSegmentOnly());
+			cemu_assert_debug(!currentRange->_noLoad);
+			rebuiltInstructions.emplace_back().make_r_name(_MakeNativeReg(ctx.regIdToBaseFormat[currentRange->GetVirtualRegister()], currentRange->GetPhysicalRegister()), currentRange->GetName());
+			currentRange = currentRange->link_allSegmentRanges.next;
+		}
+	}
+
+	imlSegment->imlList = std::move(rebuiltInstructions);
+	cemu_assert_debug(hadSuffixInstruction == imlSegment->HasSuffixInstruction());
+
+#if DEBUG_RA_INSTRUCTION_GEN
+	cemuLog_log(LogType::Force, "");
+	cemuLog_log(LogType::Force, "[Seg after RA]");
+	IMLDebug_DumpSegment(nullptr, imlSegment, false);
+#endif
+}
+
+void IMLRA_GenerateMoveInstructions(IMLRegisterAllocatorContext& ctx)
+{
+	for (size_t s = 0; s < ctx.deprGenContext->segmentList2.size(); s++)
+	{
+		IMLSegment* imlSegment = ctx.deprGenContext->segmentList2[s];
+		IMLRA_GenerateSegmentMoveInstructions2(ctx, imlSegment);
+	}
+}
+
+static void DbgVerifyFixedRegRequirements(IMLSegment* imlSegment)
+{
+#if DEBUG_RA_EXTRA_VALIDATION
+	std::vector<raFixedRegRequirementWithVGPR> frr = IMLRA_BuildSegmentInstructionFixedRegList(imlSegment);
+	for(auto& fixedReq : frr)
+	{
+		for (raLivenessRange* range = imlSegment->raInfo.linkedList_allSubranges; range; range = range->link_allSegmentRanges.next)
+		{
+			if (!range->interval2.ContainsEdge(fixedReq.pos))
+				continue;
+			// verify if the requirement is compatible
+			if(range->GetVirtualRegister() == fixedReq.regId)
+			{
+				cemu_assert(range->HasPhysicalRegister());
+				cemu_assert(fixedReq.allowedReg.IsAvailable(range->GetPhysicalRegister())); // virtual register matches, but not assigned the right physical register
+			}
+			else
+			{
+				cemu_assert(!fixedReq.allowedReg.IsAvailable(range->GetPhysicalRegister())); // virtual register does not match, but using the reserved physical register
+			}
+		}
+	}
+#endif
+}
+
+static void DbgVerifyAllRanges(IMLRegisterAllocatorContext& ctx)
+{
+#if DEBUG_RA_EXTRA_VALIDATION
+	for (size_t s = 0; s < ctx.deprGenContext->segmentList2.size(); s++)
+	{
+		IMLSegment* imlSegment = ctx.deprGenContext->segmentList2[s];
+		raLivenessRange* subrangeItr = imlSegment->raInfo.linkedList_allSubranges;
+		while (subrangeItr)
+		{
+			PPCRecRA_debugValidateSubrange(subrangeItr);
+			subrangeItr = subrangeItr->link_allSegmentRanges.next;
+		}
+	}
+	// check that no range validates register requirements
+	for (size_t s = 0; s < ctx.deprGenContext->segmentList2.size(); s++)
+	{
+		DbgVerifyFixedRegRequirements(ctx.deprGenContext->segmentList2[s]);
+	}
+#endif
+}
+
+void IMLRegisterAllocator_AllocateRegisters(ppcImlGenContext_t* ppcImlGenContext, IMLRegisterAllocatorParameters& raParam)
+{
+	IMLRegisterAllocatorContext ctx;
+	ctx.raParam = &raParam;
+	ctx.deprGenContext = ppcImlGenContext;
+
+	IMLRA_ReshapeForRegisterAllocation(ppcImlGenContext);
+	ppcImlGenContext->UpdateSegmentIndices(); // update momentaryIndex of each segment
+	ctx.perSegmentAbstractRanges.resize(ppcImlGenContext->segmentList2.size());
+	IMLRA_CalculateLivenessRanges(ctx);
+	IMLRA_ProcessFlowAndCalculateLivenessRanges(ctx);
+	IMLRA_AssignRegisters(ctx, ppcImlGenContext);
+	DbgVerifyAllRanges(ctx);
+	IMLRA_AnalyzeRangeDataFlow(ppcImlGenContext);
+	IMLRA_GenerateMoveInstructions(ctx);
+
+	IMLRA_DeleteAllRanges(ppcImlGenContext);
+}
diff --git a/src/Cafe/HW/Espresso/Recompiler/IML/IMLRegisterAllocator.h b/src/Cafe/HW/Espresso/Recompiler/IML/IMLRegisterAllocator.h
new file mode 100644
index 00000000..0a54e4cb
--- /dev/null
+++ b/src/Cafe/HW/Espresso/Recompiler/IML/IMLRegisterAllocator.h
@@ -0,0 +1,125 @@
+#pragma once
+
+// container for storing a set of register indices
+// specifically optimized towards storing typical range of physical register indices (expected to be below 64)
+class IMLPhysRegisterSet
+{
+public:
+	void SetAvailable(uint32 index)
+	{
+		cemu_assert_debug(index < 64);
+		m_regBitmask |= ((uint64)1 << index);
+	}
+
+	void SetReserved(uint32 index)
+	{
+		cemu_assert_debug(index < 64);
+		m_regBitmask &= ~((uint64)1 << index);
+	}
+
+	void SetAllAvailable()
+	{
+		m_regBitmask = ~0ull;
+	}
+
+	bool HasAllAvailable() const
+	{
+		return m_regBitmask == ~0ull;
+	}
+
+	bool IsAvailable(uint32 index) const
+	{
+		return (m_regBitmask & ((uint64)1 << index)) != 0;
+	}
+
+	IMLPhysRegisterSet& operator&=(const IMLPhysRegisterSet& other)
+	{
+		this->m_regBitmask &= other.m_regBitmask;
+		return *this;
+	}
+
+	IMLPhysRegisterSet& operator=(const IMLPhysRegisterSet& other)
+	{
+		this->m_regBitmask = other.m_regBitmask;
+		return *this;
+	}
+
+	void RemoveRegisters(const IMLPhysRegisterSet& other)
+	{
+		this->m_regBitmask &= ~other.m_regBitmask;
+	}
+
+	bool HasAnyAvailable() const
+	{
+		return m_regBitmask != 0;
+	}
+
+	bool HasExactlyOneAvailable() const
+	{
+		return m_regBitmask != 0 && (m_regBitmask & (m_regBitmask - 1)) == 0;
+	}
+
+	// returns index of first available register. Do not call when HasAnyAvailable() == false
+	IMLPhysReg GetFirstAvailableReg()
+	{
+		cemu_assert_debug(m_regBitmask != 0);
+		sint32 regIndex = 0;
+		auto tmp = m_regBitmask;
+		while ((tmp & 0xFF) == 0)
+		{
+			regIndex += 8;
+			tmp >>= 8;
+		}
+		while ((tmp & 0x1) == 0)
+		{
+			regIndex++;
+			tmp >>= 1;
+		}
+		return regIndex;
+	}
+
+	// returns index of next available register (search includes any register index >= startIndex)
+	// returns -1 if there is no more register
+	IMLPhysReg GetNextAvailableReg(sint32 startIndex) const
+	{
+		if (startIndex >= 64)
+			return -1;
+		uint32 regIndex = startIndex;
+		auto tmp = m_regBitmask;
+		tmp >>= regIndex;
+		if (!tmp)
+			return -1;
+		while ((tmp & 0xFF) == 0)
+		{
+			regIndex += 8;
+			tmp >>= 8;
+		}
+		while ((tmp & 0x1) == 0)
+		{
+			regIndex++;
+			tmp >>= 1;
+		}
+		return regIndex;
+	}
+
+	sint32 CountAvailableRegs() const
+	{
+		return std::popcount(m_regBitmask);
+	}
+
+private:
+	uint64 m_regBitmask{ 0 };
+};
+
+struct IMLRegisterAllocatorParameters
+{
+	inline IMLPhysRegisterSet& GetPhysRegPool(IMLRegFormat regFormat)
+	{
+		return perTypePhysPool[stdx::to_underlying(regFormat)];
+	}
+
+	IMLPhysRegisterSet perTypePhysPool[stdx::to_underlying(IMLRegFormat::TYPE_COUNT)];
+	std::unordered_map<IMLRegID, IMLName> regIdToName;
+};
+
+void IMLRegisterAllocator_AllocateRegisters(ppcImlGenContext_t* ppcImlGenContext, IMLRegisterAllocatorParameters& raParam);
\ No newline at end of file
diff --git a/src/Cafe/HW/Espresso/Recompiler/IML/IMLRegisterAllocatorRanges.cpp b/src/Cafe/HW/Espresso/Recompiler/IML/IMLRegisterAllocatorRanges.cpp
new file mode 100644
index 00000000..583d5905
--- /dev/null
+++ b/src/Cafe/HW/Espresso/Recompiler/IML/IMLRegisterAllocatorRanges.cpp
@@ -0,0 +1,635 @@
+#include "../PPCRecompiler.h"
+#include "../PPCRecompilerIml.h"
+#include "IMLRegisterAllocatorRanges.h"
+#include "util/helpers/MemoryPool.h"
+
+uint32 IMLRA_GetNextIterationIndex();
+
+IMLRegID raLivenessRange::GetVirtualRegister() const
+{
+	return virtualRegister;
+}
+
+sint32 raLivenessRange::GetPhysicalRegister() const
+{
+	return physicalRegister;
+}
+
+IMLName raLivenessRange::GetName() const
+{
+	return name;
+}
+
+void raLivenessRange::SetPhysicalRegister(IMLPhysReg physicalRegister)
+{
+	this->physicalRegister = physicalRegister;
+}
+
+void raLivenessRange::SetPhysicalRegisterForCluster(IMLPhysReg physicalRegister)
+{
+	auto clusterRanges = GetAllSubrangesInCluster();
+	for(auto& range : clusterRanges)
+		range->physicalRegister = physicalRegister;
+}
+
+boost::container::small_vector<raLivenessRange*, 128> raLivenessRange::GetAllSubrangesInCluster()
+{
+	uint32 iterationIndex = IMLRA_GetNextIterationIndex();
+	boost::container::small_vector<raLivenessRange*, 128> subranges;
+	subranges.push_back(this);
+	this->lastIterationIndex = iterationIndex;
+	size_t i = 0;
+	while(i<subranges.size())
+	{
+		raLivenessRange* cur = subranges[i];
+		i++;
+		// check successors
+		if(cur->subrangeBranchTaken && cur->subrangeBranchTaken->lastIterationIndex != iterationIndex)
+		{
+			cur->subrangeBranchTaken->lastIterationIndex = iterationIndex;
+			subranges.push_back(cur->subrangeBranchTaken);
+		}
+		if(cur->subrangeBranchNotTaken && cur->subrangeBranchNotTaken->lastIterationIndex != iterationIndex)
+		{
+			cur->subrangeBranchNotTaken->lastIterationIndex = iterationIndex;
+			subranges.push_back(cur->subrangeBranchNotTaken);
+		}
+		// check predecessors
+		for(auto& prev : cur->previousRanges)
+		{
+			if(prev->lastIterationIndex != iterationIndex)
+			{
+				prev->lastIterationIndex = iterationIndex;
+				subranges.push_back(prev);
+			}
+		}
+	}
+	return subranges;
+}
+
+void raLivenessRange::GetAllowedRegistersExRecursive(raLivenessRange* range, uint32 iterationIndex, IMLPhysRegisterSet& allowedRegs)
+{
+	range->lastIterationIndex = iterationIndex;
+	for (auto& it : range->list_fixedRegRequirements)
+		allowedRegs &= it.allowedReg;
+	// check successors
+	if (range->subrangeBranchTaken && range->subrangeBranchTaken->lastIterationIndex != iterationIndex)
+		GetAllowedRegistersExRecursive(range->subrangeBranchTaken, iterationIndex, allowedRegs);
+	if (range->subrangeBranchNotTaken && range->subrangeBranchNotTaken->lastIterationIndex != iterationIndex)
+		GetAllowedRegistersExRecursive(range->subrangeBranchNotTaken, iterationIndex, allowedRegs);
+	// check predecessors
+	for (auto& prev : range->previousRanges)
+	{
+		if (prev->lastIterationIndex != iterationIndex)
+			GetAllowedRegistersExRecursive(prev, iterationIndex, allowedRegs);
+	}
+};
+
+bool raLivenessRange::GetAllowedRegistersEx(IMLPhysRegisterSet& allowedRegisters)
+{
+	uint32 iterationIndex = IMLRA_GetNextIterationIndex();
+	allowedRegisters.SetAllAvailable();
+	GetAllowedRegistersExRecursive(this, iterationIndex, allowedRegisters);
+	return !allowedRegisters.HasAllAvailable();
+}
+
+IMLPhysRegisterSet raLivenessRange::GetAllowedRegisters(IMLPhysRegisterSet regPool)
+{
+	IMLPhysRegisterSet fixedRegRequirements = regPool;
+	if(interval.ExtendsPreviousSegment() || interval.ExtendsIntoNextSegment())
+	{
+		auto clusterRanges = GetAllSubrangesInCluster();
+		for(auto& subrange : clusterRanges)
+		{
+			for(auto& fixedRegLoc : subrange->list_fixedRegRequirements)
+				fixedRegRequirements &= fixedRegLoc.allowedReg;
+		}
+		return fixedRegRequirements;
+	}
+	for(auto& fixedRegLoc : list_fixedRegRequirements)
+		fixedRegRequirements &= fixedRegLoc.allowedReg;
+	return fixedRegRequirements;
+}
+
+void PPCRecRARange_addLink_perVirtualGPR(std::unordered_map<IMLRegID, raLivenessRange*>& root, raLivenessRange* subrange)
+{
+	IMLRegID regId = subrange->GetVirtualRegister();
+	auto it = root.find(regId);
+	if (it == root.end())
+	{
+		// new single element
+		root.try_emplace(regId, subrange);
+		subrange->link_sameVirtualRegister.prev = nullptr;
+		subrange->link_sameVirtualRegister.next = nullptr;
+	}
+	else
+	{
+		// insert in first position
+		raLivenessRange* priorFirst = it->second;
+		subrange->link_sameVirtualRegister.next = priorFirst;
+		it->second = subrange;
+		subrange->link_sameVirtualRegister.prev = nullptr;
+		priorFirst->link_sameVirtualRegister.prev = subrange;
+	}
+}
+
+void PPCRecRARange_addLink_allSegmentRanges(raLivenessRange** root, raLivenessRange* subrange)
+{
+	subrange->link_allSegmentRanges.next = *root;
+	if (*root)
+		(*root)->link_allSegmentRanges.prev = subrange;
+	subrange->link_allSegmentRanges.prev = nullptr;
+	*root = subrange;
+}
+
+void PPCRecRARange_removeLink_perVirtualGPR(std::unordered_map<IMLRegID, raLivenessRange*>& root, raLivenessRange* subrange)
+{
+#ifdef CEMU_DEBUG_ASSERT
+	raLivenessRange* cur = root.find(subrange->GetVirtualRegister())->second;
+	bool hasRangeFound = false;
+	while(cur)
+	{
+		if(cur == subrange)
+		{
+			hasRangeFound = true;
+			break;
+		}
+		cur = cur->link_sameVirtualRegister.next;
+	}
+	cemu_assert_debug(hasRangeFound);
+#endif
+	IMLRegID regId = subrange->GetVirtualRegister();
+	raLivenessRange* nextRange = subrange->link_sameVirtualRegister.next;
+	raLivenessRange* prevRange = subrange->link_sameVirtualRegister.prev;
+	raLivenessRange* newBase = prevRange ? prevRange : nextRange;
+	if (prevRange)
+		prevRange->link_sameVirtualRegister.next = subrange->link_sameVirtualRegister.next;
+	if (nextRange)
+		nextRange->link_sameVirtualRegister.prev = subrange->link_sameVirtualRegister.prev;
+
+	if (!prevRange)
+	{
+		if (nextRange)
+		{
+			root.find(regId)->second = nextRange;
+		}
+		else
+		{
+			cemu_assert_debug(root.find(regId)->second == subrange);
+			root.erase(regId);
+		}
+	}
+#ifdef CEMU_DEBUG_ASSERT
+	subrange->link_sameVirtualRegister.prev = (raLivenessRange*)1;
+	subrange->link_sameVirtualRegister.next = (raLivenessRange*)1;
+#endif
+}
+
+void PPCRecRARange_removeLink_allSegmentRanges(raLivenessRange** root, raLivenessRange* subrange)
+{
+	raLivenessRange* tempPrev = subrange->link_allSegmentRanges.prev;
+	if (subrange->link_allSegmentRanges.prev)
+		subrange->link_allSegmentRanges.prev->link_allSegmentRanges.next = subrange->link_allSegmentRanges.next;
+	else
+		(*root) = subrange->link_allSegmentRanges.next;
+	if (subrange->link_allSegmentRanges.next)
+		subrange->link_allSegmentRanges.next->link_allSegmentRanges.prev = tempPrev;
+#ifdef CEMU_DEBUG_ASSERT
+	subrange->link_allSegmentRanges.prev = (raLivenessRange*)1;
+	subrange->link_allSegmentRanges.next = (raLivenessRange*)1;
+#endif
+}
+
+MemoryPoolPermanentObjects<raLivenessRange> memPool_livenessSubrange(4096);
+
+// startPosition and endPosition are inclusive
+raLivenessRange* IMLRA_CreateRange(ppcImlGenContext_t* ppcImlGenContext, IMLSegment* imlSegment, IMLRegID virtualRegister, IMLName name, raInstructionEdge startPosition, raInstructionEdge endPosition)
+{
+	raLivenessRange* range = memPool_livenessSubrange.acquireObj();
+	range->previousRanges.clear();
+	range->list_accessLocations.clear();
+	range->list_fixedRegRequirements.clear();
+	range->imlSegment = imlSegment;
+
+	cemu_assert_debug(startPosition <= endPosition);
+	range->interval.start = startPosition;
+	range->interval.end = endPosition;
+
+	// register mapping
+	range->virtualRegister = virtualRegister;
+	range->name = name;
+	range->physicalRegister = -1;
+	// default values
+	range->hasStore = false;
+	range->hasStoreDelayed = false;
+	range->lastIterationIndex = 0;
+	range->subrangeBranchNotTaken = nullptr;
+	range->subrangeBranchTaken = nullptr;
+	cemu_assert_debug(range->previousRanges.empty());
+	range->_noLoad = false;
+	// add to segment linked lists
+	PPCRecRARange_addLink_perVirtualGPR(imlSegment->raInfo.linkedList_perVirtualRegister, range);
+	PPCRecRARange_addLink_allSegmentRanges(&imlSegment->raInfo.linkedList_allSubranges, range);
+	return range;
+}
+
+void _unlinkSubrange(raLivenessRange* range)
+{
+	IMLSegment* imlSegment = range->imlSegment;
+	PPCRecRARange_removeLink_perVirtualGPR(imlSegment->raInfo.linkedList_perVirtualRegister, range);
+	PPCRecRARange_removeLink_allSegmentRanges(&imlSegment->raInfo.linkedList_allSubranges, range);
+	// unlink reverse references
+	if(range->subrangeBranchTaken)
+		range->subrangeBranchTaken->previousRanges.erase(std::find(range->subrangeBranchTaken->previousRanges.begin(), range->subrangeBranchTaken->previousRanges.end(), range));
+	if(range->subrangeBranchNotTaken)
+		range->subrangeBranchNotTaken->previousRanges.erase(std::find(range->subrangeBranchNotTaken->previousRanges.begin(), range->subrangeBranchNotTaken->previousRanges.end(), range));
+	range->subrangeBranchTaken = (raLivenessRange*)(uintptr_t)-1;
+	range->subrangeBranchNotTaken = (raLivenessRange*)(uintptr_t)-1;
+	// remove forward references
+	for(auto& prev : range->previousRanges)
+	{
+		if(prev->subrangeBranchTaken == range)
+			prev->subrangeBranchTaken = nullptr;
+		if(prev->subrangeBranchNotTaken == range)
+			prev->subrangeBranchNotTaken = nullptr;
+	}
+	range->previousRanges.clear();
+}
+
+void IMLRA_DeleteRange(ppcImlGenContext_t* ppcImlGenContext, raLivenessRange* range)
+{
+	_unlinkSubrange(range);
+	range->list_accessLocations.clear();
+	range->list_fixedRegRequirements.clear();
+	memPool_livenessSubrange.releaseObj(range);
+}
+
+void IMLRA_DeleteRangeCluster(ppcImlGenContext_t* ppcImlGenContext, raLivenessRange* range)
+{
+	auto clusterRanges = range->GetAllSubrangesInCluster();
+	for (auto& subrange : clusterRanges)
+		IMLRA_DeleteRange(ppcImlGenContext, subrange);
+}
+
+void IMLRA_DeleteAllRanges(ppcImlGenContext_t* ppcImlGenContext)
+{
+	for(auto& seg : ppcImlGenContext->segmentList2)
+	{
+		raLivenessRange* cur;
+		while(cur = seg->raInfo.linkedList_allSubranges)
+			IMLRA_DeleteRange(ppcImlGenContext, cur);
+		seg->raInfo.linkedList_allSubranges = nullptr;
+		seg->raInfo.linkedList_perVirtualRegister.clear();
+	}
+}
+
+void IMLRA_MergeSubranges(ppcImlGenContext_t* ppcImlGenContext, raLivenessRange* subrange, raLivenessRange* absorbedSubrange)
+{
+#ifdef CEMU_DEBUG_ASSERT
+	PPCRecRA_debugValidateSubrange(subrange);
+	PPCRecRA_debugValidateSubrange(absorbedSubrange);
+	if (subrange->imlSegment != absorbedSubrange->imlSegment)
+		assert_dbg();
+	cemu_assert_debug(subrange->interval.end == absorbedSubrange->interval.start);
+
+	if (subrange->subrangeBranchTaken || subrange->subrangeBranchNotTaken)
+		assert_dbg();
+	if (subrange == absorbedSubrange)
+		assert_dbg();
+#endif
+	// update references
+	subrange->subrangeBranchTaken = absorbedSubrange->subrangeBranchTaken;
+	subrange->subrangeBranchNotTaken = absorbedSubrange->subrangeBranchNotTaken;
+	absorbedSubrange->subrangeBranchTaken = nullptr;
+	absorbedSubrange->subrangeBranchNotTaken = nullptr;
+	if(subrange->subrangeBranchTaken)
+		*std::find(subrange->subrangeBranchTaken->previousRanges.begin(), subrange->subrangeBranchTaken->previousRanges.end(), absorbedSubrange) = subrange;
+	if(subrange->subrangeBranchNotTaken)
+		*std::find(subrange->subrangeBranchNotTaken->previousRanges.begin(), subrange->subrangeBranchNotTaken->previousRanges.end(), absorbedSubrange) = subrange;
+
+	// merge usage locations
+	for (auto& accessLoc : absorbedSubrange->list_accessLocations)
+		subrange->list_accessLocations.push_back(accessLoc);
+	absorbedSubrange->list_accessLocations.clear();
+	// merge fixed reg locations
+#ifdef CEMU_DEBUG_ASSERT
+	if(!subrange->list_fixedRegRequirements.empty() && !absorbedSubrange->list_fixedRegRequirements.empty())
+	{
+		cemu_assert_debug(subrange->list_fixedRegRequirements.back().pos < absorbedSubrange->list_fixedRegRequirements.front().pos);
+	}
+#endif
+	for (auto& fixedReg : absorbedSubrange->list_fixedRegRequirements)
+		subrange->list_fixedRegRequirements.push_back(fixedReg);
+	absorbedSubrange->list_fixedRegRequirements.clear();
+
+	subrange->interval.end = absorbedSubrange->interval.end;
+
+	PPCRecRA_debugValidateSubrange(subrange);
+
+	IMLRA_DeleteRange(ppcImlGenContext, absorbedSubrange);
+}
+
+// remove all inter-segment connections from the range cluster and split it into local ranges. Ranges are trimmed and if they have no access location they will be removed
+void IMLRA_ExplodeRangeCluster(ppcImlGenContext_t* ppcImlGenContext, raLivenessRange* originRange)
+{
+	cemu_assert_debug(originRange->interval.ExtendsPreviousSegment() || originRange->interval.ExtendsIntoNextSegment()); // only call this on ranges that span multiple segments
+	auto clusterRanges = originRange->GetAllSubrangesInCluster();
+	for (auto& subrange : clusterRanges)
+	{
+		if (subrange->list_accessLocations.empty())
+			continue;
+		raInterval interval;
+		interval.SetInterval(subrange->list_accessLocations.front().pos, subrange->list_accessLocations.back().pos);
+		raLivenessRange* newSubrange = IMLRA_CreateRange(ppcImlGenContext, subrange->imlSegment, subrange->GetVirtualRegister(), subrange->GetName(), interval.start, interval.end);
+		// copy locations and fixed reg indices
+		newSubrange->list_accessLocations = subrange->list_accessLocations;
+		newSubrange->list_fixedRegRequirements = subrange->list_fixedRegRequirements;
+		if(originRange->HasPhysicalRegister())
+		{
+			cemu_assert_debug(subrange->list_fixedRegRequirements.empty()); // avoid unassigning a register from a range with a fixed register requirement
+		}
+		// validate
+		if(!newSubrange->list_accessLocations.empty())
+		{
+			cemu_assert_debug(newSubrange->list_accessLocations.front().pos >= newSubrange->interval.start);
+			cemu_assert_debug(newSubrange->list_accessLocations.back().pos <= newSubrange->interval.end);
+		}
+		if(!newSubrange->list_fixedRegRequirements.empty())
+		{
+			cemu_assert_debug(newSubrange->list_fixedRegRequirements.front().pos >= newSubrange->interval.start); // fixed register requirements outside of the actual access range probably means there is a mistake in GetInstructionFixedRegisters()
+			cemu_assert_debug(newSubrange->list_fixedRegRequirements.back().pos <= newSubrange->interval.end);
+		}
+	}
+	// delete the original range cluster
+	IMLRA_DeleteRangeCluster(ppcImlGenContext, originRange);
+}
+
+#ifdef CEMU_DEBUG_ASSERT
+void PPCRecRA_debugValidateSubrange(raLivenessRange* range)
+{
+	// validate subrange
+	if (range->subrangeBranchTaken && range->subrangeBranchTaken->imlSegment != range->imlSegment->nextSegmentBranchTaken)
+		assert_dbg();
+	if (range->subrangeBranchNotTaken && range->subrangeBranchNotTaken->imlSegment != range->imlSegment->nextSegmentBranchNotTaken)
+		assert_dbg();
+
+	if(range->subrangeBranchTaken || range->subrangeBranchNotTaken)
+	{
+		cemu_assert_debug(range->interval.end.ConnectsToNextSegment());
+	}
+	if(!range->previousRanges.empty())
+	{
+		cemu_assert_debug(range->interval.start.ConnectsToPreviousSegment());
+	}
+	// validate locations
+	if (!range->list_accessLocations.empty())
+	{
+		cemu_assert_debug(range->list_accessLocations.front().pos >= range->interval.start);
+		cemu_assert_debug(range->list_accessLocations.back().pos <= range->interval.end);
+	}
+	// validate fixed reg requirements
+	if (!range->list_fixedRegRequirements.empty())
+	{
+		cemu_assert_debug(range->list_fixedRegRequirements.front().pos >= range->interval.start);
+		cemu_assert_debug(range->list_fixedRegRequirements.back().pos <= range->interval.end);
+		for(sint32 i = 0; i < (sint32)range->list_fixedRegRequirements.size()-1; i++)
+			cemu_assert_debug(range->list_fixedRegRequirements[i].pos < range->list_fixedRegRequirements[i+1].pos);
+	}
+
+}
+#else
+void PPCRecRA_debugValidateSubrange(raLivenessRange* range) {}
+#endif
+
+// trim start and end of range to match first and last read/write locations
+// does not trim start/endpoints which extend into the next/previous segment
+void IMLRA_TrimRangeToUse(raLivenessRange* range)
+{
+	if(range->list_accessLocations.empty())
+	{
+		// special case where we trim ranges extending from other segments to a single instruction edge
+		cemu_assert_debug(!range->interval.start.IsInstructionIndex() || !range->interval.end.IsInstructionIndex());
+		if(range->interval.start.IsInstructionIndex())
+			range->interval.start = range->interval.end;
+		if(range->interval.end.IsInstructionIndex())
+			range->interval.end = range->interval.start;
+		return;
+	}
+	// trim start and end
+	raInterval prevInterval = range->interval;
+	if(range->interval.start.IsInstructionIndex())
+		range->interval.start = range->list_accessLocations.front().pos;
+	if(range->interval.end.IsInstructionIndex())
+		range->interval.end = range->list_accessLocations.back().pos;
+	// extra checks
+#ifdef CEMU_DEBUG_ASSERT
+	cemu_assert_debug(range->interval.start <= range->interval.end);
+	for(auto& loc : range->list_accessLocations)
+	{
+		cemu_assert_debug(range->interval.ContainsEdge(loc.pos));
+	}
+	cemu_assert_debug(prevInterval.ContainsWholeInterval(range->interval));
+#endif
+}
+
+// split range at the given position
+// After the split there will be two ranges:
+// head -> subrange is shortened to end at splitIndex (exclusive)
+// tail -> a new subrange that ranges from splitIndex (inclusive) to the end of the original subrange
+// if head has a physical register assigned it will not carry over to tail
+// The return value is the tail range
+// If trimToUsage is true, the end of the head subrange and the start of the tail subrange will be shrunk to fit the read/write locations within. If there are no locations then the range will be deleted
+raLivenessRange* IMLRA_SplitRange(ppcImlGenContext_t* ppcImlGenContext, raLivenessRange*& subrange, raInstructionEdge splitPosition, bool trimToUsage)
+{
+	cemu_assert_debug(splitPosition.IsInstructionIndex());
+	cemu_assert_debug(!subrange->interval.IsNextSegmentOnly() && !subrange->interval.IsPreviousSegmentOnly());
+	cemu_assert_debug(subrange->interval.ContainsEdge(splitPosition));
+	// determine new intervals
+	raInterval headInterval, tailInterval;
+	headInterval.SetInterval(subrange->interval.start, splitPosition-1);
+	tailInterval.SetInterval(splitPosition, subrange->interval.end);
+	cemu_assert_debug(headInterval.start <= headInterval.end);
+	cemu_assert_debug(tailInterval.start <= tailInterval.end);
+	// create tail
+	raLivenessRange* tailSubrange = IMLRA_CreateRange(ppcImlGenContext, subrange->imlSegment, subrange->GetVirtualRegister(), subrange->GetName(), tailInterval.start, tailInterval.end);
+	tailSubrange->SetPhysicalRegister(subrange->GetPhysicalRegister());
+	// carry over branch targets and update reverse references
+	tailSubrange->subrangeBranchTaken = subrange->subrangeBranchTaken;
+	tailSubrange->subrangeBranchNotTaken = subrange->subrangeBranchNotTaken;
+	subrange->subrangeBranchTaken = nullptr;
+	subrange->subrangeBranchNotTaken = nullptr;
+	if(tailSubrange->subrangeBranchTaken)
+		*std::find(tailSubrange->subrangeBranchTaken->previousRanges.begin(), tailSubrange->subrangeBranchTaken->previousRanges.end(), subrange) = tailSubrange;
+	if(tailSubrange->subrangeBranchNotTaken)
+		*std::find(tailSubrange->subrangeBranchNotTaken->previousRanges.begin(), tailSubrange->subrangeBranchNotTaken->previousRanges.end(), subrange) = tailSubrange;
+	// we assume that list_locations is ordered by instruction index and contains no duplicate indices, so lets check that here just in case
+#ifdef CEMU_DEBUG_ASSERT
+	if(subrange->list_accessLocations.size() > 1)
+	{
+		for(size_t i=0; i<subrange->list_accessLocations.size()-1; i++)
+		{
+			cemu_assert_debug(subrange->list_accessLocations[i].pos < subrange->list_accessLocations[i+1].pos);
+		}
+	}
+#endif
+	// split locations
+	auto it = std::lower_bound(
+		subrange->list_accessLocations.begin(), subrange->list_accessLocations.end(), splitPosition,
+		[](const raAccessLocation& accessLoc, raInstructionEdge value) { return accessLoc.pos < value; }
+	);
+	size_t originalCount = subrange->list_accessLocations.size();
+	tailSubrange->list_accessLocations.insert(tailSubrange->list_accessLocations.end(), it, subrange->list_accessLocations.end());
+	subrange->list_accessLocations.erase(it, subrange->list_accessLocations.end());
+	cemu_assert_debug(subrange->list_accessLocations.empty() || subrange->list_accessLocations.back().pos < splitPosition);
+	cemu_assert_debug(tailSubrange->list_accessLocations.empty() || tailSubrange->list_accessLocations.front().pos >= splitPosition);
+	cemu_assert_debug(subrange->list_accessLocations.size() + tailSubrange->list_accessLocations.size() == originalCount);
+	// split fixed reg requirements
+	for (sint32 i = 0; i < subrange->list_fixedRegRequirements.size(); i++)
+	{
+		raFixedRegRequirement* fixedReg = subrange->list_fixedRegRequirements.data() + i;
+		if (tailInterval.ContainsEdge(fixedReg->pos))
+		{
+			tailSubrange->list_fixedRegRequirements.push_back(*fixedReg);
+		}
+	}
+	// remove tail fixed reg requirements from head
+	for (sint32 i = 0; i < subrange->list_fixedRegRequirements.size(); i++)
+	{
+		raFixedRegRequirement* fixedReg = subrange->list_fixedRegRequirements.data() + i;
+		if (!headInterval.ContainsEdge(fixedReg->pos))
+		{
+			subrange->list_fixedRegRequirements.resize(i);
+			break;
+		}
+	}
+	// adjust intervals
+	subrange->interval = headInterval;
+	tailSubrange->interval = tailInterval;
+	// trim to hole
+	if(trimToUsage)
+	{
+		if(subrange->list_accessLocations.empty() && (subrange->interval.start.IsInstructionIndex() && subrange->interval.end.IsInstructionIndex()))
+		{
+			IMLRA_DeleteRange(ppcImlGenContext, subrange);
+			subrange = nullptr;
+		}
+		else
+		{
+			IMLRA_TrimRangeToUse(subrange);
+		}
+		if(tailSubrange->list_accessLocations.empty() && (tailSubrange->interval.start.IsInstructionIndex() && tailSubrange->interval.end.IsInstructionIndex()))
+		{
+			IMLRA_DeleteRange(ppcImlGenContext, tailSubrange);
+			tailSubrange = nullptr;
+		}
+		else
+		{
+			IMLRA_TrimRangeToUse(tailSubrange);
+		}
+	}
+	// validation
+	cemu_assert_debug(!subrange || subrange->interval.start <= subrange->interval.end);
+	cemu_assert_debug(!tailSubrange || tailSubrange->interval.start <= tailSubrange->interval.end);
+	cemu_assert_debug(!tailSubrange || tailSubrange->interval.start >= splitPosition);
+	if (!trimToUsage)
+		cemu_assert_debug(!tailSubrange || tailSubrange->interval.start == splitPosition);
+
+	if(subrange)
+		PPCRecRA_debugValidateSubrange(subrange);
+	if(tailSubrange)
+		PPCRecRA_debugValidateSubrange(tailSubrange);
+	return tailSubrange;
+}
+
+sint32 IMLRA_GetSegmentReadWriteCost(IMLSegment* imlSegment)
+{
+	sint32 v = imlSegment->loopDepth + 1;
+	v *= 5;
+	return v*v; // 25, 100, 225, 400
+}
+
+// calculate additional cost of range that it would have after calling _ExplodeRange() on it
+sint32 IMLRA_CalculateAdditionalCostOfRangeExplode(raLivenessRange* subrange)
+{
+	auto ranges = subrange->GetAllSubrangesInCluster();
+	sint32 cost = 0;//-PPCRecRARange_estimateTotalCost(ranges);
+	for (auto& subrange : ranges)
+	{
+		if (subrange->list_accessLocations.empty())
+			continue; // this range would be deleted and thus has no cost
+		sint32 segmentLoadStoreCost = IMLRA_GetSegmentReadWriteCost(subrange->imlSegment);
+		bool hasAdditionalLoad = subrange->interval.ExtendsPreviousSegment();
+		bool hasAdditionalStore = subrange->interval.ExtendsIntoNextSegment();
+		if(hasAdditionalLoad && subrange->list_accessLocations.front().IsWrite()) // if written before read then a load isn't necessary
+		{
+			cemu_assert_debug(!subrange->list_accessLocations.front().IsRead());
+			cost += segmentLoadStoreCost;
+		}
+		if(hasAdditionalStore)
+		{
+			bool hasWrite = std::find_if(subrange->list_accessLocations.begin(), subrange->list_accessLocations.end(), [](const raAccessLocation& loc) { return loc.IsWrite(); }) != subrange->list_accessLocations.end();
+			if(!hasWrite) // ranges which don't modify their value do not need to be stored
+				cost += segmentLoadStoreCost;
+		}
+	}
+	// todo - properly calculating all the data-flow dependency based costs is more complex so this currently is an approximation
+	return cost;
+}
+
+sint32 IMLRA_CalculateAdditionalCostAfterSplit(raLivenessRange* subrange, raInstructionEdge splitPosition)
+{
+	// validation
+#ifdef CEMU_DEBUG_ASSERT
+	if (subrange->interval.ExtendsIntoNextSegment())
+		assert_dbg();
+#endif
+	cemu_assert_debug(splitPosition.IsInstructionIndex());
+
+	sint32 cost = 0;
+	// find split position in location list
+	if (subrange->list_accessLocations.empty())
+		return 0;
+	if (splitPosition <= subrange->list_accessLocations.front().pos)
+		return 0;
+	if (splitPosition > subrange->list_accessLocations.back().pos)
+		return 0;
+
+	size_t firstTailLocationIndex = 0;
+	for (size_t i = 0; i < subrange->list_accessLocations.size(); i++)
+	{
+		if (subrange->list_accessLocations[i].pos >= splitPosition)
+		{
+			firstTailLocationIndex = i;
+			break;
+		}
+	}
+	std::span<raAccessLocation> headLocations{subrange->list_accessLocations.data(), firstTailLocationIndex};
+	std::span<raAccessLocation> tailLocations{subrange->list_accessLocations.data() + firstTailLocationIndex, subrange->list_accessLocations.size() - firstTailLocationIndex};
+	cemu_assert_debug(headLocations.empty() || headLocations.back().pos < splitPosition);
+	cemu_assert_debug(tailLocations.empty() || tailLocations.front().pos >= splitPosition);
+
+	sint32 segmentLoadStoreCost = IMLRA_GetSegmentReadWriteCost(subrange->imlSegment);
+
+	auto CalculateCostFromLocationRange = [segmentLoadStoreCost](std::span<raAccessLocation> locations, bool trackLoadCost = true, bool trackStoreCost = true) -> sint32
+	{
+		if(locations.empty())
+			return 0;
+		sint32 cost = 0;
+		if(locations.front().IsRead() && trackLoadCost)
+			cost += segmentLoadStoreCost; // not overwritten, so there is a load cost
+		bool hasWrite = std::find_if(locations.begin(), locations.end(), [](const raAccessLocation& loc) { return loc.IsWrite(); }) != locations.end();
+		if(hasWrite && trackStoreCost)
+			cost += segmentLoadStoreCost; // modified, so there is a store cost
+		return cost;
+	};
+
+	sint32 baseCost = CalculateCostFromLocationRange(subrange->list_accessLocations);
+
+	bool tailOverwritesValue = !tailLocations.empty() && !tailLocations.front().IsRead() && tailLocations.front().IsWrite();
+
+	sint32 newCost = CalculateCostFromLocationRange(headLocations) + CalculateCostFromLocationRange(tailLocations, !tailOverwritesValue, true);
+	cemu_assert_debug(newCost >= baseCost);
+	cost = newCost - baseCost;
+
+	return cost;
+}
\ No newline at end of file
diff --git a/src/Cafe/HW/Espresso/Recompiler/IML/IMLRegisterAllocatorRanges.h b/src/Cafe/HW/Espresso/Recompiler/IML/IMLRegisterAllocatorRanges.h
new file mode 100644
index 00000000..b0685cc5
--- /dev/null
+++ b/src/Cafe/HW/Espresso/Recompiler/IML/IMLRegisterAllocatorRanges.h
@@ -0,0 +1,364 @@
+#pragma once
+#include "IMLRegisterAllocator.h"
+
+struct raLivenessSubrangeLink
+{
+	struct raLivenessRange* prev;
+	struct raLivenessRange* next;
+};
+
+struct raInstructionEdge
+{
+	friend struct raInterval;
+public:
+	raInstructionEdge()
+	{
+		index = 0;
+	}
+
+	raInstructionEdge(sint32 instructionIndex, bool isInputEdge)
+	{
+		Set(instructionIndex, isInputEdge);
+	}
+
+	void Set(sint32 instructionIndex, bool isInputEdge)
+	{
+		if(instructionIndex == RA_INTER_RANGE_START || instructionIndex == RA_INTER_RANGE_END)
+		{
+			index = instructionIndex;
+			return;
+		}
+		index = instructionIndex * 2 + (isInputEdge ? 0 : 1);
+		cemu_assert_debug(index >= 0 && index < 0x100000*2); // make sure index value is sane
+	}
+
+	void SetRaw(sint32 index)
+	{
+		this->index = index;
+		cemu_assert_debug(index == RA_INTER_RANGE_START || index == RA_INTER_RANGE_END || (index >= 0 && index < 0x100000*2)); // make sure index value is sane
+	}
+
+	// sint32 GetRaw()
+	// {
+	// 	this->index = index;
+	// }
+
+	std::string GetDebugString()
+	{
+		if(index == RA_INTER_RANGE_START)
+			return "RA_START";
+		else if(index == RA_INTER_RANGE_END)
+			return "RA_END";
+		std::string str = fmt::format("{}", GetInstructionIndex());
+		if(IsOnInputEdge())
+			str += "i";
+		else if(IsOnOutputEdge())
+			str += "o";
+		return str;
+	}
+
+	sint32 GetInstructionIndex() const
+	{
+		cemu_assert_debug(index != RA_INTER_RANGE_START && index != RA_INTER_RANGE_END);
+		return index >> 1;
+	}
+
+	// returns instruction index or RA_INTER_RANGE_START/RA_INTER_RANGE_END
+	sint32 GetInstructionIndexEx() const
+	{
+		if(index == RA_INTER_RANGE_START || index == RA_INTER_RANGE_END)
+			return index;
+		return index >> 1;
+	}
+
+	sint32 GetRaw() const
+	{
+		return index;
+	}
+
+	bool IsOnInputEdge() const
+	{
+		cemu_assert_debug(index != RA_INTER_RANGE_START && index != RA_INTER_RANGE_END);
+		return (index&1) == 0;
+	}
+
+	bool IsOnOutputEdge() const
+	{
+		cemu_assert_debug(index != RA_INTER_RANGE_START && index != RA_INTER_RANGE_END);
+		return (index&1) != 0;
+	}
+
+	bool ConnectsToPreviousSegment() const
+	{
+		return index == RA_INTER_RANGE_START;
+	}
+
+	bool ConnectsToNextSegment() const
+	{
+		return index == RA_INTER_RANGE_END;
+	}
+
+	bool IsInstructionIndex() const
+	{
+		return index != RA_INTER_RANGE_START && index != RA_INTER_RANGE_END;
+	}
+
+	// comparison operators
+	bool operator>(const raInstructionEdge& other) const
+	{
+		return index > other.index;
+	}
+	bool operator<(const raInstructionEdge& other) const
+	{
+		return index < other.index;
+	}
+	bool operator<=(const raInstructionEdge& other) const
+	{
+		return index <= other.index;
+	}
+	bool operator>=(const raInstructionEdge& other) const
+	{
+		return index >= other.index;
+	}
+	bool operator==(const raInstructionEdge& other) const
+	{
+		return index == other.index;
+	}
+
+	raInstructionEdge operator+(sint32 offset) const
+	{
+		cemu_assert_debug(IsInstructionIndex());
+		cemu_assert_debug(offset >= 0 && offset < RA_INTER_RANGE_END);
+		raInstructionEdge edge;
+		edge.index = index + offset;
+		return edge;
+	}
+
+	raInstructionEdge operator-(sint32 offset) const
+	{
+		cemu_assert_debug(IsInstructionIndex());
+		cemu_assert_debug(offset >= 0 && offset < RA_INTER_RANGE_END);
+		raInstructionEdge edge;
+		edge.index = index - offset;
+		return edge;
+	}
+
+	raInstructionEdge& operator++()
+	{
+		cemu_assert_debug(IsInstructionIndex());
+		index++;
+		return *this;
+	}
+
+private:
+	sint32 index; // can also be RA_INTER_RANGE_START or RA_INTER_RANGE_END, otherwise contains instruction index * 2
+
+};
+
+struct raAccessLocation
+{
+	raAccessLocation(raInstructionEdge pos) : pos(pos) {}
+
+	bool IsRead() const
+	{
+		return pos.IsOnInputEdge();
+	}
+
+	bool IsWrite() const
+	{
+		return pos.IsOnOutputEdge();
+	}
+
+	raInstructionEdge pos;
+};
+
+struct raInterval
+{
+	raInterval()
+	{
+
+	}
+
+	raInterval(raInstructionEdge start, raInstructionEdge end)
+	{
+		SetInterval(start, end);
+	}
+
+	// isStartOnInput = Input+Output edge on first instruction. If false then only output
+	// isEndOnOutput = Input+Output edge on last instruction. If false then only input
+	void SetInterval(sint32 start, bool isStartOnInput, sint32 end, bool isEndOnOutput)
+	{
+		this->start.Set(start, isStartOnInput);
+		this->end.Set(end, !isEndOnOutput);
+	}
+
+	void SetInterval(raInstructionEdge start, raInstructionEdge end)
+	{
+		cemu_assert_debug(start <= end);
+		this->start = start;
+		this->end = end;
+	}
+
+	void SetStart(const raInstructionEdge& edge)
+	{
+		start = edge;
+	}
+
+	void SetEnd(const raInstructionEdge& edge)
+	{
+		end = edge;
+	}
+
+	sint32 GetStartIndex() const
+	{
+		return start.GetInstructionIndex();
+	}
+
+	sint32 GetEndIndex() const
+	{
+		return end.GetInstructionIndex();
+	}
+
+	bool ExtendsPreviousSegment() const
+	{
+		return start.ConnectsToPreviousSegment();
+	}
+
+	bool ExtendsIntoNextSegment() const
+	{
+		return end.ConnectsToNextSegment();
+	}
+
+	bool IsNextSegmentOnly() const
+	{
+		return start.ConnectsToNextSegment() && end.ConnectsToNextSegment();
+	}
+
+	bool IsPreviousSegmentOnly() const
+	{
+		return start.ConnectsToPreviousSegment() && end.ConnectsToPreviousSegment();
+	}
+
+	// returns true if range is contained within a single segment
+	bool IsLocal() const
+	{
+		return start.GetRaw() > RA_INTER_RANGE_START && end.GetRaw() < RA_INTER_RANGE_END;
+	}
+
+	bool ContainsInstructionIndex(sint32 instructionIndex) const
+	{
+		cemu_assert_debug(instructionIndex != RA_INTER_RANGE_START && instructionIndex != RA_INTER_RANGE_END);
+		return instructionIndex >= start.GetInstructionIndexEx() && instructionIndex <= end.GetInstructionIndexEx();
+	}
+
+	// similar to ContainsInstructionIndex, but allows RA_INTER_RANGE_START/END as input
+	bool ContainsInstructionIndexEx(sint32 instructionIndex) const
+	{
+		if(instructionIndex == RA_INTER_RANGE_START)
+			return start.ConnectsToPreviousSegment();
+		if(instructionIndex == RA_INTER_RANGE_END)
+			return end.ConnectsToNextSegment();
+		return instructionIndex >= start.GetInstructionIndexEx() && instructionIndex <= end.GetInstructionIndexEx();
+	}
+
+	bool ContainsEdge(const raInstructionEdge& edge) const
+	{
+		return edge >= start && edge <= end;
+	}
+
+	bool ContainsWholeInterval(const raInterval& other) const
+	{
+		return other.start >= start && other.end <= end;
+	}
+
+	bool IsOverlapping(const raInterval& other) const
+	{
+		return start <= other.end && end >= other.start;
+	}
+
+	sint32 GetPreciseDistance()
+	{
+		cemu_assert_debug(!start.ConnectsToNextSegment()); // how to handle this?
+		if(start == end)
+			return 1;
+		cemu_assert_debug(!end.ConnectsToPreviousSegment() && !end.ConnectsToNextSegment());
+		if(start.ConnectsToPreviousSegment())
+			return end.GetRaw() + 1;
+
+		return end.GetRaw() - start.GetRaw() + 1; // +1 because end is inclusive
+	}
+
+//private: not making these directly accessible only forces us to create loads of verbose getters and setters
+	raInstructionEdge start;
+	raInstructionEdge end;
+};
+
+struct raFixedRegRequirement
+{
+	raInstructionEdge pos;
+	IMLPhysRegisterSet allowedReg;
+};
+
+struct raLivenessRange
+{
+	IMLSegment* imlSegment;
+	raInterval interval;
+
+	// dirty state tracking
+	bool _noLoad;
+	bool hasStore;
+	bool hasStoreDelayed;
+	// next
+	raLivenessRange* subrangeBranchTaken;
+	raLivenessRange* subrangeBranchNotTaken;
+	// reverse counterpart of BranchTaken/BranchNotTaken
+	boost::container::small_vector<raLivenessRange*, 4> previousRanges;
+	// processing
+	uint32 lastIterationIndex;
+	// instruction read/write locations
+	std::vector<raAccessLocation> list_accessLocations;
+	// ordered list of all raInstructionEdge indices which require a fixed register
+	std::vector<raFixedRegRequirement> list_fixedRegRequirements;
+	// linked list (subranges with same GPR virtual register)
+	raLivenessSubrangeLink link_sameVirtualRegister;
+	// linked list (all subranges for this segment)
+	raLivenessSubrangeLink link_allSegmentRanges;
+	// register info
+	IMLRegID virtualRegister;
+	IMLName name;
+	// register allocator result
+	IMLPhysReg physicalRegister;
+
+	boost::container::small_vector<raLivenessRange*, 128> GetAllSubrangesInCluster();
+	bool GetAllowedRegistersEx(IMLPhysRegisterSet& allowedRegisters); // if the cluster has fixed register requirements in any instruction this returns the combined register mask. Otherwise returns false in which case allowedRegisters is left undefined
+	IMLPhysRegisterSet GetAllowedRegisters(IMLPhysRegisterSet regPool); // return regPool with fixed register requirements filtered out
+
+	IMLRegID GetVirtualRegister() const;
+	sint32 GetPhysicalRegister() const;
+	bool HasPhysicalRegister() const { return physicalRegister >= 0; }
+	IMLName GetName() const;
+	void SetPhysicalRegister(IMLPhysReg physicalRegister);
+	void SetPhysicalRegisterForCluster(IMLPhysReg physicalRegister);
+	void UnsetPhysicalRegister() { physicalRegister = -1; }
+
+  private:
+	void GetAllowedRegistersExRecursive(raLivenessRange* range, uint32 iterationIndex, IMLPhysRegisterSet& allowedRegs);
+};
+
+raLivenessRange* IMLRA_CreateRange(ppcImlGenContext_t* ppcImlGenContext, IMLSegment* imlSegment, IMLRegID virtualRegister, IMLName name, raInstructionEdge startPosition, raInstructionEdge endPosition);
+void IMLRA_DeleteRange(ppcImlGenContext_t* ppcImlGenContext, raLivenessRange* subrange);
+void IMLRA_DeleteAllRanges(ppcImlGenContext_t* ppcImlGenContext);
+
+void IMLRA_ExplodeRangeCluster(ppcImlGenContext_t* ppcImlGenContext, raLivenessRange* originRange);
+
+void IMLRA_MergeSubranges(ppcImlGenContext_t* ppcImlGenContext, raLivenessRange* subrange, raLivenessRange* absorbedSubrange);
+
+raLivenessRange* IMLRA_SplitRange(ppcImlGenContext_t* ppcImlGenContext, raLivenessRange*& subrange, raInstructionEdge splitPosition, bool trimToUsage = false);
+
+void PPCRecRA_debugValidateSubrange(raLivenessRange* subrange);
+
+// cost estimation
+sint32 IMLRA_GetSegmentReadWriteCost(IMLSegment* imlSegment);
+sint32 IMLRA_CalculateAdditionalCostOfRangeExplode(raLivenessRange* subrange);
+//sint32 PPCRecRARange_estimateAdditionalCostAfterSplit(raLivenessRange* subrange, sint32 splitIndex);
+sint32 IMLRA_CalculateAdditionalCostAfterSplit(raLivenessRange* subrange, raInstructionEdge splitPosition);
\ No newline at end of file
diff --git a/src/Cafe/HW/Espresso/Recompiler/IML/IMLSegment.cpp b/src/Cafe/HW/Espresso/Recompiler/IML/IMLSegment.cpp
new file mode 100644
index 00000000..f3b6834f
--- /dev/null
+++ b/src/Cafe/HW/Espresso/Recompiler/IML/IMLSegment.cpp
@@ -0,0 +1,133 @@
+#include "IMLInstruction.h"
+#include "IMLSegment.h"
+
+void IMLSegment::SetEnterable(uint32 enterAddress)
+{
+	cemu_assert_debug(!isEnterable || enterPPCAddress == enterAddress);
+	isEnterable = true;
+	enterPPCAddress = enterAddress;
+}
+
+bool IMLSegment::HasSuffixInstruction() const
+{
+	if (imlList.empty())
+		return false;
+	const IMLInstruction& imlInstruction = imlList.back();
+	return imlInstruction.IsSuffixInstruction();
+}
+
+sint32 IMLSegment::GetSuffixInstructionIndex() const
+{
+	cemu_assert_debug(HasSuffixInstruction());
+	return (sint32)(imlList.size() - 1);
+}
+
+IMLInstruction* IMLSegment::GetLastInstruction()
+{
+	if (imlList.empty())
+		return nullptr;
+	return &imlList.back();
+}
+
+void IMLSegment::SetLinkBranchNotTaken(IMLSegment* imlSegmentDst)
+{
+	if (nextSegmentBranchNotTaken)
+		nextSegmentBranchNotTaken->list_prevSegments.erase(std::find(nextSegmentBranchNotTaken->list_prevSegments.begin(), nextSegmentBranchNotTaken->list_prevSegments.end(), this));
+	nextSegmentBranchNotTaken = imlSegmentDst;
+	if(imlSegmentDst)
+		imlSegmentDst->list_prevSegments.push_back(this);
+}
+
+void IMLSegment::SetLinkBranchTaken(IMLSegment* imlSegmentDst)
+{
+	if (nextSegmentBranchTaken)
+		nextSegmentBranchTaken->list_prevSegments.erase(std::find(nextSegmentBranchTaken->list_prevSegments.begin(), nextSegmentBranchTaken->list_prevSegments.end(), this));
+	nextSegmentBranchTaken = imlSegmentDst;
+	if (imlSegmentDst)
+		imlSegmentDst->list_prevSegments.push_back(this);
+}
+
+IMLInstruction* IMLSegment::AppendInstruction()
+{
+	IMLInstruction& inst = imlList.emplace_back();
+	memset(&inst, 0, sizeof(IMLInstruction));
+	return &inst;
+}
+
+void IMLSegment_SetLinkBranchNotTaken(IMLSegment* imlSegmentSrc, IMLSegment* imlSegmentDst)
+{
+	// make sure segments aren't already linked
+	if (imlSegmentSrc->nextSegmentBranchNotTaken == imlSegmentDst)
+		return;
+	// add as next segment for source
+	if (imlSegmentSrc->nextSegmentBranchNotTaken != nullptr)
+		assert_dbg();
+	imlSegmentSrc->nextSegmentBranchNotTaken = imlSegmentDst;
+	// add as previous segment for destination
+	imlSegmentDst->list_prevSegments.push_back(imlSegmentSrc);
+}
+
+void IMLSegment_SetLinkBranchTaken(IMLSegment* imlSegmentSrc, IMLSegment* imlSegmentDst)
+{
+	// make sure segments aren't already linked
+	if (imlSegmentSrc->nextSegmentBranchTaken == imlSegmentDst)
+		return;
+	// add as next segment for source
+	if (imlSegmentSrc->nextSegmentBranchTaken != nullptr)
+		assert_dbg();
+	imlSegmentSrc->nextSegmentBranchTaken = imlSegmentDst;
+	// add as previous segment for destination
+	imlSegmentDst->list_prevSegments.push_back(imlSegmentSrc);
+}
+
+void IMLSegment_RemoveLink(IMLSegment* imlSegmentSrc, IMLSegment* imlSegmentDst)
+{
+	if (imlSegmentSrc->nextSegmentBranchNotTaken == imlSegmentDst)
+	{
+		imlSegmentSrc->nextSegmentBranchNotTaken = nullptr;
+	}
+	else if (imlSegmentSrc->nextSegmentBranchTaken == imlSegmentDst)
+	{
+		imlSegmentSrc->nextSegmentBranchTaken = nullptr;
+	}
+	else
+		assert_dbg();
+
+	bool matchFound = false;
+	for (sint32 i = 0; i < imlSegmentDst->list_prevSegments.size(); i++)
+	{
+		if (imlSegmentDst->list_prevSegments[i] == imlSegmentSrc)
+		{
+			imlSegmentDst->list_prevSegments.erase(imlSegmentDst->list_prevSegments.begin() + i);
+			matchFound = true;
+			break;
+		}
+	}
+	if (matchFound == false)
+		assert_dbg();
+}
+
+/*
+ * Replaces all links to segment orig with linkts to segment new
+ */
+void IMLSegment_RelinkInputSegment(IMLSegment* imlSegmentOrig, IMLSegment* imlSegmentNew)
+{
+	while (imlSegmentOrig->list_prevSegments.size() != 0)
+	{
+		IMLSegment* prevSegment = imlSegmentOrig->list_prevSegments[0];
+		if (prevSegment->nextSegmentBranchNotTaken == imlSegmentOrig)
+		{
+			IMLSegment_RemoveLink(prevSegment, imlSegmentOrig);
+			IMLSegment_SetLinkBranchNotTaken(prevSegment, imlSegmentNew);
+		}
+		else if (prevSegment->nextSegmentBranchTaken == imlSegmentOrig)
+		{
+			IMLSegment_RemoveLink(prevSegment, imlSegmentOrig);
+			IMLSegment_SetLinkBranchTaken(prevSegment, imlSegmentNew);
+		}
+		else
+		{
+			assert_dbg();
+		}
+	}
+}
diff --git a/src/Cafe/HW/Espresso/Recompiler/IML/IMLSegment.h b/src/Cafe/HW/Espresso/Recompiler/IML/IMLSegment.h
new file mode 100644
index 00000000..10e3dc06
--- /dev/null
+++ b/src/Cafe/HW/Espresso/Recompiler/IML/IMLSegment.h
@@ -0,0 +1,193 @@
+#pragma once
+#include "IMLInstruction.h"
+
+#include <boost/container/small_vector.hpp>
+
+// special values to mark the index of ranges that reach across the segment border
+#define RA_INTER_RANGE_START	(-1)
+#define RA_INTER_RANGE_END		(0x70000000)
+
+struct IMLSegmentPoint
+{
+	friend struct IMLSegmentInterval;
+
+	sint32 index;
+	struct IMLSegment* imlSegment; // do we really need to track this? SegmentPoints are always accessed via the segment that they are part of
+	IMLSegmentPoint* next;
+	IMLSegmentPoint* prev;
+
+	// the index is the instruction index times two.
+	// this gives us the ability to cover half an instruction with RA ranges
+	// covering only the first half of an instruction (0-0) means that the register is read, but not preserved
+	// covering first and the second half means the register is read and preserved
+	// covering only the second half means the register is written but not read
+
+	sint32 GetInstructionIndex() const
+	{
+		return index;
+	}
+
+	void SetInstructionIndex(sint32 index)
+	{
+		this->index = index;
+	}
+
+	void ShiftIfAfter(sint32 instructionIndex, sint32 shiftCount)
+	{
+		if (!IsPreviousSegment() && !IsNextSegment())
+		{
+			if (GetInstructionIndex() >= instructionIndex)
+				index += shiftCount;
+		}
+	}
+
+	void DecrementByOneInstruction()
+	{
+		index--;
+	}
+
+	// the segment point can point beyond the first and last instruction which indicates that it is an infinite range reaching up to the previous or next segment
+	bool IsPreviousSegment() const { return index == RA_INTER_RANGE_START; }
+	bool IsNextSegment() const { return index == RA_INTER_RANGE_END; }
+
+	// overload operand > and <
+	bool operator>(const IMLSegmentPoint& other) const { return index > other.index; }
+	bool operator<(const IMLSegmentPoint& other) const { return index < other.index; }
+	bool operator==(const IMLSegmentPoint& other) const { return index == other.index; }
+	bool operator!=(const IMLSegmentPoint& other) const { return index != other.index; }
+
+	// overload comparison operands for sint32
+	bool operator>(const sint32 other) const { return index > other; }
+	bool operator<(const sint32 other) const { return index < other; }
+	bool operator<=(const sint32 other) const { return index <= other; }
+	bool operator>=(const sint32 other) const { return index >= other; }
+};
+
+struct IMLSegmentInterval
+{
+	IMLSegmentPoint start;
+	IMLSegmentPoint end;
+
+	bool ContainsInstructionIndex(sint32 offset) const { return start <= offset && end > offset; }
+
+	bool IsRangeOverlapping(const IMLSegmentInterval& other)
+	{
+		// todo - compare the raw index
+		sint32 r1start = this->start.GetInstructionIndex();
+		sint32 r1end = this->end.GetInstructionIndex();
+		sint32 r2start = other.start.GetInstructionIndex();
+		sint32 r2end = other.end.GetInstructionIndex();
+		if (r1start < r2end && r1end > r2start)
+			return true;
+		if (this->start.IsPreviousSegment() && r1start == r2start)
+			return true;
+		if (this->end.IsNextSegment() && r1end == r2end)
+			return true;
+		return false;
+	}
+
+	bool ExtendsIntoPreviousSegment() const
+	{
+		return start.IsPreviousSegment();
+	}
+
+	bool ExtendsIntoNextSegment() const
+	{
+		return end.IsNextSegment();
+	}
+
+	bool IsNextSegmentOnly() const
+	{
+		if(!start.IsNextSegment())
+			return false;
+		cemu_assert_debug(end.IsNextSegment());
+		return true;
+	}
+
+	bool IsPreviousSegmentOnly() const
+	{
+		if (!end.IsPreviousSegment())
+			return false;
+		cemu_assert_debug(start.IsPreviousSegment());
+		return true;
+	}
+
+	sint32 GetDistance() const
+	{
+		// todo - assert if either start or end is outside the segment
+		// we may also want to switch this to raw indices?
+		return end.GetInstructionIndex() - start.GetInstructionIndex();
+	}
+};
+
+struct PPCSegmentRegisterAllocatorInfo_t
+{
+	// used during loop detection
+	bool isPartOfProcessedLoop{}; 
+	sint32 lastIterationIndex{};
+	// linked lists
+	struct raLivenessRange* linkedList_allSubranges{};
+	std::unordered_map<IMLRegID, struct raLivenessRange*> linkedList_perVirtualRegister;
+};
+
+struct IMLSegment
+{
+	sint32 momentaryIndex{}; // index in segment list, generally not kept up to date except if needed (necessary for loop detection)
+	sint32 loopDepth{};
+	uint32 ppcAddress{}; // ppc address (0xFFFFFFFF if not associated with an address)
+	uint32 x64Offset{}; // x64 code offset of segment start
+	// list of intermediate instructions in this segment
+	std::vector<IMLInstruction> imlList;
+	// segment link
+	IMLSegment* nextSegmentBranchNotTaken{}; // this is also the default for segments where there is no branch
+	IMLSegment* nextSegmentBranchTaken{};
+	bool nextSegmentIsUncertain{};
+	std::vector<IMLSegment*> list_prevSegments{};
+	// source for overwrite analysis (if nextSegmentIsUncertain is true)
+	// sometimes a segment is marked as an exit point, but for the purposes of dead code elimination we know the next segment
+	IMLSegment* deadCodeEliminationHintSeg{};
+	std::vector<IMLSegment*> list_deadCodeHintBy{};
+	// enterable segments
+	bool isEnterable{}; // this segment can be entered from outside the recompiler (no preloaded registers necessary)
+	uint32 enterPPCAddress{}; // used if isEnterable is true
+	// register allocator info
+	PPCSegmentRegisterAllocatorInfo_t raInfo{};
+	// segment state API
+	void SetEnterable(uint32 enterAddress);
+	void SetLinkBranchNotTaken(IMLSegment* imlSegmentDst);
+	void SetLinkBranchTaken(IMLSegment* imlSegmentDst);
+
+	IMLSegment* GetBranchTaken()
+	{
+		return nextSegmentBranchTaken;
+	}
+
+	IMLSegment* GetBranchNotTaken()
+	{
+		return nextSegmentBranchNotTaken;
+	}
+
+	void SetNextSegmentForOverwriteHints(IMLSegment* seg)
+	{
+		cemu_assert_debug(!deadCodeEliminationHintSeg);
+		deadCodeEliminationHintSeg = seg;
+		if (seg)
+			seg->list_deadCodeHintBy.push_back(this);
+	}
+
+	// instruction API
+	IMLInstruction* AppendInstruction();
+
+	bool HasSuffixInstruction() const;
+	sint32 GetSuffixInstructionIndex() const;
+	IMLInstruction* GetLastInstruction();
+
+	// segment points
+	IMLSegmentPoint* segmentPointList{};
+};
+
+
+void IMLSegment_SetLinkBranchNotTaken(IMLSegment* imlSegmentSrc, IMLSegment* imlSegmentDst);
+void IMLSegment_SetLinkBranchTaken(IMLSegment* imlSegmentSrc, IMLSegment* imlSegmentDst);
+void IMLSegment_RelinkInputSegment(IMLSegment* imlSegmentOrig, IMLSegment* imlSegmentNew);
+void IMLSegment_RemoveLink(IMLSegment* imlSegmentSrc, IMLSegment* imlSegmentDst);
diff --git a/src/Cafe/HW/Espresso/Recompiler/PPCFunctionBoundaryTracker.h b/src/Cafe/HW/Espresso/Recompiler/PPCFunctionBoundaryTracker.h
index 3fc48a93..96b5143e 100644
--- a/src/Cafe/HW/Espresso/Recompiler/PPCFunctionBoundaryTracker.h
+++ b/src/Cafe/HW/Espresso/Recompiler/PPCFunctionBoundaryTracker.h
@@ -10,7 +10,7 @@ class PPCFunctionBoundaryTracker
 public:
 	struct PPCRange_t
 	{
-		PPCRange_t() {};
+		PPCRange_t() = default;
 		PPCRange_t(uint32 _startAddress) : startAddress(_startAddress) {};
 
 		uint32 startAddress{};
@@ -21,6 +21,16 @@ public:
 	};
 
 public:
+	~PPCFunctionBoundaryTracker()
+	{
+		while (!map_ranges.empty())
+		{
+			PPCRange_t* range = *map_ranges.begin();
+			delete range;
+			map_ranges.erase(map_ranges.begin());
+		}
+	}
+
 	void trackStartPoint(MPTR startAddress)
 	{
 		processRange(startAddress, nullptr, nullptr);
@@ -40,10 +50,34 @@ public:
 		return false;
 	}
 
+	std::vector<PPCRange_t> GetRanges()
+	{
+		std::vector<PPCRange_t> r;
+		for (auto& it : map_ranges)
+			r.emplace_back(*it);
+		return r;
+	}
+
+	bool ContainsAddress(uint32 addr) const
+	{
+		for (auto& it : map_ranges)
+		{
+			if (addr >= it->startAddress && addr < it->getEndAddress())
+				return true;
+		}
+		return false;
+	}
+
+	const std::set<uint32>& GetBranchTargets() const
+	{
+		return map_branchTargetsAll;
+	}
+
 private:
 	void addBranchDestination(PPCRange_t* sourceRange, MPTR address)
 	{
-		map_branchTargets.emplace(address);
+		map_queuedBranchTargets.emplace(address);
+		map_branchTargetsAll.emplace(address);
 	}
 
 	// process flow of instruction
@@ -114,7 +148,7 @@ private:
 				Espresso::BOField BO;
 				uint32 BI;
 				bool LK;
-				Espresso::decodeOp_BCLR(opcode, BO, BI, LK);
+				Espresso::decodeOp_BCSPR(opcode, BO, BI, LK);
 				if (BO.branchAlways() && !LK)
 				{
 					// unconditional BLR
@@ -153,7 +187,7 @@ private:
 
 	void checkForCollisions()
 	{
-#ifndef PUBLIC_RELEASE
+#ifdef CEMU_DEBUG_ASSERT
 		uint32 endOfPrevious = 0;
 		for (auto itr : map_ranges)
 		{
@@ -218,7 +252,7 @@ private:
 		auto rangeItr = map_ranges.begin();
 
 		PPCRange_t* previousRange = nullptr;
-		for (std::set<uint32_t>::const_iterator targetItr = map_branchTargets.begin() ; targetItr != map_branchTargets.end(); )
+		for (std::set<uint32_t>::const_iterator targetItr = map_queuedBranchTargets.begin() ; targetItr != map_queuedBranchTargets.end(); )
 		{
 			while (rangeItr != map_ranges.end() && ((*rangeItr)->startAddress + (*rangeItr)->length) <= (*targetItr))
 			{
@@ -239,7 +273,7 @@ private:
 				(*targetItr) < ((*rangeItr)->startAddress + (*rangeItr)->length))
 			{
 				// delete visited targets
-				targetItr = map_branchTargets.erase(targetItr);
+				targetItr = map_queuedBranchTargets.erase(targetItr);
 				continue;
 			}
 
@@ -289,5 +323,6 @@ private:
 	};
 
 	std::set<PPCRange_t*, RangePtrCmp> map_ranges;
-	std::set<uint32> map_branchTargets;
+	std::set<uint32> map_queuedBranchTargets;
+	std::set<uint32> map_branchTargetsAll;
 };
\ No newline at end of file
diff --git a/src/Cafe/HW/Espresso/Recompiler/PPCRecompiler.cpp b/src/Cafe/HW/Espresso/Recompiler/PPCRecompiler.cpp
index 61aa11ca..6125c7da 100644
--- a/src/Cafe/HW/Espresso/Recompiler/PPCRecompiler.cpp
+++ b/src/Cafe/HW/Espresso/Recompiler/PPCRecompiler.cpp
@@ -2,19 +2,28 @@
 #include "PPCFunctionBoundaryTracker.h"
 #include "PPCRecompiler.h"
 #include "PPCRecompilerIml.h"
-#include "PPCRecompilerX64.h"
 #include "Cafe/OS/RPL/rpl.h"
 #include "util/containers/RangeStore.h"
 #include "Cafe/OS/libs/coreinit/coreinit_CodeGen.h"
 #include "config/ActiveSettings.h"
 #include "config/LaunchSettings.h"
-
-#include "util/helpers/fspinlock.h"
 #include "Common/ExceptionHandler/ExceptionHandler.h"
+#include "Common/cpu_features.h"
+#include "util/helpers/fspinlock.h"
 #include "util/helpers/helpers.h"
-
 #include "util/MemMapper/MemMapper.h"
 
+#include "IML/IML.h"
+#include "IML/IMLRegisterAllocator.h"
+#include "BackendX64/BackendX64.h"
+#ifdef __aarch64__
+#include "BackendAArch64/BackendAArch64.h"
+#endif
+#include "util/highresolutiontimer/HighResolutionTimer.h"
+
+#define PPCREC_FORCE_SYNCHRONOUS_COMPILATION	0 // if 1, then function recompilation will block and execute on the thread that called PPCRecompiler_visitAddressNoBlock
+#define PPCREC_LOG_RECOMPILATION_RESULTS		0
+
 struct PPCInvalidationRange
 {
 	MPTR startAddress;
@@ -38,29 +47,54 @@ void ATTR_MS_ABI (*PPCRecompiler_leaveRecompilerCode_unvisited)();
 
 PPCRecompilerInstanceData_t* ppcRecompilerInstanceData;
 
+#if PPCREC_FORCE_SYNCHRONOUS_COMPILATION
+static std::mutex s_singleRecompilationMutex;
+#endif
+
 bool ppcRecompilerEnabled = false;
 
+void PPCRecompiler_recompileAtAddress(uint32 address);
+
 // this function does never block and can fail if the recompiler lock cannot be acquired immediately
 void PPCRecompiler_visitAddressNoBlock(uint32 enterAddress)
 {
+#if PPCREC_FORCE_SYNCHRONOUS_COMPILATION
+	if (ppcRecompilerInstanceData->ppcRecompilerDirectJumpTable[enterAddress / 4] != PPCRecompiler_leaveRecompilerCode_unvisited)
+		return;
+	PPCRecompilerState.recompilerSpinlock.lock();
+	if (ppcRecompilerInstanceData->ppcRecompilerDirectJumpTable[enterAddress / 4] != PPCRecompiler_leaveRecompilerCode_unvisited)
+	{
+		PPCRecompilerState.recompilerSpinlock.unlock();
+		return;
+	}
+	ppcRecompilerInstanceData->ppcRecompilerDirectJumpTable[enterAddress / 4] = PPCRecompiler_leaveRecompilerCode_visited;
+	PPCRecompilerState.recompilerSpinlock.unlock();
+	s_singleRecompilationMutex.lock();
+	if (ppcRecompilerInstanceData->ppcRecompilerDirectJumpTable[enterAddress / 4] == PPCRecompiler_leaveRecompilerCode_visited)
+	{
+		PPCRecompiler_recompileAtAddress(enterAddress);
+	}
+	s_singleRecompilationMutex.unlock();
+	return;
+#endif
 	// quick read-only check without lock
 	if (ppcRecompilerInstanceData->ppcRecompilerDirectJumpTable[enterAddress / 4] != PPCRecompiler_leaveRecompilerCode_unvisited)
 		return;
 	// try to acquire lock
-	if (!PPCRecompilerState.recompilerSpinlock.tryAcquire())
+	if (!PPCRecompilerState.recompilerSpinlock.try_lock())
 		return;
 	auto funcPtr = ppcRecompilerInstanceData->ppcRecompilerDirectJumpTable[enterAddress / 4];
 	if (funcPtr != PPCRecompiler_leaveRecompilerCode_unvisited)
 	{
 		// was visited since previous check
-		PPCRecompilerState.recompilerSpinlock.release();
+		PPCRecompilerState.recompilerSpinlock.unlock();
 		return;
 	}
 	// add to recompilation queue and flag as visited
 	PPCRecompilerState.targetQueue.emplace(enterAddress);
 	ppcRecompilerInstanceData->ppcRecompilerDirectJumpTable[enterAddress / 4] = PPCRecompiler_leaveRecompilerCode_visited;
 
-	PPCRecompilerState.recompilerSpinlock.release();
+	PPCRecompilerState.recompilerSpinlock.unlock();
 }
 
 void PPCRecompiler_recompileIfUnvisited(uint32 enterAddress)
@@ -78,12 +112,12 @@ void PPCRecompiler_enter(PPCInterpreter_t* hCPU, PPCREC_JUMP_ENTRY funcPtr)
 	PPCRecompiler_enterRecompilerCode((uint64)funcPtr, (uint64)hCPU);
 	_controlfp(prevState, _MCW_RC);
 	// debug recompiler exit - useful to find frequently executed functions which couldn't be recompiled
-	#ifndef PUBLIC_RELEASE
+	#ifdef CEMU_DEBUG_ASSERT
 	if (hCPU->remainingCycles > 0 && GetAsyncKeyState(VK_F4))
 	{
 		auto t = std::chrono::high_resolution_clock::now();
 		auto dur = std::chrono::duration_cast<std::chrono::microseconds>(t.time_since_epoch()).count();
-		forceLog_printf("Recompiler exit: 0x%08x LR: 0x%08x Timestamp %lld.%04lld", hCPU->instructionPointer, hCPU->spr.LR, dur / 1000LL, (dur % 1000LL));
+		cemuLog_log(LogType::Force, "Recompiler exit: 0x{:08x} LR: 0x{:08x} Timestamp {}.{:04}", hCPU->instructionPointer, hCPU->spr.LR, dur / 1000LL, (dur % 1000LL));
 	}
 	#endif
 #else
@@ -128,15 +162,15 @@ void PPCRecompiler_attemptEnter(PPCInterpreter_t* hCPU, uint32 enterAddress)
 		PPCRecompiler_enter(hCPU, funcPtr);
 	}
 }
+bool PPCRecompiler_ApplyIMLPasses(ppcImlGenContext_t& ppcImlGenContext);
 
-PPCRecFunction_t* PPCRecompiler_recompileFunction(PPCFunctionBoundaryTracker::PPCRange_t range, std::set<uint32>& entryAddresses, std::vector<std::pair<MPTR, uint32>>& entryPointsOut)
+PPCRecFunction_t* PPCRecompiler_recompileFunction(PPCFunctionBoundaryTracker::PPCRange_t range, std::set<uint32>& entryAddresses, std::vector<std::pair<MPTR, uint32>>& entryPointsOut, PPCFunctionBoundaryTracker& boundaryTracker)
 {
 	if (range.startAddress >= PPC_REC_CODE_AREA_END)
 	{
-		cemuLog_force("Attempting to recompile function outside of allowed code area");
+		cemuLog_log(LogType::Force, "Attempting to recompile function outside of allowed code area");
 		return nullptr;
 	}
-
 	uint32 codeGenRangeStart;
 	uint32 codeGenRangeSize = 0;
 	coreinit::OSGetCodegenVirtAddrRangeInternal(codeGenRangeStart, codeGenRangeSize);
@@ -154,29 +188,69 @@ PPCRecFunction_t* PPCRecompiler_recompileFunction(PPCFunctionBoundaryTracker::PP
 	PPCRecFunction_t* ppcRecFunc = new PPCRecFunction_t();
 	ppcRecFunc->ppcAddress = range.startAddress;
 	ppcRecFunc->ppcSize = range.length;
+
+#if PPCREC_LOG_RECOMPILATION_RESULTS
+	BenchmarkTimer bt;
+	bt.Start();
+#endif
+
 	// generate intermediate code
 	ppcImlGenContext_t ppcImlGenContext = { 0 };
-	bool compiledSuccessfully = PPCRecompiler_generateIntermediateCode(ppcImlGenContext, ppcRecFunc, entryAddresses);
+	ppcImlGenContext.debug_entryPPCAddress = range.startAddress;
+	bool compiledSuccessfully = PPCRecompiler_generateIntermediateCode(ppcImlGenContext, ppcRecFunc, entryAddresses, boundaryTracker);
 	if (compiledSuccessfully == false)
 	{
-		// todo: Free everything
-		PPCRecompiler_freeContext(&ppcImlGenContext);
 		delete ppcRecFunc;
-		return NULL;
+		return nullptr;
 	}
+
+	uint32 ppcRecLowerAddr = LaunchSettings::GetPPCRecLowerAddr();
+	uint32 ppcRecUpperAddr = LaunchSettings::GetPPCRecUpperAddr();
+
+	if (ppcRecLowerAddr != 0 && ppcRecUpperAddr != 0)
+	{
+		if (ppcRecFunc->ppcAddress < ppcRecLowerAddr || ppcRecFunc->ppcAddress > ppcRecUpperAddr)
+		{
+			delete ppcRecFunc;
+			return nullptr;
+		}
+	}
+
+	// apply passes
+	if (!PPCRecompiler_ApplyIMLPasses(ppcImlGenContext))
+	{
+		delete ppcRecFunc;
+		return nullptr;
+	}
+
+#if defined(ARCH_X86_64)
 	// emit x64 code
 	bool x64GenerationSuccess = PPCRecompiler_generateX64Code(ppcRecFunc, &ppcImlGenContext);
 	if (x64GenerationSuccess == false)
 	{
-		PPCRecompiler_freeContext(&ppcImlGenContext);
 		return nullptr;
 	}
+#elif defined(__aarch64__)
+	bool aarch64GenerationSuccess = PPCRecompiler_generateAArch64Code(ppcRecFunc, &ppcImlGenContext);
+	if (aarch64GenerationSuccess == false)
+	{
+		return nullptr;
+	}
+#endif
+	if (ActiveSettings::DumpRecompilerFunctionsEnabled())
+	{
+		FileStream* fs = FileStream::createFile2(ActiveSettings::GetUserDataPath(fmt::format("dump/recompiler/ppc_{:08x}.bin", ppcRecFunc->ppcAddress)));
+		if (fs)
+		{
+			fs->writeData(ppcRecFunc->x86Code, ppcRecFunc->x86Size);
+			delete fs;
+		}
+	}
 
 	// collect list of PPC-->x64 entry points
 	entryPointsOut.clear();
-	for (sint32 s = 0; s < ppcImlGenContext.segmentListCount; s++)
+	for(IMLSegment* imlSegment : ppcImlGenContext.segmentList2)
 	{
-		PPCRecImlSegment_t* imlSegment = ppcImlGenContext.segmentList[s];
 		if (imlSegment->isEnterable == false)
 			continue;
 
@@ -186,24 +260,108 @@ PPCRecFunction_t* PPCRecompiler_recompileFunction(PPCFunctionBoundaryTracker::PP
 		entryPointsOut.emplace_back(ppcEnterOffset, x64Offset);
 	}
 
-	PPCRecompiler_freeContext(&ppcImlGenContext);
+#if PPCREC_LOG_RECOMPILATION_RESULTS
+	bt.Stop();
+	uint32 codeHash = 0;
+	for (uint32 i = 0; i < ppcRecFunc->x86Size; i++)
+	{
+		codeHash = _rotr(codeHash, 3);
+		codeHash += ((uint8*)ppcRecFunc->x86Code)[i];
+	}
+	cemuLog_log(LogType::Force, "[Recompiler] PPC 0x{:08x} -> x64: 0x{:x} Took {:.4}ms | Size {:04x} CodeHash {:08x}", (uint32)ppcRecFunc->ppcAddress, (uint64)(uintptr_t)ppcRecFunc->x86Code, bt.GetElapsedMilliseconds(), ppcRecFunc->x86Size, codeHash);
+#endif
+
 	return ppcRecFunc;
 }
 
+void PPCRecompiler_NativeRegisterAllocatorPass(ppcImlGenContext_t& ppcImlGenContext)
+{
+	IMLRegisterAllocatorParameters raParam;
+
+	for (auto& it : ppcImlGenContext.mappedRegs)
+		raParam.regIdToName.try_emplace(it.second.GetRegID(), it.first);
+
+#if defined(ARCH_X86_64)
+	auto& gprPhysPool = raParam.GetPhysRegPool(IMLRegFormat::I64);
+	gprPhysPool.SetAvailable(IMLArchX86::PHYSREG_GPR_BASE + X86_REG_RAX);
+	gprPhysPool.SetAvailable(IMLArchX86::PHYSREG_GPR_BASE + X86_REG_RDX);
+	gprPhysPool.SetAvailable(IMLArchX86::PHYSREG_GPR_BASE + X86_REG_RBX);
+	gprPhysPool.SetAvailable(IMLArchX86::PHYSREG_GPR_BASE + X86_REG_RBP);
+	gprPhysPool.SetAvailable(IMLArchX86::PHYSREG_GPR_BASE + X86_REG_RSI);
+	gprPhysPool.SetAvailable(IMLArchX86::PHYSREG_GPR_BASE + X86_REG_RDI);
+	gprPhysPool.SetAvailable(IMLArchX86::PHYSREG_GPR_BASE + X86_REG_R8);
+	gprPhysPool.SetAvailable(IMLArchX86::PHYSREG_GPR_BASE + X86_REG_R9);
+	gprPhysPool.SetAvailable(IMLArchX86::PHYSREG_GPR_BASE + X86_REG_R10);
+	gprPhysPool.SetAvailable(IMLArchX86::PHYSREG_GPR_BASE + X86_REG_R11);
+	gprPhysPool.SetAvailable(IMLArchX86::PHYSREG_GPR_BASE + X86_REG_R12);
+	gprPhysPool.SetAvailable(IMLArchX86::PHYSREG_GPR_BASE + X86_REG_RCX);
+
+	// add XMM registers, except XMM15 which is the temporary register
+	auto& fprPhysPool = raParam.GetPhysRegPool(IMLRegFormat::F64);
+	fprPhysPool.SetAvailable(IMLArchX86::PHYSREG_FPR_BASE + 0);
+	fprPhysPool.SetAvailable(IMLArchX86::PHYSREG_FPR_BASE + 1);
+	fprPhysPool.SetAvailable(IMLArchX86::PHYSREG_FPR_BASE + 2);
+	fprPhysPool.SetAvailable(IMLArchX86::PHYSREG_FPR_BASE + 3);
+	fprPhysPool.SetAvailable(IMLArchX86::PHYSREG_FPR_BASE + 4);
+	fprPhysPool.SetAvailable(IMLArchX86::PHYSREG_FPR_BASE + 5);
+	fprPhysPool.SetAvailable(IMLArchX86::PHYSREG_FPR_BASE + 6);
+	fprPhysPool.SetAvailable(IMLArchX86::PHYSREG_FPR_BASE + 7);
+	fprPhysPool.SetAvailable(IMLArchX86::PHYSREG_FPR_BASE + 8);
+	fprPhysPool.SetAvailable(IMLArchX86::PHYSREG_FPR_BASE + 9);
+	fprPhysPool.SetAvailable(IMLArchX86::PHYSREG_FPR_BASE + 10);
+	fprPhysPool.SetAvailable(IMLArchX86::PHYSREG_FPR_BASE + 11);
+	fprPhysPool.SetAvailable(IMLArchX86::PHYSREG_FPR_BASE + 12);
+	fprPhysPool.SetAvailable(IMLArchX86::PHYSREG_FPR_BASE + 13);
+	fprPhysPool.SetAvailable(IMLArchX86::PHYSREG_FPR_BASE + 14);
+#elif defined(__aarch64__)
+	auto& gprPhysPool = raParam.GetPhysRegPool(IMLRegFormat::I64);
+	for (auto i = IMLArchAArch64::PHYSREG_GPR_BASE; i < IMLArchAArch64::PHYSREG_GPR_BASE + IMLArchAArch64::PHYSREG_GPR_COUNT; i++)
+	{
+		if (i == IMLArchAArch64::PHYSREG_GPR_BASE + 18)
+			continue; // Skip reserved platform register
+		gprPhysPool.SetAvailable(i);
+	}
+
+	auto& fprPhysPool = raParam.GetPhysRegPool(IMLRegFormat::F64);
+	for (auto i = IMLArchAArch64::PHYSREG_FPR_BASE; i < IMLArchAArch64::PHYSREG_FPR_BASE + IMLArchAArch64::PHYSREG_FPR_COUNT; i++)
+		fprPhysPool.SetAvailable(i);
+#endif
+
+	IMLRegisterAllocator_AllocateRegisters(&ppcImlGenContext, raParam);
+}
+
+bool PPCRecompiler_ApplyIMLPasses(ppcImlGenContext_t& ppcImlGenContext)
+{
+	// isolate entry points from function flow (enterable segments must not be the target of any other segment)
+	// this simplifies logic during register allocation
+	PPCRecompilerIML_isolateEnterableSegments(&ppcImlGenContext);
+
+	// merge certain float load+store patterns
+	IMLOptimizer_OptimizeDirectFloatCopies(&ppcImlGenContext);
+	// delay byte swapping for certain load+store patterns
+	IMLOptimizer_OptimizeDirectIntegerCopies(&ppcImlGenContext);
+
+	IMLOptimizer_StandardOptimizationPass(ppcImlGenContext);
+
+	PPCRecompiler_NativeRegisterAllocatorPass(ppcImlGenContext);
+
+	return true;
+}
+
 bool PPCRecompiler_makeRecompiledFunctionActive(uint32 initialEntryPoint, PPCFunctionBoundaryTracker::PPCRange_t& range, PPCRecFunction_t* ppcRecFunc, std::vector<std::pair<MPTR, uint32>>& entryPoints)
 {
 	// update jump table
-	PPCRecompilerState.recompilerSpinlock.acquire();
+	PPCRecompilerState.recompilerSpinlock.lock();
 
 	// check if the initial entrypoint is still flagged for recompilation
 	// its possible that the range has been invalidated during the time it took to translate the function
 	if (ppcRecompilerInstanceData->ppcRecompilerDirectJumpTable[initialEntryPoint / 4] != PPCRecompiler_leaveRecompilerCode_visited)
 	{
-		PPCRecompilerState.recompilerSpinlock.release();
+		PPCRecompilerState.recompilerSpinlock.unlock();
 		return false;
 	}
 
-	// check if the current range got invalidated in the time it took to recompile it
+	// check if the current range got invalidated during the time it took to recompile it
 	bool isInvalidated = false;
 	for (auto& invRange : PPCRecompilerState.invalidationRanges)
 	{
@@ -221,7 +379,7 @@ bool PPCRecompiler_makeRecompiledFunctionActive(uint32 initialEntryPoint, PPCFun
 	PPCRecompilerState.invalidationRanges.clear();
 	if (isInvalidated)
 	{
-		PPCRecompilerState.recompilerSpinlock.release();
+		PPCRecompilerState.recompilerSpinlock.unlock();
 		return false;
 	}
 
@@ -249,7 +407,7 @@ bool PPCRecompiler_makeRecompiledFunctionActive(uint32 initialEntryPoint, PPCFun
 	{
 		r.storedRange = rangeStore_ppcRanges.storeRange(ppcRecFunc, r.ppcAddress, r.ppcAddress + r.ppcSize);
 	}
-	PPCRecompilerState.recompilerSpinlock.release();
+	PPCRecompilerState.recompilerSpinlock.unlock();
 
 
 	return true;
@@ -272,16 +430,16 @@ void PPCRecompiler_recompileAtAddress(uint32 address)
 	// todo - use info from previously compiled ranges to determine full size of this function (and merge all the entryAddresses)
 
 	// collect all currently known entry points for this range
-	PPCRecompilerState.recompilerSpinlock.acquire();
+	PPCRecompilerState.recompilerSpinlock.lock();
 
 	std::set<uint32> entryAddresses;
 
 	entryAddresses.emplace(address);
 
-	PPCRecompilerState.recompilerSpinlock.release();
+	PPCRecompilerState.recompilerSpinlock.unlock();
 
 	std::vector<std::pair<MPTR, uint32>> functionEntryPoints;
-	auto func = PPCRecompiler_recompileFunction(range, entryAddresses, functionEntryPoints);
+	auto func = PPCRecompiler_recompileFunction(range, entryAddresses, functionEntryPoints, funcBoundaries);
 
 	if (!func)
 	{
@@ -290,11 +448,20 @@ void PPCRecompiler_recompileAtAddress(uint32 address)
 	bool r = PPCRecompiler_makeRecompiledFunctionActive(address, range, func, functionEntryPoints);
 }
 
+std::thread s_threadRecompiler;
+std::atomic_bool s_recompilerThreadStopSignal{false};
+
 void PPCRecompiler_thread()
 {
-	SetThreadName("PPCRecompiler_thread");
+	SetThreadName("PPCRecompiler");
+#if PPCREC_FORCE_SYNCHRONOUS_COMPILATION
+	return;
+#endif
+
 	while (true)
 	{
+        if(s_recompilerThreadStopSignal)
+            return;
 		std::this_thread::sleep_for(std::chrono::milliseconds(10));
 		// asynchronous recompilation:
 		// 1) take address from queue
@@ -302,10 +469,10 @@ void PPCRecompiler_thread()
 		// 3) if yes -> calculate size, gather all entry points, recompile and update jump table
 		while (true)
 		{
-			PPCRecompilerState.recompilerSpinlock.acquire();
+			PPCRecompilerState.recompilerSpinlock.lock();
 			if (PPCRecompilerState.targetQueue.empty())
 			{
-				PPCRecompilerState.recompilerSpinlock.release();
+				PPCRecompilerState.recompilerSpinlock.unlock();
 				break;
 			}
 			auto enterAddress = PPCRecompilerState.targetQueue.front();
@@ -315,19 +482,26 @@ void PPCRecompiler_thread()
 			if (funcPtr != PPCRecompiler_leaveRecompilerCode_visited)
 			{
 				// only recompile functions if marked as visited
-				PPCRecompilerState.recompilerSpinlock.release();
+				PPCRecompilerState.recompilerSpinlock.unlock();
 				continue;
 			}
-			PPCRecompilerState.recompilerSpinlock.release();
+			PPCRecompilerState.recompilerSpinlock.unlock();
 
 			PPCRecompiler_recompileAtAddress(enterAddress);
+			if(s_recompilerThreadStopSignal)
+				return;
 		}
 	}
 }
 
 #define PPC_REC_ALLOC_BLOCK_SIZE	(4*1024*1024) // 4MB
 
-std::bitset<(MEMORY_CODEAREA_ADDR + MEMORY_CODEAREA_SIZE) / PPC_REC_ALLOC_BLOCK_SIZE> ppcRecompiler_reservedBlockMask;
+constexpr uint32 PPCRecompiler_GetNumAddressSpaceBlocks()
+{
+    return (MEMORY_CODEAREA_ADDR + MEMORY_CODEAREA_SIZE + PPC_REC_ALLOC_BLOCK_SIZE - 1) / PPC_REC_ALLOC_BLOCK_SIZE;
+}
+
+std::bitset<PPCRecompiler_GetNumAddressSpaceBlocks()> ppcRecompiler_reservedBlockMask;
 
 void PPCRecompiler_reserveLookupTableBlock(uint32 offset)
 {
@@ -342,7 +516,7 @@ void PPCRecompiler_reserveLookupTableBlock(uint32 offset)
 	void* p3 = MemMapper::AllocateMemory(&(ppcRecompilerInstanceData->ppcRecompilerDirectJumpTable[offset/4]), (PPC_REC_ALLOC_BLOCK_SIZE/4)*sizeof(void*), MemMapper::PAGE_PERMISSION::P_RW, true);
 	if( !p1 || !p3 )
 	{
-		forceLog_printf("Failed to allocate memory for recompiler (0x%08x)", offset);
+		cemuLog_log(LogType::Force, "Failed to allocate memory for recompiler (0x{:08x})", offset);
 		cemu_assert(false);
 		return;
 	}
@@ -376,7 +550,7 @@ struct ppcRecompilerFuncRange_t
 
 bool PPCRecompiler_findFuncRanges(uint32 addr, ppcRecompilerFuncRange_t* rangesOut, size_t* countInOut)
 {
-	PPCRecompilerState.recompilerSpinlock.acquire();
+	PPCRecompilerState.recompilerSpinlock.lock();
 	size_t countIn = *countInOut;
 	size_t countOut = 0;
 
@@ -392,7 +566,7 @@ bool PPCRecompiler_findFuncRanges(uint32 addr, ppcRecompilerFuncRange_t* rangesO
 		countOut++;
 	}
 	);
-	PPCRecompilerState.recompilerSpinlock.release();
+	PPCRecompilerState.recompilerSpinlock.unlock();
 	*countInOut = countOut;
 	if (countOut > countIn)
 		return false;
@@ -420,7 +594,7 @@ void PPCRecompiler_invalidateTableRange(uint32 offset, uint32 size)
 void PPCRecompiler_deleteFunction(PPCRecFunction_t* func)
 {
 	// assumes PPCRecompilerState.recompilerSpinlock is already held
-	cemu_assert_debug(PPCRecompilerState.recompilerSpinlock.isHolding());
+	cemu_assert_debug(PPCRecompilerState.recompilerSpinlock.is_locked());
 	for (auto& r : func->list_ranges)
 	{
 		PPCRecompiler_invalidateTableRange(r.ppcAddress, r.ppcSize);
@@ -439,7 +613,7 @@ void PPCRecompiler_invalidateRange(uint32 startAddr, uint32 endAddr)
 		return;
 	cemu_assert_debug(endAddr >= startAddr);
 
-	PPCRecompilerState.recompilerSpinlock.acquire();
+	PPCRecompilerState.recompilerSpinlock.lock();
 
 	uint32 rStart;
 	uint32 rEnd;
@@ -458,43 +632,12 @@ void PPCRecompiler_invalidateRange(uint32 startAddr, uint32 endAddr)
 		PPCRecompiler_deleteFunction(rFunc);
 	}
 
-	PPCRecompilerState.recompilerSpinlock.release();
+	PPCRecompilerState.recompilerSpinlock.unlock();
 }
 
-void PPCRecompiler_init()
+#if defined(ARCH_X86_64)
+void PPCRecompiler_initPlatform()
 {
-	if (ActiveSettings::GetCPUMode() == CPUMode::SinglecoreInterpreter)
-	{
-		ppcRecompilerEnabled = false;
-		return;
-	}
-	if (LaunchSettings::ForceInterpreter())
-	{
-		cemuLog_log(LogType::Force, "Recompiler disabled. Command line --force-interpreter was passed");
-		return;
-	}
-	if (ppcRecompilerInstanceData)
-	{
-		MemMapper::FreeReservation(ppcRecompilerInstanceData, sizeof(PPCRecompilerInstanceData_t));
-		ppcRecompilerInstanceData = nullptr;
-	}
-	debug_printf("Allocating %dMB for recompiler instance data...\n", (sint32)(sizeof(PPCRecompilerInstanceData_t) / 1024 / 1024));
-	ppcRecompilerInstanceData = (PPCRecompilerInstanceData_t*)MemMapper::ReserveMemory(nullptr, sizeof(PPCRecompilerInstanceData_t), MemMapper::PAGE_PERMISSION::P_RW);
-	MemMapper::AllocateMemory(&(ppcRecompilerInstanceData->_x64XMM_xorNegateMaskBottom), sizeof(PPCRecompilerInstanceData_t) - offsetof(PPCRecompilerInstanceData_t, _x64XMM_xorNegateMaskBottom), MemMapper::PAGE_PERMISSION::P_RW, true);
-	PPCRecompilerX64Gen_generateRecompilerInterfaceFunctions();
-
-	uint32 codeRegionEnd = RPLLoader_GetMaxCodeOffset();
-	codeRegionEnd = (codeRegionEnd + PPC_REC_ALLOC_BLOCK_SIZE - 1) & ~(PPC_REC_ALLOC_BLOCK_SIZE - 1);
-
-	uint32 codeRegionSize = codeRegionEnd - PPC_REC_CODE_AREA_START;
-	forceLogDebug_printf("Allocating recompiler tables for range 0x%08x-0x%08x", PPC_REC_CODE_AREA_START, codeRegionEnd);
-
-	for (uint32 i = 0; i < codeRegionSize; i += PPC_REC_ALLOC_BLOCK_SIZE)
-	{
-		PPCRecompiler_reserveLookupTableBlock(i);
-	}
-
-	// init x64 recompiler instance data
 	ppcRecompilerInstanceData->_x64XMM_xorNegateMaskBottom[0] = 1ULL << 63ULL;
 	ppcRecompilerInstanceData->_x64XMM_xorNegateMaskBottom[1] = 0ULL;
 	ppcRecompilerInstanceData->_x64XMM_xorNegateMaskPair[0] = 1ULL << 63ULL;
@@ -530,64 +673,80 @@ void PPCRecompiler_init()
 	ppcRecompilerInstanceData->_x64XMM_flushDenormalMaskResetSignBits[2] = ~0x80000000;
 	ppcRecompilerInstanceData->_x64XMM_flushDenormalMaskResetSignBits[3] = ~0x80000000;
 
-	// setup GQR scale tables
-
-	for (uint32 i = 0; i < 32; i++)
-	{
-		float a = 1.0f / (float)(1u << i);
-		float b = 0;
-		if (i == 0)
-			b = 4294967296.0f;
-		else
-			b = (float)(1u << (32u - i));
-
-		float ar = (float)(1u << i);
-		float br = 0;
-		if (i == 0)
-			br = 1.0f / 4294967296.0f;
-		else
-			br = 1.0f / (float)(1u << (32u - i));
-
-		ppcRecompilerInstanceData->_psq_ld_scale_ps0_1[i * 2 + 0] = a;
-		ppcRecompilerInstanceData->_psq_ld_scale_ps0_1[i * 2 + 1] = 1.0f;
-		ppcRecompilerInstanceData->_psq_ld_scale_ps0_1[(i + 32) * 2 + 0] = b;
-		ppcRecompilerInstanceData->_psq_ld_scale_ps0_1[(i + 32) * 2 + 1] = 1.0f;
-
-		ppcRecompilerInstanceData->_psq_ld_scale_ps0_ps1[i * 2 + 0] = a;
-		ppcRecompilerInstanceData->_psq_ld_scale_ps0_ps1[i * 2 + 1] = a;
-		ppcRecompilerInstanceData->_psq_ld_scale_ps0_ps1[(i + 32) * 2 + 0] = b;
-		ppcRecompilerInstanceData->_psq_ld_scale_ps0_ps1[(i + 32) * 2 + 1] = b;
-
-		ppcRecompilerInstanceData->_psq_st_scale_ps0_1[i * 2 + 0] = ar;
-		ppcRecompilerInstanceData->_psq_st_scale_ps0_1[i * 2 + 1] = 1.0f;
-		ppcRecompilerInstanceData->_psq_st_scale_ps0_1[(i + 32) * 2 + 0] = br;
-		ppcRecompilerInstanceData->_psq_st_scale_ps0_1[(i + 32) * 2 + 1] = 1.0f;
-
-		ppcRecompilerInstanceData->_psq_st_scale_ps0_ps1[i * 2 + 0] = ar;
-		ppcRecompilerInstanceData->_psq_st_scale_ps0_ps1[i * 2 + 1] = ar;
-		ppcRecompilerInstanceData->_psq_st_scale_ps0_ps1[(i + 32) * 2 + 0] = br;
-		ppcRecompilerInstanceData->_psq_st_scale_ps0_ps1[(i + 32) * 2 + 1] = br;
-	}
-
 	// mxcsr
 	ppcRecompilerInstanceData->_x64XMM_mxCsr_ftzOn = 0x1F80 | 0x8000;
 	ppcRecompilerInstanceData->_x64XMM_mxCsr_ftzOff = 0x1F80;
+}
+#else
+void PPCRecompiler_initPlatform()
+{
+    
+}
+#endif
 
-	// query processor extensions
-	int cpuInfo[4];
-	cpuid(cpuInfo, 0x80000001);
-	hasLZCNTSupport = ((cpuInfo[2] >> 5) & 1) != 0;
-	cpuid(cpuInfo, 0x1);
-	hasMOVBESupport = ((cpuInfo[2] >> 22) & 1) != 0;
-	hasAVXSupport = ((cpuInfo[2] >> 28) & 1) != 0;
-	cpuidex(cpuInfo, 0x7, 0);
-	hasBMI2Support = ((cpuInfo[1] >> 8) & 1) != 0;
+void PPCRecompiler_init()
+{
+	if (ActiveSettings::GetCPUMode() == CPUMode::SinglecoreInterpreter)
+	{
+		ppcRecompilerEnabled = false;
+		return;
+	}
+	if (LaunchSettings::ForceInterpreter() || LaunchSettings::ForceMultiCoreInterpreter())
+	{
+		cemuLog_log(LogType::Force, "Recompiler disabled. Command line --force-interpreter or force-multicore-interpreter was passed");
+		return;
+	}
+	if (ppcRecompilerInstanceData)
+	{
+		MemMapper::FreeReservation(ppcRecompilerInstanceData, sizeof(PPCRecompilerInstanceData_t));
+		ppcRecompilerInstanceData = nullptr;
+	}
+	debug_printf("Allocating %dMB for recompiler instance data...\n", (sint32)(sizeof(PPCRecompilerInstanceData_t) / 1024 / 1024));
+	ppcRecompilerInstanceData = (PPCRecompilerInstanceData_t*)MemMapper::ReserveMemory(nullptr, sizeof(PPCRecompilerInstanceData_t), MemMapper::PAGE_PERMISSION::P_RW);
+	MemMapper::AllocateMemory(&(ppcRecompilerInstanceData->_x64XMM_xorNegateMaskBottom), sizeof(PPCRecompilerInstanceData_t) - offsetof(PPCRecompilerInstanceData_t, _x64XMM_xorNegateMaskBottom), MemMapper::PAGE_PERMISSION::P_RW, true);
+#ifdef ARCH_X86_64
+	PPCRecompilerX64Gen_generateRecompilerInterfaceFunctions();
+#elif defined(__aarch64__)
+	PPCRecompilerAArch64Gen_generateRecompilerInterfaceFunctions();
+#endif
+    PPCRecompiler_allocateRange(0, 0x1000); // the first entry is used for fallback to interpreter
+    PPCRecompiler_allocateRange(mmuRange_TRAMPOLINE_AREA.getBase(), mmuRange_TRAMPOLINE_AREA.getSize());
+    PPCRecompiler_allocateRange(mmuRange_CODECAVE.getBase(), mmuRange_CODECAVE.getSize());
 
-	forceLog_printf("Recompiler initialized. CPU extensions: %s%s%s", hasLZCNTSupport ? "LZCNT " : "", hasMOVBESupport ? "MOVBE " : "", hasAVXSupport ? "AVX " : "");
+    PPCRecompiler_initPlatform();
+    
+	cemuLog_log(LogType::Force, "Recompiler initialized");
 
 	ppcRecompilerEnabled = true;
 
 	// launch recompilation thread
-	std::thread t_recompiler(PPCRecompiler_thread);
-	t_recompiler.detach();
+    s_recompilerThreadStopSignal = false;
+    s_threadRecompiler = std::thread(PPCRecompiler_thread);
+}
+
+void PPCRecompiler_Shutdown()
+{
+    // shut down recompiler thread
+    s_recompilerThreadStopSignal = true;
+    if(s_threadRecompiler.joinable())
+        s_threadRecompiler.join();
+    // clean up queues
+    while(!PPCRecompilerState.targetQueue.empty())
+        PPCRecompilerState.targetQueue.pop();
+    PPCRecompilerState.invalidationRanges.clear();
+    // clean range store
+    rangeStore_ppcRanges.clear();
+    // clean up memory
+    uint32 numBlocks = PPCRecompiler_GetNumAddressSpaceBlocks();
+    for(uint32 i=0; i<numBlocks; i++)
+    {
+        if(!ppcRecompiler_reservedBlockMask[i])
+            continue;
+        // deallocate
+        uint64 offset = i * PPC_REC_ALLOC_BLOCK_SIZE;
+        MemMapper::FreeMemory(&(ppcRecompilerInstanceData->ppcRecompilerFuncTable[offset/4]), (PPC_REC_ALLOC_BLOCK_SIZE/4)*sizeof(void*), true);
+        MemMapper::FreeMemory(&(ppcRecompilerInstanceData->ppcRecompilerDirectJumpTable[offset/4]), (PPC_REC_ALLOC_BLOCK_SIZE/4)*sizeof(void*), true);
+        // mark as unmapped
+        ppcRecompiler_reservedBlockMask[i] = false;
+    }
 }
diff --git a/src/Cafe/HW/Espresso/Recompiler/PPCRecompiler.h b/src/Cafe/HW/Espresso/Recompiler/PPCRecompiler.h
index ee0454ce..47902630 100644
--- a/src/Cafe/HW/Espresso/Recompiler/PPCRecompiler.h
+++ b/src/Cafe/HW/Espresso/Recompiler/PPCRecompiler.h
@@ -1,4 +1,4 @@
-#include <vector>
+#pragma once
 
 #define PPC_REC_CODE_AREA_START		(0x00000000) // lower bound of executable memory area. Recompiler expects this address to be 0
 #define PPC_REC_CODE_AREA_END		(0x10000000) // upper bound of executable memory area
@@ -6,336 +6,113 @@
 
 #define PPC_REC_ALIGN_TO_4MB(__v)	(((__v)+4*1024*1024-1)&~(4*1024*1024-1))
 
-#define PPC_REC_MAX_VIRTUAL_GPR		(40) // enough to store 32 GPRs + a few SPRs + temp registers (usually only 1-2)
+#define PPC_REC_MAX_VIRTUAL_GPR		(40 + 32) // enough to store 32 GPRs + a few SPRs + temp registers (usually only 1-2)
 
-typedef struct  
+struct ppcRecRange_t
 {
 	uint32 ppcAddress;
 	uint32 ppcSize;
-	//void* x86Start;
-	//size_t x86Size;
 	void* storedRange;
-}ppcRecRange_t;
+};
 
-typedef struct  
+struct PPCRecFunction_t
 {
 	uint32 ppcAddress;
 	uint32 ppcSize; // ppc code size of function
 	void*  x86Code; // pointer to x86 code
 	size_t x86Size;
 	std::vector<ppcRecRange_t> list_ranges;
-}PPCRecFunction_t;
-
-#define PPCREC_IML_OP_FLAG_SIGNEXTEND			(1<<0)
-#define PPCREC_IML_OP_FLAG_SWITCHENDIAN			(1<<1)
-#define PPCREC_IML_OP_FLAG_NOT_EXPANDED			(1<<2) // set single-precision load instructions to indicate that the value should not be rounded to double-precision 
-#define PPCREC_IML_OP_FLAG_UNUSED				(1<<7) // used to mark instructions that are not used
-
-typedef struct  
-{
-	uint8 type;
-	uint8 operation;
-	uint8 crRegister; // set to 0xFF if not set, not all IML instruction types support cr.
-	uint8 crMode; // only used when crRegister is valid, used to differentiate between various forms of condition flag set/clear behavior
-	uint32 crIgnoreMask; // bit set for every respective CR bit that doesn't need to be updated
-	uint32 associatedPPCAddress; // ppc address that is associated with this instruction
-	union
-	{
-		struct  
-		{
-			uint8 _padding[7];
-		}padding;
-		struct  
-		{
-			// R (op) A [update cr* in mode *]
-			uint8 registerResult;
-			uint8 registerA;
-		}op_r_r;
-		struct  
-		{
-			// R = A (op) B [update cr* in mode *]
-			uint8 registerResult;
-			uint8 registerA;
-			uint8 registerB;
-		}op_r_r_r;
-		struct  
-		{
-			// R = A (op) immS32 [update cr* in mode *]
-			uint8 registerResult;
-			uint8 registerA;
-			sint32 immS32;
-		}op_r_r_s32;
-		struct  
-		{
-			// R/F = NAME or NAME = R/F
-			uint8 registerIndex;
-			uint8 copyWidth;
-			uint32 name;
-			uint8 flags;
-		}op_r_name;
-		struct  
-		{
-			// R (op) s32 [update cr* in mode *]
-			uint8 registerIndex;
-			sint32 immS32;
-		}op_r_immS32;
-		struct  
-		{
-			uint32 address;
-			uint8 flags;
-		}op_jumpmark;
-		struct  
-		{
-			uint32 param;
-			uint32 param2;
-			uint16 paramU16;
-		}op_macro;
-		struct  
-		{
-			uint32 jumpmarkAddress;
-			bool jumpAccordingToSegment; //PPCRecImlSegment_t* destinationSegment; // if set, this replaces jumpmarkAddress
-			uint8 condition; // only used when crRegisterIndex is 8 or above (update: Apparently only used to mark jumps without a condition? -> Cleanup)
-			uint8 crRegisterIndex;
-			uint8 crBitIndex;
-			bool  bitMustBeSet;
-		}op_conditionalJump;
-		struct
-		{
-			uint8 registerData;
-			uint8 registerMem;
-			uint8 registerMem2;
-			uint8 registerGQR;
-			uint8 copyWidth;
-			//uint8 flags;
-			struct  
-			{
-				bool swapEndian : 1;
-				bool signExtend : 1;
-				bool notExpanded : 1; // for floats
-			}flags2;
-			uint8 mode; // transfer mode (copy width, ps0/ps1 behavior)
-			sint32 immS32;
-		}op_storeLoad;
-		struct
-		{
-			struct
-			{
-				uint8 registerMem;
-				sint32 immS32;
-			}src;
-			struct
-			{
-				uint8 registerMem;
-				sint32 immS32;
-			}dst;
-			uint8 copyWidth;
-		}op_mem2mem;
-		struct  
-		{
-			uint8 registerResult;
-			uint8 registerOperand;
-			uint8 flags;
-		}op_fpr_r_r;
-		struct  
-		{
-			uint8 registerResult;
-			uint8 registerOperandA;
-			uint8 registerOperandB;
-			uint8 flags;
-		}op_fpr_r_r_r;
-		struct  
-		{
-			uint8 registerResult;
-			uint8 registerOperandA;
-			uint8 registerOperandB;
-			uint8 registerOperandC;
-			uint8 flags;
-		}op_fpr_r_r_r_r;
-		struct  
-		{
-			uint8 registerResult;
-			//uint8 flags;
-		}op_fpr_r;
-		struct  
-		{
-			uint32 ppcAddress;
-			uint32 x64Offset;
-		}op_ppcEnter;
-		struct  
-		{
-			uint8 crD; // crBitIndex (result)
-			uint8 crA; // crBitIndex
-			uint8 crB; // crBitIndex
-		}op_cr;
-		// conditional operations (emitted if supported by target platform)
-		struct
-		{
-			// r_s32
-			uint8 registerIndex;
-			sint32 immS32;
-			// condition
-			uint8 crRegisterIndex;
-			uint8 crBitIndex;
-			bool  bitMustBeSet;
-		}op_conditional_r_s32;
-	};
-}PPCRecImlInstruction_t;
-
-typedef struct _PPCRecImlSegment_t PPCRecImlSegment_t;
-
-typedef struct _ppcRecompilerSegmentPoint_t
-{
-	sint32 index;
-	PPCRecImlSegment_t* imlSegment;
-	_ppcRecompilerSegmentPoint_t* next;
-	_ppcRecompilerSegmentPoint_t* prev;
-}ppcRecompilerSegmentPoint_t;
-
-struct raLivenessLocation_t
-{
-	sint32 index;
-	bool isRead;
-	bool isWrite;
-
-	raLivenessLocation_t() {};
-
-	raLivenessLocation_t(sint32 index, bool isRead, bool isWrite)
-		: index(index), isRead(isRead), isWrite(isWrite) {};
 };
 
-struct raLivenessSubrangeLink_t
-{
-	struct raLivenessSubrange_t* prev;
-	struct raLivenessSubrange_t* next;
-};
+#include "Cafe/HW/Espresso/Recompiler/IML/IMLInstruction.h"
+#include "Cafe/HW/Espresso/Recompiler/IML/IMLSegment.h"
 
-struct raLivenessSubrange_t
-{
-	struct raLivenessRange_t* range;
-	PPCRecImlSegment_t* imlSegment;
-	ppcRecompilerSegmentPoint_t start;
-	ppcRecompilerSegmentPoint_t end;
-	// dirty state tracking
-	bool _noLoad;
-	bool hasStore;
-	bool hasStoreDelayed;
-	// next
-	raLivenessSubrange_t* subrangeBranchTaken;
-	raLivenessSubrange_t* subrangeBranchNotTaken;
-	// processing
-	uint32 lastIterationIndex;
-	// instruction locations
-	std::vector<raLivenessLocation_t> list_locations;
-	// linked list (subranges with same GPR virtual register)
-	raLivenessSubrangeLink_t link_sameVirtualRegisterGPR;
-	// linked list (all subranges for this segment)
-	raLivenessSubrangeLink_t link_segmentSubrangesGPR;
-};
-
-struct raLivenessRange_t
-{
-	sint32 virtualRegister;
-	sint32 physicalRegister;
-	sint32 name;
-	std::vector<raLivenessSubrange_t*> list_subranges;
-};
-
-struct PPCSegmentRegisterAllocatorInfo_t
-{
-	// analyzer stage
-	bool isPartOfProcessedLoop{}; // used during loop detection
-	sint32 lastIterationIndex{};
-	// linked lists
-	raLivenessSubrange_t* linkedList_allSubranges{};
-	raLivenessSubrange_t* linkedList_perVirtualGPR[PPC_REC_MAX_VIRTUAL_GPR]{};
-};
-
-struct PPCRecVGPRDistances_t
-{
-	struct _RegArrayEntry
-	{
-		sint32 usageStart{};
-		sint32 usageEnd{};
-	}reg[PPC_REC_MAX_VIRTUAL_GPR];
-	bool isProcessed[PPC_REC_MAX_VIRTUAL_GPR]{};
-};
-
-typedef struct _PPCRecImlSegment_t
-{
-	sint32 momentaryIndex{}; // index in segment list, generally not kept up to date except if needed (necessary for loop detection)
-	sint32 startOffset{}; // offset to first instruction in iml instruction list
-	sint32 count{}; // number of instructions in segment
-	uint32 ppcAddress{}; // ppc address (0xFFFFFFFF if not associated with an address)
-	uint32 x64Offset{}; // x64 code offset of segment start
-	uint32 cycleCount{}; // number of PPC cycles required to execute this segment (roughly)
-	// list of intermediate instructions in this segment
-	PPCRecImlInstruction_t* imlList{};
-	sint32 imlListSize{};
-	sint32 imlListCount{};
-	// segment link
-	_PPCRecImlSegment_t* nextSegmentBranchNotTaken{}; // this is also the default for segments where there is no branch
-	_PPCRecImlSegment_t* nextSegmentBranchTaken{};
-	bool nextSegmentIsUncertain{};
-	sint32 loopDepth{};
-	//sList_t* list_prevSegments;
-	std::vector<_PPCRecImlSegment_t*> list_prevSegments{};
-	// PPC range of segment
-	uint32 ppcAddrMin{};
-	uint32 ppcAddrMax{};
-	// enterable segments
-	bool isEnterable{}; // this segment can be entered from outside the recompiler (no preloaded registers necessary)
-	uint32 enterPPCAddress{}; // used if isEnterable is true
-	// jump destination segments
-	bool isJumpDestination{}; // segment is a destination for one or more (conditional) jumps
-	uint32 jumpDestinationPPCAddress{};
-	// PPC FPR use mask
-	bool ppcFPRUsed[32]{}; // same as ppcGPRUsed, but for FPR
-	// CR use mask
-	uint32 crBitsInput{}; // bits that are expected to be set from the previous segment (read in this segment but not overwritten)
-	uint32 crBitsRead{}; // all bits that are read in this segment
-	uint32 crBitsWritten{}; // bits that are written in this segment
-	// register allocator info
-	PPCSegmentRegisterAllocatorInfo_t raInfo{};
-	PPCRecVGPRDistances_t raDistances{};
-	bool raRangeExtendProcessed{};
-	// segment points
-	ppcRecompilerSegmentPoint_t* segmentPointList{};
-}PPCRecImlSegment_t;
+struct IMLInstruction* PPCRecompilerImlGen_generateNewEmptyInstruction(struct ppcImlGenContext_t* ppcImlGenContext);
 
 struct ppcImlGenContext_t
 {
-	PPCRecFunction_t* functionRef;
+	class PPCFunctionBoundaryTracker* boundaryTracker;
 	uint32* currentInstruction;
 	uint32  ppcAddressOfCurrentInstruction;
+	IMLSegment* currentOutputSegment;
+	struct PPCBasicBlockInfo* currentBasicBlock{};
 	// fpr mode
 	bool LSQE{ true };
 	bool PSE{ true };
 	// cycle counter
 	uint32 cyclesSinceLastBranch; // used to track ppc cycles
-	// temporary general purpose registers
-	uint32 mappedRegister[PPC_REC_MAX_VIRTUAL_GPR];
-	// temporary floating point registers (single and double precision)
-	uint32 mappedFPRRegister[256];
-	// list of intermediate instructions
-	PPCRecImlInstruction_t* imlList;
-	sint32 imlListSize;
-	sint32 imlListCount;
+	std::unordered_map<IMLName, IMLReg> mappedRegs;
+
+	uint32 GetMaxRegId() const
+	{
+		if (mappedRegs.empty())
+			return 0;
+		return mappedRegs.size()-1;
+	}
+
 	// list of segments
-	PPCRecImlSegment_t** segmentList;
-	sint32 segmentListSize;
-	sint32 segmentListCount;
+	std::vector<IMLSegment*> segmentList2;
 	// code generation control
 	bool hasFPUInstruction; // if true, PPCEnter macro will create FP_UNAVAIL checks -> Not needed in user mode
-	// register allocator info
-	struct  
-	{
-		std::vector<raLivenessRange_t*> list_ranges;
-	}raInfo;
 	// analysis info
 	struct  
 	{
 		bool modifiesGQR[8];
 	}tracking;
+	// debug helpers
+	uint32 debug_entryPPCAddress{0};
+
+	~ppcImlGenContext_t()
+	{
+		for (IMLSegment* imlSegment : segmentList2)
+			delete imlSegment;
+		segmentList2.clear();
+	}
+
+	// append raw instruction
+	IMLInstruction& emitInst()
+	{
+		return *PPCRecompilerImlGen_generateNewEmptyInstruction(this);
+	}
+
+	IMLSegment* NewSegment()
+	{
+		IMLSegment* seg = new IMLSegment();
+		segmentList2.emplace_back(seg);
+		return seg;
+	}
+
+	size_t GetSegmentIndex(IMLSegment* seg)
+	{
+		for (size_t i = 0; i < segmentList2.size(); i++)
+		{
+			if (segmentList2[i] == seg)
+				return i;
+		}
+		cemu_assert_error();
+		return 0;
+	}
+
+	IMLSegment* InsertSegment(size_t index)
+	{
+		IMLSegment* newSeg = new IMLSegment();
+		segmentList2.insert(segmentList2.begin() + index, 1, newSeg);
+		return newSeg;
+	}
+
+	std::span<IMLSegment*> InsertSegments(size_t index, size_t count)
+	{
+		segmentList2.insert(segmentList2.begin() + index, count, {});
+		for (size_t i = index; i < (index + count); i++)
+			segmentList2[i] = new IMLSegment();
+		return { segmentList2.data() + index, count};
+	}
+
+	void UpdateSegmentIndices()
+	{
+		for (size_t i = 0; i < segmentList2.size(); i++)
+			segmentList2[i]->momentaryIndex = (sint32)i;
+	}
 };
 
 typedef void ATTR_MS_ABI (*PPCREC_JUMP_ENTRY)();
@@ -359,11 +136,6 @@ typedef struct
 	alignas(16) float  _x64XMM_constFloatMin[2];
 	alignas(16) uint32 _x64XMM_flushDenormalMask1[4];
 	alignas(16) uint32 _x64XMM_flushDenormalMaskResetSignBits[4];
-	// PSQ load/store scale tables
-	double _psq_ld_scale_ps0_ps1[64 * 2];
-	double _psq_ld_scale_ps0_1[64 * 2];
-	double _psq_st_scale_ps0_ps1[64 * 2];
-	double _psq_st_scale_ps0_1[64 * 2];
 	// MXCSR
 	uint32 _x64XMM_mxCsr_ftzOn;
 	uint32 _x64XMM_mxCsr_ftzOff;
@@ -373,6 +145,7 @@ extern PPCRecompilerInstanceData_t* ppcRecompilerInstanceData;
 extern bool ppcRecompilerEnabled;
 
 void PPCRecompiler_init();
+void PPCRecompiler_Shutdown();
 
 void PPCRecompiler_allocateRange(uint32 startAddress, uint32 size);
 
@@ -384,14 +157,6 @@ extern void ATTR_MS_ABI (*PPCRecompiler_leaveRecompilerCode_unvisited)();
 
 #define PPC_REC_INVALID_FUNCTION	((PPCRecFunction_t*)-1)
 
-// CPUID
-extern bool hasLZCNTSupport;
-extern bool hasMOVBESupport;
-extern bool hasBMI2Support;
-extern bool hasAVXSupport;
-
-// todo - move some of the stuff above into PPCRecompilerInternal.h
-
 // recompiler interface
 
 void PPCRecompiler_recompileIfUnvisited(uint32 enterAddress);
diff --git a/src/Cafe/HW/Espresso/Recompiler/PPCRecompilerIml.h b/src/Cafe/HW/Espresso/Recompiler/PPCRecompilerIml.h
index 86af33b2..bfb2aed5 100644
--- a/src/Cafe/HW/Espresso/Recompiler/PPCRecompilerIml.h
+++ b/src/Cafe/HW/Espresso/Recompiler/PPCRecompilerIml.h
@@ -1,293 +1,33 @@
+bool PPCRecompiler_generateIntermediateCode(ppcImlGenContext_t& ppcImlGenContext, PPCRecFunction_t* PPCRecFunction, std::set<uint32>& entryAddresses, class PPCFunctionBoundaryTracker& boundaryTracker);
 
-#define PPCREC_CR_REG_TEMP			8 // there are only 8 cr registers (0-7) we use the 8th as temporary cr register that is never stored (BDNZ instruction for example)
+IMLSegment* PPCIMLGen_CreateSplitSegmentAtEnd(ppcImlGenContext_t& ppcImlGenContext, PPCBasicBlockInfo& basicBlockInfo);
+IMLSegment* PPCIMLGen_CreateNewSegmentAsBranchTarget(ppcImlGenContext_t& ppcImlGenContext, PPCBasicBlockInfo& basicBlockInfo);
 
-enum
-{
-	PPCREC_IML_OP_ASSIGN,			// '=' operator
-	PPCREC_IML_OP_ENDIAN_SWAP,		// '=' operator with 32bit endian swap
-	PPCREC_IML_OP_ADD,				// '+' operator
-	PPCREC_IML_OP_SUB,				// '-' operator
-	PPCREC_IML_OP_SUB_CARRY_UPDATE_CARRY, // complex operation, result = operand + ~operand2 + carry bit, updates carry bit
-	PPCREC_IML_OP_COMPARE_SIGNED,	// arithmetic/signed comparison operator (updates cr)
-	PPCREC_IML_OP_COMPARE_UNSIGNED, // logical/unsigned comparison operator (updates cr)
-	PPCREC_IML_OP_MULTIPLY_SIGNED,  // '*' operator (signed multiply)
-	PPCREC_IML_OP_MULTIPLY_HIGH_UNSIGNED, // unsigned 64bit multiply, store only high 32bit-word of result
-	PPCREC_IML_OP_MULTIPLY_HIGH_SIGNED, // signed 64bit multiply, store only high 32bit-word of result
-	PPCREC_IML_OP_DIVIDE_SIGNED,	// '/' operator (signed divide)
-	PPCREC_IML_OP_DIVIDE_UNSIGNED,	// '/' operator (unsigned divide)
-	PPCREC_IML_OP_ADD_CARRY,		// complex operation, result = operand + carry bit, updates carry bit
-	PPCREC_IML_OP_ADD_CARRY_ME,		// complex operation, result = operand + carry bit + (-1), updates carry bit
-	PPCREC_IML_OP_ADD_UPDATE_CARRY,	// '+' operator but also updates carry flag
-	PPCREC_IML_OP_ADD_CARRY_UPDATE_CARRY, // '+' operator and also adds carry, updates carry flag
-	// assign operators with cast
-	PPCREC_IML_OP_ASSIGN_S16_TO_S32, // copy 16bit and sign extend
-	PPCREC_IML_OP_ASSIGN_S8_TO_S32,  // copy 8bit and sign extend
-	// binary operation
-	PPCREC_IML_OP_OR,				// '|' operator
-	PPCREC_IML_OP_ORC,				// '|' operator, second operand is complemented first
-	PPCREC_IML_OP_AND,				// '&' operator
-	PPCREC_IML_OP_XOR,				// '^' operator
-	PPCREC_IML_OP_LEFT_ROTATE,		// left rotate operator
-	PPCREC_IML_OP_LEFT_SHIFT,		// shift left operator
-	PPCREC_IML_OP_RIGHT_SHIFT,		// right shift operator (unsigned)
-	PPCREC_IML_OP_NOT,				// complement each bit
-	PPCREC_IML_OP_NEG,				// negate
-	// ppc
-	PPCREC_IML_OP_RLWIMI,			// RLWIMI instruction (rotate, merge based on mask)
-	PPCREC_IML_OP_SRAW,				// SRAWI/SRAW instruction (algebraic shift right, sets ca flag)
-	PPCREC_IML_OP_SLW,				// SLW (shift based on register by up to 63 bits)
-	PPCREC_IML_OP_SRW,				// SRW (shift based on register by up to 63 bits)
-	PPCREC_IML_OP_CNTLZW,
-	PPCREC_IML_OP_SUBFC,			// SUBFC and SUBFIC (subtract from and set carry)
-	PPCREC_IML_OP_DCBZ,				// clear 32 bytes aligned to 0x20
-	PPCREC_IML_OP_MFCR,				// copy cr to gpr
-	PPCREC_IML_OP_MTCRF,			// copy gpr to cr (with mask)
-	// condition register
-	PPCREC_IML_OP_CR_CLEAR,			// clear cr bit
-	PPCREC_IML_OP_CR_SET,			// set cr bit
-	PPCREC_IML_OP_CR_OR,			// OR cr bits
-	PPCREC_IML_OP_CR_ORC,			// OR cr bits, complement second input operand bit first
-	PPCREC_IML_OP_CR_AND,			// AND cr bits
-	PPCREC_IML_OP_CR_ANDC,			// AND cr bits, complement second input operand bit first
-	// FPU
-	PPCREC_IML_OP_FPR_ADD_BOTTOM,
-	PPCREC_IML_OP_FPR_ADD_PAIR,
-	PPCREC_IML_OP_FPR_SUB_PAIR,
-	PPCREC_IML_OP_FPR_SUB_BOTTOM,
-	PPCREC_IML_OP_FPR_MULTIPLY_BOTTOM,
-	PPCREC_IML_OP_FPR_MULTIPLY_PAIR,
-	PPCREC_IML_OP_FPR_DIVIDE_BOTTOM,
-	PPCREC_IML_OP_FPR_DIVIDE_PAIR,
-	PPCREC_IML_OP_FPR_COPY_BOTTOM_TO_BOTTOM_AND_TOP,
-	PPCREC_IML_OP_FPR_COPY_TOP_TO_BOTTOM_AND_TOP,
-	PPCREC_IML_OP_FPR_COPY_BOTTOM_TO_BOTTOM,
-	PPCREC_IML_OP_FPR_COPY_BOTTOM_TO_TOP, // leave bottom of destination untouched
-	PPCREC_IML_OP_FPR_COPY_TOP_TO_TOP, // leave bottom of destination untouched
-	PPCREC_IML_OP_FPR_COPY_TOP_TO_BOTTOM, // leave top of destination untouched
-	PPCREC_IML_OP_FPR_COPY_BOTTOM_AND_TOP_SWAPPED,
-	PPCREC_IML_OP_FPR_EXPAND_BOTTOM32_TO_BOTTOM64_AND_TOP64, // expand bottom f32 to f64 in bottom and top half
-	PPCREC_IML_OP_FPR_BOTTOM_FRES_TO_BOTTOM_AND_TOP, // calculate reciprocal with Espresso accuracy of source bottom half and write result to destination bottom and top half
-	PPCREC_IML_OP_FPR_FCMPO_BOTTOM,
-	PPCREC_IML_OP_FPR_FCMPU_BOTTOM,
-	PPCREC_IML_OP_FPR_FCMPU_TOP,
-	PPCREC_IML_OP_FPR_NEGATE_BOTTOM,
-	PPCREC_IML_OP_FPR_NEGATE_PAIR,
-	PPCREC_IML_OP_FPR_ABS_BOTTOM, // abs(fp0)
-	PPCREC_IML_OP_FPR_ABS_PAIR,
-	PPCREC_IML_OP_FPR_FRES_PAIR, // 1.0/fp approx (Espresso accuracy)
-	PPCREC_IML_OP_FPR_FRSQRTE_PAIR, // 1.0/sqrt(fp) approx (Espresso accuracy)
-	PPCREC_IML_OP_FPR_NEGATIVE_ABS_BOTTOM, // -abs(fp0)
-	PPCREC_IML_OP_FPR_ROUND_TO_SINGLE_PRECISION_BOTTOM, // round 64bit double to 64bit double with 32bit float precision (in bottom half of xmm register)
-	PPCREC_IML_OP_FPR_ROUND_TO_SINGLE_PRECISION_PAIR, // round two 64bit doubles to 64bit double with 32bit float precision
-	PPCREC_IML_OP_FPR_BOTTOM_RECIPROCAL_SQRT,
-	PPCREC_IML_OP_FPR_BOTTOM_FCTIWZ,
-	PPCREC_IML_OP_FPR_SELECT_BOTTOM, // selectively copy bottom value from operand B or C based on value in operand A
-	PPCREC_IML_OP_FPR_SELECT_PAIR, // selectively copy top/bottom from operand B or C based on value in top/bottom of operand A
-	// PS
-	PPCREC_IML_OP_FPR_SUM0,
-	PPCREC_IML_OP_FPR_SUM1,
-};
+void PPCIMLGen_AssertIfNotLastSegmentInstruction(ppcImlGenContext_t& ppcImlGenContext);
 
-#define PPCREC_IML_OP_FPR_COPY_PAIR (PPCREC_IML_OP_ASSIGN)
-
-enum
-{
-	PPCREC_IML_MACRO_BLR,			// macro for BLR instruction code
-	PPCREC_IML_MACRO_BLRL,			// macro for BLRL instruction code
-	PPCREC_IML_MACRO_BCTR,			// macro for BCTR instruction code
-	PPCREC_IML_MACRO_BCTRL,			// macro for BCTRL instruction code
-	PPCREC_IML_MACRO_BL,			// call to different function (can be within same function)
-	PPCREC_IML_MACRO_B_FAR,			// branch to different function
-	PPCREC_IML_MACRO_COUNT_CYCLES,	// decrease current remaining thread cycles by a certain amount
-	PPCREC_IML_MACRO_HLE,			// HLE function call
-	PPCREC_IML_MACRO_MFTB,			// get TB register value (low or high)
-	PPCREC_IML_MACRO_LEAVE,			// leaves recompiler and switches to interpeter
-	// debugging
-	PPCREC_IML_MACRO_DEBUGBREAK,	// throws a debugbreak
-};
-
-enum
-{
-	PPCREC_JUMP_CONDITION_NONE,
-	PPCREC_JUMP_CONDITION_E, // equal / zero
-	PPCREC_JUMP_CONDITION_NE, // not equal / not zero
-	PPCREC_JUMP_CONDITION_LE, // less or equal
-	PPCREC_JUMP_CONDITION_L, // less
-	PPCREC_JUMP_CONDITION_GE, // greater or equal
-	PPCREC_JUMP_CONDITION_G, // greater
-	// special case:
-	PPCREC_JUMP_CONDITION_SUMMARYOVERFLOW, // needs special handling
-	PPCREC_JUMP_CONDITION_NSUMMARYOVERFLOW, // not summaryoverflow
-
-};
-
-enum
-{
-	PPCREC_CR_MODE_COMPARE_SIGNED,
-	PPCREC_CR_MODE_COMPARE_UNSIGNED, // alias logic compare
-	// others: 	PPCREC_CR_MODE_ARITHMETIC,
-	PPCREC_CR_MODE_ARITHMETIC, // arithmetic use (for use with add/sub instructions without generating extra code)
-	PPCREC_CR_MODE_LOGICAL,
-};
-
-enum
-{
-	PPCREC_IML_TYPE_NONE,
-	PPCREC_IML_TYPE_NO_OP,				// no-op instruction
-	PPCREC_IML_TYPE_JUMPMARK,			// possible jump destination (generated before each ppc instruction)
-	PPCREC_IML_TYPE_R_R,				// r* (op) *r
-	PPCREC_IML_TYPE_R_R_R,				// r* = r* (op) r*
-	PPCREC_IML_TYPE_R_R_S32,			// r* = r* (op) s32*
-	PPCREC_IML_TYPE_LOAD,				// r* = [r*+s32*]
-	PPCREC_IML_TYPE_LOAD_INDEXED,		// r* = [r*+r*]
-	PPCREC_IML_TYPE_STORE,				// [r*+s32*] = r*
-	PPCREC_IML_TYPE_STORE_INDEXED,		// [r*+r*] = r*
-	PPCREC_IML_TYPE_R_NAME,				// r* = name
-	PPCREC_IML_TYPE_NAME_R,				// name* = r*
-	PPCREC_IML_TYPE_R_S32,				// r* (op) imm
-	PPCREC_IML_TYPE_MACRO,
-	PPCREC_IML_TYPE_CJUMP,				// conditional jump
-	PPCREC_IML_TYPE_CJUMP_CYCLE_CHECK,	// jumps only if remaining thread cycles >= 0
-	PPCREC_IML_TYPE_PPC_ENTER,			// used to mark locations that should be written to recompilerCallTable
-	PPCREC_IML_TYPE_CR,					// condition register specific operations (one or more operands)
-	// conditional
-	PPCREC_IML_TYPE_CONDITIONAL_R_S32,
-	// FPR
-	PPCREC_IML_TYPE_FPR_R_NAME,			// name = f*
-	PPCREC_IML_TYPE_FPR_NAME_R,			// f* = name
-	PPCREC_IML_TYPE_FPR_LOAD,			// r* = (bitdepth) [r*+s32*] (single or paired single mode)
-	PPCREC_IML_TYPE_FPR_LOAD_INDEXED,	// r* = (bitdepth) [r*+r*] (single or paired single mode)
-	PPCREC_IML_TYPE_FPR_STORE,			// (bitdepth) [r*+s32*] = r* (single or paired single mode)
-	PPCREC_IML_TYPE_FPR_STORE_INDEXED,	// (bitdepth) [r*+r*] = r* (single or paired single mode)
-	PPCREC_IML_TYPE_FPR_R_R,
-	PPCREC_IML_TYPE_FPR_R_R_R,
-	PPCREC_IML_TYPE_FPR_R_R_R_R,
-	PPCREC_IML_TYPE_FPR_R,
-	// special
-	PPCREC_IML_TYPE_MEM2MEM,			// memory to memory copy (deprecated)
-
-};
-
-enum
-{
-	PPCREC_NAME_NONE,
-	PPCREC_NAME_TEMPORARY,
-	PPCREC_NAME_R0 = 1000,
-	PPCREC_NAME_SPR0 = 2000,
-	PPCREC_NAME_FPR0 = 3000,
-	PPCREC_NAME_TEMPORARY_FPR0 = 4000, // 0 to 7
-	//PPCREC_NAME_CR0 = 3000, // value mapped condition register (usually it isn't needed and can be optimized away)
-};
-
-// special cases for LOAD/STORE
-#define PPC_REC_LOAD_LWARX_MARKER	(100)	// lwarx instruction (similar to LWZX but sets reserved address/value)
-#define PPC_REC_STORE_STWCX_MARKER	(100)	// stwcx instruction (similar to STWX but writes only if reservation from LWARX is valid)
-#define PPC_REC_STORE_STSWI_1		(200)   // stswi nb = 1
-#define PPC_REC_STORE_STSWI_2		(201)   // stswi nb = 2
-#define PPC_REC_STORE_STSWI_3		(202)   // stswi nb = 3
-#define PPC_REC_STORE_LSWI_1		(200)   // lswi nb = 1
-#define PPC_REC_STORE_LSWI_2		(201)   // lswi nb = 2
-#define PPC_REC_STORE_LSWI_3		(202)   // lswi nb = 3
-
-#define PPC_REC_INVALID_REGISTER		0xFF
-
-#define PPCREC_CR_BIT_LT	0
-#define PPCREC_CR_BIT_GT	1
-#define PPCREC_CR_BIT_EQ	2
-#define PPCREC_CR_BIT_SO	3
-
-enum
-{
-	// fpr load
-	PPCREC_FPR_LD_MODE_SINGLE_INTO_PS0,
-	PPCREC_FPR_LD_MODE_SINGLE_INTO_PS0_PS1,
-	PPCREC_FPR_LD_MODE_DOUBLE_INTO_PS0,
-	PPCREC_FPR_LD_MODE_PSQ_GENERIC_PS0,
-	PPCREC_FPR_LD_MODE_PSQ_GENERIC_PS0_PS1,
-	PPCREC_FPR_LD_MODE_PSQ_FLOAT_PS0,
-	PPCREC_FPR_LD_MODE_PSQ_FLOAT_PS0_PS1,
-	PPCREC_FPR_LD_MODE_PSQ_S16_PS0,
-	PPCREC_FPR_LD_MODE_PSQ_S16_PS0_PS1,
-	PPCREC_FPR_LD_MODE_PSQ_U16_PS0,
-	PPCREC_FPR_LD_MODE_PSQ_U16_PS0_PS1,
-	PPCREC_FPR_LD_MODE_PSQ_S8_PS0,
-	PPCREC_FPR_LD_MODE_PSQ_S8_PS0_PS1,
-	PPCREC_FPR_LD_MODE_PSQ_U8_PS0,
-	PPCREC_FPR_LD_MODE_PSQ_U8_PS0_PS1,
-	// fpr store
-	PPCREC_FPR_ST_MODE_SINGLE_FROM_PS0, // store 1 single precision float from ps0
-	PPCREC_FPR_ST_MODE_DOUBLE_FROM_PS0, // store 1 double precision float from ps0
-
-	PPCREC_FPR_ST_MODE_UI32_FROM_PS0, // store raw low-32bit of PS0
-
-	PPCREC_FPR_ST_MODE_PSQ_GENERIC_PS0_PS1,
-	PPCREC_FPR_ST_MODE_PSQ_GENERIC_PS0,
-	PPCREC_FPR_ST_MODE_PSQ_FLOAT_PS0_PS1,
-	PPCREC_FPR_ST_MODE_PSQ_FLOAT_PS0,
-	PPCREC_FPR_ST_MODE_PSQ_S8_PS0,
-	PPCREC_FPR_ST_MODE_PSQ_S8_PS0_PS1,
-	PPCREC_FPR_ST_MODE_PSQ_U8_PS0, 
-	PPCREC_FPR_ST_MODE_PSQ_U8_PS0_PS1,
-	PPCREC_FPR_ST_MODE_PSQ_U16_PS0,
-	PPCREC_FPR_ST_MODE_PSQ_U16_PS0_PS1,
-	PPCREC_FPR_ST_MODE_PSQ_S16_PS0,
-	PPCREC_FPR_ST_MODE_PSQ_S16_PS0_PS1,
-};
-
-bool PPCRecompiler_generateIntermediateCode(ppcImlGenContext_t& ppcImlGenContext, PPCRecFunction_t* PPCRecFunction, std::set<uint32>& entryAddresses);
-void PPCRecompiler_freeContext(ppcImlGenContext_t* ppcImlGenContext); // todo - move to destructor
-
-PPCRecImlInstruction_t* PPCRecompilerImlGen_generateNewEmptyInstruction(ppcImlGenContext_t* ppcImlGenContext);
-void PPCRecompiler_pushBackIMLInstructions(PPCRecImlSegment_t* imlSegment, sint32 index, sint32 shiftBackCount);
-PPCRecImlInstruction_t* PPCRecompiler_insertInstruction(PPCRecImlSegment_t* imlSegment, sint32 index);
+IMLInstruction* PPCRecompilerImlGen_generateNewEmptyInstruction(ppcImlGenContext_t* ppcImlGenContext);
+void PPCRecompiler_pushBackIMLInstructions(IMLSegment* imlSegment, sint32 index, sint32 shiftBackCount);
+IMLInstruction* PPCRecompiler_insertInstruction(IMLSegment* imlSegment, sint32 index);
 
 void PPCRecompilerIml_insertSegments(ppcImlGenContext_t* ppcImlGenContext, sint32 index, sint32 count);
 
-void PPCRecompilerIml_setSegmentPoint(ppcRecompilerSegmentPoint_t* segmentPoint, PPCRecImlSegment_t* imlSegment, sint32 index);
-void PPCRecompilerIml_removeSegmentPoint(ppcRecompilerSegmentPoint_t* segmentPoint);
+void PPCRecompilerIml_setSegmentPoint(IMLSegmentPoint* segmentPoint, IMLSegment* imlSegment, sint32 index);
+void PPCRecompilerIml_removeSegmentPoint(IMLSegmentPoint* segmentPoint);
 
-// GPR register management
-uint32 PPCRecompilerImlGen_loadRegister(ppcImlGenContext_t* ppcImlGenContext, uint32 mappedName, bool loadNew = false);
-uint32 PPCRecompilerImlGen_loadOverwriteRegister(ppcImlGenContext_t* ppcImlGenContext, uint32 mappedName);
+// Register management
+IMLReg PPCRecompilerImlGen_LookupReg(ppcImlGenContext_t* ppcImlGenContext, IMLName mappedName, IMLRegFormat regFormat);
 
-// FPR register management
-uint32 PPCRecompilerImlGen_loadFPRRegister(ppcImlGenContext_t* ppcImlGenContext, uint32 mappedName, bool loadNew = false);
-uint32 PPCRecompilerImlGen_loadOverwriteFPRRegister(ppcImlGenContext_t* ppcImlGenContext, uint32 mappedName);
+IMLReg PPCRecompilerImlGen_loadRegister(ppcImlGenContext_t* ppcImlGenContext, uint32 mappedName);
 
 // IML instruction generation
-void PPCRecompilerImlGen_generateNewInstruction_jump(ppcImlGenContext_t* ppcImlGenContext, PPCRecImlInstruction_t* imlInstruction, uint32 jumpmarkAddress);
-void PPCRecompilerImlGen_generateNewInstruction_jumpSegment(ppcImlGenContext_t* ppcImlGenContext, PPCRecImlInstruction_t* imlInstruction);
-
-void PPCRecompilerImlGen_generateNewInstruction_r_s32(ppcImlGenContext_t* ppcImlGenContext, uint32 operation, uint8 registerIndex, sint32 immS32, uint32 copyWidth, bool signExtend, bool bigEndian, uint8 crRegister, uint32 crMode);
-void PPCRecompilerImlGen_generateNewInstruction_conditional_r_s32(ppcImlGenContext_t* ppcImlGenContext, PPCRecImlInstruction_t* imlInstruction, uint32 operation, uint8 registerIndex, sint32 immS32, uint32 crRegisterIndex, uint32 crBitIndex, bool bitMustBeSet);
-void PPCRecompilerImlGen_generateNewInstruction_r_r(ppcImlGenContext_t* ppcImlGenContext, PPCRecImlInstruction_t* imlInstruction, uint32 operation, uint8 registerResult, uint8 registerA, uint8 crRegister = PPC_REC_INVALID_REGISTER, uint8 crMode = 0);
-
-
-
-// IML instruction generation (new style, can generate new instructions but also overwrite existing ones)
-
-void PPCRecompilerImlGen_generateNewInstruction_noOp(ppcImlGenContext_t* ppcImlGenContext, PPCRecImlInstruction_t* imlInstruction);
-void PPCRecompilerImlGen_generateNewInstruction_memory_memory(ppcImlGenContext_t* ppcImlGenContext, PPCRecImlInstruction_t* imlInstruction, uint8 srcMemReg, sint32 srcImmS32, uint8 dstMemReg, sint32 dstImmS32, uint8 copyWidth);
-
-void PPCRecompilerImlGen_generateNewInstruction_fpr_r(ppcImlGenContext_t* ppcImlGenContext, PPCRecImlInstruction_t* imlInstruction, sint32 operation, uint8 registerResult, sint32 crRegister = PPC_REC_INVALID_REGISTER);
+void PPCRecompilerImlGen_generateNewInstruction_conditional_r_s32(ppcImlGenContext_t* ppcImlGenContext, IMLInstruction* imlInstruction, uint32 operation, IMLReg registerIndex, sint32 immS32, uint32 crRegisterIndex, uint32 crBitIndex, bool bitMustBeSet);
 
 // IML generation - FPU
-bool PPCRecompilerImlGen_LFS(ppcImlGenContext_t* ppcImlGenContext, uint32 opcode);
-bool PPCRecompilerImlGen_LFSU(ppcImlGenContext_t* ppcImlGenContext, uint32 opcode);
-bool PPCRecompilerImlGen_LFSX(ppcImlGenContext_t* ppcImlGenContext, uint32 opcode);
-bool PPCRecompilerImlGen_LFSUX(ppcImlGenContext_t* ppcImlGenContext, uint32 opcode);
-bool PPCRecompilerImlGen_LFD(ppcImlGenContext_t* ppcImlGenContext, uint32 opcode);
-bool PPCRecompilerImlGen_LFDU(ppcImlGenContext_t* ppcImlGenContext, uint32 opcode);
-bool PPCRecompilerImlGen_LFDX(ppcImlGenContext_t* ppcImlGenContext, uint32 opcode);
-bool PPCRecompilerImlGen_LFDUX(ppcImlGenContext_t* ppcImlGenContext, uint32 opcode);
-bool PPCRecompilerImlGen_STFS(ppcImlGenContext_t* ppcImlGenContext, uint32 opcode);
-bool PPCRecompilerImlGen_STFSU(ppcImlGenContext_t* ppcImlGenContext, uint32 opcode);
-bool PPCRecompilerImlGen_STFSX(ppcImlGenContext_t* ppcImlGenContext, uint32 opcode);
-bool PPCRecompilerImlGen_STFSUX(ppcImlGenContext_t* ppcImlGenContext, uint32 opcode);
+bool PPCRecompilerImlGen_LFS_LFSU_LFD_LFDU(ppcImlGenContext_t* ppcImlGenContext, uint32 opcode, bool withUpdate, bool isDouble);
+bool PPCRecompilerImlGen_LFSX_LFSUX_LFDX_LFDUX(ppcImlGenContext_t* ppcImlGenContext, uint32 opcode, bool withUpdate, bool isDouble);
+bool PPCRecompilerImlGen_STFS_STFSU_STFD_STFDU(ppcImlGenContext_t* ppcImlGenContext, uint32 opcode, bool withUpdate, bool isDouble);
+bool PPCRecompilerImlGen_STFSX_STFSUX_STFDX_STFDUX(ppcImlGenContext_t* ppcImlGenContext, uint32 opcode, bool hasUpdate, bool isDouble);
 bool PPCRecompilerImlGen_STFIWX(ppcImlGenContext_t* ppcImlGenContext, uint32 opcode);
-bool PPCRecompilerImlGen_STFD(ppcImlGenContext_t* ppcImlGenContext, uint32 opcode);
-bool PPCRecompilerImlGen_STFDU(ppcImlGenContext_t* ppcImlGenContext, uint32 opcode);
-bool PPCRecompilerImlGen_STFDX(ppcImlGenContext_t* ppcImlGenContext, uint32 opcode);
 bool PPCRecompilerImlGen_FADD(ppcImlGenContext_t* ppcImlGenContext, uint32 opcode);
 bool PPCRecompilerImlGen_FSUB(ppcImlGenContext_t* ppcImlGenContext, uint32 opcode);
 bool PPCRecompilerImlGen_FMUL(ppcImlGenContext_t* ppcImlGenContext, uint32 opcode);
@@ -313,22 +53,17 @@ bool PPCRecompilerImlGen_FNEG(ppcImlGenContext_t* ppcImlGenContext, uint32 opcod
 bool PPCRecompilerImlGen_FSEL(ppcImlGenContext_t* ppcImlGenContext, uint32 opcode);
 bool PPCRecompilerImlGen_FRSQRTE(ppcImlGenContext_t* ppcImlGenContext, uint32 opcode);
 bool PPCRecompilerImlGen_FCTIWZ(ppcImlGenContext_t* ppcImlGenContext, uint32 opcode);
-bool PPCRecompilerImlGen_PSQ_L(ppcImlGenContext_t* ppcImlGenContext, uint32 opcode);
-bool PPCRecompilerImlGen_PSQ_LU(ppcImlGenContext_t* ppcImlGenContext, uint32 opcode);
-bool PPCRecompilerImlGen_PSQ_ST(ppcImlGenContext_t* ppcImlGenContext, uint32 opcode);
-bool PPCRecompilerImlGen_PSQ_STU(ppcImlGenContext_t* ppcImlGenContext, uint32 opcode);
-bool PPCRecompilerImlGen_PS_MULS0(ppcImlGenContext_t* ppcImlGenContext, uint32 opcode);
-bool PPCRecompilerImlGen_PS_MULS1(ppcImlGenContext_t* ppcImlGenContext, uint32 opcode);
-bool PPCRecompilerImlGen_PS_MADDS0(ppcImlGenContext_t* ppcImlGenContext, uint32 opcode);
-bool PPCRecompilerImlGen_PS_MADDS1(ppcImlGenContext_t* ppcImlGenContext, uint32 opcode);
+bool PPCRecompilerImlGen_PSQ_L(ppcImlGenContext_t* ppcImlGenContext, uint32 opcode, bool withUpdate);
+bool PPCRecompilerImlGen_PSQ_ST(ppcImlGenContext_t* ppcImlGenContext, uint32 opcode, bool withUpdate);
+bool PPCRecompilerImlGen_PS_MULSX(ppcImlGenContext_t* ppcImlGenContext, uint32 opcode, bool isVariant1);
+bool PPCRecompilerImlGen_PS_MADDSX(ppcImlGenContext_t* ppcImlGenContext, uint32 opcode, bool isVariant1);
 bool PPCRecompilerImlGen_PS_ADD(ppcImlGenContext_t* ppcImlGenContext, uint32 opcode);
 bool PPCRecompilerImlGen_PS_SUB(ppcImlGenContext_t* ppcImlGenContext, uint32 opcode);
 bool PPCRecompilerImlGen_PS_MUL(ppcImlGenContext_t* ppcImlGenContext, uint32 opcode);
 bool PPCRecompilerImlGen_PS_DIV(ppcImlGenContext_t* ppcImlGenContext, uint32 opcode);
 bool PPCRecompilerImlGen_PS_MADD(ppcImlGenContext_t* ppcImlGenContext, uint32 opcode);
 bool PPCRecompilerImlGen_PS_NMADD(ppcImlGenContext_t* ppcImlGenContext, uint32 opcode);
-bool PPCRecompilerImlGen_PS_MSUB(ppcImlGenContext_t* ppcImlGenContext, uint32 opcode);
-bool PPCRecompilerImlGen_PS_NMSUB(ppcImlGenContext_t* ppcImlGenContext, uint32 opcode);
+bool PPCRecompilerImlGen_PS_MSUB(ppcImlGenContext_t* ppcImlGenContext, uint32 opcode, bool withNegative);
 bool PPCRecompilerImlGen_PS_SUM0(ppcImlGenContext_t* ppcImlGenContext, uint32 opcode);
 bool PPCRecompilerImlGen_PS_SUM1(ppcImlGenContext_t* ppcImlGenContext, uint32 opcode);
 bool PPCRecompilerImlGen_PS_NEG(ppcImlGenContext_t* ppcImlGenContext, uint32 opcode);
@@ -347,76 +82,20 @@ bool PPCRecompilerImlGen_PS_CMPU1(ppcImlGenContext_t* ppcImlGenContext, uint32 o
 
 // IML general
 
-bool PPCRecompiler_isSuffixInstruction(PPCRecImlInstruction_t* iml);
-void PPCRecompilerIML_linkSegments(ppcImlGenContext_t* ppcImlGenContext);
-void PPCRecompilerIml_setLinkBranchNotTaken(PPCRecImlSegment_t* imlSegmentSrc, PPCRecImlSegment_t* imlSegmentDst);
-void PPCRecompilerIml_setLinkBranchTaken(PPCRecImlSegment_t* imlSegmentSrc, PPCRecImlSegment_t* imlSegmentDst);
-void PPCRecompilerIML_relinkInputSegment(PPCRecImlSegment_t* imlSegmentOrig, PPCRecImlSegment_t* imlSegmentNew);
-void PPCRecompilerIML_removeLink(PPCRecImlSegment_t* imlSegmentSrc, PPCRecImlSegment_t* imlSegmentDst);
 void PPCRecompilerIML_isolateEnterableSegments(ppcImlGenContext_t* ppcImlGenContext);
 
-PPCRecImlInstruction_t* PPCRecompilerIML_getLastInstruction(PPCRecImlSegment_t* imlSegment);
+void PPCIMLGen_CreateSegmentBranchedPath(ppcImlGenContext_t& ppcImlGenContext, PPCBasicBlockInfo& basicBlockInfo, const std::function<void(ppcImlGenContext_t&)>& genSegmentBranchTaken, const std::function<void(ppcImlGenContext_t&)>& genSegmentBranchNotTaken);
+void PPCIMLGen_CreateSegmentBranchedPath(ppcImlGenContext_t& ppcImlGenContext, PPCBasicBlockInfo& basicBlockInfo, const std::function<void(ppcImlGenContext_t&)>& genSegmentBranchNotTaken); // no else segment
+void PPCIMLGen_CreateSegmentBranchedPathMultiple(ppcImlGenContext_t& ppcImlGenContext, PPCBasicBlockInfo& basicBlockInfo, IMLSegment** segmentsOut, IMLReg compareReg, sint32* compareValues, sint32 count, sint32 defaultCaseIndex);
 
-// IML analyzer
-typedef struct
+class IMLRedirectInstOutput
 {
-	uint32 readCRBits;
-	uint32 writtenCRBits;
-}PPCRecCRTracking_t;
-
-bool PPCRecompilerImlAnalyzer_isTightFiniteLoop(PPCRecImlSegment_t* imlSegment);
-bool PPCRecompilerImlAnalyzer_canTypeWriteCR(PPCRecImlInstruction_t* imlInstruction);
-void PPCRecompilerImlAnalyzer_getCRTracking(PPCRecImlInstruction_t* imlInstruction, PPCRecCRTracking_t* crTracking);
-
-// IML optimizer
-bool PPCRecompiler_reduceNumberOfFPRRegisters(ppcImlGenContext_t* ppcImlGenContext);
-
-bool PPCRecompiler_manageFPRRegisters(ppcImlGenContext_t* ppcImlGenContext);
-
-void PPCRecompiler_removeRedundantCRUpdates(ppcImlGenContext_t* ppcImlGenContext);
-void PPCRecompiler_optimizeDirectFloatCopies(ppcImlGenContext_t* ppcImlGenContext);
-void PPCRecompiler_optimizeDirectIntegerCopies(ppcImlGenContext_t* ppcImlGenContext);
-
-void PPCRecompiler_optimizePSQLoadAndStore(ppcImlGenContext_t* ppcImlGenContext);
-
-// IML register allocator
-void PPCRecompilerImm_allocateRegisters(ppcImlGenContext_t* ppcImlGenContext);
-
-// late optimizations
-void PPCRecompiler_reorderConditionModifyInstructions(ppcImlGenContext_t* ppcImlGenContext);
-
-// debug
-
-void PPCRecompiler_dumpIMLSegment(PPCRecImlSegment_t* imlSegment, sint32 segmentIndex, bool printLivenessRangeInfo = false);
+public:
+	IMLRedirectInstOutput(ppcImlGenContext_t* ppcImlGenContext, IMLSegment* outputSegment);
+	~IMLRedirectInstOutput();
 
 
-typedef struct
-{
-	union
-	{
-		struct
-		{
-			sint16 readNamedReg1;
-			sint16 readNamedReg2;
-			sint16 readNamedReg3;
-			sint16 writtenNamedReg1;
-		};
-		sint16 gpr[4]; // 3 read + 1 write
-	};
-	// FPR
-	union
-	{
-		struct
-		{
-			// note: If destination operand is not fully written, it will be added as a read FPR as well
-			sint16 readFPR1;
-			sint16 readFPR2;
-			sint16 readFPR3;
-			sint16 readFPR4; // usually this is set to the result FPR if only partially overwritten
-			sint16 writtenFPR1;
-		};
-		sint16 fpr[4];
-	};
-}PPCImlOptimizerUsedRegisters_t;
-
-void PPCRecompiler_checkRegisterUsage(ppcImlGenContext_t* ppcImlGenContext, PPCRecImlInstruction_t* imlInstruction, PPCImlOptimizerUsedRegisters_t* registersUsed);
+private:
+	ppcImlGenContext_t* m_context;
+	IMLSegment* m_prevSegment;
+};
\ No newline at end of file
diff --git a/src/Cafe/HW/Espresso/Recompiler/PPCRecompilerImlAnalyzer.cpp b/src/Cafe/HW/Espresso/Recompiler/PPCRecompilerImlAnalyzer.cpp
deleted file mode 100644
index 4962d30d..00000000
--- a/src/Cafe/HW/Espresso/Recompiler/PPCRecompilerImlAnalyzer.cpp
+++ /dev/null
@@ -1,137 +0,0 @@
-#include "PPCRecompiler.h"
-#include "PPCRecompilerIml.h"
-#include "util/helpers/fixedSizeList.h"
-#include "Cafe/HW/Espresso/Interpreter/PPCInterpreterInternal.h"
-
-/*
- * Initializes a single segment and returns true if it is a finite loop
- */
-bool PPCRecompilerImlAnalyzer_isTightFiniteLoop(PPCRecImlSegment_t* imlSegment)
-{
-	bool isTightFiniteLoop = false;
-	// base criteria, must jump to beginning of same segment
-	if (imlSegment->nextSegmentBranchTaken != imlSegment)
-		return false;
-	// loops using BDNZ are assumed to always be finite
-	for (sint32 t = 0; t < imlSegment->imlListCount; t++)
-	{
-		if (imlSegment->imlList[t].type == PPCREC_IML_TYPE_R_S32 && imlSegment->imlList[t].operation == PPCREC_IML_OP_SUB && imlSegment->imlList[t].crRegister == 8)
-		{
-			return true;
-		}
-	}
-	// for non-BDNZ loops, check for common patterns
-	// risky approach, look for ADD/SUB operations and assume that potential overflow means finite (does not include r_r_s32 ADD/SUB)
-	// this catches most loops with load-update and store-update instructions, but also those with decrementing counters
-	FixedSizeList<sint32, 64, true> list_modifiedRegisters;
-	for (sint32 t = 0; t < imlSegment->imlListCount; t++)
-	{
-		if (imlSegment->imlList[t].type == PPCREC_IML_TYPE_R_S32 && (imlSegment->imlList[t].operation == PPCREC_IML_OP_ADD || imlSegment->imlList[t].operation == PPCREC_IML_OP_SUB) )
-		{
-			list_modifiedRegisters.addUnique(imlSegment->imlList[t].op_r_immS32.registerIndex);
-		}
-	}
-	if (list_modifiedRegisters.count > 0)
-	{
-		// remove all registers from the list that are modified by non-ADD/SUB instructions
-		// todo: We should also cover the case where ADD+SUB on the same register cancel the effect out
-		PPCImlOptimizerUsedRegisters_t registersUsed;
-		for (sint32 t = 0; t < imlSegment->imlListCount; t++)
-		{
-			if (imlSegment->imlList[t].type == PPCREC_IML_TYPE_R_S32 && (imlSegment->imlList[t].operation == PPCREC_IML_OP_ADD || imlSegment->imlList[t].operation == PPCREC_IML_OP_SUB))
-				continue;
-			PPCRecompiler_checkRegisterUsage(NULL, imlSegment->imlList + t, &registersUsed);
-			if(registersUsed.writtenNamedReg1 < 0)
-				continue;
-			list_modifiedRegisters.remove(registersUsed.writtenNamedReg1);
-		}
-		if (list_modifiedRegisters.count > 0)
-		{
-			return true;
-		}
-	}
-	return false;
-}
-
-/*
-* Returns true if the imlInstruction can overwrite CR (depending on value of ->crRegister)
-*/
-bool PPCRecompilerImlAnalyzer_canTypeWriteCR(PPCRecImlInstruction_t* imlInstruction)
-{
-	if (imlInstruction->type == PPCREC_IML_TYPE_R_R)
-		return true;
-	if (imlInstruction->type == PPCREC_IML_TYPE_R_R_R)
-		return true;
-	if (imlInstruction->type == PPCREC_IML_TYPE_R_R_S32)
-		return true;
-	if (imlInstruction->type == PPCREC_IML_TYPE_R_S32)
-		return true;
-	if (imlInstruction->type == PPCREC_IML_TYPE_FPR_R_R)
-		return true;
-	if (imlInstruction->type == PPCREC_IML_TYPE_FPR_R_R_R)
-		return true;
-	if (imlInstruction->type == PPCREC_IML_TYPE_FPR_R_R_R_R)
-		return true;
-	if (imlInstruction->type == PPCREC_IML_TYPE_FPR_R)
-		return true;
-	return false;
-}
-
-void PPCRecompilerImlAnalyzer_getCRTracking(PPCRecImlInstruction_t* imlInstruction, PPCRecCRTracking_t* crTracking)
-{
-	crTracking->readCRBits = 0;
-	crTracking->writtenCRBits = 0;
-	if (imlInstruction->type == PPCREC_IML_TYPE_CJUMP)
-	{
-		if (imlInstruction->op_conditionalJump.condition != PPCREC_JUMP_CONDITION_NONE)
-		{
-			uint32 crBitFlag = 1 << (imlInstruction->op_conditionalJump.crRegisterIndex * 4 + imlInstruction->op_conditionalJump.crBitIndex);
-			crTracking->readCRBits = (crBitFlag);
-		}
-	}
-	else if (imlInstruction->type == PPCREC_IML_TYPE_CONDITIONAL_R_S32)
-	{
-		uint32 crBitFlag = 1 << (imlInstruction->op_conditional_r_s32.crRegisterIndex * 4 + imlInstruction->op_conditional_r_s32.crBitIndex);
-		crTracking->readCRBits = crBitFlag;
-	}
-	else if (imlInstruction->type == PPCREC_IML_TYPE_R_S32 && imlInstruction->operation == PPCREC_IML_OP_MFCR)
-	{
-		crTracking->readCRBits = 0xFFFFFFFF;
-	}
-	else if (imlInstruction->type == PPCREC_IML_TYPE_R_S32 && imlInstruction->operation == PPCREC_IML_OP_MTCRF)
-	{
-		crTracking->writtenCRBits |= ppc_MTCRFMaskToCRBitMask((uint32)imlInstruction->op_r_immS32.immS32);
-	}
-	else if (imlInstruction->type == PPCREC_IML_TYPE_CR)
-	{
-		if (imlInstruction->operation == PPCREC_IML_OP_CR_CLEAR ||
-			imlInstruction->operation == PPCREC_IML_OP_CR_SET)
-		{
-			uint32 crBitFlag = 1 << (imlInstruction->op_cr.crD);
-			crTracking->writtenCRBits = crBitFlag;
-		}
-		else if (imlInstruction->operation == PPCREC_IML_OP_CR_OR ||
-			imlInstruction->operation == PPCREC_IML_OP_CR_ORC ||
-			imlInstruction->operation == PPCREC_IML_OP_CR_AND || 
-			imlInstruction->operation == PPCREC_IML_OP_CR_ANDC)
-		{
-			uint32 crBitFlag = 1 << (imlInstruction->op_cr.crD);
-			crTracking->writtenCRBits = crBitFlag;
-			crBitFlag = 1 << (imlInstruction->op_cr.crA);
-			crTracking->readCRBits = crBitFlag;
-			crBitFlag = 1 << (imlInstruction->op_cr.crB);
-			crTracking->readCRBits |= crBitFlag;
-		}
-		else
-			assert_dbg();
-	}
-	else if (PPCRecompilerImlAnalyzer_canTypeWriteCR(imlInstruction) && imlInstruction->crRegister >= 0 && imlInstruction->crRegister <= 7)
-	{
-		crTracking->writtenCRBits |= (0xF << (imlInstruction->crRegister * 4));
-	}
-	else if ((imlInstruction->type == PPCREC_IML_TYPE_STORE || imlInstruction->type == PPCREC_IML_TYPE_STORE_INDEXED) && imlInstruction->op_storeLoad.copyWidth == PPC_REC_STORE_STWCX_MARKER)
-	{
-		// overwrites CR0
-		crTracking->writtenCRBits |= (0xF << 0);
-	}
-}
diff --git a/src/Cafe/HW/Espresso/Recompiler/PPCRecompilerImlGen.cpp b/src/Cafe/HW/Espresso/Recompiler/PPCRecompilerImlGen.cpp
index 7291ac41..e76a53fa 100644
--- a/src/Cafe/HW/Espresso/Recompiler/PPCRecompilerImlGen.cpp
+++ b/src/Cafe/HW/Espresso/Recompiler/PPCRecompilerImlGen.cpp
@@ -1,563 +1,345 @@
 #include "Cafe/HW/Espresso/Interpreter/PPCInterpreterInternal.h"
 #include "Cafe/HW/Espresso/Interpreter/PPCInterpreterHelper.h"
+#include "Cafe/HW/Espresso/EspressoISA.h"
 #include "PPCRecompiler.h"
 #include "PPCRecompilerIml.h"
-#include "PPCRecompilerX64.h"
-#include "PPCRecompilerImlRanges.h"
-#include "util/helpers/StringBuf.h"
+#include "IML/IML.h"
+#include "IML/IMLRegisterAllocatorRanges.h"
+#include "PPCFunctionBoundaryTracker.h"
+#include "Cafe/OS/libs/coreinit/coreinit_Time.h"
 
 bool PPCRecompiler_decodePPCInstruction(ppcImlGenContext_t* ppcImlGenContext);
-uint32 PPCRecompiler_iterateCurrentInstruction(ppcImlGenContext_t* ppcImlGenContext);
-uint32 PPCRecompiler_getInstructionByOffset(ppcImlGenContext_t* ppcImlGenContext, uint32 offset);
 
-PPCRecImlInstruction_t* PPCRecompilerImlGen_generateNewEmptyInstruction(ppcImlGenContext_t* ppcImlGenContext)
+struct PPCBasicBlockInfo
 {
-	if( ppcImlGenContext->imlListCount+1 > ppcImlGenContext->imlListSize )
+	PPCBasicBlockInfo(uint32 startAddress, const std::set<uint32>& entryAddresses) : startAddress(startAddress), lastAddress(startAddress)
 	{
-		sint32 newSize = ppcImlGenContext->imlListCount*2 + 2;
-		ppcImlGenContext->imlList = (PPCRecImlInstruction_t*)realloc(ppcImlGenContext->imlList, sizeof(PPCRecImlInstruction_t)*newSize);
-		ppcImlGenContext->imlListSize = newSize;
+		isEnterable = entryAddresses.find(startAddress) != entryAddresses.end();
 	}
-	PPCRecImlInstruction_t* imlInstruction = ppcImlGenContext->imlList+ppcImlGenContext->imlListCount;
-	memset(imlInstruction, 0x00, sizeof(PPCRecImlInstruction_t));
-	imlInstruction->crRegister = PPC_REC_INVALID_REGISTER; // dont update any cr register by default
-	imlInstruction->associatedPPCAddress = ppcImlGenContext->ppcAddressOfCurrentInstruction;
-	ppcImlGenContext->imlListCount++;
-	return imlInstruction;
+
+	uint32 startAddress;
+	uint32 lastAddress; // inclusive
+	bool isEnterable{ false };
+	bool hasContinuedFlow{ true }; // non-branch path goes to next segment, assumed by default
+	bool hasBranchTarget{ false };
+	uint32 branchTarget{};
+
+	// associated IML segments
+	IMLSegment* firstSegment{}; // first segment in chain, used as branch target for other segments
+	IMLSegment* appendSegment{}; // last segment in chain, additional instructions should be appended to this segment
+
+	void SetInitialSegment(IMLSegment* seg)
+	{
+		cemu_assert_debug(!firstSegment);
+		cemu_assert_debug(!appendSegment);
+		firstSegment = seg;
+		appendSegment = seg;
+	}
+
+	IMLSegment* GetFirstSegmentInChain()
+	{
+		return firstSegment;
+	}
+
+	IMLSegment* GetSegmentForInstructionAppend()
+	{
+		return appendSegment;
+	}
+};
+
+IMLInstruction* PPCRecompilerImlGen_generateNewEmptyInstruction(ppcImlGenContext_t* ppcImlGenContext)
+{
+	IMLInstruction& inst = ppcImlGenContext->currentOutputSegment->imlList.emplace_back();
+	memset(&inst, 0x00, sizeof(IMLInstruction));
+	return &inst;
 }
 
-void PPCRecompilerImlGen_generateNewInstruction_jumpmark(ppcImlGenContext_t* ppcImlGenContext, uint32 address)
+void PPCRecompilerImlGen_generateNewInstruction_r_memory_indexed(ppcImlGenContext_t* ppcImlGenContext, IMLReg registerDestination, IMLReg registerMemory1, IMLReg registerMemory2, uint32 copyWidth, bool signExtend, bool switchEndian)
 {
-	// no-op that indicates possible destination of a jump
-	PPCRecImlInstruction_t* imlInstruction = PPCRecompilerImlGen_generateNewEmptyInstruction(ppcImlGenContext);
-	imlInstruction->type = PPCREC_IML_TYPE_JUMPMARK;
-	imlInstruction->op_jumpmark.address = address;
-}
-
-void PPCRecompilerImlGen_generateNewInstruction_macro(ppcImlGenContext_t* ppcImlGenContext, uint32 macroId, uint32 param, uint32 param2, uint16 paramU16)
-{
-	// no-op that indicates possible destination of a jump
-	PPCRecImlInstruction_t* imlInstruction = PPCRecompilerImlGen_generateNewEmptyInstruction(ppcImlGenContext);
-	imlInstruction->type = PPCREC_IML_TYPE_MACRO;
-	imlInstruction->operation = macroId;
-	imlInstruction->op_macro.param = param;
-	imlInstruction->op_macro.param2 = param2;
-	imlInstruction->op_macro.paramU16 = paramU16;
-}
-
-/*
- * Generates a marker for Interpreter -> Recompiler entrypoints
- * PPC_ENTER iml instructions have no associated PPC address but the instruction itself has one
- */
-void PPCRecompilerImlGen_generateNewInstruction_ppcEnter(ppcImlGenContext_t* ppcImlGenContext, uint32 ppcAddress)
-{
-	// no-op that indicates possible destination of a jump
-	PPCRecImlInstruction_t* imlInstruction = PPCRecompilerImlGen_generateNewEmptyInstruction(ppcImlGenContext);
-	imlInstruction->type = PPCREC_IML_TYPE_PPC_ENTER;
-	imlInstruction->operation = 0;
-	imlInstruction->op_ppcEnter.ppcAddress = ppcAddress;
-	imlInstruction->op_ppcEnter.x64Offset = 0;
-	imlInstruction->associatedPPCAddress = 0;
-}
-
-void PPCRecompilerImlGen_generateNewInstruction_r_r(ppcImlGenContext_t* ppcImlGenContext, PPCRecImlInstruction_t* imlInstruction, uint32 operation, uint8 registerResult, uint8 registerA, uint8 crRegister, uint8 crMode)
-{
-	// operation with two register operands (e.g. "t0 = t1")
-	if(imlInstruction == NULL)
-		imlInstruction = PPCRecompilerImlGen_generateNewEmptyInstruction(ppcImlGenContext);
-	imlInstruction->type = PPCREC_IML_TYPE_R_R;
-	imlInstruction->operation = operation;
-	imlInstruction->crRegister = crRegister;
-	imlInstruction->crMode = crMode;
-	imlInstruction->op_r_r.registerResult = registerResult;
-	imlInstruction->op_r_r.registerA = registerA;
-}
-
-void PPCRecompilerImlGen_generateNewInstruction_r_r_r(ppcImlGenContext_t* ppcImlGenContext, uint32 operation, uint8 registerResult, uint8 registerA, uint8 registerB, uint8 crRegister=PPC_REC_INVALID_REGISTER, uint8 crMode=0)
-{
-	// operation with three register operands (e.g. "t0 = t1 + t4")
-	PPCRecImlInstruction_t* imlInstruction = PPCRecompilerImlGen_generateNewEmptyInstruction(ppcImlGenContext);
-	imlInstruction->type = PPCREC_IML_TYPE_R_R_R;
-	imlInstruction->operation = operation;
-	imlInstruction->crRegister = crRegister;
-	imlInstruction->crMode = crMode;
-	imlInstruction->op_r_r_r.registerResult = registerResult;
-	imlInstruction->op_r_r_r.registerA = registerA;
-	imlInstruction->op_r_r_r.registerB = registerB;
-}
-
-void PPCRecompilerImlGen_generateNewInstruction_r_r_s32(ppcImlGenContext_t* ppcImlGenContext, uint32 operation, uint8 registerResult, uint8 registerA, sint32 immS32, uint8 crRegister=PPC_REC_INVALID_REGISTER, uint8 crMode=0)
-{
-	// operation with two register operands and one signed immediate (e.g. "t0 = t1 + 1234")
-	PPCRecImlInstruction_t* imlInstruction = PPCRecompilerImlGen_generateNewEmptyInstruction(ppcImlGenContext);
-	imlInstruction->type = PPCREC_IML_TYPE_R_R_S32;
-	imlInstruction->operation = operation;
-	imlInstruction->crRegister = crRegister;
-	imlInstruction->crMode = crMode;
-	imlInstruction->op_r_r_s32.registerResult = registerResult;
-	imlInstruction->op_r_r_s32.registerA = registerA;
-	imlInstruction->op_r_r_s32.immS32 = immS32;
-}
-
-void PPCRecompilerImlGen_generateNewInstruction_name_r(ppcImlGenContext_t* ppcImlGenContext, uint32 operation, uint8 registerIndex, uint32 name, uint32 copyWidth, bool signExtend, bool bigEndian)
-{
-	// Store name (e.g. "'r3' = t0" which translates to MOV [ESP+offset_r3], reg32)
-	PPCRecImlInstruction_t* imlInstruction = PPCRecompilerImlGen_generateNewEmptyInstruction(ppcImlGenContext);
-	imlInstruction->type = PPCREC_IML_TYPE_NAME_R;
-	imlInstruction->operation = operation;
-	imlInstruction->op_r_name.registerIndex = registerIndex;
-	imlInstruction->op_r_name.name = name;
-	imlInstruction->op_r_name.copyWidth = copyWidth;
-	imlInstruction->op_r_name.flags = (signExtend?PPCREC_IML_OP_FLAG_SIGNEXTEND:0)|(bigEndian?PPCREC_IML_OP_FLAG_SWITCHENDIAN:0);
-}
-
-void PPCRecompilerImlGen_generateNewInstruction_r_s32(ppcImlGenContext_t* ppcImlGenContext, uint32 operation, uint8 registerIndex, sint32 immS32, uint32 copyWidth, bool signExtend, bool bigEndian, uint8 crRegister, uint32 crMode)
-{
-	// two variations:
-	// operation without store (e.g. "'r3' < 123" which has no effect other than updating a condition flags register)
-	// operation with store (e.g. "'r3' = 123")
-	PPCRecImlInstruction_t* imlInstruction = PPCRecompilerImlGen_generateNewEmptyInstruction(ppcImlGenContext);
-	imlInstruction->type = PPCREC_IML_TYPE_R_S32;
-	imlInstruction->operation = operation;
-	imlInstruction->crRegister = crRegister;
-	imlInstruction->crMode = crMode;
-	imlInstruction->op_r_immS32.registerIndex = registerIndex;
-	imlInstruction->op_r_immS32.immS32 = immS32;
-}
-
-void PPCRecompilerImlGen_generateNewInstruction_conditional_r_s32(ppcImlGenContext_t* ppcImlGenContext, PPCRecImlInstruction_t* imlInstruction, uint32 operation, uint8 registerIndex, sint32 immS32, uint32 crRegisterIndex, uint32 crBitIndex, bool bitMustBeSet)
-{
-	if(imlInstruction == NULL)
-		imlInstruction = PPCRecompilerImlGen_generateNewEmptyInstruction(ppcImlGenContext);
-	else
-		memset(imlInstruction, 0, sizeof(PPCRecImlInstruction_t));
-	imlInstruction->type = PPCREC_IML_TYPE_CONDITIONAL_R_S32;
-	imlInstruction->operation = operation;
-	imlInstruction->crRegister = PPC_REC_INVALID_REGISTER;
-	// r_s32 operation
-	imlInstruction->op_conditional_r_s32.registerIndex = registerIndex;
-	imlInstruction->op_conditional_r_s32.immS32 = immS32;
-	// condition
-	imlInstruction->op_conditional_r_s32.crRegisterIndex = crRegisterIndex;
-	imlInstruction->op_conditional_r_s32.crBitIndex = crBitIndex;
-	imlInstruction->op_conditional_r_s32.bitMustBeSet = bitMustBeSet;
-}
-
-
-void PPCRecompilerImlGen_generateNewInstruction_jump(ppcImlGenContext_t* ppcImlGenContext, PPCRecImlInstruction_t* imlInstruction, uint32 jumpmarkAddress)
-{
-	// jump
-	if (imlInstruction == NULL)
-		imlInstruction = PPCRecompilerImlGen_generateNewEmptyInstruction(ppcImlGenContext);
-	else
-		memset(imlInstruction, 0, sizeof(PPCRecImlInstruction_t));
-	imlInstruction->type = PPCREC_IML_TYPE_CJUMP;
-	imlInstruction->crRegister = PPC_REC_INVALID_REGISTER;
-	imlInstruction->op_conditionalJump.jumpmarkAddress = jumpmarkAddress;
-	imlInstruction->op_conditionalJump.jumpAccordingToSegment = false;
-	imlInstruction->op_conditionalJump.condition = PPCREC_JUMP_CONDITION_NONE;
-	imlInstruction->op_conditionalJump.crRegisterIndex = 0;
-	imlInstruction->op_conditionalJump.crBitIndex = 0;
-	imlInstruction->op_conditionalJump.bitMustBeSet = false;
-}
-
-// jump based on segment branches
-void PPCRecompilerImlGen_generateNewInstruction_jumpSegment(ppcImlGenContext_t* ppcImlGenContext, PPCRecImlInstruction_t* imlInstruction)
-{
-	// jump
-	if (imlInstruction == NULL)
-		imlInstruction = PPCRecompilerImlGen_generateNewEmptyInstruction(ppcImlGenContext);
-	imlInstruction->associatedPPCAddress = 0;
-	imlInstruction->type = PPCREC_IML_TYPE_CJUMP;
-	imlInstruction->crRegister = PPC_REC_INVALID_REGISTER;
-	imlInstruction->op_conditionalJump.jumpmarkAddress = 0;
-	imlInstruction->op_conditionalJump.jumpAccordingToSegment = true;
-	imlInstruction->op_conditionalJump.condition = PPCREC_JUMP_CONDITION_NONE;
-	imlInstruction->op_conditionalJump.crRegisterIndex = 0;
-	imlInstruction->op_conditionalJump.crBitIndex = 0;
-	imlInstruction->op_conditionalJump.bitMustBeSet = false;
-}
-
-void PPCRecompilerImlGen_generateNewInstruction_noOp(ppcImlGenContext_t* ppcImlGenContext, PPCRecImlInstruction_t* imlInstruction)
-{
-	if (imlInstruction == NULL)
-		imlInstruction = PPCRecompilerImlGen_generateNewEmptyInstruction(ppcImlGenContext);
-	imlInstruction->type = PPCREC_IML_TYPE_NO_OP;
-	imlInstruction->operation = 0;
-	imlInstruction->crRegister = PPC_REC_INVALID_REGISTER;
-	imlInstruction->crMode = 0;
-}
-
-void PPCRecompilerImlGen_generateNewInstruction_cr(ppcImlGenContext_t* ppcImlGenContext, uint32 operation, uint8 crD, uint8 crA, uint8 crB)
-{
-	// multiple variations:
-	// operation involving only one cr bit (like clear crD bit)
-	// operation involving three cr bits (like crD = crA or crB)
-	PPCRecImlInstruction_t* imlInstruction = PPCRecompilerImlGen_generateNewEmptyInstruction(ppcImlGenContext);
-	imlInstruction->type = PPCREC_IML_TYPE_CR;
-	imlInstruction->operation = operation;
-	imlInstruction->crRegister = PPC_REC_INVALID_REGISTER;
-	imlInstruction->crMode = 0;
-	imlInstruction->op_cr.crD = crD;
-	imlInstruction->op_cr.crA = crA;
-	imlInstruction->op_cr.crB = crB;
-}
-
-void PPCRecompilerImlGen_generateNewInstruction_conditionalJump(ppcImlGenContext_t* ppcImlGenContext, uint32 jumpmarkAddress, uint32 jumpCondition, uint32 crRegisterIndex, uint32 crBitIndex, bool bitMustBeSet)
-{
-	// conditional jump
-	PPCRecImlInstruction_t* imlInstruction = PPCRecompilerImlGen_generateNewEmptyInstruction(ppcImlGenContext);
-	imlInstruction->type = PPCREC_IML_TYPE_CJUMP;
-	imlInstruction->crRegister = PPC_REC_INVALID_REGISTER;
-	imlInstruction->op_conditionalJump.jumpmarkAddress = jumpmarkAddress;
-	imlInstruction->op_conditionalJump.condition = jumpCondition;
-	imlInstruction->op_conditionalJump.crRegisterIndex = crRegisterIndex;
-	imlInstruction->op_conditionalJump.crBitIndex = crBitIndex;
-	imlInstruction->op_conditionalJump.bitMustBeSet = bitMustBeSet;
-}
-
-void PPCRecompilerImlGen_generateNewInstruction_r_memory(ppcImlGenContext_t* ppcImlGenContext, uint8 registerDestination, uint8 registerMemory, sint32 immS32, uint32 copyWidth, bool signExtend, bool switchEndian)
-{
-	// load from memory
-	PPCRecImlInstruction_t* imlInstruction = PPCRecompilerImlGen_generateNewEmptyInstruction(ppcImlGenContext);
-	imlInstruction->type = PPCREC_IML_TYPE_LOAD;
-	imlInstruction->operation = 0;
-	imlInstruction->crRegister = PPC_REC_INVALID_REGISTER;
-	imlInstruction->op_storeLoad.registerData = registerDestination;
-	imlInstruction->op_storeLoad.registerMem = registerMemory;
-	imlInstruction->op_storeLoad.immS32 = immS32;
-	imlInstruction->op_storeLoad.copyWidth = copyWidth;
-	//imlInstruction->op_storeLoad.flags = (signExtend ? PPCREC_IML_OP_FLAG_SIGNEXTEND : 0) | (switchEndian ? PPCREC_IML_OP_FLAG_SWITCHENDIAN : 0);
-	imlInstruction->op_storeLoad.flags2.swapEndian = switchEndian;
-	imlInstruction->op_storeLoad.flags2.signExtend = signExtend;
-}
-
-void PPCRecompilerImlGen_generateNewInstruction_r_memory_indexed(ppcImlGenContext_t* ppcImlGenContext, uint8 registerDestination, uint8 registerMemory1, uint8 registerMemory2, uint32 copyWidth, bool signExtend, bool switchEndian)
-{
-	// load from memory
-	PPCRecImlInstruction_t* imlInstruction = PPCRecompilerImlGen_generateNewEmptyInstruction(ppcImlGenContext);
+	cemu_assert_debug(registerMemory1.IsValid());
+	cemu_assert_debug(registerMemory2.IsValid());
+	cemu_assert_debug(registerDestination.IsValid());
+	IMLInstruction* imlInstruction = PPCRecompilerImlGen_generateNewEmptyInstruction(ppcImlGenContext);
 	imlInstruction->type = PPCREC_IML_TYPE_LOAD_INDEXED;
 	imlInstruction->operation = 0;
-	imlInstruction->crRegister = PPC_REC_INVALID_REGISTER;
 	imlInstruction->op_storeLoad.registerData = registerDestination;
 	imlInstruction->op_storeLoad.registerMem = registerMemory1;
 	imlInstruction->op_storeLoad.registerMem2 = registerMemory2;
 	imlInstruction->op_storeLoad.copyWidth = copyWidth;
-	//imlInstruction->op_storeLoad.flags = (signExtend?PPCREC_IML_OP_FLAG_SIGNEXTEND:0)|(switchEndian?PPCREC_IML_OP_FLAG_SWITCHENDIAN:0);
 	imlInstruction->op_storeLoad.flags2.swapEndian = switchEndian;
 	imlInstruction->op_storeLoad.flags2.signExtend = signExtend;
 }
 
-void PPCRecompilerImlGen_generateNewInstruction_memory_r(ppcImlGenContext_t* ppcImlGenContext, uint8 registerSource, uint8 registerMemory, sint32 immS32, uint32 copyWidth, bool switchEndian)
+void PPCRecompilerImlGen_generateNewInstruction_memory_r_indexed(ppcImlGenContext_t* ppcImlGenContext, IMLReg registerDestination, IMLReg registerMemory1, IMLReg registerMemory2, uint32 copyWidth, bool signExtend, bool switchEndian)
 {
-	// load from memory
-	PPCRecImlInstruction_t* imlInstruction = PPCRecompilerImlGen_generateNewEmptyInstruction(ppcImlGenContext);
-	imlInstruction->type = PPCREC_IML_TYPE_STORE;
-	imlInstruction->operation = 0;
-	imlInstruction->crRegister = PPC_REC_INVALID_REGISTER;
-	imlInstruction->op_storeLoad.registerData = registerSource;
-	imlInstruction->op_storeLoad.registerMem = registerMemory;
-	imlInstruction->op_storeLoad.immS32 = immS32;
-	imlInstruction->op_storeLoad.copyWidth = copyWidth;
-	//imlInstruction->op_storeLoad.flags = (switchEndian?PPCREC_IML_OP_FLAG_SWITCHENDIAN:0);
-	imlInstruction->op_storeLoad.flags2.swapEndian = switchEndian;
-	imlInstruction->op_storeLoad.flags2.signExtend = false;
-}
-
-void PPCRecompilerImlGen_generateNewInstruction_memory_r_indexed(ppcImlGenContext_t* ppcImlGenContext, uint8 registerDestination, uint8 registerMemory1, uint8 registerMemory2, uint32 copyWidth, bool signExtend, bool switchEndian)
-{
-	// load from memory
-	PPCRecImlInstruction_t* imlInstruction = PPCRecompilerImlGen_generateNewEmptyInstruction(ppcImlGenContext);
+	cemu_assert_debug(registerMemory1.IsValid());
+	cemu_assert_debug(registerMemory2.IsValid());
+	cemu_assert_debug(registerDestination.IsValid());
+	IMLInstruction* imlInstruction = PPCRecompilerImlGen_generateNewEmptyInstruction(ppcImlGenContext);
 	imlInstruction->type = PPCREC_IML_TYPE_STORE_INDEXED;
 	imlInstruction->operation = 0;
-	imlInstruction->crRegister = PPC_REC_INVALID_REGISTER;
 	imlInstruction->op_storeLoad.registerData = registerDestination;
 	imlInstruction->op_storeLoad.registerMem = registerMemory1;
 	imlInstruction->op_storeLoad.registerMem2 = registerMemory2;
 	imlInstruction->op_storeLoad.copyWidth = copyWidth;
-	//imlInstruction->op_storeLoad.flags = (signExtend?PPCREC_IML_OP_FLAG_SIGNEXTEND:0)|(switchEndian?PPCREC_IML_OP_FLAG_SWITCHENDIAN:0);
 	imlInstruction->op_storeLoad.flags2.swapEndian = switchEndian;
 	imlInstruction->op_storeLoad.flags2.signExtend = signExtend;
 }
 
-void PPCRecompilerImlGen_generateNewInstruction_memory_memory(ppcImlGenContext_t* ppcImlGenContext, PPCRecImlInstruction_t* imlInstruction, uint8 srcMemReg, sint32 srcImmS32, uint8 dstMemReg, sint32 dstImmS32, uint8 copyWidth)
+// create and fill two segments (branch taken and branch not taken) as a follow up to the current segment and then merge flow afterwards
+void PPCIMLGen_CreateSegmentBranchedPath(ppcImlGenContext_t& ppcImlGenContext, PPCBasicBlockInfo& basicBlockInfo, const std::function<void(ppcImlGenContext_t&)>& genSegmentBranchTaken, const std::function<void(ppcImlGenContext_t&)>& genSegmentBranchNotTaken)
 {
-	// copy from memory to memory
-	if(imlInstruction == NULL)
-		imlInstruction = PPCRecompilerImlGen_generateNewEmptyInstruction(ppcImlGenContext);
-	imlInstruction->type = PPCREC_IML_TYPE_MEM2MEM;
-	imlInstruction->operation = 0;
-	imlInstruction->crRegister = PPC_REC_INVALID_REGISTER;
-	imlInstruction->op_mem2mem.src.registerMem = srcMemReg;
-	imlInstruction->op_mem2mem.src.immS32 = srcImmS32;
-	imlInstruction->op_mem2mem.dst.registerMem = dstMemReg;
-	imlInstruction->op_mem2mem.dst.immS32 = dstImmS32;
-	imlInstruction->op_mem2mem.copyWidth = copyWidth;
+	IMLSegment* currentWriteSegment = basicBlockInfo.GetSegmentForInstructionAppend();
+
+	std::span<IMLSegment*> segments = ppcImlGenContext.InsertSegments(ppcImlGenContext.GetSegmentIndex(currentWriteSegment) + 1, 3);
+	IMLSegment* segBranchNotTaken = segments[0];
+	IMLSegment* segBranchTaken = segments[1];
+	IMLSegment* segMerge = segments[2];
+
+	// link the segments
+	segMerge->SetLinkBranchTaken(currentWriteSegment->GetBranchTaken());
+	segMerge->SetLinkBranchNotTaken(currentWriteSegment->GetBranchNotTaken());
+	currentWriteSegment->SetLinkBranchTaken(segBranchTaken);
+	currentWriteSegment->SetLinkBranchNotTaken(segBranchNotTaken);
+	segBranchTaken->SetLinkBranchNotTaken(segMerge);
+	segBranchNotTaken->SetLinkBranchTaken(segMerge);
+	// generate code for branch taken segment
+	ppcImlGenContext.currentOutputSegment = segBranchTaken;
+	genSegmentBranchTaken(ppcImlGenContext);
+	cemu_assert_debug(ppcImlGenContext.currentOutputSegment == segBranchTaken);
+	// generate code for branch not taken segment
+	ppcImlGenContext.currentOutputSegment = segBranchNotTaken;
+	genSegmentBranchNotTaken(ppcImlGenContext);
+	cemu_assert_debug(ppcImlGenContext.currentOutputSegment == segBranchNotTaken);
+	ppcImlGenContext.emitInst().make_jump();
+	// make merge segment the new write segment
+	ppcImlGenContext.currentOutputSegment = segMerge;
+	basicBlockInfo.appendSegment = segMerge;
 }
 
-uint32 PPCRecompilerImlGen_getAndLockFreeTemporaryGPR(ppcImlGenContext_t* ppcImlGenContext, uint32 mappedName)
+void PPCIMLGen_CreateSegmentBranchedPath(ppcImlGenContext_t& ppcImlGenContext, PPCBasicBlockInfo& basicBlockInfo, const std::function<void(ppcImlGenContext_t&)>& genSegmentBranchNotTaken)
 {
-	if( mappedName == PPCREC_NAME_NONE )
+	IMLSegment* currentWriteSegment = basicBlockInfo.GetSegmentForInstructionAppend();
+
+	std::span<IMLSegment*> segments = ppcImlGenContext.InsertSegments(ppcImlGenContext.GetSegmentIndex(currentWriteSegment) + 1, 2);
+	IMLSegment* segBranchNotTaken = segments[0];
+	IMLSegment* segMerge = segments[1];
+
+	// link the segments
+	segMerge->SetLinkBranchTaken(currentWriteSegment->GetBranchTaken());
+	segMerge->SetLinkBranchNotTaken(currentWriteSegment->GetBranchNotTaken());
+	currentWriteSegment->SetLinkBranchTaken(segMerge);
+	currentWriteSegment->SetLinkBranchNotTaken(segBranchNotTaken);
+	segBranchNotTaken->SetLinkBranchNotTaken(segMerge);
+	// generate code for branch not taken segment
+	ppcImlGenContext.currentOutputSegment = segBranchNotTaken;
+	genSegmentBranchNotTaken(ppcImlGenContext);
+	cemu_assert_debug(ppcImlGenContext.currentOutputSegment == segBranchNotTaken);
+	// make merge segment the new write segment
+	ppcImlGenContext.currentOutputSegment = segMerge;
+	basicBlockInfo.appendSegment = segMerge;
+}
+
+IMLReg _GetRegTemporaryS8(ppcImlGenContext_t* ppcImlGenContext, uint32 index);
+
+IMLRedirectInstOutput::IMLRedirectInstOutput(ppcImlGenContext_t* ppcImlGenContext, IMLSegment* outputSegment) : m_context(ppcImlGenContext)
+{
+	m_prevSegment = ppcImlGenContext->currentOutputSegment;
+	cemu_assert_debug(ppcImlGenContext->currentOutputSegment == ppcImlGenContext->currentBasicBlock->appendSegment);
+	if (outputSegment == ppcImlGenContext->currentOutputSegment)
 	{
-		debug_printf("PPCRecompilerImlGen_getAndLockFreeTemporaryGPR(): Invalid mappedName parameter\n");
-		return PPC_REC_INVALID_REGISTER;
+		m_prevSegment = nullptr;
+		return;
 	}
-	for(uint32 i=0; i<(PPC_REC_MAX_VIRTUAL_GPR-1); i++)
+	m_context->currentBasicBlock->appendSegment = outputSegment;
+	m_context->currentOutputSegment = outputSegment;
+}
+
+IMLRedirectInstOutput::~IMLRedirectInstOutput()
+{
+	if (m_prevSegment)
 	{
-		if( ppcImlGenContext->mappedRegister[i] == PPCREC_NAME_NONE )
+		m_context->currentBasicBlock->appendSegment = m_prevSegment;
+		m_context->currentOutputSegment = m_prevSegment;
+	}
+}
+
+// compare values and branch to segment with same index in segmentsOut. The last segment doesn't actually have any comparison and just is the default case. Thus compareValues is one shorter than count
+void PPCIMLGen_CreateSegmentBranchedPathMultiple(ppcImlGenContext_t& ppcImlGenContext, PPCBasicBlockInfo& basicBlockInfo, IMLSegment** segmentsOut, IMLReg compareReg, sint32* compareValues, sint32 count, sint32 defaultCaseIndex)
+{
+	IMLSegment* currentWriteSegment = basicBlockInfo.GetSegmentForInstructionAppend();
+	cemu_assert_debug(!currentWriteSegment->HasSuffixInstruction()); // must not already have a suffix instruction
+
+	const sint32 numBranchSegments = count + 1;
+	const sint32 numCaseSegments = count;
+
+	std::span<IMLSegment*> segments = ppcImlGenContext.InsertSegments(ppcImlGenContext.GetSegmentIndex(currentWriteSegment) + 1, numBranchSegments - 1 + numCaseSegments + 1);
+	IMLSegment** extraBranchSegments = segments.data();
+	IMLSegment** caseSegments = segments.data() + numBranchSegments - 1;
+	IMLSegment* mergeSegment = segments[numBranchSegments - 1 + numCaseSegments];
+
+	// move links to the merge segment
+	mergeSegment->SetLinkBranchTaken(currentWriteSegment->GetBranchTaken());
+	mergeSegment->SetLinkBranchNotTaken(currentWriteSegment->GetBranchNotTaken());
+	currentWriteSegment->SetLinkBranchTaken(nullptr);
+	currentWriteSegment->SetLinkBranchNotTaken(nullptr);
+
+	for (sint32 i=0; i<numCaseSegments; i++)
+		segmentsOut[i] = caseSegments[i];
+
+	IMLReg tmpBoolReg = _GetRegTemporaryS8(&ppcImlGenContext, 2);
+
+	// the first branch segment is the original current write segment
+	auto GetBranchSegment = [&](sint32 index) {
+		if (index == 0)
+			return currentWriteSegment;
+		else
+			return extraBranchSegments[index - 1];
+	};
+	// link branch segments (taken: Link to case segment. NotTaken: Link to next branch segment. For the last one use a non-conditional jump)
+	for (sint32 i=0; i<numBranchSegments; i++)
+	{
+		IMLSegment* seg = GetBranchSegment(i);
+		if (i < numBranchSegments - 1)
 		{
-			ppcImlGenContext->mappedRegister[i] = mappedName;
-			return i;
+			cemu_assert_debug(i < numCaseSegments);
+			seg->SetLinkBranchTaken(caseSegments[i]);
+			seg->SetLinkBranchNotTaken(GetBranchSegment(i + 1));
+			seg->AppendInstruction()->make_compare_s32(compareReg, compareValues[i], tmpBoolReg, IMLCondition::EQ);
+			seg->AppendInstruction()->make_conditional_jump(tmpBoolReg, true);
+		}
+		else
+		{
+			cemu_assert_debug(defaultCaseIndex < numCaseSegments);
+			seg->SetLinkBranchTaken(caseSegments[defaultCaseIndex]);
+			seg->AppendInstruction()->make_jump();
 		}
 	}
+	// link case segments
+	for (sint32 i=0; i<numCaseSegments; i++)
+	{
+		IMLSegment* seg = caseSegments[i];
+		if (i < numCaseSegments - 1)
+		{
+			seg->SetLinkBranchTaken(mergeSegment);
+			// -> Jumps are added after the instructions
+		}
+		else
+		{
+			seg->SetLinkBranchTaken(mergeSegment);
+		}
+	}
+	ppcImlGenContext.currentOutputSegment = mergeSegment;
+	basicBlockInfo.appendSegment = mergeSegment;
+}
+
+IMLReg PPCRecompilerImlGen_LookupReg(ppcImlGenContext_t* ppcImlGenContext, IMLName mappedName, IMLRegFormat regFormat)
+{
+	auto it = ppcImlGenContext->mappedRegs.find(mappedName);
+	if (it != ppcImlGenContext->mappedRegs.end())
+		return it->second;
+	// create new reg entry
+	IMLRegFormat baseFormat;
+	if (regFormat == IMLRegFormat::F64)
+		baseFormat = IMLRegFormat::F64;
+	else if (regFormat == IMLRegFormat::I32)
+		baseFormat = IMLRegFormat::I64;
+	else
+	{
+		cemu_assert_suspicious();
+	}
+	IMLRegID newRegId = ppcImlGenContext->mappedRegs.size();
+	IMLReg newReg(baseFormat, regFormat, 0, newRegId);
+	ppcImlGenContext->mappedRegs.try_emplace(mappedName, newReg);
+	return newReg;
+}
+
+IMLName PPCRecompilerImlGen_GetRegName(ppcImlGenContext_t* ppcImlGenContext, IMLReg reg)
+{
+	for (auto& it : ppcImlGenContext->mappedRegs)
+	{
+		if (it.second.GetRegID() == reg.GetRegID())
+			return it.first;
+	}
+	cemu_assert(false);
 	return 0;
 }
 
-uint32 PPCRecompilerImlGen_findRegisterByMappedName(ppcImlGenContext_t* ppcImlGenContext, uint32 mappedName)
-{
-	for(uint32 i=0; i< PPC_REC_MAX_VIRTUAL_GPR; i++)
-	{
-		if( ppcImlGenContext->mappedRegister[i] == mappedName )
-		{
-			return i;
-		}
-	}
-	return PPC_REC_INVALID_REGISTER;
-}
-
 uint32 PPCRecompilerImlGen_getAndLockFreeTemporaryFPR(ppcImlGenContext_t* ppcImlGenContext, uint32 mappedName)
 {
-	if( mappedName == PPCREC_NAME_NONE )
-	{
-		debug_printf("PPCRecompilerImlGen_getAndLockFreeTemporaryFPR(): Invalid mappedName parameter\n");
-		return PPC_REC_INVALID_REGISTER;
-	}
-	for(uint32 i=0; i<255; i++)
-	{
-		if( ppcImlGenContext->mappedFPRRegister[i] == PPCREC_NAME_NONE )
-		{
-			ppcImlGenContext->mappedFPRRegister[i] = mappedName;
-			return i;
-		}
-	}
+	DEBUG_BREAK;
+	//if( mappedName == PPCREC_NAME_NONE )
+	//{
+	//	debug_printf("PPCRecompilerImlGen_getAndLockFreeTemporaryFPR(): Invalid mappedName parameter\n");
+	//	return PPC_REC_INVALID_REGISTER;
+	//}
+	//for(uint32 i=0; i<255; i++)
+	//{
+	//	if( ppcImlGenContext->mappedFPRRegister[i] == PPCREC_NAME_NONE )
+	//	{
+	//		ppcImlGenContext->mappedFPRRegister[i] = mappedName;
+	//		return i;
+	//	}
+	//}
 	return 0;
 }
 
 uint32 PPCRecompilerImlGen_findFPRRegisterByMappedName(ppcImlGenContext_t* ppcImlGenContext, uint32 mappedName)
 {
-	for(uint32 i=0; i<255; i++)
-	{
-		if( ppcImlGenContext->mappedFPRRegister[i] == mappedName )
-		{
-			return i;
-		}
-	}
+	DEBUG_BREAK;
+	//for(uint32 i=0; i<255; i++)
+	//{
+	//	if( ppcImlGenContext->mappedFPRRegister[i] == mappedName )
+	//	{
+	//		return i;
+	//	}
+	//}
 	return PPC_REC_INVALID_REGISTER;
 }
 
-/*
- * Loads a PPC gpr into any of the available IML registers
- * If loadNew is false, it will reuse already loaded instances
- */
-uint32 PPCRecompilerImlGen_loadRegister(ppcImlGenContext_t* ppcImlGenContext, uint32 mappedName, bool loadNew)
+IMLReg PPCRecompilerImlGen_loadRegister(ppcImlGenContext_t* ppcImlGenContext, uint32 mappedName)
 {
-	if( loadNew == false )
-	{
-		uint32 loadedRegisterIndex = PPCRecompilerImlGen_findRegisterByMappedName(ppcImlGenContext, mappedName);
-		if( loadedRegisterIndex != PPC_REC_INVALID_REGISTER )
-			return loadedRegisterIndex;
-	}
-	uint32 registerIndex = PPCRecompilerImlGen_getAndLockFreeTemporaryGPR(ppcImlGenContext, mappedName);
-	return registerIndex;
+	return PPCRecompilerImlGen_LookupReg(ppcImlGenContext, mappedName, IMLRegFormat::I32);
 }
 
-/*
- * Reuse already loaded register if present
- * Otherwise create new IML register and map the name. The register contents will be undefined
- */
-uint32 PPCRecompilerImlGen_loadOverwriteRegister(ppcImlGenContext_t* ppcImlGenContext, uint32 mappedName)
+IMLReg _GetRegGPR(ppcImlGenContext_t* ppcImlGenContext, uint32 index)
 {
-	uint32 loadedRegisterIndex = PPCRecompilerImlGen_findRegisterByMappedName(ppcImlGenContext, mappedName);
-	if( loadedRegisterIndex != PPC_REC_INVALID_REGISTER )
-		return loadedRegisterIndex;
-	uint32 registerIndex = PPCRecompilerImlGen_getAndLockFreeTemporaryGPR(ppcImlGenContext, mappedName);
-	return registerIndex;
+	cemu_assert_debug(index < 32);
+	return PPCRecompilerImlGen_loadRegister(ppcImlGenContext, PPCREC_NAME_R0 + index);
 }
 
-/*
- * Loads a PPC fpr into any of the available IML FPU registers
- * If loadNew is false, it will check first if the fpr is already loaded into any IML register
- */
-uint32 PPCRecompilerImlGen_loadFPRRegister(ppcImlGenContext_t* ppcImlGenContext, uint32 mappedName, bool loadNew)
+IMLReg _GetRegCR(ppcImlGenContext_t* ppcImlGenContext, uint32 index)
 {
-	if( loadNew == false )
-	{
-		uint32 loadedRegisterIndex = PPCRecompilerImlGen_findFPRRegisterByMappedName(ppcImlGenContext, mappedName);
-		if( loadedRegisterIndex != PPC_REC_INVALID_REGISTER )
-			return loadedRegisterIndex;
-	}
-	uint32 registerIndex = PPCRecompilerImlGen_getAndLockFreeTemporaryFPR(ppcImlGenContext, mappedName);
-	return registerIndex;
+	cemu_assert_debug(index < 32);
+	return PPCRecompilerImlGen_loadRegister(ppcImlGenContext, PPCREC_NAME_CR + index);
 }
 
-/*
- * Checks if a PPC fpr register is already loaded into any IML register
- * If no, it will create a new undefined temporary IML FPU register and map the name (effectively overwriting the old ppc register)
- */
-uint32 PPCRecompilerImlGen_loadOverwriteFPRRegister(ppcImlGenContext_t* ppcImlGenContext, uint32 mappedName)
+IMLReg _GetRegCR(ppcImlGenContext_t* ppcImlGenContext, uint8 crReg, uint8 crBit)
 {
-	uint32 loadedRegisterIndex = PPCRecompilerImlGen_findFPRRegisterByMappedName(ppcImlGenContext, mappedName);
-	if( loadedRegisterIndex != PPC_REC_INVALID_REGISTER )
-		return loadedRegisterIndex;
-	uint32 registerIndex = PPCRecompilerImlGen_getAndLockFreeTemporaryFPR(ppcImlGenContext, mappedName);
-	return registerIndex;
+	cemu_assert_debug(crReg < 8);
+	cemu_assert_debug(crBit < 4);
+	return _GetRegCR(ppcImlGenContext, (crReg * 4) + crBit);
 }
 
-void PPCRecompilerImlGen_TW(ppcImlGenContext_t* ppcImlGenContext, uint32 opcode)
+IMLReg _GetRegTemporary(ppcImlGenContext_t* ppcImlGenContext, uint32 index)
 {
-//#ifndef PUBLIC_RELEASE
-//	PPCRecompilerImlGen_generateNewInstruction_macro(ppcImlGenContext, PPCREC_IML_MACRO_DEBUGBREAK, ppcImlGenContext->ppcAddressOfCurrentInstruction, 0, 0);
-//#endif
-	PPCRecompilerImlGen_generateNewInstruction_macro(ppcImlGenContext, PPCREC_IML_MACRO_LEAVE, ppcImlGenContext->ppcAddressOfCurrentInstruction, 0, 0);
+	cemu_assert_debug(index < 4);
+	return PPCRecompilerImlGen_loadRegister(ppcImlGenContext, PPCREC_NAME_TEMPORARY + index);
 }
 
-bool PPCRecompilerImlGen_MTSPR(ppcImlGenContext_t* ppcImlGenContext, uint32 opcode)
+// get throw-away register
+// be careful to not collide with other temporary register
+IMLReg _GetRegTemporaryS8(ppcImlGenContext_t* ppcImlGenContext, uint32 index)
 {
-	uint32 rD, spr1, spr2, spr;
-	PPC_OPC_TEMPL_XO(opcode, rD, spr1, spr2);
-	spr = spr1 | (spr2<<5);
-	if (spr == SPR_CTR || spr == SPR_LR)
-	{
-		uint32 gprReg = PPCRecompilerImlGen_findRegisterByMappedName(ppcImlGenContext, PPCREC_NAME_R0 + rD);
-		if (gprReg == PPC_REC_INVALID_REGISTER)
-			gprReg = PPCRecompilerImlGen_loadRegister(ppcImlGenContext, PPCREC_NAME_R0 + rD);
-		uint32 sprReg = PPCRecompilerImlGen_loadOverwriteRegister(ppcImlGenContext, PPCREC_NAME_SPR0 + spr);
-		PPCRecompilerImlGen_generateNewInstruction_r_r(ppcImlGenContext, NULL, PPCREC_IML_OP_ASSIGN, sprReg, gprReg);
-	}
-	else if (spr >= SPR_UGQR0 && spr <= SPR_UGQR7)
-	{
-		uint32 gprReg = PPCRecompilerImlGen_findRegisterByMappedName(ppcImlGenContext, PPCREC_NAME_R0 + rD);
-		if (gprReg == PPC_REC_INVALID_REGISTER)
-			gprReg = PPCRecompilerImlGen_loadRegister(ppcImlGenContext, PPCREC_NAME_R0 + rD);
-		uint32 sprReg = PPCRecompilerImlGen_loadOverwriteRegister(ppcImlGenContext, PPCREC_NAME_SPR0 + spr);
-		PPCRecompilerImlGen_generateNewInstruction_r_r(ppcImlGenContext, NULL, PPCREC_IML_OP_ASSIGN, sprReg, gprReg);
-		ppcImlGenContext->tracking.modifiesGQR[spr - SPR_UGQR0] = true;
-	}
-	else
-		return false;
-	return true;
-}
-
-bool PPCRecompilerImlGen_MFSPR(ppcImlGenContext_t* ppcImlGenContext, uint32 opcode)
-{
-	uint32 rD, spr1, spr2, spr;
-	PPC_OPC_TEMPL_XO(opcode, rD, spr1, spr2);
-	spr = spr1 | (spr2<<5);
-	if (spr == SPR_LR || spr == SPR_CTR)
-	{
-		uint32 sprReg = PPCRecompilerImlGen_loadRegister(ppcImlGenContext, PPCREC_NAME_SPR0 + spr);
-		uint32 gprReg = PPCRecompilerImlGen_loadOverwriteRegister(ppcImlGenContext, PPCREC_NAME_R0 + rD);
-		PPCRecompilerImlGen_generateNewInstruction_r_r(ppcImlGenContext, NULL, PPCREC_IML_OP_ASSIGN, gprReg, sprReg);
-	}
-	else if (spr >= SPR_UGQR0 && spr <= SPR_UGQR7)
-	{
-		uint32 sprReg = PPCRecompilerImlGen_loadRegister(ppcImlGenContext, PPCREC_NAME_SPR0 + spr);
-		uint32 gprReg = PPCRecompilerImlGen_loadOverwriteRegister(ppcImlGenContext, PPCREC_NAME_R0 + rD);
-		PPCRecompilerImlGen_generateNewInstruction_r_r(ppcImlGenContext, NULL, PPCREC_IML_OP_ASSIGN, gprReg, sprReg);
-	}
-	else
-		return false;
-	return true;
-}
-
-bool PPCRecompilerImlGen_MFTB(ppcImlGenContext_t* ppcImlGenContext, uint32 opcode)
-{
-	uint32 rD, spr1, spr2, spr;
-	PPC_OPC_TEMPL_XO(opcode, rD, spr1, spr2);
-	spr = spr1 | (spr2<<5);
-	
-	if (spr == 268 || spr == 269)
-	{
-		// TBL / TBU
-		uint32 param2 = spr | (rD << 16);
-		PPCRecompilerImlGen_generateNewInstruction_macro(ppcImlGenContext, PPCREC_IML_MACRO_MFTB, ppcImlGenContext->ppcAddressOfCurrentInstruction, param2, 0);
-		return true;
-	}
-	return false;
-}
-
-bool PPCRecompilerImlGen_MFCR(ppcImlGenContext_t* ppcImlGenContext, uint32 opcode)
-{
-	sint32 rD, rA, rB;
-	PPC_OPC_TEMPL_X(opcode, rD, rA, rB);
-	uint32 gprReg = PPCRecompilerImlGen_loadOverwriteRegister(ppcImlGenContext, PPCREC_NAME_R0 + rD);
-	PPCRecompilerImlGen_generateNewInstruction_r_s32(ppcImlGenContext, PPCREC_IML_OP_MFCR, gprReg, 0, 0, false, false, PPC_REC_INVALID_REGISTER, 0);
-	return true;
-}
-
-bool PPCRecompilerImlGen_MTCRF(ppcImlGenContext_t* ppcImlGenContext, uint32 opcode)
-{
-	uint32 rS;
-	uint32 crMask;
-	PPC_OPC_TEMPL_XFX(opcode, rS, crMask);
-	uint32 gprReg = PPCRecompilerImlGen_loadOverwriteRegister(ppcImlGenContext, PPCREC_NAME_R0 + rS);
-	PPCRecompilerImlGen_generateNewInstruction_r_s32(ppcImlGenContext, PPCREC_IML_OP_MTCRF, gprReg, crMask, 0, false, false, PPC_REC_INVALID_REGISTER, 0);
-	return true;
-}
-
-void PPCRecompilerImlGen_CMP(ppcImlGenContext_t* ppcImlGenContext, uint32 opcode)
-{
-	uint32 cr;
-	int rA, rB;
-	PPC_OPC_TEMPL_X(opcode, cr, rA, rB);
-	cr >>= 2;
-	uint32 gprRegisterA = PPCRecompilerImlGen_loadRegister(ppcImlGenContext, PPCREC_NAME_R0+rA, false);
-	uint32 gprRegisterB = PPCRecompilerImlGen_loadRegister(ppcImlGenContext, PPCREC_NAME_R0+rB, false);
-	PPCRecompilerImlGen_generateNewInstruction_r_r(ppcImlGenContext, NULL, PPCREC_IML_OP_COMPARE_SIGNED, gprRegisterA, gprRegisterB, cr, PPCREC_CR_MODE_COMPARE_SIGNED);
-}
-
-void PPCRecompilerImlGen_CMPL(ppcImlGenContext_t* ppcImlGenContext, uint32 opcode)
-{
-	uint32 cr;
-	int rA, rB;
-	PPC_OPC_TEMPL_X(opcode, cr, rA, rB);
-	cr >>= 2;
-	uint32 gprRegisterA = PPCRecompilerImlGen_loadRegister(ppcImlGenContext, PPCREC_NAME_R0+rA, false);
-	uint32 gprRegisterB = PPCRecompilerImlGen_loadRegister(ppcImlGenContext, PPCREC_NAME_R0+rB, false);
-	PPCRecompilerImlGen_generateNewInstruction_r_r(ppcImlGenContext, NULL, PPCREC_IML_OP_COMPARE_UNSIGNED, gprRegisterA, gprRegisterB, cr, PPCREC_CR_MODE_COMPARE_UNSIGNED);
-}
-
-void PPCRecompilerImlGen_CMPI(ppcImlGenContext_t* ppcImlGenContext, uint32 opcode)
-{
-	uint32 cr;
-	int rA;
-	uint32 imm;
-	PPC_OPC_TEMPL_D_SImm(opcode, cr, rA, imm);
-	cr >>= 2;
-	sint32 b = imm;
-	// load gpr into register
-	uint32 gprRegister = PPCRecompilerImlGen_loadRegister(ppcImlGenContext, PPCREC_NAME_R0+rA, false);
-	PPCRecompilerImlGen_generateNewInstruction_r_s32(ppcImlGenContext, PPCREC_IML_OP_COMPARE_SIGNED, gprRegister, b, 0, false, false, cr, PPCREC_CR_MODE_COMPARE_SIGNED);
-}
-
-void PPCRecompilerImlGen_CMPLI(ppcImlGenContext_t* ppcImlGenContext, uint32 opcode)
-{
-	uint32 cr;
-	int rA;
-	uint32 imm;
-	PPC_OPC_TEMPL_D_UImm(opcode, cr, rA, imm);
-	cr >>= 2;
-	uint32 b = imm;
-	// load gpr into register
-	uint32 gprRegister = PPCRecompilerImlGen_loadRegister(ppcImlGenContext, PPCREC_NAME_R0+rA, false);
-	PPCRecompilerImlGen_generateNewInstruction_r_s32(ppcImlGenContext, PPCREC_IML_OP_COMPARE_UNSIGNED, gprRegister, (sint32)b, 0, false, false, cr, PPCREC_CR_MODE_COMPARE_UNSIGNED);
+	cemu_assert_debug(index < 4);
+	return PPCRecompilerImlGen_loadRegister(ppcImlGenContext, PPCREC_NAME_TEMPORARY + index);
 }
 
 bool PPCRecompiler_canInlineFunction(MPTR functionPtr, sint32* functionInstructionCount)
 {
 	for (sint32 i = 0; i < 6; i++)
 	{
-		uint32 opcode = memory_readU32(functionPtr+i*4);
+		uint32 opcode = memory_readU32(functionPtr + i * 4);
 		switch ((opcode >> 26))
 		{
 		case 14: // ADDI
@@ -611,18 +393,220 @@ void PPCRecompiler_generateInlinedCode(ppcImlGenContext_t* ppcImlGenContext, uin
 {
 	for (sint32 i = 0; i < instructionCount; i++)
 	{
-		ppcImlGenContext->ppcAddressOfCurrentInstruction = startAddress + i*4;
+		ppcImlGenContext->ppcAddressOfCurrentInstruction = startAddress + i * 4;
 		ppcImlGenContext->cyclesSinceLastBranch++;
 		if (PPCRecompiler_decodePPCInstruction(ppcImlGenContext))
 		{
-			assert_dbg();
+			cemu_assert_suspicious();
 		}
 	}
 	// add range
-	ppcRecRange_t recRange;
-	recRange.ppcAddress = startAddress;
-	recRange.ppcSize = instructionCount*4 + 4; // + 4 because we have to include the BLR
-	ppcImlGenContext->functionRef->list_ranges.push_back(recRange);
+	cemu_assert_unimplemented();
+	//ppcRecRange_t recRange;
+	//recRange.ppcAddress = startAddress;
+	//recRange.ppcSize = instructionCount*4 + 4; // + 4 because we have to include the BLR
+	//ppcImlGenContext->functionRef->list_ranges.push_back(recRange);
+}
+
+// for handling RC bit of many instructions
+void PPCImlGen_UpdateCR0(ppcImlGenContext_t* ppcImlGenContext, IMLReg regR)
+{
+	IMLReg crBitRegLT = _GetRegCR(ppcImlGenContext, 0, Espresso::CR_BIT::CR_BIT_INDEX_LT);
+	IMLReg crBitRegGT = _GetRegCR(ppcImlGenContext, 0, Espresso::CR_BIT::CR_BIT_INDEX_GT);
+	IMLReg crBitRegEQ = _GetRegCR(ppcImlGenContext, 0, Espresso::CR_BIT::CR_BIT_INDEX_EQ);
+	// todo - SO bit
+
+	ppcImlGenContext->emitInst().make_compare_s32(regR, 0, crBitRegLT, IMLCondition::SIGNED_LT);
+	ppcImlGenContext->emitInst().make_compare_s32(regR, 0, crBitRegGT, IMLCondition::SIGNED_GT);
+	ppcImlGenContext->emitInst().make_compare_s32(regR, 0, crBitRegEQ, IMLCondition::EQ);
+
+	//ppcImlGenContext->emitInst().make_r_s32(PPCREC_IML_OP_ASSIGN, crBitRegSO, 0); // todo - copy from XER
+
+	//ppcImlGenContext->emitInst().make_r_r(PPCREC_IML_OP_ASSIGN, registerR, registerR, 0, PPCREC_CR_MODE_LOGICAL);
+}
+
+void PPCRecompilerImlGen_TW(ppcImlGenContext_t* ppcImlGenContext, uint32 opcode)
+{
+	// split before and after to make sure the macro is in an isolated segment that we can make enterable
+	PPCIMLGen_CreateSplitSegmentAtEnd(*ppcImlGenContext, *ppcImlGenContext->currentBasicBlock);
+	ppcImlGenContext->currentOutputSegment->SetEnterable(ppcImlGenContext->ppcAddressOfCurrentInstruction);
+	PPCRecompilerImlGen_generateNewEmptyInstruction(ppcImlGenContext)->make_macro(PPCREC_IML_MACRO_LEAVE, ppcImlGenContext->ppcAddressOfCurrentInstruction, 0, 0, IMLREG_INVALID);
+	IMLSegment* middleSeg = PPCIMLGen_CreateSplitSegmentAtEnd(*ppcImlGenContext, *ppcImlGenContext->currentBasicBlock);
+	middleSeg->SetLinkBranchTaken(nullptr);
+	middleSeg->SetLinkBranchNotTaken(nullptr);
+}
+
+bool PPCRecompilerImlGen_MTSPR(ppcImlGenContext_t* ppcImlGenContext, uint32 opcode)
+{
+	uint32 rD, spr1, spr2, spr;
+	PPC_OPC_TEMPL_XO(opcode, rD, spr1, spr2);
+	spr = spr1 | (spr2<<5);
+	IMLReg gprReg = _GetRegGPR(ppcImlGenContext, rD);
+	if (spr == SPR_CTR || spr == SPR_LR)
+	{
+		IMLReg sprReg = PPCRecompilerImlGen_loadRegister(ppcImlGenContext, PPCREC_NAME_SPR0 + spr);
+		ppcImlGenContext->emitInst().make_r_r(PPCREC_IML_OP_ASSIGN, sprReg, gprReg);
+	}
+	else if (spr >= SPR_UGQR0 && spr <= SPR_UGQR7)
+	{
+		IMLReg sprReg = PPCRecompilerImlGen_loadRegister(ppcImlGenContext, PPCREC_NAME_SPR0 + spr);
+		ppcImlGenContext->emitInst().make_r_r(PPCREC_IML_OP_ASSIGN, sprReg, gprReg);
+		ppcImlGenContext->tracking.modifiesGQR[spr - SPR_UGQR0] = true;
+	}
+	else
+		return false;
+	return true;
+}
+
+bool PPCRecompilerImlGen_MFSPR(ppcImlGenContext_t* ppcImlGenContext, uint32 opcode)
+{
+	uint32 rD, spr1, spr2, spr;
+	PPC_OPC_TEMPL_XO(opcode, rD, spr1, spr2);
+	spr = spr1 | (spr2<<5);
+	IMLReg gprReg = _GetRegGPR(ppcImlGenContext, rD);
+	if (spr == SPR_LR || spr == SPR_CTR)
+	{
+		IMLReg sprReg = PPCRecompilerImlGen_loadRegister(ppcImlGenContext, PPCREC_NAME_SPR0 + spr);
+		ppcImlGenContext->emitInst().make_r_r(PPCREC_IML_OP_ASSIGN, gprReg, sprReg);
+	}
+	else if (spr >= SPR_UGQR0 && spr <= SPR_UGQR7)
+	{
+		IMLReg sprReg = PPCRecompilerImlGen_loadRegister(ppcImlGenContext, PPCREC_NAME_SPR0 + spr);
+		ppcImlGenContext->emitInst().make_r_r(PPCREC_IML_OP_ASSIGN, gprReg, sprReg);
+	}
+	else
+		return false;
+	return true;
+}
+
+ATTR_MS_ABI uint32 PPCRecompiler_GetTBL()
+{
+	return (uint32)coreinit::OSGetSystemTime();
+}
+
+ATTR_MS_ABI uint32 PPCRecompiler_GetTBU()
+{
+	return (uint32)(coreinit::OSGetSystemTime() >> 32);
+}
+
+bool PPCRecompilerImlGen_MFTB(ppcImlGenContext_t* ppcImlGenContext, uint32 opcode)
+{
+	uint32 rD, spr1, spr2, spr;
+	PPC_OPC_TEMPL_XO(opcode, rD, spr1, spr2);
+	spr = spr1 | (spr2<<5);
+
+	if( spr == SPR_TBL || spr == SPR_TBU )
+	{
+		IMLReg resultReg = _GetRegGPR(ppcImlGenContext, rD);
+		ppcImlGenContext->emitInst().make_call_imm(spr == SPR_TBL ? (uintptr_t)PPCRecompiler_GetTBL : (uintptr_t)PPCRecompiler_GetTBU, IMLREG_INVALID, IMLREG_INVALID, IMLREG_INVALID, resultReg);
+		return true;
+	}
+	return false;
+}
+
+void PPCRecompilerImlGen_MCRF(ppcImlGenContext_t* ppcImlGenContext, uint32 opcode)
+{
+	uint32 crD, crS, b;
+	PPC_OPC_TEMPL_X(opcode, crD, crS, b);
+	cemu_assert_debug((crD&3) == 0);
+	cemu_assert_debug((crS&3) == 0);
+	crD >>= 2;
+	crS >>= 2;
+	for (sint32 i = 0; i<4; i++)
+	{
+		IMLReg regCrSrcBit = _GetRegCR(ppcImlGenContext, crS * 4 + i);
+		IMLReg regCrDstBit = _GetRegCR(ppcImlGenContext, crD * 4 + i);
+		ppcImlGenContext->emitInst().make_r_r(PPCREC_IML_OP_ASSIGN, regCrDstBit, regCrSrcBit);
+	}
+}
+
+bool PPCRecompilerImlGen_MFCR(ppcImlGenContext_t* ppcImlGenContext, uint32 opcode)
+{
+	sint32 rD, rA, rB;
+	PPC_OPC_TEMPL_X(opcode, rD, rA, rB);
+	IMLReg regD = _GetRegGPR(ppcImlGenContext, rD);
+	ppcImlGenContext->emitInst().make_r_s32(PPCREC_IML_OP_ASSIGN, regD, 0);
+	for (sint32 i = 0; i < 32; i++)
+	{
+		IMLReg regCrBit = _GetRegCR(ppcImlGenContext, i);
+		cemu_assert_debug(regCrBit.GetRegFormat() == IMLRegFormat::I32); // addition is only allowed between same-format regs
+		ppcImlGenContext->emitInst().make_r_r_s32(PPCREC_IML_OP_LEFT_SHIFT, regD, regD, 1);
+		ppcImlGenContext->emitInst().make_r_r_r(PPCREC_IML_OP_ADD, regD, regD, regCrBit);
+	}
+	return true;
+}
+
+bool PPCRecompilerImlGen_MTCRF(ppcImlGenContext_t* ppcImlGenContext, uint32 opcode)
+{
+	uint32 rS;
+	uint32 crMask;
+	PPC_OPC_TEMPL_XFX(opcode, rS, crMask);
+	IMLReg regS = _GetRegGPR(ppcImlGenContext, rS);
+	IMLReg regTmp = _GetRegTemporary(ppcImlGenContext, 0);
+	uint32 crBitMask = ppc_MTCRFMaskToCRBitMask(crMask);
+	for (sint32 f = 0; f < 32; f++)
+	{
+		if(((crBitMask >> f) & 1) == 0)
+			continue;
+		IMLReg regCrBit = _GetRegCR(ppcImlGenContext, f);
+		cemu_assert_debug(regCrBit.GetRegFormat() == IMLRegFormat::I32);
+		ppcImlGenContext->emitInst().make_r_r_s32(PPCREC_IML_OP_RIGHT_SHIFT_U, regTmp, regS, (31-f));
+		ppcImlGenContext->emitInst().make_r_r_s32(PPCREC_IML_OP_AND, regCrBit, regTmp, 1);
+	}
+	return true;
+}
+
+void PPCRecompilerImlGen_CMP(ppcImlGenContext_t* ppcImlGenContext, uint32 opcode, bool isUnsigned)
+{
+	uint32 cr;
+	int rA, rB;
+	PPC_OPC_TEMPL_X(opcode, cr, rA, rB);
+	cr >>= 2;
+
+	IMLReg gprRegisterA = _GetRegGPR(ppcImlGenContext, rA);
+	IMLReg gprRegisterB = _GetRegGPR(ppcImlGenContext, rB);
+	IMLReg regXerSO = PPCRecompilerImlGen_loadRegister(ppcImlGenContext, PPCREC_NAME_XER_SO);
+
+	IMLReg crBitRegLT = _GetRegCR(ppcImlGenContext, cr, Espresso::CR_BIT::CR_BIT_INDEX_LT);
+	IMLReg crBitRegGT = _GetRegCR(ppcImlGenContext, cr, Espresso::CR_BIT::CR_BIT_INDEX_GT);
+	IMLReg crBitRegEQ = _GetRegCR(ppcImlGenContext, cr, Espresso::CR_BIT::CR_BIT_INDEX_EQ);
+	IMLReg crBitRegSO = _GetRegCR(ppcImlGenContext, cr, Espresso::CR_BIT::CR_BIT_INDEX_SO);
+
+	ppcImlGenContext->emitInst().make_compare(gprRegisterA, gprRegisterB, crBitRegLT, isUnsigned ? IMLCondition::UNSIGNED_LT : IMLCondition::SIGNED_LT);
+	ppcImlGenContext->emitInst().make_compare(gprRegisterA, gprRegisterB, crBitRegGT, isUnsigned ? IMLCondition::UNSIGNED_GT : IMLCondition::SIGNED_GT);
+	ppcImlGenContext->emitInst().make_compare(gprRegisterA, gprRegisterB, crBitRegEQ, IMLCondition::EQ);
+	ppcImlGenContext->emitInst().make_r_r(PPCREC_IML_OP_ASSIGN, crBitRegSO, regXerSO);
+}
+
+bool PPCRecompilerImlGen_CMPI(ppcImlGenContext_t* ppcImlGenContext, uint32 opcode, bool isUnsigned)
+{
+	uint32 cr;
+	int rA;
+	uint32 imm;
+	if (isUnsigned)
+	{
+		PPC_OPC_TEMPL_D_UImm(opcode, cr, rA, imm);
+	}
+	else
+	{
+		PPC_OPC_TEMPL_D_SImm(opcode, cr, rA, imm);
+	}
+	cr >>= 2;
+
+	IMLReg regA = _GetRegGPR(ppcImlGenContext, rA);
+	IMLReg regXerSO = PPCRecompilerImlGen_loadRegister(ppcImlGenContext, PPCREC_NAME_XER_SO);
+
+	IMLReg crBitRegLT = _GetRegCR(ppcImlGenContext, cr, Espresso::CR_BIT::CR_BIT_INDEX_LT);
+	IMLReg crBitRegGT = _GetRegCR(ppcImlGenContext, cr, Espresso::CR_BIT::CR_BIT_INDEX_GT);
+	IMLReg crBitRegEQ = _GetRegCR(ppcImlGenContext, cr, Espresso::CR_BIT::CR_BIT_INDEX_EQ);
+	IMLReg crBitRegSO = _GetRegCR(ppcImlGenContext, cr, Espresso::CR_BIT::CR_BIT_INDEX_SO);
+
+	ppcImlGenContext->emitInst().make_compare_s32(regA, (sint32)imm, crBitRegLT, isUnsigned ? IMLCondition::UNSIGNED_LT : IMLCondition::SIGNED_LT);
+	ppcImlGenContext->emitInst().make_compare_s32(regA, (sint32)imm, crBitRegGT, isUnsigned ? IMLCondition::UNSIGNED_GT : IMLCondition::SIGNED_GT);
+	ppcImlGenContext->emitInst().make_compare_s32(regA, (sint32)imm, crBitRegEQ, IMLCondition::EQ);
+	ppcImlGenContext->emitInst().make_r_r(PPCREC_IML_OP_ASSIGN, crBitRegSO, regXerSO);
+
+	return true;
 }
 
 bool PPCRecompilerImlGen_B(ppcImlGenContext_t* ppcImlGenContext, uint32 opcode)
@@ -637,43 +621,26 @@ bool PPCRecompilerImlGen_B(ppcImlGenContext_t* ppcImlGenContext, uint32 opcode)
 	if( opcode&PPC_OPC_LK )
 	{
 		// function call
-		// check if function can be inlined
-		sint32 inlineFuncInstructionCount = 0;
-		if (PPCRecompiler_canInlineFunction(jumpAddressDest, &inlineFuncInstructionCount))
-		{
-			// generate NOP iml instead of BL macro (this assures that segment PPC range remains intact)
-			PPCRecompilerImlGen_generateNewInstruction_noOp(ppcImlGenContext, NULL);
-			//forceLog_printf("Inline func 0x%08x at %08x", jumpAddressDest, ppcImlGenContext->ppcAddressOfCurrentInstruction);
-			uint32* prevInstructionPtr = ppcImlGenContext->currentInstruction;
-			ppcImlGenContext->currentInstruction = (uint32*)memory_getPointerFromVirtualOffset(jumpAddressDest);
-			PPCRecompiler_generateInlinedCode(ppcImlGenContext, jumpAddressDest, inlineFuncInstructionCount);
-			ppcImlGenContext->currentInstruction = prevInstructionPtr;
-			return true;
-		}
-		// generate funtion call instructions
-		PPCRecompilerImlGen_generateNewInstruction_macro(ppcImlGenContext, PPCREC_IML_MACRO_BL, ppcImlGenContext->ppcAddressOfCurrentInstruction, jumpAddressDest, ppcImlGenContext->cyclesSinceLastBranch);
-		PPCRecompilerImlGen_generateNewInstruction_ppcEnter(ppcImlGenContext, ppcImlGenContext->ppcAddressOfCurrentInstruction+4);
+		ppcImlGenContext->emitInst().make_macro(PPCREC_IML_MACRO_BL, ppcImlGenContext->ppcAddressOfCurrentInstruction, jumpAddressDest, ppcImlGenContext->cyclesSinceLastBranch, IMLREG_INVALID);
 		return true;
 	}
 	// is jump destination within recompiled function?
-	if( jumpAddressDest >= ppcImlGenContext->functionRef->ppcAddress && jumpAddressDest < (ppcImlGenContext->functionRef->ppcAddress + ppcImlGenContext->functionRef->ppcSize) )
-	{
-		// generate instruction
-		PPCRecompilerImlGen_generateNewInstruction_jump(ppcImlGenContext, NULL, jumpAddressDest);
-	}
+	if (ppcImlGenContext->boundaryTracker->ContainsAddress(jumpAddressDest))
+		ppcImlGenContext->emitInst().make_jump();
 	else
-	{
-		// todo: Inline this jump destination if possible (in many cases it's a bunch of GPR/FPR store instructions + BLR)
-		PPCRecompilerImlGen_generateNewInstruction_macro(ppcImlGenContext, PPCREC_IML_MACRO_B_FAR, ppcImlGenContext->ppcAddressOfCurrentInstruction, jumpAddressDest, ppcImlGenContext->cyclesSinceLastBranch);
-	}
+		ppcImlGenContext->emitInst().make_macro(PPCREC_IML_MACRO_B_FAR, ppcImlGenContext->ppcAddressOfCurrentInstruction, jumpAddressDest, ppcImlGenContext->cyclesSinceLastBranch, IMLREG_INVALID);
 	return true;
 }
 
 bool PPCRecompilerImlGen_BC(ppcImlGenContext_t* ppcImlGenContext, uint32 opcode)
 {
+	PPCIMLGen_AssertIfNotLastSegmentInstruction(*ppcImlGenContext);
+
 	uint32 BO, BI, BD;
 	PPC_OPC_TEMPL_B(opcode, BO, BI, BD);
 
+	Espresso::BOField boField(BO);
+
 	uint32 crRegister = BI/4;
 	uint32 crBit = BI%4;
 	uint32 jumpCondition = 0;
@@ -682,6 +649,10 @@ bool PPCRecompilerImlGen_BC(ppcImlGenContext_t* ppcImlGenContext, uint32 opcode)
 	bool decrementerMustBeZero = (BO&2)!=0; // bit set -> branch if CTR = 0, bit not set -> branch if CTR != 0
 	bool ignoreCondition = (BO&16)!=0;
 
+	IMLReg regCRBit;
+	if (!ignoreCondition)
+		regCRBit = _GetRegCR(ppcImlGenContext, crRegister, crBit);
+
 	uint32 jumpAddressDest = BD;
 	if( (opcode&PPC_OPC_AA) == 0 )
 	{
@@ -690,37 +661,15 @@ bool PPCRecompilerImlGen_BC(ppcImlGenContext_t* ppcImlGenContext, uint32 opcode)
 
 	if( opcode&PPC_OPC_LK )
 	{
+		if (useDecrementer)
+			return false;
 		// conditional function calls are not supported
 		if( ignoreCondition == false )
 		{
-			// generate jump condition
-			if( conditionMustBeTrue )
-			{
-				if( crBit == 0 )
-					jumpCondition = PPCREC_JUMP_CONDITION_GE;
-				else if( crBit == 1 )
-					jumpCondition = PPCREC_JUMP_CONDITION_LE;
-				else if( crBit == 2 )
-					jumpCondition = PPCREC_JUMP_CONDITION_NE;
-				else if( crBit == 3 )
-					jumpCondition = PPCREC_JUMP_CONDITION_NSUMMARYOVERFLOW;
-			}
-			else
-			{
-				if( crBit == 0 )
-					jumpCondition = PPCREC_JUMP_CONDITION_L;
-				else if( crBit == 1 )
-					jumpCondition = PPCREC_JUMP_CONDITION_G;
-				else if( crBit == 2 )
-					jumpCondition = PPCREC_JUMP_CONDITION_E;
-				else if( crBit == 3 )
-					jumpCondition = PPCREC_JUMP_CONDITION_SUMMARYOVERFLOW;
-			}
-			// generate instruction
-			//PPCRecompilerImlGen_generateNewInstruction_macro(ppcImlGenContext, PPCREC_IML_MACRO_DEBUGBREAK, ppcImlGenContext->ppcAddressOfCurrentInstruction, 0, 0);
-			PPCRecompilerImlGen_generateNewInstruction_conditionalJump(ppcImlGenContext, ppcImlGenContext->ppcAddressOfCurrentInstruction+4, jumpCondition, crRegister, crBit, !conditionMustBeTrue);
-			PPCRecompilerImlGen_generateNewInstruction_macro(ppcImlGenContext, PPCREC_IML_MACRO_BL, ppcImlGenContext->ppcAddressOfCurrentInstruction, jumpAddressDest, ppcImlGenContext->cyclesSinceLastBranch);
-			PPCRecompilerImlGen_generateNewInstruction_ppcEnter(ppcImlGenContext, ppcImlGenContext->ppcAddressOfCurrentInstruction+4);
+			PPCBasicBlockInfo* currentBasicBlock = ppcImlGenContext->currentBasicBlock;
+			IMLSegment* blSeg = PPCIMLGen_CreateNewSegmentAsBranchTarget(*ppcImlGenContext, *currentBasicBlock);
+			ppcImlGenContext->emitInst().make_conditional_jump(regCRBit, conditionMustBeTrue);
+			blSeg->AppendInstruction()->make_macro(PPCREC_IML_MACRO_BL, ppcImlGenContext->ppcAddressOfCurrentInstruction, jumpAddressDest, ppcImlGenContext->cyclesSinceLastBranch, IMLREG_INVALID);
 			return true;
 		}
 		return false;
@@ -730,12 +679,11 @@ bool PPCRecompilerImlGen_BC(ppcImlGenContext_t* ppcImlGenContext, uint32 opcode)
 	{
 		if( ignoreCondition == false )
 			return false; // not supported for the moment
-		uint32 ctrRegister = PPCRecompilerImlGen_loadRegister(ppcImlGenContext, PPCREC_NAME_SPR0+SPR_CTR, false);
-		PPCRecompilerImlGen_generateNewInstruction_r_s32(ppcImlGenContext, PPCREC_IML_OP_SUB, ctrRegister, 1, 0, false, false, PPCREC_CR_REG_TEMP, PPCREC_CR_MODE_ARITHMETIC);
-		if( decrementerMustBeZero )
-			PPCRecompilerImlGen_generateNewInstruction_conditionalJump(ppcImlGenContext, jumpAddressDest, PPCREC_JUMP_CONDITION_E, PPCREC_CR_REG_TEMP, 0, false);
-		else
-			PPCRecompilerImlGen_generateNewInstruction_conditionalJump(ppcImlGenContext, jumpAddressDest, PPCREC_JUMP_CONDITION_NE, PPCREC_CR_REG_TEMP, 0, false);
+		IMLReg ctrRegister = PPCRecompilerImlGen_loadRegister(ppcImlGenContext, PPCREC_NAME_SPR0+SPR_CTR);
+		IMLReg tmpBoolReg = _GetRegTemporaryS8(ppcImlGenContext, 1);
+		ppcImlGenContext->emitInst().make_r_r_s32(PPCREC_IML_OP_SUB, ctrRegister, ctrRegister, 1);
+		ppcImlGenContext->emitInst().make_compare_s32(ctrRegister, 0, tmpBoolReg, decrementerMustBeZero ? IMLCondition::EQ : IMLCondition::NEQ);
+		ppcImlGenContext->emitInst().make_conditional_jump(tmpBoolReg, true);
 		return true;
 	}
 	else
@@ -743,219 +691,90 @@ bool PPCRecompilerImlGen_BC(ppcImlGenContext_t* ppcImlGenContext, uint32 opcode)
 		if( ignoreCondition )
 		{
 			// branch always, no condition and no decrementer
-			debugBreakpoint();
-			crRegister = PPC_REC_INVALID_REGISTER; // not necessary but lets optimizer know we dont care for cr register on this instruction
+			// not supported
+			return false;
 		}
 		else
 		{
-			// generate jump condition
-			if( conditionMustBeTrue )
-			{
-				if( crBit == 0 )
-					jumpCondition = PPCREC_JUMP_CONDITION_GE;
-				else if( crBit == 1 )
-					jumpCondition = PPCREC_JUMP_CONDITION_LE;
-				else if( crBit == 2 )
-					jumpCondition = PPCREC_JUMP_CONDITION_NE;
-				else if( crBit == 3 )
-					jumpCondition = PPCREC_JUMP_CONDITION_NSUMMARYOVERFLOW;
-			}
-			else
-			{
-				if( crBit == 0 )
-					jumpCondition = PPCREC_JUMP_CONDITION_L;
-				else if( crBit == 1 )
-					jumpCondition = PPCREC_JUMP_CONDITION_G;
-				else if( crBit == 2 )
-					jumpCondition = PPCREC_JUMP_CONDITION_E;
-				else if( crBit == 3 )
-					jumpCondition = PPCREC_JUMP_CONDITION_SUMMARYOVERFLOW;
-			}
-
-			if (jumpAddressDest >= ppcImlGenContext->functionRef->ppcAddress && jumpAddressDest < (ppcImlGenContext->functionRef->ppcAddress + ppcImlGenContext->functionRef->ppcSize))
+			if (ppcImlGenContext->boundaryTracker->ContainsAddress(jumpAddressDest))
 			{
 				// near jump
-				PPCRecompilerImlGen_generateNewInstruction_conditionalJump(ppcImlGenContext, jumpAddressDest, jumpCondition, crRegister, crBit, conditionMustBeTrue);
+				ppcImlGenContext->emitInst().make_conditional_jump(regCRBit, conditionMustBeTrue);
 			}
 			else
 			{
 				// far jump
-				PPCRecompilerImlGen_generateNewInstruction_conditionalJump(ppcImlGenContext, ppcImlGenContext->ppcAddressOfCurrentInstruction + 4, jumpCondition, crRegister, crBit, !conditionMustBeTrue);
-				PPCRecompilerImlGen_generateNewInstruction_macro(ppcImlGenContext, PPCREC_IML_MACRO_B_FAR, ppcImlGenContext->ppcAddressOfCurrentInstruction, jumpAddressDest, ppcImlGenContext->cyclesSinceLastBranch);
-				PPCRecompilerImlGen_generateNewInstruction_ppcEnter(ppcImlGenContext, ppcImlGenContext->ppcAddressOfCurrentInstruction + 4);
+				debug_printf("PPCRecompilerImlGen_BC(): Far jump not supported yet");
+				return false;
 			}
 		}
 	}
 	return true;
 }
 
-bool PPCRecompilerImlGen_BCLR(ppcImlGenContext_t* ppcImlGenContext, uint32 opcode)
+// BCCTR or BCLR
+bool PPCRecompilerImlGen_BCSPR(ppcImlGenContext_t* ppcImlGenContext, uint32 opcode, uint32 sprReg)
 {
-	uint32 BO, BI, BD;
-	PPC_OPC_TEMPL_XL(opcode, BO, BI, BD);
+	PPCIMLGen_AssertIfNotLastSegmentInstruction(*ppcImlGenContext);
 
+	Espresso::BOField BO;
+	uint32 BI;
+	bool LK;
+	Espresso::decodeOp_BCSPR(opcode, BO, BI, LK);
 	uint32 crRegister = BI/4;
 	uint32 crBit = BI%4;
 
-	uint32 jumpCondition = 0;
+	IMLReg regCRBit;
+	if (!BO.conditionIgnore())
+		regCRBit = _GetRegCR(ppcImlGenContext, crRegister, crBit);
 
-	bool conditionMustBeTrue = (BO&8)!=0;
-	bool useDecrementer = (BO&4)==0; // bit not set -> decrement
-	bool decrementerMustBeZero = (BO&2)!=0; // bit set -> branch if CTR = 0, bit not set -> branch if CTR != 0
-	bool ignoreCondition = (BO&16)!=0;
-	bool saveLR = (opcode&PPC_OPC_LK)!=0;
-	// since we skip this instruction if the condition is true, we need to invert the logic
-	bool invertedConditionMustBeTrue = !conditionMustBeTrue;
-	if( useDecrementer )
+	IMLReg branchDestReg = PPCRecompilerImlGen_loadRegister(ppcImlGenContext, PPCREC_NAME_SPR0 + sprReg);
+	if (LK)
 	{
-		cemu_assert_debug(false);
-		return false; // unsupported
+		if (sprReg == SPR_LR)
+		{
+			// if the branch target is LR, then preserve it in a temporary
+			cemu_assert_suspicious(); // this case needs testing
+			IMLReg tmpRegister = PPCRecompilerImlGen_loadRegister(ppcImlGenContext, PPCREC_NAME_TEMPORARY);
+			ppcImlGenContext->emitInst().make_r_r(PPCREC_IML_OP_ASSIGN, tmpRegister, branchDestReg);
+			branchDestReg = tmpRegister;
+		}
+		IMLReg registerLR = PPCRecompilerImlGen_loadRegister(ppcImlGenContext, PPCREC_NAME_SPR0 + SPR_LR);
+		ppcImlGenContext->emitInst().make_r_s32(PPCREC_IML_OP_ASSIGN, registerLR, ppcImlGenContext->ppcAddressOfCurrentInstruction + 4);
+	}
+
+	if (!BO.decrementerIgnore())
+	{
+		cemu_assert_unimplemented();
+		return false;
+	}
+	else if (!BO.conditionIgnore())
+	{
+		// no decrementer but CR check
+		cemu_assert_debug(ppcImlGenContext->currentBasicBlock->hasContinuedFlow);
+		cemu_assert_debug(!ppcImlGenContext->currentBasicBlock->hasBranchTarget);
+		PPCBasicBlockInfo* currentBasicBlock = ppcImlGenContext->currentBasicBlock;
+		IMLSegment* bctrSeg = PPCIMLGen_CreateNewSegmentAsBranchTarget(*ppcImlGenContext, *currentBasicBlock);
+		ppcImlGenContext->emitInst().make_conditional_jump(regCRBit, !BO.conditionInverted());
+		bctrSeg->AppendInstruction()->make_macro(PPCREC_IML_MACRO_B_TO_REG, 0, 0, 0, branchDestReg);
 	}
 	else
 	{
-		if( ignoreCondition )
-		{
-			// store LR
-			if( saveLR )
-			{
-				PPCRecompilerImlGen_generateNewInstruction_macro(ppcImlGenContext, PPCREC_IML_MACRO_BLRL, ppcImlGenContext->ppcAddressOfCurrentInstruction, 0, ppcImlGenContext->cyclesSinceLastBranch);
-				PPCRecompilerImlGen_generateNewInstruction_ppcEnter(ppcImlGenContext, ppcImlGenContext->ppcAddressOfCurrentInstruction+4);
-			}
-			else
-			{
-				// branch always, no condition and no decrementer
-				PPCRecompilerImlGen_generateNewInstruction_macro(ppcImlGenContext, PPCREC_IML_MACRO_BLR, ppcImlGenContext->ppcAddressOfCurrentInstruction, 0, ppcImlGenContext->cyclesSinceLastBranch);
-			}
-		}
-		else
-		{
-			// store LR
-			if( saveLR )
-			{
-				uint32 registerLR = PPCRecompilerImlGen_loadOverwriteRegister(ppcImlGenContext, PPCREC_NAME_SPR0+SPR_LR);
-				PPCRecompilerImlGen_generateNewInstruction_r_s32(ppcImlGenContext, PPCREC_IML_OP_ASSIGN, registerLR, (ppcImlGenContext->ppcAddressOfCurrentInstruction+4)&0x7FFFFFFF, 0, false, false, PPC_REC_INVALID_REGISTER, 0);
-			}
-			// generate jump condition
-			if( invertedConditionMustBeTrue )
-			{
-				if( crBit == 0 )
-					jumpCondition = PPCREC_JUMP_CONDITION_L;
-				else if( crBit == 1 )
-					jumpCondition = PPCREC_JUMP_CONDITION_G;
-				else if( crBit == 2 )
-					jumpCondition = PPCREC_JUMP_CONDITION_E;
-				else if( crBit == 3 )
-					jumpCondition = PPCREC_JUMP_CONDITION_SUMMARYOVERFLOW;
-			}
-			else
-			{
-				if( crBit == 0 )
-					jumpCondition = PPCREC_JUMP_CONDITION_GE;
-				else if( crBit == 1 )
-					jumpCondition = PPCREC_JUMP_CONDITION_LE;
-				else if( crBit == 2 )
-					jumpCondition = PPCREC_JUMP_CONDITION_NE;
-				else if( crBit == 3 )
-					jumpCondition = PPCREC_JUMP_CONDITION_NSUMMARYOVERFLOW;
-			}
-			// jump if BCLR condition NOT met (jump to jumpmark of next instruction, essentially skipping current instruction)
-			PPCRecompilerImlGen_generateNewInstruction_conditionalJump(ppcImlGenContext, ppcImlGenContext->ppcAddressOfCurrentInstruction+4, jumpCondition, crRegister, crBit, invertedConditionMustBeTrue);
-			PPCRecompilerImlGen_generateNewInstruction_macro(ppcImlGenContext, PPCREC_IML_MACRO_BLR, ppcImlGenContext->ppcAddressOfCurrentInstruction, 0, ppcImlGenContext->cyclesSinceLastBranch);
-		}
-	}
-	return true;
-}
-
-bool PPCRecompilerImlGen_BCCTR(ppcImlGenContext_t* ppcImlGenContext, uint32 opcode)
-{
-	uint32 BO, BI, BD;
-	PPC_OPC_TEMPL_XL(opcode, BO, BI, BD);
-
-	uint32 crRegister = BI/4;
-	uint32 crBit = BI%4;
-
-	uint32 jumpCondition = 0;
-
-	bool conditionMustBeTrue = (BO&8)!=0;
-	bool useDecrementer = (BO&4)==0; // bit not set -> decrement
-	bool decrementerMustBeZero = (BO&2)!=0; // bit set -> branch if CTR = 0, bit not set -> branch if CTR != 0
-	bool ignoreCondition = (BO&16)!=0;
-	bool saveLR = (opcode&PPC_OPC_LK)!=0;
-	// since we skip this instruction if the condition is true, we need to invert the logic
-	bool invertedConditionMustBeTrue = !conditionMustBeTrue;
-	if( useDecrementer )
-	{
-		assert_dbg();
-		// if added, dont forget inverted logic
-		debug_printf("Rec: BCLR unsupported decrementer\n");
-		return false; // unsupported
-	}
-	else
-	{
-		if( ignoreCondition )
-		{
-			// store LR
-			if( saveLR )
-			{
-				uint32 registerLR = PPCRecompilerImlGen_loadOverwriteRegister(ppcImlGenContext, PPCREC_NAME_SPR0+SPR_LR);
-				PPCRecompilerImlGen_generateNewInstruction_r_s32(ppcImlGenContext, PPCREC_IML_OP_ASSIGN, registerLR, (ppcImlGenContext->ppcAddressOfCurrentInstruction+4)&0x7FFFFFFF, 0, false, false, PPC_REC_INVALID_REGISTER, 0);
-				PPCRecompilerImlGen_generateNewInstruction_macro(ppcImlGenContext, PPCREC_IML_MACRO_BCTRL, ppcImlGenContext->ppcAddressOfCurrentInstruction, 0, ppcImlGenContext->cyclesSinceLastBranch);
-				PPCRecompilerImlGen_generateNewInstruction_ppcEnter(ppcImlGenContext, ppcImlGenContext->ppcAddressOfCurrentInstruction+4);
-			}
-			else
-			{
-				// branch always, no condition and no decrementer
-				PPCRecompilerImlGen_generateNewInstruction_macro(ppcImlGenContext, PPCREC_IML_MACRO_BCTR, ppcImlGenContext->ppcAddressOfCurrentInstruction, 0, ppcImlGenContext->cyclesSinceLastBranch);
-			}
-		}
-		else
-		{
-			// store LR
-			if( saveLR )
-			{
-				uint32 registerLR = PPCRecompilerImlGen_loadOverwriteRegister(ppcImlGenContext, PPCREC_NAME_SPR0+SPR_LR);
-				PPCRecompilerImlGen_generateNewInstruction_r_s32(ppcImlGenContext, PPCREC_IML_OP_ASSIGN, registerLR, (ppcImlGenContext->ppcAddressOfCurrentInstruction+4)&0x7FFFFFFF, 0, false, false, PPC_REC_INVALID_REGISTER, 0);
-			}
-			// generate jump condition
-			if( invertedConditionMustBeTrue )
-			{
-				if( crBit == 0 )
-					jumpCondition = PPCREC_JUMP_CONDITION_L;
-				else if( crBit == 1 )
-					jumpCondition = PPCREC_JUMP_CONDITION_G;
-				else if( crBit == 2 )
-					jumpCondition = PPCREC_JUMP_CONDITION_E;
-				else if( crBit == 3 )
-					jumpCondition = PPCREC_JUMP_CONDITION_SUMMARYOVERFLOW;
-			}
-			else
-			{
-				if( crBit == 0 )
-					jumpCondition = PPCREC_JUMP_CONDITION_GE;
-				else if( crBit == 1 )
-					jumpCondition = PPCREC_JUMP_CONDITION_LE;
-				else if( crBit == 2 )
-					jumpCondition = PPCREC_JUMP_CONDITION_NE;
-				else if( crBit == 3 )
-					jumpCondition = PPCREC_JUMP_CONDITION_NSUMMARYOVERFLOW;
-			}
-			// jump if BCLR condition NOT met (jump to jumpmark of next instruction, essentially skipping current instruction)
-			PPCRecompilerImlGen_generateNewInstruction_conditionalJump(ppcImlGenContext, ppcImlGenContext->ppcAddressOfCurrentInstruction+4, jumpCondition, crRegister, crBit, invertedConditionMustBeTrue);
-			PPCRecompilerImlGen_generateNewInstruction_macro(ppcImlGenContext, PPCREC_IML_MACRO_BCTR, ppcImlGenContext->ppcAddressOfCurrentInstruction, 0, ppcImlGenContext->cyclesSinceLastBranch);
-		}
+		// branch always, no condition and no decrementer check
+		cemu_assert_debug(!ppcImlGenContext->currentBasicBlock->hasContinuedFlow);
+		cemu_assert_debug(!ppcImlGenContext->currentBasicBlock->hasBranchTarget);
+		ppcImlGenContext->emitInst().make_macro(PPCREC_IML_MACRO_B_TO_REG, 0, 0, 0, branchDestReg);
 	}
 	return true;
 }
 
 bool PPCRecompilerImlGen_ISYNC(ppcImlGenContext_t* ppcImlGenContext, uint32 opcode)
 {
-	// does not need to be translated
 	return true;
 }
 
 bool PPCRecompilerImlGen_SYNC(ppcImlGenContext_t* ppcImlGenContext, uint32 opcode)
 {
-	// does not need to be translated
 	return true;
 }
 
@@ -963,102 +782,12 @@ bool PPCRecompilerImlGen_ADD(ppcImlGenContext_t* ppcImlGenContext, uint32 opcode
 {
 	sint32 rD, rA, rB;
 	PPC_OPC_TEMPL_XO(opcode, rD, rA, rB);
-	//hCPU->gpr[rD] = (int)hCPU->gpr[rA] + (int)hCPU->gpr[rB];
-	uint32 registerRA = PPCRecompilerImlGen_loadRegister(ppcImlGenContext, PPCREC_NAME_R0+rA, false);
-	uint32 registerRB = PPCRecompilerImlGen_loadRegister(ppcImlGenContext, PPCREC_NAME_R0+rB, false);
-	uint32 registerRD = PPCRecompilerImlGen_loadOverwriteRegister(ppcImlGenContext, PPCREC_NAME_R0+rD);
-	if( opcode&PPC_OPC_RC )
-	{
-		PPCRecompilerImlGen_generateNewInstruction_r_r_r(ppcImlGenContext, PPCREC_IML_OP_ADD, registerRD, registerRA, registerRB, 0, PPCREC_CR_MODE_LOGICAL);
-	}
-	else
-	{
-		PPCRecompilerImlGen_generateNewInstruction_r_r_r(ppcImlGenContext, PPCREC_IML_OP_ADD, registerRD, registerRA, registerRB);
-	}
-	return true;
-}
-
-bool PPCRecompilerImlGen_ADDC(ppcImlGenContext_t* ppcImlGenContext, uint32 opcode)
-{
-	sint32 rD, rA, rB;
-	PPC_OPC_TEMPL_XO(opcode, rD, rA, rB);
-	//hCPU->gpr[rD] = (int)hCPU->gpr[rA] + (int)hCPU->gpr[rB]; -> Update carry
-	uint32 registerRA = PPCRecompilerImlGen_loadRegister(ppcImlGenContext, PPCREC_NAME_R0+rA, false);
-	uint32 registerRB = PPCRecompilerImlGen_loadRegister(ppcImlGenContext, PPCREC_NAME_R0+rB, false);
-	uint32 registerRD = PPCRecompilerImlGen_loadOverwriteRegister(ppcImlGenContext, PPCREC_NAME_R0+rD);
-	if( opcode&PPC_OPC_RC )
-		PPCRecompilerImlGen_generateNewInstruction_r_r_r(ppcImlGenContext, PPCREC_IML_OP_ADD_UPDATE_CARRY, registerRD, registerRA, registerRB, 0, PPCREC_CR_MODE_LOGICAL);
-	else
-		PPCRecompilerImlGen_generateNewInstruction_r_r_r(ppcImlGenContext, PPCREC_IML_OP_ADD_UPDATE_CARRY, registerRD, registerRA, registerRB);
-	return true;
-}
-
-bool PPCRecompilerImlGen_ADDE(ppcImlGenContext_t* ppcImlGenContext, uint32 opcode)
-{
-	sint32 rD, rA, rB;
-	PPC_OPC_TEMPL_XO(opcode, rD, rA, rB);
-	// hCPU->gpr[rD] = hCPU->gpr[rA] + hCPU->gpr[rB] + ca;
-	uint32 registerRA = PPCRecompilerImlGen_loadRegister(ppcImlGenContext, PPCREC_NAME_R0+rA, false);
-	uint32 registerRB = PPCRecompilerImlGen_loadRegister(ppcImlGenContext, PPCREC_NAME_R0+rB, false);
-	uint32 registerRD = PPCRecompilerImlGen_loadOverwriteRegister(ppcImlGenContext, PPCREC_NAME_R0+rD);
-	if( opcode&PPC_OPC_RC )
-		PPCRecompilerImlGen_generateNewInstruction_r_r_r(ppcImlGenContext, PPCREC_IML_OP_ADD_CARRY_UPDATE_CARRY, registerRD, registerRB, registerRA, 0, PPCREC_CR_MODE_LOGICAL);
-	else
-		PPCRecompilerImlGen_generateNewInstruction_r_r_r(ppcImlGenContext, PPCREC_IML_OP_ADD_CARRY_UPDATE_CARRY, registerRD, registerRB, registerRA);
-	return true;
-}
-
-bool PPCRecompilerImlGen_ADDZE(ppcImlGenContext_t* ppcImlGenContext, uint32 opcode)
-{
-	sint32 rD, rA, rB;
-	PPC_OPC_TEMPL_XO(opcode, rD, rA, rB);
-	PPC_ASSERT(rB == 0);
-	//uint32 a = hCPU->gpr[rA];
-	//uint32 ca = hCPU->xer_ca;
-	//hCPU->gpr[rD] = a + ca;
-
-	uint32 registerRA = PPCRecompilerImlGen_loadRegister(ppcImlGenContext, PPCREC_NAME_R0+rA, false);
-	uint32 registerRD = PPCRecompilerImlGen_loadOverwriteRegister(ppcImlGenContext, PPCREC_NAME_R0+rD);
-	// move rA to rD
-	if( registerRA != registerRD )
-	{
-		PPCRecompilerImlGen_generateNewInstruction_r_r(ppcImlGenContext, NULL, PPCREC_IML_OP_ASSIGN, registerRD, registerRA);
-	}
-	if( opcode&PPC_OPC_RC )
-	{
-		PPCRecompilerImlGen_generateNewInstruction_r_r(ppcImlGenContext, NULL, PPCREC_IML_OP_ADD_CARRY, registerRD, registerRD, 0, PPCREC_CR_MODE_LOGICAL);
-	}
-	else
-	{
-		PPCRecompilerImlGen_generateNewInstruction_r_r(ppcImlGenContext, NULL, PPCREC_IML_OP_ADD_CARRY, registerRD, registerRD);
-	}
-	return true;
-}
-
-bool PPCRecompilerImlGen_ADDME(ppcImlGenContext_t* ppcImlGenContext, uint32 opcode)
-{
-	sint32 rD, rA, rB;
-	PPC_OPC_TEMPL_XO(opcode, rD, rA, rB);
-	PPC_ASSERT(rB == 0);
-	//uint32 a = hCPU->gpr[rA];
-	//uint32 ca = hCPU->xer_ca;
-	//hCPU->gpr[rD] = a + ca + -1;
-
-	uint32 registerRA = PPCRecompilerImlGen_loadRegister(ppcImlGenContext, PPCREC_NAME_R0+rA, false);
-	uint32 registerRD = PPCRecompilerImlGen_loadOverwriteRegister(ppcImlGenContext, PPCREC_NAME_R0+rD);
-	// move rA to rD
-	if( registerRA != registerRD )
-	{
-		PPCRecompilerImlGen_generateNewInstruction_r_r(ppcImlGenContext, NULL, PPCREC_IML_OP_ASSIGN, registerRD, registerRA);
-	}
-	if( opcode&PPC_OPC_RC )
-	{
-		PPCRecompilerImlGen_generateNewInstruction_r_r(ppcImlGenContext, NULL, PPCREC_IML_OP_ADD_CARRY_ME, registerRD, registerRD, 0, PPCREC_CR_MODE_LOGICAL);
-	}
-	else
-	{
-		PPCRecompilerImlGen_generateNewInstruction_r_r(ppcImlGenContext, NULL, PPCREC_IML_OP_ADD_CARRY_ME, registerRD, registerRD);
-	}
+	IMLReg regA = _GetRegGPR(ppcImlGenContext, rA);
+	IMLReg regB = _GetRegGPR(ppcImlGenContext, rB);
+	IMLReg regD = _GetRegGPR(ppcImlGenContext, rD);
+	ppcImlGenContext->emitInst().make_r_r_r(PPCREC_IML_OP_ADD, regD, regA, regB);
+	if (opcode & PPC_OPC_RC)
+		PPCImlGen_UpdateCR0(ppcImlGenContext, regD);
 	return true;
 }
 
@@ -1067,22 +796,16 @@ bool PPCRecompilerImlGen_ADDI(ppcImlGenContext_t* ppcImlGenContext, uint32 opcod
 	sint32 rD, rA;
 	uint32 imm;
 	PPC_OPC_TEMPL_D_SImm(opcode, rD, rA, imm);
-	//hCPU->gpr[rD] = (rA ? (int)hCPU->gpr[rA] : 0) + (int)imm;
-	if( rA != 0 )
+	IMLReg regD = _GetRegGPR(ppcImlGenContext, rD);
+	if (rA != 0)
 	{
-		uint32 registerRA = PPCRecompilerImlGen_loadRegister(ppcImlGenContext, PPCREC_NAME_R0+rA, false);
-		// check if rD is already loaded, else use new temporary register
-		uint32 registerRD = PPCRecompilerImlGen_loadOverwriteRegister(ppcImlGenContext, PPCREC_NAME_R0+rD);
-		PPCRecompilerImlGen_generateNewInstruction_r_r_s32(ppcImlGenContext, PPCREC_IML_OP_ADD, registerRD, registerRA, imm);
+		IMLReg regA = _GetRegGPR(ppcImlGenContext, rA);
+		ppcImlGenContext->emitInst().make_r_r_s32(PPCREC_IML_OP_ADD, regD, regA, imm);
 	}
 	else
 	{
-		// rA not used, instruction is value assignment
-		// rD = imm
-		uint32 registerRD = PPCRecompilerImlGen_loadOverwriteRegister(ppcImlGenContext, PPCREC_NAME_R0+rD);
-		PPCRecompilerImlGen_generateNewInstruction_r_s32(ppcImlGenContext, PPCREC_IML_OP_ASSIGN, registerRD, imm, 0, false, false, PPC_REC_INVALID_REGISTER, 0);
+		ppcImlGenContext->emitInst().make_r_s32(PPCREC_IML_OP_ASSIGN, regD, imm);
 	}
-	// never updates any cr
 	return true;
 }
 
@@ -1091,49 +814,88 @@ bool PPCRecompilerImlGen_ADDIS(ppcImlGenContext_t* ppcImlGenContext, uint32 opco
 	int rD, rA;
 	uint32 imm;
 	PPC_OPC_TEMPL_D_Shift16(opcode, rD, rA, imm);
-	if( rA != 0 )
+	IMLReg regD = _GetRegGPR(ppcImlGenContext, rD);
+	if (rA != 0)
 	{
-		uint32 registerRA = PPCRecompilerImlGen_loadRegister(ppcImlGenContext, PPCREC_NAME_R0+rA, false);
-		// check if rD is already loaded, else use new temporary register
-		uint32 registerRD = PPCRecompilerImlGen_loadOverwriteRegister(ppcImlGenContext, PPCREC_NAME_R0+rD);
-		PPCRecompilerImlGen_generateNewInstruction_r_r_s32(ppcImlGenContext, PPCREC_IML_OP_ADD, registerRD, registerRA, (sint32)imm);
+		IMLReg regA = _GetRegGPR(ppcImlGenContext, rA);
+		ppcImlGenContext->emitInst().make_r_r_s32(PPCREC_IML_OP_ADD, regD, regA, (sint32)imm);
 	}
 	else
 	{
-		// rA not used, instruction turns into simple value assignment
-		// rD = imm
-		uint32 registerRD = PPCRecompilerImlGen_loadOverwriteRegister(ppcImlGenContext, PPCREC_NAME_R0+rD);
-		PPCRecompilerImlGen_generateNewInstruction_r_s32(ppcImlGenContext, PPCREC_IML_OP_ASSIGN, registerRD, (sint32)imm, 0, false, false, PPC_REC_INVALID_REGISTER, 0);
+		ppcImlGenContext->emitInst().make_r_s32(PPCREC_IML_OP_ASSIGN, regD, (sint32)imm);
 	}
-	// never updates any cr
 	return true;
 }
 
-bool PPCRecompilerImlGen_ADDIC(ppcImlGenContext_t* ppcImlGenContext, uint32 opcode)
+bool PPCRecompilerImlGen_ADDC(ppcImlGenContext_t* ppcImlGenContext, uint32 opcode)
+{
+	// r = a + b -> update carry
+	sint32 rD, rA, rB;
+	PPC_OPC_TEMPL_XO(opcode, rD, rA, rB);
+	IMLReg regRA = _GetRegGPR(ppcImlGenContext, rA);
+	IMLReg regRB = _GetRegGPR(ppcImlGenContext, rB);
+	IMLReg regRD = _GetRegGPR(ppcImlGenContext, rD);
+	IMLReg regCa = PPCRecompilerImlGen_loadRegister(ppcImlGenContext, PPCREC_NAME_XER_CA);
+	ppcImlGenContext->emitInst().make_r_r_r_carry(PPCREC_IML_OP_ADD, regRD, regRA, regRB, regCa);
+	if (opcode & PPC_OPC_RC)
+		PPCImlGen_UpdateCR0(ppcImlGenContext, regRD);
+	return true;
+}
+
+bool PPCRecompilerImlGen_ADDIC_(ppcImlGenContext_t* ppcImlGenContext, uint32 opcode, bool updateCR0)
 {
 	sint32 rD, rA;
 	uint32 imm;
 	PPC_OPC_TEMPL_D_SImm(opcode, rD, rA, imm);
-	// rD = rA + imm;
-	uint32 registerRA = PPCRecompilerImlGen_loadRegister(ppcImlGenContext, PPCREC_NAME_R0+rA, false);
-	// check if rD is already loaded, else use new temporary register
-	uint32 registerRD = PPCRecompilerImlGen_loadOverwriteRegister(ppcImlGenContext, PPCREC_NAME_R0+rD);
-	PPCRecompilerImlGen_generateNewInstruction_r_r_s32(ppcImlGenContext, PPCREC_IML_OP_ADD_UPDATE_CARRY, registerRD, registerRA, imm);
-	// never updates any cr
+	IMLReg regA = _GetRegGPR(ppcImlGenContext, rA);
+	IMLReg regD = _GetRegGPR(ppcImlGenContext, rD);
+	IMLReg regCa = PPCRecompilerImlGen_loadRegister(ppcImlGenContext, PPCREC_NAME_XER_CA);
+	ppcImlGenContext->emitInst().make_r_r_s32_carry(PPCREC_IML_OP_ADD, regD, regA, (sint32)imm, regCa);
+	if(updateCR0)
+		PPCImlGen_UpdateCR0(ppcImlGenContext, regD);
 	return true;
 }
 
-bool PPCRecompilerImlGen_ADDIC_(ppcImlGenContext_t* ppcImlGenContext, uint32 opcode)
+bool PPCRecompilerImlGen_ADDE(ppcImlGenContext_t* ppcImlGenContext, uint32 opcode)
 {
-	// this opcode is identical to ADDIC but additionally it updates CR0
-	sint32 rD, rA;
-	uint32 imm;
-	PPC_OPC_TEMPL_D_SImm(opcode, rD, rA, imm);
-	// rD = rA + imm;
-	uint32 registerRA = PPCRecompilerImlGen_loadRegister(ppcImlGenContext, PPCREC_NAME_R0+rA, false);
-	// check if rD is already loaded, else use new temporary register
-	uint32 registerRD = PPCRecompilerImlGen_loadOverwriteRegister(ppcImlGenContext, PPCREC_NAME_R0+rD);
-	PPCRecompilerImlGen_generateNewInstruction_r_r_s32(ppcImlGenContext, PPCREC_IML_OP_ADD_UPDATE_CARRY, registerRD, registerRA, imm, 0, PPCREC_CR_MODE_LOGICAL);
+	// r = a + b + carry -> update carry
+	sint32 rD, rA, rB;
+	PPC_OPC_TEMPL_XO(opcode, rD, rA, rB);
+	IMLReg regRA = _GetRegGPR(ppcImlGenContext, rA);
+	IMLReg regRB = _GetRegGPR(ppcImlGenContext, rB);
+	IMLReg regRD = _GetRegGPR(ppcImlGenContext, rD);
+	IMLReg regCa = PPCRecompilerImlGen_loadRegister(ppcImlGenContext, PPCREC_NAME_XER_CA);
+	ppcImlGenContext->emitInst().make_r_r_r_carry(PPCREC_IML_OP_ADD_WITH_CARRY, regRD, regRA, regRB, regCa);
+	if (opcode & PPC_OPC_RC)
+		PPCImlGen_UpdateCR0(ppcImlGenContext, regRD);
+	return true;
+}
+
+bool PPCRecompilerImlGen_ADDZE(ppcImlGenContext_t* ppcImlGenContext, uint32 opcode)
+{
+	// r = a + carry -> update carry
+	sint32 rD, rA, rB;
+	PPC_OPC_TEMPL_XO(opcode, rD, rA, rB);
+	IMLReg regRA = _GetRegGPR(ppcImlGenContext, rA);
+	IMLReg regRD = _GetRegGPR(ppcImlGenContext, rD);
+	IMLReg regCa = PPCRecompilerImlGen_loadRegister(ppcImlGenContext, PPCREC_NAME_XER_CA);
+	ppcImlGenContext->emitInst().make_r_r_s32_carry(PPCREC_IML_OP_ADD_WITH_CARRY, regRD, regRA, 0, regCa);
+	if (opcode & PPC_OPC_RC)
+		PPCImlGen_UpdateCR0(ppcImlGenContext, regRD);
+	return true;
+}
+
+bool PPCRecompilerImlGen_ADDME(ppcImlGenContext_t* ppcImlGenContext, uint32 opcode)
+{
+	// r = a + 0xFFFFFFFF + carry -> update carry
+	sint32 rD, rA, rB;
+	PPC_OPC_TEMPL_XO(opcode, rD, rA, rB);
+	IMLReg regRA = _GetRegGPR(ppcImlGenContext, rA);
+	IMLReg regRD = _GetRegGPR(ppcImlGenContext, rD);
+	IMLReg regCa = PPCRecompilerImlGen_loadRegister(ppcImlGenContext, PPCREC_NAME_XER_CA);
+	ppcImlGenContext->emitInst().make_r_r_s32_carry(PPCREC_IML_OP_ADD_WITH_CARRY, regRD, regRA, -1, regCa);
+	if (opcode & PPC_OPC_RC)
+		PPCImlGen_UpdateCR0(ppcImlGenContext, regRD);
 	return true;
 }
 
@@ -1141,74 +903,79 @@ bool PPCRecompilerImlGen_SUBF(ppcImlGenContext_t* ppcImlGenContext, uint32 opcod
 {
 	sint32 rD, rA, rB;
 	PPC_OPC_TEMPL_XO(opcode, rD, rA, rB);
-	// hCPU->gpr[rD] = ~hCPU->gpr[rA] + hCPU->gpr[rB] + 1;
-	// rD = rB - rA
-	uint32 registerRA = PPCRecompilerImlGen_loadRegister(ppcImlGenContext, PPCREC_NAME_R0+rA, false);
-	uint32 registerRB = PPCRecompilerImlGen_loadRegister(ppcImlGenContext, PPCREC_NAME_R0+rB, false);
-	uint32 registerRD = PPCRecompilerImlGen_loadOverwriteRegister(ppcImlGenContext, PPCREC_NAME_R0+rD);
-	if( opcode&PPC_OPC_RC )
-		PPCRecompilerImlGen_generateNewInstruction_r_r_r(ppcImlGenContext, PPCREC_IML_OP_SUB, registerRD, registerRB, registerRA, 0, PPCREC_CR_MODE_LOGICAL);
-	else
-		PPCRecompilerImlGen_generateNewInstruction_r_r_r(ppcImlGenContext, PPCREC_IML_OP_SUB, registerRD, registerRB, registerRA);
+	// rD = ~rA + rB + 1
+	IMLReg regA = _GetRegGPR(ppcImlGenContext, rA);
+	IMLReg regB = _GetRegGPR(ppcImlGenContext, rB);
+	IMLReg regD = _GetRegGPR(ppcImlGenContext, rD);
+	ppcImlGenContext->emitInst().make_r_r_r(PPCREC_IML_OP_SUB, regD, regB, regA);
+	if ((opcode & PPC_OPC_RC))
+		PPCImlGen_UpdateCR0(ppcImlGenContext, regD);
 	return true;
 }
 
 bool PPCRecompilerImlGen_SUBFE(ppcImlGenContext_t* ppcImlGenContext, uint32 opcode)
 {
+	// d = ~a + b + ca;
 	sint32 rD, rA, rB;
 	PPC_OPC_TEMPL_XO(opcode, rD, rA, rB);
-	// hCPU->gpr[rD] = ~hCPU->gpr[rA] + hCPU->gpr[rB] + ca;
-	uint32 registerRA = PPCRecompilerImlGen_loadRegister(ppcImlGenContext, PPCREC_NAME_R0+rA, false);
-	uint32 registerRB = PPCRecompilerImlGen_loadRegister(ppcImlGenContext, PPCREC_NAME_R0+rB, false);
-	uint32 registerRD = PPCRecompilerImlGen_loadOverwriteRegister(ppcImlGenContext, PPCREC_NAME_R0+rD);
-	if( opcode&PPC_OPC_RC )
-		PPCRecompilerImlGen_generateNewInstruction_r_r_r(ppcImlGenContext, PPCREC_IML_OP_SUB_CARRY_UPDATE_CARRY, registerRD, registerRB, registerRA, 0, PPCREC_CR_MODE_LOGICAL);
-	else
-		PPCRecompilerImlGen_generateNewInstruction_r_r_r(ppcImlGenContext, PPCREC_IML_OP_SUB_CARRY_UPDATE_CARRY, registerRD, registerRB, registerRA);
+	IMLReg regA = _GetRegGPR(ppcImlGenContext, rA);
+	IMLReg regB = _GetRegGPR(ppcImlGenContext, rB);
+	IMLReg regD = _GetRegGPR(ppcImlGenContext, rD);
+	IMLReg regTmp = PPCRecompilerImlGen_loadRegister(ppcImlGenContext, PPCREC_NAME_TEMPORARY + 0);
+	IMLReg regCa = PPCRecompilerImlGen_loadRegister(ppcImlGenContext, PPCREC_NAME_XER_CA);
+	ppcImlGenContext->emitInst().make_r_r(PPCREC_IML_OP_NOT, regTmp, regA);
+	ppcImlGenContext->emitInst().make_r_r_r_carry(PPCREC_IML_OP_ADD_WITH_CARRY, regD, regTmp, regB, regCa);
+	if (opcode & PPC_OPC_RC)
+		PPCImlGen_UpdateCR0(ppcImlGenContext, regD);
 	return true;
 }
 
 bool PPCRecompilerImlGen_SUBFZE(ppcImlGenContext_t* ppcImlGenContext, uint32 opcode)
 {
+	// d = ~a + ca;
 	sint32 rD, rA, rB;
 	PPC_OPC_TEMPL_XO(opcode, rD, rA, rB);
-	if( rB != 0 )
-		debugBreakpoint();
-	uint32 registerRA = PPCRecompilerImlGen_loadRegister(ppcImlGenContext, PPCREC_NAME_R0+rA, false);
-	uint32 registerRD = PPCRecompilerImlGen_loadOverwriteRegister(ppcImlGenContext, PPCREC_NAME_R0+rD);
-	if( opcode&PPC_OPC_RC )
-		PPCRecompilerImlGen_generateNewInstruction_r_r(ppcImlGenContext, NULL, PPCREC_IML_OP_SUB_CARRY_UPDATE_CARRY, registerRD, registerRA, 0, PPCREC_CR_MODE_LOGICAL);
-	else
-		PPCRecompilerImlGen_generateNewInstruction_r_r(ppcImlGenContext, NULL, PPCREC_IML_OP_SUB_CARRY_UPDATE_CARRY, registerRD, registerRA);
+	IMLReg regA = _GetRegGPR(ppcImlGenContext, rA);
+	IMLReg regD = _GetRegGPR(ppcImlGenContext, rD);
+	IMLReg regTmp = PPCRecompilerImlGen_loadRegister(ppcImlGenContext, PPCREC_NAME_TEMPORARY + 0);
+	IMLReg regCa = PPCRecompilerImlGen_loadRegister(ppcImlGenContext, PPCREC_NAME_XER_CA);
+	ppcImlGenContext->emitInst().make_r_r(PPCREC_IML_OP_NOT, regTmp, regA);
+	ppcImlGenContext->emitInst().make_r_r_s32_carry(PPCREC_IML_OP_ADD_WITH_CARRY, regD, regTmp, 0, regCa);
+	if (opcode & PPC_OPC_RC)
+		PPCImlGen_UpdateCR0(ppcImlGenContext, regD);
 	return true;
 }
 
 bool PPCRecompilerImlGen_SUBFC(ppcImlGenContext_t* ppcImlGenContext, uint32 opcode)
 {
+	// d = ~a + b + 1;
 	sint32 rD, rA, rB;
 	PPC_OPC_TEMPL_XO(opcode, rD, rA, rB);
-	// hCPU->gpr[rD] = ~hCPU->gpr[rA] + hCPU->gpr[rB] + 1;
-	// rD = rB - rA
-	uint32 registerRA = PPCRecompilerImlGen_loadRegister(ppcImlGenContext, PPCREC_NAME_R0+rA, false);
-	uint32 registerRB = PPCRecompilerImlGen_loadRegister(ppcImlGenContext, PPCREC_NAME_R0+rB, false);
-	uint32 registerRD = PPCRecompilerImlGen_loadOverwriteRegister(ppcImlGenContext, PPCREC_NAME_R0+rD);
-	PPCRecompilerImlGen_generateNewInstruction_r_r_r(ppcImlGenContext, PPCREC_IML_OP_SUBFC, registerRD, registerRA, registerRB);
-	if (opcode & PPC_OPC_RC)
-		PPCRecompilerImlGen_generateNewInstruction_r_r(ppcImlGenContext, NULL, PPCREC_IML_OP_AND, registerRD, registerRD, 0, PPCREC_CR_MODE_LOGICAL);
+	IMLReg regA = _GetRegGPR(ppcImlGenContext, rA);
+	IMLReg regB = _GetRegGPR(ppcImlGenContext, rB);
+	IMLReg regD = _GetRegGPR(ppcImlGenContext, rD);
+	IMLReg regTmp = PPCRecompilerImlGen_loadRegister(ppcImlGenContext, PPCREC_NAME_TEMPORARY + 0);
+	IMLReg regCa = PPCRecompilerImlGen_loadRegister(ppcImlGenContext, PPCREC_NAME_XER_CA);
+	ppcImlGenContext->emitInst().make_r_r(PPCREC_IML_OP_NOT, regTmp, regA);
+	ppcImlGenContext->emitInst().make_r_s32(PPCREC_IML_OP_ASSIGN, regCa, 1); // set input carry to simulate offset of 1
+	ppcImlGenContext->emitInst().make_r_r_r_carry(PPCREC_IML_OP_ADD_WITH_CARRY, regD, regTmp, regB, regCa);
+	if ((opcode & PPC_OPC_RC))
+		PPCImlGen_UpdateCR0(ppcImlGenContext, regD);
 	return true;
 }
 
 bool PPCRecompilerImlGen_SUBFIC(ppcImlGenContext_t* ppcImlGenContext, uint32 opcode)
 {
+	// d = ~a + imm + 1
 	sint32 rD, rA;
 	uint32 imm;
 	PPC_OPC_TEMPL_D_SImm(opcode, rD, rA, imm);
-	//uint32 a = hCPU->gpr[rA];
-	//hCPU->gpr[rD] = ~a + imm + 1;
-	// cr0 is never affected
-	uint32 registerRA = PPCRecompilerImlGen_loadRegister(ppcImlGenContext, PPCREC_NAME_R0+rA, false);
-	uint32 registerRD = PPCRecompilerImlGen_loadOverwriteRegister(ppcImlGenContext, PPCREC_NAME_R0+rD);
-	PPCRecompilerImlGen_generateNewInstruction_r_r_s32(ppcImlGenContext, PPCREC_IML_OP_SUBFC, registerRD, registerRA, imm);
+	IMLReg regA = _GetRegGPR(ppcImlGenContext, rA);
+	IMLReg regD = _GetRegGPR(ppcImlGenContext, rD);
+	IMLReg regCa = PPCRecompilerImlGen_loadRegister(ppcImlGenContext, PPCREC_NAME_XER_CA);
+	IMLReg regTmp = PPCRecompilerImlGen_loadRegister(ppcImlGenContext, PPCREC_NAME_TEMPORARY + 0);
+	ppcImlGenContext->emitInst().make_r_r(PPCREC_IML_OP_NOT, regTmp, regA);
+	ppcImlGenContext->emitInst().make_r_r_s32_carry(PPCREC_IML_OP_ADD, regD, regTmp, (sint32)imm + 1, regCa);
 	return true;
 }
 
@@ -1217,10 +984,9 @@ bool PPCRecompilerImlGen_MULLI(ppcImlGenContext_t* ppcImlGenContext, uint32 opco
 	int rD, rA;
 	uint32 imm;
 	PPC_OPC_TEMPL_D_SImm(opcode, rD, rA, imm);
-	// mulli instruction does not modify any flags
-	uint32 registerResult = PPCRecompilerImlGen_loadRegister(ppcImlGenContext, PPCREC_NAME_R0+rD, false);
-	uint32 registerOperand = PPCRecompilerImlGen_loadRegister(ppcImlGenContext, PPCREC_NAME_R0+rA, false);
-	PPCRecompilerImlGen_generateNewInstruction_r_r_s32(ppcImlGenContext, PPCREC_IML_OP_MULTIPLY_SIGNED, registerResult, registerOperand, (sint32)imm);
+	IMLReg regD = _GetRegGPR(ppcImlGenContext, rD);
+	IMLReg regA = _GetRegGPR(ppcImlGenContext, rA);
+	ppcImlGenContext->emitInst().make_r_r_s32(PPCREC_IML_OP_MULTIPLY_SIGNED, regD, regA, (sint32)imm);
 	return true;
 }
 
@@ -1228,18 +994,16 @@ bool PPCRecompilerImlGen_MULLW(ppcImlGenContext_t* ppcImlGenContext, uint32 opco
 {
 	sint32 rD, rA, rB;
 	PPC_OPC_TEMPL_XO(opcode, rD, rA, rB);
-	//hCPU->gpr[rD] = hCPU->gpr[rA] * hCPU->gpr[rB];
-	uint32 registerResult = PPCRecompilerImlGen_loadRegister(ppcImlGenContext, PPCREC_NAME_R0+rD, false);
-	uint32 registerOperand1 = PPCRecompilerImlGen_loadRegister(ppcImlGenContext, PPCREC_NAME_R0+rA, false);
-	uint32 registerOperand2 = PPCRecompilerImlGen_loadRegister(ppcImlGenContext, PPCREC_NAME_R0+rB, false);
+	IMLReg regD = _GetRegGPR(ppcImlGenContext, rD);
+	IMLReg regA = _GetRegGPR(ppcImlGenContext, rA);
+	IMLReg regB = _GetRegGPR(ppcImlGenContext, rB);
 	if (opcode & PPC_OPC_OE)
 	{
 		return false;
 	}
-	if( opcode&PPC_OPC_RC )
-		PPCRecompilerImlGen_generateNewInstruction_r_r_r(ppcImlGenContext, PPCREC_IML_OP_MULTIPLY_SIGNED, registerResult, registerOperand1, registerOperand2, 0, PPCREC_CR_MODE_LOGICAL);
-	else
-		PPCRecompilerImlGen_generateNewInstruction_r_r_r(ppcImlGenContext, PPCREC_IML_OP_MULTIPLY_SIGNED, registerResult, registerOperand1, registerOperand2);
+	ppcImlGenContext->emitInst().make_r_r_r(PPCREC_IML_OP_MULTIPLY_SIGNED, regD, regA, regB);
+	if (opcode & PPC_OPC_RC)
+		PPCImlGen_UpdateCR0(ppcImlGenContext, regD);
 	return true;
 }
 
@@ -1247,14 +1011,12 @@ bool PPCRecompilerImlGen_MULHW(ppcImlGenContext_t* ppcImlGenContext, uint32 opco
 {
 	sint32 rD, rA, rB;
 	PPC_OPC_TEMPL_XO(opcode, rD, rA, rB);
-	//hCPU->gpr[rD] = ((sint64)(sint32)hCPU->gpr[rA] * (sint64)(sint32)hCPU->gpr[rB])>>32;
-	uint32 registerResult = PPCRecompilerImlGen_loadRegister(ppcImlGenContext, PPCREC_NAME_R0+rD, false);
-	uint32 registerOperand1 = PPCRecompilerImlGen_loadRegister(ppcImlGenContext, PPCREC_NAME_R0+rA, false);
-	uint32 registerOperand2 = PPCRecompilerImlGen_loadRegister(ppcImlGenContext, PPCREC_NAME_R0+rB, false);
-	if( opcode&PPC_OPC_RC )
-		PPCRecompilerImlGen_generateNewInstruction_r_r_r(ppcImlGenContext, PPCREC_IML_OP_MULTIPLY_HIGH_SIGNED, registerResult, registerOperand1, registerOperand2, 0, PPCREC_CR_MODE_LOGICAL);
-	else
-		PPCRecompilerImlGen_generateNewInstruction_r_r_r(ppcImlGenContext, PPCREC_IML_OP_MULTIPLY_HIGH_SIGNED, registerResult, registerOperand1, registerOperand2);
+	IMLReg regD = _GetRegGPR(ppcImlGenContext, rD);
+	IMLReg regA = _GetRegGPR(ppcImlGenContext, rA);
+	IMLReg regB = _GetRegGPR(ppcImlGenContext, rB);
+	ppcImlGenContext->emitInst().make_r_r_r(PPCREC_IML_OP_MULTIPLY_HIGH_SIGNED, regD, regA, regB);
+	if (opcode & PPC_OPC_RC)
+		PPCImlGen_UpdateCR0(ppcImlGenContext, regD);
 	return true;
 }
 
@@ -1262,14 +1024,12 @@ bool PPCRecompilerImlGen_MULHWU(ppcImlGenContext_t* ppcImlGenContext, uint32 opc
 {
 	sint32 rD, rA, rB;
 	PPC_OPC_TEMPL_XO(opcode, rD, rA, rB);
-	//hCPU->gpr[rD] = (hCPU->gpr[rA] * hCPU->gpr[rB])>>32;
-	uint32 registerResult = PPCRecompilerImlGen_loadRegister(ppcImlGenContext, PPCREC_NAME_R0+rD, false);
-	uint32 registerOperand1 = PPCRecompilerImlGen_loadRegister(ppcImlGenContext, PPCREC_NAME_R0+rA, false);
-	uint32 registerOperand2 = PPCRecompilerImlGen_loadRegister(ppcImlGenContext, PPCREC_NAME_R0+rB, false);
-	if( opcode&PPC_OPC_RC )
-		PPCRecompilerImlGen_generateNewInstruction_r_r_r(ppcImlGenContext, PPCREC_IML_OP_MULTIPLY_HIGH_UNSIGNED, registerResult, registerOperand1, registerOperand2, 0, PPCREC_CR_MODE_LOGICAL);
-	else
-		PPCRecompilerImlGen_generateNewInstruction_r_r_r(ppcImlGenContext, PPCREC_IML_OP_MULTIPLY_HIGH_UNSIGNED, registerResult, registerOperand1, registerOperand2);
+	IMLReg regD = _GetRegGPR(ppcImlGenContext, rD);
+	IMLReg regA = _GetRegGPR(ppcImlGenContext, rA);
+	IMLReg regB = _GetRegGPR(ppcImlGenContext, rB);
+	ppcImlGenContext->emitInst().make_r_r_r(PPCREC_IML_OP_MULTIPLY_HIGH_UNSIGNED, regD, regA, regB);
+	if (opcode & PPC_OPC_RC)
+		PPCImlGen_UpdateCR0(ppcImlGenContext, regD);
 	return true;
 }
 
@@ -1277,18 +1037,12 @@ bool PPCRecompilerImlGen_DIVW(ppcImlGenContext_t* ppcImlGenContext, uint32 opcod
 {
 	sint32 rD, rA, rB;
 	PPC_OPC_TEMPL_XO(opcode, rD, rA, rB);
-	// hCPU->gpr[rD] = (sint32)a / (sint32)b;
-	uint32 registerResult = PPCRecompilerImlGen_loadRegister(ppcImlGenContext, PPCREC_NAME_R0+rD, false);
-	uint32 registerOperand1 = PPCRecompilerImlGen_loadRegister(ppcImlGenContext, PPCREC_NAME_R0+rA, false);
-	uint32 registerOperand2 = PPCRecompilerImlGen_loadRegister(ppcImlGenContext, PPCREC_NAME_R0+rB, false);
+	IMLReg regR = _GetRegGPR(ppcImlGenContext, rD);
+	IMLReg regA = _GetRegGPR(ppcImlGenContext, rA);
+	IMLReg regB = _GetRegGPR(ppcImlGenContext, rB);
+	ppcImlGenContext->emitInst().make_r_r_r(PPCREC_IML_OP_DIVIDE_SIGNED, regR, regA, regB);
 	if (opcode & PPC_OPC_RC)
-	{
-		PPCRecompilerImlGen_generateNewInstruction_r_r_r(ppcImlGenContext, PPCREC_IML_OP_DIVIDE_SIGNED, registerResult, registerOperand1, registerOperand2, 0, PPCREC_CR_MODE_ARITHMETIC);
-	}
-	else
-	{
-		PPCRecompilerImlGen_generateNewInstruction_r_r_r(ppcImlGenContext, PPCREC_IML_OP_DIVIDE_SIGNED, registerResult, registerOperand1, registerOperand2);
-	}
+		PPCImlGen_UpdateCR0(ppcImlGenContext, regR);
 	return true;
 }
 
@@ -1296,84 +1050,66 @@ bool PPCRecompilerImlGen_DIVWU(ppcImlGenContext_t* ppcImlGenContext, uint32 opco
 {
 	sint32 rD, rA, rB;
 	PPC_OPC_TEMPL_XO(opcode, rD, rA, rB);
-	// hCPU->gpr[rD] = (uint32)a / (uint32)b;
-	uint32 registerResult = PPCRecompilerImlGen_loadRegister(ppcImlGenContext, PPCREC_NAME_R0+rD, false);
-	uint32 registerOperand1 = PPCRecompilerImlGen_loadRegister(ppcImlGenContext, PPCREC_NAME_R0+rA, false);
-	uint32 registerOperand2 = PPCRecompilerImlGen_loadRegister(ppcImlGenContext, PPCREC_NAME_R0+rB, false);
+	IMLReg regD = _GetRegGPR(ppcImlGenContext, rD);
+	IMLReg regA = _GetRegGPR(ppcImlGenContext, rA);
+	IMLReg regB = _GetRegGPR(ppcImlGenContext, rB);
+	ppcImlGenContext->emitInst().make_r_r_r(PPCREC_IML_OP_DIVIDE_UNSIGNED, regD, regA, regB);
 	if (opcode & PPC_OPC_RC)
-	{
-		PPCRecompilerImlGen_generateNewInstruction_r_r_r(ppcImlGenContext, PPCREC_IML_OP_DIVIDE_UNSIGNED, registerResult, registerOperand1, registerOperand2, 0, PPCREC_CR_MODE_ARITHMETIC);
-	}
-	else
-	{
-		PPCRecompilerImlGen_generateNewInstruction_r_r_r(ppcImlGenContext, PPCREC_IML_OP_DIVIDE_UNSIGNED, registerResult, registerOperand1, registerOperand2);
-	}
+		PPCImlGen_UpdateCR0(ppcImlGenContext, regD);
 	return true;
 }
 
 bool PPCRecompilerImlGen_RLWINM(ppcImlGenContext_t* ppcImlGenContext, uint32 opcode)
 {
-	int rS, rA, SH, MB, ME;
+	sint32 rS, rA, SH, MB, ME;
 	PPC_OPC_TEMPL_M(opcode, rS, rA, SH, MB, ME);
 	uint32 mask = ppc_mask(MB, ME);
-	//uint32 v = ppc_word_rotl(hCPU->gpr[rS], SH);
-	//hCPU->gpr[rA] = v & mask;
 
-	uint32 registerRS = PPCRecompilerImlGen_loadRegister(ppcImlGenContext, PPCREC_NAME_R0+rS, false);
-	uint32 registerRA = PPCRecompilerImlGen_loadOverwriteRegister(ppcImlGenContext, PPCREC_NAME_R0+rA);
-	// handle special forms of RLWINM
-	if( SH == 0 && SH == (ME-SH) && MB == 0 )
-	{
-		// CLRRWI
-		// todo
-	}
-	else if( ME == (31-SH) && MB == 0 )
+	IMLReg regS = _GetRegGPR(ppcImlGenContext, rS);
+	IMLReg regA = _GetRegGPR(ppcImlGenContext, rA);
+	if( ME == (31-SH) && MB == 0 )
 	{
 		// SLWI
-		if(opcode&PPC_OPC_RC)
-			PPCRecompilerImlGen_generateNewInstruction_r_r_s32(ppcImlGenContext, PPCREC_IML_OP_LEFT_SHIFT, registerRA, registerRS, SH, 0, PPCREC_CR_MODE_LOGICAL);
-		else
-			PPCRecompilerImlGen_generateNewInstruction_r_r_s32(ppcImlGenContext, PPCREC_IML_OP_LEFT_SHIFT, registerRA, registerRS, SH);
-		return true;
+		ppcImlGenContext->emitInst().make_r_r_s32(PPCREC_IML_OP_LEFT_SHIFT, regA, regS, SH);
 	}
 	else if( SH == (32-MB) && ME == 31 )
 	{
 		// SRWI
-		if(opcode&PPC_OPC_RC)
-			PPCRecompilerImlGen_generateNewInstruction_r_r_s32(ppcImlGenContext, PPCREC_IML_OP_RIGHT_SHIFT, registerRA, registerRS, MB, 0, PPCREC_CR_MODE_LOGICAL);
-		else
-			PPCRecompilerImlGen_generateNewInstruction_r_r_s32(ppcImlGenContext, PPCREC_IML_OP_RIGHT_SHIFT, registerRA, registerRS, MB);
-		return true;
-	}
-	// general handler
-	if( registerRA != registerRS )
-		PPCRecompilerImlGen_generateNewInstruction_r_r(ppcImlGenContext, NULL, PPCREC_IML_OP_ASSIGN, registerRA, registerRS);
-	if( SH != 0 )
-		PPCRecompilerImlGen_generateNewInstruction_r_s32(ppcImlGenContext, PPCREC_IML_OP_LEFT_ROTATE, registerRA, SH, 0, false, false, PPC_REC_INVALID_REGISTER, 0);
-	if(opcode&PPC_OPC_RC)
-	{
-		PPCRecompilerImlGen_generateNewInstruction_r_s32(ppcImlGenContext, PPCREC_IML_OP_AND, registerRA, (sint32)mask, 0, false, false, 0, PPCREC_CR_MODE_LOGICAL);
+		ppcImlGenContext->emitInst().make_r_r_s32(PPCREC_IML_OP_RIGHT_SHIFT_U, regA, regS, MB);
 	}
 	else
 	{
-		if( mask != 0xFFFFFFFF )
-			PPCRecompilerImlGen_generateNewInstruction_r_s32(ppcImlGenContext, PPCREC_IML_OP_AND, registerRA, (sint32)mask, 0, false, false, PPC_REC_INVALID_REGISTER, 0);
+		// general handler
+		if (rA != rS)
+			ppcImlGenContext->emitInst().make_r_r(PPCREC_IML_OP_ASSIGN, regA, regS);
+		if (SH != 0)
+			ppcImlGenContext->emitInst().make_r_s32(PPCREC_IML_OP_LEFT_ROTATE, regA, SH);
+		if (mask != 0xFFFFFFFF)
+			ppcImlGenContext->emitInst().make_r_r_s32(PPCREC_IML_OP_AND, regA, regA, (sint32)mask);
 	}
+	if (opcode & PPC_OPC_RC)
+		PPCImlGen_UpdateCR0(ppcImlGenContext, regA);
 	return true;
 }
 
 bool PPCRecompilerImlGen_RLWIMI(ppcImlGenContext_t* ppcImlGenContext, uint32 opcode)
 {
-	int rS, rA, SH, MB, ME;
+	sint32 rS, rA, SH, MB, ME;
 	PPC_OPC_TEMPL_M(opcode, rS, rA, SH, MB, ME);
-
-	uint32 registerRS = PPCRecompilerImlGen_loadRegister(ppcImlGenContext, PPCREC_NAME_R0+rS, false);
-	uint32 registerRA = PPCRecompilerImlGen_loadOverwriteRegister(ppcImlGenContext, PPCREC_NAME_R0+rA);
-	// pack RLWIMI parameters into single integer
-	uint32 vImm = MB|(ME<<8)|(SH<<16);
-	PPCRecompilerImlGen_generateNewInstruction_r_r_s32(ppcImlGenContext, PPCREC_IML_OP_RLWIMI, registerRA, registerRS, (sint32)vImm, PPC_REC_INVALID_REGISTER, 0);
+	IMLReg regS = _GetRegGPR(ppcImlGenContext, rS);
+	IMLReg regR = _GetRegGPR(ppcImlGenContext, rA);
+	IMLReg regTmp = _GetRegTemporary(ppcImlGenContext, 0);
+	uint32 mask = ppc_mask(MB, ME);
+	ppcImlGenContext->emitInst().make_r_r(PPCREC_IML_OP_ASSIGN, regTmp, regS);
+	if (SH)
+		ppcImlGenContext->emitInst().make_r_s32(PPCREC_IML_OP_LEFT_ROTATE, regTmp, SH);
+	if (mask != 0)
+		ppcImlGenContext->emitInst().make_r_r_s32(PPCREC_IML_OP_AND, regR, regR, (sint32)~mask);
+	if (mask != 0xFFFFFFFF)
+		ppcImlGenContext->emitInst().make_r_r_s32(PPCREC_IML_OP_AND, regTmp, regTmp, (sint32)mask);
+	ppcImlGenContext->emitInst().make_r_r_r(PPCREC_IML_OP_OR, regR, regR, regTmp);
 	if (opcode & PPC_OPC_RC)
-		PPCRecompilerImlGen_generateNewInstruction_r_r(ppcImlGenContext, NULL, PPCREC_IML_OP_AND, registerRA, registerRA, 0, PPCREC_CR_MODE_LOGICAL);
+		PPCImlGen_UpdateCR0(ppcImlGenContext, regR);
 	return true;
 }
 
@@ -1381,61 +1117,61 @@ bool PPCRecompilerImlGen_RLWNM(ppcImlGenContext_t* ppcImlGenContext, uint32 opco
 {
 	sint32 rS, rA, rB, MB, ME;
 	PPC_OPC_TEMPL_M(opcode, rS, rA, rB, MB, ME);
-	//	uint32 v = ppc_word_rotl(hCPU->gpr[rS], hCPU->gpr[rB]);
 	uint32 mask = ppc_mask(MB, ME);
-	//	uint32 v = ppc_word_rotl(hCPU->gpr[rS], hCPU->gpr[rB]);
-	//	hCPU->gpr[rA] = v & mask;
-	uint32 registerRS = PPCRecompilerImlGen_loadRegister(ppcImlGenContext, PPCREC_NAME_R0+rS, false);
-	uint32 registerRB = PPCRecompilerImlGen_loadRegister(ppcImlGenContext, PPCREC_NAME_R0+rB, false);
-	uint32 registerRA = PPCRecompilerImlGen_loadOverwriteRegister(ppcImlGenContext, PPCREC_NAME_R0+rA);
-
-	PPCRecompilerImlGen_generateNewInstruction_r_r_r(ppcImlGenContext, PPCREC_IML_OP_LEFT_ROTATE, registerRA, registerRS, registerRB);
+	IMLReg regS = PPCRecompilerImlGen_loadRegister(ppcImlGenContext, PPCREC_NAME_R0+rS);
+	IMLReg regB = PPCRecompilerImlGen_loadRegister(ppcImlGenContext, PPCREC_NAME_R0+rB);
+	IMLReg regA = PPCRecompilerImlGen_loadRegister(ppcImlGenContext, PPCREC_NAME_R0+rA);
+	ppcImlGenContext->emitInst().make_r_r_r(PPCREC_IML_OP_LEFT_ROTATE, regA, regS, regB);
+	if( mask != 0xFFFFFFFF )
+		ppcImlGenContext->emitInst().make_r_r_s32(PPCREC_IML_OP_AND, regA, regA, (sint32)mask);
 	if (opcode & PPC_OPC_RC)
-	{
-		PPCRecompilerImlGen_generateNewInstruction_r_s32(ppcImlGenContext, PPCREC_IML_OP_AND, registerRA, (sint32)mask, 32, false, false, 0, PPCREC_CR_MODE_LOGICAL);
-	}
-	else
-	{
-		if( mask != 0xFFFFFFFF )
-			PPCRecompilerImlGen_generateNewInstruction_r_s32(ppcImlGenContext, PPCREC_IML_OP_AND, registerRA, (sint32)mask, 32, false, false, PPC_REC_INVALID_REGISTER, 0);
-	}
+		PPCImlGen_UpdateCR0(ppcImlGenContext, regA);
 	return true;
 }
 
 bool PPCRecompilerImlGen_SRAW(ppcImlGenContext_t* ppcImlGenContext, uint32 opcode)
 {
+	// unlike SRAWI, for SRAW the shift range is 0-63 (masked to 6 bits)
+	// but only shifts up to register bitwidth minus one are well defined in IML so this requires special handling for shifts >= 32
 	sint32 rS, rA, rB;
 	PPC_OPC_TEMPL_X(opcode, rS, rA, rB);
-	//uint32 SH = hCPU->gpr[rB] & 0x3f;
-	//hCPU->gpr[rA] = hCPU->gpr[rS];
-	//hCPU->xer_ca = 0;
-	//if (hCPU->gpr[rA] & 0x80000000) {
-	//	uint32 ca = 0;
-	//	for (uint32 i=0; i < SH; i++) {
-	//		if (hCPU->gpr[rA] & 1) ca = 1;
-	//		hCPU->gpr[rA] >>= 1;
-	//		hCPU->gpr[rA] |= 0x80000000;
-	//	}
-	//	if (ca) hCPU->xer_ca = 1;
-	//} else {
-	//	if (SH > 31) {
-	//		hCPU->gpr[rA] = 0;
-	//	} else {
-	//		hCPU->gpr[rA] >>= SH;
-	//	}
-	//}     
-	//if (Opcode & PPC_OPC_RC) {
-	//	// update cr0 flags
-	//	ppc_update_cr0(hCPU, hCPU->gpr[rA]);
-	//}
+	IMLReg regS = PPCRecompilerImlGen_loadRegister(ppcImlGenContext, PPCREC_NAME_R0+rS);
+	IMLReg regB = PPCRecompilerImlGen_loadRegister(ppcImlGenContext, PPCREC_NAME_R0+rB);
+	IMLReg regA = PPCRecompilerImlGen_loadRegister(ppcImlGenContext, PPCREC_NAME_R0+rA);
+	IMLReg regCarry = PPCRecompilerImlGen_loadRegister(ppcImlGenContext, PPCREC_NAME_XER_CA);
 
-	uint32 registerRS = PPCRecompilerImlGen_loadRegister(ppcImlGenContext, PPCREC_NAME_R0+rS, false);
-	uint32 registerRB = PPCRecompilerImlGen_loadRegister(ppcImlGenContext, PPCREC_NAME_R0+rB, false);
-	uint32 registerRA = PPCRecompilerImlGen_loadOverwriteRegister(ppcImlGenContext, PPCREC_NAME_R0+rA);
-	if( (opcode&PPC_OPC_RC) != 0 )
-		PPCRecompilerImlGen_generateNewInstruction_r_r_r(ppcImlGenContext, PPCREC_IML_OP_SRAW, registerRA, registerRS, registerRB, 0, PPCREC_CR_MODE_LOGICAL);
-	else
-		PPCRecompilerImlGen_generateNewInstruction_r_r_r(ppcImlGenContext, PPCREC_IML_OP_SRAW, registerRA, registerRS, registerRB);
+	IMLReg regTmpShiftAmount = PPCRecompilerImlGen_loadRegister(ppcImlGenContext, PPCREC_NAME_TEMPORARY + 0);
+	IMLReg regTmpCondBool = PPCRecompilerImlGen_loadRegister(ppcImlGenContext, PPCREC_NAME_TEMPORARY + 1);
+	IMLReg regTmp1 = PPCRecompilerImlGen_loadRegister(ppcImlGenContext, PPCREC_NAME_TEMPORARY + 2);
+	IMLReg regTmp2 = PPCRecompilerImlGen_loadRegister(ppcImlGenContext, PPCREC_NAME_TEMPORARY + 3);
+
+	// load masked shift factor into temporary register
+	ppcImlGenContext->emitInst().make_r_r_s32(PPCREC_IML_OP_AND, regTmpShiftAmount, regB, 0x3F);
+	ppcImlGenContext->emitInst().make_compare_s32(regTmpShiftAmount, 31, regTmpCondBool, IMLCondition::UNSIGNED_GT);
+	ppcImlGenContext->emitInst().make_conditional_jump(regTmpCondBool, true);
+
+	PPCIMLGen_CreateSegmentBranchedPath(*ppcImlGenContext, *ppcImlGenContext->currentBasicBlock,
+		[&](ppcImlGenContext_t& genCtx)
+		{
+			/* branch taken, shift size 32 or above */
+			genCtx.emitInst().make_r_r_s32(PPCREC_IML_OP_RIGHT_SHIFT_S, regA, regS, 31); // shift the sign bit into all the bits
+			genCtx.emitInst().make_compare_s32(regA, 0, regCarry, IMLCondition::NEQ);
+		},
+		[&](ppcImlGenContext_t& genCtx) 
+		{
+			/* branch not taken, shift size below 32 */
+			genCtx.emitInst().make_r_r_s32(PPCREC_IML_OP_RIGHT_SHIFT_S, regTmp1, regS, 31); // signMask = input >> 31 (arithmetic shift)
+			genCtx.emitInst().make_r_s32(PPCREC_IML_OP_ASSIGN, regTmp2, 1); // shiftMask = ((1<<SH)-1)
+			genCtx.emitInst().make_r_r_r(PPCREC_IML_OP_LEFT_SHIFT, regTmp2, regTmp2, regTmpShiftAmount);
+			genCtx.emitInst().make_r_r_s32(PPCREC_IML_OP_SUB, regTmp2, regTmp2, 1);
+			genCtx.emitInst().make_r_r_r(PPCREC_IML_OP_AND, regTmp1, regTmp1, regTmp2); // signMask & shiftMask & input
+			genCtx.emitInst().make_r_r_r(PPCREC_IML_OP_AND, regTmp1, regTmp1, regS);
+			genCtx.emitInst().make_compare_s32(regTmp1, 0, regCarry, IMLCondition::NEQ);
+			genCtx.emitInst().make_r_r_r(PPCREC_IML_OP_RIGHT_SHIFT_S, regA, regS, regTmpShiftAmount);
+		}
+	);
+	if (opcode & PPC_OPC_RC)
+		PPCImlGen_UpdateCR0(ppcImlGenContext, regA);
 	return true;
 }
 
@@ -1445,12 +1181,21 @@ bool PPCRecompilerImlGen_SRAWI(ppcImlGenContext_t* ppcImlGenContext, uint32 opco
 	uint32 SH;
 	PPC_OPC_TEMPL_X(opcode, rS, rA, SH);
 	cemu_assert_debug(SH < 32);
-	uint32 registerRS = PPCRecompilerImlGen_loadRegister(ppcImlGenContext, PPCREC_NAME_R0+rS, false);
-	uint32 registerRA = PPCRecompilerImlGen_loadOverwriteRegister(ppcImlGenContext, PPCREC_NAME_R0+rA);
-	if( opcode&PPC_OPC_RC )
-		PPCRecompilerImlGen_generateNewInstruction_r_r_s32(ppcImlGenContext, PPCREC_IML_OP_SRAW, registerRA, registerRS, (sint32)SH, 0, PPCREC_CR_MODE_LOGICAL);
-	else
-		PPCRecompilerImlGen_generateNewInstruction_r_r_s32(ppcImlGenContext, PPCREC_IML_OP_SRAW, registerRA, registerRS, (sint32)SH);
+	if (SH == 0)
+		return false; // becomes a no-op (unless RC bit is set) but also sets ca bit to 0?
+	IMLReg regS = PPCRecompilerImlGen_loadRegister(ppcImlGenContext, PPCREC_NAME_R0 + rS);
+	IMLReg regA = PPCRecompilerImlGen_loadRegister(ppcImlGenContext, PPCREC_NAME_R0 + rA);
+	IMLReg regCarry = PPCRecompilerImlGen_loadRegister(ppcImlGenContext, PPCREC_NAME_XER_CA);
+	IMLReg regTmp = PPCRecompilerImlGen_loadRegister(ppcImlGenContext, PPCREC_NAME_TEMPORARY + 0);
+	// calculate CA first
+	ppcImlGenContext->emitInst().make_r_r_s32(PPCREC_IML_OP_RIGHT_SHIFT_S, regTmp, regS, 31); // signMask = input >> 31 (arithmetic shift)
+	ppcImlGenContext->emitInst().make_r_r_r(PPCREC_IML_OP_AND, regTmp, regTmp, regS); // testValue = input & signMask & ((1<<SH)-1)
+	ppcImlGenContext->emitInst().make_r_r_s32(PPCREC_IML_OP_AND, regTmp, regTmp, ((1 << SH) - 1));
+	ppcImlGenContext->emitInst().make_compare_s32(regTmp, 0, regCarry, IMLCondition::NEQ); // ca = (testValue != 0)
+	// do the actual shift
+	ppcImlGenContext->emitInst().make_r_r_s32(PPCREC_IML_OP_RIGHT_SHIFT_S, regA, regS, (sint32)SH);
+	if (opcode & PPC_OPC_RC)
+		PPCImlGen_UpdateCR0(ppcImlGenContext, regA);
 	return true;
 }
 
@@ -1459,17 +1204,12 @@ bool PPCRecompilerImlGen_SLW(ppcImlGenContext_t* ppcImlGenContext, uint32 opcode
 	int rS, rA, rB;
 	PPC_OPC_TEMPL_X(opcode, rS, rA, rB);
 
-	uint32 registerRS = PPCRecompilerImlGen_loadRegister(ppcImlGenContext, PPCREC_NAME_R0+rS, false);
-	uint32 registerRB = PPCRecompilerImlGen_loadRegister(ppcImlGenContext, PPCREC_NAME_R0+rB, false);
-	uint32 registerRA = PPCRecompilerImlGen_loadOverwriteRegister(ppcImlGenContext, PPCREC_NAME_R0+rA);
-	if (opcode & PPC_OPC_RC)
-	{
-		PPCRecompilerImlGen_generateNewInstruction_r_r_r(ppcImlGenContext, PPCREC_IML_OP_SLW, registerRA, registerRS, registerRB, 0, PPCREC_CR_MODE_LOGICAL);
-	}
-	else
-	{
-		PPCRecompilerImlGen_generateNewInstruction_r_r_r(ppcImlGenContext, PPCREC_IML_OP_SLW, registerRA, registerRS, registerRB, PPC_REC_INVALID_REGISTER, 0);
-	}
+	IMLReg regS = _GetRegGPR(ppcImlGenContext, rS);
+	IMLReg regB = _GetRegGPR(ppcImlGenContext, rB);
+	IMLReg regA = _GetRegGPR(ppcImlGenContext, rA);
+	ppcImlGenContext->emitInst().make_r_r_r(PPCREC_IML_OP_SLW, regA, regS, regB);
+	if ((opcode & PPC_OPC_RC))
+		PPCImlGen_UpdateCR0(ppcImlGenContext, regA);
 	return true;
 }
 
@@ -1477,37 +1217,24 @@ bool PPCRecompilerImlGen_SRW(ppcImlGenContext_t* ppcImlGenContext, uint32 opcode
 {
 	int rS, rA, rB;
 	PPC_OPC_TEMPL_X(opcode, rS, rA, rB);
-
-	uint32 registerRS = PPCRecompilerImlGen_loadRegister(ppcImlGenContext, PPCREC_NAME_R0+rS, false);
-	uint32 registerRB = PPCRecompilerImlGen_loadRegister(ppcImlGenContext, PPCREC_NAME_R0+rB, false);
-	uint32 registerRA = PPCRecompilerImlGen_loadOverwriteRegister(ppcImlGenContext, PPCREC_NAME_R0+rA);
+	IMLReg regS = _GetRegGPR(ppcImlGenContext, rS);
+	IMLReg regB = _GetRegGPR(ppcImlGenContext, rB);
+	IMLReg regA = _GetRegGPR(ppcImlGenContext, rA);
+	ppcImlGenContext->emitInst().make_r_r_r(PPCREC_IML_OP_SRW, regA, regS, regB);
 	if (opcode & PPC_OPC_RC)
-	{
-		PPCRecompilerImlGen_generateNewInstruction_r_r_r(ppcImlGenContext, PPCREC_IML_OP_SRW, registerRA, registerRS, registerRB, 0, PPCREC_CR_MODE_LOGICAL);
-	}
-	else
-	{
-		PPCRecompilerImlGen_generateNewInstruction_r_r_r(ppcImlGenContext, PPCREC_IML_OP_SRW, registerRA, registerRS, registerRB, PPC_REC_INVALID_REGISTER, 0);
-	}
+		PPCImlGen_UpdateCR0(ppcImlGenContext, regA);
 	return true;
 }
 
-
 bool PPCRecompilerImlGen_EXTSH(ppcImlGenContext_t* ppcImlGenContext, uint32 opcode)
 {
 	int rS, rA, rB;
 	PPC_OPC_TEMPL_X(opcode, rS, rA, rB);
-	PPC_ASSERT(rB==0);
-	uint32 registerRS = PPCRecompilerImlGen_loadRegister(ppcImlGenContext, PPCREC_NAME_R0+rS, false);
-	uint32 registerRA = PPCRecompilerImlGen_loadOverwriteRegister(ppcImlGenContext, PPCREC_NAME_R0+rA);
-	if ( opcode&PPC_OPC_RC )
-	{
-		PPCRecompilerImlGen_generateNewInstruction_r_r(ppcImlGenContext, NULL, PPCREC_IML_OP_ASSIGN_S16_TO_S32, registerRA, registerRS, 0, PPCREC_CR_MODE_ARITHMETIC);
-	}
-	else
-	{
-		PPCRecompilerImlGen_generateNewInstruction_r_r(ppcImlGenContext, NULL, PPCREC_IML_OP_ASSIGN_S16_TO_S32, registerRA, registerRS);
-	}
+	IMLReg regS = _GetRegGPR(ppcImlGenContext, rS);
+	IMLReg regA = _GetRegGPR(ppcImlGenContext, rA);
+	ppcImlGenContext->emitInst().make_r_r(PPCREC_IML_OP_ASSIGN_S16_TO_S32, regA, regS);
+	if (opcode & PPC_OPC_RC)
+		PPCImlGen_UpdateCR0(ppcImlGenContext, regA);
 	return true;
 }
 
@@ -1515,16 +1242,11 @@ bool PPCRecompilerImlGen_EXTSB(ppcImlGenContext_t* ppcImlGenContext, uint32 opco
 {
 	sint32 rS, rA, rB;
 	PPC_OPC_TEMPL_X(opcode, rS, rA, rB);
-	uint32 registerRS = PPCRecompilerImlGen_loadRegister(ppcImlGenContext, PPCREC_NAME_R0+rS, false);
-	uint32 registerRA = PPCRecompilerImlGen_loadOverwriteRegister(ppcImlGenContext, PPCREC_NAME_R0+rA);
-	if ( opcode&PPC_OPC_RC )
-	{
-		PPCRecompilerImlGen_generateNewInstruction_r_r(ppcImlGenContext, NULL, PPCREC_IML_OP_ASSIGN_S8_TO_S32, registerRA, registerRS, 0, PPCREC_CR_MODE_ARITHMETIC);
-	}
-	else
-	{
-		PPCRecompilerImlGen_generateNewInstruction_r_r(ppcImlGenContext, NULL, PPCREC_IML_OP_ASSIGN_S8_TO_S32, registerRA, registerRS);
-	}
+	IMLReg regS = _GetRegGPR(ppcImlGenContext, rS);
+	IMLReg regA = _GetRegGPR(ppcImlGenContext, rA);
+	ppcImlGenContext->emitInst().make_r_r(PPCREC_IML_OP_ASSIGN_S8_TO_S32, regA, regS);
+	if ((opcode & PPC_OPC_RC))
+		PPCImlGen_UpdateCR0(ppcImlGenContext, regA);
 	return true;
 }
 
@@ -1532,30 +1254,11 @@ bool PPCRecompilerImlGen_CNTLZW(ppcImlGenContext_t* ppcImlGenContext, uint32 opc
 {
 	sint32 rS, rA, rB;
 	PPC_OPC_TEMPL_X(opcode, rS, rA, rB);
-	PPC_ASSERT(rB==0);
-	if( opcode&PPC_OPC_RC )
-	{
-		return false;
-	}
-	uint32 registerRS = PPCRecompilerImlGen_loadRegister(ppcImlGenContext, PPCREC_NAME_R0+rS, false);
-	uint32 registerRA = PPCRecompilerImlGen_loadOverwriteRegister(ppcImlGenContext, PPCREC_NAME_R0+rA);
-	PPCRecompilerImlGen_generateNewInstruction_r_r(ppcImlGenContext, NULL, PPCREC_IML_OP_CNTLZW, registerRA, registerRS);
-
-	//uint32 n=0;
-	//uint32 x=0x80000000;
-	//uint32 v=hCPU->gpr[rS];
-	//while (!(v & x)) {
-	//	n++;
-	//	if (n==32) break;
-	//	x>>=1;
-	//}
-	//hCPU->gpr[rA] = n;
-	//if (Opcode & PPC_OPC_RC) {
-	//	// update cr0 flags
-	//	ppc_update_cr0(hCPU, hCPU->gpr[rA]);
-	//}
-
-
+	IMLReg regS = _GetRegGPR(ppcImlGenContext, rS);
+	IMLReg regA = _GetRegGPR(ppcImlGenContext, rA);
+	ppcImlGenContext->emitInst().make_r_r(PPCREC_IML_OP_CNTLZW, regA, regS);
+	if ((opcode & PPC_OPC_RC))
+		PPCImlGen_UpdateCR0(ppcImlGenContext, regA);
 	return true;
 }
 
@@ -1563,438 +1266,124 @@ bool PPCRecompilerImlGen_NEG(ppcImlGenContext_t* ppcImlGenContext, uint32 opcode
 {
 	sint32 rD, rA, rB;
 	PPC_OPC_TEMPL_XO(opcode, rD, rA, rB);
-	PPC_ASSERT(rB == 0);
-	//hCPU->gpr[rD] = -((signed int)hCPU->gpr[rA]);
-	//if (Opcode & PPC_OPC_RC) {
-	//	// update cr0 flags
-	//	ppc_update_cr0(hCPU, hCPU->gpr[rD]);
-	//}
-	uint32 registerRA = PPCRecompilerImlGen_loadRegister(ppcImlGenContext, PPCREC_NAME_R0+rA, false);
-	uint32 registerRD = PPCRecompilerImlGen_loadOverwriteRegister(ppcImlGenContext, PPCREC_NAME_R0+rD);
-	if( opcode&PPC_OPC_RC )
-	{
-		PPCRecompilerImlGen_generateNewInstruction_r_r(ppcImlGenContext, NULL, PPCREC_IML_OP_NEG, registerRD, registerRA, 0, PPCREC_CR_MODE_ARITHMETIC);
-	}
-	else
-	{
-		PPCRecompilerImlGen_generateNewInstruction_r_r(ppcImlGenContext, NULL, PPCREC_IML_OP_NEG, registerRD, registerRA);
-	}
+	IMLReg regA = _GetRegGPR(ppcImlGenContext, rA);
+	IMLReg regD = _GetRegGPR(ppcImlGenContext, rD);
+	ppcImlGenContext->emitInst().make_r_r(PPCREC_IML_OP_NEG, regD, regA);
+	if (opcode & PPC_OPC_RC)
+		PPCImlGen_UpdateCR0(ppcImlGenContext, regD);
 	return true;
 }
 
-void PPCRecompilerImlGen_LWZ(ppcImlGenContext_t* ppcImlGenContext, uint32 opcode)
+bool PPCRecompilerImlGen_LOAD(ppcImlGenContext_t* ppcImlGenContext, uint32 opcode, uint32 bitWidth, bool signExtend, bool isBigEndian, bool updateAddrReg)
 {
 	int rA, rD;
 	uint32 imm;
 	PPC_OPC_TEMPL_D_SImm(opcode, rD, rA, imm);
-	if( rA == 0 )
-	{
-		// special form where gpr is ignored and only imm is used
-		PPCRecompilerImlGen_generateNewInstruction_macro(ppcImlGenContext, PPCREC_IML_MACRO_DEBUGBREAK, ppcImlGenContext->ppcAddressOfCurrentInstruction, ppcImlGenContext->ppcAddressOfCurrentInstruction, ppcImlGenContext->cyclesSinceLastBranch);
-		return;
-	}
-	// load memory gpr into register
-	uint32 gprRegister = PPCRecompilerImlGen_loadRegister(ppcImlGenContext, PPCREC_NAME_R0+rA, false);
-	// check if destination register is already loaded
-	uint32 destinationRegister = PPCRecompilerImlGen_findRegisterByMappedName(ppcImlGenContext, PPCREC_NAME_R0+rD);
-	if( destinationRegister == PPC_REC_INVALID_REGISTER )
-		destinationRegister = PPCRecompilerImlGen_getAndLockFreeTemporaryGPR(ppcImlGenContext, PPCREC_NAME_R0+rD); // else just create new register
-	// load half
-	PPCRecompilerImlGen_generateNewInstruction_r_memory(ppcImlGenContext, destinationRegister, gprRegister, imm, 32, false, true);
-}
-
-void PPCRecompilerImlGen_LWZU(ppcImlGenContext_t* ppcImlGenContext, uint32 opcode)
-{
-	int rA, rD;
-	uint32 imm;
-	PPC_OPC_TEMPL_D_SImm(opcode, rD, rA, imm);
-	if( rA == 0 )
-	{
-		// special form where gpr is ignored and only imm is used
-		PPCRecompilerImlGen_generateNewInstruction_macro(ppcImlGenContext, PPCREC_IML_MACRO_DEBUGBREAK, ppcImlGenContext->ppcAddressOfCurrentInstruction, ppcImlGenContext->ppcAddressOfCurrentInstruction, ppcImlGenContext->cyclesSinceLastBranch);
-		return;
-	}
-	// load memory gpr into register
-	uint32 gprRegister = PPCRecompilerImlGen_loadRegister(ppcImlGenContext, PPCREC_NAME_R0+rA, false);
-	// add imm to memory register
-	PPCRecompilerImlGen_generateNewInstruction_r_s32(ppcImlGenContext, PPCREC_IML_OP_ADD, gprRegister, (sint32)imm, 0, false, false, PPC_REC_INVALID_REGISTER, 0);
-	// check if destination register is already loaded
-	uint32 destinationRegister = PPCRecompilerImlGen_findRegisterByMappedName(ppcImlGenContext, PPCREC_NAME_R0+rD);
-	if( destinationRegister == PPC_REC_INVALID_REGISTER )
-		destinationRegister = PPCRecompilerImlGen_getAndLockFreeTemporaryGPR(ppcImlGenContext, PPCREC_NAME_R0+rD); // else just create new register
-	// load half
-	PPCRecompilerImlGen_generateNewInstruction_r_memory(ppcImlGenContext, destinationRegister, gprRegister, 0, 32, false, true);
-}
-
-void PPCRecompilerImlGen_LHA(ppcImlGenContext_t* ppcImlGenContext, uint32 opcode)
-{
-	int rA, rD;
-	uint32 imm;
-	PPC_OPC_TEMPL_D_SImm(opcode, rD, rA, imm);
-	if( rA == 0 )
-	{
-		// special form where gpr is ignored and only imm is used
-		PPCRecompilerImlGen_generateNewInstruction_macro(ppcImlGenContext, PPCREC_IML_MACRO_DEBUGBREAK, ppcImlGenContext->ppcAddressOfCurrentInstruction, ppcImlGenContext->ppcAddressOfCurrentInstruction, ppcImlGenContext->cyclesSinceLastBranch);
-		return;
-	}
-	// load memory gpr into register
-	uint32 gprRegister = PPCRecompilerImlGen_loadRegister(ppcImlGenContext, PPCREC_NAME_R0+rA, false);
-	// check if destination register is already loaded
-	uint32 destinationRegister = PPCRecompilerImlGen_findRegisterByMappedName(ppcImlGenContext, PPCREC_NAME_R0+rD);
-	if( destinationRegister == PPC_REC_INVALID_REGISTER )
-		destinationRegister = PPCRecompilerImlGen_getAndLockFreeTemporaryGPR(ppcImlGenContext, PPCREC_NAME_R0+rD); // else just create new temporary register
-	// load half
-	PPCRecompilerImlGen_generateNewInstruction_r_memory(ppcImlGenContext, destinationRegister, gprRegister, imm, 16, true, true);
-}
-
-void PPCRecompilerImlGen_LHAU(ppcImlGenContext_t* ppcImlGenContext, uint32 opcode)
-{
-	sint32 rA, rD;
-	uint32 imm;
-	PPC_OPC_TEMPL_D_SImm(opcode, rD, rA, imm);
-	if( rA == 0 )
-	{
-		// special form where gpr is ignored and only imm is used
-		PPCRecompilerImlGen_generateNewInstruction_macro(ppcImlGenContext, PPCREC_IML_MACRO_DEBUGBREAK, ppcImlGenContext->ppcAddressOfCurrentInstruction, ppcImlGenContext->ppcAddressOfCurrentInstruction, ppcImlGenContext->cyclesSinceLastBranch);
-		return;
-	}
-	// load memory gpr into register
-	uint32 gprRegister = PPCRecompilerImlGen_loadRegister(ppcImlGenContext, PPCREC_NAME_R0+rA, false);
-	// add imm to memory register
-	PPCRecompilerImlGen_generateNewInstruction_r_s32(ppcImlGenContext, PPCREC_IML_OP_ADD, gprRegister, (sint32)imm, 0, false, false, PPC_REC_INVALID_REGISTER, 0);
-	// check if destination register is already loaded
-	uint32 destinationRegister = PPCRecompilerImlGen_findRegisterByMappedName(ppcImlGenContext, PPCREC_NAME_R0+rD);
-	if( destinationRegister == PPC_REC_INVALID_REGISTER )
-		destinationRegister = PPCRecompilerImlGen_getAndLockFreeTemporaryGPR(ppcImlGenContext, PPCREC_NAME_R0+rD); // else just create new temporary register
-	// load half
-	PPCRecompilerImlGen_generateNewInstruction_r_memory(ppcImlGenContext, destinationRegister, gprRegister, 0, 16, true, true);
-}
-
-void PPCRecompilerImlGen_LHZ(ppcImlGenContext_t* ppcImlGenContext, uint32 opcode)
-{
-	sint32 rA, rD;
-	uint32 imm;
-	PPC_OPC_TEMPL_D_SImm(opcode, rD, rA, imm);
-	if( rA == 0 )
-	{
-		// special form where gpr is ignored and only imm is used
-		// note: Darksiders 2 has this instruction form but it is never executed.
-		PPCRecompilerImlGen_generateNewInstruction_macro(ppcImlGenContext, PPCREC_IML_MACRO_DEBUGBREAK, ppcImlGenContext->ppcAddressOfCurrentInstruction, ppcImlGenContext->ppcAddressOfCurrentInstruction, ppcImlGenContext->cyclesSinceLastBranch);
-		return;
-	}
-	// load memory gpr into register
-	uint32 gprRegister = PPCRecompilerImlGen_loadRegister(ppcImlGenContext, PPCREC_NAME_R0+rA, false);
-	// check if destination register is already loaded
-	uint32 destinationRegister = PPCRecompilerImlGen_findRegisterByMappedName(ppcImlGenContext, PPCREC_NAME_R0+rD);
-	if( destinationRegister == PPC_REC_INVALID_REGISTER )
-		destinationRegister = PPCRecompilerImlGen_getAndLockFreeTemporaryGPR(ppcImlGenContext, PPCREC_NAME_R0+rD); // else just create new temporary register
-	// load half
-	PPCRecompilerImlGen_generateNewInstruction_r_memory(ppcImlGenContext, destinationRegister, gprRegister, imm, 16, false, true);
-}
-
-void PPCRecompilerImlGen_LHZU(ppcImlGenContext_t* ppcImlGenContext, uint32 opcode)
-{
-	sint32 rA, rD;
-	uint32 imm;
-	PPC_OPC_TEMPL_D_SImm(opcode, rD, rA, imm);
-	if( rA == 0 )
-	{
-		// special form where gpr is ignored and only imm is used
-		PPCRecompilerImlGen_generateNewInstruction_macro(ppcImlGenContext, PPCREC_IML_MACRO_DEBUGBREAK, ppcImlGenContext->ppcAddressOfCurrentInstruction, ppcImlGenContext->ppcAddressOfCurrentInstruction, ppcImlGenContext->cyclesSinceLastBranch);
-		return;
-	}
-	// load memory gpr into register
-	uint32 gprRegister = PPCRecompilerImlGen_loadRegister(ppcImlGenContext, PPCREC_NAME_R0+rA, false);
-	// add imm to memory register
-	PPCRecompilerImlGen_generateNewInstruction_r_s32(ppcImlGenContext, PPCREC_IML_OP_ADD, gprRegister, (sint32)imm, 0, false, false, PPC_REC_INVALID_REGISTER, 0);
-	// check if destination register is already loaded
-	uint32 destinationRegister = PPCRecompilerImlGen_findRegisterByMappedName(ppcImlGenContext, PPCREC_NAME_R0+rD);
-	if( destinationRegister == PPC_REC_INVALID_REGISTER )
-		destinationRegister = PPCRecompilerImlGen_getAndLockFreeTemporaryGPR(ppcImlGenContext, PPCREC_NAME_R0+rD); // else just create new temporary register
-	// load half
-	PPCRecompilerImlGen_generateNewInstruction_r_memory(ppcImlGenContext, destinationRegister, gprRegister, 0, 16, false, true);
-}
-
-void PPCRecompilerImlGen_LBZ(ppcImlGenContext_t* ppcImlGenContext, uint32 opcode)
-{
-	int rA, rD;
-	uint32 imm;
-	PPC_OPC_TEMPL_D_SImm(opcode, rD, rA, imm);
-	if( rA == 0 )
-	{
-		// special form where gpr is ignored and only imm is used
-		PPCRecompilerImlGen_generateNewInstruction_macro(ppcImlGenContext, PPCREC_IML_MACRO_DEBUGBREAK, ppcImlGenContext->ppcAddressOfCurrentInstruction, ppcImlGenContext->ppcAddressOfCurrentInstruction, ppcImlGenContext->cyclesSinceLastBranch);
-		return;
-	}
-	// load memory gpr into register
-	uint32 gprRegister = PPCRecompilerImlGen_loadRegister(ppcImlGenContext, PPCREC_NAME_R0+rA, false);
-	// check if destination register is already loaded
-	uint32 destinationRegister = PPCRecompilerImlGen_findRegisterByMappedName(ppcImlGenContext, PPCREC_NAME_R0+rD);
-	if( destinationRegister == PPC_REC_INVALID_REGISTER )
-		destinationRegister = PPCRecompilerImlGen_getAndLockFreeTemporaryGPR(ppcImlGenContext, PPCREC_NAME_R0+rD); // else just create new register
-	// load byte
-	PPCRecompilerImlGen_generateNewInstruction_r_memory(ppcImlGenContext, destinationRegister, gprRegister, imm, 8, false, true);
-}
-
-void PPCRecompilerImlGen_LBZU(ppcImlGenContext_t* ppcImlGenContext, uint32 opcode)
-{
-	int rA, rD;
-	uint32 imm;
-	PPC_OPC_TEMPL_D_SImm(opcode, rD, rA, imm);
-	if( rA == 0 )
-	{
-		// special form where gpr is ignored and only imm is used
-		PPCRecompilerImlGen_generateNewInstruction_macro(ppcImlGenContext, PPCREC_IML_MACRO_DEBUGBREAK, ppcImlGenContext->ppcAddressOfCurrentInstruction, ppcImlGenContext->ppcAddressOfCurrentInstruction, ppcImlGenContext->cyclesSinceLastBranch);
-		return;
-	}
-	// load memory gpr into register
-	uint32 gprRegister = PPCRecompilerImlGen_loadRegister(ppcImlGenContext, PPCREC_NAME_R0+rA, false);
-	// add imm to memory register
-	PPCRecompilerImlGen_generateNewInstruction_r_s32(ppcImlGenContext, PPCREC_IML_OP_ADD, gprRegister, (sint32)imm, 0, false, false, PPC_REC_INVALID_REGISTER, 0);
-	// check if destination register is already loaded
-	uint32 destinationRegister = PPCRecompilerImlGen_findRegisterByMappedName(ppcImlGenContext, PPCREC_NAME_R0+rD);
-	if( destinationRegister == PPC_REC_INVALID_REGISTER )
-		destinationRegister = PPCRecompilerImlGen_getAndLockFreeTemporaryGPR(ppcImlGenContext, PPCREC_NAME_R0+rD); // else just create new register
-	// load byte
-	PPCRecompilerImlGen_generateNewInstruction_r_memory(ppcImlGenContext, destinationRegister, gprRegister, 0, 8, false, true);
-}
-
-bool PPCRecompilerImlGen_LWZX(ppcImlGenContext_t* ppcImlGenContext, uint32 opcode)
-{
-	sint32 rA, rD, rB;
-	PPC_OPC_TEMPL_X(opcode, rD, rA, rB);
-	if( rA == 0 )
-	{
-		return false;
-	}
-	// hCPU->gpr[rD] = memory_readU8((rA?hCPU->gpr[rA]:0)+hCPU->gpr[rB]);
-	// load memory rA and rB into register
-	uint32 gprRegisterA = PPCRecompilerImlGen_loadRegister(ppcImlGenContext, PPCREC_NAME_R0+rA, false);
-	uint32 gprRegisterB = PPCRecompilerImlGen_loadRegister(ppcImlGenContext, PPCREC_NAME_R0+rB, false);
-	// check if destination register is already loaded
-	uint32 destinationRegister = PPCRecompilerImlGen_findRegisterByMappedName(ppcImlGenContext, PPCREC_NAME_R0+rD);
-	if( destinationRegister == PPC_REC_INVALID_REGISTER )
-		destinationRegister = PPCRecompilerImlGen_getAndLockFreeTemporaryGPR(ppcImlGenContext, PPCREC_NAME_R0+rD); // else just create new register
-	// load word
-	PPCRecompilerImlGen_generateNewInstruction_r_memory_indexed(ppcImlGenContext, destinationRegister, gprRegisterA, gprRegisterB, 32, false, true);
-	return true;
-}
-
-bool PPCRecompilerImlGen_LWZUX(ppcImlGenContext_t* ppcImlGenContext, uint32 opcode)
-{
-	sint32 rA, rD, rB;
-	PPC_OPC_TEMPL_X(opcode, rD, rA, rB);
-	if( rA == 0 )
-	{
-		return false;
-	}
-	// load memory rA and rB into register
-	uint32 gprRegisterA = PPCRecompilerImlGen_loadRegister(ppcImlGenContext, PPCREC_NAME_R0+rA, false);
-	uint32 gprRegisterB = PPCRecompilerImlGen_loadRegister(ppcImlGenContext, PPCREC_NAME_R0+rB, false);
-	// check if destination register is already loaded
-	uint32 destinationRegister = PPCRecompilerImlGen_findRegisterByMappedName(ppcImlGenContext, PPCREC_NAME_R0+rD);
-	if( destinationRegister == PPC_REC_INVALID_REGISTER )
-		destinationRegister = PPCRecompilerImlGen_getAndLockFreeTemporaryGPR(ppcImlGenContext, PPCREC_NAME_R0+rD); // else just create new register
-	// add rB to rA
-	PPCRecompilerImlGen_generateNewInstruction_r_r(ppcImlGenContext, NULL, PPCREC_IML_OP_ADD, gprRegisterA, gprRegisterB);
-	// load word
-	PPCRecompilerImlGen_generateNewInstruction_r_memory(ppcImlGenContext, destinationRegister, gprRegisterA, 0, 32, false, true);
-	return true;
-}
-
-bool PPCRecompilerImlGen_LWBRX(ppcImlGenContext_t* ppcImlGenContext, uint32 opcode)
-{
-	sint32 rA, rD, rB;
-	PPC_OPC_TEMPL_X(opcode, rD, rA, rB);
-	// load memory rA and rB into register
-	uint32 gprRegisterA = 0;
-	if( rA )
-		gprRegisterA = PPCRecompilerImlGen_loadRegister(ppcImlGenContext, PPCREC_NAME_R0 + rA, false);
-	uint32 gprRegisterB = PPCRecompilerImlGen_loadRegister(ppcImlGenContext, PPCREC_NAME_R0 + rB, false);
-	// check if destination register is already loaded
-	uint32 destinationRegister = PPCRecompilerImlGen_findRegisterByMappedName(ppcImlGenContext, PPCREC_NAME_R0 + rD);
-	if (destinationRegister == PPC_REC_INVALID_REGISTER)
-		destinationRegister = PPCRecompilerImlGen_getAndLockFreeTemporaryGPR(ppcImlGenContext, PPCREC_NAME_R0 + rD); // else just create new register
-	// load word
-	if( rA )
-		PPCRecompilerImlGen_generateNewInstruction_r_memory_indexed(ppcImlGenContext, destinationRegister, gprRegisterA, gprRegisterB, 32, false, false);
-	else
-		PPCRecompilerImlGen_generateNewInstruction_r_memory(ppcImlGenContext, destinationRegister, gprRegisterB, 0, 32, false, false);
-	return true;
-}
-
-bool PPCRecompilerImlGen_LHAX(ppcImlGenContext_t* ppcImlGenContext, uint32 opcode)
-{
-	sint32 rA, rD, rB;
-	PPC_OPC_TEMPL_X(opcode, rD, rA, rB);
-	if( rA == 0 )
-	{
-		// special form where gpr is ignored and only imm is used
-		PPCRecompilerImlGen_generateNewInstruction_macro(ppcImlGenContext, PPCREC_IML_MACRO_DEBUGBREAK, ppcImlGenContext->ppcAddressOfCurrentInstruction, ppcImlGenContext->ppcAddressOfCurrentInstruction, ppcImlGenContext->cyclesSinceLastBranch);
-		return true;
-	}
-	// load memory rA and rB into register
-	uint32 gprRegisterA = PPCRecompilerImlGen_loadRegister(ppcImlGenContext, PPCREC_NAME_R0+rA, false);
-	uint32 gprRegisterB = PPCRecompilerImlGen_loadRegister(ppcImlGenContext, PPCREC_NAME_R0+rB, false);
-	// check if destination register is already loaded
-	uint32 destinationRegister = PPCRecompilerImlGen_findRegisterByMappedName(ppcImlGenContext, PPCREC_NAME_R0+rD);
-	if( destinationRegister == PPC_REC_INVALID_REGISTER )
-		destinationRegister = PPCRecompilerImlGen_getAndLockFreeTemporaryGPR(ppcImlGenContext, PPCREC_NAME_R0+rD); // else just create new register
-	// load half word
-	PPCRecompilerImlGen_generateNewInstruction_r_memory_indexed(ppcImlGenContext, destinationRegister, gprRegisterA, gprRegisterB, 16, true, true);
-	return true;
-}
-
-bool PPCRecompilerImlGen_LHAUX(ppcImlGenContext_t* ppcImlGenContext, uint32 opcode)
-{
-	sint32 rA, rD, rB;
-	PPC_OPC_TEMPL_X(opcode, rD, rA, rB);
-	if( rA == 0 )
-	{
-		// special form where gpr is ignored and only imm is used
-		PPCRecompilerImlGen_generateNewInstruction_macro(ppcImlGenContext, PPCREC_IML_MACRO_DEBUGBREAK, ppcImlGenContext->ppcAddressOfCurrentInstruction, ppcImlGenContext->ppcAddressOfCurrentInstruction, ppcImlGenContext->cyclesSinceLastBranch);
-		return true;
-	}
-	// load memory rA and rB into register
-	uint32 gprRegisterA = PPCRecompilerImlGen_loadRegister(ppcImlGenContext, PPCREC_NAME_R0+rA, false);
-	uint32 gprRegisterB = PPCRecompilerImlGen_loadRegister(ppcImlGenContext, PPCREC_NAME_R0+rB, false);
-	// check if destination register is already loaded
-	uint32 destinationRegister = PPCRecompilerImlGen_findRegisterByMappedName(ppcImlGenContext, PPCREC_NAME_R0+rD);
-	if( destinationRegister == PPC_REC_INVALID_REGISTER )
-		destinationRegister = PPCRecompilerImlGen_getAndLockFreeTemporaryGPR(ppcImlGenContext, PPCREC_NAME_R0+rD); // else just create new register
-	// add rB to rA
-	PPCRecompilerImlGen_generateNewInstruction_r_r(ppcImlGenContext, NULL, PPCREC_IML_OP_ADD, gprRegisterA, gprRegisterB);
-	// load half word
-	PPCRecompilerImlGen_generateNewInstruction_r_memory(ppcImlGenContext, destinationRegister, gprRegisterA, 0, 16, true, true);
-	return true;
-}
-
-bool PPCRecompilerImlGen_LHZX(ppcImlGenContext_t* ppcImlGenContext, uint32 opcode)
-{
-	sint32 rA, rD, rB;
-	PPC_OPC_TEMPL_X(opcode, rD, rA, rB);
-	if( rA == 0 )
-	{
-		// special form where gpr is ignored and only imm is used
-		PPCRecompilerImlGen_generateNewInstruction_macro(ppcImlGenContext, PPCREC_IML_MACRO_DEBUGBREAK, ppcImlGenContext->ppcAddressOfCurrentInstruction, ppcImlGenContext->ppcAddressOfCurrentInstruction, ppcImlGenContext->cyclesSinceLastBranch);
-		return true;
-	}
-	// load memory rA and rB into register
-	uint32 gprRegisterA = PPCRecompilerImlGen_loadRegister(ppcImlGenContext, PPCREC_NAME_R0+rA, false);
-	uint32 gprRegisterB = PPCRecompilerImlGen_loadRegister(ppcImlGenContext, PPCREC_NAME_R0+rB, false);
-	// check if destination register is already loaded
-	uint32 destinationRegister = PPCRecompilerImlGen_findRegisterByMappedName(ppcImlGenContext, PPCREC_NAME_R0+rD);
-	if( destinationRegister == PPC_REC_INVALID_REGISTER )
-		destinationRegister = PPCRecompilerImlGen_getAndLockFreeTemporaryGPR(ppcImlGenContext, PPCREC_NAME_R0+rD); // else just create new register
-	// load half word
-	PPCRecompilerImlGen_generateNewInstruction_r_memory_indexed(ppcImlGenContext, destinationRegister, gprRegisterA, gprRegisterB, 16, false, true);
-	return true;
-}
-
-bool PPCRecompilerImlGen_LHZUX(ppcImlGenContext_t* ppcImlGenContext, uint32 opcode)
-{
-	sint32 rA, rD, rB;
-	PPC_OPC_TEMPL_X(opcode, rD, rA, rB);
-	if( rA == 0 )
-	{
-		// special form where gpr is ignored and only imm is used
-		PPCRecompilerImlGen_generateNewInstruction_macro(ppcImlGenContext, PPCREC_IML_MACRO_DEBUGBREAK, ppcImlGenContext->ppcAddressOfCurrentInstruction, ppcImlGenContext->ppcAddressOfCurrentInstruction, ppcImlGenContext->cyclesSinceLastBranch);
-		return true;
-	}
-	// load memory rA and rB into register
-	uint32 gprRegisterA = PPCRecompilerImlGen_loadRegister(ppcImlGenContext, PPCREC_NAME_R0+rA, false);
-	uint32 gprRegisterB = PPCRecompilerImlGen_loadRegister(ppcImlGenContext, PPCREC_NAME_R0+rB, false);
-	// check if destination register is already loaded
-	uint32 destinationRegister = PPCRecompilerImlGen_findRegisterByMappedName(ppcImlGenContext, PPCREC_NAME_R0+rD);
-	if( destinationRegister == PPC_REC_INVALID_REGISTER )
-		destinationRegister = PPCRecompilerImlGen_getAndLockFreeTemporaryGPR(ppcImlGenContext, PPCREC_NAME_R0+rD); // else just create new register
-	// add rB to rA
-	PPCRecompilerImlGen_generateNewInstruction_r_r(ppcImlGenContext, NULL, PPCREC_IML_OP_ADD, gprRegisterA, gprRegisterB);
-	// load hald word
-	PPCRecompilerImlGen_generateNewInstruction_r_memory(ppcImlGenContext, destinationRegister, gprRegisterA, 0, 16, false, true);
-	return true;
-}
-
-void PPCRecompilerImlGen_LHBRX(ppcImlGenContext_t* ppcImlGenContext, uint32 opcode)
-{
-	sint32 rA, rD, rB;
-	PPC_OPC_TEMPL_X(opcode, rD, rA, rB);
-	// load memory rA and rB into register
-	uint32 gprRegisterA = rA != 0 ? PPCRecompilerImlGen_loadRegister(ppcImlGenContext, PPCREC_NAME_R0 + rA, false) : 0;
-	uint32 gprRegisterB = PPCRecompilerImlGen_loadRegister(ppcImlGenContext, PPCREC_NAME_R0 + rB, false);
-	// check if destination register is already loaded
-	uint32 destinationRegister = PPCRecompilerImlGen_findRegisterByMappedName(ppcImlGenContext, PPCREC_NAME_R0 + rD);
-	if (destinationRegister == PPC_REC_INVALID_REGISTER)
-		destinationRegister = PPCRecompilerImlGen_getAndLockFreeTemporaryGPR(ppcImlGenContext, PPCREC_NAME_R0 + rD); // else just create new register
-	// load half word (little-endian)
-	if (rA == 0)
-		PPCRecompilerImlGen_generateNewInstruction_r_memory(ppcImlGenContext, destinationRegister, gprRegisterB, 0, 16, false, false);
-	else
-		PPCRecompilerImlGen_generateNewInstruction_r_memory_indexed(ppcImlGenContext, destinationRegister, gprRegisterA, gprRegisterB, 16, false, false);
-}
-
-bool PPCRecompilerImlGen_LBZX(ppcImlGenContext_t* ppcImlGenContext, uint32 opcode)
-{
-	sint32 rA, rD, rB;
-	PPC_OPC_TEMPL_X(opcode, rD, rA, rB);
-	if( rA == 0 )
-	{
-		// special case where rA is ignored and only rB is used
-		return false;
-	}
-	// hCPU->gpr[rD] = memory_readU8((rA?hCPU->gpr[rA]:0)+hCPU->gpr[rB]);
-	// load memory rA and rB into register
-	uint32 gprRegisterA = PPCRecompilerImlGen_loadRegister(ppcImlGenContext, PPCREC_NAME_R0+rA, false);
-	uint32 gprRegisterB = PPCRecompilerImlGen_loadRegister(ppcImlGenContext, PPCREC_NAME_R0+rB, false);
-	// check if destination register is already loaded
-	uint32 destinationRegister = PPCRecompilerImlGen_findRegisterByMappedName(ppcImlGenContext, PPCREC_NAME_R0+rD);
-	if( destinationRegister == PPC_REC_INVALID_REGISTER )
-		destinationRegister = PPCRecompilerImlGen_getAndLockFreeTemporaryGPR(ppcImlGenContext, PPCREC_NAME_R0+rD); // else just create new register
-	// load byte
-	PPCRecompilerImlGen_generateNewInstruction_r_memory_indexed(ppcImlGenContext, destinationRegister, gprRegisterA, gprRegisterB, 8, false, true);
-	return true;
-}
-
-bool PPCRecompilerImlGen_LBZUX(ppcImlGenContext_t* ppcImlGenContext, uint32 opcode)
-{
-	sint32 rA, rD, rB;
-	PPC_OPC_TEMPL_X(opcode, rD, rA, rB);
+	IMLReg regMemAddr;
 	if (rA == 0)
 	{
-		// special form where gpr is ignored and only imm is used
-		PPCRecompilerImlGen_generateNewInstruction_macro(ppcImlGenContext, PPCREC_IML_MACRO_DEBUGBREAK, ppcImlGenContext->ppcAddressOfCurrentInstruction, ppcImlGenContext->ppcAddressOfCurrentInstruction, ppcImlGenContext->cyclesSinceLastBranch);
-		return true;
+		if (updateAddrReg)
+			return false; // invalid instruction form
+		regMemAddr = _GetRegTemporary(ppcImlGenContext, 0);
+		ppcImlGenContext->emitInst().make_r_s32(PPCREC_IML_OP_ASSIGN, regMemAddr, 0);
 	}
-	// load memory rA and rB into register
-	uint32 gprRegisterA = PPCRecompilerImlGen_loadRegister(ppcImlGenContext, PPCREC_NAME_R0 + rA, false);
-	uint32 gprRegisterB = PPCRecompilerImlGen_loadRegister(ppcImlGenContext, PPCREC_NAME_R0 + rB, false);
-	// check if destination register is already loaded
-	uint32 destinationRegister = PPCRecompilerImlGen_findRegisterByMappedName(ppcImlGenContext, PPCREC_NAME_R0 + rD);
-	if (destinationRegister == PPC_REC_INVALID_REGISTER)
-		destinationRegister = PPCRecompilerImlGen_getAndLockFreeTemporaryGPR(ppcImlGenContext, PPCREC_NAME_R0 + rD); // else just create new register
-	// add rB to rA
-	PPCRecompilerImlGen_generateNewInstruction_r_r(ppcImlGenContext, NULL, PPCREC_IML_OP_ADD, gprRegisterA, gprRegisterB);
-	// load byte
-	PPCRecompilerImlGen_generateNewInstruction_r_memory(ppcImlGenContext, destinationRegister, gprRegisterA, 0, 8, false, true);
+	else
+	{
+		if (updateAddrReg && rA == rD)
+			return false; // invalid instruction form
+		regMemAddr = _GetRegGPR(ppcImlGenContext, rA);
+	}
+	if (updateAddrReg)
+	{
+		ppcImlGenContext->emitInst().make_r_r_s32(PPCREC_IML_OP_ADD, regMemAddr, regMemAddr, (sint32)imm);
+		imm = 0;
+	}
+	IMLReg regDst = _GetRegGPR(ppcImlGenContext, rD);
+	ppcImlGenContext->emitInst().make_r_memory(regDst, regMemAddr, (sint32)imm, bitWidth, signExtend, isBigEndian);
 	return true;
 }
 
-bool PPCRecompilerImlGen_LWARX(ppcImlGenContext_t* ppcImlGenContext, uint32 opcode)
+void PPCRecompilerImlGen_LOAD_INDEXED(ppcImlGenContext_t* ppcImlGenContext, uint32 opcode, uint32 bitWidth, bool signExtend, bool isBigEndian, bool updateAddrReg)
 {
+	// if rA == rD, then the EA wont be stored to rA. We could set updateAddrReg to false in such cases but the end result is the same since the loaded value would overwrite rA
 	sint32 rA, rD, rB;
 	PPC_OPC_TEMPL_X(opcode, rD, rA, rB);
-	// load memory rA and rB into register
-	uint32 gprRegisterA = rA != 0?PPCRecompilerImlGen_loadRegister(ppcImlGenContext, PPCREC_NAME_R0+rA, false):0;
-	uint32 gprRegisterB = PPCRecompilerImlGen_loadRegister(ppcImlGenContext, PPCREC_NAME_R0+rB, false);
-	// check if destination register is already loaded
-	uint32 destinationRegister = PPCRecompilerImlGen_findRegisterByMappedName(ppcImlGenContext, PPCREC_NAME_R0+rD);
-	if( destinationRegister == PPC_REC_INVALID_REGISTER )
-		destinationRegister = PPCRecompilerImlGen_getAndLockFreeTemporaryGPR(ppcImlGenContext, PPCREC_NAME_R0+rD); // else just create new register
-	// load word
-	if( rA != 0 )
-		PPCRecompilerImlGen_generateNewInstruction_r_memory_indexed(ppcImlGenContext, destinationRegister, gprRegisterA, gprRegisterB, PPC_REC_LOAD_LWARX_MARKER, false, true);
+	updateAddrReg = updateAddrReg && (rA != 0);
+	IMLReg regA = rA != 0 ? _GetRegGPR(ppcImlGenContext, rA) : IMLREG_INVALID;
+	IMLReg regB = _GetRegGPR(ppcImlGenContext, rB);
+	IMLReg regDst = _GetRegGPR(ppcImlGenContext, rD);
+	if (updateAddrReg)
+	{
+		ppcImlGenContext->emitInst().make_r_r_r(PPCREC_IML_OP_ADD, regA, regA, regB);
+		// use single register addressing
+		regB = regA;
+		regA = IMLREG_INVALID;
+	}
+	if(regA.IsValid())
+		PPCRecompilerImlGen_generateNewInstruction_r_memory_indexed(ppcImlGenContext, regDst, regA, regB, bitWidth, signExtend, isBigEndian);
 	else
-		PPCRecompilerImlGen_generateNewInstruction_r_memory(ppcImlGenContext, destinationRegister, gprRegisterB, 0, PPC_REC_LOAD_LWARX_MARKER, false, true);
+		ppcImlGenContext->emitInst().make_r_memory(regDst, regB, 0, bitWidth, signExtend, isBigEndian);
+}
+
+bool PPCRecompilerImlGen_STORE(ppcImlGenContext_t* ppcImlGenContext, uint32 opcode, uint32 bitWidth, bool isBigEndian, bool updateAddrReg)
+{
+	int rA, rD;
+	uint32 imm;
+	PPC_OPC_TEMPL_D_SImm(opcode, rD, rA, imm);
+	IMLReg regA;
+	if (rA != 0)
+	{
+		regA = _GetRegGPR(ppcImlGenContext, rA);
+	}
+	else
+	{
+		if (updateAddrReg)
+			return false; // invalid instruction form
+		regA = _GetRegTemporary(ppcImlGenContext, 0);
+		ppcImlGenContext->emitInst().make_r_s32(PPCREC_IML_OP_ASSIGN, regA, 0);
+	}
+	IMLReg regD = _GetRegGPR(ppcImlGenContext, rD);
+	if (updateAddrReg)
+	{
+		if (rD == rA)
+		{
+			// make sure to keep source data intact
+			regD = _GetRegTemporary(ppcImlGenContext, 0);
+			ppcImlGenContext->emitInst().make_r_r(PPCREC_IML_OP_ASSIGN, regD, regA);
+		}
+		ppcImlGenContext->emitInst().make_r_r_s32(PPCREC_IML_OP_ADD, regA, regA, (sint32)imm);
+		imm = 0;
+	}
+	ppcImlGenContext->emitInst().make_memory_r(regD, regA, (sint32)imm, bitWidth, isBigEndian);
+	return true;
+}
+
+bool PPCRecompilerImlGen_STORE_INDEXED(ppcImlGenContext_t* ppcImlGenContext, uint32 opcode, uint32 bitWidth, bool isBigEndian, bool updateAddrReg)
+{
+	sint32 rA, rS, rB;
+	PPC_OPC_TEMPL_X(opcode, rS, rA, rB);
+	IMLReg regA = rA != 0 ? _GetRegGPR(ppcImlGenContext, rA) : IMLREG_INVALID;
+	IMLReg regB = _GetRegGPR(ppcImlGenContext, rB);
+	IMLReg regSrc = _GetRegGPR(ppcImlGenContext, rS);
+	if (updateAddrReg)
+	{
+		if(rA == 0)
+			return false; // invalid instruction form
+		if (regSrc == regA)
+		{
+			// make sure to keep source data intact
+			regSrc = _GetRegTemporary(ppcImlGenContext, 0);
+			ppcImlGenContext->emitInst().make_r_r(PPCREC_IML_OP_ASSIGN, regSrc, regA);
+		}
+		ppcImlGenContext->emitInst().make_r_r_r(PPCREC_IML_OP_ADD, regA, regA, regB);
+		// use single register addressing
+		regB = regA;
+		regA = IMLREG_INVALID;
+	}
+	if (regA.IsInvalid())
+		ppcImlGenContext->emitInst().make_memory_r(regSrc, regB, 0, bitWidth, isBigEndian);
+	else
+		PPCRecompilerImlGen_generateNewInstruction_memory_r_indexed(ppcImlGenContext, regSrc, regA, regB, bitWidth, false, isBigEndian);
 	return true;
 }
 
@@ -2003,257 +1392,33 @@ void PPCRecompilerImlGen_LMW(ppcImlGenContext_t* ppcImlGenContext, uint32 opcode
 	sint32 rD, rA;
 	uint32 imm;
 	PPC_OPC_TEMPL_D_SImm(opcode, rD, rA, imm);
-	//uint32 ea = (rA ? hCPU->gpr[rA] : 0) + imm;
+	cemu_assert_debug(rA != 0);
 	sint32 index = 0;
-	while( rD <= 31 )
+	while (rD <= 31)
 	{
-		// load memory gpr into register
-		uint32 gprRegister = PPCRecompilerImlGen_loadRegister(ppcImlGenContext, PPCREC_NAME_R0+rA, false);
-		// check if destination register is already loaded
-		uint32 destinationRegister = PPCRecompilerImlGen_findRegisterByMappedName(ppcImlGenContext, PPCREC_NAME_R0+rD);
-		if( destinationRegister == PPC_REC_INVALID_REGISTER )
-			destinationRegister = PPCRecompilerImlGen_getAndLockFreeTemporaryGPR(ppcImlGenContext, PPCREC_NAME_R0+rD); // else just create new register
+		IMLReg regA = _GetRegGPR(ppcImlGenContext, rA);
+		IMLReg regD = _GetRegGPR(ppcImlGenContext, rD);
 		// load word
-		PPCRecompilerImlGen_generateNewInstruction_r_memory(ppcImlGenContext, destinationRegister, gprRegister, imm+index*4, 32, false, true);
+		ppcImlGenContext->emitInst().make_r_memory(regD, regA, (sint32)imm + index * 4, 32, false, true);
 		// next
 		rD++;
 		index++;
 	}
 }
 
-void PPCRecompilerImlGen_STW(ppcImlGenContext_t* ppcImlGenContext, uint32 opcode)
-{
-	int rA, rD;
-	uint32 imm;
-	PPC_OPC_TEMPL_D_SImm(opcode, rD, rA, imm);
-	if( rA == 0 )
-	{
-		// special form where gpr is ignored and only imm is used
-		// note: Darksiders 2 has this instruction form but it is never executed.
-		//PPCRecompilerImlGen_generateNewInstruction_macro(ppcImlGenContext, PPCREC_IML_MACRO_DEBUGBREAK, ppcImlGenContext->ppcAddressOfCurrentInstruction, ppcImlGenContext->ppcAddressOfCurrentInstruction, ppcImlGenContext->cyclesSinceLastBranch);
-		return;
-	}
-	// load memory gpr into register
-	uint32 gprRegister = PPCRecompilerImlGen_loadRegister(ppcImlGenContext, PPCREC_NAME_R0+rA, false);
-	// load source register
-	uint32 sourceRegister = PPCRecompilerImlGen_loadRegister(ppcImlGenContext, PPCREC_NAME_R0+rD, false); // can be the same as gprRegister
-	// store word
-	PPCRecompilerImlGen_generateNewInstruction_memory_r(ppcImlGenContext, sourceRegister, gprRegister, imm, 32, true);
-}
-
-void PPCRecompilerImlGen_STWU(ppcImlGenContext_t* ppcImlGenContext, uint32 opcode)
-{
-	int rA, rD;
-	uint32 imm;
-	PPC_OPC_TEMPL_D_SImm(opcode, rD, rA, imm);
-	if( rA == 0 )
-	{
-		// special form where gpr is ignored and only imm is used
-		PPCRecompilerImlGen_generateNewInstruction_macro(ppcImlGenContext, PPCREC_IML_MACRO_DEBUGBREAK, ppcImlGenContext->ppcAddressOfCurrentInstruction, ppcImlGenContext->ppcAddressOfCurrentInstruction, ppcImlGenContext->cyclesSinceLastBranch);
-		return;
-	}
-	// store&update instructions where rD==rA store the register contents without added imm, therefore we need to handle it differently
-	// get memory gpr register
-	uint32 gprRegister = PPCRecompilerImlGen_loadRegister(ppcImlGenContext, PPCREC_NAME_R0+rA, false);
-	// get source register
-	uint32 sourceRegister = PPCRecompilerImlGen_loadRegister(ppcImlGenContext, PPCREC_NAME_R0+rD, false); // can be the same as gprRegister
-	// add imm to memory register early if possible
-	if( rD != rA )
-		PPCRecompilerImlGen_generateNewInstruction_r_s32(ppcImlGenContext, PPCREC_IML_OP_ADD, gprRegister, (sint32)imm, 0, false, false, PPC_REC_INVALID_REGISTER, 0);
-	// store word
-	PPCRecompilerImlGen_generateNewInstruction_memory_r(ppcImlGenContext, sourceRegister, gprRegister, (rD==rA)?imm:0, 32, true);
-	// add imm to memory register late if we couldn't do it early
-	if( rD == rA )
-		PPCRecompilerImlGen_generateNewInstruction_r_s32(ppcImlGenContext, PPCREC_IML_OP_ADD, gprRegister, (sint32)imm, 0, false, false, PPC_REC_INVALID_REGISTER, 0);
-}
-
-void PPCRecompilerImlGen_STH(ppcImlGenContext_t* ppcImlGenContext, uint32 opcode)
-{
-	int rA, rD;
-	uint32 imm;
-	PPC_OPC_TEMPL_D_SImm(opcode, rD, rA, imm);
-	if( rA == 0 )
-	{
-		// special form where gpr is ignored and only imm is used
-		PPCRecompilerImlGen_generateNewInstruction_macro(ppcImlGenContext, PPCREC_IML_MACRO_DEBUGBREAK, ppcImlGenContext->ppcAddressOfCurrentInstruction, ppcImlGenContext->ppcAddressOfCurrentInstruction, ppcImlGenContext->cyclesSinceLastBranch);
-		return;
-	}
-	// load memory gpr into register
-	uint32 gprRegister = PPCRecompilerImlGen_loadRegister(ppcImlGenContext, PPCREC_NAME_R0+rA, false);
-	// load source register
-	uint32 sourceRegister = PPCRecompilerImlGen_loadRegister(ppcImlGenContext, PPCREC_NAME_R0+rD, false); // can be the same as gprRegister
-	// load half
-	PPCRecompilerImlGen_generateNewInstruction_memory_r(ppcImlGenContext, sourceRegister, gprRegister, imm, 16, true);
-}
-
-void PPCRecompilerImlGen_STHU(ppcImlGenContext_t* ppcImlGenContext, uint32 opcode)
-{
-	int rA, rD;
-	uint32 imm;
-	PPC_OPC_TEMPL_D_SImm(opcode, rD, rA, imm);
-	if( rA == 0 )
-	{
-		// special form where gpr is ignored and only imm is used
-		PPCRecompilerImlGen_generateNewInstruction_macro(ppcImlGenContext, PPCREC_IML_MACRO_DEBUGBREAK, ppcImlGenContext->ppcAddressOfCurrentInstruction, ppcImlGenContext->ppcAddressOfCurrentInstruction, ppcImlGenContext->cyclesSinceLastBranch);
-		return;
-	}
-	// get memory gpr register
-	uint32 gprRegister = PPCRecompilerImlGen_loadRegister(ppcImlGenContext, PPCREC_NAME_R0+rA, false);
-	// get source register
-	uint32 sourceRegister = PPCRecompilerImlGen_loadRegister(ppcImlGenContext, PPCREC_NAME_R0+rD, false); // can be the same as gprRegister
-	// add imm to memory register early if possible
-	if( rD != rA )
-		PPCRecompilerImlGen_generateNewInstruction_r_s32(ppcImlGenContext, PPCREC_IML_OP_ADD, gprRegister, (sint32)imm, 0, false, false, PPC_REC_INVALID_REGISTER, 0);
-	// store word
-	PPCRecompilerImlGen_generateNewInstruction_memory_r(ppcImlGenContext, sourceRegister, gprRegister, (rD==rA)?imm:0, 16, true);
-	// add imm to memory register late if we couldn't do it early
-	if( rD == rA )
-		PPCRecompilerImlGen_generateNewInstruction_r_s32(ppcImlGenContext, PPCREC_IML_OP_ADD, gprRegister, (sint32)imm, 0, false, false, PPC_REC_INVALID_REGISTER, 0);
-}
-
-void PPCRecompilerImlGen_STB(ppcImlGenContext_t* ppcImlGenContext, uint32 opcode)
-{
-	int rA, rS;
-	uint32 imm;
-	PPC_OPC_TEMPL_D_SImm(opcode, rS, rA, imm);
-	if( rA == 0 )
-	{
-		// special form where gpr is ignored and only imm is used
-		PPCRecompilerImlGen_generateNewInstruction_macro(ppcImlGenContext, PPCREC_IML_MACRO_DEBUGBREAK, ppcImlGenContext->ppcAddressOfCurrentInstruction, ppcImlGenContext->ppcAddressOfCurrentInstruction, ppcImlGenContext->cyclesSinceLastBranch);
-		return;
-	}
-	// load memory gpr into register
-	uint32 gprRegister = PPCRecompilerImlGen_loadRegister(ppcImlGenContext, PPCREC_NAME_R0+rA, false);
-	// load source register
-	uint32 sourceRegister = PPCRecompilerImlGen_loadRegister(ppcImlGenContext, PPCREC_NAME_R0+rS, false); // can be the same as gprRegister
-	// store byte
-	PPCRecompilerImlGen_generateNewInstruction_memory_r(ppcImlGenContext, sourceRegister, gprRegister, imm, 8, true);
-}
-
-void PPCRecompilerImlGen_STBU(ppcImlGenContext_t* ppcImlGenContext, uint32 opcode)
-{
-	int rA, rD;
-	uint32 imm;
-	PPC_OPC_TEMPL_D_SImm(opcode, rD, rA, imm);
-	if( rA == 0 )
-	{
-		// special form where gpr is ignored and only imm is used
-		PPCRecompilerImlGen_generateNewInstruction_macro(ppcImlGenContext, PPCREC_IML_MACRO_DEBUGBREAK, ppcImlGenContext->ppcAddressOfCurrentInstruction, ppcImlGenContext->ppcAddressOfCurrentInstruction, ppcImlGenContext->cyclesSinceLastBranch);
-		return;
-	}
-	// get memory gpr register
-	uint32 gprRegister = PPCRecompilerImlGen_loadRegister(ppcImlGenContext, PPCREC_NAME_R0+rA, false);
-	// get source register
-	uint32 sourceRegister = PPCRecompilerImlGen_loadRegister(ppcImlGenContext, PPCREC_NAME_R0+rD, false); // can be the same as gprRegister
-	// add imm to memory register early if possible
-	if( rD != rA )
-		PPCRecompilerImlGen_generateNewInstruction_r_s32(ppcImlGenContext, PPCREC_IML_OP_ADD, gprRegister, (sint32)imm, 0, false, false, PPC_REC_INVALID_REGISTER, 0);
-	// store byte
-	PPCRecompilerImlGen_generateNewInstruction_memory_r(ppcImlGenContext, sourceRegister, gprRegister, (rD==rA)?imm:0, 8, true);
-	// add imm to memory register late if we couldn't do it early
-	if( rD == rA )
-		PPCRecompilerImlGen_generateNewInstruction_r_s32(ppcImlGenContext, PPCREC_IML_OP_ADD, gprRegister, (sint32)imm, 0, false, false, PPC_REC_INVALID_REGISTER, 0);
-}
-
-// generic indexed store (STWX, STHX, STBX, STWUX. If bitReversed == true -> STHBRX)
-bool PPCRecompilerImlGen_STORE_INDEXED(ppcImlGenContext_t* ppcImlGenContext, uint32 opcode, uint32 storeBitWidth, bool byteReversed = false)
-{
-	sint32 rA, rS, rB;
-	PPC_OPC_TEMPL_X(opcode, rS, rA, rB);
-	// prepare registers
-	uint32 gprRegisterA;
-	if(rA != 0)
-		gprRegisterA = PPCRecompilerImlGen_loadRegister(ppcImlGenContext, PPCREC_NAME_R0 + rA, false);
-	uint32 gprRegisterB = PPCRecompilerImlGen_loadRegister(ppcImlGenContext, PPCREC_NAME_R0+rB, false);
-	uint32 destinationRegister = PPCRecompilerImlGen_loadOverwriteRegister(ppcImlGenContext, PPCREC_NAME_R0+rS);
-	// store word
-	if (rA == 0)
-	{
-		PPCRecompilerImlGen_generateNewInstruction_memory_r(ppcImlGenContext, destinationRegister, gprRegisterB, 0, storeBitWidth, !byteReversed);
-	}
-	else
-		PPCRecompilerImlGen_generateNewInstruction_memory_r_indexed(ppcImlGenContext, destinationRegister, gprRegisterA, gprRegisterB, storeBitWidth, false, !byteReversed);
-	return true;
-}
-
-bool PPCRecompilerImlGen_STORE_INDEXED_UPDATE(ppcImlGenContext_t* ppcImlGenContext, uint32 opcode, uint32 storeBitWidth)
-{
-	sint32 rA, rS, rB;
-	PPC_OPC_TEMPL_X(opcode, rS, rA, rB);
-	if( rA == 0 )
-	{
-		// not supported
-		return false;
-	}
-	if( rS == rA || rS == rB )
-	{
-		// prepare registers
-		uint32 gprRegisterA = PPCRecompilerImlGen_loadRegister(ppcImlGenContext, PPCREC_NAME_R0+rA, false);
-		uint32 gprRegisterB = PPCRecompilerImlGen_loadRegister(ppcImlGenContext, PPCREC_NAME_R0+rB, false);
-		uint32 destinationRegister = PPCRecompilerImlGen_loadOverwriteRegister(ppcImlGenContext, PPCREC_NAME_R0+rS);
-		// store word
-		PPCRecompilerImlGen_generateNewInstruction_memory_r_indexed(ppcImlGenContext, destinationRegister, gprRegisterA, gprRegisterB, storeBitWidth, false, true);
-		// update EA after store
-		PPCRecompilerImlGen_generateNewInstruction_r_r(ppcImlGenContext, NULL, PPCREC_IML_OP_ADD, gprRegisterA, gprRegisterB);
-		return true;
-	}
-	// prepare registers
-	uint32 gprRegisterA = PPCRecompilerImlGen_loadRegister(ppcImlGenContext, PPCREC_NAME_R0+rA, false);
-	uint32 gprRegisterB = PPCRecompilerImlGen_loadRegister(ppcImlGenContext, PPCREC_NAME_R0+rB, false);
-	uint32 sourceRegister = PPCRecompilerImlGen_loadOverwriteRegister(ppcImlGenContext, PPCREC_NAME_R0+rS);
-	// update EA
-	PPCRecompilerImlGen_generateNewInstruction_r_r(ppcImlGenContext, NULL, PPCREC_IML_OP_ADD, gprRegisterA, gprRegisterB);	
-	// store word
-	PPCRecompilerImlGen_generateNewInstruction_memory_r(ppcImlGenContext, sourceRegister, gprRegisterA, 0, storeBitWidth, true);
-	return true;
-}
-
-bool PPCRecompilerImlGen_STWCX(ppcImlGenContext_t* ppcImlGenContext, uint32 opcode)
-{
-	sint32 rA, rS, rB;
-	PPC_OPC_TEMPL_X(opcode, rS, rA, rB);
-	// prepare registers
-	uint32 gprRegisterA = rA!=0?PPCRecompilerImlGen_loadRegister(ppcImlGenContext, PPCREC_NAME_R0+rA, false):0;
-	uint32 gprRegisterB = PPCRecompilerImlGen_loadRegister(ppcImlGenContext, PPCREC_NAME_R0+rB, false);
-	uint32 destinationRegister = PPCRecompilerImlGen_loadOverwriteRegister(ppcImlGenContext, PPCREC_NAME_R0+rS);
-	// store word
-	if( rA != 0 )
-		PPCRecompilerImlGen_generateNewInstruction_memory_r_indexed(ppcImlGenContext, destinationRegister, gprRegisterA, gprRegisterB, PPC_REC_STORE_STWCX_MARKER, false, true);
-	else
-		PPCRecompilerImlGen_generateNewInstruction_memory_r(ppcImlGenContext, destinationRegister, gprRegisterB, 0, PPC_REC_STORE_STWCX_MARKER, true);
-	return true;
-}
-
-bool PPCRecompilerImlGen_STWBRX(ppcImlGenContext_t* ppcImlGenContext, uint32 opcode)
-{
-	sint32 rA, rS, rB;
-	PPC_OPC_TEMPL_X(opcode, rS, rA, rB);
-	// prepare registers
-	uint32 gprRegisterA = rA!=0?PPCRecompilerImlGen_loadRegister(ppcImlGenContext, PPCREC_NAME_R0+rA, false):0;
-	uint32 gprRegisterB = PPCRecompilerImlGen_loadRegister(ppcImlGenContext, PPCREC_NAME_R0+rB, false);
-	uint32 destinationRegister = PPCRecompilerImlGen_loadOverwriteRegister(ppcImlGenContext, PPCREC_NAME_R0+rS);
-	// store word
-	if( rA != 0 )
-		PPCRecompilerImlGen_generateNewInstruction_memory_r_indexed(ppcImlGenContext, destinationRegister, gprRegisterA, gprRegisterB, 32, false, false);
-	else
-		PPCRecompilerImlGen_generateNewInstruction_memory_r(ppcImlGenContext, destinationRegister, gprRegisterB, 0, 32, false);
-	return true;
-}
-
 void PPCRecompilerImlGen_STMW(ppcImlGenContext_t* ppcImlGenContext, uint32 opcode)
 {
 	sint32 rS, rA;
 	uint32 imm;
 	PPC_OPC_TEMPL_D_SImm(opcode, rS, rA, imm);
+	cemu_assert_debug(rA != 0);
 	sint32 index = 0;
 	while( rS <= 31 )
 	{
-		// load memory gpr into register
-		uint32 gprRegister = PPCRecompilerImlGen_loadRegister(ppcImlGenContext, PPCREC_NAME_R0+rA, false);
-		// load source register
-		uint32 sourceRegister = PPCRecompilerImlGen_loadRegister(ppcImlGenContext, PPCREC_NAME_R0+rS, false); // can be the same as gprRegister
+		IMLReg regA = _GetRegGPR(ppcImlGenContext, rA);
+		IMLReg regS = _GetRegGPR(ppcImlGenContext, rS);
 		// store word
-		PPCRecompilerImlGen_generateNewInstruction_memory_r(ppcImlGenContext, sourceRegister, gprRegister, imm+index*4, 32, true);
+		ppcImlGenContext->emitInst().make_memory_r(regS, regA, (sint32)imm + index * 4, 32, true);
 		// next
 		rS++;
 		index++;
@@ -2266,70 +1431,43 @@ bool PPCRecompilerImlGen_LSWI(ppcImlGenContext_t* ppcImlGenContext, uint32 opcod
 	PPC_OPC_TEMPL_X(opcode, rD, rA, nb);
 	if( nb == 0 )
 		nb = 32;
-	if( nb == 4 )
+
+	if (rA == 0)
 	{
-		// if nb == 4 this instruction immitates LWZ
-		if( rA == 0 )
-		{
-#ifndef PUBLIC_RELEASE
-			assert_dbg(); // special form where gpr is ignored and only imm is used
-#endif
-			return false;
-		}
-		// load memory gpr into register
-		uint32 gprRegister = PPCRecompilerImlGen_loadRegister(ppcImlGenContext, PPCREC_NAME_R0+rA, false);
-		// check if destination register is already loaded
-		uint32 destinationRegister = PPCRecompilerImlGen_findRegisterByMappedName(ppcImlGenContext, PPCREC_NAME_R0+rD);
-		if( destinationRegister == PPC_REC_INVALID_REGISTER )
-			destinationRegister = PPCRecompilerImlGen_getAndLockFreeTemporaryGPR(ppcImlGenContext, PPCREC_NAME_R0+rD); // else just create new register
-		// load half
-		PPCRecompilerImlGen_generateNewInstruction_r_memory(ppcImlGenContext, destinationRegister, gprRegister, 0, 32, false, true);
-		return true;
+		cemu_assert_unimplemented(); // special form where gpr is ignored and EA is 0
+		return false;
 	}
-	else if( nb == 2 )
+
+	// potential optimization: On x86 unaligned access is allowed and we could handle the case nb==4 with a single memory read, and nb==2 with a memory read and shift
+
+	IMLReg memReg = _GetRegGPR(ppcImlGenContext, rA);
+	IMLReg regTmp = _GetRegTemporary(ppcImlGenContext, 0);
+	uint32 memOffset = 0;
+	while (nb > 0)
 	{
-		// if nb == 2 this instruction immitates a LHZ but the result is shifted left by 16 bits
-		if( rA == 0 )
-		{
-#ifndef PUBLIC_RELEASE
-			assert_dbg(); // special form where gpr is ignored and only imm is used
-#endif
+		if (rD == rA)
 			return false;
-		}
-		// load memory gpr into register
-		uint32 gprRegister = PPCRecompilerImlGen_loadRegister(ppcImlGenContext, PPCREC_NAME_R0+rA, false);
-		// check if destination register is already loaded
-		uint32 destinationRegister = PPCRecompilerImlGen_findRegisterByMappedName(ppcImlGenContext, PPCREC_NAME_R0+rD);
-		if( destinationRegister == PPC_REC_INVALID_REGISTER )
-			destinationRegister = PPCRecompilerImlGen_getAndLockFreeTemporaryGPR(ppcImlGenContext, PPCREC_NAME_R0+rD); // else just create new register
-		// load half
-		PPCRecompilerImlGen_generateNewInstruction_r_memory(ppcImlGenContext, destinationRegister, gprRegister, 0, 16, false, true);
-		// shift
-		PPCRecompilerImlGen_generateNewInstruction_r_r_s32(ppcImlGenContext, PPCREC_IML_OP_LEFT_SHIFT, destinationRegister, destinationRegister, 16);		
-		return true;
-	}
-	else if( nb == 3 )
-	{
-		// if nb == 3 this instruction loads a 3-byte big-endian and the result is shifted left by 8 bits
-		if( rA == 0 )
+		cemu_assert(rD < 32);
+		IMLReg regDst = _GetRegGPR(ppcImlGenContext, rD);
+		// load bytes one-by-one
+		for (sint32 b = 0; b < 4; b++)
 		{
-#ifndef PUBLIC_RELEASE
-			assert_dbg(); // special form where gpr is ignored and only imm is used
-#endif
-			return false;
+			ppcImlGenContext->emitInst().make_r_memory(regTmp, memReg, memOffset + b, 8, false, false);
+			sint32 shiftAmount = (3 - b) * 8;
+			if(shiftAmount)
+				ppcImlGenContext->emitInst().make_r_r_s32(PPCREC_IML_OP_LEFT_SHIFT, regTmp, regTmp, shiftAmount);
+			if(b == 0)
+				ppcImlGenContext->emitInst().make_r_r(PPCREC_IML_OP_ASSIGN, regDst, regTmp);
+			else
+				ppcImlGenContext->emitInst().make_r_r_r(PPCREC_IML_OP_OR, regDst, regDst, regTmp);
+			nb--;
+			if (nb == 0)
+				break;
 		}
-		// load memory gpr into register
-		uint32 gprRegister = PPCRecompilerImlGen_loadRegister(ppcImlGenContext, PPCREC_NAME_R0+rA, false);
-		// check if destination register is already loaded
-		uint32 destinationRegister = PPCRecompilerImlGen_findRegisterByMappedName(ppcImlGenContext, PPCREC_NAME_R0+rD);
-		if( destinationRegister == PPC_REC_INVALID_REGISTER )
-			destinationRegister = PPCRecompilerImlGen_getAndLockFreeTemporaryGPR(ppcImlGenContext, PPCREC_NAME_R0+rD); // else just create new register
-		// load half
-		PPCRecompilerImlGen_generateNewInstruction_r_memory(ppcImlGenContext, destinationRegister, gprRegister, 0, PPC_REC_STORE_LSWI_3, false, true);
-		return true;
+		memOffset += 4;
+		rD++;
 	}
-	debug_printf("PPCRecompilerImlGen_LSWI(): Unsupported nb value %d\n", nb);
-	return false;
+	return true;
 }
 
 bool PPCRecompilerImlGen_STSWI(ppcImlGenContext_t* ppcImlGenContext, uint32 opcode)
@@ -2338,38 +1476,111 @@ bool PPCRecompilerImlGen_STSWI(ppcImlGenContext_t* ppcImlGenContext, uint32 opco
 	PPC_OPC_TEMPL_X(opcode, rS, rA, nb);
 	if( nb == 0 )
 		nb = 32;
-	if( nb == 4 )
+
+	IMLReg regMem = _GetRegGPR(ppcImlGenContext, rA);
+	IMLReg regTmp = _GetRegTemporary(ppcImlGenContext, 0);
+	uint32 memOffset = 0;
+	while (nb > 0)
 	{
-		// load memory gpr into register
-		uint32 gprRegister = PPCRecompilerImlGen_loadRegister(ppcImlGenContext, PPCREC_NAME_R0+rA, false);
-		// load source register
-		uint32 sourceRegister = PPCRecompilerImlGen_loadRegister(ppcImlGenContext, PPCREC_NAME_R0+rS, false); // can be the same as gprRegister
-		// store word
-		PPCRecompilerImlGen_generateNewInstruction_memory_r(ppcImlGenContext, sourceRegister, gprRegister, 0, 32, true);
-		return true;
+		if (rS == rA)
+			return false;
+		cemu_assert(rS < 32);
+		IMLReg regSrc = _GetRegGPR(ppcImlGenContext, rS);
+		// store bytes one-by-one
+		for (sint32 b = 0; b < 4; b++)
+		{
+			ppcImlGenContext->emitInst().make_r_r(PPCREC_IML_OP_ASSIGN, regTmp, regSrc);
+			sint32 shiftAmount = (3 - b) * 8;
+			if (shiftAmount)
+				ppcImlGenContext->emitInst().make_r_r_s32(PPCREC_IML_OP_RIGHT_SHIFT_U, regTmp, regTmp, shiftAmount);
+			ppcImlGenContext->emitInst().make_memory_r(regTmp, regMem, memOffset + b, 8, false);
+			nb--;
+			if (nb == 0)
+				break;
+		}
+		memOffset += 4;
+		rS++;
 	}
-	else if( nb == 2 )
-	{
-		// load memory gpr into register
-		uint32 gprRegister = PPCRecompilerImlGen_loadRegister(ppcImlGenContext, PPCREC_NAME_R0+rA, false);
-		// load source register
-		uint32 sourceRegister = PPCRecompilerImlGen_loadRegister(ppcImlGenContext, PPCREC_NAME_R0+rS, false); // can be the same as gprRegister
-		// store half-word (shifted << 16)
-		PPCRecompilerImlGen_generateNewInstruction_memory_r(ppcImlGenContext, sourceRegister, gprRegister, 0, PPC_REC_STORE_STSWI_2, false);
-		return true;
-	}
-	else if( nb == 3 )
-	{
-		// load memory gpr into register
-		uint32 gprRegister = PPCRecompilerImlGen_loadRegister(ppcImlGenContext, PPCREC_NAME_R0+rA, false);
-		// load source register
-		uint32 sourceRegister = PPCRecompilerImlGen_loadRegister(ppcImlGenContext, PPCREC_NAME_R0+rS, false); // can be the same as gprRegister
-		// store 3-byte-word (shifted << 8)
-		PPCRecompilerImlGen_generateNewInstruction_memory_r(ppcImlGenContext, sourceRegister, gprRegister, 0, PPC_REC_STORE_STSWI_3, false);
-		return true;
-	}
-	debug_printf("PPCRecompilerImlGen_STSWI(): Unsupported nb value %d\n", nb);
-	return false;
+	return true;
+}
+
+bool PPCRecompilerImlGen_LWARX(ppcImlGenContext_t* ppcImlGenContext, uint32 opcode)
+{
+	sint32 rA, rD, rB;
+	PPC_OPC_TEMPL_X(opcode, rD, rA, rB);
+
+	IMLReg regA = rA != 0 ? PPCRecompilerImlGen_loadRegister(ppcImlGenContext, PPCREC_NAME_R0 + rA) : IMLREG_INVALID;
+	IMLReg regB = PPCRecompilerImlGen_loadRegister(ppcImlGenContext, PPCREC_NAME_R0 + rB);
+	IMLReg regD = PPCRecompilerImlGen_loadRegister(ppcImlGenContext, PPCREC_NAME_R0 + rD);
+	IMLReg regMemResEA = PPCRecompilerImlGen_loadRegister(ppcImlGenContext, PPCREC_NAME_CPU_MEMRES_EA);
+	IMLReg regMemResVal = PPCRecompilerImlGen_loadRegister(ppcImlGenContext, PPCREC_NAME_CPU_MEMRES_VAL);
+	// calculate EA
+	if (regA.IsValid())
+		ppcImlGenContext->emitInst().make_r_r_r(PPCREC_IML_OP_ADD, regMemResEA, regA, regB);
+	else
+		ppcImlGenContext->emitInst().make_r_r(PPCREC_IML_OP_ASSIGN, regMemResEA, regB);
+	// load word
+	ppcImlGenContext->emitInst().make_r_memory(regD, regMemResEA, 0, 32, false, true);
+	ppcImlGenContext->emitInst().make_r_r(PPCREC_IML_OP_ASSIGN, regMemResVal, regD);
+	return true;
+}
+
+bool PPCRecompilerImlGen_STWCX(ppcImlGenContext_t* ppcImlGenContext, uint32 opcode)
+{
+	sint32 rA, rS, rB;
+	PPC_OPC_TEMPL_X(opcode, rS, rA, rB);
+	IMLReg regA = rA != 0 ? PPCRecompilerImlGen_loadRegister(ppcImlGenContext, PPCREC_NAME_R0 + rA) : IMLREG_INVALID;
+	IMLReg regB = PPCRecompilerImlGen_loadRegister(ppcImlGenContext, PPCREC_NAME_R0 + rB);
+	IMLReg regData = PPCRecompilerImlGen_loadRegister(ppcImlGenContext, PPCREC_NAME_R0 + rS);
+	IMLReg regTmpDataBE = PPCRecompilerImlGen_loadRegister(ppcImlGenContext, PPCREC_NAME_TEMPORARY + 2);
+	IMLReg regTmpCompareBE = PPCRecompilerImlGen_loadRegister(ppcImlGenContext, PPCREC_NAME_TEMPORARY + 3);
+	// calculate EA
+	IMLReg regCalcEA = PPCRecompilerImlGen_loadRegister(ppcImlGenContext, PPCREC_NAME_TEMPORARY);
+	if (regA.IsValid())
+		ppcImlGenContext->emitInst().make_r_r_r(PPCREC_IML_OP_ADD, regCalcEA, regA, regB);
+	else
+		ppcImlGenContext->emitInst().make_r_r(PPCREC_IML_OP_ASSIGN, regCalcEA, regB);
+	// get  CR bit regs and set LT, GT and SO immediately
+	IMLReg regCrLT = _GetRegCR(ppcImlGenContext, 0, Espresso::CR_BIT_INDEX_LT);
+	IMLReg regCrGT = _GetRegCR(ppcImlGenContext, 0, Espresso::CR_BIT_INDEX_GT);
+	IMLReg regCrEQ = _GetRegCR(ppcImlGenContext, 0, Espresso::CR_BIT_INDEX_EQ);
+	IMLReg regCrSO = _GetRegCR(ppcImlGenContext, 0, Espresso::CR_BIT_INDEX_SO);
+	IMLReg regXerSO = _GetRegCR(ppcImlGenContext, 0, Espresso::CR_BIT_INDEX_SO);
+	ppcImlGenContext->emitInst().make_r_s32(PPCREC_IML_OP_ASSIGN, regCrLT, 0);
+	ppcImlGenContext->emitInst().make_r_s32(PPCREC_IML_OP_ASSIGN, regCrGT, 0);
+	ppcImlGenContext->emitInst().make_r_r(PPCREC_IML_OP_ASSIGN, regCrSO, regXerSO);
+	// get regs for reservation address and value
+	IMLReg regMemResEA = PPCRecompilerImlGen_loadRegister(ppcImlGenContext, PPCREC_NAME_CPU_MEMRES_EA);
+	IMLReg regMemResVal = PPCRecompilerImlGen_loadRegister(ppcImlGenContext, PPCREC_NAME_CPU_MEMRES_VAL);
+	// compare calculated EA with reservation
+	IMLReg regTmpBool = PPCRecompilerImlGen_loadRegister(ppcImlGenContext, PPCREC_NAME_TEMPORARY + 1);
+	ppcImlGenContext->emitInst().make_compare(regCalcEA, regMemResEA, regTmpBool, IMLCondition::EQ);
+	ppcImlGenContext->emitInst().make_conditional_jump(regTmpBool, true);
+
+	PPCIMLGen_CreateSegmentBranchedPath(*ppcImlGenContext, *ppcImlGenContext->currentBasicBlock,
+		[&](ppcImlGenContext_t& genCtx)
+		{
+			/* branch taken, EA matching */
+			ppcImlGenContext->emitInst().make_r_r(PPCREC_IML_OP_ENDIAN_SWAP, regTmpDataBE, regData);
+			ppcImlGenContext->emitInst().make_r_r(PPCREC_IML_OP_ENDIAN_SWAP, regTmpCompareBE, regMemResVal);
+			ppcImlGenContext->emitInst().make_atomic_cmp_store(regMemResEA, regTmpCompareBE, regTmpDataBE, regCrEQ);
+		},
+		[&](ppcImlGenContext_t& genCtx)
+		{
+			/* branch not taken, EA mismatching */
+			ppcImlGenContext->emitInst().make_r_s32(PPCREC_IML_OP_ASSIGN, regCrEQ, 0);
+		}
+	);
+
+	// reset reservation
+	// I found contradictory information of whether the reservation is cleared in all cases, so unit testing would be required
+	// Most sources state that it is cleared on successful store. They don't explicitly mention what happens on failure
+	// "The PowerPC 600 series, part 7: Atomic memory access and cache coherency" states that it is always cleared
+	// There may also be different behavior between individual PPC architectures
+	ppcImlGenContext->emitInst().make_r_s32(PPCREC_IML_OP_ASSIGN, regMemResEA, 0);
+	ppcImlGenContext->emitInst().make_r_s32(PPCREC_IML_OP_ASSIGN, regMemResVal, 0);
+
+	return true;
 }
 
 bool PPCRecompilerImlGen_DCBZ(ppcImlGenContext_t* ppcImlGenContext, uint32 opcode)
@@ -2378,92 +1589,39 @@ bool PPCRecompilerImlGen_DCBZ(ppcImlGenContext_t* ppcImlGenContext, uint32 opcod
 	rA = (opcode>>16)&0x1F;
 	rB = (opcode>>11)&0x1F;
 	// prepare registers
-	uint32 gprRegisterA = rA!=0?PPCRecompilerImlGen_loadRegister(ppcImlGenContext, PPCREC_NAME_R0+rA, false):0;
-	uint32 gprRegisterB = PPCRecompilerImlGen_loadRegister(ppcImlGenContext, PPCREC_NAME_R0+rB, false);
-	// store
-	if( rA != 0 )
-		PPCRecompilerImlGen_generateNewInstruction_r_r(ppcImlGenContext, NULL, PPCREC_IML_OP_DCBZ, gprRegisterA, gprRegisterB);
+	IMLReg regA = rA!=0?PPCRecompilerImlGen_loadRegister(ppcImlGenContext, PPCREC_NAME_R0+rA):IMLREG_INVALID;
+	IMLReg regB = PPCRecompilerImlGen_loadRegister(ppcImlGenContext, PPCREC_NAME_R0+rB);
+	// load zero into a temporary register
+	IMLReg regZero = PPCRecompilerImlGen_loadRegister(ppcImlGenContext, PPCREC_NAME_TEMPORARY + 0);
+	ppcImlGenContext->emitInst().make_r_s32(PPCREC_IML_OP_ASSIGN, regZero, 0);
+	// prepare EA and align it to cacheline
+	IMLReg regMemResEA = PPCRecompilerImlGen_loadRegister(ppcImlGenContext, PPCREC_NAME_TEMPORARY + 1);
+	if(rA != 0)
+		ppcImlGenContext->emitInst().make_r_r_r(PPCREC_IML_OP_ADD, regMemResEA, regA, regB);
 	else
-		PPCRecompilerImlGen_generateNewInstruction_r_r(ppcImlGenContext, NULL, PPCREC_IML_OP_DCBZ, gprRegisterB, gprRegisterB);
+		ppcImlGenContext->emitInst().make_r_r(PPCREC_IML_OP_ASSIGN, regMemResEA, regB);
+	ppcImlGenContext->emitInst().make_r_r_s32(PPCREC_IML_OP_AND, regMemResEA, regMemResEA, ~31);
+	// zero out the cacheline
+	for(sint32 i = 0; i < 32; i += 4)
+		ppcImlGenContext->emitInst().make_memory_r(regZero, regMemResEA, i, 32, false);
 	return true;
 }
 
-bool PPCRecompilerImlGen_OR(ppcImlGenContext_t* ppcImlGenContext, uint32 opcode)
+bool PPCRecompilerImlGen_OR_NOR(ppcImlGenContext_t* ppcImlGenContext, uint32 opcode, bool complementResult)
 {
 	int rS, rA, rB;
 	PPC_OPC_TEMPL_X(opcode, rS, rA, rB);
-	// check for MR mnemonic
-	if( rS == rB )
-	{
-		// simple register copy
-		if( rA != rS ) // check if no-op
-		{
-			sint32 gprSourceReg = PPCRecompilerImlGen_loadRegister(ppcImlGenContext, PPCREC_NAME_R0+rS);
-			sint32 gprDestReg = PPCRecompilerImlGen_loadOverwriteRegister(ppcImlGenContext, PPCREC_NAME_R0+rA);
-			if( opcode&PPC_OPC_RC )
-			{
-				PPCRecompilerImlGen_generateNewInstruction_r_r(ppcImlGenContext, NULL, PPCREC_IML_OP_ASSIGN, gprDestReg, gprSourceReg, 0, PPCREC_CR_MODE_LOGICAL);
-			}
-			else
-			{
-				PPCRecompilerImlGen_generateNewInstruction_r_r(ppcImlGenContext, NULL, PPCREC_IML_OP_ASSIGN, gprDestReg, gprSourceReg);
-			}
-		}
-		else
-		{
-			if( opcode&PPC_OPC_RC )
-			{
-				// no effect but CR is updated
-				sint32 gprSourceReg = PPCRecompilerImlGen_loadRegister(ppcImlGenContext, PPCREC_NAME_R0+rS);
-				PPCRecompilerImlGen_generateNewInstruction_r_r(ppcImlGenContext, NULL, PPCREC_IML_OP_ASSIGN, gprSourceReg, gprSourceReg, 0, PPCREC_CR_MODE_LOGICAL);
-			}
-			else
-			{
-				// no-op
-			}
-		}
-	}
+	IMLReg regA = _GetRegGPR(ppcImlGenContext, rA);
+	IMLReg regS = _GetRegGPR(ppcImlGenContext, rS);
+	IMLReg regB = _GetRegGPR(ppcImlGenContext, rB);
+	if(rS == rB) // check for MR mnemonic
+		ppcImlGenContext->emitInst().make_r_r(PPCREC_IML_OP_ASSIGN, regA, regS);
 	else
-	{
-		// rA = rS | rA
-		sint32 gprSource1Reg = PPCRecompilerImlGen_loadRegister(ppcImlGenContext, PPCREC_NAME_R0+rS);
-		sint32 gprSource2Reg = PPCRecompilerImlGen_loadRegister(ppcImlGenContext, PPCREC_NAME_R0+rB);
-		sint32 gprDestReg = PPCRecompilerImlGen_loadOverwriteRegister(ppcImlGenContext, PPCREC_NAME_R0+rA);
-		if( gprSource1Reg == gprDestReg || gprSource2Reg == gprDestReg )
-		{
-			// make sure we don't overwrite rS or rA
-			if( gprSource1Reg == gprDestReg )
-			{
-				PPCRecompilerImlGen_generateNewInstruction_r_r(ppcImlGenContext, NULL, PPCREC_IML_OP_OR, gprDestReg, gprSource2Reg);
-			}
-			else
-			{
-				PPCRecompilerImlGen_generateNewInstruction_r_r(ppcImlGenContext, NULL, PPCREC_IML_OP_OR, gprDestReg, gprSource1Reg);
-			}
-			if( opcode&PPC_OPC_RC )
-			{
-				// fixme: merge CR update into OR instruction above
-				PPCRecompilerImlGen_generateNewInstruction_r_r(ppcImlGenContext, NULL, PPCREC_IML_OP_AND, gprDestReg, gprDestReg, 0, PPCREC_CR_MODE_LOGICAL);
-			}
-		}
-		else
-		{
-			// rA = rS
-			if( gprDestReg != gprSource1Reg )
-			{
-				PPCRecompilerImlGen_generateNewInstruction_r_r(ppcImlGenContext, NULL, PPCREC_IML_OP_ASSIGN, gprDestReg, gprSource1Reg);
-			}
-			// rA |= rB
-			if( opcode&PPC_OPC_RC )
-			{
-				PPCRecompilerImlGen_generateNewInstruction_r_r(ppcImlGenContext, NULL, PPCREC_IML_OP_OR, gprDestReg, gprSource2Reg, 0, PPCREC_CR_MODE_LOGICAL);
-			}
-			else
-			{
-				PPCRecompilerImlGen_generateNewInstruction_r_r(ppcImlGenContext, NULL, PPCREC_IML_OP_OR, gprDestReg, gprSource2Reg);
-			}
-		}
-	}
+		ppcImlGenContext->emitInst().make_r_r_r(PPCREC_IML_OP_OR, regA, regS, regB);
+	if(complementResult)
+		ppcImlGenContext->emitInst().make_r_r(PPCREC_IML_OP_NOT, regA, regA);
+	if (opcode & PPC_OPC_RC)
+		PPCImlGen_UpdateCR0(ppcImlGenContext, regA);
 	return true;
 }
 
@@ -2471,151 +1629,33 @@ bool PPCRecompilerImlGen_ORC(ppcImlGenContext_t* ppcImlGenContext, uint32 opcode
 {
 	sint32 rS, rA, rB;
 	PPC_OPC_TEMPL_X(opcode, rS, rA, rB);
-	// hCPU->gpr[rA] = hCPU->gpr[rS] | ~hCPU->gpr[rB];
-	sint32 gprSource1Reg = PPCRecompilerImlGen_loadRegister(ppcImlGenContext, PPCREC_NAME_R0+rS);
-	sint32 gprSource2Reg = PPCRecompilerImlGen_loadRegister(ppcImlGenContext, PPCREC_NAME_R0+rB);
-	sint32 gprDestReg = PPCRecompilerImlGen_loadOverwriteRegister(ppcImlGenContext, PPCREC_NAME_R0+rA);
-	if( opcode&PPC_OPC_RC )
-		PPCRecompilerImlGen_generateNewInstruction_r_r_r(ppcImlGenContext, PPCREC_IML_OP_ORC, gprDestReg, gprSource1Reg, gprSource2Reg, 0, PPCREC_CR_MODE_LOGICAL);
-	else
-		PPCRecompilerImlGen_generateNewInstruction_r_r_r(ppcImlGenContext, PPCREC_IML_OP_ORC, gprDestReg, gprSource1Reg, gprSource2Reg);
+	// rA = rS | ~rB;
+	IMLReg regS = _GetRegGPR(ppcImlGenContext, rS);
+	IMLReg regB = _GetRegGPR(ppcImlGenContext, rB);
+	IMLReg regTmp = _GetRegTemporary(ppcImlGenContext, 0);
+	IMLReg regA = _GetRegGPR(ppcImlGenContext, rA);
+	ppcImlGenContext->emitInst().make_r_r(PPCREC_IML_OP_NOT, regTmp, regB);
+	ppcImlGenContext->emitInst().make_r_r_r(PPCREC_IML_OP_OR, regA, regS, regTmp);
+	if (opcode & PPC_OPC_RC)
+		PPCImlGen_UpdateCR0(ppcImlGenContext, regA);
 	return true;
 }
 
-bool PPCRecompilerImlGen_NOR(ppcImlGenContext_t* ppcImlGenContext, uint32 opcode)
+bool PPCRecompilerImlGen_AND_NAND(ppcImlGenContext_t* ppcImlGenContext, uint32 opcode, bool complementResult)
 {
 	int rS, rA, rB;
 	PPC_OPC_TEMPL_X(opcode, rS, rA, rB);
-	//hCPU->gpr[rA] = ~(hCPU->gpr[rS] | hCPU->gpr[rB]);
-	// check for NOT mnemonic
-	if( rS == rB )
-	{
-		// simple register copy with NOT
-		sint32 gprSourceReg = PPCRecompilerImlGen_loadRegister(ppcImlGenContext, PPCREC_NAME_R0+rS);
-		sint32 gprDestReg = PPCRecompilerImlGen_loadOverwriteRegister(ppcImlGenContext, PPCREC_NAME_R0+rA);
-		if( gprDestReg != gprSourceReg )
-			PPCRecompilerImlGen_generateNewInstruction_r_r(ppcImlGenContext, NULL, PPCREC_IML_OP_ASSIGN, gprDestReg, gprSourceReg);
-		if( opcode&PPC_OPC_RC )
-		{
-			PPCRecompilerImlGen_generateNewInstruction_r_r(ppcImlGenContext, NULL, PPCREC_IML_OP_NOT, gprDestReg, gprDestReg, 0, PPCREC_CR_MODE_ARITHMETIC);
-		}
-		else
-		{
-			PPCRecompilerImlGen_generateNewInstruction_r_r(ppcImlGenContext, NULL, PPCREC_IML_OP_NOT, gprDestReg, gprDestReg);
-		}
-	}
+	IMLReg regA = _GetRegGPR(ppcImlGenContext, rA);
+	IMLReg regS = _GetRegGPR(ppcImlGenContext, rS);
+	IMLReg regB = _GetRegGPR(ppcImlGenContext, rB);
+	if (regS == regB)
+		ppcImlGenContext->emitInst().make_r_r(PPCREC_IML_OP_ASSIGN, regA, regS);
 	else
-	{
-		// rA = rS | rA
-		sint32 gprSource1Reg = PPCRecompilerImlGen_loadRegister(ppcImlGenContext, PPCREC_NAME_R0+rS);
-		sint32 gprSource2Reg = PPCRecompilerImlGen_loadRegister(ppcImlGenContext, PPCREC_NAME_R0+rB);
-		sint32 gprDestReg = PPCRecompilerImlGen_loadOverwriteRegister(ppcImlGenContext, PPCREC_NAME_R0+rA);
-		if( gprSource1Reg == gprDestReg || gprSource2Reg == gprDestReg )
-		{
-			// make sure we don't overwrite rS or rA
-			if( gprSource1Reg == gprDestReg )
-			{
-				PPCRecompilerImlGen_generateNewInstruction_r_r(ppcImlGenContext, NULL, PPCREC_IML_OP_OR, gprDestReg, gprSource2Reg);
-			}
-			else
-			{
-				PPCRecompilerImlGen_generateNewInstruction_r_r(ppcImlGenContext, NULL, PPCREC_IML_OP_OR, gprDestReg, gprSource1Reg);
-			}
-			PPCRecompilerImlGen_generateNewInstruction_r_r(ppcImlGenContext, NULL, PPCREC_IML_OP_NOT, gprDestReg, gprDestReg);
-			if( opcode&PPC_OPC_RC )
-			{
-				// fixme: merge CR update into OR instruction above
-				PPCRecompilerImlGen_generateNewInstruction_r_r(ppcImlGenContext, NULL, PPCREC_IML_OP_AND, gprDestReg, gprDestReg, 0, PPCREC_CR_MODE_LOGICAL);
-			}
-		}
-		else
-		{
-			// rA = rS
-			if( gprDestReg != gprSource1Reg )
-			{
-				PPCRecompilerImlGen_generateNewInstruction_r_r(ppcImlGenContext, NULL, PPCREC_IML_OP_ASSIGN, gprDestReg, gprSource1Reg);
-			}
-			// rA |= rB
-			PPCRecompilerImlGen_generateNewInstruction_r_r(ppcImlGenContext, NULL, PPCREC_IML_OP_OR, gprDestReg, gprSource2Reg);
-			if( opcode&PPC_OPC_RC )
-			{
-				PPCRecompilerImlGen_generateNewInstruction_r_r(ppcImlGenContext, NULL, PPCREC_IML_OP_NOT, gprDestReg, gprDestReg, 0, PPCREC_CR_MODE_ARITHMETIC);
-			}
-			else
-			{
-				PPCRecompilerImlGen_generateNewInstruction_r_r(ppcImlGenContext, NULL, PPCREC_IML_OP_NOT, gprDestReg, gprDestReg);
-			}
-		}
-	}
-	return true;
-}
-
-bool PPCRecompilerImlGen_AND(ppcImlGenContext_t* ppcImlGenContext, uint32 opcode)
-{
-	sint32 rS, rA, rB;
-	PPC_OPC_TEMPL_X(opcode, rS, rA, rB);
-	// check for MR mnemonic
-	if( rS == rB )
-	{
-		// simple register copy
-		if( rA != rS ) // check if no-op
-		{
-			sint32 gprSourceReg = PPCRecompilerImlGen_loadRegister(ppcImlGenContext, PPCREC_NAME_R0+rS);
-			sint32 gprDestReg = PPCRecompilerImlGen_loadOverwriteRegister(ppcImlGenContext, PPCREC_NAME_R0+rA);
-			if( opcode&PPC_OPC_RC )
-			{
-				PPCRecompilerImlGen_generateNewInstruction_r_r(ppcImlGenContext, NULL, PPCREC_IML_OP_ASSIGN, gprDestReg, gprSourceReg, 0, PPCREC_CR_MODE_LOGICAL);
-			}
-			else
-			{
-				PPCRecompilerImlGen_generateNewInstruction_r_r(ppcImlGenContext, NULL, PPCREC_IML_OP_ASSIGN, gprDestReg, gprSourceReg);
-			}
-		}
-		else
-		{
-			cemu_assert_unimplemented(); // no-op -> verify this case
-		}
-	}
-	else
-	{
-		// rA = rS & rA
-		sint32 gprSource1Reg = PPCRecompilerImlGen_loadRegister(ppcImlGenContext, PPCREC_NAME_R0+rS);
-		sint32 gprSource2Reg = PPCRecompilerImlGen_loadRegister(ppcImlGenContext, PPCREC_NAME_R0+rB);
-		sint32 gprDestReg = PPCRecompilerImlGen_loadOverwriteRegister(ppcImlGenContext, PPCREC_NAME_R0+rA);
-		if( gprSource1Reg == gprDestReg || gprSource2Reg == gprDestReg )
-		{
-			// make sure we don't overwrite rS or rA
-			if( gprSource1Reg == gprDestReg )
-			{
-				PPCRecompilerImlGen_generateNewInstruction_r_r(ppcImlGenContext, NULL, PPCREC_IML_OP_AND, gprDestReg, gprSource2Reg);
-			}
-			else
-			{
-				PPCRecompilerImlGen_generateNewInstruction_r_r(ppcImlGenContext, NULL, PPCREC_IML_OP_AND, gprDestReg, gprSource1Reg);
-			}
-			if( opcode&PPC_OPC_RC )
-			{
-				PPCRecompilerImlGen_generateNewInstruction_r_r(ppcImlGenContext, NULL, PPCREC_IML_OP_AND, gprDestReg, gprDestReg, 0, PPCREC_CR_MODE_LOGICAL);
-			}
-		}
-		else
-		{
-			// rA = rS
-			if( gprDestReg != gprSource1Reg )
-			{
-				PPCRecompilerImlGen_generateNewInstruction_r_r(ppcImlGenContext, NULL, PPCREC_IML_OP_ASSIGN, gprDestReg, gprSource1Reg);
-			}
-			// rA &= rB
-			if( opcode&PPC_OPC_RC )
-			{
-				PPCRecompilerImlGen_generateNewInstruction_r_r(ppcImlGenContext, NULL, PPCREC_IML_OP_AND, gprDestReg, gprSource2Reg, 0, PPCREC_CR_MODE_LOGICAL);
-			}
-			else
-			{
-				PPCRecompilerImlGen_generateNewInstruction_r_r(ppcImlGenContext, NULL, PPCREC_IML_OP_AND, gprDestReg, gprSource2Reg);
-			}
-		}
-	}
+		ppcImlGenContext->emitInst().make_r_r_r(PPCREC_IML_OP_AND, regA, regS, regB);
+	if (complementResult)
+		ppcImlGenContext->emitInst().make_r_r(PPCREC_IML_OP_NOT, regA, regA);
+	if (opcode & PPC_OPC_RC)
+		PPCImlGen_UpdateCR0(ppcImlGenContext, regA);
 	return true;
 }
 
@@ -2623,277 +1663,101 @@ bool PPCRecompilerImlGen_ANDC(ppcImlGenContext_t* ppcImlGenContext, uint32 opcod
 {
 	sint32 rS, rA, rB;
 	PPC_OPC_TEMPL_X(opcode, rS, rA, rB);
-	//hCPU->gpr[rA] = hCPU->gpr[rS] & ~hCPU->gpr[rB];
-	//if (Opcode & PPC_OPC_RC) {
-	if( rS == rB )
-	{
-		// result is always 0 -> replace with XOR rA,rA
-		sint32 gprDestReg = PPCRecompilerImlGen_loadOverwriteRegister(ppcImlGenContext, PPCREC_NAME_R0+rA);
-		if( opcode&PPC_OPC_RC )
-		{
-			PPCRecompilerImlGen_generateNewInstruction_r_r(ppcImlGenContext, NULL, PPCREC_IML_OP_XOR, gprDestReg, gprDestReg, 0, PPCREC_CR_MODE_LOGICAL);
-		}
-		else
-		{
-			PPCRecompilerImlGen_generateNewInstruction_r_r(ppcImlGenContext, NULL, PPCREC_IML_OP_XOR, gprDestReg, gprDestReg);
-		}
-	}
-	else if( rA == rB )
-	{
-		// rB already in rA, therefore we complement rA first and then AND it with rS
-		sint32 gprRS = PPCRecompilerImlGen_loadRegister(ppcImlGenContext, PPCREC_NAME_R0+rS);
-		sint32 gprRA = PPCRecompilerImlGen_loadRegister(ppcImlGenContext, PPCREC_NAME_R0+rA);
-		// rA = ~rA
-		PPCRecompilerImlGen_generateNewInstruction_r_r(ppcImlGenContext, NULL, PPCREC_IML_OP_NOT, gprRA, gprRA);
-		// rA &= rS
-		if( opcode&PPC_OPC_RC )
-		{
-			PPCRecompilerImlGen_generateNewInstruction_r_r(ppcImlGenContext, NULL, PPCREC_IML_OP_AND, gprRA, gprRS, 0, PPCREC_CR_MODE_LOGICAL);
-		}
-		else
-		{
-			PPCRecompilerImlGen_generateNewInstruction_r_r(ppcImlGenContext, NULL, PPCREC_IML_OP_AND, gprRA, gprRS);
-		}
-	}
-	else
-	{
-		// a & (~b) is the same as ~((~a) | b)
-		sint32 gprRA = PPCRecompilerImlGen_loadRegister(ppcImlGenContext, PPCREC_NAME_R0+rA);
-		sint32 gprRB = PPCRecompilerImlGen_loadRegister(ppcImlGenContext, PPCREC_NAME_R0+rB);
-		sint32 gprRS = PPCRecompilerImlGen_loadOverwriteRegister(ppcImlGenContext, PPCREC_NAME_R0+rS);
-		// move rS to rA (if required)
-		if( gprRA != gprRS )
-		{
-			PPCRecompilerImlGen_generateNewInstruction_r_r(ppcImlGenContext, NULL, PPCREC_IML_OP_ASSIGN, gprRA, gprRS);
-		}
-		// rS already in rA, therefore we complement rS first and then OR it with rB
-		// rA = ~rA
-		PPCRecompilerImlGen_generateNewInstruction_r_r(ppcImlGenContext, NULL, PPCREC_IML_OP_NOT, gprRA, gprRA);
-		// rA |= rB
-		PPCRecompilerImlGen_generateNewInstruction_r_r(ppcImlGenContext, NULL, PPCREC_IML_OP_OR, gprRA, gprRB);
-		// rA = ~rA
-		if( opcode&PPC_OPC_RC )
-		{
-			PPCRecompilerImlGen_generateNewInstruction_r_r(ppcImlGenContext, NULL, PPCREC_IML_OP_NOT, gprRA, gprRA, 0, PPCREC_CR_MODE_LOGICAL);
-		}
-		else
-		{
-			PPCRecompilerImlGen_generateNewInstruction_r_r(ppcImlGenContext, NULL, PPCREC_IML_OP_NOT, gprRA, gprRA);
-		}
-	}
+	// rA = rS & ~rB;
+	IMLReg regS = _GetRegGPR(ppcImlGenContext, rS);
+	IMLReg regB = _GetRegGPR(ppcImlGenContext, rB);
+	IMLReg regTmp = _GetRegTemporary(ppcImlGenContext, 0);
+	IMLReg regA = _GetRegGPR(ppcImlGenContext, rA);
+	ppcImlGenContext->emitInst().make_r_r(PPCREC_IML_OP_NOT, regTmp, regB);
+	ppcImlGenContext->emitInst().make_r_r_r(PPCREC_IML_OP_AND, regA, regS, regTmp);
+	if (opcode & PPC_OPC_RC)
+		PPCImlGen_UpdateCR0(ppcImlGenContext, regA);
 	return true;
 }
 
-void PPCRecompilerImlGen_ANDI(ppcImlGenContext_t* ppcImlGenContext, uint32 opcode)
-{
-	sint32 rS, rA;
-	uint32 imm;
-	PPC_OPC_TEMPL_D_UImm(opcode, rS, rA, imm);
-	// ANDI. always sets cr0 flags
-	sint32 gprSourceReg = PPCRecompilerImlGen_loadRegister(ppcImlGenContext, PPCREC_NAME_R0+rS);
-	sint32 gprDestReg = PPCRecompilerImlGen_loadOverwriteRegister(ppcImlGenContext, PPCREC_NAME_R0+rA);
-	// rA = rS
-	if( gprDestReg != gprSourceReg )
-		PPCRecompilerImlGen_generateNewInstruction_r_r(ppcImlGenContext, NULL, PPCREC_IML_OP_ASSIGN, gprDestReg, gprSourceReg);
-	// rA &= imm32
-	PPCRecompilerImlGen_generateNewInstruction_r_s32(ppcImlGenContext, PPCREC_IML_OP_AND, gprDestReg, (sint32)imm, 0, false, false, 0, PPCREC_CR_MODE_LOGICAL);
-}
-
-void PPCRecompilerImlGen_ANDIS(ppcImlGenContext_t* ppcImlGenContext, uint32 opcode)
-{
-	sint32 rS, rA;
-	uint32 imm;
-	PPC_OPC_TEMPL_D_Shift16(opcode, rS, rA, imm);
-	// ANDI. always sets cr0 flags
-	sint32 gprSourceReg = PPCRecompilerImlGen_loadRegister(ppcImlGenContext, PPCREC_NAME_R0+rS);
-	sint32 gprDestReg = PPCRecompilerImlGen_loadOverwriteRegister(ppcImlGenContext, PPCREC_NAME_R0+rA);
-	// rA = rS
-	if( gprDestReg != gprSourceReg )
-		PPCRecompilerImlGen_generateNewInstruction_r_r(ppcImlGenContext, NULL, PPCREC_IML_OP_ASSIGN, gprDestReg, gprSourceReg);
-	// rA &= imm32
-	PPCRecompilerImlGen_generateNewInstruction_r_s32(ppcImlGenContext, PPCREC_IML_OP_AND, gprDestReg, (sint32)imm, 0, false, false, 0, PPCREC_CR_MODE_LOGICAL);
-}
-
-bool PPCRecompilerImlGen_XOR(ppcImlGenContext_t* ppcImlGenContext, uint32 opcode)
+bool PPCRecompilerImlGen_XOR(ppcImlGenContext_t* ppcImlGenContext, uint32 opcode, bool complementResult)
 {
 	sint32 rS, rA, rB;
 	PPC_OPC_TEMPL_X(opcode, rS, rA, rB);
+	IMLReg regA = _GetRegGPR(ppcImlGenContext, rA);
 	if( rS == rB )
 	{
-		// xor register with itself
-		sint32 gprDestReg = PPCRecompilerImlGen_loadOverwriteRegister(ppcImlGenContext, PPCREC_NAME_R0+rA);
-		if( opcode&PPC_OPC_RC )
-		{
-			PPCRecompilerImlGen_generateNewInstruction_r_r(ppcImlGenContext, NULL, PPCREC_IML_OP_XOR, gprDestReg, gprDestReg, 0, PPCREC_CR_MODE_LOGICAL);
-		}
-		else
-		{
-			PPCRecompilerImlGen_generateNewInstruction_r_r(ppcImlGenContext, NULL, PPCREC_IML_OP_XOR, gprDestReg, gprDestReg);
-		}
+		ppcImlGenContext->emitInst().make_r_s32(PPCREC_IML_OP_ASSIGN, regA, 0);
 	}
 	else
 	{
-		// rA = rS ^ rA
-		sint32 gprSource1Reg = PPCRecompilerImlGen_loadRegister(ppcImlGenContext, PPCREC_NAME_R0+rS);
-		sint32 gprSource2Reg = PPCRecompilerImlGen_loadRegister(ppcImlGenContext, PPCREC_NAME_R0+rB);
-		sint32 gprDestReg = PPCRecompilerImlGen_loadOverwriteRegister(ppcImlGenContext, PPCREC_NAME_R0+rA);
-		if( gprSource1Reg == gprDestReg || gprSource2Reg == gprDestReg )
-		{
-			// make sure we don't overwrite rS or rA
-			if( gprSource1Reg == gprDestReg )
-			{
-				PPCRecompilerImlGen_generateNewInstruction_r_r(ppcImlGenContext, NULL, PPCREC_IML_OP_XOR, gprDestReg, gprSource2Reg);
-			}
-			else
-			{
-				PPCRecompilerImlGen_generateNewInstruction_r_r(ppcImlGenContext, NULL, PPCREC_IML_OP_XOR, gprDestReg, gprSource1Reg);
-			}
-			if( opcode&PPC_OPC_RC )
-			{
-				PPCRecompilerImlGen_generateNewInstruction_r_r(ppcImlGenContext, NULL, PPCREC_IML_OP_AND, gprDestReg, gprDestReg, 0, PPCREC_CR_MODE_LOGICAL);
-			}
-		}
-		else
-		{
-			// rA = rS
-			if( gprDestReg != gprSource1Reg )
-			{
-				PPCRecompilerImlGen_generateNewInstruction_r_r(ppcImlGenContext, NULL, PPCREC_IML_OP_ASSIGN, gprDestReg, gprSource1Reg);
-			}
-			// rA ^= rB
-			if( opcode&PPC_OPC_RC )
-			{
-				PPCRecompilerImlGen_generateNewInstruction_r_r(ppcImlGenContext, NULL, PPCREC_IML_OP_XOR, gprDestReg, gprSource2Reg, 0, PPCREC_CR_MODE_LOGICAL);
-			}
-			else
-			{
-				PPCRecompilerImlGen_generateNewInstruction_r_r(ppcImlGenContext, NULL, PPCREC_IML_OP_XOR, gprDestReg, gprSource2Reg);
-			}
-		}
+		IMLReg regS = _GetRegGPR(ppcImlGenContext, rS);
+		IMLReg regB = _GetRegGPR(ppcImlGenContext, rB);
+		ppcImlGenContext->emitInst().make_r_r_r(PPCREC_IML_OP_XOR, regA, regS, regB);
 	}
+	if (complementResult)
+		ppcImlGenContext->emitInst().make_r_r(PPCREC_IML_OP_NOT, regA, regA);
+	if (opcode & PPC_OPC_RC)
+		PPCImlGen_UpdateCR0(ppcImlGenContext, regA);
 	return true;
 }
 
-
-bool PPCRecompilerImlGen_EQV(ppcImlGenContext_t* ppcImlGenContext, uint32 opcode)
+void PPCRecompilerImlGen_ANDI_ANDIS(ppcImlGenContext_t* ppcImlGenContext, uint32 opcode, bool isShifted)
 {
-	sint32 rS, rA, rB;
-	PPC_OPC_TEMPL_X(opcode, rS, rA, rB);
-	if( rS == rB )
+	sint32 rS, rA;
+	uint32 imm;
+	if (isShifted)
 	{
-		// xor register with itself, then invert
-		sint32 gprDestReg = PPCRecompilerImlGen_loadOverwriteRegister(ppcImlGenContext, PPCREC_NAME_R0+rA);
-		PPCRecompilerImlGen_generateNewInstruction_r_r(ppcImlGenContext, NULL, PPCREC_IML_OP_XOR, gprDestReg, gprDestReg);
-		if( opcode&PPC_OPC_RC )
-			PPCRecompilerImlGen_generateNewInstruction_r_r(ppcImlGenContext, NULL, PPCREC_IML_OP_NOT, gprDestReg, gprDestReg, 0, PPCREC_CR_MODE_LOGICAL);
-		else
-			PPCRecompilerImlGen_generateNewInstruction_r_r(ppcImlGenContext, NULL, PPCREC_IML_OP_NOT, gprDestReg, gprDestReg);
+		PPC_OPC_TEMPL_D_Shift16(opcode, rS, rA, imm);
 	}
 	else
 	{
-		// rA = ~(rS ^ rA)
-		sint32 gprSource1Reg = PPCRecompilerImlGen_loadRegister(ppcImlGenContext, PPCREC_NAME_R0+rS);
-		sint32 gprSource2Reg = PPCRecompilerImlGen_loadRegister(ppcImlGenContext, PPCREC_NAME_R0+rB);
-		sint32 gprDestReg = PPCRecompilerImlGen_loadOverwriteRegister(ppcImlGenContext, PPCREC_NAME_R0+rA);
-		if( gprSource1Reg == gprDestReg || gprSource2Reg == gprDestReg )
-		{
-			// make sure we don't overwrite rS or rA
-			if( gprSource1Reg == gprDestReg )
-			{
-				PPCRecompilerImlGen_generateNewInstruction_r_r(ppcImlGenContext, NULL, PPCREC_IML_OP_XOR, gprDestReg, gprSource2Reg);
-			}
-			else
-			{
-				PPCRecompilerImlGen_generateNewInstruction_r_r(ppcImlGenContext, NULL, PPCREC_IML_OP_XOR, gprDestReg, gprSource1Reg);
-			}
-		}
-		else
-		{
-			// rA = rS
-			if( gprDestReg != gprSource1Reg )
-			{
-				PPCRecompilerImlGen_generateNewInstruction_r_r(ppcImlGenContext, NULL, PPCREC_IML_OP_ASSIGN, gprDestReg, gprSource1Reg);
-			}
-			// rA ^= rB
-			PPCRecompilerImlGen_generateNewInstruction_r_r(ppcImlGenContext, NULL, PPCREC_IML_OP_XOR, gprDestReg, gprSource2Reg);
-		}
-		if( opcode&PPC_OPC_RC )
-			PPCRecompilerImlGen_generateNewInstruction_r_r(ppcImlGenContext, NULL, PPCREC_IML_OP_NOT, gprDestReg, gprDestReg, 0, PPCREC_CR_MODE_LOGICAL);
-		else
-			PPCRecompilerImlGen_generateNewInstruction_r_r(ppcImlGenContext, NULL, PPCREC_IML_OP_NOT, gprDestReg, gprDestReg);
+		PPC_OPC_TEMPL_D_UImm(opcode, rS, rA, imm);
 	}
-	return true;
+	IMLReg regS = _GetRegGPR(ppcImlGenContext, rS);
+	IMLReg regA = _GetRegGPR(ppcImlGenContext, rA);
+	ppcImlGenContext->emitInst().make_r_r_s32(PPCREC_IML_OP_AND, regA, regS, (sint32)imm);
+	// ANDI/ANDIS always updates cr0
+	PPCImlGen_UpdateCR0(ppcImlGenContext, regA);
 }
 
-void PPCRecompilerImlGen_ORI(ppcImlGenContext_t* ppcImlGenContext, uint32 opcode)
+void PPCRecompilerImlGen_ORI_ORIS(ppcImlGenContext_t* ppcImlGenContext, uint32 opcode, bool isShifted)
 {
 	sint32 rS, rA;
 	uint32 imm;
-	PPC_OPC_TEMPL_D_UImm(opcode, rS, rA, imm);
-	// ORI does not set cr0 flags
-	//hCPU->gpr[rA] = hCPU->gpr[rS] | imm;
-	sint32 gprSourceReg = PPCRecompilerImlGen_loadRegister(ppcImlGenContext, PPCREC_NAME_R0+rS);
-	sint32 gprDestReg = PPCRecompilerImlGen_loadOverwriteRegister(ppcImlGenContext, PPCREC_NAME_R0+rA);
-	// rA = rS
-	if( gprDestReg != gprSourceReg )
-		PPCRecompilerImlGen_generateNewInstruction_r_r(ppcImlGenContext, NULL, PPCREC_IML_OP_ASSIGN, gprDestReg, gprSourceReg);
-	// rA |= imm32
-	PPCRecompilerImlGen_generateNewInstruction_r_s32(ppcImlGenContext, PPCREC_IML_OP_OR, gprDestReg, (sint32)imm, 0, false, false, PPC_REC_INVALID_REGISTER, 0);
+	if (isShifted)
+	{
+		PPC_OPC_TEMPL_D_Shift16(opcode, rS, rA, imm);
+	}
+	else
+	{
+		PPC_OPC_TEMPL_D_UImm(opcode, rS, rA, imm);
+	}
+	IMLReg regS = _GetRegGPR(ppcImlGenContext, rS);
+	IMLReg regA = _GetRegGPR(ppcImlGenContext, rA);
+	ppcImlGenContext->emitInst().make_r_r_s32(PPCREC_IML_OP_OR, regA, regS, (sint32)imm);
 }
 
-void PPCRecompilerImlGen_ORIS(ppcImlGenContext_t* ppcImlGenContext, uint32 opcode)
+void PPCRecompilerImlGen_XORI_XORIS(ppcImlGenContext_t* ppcImlGenContext, uint32 opcode, bool isShifted)
 {
 	sint32 rS, rA;
 	uint32 imm;
-	PPC_OPC_TEMPL_D_Shift16(opcode, rS, rA, imm);
-	// ORI does not set cr0 flags
-	//hCPU->gpr[rA] = hCPU->gpr[rS] | imm;
-	sint32 gprSourceReg = PPCRecompilerImlGen_loadRegister(ppcImlGenContext, PPCREC_NAME_R0+rS);
-	sint32 gprDestReg = PPCRecompilerImlGen_loadOverwriteRegister(ppcImlGenContext, PPCREC_NAME_R0+rA);
-	// rA = rS
-	if( gprDestReg != gprSourceReg )
-		PPCRecompilerImlGen_generateNewInstruction_r_r(ppcImlGenContext, NULL, PPCREC_IML_OP_ASSIGN, gprDestReg, gprSourceReg);
-	// rA |= imm32
-	PPCRecompilerImlGen_generateNewInstruction_r_s32(ppcImlGenContext, PPCREC_IML_OP_OR, gprDestReg, (sint32)imm, 0, false, false, PPC_REC_INVALID_REGISTER, 0);
-}
-
-void PPCRecompilerImlGen_XORI(ppcImlGenContext_t* ppcImlGenContext, uint32 opcode)
-{
-	sint32 rS, rA;
-	uint32 imm;
-	PPC_OPC_TEMPL_D_UImm(opcode, rS, rA, imm);
-	//hCPU->gpr[rA] = hCPU->gpr[rS] ^ imm;
-	// XORI does not set cr0 flags
-	sint32 gprSourceReg = PPCRecompilerImlGen_loadRegister(ppcImlGenContext, PPCREC_NAME_R0+rS);
-	sint32 gprDestReg = PPCRecompilerImlGen_loadOverwriteRegister(ppcImlGenContext, PPCREC_NAME_R0+rA);
-	// rA = rS
-	if( gprDestReg != gprSourceReg )
-		PPCRecompilerImlGen_generateNewInstruction_r_r(ppcImlGenContext, NULL, PPCREC_IML_OP_ASSIGN, gprDestReg, gprSourceReg);
-	// rA |= imm32
-	PPCRecompilerImlGen_generateNewInstruction_r_s32(ppcImlGenContext, PPCREC_IML_OP_XOR, gprDestReg, (sint32)imm, 0, false, false, PPC_REC_INVALID_REGISTER, 0);
-}
-
-void PPCRecompilerImlGen_XORIS(ppcImlGenContext_t* ppcImlGenContext, uint32 opcode)
-{
-	sint32 rS, rA;
-	uint32 imm;
-	PPC_OPC_TEMPL_D_Shift16(opcode, rS, rA, imm);
-	//hCPU->gpr[rA] = hCPU->gpr[rS] ^ imm;
-	// XORIS does not set cr0 flags
-	sint32 gprSourceReg = PPCRecompilerImlGen_loadRegister(ppcImlGenContext, PPCREC_NAME_R0+rS);
-	sint32 gprDestReg = PPCRecompilerImlGen_loadOverwriteRegister(ppcImlGenContext, PPCREC_NAME_R0+rA);
-	// rA = rS
-	if( gprDestReg != gprSourceReg )
-		PPCRecompilerImlGen_generateNewInstruction_r_r(ppcImlGenContext, NULL, PPCREC_IML_OP_ASSIGN, gprDestReg, gprSourceReg);
-	// rA |= imm32
-	PPCRecompilerImlGen_generateNewInstruction_r_s32(ppcImlGenContext, PPCREC_IML_OP_XOR, gprDestReg, (sint32)imm, 0, false, false, PPC_REC_INVALID_REGISTER, 0);
+	if (isShifted)
+	{
+		PPC_OPC_TEMPL_D_Shift16(opcode, rS, rA, imm);
+	}
+	else
+	{
+		PPC_OPC_TEMPL_D_UImm(opcode, rS, rA, imm);
+	}
+	IMLReg regS = _GetRegGPR(ppcImlGenContext, rS);
+	IMLReg regA = _GetRegGPR(ppcImlGenContext, rA);
+	ppcImlGenContext->emitInst().make_r_r_s32(PPCREC_IML_OP_XOR, regA, regS, (sint32)imm);
 }
 
 bool PPCRecompilerImlGen_CROR(ppcImlGenContext_t* ppcImlGenContext, uint32 opcode)
 {
 	int crD, crA, crB;
 	PPC_OPC_TEMPL_X(opcode, crD, crA, crB);
-	PPCRecompilerImlGen_generateNewInstruction_cr(ppcImlGenContext, PPCREC_IML_OP_CR_OR, crD, crA, crB);
+	IMLReg regCrA = _GetRegCR(ppcImlGenContext, crA);
+	IMLReg regCrB = _GetRegCR(ppcImlGenContext, crB);
+	IMLReg regCrR = _GetRegCR(ppcImlGenContext, crD);
+	ppcImlGenContext->emitInst().make_r_r_r(PPCREC_IML_OP_OR, regCrR, regCrA, regCrB);
 	return true;
 }
 
@@ -2901,7 +1765,12 @@ bool PPCRecompilerImlGen_CRORC(ppcImlGenContext_t* ppcImlGenContext, uint32 opco
 {
 	int crD, crA, crB;
 	PPC_OPC_TEMPL_X(opcode, crD, crA, crB);
-	PPCRecompilerImlGen_generateNewInstruction_cr(ppcImlGenContext, PPCREC_IML_OP_CR_ORC, crD, crA, crB);
+	IMLReg regCrA = _GetRegCR(ppcImlGenContext, crA);
+	IMLReg regCrB = _GetRegCR(ppcImlGenContext, crB);
+	IMLReg regCrR = _GetRegCR(ppcImlGenContext, crD);
+	IMLReg regTmp = PPCRecompilerImlGen_loadRegister(ppcImlGenContext, PPCREC_NAME_TEMPORARY);
+	ppcImlGenContext->emitInst().make_r_r_s32(PPCREC_IML_OP_XOR, regTmp, regCrB, 1); // invert crB
+	ppcImlGenContext->emitInst().make_r_r_r(PPCREC_IML_OP_OR, regCrR, regCrA, regTmp);
 	return true;
 }
 
@@ -2909,7 +1778,10 @@ bool PPCRecompilerImlGen_CRAND(ppcImlGenContext_t* ppcImlGenContext, uint32 opco
 {
 	int crD, crA, crB;
 	PPC_OPC_TEMPL_X(opcode, crD, crA, crB);
-	PPCRecompilerImlGen_generateNewInstruction_cr(ppcImlGenContext, PPCREC_IML_OP_CR_AND, crD, crA, crB);
+	IMLReg regCrA = _GetRegCR(ppcImlGenContext, crA);
+	IMLReg regCrB = _GetRegCR(ppcImlGenContext, crB);
+	IMLReg regCrR = _GetRegCR(ppcImlGenContext, crD);
+	ppcImlGenContext->emitInst().make_r_r_r(PPCREC_IML_OP_AND, regCrR, regCrA, regCrB);
 	return true;
 }
 
@@ -2917,7 +1789,12 @@ bool PPCRecompilerImlGen_CRANDC(ppcImlGenContext_t* ppcImlGenContext, uint32 opc
 {
 	int crD, crA, crB;
 	PPC_OPC_TEMPL_X(opcode, crD, crA, crB);
-	PPCRecompilerImlGen_generateNewInstruction_cr(ppcImlGenContext, PPCREC_IML_OP_CR_ANDC, crD, crA, crB);
+	IMLReg regCrA = _GetRegCR(ppcImlGenContext, crA);
+	IMLReg regCrB = _GetRegCR(ppcImlGenContext, crB);
+	IMLReg regCrR = _GetRegCR(ppcImlGenContext, crD);
+	IMLReg regTmp = PPCRecompilerImlGen_loadRegister(ppcImlGenContext, PPCREC_NAME_TEMPORARY);
+	ppcImlGenContext->emitInst().make_r_r_s32(PPCREC_IML_OP_XOR, regTmp, regCrB, 1); // invert crB
+	ppcImlGenContext->emitInst().make_r_r_r(PPCREC_IML_OP_AND, regCrR, regCrA, regTmp);
 	return true;
 }
 
@@ -2925,17 +1802,15 @@ bool PPCRecompilerImlGen_CRXOR(ppcImlGenContext_t* ppcImlGenContext, uint32 opco
 {
 	int crD, crA, crB;
 	PPC_OPC_TEMPL_X(opcode, crD, crA, crB);
-	if (crA == crB)
+	IMLReg regCrA = _GetRegCR(ppcImlGenContext, crA);
+	IMLReg regCrB = _GetRegCR(ppcImlGenContext, crB);
+	IMLReg regCrR = _GetRegCR(ppcImlGenContext, crD);
+	if (regCrA == regCrB)
 	{
-		// both operands equal, clear bit in crD
-		// PPC's assert() uses this to pass a parameter to OSPanic
-		PPCRecompilerImlGen_generateNewInstruction_cr(ppcImlGenContext, PPCREC_IML_OP_CR_CLEAR, crD, 0, 0);
+		ppcImlGenContext->emitInst().make_r_s32(PPCREC_IML_OP_ASSIGN, regCrR, 0);
 		return true;
 	}
-	else
-	{
-		return false;
-	}
+	ppcImlGenContext->emitInst().make_r_r_r(PPCREC_IML_OP_XOR, regCrR, regCrA, regCrB);
 	return true;
 }
 
@@ -2943,23 +1818,24 @@ bool PPCRecompilerImlGen_CREQV(ppcImlGenContext_t* ppcImlGenContext, uint32 opco
 {
 	int crD, crA, crB;
 	PPC_OPC_TEMPL_X(opcode, crD, crA, crB);
-	if (crA == crB)
+	IMLReg regCrA = _GetRegCR(ppcImlGenContext, crA);
+	IMLReg regCrB = _GetRegCR(ppcImlGenContext, crB);
+	IMLReg regCrR = _GetRegCR(ppcImlGenContext, crD);
+	if (regCrA == regCrB)
 	{
-		// both operands equal, set bit in crD
-		PPCRecompilerImlGen_generateNewInstruction_cr(ppcImlGenContext, PPCREC_IML_OP_CR_SET, crD, 0, 0);
+		ppcImlGenContext->emitInst().make_r_s32(PPCREC_IML_OP_ASSIGN, regCrR, 1);
 		return true;
 	}
-	else
-	{
-		return false;
-	}
+	IMLReg regTmp = PPCRecompilerImlGen_loadRegister(ppcImlGenContext, PPCREC_NAME_TEMPORARY);
+	ppcImlGenContext->emitInst().make_r_r_s32(PPCREC_IML_OP_XOR, regTmp, regCrB, 1); // invert crB
+	ppcImlGenContext->emitInst().make_r_r_r(PPCREC_IML_OP_XOR, regCrR, regCrA, regTmp);
 	return true;
 }
 
 bool PPCRecompilerImlGen_HLE(ppcImlGenContext_t* ppcImlGenContext, uint32 opcode)
 {
 	uint32 hleFuncId = opcode&0xFFFF;
-	PPCRecompilerImlGen_generateNewInstruction_macro(ppcImlGenContext, PPCREC_IML_MACRO_HLE, ppcImlGenContext->ppcAddressOfCurrentInstruction, hleFuncId, 0);
+	ppcImlGenContext->emitInst().make_macro(PPCREC_IML_MACRO_HLE, ppcImlGenContext->ppcAddressOfCurrentInstruction, hleFuncId, 0, IMLREG_INVALID);
 	return true;
 }
 
@@ -2970,12 +1846,6 @@ uint32 PPCRecompiler_iterateCurrentInstruction(ppcImlGenContext_t* ppcImlGenCont
 	return v;
 }
 
-uint32 PPCRecompiler_getInstructionByOffset(ppcImlGenContext_t* ppcImlGenContext, uint32 offset)
-{
-	uint32 v = CPU_swapEndianU32(*(ppcImlGenContext->currentInstruction + offset/4));
-	return v;
-}
-
 uint32 PPCRecompiler_getCurrentInstruction(ppcImlGenContext_t* ppcImlGenContext)
 {
 	uint32 v = CPU_swapEndianU32(*(ppcImlGenContext->currentInstruction));
@@ -2988,480 +1858,10 @@ uint32 PPCRecompiler_getPreviousInstruction(ppcImlGenContext_t* ppcImlGenContext
 	return v;
 }
 
-char _tempOpcodename[32];
-
-const char* PPCRecompiler_getOpcodeDebugName(PPCRecImlInstruction_t* iml)
-{
-	uint32 op = iml->operation;
-	if (op == PPCREC_IML_OP_ASSIGN)
-		return "MOV";
-	else if (op == PPCREC_IML_OP_ADD)
-		return "ADD";
-	else if (op == PPCREC_IML_OP_SUB)
-		return "SUB";
-	else if (op == PPCREC_IML_OP_ADD_CARRY_UPDATE_CARRY)
-		return "ADDCSC";
-	else if (op == PPCREC_IML_OP_OR)
-		return "OR";
-	else if (op == PPCREC_IML_OP_AND)
-		return "AND";
-	else if (op == PPCREC_IML_OP_XOR)
-		return "XOR";
-	else if (op == PPCREC_IML_OP_LEFT_SHIFT)
-		return "LSH";
-	else if (op == PPCREC_IML_OP_RIGHT_SHIFT)
-		return "RSH";
-	else if (op == PPCREC_IML_OP_MULTIPLY_SIGNED)
-		return "MULS";
-	else if (op == PPCREC_IML_OP_DIVIDE_SIGNED)
-		return "DIVS";
-
-	sprintf(_tempOpcodename, "OP0%02x_T%d", iml->operation, iml->type);
-	return _tempOpcodename;
-}
-
-void PPCRecDebug_addRegisterParam(StringBuf& strOutput, sint32 virtualRegister, bool isLast = false)
-{
-	if (isLast)
-	{
-		if (virtualRegister < 10)
-			strOutput.addFmt("t{} ", virtualRegister);
-		else
-			strOutput.addFmt("t{}", virtualRegister);
-		return;
-	}
-	if (virtualRegister < 10)
-		strOutput.addFmt("t{} , ", virtualRegister);
-	else
-		strOutput.addFmt("t{}, ", virtualRegister);
-}
-
-void PPCRecDebug_addS32Param(StringBuf& strOutput, sint32 val, bool isLast = false)
-{
-	if (isLast)
-	{
-		strOutput.addFmt("0x{:08x}", val);
-		return;
-	}
-	strOutput.addFmt("0x{:08x}, ", val);
-}
-
-void PPCRecompilerDebug_printLivenessRangeInfo(StringBuf& currentLineText, PPCRecImlSegment_t* imlSegment, sint32 offset)
-{
-	// pad to 70 characters
-	sint32 index = currentLineText.getLen();
-	while (index < 70)
-	{
-		debug_printf(" ");
-		index++;
-	}
-	raLivenessSubrange_t* subrangeItr = imlSegment->raInfo.linkedList_allSubranges;
-	while (subrangeItr)
-	{
-		if (offset == subrangeItr->start.index)
-		{
-			if (false)//subrange->isDirtied && i == subrange->becomesDirtyAtIndex.index)
-			{
-				debug_printf("*%-2d", subrangeItr->range->virtualRegister);
-			}
-			else
-			{
-				debug_printf("|%-2d", subrangeItr->range->virtualRegister);
-			}
-		}
-		else if (false)//subrange->isDirtied && i == subrange->becomesDirtyAtIndex.index )
-		{
-			debug_printf("*  ");
-		}
-		else if (offset >= subrangeItr->start.index && offset < subrangeItr->end.index)
-		{
-			debug_printf("|  ");
-		}
-		else
-		{
-			debug_printf("   ");
-		}
-		index += 3;
-		// next
-		subrangeItr = subrangeItr->link_segmentSubrangesGPR.next;
-	}
-}
-
-void PPCRecompiler_dumpIMLSegment(PPCRecImlSegment_t* imlSegment, sint32 segmentIndex, bool printLivenessRangeInfo)
-{
-	StringBuf strOutput(1024);
-
-	strOutput.addFmt("SEGMENT 0x{:04x} 0x{:08x} PPC 0x{:08x} - 0x{:08x} Loop-depth {}", segmentIndex, imlSegment->ppcAddress, imlSegment->ppcAddrMin, imlSegment->ppcAddrMax, imlSegment->loopDepth);
-	if (imlSegment->isEnterable)
-	{
-		strOutput.addFmt(" ENTERABLE (0x{:08x})", imlSegment->enterPPCAddress);
-	}
-	else if( imlSegment->isJumpDestination )
-	{
-		strOutput.addFmt(" JUMP-DEST (0x{:08x})", imlSegment->jumpDestinationPPCAddress);
-	}
-
-	debug_printf("%s\n", strOutput.c_str());
-
-	strOutput.reset();
-	strOutput.addFmt("SEGMENT NAME 0x{:016x}", (uintptr_t)imlSegment);
-	debug_printf("%s", strOutput.c_str());
-
-	if (printLivenessRangeInfo)
-	{
-		PPCRecompilerDebug_printLivenessRangeInfo(strOutput, imlSegment, RA_INTER_RANGE_START);
-	}
-	debug_printf("\n");
-
-	sint32 lineOffsetParameters = 18;
-
-	for(sint32 i=0; i<imlSegment->imlListCount; i++)
-	{
-		// don't log NOP instructions unless they have an associated PPC address
-		if(imlSegment->imlList[i].type == PPCREC_IML_TYPE_NO_OP && imlSegment->imlList[i].associatedPPCAddress == MPTR_NULL)
-			continue;
-		strOutput.reset();
-		strOutput.addFmt("{:08x} ", imlSegment->imlList[i].associatedPPCAddress);
-		if( imlSegment->imlList[i].type == PPCREC_IML_TYPE_R_NAME || imlSegment->imlList[i].type == PPCREC_IML_TYPE_NAME_R)
-		{
-			if(imlSegment->imlList[i].type == PPCREC_IML_TYPE_R_NAME)
-				strOutput.add("LD_NAME");
-			else
-				strOutput.add("ST_NAME");
-			while ((sint32)strOutput.getLen() < lineOffsetParameters)
-				strOutput.add(" ");
-
-			PPCRecDebug_addRegisterParam(strOutput, imlSegment->imlList[i].op_r_name.registerIndex);
-
-			strOutput.addFmt("name_{} (", imlSegment->imlList[i].op_r_name.registerIndex, imlSegment->imlList[i].op_r_name.name);
-			if( imlSegment->imlList[i].op_r_name.name >= PPCREC_NAME_R0 && imlSegment->imlList[i].op_r_name.name < (PPCREC_NAME_R0+999) )
-			{
-				strOutput.addFmt("r{}", imlSegment->imlList[i].op_r_name.name-PPCREC_NAME_R0);
-			}
-			else if( imlSegment->imlList[i].op_r_name.name >= PPCREC_NAME_SPR0 && imlSegment->imlList[i].op_r_name.name < (PPCREC_NAME_SPR0+999) )
-			{
-				strOutput.addFmt("spr{}", imlSegment->imlList[i].op_r_name.name-PPCREC_NAME_SPR0);
-			}
-			else
-				strOutput.add("ukn");
-			strOutput.add(")");
-		}
-		else if( imlSegment->imlList[i].type == PPCREC_IML_TYPE_R_R )
-		{
-			strOutput.addFmt("{}", PPCRecompiler_getOpcodeDebugName(imlSegment->imlList+i));
-			while ((sint32)strOutput.getLen() < lineOffsetParameters)
-				strOutput.add(" ");
-			PPCRecDebug_addRegisterParam(strOutput, imlSegment->imlList[i].op_r_r.registerResult);
-			PPCRecDebug_addRegisterParam(strOutput, imlSegment->imlList[i].op_r_r.registerA, true);
-
-			if( imlSegment->imlList[i].crRegister != PPC_REC_INVALID_REGISTER )
-			{
-				strOutput.addFmt(" -> CR{}", imlSegment->imlList[i].crRegister);
-			}
-		}
-		else if( imlSegment->imlList[i].type == PPCREC_IML_TYPE_R_R_R )
-		{
-			strOutput.addFmt("{}", PPCRecompiler_getOpcodeDebugName(imlSegment->imlList + i));
-			while ((sint32)strOutput.getLen() < lineOffsetParameters)
-				strOutput.add(" ");
-			PPCRecDebug_addRegisterParam(strOutput, imlSegment->imlList[i].op_r_r_r.registerResult);
-			PPCRecDebug_addRegisterParam(strOutput, imlSegment->imlList[i].op_r_r_r.registerA);
-			PPCRecDebug_addRegisterParam(strOutput, imlSegment->imlList[i].op_r_r_r.registerB, true);
-			if( imlSegment->imlList[i].crRegister != PPC_REC_INVALID_REGISTER )
-			{
-				strOutput.addFmt(" -> CR{}", imlSegment->imlList[i].crRegister);
-			}
-		}
-		else if (imlSegment->imlList[i].type == PPCREC_IML_TYPE_R_R_S32)
-		{
-			strOutput.addFmt("{}", PPCRecompiler_getOpcodeDebugName(imlSegment->imlList + i));
-			while ((sint32)strOutput.getLen() < lineOffsetParameters)
-				strOutput.add(" ");
-
-			PPCRecDebug_addRegisterParam(strOutput, imlSegment->imlList[i].op_r_r_s32.registerResult);
-			PPCRecDebug_addRegisterParam(strOutput, imlSegment->imlList[i].op_r_r_s32.registerA);
-			PPCRecDebug_addS32Param(strOutput, imlSegment->imlList[i].op_r_r_s32.immS32, true);
-
-			if (imlSegment->imlList[i].crRegister != PPC_REC_INVALID_REGISTER)
-			{
-				strOutput.addFmt(" -> CR{}", imlSegment->imlList[i].crRegister);
-			}
-		}
-		else if (imlSegment->imlList[i].type == PPCREC_IML_TYPE_R_S32)
-		{
-			strOutput.addFmt("{}", PPCRecompiler_getOpcodeDebugName(imlSegment->imlList + i));
-			while ((sint32)strOutput.getLen() < lineOffsetParameters)
-				strOutput.add(" ");
-
-			PPCRecDebug_addRegisterParam(strOutput, imlSegment->imlList[i].op_r_immS32.registerIndex);
-			PPCRecDebug_addS32Param(strOutput, imlSegment->imlList[i].op_r_immS32.immS32, true);
-
-			if (imlSegment->imlList[i].crRegister != PPC_REC_INVALID_REGISTER)
-			{
-				strOutput.addFmt(" -> CR{}", imlSegment->imlList[i].crRegister);
-			}
-		}
-		else if( imlSegment->imlList[i].type == PPCREC_IML_TYPE_JUMPMARK )
-		{
-			strOutput.addFmt("jm_{:08x}:", imlSegment->imlList[i].op_jumpmark.address);
-		}
-		else if( imlSegment->imlList[i].type == PPCREC_IML_TYPE_PPC_ENTER )
-		{
-			strOutput.addFmt("ppcEnter_{:08x}:", imlSegment->imlList[i].op_ppcEnter.ppcAddress);
-		}
-		else if(imlSegment->imlList[i].type == PPCREC_IML_TYPE_LOAD || imlSegment->imlList[i].type == PPCREC_IML_TYPE_STORE ||
-			imlSegment->imlList[i].type == PPCREC_IML_TYPE_LOAD_INDEXED || imlSegment->imlList[i].type == PPCREC_IML_TYPE_STORE_INDEXED )
-		{
-			if(imlSegment->imlList[i].type == PPCREC_IML_TYPE_LOAD || imlSegment->imlList[i].type == PPCREC_IML_TYPE_LOAD_INDEXED)
-				strOutput.add("LD_");
-			else
-				strOutput.add("ST_");
-
-			if (imlSegment->imlList[i].op_storeLoad.flags2.signExtend)
-				strOutput.add("S");
-			else
-				strOutput.add("U");
-			strOutput.addFmt("{}", imlSegment->imlList[i].op_storeLoad.copyWidth);
-			
-			while ((sint32)strOutput.getLen() < lineOffsetParameters)
-				strOutput.add(" ");
-
-			PPCRecDebug_addRegisterParam(strOutput, imlSegment->imlList[i].op_storeLoad.registerData);
-			
-			if(imlSegment->imlList[i].type == PPCREC_IML_TYPE_LOAD_INDEXED || imlSegment->imlList[i].type == PPCREC_IML_TYPE_STORE_INDEXED)
-				strOutput.addFmt("[t{}+t{}]", imlSegment->imlList[i].op_storeLoad.registerMem, imlSegment->imlList[i].op_storeLoad.registerMem2);
-			else
-				strOutput.addFmt("[t{}+{}]", imlSegment->imlList[i].op_storeLoad.registerMem, imlSegment->imlList[i].op_storeLoad.immS32);
-		}
-		else if (imlSegment->imlList[i].type == PPCREC_IML_TYPE_MEM2MEM)
-		{
-			strOutput.addFmt("{} [t{}+{}] = [t{}+{}]", imlSegment->imlList[i].op_mem2mem.copyWidth, imlSegment->imlList[i].op_mem2mem.dst.registerMem, imlSegment->imlList[i].op_mem2mem.dst.immS32, imlSegment->imlList[i].op_mem2mem.src.registerMem, imlSegment->imlList[i].op_mem2mem.src.immS32);
-		}
-		else if( imlSegment->imlList[i].type == PPCREC_IML_TYPE_CJUMP )
-		{
-			if (imlSegment->imlList[i].op_conditionalJump.condition == PPCREC_JUMP_CONDITION_E)
-				strOutput.add("JE");
-			else if (imlSegment->imlList[i].op_conditionalJump.condition == PPCREC_JUMP_CONDITION_NE)
-				strOutput.add("JNE");
-			else if (imlSegment->imlList[i].op_conditionalJump.condition == PPCREC_JUMP_CONDITION_G)
-				strOutput.add("JG");
-			else if (imlSegment->imlList[i].op_conditionalJump.condition == PPCREC_JUMP_CONDITION_GE)
-				strOutput.add("JGE");
-			else if (imlSegment->imlList[i].op_conditionalJump.condition == PPCREC_JUMP_CONDITION_L)
-				strOutput.add("JL");
-			else if (imlSegment->imlList[i].op_conditionalJump.condition == PPCREC_JUMP_CONDITION_LE)
-				strOutput.add("JLE");
-			else if (imlSegment->imlList[i].op_conditionalJump.condition == PPCREC_JUMP_CONDITION_NONE)
-				strOutput.add("JALW"); // jump always
-			else
-				cemu_assert_unimplemented();
-			strOutput.addFmt(" jm_{:08x} (cr{})", imlSegment->imlList[i].op_conditionalJump.jumpmarkAddress, imlSegment->imlList[i].crRegister);
-		}
-		else if( imlSegment->imlList[i].type == PPCREC_IML_TYPE_NO_OP )
-		{
-		strOutput.add("NOP");
-		}
-		else if( imlSegment->imlList[i].type == PPCREC_IML_TYPE_MACRO )
-		{
-			if( imlSegment->imlList[i].operation == PPCREC_IML_MACRO_BLR )
-			{
-				strOutput.addFmt("MACRO BLR 0x{:08x} cycles (depr): {}", imlSegment->imlList[i].op_macro.param, (sint32)imlSegment->imlList[i].op_macro.paramU16);
-			}
-			else if( imlSegment->imlList[i].operation == PPCREC_IML_MACRO_BLRL )
-			{
-				strOutput.addFmt("MACRO BLRL 0x{:08x} cycles (depr): {}", imlSegment->imlList[i].op_macro.param, (sint32)imlSegment->imlList[i].op_macro.paramU16);
-			}
-			else if( imlSegment->imlList[i].operation == PPCREC_IML_MACRO_BCTR )
-			{
-				strOutput.addFmt("MACRO BCTR 0x{:08x} cycles (depr): {}", imlSegment->imlList[i].op_macro.param, (sint32)imlSegment->imlList[i].op_macro.paramU16);
-			}
-			else if( imlSegment->imlList[i].operation == PPCREC_IML_MACRO_BCTRL )
-			{
-				strOutput.addFmt("MACRO BCTRL 0x{:08x} cycles (depr): {}", imlSegment->imlList[i].op_macro.param, (sint32)imlSegment->imlList[i].op_macro.paramU16);
-			}
-			else if( imlSegment->imlList[i].operation == PPCREC_IML_MACRO_BL )
-			{
-				strOutput.addFmt("MACRO BL 0x{:08x} -> 0x{:08x} cycles (depr): {}", imlSegment->imlList[i].op_macro.param, imlSegment->imlList[i].op_macro.param2, (sint32)imlSegment->imlList[i].op_macro.paramU16);
-			}
-			else if( imlSegment->imlList[i].operation == PPCREC_IML_MACRO_B_FAR )
-			{
-				strOutput.addFmt("MACRO B_FAR 0x{:08x} -> 0x{:08x} cycles (depr): {}", imlSegment->imlList[i].op_macro.param, imlSegment->imlList[i].op_macro.param2, (sint32)imlSegment->imlList[i].op_macro.paramU16);
-			}
-			else if( imlSegment->imlList[i].operation == PPCREC_IML_MACRO_LEAVE )
-			{
-				strOutput.addFmt("MACRO LEAVE ppc: 0x{:08x}", imlSegment->imlList[i].op_macro.param);
-			}
-			else if( imlSegment->imlList[i].operation == PPCREC_IML_MACRO_HLE )
-			{
-				strOutput.addFmt("MACRO HLE ppcAddr: 0x{:08x} funcId: 0x{:08x}", imlSegment->imlList[i].op_macro.param, imlSegment->imlList[i].op_macro.param2);
-			}
-			else if( imlSegment->imlList[i].operation == PPCREC_IML_MACRO_MFTB )
-			{
-				strOutput.addFmt("MACRO MFTB ppcAddr: 0x{:08x} sprId: 0x{:08x}", imlSegment->imlList[i].op_macro.param, imlSegment->imlList[i].op_macro.param2);
-			}
-			else if( imlSegment->imlList[i].operation == PPCREC_IML_MACRO_COUNT_CYCLES )
-			{
-				strOutput.addFmt("MACRO COUNT_CYCLES cycles: {}", imlSegment->imlList[i].op_macro.param);
-			}
-			else
-			{
-				strOutput.addFmt("MACRO ukn operation {}", imlSegment->imlList[i].operation);
-			}
-		}
-		else if( imlSegment->imlList[i].type == PPCREC_IML_TYPE_FPR_R_NAME )
-		{
-			strOutput.addFmt("fpr_t{} = name_{} (", imlSegment->imlList[i].op_r_name.registerIndex, imlSegment->imlList[i].op_r_name.name);
-			if( imlSegment->imlList[i].op_r_name.name >= PPCREC_NAME_FPR0 && imlSegment->imlList[i].op_r_name.name < (PPCREC_NAME_FPR0+999) )
-			{
-				strOutput.addFmt("fpr{}", imlSegment->imlList[i].op_r_name.name-PPCREC_NAME_FPR0);
-			}
-			else if( imlSegment->imlList[i].op_r_name.name >= PPCREC_NAME_TEMPORARY_FPR0 && imlSegment->imlList[i].op_r_name.name < (PPCREC_NAME_TEMPORARY_FPR0+999) )
-			{
-				strOutput.addFmt("tempFpr{}", imlSegment->imlList[i].op_r_name.name-PPCREC_NAME_TEMPORARY_FPR0);
-			}
-			else
-				strOutput.add("ukn");
-			strOutput.add(")");
-		}
-		else if( imlSegment->imlList[i].type == PPCREC_IML_TYPE_FPR_NAME_R )
-		{
-			strOutput.addFmt("name_{} (", imlSegment->imlList[i].op_r_name.name);
-			if( imlSegment->imlList[i].op_r_name.name >= PPCREC_NAME_FPR0 && imlSegment->imlList[i].op_r_name.name < (PPCREC_NAME_FPR0+999) )
-			{
-				strOutput.addFmt("fpr{}", imlSegment->imlList[i].op_r_name.name-PPCREC_NAME_FPR0);
-			}
-			else if( imlSegment->imlList[i].op_r_name.name >= PPCREC_NAME_TEMPORARY_FPR0 && imlSegment->imlList[i].op_r_name.name < (PPCREC_NAME_TEMPORARY_FPR0+999) )
-			{
-				strOutput.addFmt("tempFpr{}", imlSegment->imlList[i].op_r_name.name-PPCREC_NAME_TEMPORARY_FPR0);
-			}
-			else
-				strOutput.add("ukn");
-			strOutput.addFmt(") = fpr_t{}", imlSegment->imlList[i].op_r_name.registerIndex);
-		}
-		else if( imlSegment->imlList[i].type == PPCREC_IML_TYPE_FPR_LOAD )
-		{
-			strOutput.addFmt("fpr_t{} = ", imlSegment->imlList[i].op_storeLoad.registerData);
-			if( imlSegment->imlList[i].op_storeLoad.flags2.signExtend )
-				strOutput.add("S");
-			else
-				strOutput.add("U");
-			strOutput.addFmt("{} [t{}+{}] mode {}", imlSegment->imlList[i].op_storeLoad.copyWidth / 8, imlSegment->imlList[i].op_storeLoad.registerMem, imlSegment->imlList[i].op_storeLoad.immS32, imlSegment->imlList[i].op_storeLoad.mode);
-			if (imlSegment->imlList[i].op_storeLoad.flags2.notExpanded)
-			{
-				strOutput.addFmt(" <No expand>");
-			}
-		}
-		else if( imlSegment->imlList[i].type == PPCREC_IML_TYPE_FPR_STORE )
-		{
-			if( imlSegment->imlList[i].op_storeLoad.flags2.signExtend )
-				strOutput.add("S");
-			else
-				strOutput.add("U");
-			strOutput.addFmt("{} [t{}+{}]", imlSegment->imlList[i].op_storeLoad.copyWidth/8, imlSegment->imlList[i].op_storeLoad.registerMem, imlSegment->imlList[i].op_storeLoad.immS32);
-			strOutput.addFmt("= fpr_t{} mode {}\n", imlSegment->imlList[i].op_storeLoad.registerData, imlSegment->imlList[i].op_storeLoad.mode);
-		}
-		else if( imlSegment->imlList[i].type == PPCREC_IML_TYPE_FPR_R_R )
-		{
-			strOutput.addFmt("{:-6} ", PPCRecompiler_getOpcodeDebugName(&imlSegment->imlList[i]));
-			strOutput.addFmt("fpr{:02d}, fpr{:02d}", imlSegment->imlList[i].op_fpr_r_r.registerResult, imlSegment->imlList[i].op_fpr_r_r.registerOperand);
-		}
-		else if( imlSegment->imlList[i].type == PPCREC_IML_TYPE_FPR_R_R_R_R )
-		{
-			strOutput.addFmt("{:-6} ", PPCRecompiler_getOpcodeDebugName(&imlSegment->imlList[i]));
-			strOutput.addFmt("fpr{:02d}, fpr{:02d}, fpr{:02d}, fpr{:02d}", imlSegment->imlList[i].op_fpr_r_r_r_r.registerResult, imlSegment->imlList[i].op_fpr_r_r_r_r.registerOperandA, imlSegment->imlList[i].op_fpr_r_r_r_r.registerOperandB, imlSegment->imlList[i].op_fpr_r_r_r_r.registerOperandC);
-		}
-		else if( imlSegment->imlList[i].type == PPCREC_IML_TYPE_FPR_R_R_R )
-		{
-			strOutput.addFmt("{:-6} ", PPCRecompiler_getOpcodeDebugName(&imlSegment->imlList[i]));
-			strOutput.addFmt("fpr{:02d}, fpr{:02d}, fpr{:02d}", imlSegment->imlList[i].op_fpr_r_r_r.registerResult, imlSegment->imlList[i].op_fpr_r_r_r.registerOperandA, imlSegment->imlList[i].op_fpr_r_r_r.registerOperandB);
-		}
-		else if (imlSegment->imlList[i].type == PPCREC_IML_TYPE_CJUMP_CYCLE_CHECK)
-		{
-			strOutput.addFmt("CYCLE_CHECK jm_{:08x}\n", imlSegment->imlList[i].op_conditionalJump.jumpmarkAddress);
-		}
-		else if (imlSegment->imlList[i].type == PPCREC_IML_TYPE_CONDITIONAL_R_S32)
-		{
-			strOutput.addFmt("t{} ", imlSegment->imlList[i].op_conditional_r_s32.registerIndex);
-			bool displayAsHex = false;
-			if (imlSegment->imlList[i].operation == PPCREC_IML_OP_ASSIGN)
-			{
-				displayAsHex = true;
-				strOutput.add("=");
-			}
-			else
-				strOutput.addFmt("(unknown operation CONDITIONAL_R_S32 {})", imlSegment->imlList[i].operation);
-			if (displayAsHex)
-				strOutput.addFmt(" 0x{:x}", imlSegment->imlList[i].op_conditional_r_s32.immS32);
-			else
-				strOutput.addFmt(" {}", imlSegment->imlList[i].op_conditional_r_s32.immS32);
-			strOutput.add(" (conditional)");
-			if (imlSegment->imlList[i].crRegister != PPC_REC_INVALID_REGISTER)
-			{
-				strOutput.addFmt(" -> and update CR{}", imlSegment->imlList[i].crRegister);
-			}
-		}
-		else
-		{
-		strOutput.addFmt("Unknown iml type {}", imlSegment->imlList[i].type);
-		}
-		debug_printf("%s", strOutput.c_str());
-		if (printLivenessRangeInfo)
-		{
-			PPCRecompilerDebug_printLivenessRangeInfo(strOutput, imlSegment, i);
-		}
-		debug_printf("\n");
-	}
-	// all ranges
-	if (printLivenessRangeInfo)
-	{
-		debug_printf("Ranges-VirtReg                                                        ");
-		raLivenessSubrange_t* subrangeItr = imlSegment->raInfo.linkedList_allSubranges;
-		while(subrangeItr)
-		{
-			debug_printf("v%-2d", subrangeItr->range->virtualRegister);
-			subrangeItr = subrangeItr->link_segmentSubrangesGPR.next;
-		}
-		debug_printf("\n");
-		debug_printf("Ranges-PhysReg                                                        ");
-		subrangeItr = imlSegment->raInfo.linkedList_allSubranges;
-		while (subrangeItr)
-		{
-			debug_printf("p%-2d", subrangeItr->range->physicalRegister);
-			subrangeItr = subrangeItr->link_segmentSubrangesGPR.next;
-		}
-		debug_printf("\n");
-	}
-	// branch info
-	debug_printf("Links from: ");
-	for (sint32 i = 0; i < imlSegment->list_prevSegments.size(); i++)
-	{
-		if (i)
-			debug_printf(", ");
-		debug_printf("%p", (void*)imlSegment->list_prevSegments[i]);
-	}
-	debug_printf("\n");
-	debug_printf("Links to: ");
-	if (imlSegment->nextSegmentBranchNotTaken)
-		debug_printf("%p (no branch), ", (void*)imlSegment->nextSegmentBranchNotTaken);
-	if (imlSegment->nextSegmentBranchTaken)
-		debug_printf("%p (branch)", (void*)imlSegment->nextSegmentBranchTaken);
-	debug_printf("\n");
-}
-
-void PPCRecompiler_dumpIML(PPCRecFunction_t* PPCRecFunction, ppcImlGenContext_t* ppcImlGenContext)
-{
-	for(sint32 f=0; f<ppcImlGenContext->segmentListCount; f++)
-	{
-		PPCRecImlSegment_t* imlSegment = ppcImlGenContext->segmentList[f];
-		PPCRecompiler_dumpIMLSegment(imlSegment, f);
-		debug_printf("\n");
-	}
-}
-
-void PPCRecompilerIml_setSegmentPoint(ppcRecompilerSegmentPoint_t* segmentPoint, PPCRecImlSegment_t* imlSegment, sint32 index)
+void PPCRecompilerIml_setSegmentPoint(IMLSegmentPoint* segmentPoint, IMLSegment* imlSegment, sint32 index)
 {
 	segmentPoint->imlSegment = imlSegment;
-	segmentPoint->index = index;
+	segmentPoint->SetInstructionIndex(index);
 	if (imlSegment->segmentPointList)
 		imlSegment->segmentPointList->prev = segmentPoint;
 	segmentPoint->prev = nullptr;
@@ -3469,7 +1869,7 @@ void PPCRecompilerIml_setSegmentPoint(ppcRecompilerSegmentPoint_t* segmentPoint,
 	imlSegment->segmentPointList = segmentPoint;
 }
 
-void PPCRecompilerIml_removeSegmentPoint(ppcRecompilerSegmentPoint_t* segmentPoint)
+void PPCRecompilerIml_removeSegmentPoint(IMLSegmentPoint* segmentPoint)
 {
 	if (segmentPoint->prev)
 		segmentPoint->prev->next = segmentPoint->next;
@@ -3481,147 +1881,60 @@ void PPCRecompilerIml_removeSegmentPoint(ppcRecompilerSegmentPoint_t* segmentPoi
 
 /*
 * Insert multiple no-op instructions
-* Warning: Can invalidate any previous instruction structs from the same segment
+* Warning: Can invalidate any previous instruction pointers from the same segment
 */
-void PPCRecompiler_pushBackIMLInstructions(PPCRecImlSegment_t* imlSegment, sint32 index, sint32 shiftBackCount)
+void PPCRecompiler_pushBackIMLInstructions(IMLSegment* imlSegment, sint32 index, sint32 shiftBackCount)
 {
-	cemu_assert(index >= 0 && index <= imlSegment->imlListCount);
+	cemu_assert_debug(index >= 0 && index <= imlSegment->imlList.size());
+
+	imlSegment->imlList.insert(imlSegment->imlList.begin() + index, shiftBackCount, {});
+
+	memset(imlSegment->imlList.data() + index, 0, sizeof(IMLInstruction) * shiftBackCount);
 
-	if (imlSegment->imlListCount + shiftBackCount > imlSegment->imlListSize)
-	{
-		sint32 newSize = imlSegment->imlListCount + shiftBackCount + std::max(2, imlSegment->imlListSize/2);
-		imlSegment->imlList = (PPCRecImlInstruction_t*)realloc(imlSegment->imlList, sizeof(PPCRecImlInstruction_t)*newSize);
-		imlSegment->imlListSize = newSize;
-	}
-	for (sint32 i = (sint32)imlSegment->imlListCount - 1; i >= index; i--)
-	{
-		memcpy(imlSegment->imlList + (i + shiftBackCount), imlSegment->imlList + i, sizeof(PPCRecImlInstruction_t));
-	}
 	// fill empty space with NOP instructions
 	for (sint32 i = 0; i < shiftBackCount; i++)
 	{
 		imlSegment->imlList[index + i].type = PPCREC_IML_TYPE_NONE;
 	}
-	imlSegment->imlListCount += shiftBackCount;
 
+	// update position of segment points
 	if (imlSegment->segmentPointList)
 	{
-		ppcRecompilerSegmentPoint_t* segmentPoint = imlSegment->segmentPointList;
+		IMLSegmentPoint* segmentPoint = imlSegment->segmentPointList;
 		while (segmentPoint)
 		{
-			if (segmentPoint->index != RA_INTER_RANGE_START && segmentPoint->index != RA_INTER_RANGE_END)
-			{
-				if (segmentPoint->index >= index)
-					segmentPoint->index += shiftBackCount;
-			}
-			// next
+			segmentPoint->ShiftIfAfter(index, shiftBackCount);
 			segmentPoint = segmentPoint->next;
 		}
 	}
 }
 
-/*
-* Insert and return new instruction at index
-* Warning: Can invalidate any previous instruction structs from the same segment
-*/
-PPCRecImlInstruction_t* PPCRecompiler_insertInstruction(PPCRecImlSegment_t* imlSegment, sint32 index)
+IMLInstruction* PPCRecompiler_insertInstruction(IMLSegment* imlSegment, sint32 index)
 {
 	PPCRecompiler_pushBackIMLInstructions(imlSegment, index, 1);
-	return imlSegment->imlList + index;
+	return imlSegment->imlList.data() + index;
 }
 
-/*
-* Append and return new instruction at the end of the segment
-* Warning: Can invalidate any previous instruction structs from the same segment
-*/
-PPCRecImlInstruction_t* PPCRecompiler_appendInstruction(PPCRecImlSegment_t* imlSegment)
+IMLInstruction* PPCRecompiler_appendInstruction(IMLSegment* imlSegment)
 {
-	sint32 index = imlSegment->imlListCount;
-	if (index >= imlSegment->imlListSize)
-	{
-		sint32 newSize = index+1;
-		imlSegment->imlList = (PPCRecImlInstruction_t*)realloc(imlSegment->imlList, sizeof(PPCRecImlInstruction_t)*newSize);
-		imlSegment->imlListSize = newSize;
-	}
-	imlSegment->imlListCount++;
-	memset(imlSegment->imlList + index, 0, sizeof(PPCRecImlInstruction_t));
-	return imlSegment->imlList + index;
+	size_t index = imlSegment->imlList.size();
+	imlSegment->imlList.emplace_back();
+	memset(imlSegment->imlList.data() + index, 0, sizeof(IMLInstruction));
+	return imlSegment->imlList.data() + index;
+}
+
+IMLSegment* PPCRecompilerIml_appendSegment(ppcImlGenContext_t* ppcImlGenContext)
+{
+	IMLSegment* segment = new IMLSegment();
+	ppcImlGenContext->segmentList2.emplace_back(segment);
+	return segment;
 }
 
 void PPCRecompilerIml_insertSegments(ppcImlGenContext_t* ppcImlGenContext, sint32 index, sint32 count)
 {
-	if( (ppcImlGenContext->segmentListCount+count) > ppcImlGenContext->segmentListSize )
-	{
-		// allocate space for more segments
-		ppcImlGenContext->segmentListSize += count;
-		ppcImlGenContext->segmentList = (PPCRecImlSegment_t**)realloc(ppcImlGenContext->segmentList, ppcImlGenContext->segmentListSize*sizeof(PPCRecImlSegment_t*));
-	}
-	for(sint32 i=(sint32)ppcImlGenContext->segmentListCount-1; i>=index; i--)
-	{
-		memcpy(ppcImlGenContext->segmentList+(i+count), ppcImlGenContext->segmentList+i, sizeof(PPCRecImlSegment_t*));
-	}
-	ppcImlGenContext->segmentListCount += count;
-	for(sint32 i=0; i<count; i++)
-	{
-		//memset(ppcImlGenContext->segmentList+index+i, 0x00, sizeof(PPCRecImlSegment_t*));
-		ppcImlGenContext->segmentList[index+i] = (PPCRecImlSegment_t*)malloc(sizeof(PPCRecImlSegment_t));
-		memset(ppcImlGenContext->segmentList[index+i], 0x00, sizeof(PPCRecImlSegment_t));
-		ppcImlGenContext->segmentList[index + i]->list_prevSegments = std::vector<PPCRecImlSegment_t*>();
-	}
-}
-
-/*
- * Allocate and init a new iml instruction segment
- */
-PPCRecImlSegment_t* PPCRecompiler_generateImlSegment(ppcImlGenContext_t* ppcImlGenContext)
-{
-	if( ppcImlGenContext->segmentListCount >= ppcImlGenContext->segmentListSize )
-	{
-		// allocate space for more segments
-		ppcImlGenContext->segmentListSize *= 2;
-		ppcImlGenContext->segmentList = (PPCRecImlSegment_t**)realloc(ppcImlGenContext->segmentList, ppcImlGenContext->segmentListSize*sizeof(PPCRecImlSegment_t*));
-	}
-	PPCRecImlSegment_t* ppcRecSegment = new PPCRecImlSegment_t();
-	ppcImlGenContext->segmentList[ppcImlGenContext->segmentListCount] = ppcRecSegment;
-	ppcImlGenContext->segmentListCount++;
-	return ppcRecSegment;
-}
-
-void PPCRecompiler_freeContext(ppcImlGenContext_t* ppcImlGenContext)
-{
-	if (ppcImlGenContext->imlList)
-	{
-		free(ppcImlGenContext->imlList);
-		ppcImlGenContext->imlList = nullptr;
-	}
-	for(sint32 i=0; i<ppcImlGenContext->segmentListCount; i++)
-	{
-		free(ppcImlGenContext->segmentList[i]->imlList);
-		delete ppcImlGenContext->segmentList[i];
-	}
-	ppcImlGenContext->segmentListCount = 0;
-	if (ppcImlGenContext->segmentList)
-	{
-		free(ppcImlGenContext->segmentList);
-		ppcImlGenContext->segmentList = nullptr;
-	}
-}
-
-bool PPCRecompiler_isSuffixInstruction(PPCRecImlInstruction_t* iml)
-{
-	if (iml->type == PPCREC_IML_TYPE_MACRO && (iml->operation == PPCREC_IML_MACRO_BLR || iml->operation == PPCREC_IML_MACRO_BCTR) ||
-		iml->type == PPCREC_IML_TYPE_MACRO && iml->operation == PPCREC_IML_MACRO_BL ||
-		iml->type == PPCREC_IML_TYPE_MACRO && iml->operation == PPCREC_IML_MACRO_B_FAR ||
-		iml->type == PPCREC_IML_TYPE_MACRO && iml->operation == PPCREC_IML_MACRO_BLRL ||
-		iml->type == PPCREC_IML_TYPE_MACRO && iml->operation == PPCREC_IML_MACRO_BCTRL ||
-		iml->type == PPCREC_IML_TYPE_MACRO && iml->operation == PPCREC_IML_MACRO_LEAVE ||
-		iml->type == PPCREC_IML_TYPE_MACRO && iml->operation == PPCREC_IML_MACRO_HLE ||
-		iml->type == PPCREC_IML_TYPE_MACRO && iml->operation == PPCREC_IML_MACRO_MFTB ||
-		iml->type == PPCREC_IML_TYPE_PPC_ENTER ||
-		iml->type == PPCREC_IML_TYPE_CJUMP ||
-		iml->type == PPCREC_IML_TYPE_CJUMP_CYCLE_CHECK)
-		return true;
-	return false;
+	ppcImlGenContext->segmentList2.insert(ppcImlGenContext->segmentList2.begin() + index, count, nullptr);
+	for (sint32 i = 0; i < count; i++)
+		ppcImlGenContext->segmentList2[index + i] = new IMLSegment();
 }
 
 bool PPCRecompiler_decodePPCInstruction(ppcImlGenContext_t* ppcImlGenContext)
@@ -3643,15 +1956,18 @@ bool PPCRecompiler_decodePPCInstruction(ppcImlGenContext_t* ppcImlGenContext)
 			switch (PPC_getBits(opcode, 25, 5))
 			{
 			case 0:
-				PPCRecompilerImlGen_PS_CMPU0(ppcImlGenContext, opcode);
+				if( !PPCRecompilerImlGen_PS_CMPU0(ppcImlGenContext, opcode) )
+					unsupportedInstructionFound = true;
 				ppcImlGenContext->hasFPUInstruction = true;
 				break;
 			case 1:
-				PPCRecompilerImlGen_PS_CMPO0(ppcImlGenContext, opcode);
+				if( !PPCRecompilerImlGen_PS_CMPO0(ppcImlGenContext, opcode) )
+					unsupportedInstructionFound = true;
 				ppcImlGenContext->hasFPUInstruction = true;
 				break;
 			case 2:
-				PPCRecompilerImlGen_PS_CMPU1(ppcImlGenContext, opcode);
+				if( !PPCRecompilerImlGen_PS_CMPU1(ppcImlGenContext, opcode) )
+					unsupportedInstructionFound = true;
 				ppcImlGenContext->hasFPUInstruction = true;
 				break;
 			default:
@@ -3692,23 +2008,23 @@ bool PPCRecompiler_decodePPCInstruction(ppcImlGenContext_t* ppcImlGenContext)
 				unsupportedInstructionFound = true;
 			ppcImlGenContext->hasFPUInstruction = true;
 			break;
-		case 12: // multiply scalar
-			if (PPCRecompilerImlGen_PS_MULS0(ppcImlGenContext, opcode) == false)
+		case 12: // PS_MULS0
+			if (PPCRecompilerImlGen_PS_MULSX(ppcImlGenContext, opcode, false) == false)
 				unsupportedInstructionFound = true;
 			ppcImlGenContext->hasFPUInstruction = true;
 			break;
-		case 13: // multiply scalar
-			if (PPCRecompilerImlGen_PS_MULS1(ppcImlGenContext, opcode) == false)
+		case 13: // PS_MULS1
+			if (PPCRecompilerImlGen_PS_MULSX(ppcImlGenContext, opcode, true) == false)
 				unsupportedInstructionFound = true;
 			ppcImlGenContext->hasFPUInstruction = true;
 			break;
-		case 14: // multiply add scalar
-			if (PPCRecompilerImlGen_PS_MADDS0(ppcImlGenContext, opcode) == false)
+		case 14: // PS_MADDS0
+			if (PPCRecompilerImlGen_PS_MADDSX(ppcImlGenContext, opcode, false) == false)
 				unsupportedInstructionFound = true;
 			ppcImlGenContext->hasFPUInstruction = true;
 			break;
-		case 15: // multiply add scalar
-			if (PPCRecompilerImlGen_PS_MADDS1(ppcImlGenContext, opcode) == false)
+		case 15: // PS_MADDS1
+			if (PPCRecompilerImlGen_PS_MADDSX(ppcImlGenContext, opcode, true) == false)
 				unsupportedInstructionFound = true;
 			ppcImlGenContext->hasFPUInstruction = true;
 			break;
@@ -3775,22 +2091,22 @@ bool PPCRecompiler_decodePPCInstruction(ppcImlGenContext_t* ppcImlGenContext)
 				unsupportedInstructionFound = true;
 			ppcImlGenContext->hasFPUInstruction = true;
 			break;
-		case 28: // multiply sub paired
-			if (PPCRecompilerImlGen_PS_MSUB(ppcImlGenContext, opcode) == false)
+		case 28: // PS_MSUB
+			if (PPCRecompilerImlGen_PS_MSUB(ppcImlGenContext, opcode, false) == false)
 				unsupportedInstructionFound = true;
 			ppcImlGenContext->hasFPUInstruction = true;
 			break;
-		case 29: // multiply add paired
+		case 29: // PS_MADD
 			if (PPCRecompilerImlGen_PS_MADD(ppcImlGenContext, opcode) == false)
 				unsupportedInstructionFound = true;
 			ppcImlGenContext->hasFPUInstruction = true;
 			break;
-		case 30: // negative multiply sub paired
-			if (PPCRecompilerImlGen_PS_NMSUB(ppcImlGenContext, opcode) == false)
+		case 30: // PS_NMSUB
+			if (PPCRecompilerImlGen_PS_MSUB(ppcImlGenContext, opcode, true) == false)
 				unsupportedInstructionFound = true;
 			ppcImlGenContext->hasFPUInstruction = true;
 			break;
-		case 31: // negative multiply add paired
+		case 31: // PS_NMADD
 			if (PPCRecompilerImlGen_PS_NMADD(ppcImlGenContext, opcode) == false)
 				unsupportedInstructionFound = true;
 			ppcImlGenContext->hasFPUInstruction = true;
@@ -3804,20 +2120,23 @@ bool PPCRecompiler_decodePPCInstruction(ppcImlGenContext_t* ppcImlGenContext)
 		PPCRecompilerImlGen_MULLI(ppcImlGenContext, opcode);
 		break;
 	case 8: // SUBFIC
-		PPCRecompilerImlGen_SUBFIC(ppcImlGenContext, opcode);
+		if (!PPCRecompilerImlGen_SUBFIC(ppcImlGenContext, opcode))
+			unsupportedInstructionFound = true;
 		break;
 	case 10: // CMPLI
-		PPCRecompilerImlGen_CMPLI(ppcImlGenContext, opcode);
+		if (!PPCRecompilerImlGen_CMPI(ppcImlGenContext, opcode, true))
+			unsupportedInstructionFound = true;
 		break;
 	case 11: // CMPI
-		PPCRecompilerImlGen_CMPI(ppcImlGenContext, opcode);
+		if (!PPCRecompilerImlGen_CMPI(ppcImlGenContext, opcode, false))
+			unsupportedInstructionFound = true;
 		break;
 	case 12: // ADDIC
-		if (PPCRecompilerImlGen_ADDIC(ppcImlGenContext, opcode) == false)
+		if (PPCRecompilerImlGen_ADDIC_(ppcImlGenContext, opcode, false) == false)
 			unsupportedInstructionFound = true;
 		break;
 	case 13: // ADDIC.
-		if (PPCRecompilerImlGen_ADDIC_(ppcImlGenContext, opcode) == false)
+		if (PPCRecompilerImlGen_ADDIC_(ppcImlGenContext, opcode, true) == false)
 			unsupportedInstructionFound = true;
 		break;
 	case 14: // ADDI
@@ -3849,8 +2168,11 @@ bool PPCRecompiler_decodePPCInstruction(ppcImlGenContext_t* ppcImlGenContext)
 	case 19: // opcode category 19
 		switch (PPC_getBits(opcode, 30, 10))
 		{
-		case 16:
-			if (PPCRecompilerImlGen_BCLR(ppcImlGenContext, opcode) == false)
+		case 0:
+			PPCRecompilerImlGen_MCRF(ppcImlGenContext, opcode);
+			break;
+		case 16: // BCLR
+			if (PPCRecompilerImlGen_BCSPR(ppcImlGenContext, opcode, SPR_LR) == false)
 				unsupportedInstructionFound = true;
 			break;
 		case 129:
@@ -3881,8 +2203,8 @@ bool PPCRecompiler_decodePPCInstruction(ppcImlGenContext_t* ppcImlGenContext)
 			if (PPCRecompilerImlGen_CROR(ppcImlGenContext, opcode) == false)
 				unsupportedInstructionFound = true;
 			break;
-		case 528:
-			if (PPCRecompilerImlGen_BCCTR(ppcImlGenContext, opcode) == false)
+		case 528: // BCCTR
+			if (PPCRecompilerImlGen_BCSPR(ppcImlGenContext, opcode, SPR_CTR) == false)
 				unsupportedInstructionFound = true;
 			break;
 		default:
@@ -3902,37 +2224,34 @@ bool PPCRecompiler_decodePPCInstruction(ppcImlGenContext_t* ppcImlGenContext)
 		if (PPCRecompilerImlGen_RLWNM(ppcImlGenContext, opcode) == false)
 			unsupportedInstructionFound = true;
 		break;
-	case 24:
-		PPCRecompilerImlGen_ORI(ppcImlGenContext, opcode);
+	case 24: // ORI
+		PPCRecompilerImlGen_ORI_ORIS(ppcImlGenContext, opcode, false);
 		break;
-	case 25:
-		PPCRecompilerImlGen_ORIS(ppcImlGenContext, opcode);
+	case 25: // ORIS
+		PPCRecompilerImlGen_ORI_ORIS(ppcImlGenContext, opcode, true);
 		break;
-	case 26:
-		PPCRecompilerImlGen_XORI(ppcImlGenContext, opcode);
+	case 26: // XORI
+		PPCRecompilerImlGen_XORI_XORIS(ppcImlGenContext, opcode, false);
 		break;
-	case 27:
-		PPCRecompilerImlGen_XORIS(ppcImlGenContext, opcode);
+	case 27: // XORIS
+		PPCRecompilerImlGen_XORI_XORIS(ppcImlGenContext, opcode, true);
 		break;
-	case 28:
-		PPCRecompilerImlGen_ANDI(ppcImlGenContext, opcode);
+	case 28: // ANDI
+		PPCRecompilerImlGen_ANDI_ANDIS(ppcImlGenContext, opcode, false);
 		break;
-	case 29:
-		PPCRecompilerImlGen_ANDIS(ppcImlGenContext, opcode);
+	case 29: // ANDIS
+		PPCRecompilerImlGen_ANDI_ANDIS(ppcImlGenContext, opcode, true);
 		break;
 	case 31: // opcode category
 		switch (PPC_getBits(opcode, 30, 10))
 		{
 		case 0:
-			PPCRecompilerImlGen_CMP(ppcImlGenContext, opcode);
+			PPCRecompilerImlGen_CMP(ppcImlGenContext, opcode, false);
 			break;
 		case 4:
 			PPCRecompilerImlGen_TW(ppcImlGenContext, opcode);
 			break;
 		case 8:
-		// todo: Check if we can optimize this pattern:
-		// SUBFC + SUBFE 			
-		// SUBFC
 		if (PPCRecompilerImlGen_SUBFC(ppcImlGenContext, opcode) == false)
 			unsupportedInstructionFound = true;
 		break;
@@ -3952,9 +2271,8 @@ bool PPCRecompiler_decodePPCInstruction(ppcImlGenContext_t* ppcImlGenContext)
 			if (PPCRecompilerImlGen_LWARX(ppcImlGenContext, opcode) == false)
 				unsupportedInstructionFound = true;
 			break;
-		case 23:
-			if (PPCRecompilerImlGen_LWZX(ppcImlGenContext, opcode) == false)
-				unsupportedInstructionFound = true;
+		case 23: // LWZX
+			PPCRecompilerImlGen_LOAD_INDEXED(ppcImlGenContext, opcode, 32, false, true, false);
 			break;
 		case 24:
 			if (PPCRecompilerImlGen_SLW(ppcImlGenContext, opcode) == false)
@@ -3964,12 +2282,12 @@ bool PPCRecompiler_decodePPCInstruction(ppcImlGenContext_t* ppcImlGenContext)
 			if (PPCRecompilerImlGen_CNTLZW(ppcImlGenContext, opcode) == false)
 				unsupportedInstructionFound = true;
 			break;
-		case 28:
-			if (PPCRecompilerImlGen_AND(ppcImlGenContext, opcode) == false)
+		case 28: // AND
+			if (!PPCRecompilerImlGen_AND_NAND(ppcImlGenContext, opcode, false))
 				unsupportedInstructionFound = true;
 			break;
 		case 32:
-			PPCRecompilerImlGen_CMPL(ppcImlGenContext, opcode);
+			PPCRecompilerImlGen_CMP(ppcImlGenContext, opcode, true); // CMPL
 			break;
 		case 40:
 			if (PPCRecompilerImlGen_SUBF(ppcImlGenContext, opcode) == false)
@@ -3978,12 +2296,11 @@ bool PPCRecompiler_decodePPCInstruction(ppcImlGenContext_t* ppcImlGenContext)
 		case 54:
 			// DBCST - Generates no code
 			break;
-		case 55:
-			if (PPCRecompilerImlGen_LWZUX(ppcImlGenContext, opcode) == false)
-				unsupportedInstructionFound = true;
+		case 55: // LWZUX
+			PPCRecompilerImlGen_LOAD_INDEXED(ppcImlGenContext, opcode, 32, false, true, true);
 			break;
-		case 60:
-			if (PPCRecompilerImlGen_ANDC(ppcImlGenContext, opcode) == false)
+		case 60: // ANDC
+			if (!PPCRecompilerImlGen_ANDC(ppcImlGenContext, opcode))
 				unsupportedInstructionFound = true;
 			break;
 		case 75:
@@ -3993,20 +2310,18 @@ bool PPCRecompiler_decodePPCInstruction(ppcImlGenContext_t* ppcImlGenContext)
 		case 86:
 			// DCBF -> No-Op
 			break;
-		case 87:
-			if (PPCRecompilerImlGen_LBZX(ppcImlGenContext, opcode) == false)
-				unsupportedInstructionFound = true;
+		case 87: // LBZX
+			PPCRecompilerImlGen_LOAD_INDEXED(ppcImlGenContext, opcode, 8, false, true, false);
 			break;
 		case 104:
 			if (PPCRecompilerImlGen_NEG(ppcImlGenContext, opcode) == false)
 				unsupportedInstructionFound = true;
 			break;
-		case 119:
-			if (PPCRecompilerImlGen_LBZUX(ppcImlGenContext, opcode) == false)
-				unsupportedInstructionFound = true;
+		case 119: // LBZUX
+			PPCRecompilerImlGen_LOAD_INDEXED(ppcImlGenContext, opcode, 8, false, true, true);
 			break;
-		case 124:
-			if (PPCRecompilerImlGen_NOR(ppcImlGenContext, opcode) == false)
+		case 124: // NOR
+			if (!PPCRecompilerImlGen_OR_NOR(ppcImlGenContext, opcode, true))
 				unsupportedInstructionFound = true;
 			break;
 		case 136:
@@ -4018,19 +2333,20 @@ bool PPCRecompiler_decodePPCInstruction(ppcImlGenContext_t* ppcImlGenContext)
 				unsupportedInstructionFound = true;
 			break;
 		case 144:
-			PPCRecompilerImlGen_MTCRF(ppcImlGenContext, opcode);
+			if( !PPCRecompilerImlGen_MTCRF(ppcImlGenContext, opcode))
+				unsupportedInstructionFound = true;
 			break;
 		case 150:
-			if (PPCRecompilerImlGen_STWCX(ppcImlGenContext, opcode) == false)
+			if (!PPCRecompilerImlGen_STWCX(ppcImlGenContext, opcode))
 				unsupportedInstructionFound = true;
 			break;
-		case 151:
-			if (PPCRecompilerImlGen_STORE_INDEXED(ppcImlGenContext, opcode, 32) == false)
+		case 151: // STWX
+			if (!PPCRecompilerImlGen_STORE_INDEXED(ppcImlGenContext, opcode, 32, true, false))
 				unsupportedInstructionFound = true;
 			break;
-		case 183:
-			if (PPCRecompilerImlGen_STORE_INDEXED_UPDATE(ppcImlGenContext, opcode, 32) == false)
-				unsupportedInstructionFound = true;
+		case 183: // STWUX
+			if (!PPCRecompilerImlGen_STORE_INDEXED(ppcImlGenContext, opcode, 32, true, true))
+				unsupportedInstructionFound = true;			
 			break;
 		case 200:
 			if (PPCRecompilerImlGen_SUBFZE(ppcImlGenContext, opcode) == false)
@@ -4040,8 +2356,8 @@ bool PPCRecompiler_decodePPCInstruction(ppcImlGenContext_t* ppcImlGenContext)
 			if (PPCRecompilerImlGen_ADDZE(ppcImlGenContext, opcode) == false)
 				unsupportedInstructionFound = true;
 			break;
-		case 215:
-			if (PPCRecompilerImlGen_STORE_INDEXED(ppcImlGenContext, opcode, 8) == false)
+		case 215: // STBX
+			if (!PPCRecompilerImlGen_STORE_INDEXED(ppcImlGenContext, opcode, 8, true, false))
 				unsupportedInstructionFound = true;
 			break;
 		case 234:
@@ -4052,59 +2368,56 @@ bool PPCRecompiler_decodePPCInstruction(ppcImlGenContext_t* ppcImlGenContext)
 			if (PPCRecompilerImlGen_MULLW(ppcImlGenContext, opcode) == false)
 				unsupportedInstructionFound = true;
 			break;
-		case 247:
-			if (PPCRecompilerImlGen_STORE_INDEXED_UPDATE(ppcImlGenContext, opcode, 8) == false)
+		case 247: // STBUX
+			if (!PPCRecompilerImlGen_STORE_INDEXED(ppcImlGenContext, opcode, 8, true, true))
 				unsupportedInstructionFound = true;
 			break;
 		case 266:
 			if (PPCRecompilerImlGen_ADD(ppcImlGenContext, opcode) == false)
 				unsupportedInstructionFound = true;
 			break;
-		case 279:
-			if (PPCRecompilerImlGen_LHZX(ppcImlGenContext, opcode) == false)
+		case 279: // LHZX
+			PPCRecompilerImlGen_LOAD_INDEXED(ppcImlGenContext, opcode, 16, false, true, false);
+			break;
+		case 284: // EQV (alias to NXOR)
+			if (!PPCRecompilerImlGen_XOR(ppcImlGenContext, opcode, true))
 				unsupportedInstructionFound = true;
 			break;
-		case 284:
-			PPCRecompilerImlGen_EQV(ppcImlGenContext, opcode);
+		case 311: // LHZUX
+			PPCRecompilerImlGen_LOAD_INDEXED(ppcImlGenContext, opcode, 16, false, true, true);
 			break;
-		case 311:
-			if (PPCRecompilerImlGen_LHZUX(ppcImlGenContext, opcode) == false)
-				unsupportedInstructionFound = true;
-			break;
-		case 316:
-			if (PPCRecompilerImlGen_XOR(ppcImlGenContext, opcode) == false)
+		case 316: // XOR
+			if (!PPCRecompilerImlGen_XOR(ppcImlGenContext, opcode, false))
 				unsupportedInstructionFound = true;
 			break;
 		case 339:
 			if (PPCRecompilerImlGen_MFSPR(ppcImlGenContext, opcode) == false)
 				unsupportedInstructionFound = true;
 			break;
-		case 343:
-			if (PPCRecompilerImlGen_LHAX(ppcImlGenContext, opcode) == false)
-				unsupportedInstructionFound = true;
+		case 343: // LHAX
+			PPCRecompilerImlGen_LOAD_INDEXED(ppcImlGenContext, opcode, 16, true, true, false);
 			break;
 		case 371:
 			if (PPCRecompilerImlGen_MFTB(ppcImlGenContext, opcode) == false)
 				unsupportedInstructionFound = true;
 			break;
-		case 375:
-			if (PPCRecompilerImlGen_LHAUX(ppcImlGenContext, opcode) == false)
-				unsupportedInstructionFound = true;
+		case 375: // LHAUX
+			PPCRecompilerImlGen_LOAD_INDEXED(ppcImlGenContext, opcode, 16, true, true, true);
 			break;
-		case 407:
-			if (PPCRecompilerImlGen_STORE_INDEXED(ppcImlGenContext, opcode, 16) == false)
+		case 407: // STHX
+			if (!PPCRecompilerImlGen_STORE_INDEXED(ppcImlGenContext, opcode, 16, true, false))
 				unsupportedInstructionFound = true;
 			break;
 		case 412:
 			if (PPCRecompilerImlGen_ORC(ppcImlGenContext, opcode) == false)
 				unsupportedInstructionFound = true;
 			break;
-		case 439:
-			if (PPCRecompilerImlGen_STORE_INDEXED_UPDATE(ppcImlGenContext, opcode, 16) == false)
+		case 439: // STHUX
+			if (!PPCRecompilerImlGen_STORE_INDEXED(ppcImlGenContext, opcode, 16, true, true))
 				unsupportedInstructionFound = true;
 			break;
-		case 444:
-			if (PPCRecompilerImlGen_OR(ppcImlGenContext, opcode) == false)
+		case 444: // OR
+			if (!PPCRecompilerImlGen_OR_NOR(ppcImlGenContext, opcode, false))
 				unsupportedInstructionFound = true;
 			break;
 		case 459:
@@ -4114,17 +2427,19 @@ bool PPCRecompiler_decodePPCInstruction(ppcImlGenContext_t* ppcImlGenContext)
 			if (PPCRecompilerImlGen_MTSPR(ppcImlGenContext, opcode) == false)
 				unsupportedInstructionFound = true;
 			break;
+		case 476: // NAND
+			if (!PPCRecompilerImlGen_AND_NAND(ppcImlGenContext, opcode, true))
+				unsupportedInstructionFound = true;
+			break;
 		case 491:
 			if (PPCRecompilerImlGen_DIVW(ppcImlGenContext, opcode) == false)
 				unsupportedInstructionFound = true;
 			break;
-		case 534:
-			if (PPCRecompilerImlGen_LWBRX(ppcImlGenContext, opcode) == false)
-				unsupportedInstructionFound = true;
-			ppcImlGenContext->hasFPUInstruction = true;
+		case 534: // LWBRX
+			PPCRecompilerImlGen_LOAD_INDEXED(ppcImlGenContext, opcode, 32, false, false, false);
 			break;
-		case 535:
-			if (PPCRecompilerImlGen_LFSX(ppcImlGenContext, opcode) == false)
+		case 535: // LFSX
+			if (PPCRecompilerImlGen_LFSX_LFSUX_LFDX_LFDUX(ppcImlGenContext, opcode, false, false) == false)
 				unsupportedInstructionFound = true;
 			ppcImlGenContext->hasFPUInstruction = true;
 			break;
@@ -4132,8 +2447,8 @@ bool PPCRecompiler_decodePPCInstruction(ppcImlGenContext_t* ppcImlGenContext)
 			if (PPCRecompilerImlGen_SRW(ppcImlGenContext, opcode) == false)
 				unsupportedInstructionFound = true;
 			break;
-		case 567:
-			if (PPCRecompilerImlGen_LFSUX(ppcImlGenContext, opcode) == false)
+		case 567: // LFSUX
+			if (PPCRecompilerImlGen_LFSX_LFSUX_LFDX_LFDUX(ppcImlGenContext, opcode, true, false) == false)
 				unsupportedInstructionFound = true;
 			ppcImlGenContext->hasFPUInstruction = true;
 			break;
@@ -4144,38 +2459,42 @@ bool PPCRecompiler_decodePPCInstruction(ppcImlGenContext_t* ppcImlGenContext)
 		case 598:
 			PPCRecompilerImlGen_SYNC(ppcImlGenContext, opcode);
 			break;
-		case 599:
-			if (PPCRecompilerImlGen_LFDX(ppcImlGenContext, opcode) == false)
+		case 599: // LFDX
+			if (PPCRecompilerImlGen_LFSX_LFSUX_LFDX_LFDUX(ppcImlGenContext, opcode, false, true) == false)
 				unsupportedInstructionFound = true;
 			ppcImlGenContext->hasFPUInstruction = true;
 			break;
-		case 631:
-			if (PPCRecompilerImlGen_LFDUX(ppcImlGenContext, opcode) == false)
+		case 631: // LFDUX
+			if (PPCRecompilerImlGen_LFSX_LFSUX_LFDX_LFDUX(ppcImlGenContext, opcode, true, true) == false)
 				unsupportedInstructionFound = true;
 			ppcImlGenContext->hasFPUInstruction = true;
 			break;
-		case 662:
-			if (PPCRecompilerImlGen_STWBRX(ppcImlGenContext, opcode) == false)
+		case 662: // STWBRX
+			if (!PPCRecompilerImlGen_STORE_INDEXED(ppcImlGenContext, opcode, 32, false, false))
 				unsupportedInstructionFound = true;
 			break;
-		case 663:
-			if (PPCRecompilerImlGen_STFSX(ppcImlGenContext, opcode) == false)
+		case 663: // STFSX
+			if (PPCRecompilerImlGen_STFSX_STFSUX_STFDX_STFDUX(ppcImlGenContext, opcode, false, false) == false)
 				unsupportedInstructionFound = true;
 			break;
-		case 695:
-			if (PPCRecompilerImlGen_STFSUX(ppcImlGenContext, opcode) == false)
+		case 695: // STFSUX
+			if (PPCRecompilerImlGen_STFSX_STFSUX_STFDX_STFDUX(ppcImlGenContext, opcode, true, false) == false)
 				unsupportedInstructionFound = true;
 			break;
 		case 725:
 			if (PPCRecompilerImlGen_STSWI(ppcImlGenContext, opcode) == false)
 				unsupportedInstructionFound = true;
 			break;
-		case 727:
-			if (PPCRecompilerImlGen_STFDX(ppcImlGenContext, opcode) == false)
+		case 727: // STFDX
+			if (PPCRecompilerImlGen_STFSX_STFSUX_STFDX_STFDUX(ppcImlGenContext, opcode, false, true) == false)
 				unsupportedInstructionFound = true;
 			break;
-		case 790:
-			PPCRecompilerImlGen_LHBRX(ppcImlGenContext, opcode);
+		case 759: // STFDUX
+			if (PPCRecompilerImlGen_STFSX_STFSUX_STFDX_STFDUX(ppcImlGenContext, opcode, true, true) == false)
+				unsupportedInstructionFound = true;
+			break;
+		case 790: // LHBRX
+			PPCRecompilerImlGen_LOAD_INDEXED(ppcImlGenContext, opcode, 16, false, false, false);
 			break;
 		case 792:
 			if (PPCRecompilerImlGen_SRAW(ppcImlGenContext, opcode) == false)
@@ -4186,7 +2505,7 @@ bool PPCRecompiler_decodePPCInstruction(ppcImlGenContext_t* ppcImlGenContext)
 				unsupportedInstructionFound = true;
 			break;
 		case 918: // STHBRX
-			if (PPCRecompilerImlGen_STORE_INDEXED(ppcImlGenContext, opcode, 16, true) == false)
+			if (!PPCRecompilerImlGen_STORE_INDEXED(ppcImlGenContext, opcode, 16, false, true))
 				unsupportedInstructionFound = true;
 			break;
 		case 922:
@@ -4210,47 +2529,61 @@ bool PPCRecompiler_decodePPCInstruction(ppcImlGenContext_t* ppcImlGenContext)
 			break;
 		}
 		break;
-	case 32:
-		PPCRecompilerImlGen_LWZ(ppcImlGenContext, opcode);
+	case 32: // LWZ
+		if(!PPCRecompilerImlGen_LOAD(ppcImlGenContext, opcode, 32, false, true, false))
+			unsupportedInstructionFound = true;
 		break;
-	case 33:
-		PPCRecompilerImlGen_LWZU(ppcImlGenContext, opcode);
+	case 33: // LWZU
+		if (!PPCRecompilerImlGen_LOAD(ppcImlGenContext, opcode, 32, false, true, true))
+			unsupportedInstructionFound = true;
 		break;
-	case 34:
-		PPCRecompilerImlGen_LBZ(ppcImlGenContext, opcode);
+	case 34: // LBZ
+		if (!PPCRecompilerImlGen_LOAD(ppcImlGenContext, opcode, 8, false, true, false))
+			unsupportedInstructionFound = true;
 		break;
-	case 35:
-		PPCRecompilerImlGen_LBZU(ppcImlGenContext, opcode);
+	case 35: // LBZU
+		if (!PPCRecompilerImlGen_LOAD(ppcImlGenContext, opcode, 8, false, true, true))
+			unsupportedInstructionFound = true;
 		break;
-	case 36:
-		PPCRecompilerImlGen_STW(ppcImlGenContext, opcode);
+	case 36: // STW
+		if(!PPCRecompilerImlGen_STORE(ppcImlGenContext, opcode, 32, true, false))
+			unsupportedInstructionFound = true;
 		break;
-	case 37:
-		PPCRecompilerImlGen_STWU(ppcImlGenContext, opcode);
+	case 37: // STWU
+		if (!PPCRecompilerImlGen_STORE(ppcImlGenContext, opcode, 32, true, true))
+			unsupportedInstructionFound = true;
 		break;
-	case 38:
-		PPCRecompilerImlGen_STB(ppcImlGenContext, opcode);
+	case 38: // STB
+		if (!PPCRecompilerImlGen_STORE(ppcImlGenContext, opcode, 8, true, false))
+			unsupportedInstructionFound = true;
 		break;
-	case 39:
-		PPCRecompilerImlGen_STBU(ppcImlGenContext, opcode);
+	case 39: // STBU
+		if (!PPCRecompilerImlGen_STORE(ppcImlGenContext, opcode, 8, true, true))
+			unsupportedInstructionFound = true;
 		break;
-	case 40:
-		PPCRecompilerImlGen_LHZ(ppcImlGenContext, opcode);
+	case 40: // LHZ
+		if (!PPCRecompilerImlGen_LOAD(ppcImlGenContext, opcode, 16, false, true, false))
+			unsupportedInstructionFound = true;
 		break;
-	case 41:
-		PPCRecompilerImlGen_LHZU(ppcImlGenContext, opcode);
+	case 41: // LHZU
+		if (!PPCRecompilerImlGen_LOAD(ppcImlGenContext, opcode, 16, false, true, true))
+			unsupportedInstructionFound = true;
 		break;
-	case 42:
-		PPCRecompilerImlGen_LHA(ppcImlGenContext, opcode);
+	case 42: // LHA
+		if (!PPCRecompilerImlGen_LOAD(ppcImlGenContext, opcode, 16, true, true, false))
+			unsupportedInstructionFound = true;
 		break;
-	case 43:
-		PPCRecompilerImlGen_LHAU(ppcImlGenContext, opcode);
+	case 43: // LHAU
+		if (!PPCRecompilerImlGen_LOAD(ppcImlGenContext, opcode, 16, true, true, true))
+			unsupportedInstructionFound = true;
 		break;
-	case 44:
-		PPCRecompilerImlGen_STH(ppcImlGenContext, opcode);
+	case 44: // STH
+		if (!PPCRecompilerImlGen_STORE(ppcImlGenContext, opcode, 16, true, false))
+			unsupportedInstructionFound = true;
 		break;
-	case 45:
-		PPCRecompilerImlGen_STHU(ppcImlGenContext, opcode);
+	case 45: // STHU
+		if (!PPCRecompilerImlGen_STORE(ppcImlGenContext, opcode, 16, true, true))
+			unsupportedInstructionFound = true;
 		break;
 	case 46:
 		PPCRecompilerImlGen_LMW(ppcImlGenContext, opcode);
@@ -4258,53 +2591,53 @@ bool PPCRecompiler_decodePPCInstruction(ppcImlGenContext_t* ppcImlGenContext)
 	case 47:
 		PPCRecompilerImlGen_STMW(ppcImlGenContext, opcode);
 		break;
-	case 48:
-		if (PPCRecompilerImlGen_LFS(ppcImlGenContext, opcode) == false)
+	case 48: // LFS
+		if (PPCRecompilerImlGen_LFS_LFSU_LFD_LFDU(ppcImlGenContext, opcode, false, false) == false)
 			unsupportedInstructionFound = true;
 		ppcImlGenContext->hasFPUInstruction = true;
 		break;
-	case 49:
-		if (PPCRecompilerImlGen_LFSU(ppcImlGenContext, opcode) == false)
+	case 49: // LFSU
+		if (PPCRecompilerImlGen_LFS_LFSU_LFD_LFDU(ppcImlGenContext, opcode, true, false) == false)
 			unsupportedInstructionFound = true;
 		ppcImlGenContext->hasFPUInstruction = true;
 		break;
-	case 50:
-		if (PPCRecompilerImlGen_LFD(ppcImlGenContext, opcode) == false)
+	case 50: // LFD
+		if (PPCRecompilerImlGen_LFS_LFSU_LFD_LFDU(ppcImlGenContext, opcode, false, true) == false)
 			unsupportedInstructionFound = true;
 		ppcImlGenContext->hasFPUInstruction = true;
 		break;
-	case 51:
-		if (PPCRecompilerImlGen_LFDU(ppcImlGenContext, opcode) == false)
+	case 51: // LFDU
+		if (PPCRecompilerImlGen_LFS_LFSU_LFD_LFDU(ppcImlGenContext, opcode, true, true) == false)
 			unsupportedInstructionFound = true;
 		ppcImlGenContext->hasFPUInstruction = true;
 		break;
-	case 52:
-		if (PPCRecompilerImlGen_STFS(ppcImlGenContext, opcode) == false)
+	case 52: // STFS
+		if (PPCRecompilerImlGen_STFS_STFSU_STFD_STFDU(ppcImlGenContext, opcode, false, false) == false)
 			unsupportedInstructionFound = true;
 		ppcImlGenContext->hasFPUInstruction = true;
 		break;
-	case 53:
-		if (PPCRecompilerImlGen_STFSU(ppcImlGenContext, opcode) == false)
+	case 53: // STFSU
+		if (PPCRecompilerImlGen_STFS_STFSU_STFD_STFDU(ppcImlGenContext, opcode, true, false) == false)
 			unsupportedInstructionFound = true;
 		ppcImlGenContext->hasFPUInstruction = true;
 		break;
-	case 54:
-		if (PPCRecompilerImlGen_STFD(ppcImlGenContext, opcode) == false)
+	case 54: // STFD
+		if (PPCRecompilerImlGen_STFS_STFSU_STFD_STFDU(ppcImlGenContext, opcode, false, true) == false)
 			unsupportedInstructionFound = true;
 		ppcImlGenContext->hasFPUInstruction = true;
 		break;
-	case 55:
-		if (PPCRecompilerImlGen_STFDU(ppcImlGenContext, opcode) == false)
+	case 55: // STFDU
+		if (PPCRecompilerImlGen_STFS_STFSU_STFD_STFDU(ppcImlGenContext, opcode, true, true) == false)
 			unsupportedInstructionFound = true;
 		ppcImlGenContext->hasFPUInstruction = true;
 		break;
 	case 56:
-		if (PPCRecompilerImlGen_PSQ_L(ppcImlGenContext, opcode) == false)
+		if (PPCRecompilerImlGen_PSQ_L(ppcImlGenContext, opcode, false) == false)
 			unsupportedInstructionFound = true;
 		ppcImlGenContext->hasFPUInstruction = true;
 		break;
 	case 57:
-		if (PPCRecompilerImlGen_PSQ_LU(ppcImlGenContext, opcode) == false)
+		if (PPCRecompilerImlGen_PSQ_L(ppcImlGenContext, opcode, true) == false)
 			unsupportedInstructionFound = true;
 		ppcImlGenContext->hasFPUInstruction = true;
 		break;
@@ -4357,12 +2690,12 @@ bool PPCRecompiler_decodePPCInstruction(ppcImlGenContext_t* ppcImlGenContext)
 		}
 		break;
 	case 60:
-		if (PPCRecompilerImlGen_PSQ_ST(ppcImlGenContext, opcode) == false)
+		if (PPCRecompilerImlGen_PSQ_ST(ppcImlGenContext, opcode, false) == false)
 			unsupportedInstructionFound = true;
 		ppcImlGenContext->hasFPUInstruction = true;
 		break;
 	case 61:
-		if (PPCRecompilerImlGen_PSQ_STU(ppcImlGenContext, opcode) == false)
+		if (PPCRecompilerImlGen_PSQ_ST(ppcImlGenContext, opcode, true) == false)
 			unsupportedInstructionFound = true;
 		ppcImlGenContext->hasFPUInstruction = true;
 		break;
@@ -4471,556 +2804,482 @@ bool PPCRecompiler_decodePPCInstruction(ppcImlGenContext_t* ppcImlGenContext)
 	return unsupportedInstructionFound;
 }
 
-bool PPCRecompiler_generateIntermediateCode(ppcImlGenContext_t& ppcImlGenContext, PPCRecFunction_t* ppcRecFunc, std::set<uint32>& entryAddresses)
+// returns false if code flow is not interrupted
+bool PPCRecompiler_CheckIfInstructionEndsSegment(PPCFunctionBoundaryTracker& boundaryTracker, uint32 instructionAddress, uint32 opcode, bool& makeNextInstEnterable, bool& continueDefaultPath, bool& hasBranchTarget, uint32& branchTarget)
 {
-	//ppcImlGenContext_t ppcImlGenContext = { 0 };
-	ppcImlGenContext.functionRef = ppcRecFunc;
-	// add entire range
+	hasBranchTarget = false;
+	branchTarget = 0xFFFFFFFF;
+	makeNextInstEnterable = false;
+	continueDefaultPath = false;
+	switch (Espresso::GetPrimaryOpcode(opcode))
+	{
+	case Espresso::PrimaryOpcode::VIRTUAL_HLE:
+	{
+		makeNextInstEnterable = true;
+		hasBranchTarget = false;
+		continueDefaultPath = false;
+		return true;
+	}
+	case Espresso::PrimaryOpcode::BC:
+	{
+		uint32 BD, BI;
+		Espresso::BOField BO;
+		bool AA, LK;
+		Espresso::decodeOp_BC(opcode, BD, BO, BI, AA, LK);
+		if (!LK)
+		{
+			hasBranchTarget = true;
+			branchTarget = (AA ? BD : BD) + instructionAddress;
+			if (!boundaryTracker.ContainsAddress(branchTarget))
+				hasBranchTarget = false; // far jump
+		}
+		makeNextInstEnterable = LK;
+		continueDefaultPath = true;
+		return true;
+	}
+	case Espresso::PrimaryOpcode::B:
+	{
+		uint32 LI;
+		bool AA, LK;
+		Espresso::decodeOp_B(opcode, LI, AA, LK);
+		if (!LK)
+		{
+			hasBranchTarget = true;
+			branchTarget = AA ? LI : LI + instructionAddress;
+			if (!boundaryTracker.ContainsAddress(branchTarget))
+				hasBranchTarget = false; // far jump
+		}
+		makeNextInstEnterable = LK;
+		continueDefaultPath = false;
+		return true;
+	}
+	case Espresso::PrimaryOpcode::GROUP_19:
+		switch (Espresso::GetGroup19Opcode(opcode))
+		{
+		case Espresso::Opcode19::BCLR:
+		case Espresso::Opcode19::BCCTR:
+		{
+			Espresso::BOField BO;
+			uint32 BI;
+			bool LK;
+			Espresso::decodeOp_BCSPR(opcode, BO, BI, LK);
+			continueDefaultPath = !BO.conditionIgnore() || !BO.decrementerIgnore(); // if branch is always taken then there is no continued path
+			makeNextInstEnterable = Espresso::DecodeLK(opcode);
+			return true;
+		}
+		default:
+			break;
+		}
+		break;
+	case Espresso::PrimaryOpcode::GROUP_31:
+		switch (Espresso::GetGroup31Opcode(opcode))
+		{
+		default:
+			break;
+		}
+		break;
+	default:
+		break;
+	}
+	return false;
+}
+
+void PPCRecompiler_DetermineBasicBlockRange(std::vector<PPCBasicBlockInfo>& basicBlockList, PPCFunctionBoundaryTracker& boundaryTracker, uint32 ppcStart, uint32 ppcEnd, const std::set<uint32>& combinedBranchTargets, const std::set<uint32>& entryAddresses)
+{
+	cemu_assert_debug(ppcStart <= ppcEnd);
+
+	uint32 currentAddr = ppcStart;
+
+	PPCBasicBlockInfo* curBlockInfo = &basicBlockList.emplace_back(currentAddr, entryAddresses);
+
+	uint32 basicBlockStart = currentAddr;	
+	while (currentAddr <= ppcEnd)
+	{
+		curBlockInfo->lastAddress = currentAddr;
+		uint32 opcode = memory_readU32(currentAddr);
+		bool nextInstIsEnterable = false;
+		bool hasBranchTarget = false;
+		bool hasContinuedFlow = false;
+		uint32 branchTarget = 0;
+		if (PPCRecompiler_CheckIfInstructionEndsSegment(boundaryTracker, currentAddr, opcode, nextInstIsEnterable, hasContinuedFlow, hasBranchTarget, branchTarget))
+		{
+			curBlockInfo->hasBranchTarget = hasBranchTarget;
+			curBlockInfo->branchTarget = branchTarget;
+			curBlockInfo->hasContinuedFlow = hasContinuedFlow;
+			// start new basic block, except if this is the last instruction
+			if (currentAddr >= ppcEnd)
+				break;
+			curBlockInfo = &basicBlockList.emplace_back(currentAddr + 4, entryAddresses);
+			curBlockInfo->isEnterable = curBlockInfo->isEnterable || nextInstIsEnterable;
+			currentAddr += 4;
+			continue;
+		}
+		currentAddr += 4;
+		if (currentAddr <= ppcEnd)
+		{
+			if (combinedBranchTargets.find(currentAddr) != combinedBranchTargets.end())
+			{
+				// instruction is branch target, start new basic block
+				curBlockInfo = &basicBlockList.emplace_back(currentAddr, entryAddresses);
+			}
+		}
+
+	}
+}
+
+std::vector<PPCBasicBlockInfo> PPCRecompiler_DetermineBasicBlockRange(PPCFunctionBoundaryTracker& boundaryTracker, const std::set<uint32>& entryAddresses)
+{
+	cemu_assert(!entryAddresses.empty());
+	std::vector<PPCBasicBlockInfo> basicBlockList;
+
+	const std::set<uint32> branchTargets = boundaryTracker.GetBranchTargets();
+	auto funcRanges = boundaryTracker.GetRanges();
+
+	std::set<uint32> combinedBranchTargets = branchTargets;
+	combinedBranchTargets.insert(entryAddresses.begin(), entryAddresses.end());
+
+	for (auto& funcRangeIt : funcRanges)
+		PPCRecompiler_DetermineBasicBlockRange(basicBlockList, boundaryTracker, funcRangeIt.startAddress, funcRangeIt.startAddress + funcRangeIt.length - 4, combinedBranchTargets, entryAddresses);
+
+	// mark all segments that start at entryAddresses as enterable (debug code for verification, can be removed)
+	size_t numMarkedEnterable = 0;
+	for (auto& basicBlockIt : basicBlockList)
+	{
+		if (entryAddresses.find(basicBlockIt.startAddress) != entryAddresses.end())
+		{
+			cemu_assert_debug(basicBlockIt.isEnterable);
+			numMarkedEnterable++;
+		}
+	}
+	cemu_assert_debug(numMarkedEnterable == entryAddresses.size());
+
+	// todo - inline BL, currently this is done in the instruction handler of BL but this will mean that instruction cycle increasing is ignored
+
+	return basicBlockList;
+}
+
+bool PPCIMLGen_FillBasicBlock(ppcImlGenContext_t& ppcImlGenContext, PPCBasicBlockInfo& basicBlockInfo)
+{
+	ppcImlGenContext.currentOutputSegment = basicBlockInfo.GetSegmentForInstructionAppend();
+	ppcImlGenContext.currentInstruction = (uint32*)(memory_base + basicBlockInfo.startAddress);
+
+	uint32* firstCurrentInstruction = ppcImlGenContext.currentInstruction;
+	uint32* endCurrentInstruction = (uint32*)(memory_base + basicBlockInfo.lastAddress);
+
+	while (ppcImlGenContext.currentInstruction <= endCurrentInstruction)
+	{
+		uint32 addressOfCurrentInstruction = (uint32)((uint8*)ppcImlGenContext.currentInstruction - memory_base);
+		ppcImlGenContext.ppcAddressOfCurrentInstruction = addressOfCurrentInstruction;
+
+		if (PPCRecompiler_decodePPCInstruction(&ppcImlGenContext))
+		{
+			cemuLog_logDebug(LogType::Force, "PPCRecompiler: Unsupported instruction at 0x{:08x}", addressOfCurrentInstruction);
+			ppcImlGenContext.currentOutputSegment = nullptr;
+			return false;
+		}
+	}
+	ppcImlGenContext.currentOutputSegment = nullptr;
+	return true;
+}
+
+// returns split segment from which the continued segment is available via seg->GetBranchNotTaken()
+IMLSegment* PPCIMLGen_CreateSplitSegmentAtEnd(ppcImlGenContext_t& ppcImlGenContext, PPCBasicBlockInfo& basicBlockInfo)
+{
+	IMLSegment* writeSegment = basicBlockInfo.GetSegmentForInstructionAppend();
+
+	IMLSegment* continuedSegment = ppcImlGenContext.InsertSegment(ppcImlGenContext.GetSegmentIndex(writeSegment) + 1);
+
+	continuedSegment->SetLinkBranchTaken(writeSegment->GetBranchTaken());
+	continuedSegment->SetLinkBranchNotTaken(writeSegment->GetBranchNotTaken());
+
+	writeSegment->SetLinkBranchNotTaken(continuedSegment);
+	writeSegment->SetLinkBranchTaken(nullptr);
+
+	if (ppcImlGenContext.currentOutputSegment == writeSegment)
+		ppcImlGenContext.currentOutputSegment = continuedSegment;
+
+	cemu_assert_debug(basicBlockInfo.appendSegment == writeSegment);
+	basicBlockInfo.appendSegment = continuedSegment;
+
+	return writeSegment;
+}
+
+// generates a new segment and sets it as branch target for the current write segment. Returns the created segment
+IMLSegment* PPCIMLGen_CreateNewSegmentAsBranchTarget(ppcImlGenContext_t& ppcImlGenContext, PPCBasicBlockInfo& basicBlockInfo)
+{
+	IMLSegment* writeSegment = basicBlockInfo.GetSegmentForInstructionAppend();
+	IMLSegment* branchTargetSegment = ppcImlGenContext.NewSegment();
+	cemu_assert_debug(!writeSegment->GetBranchTaken()); // must not have a target already
+	writeSegment->SetLinkBranchTaken(branchTargetSegment);
+	return branchTargetSegment;
+}
+
+// verify that current instruction is the last instruction of the active basic block
+void PPCIMLGen_AssertIfNotLastSegmentInstruction(ppcImlGenContext_t& ppcImlGenContext)
+{
+	cemu_assert_debug(ppcImlGenContext.currentBasicBlock->lastAddress == ppcImlGenContext.ppcAddressOfCurrentInstruction);
+}
+
+bool PPCRecompiler_IsBasicBlockATightFiniteLoop(IMLSegment* imlSegment, PPCBasicBlockInfo& basicBlockInfo)
+{
+	// if we detect a finite loop we can skip generating the cycle check
+	// currently we only check for BDNZ loops since thats reasonably safe to rely on
+	// however there are other forms of loops that can be classified as finite,
+	// but detecting those involves analyzing PPC code and we dont have the infrastructure for that (e.g. IML has CheckRegisterUsage but we dont have an equivalent for PPC code)
+
+	// base criteria, must jump to beginning of same segment
+	if (imlSegment->nextSegmentBranchTaken != imlSegment)
+		return false;
+
+	uint32 opcode = *(uint32be*)(memory_base + basicBlockInfo.lastAddress);
+	if (Espresso::GetPrimaryOpcode(opcode) != Espresso::PrimaryOpcode::BC)
+		return false;
+	uint32 BO, BI, BD;
+	PPC_OPC_TEMPL_B(opcode, BO, BI, BD);
+	Espresso::BOField boField(BO);
+	if(!boField.conditionIgnore() || boField.branchAlways())
+		return false;
+	if(boField.decrementerIgnore())
+		return false;
+	return true;
+}
+
+void PPCRecompiler_HandleCycleCheckCount(ppcImlGenContext_t& ppcImlGenContext, PPCBasicBlockInfo& basicBlockInfo)
+{
+	IMLSegment* imlSegment = basicBlockInfo.GetFirstSegmentInChain();
+	if (!basicBlockInfo.hasBranchTarget)
+		return;
+	if (basicBlockInfo.branchTarget > basicBlockInfo.startAddress)
+		return;
+
+	if (PPCRecompiler_IsBasicBlockATightFiniteLoop(imlSegment, basicBlockInfo))
+		return;
+
+	// make the segment enterable so execution can return after passing a check
+	basicBlockInfo.GetFirstSegmentInChain()->SetEnterable(basicBlockInfo.startAddress);
+
+	IMLSegment* splitSeg = PPCIMLGen_CreateSplitSegmentAtEnd(ppcImlGenContext, basicBlockInfo);
+	splitSeg->AppendInstruction()->make_cjump_cycle_check();
+
+	IMLSegment* exitSegment = ppcImlGenContext.NewSegment();
+	splitSeg->SetLinkBranchTaken(exitSegment);
+
+	exitSegment->AppendInstruction()->make_macro(PPCREC_IML_MACRO_LEAVE, basicBlockInfo.startAddress, 0, 0, IMLREG_INVALID);
+
+	cemu_assert_debug(splitSeg->nextSegmentBranchNotTaken);
+	// let the IML optimizer and RA know that the original segment should be used during analysis for dead code elimination
+	exitSegment->SetNextSegmentForOverwriteHints(splitSeg->nextSegmentBranchNotTaken);
+}
+
+void PPCRecompiler_SetSegmentsUncertainFlow(ppcImlGenContext_t& ppcImlGenContext)
+{
+	for (IMLSegment* segIt : ppcImlGenContext.segmentList2)
+	{
+		// handle empty segment
+		if (segIt->imlList.empty())
+		{
+			cemu_assert_debug(segIt->GetBranchNotTaken());
+			continue;
+		}
+		// check last instruction of segment
+		IMLInstruction* imlInstruction = segIt->GetLastInstruction();
+		if (imlInstruction->type == PPCREC_IML_TYPE_MACRO)
+		{
+			auto macroType = imlInstruction->operation;
+			switch (macroType)
+			{
+				case PPCREC_IML_MACRO_B_TO_REG:
+				case PPCREC_IML_MACRO_BL:
+				case PPCREC_IML_MACRO_B_FAR:
+				case PPCREC_IML_MACRO_HLE:
+				case PPCREC_IML_MACRO_LEAVE:
+					segIt->nextSegmentIsUncertain = true;
+					break;
+				case PPCREC_IML_MACRO_DEBUGBREAK:
+				case PPCREC_IML_MACRO_COUNT_CYCLES:
+					break;
+				default:
+				cemu_assert_unimplemented();
+			}
+		}
+	}
+}
+
+bool PPCRecompiler_GenerateIML(ppcImlGenContext_t& ppcImlGenContext, PPCFunctionBoundaryTracker& boundaryTracker, std::set<uint32>& entryAddresses)
+{
+	std::vector<PPCBasicBlockInfo> basicBlockList = PPCRecompiler_DetermineBasicBlockRange(boundaryTracker, entryAddresses);
+
+	// create segments
+	std::unordered_map<uint32, PPCBasicBlockInfo*> addrToBB;
+	ppcImlGenContext.segmentList2.resize(basicBlockList.size());
+	for (size_t i = 0; i < basicBlockList.size(); i++)
+	{
+		PPCBasicBlockInfo& basicBlockInfo = basicBlockList[i];
+		IMLSegment* seg = new IMLSegment();
+		seg->ppcAddress = basicBlockInfo.startAddress;
+		if(basicBlockInfo.isEnterable)
+			seg->SetEnterable(basicBlockInfo.startAddress);
+		ppcImlGenContext.segmentList2[i] = seg;
+		cemu_assert_debug(addrToBB.find(basicBlockInfo.startAddress) == addrToBB.end());
+		basicBlockInfo.SetInitialSegment(seg);
+		addrToBB.emplace(basicBlockInfo.startAddress, &basicBlockInfo);
+	}
+	// link segments
+	for (size_t i = 0; i < basicBlockList.size(); i++)
+	{
+		PPCBasicBlockInfo& bbInfo = basicBlockList[i];
+		cemu_assert_debug(bbInfo.GetFirstSegmentInChain() == bbInfo.GetSegmentForInstructionAppend());
+		IMLSegment* seg = ppcImlGenContext.segmentList2[i];
+		if (bbInfo.hasBranchTarget)
+		{
+			PPCBasicBlockInfo* targetBB = addrToBB[bbInfo.branchTarget];
+			cemu_assert_debug(targetBB);
+			IMLSegment_SetLinkBranchTaken(seg, targetBB->GetFirstSegmentInChain());
+		}
+		if (bbInfo.hasContinuedFlow)
+		{
+			PPCBasicBlockInfo* targetBB = addrToBB[bbInfo.lastAddress + 4];
+			if (!targetBB)
+			{
+				cemuLog_log(LogType::Recompiler, "Recompiler was unable to link segment [0x{:08x}-0x{:08x}] to 0x{:08x}", bbInfo.startAddress, bbInfo.lastAddress, bbInfo.lastAddress + 4);
+				return false;
+			}
+			cemu_assert_debug(targetBB);
+			IMLSegment_SetLinkBranchNotTaken(seg, targetBB->GetFirstSegmentInChain());
+		}
+	}
+	// we assume that all unreachable segments are potentially enterable
+	// todo - mark them as such
+
+
+	// generate cycle counters
+	// in theory we could generate these as part of FillBasicBlock() but in the future we might use more complex logic to emit fewer operations
+	for (size_t i = 0; i < basicBlockList.size(); i++)
+	{
+		PPCBasicBlockInfo& basicBlockInfo = basicBlockList[i];
+		IMLSegment* seg = basicBlockInfo.GetSegmentForInstructionAppend();
+
+		uint32 ppcInstructionCount = (basicBlockInfo.lastAddress - basicBlockInfo.startAddress + 4) / 4;
+		cemu_assert_debug(ppcInstructionCount > 0);
+
+		PPCRecompiler_pushBackIMLInstructions(seg, 0, 1);
+		seg->imlList[0].type = PPCREC_IML_TYPE_MACRO;
+		seg->imlList[0].operation = PPCREC_IML_MACRO_COUNT_CYCLES;
+		seg->imlList[0].op_macro.param = ppcInstructionCount;
+	}
+
+	// generate cycle check instructions
+	// note: Introduces new segments
+	for (size_t i = 0; i < basicBlockList.size(); i++)
+	{
+		PPCBasicBlockInfo& basicBlockInfo = basicBlockList[i];
+		PPCRecompiler_HandleCycleCheckCount(ppcImlGenContext, basicBlockInfo);
+	}
+
+	// fill in all the basic blocks
+	// note: This step introduces new segments as is necessary for some instructions
+	for (size_t i = 0; i < basicBlockList.size(); i++)
+	{
+		PPCBasicBlockInfo& basicBlockInfo = basicBlockList[i];
+		ppcImlGenContext.currentBasicBlock = &basicBlockInfo;
+		if (!PPCIMLGen_FillBasicBlock(ppcImlGenContext, basicBlockInfo))
+			return false;
+		ppcImlGenContext.currentBasicBlock = nullptr;
+	}
+
+	// mark segments with unknown jump destination (e.g. BLR and most macros)
+	PPCRecompiler_SetSegmentsUncertainFlow(ppcImlGenContext);
+
+	// debug - check segment graph
+#ifdef CEMU_DEBUG_ASSERT
+	//for (size_t i = 0; i < basicBlockList.size(); i++)
+	//{
+	//	IMLSegment* seg = ppcImlGenContext.segmentList2[i];
+	//	if (seg->list_prevSegments.empty())
+	//	{
+	//		cemu_assert_debug(seg->isEnterable);
+	//	}
+	//}
+	// debug - check if suffix instructions are at the end of segments and if they are present for branching segments
+	for (size_t segIndex = 0; segIndex < ppcImlGenContext.segmentList2.size(); segIndex++)
+	{
+		IMLSegment* seg = ppcImlGenContext.segmentList2[segIndex];
+		IMLSegment* nextSeg = (segIndex+1) < ppcImlGenContext.segmentList2.size() ? ppcImlGenContext.segmentList2[segIndex + 1] : nullptr;
+
+		if (seg->imlList.size() > 0)
+		{
+			for (size_t f = 0; f < seg->imlList.size() - 1; f++)
+			{
+				if (seg->imlList[f].IsSuffixInstruction())
+				{
+					debug_printf("---------------- SegmentDump (Suffix instruction at wrong pos in segment 0x%x):\n", (int)segIndex);
+					IMLDebug_Dump(&ppcImlGenContext);
+					DEBUG_BREAK;
+				}
+			}
+		}
+		if (seg->nextSegmentBranchTaken)
+		{
+			if (!seg->HasSuffixInstruction())
+			{
+				debug_printf("---------------- SegmentDump (NoSuffixInstruction in segment 0x%x):\n", (int)segIndex);
+				IMLDebug_Dump(&ppcImlGenContext);
+				DEBUG_BREAK;
+			}
+		}
+		if (seg->nextSegmentBranchNotTaken)
+		{
+			// if branch not taken, flow must continue to next segment in sequence
+			cemu_assert_debug(seg->nextSegmentBranchNotTaken == nextSeg);
+		}
+		// more detailed checks based on actual suffix instruction
+		if (seg->imlList.size() > 0)
+		{
+			IMLInstruction* inst = seg->GetLastInstruction();
+			if (inst->type == PPCREC_IML_TYPE_MACRO && inst->op_macro.param == PPCREC_IML_MACRO_B_FAR)
+			{
+				cemu_assert_debug(!seg->GetBranchTaken());
+				cemu_assert_debug(!seg->GetBranchNotTaken());
+			}
+			if (inst->type == PPCREC_IML_TYPE_CJUMP_CYCLE_CHECK)
+			{
+				cemu_assert_debug(seg->GetBranchTaken());
+				cemu_assert_debug(seg->GetBranchNotTaken());
+			}
+			if (inst->type == PPCREC_IML_TYPE_CONDITIONAL_JUMP)
+			{
+				if (!seg->GetBranchTaken() || !seg->GetBranchNotTaken())
+				{
+					debug_printf("---------------- SegmentDump (Missing branch for conditional jump in segment 0x%x):\n", (int)segIndex);
+					IMLDebug_Dump(&ppcImlGenContext);
+					cemu_assert_error();
+				}
+			}
+		}
+		segIndex++;
+	}
+#endif
+
+
+	// todos:
+	// - basic block determination should look for the B(L) B(L) pattern. Or maybe just mark every bb without any input segments as an entry segment
+
+	return true;
+}
+
+bool PPCRecompiler_generateIntermediateCode(ppcImlGenContext_t& ppcImlGenContext, PPCRecFunction_t* ppcRecFunc, std::set<uint32>& entryAddresses, PPCFunctionBoundaryTracker& boundaryTracker)
+{
+	ppcImlGenContext.boundaryTracker = &boundaryTracker;
+	if (!PPCRecompiler_GenerateIML(ppcImlGenContext, boundaryTracker, entryAddresses))
+		return false;
+
+	// set range
+	// todo - support non-continuous functions for the range tracking?
 	ppcRecRange_t recRange;
 	recRange.ppcAddress = ppcRecFunc->ppcAddress;
 	recRange.ppcSize = ppcRecFunc->ppcSize;
 	ppcRecFunc->list_ranges.push_back(recRange);
-	// process ppc instructions
-	ppcImlGenContext.currentInstruction = (uint32*)memory_getPointerFromVirtualOffset(ppcRecFunc->ppcAddress);
-	bool unsupportedInstructionFound = false;
-	sint32 numPPCInstructions = ppcRecFunc->ppcSize/4;
-	sint32 unsupportedInstructionCount = 0;
-	uint32 unsupportedInstructionLastOffset = 0;
-	uint32* firstCurrentInstruction = ppcImlGenContext.currentInstruction;
-	uint32* endCurrentInstruction = ppcImlGenContext.currentInstruction + numPPCInstructions;
+
 	
-	while(ppcImlGenContext.currentInstruction < endCurrentInstruction)
-	{
-		uint32 addressOfCurrentInstruction = (uint32)((uint8*)ppcImlGenContext.currentInstruction - memory_base);
-		ppcImlGenContext.ppcAddressOfCurrentInstruction = addressOfCurrentInstruction;
-		ppcImlGenContext.cyclesSinceLastBranch++;
-		PPCRecompilerImlGen_generateNewInstruction_jumpmark(&ppcImlGenContext, addressOfCurrentInstruction);
-		
-		if (entryAddresses.find(addressOfCurrentInstruction) != entryAddresses.end())
-		{
-			// add PPCEnter for addresses that are in entryAddresses
-			PPCRecompilerImlGen_generateNewInstruction_ppcEnter(&ppcImlGenContext, addressOfCurrentInstruction);
-		}
-		else if(ppcImlGenContext.currentInstruction != firstCurrentInstruction)
-		{
-			// add PPCEnter mark if code is seemingly unreachable (for example if between two unconditional jump instructions without jump goal)
-			uint32 opcodeCurrent = PPCRecompiler_getCurrentInstruction(&ppcImlGenContext);
-			uint32 opcodePrevious = PPCRecompiler_getPreviousInstruction(&ppcImlGenContext);
-			if( ((opcodePrevious>>26) == 18) && ((opcodeCurrent>>26) == 18) )
-			{
-				// between two B(L) instructions
-				// todo: for BL only if they are not inlineable
-
-				bool canInlineFunction = false;
-				if ((opcodePrevious & PPC_OPC_LK) && (opcodePrevious & PPC_OPC_AA) == 0)
-				{
-					uint32 li;
-					PPC_OPC_TEMPL_I(opcodePrevious, li);
-					sint32 inlineSize = 0;
-					if (PPCRecompiler_canInlineFunction(li + addressOfCurrentInstruction - 4, &inlineSize))
-						canInlineFunction = true;
-				}
-				if( canInlineFunction == false && (opcodePrevious & PPC_OPC_LK) == false)
-					PPCRecompilerImlGen_generateNewInstruction_ppcEnter(&ppcImlGenContext, addressOfCurrentInstruction);
-			}
-			if( ((opcodePrevious>>26) == 19) && PPC_getBits(opcodePrevious, 30, 10) == 528 )
-			{
-				uint32 BO, BI, BD;
-				PPC_OPC_TEMPL_XL(opcodePrevious, BO, BI, BD);
-				if( (BO & 16) && (opcodePrevious&PPC_OPC_LK) == 0 )
-				{
-					// after unconditional BCTR instruction
-					PPCRecompilerImlGen_generateNewInstruction_ppcEnter(&ppcImlGenContext, addressOfCurrentInstruction);
-				}
-			}
-		}
-
-		unsupportedInstructionFound = PPCRecompiler_decodePPCInstruction(&ppcImlGenContext);
-		if( unsupportedInstructionFound )
-		{
-			unsupportedInstructionCount++;
-			unsupportedInstructionLastOffset = ppcImlGenContext.ppcAddressOfCurrentInstruction;
-			unsupportedInstructionFound = false;
-			//break;
-		}
-	}
-	ppcImlGenContext.ppcAddressOfCurrentInstruction = 0; // reset current instruction offset (any future generated IML instruction will be assigned to ppc address 0)
-	if( unsupportedInstructionCount > 0 || unsupportedInstructionFound )
-	{
-		// could not compile function
-		debug_printf("Failed recompile due to unknown instruction at 0x%08x\n", unsupportedInstructionLastOffset);
-		PPCRecompiler_freeContext(&ppcImlGenContext);
-		return false;
-	}
-	// optimize unused jumpmarks away
-	// first, flag all jumpmarks as unused
-	std::map<uint32, PPCRecImlInstruction_t*> map_jumpMarks;
-	for(sint32 i=0; i<ppcImlGenContext.imlListCount; i++)
-	{
-		if( ppcImlGenContext.imlList[i].type == PPCREC_IML_TYPE_JUMPMARK )
-		{
-			ppcImlGenContext.imlList[i].op_jumpmark.flags |= PPCREC_IML_OP_FLAG_UNUSED;
-#ifndef PUBLIC_RELEASE
-			if (map_jumpMarks.find(ppcImlGenContext.imlList[i].op_jumpmark.address) != map_jumpMarks.end())
-				assert_dbg();
-#endif
-			map_jumpMarks.emplace(ppcImlGenContext.imlList[i].op_jumpmark.address, ppcImlGenContext.imlList+i);
-		}
-	}
-	// second, unflag jumpmarks that have at least one reference
-	for(sint32 i=0; i<ppcImlGenContext.imlListCount; i++)
-	{
-		if( ppcImlGenContext.imlList[i].type == PPCREC_IML_TYPE_CJUMP )
-		{
-			uint32 jumpDest = ppcImlGenContext.imlList[i].op_conditionalJump.jumpmarkAddress;
-			auto jumpMarkIml = map_jumpMarks.find(jumpDest);
-			if (jumpMarkIml != map_jumpMarks.end())
-				jumpMarkIml->second->op_jumpmark.flags &= ~PPCREC_IML_OP_FLAG_UNUSED;
-		}
-	}
-	// lastly, remove jumpmarks that still have the unused flag set
-	sint32 currentImlIndex = 0;
-	for(sint32 i=0; i<ppcImlGenContext.imlListCount; i++)
-	{
-		if( ppcImlGenContext.imlList[i].type == PPCREC_IML_TYPE_JUMPMARK && (ppcImlGenContext.imlList[i].op_jumpmark.flags&PPCREC_IML_OP_FLAG_UNUSED) )
-		{
-			continue; // skip this instruction
-		}
-		// move back instruction
-		if( currentImlIndex < i )
-		{
-			memcpy(ppcImlGenContext.imlList+currentImlIndex, ppcImlGenContext.imlList+i, sizeof(PPCRecImlInstruction_t));
-		}
-		currentImlIndex++;
-	}
-	// fix intermediate instruction count
-	ppcImlGenContext.imlListCount = currentImlIndex;
-	// divide iml instructions into segments
-	// each segment is defined by one or more instructions with no branches or jump destinations in between
-	// a branch instruction may only be the very last instruction of a segment
-	ppcImlGenContext.segmentListCount = 0;
-	ppcImlGenContext.segmentListSize = 2;
-	ppcImlGenContext.segmentList = (PPCRecImlSegment_t**)malloc(ppcImlGenContext.segmentListSize*sizeof(PPCRecImlSegment_t*));
-	sint32 segmentStart = 0;
-	sint32 segmentImlIndex = 0;
-	while( segmentImlIndex < ppcImlGenContext.imlListCount )
-	{
-		bool genNewSegment = false;
-		// segment definition: 
-		//    If we encounter a branch instruction -> end of segment after current instruction
-		//    If we encounter a jumpmark		   -> end of segment before current instruction
-		//    If we encounter ppc_enter			   -> end of segment before current instruction
-		if( ppcImlGenContext.imlList[segmentImlIndex].type == PPCREC_IML_TYPE_CJUMP ||
-			(ppcImlGenContext.imlList[segmentImlIndex].type == PPCREC_IML_TYPE_MACRO && (ppcImlGenContext.imlList[segmentImlIndex].operation == PPCREC_IML_MACRO_BLR || ppcImlGenContext.imlList[segmentImlIndex].operation == PPCREC_IML_MACRO_BLRL || ppcImlGenContext.imlList[segmentImlIndex].operation == PPCREC_IML_MACRO_BCTR || ppcImlGenContext.imlList[segmentImlIndex].operation == PPCREC_IML_MACRO_BCTRL)) ||
-			(ppcImlGenContext.imlList[segmentImlIndex].type == PPCREC_IML_TYPE_MACRO && (ppcImlGenContext.imlList[segmentImlIndex].operation == PPCREC_IML_MACRO_BL)) ||
-			(ppcImlGenContext.imlList[segmentImlIndex].type == PPCREC_IML_TYPE_MACRO && (ppcImlGenContext.imlList[segmentImlIndex].operation == PPCREC_IML_MACRO_B_FAR)) ||
-			(ppcImlGenContext.imlList[segmentImlIndex].type == PPCREC_IML_TYPE_MACRO && (ppcImlGenContext.imlList[segmentImlIndex].operation == PPCREC_IML_MACRO_LEAVE)) ||
-			(ppcImlGenContext.imlList[segmentImlIndex].type == PPCREC_IML_TYPE_MACRO && (ppcImlGenContext.imlList[segmentImlIndex].operation == PPCREC_IML_MACRO_HLE)) ||
-			(ppcImlGenContext.imlList[segmentImlIndex].type == PPCREC_IML_TYPE_MACRO && (ppcImlGenContext.imlList[segmentImlIndex].operation == PPCREC_IML_MACRO_MFTB)) )
-		{
-			// segment ends after current instruction
-			PPCRecImlSegment_t* ppcRecSegment = PPCRecompiler_generateImlSegment(&ppcImlGenContext);
-			ppcRecSegment->startOffset = segmentStart;
-			ppcRecSegment->count = segmentImlIndex-segmentStart+1;
-			ppcRecSegment->ppcAddress = 0xFFFFFFFF;
-			segmentStart = segmentImlIndex+1;
-		}
-		else if( ppcImlGenContext.imlList[segmentImlIndex].type == PPCREC_IML_TYPE_JUMPMARK ||
-			ppcImlGenContext.imlList[segmentImlIndex].type == PPCREC_IML_TYPE_PPC_ENTER )
-		{
-			// segment ends before current instruction
-			if( segmentImlIndex > segmentStart )
-			{
-				PPCRecImlSegment_t* ppcRecSegment = PPCRecompiler_generateImlSegment(&ppcImlGenContext);
-				ppcRecSegment->startOffset = segmentStart;
-				ppcRecSegment->count = segmentImlIndex-segmentStart;
-				ppcRecSegment->ppcAddress = 0xFFFFFFFF;
-				segmentStart = segmentImlIndex;
-			}
-		}
-		segmentImlIndex++;
-	}
-	if( segmentImlIndex != segmentStart )
-	{
-		// final segment
-		PPCRecImlSegment_t* ppcRecSegment = PPCRecompiler_generateImlSegment(&ppcImlGenContext);
-		ppcRecSegment->startOffset = segmentStart;
-		ppcRecSegment->count = segmentImlIndex-segmentStart;
-		ppcRecSegment->ppcAddress = 0xFFFFFFFF;
-		segmentStart = segmentImlIndex;
-	}
-	// move iml instructions into the segments
-	for(sint32 s=0; s<ppcImlGenContext.segmentListCount; s++)
-	{
-		uint32 imlStartIndex = ppcImlGenContext.segmentList[s]->startOffset;
-		uint32 imlCount = ppcImlGenContext.segmentList[s]->count;
-		if( imlCount > 0 )
-		{
-			ppcImlGenContext.segmentList[s]->imlListSize = imlCount + 4;
-			ppcImlGenContext.segmentList[s]->imlList = (PPCRecImlInstruction_t*)malloc(sizeof(PPCRecImlInstruction_t)*ppcImlGenContext.segmentList[s]->imlListSize);
-			ppcImlGenContext.segmentList[s]->imlListCount = imlCount;
-			memcpy(ppcImlGenContext.segmentList[s]->imlList, ppcImlGenContext.imlList+imlStartIndex, sizeof(PPCRecImlInstruction_t)*imlCount);
-		}
-		else
-		{
-			// empty segments are allowed so we can handle multiple PPC entry addresses pointing to the same code
-			ppcImlGenContext.segmentList[s]->imlList = NULL;
-			ppcImlGenContext.segmentList[s]->imlListSize = 0;
-			ppcImlGenContext.segmentList[s]->imlListCount = 0;
-		}
-		ppcImlGenContext.segmentList[s]->startOffset = 9999999;
-		ppcImlGenContext.segmentList[s]->count = 9999999;
-	}
-	// clear segment-independent iml list
-	free(ppcImlGenContext.imlList);
-	ppcImlGenContext.imlList = NULL;
-	ppcImlGenContext.imlListCount = 999999; // set to high number to force crash in case old code still uses ppcImlGenContext.imlList
-	// calculate PPC address of each segment based on iml instructions inside that segment (we need this info to calculate how many cpu cycles each segment takes)
-	for(sint32 s=0; s<ppcImlGenContext.segmentListCount; s++)
-	{
-		uint32 segmentPPCAddrMin = 0xFFFFFFFF;
-		uint32 segmentPPCAddrMax = 0x00000000;
-		for(sint32 i=0; i<ppcImlGenContext.segmentList[s]->imlListCount; i++)
-		{
-			if( ppcImlGenContext.segmentList[s]->imlList[i].associatedPPCAddress == 0 )
-				continue;
-			//if( ppcImlGenContext.segmentList[s]->imlList[i].type == PPCREC_IML_TYPE_JUMPMARK || ppcImlGenContext.segmentList[s]->imlList[i].type == PPCREC_IML_TYPE_NO_OP )
-			//	continue; // jumpmarks and no-op instructions must not affect segment ppc address range
-			segmentPPCAddrMin = std::min(ppcImlGenContext.segmentList[s]->imlList[i].associatedPPCAddress, segmentPPCAddrMin);
-			segmentPPCAddrMax = std::max(ppcImlGenContext.segmentList[s]->imlList[i].associatedPPCAddress, segmentPPCAddrMax);
-		}
-		if( segmentPPCAddrMin != 0xFFFFFFFF )
-		{
-			ppcImlGenContext.segmentList[s]->ppcAddrMin = segmentPPCAddrMin;
-			ppcImlGenContext.segmentList[s]->ppcAddrMax = segmentPPCAddrMax;
-		}
-		else
-		{
-			ppcImlGenContext.segmentList[s]->ppcAddrMin = 0;
-			ppcImlGenContext.segmentList[s]->ppcAddrMax = 0;
-		}
-	}
-	// certain instructions can change the segment state
-	// ppcEnter instruction marks a segment as enterable (BL, BCTR, etc. instructions can enter at this location from outside)
-	// jumpmarks mark the segment as a jump destination (within the same function)
-	for(sint32 s=0; s<ppcImlGenContext.segmentListCount; s++)
-	{
-		while( ppcImlGenContext.segmentList[s]->imlListCount > 0 )
-		{
-			if( ppcImlGenContext.segmentList[s]->imlList[0].type == PPCREC_IML_TYPE_PPC_ENTER )
-			{
-				// mark segment as enterable
-				if( ppcImlGenContext.segmentList[s]->isEnterable )
-					assert_dbg(); // should not happen?
-				ppcImlGenContext.segmentList[s]->isEnterable = true;
-				ppcImlGenContext.segmentList[s]->enterPPCAddress = ppcImlGenContext.segmentList[s]->imlList[0].op_ppcEnter.ppcAddress;
-				// remove ppc_enter instruction
-				ppcImlGenContext.segmentList[s]->imlList[0].type = PPCREC_IML_TYPE_NO_OP;
-				ppcImlGenContext.segmentList[s]->imlList[0].crRegister = PPC_REC_INVALID_REGISTER;
-				ppcImlGenContext.segmentList[s]->imlList[0].associatedPPCAddress = 0;
-			}
-			else if( ppcImlGenContext.segmentList[s]->imlList[0].type == PPCREC_IML_TYPE_JUMPMARK )
-			{
-				// mark segment as jump destination
-				if( ppcImlGenContext.segmentList[s]->isJumpDestination )
-					assert_dbg(); // should not happen?
-				ppcImlGenContext.segmentList[s]->isJumpDestination = true;
-				ppcImlGenContext.segmentList[s]->jumpDestinationPPCAddress = ppcImlGenContext.segmentList[s]->imlList[0].op_jumpmark.address;
-				// remove jumpmark instruction
-				ppcImlGenContext.segmentList[s]->imlList[0].type = PPCREC_IML_TYPE_NO_OP;
-				ppcImlGenContext.segmentList[s]->imlList[0].crRegister = PPC_REC_INVALID_REGISTER;
-				ppcImlGenContext.segmentList[s]->imlList[0].associatedPPCAddress = 0;
-			}
-			else
-				break;
-		}
-	}
-	// the first segment is always enterable as the recompiled functions entrypoint
-	ppcImlGenContext.segmentList[0]->isEnterable = true;
-	ppcImlGenContext.segmentList[0]->enterPPCAddress = ppcImlGenContext.functionRef->ppcAddress;
-
-	// link segments for further inter-segment optimization
-	PPCRecompilerIML_linkSegments(&ppcImlGenContext);
-
-	// optimization pass - replace segments with conditional MOVs if possible
-	for (sint32 s = 0; s < ppcImlGenContext.segmentListCount; s++)
-	{
-		PPCRecImlSegment_t* imlSegment = ppcImlGenContext.segmentList[s];
-		if (imlSegment->nextSegmentBranchNotTaken == NULL || imlSegment->nextSegmentBranchTaken == NULL)
-			continue; // not a branching segment
-		PPCRecImlInstruction_t* lastInstruction = PPCRecompilerIML_getLastInstruction(imlSegment);
-		if (lastInstruction->type != PPCREC_IML_TYPE_CJUMP || lastInstruction->op_conditionalJump.crRegisterIndex != 0)
-			continue;
-		PPCRecImlSegment_t* conditionalSegment = imlSegment->nextSegmentBranchNotTaken;
-		PPCRecImlSegment_t* finalSegment = imlSegment->nextSegmentBranchTaken;
-		if(imlSegment->nextSegmentBranchTaken != imlSegment->nextSegmentBranchNotTaken->nextSegmentBranchNotTaken)
-			continue;
-		if (imlSegment->nextSegmentBranchNotTaken->imlListCount > 4)
-			continue;
-		if(conditionalSegment->list_prevSegments.size() != 1)
-			continue; // the reduced segment must not be the target of any other branch
-		if(conditionalSegment->isEnterable)
-			continue;
-		// check if the segment contains only iml instructions that can be turned into conditional moves (Value assignment, register assignment)
-		bool canReduceSegment = true;
-		for (sint32 f = 0; f < conditionalSegment->imlListCount; f++)
-		{
-			PPCRecImlInstruction_t* imlInstruction = conditionalSegment->imlList+f;
-			if( imlInstruction->type == PPCREC_IML_TYPE_R_S32 && imlInstruction->operation == PPCREC_IML_OP_ASSIGN)
-				continue;
-			// todo: Register to register copy
-			canReduceSegment = false;
-			break;
-		}
-
-		if( canReduceSegment == false )
-			continue;
-		
-		// remove the branch instruction
-		uint8 branchCond_crRegisterIndex = lastInstruction->op_conditionalJump.crRegisterIndex;
-		uint8 branchCond_crBitIndex = lastInstruction->op_conditionalJump.crBitIndex;
-		bool  branchCond_bitMustBeSet = lastInstruction->op_conditionalJump.bitMustBeSet;
-		
-		PPCRecompilerImlGen_generateNewInstruction_noOp(&ppcImlGenContext, lastInstruction);
-
-		// append conditional moves based on branch condition
-		for (sint32 f = 0; f < conditionalSegment->imlListCount; f++)
-		{
-			PPCRecImlInstruction_t* imlInstruction = conditionalSegment->imlList + f;
-			if (imlInstruction->type == PPCREC_IML_TYPE_R_S32 && imlInstruction->operation == PPCREC_IML_OP_ASSIGN)
-				PPCRecompilerImlGen_generateNewInstruction_conditional_r_s32(&ppcImlGenContext, PPCRecompiler_appendInstruction(imlSegment), PPCREC_IML_OP_ASSIGN, imlInstruction->op_r_immS32.registerIndex, imlInstruction->op_r_immS32.immS32, branchCond_crRegisterIndex, branchCond_crBitIndex, !branchCond_bitMustBeSet);
-			else
-				assert_dbg();
-		}
-		// update segment links
-		// source segment: imlSegment, conditional/removed segment: conditionalSegment, final segment: finalSegment
-		PPCRecompilerIML_removeLink(imlSegment, conditionalSegment);
-		PPCRecompilerIML_removeLink(imlSegment, finalSegment);
-		PPCRecompilerIML_removeLink(conditionalSegment, finalSegment);
-		PPCRecompilerIml_setLinkBranchNotTaken(imlSegment, finalSegment);
-		// remove all instructions from conditional segment
-		conditionalSegment->imlListCount = 0;
-
-		// if possible, merge imlSegment with finalSegment
-		if (finalSegment->isEnterable == false && finalSegment->list_prevSegments.size() == 1)
-		{
-			// todo: Clean this up and move into separate function PPCRecompilerIML_mergeSegments()
-			PPCRecompilerIML_removeLink(imlSegment, finalSegment);
-			if (finalSegment->nextSegmentBranchNotTaken)
-			{
-				PPCRecImlSegment_t* tempSegment = finalSegment->nextSegmentBranchNotTaken;
-				PPCRecompilerIML_removeLink(finalSegment, tempSegment);
-				PPCRecompilerIml_setLinkBranchNotTaken(imlSegment, tempSegment);
-			}
-			if (finalSegment->nextSegmentBranchTaken)
-			{
-				PPCRecImlSegment_t* tempSegment = finalSegment->nextSegmentBranchTaken;
-				PPCRecompilerIML_removeLink(finalSegment, tempSegment);
-				PPCRecompilerIml_setLinkBranchTaken(imlSegment, tempSegment);
-			}
-			// copy IML instructions
-			for (sint32 f = 0; f < finalSegment->imlListCount; f++)
-			{
-				memcpy(PPCRecompiler_appendInstruction(imlSegment), finalSegment->imlList + f, sizeof(PPCRecImlInstruction_t));
-			}
-			finalSegment->imlListCount = 0;
-
-			//PPCRecompiler_dumpIML(ppcRecFunc, &ppcImlGenContext);
-		}
-
-		// todo: If possible, merge with the segment following conditionalSegment (merging is only possible if the segment is not an entry point or has no other jump sources)
-	}
-
-	// insert cycle counter instruction in every segment that has a cycle count greater zero
-	for(sint32 s=0; s<ppcImlGenContext.segmentListCount; s++)
-	{
-		PPCRecImlSegment_t* imlSegment = ppcImlGenContext.segmentList[s];
-		if( imlSegment->ppcAddrMin == 0 )
-			continue;
-		// count number of PPC instructions in segment
-		// note: This algorithm correctly counts inlined functions but it doesn't count NO-OP instructions like ISYNC
-		uint32 lastPPCInstAddr = 0;
-		uint32 ppcCount2 = 0;
-		for (sint32 i = 0; i < imlSegment->imlListCount; i++)
-		{
-			if (imlSegment->imlList[i].associatedPPCAddress == 0)
-				continue;
-			if (imlSegment->imlList[i].associatedPPCAddress == lastPPCInstAddr)
-				continue;
-			lastPPCInstAddr = imlSegment->imlList[i].associatedPPCAddress;
-			ppcCount2++;
-		}
-		//uint32 ppcCount = imlSegment->ppcAddrMax-imlSegment->ppcAddrMin+4; -> No longer works with inlined functions
-		uint32 cycleCount = ppcCount2;// ppcCount / 4;
-		if( cycleCount > 0 )
-		{
-			PPCRecompiler_pushBackIMLInstructions(imlSegment, 0, 1);
-			imlSegment->imlList[0].type = PPCREC_IML_TYPE_MACRO;
-			imlSegment->imlList[0].crRegister = PPC_REC_INVALID_REGISTER;
-			imlSegment->imlList[0].operation = PPCREC_IML_MACRO_COUNT_CYCLES;
-			imlSegment->imlList[0].op_macro.param = cycleCount;
-		}
-	}
-
-	// find segments that have a (conditional) jump instruction that points in reverse direction of code flow
-	// for these segments there is a risk that the recompiler could get trapped in an infinite busy loop. 
-	// todo: We should do a loop-detection prepass where we flag segments that are actually in a loop. We can then use this information below to avoid generating the scheduler-exit code for segments that aren't actually in a loop despite them referencing an earlier segment (which could be an exit segment for example)	
-	uint32 currentLoopEscapeJumpMarker = 0xFF000000; // start in an area where no valid code can be located
-	for(sint32 s=0; s<ppcImlGenContext.segmentListCount; s++)
-	{
-		// todo: This currently uses segment->ppcAddrMin which isn't really reliable. (We already had a problem where function inlining would generate falsified segment ranges by omitting the branch instruction). Find a better solution (use jumpmark/enterable offsets?)
-		PPCRecImlSegment_t* imlSegment = ppcImlGenContext.segmentList[s];
-		if( imlSegment->imlListCount == 0 )
-			continue;
-		if (imlSegment->imlList[imlSegment->imlListCount - 1].type != PPCREC_IML_TYPE_CJUMP || imlSegment->imlList[imlSegment->imlListCount - 1].op_conditionalJump.jumpmarkAddress > imlSegment->ppcAddrMin)
-			continue;
-		if (imlSegment->imlList[imlSegment->imlListCount - 1].type != PPCREC_IML_TYPE_CJUMP || imlSegment->imlList[imlSegment->imlListCount - 1].op_conditionalJump.jumpAccordingToSegment)
-			continue;
-		// exclude non-infinite tight loops
-		if (PPCRecompilerImlAnalyzer_isTightFiniteLoop(imlSegment))
-			continue;
-		// potential loop segment found, split this segment into four:
-		// P0: This segment checks if the remaining cycles counter is still above zero. If yes, it jumps to segment P2 (it's also the jump destination for other segments)
-		// P1: This segment consists only of a single ppc_leave instruction and is usually skipped. Register unload instructions are later inserted here.
-		// P2: This segment contains the iml instructions of the original segment
-		// PEntry: This segment is used to enter the function, it jumps to P0
-		// All segments are considered to be part of the same PPC instruction range
-		// The first segment also retains the jump destination and enterable properties from the original segment.
-		//debug_printf("--- Insert cycle counter check ---\n");
-		//PPCRecompiler_dumpIML(ppcRecFunc, &ppcImlGenContext);
-
-		PPCRecompilerIml_insertSegments(&ppcImlGenContext, s, 2);
-		imlSegment = NULL;
-		PPCRecImlSegment_t* imlSegmentP0 = ppcImlGenContext.segmentList[s+0];
-		PPCRecImlSegment_t* imlSegmentP1 = ppcImlGenContext.segmentList[s+1];
-		PPCRecImlSegment_t* imlSegmentP2 = ppcImlGenContext.segmentList[s+2];
-		// create entry point segment
-		PPCRecompilerIml_insertSegments(&ppcImlGenContext, ppcImlGenContext.segmentListCount, 1);
-		PPCRecImlSegment_t* imlSegmentPEntry = ppcImlGenContext.segmentList[ppcImlGenContext.segmentListCount-1];
-		// relink segments	
-		PPCRecompilerIML_relinkInputSegment(imlSegmentP2, imlSegmentP0);
-		PPCRecompilerIml_setLinkBranchNotTaken(imlSegmentP0, imlSegmentP1);
-		PPCRecompilerIml_setLinkBranchTaken(imlSegmentP0, imlSegmentP2);
-		PPCRecompilerIml_setLinkBranchTaken(imlSegmentPEntry, imlSegmentP0);
-		// update segments
-		uint32 enterPPCAddress = imlSegmentP2->ppcAddrMin;
-		if (imlSegmentP2->isEnterable)
-			enterPPCAddress = imlSegmentP2->enterPPCAddress;
-		imlSegmentP0->ppcAddress = 0xFFFFFFFF;
-		imlSegmentP1->ppcAddress = 0xFFFFFFFF;
-		imlSegmentP2->ppcAddress = 0xFFFFFFFF;
-		cemu_assert_debug(imlSegmentP2->ppcAddrMin != 0);
-		// move segment properties from segment P2 to segment P0
-		imlSegmentP0->isJumpDestination = imlSegmentP2->isJumpDestination;
-		imlSegmentP0->jumpDestinationPPCAddress = imlSegmentP2->jumpDestinationPPCAddress;
-		imlSegmentP0->isEnterable = false;
-		//imlSegmentP0->enterPPCAddress = imlSegmentP2->enterPPCAddress;
-		imlSegmentP0->ppcAddrMin = imlSegmentP2->ppcAddrMin;
-		imlSegmentP0->ppcAddrMax = imlSegmentP2->ppcAddrMax;
-		imlSegmentP2->isJumpDestination = false;
-		imlSegmentP2->jumpDestinationPPCAddress = 0;
-		imlSegmentP2->isEnterable = false;
-		imlSegmentP2->enterPPCAddress = 0;
-		imlSegmentP2->ppcAddrMin = 0;
-		imlSegmentP2->ppcAddrMax = 0;
-		// setup enterable segment
-		if( enterPPCAddress != 0 && enterPPCAddress != 0xFFFFFFFF )
-		{
-			imlSegmentPEntry->isEnterable = true;
-			imlSegmentPEntry->ppcAddress = enterPPCAddress;
-			imlSegmentPEntry->enterPPCAddress = enterPPCAddress;
-		}
-		// assign new jumpmark to segment P2
-		imlSegmentP2->isJumpDestination = true;
-		imlSegmentP2->jumpDestinationPPCAddress = currentLoopEscapeJumpMarker;
-		currentLoopEscapeJumpMarker++;
-		// create ppc_leave instruction in segment P1
-		PPCRecompiler_pushBackIMLInstructions(imlSegmentP1, 0, 1);
-		imlSegmentP1->imlList[0].type = PPCREC_IML_TYPE_MACRO;
-		imlSegmentP1->imlList[0].operation = PPCREC_IML_MACRO_LEAVE;
-		imlSegmentP1->imlList[0].crRegister = PPC_REC_INVALID_REGISTER;
-		imlSegmentP1->imlList[0].op_macro.param = imlSegmentP0->ppcAddrMin;
-		imlSegmentP1->imlList[0].associatedPPCAddress = imlSegmentP0->ppcAddrMin;
-		// create cycle-based conditional instruction in segment P0
-		PPCRecompiler_pushBackIMLInstructions(imlSegmentP0, 0, 1);
-		imlSegmentP0->imlList[0].type = PPCREC_IML_TYPE_CJUMP_CYCLE_CHECK;
-		imlSegmentP0->imlList[0].operation = 0;
-		imlSegmentP0->imlList[0].crRegister = PPC_REC_INVALID_REGISTER;
-		imlSegmentP0->imlList[0].op_conditionalJump.jumpmarkAddress = imlSegmentP2->jumpDestinationPPCAddress;
-		imlSegmentP0->imlList[0].associatedPPCAddress = imlSegmentP0->ppcAddrMin;
-		// jump instruction for PEntry
-		PPCRecompiler_pushBackIMLInstructions(imlSegmentPEntry, 0, 1);
-		PPCRecompilerImlGen_generateNewInstruction_jumpSegment(&ppcImlGenContext, imlSegmentPEntry->imlList + 0);
-
-		// skip the newly created segments
-		s += 2;
-	}
-
-	// isolate entry points from function flow (enterable segments must not be the target of any other segment)
-	// this simplifies logic during register allocation
-	PPCRecompilerIML_isolateEnterableSegments(&ppcImlGenContext);
-
-	// if GQRs can be predicted, optimize PSQ load/stores
-	PPCRecompiler_optimizePSQLoadAndStore(&ppcImlGenContext);
-
-	// count number of used registers
-	uint32 numLoadedFPRRegisters = 0;
-	for(uint32 i=0; i<255; i++)
-	{
-		if( ppcImlGenContext.mappedFPRRegister[i] )
-			numLoadedFPRRegisters++;
-	}
-
-	// insert name store instructions at the end of each segment but before branch instructions
-	for(sint32 s=0; s<ppcImlGenContext.segmentListCount; s++)
-	{
-		PPCRecImlSegment_t* imlSegment = ppcImlGenContext.segmentList[s];
-		if( ppcImlGenContext.segmentList[s]->imlListCount == 0 )
-			continue; // ignore empty segments
-		// analyze segment for register usage
-		PPCImlOptimizerUsedRegisters_t registersUsed;
-		for(sint32 i=0; i<imlSegment->imlListCount; i++)
-		{
-			PPCRecompiler_checkRegisterUsage(&ppcImlGenContext, imlSegment->imlList+i, &registersUsed);
-			//PPCRecompilerImlGen_findRegisterByMappedName(ppcImlGenContext, registersUsed.readGPR1);
-			sint32 accessedTempReg[5];
-			// intermediate FPRs
-			accessedTempReg[0] = registersUsed.readFPR1;
-			accessedTempReg[1] = registersUsed.readFPR2;
-			accessedTempReg[2] = registersUsed.readFPR3;
-			accessedTempReg[3] = registersUsed.readFPR4;
-			accessedTempReg[4] = registersUsed.writtenFPR1;
-			for(sint32 f=0; f<5; f++)
-			{
-				if( accessedTempReg[f] == -1 )
-					continue;
-				uint32 regName = ppcImlGenContext.mappedFPRRegister[accessedTempReg[f]];
-				if( regName >= PPCREC_NAME_FPR0 && regName < PPCREC_NAME_FPR0+32 )
-				{
-					imlSegment->ppcFPRUsed[regName - PPCREC_NAME_FPR0] = true;
-				}
-			}
-		}
-	}
-
-	// merge certain float load+store patterns (must happen before FPR register remapping)
-	PPCRecompiler_optimizeDirectFloatCopies(&ppcImlGenContext);
-	// delay byte swapping for certain load+store patterns
-	PPCRecompiler_optimizeDirectIntegerCopies(&ppcImlGenContext);
-
-	if (numLoadedFPRRegisters > 0)
-	{
-		if (PPCRecompiler_manageFPRRegisters(&ppcImlGenContext) == false)
-		{
-			PPCRecompiler_freeContext(&ppcImlGenContext);
-			return false;
-		}
-	}
-
-	PPCRecompilerImm_allocateRegisters(&ppcImlGenContext);
-
-	// remove redundant name load and store instructions
-	PPCRecompiler_reorderConditionModifyInstructions(&ppcImlGenContext);
-	PPCRecompiler_removeRedundantCRUpdates(&ppcImlGenContext);
 	return true;
 }
diff --git a/src/Cafe/HW/Espresso/Recompiler/PPCRecompilerImlGenFPU.cpp b/src/Cafe/HW/Espresso/Recompiler/PPCRecompilerImlGenFPU.cpp
index e30a9683..6e602b47 100644
--- a/src/Cafe/HW/Espresso/Recompiler/PPCRecompilerImlGenFPU.cpp
+++ b/src/Cafe/HW/Espresso/Recompiler/PPCRecompilerImlGenFPU.cpp
@@ -1,198 +1,85 @@
+#include "Cafe/HW/Espresso/EspressoISA.h"
 #include "../Interpreter/PPCInterpreterInternal.h"
 #include "PPCRecompiler.h"
 #include "PPCRecompilerIml.h"
 #include "Cafe/GameProfile/GameProfile.h"
+#include "IML/IML.h"
 
-bool hasSSE1Support = true;
-bool hasSSE2Support = true;
-bool hasSSE3Support = true;
-bool hasLZCNTSupport = false;
-bool hasMOVBESupport = false;
-bool hasBMI2Support = false;
-bool hasAVXSupport = false;
+ATTR_MS_ABI double frsqrte_espresso(double input);
+ATTR_MS_ABI double fres_espresso(double input);
 
-void PPCRecompilerImlGen_generateNewInstruction_fpr_r_memory(ppcImlGenContext_t* ppcImlGenContext, uint8 registerDestination, uint8 registerMemory, sint32 immS32, uint32 mode, bool switchEndian, uint8 registerGQR = PPC_REC_INVALID_REGISTER)
+IMLReg _GetRegCR(ppcImlGenContext_t* ppcImlGenContext, uint8 crReg, uint8 crBit);
+
+#define DefinePS0(name, regIndex) IMLReg name = _GetFPRRegPS0(ppcImlGenContext, regIndex);
+#define DefinePS1(name, regIndex) IMLReg name = _GetFPRRegPS1(ppcImlGenContext, regIndex);
+#define DefinePSX(name, regIndex, isPS1) IMLReg name = isPS1 ? _GetFPRRegPS1(ppcImlGenContext, regIndex) : _GetFPRRegPS0(ppcImlGenContext, regIndex);
+#define DefineTempFPR(name, index) IMLReg name = _GetFPRTemp(ppcImlGenContext, index);
+
+IMLReg _GetFPRRegPS0(ppcImlGenContext_t* ppcImlGenContext, uint32 regIndex)
 {
-	// load from memory
-	PPCRecImlInstruction_t* imlInstruction = PPCRecompilerImlGen_generateNewEmptyInstruction(ppcImlGenContext);
-	imlInstruction->type = PPCREC_IML_TYPE_FPR_LOAD;
-	imlInstruction->crRegister = PPC_REC_INVALID_REGISTER;
-	imlInstruction->operation = 0;
-	imlInstruction->op_storeLoad.registerData = registerDestination;
-	imlInstruction->op_storeLoad.registerMem = registerMemory;
-	imlInstruction->op_storeLoad.registerGQR = registerGQR;
-	imlInstruction->op_storeLoad.immS32 = immS32;
-	imlInstruction->op_storeLoad.mode = mode;
-	imlInstruction->op_storeLoad.flags2.swapEndian = switchEndian;
+	cemu_assert_debug(regIndex < 32);
+	return PPCRecompilerImlGen_LookupReg(ppcImlGenContext, PPCREC_NAME_FPR_HALF + regIndex * 2 + 0, IMLRegFormat::F64);
 }
 
-void PPCRecompilerImlGen_generateNewInstruction_fpr_r_memory_indexed(ppcImlGenContext_t* ppcImlGenContext, uint8 registerDestination, uint8 registerMemory1, uint8 registerMemory2, uint32 mode, bool switchEndian, uint8 registerGQR = PPC_REC_INVALID_REGISTER)
+IMLReg _GetFPRRegPS1(ppcImlGenContext_t* ppcImlGenContext, uint32 regIndex)
 {
-	// load from memory
-	PPCRecImlInstruction_t* imlInstruction = PPCRecompilerImlGen_generateNewEmptyInstruction(ppcImlGenContext);
-	imlInstruction->type = PPCREC_IML_TYPE_FPR_LOAD_INDEXED;
-	imlInstruction->crRegister = PPC_REC_INVALID_REGISTER;
-	imlInstruction->operation = 0;
-	imlInstruction->op_storeLoad.registerData = registerDestination;
-	imlInstruction->op_storeLoad.registerMem = registerMemory1;
-	imlInstruction->op_storeLoad.registerMem2 = registerMemory2;
-	imlInstruction->op_storeLoad.registerGQR = registerGQR;
-	imlInstruction->op_storeLoad.immS32 = 0;
-	imlInstruction->op_storeLoad.mode = mode;
-	imlInstruction->op_storeLoad.flags2.swapEndian = switchEndian;
+	cemu_assert_debug(regIndex < 32);
+	return PPCRecompilerImlGen_LookupReg(ppcImlGenContext, PPCREC_NAME_FPR_HALF + regIndex * 2 + 1, IMLRegFormat::F64);
 }
 
-void PPCRecompilerImlGen_generateNewInstruction_fpr_memory_r(ppcImlGenContext_t* ppcImlGenContext, uint8 registerSource, uint8 registerMemory, sint32 immS32, uint32 mode, bool switchEndian, uint8 registerGQR = PPC_REC_INVALID_REGISTER)
+IMLReg _GetFPRTemp(ppcImlGenContext_t* ppcImlGenContext, uint32 index)
 {
-	// store to memory
-	PPCRecImlInstruction_t* imlInstruction = PPCRecompilerImlGen_generateNewEmptyInstruction(ppcImlGenContext);
-	imlInstruction->type = PPCREC_IML_TYPE_FPR_STORE;
-	imlInstruction->crRegister = PPC_REC_INVALID_REGISTER;
-	imlInstruction->operation = 0;
-	imlInstruction->op_storeLoad.registerData = registerSource;
-	imlInstruction->op_storeLoad.registerMem = registerMemory;
-	imlInstruction->op_storeLoad.registerGQR = registerGQR;
-	imlInstruction->op_storeLoad.immS32 = immS32;
-	imlInstruction->op_storeLoad.mode = mode;
-	imlInstruction->op_storeLoad.flags2.swapEndian = switchEndian;
+	cemu_assert_debug(index < 4);
+	return PPCRecompilerImlGen_LookupReg(ppcImlGenContext, PPCREC_NAME_TEMPORARY_FPR0 + index, IMLRegFormat::F64);
 }
 
-void PPCRecompilerImlGen_generateNewInstruction_fpr_memory_r_indexed(ppcImlGenContext_t* ppcImlGenContext, uint8 registerSource, uint8 registerMemory1, uint8 registerMemory2, sint32 immS32, uint32 mode, bool switchEndian, uint8 registerGQR = 0)
+IMLReg _GetFPRReg(ppcImlGenContext_t* ppcImlGenContext, uint32 regIndex, bool selectPS1)
 {
-	// store to memory
-	PPCRecImlInstruction_t* imlInstruction = PPCRecompilerImlGen_generateNewEmptyInstruction(ppcImlGenContext);
-	imlInstruction->type = PPCREC_IML_TYPE_FPR_STORE_INDEXED;
-	imlInstruction->crRegister = PPC_REC_INVALID_REGISTER;
-	imlInstruction->operation = 0;
-	imlInstruction->op_storeLoad.registerData = registerSource;
-	imlInstruction->op_storeLoad.registerMem = registerMemory1;
-	imlInstruction->op_storeLoad.registerMem2 = registerMemory2;
-	imlInstruction->op_storeLoad.registerGQR = registerGQR;
-	imlInstruction->op_storeLoad.immS32 = immS32;
-	imlInstruction->op_storeLoad.mode = mode;
-	imlInstruction->op_storeLoad.flags2.swapEndian = switchEndian;
+	cemu_assert_debug(regIndex < 32);
+	return PPCRecompilerImlGen_LookupReg(ppcImlGenContext, PPCREC_NAME_FPR_HALF + regIndex * 2 + (selectPS1 ? 1 : 0), IMLRegFormat::F64);
 }
 
-void PPCRecompilerImlGen_generateNewInstruction_fpr_r_r(ppcImlGenContext_t* ppcImlGenContext, sint32 operation, uint8 registerResult, uint8 registerOperand, sint32 crRegister=PPC_REC_INVALID_REGISTER)
+void PPRecompilerImmGen_roundToSinglePrecision(ppcImlGenContext_t* ppcImlGenContext, IMLReg fprRegister, bool flushDenormals=false)
 {
-	// fpr OP fpr
-	PPCRecImlInstruction_t* imlInstruction = PPCRecompilerImlGen_generateNewEmptyInstruction(ppcImlGenContext);
-	imlInstruction->type = PPCREC_IML_TYPE_FPR_R_R;
-	imlInstruction->operation = operation;
-	imlInstruction->op_fpr_r_r.registerResult = registerResult;
-	imlInstruction->op_fpr_r_r.registerOperand = registerOperand;
-	imlInstruction->crRegister = crRegister;
-	imlInstruction->op_fpr_r_r.flags = 0;
-}
-
-void PPCRecompilerImlGen_generateNewInstruction_fpr_r_r_r(ppcImlGenContext_t* ppcImlGenContext, sint32 operation, uint8 registerResult, uint8 registerOperand1, uint8 registerOperand2, sint32 crRegister=PPC_REC_INVALID_REGISTER)
-{
-	// fpr = OP (fpr,fpr)
-	PPCRecImlInstruction_t* imlInstruction = PPCRecompilerImlGen_generateNewEmptyInstruction(ppcImlGenContext);
-	imlInstruction->type = PPCREC_IML_TYPE_FPR_R_R_R;
-	imlInstruction->operation = operation;
-	imlInstruction->op_fpr_r_r_r.registerResult = registerResult;
-	imlInstruction->op_fpr_r_r_r.registerOperandA = registerOperand1;
-	imlInstruction->op_fpr_r_r_r.registerOperandB = registerOperand2;
-	imlInstruction->crRegister = crRegister;
-	imlInstruction->op_fpr_r_r_r.flags = 0;
-}
-
-void PPCRecompilerImlGen_generateNewInstruction_fpr_r_r_r_r(ppcImlGenContext_t* ppcImlGenContext, sint32 operation, uint8 registerResult, uint8 registerOperandA, uint8 registerOperandB, uint8 registerOperandC, sint32 crRegister=PPC_REC_INVALID_REGISTER)
-{
-	// fpr = OP (fpr,fpr,fpr)
-	PPCRecImlInstruction_t* imlInstruction = PPCRecompilerImlGen_generateNewEmptyInstruction(ppcImlGenContext);
-	imlInstruction->type = PPCREC_IML_TYPE_FPR_R_R_R_R;
-	imlInstruction->operation = operation;
-	imlInstruction->op_fpr_r_r_r_r.registerResult = registerResult;
-	imlInstruction->op_fpr_r_r_r_r.registerOperandA = registerOperandA;
-	imlInstruction->op_fpr_r_r_r_r.registerOperandB = registerOperandB;
-	imlInstruction->op_fpr_r_r_r_r.registerOperandC = registerOperandC;
-	imlInstruction->crRegister = crRegister;
-	imlInstruction->op_fpr_r_r_r_r.flags = 0;
-}
-
-void PPCRecompilerImlGen_generateNewInstruction_fpr_r(ppcImlGenContext_t* ppcImlGenContext, PPCRecImlInstruction_t* imlInstruction, sint32 operation, uint8 registerResult, sint32 crRegister)
-{
-	// OP (fpr)
-	if(imlInstruction == NULL)
-		imlInstruction = PPCRecompilerImlGen_generateNewEmptyInstruction(ppcImlGenContext);
-	imlInstruction->type = PPCREC_IML_TYPE_FPR_R;
-	imlInstruction->operation = operation;
-	imlInstruction->op_fpr_r.registerResult = registerResult;
-	imlInstruction->crRegister = crRegister;
-}
-
-/*
- * Rounds the bottom double to single precision (if single precision accuracy is emulated)
- */
-void PPRecompilerImmGen_optionalRoundBottomFPRToSinglePrecision(ppcImlGenContext_t* ppcImlGenContext, uint32 fprRegister, bool flushDenormals=false)
-{
-	PPCRecompilerImlGen_generateNewInstruction_fpr_r(ppcImlGenContext, NULL, PPCREC_IML_OP_FPR_ROUND_TO_SINGLE_PRECISION_BOTTOM, fprRegister);
+	ppcImlGenContext->emitInst().make_fpr_r(PPCREC_IML_OP_FPR_ROUND_TO_SINGLE_PRECISION_BOTTOM, fprRegister);
 	if( flushDenormals )
 		assert_dbg();
 }
 
-/*
- * Rounds pair of doubles to single precision (if single precision accuracy is emulated)
- */
-void PPRecompilerImmGen_optionalRoundPairFPRToSinglePrecision(ppcImlGenContext_t* ppcImlGenContext, uint32 fprRegister, bool flushDenormals=false)
+bool PPCRecompilerImlGen_LFS_LFSU_LFD_LFDU(ppcImlGenContext_t* ppcImlGenContext, uint32 opcode, bool withUpdate, bool isDouble)
 {
-	PPCRecompilerImlGen_generateNewInstruction_fpr_r(ppcImlGenContext, NULL, PPCREC_IML_OP_FPR_ROUND_TO_SINGLE_PRECISION_PAIR, fprRegister);
-	if( flushDenormals )
-		assert_dbg();
-}
-
-bool PPCRecompilerImlGen_LFS(ppcImlGenContext_t* ppcImlGenContext, uint32 opcode)
-{
-	if( hasSSE1Support == false )
-		return false;
 	sint32 rA, frD;
 	uint32 imm;
 	PPC_OPC_TEMPL_D_SImm(opcode, frD, rA, imm);
-	// get memory gpr register index
-	uint32 gprRegister = PPCRecompilerImlGen_loadRegister(ppcImlGenContext, PPCREC_NAME_R0+rA, false);
-	// get fpr register index
-	uint32 fprRegister = PPCRecompilerImlGen_loadOverwriteFPRRegister(ppcImlGenContext, PPCREC_NAME_FPR0+frD);
-	if( ppcImlGenContext->LSQE )
+	IMLReg gprRegister = PPCRecompilerImlGen_loadRegister(ppcImlGenContext, PPCREC_NAME_R0+rA);
+	if (withUpdate)
 	{
-		PPCRecompilerImlGen_generateNewInstruction_fpr_r_memory(ppcImlGenContext, fprRegister, gprRegister, imm, PPCREC_FPR_LD_MODE_SINGLE_INTO_PS0_PS1, true);
+		// add imm to memory register
+		cemu_assert_debug(rA != 0);
+		ppcImlGenContext->emitInst().make_r_r_s32(PPCREC_IML_OP_ADD, gprRegister, gprRegister, (sint32)imm);
+		imm = 0; // set imm to 0 so we dont add it twice
+	}
+	DefinePS0(fpPs0, frD);
+	if (isDouble)
+	{
+		// LFD/LFDU
+		ppcImlGenContext->emitInst().make_fpr_r_memory(fpPs0, gprRegister, imm, PPCREC_FPR_LD_MODE_DOUBLE, true);
 	}
 	else
 	{
-		PPCRecompilerImlGen_generateNewInstruction_fpr_r_memory(ppcImlGenContext, fprRegister, gprRegister, imm, PPCREC_FPR_LD_MODE_SINGLE_INTO_PS0, true);
+		// LFS/LFSU
+		ppcImlGenContext->emitInst().make_fpr_r_memory(fpPs0, gprRegister, imm, PPCREC_FPR_LD_MODE_SINGLE, true);
+		if( ppcImlGenContext->LSQE )
+		{
+			DefinePS1(fpPs1, frD);
+			ppcImlGenContext->emitInst().make_fpr_r_r(PPCREC_IML_OP_FPR_ASSIGN, fpPs1, fpPs0);
+		}
 	}
 	return true;
 }
 
-bool PPCRecompilerImlGen_LFSU(ppcImlGenContext_t* ppcImlGenContext, uint32 opcode)
+bool PPCRecompilerImlGen_LFSX_LFSUX_LFDX_LFDUX(ppcImlGenContext_t* ppcImlGenContext, uint32 opcode, bool withUpdate, bool isDouble)
 {
-	if( hasSSE1Support == false )
-		return false;
-	sint32 rA, frD;
-	uint32 imm;
-	PPC_OPC_TEMPL_D_SImm(opcode, frD, rA, imm);
-	// get memory gpr register index
-	uint32 gprRegister = PPCRecompilerImlGen_loadRegister(ppcImlGenContext, PPCREC_NAME_R0+rA, false);
-	// add imm to memory register
-	PPCRecompilerImlGen_generateNewInstruction_r_s32(ppcImlGenContext, PPCREC_IML_OP_ADD, gprRegister, (sint32)imm, 0, false, false, PPC_REC_INVALID_REGISTER, 0);
-	// get fpr register index
-	uint32 fprRegister = PPCRecompilerImlGen_loadOverwriteFPRRegister(ppcImlGenContext, PPCREC_NAME_FPR0+frD);
-	if( ppcImlGenContext->LSQE )
-	{
-		PPCRecompilerImlGen_generateNewInstruction_fpr_r_memory(ppcImlGenContext, fprRegister, gprRegister, 0, PPCREC_FPR_LD_MODE_SINGLE_INTO_PS0_PS1, true);
-	}
-	else
-	{
-		PPCRecompilerImlGen_generateNewInstruction_fpr_r_memory(ppcImlGenContext, fprRegister, gprRegister, 0, PPCREC_FPR_LD_MODE_SINGLE_INTO_PS0, true);
-	}
-	return true;
-}
-
-bool PPCRecompilerImlGen_LFSX(ppcImlGenContext_t* ppcImlGenContext, uint32 opcode)
-{
-	if( hasSSE2Support == false )
-		return false;
 	sint32 rA, frD, rB;
 	PPC_OPC_TEMPL_X(opcode, frD, rA, rB);
 	if( rA == 0 )
@@ -201,171 +88,54 @@ bool PPCRecompilerImlGen_LFSX(ppcImlGenContext_t* ppcImlGenContext, uint32 opcod
 		return false;
 	}
 	// get memory gpr registers
-	uint32 gprRegister1 = PPCRecompilerImlGen_loadRegister(ppcImlGenContext, PPCREC_NAME_R0+rA, false);
-	uint32 gprRegister2 = PPCRecompilerImlGen_loadRegister(ppcImlGenContext, PPCREC_NAME_R0+rB, false);
-	// get fpr register index
-	uint32 fprRegister = PPCRecompilerImlGen_loadOverwriteFPRRegister(ppcImlGenContext, PPCREC_NAME_FPR0+frD);
-	if( ppcImlGenContext->LSQE )
+	IMLReg gprRegister1 = PPCRecompilerImlGen_loadRegister(ppcImlGenContext, PPCREC_NAME_R0+rA);
+	IMLReg gprRegister2 = PPCRecompilerImlGen_loadRegister(ppcImlGenContext, PPCREC_NAME_R0+rB);
+	if (withUpdate)
+		ppcImlGenContext->emitInst().make_r_r_r(PPCREC_IML_OP_ADD, gprRegister1, gprRegister1, gprRegister2);
+	DefinePS0(fpPs0, frD);
+	if (isDouble)
 	{
-		PPCRecompilerImlGen_generateNewInstruction_fpr_r_memory_indexed(ppcImlGenContext, fprRegister, gprRegister1, gprRegister2, PPCREC_FPR_LD_MODE_SINGLE_INTO_PS0_PS1, true);
+		if (withUpdate)
+			ppcImlGenContext->emitInst().make_fpr_r_memory(fpPs0, gprRegister1, 0, PPCREC_FPR_LD_MODE_DOUBLE, true);
+		else
+			ppcImlGenContext->emitInst().make_fpr_r_memory_indexed(fpPs0, gprRegister1, gprRegister2, PPCREC_FPR_LD_MODE_DOUBLE, true);
 	}
 	else
 	{
-		PPCRecompilerImlGen_generateNewInstruction_fpr_r_memory_indexed(ppcImlGenContext, fprRegister, gprRegister1, gprRegister2, PPCREC_FPR_LD_MODE_SINGLE_INTO_PS0, true);
+		if (withUpdate)
+			ppcImlGenContext->emitInst().make_fpr_r_memory( fpPs0, gprRegister1, 0, PPCREC_FPR_LD_MODE_SINGLE, true);
+		else
+			ppcImlGenContext->emitInst().make_fpr_r_memory_indexed( fpPs0, gprRegister1, gprRegister2, PPCREC_FPR_LD_MODE_SINGLE, true);
+		if( ppcImlGenContext->LSQE )
+		{
+			DefinePS1(fpPs1, frD);
+			ppcImlGenContext->emitInst().make_fpr_r_r(PPCREC_IML_OP_FPR_ASSIGN, fpPs1, fpPs0);
+		}
 	}
 	return true;
 }
 
-bool PPCRecompilerImlGen_LFSUX(ppcImlGenContext_t* ppcImlGenContext, uint32 opcode)
+bool PPCRecompilerImlGen_STFS_STFSU_STFD_STFDU(ppcImlGenContext_t* ppcImlGenContext, uint32 opcode, bool withUpdate, bool isDouble)
 {
-	if( hasSSE2Support == false )
-		return false;
-	sint32 rA, frD, rB;
-	PPC_OPC_TEMPL_X(opcode, frD, rA, rB);
-	if( rA == 0 )
+	sint32 rA, frD;
+	uint32 imm;
+	PPC_OPC_TEMPL_D_SImm(opcode, frD, rA, imm);
+	IMLReg gprRegister = PPCRecompilerImlGen_loadRegister(ppcImlGenContext, PPCREC_NAME_R0+rA);
+	DefinePS0(fpPs0, frD);
+	if (withUpdate)
 	{
-		debugBreakpoint();
-		return false;
-	}
-	// get memory gpr registers
-	uint32 gprRegister1 = PPCRecompilerImlGen_loadRegister(ppcImlGenContext, PPCREC_NAME_R0+rA, false);
-	uint32 gprRegister2 = PPCRecompilerImlGen_loadRegister(ppcImlGenContext, PPCREC_NAME_R0+rB, false);
-	// add rB to rA (if rA != 0)
-	PPCRecompilerImlGen_generateNewInstruction_r_r(ppcImlGenContext, NULL, PPCREC_IML_OP_ADD, gprRegister1, gprRegister2);
-	// get fpr register index
-	uint32 fprRegister = PPCRecompilerImlGen_loadOverwriteFPRRegister(ppcImlGenContext, PPCREC_NAME_FPR0+frD);
-	if( ppcImlGenContext->LSQE )
-	{
-		PPCRecompilerImlGen_generateNewInstruction_fpr_r_memory(ppcImlGenContext, fprRegister, gprRegister1, 0, PPCREC_FPR_LD_MODE_SINGLE_INTO_PS0_PS1, true);
+		ppcImlGenContext->emitInst().make_r_r_s32(PPCREC_IML_OP_ADD, gprRegister, gprRegister, (sint32)imm);
+		imm = 0;
 	}
+	if (isDouble)
+		ppcImlGenContext->emitInst().make_fpr_memory_r(fpPs0, gprRegister, imm, PPCREC_FPR_ST_MODE_DOUBLE, true);
 	else
-	{
-		PPCRecompilerImlGen_generateNewInstruction_fpr_r_memory(ppcImlGenContext, fprRegister, gprRegister1, 0, PPCREC_FPR_LD_MODE_SINGLE_INTO_PS0, true);
-	}
+		ppcImlGenContext->emitInst().make_fpr_memory_r(fpPs0, gprRegister, imm, PPCREC_FPR_ST_MODE_SINGLE, true);
 	return true;
 }
 
-bool PPCRecompilerImlGen_LFD(ppcImlGenContext_t* ppcImlGenContext, uint32 opcode)
+bool PPCRecompilerImlGen_STFSX_STFSUX_STFDX_STFDUX(ppcImlGenContext_t* ppcImlGenContext, uint32 opcode, bool hasUpdate, bool isDouble)
 {
-	if( hasSSE1Support == false )
-		return false;
-	sint32 rA, frD;
-	uint32 imm;
-	PPC_OPC_TEMPL_D_SImm(opcode, frD, rA, imm);
-	if( rA == 0 )
-	{
-		assert_dbg();
-	}
-	// get memory gpr register index
-	uint32 gprRegister = PPCRecompilerImlGen_loadRegister(ppcImlGenContext, PPCREC_NAME_R0+rA, false);
-	// get fpr register index
-	uint32 fprRegister = PPCRecompilerImlGen_loadOverwriteFPRRegister(ppcImlGenContext, PPCREC_NAME_FPR0+frD);
-	PPCRecompilerImlGen_generateNewInstruction_fpr_r_memory(ppcImlGenContext, fprRegister, gprRegister, imm, PPCREC_FPR_LD_MODE_DOUBLE_INTO_PS0, true);
-	return true;
-}
-
-bool PPCRecompilerImlGen_LFDU(ppcImlGenContext_t* ppcImlGenContext, uint32 opcode)
-{
-	if( hasSSE1Support == false )
-		return false;
-	sint32 rA, frD;
-	uint32 imm;
-	PPC_OPC_TEMPL_D_SImm(opcode, frD, rA, imm);
-	if( rA == 0 )
-	{
-		assert_dbg();
-	}
-	// get memory gpr register index
-	uint32 gprRegister = PPCRecompilerImlGen_loadRegister(ppcImlGenContext, PPCREC_NAME_R0+rA, false);
-	// add imm to memory register
-	PPCRecompilerImlGen_generateNewInstruction_r_s32(ppcImlGenContext, PPCREC_IML_OP_ADD, gprRegister, (sint32)imm, 0, false, false, PPC_REC_INVALID_REGISTER, 0);
-	// get fpr register index
-	uint32 fprRegister = PPCRecompilerImlGen_loadOverwriteFPRRegister(ppcImlGenContext, PPCREC_NAME_FPR0+frD);
-	// emit load iml
-	PPCRecompilerImlGen_generateNewInstruction_fpr_r_memory(ppcImlGenContext, fprRegister, gprRegister, 0, PPCREC_FPR_LD_MODE_DOUBLE_INTO_PS0, true);
-	return true;
-}
-
-bool PPCRecompilerImlGen_LFDX(ppcImlGenContext_t* ppcImlGenContext, uint32 opcode)
-{
-	if( hasSSE2Support == false )
-		return false;
-	sint32 rA, frD, rB;
-	PPC_OPC_TEMPL_X(opcode, frD, rA, rB);
-	if( rA == 0 )
-	{
-		debugBreakpoint();
-		return false;
-	}
-	// get memory gpr registers
-	uint32 gprRegister1 = PPCRecompilerImlGen_loadRegister(ppcImlGenContext, PPCREC_NAME_R0+rA, false);
-	uint32 gprRegister2 = PPCRecompilerImlGen_loadRegister(ppcImlGenContext, PPCREC_NAME_R0+rB, false);
-	// get fpr register index
-	uint32 fprRegister = PPCRecompilerImlGen_loadOverwriteFPRRegister(ppcImlGenContext, PPCREC_NAME_FPR0+frD);
-	PPCRecompilerImlGen_generateNewInstruction_fpr_r_memory_indexed(ppcImlGenContext, fprRegister, gprRegister1, gprRegister2, PPCREC_FPR_LD_MODE_DOUBLE_INTO_PS0, true);
-	return true;
-}
-
-bool PPCRecompilerImlGen_LFDUX(ppcImlGenContext_t* ppcImlGenContext, uint32 opcode)
-{
-	if( hasSSE2Support == false )
-		return false;
-	sint32 rA, frD, rB;
-	PPC_OPC_TEMPL_X(opcode, frD, rA, rB);
-	if( rA == 0 )
-	{
-		debugBreakpoint();
-		return false;
-	}
-	// get memory gpr registers
-	uint32 gprRegister1 = PPCRecompilerImlGen_loadRegister(ppcImlGenContext, PPCREC_NAME_R0+rA, false);
-	uint32 gprRegister2 = PPCRecompilerImlGen_loadRegister(ppcImlGenContext, PPCREC_NAME_R0+rB, false);
-	// add rB to rA (if rA != 0)
-	PPCRecompilerImlGen_generateNewInstruction_r_r(ppcImlGenContext, NULL, PPCREC_IML_OP_ADD, gprRegister1, gprRegister2);
-	// get fpr register index
-	uint32 fprRegister = PPCRecompilerImlGen_loadOverwriteFPRRegister(ppcImlGenContext, PPCREC_NAME_FPR0+frD);
-	PPCRecompilerImlGen_generateNewInstruction_fpr_r_memory(ppcImlGenContext, fprRegister, gprRegister1, 0, PPCREC_FPR_LD_MODE_DOUBLE_INTO_PS0, true);
-	return true;
-}
-
-bool PPCRecompilerImlGen_STFS(ppcImlGenContext_t* ppcImlGenContext, uint32 opcode)
-{
-	if( hasSSE1Support == false )
-		return false;
-	sint32 rA, frD;
-	uint32 imm;
-	PPC_OPC_TEMPL_D_SImm(opcode, frD, rA, imm);
-	// get memory gpr register index
-	uint32 gprRegister = PPCRecompilerImlGen_loadRegister(ppcImlGenContext, PPCREC_NAME_R0+rA, false);
-	// get fpr register index
-	uint32 fprRegister = PPCRecompilerImlGen_loadFPRRegister(ppcImlGenContext, PPCREC_NAME_FPR0+frD);
-
-	PPCRecompilerImlGen_generateNewInstruction_fpr_memory_r(ppcImlGenContext, fprRegister, gprRegister, imm, PPCREC_FPR_ST_MODE_SINGLE_FROM_PS0, true);
-	return true;
-}
-
-bool PPCRecompilerImlGen_STFSU(ppcImlGenContext_t* ppcImlGenContext, uint32 opcode)
-{
-	if( hasSSE1Support == false )
-		return false;
-	sint32 rA, frD;
-	uint32 imm;
-	PPC_OPC_TEMPL_D_SImm(opcode, frD, rA, imm);
-	// get memory gpr register index
-	uint32 gprRegister = PPCRecompilerImlGen_loadRegister(ppcImlGenContext, PPCREC_NAME_R0+rA, false);
-	// add imm to memory register
-	PPCRecompilerImlGen_generateNewInstruction_r_s32(ppcImlGenContext, PPCREC_IML_OP_ADD, gprRegister, (sint32)imm, 0, false, false, PPC_REC_INVALID_REGISTER, 0);
-	// get fpr register index
-	uint32 fprRegister = PPCRecompilerImlGen_loadFPRRegister(ppcImlGenContext, PPCREC_NAME_FPR0+frD);
-
-	PPCRecompilerImlGen_generateNewInstruction_fpr_memory_r(ppcImlGenContext, fprRegister, gprRegister, 0, PPCREC_FPR_ST_MODE_SINGLE_FROM_PS0, true);
-	return true;
-}
-
-bool PPCRecompilerImlGen_STFSX(ppcImlGenContext_t* ppcImlGenContext, uint32 opcode)
-{
-	if( hasSSE2Support == false )
-		return false;
 	sint32 rA, frS, rB;
 	PPC_OPC_TEMPL_X(opcode, frS, rA, rB);
 	if( rA == 0 )
@@ -374,141 +144,53 @@ bool PPCRecompilerImlGen_STFSX(ppcImlGenContext_t* ppcImlGenContext, uint32 opco
 		return false;
 	}
 	// get memory gpr registers
-	uint32 gprRegister1 = PPCRecompilerImlGen_loadRegister(ppcImlGenContext, PPCREC_NAME_R0+rA, false);
-	uint32 gprRegister2 = PPCRecompilerImlGen_loadRegister(ppcImlGenContext, PPCREC_NAME_R0+rB, false);
-	// get fpr register index
-	uint32 fprRegister = PPCRecompilerImlGen_loadFPRRegister(ppcImlGenContext, PPCREC_NAME_FPR0+frS);
+	IMLReg gprRegister1 = PPCRecompilerImlGen_loadRegister(ppcImlGenContext, PPCREC_NAME_R0+rA);
+	IMLReg gprRegister2 = PPCRecompilerImlGen_loadRegister(ppcImlGenContext, PPCREC_NAME_R0+rB);
+	if (hasUpdate)
+	{
+		ppcImlGenContext->emitInst().make_r_r_r(PPCREC_IML_OP_ADD, gprRegister1, gprRegister1, gprRegister2);
+	}
+	DefinePS0(fpPs0, frS);
+	auto mode = isDouble ? PPCREC_FPR_ST_MODE_DOUBLE : PPCREC_FPR_ST_MODE_SINGLE;
 	if( ppcImlGenContext->LSQE )
 	{
-		PPCRecompilerImlGen_generateNewInstruction_fpr_memory_r_indexed(ppcImlGenContext, fprRegister, gprRegister1, gprRegister2, 0, PPCREC_FPR_ST_MODE_SINGLE_FROM_PS0, true);
+		if (hasUpdate)
+			ppcImlGenContext->emitInst().make_fpr_memory_r(fpPs0, gprRegister1, 0, mode, true);
+		else
+			ppcImlGenContext->emitInst().make_fpr_memory_r_indexed(fpPs0, gprRegister1, gprRegister2, 0, mode, true);
 	}
 	else
 	{
-		PPCRecompilerImlGen_generateNewInstruction_fpr_memory_r_indexed(ppcImlGenContext, fprRegister, gprRegister1, gprRegister2, 0, PPCREC_FPR_ST_MODE_SINGLE_FROM_PS0, true);
-	}
-	return true;
-}
-
-
-bool PPCRecompilerImlGen_STFSUX(ppcImlGenContext_t* ppcImlGenContext, uint32 opcode)
-{
-	if( hasSSE2Support == false )
-		return false;
-	sint32 rA, frS, rB;
-	PPC_OPC_TEMPL_X(opcode, frS, rA, rB);
-	if( rA == 0 )
-	{
-		debugBreakpoint();
-		return false;
-	}
-	// get memory gpr registers
-	uint32 gprRegister1 = PPCRecompilerImlGen_loadRegister(ppcImlGenContext, PPCREC_NAME_R0+rA, false);
-	uint32 gprRegister2 = PPCRecompilerImlGen_loadRegister(ppcImlGenContext, PPCREC_NAME_R0+rB, false);
-	// get fpr register index
-	uint32 fprRegister = PPCRecompilerImlGen_loadFPRRegister(ppcImlGenContext, PPCREC_NAME_FPR0+frS);
-	// calculate EA in rA
-	PPCRecompilerImlGen_generateNewInstruction_r_r(ppcImlGenContext, NULL, PPCREC_IML_OP_ADD, gprRegister1, gprRegister2);
-
-	PPCRecompilerImlGen_generateNewInstruction_fpr_memory_r(ppcImlGenContext, fprRegister, gprRegister1, 0, PPCREC_FPR_ST_MODE_SINGLE_FROM_PS0, true);
-	return true;
-}
-
-bool PPCRecompilerImlGen_STFD(ppcImlGenContext_t* ppcImlGenContext, uint32 opcode)
-{
-	if( hasSSE1Support == false )
-		return false;
-	sint32 rA, frD;
-	uint32 imm;
-	PPC_OPC_TEMPL_D_SImm(opcode, frD, rA, imm);
-	if( rA == 0 )
-	{
-		debugBreakpoint();
-		return false;
-	}
-	// get memory gpr register index
-	uint32 gprRegister = PPCRecompilerImlGen_loadRegister(ppcImlGenContext, PPCREC_NAME_R0+rA, false);
-	// get fpr register index
-	uint32 fprRegister = PPCRecompilerImlGen_loadOverwriteFPRRegister(ppcImlGenContext, PPCREC_NAME_FPR0+frD);
-	PPCRecompilerImlGen_generateNewInstruction_fpr_memory_r(ppcImlGenContext, fprRegister, gprRegister, imm, PPCREC_FPR_ST_MODE_DOUBLE_FROM_PS0, true);
-	return true;
-}
-
-bool PPCRecompilerImlGen_STFDU(ppcImlGenContext_t* ppcImlGenContext, uint32 opcode)
-{
-	if( hasSSE1Support == false )
-		return false;
-	sint32 rA, frD;
-	uint32 imm;
-	PPC_OPC_TEMPL_D_SImm(opcode, frD, rA, imm);
-	if( rA == 0 )
-	{
-		debugBreakpoint();
-		return false;
-	}
-	// get memory gpr register index
-	uint32 gprRegister = PPCRecompilerImlGen_loadRegister(ppcImlGenContext, PPCREC_NAME_R0+rA, false);
-	// add imm to memory register
-	PPCRecompilerImlGen_generateNewInstruction_r_s32(ppcImlGenContext, PPCREC_IML_OP_ADD, gprRegister, (sint32)imm, 0, false, false, PPC_REC_INVALID_REGISTER, 0);
-	// get fpr register index
-	uint32 fprRegister = PPCRecompilerImlGen_loadOverwriteFPRRegister(ppcImlGenContext, PPCREC_NAME_FPR0+frD);
-
-	PPCRecompilerImlGen_generateNewInstruction_fpr_memory_r(ppcImlGenContext, fprRegister, gprRegister, 0, PPCREC_FPR_ST_MODE_DOUBLE_FROM_PS0, true);
-	return true;
-}
-
-bool PPCRecompilerImlGen_STFDX(ppcImlGenContext_t* ppcImlGenContext, uint32 opcode)
-{
-	if( hasSSE2Support == false )
-		return false;
-	sint32 rA, frS, rB;
-	PPC_OPC_TEMPL_X(opcode, frS, rA, rB);
-	if( rA == 0 )
-	{
-		debugBreakpoint();
-		return false;
-	}
-	// get memory gpr registers
-	uint32 gprRegister1 = PPCRecompilerImlGen_loadRegister(ppcImlGenContext, PPCREC_NAME_R0+rA, false);
-	uint32 gprRegister2 = PPCRecompilerImlGen_loadRegister(ppcImlGenContext, PPCREC_NAME_R0+rB, false);
-	// get fpr register index
-	uint32 fprRegister = PPCRecompilerImlGen_loadFPRRegister(ppcImlGenContext, PPCREC_NAME_FPR0+frS);
-	if( ppcImlGenContext->LSQE )
-	{
-		PPCRecompilerImlGen_generateNewInstruction_fpr_memory_r_indexed(ppcImlGenContext, fprRegister, gprRegister1, gprRegister2, 0, PPCREC_FPR_ST_MODE_DOUBLE_FROM_PS0, true);
-	}
-	else
-	{
-		PPCRecompilerImlGen_generateNewInstruction_fpr_memory_r_indexed(ppcImlGenContext, fprRegister, gprRegister1, gprRegister2, 0, PPCREC_FPR_ST_MODE_DOUBLE_FROM_PS0, true);
+		if (hasUpdate)
+			ppcImlGenContext->emitInst().make_fpr_memory_r(fpPs0, gprRegister1, 0, mode, true);
+		else
+			ppcImlGenContext->emitInst().make_fpr_memory_r_indexed(fpPs0, gprRegister1, gprRegister2, 0, mode, true);
 	}
 	return true;
 }
 
 bool PPCRecompilerImlGen_STFIWX(ppcImlGenContext_t* ppcImlGenContext, uint32 opcode)
 {
-	if( hasSSE2Support == false )
-		return false;
 	sint32 rA, frS, rB;
 	PPC_OPC_TEMPL_X(opcode, frS, rA, rB);
-	// get memory gpr registers
-	uint32 gprRegister1;
-	uint32 gprRegister2;
+	DefinePS0(fpPs0, frS);
+	IMLReg gprRegister1;
+	IMLReg gprRegister2;
 	if( rA != 0 )
 	{
-		gprRegister1 = PPCRecompilerImlGen_loadRegister(ppcImlGenContext, PPCREC_NAME_R0+rA, false);
-		gprRegister2 = PPCRecompilerImlGen_loadRegister(ppcImlGenContext, PPCREC_NAME_R0+rB, false);
+		gprRegister1 = PPCRecompilerImlGen_loadRegister(ppcImlGenContext, PPCREC_NAME_R0+rA);
+		gprRegister2 = PPCRecompilerImlGen_loadRegister(ppcImlGenContext, PPCREC_NAME_R0+rB);
 	}
 	else
 	{
 		// rA is not used
-		gprRegister1 = PPCRecompilerImlGen_loadRegister(ppcImlGenContext, PPCREC_NAME_R0+rB, false);
-		gprRegister2 = 0;
+		gprRegister1 = PPCRecompilerImlGen_loadRegister(ppcImlGenContext, PPCREC_NAME_R0+rB);
+		gprRegister2 = IMLREG_INVALID;
 	}
-	// get fpr register index
-	uint32 fprRegister = PPCRecompilerImlGen_loadFPRRegister(ppcImlGenContext, PPCREC_NAME_FPR0+frS);
 	if( rA != 0 )
-		PPCRecompilerImlGen_generateNewInstruction_fpr_memory_r_indexed(ppcImlGenContext, fprRegister, gprRegister1, gprRegister2, 0, PPCREC_FPR_ST_MODE_UI32_FROM_PS0, true);
+		ppcImlGenContext->emitInst().make_fpr_memory_r_indexed(fpPs0, gprRegister1, gprRegister2, 0, PPCREC_FPR_ST_MODE_UI32_FROM_PS0, true);
 	else
-		PPCRecompilerImlGen_generateNewInstruction_fpr_memory_r(ppcImlGenContext, fprRegister, gprRegister1, 0, PPCREC_FPR_ST_MODE_UI32_FROM_PS0, true);
+		ppcImlGenContext->emitInst().make_fpr_memory_r(fpPs0, gprRegister1, 0, PPCREC_FPR_ST_MODE_UI32_FROM_PS0, true);
 	return true;
 }
 
@@ -517,13 +199,10 @@ bool PPCRecompilerImlGen_FADD(ppcImlGenContext_t* ppcImlGenContext, uint32 opcod
 	sint32 frD, frA, frB, frC;
 	PPC_OPC_TEMPL_A(opcode, frD, frA, frB, frC);
 	PPC_ASSERT(frC==0);
-
-	// load registers
-	uint32 fprRegisterA = PPCRecompilerImlGen_loadFPRRegister(ppcImlGenContext, PPCREC_NAME_FPR0+frA);
-	uint32 fprRegisterB = PPCRecompilerImlGen_loadFPRRegister(ppcImlGenContext, PPCREC_NAME_FPR0+frB);
-	uint32 fprRegisterD = PPCRecompilerImlGen_loadOverwriteFPRRegister(ppcImlGenContext, PPCREC_NAME_FPR0+frD);
-
-	PPCRecompilerImlGen_generateNewInstruction_fpr_r_r_r(ppcImlGenContext, PPCREC_IML_OP_FPR_ADD_BOTTOM, fprRegisterD, fprRegisterA, fprRegisterB);
+	DefinePS0(fprA, frA);
+	DefinePS0(fprB, frB);
+	DefinePS0(fprD, frD);
+	ppcImlGenContext->emitInst().make_fpr_r_r_r(PPCREC_IML_OP_FPR_ADD, fprD, fprA, fprB);
 	return true;
 }
 
@@ -532,13 +211,10 @@ bool PPCRecompilerImlGen_FSUB(ppcImlGenContext_t* ppcImlGenContext, uint32 opcod
 	sint32 frD, frA, frB, frC;
 	PPC_OPC_TEMPL_A(opcode, frD, frA, frB, frC);
 	PPC_ASSERT(frC==0);
-
-	// load registers
-	uint32 fprRegisterA = PPCRecompilerImlGen_loadFPRRegister(ppcImlGenContext, PPCREC_NAME_FPR0+frA);
-	uint32 fprRegisterB = PPCRecompilerImlGen_loadFPRRegister(ppcImlGenContext, PPCREC_NAME_FPR0+frB);
-	uint32 fprRegisterD = PPCRecompilerImlGen_loadOverwriteFPRRegister(ppcImlGenContext, PPCREC_NAME_FPR0+frD);
-	// subtract bottom double of frB from bottom double of frD
-	PPCRecompilerImlGen_generateNewInstruction_fpr_r_r_r(ppcImlGenContext, PPCREC_IML_OP_FPR_SUB_BOTTOM, fprRegisterD, fprRegisterA, fprRegisterB);
+	DefinePS0(fprA, frA);
+	DefinePS0(fprB, frB);
+	DefinePS0(fprD, frD);
+	ppcImlGenContext->emitInst().make_fpr_r_r_r(PPCREC_IML_OP_FPR_SUB, fprD, fprA, fprB);
 	return true;
 }
 
@@ -553,15 +229,14 @@ bool PPCRecompilerImlGen_FMUL(ppcImlGenContext_t* ppcImlGenContext, uint32 opcod
 		frA = frC;
 		frC = temp;
 	}
-	// load registers
-	uint32 fprRegisterA = PPCRecompilerImlGen_loadFPRRegister(ppcImlGenContext, PPCREC_NAME_FPR0+frA);
-	uint32 fprRegisterC = PPCRecompilerImlGen_loadFPRRegister(ppcImlGenContext, PPCREC_NAME_FPR0+frC);
-	uint32 fprRegisterD = PPCRecompilerImlGen_loadOverwriteFPRRegister(ppcImlGenContext, PPCREC_NAME_FPR0+frD);
+	DefinePS0(fprA, frA);
+	DefinePS0(fprC, frC);
+	DefinePS0(fprD, frD);
 	// move frA to frD (if different register)
-	if( fprRegisterD != fprRegisterA )
-		PPCRecompilerImlGen_generateNewInstruction_fpr_r_r(ppcImlGenContext, PPCREC_IML_OP_ASSIGN, fprRegisterD, fprRegisterA); // always copy ps0 and ps1
+	if( frD != frA )
+		ppcImlGenContext->emitInst().make_fpr_r_r(PPCREC_IML_OP_FPR_ASSIGN, fprD, fprA);
 	// multiply bottom double of frD with bottom double of frB
-	PPCRecompilerImlGen_generateNewInstruction_fpr_r_r(ppcImlGenContext, PPCREC_IML_OP_FPR_MULTIPLY_BOTTOM, fprRegisterD, fprRegisterC);
+	ppcImlGenContext->emitInst().make_fpr_r_r(PPCREC_IML_OP_FPR_MULTIPLY, fprD, fprC);
 	return true;
 }
 
@@ -570,27 +245,25 @@ bool PPCRecompilerImlGen_FDIV(ppcImlGenContext_t* ppcImlGenContext, uint32 opcod
 	sint32 frD, frA, frB, frC_unused;
 	PPC_OPC_TEMPL_A(opcode, frD, frA, frB, frC_unused);
 	PPC_ASSERT(frB==0);
-	// load registers
-	uint32 fprRegisterA = PPCRecompilerImlGen_loadFPRRegister(ppcImlGenContext, PPCREC_NAME_FPR0+frA);
-	uint32 fprRegisterB = PPCRecompilerImlGen_loadFPRRegister(ppcImlGenContext, PPCREC_NAME_FPR0+frB);
-	uint32 fprRegisterD = PPCRecompilerImlGen_loadOverwriteFPRRegister(ppcImlGenContext, PPCREC_NAME_FPR0+frD);
-
+	DefinePS0(fprA, frA);
+	DefinePS0(fprB, frB);
+	DefinePS0(fprD, frD);
 	if( frB == frD && frA != frB )
 	{
-		uint32 fprRegisterTemp = PPCRecompilerImlGen_loadOverwriteFPRRegister(ppcImlGenContext, PPCREC_NAME_TEMPORARY_FPR0+0);
+		DefineTempFPR(fprTemp, 0);
 		// move frA to temporary register
-		PPCRecompilerImlGen_generateNewInstruction_fpr_r_r(ppcImlGenContext, PPCREC_IML_OP_ASSIGN, fprRegisterTemp, fprRegisterA);
+		ppcImlGenContext->emitInst().make_fpr_r_r(PPCREC_IML_OP_FPR_ASSIGN, fprTemp, fprA);
 		// divide bottom double of temporary register by bottom double of frB
-		PPCRecompilerImlGen_generateNewInstruction_fpr_r_r(ppcImlGenContext, PPCREC_IML_OP_FPR_DIVIDE_BOTTOM, fprRegisterTemp, fprRegisterB);
+		ppcImlGenContext->emitInst().make_fpr_r_r(PPCREC_IML_OP_FPR_DIVIDE, fprTemp, fprB);
 		// move result to frD
-		PPCRecompilerImlGen_generateNewInstruction_fpr_r_r(ppcImlGenContext, PPCREC_IML_OP_FPR_COPY_BOTTOM_TO_BOTTOM, fprRegisterD, fprRegisterTemp);
+		ppcImlGenContext->emitInst().make_fpr_r_r(PPCREC_IML_OP_FPR_ASSIGN, fprD, fprTemp);
 		return true;
 	}
 	// move frA to frD (if different register)
-	if( fprRegisterD != fprRegisterA )
-		PPCRecompilerImlGen_generateNewInstruction_fpr_r_r(ppcImlGenContext, PPCREC_IML_OP_FPR_COPY_BOTTOM_TO_BOTTOM, fprRegisterD, fprRegisterA); // copy ps0
+	if( frD != frA )
+		ppcImlGenContext->emitInst().make_fpr_r_r(PPCREC_IML_OP_FPR_ASSIGN, fprD, fprA); // copy ps0
 	// divide bottom double of frD by bottom double of frB
-	PPCRecompilerImlGen_generateNewInstruction_fpr_r_r(ppcImlGenContext, PPCREC_IML_OP_FPR_DIVIDE_BOTTOM, fprRegisterD, fprRegisterB);
+	ppcImlGenContext->emitInst().make_fpr_r_r(PPCREC_IML_OP_FPR_DIVIDE, fprD, fprB);
 	return true;
 }
 
@@ -598,38 +271,37 @@ bool PPCRecompilerImlGen_FMADD(ppcImlGenContext_t* ppcImlGenContext, uint32 opco
 {
 	sint32 frD, frA, frB, frC;
 	PPC_OPC_TEMPL_A(opcode, frD, frA, frB, frC);
-	// load registers
-	uint32 fprRegisterA = PPCRecompilerImlGen_loadFPRRegister(ppcImlGenContext, PPCREC_NAME_FPR0+frA);
-	uint32 fprRegisterC = PPCRecompilerImlGen_loadFPRRegister(ppcImlGenContext, PPCREC_NAME_FPR0+frC);
-	uint32 fprRegisterB = PPCRecompilerImlGen_loadFPRRegister(ppcImlGenContext, PPCREC_NAME_FPR0+frB);
-	uint32 fprRegisterD = PPCRecompilerImlGen_loadOverwriteFPRRegister(ppcImlGenContext, PPCREC_NAME_FPR0+frD);
+	DefinePS0(fprA, frA);
+	DefinePS0(fprB, frB);
+	DefinePS0(fprC, frC);
+	DefinePS0(fprD, frD);
 	// if frB is already in frD we need a temporary register to store the product of frA*frC
 	if( frB == frD )
 	{
-		uint32 fprRegisterTemp = PPCRecompilerImlGen_loadOverwriteFPRRegister(ppcImlGenContext, PPCREC_NAME_TEMPORARY_FPR0+0);
+		DefineTempFPR(fprTemp, 0);
 		// move frA to temporary register
-		PPCRecompilerImlGen_generateNewInstruction_fpr_r_r(ppcImlGenContext, PPCREC_IML_OP_ASSIGN, fprRegisterTemp, fprRegisterA);
+		ppcImlGenContext->emitInst().make_fpr_r_r(PPCREC_IML_OP_FPR_ASSIGN, fprTemp, fprA);
 		// multiply bottom double of temporary register with bottom double of frC
-		PPCRecompilerImlGen_generateNewInstruction_fpr_r_r(ppcImlGenContext, PPCREC_IML_OP_FPR_MULTIPLY_BOTTOM, fprRegisterTemp, fprRegisterC);
+		ppcImlGenContext->emitInst().make_fpr_r_r(PPCREC_IML_OP_FPR_MULTIPLY, fprTemp, fprC);
 		// add result to frD
-		PPCRecompilerImlGen_generateNewInstruction_fpr_r_r(ppcImlGenContext, PPCREC_IML_OP_FPR_ADD_BOTTOM, fprRegisterD, fprRegisterTemp);
+		ppcImlGenContext->emitInst().make_fpr_r_r(PPCREC_IML_OP_FPR_ADD, fprD, fprTemp);
 		return true;
 	}
 	// if frC == frD -> swap registers, we assume that frC != frD
-	if( fprRegisterD == fprRegisterC )
+	if( frD == frC )
 	{
 		// swap frA and frC
-		sint32 temp = fprRegisterA;
-		fprRegisterA = fprRegisterC;
-		fprRegisterC = temp;
+		IMLReg temp = fprA;
+		fprA = fprC;
+		fprC = temp;
 	}
 	// move frA to frD (if different register)
-	if( fprRegisterD != fprRegisterA )
-		PPCRecompilerImlGen_generateNewInstruction_fpr_r_r(ppcImlGenContext, PPCREC_IML_OP_ASSIGN, fprRegisterD, fprRegisterA); // always copy ps0 and ps1
+	if( frD != frA )
+		ppcImlGenContext->emitInst().make_fpr_r_r(PPCREC_IML_OP_FPR_ASSIGN, fprD, fprA); // always copy ps0 and ps1
 	// multiply bottom double of frD with bottom double of frC
-	PPCRecompilerImlGen_generateNewInstruction_fpr_r_r(ppcImlGenContext, PPCREC_IML_OP_FPR_MULTIPLY_BOTTOM, fprRegisterD, fprRegisterC);
+	ppcImlGenContext->emitInst().make_fpr_r_r(PPCREC_IML_OP_FPR_MULTIPLY, fprD, fprC);
 	// add frB
-	PPCRecompilerImlGen_generateNewInstruction_fpr_r_r(ppcImlGenContext, PPCREC_IML_OP_FPR_ADD_BOTTOM, fprRegisterD, fprRegisterB);
+	ppcImlGenContext->emitInst().make_fpr_r_r(PPCREC_IML_OP_FPR_ADD, fprD, fprB);
 	return true;
 }
 
@@ -637,32 +309,34 @@ bool PPCRecompilerImlGen_FMSUB(ppcImlGenContext_t* ppcImlGenContext, uint32 opco
 {
 	sint32 frD, frA, frB, frC;
 	PPC_OPC_TEMPL_A(opcode, frD, frA, frB, frC);
-	// load registers
-	uint32 fprRegisterA = PPCRecompilerImlGen_loadFPRRegister(ppcImlGenContext, PPCREC_NAME_FPR0+frA);
-	uint32 fprRegisterC = PPCRecompilerImlGen_loadFPRRegister(ppcImlGenContext, PPCREC_NAME_FPR0+frC);
-	uint32 fprRegisterB = PPCRecompilerImlGen_loadFPRRegister(ppcImlGenContext, PPCREC_NAME_FPR0+frB);
-	uint32 fprRegisterD = PPCRecompilerImlGen_loadOverwriteFPRRegister(ppcImlGenContext, PPCREC_NAME_FPR0+frD);
-	// if frB is already in frD we need a temporary register to store the product of frA*frC
+	DefinePS0(fprA, frA);
+	DefinePS0(fprB, frB);
+	DefinePS0(fprC, frC);
+	DefinePS0(fprD, frD);
 	if( frB == frD )
 	{
-		// not implemented
+		// if frB is already in frD we need a temporary register to store the product of frA*frC
+		DefineTempFPR(fprTemp, 0);
+		ppcImlGenContext->emitInst().make_fpr_r_r(PPCREC_IML_OP_FPR_ASSIGN, fprTemp, fprA);
+		ppcImlGenContext->emitInst().make_fpr_r_r(PPCREC_IML_OP_FPR_MULTIPLY, fprTemp, fprC);
+		ppcImlGenContext->emitInst().make_fpr_r_r(PPCREC_IML_OP_FPR_SUB, fprTemp, fprB);
+		ppcImlGenContext->emitInst().make_fpr_r_r(PPCREC_IML_OP_FPR_ASSIGN, fprD, fprTemp);
 		return false;
 	}
-	// if frC == frD -> swap registers, we assume that frC != frD
-	if( fprRegisterD == fprRegisterC )
+	if( frD == frC )
 	{
 		// swap frA and frC
-		sint32 temp = fprRegisterA;
-		fprRegisterA = fprRegisterC;
-		fprRegisterC = temp;
+		IMLReg temp = fprA;
+		fprA = fprC;
+		fprC = temp;
 	}
-	// move frA to frD (if different register)
-	if( fprRegisterD != fprRegisterA )
-		PPCRecompilerImlGen_generateNewInstruction_fpr_r_r(ppcImlGenContext, PPCREC_IML_OP_ASSIGN, fprRegisterD, fprRegisterA); // always copy ps0 and ps1
+	// move frA to frD
+	if( frD != frA )
+		ppcImlGenContext->emitInst().make_fpr_r_r(PPCREC_IML_OP_FPR_ASSIGN, fprD, fprA);
 	// multiply bottom double of frD with bottom double of frC
-	PPCRecompilerImlGen_generateNewInstruction_fpr_r_r(ppcImlGenContext, PPCREC_IML_OP_FPR_MULTIPLY_BOTTOM, fprRegisterD, fprRegisterC);
+	ppcImlGenContext->emitInst().make_fpr_r_r(PPCREC_IML_OP_FPR_MULTIPLY, fprD, fprC);
 	// sub frB
-	PPCRecompilerImlGen_generateNewInstruction_fpr_r_r(ppcImlGenContext, PPCREC_IML_OP_FPR_SUB_BOTTOM, fprRegisterD, fprRegisterB);
+	ppcImlGenContext->emitInst().make_fpr_r_r(PPCREC_IML_OP_FPR_SUB, fprD, fprB);
 	return true;
 }
 
@@ -670,51 +344,52 @@ bool PPCRecompilerImlGen_FNMSUB(ppcImlGenContext_t* ppcImlGenContext, uint32 opc
 {
 	sint32 frD, frA, frB, frC;
 	PPC_OPC_TEMPL_A(opcode, frD, frA, frB, frC);
-
-	// load registers
-	uint32 fprRegisterA = PPCRecompilerImlGen_loadFPRRegister(ppcImlGenContext, PPCREC_NAME_FPR0+frA);
-	uint32 fprRegisterC = PPCRecompilerImlGen_loadFPRRegister(ppcImlGenContext, PPCREC_NAME_FPR0+frC);
-	uint32 fprRegisterB = PPCRecompilerImlGen_loadFPRRegister(ppcImlGenContext, PPCREC_NAME_FPR0+frB);
-	uint32 fprRegisterD = PPCRecompilerImlGen_loadOverwriteFPRRegister(ppcImlGenContext, PPCREC_NAME_FPR0+frD);
+	DefinePS0(fprA, frA);
+	DefinePS0(fprB, frB);
+	DefinePS0(fprC, frC);
+	DefinePS0(fprD, frD);
 	// if frB is already in frD we need a temporary register to store the product of frA*frC
 	if( frB == frD )
 	{
-		// hCPU->fpr[frD].fpr = -(hCPU->fpr[frA].fpr * hCPU->fpr[frC].fpr - hCPU->fpr[frD].fpr);
-		uint32 fprRegisterTemp = PPCRecompilerImlGen_loadOverwriteFPRRegister(ppcImlGenContext, PPCREC_NAME_TEMPORARY_FPR0+0);
-		//// negate frB/frD
-		//PPCRecompilerImlGen_generateNewInstruction_fpr_r(ppcImlGenContext, NULL,PPCREC_IML_OP_FPR_NEGATE_BOTTOM, fprRegisterD, true);
+		DefineTempFPR(fprTemp, 0);
 		// move frA to temporary register
-		PPCRecompilerImlGen_generateNewInstruction_fpr_r_r(ppcImlGenContext, PPCREC_IML_OP_FPR_COPY_BOTTOM_TO_BOTTOM, fprRegisterTemp, fprRegisterA);
+		ppcImlGenContext->emitInst().make_fpr_r_r(PPCREC_IML_OP_FPR_ASSIGN, fprTemp, fprA);
 		// multiply bottom double of temporary register with bottom double of frC
-		PPCRecompilerImlGen_generateNewInstruction_fpr_r_r(ppcImlGenContext, PPCREC_IML_OP_FPR_MULTIPLY_BOTTOM, fprRegisterTemp, fprRegisterC);
+		ppcImlGenContext->emitInst().make_fpr_r_r(PPCREC_IML_OP_FPR_MULTIPLY, fprTemp, fprC);
 		// sub frB from temporary register
-		PPCRecompilerImlGen_generateNewInstruction_fpr_r_r(ppcImlGenContext, PPCREC_IML_OP_FPR_SUB_BOTTOM, fprRegisterTemp, fprRegisterB);
+		ppcImlGenContext->emitInst().make_fpr_r_r(PPCREC_IML_OP_FPR_SUB, fprTemp, fprB);
 		// negate result
-		PPCRecompilerImlGen_generateNewInstruction_fpr_r(ppcImlGenContext, NULL,PPCREC_IML_OP_FPR_NEGATE_BOTTOM, fprRegisterTemp);
+		ppcImlGenContext->emitInst().make_fpr_r(PPCREC_IML_OP_FPR_NEGATE, fprTemp);
 		// move result to frD
-		PPCRecompilerImlGen_generateNewInstruction_fpr_r_r(ppcImlGenContext, PPCREC_IML_OP_FPR_COPY_BOTTOM_TO_BOTTOM, fprRegisterD, fprRegisterTemp);
+		ppcImlGenContext->emitInst().make_fpr_r_r(PPCREC_IML_OP_FPR_ASSIGN, fprD, fprTemp);
 		return true;
 	}
 	// if frC == frD -> swap registers, we assume that frC != frD
-	if( fprRegisterD == fprRegisterC )
+	if( frD == frC )
 	{
 		// swap frA and frC
-		sint32 temp = fprRegisterA;
-		fprRegisterA = fprRegisterC;
-		fprRegisterC = temp;
+		IMLReg temp = fprA;
+		fprA = fprC;
+		fprC = temp;
 	}
 	// move frA to frD (if different register)
-	if( fprRegisterD != fprRegisterA )
-		PPCRecompilerImlGen_generateNewInstruction_fpr_r_r(ppcImlGenContext, PPCREC_IML_OP_FPR_COPY_BOTTOM_TO_BOTTOM, fprRegisterD, fprRegisterA); // always copy ps0 and ps1
+	if( frD != frA )
+		ppcImlGenContext->emitInst().make_fpr_r_r(PPCREC_IML_OP_FPR_ASSIGN, fprD, fprA);
 	// multiply bottom double of frD with bottom double of frC
-	PPCRecompilerImlGen_generateNewInstruction_fpr_r_r(ppcImlGenContext, PPCREC_IML_OP_FPR_MULTIPLY_BOTTOM, fprRegisterD, fprRegisterC);
+	ppcImlGenContext->emitInst().make_fpr_r_r(PPCREC_IML_OP_FPR_MULTIPLY, fprD, fprC);
 	// sub frB
-	PPCRecompilerImlGen_generateNewInstruction_fpr_r_r(ppcImlGenContext, PPCREC_IML_OP_FPR_SUB_BOTTOM, fprRegisterD, fprRegisterB);
+	ppcImlGenContext->emitInst().make_fpr_r_r(PPCREC_IML_OP_FPR_SUB, fprD, fprB);
 	// negate result
-	PPCRecompilerImlGen_generateNewInstruction_fpr_r(ppcImlGenContext, NULL,PPCREC_IML_OP_FPR_NEGATE_BOTTOM, fprRegisterD);
+	ppcImlGenContext->emitInst().make_fpr_r(PPCREC_IML_OP_FPR_NEGATE, fprD);
 	return true;
 }
 
+#define PSE_CopyResultToPs1() 	if( ppcImlGenContext->PSE ) \
+								{ \
+									DefinePS1(fprDPS1, frD); \
+									ppcImlGenContext->emitInst().make_fpr_r_r(PPCREC_IML_OP_FPR_ASSIGN, fprDPS1, fprD); \
+								}
+
 bool PPCRecompilerImlGen_FMULS(ppcImlGenContext_t* ppcImlGenContext, uint32 opcode)
 {
 	sint32 frD, frA, frB_unused, frC;
@@ -727,24 +402,18 @@ bool PPCRecompilerImlGen_FMULS(ppcImlGenContext_t* ppcImlGenContext, uint32 opco
 		frA = frC;
 		frC = temp;
 	}
-	// load registers
-	uint32 fprRegisterA = PPCRecompilerImlGen_loadFPRRegister(ppcImlGenContext, PPCREC_NAME_FPR0+frA);
-	uint32 fprRegisterC = PPCRecompilerImlGen_loadFPRRegister(ppcImlGenContext, PPCREC_NAME_FPR0+frC);
-	uint32 fprRegisterD = PPCRecompilerImlGen_loadOverwriteFPRRegister(ppcImlGenContext, PPCREC_NAME_FPR0+frD);
+	DefinePS0(fprA, frA);
+	DefinePS0(fprC, frC);
+	DefinePS0(fprD, frD);
 	// move frA to frD (if different register)
-	if( fprRegisterD != fprRegisterA )
-		PPCRecompilerImlGen_generateNewInstruction_fpr_r_r(ppcImlGenContext, PPCREC_IML_OP_ASSIGN, fprRegisterD, fprRegisterA); // always copy ps0 and ps1
-	
+	if( frD != frA )
+		ppcImlGenContext->emitInst().make_fpr_r_r(PPCREC_IML_OP_FPR_ASSIGN, fprD, fprA);
 	// multiply bottom double of frD with bottom double of frB
-	PPCRecompilerImlGen_generateNewInstruction_fpr_r_r(ppcImlGenContext, PPCREC_IML_OP_FPR_MULTIPLY_BOTTOM, fprRegisterD, fprRegisterC);
+	ppcImlGenContext->emitInst().make_fpr_r_r(PPCREC_IML_OP_FPR_MULTIPLY, fprD, fprC);
 	// adjust accuracy
-	PPRecompilerImmGen_optionalRoundBottomFPRToSinglePrecision(ppcImlGenContext, fprRegisterD);
+	PPRecompilerImmGen_roundToSinglePrecision(ppcImlGenContext, fprD);
 	// if paired single mode, copy frD ps0 to ps1
-	if( ppcImlGenContext->PSE )
-	{	
-		PPCRecompilerImlGen_generateNewInstruction_fpr_r_r(ppcImlGenContext, PPCREC_IML_OP_FPR_COPY_BOTTOM_TO_BOTTOM_AND_TOP, fprRegisterD, fprRegisterD);
-	}
-	
+	PSE_CopyResultToPs1();
 	return true;
 }
 
@@ -753,44 +422,31 @@ bool PPCRecompilerImlGen_FDIVS(ppcImlGenContext_t* ppcImlGenContext, uint32 opco
 	sint32 frD, frA, frB, frC_unused;
 	PPC_OPC_TEMPL_A(opcode, frD, frA, frB, frC_unused);
 	PPC_ASSERT(frB==0);
-	/*hCPU->fpr[frD].fpr = (float)(hCPU->fpr[frA].fpr / hCPU->fpr[frB].fpr);
-	if( hCPU->PSE )
-		hCPU->fpr[frD].fp1 = hCPU->fpr[frD].fp0;*/
-	// load registers
-	uint32 fprRegisterA = PPCRecompilerImlGen_loadFPRRegister(ppcImlGenContext, PPCREC_NAME_FPR0+frA);
-	uint32 fprRegisterB = PPCRecompilerImlGen_loadFPRRegister(ppcImlGenContext, PPCREC_NAME_FPR0+frB);
-	uint32 fprRegisterD = PPCRecompilerImlGen_loadOverwriteFPRRegister(ppcImlGenContext, PPCREC_NAME_FPR0+frD);
-
+	DefinePS0(fprA, frA);
+	DefinePS0(fprB, frB);
+	DefinePS0(fprD, frD);
 	if( frB == frD && frA != frB )
 	{
-		uint32 fprRegisterTemp = PPCRecompilerImlGen_loadOverwriteFPRRegister(ppcImlGenContext, PPCREC_NAME_TEMPORARY_FPR0+0);
+		DefineTempFPR(fprTemp, 0);
 		// move frA to temporary register
-		PPCRecompilerImlGen_generateNewInstruction_fpr_r_r(ppcImlGenContext, PPCREC_IML_OP_ASSIGN, fprRegisterTemp, fprRegisterA);
+		ppcImlGenContext->emitInst().make_fpr_r_r(PPCREC_IML_OP_FPR_ASSIGN, fprTemp, fprA);
 		// divide bottom double of temporary register by bottom double of frB
-		PPCRecompilerImlGen_generateNewInstruction_fpr_r_r(ppcImlGenContext, PPCREC_IML_OP_FPR_DIVIDE_BOTTOM, fprRegisterTemp, fprRegisterB);
+		ppcImlGenContext->emitInst().make_fpr_r_r(PPCREC_IML_OP_FPR_DIVIDE, fprTemp, fprB);
 		// move result to frD
-		PPCRecompilerImlGen_generateNewInstruction_fpr_r_r(ppcImlGenContext, PPCREC_IML_OP_FPR_COPY_BOTTOM_TO_BOTTOM, fprRegisterD, fprRegisterTemp);
+		ppcImlGenContext->emitInst().make_fpr_r_r(PPCREC_IML_OP_FPR_ASSIGN, fprD, fprTemp);
 		// adjust accuracy
-		PPRecompilerImmGen_optionalRoundBottomFPRToSinglePrecision(ppcImlGenContext, fprRegisterD);
-		// if paired single mode, copy frD ps0 to ps1
-		if( ppcImlGenContext->PSE )
-		{	
-			PPCRecompilerImlGen_generateNewInstruction_fpr_r_r(ppcImlGenContext, PPCREC_IML_OP_FPR_COPY_BOTTOM_TO_BOTTOM_AND_TOP, fprRegisterD, fprRegisterD);
-		}
+		PPRecompilerImmGen_roundToSinglePrecision(ppcImlGenContext, fprD);
+		PSE_CopyResultToPs1();
 		return true;
 	}
 	// move frA to frD (if different register)
-	if( fprRegisterD != fprRegisterA )
-		PPCRecompilerImlGen_generateNewInstruction_fpr_r_r(ppcImlGenContext, PPCREC_IML_OP_ASSIGN, fprRegisterD, fprRegisterA); // always copy ps0 and ps1
+	if( frD != frA )
+		ppcImlGenContext->emitInst().make_fpr_r_r(PPCREC_IML_OP_FPR_ASSIGN, fprD, fprA);
 	// subtract bottom double of frB from bottom double of frD
-	PPCRecompilerImlGen_generateNewInstruction_fpr_r_r(ppcImlGenContext, PPCREC_IML_OP_FPR_DIVIDE_BOTTOM, fprRegisterD, fprRegisterB);
+	ppcImlGenContext->emitInst().make_fpr_r_r(PPCREC_IML_OP_FPR_DIVIDE, fprD, fprB);
 	// adjust accuracy
-	PPRecompilerImmGen_optionalRoundBottomFPRToSinglePrecision(ppcImlGenContext, fprRegisterD);
-	// if paired single mode, copy frD ps0 to ps1
-	if( ppcImlGenContext->PSE )
-	{	
-		PPCRecompilerImlGen_generateNewInstruction_fpr_r_r(ppcImlGenContext, PPCREC_IML_OP_FPR_COPY_BOTTOM_TO_BOTTOM_AND_TOP, fprRegisterD, fprRegisterD);
-	}
+	PPRecompilerImmGen_roundToSinglePrecision(ppcImlGenContext, fprD);
+	PSE_CopyResultToPs1();
 	return true;
 }
 
@@ -806,22 +462,17 @@ bool PPCRecompilerImlGen_FADDS(ppcImlGenContext_t* ppcImlGenContext, uint32 opco
 		frA = frB;
 		frB = temp;
 	}
-	// load registers
-	uint32 fprRegisterA = PPCRecompilerImlGen_loadFPRRegister(ppcImlGenContext, PPCREC_NAME_FPR0+frA);
-	uint32 fprRegisterB = PPCRecompilerImlGen_loadFPRRegister(ppcImlGenContext, PPCREC_NAME_FPR0+frB);
-	uint32 fprRegisterD = PPCRecompilerImlGen_loadOverwriteFPRRegister(ppcImlGenContext, PPCREC_NAME_FPR0+frD);
+	DefinePS0(fprA, frA);
+	DefinePS0(fprB, frB);
+	DefinePS0(fprD, frD);
 	// move frA to frD (if different register)
-	if( fprRegisterD != fprRegisterA )
-		PPCRecompilerImlGen_generateNewInstruction_fpr_r_r(ppcImlGenContext, PPCREC_IML_OP_ASSIGN, fprRegisterD, fprRegisterA); // always copy ps0 and ps1
+	if( frD != frA )
+		ppcImlGenContext->emitInst().make_fpr_r_r(PPCREC_IML_OP_FPR_ASSIGN, fprD, fprA);
 	// add bottom double of frD and bottom double of frB
-	PPCRecompilerImlGen_generateNewInstruction_fpr_r_r(ppcImlGenContext, PPCREC_IML_OP_FPR_ADD_BOTTOM, fprRegisterD, fprRegisterB);
+	ppcImlGenContext->emitInst().make_fpr_r_r(PPCREC_IML_OP_FPR_ADD, fprD, fprB);
 	// adjust accuracy
-	PPRecompilerImmGen_optionalRoundBottomFPRToSinglePrecision(ppcImlGenContext, fprRegisterD);
-	// if paired single mode, copy frD ps0 to ps1
-	if( ppcImlGenContext->PSE )
-	{	
-		PPCRecompilerImlGen_generateNewInstruction_fpr_r_r(ppcImlGenContext, PPCREC_IML_OP_FPR_COPY_BOTTOM_TO_BOTTOM_AND_TOP, fprRegisterD, fprRegisterD);
-	}
+	PPRecompilerImmGen_roundToSinglePrecision(ppcImlGenContext, fprD);
+	PSE_CopyResultToPs1();
 	return true;
 }
 
@@ -830,20 +481,12 @@ bool PPCRecompilerImlGen_FSUBS(ppcImlGenContext_t* ppcImlGenContext, uint32 opco
 	int frD, frA, frB, frC;
 	PPC_OPC_TEMPL_A(opcode, frD, frA, frB, frC);
 	PPC_ASSERT(frB==0);
-
-	// load registers
-	uint32 fprRegisterA = PPCRecompilerImlGen_loadFPRRegister(ppcImlGenContext, PPCREC_NAME_FPR0+frA);
-	uint32 fprRegisterB = PPCRecompilerImlGen_loadFPRRegister(ppcImlGenContext, PPCREC_NAME_FPR0+frB);
-	uint32 fprRegisterD = PPCRecompilerImlGen_loadOverwriteFPRRegister(ppcImlGenContext, PPCREC_NAME_FPR0+frD);
-	// subtract bottom
-	PPCRecompilerImlGen_generateNewInstruction_fpr_r_r_r(ppcImlGenContext, PPCREC_IML_OP_FPR_SUB_BOTTOM, fprRegisterD, fprRegisterA, fprRegisterB);
-	// adjust accuracy
-	PPRecompilerImmGen_optionalRoundBottomFPRToSinglePrecision(ppcImlGenContext, fprRegisterD);
-	// if paired single mode, copy frD ps0 to ps1
-	if( ppcImlGenContext->PSE )
-	{	
-		PPCRecompilerImlGen_generateNewInstruction_fpr_r_r(ppcImlGenContext, PPCREC_IML_OP_FPR_COPY_BOTTOM_TO_BOTTOM_AND_TOP, fprRegisterD, fprRegisterD);
-	}
+	DefinePS0(fprA, frA);
+	DefinePS0(fprB, frB);
+	DefinePS0(fprD, frD);
+	ppcImlGenContext->emitInst().make_fpr_r_r_r(PPCREC_IML_OP_FPR_SUB, fprD, fprA, fprB);
+	PPRecompilerImmGen_roundToSinglePrecision(ppcImlGenContext, fprD);
+	PSE_CopyResultToPs1();
 	return true;
 }
 
@@ -851,34 +494,26 @@ bool PPCRecompilerImlGen_FMADDS(ppcImlGenContext_t* ppcImlGenContext, uint32 opc
 {
 	sint32 frD, frA, frB, frC;
 	PPC_OPC_TEMPL_A(opcode, frD, frA, frB, frC);
-	//FPRD(RD) = FPRD(RA) * FPRD(RC) + FPRD(RB);
-	//hCPU->fpr[frD].fpr = hCPU->fpr[frA].fpr * hCPU->fpr[frC].fpr + hCPU->fpr[frB].fpr;
-	//if( hCPU->PSE )
-	//	hCPU->fpr[frD].fp1 = hCPU->fpr[frD].fp0;
-	// load registers
-	uint32 fprRegisterA = PPCRecompilerImlGen_loadFPRRegister(ppcImlGenContext, PPCREC_NAME_FPR0+frA);
-	uint32 fprRegisterC = PPCRecompilerImlGen_loadFPRRegister(ppcImlGenContext, PPCREC_NAME_FPR0+frC);
-	uint32 fprRegisterB = PPCRecompilerImlGen_loadFPRRegister(ppcImlGenContext, PPCREC_NAME_FPR0+frB);
-	uint32 fprRegisterD = PPCRecompilerImlGen_loadOverwriteFPRRegister(ppcImlGenContext, PPCREC_NAME_FPR0+frD);
-	uint32 fprRegisterTemp;
+	DefinePS0(fprA, frA);
+	DefinePS0(fprB, frB);
+	DefinePS0(fprC, frC);
+	DefinePS0(fprD, frD);
 	// if none of the operand registers overlap with the result register then we can avoid the usage of a temporary register
-	if( fprRegisterD != fprRegisterA && fprRegisterD != fprRegisterB && fprRegisterD != fprRegisterC )
-		fprRegisterTemp = fprRegisterD;
+	IMLReg fprRegisterTemp;
+	if( frD != frA && frD != frB && frD != frC )
+		fprRegisterTemp = fprD;
 	else
-		fprRegisterTemp = PPCRecompilerImlGen_loadOverwriteFPRRegister(ppcImlGenContext, PPCREC_NAME_TEMPORARY_FPR0+0);
-	PPCRecompilerImlGen_generateNewInstruction_fpr_r_r_r(ppcImlGenContext, PPCREC_IML_OP_FPR_MULTIPLY_BOTTOM, fprRegisterTemp, fprRegisterA, fprRegisterC);
-	PPCRecompilerImlGen_generateNewInstruction_fpr_r_r(ppcImlGenContext, PPCREC_IML_OP_FPR_ADD_BOTTOM, fprRegisterTemp, fprRegisterB);
+		fprRegisterTemp = _GetFPRTemp(ppcImlGenContext, 0);
+	ppcImlGenContext->emitInst().make_fpr_r_r_r(PPCREC_IML_OP_FPR_MULTIPLY, fprRegisterTemp, fprA, fprC);
+	ppcImlGenContext->emitInst().make_fpr_r_r(PPCREC_IML_OP_FPR_ADD, fprRegisterTemp, fprB);
 	// adjust accuracy
-	PPRecompilerImmGen_optionalRoundBottomFPRToSinglePrecision(ppcImlGenContext, fprRegisterTemp);
+	PPRecompilerImmGen_roundToSinglePrecision(ppcImlGenContext, fprRegisterTemp);
 	// set result
-	if( ppcImlGenContext->PSE )
-	{	
-		PPCRecompilerImlGen_generateNewInstruction_fpr_r_r(ppcImlGenContext, PPCREC_IML_OP_FPR_COPY_BOTTOM_TO_BOTTOM_AND_TOP, fprRegisterD, fprRegisterTemp);
-	}
-	else if( fprRegisterD != fprRegisterTemp )
+	if( fprD != fprRegisterTemp )
 	{
-		PPCRecompilerImlGen_generateNewInstruction_fpr_r_r(ppcImlGenContext, PPCREC_IML_OP_FPR_COPY_BOTTOM_TO_BOTTOM, fprRegisterD, fprRegisterTemp);
+		ppcImlGenContext->emitInst().make_fpr_r_r(PPCREC_IML_OP_FPR_ASSIGN, fprD, fprRegisterTemp);
 	}
+	PSE_CopyResultToPs1();
 	return true;
 }
 
@@ -886,33 +521,27 @@ bool PPCRecompilerImlGen_FMSUBS(ppcImlGenContext_t* ppcImlGenContext, uint32 opc
 {
 	sint32 frD, frA, frB, frC;
 	PPC_OPC_TEMPL_A(opcode, frD, frA, frB, frC);
-	//hCPU->fpr[frD].fp0 = (float)(hCPU->fpr[frA].fp0 * hCPU->fpr[frC].fp0 - hCPU->fpr[frB].fp0);
-	//if( hCPU->PSE )
-	//	hCPU->fpr[frD].fp1 = hCPU->fpr[frD].fp0;
-	// load registers
-	uint32 fprRegisterA = PPCRecompilerImlGen_loadFPRRegister(ppcImlGenContext, PPCREC_NAME_FPR0+frA);
-	uint32 fprRegisterC = PPCRecompilerImlGen_loadFPRRegister(ppcImlGenContext, PPCREC_NAME_FPR0+frC);
-	uint32 fprRegisterB = PPCRecompilerImlGen_loadFPRRegister(ppcImlGenContext, PPCREC_NAME_FPR0+frB);
-	uint32 fprRegisterD = PPCRecompilerImlGen_loadOverwriteFPRRegister(ppcImlGenContext, PPCREC_NAME_FPR0+frD);
-	uint32 fprRegisterTemp;
+	DefinePS0(fprA, frA);
+	DefinePS0(fprB, frB);
+	DefinePS0(fprC, frC);
+	DefinePS0(fprD, frD);
+
+	IMLReg fprRegisterTemp;
 	// if none of the operand registers overlap with the result register then we can avoid the usage of a temporary register
-	if( fprRegisterD != fprRegisterA && fprRegisterD != fprRegisterB && fprRegisterD != fprRegisterC )
-		fprRegisterTemp = fprRegisterD;
+	if( frD != frA && frD != frB && frD != frC )
+		fprRegisterTemp = fprD;
 	else
-		fprRegisterTemp = PPCRecompilerImlGen_loadOverwriteFPRRegister(ppcImlGenContext, PPCREC_NAME_TEMPORARY_FPR0+0);
-	PPCRecompilerImlGen_generateNewInstruction_fpr_r_r_r(ppcImlGenContext, PPCREC_IML_OP_FPR_MULTIPLY_BOTTOM, fprRegisterTemp, fprRegisterA, fprRegisterC);
-	PPCRecompilerImlGen_generateNewInstruction_fpr_r_r(ppcImlGenContext, PPCREC_IML_OP_FPR_SUB_BOTTOM, fprRegisterTemp, fprRegisterB);
+		fprRegisterTemp = _GetFPRTemp(ppcImlGenContext, 0);
+	ppcImlGenContext->emitInst().make_fpr_r_r_r(PPCREC_IML_OP_FPR_MULTIPLY, fprRegisterTemp, fprA, fprC);
+	ppcImlGenContext->emitInst().make_fpr_r_r(PPCREC_IML_OP_FPR_SUB, fprRegisterTemp, fprB);
 	// adjust accuracy
-	PPRecompilerImmGen_optionalRoundBottomFPRToSinglePrecision(ppcImlGenContext, fprRegisterTemp);
+	PPRecompilerImmGen_roundToSinglePrecision(ppcImlGenContext, fprRegisterTemp);
 	// set result
-	if( ppcImlGenContext->PSE )
-	{	
-		PPCRecompilerImlGen_generateNewInstruction_fpr_r_r(ppcImlGenContext, PPCREC_IML_OP_FPR_COPY_BOTTOM_TO_BOTTOM_AND_TOP, fprRegisterD, fprRegisterTemp);
-	}
-	else if( fprRegisterD != fprRegisterTemp )
+	if( fprD != fprRegisterTemp )
 	{
-		PPCRecompilerImlGen_generateNewInstruction_fpr_r_r(ppcImlGenContext, PPCREC_IML_OP_FPR_COPY_BOTTOM_TO_BOTTOM, fprRegisterD, fprRegisterTemp);
+		ppcImlGenContext->emitInst().make_fpr_r_r(PPCREC_IML_OP_FPR_ASSIGN, fprD, fprRegisterTemp);
 	}
+	PSE_CopyResultToPs1();
 	return true;
 }
 
@@ -920,53 +549,32 @@ bool PPCRecompilerImlGen_FNMSUBS(ppcImlGenContext_t* ppcImlGenContext, uint32 op
 {
 	sint32 frD, frA, frB, frC;
 	PPC_OPC_TEMPL_A(opcode, frD, frA, frB, frC);
-
-	//[FP1(RD) = ]FP0(RD) = -(FP0(RA) * FP0(RC) - FP0(RB));
-	//hCPU->fpr[frD].fp0 = (float)-(hCPU->fpr[frA].fp0 * hCPU->fpr[frC].fp0 - hCPU->fpr[frB].fp0);
-	//if( PPC_PSE )
-	//	hCPU->fpr[frD].fp1 = hCPU->fpr[frD].fp0;
-
-	// load registers
-	uint32 fprRegisterA = PPCRecompilerImlGen_loadFPRRegister(ppcImlGenContext, PPCREC_NAME_FPR0+frA);
-	uint32 fprRegisterC = PPCRecompilerImlGen_loadFPRRegister(ppcImlGenContext, PPCREC_NAME_FPR0+frC);
-	uint32 fprRegisterB = PPCRecompilerImlGen_loadFPRRegister(ppcImlGenContext, PPCREC_NAME_FPR0+frB);
-	uint32 fprRegisterD = PPCRecompilerImlGen_loadOverwriteFPRRegister(ppcImlGenContext, PPCREC_NAME_FPR0+frD);
-	uint32 fprRegisterTemp;
+	DefinePS0(fprA, frA);
+	DefinePS0(fprB, frB);
+	DefinePS0(fprC, frC);
+	DefinePS0(fprD, frD);
+	IMLReg fprRegisterTemp;
 	// if none of the operand registers overlap with the result register then we can avoid the usage of a temporary register
-	if( fprRegisterD != fprRegisterA && fprRegisterD != fprRegisterB && fprRegisterD != fprRegisterC )
-		fprRegisterTemp = fprRegisterD;
+	if( frD != frA && frD != frB && frD != frC )
+		fprRegisterTemp = fprD;
 	else
-		fprRegisterTemp = PPCRecompilerImlGen_loadOverwriteFPRRegister(ppcImlGenContext, PPCREC_NAME_TEMPORARY_FPR0+0);
-	PPCRecompilerImlGen_generateNewInstruction_fpr_r_r_r(ppcImlGenContext, PPCREC_IML_OP_FPR_MULTIPLY_BOTTOM, fprRegisterTemp, fprRegisterA, fprRegisterC);
-	PPCRecompilerImlGen_generateNewInstruction_fpr_r_r(ppcImlGenContext, PPCREC_IML_OP_FPR_SUB_BOTTOM, fprRegisterTemp, fprRegisterB);
-	PPCRecompilerImlGen_generateNewInstruction_fpr_r(ppcImlGenContext, NULL,PPCREC_IML_OP_FPR_NEGATE_BOTTOM, fprRegisterTemp);
+		fprRegisterTemp = _GetFPRTemp(ppcImlGenContext, 0);
+	ppcImlGenContext->emitInst().make_fpr_r_r_r(PPCREC_IML_OP_FPR_MULTIPLY, fprRegisterTemp, fprA, fprC);
+	ppcImlGenContext->emitInst().make_fpr_r_r(PPCREC_IML_OP_FPR_SUB, fprRegisterTemp, fprB);
+	ppcImlGenContext->emitInst().make_fpr_r(PPCREC_IML_OP_FPR_NEGATE, fprRegisterTemp);
 	// adjust accuracy
-	PPRecompilerImmGen_optionalRoundBottomFPRToSinglePrecision(ppcImlGenContext, fprRegisterTemp);
+	PPRecompilerImmGen_roundToSinglePrecision(ppcImlGenContext, fprRegisterTemp);
 	// set result
-	if( ppcImlGenContext->PSE )
-	{	
-		PPCRecompilerImlGen_generateNewInstruction_fpr_r_r(ppcImlGenContext, PPCREC_IML_OP_FPR_COPY_BOTTOM_TO_BOTTOM_AND_TOP, fprRegisterD, fprRegisterTemp);
-	}
-	else if( fprRegisterD != fprRegisterTemp )
-	{
-		PPCRecompilerImlGen_generateNewInstruction_fpr_r_r(ppcImlGenContext, PPCREC_IML_OP_FPR_COPY_BOTTOM_TO_BOTTOM, fprRegisterD, fprRegisterTemp);
-	}
+	if( fprD != fprRegisterTemp )
+		ppcImlGenContext->emitInst().make_fpr_r_r(PPCREC_IML_OP_FPR_ASSIGN, fprD, fprRegisterTemp);
+	PSE_CopyResultToPs1();
 	return true;
 }
 
 bool PPCRecompilerImlGen_FCMPO(ppcImlGenContext_t* ppcImlGenContext, uint32 opcode)
 {
-	sint32 crfD, frA, frB;
-	PPC_OPC_TEMPL_X(opcode, crfD, frA, frB);
-	crfD >>= 2;
-	if( hasSSE2Support == false )
-	{
-		return false;
-	}
-	uint32 fprRegisterA = PPCRecompilerImlGen_loadFPRRegister(ppcImlGenContext, PPCREC_NAME_FPR0+frA);
-	uint32 fprRegisterB = PPCRecompilerImlGen_loadFPRRegister(ppcImlGenContext, PPCREC_NAME_FPR0+frB);
-	PPCRecompilerImlGen_generateNewInstruction_fpr_r_r(ppcImlGenContext, PPCREC_IML_OP_FPR_FCMPO_BOTTOM, fprRegisterA, fprRegisterB, crfD);
-	return true;
+	// Not implemented
+	return false;
 }
 
 bool PPCRecompilerImlGen_FCMPU(ppcImlGenContext_t* ppcImlGenContext, uint32 opcode)
@@ -974,13 +582,21 @@ bool PPCRecompilerImlGen_FCMPU(ppcImlGenContext_t* ppcImlGenContext, uint32 opco
 	sint32 crfD, frA, frB;
 	PPC_OPC_TEMPL_X(opcode, crfD, frA, frB);
 	crfD >>= 2;
-	if( hasSSE2Support == false )
-	{
-		return false;
-	}
-	uint32 fprRegisterA = PPCRecompilerImlGen_loadFPRRegister(ppcImlGenContext, PPCREC_NAME_FPR0+frA);
-	uint32 fprRegisterB = PPCRecompilerImlGen_loadFPRRegister(ppcImlGenContext, PPCREC_NAME_FPR0+frB);
-	PPCRecompilerImlGen_generateNewInstruction_fpr_r_r(ppcImlGenContext, PPCREC_IML_OP_FPR_FCMPU_BOTTOM, fprRegisterA, fprRegisterB, crfD);
+	DefinePS0(fprA, frA);
+	DefinePS0(fprB, frB);
+
+	IMLReg crBitRegLT = _GetRegCR(ppcImlGenContext, crfD, Espresso::CR_BIT::CR_BIT_INDEX_LT);
+	IMLReg crBitRegGT = _GetRegCR(ppcImlGenContext, crfD, Espresso::CR_BIT::CR_BIT_INDEX_GT);
+	IMLReg crBitRegEQ = _GetRegCR(ppcImlGenContext, crfD, Espresso::CR_BIT::CR_BIT_INDEX_EQ);
+	IMLReg crBitRegSO = _GetRegCR(ppcImlGenContext, crfD, Espresso::CR_BIT::CR_BIT_INDEX_SO);
+
+	ppcImlGenContext->emitInst().make_fpr_compare(fprA, fprB, crBitRegLT, IMLCondition::UNORDERED_LT);
+	ppcImlGenContext->emitInst().make_fpr_compare(fprA, fprB, crBitRegGT, IMLCondition::UNORDERED_GT);
+	ppcImlGenContext->emitInst().make_fpr_compare(fprA, fprB, crBitRegEQ, IMLCondition::UNORDERED_EQ);
+	ppcImlGenContext->emitInst().make_fpr_compare(fprA, fprB, crBitRegSO, IMLCondition::UNORDERED_U);
+
+	// todo: set fpscr
+
 	return true;
 }
 
@@ -988,9 +604,9 @@ bool PPCRecompilerImlGen_FMR(ppcImlGenContext_t* ppcImlGenContext, uint32 opcode
 {
 	sint32 frD, rA, frB;
 	PPC_OPC_TEMPL_X(opcode, frD, rA, frB);
-	uint32 fprRegisterB = PPCRecompilerImlGen_loadFPRRegister(ppcImlGenContext, PPCREC_NAME_FPR0+frB);
-	uint32 fprRegisterD = PPCRecompilerImlGen_loadOverwriteFPRRegister(ppcImlGenContext, PPCREC_NAME_FPR0+frD);
-	PPCRecompilerImlGen_generateNewInstruction_fpr_r_r(ppcImlGenContext, PPCREC_IML_OP_FPR_COPY_BOTTOM_TO_BOTTOM, fprRegisterD, fprRegisterB);
+	DefinePS0(fprB, frB);
+	DefinePS0(fprD, frD);
+	ppcImlGenContext->emitInst().make_fpr_r_r(PPCREC_IML_OP_FPR_ASSIGN, fprD, fprB);
 	return true;
 }
 
@@ -999,14 +615,11 @@ bool PPCRecompilerImlGen_FABS(ppcImlGenContext_t* ppcImlGenContext, uint32 opcod
 	sint32 frD, frA, frB;
 	PPC_OPC_TEMPL_X(opcode, frD, frA, frB);
 	PPC_ASSERT(frA==0);
-	// load registers
-	uint32 fprRegisterB = PPCRecompilerImlGen_loadFPRRegister(ppcImlGenContext, PPCREC_NAME_FPR0+frB);
-	uint32 fprRegisterD = PPCRecompilerImlGen_loadOverwriteFPRRegister(ppcImlGenContext, PPCREC_NAME_FPR0+frD);
-	// move frB to frD (if different register)
-	if( fprRegisterD != fprRegisterB )
-		PPCRecompilerImlGen_generateNewInstruction_fpr_r_r(ppcImlGenContext, PPCREC_IML_OP_FPR_COPY_BOTTOM_TO_BOTTOM, fprRegisterD, fprRegisterB);
-	// abs frD
-	PPCRecompilerImlGen_generateNewInstruction_fpr_r(ppcImlGenContext, NULL,PPCREC_IML_OP_FPR_ABS_BOTTOM, fprRegisterD);
+	DefinePS0(fprB, frB);
+	DefinePS0(fprD, frD);
+	if( frD != frB )
+		ppcImlGenContext->emitInst().make_fpr_r_r(PPCREC_IML_OP_FPR_ASSIGN, fprD, fprB);
+	ppcImlGenContext->emitInst().make_fpr_r(PPCREC_IML_OP_FPR_ABS, fprD);
 	return true;
 }
 
@@ -1015,14 +628,11 @@ bool PPCRecompilerImlGen_FNABS(ppcImlGenContext_t* ppcImlGenContext, uint32 opco
 	sint32 frD, frA, frB;
 	PPC_OPC_TEMPL_X(opcode, frD, frA, frB);
 	PPC_ASSERT(frA==0);
-	// load registers
-	uint32 fprRegisterB = PPCRecompilerImlGen_loadFPRRegister(ppcImlGenContext, PPCREC_NAME_FPR0+frB);
-	uint32 fprRegisterD = PPCRecompilerImlGen_loadOverwriteFPRRegister(ppcImlGenContext, PPCREC_NAME_FPR0+frD);
-	// move frB to frD (if different register)
-	if( fprRegisterD != fprRegisterB )
-		PPCRecompilerImlGen_generateNewInstruction_fpr_r_r(ppcImlGenContext, PPCREC_IML_OP_FPR_COPY_BOTTOM_TO_BOTTOM, fprRegisterD, fprRegisterB);
-	// abs frD
-	PPCRecompilerImlGen_generateNewInstruction_fpr_r(ppcImlGenContext, NULL,PPCREC_IML_OP_FPR_NEGATIVE_ABS_BOTTOM, fprRegisterD);
+	DefinePS0(fprB, frB);
+	DefinePS0(fprD, frD);
+	if( frD != frB )
+		ppcImlGenContext->emitInst().make_fpr_r_r(PPCREC_IML_OP_FPR_ASSIGN, fprD, fprB);
+	ppcImlGenContext->emitInst().make_fpr_r(PPCREC_IML_OP_FPR_NEGATIVE_ABS, fprD);
 	return true;
 }
 
@@ -1031,12 +641,12 @@ bool PPCRecompilerImlGen_FRES(ppcImlGenContext_t* ppcImlGenContext, uint32 opcod
 	sint32 frD, frA, frB;
 	PPC_OPC_TEMPL_X(opcode, frD, frA, frB);
 	PPC_ASSERT(frA==0);
-	// load registers
-	uint32 fprRegisterB = PPCRecompilerImlGen_loadFPRRegister(ppcImlGenContext, PPCREC_NAME_FPR0+frB);
-	uint32 fprRegisterD = PPCRecompilerImlGen_loadOverwriteFPRRegister(ppcImlGenContext, PPCREC_NAME_FPR0+frD);
-	PPCRecompilerImlGen_generateNewInstruction_fpr_r_r(ppcImlGenContext, PPCREC_IML_OP_FPR_BOTTOM_FRES_TO_BOTTOM_AND_TOP, fprRegisterD, fprRegisterB);
+	DefinePS0(fprB, frB);
+	DefinePS0(fprD, frD);
+	ppcImlGenContext->emitInst().make_call_imm((uintptr_t)fres_espresso, fprB, IMLREG_INVALID, IMLREG_INVALID, fprD);
 	// adjust accuracy
-	PPRecompilerImmGen_optionalRoundBottomFPRToSinglePrecision(ppcImlGenContext, fprRegisterD);
+	PPRecompilerImmGen_roundToSinglePrecision(ppcImlGenContext, fprD);
+	PSE_CopyResultToPs1();
 	return true;
 }
 
@@ -1045,17 +655,12 @@ bool PPCRecompilerImlGen_FRSP(ppcImlGenContext_t* ppcImlGenContext, uint32 opcod
 	sint32 frD, frA, frB;
 	PPC_OPC_TEMPL_X(opcode, frD, frA, frB);
 	PPC_ASSERT(frA==0);
-	uint32 fprRegisterB = PPCRecompilerImlGen_loadFPRRegister(ppcImlGenContext, PPCREC_NAME_FPR0+frB);
-	uint32 fprRegisterD = PPCRecompilerImlGen_loadOverwriteFPRRegister(ppcImlGenContext, PPCREC_NAME_FPR0+frD);
-	if( fprRegisterD != fprRegisterB )
-	{
-		PPCRecompilerImlGen_generateNewInstruction_fpr_r_r(ppcImlGenContext, PPCREC_IML_OP_FPR_COPY_BOTTOM_TO_BOTTOM, fprRegisterD, fprRegisterB);
-	}
-	PPCRecompilerImlGen_generateNewInstruction_fpr_r(ppcImlGenContext, NULL,PPCREC_IML_OP_FPR_ROUND_TO_SINGLE_PRECISION_BOTTOM, fprRegisterD);
-	if( ppcImlGenContext->PSE )
-	{
-		PPCRecompilerImlGen_generateNewInstruction_fpr_r_r(ppcImlGenContext, PPCREC_IML_OP_FPR_COPY_BOTTOM_TO_BOTTOM_AND_TOP, fprRegisterD, fprRegisterD);
-	}
+	DefinePS0(fprB, frB);
+	DefinePS0(fprD, frD);
+	if( fprD != fprB )
+		ppcImlGenContext->emitInst().make_fpr_r_r(PPCREC_IML_OP_FPR_ASSIGN, fprD, fprB);
+	ppcImlGenContext->emitInst().make_fpr_r(PPCREC_IML_OP_FPR_ROUND_TO_SINGLE_PRECISION_BOTTOM, fprD);
+	PSE_CopyResultToPs1();
 	return true;
 }
 
@@ -1065,17 +670,12 @@ bool PPCRecompilerImlGen_FNEG(ppcImlGenContext_t* ppcImlGenContext, uint32 opcod
 	PPC_OPC_TEMPL_X(opcode, frD, frA, frB);
 	PPC_ASSERT(frA==0);
 	if( opcode&PPC_OPC_RC )
-	{
 		return false;
-	}
-	// load registers
-	uint32 fprRegisterB = PPCRecompilerImlGen_loadFPRRegister(ppcImlGenContext, PPCREC_NAME_FPR0+frB);
-	uint32 fprRegisterD = PPCRecompilerImlGen_loadOverwriteFPRRegister(ppcImlGenContext, PPCREC_NAME_FPR0+frD);
-	// move frB to frD (if different register)
-	if( fprRegisterD != fprRegisterB )
-		PPCRecompilerImlGen_generateNewInstruction_fpr_r_r(ppcImlGenContext, PPCREC_IML_OP_FPR_COPY_BOTTOM_TO_BOTTOM, fprRegisterD, fprRegisterB);
-	// negate frD
-	PPCRecompilerImlGen_generateNewInstruction_fpr_r(ppcImlGenContext, NULL,PPCREC_IML_OP_FPR_NEGATE_BOTTOM, fprRegisterD);
+	DefinePS0(fprB, frB);
+	DefinePS0(fprD, frD);
+	if( frD != frB )
+		ppcImlGenContext->emitInst().make_fpr_r_r(PPCREC_IML_OP_FPR_ASSIGN, fprD, fprB);
+	ppcImlGenContext->emitInst().make_fpr_r(PPCREC_IML_OP_FPR_NEGATE, fprD);
 	return true;
 }
 
@@ -1087,11 +687,11 @@ bool PPCRecompilerImlGen_FSEL(ppcImlGenContext_t* ppcImlGenContext, uint32 opcod
 	{
 		return false;
 	}
-	uint32 fprRegisterA = PPCRecompilerImlGen_loadFPRRegister(ppcImlGenContext, PPCREC_NAME_FPR0+frA);
-	uint32 fprRegisterB = PPCRecompilerImlGen_loadFPRRegister(ppcImlGenContext, PPCREC_NAME_FPR0+frB);
-	uint32 fprRegisterC = PPCRecompilerImlGen_loadFPRRegister(ppcImlGenContext, PPCREC_NAME_FPR0+frC);
-	uint32 fprRegisterD = PPCRecompilerImlGen_loadOverwriteFPRRegister(ppcImlGenContext, PPCREC_NAME_FPR0+frD);
-	PPCRecompilerImlGen_generateNewInstruction_fpr_r_r_r_r(ppcImlGenContext, PPCREC_IML_OP_FPR_SELECT_BOTTOM, fprRegisterD, fprRegisterA, fprRegisterB, fprRegisterC);
+	DefinePS0(fprA, frA);
+	DefinePS0(fprB, frB);
+	DefinePS0(fprC, frC);
+	DefinePS0(fprD, frD);
+	ppcImlGenContext->emitInst().make_fpr_r_r_r_r(PPCREC_IML_OP_FPR_SELECT, fprD, fprA, fprB, fprC);
 	return true;
 }
 
@@ -1099,12 +699,11 @@ bool PPCRecompilerImlGen_FRSQRTE(ppcImlGenContext_t* ppcImlGenContext, uint32 op
 {
 	sint32 frD, frA, frB, frC;
 	PPC_OPC_TEMPL_A(opcode, frD, frA, frB, frC);
-	// hCPU->fpr[frD].fpr = 1.0 / sqrt(hCPU->fpr[frB].fpr);
-	uint32 fprRegisterB = PPCRecompilerImlGen_loadFPRRegister(ppcImlGenContext, PPCREC_NAME_FPR0+frB);
-	uint32 fprRegisterD = PPCRecompilerImlGen_loadOverwriteFPRRegister(ppcImlGenContext, PPCREC_NAME_FPR0+frD);
-	PPCRecompilerImlGen_generateNewInstruction_fpr_r_r(ppcImlGenContext, PPCREC_IML_OP_FPR_BOTTOM_RECIPROCAL_SQRT, fprRegisterD, fprRegisterB);
+	DefinePS0(fprB, frB);
+	DefinePS0(fprD, frD);
+	ppcImlGenContext->emitInst().make_call_imm((uintptr_t)frsqrte_espresso, fprB, IMLREG_INVALID, IMLREG_INVALID, fprD);
 	// adjust accuracy
-	PPRecompilerImmGen_optionalRoundBottomFPRToSinglePrecision(ppcImlGenContext, fprRegisterD);
+	PPRecompilerImmGen_roundToSinglePrecision(ppcImlGenContext, fprD);
 	return true;
 }
 
@@ -1112,69 +711,242 @@ bool PPCRecompilerImlGen_FCTIWZ(ppcImlGenContext_t* ppcImlGenContext, uint32 opc
 {
 	sint32 frD, frA, frB;
 	PPC_OPC_TEMPL_X(opcode, frD, frA, frB);
-	uint32 fprRegisterB = PPCRecompilerImlGen_loadFPRRegister(ppcImlGenContext, PPCREC_NAME_FPR0+frB);
-	uint32 fprRegisterD = PPCRecompilerImlGen_loadOverwriteFPRRegister(ppcImlGenContext, PPCREC_NAME_FPR0+frD);
-	PPCRecompilerImlGen_generateNewInstruction_fpr_r_r(ppcImlGenContext, PPCREC_IML_OP_FPR_BOTTOM_FCTIWZ, fprRegisterD, fprRegisterB);
+	DefinePS0(fprB, frB);
+	DefinePS0(fprD, frD);
+	ppcImlGenContext->emitInst().make_fpr_r_r(PPCREC_IML_OP_FPR_FCTIWZ, fprD, fprB);
 	return true;
 }
 
-bool PPCRecompilerImlGen_PSQ_L(ppcImlGenContext_t* ppcImlGenContext, uint32 opcode)
+bool PPCRecompiler_isUGQRValueKnown(ppcImlGenContext_t* ppcImlGenContext, sint32 gqrIndex, uint32& gqrValue);
+
+void PPCRecompilerImlGen_ClampInteger(ppcImlGenContext_t* ppcImlGenContext, IMLReg reg, sint32 clampMin, sint32 clampMax)
+{
+	IMLReg regTmpCondBool = PPCRecompilerImlGen_loadRegister(ppcImlGenContext, PPCREC_NAME_TEMPORARY + 1);
+	// min(reg, clampMax)
+	ppcImlGenContext->emitInst().make_compare_s32(reg, clampMax, regTmpCondBool, IMLCondition::SIGNED_GT);
+	ppcImlGenContext->emitInst().make_conditional_jump(regTmpCondBool, false); // condition needs to be inverted because we skip if the condition is true
+	PPCIMLGen_CreateSegmentBranchedPath(*ppcImlGenContext, *ppcImlGenContext->currentBasicBlock,
+		[&](ppcImlGenContext_t& genCtx)
+		{
+			/* branch not taken */
+			genCtx.emitInst().make_r_s32(PPCREC_IML_OP_ASSIGN, reg, clampMax);
+		}
+	);
+	// max(reg, clampMin)
+	ppcImlGenContext->emitInst().make_compare_s32(reg, clampMin, regTmpCondBool, IMLCondition::SIGNED_LT);
+	ppcImlGenContext->emitInst().make_conditional_jump(regTmpCondBool, false);
+	PPCIMLGen_CreateSegmentBranchedPath(*ppcImlGenContext, *ppcImlGenContext->currentBasicBlock,
+		[&](ppcImlGenContext_t& genCtx)
+		{
+			/* branch not taken */
+			genCtx.emitInst().make_r_s32(PPCREC_IML_OP_ASSIGN, reg, clampMin);
+		}
+	);
+}
+
+void PPCRecompilerIMLGen_GetPSQScale(ppcImlGenContext_t* ppcImlGenContext, IMLReg gqrRegister, IMLReg fprRegScaleOut, bool isLoad)
+{
+	IMLReg gprTmp2 = PPCRecompilerImlGen_loadRegister(ppcImlGenContext, PPCREC_NAME_TEMPORARY + 2);
+	// extract scale factor and sign extend it
+	ppcImlGenContext->emitInst().make_r_r_s32(PPCREC_IML_OP_LEFT_SHIFT, gprTmp2, gqrRegister, 32 - ((isLoad ? 24 : 8)+7));
+	ppcImlGenContext->emitInst().make_r_r_s32(PPCREC_IML_OP_RIGHT_SHIFT_S, gprTmp2, gprTmp2, (32-23)-7);
+	ppcImlGenContext->emitInst().make_r_r_s32(PPCREC_IML_OP_AND, gprTmp2, gprTmp2, 0x1FF<<23);
+	if (isLoad)
+		ppcImlGenContext->emitInst().make_r_r(PPCREC_IML_OP_NEG, gprTmp2, gprTmp2);
+	ppcImlGenContext->emitInst().make_r_r_s32(PPCREC_IML_OP_ADD, gprTmp2, gprTmp2, 0x7F<<23);
+	// gprTmp2 now holds the scale float bits, bitcast to float
+	ppcImlGenContext->emitInst().make_fpr_r_r(PPCREC_IML_OP_FPR_BITCAST_INT_TO_FLOAT, fprRegScaleOut, gprTmp2);
+}
+
+void PPCRecompilerImlGen_EmitPSQLoadCase(ppcImlGenContext_t* ppcImlGenContext, sint32 gqrIndex, Espresso::PSQ_LOAD_TYPE loadType, bool readPS1, IMLReg gprA, sint32 imm, IMLReg fprDPS0, IMLReg fprDPS1)
+{
+	if (loadType == Espresso::PSQ_LOAD_TYPE::TYPE_F32)
+	{
+		ppcImlGenContext->emitInst().make_fpr_r_memory(fprDPS0, gprA, imm, PPCREC_FPR_LD_MODE_SINGLE, true);
+		if(readPS1)
+		{
+			ppcImlGenContext->emitInst().make_fpr_r_memory(fprDPS1, gprA, imm + 4, PPCREC_FPR_LD_MODE_SINGLE, true);
+		}
+	}
+	if (loadType == Espresso::PSQ_LOAD_TYPE::TYPE_U16 || loadType == Espresso::PSQ_LOAD_TYPE::TYPE_S16)
+	{
+		// get scale factor
+		IMLReg gqrRegister = PPCRecompilerImlGen_loadRegister(ppcImlGenContext, PPCREC_NAME_SPR0 + SPR_UGQR0 + gqrIndex);
+		IMLReg fprScaleReg = _GetFPRTemp(ppcImlGenContext, 2);
+		PPCRecompilerIMLGen_GetPSQScale(ppcImlGenContext, gqrRegister, fprScaleReg, true);
+
+		bool isSigned = (loadType == Espresso::PSQ_LOAD_TYPE::TYPE_S16);
+		IMLReg gprTmp = PPCRecompilerImlGen_loadRegister(ppcImlGenContext, PPCREC_NAME_TEMPORARY + 0);
+		ppcImlGenContext->emitInst().make_r_memory(gprTmp, gprA, imm, 16, isSigned, true);
+		ppcImlGenContext->emitInst().make_fpr_r_r(PPCREC_IML_OP_FPR_INT_TO_FLOAT, fprDPS0, gprTmp);
+
+		ppcImlGenContext->emitInst().make_fpr_r_r_r(PPCREC_IML_OP_FPR_MULTIPLY, fprDPS0, fprDPS0, fprScaleReg);
+
+		if(readPS1)
+		{
+			ppcImlGenContext->emitInst().make_r_memory(gprTmp, gprA, imm + 2, 16, isSigned, true);
+			ppcImlGenContext->emitInst().make_fpr_r_r(PPCREC_IML_OP_FPR_INT_TO_FLOAT, fprDPS1, gprTmp);
+			ppcImlGenContext->emitInst().make_fpr_r_r_r(PPCREC_IML_OP_FPR_MULTIPLY, fprDPS1, fprDPS1, fprScaleReg);
+		}
+	}
+	else if (loadType == Espresso::PSQ_LOAD_TYPE::TYPE_U8 || loadType == Espresso::PSQ_LOAD_TYPE::TYPE_S8)
+	{
+		// get scale factor
+		IMLReg gqrRegister = PPCRecompilerImlGen_loadRegister(ppcImlGenContext, PPCREC_NAME_SPR0 + SPR_UGQR0 + gqrIndex);
+		IMLReg fprScaleReg = _GetFPRTemp(ppcImlGenContext, 2);
+		PPCRecompilerIMLGen_GetPSQScale(ppcImlGenContext, gqrRegister, fprScaleReg, true);
+
+		bool isSigned = (loadType == Espresso::PSQ_LOAD_TYPE::TYPE_S8);
+		IMLReg gprTmp = PPCRecompilerImlGen_loadRegister(ppcImlGenContext, PPCREC_NAME_TEMPORARY + 0);
+		ppcImlGenContext->emitInst().make_r_memory(gprTmp, gprA, imm, 8, isSigned, true);
+		ppcImlGenContext->emitInst().make_fpr_r_r(PPCREC_IML_OP_FPR_INT_TO_FLOAT, fprDPS0, gprTmp);
+		ppcImlGenContext->emitInst().make_fpr_r_r_r(PPCREC_IML_OP_FPR_MULTIPLY, fprDPS0, fprDPS0, fprScaleReg);
+		if(readPS1)
+		{
+			ppcImlGenContext->emitInst().make_r_memory(gprTmp, gprA, imm + 1, 8, isSigned, true);
+			ppcImlGenContext->emitInst().make_fpr_r_r(PPCREC_IML_OP_FPR_INT_TO_FLOAT, fprDPS1, gprTmp);
+			ppcImlGenContext->emitInst().make_fpr_r_r_r(PPCREC_IML_OP_FPR_MULTIPLY, fprDPS1, fprDPS1, fprScaleReg);
+		}
+	}
+}
+
+// PSQ_L and PSQ_LU
+bool PPCRecompilerImlGen_PSQ_L(ppcImlGenContext_t* ppcImlGenContext, uint32 opcode, bool withUpdate)
 {
-	if (hasSSE2Support == false)
-		return false;
 	int rA, frD;
 	uint32 immUnused;
 	PPC_OPC_TEMPL_D_SImm(opcode, frD, rA, immUnused);
-
 	sint32 gqrIndex = ((opcode >> 12) & 7);
 	uint32 imm = opcode & 0xFFF;
 	if (imm & 0x800)
 		imm |= ~0xFFF;
-
 	bool readPS1 = (opcode & 0x8000) == false;
 
-	// get gqr register
-	uint32 gqrRegister = PPCRecompilerImlGen_loadRegister(ppcImlGenContext, PPCREC_NAME_SPR0 + SPR_UGQR0 + gqrIndex, false);
-	// get memory gpr register index
-	uint32 gprRegister = PPCRecompilerImlGen_loadRegister(ppcImlGenContext, PPCREC_NAME_R0 + rA, false);
-	// get fpr register index
-	uint32 fprRegister = PPCRecompilerImlGen_loadOverwriteFPRRegister(ppcImlGenContext, PPCREC_NAME_FPR0 + frD);
-	// psq load
-	PPCRecompilerImlGen_generateNewInstruction_fpr_r_memory(ppcImlGenContext, fprRegister, gprRegister, imm, readPS1 ? PPCREC_FPR_LD_MODE_PSQ_GENERIC_PS0_PS1 : PPCREC_FPR_LD_MODE_PSQ_GENERIC_PS0, true, gqrRegister);
+	IMLReg gprA = PPCRecompilerImlGen_loadRegister(ppcImlGenContext, PPCREC_NAME_R0+rA);
+	DefinePS0(fprDPS0, frD);
+	DefinePS1(fprDPS1, frD);
+	if (!readPS1)
+	{
+		// if PS1 is not explicitly read then set it to 1.0
+		ppcImlGenContext->emitInst().make_fpr_r(PPCREC_IML_OP_FPR_LOAD_ONE, fprDPS1);
+	}
+	if (withUpdate)
+	{
+		ppcImlGenContext->emitInst().make_r_r_s32(PPCREC_IML_OP_ADD, gprA, gprA, (sint32)imm);
+		imm = 0;
+	}
+	uint32 knownGQRValue = 0;
+	if ( !PPCRecompiler_isUGQRValueKnown(ppcImlGenContext, gqrIndex, knownGQRValue) )
+	{
+		// generate complex dynamic handler when we dont know the GQR value ahead of time
+		IMLReg gqrRegister = PPCRecompilerImlGen_loadRegister(ppcImlGenContext, PPCREC_NAME_SPR0 + SPR_UGQR0 + gqrIndex);
+		IMLReg loadTypeReg = PPCRecompilerImlGen_loadRegister(ppcImlGenContext, PPCREC_NAME_TEMPORARY + 0);
+		// extract the load type from the GQR register
+		ppcImlGenContext->emitInst().make_r_r_s32(PPCREC_IML_OP_RIGHT_SHIFT_U, loadTypeReg, gqrRegister, 16);
+		ppcImlGenContext->emitInst().make_r_r_s32(PPCREC_IML_OP_AND, loadTypeReg, loadTypeReg, 0x7);
+		IMLSegment* caseSegment[6];
+		sint32 compareValues[6] = {0, 4, 5, 6, 7};
+		PPCIMLGen_CreateSegmentBranchedPathMultiple(*ppcImlGenContext, *ppcImlGenContext->currentBasicBlock, caseSegment, loadTypeReg, compareValues, 5, 0);
+		for (sint32 i=0; i<5; i++)
+		{
+			IMLRedirectInstOutput outputToCase(ppcImlGenContext, caseSegment[i]); // while this is in scope, instructions go to caseSegment[i]
+			PPCRecompilerImlGen_EmitPSQLoadCase(ppcImlGenContext, gqrIndex, static_cast<Espresso::PSQ_LOAD_TYPE>(compareValues[i]), readPS1, gprA, imm, fprDPS0, fprDPS1);
+			// create the case jump instructions here because we need to add it last
+			caseSegment[i]->AppendInstruction()->make_jump();
+		}
+		return true;
+	}
+
+	Espresso::PSQ_LOAD_TYPE type = static_cast<Espresso::PSQ_LOAD_TYPE>((knownGQRValue >> 0) & 0x7);
+	sint32 scale = (knownGQRValue >> 8) & 0x3F;
+	cemu_assert_debug(scale == 0); // known GQR values always use a scale of 0 (1.0f)
+	if (scale != 0)
+		return false;
+
+	if (type == Espresso::PSQ_LOAD_TYPE::TYPE_UNUSED1 ||
+		type == Espresso::PSQ_LOAD_TYPE::TYPE_UNUSED2 ||
+		type == Espresso::PSQ_LOAD_TYPE::TYPE_UNUSED3)
+	{
+		return false;
+	}
+
+	PPCRecompilerImlGen_EmitPSQLoadCase(ppcImlGenContext, gqrIndex, type, readPS1, gprA, imm, fprDPS0, fprDPS1);
 	return true;
 }
 
-bool PPCRecompilerImlGen_PSQ_LU(ppcImlGenContext_t* ppcImlGenContext, uint32 opcode)
+void PPCRecompilerImlGen_EmitPSQStoreCase(ppcImlGenContext_t* ppcImlGenContext, sint32 gqrIndex, Espresso::PSQ_LOAD_TYPE storeType, bool storePS1, IMLReg gprA, sint32 imm, IMLReg fprDPS0, IMLReg fprDPS1)
 {
-	if (hasSSE2Support == false)
-		return false;
-	int rA, frD;
-	uint32 immUnused;
-	PPC_OPC_TEMPL_D_SImm(opcode, frD, rA, immUnused);
-	if (rA == 0)
-		return false;
+	cemu_assert_debug(!storePS1 || fprDPS1.IsValid());
+	if (storeType == Espresso::PSQ_LOAD_TYPE::TYPE_F32)
+	{
+		ppcImlGenContext->emitInst().make_fpr_memory_r(fprDPS0, gprA, imm, PPCREC_FPR_ST_MODE_SINGLE, true);
+		if(storePS1)
+		{
+			ppcImlGenContext->emitInst().make_fpr_memory_r(fprDPS1, gprA, imm + 4, PPCREC_FPR_ST_MODE_SINGLE, true);
+		}
+	}
+	else if (storeType == Espresso::PSQ_LOAD_TYPE::TYPE_U16 || storeType == Espresso::PSQ_LOAD_TYPE::TYPE_S16)
+	{
+		// get scale factor
+		IMLReg gqrRegister = PPCRecompilerImlGen_loadRegister(ppcImlGenContext, PPCREC_NAME_SPR0 + SPR_UGQR0 + gqrIndex);
+		IMLReg fprScaleReg = _GetFPRTemp(ppcImlGenContext, 2);
+		PPCRecompilerIMLGen_GetPSQScale(ppcImlGenContext, gqrRegister, fprScaleReg, false);
 
-	sint32 gqrIndex = ((opcode >> 12) & 7);
-	uint32 imm = opcode & 0xFFF;
-	if (imm & 0x800)
-		imm |= ~0xFFF;
+		bool isSigned = (storeType == Espresso::PSQ_LOAD_TYPE::TYPE_S16);
+		IMLReg fprTmp = _GetFPRTemp(ppcImlGenContext, 0);
 
-	bool readPS1 = (opcode & 0x8000) == false;
-	
-	// get gqr register
-	uint32 gqrRegister = PPCRecompilerImlGen_loadRegister(ppcImlGenContext, PPCREC_NAME_SPR0 + SPR_UGQR0 + gqrIndex, false);
-	// get memory gpr register index
-	uint32 gprRegister = PPCRecompilerImlGen_loadRegister(ppcImlGenContext, PPCREC_NAME_R0 + rA, false);
-	// add imm to memory register
-	PPCRecompilerImlGen_generateNewInstruction_r_s32(ppcImlGenContext, PPCREC_IML_OP_ADD, gprRegister, (sint32)imm, 0, false, false, PPC_REC_INVALID_REGISTER, 0);
-	// get fpr register index
-	uint32 fprRegister = PPCRecompilerImlGen_loadOverwriteFPRRegister(ppcImlGenContext, PPCREC_NAME_FPR0 + frD);
-	// paired load
-	PPCRecompilerImlGen_generateNewInstruction_fpr_r_memory(ppcImlGenContext, fprRegister, gprRegister, 0, readPS1 ? PPCREC_FPR_LD_MODE_PSQ_GENERIC_PS0_PS1 : PPCREC_FPR_LD_MODE_PSQ_GENERIC_PS0, true, gqrRegister);
-	return true;
+		IMLReg gprTmp = PPCRecompilerImlGen_loadRegister(ppcImlGenContext, PPCREC_NAME_TEMPORARY + 0);
+		ppcImlGenContext->emitInst().make_fpr_r_r_r(PPCREC_IML_OP_FPR_MULTIPLY, fprTmp, fprDPS0, fprScaleReg);
+		ppcImlGenContext->emitInst().make_fpr_r_r(PPCREC_IML_OP_FPR_FLOAT_TO_INT, gprTmp, fprTmp);
+
+		if (isSigned)
+			PPCRecompilerImlGen_ClampInteger(ppcImlGenContext, gprTmp, -32768, 32767);
+		else
+			PPCRecompilerImlGen_ClampInteger(ppcImlGenContext, gprTmp, 0, 65535);
+		ppcImlGenContext->emitInst().make_memory_r(gprTmp, gprA, imm, 16, true);
+		if(storePS1)
+		{
+			ppcImlGenContext->emitInst().make_fpr_r_r_r(PPCREC_IML_OP_FPR_MULTIPLY, fprTmp, fprDPS1, fprScaleReg);
+			ppcImlGenContext->emitInst().make_fpr_r_r(PPCREC_IML_OP_FPR_FLOAT_TO_INT, gprTmp, fprTmp);
+			if (isSigned)
+				PPCRecompilerImlGen_ClampInteger(ppcImlGenContext, gprTmp, -32768, 32767);
+			else
+				PPCRecompilerImlGen_ClampInteger(ppcImlGenContext, gprTmp, 0, 65535);
+			ppcImlGenContext->emitInst().make_memory_r(gprTmp, gprA, imm + 2, 16, true);
+		}
+	}
+	else if (storeType == Espresso::PSQ_LOAD_TYPE::TYPE_U8 || storeType == Espresso::PSQ_LOAD_TYPE::TYPE_S8)
+	{
+		// get scale factor
+		IMLReg gqrRegister = PPCRecompilerImlGen_loadRegister(ppcImlGenContext, PPCREC_NAME_SPR0 + SPR_UGQR0 + gqrIndex);
+		IMLReg fprScaleReg = _GetFPRTemp(ppcImlGenContext, 2);
+		PPCRecompilerIMLGen_GetPSQScale(ppcImlGenContext, gqrRegister, fprScaleReg, false);
+
+		bool isSigned = (storeType == Espresso::PSQ_LOAD_TYPE::TYPE_S8);
+		IMLReg fprTmp = _GetFPRTemp(ppcImlGenContext, 0);
+		IMLReg gprTmp = PPCRecompilerImlGen_loadRegister(ppcImlGenContext, PPCREC_NAME_TEMPORARY + 0);
+		ppcImlGenContext->emitInst().make_fpr_r_r_r(PPCREC_IML_OP_FPR_MULTIPLY, fprTmp, fprDPS0, fprScaleReg);
+		ppcImlGenContext->emitInst().make_fpr_r_r(PPCREC_IML_OP_FPR_FLOAT_TO_INT, gprTmp, fprTmp);
+		if (isSigned)
+			PPCRecompilerImlGen_ClampInteger(ppcImlGenContext, gprTmp, -128, 127);
+		else
+			PPCRecompilerImlGen_ClampInteger(ppcImlGenContext, gprTmp, 0, 255);
+		ppcImlGenContext->emitInst().make_memory_r(gprTmp, gprA, imm, 8, true);
+		if(storePS1)
+		{
+			ppcImlGenContext->emitInst().make_fpr_r_r_r(PPCREC_IML_OP_FPR_MULTIPLY, fprTmp, fprDPS1, fprScaleReg);
+			ppcImlGenContext->emitInst().make_fpr_r_r(PPCREC_IML_OP_FPR_FLOAT_TO_INT, gprTmp, fprTmp);
+			if (isSigned)
+				PPCRecompilerImlGen_ClampInteger(ppcImlGenContext, gprTmp, -128, 127);
+			else
+				PPCRecompilerImlGen_ClampInteger(ppcImlGenContext, gprTmp, 0, 255);
+			ppcImlGenContext->emitInst().make_memory_r(gprTmp, gprA, imm + 1, 8, true);
+		}
+	}
 }
 
-bool PPCRecompilerImlGen_PSQ_ST(ppcImlGenContext_t* ppcImlGenContext, uint32 opcode)
+// PSQ_ST and PSQ_STU
+bool PPCRecompilerImlGen_PSQ_ST(ppcImlGenContext_t* ppcImlGenContext, uint32 opcode, bool withUpdate)
 {
 	int rA, frD;
 	uint32 immUnused;
@@ -1183,181 +955,133 @@ bool PPCRecompilerImlGen_PSQ_ST(ppcImlGenContext_t* ppcImlGenContext, uint32 opc
 	if (imm & 0x800)
 		imm |= ~0xFFF;
 	sint32 gqrIndex = ((opcode >> 12) & 7);
-
 	bool storePS1 = (opcode & 0x8000) == false;
 
-	// get gqr register
-	uint32 gqrRegister = PPCRecompilerImlGen_loadRegister(ppcImlGenContext, PPCREC_NAME_SPR0 + SPR_UGQR0 + gqrIndex, false);
-	// get memory gpr register index
-	uint32 gprRegister = PPCRecompilerImlGen_loadRegister(ppcImlGenContext, PPCREC_NAME_R0 + rA, false);
-	// get fpr register index
-	uint32 fprRegister = PPCRecompilerImlGen_loadOverwriteFPRRegister(ppcImlGenContext, PPCREC_NAME_FPR0 + frD);
-	// paired store
-	PPCRecompilerImlGen_generateNewInstruction_fpr_memory_r(ppcImlGenContext, fprRegister, gprRegister, imm, storePS1 ? PPCREC_FPR_ST_MODE_PSQ_GENERIC_PS0_PS1 : PPCREC_FPR_ST_MODE_PSQ_GENERIC_PS0, true, gqrRegister);
-	return true;
-}
+	IMLReg gprA = PPCRecompilerImlGen_loadRegister(ppcImlGenContext, PPCREC_NAME_R0+rA);
+	DefinePS0(fprDPS0, frD);
+	IMLReg fprDPS1 = storePS1 ? _GetFPRRegPS1(ppcImlGenContext, frD) : IMLREG_INVALID;
 
-bool PPCRecompilerImlGen_PSQ_STU(ppcImlGenContext_t* ppcImlGenContext, uint32 opcode)
-{
-	int rA, frD;
-	uint32 immUnused;
-	PPC_OPC_TEMPL_D_SImm(opcode, frD, rA, immUnused);
-	if (rA == 0)
+	if (withUpdate)
+	{
+		ppcImlGenContext->emitInst().make_r_r_s32(PPCREC_IML_OP_ADD, gprA, gprA, (sint32)imm);
+		imm = 0;
+	}
+
+	uint32 gqrValue = 0;
+	if ( !PPCRecompiler_isUGQRValueKnown(ppcImlGenContext, gqrIndex, gqrValue) )
+	{
+		// generate complex dynamic handler when we dont know the GQR value ahead of time
+		IMLReg gqrRegister = PPCRecompilerImlGen_loadRegister(ppcImlGenContext, PPCREC_NAME_SPR0 + SPR_UGQR0 + gqrIndex);
+		IMLReg loadTypeReg = PPCRecompilerImlGen_loadRegister(ppcImlGenContext, PPCREC_NAME_TEMPORARY + 0);
+		// extract the load type from the GQR register
+		ppcImlGenContext->emitInst().make_r_r_s32(PPCREC_IML_OP_AND, loadTypeReg, gqrRegister, 0x7);
+
+		IMLSegment* caseSegment[5];
+		sint32 compareValues[5] = {0, 4, 5, 6, 7};
+		PPCIMLGen_CreateSegmentBranchedPathMultiple(*ppcImlGenContext, *ppcImlGenContext->currentBasicBlock, caseSegment, loadTypeReg, compareValues, 5, 0);
+		for (sint32 i=0; i<5; i++)
+		{
+			IMLRedirectInstOutput outputToCase(ppcImlGenContext, caseSegment[i]); // while this is in scope, instructions go to caseSegment[i]
+			PPCRecompilerImlGen_EmitPSQStoreCase(ppcImlGenContext, gqrIndex, static_cast<Espresso::PSQ_LOAD_TYPE>(compareValues[i]), storePS1, gprA, imm, fprDPS0, fprDPS1);
+			ppcImlGenContext->emitInst().make_jump(); // finalize case
+		}
+		return true;
+	}
+
+	Espresso::PSQ_LOAD_TYPE type = static_cast<Espresso::PSQ_LOAD_TYPE>((gqrValue >> 16) & 0x7);
+	sint32 scale = (gqrValue >> 24) & 0x3F;
+	cemu_assert_debug(scale == 0); // known GQR values always use a scale of 0 (1.0f)
+
+	if (type == Espresso::PSQ_LOAD_TYPE::TYPE_UNUSED1 ||
+		type == Espresso::PSQ_LOAD_TYPE::TYPE_UNUSED2 ||
+		type == Espresso::PSQ_LOAD_TYPE::TYPE_UNUSED3)
+	{
 		return false;
+	}
 
-	uint32 imm = opcode & 0xFFF;
-	if (imm & 0x800)
-		imm |= ~0xFFF;
-	sint32 gqrIndex = ((opcode >> 12) & 7);
-
-	bool storePS1 = (opcode & 0x8000) == false;
-
-	// get gqr register
-	uint32 gqrRegister = PPCRecompilerImlGen_loadRegister(ppcImlGenContext, PPCREC_NAME_SPR0 + SPR_UGQR0 + gqrIndex, false);
-	// get memory gpr register index
-	uint32 gprRegister = PPCRecompilerImlGen_loadRegister(ppcImlGenContext, PPCREC_NAME_R0 + rA, false);
-	// add imm to memory register
-	PPCRecompilerImlGen_generateNewInstruction_r_s32(ppcImlGenContext, PPCREC_IML_OP_ADD, gprRegister, (sint32)imm, 0, false, false, PPC_REC_INVALID_REGISTER, 0);
-	// get fpr register index
-	uint32 fprRegister = PPCRecompilerImlGen_loadOverwriteFPRRegister(ppcImlGenContext, PPCREC_NAME_FPR0 + frD);
-	// paired store
-	PPCRecompilerImlGen_generateNewInstruction_fpr_memory_r(ppcImlGenContext, fprRegister, gprRegister, 0, storePS1 ? PPCREC_FPR_ST_MODE_PSQ_GENERIC_PS0_PS1 : PPCREC_FPR_ST_MODE_PSQ_GENERIC_PS0, true, gqrRegister);
+	PPCRecompilerImlGen_EmitPSQStoreCase(ppcImlGenContext, gqrIndex, type, storePS1, gprA, imm, fprDPS0, fprDPS1);
 	return true;
 }
 
-bool PPCRecompilerImlGen_PS_MULS0(ppcImlGenContext_t* ppcImlGenContext, uint32 opcode)
+// PS_MULS0 and PS_MULS1
+bool PPCRecompilerImlGen_PS_MULSX(ppcImlGenContext_t* ppcImlGenContext, uint32 opcode, bool isVariant1)
 {
 	sint32 frD, frA, frC;
 	frC = (opcode>>6)&0x1F;
 	frA = (opcode>>16)&0x1F;
 	frD = (opcode>>21)&0x1F;
-	// load registers
-	uint32 fprRegisterA = PPCRecompilerImlGen_loadFPRRegister(ppcImlGenContext, PPCREC_NAME_FPR0+frA);
-	uint32 fprRegisterC = PPCRecompilerImlGen_loadFPRRegister(ppcImlGenContext, PPCREC_NAME_FPR0+frC);
-	uint32 fprRegisterD = PPCRecompilerImlGen_loadOverwriteFPRRegister(ppcImlGenContext, PPCREC_NAME_FPR0+frD);
-	// we need a temporary register to store frC.fp0 in low and high half
-	uint32 fprRegisterTemp = PPCRecompilerImlGen_loadOverwriteFPRRegister(ppcImlGenContext, PPCREC_NAME_TEMPORARY_FPR0+0);
-	PPCRecompilerImlGen_generateNewInstruction_fpr_r_r(ppcImlGenContext, PPCREC_IML_OP_FPR_COPY_BOTTOM_TO_BOTTOM_AND_TOP, fprRegisterTemp, fprRegisterC);
-	// if frD == frA we can multiply frD immediately and safe a copy instruction
-	if( frD == frA )
-	{
-		PPCRecompilerImlGen_generateNewInstruction_fpr_r_r(ppcImlGenContext, PPCREC_IML_OP_FPR_MULTIPLY_PAIR, fprRegisterD, fprRegisterTemp);
-	}
-	else
-	{
-		// we multiply temporary by frA
-		PPCRecompilerImlGen_generateNewInstruction_fpr_r_r(ppcImlGenContext, PPCREC_IML_OP_FPR_MULTIPLY_PAIR, fprRegisterTemp, fprRegisterA);
-		// copy result to frD
-		PPCRecompilerImlGen_generateNewInstruction_fpr_r_r(ppcImlGenContext, PPCREC_IML_OP_FPR_COPY_PAIR, fprRegisterD, fprRegisterTemp);
-	}
-	// adjust accuracy
-	PPRecompilerImmGen_optionalRoundPairFPRToSinglePrecision(ppcImlGenContext, fprRegisterD);
+
+	DefinePS0(fprAps0, frA);
+	DefinePS1(fprAps1, frA);
+	DefinePSX(fprC, frC, isVariant1);
+	DefinePS0(fprDps0, frD);
+	DefinePS1(fprDps1, frD);
+
+	DefineTempFPR(fprTmp0, 0);
+	DefineTempFPR(fprTmp1, 1);
+
+	// todo - optimize cases where a temporary is not necessary
+	// todo - round fprC to 25bit accuracy
+
+	// copy ps0 and ps1 to temporary
+	ppcImlGenContext->emitInst().make_fpr_r_r(PPCREC_IML_OP_FPR_ASSIGN, fprTmp0, fprAps0);
+	ppcImlGenContext->emitInst().make_fpr_r_r(PPCREC_IML_OP_FPR_ASSIGN, fprTmp1, fprAps1);
+
+	// multiply
+	ppcImlGenContext->emitInst().make_fpr_r_r(PPCREC_IML_OP_FPR_MULTIPLY, fprTmp0, fprC);
+	ppcImlGenContext->emitInst().make_fpr_r_r(PPCREC_IML_OP_FPR_MULTIPLY, fprTmp1, fprC);
+
+	// copy back to result
+	ppcImlGenContext->emitInst().make_fpr_r_r(PPCREC_IML_OP_FPR_ASSIGN, fprDps0, fprTmp0);
+	ppcImlGenContext->emitInst().make_fpr_r_r(PPCREC_IML_OP_FPR_ASSIGN, fprDps1, fprTmp1);
+
+	PPRecompilerImmGen_roundToSinglePrecision(ppcImlGenContext, fprDps0);
+	PPRecompilerImmGen_roundToSinglePrecision(ppcImlGenContext, fprDps1);
+
 	return true;
 }
 
-bool PPCRecompilerImlGen_PS_MULS1(ppcImlGenContext_t* ppcImlGenContext, uint32 opcode)
-{
-	sint32 frD, frA, frC;
-	frC = (opcode>>6)&0x1F;
-	frA = (opcode>>16)&0x1F;
-	frD = (opcode>>21)&0x1F;
-	// load registers
-	uint32 fprRegisterA = PPCRecompilerImlGen_loadFPRRegister(ppcImlGenContext, PPCREC_NAME_FPR0+frA);
-	uint32 fprRegisterC = PPCRecompilerImlGen_loadFPRRegister(ppcImlGenContext, PPCREC_NAME_FPR0+frC);
-	uint32 fprRegisterD = PPCRecompilerImlGen_loadOverwriteFPRRegister(ppcImlGenContext, PPCREC_NAME_FPR0+frD);
-	// we need a temporary register to store frC.fp0 in low and high half
-	uint32 fprRegisterTemp = PPCRecompilerImlGen_loadOverwriteFPRRegister(ppcImlGenContext, PPCREC_NAME_TEMPORARY_FPR0+0);
-	PPCRecompilerImlGen_generateNewInstruction_fpr_r_r(ppcImlGenContext, PPCREC_IML_OP_FPR_COPY_TOP_TO_BOTTOM_AND_TOP, fprRegisterTemp, fprRegisterC);
-	// if frD == frA we can multiply frD immediately and safe a copy instruction
-	if( frD == frA )
-	{
-		PPCRecompilerImlGen_generateNewInstruction_fpr_r_r(ppcImlGenContext, PPCREC_IML_OP_FPR_MULTIPLY_PAIR, fprRegisterD, fprRegisterTemp);
-	}
-	else
-	{
-		// we multiply temporary by frA
-		PPCRecompilerImlGen_generateNewInstruction_fpr_r_r(ppcImlGenContext, PPCREC_IML_OP_FPR_MULTIPLY_PAIR, fprRegisterTemp, fprRegisterA);
-		// copy result to frD
-		PPCRecompilerImlGen_generateNewInstruction_fpr_r_r(ppcImlGenContext, PPCREC_IML_OP_FPR_COPY_PAIR, fprRegisterD, fprRegisterTemp);
-	}
-	// adjust accuracy
-	PPRecompilerImmGen_optionalRoundPairFPRToSinglePrecision(ppcImlGenContext, fprRegisterD);
-	return true;
-}
-
-bool PPCRecompilerImlGen_PS_MADDS0(ppcImlGenContext_t* ppcImlGenContext, uint32 opcode)
+// PS_MADDS0 and PS_MADDS1
+bool PPCRecompilerImlGen_PS_MADDSX(ppcImlGenContext_t* ppcImlGenContext, uint32 opcode, bool isVariant1)
 {
 	sint32 frD, frA, frB, frC;
 	frC = (opcode>>6)&0x1F;
 	frB = (opcode>>11)&0x1F;
 	frA = (opcode>>16)&0x1F;
 	frD = (opcode>>21)&0x1F;
-	//float s0 = (float)(hCPU->fpr[frA].fp0 * hCPU->fpr[frC].fp0 + hCPU->fpr[frB].fp0);
-	//float s1 = (float)(hCPU->fpr[frA].fp1 * hCPU->fpr[frC].fp0 + hCPU->fpr[frB].fp1);
-	// load registers
-	uint32 fprRegisterA = PPCRecompilerImlGen_loadFPRRegister(ppcImlGenContext, PPCREC_NAME_FPR0+frA);
-	uint32 fprRegisterB = PPCRecompilerImlGen_loadFPRRegister(ppcImlGenContext, PPCREC_NAME_FPR0+frB);
-	uint32 fprRegisterC = PPCRecompilerImlGen_loadFPRRegister(ppcImlGenContext, PPCREC_NAME_FPR0+frC);
-	uint32 fprRegisterD = PPCRecompilerImlGen_loadOverwriteFPRRegister(ppcImlGenContext, PPCREC_NAME_FPR0+frD);
-	// we need a temporary register to store frC.fp0 in low and high half
-	uint32 fprRegisterTemp = PPCRecompilerImlGen_loadOverwriteFPRRegister(ppcImlGenContext, PPCREC_NAME_TEMPORARY_FPR0+0);
-	PPCRecompilerImlGen_generateNewInstruction_fpr_r_r(ppcImlGenContext, PPCREC_IML_OP_FPR_COPY_BOTTOM_TO_BOTTOM_AND_TOP, fprRegisterTemp, fprRegisterC);
-	// if frD == frA and frD != frB we can multiply frD immediately and safe a copy instruction
-	if( frD == frA && frD != frB )
-	{
-		PPCRecompilerImlGen_generateNewInstruction_fpr_r_r(ppcImlGenContext, PPCREC_IML_OP_FPR_MULTIPLY_PAIR, fprRegisterD, fprRegisterTemp);
-		// add frB
-		PPCRecompilerImlGen_generateNewInstruction_fpr_r_r(ppcImlGenContext, PPCREC_IML_OP_FPR_ADD_PAIR, fprRegisterD, fprRegisterB);
-	}
-	else
-	{
-		// we multiply temporary by frA
-		PPCRecompilerImlGen_generateNewInstruction_fpr_r_r(ppcImlGenContext, PPCREC_IML_OP_FPR_MULTIPLY_PAIR, fprRegisterTemp, fprRegisterA);
-		// add frB
-		PPCRecompilerImlGen_generateNewInstruction_fpr_r_r(ppcImlGenContext, PPCREC_IML_OP_FPR_ADD_PAIR, fprRegisterTemp, fprRegisterB);
-		// copy result to frD
-		PPCRecompilerImlGen_generateNewInstruction_fpr_r_r(ppcImlGenContext, PPCREC_IML_OP_FPR_COPY_PAIR, fprRegisterD, fprRegisterTemp);
-	}
-	// adjust accuracy
-	PPRecompilerImmGen_optionalRoundPairFPRToSinglePrecision(ppcImlGenContext, fprRegisterD);
-	return true;
-}
 
-bool PPCRecompilerImlGen_PS_MADDS1(ppcImlGenContext_t* ppcImlGenContext, uint32 opcode)
-{
-	sint32 frD, frA, frB, frC;
-	frC = (opcode>>6)&0x1F;
-	frB = (opcode>>11)&0x1F;
-	frA = (opcode>>16)&0x1F;
-	frD = (opcode>>21)&0x1F;
-	//float s0 = (float)(hCPU->fpr[frA].fp0 * hCPU->fpr[frC].fp1 + hCPU->fpr[frB].fp0);
-	//float s1 = (float)(hCPU->fpr[frA].fp1 * hCPU->fpr[frC].fp1 + hCPU->fpr[frB].fp1);
-	// load registers
-	uint32 fprRegisterA = PPCRecompilerImlGen_loadFPRRegister(ppcImlGenContext, PPCREC_NAME_FPR0+frA);
-	uint32 fprRegisterB = PPCRecompilerImlGen_loadFPRRegister(ppcImlGenContext, PPCREC_NAME_FPR0+frB);
-	uint32 fprRegisterC = PPCRecompilerImlGen_loadFPRRegister(ppcImlGenContext, PPCREC_NAME_FPR0+frC);
-	uint32 fprRegisterD = PPCRecompilerImlGen_loadOverwriteFPRRegister(ppcImlGenContext, PPCREC_NAME_FPR0+frD);
-	// we need a temporary register to store frC.fp1 in bottom and top half
-	uint32 fprRegisterTemp = PPCRecompilerImlGen_loadOverwriteFPRRegister(ppcImlGenContext, PPCREC_NAME_TEMPORARY_FPR0+0);
-	PPCRecompilerImlGen_generateNewInstruction_fpr_r_r(ppcImlGenContext, PPCREC_IML_OP_FPR_COPY_TOP_TO_BOTTOM_AND_TOP, fprRegisterTemp, fprRegisterC);
-	// if frD == frA and frD != frB we can multiply frD immediately and safe a copy instruction
-	if( frD == frA && frD != frB )
-	{
-		PPCRecompilerImlGen_generateNewInstruction_fpr_r_r(ppcImlGenContext, PPCREC_IML_OP_FPR_MULTIPLY_PAIR, fprRegisterD, fprRegisterTemp);
-		// add frB
-		PPCRecompilerImlGen_generateNewInstruction_fpr_r_r(ppcImlGenContext, PPCREC_IML_OP_FPR_ADD_PAIR, fprRegisterD, fprRegisterB);
-	}
-	else
-	{
-		// we multiply temporary by frA
-		PPCRecompilerImlGen_generateNewInstruction_fpr_r_r(ppcImlGenContext, PPCREC_IML_OP_FPR_MULTIPLY_PAIR, fprRegisterTemp, fprRegisterA);
-		// add frB
-		PPCRecompilerImlGen_generateNewInstruction_fpr_r_r(ppcImlGenContext, PPCREC_IML_OP_FPR_ADD_PAIR, fprRegisterTemp, fprRegisterB);
-		// copy result to frD
-		PPCRecompilerImlGen_generateNewInstruction_fpr_r_r(ppcImlGenContext, PPCREC_IML_OP_FPR_COPY_PAIR, fprRegisterD, fprRegisterTemp);
-	}
-	// adjust accuracy
-	PPRecompilerImmGen_optionalRoundPairFPRToSinglePrecision(ppcImlGenContext, fprRegisterD);
+	DefinePS0(fprAps0, frA);
+	DefinePS1(fprAps1, frA);
+	DefinePS0(fprBps0, frB);
+	DefinePS1(fprBps1, frB);
+	DefinePSX(fprC, frC, isVariant1);
+	DefinePS0(fprDps0, frD);
+	DefinePS1(fprDps1, frD);
+
+	DefineTempFPR(fprTmp0, 0);
+	DefineTempFPR(fprTmp1, 1);
+
+	// todo - round C to 25bit
+	// todo - optimize cases where a temporary is not necessary
+
+	// copy ps0 and ps1 to temporary
+	ppcImlGenContext->emitInst().make_fpr_r_r(PPCREC_IML_OP_FPR_ASSIGN, fprTmp0, fprAps0);
+	ppcImlGenContext->emitInst().make_fpr_r_r(PPCREC_IML_OP_FPR_ASSIGN, fprTmp1, fprAps1);
+
+	// multiply
+	ppcImlGenContext->emitInst().make_fpr_r_r(PPCREC_IML_OP_FPR_MULTIPLY, fprTmp0, fprC);
+	ppcImlGenContext->emitInst().make_fpr_r_r(PPCREC_IML_OP_FPR_MULTIPLY, fprTmp1, fprC);
+
+	// add
+	ppcImlGenContext->emitInst().make_fpr_r_r(PPCREC_IML_OP_FPR_ADD, fprTmp0, fprBps0);
+	ppcImlGenContext->emitInst().make_fpr_r_r(PPCREC_IML_OP_FPR_ADD, fprTmp1, fprBps1);
+
+	// copy back to result
+	ppcImlGenContext->emitInst().make_fpr_r_r(PPCREC_IML_OP_FPR_ASSIGN, fprDps0, fprTmp0);
+	ppcImlGenContext->emitInst().make_fpr_r_r(PPCREC_IML_OP_FPR_ASSIGN, fprDps1, fprTmp1);
+
+	PPRecompilerImmGen_roundToSinglePrecision(ppcImlGenContext, fprDps0);
+	PPRecompilerImmGen_roundToSinglePrecision(ppcImlGenContext, fprDps1);
 	return true;
 }
 
@@ -1369,25 +1093,34 @@ bool PPCRecompilerImlGen_PS_ADD(ppcImlGenContext_t* ppcImlGenContext, uint32 opc
 	frD = (opcode>>21)&0x1F;
 	//hCPU->fpr[frD].fp0 = hCPU->fpr[frA].fp0 + hCPU->fpr[frB].fp0;
 	//hCPU->fpr[frD].fp1 = hCPU->fpr[frA].fp1 + hCPU->fpr[frB].fp1;
-	// load registers
-	uint32 fprRegisterA = PPCRecompilerImlGen_loadFPRRegister(ppcImlGenContext, PPCREC_NAME_FPR0+frA);
-	uint32 fprRegisterB = PPCRecompilerImlGen_loadFPRRegister(ppcImlGenContext, PPCREC_NAME_FPR0+frB);
-	uint32 fprRegisterD = PPCRecompilerImlGen_loadOverwriteFPRRegister(ppcImlGenContext, PPCREC_NAME_FPR0+frD);
+
+	DefinePS0(fprDps0, frD);
+	DefinePS1(fprDps1, frD);
+	DefinePS0(fprAps0, frA);
+	DefinePS1(fprAps1, frA);
+	DefinePS0(fprBps0, frB);
+	DefinePS1(fprBps1, frB);
+
 	if( frD == frA )
 	{
-		PPCRecompilerImlGen_generateNewInstruction_fpr_r_r(ppcImlGenContext, PPCREC_IML_OP_FPR_ADD_PAIR, fprRegisterD, fprRegisterB);
+		ppcImlGenContext->emitInst().make_fpr_r_r(PPCREC_IML_OP_FPR_ADD, fprDps0, fprBps0);
+		ppcImlGenContext->emitInst().make_fpr_r_r(PPCREC_IML_OP_FPR_ADD, fprDps1, fprBps1);
 	}
 	else if( frD == frB )
 	{
-		PPCRecompilerImlGen_generateNewInstruction_fpr_r_r(ppcImlGenContext, PPCREC_IML_OP_FPR_ADD_PAIR, fprRegisterD, fprRegisterA);
+		ppcImlGenContext->emitInst().make_fpr_r_r(PPCREC_IML_OP_FPR_ADD, fprDps0, fprAps0);
+		ppcImlGenContext->emitInst().make_fpr_r_r(PPCREC_IML_OP_FPR_ADD, fprDps1, fprAps1);
 	}
 	else
 	{
-		PPCRecompilerImlGen_generateNewInstruction_fpr_r_r(ppcImlGenContext, PPCREC_IML_OP_FPR_COPY_PAIR, fprRegisterD, fprRegisterA);
-		PPCRecompilerImlGen_generateNewInstruction_fpr_r_r(ppcImlGenContext, PPCREC_IML_OP_FPR_ADD_PAIR, fprRegisterD, fprRegisterB);
+		ppcImlGenContext->emitInst().make_fpr_r_r(PPCREC_IML_OP_FPR_ASSIGN, fprDps0, fprAps0);
+		ppcImlGenContext->emitInst().make_fpr_r_r(PPCREC_IML_OP_FPR_ASSIGN, fprDps1, fprAps1);
+		ppcImlGenContext->emitInst().make_fpr_r_r(PPCREC_IML_OP_FPR_ADD, fprDps0, fprBps0);
+		ppcImlGenContext->emitInst().make_fpr_r_r(PPCREC_IML_OP_FPR_ADD, fprDps1, fprBps1);
 	}
 	// adjust accuracy
-	PPRecompilerImmGen_optionalRoundPairFPRToSinglePrecision(ppcImlGenContext, fprRegisterD);
+	PPRecompilerImmGen_roundToSinglePrecision(ppcImlGenContext, fprDps0);
+	PPRecompilerImmGen_roundToSinglePrecision(ppcImlGenContext, fprDps1);
 	return true;
 }
 
@@ -1399,13 +1132,20 @@ bool PPCRecompilerImlGen_PS_SUB(ppcImlGenContext_t* ppcImlGenContext, uint32 opc
 	frD = (opcode>>21)&0x1F;
 	//hCPU->fpr[frD].fp0 = hCPU->fpr[frA].fp0 - hCPU->fpr[frB].fp0;
 	//hCPU->fpr[frD].fp1 = hCPU->fpr[frA].fp1 - hCPU->fpr[frB].fp1;
-	// load registers
-	uint32 fprRegisterA = PPCRecompilerImlGen_loadFPRRegister(ppcImlGenContext, PPCREC_NAME_FPR0+frA);
-	uint32 fprRegisterB = PPCRecompilerImlGen_loadFPRRegister(ppcImlGenContext, PPCREC_NAME_FPR0+frB);
-	uint32 fprRegisterD = PPCRecompilerImlGen_loadOverwriteFPRRegister(ppcImlGenContext, PPCREC_NAME_FPR0+frD);
-	PPCRecompilerImlGen_generateNewInstruction_fpr_r_r_r(ppcImlGenContext, PPCREC_IML_OP_FPR_SUB_PAIR, fprRegisterD, fprRegisterA, fprRegisterB);
+
+	DefinePS0(fprDps0, frD);
+	DefinePS1(fprDps1, frD);
+	DefinePS0(fprAps0, frA);
+	DefinePS1(fprAps1, frA);
+	DefinePS0(fprBps0, frB);
+	DefinePS1(fprBps1, frB);
+
+	ppcImlGenContext->emitInst().make_fpr_r_r_r(PPCREC_IML_OP_FPR_SUB, fprDps0, fprAps0, fprBps0);
+	ppcImlGenContext->emitInst().make_fpr_r_r_r(PPCREC_IML_OP_FPR_SUB, fprDps1, fprAps1, fprBps1);
+
 	// adjust accuracy
-	PPRecompilerImmGen_optionalRoundPairFPRToSinglePrecision(ppcImlGenContext, fprRegisterD);
+	PPRecompilerImmGen_roundToSinglePrecision(ppcImlGenContext, fprDps0);
+	PPRecompilerImmGen_roundToSinglePrecision(ppcImlGenContext, fprDps1);
 	return true;
 }
 
@@ -1415,28 +1155,37 @@ bool PPCRecompilerImlGen_PS_MUL(ppcImlGenContext_t* ppcImlGenContext, uint32 opc
 	frC = (opcode >> 6) & 0x1F;
 	frA = (opcode >> 16) & 0x1F;
 	frD = (opcode >> 21) & 0x1F;
-	// load registers
-	uint32 fprRegisterA = PPCRecompilerImlGen_loadFPRRegister(ppcImlGenContext, PPCREC_NAME_FPR0 + frA);
-	uint32 fprRegisterC = PPCRecompilerImlGen_loadFPRRegister(ppcImlGenContext, PPCREC_NAME_FPR0 + frC);
-	uint32 fprRegisterD = PPCRecompilerImlGen_loadOverwriteFPRRegister(ppcImlGenContext, PPCREC_NAME_FPR0 + frD);
-	// we need a temporary register
-	uint32 fprRegisterTemp = PPCRecompilerImlGen_loadOverwriteFPRRegister(ppcImlGenContext, PPCREC_NAME_TEMPORARY_FPR0 + 0);
-	PPCRecompilerImlGen_generateNewInstruction_fpr_r_r(ppcImlGenContext, PPCREC_IML_OP_FPR_COPY_PAIR, fprRegisterTemp, fprRegisterC);
-	// todo-optimize: This instruction can be optimized so that it doesn't always use a temporary register
-	// if frD == frA we can multiply frD immediately and safe a copy instruction
+
+	DefinePS0(fprDps0, frD);
+	DefinePS1(fprDps1, frD);
+	DefinePS0(fprAps0, frA);
+	DefinePS1(fprAps1, frA);
+	DefinePS0(fprCps0, frC);
+	DefinePS1(fprCps1, frC);
+
+	DefineTempFPR(fprTemp0, 0);
+	DefineTempFPR(fprTemp1, 1);
+
+	// todo: Optimize for when a temporary isnt necessary
+	// todo: Round to 25bit?
+
+	ppcImlGenContext->emitInst().make_fpr_r_r(PPCREC_IML_OP_FPR_ASSIGN, fprTemp0, fprCps0);
+	ppcImlGenContext->emitInst().make_fpr_r_r(PPCREC_IML_OP_FPR_ASSIGN, fprTemp1, fprCps1);
 	if (frD == frA)
 	{
-		PPCRecompilerImlGen_generateNewInstruction_fpr_r_r(ppcImlGenContext, PPCREC_IML_OP_FPR_MULTIPLY_PAIR, fprRegisterD, fprRegisterTemp);
+		ppcImlGenContext->emitInst().make_fpr_r_r(PPCREC_IML_OP_FPR_MULTIPLY, fprDps0, fprTemp0);
+		ppcImlGenContext->emitInst().make_fpr_r_r(PPCREC_IML_OP_FPR_MULTIPLY, fprDps1, fprTemp1);
 	}
 	else
 	{
-		// we multiply temporary by frA
-		PPCRecompilerImlGen_generateNewInstruction_fpr_r_r(ppcImlGenContext, PPCREC_IML_OP_FPR_MULTIPLY_PAIR, fprRegisterTemp, fprRegisterA);
-		// copy result to frD
-		PPCRecompilerImlGen_generateNewInstruction_fpr_r_r(ppcImlGenContext, PPCREC_IML_OP_FPR_COPY_PAIR, fprRegisterD, fprRegisterTemp);
+		ppcImlGenContext->emitInst().make_fpr_r_r(PPCREC_IML_OP_FPR_MULTIPLY, fprTemp0, fprAps0);
+		ppcImlGenContext->emitInst().make_fpr_r_r(PPCREC_IML_OP_FPR_MULTIPLY, fprTemp1, fprAps1);
+		ppcImlGenContext->emitInst().make_fpr_r_r(PPCREC_IML_OP_FPR_ASSIGN, fprDps0, fprTemp0);
+		ppcImlGenContext->emitInst().make_fpr_r_r(PPCREC_IML_OP_FPR_ASSIGN, fprDps1, fprTemp1);
 	}
 	// adjust accuracy
-	PPRecompilerImmGen_optionalRoundPairFPRToSinglePrecision(ppcImlGenContext, fprRegisterD);
+	PPRecompilerImmGen_roundToSinglePrecision(ppcImlGenContext, fprDps0);
+	PPRecompilerImmGen_roundToSinglePrecision(ppcImlGenContext, fprDps1);
 	return true;
 }
 
@@ -1448,28 +1197,35 @@ bool PPCRecompilerImlGen_PS_DIV(ppcImlGenContext_t* ppcImlGenContext, uint32 opc
 	frD = (opcode >> 21) & 0x1F;
 	//hCPU->fpr[frD].fp0 = hCPU->fpr[frA].fp0 / hCPU->fpr[frB].fp0;
 	//hCPU->fpr[frD].fp1 = hCPU->fpr[frA].fp1 / hCPU->fpr[frB].fp1;
-	// load registers
-	uint32 fprRegisterA = PPCRecompilerImlGen_loadFPRRegister(ppcImlGenContext, PPCREC_NAME_FPR0 + frA);
-	uint32 fprRegisterB = PPCRecompilerImlGen_loadFPRRegister(ppcImlGenContext, PPCREC_NAME_FPR0 + frB);
-	uint32 fprRegisterD = PPCRecompilerImlGen_loadOverwriteFPRRegister(ppcImlGenContext, PPCREC_NAME_FPR0 + frD);
-	// todo-optimize: This instruction can be optimized so that it doesn't always use a temporary register
-	// if frD == frA we can divide frD immediately and safe a copy instruction
+
+	DefinePS0(fprDps0, frD);
+	DefinePS1(fprDps1, frD);
+	DefinePS0(fprAps0, frA);
+	DefinePS1(fprAps1, frA);
+	DefinePS0(fprBps0, frB);
+	DefinePS1(fprBps1, frB);
+
 	if (frD == frA)
 	{
-		PPCRecompilerImlGen_generateNewInstruction_fpr_r_r(ppcImlGenContext, PPCREC_IML_OP_FPR_DIVIDE_PAIR, fprRegisterD, fprRegisterB);
+		ppcImlGenContext->emitInst().make_fpr_r_r(PPCREC_IML_OP_FPR_DIVIDE, fprDps0, fprBps0);
+		ppcImlGenContext->emitInst().make_fpr_r_r(PPCREC_IML_OP_FPR_DIVIDE, fprDps1, fprBps1);
 	}
 	else
 	{
-		// we need a temporary register
-		uint32 fprRegisterTemp = PPCRecompilerImlGen_loadOverwriteFPRRegister(ppcImlGenContext, PPCREC_NAME_TEMPORARY_FPR0 + 0);
-		PPCRecompilerImlGen_generateNewInstruction_fpr_r_r(ppcImlGenContext, PPCREC_IML_OP_FPR_COPY_PAIR, fprRegisterTemp, fprRegisterA);
+		DefineTempFPR(fprTemp0, 0);
+		DefineTempFPR(fprTemp1, 1);
+		ppcImlGenContext->emitInst().make_fpr_r_r(PPCREC_IML_OP_FPR_ASSIGN, fprTemp0, fprAps0);
+		ppcImlGenContext->emitInst().make_fpr_r_r(PPCREC_IML_OP_FPR_ASSIGN, fprTemp1, fprAps1);
 		// we divide temporary by frB
-		PPCRecompilerImlGen_generateNewInstruction_fpr_r_r(ppcImlGenContext, PPCREC_IML_OP_FPR_DIVIDE_PAIR, fprRegisterTemp, fprRegisterB);
+		ppcImlGenContext->emitInst().make_fpr_r_r(PPCREC_IML_OP_FPR_DIVIDE, fprTemp0, fprBps0);
+		ppcImlGenContext->emitInst().make_fpr_r_r(PPCREC_IML_OP_FPR_DIVIDE, fprTemp1, fprBps1);
 		// copy result to frD
-		PPCRecompilerImlGen_generateNewInstruction_fpr_r_r(ppcImlGenContext, PPCREC_IML_OP_FPR_COPY_PAIR, fprRegisterD, fprRegisterTemp);
+		ppcImlGenContext->emitInst().make_fpr_r_r(PPCREC_IML_OP_FPR_ASSIGN, fprDps0, fprTemp0);
+		ppcImlGenContext->emitInst().make_fpr_r_r(PPCREC_IML_OP_FPR_ASSIGN, fprDps1, fprTemp1);
 	}
 	// adjust accuracy
-	PPRecompilerImmGen_optionalRoundPairFPRToSinglePrecision(ppcImlGenContext, fprRegisterD);
+	PPRecompilerImmGen_roundToSinglePrecision(ppcImlGenContext, fprDps0);
+	PPRecompilerImmGen_roundToSinglePrecision(ppcImlGenContext, fprDps1);
 	return true;
 }
 
@@ -1483,33 +1239,61 @@ bool PPCRecompilerImlGen_PS_MADD(ppcImlGenContext_t* ppcImlGenContext, uint32 op
 	//float s0 = (float)(hCPU->fpr[frA].fp0 * hCPU->fpr[frC].fp0 + hCPU->fpr[frB].fp0);
 	//float s1 = (float)(hCPU->fpr[frA].fp1 * hCPU->fpr[frC].fp1 + hCPU->fpr[frB].fp1);
 
-	// load registers
-	uint32 fprRegisterA = PPCRecompilerImlGen_loadFPRRegister(ppcImlGenContext, PPCREC_NAME_FPR0+frA);
-	uint32 fprRegisterB = PPCRecompilerImlGen_loadFPRRegister(ppcImlGenContext, PPCREC_NAME_FPR0+frB);
-	uint32 fprRegisterC = PPCRecompilerImlGen_loadFPRRegister(ppcImlGenContext, PPCREC_NAME_FPR0+frC);
-	uint32 fprRegisterD = PPCRecompilerImlGen_loadOverwriteFPRRegister(ppcImlGenContext, PPCREC_NAME_FPR0+frD);
-	// we need a temporary register to store frC.fp0 in low and high half
-	uint32 fprRegisterTemp = PPCRecompilerImlGen_loadOverwriteFPRRegister(ppcImlGenContext, PPCREC_NAME_TEMPORARY_FPR0+0);
-	PPCRecompilerImlGen_generateNewInstruction_fpr_r_r(ppcImlGenContext, PPCREC_IML_OP_FPR_COPY_PAIR, fprRegisterTemp, fprRegisterC);
-	// todo-optimize: This instruction can be optimized so that it doesn't always use a temporary register
-	// if frD == frA and frD != frB we can multiply frD immediately and save a copy instruction
-	if( frD == frA && frD != frB )
+	DefinePS0(fprDps0, frD);
+	DefinePS1(fprDps1, frD);
+	DefinePS0(fprAps0, frA);
+	DefinePS1(fprAps1, frA);
+	DefinePS0(fprBps0, frB);
+	DefinePS1(fprBps1, frB);
+	DefinePS0(fprCps0, frC);
+	DefinePS1(fprCps1, frC);
+
+	if (frD != frA && frD != frB)
 	{
-		PPCRecompilerImlGen_generateNewInstruction_fpr_r_r(ppcImlGenContext, PPCREC_IML_OP_FPR_MULTIPLY_PAIR, fprRegisterD, fprRegisterTemp);
-		// add frB
-		PPCRecompilerImlGen_generateNewInstruction_fpr_r_r(ppcImlGenContext, PPCREC_IML_OP_FPR_ADD_PAIR, fprRegisterD, fprRegisterB);
+		if (frD == frC)
+		{
+			ppcImlGenContext->emitInst().make_fpr_r_r(PPCREC_IML_OP_FPR_MULTIPLY, fprCps0, fprAps0);
+			ppcImlGenContext->emitInst().make_fpr_r_r(PPCREC_IML_OP_FPR_MULTIPLY, fprCps1, fprAps1);
+		}
+		else
+		{
+			ppcImlGenContext->emitInst().make_fpr_r_r(PPCREC_IML_OP_FPR_ASSIGN, fprDps0, fprAps0);
+			ppcImlGenContext->emitInst().make_fpr_r_r(PPCREC_IML_OP_FPR_ASSIGN, fprDps1, fprAps1);
+			ppcImlGenContext->emitInst().make_fpr_r_r(PPCREC_IML_OP_FPR_MULTIPLY, fprDps0, fprCps0);
+			ppcImlGenContext->emitInst().make_fpr_r_r(PPCREC_IML_OP_FPR_MULTIPLY, fprDps1, fprCps1);
+		}
+		ppcImlGenContext->emitInst().make_fpr_r_r(PPCREC_IML_OP_FPR_ADD, fprDps0, fprBps0);
+		ppcImlGenContext->emitInst().make_fpr_r_r(PPCREC_IML_OP_FPR_ADD, fprDps1, fprBps1);
 	}
 	else
 	{
-		// we multiply temporary by frA
-		PPCRecompilerImlGen_generateNewInstruction_fpr_r_r(ppcImlGenContext, PPCREC_IML_OP_FPR_MULTIPLY_PAIR, fprRegisterTemp, fprRegisterA);
-		// add frB
-		PPCRecompilerImlGen_generateNewInstruction_fpr_r_r(ppcImlGenContext, PPCREC_IML_OP_FPR_ADD_PAIR, fprRegisterTemp, fprRegisterB);
-		// copy result to frD
-		PPCRecompilerImlGen_generateNewInstruction_fpr_r_r(ppcImlGenContext, PPCREC_IML_OP_FPR_COPY_PAIR, fprRegisterD, fprRegisterTemp);
+		DefineTempFPR(fprTemp0, 0);
+		DefineTempFPR(fprTemp1, 1);
+		ppcImlGenContext->emitInst().make_fpr_r_r(PPCREC_IML_OP_FPR_ASSIGN, fprTemp0, fprCps0);
+		ppcImlGenContext->emitInst().make_fpr_r_r(PPCREC_IML_OP_FPR_ASSIGN, fprTemp1, fprCps1);
+		if( frD == frA && frD != frB )
+		{
+			ppcImlGenContext->emitInst().make_fpr_r_r(PPCREC_IML_OP_FPR_MULTIPLY, fprDps0, fprTemp0);
+			ppcImlGenContext->emitInst().make_fpr_r_r(PPCREC_IML_OP_FPR_MULTIPLY, fprDps1, fprTemp1);
+			ppcImlGenContext->emitInst().make_fpr_r_r(PPCREC_IML_OP_FPR_ADD, fprDps0, fprBps0);
+			ppcImlGenContext->emitInst().make_fpr_r_r(PPCREC_IML_OP_FPR_ADD, fprDps1, fprBps1);
+		}
+		else
+		{
+			// we multiply temporary by frA
+			ppcImlGenContext->emitInst().make_fpr_r_r(PPCREC_IML_OP_FPR_MULTIPLY, fprTemp0, fprAps0);
+			ppcImlGenContext->emitInst().make_fpr_r_r(PPCREC_IML_OP_FPR_MULTIPLY, fprTemp1, fprAps1);
+			// add frB
+			ppcImlGenContext->emitInst().make_fpr_r_r(PPCREC_IML_OP_FPR_ADD, fprTemp0, fprBps0);
+			ppcImlGenContext->emitInst().make_fpr_r_r(PPCREC_IML_OP_FPR_ADD, fprTemp1, fprBps1);
+			// copy result to frD
+			ppcImlGenContext->emitInst().make_fpr_r_r(PPCREC_IML_OP_FPR_ASSIGN, fprDps0, fprTemp0);
+			ppcImlGenContext->emitInst().make_fpr_r_r(PPCREC_IML_OP_FPR_ASSIGN, fprDps1, fprTemp1);
+		}
 	}
 	// adjust accuracy
-	PPRecompilerImmGen_optionalRoundPairFPRToSinglePrecision(ppcImlGenContext, fprRegisterD);
+	PPRecompilerImmGen_roundToSinglePrecision(ppcImlGenContext, fprDps0);
+	PPRecompilerImmGen_roundToSinglePrecision(ppcImlGenContext, fprDps1);
 	return true;
 }
 
@@ -1521,81 +1305,54 @@ bool PPCRecompilerImlGen_PS_NMADD(ppcImlGenContext_t* ppcImlGenContext, uint32 o
 	frA = (opcode>>16)&0x1F;
 	frD = (opcode>>21)&0x1F;
 
-	// load registers
-	uint32 fprRegisterA = PPCRecompilerImlGen_loadFPRRegister(ppcImlGenContext, PPCREC_NAME_FPR0+frA);
-	uint32 fprRegisterB = PPCRecompilerImlGen_loadFPRRegister(ppcImlGenContext, PPCREC_NAME_FPR0+frB);
-	uint32 fprRegisterC = PPCRecompilerImlGen_loadFPRRegister(ppcImlGenContext, PPCREC_NAME_FPR0+frC);
-	uint32 fprRegisterD = PPCRecompilerImlGen_loadOverwriteFPRRegister(ppcImlGenContext, PPCREC_NAME_FPR0+frD);
-	// we need a temporary register to store frC.fp0 in low and high half
-	uint32 fprRegisterTemp = PPCRecompilerImlGen_loadOverwriteFPRRegister(ppcImlGenContext, PPCREC_NAME_TEMPORARY_FPR0+0);
-	PPCRecompilerImlGen_generateNewInstruction_fpr_r_r(ppcImlGenContext, PPCREC_IML_OP_FPR_COPY_PAIR, fprRegisterTemp, fprRegisterC);
+	DefinePS0(fprDps0, frD);
+	DefinePS1(fprDps1, frD);
+	DefinePS0(fprAps0, frA);
+	DefinePS1(fprAps1, frA);
+	DefinePS0(fprBps0, frB);
+	DefinePS1(fprBps1, frB);
+	DefinePS0(fprCps0, frC);
+	DefinePS1(fprCps1, frC);
+
+	DefineTempFPR(fprTemp0, 0);
+	DefineTempFPR(fprTemp1, 1);
+
+	ppcImlGenContext->emitInst().make_fpr_r_r(PPCREC_IML_OP_FPR_ASSIGN, fprTemp0, fprCps0);
+	ppcImlGenContext->emitInst().make_fpr_r_r(PPCREC_IML_OP_FPR_ASSIGN, fprTemp1, fprCps1);
 	// todo-optimize: This instruction can be optimized so that it doesn't always use a temporary register
-	// if frD == frA and frD != frB we can multiply frD immediately and safe a copy instruction
+	// if frD == frA and frD != frB we can multiply frD immediately and save a copy instruction
 	if( frD == frA && frD != frB )
 	{
-		PPCRecompilerImlGen_generateNewInstruction_fpr_r_r(ppcImlGenContext, PPCREC_IML_OP_FPR_MULTIPLY_PAIR, fprRegisterD, fprRegisterTemp);
-		// add frB
-		PPCRecompilerImlGen_generateNewInstruction_fpr_r_r(ppcImlGenContext, PPCREC_IML_OP_FPR_ADD_PAIR, fprRegisterD, fprRegisterB);
+		ppcImlGenContext->emitInst().make_fpr_r_r(PPCREC_IML_OP_FPR_MULTIPLY, fprDps0, fprTemp0);
+		ppcImlGenContext->emitInst().make_fpr_r_r(PPCREC_IML_OP_FPR_MULTIPLY, fprDps1, fprTemp1);
+		ppcImlGenContext->emitInst().make_fpr_r_r(PPCREC_IML_OP_FPR_ADD, fprDps0, fprBps0);
+		ppcImlGenContext->emitInst().make_fpr_r_r(PPCREC_IML_OP_FPR_ADD, fprDps1, fprBps1);
 	}
 	else
 	{
 		// we multiply temporary by frA
-		PPCRecompilerImlGen_generateNewInstruction_fpr_r_r(ppcImlGenContext, PPCREC_IML_OP_FPR_MULTIPLY_PAIR, fprRegisterTemp, fprRegisterA);
+		ppcImlGenContext->emitInst().make_fpr_r_r(PPCREC_IML_OP_FPR_MULTIPLY, fprTemp0, fprAps0);
+		ppcImlGenContext->emitInst().make_fpr_r_r(PPCREC_IML_OP_FPR_MULTIPLY, fprTemp1, fprAps1);
 		// add frB
-		PPCRecompilerImlGen_generateNewInstruction_fpr_r_r(ppcImlGenContext, PPCREC_IML_OP_FPR_ADD_PAIR, fprRegisterTemp, fprRegisterB);
+		ppcImlGenContext->emitInst().make_fpr_r_r(PPCREC_IML_OP_FPR_ADD, fprTemp0, fprBps0);
+		ppcImlGenContext->emitInst().make_fpr_r_r(PPCREC_IML_OP_FPR_ADD, fprTemp1, fprBps1);
 		// copy result to frD
-		PPCRecompilerImlGen_generateNewInstruction_fpr_r_r(ppcImlGenContext, PPCREC_IML_OP_FPR_COPY_PAIR, fprRegisterD, fprRegisterTemp);
+		ppcImlGenContext->emitInst().make_fpr_r_r(PPCREC_IML_OP_FPR_ASSIGN, fprDps0, fprTemp0);
+		ppcImlGenContext->emitInst().make_fpr_r_r(PPCREC_IML_OP_FPR_ASSIGN, fprDps1, fprTemp1);
 	}
+
 	// negate
-	PPCRecompilerImlGen_generateNewInstruction_fpr_r_r(ppcImlGenContext, PPCREC_IML_OP_FPR_NEGATE_PAIR, fprRegisterD, fprRegisterD);
+	ppcImlGenContext->emitInst().make_fpr_r(PPCREC_IML_OP_FPR_NEGATE, fprDps0);
+	ppcImlGenContext->emitInst().make_fpr_r(PPCREC_IML_OP_FPR_NEGATE, fprDps1);
 	// adjust accuracy
 	//PPRecompilerImmGen_optionalRoundPairFPRToSinglePrecision(ppcImlGenContext, fprRegisterD);
 	// Splatoon requires that we emulate flush-to-denormals for this instruction
-	//PPCRecompilerImlGen_generateNewInstruction_fpr_r(ppcImlGenContext, NULL,PPCREC_IML_OP_FPR_ROUND_FLDN_TO_SINGLE_PRECISION_PAIR, fprRegisterD, false);
+	//ppcImlGenContext->emitInst().make_fpr_r(NULL,PPCREC_IML_OP_FPR_ROUND_FLDN_TO_SINGLE_PRECISION_PAIR, fprRegisterD, false);
 	return true;
 }
 
-bool PPCRecompilerImlGen_PS_MSUB(ppcImlGenContext_t* ppcImlGenContext, uint32 opcode)
-{
-	sint32 frD, frA, frB, frC;
-	frC = (opcode>>6)&0x1F;
-	frB = (opcode>>11)&0x1F;
-	frA = (opcode>>16)&0x1F;
-	frD = (opcode>>21)&0x1F;
-	//hCPU->fpr[frD].fp0 = (hCPU->fpr[frA].fp0 * hCPU->fpr[frC].fp0 - hCPU->fpr[frB].fp0);
-	//hCPU->fpr[frD].fp1 = (hCPU->fpr[frA].fp1 * hCPU->fpr[frC].fp1 - hCPU->fpr[frB].fp1);
-
-	// load registers
-	uint32 fprRegisterA = PPCRecompilerImlGen_loadFPRRegister(ppcImlGenContext, PPCREC_NAME_FPR0+frA);
-	uint32 fprRegisterB = PPCRecompilerImlGen_loadFPRRegister(ppcImlGenContext, PPCREC_NAME_FPR0+frB);
-	uint32 fprRegisterC = PPCRecompilerImlGen_loadFPRRegister(ppcImlGenContext, PPCREC_NAME_FPR0+frC);
-	uint32 fprRegisterD = PPCRecompilerImlGen_loadOverwriteFPRRegister(ppcImlGenContext, PPCREC_NAME_FPR0+frD);
-	// we need a temporary register to store frC.fp0 in low and high half
-	uint32 fprRegisterTemp = PPCRecompilerImlGen_loadOverwriteFPRRegister(ppcImlGenContext, PPCREC_NAME_TEMPORARY_FPR0+0);
-	PPCRecompilerImlGen_generateNewInstruction_fpr_r_r(ppcImlGenContext, PPCREC_IML_OP_FPR_COPY_PAIR, fprRegisterTemp, fprRegisterC);
-	// todo-optimize: This instruction can be optimized so that it doesn't always use a temporary register
-	// if frD == frA and frD != frB we can multiply frD immediately and safe a copy instruction
-	if( frD == frA && frD != frB )
-	{
-		PPCRecompilerImlGen_generateNewInstruction_fpr_r_r(ppcImlGenContext, PPCREC_IML_OP_FPR_MULTIPLY_PAIR, fprRegisterD, fprRegisterTemp);
-		// sub frB
-		PPCRecompilerImlGen_generateNewInstruction_fpr_r_r(ppcImlGenContext, PPCREC_IML_OP_FPR_SUB_PAIR, fprRegisterD, fprRegisterB);
-	}
-	else
-	{
-		// we multiply temporary by frA
-		PPCRecompilerImlGen_generateNewInstruction_fpr_r_r(ppcImlGenContext, PPCREC_IML_OP_FPR_MULTIPLY_PAIR, fprRegisterTemp, fprRegisterA);
-		// sub frB
-		PPCRecompilerImlGen_generateNewInstruction_fpr_r_r(ppcImlGenContext, PPCREC_IML_OP_FPR_SUB_PAIR, fprRegisterTemp, fprRegisterB);
-		// copy result to frD
-		PPCRecompilerImlGen_generateNewInstruction_fpr_r_r(ppcImlGenContext, PPCREC_IML_OP_FPR_COPY_PAIR, fprRegisterD, fprRegisterTemp);
-	}
-	// adjust accuracy
-	PPRecompilerImmGen_optionalRoundPairFPRToSinglePrecision(ppcImlGenContext, fprRegisterD);
-	return true;
-}
-
-bool PPCRecompilerImlGen_PS_NMSUB(ppcImlGenContext_t* ppcImlGenContext, uint32 opcode)
+// PS_MSUB and PS_NMSUB
+bool PPCRecompilerImlGen_PS_MSUB(ppcImlGenContext_t* ppcImlGenContext, uint32 opcode, bool withNegative)
 {
 	sint32 frD, frA, frB, frC;
 	frC = (opcode>>6)&0x1F;
@@ -1603,35 +1360,64 @@ bool PPCRecompilerImlGen_PS_NMSUB(ppcImlGenContext_t* ppcImlGenContext, uint32 o
 	frA = (opcode>>16)&0x1F;
 	frD = (opcode>>21)&0x1F;
 
-	// load registers
-	uint32 fprRegisterA = PPCRecompilerImlGen_loadFPRRegister(ppcImlGenContext, PPCREC_NAME_FPR0+frA);
-	uint32 fprRegisterB = PPCRecompilerImlGen_loadFPRRegister(ppcImlGenContext, PPCREC_NAME_FPR0+frB);
-	uint32 fprRegisterC = PPCRecompilerImlGen_loadFPRRegister(ppcImlGenContext, PPCREC_NAME_FPR0+frC);
-	uint32 fprRegisterD = PPCRecompilerImlGen_loadOverwriteFPRRegister(ppcImlGenContext, PPCREC_NAME_FPR0+frD);
-	// we need a temporary register to store frC.fp0 in low and high half
-	uint32 fprRegisterTemp = PPCRecompilerImlGen_loadOverwriteFPRRegister(ppcImlGenContext, PPCREC_NAME_TEMPORARY_FPR0+0);
-	PPCRecompilerImlGen_generateNewInstruction_fpr_r_r(ppcImlGenContext, PPCREC_IML_OP_FPR_COPY_PAIR, fprRegisterTemp, fprRegisterC);
-	// todo-optimize: This instruction can be optimized so that it doesn't always use a temporary register
-	// if frD == frA and frD != frB we can multiply frD immediately and safe a copy instruction
-	if( frD == frA && frD != frB )
+	DefinePS0(fprDps0, frD);
+	DefinePS1(fprDps1, frD);
+	DefinePS0(fprAps0, frA);
+	DefinePS1(fprAps1, frA);
+	DefinePS0(fprBps0, frB);
+	DefinePS1(fprBps1, frB);
+	DefinePS0(fprCps0, frC);
+	DefinePS1(fprCps1, frC);
+
+	if (frD != frA && frD != frB)
 	{
-		PPCRecompilerImlGen_generateNewInstruction_fpr_r_r(ppcImlGenContext, PPCREC_IML_OP_FPR_MULTIPLY_PAIR, fprRegisterD, fprRegisterTemp);
-		// sub frB
-		PPCRecompilerImlGen_generateNewInstruction_fpr_r_r(ppcImlGenContext, PPCREC_IML_OP_FPR_SUB_PAIR, fprRegisterD, fprRegisterB);
+		if (frD == frC)
+		{
+			ppcImlGenContext->emitInst().make_fpr_r_r(PPCREC_IML_OP_FPR_MULTIPLY, fprCps0, fprAps0);
+			ppcImlGenContext->emitInst().make_fpr_r_r(PPCREC_IML_OP_FPR_MULTIPLY, fprCps1, fprAps1);
+		}
+		else
+		{
+			ppcImlGenContext->emitInst().make_fpr_r_r(PPCREC_IML_OP_FPR_ASSIGN, fprDps0, fprAps0);
+			ppcImlGenContext->emitInst().make_fpr_r_r(PPCREC_IML_OP_FPR_ASSIGN, fprDps1, fprAps1);
+			ppcImlGenContext->emitInst().make_fpr_r_r(PPCREC_IML_OP_FPR_MULTIPLY, fprDps0, fprCps0);
+			ppcImlGenContext->emitInst().make_fpr_r_r(PPCREC_IML_OP_FPR_MULTIPLY, fprDps1, fprCps1);
+		}
+		ppcImlGenContext->emitInst().make_fpr_r_r(PPCREC_IML_OP_FPR_SUB, fprDps0, fprBps0);
+		ppcImlGenContext->emitInst().make_fpr_r_r(PPCREC_IML_OP_FPR_SUB, fprDps1, fprBps1);
 	}
 	else
 	{
-		// we multiply temporary by frA
-		PPCRecompilerImlGen_generateNewInstruction_fpr_r_r(ppcImlGenContext, PPCREC_IML_OP_FPR_MULTIPLY_PAIR, fprRegisterTemp, fprRegisterA);
-		// sub frB
-		PPCRecompilerImlGen_generateNewInstruction_fpr_r_r(ppcImlGenContext, PPCREC_IML_OP_FPR_SUB_PAIR, fprRegisterTemp, fprRegisterB);
-		// copy result to frD
-		PPCRecompilerImlGen_generateNewInstruction_fpr_r_r(ppcImlGenContext, PPCREC_IML_OP_FPR_COPY_PAIR, fprRegisterD, fprRegisterTemp);
+		DefineTempFPR(fprTemp0, 0);
+		DefineTempFPR(fprTemp1, 1);
+		ppcImlGenContext->emitInst().make_fpr_r_r(PPCREC_IML_OP_FPR_ASSIGN, fprTemp0, fprCps0);
+		ppcImlGenContext->emitInst().make_fpr_r_r(PPCREC_IML_OP_FPR_ASSIGN, fprTemp1, fprCps1);
+		if( frD == frA && frD != frB )
+		{
+			ppcImlGenContext->emitInst().make_fpr_r_r(PPCREC_IML_OP_FPR_MULTIPLY, fprDps0, fprTemp0);
+			ppcImlGenContext->emitInst().make_fpr_r_r(PPCREC_IML_OP_FPR_MULTIPLY, fprDps1, fprTemp1);
+			ppcImlGenContext->emitInst().make_fpr_r_r(PPCREC_IML_OP_FPR_SUB, fprDps0, fprBps0);
+			ppcImlGenContext->emitInst().make_fpr_r_r(PPCREC_IML_OP_FPR_SUB, fprDps1, fprBps1);
+		}
+		else
+		{
+			ppcImlGenContext->emitInst().make_fpr_r_r(PPCREC_IML_OP_FPR_MULTIPLY, fprTemp0, fprAps0);
+			ppcImlGenContext->emitInst().make_fpr_r_r(PPCREC_IML_OP_FPR_MULTIPLY, fprTemp1, fprAps1);
+			ppcImlGenContext->emitInst().make_fpr_r_r(PPCREC_IML_OP_FPR_SUB, fprTemp0, fprBps0);
+			ppcImlGenContext->emitInst().make_fpr_r_r(PPCREC_IML_OP_FPR_SUB, fprTemp1, fprBps1);
+			ppcImlGenContext->emitInst().make_fpr_r_r(PPCREC_IML_OP_FPR_ASSIGN, fprDps0, fprTemp0);
+			ppcImlGenContext->emitInst().make_fpr_r_r(PPCREC_IML_OP_FPR_ASSIGN, fprDps1, fprTemp1);
+		}
 	}
 	// negate result
-	PPCRecompilerImlGen_generateNewInstruction_fpr_r_r(ppcImlGenContext, PPCREC_IML_OP_FPR_NEGATE_PAIR, fprRegisterD, fprRegisterD);
+	if (withNegative)
+	{
+		ppcImlGenContext->emitInst().make_fpr_r(PPCREC_IML_OP_FPR_NEGATE, fprDps0);
+		ppcImlGenContext->emitInst().make_fpr_r(PPCREC_IML_OP_FPR_NEGATE, fprDps1);
+	}
 	// adjust accuracy
-	PPRecompilerImmGen_optionalRoundPairFPRToSinglePrecision(ppcImlGenContext, fprRegisterD);
+	PPRecompilerImmGen_roundToSinglePrecision(ppcImlGenContext, fprDps0);
+	PPRecompilerImmGen_roundToSinglePrecision(ppcImlGenContext, fprDps1);
 	return true;
 }
 
@@ -1642,18 +1428,27 @@ bool PPCRecompilerImlGen_PS_SUM0(ppcImlGenContext_t* ppcImlGenContext, uint32 op
 	frB = (opcode>>11)&0x1F;
 	frA = (opcode>>16)&0x1F;
 	frD = (opcode>>21)&0x1F;
-	//float s0 = (float)(hCPU->fpr[frA].fp0 + hCPU->fpr[frB].fp1);
-	//float s1 = (float)hCPU->fpr[frC].fp1;
-	//hCPU->fpr[frD].fp0 = s0;
-	//hCPU->fpr[frD].fp1 = s1;
-	// load registers
-	uint32 fprRegisterA = PPCRecompilerImlGen_loadFPRRegister(ppcImlGenContext, PPCREC_NAME_FPR0+frA);
-	uint32 fprRegisterB = PPCRecompilerImlGen_loadFPRRegister(ppcImlGenContext, PPCREC_NAME_FPR0+frB);
-	uint32 fprRegisterC = PPCRecompilerImlGen_loadFPRRegister(ppcImlGenContext, PPCREC_NAME_FPR0+frC);
-	uint32 fprRegisterD = PPCRecompilerImlGen_loadOverwriteFPRRegister(ppcImlGenContext, PPCREC_NAME_FPR0+frD);
-	PPCRecompilerImlGen_generateNewInstruction_fpr_r_r_r_r(ppcImlGenContext, PPCREC_IML_OP_FPR_SUM0, fprRegisterD, fprRegisterA, fprRegisterB, fprRegisterC);
+
+	DefinePS0(fprDps0, frD);
+	DefinePS1(fprDps1, frD);
+	DefinePS0(fprAps0, frA);
+	DefinePS1(fprBps1, frB);
+	DefinePS1(fprCps1, frC);
+
+	if( frD == frA )
+	{
+		ppcImlGenContext->emitInst().make_fpr_r_r(PPCREC_IML_OP_FPR_ADD, fprDps0, fprBps1);
+	}
+	else
+	{
+		ppcImlGenContext->emitInst().make_fpr_r_r(PPCREC_IML_OP_FPR_ASSIGN, fprDps0, fprAps0);
+		ppcImlGenContext->emitInst().make_fpr_r_r(PPCREC_IML_OP_FPR_ADD, fprDps0, fprBps1);
+	}
+	if (fprDps1 != fprCps1)
+		ppcImlGenContext->emitInst().make_fpr_r_r(PPCREC_IML_OP_FPR_ASSIGN, fprDps1, fprCps1);
 	// adjust accuracy
-	PPRecompilerImmGen_optionalRoundPairFPRToSinglePrecision(ppcImlGenContext, fprRegisterD);
+	PPRecompilerImmGen_roundToSinglePrecision(ppcImlGenContext, fprDps0);
+	PPRecompilerImmGen_roundToSinglePrecision(ppcImlGenContext, fprDps1);
 	return true;
 }
 
@@ -1664,18 +1459,26 @@ bool PPCRecompilerImlGen_PS_SUM1(ppcImlGenContext_t* ppcImlGenContext, uint32 op
 	frB = (opcode>>11)&0x1F;
 	frA = (opcode>>16)&0x1F;
 	frD = (opcode>>21)&0x1F;
-	//float s0 = (float)hCPU->fpr[frC].fp0;
-	//float s1 = (float)(hCPU->fpr[frA].fp0 + hCPU->fpr[frB].fp1);
-	//hCPU->fpr[frD].fp0 = s0;
-	//hCPU->fpr[frD].fp1 = s1;
-	// load registers
-	uint32 fprRegisterA = PPCRecompilerImlGen_loadFPRRegister(ppcImlGenContext, PPCREC_NAME_FPR0+frA);
-	uint32 fprRegisterB = PPCRecompilerImlGen_loadFPRRegister(ppcImlGenContext, PPCREC_NAME_FPR0+frB);
-	uint32 fprRegisterC = PPCRecompilerImlGen_loadFPRRegister(ppcImlGenContext, PPCREC_NAME_FPR0+frC);
-	uint32 fprRegisterD = PPCRecompilerImlGen_loadOverwriteFPRRegister(ppcImlGenContext, PPCREC_NAME_FPR0+frD);
-	PPCRecompilerImlGen_generateNewInstruction_fpr_r_r_r_r(ppcImlGenContext, PPCREC_IML_OP_FPR_SUM1, fprRegisterD, fprRegisterA, fprRegisterB, fprRegisterC);
+
+	DefinePS0(fprDps0, frD);
+	DefinePS1(fprDps1, frD);
+	DefinePS0(fprAps0, frA);
+	DefinePS1(fprBps1, frB);
+	DefinePS0(fprCps0, frC);
+
+	if (frB != frD)
+	{
+		ppcImlGenContext->emitInst().make_fpr_r_r(PPCREC_IML_OP_FPR_ASSIGN, fprDps1, fprAps0);
+		ppcImlGenContext->emitInst().make_fpr_r_r(PPCREC_IML_OP_FPR_ADD, fprDps1, fprBps1);
+	}
+	else
+		ppcImlGenContext->emitInst().make_fpr_r_r(PPCREC_IML_OP_FPR_ADD, fprDps1, fprAps0);
+
+	ppcImlGenContext->emitInst().make_fpr_r_r(PPCREC_IML_OP_FPR_ASSIGN, fprDps0, fprCps0);
+
 	// adjust accuracy
-	PPRecompilerImmGen_optionalRoundPairFPRToSinglePrecision(ppcImlGenContext, fprRegisterD);
+	PPRecompilerImmGen_roundToSinglePrecision(ppcImlGenContext, fprDps0);
+	PPRecompilerImmGen_roundToSinglePrecision(ppcImlGenContext, fprDps1);
 	return true;
 }
 
@@ -1684,12 +1487,20 @@ bool PPCRecompilerImlGen_PS_NEG(ppcImlGenContext_t* ppcImlGenContext, uint32 opc
 	sint32 frD, frB;
 	frB = (opcode>>11)&0x1F;
 	frD = (opcode>>21)&0x1F;
-	//hCPU->fpr[frD].fp0 = -hCPU->fpr[frB].fp0;
-	//hCPU->fpr[frD].fp1 = -hCPU->fpr[frB].fp1;
-	// load registers
-	uint32 fprRegisterB = PPCRecompilerImlGen_loadFPRRegister(ppcImlGenContext, PPCREC_NAME_FPR0+frB);
-	uint32 fprRegisterD = PPCRecompilerImlGen_loadOverwriteFPRRegister(ppcImlGenContext, PPCREC_NAME_FPR0+frD);
-	PPCRecompilerImlGen_generateNewInstruction_fpr_r_r(ppcImlGenContext, PPCREC_IML_OP_FPR_NEGATE_PAIR, fprRegisterD, fprRegisterB);
+
+	DefinePS0(fprBps0, frB);
+	DefinePS1(fprBps1, frB);
+	DefinePS0(fprDps0, frD);
+	DefinePS1(fprDps1, frD);
+
+	if (frB != frD)
+	{
+		// copy
+		ppcImlGenContext->emitInst().make_fpr_r_r(PPCREC_IML_OP_FPR_ASSIGN, fprDps0, fprBps0);
+		ppcImlGenContext->emitInst().make_fpr_r_r(PPCREC_IML_OP_FPR_ASSIGN, fprDps1, fprBps1);
+	}
+	ppcImlGenContext->emitInst().make_fpr_r(PPCREC_IML_OP_FPR_NEGATE, fprDps0);
+	ppcImlGenContext->emitInst().make_fpr_r(PPCREC_IML_OP_FPR_NEGATE, fprDps1);
 	return true;
 }
 
@@ -1698,10 +1509,17 @@ bool PPCRecompilerImlGen_PS_ABS(ppcImlGenContext_t* ppcImlGenContext, uint32 opc
 	sint32 frD, frB;
 	frB = (opcode>>11)&0x1F;
 	frD = (opcode>>21)&0x1F;
-	// load registers
-	uint32 fprRegisterB = PPCRecompilerImlGen_loadFPRRegister(ppcImlGenContext, PPCREC_NAME_FPR0+frB);
-	uint32 fprRegisterD = PPCRecompilerImlGen_loadOverwriteFPRRegister(ppcImlGenContext, PPCREC_NAME_FPR0+frD);
-	PPCRecompilerImlGen_generateNewInstruction_fpr_r_r(ppcImlGenContext, PPCREC_IML_OP_FPR_ABS_PAIR, fprRegisterD, fprRegisterB);
+
+	DefinePS0(fprBps0, frB);
+	DefinePS1(fprBps1, frB);
+	DefinePS0(fprDps0, frD);
+	DefinePS1(fprDps1, frD);
+
+	ppcImlGenContext->emitInst().make_fpr_r_r(PPCREC_IML_OP_FPR_ASSIGN, fprDps0, fprBps0);
+	ppcImlGenContext->emitInst().make_fpr_r_r(PPCREC_IML_OP_FPR_ASSIGN, fprDps1, fprBps1);
+
+	ppcImlGenContext->emitInst().make_fpr_r(PPCREC_IML_OP_FPR_ABS, fprDps0);
+	ppcImlGenContext->emitInst().make_fpr_r(PPCREC_IML_OP_FPR_ABS, fprDps1);
 	return true;
 }
 
@@ -1713,11 +1531,16 @@ bool PPCRecompilerImlGen_PS_RES(ppcImlGenContext_t* ppcImlGenContext, uint32 opc
 	//hCPU->fpr[frD].fp0 = (float)(1.0f / (float)hCPU->fpr[frB].fp0);
 	//hCPU->fpr[frD].fp1 = (float)(1.0f / (float)hCPU->fpr[frB].fp1);
 
-	// load registers
-	uint32 fprRegisterB = PPCRecompilerImlGen_loadFPRRegister(ppcImlGenContext, PPCREC_NAME_FPR0+frB);
-	uint32 fprRegisterD = PPCRecompilerImlGen_loadOverwriteFPRRegister(ppcImlGenContext, PPCREC_NAME_FPR0+frD);
+	DefinePS0(fprBps0, frB);
+	DefinePS1(fprBps1, frB);
+	DefinePS0(fprDps0, frD);
+	DefinePS1(fprDps1, frD);
 
-	PPCRecompilerImlGen_generateNewInstruction_fpr_r_r(ppcImlGenContext, PPCREC_IML_OP_FPR_FRES_PAIR, fprRegisterD, fprRegisterB);
+	ppcImlGenContext->emitInst().make_call_imm((uintptr_t)fres_espresso, fprBps0, IMLREG_INVALID, IMLREG_INVALID, fprDps0);
+	ppcImlGenContext->emitInst().make_call_imm((uintptr_t)fres_espresso, fprBps1, IMLREG_INVALID, IMLREG_INVALID, fprDps1);
+	// adjust accuracy
+	PPRecompilerImmGen_roundToSinglePrecision(ppcImlGenContext, fprDps0);
+	PPRecompilerImmGen_roundToSinglePrecision(ppcImlGenContext, fprDps1);
 	return true;
 }
 
@@ -1726,13 +1549,17 @@ bool PPCRecompilerImlGen_PS_RSQRTE(ppcImlGenContext_t* ppcImlGenContext, uint32
 	sint32 frD, frB;
 	frB = (opcode>>11)&0x1F;
 	frD = (opcode>>21)&0x1F;
-	//hCPU->fpr[frD].fp0 = (float)(1.0f / (float)sqrt(hCPU->fpr[frB].fp0));
-	//hCPU->fpr[frD].fp1 = (float)(1.0f / (float)sqrt(hCPU->fpr[frB].fp1));
 
-	// load registers
-	uint32 fprRegisterB = PPCRecompilerImlGen_loadFPRRegister(ppcImlGenContext, PPCREC_NAME_FPR0+frB);
-	uint32 fprRegisterD = PPCRecompilerImlGen_loadOverwriteFPRRegister(ppcImlGenContext, PPCREC_NAME_FPR0+frD);
-	PPCRecompilerImlGen_generateNewInstruction_fpr_r_r(ppcImlGenContext, PPCREC_IML_OP_FPR_FRSQRTE_PAIR, fprRegisterD, fprRegisterB);
+	DefinePS0(fprBps0, frB);
+	DefinePS1(fprBps1, frB);
+	DefinePS0(fprDps0, frD);
+	DefinePS1(fprDps1, frD);
+
+	ppcImlGenContext->emitInst().make_call_imm((uintptr_t)frsqrte_espresso, fprBps0, IMLREG_INVALID, IMLREG_INVALID, fprDps0);
+	ppcImlGenContext->emitInst().make_call_imm((uintptr_t)frsqrte_espresso, fprBps1, IMLREG_INVALID, IMLREG_INVALID, fprDps1);
+	// adjust accuracy
+	PPRecompilerImmGen_roundToSinglePrecision(ppcImlGenContext, fprDps0);
+	PPRecompilerImmGen_roundToSinglePrecision(ppcImlGenContext, fprDps1);
 	return true;
 }
 
@@ -1741,14 +1568,15 @@ bool PPCRecompilerImlGen_PS_MR(ppcImlGenContext_t* ppcImlGenContext, uint32 opco
 	sint32 frD, frB;
 	frB = (opcode>>11)&0x1F;
 	frD = (opcode>>21)&0x1F;
-	//hCPU->fpr[frD].fp0 = hCPU->fpr[frB].fp0;
-	//hCPU->fpr[frD].fp1 = hCPU->fpr[frB].fp1;
-	// load registers
 	if( frB != frD )
 	{
-		uint32 fprRegisterB = PPCRecompilerImlGen_loadFPRRegister(ppcImlGenContext, PPCREC_NAME_FPR0+frB);
-		uint32 fprRegisterD = PPCRecompilerImlGen_loadOverwriteFPRRegister(ppcImlGenContext, PPCREC_NAME_FPR0+frD);
-		PPCRecompilerImlGen_generateNewInstruction_fpr_r_r(ppcImlGenContext, PPCREC_IML_OP_FPR_COPY_PAIR, fprRegisterD, fprRegisterB);
+		DefinePS0(fprBps0, frB);
+		DefinePS1(fprBps1, frB);
+		DefinePS0(fprDps0, frD);
+		DefinePS1(fprDps1, frD);
+
+		ppcImlGenContext->emitInst().make_fpr_r_r(PPCREC_IML_OP_FPR_ASSIGN, fprDps0, fprBps0);
+		ppcImlGenContext->emitInst().make_fpr_r_r(PPCREC_IML_OP_FPR_ASSIGN, fprDps1, fprBps1);
 	}
 	return true;
 }
@@ -1761,11 +1589,17 @@ bool PPCRecompilerImlGen_PS_SEL(ppcImlGenContext_t* ppcImlGenContext, uint32 opc
 	frA = (opcode>>16)&0x1F;
 	frD = (opcode>>21)&0x1F;
 
-	uint32 fprRegisterA = PPCRecompilerImlGen_loadFPRRegister(ppcImlGenContext, PPCREC_NAME_FPR0+frA);
-	uint32 fprRegisterB = PPCRecompilerImlGen_loadFPRRegister(ppcImlGenContext, PPCREC_NAME_FPR0+frB);
-	uint32 fprRegisterC = PPCRecompilerImlGen_loadFPRRegister(ppcImlGenContext, PPCREC_NAME_FPR0+frC);
-	uint32 fprRegisterD = PPCRecompilerImlGen_loadOverwriteFPRRegister(ppcImlGenContext, PPCREC_NAME_FPR0+frD);
-	PPCRecompilerImlGen_generateNewInstruction_fpr_r_r_r_r(ppcImlGenContext, PPCREC_IML_OP_FPR_SELECT_PAIR, fprRegisterD, fprRegisterA, fprRegisterB, fprRegisterC);
+	DefinePS0(fprAps0, frA);
+	DefinePS1(fprAps1, frA);
+	DefinePS0(fprBps0, frB);
+	DefinePS1(fprBps1, frB);
+	DefinePS0(fprCps0, frC);
+	DefinePS1(fprCps1, frC);
+	DefinePS0(fprDps0, frD);
+	DefinePS1(fprDps1, frD);
+
+	ppcImlGenContext->emitInst().make_fpr_r_r_r_r(PPCREC_IML_OP_FPR_SELECT, fprDps0, fprAps0, fprBps0, fprCps0);
+	ppcImlGenContext->emitInst().make_fpr_r_r_r_r(PPCREC_IML_OP_FPR_SELECT, fprDps1, fprAps1, fprBps1, fprCps1);
 	return true;
 }
 
@@ -1775,26 +1609,13 @@ bool PPCRecompilerImlGen_PS_MERGE00(ppcImlGenContext_t* ppcImlGenContext, uint32
 	frB = (opcode>>11)&0x1F;
 	frA = (opcode>>16)&0x1F;
 	frD = (opcode>>21)&0x1F;
-	//float s0 = (float)hCPU->fpr[frA].fp0;
-	//float s1 = (float)hCPU->fpr[frB].fp0;
-	//hCPU->fpr[frD].fp0 = s0;
-	//hCPU->fpr[frD].fp1 = s1;
-	uint32 fprRegisterA = PPCRecompilerImlGen_loadFPRRegister(ppcImlGenContext, PPCREC_NAME_FPR0+frA);
-	uint32 fprRegisterB = PPCRecompilerImlGen_loadFPRRegister(ppcImlGenContext, PPCREC_NAME_FPR0+frB);
-	uint32 fprRegisterD = PPCRecompilerImlGen_loadOverwriteFPRRegister(ppcImlGenContext, PPCREC_NAME_FPR0+frD);
-	// unpcklpd
-	if( frA == frB )
-	{
-		// simply duplicate bottom into bottom and top of destination register
-		PPCRecompilerImlGen_generateNewInstruction_fpr_r_r(ppcImlGenContext, PPCREC_IML_OP_FPR_COPY_BOTTOM_TO_BOTTOM_AND_TOP, fprRegisterD, fprRegisterA);
-	}
-	else
-	{
-		// copy bottom of frB to top first
-		PPCRecompilerImlGen_generateNewInstruction_fpr_r_r(ppcImlGenContext, PPCREC_IML_OP_FPR_COPY_BOTTOM_TO_TOP, fprRegisterD, fprRegisterB);
-		// copy bottom of frA
-		PPCRecompilerImlGen_generateNewInstruction_fpr_r_r(ppcImlGenContext, PPCREC_IML_OP_FPR_COPY_BOTTOM_TO_BOTTOM, fprRegisterD, fprRegisterA);
-	}
+	DefinePS0(frpAps0, frA);
+	DefinePS0(frpBps0, frB);
+	DefinePS0(frpDps0, frD);
+	DefinePS1(frpDps1, frD);
+	ppcImlGenContext->emitInst().make_fpr_r_r(PPCREC_IML_OP_FPR_ASSIGN, frpDps1, frpBps0);
+	if (frpDps0 != frpAps0)
+		ppcImlGenContext->emitInst().make_fpr_r_r(PPCREC_IML_OP_FPR_ASSIGN, frpDps0, frpAps0);
 	return true;
 }
 
@@ -1804,17 +1625,14 @@ bool PPCRecompilerImlGen_PS_MERGE01(ppcImlGenContext_t* ppcImlGenContext, uint32
 	frB = (opcode>>11)&0x1F;
 	frA = (opcode>>16)&0x1F;
 	frD = (opcode>>21)&0x1F;
-	// hCPU->fpr[frD].fp0 = hCPU->fpr[frA].fp0;
-	// hCPU->fpr[frD].fp1 = hCPU->fpr[frB].fp1;
-	uint32 fprRegisterA = PPCRecompilerImlGen_loadFPRRegister(ppcImlGenContext, PPCREC_NAME_FPR0+frA);
-	uint32 fprRegisterB = PPCRecompilerImlGen_loadFPRRegister(ppcImlGenContext, PPCREC_NAME_FPR0+frB);
-	uint32 fprRegisterD = PPCRecompilerImlGen_loadOverwriteFPRRegister(ppcImlGenContext, PPCREC_NAME_FPR0+frD);
-
-	if( fprRegisterD != fprRegisterB )
-		PPCRecompilerImlGen_generateNewInstruction_fpr_r_r(ppcImlGenContext, PPCREC_IML_OP_FPR_COPY_TOP_TO_TOP, fprRegisterD, fprRegisterB);
-	if( fprRegisterD != fprRegisterA )
-		PPCRecompilerImlGen_generateNewInstruction_fpr_r_r(ppcImlGenContext, PPCREC_IML_OP_FPR_COPY_BOTTOM_TO_BOTTOM, fprRegisterD, fprRegisterA);
+	DefinePS0(frpAps0, frA);
+	DefinePS1(frpBps1, frB);
+	DefinePS0(frpDps0, frD);
+	DefinePS1(frpDps1, frD);
 
+	if (frpDps0 != frpAps0)
+		ppcImlGenContext->emitInst().make_fpr_r_r(PPCREC_IML_OP_FPR_ASSIGN, frpDps0, frpAps0);
+	ppcImlGenContext->emitInst().make_fpr_r_r(PPCREC_IML_OP_FPR_ASSIGN, frpDps1, frpBps1);
 	return true;
 }
 
@@ -1825,33 +1643,22 @@ bool PPCRecompilerImlGen_PS_MERGE10(ppcImlGenContext_t* ppcImlGenContext, uint32
 	frA = (opcode>>16)&0x1F;
 	frD = (opcode>>21)&0x1F;
 
-	uint32 fprRegisterA = PPCRecompilerImlGen_loadFPRRegister(ppcImlGenContext, PPCREC_NAME_FPR0+frA);
-	uint32 fprRegisterB = PPCRecompilerImlGen_loadFPRRegister(ppcImlGenContext, PPCREC_NAME_FPR0+frB);
-	uint32 fprRegisterD = PPCRecompilerImlGen_loadOverwriteFPRRegister(ppcImlGenContext, PPCREC_NAME_FPR0+frD);
-	if( frA == frB )
+	DefinePS1(frpAps1, frA);
+	DefinePS0(frpBps0, frB);
+	DefinePS0(frpDps0, frD);
+	DefinePS1(frpDps1, frD);
+
+	if (frD != frB)
 	{
-		// swap bottom and top
-		PPCRecompilerImlGen_generateNewInstruction_fpr_r_r(ppcImlGenContext, PPCREC_IML_OP_FPR_COPY_BOTTOM_AND_TOP_SWAPPED, fprRegisterD, fprRegisterA);
-	}
-	else if( frA == frD )
-	{
-		// copy frB bottom to frD bottom
-		PPCRecompilerImlGen_generateNewInstruction_fpr_r_r(ppcImlGenContext, PPCREC_IML_OP_FPR_COPY_BOTTOM_TO_BOTTOM, fprRegisterD, fprRegisterB);
-		// swap lower and upper half of frD
-		PPCRecompilerImlGen_generateNewInstruction_fpr_r_r(ppcImlGenContext, PPCREC_IML_OP_FPR_COPY_BOTTOM_AND_TOP_SWAPPED, fprRegisterD, fprRegisterD);
-	}
-	else if( frB == frD )
-	{
-		// copy upper half of frA to upper half of frD
-		PPCRecompilerImlGen_generateNewInstruction_fpr_r_r(ppcImlGenContext, PPCREC_IML_OP_FPR_COPY_TOP_TO_TOP, fprRegisterD, fprRegisterA);
-		// swap lower and upper half of frD
-		PPCRecompilerImlGen_generateNewInstruction_fpr_r_r(ppcImlGenContext, PPCREC_IML_OP_FPR_COPY_BOTTOM_AND_TOP_SWAPPED, fprRegisterD, fprRegisterD);
+		ppcImlGenContext->emitInst().make_fpr_r_r(PPCREC_IML_OP_FPR_ASSIGN, frpDps0, frpAps1);
+		ppcImlGenContext->emitInst().make_fpr_r_r(PPCREC_IML_OP_FPR_ASSIGN, frpDps1, frpBps0);
 	}
 	else
 	{
-		PPCRecompilerImlGen_generateNewInstruction_fpr_r_r(ppcImlGenContext, PPCREC_IML_OP_FPR_COPY_TOP_TO_BOTTOM_AND_TOP, fprRegisterD, fprRegisterA);
-		PPCRecompilerImlGen_generateNewInstruction_fpr_r_r(ppcImlGenContext, PPCREC_IML_OP_FPR_COPY_BOTTOM_TO_BOTTOM, fprRegisterD, fprRegisterB);
-		PPCRecompilerImlGen_generateNewInstruction_fpr_r_r(ppcImlGenContext, PPCREC_IML_OP_FPR_COPY_BOTTOM_AND_TOP_SWAPPED, fprRegisterD, fprRegisterD);
+		DefineTempFPR(frpTemp, 0);
+		ppcImlGenContext->emitInst().make_fpr_r_r(PPCREC_IML_OP_FPR_ASSIGN, frpTemp, frpBps0);
+		ppcImlGenContext->emitInst().make_fpr_r_r(PPCREC_IML_OP_FPR_ASSIGN, frpDps0, frpAps1);
+		ppcImlGenContext->emitInst().make_fpr_r_r(PPCREC_IML_OP_FPR_ASSIGN, frpDps1, frpTemp);
 	}
 	return true;
 }
@@ -1863,42 +1670,20 @@ bool PPCRecompilerImlGen_PS_MERGE11(ppcImlGenContext_t* ppcImlGenContext, uint32
 	frA = (opcode>>16)&0x1F;
 	frD = (opcode>>21)&0x1F;
 
-	uint32 fprRegisterA = PPCRecompilerImlGen_loadFPRRegister(ppcImlGenContext, PPCREC_NAME_FPR0+frA);
-	uint32 fprRegisterB = PPCRecompilerImlGen_loadFPRRegister(ppcImlGenContext, PPCREC_NAME_FPR0+frB);
-	uint32 fprRegisterD = PPCRecompilerImlGen_loadOverwriteFPRRegister(ppcImlGenContext, PPCREC_NAME_FPR0+frD);
-	if( fprRegisterA == fprRegisterB )
-	{
-		PPCRecompilerImlGen_generateNewInstruction_fpr_r_r(ppcImlGenContext, PPCREC_IML_OP_FPR_COPY_TOP_TO_BOTTOM_AND_TOP, fprRegisterD, fprRegisterA);
-	}
-	else if( fprRegisterD != fprRegisterB )
-	{
-		PPCRecompilerImlGen_generateNewInstruction_fpr_r_r(ppcImlGenContext, PPCREC_IML_OP_FPR_COPY_TOP_TO_BOTTOM_AND_TOP, fprRegisterD, fprRegisterA);
-		PPCRecompilerImlGen_generateNewInstruction_fpr_r_r(ppcImlGenContext, PPCREC_IML_OP_FPR_COPY_TOP_TO_TOP, fprRegisterD, fprRegisterB);
-	}
-	else if( fprRegisterD == fprRegisterB )
-	{
-		PPCRecompilerImlGen_generateNewInstruction_fpr_r_r(ppcImlGenContext, PPCREC_IML_OP_FPR_COPY_TOP_TO_BOTTOM, fprRegisterD, fprRegisterA);
-	}
-	else
-	{
-		debugBreakpoint();
-		return false;
-	}
+	DefinePS1(frpAps1, frA);
+	DefinePS1(frpBps1, frB);
+	DefinePS0(frpDps0, frD);
+	DefinePS1(frpDps1, frD);
+
+	ppcImlGenContext->emitInst().make_fpr_r_r(PPCREC_IML_OP_FPR_ASSIGN, frpDps0, frpAps1);
+	ppcImlGenContext->emitInst().make_fpr_r_r(PPCREC_IML_OP_FPR_ASSIGN, frpDps1, frpBps1);
 	return true;
 }
 
 bool PPCRecompilerImlGen_PS_CMPO0(ppcImlGenContext_t* ppcImlGenContext, uint32 opcode)
 {
-	sint32 crfD, frA, frB;
-	uint32 c=0;
-	frB = (opcode>>11)&0x1F;
-	frA = (opcode>>16)&0x1F;
-	crfD = (opcode>>23)&0x7;
-
-	uint32 fprRegisterA = PPCRecompilerImlGen_loadFPRRegister(ppcImlGenContext, PPCREC_NAME_FPR0+frA);
-	uint32 fprRegisterB = PPCRecompilerImlGen_loadFPRRegister(ppcImlGenContext, PPCREC_NAME_FPR0+frB);
-	PPCRecompilerImlGen_generateNewInstruction_fpr_r_r(ppcImlGenContext, PPCREC_IML_OP_FPR_FCMPO_BOTTOM, fprRegisterA, fprRegisterB, crfD);
-	return true;
+	// Not implemented
+	return false;
 }
 
 bool PPCRecompilerImlGen_PS_CMPU0(ppcImlGenContext_t* ppcImlGenContext, uint32 opcode)
@@ -1907,9 +1692,21 @@ bool PPCRecompilerImlGen_PS_CMPU0(ppcImlGenContext_t* ppcImlGenContext, uint32 o
 	frB = (opcode >> 11) & 0x1F;
 	frA = (opcode >> 16) & 0x1F;
 	crfD = (opcode >> 23) & 0x7;
-	uint32 fprRegisterA = PPCRecompilerImlGen_loadFPRRegister(ppcImlGenContext, PPCREC_NAME_FPR0 + frA);
-	uint32 fprRegisterB = PPCRecompilerImlGen_loadFPRRegister(ppcImlGenContext, PPCREC_NAME_FPR0 + frB);
-	PPCRecompilerImlGen_generateNewInstruction_fpr_r_r(ppcImlGenContext, PPCREC_IML_OP_FPR_FCMPU_BOTTOM, fprRegisterA, fprRegisterB, crfD);
+
+	DefinePS0(fprA, frA);
+	DefinePS0(fprB, frB);
+
+	IMLReg crBitRegLT = _GetRegCR(ppcImlGenContext, crfD, Espresso::CR_BIT::CR_BIT_INDEX_LT);
+	IMLReg crBitRegGT = _GetRegCR(ppcImlGenContext, crfD, Espresso::CR_BIT::CR_BIT_INDEX_GT);
+	IMLReg crBitRegEQ = _GetRegCR(ppcImlGenContext, crfD, Espresso::CR_BIT::CR_BIT_INDEX_EQ);
+	IMLReg crBitRegSO = _GetRegCR(ppcImlGenContext, crfD, Espresso::CR_BIT::CR_BIT_INDEX_SO);
+
+	ppcImlGenContext->emitInst().make_fpr_compare(fprA, fprB, crBitRegLT, IMLCondition::UNORDERED_LT);
+	ppcImlGenContext->emitInst().make_fpr_compare(fprA, fprB, crBitRegGT, IMLCondition::UNORDERED_GT);
+	ppcImlGenContext->emitInst().make_fpr_compare(fprA, fprB, crBitRegEQ, IMLCondition::UNORDERED_EQ);
+	ppcImlGenContext->emitInst().make_fpr_compare(fprA, fprB, crBitRegSO, IMLCondition::UNORDERED_U);
+
+	// todo: set fpscr
 	return true;
 }
 
@@ -1919,8 +1716,18 @@ bool PPCRecompilerImlGen_PS_CMPU1(ppcImlGenContext_t* ppcImlGenContext, uint32 o
 	frB = (opcode >> 11) & 0x1F;
 	frA = (opcode >> 16) & 0x1F;
 	crfD = (opcode >> 23) & 0x7;
-	uint32 fprRegisterA = PPCRecompilerImlGen_loadFPRRegister(ppcImlGenContext, PPCREC_NAME_FPR0 + frA);
-	uint32 fprRegisterB = PPCRecompilerImlGen_loadFPRRegister(ppcImlGenContext, PPCREC_NAME_FPR0 + frB);
-	PPCRecompilerImlGen_generateNewInstruction_fpr_r_r(ppcImlGenContext, PPCREC_IML_OP_FPR_FCMPU_TOP, fprRegisterA, fprRegisterB, crfD);
+
+	DefinePS1(fprA, frA);
+	DefinePS1(fprB, frB);
+
+	IMLReg crBitRegLT = _GetRegCR(ppcImlGenContext, crfD, Espresso::CR_BIT::CR_BIT_INDEX_LT);
+	IMLReg crBitRegGT = _GetRegCR(ppcImlGenContext, crfD, Espresso::CR_BIT::CR_BIT_INDEX_GT);
+	IMLReg crBitRegEQ = _GetRegCR(ppcImlGenContext, crfD, Espresso::CR_BIT::CR_BIT_INDEX_EQ);
+	IMLReg crBitRegSO = _GetRegCR(ppcImlGenContext, crfD, Espresso::CR_BIT::CR_BIT_INDEX_SO);
+
+	ppcImlGenContext->emitInst().make_fpr_compare(fprA, fprB, crBitRegLT, IMLCondition::UNORDERED_LT);
+	ppcImlGenContext->emitInst().make_fpr_compare(fprA, fprB, crBitRegGT, IMLCondition::UNORDERED_GT);
+	ppcImlGenContext->emitInst().make_fpr_compare(fprA, fprB, crBitRegEQ, IMLCondition::UNORDERED_EQ);
+	ppcImlGenContext->emitInst().make_fpr_compare(fprA, fprB, crBitRegSO, IMLCondition::UNORDERED_U);
 	return true;
-}
\ No newline at end of file
+}
diff --git a/src/Cafe/HW/Espresso/Recompiler/PPCRecompilerImlOptimizer.cpp b/src/Cafe/HW/Espresso/Recompiler/PPCRecompilerImlOptimizer.cpp
deleted file mode 100644
index 1a15bd22..00000000
--- a/src/Cafe/HW/Espresso/Recompiler/PPCRecompilerImlOptimizer.cpp
+++ /dev/null
@@ -1,2175 +0,0 @@
-#include "../Interpreter/PPCInterpreterInternal.h"
-#include "PPCRecompiler.h"
-#include "PPCRecompilerIml.h"
-#include "PPCRecompilerX64.h"
-
-void PPCRecompiler_checkRegisterUsage(ppcImlGenContext_t* ppcImlGenContext, PPCRecImlInstruction_t* imlInstruction, PPCImlOptimizerUsedRegisters_t* registersUsed)
-{
-	registersUsed->readNamedReg1 = -1;
-	registersUsed->readNamedReg2 = -1;
-	registersUsed->readNamedReg3 = -1;
-	registersUsed->writtenNamedReg1 = -1;
-	registersUsed->readFPR1 = -1;
-	registersUsed->readFPR2 = -1;
-	registersUsed->readFPR3 = -1;
-	registersUsed->readFPR4 = -1;
-	registersUsed->writtenFPR1 = -1;
-	if( imlInstruction->type == PPCREC_IML_TYPE_R_NAME )
-	{
-		registersUsed->writtenNamedReg1 = imlInstruction->op_r_name.registerIndex;
-	}
-	else if( imlInstruction->type == PPCREC_IML_TYPE_NAME_R )
-	{
-		registersUsed->readNamedReg1 = imlInstruction->op_r_name.registerIndex;
-	}
-	else if( imlInstruction->type == PPCREC_IML_TYPE_R_R )
-	{
-		if (imlInstruction->operation == PPCREC_IML_OP_COMPARE_SIGNED || imlInstruction->operation == PPCREC_IML_OP_COMPARE_UNSIGNED || imlInstruction->operation == PPCREC_IML_OP_DCBZ)
-		{
-			// both operands are read only
-			registersUsed->readNamedReg1 = imlInstruction->op_r_r.registerResult;
-			registersUsed->readNamedReg2 = imlInstruction->op_r_r.registerA;
-		}
-		else if (
-			imlInstruction->operation == PPCREC_IML_OP_OR ||
-			imlInstruction->operation == PPCREC_IML_OP_AND ||
-			imlInstruction->operation == PPCREC_IML_OP_XOR ||
-			imlInstruction->operation == PPCREC_IML_OP_ADD ||
-			imlInstruction->operation == PPCREC_IML_OP_ADD_CARRY ||
-			imlInstruction->operation == PPCREC_IML_OP_ADD_CARRY_ME ||
-			imlInstruction->operation == PPCREC_IML_OP_SUB_CARRY_UPDATE_CARRY)
-		{
-			// result is read and written, operand is read
-			registersUsed->writtenNamedReg1 = imlInstruction->op_r_r.registerResult;
-			registersUsed->readNamedReg1 = imlInstruction->op_r_r.registerResult;
-			registersUsed->readNamedReg2 = imlInstruction->op_r_r.registerA;
-		}
-		else if (
-			imlInstruction->operation == PPCREC_IML_OP_ASSIGN ||
-			imlInstruction->operation == PPCREC_IML_OP_ENDIAN_SWAP ||
-			imlInstruction->operation == PPCREC_IML_OP_CNTLZW ||
-			imlInstruction->operation == PPCREC_IML_OP_NOT ||
-			imlInstruction->operation == PPCREC_IML_OP_NEG ||
-			imlInstruction->operation == PPCREC_IML_OP_ASSIGN_S16_TO_S32 ||
-			imlInstruction->operation == PPCREC_IML_OP_ASSIGN_S8_TO_S32)
-		{
-			// result is written, operand is read
-			registersUsed->writtenNamedReg1 = imlInstruction->op_r_r.registerResult;
-			registersUsed->readNamedReg1 = imlInstruction->op_r_r.registerA;
-		}
-		else
-			cemu_assert_unimplemented();
-	}
-	else if (imlInstruction->type == PPCREC_IML_TYPE_R_S32)
-	{
-		if (imlInstruction->operation == PPCREC_IML_OP_COMPARE_SIGNED || imlInstruction->operation == PPCREC_IML_OP_COMPARE_UNSIGNED || imlInstruction->operation == PPCREC_IML_OP_MTCRF)
-		{
-			// operand register is read only
-			registersUsed->readNamedReg1 = imlInstruction->op_r_immS32.registerIndex;
-		}
-		else if (imlInstruction->operation == PPCREC_IML_OP_ADD ||
-			imlInstruction->operation == PPCREC_IML_OP_SUB ||
-			imlInstruction->operation == PPCREC_IML_OP_AND ||
-			imlInstruction->operation == PPCREC_IML_OP_OR ||
-			imlInstruction->operation == PPCREC_IML_OP_XOR ||
-			imlInstruction->operation == PPCREC_IML_OP_LEFT_ROTATE)
-		{
-			// operand register is read and write
-			registersUsed->readNamedReg1 = imlInstruction->op_r_immS32.registerIndex;
-			registersUsed->writtenNamedReg1 = imlInstruction->op_r_immS32.registerIndex;
-		}
-		else
-		{
-			// operand register is write only
-			// todo - use explicit lists, avoid default cases
-			registersUsed->writtenNamedReg1 = imlInstruction->op_r_immS32.registerIndex;
-		}
-	}
-	else if (imlInstruction->type == PPCREC_IML_TYPE_CONDITIONAL_R_S32)
-	{
-		if (imlInstruction->operation == PPCREC_IML_OP_ASSIGN)
-		{
-			// result is written, but also considered read (in case the condition fails)
-			registersUsed->readNamedReg1 = imlInstruction->op_conditional_r_s32.registerIndex;
-			registersUsed->writtenNamedReg1 = imlInstruction->op_conditional_r_s32.registerIndex;
-		}
-		else
-			cemu_assert_unimplemented();
-	}
-	else if( imlInstruction->type == PPCREC_IML_TYPE_R_R_S32 )
-	{
-		if( imlInstruction->operation == PPCREC_IML_OP_RLWIMI )
-		{
-			// result and operand register are both read, result is written
-			registersUsed->writtenNamedReg1 = imlInstruction->op_r_r_s32.registerResult;
-			registersUsed->readNamedReg1 = imlInstruction->op_r_r_s32.registerResult;
-			registersUsed->readNamedReg2 = imlInstruction->op_r_r_s32.registerA;
-		}
-		else
-		{
-			// result is write only and operand is read only
-			registersUsed->writtenNamedReg1 = imlInstruction->op_r_r_s32.registerResult;
-			registersUsed->readNamedReg1 = imlInstruction->op_r_r_s32.registerA;
-		}
-	}
-	else if( imlInstruction->type == PPCREC_IML_TYPE_R_R_R )
-	{
-		// in all cases result is written and other operands are read only
-		registersUsed->writtenNamedReg1 = imlInstruction->op_r_r_r.registerResult;
-		registersUsed->readNamedReg1 = imlInstruction->op_r_r_r.registerA;
-		registersUsed->readNamedReg2 = imlInstruction->op_r_r_r.registerB;
-	}
-	else if( imlInstruction->type == PPCREC_IML_TYPE_CJUMP || imlInstruction->type == PPCREC_IML_TYPE_CJUMP_CYCLE_CHECK )
-	{
-		// no effect on registers
-	}
-	else if( imlInstruction->type == PPCREC_IML_TYPE_NO_OP )
-	{
-		// no effect on registers
-	}
-	else if( imlInstruction->type == PPCREC_IML_TYPE_MACRO )
-	{
-		if( imlInstruction->operation == PPCREC_IML_MACRO_BL || imlInstruction->operation == PPCREC_IML_MACRO_B_FAR || imlInstruction->operation == PPCREC_IML_MACRO_BLR || imlInstruction->operation == PPCREC_IML_MACRO_BLRL || imlInstruction->operation == PPCREC_IML_MACRO_BCTR || imlInstruction->operation == PPCREC_IML_MACRO_BCTRL || imlInstruction->operation == PPCREC_IML_MACRO_LEAVE || imlInstruction->operation == PPCREC_IML_MACRO_DEBUGBREAK || imlInstruction->operation == PPCREC_IML_MACRO_COUNT_CYCLES || imlInstruction->operation == PPCREC_IML_MACRO_HLE || imlInstruction->operation == PPCREC_IML_MACRO_MFTB )
-		{
-			// no effect on registers
-		}
-		else
-			cemu_assert_unimplemented();
-	}
-	else if (imlInstruction->type == PPCREC_IML_TYPE_LOAD)
-	{
-		registersUsed->writtenNamedReg1 = imlInstruction->op_storeLoad.registerData;
-		if (imlInstruction->op_storeLoad.registerMem != PPC_REC_INVALID_REGISTER)
-			registersUsed->readNamedReg1 = imlInstruction->op_storeLoad.registerMem;
-	}
-	else if (imlInstruction->type == PPCREC_IML_TYPE_MEM2MEM)
-	{
-		registersUsed->readNamedReg1 = imlInstruction->op_mem2mem.src.registerMem;
-		registersUsed->readNamedReg2 = imlInstruction->op_mem2mem.dst.registerMem;
-	}
-	else if( imlInstruction->type == PPCREC_IML_TYPE_LOAD_INDEXED )
-	{
-		registersUsed->writtenNamedReg1 = imlInstruction->op_storeLoad.registerData;
-		if( imlInstruction->op_storeLoad.registerMem != PPC_REC_INVALID_REGISTER )
-			registersUsed->readNamedReg1 = imlInstruction->op_storeLoad.registerMem;
-		if( imlInstruction->op_storeLoad.registerMem2 != PPC_REC_INVALID_REGISTER )
-			registersUsed->readNamedReg2 = imlInstruction->op_storeLoad.registerMem2;
-	}
-	else if( imlInstruction->type == PPCREC_IML_TYPE_STORE )
-	{
-		registersUsed->readNamedReg1 = imlInstruction->op_storeLoad.registerData;
-		if( imlInstruction->op_storeLoad.registerMem != PPC_REC_INVALID_REGISTER )
-			registersUsed->readNamedReg2 = imlInstruction->op_storeLoad.registerMem;
-	}
-	else if( imlInstruction->type == PPCREC_IML_TYPE_STORE_INDEXED )
-	{
-		registersUsed->readNamedReg1 = imlInstruction->op_storeLoad.registerData;
-		if( imlInstruction->op_storeLoad.registerMem != PPC_REC_INVALID_REGISTER )
-			registersUsed->readNamedReg2 = imlInstruction->op_storeLoad.registerMem;
-		if( imlInstruction->op_storeLoad.registerMem2 != PPC_REC_INVALID_REGISTER )
-			registersUsed->readNamedReg3 = imlInstruction->op_storeLoad.registerMem2;
-	}
-	else if( imlInstruction->type == PPCREC_IML_TYPE_CR )
-	{
-		// only affects cr register	
-	}
-	else if( imlInstruction->type == PPCREC_IML_TYPE_JUMPMARK )
-	{
-		// no effect on registers
-	}
-	else if( imlInstruction->type == PPCREC_IML_TYPE_PPC_ENTER )
-	{
-		// no op
-	}
-	else if( imlInstruction->type == PPCREC_IML_TYPE_FPR_R_NAME )
-	{
-		// fpr operation
-		registersUsed->writtenFPR1 = imlInstruction->op_r_name.registerIndex;
-	}
-	else if( imlInstruction->type == PPCREC_IML_TYPE_FPR_NAME_R )
-	{
-		// fpr operation
-		registersUsed->readFPR1 = imlInstruction->op_r_name.registerIndex;
-	}
-	else if( imlInstruction->type == PPCREC_IML_TYPE_FPR_LOAD )
-	{
-		// fpr load operation
-		registersUsed->writtenFPR1 = imlInstruction->op_storeLoad.registerData;
-		// address is in gpr register
-		if (imlInstruction->op_storeLoad.registerMem != PPC_REC_INVALID_REGISTER)
-			registersUsed->readNamedReg1 = imlInstruction->op_storeLoad.registerMem;
-		// determine partially written result
-		switch (imlInstruction->op_storeLoad.mode)
-		{
-		case PPCREC_FPR_LD_MODE_PSQ_GENERIC_PS0:
-		case PPCREC_FPR_LD_MODE_PSQ_GENERIC_PS0_PS1:
-			cemu_assert_debug(imlInstruction->op_storeLoad.registerGQR != PPC_REC_INVALID_REGISTER);
-			registersUsed->readNamedReg2 = imlInstruction->op_storeLoad.registerGQR;
-			break;
-		case PPCREC_FPR_LD_MODE_DOUBLE_INTO_PS0:
-			// PS1 remains the same
-			registersUsed->readFPR4 = imlInstruction->op_storeLoad.registerData;
-			break;
-		case PPCREC_FPR_LD_MODE_SINGLE_INTO_PS0_PS1:
-		case PPCREC_FPR_LD_MODE_PSQ_FLOAT_PS0_PS1:
-		case PPCREC_FPR_LD_MODE_PSQ_FLOAT_PS0:
-		case PPCREC_FPR_LD_MODE_PSQ_S16_PS0:
-		case PPCREC_FPR_LD_MODE_PSQ_S16_PS0_PS1:
-		case PPCREC_FPR_LD_MODE_PSQ_U16_PS0_PS1:
-		case PPCREC_FPR_LD_MODE_PSQ_U16_PS0:
-		case PPCREC_FPR_LD_MODE_PSQ_S8_PS0_PS1:
-		case PPCREC_FPR_LD_MODE_PSQ_U8_PS0_PS1:
-		case PPCREC_FPR_LD_MODE_PSQ_U8_PS0:
-		case PPCREC_FPR_LD_MODE_PSQ_S8_PS0:
-			break;
-		default:
-			cemu_assert_unimplemented();
-		}
-	}
-	else if( imlInstruction->type == PPCREC_IML_TYPE_FPR_LOAD_INDEXED )
-	{
-		// fpr load operation
-		registersUsed->writtenFPR1 = imlInstruction->op_storeLoad.registerData;
-		// address is in gpr registers
-		if (imlInstruction->op_storeLoad.registerMem != PPC_REC_INVALID_REGISTER)
-			registersUsed->readNamedReg1 = imlInstruction->op_storeLoad.registerMem;
-		if (imlInstruction->op_storeLoad.registerMem2 != PPC_REC_INVALID_REGISTER)
-			registersUsed->readNamedReg2 = imlInstruction->op_storeLoad.registerMem2;
-		// determine partially written result
-		switch (imlInstruction->op_storeLoad.mode)
-		{
-		case PPCREC_FPR_LD_MODE_PSQ_GENERIC_PS0:
-		case PPCREC_FPR_LD_MODE_PSQ_GENERIC_PS0_PS1:
-			cemu_assert_debug(imlInstruction->op_storeLoad.registerGQR != PPC_REC_INVALID_REGISTER);
-			registersUsed->readNamedReg3 = imlInstruction->op_storeLoad.registerGQR;
-			break;
-		case PPCREC_FPR_LD_MODE_DOUBLE_INTO_PS0:
-			// PS1 remains the same
-			registersUsed->readFPR4 = imlInstruction->op_storeLoad.registerData;
-			break;
-		case PPCREC_FPR_LD_MODE_SINGLE_INTO_PS0_PS1:
-		case PPCREC_FPR_LD_MODE_PSQ_FLOAT_PS0_PS1:
-		case PPCREC_FPR_LD_MODE_PSQ_FLOAT_PS0:
-		case PPCREC_FPR_LD_MODE_PSQ_S16_PS0:
-		case PPCREC_FPR_LD_MODE_PSQ_S16_PS0_PS1:
-		case PPCREC_FPR_LD_MODE_PSQ_U16_PS0_PS1:
-		case PPCREC_FPR_LD_MODE_PSQ_U16_PS0:
-		case PPCREC_FPR_LD_MODE_PSQ_S8_PS0_PS1:
-		case PPCREC_FPR_LD_MODE_PSQ_U8_PS0_PS1:
-		case PPCREC_FPR_LD_MODE_PSQ_U8_PS0:
-			break;
-		default:
-			cemu_assert_unimplemented();
-		}
-	}
-	else if( imlInstruction->type == PPCREC_IML_TYPE_FPR_STORE )
-	{
-		// fpr store operation
-		registersUsed->readFPR1 = imlInstruction->op_storeLoad.registerData;
-		if( imlInstruction->op_storeLoad.registerMem != PPC_REC_INVALID_REGISTER )
-			registersUsed->readNamedReg1 = imlInstruction->op_storeLoad.registerMem;
-		// PSQ generic stores also access GQR
-		switch (imlInstruction->op_storeLoad.mode)
-		{
-		case PPCREC_FPR_ST_MODE_PSQ_GENERIC_PS0:
-		case PPCREC_FPR_ST_MODE_PSQ_GENERIC_PS0_PS1:
-			cemu_assert_debug(imlInstruction->op_storeLoad.registerGQR != PPC_REC_INVALID_REGISTER);
-			registersUsed->readNamedReg2 = imlInstruction->op_storeLoad.registerGQR;
-			break;
-		default:
-			break;
-		}
-	}
-	else if( imlInstruction->type == PPCREC_IML_TYPE_FPR_STORE_INDEXED )
-	{
-		// fpr store operation
-		registersUsed->readFPR1 = imlInstruction->op_storeLoad.registerData;
-		// address is in gpr registers
-		if( imlInstruction->op_storeLoad.registerMem != PPC_REC_INVALID_REGISTER )
-			registersUsed->readNamedReg1 = imlInstruction->op_storeLoad.registerMem;
-		if( imlInstruction->op_storeLoad.registerMem2 != PPC_REC_INVALID_REGISTER )
-			registersUsed->readNamedReg2 = imlInstruction->op_storeLoad.registerMem2;
-		// PSQ generic stores also access GQR
-		switch (imlInstruction->op_storeLoad.mode)
-		{
-		case PPCREC_FPR_ST_MODE_PSQ_GENERIC_PS0:
-		case PPCREC_FPR_ST_MODE_PSQ_GENERIC_PS0_PS1:
-			cemu_assert_debug(imlInstruction->op_storeLoad.registerGQR != PPC_REC_INVALID_REGISTER);
-			registersUsed->readNamedReg3 = imlInstruction->op_storeLoad.registerGQR;
-			break;
-		default:
-			break;
-		}
-	}
-	else if( imlInstruction->type == PPCREC_IML_TYPE_FPR_R_R )
-	{
-		// fpr operation
-		if( imlInstruction->operation == PPCREC_IML_OP_FPR_COPY_BOTTOM_TO_BOTTOM_AND_TOP ||
-			imlInstruction->operation == PPCREC_IML_OP_FPR_COPY_TOP_TO_BOTTOM_AND_TOP ||
-			imlInstruction->operation == PPCREC_IML_OP_FPR_COPY_BOTTOM_AND_TOP_SWAPPED ||
-			imlInstruction->operation == PPCREC_IML_OP_ASSIGN ||
-			imlInstruction->operation == PPCREC_IML_OP_FPR_BOTTOM_FRES_TO_BOTTOM_AND_TOP ||
-			imlInstruction->operation == PPCREC_IML_OP_FPR_NEGATE_PAIR ||
-			imlInstruction->operation == PPCREC_IML_OP_FPR_ABS_PAIR ||
-			imlInstruction->operation == PPCREC_IML_OP_FPR_FRES_PAIR ||
-			imlInstruction->operation == PPCREC_IML_OP_FPR_FRSQRTE_PAIR )
-		{
-			// operand read, result written
-			registersUsed->readFPR1 = imlInstruction->op_fpr_r_r.registerOperand;
-			registersUsed->writtenFPR1 = imlInstruction->op_fpr_r_r.registerResult;
-		}
-		else if( 
-			imlInstruction->operation == PPCREC_IML_OP_FPR_COPY_BOTTOM_TO_BOTTOM ||
-			imlInstruction->operation == PPCREC_IML_OP_FPR_COPY_BOTTOM_TO_TOP ||
-			imlInstruction->operation == PPCREC_IML_OP_FPR_COPY_TOP_TO_TOP ||
-			imlInstruction->operation == PPCREC_IML_OP_FPR_COPY_TOP_TO_BOTTOM ||
-			imlInstruction->operation == PPCREC_IML_OP_FPR_EXPAND_BOTTOM32_TO_BOTTOM64_AND_TOP64 ||
-			imlInstruction->operation == PPCREC_IML_OP_FPR_BOTTOM_FCTIWZ ||
-			imlInstruction->operation == PPCREC_IML_OP_FPR_BOTTOM_RECIPROCAL_SQRT
-			 )
-		{
-			// operand read, result read and (partially) written
-			registersUsed->readFPR1 = imlInstruction->op_fpr_r_r.registerOperand;
-			registersUsed->readFPR4 = imlInstruction->op_fpr_r_r.registerResult;
-			registersUsed->writtenFPR1 = imlInstruction->op_fpr_r_r.registerResult;
-		}
-		else if( imlInstruction->operation == PPCREC_IML_OP_FPR_MULTIPLY_BOTTOM ||
-			imlInstruction->operation == PPCREC_IML_OP_FPR_MULTIPLY_PAIR ||
-			imlInstruction->operation == PPCREC_IML_OP_FPR_DIVIDE_BOTTOM ||
-			imlInstruction->operation == PPCREC_IML_OP_FPR_DIVIDE_PAIR ||
-			imlInstruction->operation == PPCREC_IML_OP_FPR_ADD_BOTTOM ||
-			imlInstruction->operation == PPCREC_IML_OP_FPR_ADD_PAIR ||
-			imlInstruction->operation == PPCREC_IML_OP_FPR_SUB_PAIR ||
-			imlInstruction->operation == PPCREC_IML_OP_FPR_SUB_BOTTOM )
-		{
-			// operand read, result read and written
-			registersUsed->readFPR1 = imlInstruction->op_fpr_r_r.registerOperand;
-			registersUsed->readFPR2 = imlInstruction->op_fpr_r_r.registerResult;
-			registersUsed->writtenFPR1 = imlInstruction->op_fpr_r_r.registerResult;
-
-		}
-		else if(imlInstruction->operation == PPCREC_IML_OP_FPR_FCMPU_BOTTOM ||
-			imlInstruction->operation == PPCREC_IML_OP_FPR_FCMPU_TOP ||
-			imlInstruction->operation == PPCREC_IML_OP_FPR_FCMPO_BOTTOM)
-		{
-			// operand read, result read
-			registersUsed->readFPR1 = imlInstruction->op_fpr_r_r.registerOperand;
-			registersUsed->readFPR2 = imlInstruction->op_fpr_r_r.registerResult;
-		}
-		else
-			cemu_assert_unimplemented();
-	}
-	else if( imlInstruction->type == PPCREC_IML_TYPE_FPR_R_R_R )
-	{
-		// fpr operation
-		registersUsed->readFPR1 = imlInstruction->op_fpr_r_r_r.registerOperandA;
-		registersUsed->readFPR2 = imlInstruction->op_fpr_r_r_r.registerOperandB;
-		registersUsed->writtenFPR1 = imlInstruction->op_fpr_r_r_r.registerResult;
-		// handle partially written result
-		switch (imlInstruction->operation)
-		{
-		case PPCREC_IML_OP_FPR_MULTIPLY_BOTTOM:
-		case PPCREC_IML_OP_FPR_ADD_BOTTOM:
-		case PPCREC_IML_OP_FPR_SUB_BOTTOM:
-			registersUsed->readFPR4 = imlInstruction->op_fpr_r_r_r.registerResult;
-			break;
-		case PPCREC_IML_OP_FPR_SUB_PAIR:
-			break;
-		default:
-			cemu_assert_unimplemented();
-		}
-	}
-	else if( imlInstruction->type == PPCREC_IML_TYPE_FPR_R_R_R_R )
-	{
-		// fpr operation
-		registersUsed->readFPR1 = imlInstruction->op_fpr_r_r_r_r.registerOperandA;
-		registersUsed->readFPR2 = imlInstruction->op_fpr_r_r_r_r.registerOperandB;
-		registersUsed->readFPR3 = imlInstruction->op_fpr_r_r_r_r.registerOperandC;
-		registersUsed->writtenFPR1 = imlInstruction->op_fpr_r_r_r_r.registerResult;
-		// handle partially written result
-		switch (imlInstruction->operation)
-		{
-		case PPCREC_IML_OP_FPR_SELECT_BOTTOM:
-			registersUsed->readFPR4 = imlInstruction->op_fpr_r_r_r_r.registerResult;
-			break;
-		case PPCREC_IML_OP_FPR_SUM0:
-		case PPCREC_IML_OP_FPR_SUM1:
-		case PPCREC_IML_OP_FPR_SELECT_PAIR:
-			break;
-		default:
-			cemu_assert_unimplemented();
-		}
-	}
-	else if( imlInstruction->type == PPCREC_IML_TYPE_FPR_R )
-	{
-		// fpr operation
-		if( imlInstruction->operation == PPCREC_IML_OP_FPR_NEGATE_BOTTOM ||
-			imlInstruction->operation == PPCREC_IML_OP_FPR_ABS_BOTTOM ||
-			imlInstruction->operation == PPCREC_IML_OP_FPR_NEGATIVE_ABS_BOTTOM ||
-			imlInstruction->operation == PPCREC_IML_OP_FPR_EXPAND_BOTTOM32_TO_BOTTOM64_AND_TOP64 ||
-			imlInstruction->operation == PPCREC_IML_OP_FPR_ROUND_TO_SINGLE_PRECISION_BOTTOM ||
-			imlInstruction->operation == PPCREC_IML_OP_FPR_ROUND_TO_SINGLE_PRECISION_PAIR )
-		{
-			registersUsed->readFPR1 = imlInstruction->op_fpr_r.registerResult;
-			registersUsed->writtenFPR1 = imlInstruction->op_fpr_r.registerResult;		
-		}
-		else
-			cemu_assert_unimplemented();
-	}
-	else
-	{
-		cemu_assert_unimplemented();
-	}
-}
-
-#define replaceRegister(__x,__r,__n) (((__x)==(__r))?(__n):(__x))
-
-sint32 replaceRegisterMultiple(sint32 reg, sint32 match[4], sint32 replaced[4])
-{
-	for (sint32 i = 0; i < 4; i++)
-	{
-		if(match[i] < 0)
-			continue;
-		if (reg == match[i])
-		{
-			return replaced[i];
-		}
-	}
-	return reg;
-}
-
-void PPCRecompiler_replaceGPRRegisterUsageMultiple(ppcImlGenContext_t* ppcImlGenContext, PPCRecImlInstruction_t* imlInstruction, sint32 gprRegisterSearched[4], sint32 gprRegisterReplaced[4])
-{
-	if (imlInstruction->type == PPCREC_IML_TYPE_R_NAME)
-	{
-		imlInstruction->op_r_name.registerIndex = replaceRegisterMultiple(imlInstruction->op_r_name.registerIndex, gprRegisterSearched, gprRegisterReplaced);
-	}
-	else if (imlInstruction->type == PPCREC_IML_TYPE_NAME_R)
-	{
-		imlInstruction->op_r_name.registerIndex = replaceRegisterMultiple(imlInstruction->op_r_name.registerIndex, gprRegisterSearched, gprRegisterReplaced);
-	}
-	else if (imlInstruction->type == PPCREC_IML_TYPE_R_R)
-	{
-		imlInstruction->op_r_r.registerResult = replaceRegisterMultiple(imlInstruction->op_r_r.registerResult, gprRegisterSearched, gprRegisterReplaced);
-		imlInstruction->op_r_r.registerA = replaceRegisterMultiple(imlInstruction->op_r_r.registerA, gprRegisterSearched, gprRegisterReplaced);
-	}
-	else if (imlInstruction->type == PPCREC_IML_TYPE_R_S32)
-	{
-		imlInstruction->op_r_immS32.registerIndex = replaceRegisterMultiple(imlInstruction->op_r_immS32.registerIndex, gprRegisterSearched, gprRegisterReplaced);
-	}
-	else if (imlInstruction->type == PPCREC_IML_TYPE_CONDITIONAL_R_S32)
-	{
-		imlInstruction->op_conditional_r_s32.registerIndex = replaceRegisterMultiple(imlInstruction->op_conditional_r_s32.registerIndex, gprRegisterSearched, gprRegisterReplaced);
-	}
-	else if (imlInstruction->type == PPCREC_IML_TYPE_R_R_S32)
-	{
-		// in all cases result is written and other operand is read only
-		imlInstruction->op_r_r_s32.registerResult = replaceRegisterMultiple(imlInstruction->op_r_r_s32.registerResult, gprRegisterSearched, gprRegisterReplaced);
-		imlInstruction->op_r_r_s32.registerA = replaceRegisterMultiple(imlInstruction->op_r_r_s32.registerA, gprRegisterSearched, gprRegisterReplaced);
-	}
-	else if (imlInstruction->type == PPCREC_IML_TYPE_R_R_R)
-	{
-		// in all cases result is written and other operands are read only
-		imlInstruction->op_r_r_r.registerResult = replaceRegisterMultiple(imlInstruction->op_r_r_r.registerResult, gprRegisterSearched, gprRegisterReplaced);
-		imlInstruction->op_r_r_r.registerA = replaceRegisterMultiple(imlInstruction->op_r_r_r.registerA, gprRegisterSearched, gprRegisterReplaced);
-		imlInstruction->op_r_r_r.registerB = replaceRegisterMultiple(imlInstruction->op_r_r_r.registerB, gprRegisterSearched, gprRegisterReplaced);
-	}
-	else if (imlInstruction->type == PPCREC_IML_TYPE_CJUMP || imlInstruction->type == PPCREC_IML_TYPE_CJUMP_CYCLE_CHECK)
-	{
-		// no effect on registers
-	}
-	else if (imlInstruction->type == PPCREC_IML_TYPE_NO_OP)
-	{
-		// no effect on registers
-	}
-	else if (imlInstruction->type == PPCREC_IML_TYPE_MACRO)
-	{
-		if (imlInstruction->operation == PPCREC_IML_MACRO_BL || imlInstruction->operation == PPCREC_IML_MACRO_B_FAR || imlInstruction->operation == PPCREC_IML_MACRO_BLR || imlInstruction->operation == PPCREC_IML_MACRO_BLRL || imlInstruction->operation == PPCREC_IML_MACRO_BCTR || imlInstruction->operation == PPCREC_IML_MACRO_BCTRL || imlInstruction->operation == PPCREC_IML_MACRO_LEAVE || imlInstruction->operation == PPCREC_IML_MACRO_DEBUGBREAK || imlInstruction->operation == PPCREC_IML_MACRO_HLE || imlInstruction->operation == PPCREC_IML_MACRO_MFTB || imlInstruction->operation == PPCREC_IML_MACRO_COUNT_CYCLES )
-		{
-			// no effect on registers
-		}
-		else
-		{
-			cemu_assert_unimplemented();
-		}
-	}
-	else if (imlInstruction->type == PPCREC_IML_TYPE_LOAD)
-	{
-		imlInstruction->op_storeLoad.registerData = replaceRegisterMultiple(imlInstruction->op_storeLoad.registerData, gprRegisterSearched, gprRegisterReplaced);
-		if (imlInstruction->op_storeLoad.registerMem != PPC_REC_INVALID_REGISTER)
-		{
-			imlInstruction->op_storeLoad.registerMem = replaceRegisterMultiple(imlInstruction->op_storeLoad.registerMem, gprRegisterSearched, gprRegisterReplaced);
-		}
-	}
-	else if (imlInstruction->type == PPCREC_IML_TYPE_LOAD_INDEXED)
-	{
-		imlInstruction->op_storeLoad.registerData = replaceRegisterMultiple(imlInstruction->op_storeLoad.registerData, gprRegisterSearched, gprRegisterReplaced);
-		if (imlInstruction->op_storeLoad.registerMem != PPC_REC_INVALID_REGISTER)
-			imlInstruction->op_storeLoad.registerMem = replaceRegisterMultiple(imlInstruction->op_storeLoad.registerMem, gprRegisterSearched, gprRegisterReplaced);
-		if (imlInstruction->op_storeLoad.registerMem2 != PPC_REC_INVALID_REGISTER)
-			imlInstruction->op_storeLoad.registerMem2 = replaceRegisterMultiple(imlInstruction->op_storeLoad.registerMem2, gprRegisterSearched, gprRegisterReplaced);
-	}
-	else if (imlInstruction->type == PPCREC_IML_TYPE_STORE)
-	{
-		imlInstruction->op_storeLoad.registerData = replaceRegisterMultiple(imlInstruction->op_storeLoad.registerData, gprRegisterSearched, gprRegisterReplaced);
-		if (imlInstruction->op_storeLoad.registerMem != PPC_REC_INVALID_REGISTER)
-			imlInstruction->op_storeLoad.registerMem = replaceRegisterMultiple(imlInstruction->op_storeLoad.registerMem, gprRegisterSearched, gprRegisterReplaced);
-	}
-	else if (imlInstruction->type == PPCREC_IML_TYPE_STORE_INDEXED)
-	{
-		imlInstruction->op_storeLoad.registerData = replaceRegisterMultiple(imlInstruction->op_storeLoad.registerData, gprRegisterSearched, gprRegisterReplaced);
-		if (imlInstruction->op_storeLoad.registerMem != PPC_REC_INVALID_REGISTER)
-			imlInstruction->op_storeLoad.registerMem = replaceRegisterMultiple(imlInstruction->op_storeLoad.registerMem, gprRegisterSearched, gprRegisterReplaced);
-		if (imlInstruction->op_storeLoad.registerMem2 != PPC_REC_INVALID_REGISTER)
-			imlInstruction->op_storeLoad.registerMem2 = replaceRegisterMultiple(imlInstruction->op_storeLoad.registerMem2, gprRegisterSearched, gprRegisterReplaced);
-	}
-	else if (imlInstruction->type == PPCREC_IML_TYPE_CR)
-	{
-		// only affects cr register	
-	}
-	else if (imlInstruction->type == PPCREC_IML_TYPE_JUMPMARK)
-	{
-		// no effect on registers
-	}
-	else if (imlInstruction->type == PPCREC_IML_TYPE_PPC_ENTER)
-	{
-		// no op
-	}
-	else if (imlInstruction->type == PPCREC_IML_TYPE_FPR_R_NAME)
-	{
-
-	}
-	else if (imlInstruction->type == PPCREC_IML_TYPE_FPR_NAME_R)
-	{
-
-	}
-	else if (imlInstruction->type == PPCREC_IML_TYPE_FPR_LOAD)
-	{
-		if (imlInstruction->op_storeLoad.registerMem != PPC_REC_INVALID_REGISTER)
-		{
-			imlInstruction->op_storeLoad.registerMem = replaceRegisterMultiple(imlInstruction->op_storeLoad.registerMem, gprRegisterSearched, gprRegisterReplaced);
-		}
-		if (imlInstruction->op_storeLoad.registerGQR != PPC_REC_INVALID_REGISTER)
-		{
-			imlInstruction->op_storeLoad.registerGQR = replaceRegisterMultiple(imlInstruction->op_storeLoad.registerGQR, gprRegisterSearched, gprRegisterReplaced);
-		}
-	}
-	else if (imlInstruction->type == PPCREC_IML_TYPE_FPR_LOAD_INDEXED)
-	{
-		if (imlInstruction->op_storeLoad.registerMem != PPC_REC_INVALID_REGISTER)
-		{
-			imlInstruction->op_storeLoad.registerMem = replaceRegisterMultiple(imlInstruction->op_storeLoad.registerMem, gprRegisterSearched, gprRegisterReplaced);
-		}
-		if (imlInstruction->op_storeLoad.registerMem2 != PPC_REC_INVALID_REGISTER)
-		{
-			imlInstruction->op_storeLoad.registerMem2 = replaceRegisterMultiple(imlInstruction->op_storeLoad.registerMem2, gprRegisterSearched, gprRegisterReplaced);
-		}
-		if (imlInstruction->op_storeLoad.registerGQR != PPC_REC_INVALID_REGISTER)
-		{
-			imlInstruction->op_storeLoad.registerGQR = replaceRegisterMultiple(imlInstruction->op_storeLoad.registerGQR, gprRegisterSearched, gprRegisterReplaced);
-		}
-	}
-	else if (imlInstruction->type == PPCREC_IML_TYPE_FPR_STORE)
-	{
-		if (imlInstruction->op_storeLoad.registerMem != PPC_REC_INVALID_REGISTER)
-		{
-			imlInstruction->op_storeLoad.registerMem = replaceRegisterMultiple(imlInstruction->op_storeLoad.registerMem, gprRegisterSearched, gprRegisterReplaced);
-		}
-		if (imlInstruction->op_storeLoad.registerGQR != PPC_REC_INVALID_REGISTER)
-		{
-			imlInstruction->op_storeLoad.registerGQR = replaceRegisterMultiple(imlInstruction->op_storeLoad.registerGQR, gprRegisterSearched, gprRegisterReplaced);
-		}
-	}
-	else if (imlInstruction->type == PPCREC_IML_TYPE_FPR_STORE_INDEXED)
-	{
-		if (imlInstruction->op_storeLoad.registerMem != PPC_REC_INVALID_REGISTER)
-		{
-			imlInstruction->op_storeLoad.registerMem = replaceRegisterMultiple(imlInstruction->op_storeLoad.registerMem, gprRegisterSearched, gprRegisterReplaced);
-		}
-		if (imlInstruction->op_storeLoad.registerMem2 != PPC_REC_INVALID_REGISTER)
-		{
-			imlInstruction->op_storeLoad.registerMem2 = replaceRegisterMultiple(imlInstruction->op_storeLoad.registerMem2, gprRegisterSearched, gprRegisterReplaced);
-		}
-		if (imlInstruction->op_storeLoad.registerGQR != PPC_REC_INVALID_REGISTER)
-		{
-			imlInstruction->op_storeLoad.registerGQR = replaceRegisterMultiple(imlInstruction->op_storeLoad.registerGQR, gprRegisterSearched, gprRegisterReplaced);
-		}
-	}
-	else if (imlInstruction->type == PPCREC_IML_TYPE_FPR_R_R)
-	{
-	}
-	else if (imlInstruction->type == PPCREC_IML_TYPE_FPR_R_R_R)
-	{
-	}
-	else if (imlInstruction->type == PPCREC_IML_TYPE_FPR_R_R_R_R)
-	{
-	}
-	else if (imlInstruction->type == PPCREC_IML_TYPE_FPR_R)
-	{
-	}
-	else
-	{
-		cemu_assert_unimplemented();
-	}
-}
-
-void PPCRecompiler_replaceFPRRegisterUsageMultiple(ppcImlGenContext_t* ppcImlGenContext, PPCRecImlInstruction_t* imlInstruction, sint32 fprRegisterSearched[4], sint32 fprRegisterReplaced[4])
-{
-	if (imlInstruction->type == PPCREC_IML_TYPE_R_NAME)
-	{
-		// not affected
-	}
-	else if (imlInstruction->type == PPCREC_IML_TYPE_NAME_R)
-	{
-		// not affected
-	}
-	else if (imlInstruction->type == PPCREC_IML_TYPE_R_R)
-	{
-		// not affected
-	}
-	else if (imlInstruction->type == PPCREC_IML_TYPE_R_S32)
-	{
-		// not affected
-	}
-	else if (imlInstruction->type == PPCREC_IML_TYPE_R_R_S32)
-	{
-		// not affected
-	}
-	else if (imlInstruction->type == PPCREC_IML_TYPE_R_R_R)
-	{
-		// not affected
-	}
-	else if (imlInstruction->type == PPCREC_IML_TYPE_CJUMP || imlInstruction->type == PPCREC_IML_TYPE_CJUMP_CYCLE_CHECK)
-	{
-		// no effect on registers
-	}
-	else if (imlInstruction->type == PPCREC_IML_TYPE_NO_OP)
-	{
-		// no effect on registers
-	}
-	else if (imlInstruction->type == PPCREC_IML_TYPE_MACRO)
-	{
-		// not affected
-	}
-	else if (imlInstruction->type == PPCREC_IML_TYPE_LOAD)
-	{
-		// not affected
-	}
-	else if (imlInstruction->type == PPCREC_IML_TYPE_MEM2MEM)
-	{
-		// not affected
-	}
-	else if (imlInstruction->type == PPCREC_IML_TYPE_LOAD_INDEXED)
-	{
-		// not affected
-	}
-	else if (imlInstruction->type == PPCREC_IML_TYPE_STORE)
-	{
-		// not affected
-	}
-	else if (imlInstruction->type == PPCREC_IML_TYPE_STORE_INDEXED)
-	{
-		// not affected
-	}
-	else if (imlInstruction->type == PPCREC_IML_TYPE_CR)
-	{
-		// only affects cr register	
-	}
-	else if (imlInstruction->type == PPCREC_IML_TYPE_JUMPMARK)
-	{
-		// no effect on registers
-	}
-	else if (imlInstruction->type == PPCREC_IML_TYPE_PPC_ENTER)
-	{
-		// no op
-	}
-	else if (imlInstruction->type == PPCREC_IML_TYPE_FPR_R_NAME)
-	{
-		imlInstruction->op_r_name.registerIndex = replaceRegisterMultiple(imlInstruction->op_r_name.registerIndex, fprRegisterSearched, fprRegisterReplaced);
-	}
-	else if (imlInstruction->type == PPCREC_IML_TYPE_FPR_NAME_R)
-	{
-		imlInstruction->op_r_name.registerIndex = replaceRegisterMultiple(imlInstruction->op_r_name.registerIndex, fprRegisterSearched, fprRegisterReplaced);
-	}
-	else if (imlInstruction->type == PPCREC_IML_TYPE_FPR_LOAD)
-	{
-		imlInstruction->op_storeLoad.registerData = replaceRegisterMultiple(imlInstruction->op_storeLoad.registerData, fprRegisterSearched, fprRegisterReplaced);
-	}
-	else if (imlInstruction->type == PPCREC_IML_TYPE_FPR_LOAD_INDEXED)
-	{
-		imlInstruction->op_storeLoad.registerData = replaceRegisterMultiple(imlInstruction->op_storeLoad.registerData, fprRegisterSearched, fprRegisterReplaced);
-	}
-	else if (imlInstruction->type == PPCREC_IML_TYPE_FPR_STORE)
-	{
-		imlInstruction->op_storeLoad.registerData = replaceRegisterMultiple(imlInstruction->op_storeLoad.registerData, fprRegisterSearched, fprRegisterReplaced);
-	}
-	else if (imlInstruction->type == PPCREC_IML_TYPE_FPR_STORE_INDEXED)
-	{
-		imlInstruction->op_storeLoad.registerData = replaceRegisterMultiple(imlInstruction->op_storeLoad.registerData, fprRegisterSearched, fprRegisterReplaced);
-	}
-	else if (imlInstruction->type == PPCREC_IML_TYPE_FPR_R_R)
-	{
-		imlInstruction->op_fpr_r_r.registerResult = replaceRegisterMultiple(imlInstruction->op_fpr_r_r.registerResult, fprRegisterSearched, fprRegisterReplaced);
-		imlInstruction->op_fpr_r_r.registerOperand = replaceRegisterMultiple(imlInstruction->op_fpr_r_r.registerOperand, fprRegisterSearched, fprRegisterReplaced);
-	}
-	else if (imlInstruction->type == PPCREC_IML_TYPE_FPR_R_R_R)
-	{
-		imlInstruction->op_fpr_r_r_r.registerResult = replaceRegisterMultiple(imlInstruction->op_fpr_r_r_r.registerResult, fprRegisterSearched, fprRegisterReplaced);
-		imlInstruction->op_fpr_r_r_r.registerOperandA = replaceRegisterMultiple(imlInstruction->op_fpr_r_r_r.registerOperandA, fprRegisterSearched, fprRegisterReplaced);
-		imlInstruction->op_fpr_r_r_r.registerOperandB = replaceRegisterMultiple(imlInstruction->op_fpr_r_r_r.registerOperandB, fprRegisterSearched, fprRegisterReplaced);
-	}
-	else if (imlInstruction->type == PPCREC_IML_TYPE_FPR_R_R_R_R)
-	{
-		imlInstruction->op_fpr_r_r_r_r.registerResult = replaceRegisterMultiple(imlInstruction->op_fpr_r_r_r_r.registerResult, fprRegisterSearched, fprRegisterReplaced);
-		imlInstruction->op_fpr_r_r_r_r.registerOperandA = replaceRegisterMultiple(imlInstruction->op_fpr_r_r_r_r.registerOperandA, fprRegisterSearched, fprRegisterReplaced);
-		imlInstruction->op_fpr_r_r_r_r.registerOperandB = replaceRegisterMultiple(imlInstruction->op_fpr_r_r_r_r.registerOperandB, fprRegisterSearched, fprRegisterReplaced);
-		imlInstruction->op_fpr_r_r_r_r.registerOperandC = replaceRegisterMultiple(imlInstruction->op_fpr_r_r_r_r.registerOperandC, fprRegisterSearched, fprRegisterReplaced);
-	}
-	else if (imlInstruction->type == PPCREC_IML_TYPE_FPR_R)
-	{
-		imlInstruction->op_fpr_r.registerResult = replaceRegisterMultiple(imlInstruction->op_fpr_r.registerResult, fprRegisterSearched, fprRegisterReplaced);
-	}
-	else
-	{
-		cemu_assert_unimplemented();
-	}
-}
-
-void PPCRecompiler_replaceFPRRegisterUsage(ppcImlGenContext_t* ppcImlGenContext, PPCRecImlInstruction_t* imlInstruction, sint32 fprRegisterSearched, sint32 fprRegisterReplaced)
-{
-	if( imlInstruction->type == PPCREC_IML_TYPE_R_NAME )
-	{
-		// not affected
-	}
-	else if( imlInstruction->type == PPCREC_IML_TYPE_NAME_R )
-	{
-		// not affected
-	}
-	else if( imlInstruction->type == PPCREC_IML_TYPE_R_R )
-	{
-		// not affected
-	}
-	else if( imlInstruction->type == PPCREC_IML_TYPE_R_S32 )
-	{
-		// not affected
-	}
-	else if( imlInstruction->type == PPCREC_IML_TYPE_R_R_S32 )
-	{
-		// not affected
-	}
-	else if( imlInstruction->type == PPCREC_IML_TYPE_R_R_R )
-	{
-		// not affected
-	}
-	else if( imlInstruction->type == PPCREC_IML_TYPE_CJUMP || imlInstruction->type == PPCREC_IML_TYPE_CJUMP_CYCLE_CHECK )
-	{
-		// no effect on registers
-	}
-	else if( imlInstruction->type == PPCREC_IML_TYPE_NO_OP )
-	{
-		// no effect on registers
-	}
-	else if( imlInstruction->type == PPCREC_IML_TYPE_MACRO )
-	{
-		// not affected
-	}
-	else if( imlInstruction->type == PPCREC_IML_TYPE_LOAD )
-	{
-		// not affected
-	}
-	else if (imlInstruction->type == PPCREC_IML_TYPE_MEM2MEM)
-	{
-		// not affected
-	}
-	else if( imlInstruction->type == PPCREC_IML_TYPE_LOAD_INDEXED )
-	{
-		// not affected
-	}
-	else if( imlInstruction->type == PPCREC_IML_TYPE_STORE )
-	{
-		// not affected
-	}
-	else if( imlInstruction->type == PPCREC_IML_TYPE_STORE_INDEXED )
-	{
-		// not affected
-	}
-	else if( imlInstruction->type == PPCREC_IML_TYPE_CR )
-	{
-		// only affects cr register	
-	}
-	else if( imlInstruction->type == PPCREC_IML_TYPE_JUMPMARK )
-	{
-		// no effect on registers
-	}
-	else if( imlInstruction->type == PPCREC_IML_TYPE_PPC_ENTER )
-	{
-		// no op
-	}
-	else if( imlInstruction->type == PPCREC_IML_TYPE_FPR_R_NAME )
-	{
-		imlInstruction->op_r_name.registerIndex = replaceRegister(imlInstruction->op_r_name.registerIndex, fprRegisterSearched, fprRegisterReplaced);
-	}
-	else if( imlInstruction->type == PPCREC_IML_TYPE_FPR_NAME_R )
-	{
-		imlInstruction->op_r_name.registerIndex = replaceRegister(imlInstruction->op_r_name.registerIndex, fprRegisterSearched, fprRegisterReplaced);
-	}
-	else if( imlInstruction->type == PPCREC_IML_TYPE_FPR_LOAD )
-	{
-		imlInstruction->op_storeLoad.registerData = replaceRegister(imlInstruction->op_storeLoad.registerData, fprRegisterSearched, fprRegisterReplaced);
-	}
-	else if( imlInstruction->type == PPCREC_IML_TYPE_FPR_LOAD_INDEXED )
-	{
-		imlInstruction->op_storeLoad.registerData = replaceRegister(imlInstruction->op_storeLoad.registerData, fprRegisterSearched, fprRegisterReplaced);
-	}
-	else if( imlInstruction->type == PPCREC_IML_TYPE_FPR_STORE )
-	{
-		imlInstruction->op_storeLoad.registerData = replaceRegister(imlInstruction->op_storeLoad.registerData, fprRegisterSearched, fprRegisterReplaced);
-	}
-	else if( imlInstruction->type == PPCREC_IML_TYPE_FPR_STORE_INDEXED )
-	{
-		imlInstruction->op_storeLoad.registerData = replaceRegister(imlInstruction->op_storeLoad.registerData, fprRegisterSearched, fprRegisterReplaced);
-	}
-	else if( imlInstruction->type == PPCREC_IML_TYPE_FPR_R_R )
-	{
-		imlInstruction->op_fpr_r_r.registerResult = replaceRegister(imlInstruction->op_fpr_r_r.registerResult, fprRegisterSearched, fprRegisterReplaced);
-		imlInstruction->op_fpr_r_r.registerOperand = replaceRegister(imlInstruction->op_fpr_r_r.registerOperand, fprRegisterSearched, fprRegisterReplaced);
-	}
-	else if( imlInstruction->type == PPCREC_IML_TYPE_FPR_R_R_R )
-	{
-		imlInstruction->op_fpr_r_r_r.registerResult = replaceRegister(imlInstruction->op_fpr_r_r_r.registerResult, fprRegisterSearched, fprRegisterReplaced);
-		imlInstruction->op_fpr_r_r_r.registerOperandA = replaceRegister(imlInstruction->op_fpr_r_r_r.registerOperandA, fprRegisterSearched, fprRegisterReplaced);
-		imlInstruction->op_fpr_r_r_r.registerOperandB = replaceRegister(imlInstruction->op_fpr_r_r_r.registerOperandB, fprRegisterSearched, fprRegisterReplaced);
-	}
-	else if( imlInstruction->type == PPCREC_IML_TYPE_FPR_R_R_R_R )
-	{
-		imlInstruction->op_fpr_r_r_r_r.registerResult = replaceRegister(imlInstruction->op_fpr_r_r_r_r.registerResult, fprRegisterSearched, fprRegisterReplaced);
-		imlInstruction->op_fpr_r_r_r_r.registerOperandA = replaceRegister(imlInstruction->op_fpr_r_r_r_r.registerOperandA, fprRegisterSearched, fprRegisterReplaced);
-		imlInstruction->op_fpr_r_r_r_r.registerOperandB = replaceRegister(imlInstruction->op_fpr_r_r_r_r.registerOperandB, fprRegisterSearched, fprRegisterReplaced);
-		imlInstruction->op_fpr_r_r_r_r.registerOperandC = replaceRegister(imlInstruction->op_fpr_r_r_r_r.registerOperandC, fprRegisterSearched, fprRegisterReplaced);
-	}
-	else if( imlInstruction->type == PPCREC_IML_TYPE_FPR_R )
-	{
-		imlInstruction->op_fpr_r.registerResult = replaceRegister(imlInstruction->op_fpr_r.registerResult, fprRegisterSearched, fprRegisterReplaced);
-	}
-	else
-	{
-		cemu_assert_unimplemented();
-	}
-}
-
-typedef struct  
-{
-	struct  
-	{
-		sint32 instructionIndex;
-		sint32 registerPreviousName;
-		sint32 registerNewName;
-		sint32 index; // new index
-		sint32 previousIndex; // previous index (always out of range)
-		bool nameMustBeMaintained; // must be stored before replacement and loaded after replacement ends
-	}replacedRegisterEntry[PPC_X64_GPR_USABLE_REGISTERS];
-	sint32 count;
-}replacedRegisterTracker_t;
-
-bool PPCRecompiler_checkIfGPRRegisterIsAccessed(PPCImlOptimizerUsedRegisters_t* registersUsed, sint32 gprRegister)
-{
-	if( registersUsed->readNamedReg1 == gprRegister )
-		return true;
-	if( registersUsed->readNamedReg2 == gprRegister )
-		return true;
-	if( registersUsed->readNamedReg3 == gprRegister )
-		return true;
-	if( registersUsed->writtenNamedReg1 == gprRegister )
-		return true;
-	return false;
-}
-
-/*
- * Returns index of register to replace
- * If no register needs to be replaced, -1 is returned
- */
-sint32 PPCRecompiler_getNextRegisterToReplace(PPCImlOptimizerUsedRegisters_t* registersUsed)
-{
-	// get index of register to replace
-	sint32 gprToReplace = -1;
-	if( registersUsed->readNamedReg1 >= PPC_X64_GPR_USABLE_REGISTERS )
-		gprToReplace = registersUsed->readNamedReg1;
-	else if( registersUsed->readNamedReg2 >= PPC_X64_GPR_USABLE_REGISTERS )
-		gprToReplace = registersUsed->readNamedReg2;
-	else if( registersUsed->readNamedReg3 >= PPC_X64_GPR_USABLE_REGISTERS )
-		gprToReplace = registersUsed->readNamedReg3;
-	else if( registersUsed->writtenNamedReg1 >= PPC_X64_GPR_USABLE_REGISTERS )
-		gprToReplace = registersUsed->writtenNamedReg1;
-	// return 
-	return gprToReplace;
-}
-
-bool PPCRecompiler_findAvailableRegisterDepr(ppcImlGenContext_t* ppcImlGenContext, PPCRecImlSegment_t* imlSegment, sint32 imlIndexStart, replacedRegisterTracker_t* replacedRegisterTracker, sint32* registerIndex, sint32* registerName, bool* isUsed)
-{
-	PPCImlOptimizerUsedRegisters_t registersUsed;
-	PPCRecompiler_checkRegisterUsage(ppcImlGenContext, imlSegment->imlList+imlIndexStart, &registersUsed);
-	// mask all registers used by this instruction
-	uint32 instructionReservedRegisterMask = 0;//(1<<(PPC_X64_GPR_USABLE_REGISTERS+1))-1;
-	if( registersUsed.readNamedReg1 != -1 )
-		instructionReservedRegisterMask |= (1<<(registersUsed.readNamedReg1));
-	if( registersUsed.readNamedReg2 != -1 )
-		instructionReservedRegisterMask |= (1<<(registersUsed.readNamedReg2));
-	if( registersUsed.readNamedReg3 != -1 )
-		instructionReservedRegisterMask |= (1<<(registersUsed.readNamedReg3));
-	if( registersUsed.writtenNamedReg1 != -1 )
-		instructionReservedRegisterMask |= (1<<(registersUsed.writtenNamedReg1));
-	// mask all registers that are reserved for other replacements
-	uint32 replacementReservedRegisterMask = 0;
-	for(sint32 i=0; i<replacedRegisterTracker->count; i++)
-	{
-		replacementReservedRegisterMask |= (1<<replacedRegisterTracker->replacedRegisterEntry[i].index);
-	}
-
-	// potential improvement: Scan ahead a few instructions and look for registers that are the least used (or ideally never used)
-
-	// pick available register
-	const uint32 allRegisterMask = (1<<(PPC_X64_GPR_USABLE_REGISTERS+1))-1; // mask with set bit for every register
-	uint32 reservedRegisterMask = instructionReservedRegisterMask | replacementReservedRegisterMask;
-	cemu_assert(instructionReservedRegisterMask != allRegisterMask); // no usable register! (Need to store a register from the replacedRegisterTracker)
-	sint32 usedRegisterIndex = -1;
-	for(sint32 i=0; i<PPC_X64_GPR_USABLE_REGISTERS; i++)
-	{
-		if( (reservedRegisterMask&(1<<i)) == 0 )
-		{
-			if( (instructionReservedRegisterMask&(1<<i)) == 0 && ppcImlGenContext->mappedRegister[i] != -1 )
-			{
-				// register is reserved by segment -> In use
-				*isUsed = true;
-				*registerName = ppcImlGenContext->mappedRegister[i];
-			}
-			else
-			{
-				*isUsed = false;
-				*registerName = -1;
-			}
-			*registerIndex = i;
-			return true;
-		}
-	}
-	return false;
-
-}
-
-bool PPCRecompiler_hasSuffixInstruction(PPCRecImlSegment_t* imlSegment)
-{
-	if( imlSegment->imlListCount == 0 )
-		return false;
-	PPCRecImlInstruction_t* imlInstruction = imlSegment->imlList+imlSegment->imlListCount-1;
-	if( imlInstruction->type == PPCREC_IML_TYPE_MACRO && (imlInstruction->operation == PPCREC_IML_MACRO_BLR || imlInstruction->operation == PPCREC_IML_MACRO_BCTR) ||
-		imlInstruction->type == PPCREC_IML_TYPE_MACRO && imlInstruction->operation == PPCREC_IML_MACRO_BL ||
-		imlInstruction->type == PPCREC_IML_TYPE_MACRO && imlInstruction->operation == PPCREC_IML_MACRO_B_FAR ||
-		imlInstruction->type == PPCREC_IML_TYPE_MACRO && imlInstruction->operation == PPCREC_IML_MACRO_BLRL ||
-		imlInstruction->type == PPCREC_IML_TYPE_MACRO && imlInstruction->operation == PPCREC_IML_MACRO_BCTRL ||
-		imlInstruction->type == PPCREC_IML_TYPE_MACRO && imlInstruction->operation == PPCREC_IML_MACRO_LEAVE ||
-		imlInstruction->type == PPCREC_IML_TYPE_MACRO && imlInstruction->operation == PPCREC_IML_MACRO_HLE ||
-		imlInstruction->type == PPCREC_IML_TYPE_MACRO && imlInstruction->operation == PPCREC_IML_MACRO_MFTB ||
-		imlInstruction->type == PPCREC_IML_TYPE_PPC_ENTER ||
-		imlInstruction->type == PPCREC_IML_TYPE_CJUMP ||
-		imlInstruction->type == PPCREC_IML_TYPE_CJUMP_CYCLE_CHECK )
-		return true;
-	return false;
-}
-
-void PPCRecompiler_storeReplacedRegister(ppcImlGenContext_t* ppcImlGenContext, PPCRecImlSegment_t* imlSegment, replacedRegisterTracker_t* replacedRegisterTracker, sint32 registerTrackerIndex, sint32* imlIndex)
-{
-	// store register
-	sint32 imlIndexEdit = *imlIndex;
-	PPCRecompiler_pushBackIMLInstructions(imlSegment, imlIndexEdit, 1);
-	// name_unusedRegister = unusedRegister
-	PPCRecImlInstruction_t* imlInstructionItr = imlSegment->imlList+(imlIndexEdit+0);
-	memset(imlInstructionItr, 0x00, sizeof(PPCRecImlInstruction_t));
-	imlInstructionItr->type = PPCREC_IML_TYPE_NAME_R;
-	imlInstructionItr->crRegister = PPC_REC_INVALID_REGISTER;
-	imlInstructionItr->operation = PPCREC_IML_OP_ASSIGN;
-	imlInstructionItr->op_r_name.registerIndex = replacedRegisterTracker->replacedRegisterEntry[registerTrackerIndex].index;
-	imlInstructionItr->op_r_name.name = replacedRegisterTracker->replacedRegisterEntry[registerTrackerIndex].registerNewName;
-	imlInstructionItr->op_r_name.copyWidth = 32;
-	imlInstructionItr->op_r_name.flags = 0;
-	imlIndexEdit++;
-	// load new register if required
-	if( replacedRegisterTracker->replacedRegisterEntry[registerTrackerIndex].nameMustBeMaintained )
-	{
-		PPCRecompiler_pushBackIMLInstructions(imlSegment, imlIndexEdit, 1);
-		PPCRecImlInstruction_t* imlInstructionItr = imlSegment->imlList+(imlIndexEdit+0);
-		memset(imlInstructionItr, 0x00, sizeof(PPCRecImlInstruction_t));
-		imlInstructionItr->type = PPCREC_IML_TYPE_R_NAME;
-		imlInstructionItr->crRegister = PPC_REC_INVALID_REGISTER;
-		imlInstructionItr->operation = PPCREC_IML_OP_ASSIGN;
-		imlInstructionItr->op_r_name.registerIndex = replacedRegisterTracker->replacedRegisterEntry[registerTrackerIndex].index;
-		imlInstructionItr->op_r_name.name = replacedRegisterTracker->replacedRegisterEntry[registerTrackerIndex].registerPreviousName;//ppcImlGenContext->mappedRegister[replacedRegisterTracker.replacedRegisterEntry[i].index];
-		imlInstructionItr->op_r_name.copyWidth = 32;
-		imlInstructionItr->op_r_name.flags = 0;
-		imlIndexEdit += 1;
-	}
-	// move last entry to current one
-	memcpy(replacedRegisterTracker->replacedRegisterEntry+registerTrackerIndex, replacedRegisterTracker->replacedRegisterEntry+replacedRegisterTracker->count-1, sizeof(replacedRegisterTracker->replacedRegisterEntry[0]));
-	replacedRegisterTracker->count--;
-	*imlIndex = imlIndexEdit;
-}
-
-bool PPCRecompiler_reduceNumberOfFPRRegisters(ppcImlGenContext_t* ppcImlGenContext)
-{
-	// only xmm0 to xmm14 may be used, xmm15 is reserved
-	// this method will reduce the number of fpr registers used
-	// inefficient algorithm for optimizing away excess registers
-	// we simply load, use and store excess registers into other unused registers when we need to
-	// first we remove all name load and store instructions that involve out-of-bounds registers
-	for(sint32 s=0; s<ppcImlGenContext->segmentListCount; s++)
-	{
-		PPCRecImlSegment_t* imlSegment = ppcImlGenContext->segmentList[s];
-		sint32 imlIndex = 0;
-		while( imlIndex < imlSegment->imlListCount )
-		{
-			PPCRecImlInstruction_t* imlInstructionItr = imlSegment->imlList+imlIndex;
-			if( imlInstructionItr->type == PPCREC_IML_TYPE_FPR_R_NAME || imlInstructionItr->type == PPCREC_IML_TYPE_FPR_NAME_R )
-			{
-				if( imlInstructionItr->op_r_name.registerIndex >= PPC_X64_FPR_USABLE_REGISTERS )
-				{
-					// convert to NO-OP instruction
-					imlInstructionItr->type = PPCREC_IML_TYPE_NO_OP;
-					imlInstructionItr->associatedPPCAddress = 0;
-				}
-			}
-			imlIndex++;
-		}	
-	}
-	// replace registers
-	for(sint32 s=0; s<ppcImlGenContext->segmentListCount; s++)
-	{
-		PPCRecImlSegment_t* imlSegment = ppcImlGenContext->segmentList[s];
-		sint32 imlIndex = 0;
-		while( imlIndex < imlSegment->imlListCount )
-		{
-			PPCImlOptimizerUsedRegisters_t registersUsed;
-			while( true )
-			{
-				PPCRecompiler_checkRegisterUsage(ppcImlGenContext, imlSegment->imlList+imlIndex, &registersUsed);
-				if( registersUsed.readFPR1 >= PPC_X64_FPR_USABLE_REGISTERS || registersUsed.readFPR2 >= PPC_X64_FPR_USABLE_REGISTERS || registersUsed.readFPR3 >= PPC_X64_FPR_USABLE_REGISTERS || registersUsed.readFPR4 >= PPC_X64_FPR_USABLE_REGISTERS || registersUsed.writtenFPR1 >= PPC_X64_FPR_USABLE_REGISTERS )
-				{
-					// get index of register to replace
-					sint32 fprToReplace = -1;
-					if( registersUsed.readFPR1 >= PPC_X64_FPR_USABLE_REGISTERS )
-						fprToReplace = registersUsed.readFPR1;
-					else if( registersUsed.readFPR2 >= PPC_X64_FPR_USABLE_REGISTERS )
-						fprToReplace = registersUsed.readFPR2;
-					else if (registersUsed.readFPR3 >= PPC_X64_FPR_USABLE_REGISTERS)
-						fprToReplace = registersUsed.readFPR3;
-					else if (registersUsed.readFPR4 >= PPC_X64_FPR_USABLE_REGISTERS)
-						fprToReplace = registersUsed.readFPR4;
-					else if( registersUsed.writtenFPR1 >= PPC_X64_FPR_USABLE_REGISTERS )
-						fprToReplace = registersUsed.writtenFPR1;
-					// generate mask of useable registers
-					uint8 useableRegisterMask = 0x7F; // lowest bit is fpr register 0
-					if( registersUsed.readFPR1 != -1 )
-						useableRegisterMask &= ~(1<<(registersUsed.readFPR1));
-					if( registersUsed.readFPR2 != -1 )
-						useableRegisterMask &= ~(1<<(registersUsed.readFPR2));
-					if (registersUsed.readFPR3 != -1)
-						useableRegisterMask &= ~(1 << (registersUsed.readFPR3));
-					if (registersUsed.readFPR4 != -1)
-						useableRegisterMask &= ~(1 << (registersUsed.readFPR4));
-					if( registersUsed.writtenFPR1 != -1 )
-						useableRegisterMask &= ~(1<<(registersUsed.writtenFPR1));
-					// get highest unused register index (0-6 range)
-					sint32 unusedRegisterIndex = -1;
-					for(sint32 f=0; f<PPC_X64_FPR_USABLE_REGISTERS; f++)
-					{
-						if( useableRegisterMask&(1<<f) )
-						{
-							unusedRegisterIndex = f;
-						}
-					}
-					if( unusedRegisterIndex == -1 )
-						assert_dbg();
-					// determine if the placeholder register is actually used (if not we must not load/store it)
-					uint32 unusedRegisterName = ppcImlGenContext->mappedFPRRegister[unusedRegisterIndex];
-					bool replacedRegisterIsUsed = true;
-					if( unusedRegisterName >= PPCREC_NAME_FPR0 && unusedRegisterName < (PPCREC_NAME_FPR0+32) )
-					{
-						replacedRegisterIsUsed = imlSegment->ppcFPRUsed[unusedRegisterName-PPCREC_NAME_FPR0];
-					}
-					// replace registers that are out of range
-					PPCRecompiler_replaceFPRRegisterUsage(ppcImlGenContext, imlSegment->imlList+imlIndex, fprToReplace, unusedRegisterIndex);
-					// add load/store name after instruction
-					PPCRecompiler_pushBackIMLInstructions(imlSegment, imlIndex+1, 2);
-					// add load/store before current instruction
-					PPCRecompiler_pushBackIMLInstructions(imlSegment, imlIndex, 2);
-					// name_unusedRegister = unusedRegister
-					PPCRecImlInstruction_t* imlInstructionItr = imlSegment->imlList+(imlIndex+0);
-					memset(imlInstructionItr, 0x00, sizeof(PPCRecImlInstruction_t));
-					if( replacedRegisterIsUsed )
-					{
-						imlInstructionItr->type = PPCREC_IML_TYPE_FPR_NAME_R;
-						imlInstructionItr->operation = PPCREC_IML_OP_ASSIGN;
-						imlInstructionItr->op_r_name.registerIndex = unusedRegisterIndex;
-						imlInstructionItr->op_r_name.name = ppcImlGenContext->mappedFPRRegister[unusedRegisterIndex];
-						imlInstructionItr->op_r_name.copyWidth = 32;
-						imlInstructionItr->op_r_name.flags = 0;
-					}
-					else
-						imlInstructionItr->type = PPCREC_IML_TYPE_NO_OP;
-					imlInstructionItr = imlSegment->imlList+(imlIndex+1);
-					memset(imlInstructionItr, 0x00, sizeof(PPCRecImlInstruction_t));
-					imlInstructionItr->type = PPCREC_IML_TYPE_FPR_R_NAME;
-					imlInstructionItr->operation = PPCREC_IML_OP_ASSIGN;
-					imlInstructionItr->op_r_name.registerIndex = unusedRegisterIndex;
-					imlInstructionItr->op_r_name.name = ppcImlGenContext->mappedFPRRegister[fprToReplace];
-					imlInstructionItr->op_r_name.copyWidth = 32;
-					imlInstructionItr->op_r_name.flags = 0;
-					// name_gprToReplace = unusedRegister
-					imlInstructionItr = imlSegment->imlList+(imlIndex+3);
-					memset(imlInstructionItr, 0x00, sizeof(PPCRecImlInstruction_t));
-					imlInstructionItr->type = PPCREC_IML_TYPE_FPR_NAME_R;
-					imlInstructionItr->operation = PPCREC_IML_OP_ASSIGN;
-					imlInstructionItr->op_r_name.registerIndex = unusedRegisterIndex;
-					imlInstructionItr->op_r_name.name = ppcImlGenContext->mappedFPRRegister[fprToReplace];
-					imlInstructionItr->op_r_name.copyWidth = 32;
-					imlInstructionItr->op_r_name.flags = 0;
-					// unusedRegister = name_unusedRegister
-					imlInstructionItr = imlSegment->imlList+(imlIndex+4);
-					memset(imlInstructionItr, 0x00, sizeof(PPCRecImlInstruction_t));
-					if( replacedRegisterIsUsed )
-					{
-						imlInstructionItr->type = PPCREC_IML_TYPE_FPR_R_NAME;
-						imlInstructionItr->operation = PPCREC_IML_OP_ASSIGN;
-						imlInstructionItr->op_r_name.registerIndex = unusedRegisterIndex;
-						imlInstructionItr->op_r_name.name = ppcImlGenContext->mappedFPRRegister[unusedRegisterIndex];
-						imlInstructionItr->op_r_name.copyWidth = 32;
-						imlInstructionItr->op_r_name.flags = 0;
-					}
-					else
-						imlInstructionItr->type = PPCREC_IML_TYPE_NO_OP;
-				}
-				else
-					break;
-			}
-			imlIndex++;
-		}
-	}
-	return true;
-}
-
-typedef struct  
-{
-	bool isActive;
-	uint32 virtualReg;
-	sint32 lastUseIndex;
-}ppcRecRegisterMapping_t;
-
-typedef struct  
-{
-	ppcRecRegisterMapping_t currentMapping[PPC_X64_FPR_USABLE_REGISTERS];
-	sint32 ppcRegToMapping[64];
-	sint32 currentUseIndex;
-}ppcRecManageRegisters_t;
-
-ppcRecRegisterMapping_t* PPCRecompiler_findAvailableRegisterDepr(ppcRecManageRegisters_t* rCtx, PPCImlOptimizerUsedRegisters_t* instructionUsedRegisters)
-{
-	// find free register
-	for (sint32 i = 0; i < PPC_X64_FPR_USABLE_REGISTERS; i++)
-	{
-		if (rCtx->currentMapping[i].isActive == false)
-		{
-			rCtx->currentMapping[i].isActive = true;
-			rCtx->currentMapping[i].virtualReg = -1;
-			rCtx->currentMapping[i].lastUseIndex = rCtx->currentUseIndex;
-			return rCtx->currentMapping + i;
-		}
-	}
-	// all registers are used
-	return nullptr;
-}
-
-ppcRecRegisterMapping_t* PPCRecompiler_findUnloadableRegister(ppcRecManageRegisters_t* rCtx, PPCImlOptimizerUsedRegisters_t* instructionUsedRegisters, uint32 unloadLockedMask)
-{
-	// find unloadable register (with lowest lastUseIndex)
-	sint32 unloadIndex = -1;
-	sint32 unloadIndexLastUse = 0x7FFFFFFF;
-	for (sint32 i = 0; i < PPC_X64_FPR_USABLE_REGISTERS; i++)
-	{
-		if (rCtx->currentMapping[i].isActive == false)
-			continue;
-		if( (unloadLockedMask&(1<<i)) != 0 )
-			continue;
-		uint32 virtualReg = rCtx->currentMapping[i].virtualReg;
-		bool isReserved = false;
-		for (sint32 f = 0; f < 4; f++)
-		{
-			if (virtualReg == (sint32)instructionUsedRegisters->fpr[f])
-			{
-				isReserved = true;
-				break;
-			}
-		}
-		if (isReserved)
-			continue;
-		if (rCtx->currentMapping[i].lastUseIndex < unloadIndexLastUse)
-		{
-			unloadIndexLastUse = rCtx->currentMapping[i].lastUseIndex;
-			unloadIndex = i;
-		}
-	}
-	cemu_assert(unloadIndex != -1);
-	return rCtx->currentMapping + unloadIndex;
-}
-
-bool PPCRecompiler_manageFPRRegistersForSegment(ppcImlGenContext_t* ppcImlGenContext, sint32 segmentIndex)
-{
-	ppcRecManageRegisters_t rCtx = { 0 };
-	for (sint32 i = 0; i < 64; i++)
-		rCtx.ppcRegToMapping[i] = -1;
-	PPCRecImlSegment_t* imlSegment = ppcImlGenContext->segmentList[segmentIndex];
-	sint32 idx = 0;
-	sint32 currentUseIndex = 0;
-	PPCImlOptimizerUsedRegisters_t registersUsed;
-	while (idx < imlSegment->imlListCount)
-	{
-		if ( PPCRecompiler_isSuffixInstruction(imlSegment->imlList + idx) )
-			break;
-		PPCRecompiler_checkRegisterUsage(ppcImlGenContext, imlSegment->imlList + idx, &registersUsed);
-		sint32 fprMatch[4];
-		sint32 fprReplace[4];
-		fprMatch[0] = -1;
-		fprMatch[1] = -1;
-		fprMatch[2] = -1;
-		fprMatch[3] = -1;
-		fprReplace[0] = -1;
-		fprReplace[1] = -1;
-		fprReplace[2] = -1;
-		fprReplace[3] = -1;
-		// generate a mask of registers that we may not free
-		sint32 numReplacedOperands = 0;
-		uint32 unloadLockedMask = 0;
-		for (sint32 f = 0; f < 5; f++)
-		{
-			sint32 virtualFpr;
-			if (f == 0)
-				virtualFpr = registersUsed.readFPR1;
-			else if (f == 1)
-				virtualFpr = registersUsed.readFPR2;
-			else if (f == 2)
-				virtualFpr = registersUsed.readFPR3;
-			else if (f == 3)
-				virtualFpr = registersUsed.readFPR4;
-			else if (f == 4)
-				virtualFpr = registersUsed.writtenFPR1;
-			if( virtualFpr < 0 )
-				continue;
-			cemu_assert_debug(virtualFpr < 64);
-			// check if this virtual FPR is already loaded in any real register
-			ppcRecRegisterMapping_t* regMapping;
-			if (rCtx.ppcRegToMapping[virtualFpr] == -1)
-			{
-				// not loaded
-				// find available register
-				while (true)
-				{
-					regMapping = PPCRecompiler_findAvailableRegisterDepr(&rCtx, &registersUsed);
-					if (regMapping == NULL)
-					{
-						// unload least recently used register and try again
-						ppcRecRegisterMapping_t* unloadRegMapping = PPCRecompiler_findUnloadableRegister(&rCtx, &registersUsed, unloadLockedMask);
-						// mark as locked
-						unloadLockedMask |= (1<<(unloadRegMapping- rCtx.currentMapping));
-						// create unload instruction
-						PPCRecompiler_pushBackIMLInstructions(imlSegment, idx, 1);
-						PPCRecImlInstruction_t* imlInstructionTemp = imlSegment->imlList + idx;
-						memset(imlInstructionTemp, 0x00, sizeof(PPCRecImlInstruction_t));
-						imlInstructionTemp->type = PPCREC_IML_TYPE_FPR_NAME_R;
-						imlInstructionTemp->operation = PPCREC_IML_OP_ASSIGN;
-						imlInstructionTemp->op_r_name.registerIndex = (uint8)(unloadRegMapping - rCtx.currentMapping);
-						imlInstructionTemp->op_r_name.name = ppcImlGenContext->mappedFPRRegister[unloadRegMapping->virtualReg];
-						imlInstructionTemp->op_r_name.copyWidth = 32;
-						imlInstructionTemp->op_r_name.flags = 0;
-						idx++;
-						// update mapping
-						unloadRegMapping->isActive = false;
-						rCtx.ppcRegToMapping[unloadRegMapping->virtualReg] = -1;
-					}
-					else
-						break;
-				}
-				// create load instruction
-				PPCRecompiler_pushBackIMLInstructions(imlSegment, idx, 1);
-				PPCRecImlInstruction_t* imlInstructionTemp = imlSegment->imlList + idx;
-				memset(imlInstructionTemp, 0x00, sizeof(PPCRecImlInstruction_t));
-				imlInstructionTemp->type = PPCREC_IML_TYPE_FPR_R_NAME;
-				imlInstructionTemp->operation = PPCREC_IML_OP_ASSIGN;
-				imlInstructionTemp->op_r_name.registerIndex = (uint8)(regMapping-rCtx.currentMapping);
-				imlInstructionTemp->op_r_name.name = ppcImlGenContext->mappedFPRRegister[virtualFpr];
-				imlInstructionTemp->op_r_name.copyWidth = 32;
-				imlInstructionTemp->op_r_name.flags = 0;
-				idx++;
-				// update mapping
-				regMapping->virtualReg = virtualFpr;
-				rCtx.ppcRegToMapping[virtualFpr] = (sint32)(regMapping - rCtx.currentMapping);
-				regMapping->lastUseIndex = rCtx.currentUseIndex;
-				rCtx.currentUseIndex++;
-			}
-			else
-			{
-				regMapping = rCtx.currentMapping + rCtx.ppcRegToMapping[virtualFpr];
-				regMapping->lastUseIndex = rCtx.currentUseIndex;
-				rCtx.currentUseIndex++;
-			}
-			// replace FPR
-			bool entryFound = false;
-			for (sint32 t = 0; t < numReplacedOperands; t++)
-			{
-				if (fprMatch[t] == virtualFpr)
-				{
-					cemu_assert_debug(fprReplace[t] == (regMapping - rCtx.currentMapping));
-					entryFound = true;
-					break;
-				}
-			}
-			if (entryFound == false)
-			{
-				cemu_assert_debug(numReplacedOperands != 4);
-				fprMatch[numReplacedOperands] = virtualFpr;
-				fprReplace[numReplacedOperands] = (sint32)(regMapping - rCtx.currentMapping);
-				numReplacedOperands++;
-			}
-		}
-		if (numReplacedOperands > 0)
-		{
-			PPCRecompiler_replaceFPRRegisterUsageMultiple(ppcImlGenContext, imlSegment->imlList + idx, fprMatch, fprReplace);
-		}
-		// next
-		idx++;
-	}
-	// count loaded registers
-	sint32 numLoadedRegisters = 0;
-	for (sint32 i = 0; i < PPC_X64_FPR_USABLE_REGISTERS; i++)
-	{
-		if (rCtx.currentMapping[i].isActive)
-			numLoadedRegisters++;
-	}
-	// store all loaded registers
-	if (numLoadedRegisters > 0)
-	{
-		PPCRecompiler_pushBackIMLInstructions(imlSegment, idx, numLoadedRegisters);
-		for (sint32 i = 0; i < PPC_X64_FPR_USABLE_REGISTERS; i++)
-		{
-			if (rCtx.currentMapping[i].isActive == false)
-				continue;
-			PPCRecImlInstruction_t* imlInstructionTemp = imlSegment->imlList + idx;
-			memset(imlInstructionTemp, 0x00, sizeof(PPCRecImlInstruction_t));
-			imlInstructionTemp->type = PPCREC_IML_TYPE_FPR_NAME_R;
-			imlInstructionTemp->operation = PPCREC_IML_OP_ASSIGN;
-			imlInstructionTemp->op_r_name.registerIndex = i;
-			imlInstructionTemp->op_r_name.name = ppcImlGenContext->mappedFPRRegister[rCtx.currentMapping[i].virtualReg];
-			imlInstructionTemp->op_r_name.copyWidth = 32;
-			imlInstructionTemp->op_r_name.flags = 0;
-			idx++;
-		}
-	}
-	return true;
-}
-
-bool PPCRecompiler_manageFPRRegisters(ppcImlGenContext_t* ppcImlGenContext)
-{
-	for (sint32 s = 0; s < ppcImlGenContext->segmentListCount; s++)
-	{
-		if (PPCRecompiler_manageFPRRegistersForSegment(ppcImlGenContext, s) == false)
-			return false;
-	}
-	return true;
-}
-
-
-/*
- * Returns true if the loaded value is guaranteed to be overwritten
- */
-bool PPCRecompiler_trackRedundantNameLoadInstruction(ppcImlGenContext_t* ppcImlGenContext, PPCRecImlSegment_t* imlSegment, sint32 startIndex, PPCRecImlInstruction_t* nameStoreInstruction, sint32 scanDepth)
-{
-	sint16 registerIndex = nameStoreInstruction->op_r_name.registerIndex;
-	for(sint32 i=startIndex; i<imlSegment->imlListCount; i++)
-	{
-		PPCRecImlInstruction_t* imlInstruction = imlSegment->imlList+i;
-		//nameStoreInstruction->op_r_name.registerIndex
-		PPCImlOptimizerUsedRegisters_t registersUsed;
-		PPCRecompiler_checkRegisterUsage(ppcImlGenContext, imlSegment->imlList+i, &registersUsed);
-		if( registersUsed.readNamedReg1 == registerIndex || registersUsed.readNamedReg2 == registerIndex || registersUsed.readNamedReg3 == registerIndex )
-			return false;
-		if( registersUsed.writtenNamedReg1 == registerIndex )
-			return true;
-	}
-	// todo: Scan next segment(s)
-	return false;
-}
-
-/*
- * Returns true if the loaded value is guaranteed to be overwritten
- */
-bool PPCRecompiler_trackRedundantFPRNameLoadInstruction(ppcImlGenContext_t* ppcImlGenContext, PPCRecImlSegment_t* imlSegment, sint32 startIndex, PPCRecImlInstruction_t* nameStoreInstruction, sint32 scanDepth)
-{
-	sint16 registerIndex = nameStoreInstruction->op_r_name.registerIndex;
-	for(sint32 i=startIndex; i<imlSegment->imlListCount; i++)
-	{
-		PPCRecImlInstruction_t* imlInstruction = imlSegment->imlList+i;
-		PPCImlOptimizerUsedRegisters_t registersUsed;
-		PPCRecompiler_checkRegisterUsage(ppcImlGenContext, imlSegment->imlList+i, &registersUsed);
-		if( registersUsed.readFPR1 == registerIndex || registersUsed.readFPR2 == registerIndex || registersUsed.readFPR3 == registerIndex || registersUsed.readFPR4 == registerIndex)
-			return false;
-		if( registersUsed.writtenFPR1 == registerIndex )
-			return true;
-	}
-	// todo: Scan next segment(s)
-	return false;
-}
-
-/*
- * Returns true if the loaded name is never changed
- */
-bool PPCRecompiler_trackRedundantNameStoreInstruction(ppcImlGenContext_t* ppcImlGenContext, PPCRecImlSegment_t* imlSegment, sint32 startIndex, PPCRecImlInstruction_t* nameStoreInstruction, sint32 scanDepth)
-{
-	sint16 registerIndex = nameStoreInstruction->op_r_name.registerIndex;
-	for(sint32 i=startIndex; i>=0; i--)
-	{
-		PPCRecImlInstruction_t* imlInstruction = imlSegment->imlList+i;
-		PPCImlOptimizerUsedRegisters_t registersUsed;
-		PPCRecompiler_checkRegisterUsage(ppcImlGenContext, imlSegment->imlList+i, &registersUsed);
-		if( registersUsed.writtenNamedReg1 == registerIndex )
-		{
-			if( imlSegment->imlList[i].type == PPCREC_IML_TYPE_R_NAME )
-				return true;
-			return false;
-		}
-	}
-	return false;
-}
-
-sint32 debugCallCounter1 = 0;
-
-/*
- * Returns true if the name is overwritten in the current or any following segments
- */
-bool PPCRecompiler_trackOverwrittenNameStoreInstruction(ppcImlGenContext_t* ppcImlGenContext, PPCRecImlSegment_t* imlSegment, sint32 startIndex, PPCRecImlInstruction_t* nameStoreInstruction, sint32 scanDepth)
-{
-	//sint16 registerIndex = nameStoreInstruction->op_r_name.registerIndex;
-	uint32 name = nameStoreInstruction->op_r_name.name;
-	for(sint32 i=startIndex; i<imlSegment->imlListCount; i++)
-	{
-		PPCRecImlInstruction_t* imlInstruction = imlSegment->imlList+i;
-		if( imlSegment->imlList[i].type == PPCREC_IML_TYPE_R_NAME )
-		{
-			// name is loaded before being written
-			if( imlSegment->imlList[i].op_r_name.name == name )
-				return false;
-		}
-		else if( imlSegment->imlList[i].type == PPCREC_IML_TYPE_NAME_R )
-		{
-			// name is written before being loaded
-			if( imlSegment->imlList[i].op_r_name.name == name )
-				return true;
-		}
-	}
-	if( scanDepth >= 2 )
-		return false;
-	if( imlSegment->nextSegmentIsUncertain )
-		return false;
-	if( imlSegment->nextSegmentBranchTaken && PPCRecompiler_trackOverwrittenNameStoreInstruction(ppcImlGenContext, imlSegment->nextSegmentBranchTaken, 0, nameStoreInstruction, scanDepth+1) == false )
-		return false;
-	if( imlSegment->nextSegmentBranchNotTaken && PPCRecompiler_trackOverwrittenNameStoreInstruction(ppcImlGenContext, imlSegment->nextSegmentBranchNotTaken, 0, nameStoreInstruction, scanDepth+1) == false )
-		return false;
-	if( imlSegment->nextSegmentBranchTaken == NULL && imlSegment->nextSegmentBranchNotTaken == NULL )
-		return false;
-
-	return true;
-}
-
-/*
- * Returns true if the loaded FPR name is never changed
- */
-bool PPCRecompiler_trackRedundantFPRNameStoreInstruction(ppcImlGenContext_t* ppcImlGenContext, PPCRecImlSegment_t* imlSegment, sint32 startIndex, PPCRecImlInstruction_t* nameStoreInstruction, sint32 scanDepth)
-{
-	sint16 registerIndex = nameStoreInstruction->op_r_name.registerIndex;
-	for(sint32 i=startIndex; i>=0; i--)
-	{
-		PPCRecImlInstruction_t* imlInstruction = imlSegment->imlList+i;
-		PPCImlOptimizerUsedRegisters_t registersUsed;
-		PPCRecompiler_checkRegisterUsage(ppcImlGenContext, imlSegment->imlList+i, &registersUsed);
-		if( registersUsed.writtenFPR1 == registerIndex )
-		{
-			if( imlSegment->imlList[i].type == PPCREC_IML_TYPE_FPR_R_NAME )
-				return true;
-			return false;
-		}
-	}
-	// todo: Scan next segment(s)
-	return false;
-}
-
-uint32 _PPCRecompiler_getCROverwriteMask(ppcImlGenContext_t* ppcImlGenContext, PPCRecImlSegment_t* imlSegment, uint32 currentOverwriteMask, uint32 currentReadMask, uint32 scanDepth)
-{
-	// is any bit overwritten but not read?
-	uint32 overwriteMask = imlSegment->crBitsWritten&~imlSegment->crBitsInput;
-	currentOverwriteMask |= overwriteMask;
-	// next segment
-	if( imlSegment->nextSegmentIsUncertain == false && scanDepth < 3 )
-	{
-		uint32 nextSegmentOverwriteMask = 0;
-		if( imlSegment->nextSegmentBranchTaken && imlSegment->nextSegmentBranchNotTaken )
-		{
-			uint32 mask0 = _PPCRecompiler_getCROverwriteMask(ppcImlGenContext, imlSegment->nextSegmentBranchTaken, 0, 0, scanDepth+1);
-			uint32 mask1 = _PPCRecompiler_getCROverwriteMask(ppcImlGenContext, imlSegment->nextSegmentBranchNotTaken, 0, 0, scanDepth+1);
-			nextSegmentOverwriteMask = mask0&mask1;
-		}
-		else if( imlSegment->nextSegmentBranchNotTaken)
-		{
-			nextSegmentOverwriteMask = _PPCRecompiler_getCROverwriteMask(ppcImlGenContext, imlSegment->nextSegmentBranchNotTaken, 0, 0, scanDepth+1);
-		}
-		nextSegmentOverwriteMask &= ~imlSegment->crBitsRead;
-		currentOverwriteMask |= nextSegmentOverwriteMask;
-	}
-	else if (imlSegment->nextSegmentIsUncertain)
-	{
-		if (ppcImlGenContext->segmentListCount >= 5)
-		{
-			return 7; // for more complex functions we assume that CR is not passed on
-		}
-	}
-	return currentOverwriteMask;
-}
-
-/*
- * Returns a mask of all CR bits that are overwritten (written but not read) in the segment and all it's following segments
- * If the write state of a CR bit cannot be determined, it is returned as 0 (not overwritten)
- */
-uint32 PPCRecompiler_getCROverwriteMask(ppcImlGenContext_t* ppcImlGenContext, PPCRecImlSegment_t* imlSegment)
-{
-	if (imlSegment->nextSegmentIsUncertain)
-	{
-		return 0;
-	}
-	if( imlSegment->nextSegmentBranchTaken && imlSegment->nextSegmentBranchNotTaken )
-	{
-		uint32 mask0 = _PPCRecompiler_getCROverwriteMask(ppcImlGenContext, imlSegment->nextSegmentBranchTaken, 0, 0, 0);
-		uint32 mask1 = _PPCRecompiler_getCROverwriteMask(ppcImlGenContext, imlSegment->nextSegmentBranchNotTaken, 0, 0, 0);
-		return mask0&mask1; // only return bits that are overwritten in both branches
-	}
-	else if( imlSegment->nextSegmentBranchNotTaken )
-	{
-		uint32 mask = _PPCRecompiler_getCROverwriteMask(ppcImlGenContext, imlSegment->nextSegmentBranchNotTaken, 0, 0, 0);
-		return mask;
-	}
-	else
-	{
-		// not implemented
-	}
-	return 0;
-}
-
-void PPCRecompiler_removeRedundantCRUpdates(ppcImlGenContext_t* ppcImlGenContext)
-{
-	for(sint32 s=0; s<ppcImlGenContext->segmentListCount; s++)
-	{
-		PPCRecImlSegment_t* imlSegment = ppcImlGenContext->segmentList[s];
-
-		for(sint32 i=0; i<imlSegment->imlListCount; i++)
-		{
-			PPCRecImlInstruction_t* imlInstruction = imlSegment->imlList+i;
-			if (imlInstruction->type == PPCREC_IML_TYPE_CJUMP)
-			{
-				if (imlInstruction->op_conditionalJump.condition != PPCREC_JUMP_CONDITION_NONE)
-				{
-					uint32 crBitFlag = 1 << (imlInstruction->op_conditionalJump.crRegisterIndex * 4 + imlInstruction->op_conditionalJump.crBitIndex);
-					imlSegment->crBitsInput |= (crBitFlag&~imlSegment->crBitsWritten); // flag bits that have not already been written
-					imlSegment->crBitsRead |= (crBitFlag);
-				}
-			}
-			else if (imlInstruction->type == PPCREC_IML_TYPE_CONDITIONAL_R_S32)
-			{
-				uint32 crBitFlag = 1 << (imlInstruction->op_conditional_r_s32.crRegisterIndex * 4 + imlInstruction->op_conditional_r_s32.crBitIndex);
-				imlSegment->crBitsInput |= (crBitFlag&~imlSegment->crBitsWritten); // flag bits that have not already been written
-				imlSegment->crBitsRead |= (crBitFlag);
-			}
-			else if (imlInstruction->type == PPCREC_IML_TYPE_R_S32 && imlInstruction->operation == PPCREC_IML_OP_MFCR)
-			{
-				imlSegment->crBitsRead |= 0xFFFFFFFF;
-			}
-			else if (imlInstruction->type == PPCREC_IML_TYPE_R_S32 && imlInstruction->operation == PPCREC_IML_OP_MTCRF)
-			{
-				imlSegment->crBitsWritten |= ppc_MTCRFMaskToCRBitMask((uint32)imlInstruction->op_r_immS32.immS32);
-			}
-			else if( imlInstruction->type == PPCREC_IML_TYPE_CR )
-			{
-				if (imlInstruction->operation == PPCREC_IML_OP_CR_CLEAR ||
-					imlInstruction->operation == PPCREC_IML_OP_CR_SET)
-				{
-					uint32 crBitFlag = 1 << (imlInstruction->op_cr.crD);
-					imlSegment->crBitsWritten |= (crBitFlag & ~imlSegment->crBitsWritten);
-				}
-				else if (imlInstruction->operation == PPCREC_IML_OP_CR_OR ||
-					imlInstruction->operation == PPCREC_IML_OP_CR_ORC ||
-					imlInstruction->operation == PPCREC_IML_OP_CR_AND ||
-					imlInstruction->operation == PPCREC_IML_OP_CR_ANDC)
-				{
-					uint32 crBitFlag = 1 << (imlInstruction->op_cr.crD);
-					imlSegment->crBitsWritten |= (crBitFlag & ~imlSegment->crBitsWritten);
-					crBitFlag = 1 << (imlInstruction->op_cr.crA);
-					imlSegment->crBitsRead |= (crBitFlag & ~imlSegment->crBitsRead);
-					crBitFlag = 1 << (imlInstruction->op_cr.crB);
-					imlSegment->crBitsRead |= (crBitFlag & ~imlSegment->crBitsRead);
-				}
-				else
-					cemu_assert_unimplemented();
-			}
-			else if( PPCRecompilerImlAnalyzer_canTypeWriteCR(imlInstruction) && imlInstruction->crRegister >= 0 && imlInstruction->crRegister <= 7 )
-			{
-				imlSegment->crBitsWritten |= (0xF<<(imlInstruction->crRegister*4));
-			}
-			else if( (imlInstruction->type == PPCREC_IML_TYPE_STORE || imlInstruction->type == PPCREC_IML_TYPE_STORE_INDEXED) && imlInstruction->op_storeLoad.copyWidth == PPC_REC_STORE_STWCX_MARKER )
-			{
-				// overwrites CR0
-				imlSegment->crBitsWritten |= (0xF<<0);
-			}
-		}
-	}
-	// flag instructions that write to CR where we can ignore individual CR bits
-	for(sint32 s=0; s<ppcImlGenContext->segmentListCount; s++)
-	{
-		PPCRecImlSegment_t* imlSegment = ppcImlGenContext->segmentList[s];
-		for(sint32 i=0; i<imlSegment->imlListCount; i++)
-		{
-			PPCRecImlInstruction_t* imlInstruction = imlSegment->imlList+i;
-			if( PPCRecompilerImlAnalyzer_canTypeWriteCR(imlInstruction) && imlInstruction->crRegister >= 0 && imlInstruction->crRegister <= 7 )
-			{
-				uint32 crBitFlags = 0xF<<((uint32)imlInstruction->crRegister*4);
-				uint32 crOverwriteMask = PPCRecompiler_getCROverwriteMask(ppcImlGenContext, imlSegment);
-				uint32 crIgnoreMask = crOverwriteMask & ~imlSegment->crBitsRead;
-				imlInstruction->crIgnoreMask = crIgnoreMask;
-			}
-		}
-	}
-}
-
-bool PPCRecompiler_checkIfGPRIsModifiedInRange(ppcImlGenContext_t* ppcImlGenContext, PPCRecImlSegment_t* imlSegment, sint32 startIndex, sint32 endIndex, sint32 vreg)
-{
-	PPCImlOptimizerUsedRegisters_t registersUsed;
-	for (sint32 i = startIndex; i <= endIndex; i++)
-	{
-		PPCRecImlInstruction_t* imlInstruction = imlSegment->imlList + i;
-		PPCRecompiler_checkRegisterUsage(ppcImlGenContext, imlInstruction, &registersUsed);
-		if (registersUsed.writtenNamedReg1 == vreg)
-			return true;
-	}
-	return false;
-}
-
-sint32 PPCRecompiler_scanBackwardsForReusableRegister(ppcImlGenContext_t* ppcImlGenContext, PPCRecImlSegment_t* startSegment, sint32 startIndex, sint32 name)
-{
-	// current segment
-	sint32 currentIndex = startIndex;
-	PPCRecImlSegment_t* currentSegment = startSegment;
-	sint32 segmentIterateCount = 0;
-	sint32 foundRegister = -1;
-	while (true)
-	{
-		// stop scanning if segment is enterable
-		if (currentSegment->isEnterable)
-			return -1;
-		while (currentIndex >= 0)
-		{
-			if (currentSegment->imlList[currentIndex].type == PPCREC_IML_TYPE_NAME_R && currentSegment->imlList[currentIndex].op_r_name.name == name)
-			{
-				foundRegister = currentSegment->imlList[currentIndex].op_r_name.registerIndex;
-				break;
-			}
-			// previous instruction
-			currentIndex--;
-		}
-		if (foundRegister >= 0)
-			break;
-		// continue at previous segment (if there is only one)
-		if (segmentIterateCount >= 1)
-			return -1;
-		if (currentSegment->list_prevSegments.size() != 1)
-			return -1;
-		currentSegment = currentSegment->list_prevSegments[0];
-		currentIndex = currentSegment->imlListCount - 1;
-		segmentIterateCount++;
-	}
-	// scan again to make sure the register is not modified inbetween
-	currentIndex = startIndex;
-	currentSegment = startSegment;
-	segmentIterateCount = 0;
-	PPCImlOptimizerUsedRegisters_t registersUsed;
-	while (true)
-	{
-		while (currentIndex >= 0)
-		{
-			// check if register is modified
-			PPCRecompiler_checkRegisterUsage(ppcImlGenContext, currentSegment->imlList+currentIndex, &registersUsed);
-			if (registersUsed.writtenNamedReg1 == foundRegister)
-				return -1;
-			// check if end of scan reached
-			if (currentSegment->imlList[currentIndex].type == PPCREC_IML_TYPE_NAME_R && currentSegment->imlList[currentIndex].op_r_name.name == name)
-			{
-				//foundRegister = currentSegment->imlList[currentIndex].op_r_name.registerIndex;
-				return foundRegister;
-			}
-			// previous instruction
-			currentIndex--;
-		}
-		// continue at previous segment (if there is only one)
-		if (segmentIterateCount >= 1)
-			return -1;
-		if (currentSegment->list_prevSegments.size() != 1)
-			return -1;
-		currentSegment = currentSegment->list_prevSegments[0];
-		currentIndex = currentSegment->imlListCount - 1;
-		segmentIterateCount++;
-	}
-	return -1;
-}
-
-void PPCRecompiler_optimizeDirectFloatCopiesScanForward(ppcImlGenContext_t* ppcImlGenContext, PPCRecImlSegment_t* imlSegment, sint32 imlIndexLoad, sint32 fprIndex)
-{
-	PPCRecImlInstruction_t* imlInstructionLoad = imlSegment->imlList + imlIndexLoad;
-	if (imlInstructionLoad->op_storeLoad.flags2.notExpanded)
-		return;
-
-	PPCImlOptimizerUsedRegisters_t registersUsed;
-	sint32 scanRangeEnd = std::min(imlIndexLoad + 25, imlSegment->imlListCount); // don't scan too far (saves performance and also the chances we can merge the load+store become low at high distances)
-	bool foundMatch = false;
-	sint32 lastStore = -1;
-	for (sint32 i = imlIndexLoad + 1; i < scanRangeEnd; i++)
-	{
-		PPCRecImlInstruction_t* imlInstruction = imlSegment->imlList + i;
-		if (PPCRecompiler_isSuffixInstruction(imlInstruction))
-		{
-			break;
-		}
-
-		// check if FPR is stored
-		if ((imlInstruction->type == PPCREC_IML_TYPE_FPR_STORE && imlInstruction->op_storeLoad.mode == PPCREC_FPR_ST_MODE_SINGLE_FROM_PS0) ||
-			(imlInstruction->type == PPCREC_IML_TYPE_FPR_STORE_INDEXED && imlInstruction->op_storeLoad.mode == PPCREC_FPR_ST_MODE_SINGLE_FROM_PS0))
-		{
-			if (imlInstruction->op_storeLoad.registerData == fprIndex)
-			{
-				if (foundMatch == false)
-				{
-					// flag the load-single instruction as "don't expand" (leave single value as-is)
-					imlInstructionLoad->op_storeLoad.flags2.notExpanded = true;
-				}
-				// also set the flag for the store instruction
-				PPCRecImlInstruction_t* imlInstructionStore = imlInstruction;
-				imlInstructionStore->op_storeLoad.flags2.notExpanded = true;
-
-				foundMatch = true;
-				lastStore = i + 1;
-
-				continue;
-			}
-		}
-
-		// check if FPR is overwritten (we can actually ignore read operations?)
-		PPCRecompiler_checkRegisterUsage(ppcImlGenContext, imlInstruction, &registersUsed);
-		if (registersUsed.writtenFPR1 == fprIndex)
-			break;
-		if (registersUsed.readFPR1 == fprIndex)
-			break;
-		if (registersUsed.readFPR2 == fprIndex)
-			break;
-		if (registersUsed.readFPR3 == fprIndex)
-			break;
-		if (registersUsed.readFPR4 == fprIndex)
-			break;
-	}
-
-	if (foundMatch)
-	{
-		// insert expand instruction after store
-		PPCRecImlInstruction_t* newExpand = PPCRecompiler_insertInstruction(imlSegment, lastStore);
-		PPCRecompilerImlGen_generateNewInstruction_fpr_r(ppcImlGenContext, newExpand, PPCREC_IML_OP_FPR_EXPAND_BOTTOM32_TO_BOTTOM64_AND_TOP64, fprIndex);
-	}
-}
-
-/*
-* Scans for patterns:
-* <Load sp float into register f>
-* <Random unrelated instructions>
-* <Store sp float from register f>
-* For these patterns the store and load is modified to work with un-extended values (float remains as float, no double conversion)
-* The float->double extension is then executed later
-* Advantages:
-* Keeps denormals and other special float values intact
-* Slightly improves performance
-*/
-void PPCRecompiler_optimizeDirectFloatCopies(ppcImlGenContext_t* ppcImlGenContext)
-{
-	for (sint32 s = 0; s < ppcImlGenContext->segmentListCount; s++)
-	{
-		PPCRecImlSegment_t* imlSegment = ppcImlGenContext->segmentList[s];
-
-		for (sint32 i = 0; i < imlSegment->imlListCount; i++)
-		{
-			PPCRecImlInstruction_t* imlInstruction = imlSegment->imlList + i;
-			if (imlInstruction->type == PPCREC_IML_TYPE_FPR_LOAD && imlInstruction->op_storeLoad.mode == PPCREC_FPR_LD_MODE_SINGLE_INTO_PS0_PS1)
-			{
-				PPCRecompiler_optimizeDirectFloatCopiesScanForward(ppcImlGenContext, imlSegment, i, imlInstruction->op_storeLoad.registerData);
-			}
-			else if (imlInstruction->type == PPCREC_IML_TYPE_FPR_LOAD_INDEXED && imlInstruction->op_storeLoad.mode == PPCREC_FPR_LD_MODE_SINGLE_INTO_PS0_PS1)
-			{
-				PPCRecompiler_optimizeDirectFloatCopiesScanForward(ppcImlGenContext, imlSegment, i, imlInstruction->op_storeLoad.registerData);
-			}
-		}
-	}
-}
-
-void PPCRecompiler_optimizeDirectIntegerCopiesScanForward(ppcImlGenContext_t* ppcImlGenContext, PPCRecImlSegment_t* imlSegment, sint32 imlIndexLoad, sint32 gprIndex)
-{
-	PPCRecImlInstruction_t* imlInstructionLoad = imlSegment->imlList + imlIndexLoad;
-	if ( imlInstructionLoad->op_storeLoad.flags2.swapEndian == false )
-		return;
-	bool foundMatch = false;
-	PPCImlOptimizerUsedRegisters_t registersUsed;
-	sint32 scanRangeEnd = std::min(imlIndexLoad + 25, imlSegment->imlListCount); // don't scan too far (saves performance and also the chances we can merge the load+store become low at high distances)
-	sint32 i = imlIndexLoad + 1;
-	for (; i < scanRangeEnd; i++)
-	{
-		PPCRecImlInstruction_t* imlInstruction = imlSegment->imlList + i;
-		if (PPCRecompiler_isSuffixInstruction(imlInstruction))
-		{
-			break;
-		}
-		// check if GPR is stored
-		if ((imlInstruction->type == PPCREC_IML_TYPE_STORE && imlInstruction->op_storeLoad.copyWidth == 32 ) )
-		{
-			if (imlInstruction->op_storeLoad.registerMem == gprIndex)
-				break;
-			if (imlInstruction->op_storeLoad.registerData == gprIndex)
-			{
-				PPCRecImlInstruction_t* imlInstructionStore = imlInstruction;
-				if (foundMatch == false)
-				{
-					// switch the endian swap flag for the load instruction
-					imlInstructionLoad->op_storeLoad.flags2.swapEndian = !imlInstructionLoad->op_storeLoad.flags2.swapEndian;
-					foundMatch = true;
-				}
-				// switch the endian swap flag for the store instruction
-				imlInstructionStore->op_storeLoad.flags2.swapEndian = !imlInstructionStore->op_storeLoad.flags2.swapEndian;
-				// keep scanning
-				continue;
-			}
-		}
-		// check if GPR is accessed
-		PPCRecompiler_checkRegisterUsage(ppcImlGenContext, imlInstruction, &registersUsed);
-		if (registersUsed.readNamedReg1 == gprIndex ||
-			registersUsed.readNamedReg2 == gprIndex ||
-			registersUsed.readNamedReg3 == gprIndex)
-		{
-			break;
-		}
-		if (registersUsed.writtenNamedReg1 == gprIndex)
-			return; // GPR overwritten, we don't need to byte swap anymore
-	}
-	if (foundMatch)
-	{
-		// insert expand instruction
-		PPCRecImlInstruction_t* newExpand = PPCRecompiler_insertInstruction(imlSegment, i);
-		PPCRecompilerImlGen_generateNewInstruction_r_r(ppcImlGenContext, newExpand, PPCREC_IML_OP_ENDIAN_SWAP, gprIndex, gprIndex);
-	}
-}
-
-/*
-* Scans for patterns:
-* <Load sp integer into register r>
-* <Random unrelated instructions>
-* <Store sp integer from register r>
-* For these patterns the store and load is modified to work with non-swapped values
-* The big_endian->little_endian conversion is then executed later
-* Advantages:
-* Slightly improves performance
-*/
-void PPCRecompiler_optimizeDirectIntegerCopies(ppcImlGenContext_t* ppcImlGenContext)
-{
-	for (sint32 s = 0; s < ppcImlGenContext->segmentListCount; s++)
-	{
-		PPCRecImlSegment_t* imlSegment = ppcImlGenContext->segmentList[s];
-
-		for (sint32 i = 0; i < imlSegment->imlListCount; i++)
-		{
-			PPCRecImlInstruction_t* imlInstruction = imlSegment->imlList + i;
-			if (imlInstruction->type == PPCREC_IML_TYPE_LOAD && imlInstruction->op_storeLoad.copyWidth == 32 && imlInstruction->op_storeLoad.flags2.swapEndian )
-			{
-				PPCRecompiler_optimizeDirectIntegerCopiesScanForward(ppcImlGenContext, imlSegment, i, imlInstruction->op_storeLoad.registerData);
-			}
-		}
-	}
-}
-
-sint32 _getGQRIndexFromRegister(ppcImlGenContext_t* ppcImlGenContext, sint32 registerIndex)
-{
-	if (registerIndex == PPC_REC_INVALID_REGISTER)
-		return -1;
-	sint32 namedReg = ppcImlGenContext->mappedRegister[registerIndex];
-	if (namedReg >= (PPCREC_NAME_SPR0 + SPR_UGQR0) && namedReg <= (PPCREC_NAME_SPR0 + SPR_UGQR7))
-	{
-		return namedReg - (PPCREC_NAME_SPR0 + SPR_UGQR0);
-	}
-	return -1;
-}
-
-bool PPCRecompiler_isUGQRValueKnown(ppcImlGenContext_t* ppcImlGenContext, sint32 gqrIndex, uint32& gqrValue)
-{
-	// UGQR 2 to 7 are initialized by the OS and we assume that games won't ever permanently touch those
-	// todo - hack - replace with more accurate solution
-	if (gqrIndex == 2)
-		gqrValue = 0x00040004;
-	else if (gqrIndex == 3)
-		gqrValue = 0x00050005;
-	else if (gqrIndex == 4)
-		gqrValue = 0x00060006;
-	else if (gqrIndex == 5)
-		gqrValue = 0x00070007;
-	else
-		return false;
-	return true;
-}
-
-/*
- * If value of GQR can be predicted for a given PSQ load or store instruction then replace it with an optimized version
- */
-void PPCRecompiler_optimizePSQLoadAndStore(ppcImlGenContext_t* ppcImlGenContext)
-{
-	for (sint32 s = 0; s < ppcImlGenContext->segmentListCount; s++)
-	{
-		PPCRecImlSegment_t* imlSegment = ppcImlGenContext->segmentList[s];
-		for (sint32 i = 0; i < imlSegment->imlListCount; i++)
-		{
-			PPCRecImlInstruction_t* imlInstruction = imlSegment->imlList + i;
-			if (imlInstruction->type == PPCREC_IML_TYPE_FPR_LOAD || imlInstruction->type == PPCREC_IML_TYPE_FPR_LOAD_INDEXED)
-			{
-				if(imlInstruction->op_storeLoad.mode != PPCREC_FPR_LD_MODE_PSQ_GENERIC_PS0 &&
-					imlInstruction->op_storeLoad.mode != PPCREC_FPR_LD_MODE_PSQ_GENERIC_PS0_PS1 )
-					continue;
-				// get GQR value
-				cemu_assert_debug(imlInstruction->op_storeLoad.registerGQR != PPC_REC_INVALID_REGISTER);
-				sint32 gqrIndex = _getGQRIndexFromRegister(ppcImlGenContext, imlInstruction->op_storeLoad.registerGQR);
-				cemu_assert(gqrIndex >= 0);
-				if (ppcImlGenContext->tracking.modifiesGQR[gqrIndex])
-					continue;
-				//uint32 gqrValue = ppcInterpreterCurrentInstance->sprNew.UGQR[gqrIndex];
-				uint32 gqrValue;
-				if (!PPCRecompiler_isUGQRValueKnown(ppcImlGenContext, gqrIndex, gqrValue))
-					continue;
-
-				uint32 formatType = (gqrValue >> 16) & 7;
-				uint32 scale = (gqrValue >> 24) & 0x3F;
-				if (scale != 0)
-					continue; // only generic handler supports scale
-				if (imlInstruction->op_storeLoad.mode == PPCREC_FPR_LD_MODE_PSQ_GENERIC_PS0)
-				{
-					if (formatType == 0)
-						imlInstruction->op_storeLoad.mode = PPCREC_FPR_LD_MODE_PSQ_FLOAT_PS0;
-					else if (formatType == 4)
-						imlInstruction->op_storeLoad.mode = PPCREC_FPR_LD_MODE_PSQ_U8_PS0;
-					else if (formatType == 5)
-						imlInstruction->op_storeLoad.mode = PPCREC_FPR_LD_MODE_PSQ_U16_PS0;
-					else if (formatType == 6)
-						imlInstruction->op_storeLoad.mode = PPCREC_FPR_LD_MODE_PSQ_S8_PS0;
-					else if (formatType == 7)
-						imlInstruction->op_storeLoad.mode = PPCREC_FPR_LD_MODE_PSQ_S16_PS0;
-				}
-				else if (imlInstruction->op_storeLoad.mode == PPCREC_FPR_LD_MODE_PSQ_GENERIC_PS0_PS1)
-				{
-					if (formatType == 0)
-						imlInstruction->op_storeLoad.mode = PPCREC_FPR_LD_MODE_PSQ_FLOAT_PS0_PS1;
-					else if (formatType == 4)
-						imlInstruction->op_storeLoad.mode = PPCREC_FPR_LD_MODE_PSQ_U8_PS0_PS1;
-					else if (formatType == 5)
-						imlInstruction->op_storeLoad.mode = PPCREC_FPR_LD_MODE_PSQ_U16_PS0_PS1;
-					else if (formatType == 6)
-						imlInstruction->op_storeLoad.mode = PPCREC_FPR_LD_MODE_PSQ_S8_PS0_PS1;
-					else if (formatType == 7)
-						imlInstruction->op_storeLoad.mode = PPCREC_FPR_LD_MODE_PSQ_S16_PS0_PS1;
-				}
-			}
-			else if (imlInstruction->type == PPCREC_IML_TYPE_FPR_STORE || imlInstruction->type == PPCREC_IML_TYPE_FPR_STORE_INDEXED)
-			{
-				if(imlInstruction->op_storeLoad.mode != PPCREC_FPR_ST_MODE_PSQ_GENERIC_PS0 &&
-					imlInstruction->op_storeLoad.mode != PPCREC_FPR_ST_MODE_PSQ_GENERIC_PS0_PS1)
-					continue;
-				// get GQR value
-				cemu_assert_debug(imlInstruction->op_storeLoad.registerGQR != PPC_REC_INVALID_REGISTER);
-				sint32 gqrIndex = _getGQRIndexFromRegister(ppcImlGenContext, imlInstruction->op_storeLoad.registerGQR);
-				cemu_assert(gqrIndex >= 0);
-				if (ppcImlGenContext->tracking.modifiesGQR[gqrIndex])
-					continue;
-				uint32 gqrValue;
-				if(!PPCRecompiler_isUGQRValueKnown(ppcImlGenContext, gqrIndex, gqrValue))
-					continue;
-				uint32 formatType = (gqrValue >> 16) & 7;
-				uint32 scale = (gqrValue >> 24) & 0x3F;
-				if (scale != 0)
-					continue; // only generic handler supports scale
-				if (imlInstruction->op_storeLoad.mode == PPCREC_FPR_ST_MODE_PSQ_GENERIC_PS0)
-				{
-					if (formatType == 0)
-						imlInstruction->op_storeLoad.mode = PPCREC_FPR_ST_MODE_PSQ_FLOAT_PS0;
-					else if (formatType == 4)
-						imlInstruction->op_storeLoad.mode = PPCREC_FPR_ST_MODE_PSQ_U8_PS0;
-					else if (formatType == 5)
-						imlInstruction->op_storeLoad.mode = PPCREC_FPR_ST_MODE_PSQ_U16_PS0;
-					else if (formatType == 6)
-						imlInstruction->op_storeLoad.mode = PPCREC_FPR_ST_MODE_PSQ_S8_PS0;
-					else if (formatType == 7)
-						imlInstruction->op_storeLoad.mode = PPCREC_FPR_ST_MODE_PSQ_S16_PS0;
-				}
-				else if (imlInstruction->op_storeLoad.mode == PPCREC_FPR_ST_MODE_PSQ_GENERIC_PS0_PS1)
-				{
-					if (formatType == 0)
-						imlInstruction->op_storeLoad.mode = PPCREC_FPR_ST_MODE_PSQ_FLOAT_PS0_PS1;
-					else if (formatType == 4)
-						imlInstruction->op_storeLoad.mode = PPCREC_FPR_ST_MODE_PSQ_U8_PS0_PS1;
-					else if (formatType == 5)
-						imlInstruction->op_storeLoad.mode = PPCREC_FPR_ST_MODE_PSQ_U16_PS0_PS1;
-					else if (formatType == 6)
-						imlInstruction->op_storeLoad.mode = PPCREC_FPR_ST_MODE_PSQ_S8_PS0_PS1;
-					else if (formatType == 7)
-						imlInstruction->op_storeLoad.mode = PPCREC_FPR_ST_MODE_PSQ_S16_PS0_PS1;
-				}
-			}
-		}
-	}
-}
-
-/*
- * Returns true if registerWrite overwrites any of the registers read by registerRead
- */
-bool PPCRecompilerAnalyzer_checkForGPROverwrite(PPCImlOptimizerUsedRegisters_t* registerRead, PPCImlOptimizerUsedRegisters_t* registerWrite)
-{
-	if (registerWrite->writtenNamedReg1 < 0)
-		return false;
-
-	if (registerWrite->writtenNamedReg1 == registerRead->readNamedReg1)
-		return true;
-	if (registerWrite->writtenNamedReg1 == registerRead->readNamedReg2)
-		return true;
-	if (registerWrite->writtenNamedReg1 == registerRead->readNamedReg3)
-		return true;
-	return false;
-}
-
-void _reorderConditionModifyInstructions(PPCRecImlSegment_t* imlSegment)
-{
-	PPCRecImlInstruction_t* lastInstruction = PPCRecompilerIML_getLastInstruction(imlSegment);
-	// last instruction a conditional branch?
-	if (lastInstruction == nullptr || lastInstruction->type != PPCREC_IML_TYPE_CJUMP)
-		return;
-	if (lastInstruction->op_conditionalJump.crRegisterIndex >= 8)
-		return;
-	// get CR bitmask of bit required for conditional jump
-	PPCRecCRTracking_t crTracking;
-	PPCRecompilerImlAnalyzer_getCRTracking(lastInstruction, &crTracking);
-	uint32 requiredCRBits = crTracking.readCRBits;
-
-	// scan backwards until we find the instruction that sets the CR
-	sint32 crSetterInstructionIndex = -1;
-	sint32 unsafeInstructionIndex = -1;
-	for (sint32 i = imlSegment->imlListCount-2; i >= 0; i--)
-	{
-		PPCRecImlInstruction_t* imlInstruction = imlSegment->imlList + i;
-		PPCRecompilerImlAnalyzer_getCRTracking(imlInstruction, &crTracking);
-		if (crTracking.readCRBits != 0)
-			return; // dont handle complex cases for now
-		if (crTracking.writtenCRBits != 0)
-		{
-			if ((crTracking.writtenCRBits&requiredCRBits) != 0)
-			{
-				crSetterInstructionIndex = i;
-				break;
-			}
-			else
-			{
-				return; // other CR bits overwritten (dont handle complex cases)
-			}
-		}
-		// is safe? (no risk of overwriting x64 eflags)
-		if ((imlInstruction->type == PPCREC_IML_TYPE_NAME_R || imlInstruction->type == PPCREC_IML_TYPE_R_NAME || imlInstruction->type == PPCREC_IML_TYPE_NO_OP) ||
-			(imlInstruction->type == PPCREC_IML_TYPE_FPR_NAME_R || imlInstruction->type == PPCREC_IML_TYPE_FPR_R_NAME) ||
-			(imlInstruction->type == PPCREC_IML_TYPE_R_S32 && (imlInstruction->operation == PPCREC_IML_OP_ASSIGN)) ||
-			(imlInstruction->type == PPCREC_IML_TYPE_R_R && (imlInstruction->operation == PPCREC_IML_OP_ASSIGN)) )
-			continue;
-		// not safe
-		//hasUnsafeInstructions = true;
-		if (unsafeInstructionIndex == -1)
-			unsafeInstructionIndex = i;
-	}
-	if (crSetterInstructionIndex < 0)
-		return;
-	if (unsafeInstructionIndex < 0)
-		return; // no danger of overwriting eflags, don't reorder
-	// check if we can move the CR setter instruction to after unsafeInstructionIndex
-	PPCRecCRTracking_t crTrackingSetter = crTracking;
-	PPCImlOptimizerUsedRegisters_t regTrackingCRSetter;
-	PPCRecompiler_checkRegisterUsage(NULL, imlSegment->imlList+crSetterInstructionIndex, &regTrackingCRSetter);
-	if (regTrackingCRSetter.writtenFPR1 >= 0 || regTrackingCRSetter.readFPR1 >= 0 || regTrackingCRSetter.readFPR2 >= 0 || regTrackingCRSetter.readFPR3 >= 0 || regTrackingCRSetter.readFPR4 >= 0)
-		return; // we don't handle FPR dependency yet so just ignore FPR instructions
-	PPCImlOptimizerUsedRegisters_t registerTracking;
-	if (regTrackingCRSetter.writtenNamedReg1 >= 0)
-	{
-		// CR setter does write GPR
-		for (sint32 i = crSetterInstructionIndex + 1; i <= unsafeInstructionIndex; i++)
-		{
-			PPCRecompiler_checkRegisterUsage(NULL, imlSegment->imlList + i, &registerTracking);
-			// reads register written by CR setter?
-			if (PPCRecompilerAnalyzer_checkForGPROverwrite(&registerTracking, &regTrackingCRSetter))
-			{
-				return; // cant move CR setter because of dependency
-			}
-			// writes register read by CR setter?
-			if (PPCRecompilerAnalyzer_checkForGPROverwrite(&regTrackingCRSetter, &registerTracking))
-			{
-				return; // cant move CR setter because of dependency
-			}
-			// overwrites register written by CR setter?
-			if (regTrackingCRSetter.writtenNamedReg1 == registerTracking.writtenNamedReg1)
-				return;
-		}
-	}
-	else
-	{
-		// CR setter does not write GPR
-		for (sint32 i = crSetterInstructionIndex + 1; i <= unsafeInstructionIndex; i++)
-		{
-			PPCRecompiler_checkRegisterUsage(NULL, imlSegment->imlList + i, &registerTracking);
-			// writes register read by CR setter?
-			if (PPCRecompilerAnalyzer_checkForGPROverwrite(&regTrackingCRSetter, &registerTracking))
-			{
-				return; // cant move CR setter because of dependency
-			}
-		}
-	}
-
-	// move CR setter instruction
-#ifndef PUBLIC_RELEASE
-	if ((unsafeInstructionIndex + 1) <= crSetterInstructionIndex)
-		assert_dbg();
-#endif
-	PPCRecImlInstruction_t* newCRSetterInstruction = PPCRecompiler_insertInstruction(imlSegment, unsafeInstructionIndex+1);
-	memcpy(newCRSetterInstruction, imlSegment->imlList + crSetterInstructionIndex, sizeof(PPCRecImlInstruction_t));
-	PPCRecompilerImlGen_generateNewInstruction_noOp(NULL, imlSegment->imlList + crSetterInstructionIndex);
-}
-
-/*
- * Move instructions which update the condition flags closer to the instruction that consumes them
- * On x64 this improves performance since we often can avoid storing CR in memory
- */
-void PPCRecompiler_reorderConditionModifyInstructions(ppcImlGenContext_t* ppcImlGenContext)
-{
-	// check if this segment has a conditional branch
-	for (sint32 s = 0; s < ppcImlGenContext->segmentListCount; s++)
-	{
-		PPCRecImlSegment_t* imlSegment = ppcImlGenContext->segmentList[s];
-		_reorderConditionModifyInstructions(imlSegment);
-	}
-}
diff --git a/src/Cafe/HW/Espresso/Recompiler/PPCRecompilerImlRanges.cpp b/src/Cafe/HW/Espresso/Recompiler/PPCRecompilerImlRanges.cpp
deleted file mode 100644
index f6370d8c..00000000
--- a/src/Cafe/HW/Espresso/Recompiler/PPCRecompilerImlRanges.cpp
+++ /dev/null
@@ -1,399 +0,0 @@
-#include "PPCRecompiler.h"
-#include "PPCRecompilerIml.h"
-#include "PPCRecompilerX64.h"
-#include "PPCRecompilerImlRanges.h"
-#include "util/helpers/MemoryPool.h"
-
-void PPCRecRARange_addLink_perVirtualGPR(raLivenessSubrange_t** root, raLivenessSubrange_t* subrange)
-{
-#ifndef PUBLIC_RELEASE
-	if ((*root) && (*root)->range->virtualRegister != subrange->range->virtualRegister)
-		assert_dbg();
-#endif
-	subrange->link_sameVirtualRegisterGPR.next = *root;
-	if (*root)
-		(*root)->link_sameVirtualRegisterGPR.prev = subrange;
-	subrange->link_sameVirtualRegisterGPR.prev = nullptr;
-	*root = subrange;
-}
-
-void PPCRecRARange_addLink_allSubrangesGPR(raLivenessSubrange_t** root, raLivenessSubrange_t* subrange)
-{
-	subrange->link_segmentSubrangesGPR.next = *root;
-	if (*root)
-		(*root)->link_segmentSubrangesGPR.prev = subrange;
-	subrange->link_segmentSubrangesGPR.prev = nullptr;
-	*root = subrange;
-}
-
-void PPCRecRARange_removeLink_perVirtualGPR(raLivenessSubrange_t** root, raLivenessSubrange_t* subrange)
-{
-	raLivenessSubrange_t* tempPrev = subrange->link_sameVirtualRegisterGPR.prev;
-	if (subrange->link_sameVirtualRegisterGPR.prev)
-		subrange->link_sameVirtualRegisterGPR.prev->link_sameVirtualRegisterGPR.next = subrange->link_sameVirtualRegisterGPR.next;
-	else
-		(*root) = subrange->link_sameVirtualRegisterGPR.next;
-	if (subrange->link_sameVirtualRegisterGPR.next)
-		subrange->link_sameVirtualRegisterGPR.next->link_sameVirtualRegisterGPR.prev = tempPrev;
-#ifndef PUBLIC_RELEASE
-	subrange->link_sameVirtualRegisterGPR.prev = (raLivenessSubrange_t*)1;
-	subrange->link_sameVirtualRegisterGPR.next = (raLivenessSubrange_t*)1;
-#endif
-}
-
-void PPCRecRARange_removeLink_allSubrangesGPR(raLivenessSubrange_t** root, raLivenessSubrange_t* subrange)
-{
-	raLivenessSubrange_t* tempPrev = subrange->link_segmentSubrangesGPR.prev;
-	if (subrange->link_segmentSubrangesGPR.prev)
-		subrange->link_segmentSubrangesGPR.prev->link_segmentSubrangesGPR.next = subrange->link_segmentSubrangesGPR.next;
-	else
-		(*root) = subrange->link_segmentSubrangesGPR.next;
-	if (subrange->link_segmentSubrangesGPR.next)
-		subrange->link_segmentSubrangesGPR.next->link_segmentSubrangesGPR.prev = tempPrev;
-#ifndef PUBLIC_RELEASE
-	subrange->link_segmentSubrangesGPR.prev = (raLivenessSubrange_t*)1;
-	subrange->link_segmentSubrangesGPR.next = (raLivenessSubrange_t*)1;
-#endif
-}
-
-MemoryPoolPermanentObjects<raLivenessRange_t> memPool_livenessRange(4096);
-MemoryPoolPermanentObjects<raLivenessSubrange_t> memPool_livenessSubrange(4096);
-
-raLivenessRange_t* PPCRecRA_createRangeBase(ppcImlGenContext_t* ppcImlGenContext, uint32 virtualRegister, uint32 name)
-{
-	raLivenessRange_t* livenessRange = memPool_livenessRange.acquireObj();
-	livenessRange->list_subranges.resize(0);
-	livenessRange->virtualRegister = virtualRegister;
-	livenessRange->name = name;
-	livenessRange->physicalRegister = -1;
-	ppcImlGenContext->raInfo.list_ranges.push_back(livenessRange);
-	return livenessRange;
-}
-
-raLivenessSubrange_t* PPCRecRA_createSubrange(ppcImlGenContext_t* ppcImlGenContext, raLivenessRange_t* range, PPCRecImlSegment_t* imlSegment, sint32 startIndex, sint32 endIndex)
-{
-	raLivenessSubrange_t* livenessSubrange = memPool_livenessSubrange.acquireObj();
-	livenessSubrange->list_locations.resize(0);
-	livenessSubrange->range = range;
-	livenessSubrange->imlSegment = imlSegment;
-	PPCRecompilerIml_setSegmentPoint(&livenessSubrange->start, imlSegment, startIndex);
-	PPCRecompilerIml_setSegmentPoint(&livenessSubrange->end, imlSegment, endIndex);
-	// default values
-	livenessSubrange->hasStore = false;
-	livenessSubrange->hasStoreDelayed = false;
-	livenessSubrange->lastIterationIndex = 0;
-	livenessSubrange->subrangeBranchNotTaken = nullptr;
-	livenessSubrange->subrangeBranchTaken = nullptr;
-	livenessSubrange->_noLoad = false;
-	// add to range
-	range->list_subranges.push_back(livenessSubrange);
-	// add to segment
-	PPCRecRARange_addLink_perVirtualGPR(&(imlSegment->raInfo.linkedList_perVirtualGPR[range->virtualRegister]), livenessSubrange);
-	PPCRecRARange_addLink_allSubrangesGPR(&imlSegment->raInfo.linkedList_allSubranges, livenessSubrange);
-	return livenessSubrange;
-}
-
-void _unlinkSubrange(raLivenessSubrange_t* subrange)
-{
-	PPCRecImlSegment_t* imlSegment = subrange->imlSegment;
-	PPCRecRARange_removeLink_perVirtualGPR(&imlSegment->raInfo.linkedList_perVirtualGPR[subrange->range->virtualRegister], subrange);
-	PPCRecRARange_removeLink_allSubrangesGPR(&imlSegment->raInfo.linkedList_allSubranges, subrange);
-}
-
-void PPCRecRA_deleteSubrange(ppcImlGenContext_t* ppcImlGenContext, raLivenessSubrange_t* subrange)
-{
-	_unlinkSubrange(subrange);
-	subrange->range->list_subranges.erase(std::find(subrange->range->list_subranges.begin(), subrange->range->list_subranges.end(), subrange));
-	subrange->list_locations.clear();
-	PPCRecompilerIml_removeSegmentPoint(&subrange->start);
-	PPCRecompilerIml_removeSegmentPoint(&subrange->end);
-	memPool_livenessSubrange.releaseObj(subrange);
-}
-
-void _PPCRecRA_deleteSubrangeNoUnlinkFromRange(ppcImlGenContext_t* ppcImlGenContext, raLivenessSubrange_t* subrange)
-{
-	_unlinkSubrange(subrange);
-	PPCRecompilerIml_removeSegmentPoint(&subrange->start);
-	PPCRecompilerIml_removeSegmentPoint(&subrange->end);
-	memPool_livenessSubrange.releaseObj(subrange);
-}
-
-void PPCRecRA_deleteRange(ppcImlGenContext_t* ppcImlGenContext, raLivenessRange_t* range)
-{
-	for (auto& subrange : range->list_subranges)
-	{
-		_PPCRecRA_deleteSubrangeNoUnlinkFromRange(ppcImlGenContext, subrange);
-	}
-	ppcImlGenContext->raInfo.list_ranges.erase(std::find(ppcImlGenContext->raInfo.list_ranges.begin(), ppcImlGenContext->raInfo.list_ranges.end(), range));
-	memPool_livenessRange.releaseObj(range);
-}
-
-void PPCRecRA_deleteRangeNoUnlink(ppcImlGenContext_t* ppcImlGenContext, raLivenessRange_t* range)
-{
-	for (auto& subrange : range->list_subranges)
-	{
-		_PPCRecRA_deleteSubrangeNoUnlinkFromRange(ppcImlGenContext, subrange);
-	}
-	memPool_livenessRange.releaseObj(range);
-}
-
-void PPCRecRA_deleteAllRanges(ppcImlGenContext_t* ppcImlGenContext)
-{
-	for(auto& range : ppcImlGenContext->raInfo.list_ranges)
-	{
-		PPCRecRA_deleteRangeNoUnlink(ppcImlGenContext, range);
-	}
-	ppcImlGenContext->raInfo.list_ranges.clear();
-}
-
-void PPCRecRA_mergeRanges(ppcImlGenContext_t* ppcImlGenContext, raLivenessRange_t* range, raLivenessRange_t* absorbedRange)
-{
-	cemu_assert_debug(range != absorbedRange);
-	cemu_assert_debug(range->virtualRegister == absorbedRange->virtualRegister);
-	// move all subranges from absorbedRange to range
-	for (auto& subrange : absorbedRange->list_subranges)
-	{
-		range->list_subranges.push_back(subrange);
-		subrange->range = range;
-	}
-	absorbedRange->list_subranges.clear();
-	PPCRecRA_deleteRange(ppcImlGenContext, absorbedRange);
-}
-
-void PPCRecRA_mergeSubranges(ppcImlGenContext_t* ppcImlGenContext, raLivenessSubrange_t* subrange, raLivenessSubrange_t* absorbedSubrange)
-{
-#ifndef PUBLIC_RELEASE
-	PPCRecRA_debugValidateSubrange(subrange);
-	PPCRecRA_debugValidateSubrange(absorbedSubrange);
-	if (subrange->imlSegment != absorbedSubrange->imlSegment)
-		assert_dbg();
-	if (subrange->end.index > absorbedSubrange->start.index)
-		assert_dbg();
-	if (subrange->subrangeBranchTaken || subrange->subrangeBranchNotTaken)
-		assert_dbg();
-	if (subrange == absorbedSubrange)
-		assert_dbg();
-#endif
-	subrange->subrangeBranchTaken = absorbedSubrange->subrangeBranchTaken;
-	subrange->subrangeBranchNotTaken = absorbedSubrange->subrangeBranchNotTaken;
-
-	// merge usage locations
-	for (auto& location : absorbedSubrange->list_locations)
-	{
-		subrange->list_locations.push_back(location);
-	}
-	absorbedSubrange->list_locations.clear();
-
-	subrange->end.index = absorbedSubrange->end.index;
-
-	PPCRecRA_debugValidateSubrange(subrange);
-
-	PPCRecRA_deleteSubrange(ppcImlGenContext, absorbedSubrange);
-}
-
-// remove all inter-segment connections from the range and split it into local ranges (also removes empty ranges)
-void PPCRecRA_explodeRange(ppcImlGenContext_t* ppcImlGenContext, raLivenessRange_t* range)
-{
-	if (range->list_subranges.size() == 1)
-		assert_dbg();
-	for (auto& subrange : range->list_subranges)
-	{
-		if (subrange->list_locations.empty())
-			continue;
-		raLivenessRange_t* newRange = PPCRecRA_createRangeBase(ppcImlGenContext, range->virtualRegister, range->name);
-		raLivenessSubrange_t* newSubrange = PPCRecRA_createSubrange(ppcImlGenContext, newRange, subrange->imlSegment, subrange->list_locations.data()[0].index, subrange->list_locations.data()[subrange->list_locations.size() - 1].index + 1);
-		// copy locations
-		for (auto& location : subrange->list_locations)
-		{
-			newSubrange->list_locations.push_back(location);
-		}
-	}
-	// remove original range
-	PPCRecRA_deleteRange(ppcImlGenContext, range);
-}
-
-#ifndef PUBLIC_RELEASE
-void PPCRecRA_debugValidateSubrange(raLivenessSubrange_t* subrange)
-{
-	// validate subrange
-	if (subrange->subrangeBranchTaken && subrange->subrangeBranchTaken->imlSegment != subrange->imlSegment->nextSegmentBranchTaken)
-		assert_dbg();
-	if (subrange->subrangeBranchNotTaken && subrange->subrangeBranchNotTaken->imlSegment != subrange->imlSegment->nextSegmentBranchNotTaken)
-		assert_dbg();
-}
-#else
-void PPCRecRA_debugValidateSubrange(raLivenessSubrange_t* subrange) {}
-#endif
-
-// split subrange at the given index
-// After the split there will be two ranges/subranges:
-// head -> subrange is shortned to end at splitIndex
-// tail -> a new subrange that reaches from splitIndex to the end of the original subrange
-// if head has a physical register assigned it will not carry over to tail
-// The return value is the tail subrange
-// If trimToHole is true, the end of the head subrange and the start of the tail subrange will be moved to fit the locations
-// Ranges that begin at RA_INTER_RANGE_START are allowed and can be split
-raLivenessSubrange_t* PPCRecRA_splitLocalSubrange(ppcImlGenContext_t* ppcImlGenContext, raLivenessSubrange_t* subrange, sint32 splitIndex, bool trimToHole)
-{
-	// validation
-#ifndef PUBLIC_RELEASE
-	if (subrange->end.index == RA_INTER_RANGE_END || subrange->end.index == RA_INTER_RANGE_START)
-		assert_dbg();
-	if (subrange->start.index >= splitIndex)
-		assert_dbg();
-	if (subrange->end.index <= splitIndex)
-		assert_dbg();
-#endif
-	// create tail
-	raLivenessRange_t* tailRange = PPCRecRA_createRangeBase(ppcImlGenContext, subrange->range->virtualRegister, subrange->range->name);
-	raLivenessSubrange_t* tailSubrange = PPCRecRA_createSubrange(ppcImlGenContext, tailRange, subrange->imlSegment, splitIndex, subrange->end.index);
-	// copy locations
-	for (auto& location : subrange->list_locations)
-	{
-		if (location.index >= splitIndex)
-			tailSubrange->list_locations.push_back(location);
-	}
-	// remove tail locations from head
-	for (sint32 i = 0; i < subrange->list_locations.size(); i++)
-	{
-		raLivenessLocation_t* location = subrange->list_locations.data() + i;
-		if (location->index >= splitIndex)
-		{
-			subrange->list_locations.resize(i);
-			break;
-		}
-	}
-	// adjust start/end
-	if (trimToHole)
-	{
-		if (subrange->list_locations.empty())
-		{
-			subrange->end.index = subrange->start.index+1;
-		}
-		else
-		{
-			subrange->end.index = subrange->list_locations.back().index + 1;
-		}
-		if (tailSubrange->list_locations.empty())
-		{
-			assert_dbg(); // should not happen? (In this case we can just avoid generating a tail at all)
-		}
-		else
-		{
-			tailSubrange->start.index = tailSubrange->list_locations.front().index;
-		}
-	}
-	return tailSubrange;
-}
-
-void PPCRecRA_updateOrAddSubrangeLocation(raLivenessSubrange_t* subrange, sint32 index, bool isRead, bool isWrite)
-{
-	if (subrange->list_locations.empty())
-	{
-		subrange->list_locations.emplace_back(index, isRead, isWrite);
-		return;
-	}
-	raLivenessLocation_t* lastLocation = subrange->list_locations.data() + (subrange->list_locations.size() - 1);
-	cemu_assert_debug(lastLocation->index <= index);
-	if (lastLocation->index == index)
-	{
-		// update
-		lastLocation->isRead = lastLocation->isRead || isRead;
-		lastLocation->isWrite = lastLocation->isWrite || isWrite;
-		return;
-	}
-	// add new
-	subrange->list_locations.emplace_back(index, isRead, isWrite);
-}
-
-sint32 PPCRecRARange_getReadWriteCost(PPCRecImlSegment_t* imlSegment)
-{
-	sint32 v = imlSegment->loopDepth + 1;
-	v *= 5;
-	return v*v; // 25, 100, 225, 400
-}
-
-// calculate cost of entire range
-// ignores data flow and does not detect avoidable reads/stores
-sint32 PPCRecRARange_estimateCost(raLivenessRange_t* range)
-{
-	sint32 cost = 0;
-
-	// todo - this algorithm isn't accurate. If we have 10 parallel branches with a load each then the actual cost is still only that of one branch (plus minimal extra cost for generating more code). 
-
-	// currently we calculate the cost based on the most expensive entry/exit point
-
-	sint32 mostExpensiveRead = 0;
-	sint32 mostExpensiveWrite = 0;
-	sint32 readCount = 0;
-	sint32 writeCount = 0;
-
-	for (auto& subrange : range->list_subranges)
-	{
-		if (subrange->start.index != RA_INTER_RANGE_START)
-		{
-			//cost += PPCRecRARange_getReadWriteCost(subrange->imlSegment);
-			mostExpensiveRead = std::max(mostExpensiveRead, PPCRecRARange_getReadWriteCost(subrange->imlSegment));
-			readCount++;
-		}
-		if (subrange->end.index != RA_INTER_RANGE_END)
-		{
-			//cost += PPCRecRARange_getReadWriteCost(subrange->imlSegment);
-			mostExpensiveWrite = std::max(mostExpensiveWrite, PPCRecRARange_getReadWriteCost(subrange->imlSegment));
-			writeCount++;
-		}
-	}
-	cost = mostExpensiveRead + mostExpensiveWrite;
-	cost = cost + (readCount + writeCount) / 10;
-	return cost;
-}
-
-// calculate cost of range that it would have after calling PPCRecRA_explodeRange() on it
-sint32 PPCRecRARange_estimateAdditionalCostAfterRangeExplode(raLivenessRange_t* range)
-{
-	sint32 cost = -PPCRecRARange_estimateCost(range);
-	for (auto& subrange : range->list_subranges)
-	{
-		if (subrange->list_locations.empty())
-			continue;
-		cost += PPCRecRARange_getReadWriteCost(subrange->imlSegment) * 2; // we assume a read and a store
-	}
-	return cost;
-}
-
-sint32 PPCRecRARange_estimateAdditionalCostAfterSplit(raLivenessSubrange_t* subrange, sint32 splitIndex)
-{
-	// validation
-#ifndef PUBLIC_RELEASE
-	if (subrange->end.index == RA_INTER_RANGE_END)
-		assert_dbg();
-#endif
-
-	sint32 cost = 0;
-	// find split position in location list
-	if (subrange->list_locations.empty())
-	{
-		assert_dbg(); // should not happen?
-		return 0;
-	}
-	if (splitIndex <= subrange->list_locations.front().index)
-		return 0;
-	if (splitIndex > subrange->list_locations.back().index)
-		return 0;
-
-	// todo - determine exact cost of split subranges
-
-	cost += PPCRecRARange_getReadWriteCost(subrange->imlSegment) * 2; // currently we assume that the additional region will require a read and a store
-
-	//for (sint32 f = 0; f < subrange->list_locations.size(); f++)
-	//{
-	//	raLivenessLocation_t* location = subrange->list_locations.data() + f;
-	//	if (location->index >= splitIndex)
-	//	{
-	//		...
-	//		return cost;
-	//	}
-	//}
-
-	return cost;
-}
diff --git a/src/Cafe/HW/Espresso/Recompiler/PPCRecompilerImlRanges.h b/src/Cafe/HW/Espresso/Recompiler/PPCRecompilerImlRanges.h
deleted file mode 100644
index 01970bbf..00000000
--- a/src/Cafe/HW/Espresso/Recompiler/PPCRecompilerImlRanges.h
+++ /dev/null
@@ -1,27 +0,0 @@
-#pragma once
-
-raLivenessRange_t* PPCRecRA_createRangeBase(ppcImlGenContext_t* ppcImlGenContext, uint32 virtualRegister, uint32 name);
-raLivenessSubrange_t* PPCRecRA_createSubrange(ppcImlGenContext_t* ppcImlGenContext, raLivenessRange_t* range, PPCRecImlSegment_t* imlSegment, sint32 startIndex, sint32 endIndex);
-void PPCRecRA_deleteSubrange(ppcImlGenContext_t* ppcImlGenContext, raLivenessSubrange_t* subrange);
-void PPCRecRA_deleteRange(ppcImlGenContext_t* ppcImlGenContext, raLivenessRange_t* range);
-void PPCRecRA_deleteAllRanges(ppcImlGenContext_t* ppcImlGenContext);
-
-void PPCRecRA_mergeRanges(ppcImlGenContext_t* ppcImlGenContext, raLivenessRange_t* range, raLivenessRange_t* absorbedRange);
-void PPCRecRA_explodeRange(ppcImlGenContext_t* ppcImlGenContext, raLivenessRange_t* range);
-
-void PPCRecRA_mergeSubranges(ppcImlGenContext_t* ppcImlGenContext, raLivenessSubrange_t* subrange, raLivenessSubrange_t* absorbedSubrange);
-
-raLivenessSubrange_t* PPCRecRA_splitLocalSubrange(ppcImlGenContext_t* ppcImlGenContext, raLivenessSubrange_t* subrange, sint32 splitIndex, bool trimToHole = false);
-
-void PPCRecRA_updateOrAddSubrangeLocation(raLivenessSubrange_t* subrange, sint32 index, bool isRead, bool isWrite);
-void PPCRecRA_debugValidateSubrange(raLivenessSubrange_t* subrange);
-
-// cost estimation
-sint32 PPCRecRARange_getReadWriteCost(PPCRecImlSegment_t* imlSegment);
-sint32 PPCRecRARange_estimateCost(raLivenessRange_t* range);
-sint32 PPCRecRARange_estimateAdditionalCostAfterRangeExplode(raLivenessRange_t* range);
-sint32 PPCRecRARange_estimateAdditionalCostAfterSplit(raLivenessSubrange_t* subrange, sint32 splitIndex);
-
-// special values to mark the index of ranges that reach across the segment border
-#define RA_INTER_RANGE_START	(-1)
-#define RA_INTER_RANGE_END		(0x70000000)
diff --git a/src/Cafe/HW/Espresso/Recompiler/PPCRecompilerImlRegisterAllocator.cpp b/src/Cafe/HW/Espresso/Recompiler/PPCRecompilerImlRegisterAllocator.cpp
deleted file mode 100644
index 92fbd9b0..00000000
--- a/src/Cafe/HW/Espresso/Recompiler/PPCRecompilerImlRegisterAllocator.cpp
+++ /dev/null
@@ -1,1012 +0,0 @@
-#include "PPCRecompiler.h"
-#include "PPCRecompilerIml.h"
-#include "PPCRecompilerX64.h"
-#include "PPCRecompilerImlRanges.h"
-
-void PPCRecompiler_replaceGPRRegisterUsageMultiple(ppcImlGenContext_t* ppcImlGenContext, PPCRecImlInstruction_t* imlInstruction, sint32 gprRegisterSearched[4], sint32 gprRegisterReplaced[4]);
-
-bool PPCRecompiler_isSuffixInstruction(PPCRecImlInstruction_t* iml);
-
-uint32 recRACurrentIterationIndex = 0;
-
-uint32 PPCRecRA_getNextIterationIndex()
-{
-	recRACurrentIterationIndex++;
-	return recRACurrentIterationIndex;
-}
-
-bool _detectLoop(PPCRecImlSegment_t* currentSegment, sint32 depth, uint32 iterationIndex, PPCRecImlSegment_t* imlSegmentLoopBase)
-{
-	if (currentSegment == imlSegmentLoopBase)
-		return true;
-	if (currentSegment->raInfo.lastIterationIndex == iterationIndex)
-		return currentSegment->raInfo.isPartOfProcessedLoop;
-	if (depth >= 9)
-		return false;
-	currentSegment->raInfo.lastIterationIndex = iterationIndex;
-	currentSegment->raInfo.isPartOfProcessedLoop = false;
-	
-	if (currentSegment->nextSegmentIsUncertain)
-		return false;
-	if (currentSegment->nextSegmentBranchNotTaken)
-	{
-		if (currentSegment->nextSegmentBranchNotTaken->momentaryIndex > currentSegment->momentaryIndex)
-		{
-			currentSegment->raInfo.isPartOfProcessedLoop = _detectLoop(currentSegment->nextSegmentBranchNotTaken, depth + 1, iterationIndex, imlSegmentLoopBase);
-		}
-	}
-	if (currentSegment->nextSegmentBranchTaken)
-	{
-		if (currentSegment->nextSegmentBranchTaken->momentaryIndex > currentSegment->momentaryIndex)
-		{
-			currentSegment->raInfo.isPartOfProcessedLoop = _detectLoop(currentSegment->nextSegmentBranchTaken, depth + 1, iterationIndex, imlSegmentLoopBase);
-		}
-	}
-	if (currentSegment->raInfo.isPartOfProcessedLoop)
-		currentSegment->loopDepth++;
-	return currentSegment->raInfo.isPartOfProcessedLoop;
-}
-
-void PPCRecRA_detectLoop(ppcImlGenContext_t* ppcImlGenContext, PPCRecImlSegment_t* imlSegmentLoopBase)
-{
-	uint32 iterationIndex = PPCRecRA_getNextIterationIndex();
-	imlSegmentLoopBase->raInfo.lastIterationIndex = iterationIndex;
-	if (_detectLoop(imlSegmentLoopBase->nextSegmentBranchTaken, 0, iterationIndex, imlSegmentLoopBase))
-	{
-		imlSegmentLoopBase->loopDepth++;
-	}
-}
-
-void PPCRecRA_identifyLoop(ppcImlGenContext_t* ppcImlGenContext, PPCRecImlSegment_t* imlSegment)
-{
-	if (imlSegment->nextSegmentIsUncertain)
-		return;
-	// check if this segment has a branch that links to itself (tight loop)
-	if (imlSegment->nextSegmentBranchTaken == imlSegment)
-	{
-		// segment loops over itself
-		imlSegment->loopDepth++;
-		return;
-	}
-	// check if this segment has a branch that goes backwards (potential complex loop)
-	if (imlSegment->nextSegmentBranchTaken && imlSegment->nextSegmentBranchTaken->momentaryIndex < imlSegment->momentaryIndex)
-	{
-		PPCRecRA_detectLoop(ppcImlGenContext, imlSegment);
-	}
-}
-
-typedef struct
-{
-	sint32 name;
-	sint32 virtualRegister;
-	sint32 physicalRegister;
-	bool isDirty;
-}raRegisterState_t;
-
-const sint32 _raInfo_physicalGPRCount = PPC_X64_GPR_USABLE_REGISTERS;
-
-raRegisterState_t* PPCRecRA_getRegisterState(raRegisterState_t* regState, sint32 virtualRegister)
-{
-	for (sint32 i = 0; i < _raInfo_physicalGPRCount; i++)
-	{
-		if (regState[i].virtualRegister == virtualRegister)
-		{
-#ifndef PUBLIC_RELEASE
-			if (regState[i].physicalRegister < 0)
-				assert_dbg();
-#endif
-			return regState + i;
-		}
-	}
-	return nullptr;
-}
-
-raRegisterState_t* PPCRecRA_getFreePhysicalRegister(raRegisterState_t* regState)
-{
-	for (sint32 i = 0; i < _raInfo_physicalGPRCount; i++)
-	{
-		if (regState[i].physicalRegister < 0)
-		{
-			regState[i].physicalRegister = i;
-			return regState + i;
-		}
-	}
-	return nullptr;
-}
-
-typedef struct
-{
-	uint16 registerIndex;
-	uint16 registerName;
-}raLoadStoreInfo_t;
-
-void PPCRecRA_insertGPRLoadInstruction(PPCRecImlSegment_t* imlSegment, sint32 insertIndex, sint32 registerIndex, sint32 registerName)
-{
-	PPCRecompiler_pushBackIMLInstructions(imlSegment, insertIndex, 1);
-	PPCRecImlInstruction_t* imlInstructionItr = imlSegment->imlList + (insertIndex + 0);
-	memset(imlInstructionItr, 0x00, sizeof(PPCRecImlInstruction_t));
-	imlInstructionItr->type = PPCREC_IML_TYPE_R_NAME;
-	imlInstructionItr->operation = PPCREC_IML_OP_ASSIGN;
-	imlInstructionItr->op_r_name.registerIndex = registerIndex;
-	imlInstructionItr->op_r_name.name = registerName;
-	imlInstructionItr->op_r_name.copyWidth = 32;
-	imlInstructionItr->op_r_name.flags = 0;
-}
-
-void PPCRecRA_insertGPRLoadInstructions(PPCRecImlSegment_t* imlSegment, sint32 insertIndex, raLoadStoreInfo_t* loadList, sint32 loadCount)
-{
-	PPCRecompiler_pushBackIMLInstructions(imlSegment, insertIndex, loadCount);
-	memset(imlSegment->imlList + (insertIndex + 0), 0x00, sizeof(PPCRecImlInstruction_t)*loadCount);
-	for (sint32 i = 0; i < loadCount; i++)
-	{
-		PPCRecImlInstruction_t* imlInstructionItr = imlSegment->imlList + (insertIndex + i);
-		imlInstructionItr->type = PPCREC_IML_TYPE_R_NAME;
-		imlInstructionItr->operation = PPCREC_IML_OP_ASSIGN;
-		imlInstructionItr->op_r_name.registerIndex = (uint8)loadList[i].registerIndex;
-		imlInstructionItr->op_r_name.name = (uint32)loadList[i].registerName;
-		imlInstructionItr->op_r_name.copyWidth = 32;
-		imlInstructionItr->op_r_name.flags = 0;
-	}
-}
-
-void PPCRecRA_insertGPRStoreInstruction(PPCRecImlSegment_t* imlSegment, sint32 insertIndex, sint32 registerIndex, sint32 registerName)
-{
-	PPCRecompiler_pushBackIMLInstructions(imlSegment, insertIndex, 1);
-	PPCRecImlInstruction_t* imlInstructionItr = imlSegment->imlList + (insertIndex + 0);
-	memset(imlInstructionItr, 0x00, sizeof(PPCRecImlInstruction_t));
-	imlInstructionItr->type = PPCREC_IML_TYPE_NAME_R;
-	imlInstructionItr->operation = PPCREC_IML_OP_ASSIGN;
-	imlInstructionItr->op_r_name.registerIndex = registerIndex;
-	imlInstructionItr->op_r_name.name = registerName;
-	imlInstructionItr->op_r_name.copyWidth = 32;
-	imlInstructionItr->op_r_name.flags = 0;
-}
-
-void PPCRecRA_insertGPRStoreInstructions(PPCRecImlSegment_t* imlSegment, sint32 insertIndex, raLoadStoreInfo_t* storeList, sint32 storeCount)
-{
-	PPCRecompiler_pushBackIMLInstructions(imlSegment, insertIndex, storeCount);
-	memset(imlSegment->imlList + (insertIndex + 0), 0x00, sizeof(PPCRecImlInstruction_t)*storeCount);
-	for (sint32 i = 0; i < storeCount; i++)
-	{
-		PPCRecImlInstruction_t* imlInstructionItr = imlSegment->imlList + (insertIndex + i);
-		memset(imlInstructionItr, 0x00, sizeof(PPCRecImlInstruction_t));
-		imlInstructionItr->type = PPCREC_IML_TYPE_NAME_R;
-		imlInstructionItr->operation = PPCREC_IML_OP_ASSIGN;
-		imlInstructionItr->op_r_name.registerIndex = (uint8)storeList[i].registerIndex;
-		imlInstructionItr->op_r_name.name = (uint32)storeList[i].registerName;
-		imlInstructionItr->op_r_name.copyWidth = 32;
-		imlInstructionItr->op_r_name.flags = 0;
-	}
-}
-
-#define SUBRANGE_LIST_SIZE	(128)
-
-sint32 PPCRecRA_countInstructionsUntilNextUse(raLivenessSubrange_t* subrange, sint32 startIndex)
-{
-	for (sint32 i = 0; i < subrange->list_locations.size(); i++)
-	{
-		if (subrange->list_locations.data()[i].index >= startIndex)
-			return subrange->list_locations.data()[i].index - startIndex;
-	}
-	return INT_MAX;
-}
-
-// count how many instructions there are until physRegister is used by any subrange (returns 0 if register is in use at startIndex, and INT_MAX if not used for the remainder of the segment)
-sint32 PPCRecRA_countInstructionsUntilNextLocalPhysRegisterUse(PPCRecImlSegment_t* imlSegment, sint32 startIndex, sint32 physRegister)
-{
-	sint32 minDistance = INT_MAX;
-	// next
-	raLivenessSubrange_t* subrangeItr = imlSegment->raInfo.linkedList_allSubranges;
-	while(subrangeItr)
-	{
-		if (subrangeItr->range->physicalRegister != physRegister)
-		{
-			subrangeItr = subrangeItr->link_segmentSubrangesGPR.next;
-			continue;
-		}
-		if (startIndex >= subrangeItr->start.index && startIndex < subrangeItr->end.index)
-			return 0;
-		if (subrangeItr->start.index >= startIndex)
-		{
-			minDistance = std::min(minDistance, (subrangeItr->start.index - startIndex));
-		}
-		subrangeItr = subrangeItr->link_segmentSubrangesGPR.next;
-	}
-	return minDistance;
-}
-
-typedef struct  
-{
-	raLivenessSubrange_t* liveRangeList[64];
-	sint32 liveRangesCount;
-}raLiveRangeInfo_t;
-
-// return a bitmask that contains only registers that are not used by any colliding range
-uint32 PPCRecRA_getAllowedRegisterMaskForFullRange(raLivenessRange_t* range)
-{
-	uint32 physRegisterMask = (1 << PPC_X64_GPR_USABLE_REGISTERS) - 1;
-	for (auto& subrange : range->list_subranges)
-	{
-		PPCRecImlSegment_t* imlSegment = subrange->imlSegment;
-		raLivenessSubrange_t* subrangeItr = imlSegment->raInfo.linkedList_allSubranges;
-		while(subrangeItr)
-		{
-			if (subrange == subrangeItr)
-			{
-				// next
-				subrangeItr = subrangeItr->link_segmentSubrangesGPR.next;
-				continue;
-			}
-
-			if (subrange->start.index < subrangeItr->end.index && subrange->end.index > subrangeItr->start.index ||
-				(subrange->start.index == RA_INTER_RANGE_START && subrange->start.index == subrangeItr->start.index) ||
-				(subrange->end.index == RA_INTER_RANGE_END && subrange->end.index == subrangeItr->end.index) )
-			{
-				if(subrangeItr->range->physicalRegister >= 0)
-					physRegisterMask &= ~(1<<(subrangeItr->range->physicalRegister));
-			}
-			// next
-			subrangeItr = subrangeItr->link_segmentSubrangesGPR.next;
-		}
-	}
-	return physRegisterMask;
-}
-
-bool _livenessRangeStartCompare(raLivenessSubrange_t* lhs, raLivenessSubrange_t* rhs) { return lhs->start.index < rhs->start.index; }
-
-void _sortSegmentAllSubrangesLinkedList(PPCRecImlSegment_t* imlSegment)
-{
-	raLivenessSubrange_t* subrangeList[4096+1];
-	sint32 count = 0;
-	// disassemble linked list
-	raLivenessSubrange_t* subrangeItr = imlSegment->raInfo.linkedList_allSubranges;
-	while (subrangeItr)
-	{
-		if (count >= 4096)
-			assert_dbg();
-		subrangeList[count] = subrangeItr;
-		count++;
-		// next
-		subrangeItr = subrangeItr->link_segmentSubrangesGPR.next;
-	}
-	if (count == 0)
-	{
-		imlSegment->raInfo.linkedList_allSubranges = nullptr;
-		return;
-	}
-	// sort
-	std::sort(subrangeList, subrangeList + count, _livenessRangeStartCompare);
-	//for (sint32 i1 = 0; i1 < count; i1++)
-	//{
-	//	for (sint32 i2 = i1+1; i2 < count; i2++)
-	//	{
-	//		if (subrangeList[i1]->start.index > subrangeList[i2]->start.index)
-	//		{
-	//			// swap
-	//			raLivenessSubrange_t* temp = subrangeList[i1];
-	//			subrangeList[i1] = subrangeList[i2];
-	//			subrangeList[i2] = temp;
-	//		}
-	//	}
-	//}
-	// reassemble linked list
-	subrangeList[count] = nullptr;
-	imlSegment->raInfo.linkedList_allSubranges = subrangeList[0];
-	subrangeList[0]->link_segmentSubrangesGPR.prev = nullptr;
-	subrangeList[0]->link_segmentSubrangesGPR.next = subrangeList[1];
-	for (sint32 i = 1; i < count; i++)
-	{
-		subrangeList[i]->link_segmentSubrangesGPR.prev = subrangeList[i - 1];
-		subrangeList[i]->link_segmentSubrangesGPR.next = subrangeList[i + 1];
-	}
-	// validate list
-#ifndef PUBLIC_RELEASE
-	sint32 count2 = 0;
-	subrangeItr = imlSegment->raInfo.linkedList_allSubranges;
-	sint32 currentStartIndex = RA_INTER_RANGE_START;
-	while (subrangeItr)
-	{
-		count2++;
-		if (subrangeItr->start.index < currentStartIndex)
-			assert_dbg();
-		currentStartIndex = subrangeItr->start.index;
-		// next
-		subrangeItr = subrangeItr->link_segmentSubrangesGPR.next;
-	}
-	if (count != count2)
-		assert_dbg();
-#endif
-}
-
-bool PPCRecRA_assignSegmentRegisters(ppcImlGenContext_t* ppcImlGenContext, PPCRecImlSegment_t* imlSegment)
-{
-
-	// sort subranges ascending by start index
-
-	//std::sort(imlSegment->raInfo.list_subranges.begin(), imlSegment->raInfo.list_subranges.end(), _sortSubrangesByStartIndexDepr);
-	_sortSegmentAllSubrangesLinkedList(imlSegment);
-	
-	raLiveRangeInfo_t liveInfo;
-	liveInfo.liveRangesCount = 0;
-	//sint32 subrangeIndex = 0;
-	//for (auto& subrange : imlSegment->raInfo.list_subranges)
-	raLivenessSubrange_t* subrangeItr = imlSegment->raInfo.linkedList_allSubranges;
-	while(subrangeItr)
-	{
-		sint32 currentIndex = subrangeItr->start.index;
-		// validate subrange
-		PPCRecRA_debugValidateSubrange(subrangeItr);
-		// expire ranges
-		for (sint32 f = 0; f < liveInfo.liveRangesCount; f++)
-		{
-			raLivenessSubrange_t* liverange = liveInfo.liveRangeList[f];
-			if (liverange->end.index <= currentIndex && liverange->end.index != RA_INTER_RANGE_END)
-			{
-#ifndef PUBLIC_RELEASE
-				if (liverange->subrangeBranchTaken || liverange->subrangeBranchNotTaken)
-					assert_dbg(); // infinite subranges should not expire
-#endif
-				// remove entry
-				liveInfo.liveRangesCount--;
-				liveInfo.liveRangeList[f] = liveInfo.liveRangeList[liveInfo.liveRangesCount];
-				f--;
-			}
-		}
-		// check if subrange already has register assigned
-		if (subrangeItr->range->physicalRegister >= 0)
-		{
-			// verify if register is actually available
-#ifndef PUBLIC_RELEASE
-			for (sint32 f = 0; f < liveInfo.liveRangesCount; f++)
-			{
-				raLivenessSubrange_t* liverangeItr = liveInfo.liveRangeList[f];
-				if (liverangeItr->range->physicalRegister == subrangeItr->range->physicalRegister)
-				{
-					// this should never happen because we try to preventively avoid register conflicts
-					assert_dbg();				
-				}
-			}
-#endif
-			// add to live ranges
-			liveInfo.liveRangeList[liveInfo.liveRangesCount] = subrangeItr;
-			liveInfo.liveRangesCount++;
-			// next
-			subrangeItr = subrangeItr->link_segmentSubrangesGPR.next;
-			continue;
-		}
-		// find free register
-		uint32 physRegisterMask = (1<<PPC_X64_GPR_USABLE_REGISTERS)-1;
-		for (sint32 f = 0; f < liveInfo.liveRangesCount; f++)
-		{
-			raLivenessSubrange_t* liverange = liveInfo.liveRangeList[f];
-			if (liverange->range->physicalRegister < 0)
-				assert_dbg();
-			physRegisterMask &= ~(1<<liverange->range->physicalRegister);
-		}
-		// check intersections with other ranges and determine allowed registers
-		uint32 allowedPhysRegisterMask = 0;
-		uint32 unusedRegisterMask = physRegisterMask; // mask of registers that are currently not used (does not include range checks)
-		if (physRegisterMask != 0)
-		{
-			allowedPhysRegisterMask = PPCRecRA_getAllowedRegisterMaskForFullRange(subrangeItr->range);
-			physRegisterMask &= allowedPhysRegisterMask;
-		}
-		if (physRegisterMask == 0)
-		{
-			struct
-			{
-				// estimated costs and chosen candidates for the different spill strategies
-				// hole cutting into a local range
-				struct
-				{
-					sint32 distance;
-					raLivenessSubrange_t* largestHoleSubrange;
-					sint32 cost; // additional cost of choosing this candidate
-				}localRangeHoleCutting;
-				// split current range (this is generally only a good choice when the current range is long but rarely used)
-				struct
-				{
-					sint32 cost;
-					sint32 physRegister;
-					sint32 distance; // size of hole
-				}availableRegisterHole;
-				// explode a inter-segment range (prefer ranges that are not read/written in this segment)
-				struct
-				{
-					raLivenessRange_t* range;
-					sint32 cost;
-					sint32 distance; // size of hole
-					// note: If we explode a range, we still have to check the size of the hole that becomes available, if too small then we need to add cost of splitting local subrange
-				}explodeRange;
-				// todo - add more strategies, make cost estimation smarter (for example, in some cases splitting can have reduced or no cost if read/store can be avoided due to data flow)
-			}spillStrategies;
-			// cant assign register
-			// there might be registers available, we just can't use them due to range conflicts
-			if (subrangeItr->end.index != RA_INTER_RANGE_END)
-			{
-				// range ends in current segment
-
-				// Current algo looks like this:
-				// 1) Get the size of the largest possible hole that we can cut into any of the live local subranges
-				// 1.1) Check if the hole is large enough to hold the current subrange
-				// 2) If yes, cut hole and return false (full retry)
-				// 3) If no, try to reuse free register (need to determine how large the region is we can use)
-				// 4) If there is no free register or the range is extremely short go back to step 1+2 but additionally split the current subrange at where the hole ends
-
-				cemu_assert_debug(currentIndex == subrangeItr->start.index);
-
-				sint32 requiredSize = subrangeItr->end.index - subrangeItr->start.index;
-				// evaluate strategy: Cut hole into local subrange
-				spillStrategies.localRangeHoleCutting.distance = -1;
-				spillStrategies.localRangeHoleCutting.largestHoleSubrange = nullptr;
-				spillStrategies.localRangeHoleCutting.cost = INT_MAX;
-				if (currentIndex >= 0)
-				{
-					for (sint32 f = 0; f < liveInfo.liveRangesCount; f++)
-					{
-						raLivenessSubrange_t* candidate = liveInfo.liveRangeList[f];
-						if (candidate->end.index == RA_INTER_RANGE_END)
-							continue;
-						sint32 distance = PPCRecRA_countInstructionsUntilNextUse(candidate, currentIndex);
-						if (distance < 2)
-							continue; // not even worth the consideration
-									  // calculate split cost of candidate
-						sint32 cost = PPCRecRARange_estimateAdditionalCostAfterSplit(candidate, currentIndex + distance);
-						// calculate additional split cost of currentRange if hole is not large enough
-						if (distance < requiredSize)
-						{
-							cost += PPCRecRARange_estimateAdditionalCostAfterSplit(subrangeItr, currentIndex + distance);
-							// we also slightly increase cost in relation to the remaining length (in order to make the algorithm prefer larger holes)
-							cost += (requiredSize - distance) / 10;
-						}
-						// compare cost with previous candidates
-						if (cost < spillStrategies.localRangeHoleCutting.cost)
-						{
-							spillStrategies.localRangeHoleCutting.cost = cost;
-							spillStrategies.localRangeHoleCutting.distance = distance;
-							spillStrategies.localRangeHoleCutting.largestHoleSubrange = candidate;
-						}
-					}
-				}
-				// evaluate strategy: Split current range to fit in available holes
-				spillStrategies.availableRegisterHole.cost = INT_MAX;
-				spillStrategies.availableRegisterHole.distance = -1;
-				spillStrategies.availableRegisterHole.physRegister = -1;
-				if (currentIndex >= 0)
-				{
-					if (unusedRegisterMask != 0)
-					{
-						for (sint32 t = 0; t < PPC_X64_GPR_USABLE_REGISTERS; t++)
-						{
-							if ((unusedRegisterMask&(1 << t)) == 0)
-								continue;
-							// get size of potential hole for this register
-							sint32 distance = PPCRecRA_countInstructionsUntilNextLocalPhysRegisterUse(imlSegment, currentIndex, t);
-							if (distance < 2)
-								continue; // not worth consideration
-							// calculate additional cost due to split
-							if (distance >= requiredSize)
-								assert_dbg(); // should not happen or else we would have selected this register
-							sint32 cost = PPCRecRARange_estimateAdditionalCostAfterSplit(subrangeItr, currentIndex + distance);
-							// add small additional cost for the remaining range (prefer larger holes)
-							cost += (requiredSize - distance) / 10;
-							if (cost < spillStrategies.availableRegisterHole.cost)
-							{
-								spillStrategies.availableRegisterHole.cost = cost;
-								spillStrategies.availableRegisterHole.distance = distance;
-								spillStrategies.availableRegisterHole.physRegister = t;
-							}
-						}
-					}
-				}
-				// evaluate strategy: Explode inter-segment ranges
-				spillStrategies.explodeRange.cost = INT_MAX;
-				spillStrategies.explodeRange.range = nullptr;
-				spillStrategies.explodeRange.distance = -1;
-				for (sint32 f = 0; f < liveInfo.liveRangesCount; f++)
-				{
-					raLivenessSubrange_t* candidate = liveInfo.liveRangeList[f];
-					if (candidate->end.index != RA_INTER_RANGE_END)
-						continue;
-					sint32 distance = PPCRecRA_countInstructionsUntilNextUse(liveInfo.liveRangeList[f], currentIndex);
-					if( distance < 2)
-						continue;
-					sint32 cost;
-					cost = PPCRecRARange_estimateAdditionalCostAfterRangeExplode(candidate->range);
-					// if the hole is not large enough, add cost of splitting current subrange
-					if (distance < requiredSize)
-					{
-						cost += PPCRecRARange_estimateAdditionalCostAfterSplit(subrangeItr, currentIndex + distance);
-						// add small additional cost for the remaining range (prefer larger holes)
-						cost += (requiredSize - distance) / 10;
-					}
-					// compare with current best candidate for this strategy
-					if (cost < spillStrategies.explodeRange.cost)
-					{
-						spillStrategies.explodeRange.cost = cost;
-						spillStrategies.explodeRange.distance = distance;
-						spillStrategies.explodeRange.range = candidate->range;
-					}
-				}
-				// choose strategy
-				if (spillStrategies.explodeRange.cost != INT_MAX && spillStrategies.explodeRange.cost <= spillStrategies.localRangeHoleCutting.cost && spillStrategies.explodeRange.cost <= spillStrategies.availableRegisterHole.cost)
-				{
-					// explode range
-					PPCRecRA_explodeRange(ppcImlGenContext, spillStrategies.explodeRange.range);
-					// split current subrange if necessary
-					if( requiredSize > spillStrategies.explodeRange.distance)
-						PPCRecRA_splitLocalSubrange(ppcImlGenContext, subrangeItr, currentIndex+spillStrategies.explodeRange.distance, true);
-				}
-				else if (spillStrategies.availableRegisterHole.cost != INT_MAX && spillStrategies.availableRegisterHole.cost <= spillStrategies.explodeRange.cost && spillStrategies.availableRegisterHole.cost <= spillStrategies.localRangeHoleCutting.cost)
-				{
-					// use available register
-					PPCRecRA_splitLocalSubrange(ppcImlGenContext, subrangeItr, currentIndex + spillStrategies.availableRegisterHole.distance, true);
-				}
-				else if (spillStrategies.localRangeHoleCutting.cost != INT_MAX && spillStrategies.localRangeHoleCutting.cost <= spillStrategies.explodeRange.cost && spillStrategies.localRangeHoleCutting.cost <= spillStrategies.availableRegisterHole.cost)
-				{
-					// cut hole
-					PPCRecRA_splitLocalSubrange(ppcImlGenContext, spillStrategies.localRangeHoleCutting.largestHoleSubrange, currentIndex + spillStrategies.localRangeHoleCutting.distance, true);
-					// split current subrange if necessary
-					if (requiredSize > spillStrategies.localRangeHoleCutting.distance)
-						PPCRecRA_splitLocalSubrange(ppcImlGenContext, subrangeItr, currentIndex + spillStrategies.localRangeHoleCutting.distance, true);
-				}
-				else if (subrangeItr->start.index == RA_INTER_RANGE_START)
-				{
-					// alternative strategy if we have no other choice: explode current range
-					PPCRecRA_explodeRange(ppcImlGenContext, subrangeItr->range);
-				}
-				else
-					assert_dbg();
-
-				return false;
-			}
-			else
-			{
-				// range exceeds segment border
-				// simple but bad solution -> explode the entire range (no longer allow it to cross segment boundaries)
-				// better solutions: 1) Depending on the situation, we can explode other ranges to resolve the conflict. Thus we should explode the range with the lowest extra cost
-				//					 2) Or we explode the range only partially
-				// explode the range with the least cost
-				spillStrategies.explodeRange.cost = INT_MAX;
-				spillStrategies.explodeRange.range = nullptr;
-				spillStrategies.explodeRange.distance = -1;
-				for (sint32 f = 0; f < liveInfo.liveRangesCount; f++)
-				{
-					raLivenessSubrange_t* candidate = liveInfo.liveRangeList[f];
-					if (candidate->end.index != RA_INTER_RANGE_END)
-						continue;
-					// only select candidates that clash with current subrange
-					if (candidate->range->physicalRegister < 0 && candidate != subrangeItr)
-						continue;
-					
-					sint32 cost;
-					cost = PPCRecRARange_estimateAdditionalCostAfterRangeExplode(candidate->range);
-					// compare with current best candidate for this strategy
-					if (cost < spillStrategies.explodeRange.cost)
-					{
-						spillStrategies.explodeRange.cost = cost;
-						spillStrategies.explodeRange.distance = INT_MAX;
-						spillStrategies.explodeRange.range = candidate->range;
-					}
-				}
-				// add current range as a candidate too
-				sint32 ownCost;
-				ownCost = PPCRecRARange_estimateAdditionalCostAfterRangeExplode(subrangeItr->range);
-				if (ownCost < spillStrategies.explodeRange.cost)
-				{
-					spillStrategies.explodeRange.cost = ownCost;
-					spillStrategies.explodeRange.distance = INT_MAX;
-					spillStrategies.explodeRange.range = subrangeItr->range;
-				}
-				if (spillStrategies.explodeRange.cost == INT_MAX)
-					assert_dbg(); // should not happen
-				PPCRecRA_explodeRange(ppcImlGenContext, spillStrategies.explodeRange.range);
-			}
-			return false;
-		}
-		// assign register to range
-		sint32 registerIndex = -1;
-		for (sint32 f = 0; f < PPC_X64_GPR_USABLE_REGISTERS; f++)
-		{
-			if ((physRegisterMask&(1 << f)) != 0)
-			{
-				registerIndex = f;
-				break;
-			}
-		}
-		subrangeItr->range->physicalRegister = registerIndex;
-		// add to live ranges
-		liveInfo.liveRangeList[liveInfo.liveRangesCount] = subrangeItr;
-		liveInfo.liveRangesCount++;
-		// next
-		subrangeItr = subrangeItr->link_segmentSubrangesGPR.next;	
-	}
-	return true;
-}
-
-void PPCRecRA_assignRegisters(ppcImlGenContext_t* ppcImlGenContext)
-{
-	// start with frequently executed segments first
-	sint32 maxLoopDepth = 0;
-	for (sint32 i = 0; i < ppcImlGenContext->segmentListCount; i++)
-	{
-		maxLoopDepth = std::max(maxLoopDepth, ppcImlGenContext->segmentList[i]->loopDepth);
-	}
-	while (true)
-	{
-		bool done = false;
-		for (sint32 d = maxLoopDepth; d >= 0; d--)
-		{
-			for (sint32 i = 0; i < ppcImlGenContext->segmentListCount; i++)
-			{
-				PPCRecImlSegment_t* imlSegment = ppcImlGenContext->segmentList[i];
-				if (imlSegment->loopDepth != d)
-					continue;
-				done = PPCRecRA_assignSegmentRegisters(ppcImlGenContext, imlSegment);
-				if (done == false)
-					break;
-			}
-			if (done == false)
-				break;
-		}
-		if (done)
-			break;
-	}
-}
-
-typedef struct  
-{
-	raLivenessSubrange_t* subrangeList[SUBRANGE_LIST_SIZE];
-	sint32 subrangeCount;
-	bool hasUndefinedEndings;
-}subrangeEndingInfo_t;
-
-void _findSubrangeWriteEndings(raLivenessSubrange_t* subrange, uint32 iterationIndex, sint32 depth, subrangeEndingInfo_t* info)
-{
-	if (depth >= 30)
-	{
-		info->hasUndefinedEndings = true;
-		return;
-	}
-	if (subrange->lastIterationIndex == iterationIndex)
-		return; // already processed
-	subrange->lastIterationIndex = iterationIndex;
-	if (subrange->hasStoreDelayed)
-		return; // no need to traverse this subrange
-	PPCRecImlSegment_t* imlSegment = subrange->imlSegment;
-	if (subrange->end.index != RA_INTER_RANGE_END)
-	{
-		// ending segment
-		if (info->subrangeCount >= SUBRANGE_LIST_SIZE)
-		{
-			info->hasUndefinedEndings = true;
-			return;
-		}
-		else
-		{
-			info->subrangeList[info->subrangeCount] = subrange;
-			info->subrangeCount++;
-		}
-		return;
-	}
-
-	// traverse next subranges in flow
-	if (imlSegment->nextSegmentBranchNotTaken)
-	{
-		if (subrange->subrangeBranchNotTaken == nullptr)
-		{
-			info->hasUndefinedEndings = true;
-		}
-		else
-		{
-			_findSubrangeWriteEndings(subrange->subrangeBranchNotTaken, iterationIndex, depth + 1, info);
-		}
-	}
-	if (imlSegment->nextSegmentBranchTaken)
-	{
-		if (subrange->subrangeBranchTaken == nullptr)
-		{
-			info->hasUndefinedEndings = true;
-		}
-		else
-		{
-			_findSubrangeWriteEndings(subrange->subrangeBranchTaken, iterationIndex, depth + 1, info);
-		}
-	}
-}
-
-void _analyzeRangeDataFlow(raLivenessSubrange_t* subrange)
-{
-	if (subrange->end.index != RA_INTER_RANGE_END)
-		return;
-	// analyze data flow across segments (if this segment has writes)
-	if (subrange->hasStore)
-	{
-		subrangeEndingInfo_t writeEndingInfo;
-		writeEndingInfo.subrangeCount = 0;
-		writeEndingInfo.hasUndefinedEndings = false;
-		_findSubrangeWriteEndings(subrange, PPCRecRA_getNextIterationIndex(), 0, &writeEndingInfo);
-		if (writeEndingInfo.hasUndefinedEndings == false)
-		{
-			// get cost of delaying store into endings
-			sint32 delayStoreCost = 0;
-			bool alreadyStoredInAllEndings = true;
-			for (sint32 i = 0; i < writeEndingInfo.subrangeCount; i++)
-			{
-				raLivenessSubrange_t* subrangeItr = writeEndingInfo.subrangeList[i];
-				if( subrangeItr->hasStore )
-					continue; // this ending already stores, no extra cost
-				alreadyStoredInAllEndings = false;
-				sint32 storeCost = PPCRecRARange_getReadWriteCost(subrangeItr->imlSegment);
-				delayStoreCost = std::max(storeCost, delayStoreCost);
-			}
-			if (alreadyStoredInAllEndings)
-			{
-				subrange->hasStore = false;
-				subrange->hasStoreDelayed = true;
-			}
-			else if (delayStoreCost <= PPCRecRARange_getReadWriteCost(subrange->imlSegment))
-			{
-				subrange->hasStore = false;
-				subrange->hasStoreDelayed = true;
-				for (sint32 i = 0; i < writeEndingInfo.subrangeCount; i++)
-				{
-					raLivenessSubrange_t* subrangeItr = writeEndingInfo.subrangeList[i];
-					subrangeItr->hasStore = true;
-				}
-			}
-		}
-	}
-}
-
-void PPCRecRA_generateSegmentInstructions(ppcImlGenContext_t* ppcImlGenContext, PPCRecImlSegment_t* imlSegment)
-{
-	sint16 virtualReg2PhysReg[PPC_REC_MAX_VIRTUAL_GPR];
-	for (sint32 i = 0; i < PPC_REC_MAX_VIRTUAL_GPR; i++)
-		virtualReg2PhysReg[i] = -1;
-
-	raLiveRangeInfo_t liveInfo;
-	liveInfo.liveRangesCount = 0;
-	sint32 index = 0;
-	sint32 suffixInstructionCount = (imlSegment->imlListCount > 0 && PPCRecompiler_isSuffixInstruction(imlSegment->imlList + imlSegment->imlListCount - 1)) ? 1 : 0;
-	// load register ranges that are supplied from previous segments
-	raLivenessSubrange_t* subrangeItr = imlSegment->raInfo.linkedList_allSubranges;
-	//for (auto& subrange : imlSegment->raInfo.list_subranges)
-	while(subrangeItr)
-	{
-		if (subrangeItr->start.index == RA_INTER_RANGE_START)
-		{
-			liveInfo.liveRangeList[liveInfo.liveRangesCount] = subrangeItr;
-			liveInfo.liveRangesCount++;
-#ifndef PUBLIC_RELEASE
-			// load GPR
-			if (subrangeItr->_noLoad == false)
-			{
-				assert_dbg();
-			}
-			// update translation table
-			if (virtualReg2PhysReg[subrangeItr->range->virtualRegister] != -1)
-				assert_dbg();
-#endif
-			virtualReg2PhysReg[subrangeItr->range->virtualRegister] = subrangeItr->range->physicalRegister;
-		}
-		// next
-		subrangeItr = subrangeItr->link_segmentSubrangesGPR.next;
-	}
-	// process instructions
-	while(index < imlSegment->imlListCount+1)
-	{
-		// expire ranges
-		for (sint32 f = 0; f < liveInfo.liveRangesCount; f++)
-		{
-			raLivenessSubrange_t* liverange = liveInfo.liveRangeList[f];
-			if (liverange->end.index <= index)
-			{
-				// update translation table
-				if (virtualReg2PhysReg[liverange->range->virtualRegister] == -1)
-					assert_dbg();
-				virtualReg2PhysReg[liverange->range->virtualRegister] = -1;
-				// store GPR
-				if (liverange->hasStore)
-				{
-					PPCRecRA_insertGPRStoreInstruction(imlSegment, std::min(index, imlSegment->imlListCount - suffixInstructionCount), liverange->range->physicalRegister, liverange->range->name);
-					index++;
-				}
-				// remove entry
-				liveInfo.liveRangesCount--;
-				liveInfo.liveRangeList[f] = liveInfo.liveRangeList[liveInfo.liveRangesCount];
-				f--;
-			}
-		}
-		// load new ranges
-		subrangeItr = imlSegment->raInfo.linkedList_allSubranges;
-		while(subrangeItr)
-		{
-			if (subrangeItr->start.index == index)
-			{
-				liveInfo.liveRangeList[liveInfo.liveRangesCount] = subrangeItr;
-				liveInfo.liveRangesCount++;
-				// load GPR
-				if (subrangeItr->_noLoad == false)
-				{
-					PPCRecRA_insertGPRLoadInstruction(imlSegment, std::min(index, imlSegment->imlListCount - suffixInstructionCount), subrangeItr->range->physicalRegister, subrangeItr->range->name);
-					index++;
-					subrangeItr->start.index--;
-				}
-				// update translation table
-				cemu_assert_debug(virtualReg2PhysReg[subrangeItr->range->virtualRegister] == -1);
-				virtualReg2PhysReg[subrangeItr->range->virtualRegister] = subrangeItr->range->physicalRegister;
-			}
-			subrangeItr = subrangeItr->link_segmentSubrangesGPR.next;
-		}
-		// replace registers
-		if (index < imlSegment->imlListCount)
-		{
-			PPCImlOptimizerUsedRegisters_t gprTracking;
-			PPCRecompiler_checkRegisterUsage(NULL, imlSegment->imlList + index, &gprTracking);
-
-			sint32 inputGpr[4];
-			inputGpr[0] = gprTracking.gpr[0];
-			inputGpr[1] = gprTracking.gpr[1];
-			inputGpr[2] = gprTracking.gpr[2];
-			inputGpr[3] = gprTracking.gpr[3];
-			sint32 replaceGpr[4];
-			for (sint32 f = 0; f < 4; f++)
-			{
-				sint32 virtualRegister = gprTracking.gpr[f];
-				if (virtualRegister < 0)
-				{
-					replaceGpr[f] = -1;
-					continue;
-				}
-				if (virtualRegister >= PPC_REC_MAX_VIRTUAL_GPR)
-					assert_dbg();
-				replaceGpr[f] = virtualReg2PhysReg[virtualRegister];
-				cemu_assert_debug(replaceGpr[f] >= 0);
-			}
-			PPCRecompiler_replaceGPRRegisterUsageMultiple(ppcImlGenContext, imlSegment->imlList + index, inputGpr, replaceGpr);
-		}
-		// next iml instruction
-		index++;
-	}
-	// expire infinite subranges (subranges that cross the segment border)
-	sint32 storeLoadListLength = 0;
-	raLoadStoreInfo_t loadStoreList[PPC_REC_MAX_VIRTUAL_GPR];
-	for (sint32 f = 0; f < liveInfo.liveRangesCount; f++)
-	{
-		raLivenessSubrange_t* liverange = liveInfo.liveRangeList[f];
-		if (liverange->end.index == RA_INTER_RANGE_END)
-		{
-			// update translation table
-			cemu_assert_debug(virtualReg2PhysReg[liverange->range->virtualRegister] != -1);
-			virtualReg2PhysReg[liverange->range->virtualRegister] = -1;
-			// store GPR
-			if (liverange->hasStore)
-			{
-				loadStoreList[storeLoadListLength].registerIndex = liverange->range->physicalRegister;
-				loadStoreList[storeLoadListLength].registerName = liverange->range->name;
-				storeLoadListLength++;
-			}
-			// remove entry
-			liveInfo.liveRangesCount--;
-			liveInfo.liveRangeList[f] = liveInfo.liveRangeList[liveInfo.liveRangesCount];
-			f--;
-		}
-		else
-		{
-			cemu_assert_suspicious();
-		}
-	}
-	if (storeLoadListLength > 0)
-	{
-		PPCRecRA_insertGPRStoreInstructions(imlSegment, imlSegment->imlListCount - suffixInstructionCount, loadStoreList, storeLoadListLength);
-	}
-	// load subranges for next segments
-	subrangeItr = imlSegment->raInfo.linkedList_allSubranges;
-	storeLoadListLength = 0;
-	while(subrangeItr)
-	{
-		if (subrangeItr->start.index == RA_INTER_RANGE_END)
-		{
-			liveInfo.liveRangeList[liveInfo.liveRangesCount] = subrangeItr;
-			liveInfo.liveRangesCount++;
-			// load GPR
-			if (subrangeItr->_noLoad == false)
-			{
-				loadStoreList[storeLoadListLength].registerIndex = subrangeItr->range->physicalRegister;
-				loadStoreList[storeLoadListLength].registerName = subrangeItr->range->name;
-				storeLoadListLength++;
-			}
-			// update translation table
-			cemu_assert_debug(virtualReg2PhysReg[subrangeItr->range->virtualRegister] == -1);
-			virtualReg2PhysReg[subrangeItr->range->virtualRegister] = subrangeItr->range->physicalRegister;
-		}
-		// next
-		subrangeItr = subrangeItr->link_segmentSubrangesGPR.next;
-	}
-	if (storeLoadListLength > 0)
-	{
-		PPCRecRA_insertGPRLoadInstructions(imlSegment, imlSegment->imlListCount - suffixInstructionCount, loadStoreList, storeLoadListLength);
-	}
-}
-
-void PPCRecRA_generateMoveInstructions(ppcImlGenContext_t* ppcImlGenContext)
-{
-	for (sint32 s = 0; s < ppcImlGenContext->segmentListCount; s++)
-	{
-		PPCRecImlSegment_t* imlSegment = ppcImlGenContext->segmentList[s];
-		PPCRecRA_generateSegmentInstructions(ppcImlGenContext, imlSegment);
-	}
-}
-
-void PPCRecRA_calculateLivenessRangesV2(ppcImlGenContext_t* ppcImlGenContext);
-void PPCRecRA_processFlowAndCalculateLivenessRangesV2(ppcImlGenContext_t* ppcImlGenContext);
-void PPCRecRA_analyzeRangeDataFlowV2(ppcImlGenContext_t* ppcImlGenContext);
-
-void PPCRecompilerImm_prepareForRegisterAllocation(ppcImlGenContext_t* ppcImlGenContext)
-{
-	// insert empty segments after every non-taken branch if the linked segment has more than one input
-	// this gives the register allocator more room to create efficient spill code
-	sint32 segmentIndex = 0;
-	while (segmentIndex < ppcImlGenContext->segmentListCount)
-	{
-		PPCRecImlSegment_t* imlSegment = ppcImlGenContext->segmentList[segmentIndex];
-		if (imlSegment->nextSegmentIsUncertain)
-		{
-			segmentIndex++;
-			continue;
-		}
-		if (imlSegment->nextSegmentBranchTaken == nullptr || imlSegment->nextSegmentBranchNotTaken == nullptr)
-		{
-			segmentIndex++;
-			continue;
-		}
-		if (imlSegment->nextSegmentBranchNotTaken->list_prevSegments.size() <= 1)
-		{
-			segmentIndex++;
-			continue;
-		}
-		if (imlSegment->nextSegmentBranchNotTaken->isEnterable)
-		{
-			segmentIndex++;
-			continue;
-		}
-		PPCRecompilerIml_insertSegments(ppcImlGenContext, segmentIndex + 1, 1);
-		PPCRecImlSegment_t* imlSegmentP0 = ppcImlGenContext->segmentList[segmentIndex + 0];
-		PPCRecImlSegment_t* imlSegmentP1 = ppcImlGenContext->segmentList[segmentIndex + 1];
-		PPCRecImlSegment_t* nextSegment = imlSegment->nextSegmentBranchNotTaken;
-		PPCRecompilerIML_removeLink(imlSegmentP0, nextSegment);
-		PPCRecompilerIml_setLinkBranchNotTaken(imlSegmentP1, nextSegment);
-		PPCRecompilerIml_setLinkBranchNotTaken(imlSegmentP0, imlSegmentP1);
-		segmentIndex++;
-	}
-	// detect loops
-	for (sint32 s = 0; s < ppcImlGenContext->segmentListCount; s++)
-	{
-		PPCRecImlSegment_t* imlSegment = ppcImlGenContext->segmentList[s];
-		imlSegment->momentaryIndex = s;
-	}
-	for (sint32 s = 0; s < ppcImlGenContext->segmentListCount; s++)
-	{
-		PPCRecImlSegment_t* imlSegment = ppcImlGenContext->segmentList[s];
-		PPCRecRA_identifyLoop(ppcImlGenContext, imlSegment);
-	}
-}
-
-void PPCRecompilerImm_allocateRegisters(ppcImlGenContext_t* ppcImlGenContext)
-{
-	PPCRecompilerImm_prepareForRegisterAllocation(ppcImlGenContext);
-
-	ppcImlGenContext->raInfo.list_ranges = std::vector<raLivenessRange_t*>();
-	
-	// calculate liveness
-	PPCRecRA_calculateLivenessRangesV2(ppcImlGenContext);
-	PPCRecRA_processFlowAndCalculateLivenessRangesV2(ppcImlGenContext);
-
-	PPCRecRA_assignRegisters(ppcImlGenContext);
-
-	PPCRecRA_analyzeRangeDataFlowV2(ppcImlGenContext);
-	PPCRecRA_generateMoveInstructions(ppcImlGenContext);
-
-	PPCRecRA_deleteAllRanges(ppcImlGenContext);
-}
\ No newline at end of file
diff --git a/src/Cafe/HW/Espresso/Recompiler/PPCRecompilerImlRegisterAllocator2.cpp b/src/Cafe/HW/Espresso/Recompiler/PPCRecompilerImlRegisterAllocator2.cpp
deleted file mode 100644
index e2070703..00000000
--- a/src/Cafe/HW/Espresso/Recompiler/PPCRecompilerImlRegisterAllocator2.cpp
+++ /dev/null
@@ -1,414 +0,0 @@
-#include "PPCRecompiler.h"
-#include "PPCRecompilerIml.h"
-#include "PPCRecompilerX64.h"
-#include "PPCRecompilerImlRanges.h"
-#include <queue>
-
-bool _isRangeDefined(PPCRecImlSegment_t* imlSegment, sint32 vGPR)
-{
-	return (imlSegment->raDistances.reg[vGPR].usageStart != INT_MAX);
-}
-
-void PPCRecRA_calculateSegmentMinMaxRanges(ppcImlGenContext_t* ppcImlGenContext, PPCRecImlSegment_t* imlSegment)
-{
-	for (sint32 i = 0; i < PPC_REC_MAX_VIRTUAL_GPR; i++)
-	{
-		imlSegment->raDistances.reg[i].usageStart = INT_MAX;
-		imlSegment->raDistances.reg[i].usageEnd = INT_MIN;
-	}
-	// scan instructions for usage range
-	sint32 index = 0;
-	PPCImlOptimizerUsedRegisters_t gprTracking;
-	while (index < imlSegment->imlListCount)
-	{
-		// end loop at suffix instruction
-		if (PPCRecompiler_isSuffixInstruction(imlSegment->imlList + index))
-			break;
-		// get accessed GPRs
-		PPCRecompiler_checkRegisterUsage(NULL, imlSegment->imlList + index, &gprTracking);
-		for (sint32 t = 0; t < 4; t++)
-		{
-			sint32 virtualRegister = gprTracking.gpr[t];
-			if (virtualRegister < 0)
-				continue;
-			cemu_assert_debug(virtualRegister < PPC_REC_MAX_VIRTUAL_GPR);
-			imlSegment->raDistances.reg[virtualRegister].usageStart = std::min(imlSegment->raDistances.reg[virtualRegister].usageStart, index); // index before/at instruction
-			imlSegment->raDistances.reg[virtualRegister].usageEnd = std::max(imlSegment->raDistances.reg[virtualRegister].usageEnd, index+1); // index after instruction
-		}
-		// next instruction
-		index++;
-	}
-}
-
-void PPCRecRA_calculateLivenessRangesV2(ppcImlGenContext_t* ppcImlGenContext)
-{
-	// for each register calculate min/max index of usage range within each segment
-	for (sint32 s = 0; s < ppcImlGenContext->segmentListCount; s++)
-	{
-		PPCRecRA_calculateSegmentMinMaxRanges(ppcImlGenContext, ppcImlGenContext->segmentList[s]);
-	}
-}
-
-raLivenessSubrange_t* PPCRecRA_convertToMappedRanges(ppcImlGenContext_t* ppcImlGenContext, PPCRecImlSegment_t* imlSegment, sint32 vGPR, raLivenessRange_t* range)
-{
-	if (imlSegment->raDistances.isProcessed[vGPR])
-	{
-		// return already existing segment
-		return imlSegment->raInfo.linkedList_perVirtualGPR[vGPR];
-	}
-	imlSegment->raDistances.isProcessed[vGPR] = true;
-	if (_isRangeDefined(imlSegment, vGPR) == false)
-		return nullptr;
-	// create subrange
-	cemu_assert_debug(imlSegment->raInfo.linkedList_perVirtualGPR[vGPR] == nullptr);
-	raLivenessSubrange_t* subrange = PPCRecRA_createSubrange(ppcImlGenContext, range, imlSegment, imlSegment->raDistances.reg[vGPR].usageStart, imlSegment->raDistances.reg[vGPR].usageEnd);
-	// traverse forward
-	if (imlSegment->raDistances.reg[vGPR].usageEnd == RA_INTER_RANGE_END)
-	{
-		if (imlSegment->nextSegmentBranchTaken && imlSegment->nextSegmentBranchTaken->raDistances.reg[vGPR].usageStart == RA_INTER_RANGE_START)
-		{
-			subrange->subrangeBranchTaken = PPCRecRA_convertToMappedRanges(ppcImlGenContext, imlSegment->nextSegmentBranchTaken, vGPR, range);
-			cemu_assert_debug(subrange->subrangeBranchTaken->start.index == RA_INTER_RANGE_START);
-		}
-		if (imlSegment->nextSegmentBranchNotTaken && imlSegment->nextSegmentBranchNotTaken->raDistances.reg[vGPR].usageStart == RA_INTER_RANGE_START)
-		{
-			subrange->subrangeBranchNotTaken = PPCRecRA_convertToMappedRanges(ppcImlGenContext, imlSegment->nextSegmentBranchNotTaken, vGPR, range);
-			cemu_assert_debug(subrange->subrangeBranchNotTaken->start.index == RA_INTER_RANGE_START);
-		}
-	}
-	// traverse backward
-	if (imlSegment->raDistances.reg[vGPR].usageStart == RA_INTER_RANGE_START)
-	{
-		for (auto& it : imlSegment->list_prevSegments)
-		{
-			if (it->raDistances.reg[vGPR].usageEnd == RA_INTER_RANGE_END)
-				PPCRecRA_convertToMappedRanges(ppcImlGenContext, it, vGPR, range);
-		}
-	}
-	// return subrange
-	return subrange;
-}
-
-void PPCRecRA_createSegmentLivenessRanges(ppcImlGenContext_t* ppcImlGenContext, PPCRecImlSegment_t* imlSegment)
-{
-	for (sint32 i = 0; i < PPC_REC_MAX_VIRTUAL_GPR; i++)
-	{
-		if( _isRangeDefined(imlSegment, i) == false )
-			continue;
-		if( imlSegment->raDistances.isProcessed[i])
-			continue;
-		raLivenessRange_t* range = PPCRecRA_createRangeBase(ppcImlGenContext, i, ppcImlGenContext->mappedRegister[i]);
-		PPCRecRA_convertToMappedRanges(ppcImlGenContext, imlSegment, i, range);
-	}
-	// create lookup table of ranges
-	raLivenessSubrange_t* vGPR2Subrange[PPC_REC_MAX_VIRTUAL_GPR];
-	for (sint32 i = 0; i < PPC_REC_MAX_VIRTUAL_GPR; i++)
-	{
-		vGPR2Subrange[i] = imlSegment->raInfo.linkedList_perVirtualGPR[i];
-#ifndef PUBLIC_RELEASE
-		if (vGPR2Subrange[i] && vGPR2Subrange[i]->link_sameVirtualRegisterGPR.next != nullptr)
-			assert_dbg();
-#endif
-	}
-	// parse instructions and convert to locations
-	sint32 index = 0;
-	PPCImlOptimizerUsedRegisters_t gprTracking;
-	while (index < imlSegment->imlListCount)
-	{
-		// end loop at suffix instruction
-		if (PPCRecompiler_isSuffixInstruction(imlSegment->imlList + index))
-			break;
-		// get accessed GPRs
-		PPCRecompiler_checkRegisterUsage(NULL, imlSegment->imlList + index, &gprTracking);
-		// handle accessed GPR
-		for (sint32 t = 0; t < 4; t++)
-		{
-			sint32 virtualRegister = gprTracking.gpr[t];
-			if (virtualRegister < 0)
-				continue;
-			bool isWrite = (t == 3);
-			// add location
-			PPCRecRA_updateOrAddSubrangeLocation(vGPR2Subrange[virtualRegister], index, isWrite == false, isWrite);
-#ifndef PUBLIC_RELEASE
-			if (index < vGPR2Subrange[virtualRegister]->start.index)
-				assert_dbg();
-			if (index+1 > vGPR2Subrange[virtualRegister]->end.index)
-				assert_dbg();
-#endif
-		}
-		// next instruction
-		index++;
-	}
-}
-
-void PPCRecRA_extendRangeToEndOfSegment(ppcImlGenContext_t* ppcImlGenContext, PPCRecImlSegment_t* imlSegment, sint32 vGPR)
-{
-	if (_isRangeDefined(imlSegment, vGPR) == false)
-	{
-		imlSegment->raDistances.reg[vGPR].usageStart = RA_INTER_RANGE_END;
-		imlSegment->raDistances.reg[vGPR].usageEnd = RA_INTER_RANGE_END;
-		return;
-	}
-	imlSegment->raDistances.reg[vGPR].usageEnd = RA_INTER_RANGE_END;
-}
-
-void PPCRecRA_extendRangeToBeginningOfSegment(ppcImlGenContext_t* ppcImlGenContext, PPCRecImlSegment_t* imlSegment, sint32 vGPR)
-{
-	if (_isRangeDefined(imlSegment, vGPR) == false)
-	{
-		imlSegment->raDistances.reg[vGPR].usageStart = RA_INTER_RANGE_START;
-		imlSegment->raDistances.reg[vGPR].usageEnd = RA_INTER_RANGE_START;
-	}
-	else
-	{
-		imlSegment->raDistances.reg[vGPR].usageStart = RA_INTER_RANGE_START;
-	}
-	// propagate backwards
-	for (auto& it : imlSegment->list_prevSegments)
-	{
-		PPCRecRA_extendRangeToEndOfSegment(ppcImlGenContext, it, vGPR);
-	}
-}
-
-void _PPCRecRA_connectRanges(ppcImlGenContext_t* ppcImlGenContext, sint32 vGPR, PPCRecImlSegment_t** route, sint32 routeDepth)
-{
-#ifndef PUBLIC_RELEASE
-	if (routeDepth < 2)
-		assert_dbg();
-#endif
-	// extend starting range to end of segment
-	PPCRecRA_extendRangeToEndOfSegment(ppcImlGenContext, route[0], vGPR);
-	// extend all the connecting segments in both directions
-	for (sint32 i = 1; i < (routeDepth - 1); i++)
-	{
-		PPCRecRA_extendRangeToEndOfSegment(ppcImlGenContext, route[i], vGPR);
-		PPCRecRA_extendRangeToBeginningOfSegment(ppcImlGenContext, route[i], vGPR);
-	}
-	// extend the final segment towards the beginning
-	PPCRecRA_extendRangeToBeginningOfSegment(ppcImlGenContext, route[routeDepth-1], vGPR);
-}
-
-void _PPCRecRA_checkAndTryExtendRange(ppcImlGenContext_t* ppcImlGenContext, PPCRecImlSegment_t* currentSegment, sint32 vGPR, sint32 distanceLeft, PPCRecImlSegment_t** route, sint32 routeDepth)
-{
-	if (routeDepth >= 64)
-	{
-		forceLogDebug_printf("Recompiler RA route maximum depth exceeded for function 0x%08x\n", ppcImlGenContext->functionRef->ppcAddress);
-		return;
-	}
-	route[routeDepth] = currentSegment;
-	if (currentSegment->raDistances.reg[vGPR].usageStart == INT_MAX)
-	{
-		// measure distance to end of segment
-		distanceLeft -= currentSegment->imlListCount;
-		if (distanceLeft > 0)
-		{
-			if (currentSegment->nextSegmentBranchNotTaken)
-				_PPCRecRA_checkAndTryExtendRange(ppcImlGenContext, currentSegment->nextSegmentBranchNotTaken, vGPR, distanceLeft, route, routeDepth + 1);
-			if (currentSegment->nextSegmentBranchTaken)
-				_PPCRecRA_checkAndTryExtendRange(ppcImlGenContext, currentSegment->nextSegmentBranchTaken, vGPR, distanceLeft, route, routeDepth + 1);
-		}
-		return;
-	}
-	else
-	{
-		// measure distance to range
-		if (currentSegment->raDistances.reg[vGPR].usageStart == RA_INTER_RANGE_END)
-		{
-			if (distanceLeft < currentSegment->imlListCount)
-				return; // range too far away
-		}
-		else if (currentSegment->raDistances.reg[vGPR].usageStart != RA_INTER_RANGE_START && currentSegment->raDistances.reg[vGPR].usageStart > distanceLeft)
-			return; // out of range
-		// found close range -> connect ranges
-		_PPCRecRA_connectRanges(ppcImlGenContext, vGPR, route, routeDepth + 1);
-	}
-}
-
-void PPCRecRA_checkAndTryExtendRange(ppcImlGenContext_t* ppcImlGenContext, PPCRecImlSegment_t* currentSegment, sint32 vGPR)
-{
-#ifndef PUBLIC_RELEASE
-	if (currentSegment->raDistances.reg[vGPR].usageEnd < 0)
-		assert_dbg();
-#endif
-	// count instructions to end of initial segment
-	if (currentSegment->raDistances.reg[vGPR].usageEnd == RA_INTER_RANGE_START)
-		assert_dbg();
-	sint32 instructionsUntilEndOfSeg;
-	if (currentSegment->raDistances.reg[vGPR].usageEnd == RA_INTER_RANGE_END)
-		instructionsUntilEndOfSeg = 0;
-	else
-		instructionsUntilEndOfSeg = currentSegment->imlListCount - currentSegment->raDistances.reg[vGPR].usageEnd;
-
-#ifndef PUBLIC_RELEASE
-	if (instructionsUntilEndOfSeg < 0)
-		assert_dbg();
-#endif
-	sint32 remainingScanDist = 45 - instructionsUntilEndOfSeg;
-	if (remainingScanDist <= 0)
-		return; // can't reach end
-
-	// also dont forget: Extending is easier if we allow 'non symetric' branches. E.g. register range one enters one branch
-	PPCRecImlSegment_t* route[64];
-	route[0] = currentSegment;
-	if (currentSegment->nextSegmentBranchNotTaken)
-	{
-		_PPCRecRA_checkAndTryExtendRange(ppcImlGenContext, currentSegment->nextSegmentBranchNotTaken, vGPR, remainingScanDist, route, 1);
-	}
-	if (currentSegment->nextSegmentBranchTaken)
-	{
-		_PPCRecRA_checkAndTryExtendRange(ppcImlGenContext, currentSegment->nextSegmentBranchTaken, vGPR, remainingScanDist, route, 1);
-	}
-}
-
-void PPCRecRA_mergeCloseRangesForSegmentV2(ppcImlGenContext_t* ppcImlGenContext, PPCRecImlSegment_t* imlSegment)
-{
-	for (sint32 i = 0; i < PPC_REC_MAX_VIRTUAL_GPR; i++) // todo: Use dynamic maximum or list of used vGPRs so we can avoid parsing empty entries
-	{
-		if(imlSegment->raDistances.reg[i].usageStart == INT_MAX)
-			continue; // not used
-		// check and extend if possible
-		PPCRecRA_checkAndTryExtendRange(ppcImlGenContext, imlSegment, i);
-	}
-#ifndef PUBLIC_RELEASE
-	if (imlSegment->list_prevSegments.empty() == false && imlSegment->isEnterable)
-		assert_dbg();
-	if ((imlSegment->nextSegmentBranchNotTaken != nullptr || imlSegment->nextSegmentBranchTaken != nullptr) && imlSegment->nextSegmentIsUncertain)
-		assert_dbg();
-#endif
-}
-
-void PPCRecRA_followFlowAndExtendRanges(ppcImlGenContext_t* ppcImlGenContext, PPCRecImlSegment_t* imlSegment)
-{
-	std::vector<PPCRecImlSegment_t*> list_segments;
-	list_segments.reserve(1000);
-	sint32 index = 0;
-	imlSegment->raRangeExtendProcessed = true;
-	list_segments.push_back(imlSegment);
-	while (index < list_segments.size())
-	{
-		PPCRecImlSegment_t* currentSegment = list_segments[index];
-		PPCRecRA_mergeCloseRangesForSegmentV2(ppcImlGenContext, currentSegment);
-		// follow flow
-		if (currentSegment->nextSegmentBranchNotTaken && currentSegment->nextSegmentBranchNotTaken->raRangeExtendProcessed == false)
-		{
-			currentSegment->nextSegmentBranchNotTaken->raRangeExtendProcessed = true;
-			list_segments.push_back(currentSegment->nextSegmentBranchNotTaken);
-		}
-		if (currentSegment->nextSegmentBranchTaken && currentSegment->nextSegmentBranchTaken->raRangeExtendProcessed == false)
-		{
-			currentSegment->nextSegmentBranchTaken->raRangeExtendProcessed = true;
-			list_segments.push_back(currentSegment->nextSegmentBranchTaken);
-		}
-		index++;
-	}
-}
-
-void PPCRecRA_mergeCloseRangesV2(ppcImlGenContext_t* ppcImlGenContext)
-{
-	for (sint32 s = 0; s < ppcImlGenContext->segmentListCount; s++)
-	{
-		PPCRecImlSegment_t* imlSegment = ppcImlGenContext->segmentList[s];
-		if (imlSegment->list_prevSegments.empty())
-		{
-			if (imlSegment->raRangeExtendProcessed)
-				assert_dbg(); // should not happen
-			PPCRecRA_followFlowAndExtendRanges(ppcImlGenContext, imlSegment);
-		}
-	}
-}
-
-void PPCRecRA_extendRangesOutOfLoopsV2(ppcImlGenContext_t* ppcImlGenContext)
-{
-	for (sint32 s = 0; s < ppcImlGenContext->segmentListCount; s++)
-	{
-		PPCRecImlSegment_t* imlSegment = ppcImlGenContext->segmentList[s];
-		auto localLoopDepth = imlSegment->loopDepth;
-		if( localLoopDepth <= 0 )
-			continue; // not inside a loop
-		// look for loop exit
-		bool hasLoopExit = false;
-		if (imlSegment->nextSegmentBranchTaken && imlSegment->nextSegmentBranchTaken->loopDepth < localLoopDepth)
-		{
-			hasLoopExit = true;
-		}
-		if (imlSegment->nextSegmentBranchNotTaken && imlSegment->nextSegmentBranchNotTaken->loopDepth < localLoopDepth)
-		{
-			hasLoopExit = true;
-		}
-		if(hasLoopExit == false)
-			continue;
-
-		// extend looping ranges into all exits (this allows the data flow analyzer to move stores out of the loop)
-		for (sint32 i = 0; i < PPC_REC_MAX_VIRTUAL_GPR; i++) // todo: Use dynamic maximum or list of used vGPRs so we can avoid parsing empty entries
-		{
-			if (imlSegment->raDistances.reg[i].usageEnd != RA_INTER_RANGE_END)
-				continue; // range not set or does not reach end of segment
-			if(imlSegment->nextSegmentBranchTaken)
-				PPCRecRA_extendRangeToBeginningOfSegment(ppcImlGenContext, imlSegment->nextSegmentBranchTaken, i);
-			if(imlSegment->nextSegmentBranchNotTaken)
-				PPCRecRA_extendRangeToBeginningOfSegment(ppcImlGenContext, imlSegment->nextSegmentBranchNotTaken, i);
-		}
-	}
-}
-
-void PPCRecRA_processFlowAndCalculateLivenessRangesV2(ppcImlGenContext_t* ppcImlGenContext)
-{
-	// merge close ranges
-	PPCRecRA_mergeCloseRangesV2(ppcImlGenContext);
-	// extra pass to move register stores out of loops
-	PPCRecRA_extendRangesOutOfLoopsV2(ppcImlGenContext);
-	// calculate liveness ranges
-	for (sint32 s = 0; s < ppcImlGenContext->segmentListCount; s++)
-	{
-		PPCRecImlSegment_t* imlSegment = ppcImlGenContext->segmentList[s];
-		PPCRecRA_createSegmentLivenessRanges(ppcImlGenContext, imlSegment);
-	}
-}
-
-void PPCRecRA_analyzeSubrangeDataDependencyV2(raLivenessSubrange_t* subrange)
-{
-	bool isRead = false;
-	bool isWritten = false;
-	bool isOverwritten = false;
-	for (auto& location : subrange->list_locations)
-	{
-		if (location.isRead)
-		{
-			isRead = true;
-		}
-		if (location.isWrite)
-		{
-			if (isRead == false)
-				isOverwritten = true;
-			isWritten = true;
-		}
-	}
-	subrange->_noLoad = isOverwritten;
-	subrange->hasStore = isWritten;
-
-	if (subrange->start.index == RA_INTER_RANGE_START)
-		subrange->_noLoad = true;
-}
-
-void _analyzeRangeDataFlow(raLivenessSubrange_t* subrange);
-
-void PPCRecRA_analyzeRangeDataFlowV2(ppcImlGenContext_t* ppcImlGenContext)
-{
-	// this function is called after _assignRegisters(), which means that all ranges are already final and wont change anymore
-	// first do a per-subrange pass
-	for (auto& range : ppcImlGenContext->raInfo.list_ranges)
-	{
-		for (auto& subrange : range->list_subranges)
-		{
-			PPCRecRA_analyzeSubrangeDataDependencyV2(subrange);
-		}
-	}
-	// then do a second pass where we scan along subrange flow
-	for (auto& range : ppcImlGenContext->raInfo.list_ranges)
-	{
-		for (auto& subrange : range->list_subranges) // todo - traversing this backwards should be faster and yield better results due to the nature of the algorithm
-		{
-			_analyzeRangeDataFlow(subrange);
-		}
-	}
-}
\ No newline at end of file
diff --git a/src/Cafe/HW/Espresso/Recompiler/PPCRecompilerIntermediate.cpp b/src/Cafe/HW/Espresso/Recompiler/PPCRecompilerIntermediate.cpp
index fcbe64be..468af5b2 100644
--- a/src/Cafe/HW/Espresso/Recompiler/PPCRecompilerIntermediate.cpp
+++ b/src/Cafe/HW/Espresso/Recompiler/PPCRecompilerIntermediate.cpp
@@ -1,173 +1,26 @@
 #include "PPCRecompiler.h"
 #include "PPCRecompilerIml.h"
 
-PPCRecImlSegment_t* PPCRecompiler_getSegmentByPPCJumpAddress(ppcImlGenContext_t* ppcImlGenContext, uint32 ppcOffset)
-{
-	for(sint32 s=0; s<ppcImlGenContext->segmentListCount; s++)
-	{
-		if( ppcImlGenContext->segmentList[s]->isJumpDestination && ppcImlGenContext->segmentList[s]->jumpDestinationPPCAddress == ppcOffset )
-		{
-			return ppcImlGenContext->segmentList[s];
-		}
-	}
-	debug_printf("PPCRecompiler_getSegmentByPPCJumpAddress(): Unable to find segment (ppcOffset 0x%08x)\n", ppcOffset);
-	return NULL;
-}
-
-void PPCRecompilerIml_setLinkBranchNotTaken(PPCRecImlSegment_t* imlSegmentSrc, PPCRecImlSegment_t* imlSegmentDst)
-{
-	// make sure segments aren't already linked
-	if (imlSegmentSrc->nextSegmentBranchNotTaken == imlSegmentDst)
-		return;
-	// add as next segment for source
-	if (imlSegmentSrc->nextSegmentBranchNotTaken != NULL)
-		assert_dbg();
-	imlSegmentSrc->nextSegmentBranchNotTaken = imlSegmentDst;
-	// add as previous segment for destination
-	imlSegmentDst->list_prevSegments.push_back(imlSegmentSrc);
-}
-
-void PPCRecompilerIml_setLinkBranchTaken(PPCRecImlSegment_t* imlSegmentSrc, PPCRecImlSegment_t* imlSegmentDst)
-{
-	// make sure segments aren't already linked
-	if (imlSegmentSrc->nextSegmentBranchTaken == imlSegmentDst)
-		return;
-	// add as next segment for source
-	if (imlSegmentSrc->nextSegmentBranchTaken != NULL)
-		assert_dbg();
-	imlSegmentSrc->nextSegmentBranchTaken = imlSegmentDst;
-	// add as previous segment for destination
-	imlSegmentDst->list_prevSegments.push_back(imlSegmentSrc);
-}
-
-void PPCRecompilerIML_removeLink(PPCRecImlSegment_t* imlSegmentSrc, PPCRecImlSegment_t* imlSegmentDst)
-{
-	if (imlSegmentSrc->nextSegmentBranchNotTaken == imlSegmentDst)
-	{
-		imlSegmentSrc->nextSegmentBranchNotTaken = NULL;
-	}
-	else if (imlSegmentSrc->nextSegmentBranchTaken == imlSegmentDst)
-	{
-		imlSegmentSrc->nextSegmentBranchTaken = NULL;
-	}
-	else
-		assert_dbg();
-
-	bool matchFound = false;
-	for (sint32 i = 0; i < imlSegmentDst->list_prevSegments.size(); i++)
-	{
-		if (imlSegmentDst->list_prevSegments[i] == imlSegmentSrc)
-		{
-			imlSegmentDst->list_prevSegments.erase(imlSegmentDst->list_prevSegments.begin()+i);
-			matchFound = true;
-			break;
-		}
-	}
-	if (matchFound == false)
-		assert_dbg();
-}
-
-/*
- * Replaces all links to segment orig with linkts to segment new
- */
-void PPCRecompilerIML_relinkInputSegment(PPCRecImlSegment_t* imlSegmentOrig, PPCRecImlSegment_t* imlSegmentNew)
-{
-	while (imlSegmentOrig->list_prevSegments.size() != 0)
-	{
-		PPCRecImlSegment_t* prevSegment = imlSegmentOrig->list_prevSegments[0];
-		if (prevSegment->nextSegmentBranchNotTaken == imlSegmentOrig)
-		{
-			PPCRecompilerIML_removeLink(prevSegment, imlSegmentOrig);
-			PPCRecompilerIml_setLinkBranchNotTaken(prevSegment, imlSegmentNew);
-		}
-		else if (prevSegment->nextSegmentBranchTaken == imlSegmentOrig)
-		{
-			PPCRecompilerIML_removeLink(prevSegment, imlSegmentOrig);
-			PPCRecompilerIml_setLinkBranchTaken(prevSegment, imlSegmentNew);
-		}
-		else
-		{
-			assert_dbg();
-		}
-	}
-}
-
-void PPCRecompilerIML_linkSegments(ppcImlGenContext_t* ppcImlGenContext)
-{
-	for(sint32 s=0; s<ppcImlGenContext->segmentListCount; s++)
-	{
-		PPCRecImlSegment_t* imlSegment = ppcImlGenContext->segmentList[s];
-
-		bool isLastSegment = (s+1)>=ppcImlGenContext->segmentListCount;
-		PPCRecImlSegment_t* nextSegment = isLastSegment?NULL:ppcImlGenContext->segmentList[s+1];
-		// handle empty segment
-		if( imlSegment->imlListCount == 0 )
-		{
-			if (isLastSegment == false)
-				PPCRecompilerIml_setLinkBranchNotTaken(imlSegment, ppcImlGenContext->segmentList[s+1]); // continue execution to next segment
-			else
-				imlSegment->nextSegmentIsUncertain = true;
-			continue;
-		}
-		// check last instruction of segment
-		PPCRecImlInstruction_t* imlInstruction = imlSegment->imlList+(imlSegment->imlListCount-1);
-		if( imlInstruction->type == PPCREC_IML_TYPE_CJUMP || imlInstruction->type == PPCREC_IML_TYPE_CJUMP_CYCLE_CHECK )
-		{
-			// find destination segment by ppc jump address
-			PPCRecImlSegment_t* jumpDestSegment = PPCRecompiler_getSegmentByPPCJumpAddress(ppcImlGenContext, imlInstruction->op_conditionalJump.jumpmarkAddress);
-			if( jumpDestSegment )
-			{
-				if (imlInstruction->op_conditionalJump.condition != PPCREC_JUMP_CONDITION_NONE)
-					PPCRecompilerIml_setLinkBranchNotTaken(imlSegment, nextSegment);
-				PPCRecompilerIml_setLinkBranchTaken(imlSegment, jumpDestSegment);
-			}
-			else
-			{
-				imlSegment->nextSegmentIsUncertain = true;
-			}
-		}
-		else if( imlInstruction->type == PPCREC_IML_TYPE_MACRO )
-		{
-			// currently we assume that the next segment is unknown for all macros
-			imlSegment->nextSegmentIsUncertain = true;
-		}
-		else
-		{
-			// all other instruction types do not branch
-			//imlSegment->nextSegment[0] = nextSegment;
-			PPCRecompilerIml_setLinkBranchNotTaken(imlSegment, nextSegment);
-			//imlSegment->nextSegmentIsUncertain = true;
-		}
-	}
-}
-
 void PPCRecompilerIML_isolateEnterableSegments(ppcImlGenContext_t* ppcImlGenContext)
 {
-	sint32 initialSegmentCount = ppcImlGenContext->segmentListCount;
-	for (sint32 i = 0; i < ppcImlGenContext->segmentListCount; i++)
+	size_t initialSegmentCount = ppcImlGenContext->segmentList2.size();
+	for (size_t i = 0; i < initialSegmentCount; i++)
 	{
-		PPCRecImlSegment_t* imlSegment = ppcImlGenContext->segmentList[i];
+		IMLSegment* imlSegment = ppcImlGenContext->segmentList2[i];
 		if (imlSegment->list_prevSegments.empty() == false && imlSegment->isEnterable)
 		{
 			// spawn new segment at end
-			PPCRecompilerIml_insertSegments(ppcImlGenContext, ppcImlGenContext->segmentListCount, 1);
-			PPCRecImlSegment_t* entrySegment = ppcImlGenContext->segmentList[ppcImlGenContext->segmentListCount-1];
+			PPCRecompilerIml_insertSegments(ppcImlGenContext, ppcImlGenContext->segmentList2.size(), 1);
+			IMLSegment* entrySegment = ppcImlGenContext->segmentList2[ppcImlGenContext->segmentList2.size()-1];
 			entrySegment->isEnterable = true;
 			entrySegment->enterPPCAddress = imlSegment->enterPPCAddress;
 			// create jump instruction
 			PPCRecompiler_pushBackIMLInstructions(entrySegment, 0, 1);
-			PPCRecompilerImlGen_generateNewInstruction_jumpSegment(ppcImlGenContext, entrySegment->imlList + 0);
-			PPCRecompilerIml_setLinkBranchTaken(entrySegment, imlSegment);
+			entrySegment->imlList.data()[0].make_jump();
+			IMLSegment_SetLinkBranchTaken(entrySegment, imlSegment);
 			// remove enterable flag from original segment
 			imlSegment->isEnterable = false;
 			imlSegment->enterPPCAddress = 0;
 		}
 	}
-}
-
-PPCRecImlInstruction_t* PPCRecompilerIML_getLastInstruction(PPCRecImlSegment_t* imlSegment)
-{
-	if (imlSegment->imlListCount == 0)
-		return nullptr;
-	return imlSegment->imlList + (imlSegment->imlListCount - 1);
-}
+}
\ No newline at end of file
diff --git a/src/Cafe/HW/Espresso/Recompiler/PPCRecompilerX64.cpp b/src/Cafe/HW/Espresso/Recompiler/PPCRecompilerX64.cpp
deleted file mode 100644
index 8e8a63d9..00000000
--- a/src/Cafe/HW/Espresso/Recompiler/PPCRecompilerX64.cpp
+++ /dev/null
@@ -1,2688 +0,0 @@
-#include "Cafe/HW/Espresso/PPCState.h"
-#include "Cafe/HW/Espresso/Interpreter/PPCInterpreterInternal.h"
-#include "Cafe/HW/Espresso/Interpreter/PPCInterpreterHelper.h"
-#include "PPCRecompiler.h"
-#include "PPCRecompilerIml.h"
-#include "PPCRecompilerX64.h"
-#include "Cafe/OS/libs/coreinit/coreinit_Time.h"
-
-#include "util/MemMapper/MemMapper.h"
-
-sint32 x64Gen_registerMap[12] = // virtual GPR to x64 register mapping
-{
-	REG_RAX, REG_RDX, REG_RBX, REG_RBP, REG_RSI, REG_RDI, REG_R8, REG_R9, REG_R10, REG_R11, REG_R12, REG_RCX
-};
-
-/*
-* Remember current instruction output offset for reloc
-* The instruction generated after this method has been called will be adjusted
-*/
-void PPCRecompilerX64Gen_rememberRelocatableOffset(x64GenContext_t* x64GenContext, uint8 type, void* extraInfo = nullptr)
-{
-	if( x64GenContext->relocateOffsetTableCount >= x64GenContext->relocateOffsetTableSize )
-	{
-		x64GenContext->relocateOffsetTableSize = std::max(4, x64GenContext->relocateOffsetTableSize*2);
-		x64GenContext->relocateOffsetTable = (x64RelocEntry_t*)realloc(x64GenContext->relocateOffsetTable, sizeof(x64RelocEntry_t)*x64GenContext->relocateOffsetTableSize);
-	}
-	x64GenContext->relocateOffsetTable[x64GenContext->relocateOffsetTableCount].offset = x64GenContext->codeBufferIndex;
-	x64GenContext->relocateOffsetTable[x64GenContext->relocateOffsetTableCount].type = type;
-	x64GenContext->relocateOffsetTable[x64GenContext->relocateOffsetTableCount].extraInfo = extraInfo;
-	x64GenContext->relocateOffsetTableCount++;
-}
-
-/*
-* Overwrites the currently cached (in x64 cf) cr* register
-* Should be called before each x64 instruction which overwrites the current status flags (with mappedCRRegister set to PPCREC_CR_TEMPORARY unless explicitly set by PPC instruction)
-*/
-void PPCRecompilerX64Gen_crConditionFlags_set(PPCRecFunction_t* PPCRecFunction, ppcImlGenContext_t* ppcImlGenContext, x64GenContext_t* x64GenContext, sint32 mappedCRRegister, sint32 crState)
-{
-	x64GenContext->activeCRRegister = mappedCRRegister;
-	x64GenContext->activeCRState = crState;
-}
-
-/*
-* Reset cached cr* register without storing it first
-*/
-void PPCRecompilerX64Gen_crConditionFlags_forget(PPCRecFunction_t* PPCRecFunction, ppcImlGenContext_t* ppcImlGenContext, x64GenContext_t* x64GenContext)
-{
-	x64GenContext->activeCRRegister = PPC_REC_INVALID_REGISTER;
-}
-
-void PPCRecompilerX64Gen_redirectRelativeJump(x64GenContext_t* x64GenContext, sint32 jumpInstructionOffset, sint32 destinationOffset)
-{
-	uint8* instructionData = x64GenContext->codeBuffer + jumpInstructionOffset;
-	if (instructionData[0] == 0x0F && (instructionData[1] >= 0x80 && instructionData[1] <= 0x8F))
-	{
-		// far conditional jump
-		*(uint32*)(instructionData + 2) = (destinationOffset - (jumpInstructionOffset + 6));
-	}
-	else if (instructionData[0] >= 0x70 && instructionData[0] <= 0x7F)
-	{
-		// short conditional jump
-		sint32 distance = (sint32)((destinationOffset - (jumpInstructionOffset + 2)));
-		cemu_assert_debug(distance >= -128 && distance <= 127);
-		*(uint8*)(instructionData + 1) = (uint8)distance;
-	}
-	else if (instructionData[0] == 0xE9)
-	{
-		*(uint32*)(instructionData + 1) = (destinationOffset - (jumpInstructionOffset + 5));
-	}
-	else if (instructionData[0] == 0xEB)
-	{
-		sint32 distance = (sint32)((destinationOffset - (jumpInstructionOffset + 2)));
-		cemu_assert_debug(distance >= -128 && distance <= 127);
-		*(uint8*)(instructionData + 1) = (uint8)distance;
-	}
-	else
-	{
-		assert_dbg();
-	}
-}
-
-void PPCRecompilerX64Gen_updateCRLogical(PPCRecFunction_t* PPCRecFunction, ppcImlGenContext_t* ppcImlGenContext, x64GenContext_t* x64GenContext, PPCRecImlInstruction_t* imlInstruction)
-{
-	sint32 crRegister = imlInstruction->crRegister;
-	if( (imlInstruction->crIgnoreMask&(1<<(crRegister*4+PPCREC_CR_BIT_LT))) == 0 )
-		x64Gen_setcc_mem8(x64GenContext, X86_CONDITION_SIGN, REG_RSP, offsetof(PPCInterpreter_t, cr)+sizeof(uint8)*(crRegister*4+PPCREC_CR_BIT_LT)); // check for sign instead of _BELOW (CF) which is not set by TEST
-	if( (imlInstruction->crIgnoreMask&(1<<(crRegister*4+PPCREC_CR_BIT_GT))) == 0 )
-		x64Gen_setcc_mem8(x64GenContext, X86_CONDITION_SIGNED_GREATER, REG_RSP, offsetof(PPCInterpreter_t, cr)+sizeof(uint8)*(crRegister*4+PPCREC_CR_BIT_GT));
-	if( (imlInstruction->crIgnoreMask&(1<<(crRegister*4+PPCREC_CR_BIT_EQ))) == 0 )
-		x64Gen_setcc_mem8(x64GenContext, X86_CONDITION_EQUAL, REG_RSP, offsetof(PPCInterpreter_t, cr)+sizeof(uint8)*(crRegister*4+PPCREC_CR_BIT_EQ));
-	// todo: Set CR SO if XER SO bit is set
-	PPCRecompilerX64Gen_crConditionFlags_set(PPCRecFunction, ppcImlGenContext, x64GenContext, crRegister, PPCREC_CR_STATE_TYPE_LOGICAL);
-}
-
-void* ATTR_MS_ABI PPCRecompiler_virtualHLE(PPCInterpreter_t* hCPU, uint32 hleFuncId)
-{
-	void* prevRSPTemp = hCPU->rspTemp;
-	if( hleFuncId == 0xFFD0 )
-	{
-		hCPU->remainingCycles -= 500; // let subtract about 500 cycles for each HLE call
-		hCPU->gpr[3] = 0;
-		PPCInterpreter_nextInstruction(hCPU);
-		return ppcInterpreterCurrentInstance;
-	}
-	else
-	{
-		auto hleCall = PPCInterpreter_getHLECall(hleFuncId);
-		cemu_assert(hleCall != nullptr);
-		hleCall(hCPU);
-	}
-	hCPU->rspTemp = prevRSPTemp;
-	return ppcInterpreterCurrentInstance;
-}
-
-void ATTR_MS_ABI PPCRecompiler_getTBL(PPCInterpreter_t* hCPU, uint32 gprIndex)
-{
-	uint64 coreTime = coreinit::coreinit_getTimerTick();
-	hCPU->gpr[gprIndex] = (uint32)(coreTime&0xFFFFFFFF);
-}
-
-void ATTR_MS_ABI PPCRecompiler_getTBU(PPCInterpreter_t* hCPU, uint32 gprIndex)
-{
-	uint64 coreTime = coreinit::coreinit_getTimerTick();
-	hCPU->gpr[gprIndex] = (uint32)((coreTime>>32)&0xFFFFFFFF);
-}
-
-bool PPCRecompilerX64Gen_imlInstruction_macro(PPCRecFunction_t* PPCRecFunction, ppcImlGenContext_t* ppcImlGenContext, x64GenContext_t* x64GenContext, PPCRecImlInstruction_t* imlInstruction)
-{
-	PPCRecompilerX64Gen_crConditionFlags_forget(PPCRecFunction, ppcImlGenContext, x64GenContext);
-	if( imlInstruction->operation == PPCREC_IML_MACRO_BLR || imlInstruction->operation == PPCREC_IML_MACRO_BLRL )
-	{
-		uint32 currentInstructionAddress = imlInstruction->op_macro.param;
-		// MOV EDX, [SPR_LR]
-		x64Emit_mov_reg64_mem32(x64GenContext, REG_RDX, REG_RSP, offsetof(PPCInterpreter_t, spr.LR));
-		// if BLRL, then update SPR LR
-		if (imlInstruction->operation == PPCREC_IML_MACRO_BLRL)
-			x64Gen_mov_mem32Reg64_imm32(x64GenContext, REG_RSP, offsetof(PPCInterpreter_t, spr.LR), currentInstructionAddress + 4);
-		// JMP [offset+RDX*(8/4)+R15]
-		x64Gen_writeU8(x64GenContext, 0x41);
-		x64Gen_writeU8(x64GenContext, 0xFF);
-		x64Gen_writeU8(x64GenContext, 0xA4);
-		x64Gen_writeU8(x64GenContext, 0x57);
-		x64Gen_writeU32(x64GenContext, (uint32)offsetof(PPCRecompilerInstanceData_t, ppcRecompilerDirectJumpTable));
-		return true;
-	}
-	else if( imlInstruction->operation == PPCREC_IML_MACRO_BCTR || imlInstruction->operation == PPCREC_IML_MACRO_BCTRL )
-	{
-		uint32 currentInstructionAddress = imlInstruction->op_macro.param;
-		// MOV EDX, [SPR_CTR]
-		x64Emit_mov_reg64_mem32(x64GenContext, REG_RDX, REG_RSP, offsetof(PPCInterpreter_t, spr.CTR));
-		// if BCTRL, then update SPR LR
-		if (imlInstruction->operation == PPCREC_IML_MACRO_BCTRL)
-			x64Gen_mov_mem32Reg64_imm32(x64GenContext, REG_RSP, offsetof(PPCInterpreter_t, spr.LR), currentInstructionAddress + 4);
-		// JMP [offset+RDX*(8/4)+R15]
-		x64Gen_writeU8(x64GenContext, 0x41);
-		x64Gen_writeU8(x64GenContext, 0xFF);
-		x64Gen_writeU8(x64GenContext, 0xA4);
-		x64Gen_writeU8(x64GenContext, 0x57);
-		x64Gen_writeU32(x64GenContext, (uint32)offsetof(PPCRecompilerInstanceData_t, ppcRecompilerDirectJumpTable));
-		return true;
-	}
-	else if( imlInstruction->operation == PPCREC_IML_MACRO_BL )
-	{
-		// MOV DWORD [SPR_LinkRegister], newLR
-		uint32 newLR = imlInstruction->op_macro.param + 4;
-		x64Gen_mov_mem32Reg64_imm32(x64GenContext, REG_RSP, offsetof(PPCInterpreter_t, spr.LR), newLR);
-		// remember new instruction pointer in RDX
-		uint32 newIP = imlInstruction->op_macro.param2;
-		x64Gen_mov_reg64Low32_imm32(x64GenContext, REG_RDX, newIP);
-		// since RDX is constant we can use JMP [R15+const_offset] if jumpTableOffset+RDX*2 does not exceed the 2GB boundary
-		uint64 lookupOffset = (uint64)offsetof(PPCRecompilerInstanceData_t, ppcRecompilerDirectJumpTable) + (uint64)newIP * 2ULL;
-		if (lookupOffset >= 0x80000000ULL)
-		{
-			// JMP [offset+RDX*(8/4)+R15]
-			x64Gen_writeU8(x64GenContext, 0x41);
-			x64Gen_writeU8(x64GenContext, 0xFF);
-			x64Gen_writeU8(x64GenContext, 0xA4);
-			x64Gen_writeU8(x64GenContext, 0x57);
-			x64Gen_writeU32(x64GenContext, (uint32)offsetof(PPCRecompilerInstanceData_t, ppcRecompilerDirectJumpTable));
-		}
-		else
-		{
-			x64Gen_writeU8(x64GenContext, 0x41);
-			x64Gen_writeU8(x64GenContext, 0xFF);
-			x64Gen_writeU8(x64GenContext, 0xA7);
-			x64Gen_writeU32(x64GenContext, (uint32)lookupOffset);
-		}
-		return true;
-	}
-	else if( imlInstruction->operation == PPCREC_IML_MACRO_B_FAR )
-	{
-		// remember new instruction pointer in RDX
-		uint32 newIP = imlInstruction->op_macro.param2;
-		x64Gen_mov_reg64Low32_imm32(x64GenContext, REG_RDX, newIP);
-		// Since RDX is constant we can use JMP [R15+const_offset] if jumpTableOffset+RDX*2 does not exceed the 2GB boundary
-		uint64 lookupOffset = (uint64)offsetof(PPCRecompilerInstanceData_t, ppcRecompilerDirectJumpTable) + (uint64)newIP * 2ULL;
-		if (lookupOffset >= 0x80000000ULL)
-		{
-			// JMP [offset+RDX*(8/4)+R15]
-			x64Gen_writeU8(x64GenContext, 0x41);
-			x64Gen_writeU8(x64GenContext, 0xFF);
-			x64Gen_writeU8(x64GenContext, 0xA4);
-			x64Gen_writeU8(x64GenContext, 0x57);
-			x64Gen_writeU32(x64GenContext, (uint32)offsetof(PPCRecompilerInstanceData_t, ppcRecompilerDirectJumpTable));
-		}
-		else
-		{
-			x64Gen_writeU8(x64GenContext, 0x41);
-			x64Gen_writeU8(x64GenContext, 0xFF);
-			x64Gen_writeU8(x64GenContext, 0xA7);
-			x64Gen_writeU32(x64GenContext, (uint32)lookupOffset);
-		}
-		return true;
-	}
-	else if( imlInstruction->operation == PPCREC_IML_MACRO_LEAVE )
-	{
-		uint32 currentInstructionAddress = imlInstruction->op_macro.param;
-		// remember PC value in REG_EDX
-		x64Gen_mov_reg64Low32_imm32(x64GenContext, REG_RDX, currentInstructionAddress);
-
-		uint32 newIP = 0; // special value for recompiler exit
-		uint64 lookupOffset = (uint64)&(((PPCRecompilerInstanceData_t*)NULL)->ppcRecompilerDirectJumpTable) + (uint64)newIP * 2ULL;
-		// JMP [R15+offset]
-		x64Gen_writeU8(x64GenContext, 0x41);
-		x64Gen_writeU8(x64GenContext, 0xFF);
-		x64Gen_writeU8(x64GenContext, 0xA7);
-		x64Gen_writeU32(x64GenContext, (uint32)lookupOffset);
-		return true;
-	}
-	else if( imlInstruction->operation == PPCREC_IML_MACRO_DEBUGBREAK )
-	{
-		x64Gen_mov_reg64Low32_imm32(x64GenContext, REG_RESV_TEMP, imlInstruction->op_macro.param2);
-		x64Gen_int3(x64GenContext);
-		return true;
-	}
-	else if( imlInstruction->operation == PPCREC_IML_MACRO_COUNT_CYCLES )
-	{
-		uint32 cycleCount = imlInstruction->op_macro.param;
-		x64Gen_sub_mem32reg64_imm32(x64GenContext, REG_RSP, offsetof(PPCInterpreter_t, remainingCycles), cycleCount);
-		return true;
-	}
-	else if( imlInstruction->operation == PPCREC_IML_MACRO_HLE )
-	{
-		uint32 ppcAddress = imlInstruction->op_macro.param;
-		uint32 funcId = imlInstruction->op_macro.param2;
-		//x64Gen_int3(x64GenContext);
-		// update instruction pointer
-		x64Gen_mov_mem32Reg64_imm32(x64GenContext, REG_RSP, offsetof(PPCInterpreter_t, instructionPointer), ppcAddress);
-		//// save hCPU (RSP)
-		//x64Gen_mov_reg64_imm64(x64GenContext, REG_RESV_TEMP, (uint64)&ppcRecompilerX64_hCPUTemp);
-		//x64Emit_mov_mem64_reg64(x64GenContext, REG_RESV_TEMP, 0, REG_RSP);
-		// set parameters
-		x64Gen_mov_reg64_reg64(x64GenContext, REG_RCX, REG_RSP);
-		x64Gen_mov_reg64_imm64(x64GenContext, REG_RDX, funcId);
-		// restore stackpointer from executionContext/hCPU->rspTemp
-		x64Emit_mov_reg64_mem64(x64GenContext, REG_RSP, REG_RESV_HCPU, offsetof(PPCInterpreter_t, rspTemp));
-		//x64Emit_mov_reg64_mem64(x64GenContext, REG_RSP, REG_R14, 0);
-		//x64Gen_int3(x64GenContext);
-		// reserve space on stack for call parameters
-		x64Gen_sub_reg64_imm32(x64GenContext, REG_RSP, 8*11); // must be uneven number in order to retain stack 0x10 alignment
-		x64Gen_mov_reg64_imm64(x64GenContext, REG_RBP, 0);
-		// call HLE function
-		x64Gen_mov_reg64_imm64(x64GenContext, REG_RAX, (uint64)PPCRecompiler_virtualHLE);
-		x64Gen_call_reg64(x64GenContext, REG_RAX);
-		// restore RSP to hCPU (from RAX, result of PPCRecompiler_virtualHLE)
-		//x64Gen_mov_reg64_imm64(x64GenContext, REG_RESV_TEMP, (uint64)&ppcRecompilerX64_hCPUTemp);
-		//x64Emit_mov_reg64_mem64Reg64(x64GenContext, REG_RSP, REG_RESV_TEMP, 0);
-		x64Gen_mov_reg64_reg64(x64GenContext, REG_RSP, REG_RAX);
-		// MOV R15, ppcRecompilerInstanceData
-		x64Gen_mov_reg64_imm64(x64GenContext, REG_R15, (uint64)ppcRecompilerInstanceData);
-		// MOV R13, memory_base
-		x64Gen_mov_reg64_imm64(x64GenContext, REG_R13, (uint64)memory_base);
-		// check if cycles where decreased beyond zero, if yes -> leave recompiler
-		x64Gen_bt_mem8(x64GenContext, REG_RSP, offsetof(PPCInterpreter_t, remainingCycles), 31); // check if negative
-		sint32 jumpInstructionOffset1 = x64GenContext->codeBufferIndex;
-		x64Gen_jmpc_near(x64GenContext, X86_CONDITION_NOT_CARRY, 0);
-		//x64Gen_int3(x64GenContext);
-		//x64Gen_mov_reg64Low32_imm32(x64GenContext, REG_RDX, ppcAddress);
-
-		x64Emit_mov_reg64_mem32(x64GenContext, REG_RDX, REG_RSP, offsetof(PPCInterpreter_t, instructionPointer));
-		// set EAX to 0 (we assume that ppcRecompilerDirectJumpTable[0] will be a recompiler escape function)
-		x64Gen_xor_reg32_reg32(x64GenContext, REG_RAX, REG_RAX);
-		// ADD RAX, R15 (R15 -> Pointer to ppcRecompilerInstanceData
-		x64Gen_add_reg64_reg64(x64GenContext, REG_RAX, REG_R15);
-		//// JMP [recompilerCallTable+EAX/4*8]
-		//x64Gen_int3(x64GenContext);
-		x64Gen_jmp_memReg64(x64GenContext, REG_RAX, (uint32)offsetof(PPCRecompilerInstanceData_t, ppcRecompilerDirectJumpTable));
-		PPCRecompilerX64Gen_redirectRelativeJump(x64GenContext, jumpInstructionOffset1, x64GenContext->codeBufferIndex);
-		// check if instruction pointer was changed
-		// assign new instruction pointer to EAX
-		x64Emit_mov_reg64_mem32(x64GenContext, REG_RAX, REG_RSP, offsetof(PPCInterpreter_t, instructionPointer));
-		// remember instruction pointer in REG_EDX
-		x64Gen_mov_reg64_reg64(x64GenContext, REG_RDX, REG_RAX);
-		// EAX *= 2
-		x64Gen_add_reg64_reg64(x64GenContext, REG_RAX, REG_RAX);
-		// ADD RAX, R15 (R15 -> Pointer to ppcRecompilerInstanceData
-		x64Gen_add_reg64_reg64(x64GenContext, REG_RAX, REG_R15);
-		// JMP [ppcRecompilerDirectJumpTable+RAX/4*8]
-		x64Gen_jmp_memReg64(x64GenContext, REG_RAX, (uint32)offsetof(PPCRecompilerInstanceData_t, ppcRecompilerDirectJumpTable));
-		return true;
-	}
-	else if( imlInstruction->operation == PPCREC_IML_MACRO_MFTB )
-	{
-		uint32 ppcAddress = imlInstruction->op_macro.param;
-		uint32 sprId = imlInstruction->op_macro.param2&0xFFFF;
-		uint32 gprIndex = (imlInstruction->op_macro.param2>>16)&0x1F;
-		// update instruction pointer
-		x64Gen_mov_mem32Reg64_imm32(x64GenContext, REG_RSP, offsetof(PPCInterpreter_t, instructionPointer), ppcAddress);
-		// set parameters
-		x64Gen_mov_reg64_reg64(x64GenContext, REG_RCX, REG_RSP);
-		x64Gen_mov_reg64_imm64(x64GenContext, REG_RDX, gprIndex);
-		// restore stackpointer to original RSP
-		x64Emit_mov_reg64_mem64(x64GenContext, REG_RSP, REG_RESV_HCPU, offsetof(PPCInterpreter_t, rspTemp));
-		// push hCPU on stack
-		x64Gen_push_reg64(x64GenContext, REG_RCX);
-		// reserve space on stack for call parameters
-		x64Gen_sub_reg64_imm32(x64GenContext, REG_RSP, 8*11 + 8);
-		x64Gen_mov_reg64_imm64(x64GenContext, REG_RBP, 0);
-		// call HLE function
-		if( sprId == SPR_TBL )
-			x64Gen_mov_reg64_imm64(x64GenContext, REG_RAX, (uint64)PPCRecompiler_getTBL);
-		else if( sprId == SPR_TBU )
-			x64Gen_mov_reg64_imm64(x64GenContext, REG_RAX, (uint64)PPCRecompiler_getTBU);
-		else
-			assert_dbg();
-		x64Gen_call_reg64(x64GenContext, REG_RAX);
-		// restore hCPU from stack
-		x64Gen_add_reg64_imm32(x64GenContext, REG_RSP, 8 * 11 + 8);
-		x64Gen_pop_reg64(x64GenContext, REG_RSP);
-		// MOV R15, ppcRecompilerInstanceData
-		x64Gen_mov_reg64_imm64(x64GenContext, REG_R15, (uint64)ppcRecompilerInstanceData);
-		// MOV R13, memory_base
-		x64Gen_mov_reg64_imm64(x64GenContext, REG_R13, (uint64)memory_base);
-		return true;
-	}
-	else
-	{
-		debug_printf("Unknown recompiler macro operation %d\n", imlInstruction->operation);
-		assert_dbg();
-	}
-	return false;
-}
-
-/*
-* Load from memory
-*/
-bool PPCRecompilerX64Gen_imlInstruction_load(PPCRecFunction_t* PPCRecFunction, ppcImlGenContext_t* ppcImlGenContext, x64GenContext_t* x64GenContext, PPCRecImlInstruction_t* imlInstruction, bool indexed)
-{
-	sint32 realRegisterData = tempToRealRegister(imlInstruction->op_storeLoad.registerData);
-	sint32 realRegisterMem = tempToRealRegister(imlInstruction->op_storeLoad.registerMem);
-	sint32 realRegisterMem2 = PPC_REC_INVALID_REGISTER;
-	if( indexed )
-		realRegisterMem2 = tempToRealRegister(imlInstruction->op_storeLoad.registerMem2);
-	if( false )//imlInstruction->op_storeLoad.flags & PPCREC_IML_OP_FLAG_FASTMEMACCESS )
-	{
-		// load u8/u16/u32 via direct memory access + optional sign extend
-		assert_dbg(); // todo
-	}
-	else
-	{
-		if( indexed && realRegisterMem == realRegisterMem2 )
-		{
-			return false;
-		}
-		if( indexed && realRegisterData == realRegisterMem2 )
-		{
-			// for indexed memory access realRegisterData must not be the same register as the second memory register,
-			// this can easily be fixed by swapping the logic of realRegisterMem and realRegisterMem2
-			sint32 temp = realRegisterMem;
-			realRegisterMem = realRegisterMem2;
-			realRegisterMem2 = temp;
-		}
-
-		bool signExtend = imlInstruction->op_storeLoad.flags2.signExtend;
-		bool switchEndian = imlInstruction->op_storeLoad.flags2.swapEndian;
-		if( imlInstruction->op_storeLoad.copyWidth == 32 )
-		{
-			//if( indexed )
-			//	PPCRecompilerX64Gen_crConditionFlags_forget(PPCRecFunction, ppcImlGenContext, x64GenContext);
-			if (indexed)
-			{
-				x64Gen_lea_reg64Low32_reg64Low32PlusReg64Low32(x64GenContext, REG_RESV_TEMP, realRegisterMem, realRegisterMem2);
-			}
-			if( hasMOVBESupport && switchEndian )
-			{
-				if (indexed)
-				{
-					x64Gen_movBEZeroExtend_reg64_mem32Reg64PlusReg64(x64GenContext, realRegisterData, REG_R13, REG_RESV_TEMP, imlInstruction->op_storeLoad.immS32);
-					//if (indexed && realRegisterMem != realRegisterData)
-					//	x64Gen_sub_reg64Low32_reg64Low32(x64GenContext, realRegisterMem, realRegisterMem2);
-				}
-				else
-				{
-					x64Gen_movBEZeroExtend_reg64_mem32Reg64PlusReg64(x64GenContext, realRegisterData, REG_R13, realRegisterMem, imlInstruction->op_storeLoad.immS32);
-				}
-			}
-			else
-			{
-				if (indexed)
-				{
-					x64Emit_mov_reg32_mem32(x64GenContext, realRegisterData, REG_R13, REG_RESV_TEMP, imlInstruction->op_storeLoad.immS32);
-					//if (realRegisterMem != realRegisterData)
-					//	x64Gen_sub_reg64Low32_reg64Low32(x64GenContext, realRegisterMem, realRegisterMem2);
-					if (switchEndian)
-						x64Gen_bswap_reg64Lower32bit(x64GenContext, realRegisterData);
-				}
-				else
-				{
-					x64Emit_mov_reg32_mem32(x64GenContext, realRegisterData, REG_R13, realRegisterMem, imlInstruction->op_storeLoad.immS32);
-					if (switchEndian)
-						x64Gen_bswap_reg64Lower32bit(x64GenContext, realRegisterData);
-				}
-			}
-		}
-		else if( imlInstruction->op_storeLoad.copyWidth == 16 )
-		{
-			PPCRecompilerX64Gen_crConditionFlags_forget(PPCRecFunction, ppcImlGenContext, x64GenContext); // todo: We can avoid this if MOVBE is available
-			if (indexed)
-			{
-				x64Gen_add_reg64Low32_reg64Low32(x64GenContext, realRegisterMem, realRegisterMem2);
-			}			
-			if( hasMOVBESupport && switchEndian )
-			{
-				x64Gen_movBEZeroExtend_reg64Low16_mem16Reg64PlusReg64(x64GenContext, realRegisterData, REG_R13, realRegisterMem, imlInstruction->op_storeLoad.immS32);
-				if( indexed && realRegisterMem != realRegisterData )
-					x64Gen_sub_reg64Low32_reg64Low32(x64GenContext, realRegisterMem, realRegisterMem2);
-			}
-			else
-			{
-				x64Gen_movZeroExtend_reg64Low16_mem16Reg64PlusReg64(x64GenContext, realRegisterData, REG_R13, realRegisterMem, imlInstruction->op_storeLoad.immS32);
-				if( indexed && realRegisterMem != realRegisterData )
-					x64Gen_sub_reg64Low32_reg64Low32(x64GenContext, realRegisterMem, realRegisterMem2);
-				if( switchEndian )
-					x64Gen_rol_reg64Low16_imm8(x64GenContext, realRegisterData, 8);
-			}
-			if( signExtend )
-				x64Gen_movSignExtend_reg64Low32_reg64Low16(x64GenContext, realRegisterData, realRegisterData);
-			else
-				x64Gen_movZeroExtend_reg64Low32_reg64Low16(x64GenContext, realRegisterData, realRegisterData);
-		}
-		else if( imlInstruction->op_storeLoad.copyWidth == 8 )
-		{
-			if( indexed )
-				PPCRecompilerX64Gen_crConditionFlags_forget(PPCRecFunction, ppcImlGenContext, x64GenContext);
-			// todo: Optimize by using only MOVZX/MOVSX
-			if( indexed )
-				x64Gen_add_reg64Low32_reg64Low32(x64GenContext, realRegisterMem, realRegisterMem2);
-			// todo: Use sign extend move from memory instead of separate sign-extend?
-			if( signExtend )
-				x64Gen_movSignExtend_reg64Low32_mem8Reg64PlusReg64(x64GenContext, realRegisterData, REG_R13, realRegisterMem, imlInstruction->op_storeLoad.immS32);
-			else
-				x64Emit_movZX_reg32_mem8(x64GenContext, realRegisterData, REG_R13, realRegisterMem, imlInstruction->op_storeLoad.immS32);
-			if( indexed && realRegisterMem != realRegisterData )
-				x64Gen_sub_reg64Low32_reg64Low32(x64GenContext, realRegisterMem, realRegisterMem2);
-		}
-		else if( imlInstruction->op_storeLoad.copyWidth == PPC_REC_LOAD_LWARX_MARKER )
-		{
-			PPCRecompilerX64Gen_crConditionFlags_forget(PPCRecFunction, ppcImlGenContext, x64GenContext);
-			if( imlInstruction->op_storeLoad.immS32 != 0 )
-				assert_dbg(); // not supported
-			if( indexed )
-				x64Gen_add_reg64Low32_reg64Low32(x64GenContext, realRegisterMem, realRegisterMem2);
-			x64Emit_mov_mem32_reg32(x64GenContext, REG_RSP, (uint32)offsetof(PPCInterpreter_t, reservedMemAddr), realRegisterMem); // remember EA for reservation
-			x64Emit_mov_reg32_mem32(x64GenContext, realRegisterData, REG_R13, realRegisterMem, imlInstruction->op_storeLoad.immS32);
-			if( indexed && realRegisterMem != realRegisterData )
-				x64Gen_sub_reg64Low32_reg64Low32(x64GenContext, realRegisterMem, realRegisterMem2);
-			if( switchEndian )
-				x64Gen_bswap_reg64Lower32bit(x64GenContext, realRegisterData);
-			x64Emit_mov_mem32_reg32(x64GenContext, REG_RSP, (uint32)offsetof(PPCInterpreter_t, reservedMemValue), realRegisterData); // remember value for reservation
-			// LWARX instruction costs extra cycles (this speeds up busy loops)
-			x64Gen_sub_mem32reg64_imm32(x64GenContext, REG_RSP, offsetof(PPCInterpreter_t, remainingCycles), 20);
-		}
-		else if( imlInstruction->op_storeLoad.copyWidth == PPC_REC_STORE_LSWI_3 )
-		{
-			PPCRecompilerX64Gen_crConditionFlags_forget(PPCRecFunction, ppcImlGenContext, x64GenContext);
-			if( switchEndian == false )
-				assert_dbg();
-			if( indexed )
-				x64Gen_add_reg64Low32_reg64Low32(x64GenContext, realRegisterMem, realRegisterMem2); // can be replaced with LEA temp, [memReg1+memReg2] (this way we can avoid the SUB instruction after the move)
-			if( hasMOVBESupport )
-			{
-				x64Gen_movBEZeroExtend_reg64_mem32Reg64PlusReg64(x64GenContext, realRegisterData, REG_R13, realRegisterMem, imlInstruction->op_storeLoad.immS32);
-				if( indexed && realRegisterMem != realRegisterData )
-					x64Gen_sub_reg64Low32_reg64Low32(x64GenContext, realRegisterMem, realRegisterMem2);
-			}
-			else
-			{
-				x64Emit_mov_reg32_mem32(x64GenContext, realRegisterData, REG_R13, realRegisterMem, imlInstruction->op_storeLoad.immS32);
-				if( indexed && realRegisterMem != realRegisterData )
-					x64Gen_sub_reg64Low32_reg64Low32(x64GenContext, realRegisterMem, realRegisterMem2);
-				x64Gen_bswap_reg64Lower32bit(x64GenContext, realRegisterData);
-			}
-			x64Gen_and_reg64Low32_imm32(x64GenContext, realRegisterData, 0xFFFFFF00);
-		}
-		else
-			return false;
-		return true;
-	}
-	return false;
-}
-
-/*
-* Write to memory
-*/
-bool PPCRecompilerX64Gen_imlInstruction_store(PPCRecFunction_t* PPCRecFunction, ppcImlGenContext_t* ppcImlGenContext, x64GenContext_t* x64GenContext, PPCRecImlInstruction_t* imlInstruction, bool indexed)
-{
-	sint32 realRegisterData = tempToRealRegister(imlInstruction->op_storeLoad.registerData);
-	sint32 realRegisterMem = tempToRealRegister(imlInstruction->op_storeLoad.registerMem);
-	sint32 realRegisterMem2 = PPC_REC_INVALID_REGISTER;
-	if (indexed)
-		realRegisterMem2 = tempToRealRegister(imlInstruction->op_storeLoad.registerMem2);
-
-	if (false)//imlInstruction->op_storeLoad.flags & PPCREC_IML_OP_FLAG_FASTMEMACCESS )
-	{
-		// load u8/u16/u32 via direct memory access + optional sign extend
-		assert_dbg(); // todo
-	}
-	else
-	{
-		if (indexed && realRegisterMem == realRegisterMem2)
-		{
-			return false;
-		}
-		if (indexed && realRegisterData == realRegisterMem2)
-		{
-			// for indexed memory access realRegisterData must not be the same register as the second memory register,
-			// this can easily be fixed by swapping the logic of realRegisterMem and realRegisterMem2
-			sint32 temp = realRegisterMem;
-			realRegisterMem = realRegisterMem2;
-			realRegisterMem2 = temp;
-		}
-
-		bool signExtend = imlInstruction->op_storeLoad.flags2.signExtend;
-		bool swapEndian = imlInstruction->op_storeLoad.flags2.swapEndian;
-		if (imlInstruction->op_storeLoad.copyWidth == 32)
-		{
-			if (indexed)
-				PPCRecompilerX64Gen_crConditionFlags_forget(PPCRecFunction, ppcImlGenContext, x64GenContext);
-			uint32 valueRegister;
-			if ((swapEndian == false || hasMOVBESupport) && realRegisterMem != realRegisterData)
-			{
-				valueRegister = realRegisterData;
-			}
-			else
-			{
-				x64Gen_mov_reg64_reg64(x64GenContext, REG_RESV_TEMP, realRegisterData);
-				valueRegister = REG_RESV_TEMP;
-			}
-			if (hasMOVBESupport == false && swapEndian)
-				x64Gen_bswap_reg64Lower32bit(x64GenContext, valueRegister);
-			if (indexed)
-				x64Gen_add_reg64Low32_reg64Low32(x64GenContext, realRegisterMem, realRegisterMem2);
-			if (hasMOVBESupport && swapEndian)
-				x64Gen_movBETruncate_mem32Reg64PlusReg64_reg64(x64GenContext, REG_R13, realRegisterMem, imlInstruction->op_storeLoad.immS32, valueRegister);
-			else
-				x64Gen_movTruncate_mem32Reg64PlusReg64_reg64(x64GenContext, REG_R13, realRegisterMem, imlInstruction->op_storeLoad.immS32, valueRegister);
-			if (indexed)
-				x64Gen_sub_reg64Low32_reg64Low32(x64GenContext, realRegisterMem, realRegisterMem2);
-		}
-		else if (imlInstruction->op_storeLoad.copyWidth == 16)
-		{
-			if (indexed || swapEndian)
-				PPCRecompilerX64Gen_crConditionFlags_forget(PPCRecFunction, ppcImlGenContext, x64GenContext);
-			x64Gen_mov_reg64_reg64(x64GenContext, REG_RESV_TEMP, realRegisterData);
-			if (swapEndian)
-				x64Gen_rol_reg64Low16_imm8(x64GenContext, REG_RESV_TEMP, 8);
-			if (indexed)
-				x64Gen_add_reg64Low32_reg64Low32(x64GenContext, realRegisterMem, realRegisterMem2);
-			x64Gen_movTruncate_mem16Reg64PlusReg64_reg64(x64GenContext, REG_R13, realRegisterMem, imlInstruction->op_storeLoad.immS32, REG_RESV_TEMP);
-			if (indexed)
-				x64Gen_sub_reg64Low32_reg64Low32(x64GenContext, realRegisterMem, realRegisterMem2);
-			// todo: Optimize this, e.g. by using MOVBE
-		}
-		else if (imlInstruction->op_storeLoad.copyWidth == 8)
-		{
-			if (indexed)
-				PPCRecompilerX64Gen_crConditionFlags_forget(PPCRecFunction, ppcImlGenContext, x64GenContext);
-			if (indexed && realRegisterMem == realRegisterData)
-			{
-				x64Gen_mov_reg64_reg64(x64GenContext, REG_RESV_TEMP, realRegisterData);
-				realRegisterData = REG_RESV_TEMP;
-			}
-			if (indexed)
-				x64Gen_add_reg64Low32_reg64Low32(x64GenContext, realRegisterMem, realRegisterMem2);
-			x64Gen_movTruncate_mem8Reg64PlusReg64_reg64(x64GenContext, REG_RESV_MEMBASE, realRegisterMem, imlInstruction->op_storeLoad.immS32, realRegisterData);
-			if (indexed)
-				x64Gen_sub_reg64Low32_reg64Low32(x64GenContext, realRegisterMem, realRegisterMem2);
-		}
-		else if (imlInstruction->op_storeLoad.copyWidth == PPC_REC_STORE_STWCX_MARKER)
-		{
-			PPCRecompilerX64Gen_crConditionFlags_forget(PPCRecFunction, ppcImlGenContext, x64GenContext);
-			if (imlInstruction->op_storeLoad.immS32 != 0)
-				assert_dbg(); // todo
-								// reset cr0 LT, GT and EQ
-			sint32 crRegister = 0;
-			x64Gen_mov_mem8Reg64_imm8(x64GenContext, REG_RSP, offsetof(PPCInterpreter_t, cr) + sizeof(uint8)*(crRegister * 4 + PPCREC_CR_BIT_LT), 0);
-			x64Gen_mov_mem8Reg64_imm8(x64GenContext, REG_RSP, offsetof(PPCInterpreter_t, cr) + sizeof(uint8)*(crRegister * 4 + PPCREC_CR_BIT_GT), 0);
-			x64Gen_mov_mem8Reg64_imm8(x64GenContext, REG_RSP, offsetof(PPCInterpreter_t, cr) + sizeof(uint8)*(crRegister * 4 + PPCREC_CR_BIT_EQ), 0);
-			// calculate effective address
-			x64Gen_mov_reg64_reg64(x64GenContext, REG_RESV_TEMP, realRegisterData);
-			if (swapEndian)
-				x64Gen_bswap_reg64Lower32bit(x64GenContext, REG_RESV_TEMP);
-			if (indexed)
-				x64Gen_add_reg64Low32_reg64Low32(x64GenContext, realRegisterMem, realRegisterMem2);
-			// realRegisterMem now holds EA
-			x64Gen_cmp_reg64Low32_mem32reg64(x64GenContext, realRegisterMem, REG_RESV_HCPU, offsetof(PPCInterpreter_t, reservedMemAddr));
-			sint32 jumpInstructionOffsetJumpToEnd = x64GenContext->codeBufferIndex;
-			x64Gen_jmpc_near(x64GenContext, X86_CONDITION_NOT_EQUAL, 0);
-			// EA matches reservation
-			// backup EAX (since it's an explicit operand of CMPXCHG and will be overwritten)
-			x64Emit_mov_mem32_reg32(x64GenContext, REG_RSP, (uint32)offsetof(PPCInterpreter_t, temporaryGPR[0]), REG_EAX);
-			// backup REG_RESV_MEMBASE
-			x64Emit_mov_mem64_reg64(x64GenContext, REG_RESV_HCPU, (uint32)offsetof(PPCInterpreter_t, temporaryGPR[2]), REG_RESV_MEMBASE);
-			// add mem register to REG_RESV_MEMBASE
-			x64Gen_add_reg64_reg64(x64GenContext, REG_RESV_MEMBASE, realRegisterMem);
-			// load reserved value in EAX
-			x64Emit_mov_reg64_mem32(x64GenContext, REG_EAX, REG_RESV_HCPU, offsetof(PPCInterpreter_t, reservedMemValue));
-			// bswap EAX
-			x64Gen_bswap_reg64Lower32bit(x64GenContext, REG_EAX);
-
-			//x64Gen_lock_cmpxchg_mem32Reg64PlusReg64_reg64(x64GenContext, REG_RESV_MEMBASE, realRegisterMem, 0, REG_RESV_TEMP);
-			x64Gen_lock_cmpxchg_mem32Reg64_reg64(x64GenContext, REG_RESV_MEMBASE, 0, REG_RESV_TEMP);
-
-			x64Gen_setcc_mem8(x64GenContext, X86_CONDITION_EQUAL, REG_RSP, offsetof(PPCInterpreter_t, cr) + sizeof(uint8)*(crRegister * 4 + PPCREC_CR_BIT_EQ));
-
-			// reset reservation
-			x64Gen_mov_mem32Reg64_imm32(x64GenContext, REG_RESV_HCPU, (uint32)offsetof(PPCInterpreter_t, reservedMemAddr), 0);
-			x64Gen_mov_mem32Reg64_imm32(x64GenContext, REG_RESV_HCPU, (uint32)offsetof(PPCInterpreter_t, reservedMemValue), 0);
-
-			// restore EAX
-			x64Emit_mov_reg64_mem32(x64GenContext, REG_EAX, REG_RESV_HCPU, (uint32)offsetof(PPCInterpreter_t, temporaryGPR[0]));
-			// restore REG_RESV_MEMBASE
-			x64Emit_mov_reg64_mem64(x64GenContext, REG_RESV_MEMBASE, REG_RESV_HCPU, (uint32)offsetof(PPCInterpreter_t, temporaryGPR[2]));
-
-			// copy XER SO to CR0 SO
-			x64Gen_bt_mem8(x64GenContext, REG_RSP, offsetof(PPCInterpreter_t, spr.XER), 31);
-			x64Gen_setcc_mem8(x64GenContext, X86_CONDITION_CARRY, REG_RESV_HCPU, offsetof(PPCInterpreter_t, cr) + sizeof(uint8)*(crRegister * 4 + PPCREC_CR_BIT_SO));
-			// end
-			PPCRecompilerX64Gen_redirectRelativeJump(x64GenContext, jumpInstructionOffsetJumpToEnd, x64GenContext->codeBufferIndex);
-		}
-		else if (imlInstruction->op_storeLoad.copyWidth == PPC_REC_STORE_STSWI_2)
-		{
-			PPCRecompilerX64Gen_crConditionFlags_forget(PPCRecFunction, ppcImlGenContext, x64GenContext);
-			x64Gen_mov_reg64_reg64(x64GenContext, REG_RESV_TEMP, realRegisterData);
-			x64Gen_shr_reg64Low32_imm8(x64GenContext, REG_RESV_TEMP, 16); // store upper 2 bytes ..
-			x64Gen_rol_reg64Low16_imm8(x64GenContext, REG_RESV_TEMP, 8); // .. as big-endian
-			if (indexed)
-				x64Gen_add_reg64Low32_reg64Low32(x64GenContext, realRegisterMem, realRegisterMem2);
-
-			x64Gen_movTruncate_mem16Reg64PlusReg64_reg64(x64GenContext, REG_R13, realRegisterMem, imlInstruction->op_storeLoad.immS32, REG_RESV_TEMP);
-			if (indexed)
-				x64Gen_sub_reg64Low32_reg64Low32(x64GenContext, realRegisterMem, realRegisterMem2);
-		}
-		else if (imlInstruction->op_storeLoad.copyWidth == PPC_REC_STORE_STSWI_3)
-		{
-			PPCRecompilerX64Gen_crConditionFlags_forget(PPCRecFunction, ppcImlGenContext, x64GenContext);
-			x64Gen_mov_reg64_reg64(x64GenContext, REG_RESV_TEMP, realRegisterData);
-			if (indexed)
-				x64Gen_add_reg64Low32_reg64Low32(x64GenContext, realRegisterMem, realRegisterMem2);
-
-			x64Gen_shr_reg64Low32_imm8(x64GenContext, REG_RESV_TEMP, 8);
-			x64Gen_movTruncate_mem8Reg64PlusReg64_reg64(x64GenContext, REG_R13, realRegisterMem, imlInstruction->op_storeLoad.immS32 + 2, REG_RESV_TEMP);
-			x64Gen_shr_reg64Low32_imm8(x64GenContext, REG_RESV_TEMP, 8);
-			x64Gen_movTruncate_mem8Reg64PlusReg64_reg64(x64GenContext, REG_R13, realRegisterMem, imlInstruction->op_storeLoad.immS32 + 1, REG_RESV_TEMP);
-			x64Gen_shr_reg64Low32_imm8(x64GenContext, REG_RESV_TEMP, 8);
-			x64Gen_movTruncate_mem8Reg64PlusReg64_reg64(x64GenContext, REG_R13, realRegisterMem, imlInstruction->op_storeLoad.immS32 + 0, REG_RESV_TEMP);
-
-			if (indexed)
-				x64Gen_sub_reg64Low32_reg64Low32(x64GenContext, realRegisterMem, realRegisterMem2);
-		}
-		else
-			return false;
-		return true;
-	}
-	return false;
-}
-
-/*
- * Copy byte/word/dword from memory to memory
- */
-void PPCRecompilerX64Gen_imlInstruction_mem2mem(PPCRecFunction_t* PPCRecFunction, ppcImlGenContext_t* ppcImlGenContext, x64GenContext_t* x64GenContext, PPCRecImlInstruction_t* imlInstruction)
-{
-	sint32 realSrcMemReg = tempToRealRegister(imlInstruction->op_mem2mem.src.registerMem);
-	sint32 realSrcMemImm = imlInstruction->op_mem2mem.src.immS32;
-	sint32 realDstMemReg = tempToRealRegister(imlInstruction->op_mem2mem.dst.registerMem);
-	sint32 realDstMemImm = imlInstruction->op_mem2mem.dst.immS32;
-	// PPCRecompilerX64Gen_crConditionFlags_forget() is not needed here, since MOVs don't affect eflags
-	if (imlInstruction->op_mem2mem.copyWidth == 32)
-	{
-		x64Emit_mov_reg32_mem32(x64GenContext, REG_RESV_TEMP, REG_R13, realSrcMemReg, realSrcMemImm);
-		x64Gen_movTruncate_mem32Reg64PlusReg64_reg64(x64GenContext, REG_R13, realDstMemReg, realDstMemImm, REG_RESV_TEMP);
-	}
-	else
-	{
-		assert_dbg();
-	}
-}
-
-bool PPCRecompilerX64Gen_imlInstruction_r_r(PPCRecFunction_t* PPCRecFunction, ppcImlGenContext_t* ppcImlGenContext, x64GenContext_t* x64GenContext, PPCRecImlInstruction_t* imlInstruction)
-{
-	if (imlInstruction->operation == PPCREC_IML_OP_ASSIGN)
-	{
-		// registerResult = registerA
-		if (imlInstruction->crRegister != PPC_REC_INVALID_REGISTER)
-		{
-			x64Gen_mov_reg64_reg64(x64GenContext, tempToRealRegister(imlInstruction->op_r_r.registerResult), tempToRealRegister(imlInstruction->op_r_r.registerA));
-			if (imlInstruction->crMode == PPCREC_CR_MODE_LOGICAL)
-			{
-				// since MOV doesn't set eflags we need another test instruction
-				x64Gen_test_reg64Low32_reg64Low32(x64GenContext, tempToRealRegister(imlInstruction->op_r_r.registerResult), tempToRealRegister(imlInstruction->op_r_r.registerResult));
-				// set cr bits
-				PPCRecompilerX64Gen_updateCRLogical(PPCRecFunction, ppcImlGenContext, x64GenContext, imlInstruction);
-			}
-			else
-			{
-				assert_dbg();
-			}
-		}
-		else
-		{
-			x64Gen_mov_reg64Low32_reg64Low32(x64GenContext, tempToRealRegister(imlInstruction->op_r_r.registerResult), tempToRealRegister(imlInstruction->op_r_r.registerA));
-		}
-	}
-	else if (imlInstruction->operation == PPCREC_IML_OP_ENDIAN_SWAP)
-	{
-		// registerResult = endianSwap32(registerA)
-		if (imlInstruction->op_r_r.registerA != imlInstruction->op_r_r.registerResult)
-			assert_dbg();
-		x64Gen_bswap_reg64Lower32bit(x64GenContext, tempToRealRegister(imlInstruction->op_r_r.registerResult));
-	}
-	else if( imlInstruction->operation == PPCREC_IML_OP_ADD )
-	{
-		// registerResult += registerA
-		PPCRecompilerX64Gen_crConditionFlags_forget(PPCRecFunction, ppcImlGenContext, x64GenContext);
-		cemu_assert_debug(imlInstruction->crRegister == PPC_REC_INVALID_REGISTER);
-		x64Gen_add_reg64Low32_reg64Low32(x64GenContext, tempToRealRegister(imlInstruction->op_r_r.registerResult), tempToRealRegister(imlInstruction->op_r_r.registerA));
-	}
-	else if( imlInstruction->operation == PPCREC_IML_OP_ASSIGN_S8_TO_S32 )
-	{
-		PPCRecompilerX64Gen_crConditionFlags_forget(PPCRecFunction, ppcImlGenContext, x64GenContext);
-		x64Gen_movSignExtend_reg64Low32_reg64Low8(x64GenContext, tempToRealRegister(imlInstruction->op_r_r.registerResult), tempToRealRegister(imlInstruction->op_r_r.registerA));
-		if( imlInstruction->crRegister != PPC_REC_INVALID_REGISTER )
-		{
-			if( imlInstruction->crMode == PPCREC_CR_MODE_ARITHMETIC )
-			{
-				x64Gen_test_reg64Low32_reg64Low32(x64GenContext, tempToRealRegister(imlInstruction->op_r_r.registerResult), tempToRealRegister(imlInstruction->op_r_r.registerResult));
-				// set cr bits
-				PPCRecompilerX64Gen_updateCRLogical(PPCRecFunction, ppcImlGenContext, x64GenContext, imlInstruction);
-			}
-			else
-			{
-				debug_printf("PPCRecompilerX64Gen_imlInstruction_r_r(): Unsupported operation\n");
-				assert_dbg();
-			}
-		}
-	}
-	else if( imlInstruction->operation == PPCREC_IML_OP_OR || imlInstruction->operation == PPCREC_IML_OP_AND || imlInstruction->operation == PPCREC_IML_OP_XOR )
-	{
-		PPCRecompilerX64Gen_crConditionFlags_forget(PPCRecFunction, ppcImlGenContext, x64GenContext);
-		if( imlInstruction->operation == PPCREC_IML_OP_OR )
-		{
-			// registerResult |= registerA
-			x64Gen_or_reg64Low32_reg64Low32(x64GenContext, tempToRealRegister(imlInstruction->op_r_r.registerResult), tempToRealRegister(imlInstruction->op_r_r.registerA));
-		}
-		else if( imlInstruction->operation == PPCREC_IML_OP_AND )
-		{
-			// registerResult &= registerA
-			x64Gen_and_reg64Low32_reg64Low32(x64GenContext, tempToRealRegister(imlInstruction->op_r_r.registerResult), tempToRealRegister(imlInstruction->op_r_r.registerA));
-		}
-		else
-		{
-			// registerResult ^= registerA
-			x64Gen_xor_reg64Low32_reg64Low32(x64GenContext, tempToRealRegister(imlInstruction->op_r_r.registerResult), tempToRealRegister(imlInstruction->op_r_r.registerA));
-		}
-		if( imlInstruction->crRegister != PPC_REC_INVALID_REGISTER )
-		{
-			// set cr bits
-			PPCRecompilerX64Gen_updateCRLogical(PPCRecFunction, ppcImlGenContext, x64GenContext, imlInstruction);
-		}
-	}
-	else if( imlInstruction->operation == PPCREC_IML_OP_NOT )
-	{
-		// copy register content if different registers
-		PPCRecompilerX64Gen_crConditionFlags_forget(PPCRecFunction, ppcImlGenContext, x64GenContext);
-		if( imlInstruction->op_r_r.registerResult != imlInstruction->op_r_r.registerA )
-		{
-			x64Gen_mov_reg64_reg64(x64GenContext, tempToRealRegister(imlInstruction->op_r_r.registerResult), tempToRealRegister(imlInstruction->op_r_r.registerA));
-		}
-		// NOT destination register
-		x64Gen_not_reg64Low32(x64GenContext, tempToRealRegister(imlInstruction->op_r_r.registerResult));
-		// update cr bits
-		if( imlInstruction->crRegister != PPC_REC_INVALID_REGISTER )
-		{
-			// NOT instruction does not update flags, so we have to generate an additional TEST instruction
-			x64Gen_test_reg64Low32_reg64Low32(x64GenContext, tempToRealRegister(imlInstruction->op_r_r.registerResult), tempToRealRegister(imlInstruction->op_r_r.registerResult));
-			// set cr bits
-			PPCRecompilerX64Gen_updateCRLogical(PPCRecFunction, ppcImlGenContext, x64GenContext, imlInstruction);
-		}
-	}
-	else if( imlInstruction->operation == PPCREC_IML_OP_CNTLZW )
-	{
-		// count leading zeros
-		PPCRecompilerX64Gen_crConditionFlags_forget(PPCRecFunction, ppcImlGenContext, x64GenContext);
-		cemu_assert_debug(imlInstruction->crRegister == PPC_REC_INVALID_REGISTER);
-		// LZCNT instruction (part of SSE4, CPUID.80000001H:ECX.ABM[Bit 5])
-		if( hasLZCNTSupport )
-		{
-			x64Gen_lzcnt_reg64Low32_reg64Low32(x64GenContext, tempToRealRegister(imlInstruction->op_r_r.registerResult), tempToRealRegister(imlInstruction->op_r_r.registerA));
-		}
-		else
-		{
-			x64Gen_test_reg64Low32_reg64Low32(x64GenContext, tempToRealRegister(imlInstruction->op_r_r.registerA), tempToRealRegister(imlInstruction->op_r_r.registerA));
-			sint32 jumpInstructionOffset1 = x64GenContext->codeBufferIndex;
-			x64Gen_jmpc_near(x64GenContext, X86_CONDITION_EQUAL, 0);
-			x64Gen_bsr_reg64Low32_reg64Low32(x64GenContext, tempToRealRegister(imlInstruction->op_r_r.registerResult), tempToRealRegister(imlInstruction->op_r_r.registerA));
-			x64Gen_neg_reg64Low32(x64GenContext, tempToRealRegister(imlInstruction->op_r_r.registerResult));
-			x64Gen_add_reg64Low32_imm32(x64GenContext, tempToRealRegister(imlInstruction->op_r_r.registerResult), 32-1);
-			sint32 jumpInstructionOffset2 = x64GenContext->codeBufferIndex;
-			x64Gen_jmpc_near(x64GenContext, X86_CONDITION_NONE, 0);
-			PPCRecompilerX64Gen_redirectRelativeJump(x64GenContext, jumpInstructionOffset1, x64GenContext->codeBufferIndex);
-			x64Gen_mov_reg64Low32_imm32(x64GenContext, tempToRealRegister(imlInstruction->op_r_r.registerResult), 32);
-			PPCRecompilerX64Gen_redirectRelativeJump(x64GenContext, jumpInstructionOffset2, x64GenContext->codeBufferIndex);
-		}
-	}
-	else if( imlInstruction->operation == PPCREC_IML_OP_COMPARE_SIGNED || imlInstruction->operation == PPCREC_IML_OP_COMPARE_UNSIGNED )
-	{
-		// registerA CMP registerB (arithmetic compare)
-		PPCRecompilerX64Gen_crConditionFlags_forget(PPCRecFunction, ppcImlGenContext, x64GenContext);
-		if( imlInstruction->crRegister == PPC_REC_INVALID_REGISTER )
-		{
-			return false; // a NO-OP instruction
-		}
-		if( imlInstruction->crRegister >= 8 )
-		{
-			return false;
-		}
-		// update state of cr register
-		if( imlInstruction->operation == PPCREC_IML_OP_COMPARE_SIGNED )
-			PPCRecompilerX64Gen_crConditionFlags_set(PPCRecFunction, ppcImlGenContext, x64GenContext, imlInstruction->crRegister, PPCREC_CR_STATE_TYPE_SIGNED_ARITHMETIC);
-		else
-			PPCRecompilerX64Gen_crConditionFlags_set(PPCRecFunction, ppcImlGenContext, x64GenContext, imlInstruction->crRegister, PPCREC_CR_STATE_TYPE_UNSIGNED_ARITHMETIC);
-		// create compare instruction
-		x64Gen_cmp_reg64Low32_reg64Low32(x64GenContext, tempToRealRegister(imlInstruction->op_r_r.registerResult), tempToRealRegister(imlInstruction->op_r_r.registerA));
-		// set cr bits
-		sint32 crRegister = imlInstruction->crRegister;
-		if( imlInstruction->operation == PPCREC_IML_OP_COMPARE_SIGNED )
-		{
-			if( (imlInstruction->crIgnoreMask&(1<<(crRegister*4+PPCREC_CR_BIT_LT))) == 0 )
-				x64Gen_setcc_mem8(x64GenContext, X86_CONDITION_SIGNED_LESS, REG_ESP, offsetof(PPCInterpreter_t, cr)+sizeof(uint8)*(crRegister*4+PPCREC_CR_BIT_LT));
-			if( (imlInstruction->crIgnoreMask&(1<<(crRegister*4+PPCREC_CR_BIT_GT))) == 0 )
-				x64Gen_setcc_mem8(x64GenContext, X86_CONDITION_SIGNED_GREATER, REG_ESP, offsetof(PPCInterpreter_t, cr)+sizeof(uint8)*(crRegister*4+PPCREC_CR_BIT_GT));
-			if( (imlInstruction->crIgnoreMask&(1<<(crRegister*4+PPCREC_CR_BIT_EQ))) == 0 )
-				x64Gen_setcc_mem8(x64GenContext, X86_CONDITION_EQUAL, REG_ESP, offsetof(PPCInterpreter_t, cr)+sizeof(uint8)*(crRegister*4+PPCREC_CR_BIT_EQ));
-			// todo: Also set summary overflow if xer bit is set
-		}
-		else if( imlInstruction->operation == PPCREC_IML_OP_COMPARE_UNSIGNED )
-		{
-			if( (imlInstruction->crIgnoreMask&(1<<(crRegister*4+PPCREC_CR_BIT_LT))) == 0 )
-				x64Gen_setcc_mem8(x64GenContext, X86_CONDITION_UNSIGNED_BELOW, REG_ESP, offsetof(PPCInterpreter_t, cr)+sizeof(uint8)*(crRegister*4+PPCREC_CR_BIT_LT));
-			if( (imlInstruction->crIgnoreMask&(1<<(crRegister*4+PPCREC_CR_BIT_GT))) == 0 )
-				x64Gen_setcc_mem8(x64GenContext, X86_CONDITION_UNSIGNED_ABOVE, REG_ESP, offsetof(PPCInterpreter_t, cr)+sizeof(uint8)*(crRegister*4+PPCREC_CR_BIT_GT));
-			if( (imlInstruction->crIgnoreMask&(1<<(crRegister*4+PPCREC_CR_BIT_EQ))) == 0 )
-				x64Gen_setcc_mem8(x64GenContext, X86_CONDITION_EQUAL, REG_ESP, offsetof(PPCInterpreter_t, cr)+sizeof(uint8)*(crRegister*4+PPCREC_CR_BIT_EQ));
-			// todo: Also set summary overflow if xer bit is set
-		}
-		else
-			assert_dbg();
-	}
-	else if( imlInstruction->operation == PPCREC_IML_OP_NEG )
-	{
-		// copy register content if different registers
-		PPCRecompilerX64Gen_crConditionFlags_forget(PPCRecFunction, ppcImlGenContext, x64GenContext);
-		if( imlInstruction->op_r_r.registerResult != imlInstruction->op_r_r.registerA )
-		{
-			x64Gen_mov_reg64_reg64(x64GenContext, tempToRealRegister(imlInstruction->op_r_r.registerResult), tempToRealRegister(imlInstruction->op_r_r.registerA));
-		}
-		// NEG destination register
-		x64Gen_neg_reg64Low32(x64GenContext, tempToRealRegister(imlInstruction->op_r_r.registerResult));
-		// update cr bits
-		if( imlInstruction->crRegister != PPC_REC_INVALID_REGISTER )
-		{
-			// set cr bits
-			PPCRecompilerX64Gen_updateCRLogical(PPCRecFunction, ppcImlGenContext, x64GenContext, imlInstruction);
-		}
-	}
-	else if( imlInstruction->operation == PPCREC_IML_OP_ADD_CARRY )
-	{
-		PPCRecompilerX64Gen_crConditionFlags_forget(PPCRecFunction, ppcImlGenContext, x64GenContext);
-		// copy operand to result if different registers
-		if( imlInstruction->op_r_r.registerResult != imlInstruction->op_r_r.registerA )
-		{
-			x64Gen_mov_reg64_reg64(x64GenContext, tempToRealRegister(imlInstruction->op_r_r.registerResult), tempToRealRegister(imlInstruction->op_r_r.registerA));
-		}
-		// copy xer_ca to eflags carry
-		x64Gen_bt_mem8(x64GenContext, REG_RSP, offsetof(PPCInterpreter_t, xer_ca), 0);
-		// add carry bit
-		x64Gen_adc_reg64Low32_imm32(x64GenContext, tempToRealRegister(imlInstruction->op_r_r.registerResult), 0);
-		// update xer carry
-		x64Gen_setcc_mem8(x64GenContext, X86_CONDITION_CARRY, REG_RSP, offsetof(PPCInterpreter_t, xer_ca));
-		if( imlInstruction->crRegister != PPC_REC_INVALID_REGISTER )
-		{
-			// set cr bits
-			sint32 crRegister = imlInstruction->crRegister;
-			x64Gen_setcc_mem8(x64GenContext, X86_CONDITION_SIGN, REG_RSP, offsetof(PPCInterpreter_t, cr)+sizeof(uint8)*(crRegister*4+PPCREC_CR_BIT_LT)); // check for sign instead of _BELOW (CF) which is not set by AND/OR
-			x64Gen_setcc_mem8(x64GenContext, X86_CONDITION_UNSIGNED_ABOVE, REG_RSP, offsetof(PPCInterpreter_t, cr)+sizeof(uint8)*(crRegister*4+PPCREC_CR_BIT_GT));
-			x64Gen_setcc_mem8(x64GenContext, X86_CONDITION_EQUAL, REG_RSP, offsetof(PPCInterpreter_t, cr)+sizeof(uint8)*(crRegister*4+PPCREC_CR_BIT_EQ));
-			// todo: Use different version of PPCRecompilerX64Gen_updateCRLogical(PPCRecFunction, ppcImlGenContext, x64GenContext, imlInstruction)
-			// todo: Also set summary overflow if xer bit is set
-		}
-	}
-	else if( imlInstruction->operation == PPCREC_IML_OP_ADD_CARRY_ME )
-	{
-		PPCRecompilerX64Gen_crConditionFlags_forget(PPCRecFunction, ppcImlGenContext, x64GenContext);
-		// copy operand to result if different registers
-		if( imlInstruction->op_r_r.registerResult != imlInstruction->op_r_r.registerA )
-		{
-			x64Gen_mov_reg64_reg64(x64GenContext, tempToRealRegister(imlInstruction->op_r_r.registerResult), tempToRealRegister(imlInstruction->op_r_r.registerA));
-		}
-		// copy xer_ca to eflags carry
-		x64Gen_bt_mem8(x64GenContext, REG_RSP, offsetof(PPCInterpreter_t, xer_ca), 0);
-		// add carry bit
-		x64Gen_adc_reg64Low32_imm32(x64GenContext, tempToRealRegister(imlInstruction->op_r_r.registerResult), (uint32)-1);
-		// update xer carry
-		x64Gen_setcc_mem8(x64GenContext, X86_CONDITION_CARRY, REG_RSP, offsetof(PPCInterpreter_t, xer_ca));
-		if( imlInstruction->crRegister != PPC_REC_INVALID_REGISTER )
-		{
-			// set cr bits
-			sint32 crRegister = imlInstruction->crRegister;
-			x64Gen_test_reg64Low32_reg64Low32(x64GenContext, tempToRealRegister(imlInstruction->op_r_r.registerResult), tempToRealRegister(imlInstruction->op_r_r.registerResult));
-			PPCRecompilerX64Gen_updateCRLogical(PPCRecFunction, ppcImlGenContext, x64GenContext, imlInstruction);
-		}
-	}
-	else if( imlInstruction->operation == PPCREC_IML_OP_SUB_CARRY_UPDATE_CARRY )
-	{
-		// registerResult = ~registerOperand1 + carry
-		PPCRecompilerX64Gen_crConditionFlags_forget(PPCRecFunction, ppcImlGenContext, x64GenContext);
-		sint32 rRegResult = tempToRealRegister(imlInstruction->op_r_r.registerResult);
-		sint32 rRegOperand1 = tempToRealRegister(imlInstruction->op_r_r.registerA);
-		// copy operand to result register
-		x64Gen_mov_reg64Low32_reg64Low32(x64GenContext, rRegResult, rRegOperand1);		
-		// execute NOT on result
-		x64Gen_not_reg64Low32(x64GenContext, rRegResult);
-		// copy xer_ca to eflags carry
-		x64Gen_bt_mem8(x64GenContext, REG_RSP, offsetof(PPCInterpreter_t, xer_ca), 0);
-		// add carry
-		x64Gen_adc_reg64Low32_imm32(x64GenContext, rRegResult, 0);
-		// update carry
-		x64Gen_setcc_mem8(x64GenContext, X86_CONDITION_CARRY, REG_RSP, offsetof(PPCInterpreter_t, xer_ca));
-		// update cr if requested
-		if( imlInstruction->crRegister != PPC_REC_INVALID_REGISTER )
-		{
-			if( imlInstruction->crMode == PPCREC_CR_MODE_LOGICAL )
-			{
-				x64Gen_test_reg64Low32_reg64Low32(x64GenContext, rRegResult, rRegResult);
-				// set cr bits
-				PPCRecompilerX64Gen_updateCRLogical(PPCRecFunction, ppcImlGenContext, x64GenContext, imlInstruction);
-			}
-			else
-			{
-				assert_dbg();
-			}
-		}
-	}
-	else if( imlInstruction->operation == PPCREC_IML_OP_ASSIGN_S16_TO_S32 )
-	{
-		// registerResult = (uint32)(sint32)(sint16)registerA
-		PPCRecompilerX64Gen_crConditionFlags_forget(PPCRecFunction, ppcImlGenContext, x64GenContext);
-		x64Gen_movSignExtend_reg64Low32_reg64Low16(x64GenContext, tempToRealRegister(imlInstruction->op_r_r.registerResult), reg32ToReg16(tempToRealRegister(imlInstruction->op_r_r.registerA)));
-		if( imlInstruction->crRegister != PPC_REC_INVALID_REGISTER )
-		{
-			if( imlInstruction->crMode == PPCREC_CR_MODE_ARITHMETIC )
-			{
-				x64Gen_test_reg64Low32_reg64Low32(x64GenContext, tempToRealRegister(imlInstruction->op_r_r.registerResult), tempToRealRegister(imlInstruction->op_r_r.registerResult));
-				// set cr bits
-				PPCRecompilerX64Gen_updateCRLogical(PPCRecFunction, ppcImlGenContext, x64GenContext, imlInstruction);
-			}
-			else
-			{
-				debug_printf("PPCRecompilerX64Gen_imlInstruction_r_r(): Unsupported operation\n");
-				assert_dbg();
-			}
-		}
-	}
-	else if( imlInstruction->operation == PPCREC_IML_OP_DCBZ )
-	{
-		PPCRecompilerX64Gen_crConditionFlags_forget(PPCRecFunction, ppcImlGenContext, x64GenContext);
-		if( imlInstruction->op_r_r.registerResult != imlInstruction->op_r_r.registerA )
-		{
-			x64Gen_mov_reg64_reg64(x64GenContext, REG_RESV_TEMP, tempToRealRegister(imlInstruction->op_r_r.registerA));
-			x64Gen_add_reg64Low32_reg64Low32(x64GenContext, REG_RESV_TEMP, tempToRealRegister(imlInstruction->op_r_r.registerResult));
-			x64Gen_and_reg64Low32_imm32(x64GenContext, REG_RESV_TEMP, ~0x1F);
-			x64Gen_add_reg64_reg64(x64GenContext, REG_RESV_TEMP, REG_RESV_MEMBASE);
-			for(sint32 f=0; f<0x20; f+=8)
-				x64Gen_mov_mem64Reg64_imm32(x64GenContext, REG_RESV_TEMP, f, 0);
-		}
-		else
-		{
-			// calculate effective address
-			x64Gen_mov_reg64_reg64(x64GenContext, REG_RESV_TEMP, tempToRealRegister(imlInstruction->op_r_r.registerA));
-			x64Gen_and_reg64Low32_imm32(x64GenContext, REG_RESV_TEMP, ~0x1F);
-			x64Gen_add_reg64_reg64(x64GenContext, REG_RESV_TEMP, REG_RESV_MEMBASE);
-			for(sint32 f=0; f<0x20; f+=8)
-				x64Gen_mov_mem64Reg64_imm32(x64GenContext, REG_RESV_TEMP, f, 0);
-		}
-	}
-	else
-	{
-		debug_printf("PPCRecompilerX64Gen_imlInstruction_r_r(): Unsupported operation 0x%x\n", imlInstruction->operation);
-		return false;
-	}
-	return true;
-}
-
-bool PPCRecompilerX64Gen_imlInstruction_r_s32(PPCRecFunction_t* PPCRecFunction, ppcImlGenContext_t* ppcImlGenContext, x64GenContext_t* x64GenContext, PPCRecImlInstruction_t* imlInstruction)
-{
-	if( imlInstruction->operation == PPCREC_IML_OP_ASSIGN )
-	{
-		// registerResult = immS32
-		cemu_assert_debug(imlInstruction->crRegister == PPC_REC_INVALID_REGISTER);
-		x64Gen_mov_reg64Low32_imm32(x64GenContext, tempToRealRegister(imlInstruction->op_r_immS32.registerIndex), (uint32)imlInstruction->op_r_immS32.immS32);
-	}
-	else if( imlInstruction->operation == PPCREC_IML_OP_ADD )
-	{
-		// registerResult += immS32
-		PPCRecompilerX64Gen_crConditionFlags_forget(PPCRecFunction, ppcImlGenContext, x64GenContext);
-		if( imlInstruction->crRegister != PPC_REC_INVALID_REGISTER )
-		{
-			assert_dbg();
-		}
-		x64Gen_add_reg64Low32_imm32(x64GenContext, tempToRealRegister(imlInstruction->op_r_immS32.registerIndex), (uint32)imlInstruction->op_r_immS32.immS32);
-	}
-	else if( imlInstruction->operation == PPCREC_IML_OP_SUB )
-	{
-		// registerResult -= immS32
-		PPCRecompilerX64Gen_crConditionFlags_forget(PPCRecFunction, ppcImlGenContext, x64GenContext);
-		if (imlInstruction->crRegister == PPCREC_CR_REG_TEMP)
-		{
-			// do nothing -> SUB is for BDNZ instruction
-		}
-		else if( imlInstruction->crRegister != PPC_REC_INVALID_REGISTER )
-		{
-			// update cr register
-			assert_dbg();
-		}
-		x64Gen_sub_reg64Low32_imm32(x64GenContext, tempToRealRegister(imlInstruction->op_r_immS32.registerIndex), (uint32)imlInstruction->op_r_immS32.immS32);
-	}
-	else if( imlInstruction->operation == PPCREC_IML_OP_AND )
-	{
-		// registerResult &= immS32
-		PPCRecompilerX64Gen_crConditionFlags_forget(PPCRecFunction, ppcImlGenContext, x64GenContext);
-		x64Gen_and_reg64Low32_imm32(x64GenContext, tempToRealRegister(imlInstruction->op_r_immS32.registerIndex), (uint32)imlInstruction->op_r_immS32.immS32);
-		if( imlInstruction->crRegister != PPC_REC_INVALID_REGISTER )
-		{
-			if( imlInstruction->crMode != PPCREC_CR_MODE_LOGICAL )
-			{
-				assert_dbg();
-			}
-			// set cr bits
-			sint32 crRegister = imlInstruction->crRegister;
-			PPCRecompilerX64Gen_updateCRLogical(PPCRecFunction, ppcImlGenContext, x64GenContext, imlInstruction);
-			// todo: Set CR SO if XER SO bit is set
-		}
-	}
-	else if( imlInstruction->operation == PPCREC_IML_OP_OR )
-	{
-		// registerResult |= immS32
-		PPCRecompilerX64Gen_crConditionFlags_forget(PPCRecFunction, ppcImlGenContext, x64GenContext);
-		cemu_assert_debug(imlInstruction->crRegister == PPC_REC_INVALID_REGISTER);
-		x64Gen_or_reg64Low32_imm32(x64GenContext, tempToRealRegister(imlInstruction->op_r_immS32.registerIndex), (uint32)imlInstruction->op_r_immS32.immS32);
-	}
-	else if( imlInstruction->operation == PPCREC_IML_OP_XOR )
-	{
-		// registerResult ^= immS32
-		PPCRecompilerX64Gen_crConditionFlags_forget(PPCRecFunction, ppcImlGenContext, x64GenContext);
-		cemu_assert_debug(imlInstruction->crRegister == PPC_REC_INVALID_REGISTER);
-		x64Gen_xor_reg64Low32_imm32(x64GenContext, tempToRealRegister(imlInstruction->op_r_immS32.registerIndex), (uint32)imlInstruction->op_r_immS32.immS32);
-	}
-	else if( imlInstruction->operation == PPCREC_IML_OP_LEFT_ROTATE )
-	{
-		// registerResult <<<= immS32
-		PPCRecompilerX64Gen_crConditionFlags_forget(PPCRecFunction, ppcImlGenContext, x64GenContext);
-		cemu_assert_debug(imlInstruction->crRegister == PPC_REC_INVALID_REGISTER);
-		if( (imlInstruction->op_r_immS32.immS32&0x80) )
-			assert_dbg(); // should not happen
-		x64Gen_rol_reg64Low32_imm8(x64GenContext, tempToRealRegister(imlInstruction->op_r_immS32.registerIndex), (uint8)imlInstruction->op_r_immS32.immS32);
-	}
-	else if( imlInstruction->operation == PPCREC_IML_OP_COMPARE_SIGNED || imlInstruction->operation == PPCREC_IML_OP_COMPARE_UNSIGNED )
-	{
-		// registerResult CMP immS32 (arithmetic compare)
-		PPCRecompilerX64Gen_crConditionFlags_forget(PPCRecFunction, ppcImlGenContext, x64GenContext);
-		if( imlInstruction->crRegister == PPC_REC_INVALID_REGISTER )
-		{
-			debug_printf("PPCRecompilerX64Gen_imlInstruction_r_s32(): No-Op CMP found\n");
-			return true; // a NO-OP instruction
-		}
-		if( imlInstruction->crRegister >= 8 )
-		{
-			debug_printf("PPCRecompilerX64Gen_imlInstruction_r_s32(): Unsupported CMP with crRegister = 8\n");
-			return false;
-		}
-		// update state of cr register
-		if( imlInstruction->operation == PPCREC_IML_OP_COMPARE_SIGNED )
-			PPCRecompilerX64Gen_crConditionFlags_set(PPCRecFunction, ppcImlGenContext, x64GenContext, imlInstruction->crRegister, PPCREC_CR_STATE_TYPE_SIGNED_ARITHMETIC);
-		else
-			PPCRecompilerX64Gen_crConditionFlags_set(PPCRecFunction, ppcImlGenContext, x64GenContext, imlInstruction->crRegister, PPCREC_CR_STATE_TYPE_UNSIGNED_ARITHMETIC);
-		// create compare instruction
-		x64Gen_cmp_reg64Low32_imm32(x64GenContext, tempToRealRegister(imlInstruction->op_r_immS32.registerIndex), imlInstruction->op_r_immS32.immS32);
-		// set cr bits
-		uint32 crRegister = imlInstruction->crRegister;
-		if( imlInstruction->operation == PPCREC_IML_OP_COMPARE_SIGNED )
-		{
-			if( (imlInstruction->crIgnoreMask&(1<<(crRegister*4+PPCREC_CR_BIT_LT))) == 0 )
-				x64Gen_setcc_mem8(x64GenContext, X86_CONDITION_SIGNED_LESS, REG_ESP, offsetof(PPCInterpreter_t, cr)+sizeof(uint8)*(crRegister*4+PPCREC_CR_BIT_LT));
-			if( (imlInstruction->crIgnoreMask&(1<<(crRegister*4+PPCREC_CR_BIT_GT))) == 0 )
-				x64Gen_setcc_mem8(x64GenContext, X86_CONDITION_SIGNED_GREATER, REG_ESP, offsetof(PPCInterpreter_t, cr)+sizeof(uint8)*(crRegister*4+PPCREC_CR_BIT_GT));
-			if( (imlInstruction->crIgnoreMask&(1<<(crRegister*4+PPCREC_CR_BIT_EQ))) == 0 )
-				x64Gen_setcc_mem8(x64GenContext, X86_CONDITION_EQUAL, REG_ESP, offsetof(PPCInterpreter_t, cr)+sizeof(uint8)*(crRegister*4+PPCREC_CR_BIT_EQ));
-		}
-		else if( imlInstruction->operation == PPCREC_IML_OP_COMPARE_UNSIGNED )
-		{
-			if( (imlInstruction->crIgnoreMask&(1<<(crRegister*4+PPCREC_CR_BIT_LT))) == 0 )
-				x64Gen_setcc_mem8(x64GenContext, X86_CONDITION_UNSIGNED_BELOW, REG_ESP, offsetof(PPCInterpreter_t, cr)+sizeof(uint8)*(crRegister*4+PPCREC_CR_BIT_LT));
-			if( (imlInstruction->crIgnoreMask&(1<<(crRegister*4+PPCREC_CR_BIT_GT))) == 0 )
-				x64Gen_setcc_mem8(x64GenContext, X86_CONDITION_UNSIGNED_ABOVE, REG_ESP, offsetof(PPCInterpreter_t, cr)+sizeof(uint8)*(crRegister*4+PPCREC_CR_BIT_GT));
-			if( (imlInstruction->crIgnoreMask&(1<<(crRegister*4+PPCREC_CR_BIT_EQ))) == 0 )
-				x64Gen_setcc_mem8(x64GenContext, X86_CONDITION_EQUAL, REG_ESP, offsetof(PPCInterpreter_t, cr)+sizeof(uint8)*(crRegister*4+PPCREC_CR_BIT_EQ));
-		}
-		else
-			assert_dbg();
-		// todo: Also set summary overflow if xer bit is set?
-	}
-	else if( imlInstruction->operation == PPCREC_IML_OP_MFCR )
-	{
-		PPCRecompilerX64Gen_crConditionFlags_forget(PPCRecFunction, ppcImlGenContext, x64GenContext);
-		uint32 destRegister = tempToRealRegister(imlInstruction->op_r_immS32.registerIndex);
-		x64Gen_xor_reg64Low32_reg64Low32(x64GenContext, destRegister, destRegister);
-		for(sint32 f=0; f<32; f++)
-		{
-			x64Gen_bt_mem8(x64GenContext, REG_RSP, offsetof(PPCInterpreter_t, cr)+f, 0);
-			x64Gen_adc_reg64Low32_reg64Low32(x64GenContext, destRegister, destRegister);
-		}
-	}
-	else if (imlInstruction->operation == PPCREC_IML_OP_MTCRF)
-	{
-		PPCRecompilerX64Gen_crConditionFlags_forget(PPCRecFunction, ppcImlGenContext, x64GenContext);
-		uint32 srcRegister = tempToRealRegister(imlInstruction->op_r_immS32.registerIndex);
-		uint32 crBitMask = ppc_MTCRFMaskToCRBitMask((uint32)imlInstruction->op_r_immS32.immS32);
-		for (sint32 f = 0; f < 32; f++)
-		{
-			if(((crBitMask >> f) & 1) == 0)
-				continue;
-			x64Gen_mov_mem8Reg64_imm8(x64GenContext, REG_ESP, offsetof(PPCInterpreter_t, cr) + sizeof(uint8) * (f), 0);
-			x64Gen_test_reg64Low32_imm32(x64GenContext, srcRegister, 0x80000000>>f);
-			x64Gen_setcc_mem8(x64GenContext, X86_CONDITION_NOT_EQUAL, REG_ESP, offsetof(PPCInterpreter_t, cr) + sizeof(uint8) * (f));
-		}
-	}
-	else
-	{
-		debug_printf("PPCRecompilerX64Gen_imlInstruction_r_s32(): Unsupported operation 0x%x\n", imlInstruction->operation);
-		return false;
-	}
-	return true;
-}
-
-bool PPCRecompilerX64Gen_imlInstruction_conditional_r_s32(PPCRecFunction_t* PPCRecFunction, ppcImlGenContext_t* ppcImlGenContext, x64GenContext_t* x64GenContext, PPCRecImlInstruction_t* imlInstruction)
-{
-	if (imlInstruction->operation == PPCREC_IML_OP_ASSIGN)
-	{
-		// registerResult = immS32 (conditional)
-		if (imlInstruction->crRegister != PPC_REC_INVALID_REGISTER)
-		{
-			assert_dbg();
-		}
-
-		x64Gen_mov_reg64Low32_imm32(x64GenContext, REG_RESV_TEMP, (uint32)imlInstruction->op_conditional_r_s32.immS32);
-
-		uint8 crBitIndex = imlInstruction->op_conditional_r_s32.crRegisterIndex * 4 + imlInstruction->op_conditional_r_s32.crBitIndex;
-		if (imlInstruction->op_conditional_r_s32.crRegisterIndex == x64GenContext->activeCRRegister)
-		{
-			if (x64GenContext->activeCRState == PPCREC_CR_STATE_TYPE_UNSIGNED_ARITHMETIC)
-			{
-				if (imlInstruction->op_conditional_r_s32.crBitIndex == CR_BIT_LT)
-				{
-					x64Gen_cmovcc_reg64Low32_reg64Low32(x64GenContext, imlInstruction->op_conditional_r_s32.bitMustBeSet ? X86_CONDITION_CARRY : X86_CONDITION_NOT_CARRY, tempToRealRegister(imlInstruction->op_conditional_r_s32.registerIndex), REG_RESV_TEMP);
-					return true;
-				}
-				else if (imlInstruction->op_conditional_r_s32.crBitIndex == CR_BIT_EQ)
-				{
-					x64Gen_cmovcc_reg64Low32_reg64Low32(x64GenContext, imlInstruction->op_conditional_r_s32.bitMustBeSet ? X86_CONDITION_EQUAL : X86_CONDITION_NOT_EQUAL, tempToRealRegister(imlInstruction->op_conditional_r_s32.registerIndex), REG_RESV_TEMP);
-					return true;
-				}
-				else if (imlInstruction->op_conditional_r_s32.crBitIndex == CR_BIT_GT)
-				{
-					x64Gen_cmovcc_reg64Low32_reg64Low32(x64GenContext, imlInstruction->op_conditional_r_s32.bitMustBeSet ? X86_CONDITION_UNSIGNED_ABOVE : X86_CONDITION_UNSIGNED_BELOW_EQUAL, tempToRealRegister(imlInstruction->op_conditional_r_s32.registerIndex), REG_RESV_TEMP);
-					return true;
-				}
-			}
-			else if (x64GenContext->activeCRState == PPCREC_CR_STATE_TYPE_SIGNED_ARITHMETIC)
-			{
-				if (imlInstruction->op_conditional_r_s32.crBitIndex == CR_BIT_LT)
-				{
-					x64Gen_cmovcc_reg64Low32_reg64Low32(x64GenContext, imlInstruction->op_conditional_r_s32.bitMustBeSet ? X86_CONDITION_SIGNED_LESS : X86_CONDITION_SIGNED_GREATER_EQUAL, tempToRealRegister(imlInstruction->op_conditional_r_s32.registerIndex), REG_RESV_TEMP);
-					return true;
-				}
-				else if (imlInstruction->op_conditional_r_s32.crBitIndex == CR_BIT_EQ)
-				{
-					x64Gen_cmovcc_reg64Low32_reg64Low32(x64GenContext, imlInstruction->op_conditional_r_s32.bitMustBeSet ? X86_CONDITION_EQUAL : X86_CONDITION_NOT_EQUAL, tempToRealRegister(imlInstruction->op_conditional_r_s32.registerIndex), REG_RESV_TEMP);
-					return true;
-				}
-				else if (imlInstruction->op_conditional_r_s32.crBitIndex == CR_BIT_GT)
-				{
-					x64Gen_cmovcc_reg64Low32_reg64Low32(x64GenContext, imlInstruction->op_conditional_r_s32.bitMustBeSet ? X86_CONDITION_SIGNED_GREATER : X86_CONDITION_SIGNED_LESS_EQUAL, tempToRealRegister(imlInstruction->op_conditional_r_s32.registerIndex), REG_RESV_TEMP);
-					return true;
-				}
-			}
-			else if (x64GenContext->activeCRState == PPCREC_CR_STATE_TYPE_LOGICAL)
-			{
-				if (imlInstruction->op_conditional_r_s32.crBitIndex == CR_BIT_LT)
-				{
-					x64Gen_cmovcc_reg64Low32_reg64Low32(x64GenContext, imlInstruction->op_conditional_r_s32.bitMustBeSet ? X86_CONDITION_SIGN : X86_CONDITION_NOT_SIGN, tempToRealRegister(imlInstruction->op_conditional_r_s32.registerIndex), REG_RESV_TEMP);
-					return true;
-				}
-				else if (imlInstruction->op_conditional_r_s32.crBitIndex == CR_BIT_EQ)
-				{
-					x64Gen_cmovcc_reg64Low32_reg64Low32(x64GenContext, imlInstruction->op_conditional_r_s32.bitMustBeSet ? X86_CONDITION_EQUAL : X86_CONDITION_NOT_EQUAL, tempToRealRegister(imlInstruction->op_conditional_r_s32.registerIndex), REG_RESV_TEMP);
-					return true;
-				}
-				else if (imlInstruction->op_conditional_r_s32.crBitIndex == CR_BIT_GT)
-				{
-					x64Gen_cmovcc_reg64Low32_reg64Low32(x64GenContext, imlInstruction->op_conditional_r_s32.bitMustBeSet ? X86_CONDITION_SIGNED_GREATER : X86_CONDITION_SIGNED_LESS_EQUAL, tempToRealRegister(imlInstruction->op_conditional_r_s32.registerIndex), REG_RESV_TEMP);
-					return true;
-				}
-			}
-		}
-		PPCRecompilerX64Gen_crConditionFlags_forget(PPCRecFunction, ppcImlGenContext, x64GenContext);
-		x64Gen_bt_mem8(x64GenContext, REG_RSP, offsetof(PPCInterpreter_t, cr) + crBitIndex * sizeof(uint8), 0);
-		if (imlInstruction->op_conditional_r_s32.bitMustBeSet)
-			x64Gen_cmovcc_reg64Low32_reg64Low32(x64GenContext, X86_CONDITION_CARRY, tempToRealRegister(imlInstruction->op_conditional_r_s32.registerIndex), REG_RESV_TEMP);
-		else
-			x64Gen_cmovcc_reg64Low32_reg64Low32(x64GenContext, X86_CONDITION_NOT_CARRY, tempToRealRegister(imlInstruction->op_conditional_r_s32.registerIndex), REG_RESV_TEMP);
-		return true;
-	}
-	return false;
-}
-
-bool PPCRecompilerX64Gen_imlInstruction_r_r_r(PPCRecFunction_t* PPCRecFunction, ppcImlGenContext_t* ppcImlGenContext, x64GenContext_t* x64GenContext, PPCRecImlInstruction_t* imlInstruction)
-{
-	if( imlInstruction->operation == PPCREC_IML_OP_ADD || imlInstruction->operation == PPCREC_IML_OP_ADD_UPDATE_CARRY || imlInstruction->operation == PPCREC_IML_OP_ADD_CARRY_UPDATE_CARRY )
-	{
-		// registerResult = registerOperand1 + registerOperand2
-		PPCRecompilerX64Gen_crConditionFlags_forget(PPCRecFunction, ppcImlGenContext, x64GenContext);
-		sint32 rRegResult = tempToRealRegister(imlInstruction->op_r_r_r.registerResult);
-		sint32 rRegOperand1 = tempToRealRegister(imlInstruction->op_r_r_r.registerA);
-		sint32 rRegOperand2 = tempToRealRegister(imlInstruction->op_r_r_r.registerB);
-
-		bool addCarry = imlInstruction->operation == PPCREC_IML_OP_ADD_CARRY_UPDATE_CARRY;
-		if( (rRegResult == rRegOperand1) || (rRegResult == rRegOperand2) )
-		{
-			// be careful not to overwrite the operand before we use it
-			if( rRegResult == rRegOperand1 )
-			{
-				if( addCarry )
-				{
-					x64Gen_bt_mem8(x64GenContext, REG_RSP, offsetof(PPCInterpreter_t, xer_ca), 0);
-					x64Gen_adc_reg64Low32_reg64Low32(x64GenContext, rRegResult, rRegOperand2);
-				}
-				else
-					x64Gen_add_reg64Low32_reg64Low32(x64GenContext, rRegResult, rRegOperand2);
-			}
-			else
-			{
-				if( addCarry )
-				{
-					x64Gen_bt_mem8(x64GenContext, REG_RSP, offsetof(PPCInterpreter_t, xer_ca), 0);
-					x64Gen_adc_reg64Low32_reg64Low32(x64GenContext, rRegResult, rRegOperand1);
-				}
-				else
-					x64Gen_add_reg64Low32_reg64Low32(x64GenContext, rRegResult, rRegOperand1);
-			}
-		}
-		else
-		{
-			// copy operand1 to destination register before doing addition
-			x64Gen_mov_reg64_reg64(x64GenContext, rRegResult, rRegOperand1);
-			// add operand2
-			if( addCarry )
-			{
-				x64Gen_bt_mem8(x64GenContext, REG_RSP, offsetof(PPCInterpreter_t, xer_ca), 0);
-				x64Gen_adc_reg64Low32_reg64Low32(x64GenContext, rRegResult, rRegOperand2);
-			}
-			else
-				x64Gen_add_reg64Low32_reg64Low32(x64GenContext, rRegResult, rRegOperand2);
-		}
-		// update carry
-		if( imlInstruction->operation == PPCREC_IML_OP_ADD_UPDATE_CARRY || imlInstruction->operation == PPCREC_IML_OP_ADD_CARRY_UPDATE_CARRY )
-		{
-			x64Gen_setcc_mem8(x64GenContext, X86_CONDITION_CARRY, REG_RSP, offsetof(PPCInterpreter_t, xer_ca));
-		}
-		// set cr bits if enabled
-		if( imlInstruction->crRegister != PPC_REC_INVALID_REGISTER )
-		{
-			if( imlInstruction->crMode != PPCREC_CR_MODE_LOGICAL )
-			{
-				assert_dbg();
-			}
-			sint32 crRegister = imlInstruction->crRegister;
-			PPCRecompilerX64Gen_updateCRLogical(PPCRecFunction, ppcImlGenContext, x64GenContext, imlInstruction);
-			return true;
-		}
-	}
-	else if( imlInstruction->operation == PPCREC_IML_OP_SUB )
-	{
-		// registerResult = registerOperand1 - registerOperand2
-		PPCRecompilerX64Gen_crConditionFlags_forget(PPCRecFunction, ppcImlGenContext, x64GenContext);
-		sint32 rRegResult = tempToRealRegister(imlInstruction->op_r_r_r.registerResult);
-		sint32 rRegOperand1 = tempToRealRegister(imlInstruction->op_r_r_r.registerA);
-		sint32 rRegOperand2 = tempToRealRegister(imlInstruction->op_r_r_r.registerB);
-		if( rRegOperand1 == rRegOperand2 )
-		{
-			// result = operand1 - operand1 -> 0
-			x64Gen_sub_reg64Low32_reg64Low32(x64GenContext, rRegResult, rRegResult);
-		}
-		else if( rRegResult == rRegOperand1 )
-		{
-			// result = result - operand2
-			x64Gen_sub_reg64Low32_reg64Low32(x64GenContext, rRegResult, rRegOperand2);
-		}
-		else if ( rRegResult == rRegOperand2 )
-		{
-			// result = operand1 - result
-			// NEG result
-			x64Gen_neg_reg64Low32(x64GenContext, rRegResult);
-			// ADD result, operand1
-			x64Gen_add_reg64Low32_reg64Low32(x64GenContext, rRegResult, rRegOperand1);
-		}
-		else
-		{
-			// copy operand1 to destination register before doing addition
-			x64Gen_mov_reg64_reg64(x64GenContext, rRegResult, rRegOperand1);
-			// sub operand2
-			x64Gen_sub_reg64Low32_reg64Low32(x64GenContext, rRegResult, rRegOperand2);
-		}
-		// set cr bits if enabled
-		if( imlInstruction->crRegister != PPC_REC_INVALID_REGISTER )
-		{
-			if( imlInstruction->crMode != PPCREC_CR_MODE_LOGICAL )
-			{
-				assert_dbg();
-			}
-			sint32 crRegister = imlInstruction->crRegister;
-			PPCRecompilerX64Gen_updateCRLogical(PPCRecFunction, ppcImlGenContext, x64GenContext, imlInstruction);
-			return true;
-		}
-	}
-	else if( imlInstruction->operation == PPCREC_IML_OP_SUB_CARRY_UPDATE_CARRY )
-	{
-		// registerResult = registerOperand1 - registerOperand2 + carry
-		PPCRecompilerX64Gen_crConditionFlags_forget(PPCRecFunction, ppcImlGenContext, x64GenContext);
-		sint32 rRegResult = tempToRealRegister(imlInstruction->op_r_r_r.registerResult);
-		sint32 rRegOperand1 = tempToRealRegister(imlInstruction->op_r_r_r.registerA);
-		sint32 rRegOperand2 = tempToRealRegister(imlInstruction->op_r_r_r.registerB);
-		if( rRegOperand1 == rRegOperand2 )
-		{
-			// copy xer_ca to eflags carry
-			x64Gen_bt_mem8(x64GenContext, REG_RSP, offsetof(PPCInterpreter_t, xer_ca), 0);
-			x64Gen_cmc(x64GenContext);
-			// result = operand1 - operand1 -> 0
-			x64Gen_sbb_reg64Low32_reg64Low32(x64GenContext, rRegResult, rRegResult);
-		}
-		else if( rRegResult == rRegOperand1 )
-		{
-			// copy inverted xer_ca to eflags carry
-			x64Gen_bt_mem8(x64GenContext, REG_RSP, offsetof(PPCInterpreter_t, xer_ca), 0);
-			x64Gen_cmc(x64GenContext);
-			// result = result - operand2
-			x64Gen_sbb_reg64Low32_reg64Low32(x64GenContext, rRegResult, rRegOperand2);
-		}
-		else if ( rRegResult == rRegOperand2 )
-		{
-			// result = operand1 - result
-			// NOT result
-			x64Gen_not_reg64Low32(x64GenContext, rRegResult);
-			// copy xer_ca to eflags carry
-			x64Gen_bt_mem8(x64GenContext, REG_RSP, offsetof(PPCInterpreter_t, xer_ca), 0);
-			// ADC result, operand1
-			x64Gen_adc_reg64Low32_reg64Low32(x64GenContext, rRegResult, rRegOperand1);
-		}
-		else
-		{
-			// copy operand1 to destination register before doing addition
-			x64Gen_mov_reg64_reg64(x64GenContext, rRegResult, rRegOperand1);
-			// copy xer_ca to eflags carry
-			x64Gen_bt_mem8(x64GenContext, REG_RSP, offsetof(PPCInterpreter_t, xer_ca), 0);
-			x64Gen_cmc(x64GenContext);
-			// sub operand2
-			x64Gen_sbb_reg64Low32_reg64Low32(x64GenContext, rRegResult, rRegOperand2);
-		}
-		// update carry flag (todo: is this actually correct in all cases?)
-		x64Gen_setcc_mem8(x64GenContext, X86_CONDITION_CARRY, REG_RSP, offsetof(PPCInterpreter_t, xer_ca));
-		// update cr0 if requested
-		if( imlInstruction->crRegister != PPC_REC_INVALID_REGISTER )
-		{
-			if( imlInstruction->crMode != PPCREC_CR_MODE_LOGICAL )
-				assert_dbg();
-			x64Gen_test_reg64Low32_reg64Low32(x64GenContext, rRegResult, rRegResult);
-			PPCRecompilerX64Gen_updateCRLogical(PPCRecFunction, ppcImlGenContext, x64GenContext, imlInstruction);
-		}
-	}
-	else if( imlInstruction->operation == PPCREC_IML_OP_MULTIPLY_SIGNED )
-	{
-		// registerResult = registerOperand1 * registerOperand2
-		PPCRecompilerX64Gen_crConditionFlags_forget(PPCRecFunction, ppcImlGenContext, x64GenContext);
-		sint32 rRegResult = tempToRealRegister(imlInstruction->op_r_r_r.registerResult);
-		sint32 rRegOperand1 = tempToRealRegister(imlInstruction->op_r_r_r.registerA);
-		sint32 rRegOperand2 = tempToRealRegister(imlInstruction->op_r_r_r.registerB);
-		if( (rRegResult == rRegOperand1) || (rRegResult == rRegOperand2) )
-		{
-			// be careful not to overwrite the operand before we use it
-			if( rRegResult == rRegOperand1 )
-				x64Gen_imul_reg64Low32_reg64Low32(x64GenContext, rRegResult, rRegOperand2);
-			else
-				x64Gen_imul_reg64Low32_reg64Low32(x64GenContext, rRegResult, rRegOperand1);
-		}
-		else
-		{
-			// copy operand1 to destination register before doing multiplication
-			x64Gen_mov_reg64_reg64(x64GenContext, rRegResult, rRegOperand1);
-			// add operand2
-			x64Gen_imul_reg64Low32_reg64Low32(x64GenContext, rRegResult, rRegOperand2);
-		}
-		// set cr bits if enabled
-		if( imlInstruction->crRegister != PPC_REC_INVALID_REGISTER )
-		{
-			if( imlInstruction->crMode != PPCREC_CR_MODE_LOGICAL )
-			{
-				assert_dbg();
-			}
-			// since IMUL instruction leaves relevant flags undefined, we have to use another TEST instruction to get the correct results
-			x64Gen_test_reg64Low32_reg64Low32(x64GenContext, rRegResult, rRegResult);
-			PPCRecompilerX64Gen_updateCRLogical(PPCRecFunction, ppcImlGenContext, x64GenContext, imlInstruction);
-		}
-	}
-	else if( imlInstruction->operation == PPCREC_IML_OP_SUBFC )
-	{
-		// registerResult = registerOperand2(rB) - registerOperand1(rA)
-		PPCRecompilerX64Gen_crConditionFlags_forget(PPCRecFunction, ppcImlGenContext, x64GenContext);
-		// updates carry flag
-		if( imlInstruction->crRegister != PPC_REC_INVALID_REGISTER )
-		{
-			return false;
-		}
-		sint32 rRegResult = tempToRealRegister(imlInstruction->op_r_r_r.registerResult);
-		sint32 rRegOperandA = tempToRealRegister(imlInstruction->op_r_r_r.registerA);
-		sint32 rRegOperandB = tempToRealRegister(imlInstruction->op_r_r_r.registerB);
-		// update carry flag
-		// carry flag is detected this way:
-		//if ((~a+b) < a) {
-		//	return true;
-		//}
-		//if ((~a+b+1) < 1) {
-		//	return true;
-		//}
-		// set carry to zero
-		x64Gen_mov_mem8Reg64_imm8(x64GenContext, REG_RSP, offsetof(PPCInterpreter_t, xer_ca), 0);
-		// ((~a+b)<~a) == true -> ca = 1
-		x64Gen_mov_reg64_reg64(x64GenContext, REG_RESV_TEMP, rRegOperandA);
-		x64Gen_not_reg64Low32(x64GenContext, REG_RESV_TEMP);
-		x64Gen_add_reg64Low32_reg64Low32(x64GenContext, REG_RESV_TEMP, rRegOperandB);
-		x64Gen_not_reg64Low32(x64GenContext, rRegOperandA);
-		x64Gen_cmp_reg64Low32_reg64Low32(x64GenContext, REG_RESV_TEMP, rRegOperandA);
-		x64Gen_not_reg64Low32(x64GenContext, rRegOperandA);
-		sint32 jumpInstructionOffset1 = x64GenContext->codeBufferIndex;
-		x64Gen_jmpc_near(x64GenContext, X86_CONDITION_UNSIGNED_ABOVE_EQUAL, 0);
-		// reset carry flag + jump destination afterwards
-		x64Gen_mov_mem8Reg64_imm8(x64GenContext, REG_RSP, offsetof(PPCInterpreter_t, xer_ca), 1);
-		PPCRecompilerX64Gen_redirectRelativeJump(x64GenContext, jumpInstructionOffset1, x64GenContext->codeBufferIndex);
-		// OR ((~a+b+1)<1) == true -> ca = 1
-		x64Gen_mov_reg64_reg64(x64GenContext, REG_RESV_TEMP, rRegOperandA);
-		// todo: Optimize by reusing result in REG_RESV_TEMP from above and only add 1
-		x64Gen_not_reg64Low32(x64GenContext, REG_RESV_TEMP);
-		x64Gen_add_reg64Low32_reg64Low32(x64GenContext, REG_RESV_TEMP, rRegOperandB);
-		x64Gen_add_reg64Low32_imm32(x64GenContext, REG_RESV_TEMP, 1);
-		x64Gen_cmp_reg64Low32_imm32(x64GenContext, REG_RESV_TEMP, 1);
-		sint32 jumpInstructionOffset2 = x64GenContext->codeBufferIndex;
-		x64Gen_jmpc_near(x64GenContext, X86_CONDITION_UNSIGNED_ABOVE_EQUAL, 0);
-		// reset carry flag + jump destination afterwards
-		x64Gen_mov_mem8Reg64_imm8(x64GenContext, REG_RSP, offsetof(PPCInterpreter_t, xer_ca), 1);
-		PPCRecompilerX64Gen_redirectRelativeJump(x64GenContext, jumpInstructionOffset2, x64GenContext->codeBufferIndex);
-		// do subtraction
-		if( rRegOperandB == rRegOperandA )
-		{
-			// result = operandA - operandA -> 0
-			x64Gen_xor_reg64Low32_reg64Low32(x64GenContext, rRegResult, rRegResult);
-		}
-		else if( rRegResult == rRegOperandB )
-		{
-			// result = result - operandA
-			x64Gen_sub_reg64Low32_reg64Low32(x64GenContext, rRegResult, rRegOperandA);
-		}
-		else if ( rRegResult == rRegOperandA )
-		{
-			// result = operandB - result
-			// NEG result
-			x64Gen_neg_reg64Low32(x64GenContext, rRegResult);
-			// ADD result, operandB
-			x64Gen_add_reg64Low32_reg64Low32(x64GenContext, rRegResult, rRegOperandB);
-		}
-		else
-		{
-			// copy operand1 to destination register before doing addition
-			x64Gen_mov_reg64_reg64(x64GenContext, rRegResult, rRegOperandB);
-			// sub operand2
-			x64Gen_sub_reg64Low32_reg64Low32(x64GenContext, rRegResult, rRegOperandA);
-		}
-	}
-	else if( imlInstruction->operation == PPCREC_IML_OP_SLW || imlInstruction->operation == PPCREC_IML_OP_SRW )
-	{
-		// registerResult = registerOperand1(rA) >> registerOperand2(rB) (up to 63 bits)
-		PPCRecompilerX64Gen_crConditionFlags_forget(PPCRecFunction, ppcImlGenContext, x64GenContext);
-		sint32 rRegResult = tempToRealRegister(imlInstruction->op_r_r_r.registerResult);
-		sint32 rRegOperand1 = tempToRealRegister(imlInstruction->op_r_r_r.registerA);
-		sint32 rRegOperand2 = tempToRealRegister(imlInstruction->op_r_r_r.registerB);
-
-		if (hasBMI2Support && imlInstruction->operation == PPCREC_IML_OP_SRW)
-		{
-			// use BMI2 SHRX if available
-			x64Gen_shrx_reg64_reg64_reg64(x64GenContext, rRegResult, rRegOperand1, rRegOperand2);
-		}
-		else if (hasBMI2Support && imlInstruction->operation == PPCREC_IML_OP_SLW)
-		{
-			// use BMI2 SHLX if available
-			x64Gen_shlx_reg64_reg64_reg64(x64GenContext, rRegResult, rRegOperand1, rRegOperand2);
-			x64Gen_and_reg64Low32_reg64Low32(x64GenContext, rRegResult, rRegResult); // trim result to 32bit
-		}
-		else
-		{
-			// lazy and slow way to do shift by register without relying on ECX/CL or BMI2
-			x64Gen_mov_reg64_reg64(x64GenContext, REG_RESV_TEMP, rRegOperand1);
-			for (sint32 b = 0; b < 6; b++)
-			{
-				x64Gen_test_reg64Low32_imm32(x64GenContext, rRegOperand2, (1 << b));
-				sint32 jumpInstructionOffset = x64GenContext->codeBufferIndex;
-				x64Gen_jmpc_near(x64GenContext, X86_CONDITION_EQUAL, 0); // jump if bit not set
-				if (b == 5)
-				{
-					x64Gen_xor_reg64Low32_reg64Low32(x64GenContext, REG_RESV_TEMP, REG_RESV_TEMP);
-				}
-				else
-				{
-					if (imlInstruction->operation == PPCREC_IML_OP_SLW)
-						x64Gen_shl_reg64Low32_imm8(x64GenContext, REG_RESV_TEMP, (1 << b));
-					else
-						x64Gen_shr_reg64Low32_imm8(x64GenContext, REG_RESV_TEMP, (1 << b));
-				}
-				PPCRecompilerX64Gen_redirectRelativeJump(x64GenContext, jumpInstructionOffset, x64GenContext->codeBufferIndex);
-			}
-			x64Gen_mov_reg64_reg64(x64GenContext, rRegResult, REG_RESV_TEMP);
-		}
-		// set cr bits if enabled
-		if( imlInstruction->crRegister != PPC_REC_INVALID_REGISTER )
-		{
-			if( imlInstruction->crMode != PPCREC_CR_MODE_LOGICAL )
-			{
-				assert_dbg();
-			}
-			x64Gen_test_reg64Low32_reg64Low32(x64GenContext, rRegResult, rRegResult);
-			PPCRecompilerX64Gen_updateCRLogical(PPCRecFunction, ppcImlGenContext, x64GenContext, imlInstruction);
-		}
-	}
-	else if( imlInstruction->operation == PPCREC_IML_OP_LEFT_ROTATE )
-	{
-		PPCRecompilerX64Gen_crConditionFlags_forget(PPCRecFunction, ppcImlGenContext, x64GenContext);
-		sint32 rRegResult = tempToRealRegister(imlInstruction->op_r_r_r.registerResult);
-		sint32 rRegOperand1 = tempToRealRegister(imlInstruction->op_r_r_r.registerA);
-		sint32 rRegOperand2 = tempToRealRegister(imlInstruction->op_r_r_r.registerB);
-		// todo: Use BMI2 rotate if available
-		// check if CL/ECX/RCX is available
-		if( rRegResult != REG_RCX && rRegOperand1 != REG_RCX && rRegOperand2 != REG_RCX )
-		{
-			// swap operand 2 with RCX
-			x64Gen_xchg_reg64_reg64(x64GenContext, REG_RCX, rRegOperand2);
-			// move operand 1 to temp register
-			x64Gen_mov_reg64_reg64(x64GenContext, REG_RESV_TEMP, rRegOperand1);
-			// rotate
-			x64Gen_rol_reg64Low32_cl(x64GenContext, REG_RESV_TEMP);
-			// undo swap operand 2 with RCX
-			x64Gen_xchg_reg64_reg64(x64GenContext, REG_RCX, rRegOperand2);
-			// copy to result register
-			x64Gen_mov_reg64_reg64(x64GenContext, rRegResult, REG_RESV_TEMP);
-		}
-		else
-		{
-			x64Gen_mov_reg64_reg64(x64GenContext, REG_RESV_TEMP, rRegOperand1);
-			// lazy and slow way to do shift by register without relying on ECX/CL
-			for(sint32 b=0; b<5; b++)
-			{
-				x64Gen_test_reg64Low32_imm32(x64GenContext, rRegOperand2, (1<<b));
-				sint32 jumpInstructionOffset = x64GenContext->codeBufferIndex;
-				x64Gen_jmpc_near(x64GenContext, X86_CONDITION_EQUAL, 0); // jump if bit not set
-				x64Gen_rol_reg64Low32_imm8(x64GenContext, REG_RESV_TEMP, (1<<b));
-				PPCRecompilerX64Gen_redirectRelativeJump(x64GenContext, jumpInstructionOffset, x64GenContext->codeBufferIndex);
-			}
-			x64Gen_mov_reg64_reg64(x64GenContext, rRegResult, REG_RESV_TEMP);
-		}
-		// set cr bits if enabled
-		if( imlInstruction->crRegister != PPC_REC_INVALID_REGISTER )
-		{
-			if( imlInstruction->crMode != PPCREC_CR_MODE_LOGICAL )
-			{
-				assert_dbg();
-			}
-			x64Gen_test_reg64Low32_reg64Low32(x64GenContext, rRegResult, rRegResult);
-			PPCRecompilerX64Gen_updateCRLogical(PPCRecFunction, ppcImlGenContext, x64GenContext, imlInstruction);
-		}
-	}
-	else if( imlInstruction->operation == PPCREC_IML_OP_SRAW )
-	{
-		// registerResult = (sint32)registerOperand1(rA) >> (sint32)registerOperand2(rB) (up to 63 bits)
-		PPCRecompilerX64Gen_crConditionFlags_forget(PPCRecFunction, ppcImlGenContext, x64GenContext);
-		sint32 rRegResult = tempToRealRegister(imlInstruction->op_r_r_r.registerResult);
-		sint32 rRegOperand1 = tempToRealRegister(imlInstruction->op_r_r_r.registerA);
-		sint32 rRegOperand2 = tempToRealRegister(imlInstruction->op_r_r_r.registerB);
-		// save cr
-		if( imlInstruction->crRegister != PPC_REC_INVALID_REGISTER )
-		{
-			return false;
-		}
-		// todo: Use BMI instructions if available?
-		// MOV registerResult, registerOperand (if different)
-		x64Gen_mov_reg64_reg64(x64GenContext, REG_RESV_TEMP, rRegOperand1);
-		 // reset carry
-		x64Gen_mov_mem8Reg64_imm8(x64GenContext, REG_RSP, offsetof(PPCInterpreter_t, xer_ca), 0);
-		// we use the same shift by register approach as in SLW/SRW, but we have to differentiate by signed/unsigned shift since it influences how the carry flag is set
-		x64Gen_test_reg64Low32_imm32(x64GenContext, REG_RESV_TEMP, 0x80000000);
-		sint32 jumpInstructionJumpToSignedShift = x64GenContext->codeBufferIndex;		
-		x64Gen_jmpc_far(x64GenContext, X86_CONDITION_NOT_EQUAL, 0);
-		//sint32 jumpInstructionJumpToEnd = x64GenContext->codeBufferIndex;
-		//x64Gen_jmpc(x64GenContext, X86_CONDITION_EQUAL, 0);
-		// unsigned shift (MSB of input register is not set)
-		for(sint32 b=0; b<6; b++)
-		{
-			x64Gen_test_reg64Low32_imm32(x64GenContext, rRegOperand2, (1<<b));
-			sint32 jumpInstructionOffset = x64GenContext->codeBufferIndex;
-			x64Gen_jmpc_near(x64GenContext, X86_CONDITION_EQUAL, 0); // jump if bit not set
-			if( b == 5 )
-			{
-				x64Gen_sar_reg64Low32_imm8(x64GenContext, REG_RESV_TEMP, (1<<b)/2);
-				x64Gen_sar_reg64Low32_imm8(x64GenContext, REG_RESV_TEMP, (1<<b)/2);
-			}
-			else
-			{
-				x64Gen_sar_reg64Low32_imm8(x64GenContext, REG_RESV_TEMP, (1<<b));
-			}
-			PPCRecompilerX64Gen_redirectRelativeJump(x64GenContext, jumpInstructionOffset, x64GenContext->codeBufferIndex);
-		}
-		sint32 jumpInstructionJumpToEnd = x64GenContext->codeBufferIndex;
-		x64Gen_jmpc_far(x64GenContext, X86_CONDITION_NONE, 0);
-		// signed shift
-		PPCRecompilerX64Gen_redirectRelativeJump(x64GenContext, jumpInstructionJumpToSignedShift, x64GenContext->codeBufferIndex);
-		for(sint32 b=0; b<6; b++)
-		{
-			// check if we need to shift by (1<<bit)
-			x64Gen_test_reg64Low32_imm32(x64GenContext, rRegOperand2, (1<<b));
-			sint32 jumpInstructionOffset = x64GenContext->codeBufferIndex;
-			x64Gen_jmpc_near(x64GenContext, X86_CONDITION_EQUAL, 0); // jump if bit not set
-			// set ca if any non-zero bit is shifted out
-			x64Gen_test_reg64Low32_imm32(x64GenContext, REG_RESV_TEMP, (1<<(1<<b))-1);
-			sint32 jumpInstructionJumpToAfterCa = x64GenContext->codeBufferIndex;
-			x64Gen_jmpc_near(x64GenContext, X86_CONDITION_EQUAL, 0); // jump if no bit is set
-			x64Gen_mov_mem8Reg64_imm8(x64GenContext, REG_RSP, offsetof(PPCInterpreter_t, xer_ca), 1);
-			PPCRecompilerX64Gen_redirectRelativeJump(x64GenContext, jumpInstructionJumpToAfterCa, x64GenContext->codeBufferIndex);
-			// arithmetic shift
-			if( b == 5 )
-			{
-				// copy sign bit into all bits
-				x64Gen_sar_reg64Low32_imm8(x64GenContext, REG_RESV_TEMP, (1<<b)/2);
-				x64Gen_sar_reg64Low32_imm8(x64GenContext, REG_RESV_TEMP, (1<<b)/2);
-			}
-			else
-			{
-				x64Gen_sar_reg64Low32_imm8(x64GenContext, REG_RESV_TEMP, (1<<b));
-			}
-			PPCRecompilerX64Gen_redirectRelativeJump(x64GenContext, jumpInstructionOffset, x64GenContext->codeBufferIndex);
-		}
-		// end
-		PPCRecompilerX64Gen_redirectRelativeJump(x64GenContext, jumpInstructionJumpToEnd, x64GenContext->codeBufferIndex);
-		x64Gen_mov_reg64_reg64(x64GenContext, rRegResult, REG_RESV_TEMP);
-		// update CR if requested
-		// todo
-	}
-	else if( imlInstruction->operation == PPCREC_IML_OP_DIVIDE_SIGNED || imlInstruction->operation == PPCREC_IML_OP_DIVIDE_UNSIGNED )
-	{
-		PPCRecompilerX64Gen_crConditionFlags_forget(PPCRecFunction, ppcImlGenContext, x64GenContext);
-		sint32 rRegResult = tempToRealRegister(imlInstruction->op_r_r_r.registerResult);
-		sint32 rRegOperand1 = tempToRealRegister(imlInstruction->op_r_r_r.registerA);
-		sint32 rRegOperand2 = tempToRealRegister(imlInstruction->op_r_r_r.registerB);
-
-		x64Emit_mov_mem32_reg32(x64GenContext, REG_RSP, (uint32)offsetof(PPCInterpreter_t, temporaryGPR[0]), REG_EAX);
-		x64Emit_mov_mem32_reg32(x64GenContext, REG_RSP, (uint32)offsetof(PPCInterpreter_t, temporaryGPR[1]), REG_EDX);
-		// mov operand 2 to temp register
-		x64Gen_mov_reg64_reg64(x64GenContext, REG_RESV_TEMP, rRegOperand2);
-		// mov operand1 to EAX
-		x64Gen_mov_reg64Low32_reg64Low32(x64GenContext, REG_EAX, rRegOperand1);
-		// sign or zero extend EAX to EDX:EAX based on division sign mode
-		if( imlInstruction->operation == PPCREC_IML_OP_DIVIDE_SIGNED )
-			x64Gen_cdq(x64GenContext);
-		else
-			x64Gen_xor_reg64Low32_reg64Low32(x64GenContext, REG_EDX, REG_EDX);
-		// make sure we avoid division by zero
-		x64Gen_test_reg64Low32_reg64Low32(x64GenContext, REG_RESV_TEMP, REG_RESV_TEMP);
-		x64Gen_jmpc_near(x64GenContext, X86_CONDITION_EQUAL, 3);
-		// divide
-		if( imlInstruction->operation == PPCREC_IML_OP_DIVIDE_SIGNED )
-			x64Gen_idiv_reg64Low32(x64GenContext, REG_RESV_TEMP);
-		else
-			x64Gen_div_reg64Low32(x64GenContext, REG_RESV_TEMP);
-		// result of division is now stored in EAX, move it to result register
-		if( rRegResult != REG_EAX )
-			x64Gen_mov_reg64_reg64(x64GenContext, rRegResult, REG_EAX);
-		// restore EAX / EDX
-		if( rRegResult != REG_RAX )
-			x64Emit_mov_reg64_mem32(x64GenContext, REG_EAX, REG_RSP, (uint32)offsetof(PPCInterpreter_t, temporaryGPR[0]));
-		if( rRegResult != REG_RDX )
-			x64Emit_mov_reg64_mem32(x64GenContext, REG_EDX, REG_RSP, (uint32)offsetof(PPCInterpreter_t, temporaryGPR[1]));
-		// set cr bits if requested
-		if( imlInstruction->crRegister != PPC_REC_INVALID_REGISTER )
-		{
-			if( imlInstruction->crMode != PPCREC_CR_MODE_ARITHMETIC )
-			{
-				assert_dbg();
-			}
-			x64Gen_test_reg64Low32_reg64Low32(x64GenContext, rRegResult, rRegResult);
-			PPCRecompilerX64Gen_updateCRLogical(PPCRecFunction, ppcImlGenContext, x64GenContext, imlInstruction);
-		}
-	}
-	else if( imlInstruction->operation == PPCREC_IML_OP_MULTIPLY_HIGH_SIGNED || imlInstruction->operation == PPCREC_IML_OP_MULTIPLY_HIGH_UNSIGNED )
-	{
-		PPCRecompilerX64Gen_crConditionFlags_forget(PPCRecFunction, ppcImlGenContext, x64GenContext);
-		sint32 rRegResult = tempToRealRegister(imlInstruction->op_r_r_r.registerResult);
-		sint32 rRegOperand1 = tempToRealRegister(imlInstruction->op_r_r_r.registerA);
-		sint32 rRegOperand2 = tempToRealRegister(imlInstruction->op_r_r_r.registerB);
-
-		x64Emit_mov_mem32_reg32(x64GenContext, REG_RSP, (uint32)offsetof(PPCInterpreter_t, temporaryGPR[0]), REG_EAX);
-		x64Emit_mov_mem32_reg32(x64GenContext, REG_RSP, (uint32)offsetof(PPCInterpreter_t, temporaryGPR[1]), REG_EDX);
-		// mov operand 2 to temp register
-		x64Gen_mov_reg64_reg64(x64GenContext, REG_RESV_TEMP, rRegOperand2);
-		// mov operand1 to EAX
-		x64Gen_mov_reg64Low32_reg64Low32(x64GenContext, REG_EAX, rRegOperand1);
-		if( imlInstruction->operation == PPCREC_IML_OP_MULTIPLY_HIGH_SIGNED )
-		{
-			// zero extend EAX to EDX:EAX
-			x64Gen_xor_reg64Low32_reg64Low32(x64GenContext, REG_EDX, REG_EDX);
-		}
-		else
-		{
-			// sign extend EAX to EDX:EAX
-			x64Gen_cdq(x64GenContext);
-		}
-		// multiply
-		if( imlInstruction->operation == PPCREC_IML_OP_MULTIPLY_HIGH_SIGNED )
-			x64Gen_imul_reg64Low32(x64GenContext, REG_RESV_TEMP);
-		else
-			x64Gen_mul_reg64Low32(x64GenContext, REG_RESV_TEMP);
-		// result of multiplication is now stored in EDX:EAX, move it to result register
-		if( rRegResult != REG_EDX )
-			x64Gen_mov_reg64_reg64(x64GenContext, rRegResult, REG_EDX);
-		// restore EAX / EDX
-		if( rRegResult != REG_RAX )
-			x64Emit_mov_reg64_mem32(x64GenContext, REG_EAX, REG_RSP, (uint32)offsetof(PPCInterpreter_t, temporaryGPR[0]));
-		if( rRegResult != REG_RDX )
-			x64Emit_mov_reg64_mem32(x64GenContext, REG_EDX, REG_RSP, (uint32)offsetof(PPCInterpreter_t, temporaryGPR[1]));
-		// set cr bits if requested
-		if( imlInstruction->crRegister != PPC_REC_INVALID_REGISTER )
-		{
-			if( imlInstruction->crMode != PPCREC_CR_MODE_LOGICAL )
-			{
-				assert_dbg();
-			}
-			x64Gen_test_reg64Low32_reg64Low32(x64GenContext, rRegResult, rRegResult);
-			PPCRecompilerX64Gen_updateCRLogical(PPCRecFunction, ppcImlGenContext, x64GenContext, imlInstruction);
-		}
-	}
-	else if( imlInstruction->operation == PPCREC_IML_OP_ORC )
-	{
-		// registerResult = registerOperand1 | ~registerOperand2
-		PPCRecompilerX64Gen_crConditionFlags_forget(PPCRecFunction, ppcImlGenContext, x64GenContext);
-		sint32 rRegResult = tempToRealRegister(imlInstruction->op_r_r_r.registerResult);
-		sint32 rRegOperand1 = tempToRealRegister(imlInstruction->op_r_r_r.registerA);
-		sint32 rRegOperand2 = tempToRealRegister(imlInstruction->op_r_r_r.registerB);
-
-		x64Gen_mov_reg64_reg64(x64GenContext, REG_RESV_TEMP, rRegOperand2);
-		x64Gen_not_reg64Low32(x64GenContext, REG_RESV_TEMP);
-		if( rRegResult != rRegOperand1 )
-			x64Gen_mov_reg64Low32_reg64Low32(x64GenContext, rRegResult, rRegOperand1);
-		x64Gen_or_reg64Low32_reg64Low32(x64GenContext, rRegResult, REG_RESV_TEMP);
-
-		// set cr bits if enabled
-		if( imlInstruction->crRegister != PPC_REC_INVALID_REGISTER )
-		{
-			if( imlInstruction->crMode != PPCREC_CR_MODE_LOGICAL )
-			{
-				assert_dbg();
-			}
-			PPCRecompilerX64Gen_updateCRLogical(PPCRecFunction, ppcImlGenContext, x64GenContext, imlInstruction);
-			return true;
-		}
-	}
-	else
-	{
-		debug_printf("PPCRecompilerX64Gen_imlInstruction_r_r_r(): Unsupported operation 0x%x\n", imlInstruction->operation);
-		return false;
-	}
-	return true;
-}
-
-bool PPCRecompilerX64Gen_imlInstruction_r_r_s32(PPCRecFunction_t* PPCRecFunction, ppcImlGenContext_t* ppcImlGenContext, x64GenContext_t* x64GenContext, PPCRecImlInstruction_t* imlInstruction)
-{
-	if( imlInstruction->operation == PPCREC_IML_OP_ADD )
-	{
-		// registerResult = registerOperand + immS32
-		PPCRecompilerX64Gen_crConditionFlags_forget(PPCRecFunction, ppcImlGenContext, x64GenContext);
-		cemu_assert_debug(imlInstruction->crRegister == PPC_REC_INVALID_REGISTER);
-		sint32 rRegResult = tempToRealRegister(imlInstruction->op_r_r_s32.registerResult);
-		sint32 rRegOperand = tempToRealRegister(imlInstruction->op_r_r_s32.registerA);
-		uint32 immU32 = (uint32)imlInstruction->op_r_r_s32.immS32;
-		if( rRegResult != rRegOperand )
-		{
-			// copy value to destination register before doing addition
-			x64Gen_mov_reg64_reg64(x64GenContext, rRegResult, rRegOperand);
-		}
-		x64Gen_add_reg64Low32_imm32(x64GenContext, rRegResult, (uint32)immU32);
-	}
-	else if( imlInstruction->operation == PPCREC_IML_OP_ADD_UPDATE_CARRY )
-	{
-		// registerResult = registerOperand + immS32
-		PPCRecompilerX64Gen_crConditionFlags_forget(PPCRecFunction, ppcImlGenContext, x64GenContext);
-		sint32 rRegResult = tempToRealRegister(imlInstruction->op_r_r_s32.registerResult);
-		sint32 rRegOperand = tempToRealRegister(imlInstruction->op_r_r_s32.registerA);
-		uint32 immU32 = (uint32)imlInstruction->op_r_r_s32.immS32;
-		if( rRegResult != rRegOperand )
-		{
-			// copy value to destination register before doing addition
-			x64Gen_mov_reg64_reg64(x64GenContext, rRegResult, rRegOperand);
-		}
-		x64Gen_add_reg64Low32_imm32(x64GenContext, rRegResult, (uint32)immU32);
-		// update carry flag
-		x64Gen_setcc_mem8(x64GenContext, X86_CONDITION_CARRY, REG_RSP, offsetof(PPCInterpreter_t, xer_ca));
-		// set cr bits if enabled
-		if( imlInstruction->crRegister != PPC_REC_INVALID_REGISTER )
-		{
-			if( imlInstruction->crMode != PPCREC_CR_MODE_LOGICAL )
-			{
-				assert_dbg();
-			}
-			sint32 crRegister = imlInstruction->crRegister;
-			//x64Gen_setcc_mem8(x64GenContext, X86_CONDITION_SIGN, REG_RSP, offsetof(PPCInterpreter_t, cr)+sizeof(uint8)*(crRegister*4+PPCREC_CR_BIT_LT));
-			//x64Gen_setcc_mem8(x64GenContext, X86_CONDITION_SIGNED_GREATER, REG_RSP, offsetof(PPCInterpreter_t, cr)+sizeof(uint8)*(crRegister*4+PPCREC_CR_BIT_GT));
-			//x64Gen_setcc_mem8(x64GenContext, X86_CONDITION_EQUAL, REG_RSP, offsetof(PPCInterpreter_t, cr)+sizeof(uint8)*(crRegister*4+PPCREC_CR_BIT_EQ));
-			PPCRecompilerX64Gen_updateCRLogical(PPCRecFunction, ppcImlGenContext, x64GenContext, imlInstruction);
-		}
-	}
-	else if( imlInstruction->operation == PPCREC_IML_OP_SUBFC )
-	{
-		// registerResult = immS32 - registerOperand
-		PPCRecompilerX64Gen_crConditionFlags_forget(PPCRecFunction, ppcImlGenContext, x64GenContext);
-		cemu_assert_debug(imlInstruction->crRegister == PPC_REC_INVALID_REGISTER);
-		sint32 rRegResult = tempToRealRegister(imlInstruction->op_r_r_s32.registerResult);
-		sint32 rRegOperand = tempToRealRegister(imlInstruction->op_r_r_s32.registerA);
-		sint32 immS32 = (sint32)imlInstruction->op_r_r_s32.immS32;
-		if( rRegResult != rRegOperand )
-		{
-			// copy value to destination register before doing addition
-			x64Gen_mov_reg64_reg64(x64GenContext, rRegResult, rRegOperand);
-		}
-		// set carry to zero
-		x64Gen_mov_mem8Reg64_imm8(x64GenContext, REG_RSP, offsetof(PPCInterpreter_t, xer_ca), 0);
-		// ((~a+b)<~a) == true -> ca = 1
-		x64Gen_mov_reg64_reg64(x64GenContext, REG_RESV_TEMP, rRegOperand);
-		x64Gen_not_reg64Low32(x64GenContext, REG_RESV_TEMP);
-		x64Gen_add_reg64Low32_imm32(x64GenContext, REG_RESV_TEMP, (uint32)immS32);
-		x64Gen_not_reg64Low32(x64GenContext, rRegOperand);
-		x64Gen_cmp_reg64Low32_reg64Low32(x64GenContext, REG_RESV_TEMP, rRegOperand);
-		x64Gen_not_reg64Low32(x64GenContext, rRegOperand);
-		sint32 jumpInstructionOffset1 = x64GenContext->codeBufferIndex;
-		x64Gen_jmpc_far(x64GenContext, X86_CONDITION_UNSIGNED_ABOVE_EQUAL, 0);
-		// reset carry flag + jump destination afterwards
-		x64Gen_mov_mem8Reg64_imm8(x64GenContext, REG_RSP, offsetof(PPCInterpreter_t, xer_ca), 1);
-		PPCRecompilerX64Gen_redirectRelativeJump(x64GenContext, jumpInstructionOffset1, x64GenContext->codeBufferIndex);
-		// OR ((~a+b+1)<1) == true -> ca = 1
-		x64Gen_mov_reg64_reg64(x64GenContext, REG_RESV_TEMP, rRegOperand);
-		// todo: Optimize by reusing result in REG_RESV_TEMP from above and only add 1
-		x64Gen_not_reg64Low32(x64GenContext, REG_RESV_TEMP);
-		x64Gen_add_reg64Low32_imm32(x64GenContext, REG_RESV_TEMP, (uint32)immS32);
-		x64Gen_add_reg64Low32_imm32(x64GenContext, REG_RESV_TEMP, 1);
-		x64Gen_cmp_reg64Low32_imm32(x64GenContext, REG_RESV_TEMP, 1);
-		sint32 jumpInstructionOffset2 = x64GenContext->codeBufferIndex;
-		x64Gen_jmpc_far(x64GenContext, X86_CONDITION_UNSIGNED_ABOVE_EQUAL, 0);
-		// reset carry flag + jump destination afterwards
-		x64Gen_mov_mem8Reg64_imm8(x64GenContext, REG_RSP, offsetof(PPCInterpreter_t, xer_ca), 1);
-		PPCRecompilerX64Gen_redirectRelativeJump(x64GenContext, jumpInstructionOffset2, x64GenContext->codeBufferIndex);
-		// do actual computation of value, note: a - b is equivalent to a + ~b + 1
-		x64Gen_not_reg64Low32(x64GenContext, rRegResult);
-		x64Gen_add_reg64Low32_imm32(x64GenContext, rRegResult, (uint32)immS32 + 1);
-	}
-	else if( imlInstruction->operation == PPCREC_IML_OP_RLWIMI )
-	{
-		// registerResult = ((registerResult<<<SH)&mask) | (registerOperand&~mask)
-		PPCRecompilerX64Gen_crConditionFlags_forget(PPCRecFunction, ppcImlGenContext, x64GenContext);
-		uint32 vImm = (uint32)imlInstruction->op_r_r_s32.immS32;
-		uint32 mb = (vImm>>0)&0xFF;
-		uint32 me = (vImm>>8)&0xFF;
-		uint32 sh = (vImm>>16)&0xFF;
-		uint32 mask = ppc_mask(mb, me);
-		// save cr
-		cemu_assert_debug(imlInstruction->crRegister == PPC_REC_INVALID_REGISTER);
-		// copy rS to temporary register
-		x64Gen_mov_reg64_reg64(x64GenContext, REG_RESV_TEMP, tempToRealRegister(imlInstruction->op_r_r_s32.registerA));
-		// rotate destination register
-		if( sh )
-			x64Gen_rol_reg64Low32_imm8(x64GenContext, REG_RESV_TEMP, (uint8)sh&0x1F);
-		// AND destination register with inverted mask
-		x64Gen_and_reg64Low32_imm32(x64GenContext, tempToRealRegister(imlInstruction->op_r_r_s32.registerResult), ~mask);
-		// AND temporary rS register with mask
-		x64Gen_and_reg64Low32_imm32(x64GenContext, REG_RESV_TEMP, mask);
-		// OR result with temporary
-		x64Gen_or_reg64Low32_reg64Low32(x64GenContext, tempToRealRegister(imlInstruction->op_r_r_s32.registerResult), REG_RESV_TEMP);
-	}
-	else if( imlInstruction->operation == PPCREC_IML_OP_MULTIPLY_SIGNED )
-	{
-		// registerResult = registerOperand * immS32
-		PPCRecompilerX64Gen_crConditionFlags_forget(PPCRecFunction, ppcImlGenContext, x64GenContext);
-		sint32 rRegResult = tempToRealRegister(imlInstruction->op_r_r_s32.registerResult);
-		sint32 rRegOperand = tempToRealRegister(imlInstruction->op_r_r_s32.registerA);
-		sint32 immS32 = (uint32)imlInstruction->op_r_r_s32.immS32;
-		x64Gen_mov_reg64_imm64(x64GenContext, REG_RESV_TEMP, (sint64)immS32); // todo: Optimize
-		if( rRegResult != rRegOperand )
-			x64Gen_mov_reg64_reg64(x64GenContext, rRegResult, rRegOperand);
-		x64Gen_imul_reg64Low32_reg64Low32(x64GenContext, rRegResult, REG_RESV_TEMP);
-	}
-	else if( imlInstruction->operation == PPCREC_IML_OP_SRAW )
-	{
-		// registerResult = registerOperand>>SH   and set xer ca flag
-		PPCRecompilerX64Gen_crConditionFlags_forget(PPCRecFunction, ppcImlGenContext, x64GenContext);
-		uint32 sh = (uint32)imlInstruction->op_r_r_s32.immS32;
-		// MOV registerResult, registerOperand (if different)
-		if( imlInstruction->op_r_r_s32.registerA != imlInstruction->op_r_r_s32.registerResult )
-			x64Gen_mov_reg64_reg64(x64GenContext, tempToRealRegister(imlInstruction->op_r_r_s32.registerResult), tempToRealRegister(imlInstruction->op_r_r_s32.registerA));
-		// todo: Detect if we don't need to update carry
-		// generic case
-		// TEST registerResult, (1<<(SH+1))-1
-		uint32 caTestMask = 0;
-		if (sh >= 31)
-			caTestMask = 0x7FFFFFFF;
-		else
-			caTestMask = (1 << (sh)) - 1;
-		x64Gen_test_reg64Low32_imm32(x64GenContext, tempToRealRegister(imlInstruction->op_r_r_s32.registerResult), caTestMask);
-		// SETNE/NZ [ESP+XER_CA]
-		x64Gen_setcc_mem8(x64GenContext, X86_CONDITION_NOT_EQUAL, REG_RSP, offsetof(PPCInterpreter_t, xer_ca));
-		// SAR registerResult, SH
-		x64Gen_sar_reg64Low32_imm8(x64GenContext, tempToRealRegister(imlInstruction->op_r_r_s32.registerResult), sh);
-		// JNS <skipInstruction> (if sign not set)
-		sint32 jumpInstructionOffset = x64GenContext->codeBufferIndex;
-		x64Gen_jmpc_near(x64GenContext, X86_CONDITION_SIGN, 0); // todo: Can use 2-byte form of jump instruction here
-		// MOV BYTE [ESP+xer_ca], 0
-		x64Gen_mov_mem8Reg64_imm8(x64GenContext, REG_RSP, offsetof(PPCInterpreter_t, xer_ca), 0);
-		// jump destination
-		PPCRecompilerX64Gen_redirectRelativeJump(x64GenContext, jumpInstructionOffset, x64GenContext->codeBufferIndex);
-		// CR update
-		if (imlInstruction->crRegister != PPC_REC_INVALID_REGISTER)
-		{
-			sint32 crRegister = imlInstruction->crRegister;
-			x64Gen_test_reg64Low32_reg64Low32(x64GenContext, tempToRealRegister(imlInstruction->op_r_r_s32.registerResult), tempToRealRegister(imlInstruction->op_r_r_s32.registerResult));
-			x64Gen_setcc_mem8(x64GenContext, X86_CONDITION_SIGN, REG_RSP, offsetof(PPCInterpreter_t, cr) + sizeof(uint8)*(crRegister * 4 + PPCREC_CR_BIT_LT));
-			x64Gen_setcc_mem8(x64GenContext, X86_CONDITION_SIGNED_GREATER, REG_RSP, offsetof(PPCInterpreter_t, cr) + sizeof(uint8)*(crRegister * 4 + PPCREC_CR_BIT_GT));
-			x64Gen_setcc_mem8(x64GenContext, X86_CONDITION_EQUAL, REG_RSP, offsetof(PPCInterpreter_t, cr) + sizeof(uint8)*(crRegister * 4 + PPCREC_CR_BIT_EQ));
-		}
-	}
-	else if( imlInstruction->operation == PPCREC_IML_OP_LEFT_SHIFT ||
-		imlInstruction->operation == PPCREC_IML_OP_RIGHT_SHIFT )
-	{
-		PPCRecompilerX64Gen_crConditionFlags_forget(PPCRecFunction, ppcImlGenContext, x64GenContext);
-		// MOV registerResult, registerOperand (if different)
-		if( imlInstruction->op_r_r_s32.registerA != imlInstruction->op_r_r_s32.registerResult )
-			x64Gen_mov_reg64_reg64(x64GenContext, tempToRealRegister(imlInstruction->op_r_r_s32.registerResult), tempToRealRegister(imlInstruction->op_r_r_s32.registerA));
-		// Shift
-		if( imlInstruction->operation == PPCREC_IML_OP_LEFT_SHIFT )
-			x64Gen_shl_reg64Low32_imm8(x64GenContext, tempToRealRegister(imlInstruction->op_r_r_s32.registerResult), imlInstruction->op_r_r_s32.immS32);
-		else
-			x64Gen_shr_reg64Low32_imm8(x64GenContext, tempToRealRegister(imlInstruction->op_r_r_s32.registerResult), imlInstruction->op_r_r_s32.immS32);
-		// CR update
-		if (imlInstruction->crRegister != PPC_REC_INVALID_REGISTER)
-		{
-			// since SHL/SHR only modifies the OF flag we need another TEST reg,reg here
-			x64Gen_test_reg64Low32_reg64Low32(x64GenContext, tempToRealRegister(imlInstruction->op_r_r_s32.registerResult), tempToRealRegister(imlInstruction->op_r_r_s32.registerResult));
-			PPCRecompilerX64Gen_updateCRLogical(PPCRecFunction, ppcImlGenContext, x64GenContext, imlInstruction);
-		}
-	}
-	else
-	{
-		debug_printf("PPCRecompilerX64Gen_imlInstruction_r_r_s32(): Unsupported operation 0x%x\n", imlInstruction->operation);
-		return false;
-	}
-	return true;
-}
-
-bool PPCRecompilerX64Gen_imlInstruction_conditionalJump(PPCRecFunction_t* PPCRecFunction, ppcImlGenContext_t* ppcImlGenContext, x64GenContext_t* x64GenContext, PPCRecImlSegment_t* imlSegment, PPCRecImlInstruction_t* imlInstruction)
-{
-	if( imlInstruction->op_conditionalJump.condition == PPCREC_JUMP_CONDITION_NONE )
-	{
-		// jump always
-		if (imlInstruction->op_conditionalJump.jumpAccordingToSegment)
-		{
-			// jump to segment
-			if (imlSegment->nextSegmentBranchTaken == nullptr)
-				assert_dbg();
-			PPCRecompilerX64Gen_rememberRelocatableOffset(x64GenContext, X64_RELOC_LINK_TO_SEGMENT, imlSegment->nextSegmentBranchTaken);
-			x64Gen_jmp_imm32(x64GenContext, 0);
-		}
-		else
-		{
-			// deprecated (jump to jumpmark)
-			PPCRecompilerX64Gen_rememberRelocatableOffset(x64GenContext, X64_RELOC_LINK_TO_PPC, (void*)(size_t)imlInstruction->op_conditionalJump.jumpmarkAddress);
-			x64Gen_jmp_imm32(x64GenContext, 0);
-		}
-	}
-	else
-	{
-		if (imlInstruction->op_conditionalJump.jumpAccordingToSegment)
-			assert_dbg();
-		// generate jump update marker
-		if( imlInstruction->op_conditionalJump.crRegisterIndex == PPCREC_CR_TEMPORARY || imlInstruction->op_conditionalJump.crRegisterIndex >= 8 )
-		{
-			// temporary cr is used, which means we use the currently active eflags
-			PPCRecompilerX64Gen_rememberRelocatableOffset(x64GenContext, X64_RELOC_LINK_TO_PPC, (void*)(size_t)imlInstruction->op_conditionalJump.jumpmarkAddress);
-			sint32 condition = imlInstruction->op_conditionalJump.condition;
-			if( condition == PPCREC_JUMP_CONDITION_E )
-				x64Gen_jmpc_far(x64GenContext, X86_CONDITION_EQUAL, 0);
-			else if( condition == PPCREC_JUMP_CONDITION_NE )
-				x64Gen_jmpc_far(x64GenContext, X86_CONDITION_NOT_EQUAL, 0);
-			else
-				assert_dbg();
-		}
-		else
-		{
-			uint8 crBitIndex = imlInstruction->op_conditionalJump.crRegisterIndex*4 + imlInstruction->op_conditionalJump.crBitIndex;
-			if (imlInstruction->op_conditionalJump.crRegisterIndex == x64GenContext->activeCRRegister )
-			{
-				if (x64GenContext->activeCRState == PPCREC_CR_STATE_TYPE_UNSIGNED_ARITHMETIC)
-				{
-					if (imlInstruction->op_conditionalJump.crBitIndex == CR_BIT_LT)
-					{
-						PPCRecompilerX64Gen_rememberRelocatableOffset(x64GenContext, X64_RELOC_LINK_TO_PPC, (void*)(size_t)imlInstruction->op_conditionalJump.jumpmarkAddress);
-						x64Gen_jmpc_far(x64GenContext, imlInstruction->op_conditionalJump.bitMustBeSet ? X86_CONDITION_CARRY : X86_CONDITION_NOT_CARRY, 0);
-						return true;
-					}
-					else if (imlInstruction->op_conditionalJump.crBitIndex == CR_BIT_EQ)
-					{
-						PPCRecompilerX64Gen_rememberRelocatableOffset(x64GenContext, X64_RELOC_LINK_TO_PPC, (void*)(size_t)imlInstruction->op_conditionalJump.jumpmarkAddress);
-						x64Gen_jmpc_far(x64GenContext, imlInstruction->op_conditionalJump.bitMustBeSet ? X86_CONDITION_EQUAL : X86_CONDITION_NOT_EQUAL, 0);
-						return true;
-					}
-					else if (imlInstruction->op_conditionalJump.crBitIndex == CR_BIT_GT)
-					{
-						PPCRecompilerX64Gen_rememberRelocatableOffset(x64GenContext, X64_RELOC_LINK_TO_PPC, (void*)(size_t)imlInstruction->op_conditionalJump.jumpmarkAddress);
-						x64Gen_jmpc_far(x64GenContext, imlInstruction->op_conditionalJump.bitMustBeSet ? X86_CONDITION_UNSIGNED_ABOVE : X86_CONDITION_UNSIGNED_BELOW_EQUAL, 0);
-						return true;
-					}
-				}
-				else if (x64GenContext->activeCRState == PPCREC_CR_STATE_TYPE_SIGNED_ARITHMETIC)
-				{
-					if (imlInstruction->op_conditionalJump.crBitIndex == CR_BIT_LT)
-					{
-						PPCRecompilerX64Gen_rememberRelocatableOffset(x64GenContext, X64_RELOC_LINK_TO_PPC, (void*)(size_t)imlInstruction->op_conditionalJump.jumpmarkAddress);
-						x64Gen_jmpc_far(x64GenContext, imlInstruction->op_conditionalJump.bitMustBeSet ? X86_CONDITION_SIGNED_LESS : X86_CONDITION_SIGNED_GREATER_EQUAL, 0);
-						return true;
-					}
-					else if (imlInstruction->op_conditionalJump.crBitIndex == CR_BIT_EQ)
-					{
-						PPCRecompilerX64Gen_rememberRelocatableOffset(x64GenContext, X64_RELOC_LINK_TO_PPC, (void*)(size_t)imlInstruction->op_conditionalJump.jumpmarkAddress);
-						x64Gen_jmpc_far(x64GenContext, imlInstruction->op_conditionalJump.bitMustBeSet ? X86_CONDITION_EQUAL : X86_CONDITION_NOT_EQUAL, 0);
-						return true;
-					}
-					else if (imlInstruction->op_conditionalJump.crBitIndex == CR_BIT_GT)
-					{
-						PPCRecompilerX64Gen_rememberRelocatableOffset(x64GenContext, X64_RELOC_LINK_TO_PPC, (void*)(size_t)imlInstruction->op_conditionalJump.jumpmarkAddress);
-						x64Gen_jmpc_far(x64GenContext, imlInstruction->op_conditionalJump.bitMustBeSet ? X86_CONDITION_SIGNED_GREATER : X86_CONDITION_SIGNED_LESS_EQUAL, 0);
-						return true;
-					}
-				}
-				else if (x64GenContext->activeCRState == PPCREC_CR_STATE_TYPE_LOGICAL)
-				{
-					if (imlInstruction->op_conditionalJump.crBitIndex == CR_BIT_LT)
-					{
-						PPCRecompilerX64Gen_rememberRelocatableOffset(x64GenContext, X64_RELOC_LINK_TO_PPC, (void*)(size_t)imlInstruction->op_conditionalJump.jumpmarkAddress);
-						x64Gen_jmpc_far(x64GenContext, imlInstruction->op_conditionalJump.bitMustBeSet ? X86_CONDITION_SIGN : X86_CONDITION_NOT_SIGN, 0);
-						return true;
-					}
-					else if (imlInstruction->op_conditionalJump.crBitIndex == CR_BIT_EQ)
-					{
-						PPCRecompilerX64Gen_rememberRelocatableOffset(x64GenContext, X64_RELOC_LINK_TO_PPC, (void*)(size_t)imlInstruction->op_conditionalJump.jumpmarkAddress);
-						x64Gen_jmpc_far(x64GenContext, imlInstruction->op_conditionalJump.bitMustBeSet ? X86_CONDITION_EQUAL : X86_CONDITION_NOT_EQUAL, 0);
-						return true;
-					}
-					else if (imlInstruction->op_conditionalJump.crBitIndex == CR_BIT_GT)
-					{
-						PPCRecompilerX64Gen_rememberRelocatableOffset(x64GenContext, X64_RELOC_LINK_TO_PPC, (void*)(size_t)imlInstruction->op_conditionalJump.jumpmarkAddress);
-						x64Gen_jmpc_far(x64GenContext, imlInstruction->op_conditionalJump.bitMustBeSet ? X86_CONDITION_SIGNED_GREATER : X86_CONDITION_SIGNED_LESS_EQUAL, 0);
-						return true;
-					}
-				}
-			}
-			x64Gen_bt_mem8(x64GenContext, REG_RSP, offsetof(PPCInterpreter_t, cr) + crBitIndex * sizeof(uint8), 0);
-			PPCRecompilerX64Gen_rememberRelocatableOffset(x64GenContext, X64_RELOC_LINK_TO_PPC, (void*)(size_t)imlInstruction->op_conditionalJump.jumpmarkAddress);
-			if( imlInstruction->op_conditionalJump.bitMustBeSet )
-			{
-				x64Gen_jmpc_far(x64GenContext, X86_CONDITION_CARRY, 0);
-			}
-			else
-			{
-				x64Gen_jmpc_far(x64GenContext, X86_CONDITION_NOT_CARRY, 0);
-			}
-		}
-	}
-	return true;
-}
-
-bool PPCRecompilerX64Gen_imlInstruction_conditionalJumpCycleCheck(PPCRecFunction_t* PPCRecFunction, ppcImlGenContext_t* ppcImlGenContext, x64GenContext_t* x64GenContext, PPCRecImlInstruction_t* imlInstruction)
-{
-	PPCRecompilerX64Gen_crConditionFlags_forget(PPCRecFunction, ppcImlGenContext, x64GenContext);
-	// some tests (all performed on a i7-4790K)
-	// 1) DEC [mem] + JNS has significantly worse performance than BT + JNC (probably due to additional memory write)
-	// 2) CMP [mem], 0 + JG has about equal (or slightly worse) performance than BT + JNC
-
-	// BT
-	x64Gen_bt_mem8(x64GenContext, REG_RSP, offsetof(PPCInterpreter_t, remainingCycles), 31); // check if negative
-	PPCRecompilerX64Gen_rememberRelocatableOffset(x64GenContext, X64_RELOC_LINK_TO_PPC, (void*)(size_t)imlInstruction->op_conditionalJump.jumpmarkAddress);
-	x64Gen_jmpc_far(x64GenContext, X86_CONDITION_NOT_CARRY, 0);
-	return true;
-}
-
-/*
-* PPC condition register operation
-*/
-bool PPCRecompilerX64Gen_imlInstruction_cr(PPCRecFunction_t* PPCRecFunction, ppcImlGenContext_t* ppcImlGenContext, x64GenContext_t* x64GenContext, PPCRecImlInstruction_t* imlInstruction)
-{
-	PPCRecompilerX64Gen_crConditionFlags_forget(PPCRecFunction, ppcImlGenContext, x64GenContext); // while these instruction do not directly affect eflags, they change the CR bit
-	if (imlInstruction->operation == PPCREC_IML_OP_CR_CLEAR)
-	{
-		// clear cr bit
-		x64Gen_mov_mem8Reg64_imm8(x64GenContext, REG_RSP, offsetof(PPCInterpreter_t, cr) + sizeof(uint8)*imlInstruction->op_cr.crD, 0);
-		return true;
-	}
-	else if (imlInstruction->operation == PPCREC_IML_OP_CR_SET)
-	{
-		// set cr bit
-		x64Gen_mov_mem8Reg64_imm8(x64GenContext, REG_RSP, offsetof(PPCInterpreter_t, cr) + sizeof(uint8)*imlInstruction->op_cr.crD, 1);
-		return true;
-	}
-	else if(imlInstruction->operation == PPCREC_IML_OP_CR_OR || imlInstruction->operation == PPCREC_IML_OP_CR_ORC ||
-		imlInstruction->operation == PPCREC_IML_OP_CR_AND || imlInstruction->operation == PPCREC_IML_OP_CR_ANDC )
-	{
-		x64Emit_movZX_reg64_mem8(x64GenContext, REG_RESV_TEMP, REG_RSP, offsetof(PPCInterpreter_t, cr) + sizeof(uint8)*imlInstruction->op_cr.crB);
-		if (imlInstruction->operation == PPCREC_IML_OP_CR_ORC || imlInstruction->operation == PPCREC_IML_OP_CR_ANDC)
-		{
-			return false; // untested
-			x64Gen_int3(x64GenContext);
-			x64Gen_xor_reg64Low32_imm32(x64GenContext, REG_RESV_TEMP, 1); // complement
-		}
-		if(imlInstruction->operation == PPCREC_IML_OP_CR_OR || imlInstruction->operation == PPCREC_IML_OP_CR_ORC)
-			x64Gen_or_reg64Low8_mem8Reg64(x64GenContext, REG_RESV_TEMP, REG_RSP, offsetof(PPCInterpreter_t, cr) + sizeof(uint8)*imlInstruction->op_cr.crA);
-		else
-			x64Gen_and_reg64Low8_mem8Reg64(x64GenContext, REG_RESV_TEMP, REG_RSP, offsetof(PPCInterpreter_t, cr) + sizeof(uint8)*imlInstruction->op_cr.crA);
-
-		x64Gen_mov_mem8Reg64_reg64Low8(x64GenContext, REG_RESV_TEMP, REG_RSP, offsetof(PPCInterpreter_t, cr) + sizeof(uint8)*imlInstruction->op_cr.crD);
-
-		return true;
-	}
-	else
-	{
-		assert_dbg();
-	}
-	return false;
-}
-
-
-void PPCRecompilerX64Gen_imlInstruction_ppcEnter(PPCRecFunction_t* PPCRecFunction, ppcImlGenContext_t* ppcImlGenContext, x64GenContext_t* x64GenContext, PPCRecImlInstruction_t* imlInstruction)
-{
-	imlInstruction->op_ppcEnter.x64Offset = x64GenContext->codeBufferIndex;
-	// generate code
-	if( ppcImlGenContext->hasFPUInstruction )
-	{
-		// old FPU unavailable code
-		//PPCRecompilerX86_crConditionFlags_saveBeforeOverwrite(PPCRecFunction, ppcImlGenContext, x64GenContext);
-		//// skip if FP bit in MSR is set
-		//// #define MSR_FP		(1<<13)
-		//x64Gen_bt_mem8(x64GenContext, REG_ESP, offsetof(PPCInterpreter_t, msr), 13);
-		//uint32 jmpCodeOffset = x64GenContext->codeBufferIndex;
-		//x64Gen_jmpc(x64GenContext, X86_CONDITION_CARRY, 0);
-		//x64Gen_mov_reg32_imm32(x64GenContext, REG_EAX, imlInstruction->op_ppcEnter.ppcAddress&0x7FFFFFFF);
-		//PPCRecompilerX64Gen_rememberRelocatableOffset(x64GenContext, X86_RELOC_MAKE_RELATIVE);
-		//x64Gen_jmp_imm32(x64GenContext, (uint32)PPCRecompiler_recompilerCallEscapeAndCallFPUUnavailable);
-		//// patch jump
-		//*(uint32*)(x64GenContext->codeBuffer+jmpCodeOffset+2) = x64GenContext->codeBufferIndex-jmpCodeOffset-6;
-	}
-}
-
-void PPCRecompilerX64Gen_imlInstruction_r_name(PPCRecFunction_t* PPCRecFunction, ppcImlGenContext_t* ppcImlGenContext, x64GenContext_t* x64GenContext, PPCRecImlInstruction_t* imlInstruction)
-{
-	uint32 name = imlInstruction->op_r_name.name;
-	if( name >= PPCREC_NAME_R0 && name < PPCREC_NAME_R0+32 )
-	{
-		x64Emit_mov_reg64_mem32(x64GenContext, tempToRealRegister(imlInstruction->op_r_name.registerIndex), REG_RSP, offsetof(PPCInterpreter_t, gpr)+sizeof(uint32)*(name-PPCREC_NAME_R0));
-	}
-	else if( name >= PPCREC_NAME_SPR0 && name < PPCREC_NAME_SPR0+999 )
-	{
-		sint32 sprIndex = (name - PPCREC_NAME_SPR0);
-		if (sprIndex == SPR_LR)
-			x64Emit_mov_reg64_mem32(x64GenContext, tempToRealRegister(imlInstruction->op_r_name.registerIndex), REG_RSP, offsetof(PPCInterpreter_t, spr.LR));
-		else if (sprIndex == SPR_CTR)
-			x64Emit_mov_reg64_mem32(x64GenContext, tempToRealRegister(imlInstruction->op_r_name.registerIndex), REG_RSP, offsetof(PPCInterpreter_t, spr.CTR));
-		else if (sprIndex == SPR_XER)
-			x64Emit_mov_reg64_mem32(x64GenContext, tempToRealRegister(imlInstruction->op_r_name.registerIndex), REG_RSP, offsetof(PPCInterpreter_t, spr.XER));
-		else if (sprIndex >= SPR_UGQR0 && sprIndex <= SPR_UGQR7)
-		{
-			sint32 memOffset = offsetof(PPCInterpreter_t, spr.UGQR) + sizeof(PPCInterpreter_t::spr.UGQR[0]) * (sprIndex - SPR_UGQR0);
-			x64Emit_mov_reg64_mem32(x64GenContext, tempToRealRegister(imlInstruction->op_r_name.registerIndex), REG_RSP, memOffset);
-		}
-		else
-			assert_dbg();
-		//x64Emit_mov_reg64_mem32(x64GenContext, tempToRealRegister(imlInstruction->op_r_name.registerIndex), REG_RSP, offsetof(PPCInterpreter_t, spr)+sizeof(uint32)*(name-PPCREC_NAME_SPR0));
-	}
-	else
-		assert_dbg();
-}
-
-void PPCRecompilerX64Gen_imlInstruction_name_r(PPCRecFunction_t* PPCRecFunction, ppcImlGenContext_t* ppcImlGenContext, x64GenContext_t* x64GenContext, PPCRecImlInstruction_t* imlInstruction)
-{
-	uint32 name = imlInstruction->op_r_name.name;
-	if( name >= PPCREC_NAME_R0 && name < PPCREC_NAME_R0+32 )
-	{
-		x64Emit_mov_mem32_reg64(x64GenContext, REG_RSP, offsetof(PPCInterpreter_t, gpr)+sizeof(uint32)*(name-PPCREC_NAME_R0), tempToRealRegister(imlInstruction->op_r_name.registerIndex));
-	}
-	else if( name >= PPCREC_NAME_SPR0 && name < PPCREC_NAME_SPR0+999 )
-	{
-		uint32 sprIndex = (name - PPCREC_NAME_SPR0);
-		if (sprIndex == SPR_LR)
-			x64Emit_mov_mem32_reg64(x64GenContext, REG_RSP, offsetof(PPCInterpreter_t, spr.LR), tempToRealRegister(imlInstruction->op_r_name.registerIndex));
-		else if (sprIndex == SPR_CTR)
-			x64Emit_mov_mem32_reg64(x64GenContext, REG_RSP, offsetof(PPCInterpreter_t, spr.CTR), tempToRealRegister(imlInstruction->op_r_name.registerIndex));
-		else if (sprIndex == SPR_XER)
-			x64Emit_mov_mem32_reg64(x64GenContext, REG_RSP, offsetof(PPCInterpreter_t, spr.XER), tempToRealRegister(imlInstruction->op_r_name.registerIndex));
-		else if (sprIndex >= SPR_UGQR0 && sprIndex <= SPR_UGQR7)
-		{
-			sint32 memOffset = offsetof(PPCInterpreter_t, spr.UGQR) + sizeof(PPCInterpreter_t::spr.UGQR[0]) * (sprIndex - SPR_UGQR0);
-			x64Emit_mov_mem32_reg64(x64GenContext, REG_RSP, memOffset, tempToRealRegister(imlInstruction->op_r_name.registerIndex));
-		}
-		else
-			assert_dbg();	
-	}
-	else
-		assert_dbg();
-}
-
-uint8* codeMemoryBlock = nullptr;
-sint32 codeMemoryBlockIndex = 0;
-sint32 codeMemoryBlockSize = 0;
-
-std::mutex mtx_allocExecutableMemory;
-
-uint8* PPCRecompilerX86_allocateExecutableMemory(sint32 size)
-{
-	std::lock_guard<std::mutex> lck(mtx_allocExecutableMemory);
-	if( codeMemoryBlockIndex+size > codeMemoryBlockSize )
-	{
-		// allocate new block
-		codeMemoryBlockSize = std::max(1024*1024*4, size+1024); // 4MB (or more if the function is larger than 4MB)
-		codeMemoryBlockIndex = 0;
-		codeMemoryBlock = (uint8*)MemMapper::AllocateMemory(nullptr, codeMemoryBlockSize, MemMapper::PAGE_PERMISSION::P_RWX);
-	}
-	uint8* codeMem = codeMemoryBlock + codeMemoryBlockIndex;
-	codeMemoryBlockIndex += size;
-	// pad to 4 byte alignment
-	while (codeMemoryBlockIndex & 3)
-	{
-		codeMemoryBlock[codeMemoryBlockIndex] = 0x90;
-		codeMemoryBlockIndex++;
-	}
-	return codeMem;
-}
-
-void PPCRecompiler_dumpIML(PPCRecFunction_t* PPCRecFunction, ppcImlGenContext_t* ppcImlGenContext);
-
-bool PPCRecompiler_generateX64Code(PPCRecFunction_t* PPCRecFunction, ppcImlGenContext_t* ppcImlGenContext)
-{
-	x64GenContext_t x64GenContext = {0};
-	x64GenContext.codeBufferSize = 1024;
-	x64GenContext.codeBuffer = (uint8*)malloc(x64GenContext.codeBufferSize);
-	x64GenContext.codeBufferIndex = 0;
-	x64GenContext.activeCRRegister = PPC_REC_INVALID_REGISTER;
-
-	// generate iml instruction code
-	bool codeGenerationFailed = false;
-	for(sint32 s=0; s<ppcImlGenContext->segmentListCount; s++)
-	{
-		PPCRecImlSegment_t* imlSegment = ppcImlGenContext->segmentList[s];
-		ppcImlGenContext->segmentList[s]->x64Offset = x64GenContext.codeBufferIndex;
-		for(sint32 i=0; i<imlSegment->imlListCount; i++)
-		{
-			PPCRecImlInstruction_t* imlInstruction = imlSegment->imlList+i;
-
-			if( imlInstruction->type == PPCREC_IML_TYPE_R_NAME )
-			{
-				PPCRecompilerX64Gen_imlInstruction_r_name(PPCRecFunction, ppcImlGenContext, &x64GenContext, imlInstruction);
-			}
-			else if( imlInstruction->type == PPCREC_IML_TYPE_NAME_R )
-			{
-				PPCRecompilerX64Gen_imlInstruction_name_r(PPCRecFunction, ppcImlGenContext, &x64GenContext, imlInstruction);
-			}
-			else if( imlInstruction->type == PPCREC_IML_TYPE_R_R )
-			{
-				if( PPCRecompilerX64Gen_imlInstruction_r_r(PPCRecFunction, ppcImlGenContext, &x64GenContext, imlInstruction) == false )
-				{
-					codeGenerationFailed = true;
-				}
-			}
-			else if (imlInstruction->type == PPCREC_IML_TYPE_R_S32)
-			{
-				if (PPCRecompilerX64Gen_imlInstruction_r_s32(PPCRecFunction, ppcImlGenContext, &x64GenContext, imlInstruction) == false)
-				{
-					codeGenerationFailed = true;
-				}
-			}
-			else if (imlInstruction->type == PPCREC_IML_TYPE_CONDITIONAL_R_S32)
-			{
-				if (PPCRecompilerX64Gen_imlInstruction_conditional_r_s32(PPCRecFunction, ppcImlGenContext, &x64GenContext, imlInstruction) == false)
-				{
-					codeGenerationFailed = true;
-				}
-			}
-			else if( imlInstruction->type == PPCREC_IML_TYPE_R_R_S32 )
-			{
-				if( PPCRecompilerX64Gen_imlInstruction_r_r_s32(PPCRecFunction, ppcImlGenContext, &x64GenContext, imlInstruction) == false )
-				{
-					codeGenerationFailed = true;
-				}
-			}
-			else if( imlInstruction->type == PPCREC_IML_TYPE_R_R_R )
-			{
-				if( PPCRecompilerX64Gen_imlInstruction_r_r_r(PPCRecFunction, ppcImlGenContext, &x64GenContext, imlInstruction) == false )
-				{
-					codeGenerationFailed = true;
-				}
-			}
-			else if( imlInstruction->type == PPCREC_IML_TYPE_CJUMP )
-			{
-				if( PPCRecompilerX64Gen_imlInstruction_conditionalJump(PPCRecFunction, ppcImlGenContext, &x64GenContext, imlSegment, imlInstruction) == false )
-				{
-					codeGenerationFailed = true;
-				}
-			}
-			else if( imlInstruction->type == PPCREC_IML_TYPE_CJUMP_CYCLE_CHECK )
-			{
-				PPCRecompilerX64Gen_imlInstruction_conditionalJumpCycleCheck(PPCRecFunction, ppcImlGenContext, &x64GenContext, imlInstruction);
-			}
-			else if( imlInstruction->type == PPCREC_IML_TYPE_MACRO )
-			{
-				if( PPCRecompilerX64Gen_imlInstruction_macro(PPCRecFunction, ppcImlGenContext, &x64GenContext, imlInstruction) == false )
-				{
-					codeGenerationFailed = true;
-				}
-			}
-			else if( imlInstruction->type == PPCREC_IML_TYPE_LOAD )
-			{
-				if( PPCRecompilerX64Gen_imlInstruction_load(PPCRecFunction, ppcImlGenContext, &x64GenContext, imlInstruction, false) == false )
-				{
-					codeGenerationFailed = true;
-				}
-			}
-			else if( imlInstruction->type == PPCREC_IML_TYPE_LOAD_INDEXED )
-			{
-				if( PPCRecompilerX64Gen_imlInstruction_load(PPCRecFunction, ppcImlGenContext, &x64GenContext, imlInstruction, true) == false )
-				{
-					codeGenerationFailed = true;
-				}
-			}
-			else if( imlInstruction->type == PPCREC_IML_TYPE_STORE )
-			{
-				if( PPCRecompilerX64Gen_imlInstruction_store(PPCRecFunction, ppcImlGenContext, &x64GenContext, imlInstruction, false) == false )
-				{
-					codeGenerationFailed = true;
-				}
-			}
-			else if( imlInstruction->type == PPCREC_IML_TYPE_STORE_INDEXED )
-			{
-				if( PPCRecompilerX64Gen_imlInstruction_store(PPCRecFunction, ppcImlGenContext, &x64GenContext, imlInstruction, true) == false )
-				{
-					codeGenerationFailed = true;
-				}
-			}
-			else if (imlInstruction->type == PPCREC_IML_TYPE_MEM2MEM)
-			{
-				PPCRecompilerX64Gen_imlInstruction_mem2mem(PPCRecFunction, ppcImlGenContext, &x64GenContext, imlInstruction);
-			}
-			else if( imlInstruction->type == PPCREC_IML_TYPE_CR )
-			{
-				if( PPCRecompilerX64Gen_imlInstruction_cr(PPCRecFunction, ppcImlGenContext, &x64GenContext, imlInstruction) == false )
-				{
-					codeGenerationFailed = true;
-				}
-			}
-			else if( imlInstruction->type == PPCREC_IML_TYPE_JUMPMARK )
-			{
-				// no op
-			}
-			else if( imlInstruction->type == PPCREC_IML_TYPE_NO_OP )
-			{
-				// no op
-			}
-			else if( imlInstruction->type == PPCREC_IML_TYPE_PPC_ENTER )
-			{
-				PPCRecompilerX64Gen_imlInstruction_ppcEnter(PPCRecFunction, ppcImlGenContext, &x64GenContext, imlInstruction);
-			}
-			else if( imlInstruction->type == PPCREC_IML_TYPE_FPR_R_NAME )
-			{
-				PPCRecompilerX64Gen_imlInstruction_fpr_r_name(PPCRecFunction, ppcImlGenContext, &x64GenContext, imlInstruction);
-			}
-			else if( imlInstruction->type == PPCREC_IML_TYPE_FPR_NAME_R )
-			{
-				PPCRecompilerX64Gen_imlInstruction_fpr_name_r(PPCRecFunction, ppcImlGenContext, &x64GenContext, imlInstruction);
-			}
-			else if( imlInstruction->type == PPCREC_IML_TYPE_FPR_LOAD )
-			{
-				if( PPCRecompilerX64Gen_imlInstruction_fpr_load(PPCRecFunction, ppcImlGenContext, &x64GenContext, imlInstruction, false) == false )
-				{
-					codeGenerationFailed = true;
-				}
-			}
-			else if( imlInstruction->type == PPCREC_IML_TYPE_FPR_LOAD_INDEXED )
-			{
-				if( PPCRecompilerX64Gen_imlInstruction_fpr_load(PPCRecFunction, ppcImlGenContext, &x64GenContext, imlInstruction, true) == false )
-				{
-					codeGenerationFailed = true;
-				}
-			}
-			else if( imlInstruction->type == PPCREC_IML_TYPE_FPR_STORE )
-			{
-				if( PPCRecompilerX64Gen_imlInstruction_fpr_store(PPCRecFunction, ppcImlGenContext, &x64GenContext, imlInstruction, false) == false )
-				{
-					codeGenerationFailed = true;
-				}
-			}
-			else if( imlInstruction->type == PPCREC_IML_TYPE_FPR_STORE_INDEXED )
-			{
-				if( PPCRecompilerX64Gen_imlInstruction_fpr_store(PPCRecFunction, ppcImlGenContext, &x64GenContext, imlInstruction, true) == false )
-				{
-					codeGenerationFailed = true;
-				}
-			}
-			else if( imlInstruction->type == PPCREC_IML_TYPE_FPR_R_R )
-			{
-				PPCRecompilerX64Gen_imlInstruction_fpr_r_r(PPCRecFunction, ppcImlGenContext, &x64GenContext, imlInstruction);		
-			}
-			else if( imlInstruction->type == PPCREC_IML_TYPE_FPR_R_R_R )
-			{
-				PPCRecompilerX64Gen_imlInstruction_fpr_r_r_r(PPCRecFunction, ppcImlGenContext, &x64GenContext, imlInstruction);		
-			}
-			else if( imlInstruction->type == PPCREC_IML_TYPE_FPR_R_R_R_R )
-			{
-				PPCRecompilerX64Gen_imlInstruction_fpr_r_r_r_r(PPCRecFunction, ppcImlGenContext, &x64GenContext, imlInstruction);		
-			}
-			else if( imlInstruction->type == PPCREC_IML_TYPE_FPR_R )
-			{
-				PPCRecompilerX64Gen_imlInstruction_fpr_r(PPCRecFunction, ppcImlGenContext, &x64GenContext, imlInstruction);		
-			}
-			else
-			{
-				debug_printf("PPCRecompiler_generateX64Code(): Unsupported iml type 0x%x\n", imlInstruction->type);
-				assert_dbg();
-			}
-		}
-	}
-	// handle failed code generation
-	if( codeGenerationFailed )
-	{
-		free(x64GenContext.codeBuffer);
-		if (x64GenContext.relocateOffsetTable)
-			free(x64GenContext.relocateOffsetTable);
-		return false;
-	}
-	// allocate executable memory
-	uint8* executableMemory = PPCRecompilerX86_allocateExecutableMemory(x64GenContext.codeBufferIndex);
-	size_t baseAddress = (size_t)executableMemory;
-	// fix relocs
-	for(sint32 i=0; i<x64GenContext.relocateOffsetTableCount; i++)
-	{
-		if( x64GenContext.relocateOffsetTable[i].type == X86_RELOC_MAKE_RELATIVE )
-		{
-			assert_dbg(); // deprecated
-		}
-		else if(x64GenContext.relocateOffsetTable[i].type == X64_RELOC_LINK_TO_PPC || x64GenContext.relocateOffsetTable[i].type == X64_RELOC_LINK_TO_SEGMENT)
-		{
-			// if link to PPC, search for segment that starts with this offset
-			uint32 ppcOffset = (uint32)(size_t)x64GenContext.relocateOffsetTable[i].extraInfo;
-			uint32 x64Offset = 0xFFFFFFFF;
-			if (x64GenContext.relocateOffsetTable[i].type == X64_RELOC_LINK_TO_PPC)
-			{
-				for (sint32 s = 0; s < ppcImlGenContext->segmentListCount; s++)
-				{
-					if (ppcImlGenContext->segmentList[s]->isJumpDestination && ppcImlGenContext->segmentList[s]->jumpDestinationPPCAddress == ppcOffset)
-					{
-						x64Offset = ppcImlGenContext->segmentList[s]->x64Offset;
-						break;
-					}
-				}
-				if (x64Offset == 0xFFFFFFFF)
-				{
-					debug_printf("Recompiler could not resolve jump (function at 0x%08x)\n", PPCRecFunction->ppcAddress);
-					// todo: Cleanup
-					return false;
-				}
-			}
-			else
-			{
-				PPCRecImlSegment_t* destSegment = (PPCRecImlSegment_t*)x64GenContext.relocateOffsetTable[i].extraInfo;
-				x64Offset = destSegment->x64Offset;
-			}
-			uint32 relocBase = x64GenContext.relocateOffsetTable[i].offset;
-			uint8* relocInstruction = x64GenContext.codeBuffer+relocBase;
-			if( relocInstruction[0] == 0x0F && (relocInstruction[1] >= 0x80 && relocInstruction[1] <= 0x8F) )
-			{
-				// Jcc relativeImm32
-				sint32 distanceNearJump = (sint32)((baseAddress + x64Offset) - (baseAddress + relocBase + 2));
-				if (distanceNearJump >= -128 && distanceNearJump < 127) // disabled
-				{
-					// convert to near Jcc
-					*(uint8*)(relocInstruction + 0) = (uint8)(relocInstruction[1]-0x80 + 0x70);
-					// patch offset
-					*(uint8*)(relocInstruction + 1) = (uint8)distanceNearJump;
-					// replace unused 4 bytes with NOP instruction
-					relocInstruction[2] = 0x0F;
-					relocInstruction[3] = 0x1F;
-					relocInstruction[4] = 0x40;
-					relocInstruction[5] = 0x00;
-				}
-				else
-				{
-					// patch offset
-					*(uint32*)(relocInstruction + 2) = (uint32)((baseAddress + x64Offset) - (baseAddress + relocBase + 6));
-				}
-			}
-			else if( relocInstruction[0] == 0xE9 )
-			{
-				// JMP relativeImm32
-				*(uint32*)(relocInstruction+1) = (uint32)((baseAddress+x64Offset)-(baseAddress+relocBase+5));
-			}
-			else
-				assert_dbg();
-		}
-		else
-		{
-			assert_dbg();
-		}
-	}
-
-	// copy code to executable memory
-	memcpy(executableMemory, x64GenContext.codeBuffer, x64GenContext.codeBufferIndex);
-	free(x64GenContext.codeBuffer);
-	x64GenContext.codeBuffer = nullptr;
-	if (x64GenContext.relocateOffsetTable)
-		free(x64GenContext.relocateOffsetTable);
-	// set code
-	PPCRecFunction->x86Code = executableMemory;
-	PPCRecFunction->x86Size = x64GenContext.codeBufferIndex;
-	return true;
-}
-
-void PPCRecompilerX64Gen_generateEnterRecompilerCode()
-{
-	x64GenContext_t x64GenContext = {0};
-	x64GenContext.codeBufferSize = 1024;
-	x64GenContext.codeBuffer = (uint8*)malloc(x64GenContext.codeBufferSize);
-	x64GenContext.codeBufferIndex = 0;
-	x64GenContext.activeCRRegister = PPC_REC_INVALID_REGISTER;
-
-	// start of recompiler entry function
-	x64Gen_push_reg64(&x64GenContext, REG_RAX);
-	x64Gen_push_reg64(&x64GenContext, REG_RCX);
-	x64Gen_push_reg64(&x64GenContext, REG_RDX);
-	x64Gen_push_reg64(&x64GenContext, REG_RBX);
-	x64Gen_push_reg64(&x64GenContext, REG_RBP);
-	x64Gen_push_reg64(&x64GenContext, REG_RDI);
-	x64Gen_push_reg64(&x64GenContext, REG_RSI);
-	x64Gen_push_reg64(&x64GenContext, REG_R8);
-	x64Gen_push_reg64(&x64GenContext, REG_R9);
-	x64Gen_push_reg64(&x64GenContext, REG_R10);
-	x64Gen_push_reg64(&x64GenContext, REG_R11);
-	x64Gen_push_reg64(&x64GenContext, REG_R12);
-	x64Gen_push_reg64(&x64GenContext, REG_R13);
-	x64Gen_push_reg64(&x64GenContext, REG_R14);
-	x64Gen_push_reg64(&x64GenContext, REG_R15);
-
-	// 000000007775EF04 | E8 00 00 00 00                      call +0x00
-	x64Gen_writeU8(&x64GenContext, 0xE8);
-	x64Gen_writeU8(&x64GenContext, 0x00);
-	x64Gen_writeU8(&x64GenContext, 0x00);
-	x64Gen_writeU8(&x64GenContext, 0x00);
-	x64Gen_writeU8(&x64GenContext, 0x00);
-	//000000007775EF09 | 48 83 04 24 05                       add qword ptr ss:[rsp],5
-	x64Gen_writeU8(&x64GenContext, 0x48);
-	x64Gen_writeU8(&x64GenContext, 0x83);
-	x64Gen_writeU8(&x64GenContext, 0x04);
-	x64Gen_writeU8(&x64GenContext, 0x24);
-	uint32 jmpPatchOffset = x64GenContext.codeBufferIndex;
-	x64Gen_writeU8(&x64GenContext, 0); // skip the distance until after the JMP
-	x64Emit_mov_mem64_reg64(&x64GenContext, REG_RDX, offsetof(PPCInterpreter_t, rspTemp), REG_RSP);
-
-
-	// MOV RSP, RDX (ppc interpreter instance)
-	x64Gen_mov_reg64_reg64(&x64GenContext, REG_RSP, REG_RDX);
-	// MOV R15, ppcRecompilerInstanceData
-	x64Gen_mov_reg64_imm64(&x64GenContext, REG_R15, (uint64)ppcRecompilerInstanceData);
-	// MOV R13, memory_base
-	x64Gen_mov_reg64_imm64(&x64GenContext, REG_R13, (uint64)memory_base);
-
-	//JMP recFunc
-	x64Gen_jmp_reg64(&x64GenContext, REG_RCX); // call argument 1
-
-	x64GenContext.codeBuffer[jmpPatchOffset] = (x64GenContext.codeBufferIndex-(jmpPatchOffset-4));
-
-	//recompilerExit1:
-	x64Gen_pop_reg64(&x64GenContext, REG_R15);
-	x64Gen_pop_reg64(&x64GenContext, REG_R14);
-	x64Gen_pop_reg64(&x64GenContext, REG_R13);
-	x64Gen_pop_reg64(&x64GenContext, REG_R12);
-	x64Gen_pop_reg64(&x64GenContext, REG_R11);
-	x64Gen_pop_reg64(&x64GenContext, REG_R10);
-	x64Gen_pop_reg64(&x64GenContext, REG_R9);
-	x64Gen_pop_reg64(&x64GenContext, REG_R8);
-	x64Gen_pop_reg64(&x64GenContext, REG_RSI);
-	x64Gen_pop_reg64(&x64GenContext, REG_RDI);
-	x64Gen_pop_reg64(&x64GenContext, REG_RBP);
-	x64Gen_pop_reg64(&x64GenContext, REG_RBX);
-	x64Gen_pop_reg64(&x64GenContext, REG_RDX);
-	x64Gen_pop_reg64(&x64GenContext, REG_RCX);
-	x64Gen_pop_reg64(&x64GenContext, REG_RAX);
-	// RET
-	x64Gen_ret(&x64GenContext);
-
-	uint8* executableMemory = PPCRecompilerX86_allocateExecutableMemory(x64GenContext.codeBufferIndex);
-	// copy code to executable memory
-	memcpy(executableMemory, x64GenContext.codeBuffer, x64GenContext.codeBufferIndex);
-	free(x64GenContext.codeBuffer);
-	PPCRecompiler_enterRecompilerCode = (void ATTR_MS_ABI (*)(uint64,uint64))executableMemory;
-}
-
-
-void* PPCRecompilerX64Gen_generateLeaveRecompilerCode()
-{
-	x64GenContext_t x64GenContext = {0};
-	x64GenContext.codeBufferSize = 128;
-	x64GenContext.codeBuffer = (uint8*)malloc(x64GenContext.codeBufferSize);
-	x64GenContext.codeBufferIndex = 0;
-	x64GenContext.activeCRRegister = PPC_REC_INVALID_REGISTER;
-
-	// update instruction pointer
-	// LR is in EDX
-	x64Emit_mov_mem32_reg32(&x64GenContext, REG_RSP, offsetof(PPCInterpreter_t, instructionPointer), REG_EDX);
-
-	// MOV RSP, [ppcRecompilerX64_rspTemp]
-	x64Emit_mov_reg64_mem64(&x64GenContext, REG_RSP, REG_RESV_HCPU, offsetof(PPCInterpreter_t, rspTemp));
-
-	// RET
-	x64Gen_ret(&x64GenContext);
-
-	uint8* executableMemory = PPCRecompilerX86_allocateExecutableMemory(x64GenContext.codeBufferIndex);
-	// copy code to executable memory
-	memcpy(executableMemory, x64GenContext.codeBuffer, x64GenContext.codeBufferIndex);
-	free(x64GenContext.codeBuffer);
-	return executableMemory;
-}
-
-void PPCRecompilerX64Gen_generateRecompilerInterfaceFunctions()
-{
-	PPCRecompilerX64Gen_generateEnterRecompilerCode();
-	PPCRecompiler_leaveRecompilerCode_unvisited = (void ATTR_MS_ABI (*)())PPCRecompilerX64Gen_generateLeaveRecompilerCode();
-	PPCRecompiler_leaveRecompilerCode_visited = (void ATTR_MS_ABI (*)())PPCRecompilerX64Gen_generateLeaveRecompilerCode();
-	cemu_assert_debug(PPCRecompiler_leaveRecompilerCode_unvisited != PPCRecompiler_leaveRecompilerCode_visited);
-}
\ No newline at end of file
diff --git a/src/Cafe/HW/Espresso/Recompiler/PPCRecompilerX64FPU.cpp b/src/Cafe/HW/Espresso/Recompiler/PPCRecompilerX64FPU.cpp
deleted file mode 100644
index fbb95b2f..00000000
--- a/src/Cafe/HW/Espresso/Recompiler/PPCRecompilerX64FPU.cpp
+++ /dev/null
@@ -1,1244 +0,0 @@
-#include "PPCRecompiler.h"
-#include "PPCRecompilerIml.h"
-#include "PPCRecompilerX64.h"
-#include "asm/x64util.h"
-
-void PPCRecompilerX64Gen_imlInstruction_fpr_r_name(PPCRecFunction_t* PPCRecFunction, ppcImlGenContext_t* ppcImlGenContext, x64GenContext_t* x64GenContext, PPCRecImlInstruction_t* imlInstruction)
-{
-	uint32 name = imlInstruction->op_r_name.name;
-	if( name >= PPCREC_NAME_FPR0 && name < (PPCREC_NAME_FPR0+32) )
-	{
-		x64Gen_movupd_xmmReg_memReg128(x64GenContext, tempToRealFPRRegister(imlInstruction->op_r_name.registerIndex), REG_ESP, offsetof(PPCInterpreter_t, fpr)+sizeof(FPR_t)*(name-PPCREC_NAME_FPR0));
-	}
-	else if( name >= PPCREC_NAME_TEMPORARY_FPR0 || name < (PPCREC_NAME_TEMPORARY_FPR0+8) )
-	{
-		x64Gen_movupd_xmmReg_memReg128(x64GenContext, tempToRealFPRRegister(imlInstruction->op_r_name.registerIndex), REG_ESP, offsetof(PPCInterpreter_t, temporaryFPR)+sizeof(FPR_t)*(name-PPCREC_NAME_TEMPORARY_FPR0));
-	}
-	else
-	{
-		cemu_assert_debug(false);
-	}
-}
-
-void PPCRecompilerX64Gen_imlInstruction_fpr_name_r(PPCRecFunction_t* PPCRecFunction, ppcImlGenContext_t* ppcImlGenContext, x64GenContext_t* x64GenContext, PPCRecImlInstruction_t* imlInstruction)
-{
-	uint32 name = imlInstruction->op_r_name.name;
-	if( name >= PPCREC_NAME_FPR0 && name < (PPCREC_NAME_FPR0+32) )
-	{
-		x64Gen_movupd_memReg128_xmmReg(x64GenContext, tempToRealFPRRegister(imlInstruction->op_r_name.registerIndex), REG_ESP, offsetof(PPCInterpreter_t, fpr)+sizeof(FPR_t)*(name-PPCREC_NAME_FPR0));
-	}
-	else if( name >= PPCREC_NAME_TEMPORARY_FPR0 && name < (PPCREC_NAME_TEMPORARY_FPR0+8) )
-	{
-		x64Gen_movupd_memReg128_xmmReg(x64GenContext, tempToRealFPRRegister(imlInstruction->op_r_name.registerIndex), REG_ESP, offsetof(PPCInterpreter_t, temporaryFPR)+sizeof(FPR_t)*(name-PPCREC_NAME_TEMPORARY_FPR0));
-	}
-	else
-	{
-		cemu_assert_debug(false);
-	}
-}
-
-void PPCRecompilerX64Gen_imlInstr_gqr_generateScaleCode(ppcImlGenContext_t* ppcImlGenContext, x64GenContext_t* x64GenContext, sint32 registerXMM, bool isLoad, bool scalePS1, sint32 registerGQR)
-{
-	// load GQR
-	x64Gen_mov_reg64_reg64(x64GenContext, REG_RESV_TEMP, registerGQR);
-	// extract scale field and multiply by 16 to get array offset
-	x64Gen_shr_reg64Low32_imm8(x64GenContext, REG_RESV_TEMP, (isLoad?16:0)+8-4);
-	x64Gen_and_reg64Low32_imm32(x64GenContext, REG_RESV_TEMP, (0x3F<<4));
-	// multiply xmm by scale
-	x64Gen_add_reg64_reg64(x64GenContext, REG_RESV_TEMP, REG_RESV_RECDATA);
-	if (isLoad)
-	{
-		if(scalePS1)
-			x64Gen_mulpd_xmmReg_memReg128(x64GenContext, registerXMM, REG_RESV_TEMP, offsetof(PPCRecompilerInstanceData_t, _psq_ld_scale_ps0_ps1));
-		else
-			x64Gen_mulpd_xmmReg_memReg128(x64GenContext, registerXMM, REG_RESV_TEMP, offsetof(PPCRecompilerInstanceData_t, _psq_ld_scale_ps0_1));
-	}
-	else
-	{
-		if (scalePS1)
-			x64Gen_mulpd_xmmReg_memReg128(x64GenContext, registerXMM, REG_RESV_TEMP, offsetof(PPCRecompilerInstanceData_t, _psq_st_scale_ps0_ps1));
-		else
-			x64Gen_mulpd_xmmReg_memReg128(x64GenContext, registerXMM, REG_RESV_TEMP, offsetof(PPCRecompilerInstanceData_t, _psq_st_scale_ps0_1));
-	}
-}
-
-// generate code for PSQ load for a particular type
-// if scaleGQR is -1 then a scale of 1.0 is assumed (no scale)
-void PPCRecompilerX64Gen_imlInstr_psq_load(ppcImlGenContext_t* ppcImlGenContext, x64GenContext_t* x64GenContext, uint8 mode, sint32 registerXMM, sint32 memReg, sint32 memRegEx, sint32 memImmS32, bool indexed, sint32 registerGQR = -1)
-{
-	if (mode == PPCREC_FPR_LD_MODE_PSQ_FLOAT_PS0_PS1)
-	{
-		if (indexed)
-		{
-			assert_dbg();
-		}
-		// optimized code for ps float load
-		x64Emit_mov_reg64_mem64(x64GenContext, REG_RESV_TEMP, REG_R13, memReg, memImmS32);
-		x64Gen_bswap_reg64(x64GenContext, REG_RESV_TEMP);
-		x64Gen_rol_reg64_imm8(x64GenContext, REG_RESV_TEMP, 32); // swap upper and lower DWORD
-		x64Gen_movq_xmmReg_reg64(x64GenContext, registerXMM, REG_RESV_TEMP);
-		x64Gen_cvtps2pd_xmmReg_xmmReg(x64GenContext, registerXMM, registerXMM);
-		// note: floats are not scaled
-	}
-	else if (mode == PPCREC_FPR_LD_MODE_PSQ_FLOAT_PS0)
-	{
-		if (indexed)
-		{
-			x64Gen_mov_reg64Low32_reg64Low32(x64GenContext, REG_RESV_TEMP, memRegEx);
-			x64Gen_add_reg64Low32_reg64Low32(x64GenContext, REG_RESV_TEMP, memReg);
-			if (hasMOVBESupport)
-			{
-				x64Gen_movBEZeroExtend_reg64_mem32Reg64PlusReg64(x64GenContext, REG_RESV_TEMP, REG_RESV_MEMBASE, REG_RESV_TEMP, memImmS32);
-			}
-			else
-			{
-				x64Emit_mov_reg32_mem32(x64GenContext, REG_RESV_TEMP, REG_RESV_MEMBASE, REG_RESV_TEMP, memImmS32);
-				x64Gen_bswap_reg64Lower32bit(x64GenContext, REG_RESV_TEMP);
-			}
-		}
-		else
-		{
-			if (hasMOVBESupport)
-			{
-				x64Gen_movBEZeroExtend_reg64_mem32Reg64PlusReg64(x64GenContext, REG_RESV_TEMP, REG_RESV_MEMBASE, memReg, memImmS32);
-			}
-			else
-			{
-				x64Emit_mov_reg32_mem32(x64GenContext, REG_RESV_TEMP, REG_RESV_MEMBASE, memReg, memImmS32);
-				x64Gen_bswap_reg64Lower32bit(x64GenContext, REG_RESV_TEMP);
-			}
-		}
-		if (hasAVXSupport)
-		{
-			x64Gen_movd_xmmReg_reg64Low32(x64GenContext, REG_RESV_FPR_TEMP, REG_RESV_TEMP);
-		}
-		else
-		{
-			x64Emit_mov_mem32_reg64(x64GenContext, REG_RSP, offsetof(PPCInterpreter_t, temporaryFPR), REG_RESV_TEMP);
-			x64Gen_movddup_xmmReg_memReg64(x64GenContext, REG_RESV_FPR_TEMP, REG_RSP, offsetof(PPCInterpreter_t, temporaryFPR));
-		}
-		x64Gen_cvtss2sd_xmmReg_xmmReg(x64GenContext, REG_RESV_FPR_TEMP, REG_RESV_FPR_TEMP);
-		// load constant 1.0 into lower half and upper half of temp register
-		x64Gen_movddup_xmmReg_memReg64(x64GenContext, registerXMM, REG_RESV_RECDATA, offsetof(PPCRecompilerInstanceData_t, _x64XMM_constDouble1_1));
-		// overwrite lower half with single from memory
-		x64Gen_movsd_xmmReg_xmmReg(x64GenContext, registerXMM, REG_RESV_FPR_TEMP);
-		// note: floats are not scaled
-	}
-	else
-	{
-		sint32 readSize;
-		bool isSigned = false;
-		if (mode == PPCREC_FPR_LD_MODE_PSQ_S16_PS0 ||
-			mode == PPCREC_FPR_LD_MODE_PSQ_S16_PS0_PS1)
-		{
-			readSize = 16;
-			isSigned = true;
-		}
-		else if (mode == PPCREC_FPR_LD_MODE_PSQ_U16_PS0 ||
-			mode == PPCREC_FPR_LD_MODE_PSQ_U16_PS0_PS1)
-		{
-			readSize = 16;
-			isSigned = false;
-		}
-		else if (mode == PPCREC_FPR_LD_MODE_PSQ_S8_PS0 ||
-			mode == PPCREC_FPR_LD_MODE_PSQ_S8_PS0_PS1)
-		{
-			readSize = 8;
-			isSigned = true;
-		}
-		else if (mode == PPCREC_FPR_LD_MODE_PSQ_U8_PS0 ||
-			mode == PPCREC_FPR_LD_MODE_PSQ_U8_PS0_PS1)
-		{
-			readSize = 8;
-			isSigned = false;
-		}
-		else
-			assert_dbg();
-
-		bool loadPS1 = (mode == PPCREC_FPR_LD_MODE_PSQ_S16_PS0_PS1 ||
-						mode == PPCREC_FPR_LD_MODE_PSQ_U16_PS0_PS1 ||
-						mode == PPCREC_FPR_LD_MODE_PSQ_U8_PS0_PS1 ||
-						mode == PPCREC_FPR_LD_MODE_PSQ_S8_PS0_PS1);
-		for (sint32 wordIndex = 0; wordIndex < 2; wordIndex++)
-		{
-			if (indexed)
-			{
-				assert_dbg();
-			}
-			// read from memory
-			if (wordIndex == 1 && loadPS1 == false)
-			{
-				// store constant 1
-				x64Gen_mov_mem32Reg64_imm32(x64GenContext, REG_RESV_HCPU, offsetof(PPCInterpreter_t, temporaryGPR) + sizeof(uint32) * 1, 1);
-			}
-			else
-			{
-				uint32 memOffset = memImmS32 + wordIndex * (readSize / 8);
-				if (readSize == 16)
-				{
-					// half word
-					x64Gen_movZeroExtend_reg64Low16_mem16Reg64PlusReg64(x64GenContext, REG_RESV_TEMP, REG_R13, memReg, memOffset);
-					x64Gen_rol_reg64Low16_imm8(x64GenContext, REG_RESV_TEMP, 8); // endian swap
-					if (isSigned)
-						x64Gen_movSignExtend_reg64Low32_reg64Low16(x64GenContext, REG_RESV_TEMP, REG_RESV_TEMP);
-					else
-						x64Gen_movZeroExtend_reg64Low32_reg64Low16(x64GenContext, REG_RESV_TEMP, REG_RESV_TEMP);
-				}
-				else if (readSize == 8)
-				{
-					// byte
-					x64Emit_mov_reg64b_mem8(x64GenContext, REG_RESV_TEMP, REG_R13, memReg, memOffset);
-					if (isSigned)
-						x64Gen_movSignExtend_reg64Low32_reg64Low8(x64GenContext, REG_RESV_TEMP, REG_RESV_TEMP);
-					else
-						x64Gen_movZeroExtend_reg64Low32_reg64Low8(x64GenContext, REG_RESV_TEMP, REG_RESV_TEMP);
-				}
-				// store
-				x64Emit_mov_mem32_reg32(x64GenContext, REG_RESV_HCPU, offsetof(PPCInterpreter_t, temporaryGPR) + sizeof(uint32) * wordIndex, REG_RESV_TEMP);
-			}
-		}
-		// convert the two integers to doubles
-		x64Gen_cvtpi2pd_xmmReg_mem64Reg64(x64GenContext, registerXMM, REG_RESV_HCPU, offsetof(PPCInterpreter_t, temporaryGPR));
-		// scale
-		if (registerGQR >= 0)
-			PPCRecompilerX64Gen_imlInstr_gqr_generateScaleCode(ppcImlGenContext, x64GenContext, registerXMM, true, loadPS1, registerGQR);
-	}
-}
-
-void PPCRecompilerX64Gen_imlInstr_psq_load_generic(ppcImlGenContext_t* ppcImlGenContext, x64GenContext_t* x64GenContext, uint8 mode, sint32 registerXMM, sint32 memReg, sint32 memRegEx, sint32 memImmS32, bool indexed, sint32 registerGQR)
-{
-	bool loadPS1 = (mode == PPCREC_FPR_LD_MODE_PSQ_GENERIC_PS0_PS1);
-	// load GQR
-	x64Gen_mov_reg64_reg64(x64GenContext, REG_RESV_TEMP, registerGQR);
-	// extract load type field
-	x64Gen_shr_reg64Low32_imm8(x64GenContext, REG_RESV_TEMP, 16);
-	x64Gen_and_reg64Low32_imm32(x64GenContext, REG_RESV_TEMP, 7);
-	// jump cases
-	x64Gen_cmp_reg64Low32_imm32(x64GenContext, REG_RESV_TEMP, 4); // type 4 -> u8
-	sint32 jumpOffset_caseU8 = x64GenContext->codeBufferIndex;
-	x64Gen_jmpc_far(x64GenContext, X86_CONDITION_EQUAL, 0);
-	x64Gen_cmp_reg64Low32_imm32(x64GenContext, REG_RESV_TEMP, 5); // type 5 -> u16
-	sint32 jumpOffset_caseU16 = x64GenContext->codeBufferIndex;
-	x64Gen_jmpc_far(x64GenContext, X86_CONDITION_EQUAL, 0);
-	x64Gen_cmp_reg64Low32_imm32(x64GenContext, REG_RESV_TEMP, 6); // type 4 -> s8
-	sint32 jumpOffset_caseS8 = x64GenContext->codeBufferIndex;
-	x64Gen_jmpc_far(x64GenContext, X86_CONDITION_EQUAL, 0);
-	x64Gen_cmp_reg64Low32_imm32(x64GenContext, REG_RESV_TEMP, 7); // type 5 -> s16
-	sint32 jumpOffset_caseS16 = x64GenContext->codeBufferIndex;
-	x64Gen_jmpc_far(x64GenContext, X86_CONDITION_EQUAL, 0);
-	// default case -> float
-
-	// generate cases
-	uint32 jumpOffset_endOfFloat;
-	uint32 jumpOffset_endOfU8;
-	uint32 jumpOffset_endOfU16;
-	uint32 jumpOffset_endOfS8;
-
-	PPCRecompilerX64Gen_imlInstr_psq_load(ppcImlGenContext, x64GenContext, loadPS1 ? PPCREC_FPR_LD_MODE_PSQ_FLOAT_PS0_PS1 : PPCREC_FPR_LD_MODE_PSQ_FLOAT_PS0, registerXMM, memReg, memRegEx, memImmS32, indexed, registerGQR);
-	jumpOffset_endOfFloat = x64GenContext->codeBufferIndex;
-	x64Gen_jmp_imm32(x64GenContext, 0);
-
-	PPCRecompilerX64Gen_redirectRelativeJump(x64GenContext, jumpOffset_caseU16, x64GenContext->codeBufferIndex);
-	PPCRecompilerX64Gen_imlInstr_psq_load(ppcImlGenContext, x64GenContext, loadPS1 ? PPCREC_FPR_LD_MODE_PSQ_U16_PS0_PS1 : PPCREC_FPR_LD_MODE_PSQ_U16_PS0, registerXMM, memReg, memRegEx, memImmS32, indexed, registerGQR);
-	jumpOffset_endOfU8 = x64GenContext->codeBufferIndex;
-	x64Gen_jmp_imm32(x64GenContext, 0);
-
-	PPCRecompilerX64Gen_redirectRelativeJump(x64GenContext, jumpOffset_caseS16, x64GenContext->codeBufferIndex);
-	PPCRecompilerX64Gen_imlInstr_psq_load(ppcImlGenContext, x64GenContext, loadPS1 ? PPCREC_FPR_LD_MODE_PSQ_S16_PS0_PS1 : PPCREC_FPR_LD_MODE_PSQ_S16_PS0, registerXMM, memReg, memRegEx, memImmS32, indexed, registerGQR);
-	jumpOffset_endOfU16 = x64GenContext->codeBufferIndex;
-	x64Gen_jmp_imm32(x64GenContext, 0);
-
-	PPCRecompilerX64Gen_redirectRelativeJump(x64GenContext, jumpOffset_caseU8, x64GenContext->codeBufferIndex);
-	PPCRecompilerX64Gen_imlInstr_psq_load(ppcImlGenContext, x64GenContext, loadPS1 ? PPCREC_FPR_LD_MODE_PSQ_U8_PS0_PS1 : PPCREC_FPR_LD_MODE_PSQ_U8_PS0, registerXMM, memReg, memRegEx, memImmS32, indexed, registerGQR);
-	jumpOffset_endOfS8 = x64GenContext->codeBufferIndex;
-	x64Gen_jmp_imm32(x64GenContext, 0);
-
-	PPCRecompilerX64Gen_redirectRelativeJump(x64GenContext, jumpOffset_caseS8, x64GenContext->codeBufferIndex);
-	PPCRecompilerX64Gen_imlInstr_psq_load(ppcImlGenContext, x64GenContext, loadPS1 ? PPCREC_FPR_LD_MODE_PSQ_S8_PS0_PS1 : PPCREC_FPR_LD_MODE_PSQ_S8_PS0, registerXMM, memReg, memRegEx, memImmS32, indexed, registerGQR);
-
-	PPCRecompilerX64Gen_redirectRelativeJump(x64GenContext, jumpOffset_endOfFloat, x64GenContext->codeBufferIndex);
-	PPCRecompilerX64Gen_redirectRelativeJump(x64GenContext, jumpOffset_endOfU8, x64GenContext->codeBufferIndex);
-	PPCRecompilerX64Gen_redirectRelativeJump(x64GenContext, jumpOffset_endOfU16, x64GenContext->codeBufferIndex);
-	PPCRecompilerX64Gen_redirectRelativeJump(x64GenContext, jumpOffset_endOfS8, x64GenContext->codeBufferIndex);
-}
-
-// load from memory
-bool PPCRecompilerX64Gen_imlInstruction_fpr_load(PPCRecFunction_t* PPCRecFunction, ppcImlGenContext_t* ppcImlGenContext, x64GenContext_t* x64GenContext, PPCRecImlInstruction_t* imlInstruction, bool indexed)
-{
-	PPCRecompilerX64Gen_crConditionFlags_forget(PPCRecFunction, ppcImlGenContext, x64GenContext);
-	sint32 realRegisterXMM = tempToRealFPRRegister(imlInstruction->op_storeLoad.registerData);
-	sint32 realRegisterMem = tempToRealRegister(imlInstruction->op_storeLoad.registerMem);
-	sint32 realRegisterMem2 = PPC_REC_INVALID_REGISTER;
-	if( indexed )
-		realRegisterMem2 = tempToRealRegister(imlInstruction->op_storeLoad.registerMem2);
-	uint8 mode = imlInstruction->op_storeLoad.mode;
-
-	if( mode == PPCREC_FPR_LD_MODE_SINGLE_INTO_PS0_PS1 )
-	{
-		// load byte swapped single into temporary FPR
-		if( indexed )
-		{
-			x64Gen_mov_reg64Low32_reg64Low32(x64GenContext, REG_RESV_TEMP, realRegisterMem2);
-			x64Gen_add_reg64Low32_reg64Low32(x64GenContext, REG_RESV_TEMP, realRegisterMem);
-			if( hasMOVBESupport )
-				x64Gen_movBEZeroExtend_reg64_mem32Reg64PlusReg64(x64GenContext, REG_RESV_TEMP, REG_RESV_MEMBASE, REG_RESV_TEMP, imlInstruction->op_storeLoad.immS32);
-			else
-				x64Emit_mov_reg32_mem32(x64GenContext, REG_RESV_TEMP, REG_RESV_MEMBASE, REG_RESV_TEMP, imlInstruction->op_storeLoad.immS32);
-		}
-		else
-		{
-			if( hasMOVBESupport )
-				x64Gen_movBEZeroExtend_reg64_mem32Reg64PlusReg64(x64GenContext, REG_RESV_TEMP, REG_RESV_MEMBASE, realRegisterMem, imlInstruction->op_storeLoad.immS32);
-			else
-				x64Emit_mov_reg32_mem32(x64GenContext, REG_RESV_TEMP, REG_RESV_MEMBASE, realRegisterMem, imlInstruction->op_storeLoad.immS32);
-		}
-		if( hasMOVBESupport == false )
-			x64Gen_bswap_reg64Lower32bit(x64GenContext, REG_RESV_TEMP);
-		if( hasAVXSupport )
-		{
-			x64Gen_movd_xmmReg_reg64Low32(x64GenContext, realRegisterXMM, REG_RESV_TEMP);
-		}
-		else
-		{
-			x64Emit_mov_mem32_reg64(x64GenContext, REG_RSP, offsetof(PPCInterpreter_t, temporaryFPR), REG_RESV_TEMP);
-			x64Gen_movddup_xmmReg_memReg64(x64GenContext, realRegisterXMM, REG_RSP, offsetof(PPCInterpreter_t, temporaryFPR));
-		}
-
-		if (imlInstruction->op_storeLoad.flags2.notExpanded)
-		{
-			// leave value as single
-		}
-		else
-		{
-			x64Gen_cvtss2sd_xmmReg_xmmReg(x64GenContext, realRegisterXMM, realRegisterXMM);
-			x64Gen_movddup_xmmReg_xmmReg(x64GenContext, realRegisterXMM, realRegisterXMM);
-		}		
-	}
-	else if( mode == PPCREC_FPR_LD_MODE_DOUBLE_INTO_PS0 )
-	{
-		if( hasAVXSupport )
-		{
-			if( indexed )
-			{
-				// calculate offset
-				x64Gen_mov_reg64Low32_reg64Low32(x64GenContext, REG_RESV_TEMP, realRegisterMem);
-				x64Gen_add_reg64Low32_reg64Low32(x64GenContext, REG_RESV_TEMP, realRegisterMem2);
-				// load value
-				x64Emit_mov_reg64_mem64(x64GenContext, REG_RESV_TEMP, REG_R13, REG_RESV_TEMP, imlInstruction->op_storeLoad.immS32+0);
-				x64Gen_bswap_reg64(x64GenContext, REG_RESV_TEMP);
-				x64Gen_movq_xmmReg_reg64(x64GenContext, REG_RESV_FPR_TEMP, REG_RESV_TEMP);
-				x64Gen_movsd_xmmReg_xmmReg(x64GenContext, realRegisterXMM, REG_RESV_FPR_TEMP);
-			}
-			else
-			{
-				x64Emit_mov_reg64_mem64(x64GenContext, REG_RESV_TEMP, REG_R13, realRegisterMem, imlInstruction->op_storeLoad.immS32+0);
-				x64Gen_bswap_reg64(x64GenContext, REG_RESV_TEMP);
-				x64Gen_movq_xmmReg_reg64(x64GenContext, REG_RESV_FPR_TEMP, REG_RESV_TEMP);
-				x64Gen_movsd_xmmReg_xmmReg(x64GenContext, realRegisterXMM, REG_RESV_FPR_TEMP);
-			}
-		}
-		else
-		{
-			if( indexed )
-			{
-				// calculate offset
-				x64Gen_mov_reg64Low32_reg64Low32(x64GenContext, REG_RESV_TEMP, realRegisterMem);
-				x64Gen_add_reg64Low32_reg64Low32(x64GenContext, REG_RESV_TEMP, realRegisterMem2);
-				// load double low part to temporaryFPR
-				x64Emit_mov_reg32_mem32(x64GenContext, REG_RESV_TEMP, REG_R13, REG_RESV_TEMP, imlInstruction->op_storeLoad.immS32+0);
-				x64Gen_bswap_reg64Lower32bit(x64GenContext, REG_RESV_TEMP);
-				x64Emit_mov_mem32_reg64(x64GenContext, REG_RSP, offsetof(PPCInterpreter_t, temporaryFPR)+4, REG_RESV_TEMP);
-				// calculate offset again
-				x64Gen_mov_reg64Low32_reg64Low32(x64GenContext, REG_RESV_TEMP, realRegisterMem);
-				x64Gen_add_reg64Low32_reg64Low32(x64GenContext, REG_RESV_TEMP, realRegisterMem2);
-				// load double high part to temporaryFPR
-				x64Emit_mov_reg32_mem32(x64GenContext, REG_RESV_TEMP, REG_R13, REG_RESV_TEMP, imlInstruction->op_storeLoad.immS32+4);
-				x64Gen_bswap_reg64Lower32bit(x64GenContext, REG_RESV_TEMP);
-				x64Emit_mov_mem32_reg64(x64GenContext, REG_RSP, offsetof(PPCInterpreter_t, temporaryFPR)+0, REG_RESV_TEMP);
-				// load double from temporaryFPR
-				x64Gen_movlpd_xmmReg_memReg64(x64GenContext, realRegisterXMM, REG_RSP, offsetof(PPCInterpreter_t, temporaryFPR));
-			}
-			else
-			{
-				// load double low part to temporaryFPR
-				x64Emit_mov_reg32_mem32(x64GenContext, REG_RESV_TEMP, REG_R13, realRegisterMem, imlInstruction->op_storeLoad.immS32+0);
-				x64Gen_bswap_reg64Lower32bit(x64GenContext, REG_RESV_TEMP);
-				x64Emit_mov_mem32_reg64(x64GenContext, REG_RSP, offsetof(PPCInterpreter_t, temporaryFPR)+4, REG_RESV_TEMP);
-				// load double high part to temporaryFPR
-				x64Emit_mov_reg32_mem32(x64GenContext, REG_RESV_TEMP, REG_R13, realRegisterMem, imlInstruction->op_storeLoad.immS32+4);
-				x64Gen_bswap_reg64Lower32bit(x64GenContext, REG_RESV_TEMP);
-				x64Emit_mov_mem32_reg64(x64GenContext, REG_RSP, offsetof(PPCInterpreter_t, temporaryFPR)+0, REG_RESV_TEMP);
-				// load double from temporaryFPR
-				x64Gen_movlpd_xmmReg_memReg64(x64GenContext, realRegisterXMM, REG_RSP, offsetof(PPCInterpreter_t, temporaryFPR));
-			}
-		}
-	}
-	else if (mode == PPCREC_FPR_LD_MODE_PSQ_FLOAT_PS0_PS1 ||
-			 mode == PPCREC_FPR_LD_MODE_PSQ_FLOAT_PS0 ||
- 			 mode == PPCREC_FPR_LD_MODE_PSQ_S16_PS0 ||
- 			 mode == PPCREC_FPR_LD_MODE_PSQ_S16_PS0_PS1 ||
-			 mode == PPCREC_FPR_LD_MODE_PSQ_S16_PS0 ||
-			 mode == PPCREC_FPR_LD_MODE_PSQ_U16_PS0 ||
-			 mode == PPCREC_FPR_LD_MODE_PSQ_U16_PS0_PS1 ||
-			 mode == PPCREC_FPR_LD_MODE_PSQ_S8_PS0 ||
-			 mode == PPCREC_FPR_LD_MODE_PSQ_S8_PS0_PS1 ||
-			 mode == PPCREC_FPR_LD_MODE_PSQ_S8_PS0 ||
-			 mode == PPCREC_FPR_LD_MODE_PSQ_U8_PS0_PS1 )
-	{
-		PPCRecompilerX64Gen_imlInstr_psq_load(ppcImlGenContext, x64GenContext, mode, realRegisterXMM, realRegisterMem, realRegisterMem2, imlInstruction->op_storeLoad.immS32, indexed);
-	}
-	else if (mode == PPCREC_FPR_LD_MODE_PSQ_GENERIC_PS0_PS1 ||
-		   	 mode == PPCREC_FPR_LD_MODE_PSQ_GENERIC_PS0)
-	{
-		PPCRecompilerX64Gen_imlInstr_psq_load_generic(ppcImlGenContext, x64GenContext, mode, realRegisterXMM, realRegisterMem, realRegisterMem2, imlInstruction->op_storeLoad.immS32, indexed, tempToRealRegister(imlInstruction->op_storeLoad.registerGQR));
-	}
-	else
-	{
-		return false;
-	}
-	return true;
-}
-
-void PPCRecompilerX64Gen_imlInstr_psq_store(ppcImlGenContext_t* ppcImlGenContext, x64GenContext_t* x64GenContext, uint8 mode, sint32 registerXMM, sint32 memReg, sint32 memRegEx, sint32 memImmS32, bool indexed, sint32 registerGQR = -1)
-{
-	bool storePS1 = (mode == PPCREC_FPR_ST_MODE_PSQ_FLOAT_PS0_PS1 ||
-		mode == PPCREC_FPR_ST_MODE_PSQ_S8_PS0_PS1 ||
-		mode == PPCREC_FPR_ST_MODE_PSQ_U8_PS0_PS1 ||
-		mode == PPCREC_FPR_ST_MODE_PSQ_U16_PS0_PS1 ||
-		mode == PPCREC_FPR_ST_MODE_PSQ_S16_PS0_PS1);
-	bool isFloat = mode == PPCREC_FPR_ST_MODE_PSQ_FLOAT_PS0 || mode == PPCREC_FPR_ST_MODE_PSQ_FLOAT_PS0_PS1;
-	if (registerGQR >= 0)
-	{
-		// move to temporary xmm and update registerXMM
-		x64Gen_movaps_xmmReg_xmmReg(x64GenContext, REG_RESV_FPR_TEMP, registerXMM);
-		registerXMM = REG_RESV_FPR_TEMP;
-		// apply scale
-		if(isFloat == false)
-			PPCRecompilerX64Gen_imlInstr_gqr_generateScaleCode(ppcImlGenContext, x64GenContext, registerXMM, false, storePS1, registerGQR);
-	}
-	if (mode == PPCREC_FPR_ST_MODE_PSQ_FLOAT_PS0)
-	{
-		x64Gen_cvtsd2ss_xmmReg_xmmReg(x64GenContext, REG_RESV_FPR_TEMP, registerXMM);
-		if (hasAVXSupport)
-		{
-			x64Gen_movd_reg64Low32_xmmReg(x64GenContext, REG_RESV_TEMP, REG_RESV_FPR_TEMP);
-		}
-		else
-		{
-			x64Gen_movsd_memReg64_xmmReg(x64GenContext, REG_RESV_FPR_TEMP, REG_RSP, offsetof(PPCInterpreter_t, temporaryFPR));
-			x64Emit_mov_reg64_mem32(x64GenContext, REG_RESV_TEMP, REG_RSP, offsetof(PPCInterpreter_t, temporaryFPR));
-		}
-		if (hasMOVBESupport == false)
-			x64Gen_bswap_reg64Lower32bit(x64GenContext, REG_RESV_TEMP);
-		if (indexed)
-		{
-			cemu_assert_debug(memReg != memRegEx);
-			x64Gen_add_reg64Low32_reg64Low32(x64GenContext, memReg, memRegEx);
-		}
-		if (hasMOVBESupport)
-			x64Gen_movBETruncate_mem32Reg64PlusReg64_reg64(x64GenContext, REG_R13, memReg, memImmS32, REG_RESV_TEMP);
-		else
-			x64Gen_movTruncate_mem32Reg64PlusReg64_reg64(x64GenContext, REG_R13, memReg, memImmS32, REG_RESV_TEMP);
-		if (indexed)
-		{
-			x64Gen_sub_reg64Low32_reg64Low32(x64GenContext, memReg, memRegEx);
-		}
-		return;
-	}
-	else if (mode == PPCREC_FPR_ST_MODE_PSQ_FLOAT_PS0_PS1)
-	{
-		if (indexed)
-			assert_dbg(); // todo
-		x64Gen_cvtpd2ps_xmmReg_xmmReg(x64GenContext, REG_RESV_FPR_TEMP, registerXMM);
-		x64Gen_movq_reg64_xmmReg(x64GenContext, REG_RESV_TEMP, REG_RESV_FPR_TEMP);
-		x64Gen_rol_reg64_imm8(x64GenContext, REG_RESV_TEMP, 32); // swap upper and lower DWORD
-		x64Gen_bswap_reg64(x64GenContext, REG_RESV_TEMP);
-		x64Gen_mov_mem64Reg64PlusReg64_reg64(x64GenContext, REG_RESV_TEMP, REG_R13, memReg, memImmS32);
-		return;
-	}
-	// store as integer
-	// get limit from mode
-	sint32 clampMin, clampMax;
-	sint32 bitWriteSize;
-	if (mode == PPCREC_FPR_ST_MODE_PSQ_S8_PS0 ||
-		mode == PPCREC_FPR_ST_MODE_PSQ_S8_PS0_PS1 )
-	{
-		clampMin = -128;
-		clampMax = 127;
-		bitWriteSize = 8;
-	}
-	else if (mode == PPCREC_FPR_ST_MODE_PSQ_U8_PS0 ||
-		mode == PPCREC_FPR_ST_MODE_PSQ_U8_PS0_PS1 )
-	{
-		clampMin = 0;
-		clampMax = 255;
-		bitWriteSize = 8;
-	}
-	else if (mode == PPCREC_FPR_ST_MODE_PSQ_U16_PS0 ||
-		mode == PPCREC_FPR_ST_MODE_PSQ_U16_PS0_PS1 )
-	{
-		clampMin = 0;
-		clampMax = 0xFFFF;
-		bitWriteSize = 16;
-	}
-	else if (mode == PPCREC_FPR_ST_MODE_PSQ_S16_PS0 ||
-		mode == PPCREC_FPR_ST_MODE_PSQ_S16_PS0_PS1 )
-	{
-		clampMin = -32768;
-		clampMax = 32767;
-		bitWriteSize = 16;
-	}
-	else
-	{
-		cemu_assert(false);
-	}
-	for (sint32 valueIndex = 0; valueIndex < (storePS1?2:1); valueIndex++)
-	{
-		// todo - multiply by GQR scale
-		if (valueIndex == 0)
-		{
-			// convert low half (PS0) to integer
-			x64Gen_cvttsd2si_reg64Low_xmmReg(x64GenContext, REG_RESV_TEMP, registerXMM);
-		}
-		else
-		{
-			// load top half (PS1) into bottom half of temporary register
-			x64Gen_movhlps_xmmReg_xmmReg(x64GenContext, REG_RESV_FPR_TEMP, registerXMM);
-			// convert low half to integer
-			x64Gen_cvttsd2si_reg64Low_xmmReg(x64GenContext, REG_RESV_TEMP, REG_RESV_FPR_TEMP);
-		}
-		// max(i, -clampMin)
-		x64Gen_cmp_reg64Low32_imm32(x64GenContext, REG_RESV_TEMP, clampMin);
-		sint32 jumpInstructionOffset1 = x64GenContext->codeBufferIndex;
-		x64Gen_jmpc_near(x64GenContext, X86_CONDITION_SIGNED_GREATER_EQUAL, 0);
-		x64Gen_mov_reg64Low32_imm32(x64GenContext, REG_RESV_TEMP, clampMin);
-		PPCRecompilerX64Gen_redirectRelativeJump(x64GenContext, jumpInstructionOffset1, x64GenContext->codeBufferIndex);
-		// min(i, clampMax)
-		x64Gen_cmp_reg64Low32_imm32(x64GenContext, REG_RESV_TEMP, clampMax);
-		sint32 jumpInstructionOffset2 = x64GenContext->codeBufferIndex;
-		x64Gen_jmpc_near(x64GenContext, X86_CONDITION_SIGNED_LESS_EQUAL, 0);
-		x64Gen_mov_reg64Low32_imm32(x64GenContext, REG_RESV_TEMP, clampMax);
-		PPCRecompilerX64Gen_redirectRelativeJump(x64GenContext, jumpInstructionOffset2, x64GenContext->codeBufferIndex);
-		// endian swap
-		if( bitWriteSize == 16)
-			x64Gen_rol_reg64Low16_imm8(x64GenContext, REG_RESV_TEMP, 8);
-		// write to memory
-		if (indexed)
-			assert_dbg(); // unsupported
-		sint32 memOffset = memImmS32 + valueIndex * (bitWriteSize/8);
-		if (bitWriteSize == 8)
-			x64Gen_movTruncate_mem8Reg64PlusReg64_reg64(x64GenContext, REG_RESV_MEMBASE, memReg, memOffset, REG_RESV_TEMP);
-		else if (bitWriteSize == 16)
-			x64Gen_movTruncate_mem16Reg64PlusReg64_reg64(x64GenContext, REG_RESV_MEMBASE, memReg, memOffset, REG_RESV_TEMP);
-	}
-}
-
-void PPCRecompilerX64Gen_imlInstr_psq_store_generic(ppcImlGenContext_t* ppcImlGenContext, x64GenContext_t* x64GenContext, uint8 mode, sint32 registerXMM, sint32 memReg, sint32 memRegEx, sint32 memImmS32, bool indexed, sint32 registerGQR)
-{
-	bool storePS1 = (mode == PPCREC_FPR_ST_MODE_PSQ_GENERIC_PS0_PS1);
-	// load GQR
-	x64Gen_mov_reg64_reg64(x64GenContext, REG_RESV_TEMP, registerGQR);
-	// extract store type field
-	x64Gen_and_reg64Low32_imm32(x64GenContext, REG_RESV_TEMP, 7);
-	// jump cases
-	x64Gen_cmp_reg64Low32_imm32(x64GenContext, REG_RESV_TEMP, 4); // type 4 -> u8
-	sint32 jumpOffset_caseU8 = x64GenContext->codeBufferIndex;
-	x64Gen_jmpc_far(x64GenContext, X86_CONDITION_EQUAL, 0);
-	x64Gen_cmp_reg64Low32_imm32(x64GenContext, REG_RESV_TEMP, 5); // type 5 -> u16
-	sint32 jumpOffset_caseU16 = x64GenContext->codeBufferIndex;
-	x64Gen_jmpc_far(x64GenContext, X86_CONDITION_EQUAL, 0);
-	x64Gen_cmp_reg64Low32_imm32(x64GenContext, REG_RESV_TEMP, 6); // type 4 -> s8
-	sint32 jumpOffset_caseS8 = x64GenContext->codeBufferIndex;
-	x64Gen_jmpc_far(x64GenContext, X86_CONDITION_EQUAL, 0);
-	x64Gen_cmp_reg64Low32_imm32(x64GenContext, REG_RESV_TEMP, 7); // type 5 -> s16
-	sint32 jumpOffset_caseS16 = x64GenContext->codeBufferIndex;
-	x64Gen_jmpc_far(x64GenContext, X86_CONDITION_EQUAL, 0);
-	// default case -> float
-
-	// generate cases
-	uint32 jumpOffset_endOfFloat;
-	uint32 jumpOffset_endOfU8;
-	uint32 jumpOffset_endOfU16;
-	uint32 jumpOffset_endOfS8;
-
-	PPCRecompilerX64Gen_imlInstr_psq_store(ppcImlGenContext, x64GenContext, storePS1 ? PPCREC_FPR_ST_MODE_PSQ_FLOAT_PS0_PS1 : PPCREC_FPR_ST_MODE_PSQ_FLOAT_PS0, registerXMM, memReg, memRegEx, memImmS32, indexed, registerGQR);
-	jumpOffset_endOfFloat = x64GenContext->codeBufferIndex;
-	x64Gen_jmp_imm32(x64GenContext, 0);
-
-	PPCRecompilerX64Gen_redirectRelativeJump(x64GenContext, jumpOffset_caseU16, x64GenContext->codeBufferIndex);
-	PPCRecompilerX64Gen_imlInstr_psq_store(ppcImlGenContext, x64GenContext, storePS1 ? PPCREC_FPR_ST_MODE_PSQ_U16_PS0_PS1 : PPCREC_FPR_ST_MODE_PSQ_U16_PS0, registerXMM, memReg, memRegEx, memImmS32, indexed, registerGQR);
-	jumpOffset_endOfU8 = x64GenContext->codeBufferIndex;
-	x64Gen_jmp_imm32(x64GenContext, 0);
-
-	PPCRecompilerX64Gen_redirectRelativeJump(x64GenContext, jumpOffset_caseS16, x64GenContext->codeBufferIndex);
-	PPCRecompilerX64Gen_imlInstr_psq_store(ppcImlGenContext, x64GenContext, storePS1 ? PPCREC_FPR_ST_MODE_PSQ_S16_PS0_PS1 : PPCREC_FPR_ST_MODE_PSQ_S16_PS0, registerXMM, memReg, memRegEx, memImmS32, indexed, registerGQR);
-	jumpOffset_endOfU16 = x64GenContext->codeBufferIndex;
-	x64Gen_jmp_imm32(x64GenContext, 0);
-
-	PPCRecompilerX64Gen_redirectRelativeJump(x64GenContext, jumpOffset_caseU8, x64GenContext->codeBufferIndex);
-	PPCRecompilerX64Gen_imlInstr_psq_store(ppcImlGenContext, x64GenContext, storePS1 ? PPCREC_FPR_ST_MODE_PSQ_U8_PS0_PS1 : PPCREC_FPR_ST_MODE_PSQ_U8_PS0, registerXMM, memReg, memRegEx, memImmS32, indexed, registerGQR);
-	jumpOffset_endOfS8 = x64GenContext->codeBufferIndex;
-	x64Gen_jmp_imm32(x64GenContext, 0);
-
-	PPCRecompilerX64Gen_redirectRelativeJump(x64GenContext, jumpOffset_caseS8, x64GenContext->codeBufferIndex);
-	PPCRecompilerX64Gen_imlInstr_psq_store(ppcImlGenContext, x64GenContext, storePS1 ? PPCREC_FPR_ST_MODE_PSQ_S8_PS0_PS1 : PPCREC_FPR_ST_MODE_PSQ_S8_PS0, registerXMM, memReg, memRegEx, memImmS32, indexed, registerGQR);
-
-	PPCRecompilerX64Gen_redirectRelativeJump(x64GenContext, jumpOffset_endOfFloat, x64GenContext->codeBufferIndex);
-	PPCRecompilerX64Gen_redirectRelativeJump(x64GenContext, jumpOffset_endOfU8, x64GenContext->codeBufferIndex);
-	PPCRecompilerX64Gen_redirectRelativeJump(x64GenContext, jumpOffset_endOfU16, x64GenContext->codeBufferIndex);
-	PPCRecompilerX64Gen_redirectRelativeJump(x64GenContext, jumpOffset_endOfS8, x64GenContext->codeBufferIndex);
-}
-
-// store to memory
-bool PPCRecompilerX64Gen_imlInstruction_fpr_store(PPCRecFunction_t* PPCRecFunction, ppcImlGenContext_t* ppcImlGenContext, x64GenContext_t* x64GenContext, PPCRecImlInstruction_t* imlInstruction, bool indexed)
-{
-	PPCRecompilerX64Gen_crConditionFlags_forget(PPCRecFunction, ppcImlGenContext, x64GenContext);
-	sint32 realRegisterXMM = tempToRealFPRRegister(imlInstruction->op_storeLoad.registerData);
-	sint32 realRegisterMem = tempToRealRegister(imlInstruction->op_storeLoad.registerMem);
-	sint32 realRegisterMem2 = PPC_REC_INVALID_REGISTER;
-	if( indexed )
-		realRegisterMem2 = tempToRealRegister(imlInstruction->op_storeLoad.registerMem2);
-	uint8 mode = imlInstruction->op_storeLoad.mode;
-	if( mode == PPCREC_FPR_ST_MODE_SINGLE_FROM_PS0 )
-	{
-		if (imlInstruction->op_storeLoad.flags2.notExpanded)
-		{
-			// value is already in single format
-			if (hasAVXSupport)
-			{
-				x64Gen_movd_reg64Low32_xmmReg(x64GenContext, REG_RESV_TEMP, realRegisterXMM);
-			}
-			else
-			{
-				x64Gen_movsd_memReg64_xmmReg(x64GenContext, realRegisterXMM, REG_RSP, offsetof(PPCInterpreter_t, temporaryFPR));
-				x64Emit_mov_reg64_mem32(x64GenContext, REG_RESV_TEMP, REG_RSP, offsetof(PPCInterpreter_t, temporaryFPR));
-			}
-		}
-		else
-		{
-			x64Gen_cvtsd2ss_xmmReg_xmmReg(x64GenContext, REG_RESV_FPR_TEMP, realRegisterXMM);
-			if (hasAVXSupport)
-			{
-				x64Gen_movd_reg64Low32_xmmReg(x64GenContext, REG_RESV_TEMP, REG_RESV_FPR_TEMP);
-			}
-			else
-			{
-				x64Gen_movsd_memReg64_xmmReg(x64GenContext, REG_RESV_FPR_TEMP, REG_RSP, offsetof(PPCInterpreter_t, temporaryFPR));
-				x64Emit_mov_reg64_mem32(x64GenContext, REG_RESV_TEMP, REG_RSP, offsetof(PPCInterpreter_t, temporaryFPR));
-			}
-		}
-		if( hasMOVBESupport == false )
-			x64Gen_bswap_reg64Lower32bit(x64GenContext, REG_RESV_TEMP);
-		if( indexed )
-		{
-			if( realRegisterMem == realRegisterMem2 )
-				assert_dbg();
-			x64Gen_add_reg64Low32_reg64Low32(x64GenContext, realRegisterMem, realRegisterMem2);
-		}
-		if( hasMOVBESupport )
-			x64Gen_movBETruncate_mem32Reg64PlusReg64_reg64(x64GenContext, REG_R13, realRegisterMem, imlInstruction->op_storeLoad.immS32, REG_RESV_TEMP);
-		else
-			x64Gen_movTruncate_mem32Reg64PlusReg64_reg64(x64GenContext, REG_R13, realRegisterMem, imlInstruction->op_storeLoad.immS32, REG_RESV_TEMP);
-		if( indexed )
-		{
-			x64Gen_sub_reg64Low32_reg64Low32(x64GenContext, realRegisterMem, realRegisterMem2);
-		}
-	}
-	else if( mode == PPCREC_FPR_ST_MODE_DOUBLE_FROM_PS0 )
-	{
-		if( indexed )
-		{
-			if( realRegisterMem == realRegisterMem2 )
-				assert_dbg();
-			x64Gen_add_reg64Low32_reg64Low32(x64GenContext, realRegisterMem, realRegisterMem2);
-		}
-		x64Gen_movsd_memReg64_xmmReg(x64GenContext, realRegisterXMM, REG_RSP, offsetof(PPCInterpreter_t, temporaryFPR));
-		// store double low part		
-		x64Emit_mov_reg64_mem32(x64GenContext, REG_RESV_TEMP, REG_RSP, offsetof(PPCInterpreter_t, temporaryFPR)+0);
-		x64Gen_bswap_reg64Lower32bit(x64GenContext, REG_RESV_TEMP);
-		x64Gen_movTruncate_mem32Reg64PlusReg64_reg64(x64GenContext, REG_R13, realRegisterMem, imlInstruction->op_storeLoad.immS32+4, REG_RESV_TEMP);
-		// store double high part		
-		x64Emit_mov_reg64_mem32(x64GenContext, REG_RESV_TEMP, REG_RSP, offsetof(PPCInterpreter_t, temporaryFPR)+4);
-		x64Gen_bswap_reg64Lower32bit(x64GenContext, REG_RESV_TEMP);
-		x64Gen_movTruncate_mem32Reg64PlusReg64_reg64(x64GenContext, REG_R13, realRegisterMem, imlInstruction->op_storeLoad.immS32+0, REG_RESV_TEMP);
-		if( indexed )
-		{
-			x64Gen_sub_reg64Low32_reg64Low32(x64GenContext, realRegisterMem, realRegisterMem2);
-		}
-	}
-	else if( mode == PPCREC_FPR_ST_MODE_UI32_FROM_PS0 )
-	{
-		if( hasAVXSupport )
-		{
-			x64Gen_movd_reg64Low32_xmmReg(x64GenContext, REG_RESV_TEMP, realRegisterXMM);
-		}
-		else
-		{
-			x64Gen_movsd_memReg64_xmmReg(x64GenContext, realRegisterXMM, REG_RSP, offsetof(PPCInterpreter_t, temporaryFPR));
-			x64Emit_mov_reg64_mem32(x64GenContext, REG_RESV_TEMP, REG_RSP, offsetof(PPCInterpreter_t, temporaryFPR));
-		}
-		x64Gen_bswap_reg64Lower32bit(x64GenContext, REG_RESV_TEMP);
-		if( indexed )
-		{
-			if( realRegisterMem == realRegisterMem2 )
-				assert_dbg();
-			x64Gen_add_reg64Low32_reg64Low32(x64GenContext, realRegisterMem, realRegisterMem2);
-			x64Gen_movTruncate_mem32Reg64PlusReg64_reg64(x64GenContext, REG_R13, realRegisterMem, imlInstruction->op_storeLoad.immS32, REG_RESV_TEMP);
-			x64Gen_sub_reg64Low32_reg64Low32(x64GenContext, realRegisterMem, realRegisterMem2);
-		}
-		else
-		{
-			x64Gen_movTruncate_mem32Reg64PlusReg64_reg64(x64GenContext, REG_R13, realRegisterMem, imlInstruction->op_storeLoad.immS32, REG_RESV_TEMP);
-		}
-	}
-	else if(mode == PPCREC_FPR_ST_MODE_PSQ_FLOAT_PS0_PS1 ||
-			mode == PPCREC_FPR_ST_MODE_PSQ_FLOAT_PS0 ||
-			mode == PPCREC_FPR_ST_MODE_PSQ_S8_PS0 ||
-			mode == PPCREC_FPR_ST_MODE_PSQ_S8_PS0_PS1 ||
-			mode == PPCREC_FPR_ST_MODE_PSQ_U8_PS0 ||
-			mode == PPCREC_FPR_ST_MODE_PSQ_U8_PS0_PS1 ||
-			mode == PPCREC_FPR_ST_MODE_PSQ_S16_PS0 ||
-			mode == PPCREC_FPR_ST_MODE_PSQ_S16_PS0_PS1 ||
-			mode == PPCREC_FPR_ST_MODE_PSQ_U16_PS0 ||
-			mode == PPCREC_FPR_ST_MODE_PSQ_U16_PS0_PS1 )
-	{
-		cemu_assert_debug(imlInstruction->op_storeLoad.flags2.notExpanded == false);
-		PPCRecompilerX64Gen_imlInstr_psq_store(ppcImlGenContext, x64GenContext, mode, realRegisterXMM, realRegisterMem, realRegisterMem2, imlInstruction->op_storeLoad.immS32, indexed);
-	}
-	else if (mode == PPCREC_FPR_ST_MODE_PSQ_GENERIC_PS0_PS1 ||
-			 mode == PPCREC_FPR_ST_MODE_PSQ_GENERIC_PS0)
-	{
-		PPCRecompilerX64Gen_imlInstr_psq_store_generic(ppcImlGenContext, x64GenContext, mode, realRegisterXMM, realRegisterMem, realRegisterMem2, imlInstruction->op_storeLoad.immS32, indexed, tempToRealRegister(imlInstruction->op_storeLoad.registerGQR));
-	}
-	else
-	{
-		if( indexed )
-			assert_dbg(); // todo
-		debug_printf("PPCRecompilerX64Gen_imlInstruction_fpr_store(): Unsupported mode %d\n", mode);
-		return false;
-	}
-	return true;
-}
-
-void _swapPS0PS1(x64GenContext_t* x64GenContext, sint32 xmmReg)
-{
-	x64Gen_shufpd_xmmReg_xmmReg_imm8(x64GenContext, xmmReg, xmmReg, 1);
-}
-
-// FPR op FPR
-void PPCRecompilerX64Gen_imlInstruction_fpr_r_r(PPCRecFunction_t* PPCRecFunction, ppcImlGenContext_t* ppcImlGenContext, x64GenContext_t* x64GenContext, PPCRecImlInstruction_t* imlInstruction)
-{
-	PPCRecompilerX64Gen_crConditionFlags_forget(PPCRecFunction, ppcImlGenContext, x64GenContext);
-	if( imlInstruction->operation == PPCREC_IML_OP_FPR_COPY_BOTTOM_TO_BOTTOM_AND_TOP )
-	{
-		if( imlInstruction->crRegister != PPC_REC_INVALID_REGISTER )
-		{
-			assert_dbg();
-		}
-		x64Gen_movddup_xmmReg_xmmReg(x64GenContext, imlInstruction->op_fpr_r_r.registerResult, imlInstruction->op_fpr_r_r.registerOperand);
-	}
-	else if( imlInstruction->operation == PPCREC_IML_OP_FPR_COPY_TOP_TO_BOTTOM_AND_TOP )
-	{
-		if( imlInstruction->crRegister != PPC_REC_INVALID_REGISTER )
-		{
-			assert_dbg();
-		}
-		// VPUNPCKHQDQ
-		if (imlInstruction->op_fpr_r_r.registerResult == imlInstruction->op_fpr_r_r.registerOperand)
-		{
-			// unpack top to bottom and top
-			x64Gen_unpckhpd_xmmReg_xmmReg(x64GenContext, imlInstruction->op_fpr_r_r.registerResult, imlInstruction->op_fpr_r_r.registerOperand);
-		}
-		//else if ( hasAVXSupport )
-		//{
-		//	// unpack top to bottom and top with non-destructive destination
-		//	// update: On Ivy Bridge this causes weird stalls?
-		//	x64Gen_avx_VUNPCKHPD_xmm_xmm_xmm(x64GenContext, imlInstruction->op_fpr_r_r.registerResult, imlInstruction->op_fpr_r_r.registerOperand, imlInstruction->op_fpr_r_r.registerOperand);
-		//}
-		else
-		{
-			// move top to bottom
-			x64Gen_movhlps_xmmReg_xmmReg(x64GenContext, imlInstruction->op_fpr_r_r.registerResult, imlInstruction->op_fpr_r_r.registerOperand);
-			// duplicate bottom
-			x64Gen_movddup_xmmReg_xmmReg(x64GenContext, imlInstruction->op_fpr_r_r.registerResult, imlInstruction->op_fpr_r_r.registerResult);
-		}
-
-	}
-	else if( imlInstruction->operation == PPCREC_IML_OP_FPR_COPY_BOTTOM_TO_BOTTOM )
-	{
-		cemu_assert_debug(imlInstruction->crRegister == PPC_REC_INVALID_REGISTER);
-		x64Gen_movsd_xmmReg_xmmReg(x64GenContext, imlInstruction->op_fpr_r_r.registerResult, imlInstruction->op_fpr_r_r.registerOperand);
-	}
-	else if( imlInstruction->operation == PPCREC_IML_OP_FPR_COPY_BOTTOM_TO_TOP )
-	{
-		cemu_assert_debug(imlInstruction->crRegister == PPC_REC_INVALID_REGISTER);
-		x64Gen_unpcklpd_xmmReg_xmmReg(x64GenContext, imlInstruction->op_fpr_r_r.registerResult, imlInstruction->op_fpr_r_r.registerOperand);
-	}
-	else if( imlInstruction->operation == PPCREC_IML_OP_FPR_COPY_BOTTOM_AND_TOP_SWAPPED )
-	{
-		cemu_assert_debug(imlInstruction->crRegister == PPC_REC_INVALID_REGISTER);
-		if( imlInstruction->op_fpr_r_r.registerResult != imlInstruction->op_fpr_r_r.registerOperand )
-			x64Gen_movaps_xmmReg_xmmReg(x64GenContext, imlInstruction->op_fpr_r_r.registerResult, imlInstruction->op_fpr_r_r.registerOperand);
-		_swapPS0PS1(x64GenContext, imlInstruction->op_fpr_r_r.registerResult);
-	}
-	else if( imlInstruction->operation == PPCREC_IML_OP_FPR_COPY_TOP_TO_TOP )
-	{
-		cemu_assert_debug(imlInstruction->crRegister == PPC_REC_INVALID_REGISTER);
-		x64Gen_shufpd_xmmReg_xmmReg_imm8(x64GenContext, imlInstruction->op_fpr_r_r.registerResult, imlInstruction->op_fpr_r_r.registerOperand, 2);
-	}
-	else if( imlInstruction->operation == PPCREC_IML_OP_FPR_COPY_TOP_TO_BOTTOM )
-	{
-		cemu_assert_debug(imlInstruction->crRegister == PPC_REC_INVALID_REGISTER);
-		// use unpckhpd here?
-		x64Gen_shufpd_xmmReg_xmmReg_imm8(x64GenContext, imlInstruction->op_fpr_r_r.registerResult, imlInstruction->op_fpr_r_r.registerOperand, 3);
-		_swapPS0PS1(x64GenContext, imlInstruction->op_fpr_r_r.registerResult);
-	}
-	else if( imlInstruction->operation == PPCREC_IML_OP_FPR_MULTIPLY_BOTTOM )
-	{
-		if( imlInstruction->crRegister != PPC_REC_INVALID_REGISTER )
-		{
-			assert_dbg();
-		}
-		x64Gen_mulsd_xmmReg_xmmReg(x64GenContext, imlInstruction->op_fpr_r_r.registerResult, imlInstruction->op_fpr_r_r.registerOperand);
-	}
-	else if( imlInstruction->operation == PPCREC_IML_OP_FPR_MULTIPLY_PAIR )
-	{
-		if( imlInstruction->crRegister != PPC_REC_INVALID_REGISTER )
-		{
-			assert_dbg();
-		}
-		x64Gen_mulpd_xmmReg_xmmReg(x64GenContext, imlInstruction->op_fpr_r_r.registerResult, imlInstruction->op_fpr_r_r.registerOperand);
-	}
-	else if( imlInstruction->operation == PPCREC_IML_OP_FPR_DIVIDE_BOTTOM )
-	{
-		if( imlInstruction->crRegister != PPC_REC_INVALID_REGISTER )
-		{
-			assert_dbg();
-		}
-		x64Gen_divsd_xmmReg_xmmReg(x64GenContext, imlInstruction->op_fpr_r_r.registerResult, imlInstruction->op_fpr_r_r.registerOperand);
-	}
-	else if (imlInstruction->operation == PPCREC_IML_OP_FPR_DIVIDE_PAIR)
-	{
-		if (imlInstruction->crRegister != PPC_REC_INVALID_REGISTER)
-		{
-			assert_dbg();
-		}
-		x64Gen_divpd_xmmReg_xmmReg(x64GenContext, imlInstruction->op_fpr_r_r.registerResult, imlInstruction->op_fpr_r_r.registerOperand);
-	}
-	else if( imlInstruction->operation == PPCREC_IML_OP_FPR_ADD_BOTTOM )
-	{
-		if( imlInstruction->crRegister != PPC_REC_INVALID_REGISTER )
-		{
-			assert_dbg();
-		}
-		x64Gen_addsd_xmmReg_xmmReg(x64GenContext, imlInstruction->op_fpr_r_r.registerResult, imlInstruction->op_fpr_r_r.registerOperand);
-	}
-	else if( imlInstruction->operation == PPCREC_IML_OP_FPR_ADD_PAIR )
-	{
-		if( imlInstruction->crRegister != PPC_REC_INVALID_REGISTER )
-		{
-			assert_dbg();
-		}
-		x64Gen_addpd_xmmReg_xmmReg(x64GenContext, imlInstruction->op_fpr_r_r.registerResult, imlInstruction->op_fpr_r_r.registerOperand);
-	}
-	else if( imlInstruction->operation == PPCREC_IML_OP_FPR_SUB_PAIR )
-	{
-		if( imlInstruction->crRegister != PPC_REC_INVALID_REGISTER )
-		{
-			assert_dbg();
-		}
-		x64Gen_subpd_xmmReg_xmmReg(x64GenContext, imlInstruction->op_fpr_r_r.registerResult, imlInstruction->op_fpr_r_r.registerOperand);
-	}
-	else if( imlInstruction->operation == PPCREC_IML_OP_FPR_SUB_BOTTOM )
-	{
-		if( imlInstruction->crRegister != PPC_REC_INVALID_REGISTER )
-		{
-			assert_dbg();
-		}
-		x64Gen_subsd_xmmReg_xmmReg(x64GenContext, imlInstruction->op_fpr_r_r.registerResult, imlInstruction->op_fpr_r_r.registerOperand);
-	}
-	else if( imlInstruction->operation == PPCREC_IML_OP_ASSIGN )
-	{
-		if( imlInstruction->crRegister != PPC_REC_INVALID_REGISTER )
-		{
-			assert_dbg();
-		}
-		x64Gen_movaps_xmmReg_xmmReg(x64GenContext, imlInstruction->op_fpr_r_r.registerResult, imlInstruction->op_fpr_r_r.registerOperand);
-	}
-	else if( imlInstruction->operation == PPCREC_IML_OP_FPR_BOTTOM_FCTIWZ )
-	{
-		if( imlInstruction->crRegister != PPC_REC_INVALID_REGISTER )
-		{
-			assert_dbg();
-		}
-		x64Gen_cvttsd2si_xmmReg_xmmReg(x64GenContext, REG_RESV_TEMP, imlInstruction->op_fpr_r_r.registerOperand);
-		x64Gen_mov_reg64Low32_reg64Low32(x64GenContext, REG_RESV_TEMP, REG_RESV_TEMP);
-		// move to FPR register
-		x64Gen_movq_xmmReg_reg64(x64GenContext, imlInstruction->op_fpr_r_r.registerResult, REG_RESV_TEMP);
-	}
-	else if(imlInstruction->operation == PPCREC_IML_OP_FPR_FCMPU_BOTTOM ||
-			imlInstruction->operation == PPCREC_IML_OP_FPR_FCMPU_TOP ||
-			imlInstruction->operation == PPCREC_IML_OP_FPR_FCMPO_BOTTOM )
-	{
-		if( imlInstruction->crRegister == PPC_REC_INVALID_REGISTER )
-		{
-			assert_dbg();
-		}
-		if (imlInstruction->operation == PPCREC_IML_OP_FPR_FCMPU_BOTTOM)
-			x64Gen_ucomisd_xmmReg_xmmReg(x64GenContext, imlInstruction->op_fpr_r_r.registerResult, imlInstruction->op_fpr_r_r.registerOperand);
-		else if (imlInstruction->operation == PPCREC_IML_OP_FPR_FCMPU_TOP)
-		{
-			// temporarily switch top/bottom of both operands and compare
-			if (imlInstruction->op_fpr_r_r.registerResult == imlInstruction->op_fpr_r_r.registerOperand)
-			{
-				_swapPS0PS1(x64GenContext, imlInstruction->op_fpr_r_r.registerResult);
-				x64Gen_ucomisd_xmmReg_xmmReg(x64GenContext, imlInstruction->op_fpr_r_r.registerResult, imlInstruction->op_fpr_r_r.registerOperand);
-				_swapPS0PS1(x64GenContext, imlInstruction->op_fpr_r_r.registerResult);
-			}
-			else
-			{
-				_swapPS0PS1(x64GenContext, imlInstruction->op_fpr_r_r.registerResult);
-				_swapPS0PS1(x64GenContext, imlInstruction->op_fpr_r_r.registerOperand);
-				x64Gen_ucomisd_xmmReg_xmmReg(x64GenContext, imlInstruction->op_fpr_r_r.registerResult, imlInstruction->op_fpr_r_r.registerOperand);
-				_swapPS0PS1(x64GenContext, imlInstruction->op_fpr_r_r.registerResult);
-				_swapPS0PS1(x64GenContext, imlInstruction->op_fpr_r_r.registerOperand);
-			}
-		}
-		else
-			x64Gen_comisd_xmmReg_xmmReg(x64GenContext, imlInstruction->op_fpr_r_r.registerResult, imlInstruction->op_fpr_r_r.registerOperand);
-		// todo: handle FPSCR updates
-		// update cr
-		sint32 crRegister = imlInstruction->crRegister;
-		// if the parity bit is set (NaN) we need to manually set CR LT, GT and EQ to 0 (comisd/ucomisd sets the respective flags to 1 in case of NaN)
-		x64Gen_setcc_mem8(x64GenContext, X86_CONDITION_PARITY, REG_RSP, offsetof(PPCInterpreter_t, cr)+sizeof(uint8)*(crRegister*4+PPCREC_CR_BIT_SO)); // unordered
-		sint32 jumpInstructionOffset1 = x64GenContext->codeBufferIndex;
-		x64Gen_jmpc_near(x64GenContext, X86_CONDITION_PARITY, 0);
-		x64Gen_setcc_mem8(x64GenContext, X86_CONDITION_UNSIGNED_BELOW, REG_RSP, offsetof(PPCInterpreter_t, cr)+sizeof(uint8)*(crRegister*4+PPCREC_CR_BIT_LT)); // same as X64_CONDITION_CARRY
-		x64Gen_setcc_mem8(x64GenContext, X86_CONDITION_UNSIGNED_ABOVE, REG_RSP, offsetof(PPCInterpreter_t, cr)+sizeof(uint8)*(crRegister*4+PPCREC_CR_BIT_GT));
-		x64Gen_setcc_mem8(x64GenContext, X86_CONDITION_EQUAL, REG_RSP, offsetof(PPCInterpreter_t, cr)+sizeof(uint8)*(crRegister*4+PPCREC_CR_BIT_EQ));
-		sint32 jumpInstructionOffset2 = x64GenContext->codeBufferIndex;
-		x64Gen_jmpc_near(x64GenContext, X86_CONDITION_NONE, 0);
-		PPCRecompilerX64Gen_redirectRelativeJump(x64GenContext, jumpInstructionOffset1, x64GenContext->codeBufferIndex);
-		x64Gen_mov_mem8Reg64_imm8(x64GenContext, REG_RSP, offsetof(PPCInterpreter_t, cr)+sizeof(uint8)*(crRegister*4+PPCREC_CR_BIT_LT), 0);
-		x64Gen_mov_mem8Reg64_imm8(x64GenContext, REG_RSP, offsetof(PPCInterpreter_t, cr)+sizeof(uint8)*(crRegister*4+PPCREC_CR_BIT_GT), 0);
-		x64Gen_mov_mem8Reg64_imm8(x64GenContext, REG_RSP, offsetof(PPCInterpreter_t, cr)+sizeof(uint8)*(crRegister*4+PPCREC_CR_BIT_EQ), 0);
-		PPCRecompilerX64Gen_redirectRelativeJump(x64GenContext, jumpInstructionOffset2, x64GenContext->codeBufferIndex);
-	}
-	else if( imlInstruction->operation == PPCREC_IML_OP_FPR_BOTTOM_FRES_TO_BOTTOM_AND_TOP )
-	{
-		if( imlInstruction->crRegister != PPC_REC_INVALID_REGISTER )
-		{
-			assert_dbg();
-		}
-		// move register to XMM15
-		x64Gen_movsd_xmmReg_xmmReg(x64GenContext, REG_RESV_FPR_TEMP, imlInstruction->op_fpr_r_r.registerOperand);
-		
-		// call assembly routine to calculate accurate FRES result in XMM15
-		x64Gen_mov_reg64_imm64(x64GenContext, REG_RESV_TEMP, (uint64)recompiler_fres);
-		x64Gen_call_reg64(x64GenContext, REG_RESV_TEMP);
-
-		// copy result to bottom and top half of result register
-		x64Gen_movddup_xmmReg_xmmReg(x64GenContext, imlInstruction->op_fpr_r_r.registerResult, REG_RESV_FPR_TEMP);
-	}
-	else if (imlInstruction->operation == PPCREC_IML_OP_FPR_BOTTOM_RECIPROCAL_SQRT)
-	{
-		cemu_assert_debug(imlInstruction->crRegister == PPC_REC_INVALID_REGISTER);
-		// move register to XMM15
-		x64Gen_movsd_xmmReg_xmmReg(x64GenContext, REG_RESV_FPR_TEMP, imlInstruction->op_fpr_r_r.registerOperand);
-
-		// call assembly routine to calculate accurate FRSQRTE result in XMM15
-		x64Gen_mov_reg64_imm64(x64GenContext, REG_RESV_TEMP, (uint64)recompiler_frsqrte);
-		x64Gen_call_reg64(x64GenContext, REG_RESV_TEMP);
-
-		// copy result to bottom of result register
-		x64Gen_movsd_xmmReg_xmmReg(x64GenContext, imlInstruction->op_fpr_r_r.registerResult, REG_RESV_FPR_TEMP);
-	}
-	else if( imlInstruction->operation == PPCREC_IML_OP_FPR_NEGATE_PAIR )
-	{
-		cemu_assert_debug(imlInstruction->crRegister == PPC_REC_INVALID_REGISTER);
-		// copy register
-		if( imlInstruction->op_fpr_r_r.registerResult != imlInstruction->op_fpr_r_r.registerOperand )
-		{
-			x64Gen_movaps_xmmReg_xmmReg(x64GenContext, imlInstruction->op_fpr_r_r.registerResult, imlInstruction->op_fpr_r_r.registerOperand);
-		}
-		// toggle sign bits
-		x64Gen_xorps_xmmReg_mem128Reg64(x64GenContext, imlInstruction->op_fpr_r_r.registerResult, REG_RESV_RECDATA, offsetof(PPCRecompilerInstanceData_t, _x64XMM_xorNegateMaskPair));
-	}
-	else if( imlInstruction->operation == PPCREC_IML_OP_FPR_ABS_PAIR )
-	{
-		cemu_assert_debug(imlInstruction->crRegister == PPC_REC_INVALID_REGISTER);
-		// copy register
-		if( imlInstruction->op_fpr_r_r.registerResult != imlInstruction->op_fpr_r_r.registerOperand )
-		{
-			x64Gen_movaps_xmmReg_xmmReg(x64GenContext, imlInstruction->op_fpr_r_r.registerResult, imlInstruction->op_fpr_r_r.registerOperand);
-		}
-		// set sign bit to 0
-		x64Gen_andps_xmmReg_mem128Reg64(x64GenContext, imlInstruction->op_fpr_r_r.registerResult, REG_RESV_RECDATA, offsetof(PPCRecompilerInstanceData_t, _x64XMM_andAbsMaskPair));
-	}
-	else if( imlInstruction->operation == PPCREC_IML_OP_FPR_FRES_PAIR || imlInstruction->operation == PPCREC_IML_OP_FPR_FRSQRTE_PAIR)
-	{
-		cemu_assert_debug(imlInstruction->crRegister == PPC_REC_INVALID_REGISTER);
-		// calculate bottom half of result
-		x64Gen_movsd_xmmReg_xmmReg(x64GenContext, REG_RESV_FPR_TEMP, imlInstruction->op_fpr_r_r.registerOperand);
-		if(imlInstruction->operation == PPCREC_IML_OP_FPR_FRES_PAIR)
-			x64Gen_mov_reg64_imm64(x64GenContext, REG_RESV_TEMP, (uint64)recompiler_fres);
-		else
-			x64Gen_mov_reg64_imm64(x64GenContext, REG_RESV_TEMP, (uint64)recompiler_frsqrte);
-		x64Gen_call_reg64(x64GenContext, REG_RESV_TEMP); // calculate fres result in xmm15
-		x64Gen_movsd_xmmReg_xmmReg(x64GenContext, imlInstruction->op_fpr_r_r.registerResult, REG_RESV_FPR_TEMP);
-
-		// calculate top half of result
-		// todo - this top to bottom copy can be optimized?
-		x64Gen_shufpd_xmmReg_xmmReg_imm8(x64GenContext, REG_RESV_FPR_TEMP, imlInstruction->op_fpr_r_r.registerOperand, 3);
-		x64Gen_shufpd_xmmReg_xmmReg_imm8(x64GenContext, REG_RESV_FPR_TEMP, REG_RESV_FPR_TEMP, 1); // swap top and bottom
-
-		x64Gen_call_reg64(x64GenContext, REG_RESV_TEMP); // calculate fres result in xmm15
-
-		x64Gen_unpcklpd_xmmReg_xmmReg(x64GenContext, imlInstruction->op_fpr_r_r.registerResult, REG_RESV_FPR_TEMP); // copy bottom to top
-	}
-	else
-	{
-		assert_dbg();
-	}
-}
-
-/*
- * FPR = op (fprA, fprB)
- */
-void PPCRecompilerX64Gen_imlInstruction_fpr_r_r_r(PPCRecFunction_t* PPCRecFunction, ppcImlGenContext_t* ppcImlGenContext, x64GenContext_t* x64GenContext, PPCRecImlInstruction_t* imlInstruction)
-{
-	PPCRecompilerX64Gen_crConditionFlags_forget(PPCRecFunction, ppcImlGenContext, x64GenContext);
-
-	if (imlInstruction->operation == PPCREC_IML_OP_FPR_MULTIPLY_BOTTOM)
-	{
-		if (imlInstruction->crRegister != PPC_REC_INVALID_REGISTER)
-		{
-			assert_dbg();
-		}
-		if (imlInstruction->op_fpr_r_r_r.registerResult == imlInstruction->op_fpr_r_r_r.registerOperandA)
-		{
-			x64Gen_mulsd_xmmReg_xmmReg(x64GenContext, imlInstruction->op_fpr_r_r_r.registerResult, imlInstruction->op_fpr_r_r_r.registerOperandB);
-		}
-		else if (imlInstruction->op_fpr_r_r_r.registerResult == imlInstruction->op_fpr_r_r_r.registerOperandB)
-		{
-			x64Gen_mulsd_xmmReg_xmmReg(x64GenContext, imlInstruction->op_fpr_r_r_r.registerResult, imlInstruction->op_fpr_r_r_r.registerOperandA);
-		}
-		else
-		{
-			x64Gen_movsd_xmmReg_xmmReg(x64GenContext, imlInstruction->op_fpr_r_r_r.registerResult, imlInstruction->op_fpr_r_r_r.registerOperandA);
-			x64Gen_mulsd_xmmReg_xmmReg(x64GenContext, imlInstruction->op_fpr_r_r_r.registerResult, imlInstruction->op_fpr_r_r_r.registerOperandB);
-		}
-	}
-	else if (imlInstruction->operation == PPCREC_IML_OP_FPR_ADD_BOTTOM)
-	{
-		// registerResult(fp0) = registerOperandA(fp0) + registerOperandB(fp0)
-		cemu_assert_debug(imlInstruction->crRegister == PPC_REC_INVALID_REGISTER);
-		// todo: Use AVX 3-operand VADDSD if available
-		if (imlInstruction->op_fpr_r_r_r.registerResult == imlInstruction->op_fpr_r_r_r.registerOperandA)
-		{
-			x64Gen_addsd_xmmReg_xmmReg(x64GenContext, imlInstruction->op_fpr_r_r_r.registerResult, imlInstruction->op_fpr_r_r_r.registerOperandB);
-		}
-		else if (imlInstruction->op_fpr_r_r_r.registerResult == imlInstruction->op_fpr_r_r_r.registerOperandB)
-		{
-			x64Gen_addsd_xmmReg_xmmReg(x64GenContext, imlInstruction->op_fpr_r_r_r.registerResult, imlInstruction->op_fpr_r_r_r.registerOperandA);
-		}
-		else
-		{
-			x64Gen_movaps_xmmReg_xmmReg(x64GenContext, imlInstruction->op_fpr_r_r_r.registerResult, imlInstruction->op_fpr_r_r_r.registerOperandA);
-			x64Gen_addsd_xmmReg_xmmReg(x64GenContext, imlInstruction->op_fpr_r_r_r.registerResult, imlInstruction->op_fpr_r_r_r.registerOperandB);
-		}
-	}
-	else if (imlInstruction->operation == PPCREC_IML_OP_FPR_SUB_PAIR)
-	{
-		// registerResult = registerOperandA - registerOperandB
-		cemu_assert_debug(imlInstruction->crRegister == PPC_REC_INVALID_REGISTER);
-		if( imlInstruction->op_fpr_r_r_r.registerResult == imlInstruction->op_fpr_r_r_r.registerOperandA )
-		{
-			x64Gen_subpd_xmmReg_xmmReg(x64GenContext, imlInstruction->op_fpr_r_r_r.registerResult, imlInstruction->op_fpr_r_r_r.registerOperandB);
-		}
-		else if (hasAVXSupport)
-		{
-			x64Gen_avx_VSUBPD_xmm_xmm_xmm(x64GenContext, imlInstruction->op_fpr_r_r_r.registerResult, imlInstruction->op_fpr_r_r_r.registerOperandA, imlInstruction->op_fpr_r_r_r.registerOperandB);
-		}
-		else if( imlInstruction->op_fpr_r_r_r.registerResult == imlInstruction->op_fpr_r_r_r.registerOperandB )
-		{
-			x64Gen_movaps_xmmReg_xmmReg(x64GenContext, REG_RESV_FPR_TEMP, imlInstruction->op_fpr_r_r_r.registerOperandA);
-			x64Gen_subpd_xmmReg_xmmReg(x64GenContext, REG_RESV_FPR_TEMP, imlInstruction->op_fpr_r_r_r.registerOperandB);
-			x64Gen_movaps_xmmReg_xmmReg(x64GenContext, imlInstruction->op_fpr_r_r_r.registerResult, REG_RESV_FPR_TEMP);
-		}
-		else
-		{
-			x64Gen_movaps_xmmReg_xmmReg(x64GenContext, imlInstruction->op_fpr_r_r_r.registerResult, imlInstruction->op_fpr_r_r_r.registerOperandA);
-			x64Gen_subpd_xmmReg_xmmReg(x64GenContext, imlInstruction->op_fpr_r_r_r.registerResult, imlInstruction->op_fpr_r_r_r.registerOperandB);
-		}
-	}
-	else if( imlInstruction->operation == PPCREC_IML_OP_FPR_SUB_BOTTOM )
-	{
-		cemu_assert_debug(imlInstruction->crRegister == PPC_REC_INVALID_REGISTER);
-		if( imlInstruction->op_fpr_r_r_r.registerResult == imlInstruction->op_fpr_r_r_r.registerOperandA )
-		{
-			x64Gen_subsd_xmmReg_xmmReg(x64GenContext, imlInstruction->op_fpr_r_r_r.registerResult, imlInstruction->op_fpr_r_r_r.registerOperandB);
-		}
-		else if( imlInstruction->op_fpr_r_r_r.registerResult == imlInstruction->op_fpr_r_r_r.registerOperandB )
-		{
-			x64Gen_movsd_xmmReg_xmmReg(x64GenContext, REG_RESV_FPR_TEMP, imlInstruction->op_fpr_r_r_r.registerOperandA);
-			x64Gen_subsd_xmmReg_xmmReg(x64GenContext, REG_RESV_FPR_TEMP, imlInstruction->op_fpr_r_r_r.registerOperandB);
-			x64Gen_movsd_xmmReg_xmmReg(x64GenContext, imlInstruction->op_fpr_r_r_r.registerResult, REG_RESV_FPR_TEMP);
-		}
-		else
-		{
-			x64Gen_movsd_xmmReg_xmmReg(x64GenContext, imlInstruction->op_fpr_r_r_r.registerResult, imlInstruction->op_fpr_r_r_r.registerOperandA);
-			x64Gen_subsd_xmmReg_xmmReg(x64GenContext, imlInstruction->op_fpr_r_r_r.registerResult, imlInstruction->op_fpr_r_r_r.registerOperandB);
-		}
-	}
-	else
-		assert_dbg();
-}
-
-/*
- * FPR = op (fprA, fprB, fprC)
- */
-void PPCRecompilerX64Gen_imlInstruction_fpr_r_r_r_r(PPCRecFunction_t* PPCRecFunction, ppcImlGenContext_t* ppcImlGenContext, x64GenContext_t* x64GenContext, PPCRecImlInstruction_t* imlInstruction)
-{
-	PPCRecompilerX64Gen_crConditionFlags_forget(PPCRecFunction, ppcImlGenContext, x64GenContext);
-	if( imlInstruction->operation == PPCREC_IML_OP_FPR_SUM0 )
-	{
-		cemu_assert_debug(imlInstruction->crRegister == PPC_REC_INVALID_REGISTER);
-
-		// todo: Investigate if there are other optimizations possible if the operand registers overlap
-		// generic case
-		// 1) move frA bottom to frTemp bottom and top
-		x64Gen_movddup_xmmReg_xmmReg(x64GenContext, REG_RESV_FPR_TEMP, imlInstruction->op_fpr_r_r_r_r.registerOperandA);
-		// 2) add frB (both halfs, lower half is overwritten in the next step)
-		x64Gen_addpd_xmmReg_xmmReg(x64GenContext, REG_RESV_FPR_TEMP, imlInstruction->op_fpr_r_r_r_r.registerOperandB);
-		// 3) Interleave top of frTemp and frC
-		x64Gen_unpckhpd_xmmReg_xmmReg(x64GenContext, REG_RESV_FPR_TEMP, imlInstruction->op_fpr_r_r_r_r.registerOperandC);
-		// todo: We can optimize the REG_RESV_FPR_TEMP -> resultReg copy operation away when the result register does not overlap with any of the operand registers
-		x64Gen_movaps_xmmReg_xmmReg(x64GenContext, imlInstruction->op_fpr_r_r_r_r.registerResult, REG_RESV_FPR_TEMP);
-	}
-	else if( imlInstruction->operation == PPCREC_IML_OP_FPR_SUM1 )
-	{
-		cemu_assert_debug(imlInstruction->crRegister == PPC_REC_INVALID_REGISTER);
-		// todo: Investigate if there are other optimizations possible if the operand registers overlap
-		// 1) move frA bottom to frTemp bottom and top
-		x64Gen_movddup_xmmReg_xmmReg(x64GenContext, REG_RESV_FPR_TEMP, imlInstruction->op_fpr_r_r_r_r.registerOperandA);
-		// 2) add frB (both halfs, lower half is overwritten in the next step)
-		x64Gen_addpd_xmmReg_xmmReg(x64GenContext, REG_RESV_FPR_TEMP, imlInstruction->op_fpr_r_r_r_r.registerOperandB);
-		// 3) Copy bottom from frC
-		x64Gen_movsd_xmmReg_xmmReg(x64GenContext, REG_RESV_FPR_TEMP, imlInstruction->op_fpr_r_r_r_r.registerOperandC);
-		//// 4) Swap bottom and top half
-		//x64Gen_shufpd_xmmReg_xmmReg_imm8(x64GenContext, REG_RESV_FPR_TEMP, REG_RESV_FPR_TEMP, 1);
-		// todo: We can optimize the REG_RESV_FPR_TEMP -> resultReg copy operation away when the result register does not overlap with any of the operand registers
-		x64Gen_movaps_xmmReg_xmmReg(x64GenContext, imlInstruction->op_fpr_r_r_r_r.registerResult, REG_RESV_FPR_TEMP);
-
-		//float s0 = (float)hCPU->fpr[frC].fp0;
-		//float s1 = (float)(hCPU->fpr[frA].fp0 + hCPU->fpr[frB].fp1);
-		//hCPU->fpr[frD].fp0 = s0;
-		//hCPU->fpr[frD].fp1 = s1;
-	}
-	else if( imlInstruction->operation == PPCREC_IML_OP_FPR_SELECT_BOTTOM )
-	{
-		cemu_assert_debug(imlInstruction->crRegister == PPC_REC_INVALID_REGISTER);
-		x64Gen_comisd_xmmReg_mem64Reg64(x64GenContext, imlInstruction->op_fpr_r_r_r_r.registerOperandA, REG_RESV_RECDATA, offsetof(PPCRecompilerInstanceData_t, _x64XMM_constDouble0_0));
-		sint32 jumpInstructionOffset1 = x64GenContext->codeBufferIndex;
-		x64Gen_jmpc_near(x64GenContext, X86_CONDITION_UNSIGNED_BELOW, 0);
-		// select C
-		x64Gen_movsd_xmmReg_xmmReg(x64GenContext, imlInstruction->op_fpr_r_r_r_r.registerResult, imlInstruction->op_fpr_r_r_r_r.registerOperandC);
-		sint32 jumpInstructionOffset2 = x64GenContext->codeBufferIndex;
-		x64Gen_jmpc_near(x64GenContext, X86_CONDITION_NONE, 0);
-		// select B
-		PPCRecompilerX64Gen_redirectRelativeJump(x64GenContext, jumpInstructionOffset1, x64GenContext->codeBufferIndex);
-		x64Gen_movsd_xmmReg_xmmReg(x64GenContext, imlInstruction->op_fpr_r_r_r_r.registerResult, imlInstruction->op_fpr_r_r_r_r.registerOperandB);
-		// end
-		PPCRecompilerX64Gen_redirectRelativeJump(x64GenContext, jumpInstructionOffset2, x64GenContext->codeBufferIndex);
-	}
-	else if( imlInstruction->operation == PPCREC_IML_OP_FPR_SELECT_PAIR )
-	{
-		cemu_assert_debug(imlInstruction->crRegister == PPC_REC_INVALID_REGISTER);
-		// select bottom
-		x64Gen_comisd_xmmReg_mem64Reg64(x64GenContext, imlInstruction->op_fpr_r_r_r_r.registerOperandA, REG_RESV_RECDATA, offsetof(PPCRecompilerInstanceData_t, _x64XMM_constDouble0_0));
-		sint32 jumpInstructionOffset1_bottom = x64GenContext->codeBufferIndex;
-		x64Gen_jmpc_near(x64GenContext, X86_CONDITION_UNSIGNED_BELOW, 0);
-		// select C bottom
-		x64Gen_movsd_xmmReg_xmmReg(x64GenContext, imlInstruction->op_fpr_r_r_r_r.registerResult, imlInstruction->op_fpr_r_r_r_r.registerOperandC);
-		sint32 jumpInstructionOffset2_bottom = x64GenContext->codeBufferIndex;
-		x64Gen_jmpc_near(x64GenContext, X86_CONDITION_NONE, 0);
-		// select B bottom
-		PPCRecompilerX64Gen_redirectRelativeJump(x64GenContext, jumpInstructionOffset1_bottom, x64GenContext->codeBufferIndex);
-		x64Gen_movsd_xmmReg_xmmReg(x64GenContext, imlInstruction->op_fpr_r_r_r_r.registerResult, imlInstruction->op_fpr_r_r_r_r.registerOperandB);
-		// end
-		PPCRecompilerX64Gen_redirectRelativeJump(x64GenContext, jumpInstructionOffset2_bottom, x64GenContext->codeBufferIndex);
-		// select top
-		x64Gen_movhlps_xmmReg_xmmReg(x64GenContext, REG_RESV_FPR_TEMP, imlInstruction->op_fpr_r_r_r_r.registerOperandA); // copy top to bottom (todo: May cause stall?)
-		x64Gen_comisd_xmmReg_mem64Reg64(x64GenContext, REG_RESV_FPR_TEMP, REG_RESV_RECDATA, offsetof(PPCRecompilerInstanceData_t, _x64XMM_constDouble0_0));
-		sint32 jumpInstructionOffset1_top = x64GenContext->codeBufferIndex;
-		x64Gen_jmpc_near(x64GenContext, X86_CONDITION_UNSIGNED_BELOW, 0);
-		// select C top
-		//x64Gen_movsd_xmmReg_xmmReg(x64GenContext, imlInstruction->op_fpr_r_r_r_r.registerResult, imlInstruction->op_fpr_r_r_r_r.registerOperandC);
-		x64Gen_shufpd_xmmReg_xmmReg_imm8(x64GenContext, imlInstruction->op_fpr_r_r_r_r.registerResult, imlInstruction->op_fpr_r_r_r_r.registerOperandC, 2);
-		sint32 jumpInstructionOffset2_top = x64GenContext->codeBufferIndex;
-		x64Gen_jmpc_near(x64GenContext, X86_CONDITION_NONE, 0);
-		// select B top
-		PPCRecompilerX64Gen_redirectRelativeJump(x64GenContext, jumpInstructionOffset1_top, x64GenContext->codeBufferIndex);
-		//x64Gen_movsd_xmmReg_xmmReg(x64GenContext, imlInstruction->op_fpr_r_r_r_r.registerResult, imlInstruction->op_fpr_r_r_r_r.registerOperandB);
-		x64Gen_shufpd_xmmReg_xmmReg_imm8(x64GenContext, imlInstruction->op_fpr_r_r_r_r.registerResult, imlInstruction->op_fpr_r_r_r_r.registerOperandB, 2);
-		// end
-		PPCRecompilerX64Gen_redirectRelativeJump(x64GenContext, jumpInstructionOffset2_top, x64GenContext->codeBufferIndex);
-	}
-	else
-		assert_dbg();
-}
-
-/*
- * Single FPR operation
- */
-void PPCRecompilerX64Gen_imlInstruction_fpr_r(PPCRecFunction_t* PPCRecFunction, ppcImlGenContext_t* ppcImlGenContext, x64GenContext_t* x64GenContext, PPCRecImlInstruction_t* imlInstruction)
-{
-	PPCRecompilerX64Gen_crConditionFlags_forget(PPCRecFunction, ppcImlGenContext, x64GenContext);
-	if( imlInstruction->operation == PPCREC_IML_OP_FPR_NEGATE_BOTTOM )
-	{
-		cemu_assert_debug(imlInstruction->crRegister == PPC_REC_INVALID_REGISTER);
-		// toggle sign bit
-		x64Gen_xorps_xmmReg_mem128Reg64(x64GenContext, imlInstruction->op_fpr_r.registerResult, REG_RESV_RECDATA, offsetof(PPCRecompilerInstanceData_t, _x64XMM_xorNegateMaskBottom));
-	}
-	else if( imlInstruction->operation == PPCREC_IML_OP_FPR_ABS_BOTTOM )
-	{
-		cemu_assert_debug(imlInstruction->crRegister == PPC_REC_INVALID_REGISTER);
-		// mask out sign bit
-		x64Gen_andps_xmmReg_mem128Reg64(x64GenContext, imlInstruction->op_fpr_r.registerResult, REG_RESV_RECDATA, offsetof(PPCRecompilerInstanceData_t, _x64XMM_andAbsMaskBottom));
-	}
-	else if( imlInstruction->operation == PPCREC_IML_OP_FPR_NEGATIVE_ABS_BOTTOM )
-	{
-		cemu_assert_debug(imlInstruction->crRegister == PPC_REC_INVALID_REGISTER);
-		// set sign bit
-		x64Gen_orps_xmmReg_mem128Reg64(x64GenContext, imlInstruction->op_fpr_r.registerResult, REG_RESV_RECDATA, offsetof(PPCRecompilerInstanceData_t, _x64XMM_xorNegateMaskBottom));
-	}
-	else if( imlInstruction->operation == PPCREC_IML_OP_FPR_ROUND_TO_SINGLE_PRECISION_BOTTOM )
-	{
-		cemu_assert_debug(imlInstruction->crRegister == PPC_REC_INVALID_REGISTER);
-		// convert to 32bit single
-		x64Gen_cvtsd2ss_xmmReg_xmmReg(x64GenContext, imlInstruction->op_fpr_r.registerResult, imlInstruction->op_fpr_r.registerResult);
-		// convert back to 64bit double
-		x64Gen_cvtss2sd_xmmReg_xmmReg(x64GenContext, imlInstruction->op_fpr_r.registerResult, imlInstruction->op_fpr_r.registerResult);
-	}
-	else if( imlInstruction->operation == PPCREC_IML_OP_FPR_ROUND_TO_SINGLE_PRECISION_PAIR )
-	{
-		cemu_assert_debug(imlInstruction->crRegister == PPC_REC_INVALID_REGISTER);
-		// convert to 32bit singles
-		x64Gen_cvtpd2ps_xmmReg_xmmReg(x64GenContext, imlInstruction->op_fpr_r.registerResult, imlInstruction->op_fpr_r.registerResult);
-		// convert back to 64bit doubles
-		x64Gen_cvtps2pd_xmmReg_xmmReg(x64GenContext, imlInstruction->op_fpr_r.registerResult, imlInstruction->op_fpr_r.registerResult);
-	}
-	else if (imlInstruction->operation == PPCREC_IML_OP_FPR_EXPAND_BOTTOM32_TO_BOTTOM64_AND_TOP64)
-	{
-		cemu_assert_debug(imlInstruction->crRegister == PPC_REC_INVALID_REGISTER);
-		// convert bottom to 64bit double
-		x64Gen_cvtss2sd_xmmReg_xmmReg(x64GenContext, imlInstruction->op_fpr_r.registerResult, imlInstruction->op_fpr_r.registerResult);
-		// copy to top half
-		x64Gen_movddup_xmmReg_xmmReg(x64GenContext, imlInstruction->op_fpr_r.registerResult, imlInstruction->op_fpr_r.registerResult);
-	}
-	else
-	{
-		cemu_assert_unimplemented();
-	}
-}
diff --git a/src/Cafe/HW/Latte/Core/FetchShader.cpp b/src/Cafe/HW/Latte/Core/FetchShader.cpp
index 1c0a72a0..6c9893f9 100644
--- a/src/Cafe/HW/Latte/Core/FetchShader.cpp
+++ b/src/Cafe/HW/Latte/Core/FetchShader.cpp
@@ -228,13 +228,13 @@ void _fetchShaderDecompiler_parseInstruction_VTX_SEMANTIC(LatteFetchShader* pars
 	else if (srcSelX == LatteClauseInstruction_VTX::SRC_SEL::SEL_Y)
 	{
 		// use alu divisor 1
-		attribGroup->attrib[groupAttribIndex].aluDivisor = (sint32)contextRegister[mmVGT_INSTANCE_STEP_RATE_0 + 0];
+		attribGroup->attrib[groupAttribIndex].aluDivisor = (sint32)contextRegister[Latte::REGADDR::VGT_INSTANCE_STEP_RATE_0];
 		cemu_assert_debug(attribGroup->attrib[groupAttribIndex].aluDivisor > 0);
 	}
 	else if (srcSelX == LatteClauseInstruction_VTX::SRC_SEL::SEL_Z)
 	{
 		// use alu divisor 2
-		attribGroup->attrib[groupAttribIndex].aluDivisor = (sint32)contextRegister[mmVGT_INSTANCE_STEP_RATE_0 + 1];
+		attribGroup->attrib[groupAttribIndex].aluDivisor = (sint32)contextRegister[Latte::REGADDR::VGT_INSTANCE_STEP_RATE_1];
 		cemu_assert_debug(attribGroup->attrib[groupAttribIndex].aluDivisor > 0);
 	}
 }
@@ -505,7 +505,7 @@ LatteFetchShader* LatteFetchShader::FindByGPUState()
 		lookupInfo->programSize = _getFSProgramSize();
 		lookupInfo->lastFrameAccessed = LatteGPUState.frameCounter;
 		g_fetchShaderLookupCache.store(fsPhysAddr24, lookupInfo);
-#ifndef PUBLIC_RELEASE
+#ifdef CEMU_DEBUG_ASSERT
 		cemu_assert_debug(g_fetchShaderLookupCache.lookup(fsPhysAddr24) == lookupInfo);
 #endif
 	}
@@ -516,16 +516,16 @@ FSpinlock s_spinlockFetchShaderCache;
 
 LatteFetchShader* LatteFetchShader::RegisterInCache(CacheHash fsHash)
 {
-	s_spinlockFetchShaderCache.acquire();
+	s_spinlockFetchShaderCache.lock();
 	auto itr = s_fetchShaderByHash.find(fsHash);
 	if (itr != s_fetchShaderByHash.end())
 	{
 		LatteFetchShader* fs = itr->second;
-		s_spinlockFetchShaderCache.release();
+		s_spinlockFetchShaderCache.unlock();
 		return fs;
 	}
 	s_fetchShaderByHash.emplace(fsHash, this);
-	s_spinlockFetchShaderCache.release();
+	s_spinlockFetchShaderCache.unlock();
 	return nullptr;
 }
 
@@ -533,11 +533,11 @@ void LatteFetchShader::UnregisterInCache()
 {
 	if (!m_isRegistered)
 		return;
-	s_spinlockFetchShaderCache.acquire();
+	s_spinlockFetchShaderCache.lock();
 	auto itr = s_fetchShaderByHash.find(m_cacheHash);
 	cemu_assert(itr == s_fetchShaderByHash.end());
 	s_fetchShaderByHash.erase(itr);
-	s_spinlockFetchShaderCache.release();
+	s_spinlockFetchShaderCache.unlock();
 }
 
 std::unordered_map<LatteFetchShader::CacheHash, LatteFetchShader*> LatteFetchShader::s_fetchShaderByHash;
diff --git a/src/Cafe/HW/Latte/Core/Latte.h b/src/Cafe/HW/Latte/Core/Latte.h
index ddff15ea..2636467b 100644
--- a/src/Cafe/HW/Latte/Core/Latte.h
+++ b/src/Cafe/HW/Latte/Core/Latte.h
@@ -25,6 +25,8 @@ struct LatteGPUState_t
 	// context control
 	uint32 contextControl0;
 	uint32 contextControl1;
+	// optional features
+	bool allowFramebufferSizeOptimization{false}; // allow using scissor box as size hint to determine non-padded rendertarget size
 	// draw context
 	struct  
 	{
@@ -45,11 +47,10 @@ struct LatteGPUState_t
 	gx2GPUSharedArea_t* sharedArea; // quick reference to shared area
 	MPTR sharedAreaAddr;
 	// other
-	// todo: Currently we have the command buffer logic implemented as a FIFO ringbuffer. On real HW it's handled as a series of command buffers that are pushed individually.
-	std::atomic<uint64> lastSubmittedCommandBufferTimestamp;
 	uint32 gx2InitCalled; // incremented every time GX2Init() is called
 	// OpenGL control
 	uint32 glVendor; // GLVENDOR_*
+	bool isDRCPrimary = false;
 	// temporary (replace with proper solution later)
 	bool tvBufferUsesSRGB;
 	bool drcBufferUsesSRGB;
@@ -64,16 +65,14 @@ struct LatteGPUState_t
 		{
 			bool isEnabled;
 			MPTR physPtr;
-			volatile uint32 flipRequestCount;
-			volatile uint32 flipExecuteCount;
+			std::atomic<uint32> flipRequestCount;
+			std::atomic<uint32> flipExecuteCount;
 		}screen[2];
 	}osScreen;
 };
 
 extern LatteGPUState_t LatteGPUState;
 
-extern uint8* gxRingBufferReadPtr; // currently active read pointer (gx2 ring buffer or display list)
-
 // texture
 
 #include "Cafe/HW/Latte/Core/LatteTexture.h"
@@ -83,6 +82,10 @@ extern uint8* gxRingBufferReadPtr; // currently active read pointer (gx2 ring bu
 void LatteTextureLoader_estimateAccessedDataRange(LatteTexture* texture, sint32 sliceIndex, sint32 mipIndex, uint32& addrStart, uint32& addrEnd);
 
 // render target
+
+#define RENDER_TARGET_TV (1 << 0)
+#define RENDER_TARGET_DRC (1 << 2)
+
 void LatteRenderTarget_updateScissorBox();
 
 void LatteRenderTarget_trackUpdates();
@@ -93,7 +96,7 @@ void LatteRenderTarget_copyToBackbuffer(LatteTextureView* textureView, bool isPa
 void LatteRenderTarget_GetCurrentVirtualViewportSize(sint32* viewportWidth, sint32* viewportHeight);
 
 void LatteRenderTarget_itHLESwapScanBuffer();
-void LatteRenderTarget_itHLEClearColorDepthStencil(uint32 clearMask, MPTR colorBufferMPTR, MPTR colorBufferFormat, Latte::E_HWTILEMODE colorBufferTilemode, uint32 colorBufferWidth, uint32 colorBufferHeight, uint32 colorBufferPitch, uint32 colorBufferViewFirstSlice, uint32 colorBufferViewNumSlice, MPTR depthBufferMPTR, MPTR depthBufferFormat, Latte::E_HWTILEMODE depthBufferTileMode, sint32 depthBufferWidth, sint32 depthBufferHeight, sint32 depthBufferPitch, sint32 depthBufferViewFirstSlice, sint32 depthBufferViewNumSlice, float r, float g, float b, float a, float clearDepth, uint32 clearStencil);
+void LatteRenderTarget_itHLEClearColorDepthStencil(uint32 clearMask, MPTR colorBufferMPTR, Latte::E_GX2SURFFMT colorBufferFormat, Latte::E_HWTILEMODE colorBufferTilemode, uint32 colorBufferWidth, uint32 colorBufferHeight, uint32 colorBufferPitch, uint32 colorBufferViewFirstSlice, uint32 colorBufferViewNumSlice, MPTR depthBufferMPTR, Latte::E_GX2SURFFMT depthBufferFormat, Latte::E_HWTILEMODE depthBufferTileMode, sint32 depthBufferWidth, sint32 depthBufferHeight, sint32 depthBufferPitch, sint32 depthBufferViewFirstSlice, sint32 depthBufferViewNumSlice, float r, float g, float b, float a, float clearDepth, uint32 clearStencil);
 void LatteRenderTarget_itHLECopyColorBufferToScanBuffer(MPTR colorBufferPtr, uint32 colorBufferWidth, uint32 colorBufferHeight, uint32 colorBufferSliceIndex, uint32 colorBufferFormat, uint32 colorBufferPitch, Latte::E_HWTILEMODE colorBufferTilemode, uint32 colorBufferSwizzle, uint32 renderTarget);
 
 void LatteRenderTarget_unloadAll();
@@ -110,7 +113,7 @@ void LatteTC_RegisterTexture(LatteTexture* tex);
 void LatteTC_UnregisterTexture(LatteTexture* tex);
 
 uint32 LatteTexture_CalculateTextureDataHash(LatteTexture* hostTexture);
-void LatteTexture_ReloadData(LatteTexture* hostTexture, uint32 textureUnit);
+void LatteTexture_ReloadData(LatteTexture* hostTexture);
 
 bool LatteTC_HasTextureChanged(LatteTexture* hostTexture, bool force = false);
 void LatteTC_ResetTextureChangeTracker(LatteTexture* hostTexture, bool force = false);
@@ -162,7 +165,7 @@ void LatteBufferCache_LoadRemappedUniforms(struct LatteDecompilerShader* shader,
 
 void LatteRenderTarget_updateViewport();
 
-#define LATTE_GLSL_DYNAMIC_UNIFORM_BLOCK_SIZE	(1024) // maximum size for uniform blocks (in vec4s). On Nvidia hardware 4096 is the maximum (64K / 16 = 4096) all other vendors have much higher limits
+#define LATTE_GLSL_DYNAMIC_UNIFORM_BLOCK_SIZE	(4096) // maximum size for uniform blocks (in vec4s). On Nvidia hardware 4096 is the maximum (64K / 16 = 4096) all other vendors have much higher limits
 
 //static uint32 glTempError;
 //#define catchOpenGLError() glFinish(); if( (glTempError = glGetError()) != 0 ) { printf("OpenGL error 0x%x: %s : %d timestamp %08x\n", glTempError, __FILE__, __LINE__, GetTickCount()); __debugbreak(); }
@@ -172,4 +175,5 @@ void LatteRenderTarget_updateViewport();
 // Latte emulation control
 void Latte_Start();
 void Latte_Stop();
-bool Latte_IsActive();
\ No newline at end of file
+bool Latte_GetStopSignal(); // returns true if stop was requested or if in stopped state
+void LatteThread_Exit();
\ No newline at end of file
diff --git a/src/Cafe/HW/Latte/Core/LatteAsyncCommands.cpp b/src/Cafe/HW/Latte/Core/LatteAsyncCommands.cpp
index a4ffa1c2..4b114ddf 100644
--- a/src/Cafe/HW/Latte/Core/LatteAsyncCommands.cpp
+++ b/src/Cafe/HW/Latte/Core/LatteAsyncCommands.cpp
@@ -96,7 +96,7 @@ void LatteAsyncCommands_waitUntilAllProcessed()
 void LatteAsyncCommands_checkAndExecute()
 {
 	// quick check if queue is empty (requires no lock)
-	if (!Latte_IsActive())
+	if (Latte_GetStopSignal())
 		LatteThread_Exit();
 	if (LatteAsyncCommandQueue.empty())
 		return;
@@ -120,7 +120,7 @@ void LatteAsyncCommands_checkAndExecute()
 			}
 			else
 			{
-				forceLogDebug_printf("Texture not found for readback");
+				cemuLog_logDebug(LogType::Force, "Texture not found for readback");
 			}
 		}
 		else if (asyncCommand.type == ASYNC_CMD_DELETE_SHADER)
@@ -135,4 +135,4 @@ void LatteAsyncCommands_checkAndExecute()
 		LatteAsyncCommandQueue.pop();
 	}
 	swl_gpuAsyncCommands.UnlockWrite();
-}
\ No newline at end of file
+}
diff --git a/src/Cafe/HW/Latte/Core/LatteBufferCache.cpp b/src/Cafe/HW/Latte/Core/LatteBufferCache.cpp
index b74f67b9..716312a3 100644
--- a/src/Cafe/HW/Latte/Core/LatteBufferCache.cpp
+++ b/src/Cafe/HW/Latte/Core/LatteBufferCache.cpp
@@ -29,7 +29,7 @@ class IntervalTree2
 
 	struct InternalRange
 	{
-		InternalRange() {};
+		InternalRange() = default;
 		InternalRange(TRangeData _rangeBegin, TRangeData _rangeEnd) : rangeBegin(_rangeBegin), rangeEnd(_rangeEnd) { cemu_assert_debug(_rangeBegin < _rangeEnd); };
 
 		TRangeData rangeBegin;
@@ -87,7 +87,7 @@ public:
 				return; // do nothing if added range is already covered
 			rangeBegin = (std::min)(rangeBegin, (*itr).first.rangeBegin);
 			// DEBUG - make sure this is the start point of the merge process (the first entry that starts below minValue)
-#ifndef PUBLIC_RELEASE
+#ifdef CEMU_DEBUG_ASSERT
 			if (itr != m_map.cbegin())
 			{
 				// check previous result
@@ -257,6 +257,11 @@ public:
 		}
 	}
 
+    bool empty() const
+    {
+        return m_map.empty();
+    }
+
 	const std::map<InternalRange, TNodeObject*>& getAll() const { return m_map; };
 };
 
@@ -304,7 +309,7 @@ public:
 	{
 		if ((rangeBegin & 0xF))
 		{
-			forceLogDebug_printf("writeStreamout(): RangeBegin not aligned to 16. Begin %08x End %08x", rangeBegin, rangeEnd);
+			cemuLog_logDebugOnce(LogType::Force, "writeStreamout(): RangeBegin not aligned to 16. Begin {:08x} End {:08x}", rangeBegin, rangeEnd);
 			rangeBegin = (rangeBegin + 0xF) & ~0xF;
 			rangeEnd = std::max(rangeBegin, rangeEnd);
 		}
@@ -313,7 +318,7 @@ public:
 			// todo - add support for 4 byte granularity for streamout writes and cache
 			// used by Affordable Space Adventures and YWW Level 1-8
 			// also used by CoD Ghosts (8 byte granularity)
-			//forceLogDebug_printf("Streamout write size is not aligned to 16 bytes");
+			//cemuLog_logDebug(LogType::Force, "Streamout write size is not aligned to 16 bytes");
 			rangeEnd &= ~0xF;
 		}
 		//cemu_assert_debug((rangeEnd & 0xF) == 0);
@@ -455,48 +460,6 @@ public:
 			}
 			if(m_invalidationRangeEnd <= m_invalidationRangeBegin)
 				m_hasInvalidation = false;
-
-			//if (resRangeBegin <= m_invalidationRangeBegin)
-			//{
-			//	// shrink/replace invalidation range from the bottom
-			//	uint32 uploadBegin = m_invalidationRangeBegin;//std::max(m_invalidationRangeBegin, resRangeBegin);
-			//	uint32 uploadEnd = std::min(resRangeEnd, m_invalidationRangeEnd);
-			//	cemu_assert_debug(uploadEnd >= uploadBegin);
-			//	if (uploadBegin != uploadEnd)
-			//		checkAndSyncModifications(uploadBegin, uploadEnd, true);
-			//	m_invalidationRangeBegin = uploadEnd;
-			//	cemu_assert_debug(m_invalidationRangeBegin <= m_invalidationRangeEnd);
-			//	if (m_invalidationRangeBegin >= m_invalidationRangeEnd)
-			//		m_hasInvalidation = false;
-			//}
-			//else if (resRangeEnd >= m_invalidationRangeEnd)
-			//{
-			//	// shrink/replace invalidation range from the top
-			//	uint32 uploadBegin = std::max(m_invalidationRangeBegin, resRangeBegin);
-			//	uint32 uploadEnd = m_invalidationRangeEnd;// std::min(resRangeEnd, m_invalidationRangeEnd);
-			//	cemu_assert_debug(uploadEnd >= uploadBegin);
-			//	if (uploadBegin != uploadEnd)
-			//		checkAndSyncModifications(uploadBegin, uploadEnd, true);
-			//	m_invalidationRangeEnd = uploadBegin;
-			//	cemu_assert_debug(m_invalidationRangeBegin <= m_invalidationRangeEnd);
-			//	if (m_invalidationRangeBegin >= m_invalidationRangeEnd)
-			//		m_hasInvalidation = false;
-			//}
-			//else
-			//{
-			//	// since we cant cut holes into the range upload it in it's entirety
-			//	cemu_assert_debug(m_invalidationRangeEnd <= m_rangeEnd);
-			//	cemu_assert_debug(m_invalidationRangeBegin >= m_rangeBegin);
-			//	cemu_assert_debug(m_invalidationRangeBegin < m_invalidationRangeEnd);
-			//	checkAndSyncModifications(m_invalidationRangeBegin, m_invalidationRangeEnd, true);
-			//	m_hasInvalidation = false;
-			//}
-
-
-
-			// todo - dont re-upload the whole range immediately
-			// under ideal circumstances we would only upload the data range requested for the current draw call
-			// but this is a hot path so we can't check
 		}
 	}
 
@@ -734,20 +697,34 @@ private:
 
 	static uint64 hashPage(uint8* mem)
 	{
-		// note - this algorithm is/was also baked into pageWriteStreamoutSignatures()
-		uint64 h = 0;
-		uint64* memU64 = (uint64*)mem;
-		for (uint32 i = 0; i < CACHE_PAGE_SIZE / 8; i++)
-		{
-			//h = _rotr64(h, 7);
-			//h ^= *memU64;
-			//memU64++;
+		static const uint64 k0 = 0x55F23EAD;
+		static const uint64 k1 = 0x185FDC6D;
+		static const uint64 k2 = 0xF7431F49;
+		static const uint64 k3 = 0xA4C7AE9D;
 
-			h = std::rotr<uint64>(h, 7);
-			h += (*memU64 + (uint64)i);
-			memU64++;
+		cemu_assert_debug((CACHE_PAGE_SIZE % 32) == 0);
+		const uint64* ptr = (const uint64*)mem;
+		const uint64* end = ptr + (CACHE_PAGE_SIZE / sizeof(uint64));
+
+		uint64 h0 = 0;
+		uint64 h1 = 0;
+		uint64 h2 = 0;
+		uint64 h3 = 0;
+		while (ptr < end)
+		{
+			h0 = std::rotr(h0, 7);
+			h1 = std::rotr(h1, 7);
+			h2 = std::rotr(h2, 7);
+			h3 = std::rotr(h3, 7);
+
+			h0 += ptr[0] * k0;
+			h1 += ptr[1] * k1;
+			h2 += ptr[2] * k2;
+			h3 += ptr[3] * k3;
+			ptr += 4;
 		}
-		return h;
+
+		return h0 + h1 + h2 + h3;
 	}
 
 	// flag page as having streamout data, also write streamout signatures to page memory
@@ -813,6 +790,21 @@ private:
 	static std::vector<uint32> g_deallocateQueue;
 
 public:
+    static void UnloadAll()
+    {
+        size_t i = 0;
+        while (i < s_allCacheNodes.size())
+        {
+            BufferCacheNode* node = s_allCacheNodes[i];
+            node->ReleaseCacheMemoryImmediately();
+            LatteBufferCache_removeSingleNodeFromTree(node);
+            delete node;
+        }
+        for(auto& it : s_allCacheNodes)
+            delete it;
+        s_allCacheNodes.clear();
+        g_deallocateQueue.clear();
+    }
 	
 	static void ProcessDeallocations()
 	{
@@ -871,11 +863,11 @@ public:
 			// retry allocation
 			if (!newRange->allocateCacheMemory())
 			{
-				forceLog_printf("Out-of-memory in GPU buffer (trying to allocate: %dKB) Cleaning up cache...", (rangeEnd - rangeBegin + 1023) / 1024);
+				cemuLog_log(LogType::Force, "Out-of-memory in GPU buffer (trying to allocate: {}KB) Cleaning up cache...", (rangeEnd - rangeBegin + 1023) / 1024);
 				CleanupCacheAggressive(rangeBegin, rangeEnd);
 				if (!newRange->allocateCacheMemory())
 				{
-					forceLog_printf("Failed to free enough memory in GPU buffer");
+					cemuLog_log(LogType::Force, "Failed to free enough memory in GPU buffer");
 					cemu_assert(false);
 				}
 			}
@@ -907,7 +899,7 @@ public:
 		// todo - add support for splitting BufferCacheNode memory allocations, then we dont need to do a separate allocation
 		if (!newRange->allocateCacheMemory())
 		{
-			forceLog_printf("Out-of-memory in GPU buffer during split operation");
+			cemuLog_log(LogType::Force, "Out-of-memory in GPU buffer during split operation");
 			cemu_assert(false);
 		}
 		newRange->syncFromNode(nodeObject);
@@ -917,7 +909,6 @@ public:
 };
 
 std::vector<uint32> BufferCacheNode::g_deallocateQueue;
-
 IntervalTree2<MPTR, BufferCacheNode> g_gpuBufferCache;
 
 void LatteBufferCache_removeSingleNodeFromTree(BufferCacheNode* node)
@@ -995,18 +986,83 @@ void LatteBufferCache_processDeallocations()
 
 void LatteBufferCache_init(size_t bufferSize)
 {
+    cemu_assert_debug(g_gpuBufferCache.empty());
 	g_gpuBufferHeap.reset(new VHeap(nullptr, (uint32)bufferSize));
 	g_renderer->bufferCache_init((uint32)bufferSize);
 }
 
+void LatteBufferCache_UnloadAll()
+{
+    BufferCacheNode::UnloadAll();
+}
+
 void LatteBufferCache_getStats(uint32& heapSize, uint32& allocationSize, uint32& allocNum)
 {
 	g_gpuBufferHeap->getStats(heapSize, allocationSize, allocNum);
 }
 
 FSpinlock g_spinlockDCFlushQueue;
-std::unordered_set<uint32>* g_DCFlushQueue = new std::unordered_set<uint32>(); // queued pages
-std::unordered_set<uint32>* g_DCFlushQueueAlternate = new std::unordered_set<uint32>();
+
+class SparseBitset
+{
+	static inline constexpr size_t TABLE_MASK = 0xFF;
+
+public:
+	bool Empty() const
+	{
+		return m_numNonEmptyVectors == 0;
+	}
+
+	void Set(uint32 index)
+	{
+		auto& v = m_bits[index & TABLE_MASK];
+		if (std::find(v.cbegin(), v.cend(), index) != v.end())
+			return;
+		if (v.empty())
+		{
+			m_nonEmptyVectors[m_numNonEmptyVectors] = &v;
+			m_numNonEmptyVectors++;
+		}
+		v.emplace_back(index);
+	}
+
+	template<typename TFunc>
+	void ForAllAndClear(TFunc callbackFunc)
+	{
+		auto vCurrent = m_nonEmptyVectors + 0;
+		auto vEnd = m_nonEmptyVectors + m_numNonEmptyVectors;
+		while (vCurrent < vEnd)
+		{
+			std::vector<uint32>* vec = *vCurrent;
+			vCurrent++;
+			for (const auto& it : *vec)
+				callbackFunc(it);
+			vec->clear();
+		}
+		m_numNonEmptyVectors = 0;
+	}
+
+	void Clear()
+	{
+		auto vCurrent = m_nonEmptyVectors + 0;
+		auto vEnd = m_nonEmptyVectors + m_numNonEmptyVectors;
+		while (vCurrent < vEnd)
+		{
+			std::vector<uint32>* vec = *vCurrent;
+			vCurrent++;
+			vec->clear();
+		}
+		m_numNonEmptyVectors = 0;
+	}
+
+private:
+	std::vector<uint32> m_bits[TABLE_MASK + 1];
+	std::vector<uint32>* m_nonEmptyVectors[TABLE_MASK + 1];
+	size_t m_numNonEmptyVectors{ 0 };
+};
+
+SparseBitset* s_DCFlushQueue = new SparseBitset();
+SparseBitset* s_DCFlushQueueAlternate = new SparseBitset();
 
 void LatteBufferCache_notifyDCFlush(MPTR address, uint32 size)
 {
@@ -1015,22 +1071,20 @@ void LatteBufferCache_notifyDCFlush(MPTR address, uint32 size)
 
 	uint32 firstPage = address / CACHE_PAGE_SIZE;
 	uint32 lastPage = (address + size - 1) / CACHE_PAGE_SIZE;
-	g_spinlockDCFlushQueue.acquire();
+	g_spinlockDCFlushQueue.lock();
 	for (uint32 i = firstPage; i <= lastPage; i++)
-		g_DCFlushQueue->emplace(i);
-	g_spinlockDCFlushQueue.release();
+		s_DCFlushQueue->Set(i);
+	g_spinlockDCFlushQueue.unlock();
 }
 
 void LatteBufferCache_processDCFlushQueue()
 {
-	if (g_DCFlushQueue->empty()) // accessing this outside of the lock is technically undefined/unsafe behavior but on all known implementations this is fine and we can avoid the spinlock
+	if (s_DCFlushQueue->Empty()) // quick check to avoid locking if there is no work to do
 		return;
-	g_spinlockDCFlushQueue.acquire();
-	std::swap(g_DCFlushQueue, g_DCFlushQueueAlternate);
-	g_spinlockDCFlushQueue.release();
-	for (auto& itr : *g_DCFlushQueueAlternate)
-		LatteBufferCache_invalidatePage(itr * CACHE_PAGE_SIZE);
-	g_DCFlushQueueAlternate->clear();
+	g_spinlockDCFlushQueue.lock();
+	std::swap(s_DCFlushQueue, s_DCFlushQueueAlternate);
+	g_spinlockDCFlushQueue.unlock();
+	s_DCFlushQueueAlternate->ForAllAndClear([](uint32 index) {LatteBufferCache_invalidatePage(index * CACHE_PAGE_SIZE); });
 }
 
 void LatteBufferCache_notifyDrawDone()
diff --git a/src/Cafe/HW/Latte/Core/LatteBufferCache.h b/src/Cafe/HW/Latte/Core/LatteBufferCache.h
index da285192..62ae3f1f 100644
--- a/src/Cafe/HW/Latte/Core/LatteBufferCache.h
+++ b/src/Cafe/HW/Latte/Core/LatteBufferCache.h
@@ -1,6 +1,7 @@
 #pragma once
 
 void LatteBufferCache_init(size_t bufferSize);
+void LatteBufferCache_UnloadAll();
 
 uint32 LatteBufferCache_retrieveDataInCache(MPTR physAddress, uint32 size);
 void LatteBufferCache_copyStreamoutDataToCache(MPTR physAddress, uint32 size, uint32 streamoutBufferOffset);
diff --git a/src/Cafe/HW/Latte/Core/LatteBufferData.cpp b/src/Cafe/HW/Latte/Core/LatteBufferData.cpp
index d864750a..85d4cdf7 100644
--- a/src/Cafe/HW/Latte/Core/LatteBufferData.cpp
+++ b/src/Cafe/HW/Latte/Core/LatteBufferData.cpp
@@ -9,6 +9,7 @@
 #include "Cafe/GameProfile/GameProfile.h"
 
 #include "Cafe/HW/Latte/Core/LatteBufferCache.h"
+#include "Cafe/HW/Latte/Renderer/Vulkan/VulkanRenderer.h"
 
 template<int vectorLen>
 void rectGenerate4thVertex(uint32be* output, uint32be* input0, uint32be* input1, uint32be* input2)
@@ -131,22 +132,18 @@ void LatteBufferCache_syncGPUUniformBuffers(LatteDecompilerShader* shader, const
 {
 	if (shader->uniformMode == LATTE_DECOMPILER_UNIFORM_MODE_FULL_CBANK)
 	{
-		// use full uniform buffers
-		for (sint32 t = 0; t < shader->uniformBufferListCount; t++)
+		for(const auto& buf : shader->list_quickBufferList)
 		{
-			sint32 i = shader->uniformBufferList[t];
+			sint32 i = buf.index;
 			MPTR physicalAddr = LatteGPUState.contextRegister[uniformBufferRegOffset + i * 7 + 0];
 			uint32 uniformSize = LatteGPUState.contextRegister[uniformBufferRegOffset + i * 7 + 1] + 1;
-
-			if (physicalAddr == MPTR_NULL)
+			if (physicalAddr == MPTR_NULL) [[unlikely]]
 			{
-				// no data
 				g_renderer->buffer_bindUniformBuffer(shaderType, i, 0, 0);
 				continue;
 			}
-
+			uniformSize = std::min<uint32>(uniformSize, buf.size);
 			uint32 bindOffset = LatteBufferCache_retrieveDataInCache(physicalAddr, uniformSize);
-
 			g_renderer->buffer_bindUniformBuffer(shaderType, i, bindOffset, uniformSize);
 		}
 	}
@@ -198,6 +195,19 @@ bool LatteBufferCache_Sync(uint32 minIndex, uint32 maxIndex, uint32 baseInstance
 		if (fixedBufferSize == 0 || bufferStride == 0)
 			fixedBufferSize += 128;
 
+
+#if BOOST_OS_MACOS
+		if(bufferStride % 4 != 0)
+		{
+			if (VulkanRenderer* vkRenderer = VulkanRenderer::GetInstance())
+			{
+				auto fixedBuffer = vkRenderer->buffer_genStrideWorkaroundVertexBuffer(bufferAddress, fixedBufferSize, bufferStride);
+				vkRenderer->buffer_bindVertexStrideWorkaroundBuffer(fixedBuffer.first, fixedBuffer.second, bufferIndex, fixedBufferSize);
+				continue;
+			}
+		}
+#endif
+
 		uint32 bindOffset = LatteBufferCache_retrieveDataInCache(bufferAddress, fixedBufferSize);
 		g_renderer->buffer_bindVertexBuffer(bufferIndex, bindOffset, fixedBufferSize);
 	}
diff --git a/src/Cafe/HW/Latte/Core/LatteCachedFBO.h b/src/Cafe/HW/Latte/Core/LatteCachedFBO.h
index 47fa9b42..5f3aaed4 100644
--- a/src/Cafe/HW/Latte/Core/LatteCachedFBO.h
+++ b/src/Cafe/HW/Latte/Core/LatteCachedFBO.h
@@ -42,7 +42,7 @@ private:
 			if(colorBuffer[i].texture == nullptr)
 				continue;
 			sint32 effectiveWidth, effectiveHeight;
-			LatteTexture_getEffectiveSize(colorBuffer[i].texture->baseTexture, &effectiveWidth, &effectiveHeight, nullptr, colorBuffer[i].texture->firstMip);
+			colorBuffer[i].texture->baseTexture->GetEffectiveSize(effectiveWidth, effectiveHeight, colorBuffer[i].texture->firstMip);
 			if (rtEffectiveSize.x == 0 && rtEffectiveSize.y == 0)
 			{
 				rtEffectiveSize.x = effectiveWidth;
@@ -50,12 +50,12 @@ private:
 			}
 			if (effectiveWidth < rtEffectiveSize.x)
 			{
-				forceLogDebug_printf("Framebuffer has color texture with smaller effective width (%d -> %d)", rtEffectiveSize.x, effectiveWidth);
+				cemuLog_logDebug(LogType::Force, "Framebuffer has color texture with smaller effective width ({} -> {})", rtEffectiveSize.x, effectiveWidth);
 				rtEffectiveSize.x = effectiveWidth;
 			}
 			if (effectiveHeight < rtEffectiveSize.y)
 			{
-				forceLogDebug_printf("Framebuffer has color texture with smaller effective height (%d -> %d)", rtEffectiveSize.y, effectiveHeight);
+				cemuLog_logDebug(LogType::Force, "Framebuffer has color texture with smaller effective height ({} -> {})", rtEffectiveSize.y, effectiveHeight);
 				rtEffectiveSize.y = effectiveHeight;
 			}
 			numViews++;
@@ -64,7 +64,7 @@ private:
 		if (depthBuffer.texture)
 		{
 			sint32 effectiveWidth, effectiveHeight;
-			LatteTexture_getEffectiveSize(depthBuffer.texture->baseTexture, &effectiveWidth, &effectiveHeight, nullptr, depthBuffer.texture->firstMip);
+			depthBuffer.texture->baseTexture->GetEffectiveSize(effectiveWidth, effectiveHeight, depthBuffer.texture->firstMip);
 			if (rtEffectiveSize.x == 0 && rtEffectiveSize.y == 0)
 			{
 				rtEffectiveSize.x = effectiveWidth;
@@ -72,12 +72,12 @@ private:
 			}
 			if (effectiveWidth < rtEffectiveSize.x)
 			{
-				forceLogDebug_printf("Framebuffer has depth texture with smaller effective width (%d -> %d)", rtEffectiveSize.x, effectiveWidth);
+				cemuLog_logDebug(LogType::Force, "Framebuffer has depth texture with smaller effective width ({} -> {})", rtEffectiveSize.x, effectiveWidth);
 				rtEffectiveSize.x = effectiveWidth;
 			}
 			if (effectiveHeight < rtEffectiveSize.y)
 			{
-				forceLogDebug_printf("Framebuffer has depth texture with smaller effective height (%d -> %d)", rtEffectiveSize.y, effectiveHeight);
+				cemuLog_logDebug(LogType::Force, "Framebuffer has depth texture with smaller effective height ({} -> {})", rtEffectiveSize.y, effectiveHeight);
 				rtEffectiveSize.y = effectiveHeight;
 			}
 			numViews++;
@@ -145,4 +145,4 @@ public:
 
 private:
 	static LatteCachedFBO* CreateCachedFBO(uint64 key);
-};
\ No newline at end of file
+};
diff --git a/src/Cafe/HW/Latte/Core/LatteCommandProcessor.cpp b/src/Cafe/HW/Latte/Core/LatteCommandProcessor.cpp
index b95b84d3..4385cf49 100644
--- a/src/Cafe/HW/Latte/Core/LatteCommandProcessor.cpp
+++ b/src/Cafe/HW/Latte/Core/LatteCommandProcessor.cpp
@@ -13,17 +13,21 @@
 #include "Cafe/HW/Latte/Core/LattePM4.h"
 
 #include "Cafe/OS/libs/coreinit/coreinit_Time.h"
+#include "Cafe/OS/libs/TCL/TCL.h" // TCL currently handles the GPU command ringbuffer
 
 #include "Cafe/CafeSystem.h"
 
+#include <boost/container/small_vector.hpp>
+
+void LatteCP_DebugPrintCmdBuffer(uint32be* bufferPtr, uint32 size);
+
 #define CP_TIMER_RECHECK	1024
 
-//#define FAST_DRAW_LOGGING
+//#define LATTE_CP_LOGGING
 
-uint8* gxRingBufferReadPtr; // currently active read pointer (gx2 ring buffer or display list)
-uint8* gx2CPParserDisplayListPtr;
-uint8* gx2CPParserDisplayListStart; // used for debugging
-uint8* gx2CPParserDisplayListEnd;
+typedef uint32be* LatteCMDPtr;
+#define LatteReadCMD() ((uint32)*(cmd++))
+#define LatteSkipCMD(_nWords) cmd += (_nWords)
 
 void LatteThread_HandleOSScreen();
 
@@ -31,6 +35,14 @@ void LatteThread_Exit();
 
 class DrawPassContext
 {
+	struct CmdQueuePos
+	{
+		CmdQueuePos(LatteCMDPtr current, LatteCMDPtr start, LatteCMDPtr end) : current(current), start(start), end(end) {};
+
+		LatteCMDPtr current;
+		LatteCMDPtr start;
+		LatteCMDPtr end;
+	};
 public:
 	bool isWithinDrawPass() const
 	{
@@ -54,6 +66,13 @@ public:
 		if (numInstances == 0)
 			return;
 
+		/*
+		if (GetAsyncKeyState('B'))
+		{
+			cemuLog_force("[executeDraw] {} Count {} BaseVertex {} BaseInstance {}", m_isFirstDraw?"Init":"Fast", count, baseVertex, baseInstance);
+		}
+		*/
+
 		if (!isAutoIndex)
 		{
 			cemu_assert_debug(physIndices != MPTR_NULL);
@@ -66,6 +85,9 @@ public:
 		{
 			g_renderer->draw_execute(baseVertex, baseInstance, numInstances, count, MPTR_NULL, Latte::LATTE_VGT_DMA_INDEX_TYPE::E_INDEX_TYPE::AUTO, m_isFirstDraw);
 		}
+		performanceMonitor.cycle[performanceMonitor.cycleIndex].drawCallCounter++;
+		if (!m_isFirstDraw)
+			performanceMonitor.cycle[performanceMonitor.cycleIndex].fastDrawCallCounter++;
 		m_isFirstDraw = false;
 		m_vertexBufferChanged = false;
 		m_uniformBufferChanged = false;
@@ -87,14 +109,41 @@ public:
 		m_uniformBufferChanged = true;
 	}
 
+	// command buffer processing position
+	void PushCurrentCommandQueuePos(LatteCMDPtr current, LatteCMDPtr start, LatteCMDPtr end)
+	{
+		m_queuePosStack.emplace_back(current, start, end);
+	}
+
+	bool PopCurrentCommandQueuePos(LatteCMDPtr& current, LatteCMDPtr& start, LatteCMDPtr& end)
+	{
+		if (m_queuePosStack.empty())
+			return false;
+		const auto& it = m_queuePosStack.back();
+		current = it.current;
+		start = it.start;
+		end = it.end;
+		m_queuePosStack.pop_back();
+		return true;
+	}
+
 private:
 	bool m_drawPassActive{ false };
 	bool m_isFirstDraw{false};
 	bool m_vertexBufferChanged{ false };
 	bool m_uniformBufferChanged{ false };
+	boost::container::small_vector<CmdQueuePos, 4> m_queuePosStack;
 };
 
-void LatteCP_processCommandBuffer(uint8* cmdBuffer, sint32 cmdSize, DrawPassContext& drawPassCtx);
+void LatteCP_processCommandBuffer(DrawPassContext& drawPassCtx);
+
+// called whenever the GPU runs out of commands or hits a wait condition (semaphores, HLE waits)
+void LatteCP_signalEnterWait()
+{
+	// based on the assumption that games won't do a rugpull and swap out buffer data in the middle of an uninterrupted sequence of drawcalls,
+	// we only flush caches when the GPU goes idle or has to wait for any operation
+	LatteIndices_invalidateAll();
+}
 
 /*
 * Read a U32 from the command buffer
@@ -102,16 +151,12 @@ void LatteCP_processCommandBuffer(uint8* cmdBuffer, sint32 cmdSize, DrawPassCont
 */
 uint32 LatteCP_readU32Deprc()
 {
-	uint32 v;
-	uint8* gxRingBufferWritePtr;
-	sint32 readDistance;
 	// no display list active
 	while (true)
 	{
-		gxRingBufferWritePtr = gx2WriteGatherPipe.writeGatherPtrGxBuffer[GX2::sGX2MainCoreIndex];
-		readDistance = (sint32)(gxRingBufferWritePtr - gxRingBufferReadPtr);
-		if (readDistance != 0)
-			break;
+		uint32 cmdWord;
+		if ( TCL::TCLGPUReadRBWord(cmdWord) )
+			return cmdWord;
 
 		g_renderer->NotifyLatteCommandProcessorIdle(); // let the renderer know in case it wants to flush any commands
 		performanceMonitor.gpuTime_idleTime.beginMeasuring();
@@ -122,57 +167,9 @@ uint32 LatteCP_readU32Deprc()
 		}
 		LatteThread_HandleOSScreen(); // check if new frame was presented via OSScreen API
 
-		readDistance = (sint32)(gxRingBufferWritePtr - gxRingBufferReadPtr);
-		if (readDistance != 0)
-			break;
-		if (!Latte_IsActive())
-			LatteThread_Exit();
-
-		// still no command data available, do some other tasks
-		LatteTiming_HandleTimedVsync();
-		LatteAsyncCommands_checkAndExecute();
-		std::this_thread::yield();
-		performanceMonitor.gpuTime_idleTime.endMeasuring();
-	}
-	v = *(uint32*)gxRingBufferReadPtr;
-	gxRingBufferReadPtr += 4;
-#ifndef PUBLIC_RELEASE
-	if (v == 0xcdcdcdcd)
-		assert_dbg();
-#endif
-	v = _swapEndianU32(v);
-	return v;
-}
-
-void LatteCP_waitForNWords(uint32 numWords)
-{
-	uint8* gxRingBufferWritePtr;
-	sint32 readDistance;
-	bool isFlushed = false;
-	sint32 waitDistance = numWords * sizeof(uint32be);
-	// no display list active
-	while (true)
-	{
-		gxRingBufferWritePtr = gx2WriteGatherPipe.writeGatherPtrGxBuffer[GX2::sGX2MainCoreIndex];
-		readDistance = (sint32)(gxRingBufferWritePtr - gxRingBufferReadPtr);
-		if (readDistance < 0)
-			return; // wrap around means there is at least one full command queued after this
-		if (readDistance >= waitDistance)
-			break;
-		g_renderer->NotifyLatteCommandProcessorIdle(); // let the renderer know in case it wants to flush any commands
-		performanceMonitor.gpuTime_idleTime.beginMeasuring();
-		// no command data available, spin in a busy loop for a while then check again
-		for (sint32 busy = 0; busy < 80; busy++)
-		{
-			_mm_pause();
-		}
-		readDistance = (sint32)(gxRingBufferWritePtr - gxRingBufferReadPtr);
-		if (readDistance < 0)
-			return; // wrap around means there is at least one full command queued after this
-		if (readDistance >= waitDistance)
-			break;
-
-		if (!Latte_IsActive())
+		if ( TCL::TCLGPUReadRBWord(cmdWord) )
+			return cmdWord;
+		if (Latte_GetStopSignal())
 			LatteThread_Exit();
 
 		// still no command data available, do some other tasks
@@ -181,6 +178,7 @@ void LatteCP_waitForNWords(uint32 numWords)
 		std::this_thread::yield();
 		performanceMonitor.gpuTime_idleTime.endMeasuring();
 	}
+	UNREACHABLE;
 }
 
 template<uint32 readU32()>
@@ -193,10 +191,6 @@ void LatteCP_skipWords(uint32 wordsToSkip)
 	}
 }
 
-typedef uint32be* LatteCMDPtr;
-#define LatteReadCMD() ((uint32)*(cmd++))
-#define LatteSkipCMD(_nWords) cmd += (_nWords)
-
 LatteCMDPtr LatteCP_itSurfaceSync(LatteCMDPtr cmd)
 {
 	uint32 invalidationFlags = LatteReadCMD();
@@ -215,33 +209,44 @@ LatteCMDPtr LatteCP_itSurfaceSync(LatteCMDPtr cmd)
 	return cmd;
 }
 
-template<uint32 readU32()>
-void LatteCP_itIndirectBufferDepr(uint32 nWords)
+// called from TCL command queue. Executes a memory command buffer
+void LatteCP_itIndirectBufferDepr(LatteCMDPtr cmd, uint32 nWords)
 {
 	cemu_assert_debug(nWords == 3);
+	uint32 physicalAddress = LatteReadCMD();
+	uint32 physicalAddressHigh = LatteReadCMD(); // unused
+	uint32 sizeInU32s = LatteReadCMD();
 
-	uint32 physicalAddress = readU32();
-	uint32 physicalAddressHigh = readU32(); // unused
-	uint32 sizeInDWords = readU32();
-	uint32 displayListSize = sizeInDWords * 4;
-	cemu_assert_debug(displayListSize >= 4);
-	DrawPassContext drawPassCtx;
-	LatteCP_processCommandBuffer(memory_getPointerFromPhysicalOffset(physicalAddress), displayListSize, drawPassCtx);
-	if (drawPassCtx.isWithinDrawPass())
-		drawPassCtx.endDrawPass();
+#ifdef LATTE_CP_LOGGING
+	if (GetAsyncKeyState('A'))
+		LatteCP_DebugPrintCmdBuffer(MEMPTR<uint32be>(physicalAddress), displayListSize);
+#endif
+
+	if (sizeInU32s > 0)
+	{
+		DrawPassContext drawPassCtx;
+		uint32be* buf = MEMPTR<uint32be>(physicalAddress).GetPtr();
+		drawPassCtx.PushCurrentCommandQueuePos(buf, buf, buf + sizeInU32s);
+
+		LatteCP_processCommandBuffer(drawPassCtx);
+		if (drawPassCtx.isWithinDrawPass())
+			drawPassCtx.endDrawPass();
+	}
 }
 
-LatteCMDPtr LatteCP_itIndirectBuffer(LatteCMDPtr cmd, uint32 nWords, DrawPassContext& drawPassCtx)
+// pushes the command buffer to the stack
+void LatteCP_itIndirectBuffer(LatteCMDPtr cmd, uint32 nWords, DrawPassContext& drawPassCtx)
 {
 	cemu_assert_debug(nWords == 3);
 	uint32 physicalAddress = LatteReadCMD();
 	uint32 physicalAddressHigh = LatteReadCMD(); // unused
 	uint32 sizeInDWords = LatteReadCMD();
-	uint32 displayListSize = sizeInDWords * 4;
-	cemu_assert_debug(displayListSize >= 4);
-
-	LatteCP_processCommandBuffer(memory_getPointerFromPhysicalOffset(physicalAddress), displayListSize, drawPassCtx);
-	return cmd;
+	if (sizeInDWords > 0)
+	{
+		uint32 displayListSize = sizeInDWords * 4;
+		uint32be* buf = MEMPTR<uint32be>(physicalAddress).GetPtr();
+		drawPassCtx.PushCurrentCommandQueuePos(buf, buf, buf + sizeInDWords);
+	}
 }
 
 LatteCMDPtr LatteCP_itStreamoutBufferUpdate(LatteCMDPtr cmd, uint32 nWords)
@@ -299,7 +304,7 @@ LatteCMDPtr LatteCP_itSetRegistersGeneric(LatteCMDPtr cmd, uint32 nWords)
 	uint32 registerIndex = TRegisterBase + registerOffset;
 	uint32 registerStartIndex = registerIndex;
 	uint32 registerEndIndex = registerStartIndex + nWords;
-#ifndef PUBLIC_RELEASE
+#ifdef CEMU_DEBUG_ASSERT
 	cemu_assert_debug((registerIndex + nWords) <= LATTE_MAX_REGISTER);
 #endif
 	uint32* outputReg = (uint32*)(LatteGPUState.contextRegister + registerIndex);
@@ -340,7 +345,7 @@ LatteCMDPtr LatteCP_itSetRegistersGeneric(LatteCMDPtr cmd, uint32 nWords, TRegRa
 	uint32 registerIndex = TRegisterBase + registerOffset;
 	uint32 registerStartIndex = registerIndex;
 	uint32 registerEndIndex = registerStartIndex + nWords;
-#ifndef PUBLIC_RELEASE
+#ifdef CEMU_DEBUG_ASSERT
 	cemu_assert_debug((registerIndex + nWords) <= LATTE_MAX_REGISTER);
 #endif
 	cbRegRange(registerStartIndex, registerEndIndex);
@@ -417,6 +422,8 @@ LatteCMDPtr LatteCP_itWaitRegMem(LatteCMDPtr cmd, uint32 nWords)
 	const uint32 GPU7_WAIT_MEM_OP_GREATER = 6;
 	const uint32 GPU7_WAIT_MEM_OP_NEVER = 7;
 
+	LatteCP_signalEnterWait();
+
 	bool stalls = false;
 	if ((word0 & 0x10) != 0)
 	{
@@ -426,18 +433,45 @@ LatteCMDPtr LatteCP_itWaitRegMem(LatteCMDPtr cmd, uint32 nWords)
 		{
 			uint32 fenceMemValue = _swapEndianU32(*fencePtr);
 			fenceMemValue &= fenceMask;
-			if (compareOp == GPU7_WAIT_MEM_OP_GEQUAL)
+			if (compareOp == GPU7_WAIT_MEM_OP_LESS)
 			{
-				// greater or equal
-				if (fenceMemValue >= fenceValue)
+				if (fenceMemValue < fenceValue)
+					break;
+			}
+			else if (compareOp == GPU7_WAIT_MEM_OP_LEQUAL)
+			{
+				if (fenceMemValue <= fenceValue)
 					break;
 			}
 			else if (compareOp == GPU7_WAIT_MEM_OP_EQUAL)
 			{
-				// equal
 				if (fenceMemValue == fenceValue)
 					break;
 			}
+			else if (compareOp == GPU7_WAIT_MEM_OP_NOTEQUAL)
+			{
+				if (fenceMemValue != fenceValue)
+					break;
+			}
+			else if (compareOp == GPU7_WAIT_MEM_OP_GEQUAL)
+			{
+				if (fenceMemValue >= fenceValue)
+					break;
+			}
+			else if (compareOp == GPU7_WAIT_MEM_OP_GREATER)
+			{
+				if (fenceMemValue > fenceValue)
+					break;
+			}
+			else if (compareOp == GPU7_WAIT_MEM_OP_ALWAYS)
+			{
+				break;
+			}
+			else if (compareOp == GPU7_WAIT_MEM_OP_NEVER)
+			{
+				cemuLog_logOnce(LogType::Force, "Latte: WAIT_MEM_OP_NEVER encountered");
+				break;
+			}
 			else
 				assert_dbg();
 			if (!stalls)
@@ -471,7 +505,7 @@ LatteCMDPtr LatteCP_itMemWrite(LatteCMDPtr cmd, uint32 nWords)
 	MPTR valuePhysAddr = (word0 & ~3);
 	if (valuePhysAddr == 0)
 	{
-		cemuLog_force("GPU: Invalid itMemWrite to null pointer");
+		cemuLog_log(LogType::Force, "GPU: Invalid itMemWrite to null pointer");
 		return cmd;
 	}
 	uint32be* memPtr = (uint32be*)memory_getPointerFromPhysicalOffset(valuePhysAddr);
@@ -479,26 +513,55 @@ LatteCMDPtr LatteCP_itMemWrite(LatteCMDPtr cmd, uint32 nWords)
 	if (word1 == 0x40000)
 	{
 		// write U32
-		*memPtr = word2;
+		stdx::atomic_ref<uint32be> atomicRef(*memPtr);
+		atomicRef.store(word2);
 	}
 	else if (word1 == 0x00000)
 	{
-		// write U64 (as two U32)
-		// note: The U32s are swapped
-		memPtr[0] = word2;
-		memPtr[1] = word3;
+		// write U64
+		// note: The U32s are swapped here, but needs verification. Also, it seems like the two U32 halves are written independently and the U64 as a whole is not atomic -> investiagte
+		stdx::atomic_ref<uint64be> atomicRef(*(uint64be*)memPtr);
+		atomicRef.store(((uint64le)word2 << 32) | word3);
 	}
 	else if (word1 == 0x20000)
 	{
 		// write U64 (little endian)
-		memPtr[0] = _swapEndianU32(word2);
-		memPtr[1] = _swapEndianU32(word3);
+		stdx::atomic_ref<uint64le> atomicRef(*(uint64le*)memPtr);
+		atomicRef.store(((uint64le)word3 << 32) | word2);
 	}
 	else
 		cemu_assert_unimplemented();
 	return cmd;
 }
 
+LatteCMDPtr LatteCP_itEventWriteEOP(LatteCMDPtr cmd, uint32 nWords)
+{
+	cemu_assert_debug(nWords == 5);
+	uint32 word0 = LatteReadCMD();
+	uint32 word1 = LatteReadCMD();
+	uint32 word2 = LatteReadCMD();
+	uint32 word3 = LatteReadCMD(); // value low bits
+	uint32 word4 = LatteReadCMD(); // value high bits
+
+	cemu_assert_debug(word2 == 0x40000000 || word2 == 0x42000000);
+
+	if (word0 == 0x504 && (word2&0x40000000)) // todo - figure out the flags
+	{
+		stdx::atomic_ref<uint64be> atomicRef(*(uint64be*)memory_getPointerFromPhysicalOffset(word1));
+		uint64 val = ((uint64)word4 << 32) | word3;
+		atomicRef.store(val);
+	}
+	else
+	{	cemu_assert_unimplemented();
+	}
+	bool triggerInterrupt = (word2 & 0x2000000) != 0;
+	if (triggerInterrupt)
+	{
+		// todo - timestamp interrupt
+	}
+	TCL::TCLGPUNotifyNewRetirementTimestamp();
+	return cmd;
+}
 
 LatteCMDPtr LatteCP_itMemSemaphore(LatteCMDPtr cmd, uint32 nWords)
 {
@@ -518,6 +581,7 @@ LatteCMDPtr LatteCP_itMemSemaphore(LatteCMDPtr cmd, uint32 nWords)
 	else if(SEM_SIGNAL == 7)
 	{
 		// wait
+		LatteCP_signalEnterWait();
 		size_t loopCount = 0;
 		while (true)
 		{
@@ -560,19 +624,19 @@ LatteCMDPtr LatteCP_itLoadReg(LatteCMDPtr cmd, uint32 nWords, uint32 regBase)
 	MPTR physAddressRegArea = LatteReadCMD();
 	uint32 waitForIdle = LatteReadCMD();
 	uint32 loadEntries = (nWords - 2) / 2;
-	uint32 regIndex = 0;
+	uint32 regShadowMemAddr = physAddressRegArea;
 	for (uint32 i = 0; i < loadEntries; i++)
 	{
 		uint32 regOffset = LatteReadCMD();
 		uint32 regCount = LatteReadCMD();
 		cemu_assert_debug(regCount != 0);
+		uint32 regAddr = regBase + regOffset;
 		for (uint32 f = 0; f < regCount; f++)
 		{
-			uint32 regAddr = regBase + regOffset + f;
-			uint32 regShadowMemAddr = physAddressRegArea + regIndex * 4;
 			LatteGPUState.contextRegisterShadowAddr[regAddr] = regShadowMemAddr;
-			LatteGPUState.contextRegister[regAddr] = memory_readU32Direct(regShadowMemAddr);
-			regIndex++;
+			LatteGPUState.contextRegister[regAddr] = memory_read<uint32>(regShadowMemAddr);
+			regAddr++;
+			regShadowMemAddr += 4;
 		}
 	}
 	return cmd;
@@ -616,8 +680,6 @@ LatteCMDPtr LatteCP_itDrawIndex2(LatteCMDPtr cmd, uint32 nWords, DrawPassContext
 	uint32 count = LatteReadCMD();
 	uint32 ukn3 = LatteReadCMD();
 
-	performanceMonitor.cycle[performanceMonitor.cycleIndex].drawCallCounter++;
-
 	LatteGPUState.currentDrawCallTick = GetTickCount();
 	drawPassCtx.executeDraw(count, false, physIndices);
 	return cmd;
@@ -629,8 +691,6 @@ LatteCMDPtr LatteCP_itDrawIndexAuto(LatteCMDPtr cmd, uint32 nWords, DrawPassCont
 	uint32 count = LatteReadCMD();
 	uint32 ukn = LatteReadCMD();
 
-	performanceMonitor.cycle[performanceMonitor.cycleIndex].drawCallCounter++;
-
 	if (LatteGPUState.drawContext.numInstances == 0)
 		return cmd;
 	LatteGPUState.currentDrawCallTick = GetTickCount();
@@ -639,7 +699,7 @@ LatteCMDPtr LatteCP_itDrawIndexAuto(LatteCMDPtr cmd, uint32 nWords, DrawPassCont
 	{
 		uint32 vsProgramCode = ((LatteGPUState.contextRegister[mmSQ_PGM_START_ES] & 0xFFFFFF) << 8);
 		uint32 vsProgramSize = LatteGPUState.contextRegister[mmSQ_PGM_START_ES + 1] << 3;
-		forceLogDebug_printf("Compute %d %08x %08x (unsupported)\n", count, vsProgramCode, vsProgramSize);
+		cemuLog_logDebug(LogType::Force, "Compute {} {:08x} {:08x} (unsupported)", count, vsProgramCode, vsProgramSize);
 	}
 	else
 	{
@@ -693,7 +753,6 @@ LatteCMDPtr LatteCP_itDrawImmediate(LatteCMDPtr cmd, uint32 nWords, DrawPassCont
 	// verify packet size
 	if (nWords != (2 + numIndexU32s))
 		debugBreakpoint();
-	performanceMonitor.cycle[performanceMonitor.cycleIndex].drawCallCounter++;
 
 	uint32 baseVertex = LatteGPUState.contextRegister[mmSQ_VTX_BASE_VTX_LOC];
 	uint32 baseInstance = LatteGPUState.contextRegister[mmSQ_VTX_START_INST_LOC];
@@ -701,23 +760,13 @@ LatteCMDPtr LatteCP_itDrawImmediate(LatteCMDPtr cmd, uint32 nWords, DrawPassCont
 
 	drawPassCtx.executeDraw(count, false, _tempIndexArrayMPTR);
 	return cmd;
-
-}
-
-LatteCMDPtr LatteCP_itHLEFifoWrapAround(LatteCMDPtr cmd, uint32 nWords)
-{
-	cemu_assert_debug(nWords == 1);
-	uint32 unused = LatteReadCMD();
-	gxRingBufferReadPtr = gx2WriteGatherPipe.gxRingBuffer;
-	cmd = (LatteCMDPtr)gxRingBufferReadPtr;
-	return cmd;
 }
 
 LatteCMDPtr LatteCP_itHLESampleTimer(LatteCMDPtr cmd, uint32 nWords)
 {
 	cemu_assert_debug(nWords == 1);
 	MPTR timerMPTR = (MPTR)LatteReadCMD();
-	memory_writeU64Slow(timerMPTR, coreinit::coreinit_getTimerTick());
+	memory_writeU64(timerMPTR, coreinit::OSGetSystemTime());
 	return cmd;
 }
 
@@ -737,16 +786,6 @@ LatteCMDPtr LatteCP_itHLESpecialState(LatteCMDPtr cmd, uint32 nWords)
 	return cmd;
 }
 
-LatteCMDPtr LatteCP_itHLESetRetirementTimestamp(LatteCMDPtr cmd, uint32 nWords)
-{
-	cemu_assert_debug(nWords == 2);
-	uint32 timestampHigh = (uint32)LatteReadCMD();
-	uint32 timestampLow = (uint32)LatteReadCMD();
-	uint64 timestamp = ((uint64)timestampHigh << 32ULL) | (uint64)timestampLow;
-	GX2::__GX2NotifyNewRetirementTimestamp(timestamp);
-	return cmd;
-}
-
 LatteCMDPtr LatteCP_itHLEBeginOcclusionQuery(LatteCMDPtr cmd, uint32 nWords)
 {
 	cemu_assert_debug(nWords == 1);
@@ -820,8 +859,8 @@ LatteCMDPtr LatteCP_itHLEClearColorDepthStencil(LatteCMDPtr cmd, uint32 nWords)
 	cemu_assert_debug(nWords == 23);
 	uint32 clearMask = LatteReadCMD(); // color (1), depth (2), stencil (4)
 	// color buffer
-	MPTR colorBufferMPTR = LatteReadCMD(); // MPTR for color buffer (physical address)
-	MPTR colorBufferFormat = LatteReadCMD(); // format for color buffer
+	MPTR colorBufferMPTR = LatteReadCMD(); // physical address for color buffer
+	Latte::E_GX2SURFFMT colorBufferFormat = (Latte::E_GX2SURFFMT)LatteReadCMD();
 	Latte::E_HWTILEMODE colorBufferTilemode = (Latte::E_HWTILEMODE)LatteReadCMD();
 	uint32 colorBufferWidth = LatteReadCMD();
 	uint32 colorBufferHeight = LatteReadCMD();
@@ -829,8 +868,8 @@ LatteCMDPtr LatteCP_itHLEClearColorDepthStencil(LatteCMDPtr cmd, uint32 nWords)
 	uint32 colorBufferViewFirstSlice = LatteReadCMD();
 	uint32 colorBufferViewNumSlice = LatteReadCMD();
 	// depth buffer
-	MPTR depthBufferMPTR = LatteReadCMD(); // MPTR for depth buffer (physical address)
-	MPTR depthBufferFormat = LatteReadCMD(); // format for depth buffer
+	MPTR depthBufferMPTR = LatteReadCMD(); // physical address for depth buffer
+	Latte::E_GX2SURFFMT depthBufferFormat = (Latte::E_GX2SURFFMT)LatteReadCMD();
 	Latte::E_HWTILEMODE depthBufferTileMode = (Latte::E_HWTILEMODE)LatteReadCMD();
 	uint32 depthBufferWidth = LatteReadCMD();
 	uint32 depthBufferHeight = LatteReadCMD();
@@ -849,8 +888,8 @@ LatteCMDPtr LatteCP_itHLEClearColorDepthStencil(LatteCMDPtr cmd, uint32 nWords)
 
 	LatteRenderTarget_itHLEClearColorDepthStencil(
 		clearMask, 
-		colorBufferMPTR, colorBufferFormat, colorBufferTilemode, colorBufferWidth, colorBufferHeight, colorBufferPitch, colorBufferViewFirstSlice, colorBufferViewNumSlice, 
-		depthBufferMPTR, depthBufferFormat, depthBufferTileMode, depthBufferWidth, depthBufferHeight, depthBufferPitch, depthBufferViewFirstSlice, depthBufferViewNumSlice, 
+		colorBufferMPTR, colorBufferFormat, colorBufferTilemode, colorBufferWidth, colorBufferHeight, colorBufferPitch, colorBufferViewFirstSlice, colorBufferViewNumSlice,
+		depthBufferMPTR, depthBufferFormat, depthBufferTileMode, depthBufferWidth, depthBufferHeight, depthBufferPitch, depthBufferViewFirstSlice, depthBufferViewNumSlice,
 		r, g, b, a,
 		clearDepth, clearStencil);
 	return cmd;
@@ -931,431 +970,411 @@ void LatteCP_dumpCommandBufferError(LatteCMDPtr cmdStart, LatteCMDPtr cmdEnd, La
 }
 
 // any drawcalls issued without changing textures, framebuffers, shader or other complex states can be done quickly without having to reinitialize the entire pipeline state
-// we implement this optimization by having an optimized version of LatteCP_processCommandBuffer, called right after drawcalls, which only implements commands that dont interfere with fast drawing. Other commands will cause this function to return to the complex parser
-LatteCMDPtr LatteCP_processCommandBuffer_continuousDrawPass(LatteCMDPtr cmd, LatteCMDPtr cmdStart, LatteCMDPtr cmdEnd, DrawPassContext& drawPassCtx)
+// we implement this optimization by having a specialized version of LatteCP_processCommandBuffer, called right after drawcalls, which only implements commands that dont interfere with fast drawing. Other commands will cause this function to return to the complex and generic parser
+void LatteCP_processCommandBuffer_continuousDrawPass(DrawPassContext& drawPassCtx)
 {
 	cemu_assert_debug(drawPassCtx.isWithinDrawPass());
 	// quit early if there are parameters set which are generally incompatible with fast drawing
 	if (LatteGPUState.contextRegister[mmVGT_STRMOUT_EN] != 0)
 	{
 		drawPassCtx.endDrawPass();
-		return cmd;
+		return;
 	}
 	// check for other special states?
 
-	while (cmd < cmdEnd)
+	while (true)
 	{
-		LatteCMDPtr cmdBeforeCommand = cmd;
-		uint32 itHeader = LatteReadCMD();
-		uint32 itHeaderType = (itHeader >> 30) & 3;
-		if (itHeaderType == 3)
+		LatteCMDPtr cmd, cmdStart, cmdEnd;
+		if (!drawPassCtx.PopCurrentCommandQueuePos(cmd, cmdStart, cmdEnd))
 		{
-			uint32 itCode = (itHeader >> 8) & 0xFF;
-			uint32 nWords = ((itHeader >> 16) & 0x3FFF) + 1;
-			switch (itCode)
-			{
-			case IT_SET_RESOURCE: // attribute buffers, uniform buffers or texture units
-			{
-				cmd = LatteCP_itSetRegistersGeneric<LATTE_REG_BASE_RESOURCE>(cmd, nWords, [&drawPassCtx](uint32 registerStart, uint32 registerEnd)
-				{
-					if (registerStart >= Latte::REGADDR::SQ_TEX_RESOURCE_WORD_FIRST && registerStart <= Latte::REGADDR::SQ_TEX_RESOURCE_WORD_LAST)
-						drawPassCtx.endDrawPass(); // texture updates end the current draw sequence
-					else if (registerStart >= mmSQ_VTX_ATTRIBUTE_BLOCK_START && registerEnd <= mmSQ_VTX_ATTRIBUTE_BLOCK_END)
-						drawPassCtx.notifyModifiedVertexBuffer();
-					else
-						drawPassCtx.notifyModifiedUniformBuffer();
-				});
-				if (!drawPassCtx.isWithinDrawPass())
-					return cmd;
-				break;
-			}
-			case IT_SET_ALU_CONST: // uniform register
-			{
-				cmd = LatteCP_itSetRegistersGeneric<LATTE_REG_BASE_ALU_CONST>(cmd, nWords);
-				break;
-			}
-			case IT_SET_CTL_CONST:
-			{
-				cmd = LatteCP_itSetRegistersGeneric<mmSQ_VTX_BASE_VTX_LOC>(cmd, nWords);
-				break;
-			}
-			case IT_SET_CONFIG_REG:
-			{
-				cmd = LatteCP_itSetRegistersGeneric<LATTE_REG_BASE_CONFIG>(cmd, nWords);
-				break;
-			}
-			case IT_INDEX_TYPE:
-			{
-				cmd = LatteCP_itIndexType(cmd, nWords);
-				break;
-			}
-			case IT_NUM_INSTANCES:
-			{
-				cmd = LatteCP_itNumInstances(cmd, nWords);
-				break;
-			}
-			case IT_DRAW_INDEX_2:
-			{
-#ifdef FAST_DRAW_LOGGING
-				if(GetAsyncKeyState('A'))
-					forceLogRemoveMe_printf("Minimal draw");
-#endif
-				cmd = LatteCP_itDrawIndex2(cmd, nWords, drawPassCtx);
-				break;
-			}
-			case IT_SET_CONTEXT_REG:
-			{
-#ifdef FAST_DRAW_LOGGING
-				if (GetAsyncKeyState('A'))
-					forceLogRemoveMe_printf("[FAST-DRAW] Quit due to command IT_SET_CONTEXT_REG Reg: %04x", (uint32)cmd[0] + 0xA000);
-#endif
-				drawPassCtx.endDrawPass();
-				return cmdBeforeCommand;
-			}
-			case IT_INDIRECT_BUFFER_PRIV:
-			{
-				cmd = LatteCP_itIndirectBuffer(cmd, nWords, drawPassCtx);
-				if (!drawPassCtx.isWithinDrawPass())
-					return cmd;
-				break;
-			}
-			default:
-#ifdef FAST_DRAW_LOGGING
-				if (GetAsyncKeyState('A'))
-					forceLogRemoveMe_printf("[FAST-DRAW] Quit due to command itCode 0x%02x", itCode);
-#endif
-				drawPassCtx.endDrawPass();
-				return cmdBeforeCommand;
-			}
-		}
-		else if (itHeaderType == 2)
-		{
-			// filler packet
-		}
-		else
-		{
-#ifdef FAST_DRAW_LOGGING
-			if (GetAsyncKeyState('A'))
-				forceLogRemoveMe_printf("[FAST-DRAW] Quit due to unsupported headerType 0x%02x", itHeaderType);
-#endif
 			drawPassCtx.endDrawPass();
-			return cmdBeforeCommand;
-		}
-	}
-	cemu_assert_debug(drawPassCtx.isWithinDrawPass());
-	return cmd;
-}
-
-void LatteCP_processCommandBuffer(uint8* cmdBuffer, sint32 cmdSize, DrawPassContext& drawPassCtx)
-{
-	LatteCMDPtr cmd = (LatteCMDPtr)cmdBuffer;
-	LatteCMDPtr cmdStart = (LatteCMDPtr)cmdBuffer;
-	LatteCMDPtr cmdEnd = (LatteCMDPtr)(cmdBuffer + cmdSize);
-
-	if (drawPassCtx.isWithinDrawPass())
-	{
-		cmd = LatteCP_processCommandBuffer_continuousDrawPass(cmd, cmdStart, cmdEnd, drawPassCtx);
-		cemu_assert_debug(cmd <= cmdEnd);
-		if (cmd == cmdEnd)
 			return;
-		cemu_assert_debug(!drawPassCtx.isWithinDrawPass());
-	}
+		}
 
-	while (cmd < cmdEnd)
-	{
-		uint32 itHeader = LatteReadCMD();
-		uint32 itHeaderType = (itHeader >> 30) & 3;
-		if (itHeaderType == 3)
+		while (cmd < cmdEnd)
 		{
-			uint32 itCode = (itHeader >> 8) & 0xFF;
-			uint32 nWords = ((itHeader >> 16) & 0x3FFF) + 1;
-#ifndef PUBLIC_RELEASE
-			LatteCMDPtr expectedPostCmd = cmd + nWords;
-#endif
-			switch (itCode)
+			LatteCMDPtr cmdBeforeCommand = cmd;
+			uint32 itHeader = LatteReadCMD();
+			uint32 itHeaderType = (itHeader >> 30) & 3;
+			if (itHeaderType == 3)
 			{
-			case IT_SET_CONTEXT_REG:
-			{
-				cmd = LatteCP_itSetRegistersGeneric<LATTE_REG_BASE_CONTEXT>(cmd, nWords);
-			}
-			break;
-			case IT_SET_RESOURCE:
-			{
-				cmd = LatteCP_itSetRegistersGeneric<LATTE_REG_BASE_RESOURCE>(cmd, nWords);
-			}
-			break;
-			case IT_SET_ALU_CONST:
-			{
-				cmd = LatteCP_itSetRegistersGeneric<LATTE_REG_BASE_ALU_CONST>(cmd, nWords);
-			}
-			break;
-			case IT_SET_CTL_CONST:
-			{
-				cmd = LatteCP_itSetRegistersGeneric<mmSQ_VTX_BASE_VTX_LOC>(cmd, nWords);
-			}
-			break;
-			case IT_SET_SAMPLER:
-			{
-				cmd = LatteCP_itSetRegistersGeneric<LATTE_REG_BASE_SAMPLER>(cmd, nWords);
-			}
-			break;
-			case IT_SET_CONFIG_REG:
-			{
-				cmd = LatteCP_itSetRegistersGeneric<LATTE_REG_BASE_CONFIG>(cmd, nWords);
-			}
-			break;
-			case IT_SET_LOOP_CONST:
-			{
-				LatteSkipCMD(nWords);
-				// todo
-			}
-			break;
-			case IT_SURFACE_SYNC:
-			{
-				cmd = LatteCP_itSurfaceSync(cmd);
-			}
-			break;
-			case IT_INDIRECT_BUFFER_PRIV:
-			{
-				cmd = LatteCP_itIndirectBuffer(cmd, nWords, drawPassCtx);
-				if (drawPassCtx.isWithinDrawPass())
+				uint32 itCode = (itHeader >> 8) & 0xFF;
+				uint32 nWords = ((itHeader >> 16) & 0x3FFF) + 1;
+				LatteCMDPtr cmdData = cmd;
+				cmd += nWords;
+				switch (itCode)
 				{
-					cmd = LatteCP_processCommandBuffer_continuousDrawPass(cmd, cmdStart, cmdEnd, drawPassCtx);
-					cemu_assert_debug(cmd <= cmdEnd);
-					if (cmd == cmdEnd)
+				case IT_SET_RESOURCE: // attribute buffers, uniform buffers or texture units
+				{
+					LatteCP_itSetRegistersGeneric<LATTE_REG_BASE_RESOURCE>(cmdData, nWords, [&drawPassCtx](uint32 registerStart, uint32 registerEnd)
+						{
+							if ((registerStart >= Latte::REGADDR::SQ_TEX_RESOURCE_WORD0_N_PS && registerStart < (Latte::REGADDR::SQ_TEX_RESOURCE_WORD0_N_PS + Latte::GPU_LIMITS::NUM_TEXTURES_PER_STAGE * 7)) ||
+								(registerStart >= Latte::REGADDR::SQ_TEX_RESOURCE_WORD0_N_VS && registerStart < (Latte::REGADDR::SQ_TEX_RESOURCE_WORD0_N_VS + Latte::GPU_LIMITS::NUM_TEXTURES_PER_STAGE * 7)) ||
+								(registerStart >= Latte::REGADDR::SQ_TEX_RESOURCE_WORD0_N_GS && registerStart < (Latte::REGADDR::SQ_TEX_RESOURCE_WORD0_N_GS + Latte::GPU_LIMITS::NUM_TEXTURES_PER_STAGE * 7)))
+								drawPassCtx.endDrawPass(); // texture updates end the current draw sequence
+							else if (registerStart >= mmSQ_VTX_ATTRIBUTE_BLOCK_START && registerEnd <= mmSQ_VTX_ATTRIBUTE_BLOCK_END)
+								drawPassCtx.notifyModifiedVertexBuffer();
+							else
+								drawPassCtx.notifyModifiedUniformBuffer();
+						});
+					if (!drawPassCtx.isWithinDrawPass())
+					{
+						drawPassCtx.PushCurrentCommandQueuePos(cmd, cmdStart, cmdEnd);
 						return;
-					cemu_assert_debug(!drawPassCtx.isWithinDrawPass());
+					}
+					break;
+				}
+				case IT_SET_ALU_CONST: // uniform register
+				{
+					LatteCP_itSetRegistersGeneric<LATTE_REG_BASE_ALU_CONST>(cmdData, nWords);
+					break;
+				}
+				case IT_SET_CTL_CONST:
+				{
+					LatteCP_itSetRegistersGeneric<mmSQ_VTX_BASE_VTX_LOC>(cmdData, nWords);
+					break;
+				}
+				case IT_SET_CONFIG_REG:
+				{
+					LatteCP_itSetRegistersGeneric<LATTE_REG_BASE_CONFIG>(cmdData, nWords);
+					break;
+				}
+				case IT_INDEX_TYPE:
+				{
+					LatteCP_itIndexType(cmdData, nWords);
+					break;
+				}
+				case IT_NUM_INSTANCES:
+				{
+					LatteCP_itNumInstances(cmdData, nWords);
+					break;
+				}
+				case IT_DRAW_INDEX_2:
+				{
+					LatteCP_itDrawIndex2(cmdData, nWords, drawPassCtx);
+					break;
+				}
+				case IT_SET_CONTEXT_REG:
+				{
+					drawPassCtx.endDrawPass();
+					drawPassCtx.PushCurrentCommandQueuePos(cmdBeforeCommand, cmdStart, cmdEnd);
+					return;
+				}
+				case IT_INDIRECT_BUFFER_PRIV:
+				{
+					drawPassCtx.PushCurrentCommandQueuePos(cmd, cmdStart, cmdEnd);
+					LatteCP_itIndirectBuffer(cmdData, nWords, drawPassCtx);
+					if (!drawPassCtx.PopCurrentCommandQueuePos(cmd, cmdStart, cmdEnd)) // switch to sub buffer
+						cemu_assert_debug(false);
+
+					//if (!drawPassCtx.isWithinDrawPass())
+					//	return cmdData;
+					break;
+				}
+				default:
+					// unsupported command for fast draw
+					drawPassCtx.endDrawPass();
+					drawPassCtx.PushCurrentCommandQueuePos(cmdBeforeCommand, cmdStart, cmdEnd);
+					return;
 				}
-#ifndef PUBLIC_RELEASE
-				expectedPostCmd = cmd;
-#endif
 			}
-			break;
-			case IT_STRMOUT_BUFFER_UPDATE:
+			else if (itHeaderType == 2)
 			{
-				cmd = LatteCP_itStreamoutBufferUpdate(cmd, nWords);
-			}
-			break;
-			case IT_INDEX_TYPE:
-			{
-				cmd = LatteCP_itIndexType(cmd, nWords);
-			}
-			break;
-			case IT_NUM_INSTANCES:
-			{
-				cmd = LatteCP_itNumInstances(cmd, nWords);
-			}
-			break;
-			case IT_DRAW_INDEX_2:
-			{
-				drawPassCtx.beginDrawPass();
-#ifdef FAST_DRAW_LOGGING
-				if (GetAsyncKeyState('A'))
-					forceLogRemoveMe_printf("[FAST-DRAW] Starting");
-#endif
-				cmd = LatteCP_itDrawIndex2(cmd, nWords, drawPassCtx);
-				cmd = LatteCP_processCommandBuffer_continuousDrawPass(cmd, cmdStart, cmdEnd, drawPassCtx);
-				cemu_assert_debug(cmd == cmdEnd || drawPassCtx.isWithinDrawPass() == false); // draw sequence should have ended if we didn't reach the end of the command buffer
-#ifndef PUBLIC_RELEASE
-				expectedPostCmd = cmd;
-#endif
-			}
-			break;
-			case IT_DRAW_INDEX_AUTO:
-			{
-				drawPassCtx.beginDrawPass();
-				cmd = LatteCP_itDrawIndexAuto(cmd, nWords, drawPassCtx);
-				cmd = LatteCP_processCommandBuffer_continuousDrawPass(cmd, cmdStart, cmdEnd, drawPassCtx);
-				cemu_assert_debug(cmd == cmdEnd || drawPassCtx.isWithinDrawPass() == false); // draw sequence should have ended if we didn't reach the end of the command buffer
-#ifndef PUBLIC_RELEASE
-				expectedPostCmd = cmd;
-#endif
-#ifdef FAST_DRAW_LOGGING
-				if (GetAsyncKeyState('A'))
-					forceLogRemoveMe_printf("[FAST-DRAW] Auto-draw");
-#endif
-			}
-			break;
-			case IT_DRAW_INDEX_IMMD:
-			{
-				DrawPassContext drawPassCtx;
-				drawPassCtx.beginDrawPass();
-				cmd = LatteCP_itDrawImmediate(cmd, nWords, drawPassCtx);
-				drawPassCtx.endDrawPass();
-				break;
-			}
-			case IT_WAIT_REG_MEM:
-			{
-				cmd = LatteCP_itWaitRegMem(cmd, nWords);
-				LatteTiming_HandleTimedVsync();
-				LatteAsyncCommands_checkAndExecute();
-			}
-			break;
-			case IT_MEM_WRITE:
-			{
-				cmd = LatteCP_itMemWrite(cmd, nWords);
-			}
-			break;
-			case IT_CONTEXT_CONTROL:
-			{
-				cmd = LatteCP_itContextControl(cmd, nWords);
-			}
-			break;
-			case IT_MEM_SEMAPHORE:
-			{
-				cmd = LatteCP_itMemSemaphore(cmd, nWords);
-			}
-			break;
-			case IT_LOAD_CONFIG_REG:
-			{
-				cmd = LatteCP_itLoadReg(cmd, nWords, LATTE_REG_BASE_CONFIG);
-			}
-			break;
-			case IT_LOAD_CONTEXT_REG:
-			{
-				cmd = LatteCP_itLoadReg(cmd, nWords, LATTE_REG_BASE_CONTEXT);
-			}
-			break;
-			case IT_LOAD_ALU_CONST:
-			{
-				cmd = LatteCP_itLoadReg(cmd, nWords, LATTE_REG_BASE_ALU_CONST);
-			}
-			break;
-			case IT_LOAD_LOOP_CONST:
-			{
-				cmd = LatteCP_itLoadReg(cmd, nWords, LATTE_REG_BASE_LOOP_CONST);
-			}
-			break;
-			case IT_LOAD_RESOURCE:
-			{
-				cmd = LatteCP_itLoadReg(cmd, nWords, LATTE_REG_BASE_RESOURCE);
-			}
-			break;
-			case IT_LOAD_SAMPLER:
-			{
-				cmd = LatteCP_itLoadReg(cmd, nWords, LATTE_REG_BASE_SAMPLER);
-			}
-			break;
-			case IT_SET_PREDICATION:
-			{
-				cmd = LatteCP_itSetPredication(cmd, nWords);
-			}
-			break;
-			case IT_HLE_COPY_COLORBUFFER_TO_SCANBUFFER:
-			{
-				cmd = LatteCP_itHLECopyColorBufferToScanBuffer(cmd, nWords);
-			}
-			break;
-			case IT_HLE_TRIGGER_SCANBUFFER_SWAP:
-			{
-				cmd = LatteCP_itHLESwapScanBuffer(cmd, nWords);
-			}
-			break;
-			case IT_HLE_WAIT_FOR_FLIP:
-			{
-				cmd = LatteCP_itHLEWaitForFlip(cmd, nWords);
-			}
-			break;
-			case IT_HLE_REQUEST_SWAP_BUFFERS:
-			{
-				cmd = LatteCP_itHLERequestSwapBuffers(cmd, nWords);
-			}
-			break;
-			case IT_HLE_CLEAR_COLOR_DEPTH_STENCIL:
-			{
-				cmd = LatteCP_itHLEClearColorDepthStencil(cmd, nWords);
-			}
-			break;
-			case IT_HLE_COPY_SURFACE_NEW:
-			{
-				cmd = LatteCP_itHLECopySurfaceNew(cmd, nWords);
-			}
-			break;
-			case IT_HLE_SAMPLE_TIMER:
-			{
-				cmd = LatteCP_itHLESampleTimer(cmd, nWords);
-			}
-			break;
-			case IT_HLE_SPECIAL_STATE:
-			{
-				cmd = LatteCP_itHLESpecialState(cmd, nWords);
-			}
-			break;
-			case IT_HLE_BEGIN_OCCLUSION_QUERY:
-			{
-				cmd = LatteCP_itHLEBeginOcclusionQuery(cmd, nWords);
-			}
-			break;
-			case IT_HLE_END_OCCLUSION_QUERY:
-			{
-				cmd = LatteCP_itHLEEndOcclusionQuery(cmd, nWords);
-			}
-			break;
-			case IT_HLE_SET_CB_RETIREMENT_TIMESTAMP:
-			{
-				cmd = LatteCP_itHLESetRetirementTimestamp(cmd, nWords);
-			}
-			break;
-			case IT_HLE_BOTTOM_OF_PIPE_CB:
-			{
-				cmd = LatteCP_itHLEBottomOfPipeCB(cmd, nWords);
-			}
-			break;
-			case IT_HLE_SYNC_ASYNC_OPERATIONS:
-			{
-				LatteSkipCMD(nWords);
-				LatteTextureReadback_UpdateFinishedTransfers(true);
-				LatteQuery_UpdateFinishedQueriesForceFinishAll();
-			}
-			break;
-			default:
-				debug_printf("Unhandled IT %02x\n", itCode);
-				cemu_assert_debug(false);
-				LatteSkipCMD(nWords);	
-			}
-#ifndef PUBLIC_RELEASE
-			if(cmd != expectedPostCmd)
-				debug_printf("cmd %016p expectedPostCmd %016p\n", cmd, expectedPostCmd);
-			cemu_assert_debug(cmd == expectedPostCmd);
-#endif
-		}
-		else if (itHeaderType == 2)
-		{
-			// filler packet
-			// has no body
-		}
-		else if (itHeaderType == 0)
-		{
-			uint32 registerBase = (itHeader & 0xFFFF);
-			uint32 registerCount = ((itHeader >> 16) & 0x3FFF) + 1;
-			if (registerBase == 0x304A)
-			{
-				GX2::__GX2NotifyEvent(GX2::GX2CallbackEventType::TIMESTAMP_TOP);
-				LatteSkipCMD(registerCount);
-			}
-			else if (registerBase == 0x304B)
-			{
-				LatteSkipCMD(registerCount);
+				// filler packet
 			}
 			else
 			{
+				// unsupported command for fast draw
+				drawPassCtx.endDrawPass();
+				drawPassCtx.PushCurrentCommandQueuePos(cmdBeforeCommand, cmdStart, cmdEnd);
+				return;
+			}
+		}
+	}
+	if (drawPassCtx.isWithinDrawPass())
+		drawPassCtx.endDrawPass();
+}
+
+void LatteCP_processCommandBuffer(DrawPassContext& drawPassCtx)
+{
+	while (true)
+	{
+		LatteCMDPtr cmd, cmdStart, cmdEnd;
+		if (!drawPassCtx.PopCurrentCommandQueuePos(cmd, cmdStart, cmdEnd))
+			break;
+		uint32 itHeader;
+		while (cmd < cmdEnd)
+		{
+			itHeader = LatteReadCMD();
+			uint32 itHeaderType = (itHeader >> 30) & 3;
+			if (itHeaderType == 3)
+			{
+				uint32 itCode = (itHeader >> 8) & 0xFF;
+				uint32 nWords = ((itHeader >> 16) & 0x3FFF) + 1;
+				LatteCMDPtr cmdData = cmd;
+				cmd += nWords;
+				switch (itCode)
+				{
+				case IT_SET_CONTEXT_REG:
+				{
+					LatteCP_itSetRegistersGeneric<LATTE_REG_BASE_CONTEXT>(cmdData, nWords);
+				}
+				break;
+				case IT_SET_RESOURCE:
+				{
+					LatteCP_itSetRegistersGeneric<LATTE_REG_BASE_RESOURCE>(cmdData, nWords);
+				}
+				break;
+				case IT_SET_ALU_CONST:
+				{
+					LatteCP_itSetRegistersGeneric<LATTE_REG_BASE_ALU_CONST>(cmdData, nWords);
+				}
+				break;
+				case IT_SET_CTL_CONST:
+				{
+					LatteCP_itSetRegistersGeneric<mmSQ_VTX_BASE_VTX_LOC>(cmdData, nWords);
+				}
+				break;
+				case IT_SET_SAMPLER:
+				{
+					LatteCP_itSetRegistersGeneric<LATTE_REG_BASE_SAMPLER>(cmdData, nWords);
+				}
+				break;
+				case IT_SET_CONFIG_REG:
+				{
+					LatteCP_itSetRegistersGeneric<LATTE_REG_BASE_CONFIG>(cmdData, nWords);
+				}
+				break;
+				case IT_SET_LOOP_CONST:
+				{
+					// todo
+				}
+				break;
+				case IT_SURFACE_SYNC:
+				{
+					LatteCP_itSurfaceSync(cmdData);
+				}
+				break;
+				case IT_INDIRECT_BUFFER_PRIV:
+				{
+					drawPassCtx.PushCurrentCommandQueuePos(cmd, cmdStart, cmdEnd);
+					LatteCP_itIndirectBuffer(cmdData, nWords, drawPassCtx);
+					if (!drawPassCtx.PopCurrentCommandQueuePos(cmd, cmdStart, cmdEnd)) // switch to sub buffer
+						cemu_assert_debug(false);
+				}
+				break;
+				case IT_STRMOUT_BUFFER_UPDATE:
+				{
+					LatteCP_itStreamoutBufferUpdate(cmdData, nWords);
+				}
+				break;
+				case IT_INDEX_TYPE:
+				{
+					LatteCP_itIndexType(cmdData, nWords);
+				}
+				break;
+				case IT_NUM_INSTANCES:
+				{
+					LatteCP_itNumInstances(cmdData, nWords);
+				}
+				break;
+				case IT_DRAW_INDEX_2:
+				{
+					drawPassCtx.beginDrawPass();
+					LatteCP_itDrawIndex2(cmdData, nWords, drawPassCtx);
+					// enter fast draw mode
+					drawPassCtx.PushCurrentCommandQueuePos(cmd, cmdStart, cmdEnd);
+					LatteCP_processCommandBuffer_continuousDrawPass(drawPassCtx);
+					cemu_assert_debug(!drawPassCtx.isWithinDrawPass());
+					if (!drawPassCtx.PopCurrentCommandQueuePos(cmd, cmdStart, cmdEnd))
+						return;
+				}
+				break;
+				case IT_DRAW_INDEX_AUTO:
+				{
+					drawPassCtx.beginDrawPass();
+					LatteCP_itDrawIndexAuto(cmdData, nWords, drawPassCtx);
+					// enter fast draw mode
+					drawPassCtx.PushCurrentCommandQueuePos(cmd, cmdStart, cmdEnd);
+					LatteCP_processCommandBuffer_continuousDrawPass(drawPassCtx);
+					cemu_assert_debug(!drawPassCtx.isWithinDrawPass());
+					if (!drawPassCtx.PopCurrentCommandQueuePos(cmd, cmdStart, cmdEnd))
+						return;
+				}
+				break;
+				case IT_DRAW_INDEX_IMMD:
+				{
+					DrawPassContext drawPassCtx;
+					drawPassCtx.beginDrawPass();
+					LatteCP_itDrawImmediate(cmdData, nWords, drawPassCtx);
+					drawPassCtx.endDrawPass();
+					break;
+				}
+				case IT_WAIT_REG_MEM:
+				{
+					LatteCP_itWaitRegMem(cmdData, nWords);
+					LatteTiming_HandleTimedVsync();
+					LatteAsyncCommands_checkAndExecute();
+					break;
+				}
+				case IT_MEM_WRITE:
+				{
+					LatteCP_itMemWrite(cmdData, nWords);
+					break;
+				}
+				case IT_CONTEXT_CONTROL:
+				{
+					LatteCP_itContextControl(cmdData, nWords);
+					break;
+				}
+				case IT_MEM_SEMAPHORE:
+				{
+					LatteCP_itMemSemaphore(cmdData, nWords);
+					break;
+				}
+				case IT_LOAD_CONFIG_REG:
+				{
+					LatteCP_itLoadReg(cmdData, nWords, LATTE_REG_BASE_CONFIG);
+					break;
+				}
+				case IT_LOAD_CONTEXT_REG:
+				{
+					LatteCP_itLoadReg(cmdData, nWords, LATTE_REG_BASE_CONTEXT);
+					break;
+				}
+				case IT_LOAD_ALU_CONST:
+				{
+					LatteCP_itLoadReg(cmdData, nWords, LATTE_REG_BASE_ALU_CONST);
+					break;
+				}
+				case IT_LOAD_LOOP_CONST:
+				{
+					LatteCP_itLoadReg(cmdData, nWords, LATTE_REG_BASE_LOOP_CONST);
+					break;
+				}
+				case IT_LOAD_RESOURCE:
+				{
+					LatteCP_itLoadReg(cmdData, nWords, LATTE_REG_BASE_RESOURCE);
+					break;
+				}
+				case IT_LOAD_SAMPLER:
+				{
+					LatteCP_itLoadReg(cmdData, nWords, LATTE_REG_BASE_SAMPLER);
+					break;
+				}
+				case IT_SET_PREDICATION:
+				{
+					LatteCP_itSetPredication(cmdData, nWords);
+					break;
+				}
+				case IT_HLE_COPY_COLORBUFFER_TO_SCANBUFFER:
+				{
+					LatteCP_itHLECopyColorBufferToScanBuffer(cmdData, nWords);
+					break;
+				}
+				case IT_HLE_TRIGGER_SCANBUFFER_SWAP:
+				{
+					LatteCP_signalEnterWait();
+					LatteCP_itHLESwapScanBuffer(cmdData, nWords);
+					break;
+				}
+				case IT_HLE_WAIT_FOR_FLIP:
+				{
+					LatteCP_signalEnterWait();
+					LatteCP_itHLEWaitForFlip(cmdData, nWords);
+					break;
+				}
+				case IT_HLE_REQUEST_SWAP_BUFFERS:
+				{
+					LatteCP_itHLERequestSwapBuffers(cmdData, nWords);
+					break;
+				}
+				case IT_HLE_CLEAR_COLOR_DEPTH_STENCIL:
+				{
+					LatteCP_itHLEClearColorDepthStencil(cmdData, nWords);
+					break;
+				}
+				case IT_HLE_COPY_SURFACE_NEW:
+				{
+					LatteCP_itHLECopySurfaceNew(cmdData, nWords);
+					break;
+				}
+				case IT_HLE_SAMPLE_TIMER:
+				{
+					LatteCP_itHLESampleTimer(cmdData, nWords);
+					break;
+				}
+				case IT_HLE_SPECIAL_STATE:
+				{
+					LatteCP_itHLESpecialState(cmdData, nWords);
+					break;
+				}
+				case IT_HLE_BEGIN_OCCLUSION_QUERY:
+				{
+					LatteCP_itHLEBeginOcclusionQuery(cmdData, nWords);
+					break;
+				}
+				case IT_HLE_END_OCCLUSION_QUERY:
+				{
+					LatteCP_itHLEEndOcclusionQuery(cmdData, nWords);
+					break;
+				}
+				case IT_HLE_BOTTOM_OF_PIPE_CB:
+				{
+					LatteCP_itHLEBottomOfPipeCB(cmdData, nWords);
+					break;
+				}
+				case IT_HLE_SYNC_ASYNC_OPERATIONS:
+				{
+					LatteTextureReadback_UpdateFinishedTransfers(true);
+					LatteQuery_UpdateFinishedQueriesForceFinishAll();
+					break;
+				}
+				default:
+					debug_printf("Unhandled IT %02x\n", itCode);
+					cemu_assert_debug(false);
+					break;
+				}
+			}
+			else if (itHeaderType == 2)
+			{
+				// filler packet
+				// has no body
+			}
+			else if (itHeaderType == 0)
+			{
+				uint32 registerBase = (itHeader & 0xFFFF);
+				uint32 registerCount = ((itHeader >> 16) & 0x3FFF) + 1;
+				if (registerBase == 0x304A)
+				{
+					GX2::__GX2NotifyEvent(GX2::GX2CallbackEventType::TIMESTAMP_TOP);
+					LatteSkipCMD(registerCount);
+				}
+				else if (registerBase == 0x304B)
+				{
+					LatteSkipCMD(registerCount);
+				}
+				else
+				{
+					LatteCP_dumpCommandBufferError(cmdStart, cmdEnd, cmd);
+					cemu_assert_debug(false);
+				}
+			}
+			else
+			{
+				debug_printf("invalid itHeaderType %08x\n", itHeaderType);
 				LatteCP_dumpCommandBufferError(cmdStart, cmdEnd, cmd);
 				cemu_assert_debug(false);
 			}
 		}
-		else
-		{
-			debug_printf("invalid itHeaderType %08x\n", itHeaderType);
-			LatteCP_dumpCommandBufferError(cmdStart, cmdEnd, cmd);
-			cemu_assert_debug(false);
-		}
+		cemu_assert_debug(cmd == cmdEnd);
 	}
-	cemu_assert_debug(cmd == cmdEnd);
 }
 
 void LatteCP_ProcessRingbuffer()
 {
-	sint32 timerRecheck = 0; // estimates how much CP processing time passed based on the executed commands, if the value exceeds CP_TIMER_RECHECK then _handleTimers() is called
+	sint32 timerRecheck = 0; // estimates how much CP processing time has elapsed based on the executed commands, if the value exceeds CP_TIMER_RECHECK then _handleTimers() is called
+	uint32be tmpBuffer[128];
 	while (true)
 	{
 		uint32 itHeader = LatteCP_readU32Deprc();
@@ -1364,82 +1383,78 @@ void LatteCP_ProcessRingbuffer()
 		{
 			uint32 itCode = (itHeader >> 8) & 0xFF;
 			uint32 nWords = ((itHeader >> 16) & 0x3FFF) + 1;
-			LatteCP_waitForNWords(nWords);
-			LatteCMDPtr cmd = (LatteCMDPtr)gxRingBufferReadPtr;
-			uint8* expectedGxRingBufferReadPtr = gxRingBufferReadPtr + nWords*4;
+			cemu_assert(nWords < 128);
+			for (sint32 i=0; i<nWords; i++)
+			{
+				uint32 word = LatteCP_readU32Deprc();
+				tmpBuffer[i] = word;
+			}
+			LatteCMDPtr cmd = (LatteCMDPtr)tmpBuffer;
 			switch (itCode)
 			{
 			case IT_SURFACE_SYNC:
 			{
-				gxRingBufferReadPtr = (uint8*)LatteCP_itSurfaceSync(cmd);
+				LatteCP_itSurfaceSync(cmd);
 				timerRecheck += CP_TIMER_RECHECK / 512;
 			}
 			break;
 			case IT_SET_CONTEXT_REG:
 			{
-				gxRingBufferReadPtr = (uint8*)LatteCP_itSetRegistersGeneric<LATTE_REG_BASE_CONTEXT>(cmd, nWords);
+				LatteCP_itSetRegistersGeneric<LATTE_REG_BASE_CONTEXT>(cmd, nWords);
 				timerRecheck += CP_TIMER_RECHECK / 512;
 			}
 			break;
 			case IT_SET_RESOURCE:
 			{
-				gxRingBufferReadPtr = (uint8*)LatteCP_itSetRegistersGeneric<LATTE_REG_BASE_RESOURCE>(cmd, nWords);
+				LatteCP_itSetRegistersGeneric<LATTE_REG_BASE_RESOURCE>(cmd, nWords);
 				timerRecheck += CP_TIMER_RECHECK / 512;
 			}
 			break;
 			case IT_SET_ALU_CONST:
 			{
-				gxRingBufferReadPtr = (uint8*)LatteCP_itSetRegistersGeneric<LATTE_REG_BASE_ALU_CONST>(cmd, nWords);
+				LatteCP_itSetRegistersGeneric<LATTE_REG_BASE_ALU_CONST>(cmd, nWords);
 				timerRecheck += CP_TIMER_RECHECK / 512;
 				break;
 			}
 			case IT_SET_CTL_CONST:
 			{
-				gxRingBufferReadPtr = (uint8*)LatteCP_itSetRegistersGeneric<mmSQ_VTX_BASE_VTX_LOC>(cmd, nWords);
+				LatteCP_itSetRegistersGeneric<mmSQ_VTX_BASE_VTX_LOC>(cmd, nWords);
 				timerRecheck += CP_TIMER_RECHECK / 512;
 				break;
 			}
 			case IT_SET_SAMPLER:
 			{
-				gxRingBufferReadPtr = (uint8*)LatteCP_itSetRegistersGeneric<LATTE_REG_BASE_SAMPLER>(cmd, nWords);
+				LatteCP_itSetRegistersGeneric<LATTE_REG_BASE_SAMPLER>(cmd, nWords);
 				timerRecheck += CP_TIMER_RECHECK / 512;
 				break;
 			}
 			case IT_SET_CONFIG_REG:
 			{
-				gxRingBufferReadPtr = (uint8*)LatteCP_itSetRegistersGeneric<LATTE_REG_BASE_CONFIG>(cmd, nWords);
+				LatteCP_itSetRegistersGeneric<LATTE_REG_BASE_CONFIG>(cmd, nWords);
 				timerRecheck += CP_TIMER_RECHECK / 512;
 				break;
 			}
 			case IT_INDIRECT_BUFFER_PRIV:
 			{
-#ifdef FAST_DRAW_LOGGING
-				if (GetAsyncKeyState('A'))
-					forceLogRemoveMe_printf("[FAST-DRAW] BEGIN CMD BUFFER");
-#endif
-				LatteCP_itIndirectBufferDepr<LatteCP_readU32Deprc>(nWords);
+				LatteCP_itIndirectBufferDepr(cmd, nWords);
 				timerRecheck += CP_TIMER_RECHECK / 512;
-#ifdef FAST_DRAW_LOGGING
-				if (GetAsyncKeyState('A'))
-					forceLogRemoveMe_printf("[FAST-DRAW] END CMD BUFFER");
-#endif
 				break;
 			}
 			case IT_STRMOUT_BUFFER_UPDATE:
 			{
-				gxRingBufferReadPtr = (uint8*)LatteCP_itStreamoutBufferUpdate(cmd, nWords);
+				LatteCP_itStreamoutBufferUpdate(cmd, nWords);
 				timerRecheck += CP_TIMER_RECHECK / 512;
 				break;
 			}
 			case IT_INDEX_TYPE:
 			{
-				gxRingBufferReadPtr = (uint8*)LatteCP_itIndexType(cmd, nWords);
+				LatteCP_itIndexType(cmd, nWords);
 				timerRecheck += CP_TIMER_RECHECK / 1024;
 				break;
 			}
 			case IT_NUM_INSTANCES:
 			{
-				gxRingBufferReadPtr = (uint8*)LatteCP_itNumInstances(cmd, nWords);
+				LatteCP_itNumInstances(cmd, nWords);
 				timerRecheck += CP_TIMER_RECHECK / 1024;
 				break;
 			}
@@ -1447,7 +1462,7 @@ void LatteCP_ProcessRingbuffer()
 			{
 				DrawPassContext drawPassCtx;
 				drawPassCtx.beginDrawPass();
-				gxRingBufferReadPtr = (uint8*)LatteCP_itDrawIndex2(cmd, nWords, drawPassCtx);
+				LatteCP_itDrawIndex2(cmd, nWords, drawPassCtx);
 				drawPassCtx.endDrawPass();
 				timerRecheck += CP_TIMER_RECHECK / 64;
 				break;
@@ -1456,7 +1471,7 @@ void LatteCP_ProcessRingbuffer()
 			{
 				DrawPassContext drawPassCtx;
 				drawPassCtx.beginDrawPass();
-				gxRingBufferReadPtr = (uint8*)LatteCP_itDrawIndexAuto(cmd, nWords, drawPassCtx);
+				LatteCP_itDrawIndexAuto(cmd, nWords, drawPassCtx);
 				drawPassCtx.endDrawPass();
 				timerRecheck += CP_TIMER_RECHECK / 512;
 				break;
@@ -1465,165 +1480,157 @@ void LatteCP_ProcessRingbuffer()
 			{
 				DrawPassContext drawPassCtx;
 				drawPassCtx.beginDrawPass();
-				gxRingBufferReadPtr = (uint8*)LatteCP_itDrawImmediate(cmd, nWords, drawPassCtx);
+				LatteCP_itDrawImmediate(cmd, nWords, drawPassCtx);
 				drawPassCtx.endDrawPass();
 				timerRecheck += CP_TIMER_RECHECK / 64;
 				break;
 			}
 			case IT_WAIT_REG_MEM:
 			{
-				gxRingBufferReadPtr = (uint8*)LatteCP_itWaitRegMem(cmd, nWords);
+				LatteCP_itWaitRegMem(cmd, nWords);
 				timerRecheck += CP_TIMER_RECHECK / 16;
 				break;
 			}
 			case IT_MEM_WRITE:
 			{
-				gxRingBufferReadPtr = (uint8*)LatteCP_itMemWrite(cmd, nWords);
+				LatteCP_itMemWrite(cmd, nWords);
 				timerRecheck += CP_TIMER_RECHECK / 128;
 				break;
 			}
 			case IT_CONTEXT_CONTROL:
 			{
-				gxRingBufferReadPtr = (uint8*)LatteCP_itContextControl(cmd, nWords);
+				LatteCP_itContextControl(cmd, nWords);
 				timerRecheck += CP_TIMER_RECHECK / 128;
 				break;
 			}
 			case IT_MEM_SEMAPHORE:
 			{
-				gxRingBufferReadPtr = (uint8*)LatteCP_itMemSemaphore(cmd, nWords);
+				LatteCP_itMemSemaphore(cmd, nWords);
 				timerRecheck += CP_TIMER_RECHECK / 128;
 				break;
 			}
 			case IT_LOAD_CONFIG_REG:
 			{
-				gxRingBufferReadPtr = (uint8*)LatteCP_itLoadReg(cmd, nWords, LATTE_REG_BASE_CONFIG);
+				LatteCP_itLoadReg(cmd, nWords, LATTE_REG_BASE_CONFIG);
 				timerRecheck += CP_TIMER_RECHECK / 64;
 				break;
 			}
 			case IT_LOAD_CONTEXT_REG:
 			{
-				gxRingBufferReadPtr = (uint8*)LatteCP_itLoadReg(cmd, nWords, LATTE_REG_BASE_CONTEXT);
+				LatteCP_itLoadReg(cmd, nWords, LATTE_REG_BASE_CONTEXT);
 				timerRecheck += CP_TIMER_RECHECK / 64;
 				break;
 			}
 			case IT_LOAD_ALU_CONST:
 			{
-				gxRingBufferReadPtr = (uint8*)LatteCP_itLoadReg(cmd, nWords, LATTE_REG_BASE_ALU_CONST);
+				LatteCP_itLoadReg(cmd, nWords, LATTE_REG_BASE_ALU_CONST);
 				timerRecheck += CP_TIMER_RECHECK / 64;
 				break;
 			}
 			case IT_LOAD_LOOP_CONST:
 			{
-				gxRingBufferReadPtr = (uint8*)LatteCP_itLoadReg(cmd, nWords, LATTE_REG_BASE_LOOP_CONST);
+				LatteCP_itLoadReg(cmd, nWords, LATTE_REG_BASE_LOOP_CONST);
 				timerRecheck += CP_TIMER_RECHECK / 64;
 				break;
 			}
 			case IT_LOAD_RESOURCE:
 			{
-				gxRingBufferReadPtr = (uint8*)LatteCP_itLoadReg(cmd, nWords, LATTE_REG_BASE_RESOURCE);
+				LatteCP_itLoadReg(cmd, nWords, LATTE_REG_BASE_RESOURCE);
 				timerRecheck += CP_TIMER_RECHECK / 64;
 				break;
 			}
 			case IT_LOAD_SAMPLER:
 			{
-				gxRingBufferReadPtr = (uint8*)LatteCP_itLoadReg(cmd, nWords, LATTE_REG_BASE_SAMPLER);
+				LatteCP_itLoadReg(cmd, nWords, LATTE_REG_BASE_SAMPLER);
 				timerRecheck += CP_TIMER_RECHECK / 64;
 				break;
 			}
 			case IT_SET_LOOP_CONST:
 			{
-				LatteSkipCMD(nWords);
-				gxRingBufferReadPtr = (uint8*)cmd;
 				// todo
 				break;
 			}
 			case IT_SET_PREDICATION:
 			{
-				gxRingBufferReadPtr = (uint8*)LatteCP_itSetPredication(cmd, nWords);
+				LatteCP_itSetPredication(cmd, nWords);
 				timerRecheck += CP_TIMER_RECHECK / 512;
 				break;
 			}
+			case IT_EVENT_WRITE_EOP:
+			{
+				LatteCP_itEventWriteEOP(cmd, nWords);
+				break;
+			}
 			case IT_HLE_COPY_COLORBUFFER_TO_SCANBUFFER:
 			{
-				gxRingBufferReadPtr = (uint8*)LatteCP_itHLECopyColorBufferToScanBuffer(cmd, nWords);
+				LatteCP_itHLECopyColorBufferToScanBuffer(cmd, nWords);
 				timerRecheck += CP_TIMER_RECHECK / 64;
 				break;
 			}
 			case IT_HLE_TRIGGER_SCANBUFFER_SWAP:
 			{
-				gxRingBufferReadPtr = (uint8*)LatteCP_itHLESwapScanBuffer(cmd, nWords);
+				LatteCP_signalEnterWait();
+				LatteCP_itHLESwapScanBuffer(cmd, nWords);
 				timerRecheck += CP_TIMER_RECHECK / 64;
 				break;
 			}
 			case IT_HLE_WAIT_FOR_FLIP:
 			{
-				gxRingBufferReadPtr = (uint8*)LatteCP_itHLEWaitForFlip(cmd, nWords);
+				LatteCP_signalEnterWait();
+				LatteCP_itHLEWaitForFlip(cmd, nWords);
 				timerRecheck += CP_TIMER_RECHECK / 1;
 				break;
 			}
 			case IT_HLE_REQUEST_SWAP_BUFFERS:
 			{
-				gxRingBufferReadPtr = (uint8*)LatteCP_itHLERequestSwapBuffers(cmd, nWords);
+				LatteCP_itHLERequestSwapBuffers(cmd, nWords);
 				timerRecheck += CP_TIMER_RECHECK / 32;
 				break;
 			}
 			case IT_HLE_CLEAR_COLOR_DEPTH_STENCIL:
 			{
-				gxRingBufferReadPtr = (uint8*)LatteCP_itHLEClearColorDepthStencil(cmd, nWords);
+				LatteCP_itHLEClearColorDepthStencil(cmd, nWords);
 				timerRecheck += CP_TIMER_RECHECK / 128;
 				break;
 			}
 			case IT_HLE_COPY_SURFACE_NEW:
 			{
-				gxRingBufferReadPtr = (uint8*)LatteCP_itHLECopySurfaceNew(cmd, nWords);
+				LatteCP_itHLECopySurfaceNew(cmd, nWords);
 				timerRecheck += CP_TIMER_RECHECK / 128;
 				break;
 			}
-			case IT_HLE_FIFO_WRAP_AROUND:
-			{
-				gxRingBufferReadPtr = (uint8*)LatteCP_itHLEFifoWrapAround(cmd, nWords);
-				expectedGxRingBufferReadPtr = gxRingBufferReadPtr;
-				timerRecheck += CP_TIMER_RECHECK / 512;
-				break;
-			}
 			case IT_HLE_SAMPLE_TIMER:
 			{
-				gxRingBufferReadPtr = (uint8*)LatteCP_itHLESampleTimer(cmd, nWords);
+				LatteCP_itHLESampleTimer(cmd, nWords);
 				timerRecheck += CP_TIMER_RECHECK / 512;
 				break;
 			}
 			case IT_HLE_SPECIAL_STATE:
 			{
-				gxRingBufferReadPtr = (uint8*)LatteCP_itHLESpecialState(cmd, nWords);
+				LatteCP_itHLESpecialState(cmd, nWords);
 				timerRecheck += CP_TIMER_RECHECK / 512;
 				break;
 			}
 			case IT_HLE_BEGIN_OCCLUSION_QUERY:
 			{
-				gxRingBufferReadPtr = (uint8*)LatteCP_itHLEBeginOcclusionQuery(cmd, nWords);
+				LatteCP_itHLEBeginOcclusionQuery(cmd, nWords);
 				timerRecheck += CP_TIMER_RECHECK / 512;
 				break;
 			}
 			case IT_HLE_END_OCCLUSION_QUERY:
 			{
-				gxRingBufferReadPtr = (uint8*)LatteCP_itHLEEndOcclusionQuery(cmd, nWords);
-				timerRecheck += CP_TIMER_RECHECK / 512;
-				break;
-			}
-			case IT_HLE_SET_CB_RETIREMENT_TIMESTAMP:
-			{
-				gxRingBufferReadPtr = (uint8*)LatteCP_itHLESetRetirementTimestamp(cmd, nWords);
+				LatteCP_itHLEEndOcclusionQuery(cmd, nWords);
 				timerRecheck += CP_TIMER_RECHECK / 512;
 				break;
 			}
 			case IT_HLE_BOTTOM_OF_PIPE_CB:
 			{
-				gxRingBufferReadPtr = (uint8*)LatteCP_itHLEBottomOfPipeCB(cmd, nWords);
+				LatteCP_itHLEBottomOfPipeCB(cmd, nWords);
 				break;
 			}
 			case IT_HLE_SYNC_ASYNC_OPERATIONS:
 			{
-				LatteCP_skipWords<LatteCP_readU32Deprc>(nWords);
+				//LatteCP_skipWords<LatteCP_readU32Deprc>(nWords);
 				LatteTextureReadback_UpdateFinishedTransfers(true);
 				LatteQuery_UpdateFinishedQueriesForceFinishAll();
 				break;
@@ -1631,7 +1638,6 @@ void LatteCP_ProcessRingbuffer()
 			default:
 				cemu_assert_debug(false);
 			}
-			cemu_assert_debug(expectedGxRingBufferReadPtr == gxRingBufferReadPtr);
 		}
 		else if (itHeaderType == 2)
 		{
@@ -1669,3 +1675,265 @@ void LatteCP_ProcessRingbuffer()
 		}
 	}
 }
+
+#ifdef LATTE_CP_LOGGING
+void LatteCP_DebugPrintCmdBuffer(uint32be* bufferPtr, uint32 size)
+{
+	uint32be* bufferPtrInitial = bufferPtr;
+	uint32be* bufferPtrEnd = bufferPtr + (size/4);
+	while (bufferPtr < bufferPtrEnd)
+	{
+		std::string strPrefix = fmt::format("[PM4 Buf {:08x} Offs {:04x}]", MEMPTR<void>(bufferPtr).GetMPTR(), (bufferPtr - bufferPtrInitial) * 4);
+		uint32 itHeader = *bufferPtr;
+		bufferPtr++;
+		uint32 itHeaderType = (itHeader >> 30) & 3;
+		if (itHeaderType == 3)
+		{
+			uint32 itCode = (itHeader >> 8) & 0xFF;
+			uint32 nWords = ((itHeader >> 16) & 0x3FFF) + 1;
+			uint32be* cmdData = bufferPtr;
+			bufferPtr += nWords;
+			switch (itCode)
+			{
+			case IT_SURFACE_SYNC:
+			{
+				cemuLog_log(LogType::Force, "{} IT_SURFACE_SYNC", strPrefix);
+				break;
+			}
+			case IT_SET_CONTEXT_REG:
+			{
+				std::string regVals;
+				for (uint32 i = 0; i < std::min<uint32>(nWords - 1, 8); i++)
+					regVals.append(fmt::format("{:08x} ", cmdData[1 + i].value()));
+				cemuLog_log(LogType::Force, "{} IT_SET_CONTEXT_REG Reg {:04x} RegValues {}", strPrefix, cmdData[0].value(), regVals);
+			}
+			case IT_SET_RESOURCE:
+			{
+				std::string regVals;
+				for (uint32 i = 0; i < std::min<uint32>(nWords - 1, 8); i++)
+					regVals.append(fmt::format("{:08x} ", cmdData[1+i].value()));
+				cemuLog_log(LogType::Force, "{} IT_SET_RESOURCE Reg {:04x} RegValues {}", strPrefix, cmdData[0].value(), regVals);
+				break;
+			}
+			case IT_SET_ALU_CONST:
+			{
+				cemuLog_log(LogType::Force, "{} IT_SET_ALU_CONST", strPrefix);
+				break;
+			}
+			case IT_SET_CTL_CONST:
+			{
+				cemuLog_log(LogType::Force, "{} IT_SET_CTL_CONST", strPrefix);
+				break;
+			}
+			case IT_SET_SAMPLER:
+			{
+				cemuLog_log(LogType::Force, "{} IT_SET_SAMPLER", strPrefix);
+				break;
+			}
+			case IT_SET_CONFIG_REG:
+			{
+				cemuLog_log(LogType::Force, "{} IT_SET_CONFIG_REG", strPrefix);
+				break;
+			}
+			case IT_INDIRECT_BUFFER_PRIV:
+			{
+				if (nWords != 3)
+				{
+					cemuLog_log(LogType::Force, "{} IT_INDIRECT_BUFFER_PRIV (malformed!)", strPrefix);
+				}
+				else
+				{
+					uint32 physicalAddress = cmdData[0];
+					uint32 physicalAddressHigh = cmdData[1];
+					uint32 sizeInDWords = cmdData[2];
+					cemuLog_log(LogType::Force, "{} IT_INDIRECT_BUFFER_PRIV Addr {:08x} Size {:08x}", strPrefix, physicalAddress, sizeInDWords*4);
+					LatteCP_DebugPrintCmdBuffer(MEMPTR<uint32be>(physicalAddress), sizeInDWords * 4);
+				}
+				break;
+			}
+			case IT_STRMOUT_BUFFER_UPDATE:
+			{
+				cemuLog_log(LogType::Force, "{} IT_STRMOUT_BUFFER_UPDATE", strPrefix);
+				break;
+			}
+			case IT_INDEX_TYPE:
+			{
+				cemuLog_log(LogType::Force, "{} IT_INDEX_TYPE", strPrefix);
+				break;
+			}
+			case IT_NUM_INSTANCES:
+			{
+				cemuLog_log(LogType::Force, "{} IT_NUM_INSTANCES", strPrefix);
+				break;
+			}
+			case IT_DRAW_INDEX_2:
+			{
+				if (nWords != 5)
+				{
+					cemuLog_log(LogType::Force, "{} IT_DRAW_INDEX_2 (malformed!)", strPrefix);
+				}
+				else
+				{
+					uint32 ukn1 = cmdData[0];
+					MPTR physIndices = cmdData[1];
+					uint32 ukn2 = cmdData[2];
+					uint32 count = cmdData[3];
+					uint32 ukn3 = cmdData[4];
+					cemuLog_log(LogType::Force, "{} IT_DRAW_INDEX_2 | Count {}", strPrefix, count);
+				}
+				break;
+			}
+			case IT_DRAW_INDEX_AUTO:
+			{
+				cemuLog_log(LogType::Force, "{} IT_DRAW_INDEX_AUTO", strPrefix);
+				break;
+			}
+			case IT_DRAW_INDEX_IMMD:
+			{
+				cemuLog_log(LogType::Force, "{} IT_DRAW_INDEX_IMMD", strPrefix);
+				break;
+			}
+			case IT_WAIT_REG_MEM:
+			{
+				cemuLog_log(LogType::Force, "{} IT_WAIT_REG_MEM", strPrefix);
+				break;
+			}
+			case IT_MEM_WRITE:
+			{
+				cemuLog_log(LogType::Force, "{} IT_MEM_WRITE", strPrefix);
+				break;
+			}
+			case IT_CONTEXT_CONTROL:
+			{
+				cemuLog_log(LogType::Force, "{} IT_CONTEXT_CONTROL", strPrefix);
+				break;
+			}
+			case IT_MEM_SEMAPHORE:
+			{
+				cemuLog_log(LogType::Force, "{} IT_MEM_SEMAPHORE", strPrefix);
+				break;
+			}
+			case IT_LOAD_CONFIG_REG:
+			{
+				cemuLog_log(LogType::Force, "{} IT_LOAD_CONFIG_REG", strPrefix);
+				break;
+			}
+			case IT_LOAD_CONTEXT_REG:
+			{
+				cemuLog_log(LogType::Force, "{} IT_LOAD_CONTEXT_REG", strPrefix);
+				break;
+			}
+			case IT_LOAD_ALU_CONST:
+			{
+				cemuLog_log(LogType::Force, "{} IT_LOAD_ALU_CONST", strPrefix);
+				break;
+			}
+			case IT_LOAD_LOOP_CONST:
+			{
+				cemuLog_log(LogType::Force, "{} IT_LOAD_LOOP_CONST", strPrefix);
+				break;
+			}
+			case IT_LOAD_RESOURCE:
+			{
+				cemuLog_log(LogType::Force, "{} IT_LOAD_RESOURCE", strPrefix);
+				break;
+			}
+			case IT_LOAD_SAMPLER:
+			{
+				cemuLog_log(LogType::Force, "{} IT_LOAD_SAMPLER", strPrefix);
+				break;
+			}
+			case IT_SET_LOOP_CONST:
+			{
+				cemuLog_log(LogType::Force, "{} IT_SET_LOOP_CONST", strPrefix);
+				break;
+			}
+			case IT_SET_PREDICATION:
+			{
+				cemuLog_log(LogType::Force, "{} IT_SET_PREDICATION", strPrefix);
+				break;
+			}
+			case IT_HLE_COPY_COLORBUFFER_TO_SCANBUFFER:
+			{
+				cemuLog_log(LogType::Force, "{} IT_HLE_COPY_COLORBUFFER_TO_SCANBUFFER", strPrefix);
+				break;
+			}
+			case IT_HLE_TRIGGER_SCANBUFFER_SWAP:
+			{
+				cemuLog_log(LogType::Force, "{} IT_HLE_TRIGGER_SCANBUFFER_SWAP", strPrefix);
+				break;
+			}
+			case IT_HLE_WAIT_FOR_FLIP:
+			{
+				cemuLog_log(LogType::Force, "{} IT_HLE_WAIT_FOR_FLIP", strPrefix);
+				break;
+			}
+			case IT_HLE_REQUEST_SWAP_BUFFERS:
+			{
+				cemuLog_log(LogType::Force, "{} IT_HLE_REQUEST_SWAP_BUFFERS", strPrefix);
+				break;
+			}
+			case IT_HLE_CLEAR_COLOR_DEPTH_STENCIL:
+			{
+				cemuLog_log(LogType::Force, "{} IT_HLE_CLEAR_COLOR_DEPTH_STENCIL", strPrefix);
+				break;
+			}
+			case IT_HLE_COPY_SURFACE_NEW:
+			{
+				cemuLog_log(LogType::Force, "{} IT_HLE_COPY_SURFACE_NEW", strPrefix);
+				break;
+			}
+			case IT_HLE_SAMPLE_TIMER:
+			{
+				cemuLog_log(LogType::Force, "{} IT_HLE_SAMPLE_TIMER", strPrefix);
+				break;
+			}
+			case IT_HLE_SPECIAL_STATE:
+			{
+				cemuLog_log(LogType::Force, "{} IT_HLE_SPECIAL_STATE", strPrefix);
+				break;
+			}
+			case IT_HLE_BEGIN_OCCLUSION_QUERY:
+			{
+				cemuLog_log(LogType::Force, "{} IT_HLE_BEGIN_OCCLUSION_QUERY", strPrefix);
+				break;
+			}
+			case IT_HLE_END_OCCLUSION_QUERY:
+			{
+				cemuLog_log(LogType::Force, "{} IT_HLE_END_OCCLUSION_QUERY", strPrefix);
+				break;
+			}
+			case IT_HLE_BOTTOM_OF_PIPE_CB:
+			{
+				cemuLog_log(LogType::Force, "{} IT_HLE_BOTTOM_OF_PIPE_CB", strPrefix);
+				break;
+			}
+			case IT_HLE_SYNC_ASYNC_OPERATIONS:
+			{
+				cemuLog_log(LogType::Force, "{} IT_HLE_SYNC_ASYNC_OPERATIONS", strPrefix);
+				break;
+			}
+			default:
+				cemuLog_log(LogType::Force, "{} Unsupported operation code", strPrefix);
+				return;
+			}
+		}
+		else if (itHeaderType == 2)
+		{
+			// filler packet
+		}
+		else if (itHeaderType == 0)
+		{
+			uint32 registerBase = (itHeader & 0xFFFF);
+			uint32 registerCount = ((itHeader >> 16) & 0x3FFF) + 1;
+			LatteCP_skipWords<LatteCP_readU32Deprc>(registerCount);
+			cemuLog_log(LogType::Force, "[LatteCP] itType=0 registerBase={:04x}", registerBase);
+		}
+		else
+		{
+			cemuLog_log(LogType::Force, "Invalid itHeaderType %08x\n", itHeaderType);
+			return;
+		}
+	}
+}
+#endif
\ No newline at end of file
diff --git a/src/Cafe/HW/Latte/Core/LatteConst.h b/src/Cafe/HW/Latte/Core/LatteConst.h
index ffbead1c..ebe741e9 100644
--- a/src/Cafe/HW/Latte/Core/LatteConst.h
+++ b/src/Cafe/HW/Latte/Core/LatteConst.h
@@ -1,21 +1,27 @@
 #pragma once
 #include "Cafe/HW/Latte/ISA/LatteReg.h"
 
-// this file contains legacy C-style defines, modernize and merge into LatteReg.h
+// todo - this file contains legacy C-style defines, modernize and merge into LatteReg.h
 
 // GPU7/Latte hardware info
 
-#define LATTE_NUM_GPR						(128)
-#define LATTE_NUM_STREAMOUT_BUFFER			(4)
-#define LATTE_NUM_COLOR_TARGET				(8)
+#define LATTE_NUM_GPR						128
+#define LATTE_NUM_STREAMOUT_BUFFER			4
+#define LATTE_NUM_COLOR_TARGET				8
 
-#define LATTE_NUM_MAX_TEX_UNITS				(18) // number of available texture units per shader stage (this might be higher than 18? BotW is the only game which uses more than 16?)
-#define LATTE_NUM_MAX_UNIFORM_BUFFERS		(16) // number of supported uniform buffer binding locations
+#define LATTE_NUM_MAX_TEX_UNITS				18 // number of available texture units per shader stage (this might be higher than 18? BotW is the only game which uses more than 16?)
+#define LATTE_NUM_MAX_UNIFORM_BUFFERS		16 // number of supported uniform buffer binding locations
 
-#define LATTE_VS_ATTRIBUTE_LIMIT			(32) // todo: verify
-#define	LATTE_NUM_MAX_ATTRIBUTE_LOCATIONS	(256) // should this be 128 since there are only 128 GPRs?
+#define LATTE_VS_ATTRIBUTE_LIMIT			32 // todo: verify
+#define	LATTE_NUM_MAX_ATTRIBUTE_LOCATIONS	256 // should this be 128 since there are only 128 GPRs?
 
-#define LATTE_MAX_VERTEX_BUFFERS			(16)
+#define LATTE_MAX_VERTEX_BUFFERS			16
+
+// Cemu-specific constants
+
+#define LATTE_CEMU_PS_TEX_UNIT_BASE 		0
+#define LATTE_CEMU_VS_TEX_UNIT_BASE 		32
+#define LATTE_CEMU_GS_TEX_UNIT_BASE 		64
 
 // vertex formats
 
@@ -76,8 +82,6 @@
 #define GLVENDOR_UNKNOWN			(0)
 #define GLVENDOR_AMD				(1)	 // AMD/ATI
 #define GLVENDOR_NVIDIA				(2)
-#define GLVENDOR_INTEL_LEGACY		(3)
-#define GLVENDOR_INTEL_NOLEGACY		(4)
 #define GLVENDOR_INTEL				(5)
 #define GLVENDOR_APPLE				(6)
 
diff --git a/src/Cafe/HW/Latte/Core/LatteGSCopyShaderParser.cpp b/src/Cafe/HW/Latte/Core/LatteGSCopyShaderParser.cpp
index 7df5eecd..16ce0737 100644
--- a/src/Cafe/HW/Latte/Core/LatteGSCopyShaderParser.cpp
+++ b/src/Cafe/HW/Latte/Core/LatteGSCopyShaderParser.cpp
@@ -208,7 +208,7 @@ LatteParsedGSCopyShader* LatteGSCopyShaderParser_parse(uint8* programData, uint3
 				uint32 bufferIndex;
 				if (cf_inst23_7 == GPU7_CF_INST_MEM_STREAM0_WRITE)
 					bufferIndex = 0;
-				else if (cf_inst23_7 == GPU7_CF_INST_MEM_STREAM0_WRITE)
+				else if (cf_inst23_7 == GPU7_CF_INST_MEM_STREAM1_WRITE)
 					bufferIndex = 1;
 				else
 					cemu_assert_debug(false);
@@ -222,7 +222,7 @@ LatteParsedGSCopyShader* LatteGSCopyShaderParser_parse(uint8* programData, uint3
 			}
 			else
 			{
-				forceLog_printf("Copyshader: Unknown 23_7 clause 0x%x found\n", cf_inst23_7);
+				cemuLog_log(LogType::Force, "Copyshader: Unknown 23_7 clause 0x{:x} found", cf_inst23_7);
 				cemu_assert_debug(false);
 			}
 			if( isEndOfProgram )
diff --git a/src/Cafe/HW/Latte/Core/LatteIndices.cpp b/src/Cafe/HW/Latte/Core/LatteIndices.cpp
index e5f3364a..2bbb617d 100644
--- a/src/Cafe/HW/Latte/Core/LatteIndices.cpp
+++ b/src/Cafe/HW/Latte/Core/LatteIndices.cpp
@@ -1,48 +1,64 @@
 #include "Cafe/HW/Latte/Core/LatteConst.h"
 #include "Cafe/HW/Latte/Renderer/Renderer.h"
-
 #include "Cafe/HW/Latte/ISA/RegDefines.h"
+#include "Cafe/HW/Latte/Core/LattePerformanceMonitor.h"
+#include "Common/cpu_features.h"
 
-#if __GNUC__
+#if defined(ARCH_X86_64) && defined(__GNUC__)
 #include <immintrin.h>
-#endif
-
-#ifdef __GNUC__
-#define ATTRIBUTE_AVX2 __attribute__((target("avx2")))
-#define ATTRIBUTE_SSE41 __attribute__((target("sse4.1")))
-#else
-#define ATTRIBUTE_AVX2
-#define ATTRIBUTE_SSE41
+#elif defined(__aarch64__)
+#include <arm_neon.h>
 #endif
 
 struct  
 {
-	const void* lastPtr;
-	uint32 lastCount;
-	LattePrimitiveMode lastPrimitiveMode;
-	LatteIndexType lastIndexType;
-	// output
-	uint32 indexMin;
-	uint32 indexMax;
-	Renderer::INDEX_TYPE renderIndexType;
-	uint32 outputCount;
-	uint32 indexBufferOffset;
-	uint32 indexBufferIndex;
+	struct CacheEntry
+	{
+		// input data
+		const void* lastPtr;
+		uint32 lastCount;
+		LattePrimitiveMode lastPrimitiveMode;
+		LatteIndexType lastIndexType;
+		uint64 lastUsed;
+		// output
+		uint32 indexMin;
+		uint32 indexMax;
+		Renderer::INDEX_TYPE renderIndexType;
+		uint32 outputCount;
+		Renderer::IndexAllocation indexAllocation;
+	};
+	std::array<CacheEntry, 8> entry;
+	uint64 currentUsageCounter{0};
 }LatteIndexCache{};
 
 void LatteIndices_invalidate(const void* memPtr, uint32 size)
 {
-	if (LatteIndexCache.lastPtr >= memPtr && (LatteIndexCache.lastPtr < ((uint8*)memPtr + size)) )
+	for(auto& entry : LatteIndexCache.entry)
 	{
-		LatteIndexCache.lastPtr = nullptr;
-		LatteIndexCache.lastCount = 0;
+		if (entry.lastPtr >= memPtr && (entry.lastPtr < ((uint8*)memPtr + size)) )
+		{
+			if(entry.lastPtr != nullptr)
+				g_renderer->indexData_releaseIndexMemory(entry.indexAllocation);
+			entry.lastPtr = nullptr;
+			entry.lastCount = 0;
+		}
 	}
 }
 
 void LatteIndices_invalidateAll()
 {
-	LatteIndexCache.lastPtr = nullptr;
-	LatteIndexCache.lastCount = 0;
+	for(auto& entry : LatteIndexCache.entry)
+	{
+		if (entry.lastPtr != nullptr)
+			g_renderer->indexData_releaseIndexMemory(entry.indexAllocation);
+		entry.lastPtr = nullptr;
+		entry.lastCount = 0;
+	}
+}
+
+uint64 LatteIndices_GetNextUsageIndex()
+{
+	return LatteIndexCache.currentUsageCounter++;
 }
 
 uint32 LatteIndices_calculateIndexOutputSize(LattePrimitiveMode primitiveMode, LatteIndexType indexType, uint32 count)
@@ -292,6 +308,7 @@ void LatteIndices_generateAutoLineLoopIndices(void* indexDataOutput, uint32 coun
 	indexMax = std::max(count, 1u) - 1;
 }
 
+#if defined(ARCH_X86_64)
 ATTRIBUTE_AVX2
 void LatteIndices_fastConvertU16_AVX2(const void* indexDataInput, void* indexDataOutput, uint32 count, uint32& indexMin, uint32& indexMax)
 {
@@ -487,6 +504,115 @@ void LatteIndices_fastConvertU32_AVX2(const void* indexDataInput, void* indexDat
 	indexMax = std::max(indexMax, _maxIndex);
 	indexMin = std::min(indexMin, _minIndex);
 }
+#elif defined(__aarch64__)
+
+void LatteIndices_fastConvertU16_NEON(const void* indexDataInput, void* indexDataOutput, uint32 count, uint32& indexMin, uint32& indexMax)
+{
+	const uint16* indicesU16BE = (const uint16*)indexDataInput;
+	uint16* indexOutput = (uint16*)indexDataOutput;
+	sint32 count8 = count >> 3;
+	sint32 countRemaining = count & 7;
+
+	if (count8)
+	{
+		uint16x8_t mMin = vdupq_n_u16(0xFFFF);
+		uint16x8_t mMax = vdupq_n_u16(0x0000);
+		uint16x8_t mTemp;
+		uint16x8_t* mRawIndices = (uint16x8_t*) indicesU16BE;
+		indicesU16BE += count8 * 8;
+		uint16x8_t* mOutputIndices = (uint16x8_t*) indexOutput;
+		indexOutput += count8 * 8;
+
+		while (count8--)
+		{
+			mTemp = vld1q_u16((uint16*)mRawIndices);
+			mRawIndices++;
+			mTemp = vrev16q_u8(mTemp);
+			mMin = vminq_u16(mMin, mTemp);
+			mMax = vmaxq_u16(mMax, mTemp);
+			vst1q_u16((uint16*)mOutputIndices, mTemp);
+			mOutputIndices++;
+		}
+
+		uint16* mMaxU16 = (uint16*)&mMax;
+		uint16* mMinU16 = (uint16*)&mMin;
+
+		for (int i = 0; i < 8; ++i) {
+			indexMax = std::max(indexMax, (uint32)mMaxU16[i]);
+			indexMin = std::min(indexMin, (uint32)mMinU16[i]);
+		}
+	}
+	// process remaining indices
+	uint32 _minIndex = 0xFFFFFFFF;
+	uint32 _maxIndex = 0;
+	for (sint32 i = countRemaining; (--i) >= 0;)
+	{
+		uint16 idx = _swapEndianU16(*indicesU16BE);
+		*indexOutput = idx;
+		indexOutput++;
+		indicesU16BE++;
+		_maxIndex = std::max(_maxIndex, (uint32)idx);
+		_minIndex = std::min(_minIndex, (uint32)idx);
+	}
+	// update min/max
+	indexMax = std::max(indexMax, _maxIndex);
+	indexMin = std::min(indexMin, _minIndex);
+}
+
+void LatteIndices_fastConvertU32_NEON(const void* indexDataInput, void* indexDataOutput, uint32 count, uint32& indexMin, uint32& indexMax)
+{
+	const uint32* indicesU32BE = (const uint32*)indexDataInput;
+	uint32* indexOutput = (uint32*)indexDataOutput;
+	sint32 count8 = count >> 2;
+	sint32 countRemaining = count & 3;
+
+	if (count8)
+	{
+		uint32x4_t mMin = vdupq_n_u32(0xFFFFFFFF);
+		uint32x4_t mMax = vdupq_n_u32(0x00000000);
+		uint32x4_t mTemp;
+		uint32x4_t* mRawIndices = (uint32x4_t*) indicesU32BE;
+		indicesU32BE += count8 * 4;
+		uint32x4_t* mOutputIndices = (uint32x4_t*) indexOutput;
+		indexOutput += count8 * 4;
+
+		while (count8--)
+		{
+			mTemp = vld1q_u32((uint32*)mRawIndices);
+			mRawIndices++;
+			mTemp = vrev32q_u8(mTemp);
+			mMin = vminq_u32(mMin, mTemp);
+			mMax = vmaxq_u32(mMax, mTemp);
+			vst1q_u32((uint32*)mOutputIndices, mTemp);
+			mOutputIndices++;
+		}
+
+		uint32* mMaxU32 = (uint32*)&mMax;
+		uint32* mMinU32 = (uint32*)&mMin;
+
+		for (int i = 0; i < 4; ++i) {
+			indexMax = std::max(indexMax, mMaxU32[i]);
+			indexMin = std::min(indexMin, mMinU32[i]);
+		}
+	}
+	// process remaining indices
+	uint32 _minIndex = 0xFFFFFFFF;
+	uint32 _maxIndex = 0;
+	for (sint32 i = countRemaining; (--i) >= 0;)
+	{
+		uint32 idx = _swapEndianU32(*indicesU32BE);
+		*indexOutput = idx;
+		indexOutput++;
+		indicesU32BE++;
+		_maxIndex = std::max(_maxIndex, idx);
+		_minIndex = std::min(_minIndex, idx);
+	}
+	// update min/max
+	indexMax = std::max(indexMax, _maxIndex);
+	indexMin = std::min(indexMin, _minIndex);
+}
+
+#endif
 
 template<typename T>
 void _LatteIndices_alternativeCalculateIndexMinMax(const void* indexData, uint32 count, uint32 primitiveRestartIndex, uint32& indexMin, uint32& indexMax)
@@ -538,7 +664,7 @@ void LatteIndices_alternativeCalculateIndexMinMax(const void* indexData, LatteIn
 	}
 }
 
-void LatteIndices_decode(const void* indexData, LatteIndexType indexType, uint32 count, LattePrimitiveMode primitiveMode, uint32& indexMin, uint32& indexMax, Renderer::INDEX_TYPE& renderIndexType, uint32& outputCount, uint32& indexBufferOffset, uint32& indexBufferIndex)
+void LatteIndices_decode(const void* indexData, LatteIndexType indexType, uint32 count, LattePrimitiveMode primitiveMode, uint32& indexMin, uint32& indexMax, Renderer::INDEX_TYPE& renderIndexType, uint32& outputCount, Renderer::IndexAllocation& indexAllocation)
 {
 	// what this should do:
 	// [x] use fast SIMD-based index decoding
@@ -548,17 +674,18 @@ void LatteIndices_decode(const void* indexData, LatteIndexType indexType, uint32
 	// [ ] better cache implementation, allow to cache across frames
 
 	// reuse from cache if data didn't change
-	if (LatteIndexCache.lastPtr == indexData &&
-		LatteIndexCache.lastCount == count &&
-		LatteIndexCache.lastPrimitiveMode == primitiveMode &&
-		LatteIndexCache.lastIndexType == indexType)
+	auto cacheEntry = std::find_if(LatteIndexCache.entry.begin(), LatteIndexCache.entry.end(), [indexData, count, primitiveMode, indexType](const auto& entry)
 	{
-		indexMin = LatteIndexCache.indexMin;
-		indexMax = LatteIndexCache.indexMax;
-		renderIndexType = LatteIndexCache.renderIndexType;
-		outputCount = LatteIndexCache.outputCount;
-		indexBufferOffset = LatteIndexCache.indexBufferOffset;
-		indexBufferIndex = LatteIndexCache.indexBufferIndex;
+		return entry.lastPtr == indexData && entry.lastCount == count && entry.lastPrimitiveMode == primitiveMode && entry.lastIndexType == indexType;
+	});
+	if (cacheEntry != LatteIndexCache.entry.end())
+	{
+		indexMin = cacheEntry->indexMin;
+		indexMax = cacheEntry->indexMax;
+		renderIndexType = cacheEntry->renderIndexType;
+		outputCount = cacheEntry->outputCount;
+		indexAllocation = cacheEntry->indexAllocation;
+		cacheEntry->lastUsed = LatteIndices_GetNextUsageIndex();
 		return;
 	}
 
@@ -582,10 +709,12 @@ void LatteIndices_decode(const void* indexData, LatteIndexType indexType, uint32
 		indexMin = 0;
 		indexMax = std::max(count, 1u)-1;
 		renderIndexType = Renderer::INDEX_TYPE::NONE;
+		indexAllocation = {};
 		return; // no indices
 	}
 	// query index buffer from renderer
-	void* indexOutputPtr = g_renderer->indexData_reserveIndexMemory(indexOutputSize, indexBufferOffset, indexBufferIndex);
+	indexAllocation = g_renderer->indexData_reserveIndexMemory(indexOutputSize);
+	void* indexOutputPtr = indexAllocation.mem;
 
 	// decode indices
 	indexMin = std::numeric_limits<uint32>::max();
@@ -669,19 +798,31 @@ void LatteIndices_decode(const void* indexData, LatteIndexType indexType, uint32
 	{
 		if (indexType == LatteIndexType::U16_BE)
 		{
-			if (_cpuExtension_AVX2)
+#if defined(ARCH_X86_64)
+			if (g_CPUFeatures.x86.avx2)
 				LatteIndices_fastConvertU16_AVX2(indexData, indexOutputPtr, count, indexMin, indexMax);
-			else if (_cpuExtension_SSE4_1 && _cpuExtension_SSSE3)
+			else if (g_CPUFeatures.x86.sse4_1 && g_CPUFeatures.x86.ssse3)
 				LatteIndices_fastConvertU16_SSE41(indexData, indexOutputPtr, count, indexMin, indexMax);
 			else
 				LatteIndices_convertBE<uint16>(indexData, indexOutputPtr, count, indexMin, indexMax);
+#elif defined(__aarch64__)
+			LatteIndices_fastConvertU16_NEON(indexData, indexOutputPtr, count, indexMin, indexMax);
+#else
+			LatteIndices_convertBE<uint16>(indexData, indexOutputPtr, count, indexMin, indexMax);            
+#endif
 		}
 		else if (indexType == LatteIndexType::U32_BE)
 		{
-			if (_cpuExtension_AVX2)
+#if defined(ARCH_X86_64)
+			if (g_CPUFeatures.x86.avx2)
 				LatteIndices_fastConvertU32_AVX2(indexData, indexOutputPtr, count, indexMin, indexMax);
 			else
 				LatteIndices_convertBE<uint32>(indexData, indexOutputPtr, count, indexMin, indexMax);
+#elif defined(__aarch64__)
+			LatteIndices_fastConvertU32_NEON(indexData, indexOutputPtr, count, indexMin, indexMax);
+#else
+			LatteIndices_convertBE<uint32>(indexData, indexOutputPtr, count, indexMin, indexMax);            
+#endif
 		}
 		else if (indexType == LatteIndexType::U16_LE)
 		{
@@ -702,16 +843,25 @@ void LatteIndices_decode(const void* indexData, LatteIndexType indexType, uint32
 		// recalculate index range but filter out primitive restart index
 		LatteIndices_alternativeCalculateIndexMinMax(indexData, indexType, count, indexMin, indexMax);
 	}
-	g_renderer->indexData_uploadIndexMemory(indexBufferOffset, indexOutputSize);
+	g_renderer->indexData_uploadIndexMemory(indexAllocation);
+	performanceMonitor.cycle[performanceMonitor.cycleIndex].indexDataUploaded += indexOutputSize;
+	// get least recently used cache entry
+	auto lruEntry = std::min_element(LatteIndexCache.entry.begin(), LatteIndexCache.entry.end(), [](const auto& a, const auto& b)
+	{
+		return a.lastUsed < b.lastUsed;
+	});
+	// invalidate previous allocation
+	if(lruEntry->lastPtr != nullptr)
+		g_renderer->indexData_releaseIndexMemory(lruEntry->indexAllocation);
 	// update cache
-	LatteIndexCache.lastPtr = indexData;
-	LatteIndexCache.lastCount = count;
-	LatteIndexCache.lastPrimitiveMode = primitiveMode;
-	LatteIndexCache.lastIndexType = indexType;
-	LatteIndexCache.indexMin = indexMin;
-	LatteIndexCache.indexMax = indexMax;
-	LatteIndexCache.renderIndexType = renderIndexType;
-	LatteIndexCache.outputCount = outputCount;
-	LatteIndexCache.indexBufferOffset = indexBufferOffset;
-	LatteIndexCache.indexBufferIndex = indexBufferIndex;
-}
\ No newline at end of file
+	lruEntry->lastPtr = indexData;
+	lruEntry->lastCount = count;
+	lruEntry->lastPrimitiveMode = primitiveMode;
+	lruEntry->lastIndexType = indexType;
+	lruEntry->indexMin = indexMin;
+	lruEntry->indexMax = indexMax;
+	lruEntry->renderIndexType = renderIndexType;
+	lruEntry->outputCount = outputCount;
+	lruEntry->indexAllocation = indexAllocation;
+	lruEntry->lastUsed = LatteIndices_GetNextUsageIndex();
+}
diff --git a/src/Cafe/HW/Latte/Core/LatteIndices.h b/src/Cafe/HW/Latte/Core/LatteIndices.h
index 917d7991..8aace24e 100644
--- a/src/Cafe/HW/Latte/Core/LatteIndices.h
+++ b/src/Cafe/HW/Latte/Core/LatteIndices.h
@@ -4,4 +4,4 @@
 
 void LatteIndices_invalidate(const void* memPtr, uint32 size);
 void LatteIndices_invalidateAll();
-void LatteIndices_decode(const void* indexData, LatteIndexType indexType, uint32 count, LattePrimitiveMode primitiveMode, uint32& indexMin, uint32& indexMax, Renderer::INDEX_TYPE& renderIndexType, uint32& outputCount, uint32& indexBufferOffset, uint32& indexBufferIndex);
\ No newline at end of file
+void LatteIndices_decode(const void* indexData, LatteIndexType indexType, uint32 count, LattePrimitiveMode primitiveMode, uint32& indexMin, uint32& indexMax, Renderer::INDEX_TYPE& renderIndexType, uint32& outputCount, Renderer::IndexAllocation& indexAllocation);
\ No newline at end of file
diff --git a/src/Cafe/HW/Latte/Core/LatteOverlay.cpp b/src/Cafe/HW/Latte/Core/LatteOverlay.cpp
index cb7c9baf..e6edb904 100644
--- a/src/Cafe/HW/Latte/Core/LatteOverlay.cpp
+++ b/src/Cafe/HW/Latte/Core/LatteOverlay.cpp
@@ -12,34 +12,21 @@
 #include "imgui/imgui_extension.h"
 
 #include "input/InputManager.h"
+#include "util/SystemInfo/SystemInfo.h"
 
 #include <cinttypes>
 
-#if BOOST_OS_WINDOWS
-#include <Psapi.h>
-#include <winternl.h>
-#pragma comment(lib, "ntdll.lib")
-#endif
-
 struct OverlayStats
 {
 	OverlayStats() {};
 
 	int processor_count = 1;
-
-	// cemu cpu stats
-	uint64_t last_cpu{}, kernel{}, user{};
-
-	// global cpu stats
-	struct ProcessorTime
-	{
-		uint64_t idle{}, kernel{}, user{};
-	};
-
+	ProcessorTime processor_time_cemu;
 	std::vector<ProcessorTime> processor_times;
 
 	double fps{};
 	uint32 draw_calls_per_frame{};
+	uint32 fast_draw_calls_per_frame{};
 	float cpu_usage{}; // cemu cpu usage in %
 	std::vector<float> cpu_per_core; // global cpu usage in % per core
 	uint32 ram_usage{}; // ram usage in MB
@@ -80,11 +67,11 @@ struct OverlayList
 const auto kPopupFlags = ImGuiWindowFlags_NoMove | ImGuiWindowFlags_NoDecoration | ImGuiWindowFlags_AlwaysAutoResize | ImGuiWindowFlags_NoSavedSettings | ImGuiWindowFlags_NoFocusOnAppearing | ImGuiWindowFlags_NoNav;
 
 const float kBackgroundAlpha = 0.65f;
-void LatteOverlay_renderOverlay(ImVec2& position, ImVec2& pivot, sint32 direction)
+void LatteOverlay_renderOverlay(ImVec2& position, ImVec2& pivot, sint32 direction, float fontSize, bool pad)
 {
 	auto& config = GetConfig();
-	
-	const auto font = ImGui_GetFont(14.0f * (float)config.overlay.text_scale / 100.0f);
+
+	const auto font = ImGui_GetFont(fontSize);
 	ImGui::PushFont(font);
 
 	const ImVec4 color = ImGui::ColorConvertU32ToFloat4(config.overlay.text_color);
@@ -100,7 +87,7 @@ void LatteOverlay_renderOverlay(ImVec2& position, ImVec2& pivot, sint32 directio
 				ImGui::Text("FPS: %.2lf", g_state.fps);
 
 			if (config.overlay.drawcalls)
-				ImGui::Text("Draws/f: %d", g_state.draw_calls_per_frame);
+				ImGui::Text("Draws/f: %d (fast: %d)", g_state.draw_calls_per_frame, g_state.fast_draw_calls_per_frame);
 
 			if (config.overlay.cpu_usage)
 				ImGui::Text("CPU: %.2lf%%", g_state.cpu_usage);
@@ -120,22 +107,28 @@ void LatteOverlay_renderOverlay(ImVec2& position, ImVec2& pivot, sint32 directio
 				ImGui::Text("VRAM: %dMB / %dMB", g_state.vramUsage, g_state.vramTotal);
 
 			if (config.overlay.debug)
+			{
+				// general debug info
+				ImGui::Text("--- Debug info ---");
+				ImGui::Text("IndexUploadPerFrame: %dKB", (performanceMonitor.stats.indexDataUploadPerFrame+1023)/1024);
+				// backend specific info
 				g_renderer->AppendOverlayDebugInfo();
+			}
 
 			position.y += (ImGui::GetWindowSize().y + 10.0f) * direction;
-			ImGui::End();
 		}
+		ImGui::End();
 	}
 
 	ImGui::PopStyleColor();
 	ImGui::PopFont();
 }
 
-void LatteOverlay_RenderNotifications(ImVec2& position, ImVec2& pivot, sint32 direction)
+void LatteOverlay_RenderNotifications(ImVec2& position, ImVec2& pivot, sint32 direction, float fontSize, bool pad)
 {
 	auto& config = GetConfig();
 
-	const auto font = ImGui_GetFont(14.0f * (float)config.notification.text_scale / 100.0f);
+	const auto font = ImGui_GetFont(fontSize);
 	ImGui::PushFont(font);
 
 	const ImVec4 color = ImGui::ColorConvertU32ToFloat4(config.notification.text_color);
@@ -170,8 +163,8 @@ void LatteOverlay_RenderNotifications(ImVec2& position, ImVec2& pivot, sint32 di
 					ImGui::TextUnformatted(s_mii_name.c_str());
 
 					position.y += (ImGui::GetWindowSize().y + 10.0f) * direction;
-					ImGui::End();
 				}
+				ImGui::End();
 				
 				// controller
 				std::vector<std::pair<int, std::string>> profiles;
@@ -209,8 +202,8 @@ void LatteOverlay_RenderNotifications(ImVec2& position, ImVec2& pivot, sint32 di
 						}
 
 						position.y += (ImGui::GetWindowSize().y + 10.0f) * direction;
-						ImGui::End();
 					}
+					ImGui::End();
 				}
 				else
 					s_init_overlay = true;
@@ -254,10 +247,8 @@ void LatteOverlay_RenderNotifications(ImVec2& position, ImVec2& pivot, sint32 di
 				}
 
 				position.y += (ImGui::GetWindowSize().y + 10.0f) * direction;
-				ImGui::End();
 			}
-
-
+			ImGui::End();
 		}
 	}
 
@@ -306,8 +297,8 @@ void LatteOverlay_RenderNotifications(ImVec2& position, ImVec2& pivot, sint32 di
 				}
 
 				position.y += (ImGui::GetWindowSize().y + 10.0f) * direction;
-				ImGui::End();
 			}
+			ImGui::End();
 		}
 	}
 
@@ -363,8 +354,8 @@ void LatteOverlay_RenderNotifications(ImVec2& position, ImVec2& pivot, sint32 di
 					}
 
 					position.y += (ImGui::GetWindowSize().y + 10.0f) * direction;
-					ImGui::End();
 				}
+				ImGui::End();
 			}
 		}
 		
@@ -402,7 +393,7 @@ void LatteOverlay_RenderNotifications(ImVec2& position, ImVec2& pivot, sint32 di
 					ImRotateEnd(0.001f * ticks.time_since_epoch().count());
 					ImGui::SameLine();
 
-#ifndef PUBLIC_RELEASE
+#ifdef CEMU_DEBUG_ASSERT
 					uint64 totalTime = g_compiling_pipelines_syncTimeSum / 1000000ull;
 					if (s_pipeline_count_async > 0)
 					{
@@ -435,8 +426,8 @@ void LatteOverlay_RenderNotifications(ImVec2& position, ImVec2& pivot, sint32 di
 					}
 #endif
 					position.y += (ImGui::GetWindowSize().y + 10.0f) * direction;
-					ImGui::End();
 				}
+				ImGui::End();
 			}
 		}
 	}
@@ -475,10 +466,9 @@ void LatteOverlay_RenderNotifications(ImVec2& position, ImVec2& pivot, sint32 di
 			}
 
 			position.y += (ImGui::GetWindowSize().y + 10.0f) * direction;
-			ImGui::End();
 		}
+		ImGui::End();
 	}
-
 	ImGui::PopStyleColor();
 	ImGui::PopFont();
 }
@@ -530,20 +520,26 @@ void LatteOverlay_render(bool pad_view)
 
 	sint32 w = 0, h = 0;
 	if (pad_view && gui_isPadWindowOpen())
-		gui_getPadWindowSize(&w, &h);
+		gui_getPadWindowPhysSize(w, h);
 	else
-		gui_getWindowSize(&w, &h);
+		gui_getWindowPhysSize(w, h);
 
 	if (w == 0 || h == 0)
 		return;
 
 	const Vector2f window_size{ (float)w,(float)h };
-	
+
+	float fontDPIScale = !pad_view ? gui_getWindowDPIScale() : gui_getPadDPIScale();
+
+	float overlayFontSize = 14.0f * (float)config.overlay.text_scale / 100.0f * fontDPIScale;
+
 	// test if fonts are already precached
-	if (!ImGui_GetFont(14.0f * (float)config.overlay.text_scale / 100.0f))
+	if (!ImGui_GetFont(overlayFontSize))
 		return;
+
+	float notificationsFontSize = 14.0f * (float)config.notification.text_scale / 100.0f * fontDPIScale;
 	
-	if (!ImGui_GetFont(14.0f * (float)config.notification.text_scale / 100.0f))
+	if (!ImGui_GetFont(notificationsFontSize))
 		return;
 
 	ImVec2 position{}, pivot{};
@@ -552,7 +548,7 @@ void LatteOverlay_render(bool pad_view)
 	if (config.overlay.position != ScreenPosition::kDisabled)
 	{
 		LatteOverlay_translateScreenPosition(config.overlay.position, window_size, position, pivot, direction);
-		LatteOverlay_renderOverlay(position, pivot, direction);
+		LatteOverlay_renderOverlay(position, pivot, direction, overlayFontSize, pad_view);
 	}
 	
 
@@ -561,127 +557,58 @@ void LatteOverlay_render(bool pad_view)
 		if(config.overlay.position != config.notification.position)
 			LatteOverlay_translateScreenPosition(config.notification.position, window_size, position, pivot, direction);
 
-		LatteOverlay_RenderNotifications(position, pivot, direction);
+		LatteOverlay_RenderNotifications(position, pivot, direction, notificationsFontSize, pad_view);
 	}
 }
 
-
 void LatteOverlay_init()
 {
-#if BOOST_OS_WINDOWS
-	SYSTEM_INFO sys_info;
-	GetSystemInfo(&sys_info);
-	g_state.processor_count = sys_info.dwNumberOfProcessors;
+	g_state.processor_count = GetProcessorCount();
 
 	g_state.processor_times.resize(g_state.processor_count);
 	g_state.cpu_per_core.resize(g_state.processor_count);
-#else
-	g_state.processor_count = 1;
-#endif
 }
 
-void LatteOverlay_updateStats(double fps, sint32 drawcalls)
+static void UpdateStats_CemuCpu()
+{
+	ProcessorTime now;
+	QueryProcTime(now);
+	
+	double cpu = ProcessorTime::Compare(g_state.processor_time_cemu, now);
+	cpu /= g_state.processor_count;
+	
+	g_state.cpu_usage = cpu * 100;
+	g_state.processor_time_cemu = now;
+}
+
+static void UpdateStats_CpuPerCore()
+{
+	std::vector<ProcessorTime> now(g_state.processor_count);
+	QueryCoreTimes(g_state.processor_count, now);
+
+	for (int32_t i = 0; i < g_state.processor_count; ++i)
+	{
+		double cpu = ProcessorTime::Compare(g_state.processor_times[i], now[i]);
+
+		g_state.cpu_per_core[i] = cpu * 100;
+		g_state.processor_times[i] = now[i];
+	}
+}
+
+void LatteOverlay_updateStats(double fps, sint32 drawcalls, sint32 fastDrawcalls)
 {
 	if (GetConfig().overlay.position == ScreenPosition::kDisabled)
 		return;
 
 	g_state.fps = fps;
 	g_state.draw_calls_per_frame = drawcalls;
-
-#if BOOST_OS_WINDOWS
-	// update cemu cpu
-	FILETIME ftime, fkernel, fuser;
-	LARGE_INTEGER now, kernel, user;
-	GetSystemTimeAsFileTime(&ftime);
-	now.LowPart = ftime.dwLowDateTime;
-	now.HighPart = ftime.dwHighDateTime;
-
-	GetProcessTimes(GetCurrentProcess(), &ftime, &ftime, &fkernel, &fuser);
-	kernel.LowPart = fkernel.dwLowDateTime;
-	kernel.HighPart = fkernel.dwHighDateTime;
-
-	user.LowPart = fuser.dwLowDateTime;
-	user.HighPart = fuser.dwHighDateTime;
-
-	double percent = (kernel.QuadPart - g_state.kernel) + (user.QuadPart - g_state.user);
-	percent /= (now.QuadPart - g_state.last_cpu);
-	percent /= g_state.processor_count;
-	g_state.cpu_usage = percent * 100;
-	g_state.last_cpu = now.QuadPart;
-	g_state.user = user.QuadPart;
-	g_state.kernel = kernel.QuadPart;
-
-	// update cpu per core
-	std::vector<SYSTEM_PROCESSOR_PERFORMANCE_INFORMATION> sppi(g_state.processor_count);
-	if (NT_SUCCESS(NtQuerySystemInformation(SystemProcessorPerformanceInformation, sppi.data(), sizeof(SYSTEM_PROCESSOR_PERFORMANCE_INFORMATION) * g_state.processor_count, nullptr)))
-	{
-		for (sint32 i = 0; i < g_state.processor_count; ++i)
-		{
-			const uint64 kernel_diff = sppi[i].KernelTime.QuadPart - g_state.processor_times[i].kernel;
-			const uint64 user_diff = sppi[i].UserTime.QuadPart - g_state.processor_times[i].user;
-			const uint64 idle_diff = sppi[i].IdleTime.QuadPart - g_state.processor_times[i].idle;
-
-			const auto total = kernel_diff + user_diff; // kernel time already includes idletime
-			const double cpu = total == 0 ? 0 : (1.0 - ((double)idle_diff / total)) * 100.0;
-
-			g_state.cpu_per_core[i] = cpu;
-			//total_cpu += cpu;
-
-			g_state.processor_times[i].idle = sppi[i].IdleTime.QuadPart;
-			g_state.processor_times[i].kernel = sppi[i].KernelTime.QuadPart;
-			g_state.processor_times[i].user = sppi[i].UserTime.QuadPart;
-		}
-
-		//total_cpu /= g_state.processor_count;
-		//g_state.cpu_usage = total_cpu;
-	}
+	g_state.fast_draw_calls_per_frame = fastDrawcalls;
+	UpdateStats_CemuCpu();
+	UpdateStats_CpuPerCore();
 
 	// update ram
-	PROCESS_MEMORY_COUNTERS pmc{};
-	pmc.cb = sizeof(pmc);
-	GetProcessMemoryInfo(GetCurrentProcess(), &pmc, sizeof(pmc));
-	g_state.ram_usage = (pmc.WorkingSetSize / 1000) / 1000;
-#endif
+	g_state.ram_usage = (QueryRamUsage() / 1000) / 1000;
 
 	// update vram
 	g_renderer->GetVRAMInfo(g_state.vramUsage, g_state.vramTotal);
 }
-
-void LatteOverlay_updateStatsPerFrame()
-{
-	if (!ActiveSettings::FrameProfilerEnabled())
-		return;
-	// update frametime graph
-	uint32 frameTime_total = (uint32)PPCTimer_tscToMicroseconds(performanceMonitor.gpuTime_frameTime.getPreviousFrameValue());
-	uint32 frameTime_idle = (uint32)PPCTimer_tscToMicroseconds(performanceMonitor.gpuTime_idleTime.getPreviousFrameValue());
-	uint32 frameTime_dcStageTextures = (uint32)PPCTimer_tscToMicroseconds(performanceMonitor.gpuTime_dcStageTextures.getPreviousFrameValue());
-	uint32 frameTime_dcStageVertexMgr = (uint32)PPCTimer_tscToMicroseconds(performanceMonitor.gpuTime_dcStageVertexMgr.getPreviousFrameValue());
-	uint32 frameTime_dcStageShaderAndUniformMgr = (uint32)PPCTimer_tscToMicroseconds(performanceMonitor.gpuTime_dcStageShaderAndUniformMgr.getPreviousFrameValue());
-	uint32 frameTime_dcStageIndexMgr = (uint32)PPCTimer_tscToMicroseconds(performanceMonitor.gpuTime_dcStageIndexMgr.getPreviousFrameValue());
-	uint32 frameTime_dcStageMRT = (uint32)PPCTimer_tscToMicroseconds(performanceMonitor.gpuTime_dcStageMRT.getPreviousFrameValue());
-	uint32 frameTime_dcStageDrawcallAPI = (uint32)PPCTimer_tscToMicroseconds(performanceMonitor.gpuTime_dcStageDrawcallAPI.getPreviousFrameValue());
-	uint32 frameTime_waitForAsync = (uint32)PPCTimer_tscToMicroseconds(performanceMonitor.gpuTime_waitForAsync.getPreviousFrameValue());
-
-	// make sure total frame time is not less than it's sums
-	uint32 minimumExpectedFrametime =
-		frameTime_idle +
-		frameTime_dcStageTextures +
-		frameTime_dcStageVertexMgr +
-		frameTime_dcStageShaderAndUniformMgr +
-		frameTime_dcStageIndexMgr +
-		frameTime_dcStageMRT +
-		frameTime_dcStageDrawcallAPI +
-		frameTime_waitForAsync;
-	frameTime_total = std::max(frameTime_total, minimumExpectedFrametime);
-
-	//g_state.frametimeGraph.appendEntry();
-	//g_state.frametimeGraph.setCurrentEntryValue(0xFF404040, frameTime_idle);
-	//g_state.frametimeGraph.setCurrentEntryValue(0xFFFFC0FF, frameTime_waitForAsync);
-	//g_state.frametimeGraph.setCurrentEntryValue(0xFF000040, frameTime_dcStageTextures); // dark red
-	//g_state.frametimeGraph.setCurrentEntryValue(0xFF004000, frameTime_dcStageVertexMgr); // dark green
-	//g_state.frametimeGraph.setCurrentEntryValue(0xFFFFFF80, frameTime_dcStageShaderAndUniformMgr); // blueish
-	//g_state.frametimeGraph.setCurrentEntryValue(0xFF800080, frameTime_dcStageIndexMgr); // purple
-	//g_state.frametimeGraph.setCurrentEntryValue(0xFF00FF00, frameTime_dcStageMRT); // green
-	//g_state.frametimeGraph.setCurrentEntryValue(0xFF00FFFF, frameTime_dcStageDrawcallAPI); // yellow
-	//g_state.frametimeGraph.setCurrentEntryValue(0xFFBBBBBB, frameTime_total - minimumExpectedFrametime);
-}
diff --git a/src/Cafe/HW/Latte/Core/LatteOverlay.h b/src/Cafe/HW/Latte/Core/LatteOverlay.h
index 3df83d1d..824c68b2 100644
--- a/src/Cafe/HW/Latte/Core/LatteOverlay.h
+++ b/src/Cafe/HW/Latte/Core/LatteOverlay.h
@@ -2,7 +2,6 @@
 
 void LatteOverlay_init();
 void LatteOverlay_render(bool pad_view);
-void LatteOverlay_updateStats(double fps, sint32 drawcalls);
-void LatteOverlay_updateStatsPerFrame();
+void LatteOverlay_updateStats(double fps, sint32 drawcalls, sint32 fastDrawcalls);
 
 void LatteOverlay_pushNotification(const std::string& text, sint32 duration);
\ No newline at end of file
diff --git a/src/Cafe/HW/Latte/Core/LattePM4.h b/src/Cafe/HW/Latte/Core/LattePM4.h
index 8079a89c..1f5d2129 100644
--- a/src/Cafe/HW/Latte/Core/LattePM4.h
+++ b/src/Cafe/HW/Latte/Core/LattePM4.h
@@ -14,6 +14,7 @@
 #define IT_MEM_WRITE				0x3D
 #define IT_SURFACE_SYNC				0x43
 #define IT_EVENT_WRITE				0x46
+#define IT_EVENT_WRITE_EOP			0x47	// end of pipe
 
 #define IT_LOAD_CONFIG_REG			0x60
 #define IT_LOAD_CONTEXT_REG			0x61
@@ -47,14 +48,12 @@
 #define IT_HLE_WAIT_FOR_FLIP					0xF1
 #define IT_HLE_BOTTOM_OF_PIPE_CB				0xF2
 #define IT_HLE_COPY_COLORBUFFER_TO_SCANBUFFER	0xF3
-#define IT_HLE_FIFO_WRAP_AROUND					0xF4
 #define IT_HLE_CLEAR_COLOR_DEPTH_STENCIL		0xF5
 #define IT_HLE_SAMPLE_TIMER						0xF7
 #define IT_HLE_TRIGGER_SCANBUFFER_SWAP			0xF8
 #define IT_HLE_SPECIAL_STATE					0xF9
 #define IT_HLE_BEGIN_OCCLUSION_QUERY			0xFA
 #define IT_HLE_END_OCCLUSION_QUERY				0xFB
-#define IT_HLE_SET_CB_RETIREMENT_TIMESTAMP		0xFD
 
 #define pm4HeaderType3(__itCode, __dataDWordCount) (0xC0000000|((uint32)(__itCode)<<8)|((uint32)((__dataDWordCount)-1)<<16))
 #define pm4HeaderType2Filler() (0x80000000)
diff --git a/src/Cafe/HW/Latte/Core/LattePerformanceMonitor.cpp b/src/Cafe/HW/Latte/Core/LattePerformanceMonitor.cpp
index 7104dbd9..14dfe9a9 100644
--- a/src/Cafe/HW/Latte/Core/LattePerformanceMonitor.cpp
+++ b/src/Cafe/HW/Latte/Core/LattePerformanceMonitor.cpp
@@ -38,6 +38,7 @@ void LattePerformanceMonitor_frameEnd()
 		uint64 indexDataCached = 0;
 		uint32 frameCounter = 0;
 		uint32 drawCallCounter = 0;
+		uint32 fastDrawCallCounter = 0;
 		uint32 shaderBindCounter = 0;
 		uint32 recompilerLeaveCount = 0;
 		uint32 threadLeaveCount = 0;
@@ -53,6 +54,7 @@ void LattePerformanceMonitor_frameEnd()
 			indexDataCached += performanceMonitor.cycle[i].indexDataCached;
 			frameCounter += performanceMonitor.cycle[i].frameCounter;
 			drawCallCounter += performanceMonitor.cycle[i].drawCallCounter;
+			fastDrawCallCounter += performanceMonitor.cycle[i].fastDrawCallCounter;
 			shaderBindCounter += performanceMonitor.cycle[i].shaderBindCount;
 			recompilerLeaveCount += performanceMonitor.cycle[i].recompilerLeaveCount;
 			threadLeaveCount += performanceMonitor.cycle[i].threadLeaveCount;
@@ -72,19 +74,18 @@ void LattePerformanceMonitor_frameEnd()
 		uniformBankDataUploadedPerFrame /= 1024ULL;
 		uint32 uniformBankCountUploadedPerFrame = (uint32)(uniformBankUploadedCount / (uint64)elapsedFrames);
 		uint64 indexDataUploadPerFrame = (indexDataUploaded / (uint64)elapsedFrames);
-		indexDataUploadPerFrame /= 1024ULL;
 
 		double fps = (double)elapsedFrames2S * 1000.0 / (double)totalElapsedTimeFPS;
-		uint32 drawCallsPerFrame = drawCallCounter / elapsedFrames;
 		uint32 shaderBindsPerFrame = shaderBindCounter / elapsedFrames;
 		passedCycles = passedCycles * 1000ULL / totalElapsedTime;
 		uint32 rlps = (uint32)((uint64)recompilerLeaveCount * 1000ULL / (uint64)totalElapsedTime);
 		uint32 tlps = (uint32)((uint64)threadLeaveCount * 1000ULL / (uint64)totalElapsedTime);
 		// set stats
-
+		performanceMonitor.stats.indexDataUploadPerFrame = indexDataUploadPerFrame;
 		// next counter cycle
 		sint32 nextCycleIndex = (performanceMonitor.cycleIndex + 1) % PERFORMANCE_MONITOR_TRACK_CYCLES;
 		performanceMonitor.cycle[nextCycleIndex].drawCallCounter = 0;
+		performanceMonitor.cycle[nextCycleIndex].fastDrawCallCounter = 0;
 		performanceMonitor.cycle[nextCycleIndex].frameCounter = 0;
 		performanceMonitor.cycle[nextCycleIndex].shaderBindCount = 0;
 		performanceMonitor.cycle[nextCycleIndex].lastCycleCount = PPCInterpreter_getMainCoreCycleCounter();
@@ -98,30 +99,25 @@ void LattePerformanceMonitor_frameEnd()
 		performanceMonitor.cycle[nextCycleIndex].recompilerLeaveCount = 0;
 		performanceMonitor.cycle[nextCycleIndex].threadLeaveCount = 0;
 		performanceMonitor.cycleIndex = nextCycleIndex;
-		
+
+		// next update in 1 second
+		performanceMonitor.cycle[performanceMonitor.cycleIndex].lastUpdate = GetTickCount();
+
 		if (isFirstUpdate)
 		{
-			LatteOverlay_updateStats(0.0, 0);
+			LatteOverlay_updateStats(0.0, 0, 0);
 			gui_updateWindowTitles(false, false, 0.0);
 		}
 		else
 		{
-			LatteOverlay_updateStats(fps, drawCallCounter / elapsedFrames);
+			LatteOverlay_updateStats(fps, drawCallCounter / elapsedFrames, fastDrawCallCounter / elapsedFrames);
 			gui_updateWindowTitles(false, false, fps);
 		}
-		// next update in 1 second
-		performanceMonitor.cycle[performanceMonitor.cycleIndex].lastUpdate = GetTickCount();
-
-		// prevent hibernation and screen saver/monitor off
-		#if BOOST_OS_WINDOWS
-		SetThreadExecutionState(ES_CONTINUOUS | ES_DISPLAY_REQUIRED | ES_SYSTEM_REQUIRED);
-		#endif
 	}
-	LatteOverlay_updateStatsPerFrame();
 }
 
 void LattePerformanceMonitor_frameBegin()
 {
 	performanceMonitor.vk.numDrawBarriersPerFrame.reset();
 	performanceMonitor.vk.numBeginRenderpassPerFrame.reset();
-}
\ No newline at end of file
+}
diff --git a/src/Cafe/HW/Latte/Core/LattePerformanceMonitor.h b/src/Cafe/HW/Latte/Core/LattePerformanceMonitor.h
index 77554e80..dbc3cff9 100644
--- a/src/Cafe/HW/Latte/Core/LattePerformanceMonitor.h
+++ b/src/Cafe/HW/Latte/Core/LattePerformanceMonitor.h
@@ -84,6 +84,7 @@ typedef struct
 		uint32 lastUpdate;
 		uint32 frameCounter;
 		uint32 drawCallCounter;
+		uint32 fastDrawCallCounter;
 		uint32 shaderBindCount;
 		uint64 vertexDataUploaded; // amount of vertex data uploaded to GPU (bytes)
 		uint64 vertexDataCached; // amount of vertex data reused from GPU cache (bytes)
@@ -123,6 +124,7 @@ typedef struct
 		LattePerfStatCounter numGraphicPipelines;
 		LattePerfStatCounter numImages;
 		LattePerfStatCounter numImageViews;
+		LattePerfStatCounter numSamplers;
 		LattePerfStatCounter numRenderPass;
 		LattePerfStatCounter numFramebuffer;
 
@@ -130,6 +132,12 @@ typedef struct
 		LattePerfStatCounter numDrawBarriersPerFrame;
 		LattePerfStatCounter numBeginRenderpassPerFrame;
 	}vk;
+
+	// calculated stats (per frame)
+	struct
+	{
+		uint32 indexDataUploadPerFrame;
+	}stats;
 }performanceMonitor_t;
 
 extern performanceMonitor_t performanceMonitor;
diff --git a/src/Cafe/HW/Latte/Core/LatteRenderTarget.cpp b/src/Cafe/HW/Latte/Core/LatteRenderTarget.cpp
index 416245b9..2efef5bf 100644
--- a/src/Cafe/HW/Latte/Core/LatteRenderTarget.cpp
+++ b/src/Cafe/HW/Latte/Core/LatteRenderTarget.cpp
@@ -11,7 +11,6 @@
 #include "Cafe/HW/Latte/Core/LattePerformanceMonitor.h"
 #include "Cafe/GraphicPack/GraphicPack2.h"
 #include "config/ActiveSettings.h"
-#include "Cafe/HW/Latte/Renderer/Vulkan/VulkanRenderer.h"
 #include "gui/guiWrapper.h"
 #include "Cafe/OS/libs/erreula/erreula.h"
 #include "input/InputManager.h"
@@ -221,40 +220,10 @@ void LatteMRT::BindDepthBufferOnly(LatteTextureView* view)
 	ApplyCurrentState();
 }
 
-/***************************************************/
-
-LatteTextureView* LatteMRT_FindColorBufferForClearing(MPTR colorBufferPtr, sint32 colorBufferWidth, sint32 colorBufferHeight, sint32 colorBufferPitch, uint32 format, sint32 sliceIndex, sint32* searchIndex)
-{
-	LatteTextureView* view = LatteTC_LookupTextureByData(colorBufferPtr, colorBufferWidth, colorBufferHeight, colorBufferPitch, 0, 1, sliceIndex, 1, searchIndex);
-	if (view == nullptr)
-		return nullptr;
-	return view;
-}
-
-LatteTextureView* LatteMRT_CreateColorBuffer(MPTR colorBufferPhysMem, uint32 width, uint32 height, uint32 pitch, Latte::E_GX2SURFFMT format, Latte::E_HWTILEMODE tileMode, uint32 swizzle, uint32 viewSlice)
-{
-	cemu_assert_debug(colorBufferPhysMem != MPTR_NULL);
-	LatteTextureView* textureView;
-	if(viewSlice != 0)
-		textureView = LatteTexture_CreateMapping(colorBufferPhysMem, MPTR_NULL, width, height, viewSlice+1, pitch, tileMode, swizzle, 0, 1, viewSlice, 1, format, Latte::E_DIM::DIM_2D_ARRAY, Latte::E_DIM::DIM_2D, false);
-	else
-		textureView = LatteTexture_CreateMapping(colorBufferPhysMem, MPTR_NULL, width, height, 1, pitch, tileMode, swizzle, 0, 1, viewSlice, 1, format, Latte::E_DIM::DIM_2D, Latte::E_DIM::DIM_2D, false);
-	// unbind texture
-	g_renderer->texture_bindAndActivate(nullptr, 0);
-	return textureView;
-}
-
 LatteTextureView* LatteMRT_CreateDepthBuffer(MPTR depthBufferPhysMem, uint32 width, uint32 height, uint32 pitch, Latte::E_HWTILEMODE tileMode, Latte::E_GX2SURFFMT format, uint32 swizzle, sint32 viewSlice)
 {
-	LatteTextureView* textureView;
-	if(viewSlice == 0)
-		textureView = LatteTexture_CreateMapping(depthBufferPhysMem, MPTR_NULL, width, height, 1, pitch, tileMode, swizzle, 0, 1, viewSlice, 1, format, Latte::E_DIM::DIM_2D, Latte::E_DIM::DIM_2D, true);
-	else
-		textureView = LatteTexture_CreateMapping(depthBufferPhysMem, MPTR_NULL, width, height, viewSlice+1, pitch, tileMode, swizzle, 0, 1, viewSlice, 1, format, Latte::E_DIM::DIM_2D_ARRAY, Latte::E_DIM::DIM_2D, true);
-
+	LatteTextureView* textureView = LatteTexture_CreateMapping(depthBufferPhysMem, MPTR_NULL, width, height, viewSlice+1, pitch, tileMode, swizzle, 0, 1, viewSlice, 1, format, viewSlice > 0 ? Latte::E_DIM::DIM_2D_ARRAY : Latte::E_DIM::DIM_2D, Latte::E_DIM::DIM_2D, true);
 	LatteMRT::SetDepthAndStencilAttachment(textureView, textureView->baseTexture->hasStencil);
-	// unbind texture
-	g_renderer->texture_bindAndActivate(nullptr, 0);
 	return textureView;
 }
 
@@ -295,6 +264,35 @@ LatteTextureView* LatteMRT::GetColorAttachmentTexture(uint32 index, bool createN
 	uint32 colorBufferHeight = pitchHeight / colorBufferPitch;
 	uint32 colorBufferWidth = colorBufferPitch;
 
+	// colorbuffer width/height has to be padded to 8/32 alignment but the actual resolution might be smaller
+	// use the scissor box as a clue to figure out the original resolution if possible
+	if(LatteGPUState.allowFramebufferSizeOptimization)
+	{
+		uint32 scissorBoxWidth = LatteGPUState.contextNew.PA_SC_GENERIC_SCISSOR_BR.get_BR_X();
+		uint32 scissorBoxHeight = LatteGPUState.contextNew.PA_SC_GENERIC_SCISSOR_BR.get_BR_Y();
+		if (((scissorBoxWidth + 7) & ~7) == colorBufferWidth)
+			colorBufferWidth = scissorBoxWidth;
+		if (((colorBufferHeight + 31) & ~31) == colorBufferHeight)
+			colorBufferHeight = scissorBoxHeight;
+	}
+
+	// log resolution changes if the above heuristic takes effect
+	// this is useful to find resolutions which need to be updated in gfx pack texture rules
+#if 0
+	uint32 colorBufferHeight2 = pitchHeight / colorBufferPitch;
+	static std::unordered_set<uint64> s_foundColorBufferResMappings;
+	if (colorBufferPitch != colorBufferWidth || colorBufferHeight != colorBufferHeight2)
+	{
+		// only log unique, source and dest resolution. Encode into a key with 16 bits per component
+		uint64 resHash = (uint64)colorBufferWidth | ((uint64)colorBufferHeight << 16) | ((uint64)colorBufferPitch << 32) | ((uint64)colorBufferHeight2 << 48);
+		if( !s_foundColorBufferResMappings.contains(resHash) )
+		{
+			s_foundColorBufferResMappings.insert(resHash);
+			cemuLog_log(LogType::Force, "[COLORBUFFER-DBG] Using res {}x{} instead of {}x{}", colorBufferWidth, colorBufferHeight, colorBufferPitch, colorBufferHeight2);
+		}
+	}
+#endif
+
 	bool colorBufferWasFound = false;
 	sint32 viewFirstMip = 0; // todo
 
@@ -305,7 +303,7 @@ LatteTextureView* LatteMRT::GetColorAttachmentTexture(uint32 index, bool createN
 	if (colorBufferView == nullptr)
 	{
 		// create color buffer view
-		colorBufferView = LatteTexture_CreateMapping(colorBufferPhysMem, 0, colorBufferWidth, colorBufferHeight, (viewFirstSlice + viewNumSlices), colorBufferPitch, colorBufferTileMode, colorBufferSwizzle>>8, viewFirstMip, 1, viewFirstSlice, viewNumSlices, (Latte::E_GX2SURFFMT)colorBufferFormat, (viewFirstSlice + viewNumSlices)>1? Latte::E_DIM::DIM_2D_ARRAY: Latte::E_DIM::DIM_2D, Latte::E_DIM::DIM_2D, false);
+		colorBufferView = LatteTexture_CreateMapping(colorBufferPhysMem, 0, colorBufferWidth, colorBufferHeight, (viewFirstSlice + viewNumSlices), colorBufferPitch, colorBufferTileMode, colorBufferSwizzle>>8, viewFirstMip, 1, viewFirstSlice, viewNumSlices, (Latte::E_GX2SURFFMT)colorBufferFormat, (viewFirstSlice + viewNumSlices)>1? Latte::E_DIM::DIM_2D_ARRAY: Latte::E_DIM::DIM_2D, Latte::E_DIM::DIM_2D, false, true);
 		LatteGPUState.repeatTextureInitialization = true;
 		checkForTextureChanges = false;
 	}
@@ -341,7 +339,7 @@ uint8 LatteMRT::GetActiveColorBufferMask(const LatteDecompilerShader* pixelShade
 		return 0;
 	cemu_assert_debug(colorControlReg.get_DEGAMMA_ENABLE() == false); // not supported
 	// combine color buffer mask with pixel output mask from pixel shader
-	colorBufferMask &= pixelShader->pixelColorOutputMask;
+	colorBufferMask &= (pixelShader ? pixelShader->pixelColorOutputMask : 0);
 	// combine color buffer mask with color channel mask from mmCB_TARGET_MASK (disable render buffer if all colors are blocked)
 	uint32 channelTargetMask = lcr.CB_TARGET_MASK.get_MASK();
 	for (uint32 i = 0; i < 8; i++)
@@ -373,6 +371,7 @@ uint8 LatteMRT::GetActiveColorBufferMask(const LatteDecompilerShader* pixelShade
 		if ((colorBufferWidth < (sint32)scissorAccessWidth) ||
 			(colorBufferHeight < (sint32)scissorAccessHeight))
 		{
+            // log this?
 			colorBufferMask &= ~(1<<i);
 		}
 
@@ -491,23 +490,20 @@ bool LatteMRT::UpdateCurrentFBO()
 		sLatteRenderTargetState.rtUpdateList[sLatteRenderTargetState.rtUpdateListCount] = colorAttachmentView;
 		sLatteRenderTargetState.rtUpdateListCount++;
 
-		sint32 colorAttachmentWidth;
-		sint32 colorAttachmentHeight;
-		LatteTexture_getSize(colorAttachmentView->baseTexture, &colorAttachmentWidth, &colorAttachmentHeight, nullptr, colorAttachmentView->firstMip);
+		sint32 colorAttachmentWidth, colorAttachmentHeight;
+		colorAttachmentView->baseTexture->GetSize(colorAttachmentWidth, colorAttachmentHeight, colorAttachmentView->firstMip);
 
 		// set effective size
 		sint32 effectiveWidth, effectiveHeight;
-		LatteTexture_getEffectiveSize(colorAttachmentView->baseTexture, &effectiveWidth, &effectiveHeight, nullptr, colorAttachmentView->firstMip);
-		if( rtEffectiveSize->width == 0 && rtEffectiveSize->height == 0 )
+		colorAttachmentView->baseTexture->GetEffectiveSize(effectiveWidth, effectiveHeight, colorAttachmentView->firstMip);
+		if (rtEffectiveSize->width == 0 && rtEffectiveSize->height == 0)
 		{
 			rtEffectiveSize->width = effectiveWidth;
 			rtEffectiveSize->height = effectiveHeight;
 		}
-		else if( rtEffectiveSize->width != effectiveWidth && rtEffectiveSize->height != effectiveHeight )
+		else if (rtEffectiveSize->width != effectiveWidth && rtEffectiveSize->height != effectiveHeight)
 		{
-#ifndef PUBLIC_RELEASE
-			forceLog_printf("Color buffer size mismatch (%dx%d). Effective size: %dx%d Real size: %dx%d Mismatching texture: %08x %dx%d fmt %04x", rtEffectiveSize->width, rtEffectiveSize->height, effectiveWidth, effectiveHeight, colorAttachmentView->baseTexture->width, colorAttachmentView->baseTexture->height, colorAttachmentView->baseTexture->physAddress, colorAttachmentView->baseTexture->width, colorAttachmentView->baseTexture->height, (uint32)colorAttachmentView->baseTexture->format);
-#endif
+			cemuLog_logDebug(LogType::Force, "Color buffer size mismatch ({}x{}). Effective size: {}x{} Real size: {}x{} Mismatching texture: {:08x} {}x{} fmt {:04x}", rtEffectiveSize->width, rtEffectiveSize->height, effectiveWidth, effectiveHeight, colorAttachmentView->baseTexture->width, colorAttachmentView->baseTexture->height, colorAttachmentView->baseTexture->physAddress, colorAttachmentView->baseTexture->width, colorAttachmentView->baseTexture->height, (uint32)colorAttachmentView->baseTexture->format);
 		}
 		// currently the first color attachment defines the size of the current render target
 		if (rtRealSize->width == 0 && rtRealSize->height == 0)
@@ -582,16 +578,11 @@ bool LatteMRT::UpdateCurrentFBO()
 
 			if (depthBufferPhysMem != MPTR_NULL)
 			{
-				bool depthBufferWasFound = false;
 				LatteTextureView* depthBufferView = LatteTextureViewLookupCache::lookupSliceEx(depthBufferPhysMem, depthBufferWidth, depthBufferHeight, depthBufferPitch, 0, depthBufferViewFirstSlice, depthBufferFormat, true);
-				if (depthBufferView == nullptr)
+				if (!depthBufferView)
 				{
-					// create depth buffer view
-					forceLogDebug_printf("Creating depth buffer tex %08x %dx%d slice %d", depthBufferPhysMem, depthBufferHeight, depthBufferWidth, depthBufferViewFirstSlice);
-					if(depthBufferViewFirstSlice == 0)
-						depthBufferView = LatteTexture_CreateMapping(depthBufferPhysMem, 0, depthBufferWidth, depthBufferHeight, 1, depthBufferPitch, depthBufferTileMode, depthBufferSwizzle, 0, 1, 0, 1, depthBufferFormat, Latte::E_DIM::DIM_2D, Latte::E_DIM::DIM_2D, true);
-					else
-						depthBufferView = LatteTexture_CreateMapping(depthBufferPhysMem, 0, depthBufferWidth, depthBufferHeight, depthBufferViewFirstSlice+1, depthBufferPitch, depthBufferTileMode, depthBufferSwizzle, 0, 1, depthBufferViewFirstSlice, 1, depthBufferFormat, Latte::E_DIM::DIM_2D_ARRAY, Latte::E_DIM::DIM_2D, true);
+					// create new depth buffer view and if it doesn't exist then also create the texture
+					depthBufferView = LatteTexture_CreateMapping(depthBufferPhysMem, 0, depthBufferWidth, depthBufferHeight, depthBufferViewFirstSlice+1, depthBufferPitch, depthBufferTileMode, depthBufferSwizzle, 0, 1, depthBufferViewFirstSlice, 1, depthBufferFormat, depthBufferViewFirstSlice > 0 ? Latte::E_DIM::DIM_2D_ARRAY : Latte::E_DIM::DIM_2D, Latte::E_DIM::DIM_2D, true, true);
 					LatteGPUState.repeatTextureInitialization = true;
 				}
 				else
@@ -601,7 +592,7 @@ bool LatteMRT::UpdateCurrentFBO()
 				}
 				// set effective size
 				sint32 effectiveWidth, effectiveHeight;
-				LatteTexture_getEffectiveSize(depthBufferView->baseTexture, &effectiveWidth, &effectiveHeight, NULL);
+				depthBufferView->baseTexture->GetEffectiveSize(effectiveWidth, effectiveHeight, depthBufferView->firstMip);
 				if (rtEffectiveSize->width == 0 && rtEffectiveSize->height == 0)
 				{
 					rtEffectiveSize->width = effectiveWidth;
@@ -611,7 +602,7 @@ bool LatteMRT::UpdateCurrentFBO()
 				{
 					if (_depthBufferSizeWarningCount < 100)
 					{
-						forceLogDebug_printf("Depth buffer size too small. Effective size: %dx%d Real size: %dx%d Mismatching texture: %08x %dx%d fmt %04x", effectiveWidth, effectiveHeight, depthBufferView->baseTexture->width, depthBufferView->baseTexture->height, depthBufferView->baseTexture->physAddress, depthBufferView->baseTexture->width, depthBufferView->baseTexture->height, (uint32)depthBufferView->baseTexture->format);
+						cemuLog_logDebug(LogType::Force, "Depth buffer size too small. Effective size: {}x{} Real size: {}x{} Mismatching texture: {:08x} {}x{} fmt {:04x}", effectiveWidth, effectiveHeight, depthBufferView->baseTexture->width, depthBufferView->baseTexture->height, depthBufferView->baseTexture->physAddress, depthBufferView->baseTexture->width, depthBufferView->baseTexture->height, (uint32)depthBufferView->baseTexture->format);
 						_depthBufferSizeWarningCount++;
 					}
 				}
@@ -721,7 +712,7 @@ void LatteRenderTarget_applyTextureColorClear(LatteTexture* texture, uint32 slic
 {
 	if (texture->isDepth)
 	{
-		forceLogDebug_printf("Unsupported clear depth as color");
+		cemuLog_logDebug(LogType::Force, "Unsupported clear depth as color");
 	}
 	else
 	{
@@ -751,7 +742,10 @@ void LatteRenderTarget_applyTextureDepthClear(LatteTexture* texture, uint32 slic
 	LatteTexture_MarkDynamicTextureAsChanged(texture->baseView, sliceIndex, mipIndex, eventCounter);
 }
 
-void LatteRenderTarget_itHLEClearColorDepthStencil(uint32 clearMask, MPTR colorBufferMPTR, MPTR colorBufferFormat, Latte::E_HWTILEMODE colorBufferTilemode, uint32 colorBufferWidth, uint32 colorBufferHeight, uint32 colorBufferPitch, uint32 colorBufferViewFirstSlice, uint32 colorBufferViewNumSlice, MPTR depthBufferMPTR, MPTR depthBufferFormat, Latte::E_HWTILEMODE depthBufferTileMode, sint32 depthBufferWidth, sint32 depthBufferHeight, sint32 depthBufferPitch, sint32 depthBufferViewFirstSlice, sint32 depthBufferViewNumSlice, float r, float g, float b, float a, float clearDepth, uint32 clearStencil)
+void LatteRenderTarget_itHLEClearColorDepthStencil(uint32 clearMask,
+												   MPTR colorBufferMPTR, Latte::E_GX2SURFFMT colorBufferFormat, Latte::E_HWTILEMODE colorBufferTilemode, uint32 colorBufferWidth, uint32 colorBufferHeight, uint32 colorBufferPitch, uint32 colorBufferViewFirstSlice, uint32 colorBufferViewNumSlice,
+												   MPTR depthBufferMPTR, Latte::E_GX2SURFFMT depthBufferFormat, Latte::E_HWTILEMODE depthBufferTileMode, sint32 depthBufferWidth, sint32 depthBufferHeight, sint32 depthBufferPitch, sint32 depthBufferViewFirstSlice, sint32 depthBufferViewNumSlice,
+												   float r, float g, float b, float a, float clearDepth, uint32 clearStencil)
 {
 	uint32 depthBufferMipIndex = 0; // todo
 	uint32 colorBufferMipIndex = 0; // todo
@@ -786,13 +780,11 @@ void LatteRenderTarget_itHLEClearColorDepthStencil(uint32 clearMask, MPTR colorB
 		bool targetFound = false;
 		while (true)
 		{
-			LatteTextureView* colorView = LatteMRT_FindColorBufferForClearing(colorBufferMPTR, colorBufferWidth, colorBufferHeight, colorBufferPitch, colorBufferFormat, colorBufferViewFirstSlice, &searchIndex);
+			LatteTextureView* colorView = LatteTC_LookupTextureByData(colorBufferMPTR, colorBufferWidth, colorBufferHeight, colorBufferPitch, 0, 1, colorBufferViewFirstSlice, 1, &searchIndex);
 			if (!colorView)
 				break;
-			if (Latte::GetFormatBits((Latte::E_GX2SURFFMT)colorBufferFormat) != Latte::GetFormatBits(colorView->baseTexture->format))
-			{
+			if (Latte::GetFormatBits(colorBufferFormat) != Latte::GetFormatBits(colorView->baseTexture->format))
 				continue;
-			}
 
 			if (colorView->baseTexture->pitch == colorBufferPitch && colorView->baseTexture->height == colorBufferHeight)
 				targetFound = true;
@@ -804,7 +796,7 @@ void LatteRenderTarget_itHLEClearColorDepthStencil(uint32 clearMask, MPTR colorB
 		{
 			// create new texture with matching format
 			cemu_assert_debug(colorBufferViewNumSlice <= 1);
-			LatteTextureView* newColorView = LatteMRT_CreateColorBuffer(colorBufferMPTR, colorBufferWidth, colorBufferHeight, colorBufferPitch, (Latte::E_GX2SURFFMT)colorBufferFormat, colorBufferTilemode, colorBufferSwizzle, colorBufferViewFirstSlice);
+			LatteTextureView* newColorView = LatteTexture_CreateMapping(colorBufferMPTR, MPTR_NULL, colorBufferWidth, colorBufferHeight, colorBufferViewFirstSlice+1, colorBufferPitch, colorBufferTilemode, colorBufferSwizzle, 0, 1, colorBufferViewFirstSlice, 1, colorBufferFormat, colorBufferViewFirstSlice > 0 ? Latte::E_DIM::DIM_2D_ARRAY : Latte::E_DIM::DIM_2D, Latte::E_DIM::DIM_2D, false);
 			LatteRenderTarget_applyTextureColorClear(newColorView->baseTexture, colorBufferViewFirstSlice, colorBufferMipIndex, r, g, b, a, eventCounter);
 		}
 	}
@@ -847,9 +839,9 @@ void LatteRenderTarget_getScreenImageArea(sint32* x, sint32* y, sint32* width, s
 {
 	int w, h;
 	if(padView && gui_isPadWindowOpen())
-		gui_getPadWindowSize(&w, &h);
+		gui_getPadWindowPhysSize(w, h);
 	else
-		gui_getWindowSize(&w, &h);
+		gui_getWindowPhysSize(w, h);
 
 	sint32 scaledOutputX;
 	sint32 scaledOutputY;
@@ -882,20 +874,13 @@ void LatteRenderTarget_getScreenImageArea(sint32* x, sint32* y, sint32* width, s
 
 void LatteRenderTarget_copyToBackbuffer(LatteTextureView* textureView, bool isPadView)
 {
-	if (g_renderer->GetType() == RendererAPI::Vulkan)
-	{
-		((VulkanRenderer*)g_renderer.get())->PreparePresentationFrame(!isPadView);
-	}
-
 	// make sure texture is updated to latest data in cache
 	LatteTexture_UpdateDataToLatest(textureView->baseTexture);
 	// mark source texture as still in use
 	LatteTC_MarkTextureStillInUse(textureView->baseTexture);
 
-	sint32 effectiveWidth;
-	sint32 effectiveHeight;
-	sint32 effectiveDepth;
-	LatteTexture_getEffectiveSize(textureView->baseTexture, &effectiveWidth, &effectiveHeight, &effectiveDepth, 0);
+	sint32 effectiveWidth, effectiveHeight;
+	textureView->baseTexture->GetEffectiveSize(effectiveWidth, effectiveHeight, 0);
 	_currentOutputImageWidth = effectiveWidth;
 	_currentOutputImageHeight = effectiveHeight;
 	
@@ -947,13 +932,6 @@ void LatteRenderTarget_copyToBackbuffer(LatteTextureView* textureView, bool isPa
 	if (shader == nullptr)
 	{
 		sint32 scaling_filter = downscaling ? GetConfig().downscale_filter : GetConfig().upscale_filter;
-		
-		if (g_renderer->GetType() == RendererAPI::Vulkan)
-		{
-			// force linear or nearest neighbor filter
-			if(scaling_filter != kLinearFilter && scaling_filter != kNearestNeighborFilter)
-				scaling_filter = kLinearFilter;
-		}
 
 		if (scaling_filter == kLinearFilter)
 		{
@@ -971,7 +949,7 @@ void LatteRenderTarget_copyToBackbuffer(LatteTextureView* textureView, bool isPa
 			else
 				shader = RendererOutputShader::s_bicubic_shader;
 
-			filter = LatteTextureView::MagFilter::kNearestNeighbor;
+			filter = LatteTextureView::MagFilter::kLinear;
 		}
 		else if (scaling_filter == kBicubicHermiteFilter)
 		{
@@ -1003,9 +981,6 @@ void LatteRenderTarget_copyToBackbuffer(LatteTextureView* textureView, bool isPa
 	g_renderer->ImguiEnd();
 }
 
-bool alwaysDisplayDRC = false;
-bool ctrlTabHotkeyPressed = false;
-
 void LatteRenderTarget_itHLECopyColorBufferToScanBuffer(MPTR colorBufferPtr, uint32 colorBufferWidth, uint32 colorBufferHeight, uint32 colorBufferSliceIndex, uint32 colorBufferFormat, uint32 colorBufferPitch, Latte::E_HWTILEMODE colorBufferTilemode, uint32 colorBufferSwizzle, uint32 renderTarget)
 {
 	cemu_assert_debug(colorBufferSliceIndex == 0); // todo - support for non-zero slice
@@ -1015,40 +990,35 @@ void LatteRenderTarget_itHLECopyColorBufferToScanBuffer(MPTR colorBufferPtr, uin
 		return;
 	}
 
-	const bool tabPressed = gui_isKeyDown(WXK_TAB);
-	const bool ctrlPressed = gui_isKeyDown(0xA2); // VK_LCONTROL
-	bool showDRC = swkbd_hasKeyboardInputHook() == false && tabPressed;
+	auto getVPADScreenActive = [](size_t n) -> std::pair<bool, bool> {
+		auto controller = InputManager::instance().get_vpad_controller(n);
+		if (!controller)
+			return {false,false};
+		auto pressed = controller->is_screen_active();
+		auto toggle = controller->is_screen_active_toggle();
+		return {pressed && !toggle, pressed && toggle};
+	};
 
-	if (ctrlPressed && tabPressed)
-	{
-		if (ctrlTabHotkeyPressed == false)
-		{
-			alwaysDisplayDRC = !alwaysDisplayDRC;
-			ctrlTabHotkeyPressed = true;
-		}
-	}
-	else
-		ctrlTabHotkeyPressed = false;
+	const bool tabPressed = gui_isKeyDown(PlatformKeyCodes::TAB);
+	const bool ctrlPressed = gui_isKeyDown(PlatformKeyCodes::LCONTROL);
+	const auto [vpad0Active, vpad0Toggle] = getVPADScreenActive(0);
+	const auto [vpad1Active, vpad1Toggle] = getVPADScreenActive(1);
 
-	if (alwaysDisplayDRC)
-		showDRC = !tabPressed;
+	const bool altScreenRequested = (!ctrlPressed && tabPressed) || vpad0Active || vpad1Active;
+	const bool togglePressed = (ctrlPressed && tabPressed) || vpad0Toggle || vpad1Toggle;
+	static bool togglePressedLast = false;
 
-	if (!showDRC)
-	{
-		auto controller = InputManager::instance().get_vpad_controller(0);
-		if (controller && controller->is_screen_active())
-			showDRC = true;
-		if (!showDRC)
-		{
-			controller = InputManager::instance().get_vpad_controller(1);
-			if (controller && controller->is_screen_active())
-				showDRC = true;	
-		}
-	}
+	bool& isDRCPrimary = LatteGPUState.isDRCPrimary;
 
-	if (renderTarget == 4 && g_renderer->IsPadWindowActive())
+	if(togglePressed && !togglePressedLast)
+		isDRCPrimary = !isDRCPrimary;
+	togglePressedLast = togglePressed;
+
+	bool showDRC = swkbd_hasKeyboardInputHook() == false && (isDRCPrimary ^ altScreenRequested);
+
+	if ((renderTarget & RENDER_TARGET_DRC) && g_renderer->IsPadWindowActive())
 		LatteRenderTarget_copyToBackbuffer(texView, true);
-	if ((renderTarget == 1 && !showDRC) || (renderTarget == 4 && showDRC))
+	if (((renderTarget & RENDER_TARGET_TV) && !showDRC) || ((renderTarget & RENDER_TARGET_DRC) && showDRC))
 		LatteRenderTarget_copyToBackbuffer(texView, false);
 }
 
@@ -1130,4 +1100,4 @@ void LatteRenderTarget_unloadAll()
 		LatteMRT::DeleteCachedFBO(g_emptyFBO);
 		g_emptyFBO = nullptr;
 	}
-}
\ No newline at end of file
+}
diff --git a/src/Cafe/HW/Latte/Core/LatteRingBuffer.cpp b/src/Cafe/HW/Latte/Core/LatteRingBuffer.cpp
index 15c2b24c..22eeea4b 100644
--- a/src/Cafe/HW/Latte/Core/LatteRingBuffer.cpp
+++ b/src/Cafe/HW/Latte/Core/LatteRingBuffer.cpp
@@ -11,7 +11,7 @@ LatteRingBuffer_t* LatteRingBuffer_create(uint8* data, uint32 size)
 
 uint8* LatteRingBuffer_allocate(LatteRingBuffer_t* rb, sint32 size, sint32 alignment)
 {
-#ifndef PUBLIC_RELEASE
+#ifdef CEMU_DEBUG_ASSERT
 	cemu_assert_debug(size < rb->size);
 #endif
 	// align
diff --git a/src/Cafe/HW/Latte/Core/LatteShader.cpp b/src/Cafe/HW/Latte/Core/LatteShader.cpp
index 5e97d485..d9f0a5dd 100644
--- a/src/Cafe/HW/Latte/Core/LatteShader.cpp
+++ b/src/Cafe/HW/Latte/Core/LatteShader.cpp
@@ -1,18 +1,25 @@
 #include "Cafe/HW/Latte/Core/LatteConst.h"
 #include "Cafe/HW/Latte/Core/LatteShaderAssembly.h"
 #include "Cafe/HW/Latte/ISA/RegDefines.h"
-#include "Cafe/OS/libs/gx2/GX2.h" // todo - remove dependency
 #include "Cafe/HW/Latte/ISA/LatteReg.h"
 #include "Cafe/HW/Latte/Core/LatteShader.h"
 #include "Cafe/HW/Latte/LegacyShaderDecompiler/LatteDecompiler.h"
 #include "Cafe/HW/Latte/Core/FetchShader.h"
 #include "Cafe/HW/Latte/Core/LattePerformanceMonitor.h"
+#include "Cafe/HW/Latte/Renderer/Vulkan/VulkanRenderer.h"
+#include "Cafe/OS/libs/gx2/GX2.h" // todo - remove dependency
 #include "Cafe/GraphicPack/GraphicPack2.h"
 #include "util/helpers/StringParser.h"
 #include "config/ActiveSettings.h"
+#include "Cafe/GameProfile/GameProfile.h"
+#include "util/containers/flat_hash_map.hpp"
+#include <cinttypes>
+
+// experimental new decompiler (WIP)
 #include "util/Zir/EmitterGLSL/ZpIREmitGLSL.h"
 #include "util/Zir/Core/ZpIRDebug.h"
-#include "util/containers/flat_hash_map.hpp"
+#include "Cafe/HW/Latte/Transcompiler/LatteTC.h"
+#include "Cafe/HW/Latte/ShaderInfo/ShaderInfo.h"
 
 struct _ShaderHashCache
 {
@@ -137,7 +144,7 @@ LatteShaderPSInputTable* LatteSHRC_GetPSInputTable()
 	return &_activePSImportTable;
 }
 
-bool LatteSHRC_RemoveFromCache(LatteDecompilerShader* shader)
+void LatteSHRC_RemoveFromCache(LatteDecompilerShader* shader)
 {
 	bool removed = false;
 	auto& cache = LatteSHRC_GetCacheByType(shader->shaderType);
@@ -149,10 +156,14 @@ bool LatteSHRC_RemoveFromCache(LatteDecompilerShader* shader)
 	}
 	else if (baseIt->second == shader)
 	{
-		if (baseIt->second->next)
-			cache.emplace(shader->baseHash, baseIt->second->next);
-		else
-			cache.erase(baseIt);
+        cemu_assert_debug(baseIt->second == shader);
+        cache.erase(baseIt);
+		if (shader->next)
+        {
+            cemu_assert_debug(shader->baseHash == shader->next->baseHash);
+            cache.emplace(shader->baseHash, shader->next);
+        }
+        shader->next = 0;
 		removed = true;
 	}
 	else
@@ -169,7 +180,7 @@ bool LatteSHRC_RemoveFromCache(LatteDecompilerShader* shader)
 			}
 		}
 	}
-	return removed;
+	cemu_assert(removed);
 }
 
 void LatteSHRC_RemoveFromCacheByHash(uint64 shader_base_hash, uint64 shader_aux_hash, LatteConst::ShaderType type)
@@ -236,7 +247,7 @@ void LatteShader_UpdatePSInputs(uint32* contextRegisters)
 	}
 
 	// semantic imports from vertex shader
-#ifndef PUBLIC_RELEASE
+#ifdef CEMU_DEBUG_ASSERT
 	uint8 semanticMask[256 / 8] = { 0 };
 #endif
 	cemu_assert_debug(numPSInputs <= GPU7_PS_MAX_INPUTS);
@@ -273,10 +284,10 @@ void LatteShader_UpdatePSInputs(uint32* contextRegisters)
 		}
 		else
 		{
-#ifndef PUBLIC_RELEASE
+#ifdef CEMU_DEBUG_ASSERT
 			if (semanticMask[psSemanticId >> 3] & (1 << (psSemanticId & 7)))
 			{
-				forceLogDebug_printf("SemanticId already used");
+				cemuLog_logDebug(LogType::Force, "SemanticId already used");
 			}
 			semanticMask[psSemanticId >> 3] |= (1 << (psSemanticId & 7));
 #endif
@@ -294,7 +305,7 @@ void LatteShader_CreateRendererShader(LatteDecompilerShader* shader, bool compil
 {
 	if (shader->hasError )
 	{
-		forceLog_printf("Unable to compile shader %I64x", shader->baseHash);
+		cemuLog_log(LogType::Force, "Unable to compile shader {:016x}", shader->baseHash);
 		return;
 	}
 
@@ -332,7 +343,7 @@ void LatteShader_CreateRendererShader(LatteDecompilerShader* shader, bool compil
 		(shader->baseHash == 0x15bc7edf9de2ed30 || shader->baseHash == 0x83a697d61a3b9202 ||
 		 shader->baseHash == 0x97bc44a5028381c6 || shader->baseHash == 0x24838b84d15a1da1))
 	{
-		forceLogDebug_printf("Filtered shader to avoid AMD crash");
+		cemuLog_logDebug(LogType::Force, "Filtered shader to avoid AMD crash");
 		shader->shader = nullptr;
 		shader->hasError = true;
 		return;
@@ -350,7 +361,7 @@ void LatteShader_FinishCompilation(LatteDecompilerShader* shader)
 {
 	if (shader->hasError)
 	{
-		forceLogDebug_printf("LatteShader_finishCompilation(): Skipped because of error in shader %llx", shader->baseHash);
+		cemuLog_logDebug(LogType::Force, "LatteShader_finishCompilation(): Skipped because of error in shader {:x}", shader->baseHash);
 		return;
 	}
 	shader->shader->WaitForCompiled();
@@ -440,9 +451,8 @@ void LatteShader_DumpShader(uint64 baseHash, uint64 auxHash, LatteDecompilerShad
 		suffix = "gs";
 	else if (shader->shaderType == LatteConst::ShaderType::Pixel)
 		suffix = "ps";
-	fs::path dumpPath = "dump/shaders";
-	dumpPath /= fmt::format("{:016x}_{:016x}_{}.txt", baseHash, auxHash, suffix);
-	FileStream* fs = FileStream::createFile2(dumpPath);
+
+	FileStream* fs = FileStream::createFile2(ActiveSettings::GetUserDataPath("dump/shaders/{:016x}_{:016x}_{}.txt", baseHash, auxHash, suffix));
 	if (fs)
 	{
 		if (shader->strBuf_shaderSource)
@@ -468,9 +478,8 @@ void LatteShader_DumpRawShader(uint64 baseHash, uint64 auxHash, uint32 type, uin
 		suffix = "copy";
 	else if (type == SHADER_DUMP_TYPE_COMPUTE)
 		suffix = "compute";
-	fs::path dumpPath = "dump/shaders";
-	dumpPath /= fmt::format("{:016x}_{:016x}_{}.bin", baseHash, auxHash, suffix);
-	FileStream* fs = FileStream::createFile2(dumpPath);
+
+	FileStream* fs = FileStream::createFile2(ActiveSettings::GetUserDataPath("dump/shaders/{:016x}_{:016x}_{}.bin", baseHash, auxHash, suffix));
 	if (fs)
 	{
 		fs->writeData(programCode, programLen);
@@ -513,7 +522,7 @@ void LatteSHRC_UpdateGSBaseHash(uint8* geometryShaderPtr, uint32 geometryShaderS
 	// update hash from geometry shader data
 	uint64 gsHash1 = 0;
 	uint64 gsHash2 = 0;
-	_calculateShaderProgramHash((uint32*)geometryShaderPtr, geometryShaderSize, &hashCacheVS, &gsHash1, &gsHash2);
+	_calculateShaderProgramHash((uint32*)geometryShaderPtr, geometryShaderSize, &hashCacheGS, &gsHash1, &gsHash2);
 	// get geometry shader
 	uint64 gsHash = gsHash1 + gsHash2;
 	gsHash += (uint64)_activeVertexShader->ringParameterCount;
@@ -543,7 +552,7 @@ uint64 LatteSHRC_CalcVSAuxHash(LatteDecompilerShader* vertexShader, uint32* cont
 		// hash stride for streamout buffers
 		for (uint32 i = 0; i < LATTE_NUM_STREAMOUT_BUFFER; i++)
 		{
-			if(!vertexShader->streamoutBufferWriteMask2[i])
+			if(!vertexShader->streamoutBufferWriteMask[i])
 				continue;
 			uint32 bufferStride = contextRegisters[mmVGT_STRMOUT_VTX_STRIDE_0 + i * 4];
 			auxHash = std::rotl<uint64>(auxHash, 7);
@@ -611,7 +620,7 @@ LatteDecompilerShader* LatteShader_CreateShaderFromDecompilerOutput(LatteDecompi
 	// copy texture info
 	shader->textureUnitMask2 = decompilerOutput.textureUnitMask;
 	// copy streamout info
-	shader->streamoutBufferWriteMask2 = decompilerOutput.streamoutBufferWriteMask;
+	shader->streamoutBufferWriteMask = decompilerOutput.streamoutBufferWriteMask;
 	shader->hasStreamoutBufferWrite = decompilerOutput.streamoutBufferWriteMask.any();
 	// copy uniform offsets
 	// for OpenGL these are retrieved in _prepareSeparableUniforms()
@@ -641,7 +650,7 @@ LatteDecompilerShader* LatteShader_CreateShaderFromDecompilerOutput(LatteDecompi
 	}
 	else
 	{
-		shader->uniform.count_uniformRegister = decompilerOutput.uniformOffsetsVK.count_uniformRegister;
+		shader->uniform.count_uniformRegister = decompilerOutput.uniformOffsetsGL.count_uniformRegister;
 	}
 	// calculate aux hash
 	if (calculateAuxHash)
@@ -671,10 +680,19 @@ LatteDecompilerShader* LatteShader_CreateShaderFromDecompilerOutput(LatteDecompi
 	return shader;
 }
 
-#include "Cafe/HW/Latte/Transcompiler/LatteTC.h"
-#include "Cafe/HW/Latte/ShaderInfo/ShaderInfo.h"
+void LatteShader_GetDecompilerOptions(LatteDecompilerOptions& options, LatteConst::ShaderType shaderType, bool geometryShaderEnabled)
+{
+	options.usesGeometryShader = geometryShaderEnabled;
+	options.spirvInstrinsics.hasRoundingModeRTEFloat32 = false;
+	if (g_renderer->GetType() == RendererAPI::Vulkan)
+	{
+		options.useTFViaSSBO = VulkanRenderer::GetInstance()->UseTFViaSSBO();
+		options.spirvInstrinsics.hasRoundingModeRTEFloat32 = VulkanRenderer::GetInstance()->HasSPRIVRoundingModeRTE32();
+	}
+	options.strictMul = g_current_game_profile->GetAccurateShaderMul() != AccurateShaderMulOption::False;
+}
 
-LatteDecompilerShader* LatteShader_compileSeparableVertexShader(uint64 baseHash, uint64& vsAuxHash, uint8* vertexShaderPtr, uint32 vertexShaderSize, bool usesGeometryShader, LatteFetchShader* fetchShader)
+LatteDecompilerShader* LatteShader_CompileSeparableVertexShader2(uint64 baseHash, uint64& vsAuxHash, uint8* vertexShaderPtr, uint32 vertexShaderSize, bool usesGeometryShader, LatteFetchShader* fetchShader)
 {
 	/* Analyze shader to gather general information about inputs/outputs */
 	Latte::ShaderDescription shaderDescription;
@@ -724,14 +742,15 @@ LatteDecompilerShader* LatteShader_compileSeparableVertexShader(uint64 baseHash,
 // compile new vertex shader (relies partially on current state)
 LatteDecompilerShader* LatteShader_CompileSeparableVertexShader(uint64 baseHash, uint64& vsAuxHash, uint8* vertexShaderPtr, uint32 vertexShaderSize, bool usesGeometryShader, LatteFetchShader* fetchShader)
 {
-	// new decompiler
-	//LatteShader_compileSeparableVertexShader(baseHash, vsAuxHash, vertexShaderPtr, vertexShaderSize, usesGeometryShader, fetchShader);
+	// new decompiler test
+	//LatteShader_CompileSeparableVertexShader2(baseHash, vsAuxHash, vertexShaderPtr, vertexShaderSize, usesGeometryShader, fetchShader);
 
 	// legacy decompiler
+	LatteDecompilerOptions options;
+	LatteShader_GetDecompilerOptions(options, LatteConst::ShaderType::Vertex, usesGeometryShader);
+
 	LatteDecompilerOutput_t decompilerOutput{};
-	LatteFetchShader* fetchShaderList[1];
-	fetchShaderList[0] = fetchShader;
-	LatteDecompiler_DecompileVertexShader(_shaderBaseHash_vs, LatteGPUState.contextRegister, vertexShaderPtr, vertexShaderSize, fetchShaderList, 1, LatteGPUState.contextNew.GetSpecialStateValues(), usesGeometryShader, &decompilerOutput);
+	LatteDecompiler_DecompileVertexShader(_shaderBaseHash_vs, LatteGPUState.contextRegister, vertexShaderPtr, vertexShaderSize, fetchShader, options, &decompilerOutput);
 	LatteDecompilerShader* vertexShader = LatteShader_CreateShaderFromDecompilerOutput(decompilerOutput, baseHash, true, 0, LatteGPUState.contextRegister);
 	vsAuxHash = vertexShader->auxHash;
 	if (vertexShader->hasError == false)
@@ -758,10 +777,11 @@ LatteDecompilerShader* LatteShader_CompileSeparableVertexShader(uint64 baseHash,
 
 LatteDecompilerShader* LatteShader_CompileSeparableGeometryShader(uint64 baseHash, uint8* geometryShaderPtr, uint32 geometryShaderSize, uint8* geometryCopyShader, uint32 geometryCopyShaderSize)
 {
+	LatteDecompilerOptions options;
+	LatteShader_GetDecompilerOptions(options, LatteConst::ShaderType::Geometry, true);
+
 	LatteDecompilerOutput_t decompilerOutput{};
-	LatteFetchShader* fetchShaderList[1];
-	fetchShaderList[0] = _activeFetchShader;
-	LatteDecompiler_DecompileGeometryShader(_shaderBaseHash_gs, LatteGPUState.contextRegister, geometryShaderPtr, geometryShaderSize, geometryCopyShader, geometryCopyShaderSize, LatteGPUState.contextNew.GetSpecialStateValues(), _activeVertexShader->ringParameterCount, &decompilerOutput);
+	LatteDecompiler_DecompileGeometryShader(_shaderBaseHash_gs, LatteGPUState.contextRegister, geometryShaderPtr, geometryShaderSize, geometryCopyShader, geometryCopyShaderSize, _activeVertexShader->ringParameterCount, options, &decompilerOutput);
 	LatteDecompilerShader* geometryShader = LatteShader_CreateShaderFromDecompilerOutput(decompilerOutput, baseHash, true, 0, LatteGPUState.contextRegister);
 	if (geometryShader->hasError == false)
 	{
@@ -786,8 +806,11 @@ LatteDecompilerShader* LatteShader_CompileSeparableGeometryShader(uint64 baseHas
 
 LatteDecompilerShader* LatteShader_CompileSeparablePixelShader(uint64 baseHash, uint64& psAuxHash, uint8* pixelShaderPtr, uint32 pixelShaderSize, bool usesGeometryShader)
 {
+	LatteDecompilerOptions options;
+	LatteShader_GetDecompilerOptions(options, LatteConst::ShaderType::Pixel, usesGeometryShader);
+
 	LatteDecompilerOutput_t decompilerOutput{};
-	LatteDecompiler_DecompilePixelShader(baseHash, LatteGPUState.contextRegister, pixelShaderPtr, pixelShaderSize, LatteGPUState.contextNew.GetSpecialStateValues(), usesGeometryShader, &decompilerOutput);
+	LatteDecompiler_DecompilePixelShader(baseHash, LatteGPUState.contextRegister, pixelShaderPtr, pixelShaderSize, options, &decompilerOutput);
 	LatteDecompilerShader* pixelShader = LatteShader_CreateShaderFromDecompilerOutput(decompilerOutput, baseHash, true, 0, LatteGPUState.contextRegister);
 	psAuxHash = pixelShader->auxHash;
 	LatteShader_DumpShader(_shaderBaseHash_ps, psAuxHash, pixelShader);
@@ -812,6 +835,7 @@ LatteDecompilerShader* LatteShader_CompileSeparablePixelShader(uint64 baseHash,
 
 void LatteSHRC_UpdateVertexShader(uint8* vertexShaderPtr, uint32 vertexShaderSize, bool usesGeometryShader)
 {
+	// todo - should include VTX_SEMANTIC table in state
 	LatteSHRC_UpdateVSBaseHash(vertexShaderPtr, vertexShaderSize, usesGeometryShader);
 	uint64 vsAuxHash = 0;
 	auto itBaseShader = sVertexShaders.find(_shaderBaseHash_vs);
@@ -828,15 +852,13 @@ void LatteSHRC_UpdateVertexShader(uint8* vertexShaderPtr, uint32 vertexShaderSiz
 		LatteGPUState.activeShaderHasError = true;
 		return;
 	}
-	g_renderer->shader_bind(vertexShader->shader);
 	_activeVertexShader = vertexShader;
 }
 
 void LatteSHRC_UpdateGeometryShader(bool usesGeometryShader, uint8* geometryShaderPtr, uint32 geometryShaderSize, uint8* geometryCopyShader, uint32 geometryCopyShaderSize)
 {
-	if (usesGeometryShader == false || _activeVertexShader == nullptr)
+	if (!usesGeometryShader || !_activeVertexShader)
 	{
-		g_renderer->shader_unbind(RendererShader::ShaderType::kGeometry);
 		_shaderBaseHash_gs = 0;
 		_activeGeometryShader = nullptr;
 		return;
@@ -860,21 +882,11 @@ void LatteSHRC_UpdateGeometryShader(bool usesGeometryShader, uint8* geometryShad
 		LatteGPUState.activeShaderHasError = true;
 		return;
 	}
-	g_renderer->shader_bind(geometryShader->shader);
 	_activeGeometryShader = geometryShader;
 }
 
 void LatteSHRC_UpdatePixelShader(uint8* pixelShaderPtr, uint32 pixelShaderSize, bool usesGeometryShader)
 {
-	if (LatteGPUState.contextRegister[mmVGT_STRMOUT_EN] != 0 && g_renderer->GetType() == RendererAPI::OpenGL)
-	{
-		if (_activePixelShader)
-		{
-			g_renderer->shader_unbind(RendererShader::ShaderType::kFragment);
-			_activePixelShader = nullptr;
-		}
-		return;
-	}
 	LatteSHRC_UpdatePSBaseHash(pixelShaderPtr, pixelShaderSize, usesGeometryShader);
 	uint64 psAuxHash = 0;
 	auto itBaseShader = sPixelShaders.find(_shaderBaseHash_ps);
@@ -891,7 +903,6 @@ void LatteSHRC_UpdatePixelShader(uint8* pixelShaderPtr, uint32 pixelShaderSize,
 		LatteGPUState.activeShaderHasError = true;
 		return;
 	}
-	g_renderer->shader_bind(pixelShader->shader);
 	_activePixelShader = pixelShader;
 }
 
@@ -986,3 +997,16 @@ void LatteSHRC_Init()
 	cemu_assert_debug(sGeometryShaders.empty());
 	cemu_assert_debug(sPixelShaders.empty());
 }
+
+void LatteSHRC_UnloadAll()
+{
+    while(!sVertexShaders.empty())
+        LatteShader_free(sVertexShaders.begin()->second);
+    cemu_assert_debug(sVertexShaders.empty());
+    while(!sGeometryShaders.empty())
+        LatteShader_free(sGeometryShaders.begin()->second);
+    cemu_assert_debug(sGeometryShaders.empty());
+    while(!sPixelShaders.empty())
+        LatteShader_free(sPixelShaders.begin()->second);
+    cemu_assert_debug(sPixelShaders.empty());
+}
\ No newline at end of file
diff --git a/src/Cafe/HW/Latte/Core/LatteShader.h b/src/Cafe/HW/Latte/Core/LatteShader.h
index 0fba0322..f8dc6d1a 100644
--- a/src/Cafe/HW/Latte/Core/LatteShader.h
+++ b/src/Cafe/HW/Latte/Core/LatteShader.h
@@ -3,6 +3,7 @@
 #include "Cafe/HW/Latte/ISA/RegDefines.h"
 
 void LatteSHRC_Init();
+void LatteSHRC_UnloadAll();
 
 void LatteSHRC_ResetCachedShaderHash();
 void LatteShaderSHRC_UpdateFetchShader();
@@ -94,6 +95,7 @@ extern uint64 _shaderBaseHash_vs;
 extern uint64 _shaderBaseHash_gs;
 extern uint64 _shaderBaseHash_ps;
 
+void LatteShader_GetDecompilerOptions(struct LatteDecompilerOptions& options, LatteConst::ShaderType shaderType, bool geometryShaderEnabled);
 LatteDecompilerShader* LatteShader_CreateShaderFromDecompilerOutput(LatteDecompilerOutput_t& decompilerOutput, uint64 baseHash, bool calculateAuxHash, uint64 optionalAuxHash, uint32* contextRegister);
 
 void LatteShader_CreateRendererShader(LatteDecompilerShader* shader, bool compileAsync);
@@ -116,11 +118,12 @@ void LatteShader_DumpShader(uint64 baseHash, uint64 auxHash, LatteDecompilerShad
 void LatteShader_DumpRawShader(uint64 baseHash, uint64 auxHash, uint32 type, uint8* programCode, uint32 programLen);
 
 // shader cache file
-void LatteShaderCache_load();
+void LatteShaderCache_Load();
+void LatteShaderCache_Close();
 
 void LatteShaderCache_writeSeparableVertexShader(uint64 shaderBaseHash, uint64 shaderAuxHash, uint8* fetchShader, uint32 fetchShaderSize, uint8* vertexShader, uint32 vertexShaderSize, uint32* contextRegisters, bool usesGeometryShader);
 void LatteShaderCache_writeSeparableGeometryShader(uint64 shaderBaseHash, uint64 shaderAuxHash, uint8* geometryShader, uint32 geometryShaderSize, uint8* gsCopyShader, uint32 gsCopyShaderSize, uint32* contextRegisters, uint32* hleSpecialState, uint32 vsRingParameterCount);
 void LatteShaderCache_writeSeparablePixelShader(uint64 shaderBaseHash, uint64 shaderAuxHash, uint8* pixelShader, uint32 pixelShaderSize, uint32* contextRegisters, bool usesGeometryShader);
 
-// todo - sort this
+// todo - refactor this
 sint32 LatteDecompiler_getTextureSamplerBaseIndex(LatteConst::ShaderType shaderType);
\ No newline at end of file
diff --git a/src/Cafe/HW/Latte/Core/LatteShaderAssembly.h b/src/Cafe/HW/Latte/Core/LatteShaderAssembly.h
index df636689..d2314a53 100644
--- a/src/Cafe/HW/Latte/Core/LatteShaderAssembly.h
+++ b/src/Cafe/HW/Latte/Core/LatteShaderAssembly.h
@@ -12,7 +12,7 @@
 #define GPU7_CF_INST_VTX				(0x02) // used only in GS copy program?
 #define GPU7_CF_INST_LOOP_END			(0x05)
 #define GPU7_CF_INST_LOOP_START_DX10	(0x06)
-#define GPU7_CF_INST_LOOP_START_NO_AL	(0x07) // (Seen in Project Zero)
+#define GPU7_CF_INST_LOOP_START_NO_AL	(0x07) // (Seen in Project Zero, Injustice: Gods Among Us)
 
 #define GPU7_CF_INST_LOOP_BREAK			(0x09)
 #define GPU7_CF_INST_JUMP				(0x0A)
diff --git a/src/Cafe/HW/Latte/Core/LatteShaderCache.cpp b/src/Cafe/HW/Latte/Core/LatteShaderCache.cpp
index ebf425bc..86035973 100644
--- a/src/Cafe/HW/Latte/Core/LatteShaderCache.cpp
+++ b/src/Cafe/HW/Latte/Core/LatteShaderCache.cpp
@@ -25,6 +25,9 @@
 #include "util/helpers/Serializer.h"
 
 #include <wx/msgdlg.h>
+#include <audio/IAudioAPI.h>
+#include <util/bootSound/BootSoundReader.h>
+#include <thread>
 
 #if BOOST_OS_WINDOWS
 #include <psapi.h>
@@ -43,7 +46,8 @@ struct
 
 struct  
 {
-	ImTextureID textureId;
+	ImTextureID textureTVId;
+	ImTextureID textureDRCId;
 	// shader loading
 	sint32 loadedShaderFiles;
 	sint32 shaderFileCount;
@@ -52,7 +56,7 @@ struct
 	sint32 pipelineFileCount;
 }g_shaderCacheLoaderState;
 
-FileCache* fc_shaderCacheGeneric = nullptr;	// contains hardware and Cemu version independent shader information
+FileCache* s_shaderCacheGeneric = nullptr;	// contains hardware and version independent shader information
 
 #define SHADER_CACHE_GENERIC_EXTRA_VERSION		2 // changing this constant will invalidate all hardware-independent cache files
 
@@ -61,7 +65,7 @@ FileCache* fc_shaderCacheGeneric = nullptr;	// contains hardware and Cemu versio
 #define SHADER_CACHE_TYPE_PIXEL					(2)
 
 bool LatteShaderCache_readSeparableShader(uint8* shaderInfoData, sint32 shaderInfoSize);
-void LatteShaderCache_loadVulkanPipelineCache(uint64 cacheTitleId);
+void LatteShaderCache_LoadVulkanPipelineCache(uint64 cacheTitleId);
 bool LatteShaderCache_updatePipelineLoadingProgress();
 void LatteShaderCache_ShowProgress(const std::function <bool(void)>& loadUpdateFunc, bool isPipelines);
 
@@ -154,6 +158,118 @@ bool LoadTGAFile(const std::vector<uint8>& buffer, TGAFILE *tgaFile)
 	return true;
 }
 
+class BootSoundPlayer
+{
+  public:
+	BootSoundPlayer() = default;
+	~BootSoundPlayer()
+	{
+		m_stopRequested = true;
+	}
+
+	void StartSound()
+	{
+		if (!m_bootSndPlayThread.joinable())
+		{
+			m_fadeOutRequested = false;
+			m_stopRequested = false;
+			m_bootSndPlayThread = std::thread{[this]() {
+				StreamBootSound();
+			}};
+		}
+	}
+
+	void FadeOutSound()
+	{
+		m_fadeOutRequested = true;
+	}
+
+	void ApplyFadeOutEffect(std::span<sint16> samples, uint64& fadeOutSample, uint64 fadeOutDuration)
+	{
+		for (size_t i = 0; i < samples.size(); i += 2)
+		{
+			const float decibel = (float)fadeOutSample / fadeOutDuration * -60.0f;
+			const float volumeFactor = pow(10, decibel / 20);
+			samples[i] *= volumeFactor;
+			samples[i + 1] *= volumeFactor;
+			fadeOutSample++;
+		}
+	}
+
+	void StreamBootSound()
+	{
+		SetThreadName("bootsnd");
+		constexpr sint32 sampleRate = 48'000;
+		constexpr sint32 bitsPerSample = 16;
+		constexpr sint32 samplesPerBlock = sampleRate / 10; // block is 1/10th of a second
+		constexpr sint32 nChannels = 2;
+		static_assert(bitsPerSample % 8 == 0, "bits per sample is not a multiple of 8");
+
+		AudioAPIPtr bootSndAudioDev;
+
+		try
+		{
+			bootSndAudioDev = IAudioAPI::CreateDeviceFromConfig(IAudioAPI::AudioType::TV, sampleRate, nChannels, samplesPerBlock, bitsPerSample);
+			if(!bootSndAudioDev)
+				return;
+		}
+		catch (const std::runtime_error& ex)
+		{
+			cemuLog_log(LogType::Force, "Failed to initialise audio device for bootup sound");
+			return;
+		}
+		bootSndAudioDev->SetAudioDelayOverride(4);
+		bootSndAudioDev->Play();
+
+		std::string sndPath = fmt::format("{}/meta/{}", CafeSystem::GetMlcStoragePath(CafeSystem::GetForegroundTitleId()), "bootSound.btsnd");
+		sint32 fscStatus = FSC_STATUS_UNDEFINED;
+
+		if(!fsc_doesFileExist(sndPath.c_str()))
+			return;
+
+		FSCVirtualFile* bootSndFileHandle = fsc_open(sndPath.c_str(), FSC_ACCESS_FLAG::OPEN_FILE | FSC_ACCESS_FLAG::READ_PERMISSION, &fscStatus);
+		if(!bootSndFileHandle)
+		{
+			cemuLog_log(LogType::Force, "failed to open bootSound.btsnd");
+			return;
+		}
+
+		constexpr sint32 audioBlockSize = samplesPerBlock * (bitsPerSample/8) * nChannels;
+		BootSoundReader bootSndFileReader(bootSndFileHandle, audioBlockSize);
+
+		uint64 fadeOutSample = 0; // track how far into the fadeout
+		constexpr uint64 fadeOutDuration = sampleRate * 2; // fadeout should last 2 seconds
+		while(fadeOutSample < fadeOutDuration && !m_stopRequested)
+		{
+			while (bootSndAudioDev->NeedAdditionalBlocks())
+			{
+				sint16* data = bootSndFileReader.getSamples();
+				if(data == nullptr)
+				{
+					// break outer loop
+					m_stopRequested = true;
+					break;
+				}
+				if(m_fadeOutRequested)
+					ApplyFadeOutEffect({data, samplesPerBlock * nChannels}, fadeOutSample, fadeOutDuration);
+
+				bootSndAudioDev->FeedBlock(data);
+			}
+			// sleep for the duration of a single block
+			std::this_thread::sleep_for(std::chrono::milliseconds(samplesPerBlock / (sampleRate/ 1'000)));
+		}
+
+		if(bootSndFileHandle)
+			fsc_close(bootSndFileHandle);
+	}
+
+  private:
+	std::thread m_bootSndPlayThread;
+	std::atomic_bool m_fadeOutRequested = false;
+	std::atomic_bool m_stopRequested = false;
+};
+static BootSoundPlayer g_bootSndPlayer;
+
 void LatteShaderCache_finish()
 {
 	if (g_renderer->GetType() == RendererAPI::Vulkan)
@@ -177,7 +293,45 @@ uint32 LatteShaderCache_getPipelineCacheExtraVersion(uint64 titleId)
 	return extraVersion;
 }
 
-void LatteShaderCache_load()
+void LatteShaderCache_drawBackgroundImage(ImTextureID texture, int width, int height)
+{
+	// clear framebuffers and clean up
+	const auto kPopupFlags =
+			ImGuiWindowFlags_NoMove | ImGuiWindowFlags_NoDecoration | ImGuiWindowFlags_NoSavedSettings |
+			ImGuiWindowFlags_NoFocusOnAppearing | ImGuiWindowFlags_NoNav | ImGuiWindowFlags_AlwaysAutoResize |
+			ImGuiWindowFlags_NoBringToFrontOnFocus;
+	auto& io = ImGui::GetIO();
+	ImGui::SetNextWindowPos({0, 0}, ImGuiCond_Always);
+	ImGui::SetNextWindowSize(io.DisplaySize, ImGuiCond_Always);
+	ImGui::PushStyleVar(ImGuiStyleVar_WindowBorderSize, 0);
+	ImGui::PushStyleVar(ImGuiStyleVar_WindowPadding, {0, 0});
+	if (ImGui::Begin("Background texture", nullptr, kPopupFlags))
+	{
+		if (texture)
+		{
+			float imageDisplayWidth = io.DisplaySize.x;
+			float imageDisplayHeight = height * imageDisplayWidth / width;
+
+			float paddingLeftAndRight = 0.0f;
+			float paddingTopAndBottom = (io.DisplaySize.y - imageDisplayHeight) / 2.0f;
+			if (imageDisplayHeight > io.DisplaySize.y)
+			{
+				imageDisplayHeight = io.DisplaySize.y;
+				imageDisplayWidth = width * imageDisplayHeight / height;
+				paddingLeftAndRight = (io.DisplaySize.x - imageDisplayWidth) / 2.0f;
+				paddingTopAndBottom = 0.0f;
+			}
+
+			ImGui::GetWindowDrawList()->AddImage(texture, ImVec2(paddingLeftAndRight, paddingTopAndBottom),
+												 ImVec2(io.DisplaySize.x - paddingLeftAndRight,
+														io.DisplaySize.y - paddingTopAndBottom), {0, 1}, {1, 0});
+		}
+	}
+	ImGui::End();
+	ImGui::PopStyleVar(2);
+}
+
+void LatteShaderCache_Load()
 {
 	shaderCacheScreenStats.compiledShaderCount = 0;
 	shaderCacheScreenStats.vertexShaderCount = 0;
@@ -197,73 +351,84 @@ void LatteShaderCache_load()
 	LatteShaderCache_initCompileQueue();
 	// create directories
 	std::error_code ec;
-	fs::create_directories(ActiveSettings::GetPath("shaderCache/transferable"), ec);
-	fs::create_directories(ActiveSettings::GetPath("shaderCache/precompiled"), ec);
+	fs::create_directories(ActiveSettings::GetCachePath("shaderCache/transferable"), ec);
+	fs::create_directories(ActiveSettings::GetCachePath("shaderCache/precompiled"), ec);
 	// initialize renderer specific caches
 	if (g_renderer->GetType() == RendererAPI::Vulkan)
 		RendererShaderVk::ShaderCacheLoading_begin(cacheTitleId);
 	else if (g_renderer->GetType() == RendererAPI::OpenGL)
 		RendererShaderGL::ShaderCacheLoading_begin(cacheTitleId);
 	// get cache file name
-	const auto pathGeneric = ActiveSettings::GetPath("shaderCache/transferable/{:016x}_shaders.bin", cacheTitleId);
-	const auto pathGenericPre1_25_0 = ActiveSettings::GetPath("shaderCache/transferable/{:016x}.bin", cacheTitleId); // before 1.25.0
-	const auto pathGenericPre1_16_0 = ActiveSettings::GetPath("shaderCache/transferable/{:08x}.bin", CafeSystem::GetRPXHashBase()); // before 1.16.0
+	const auto pathGeneric = ActiveSettings::GetCachePath("shaderCache/transferable/{:016x}_shaders.bin", cacheTitleId);
+	const auto pathGenericPre1_25_0 = ActiveSettings::GetCachePath("shaderCache/transferable/{:016x}.bin", cacheTitleId); // before 1.25.0
+	const auto pathGenericPre1_16_0 = ActiveSettings::GetCachePath("shaderCache/transferable/{:08x}.bin", CafeSystem::GetRPXHashBase()); // before 1.16.0
 
 	LatteShaderCache_handleDeprecatedCacheFiles(pathGeneric, pathGenericPre1_25_0, pathGenericPre1_16_0);
 	// calculate extraVersion for transferable and precompiled shader cache
 	uint32 transferableExtraVersion = SHADER_CACHE_GENERIC_EXTRA_VERSION;
-	fc_shaderCacheGeneric = FileCache::Open(pathGeneric.generic_wstring(), false, transferableExtraVersion); // legacy extra version (1.25.0 - 1.25.1b)
-	if(!fc_shaderCacheGeneric)
-		fc_shaderCacheGeneric = FileCache::Open(pathGeneric.generic_wstring(), true, LatteShaderCache_getShaderCacheExtraVersion(cacheTitleId));
-	if(!fc_shaderCacheGeneric)
+    s_shaderCacheGeneric = FileCache::Open(pathGeneric, false, transferableExtraVersion); // legacy extra version (1.25.0 - 1.25.1b)
+	if(!s_shaderCacheGeneric)
+        s_shaderCacheGeneric = FileCache::Open(pathGeneric, true, LatteShaderCache_getShaderCacheExtraVersion(cacheTitleId));
+	if(!s_shaderCacheGeneric)
 	{
 		// no shader cache available yet
-		forceLog_printfW(L"Unable to open or create shader cache file \"%s\"", pathGeneric.c_str());		
+		cemuLog_log(LogType::Force, "Unable to open or create shader cache file \"{}\"", _pathToUtf8(pathGeneric));
 		LatteShaderCache_finish();
 		return;
 	}
-	fc_shaderCacheGeneric->UseCompression(false);
+	s_shaderCacheGeneric->UseCompression(false);
 
 	// load/compile cached shaders
-	sint32 entryCount = fc_shaderCacheGeneric->GetMaximumFileIndex();
-	g_shaderCacheLoaderState.shaderFileCount = fc_shaderCacheGeneric->GetFileCount();
+	sint32 entryCount = s_shaderCacheGeneric->GetMaximumFileIndex();
+	g_shaderCacheLoaderState.shaderFileCount = s_shaderCacheGeneric->GetFileCount();
 	g_shaderCacheLoaderState.loadedShaderFiles = 0;
 
 	// get game background loading image
-	TGAFILE file{};
-	g_shaderCacheLoaderState.textureId = nullptr;
-
-	std::string tvTexPath = fmt::format("{}/meta/bootTvTex.tga", CafeSystem::GetMlcStoragePath(CafeSystem::GetForegroundTitleId()));
-	sint32 status;
-	auto fscfile = fsc_open(tvTexPath.c_str(), FSC_ACCESS_FLAG::OPEN_FILE | FSC_ACCESS_FLAG::READ_PERMISSION, &status);
-	if (fscfile)
+	auto loadBackgroundTexture = [](bool isTV, ImTextureID& out)
 	{
-		uint32 size = fsc_getFileSize(fscfile);
-		if (size > 0)
+		TGAFILE file{};
+		out = nullptr;
+
+		std::string fileName = isTV ? "bootTvTex.tga" : "bootDRCTex.tga";
+
+		std::string texPath = fmt::format("{}/meta/{}", CafeSystem::GetMlcStoragePath(CafeSystem::GetForegroundTitleId()), fileName);
+		sint32 status;
+		auto fscfile = fsc_open(texPath.c_str(), FSC_ACCESS_FLAG::OPEN_FILE | FSC_ACCESS_FLAG::READ_PERMISSION, &status);
+		if (fscfile)
 		{
-			std::vector<uint8> tmpData(size);
-			fsc_readFile(fscfile, tmpData.data(), size);
-			const bool backgroundLoaded = LoadTGAFile(tmpData, &file);
+			uint32 size = fsc_getFileSize(fscfile);
+			if (size > 0)
+			{
+				std::vector<uint8> tmpData(size);
+				fsc_readFile(fscfile, tmpData.data(), size);
+				const bool backgroundLoaded = LoadTGAFile(tmpData, &file);
 
-			if (backgroundLoaded)
-				g_shaderCacheLoaderState.textureId = g_renderer->GenerateTexture(file.imageData, { file.imageWidth, file.imageHeight });
+				if (backgroundLoaded)
+					out = g_renderer->GenerateTexture(file.imageData, { file.imageWidth, file.imageHeight });
+			}
+
+			fsc_close(fscfile);
 		}
+	};
 
-		fsc_close(fscfile);
-	}
+	loadBackgroundTexture(true, g_shaderCacheLoaderState.textureTVId);
+	loadBackgroundTexture(false, g_shaderCacheLoaderState.textureDRCId);
+
+	if(GetConfig().play_boot_sound)
+		g_bootSndPlayer.StartSound();
 
 	sint32 numLoadedShaders = 0;
 	uint32 loadIndex = 0;
 
 	auto LoadShadersUpdate = [&]() -> bool
 	{
-		if (loadIndex >= (uint32)fc_shaderCacheGeneric->GetMaximumFileIndex())
+		if (loadIndex >= (uint32)s_shaderCacheGeneric->GetMaximumFileIndex())
 			return false;
 		LatteShaderCache_updateCompileQueue(SHADER_CACHE_COMPILE_QUEUE_SIZE - 2);
 		uint64 name1;
 		uint64 name2;
 		std::vector<uint8> fileData;
-		if (!fc_shaderCacheGeneric->GetFileByIndex(loadIndex, &name1, &name2, fileData))
+		if (!s_shaderCacheGeneric->GetFileByIndex(loadIndex, &name1, &name2, fileData))
 		{
 			loadIndex++;
 			return true;
@@ -272,8 +437,8 @@ void LatteShaderCache_load()
 		if (LatteShaderCache_readSeparableShader(fileData.data(), fileData.size()) == false)
 		{
 			// something is wrong with the stored shader, remove entry from shader cache files
-			forceLog_printf("Shader cache entry %d invalid, deleting...", loadIndex);
-			fc_shaderCacheGeneric->DeleteFile({ name1, name2 });
+			cemuLog_log(LogType::Force, "Shader cache entry {} invalid, deleting...", loadIndex);
+			s_shaderCacheGeneric->DeleteFile({name1, name2 });
 		}
 		numLoadedShaders++;
 		loadIndex++;
@@ -291,60 +456,42 @@ void LatteShaderCache_load()
 	GetProcessMemoryInfo(GetCurrentProcess(), &pmc2, sizeof(PROCESS_MEMORY_COUNTERS));
 	LONGLONG totalMem2 = pmc2.PagefileUsage;
 	LONGLONG memCommited = totalMem2 - totalMem1;
-	forceLog_printf("Shader cache loaded with %d shaders. Commited mem %dMB. Took %dms", numLoadedShaders, (sint32)(memCommited/1024/1024), timeLoad);
+	cemuLog_log(LogType::Force, "Shader cache loaded with {} shaders. Commited mem {}MB. Took {}ms", numLoadedShaders, (sint32)(memCommited/1024/1024), timeLoad);
 #endif
 	LatteShaderCache_finish();
 	// if Vulkan then also load pipeline cache
 	if (g_renderer->GetType() == RendererAPI::Vulkan)
-		LatteShaderCache_loadVulkanPipelineCache(cacheTitleId);
+        LatteShaderCache_LoadVulkanPipelineCache(cacheTitleId);
 
-	// clear framebuffers and clean up
-	auto& io = ImGui::GetIO();
-	const auto kPopupFlags = ImGuiWindowFlags_NoMove | ImGuiWindowFlags_NoDecoration | ImGuiWindowFlags_NoSavedSettings | ImGuiWindowFlags_NoFocusOnAppearing | ImGuiWindowFlags_NoNav | ImGuiWindowFlags_AlwaysAutoResize;
-	for (int i = 0; i < 2; ++i)
+
+	g_renderer->BeginFrame(true);
+	if (g_renderer->ImguiBegin(true))
 	{
-		g_renderer->BeginFrame(true);
-		if (g_renderer->ImguiBegin(true))
-		{
-			ImGui::SetNextWindowPos({ 0,0 }, ImGuiCond_Always);
-			ImGui::SetNextWindowSize(io.DisplaySize, ImGuiCond_Always);
-			ImGui::PushStyleVar(ImGuiStyleVar_WindowBorderSize, 0);
-			ImGui::PushStyleVar(ImGuiStyleVar_WindowPadding, { 0,0 });
-			if (ImGui::Begin("Background texture", nullptr, kPopupFlags))
-			{
-				if (g_shaderCacheLoaderState.textureId)
-				{
-					float imageDisplayWidth = io.DisplaySize.x;
-					float imageDisplayHeight = 720 * imageDisplayWidth / 1280;
-
-					float paddingLeftAndRight = 0.0f;
-					float paddingTopAndBottom = (io.DisplaySize.y - imageDisplayHeight)/2.0f;
-					if (imageDisplayHeight > io.DisplaySize.y)
-					{
-						imageDisplayHeight = io.DisplaySize.y;
-						imageDisplayWidth = 1280 * imageDisplayHeight / 720;
-						paddingLeftAndRight = (io.DisplaySize.x - imageDisplayWidth)/2.0f;
-						paddingTopAndBottom = 0.0f;
-					}
-
-					ImGui::GetWindowDrawList()->AddImage(g_shaderCacheLoaderState.textureId, ImVec2(paddingLeftAndRight, paddingTopAndBottom), ImVec2(io.DisplaySize.x-paddingLeftAndRight, io.DisplaySize.y-paddingTopAndBottom), { 0,1 }, { 1,0 });
-				}
-				ImGui::End();
-			}
-			ImGui::PopStyleVar(2);
-
-			g_renderer->ImguiEnd();
-		}
-		g_renderer->SwapBuffers(true, true);
+		LatteShaderCache_drawBackgroundImage(g_shaderCacheLoaderState.textureTVId, 1280, 720);
+		g_renderer->ImguiEnd();
+	}
+	g_renderer->BeginFrame(false);
+	if (g_renderer->ImguiBegin(false))
+	{
+		LatteShaderCache_drawBackgroundImage(g_shaderCacheLoaderState.textureDRCId, 854, 480);
+		g_renderer->ImguiEnd();
 	}
 
-	if (g_shaderCacheLoaderState.textureId)
-		g_renderer->DeleteTexture(g_shaderCacheLoaderState.textureId);
+	g_renderer->SwapBuffers(true, true);
+
+	if (g_shaderCacheLoaderState.textureTVId)
+		g_renderer->DeleteTexture(g_shaderCacheLoaderState.textureTVId);
+	if (g_shaderCacheLoaderState.textureDRCId)
+		g_renderer->DeleteTexture(g_shaderCacheLoaderState.textureDRCId);
+
+	g_bootSndPlayer.FadeOutSound();
+
+	if(Latte_GetStopSignal())
+		LatteThread_Exit();
 }
 
 void LatteShaderCache_ShowProgress(const std::function <bool(void)>& loadUpdateFunc, bool isPipelines)
 {
-	auto& io = ImGui::GetIO();
 	const auto kPopupFlags = ImGuiWindowFlags_NoMove | ImGuiWindowFlags_NoDecoration | ImGuiWindowFlags_NoSavedSettings | ImGuiWindowFlags_NoFocusOnAppearing | ImGuiWindowFlags_NoNav | ImGuiWindowFlags_AlwaysAutoResize;
 	const auto textColor = 0xFF888888;
 	
@@ -352,6 +499,8 @@ void LatteShaderCache_ShowProgress(const std::function <bool(void)>& loadUpdateF
 
 	while (true)
 	{
+        if (Latte_GetStopSignal())
+            break; // thread stop requested, cancel shader loading
 		bool r = loadUpdateFunc();
 		if (!r)
 			break;
@@ -362,7 +511,7 @@ void LatteShaderCache_ShowProgress(const std::function <bool(void)>& loadUpdateF
 			continue;
 
 		int w, h;
-		gui_getWindowSize(&w, &h);
+		gui_getWindowPhysSize(w, h);
 		const Vector2f window_size{ (float)w,(float)h };
 
 		ImGui_GetFont(window_size.y / 32.0f); // = 24 by default
@@ -371,35 +520,13 @@ void LatteShaderCache_ShowProgress(const std::function <bool(void)>& loadUpdateF
 		g_renderer->BeginFrame(true);
 		if (g_renderer->ImguiBegin(true))
 		{
+			auto& io = ImGui::GetIO();
+
+			// render background texture
+			LatteShaderCache_drawBackgroundImage(g_shaderCacheLoaderState.textureTVId, 1280, 720);
+
 			const auto progress_font = ImGui_GetFont(window_size.y / 32.0f); // = 24 by default
 			const auto shader_count_font = ImGui_GetFont(window_size.y / 48.0f); // = 16
-			// render background texture
-			if (g_shaderCacheLoaderState.textureId)
-			{
-				ImGui::SetNextWindowPos({ 0, 0 }, ImGuiCond_Always);
-				ImGui::SetNextWindowSize(io.DisplaySize, ImGuiCond_Always);
-				ImGui::PushStyleVar(ImGuiStyleVar_WindowBorderSize, 0);
-				ImGui::PushStyleVar(ImGuiStyleVar_WindowPadding, { 0, 0 });
-				if (ImGui::Begin("Background texture", nullptr, kPopupFlags | ImGuiWindowFlags_NoBringToFrontOnFocus))
-				{
-					float imageDisplayWidth = io.DisplaySize.x;
-					float imageDisplayHeight = 720 * imageDisplayWidth / 1280;
-
-					float paddingLeftAndRight = 0.0f;
-					float paddingTopAndBottom = (io.DisplaySize.y - imageDisplayHeight) / 2.0f;
-					if (imageDisplayHeight > io.DisplaySize.y)
-					{
-						imageDisplayHeight = io.DisplaySize.y;
-						imageDisplayWidth = 1280 * imageDisplayHeight / 720;
-						paddingLeftAndRight = (io.DisplaySize.x - imageDisplayWidth) / 2.0f;
-						paddingTopAndBottom = 0.0f;
-					}
-
-					ImGui::GetWindowDrawList()->AddImage(g_shaderCacheLoaderState.textureId, ImVec2(paddingLeftAndRight, paddingTopAndBottom), ImVec2(io.DisplaySize.x-paddingLeftAndRight, io.DisplaySize.y-paddingTopAndBottom), { 0,1 }, { 1,0 });
-					ImGui::End();
-				}
-				ImGui::PopStyleVar(2);
-			}
 
 			ImVec2 position = { window_size.x / 2.0f, window_size.y / 2.0f };
 			ImVec2 pivot = { 0.5f, 0.5f };
@@ -446,8 +573,8 @@ void LatteShaderCache_ShowProgress(const std::function <bool(void)>& loadUpdateF
 					text = fmt::format("{}/{} ({}%)", g_shaderCacheLoaderState.loadedShaderFiles, g_shaderCacheLoaderState.shaderFileCount, (int)(percentLoaded * 100));
 				ImGui::SetCursorPosX(width - ImGui::CalcTextSize(text.c_str()).x / 2);
 				ImGui::Text("%s", text.c_str());
-				ImGui::End();
 			}
+			ImGui::End();
 			ImGui::PopFont();
 			ImGui::PopStyleColor(2);
 
@@ -473,23 +600,28 @@ void LatteShaderCache_ShowProgress(const std::function <bool(void)>& loadUpdateF
 					ImGui::Text("Geometry shaders");
 					ImGui::SameLine(offset);
 					ImGui::Text("%d", shaderCacheScreenStats.geometryShaderCount);
-
-					ImGui::End();
 				}
+				ImGui::End();
 				ImGui::PopStyleColor();
 				ImGui::PopFont();
 			}
-
 			g_renderer->ImguiEnd();
 			lastFrameUpdate = tick_cached();
 		}
 
+		g_renderer->BeginFrame(false);
+		if (g_renderer->ImguiBegin(false))
+		{
+			LatteShaderCache_drawBackgroundImage(g_shaderCacheLoaderState.textureDRCId, 854, 480);
+			g_renderer->ImguiEnd();
+		}
+
 		// finish frame
 		g_renderer->SwapBuffers(true, true);
 	}
 }
 
-void LatteShaderCache_loadVulkanPipelineCache(uint64 cacheTitleId)
+void LatteShaderCache_LoadVulkanPipelineCache(uint64 cacheTitleId)
 {
 	auto& pipelineCache = VulkanPipelineStableCache::GetInstance();
 	g_shaderCacheLoaderState.pipelineFileCount = pipelineCache.BeginLoading(cacheTitleId);
@@ -513,7 +645,7 @@ uint64 LatteShaderCache_getShaderNameInTransferableCache(uint64 baseHash, uint32
 
 void LatteShaderCache_writeSeparableVertexShader(uint64 shaderBaseHash, uint64 shaderAuxHash, uint8* fetchShader, uint32 fetchShaderSize, uint8* vertexShader, uint32 vertexShaderSize, uint32* contextRegisters, bool usesGeometryShader)
 {
-	if (!fc_shaderCacheGeneric)
+	if (!s_shaderCacheGeneric)
 		return;
 	MemStreamWriter streamWriter(128 * 1024);
 	// header
@@ -532,12 +664,12 @@ void LatteShaderCache_writeSeparableVertexShader(uint64 shaderBaseHash, uint64 s
 	// write to cache
 	uint64 shaderCacheName = LatteShaderCache_getShaderNameInTransferableCache(shaderBaseHash, SHADER_CACHE_TYPE_VERTEX);
 	std::span<uint8> dataBlob = streamWriter.getResult();
-	fc_shaderCacheGeneric->AddFileAsync({ shaderCacheName, shaderAuxHash }, dataBlob.data(), dataBlob.size());
+	s_shaderCacheGeneric->AddFileAsync({shaderCacheName, shaderAuxHash }, dataBlob.data(), dataBlob.size());
 }
 
 void LatteShaderCache_writeSeparableGeometryShader(uint64 shaderBaseHash, uint64 shaderAuxHash, uint8* geometryShader, uint32 geometryShaderSize, uint8* gsCopyShader, uint32 gsCopyShaderSize, uint32* contextRegisters, uint32* hleSpecialState, uint32 vsRingParameterCount)
 {
-	if (!fc_shaderCacheGeneric)
+	if (!s_shaderCacheGeneric)
 		return;
 	MemStreamWriter streamWriter(128 * 1024);
 	// header
@@ -557,12 +689,12 @@ void LatteShaderCache_writeSeparableGeometryShader(uint64 shaderBaseHash, uint64
 	// write to cache
 	uint64 shaderCacheName = LatteShaderCache_getShaderNameInTransferableCache(shaderBaseHash, SHADER_CACHE_TYPE_GEOMETRY);
 	std::span<uint8> dataBlob = streamWriter.getResult();
-	fc_shaderCacheGeneric->AddFileAsync({ shaderCacheName, shaderAuxHash }, dataBlob.data(), dataBlob.size());
+	s_shaderCacheGeneric->AddFileAsync({shaderCacheName, shaderAuxHash }, dataBlob.data(), dataBlob.size());
 }
 
 void LatteShaderCache_writeSeparablePixelShader(uint64 shaderBaseHash, uint64 shaderAuxHash, uint8* pixelShader, uint32 pixelShaderSize, uint32* contextRegisters, bool usesGeometryShader)
 {
-	if (!fc_shaderCacheGeneric)
+	if (!s_shaderCacheGeneric)
 		return;
 	MemStreamWriter streamWriter(128 * 1024);
 	streamWriter.writeBE<uint8>(1 | (SHADER_CACHE_TYPE_PIXEL << 4)); // version and type (shared field)
@@ -578,7 +710,7 @@ void LatteShaderCache_writeSeparablePixelShader(uint64 shaderBaseHash, uint64 sh
 	// write to cache
 	uint64 shaderCacheName = LatteShaderCache_getShaderNameInTransferableCache(shaderBaseHash, SHADER_CACHE_TYPE_PIXEL);
 	std::span<uint8> dataBlob = streamWriter.getResult();
-	fc_shaderCacheGeneric->AddFileAsync({ shaderCacheName, shaderAuxHash }, dataBlob.data(), dataBlob.size());
+	s_shaderCacheGeneric->AddFileAsync({shaderCacheName, shaderAuxHash }, dataBlob.data(), dataBlob.size());
 }
 
 void LatteShaderCache_loadOrCompileSeparableShader(LatteDecompilerShader* shader, uint64 shaderBaseHash, uint64 shaderAuxHash)
@@ -609,7 +741,7 @@ void LatteShaderCache_loadOrCompileSeparableShader(LatteDecompilerShader* shader
 
 bool LatteShaderCache_readSeparableVertexShader(MemStreamReader& streamReader, uint8 version)
 {
-	std::unique_ptr<LatteContextRegister> lcr(new LatteContextRegister());
+	auto lcr = std::make_unique<LatteContextRegister>();
 	if (version != 1)
 		return false;
 	uint64 shaderBaseHash = streamReader.readBE<uint64>();
@@ -634,22 +766,22 @@ bool LatteShaderCache_readSeparableVertexShader(MemStreamReader& streamReader, u
 		return false;
 	if (streamReader.hasError() || !streamReader.isEndOfStream())
 		return false;
-	// update PS inputs (influence VS shader outputs)
+	// update PS inputs (affects VS shader outputs)
 	LatteShader_UpdatePSInputs(lcr->GetRawView());
 	// get fetch shader
 	LatteFetchShader::CacheHash fsHash = LatteFetchShader::CalculateCacheHash((uint32*)fetchShaderData.data(), fetchShaderData.size());
 	LatteFetchShader* fetchShader = LatteShaderRecompiler_createFetchShader(fsHash, lcr->GetRawView(), (uint32*)fetchShaderData.data(), fetchShaderData.size());
+	// determine decompiler options
+	LatteDecompilerOptions options;
+	LatteShader_GetDecompilerOptions(options, LatteConst::ShaderType::Vertex, usesGeometryShader);
 	// decompile vertex shader
 	LatteDecompilerOutput_t decompilerOutput{};
-	LatteFetchShader* fetchShaderList[1];
-	fetchShaderList[0] = fetchShader;
-	LatteDecompiler_DecompileVertexShader(shaderBaseHash, lcr->GetRawView(), vertexShaderData.data(), vertexShaderData.size(), fetchShaderList, 1, lcr->GetSpecialStateValues(), usesGeometryShader, &decompilerOutput);
+	LatteDecompiler_DecompileVertexShader(shaderBaseHash, lcr->GetRawView(), vertexShaderData.data(), vertexShaderData.size(), fetchShader, options, &decompilerOutput);
 	LatteDecompilerShader* vertexShader = LatteShader_CreateShaderFromDecompilerOutput(decompilerOutput, shaderBaseHash, false, shaderAuxHash, lcr->GetRawView());
 	// compile
 	LatteShader_DumpShader(shaderBaseHash, shaderAuxHash, vertexShader);
 	LatteShader_DumpRawShader(shaderBaseHash, shaderAuxHash, SHADER_DUMP_TYPE_VERTEX, vertexShaderData.data(), vertexShaderData.size());
 	LatteShaderCache_loadOrCompileSeparableShader(vertexShader, shaderBaseHash, shaderAuxHash);
-	catchOpenGLError();
 	LatteSHRC_RegisterShader(vertexShader, shaderBaseHash, shaderAuxHash);
 	return true;
 }
@@ -658,7 +790,7 @@ bool LatteShaderCache_readSeparableGeometryShader(MemStreamReader& streamReader,
 {
 	if (version != 1)
 		return false;
-	std::unique_ptr<LatteContextRegister> lcr(new LatteContextRegister());
+	auto lcr = std::make_unique<LatteContextRegister>();
 	uint64 shaderBaseHash = streamReader.readBE<uint64>();
 	uint64 shaderAuxHash = streamReader.readBE<uint64>();
 	uint32 vsRingParameterCount = streamReader.readBE<uint16>();
@@ -681,15 +813,17 @@ bool LatteShaderCache_readSeparableGeometryShader(MemStreamReader& streamReader,
 		return false;
 	// update PS inputs
 	LatteShader_UpdatePSInputs(lcr->GetRawView());
+	// determine decompiler options
+	LatteDecompilerOptions options;
+	LatteShader_GetDecompilerOptions(options, LatteConst::ShaderType::Geometry, true);
 	// decompile geometry shader
 	LatteDecompilerOutput_t decompilerOutput{};
-	LatteDecompiler_DecompileGeometryShader(shaderBaseHash, lcr->GetRawView(), geometryShaderData.data(), geometryShaderData.size(), geometryCopyShaderData.data(), geometryCopyShaderData.size(), lcr->GetSpecialStateValues(), vsRingParameterCount, &decompilerOutput);
+	LatteDecompiler_DecompileGeometryShader(shaderBaseHash, lcr->GetRawView(), geometryShaderData.data(), geometryShaderData.size(), geometryCopyShaderData.data(), geometryCopyShaderData.size(), vsRingParameterCount, options, &decompilerOutput);
 	LatteDecompilerShader* geometryShader = LatteShader_CreateShaderFromDecompilerOutput(decompilerOutput, shaderBaseHash, false, shaderAuxHash, lcr->GetRawView());
 	// compile
 	LatteShader_DumpShader(shaderBaseHash, shaderAuxHash, geometryShader);
 	LatteShader_DumpRawShader(shaderBaseHash, shaderAuxHash, SHADER_DUMP_TYPE_GEOMETRY, geometryShaderData.data(), geometryShaderData.size());
 	LatteShaderCache_loadOrCompileSeparableShader(geometryShader, shaderBaseHash, shaderAuxHash);
-	catchOpenGLError();
 	LatteSHRC_RegisterShader(geometryShader, shaderBaseHash, shaderAuxHash);
 	return true;
 }
@@ -698,7 +832,7 @@ bool LatteShaderCache_readSeparablePixelShader(MemStreamReader& streamReader, ui
 {
 	if (version != 1)
 		return false;
-	std::unique_ptr<LatteContextRegister> lcr(new LatteContextRegister());
+	auto lcr = std::make_unique<LatteContextRegister>();
 	uint64 shaderBaseHash = streamReader.readBE<uint64>();
 	uint64 shaderAuxHash = streamReader.readBE<uint64>();
 	bool usesGeometryShader = streamReader.readBE<uint8>() != 0;
@@ -717,15 +851,17 @@ bool LatteShaderCache_readSeparablePixelShader(MemStreamReader& streamReader, ui
 		return false;
 	// update PS inputs
 	LatteShader_UpdatePSInputs(lcr->GetRawView());
+	// determine decompiler options
+	LatteDecompilerOptions options;
+	LatteShader_GetDecompilerOptions(options, LatteConst::ShaderType::Pixel, usesGeometryShader);
 	// decompile pixel shader
 	LatteDecompilerOutput_t decompilerOutput{};
-	LatteDecompiler_DecompilePixelShader(shaderBaseHash, lcr->GetRawView(), pixelShaderData.data(), pixelShaderData.size(), lcr->GetSpecialStateValues(), usesGeometryShader, &decompilerOutput);
+	LatteDecompiler_DecompilePixelShader(shaderBaseHash, lcr->GetRawView(), pixelShaderData.data(), pixelShaderData.size(), options, &decompilerOutput);
 	LatteDecompilerShader* pixelShader = LatteShader_CreateShaderFromDecompilerOutput(decompilerOutput, shaderBaseHash, false, shaderAuxHash, lcr->GetRawView());
 	// compile
 	LatteShader_DumpShader(shaderBaseHash, shaderAuxHash, pixelShader);
 	LatteShader_DumpRawShader(shaderBaseHash, shaderAuxHash, SHADER_DUMP_TYPE_PIXEL, pixelShaderData.data(), pixelShaderData.size());
 	LatteShaderCache_loadOrCompileSeparableShader(pixelShader, shaderBaseHash, shaderAuxHash);
-	catchOpenGLError();
 	LatteSHRC_RegisterShader(pixelShader, shaderBaseHash, shaderAuxHash);
 	return true;
 }
@@ -748,6 +884,23 @@ bool LatteShaderCache_readSeparableShader(uint8* shaderInfoData, sint32 shaderIn
 	return false;
 }
 
+void LatteShaderCache_Close()
+{
+    if(s_shaderCacheGeneric)
+    {
+        delete s_shaderCacheGeneric;
+        s_shaderCacheGeneric = nullptr;
+    }
+    if (g_renderer->GetType() == RendererAPI::Vulkan)
+        RendererShaderVk::ShaderCacheLoading_Close();
+    else if (g_renderer->GetType() == RendererAPI::OpenGL)
+        RendererShaderGL::ShaderCacheLoading_Close();
+
+    // if Vulkan then also close pipeline cache
+    if (g_renderer->GetType() == RendererAPI::Vulkan)
+        VulkanPipelineStableCache::GetInstance().Close();
+}
+
 #include <wx/msgdlg.h>
 
 void LatteShaderCache_handleDeprecatedCacheFiles(fs::path pathGeneric, fs::path pathGenericPre1_25_0, fs::path pathGenericPre1_16_0)
@@ -760,10 +913,9 @@ void LatteShaderCache_handleDeprecatedCacheFiles(fs::path pathGeneric, fs::path
 	if (hasOldCacheFiles && !hasNewCacheFiles)
 	{
 		// ask user if they want to delete or keep the old cache file
-		const auto infoMsg = L"Outdated shader cache\n\nCemu detected that the shader cache for this game is outdated\nOnly shader caches generated with Cemu 1.25.0 or above are supported\n\n"
-			"We recommend deleting the outdated cache file as it will no longer be used by Cemu";
+		auto infoMsg = _("Cemu detected that the shader cache for this game is outdated.\nOnly shader caches generated with Cemu 1.25.0 or above are supported.\n\nWe recommend deleting the outdated cache file as it will no longer be used by Cemu.");
 			
-		wxMessageDialog dialog(nullptr, _(infoMsg), _("Outdated shader cache"),
+		wxMessageDialog dialog(nullptr, infoMsg, _("Outdated shader cache"),
 			wxYES_NO | wxCENTRE | wxICON_EXCLAMATION);
 
 		dialog.SetYesNoLabels(_("Delete outdated cache file [recommended]"), _("Keep outdated cache file"));
@@ -774,4 +926,4 @@ void LatteShaderCache_handleDeprecatedCacheFiles(fs::path pathGeneric, fs::path
 			fs::remove(pathGenericPre1_25_0, ec);
 		}
 	}
-}
+}
\ No newline at end of file
diff --git a/src/Cafe/HW/Latte/Core/LatteShaderGL.cpp b/src/Cafe/HW/Latte/Core/LatteShaderGL.cpp
index e709e46d..b8cb0ce1 100644
--- a/src/Cafe/HW/Latte/Core/LatteShaderGL.cpp
+++ b/src/Cafe/HW/Latte/Core/LatteShaderGL.cpp
@@ -19,8 +19,8 @@ bool gxShader_checkIfSuccessfullyLinked(GLuint glProgram)
 	tempLength = sizeof(infoLog)-1;
 	glGetProgramInfoLog(glProgram, std::min(tempLength, infoLogLength), (GLsizei*)&tempLength, (GLcharARB*)infoLog);
 	infoLog[tempLength] = '\0';
-	forceLog_printf("Link error in raw shader");
-	cafeLog_logLine(LOG_TYPE_FORCE, infoLog);
+	cemuLog_log(LogType::Force, "Link error in raw shader");
+	cemuLog_log(LogType::Force, infoLog);
 	return false;
 }
 
@@ -83,8 +83,8 @@ GLuint gpu7ShaderGLDepr_compileShader(const std::string& source, uint32_t type)
 		char log[2048]{};
 		GLsizei log_size;
 		glGetShaderInfoLog(shader_object, std::min(log_length, (GLint)sizeof(log) - 1), &log_size, log);
-		forceLog_printf("Error/Warning in vertex shader:");
-		forceLog_printf("%s", log);
+		cemuLog_log(LogType::Force, "Error/Warning in vertex shader:");
+		cemuLog_log(LogType::Force, log);
 	}
 
 	return shader_object;
@@ -112,8 +112,8 @@ GLuint gpu7ShaderGLDepr_compileVertexShader(const char* shaderSource, sint32 sha
 	{
 		char messageLog[2048]{};
 		glGetShaderInfoLog(shaderObject, std::min<uint32>(shaderLogLengthInfo, sizeof(messageLog) - 1), (GLsizei*)&shaderLogLen, (GLcharARB*)messageLog);
-		forceLog_printf("Error/Warning in vertex shader:");
-		forceLog_printf("%s", messageLog);
+		cemuLog_log(LogType::Force, "Error/Warning in vertex shader:");
+		cemuLog_log(LogType::Force, messageLog);
 	}
 	return shaderObject;
 }
@@ -132,8 +132,8 @@ GLuint gpu7ShaderGLDepr_compileFragmentShader(const char* shaderSource, sint32 s
 	{
 		memset(messageLog, 0, sizeof(messageLog));
 		glGetShaderInfoLog(shaderObject, std::min<uint32>(shaderLogLengthInfo, sizeof(messageLog) - 1), (GLsizei*)&shaderLogLen, (GLcharARB*)messageLog);
-		forceLog_printf("Error/Warning in fragment shader:");
-		forceLog_printf("%s", messageLog);
+		cemuLog_log(LogType::Force, "Error/Warning in fragment shader:");
+		cemuLog_log(LogType::Force, messageLog);
 	}
 	return shaderObject;
 }
diff --git a/src/Cafe/HW/Latte/Core/LatteSoftware.cpp b/src/Cafe/HW/Latte/Core/LatteSoftware.cpp
index 8e5ec29b..57af8d83 100644
--- a/src/Cafe/HW/Latte/Core/LatteSoftware.cpp
+++ b/src/Cafe/HW/Latte/Core/LatteSoftware.cpp
@@ -252,7 +252,7 @@ float LatteSoftware_omod(uint32 omod, float f)
 	return 0.0f;
 }
 
-#ifndef PUBLIC_RELEASE
+#ifdef CEMU_DEBUG_ASSERT
 #define _clamp(__v) if(destClamp != 0) cemu_assert_unimplemented()
 #else
 #define _clamp(__v) // todo
diff --git a/src/Cafe/HW/Latte/Core/LatteStreamoutGPU.cpp b/src/Cafe/HW/Latte/Core/LatteStreamoutGPU.cpp
index 07e7106d..ccea31b8 100644
--- a/src/Cafe/HW/Latte/Core/LatteStreamoutGPU.cpp
+++ b/src/Cafe/HW/Latte/Core/LatteStreamoutGPU.cpp
@@ -100,17 +100,17 @@ void LatteStreamout_PrepareDrawcall(uint32 count, uint32 instanceCount)
 	uint32 streamoutWriteMask = 0;
 	if (geometryShader)
 	{
-#ifndef PUBLIC_RELEASE
-		cemu_assert_debug(vertexShader->streamoutBufferWriteMask2.any() == false);
+#ifdef CEMU_DEBUG_ASSERT
+		cemu_assert_debug(vertexShader->streamoutBufferWriteMask.any() == false);
 #endif
 		for (sint32 i = 0; i < LATTE_NUM_STREAMOUT_BUFFER; i++)
-			if (geometryShader->streamoutBufferWriteMask2[i])
+			if (geometryShader->streamoutBufferWriteMask[i])
 				streamoutWriteMask |= (1 << i);
 	}
 	else
 	{
 		for (sint32 i = 0; i < LATTE_NUM_STREAMOUT_BUFFER; i++)
-			if (vertexShader->streamoutBufferWriteMask2[i])
+			if (vertexShader->streamoutBufferWriteMask[i])
 				streamoutWriteMask |= (1 << i);
 	}
 	activeStreamoutOperation.streamoutWriteMask = streamoutWriteMask;
diff --git a/src/Cafe/HW/Latte/Core/LatteSurfaceCopy.cpp b/src/Cafe/HW/Latte/Core/LatteSurfaceCopy.cpp
index 1c84145a..45be6843 100644
--- a/src/Cafe/HW/Latte/Core/LatteSurfaceCopy.cpp
+++ b/src/Cafe/HW/Latte/Core/LatteSurfaceCopy.cpp
@@ -37,7 +37,7 @@ void LatteSurfaceCopy_copySurfaceNew(MPTR srcPhysAddr, MPTR srcMipAddr, uint32 s
 	if (!destinationTexture)
 	{
 		LatteTexture* renderTargetConf = nullptr;
-		destinationView = LatteTexture_CreateMapping(dstPhysAddr, dstMipAddr, dstWidth, dstHeight, dstDepth, dstPitch, dstTilemode, dstSwizzle, dstLevel, 1, dstSlice, 1, dstSurfaceFormat, dstDim, Latte::E_DIM::DIM_2D, false);
+		destinationView = LatteTexture_CreateMapping(dstPhysAddr, dstMipAddr, dstWidth, dstHeight, dstDepth, dstPitch, dstTilemode, dstSwizzle, dstLevel, 1, dstSlice, 1, dstSurfaceFormat, dstDim, Latte::IsMSAA(dstDim) ? Latte::E_DIM::DIM_2D_MSAA : Latte::E_DIM::DIM_2D, false);
 		destinationTexture = destinationView->baseTexture;
 	}
 	// copy texture
@@ -46,9 +46,7 @@ void LatteSurfaceCopy_copySurfaceNew(MPTR srcPhysAddr, MPTR srcMipAddr, uint32 s
 		// mark source and destination texture as still in use
 		LatteTC_MarkTextureStillInUse(destinationTexture);
 		LatteTC_MarkTextureStillInUse(sourceTexture);
-		// determine GL slice indices
 		sint32 realSrcSlice = srcSlice;
-		sint32 realDstSlice = dstSlice;
 		if (LatteTexture_doesEffectiveRescaleRatioMatch(sourceTexture, sourceView->firstMip, destinationTexture, destinationView->firstMip))
 		{
 			// adjust copy size
@@ -62,29 +60,11 @@ void LatteSurfaceCopy_copySurfaceNew(MPTR srcPhysAddr, MPTR srcMipAddr, uint32 s
 			LatteTexture_scaleToEffectiveSize(sourceTexture, &effectiveCopyWidth, &effectiveCopyHeight, 0);
 			// copy slice
 			if (sourceView->baseTexture->isDepth != destinationView->baseTexture->isDepth)
-			{
 				g_renderer->surfaceCopy_copySurfaceWithFormatConversion(sourceTexture, sourceView->firstMip, sourceView->firstSlice, destinationTexture, destinationView->firstMip, destinationView->firstSlice, copyWidth, copyHeight);
-				uint64 eventCounter = LatteTexture_getNextUpdateEventCounter();
-				LatteTexture_MarkDynamicTextureAsChanged(destinationTexture->baseView, destinationView->firstSlice, destinationView->firstMip, eventCounter);
-			}
 			else
-			{
-				// calculate mip levels relative to texture base
-				sint32 texDstMipLevel;
-				if (destinationTexture->physAddress == dstPhysAddr)
-				{
-					texDstMipLevel = dstLevel;
-				}
-				else
-				{
-					// todo - handle mip addresses properly
-					texDstMipLevel = dstLevel - destinationView->firstMip;
-				}
-
-				g_renderer->texture_copyImageSubData(sourceTexture, sourceView->firstMip, 0, 0, realSrcSlice, destinationTexture, texDstMipLevel, 0, 0, realDstSlice, effectiveCopyWidth, effectiveCopyHeight, 1);
-				uint64 eventCounter = LatteTexture_getNextUpdateEventCounter();
-				LatteTexture_MarkDynamicTextureAsChanged(destinationTexture->baseView, destinationView->firstSlice, texDstMipLevel, eventCounter);
-			}
+				g_renderer->texture_copyImageSubData(sourceTexture, sourceView->firstMip, 0, 0, realSrcSlice, destinationTexture, destinationView->firstMip, 0, 0, destinationView->firstSlice, effectiveCopyWidth, effectiveCopyHeight, 1);
+			const uint64 eventCounter = LatteTexture_getNextUpdateEventCounter();
+			LatteTexture_MarkDynamicTextureAsChanged(destinationTexture->baseView, destinationView->firstSlice, destinationView->firstMip, eventCounter);
 		}
 		else
 		{
@@ -101,7 +81,7 @@ void LatteSurfaceCopy_copySurfaceNew(MPTR srcPhysAddr, MPTR srcMipAddr, uint32 s
 	// download destination texture if it matches known accessed formats
 	if (destinationTexture->width == 8 && destinationTexture->height == 8 && destinationTexture->tileMode == Latte::E_HWTILEMODE::TM_1D_TILED_THIN1)
 	{
-		forceLogDebug_printf("Texture readback after copy for Bayonetta 2 (phys: 0x%08x)", destinationTexture->physAddress);
+		cemuLog_logDebug(LogType::Force, "Texture readback after copy for Bayonetta 2 (phys: 0x{:08x})", destinationTexture->physAddress);
 		LatteTextureReadback_Initate(destinationView);
 	}
-}
\ No newline at end of file
+}
diff --git a/src/Cafe/HW/Latte/Core/LatteTexture.cpp b/src/Cafe/HW/Latte/Core/LatteTexture.cpp
index 899888de..d8852891 100644
--- a/src/Cafe/HW/Latte/Core/LatteTexture.cpp
+++ b/src/Cafe/HW/Latte/Core/LatteTexture.cpp
@@ -1,5 +1,4 @@
 #include "Cafe/HW/Latte/Core/Latte.h"
-#include "Cafe/HW/Latte/Core/LatteDraw.h"
 #include "Cafe/HW/Latte/Core/LatteShader.h"
 #include "Cafe/HW/Latte/Core/LattePerformanceMonitor.h"
 #include "Cafe/HW/Latte/Core/LatteTexture.h"
@@ -9,6 +8,8 @@
 
 #include "Cafe/GraphicPack/GraphicPack2.h"
 
+#include <boost/container/small_vector.hpp>
+
 struct TexMemOccupancyEntry
 {
 	uint32 addrStart;
@@ -234,6 +235,9 @@ void LatteTexture_InitSliceAndMipInfo(LatteTexture* texture)
 // if this function returns false, textures will not be synchronized even if their data overlaps
 bool LatteTexture_IsFormatViewCompatible(Latte::E_GX2SURFFMT formatA, Latte::E_GX2SURFFMT formatB)
 {
+	if(formatA == formatB)
+		return true; // if the format is identical then compatibility must be guaranteed (otherwise we can't create the necessary default view of a texture)
+
 	// todo - find a better way to handle this
 	for (sint32 swap = 0; swap < 2; swap++)
 	{
@@ -297,18 +301,16 @@ void LatteTexture_copyData(LatteTexture* srcTexture, LatteTexture* dstTexture, s
 	else
 	{
 		sint32 effectiveWidth_dst, effectiveHeight_dst;
-		LatteTexture_getEffectiveSize(srcTexture, &effectiveWidth_dst, &effectiveHeight_dst, NULL, 0);
+		srcTexture->GetEffectiveSize(effectiveWidth_dst, effectiveHeight_dst, 0);
 		sint32 effectiveWidth_src, effectiveHeight_src;
-		LatteTexture_getEffectiveSize(dstTexture, &effectiveWidth_src, &effectiveHeight_src, NULL, 0);
+		dstTexture->GetEffectiveSize(effectiveWidth_src, effectiveHeight_src, 0);
 
 		debug_printf("texture_copyData(): Effective size mismatch\n");
-		forceLogDebug_printf("texture_copyData(): Effective size mismatch (due to texture rule)");
-		forceLogDebug_printf("Destination: origResolution %04dx%04d effectiveResolution %04dx%04d fmt %04x mipIndex %d", srcTexture->width, srcTexture->height, effectiveWidth_dst, effectiveHeight_dst, (uint32)dstTexture->format, 0);
-		forceLogDebug_printf("Source:      origResolution %04dx%04d effectiveResolution %04dx%04d fmt %04x mipIndex %d", srcTexture->width, srcTexture->height, effectiveWidth_src, effectiveHeight_src, (uint32)srcTexture->format, 0);
+		cemuLog_logDebug(LogType::Force, "texture_copyData(): Effective size mismatch (due to texture rule)");
+		cemuLog_logDebug(LogType::Force, "Destination: origResolution {:04}x{:04} effectiveResolution {:04}x{:04} fmt {:04x} mipIndex {}", srcTexture->width, srcTexture->height, effectiveWidth_dst, effectiveHeight_dst, (uint32)dstTexture->format, 0);
+		cemuLog_logDebug(LogType::Force, "Source:      origResolution {:04}x{:04} effectiveResolution {:04}x{:04} fmt {:04x} mipIndex {}", srcTexture->width, srcTexture->height, effectiveWidth_src, effectiveHeight_src, (uint32)srcTexture->format, 0);
 		return;
 	}
-	catchOpenGLError();
-
 	for (sint32 mipIndex = 0; mipIndex < mipCount; mipIndex++)
 	{
 		sint32 sliceCopyWidth = std::max(effectiveCopyWidth >> mipIndex, 1);
@@ -323,9 +325,7 @@ void LatteTexture_copyData(LatteTexture* srcTexture, LatteTexture* dstTexture, s
 			LatteTextureSliceMipInfo* dstTexSliceInfo = dstTexture->sliceMipInfo + dstTexture->GetSliceMipArrayIndex(sliceIndex, mipIndex);
 			dstTexSliceInfo->lastDynamicUpdate = srcTexSliceInfo->lastDynamicUpdate;
 		}
-		catchOpenGLError();
 	}
-	catchOpenGLError();
 }
 
 template<bool bothMustMatch>
@@ -374,17 +374,17 @@ void LatteTexture_CopySlice(LatteTexture* srcTexture, sint32 srcSlice, sint32 sr
 		sint32 effectiveHeight_src = srcTexture->overwriteInfo.hasResolutionOverwrite ? srcTexture->overwriteInfo.height : srcTexture->height;
 		sint32 effectiveWidth_dst = dstTexture->overwriteInfo.hasResolutionOverwrite ? dstTexture->overwriteInfo.width : dstTexture->width;
 		sint32 effectiveHeight_dst = dstTexture->overwriteInfo.hasResolutionOverwrite ? dstTexture->overwriteInfo.height : dstTexture->height;
-		if (cafeLog_isLoggingFlagEnabled(LOG_TYPE_TEXTURE_CACHE))
+		if (cemuLog_isLoggingEnabled(LogType::TextureCache))
 		{
-			forceLog_printf("_copySlice(): Unable to sync textures with mismatching scale ratio (due to texture rule)");
+			cemuLog_log(LogType::Force, "_copySlice(): Unable to sync textures with mismatching scale ratio (due to texture rule)");
 			float ratioWidth_src = (float)effectiveWidth_src / (float)srcTexture->width;
 			float ratioHeight_src = (float)effectiveHeight_src / (float)srcTexture->height;
 			float ratioWidth_dst = (float)effectiveWidth_dst / (float)dstTexture->width;
 			float ratioHeight_dst = (float)effectiveHeight_dst / (float)dstTexture->height;
-			forceLog_printf("Source:      %08x origResolution %4d/%4d effectiveResolution %4d/%4d fmt %04x mipIndex %d ratioW/H: %.4f/%.4f", srcTexture->physAddress, srcTexture->width, srcTexture->height, effectiveWidth_src, effectiveHeight_src, (uint32)srcTexture->format, srcMip, ratioWidth_src, ratioHeight_src);
-			forceLog_printf("Destination: %08x origResolution %4d/%4d effectiveResolution %4d/%4d fmt %04x mipIndex %d ratioW/H: %.4f/%.4f", dstTexture->physAddress, dstTexture->width, dstTexture->height, effectiveWidth_dst, effectiveHeight_dst, (uint32)dstTexture->format, dstMip, ratioWidth_dst, ratioHeight_dst);
+			cemuLog_log(LogType::Force, "Source:      {:08x} origResolution {:4}/{:4} effectiveResolution {:4}/{:4} fmt {:04x} mipIndex {} ratioW/H: {:.4}/{:.4}", srcTexture->physAddress, srcTexture->width, srcTexture->height, effectiveWidth_src, effectiveHeight_src, (uint32)srcTexture->format, srcMip, ratioWidth_src, ratioHeight_src);
+			cemuLog_log(LogType::Force, "Destination: {:08x} origResolution {:4}/{:4} effectiveResolution {:4}/{:4} fmt {:04x} mipIndex {} ratioW/H: {:.4}/{:.4}", dstTexture->physAddress, dstTexture->width, dstTexture->height, effectiveWidth_dst, effectiveHeight_dst, (uint32)dstTexture->format, dstMip, ratioWidth_dst, ratioHeight_dst);
 		}
-		//forceLogDebug_printf("If these textures are not meant to share data you can ignore this");
+		//cemuLog_logDebug(LogType::Force, "If these textures are not meant to share data you can ignore this");
 		return;
 	}
 	// todo - store 'lastUpdated' value per slice/mip and copy it's value when copying the slice data
@@ -438,6 +438,11 @@ void LatteTexture_SyncSlice(LatteTexture* srcTexture, sint32 srcSliceIndex, sint
 	sint32 dstWidth = dstTexture->width;
 	sint32 dstHeight = dstTexture->height;
 
+	if(srcTexture->overwriteInfo.hasFormatOverwrite != dstTexture->overwriteInfo.hasFormatOverwrite)
+		return; // dont sync: format overwrite state needs to match. Not strictly necessary but it simplifies logic down the road
+	else if(srcTexture->overwriteInfo.hasFormatOverwrite && srcTexture->overwriteInfo.format != dstTexture->overwriteInfo.format)
+		return; // both are overwritten but with different formats
+
 	if (srcMipIndex == 0 && dstMipIndex == 0 && (srcTexture->tileMode == Latte::E_HWTILEMODE::TM_LINEAR_ALIGNED || srcTexture->tileMode == Latte::E_HWTILEMODE::TM_1D_TILED_THIN1) && srcTexture->height > dstTexture->height && (srcTexture->height % dstTexture->height) == 0)
 	{
 		bool isMatch = srcTexture->tileMode == Latte::E_HWTILEMODE::TM_LINEAR_ALIGNED;
@@ -790,80 +795,42 @@ enum VIEWCOMPATIBILITY
 	VIEW_NOT_COMPATIBLE,
 };
 
-bool IsDimensionCompatibleForView(Latte::E_DIM baseDim, Latte::E_DIM viewDim)
+bool IsDimensionCompatibleForGX2View(Latte::E_DIM baseDim, Latte::E_DIM viewDim)
 {
-	bool incompatibleDim = false;
-	if (baseDim == Latte::E_DIM::DIM_2D && viewDim == Latte::E_DIM::DIM_2D)
-		;
-	else if (baseDim == Latte::E_DIM::DIM_2D && viewDim == Latte::E_DIM::DIM_2D_ARRAY)
-		;
-	else if (baseDim == Latte::E_DIM::DIM_CUBEMAP && viewDim == Latte::E_DIM::DIM_CUBEMAP)
-		;
-	else if (baseDim == Latte::E_DIM::DIM_CUBEMAP && viewDim == Latte::E_DIM::DIM_2D_ARRAY)
-		;
-	else if (baseDim == Latte::E_DIM::DIM_2D_ARRAY && viewDim == Latte::E_DIM::DIM_2D_ARRAY)
-		;
-	else if (baseDim == Latte::E_DIM::DIM_2D_ARRAY && viewDim == Latte::E_DIM::DIM_2D)
-		;
-	else if (baseDim == Latte::E_DIM::DIM_2D_ARRAY && viewDim == Latte::E_DIM::DIM_CUBEMAP)
-		;
-	else if (baseDim == Latte::E_DIM::DIM_3D && viewDim == Latte::E_DIM::DIM_2D_ARRAY)
-		;
-	else if (baseDim == Latte::E_DIM::DIM_2D_MSAA && viewDim == Latte::E_DIM::DIM_2D_MSAA)
-		;
-	else if (baseDim == Latte::E_DIM::DIM_2D_ARRAY && viewDim == Latte::E_DIM::DIM_3D)
-	{
-		// not compatible on OpenGL
-		incompatibleDim = true;
-	}
-	else if (baseDim == Latte::E_DIM::DIM_2D && viewDim == Latte::E_DIM::DIM_2D_MSAA)
-	{
-		// not compatible
-		incompatibleDim = true;
-	}
-	else if (baseDim == Latte::E_DIM::DIM_2D && viewDim == Latte::E_DIM::DIM_1D)
-	{
-		// not compatible
-		incompatibleDim = true;
-	}
-	else if (baseDim == Latte::E_DIM::DIM_2D && viewDim == Latte::E_DIM::DIM_3D)
-	{
-		// not compatible
-		incompatibleDim = true;
-	}
-	else if (baseDim == Latte::E_DIM::DIM_3D && viewDim == Latte::E_DIM::DIM_2D)
-	{
-		// not compatible
-		incompatibleDim = true;
-	}
-	else if ((baseDim == Latte::E_DIM::DIM_2D && viewDim == Latte::E_DIM::DIM_CUBEMAP) ||
-		(baseDim == Latte::E_DIM::DIM_CUBEMAP && viewDim == Latte::E_DIM::DIM_2D))
-	{
-		// not compatible
-		incompatibleDim = true;
-	}
-	else if (baseDim == Latte::E_DIM::DIM_2D_MSAA && viewDim == Latte::E_DIM::DIM_2D)
-	{
-		// not compatible
-		incompatibleDim = true;
-	}
-	else if (baseDim == Latte::E_DIM::DIM_1D && viewDim == Latte::E_DIM::DIM_2D)
-	{
-		// not compatible (probably?)
-		incompatibleDim = true;
-	}
-	else
-	{
-		cemu_assert_debug(false);
-		incompatibleDim = true;
-	}
-	return !incompatibleDim;
+	// Note that some combinations depend on the exact view/slice index and count which we currently ignore (like a 3D view of a 3D texture)
+	bool isCompatible =
+		(baseDim == viewDim) ||
+		(baseDim == Latte::E_DIM::DIM_CUBEMAP && viewDim == Latte::E_DIM::DIM_2D) ||
+		(baseDim == Latte::E_DIM::DIM_2D && viewDim == Latte::E_DIM::DIM_2D_ARRAY) ||
+		(baseDim == Latte::E_DIM::DIM_2D_ARRAY && viewDim == Latte::E_DIM::DIM_2D) ||
+		(baseDim == Latte::E_DIM::DIM_CUBEMAP && viewDim == Latte::E_DIM::DIM_2D_ARRAY) ||
+		(baseDim == Latte::E_DIM::DIM_2D_ARRAY && viewDim == Latte::E_DIM::DIM_CUBEMAP) ||
+		(baseDim == Latte::E_DIM::DIM_3D && viewDim == Latte::E_DIM::DIM_2D_ARRAY);
+	if(isCompatible)
+		return true;
+	// these combinations have been seen in use by games and are considered incompatible:
+	// (baseDim == Latte::E_DIM::DIM_2D_ARRAY && viewDim == Latte::E_DIM::DIM_3D) -> Not allowed on OpenGL
+	// (baseDim == Latte::E_DIM::DIM_2D && viewDim == Latte::E_DIM::DIM_2D_MSAA)
+	// (baseDim == Latte::E_DIM::DIM_2D && viewDim == Latte::E_DIM::DIM_1D)
+	// (baseDim == Latte::E_DIM::DIM_2D && viewDim == Latte::E_DIM::DIM_3D)
+	// (baseDim == Latte::E_DIM::DIM_3D && viewDim == Latte::E_DIM::DIM_2D)
+	// (baseDim == Latte::E_DIM::DIM_3D && viewDim == Latte::E_DIM::DIM_3D) -> Only compatible if the same depth and shared at mip/slice 0
+	// (baseDim == Latte::E_DIM::DIM_2D && viewDim == Latte::E_DIM::DIM_CUBEMAP)
+	// (baseDim == Latte::E_DIM::DIM_2D_MSAA && viewDim == Latte::E_DIM::DIM_2D)
+	// (baseDim == Latte::E_DIM::DIM_1D && viewDim == Latte::E_DIM::DIM_2D)
+	return false;
 }
 
 VIEWCOMPATIBILITY LatteTexture_CanTextureBeRepresentedAsView(LatteTexture* baseTexture, uint32 physAddr, sint32 width, sint32 height, sint32 pitch, Latte::E_DIM dimView, Latte::E_GX2SURFFMT format, bool isDepth, sint32 firstMip, sint32 numMip, sint32 firstSlice, sint32 numSlice, sint32& relativeMipIndex, sint32& relativeSliceIndex)
 {
 	relativeMipIndex = 0;
 	relativeSliceIndex = 0;
+	if (baseTexture->overwriteInfo.hasFormatOverwrite)
+	{
+		// if the base format is overwritten, then we only allow aliasing if the view format matches the base format
+		if (baseTexture->format != format)
+			return VIEW_NOT_COMPATIBLE;
+	}
 	if (LatteTexture_IsFormatViewCompatible(baseTexture->format, format) == false)
 		return VIEW_NOT_COMPATIBLE;
 	if (baseTexture->physAddress == physAddr && baseTexture->pitch == pitch)
@@ -872,12 +839,14 @@ VIEWCOMPATIBILITY LatteTexture_CanTextureBeRepresentedAsView(LatteTexture* baseT
 			return VIEW_NOT_COMPATIBLE; // depth and non-depth formats are never compatible (on OpenGL)
 		if (!LatteTexture_IsTexelSizeCompatibleFormat(baseTexture->format, format) || baseTexture->width != width || baseTexture->height != height)
 			return VIEW_NOT_COMPATIBLE;
-		if (!IsDimensionCompatibleForView(baseTexture->dim, dimView))
+		// 3D views are only compatible on Vulkan if they match the base texture in regards to mip and slice count
+		bool isCompatible3DView = dimView == Latte::E_DIM::DIM_3D && baseTexture->dim == dimView && firstSlice == 0 && firstMip == 0 && baseTexture->mipLevels == numMip && baseTexture->depth == numSlice;
+		if (!isCompatible3DView && !IsDimensionCompatibleForGX2View(baseTexture->dim, dimView))
 			return VIEW_NOT_COMPATIBLE;
 		if (baseTexture->isDepth && baseTexture->format != format)
 		{
 			// depth view with different format
-			forceLogDebug_printf("_createMapping(): Incompatible depth view format");
+			cemuLog_logDebug(LogType::Force, "_createMapping(): Incompatible depth view format");
 			return VIEW_NOT_COMPATIBLE;
 		}
 
@@ -924,12 +893,12 @@ VIEWCOMPATIBILITY LatteTexture_CanTextureBeRepresentedAsView(LatteTexture* baseT
 				if (!LatteTexture_IsTexelSizeCompatibleFormat(baseTexture->format, format) )
 					return VIEW_NOT_COMPATIBLE;
 
-				if (!IsDimensionCompatibleForView(baseTexture->dim, dimView))
+				if (!IsDimensionCompatibleForGX2View(baseTexture->dim, dimView))
 					return VIEW_NOT_COMPATIBLE;
 				if (baseTexture->isDepth && baseTexture->format != format)
 				{
 					// depth view with different format
-					forceLogDebug_printf("_createMapping(): Incompatible depth view format");
+					cemuLog_logDebug(LogType::Force, "_createMapping(): Incompatible depth view format");
 					return VIEW_NOT_COMPATIBLE;
 				}
 
@@ -978,7 +947,7 @@ void LatteTexture_RecreateTextureWithDifferentMipSliceCount(LatteTexture* textur
 		newDim = Latte::E_DIM::DIM_2D_ARRAY;
 	else if (newDim == Latte::E_DIM::DIM_1D && newDepth > 1)
 		newDim = Latte::E_DIM::DIM_1D_ARRAY;
-	LatteTextureView* view = LatteTexture_CreateTexture(0, newDim, texture->physAddress, physMipAddr, texture->format, texture->width, texture->height, newDepth, texture->pitch, newMipCount, texture->swizzle, texture->tileMode, texture->isDepth);
+	LatteTextureView* view = LatteTexture_CreateTexture(newDim, texture->physAddress, physMipAddr, texture->format, texture->width, texture->height, newDepth, texture->pitch, newMipCount, texture->swizzle, texture->tileMode, texture->isDepth);
 	cemu_assert(!(view->baseTexture->mipLevels <= 1 && physMipAddr == MPTR_NULL && newMipCount > 1));
 	// copy data from old texture if its dynamically updated
 	if (texture->isUpdatedOnGPU)
@@ -998,12 +967,13 @@ void LatteTexture_RecreateTextureWithDifferentMipSliceCount(LatteTexture* textur
 }
 
 // create new texture representation
-// if allowCreateNewDataTexture is true, a new texture will be created if necessary. If it is false, only existing textures may be used, except if a data-compatible version of the requested texture already exists and it's not view compatible
+// if allowCreateNewDataTexture is true, a new texture will be created if necessary. If it is false, only existing textures may be used, except if a data-compatible version of the requested texture already exists and it's not view compatible (todo - we should differentiate between Latte compatible views and renderer compatible)
+// the returned view will map to the provided mip and slice range within the created texture, this is to match the behavior of lookupSliceEx
 LatteTextureView* LatteTexture_CreateMapping(MPTR physAddr, MPTR physMipAddr, sint32 width, sint32 height, sint32 depth, sint32 pitch, Latte::E_HWTILEMODE tileMode, uint32 swizzle, sint32 firstMip, sint32 numMip, sint32 firstSlice, sint32 numSlice, Latte::E_GX2SURFFMT format, Latte::E_DIM dimBase, Latte::E_DIM dimView, bool isDepth, bool allowCreateNewDataTexture)
 {
 	if (format == Latte::E_GX2SURFFMT::INVALID_FORMAT)
 	{
-		forceLogDebug_printf("LatteTexture_CreateMapping(): Invalid format");
+		cemuLog_logDebug(LogType::Force, "LatteTexture_CreateMapping(): Invalid format");
 		return nullptr;
 	}
 	// note: When creating an existing texture, we only allow mip and slice expansion at the end
@@ -1014,7 +984,7 @@ LatteTextureView* LatteTexture_CreateMapping(MPTR physAddr, MPTR physMipAddr, si
 	// todo, depth and numSlice are redundant
 
 	sint32 sliceCount = firstSlice + numSlice;
-	std::vector<LatteTexture*> list_overlappingTextures;
+	boost::container::small_vector<LatteTexture*, 16> list_overlappingTextures;
 	for (sint32 sliceIndex = 0; sliceIndex < sliceCount; sliceIndex++)
 	{
 		sint32 mipIndex = 0;
@@ -1089,7 +1059,7 @@ LatteTextureView* LatteTexture_CreateMapping(MPTR physAddr, MPTR physMipAddr, si
 				// for accesses to mips/slices using a physAddress offset we manually need to create a new view lookup
 				// by default views only create a lookup for the base texture physAddress
 				view->CreateLookupForSubTexture(relativeMipIndex, relativeSliceIndex);
-#ifndef PUBLIC_RELEASE
+#ifdef CEMU_DEBUG_ASSERT
 				LatteTextureView* testView = LatteTextureViewLookupCache::lookup(physAddr, width, height, depth, pitch, firstMip, numMip, firstSlice, numSlice, format, dimView);
 				cemu_assert(testView);
 #endif
@@ -1104,12 +1074,18 @@ LatteTextureView* LatteTexture_CreateMapping(MPTR physAddr, MPTR physMipAddr, si
 	// create new texture
 	if (allowCreateNewDataTexture == false)
 		return nullptr;
-	LatteTextureView* view = LatteTexture_CreateTexture(0, dimBase, physAddr, physMipAddr, format, width, height, depth, pitch, firstMip + numMip, swizzle, tileMode, isDepth);
+	LatteTextureView* view = LatteTexture_CreateTexture(dimBase, physAddr, physMipAddr, format, width, height, depth, pitch, firstMip + numMip, swizzle, tileMode, isDepth);
+	LatteTexture* newTexture = view->baseTexture;
 	LatteTexture_GatherTextureRelations(view->baseTexture);
 	LatteTexture_UpdateTextureFromDynamicChanges(view->baseTexture);
 	// delete any individual smaller slices/mips that have become redundant
 	LatteTexture_DeleteAbsorbedSubtextures(view->baseTexture);
-	return view;
+	// create view
+	sint32 relativeMipIndex;
+	sint32 relativeSliceIndex;
+	VIEWCOMPATIBILITY viewCompatibility = LatteTexture_CanTextureBeRepresentedAsView(newTexture, physAddr, width, height, pitch, dimView, format, isDepth, firstMip, numMip, firstSlice, numSlice, relativeMipIndex, relativeSliceIndex);
+	cemu_assert(viewCompatibility == VIEW_COMPATIBLE);
+	return view->baseTexture->GetOrCreateView(dimView, format, relativeMipIndex + firstMip, numMip, relativeSliceIndex + firstSlice, numSlice);
 }
 
 LatteTextureView* LatteTC_LookupTextureByData(MPTR physAddr, sint32 width, sint32 height, sint32 pitch, sint32 firstMip, sint32 numMip, sint32 firstSlice, sint32 numSlice, sint32* searchIndex)
@@ -1177,12 +1153,8 @@ LatteTextureView* LatteTC_GetTextureSliceViewOrTryCreate(MPTR srcImagePtr, MPTR
 void LatteTexture_UpdateDataToLatest(LatteTexture* texture)
 {
 	if (LatteTC_HasTextureChanged(texture))
-	{
-		g_renderer->texture_rememberBoundTexture(0);
-		g_renderer->texture_bindAndActivateRawTex(texture, 0);
-		LatteTexture_ReloadData(texture, 0);
-		g_renderer->texture_restoreBoundTexture(0);
-	}
+		LatteTexture_ReloadData(texture);
+
 	if (texture->reloadFromDynamicTextures)
 	{
 		LatteTexture_UpdateCacheFromDynamicTextures(texture);
@@ -1231,7 +1203,16 @@ std::vector<LatteTexture*>& LatteTexture::GetAllTextures()
 	return sAllTextures;
 }
 
-LatteTexture::LatteTexture(uint32 textureUnit, Latte::E_DIM dim, MPTR physAddress, MPTR physMipAddress, Latte::E_GX2SURFFMT format, uint32 width, uint32 height, uint32 depth, uint32 pitch, uint32 mipLevels, uint32 swizzle,
+bool LatteTexture_GX2FormatHasStencil(bool isDepth, Latte::E_GX2SURFFMT format)
+{
+	if (!isDepth)
+		return false;
+	return format == Latte::E_GX2SURFFMT::D24_S8_UNORM ||
+		   format == Latte::E_GX2SURFFMT::D24_S8_FLOAT ||
+		   format == Latte::E_GX2SURFFMT::D32_S8_FLOAT;
+}
+
+LatteTexture::LatteTexture(Latte::E_DIM dim, MPTR physAddress, MPTR physMipAddress, Latte::E_GX2SURFFMT format, uint32 width, uint32 height, uint32 depth, uint32 pitch, uint32 mipLevels, uint32 swizzle,
 	Latte::E_HWTILEMODE tileMode, bool isDepth)
 {
 	_AddTextureToGlobalList(this);
@@ -1249,6 +1230,7 @@ LatteTexture::LatteTexture(uint32 textureUnit, Latte::E_DIM dim, MPTR physAddres
 	this->mipLevels = mipLevels;
 	this->tileMode = tileMode;
 	this->isDepth = isDepth;
+	this->hasStencil = LatteTexture_GX2FormatHasStencil(isDepth, format);
 	this->physMipAddress = physMipAddress;
 	this->lastUpdateEventCounter = LatteTexture_getNextUpdateEventCounter();
 	this->lastWriteEventCounter = LatteTexture_getNextUpdateEventCounter();
diff --git a/src/Cafe/HW/Latte/Core/LatteTexture.h b/src/Cafe/HW/Latte/Core/LatteTexture.h
index 6cdc528e..6c09e840 100644
--- a/src/Cafe/HW/Latte/Core/LatteTexture.h
+++ b/src/Cafe/HW/Latte/Core/LatteTexture.h
@@ -24,10 +24,10 @@ struct LatteSamplerState
 class LatteTexture
 {
 public:
-	LatteTexture(uint32 textureUnit, Latte::E_DIM dim, MPTR physAddress, MPTR physMipAddress, Latte::E_GX2SURFFMT format, uint32 width, uint32 height, uint32 depth, uint32 pitch, uint32 mipLevels, uint32 swizzle, Latte::E_HWTILEMODE tileMode, bool isDepth);
+	LatteTexture(Latte::E_DIM dim, MPTR physAddress, MPTR physMipAddress, Latte::E_GX2SURFFMT format, uint32 width, uint32 height, uint32 depth, uint32 pitch, uint32 mipLevels, uint32 swizzle, Latte::E_HWTILEMODE tileMode, bool isDepth);
 	virtual ~LatteTexture();
 
-	virtual void InitTextureState() {};
+	virtual void AllocateOnHost() = 0;
 
 	LatteTextureView* GetOrCreateView(Latte::E_DIM dim, Latte::E_GX2SURFFMT format, sint32 firstMip, sint32 mipCount, sint32 firstSlice, sint32 sliceCount)
 	{
@@ -57,6 +57,29 @@ public:
 
 	bool Is3DTexture() const { return dim == Latte::E_DIM::DIM_3D; };
 
+	void GetSize(sint32& width, sint32& height, sint32 mipLevel) const
+	{
+		width = std::max(1, this->width >> mipLevel);
+		height = std::max(1, this->height >> mipLevel);
+	}
+
+	// similar to GetSize, but returns the real size of the texture taking into account any resolution overwrite by gfx pack rules
+	void GetEffectiveSize(sint32& effectiveWidth, sint32& effectiveHeight, sint32 mipLevel) const
+	{
+		if( overwriteInfo.hasResolutionOverwrite )
+		{
+			effectiveWidth = overwriteInfo.width;
+			effectiveHeight = overwriteInfo.height;
+		}
+		else
+		{
+			effectiveWidth = this->width;
+			effectiveHeight = this->height;
+		}
+		effectiveWidth = std::max(1, effectiveWidth >> mipLevel);
+		effectiveHeight = std::max(1, effectiveHeight >> mipLevel);
+	}
+
 	sint32 GetMipDepth(sint32 mipIndex)
 	{
 		cemu_assert_debug(mipIndex >= 0 && mipIndex < this->mipLevels);
@@ -307,13 +330,11 @@ std::vector<LatteTextureInformation> LatteTexture_QueryCacheInfo();
 
 float* LatteTexture_getEffectiveTextureScale(LatteConst::ShaderType shaderType, sint32 texUnit);
 
-LatteTextureView* LatteTexture_CreateTexture(uint32 textureUnit, Latte::E_DIM dim, MPTR physAddress, MPTR physMipAddress, Latte::E_GX2SURFFMT format, uint32 width, uint32 height, uint32 depth, uint32 pitch, uint32 mipLevels, uint32 swizzle, Latte::E_HWTILEMODE tileMode, bool isDepth);
+LatteTextureView* LatteTexture_CreateTexture(Latte::E_DIM dim, MPTR physAddress, MPTR physMipAddress, Latte::E_GX2SURFFMT format, uint32 width, uint32 height, uint32 depth, uint32 pitch, uint32 mipLevels, uint32 swizzle, Latte::E_HWTILEMODE tileMode, bool isDepth);
 void LatteTexture_Delete(LatteTexture* texture);
 
 void LatteTextureLoader_writeReadbackTextureToMemory(LatteTextureDefinition* textureData, uint32 sliceIndex, uint32 mipIndex, uint8* linearPixelData);
 
-void LatteTexture_getSize(LatteTexture* texture, sint32* width, sint32* height, sint32* depth, sint32 mipLevel);
-void LatteTexture_getEffectiveSize(LatteTexture* texture, sint32* effectiveWidth, sint32* effectiveHeight, sint32* effectiveDepth, sint32 mipLevel = 0);
 sint32 LatteTexture_getEffectiveWidth(LatteTexture* texture);
 bool LatteTexture_doesEffectiveRescaleRatioMatch(LatteTexture* texture1, sint32 mipLevel1, LatteTexture* texture2, sint32 mipLevel2);
 void LatteTexture_scaleToEffectiveSize(LatteTexture* texture, sint32* x, sint32* y, sint32 mipLevel);
diff --git a/src/Cafe/HW/Latte/Core/LatteTextureCache.cpp b/src/Cafe/HW/Latte/Core/LatteTextureCache.cpp
index 2caa2cd0..3145e90e 100644
--- a/src/Cafe/HW/Latte/Core/LatteTextureCache.cpp
+++ b/src/Cafe/HW/Latte/Core/LatteTextureCache.cpp
@@ -2,6 +2,7 @@
 #include "Cafe/HW/Latte/Core/LatteDraw.h"
 #include "Cafe/HW/Latte/Core/LatteTexture.h"
 #include "Cafe/HW/Latte/Renderer/Renderer.h"
+#include "Common/cpu_features.h"
 
 std::unordered_set<LatteTexture*> g_allTextures;
 
@@ -146,7 +147,7 @@ uint32 LatteTexture_CalculateTextureDataHash(LatteTexture* hostTexture)
 		if( isCompressedFormat == false )
 		{
 #if BOOST_OS_WINDOWS
-			if (_cpuExtension_AVX2)
+			if (g_CPUFeatures.x86.avx2)
 			{
 				__m256i h256 = { 0 };
 				__m256i* readPtr = (__m256i*)texDataU32;
@@ -315,7 +316,7 @@ void LatteTexture_Delete(LatteTexture* texture)
 		delete[] texture->sliceMipInfo;
 		texture->sliceMipInfo = nullptr;
 	}
-	g_renderer->texture_destroy(texture);
+	delete texture;
 }
 
 /*
diff --git a/src/Cafe/HW/Latte/Core/LatteTextureLegacy.cpp b/src/Cafe/HW/Latte/Core/LatteTextureLegacy.cpp
index 8d4c7efb..50aa4d87 100644
--- a/src/Cafe/HW/Latte/Core/LatteTextureLegacy.cpp
+++ b/src/Cafe/HW/Latte/Core/LatteTextureLegacy.cpp
@@ -1,10 +1,8 @@
 #include "Cafe/HW/Latte/ISA/RegDefines.h"
-#include "Cafe/OS/libs/gx2/GX2.h" // todo - remove this dependency
 #include "Cafe/HW/Latte/Core/Latte.h"
 #include "Cafe/HW/Latte/Core/LatteShader.h"
 
 #include "Cafe/HW/Latte/Renderer/Renderer.h"
-#include "Cafe/GraphicPack/GraphicPack2.h"
 
 #include "Cafe/HW/Latte/Renderer/OpenGL/OpenGLRenderer.h"
 #include "Cafe/HW/Latte/Renderer/OpenGL/LatteTextureGL.h"
@@ -34,9 +32,9 @@ void LatteTexture_setEffectiveTextureScale(LatteConst::ShaderType shaderType, si
 	t[1] = v;
 }
 
-void LatteTextureLoader_UpdateTextureSliceData(LatteTexture* tex, sint32 textureUnit, uint32 sliceIndex, uint32 mipIndex, MPTR physImagePtr, MPTR physMipPtr, Latte::E_DIM dim, uint32 width, uint32 height, uint32 depth, uint32 mipLevels, uint32 pitch, Latte::E_HWTILEMODE tileMode, uint32 swizzle, bool dumpTex);
+void LatteTextureLoader_UpdateTextureSliceData(LatteTexture* tex, uint32 sliceIndex, uint32 mipIndex, MPTR physImagePtr, MPTR physMipPtr, Latte::E_DIM dim, uint32 width, uint32 height, uint32 depth, uint32 mipLevels, uint32 pitch, Latte::E_HWTILEMODE tileMode, uint32 swizzle, bool dumpTex);
 
-void LatteTexture_ReloadData(LatteTexture* tex, uint32 textureUnit)
+void LatteTexture_ReloadData(LatteTexture* tex)
 {
 	tex->reloadCount++;
 	for(sint32 mip=0; mip<tex->mipLevels; mip++)
@@ -46,35 +44,35 @@ void LatteTexture_ReloadData(LatteTexture* tex, uint32 textureUnit)
 		{
 			sint32 numSlices = std::max(tex->depth, 1);
 			for(sint32 s=0; s<numSlices; s++)
-				LatteTextureLoader_UpdateTextureSliceData(tex, textureUnit, s, mip, tex->physAddress, tex->physMipAddress, tex->dim, tex->width, tex->height, tex->depth, tex->mipLevels, tex->pitch, tex->tileMode, tex->swizzle, true);
+				LatteTextureLoader_UpdateTextureSliceData(tex, s, mip, tex->physAddress, tex->physMipAddress, tex->dim, tex->width, tex->height, tex->depth, tex->mipLevels, tex->pitch, tex->tileMode, tex->swizzle, true);
 		}
 		else if( tex->dim == Latte::E_DIM::DIM_CUBEMAP )
 		{
 			cemu_assert_debug((tex->depth % 6) == 0);
 			sint32 numFullCubeMaps = tex->depth/6; // number of cubemaps (if numFullCubeMaps is >1 then this texture is a cubemap array)
 			for(sint32 s=0; s<numFullCubeMaps*6; s++)
-				LatteTextureLoader_UpdateTextureSliceData(tex, textureUnit, s, mip, tex->physAddress, tex->physMipAddress, tex->dim, tex->width, tex->height, tex->depth, tex->mipLevels, tex->pitch, tex->tileMode, tex->swizzle, true);
+				LatteTextureLoader_UpdateTextureSliceData(tex, s, mip, tex->physAddress, tex->physMipAddress, tex->dim, tex->width, tex->height, tex->depth, tex->mipLevels, tex->pitch, tex->tileMode, tex->swizzle, true);
 		}
 		else if( tex->dim == Latte::E_DIM::DIM_3D )
 		{
 			sint32 mipDepth = std::max(tex->depth>>mip, 1);
 			for(sint32 s=0; s<mipDepth; s++)
 			{
-				LatteTextureLoader_UpdateTextureSliceData(tex, textureUnit, s, mip, tex->physAddress, tex->physMipAddress, tex->dim, tex->width, tex->height, tex->depth, tex->mipLevels, tex->pitch, tex->tileMode, tex->swizzle, true);
+				LatteTextureLoader_UpdateTextureSliceData(tex, s, mip, tex->physAddress, tex->physMipAddress, tex->dim, tex->width, tex->height, tex->depth, tex->mipLevels, tex->pitch, tex->tileMode, tex->swizzle, true);
 			}
 		}
 		else
 		{
 			// load slice 0
-			LatteTextureLoader_UpdateTextureSliceData(tex, textureUnit, 0, mip, tex->physAddress, tex->physMipAddress, tex->dim, tex->width, tex->height, tex->depth, tex->mipLevels, tex->pitch, tex->tileMode, tex->swizzle, true);
+			LatteTextureLoader_UpdateTextureSliceData(tex, 0, mip, tex->physAddress, tex->physMipAddress, tex->dim, tex->width, tex->height, tex->depth, tex->mipLevels, tex->pitch, tex->tileMode, tex->swizzle, true);
 		}
 	}
 	tex->lastUpdateEventCounter = LatteTexture_getNextUpdateEventCounter();
 }
 
-LatteTextureView* LatteTexture_CreateTexture(uint32 textureUnit, Latte::E_DIM dim, MPTR physAddress, MPTR physMipAddress, Latte::E_GX2SURFFMT format, uint32 width, uint32 height, uint32 depth, uint32 pitch, uint32 mipLevels, uint32 swizzle, Latte::E_HWTILEMODE tileMode, bool isDepth)
+LatteTextureView* LatteTexture_CreateTexture(Latte::E_DIM dim, MPTR physAddress, MPTR physMipAddress, Latte::E_GX2SURFFMT format, uint32 width, uint32 height, uint32 depth, uint32 pitch, uint32 mipLevels, uint32 swizzle, Latte::E_HWTILEMODE tileMode, bool isDepth)
 {
-	const auto tex = g_renderer->texture_createTextureEx(textureUnit, dim, physAddress, physMipAddress, format, width, height, depth, pitch, mipLevels, swizzle, tileMode, isDepth);
+	const auto tex = g_renderer->texture_createTextureEx(dim, physAddress, physMipAddress, format, width, height, depth, pitch, mipLevels, swizzle, tileMode, isDepth);
 	// init slice/mip info array
 	LatteTexture_InitSliceAndMipInfo(tex);
 	LatteTexture_RegisterTextureMemoryOccupancy(tex);
@@ -112,7 +110,7 @@ LatteTextureView* LatteTexture_CreateTexture(uint32 textureUnit, Latte::E_DIM di
 			}
 		}
 	}
-	LatteTexture_ReloadData(tex, textureUnit);
+	LatteTexture_ReloadData(tex);
 	LatteTC_MarkTextureStillInUse(tex);
 	LatteTC_RegisterTexture(tex);
 	// create initial view that maps to the whole texture
@@ -209,13 +207,13 @@ void LatteTexture_updateTexturesForStage(LatteDecompilerShader* shaderContext, u
 		bool isDepthSampler = shaderContext->textureUsesDepthCompare[textureIndex];
 		// look for already existing texture
 		LatteTextureView* textureView;
-		if (isDepthSampler == false)
+		if (!isDepthSampler)
 			textureView = LatteTextureViewLookupCache::lookup(physAddr, width, height, depth, pitch, viewFirstMip, viewNumMips, viewFirstSlice, viewNumSlices, format, dim);
 		else
-			textureView = LatteTextureViewLookupCache::lookup(physAddr, width, height, depth, pitch, viewFirstMip, viewNumMips, viewFirstSlice, viewNumSlices, format, dim, true);
-		if (textureView == nullptr)
+			textureView = LatteTextureViewLookupCache::lookupWithColorOrDepthType(physAddr, width, height, depth, pitch, viewFirstMip, viewNumMips, viewFirstSlice, viewNumSlices, format, dim, true);
+		if (!textureView)
 		{
-			// create new mapping
+			// view not found, create a new mapping which will also create a new texture if necessary
 			textureView = LatteTexture_CreateMapping(physAddr, physMipAddr, width, height, depth, pitch, tileMode, swizzle, viewFirstMip, viewNumMips, viewFirstSlice, viewNumSlices, format, dim, dim, isDepthSampler);
 			if (textureView == nullptr)
 				continue;
@@ -231,25 +229,20 @@ void LatteTexture_updateTexturesForStage(LatteDecompilerShader* shaderContext, u
 			// if this texture is bound multiple times then use alternative views
 			if (textureView->lastTextureBindIndex == LatteGPUState.textureBindCounter)
 			{
-				// Intel driver has issues with textures that have multiple views bound and used by a shader, causes a softlock in BotW
-				// therefore we disable this on Intel
-				if (LatteGPUState.glVendor != GLVENDOR_INTEL_NOLEGACY)
+				LatteTextureViewGL* textureViewGL = (LatteTextureViewGL*)textureView;
+				// get next unused alternative texture view
+				while (true)
 				{
-					LatteTextureViewGL* textureViewGL = (LatteTextureViewGL*)textureView;
-					// get next unused alternative texture view
-					while (true)
-					{
-						textureViewGL = textureViewGL->GetAlternativeView();
-						if (textureViewGL->lastTextureBindIndex != LatteGPUState.textureBindCounter)
-							break;
-					}
-					textureView = textureViewGL;
+					textureViewGL = textureViewGL->GetAlternativeView();
+					if (textureViewGL->lastTextureBindIndex != LatteGPUState.textureBindCounter)
+						break;
 				}
-			}
+				textureView = textureViewGL;
+		}
 			textureView->lastTextureBindIndex = LatteGPUState.textureBindCounter;
 			rendererGL->renderstate_updateTextureSettingsGL(shaderContext, textureView, textureIndex + glBackendBaseTexUnit, word4, textureIndex, isDepthSampler);
 		}
-		g_renderer->texture_bindOnly(textureView, textureIndex + glBackendBaseTexUnit);
+		g_renderer->texture_setLatteTexture(textureView, textureIndex + glBackendBaseTexUnit);
 		// update if data changed
 		bool swizzleChanged = false;
 		if (textureView->baseTexture->swizzle != swizzle)
@@ -275,9 +268,7 @@ void LatteTexture_updateTexturesForStage(LatteDecompilerShader* shaderContext, u
 		// check for changes
 		if (LatteTC_HasTextureChanged(textureView->baseTexture) || swizzleChanged)
 		{
-#ifndef PUBLIC_RELEASE
 			debug_printf("Reload texture 0x%08x res %dx%d memRange %08x-%08x SwizzleChange: %s\n", textureView->baseTexture->physAddress, textureView->baseTexture->width, textureView->baseTexture->height, textureView->baseTexture->texDataPtrLow, textureView->baseTexture->texDataPtrHigh, swizzleChanged ? "yes" : "no");
-#endif
 			// update swizzle / changed mip address
 			if (swizzleChanged)
 			{
@@ -287,9 +278,8 @@ void LatteTexture_updateTexturesForStage(LatteDecompilerShader* shaderContext, u
 					textureView->baseTexture->physMipAddress = physMipAddr;
 				}
 			}
-			g_renderer->texture_bindAndActivateRawTex(textureView->baseTexture, textureIndex + glBackendBaseTexUnit);
 			debug_printf("Reload reason: Data-change when bound as texture (new hash 0x%08x)\n", textureView->baseTexture->texDataHash2);
-			LatteTexture_ReloadData(textureView->baseTexture, textureIndex + glBackendBaseTexUnit);
+			LatteTexture_ReloadData(textureView->baseTexture);
 		}
 		LatteTexture* baseTexture = textureView->baseTexture;
 		if (baseTexture->reloadFromDynamicTextures)
@@ -330,53 +320,15 @@ void LatteTexture_updateTextures()
 	// pixel shader
 	LatteDecompilerShader* pixelShader = LatteSHRC_GetActivePixelShader();
 	if (pixelShader)
-		LatteTexture_updateTexturesForStage(pixelShader, CEMU_PS_TEX_UNIT_BASE, LatteGPUState.contextNew.SQ_TEX_START_PS);
+		LatteTexture_updateTexturesForStage(pixelShader, LATTE_CEMU_PS_TEX_UNIT_BASE, LatteGPUState.contextNew.SQ_TEX_START_PS);
 	// vertex shader
 	LatteDecompilerShader* vertexShader = LatteSHRC_GetActiveVertexShader();
 	cemu_assert_debug(vertexShader != nullptr);
-	LatteTexture_updateTexturesForStage(vertexShader, CEMU_VS_TEX_UNIT_BASE, LatteGPUState.contextNew.SQ_TEX_START_VS);
+	LatteTexture_updateTexturesForStage(vertexShader, LATTE_CEMU_VS_TEX_UNIT_BASE, LatteGPUState.contextNew.SQ_TEX_START_VS);
 	// geometry shader
 	LatteDecompilerShader* geometryShader = LatteSHRC_GetActiveGeometryShader();
 	if (geometryShader)
-		LatteTexture_updateTexturesForStage(geometryShader, CEMU_GS_TEX_UNIT_BASE, LatteGPUState.contextNew.SQ_TEX_START_GS);
-}
-
-// returns the width, height, depth of the texture
-void LatteTexture_getSize(LatteTexture* texture, sint32* width, sint32* height, sint32* depth, sint32 mipLevel)
-{
-	*width = texture->width;
-	*height = texture->height;
-	if (depth != NULL)
-		*depth = texture->depth;
-	// handle mip level
-	*width = std::max(1, *width >> mipLevel);
-	*height = std::max(1, *height >> mipLevel);
-	if(texture->Is3DTexture() && depth)
-		*depth = std::max(1, *depth >> mipLevel);
-}
-
-/*
- * Returns the internally used width/height/depth of the texture
- * Usually this is the width/height/depth specified by the game,
- * unless the texture resolution was redefined via graphic pack texture rules
- */
-void LatteTexture_getEffectiveSize(LatteTexture* texture, sint32* effectiveWidth, sint32* effectiveHeight, sint32* effectiveDepth, sint32 mipLevel)
-{
-	*effectiveWidth = texture->width;
-	*effectiveHeight = texture->height;
-	if( effectiveDepth != NULL )
-		*effectiveDepth = texture->depth;
-	if( texture->overwriteInfo.hasResolutionOverwrite )
-	{
-		*effectiveWidth = texture->overwriteInfo.width;
-		*effectiveHeight = texture->overwriteInfo.height;
-		if( effectiveDepth != NULL )
-			*effectiveDepth = texture->overwriteInfo.depth;
-	}
-	// handle mipLevel
-	// todo: Mip-mapped 3D textures decrease in depth also?
-	*effectiveWidth = std::max(1, *effectiveWidth >> mipLevel);
-	*effectiveHeight = std::max(1, *effectiveHeight >> mipLevel);
+		LatteTexture_updateTexturesForStage(geometryShader, LATTE_CEMU_GS_TEX_UNIT_BASE, LatteGPUState.contextNew.SQ_TEX_START_GS);
 }
 
 sint32 LatteTexture_getEffectiveWidth(LatteTexture* texture)
diff --git a/src/Cafe/HW/Latte/Core/LatteTextureLoader.cpp b/src/Cafe/HW/Latte/Core/LatteTextureLoader.cpp
index 5bd71e81..c06a3bf1 100644
--- a/src/Cafe/HW/Latte/Core/LatteTextureLoader.cpp
+++ b/src/Cafe/HW/Latte/Core/LatteTextureLoader.cpp
@@ -599,7 +599,7 @@ void LatteTextureLoader_loadTextureDataIntoSlice(LatteTexture* hostTexture, sint
 	}
 }
 
-void LatteTextureLoader_UpdateTextureSliceData(LatteTexture* tex, sint32 textureUnit, uint32 sliceIndex, uint32 mipIndex, MPTR physImagePtr, MPTR physMipPtr, Latte::E_DIM dim, uint32 width, uint32 height, uint32 depth, uint32 mipLevels, uint32 pitch, Latte::E_HWTILEMODE tileMode, uint32 swizzle, bool dumpTex)
+void LatteTextureLoader_UpdateTextureSliceData(LatteTexture* tex, uint32 sliceIndex, uint32 mipIndex, MPTR physImagePtr, MPTR physMipPtr, Latte::E_DIM dim, uint32 width, uint32 height, uint32 depth, uint32 mipLevels, uint32 pitch, Latte::E_HWTILEMODE tileMode, uint32 swizzle, bool dumpTex)
 {
 	LatteTextureLoaderCtx textureLoader = { 0 };
 	
@@ -621,7 +621,7 @@ void LatteTextureLoader_UpdateTextureSliceData(LatteTexture* tex, sint32 texture
 
 	if (tex->isDataDefined == false)
 	{
-		g_renderer->texture_reserveTextureOnGPU(tex);
+		tex->AllocateOnHost();
 		tex->isDataDefined = true;
 		// if decoder is not set then clear texture
 		// on Vulkan this is used to make sure the texture is no longer in UNDEFINED layout
@@ -661,7 +661,7 @@ void LatteTextureLoader_UpdateTextureSliceData(LatteTexture* tex, sint32 texture
 	uint64 benchmarkResultMicroSeconds = (benchmark_end.QuadPart - benchmark_begin.QuadPart) * 1000000ULL / benchmark_freq.QuadPart;
 	textureDecodeBenchmark_perFormatSum[(int)tex->format & 0x3F] += benchmarkResultMicroSeconds;
 	textureDecodeBenchmark_totalSum += benchmarkResultMicroSeconds;
-	forceLog_printf("TexDecode %04dx%04dx%04d Fmt %04x Dim %d TileMode %02x Took %03d.%03dms Sum(format) %06dms Sum(total) %06dms", textureLoader.width, textureLoader.height, textureLoader.surfaceInfoDepth, (int)tex->format, (int)tex->dim, textureLoader.tileMode, (uint32)(benchmarkResultMicroSeconds / 1000ULL), (uint32)(benchmarkResultMicroSeconds % 1000ULL), (uint32)(textureDecodeBenchmark_perFormatSum[tex->gx2Format & 0x3F] / 1000ULL), (uint32)(textureDecodeBenchmark_totalSum / 1000ULL));
+	cemuLog_log(LogType::Force, "TexDecode {:04}x{:04}x{:04} Fmt {:04x} Dim {} TileMode {:02x} Took {:03}.{:03}ms Sum(format) {:06}ms Sum(total) {:06}ms", textureLoader.width, textureLoader.height, textureLoader.surfaceInfoDepth, (int)tex->format, (int)tex->dim, textureLoader.tileMode, (uint32)(benchmarkResultMicroSeconds / 1000ULL), (uint32)(benchmarkResultMicroSeconds % 1000ULL), (uint32)(textureDecodeBenchmark_perFormatSum[tex->gx2Format & 0x3F] / 1000ULL), (uint32)(textureDecodeBenchmark_totalSum / 1000ULL));
 #endif
 
 	// convert texture to RGBA when dumping is enabled
@@ -695,7 +695,7 @@ void LatteTextureLoader_UpdateTextureSliceData(LatteTexture* tex, sint32 texture
 	if (textureLoader.dump)
 	{
 		wchar_t path[1024];
-		swprintf(path, 1024, L"dump\\textures\\%08x_fmt%04x_slice%d_mip%02d_%dx%d_tm%02d.tga", physImagePtr, (uint32)tex->format, sliceIndex, mipIndex, tex->width, tex->height, tileMode);
+		swprintf(path, 1024, L"dump/textures/%08x_fmt%04x_slice%d_mip%02d_%dx%d_tm%02d.tga", physImagePtr, (uint32)tex->format, sliceIndex, mipIndex, tex->width, tex->height, tileMode);
 		tga_write_rgba(path, textureLoader.width, textureLoader.height, textureLoader.dumpRGBA);
 		free(textureLoader.dumpRGBA);
 	}
@@ -736,16 +736,18 @@ void LatteTextureLoader_writeReadbackTextureToMemory(LatteTextureDefinition* tex
 	LatteTextureLoaderCtx textureLoader = { 0 };
 	LatteTextureLoader_begin(&textureLoader, sliceIndex, mipIndex, textureData->physAddress, textureData->physMipAddress, textureData->format, textureData->dim, textureData->width, textureData->height, textureData->depth, textureData->mipLevels, textureData->pitch, textureData->tileMode, textureData->swizzle);
 
-#ifndef PUBLIC_RELEASE
+#ifdef CEMU_DEBUG_ASSERT
 	if (textureData->depth != 1)
-		forceLog_printf("_writeReadbackTextureToMemory(): Texture has multiple slices (not supported)");
+		cemuLog_log(LogType::Force, "_writeReadbackTextureToMemory(): Texture has multiple slices (not supported)");
 #endif
 	if (textureLoader.physAddress == MPTR_NULL)
 	{
-		forceLog_printf("_writeReadbackTextureToMemory(): Texture has invalid address");
+		cemuLog_log(LogType::Force, "_writeReadbackTextureToMemory(): Texture has invalid address");
 		return;
 	}
 
+	cemuLog_log(LogType::TextureReadback, "[TextureReadback-Write] PhysAddr {:08x} Res {}x{} Fmt {} Slice {} Mip {}", textureData->physAddress, textureData->width, textureData->height, textureData->format, sliceIndex, mipIndex);
+
 	if (textureData->tileMode == Latte::E_HWTILEMODE::TM_LINEAR_ALIGNED)
 	{
 		uint32 pitch = textureLoader.width;
@@ -816,7 +818,7 @@ void LatteTextureLoader_writeReadbackTextureToMemory(LatteTextureDefinition* tex
 		}
 		else
 		{
-			forceLogDebug_printf("Linear texture readback unsupported for format 0x%04x", (uint32)textureData->format);
+			cemuLog_logDebug(LogType::Force, "Linear texture readback unsupported for format 0x{:04x}", (uint32)textureData->format);
 			debugBreakpoint();
 		}
 		return;
@@ -854,7 +856,7 @@ void LatteTextureLoader_writeReadbackTextureToMemory(LatteTextureDefinition* tex
 	}	
 	else
 	{
-		forceLogDebug_printf("Texture readback unsupported format %04x for tileMode 0x%02x", (uint32)textureData->format, textureData->tileMode);
+		cemuLog_logDebug(LogType::Force, "Texture readback unsupported format {:04x} for tileMode 0x{:02x}", (uint32)textureData->format, textureData->tileMode);
 	}
 
 }
diff --git a/src/Cafe/HW/Latte/Core/LatteTextureLoader.h b/src/Cafe/HW/Latte/Core/LatteTextureLoader.h
index 7c89a09a..f6de57d6 100644
--- a/src/Cafe/HW/Latte/Core/LatteTextureLoader.h
+++ b/src/Cafe/HW/Latte/Core/LatteTextureLoader.h
@@ -556,7 +556,7 @@ public:
 	}
 };
 
-class TextureDecoder_R4_G4_UNORM_toRGBA4444 : public TextureDecoder, public SingletonClass<TextureDecoder_R4_G4_UNORM_toRGBA4444>
+class TextureDecoder_R4_G4_UNORM_To_RGBA4 : public TextureDecoder, public SingletonClass<TextureDecoder_R4_G4_UNORM_To_RGBA4>
 {
 public:
 	sint32 getBytesPerTexel(LatteTextureLoaderCtx* textureLoader) override
@@ -594,7 +594,7 @@ public:
 	}
 };
 
-class TextureDecoder_R4_G4_UNORM_toRGBA4444_vk : public TextureDecoder, public SingletonClass<TextureDecoder_R4_G4_UNORM_toRGBA4444_vk>
+class TextureDecoder_R4_G4_UNORM_To_RGBA4_vk : public TextureDecoder, public SingletonClass<TextureDecoder_R4_G4_UNORM_To_RGBA4_vk>
 {
 public:
 	sint32 getBytesPerTexel(LatteTextureLoaderCtx* textureLoader) override
@@ -612,8 +612,8 @@ public:
 				uint8* blockData = LatteTextureLoader_GetInput(textureLoader, x, y);
 				sint32 pixelOffset = (x + yc * textureLoader->width) * 2;
 				uint8 v = (*(uint8*)(blockData + 0));
-				*(uint8*)(outputData + pixelOffset + 1) = 0;
-				*(uint8*)(outputData + pixelOffset + 0) = ((v >> 4) & 0xF) | ((v << 4) & 0xF0); // todo: Is this nibble swap correct?
+				*(uint8*)(outputData + pixelOffset + 0) = 0;
+				*(uint8*)(outputData + pixelOffset + 1) = v;
 			}
 		}
 	}
@@ -632,6 +632,52 @@ public:
 	}
 };
 
+class TextureDecoder_R4G4_UNORM_To_RGBA8 : public TextureDecoder, public SingletonClass<TextureDecoder_R4G4_UNORM_To_RGBA8>
+{
+public:
+	sint32 getBytesPerTexel(LatteTextureLoaderCtx* textureLoader) override
+	{
+		return 4;
+	}
+
+	void decode(LatteTextureLoaderCtx* textureLoader, uint8* outputData) override
+	{
+		for (sint32 y = 0; y < textureLoader->height; y += textureLoader->stepY)
+		{
+			sint32 yc = y;
+			for (sint32 x = 0; x < textureLoader->width; x += textureLoader->stepX)
+			{
+				uint8* blockData = LatteTextureLoader_GetInput(textureLoader, x, y);
+				sint32 pixelOffset = (x + yc * textureLoader->width) * 4;
+				uint8 v0 = (*(uint8*)(blockData + 0));
+
+				uint8 red4 = (v0 >> 4) & 0xF;
+				uint8 green4 = (v0 & 0xF);
+
+				red4 = (red4 << 4) | red4;
+				green4 = (green4 << 4) | green4;
+
+				*(uint8*)(outputData + pixelOffset + 0) = red4;
+				*(uint8*)(outputData + pixelOffset + 1) = green4;
+				*(uint8*)(outputData + pixelOffset + 2) = 0;
+				*(uint8*)(outputData + pixelOffset + 3) = 255;
+			}
+		}
+	}
+
+	void decodePixelToRGBA(uint8* blockData, uint8* outputPixel, uint8 blockOffsetX, uint8 blockOffsetY) override
+	{
+		uint8 v0 = *(blockData + 0);
+		uint8 red4 = (v0 >> 4) & 0xF;
+		uint8 green4 = (v0 & 0xF);
+		red4 = (red4 << 4) | red4;
+		green4 = (green4 << 4) | green4;
+		*(outputPixel + 0) = red4;
+		*(outputPixel + 1) = green4;
+		*(outputPixel + 2) = 0;
+		*(outputPixel + 3) = 255;
+	}
+};
 
 class TextureDecoder_R4_G4_B4_A4_UNORM : public TextureDecoder, public SingletonClass<TextureDecoder_R4_G4_B4_A4_UNORM>
 {
@@ -677,6 +723,67 @@ public:
 	}
 };
 
+
+class TextureDecoder_R4G4B4A4_UNORM_To_RGBA8 : public TextureDecoder, public SingletonClass<TextureDecoder_R4G4B4A4_UNORM_To_RGBA8>
+{
+public:
+	sint32 getBytesPerTexel(LatteTextureLoaderCtx* textureLoader) override
+	{
+		return 4;
+	}
+
+	void decode(LatteTextureLoaderCtx* textureLoader, uint8* outputData) override
+	{
+		for (sint32 y = 0; y < textureLoader->height; y += textureLoader->stepY)
+		{
+			sint32 yc = y;
+			for (sint32 x = 0; x < textureLoader->width; x += textureLoader->stepX)
+			{
+				uint8* blockData = LatteTextureLoader_GetInput(textureLoader, x, y);
+				sint32 pixelOffset = (x + yc * textureLoader->width) * 4;
+				uint8 v0 = (*(uint8*)(blockData + 0));
+				uint8 v1 = (*(uint8*)(blockData + 1));
+
+				uint8 red4 = (v0 & 0xF);
+				uint8 green4 = (v0 >> 4) & 0xF;
+				uint8 blue4 = (v1) & 0xF;
+				uint8 alpha4 = (v1 >> 4) & 0xF;
+
+				red4 = (red4 << 4) | red4;
+				green4 = (green4 << 4) | green4;
+				blue4 = (blue4 << 4) | blue4;
+				alpha4 = (alpha4 << 4) | alpha4;
+
+				*(uint8*)(outputData + pixelOffset + 0) = red4;
+				*(uint8*)(outputData + pixelOffset + 1) = green4;
+				*(uint8*)(outputData + pixelOffset + 2) = blue4;
+				*(uint8*)(outputData + pixelOffset + 3) = alpha4;
+			}
+		}
+	}
+
+	void decodePixelToRGBA(uint8* blockData, uint8* outputPixel, uint8 blockOffsetX, uint8 blockOffsetY) override
+	{
+		uint8 v0 = *(blockData + 0);
+		uint8 v1 = *(blockData + 1);
+
+		uint8 red4 = (v0 & 0xF);
+		uint8 green4 = (v0 >> 4) & 0xF;
+		uint8 blue4 = (v1) & 0xF;
+		uint8 alpha4 = (v1 >> 4) & 0xF;
+
+		red4 = (red4 << 4) | red4;
+		green4 = (green4 << 4) | green4;
+		blue4 = (blue4 << 4) | blue4;
+		alpha4 = (alpha4 << 4) | alpha4;
+
+		*(outputPixel + 0) = red4;
+		*(outputPixel + 1) = green4;
+		*(outputPixel + 2) = blue4;
+		*(outputPixel + 3) = alpha4;
+	}
+};
+
 class TextureDecoder_R8_G8_B8_A8 : public TextureDecoder, public SingletonClass<TextureDecoder_R8_G8_B8_A8>
 {
 public:
@@ -978,6 +1085,57 @@ public:
 	}
 };
 
+class TextureDecoder_R5G6B5_UNORM_To_RGBA8 : public TextureDecoder, public SingletonClass<TextureDecoder_R5G6B5_UNORM_To_RGBA8>
+{
+public:
+	sint32 getBytesPerTexel(LatteTextureLoaderCtx* textureLoader) override
+	{
+		return 4;
+	}
+
+	void decode(LatteTextureLoaderCtx* textureLoader, uint8* outputData) override
+	{
+		for (sint32 y = 0; y < textureLoader->height; y += textureLoader->stepY)
+		{
+			sint32 yc = y;
+			for (sint32 x = 0; x < textureLoader->width; x += textureLoader->stepX)
+			{
+				uint8* blockData = LatteTextureLoader_GetInput(textureLoader, x, y);
+				sint32 pixelOffset = (x + yc * textureLoader->width) * 4;
+				uint16 v0 = (*(uint16*)(blockData + 0));
+
+				uint8 c0 = (v0 & 0x1F);
+				uint8 c1 = (v0 >> 5) & 0x3F;
+				uint8 c2 = (v0 >> 11) & 0x1F;
+
+				c0 = (c0 << 3) | c0 >> 3;// blue
+				c1 = (c1 << 2) | c1 >> 4;// green
+				c2 = (c2 << 3) | c2 >> 3;// red
+
+				*(uint8*)(outputData + pixelOffset + 0) = c0;// blue
+				*(uint8*)(outputData + pixelOffset + 1) = c1;// green
+				*(uint8*)(outputData + pixelOffset + 2) = c2;// red
+				*(uint8*)(outputData + pixelOffset + 3) = 255;//alpha
+			}
+		}
+	}
+
+	void decodePixelToRGBA(uint8* blockData, uint8* outputPixel, uint8 blockOffsetX, uint8 blockOffsetY) override
+	{
+		uint16 v0 = *(uint16*)(blockData + 0);
+		uint8 c0 = (v0 & 0x1F);// red
+		uint8 c1 = (v0 >> 5) & 0x3F;// green
+		uint8 c2 = (v0 >> 11) & 0x1F; // blue
+		c0 = (c0 << 3) | c0 >> 3;
+		c1 = (c1 << 2) | c1 >> 4;
+		c2 = (c2 << 3) | c2 >> 3;
+		*(outputPixel + 0) = c0;// red
+		*(outputPixel + 1) = c1;// green
+		*(outputPixel + 2) = c2;// blue
+		*(outputPixel + 3) = 255;// alpha
+	}
+};
+
 class TextureDecoder_R5_G5_B5_A1_UNORM : public TextureDecoder, public SingletonClass<TextureDecoder_R5_G5_B5_A1_UNORM>
 {
 public:
@@ -1045,6 +1203,58 @@ public:
 	}
 };
 
+class TextureDecoder_R5_G5_B5_A1_UNORM_swappedRB_To_RGBA8 : public TextureDecoder, public SingletonClass<TextureDecoder_R5_G5_B5_A1_UNORM_swappedRB_To_RGBA8>
+{
+public:
+//2656
+    sint32 getBytesPerTexel(LatteTextureLoaderCtx* textureLoader) override
+    {
+        return 4;
+    }
+
+    void decode(LatteTextureLoaderCtx* textureLoader, uint8* outputData) override
+    {
+        for (sint32 y = 0; y < textureLoader->height; y += textureLoader->stepY)
+        {
+            sint32 yc = y;
+            for (sint32 x = 0; x < textureLoader->width; x += textureLoader->stepX)
+            {
+                uint16* blockData = (uint16*)LatteTextureLoader_GetInput(textureLoader, x, y);
+                sint32 pixelOffset = (x + yc * textureLoader->width) * 4;
+                uint32 colorData = (*(uint16*)(blockData + 0));
+                // swap order of components
+                uint8 red = (colorData >> 0) & 0x1F;
+                uint8 green = (colorData >> 5) & 0x1F;
+                uint8 blue = (colorData >> 10) & 0x1F;
+                uint8 alpha = (colorData >> 15) & 0x1;
+
+                red = red << 3 | red >> 2;
+                green = green << 3 | green >> 2;
+                blue = blue << 3 | blue >> 2;
+                alpha = alpha * 0xff;
+
+                // MSB...LSB : ABGR
+                colorData = (alpha << 24) | (blue << 16) | (green << 8) | red;
+                *(uint32*)(outputData + pixelOffset + 0) = colorData;
+            }
+        }
+    }
+
+    void decodePixelToRGBA(uint8* blockData, uint8* outputPixel, uint8 blockOffsetX, uint8 blockOffsetY) override
+    {
+        uint16 colorData = (*(uint16*)blockData);
+        uint8 red = (colorData >> 0) & 0x1F;
+        uint8 green = (colorData >> 5) & 0x1F;
+        uint8 blue = (colorData >> 10) & 0x1F;
+        uint8 alpha = (colorData >> 15) & 0x1;
+        *(outputPixel + 0) = (red << 3) | (red >> 2);
+        *(outputPixel + 1) = (green << 3) | (green >> 2);
+        *(outputPixel + 2) = (blue << 3) | (blue >> 2);
+        *(outputPixel + 3) = alpha * 0xff;
+    }
+
+};
+
 class uint16_R5_G5_B5_A1_swapOpenGL
 {
 public:
@@ -1158,6 +1368,56 @@ public:
 	}
 };
 
+class TextureDecoder_A1_B5_G5_R5_UNORM_vulkan_To_RGBA8 : public TextureDecoder, public SingletonClass<TextureDecoder_A1_B5_G5_R5_UNORM_vulkan_To_RGBA8>
+{
+public:
+    sint32 getBytesPerTexel(LatteTextureLoaderCtx* textureLoader) override
+    {
+        return 4;
+    }
+
+    void decode(LatteTextureLoaderCtx* textureLoader, uint8* outputData) override
+    {
+        for (sint32 y = 0; y < textureLoader->height; y += textureLoader->stepY)
+        {
+            sint32 yc = y;
+            for (sint32 x = 0; x < textureLoader->width; x += textureLoader->stepX)
+            {
+                uint16* blockData = (uint16*)LatteTextureLoader_GetInput(textureLoader, x, y);
+                sint32 pixelOffset = (x + yc * textureLoader->width) * 4;
+                uint32 colorData = (*(uint16*)(blockData + 0));
+                // swap order of components
+                uint8 red = (colorData >> 11) & 0x1F;
+                uint8 green = (colorData >> 6) & 0x1F;
+                uint8 blue = (colorData >> 1) & 0x1F;
+                uint8 alpha = (colorData >> 0) & 0x1;
+
+                red = red << 3 | red >> 2;
+                green = green << 3 | green >> 2;
+                blue = blue << 3 | blue >> 2;
+                alpha = alpha * 0xff;
+
+                // MSB...LSB ABGR
+                colorData = red | (green << 8) | (blue << 16) | (alpha << 24);
+                *(uint32*)(outputData + pixelOffset + 0) = colorData;
+            }
+        }
+    }
+
+    void decodePixelToRGBA(uint8* blockData, uint8* outputPixel, uint8 blockOffsetX, uint8 blockOffsetY) override
+    {
+        uint16 colorData = (*(uint16*)blockData);
+        uint8 red5 = (colorData >> 11) & 0x1F;
+        uint8 green5 = (colorData >> 6) & 0x1F;
+        uint8 blue5 = (colorData >> 1) & 0x1F;
+        uint8 alpha1 = (colorData >> 0) & 0x1;
+        *(outputPixel + 0) = (red5 << 3) | (red5 >> 2);
+        *(outputPixel + 1) = (green5 << 3) | (green5 >> 2);
+        *(outputPixel + 2) = (blue5 << 3) | (blue5 >> 2);
+        *(outputPixel + 3) = (alpha1 << 3);
+    }
+};
+
 
 class TextureDecoder_R10_G10_B10_A2_UNORM : public TextureDecoder, public SingletonClass<TextureDecoder_R10_G10_B10_A2_UNORM>
 {
@@ -1185,7 +1445,7 @@ public:
 	}
 };
 
-class TextureDecoder_R10_G10_B10_A2_SNORM_toRGBA16 : public TextureDecoder, public SingletonClass<TextureDecoder_R10_G10_B10_A2_SNORM_toRGBA16>
+class TextureDecoder_R10_G10_B10_A2_SNORM_To_RGBA16 : public TextureDecoder, public SingletonClass<TextureDecoder_R10_G10_B10_A2_SNORM_To_RGBA16>
 {
 public:
 	sint32 getBytesPerTexel(LatteTextureLoaderCtx* textureLoader) override
@@ -1230,7 +1490,7 @@ public:
 	}
 };
 
-class TextureDecoder_A2_B10_G10_R10_UNORM_toRGBA16 : public TextureDecoder, public SingletonClass<TextureDecoder_A2_B10_G10_R10_UNORM_toRGBA16>
+class TextureDecoder_A2_B10_G10_R10_UNORM_To_RGBA16 : public TextureDecoder, public SingletonClass<TextureDecoder_A2_B10_G10_R10_UNORM_To_RGBA16>
 {
 public:
 	sint32 getBytesPerTexel(LatteTextureLoaderCtx* textureLoader) override
diff --git a/src/Cafe/HW/Latte/Core/LatteTextureReadback.cpp b/src/Cafe/HW/Latte/Core/LatteTextureReadback.cpp
index bd579b11..8df5dcea 100644
--- a/src/Cafe/HW/Latte/Core/LatteTextureReadback.cpp
+++ b/src/Cafe/HW/Latte/Core/LatteTextureReadback.cpp
@@ -8,10 +8,11 @@
 #include "Cafe/HW/Latte/Core/LatteTexture.h"
 #include "Cafe/HW/Latte/Renderer/OpenGL/LatteTextureViewGL.h"
 
-// #define LOG_READBACK_TIME
+#define LOG_READBACK_TIME
 
 struct LatteTextureReadbackQueueEntry
 {
+	HRTick initiateTime;
 	uint32 lastUpdateDrawcallIndex;
 	LatteTextureView* textureView;
 };
@@ -21,17 +22,18 @@ std::queue<LatteTextureReadbackInfo*> sTextureActiveReadbackQueue; // readbacks
 
 void LatteTextureReadback_StartTransfer(LatteTextureView* textureView)
 {
+	cemuLog_log(LogType::TextureReadback, "[TextureReadback-Start] PhysAddr {:08x} Res {}x{} Fmt {} Slice {} Mip {}", textureView->baseTexture->physAddress, textureView->baseTexture->width, textureView->baseTexture->height, textureView->baseTexture->format, textureView->firstSlice, textureView->firstMip);
+	HRTick currentTick = HighResolutionTimer().now().getTick();
 	// create info entry and store in ordered linked list
 	LatteTextureReadbackInfo* readbackInfo = g_renderer->texture_createReadback(textureView);
 	sTextureActiveReadbackQueue.push(readbackInfo);
 	readbackInfo->StartTransfer();
-	//debug_printf("[Tex-Readback] %08x %dx%d TM %d FMT %04x\n", textureView->baseTexture->physAddress, textureView->baseTexture->width, textureView->baseTexture->height, textureView->baseTexture->tileMode, textureView->baseTexture->format);
-	readbackInfo->transferStartTime = HighResolutionTimer().now().getTick();
+	readbackInfo->transferStartTime = currentTick;
 }
 
 /*
- * Checks for queued transfers and starts them if at least one drawcall has passed since the last write
- * Called after a draw operation has finished
+ * Checks for queued transfers and starts them if at least five drawcalls have passed since the last write
+ * Called after a draw sequence is completed
  * Returns true if at least one transfer was started
  */
 bool LatteTextureReadback_Update(bool forceStart)
@@ -40,13 +42,19 @@ bool LatteTextureReadback_Update(bool forceStart)
 	for (size_t i = 0; i < sTextureScheduledReadbacks.size(); i++)
 	{
 		LatteTextureReadbackQueueEntry& entry = sTextureScheduledReadbacks[i];
-		uint32 numPassedDrawcalls = LatteGPUState.drawCallCounter - entry.lastUpdateDrawcallIndex;
-		// initiate transfer
-		LatteTextureReadback_StartTransfer(entry.textureView);
-		// remove element
-		vectorRemoveByIndex(sTextureScheduledReadbacks, i);
-		i--;
-		hasStartedTransfer = true;
+		uint32 numElapsedDrawcalls = LatteGPUState.drawCallCounter - entry.lastUpdateDrawcallIndex;
+		if (forceStart || numElapsedDrawcalls >= 5)
+		{
+#ifdef LOG_READBACK_TIME
+			double elapsedSecondsSinceInitiate = HighResolutionTimer::getTimeDiff(entry.initiateTime, HighResolutionTimer().now().getTick());
+			cemuLog_log(LogType::TextureReadback, "[TextureReadback-Update] Starting transfer for {:08x} after {} elapsed drawcalls. Time since initiate: {:.4} Force-start: {}", entry.textureView->baseTexture->physAddress, numElapsedDrawcalls, elapsedSecondsSinceInitiate, forceStart?"yes":"no");
+#endif
+			LatteTextureReadback_StartTransfer(entry.textureView);
+			// remove element
+			vectorRemoveByIndex(sTextureScheduledReadbacks, i);
+			i--;
+			hasStartedTransfer = true;
+		}
 	}
 	return hasStartedTransfer;
 }
@@ -73,7 +81,7 @@ void LatteTextureReadback_Initate(LatteTextureView* textureView)
 	// currently we don't support readback for resized textures
 	if (textureView->baseTexture->overwriteInfo.hasResolutionOverwrite)
 	{
-		forceLog_printf("_initate(): Readback is not supported for textures with modified resolution");
+		cemuLog_log(LogType::Force, "Texture readback is not supported for textures with modified resolution. Texture: {:08x} {}x{}", textureView->baseTexture->physAddress, textureView->baseTexture->width, textureView->baseTexture->height);
 		return;
 	}
 	// check if texture isn't already queued for transfer
@@ -88,6 +96,7 @@ void LatteTextureReadback_Initate(LatteTextureView* textureView)
 	}
 	// queue
 	LatteTextureReadbackQueueEntry queueEntry;
+	queueEntry.initiateTime = HighResolutionTimer().now().getTick();
 	queueEntry.textureView = textureView;
 	queueEntry.lastUpdateDrawcallIndex = LatteGPUState.drawCallCounter;
 	sTextureScheduledReadbacks.emplace_back(queueEntry);
@@ -109,6 +118,14 @@ void LatteTextureReadback_UpdateFinishedTransfers(bool forceFinish)
 			if (!readbackInfo->IsFinished())
 			{
 				readbackInfo->waitStartTime = HighResolutionTimer().now().getTick();
+#ifdef LOG_READBACK_TIME
+				if (cemuLog_isLoggingEnabled(LogType::TextureReadback))
+				{
+					double elapsedSecondsTransfer = HighResolutionTimer::getTimeDiff(readbackInfo->transferStartTime, HighResolutionTimer().now().getTick());
+					cemuLog_log(LogType::TextureReadback, "[Texture-Readback] Force-finish: {:08x} Res {:}/{:} TM {:} FMT {:04x} Transfer time so far: {:.4}ms", readbackInfo->hostTextureCopy.physAddress, readbackInfo->hostTextureCopy.width, readbackInfo->hostTextureCopy.height, readbackInfo->hostTextureCopy.tileMode, (uint32)readbackInfo->hostTextureCopy.format, elapsedSecondsTransfer * 1000.0);
+				}
+#endif
+				readbackInfo->forceFinish = true;
 				readbackInfo->ForceFinish();
 				// rerun logic since ->ForceFinish() can recurively call this function and thus modify the queue
 				continue;
@@ -122,10 +139,13 @@ void LatteTextureReadback_UpdateFinishedTransfers(bool forceFinish)
 		}
 		// performance testing
 #ifdef LOG_READBACK_TIME
-		HRTick currentTick = HighResolutionTimer().now().getTick();
-		double elapsedSecondsTransfer = HighResolutionTimer::getTimeDiff(readbackInfo->transferStartTime, currentTick);
-		double elapsedSecondsWaiting = HighResolutionTimer::getTimeDiff(readbackInfo->waitStartTime, currentTick);
-		forceLog_printf("[Texture-Readback] %08x Res %4d/%4d TM %d FMT %04x ReadbackLatency: %6.3lfms WaitTime: %6.3lfms ForcedWait %s", readbackInfo->hostTextureCopy.physAddress, readbackInfo->hostTextureCopy.width, readbackInfo->hostTextureCopy.height, readbackInfo->hostTextureCopy.tileMode, (uint32)readbackInfo->hostTextureCopy.format, elapsedSecondsTransfer * 1000.0, elapsedSecondsWaiting * 1000.0, forceFinish?"yes":"no");
+		if (cemuLog_isLoggingEnabled(LogType::TextureReadback))
+		{
+			HRTick currentTick = HighResolutionTimer().now().getTick();
+			double elapsedSecondsTransfer = HighResolutionTimer::getTimeDiff(readbackInfo->transferStartTime, currentTick);
+			double elapsedSecondsWaiting = HighResolutionTimer::getTimeDiff(readbackInfo->waitStartTime, currentTick);
+			cemuLog_log(LogType::TextureReadback, "[Texture-Readback] {:08x} Res {}/{} TM {} FMT {:04x} ReadbackLatency: {:6.3}ms WaitTime: {:6.3}ms ForcedWait {}", readbackInfo->hostTextureCopy.physAddress, readbackInfo->hostTextureCopy.width, readbackInfo->hostTextureCopy.height, readbackInfo->hostTextureCopy.tileMode, (uint32)readbackInfo->hostTextureCopy.format, elapsedSecondsTransfer * 1000.0, elapsedSecondsWaiting * 1000.0, readbackInfo->forceFinish ? "yes" : "no");
+		}
 #endif
 		uint8* pixelData = readbackInfo->GetData();
 		LatteTextureLoader_writeReadbackTextureToMemory(&readbackInfo->hostTextureCopy, 0, 0, pixelData);
diff --git a/src/Cafe/HW/Latte/Core/LatteTextureReadbackInfo.h b/src/Cafe/HW/Latte/Core/LatteTextureReadbackInfo.h
index 4f3a3069..535e9442 100644
--- a/src/Cafe/HW/Latte/Core/LatteTextureReadbackInfo.h
+++ b/src/Cafe/HW/Latte/Core/LatteTextureReadbackInfo.h
@@ -21,6 +21,7 @@ public:
 
 	HRTick transferStartTime;
 	HRTick waitStartTime;
+	bool forceFinish{ false }; // set to true if not finished in time for dependent operation
 	// texture info
 	LatteTextureDefinition hostTextureCopy{};
 
diff --git a/src/Cafe/HW/Latte/Core/LatteTextureView.cpp b/src/Cafe/HW/Latte/Core/LatteTextureView.cpp
index cac5bcce..2773a34d 100644
--- a/src/Cafe/HW/Latte/Core/LatteTextureView.cpp
+++ b/src/Cafe/HW/Latte/Core/LatteTextureView.cpp
@@ -143,7 +143,6 @@ void LatteTextureViewLookupCache::RemoveAll(LatteTextureView* view)
 	}
 }
 
-
 LatteTextureView* LatteTextureViewLookupCache::lookup(MPTR physAddr, sint32 width, sint32 height, sint32 depth, sint32 pitch, sint32 firstMip, sint32 numMip, sint32 firstSlice, sint32 numSlice, Latte::E_GX2SURFFMT format, Latte::E_DIM dim)
 {
 	// todo - add tileMode param to this and the other lookup functions?
@@ -163,7 +162,7 @@ LatteTextureView* LatteTextureViewLookupCache::lookup(MPTR physAddr, sint32 widt
 	return nullptr;
 }
 
-LatteTextureView* LatteTextureViewLookupCache::lookup(MPTR physAddr, sint32 width, sint32 height, sint32 depth, sint32 pitch, sint32 firstMip, sint32 numMip, sint32 firstSlice, sint32 numSlice, Latte::E_GX2SURFFMT format, Latte::E_DIM dim, bool isDepth)
+LatteTextureView* LatteTextureViewLookupCache::lookupWithColorOrDepthType(MPTR physAddr, sint32 width, sint32 height, sint32 depth, sint32 pitch, sint32 firstMip, sint32 numMip, sint32 firstSlice, sint32 numSlice, Latte::E_GX2SURFFMT format, Latte::E_DIM dim, bool isDepth)
 {
 	cemu_assert_debug(firstSlice == 0);
 	uint32 key = _getViewBucketKey(physAddr, width, height, pitch);
diff --git a/src/Cafe/HW/Latte/Core/LatteTextureView.h b/src/Cafe/HW/Latte/Core/LatteTextureView.h
index a6d2e16c..abda084a 100644
--- a/src/Cafe/HW/Latte/Core/LatteTextureView.h
+++ b/src/Cafe/HW/Latte/Core/LatteTextureView.h
@@ -41,7 +41,7 @@ public:
 	static void RemoveAll(LatteTextureView* view);
 
 	static LatteTextureView* lookup(MPTR physAddr, sint32 width, sint32 height, sint32 depth, sint32 pitch, sint32 firstMip, sint32 numMip, sint32 firstSlice, sint32 numSlice, Latte::E_GX2SURFFMT format, Latte::E_DIM dim);
-	static LatteTextureView* lookup(MPTR physAddr, sint32 width, sint32 height, sint32 depth, sint32 pitch, sint32 firstMip, sint32 numMip, sint32 firstSlice, sint32 numSlice, Latte::E_GX2SURFFMT format, Latte::E_DIM dim, bool isDepth);
+	static LatteTextureView* lookupWithColorOrDepthType(MPTR physAddr, sint32 width, sint32 height, sint32 depth, sint32 pitch, sint32 firstMip, sint32 numMip, sint32 firstSlice, sint32 numSlice, Latte::E_GX2SURFFMT format, Latte::E_DIM dim, bool isDepth);
 	static LatteTextureView* lookupSlice(MPTR physAddr, sint32 width, sint32 height, sint32 pitch, sint32 firstMip, sint32 firstSlice, Latte::E_GX2SURFFMT format);
 	static LatteTextureView* lookupSliceMinSize(MPTR physAddr, sint32 minWidth, sint32 minHeight, sint32 pitch, sint32 firstMip, sint32 firstSlice, Latte::E_GX2SURFFMT format);
 	static LatteTextureView* lookupSliceEx(MPTR physAddr, sint32 width, sint32 height, sint32 pitch, sint32 firstMip, sint32 firstSlice, Latte::E_GX2SURFFMT format, bool isDepth);
diff --git a/src/Cafe/HW/Latte/Core/LatteThread.cpp b/src/Cafe/HW/Latte/Core/LatteThread.cpp
index d9b8ab94..e42dce5f 100644
--- a/src/Cafe/HW/Latte/Core/LatteThread.cpp
+++ b/src/Cafe/HW/Latte/Core/LatteThread.cpp
@@ -44,7 +44,7 @@ LatteTextureView* LatteHandleOSScreen_getOrCreateScreenTex(MPTR physAddress, uin
 	LatteTextureView* texView = LatteTextureViewLookupCache::lookup(physAddress, width, height, 1, pitch, 0, 1, 0, 1, Latte::E_GX2SURFFMT::R8_G8_B8_A8_UNORM, Latte::E_DIM::DIM_2D);
 	if (texView)
 		return texView;
-	return LatteTexture_CreateTexture(0, Latte::E_DIM::DIM_2D, physAddress, 0, Latte::E_GX2SURFFMT::R8_G8_B8_A8_UNORM, width, height, 1, pitch, 1, 0, Latte::E_HWTILEMODE::TM_LINEAR_ALIGNED, false);
+	return LatteTexture_CreateTexture(Latte::E_DIM::DIM_2D, physAddress, 0, Latte::E_GX2SURFFMT::R8_G8_B8_A8_UNORM, width, height, 1, pitch, 1, 0, Latte::E_HWTILEMODE::TM_LINEAR_ALIGNED, false);
 }
 
 void LatteHandleOSScreen_prepareTextures()
@@ -71,14 +71,13 @@ bool LatteHandleOSScreen_TV()
 	const uint32 bufferIndexTV = (bufferDisplayTV);
 	const uint32 bufferIndexDRC = bufferDisplayDRC;
 
-	g_renderer->texture_bindAndActivate(osScreenTVTex[bufferIndexTV], 0);
-	LatteTexture_ReloadData(osScreenTVTex[bufferIndexTV]->baseTexture, 0);
+	LatteTexture_ReloadData(osScreenTVTex[bufferIndexTV]->baseTexture);
 
 	// TV screen
 	LatteRenderTarget_copyToBackbuffer(osScreenTVTex[bufferIndexTV]->baseTexture->baseView, false);
 	
 	if (LatteGPUState.osScreen.screen[0].flipExecuteCount != LatteGPUState.osScreen.screen[0].flipRequestCount)
-		LatteGPUState.osScreen.screen[0].flipExecuteCount = LatteGPUState.osScreen.screen[0].flipRequestCount;
+		LatteGPUState.osScreen.screen[0].flipExecuteCount.store(LatteGPUState.osScreen.screen[0].flipRequestCount);
 	return true;
 }
 
@@ -94,14 +93,13 @@ bool LatteHandleOSScreen_DRC()
 
 	const uint32 bufferIndexDRC = bufferDisplayDRC;
 
-	g_renderer->texture_bindAndActivate(osScreenDRCTex[bufferIndexDRC], 0);
-	LatteTexture_ReloadData(osScreenDRCTex[bufferIndexDRC]->baseTexture, 0);
+	LatteTexture_ReloadData(osScreenDRCTex[bufferIndexDRC]->baseTexture);
 
 	// GamePad screen
 	LatteRenderTarget_copyToBackbuffer(osScreenDRCTex[bufferIndexDRC]->baseTexture->baseView, true);
 
 	if (LatteGPUState.osScreen.screen[1].flipExecuteCount != LatteGPUState.osScreen.screen[1].flipRequestCount)
-		LatteGPUState.osScreen.screen[1].flipExecuteCount = LatteGPUState.osScreen.screen[1].flipRequestCount;
+		LatteGPUState.osScreen.screen[1].flipExecuteCount.store(LatteGPUState.osScreen.screen[1].flipRequestCount);
 	return true;
 }
 
@@ -117,19 +115,11 @@ int Latte_ThreadEntry()
 {
 	SetThreadName("LatteThread");
 	sint32 w,h;
-	gui_getWindowSize(&w,&h);
-
-	// imgui
-	ImGui::CreateContext();
-	ImGuiIO& io = ImGui::GetIO();
-	io.WantSaveIniSettings = false;
-	io.IniFilename = nullptr;
-	io.Fonts->AddFontDefault();
+	gui_getWindowPhysSize(w,h);
 
 	// renderer
 	g_renderer->Initialize();
 	RendererOutputShader::InitializeStatic();
-	io.DisplaySize = ImVec2((float)w, (float)h);
 
 	LatteTiming_Init();
 	LatteTexture_init();
@@ -150,13 +140,7 @@ int Latte_ThreadEntry()
 	case GfxVendor::AMD: 
 		LatteGPUState.glVendor = GLVENDOR_AMD;
 		break;
-	case GfxVendor::IntelLegacy: 
-		LatteGPUState.glVendor = GLVENDOR_INTEL_LEGACY; 
-		break;
-	case GfxVendor::IntelNoLegacy: 
-		LatteGPUState.glVendor = GLVENDOR_INTEL_NOLEGACY; 
-		break;
-	case GfxVendor::Intel: 
+	case GfxVendor::Intel:
 		LatteGPUState.glVendor = GLVENDOR_INTEL; 
 		break;
 	case GfxVendor::Nvidia: 
@@ -171,7 +155,7 @@ int Latte_ThreadEntry()
 	sLatteThreadFinishedInit = true;
 
 	// register debug handler
-	if (cafeLog_isLoggingFlagEnabled(LOG_TYPE_OPENGL))
+	if (cemuLog_isLoggingEnabled(LogType::OpenGLLogging))
 		g_renderer->EnableDebugMode();
 
 	// wait till a game is started
@@ -191,9 +175,25 @@ int Latte_ThreadEntry()
 
 	// before doing anything with game specific shaders, we need to wait for graphic packs to finish loading
 	GraphicPack2::WaitUntilReady();
-	// load/init shader cache file
-	LatteShaderCache_load();
-
+	// if legacy packs are enabled we cannot use the colorbuffer resolution optimization
+	LatteGPUState.allowFramebufferSizeOptimization = true;
+	for(auto& pack : GraphicPack2::GetActiveGraphicPacks())
+	{
+		if(pack->AllowRendertargetSizeOptimization())
+			continue;
+		for(auto& rule : pack->GetTextureRules())
+		{
+			if(rule.filter_settings.width >= 0 || rule.filter_settings.height >= 0 || rule.filter_settings.depth >= 0 ||
+				rule.overwrite_settings.width >= 0 || rule.overwrite_settings.height >= 0 || rule.overwrite_settings.depth >= 0)
+			{
+				LatteGPUState.allowFramebufferSizeOptimization = false;
+				cemuLog_log(LogType::Force, "Graphic pack \"{}\" prevents rendertarget size optimization. This warning can be ignored and is intended for graphic pack developers", pack->GetName());
+				break;
+			}
+		}
+	}
+	// load disk shader cache
+    LatteShaderCache_Load();
 	// init registers
 	Latte_LoadInitialRegisters();
 	// let CPU thread know the GPU is done initializing
@@ -204,10 +204,9 @@ int Latte_ThreadEntry()
 		std::this_thread::yield();
 		std::this_thread::sleep_for(std::chrono::milliseconds(1));
 		LatteThread_HandleOSScreen();
-		if (!Latte_IsActive())
+		if (Latte_GetStopSignal())
 			LatteThread_Exit();
 	}
-	gxRingBufferReadPtr = gx2WriteGatherPipe.gxRingBuffer;
 	LatteCP_ProcessRingbuffer();
 	cemu_assert_debug(false); // should never reach
 	return 0;
@@ -235,25 +234,32 @@ void Latte_Start()
 void Latte_Stop()
 {
 	std::unique_lock _lock(sLatteThreadStateMutex);
+	if (!sLatteThreadRunning)
+		return;
 	sLatteThreadRunning = false;
 	_lock.unlock();
 	sLatteThread.join();
 }
 
-bool Latte_IsActive()
+bool Latte_GetStopSignal()
 {
-	return sLatteThreadRunning;
+	return !sLatteThreadRunning;
 }
 
 void LatteThread_Exit()
 {
 	if (g_renderer)
 		g_renderer->Shutdown();
+    // clean up vertex/uniform cache
+    LatteBufferCache_UnloadAll();
 	// clean up texture cache
 	LatteTC_UnloadAllTextures();
 	// clean up runtime shader cache
-	// todo
-	// destroy renderer but make sure that g_renderer remains valid until the destructor has finished
+    LatteSHRC_UnloadAll();
+    // close disk cache
+    LatteShaderCache_Close();
+	RendererOutputShader::ShutdownStatic();
+    // destroy renderer but make sure that g_renderer remains valid until the destructor has finished
 	if (g_renderer)
 	{
 		Renderer* renderer = g_renderer.get();
diff --git a/src/Cafe/HW/Latte/ISA/LatteReg.h b/src/Cafe/HW/Latte/ISA/LatteReg.h
index e539902f..d1a2a028 100644
--- a/src/Cafe/HW/Latte/ISA/LatteReg.h
+++ b/src/Cafe/HW/Latte/ISA/LatteReg.h
@@ -345,6 +345,11 @@ namespace Latte
 		return IsCompressedFormat((Latte::E_HWSURFFMT)((uint32)format & 0x3F));
 	}
 
+	inline bool IsMSAA(Latte::E_DIM dim)
+	{
+		return dim == E_DIM::DIM_2D_MSAA || dim == E_DIM::DIM_2D_ARRAY_MSAA;
+	}
+
 	enum GPU_LIMITS
 	{
 		NUM_VERTEX_BUFFERS = 16,
@@ -381,6 +386,9 @@ namespace Latte
 		PA_SC_GENERIC_SCISSOR_TL			= 0xA090,
 		PA_SC_GENERIC_SCISSOR_BR			= 0xA091,
 
+		SQ_VTX_SEMANTIC_0					= 0xA0E0,
+		SQ_VTX_SEMANTIC_31					= 0xA0FF,
+
 		VGT_MULTI_PRIM_IB_RESET_INDX		= 0xA103,
 		SX_ALPHA_TEST_CONTROL				= 0xA104,
 		CB_BLEND_RED						= 0xA105,
@@ -398,6 +406,10 @@ namespace Latte
 		PA_CL_VPORT_ZSCALE					= 0xA113,
 		PA_CL_VPORT_ZOFFSET					= 0xA114,
 
+		SPI_VS_OUT_ID_0						= 0xA185,
+
+		SPI_VS_OUT_CONFIG					= 0xA1B1,
+
 		CB_BLEND0_CONTROL					= 0xA1E0, // first
 		CB_BLEND7_CONTROL					= 0xA1E7, // last
 
@@ -408,7 +420,23 @@ namespace Latte
 		PA_CL_CLIP_CNTL						= 0xA204,
 		PA_SU_SC_MODE_CNTL					= 0xA205,
 		PA_CL_VTE_CNTL						= 0xA206,
-		
+		PA_CL_VS_OUT_CNTL					= 0xA207,
+
+		// shader program descriptors:
+		SQ_PGM_START_PS						= 0xA210,
+		SQ_PGM_RESOURCES_PS					= 0xA214,
+		SQ_PGM_EXPORTS_PS					= 0xA215,
+		SQ_PGM_START_VS						= 0xA216,
+		SQ_PGM_RESOURCES_VS					= 0xA21A,
+		SQ_PGM_START_GS 					= 0xA21B,
+		SQ_PGM_RESOURCES_GS					= 0xA21F,
+		SQ_PGM_START_ES						= 0xA220,
+		SQ_PGM_RESOURCES_ES					= 0xA224,
+		SQ_PGM_START_FS						= 0xA225,
+		SQ_PGM_RESOURCES_FS					= 0xA229,
+
+		SQ_VTX_SEMANTIC_CLEAR				= 0xA238,
+
 		PA_SU_POINT_SIZE					= 0xA280,
 		PA_SU_POINT_MINMAX					= 0xA281,
 
@@ -416,6 +444,35 @@ namespace Latte
 
 		VGT_DMA_INDEX_TYPE					= 0xA29F, // todo - verify offset
 
+		VGT_PRIMITIVEID_EN					= 0xA2A1,
+
+		VGT_MULTI_PRIM_IB_RESET_EN 			= 0xA2A5,
+
+		VGT_INSTANCE_STEP_RATE_0			= 0xA2A8,
+		VGT_INSTANCE_STEP_RATE_1			= 0xA2A9,
+
+		VGT_STRMOUT_BUFFER_SIZE_0			= 0xA2B4,
+		VGT_STRMOUT_VTX_STRIDE_0			= 0xA2B5,
+		VGT_STRMOUT_BUFFER_BASE_0			= 0xA2B6,
+		VGT_STRMOUT_BUFFER_OFFSET_0			= 0xA2B7,
+		VGT_STRMOUT_BUFFER_SIZE_1			= 0xA2B8,
+		VGT_STRMOUT_VTX_STRIDE_1			= 0xA2B9,
+		VGT_STRMOUT_BUFFER_BASE_1			= 0xA2BA,
+		VGT_STRMOUT_BUFFER_OFFSET_1			= 0xA2BB,
+		VGT_STRMOUT_BUFFER_SIZE_2			= 0xA2BC,
+		VGT_STRMOUT_VTX_STRIDE_2			= 0xA2BD,
+		VGT_STRMOUT_BUFFER_BASE_2			= 0xA2BE,
+		VGT_STRMOUT_BUFFER_OFFSET_2			= 0xA2BF,
+		VGT_STRMOUT_BUFFER_SIZE_3			= 0xA2C0,
+		VGT_STRMOUT_VTX_STRIDE_3			= 0xA2C1,
+		VGT_STRMOUT_BUFFER_BASE_3			= 0xA2C2,
+		VGT_STRMOUT_BUFFER_OFFSET_3			= 0xA2C3,
+		VGT_STRMOUT_BASE_OFFSET_0			= 0xA2C4,
+		VGT_STRMOUT_BASE_OFFSET_1			= 0xA2C5,
+		VGT_STRMOUT_BASE_OFFSET_2			= 0xA2C6,
+		VGT_STRMOUT_BASE_OFFSET_3			= 0xA2C7,
+		VGT_STRMOUT_BUFFER_EN				= 0xA2C8,
+
 		// HiZ early stencil test?
 		DB_SRESULTS_COMPARE_STATE0			= 0xA34A,
 		DB_SRESULTS_COMPARE_STATE1			= 0xA34B,
@@ -432,7 +489,7 @@ namespace Latte
 		SQ_TEX_RESOURCE_WORD0_N_GS			= 0xE930,
 		SQ_TEX_RESOURCE_WORD_FIRST			= SQ_TEX_RESOURCE_WORD0_N_PS,
 		SQ_TEX_RESOURCE_WORD_LAST			= (SQ_TEX_RESOURCE_WORD0_N_GS + GPU_LIMITS::NUM_TEXTURES_PER_STAGE * 7 - 1),
-		// there are 54 samplers with 3 registers each. 18 per stage. For stage indices see SAMPLER_BASE_INDEX_*
+		// there are 54 samplers with 3 registers each. 18 (actually only 16?) per stage. For stage indices see SAMPLER_BASE_INDEX_*
 		SQ_TEX_SAMPLER_WORD0_0				= 0xF000,
 		SQ_TEX_SAMPLER_WORD1_0				= 0xF001,
 		SQ_TEX_SAMPLER_WORD2_0				= 0xF002,
@@ -842,6 +899,12 @@ float get_##__regname() const \
 		LATTE_BITFIELD_BOOL(VTX_W0_FMT, 10);
 	};
 
+	struct LATTE_PA_CL_VS_OUT_CNTL : LATTEREG // 0xA207
+	{
+		LATTE_BITFIELD(CLIP_DIST_ENA_MASK, 0, 8);
+		LATTE_BITFIELD(CULL_DIST_ENA_MASK, 8, 8);
+	};
+
 	struct LATTE_PA_SU_POINT_SIZE : LATTEREG // 0xA280
 	{
 		LATTE_BITFIELD(HEIGHT, 0, 16);
@@ -909,6 +972,54 @@ float get_##__regname() const \
 		LATTE_BITFIELD_FULL_TYPED(INDEX_TYPE, E_INDEX_TYPE);
 	};
 
+	struct LATTE_VGT_PRIMITIVEID_EN : LATTEREG // 0xA2A1
+	{
+		LATTE_BITFIELD_BOOL(PRIMITIVEID_EN, 0);
+	};
+
+	struct LATTE_VGT_MULTI_PRIM_IB_RESET_EN : LATTEREG // 0xA2A5
+	{
+		LATTE_BITFIELD_BOOL(RESET_EN, 0);
+	};
+
+	struct LATTE_VGT_INSTANCE_STEP_RATE_X : LATTEREG // 0xA2A8-0xA2A9
+	{
+		LATTE_BITFIELD_FULL_TYPED(STEP_RATE, uint32);
+	};
+
+	struct LATTE_VGT_STRMOUT_BUFFER_SIZE_X : LATTEREG // 0xA2B4 + index * 4
+	{
+		LATTE_BITFIELD_FULL_TYPED(SIZE, uint32);
+	};
+
+	struct LATTE_VGT_STRMOUT_STRIDE_X : LATTEREG // 0xA2B5 + index * 4
+	{
+		LATTE_BITFIELD_FULL_TYPED(STRIDE, uint32);
+	};
+
+	struct LATTE_VGT_STRMOUT_BUFFER_BASE_X : LATTEREG // 0xA2B6 + index * 4
+	{
+		LATTE_BITFIELD_FULL_TYPED(BASE, uint32);
+	};
+
+	struct LATTE_VGT_STRMOUT_BUFFER_OFFSET_X : LATTEREG // 0xA2B7 + index * 4
+	{
+		LATTE_BITFIELD_FULL_TYPED(BUFFER_OFFSET, uint32);
+	};
+
+	struct LATTE_VGT_STRMOUT_BASE_OFFSET_X : LATTEREG // 0xA2C4-0xA2C7
+	{
+		LATTE_BITFIELD_FULL_TYPED(BASE_OFFSET, uint32);
+	};
+
+	struct LATTE_VGT_STRMOUT_BUFFER_EN : LATTEREG // 0xA2C8
+	{
+		LATTE_BITFIELD_BOOL(BUFFER_ENABLE_0, 0);
+		LATTE_BITFIELD_BOOL(BUFFER_ENABLE_1, 1);
+		LATTE_BITFIELD_BOOL(BUFFER_ENABLE_2, 2);
+		LATTE_BITFIELD_BOOL(BUFFER_ENABLE_3, 3);
+	};
+
 	struct LATTE_PA_SU_POLY_OFFSET_CLAMP : LATTEREG // 0xA37F
 	{
 		LATTE_BITFIELD_FLOAT(CLAMP);
@@ -934,6 +1045,16 @@ float get_##__regname() const \
 		LATTE_BITFIELD_FLOAT(OFFSET);
 	};
 
+	struct LATTE_SQ_VTX_SEMANTIC_CLEAR : LATTEREG // 0xA238
+	{
+		LATTE_BITFIELD_FULL_TYPED(CLEAR_MASK, uint32); // probably a bitmask
+	};
+
+	struct LATTE_SQ_VTX_SEMANTIC_X : LATTEREG // 0xA0E0 - 0xA0FF
+	{
+		LATTE_BITFIELD(SEMANTIC_ID, 0, 8);
+	};
+
 	struct LATTE_SQ_TEX_RESOURCE_WORD0_N : LATTEREG // 0xE000 + index * 7
 	{
 		LATTE_BITFIELD_TYPED(DIM, 0, 3, E_DIM);
@@ -1154,6 +1275,65 @@ float get_##__regname() const \
 		LATTE_BITFIELD_TYPED(TYPE, 31, 1, E_SAMPLER_TYPE);
 	};
 
+	struct LATTE_SQ_PGM_START_X : LATTEREG // 0xA210 / 0xA216 / 0xA21B / 0xA220 / 0xA225
+	{
+		LATTE_BITFIELD_FULL_TYPED(PGM_START, uint32);
+	};
+
+	struct LATTE_SQ_PGM_RESOURCES_PS : LATTEREG // 0xA214
+	{
+		LATTE_BITFIELD(NUM_GPRS, 0, 8);
+		LATTE_BITFIELD(NUM_STACK_ENTRIES, 8, 8);
+		LATTE_BITFIELD_BOOL(DX10_CLAMP, 21); // if true, CLAMP modifier in shaders will return 0 for NaN
+		LATTE_BITFIELD(FETCH_CACHE_LINES, 24, 3);
+		LATTE_BITFIELD_BOOL(UNCACHED_FIRST_INST, 28);
+		LATTE_BITFIELD_BOOL(CLAMP_CONSTS, 31);
+	};
+
+	struct LATTE_SQ_PGM_RESOURCES_VS : LATTEREG // 0xA21A
+	{
+		LATTE_BITFIELD(NUM_GPRS, 0, 8);
+		LATTE_BITFIELD(NUM_STACK_ENTRIES, 8, 8);
+		LATTE_BITFIELD_BOOL(DX10_CLAMP, 21); // if true, CLAMP modifier in shaders will return 0 for NaN
+		LATTE_BITFIELD(FETCH_CACHE_LINES, 24, 3);
+		LATTE_BITFIELD_BOOL(UNCACHED_FIRST_INST, 28);
+	};
+
+	struct LATTE_SQ_PGM_RESOURCES_GS : LATTEREG // 0xA21F
+	{
+		LATTE_BITFIELD(NUM_GPRS, 0, 8);
+		LATTE_BITFIELD(NUM_STACK_ENTRIES, 8, 8);
+		LATTE_BITFIELD_BOOL(DX10_CLAMP, 21); // if true, CLAMP modifier in shaders will return 0 for NaN
+	};
+
+	struct LATTE_SQ_PGM_RESOURCES_ES : LATTEREG // 0xA224
+	{
+		LATTE_BITFIELD(NUM_GPRS, 0, 8);
+		LATTE_BITFIELD(NUM_STACK_ENTRIES, 8, 8);
+		LATTE_BITFIELD_BOOL(DX10_CLAMP, 21); // if true, CLAMP modifier in shaders will return 0 for NaN
+	};
+
+	struct LATTE_SQ_PGM_RESOURCES_FS : LATTEREG // 0xA229
+	{
+		LATTE_BITFIELD(NUM_GPRS, 0, 8);
+		LATTE_BITFIELD(NUM_STACK_ENTRIES, 8, 8);
+		LATTE_BITFIELD_BOOL(DX10_CLAMP, 21); // if true, CLAMP modifier in shaders will return 0 for NaN
+	};
+
+	struct LATTE_SQ_XX_ITEMSIZE : LATTEREG // 0xA227 - 0xA2XX
+	{
+		// used by:
+		// SQ_ESGS_RING_ITEMSIZE
+		// SQ_GSVS_RING_ITEMSIZE
+		// SQ_ESTMP_RING_ITEMSIZE
+		// SQ_GSTMP_RING_ITEMSIZE
+		// SQ_VSTMP_RING_ITEMSIZE
+		// SQ_PSTMP_RING_ITEMSIZE
+		// SQ_FBUF_RING_ITEMSIZE
+		// SQ_REDUC_RING_ITEMSIZE
+		LATTE_BITFIELD(ITEMSIZE, 0, 15);
+	};
+
 	struct LATTE_PA_SU_SC_MODE_CNTL : LATTEREG // 0xA205
 	{
 		enum class E_FRONTFACE
@@ -1185,7 +1365,32 @@ float get_##__regname() const \
 		LATTE_BITFIELD_BOOL(OFFSET_PARA_ENABLED, 13); // offset enable for lines and points?
 		// additional fields?
 	};
-}
+
+	struct LATTE_SPI_VS_OUT_CONFIG : LATTEREG // 0xA1B1
+	{
+		LATTE_BITFIELD_BOOL(VS_PER_COMPONENT, 0);
+		LATTE_BITFIELD(VS_EXPORT_COUNT, 1, 5);
+		LATTE_BITFIELD_BOOL(EXPORTS_FOG, 8);
+		LATTE_BITFIELD(VS_OUT_FOG_VEC_ADDR, 9, 5);
+	};
+
+	struct LATTE_SPI_VS_OUT_ID_N : LATTEREG // 0xA185 - 0xA18E(?) - 0xA1B2 - 0xA1B3
+	{
+		uint8 get_SEMANTIC(sint32 index)
+		{
+			cemu_assert_debug(index < 4);
+			return (uint8)((v >> (index * 8)) & 0xFF);
+		}
+
+		void set_SEMANTIC(sint32 index, uint8 value)
+		{
+			cemu_assert_debug(index < 4);
+			v &= ~(0xFF << (index * 8));
+			v |= (value & 0xFF) << (index * 8);
+		}
+	};
+
+};
 
 struct _LatteRegisterSetTextureUnit
 {
@@ -1219,6 +1424,16 @@ struct _LatteRegisterSetSamplerBorderColor
 
 static_assert(sizeof(_LatteRegisterSetSamplerBorderColor) == 16);
 
+struct _LatteRegisterSetStreamoutBuffer
+{
+	Latte::LATTE_VGT_STRMOUT_BUFFER_SIZE_X SIZE;
+	Latte::LATTE_VGT_STRMOUT_STRIDE_X STRIDE;
+	Latte::LATTE_VGT_STRMOUT_BUFFER_BASE_X BASE;
+	Latte::LATTE_VGT_STRMOUT_BUFFER_OFFSET_X BUFFER_OFFSET;
+};
+
+static_assert(sizeof(_LatteRegisterSetStreamoutBuffer) == 16);
+
 struct LatteContextRegister
 {
 	uint8 padding0[0x08958];
@@ -1235,7 +1450,9 @@ struct LatteContextRegister
 	uint8 padding_2823C[4];
 	/* +0x28240 */ Latte::LATTE_PA_SC_GENERIC_SCISSOR_TL PA_SC_GENERIC_SCISSOR_TL;
 	/* +0x28244 */ Latte::LATTE_PA_SC_GENERIC_SCISSOR_BR PA_SC_GENERIC_SCISSOR_BR;
-	uint8 padding_28248[0x2840C - 0x28248];
+	uint8 padding_28248[0x28380 - 0x28248];
+	/* +0x28380 */ Latte::LATTE_SQ_VTX_SEMANTIC_X SQ_VTX_SEMANTIC_X[32];
+	/* +0x28400 */ uint8 padding_28400[0x2840C - 0x28400];
 	/* +0x2840C */ Latte::LATTE_VGT_MULTI_PRIM_IB_RESET_INDX VGT_MULTI_PRIM_IB_RESET_INDX;
 	/* +0x28410 */ Latte::LATTE_SX_ALPHA_TEST_CONTROL SX_ALPHA_TEST_CONTROL;
 	/* +0x28414 */ Latte::LATTE_CB_BLEND_RED CB_BLEND_RED;
@@ -1253,7 +1470,15 @@ struct LatteContextRegister
 	/* +0x2844C */ Latte::LATTE_PA_CL_VPORT_ZSCALE	PA_CL_VPORT_ZSCALE;
 	/* +0x28450 */ Latte::LATTE_PA_CL_VPORT_ZOFFSET PA_CL_VPORT_ZOFFSET;
 
-	uint8 padding_28450[0x28780 - 0x28454];
+	uint8 padding_28450[0x28614 - 0x28454];
+
+	/* +0x28614 */ Latte::LATTE_SPI_VS_OUT_ID_N LATTE_SPI_VS_OUT_ID_N[10];
+
+	uint8 padding_2863C[0x286C4 - 0x2863C];
+
+	/* +0x286C4 */ Latte::LATTE_SPI_VS_OUT_CONFIG SPI_VS_OUT_CONFIG;
+
+	uint8 padding_286C8[0x28780 - 0x286C8];
 
 	/* +0x28780 */ Latte::LATTE_CB_BLENDN_CONTROL CB_BLENDN_CONTROL[8];
 
@@ -1266,9 +1491,44 @@ struct LatteContextRegister
 	/* +0x28810 */ Latte::LATTE_PA_CL_CLIP_CNTL PA_CL_CLIP_CNTL;
 	/* +0x28814 */ Latte::LATTE_PA_SU_SC_MODE_CNTL PA_SU_SC_MODE_CNTL;
 	/* +0x28818 */ Latte::LATTE_PA_CL_VTE_CNTL PA_CL_VTE_CNTL;
+	/* +0x2881C */ Latte::LATTE_PA_CL_VS_OUT_CNTL PA_CL_VS_OUT_CNTL;
 
-	uint8 padding_2881C[0x28A00 - 0x2881C];
+	uint8 padding_2881C[0x28840 - 0x28820];
 
+	/* +0x28840 */ Latte::LATTE_SQ_PGM_START_X SQ_PGM_START_PS;
+	/* +0x28844 */ uint32 ukn28844; // PS size
+	/* +0x28848 */ uint32 ukn28848;
+	/* +0x2884C */ uint32 ukn2884C;
+	/* +0x28850 */ Latte::LATTE_SQ_PGM_RESOURCES_PS SQ_PGM_RESOURCES_PS;
+	/* +0x28854 */ uint32 ukn28854; // SQ_PGM_EXPORTS_PS
+	/* +0x28858 */ Latte::LATTE_SQ_PGM_START_X SQ_PGM_START_VS;
+	/* +0x2885C */ uint32 ukn2885C; // VS size
+	/* +0x28860 */ uint32 ukn28860;
+	/* +0x28864 */ uint32 ukn28864;
+	/* +0x28868 */ Latte::LATTE_SQ_PGM_RESOURCES_VS SQ_PGM_RESOURCES_VS;
+	/* +0x2886C */ Latte::LATTE_SQ_PGM_START_X SQ_PGM_START_GS;
+	/* +0x28870 */ uint32 ukn28870; // GS size
+	/* +0x28874 */ uint32 ukn28874;
+	/* +0x28878 */ uint32 ukn28878;
+	/* +0x2887C */ Latte::LATTE_SQ_PGM_RESOURCES_GS SQ_PGM_RESOURCES_GS;
+	/* +0x28880 */ Latte::LATTE_SQ_PGM_START_X SQ_PGM_START_ES;
+	/* +0x28884 */ uint32 ukn28884; // ES size
+	/* +0x28888 */ uint32 ukn28888;
+	/* +0x2888C */ uint32 ukn2888C;
+	/* +0x28890 */ Latte::LATTE_SQ_PGM_RESOURCES_ES SQ_PGM_RESOURCES_ES;
+	/* +0x28894 */ Latte::LATTE_SQ_PGM_START_X SQ_PGM_START_FS;
+	/* +0x28898 */ uint32 ukn28898; // FS size
+	/* +0x2889C */ uint32 ukn2889C;
+	/* +0x288A0 */ uint32 ukn288A0;
+	/* +0x288A4 */ Latte::LATTE_SQ_PGM_RESOURCES_FS SQ_PGM_RESOURCES_FS;
+	/* +0x288A8 */ Latte::LATTE_SQ_XX_ITEMSIZE SQ_ESGS_RING_ITEMSIZE;
+	/* +0x288AC */ Latte::LATTE_SQ_XX_ITEMSIZE SQ_GSVS_RING_ITEMSIZE;
+	/* +0x288B0 */ Latte::LATTE_SQ_XX_ITEMSIZE SQ_ESTMP_RING_ITEMSIZE;
+	/* +0x288B4 */ Latte::LATTE_SQ_XX_ITEMSIZE SQ_GSTMP_RING_ITEMSIZE;
+	/* +0x288B8 */ Latte::LATTE_SQ_XX_ITEMSIZE SQ_VSTMP_RING_ITEMSIZE;
+	uint8 padding_288BC[0x288E0 - 0x288BC];
+	/* +0x288E0 */ Latte::LATTE_SQ_VTX_SEMANTIC_CLEAR SQ_VTX_SEMANTIC_CLEAR;
+	uint8 padding_288E4[0x28A00 - 0x288E4];
 	/* +0x28A00 */ Latte::LATTE_PA_SU_POINT_SIZE PA_SU_POINT_SIZE;
 	/* +0x28A04 */ Latte::LATTE_PA_SU_POINT_MINMAX PA_SU_POINT_MINMAX;
 
@@ -1279,8 +1539,24 @@ struct LatteContextRegister
 	uint8 padding_28A44[0x28A7C - 0x28A44];
 
 	/* +0x28A7C */ Latte::LATTE_VGT_DMA_INDEX_TYPE VGT_DMA_INDEX_TYPE;
+	/* +0x28A80 */ uint32 ukn28A80;
+	/* +0x28A84 */ Latte::LATTE_VGT_PRIMITIVEID_EN VGT_PRIMITIVEID_EN;
+	/* +0x28A88 */ uint32 ukn28A88;
+	/* +0x28A8C */ uint32 ukn28A8C;
+	/* +0x28A90 */ uint32 ukn28A90;
+	/* +0x28A94 */ Latte::LATTE_VGT_MULTI_PRIM_IB_RESET_EN VGT_MULTI_PRIM_IB_RESET_EN;
+	/* +0x28A98 */ uint32 ukn28A98;
+	/* +0x28A9C */ uint32 ukn28A9C;
+	/* +0x28AA0 */ Latte::LATTE_VGT_INSTANCE_STEP_RATE_X VGT_INSTANCE_STEP_RATE_0;
+	/* +0x28AA4 */ Latte::LATTE_VGT_INSTANCE_STEP_RATE_X VGT_INSTANCE_STEP_RATE_1;
 
-	uint8 padding_28A80[0x28DFC - 0x28A80];
+	uint8 padding_28AA8[0x28AD0 - 0x28AA8];
+
+	/* +0x28AD0 */ _LatteRegisterSetStreamoutBuffer VGT_STRMOUT_BUFFER_X[4];
+	/* +0x28B10 */ Latte::LATTE_VGT_STRMOUT_BASE_OFFSET_X VGT_STRMOUT_BASE_OFFSET_X[4];
+	/* +0x28B20 */ Latte::LATTE_VGT_STRMOUT_BUFFER_EN VGT_STRMOUT_BUFFER_EN;
+
+	uint8 padding_28B24[0x28DFC - 0x28B24];
 
 	/* +0x28DFC */ Latte::LATTE_PA_SU_POLY_OFFSET_CLAMP PA_SU_POLY_OFFSET_CLAMP;
 	/* +0x28E00 */ Latte::LATTE_PA_SU_POLY_OFFSET_FRONT_SCALE PA_SU_POLY_OFFSET_FRONT_SCALE;
@@ -1334,6 +1610,13 @@ static_assert(offsetof(LatteContextRegister, CB_TARGET_MASK) == Latte::REGADDR::
 static_assert(offsetof(LatteContextRegister, PA_SC_GENERIC_SCISSOR_TL) == Latte::REGADDR::PA_SC_GENERIC_SCISSOR_TL * 4);
 static_assert(offsetof(LatteContextRegister, PA_SC_GENERIC_SCISSOR_BR) == Latte::REGADDR::PA_SC_GENERIC_SCISSOR_BR * 4);
 static_assert(offsetof(LatteContextRegister, VGT_MULTI_PRIM_IB_RESET_INDX) == Latte::REGADDR::VGT_MULTI_PRIM_IB_RESET_INDX * 4);
+static_assert(offsetof(LatteContextRegister, VGT_PRIMITIVEID_EN) == Latte::REGADDR::VGT_PRIMITIVEID_EN * 4);
+static_assert(offsetof(LatteContextRegister, VGT_MULTI_PRIM_IB_RESET_EN) == Latte::REGADDR::VGT_MULTI_PRIM_IB_RESET_EN * 4);
+static_assert(offsetof(LatteContextRegister, VGT_INSTANCE_STEP_RATE_0) == Latte::REGADDR::VGT_INSTANCE_STEP_RATE_0 * 4);
+static_assert(offsetof(LatteContextRegister, VGT_INSTANCE_STEP_RATE_1) == Latte::REGADDR::VGT_INSTANCE_STEP_RATE_1 * 4);
+static_assert(offsetof(LatteContextRegister, VGT_STRMOUT_BUFFER_X) == Latte::REGADDR::VGT_STRMOUT_BUFFER_SIZE_0 * 4);
+static_assert(offsetof(LatteContextRegister, VGT_STRMOUT_BASE_OFFSET_X) == Latte::REGADDR::VGT_STRMOUT_BASE_OFFSET_0 * 4);
+static_assert(offsetof(LatteContextRegister, VGT_STRMOUT_BUFFER_EN) == Latte::REGADDR::VGT_STRMOUT_BUFFER_EN * 4);
 static_assert(offsetof(LatteContextRegister, SX_ALPHA_TEST_CONTROL) == Latte::REGADDR::SX_ALPHA_TEST_CONTROL * 4);
 static_assert(offsetof(LatteContextRegister, DB_STENCILREFMASK) == Latte::REGADDR::DB_STENCILREFMASK * 4);
 static_assert(offsetof(LatteContextRegister, DB_STENCILREFMASK_BF) == Latte::REGADDR::DB_STENCILREFMASK_BF * 4);
@@ -1351,6 +1634,7 @@ static_assert(offsetof(LatteContextRegister, PA_CL_VPORT_ZOFFSET) == Latte::REGA
 static_assert(offsetof(LatteContextRegister, PA_CL_CLIP_CNTL) == Latte::REGADDR::PA_CL_CLIP_CNTL * 4);
 static_assert(offsetof(LatteContextRegister, PA_SU_SC_MODE_CNTL) == Latte::REGADDR::PA_SU_SC_MODE_CNTL * 4);
 static_assert(offsetof(LatteContextRegister, PA_CL_VTE_CNTL) == Latte::REGADDR::PA_CL_VTE_CNTL * 4);
+static_assert(offsetof(LatteContextRegister, PA_CL_VS_OUT_CNTL) == Latte::REGADDR::PA_CL_VS_OUT_CNTL * 4);
 static_assert(offsetof(LatteContextRegister, PA_SU_POINT_SIZE) == Latte::REGADDR::PA_SU_POINT_SIZE * 4);
 static_assert(offsetof(LatteContextRegister, PA_SU_POINT_MINMAX) == Latte::REGADDR::PA_SU_POINT_MINMAX * 4);
 static_assert(offsetof(LatteContextRegister, CB_BLENDN_CONTROL) == Latte::REGADDR::CB_BLEND0_CONTROL * 4);
@@ -1363,7 +1647,21 @@ static_assert(offsetof(LatteContextRegister, PA_SU_POLY_OFFSET_FRONT_SCALE) == L
 static_assert(offsetof(LatteContextRegister, PA_SU_POLY_OFFSET_FRONT_OFFSET) == Latte::REGADDR::PA_SU_POLY_OFFSET_FRONT_OFFSET * 4);
 static_assert(offsetof(LatteContextRegister, PA_SU_POLY_OFFSET_BACK_SCALE) == Latte::REGADDR::PA_SU_POLY_OFFSET_BACK_SCALE * 4);
 static_assert(offsetof(LatteContextRegister, PA_SU_POLY_OFFSET_BACK_OFFSET) == Latte::REGADDR::PA_SU_POLY_OFFSET_BACK_OFFSET * 4);
+static_assert(offsetof(LatteContextRegister, SQ_VTX_SEMANTIC_X) == Latte::REGADDR::SQ_VTX_SEMANTIC_0 * 4);
+static_assert(offsetof(LatteContextRegister, SQ_VTX_SEMANTIC_CLEAR) == Latte::REGADDR::SQ_VTX_SEMANTIC_CLEAR * 4);
 static_assert(offsetof(LatteContextRegister, SQ_TEX_START_PS) == Latte::REGADDR::SQ_TEX_RESOURCE_WORD0_N_PS * 4);
 static_assert(offsetof(LatteContextRegister, SQ_TEX_START_VS) == Latte::REGADDR::SQ_TEX_RESOURCE_WORD0_N_VS * 4);
 static_assert(offsetof(LatteContextRegister, SQ_TEX_START_GS) == Latte::REGADDR::SQ_TEX_RESOURCE_WORD0_N_GS * 4);
 static_assert(offsetof(LatteContextRegister, SQ_TEX_SAMPLER) == Latte::REGADDR::SQ_TEX_SAMPLER_WORD0_0 * 4);
+static_assert(offsetof(LatteContextRegister, SQ_PGM_START_PS) == Latte::REGADDR::SQ_PGM_START_PS * 4);
+static_assert(offsetof(LatteContextRegister, SQ_PGM_RESOURCES_PS) == Latte::REGADDR::SQ_PGM_RESOURCES_PS * 4);
+static_assert(offsetof(LatteContextRegister, SQ_PGM_START_VS) == Latte::REGADDR::SQ_PGM_START_VS * 4);
+static_assert(offsetof(LatteContextRegister, SQ_PGM_RESOURCES_VS) == Latte::REGADDR::SQ_PGM_RESOURCES_VS * 4);
+static_assert(offsetof(LatteContextRegister, SQ_PGM_START_FS) == Latte::REGADDR::SQ_PGM_START_FS * 4);
+static_assert(offsetof(LatteContextRegister, SQ_PGM_RESOURCES_FS) == Latte::REGADDR::SQ_PGM_RESOURCES_FS * 4);
+static_assert(offsetof(LatteContextRegister, SQ_PGM_START_ES) == Latte::REGADDR::SQ_PGM_START_ES * 4);
+static_assert(offsetof(LatteContextRegister, SQ_PGM_RESOURCES_ES) == Latte::REGADDR::SQ_PGM_RESOURCES_ES * 4);
+static_assert(offsetof(LatteContextRegister, SQ_PGM_START_GS) == Latte::REGADDR::SQ_PGM_START_GS * 4);
+static_assert(offsetof(LatteContextRegister, SQ_PGM_RESOURCES_GS) == Latte::REGADDR::SQ_PGM_RESOURCES_GS * 4);
+static_assert(offsetof(LatteContextRegister, SPI_VS_OUT_CONFIG) == Latte::REGADDR::SPI_VS_OUT_CONFIG * 4);
+static_assert(offsetof(LatteContextRegister, LATTE_SPI_VS_OUT_ID_N) == Latte::REGADDR::SPI_VS_OUT_ID_0 * 4);
\ No newline at end of file
diff --git a/src/Cafe/HW/Latte/ISA/RegDefines.h b/src/Cafe/HW/Latte/ISA/RegDefines.h
index d28739c0..b99c2126 100644
--- a/src/Cafe/HW/Latte/ISA/RegDefines.h
+++ b/src/Cafe/HW/Latte/ISA/RegDefines.h
@@ -50,8 +50,6 @@
 #define mmVGT_PRIMITIVEID_EN                            0xA2A1
 #define mmVGT_VTX_CNT_EN                                0xA2AE
 #define mmVGT_REUSE_OFF                                 0xA2AD
-#define mmVGT_INSTANCE_STEP_RATE_0                      0xA2A8
-#define mmVGT_INSTANCE_STEP_RATE_1                      0xA2A9
 #define mmVGT_MAX_VTX_INDX                              0xA100
 #define mmVGT_MIN_VTX_INDX                              0xA101
 #define mmVGT_INDX_OFFSET                               0xA102
diff --git a/src/Cafe/HW/Latte/LegacyShaderDecompiler/LatteDecompiler.cpp b/src/Cafe/HW/Latte/LegacyShaderDecompiler/LatteDecompiler.cpp
index 8bad99e0..5972aacc 100644
--- a/src/Cafe/HW/Latte/LegacyShaderDecompiler/LatteDecompiler.cpp
+++ b/src/Cafe/HW/Latte/LegacyShaderDecompiler/LatteDecompiler.cpp
@@ -101,7 +101,8 @@ bool LatteDecompiler_ParseCFInstruction(LatteDecompilerShaderContext* shaderCont
 			// ignored (we use ALU/IF/ELSE/PUSH/POP clauses to determine code flow)
 			return true;
 		}
-		else if (cf_inst23_7 == GPU7_CF_INST_LOOP_START_DX10 || cf_inst23_7 == GPU7_CF_INST_LOOP_END)
+		else if (cf_inst23_7 == GPU7_CF_INST_LOOP_START_DX10 || cf_inst23_7 == GPU7_CF_INST_LOOP_END ||
+				 cf_inst23_7 == GPU7_CF_INST_LOOP_START_NO_AL)
 		{
 			LatteDecompilerCFInstruction& cfInstruction = instructionList.emplace_back();
 			// set type and address
@@ -345,6 +346,7 @@ bool LatteDecompiler_IsALUTransInstruction(bool isOP3, uint32 opcode)
 		opcode == ALU_OP2_INST_SETGE_UINT ||
 		opcode == ALU_OP2_INST_SETGT_UINT ||
 		opcode == ALU_OP2_INST_MAX_DX10 ||
+		opcode == ALU_OP2_INST_MIN_DX10 ||
 		opcode == ALU_OP2_INST_PRED_SETE ||
 		opcode == ALU_OP2_INST_PRED_SETNE ||
 		opcode == ALU_OP2_INST_PRED_SETGE ||
@@ -368,6 +370,8 @@ bool LatteDecompiler_IsALUTransInstruction(bool isOP3, uint32 opcode)
 		opcode == ALU_OP2_INST_LSHR_INT ||
 		opcode == ALU_OP2_INST_MAX_INT ||
 		opcode == ALU_OP2_INST_MIN_INT ||
+		opcode == ALU_OP2_INST_MAX_UINT ||
+		opcode == ALU_OP2_INST_MIN_UINT ||
 		opcode == ALU_OP2_INST_MOVA_FLOOR ||
 		opcode == ALU_OP2_INST_MOVA_INT ||
 		opcode == ALU_OP2_INST_SETE_DX10 ||
@@ -665,6 +669,9 @@ void LatteDecompiler_ParseTEXClause(LatteDecompilerShader* shaderContext, LatteD
 			uint32 offsetY = (word2 >> 5) & 0x1F;
 			uint32 offsetZ = (word2 >> 10) & 0x1F;
 
+			sint8 lodBias = (word2 >> 21) & 0x7F;
+			if ((lodBias&0x40) != 0)
+				lodBias |= 0x80;
 			// bufferID -> Texture index
 			// samplerId -> Sampler index
 			sint32 textureIndex = bufferId - 0x00;
@@ -692,6 +699,7 @@ void LatteDecompiler_ParseTEXClause(LatteDecompilerShader* shaderContext, LatteD
 			texInstruction.textureFetch.unnormalized[1] = coordTypeY == 0;
 			texInstruction.textureFetch.unnormalized[2] = coordTypeZ == 0;
 			texInstruction.textureFetch.unnormalized[3] = coordTypeW == 0;
+			texInstruction.textureFetch.lodBias = (sint8)lodBias;
 			cfInstruction->instructionsTEX.emplace_back(texInstruction);
 		}
 		else if( inst0_4 == GPU7_TEX_INST_SET_CUBEMAP_INDEX )
@@ -931,7 +939,7 @@ void LatteDecompiler_ParseTEXClause(LatteDecompilerShader* shaderContext, LatteD
 		}
 		else
 		{
-			forceLogDebug_printf("Unsupported tex instruction %d\n", inst0_4);
+			cemuLog_logDebug(LogType::Force, "Unsupported tex instruction {}", inst0_4);
 			shaderContext->hasError = true;
 			break;
 		}
@@ -961,7 +969,8 @@ void LatteDecompiler_ParseClauses(LatteDecompilerShaderContext* decompilerContex
 		{
 			// no sub-instructions
 		}
-		else if (cfInstruction.type == GPU7_CF_INST_LOOP_START_DX10 || cfInstruction.type == GPU7_CF_INST_LOOP_END)
+		else if (cfInstruction.type == GPU7_CF_INST_LOOP_START_DX10 || cfInstruction.type == GPU7_CF_INST_LOOP_END ||
+				 cfInstruction.type == GPU7_CF_INST_LOOP_START_NO_AL)
 		{
 			// no sub-instructions
 		}
@@ -1065,44 +1074,32 @@ void _LatteDecompiler_Process(LatteDecompilerShaderContext* shaderContext, uint8
 	_LatteDecompiler_GenerateDataForFastAccess(shaderContext->shader);
 }
 
-void LatteDecompiler_InitContext(LatteDecompilerShaderContext& dCtx, LatteDecompilerOutput_t* output, LatteConst::ShaderType shaderType, uint64 shaderBaseHash, uint32* contextRegisters)
+void LatteDecompiler_InitContext(LatteDecompilerShaderContext& dCtx, const LatteDecompilerOptions& options, LatteDecompilerOutput_t* output, LatteConst::ShaderType shaderType, uint64 shaderBaseHash, uint32* contextRegisters)
 {
 	dCtx.output = output;
 	dCtx.shaderType = shaderType;
-	output->shaderType = shaderType;
+	dCtx.options = &options;
 	dCtx.shaderBaseHash = shaderBaseHash;
 	dCtx.contextRegisters = contextRegisters;
 	dCtx.contextRegistersNew = (LatteContextRegister*)contextRegisters;
+	output->shaderType = shaderType;
 }
 
-void LatteDecompiler_DecompileVertexShader(uint64 shaderBaseHash, uint32* contextRegisters, uint8* programData, uint32 programSize, LatteFetchShader** fetchShaderList, sint32 fetchShaderCount, uint32* hleSpecialState, bool usesGeometryShader, LatteDecompilerOutput_t* output, bool useTFViaSSBO)
+void LatteDecompiler_DecompileVertexShader(uint64 shaderBaseHash, uint32* contextRegisters, uint8* programData, uint32 programSize, struct LatteFetchShader* fetchShader, LatteDecompilerOptions& options, LatteDecompilerOutput_t* output)
 {
+	cemu_assert_debug(fetchShader);
 	cemu_assert_debug((programSize & 3) == 0);
 	performanceMonitor.gpuTime_shaderCreate.beginMeasuring();
 	// prepare decompiler context
 	LatteDecompilerShaderContext shaderContext = { 0 };
-	LatteDecompiler_InitContext(shaderContext, output, LatteConst::ShaderType::Vertex, shaderBaseHash, contextRegisters);
-	cemu_assert_debug(fetchShaderCount == 1);
-	for (sint32 i = 0; i < fetchShaderCount; i++)
-	{
-		shaderContext.fetchShaderList[i] = fetchShaderList[i];
-	}
-	shaderContext.fetchShaderCount = fetchShaderCount;
-	// ugly hack to get tf mode from Vulkan renderer
-	shaderContext.useTFViaSSBO = useTFViaSSBO;
-	if (g_renderer->GetType() == RendererAPI::Vulkan)
-	{
-		shaderContext.useTFViaSSBO = VulkanRenderer::GetInstance()->useTFViaSSBO();
-	}
+	LatteDecompiler_InitContext(shaderContext, options, output, LatteConst::ShaderType::Vertex, shaderBaseHash, contextRegisters);
+	shaderContext.fetchShader = fetchShader;
 	// prepare shader (deprecated)
-	LatteDecompilerShader* shader = new LatteDecompilerShader();
-	shader->shaderType = LatteConst::ShaderType::Vertex;
-	shader->compatibleFetchShader = shaderContext.fetchShaderList[0];
-	shaderContext.shaderType = LatteConst::ShaderType::Vertex;
+	LatteDecompilerShader* shader = new LatteDecompilerShader(LatteConst::ShaderType::Vertex);
+	shader->compatibleFetchShader = shaderContext.fetchShader;
 	output->shaderType = LatteConst::ShaderType::Vertex;
 	shaderContext.shader = shader;
 	output->shader = shader;
-	shaderContext.usesGeometryShader = usesGeometryShader;
 	for (sint32 i = 0; i < LATTE_NUM_MAX_TEX_UNITS; i++)
 	{
 		shader->textureUnitSamplerAssignment[i] = LATTE_DECOMPILER_SAMPLER_NONE;
@@ -1113,24 +1110,19 @@ void LatteDecompiler_DecompileVertexShader(uint64 shaderBaseHash, uint32* contex
 	performanceMonitor.gpuTime_shaderCreate.endMeasuring();
 }
 
-void LatteDecompiler_DecompileGeometryShader(uint64 shaderBaseHash, uint32* contextRegisters, uint8* programData, uint32 programSize, uint8* gsCopyProgramData, uint32 gsCopyProgramSize, uint32* hleSpecialState, uint32 vsRingParameterCount, LatteDecompilerOutput_t* output, bool useTFViaSSBO)
+void LatteDecompiler_DecompileGeometryShader(uint64 shaderBaseHash, uint32* contextRegisters, uint8* programData, uint32 programSize, uint8* gsCopyProgramData, uint32 gsCopyProgramSize, uint32 vsRingParameterCount, LatteDecompilerOptions& options, LatteDecompilerOutput_t* output)
 {
 	cemu_assert_debug((programSize & 3) == 0);
 	performanceMonitor.gpuTime_shaderCreate.beginMeasuring();
 	// prepare decompiler context
 	LatteDecompilerShaderContext shaderContext = { 0 };
-	shaderContext.fetchShaderCount = 0;
-	LatteDecompiler_InitContext(shaderContext, output, LatteConst::ShaderType::Geometry, shaderBaseHash, contextRegisters);
+	LatteDecompiler_InitContext(shaderContext, options, output, LatteConst::ShaderType::Geometry, shaderBaseHash, contextRegisters);
 	// prepare shader
-	LatteDecompilerShader* shader = new LatteDecompilerShader();
-	shaderContext.output = output;
-	shader->shaderType = LatteConst::ShaderType::Geometry;
+	LatteDecompilerShader* shader = new LatteDecompilerShader(LatteConst::ShaderType::Geometry);
 	shader->ringParameterCountFromPrevStage = vsRingParameterCount;
-	shaderContext.shaderType = LatteConst::ShaderType::Geometry;
 	output->shaderType = LatteConst::ShaderType::Geometry;
 	shaderContext.shader = shader;
 	output->shader = shader;
-	shaderContext.usesGeometryShader = true;
 	if (gsCopyProgramData == NULL)
 	{
 		shader->hasError = true;
@@ -1144,34 +1136,24 @@ void LatteDecompiler_DecompileGeometryShader(uint64 shaderBaseHash, uint32* cont
 		shader->textureUnitSamplerAssignment[i] = LATTE_DECOMPILER_SAMPLER_NONE;
 		shader->textureUsesDepthCompare[i] = false;
 	}
-	// ugly hack to get tf mode from Vulkan renderer
-	shaderContext.useTFViaSSBO = useTFViaSSBO;
-	if (g_renderer->GetType() == RendererAPI::Vulkan)
-	{
-		shaderContext.useTFViaSSBO = VulkanRenderer::GetInstance()->useTFViaSSBO();
-	}
 	// parse & compile
 	_LatteDecompiler_Process(&shaderContext, programData, programSize);
 	performanceMonitor.gpuTime_shaderCreate.endMeasuring();
 }
 
-void LatteDecompiler_DecompilePixelShader(uint64 shaderBaseHash, uint32* contextRegisters, uint8* programData, uint32 programSize, uint32* hleSpecialState, bool usesGeometryShader, LatteDecompilerOutput_t* output)
+void LatteDecompiler_DecompilePixelShader(uint64 shaderBaseHash, uint32* contextRegisters, uint8* programData, uint32 programSize, LatteDecompilerOptions& options, LatteDecompilerOutput_t* output)
 {
 	cemu_assert_debug((programSize & 3) == 0);
 	performanceMonitor.gpuTime_shaderCreate.beginMeasuring();
 	// prepare decompiler context
 	LatteDecompilerShaderContext shaderContext = { 0 };
-	LatteDecompiler_InitContext(shaderContext, output, LatteConst::ShaderType::Pixel, shaderBaseHash, contextRegisters);
+	LatteDecompiler_InitContext(shaderContext, options, output, LatteConst::ShaderType::Pixel, shaderBaseHash, contextRegisters);
 	shaderContext.contextRegisters = contextRegisters;
 	// prepare shader
-	LatteDecompilerShader* shader = new LatteDecompilerShader();
-	shaderContext.output = output;
-	shader->shaderType = LatteConst::ShaderType::Pixel;
-	shaderContext.shaderType = LatteConst::ShaderType::Pixel;
+	LatteDecompilerShader* shader = new LatteDecompilerShader(LatteConst::ShaderType::Pixel);
 	output->shaderType = LatteConst::ShaderType::Pixel;
 	shaderContext.shader = shader;
 	output->shader = shader;
-	shaderContext.usesGeometryShader = usesGeometryShader;
 	for (sint32 i = 0; i < LATTE_NUM_MAX_TEX_UNITS; i++)
 	{
 		shader->textureUnitSamplerAssignment[i] = LATTE_DECOMPILER_SAMPLER_NONE;
diff --git a/src/Cafe/HW/Latte/LegacyShaderDecompiler/LatteDecompiler.h b/src/Cafe/HW/Latte/LegacyShaderDecompiler/LatteDecompiler.h
index 4f0d3ff2..1159614e 100644
--- a/src/Cafe/HW/Latte/LegacyShaderDecompiler/LatteDecompiler.h
+++ b/src/Cafe/HW/Latte/LegacyShaderDecompiler/LatteDecompiler.h
@@ -1,6 +1,7 @@
 #pragma once
 #include "Cafe/HW/Latte/Core/LatteConst.h"
 #include "Cafe/HW/Latte/Renderer/RendererShader.h"
+#include <boost/container/static_vector.hpp>
 
 namespace LatteDecompiler
 {
@@ -148,50 +149,54 @@ struct LatteDecompilerShaderResourceMapping
 
 struct LatteDecompilerShader
 {
-	LatteDecompilerShader* next;
+	LatteDecompilerShader(LatteConst::ShaderType shaderType) : shaderType(shaderType) {}
+
+	LatteDecompilerShader* next{nullptr};
 	LatteConst::ShaderType shaderType;
-	uint64 baseHash;
-	uint64 auxHash;
+	uint64 baseHash{0};
+	uint64 auxHash{0};
 	// vertex shader
 	struct LatteFetchShader* compatibleFetchShader{};
 	// error tracking
-	bool hasError; // if set, the shader cannot be used
-	// optimized access / iteration
-	// list of uniform buffers used
-	uint8 uniformBufferList[LATTE_NUM_MAX_UNIFORM_BUFFERS];
-	uint8 uniformBufferListCount;
-	// list of used texture units (faster access than iterating textureUnitMask)
+	bool hasError{false}; // if set, the shader cannot be used
+	// compact resource lists for optimized access
+	struct QuickBufferEntry
+	{
+		uint32 index : 8;
+		uint32 size : 24;
+	};
+	boost::container::static_vector<QuickBufferEntry, LATTE_NUM_MAX_UNIFORM_BUFFERS> list_quickBufferList;
 	uint8 textureUnitList[LATTE_NUM_MAX_TEX_UNITS];
-	uint8 textureUnitListCount;
+	uint8 textureUnitListCount{ 0 };
 	// input
-	Latte::E_DIM textureUnitDim[LATTE_NUM_MAX_TEX_UNITS]; // dimension of texture unit, from the currently set texture
+	Latte::E_DIM textureUnitDim[LATTE_NUM_MAX_TEX_UNITS]{}; // dimension of texture unit, from the currently set texture
 	bool textureIsIntegerFormat[LATTE_NUM_MAX_TEX_UNITS]{};
 	// analyzer stage (uniforms)
-	uint8 uniformMode; // determines how uniforms are managed within the shader (see GPU7_DECOMPILER_UNIFORM_MODE_* constants)
-	uint64 uniformDataHash64[2]; // used to avoid redundant calls to glUniform*
+	uint8 uniformMode{0}; // determines how uniforms are managed within the shader (see LATTE_DECOMPILER_UNIFORM_MODE_* constants)
+	uint64 uniformDataHash64[2]{0}; // used to avoid redundant calls to glUniform*
 	std::vector<LatteDecompilerRemappedUniformEntry_t> list_remappedUniformEntries;
 	// analyzer stage (textures)
 	std::bitset<LATTE_NUM_MAX_TEX_UNITS> textureUnitMask2;
-	uint16 textureUnitSamplerAssignment[LATTE_NUM_MAX_TEX_UNITS]; // GPU7_SAMPLER_NONE means undefined
-	bool textureUsesDepthCompare[LATTE_NUM_MAX_TEX_UNITS];
+	uint16 textureUnitSamplerAssignment[LATTE_NUM_MAX_TEX_UNITS]{ 0 }; // LATTE_DECOMPILER_SAMPLER_NONE means undefined
+	bool textureUsesDepthCompare[LATTE_NUM_MAX_TEX_UNITS]{};
 
 	// analyzer stage (pixel outputs)
-	uint32 pixelColorOutputMask; // from LSB to MSB, 1 bit per written output. 1 if written (indices of color attachments, may differ from export index inside the pixel shader)
+	uint32 pixelColorOutputMask{ 0 }; // from LSB to MSB, 1 bit per written output. 1 if written (indices of color attachments)
 	// analyzer stage (geometry shader parameters/inputs)
-	uint32 ringParameterCount;
-	uint32 ringParameterCountFromPrevStage; // used in geometry shader to hold VS ringParameterCount
+	uint32 ringParameterCount{ 0 };
+	uint32 ringParameterCountFromPrevStage{ 0 }; // used in geometry shader to hold VS ringParameterCount
 	// analyzer stage (misc)
-	std::bitset<LATTE_NUM_STREAMOUT_BUFFER> streamoutBufferWriteMask2;
-	bool hasStreamoutBufferWrite;
+	std::bitset<LATTE_NUM_STREAMOUT_BUFFER> streamoutBufferWriteMask;
+	bool hasStreamoutBufferWrite{ false };
 	// output code
-	class StringBuf* strBuf_shaderSource{nullptr};
+	class StringBuf* strBuf_shaderSource{ nullptr };
 	// separable shaders
-	RendererShader* shader;
-	bool isCustomShader;
+	RendererShader* shader{ nullptr };
+	bool isCustomShader{ false };
 
-	uint32 outputParameterMask;
+	uint32 outputParameterMask{ 0 };
 	// resource mapping (binding points)
-	LatteDecompilerShaderResourceMapping resourceMapping;
+	LatteDecompilerShaderResourceMapping resourceMapping{};
 	// uniforms
 	struct  
 	{
@@ -208,7 +213,7 @@ struct LatteDecompilerShader
 		sint32 loc_verticesPerInstance;
 		sint32 loc_streamoutBufferBase[LATTE_NUM_STREAMOUT_BUFFER];
 		sint32 uniformRangeSize; // entire size of uniform variable block
-	}uniform;
+	}uniform{ 0 };
 	// fast access
 	struct _RemappedUniformBufferGroup 
 	{
@@ -218,7 +223,7 @@ struct LatteDecompilerShader
 		std::vector<LatteFastAccessRemappedUniformEntry_buffer_t> entries;
 	};
 	std::vector<LatteFastAccessRemappedUniformEntry_register_t>	list_remappedUniformEntries_register;
-	std::vector<_RemappedUniformBufferGroup>	list_remappedUniformEntries_bufferGroups;
+	std::vector<_RemappedUniformBufferGroup> list_remappedUniformEntries_bufferGroups;
 };
 
 struct LatteDecompilerOutputUniformOffsets
@@ -250,6 +255,19 @@ struct LatteDecompilerOutputUniformOffsets
 	}
 };
 
+struct LatteDecompilerOptions 
+{
+	bool usesGeometryShader{ false };
+	// floating point math
+	bool strictMul{}; // if true, 0*anything=0 rule is emulated
+	// Vulkan-specific
+	bool useTFViaSSBO{ false };
+	struct  
+	{
+		bool hasRoundingModeRTEFloat32{ false };
+	}spirvInstrinsics;
+};
+
 struct LatteDecompilerOutput_t
 {
 	LatteDecompilerShader* shader;
@@ -272,9 +290,9 @@ struct LatteDecompilerOutput_t
 
 struct LatteDecompilerSubroutineInfo;
 
-void LatteDecompiler_DecompileVertexShader(uint64 shaderBaseHash, uint32* contextRegisters, uint8* programData, uint32 programSize, struct LatteFetchShader** fetchShaderList, sint32 fetchShaderCount, uint32* hleSpecialState, bool usesGeometryShader, LatteDecompilerOutput_t* output, bool useTFViaSSBO = false);
-void LatteDecompiler_DecompileGeometryShader(uint64 shaderBaseHash, uint32* contextRegisters, uint8* programData, uint32 programSize, uint8* gsCopyProgramData, uint32 gsCopyProgramSize, uint32* hleSpecialState, uint32 vsRingParameterCount, LatteDecompilerOutput_t* output, bool useTFViaSSBO = false);
-void LatteDecompiler_DecompilePixelShader(uint64 shaderBaseHash, uint32* contextRegisters, uint8* programData, uint32 programSize, uint32* hleSpecialState, bool usesGeometryShader, LatteDecompilerOutput_t* output);
+void LatteDecompiler_DecompileVertexShader(uint64 shaderBaseHash, uint32* contextRegisters, uint8* programData, uint32 programSize, struct LatteFetchShader* fetchShader, LatteDecompilerOptions& options, LatteDecompilerOutput_t* output);
+void LatteDecompiler_DecompileGeometryShader(uint64 shaderBaseHash, uint32* contextRegisters, uint8* programData, uint32 programSize, uint8* gsCopyProgramData, uint32 gsCopyProgramSize, uint32 vsRingParameterCount, LatteDecompilerOptions& options, LatteDecompilerOutput_t* output);
+void LatteDecompiler_DecompilePixelShader(uint64 shaderBaseHash, uint32* contextRegisters, uint8* programData, uint32 programSize, LatteDecompilerOptions& options, LatteDecompilerOutput_t* output);
 
 // specialized shader parsers
 
diff --git a/src/Cafe/HW/Latte/LegacyShaderDecompiler/LatteDecompilerAnalyzer.cpp b/src/Cafe/HW/Latte/LegacyShaderDecompiler/LatteDecompilerAnalyzer.cpp
index 0131b34e..ff64988c 100644
--- a/src/Cafe/HW/Latte/LegacyShaderDecompiler/LatteDecompilerAnalyzer.cpp
+++ b/src/Cafe/HW/Latte/LegacyShaderDecompiler/LatteDecompilerAnalyzer.cpp
@@ -1,9 +1,7 @@
 #include "Cafe/HW/Latte/Core/LatteConst.h"
 #include "Cafe/HW/Latte/Core/LatteShaderAssembly.h"
 #include "Cafe/HW/Latte/ISA/RegDefines.h"
-#include "Cafe/OS/libs/gx2/GX2.h" // todo - remove this dependency
 #include "Cafe/HW/Latte/Core/Latte.h"
-#include "Cafe/HW/Latte/Core/LatteDraw.h"
 #include "Cafe/HW/Latte/LegacyShaderDecompiler/LatteDecompiler.h"
 #include "Cafe/HW/Latte/LegacyShaderDecompiler/LatteDecompilerInternal.h"
 #include "Cafe/HW/Latte/LegacyShaderDecompiler/LatteDecompilerInstructions.h"
@@ -76,75 +74,6 @@ void _remapUniformAccess(LatteDecompilerShaderContext* shaderContext, bool isReg
 	list_uniformMapping.emplace_back(newMapping);
 }
 
-/*
- * Checks for register collisions and marks the instructions accordingly
- * startIndex is the first instruction of the group
- * endIndex is inclusive the last instruction of the same group
- */
-void _analyzeALUInstructionGroupForRegisterCollision(LatteDecompilerShaderContext* shaderContext, LatteDecompilerCFInstruction* cfInstruction, sint32 startIndex, sint32 endIndex)
-{
-	uint8 registerChannelWriteMask[(LATTE_NUM_GPR *4+7)/8] = {0};
-
-	struct  
-	{
-		uint8 gprIndex;
-		uint8 channel;
-	}registerBackupEntries[5];
-	sint32 registerBackupCount = 0;
-
-	for(sint32 i=startIndex; i<=endIndex; i++)
-	{
-		LatteDecompilerALUInstruction& aluInstruction = cfInstruction->instructionsALU[i];
-		// ignore NOP instruction
-		if( aluInstruction.isOP3 == false && aluInstruction.opcode == ALU_OP2_INST_NOP )
-			continue;
-		if( aluInstruction.destElem > 3 )
-			debugBreakpoint();
-		registerChannelWriteMask[(aluInstruction.destGpr * 4 + aluInstruction.destElem) / 8] |= (1 << ((aluInstruction.destGpr * 4 + aluInstruction.destElem) % 8));
-		// check if any previously written register is read
-		for(sint32 f=0; f<3; f++)
-		{
-			if( GPU7_ALU_SRC_IS_GPR(aluInstruction.sourceOperand[f].sel) == false )
-				continue;
-			sint32 gprIndex = GPU7_ALU_SRC_GET_GPR_INDEX(aluInstruction.sourceOperand[f].sel);
-			if( aluInstruction.sourceOperand[f].chan > 3 )
-				debugBreakpoint();
-			if( (registerChannelWriteMask[(gprIndex*4+aluInstruction.sourceOperand[f].chan)/8]&(1<<((gprIndex*4+aluInstruction.sourceOperand[f].chan)%8))) != 0 )
-			{
-				// register is overwritten by same or previous instruction, mark register backup for this instruction
-				// check if this register already has a backup
-				bool hasBackup = false;
-				for(sint32 t=0; t<registerBackupCount; t++)
-				{
-					if( (sint32)registerBackupEntries[t].gprIndex == gprIndex && registerBackupEntries[t].channel == aluInstruction.sourceOperand[f].chan )
-					{
-						aluInstruction.sourceOperand[f].requiredRegisterBackup = true;
-						aluInstruction.sourceOperand[f].registerBackupIndex = t;
-						hasBackup = true;
-						break;
-					}
-				}
-				if( hasBackup == false )
-				{
-					// add new entry
-					if( registerBackupCount < sizeof(registerBackupEntries)/sizeof(registerBackupEntries[0]) )
-					{
-						// add entry
-						registerBackupEntries[registerBackupCount].gprIndex = gprIndex;
-						registerBackupEntries[registerBackupCount].channel = aluInstruction.sourceOperand[f].chan;
-						registerBackupCount++;
-						// mark operand for backup
-						aluInstruction.sourceOperand[f].requiredRegisterBackup = true;
-						aluInstruction.sourceOperand[f].registerBackupIndex = registerBackupCount-1;
-					}
-					else
-						debugBreakpoint();
-				}
-			}
-		}
-	}
-}
-
 /*
  * Returns true if the instruction takes integer operands or returns a integer value
  */
@@ -176,6 +105,7 @@ bool _isIntegerInstruction(const LatteDecompilerALUInstruction& aluInstruction)
 		case ALU_OP2_INST_COS:
 		case ALU_OP2_INST_RNDNE:
 		case ALU_OP2_INST_MAX_DX10:
+		case ALU_OP2_INST_MIN_DX10:
 		case ALU_OP2_INST_SETGT:
 		case ALU_OP2_INST_SETGE:
 		case ALU_OP2_INST_SETNE:
@@ -210,6 +140,8 @@ bool _isIntegerInstruction(const LatteDecompilerALUInstruction& aluInstruction)
 		case ALU_OP2_INST_SUB_INT:
 		case ALU_OP2_INST_MAX_INT:
 		case ALU_OP2_INST_MIN_INT:
+		case ALU_OP2_INST_MAX_UINT:
+		case ALU_OP2_INST_MIN_UINT:
 		case ALU_OP2_INST_SETE_INT:
 		case ALU_OP2_INST_SETGT_INT:
 		case ALU_OP2_INST_SETGE_INT:
@@ -233,7 +165,7 @@ bool _isIntegerInstruction(const LatteDecompilerALUInstruction& aluInstruction)
 		case ALU_OP2_INST_SETNE_DX10:
 			return true;
 		default:
-#ifndef PUBLIC_RELEASE
+#ifdef CEMU_DEBUG_ASSERT
 			debug_printf("_isIntegerInstruction(): OP3=%s opcode=%02x\n", aluInstruction.isOP3 ? "true" : "false", aluInstruction.opcode);
 			cemu_assert_debug(false);
 #endif
@@ -259,7 +191,7 @@ bool _isIntegerInstruction(const LatteDecompilerALUInstruction& aluInstruction)
 		case ALU_OP3_INST_CMOVGE_INT:
 			return true;
 		default:
-#ifndef PUBLIC_RELEASE
+#ifdef CEMU_DEBUG_ASSERT
 			debug_printf("_isIntegerInstruction(): OP3=%s opcode=%02x\n", aluInstruction.isOP3?"true":"false", aluInstruction.opcode);
 #endif
 			break;
@@ -282,10 +214,10 @@ void LatteDecompiler_analyzeALUClause(LatteDecompilerShaderContext* shaderContex
 	for(auto& aluInstruction : cfInstruction->instructionsALU)
 	{
 		// ignore NOP instruction
-		if( aluInstruction.isOP3 == false && aluInstruction.opcode == ALU_OP2_INST_NOP )
+		if( !aluInstruction.isOP3 && aluInstruction.opcode == ALU_OP2_INST_NOP )
 			continue;
 		// check for CUBE instruction
-		if( aluInstruction.isOP3 == false && aluInstruction.opcode == ALU_OP2_INST_CUBE )
+		if( !aluInstruction.isOP3 && aluInstruction.opcode == ALU_OP2_INST_CUBE )
 		{
 			shaderContext->analyzer.hasRedcCUBE = true;
 		}
@@ -298,47 +230,39 @@ void LatteDecompiler_analyzeALUClause(LatteDecompilerShaderContext* shaderContex
 			// check input for uniform access
 			if( aluInstruction.sourceOperand[f].sel == 0xFFFFFFFF )
 				continue; // source operand not set/used
+			// about uniform register and buffer access tracking:
+			// for absolute indices we can determine a maximum size that is accessed
+			// relative accesses are tricky because the upper bound of accessed indices is unknown
+			// worst case we have to load the full file (256 * 16 byte entries) or for buffers an arbitrary upper bound (64KB in our case)
 			if( GPU7_ALU_SRC_IS_CFILE(aluInstruction.sourceOperand[f].sel) )
 			{
-				// uniform register access
-
-				// relative register file accesses are tricky because the range of possible indices is unknown
-				// worst case we have to load the full file (256 * 16 byte entries)
-				// but here we track all access indices so the analyzer can make guesstimates about the actual size when there are relative accesses
-
-				shaderContext->analyzer.uniformRegisterAccess = true;
 				if (aluInstruction.sourceOperand[f].rel)
 				{
-					shaderContext->analyzer.uniformRegisterDynamicAccess = true;
-					shaderContext->analyzer.uniformRegisterAccessIndices.emplace_back(GPU7_ALU_SRC_GET_CFILE_INDEX(aluInstruction.sourceOperand[f].sel), true);
+					shaderContext->analyzer.uniformRegisterAccessTracker.TrackAccess(GPU7_ALU_SRC_GET_CFILE_INDEX(aluInstruction.sourceOperand[f].sel), true);
 				}
 				else
 				{
 					_remapUniformAccess(shaderContext, true, 0, GPU7_ALU_SRC_GET_CFILE_INDEX(aluInstruction.sourceOperand[f].sel));
-					shaderContext->analyzer.uniformRegisterAccessIndices.emplace_back(GPU7_ALU_SRC_GET_CFILE_INDEX(aluInstruction.sourceOperand[f].sel), false);
+					shaderContext->analyzer.uniformRegisterAccessTracker.TrackAccess(GPU7_ALU_SRC_GET_CFILE_INDEX(aluInstruction.sourceOperand[f].sel), false);
 				}
 			}
 			else if( GPU7_ALU_SRC_IS_CBANK0(aluInstruction.sourceOperand[f].sel) )
 			{
 				// uniform bank 0 (uniform buffer with index cfInstruction->cBank0Index)
 				uint32 uniformBufferIndex = cfInstruction->cBank0Index;
-				if( uniformBufferIndex >= LATTE_NUM_MAX_UNIFORM_BUFFERS)
-					debugBreakpoint();
-				shaderContext->analyzer.uniformBufferAccessMask |= (1<<uniformBufferIndex);
-				if( aluInstruction.sourceOperand[f].rel )
-					shaderContext->analyzer.uniformBufferDynamicAccessMask |= (1<<uniformBufferIndex);
-				_remapUniformAccess(shaderContext, false, uniformBufferIndex, GPU7_ALU_SRC_GET_CBANK0_INDEX(aluInstruction.sourceOperand[f].sel)+cfInstruction->cBank0AddrBase);
+				cemu_assert(uniformBufferIndex < LATTE_NUM_MAX_UNIFORM_BUFFERS);
+				uint32 offset = GPU7_ALU_SRC_GET_CBANK0_INDEX(aluInstruction.sourceOperand[f].sel)+cfInstruction->cBank0AddrBase;
+				_remapUniformAccess(shaderContext, false, uniformBufferIndex, offset);
+				shaderContext->analyzer.uniformBufferAccessTracker[uniformBufferIndex].TrackAccess(offset, aluInstruction.sourceOperand[f].rel);
 			}
 			else if( GPU7_ALU_SRC_IS_CBANK1(aluInstruction.sourceOperand[f].sel) )
 			{
 				// uniform bank 1 (uniform buffer with index cfInstruction->cBank1Index)
 				uint32 uniformBufferIndex = cfInstruction->cBank1Index;
-				if( uniformBufferIndex >= LATTE_NUM_MAX_UNIFORM_BUFFERS)
-					debugBreakpoint();
-				shaderContext->analyzer.uniformBufferAccessMask |= (1<<uniformBufferIndex);
-				if( aluInstruction.sourceOperand[f].rel )
-					shaderContext->analyzer.uniformBufferDynamicAccessMask |= (1<<uniformBufferIndex);
-				_remapUniformAccess(shaderContext, false, uniformBufferIndex, GPU7_ALU_SRC_GET_CBANK1_INDEX(aluInstruction.sourceOperand[f].sel)+cfInstruction->cBank1AddrBase);
+				cemu_assert(uniformBufferIndex < LATTE_NUM_MAX_UNIFORM_BUFFERS);
+				uint32 offset = GPU7_ALU_SRC_GET_CBANK1_INDEX(aluInstruction.sourceOperand[f].sel)+cfInstruction->cBank1AddrBase;
+				_remapUniformAccess(shaderContext, false, uniformBufferIndex, offset);
+				shaderContext->analyzer.uniformBufferAccessTracker[uniformBufferIndex].TrackAccess(offset, aluInstruction.sourceOperand[f].rel);
 			}
 			else if( GPU7_ALU_SRC_IS_GPR(aluInstruction.sourceOperand[f].sel) )
 			{
@@ -354,30 +278,9 @@ void LatteDecompiler_analyzeALUClause(LatteDecompilerShaderContext* shaderContex
 			}
 		}
 		if( aluInstruction.destRel != 0 )
-		{
 			shaderContext->analyzer.usesRelativeGPRWrite = true;
-		}
 		shaderContext->analyzer.gprUseMask[aluInstruction.destGpr/8] |= (1<<(aluInstruction.destGpr%8));
 	}
-	// check for register collisions inside instruction groups (registers that are overwritten while being read)
-	sint32 currentGroupIndex = 0;
-	sint32 currentGroupStartIndex = 0;
-	for(uint32 i=0; i<cfInstruction->instructionsALU.size(); i++)
-	{
-		LatteDecompilerALUInstruction& aluInstruction = cfInstruction->instructionsALU[i];
-		if( aluInstruction.instructionGroupIndex != currentGroupIndex )
-		{
-			cemu_assert_debug(i != 0); // first group cant end at first instruction
-			_analyzeALUInstructionGroupForRegisterCollision(shaderContext, cfInstruction, currentGroupStartIndex, i-1);
-			// start next group
-			currentGroupIndex = aluInstruction.instructionGroupIndex;
-			currentGroupStartIndex = i;
-		}
-	}
-	if( currentGroupStartIndex < (sint32)cfInstruction->instructionsALU.size() )
-	{
-		_analyzeALUInstructionGroupForRegisterCollision(shaderContext, cfInstruction, currentGroupStartIndex, (uint32)cfInstruction->instructionsALU.size()-1);
-	}
 }
 
 // analyze TEX CF instruction and all instructions within the TEX clause
@@ -399,7 +302,7 @@ void LatteDecompiler_analyzeTEXClause(LatteDecompilerShaderContext* shaderContex
 		{
 			if (texInstruction.textureFetch.textureIndex < 0 || texInstruction.textureFetch.textureIndex >= LATTE_NUM_MAX_TEX_UNITS)
 			{
-				forceLogDebug_printf("Shader %llx has out of bounds texture access (texture %d)", shaderContext->shader->baseHash, (sint32)texInstruction.textureFetch.textureIndex);
+				cemuLog_logDebug(LogType::Force, "Shader {:16x} has out of bounds texture access (texture {})", shaderContext->shader->baseHash, (sint32)texInstruction.textureFetch.textureIndex);
 				continue;
 			}
 			if( texInstruction.textureFetch.samplerIndex < 0 || texInstruction.textureFetch.samplerIndex >= 0x12 )
@@ -449,8 +352,7 @@ void LatteDecompiler_analyzeTEXClause(LatteDecompilerShaderContext* shaderContex
 			if( texInstruction.textureFetch.textureIndex >= 0x80 && texInstruction.textureFetch.textureIndex <= 0x8F )
 			{
 				uint32 uniformBufferIndex = texInstruction.textureFetch.textureIndex - 0x80;
-				shaderContext->analyzer.uniformBufferAccessMask |= (1<<uniformBufferIndex);
-				shaderContext->analyzer.uniformBufferDynamicAccessMask |= (1<<uniformBufferIndex);
+				shaderContext->analyzer.uniformBufferAccessTracker[uniformBufferIndex].TrackAccess(0, true);
 			}
 			else if( texInstruction.textureFetch.textureIndex == 0x9F && shader->shaderType == LatteConst::ShaderType::Geometry )
 			{
@@ -541,7 +443,8 @@ void LatteDecompiler_analyzeSubroutine(LatteDecompilerShaderContext* shaderConte
 		{
 			shaderContext->analyzer.modifiesPixelActiveState = true;
 		}
-		else if (cfInstruction.type == GPU7_CF_INST_LOOP_START_DX10 || cfInstruction.type == GPU7_CF_INST_LOOP_END)
+		else if (cfInstruction.type == GPU7_CF_INST_LOOP_START_DX10 || cfInstruction.type == GPU7_CF_INST_LOOP_END ||
+				 cfInstruction.type == GPU7_CF_INST_LOOP_START_NO_AL)
 		{
 			shaderContext->analyzer.modifiesPixelActiveState = true;
 		}
@@ -575,11 +478,11 @@ namespace LatteDecompiler
 				continue;
 			sint32 textureBindingPoint;
 			if (decompilerContext->shaderType == LatteConst::ShaderType::Vertex)
-				textureBindingPoint = i + CEMU_VS_TEX_UNIT_BASE;
+				textureBindingPoint = i + LATTE_CEMU_VS_TEX_UNIT_BASE;
 			else if (decompilerContext->shaderType == LatteConst::ShaderType::Geometry)
-				textureBindingPoint = i + CEMU_GS_TEX_UNIT_BASE;
+				textureBindingPoint = i + LATTE_CEMU_GS_TEX_UNIT_BASE;
 			else if (decompilerContext->shaderType == LatteConst::ShaderType::Pixel)
-				textureBindingPoint = i + CEMU_PS_TEX_UNIT_BASE;
+				textureBindingPoint = i + LATTE_CEMU_PS_TEX_UNIT_BASE;
 
 			decompilerContext->output->resourceMappingGL.textureUnitToBindingPoint[i] = textureBindingPoint;
 		}
@@ -629,7 +532,7 @@ namespace LatteDecompiler
 		if (decompilerContext->shaderType == LatteConst::ShaderType::Geometry && decompilerContext->analyzer.outputPointSize && decompilerContext->analyzer.writesPointSize == false)
 			decompilerContext->hasUniformVarBlock = true; // uf_pointSize
 		if (decompilerContext->analyzer.useSSBOForStreamout &&
-			(decompilerContext->shaderType == LatteConst::ShaderType::Vertex && decompilerContext->usesGeometryShader == false) ||
+			(decompilerContext->shaderType == LatteConst::ShaderType::Vertex && !decompilerContext->options->usesGeometryShader) ||
 			(decompilerContext->shaderType == LatteConst::ShaderType::Geometry))
 		{
 			decompilerContext->hasUniformVarBlock = true; // uf_verticesPerInstance and uf_streamoutBufferBase*
@@ -665,7 +568,7 @@ namespace LatteDecompiler
 			// for Vulkan we use consecutive indices
 			for (uint32 i = 0; i < LATTE_NUM_MAX_UNIFORM_BUFFERS; i++)
 			{
-				if ((decompilerContext->analyzer.uniformBufferAccessMask&(1 << i)) == 0)
+				if (!decompilerContext->analyzer.uniformBufferAccessTracker[i].HasAccess())
 					continue;
 				sint32 uniformBindingPoint = i;
 				if (decompilerContext->shaderType == LatteConst::ShaderType::Geometry)
@@ -681,7 +584,7 @@ namespace LatteDecompiler
 			// for OpenGL we use the relative buffer index
 			for (uint32 i = 0; i < LATTE_NUM_MAX_UNIFORM_BUFFERS; i++)
 			{
-				if ((decompilerContext->analyzer.uniformBufferAccessMask&(1 << i)) == 0)
+				if (!decompilerContext->analyzer.uniformBufferAccessTracker[i].HasAccess())
 					continue;
 				sint32 uniformBindingPoint = i;
 				if (decompilerContext->shaderType == LatteConst::ShaderType::Geometry)
@@ -734,7 +637,7 @@ void LatteDecompiler_analyze(LatteDecompilerShaderContext* shaderContext, LatteD
 	// analyze render state
 	shaderContext->analyzer.isPointsPrimitive = shaderContext->contextRegistersNew->VGT_PRIMITIVE_TYPE.get_PRIMITIVE_MODE() == Latte::LATTE_VGT_PRIMITIVE_TYPE::E_PRIMITIVE_TYPE::POINTS;
 	shaderContext->analyzer.hasStreamoutEnable = shaderContext->contextRegisters[mmVGT_STRMOUT_EN] != 0; // set if the shader is used for transform feedback operations
-	if (shaderContext->shaderType == LatteConst::ShaderType::Vertex && shaderContext->usesGeometryShader == false)
+	if (shaderContext->shaderType == LatteConst::ShaderType::Vertex && !shaderContext->options->usesGeometryShader)
 		shaderContext->analyzer.outputPointSize = shaderContext->analyzer.isPointsPrimitive;
 	else if (shaderContext->shaderType == LatteConst::ShaderType::Geometry)
 	{
@@ -745,10 +648,9 @@ void LatteDecompiler_analyze(LatteDecompilerShaderContext* shaderContext, LatteD
 	// analyze input attributes for vertex/geometry shader
 	if (shader->shaderType == LatteConst::ShaderType::Vertex || shader->shaderType == LatteConst::ShaderType::Geometry)
 	{
-		for (sint32 f = 0; f < shaderContext->fetchShaderCount; f++)
+		if(shaderContext->fetchShader)
 		{
-			LatteFetchShader* parsedFetchShader = (LatteFetchShader*)shaderContext->fetchShaderList[f];
-			
+			LatteFetchShader* parsedFetchShader = shaderContext->fetchShader;
 			for(auto& bufferGroup : parsedFetchShader->bufferGroups)
 			{
 				for (sint32 i = 0; i < bufferGroup.attribCount; i++)
@@ -786,7 +688,8 @@ void LatteDecompiler_analyze(LatteDecompilerShaderContext* shaderContext, LatteD
 		{
 			shaderContext->analyzer.modifiesPixelActiveState = true;
 		}
-		else if (cfInstruction.type == GPU7_CF_INST_LOOP_START_DX10 || cfInstruction.type == GPU7_CF_INST_LOOP_END)
+		else if (cfInstruction.type == GPU7_CF_INST_LOOP_START_DX10 || cfInstruction.type == GPU7_CF_INST_LOOP_END ||
+				 cfInstruction.type == GPU7_CF_INST_LOOP_START_NO_AL)
 		{
 			shaderContext->analyzer.modifiesPixelActiveState = true;
 			shaderContext->analyzer.hasLoops = true;
@@ -855,17 +758,24 @@ void LatteDecompiler_analyze(LatteDecompilerShaderContext* shaderContext, LatteD
 		LatteDecompiler_analyzeSubroutine(shaderContext, subroutineAddr);
 	}
 	// decide which uniform mode to use
-	if(shaderContext->analyzer.uniformBufferAccessMask != 0 && shaderContext->analyzer.uniformRegisterAccess )
-		debugBreakpoint(); // not allowed
-	if(shaderContext->analyzer.uniformBufferDynamicAccessMask != 0 )
+	bool hasAnyDynamicBufferAccess = false;
+	bool hasAnyBufferAccess = false;
+	for(auto& it : shaderContext->analyzer.uniformBufferAccessTracker)
+	{
+		if( it.HasRelativeAccess() )
+			hasAnyDynamicBufferAccess = true;
+		if( it.HasAccess() )
+			hasAnyBufferAccess = true;
+	}
+	if (hasAnyDynamicBufferAccess)
 	{
 		shader->uniformMode = LATTE_DECOMPILER_UNIFORM_MODE_FULL_CBANK;
 	}
-	else if(shaderContext->analyzer.uniformRegisterDynamicAccess )
+	else if(shaderContext->analyzer.uniformRegisterAccessTracker.HasRelativeAccess() )
 	{
 		shader->uniformMode = LATTE_DECOMPILER_UNIFORM_MODE_FULL_CFILE;
 	}
-	else if(shaderContext->analyzer.uniformBufferAccessMask != 0 || shaderContext->analyzer.uniformRegisterAccess != 0 )
+	else if(hasAnyBufferAccess || shaderContext->analyzer.uniformRegisterAccessTracker.HasAccess() )
 	{
 		shader->uniformMode = LATTE_DECOMPILER_UNIFORM_MODE_REMAPPED;
 	}
@@ -873,16 +783,18 @@ void LatteDecompiler_analyze(LatteDecompilerShaderContext* shaderContext, LatteD
 	{
 		shader->uniformMode = LATTE_DECOMPILER_UNIFORM_MODE_NONE;
 	}
-	// generate list of uniform buffers based on uniformBufferAccessMask (for faster access)
-	shader->uniformBufferListCount = 0;
+	// generate compact list of uniform buffers (for faster access)
+	cemu_assert_debug(shader->list_quickBufferList.empty());
 	for (uint32 i = 0; i < LATTE_NUM_MAX_UNIFORM_BUFFERS; i++)
 	{
-		if( !HAS_FLAG(shaderContext->analyzer.uniformBufferAccessMask, (1<<i)) )
+		if( !shaderContext->analyzer.uniformBufferAccessTracker[i].HasAccess() )
 			continue;
-		shader->uniformBufferList[shader->uniformBufferListCount] = i;
-		shader->uniformBufferListCount++;
+		LatteDecompilerShader::QuickBufferEntry entry;
+		entry.index = i;
+		entry.size = shaderContext->analyzer.uniformBufferAccessTracker[i].DetermineSize(shaderContext->shaderBaseHash, LATTE_GLSL_DYNAMIC_UNIFORM_BLOCK_SIZE) * 16;
+		shader->list_quickBufferList.push_back(entry);
 	}
-	// get dimension of each used textures
+	// get dimension of each used texture
 	_LatteRegisterSetTextureUnit* texRegs = nullptr;
 	if( shader->shaderType == LatteConst::ShaderType::Vertex )
 		texRegs = shaderContext->contextRegistersNew->SQ_TEX_START_VS;
@@ -937,9 +849,9 @@ void LatteDecompiler_analyze(LatteDecompilerShaderContext* shaderContext, LatteD
 	// analyze input attributes again (if shader has relative GPR read)
 	if(shaderContext->analyzer.usesRelativeGPRRead && (shader->shaderType == LatteConst::ShaderType::Vertex || shader->shaderType == LatteConst::ShaderType::Geometry) )
 	{
-		for (sint32 f = 0; f < shaderContext->fetchShaderCount; f++)
+		if(shaderContext->fetchShader)
 		{
-			LatteFetchShader* parsedFetchShader = (LatteFetchShader*)shaderContext->fetchShaderList[f];
+			LatteFetchShader* parsedFetchShader = shaderContext->fetchShader;
 			for(auto& bufferGroup : parsedFetchShader->bufferGroups)
 			{
 				for (sint32 i = 0; i < bufferGroup.attribCount; i++)
@@ -1021,7 +933,8 @@ void LatteDecompiler_analyze(LatteDecompilerShaderContext* shaderContext, LatteD
 			if (cfCurrentStackDepth < 0)
 				debugBreakpoint();
 		}
-		else if (cfInstruction.type == GPU7_CF_INST_LOOP_START_DX10 || cfInstruction.type == GPU7_CF_INST_LOOP_END)
+		else if (cfInstruction.type == GPU7_CF_INST_LOOP_START_DX10 || cfInstruction.type == GPU7_CF_INST_LOOP_END ||
+				 cfInstruction.type == GPU7_CF_INST_LOOP_START_NO_AL)
 		{
 			// no effect on stack depth
 			cfInstruction.activeStackDepth = cfCurrentStackDepth;
@@ -1074,9 +987,9 @@ void LatteDecompiler_analyze(LatteDecompilerShaderContext* shaderContext, LatteD
 		cemu_assert_debug(false);
 	}
 	if(list_subroutineAddrs.empty() == false)
-		forceLogDebug_printf("Todo - analyze shader subroutine CF stack");
+		cemuLog_logDebug(LogType::Force, "Todo - analyze shader subroutine CF stack");
 	// TF mode
-	if (shaderContext->useTFViaSSBO && shaderContext->output->streamoutBufferWriteMask.any())
+	if (shaderContext->options->useTFViaSSBO && shaderContext->output->streamoutBufferWriteMask.any())
 	{
 		shaderContext->analyzer.useSSBOForStreamout = true;
 	}
diff --git a/src/Cafe/HW/Latte/LegacyShaderDecompiler/LatteDecompilerEmitGLSL.cpp b/src/Cafe/HW/Latte/LegacyShaderDecompiler/LatteDecompilerEmitGLSL.cpp
index 9a5107d0..e7ebcf3a 100644
--- a/src/Cafe/HW/Latte/LegacyShaderDecompiler/LatteDecompilerEmitGLSL.cpp
+++ b/src/Cafe/HW/Latte/LegacyShaderDecompiler/LatteDecompilerEmitGLSL.cpp
@@ -9,14 +9,12 @@
 #include "Cafe/HW/Latte/LegacyShaderDecompiler/LatteDecompilerInternal.h"
 #include "Cafe/HW/Latte/LegacyShaderDecompiler/LatteDecompilerInstructions.h"
 #include "Cafe/HW/Latte/Core/FetchShader.h"
-
-#include "Cafe/GameProfile/GameProfile.h"
-
 #include "Cafe/HW/Latte/Renderer/Renderer.h"
 #include "config/ActiveSettings.h"
 #include "util/helpers/StringBuf.h"
 
 #include <bitset>
+#include <boost/container/small_vector.hpp>
 
 #define _CRLF	"\r\n"
 
@@ -180,7 +178,276 @@ static char* _getRegisterVarName(LatteDecompilerShaderContext* shaderContext, ui
 	return tempStr;
 }
 
-sint32 _getVertexShaderOutParamSemanticId(uint32* contextRegisters, sint32 index) // deprecated - moved to psInputTable
+static void _appendRegisterTypeSuffix(StringBuf* src, sint32 dataType)
+{
+	if (dataType == LATTE_DECOMPILER_DTYPE_SIGNED_INT)
+		src->add("i");
+	else if (dataType == LATTE_DECOMPILER_DTYPE_UNSIGNED_INT)
+		src->add("ui");
+	else if (dataType == LATTE_DECOMPILER_DTYPE_FLOAT)
+		src->add("f");
+	else
+		cemu_assert_unimplemented();
+}
+
+// appends x/y/z/w
+static void _appendChannel(StringBuf* src, sint32 channelIndex)
+{
+	cemu_assert_debug(channelIndex >= 0 && channelIndex <= 3);
+	switch (channelIndex)
+	{
+	case 0:
+		src->add("x");
+		return;
+	case 1:
+		src->add("y");
+		return;
+	case 2:
+		src->add("z");
+		return;
+	case 3:
+		src->add("w");
+		return;
+	}
+}
+
+// appends .x/.y/.z/.w
+static void _appendChannelAccess(StringBuf* src, sint32 channelIndex)
+{
+	cemu_assert_debug(channelIndex >= 0 && channelIndex <= 3);
+	switch (channelIndex)
+	{
+	case 0:
+		src->add(".x");
+		return;
+	case 1:
+		src->add(".y");
+		return;
+	case 2:
+		src->add(".z");
+		return;
+	case 3:
+		src->add(".w");
+		return;
+	}
+}
+
+static void _appendPVPS(LatteDecompilerShaderContext* shaderContext, StringBuf* src, uint32 groupIndex, uint8 aluUnit)
+{
+	cemu_assert_debug(aluUnit < 5);
+	if (aluUnit == 4)
+	{
+		src->addFmt("PS{}", (groupIndex & 1));
+		_appendRegisterTypeSuffix(src, shaderContext->typeTracker.defaultDataType);
+		return;
+	}
+	src->addFmt("PV{}", (groupIndex & 1));
+	_appendRegisterTypeSuffix(src, shaderContext->typeTracker.defaultDataType);
+	_appendChannel(src, aluUnit);
+}
+
+std::string _FormatFloatAsGLSLConstant(float f)
+{
+	char floatAsStr[64];
+	size_t floatAsStrLen = fmt::format_to_n(floatAsStr, 64, "{:#}", f).size;
+	size_t floatAsStrLenOrg = floatAsStrLen;
+	if(floatAsStrLen > 0 && floatAsStr[floatAsStrLen-1] == '.')
+	{
+		floatAsStr[floatAsStrLen] = '0';
+		floatAsStrLen++;
+	}
+	cemu_assert(floatAsStrLen < 50); // constant suspiciously long?
+	floatAsStr[floatAsStrLen] = '\0';
+	cemu_assert_debug(floatAsStrLen >= 3); // shortest possible form is "0.0"
+	return floatAsStr;
+}
+
+// tracks PV/PS and register backups
+struct ALUClauseTemporariesState
+{
+	struct PVPSAlias
+	{
+		enum class LOCATION_TYPE : uint8
+		{
+			LOCATION_NONE,
+			LOCATION_GPR,
+			LOCATION_PVPS,
+		};
+
+		LOCATION_TYPE location{ LOCATION_TYPE::LOCATION_NONE };
+		uint8 index; // GPR index or temporary index
+		uint8 aluUnit; // x,y,z,w (or 5 for PS)
+
+		void SetLocationGPR(uint8 gprIndex, uint8 channel)
+		{
+			cemu_assert_debug(channel < 4);
+			this->location = LOCATION_TYPE::LOCATION_GPR;
+			this->index = gprIndex;
+			this->aluUnit = channel;
+		}
+
+		void SetLocationPSPVTemporary(uint8 aluUnit, uint32 groupIndex)
+		{
+			cemu_assert_debug(aluUnit < 5);
+			this->location = LOCATION_TYPE::LOCATION_PVPS;
+			this->index = groupIndex & 1;
+			this->aluUnit = aluUnit;
+		}
+	};
+
+	struct GPRTemporary
+	{
+		GPRTemporary(uint8 gprIndex, uint8 channel, uint8 backupVarIndex) : gprIndex(gprIndex), channel(channel), backupVarIndex(backupVarIndex) {}
+
+		uint8 gprIndex;
+		uint8 channel;
+		uint8 backupVarIndex;
+	};
+
+	void TrackGroupOutputPVPS(LatteDecompilerShaderContext* shaderContext, LatteDecompilerALUInstruction* aluInstr, size_t numInstr)
+	{
+		// unset current
+		for (auto& it : m_pvps)
+			it.location = PVPSAlias::LOCATION_TYPE::LOCATION_NONE;
+		for (size_t i = 0; i < numInstr; i++)
+		{
+			LatteDecompilerALUInstruction& inst = aluInstr[i];
+			if (!inst.isOP3 && inst.opcode == ALU_OP2_INST_NOP)
+				continue; // skip NOP instruction
+
+			if (inst.writeMask == 0)
+			{
+				// map to temporary
+				m_pvps[inst.aluUnit].SetLocationPSPVTemporary(inst.aluUnit, aluInstr->instructionGroupIndex);
+			}
+			else
+			{
+				// map to GPR
+				if(inst.destRel == 0) // is PV/PS set for indexed writes?
+					m_pvps[inst.aluUnit].SetLocationGPR(inst.destGpr, inst.destElem);
+			}
+		}
+	}
+
+	bool HasPVPS(uint8 aluUnitIndex) const
+	{
+		cemu_assert_debug(aluUnitIndex < 5);
+		return m_pvps[aluUnitIndex].location != PVPSAlias::LOCATION_TYPE::LOCATION_NONE;
+	}
+
+	void EmitPVPSAccess(LatteDecompilerShaderContext* shaderContext, uint8 aluUnitIndex, uint32 currentGroupIndex) const
+	{
+		switch (m_pvps[aluUnitIndex].location)
+		{
+		case PVPSAlias::LOCATION_TYPE::LOCATION_GPR:
+		{
+			sint32 temporaryIndex = GetTemporaryForGPR(m_pvps[aluUnitIndex].index, m_pvps[aluUnitIndex].aluUnit);
+			if (temporaryIndex < 0)
+			{
+				shaderContext->shaderSource->add(_getRegisterVarName(shaderContext, m_pvps[aluUnitIndex].index, -1));
+				_appendChannelAccess(shaderContext->shaderSource, m_pvps[aluUnitIndex].aluUnit);
+			}
+			else
+			{
+				// use temporary instead of GPR
+				shaderContext->shaderSource->addFmt("backupReg{}", temporaryIndex);
+				_appendRegisterTypeSuffix(shaderContext->shaderSource, shaderContext->typeTracker.defaultDataType);
+			}
+			break;
+		}
+		case PVPSAlias::LOCATION_TYPE::LOCATION_PVPS:
+			_appendPVPS(shaderContext, shaderContext->shaderSource, currentGroupIndex-1, m_pvps[aluUnitIndex].aluUnit);
+			break;
+		default:
+			cemuLog_log(LogType::Force, "Shader {:016x} accesses PV/PS without writing to it", shaderContext->shaderBaseHash);
+			cemu_assert_suspicious();
+			break;
+		}
+	}
+
+	/*
+	 * Check for GPR channels which are modified before they are read within the same group
+	 * These registers need to be copied to a temporary
+	 */
+	void CreateGPRTemporaries(LatteDecompilerShaderContext* shaderContext, std::span<LatteDecompilerALUInstruction> aluInstructions)
+	{
+		uint8 registerChannelWriteMask[(LATTE_NUM_GPR * 4 + 7) / 8] = { 0 };
+
+		m_gprTemporaries.clear();
+		for (auto& aluInstruction : aluInstructions)
+		{
+			// ignore NOP instructions
+			if (aluInstruction.isOP3 == false && aluInstruction.opcode == ALU_OP2_INST_NOP)
+				continue;
+			cemu_assert_debug(aluInstruction.destElem <= 3);
+			// check if any previously written register is read
+			for (sint32 f = 0; f < 3; f++)
+			{
+				uint32 readGPRIndex;
+				uint32 readGPRChannel;
+				if (GPU7_ALU_SRC_IS_GPR(aluInstruction.sourceOperand[f].sel))
+				{
+					readGPRIndex = GPU7_ALU_SRC_GET_GPR_INDEX(aluInstruction.sourceOperand[f].sel);
+					cemu_assert_debug(aluInstruction.sourceOperand[f].chan <= 3);
+					readGPRChannel = aluInstruction.sourceOperand[f].chan;
+				}
+				else if (GPU7_ALU_SRC_IS_PV(aluInstruction.sourceOperand[f].sel) || GPU7_ALU_SRC_IS_PS(aluInstruction.sourceOperand[f].sel))
+				{
+					uint8 aluUnitIndex = 0;
+					if (GPU7_ALU_SRC_IS_PV(aluInstruction.sourceOperand[f].sel))
+						aluUnitIndex = aluInstruction.sourceOperand[f].chan;
+					else
+						aluUnitIndex = 4;
+					// if aliased to a GPR, then consider it a GPR read
+					if(m_pvps[aluUnitIndex].location != PVPSAlias::LOCATION_TYPE::LOCATION_GPR)
+						continue;
+					readGPRIndex = m_pvps[aluUnitIndex].index;
+					readGPRChannel = m_pvps[aluUnitIndex].aluUnit;
+				}
+				else
+					continue;
+				// track GPR read
+				if ((registerChannelWriteMask[(readGPRIndex * 4 + aluInstruction.sourceOperand[f].chan) / 8] & (1 << ((readGPRIndex * 4 + aluInstruction.sourceOperand[f].chan) % 8))) != 0)
+				{
+					// register is overwritten by previous instruction, a temporary variable is required
+					if (GetTemporaryForGPR(readGPRIndex, readGPRChannel) < 0)
+						m_gprTemporaries.emplace_back(readGPRIndex, readGPRChannel, m_gprTemporaries.size());
+				}
+			}
+			// track write
+			if (aluInstruction.writeMask != 0)
+				registerChannelWriteMask[(aluInstruction.destGpr * 4 + aluInstruction.destElem) / 8] |= (1 << ((aluInstruction.destGpr * 4 + aluInstruction.destElem) % 8));
+		}
+		// output code to move GPRs into temporaries
+		StringBuf* src = shaderContext->shaderSource;
+		for (auto& it : m_gprTemporaries)
+		{
+			src->addFmt("backupReg{}", it.backupVarIndex);
+			_appendRegisterTypeSuffix(src, shaderContext->typeTracker.defaultDataType);
+			src->add(" = ");
+			src->add(_getRegisterVarName(shaderContext, it.gprIndex));
+			_appendChannelAccess(src, it.channel);
+			src->add(";" _CRLF);
+		}
+	}
+
+	// returns -1 if none present
+	sint32 GetTemporaryForGPR(uint8 gprIndex, uint8 channel) const
+	{
+		for (auto& it : m_gprTemporaries)
+		{
+			if (it.gprIndex == gprIndex && it.channel == channel)
+				return (sint32)it.backupVarIndex;
+		}
+		return -1;
+	}
+
+private:
+	PVPSAlias m_pvps[5]{};
+	boost::container::small_vector<GPRTemporary, 4> m_gprTemporaries;
+};
+
+sint32 _getVertexShaderOutParamSemanticId(uint32* contextRegisters, sint32 index) // deprecated - move to LatteShaderPSInputTable
 {
 	uint32 vsSemanticId = (contextRegisters[mmSPI_VS_OUT_ID_0 + (index / 4)] >> (8 * (index % 4))) & 0xFF;
 	// check if export exists since exports are generated based on PS inputs
@@ -209,38 +476,6 @@ bool _isReductionInstruction(LatteDecompilerALUInstruction* aluInstruction)
 	return aluInstruction->isOP3 == false && (aluInstruction->opcode == ALU_OP2_INST_DOT4 || aluInstruction->opcode == ALU_OP2_INST_DOT4_IEEE || aluInstruction->opcode == ALU_OP2_INST_CUBE);
 }
 
-void _appendRegisterTypeSuffix(StringBuf* src, sint32 dataType)
-{
-	if (dataType == LATTE_DECOMPILER_DTYPE_SIGNED_INT)
-		src->add("i");
-	else if (dataType == LATTE_DECOMPILER_DTYPE_UNSIGNED_INT)
-		src->add("ui");
-	else if (dataType == LATTE_DECOMPILER_DTYPE_FLOAT)
-		src->add("f");
-	else
-		cemu_assert_unimplemented();
-}
-
-void _appendChannelAccess(StringBuf* src, sint32 channelIndex)
-{
-	cemu_assert_debug(channelIndex >= 0 && channelIndex <= 3);
-	switch (channelIndex)
-	{
-	case 0:
-		src->add(".x");
-		return;
-	case 1:
-		src->add(".y");
-		return;
-	case 2:
-		src->add(".z");
-		return;
-	case 3:
-		src->add(".w");
-		return;
-	}
-}
-
 /*
  * Writes the name of the output variable and channel
  * E.g. R5f.x or tempf.x if writeMask is 0
@@ -252,17 +487,10 @@ void _emitInstructionOutputVariableName(LatteDecompilerShaderContext* shaderCont
 	if( aluInstruction->writeMask == 0 )
 	{
 		// does not output to GPR
-		if( aluInstruction->aluUnit < 4 && _isReductionInstruction(aluInstruction) == false )
+		if( !_isReductionInstruction(aluInstruction) )
 		{
-			// output to PV
-			src->addFmt("PV{}", (aluInstruction->instructionGroupIndex&1));
-			_appendRegisterTypeSuffix(src, outputDataType);
-		}
-		else if( aluInstruction->aluUnit == 4 && _isReductionInstruction(aluInstruction) == false )
-		{
-			// output to PS
-			src->addFmt("PS{}", (aluInstruction->instructionGroupIndex&1));
-			_appendRegisterTypeSuffix(src, outputDataType);
+			// output to PV/PS
+			_appendPVPS(shaderContext, src, aluInstruction->instructionGroupIndex, aluInstruction->aluUnit);
 			return;
 		}
 		else
@@ -275,7 +503,7 @@ void _emitInstructionOutputVariableName(LatteDecompilerShaderContext* shaderCont
 	}
 	else
 	{
-		// output to GPR
+		// output to GPR. Aliasing to PV/PS happens at the end of the group
 		src->add(_getRegisterVarName(shaderContext, aluInstruction->destGpr, aluInstruction->destRel==0?-1:aluInstruction->indexMode));
 		_appendChannelAccess(src, aluInstruction->destElem);
 	}
@@ -283,23 +511,7 @@ void _emitInstructionOutputVariableName(LatteDecompilerShaderContext* shaderCont
 
 void _emitInstructionPVPSOutputVariableName(LatteDecompilerShaderContext* shaderContext, LatteDecompilerALUInstruction* aluInstruction)
 {
-	StringBuf* src = shaderContext->shaderSource;
-	if( aluInstruction->aluUnit == 4 )
-	{
-		// output to PS
-		src->addFmt("PS{}", aluInstruction->instructionGroupIndex&1);
-	}
-	else
-	{
-		// output to PV
-		src->addFmt("PV{}", aluInstruction->instructionGroupIndex&1);
-	}
-	sint32 outputDataType = _getALUInstructionOutputDataType(shaderContext, aluInstruction);
-	_appendRegisterTypeSuffix(src, outputDataType);
-	if( aluInstruction->aluUnit < 4 )
-	{
-		_appendChannelAccess(src, aluInstruction->aluUnit);
-	}
+	_appendPVPS(shaderContext, shaderContext->shaderSource, aluInstruction->instructionGroupIndex, aluInstruction->aluUnit);
 }
 
 void _emitRegisterAccessCode(LatteDecompilerShaderContext* shaderContext, sint32 gprIndex, sint32 channel0, sint32 channel1, sint32 channel2, sint32 channel3, sint32 dataType = -1)
@@ -311,7 +523,7 @@ void _emitRegisterAccessCode(LatteDecompilerShaderContext* shaderContext, sint32
 	{
 		_emitTypeConversionPrefix(shaderContext, registerElementDataType, dataType);
 	}
-	if(shaderContext->typeTracker.useArrayGPRs )
+	if (shaderContext->typeTracker.useArrayGPRs)
 		src->add("R");
 	else
 		src->addFmt("R{}", gprIndex);
@@ -344,18 +556,37 @@ void _emitRegisterAccessCode(LatteDecompilerShaderContext* shaderContext, sint32
 		_emitTypeConversionSuffix(shaderContext, registerElementDataType, dataType);
 }
 
+// optimized variant of _emitRegisterAccessCode for raw one channel reads
+void _emitRegisterChannelAccessCode(LatteDecompilerShaderContext* shaderContext, sint32 gprIndex, sint32 channel, sint32 dataType)
+{
+	cemu_assert_debug(gprIndex >= 0 && gprIndex <= 127);
+	cemu_assert_debug(channel >= 0 && channel < 4);
+	StringBuf* src = shaderContext->shaderSource;
+	sint32 registerElementDataType = shaderContext->typeTracker.defaultDataType;
+	_emitTypeConversionPrefix(shaderContext, registerElementDataType, dataType);
+	if (shaderContext->typeTracker.useArrayGPRs)
+		src->add("R");
+	else
+		src->addFmt("R{}", gprIndex);
+	_appendRegisterTypeSuffix(src, registerElementDataType);
+	if (shaderContext->typeTracker.useArrayGPRs)
+		src->addFmt("[{}]", gprIndex);
+	src->add(".");
+	src->add(_getElementStrByIndex(channel));
+	_emitTypeConversionSuffix(shaderContext, registerElementDataType, dataType);
+}
+
 void _emitALURegisterInputAccessCode(LatteDecompilerShaderContext* shaderContext, LatteDecompilerALUInstruction* aluInstruction, sint32 operandIndex)
 {
 	StringBuf* src = shaderContext->shaderSource;
 	sint32 currentRegisterElementType = _getInputRegisterDataType(shaderContext, aluInstruction, operandIndex);
-	if( GPU7_ALU_SRC_IS_GPR(aluInstruction->sourceOperand[operandIndex].sel) == false )
-		debugBreakpoint();
-	sint32 gprIndex = GPU7_ALU_SRC_GET_GPR_INDEX(aluInstruction->sourceOperand[operandIndex].sel);
-
-	if( aluInstruction->sourceOperand[operandIndex].requiredRegisterBackup )
+	cemu_assert_debug(GPU7_ALU_SRC_IS_GPR(aluInstruction->sourceOperand[operandIndex].sel));
+	sint32 gprIndex = GPU7_ALU_SRC_GET_GPR_INDEX(aluInstruction->sourceOperand[operandIndex].sel);	
+	sint32 temporaryIndex = shaderContext->aluPVPSState->GetTemporaryForGPR(gprIndex, aluInstruction->sourceOperand[operandIndex].chan);
+	if(temporaryIndex >= 0)
 	{
 		// access via backup variable
-		src->addFmt("backupReg{}", aluInstruction->sourceOperand[operandIndex].registerBackupIndex);
+		src->addFmt("backupReg{}", temporaryIndex);
 		_appendRegisterTypeSuffix(src, currentRegisterElementType);
 	}
 	else
@@ -365,21 +596,11 @@ void _emitALURegisterInputAccessCode(LatteDecompilerShaderContext* shaderContext
 	}
 }
 
-void _emitPVAccessCode(LatteDecompilerShaderContext* shaderContext, LatteDecompilerALUInstruction* aluInstruction, sint32 operandIndex)
+void _emitPVPSAccessCode(LatteDecompilerShaderContext* shaderContext, LatteDecompilerALUInstruction* aluInstruction, sint32 operandIndex, uint8 aluUnitIndex)
 {
-	StringBuf* src = shaderContext->shaderSource;
-	sint32 currentRegisterElementType = _getInputRegisterDataType(shaderContext, aluInstruction, operandIndex);
-	src->addFmt("PV{}", (aluInstruction->instructionGroupIndex&1)^1);
-	_appendRegisterTypeSuffix(src, currentRegisterElementType);
-	_appendChannelAccess(src, aluInstruction->sourceOperand[operandIndex].chan);
-}
-
-void _emitPSAccessCode(LatteDecompilerShaderContext* shaderContext, LatteDecompilerALUInstruction* aluInstruction, sint32 operandIndex)
-{
-	StringBuf* src = shaderContext->shaderSource;
-	sint32 currentRegisterElementType = _getInputRegisterDataType(shaderContext, aluInstruction, operandIndex);
-	src->addFmt("PS{}", (aluInstruction->instructionGroupIndex&1)^1);
-	_appendRegisterTypeSuffix(src, currentRegisterElementType);
+	cemu_assert_debug(aluInstruction->instructionGroupIndex > 0); // PV/PS is uninitialized for group 0
+	// PV/PS vars are currently always using the default type (shaderContext->typeTracker.defaultDataType)
+	shaderContext->aluPVPSState->EmitPVPSAccess(shaderContext, aluUnitIndex, aluInstruction->instructionGroupIndex);
 }
 
 /*
@@ -679,26 +900,18 @@ void _emitOperandInputCode(LatteDecompilerShaderContext* shaderContext, LatteDec
 			src->add("0");
 		else if( requiredType == LATTE_DECOMPILER_DTYPE_FLOAT )
 			src->add("0.0");
-		else
-			debugBreakpoint();
 	}
 	else if( GPU7_ALU_SRC_IS_CONST_1F(aluInstruction->sourceOperand[operandIndex].sel) )
 	{
-		if( requiredType == LATTE_DECOMPILER_DTYPE_SIGNED_INT )
-			src->add("floatBitsToInt(1.0)");
-		else if( requiredType == LATTE_DECOMPILER_DTYPE_FLOAT )
-			src->add("1.0");
-		else
-			debugBreakpoint();
+		_emitTypeConversionPrefix(shaderContext, LATTE_DECOMPILER_DTYPE_FLOAT, requiredType);
+		src->add("1.0");
+		_emitTypeConversionSuffix(shaderContext, LATTE_DECOMPILER_DTYPE_FLOAT, requiredType);
 	}
 	else if( GPU7_ALU_SRC_IS_CONST_0_5F(aluInstruction->sourceOperand[operandIndex].sel) )
 	{
-		if( requiredType == LATTE_DECOMPILER_DTYPE_SIGNED_INT )
-			src->add("floatBitsToInt(0.5)");
-		else if( requiredType == LATTE_DECOMPILER_DTYPE_FLOAT )
-			src->add("0.5");
-		else
-			debugBreakpoint();
+		_emitTypeConversionPrefix(shaderContext, LATTE_DECOMPILER_DTYPE_FLOAT, requiredType);
+		src->add("0.5");
+		_emitTypeConversionSuffix(shaderContext, LATTE_DECOMPILER_DTYPE_FLOAT, requiredType);
 	}
 	else if( GPU7_ALU_SRC_IS_CONST_1I(aluInstruction->sourceOperand[operandIndex].sel) )
 	{
@@ -707,41 +920,33 @@ void _emitOperandInputCode(LatteDecompilerShaderContext* shaderContext, LatteDec
 		else if (requiredType == LATTE_DECOMPILER_DTYPE_UNSIGNED_INT)
 			src->add("uint(1)");
 		else
-			debugBreakpoint();
+			cemu_assert_suspicious();
 	}
 	else if( GPU7_ALU_SRC_IS_CONST_M1I(aluInstruction->sourceOperand[operandIndex].sel) )
 	{
 		if( requiredType == LATTE_DECOMPILER_DTYPE_SIGNED_INT )
 			src->add("int(-1)");
 		else
-			debugBreakpoint();
+			cemu_assert_suspicious();
 	}
 	else if( GPU7_ALU_SRC_IS_LITERAL(aluInstruction->sourceOperand[operandIndex].sel) )
 	{
 		if( requiredType == LATTE_DECOMPILER_DTYPE_SIGNED_INT )
-			src->addFmt("0x{:08x}", aluInstruction->literalData.w[aluInstruction->sourceOperand[operandIndex].chan]);
+			src->addFmt("0x{:x}", aluInstruction->literalData.w[aluInstruction->sourceOperand[operandIndex].chan]);
 		else if( requiredType == LATTE_DECOMPILER_DTYPE_UNSIGNED_INT )
-			src->addFmt("uint(0x{:08x})", aluInstruction->literalData.w[aluInstruction->sourceOperand[operandIndex].chan]);
+			src->addFmt("uint(0x{:x})", aluInstruction->literalData.w[aluInstruction->sourceOperand[operandIndex].chan]);
 		else if (requiredType == LATTE_DECOMPILER_DTYPE_FLOAT)
 		{
 			uint32 constVal = aluInstruction->literalData.w[aluInstruction->sourceOperand[operandIndex].chan];
-			if (constVal == 0x3f800000)
-				src->add("1.0");
-			else if (constVal == 0x3fc00000)
-				src->add("1.5");
-			else if (constVal == 0x3e800000)
-				src->add("0.25");
-			else if (constVal == 0x80000000)
-				src->add("-0.0");
-			else if (constVal == 0x40000000)
-				src->add("2.0");
-			else if (constVal == 0x40800000)
-				src->add("4.0");
+			sint32 exponent = (constVal >> 23) & 0xFF;
+			exponent -= 127;
+			if ((constVal & 0xFF) == 0 && exponent >= -10 && exponent <= 10)
+			{
+				src->add(_FormatFloatAsGLSLConstant(*(float*)&constVal));
+			}
 			else
-				src->addFmt("intBitsToFloat(0x{:08x})", aluInstruction->literalData.w[aluInstruction->sourceOperand[operandIndex].chan]);
+				src->addFmt("intBitsToFloat(0x{:08x})", constVal);
 		}
-		else
-			debugBreakpoint();
 	}
 	else if( GPU7_ALU_SRC_IS_CFILE(aluInstruction->sourceOperand[operandIndex].sel) )
 	{
@@ -755,34 +960,20 @@ void _emitOperandInputCode(LatteDecompilerShaderContext* shaderContext, LatteDec
 	else if( GPU7_ALU_SRC_IS_PV(aluInstruction->sourceOperand[operandIndex].sel) )
 	{
 		sint32 currentPVDataType = _getInputRegisterDataType(shaderContext, aluInstruction, operandIndex);
-		if( requiredType == currentPVDataType )
-		{
-			_emitPVAccessCode(shaderContext, aluInstruction, operandIndex);
-		}
-		else
-		{
-			_emitTypeConversionPrefix(shaderContext, currentPVDataType, requiredType);
-			_emitPVAccessCode(shaderContext, aluInstruction, operandIndex);
-			_emitTypeConversionSuffix(shaderContext, currentPVDataType, requiredType);
-		}
+		_emitTypeConversionPrefix(shaderContext, currentPVDataType, requiredType);
+		_emitPVPSAccessCode(shaderContext, aluInstruction, operandIndex, aluInstruction->sourceOperand[operandIndex].chan);
+		_emitTypeConversionSuffix(shaderContext, currentPVDataType, requiredType);
 	}
 	else if( GPU7_ALU_SRC_IS_PS(aluInstruction->sourceOperand[operandIndex].sel) )
 	{
 		sint32 currentPSDataType = _getInputRegisterDataType(shaderContext, aluInstruction, operandIndex);
-		if( requiredType == currentPSDataType )
-		{
-			_emitPSAccessCode(shaderContext, aluInstruction, operandIndex);
-		}
-		else
-		{
-			_emitTypeConversionPrefix(shaderContext, currentPSDataType, requiredType);
-			_emitPSAccessCode(shaderContext, aluInstruction, operandIndex);
-			_emitTypeConversionSuffix(shaderContext, currentPSDataType, requiredType);
-		}
+		_emitTypeConversionPrefix(shaderContext, currentPSDataType, requiredType);
+		_emitPVPSAccessCode(shaderContext, aluInstruction, operandIndex, 4);
+		_emitTypeConversionSuffix(shaderContext, currentPSDataType, requiredType);
 	}
 	else
 	{
-		debug_printf("Unsupported operand sel 0x%x\n", aluInstruction->sourceOperand[operandIndex].sel);
+		cemuLog_log(LogType::Force, "Unsupported shader ALU operand sel {:#x}\n", aluInstruction->sourceOperand[operandIndex].sel);
 		debugBreakpoint();
 	}
 
@@ -793,7 +984,6 @@ void _emitOperandInputCode(LatteDecompilerShaderContext* shaderContext, LatteDec
 
 	if( requiredTypeOut != requiredType )
 		_emitTypeConversionSuffix(shaderContext, requiredType, requiredTypeOut);
-
 }
 
 void _emitTypeConversionPrefix(LatteDecompilerShaderContext* shaderContext, sint32 sourceType, sint32 destinationType)
@@ -838,13 +1028,34 @@ void _emitALUOperationBinary(LatteDecompilerShaderContext* shaderContext, LatteD
 	src->add(";" _CRLF);
 }
 
+static bool _isSameGPROperand(LatteDecompilerALUInstruction* aluInstruction, sint32 opIndexA, sint32 opIndexB)
+{
+	if (aluInstruction->sourceOperand[opIndexA].sel != aluInstruction->sourceOperand[opIndexB].sel)
+		return false;
+	if (!GPU7_ALU_SRC_IS_GPR(aluInstruction->sourceOperand[opIndexA].sel))
+		return false;
+	if (aluInstruction->sourceOperand[opIndexA].chan != aluInstruction->sourceOperand[opIndexB].chan)
+		return false;
+	if (aluInstruction->sourceOperand[opIndexA].abs != aluInstruction->sourceOperand[opIndexB].abs)
+		return false;
+	if (aluInstruction->sourceOperand[opIndexA].neg != aluInstruction->sourceOperand[opIndexB].neg)
+		return false;
+	if (aluInstruction->sourceOperand[opIndexA].rel != aluInstruction->sourceOperand[opIndexB].rel)
+		return false;
+	return true;
+}
+
+static bool _operandHasModifiers(LatteDecompilerALUInstruction* aluInstruction, sint32 opIndex)
+{
+	return aluInstruction->sourceOperand[opIndex].abs != 0 || aluInstruction->sourceOperand[opIndex].neg != 0;
+}
+
 void _emitALUOP2InstructionCode(LatteDecompilerShaderContext* shaderContext, LatteDecompilerCFInstruction* cfInstruction, LatteDecompilerALUInstruction* aluInstruction)
 {
 	StringBuf* src = shaderContext->shaderSource;
-	sint32 outputType; // data type of output
+	sint32 outputType = _getALUInstructionOutputDataType(shaderContext, aluInstruction); // data type of output
 	if( aluInstruction->opcode == ALU_OP2_INST_MOV )
 	{
-		outputType = _getALUInstructionOutputDataType(shaderContext, aluInstruction);
 		bool requiresFloatMove = false;
 		requiresFloatMove = aluInstruction->sourceOperand[0].abs != 0 || aluInstruction->sourceOperand[0].neg != 0;
 		if( requiresFloatMove )
@@ -867,12 +1078,8 @@ void _emitALUOP2InstructionCode(LatteDecompilerShaderContext* shaderContext, Lat
 	}
 	else if( aluInstruction->opcode == ALU_OP2_INST_MOVA_FLOOR )
 	{
-		if( aluInstruction->writeMask != 0 )
-			debugBreakpoint();
-		if( aluInstruction->omod != 0 )
-			debugBreakpoint(); // omod is handled after instruction code, check what affect it has on AR
-		outputType = _getALUInstructionOutputDataType(shaderContext, aluInstruction);
-
+		cemu_assert_debug(aluInstruction->writeMask == 0);
+		cemu_assert_debug(aluInstruction->omod == 0);
 		src->add("tempResultf = ");
 		_emitOperandInputCode(shaderContext, aluInstruction, 0, LATTE_DECOMPILER_DTYPE_FLOAT);
 		src->add(";" _CRLF);
@@ -897,12 +1104,8 @@ void _emitALUOP2InstructionCode(LatteDecompilerShaderContext* shaderContext, Lat
 	}
 	else if( aluInstruction->opcode == ALU_OP2_INST_MOVA_INT )
 	{
-		if( aluInstruction->writeMask != 0 )
-			debugBreakpoint();
-		if( aluInstruction->omod != 0 )
-			debugBreakpoint(); // omod is handled after instruction code, check what affect it has on AR
-		outputType = _getALUInstructionOutputDataType(shaderContext, aluInstruction);
-
+		cemu_assert_debug(aluInstruction->writeMask == 0);
+		cemu_assert_debug(aluInstruction->omod == 0);
 		src->add("tempResulti = ");
 		_emitOperandInputCode(shaderContext, aluInstruction, 0, LATTE_DECOMPILER_DTYPE_SIGNED_INT);
 		src->add(";" _CRLF);
@@ -932,7 +1135,6 @@ void _emitALUOP2InstructionCode(LatteDecompilerShaderContext* shaderContext, Lat
 	else if( aluInstruction->opcode == ALU_OP2_INST_MUL )
 	{
 		// 0*anything is always 0
-		outputType = _getALUInstructionOutputDataType(shaderContext, aluInstruction);
 		_emitInstructionOutputVariableName(shaderContext, aluInstruction);
 		src->add(" = ");
 		_emitTypeConversionPrefix(shaderContext, LATTE_DECOMPILER_DTYPE_FLOAT, outputType);
@@ -952,7 +1154,7 @@ void _emitALUOP2InstructionCode(LatteDecompilerShaderContext* shaderContext, Lat
 			{
 				useDefaultMul = true;
 			}
-			if (g_current_game_profile->GetAccurateShaderMul() != AccurateShaderMulOption::False && useDefaultMul == false)
+			if (shaderContext->options->strictMul && useDefaultMul == false)
 			{
 				src->add("mul_nonIEEE(");
 				_emitOperandInputCode(shaderContext, aluInstruction, 0, LATTE_DECOMPILER_DTYPE_FLOAT);
@@ -978,7 +1180,6 @@ void _emitALUOP2InstructionCode(LatteDecompilerShaderContext* shaderContext, Lat
 	}
 	else if (aluInstruction->opcode == ALU_OP2_INST_RECIP_IEEE)
 	{
-		outputType = _getALUInstructionOutputDataType(shaderContext, aluInstruction);
 		_emitInstructionOutputVariableName(shaderContext, aluInstruction);
 		src->add(" = ");
 		_emitTypeConversionPrefix(shaderContext, LATTE_DECOMPILER_DTYPE_FLOAT, outputType);
@@ -999,7 +1200,6 @@ void _emitALUOP2InstructionCode(LatteDecompilerShaderContext* shaderContext, Lat
 		// -INF becomes -0.0
 		src->add("else if( isinf(tempResultf) == true && (floatBitsToInt(tempResultf)&0x80000000) != 0 ) tempResultf = -0.0;" _CRLF);
 		// assign result to output
-		outputType = _getALUInstructionOutputDataType(shaderContext, aluInstruction);
 		_emitInstructionOutputVariableName(shaderContext, aluInstruction);
 		src->add(" = ");
 		_emitTypeConversionPrefix(shaderContext, LATTE_DECOMPILER_DTYPE_FLOAT, outputType);
@@ -1028,7 +1228,6 @@ void _emitALUOP2InstructionCode(LatteDecompilerShaderContext* shaderContext, Lat
 			src->add("else if( isinf(tempResultf) == true && (floatBitsToInt(tempResultf)&0x80000000) == 0 ) tempResultf = 0.0;" _CRLF);
 		}
 		// assign result to output
-		outputType = _getALUInstructionOutputDataType(shaderContext, aluInstruction);
 		_emitInstructionOutputVariableName(shaderContext, aluInstruction);
 		src->add(" = ");
 		_emitTypeConversionPrefix(shaderContext, LATTE_DECOMPILER_DTYPE_FLOAT, outputType);
@@ -1038,9 +1237,9 @@ void _emitALUOP2InstructionCode(LatteDecompilerShaderContext* shaderContext, Lat
 	}
 	else if( aluInstruction->opcode == ALU_OP2_INST_MAX ||
 		aluInstruction->opcode == ALU_OP2_INST_MIN ||
-		aluInstruction->opcode == ALU_OP2_INST_MAX_DX10 )
+		aluInstruction->opcode == ALU_OP2_INST_MAX_DX10 ||
+		aluInstruction->opcode == ALU_OP2_INST_MIN_DX10 )
 	{
-		outputType = _getALUInstructionOutputDataType(shaderContext, aluInstruction);
 		_emitInstructionOutputVariableName(shaderContext, aluInstruction);
 		src->add(" = ");
 		_emitTypeConversionPrefix(shaderContext, LATTE_DECOMPILER_DTYPE_FLOAT, outputType);
@@ -1048,10 +1247,10 @@ void _emitALUOP2InstructionCode(LatteDecompilerShaderContext* shaderContext, Lat
 			src->add("max");
 		else if( aluInstruction->opcode == ALU_OP2_INST_MIN )
 			src->add("min");
-		else if( aluInstruction->opcode == ALU_OP2_INST_MAX_DX10 )
-		{
+		else if (aluInstruction->opcode == ALU_OP2_INST_MAX_DX10)
 			src->add("max");
-		}
+		else if (aluInstruction->opcode == ALU_OP2_INST_MIN_DX10)
+			src->add("min");
 		src->add("(");
 		_emitOperandInputCode(shaderContext, aluInstruction, 0, LATTE_DECOMPILER_DTYPE_FLOAT);
 		src->add(", ");
@@ -1064,7 +1263,6 @@ void _emitALUOP2InstructionCode(LatteDecompilerShaderContext* shaderContext, Lat
 		aluInstruction->opcode == ALU_OP2_INST_FRACT ||
 		aluInstruction->opcode == ALU_OP2_INST_TRUNC )
 	{
-		outputType = _getALUInstructionOutputDataType(shaderContext, aluInstruction);
 		_emitInstructionOutputVariableName(shaderContext, aluInstruction);
 		src->add(" = ");
 		_emitTypeConversionPrefix(shaderContext, LATTE_DECOMPILER_DTYPE_FLOAT, outputType);
@@ -1090,11 +1288,9 @@ void _emitALUOP2InstructionCode(LatteDecompilerShaderContext* shaderContext, Lat
 		src->add("tempResultf = log2(tempResultf);" _CRLF);
 		if( aluInstruction->opcode == ALU_OP2_INST_LOG_CLAMPED )
 		{
-			// note: apparently -INF < 0.0 does not resolve to true
 			src->add("if( isinf(tempResultf) == true ) tempResultf = -3.40282347E+38F;" _CRLF);
 		}
 		// assign result to output
-		outputType = _getALUInstructionOutputDataType(shaderContext, aluInstruction);
 		_emitInstructionOutputVariableName(shaderContext, aluInstruction);
 		src->add(" = ");
 		_emitTypeConversionPrefix(shaderContext, LATTE_DECOMPILER_DTYPE_FLOAT, outputType);
@@ -1104,7 +1300,6 @@ void _emitALUOP2InstructionCode(LatteDecompilerShaderContext* shaderContext, Lat
 	}
 	else if( aluInstruction->opcode == ALU_OP2_INST_RNDNE )
 	{
-		outputType = _getALUInstructionOutputDataType(shaderContext, aluInstruction);
 		_emitInstructionOutputVariableName(shaderContext, aluInstruction);
 		src->add(" = ");
 		_emitTypeConversionPrefix(shaderContext, LATTE_DECOMPILER_DTYPE_FLOAT, outputType);
@@ -1117,7 +1312,6 @@ void _emitALUOP2InstructionCode(LatteDecompilerShaderContext* shaderContext, Lat
 	}
 	else if( aluInstruction->opcode == ALU_OP2_INST_EXP_IEEE )
 	{
-		outputType = _getALUInstructionOutputDataType(shaderContext, aluInstruction);
 		_emitInstructionOutputVariableName(shaderContext, aluInstruction);
 		src->add(" = ");
 		_emitTypeConversionPrefix(shaderContext, LATTE_DECOMPILER_DTYPE_FLOAT, outputType);
@@ -1130,7 +1324,6 @@ void _emitALUOP2InstructionCode(LatteDecompilerShaderContext* shaderContext, Lat
 	}
 	else if( aluInstruction->opcode == ALU_OP2_INST_SQRT_IEEE )
 	{
-		outputType = _getALUInstructionOutputDataType(shaderContext, aluInstruction);
 		_emitInstructionOutputVariableName(shaderContext, aluInstruction);
 		src->add(" = ");
 		_emitTypeConversionPrefix(shaderContext, LATTE_DECOMPILER_DTYPE_FLOAT, outputType);
@@ -1144,7 +1337,6 @@ void _emitALUOP2InstructionCode(LatteDecompilerShaderContext* shaderContext, Lat
 	else if( aluInstruction->opcode == ALU_OP2_INST_SIN ||
 		aluInstruction->opcode == ALU_OP2_INST_COS )
 	{
-		outputType = _getALUInstructionOutputDataType(shaderContext, aluInstruction);
 		_emitInstructionOutputVariableName(shaderContext, aluInstruction);
 		src->add(" = ");
 		_emitTypeConversionPrefix(shaderContext, LATTE_DECOMPILER_DTYPE_FLOAT, outputType);
@@ -1160,7 +1352,6 @@ void _emitALUOP2InstructionCode(LatteDecompilerShaderContext* shaderContext, Lat
 	}
 	else if( aluInstruction->opcode == ALU_OP2_INST_FLT_TO_INT )
 	{
-		outputType = _getALUInstructionOutputDataType(shaderContext, aluInstruction);
 		_emitInstructionOutputVariableName(shaderContext, aluInstruction);
 		src->add(" = ");
 		_emitTypeConversionPrefix(shaderContext, LATTE_DECOMPILER_DTYPE_SIGNED_INT, outputType);
@@ -1173,7 +1364,6 @@ void _emitALUOP2InstructionCode(LatteDecompilerShaderContext* shaderContext, Lat
 	}
 	else if( aluInstruction->opcode == ALU_OP2_INST_FLT_TO_UINT )
 	{
-		outputType = _getALUInstructionOutputDataType(shaderContext, aluInstruction);
 		_emitInstructionOutputVariableName(shaderContext, aluInstruction);
 		src->add(" = ");
 		_emitTypeConversionPrefix(shaderContext, LATTE_DECOMPILER_DTYPE_UNSIGNED_INT, outputType);
@@ -1186,12 +1376,10 @@ void _emitALUOP2InstructionCode(LatteDecompilerShaderContext* shaderContext, Lat
 	}
 	else if( aluInstruction->opcode == ALU_OP2_INST_INT_TO_FLOAT )
 	{
-		outputType = _getALUInstructionOutputDataType(shaderContext, aluInstruction);
 		_emitInstructionOutputVariableName(shaderContext, aluInstruction);
 		src->add(" = ");
 		_emitTypeConversionPrefix(shaderContext, LATTE_DECOMPILER_DTYPE_FLOAT, outputType);
-		src->add("float");
-		src->add("(");
+		src->add("float(");
 		_emitOperandInputCode(shaderContext, aluInstruction, 0, LATTE_DECOMPILER_DTYPE_SIGNED_INT);
 		src->add(")");
 		_emitTypeConversionSuffix(shaderContext, LATTE_DECOMPILER_DTYPE_FLOAT, outputType);
@@ -1199,12 +1387,10 @@ void _emitALUOP2InstructionCode(LatteDecompilerShaderContext* shaderContext, Lat
 	}
 	else if( aluInstruction->opcode == ALU_OP2_INST_UINT_TO_FLOAT )
 	{
-		outputType = _getALUInstructionOutputDataType(shaderContext, aluInstruction);
 		_emitInstructionOutputVariableName(shaderContext, aluInstruction);
 		src->add(" = ");
 		_emitTypeConversionPrefix(shaderContext, LATTE_DECOMPILER_DTYPE_FLOAT, outputType);
-		src->add("float");
-		src->add("(");
+		src->add("float(");
 		_emitOperandInputCode(shaderContext, aluInstruction, 0, LATTE_DECOMPILER_DTYPE_UNSIGNED_INT);
 		src->add(")");
 		_emitTypeConversionSuffix(shaderContext, LATTE_DECOMPILER_DTYPE_FLOAT, outputType);
@@ -1218,7 +1404,6 @@ void _emitALUOP2InstructionCode(LatteDecompilerShaderContext* shaderContext, Lat
 		_emitALUOperationBinary<LATTE_DECOMPILER_DTYPE_SIGNED_INT>(shaderContext, aluInstruction, " ^ ");
 	else if( aluInstruction->opcode == ALU_OP2_INST_NOT_INT )
 	{
-		outputType = _getALUInstructionOutputDataType(shaderContext, aluInstruction);
 		_emitInstructionOutputVariableName(shaderContext, aluInstruction);
 		src->add(" = ");
 		_emitTypeConversionPrefix(shaderContext, LATTE_DECOMPILER_DTYPE_SIGNED_INT, outputType);
@@ -1230,20 +1415,23 @@ void _emitALUOP2InstructionCode(LatteDecompilerShaderContext* shaderContext, Lat
 	}
 	else if( aluInstruction->opcode == ALU_OP2_INST_ADD_INT )
 		_emitALUOperationBinary<LATTE_DECOMPILER_DTYPE_SIGNED_INT>(shaderContext, aluInstruction, " + ");
-	else if( aluInstruction->opcode == ALU_OP2_INST_MAX_INT || aluInstruction->opcode == ALU_OP2_INST_MIN_INT )
+	else if( aluInstruction->opcode == ALU_OP2_INST_MAX_INT || aluInstruction->opcode == ALU_OP2_INST_MIN_INT ||
+			 aluInstruction->opcode == ALU_OP2_INST_MAX_UINT || aluInstruction->opcode == ALU_OP2_INST_MIN_UINT)
 	{
 		// not verified
-		outputType = _getALUInstructionOutputDataType(shaderContext, aluInstruction);
+		bool isUnsigned = aluInstruction->opcode == ALU_OP2_INST_MAX_UINT || aluInstruction->opcode == ALU_OP2_INST_MIN_UINT;
+		auto opType = isUnsigned ? LATTE_DECOMPILER_DTYPE_UNSIGNED_INT : LATTE_DECOMPILER_DTYPE_SIGNED_INT;
 		_emitInstructionOutputVariableName(shaderContext, aluInstruction);
-		if( aluInstruction->opcode == ALU_OP2_INST_MAX_INT )
-			src->add(" = max(");
+		src->add(" = ");
+		_emitTypeConversionPrefix(shaderContext, opType, outputType);
+		if( aluInstruction->opcode == ALU_OP2_INST_MAX_INT || aluInstruction->opcode == ALU_OP2_INST_MAX_UINT )
+			src->add("max(");
 		else
-			src->add(" = min(");
-		_emitTypeConversionPrefix(shaderContext, LATTE_DECOMPILER_DTYPE_SIGNED_INT, outputType);
-		_emitOperandInputCode(shaderContext, aluInstruction, 0, LATTE_DECOMPILER_DTYPE_SIGNED_INT);
+			src->add("min(");
+		_emitOperandInputCode(shaderContext, aluInstruction, 0, opType);
 		src->add(", ");
-		_emitOperandInputCode(shaderContext, aluInstruction, 1, LATTE_DECOMPILER_DTYPE_SIGNED_INT);
-		_emitTypeConversionSuffix(shaderContext, LATTE_DECOMPILER_DTYPE_SIGNED_INT, outputType);
+		_emitOperandInputCode(shaderContext, aluInstruction, 1, opType);
+		_emitTypeConversionSuffix(shaderContext, opType, outputType);
 		src->add(");" _CRLF);
 	}
 	else if( aluInstruction->opcode == ALU_OP2_INST_SUB_INT )
@@ -1261,7 +1449,6 @@ void _emitALUOP2InstructionCode(LatteDecompilerShaderContext* shaderContext, Lat
 		_emitALUOperationBinary<LATTE_DECOMPILER_DTYPE_SIGNED_INT>(shaderContext, aluInstruction, " >> ");
 	else if( aluInstruction->opcode == ALU_OP2_INST_ASHR_INT )
 	{
-		outputType = _getALUInstructionOutputDataType(shaderContext, aluInstruction);
 		_emitInstructionOutputVariableName(shaderContext, aluInstruction);
 		src->add(" = ");
 		_emitTypeConversionPrefix(shaderContext, LATTE_DECOMPILER_DTYPE_SIGNED_INT, outputType);
@@ -1276,7 +1463,6 @@ void _emitALUOP2InstructionCode(LatteDecompilerShaderContext* shaderContext, Lat
 		aluInstruction->opcode == ALU_OP2_INST_SETNE ||
 		aluInstruction->opcode == ALU_OP2_INST_SETE )
 	{
-		outputType = _getALUInstructionOutputDataType(shaderContext, aluInstruction);
 		_emitInstructionOutputVariableName(shaderContext, aluInstruction);
 		src->add(" = ");
 		_emitTypeConversionPrefix(shaderContext, LATTE_DECOMPILER_DTYPE_FLOAT, outputType);
@@ -1302,7 +1488,6 @@ void _emitALUOP2InstructionCode(LatteDecompilerShaderContext* shaderContext, Lat
 	{
 		if( aluInstruction->omod != 0 )
 			debugBreakpoint();
-		outputType = _getALUInstructionOutputDataType(shaderContext, aluInstruction);
 		_emitInstructionOutputVariableName(shaderContext, aluInstruction);
 		src->add(" = ");
 		_emitTypeConversionPrefix(shaderContext, LATTE_DECOMPILER_DTYPE_SIGNED_INT, outputType);
@@ -1317,7 +1502,7 @@ void _emitALUOP2InstructionCode(LatteDecompilerShaderContext* shaderContext, Lat
 		else if( aluInstruction->opcode == ALU_OP2_INST_SETGE_DX10 )
 			src->add(" >= ");
 		_emitOperandInputCode(shaderContext, aluInstruction, 1, LATTE_DECOMPILER_DTYPE_FLOAT);
-		src->add(")?int(0xFFFFFFFF):int(0x0))");
+		src->add(")?-1:0)");
 		_emitTypeConversionSuffix(shaderContext, LATTE_DECOMPILER_DTYPE_SIGNED_INT, outputType);
 		src->add(";");
 		src->add(_CRLF);
@@ -1327,7 +1512,6 @@ void _emitALUOP2InstructionCode(LatteDecompilerShaderContext* shaderContext, Lat
 		aluInstruction->opcode == ALU_OP2_INST_SETGT_INT || 
 		aluInstruction->opcode == ALU_OP2_INST_SETGE_INT )
 	{
-		outputType = _getALUInstructionOutputDataType(shaderContext, aluInstruction);
 		_emitInstructionOutputVariableName(shaderContext, aluInstruction);
 		src->add(" = ");
 		_emitTypeConversionPrefix(shaderContext, LATTE_DECOMPILER_DTYPE_SIGNED_INT, outputType);
@@ -1342,7 +1526,7 @@ void _emitALUOP2InstructionCode(LatteDecompilerShaderContext* shaderContext, Lat
 		else if( aluInstruction->opcode == ALU_OP2_INST_SETGE_INT )
 			src->add(" >= ");
 		_emitOperandInputCode(shaderContext, aluInstruction, 1, LATTE_DECOMPILER_DTYPE_SIGNED_INT);
-		src->add(")?int(0xFFFFFFFF):int(0x0)");
+		src->add(")?-1:0");
 		_emitTypeConversionSuffix(shaderContext, LATTE_DECOMPILER_DTYPE_SIGNED_INT, outputType);
 		src->add(";" _CRLF);
 	}
@@ -1350,7 +1534,6 @@ void _emitALUOP2InstructionCode(LatteDecompilerShaderContext* shaderContext, Lat
 		aluInstruction->opcode == ALU_OP2_INST_SETGT_UINT )
 	{
 		// todo: Unsure if the result is unsigned or signed
-		outputType = _getALUInstructionOutputDataType(shaderContext, aluInstruction);
 		_emitInstructionOutputVariableName(shaderContext, aluInstruction);
 		src->add(" = ");
 		_emitTypeConversionPrefix(shaderContext, LATTE_DECOMPILER_DTYPE_SIGNED_INT, outputType);
@@ -1374,9 +1557,7 @@ void _emitALUOP2InstructionCode(LatteDecompilerShaderContext* shaderContext, Lat
 		aluInstruction->opcode == ALU_OP2_INST_PRED_SETGE_INT ||
 		aluInstruction->opcode == ALU_OP2_INST_PRED_SETGT_INT )
 	{
-		if( aluInstruction->writeMask != 0 )
-			debugBreakpoint();
-
+		cemu_assert_debug(aluInstruction->writeMask == 0);
 		bool isIntPred = (aluInstruction->opcode == ALU_OP2_INST_PRED_SETNE_INT) || (aluInstruction->opcode == ALU_OP2_INST_PRED_SETE_INT) || (aluInstruction->opcode == ALU_OP2_INST_PRED_SETGE_INT) || (aluInstruction->opcode == ALU_OP2_INST_PRED_SETGT_INT);
 
 		src->add("predResult");
@@ -1462,19 +1643,41 @@ void _emitALUOP3InstructionCode(LatteDecompilerShaderContext* shaderContext, Lat
 {
 	StringBuf* src = shaderContext->shaderSource;
 	cemu_assert_debug(aluInstruction->destRel == 0); // todo
-	sint32 outputType; // data type of output
+	sint32 outputType = _getALUInstructionOutputDataType(shaderContext, aluInstruction);
+
+	/* check for common no-op or mov-like instructions */
+	if (aluInstruction->opcode == ALU_OP3_INST_CMOVGE || 
+		aluInstruction->opcode == ALU_OP3_INST_CMOVE || 
+		aluInstruction->opcode == ALU_OP3_INST_CMOVGT || 
+		aluInstruction->opcode == ALU_OP3_INST_CNDE_INT || 
+		aluInstruction->opcode == ALU_OP3_INST_CNDGT_INT || 
+		aluInstruction->opcode == ALU_OP3_INST_CMOVGE_INT)
+	{
+		if (_isSameGPROperand(aluInstruction, 1, 2) && !_operandHasModifiers(aluInstruction, 1))
+		{
+			// the condition is irrelevant as both operands are the same
+			_emitInstructionOutputVariableName(shaderContext, aluInstruction);
+			src->add(" = ");
+			_emitOperandInputCode(shaderContext, aluInstruction, 1, outputType);
+			src->add(";" _CRLF);
+			return;
+		}
+	}
+
+
+	/* generic handlers */
 	if( aluInstruction->opcode == ALU_OP3_INST_MULADD ||
 		aluInstruction->opcode == ALU_OP3_INST_MULADD_D2 ||
 		aluInstruction->opcode == ALU_OP3_INST_MULADD_M2 ||
 		aluInstruction->opcode == ALU_OP3_INST_MULADD_M4 ||
 		aluInstruction->opcode == ALU_OP3_INST_MULADD_IEEE )
 	{
-		// todo: Figure out the exact difference between normal MULADD and MULADD_IEEE
-		outputType = _getALUInstructionOutputDataType(shaderContext, aluInstruction);
+		// todo: The difference between MULADD and MULADD IEEE is that the former has 0*anything=0 rule similar to MUL/MUL_IEEE?
 		_emitInstructionOutputVariableName(shaderContext, aluInstruction);
 		src->add(" = ");
 		_emitTypeConversionPrefix(shaderContext, LATTE_DECOMPILER_DTYPE_FLOAT, outputType);
-		src->add("(");
+		if (aluInstruction->opcode != ALU_OP3_INST_MULADD) // avoid unnecessary parenthesis to improve code readability slightly
+			src->add("(");
 		
 		bool useDefaultMul = false;
 		if (GPU7_ALU_SRC_IS_LITERAL(aluInstruction->sourceOperand[0].sel) || GPU7_ALU_SRC_IS_LITERAL(aluInstruction->sourceOperand[1].sel) ||
@@ -1485,7 +1688,7 @@ void _emitALUOP3InstructionCode(LatteDecompilerShaderContext* shaderContext, Lat
 		if (aluInstruction->opcode == ALU_OP3_INST_MULADD_IEEE)
 			useDefaultMul = true;
 
-		if (g_current_game_profile->GetAccurateShaderMul() != AccurateShaderMulOption::False && useDefaultMul == false)
+		if (shaderContext->options->strictMul && useDefaultMul == false)
 		{
 			src->add("mul_nonIEEE(");
 			_emitOperandInputCode(shaderContext, aluInstruction, 0, LATTE_DECOMPILER_DTYPE_FLOAT);
@@ -1502,7 +1705,8 @@ void _emitALUOP3InstructionCode(LatteDecompilerShaderContext* shaderContext, Lat
 
 		src->add(" + ");
 		_emitOperandInputCode(shaderContext, aluInstruction, 2, LATTE_DECOMPILER_DTYPE_FLOAT);
-		src->add(")");
+		if(aluInstruction->opcode != ALU_OP3_INST_MULADD)
+			src->add(")");
 		if( aluInstruction->opcode == ALU_OP3_INST_MULADD_D2 )
 			src->add("/2.0");
 		else if( aluInstruction->opcode == ALU_OP3_INST_MULADD_M2 )
@@ -1515,13 +1719,11 @@ void _emitALUOP3InstructionCode(LatteDecompilerShaderContext* shaderContext, Lat
 	else if(aluInstruction->opcode == ALU_OP3_INST_CNDE_INT || aluInstruction->opcode == ALU_OP3_INST_CNDGT_INT || aluInstruction->opcode == ALU_OP3_INST_CMOVGE_INT)
 	{
 		bool requiresFloatResult = (aluInstruction->sourceOperand[1].neg != 0) || (aluInstruction->sourceOperand[2].neg != 0);
-		outputType = _getALUInstructionOutputDataType(shaderContext, aluInstruction);
 		_emitInstructionOutputVariableName(shaderContext, aluInstruction);
 		src->add(" = ");
 		_emitTypeConversionPrefix(shaderContext, requiresFloatResult?LATTE_DECOMPILER_DTYPE_FLOAT:LATTE_DECOMPILER_DTYPE_SIGNED_INT, outputType);
 		src->add("((");
 		_emitOperandInputCode(shaderContext, aluInstruction, 0, LATTE_DECOMPILER_DTYPE_SIGNED_INT);
-		//src->add(" == 0)?(");
 		if (aluInstruction->opcode == ALU_OP3_INST_CNDE_INT)
 			src->add(" == ");
 		else if (aluInstruction->opcode == ALU_OP3_INST_CNDGT_INT)
@@ -1541,17 +1743,16 @@ void _emitALUOP3InstructionCode(LatteDecompilerShaderContext* shaderContext, Lat
 		aluInstruction->opcode == ALU_OP3_INST_CMOVE ||
 		aluInstruction->opcode == ALU_OP3_INST_CMOVGT )
 	{
-		outputType = _getALUInstructionOutputDataType(shaderContext, aluInstruction);
 		_emitInstructionOutputVariableName(shaderContext, aluInstruction);
 		src->add(" = ");
 		_emitTypeConversionPrefix(shaderContext, LATTE_DECOMPILER_DTYPE_SIGNED_INT, outputType);
 		src->add("((");
 		_emitOperandInputCode(shaderContext, aluInstruction, 0, LATTE_DECOMPILER_DTYPE_FLOAT);
-		if( aluInstruction->opcode == ALU_OP3_INST_CMOVE )
+		if (aluInstruction->opcode == ALU_OP3_INST_CMOVE)
 			src->add(" == ");
-		else if( aluInstruction->opcode == ALU_OP3_INST_CMOVGE )
+		else if (aluInstruction->opcode == ALU_OP3_INST_CMOVGE)
 			src->add(" >= ");
-		else if( aluInstruction->opcode == ALU_OP3_INST_CMOVGT )
+		else if (aluInstruction->opcode == ALU_OP3_INST_CMOVGT)
 			src->add(" > ");
 		src->add("0.0)?(");
 		_emitOperandInputCode(shaderContext, aluInstruction, 1, LATTE_DECOMPILER_DTYPE_SIGNED_INT);
@@ -1691,36 +1892,20 @@ void _emitALUReductionInstructionCode(LatteDecompilerShaderContext* shaderContex
 		cemu_assert_unimplemented();
 }
 
-void _emitALUClauseRegisterBackupCode(LatteDecompilerShaderContext* shaderContext, LatteDecompilerCFInstruction* cfInstruction, sint32 startIndex, sint32 instructionGroupIndex)
+void _emitALUClauseRegisterBackupCode(LatteDecompilerShaderContext* shaderContext, LatteDecompilerCFInstruction* cfInstruction, sint32 startIndex)
 {
-	StringBuf* src = shaderContext->shaderSource;
-	for (size_t i = (uint32)startIndex; i < cfInstruction->instructionsALU.size(); i++)
+	sint32 instructionGroupIndex = cfInstruction->instructionsALU[startIndex].instructionGroupIndex;
+	size_t groupSize = 1;
+	while ((startIndex + groupSize) < cfInstruction->instructionsALU.size())
 	{
-		LatteDecompilerALUInstruction& aluInstruction = cfInstruction->instructionsALU[i];
-		if( aluInstruction.instructionGroupIndex != instructionGroupIndex )
-			break; // end of current group
-		// ignore NOP instruction
-		if( aluInstruction.isOP3 == false && aluInstruction.opcode == ALU_OP2_INST_NOP )
-			continue;
-		// check if there are any operand input registers that need to be kept intact
-		for(sint32 f=0; f<3; f++)
-		{
-			if( GPU7_ALU_SRC_IS_GPR(aluInstruction.sourceOperand[f].sel) == false )
-				continue;
-			if( aluInstruction.sourceOperand[f].requiredRegisterBackup == false )
-				continue;
-			sint32 gprIndex = GPU7_ALU_SRC_GET_GPR_INDEX(aluInstruction.sourceOperand[f].sel);
-			if (shaderContext->typeTracker.defaultDataType == LATTE_DECOMPILER_DTYPE_SIGNED_INT)
-				src->addFmt("backupReg{}i = ", aluInstruction.sourceOperand[f].registerBackupIndex);
-			else if (shaderContext->typeTracker.defaultDataType == LATTE_DECOMPILER_DTYPE_FLOAT)
-				src->addFmt("backupReg{}f = ", aluInstruction.sourceOperand[f].registerBackupIndex);
-			src->add(_getRegisterVarName(shaderContext, gprIndex));
-			_appendChannelAccess(src, aluInstruction.sourceOperand[f].chan);
-			src->add(";" _CRLF);
-		}
+		if (instructionGroupIndex != cfInstruction->instructionsALU[startIndex + groupSize].instructionGroupIndex)
+			break;
+		groupSize++;
 	}
+	shaderContext->aluPVPSState->CreateGPRTemporaries(shaderContext, { cfInstruction->instructionsALU.data() + startIndex, groupSize });
 }
 
+/*
 bool _isPVUsedInNextGroup(LatteDecompilerCFInstruction* cfInstruction, sint32 startIndex, sint32 pvUnit)
 {
 	sint32 currentGroupIndex = cfInstruction->instructionsALU[startIndex].instructionGroupIndex;
@@ -1777,6 +1962,7 @@ bool _isPVUsedInNextGroup(LatteDecompilerCFInstruction* cfInstruction, sint32 st
 	}
 	return false;
 }
+*/
 
 void _emitVec3(LatteDecompilerShaderContext* shaderContext, uint32 dataType, LatteDecompilerALUInstruction* aluInst0, sint32 opIdx0, LatteDecompilerALUInstruction* aluInst1, sint32 opIdx1, LatteDecompilerALUInstruction* aluInst2, sint32 opIdx2)
 {
@@ -1818,103 +2004,33 @@ void _emitGPRVectorAssignment(LatteDecompilerShaderContext* shaderContext, Latte
 	src->add(" = ");
 }
 
-/*
- * Analyze 3 instructions from the same group and generate vectorized/optimized code if possible
- * Return true if code was generated
- */
-bool _handleInstructionPattern3(LatteDecompilerShaderContext* shaderContext, LatteDecompilerCFInstruction* cfInstruction, sint32 startIndex, LatteDecompilerALUInstruction** instructionBlock)
-{
-	// check if omod and clamp is zero
-	if (instructionBlock[0]->omod != 0 || instructionBlock[0]->destClamp != 0)
-		return false;
-	if (instructionBlock[1]->omod != 0 || instructionBlock[1]->destClamp != 0)
-		return false;
-	if (instructionBlock[2]->omod != 0 || instructionBlock[2]->destClamp != 0)
-		return false;
-	// check if destination operand is the same register
-	// todo: Also check for PV
-	if (instructionBlock[0]->writeMask == 0 ||
-		instructionBlock[1]->writeMask == 0 ||
-		instructionBlock[2]->writeMask == 0
-		)
-		return false;
-	if (instructionBlock[0]->destGpr != instructionBlock[1]->destGpr || instructionBlock[1]->destGpr != instructionBlock[2]->destGpr)
-		return false;
-	if (instructionBlock[0]->destRel != 0 || instructionBlock[1]->destRel != 0 || instructionBlock[2]->destRel != 0)
-		return false;
-	// make sure all instructions are of type OP2
-	//if (instructionBlock[0]->isOP3 || instructionBlock[1]->isOP3 || instructionBlock[2]->isOP3)
-	//	return false;
-	if (instructionBlock[0]->isOP3 != instructionBlock[1]->isOP3 || instructionBlock[1]->isOP3 != instructionBlock[2]->isOP3)
-		return false;
-	// check if operation is the same
-	if (instructionBlock[0]->opcode != instructionBlock[1]->opcode || instructionBlock[1]->opcode != instructionBlock[2]->opcode)
-		return false;
-	// at this point we know the following conditions are true for the instruction block:
-	// All output to the same GPR
-	// All share the same OP2 operation
-	// omod and destClamp is 0
-	StringBuf* src = shaderContext->shaderSource;
-	if (instructionBlock[0]->isOP3 == false && instructionBlock[0]->opcode == ALU_OP2_INST_MOV)
-	{
-		uint32 outputType = _getALUInstructionOutputDataType(shaderContext, instructionBlock[0]);
-		_emitGPRVectorAssignment(shaderContext, instructionBlock, 3);
-		_emitVec3(shaderContext, outputType, instructionBlock[0], 0, instructionBlock[1], 0, instructionBlock[2], 0);
-		src->add(";" _CRLF);
-	}
-	else if (instructionBlock[0]->isOP3 == false && instructionBlock[0]->opcode == ALU_OP2_INST_ADD)
-	{
-		uint32 outputType = _getALUInstructionOutputDataType(shaderContext, instructionBlock[0]);
-		_emitGPRVectorAssignment(shaderContext, instructionBlock, 3);
-		_emitTypeConversionPrefix(shaderContext, LATTE_DECOMPILER_DTYPE_FLOAT, outputType);
-		_emitVec3(shaderContext, LATTE_DECOMPILER_DTYPE_FLOAT, instructionBlock[0], 0, instructionBlock[1], 0, instructionBlock[2], 0);
-		src->add(" + ");
-		_emitVec3(shaderContext, LATTE_DECOMPILER_DTYPE_FLOAT, instructionBlock[0], 1, instructionBlock[1], 1, instructionBlock[2], 1);
-		_emitTypeConversionSuffix(shaderContext, LATTE_DECOMPILER_DTYPE_FLOAT, outputType);
-		src->add(";" _CRLF);
-	}
-	else
-		return false;
-	// handle PV/PS
-	for (sint32 i = 0; i < 3; i++)
-	{
-		LatteDecompilerALUInstruction* aluInstruction = instructionBlock[i];
-		bool skipPV = false;
-		if (aluInstruction->writeMask == 0)
-			skipPV = true; // no write -> Value already written to PV/PS
-		if (aluInstruction->aluUnit < 4 && _isPVUsedInNextGroup(cfInstruction, startIndex, aluInstruction->aluUnit) == false)
-			skipPV = true;
-		if (skipPV == false)
-		{
-			_emitInstructionPVPSOutputVariableName(shaderContext, aluInstruction);
-			src->add(" = ");
-			_emitInstructionOutputVariableName(shaderContext, aluInstruction);
-			src->add(";" _CRLF);
-		}
-		// todo: We can vectorize this part as well
-	}
-	return true;
-}
-
 void _emitALUClauseCode(LatteDecompilerShaderContext* shaderContext, LatteDecompilerCFInstruction* cfInstruction)
 {
+	ALUClauseTemporariesState pvpsState;
+	shaderContext->aluPVPSState = &pvpsState;
 	StringBuf* src = shaderContext->shaderSource;
 	LatteDecompilerALUInstruction* aluRedcInstruction[4];
+	size_t groupStartIndex = 0;
 	for(size_t i=0; i<cfInstruction->instructionsALU.size(); i++)
 	{
 		LatteDecompilerALUInstruction& aluInstruction = cfInstruction->instructionsALU[i];
 		if( aluInstruction.indexInGroup == 0 )
 		{
 			src->addFmt("// {}" _CRLF, aluInstruction.instructionGroupIndex);
-			// create register backup code for this group (if required)
-			_emitALUClauseRegisterBackupCode(shaderContext, cfInstruction, i, aluInstruction.instructionGroupIndex);
+			// apply PV/PS updates for previous group
+			if (i > 0)
+			{
+				pvpsState.TrackGroupOutputPVPS(shaderContext, cfInstruction->instructionsALU.data() + groupStartIndex, i - groupStartIndex);
+			}
+			groupStartIndex = i;
+			// backup registers which are read after being written
+			_emitALUClauseRegisterBackupCode(shaderContext, cfInstruction, i);
 		}
 		// detect reduction instructions and use a special handler
 		bool isReductionOperation = _isReductionInstruction(&aluInstruction);
 		if( isReductionOperation )
 		{
-			if( (i+4)> cfInstruction->instructionsALU.size())
-				debugBreakpoint();
+			cemu_assert_debug((i + 4) <= cfInstruction->instructionsALU.size());
 			aluRedcInstruction[0] = &aluInstruction;
 			aluRedcInstruction[1] = &cfInstruction->instructionsALU[i + 1];
 			aluRedcInstruction[2] = &cfInstruction->instructionsALU[i + 2];
@@ -1928,35 +2044,9 @@ void _emitALUClauseCode(LatteDecompilerShaderContext* shaderContext, LatteDecomp
 			if( aluRedcInstruction[0]->destClamp != aluRedcInstruction[1]->destClamp || aluRedcInstruction[1]->destClamp != aluRedcInstruction[2]->destClamp || aluRedcInstruction[2]->destClamp != aluRedcInstruction[3]->destClamp )
 				debugBreakpoint();
 			_emitALUReductionInstructionCode(shaderContext, aluRedcInstruction);
-			i += 3; // skip the three following instructions that are part of the reduction operation
+			i += 3; // skip the instructions that are part of the reduction operation
 		}
-		// detect and handle common instruction patterns (for example, vectorizable operations)
-		if (isReductionOperation == false)
-		{
-			sint32 remainingInstructions = cfInstruction->instructionsALU.size() - i;
-			LatteDecompilerALUInstruction* instructionBlock[4];
-			// scan for instruction patterns of length 4
-			// todo
-			// scan for instruction patterns of length 3
-			if (remainingInstructions >= 3)
-			{
-				instructionBlock[0] = &aluInstruction;
-				instructionBlock[1] = &cfInstruction->instructionsALU[i + 1];
-				instructionBlock[2] = &cfInstruction->instructionsALU[i + 2];
-				if (instructionBlock[0]->instructionGroupIndex == instructionBlock[1]->instructionGroupIndex && instructionBlock[1]->instructionGroupIndex == instructionBlock[2]->instructionGroupIndex)
-				{
-					if (_handleInstructionPattern3(shaderContext, cfInstruction, i, instructionBlock))
-					{
-						i += 2;
-						continue;
-					}
-				}
-			}
-			// scan for instruction patterns of length 2
-			// todo
-		}
-		// handle instruction (if not a reduction operation, else it would already have been handled above)
-		if( isReductionOperation == false )
+		else /* not a reduction operation */
 		{
 			if( aluInstruction.isOP3 )
 			{
@@ -2002,7 +2092,7 @@ void _emitALUClauseCode(LatteDecompilerShaderContext* shaderContext, LatteDecomp
 			}
 			else
 			{
-				debugBreakpoint();
+				cemu_assert_unimplemented();
 			}
 		}
 		// handle clamp
@@ -2024,56 +2114,40 @@ void _emitALUClauseCode(LatteDecompilerShaderContext* shaderContext, LatteDecomp
 			}
 			else
 			{
-				debugBreakpoint();
+				cemu_assert_unimplemented();
 			}
 		}
-		// set PV or PS
-		if( isReductionOperation == false )
-		{
-			// make sure the result wasn't already written to PV/PS
-			bool skipPV = false;
-			if (aluInstruction.writeMask == 0)
-				skipPV = true; // no write -> Value already written to PV/PS
-			if (aluInstruction.aluUnit < 4 && _isPVUsedInNextGroup(cfInstruction, i, aluInstruction.aluUnit) == false)
-				skipPV = true;
-			if(skipPV == false)
-			{
-				_emitInstructionPVPSOutputVariableName(shaderContext, &aluInstruction);
-				src->add(" = ");
-				_emitInstructionOutputVariableName(shaderContext, &aluInstruction);
-				src->add(";" _CRLF);
-			}
-		}
-		else
+		// handle result broadcasting for reduction instructions
+		if( isReductionOperation )
 		{
 			// reduction operations set all four PV components (todo: Needs further research. According to AMD docs, dot4 only sets PV.x? update: Unlike DOT4, CUBE sets all PV elements accordingly to their GPR output?)
 			if( aluRedcInstruction[0]->opcode == ALU_OP2_INST_CUBE )
 			{
 				// CUBE
-				for(sint32 f=0; f<4; f++)
+				for (sint32 f = 0; f < 4; f++)
 				{
+					if (aluRedcInstruction[f]->writeMask != 0)
+						continue;
 					_emitInstructionPVPSOutputVariableName(shaderContext, aluRedcInstruction[f]);
 					src->add(" = ");
-					_emitInstructionOutputVariableName(shaderContext, aluRedcInstruction[f]);
+					_emitInstructionOutputVariableName(shaderContext, aluRedcInstruction[0]);
 					src->add(";" _CRLF);
 				}
 			}
 			else
 			{
 				// DOT4, DOT4_IEEE, etc.
+				// reduction operation result is only set for output in redc[0], we also need to update redc[1] to redc[3]
 				for(sint32 f=0; f<4; f++)
-				{
-					_emitInstructionPVPSOutputVariableName(shaderContext, aluRedcInstruction[f]);
-					src->add(" = ");
-					_emitInstructionOutputVariableName(shaderContext, aluRedcInstruction[0]);
-					src->add(";" _CRLF);
-				}
-				// reduction operations are only set for output in redc[0], we also need to update redc[1] to redc[3]
-				for(sint32 f=1; f<4; f++)
 				{
 					if( aluRedcInstruction[f]->writeMask == 0 )
-						continue;
-					_emitInstructionOutputVariableName(shaderContext, aluRedcInstruction[f]);
+						_emitInstructionPVPSOutputVariableName(shaderContext, aluRedcInstruction[f]);
+					else
+					{
+						if (f == 0)
+							continue;
+						_emitInstructionOutputVariableName(shaderContext, aluRedcInstruction[f]);
+					}
 					src->add(" = ");
 					_emitInstructionOutputVariableName(shaderContext, aluRedcInstruction[0]);
 					src->add(";" _CRLF);
@@ -2081,68 +2155,37 @@ void _emitALUClauseCode(LatteDecompilerShaderContext* shaderContext, LatteDecomp
 			}
 		}
 	}
+	shaderContext->aluPVPSState = nullptr;
 }
 
 /*
  * Emits code to access one component (xyzw) of the texture coordinate input vector
  */
-void _emitTEXSampleCoordInputComponent(LatteDecompilerShaderContext* shaderContext, LatteDecompilerTEXInstruction* texInstruction, sint32 componentIndex, sint32 varType)
+void _emitTEXSampleCoordInputComponent(LatteDecompilerShaderContext* shaderContext, LatteDecompilerTEXInstruction* texInstruction, sint32 componentIndex, sint32 interpretSrcAsType)
 {
+	cemu_assert(componentIndex >= 0 && componentIndex < 4);
+	cemu_assert_debug(interpretSrcAsType == LATTE_DECOMPILER_DTYPE_SIGNED_INT || interpretSrcAsType == LATTE_DECOMPILER_DTYPE_FLOAT);
 	StringBuf* src = shaderContext->shaderSource;
-	if( componentIndex >= 4 )
+	sint32 elementSel = texInstruction->textureFetch.srcSel[componentIndex];
+	if (elementSel < 4)
 	{
-		debugBreakpoint();
+		_emitRegisterChannelAccessCode(shaderContext, texInstruction->srcGpr, elementSel, interpretSrcAsType);
 		return;
 	}
-	sint32 elementSel = texInstruction->textureFetch.srcSel[componentIndex];
 	const char* resultElemTable[4] = {"x","y","z","w"};
-	if( varType == LATTE_DECOMPILER_DTYPE_SIGNED_INT )
+	if(interpretSrcAsType == LATTE_DECOMPILER_DTYPE_SIGNED_INT )
 	{
-		if (elementSel < 4)
-		{
-			if (shaderContext->typeTracker.defaultDataType == LATTE_DECOMPILER_DTYPE_SIGNED_INT)
-				src->addFmt("{}.{}", _getRegisterVarName(shaderContext, texInstruction->srcGpr), resultElemTable[elementSel]);
-			else if (shaderContext->typeTracker.defaultDataType == LATTE_DECOMPILER_DTYPE_FLOAT)
-				src->addFmt("floatBitsToInt({}.{})", _getRegisterVarName(shaderContext, texInstruction->srcGpr), resultElemTable[elementSel]);
-			else
-			{
-				cemu_assert_unimplemented();
-			}
-		}
-		else if( elementSel == 4 )
+		if( elementSel == 4 )
 			src->add("floatBitsToInt(0.0)");
 		else if( elementSel == 5 )
 			src->add("floatBitsToInt(1.0)");
-		else
-		{
-			cemu_assert_unimplemented();
-		}
 	}
-	else if( varType == LATTE_DECOMPILER_DTYPE_FLOAT )
+	else if(interpretSrcAsType == LATTE_DECOMPILER_DTYPE_FLOAT )
 	{
-		if (elementSel < 4)
-		{
-			if (shaderContext->typeTracker.defaultDataType == LATTE_DECOMPILER_DTYPE_SIGNED_INT)
-				src->addFmt("intBitsToFloat({}.{})", _getRegisterVarName(shaderContext, texInstruction->srcGpr), resultElemTable[elementSel]);
-			else if (shaderContext->typeTracker.defaultDataType == LATTE_DECOMPILER_DTYPE_FLOAT)
-				src->addFmt("{}.{}", _getRegisterVarName(shaderContext, texInstruction->srcGpr), resultElemTable[elementSel]);
-			else
-			{
-				cemu_assert_unimplemented();
-			}
-		}
-		else if( elementSel == 4 )
-			src->addFmt("0.0");
+		if( elementSel == 4 )
+			src->add("0.0");
 		else if( elementSel == 5 )
-			src->addFmt("1.0");
-		else
-		{
-			cemu_assert_unimplemented();
-		}
-	}
-	else
-	{
-		cemu_assert_unimplemented();
+			src->add("1.0");
 	}
 }
 
@@ -2387,10 +2430,6 @@ void _emitTEXSampleTextureCode(LatteDecompilerShaderContext* shaderContext, Latt
 		cemu_assert_unimplemented();
 		src->add("texture(");
 	}
-	if( texInstruction->textureFetch.srcSel[0] >= 4 )
-		cemu_assert_unimplemented();
-	if( texInstruction->textureFetch.srcSel[1] >= 4 )
-		cemu_assert_unimplemented();
 	src->addFmt("{}{}, ", _getTextureUnitVariablePrefixName(shaderContext->shader->shaderType), texInstruction->textureFetch.textureIndex);
 
 	// for textureGather() add shift (todo: depends on rounding mode set in sampler registers?)
@@ -2412,7 +2451,7 @@ void _emitTEXSampleTextureCode(LatteDecompilerShaderContext* shaderContext, Latt
 		}
 	}
 
-
+	const sint32 texCoordDataType = (texOpcode == GPU7_TEX_INST_LD) ? LATTE_DECOMPILER_DTYPE_SIGNED_INT : LATTE_DECOMPILER_DTYPE_FLOAT;
 	if(useTexelCoordinates)
 	{
 		// handle integer coordinates for texelFetch
@@ -2420,9 +2459,9 @@ void _emitTEXSampleTextureCode(LatteDecompilerShaderContext* shaderContext, Latt
 		{
 			src->add("ivec2(");
 			src->add("vec2(");
-			_emitTEXSampleCoordInputComponent(shaderContext, texInstruction, 0, (texOpcode == GPU7_TEX_INST_LD) ? LATTE_DECOMPILER_DTYPE_SIGNED_INT : LATTE_DECOMPILER_DTYPE_FLOAT);
+			_emitTEXSampleCoordInputComponent(shaderContext, texInstruction, 0, texCoordDataType);
 			src->addFmt(", ");
-			_emitTEXSampleCoordInputComponent(shaderContext, texInstruction, 1, (texOpcode == GPU7_TEX_INST_LD) ? LATTE_DECOMPILER_DTYPE_SIGNED_INT : LATTE_DECOMPILER_DTYPE_FLOAT);
+			_emitTEXSampleCoordInputComponent(shaderContext, texInstruction, 1, texCoordDataType);
 
 			src->addFmt(")*uf_tex{}Scale", texInstruction->textureFetch.textureIndex); // close vec2 and scale
 
@@ -2442,7 +2481,7 @@ void _emitTEXSampleTextureCode(LatteDecompilerShaderContext* shaderContext, Latt
 		else
 			cemu_assert_debug(false);
 	}
-	else
+	else /* useTexelCoordinates == false */
 	{
 		// float coordinates
 		if ( (texOpcode == GPU7_TEX_INST_SAMPLE_C || texOpcode == GPU7_TEX_INST_SAMPLE_C_L || texOpcode == GPU7_TEX_INST_SAMPLE_C_LZ) )
@@ -2506,10 +2545,8 @@ void _emitTEXSampleTextureCode(LatteDecompilerShaderContext* shaderContext, Latt
 		else if( texDim == Latte::E_DIM::DIM_CUBEMAP )
 		{
 			// 2 coords + faceId
-			if( texInstruction->textureFetch.srcSel[0] >= 4 || texInstruction->textureFetch.srcSel[1] >= 4 )
-			{
-				debugBreakpoint();
-			}
+			cemu_assert_debug(texInstruction->textureFetch.srcSel[0] < 4);
+			cemu_assert_debug(texInstruction->textureFetch.srcSel[1] < 4);
 			src->add("vec4(");
 			src->addFmt("redcCUBEReverse({},", _getTexGPRAccess(shaderContext, texInstruction->srcGpr, LATTE_DECOMPILER_DTYPE_FLOAT, texInstruction->textureFetch.srcSel[0], texInstruction->textureFetch.srcSel[1], -1, -1, tempBuffer0));
 			_emitTEXSampleCoordInputComponent(shaderContext, texInstruction, 2, LATTE_DECOMPILER_DTYPE_SIGNED_INT);
@@ -2524,8 +2561,11 @@ void _emitTEXSampleTextureCode(LatteDecompilerShaderContext* shaderContext, Latt
 		else
 		{
 			// 2 coords
-			src->add(_getTexGPRAccess(shaderContext, texInstruction->srcGpr, LATTE_DECOMPILER_DTYPE_FLOAT, texInstruction->textureFetch.srcSel[0], texInstruction->textureFetch.srcSel[1], -1, -1, tempBuffer0));
-
+			src->add("vec2(");
+			_emitTEXSampleCoordInputComponent(shaderContext, texInstruction, 0, LATTE_DECOMPILER_DTYPE_FLOAT);
+			src->add(",");
+			_emitTEXSampleCoordInputComponent(shaderContext, texInstruction, 1, LATTE_DECOMPILER_DTYPE_FLOAT);
+			src->add(")");
 			// avoid truncate to effectively round downwards on texel edges
 			if (ActiveSettings::ForceSamplerRoundToPrecision())
 				src->addFmt("+ vec2(1.0)/vec2(textureSize({}{}, 0))/512.0", _getTextureUnitVariablePrefixName(shaderContext->shader->shaderType), texInstruction->textureFetch.textureIndex);
@@ -2533,9 +2573,11 @@ void _emitTEXSampleTextureCode(LatteDecompilerShaderContext* shaderContext, Latt
 		// lod or lod bias parameter
 		if( texOpcode == GPU7_TEX_INST_SAMPLE_L || texOpcode == GPU7_TEX_INST_SAMPLE_LB || texOpcode == GPU7_TEX_INST_SAMPLE_C_L)
 		{
-			if( texInstruction->textureFetch.srcSel[3] >= 4 )
-				debugBreakpoint();
-			src->addFmt(",{}", _getTexGPRAccess(shaderContext, texInstruction->srcGpr, LATTE_DECOMPILER_DTYPE_FLOAT, texInstruction->textureFetch.srcSel[3], -1, -1, -1, tempBuffer0));
+			src->add(",");
+			if(texOpcode == GPU7_TEX_INST_SAMPLE_LB)
+				src->add(_FormatFloatAsGLSLConstant((float)texInstruction->textureFetch.lodBias / 16.0f));
+			else
+				_emitTEXSampleCoordInputComponent(shaderContext, texInstruction, 3, LATTE_DECOMPILER_DTYPE_FLOAT);
 		}
 		else if( texOpcode == GPU7_TEX_INST_SAMPLE_LZ || texOpcode == GPU7_TEX_INST_SAMPLE_C_LZ )
 		{
@@ -2643,7 +2685,7 @@ void _emitTEXSampleTextureCode(LatteDecompilerShaderContext* shaderContext, Latt
 	src->add(");");
 
 	// debug
-#ifndef PUBLIC_RELEASE
+#ifdef CEMU_DEBUG_ASSERT
 	if(texInstruction->opcode == GPU7_TEX_INST_LD )
 		src->add(" // TEX_INST_LD");
 	else if(texInstruction->opcode == GPU7_TEX_INST_SAMPLE )
@@ -3362,7 +3404,7 @@ void _emitCFRingWriteCode(LatteDecompilerShaderContext* shaderContext, LatteDeco
 				if ((cfInstruction->memWriteCompMask&(1 << i)) == 0)
 					continue;
 
-				if (shaderContext->useTFViaSSBO)
+				if (shaderContext->options->useTFViaSSBO)
 				{
 					uint32 u32Offset = streamWrite->exportArrayBase + i;
 					src->addFmt("sb_buffer[sbBase{} + {}]", streamWrite->bufferIndex, u32Offset);
@@ -3460,7 +3502,7 @@ void _emitStreamWriteCode(LatteDecompilerShaderContext* shaderContext, LatteDeco
 	StringBuf* src = shaderContext->shaderSource;
 	if (shaderContext->analyzer.hasStreamoutEnable == false)
 	{
-#ifndef PUBLIC_RELEASE
+#ifdef CEMU_DEBUG_ASSERT
 		src->add("// omitted streamout write" _CRLF);
 #endif
 		return;
@@ -3482,7 +3524,7 @@ void _emitStreamWriteCode(LatteDecompilerShaderContext* shaderContext, LatteDeco
 			if ((cfInstruction->memWriteCompMask&(1 << i)) == 0)
 				continue;
 
-			if (shaderContext->useTFViaSSBO)
+			if (shaderContext->options->useTFViaSSBO)
 			{
 				uint32 u32Offset = cfInstruction->exportArrayBase + i;
 				src->addFmt("sb_buffer[sbBase{} + {}]", streamoutBufferIndex, u32Offset);
@@ -3624,7 +3666,8 @@ void LatteDecompiler_emitClauseCode(LatteDecompilerShaderContext* shaderContext,
 	{
 		src->addFmt("{} = {} == true && {} == true;" _CRLF, _getActiveMaskCVarName(shaderContext, cfInstruction->activeStackDepth + 1 - cfInstruction->popCount), _getActiveMaskVarName(shaderContext, cfInstruction->activeStackDepth - cfInstruction->popCount), _getActiveMaskCVarName(shaderContext, cfInstruction->activeStackDepth - cfInstruction->popCount));
 	}
-	else if( cfInstruction->type == GPU7_CF_INST_LOOP_START_DX10 )
+	else if( cfInstruction->type == GPU7_CF_INST_LOOP_START_DX10 ||
+			 cfInstruction->type == GPU7_CF_INST_LOOP_START_NO_AL)
 	{
 		// start of loop
 		// if pixel is disabled, then skip loop
@@ -3804,8 +3847,6 @@ void LatteDecompiler_emitGLSLHelperFunctions(LatteDecompilerShaderContext* shade
 		"v.z = -1.0;\r\n"
 		"}\r\n"
 
-
-
 		"return v;\r\n"
 		"}\r\n");
 	}
@@ -3821,7 +3862,7 @@ void LatteDecompiler_emitGLSLHelperFunctions(LatteDecompilerShaderContext* shade
 		"return floatBitsToInt(clamp(intBitsToFloat(v), 0.0, 1.0));\r\n"
 	"}\r\n");
 	// mul non-ieee way (0*NaN/INF => 0.0)
-	if (g_current_game_profile->GetAccurateShaderMul() == AccurateShaderMulOption::True)
+	if (shaderContext->options->strictMul)
 	{
 		// things we tried:
 		//fCStr_shaderSource->add("float mul_nonIEEE(float a, float b){ return mix(a*b,0.0,a==0.0||b==0.0); }" STR_LINEBREAK);
@@ -3829,60 +3870,15 @@ void LatteDecompiler_emitGLSLHelperFunctions(LatteDecompilerShaderContext* shade
 		//fCStr_shaderSource->add("float mul_nonIEEE(float a, float b){ if( a == 0.0 || b == 0.0 ) return 0.0; return a*b; }" STR_LINEBREAK);
 		//fCStr_shaderSource->add("float mul_nonIEEE(float a, float b){float r = a*b;r = intBitsToFloat(floatBitsToInt(r)&(((floatBitsToInt(a) != 0) && (floatBitsToInt(b) != 0))?0xFFFFFFFF:0));return r;}" STR_LINEBREAK); works
 
+		// for "min" it used to be: float mul_nonIEEE(float a, float b){ return min(a*b,min(abs(a)*3.40282347E+38F,abs(b)*3.40282347E+38F)); }
+
 		if( LatteGPUState.glVendor == GLVENDOR_NVIDIA && !ActiveSettings::DumpShadersEnabled())
-			fCStr_shaderSource->add("float mul_nonIEEE(float a, float b){return mix(0.0, a*b, (a != 0.0) && (b != 0.0));}" _CRLF); // compiles faster on Nvidia and also results in lower RAM usage
+			fCStr_shaderSource->add("float mul_nonIEEE(float a, float b){return mix(0.0, a*b, (a != 0.0) && (b != 0.0));}" _CRLF); // compiles faster on Nvidia and also results in lower RAM usage (OpenGL)
 		else
 			fCStr_shaderSource->add("float mul_nonIEEE(float a, float b){ if( a == 0.0 || b == 0.0 ) return 0.0; return a*b; }" _CRLF);
-	}
-	else
-	{
-		fCStr_shaderSource->add("float mul_nonIEEE(float a, float b){ return min(a*b,min(abs(a)*3.40282347E+38F,abs(b)*3.40282347E+38F)); }" _CRLF);
-	}
-}
 
-void _addPixelShaderExtraDebugInfo(LatteDecompilerShaderContext* shaderContext, StringBuf* fCStr_shaderSource)
-{
-#ifndef PUBLIC_RELEASE
-	fCStr_shaderSource->add("// Color buffers:" _CRLF);
-	for(uint32 i=0; i<8; i++)
-	{
-		uint32 regColorBuffer = shaderContext->contextRegisters[mmCB_COLOR0_BASE+i];
-		uint32 regColorSize = shaderContext->contextRegisters[mmCB_COLOR0_SIZE+i];
-		uint32 regColorInfo = shaderContext->contextRegisters[mmCB_COLOR0_INFO+i];
-		uint32 regColorView = shaderContext->contextRegisters[mmCB_COLOR0_VIEW+i];
-		MPTR colorBufferPhysMem = regColorBuffer;
-		if( regColorBuffer == MPTR_NULL )
-			continue;
-
-		uint32 colorBufferFormat  = (regColorInfo>>2)&0x3F; // format
-		uint32 colorBufferTileMode = 0;
-		colorBufferTileMode = (regColorInfo >> 8) & 0xF;
-		switch ( (regColorInfo >> 12) & 7 )
-		{
-		case 4:
-			colorBufferFormat |= 0x100;
-			break;
-		case 1:
-			colorBufferFormat |= 0x200;
-			break;
-		case 5:
-			colorBufferFormat |= 0x300;
-			break;
-		case 6:
-			colorBufferFormat |= 0x400;
-			break;
-		case 7:
-			colorBufferFormat |= 0x800;
-			break;
-		default:
-			break;
-		}
-
-		uint32 colorBufferWidth = (regColorSize>>0)&0xFFFF;
-		uint32 colorBufferHeight = (regColorSize>>16)&0xFFFF;
-		fCStr_shaderSource->addFmt("// Color{}: {}x{} at 0x{:08x} fmt {:04x} tm {}" _CRLF, i, colorBufferWidth, colorBufferHeight, colorBufferPhysMem, colorBufferFormat, colorBufferTileMode);
+		// DXKV-like: fCStr_shaderSource->add("float mul_nonIEEE(float a, float b){ return (b==0.0 ? 0.0 : a) * (a==0.0 ? 0.0 : b); }" _CRLF);
 	}
-#endif
 }
 
 #include "Cafe/HW/Latte/LegacyShaderDecompiler/LatteDecompilerEmitGLSLHeader.hpp"
@@ -3891,7 +3887,7 @@ void LatteDecompiler_emitAttributeImport(LatteDecompilerShaderContext* shaderCon
 {
 	auto src = shaderContext->shaderSource;
 
-	static const char* dsMappingTableFloat[6] = { "int(attrDecoder.x)", "int(attrDecoder.y)", "int(attrDecoder.z)", "int(attrDecoder.w)", "floatBitsToInt(0.0)", "floatBitsToInt(1.0)" };
+	static const char* dsMappingTableFloat[6] = { "int(attrDecoder.x)", "int(attrDecoder.y)", "int(attrDecoder.z)", "int(attrDecoder.w)", /*"floatBitsToInt(0.0)"*/ "0", /*"floatBitsToInt(1.0)"*/ "0x3f800000" };
 	static const char* dsMappingTableInt[6] = { "int(attrDecoder.x)", "int(attrDecoder.y)", "int(attrDecoder.z)", "int(attrDecoder.w)", "0", "1" };
 
 	// get register index based on vtx semantic table
@@ -3953,18 +3949,14 @@ void LatteDecompiler_emitGLSLShader(LatteDecompilerShaderContext* shaderContext,
 	src->add("#extension GL_ARB_texture_gather : enable" _CRLF);
 	src->add("#extension GL_ARB_separate_shader_objects : enable" _CRLF);
 
-	if (shaderContext->analyzer.hasStreamoutWrite || shaderContext->usesGeometryShader )
+	if (shaderContext->analyzer.hasStreamoutWrite || shaderContext->options->usesGeometryShader )
 		src->add("#extension GL_ARB_enhanced_layouts : enable" _CRLF);
 	
 	// debug info
-	src->addFmt("// shader %08x%08x" _CRLF, (uint32)(shaderContext->shaderBaseHash >> 32), (uint32)(shaderContext->shaderBaseHash & 0xFFFFFFFF));
-#ifndef PUBLIC_RELEASE
+	src->addFmt("// shader {:016x}" _CRLF, shaderContext->shaderBaseHash);
+#ifdef CEMU_DEBUG_ASSERT
 	src->addFmt("// usesIntegerValues: {}" _CRLF, shaderContext->analyzer.usesIntegerValues?"true":"false");
 	src->addFmt(_CRLF);
-
-	if( shader->shaderType == LatteConst::ShaderType::Pixel )
-		_addPixelShaderExtraDebugInfo(shaderContext, src);
-	
 #endif
 	// header part (definitions for inputs and outputs)
 	LatteDecompiler::emitHeader(shaderContext);
@@ -3981,7 +3973,6 @@ void LatteDecompiler_emitGLSLShader(LatteDecompilerShaderContext* shaderContext,
 		{
 			if (shaderContext->analyzer.usesRelativeGPRRead || (shaderContext->analyzer.gprUseMask[i / 8] & (1 << (i & 7))) != 0)
 			{
-				//fCStr_appendFormatted(fCStr_shaderSource, "ivec4 R{}i, R{}i, R{}i, R{}i;" STR_LINEBREAK, i*4+0, i*4+1, i*4+2, i*4+3);
 				if (shaderContext->typeTracker.genIntReg)
 					src->addFmt("ivec4 R{}i = ivec4(0);" _CRLF, i);
 				else if (shaderContext->typeTracker.genFloatReg)
@@ -4013,13 +4004,13 @@ void LatteDecompiler_emitGLSLShader(LatteDecompilerShaderContext* shaderContext,
 		src->addFmt("float backupReg0f, backupReg1f, backupReg2f, backupReg3f, backupReg4f;" _CRLF);
 	if (shaderContext->typeTracker.genIntReg)
 	{
-		src->addFmt("ivec4 PV0i = ivec4(0), PV1i = ivec4(0);" _CRLF);
+		src->addFmt("int PV0ix = 0, PV0iy = 0, PV0iz = 0, PV0iw = 0, PV1ix = 0, PV1iy = 0, PV1iz = 0, PV1iw = 0;" _CRLF);
 		src->addFmt("int PS0i = 0, PS1i = 0;" _CRLF);
 		src->addFmt("ivec4 tempi = ivec4(0);" _CRLF);
 	}
 	if (shaderContext->typeTracker.genFloatReg)
 	{
-		src->addFmt("vec4 PV0f = vec4(0.0), PV1f = vec4(0.0);" _CRLF);
+		src->addFmt("float PV0fx = 0.0, PV0fy = 0.0, PV0fz = 0.0, PV0fw = 0.0, PV1fx = 0.0, PV1fy = 0.0, PV1fz = 0.0, PV1fw = 0.0;" _CRLF);
 		src->addFmt("float PS0f = 0.0, PS1f = 0.0;" _CRLF);
 		src->addFmt("vec4 tempf = vec4(0.0);" _CRLF);
 	}
@@ -4034,7 +4025,6 @@ void LatteDecompiler_emitGLSLShader(LatteDecompilerShaderContext* shaderContext,
 	src->add("bool predResult = true;" _CRLF);
 	if(shaderContext->analyzer.modifiesPixelActiveState )
 	{
-		// cemu_assert_debug(shaderContext->analyzer.activeStackMaxDepth == 0);
 		src->addFmt("bool activeMaskStack[{}];" _CRLF, shaderContext->analyzer.activeStackMaxDepth+1);
 		src->addFmt("bool activeMaskStackC[{}];" _CRLF, shaderContext->analyzer.activeStackMaxDepth+2);
 		for (sint32 i = 0; i < shaderContext->analyzer.activeStackMaxDepth; i++)
@@ -4052,13 +4042,16 @@ void LatteDecompiler_emitGLSLShader(LatteDecompilerShaderContext* shaderContext,
 		for (auto& subroutineInfo : shaderContext->list_subroutines)
 		{
 			sint32 subroutineMaxStackDepth = 0;
-			src->addFmt("bool activeMaskStackSub%04x[{}];" _CRLF, subroutineInfo.cfAddr, subroutineMaxStackDepth + 1);
-			src->addFmt("bool activeMaskStackCSub%04x[{}];" _CRLF, subroutineInfo.cfAddr, subroutineMaxStackDepth + 2);
+			src->addFmt("bool activeMaskStackSub{:04x}[{}];" _CRLF, subroutineInfo.cfAddr, subroutineMaxStackDepth + 1);
+			src->addFmt("bool activeMaskStackCSub{:04x}[{}];" _CRLF, subroutineInfo.cfAddr, subroutineMaxStackDepth + 2);
 		}
 	}
 	// helper variables for cube maps (todo: Only emit when used)
-	src->addFmt("vec3 cubeMapSTM;" _CRLF);
-	src->addFmt("int cubeMapFaceId;" _CRLF);
+	if (shaderContext->analyzer.hasRedcCUBE)
+	{
+		src->add("vec3 cubeMapSTM;" _CRLF);
+		src->add("int cubeMapFaceId;" _CRLF);
+	}
 	for(sint32 i=0; i<LATTE_NUM_MAX_TEX_UNITS; i++)
 	{
 		if(!shaderContext->output->textureUnitMask[i])
@@ -4105,25 +4098,18 @@ void LatteDecompiler_emitGLSLShader(LatteDecompilerShaderContext* shaderContext,
 				cemu_assert_unimplemented();
 		}
 
-		if (shaderContext->fetchShaderCount == 1)
+		LatteFetchShader* parsedFetchShader = shaderContext->fetchShader;
+		for(auto& bufferGroup : parsedFetchShader->bufferGroups)
 		{
-			LatteFetchShader* parsedFetchShader = shaderContext->fetchShaderList[0];
-			for(auto& bufferGroup : parsedFetchShader->bufferGroups)
-			{
-				for(sint32 i=0; i<bufferGroup.attribCount; i++)
-					LatteDecompiler_emitAttributeImport(shaderContext, bufferGroup.attrib[i]);
-			}
-			for (auto& bufferGroup : parsedFetchShader->bufferGroupsInvalid)
-			{
-				// these attributes point to non-existent buffers
-				// todo - figure out how the hardware actually handles this, currently we assume the input values are zero
-				for (sint32 i = 0; i < bufferGroup.attribCount; i++)
-					LatteDecompiler_emitAttributeImport(shaderContext, bufferGroup.attrib[i]);
-			}
+			for(sint32 i=0; i<bufferGroup.attribCount; i++)
+				LatteDecompiler_emitAttributeImport(shaderContext, bufferGroup.attrib[i]);
 		}
-		else
+		for (auto& bufferGroup : parsedFetchShader->bufferGroupsInvalid)
 		{
-			cemu_assert_unimplemented();
+			// these attributes point to non-existent buffers
+			// todo - figure out how the hardware actually handles this, currently we assume the input values are zero
+			for (sint32 i = 0; i < bufferGroup.attribCount; i++)
+				LatteDecompiler_emitAttributeImport(shaderContext, bufferGroup.attrib[i]);
 		}
 	}
 	else if (shader->shaderType == LatteConst::ShaderType::Pixel)
@@ -4171,7 +4157,7 @@ void LatteDecompiler_emitGLSLShader(LatteDecompilerShaderContext* shaderContext,
 				continue;
 			}
 
-			if (shaderContext->usesGeometryShader)
+			if (shaderContext->options->usesGeometryShader)
 			{
 				// import from geometry shader
 				if (shaderContext->typeTracker.defaultDataType == LATTE_DECOMPILER_DTYPE_SIGNED_INT)
@@ -4215,7 +4201,7 @@ void LatteDecompiler_emitGLSLShader(LatteDecompilerShaderContext* shaderContext,
 	// vertex shader should write renderstate point size at the end if required but not modified by shader
 	if (shaderContext->analyzer.outputPointSize && shaderContext->analyzer.writesPointSize == false)
 	{
-		if (shader->shaderType == LatteConst::ShaderType::Vertex && shaderContext->usesGeometryShader == false)
+		if (shader->shaderType == LatteConst::ShaderType::Vertex && shaderContext->options->usesGeometryShader == false)
 			src->add("gl_PointSize = uf_pointSize;" _CRLF);
 	}
 	// end of shader main
diff --git a/src/Cafe/HW/Latte/LegacyShaderDecompiler/LatteDecompilerEmitGLSLAttrDecoder.cpp b/src/Cafe/HW/Latte/LegacyShaderDecompiler/LatteDecompilerEmitGLSLAttrDecoder.cpp
index 1b6b0d16..76d76322 100644
--- a/src/Cafe/HW/Latte/LegacyShaderDecompiler/LatteDecompilerEmitGLSLAttrDecoder.cpp
+++ b/src/Cafe/HW/Latte/LegacyShaderDecompiler/LatteDecompilerEmitGLSLAttrDecoder.cpp
@@ -241,6 +241,16 @@ void LatteDecompiler_emitAttributeDecodeGLSL(LatteDecompilerShader* shaderContex
 			src->add("attrDecoder.z = floatBitsToUint(max(float(int(attrDecoder.z))/32767.0,-1.0));" _CRLF);
 			src->add("attrDecoder.w = floatBitsToUint(max(float(int(attrDecoder.w))/32767.0,-1.0));" _CRLF);
 		}
+		else if( attrib->format == FMT_16_16_16_16 && attrib->nfa == 2 && attrib->isSigned == 1 )
+		{
+			// seen in Rabbids Land
+			_readLittleEndianAttributeU16x4(shaderContext, src, attributeInputIndex);
+			src->add("if( (attrDecoder.x&0x8000) != 0 ) attrDecoder.x |= 0xFFFF0000;" _CRLF);
+			src->add("if( (attrDecoder.y&0x8000) != 0 ) attrDecoder.y |= 0xFFFF0000;" _CRLF);
+			src->add("if( (attrDecoder.z&0x8000) != 0 ) attrDecoder.z |= 0xFFFF0000;" _CRLF);
+			src->add("if( (attrDecoder.w&0x8000) != 0 ) attrDecoder.w |= 0xFFFF0000;" _CRLF);
+			src->add("attrDecoder.xyzw = floatBitsToUint(vec4(ivec4(attrDecoder)));" _CRLF);
+		}
 		else if (attrib->format == FMT_16_16_16_16_FLOAT && attrib->nfa == 2)
 		{
 			// seen in Giana Sisters: Twisted Dreams
@@ -488,7 +498,7 @@ void LatteDecompiler_emitAttributeDecodeGLSL(LatteDecompilerShader* shaderContex
 		}
 		else
 		{
-			forceLogDebug_printf("_emitAttributeDecodeGLSL(): Unsupported fmt {:02x} nfa {} signed {} endian {}\n", attrib->format, attrib->nfa, attrib->isSigned, attrib->endianSwap);
+			cemuLog_logDebug(LogType::Force, "_emitAttributeDecodeGLSL(): Unsupported fmt {:02x} nfa {} signed {} endian {}", attrib->format, attrib->nfa, attrib->isSigned, attrib->endianSwap);
 		}
 	}
 	else
@@ -496,3 +506,5 @@ void LatteDecompiler_emitAttributeDecodeGLSL(LatteDecompilerShader* shaderContex
 		cemu_assert_debug(false);
 	}
 }
+
+
diff --git a/src/Cafe/HW/Latte/LegacyShaderDecompiler/LatteDecompilerEmitGLSLHeader.hpp b/src/Cafe/HW/Latte/LegacyShaderDecompiler/LatteDecompilerEmitGLSLHeader.hpp
index c680ee43..428f8647 100644
--- a/src/Cafe/HW/Latte/LegacyShaderDecompiler/LatteDecompilerEmitGLSLHeader.hpp
+++ b/src/Cafe/HW/Latte/LegacyShaderDecompiler/LatteDecompilerEmitGLSLHeader.hpp
@@ -37,36 +37,14 @@ namespace LatteDecompiler
 		}
 		else if (decompilerContext->shader->uniformMode == LATTE_DECOMPILER_UNIFORM_MODE_FULL_CFILE)
 		{
-			// here we try to predict the accessed range so we dont have to upload the whole register file
-			// we assume that if there is a fixed-index access on an index higher than a relative access, it bounds the prior relative access
-			sint16 highestAccessIndex = -1;
-			bool highestAccessIndexIsRel = false;
-			for(auto& accessItr : decompilerContext->analyzer.uniformRegisterAccessIndices)
-			{
-				if (accessItr.index > highestAccessIndex || (accessItr.index == highestAccessIndex && accessItr.isRelative && !highestAccessIndexIsRel))
-				{
-					highestAccessIndex = accessItr.index;
-					highestAccessIndexIsRel = accessItr.isRelative;
-				}
-			}
-			if (highestAccessIndex < 0)
-				highestAccessIndex = 0;
-
-			uint32 cfileSize;
-			if (highestAccessIndexIsRel)
-				cfileSize = 256;
-			else
-				cfileSize = highestAccessIndex + 1;
-
-			// full uniform register file has to be present
+			uint32 cfileSize = decompilerContext->analyzer.uniformRegisterAccessTracker.DetermineSize(decompilerContext->shaderBaseHash, 256);
+			// full or partial uniform register file has to be present
 			if (shaderType == LatteConst::ShaderType::Vertex)
 				shaderSrc->addFmt("uniform ivec4 uf_uniformRegisterVS[{}];" _CRLF, cfileSize);
 			else if (shaderType == LatteConst::ShaderType::Pixel)
 				shaderSrc->addFmt("uniform ivec4 uf_uniformRegisterPS[{}];" _CRLF, cfileSize);
 			else if (shaderType == LatteConst::ShaderType::Geometry)
 				shaderSrc->addFmt("uniform ivec4 uf_uniformRegisterGS[{}];" _CRLF, cfileSize);
-			else
-				debugBreakpoint();
 			uniformOffsets.offset_uniformRegister = uniformCurrentOffset;
 			uniformOffsets.count_uniformRegister = cfileSize;
 			uniformCurrentOffset += 16 * cfileSize;
@@ -95,7 +73,7 @@ namespace LatteDecompiler
 		}
 		if (decompilerContext->analyzer.outputPointSize && decompilerContext->analyzer.writesPointSize == false)
 		{
-			if ((decompilerContext->shaderType == LatteConst::ShaderType::Vertex && !decompilerContext->usesGeometryShader) ||
+			if ((decompilerContext->shaderType == LatteConst::ShaderType::Vertex && !decompilerContext->options->usesGeometryShader) ||
 				decompilerContext->shaderType == LatteConst::ShaderType::Geometry)
 			{
 				uniformCurrentOffset = (uniformCurrentOffset + 3)&~3;
@@ -135,7 +113,7 @@ namespace LatteDecompiler
 		}
 		// define uf_verticesPerInstance + uf_streamoutBufferBaseX
 		if (decompilerContext->analyzer.useSSBOForStreamout &&
-			(shader->shaderType == LatteConst::ShaderType::Vertex && decompilerContext->usesGeometryShader == false) ||
+			(shader->shaderType == LatteConst::ShaderType::Vertex && decompilerContext->options->usesGeometryShader == false) ||
 			(shader->shaderType == LatteConst::ShaderType::Geometry) )
 		{
 			shaderSrc->add("uniform int uf_verticesPerInstance;" _CRLF);
@@ -168,7 +146,7 @@ namespace LatteDecompiler
 		{
 			for (uint32 i = 0; i < LATTE_NUM_MAX_UNIFORM_BUFFERS; i++)
 			{
-				if ((decompilerContext->analyzer.uniformBufferAccessMask&(1 << i)) == 0)
+				if (!decompilerContext->analyzer.uniformBufferAccessTracker[i].HasAccess())
 					continue;
 
 				cemu_assert_debug(decompilerContext->output->resourceMappingGL.uniformBuffersBindingPoint[i] >= 0);
@@ -178,7 +156,7 @@ namespace LatteDecompiler
 
 				shaderSrc->addFmt("uniform {}{}" _CRLF, _getShaderUniformBlockInterfaceName(decompilerContext->shaderType), i);
 				shaderSrc->add("{" _CRLF);
-				shaderSrc->addFmt("vec4 {}{}[{}];" _CRLF, _getShaderUniformBlockVariableName(decompilerContext->shaderType), i, LATTE_GLSL_DYNAMIC_UNIFORM_BLOCK_SIZE);
+				shaderSrc->addFmt("vec4 {}{}[{}];" _CRLF, _getShaderUniformBlockVariableName(decompilerContext->shaderType), i, decompilerContext->analyzer.uniformBufferAccessTracker[i].DetermineSize(decompilerContext->shaderBaseHash, LATTE_GLSL_DYNAMIC_UNIFORM_BLOCK_SIZE));
 				shaderSrc->add("};" _CRLF _CRLF);
 				shaderSrc->add(_CRLF);
 			}
@@ -298,14 +276,21 @@ namespace LatteDecompiler
 
 			if (decompilerContext->shaderType == LatteConst::ShaderType::Vertex || decompilerContext->shaderType == LatteConst::ShaderType::Geometry)
 			{
-				if (decompilerContext->usesGeometryShader)
+				if (decompilerContext->options->usesGeometryShader)
 					src->add("#define V2G_LAYOUT layout(location = 0)" _CRLF);
 			}
 		}
 		else if (decompilerContext->shaderType == LatteConst::ShaderType::Pixel)
 		{
-			//fCStr_shaderSource->append("#define GET_FRAGCOORD() vec4(gl_FragCoord.xy*uf_fragCoordScale.xy+uf_fragCoordScale.zw,gl_FragCoord.zw)" STR_LINEBREAK);
-			src->add("#define GET_FRAGCOORD() vec4(gl_FragCoord.xy*uf_fragCoordScale.xy,gl_FragCoord.zw)" _CRLF);
+			src->add("#define GET_FRAGCOORD() vec4(gl_FragCoord.xy*uf_fragCoordScale.xy,gl_FragCoord.z, 1.0/gl_FragCoord.w)" _CRLF);
+		}
+		if (decompilerContext->options->spirvInstrinsics.hasRoundingModeRTEFloat32)
+		{
+			src->add("#extension GL_EXT_spirv_intrinsics: enable" _CRLF);
+			// set RoundingModeRTE
+			src->add("spirv_execution_mode(4462, 16);" _CRLF);
+			src->add("spirv_execution_mode(4462, 32);" _CRLF);
+			src->add("spirv_execution_mode(4462, 64);" _CRLF);
 		}
 		src->add("#else" _CRLF);
 		// OpenGL defines
@@ -318,7 +303,7 @@ namespace LatteDecompiler
 				src->add("#define XFB_BLOCK_LAYOUT(__bufferIndex, __stride, __location) layout(xfb_buffer = __bufferIndex, xfb_stride = __stride)" _CRLF);
 
 			src->add("#define SET_POSITION(_v) gl_Position = _v\r\n");
-			if (decompilerContext->usesGeometryShader)
+			if (decompilerContext->options->usesGeometryShader)
 				src->add("#define V2G_LAYOUT" _CRLF);
 		}
 		else if (decompilerContext->shaderType == LatteConst::ShaderType::Pixel)
@@ -426,7 +411,7 @@ namespace LatteDecompiler
 	{
 		auto src = decompilerContext->shaderSource;
 		// per-vertex output (VS or GS)
-		if ((decompilerContext->shaderType == LatteConst::ShaderType::Vertex && decompilerContext->usesGeometryShader == false) ||
+		if ((decompilerContext->shaderType == LatteConst::ShaderType::Vertex && !decompilerContext->options->usesGeometryShader) ||
 			(decompilerContext->shaderType == LatteConst::ShaderType::Geometry))
 		{
 			src->add("out gl_PerVertex" _CRLF);
@@ -437,7 +422,7 @@ namespace LatteDecompiler
 			src->add("};" _CRLF);
 		}
 		// varyings (variables passed from vertex to pixel shader, only if geometry stage is disabled
-		if (decompilerContext->usesGeometryShader == false)
+		if (decompilerContext->options->usesGeometryShader == false)
 		{
 			if (decompilerContext->shaderType == LatteConst::ShaderType::Vertex)
 			{
@@ -533,7 +518,7 @@ namespace LatteDecompiler
 		// streamout buffer (transform feedback)
 		if ((decompilerContext->shaderType == LatteConst::ShaderType::Vertex || decompilerContext->shaderType == LatteConst::ShaderType::Geometry) && decompilerContext->analyzer.hasStreamoutEnable)
 		{
-			if (decompilerContext->useTFViaSSBO)
+			if (decompilerContext->options->useTFViaSSBO)
 			{
 				if (decompilerContext->analyzer.useSSBOForStreamout && decompilerContext->analyzer.hasStreamoutWrite)
 				{
diff --git a/src/Cafe/HW/Latte/LegacyShaderDecompiler/LatteDecompilerInstructions.h b/src/Cafe/HW/Latte/LegacyShaderDecompiler/LatteDecompilerInstructions.h
index 7c07155d..6c029b46 100644
--- a/src/Cafe/HW/Latte/LegacyShaderDecompiler/LatteDecompilerInstructions.h
+++ b/src/Cafe/HW/Latte/LegacyShaderDecompiler/LatteDecompilerInstructions.h
@@ -31,6 +31,7 @@
 #define ALU_OP2_INST_MAX			(0x003)
 #define ALU_OP2_INST_MIN			(0x004)
 #define ALU_OP2_INST_MAX_DX10		(0x005)
+#define ALU_OP2_INST_MIN_DX10		(0x006)
 #define ALU_OP2_INST_SETE			(0x008)
 #define ALU_OP2_INST_SETGT			(0x009)
 #define ALU_OP2_INST_SETGE			(0x00A)
@@ -59,6 +60,8 @@
 #define ALU_OP2_INST_SUB_INT		(0x035) // integer instruction
 #define ALU_OP2_INST_MAX_INT		(0x036) // integer instruction
 #define ALU_OP2_INST_MIN_INT		(0x037) // integer instruction
+#define ALU_OP2_INST_MAX_UINT		(0x038) // integer instruction
+#define ALU_OP2_INST_MIN_UINT		(0x039) // integer instruction
 #define ALU_OP2_INST_SETE_INT		(0x03A) // integer instruction
 #define ALU_OP2_INST_SETGT_INT		(0x03B) // integer instruction
 #define ALU_OP2_INST_SETGE_INT		(0x03C) // integer instruction
diff --git a/src/Cafe/HW/Latte/LegacyShaderDecompiler/LatteDecompilerInternal.h b/src/Cafe/HW/Latte/LegacyShaderDecompiler/LatteDecompilerInternal.h
index 3dc3eca6..ed1858ba 100644
--- a/src/Cafe/HW/Latte/LegacyShaderDecompiler/LatteDecompilerInternal.h
+++ b/src/Cafe/HW/Latte/LegacyShaderDecompiler/LatteDecompilerInternal.h
@@ -25,9 +25,6 @@ struct LatteDecompilerALUInstruction
 		uint8 abs{};
 		uint8 neg{};
 		uint8 chan{};
-		// register backup information (used for instruction groups where the same register is read and written)
-		bool requiredRegisterBackup{};
-		uint8 registerBackupIndex{}; // index of the used register backup variable (at the beginning of the group the register value is copied to the temporary register with this index)
 	}sourceOperand[3];
 	union
 	{
@@ -60,6 +57,7 @@ struct LatteDecompilerTEXInstruction
 		sint8 offsetY{};
 		sint8 offsetZ{};
 		bool unnormalized[4]{}; // set if texture coordinates are in [0,dim] range instead of [0,1]
+		sint8 lodBias{}; // divide by 16 to get actual value
 	}textureFetch;
 	// memRead
 	struct
@@ -70,8 +68,6 @@ struct LatteDecompilerTEXInstruction
 		uint8 nfa{};
 		uint8 isSigned{};
 	}memRead;
-	// custom shadow function
-	sint32 shadowFunctionIndex{};
 };
 
 struct LatteDecompilerCFInstruction
@@ -116,7 +112,7 @@ struct LatteDecompilerCFInstruction
 
 	~LatteDecompilerCFInstruction()
 	{
-		cemu_assert_debug(!(instructionsALU.size() != 0 && instructionsTEX.size() != 0)); // make sure we dont accidentally added the wrong instruction type
+		cemu_assert_debug(!(instructionsALU.size() != 0 && instructionsTEX.size() != 0)); // make sure we haven't accidentally added the wrong instruction type
 	}
 
 #if BOOST_OS_WINDOWS
@@ -130,32 +126,83 @@ struct LatteDecompilerCFInstruction
 	LatteDecompilerCFInstruction& operator=(LatteDecompilerCFInstruction&& mE) = default;
 };
 
-struct LatteDecompilerCFileAccess
-{
-	LatteDecompilerCFileAccess(uint8 index, bool isRelative) : index(index), isRelative(isRelative) {};
-	uint8 index;
-	bool isRelative;
-};
-
 struct LatteDecompilerSubroutineInfo
 {
 	uint32 cfAddr;
 	std::vector<LatteDecompilerCFInstruction> instructions;
 };
 
+// helper struct to track the highest accessed offset within a buffer
+struct LatteDecompilerBufferAccessTracker
+{
+	bool hasStaticIndexAccess{false};
+	bool hasDynamicIndexAccess{false};
+	sint32 highestAccessDynamicIndex{0};
+	sint32 highestAccessStaticIndex{0};
+
+	// track access, index is the array index and not a byte offset
+	void TrackAccess(sint32 index, bool isDynamicIndex)
+	{
+		if (isDynamicIndex)
+		{
+			hasDynamicIndexAccess = true;
+			if (index > highestAccessDynamicIndex)
+				highestAccessDynamicIndex = index;
+		}
+		else
+		{
+			hasStaticIndexAccess = true;
+			if (index > highestAccessStaticIndex)
+				highestAccessStaticIndex = index;
+		}
+	}
+
+	sint32 DetermineSize(uint64 shaderBaseHash, sint32 maximumSize) const
+	{
+		// here we try to predict the accessed byte range so we dont have to upload the whole buffer
+		// if no bound can be determined then return maximumSize
+		// for some known shaders we use hand-tuned values instead of the maximumSize fallback value that those shaders would normally use
+		if(shaderBaseHash == 0x8ff56afdf1a2f837) // XCX text rendering
+			return 24;
+		if(shaderBaseHash == 0x37b9100c1310d3bb) // BotW UI backdrops 1
+			return 24;
+		if(shaderBaseHash == 0xf7ba548c1fefe24a) // BotW UI backdrops 2
+			return 30;
+
+		sint32 highestAccessIndex = -1;
+		if(hasStaticIndexAccess)
+			highestAccessIndex = highestAccessStaticIndex;
+		if(hasDynamicIndexAccess)
+			return maximumSize; // dynamic index exists and no bound can be determined
+		if (highestAccessIndex < 0)
+			return 1; // no access at all? But avoid zero as a size
+		return highestAccessIndex + 1;
+	}
+
+	bool HasAccess() const
+	{
+		return hasStaticIndexAccess || hasDynamicIndexAccess;
+	}
+
+	bool HasRelativeAccess() const
+	{
+		return hasDynamicIndexAccess;
+	}
+};
+
 struct LatteDecompilerShaderContext
 {
 	LatteDecompilerOutput_t* output;
 	LatteDecompilerShader* shader;
 	LatteConst::ShaderType shaderType;
+	const class LatteDecompilerOptions* options;
 	uint32* contextRegisters; // deprecated
 	struct LatteContextRegister* contextRegistersNew;
 	uint64 shaderBaseHash;
-	StringBuf* shaderSource; // move to output struct
+	StringBuf* shaderSource;
 	std::vector<LatteDecompilerCFInstruction> cfInstructions;
 	// fetch shader (required for vertex shader)
-	LatteFetchShader* fetchShaderList[32];
-	sint32 fetchShaderCount;
+	LatteFetchShader* fetchShader{};
 	// geometry copy shader (only present when geometry shader is active)
 	LatteParsedGSCopyShader* parsedGSCopyShader;
 	// state
@@ -179,12 +226,9 @@ struct LatteDecompilerShaderContext
 		bool isPointsPrimitive{}; // set if current render primitive is points
 		bool outputPointSize{}; // set if the current shader should output the point size
 		std::bitset<256> inputAttributSemanticMask; // one set bit for every used semanticId - todo: there are only 128 bit available semantic locations? The MSB has special meaning?
-		// uniform
-		bool uniformRegisterAccess; // set to true if cfile (uniform register) is accessed
-		bool uniformRegisterDynamicAccess; // set to true if cfile (uniform register) is accessed with a dynamic index
-		uint32 uniformBufferAccessMask; // 1 bit per buffer, set if the uniform buffer is accessed
-		uint32 uniformBufferDynamicAccessMask; // 1 bit per buffer, set if the uniform buffer is accessed by dynamic index
-		std::vector<LatteDecompilerCFileAccess> uniformRegisterAccessIndices;
+		// uniforms
+		LatteDecompilerBufferAccessTracker uniformRegisterAccessTracker;
+		LatteDecompilerBufferAccessTracker uniformBufferAccessTracker[LATTE_NUM_MAX_UNIFORM_BUFFERS];
 		// ssbo
 		bool hasSSBORead; // shader has instructions that read from SSBO
 		bool hasSSBOWrite; // shader has instructions that write to SSBO
@@ -216,11 +260,8 @@ struct LatteDecompilerShaderContext
 	// emitter
 	bool hasUniformVarBlock;
 	sint32 currentBindingPointVK{};
-
-	// unsorted
-	bool usesGeometryShader; // for VS
-	bool useTFViaSSBO;
-	sint32 currentShadowFunctionIndex;
+	struct ALUClauseTemporariesState* aluPVPSState{nullptr};
+	// misc
 	std::vector<LatteDecompilerSubroutineInfo> list_subroutines;
 };
 
diff --git a/src/Cafe/HW/Latte/Renderer/OpenGL/LatteTextureGL.cpp b/src/Cafe/HW/Latte/Renderer/OpenGL/LatteTextureGL.cpp
index dac3c3a4..fb025eba 100644
--- a/src/Cafe/HW/Latte/Renderer/OpenGL/LatteTextureGL.cpp
+++ b/src/Cafe/HW/Latte/Renderer/OpenGL/LatteTextureGL.cpp
@@ -5,37 +5,19 @@
 
 #include "config/LaunchSettings.h"
 
-GLuint texIdPool[64];
-sint32 texIdPoolIndex = 64;
-
-static GLuint _genTextureHandleGL()
-{
-	if (texIdPoolIndex == 64)
-	{
-		glGenTextures(64, texIdPool);
-		texIdPoolIndex = 0;
-	}
-	texIdPoolIndex++;
-	return texIdPool[texIdPoolIndex - 1];
-}
-
-LatteTextureGL::LatteTextureGL(uint32 textureUnit, Latte::E_DIM dim, MPTR physAddress, MPTR physMipAddress, Latte::E_GX2SURFFMT format, uint32 width, uint32 height, uint32 depth, uint32 pitch, uint32 mipLevels, uint32 swizzle,
+LatteTextureGL::LatteTextureGL(Latte::E_DIM dim, MPTR physAddress, MPTR physMipAddress, Latte::E_GX2SURFFMT format, uint32 width, uint32 height, uint32 depth, uint32 pitch, uint32 mipLevels, uint32 swizzle,
 	Latte::E_HWTILEMODE tileMode, bool isDepth)
-	: LatteTexture(textureUnit, dim, physAddress, physMipAddress, format, width, height, depth, pitch, mipLevels, swizzle, tileMode, isDepth)
+	: LatteTexture(dim, physAddress, physMipAddress, format, width, height, depth, pitch, mipLevels, swizzle, tileMode, isDepth)
 {
-	GenerateEmptyTextureFromGX2Dim(dim, this->glId_texture, this->glTexTarget);
+	GenerateEmptyTextureFromGX2Dim(dim, this->glId_texture, this->glTexTarget, true);
 	// set format info
 	FormatInfoGL glFormatInfo;
-	GetOpenGLFormatInfo(isDepth, format, dim, &glFormatInfo);
+	GetOpenGLFormatInfo(isDepth, overwriteInfo.hasFormatOverwrite ? (Latte::E_GX2SURFFMT)overwriteInfo.format : format, dim, &glFormatInfo);
 	this->glInternalFormat = glFormatInfo.glInternalFormat;
 	this->isAlternativeFormat = glFormatInfo.isUsingAlternativeFormat;
-	this->hasStencil = glFormatInfo.hasStencil; // todo - should get this from the GX2 format?
-	// bind texture
-	g_renderer->texture_bindAndActivateRawTex(this, textureUnit);
-	LatteTextureGL::InitTextureState();
 	// set debug name
 	bool useGLDebugNames = false;
-#ifndef PUBLIC_RELEASE
+#ifdef CEMU_DEBUG_ASSERT
 	useGLDebugNames = true;
 #endif
 	if (LaunchSettings::NSightModeEnabled())
@@ -54,9 +36,8 @@ LatteTextureGL::~LatteTextureGL()
 	catchOpenGLError();
 }
 
-void LatteTextureGL::GenerateEmptyTextureFromGX2Dim(Latte::E_DIM dim, GLuint& texId, GLint& texTarget)
+void LatteTextureGL::GenerateEmptyTextureFromGX2Dim(Latte::E_DIM dim, GLuint& texId, GLint& texTarget, bool createForTargetType)
 {
-	texId = _genTextureHandleGL();
 	if (dim == Latte::E_DIM::DIM_2D)
 		texTarget = GL_TEXTURE_2D;
 	else if (dim == Latte::E_DIM::DIM_1D)
@@ -73,6 +54,10 @@ void LatteTextureGL::GenerateEmptyTextureFromGX2Dim(Latte::E_DIM dim, GLuint& te
 	{
 		cemu_assert_unimplemented();
 	}
+	if(createForTargetType)
+		texId = glCreateTextureWrapper(texTarget); // initializes the texture to texTarget (equivalent to calling glGenTextures + glBindTexture)
+	else
+		glGenTextures(1, &texId);
 }
 
 LatteTextureView* LatteTextureGL::CreateView(Latte::E_DIM dim, Latte::E_GX2SURFFMT format, sint32 firstMip, sint32 mipCount, sint32 firstSlice, sint32 sliceCount)
@@ -80,18 +65,6 @@ LatteTextureView* LatteTextureGL::CreateView(Latte::E_DIM dim, Latte::E_GX2SURFF
 	return new LatteTextureViewGL(this, dim, format, firstMip, mipCount, firstSlice, sliceCount);
 }
 
-void  LatteTextureGL::InitTextureState()
-{
-	// init texture with some default parameters (todo - this shouldn't be necessary if we properly set parameters when a texture is used)
-	catchOpenGLError();
-	glTexParameteri(glTexTarget, GL_TEXTURE_MAG_FILTER, GL_LINEAR);
-	glTexParameteri(glTexTarget, GL_TEXTURE_MIN_FILTER, GL_LINEAR);
-	glTexParameteri(glTexTarget, GL_TEXTURE_WRAP_S, GL_REPEAT);
-	glTexParameteri(glTexTarget, GL_TEXTURE_WRAP_T, GL_REPEAT);
-	glTexParameteri(glTexTarget, GL_TEXTURE_COMPARE_MODE, GL_NONE);
-	catchOpenGLError();
-}
-
 void LatteTextureGL::GetOpenGLFormatInfo(bool isDepth, Latte::E_GX2SURFFMT format, Latte::E_DIM dim, FormatInfoGL* formatInfoOut)
 {
 	formatInfoOut->isUsingAlternativeFormat = false;
@@ -100,34 +73,34 @@ void LatteTextureGL::GetOpenGLFormatInfo(bool isDepth, Latte::E_GX2SURFFMT forma
 	{
 		if (format == Latte::E_GX2SURFFMT::D24_S8_UNORM)
 		{
-			formatInfoOut->setDepthFormat(GL_DEPTH24_STENCIL8, GL_DEPTH_STENCIL, GL_UNSIGNED_INT_24_8, true);
+			formatInfoOut->setFormat(GL_DEPTH24_STENCIL8, GL_DEPTH_STENCIL, GL_UNSIGNED_INT_24_8);
 			return;
 		}
 		else if (format == Latte::E_GX2SURFFMT::D24_S8_FLOAT)
 		{
-			formatInfoOut->setDepthFormat(GL_DEPTH32F_STENCIL8, GL_DEPTH_STENCIL, GL_FLOAT_32_UNSIGNED_INT_24_8_REV, true);
+			formatInfoOut->setFormat(GL_DEPTH32F_STENCIL8, GL_DEPTH_STENCIL, GL_FLOAT_32_UNSIGNED_INT_24_8_REV);
 			formatInfoOut->markAsAlternativeFormat();
 			return;
 		}
 		else if (format == Latte::E_GX2SURFFMT::D32_S8_FLOAT)
 		{
-			formatInfoOut->setDepthFormat(GL_DEPTH32F_STENCIL8, GL_DEPTH_STENCIL, GL_FLOAT_32_UNSIGNED_INT_24_8_REV, true);
+			formatInfoOut->setFormat(GL_DEPTH32F_STENCIL8, GL_DEPTH_STENCIL, GL_FLOAT_32_UNSIGNED_INT_24_8_REV);
 			return;
 		}
 		else if (format == Latte::E_GX2SURFFMT::D32_FLOAT)
 		{
-			formatInfoOut->setDepthFormat(GL_DEPTH_COMPONENT32F, GL_DEPTH_COMPONENT, GL_FLOAT, false);
+			formatInfoOut->setFormat(GL_DEPTH_COMPONENT32F, GL_DEPTH_COMPONENT, GL_FLOAT);
 			return;
 		}
 		else if (format == Latte::E_GX2SURFFMT::D16_UNORM)
 		{
-			formatInfoOut->setDepthFormat(GL_DEPTH_COMPONENT16, GL_DEPTH_COMPONENT, GL_UNSIGNED_SHORT, false);
+			formatInfoOut->setFormat(GL_DEPTH_COMPONENT16, GL_DEPTH_COMPONENT, GL_UNSIGNED_SHORT);
 			return;
 		}
 		// unsupported depth format
-		forceLog_printf("OpenGL: Unsupported texture depth format 0x%04x", (uint32)format);
+		cemuLog_log(LogType::Force, "OpenGL: Unsupported texture depth format 0x{:04x}", (uint32)format);
 		// use placeholder format
-		formatInfoOut->setDepthFormat(GL_DEPTH_COMPONENT16, GL_DEPTH_COMPONENT, GL_UNSIGNED_SHORT, false);
+		formatInfoOut->setFormat(GL_DEPTH_COMPONENT16, GL_DEPTH_COMPONENT, GL_UNSIGNED_SHORT);
 		formatInfoOut->markAsAlternativeFormat();
 		return;
 	}
@@ -137,10 +110,6 @@ void LatteTextureGL::GetOpenGLFormatInfo(bool isDepth, Latte::E_GX2SURFFMT forma
 	sint32 glInternalFormat;
 	sint32 glSuppliedFormat;
 	sint32 glSuppliedFormatType;
-	// check if compressed textures should be used
-	bool allowCompressedGLFormat = true;
-	if (LatteGPUState.glVendor == GLVENDOR_INTEL_LEGACY)
-		allowCompressedGLFormat = false; // compressed formats seem to cause more harm than good on Intel
 	// get format information
 	if (format == Latte::E_GX2SURFFMT::R4_G4_UNORM)
 	{
@@ -176,20 +145,11 @@ void LatteTextureGL::GetOpenGLFormatInfo(bool isDepth, Latte::E_GX2SURFFMT forma
 	else if (format == Latte::E_GX2SURFFMT::BC1_UNORM ||
 		format == Latte::E_GX2SURFFMT::BC1_SRGB)
 	{
-		if (allowCompressedGLFormat)
-		{
-			if (format == Latte::E_GX2SURFFMT::BC1_SRGB)
-				formatInfoOut->setCompressed(GL_COMPRESSED_SRGB_ALPHA_S3TC_DXT1_EXT, -1, -1);
-			else
-				formatInfoOut->setCompressed(GL_COMPRESSED_RGBA_S3TC_DXT1_EXT, -1, -1);
-			return;
-		}
+		if (format == Latte::E_GX2SURFFMT::BC1_SRGB)
+			formatInfoOut->setCompressed(GL_COMPRESSED_SRGB_ALPHA_S3TC_DXT1_EXT, -1, -1);
 		else
-		{
-			formatInfoOut->setFormat(GL_RGBA16F, GL_RGBA, GL_FLOAT);
-			formatInfoOut->markAsAlternativeFormat();
-			return;
-		}
+			formatInfoOut->setCompressed(GL_COMPRESSED_RGBA_S3TC_DXT1_EXT, -1, -1);
+		return;
 	}
 	else if (format == Latte::E_GX2SURFFMT::BC2_UNORM || format == Latte::E_GX2SURFFMT::BC2_SRGB)
 	{
@@ -200,28 +160,18 @@ void LatteTextureGL::GetOpenGLFormatInfo(bool isDepth, Latte::E_GX2SURFFMT forma
 	}
 	else if (format == Latte::E_GX2SURFFMT::BC3_UNORM || format == Latte::E_GX2SURFFMT::BC3_SRGB)
 	{
-		if (allowCompressedGLFormat)
-		{
-			if (format == Latte::E_GX2SURFFMT::BC3_SRGB)
-				formatInfoOut->setCompressed(GL_COMPRESSED_SRGB_ALPHA_S3TC_DXT5_EXT, -1, -1);
-			else
-				formatInfoOut->setCompressed(GL_COMPRESSED_RGBA_S3TC_DXT5_EXT, -1, -1);
-			return;
-		}
+		if (format == Latte::E_GX2SURFFMT::BC3_SRGB)
+			formatInfoOut->setCompressed(GL_COMPRESSED_SRGB_ALPHA_S3TC_DXT5_EXT, -1, -1);
 		else
-		{
-			// todo: SRGB support
-			formatInfoOut->setFormat(GL_RGBA16F, GL_RGBA, GL_FLOAT);
-			formatInfoOut->markAsAlternativeFormat();
-			return;
-		}
+			formatInfoOut->setCompressed(GL_COMPRESSED_RGBA_S3TC_DXT5_EXT, -1, -1);
+		return;
 	}
 	else if (format == Latte::E_GX2SURFFMT::BC4_UNORM || format == Latte::E_GX2SURFFMT::BC4_SNORM)
 	{
+		bool allowCompressed = true;
 		if (dim != Latte::E_DIM::DIM_2D && dim != Latte::E_DIM::DIM_2D_ARRAY)
-			allowCompressedGLFormat = false; // RGTC1 does not support non-2D textures
-
-		if (allowCompressedGLFormat)
+			allowCompressed = false; // RGTC1 does not support non-2D textures
+		if (allowCompressed)
 		{
 			if (format == Latte::E_GX2SURFFMT::BC4_UNORM)
 				formatInfoOut->setCompressed(GL_COMPRESSED_RED_RGTC1, -1, -1);
@@ -238,20 +188,11 @@ void LatteTextureGL::GetOpenGLFormatInfo(bool isDepth, Latte::E_GX2SURFFMT forma
 	}
 	else if (format == Latte::E_GX2SURFFMT::BC5_UNORM || format == Latte::E_GX2SURFFMT::BC5_SNORM)
 	{
-		if (allowCompressedGLFormat)
-		{
-			if (format == Latte::E_GX2SURFFMT::BC5_SNORM)
-				formatInfoOut->setCompressed(GL_COMPRESSED_SIGNED_RG_RGTC2, -1, -1);
-			else
-				formatInfoOut->setCompressed(GL_COMPRESSED_RG_RGTC2, -1, -1);
-			return;
-		}
+		if (format == Latte::E_GX2SURFFMT::BC5_SNORM)
+			formatInfoOut->setCompressed(GL_COMPRESSED_SIGNED_RG_RGTC2, -1, -1);
 		else
-		{
-			formatInfoOut->setFormat(GL_RG16F, GL_RG, GL_FLOAT);
-			formatInfoOut->markAsAlternativeFormat();
-			return;
-		}
+			formatInfoOut->setCompressed(GL_COMPRESSED_RG_RGTC2, -1, -1);
+		return;
 	}
 	else if (format == Latte::E_GX2SURFFMT::R32_FLOAT)
 	{
@@ -499,7 +440,7 @@ void LatteTextureGL::GetOpenGLFormatInfo(bool isDepth, Latte::E_GX2SURFFMT forma
 	}
 	else
 	{
-		forceLog_printf("OpenGL: Unsupported texture format 0x%04x", (uint32)format);
+		cemuLog_log(LogType::Force, "OpenGL: Unsupported texture format 0x{:04x}", (uint32)format);
 		cemu_assert_unimplemented();
 	}
 	formatInfoOut->glInternalFormat = glInternalFormat;
@@ -508,3 +449,49 @@ void LatteTextureGL::GetOpenGLFormatInfo(bool isDepth, Latte::E_GX2SURFFMT forma
 	formatInfoOut->glIsCompressed = glIsCompressed;
 	formatInfoOut->isUsingAlternativeFormat = isUsingAlternativeFormat;
 }
+
+void LatteTextureGL::AllocateOnHost()
+{
+	auto hostTexture = this;
+	cemu_assert_debug(hostTexture->isDataDefined == false);
+	sint32 effectiveBaseWidth = hostTexture->width;
+	sint32 effectiveBaseHeight = hostTexture->height;
+	sint32 effectiveBaseDepth = hostTexture->depth;
+	if (hostTexture->overwriteInfo.hasResolutionOverwrite)
+	{
+		effectiveBaseWidth = hostTexture->overwriteInfo.width;
+		effectiveBaseHeight = hostTexture->overwriteInfo.height;
+		effectiveBaseDepth = hostTexture->overwriteInfo.depth;
+	}
+	// calculate mip count
+	sint32 mipLevels = std::min(hostTexture->mipLevels, hostTexture->maxPossibleMipLevels);
+	mipLevels = std::max(mipLevels, 1);
+	// create immutable storage
+	if (hostTexture->dim == Latte::E_DIM::DIM_2D || hostTexture->dim == Latte::E_DIM::DIM_2D_MSAA)
+	{
+		cemu_assert_debug(effectiveBaseDepth == 1);
+		glTextureStorage2DWrapper(GL_TEXTURE_2D, hostTexture->glId_texture, mipLevels, hostTexture->glInternalFormat, effectiveBaseWidth, effectiveBaseHeight);
+	}
+	else if (hostTexture->dim == Latte::E_DIM::DIM_1D)
+	{
+		cemu_assert_debug(effectiveBaseHeight == 1);
+		cemu_assert_debug(effectiveBaseDepth == 1);
+		glTextureStorage1DWrapper(GL_TEXTURE_1D, hostTexture->glId_texture, mipLevels, hostTexture->glInternalFormat, effectiveBaseWidth);
+	}
+	else if (hostTexture->dim == Latte::E_DIM::DIM_2D_ARRAY || hostTexture->dim == Latte::E_DIM::DIM_2D_ARRAY_MSAA)
+	{
+		glTextureStorage3DWrapper(GL_TEXTURE_2D_ARRAY, hostTexture->glId_texture, mipLevels, hostTexture->glInternalFormat, effectiveBaseWidth, effectiveBaseHeight, std::max(1, effectiveBaseDepth));
+	}
+	else if (hostTexture->dim == Latte::E_DIM::DIM_3D)
+	{
+		glTextureStorage3DWrapper(GL_TEXTURE_3D, hostTexture->glId_texture, mipLevels, hostTexture->glInternalFormat, effectiveBaseWidth, effectiveBaseHeight, std::max(1, effectiveBaseDepth));
+	}
+	else if (hostTexture->dim == Latte::E_DIM::DIM_CUBEMAP)
+	{
+		glTextureStorage3DWrapper(GL_TEXTURE_CUBE_MAP_ARRAY, hostTexture->glId_texture, mipLevels, hostTexture->glInternalFormat, effectiveBaseWidth, effectiveBaseHeight, effectiveBaseDepth);
+	}
+	else
+	{
+		cemu_assert_unimplemented();
+	}
+}
\ No newline at end of file
diff --git a/src/Cafe/HW/Latte/Renderer/OpenGL/LatteTextureGL.h b/src/Cafe/HW/Latte/Renderer/OpenGL/LatteTextureGL.h
index fabd1bac..abfb0d43 100644
--- a/src/Cafe/HW/Latte/Renderer/OpenGL/LatteTextureGL.h
+++ b/src/Cafe/HW/Latte/Renderer/OpenGL/LatteTextureGL.h
@@ -6,14 +6,14 @@
 class LatteTextureGL : public LatteTexture
 {
 public:
-	LatteTextureGL(uint32 textureUnit, Latte::E_DIM dim, MPTR physAddress, MPTR physMipAddress, Latte::E_GX2SURFFMT format, uint32 width, uint32 height, uint32 depth, uint32 pitch, uint32 mipLevels,
+	LatteTextureGL(Latte::E_DIM dim, MPTR physAddress, MPTR physMipAddress, Latte::E_GX2SURFFMT format, uint32 width, uint32 height, uint32 depth, uint32 pitch, uint32 mipLevels,
 		uint32 swizzle, Latte::E_HWTILEMODE tileMode, bool isDepth);
 
 	~LatteTextureGL();
 
-	static void GenerateEmptyTextureFromGX2Dim(Latte::E_DIM dim, GLuint& texId, GLint& texTarget);
+	void AllocateOnHost() override;
 
-	void InitTextureState() override;
+	static void GenerateEmptyTextureFromGX2Dim(Latte::E_DIM dim, GLuint& texId, GLint& texTarget, bool createForTargetType);
 
 protected:
 	LatteTextureView* CreateView(Latte::E_DIM dim, Latte::E_GX2SURFFMT format, sint32 firstMip, sint32 mipCount, sint32 firstSlice, sint32 sliceCount) override;
@@ -25,7 +25,6 @@ public:
 		sint32 glSuppliedFormat;
 		sint32 glSuppliedFormatType;
 		bool glIsCompressed;
-		bool hasStencil{};
 		bool isUsingAlternativeFormat{};
 
 		void setFormat(sint32 glInternalFormat, sint32 glSuppliedFormat, sint32 glSuppliedFormatType)
@@ -36,15 +35,6 @@ public:
 			this->glIsCompressed = false;
 		}
 
-		void setDepthFormat(sint32 glInternalFormat, sint32 glSuppliedFormat, sint32 glSuppliedFormatType, bool hasStencil)
-		{
-			this->glInternalFormat = glInternalFormat;
-			this->glSuppliedFormat = glSuppliedFormat;
-			this->glSuppliedFormatType = glSuppliedFormatType;
-			this->glIsCompressed = false;
-			this->hasStencil = hasStencil;
-		}
-
 		void setCompressed(sint32 glInternalFormat, sint32 glSuppliedFormat, sint32 glSuppliedFormatType)
 		{
 			setFormat(glInternalFormat, glSuppliedFormat, glSuppliedFormatType);
diff --git a/src/Cafe/HW/Latte/Renderer/OpenGL/LatteTextureViewGL.cpp b/src/Cafe/HW/Latte/Renderer/OpenGL/LatteTextureViewGL.cpp
index fc5b5dc4..3e8abe8e 100644
--- a/src/Cafe/HW/Latte/Renderer/OpenGL/LatteTextureViewGL.cpp
+++ b/src/Cafe/HW/Latte/Renderer/OpenGL/LatteTextureViewGL.cpp
@@ -11,7 +11,7 @@ LatteTextureViewGL::LatteTextureViewGL(LatteTextureGL* texture, Latte::E_DIM dim
 		firstSlice != 0 || firstMip != 0 || mipCount != texture->mipLevels || sliceCount != texture->depth ||	
 		forceCreateNewTexId)
 	{
-		LatteTextureGL::GenerateEmptyTextureFromGX2Dim(dim, glTexId, glTexTarget);
+		LatteTextureGL::GenerateEmptyTextureFromGX2Dim(dim, glTexId, glTexTarget, false);
 		this->glInternalFormat = 0;
 		InitAliasView();
 	}
@@ -55,12 +55,16 @@ LatteTextureViewGL::~LatteTextureViewGL()
 void LatteTextureViewGL::InitAliasView()
 {
 	const auto texture = (LatteTextureGL*)baseTexture;
-	// get internal format
-	if (baseTexture->isDepth)
+	// compute internal format
+	if(texture->overwriteInfo.hasFormatOverwrite)
+	{
+		cemu_assert_debug(format == texture->format);
+		glInternalFormat = texture->glInternalFormat; // for format overwrite no aliasing is allowed and thus we always inherit the internal format of the base texture
+	}
+	else if (baseTexture->isDepth)
 	{
 		// depth is handled differently
-		forceLogDebug_printf("Creating depth view");
-		cemu_assert(format == texture->format); // todo
+		cemu_assert(format == texture->format); // is depth alias with different format intended?
 		glInternalFormat = texture->glInternalFormat;
 	}
 	else
@@ -73,7 +77,7 @@ void LatteTextureViewGL::InitAliasView()
 	catchOpenGLError();
 	if (firstMip >= texture->maxPossibleMipLevels)
 	{
-		forceLogDebug_printf("_createNewView: Out of bounds mip level requested");
+		cemuLog_logDebug(LogType::Force, "InitAliasView(): Out of bounds mip level requested");
 		glTextureView(glTexId, glTexTarget, texture->glId_texture, glInternalFormat, texture->maxPossibleMipLevels - 1, numMip, firstSlice, this->numSlice);
 	}
 	else
@@ -97,7 +101,7 @@ void LatteTextureViewGL::InitAliasView()
 
 	// set debug name
 	bool useGLDebugNames = false;
-#ifndef PUBLIC_RELEASE
+#ifdef CEMU_DEBUG_ASSERT
 	useGLDebugNames = true;
 #endif
 	if (LaunchSettings::NSightModeEnabled())
@@ -115,4 +119,4 @@ LatteTextureViewGL* LatteTextureViewGL::GetAlternativeView()
 	if (!m_alternativeView)
 		m_alternativeView = new LatteTextureViewGL((LatteTextureGL*)baseTexture, dim, format, firstMip, numMip, firstSlice, numSlice, false, true);
 	return m_alternativeView;
-}
\ No newline at end of file
+}
diff --git a/src/Cafe/HW/Latte/Renderer/OpenGL/OpenGLRenderer.cpp b/src/Cafe/HW/Latte/Renderer/OpenGL/OpenGLRenderer.cpp
index 269f30e8..bbf988bc 100644
--- a/src/Cafe/HW/Latte/Renderer/OpenGL/OpenGLRenderer.cpp
+++ b/src/Cafe/HW/Latte/Renderer/OpenGL/OpenGLRenderer.cpp
@@ -24,9 +24,14 @@
 #define STRINGIFY2(X) #X
 #define STRINGIFY(X) STRINGIFY2(X)
 
+namespace CemuGL
+{
 #define GLFUNC(__type, __name)	__type __name;
+#define EGLFUNC(__type, __name)	__type __name;
 #include "Common/GLInclude/glFunctions.h"
 #undef GLFUNC
+#undef EGLFUNC
+}
 
 #include "config/ActiveSettings.h"
 #include "config/LaunchSettings.h"
@@ -75,8 +80,6 @@ static const GLenum glAlphaTestFunc[] =
 	GL_ALWAYS
 };
 
-
-
 OpenGLRenderer::OpenGLRenderer()
 {
 	glRendererState.useTextureUploadBuffer = false;
@@ -87,7 +90,7 @@ OpenGLRenderer::OpenGLRenderer()
 		void* buffer = glMapNamedBufferRange(glRendererState.uploadBuffer, 0, TEXBUFFER_SIZE, GL_MAP_WRITE_BIT | GL_MAP_PERSISTENT_BIT | GL_MAP_UNSYNCHRONIZED_BIT | GL_MAP_FLUSH_EXPLICIT_BIT);
 		if (buffer == nullptr)
 		{
-			forceLog_printf("Failed to allocate GL texture upload buffer. Using traditional API instead");
+			cemuLog_log(LogType::Force, "Failed to allocate GL texture upload buffer. Using traditional API instead");
 			cemu_assert_debug(false);
 		}
 		glRendererState.uploadBufferPtr = buffer;
@@ -102,7 +105,7 @@ OpenGLRenderer::OpenGLRenderer()
 	}
 	catch (const std::exception& ex)
 	{
-		forceLog_printf("Unable to create dxgi wrapper: %s (VRAM overlay stat won't be available)", ex.what());
+		cemuLog_log(LogType::Force, "Unable to create dxgi wrapper: {} (VRAM overlay stat won't be available)", ex.what());
 	}
 #endif
 }
@@ -229,10 +232,29 @@ void LoadOpenGLImports()
 		_glXGetProcAddress = (PFNGLXGETPROCADDRESSPROC)dlsym(libGL, "glXGetProcAddressARB");
 	}
 
+	void* libEGL = dlopen("libEGL.so.1", RTLD_NOW | RTLD_GLOBAL);
+	if(!libEGL)
+	{
+		libGL = dlopen("libEGL.so", RTLD_NOW | RTLD_GLOBAL);
+	}
+
 #define GLFUNC(__type, __name)	__name = (__type)_GetOpenGLFunction(libGL, _glXGetProcAddress, STRINGIFY(__name));
+#define EGLFUNC(__type, __name)	__name = (__type)dlsym(libEGL, STRINGIFY(__name));
 #include "Common/GLInclude/glFunctions.h"
 #undef GLFUNC
+#undef EGLFUNC
 }
+
+#if BOOST_OS_LINUX
+// dummy function for all code that is statically linked with cemu and attempts to use eglSwapInterval
+// used to suppress wxWidgets calls to eglSwapInterval
+extern "C"
+EGLAPI EGLBoolean EGLAPIENTRY eglSwapInterval(EGLDisplay dpy, EGLint interval)
+{
+	return EGL_TRUE;
+}
+#endif
+
 #elif BOOST_OS_MACOS
 void LoadOpenGLImports()
 {
@@ -242,8 +264,9 @@ void LoadOpenGLImports()
 
 void OpenGLRenderer::Initialize()
 {
-	auto lock = cafeLog_acquire();
-	forceLog_printf("------- Init OpenGL graphics backend -------");
+	Renderer::Initialize();
+	auto lock = cemuLog_acquire();
+	cemuLog_log(LogType::Force, "------- Init OpenGL graphics backend -------");
 
 	GLCanvas_MakeCurrent(false);
 	LoadOpenGLImports();
@@ -257,16 +280,12 @@ void OpenGLRenderer::Initialize()
 	if (glMaxShaderCompilerThreadsARB)
 		glMaxShaderCompilerThreadsARB(0xFFFFFFFF);
 
-	forceLog_printf("OpenGL extensions:");
-	forceLog_printf("ARB_clip_control: %s", glClipControl ? "available" : "not supported");
-	forceLog_printf("ARB_get_program_binary: %s", (glGetProgramBinary != NULL && glProgramBinary != NULL) ? "available" : "not supported");
-	forceLog_printf("ARB_clear_texture: %s", (glClearTexImage != NULL) ? "available" : "not supported");
-	forceLog_printf("ARB_copy_image: %s", (glCopyImageSubData != NULL) ? "available" : "not supported");
-	forceLog_printf("NV_depth_buffer_float: %s", (glDepthRangedNV != NULL) ? "available" : "not supported");
-
-	// generate default frame buffer
-	glGenFramebuffers(1, &m_defaultFramebufferId);
-	catchOpenGLError();
+	cemuLog_log(LogType::Force, "OpenGL extensions:");
+	cemuLog_log(LogType::Force, "ARB_clip_control: {}", glClipControl ? "available" : "not supported");
+	cemuLog_log(LogType::Force, "ARB_get_program_binary: {}", (glGetProgramBinary != NULL && glProgramBinary != NULL) ? "available" : "not supported");
+	cemuLog_log(LogType::Force, "ARB_clear_texture: {}", (glClearTexImage != NULL) ? "available" : "not supported");
+	cemuLog_log(LogType::Force, "ARB_copy_image: {}", (glCopyImageSubData != NULL) ? "available" : "not supported");
+	cemuLog_log(LogType::Force, "NV_depth_buffer_float: {}", (glDepthRangedNV != NULL) ? "available" : "not supported");
 
 	// enable framebuffer SRGB support
 	glEnable(GL_FRAMEBUFFER_SRGB);
@@ -311,13 +330,14 @@ void OpenGLRenderer::Initialize()
 	lock.unlock();
 
 	// create framebuffer for fast clearing (avoid glClearTexSubImage on Nvidia)
-	if (this->m_vendor == GfxVendor::Nvidia || glClearTexSubImage == nullptr)
+	if (glCreateFramebuffers)
+		glCreateFramebuffers(1, &glRendererState.clearFBO);
+	else
 	{
-		// generate framebuffer
-		if (glCreateFramebuffers && false)
-			glCreateFramebuffers(1, &glRendererState.clearFBO);
-		else
-			glGenFramebuffers(1, &glRendererState.clearFBO);
+		glGenFramebuffers(1, &glRendererState.clearFBO);
+		// bind to initialize
+		glBindFramebuffer(GL_FRAMEBUFFER_EXT, glRendererState.clearFBO);
+		glBindFramebuffer(GL_FRAMEBUFFER_EXT, 0);
 	}
 
 	draw_init();
@@ -352,18 +372,6 @@ void OpenGLRenderer::NotifyLatteCommandProcessorIdle()
 	glFlush();
 }
 
-void OpenGLRenderer::EnableVSync(int state)
-{
-#if BOOST_OS_WINDOWS
-	if(wglSwapIntervalEXT)
-		wglSwapIntervalEXT(state); // 1 = enabled, 0 = disabled
-#else
-	cemuLog_log(LogType::Force, "OpenGL vsync not implemented");
-#endif
-}
-
-bool IsRunningInWine();
-
 void OpenGLRenderer::GetVendorInformation()
 {
 	// example vendor strings:
@@ -374,11 +382,11 @@ void OpenGLRenderer::GetVendorInformation()
 	char* glRendererString = (char*)glGetString(GL_RENDERER);
 	char* glVersionString = (char*)glGetString(GL_VERSION);
 
-	forceLog_printf("GL_VENDOR: %s", glVendorString ? glVendorString : "unknown");
-	forceLog_printf("GL_RENDERER: %s", glRendererString ? glRendererString : "unknown");
-	forceLog_printf("GL_VERSION: %s", glVersionString ? glVersionString : "unknown");
+	cemuLog_log(LogType::Force, "GL_VENDOR: {}", glVendorString ? glVendorString : "unknown");
+	cemuLog_log(LogType::Force, "GL_RENDERER: {}", glRendererString ? glRendererString : "unknown");
+	cemuLog_log(LogType::Force, "GL_VERSION: {}", glVersionString ? glVersionString : "unknown");
 
-	if(boost::icontains(glVersionString, "Mesa"))
+	if(glVersionString && boost::icontains(glVersionString, "Mesa"))
 	{
 		m_vendor = GfxVendor::Mesa;
 		return;
@@ -399,10 +407,7 @@ void OpenGLRenderer::GetVendorInformation()
 		}
 		else if (memcmp(glVendorString, "Intel", 5) == 0)
 		{
-			if (LaunchSettings::ForceIntelLegacyEnabled())
-				m_vendor = GfxVendor::IntelLegacy;
-			else
-				m_vendor = GfxVendor::IntelNoLegacy;
+			m_vendor = GfxVendor::Intel;
 			return;
 		}
 	}
@@ -418,11 +423,14 @@ void _glDebugCallback(GLenum source, GLenum type, GLuint id, GLenum severity, GL
 		return;
 	if (LatteGPUState.glVendor == GLVENDOR_NVIDIA && strstr(message, "Dithering is enabled"))
 		return;
-
+	if (LatteGPUState.glVendor == GLVENDOR_NVIDIA && strstr(message, "Blending is enabled, but is not supported for integer framebuffers"))
+		return;
 	if (LatteGPUState.glVendor == GLVENDOR_NVIDIA && strstr(message, "does not have a defined base level"))
 		return;
+	if(LatteGPUState.glVendor == GLVENDOR_NVIDIA && strstr(message, "has depth comparisons disabled, with a texture object"))
+		return;
 
-	forceLog_printf("GLDEBUG: %s", message);
+	cemuLog_log(LogType::Force, "GLDEBUG: {}", message);
 
 	cemu_assert_debug(false);
 }
@@ -548,37 +556,37 @@ void OpenGLRenderer::DrawBackbufferQuad(LatteTextureView* texView, RendererOutpu
 	renderstate_resetDepthControl();
 	attributeStream_reset();
 
+	// bind back buffer
+	rendertarget_bindFramebufferObject(nullptr);
+
 	if (clearBackground)
 	{
 		int windowWidth, windowHeight;
 		if (padView)
-			gui_getPadWindowSize(&windowWidth, &windowHeight);
+			gui_getPadWindowPhysSize(windowWidth, windowHeight);
 		else
-			gui_getWindowSize(&windowWidth, &windowHeight);
+			gui_getWindowPhysSize(windowWidth, windowHeight);
 		g_renderer->renderTarget_setViewport(0, 0, windowWidth, windowHeight, 0.0f, 1.0f);
 		g_renderer->ClearColorbuffer(padView);
 	}
 
-	// bind back buffer
-	rendertarget_bindFramebufferObject(nullptr);
-
-	// calculate effective size
-	sint32 effectiveWidth;
-	sint32 effectiveHeight;
-	LatteTexture_getEffectiveSize(texView->baseTexture, &effectiveWidth, &effectiveHeight, nullptr, 0);
-
-	g_renderer->shader_unbind(RendererShader::ShaderType::kVertex);
-	g_renderer->shader_unbind(RendererShader::ShaderType::kGeometry);
-	g_renderer->shader_unbind(RendererShader::ShaderType::kFragment);
-	shader->Bind();
-	shader->SetUniformParameters(*texView, { effectiveWidth, effectiveHeight }, { imageWidth, imageHeight });
+	shader_unbind(RendererShader::ShaderType::kGeometry);
+	shader_bind(shader->GetVertexShader());
+	shader_bind(shader->GetFragmentShader());
+	shader->SetUniformParameters(*texView, {imageWidth, imageHeight});
 
 	// set viewport
 	glViewportIndexedf(0, imageX, imageY, imageWidth, imageHeight);
 
 	LatteTextureViewGL* texViewGL = (LatteTextureViewGL*)texView;
-	g_renderer->texture_bindAndActivate(texView, 0);
+	texture_bindAndActivate(texView, 0);
 
+	glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_S, GL_CLAMP_TO_EDGE);
+	glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_T, GL_CLAMP_TO_EDGE);
+	texViewGL->samplerState.clampS = texViewGL->samplerState.clampT = 0xFF;
+
+	glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, useLinearTexFilter ? GL_LINEAR : GL_NEAREST);
+	texViewGL->samplerState.filterMin = 0xFFFFFFFF;
 	glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, useLinearTexFilter ? GL_LINEAR : GL_NEAREST);
 	texViewGL->samplerState.filterMag = 0xFFFFFFFF;
 
@@ -592,7 +600,7 @@ void OpenGLRenderer::DrawBackbufferQuad(LatteTextureView* texView, RendererOutpu
 		glEnable(GL_FRAMEBUFFER_SRGB);
 
 	// unbind texture
-	g_renderer->texture_bindAndActivate(nullptr, 0);
+	texture_bindAndActivate(nullptr, 0);
 
 	catchOpenGLError();
 
@@ -666,7 +674,10 @@ void OpenGLRenderer::rendertarget_deleteCachedFBO(LatteCachedFBO* cfbo)
 {
 	auto cfboGL = (CachedFBOGL*)cfbo;
 	if (prevBoundFBO == cfboGL->glId_fbo)
-		prevBoundFBO = -1;
+	{
+		glBindFramebuffer(GL_FRAMEBUFFER_EXT, 0);
+		prevBoundFBO = 0;
+	}
 	glDeleteFramebuffers(1, &cfboGL->glId_fbo);
 }
 
@@ -838,47 +849,8 @@ TextureDecoder* OpenGLRenderer::texture_chooseDecodedFormat(Latte::E_GX2SURFFMT
 		}
 		return nullptr;
 	}
-
-	if (LatteGPUState.glVendor == GLVENDOR_INTEL_LEGACY)
-	{
-		if (format == Latte::E_GX2SURFFMT::BC1_UNORM)
-		{
-			texDecoder = TextureDecoder_BC1_UNORM_uncompress::getInstance();
-		}
-		else if (format == Latte::E_GX2SURFFMT::BC1_SRGB)
-		{
-			texDecoder = TextureDecoder_BC1_SRGB_uncompress::getInstance();
-		}
-		else if (format == Latte::E_GX2SURFFMT::BC3_UNORM)
-		{
-			texDecoder = TextureDecoder_BC3_UNORM_uncompress::getInstance();
-		}
-		else if (format == Latte::E_GX2SURFFMT::BC3_SRGB)
-		{
-			texDecoder = TextureDecoder_BC3_SRGB_uncompress::getInstance();
-		}
-		else if (format == Latte::E_GX2SURFFMT::BC4_UNORM)
-		{
-			texDecoder = TextureDecoder_BC4_UNORM_uncompress::getInstance();
-		}
-		else if (format == Latte::E_GX2SURFFMT::BC4_SNORM)
-		{
-			cemu_assert_debug(false); // todo
-		}
-		else if (format == Latte::E_GX2SURFFMT::BC5_UNORM)
-		{
-			texDecoder = TextureDecoder_BC5_UNORM_uncompress::getInstance();
-		}
-		else if (format == Latte::E_GX2SURFFMT::BC5_SNORM)
-		{
-			texDecoder = TextureDecoder_BC5_SNORM_uncompress::getInstance();
-		}
-		if (texDecoder)
-			return texDecoder;
-	}
-	
 	if (format == Latte::E_GX2SURFFMT::R4_G4_UNORM)
-		texDecoder = TextureDecoder_R4_G4_UNORM_toRGBA4444::getInstance();
+		texDecoder = TextureDecoder_R4_G4_UNORM_To_RGBA4::getInstance();
 	else if (format == Latte::E_GX2SURFFMT::R4_G4_B4_A4_UNORM)
 		texDecoder = TextureDecoder_R4_G4_B4_A4_UNORM::getInstance();
 	else if (format == Latte::E_GX2SURFFMT::R16_G16_B16_A16_FLOAT)
@@ -964,9 +936,9 @@ TextureDecoder* OpenGLRenderer::texture_chooseDecodedFormat(Latte::E_GX2SURFFMT
 	else if (format == Latte::E_GX2SURFFMT::R10_G10_B10_A2_UNORM)
 		texDecoder = TextureDecoder_R10_G10_B10_A2_UNORM::getInstance();
 	else if (format == Latte::E_GX2SURFFMT::A2_B10_G10_R10_UNORM)
-		texDecoder = TextureDecoder_A2_B10_G10_R10_UNORM_toRGBA16::getInstance();
+		texDecoder = TextureDecoder_A2_B10_G10_R10_UNORM_To_RGBA16::getInstance();
 	else if (format == Latte::E_GX2SURFFMT::R10_G10_B10_A2_SNORM)
-		texDecoder = TextureDecoder_R10_G10_B10_A2_SNORM_toRGBA16::getInstance();
+		texDecoder = TextureDecoder_R10_G10_B10_A2_SNORM_To_RGBA16::getInstance();
 	else if (format == Latte::E_GX2SURFFMT::R10_G10_B10_A2_SRGB)
 		texDecoder = TextureDecoder_R10_G10_B10_A2_UNORM::getInstance();
 	else if (format == Latte::E_GX2SURFFMT::R11_G11_B10_FLOAT)
@@ -991,64 +963,10 @@ TextureDecoder* OpenGLRenderer::texture_chooseDecodedFormat(Latte::E_GX2SURFFMT
 	return texDecoder;
 }
 
-void OpenGLRenderer::texture_destroy(LatteTexture* hostTexture)
-{
-	delete hostTexture;
-}
-
-void OpenGLRenderer::texture_reserveTextureOnGPU(LatteTexture* hostTexture)
-{
-	cemu_assert_debug(hostTexture->isDataDefined == false);
-	sint32 effectiveBaseWidth = hostTexture->width;
-	sint32 effectiveBaseHeight = hostTexture->height;
-	sint32 effectiveBaseDepth = hostTexture->depth;
-	if (hostTexture->overwriteInfo.hasResolutionOverwrite)
-	{
-		effectiveBaseWidth = hostTexture->overwriteInfo.width;
-		effectiveBaseHeight = hostTexture->overwriteInfo.height;
-		effectiveBaseDepth = hostTexture->overwriteInfo.depth;
-	}
-	// get format info
-	LatteTextureGL::FormatInfoGL glFormatInfo;
-	LatteTextureGL::GetOpenGLFormatInfo(hostTexture->isDepth, hostTexture->overwriteInfo.hasFormatOverwrite ? (Latte::E_GX2SURFFMT)hostTexture->overwriteInfo.format : hostTexture->format, hostTexture->dim, &glFormatInfo);
-	// calculate mip count
-	sint32 mipLevels = std::min(hostTexture->mipLevels, hostTexture->maxPossibleMipLevels);
-	mipLevels = std::max(mipLevels, 1);
-	// create immutable storage
-	if (hostTexture->dim == Latte::E_DIM::DIM_2D || hostTexture->dim == Latte::E_DIM::DIM_2D_MSAA)
-	{
-		cemu_assert_debug(effectiveBaseDepth == 1);
-		glTexStorage2D(GL_TEXTURE_2D, mipLevels, glFormatInfo.glInternalFormat, effectiveBaseWidth, effectiveBaseHeight);
-	}
-	else if (hostTexture->dim == Latte::E_DIM::DIM_1D)
-	{
-		cemu_assert_debug(effectiveBaseHeight == 1);
-		cemu_assert_debug(effectiveBaseDepth == 1);
-		glTexStorage1D(GL_TEXTURE_1D, mipLevels, glFormatInfo.glInternalFormat, effectiveBaseWidth);
-	}
-	else if (hostTexture->dim == Latte::E_DIM::DIM_2D_ARRAY || hostTexture->dim == Latte::E_DIM::DIM_2D_ARRAY_MSAA)
-	{
-		glTexStorage3D(GL_TEXTURE_2D_ARRAY, mipLevels, glFormatInfo.glInternalFormat, effectiveBaseWidth, effectiveBaseHeight, std::max(1, effectiveBaseDepth));
-	}
-	else if (hostTexture->dim == Latte::E_DIM::DIM_3D)
-	{
-		glTexStorage3D(GL_TEXTURE_3D, mipLevels, glFormatInfo.glInternalFormat, effectiveBaseWidth, effectiveBaseHeight, std::max(1, effectiveBaseDepth));
-	}
-	else if (hostTexture->dim == Latte::E_DIM::DIM_CUBEMAP)
-	{
-		glTexStorage3D(GL_TEXTURE_CUBE_MAP_ARRAY, mipLevels, glFormatInfo.glInternalFormat, effectiveBaseWidth, effectiveBaseHeight, effectiveBaseDepth);
-	}
-	else
-	{
-		cemu_assert_unimplemented();
-	}
-}
-
 // use standard API to upload texture data
 void OpenGLRenderer_texture_loadSlice_normal(LatteTexture* hostTextureGeneric, sint32 width, sint32 height, sint32 depth, void* pixelData, sint32 sliceIndex, sint32 mipIndex, uint32 imageSize)
 {
 	auto hostTexture = (LatteTextureGL*)hostTextureGeneric;
-
 	sint32 effectiveWidth = width;
 	sint32 effectiveHeight = height;
 	sint32 effectiveDepth = depth;
@@ -1059,58 +977,37 @@ void OpenGLRenderer_texture_loadSlice_normal(LatteTexture* hostTextureGeneric, s
 	LatteTextureGL::GetOpenGLFormatInfo(hostTexture->isDepth, hostTexture->overwriteInfo.hasFormatOverwrite ? (Latte::E_GX2SURFFMT)hostTexture->overwriteInfo.format : hostTexture->format, hostTexture->dim, &glFormatInfo);
 	// upload slice
 	catchOpenGLError();
+	if (mipIndex >= hostTexture->maxPossibleMipLevels)
+	{
+		cemuLog_logDebug(LogType::Force, "2D texture mip level allocated out of range");
+		return;
+	}
 	if (hostTexture->dim == Latte::E_DIM::DIM_2D || hostTexture->dim == Latte::E_DIM::DIM_2D_MSAA)
 	{
 		if (glFormatInfo.glIsCompressed)
-		{
-			if (glCompressedTextureSubImage2D)
-				glCompressedTextureSubImage2D(hostTexture->glId_texture, mipIndex, 0, 0, effectiveWidth, effectiveHeight, glFormatInfo.glInternalFormat, imageSize, pixelData);
-			else
-				glCompressedTexSubImage2D(GL_TEXTURE_2D, mipIndex, 0, 0, effectiveWidth, effectiveHeight, glFormatInfo.glInternalFormat, imageSize, pixelData);
-		}
+			glCompressedTextureSubImage2DWrapper(hostTexture->glTexTarget, hostTexture->glId_texture, mipIndex, 0, 0, effectiveWidth, effectiveHeight, glFormatInfo.glInternalFormat, imageSize, pixelData);
 		else
-		{
-			if (mipIndex < hostTexture->maxPossibleMipLevels)
-				glTexSubImage2D(GL_TEXTURE_2D, mipIndex, 0, 0, effectiveWidth, effectiveHeight, glFormatInfo.glSuppliedFormat, glFormatInfo.glSuppliedFormatType, pixelData);
-			else
-				forceLogDebug_printf("2D texture mip level allocated out of range");
-		}
+			glTextureSubImage2DWrapper(hostTexture->glTexTarget, hostTexture->glId_texture, mipIndex, 0, 0, effectiveWidth, effectiveHeight, glFormatInfo.glSuppliedFormat, glFormatInfo.glSuppliedFormatType, pixelData);
 	}
 	else if (hostTexture->dim == Latte::E_DIM::DIM_1D)
 	{
-		if (glFormatInfo.glIsCompressed == true)
-			cemu_assert_unimplemented();
-		glTexSubImage1D(GL_TEXTURE_1D, mipIndex, 0, width, glFormatInfo.glSuppliedFormat, glFormatInfo.glSuppliedFormatType, pixelData);
+		if (glFormatInfo.glIsCompressed)
+			glCompressedTextureSubImage1DWrapper(hostTexture->glTexTarget, hostTexture->glId_texture, mipIndex, 0, width, glFormatInfo.glInternalFormat, imageSize, pixelData);
+		else
+			glTextureSubImage1DWrapper(hostTexture->glTexTarget, hostTexture->glId_texture, mipIndex, 0, width, glFormatInfo.glSuppliedFormat, glFormatInfo.glSuppliedFormatType, pixelData);
 	}
-	else if (hostTexture->dim == Latte::E_DIM::DIM_2D_ARRAY || hostTexture->dim == Latte::E_DIM::DIM_2D_ARRAY_MSAA)
+	else if (hostTexture->dim == Latte::E_DIM::DIM_2D_ARRAY || hostTexture->dim == Latte::E_DIM::DIM_2D_ARRAY_MSAA ||
+			 hostTexture->dim == Latte::E_DIM::DIM_3D ||
+			 hostTexture->dim == Latte::E_DIM::DIM_CUBEMAP)
 	{
 		if (glFormatInfo.glIsCompressed)
-			glCompressedTexSubImage3D(GL_TEXTURE_2D_ARRAY, mipIndex, 0, 0, sliceIndex, effectiveWidth, effectiveHeight, 1, glFormatInfo.glInternalFormat, imageSize, pixelData);
+			glCompressedTextureSubImage3DWrapper(hostTexture->glTexTarget, hostTexture->glId_texture, mipIndex, 0, 0, sliceIndex, effectiveWidth, effectiveHeight, 1, glFormatInfo.glInternalFormat, imageSize, pixelData);
 		else
-			glTexSubImage3D(GL_TEXTURE_2D_ARRAY, mipIndex, 0, 0, sliceIndex, effectiveWidth, effectiveHeight, 1, glFormatInfo.glSuppliedFormat, glFormatInfo.glSuppliedFormatType, pixelData);
-	}
-	else if (hostTexture->dim == Latte::E_DIM::DIM_3D)
-	{
-		if (glFormatInfo.glIsCompressed)
-			glCompressedTexSubImage3D(GL_TEXTURE_3D, mipIndex, 0, 0, sliceIndex, effectiveWidth, effectiveHeight, 1, glFormatInfo.glInternalFormat, imageSize, pixelData);
-		else
-			glTexSubImage3D(GL_TEXTURE_3D, mipIndex, 0, 0, sliceIndex, effectiveWidth, effectiveHeight, 1, glFormatInfo.glSuppliedFormat, glFormatInfo.glSuppliedFormatType, pixelData);
-	}
-	else if (hostTexture->dim == Latte::E_DIM::DIM_CUBEMAP)
-	{
-		if (glFormatInfo.glIsCompressed)
-			glCompressedTexSubImage3D(GL_TEXTURE_CUBE_MAP_ARRAY, mipIndex, 0, 0, sliceIndex, width, height, 1, glFormatInfo.glInternalFormat, imageSize, pixelData);
-		else
-			glTexSubImage3D(GL_TEXTURE_CUBE_MAP_ARRAY, mipIndex, 0, 0, sliceIndex, width, height, 1, glFormatInfo.glSuppliedFormat, glFormatInfo.glSuppliedFormatType, pixelData);
-	}
-	else
-	{
-		cemu_assert_debug(false);
+			glTextureSubImage3DWrapper(hostTexture->glTexTarget, hostTexture->glId_texture, mipIndex, 0, 0, sliceIndex, effectiveWidth, effectiveHeight, 1, glFormatInfo.glSuppliedFormat, glFormatInfo.glSuppliedFormatType, pixelData);
 	}
 	catchOpenGLError();
 }
 
-
 // use persistent buffers to upload data
 void OpenGLRenderer_texture_loadSlice_viaBuffers(LatteTexture* hostTexture, sint32 width, sint32 height, sint32 depth, void* pixelData, sint32 sliceIndex, sint32 mipIndex, uint32 imageSize)
 {
@@ -1142,8 +1039,8 @@ void OpenGLRenderer::texture_clearColorSlice(LatteTexture* hostTexture, sint32 s
 	LatteTextureGL* texGL = (LatteTextureGL*)hostTexture;
 	cemu_assert_debug(!texGL->isDepth);
 
-	sint32 eWidth, eHeight, eDepth;
-	LatteTexture_getEffectiveSize(hostTexture, &eWidth, &eHeight, &eDepth, mipIndex);
+	sint32 eWidth, eHeight;
+	hostTexture->GetEffectiveSize(eWidth, eHeight, mipIndex);
 	renderstate_resetColorControl();
 	renderTarget_setViewport(0, 0, eWidth, eHeight, 0.0f, 1.0f);
 	LatteMRT::BindColorBufferOnly(hostTexture->GetOrCreateView(mipIndex, 1, sliceIndex, 1));
@@ -1156,8 +1053,8 @@ void OpenGLRenderer::texture_clearDepthSlice(LatteTexture* hostTexture, uint32 s
 	LatteTextureGL* texGL = (LatteTextureGL*)hostTexture;
 	cemu_assert_debug(texGL->isDepth);
 
-	sint32 eWidth, eHeight, eDepth;
-	LatteTexture_getEffectiveSize(hostTexture, &eWidth, &eHeight, &eDepth, mipIndex);
+	sint32 eWidth, eHeight;
+	hostTexture->GetEffectiveSize(eWidth, eHeight, mipIndex);
 	renderstate_resetColorControl();
 	renderstate_resetDepthControl();
 	renderTarget_setViewport(0, 0, eWidth, eHeight, 0.0f, 1.0f);
@@ -1185,13 +1082,12 @@ void OpenGLRenderer::texture_clearSlice(LatteTexture* hostTextureGeneric, sint32
 	LatteTextureGL::FormatInfoGL formatInfoGL;
 	LatteTextureGL::GetOpenGLFormatInfo(hostTexture->isDepth, hostTexture->format, hostTexture->dim, &formatInfoGL);
 	// get effective size of mip
-	sint32 effectiveWidth;
-	sint32 effectiveHeight;
-	LatteTexture_getEffectiveSize(hostTexture, &effectiveWidth, &effectiveHeight, nullptr, mipIndex);
+	sint32 effectiveWidth, effectiveHeight;
+	hostTexture->GetEffectiveSize(effectiveWidth, effectiveHeight, mipIndex);
 
 	// on Nvidia glClearTexImage and glClearTexSubImage has bad performance (clearing a 4K texture takes up to 50ms)
 	// clearing with glTextureSubImage2D from a CPU RAM buffer is only slightly slower
-	// clearing with glTextureSubImage2D from a OpenGL buffer is 10-20% faster than glClearTexImage)
+	// clearing with glTextureSubImage2D from a OpenGL buffer is 10-20% faster than glClearTexImage
 	// clearing with FBO and glClear is orders of magnitude faster than the other methods
 	// (these are results from 2018, may be different now)
 
@@ -1199,12 +1095,12 @@ void OpenGLRenderer::texture_clearSlice(LatteTexture* hostTextureGeneric, sint32
 	{
 		if (formatInfoGL.glIsCompressed)
 		{
-			forceLogDebug_printf("Unsupported clear for compressed texture");
+			cemuLog_logDebug(LogType::Force, "Unsupported clear for compressed texture");
 			return; // todo - create integer texture view to clear compressed textures
 		}
 		if (hostTextureGeneric->isDepth)
 		{
-			forceLogDebug_printf("Unsupported clear for depth texture");
+			cemuLog_logDebug(LogType::Force, "Unsupported clear for depth texture");
 			return; // todo - use depth clear
 		}
 
@@ -1222,15 +1118,13 @@ void OpenGLRenderer::texture_clearSlice(LatteTexture* hostTextureGeneric, sint32
 	}
 	if (glClearTexSubImage == nullptr)
 		return;
-	// clear
 	glClearTexSubImage(hostTexture->glId_texture, mipIndex, 0, 0, sliceIndex, effectiveWidth, effectiveHeight, 1, formatInfoGL.glSuppliedFormat, formatInfoGL.glSuppliedFormatType, NULL);
 }
 
-LatteTexture* OpenGLRenderer::texture_createTextureEx(uint32 textureUnit, Latte::E_DIM dim, MPTR physAddress, MPTR physMipAddress, Latte::E_GX2SURFFMT format, uint32 width, uint32 height, uint32 depth, uint32 pitch, uint32 mipLevels,
+LatteTexture* OpenGLRenderer::texture_createTextureEx(Latte::E_DIM dim, MPTR physAddress, MPTR physMipAddress, Latte::E_GX2SURFFMT format, uint32 width, uint32 height, uint32 depth, uint32 pitch, uint32 mipLevels,
 	uint32 swizzle, Latte::E_HWTILEMODE tileMode, bool isDepth)
 {
-	return new LatteTextureGL(textureUnit, dim, physAddress, physMipAddress, format, width, height, depth, pitch, mipLevels, swizzle, tileMode, isDepth);
-	
+	return new LatteTextureGL(dim, physAddress, physMipAddress, format, width, height, depth, pitch, mipLevels, swizzle, tileMode, isDepth);
 }
 
 void OpenGLRenderer::texture_setActiveTextureUnit(sint32 index)
@@ -1245,42 +1139,18 @@ void OpenGLRenderer::texture_setActiveTextureUnit(sint32 index)
 void OpenGLRenderer::texture_bindAndActivate(LatteTextureView* textureView, uint32 textureUnit)
 {
 	const auto textureViewGL = (LatteTextureViewGL*)textureView;
-	cemu_assert_debug(textureUnit < (sizeof(LatteBoundTexturesBackup) / sizeof(LatteBoundTexturesBackup[0])));
 	// don't call glBindTexture if the texture is already bound
-	if (LatteBoundTextures[textureUnit] == textureViewGL)
+	if (m_latteBoundTextures[textureUnit] == textureViewGL)
 	{
 		texture_setActiveTextureUnit(textureUnit);
 		return; // already bound
 	}
 	// bind
-	LatteBoundTextures[textureUnit] = textureViewGL;
+	m_latteBoundTextures[textureUnit] = textureViewGL;
 	texture_setActiveTextureUnit(textureUnit);
 	if (textureViewGL)
 	{
 		glBindTexture(textureViewGL->glTexTarget, textureViewGL->glTexId);
-		texUnitTexId[textureUnit] = textureViewGL->glTexId;
-		texUnitTexTarget[textureUnit] = textureViewGL->glTexTarget;
-	}
-}
-
-void OpenGLRenderer::texture_bindAndActivateRawTex(LatteTexture* texture, uint32 textureUnit)
-{
-	cemu_assert_debug(textureUnit < (sizeof(LatteBoundTexturesBackup) / sizeof(LatteBoundTexturesBackup[0])));
-	// don't call glBindTexture if the texture is already bound
-	if (LatteBoundTextures[textureUnit] == texture)
-	{
-		texture_setActiveTextureUnit(textureUnit);
-		return; // already bound
-	}
-	// bind
-	LatteBoundTextures[textureUnit] = texture;
-	texture_setActiveTextureUnit(textureUnit);
-	if (texture)
-	{
-		auto textureGL = (LatteTextureGL*)texture;
-		glBindTexture(textureGL->glTexTarget, textureGL->glId_texture);
-		texUnitTexId[textureUnit] = textureGL->glId_texture;
-		texUnitTexTarget[textureUnit] = textureGL->glTexTarget;
 	}
 }
 
@@ -1288,18 +1158,18 @@ void OpenGLRenderer::texture_notifyDelete(LatteTextureView* textureView)
 {
 	for (uint32 i = 0; i < Latte::GPU_LIMITS::NUM_TEXTURES_PER_STAGE * 3; i++)
 	{
-		if (LatteBoundTextures[i] == textureView)
-			LatteBoundTextures[i] = nullptr;
+		if (m_latteBoundTextures[i] == textureView)
+			m_latteBoundTextures[i] = nullptr;
 	}
 }
 
-// similar to _bindAndActivate() but doesn't call _setActiveTextureUnit() if texture is already bound
-void OpenGLRenderer::texture_bindOnly(LatteTextureView* textureView1, uint32 textureUnit)
+// set Latte texture, on the OpenGL renderer this behaves like _bindAndActivate() but doesn't call _setActiveTextureUnit() if the texture is already bound
+void OpenGLRenderer::texture_setLatteTexture(LatteTextureView* textureView1, uint32 textureUnit)
 {
 	auto textureView = ((LatteTextureViewGL*)textureView1);
 
 	cemu_assert_debug(textureUnit < Latte::GPU_LIMITS::NUM_TEXTURES_PER_STAGE * 3);
-	if (LatteBoundTextures[textureUnit] == textureView)
+	if (m_latteBoundTextures[textureUnit] == textureView)
 		return;
 	if (textureView == nullptr)
 		return;
@@ -1307,51 +1177,22 @@ void OpenGLRenderer::texture_bindOnly(LatteTextureView* textureView1, uint32 tex
 	if (glBindTextureUnit)
 	{
 		glBindTextureUnit(textureUnit, textureView->glTexId);
-		LatteBoundTextures[textureUnit] = textureView;
-		texUnitTexId[textureUnit] = textureView->glTexId;
-		texUnitTexTarget[textureUnit] = textureView->glTexTarget;
+		m_latteBoundTextures[textureUnit] = textureView;
 		activeTextureUnit = -1;
 	}
 	else
 	{
 		texture_setActiveTextureUnit(textureUnit);
 		glBindTexture(textureView->glTexTarget, textureView->glTexId);
-		LatteBoundTextures[textureUnit] = textureView;
-		texUnitTexId[textureUnit] = textureView->glTexId;
-		texUnitTexTarget[textureUnit] = textureView->glTexTarget;
+		m_latteBoundTextures[textureUnit] = textureView;
 	}
 }
 
-void OpenGLRenderer::texture_rememberBoundTexture(uint32 textureUnit)
-{
-	cemu_assert_debug(texUnitBackupSlotUsed[textureUnit] == false);
-	texUnitBackupSlotUsed[textureUnit] = true;
-	LatteBoundTexturesBackup[textureUnit] = LatteBoundTextures[textureUnit];
-	texUnitTexIdBackup[textureUnit] = texUnitTexId[textureUnit];
-	texUnitTexTargetBackup[textureUnit] = texUnitTexTarget[textureUnit];
-}
-
-void OpenGLRenderer::texture_restoreBoundTexture(uint32 textureUnit)
-{
-	cemu_assert_debug(texUnitBackupSlotUsed[textureUnit] == true);
-	texUnitBackupSlotUsed[textureUnit] = false;
-	if (LatteBoundTextures[textureUnit] == LatteBoundTexturesBackup[textureUnit])
-	{
-		return; // already bound
-	}
-	LatteBoundTextures[textureUnit] = LatteBoundTexturesBackup[textureUnit];
-	texUnitTexId[textureUnit] = texUnitTexIdBackup[textureUnit];
-	texUnitTexTarget[textureUnit] = texUnitTexTargetBackup[textureUnit];
-	texture_setActiveTextureUnit(textureUnit);
-	glBindTexture(texUnitTexTargetBackup[textureUnit], texUnitTexIdBackup[textureUnit]);
-}
-
 void OpenGLRenderer::texture_copyImageSubData(LatteTexture* src, sint32 srcMip, sint32 effectiveSrcX, sint32 effectiveSrcY, sint32 srcSlice, LatteTexture* dst, sint32 dstMip, sint32 effectiveDstX, sint32 effectiveDstY,
 	sint32 dstSlice, sint32 effectiveCopyWidth, sint32 effectiveCopyHeight, sint32 srcDepth)
 {
 	auto srcGL = (LatteTextureGL*)src;
 	auto dstGL = (LatteTextureGL*)dst;
-
 	if ((srcGL->isAlternativeFormat || dstGL->isAlternativeFormat) && (srcGL->glInternalFormat != dstGL->glInternalFormat))
 	{
 		if (srcGL->format == Latte::E_GX2SURFFMT::R16_G16_B16_A16_UINT && dstGL->format == Latte::E_GX2SURFFMT::BC4_UNORM)
@@ -1363,7 +1204,7 @@ void OpenGLRenderer::texture_copyImageSubData(LatteTexture* src, sint32 srcMip,
 		}
 		else
 		{
-			forceLogDebug_printf("_syncSlice() called with unhandled alternative format");
+			cemuLog_logDebug(LogType::Force, "_syncSlice() called with unhandled alternative format");
 			return;
 		}
 	}
@@ -1434,31 +1275,25 @@ RendererShader* OpenGLRenderer::shader_create(RendererShader::ShaderType type, u
 void OpenGLRenderer::shader_bind(RendererShader* shader)
 {
 	auto shaderGL = (RendererShaderGL*)shader;
-	
 	GLbitfield shaderBit;
-
 	const auto program = shaderGL->GetProgram();
-
 	switch(shader->GetType())
 	{
 	case RendererShader::ShaderType::kVertex:
 		if (program == prevVertexShaderProgram)
 			return;
-
 		shaderBit = GL_VERTEX_SHADER_BIT;
 		prevVertexShaderProgram = program;
 		break;
 	case RendererShader::ShaderType::kFragment:
 		if (program == prevPixelShaderProgram)
 			return;
-
 		shaderBit = GL_FRAGMENT_SHADER_BIT;
 		prevPixelShaderProgram = program;
 		break;
 	case RendererShader::ShaderType::kGeometry:
 		if (program == prevGeometryShaderProgram)
 			return;
-
 		shaderBit = GL_GEOMETRY_SHADER_BIT;
 		prevGeometryShaderProgram = program;
 		break;
@@ -1471,13 +1306,6 @@ void OpenGLRenderer::shader_bind(RendererShader* shader)
 	catchOpenGLError();
 }
 
-void OpenGLRenderer::shader_bind(GLuint program, GLbitfield shaderType)
-{
-	catchOpenGLError();
-	glUseProgramStages(m_pipeline, shaderType, program);
-	catchOpenGLError();
-}
-
 void OpenGLRenderer::shader_unbind(RendererShader::ShaderType shaderType)
 {
 	switch (shaderType) { 
diff --git a/src/Cafe/HW/Latte/Renderer/OpenGL/OpenGLRenderer.h b/src/Cafe/HW/Latte/Renderer/OpenGL/OpenGLRenderer.h
index 129ada03..e29e9d4c 100644
--- a/src/Cafe/HW/Latte/Renderer/OpenGL/OpenGLRenderer.h
+++ b/src/Cafe/HW/Latte/Renderer/OpenGL/OpenGLRenderer.h
@@ -30,8 +30,6 @@ public:
 	void Flush(bool waitIdle = false) override;
 	void NotifyLatteCommandProcessorIdle() override;
 
-	void EnableVSync(int state) override;
-
 	void EnableDebugMode() override;
 	void SwapBuffers(bool swapTV = true, bool swapDRC = true) override;
 
@@ -66,26 +64,20 @@ public:
 	void renderstate_updateTextureSettingsGL(LatteDecompilerShader* shaderContext, LatteTextureView* _hostTextureView, uint32 hostTextureUnit, const Latte::LATTE_SQ_TEX_RESOURCE_WORD4_N texUnitWord4, uint32 texUnitIndex, bool isDepthSampler);
 
 	// texture functions
-	void texture_destroy(LatteTexture* hostTexture) override;
-
 	void* texture_acquireTextureUploadBuffer(uint32 size) override;
 	void texture_releaseTextureUploadBuffer(uint8* mem) override;
 
 	TextureDecoder* texture_chooseDecodedFormat(Latte::E_GX2SURFFMT format, bool isDepth, Latte::E_DIM dim, uint32 width, uint32 height) override;
 
-	void texture_reserveTextureOnGPU(LatteTexture* hostTexture) override;
 	void texture_clearSlice(LatteTexture* hostTexture, sint32 sliceIndex, sint32 mipIndex) override;
 	void texture_loadSlice(LatteTexture* hostTexture, sint32 width, sint32 height, sint32 depth, void* pixelData, sint32 sliceIndex, sint32 mipIndex, uint32 compressedImageSize) override;
 	void texture_clearColorSlice(LatteTexture* hostTexture, sint32 sliceIndex, sint32 mipIndex, float r, float g, float b, float a) override;
 	void texture_clearDepthSlice(LatteTexture* hostTexture, uint32 sliceIndex, sint32 mipIndex, bool clearDepth, bool clearStencil, float depthValue, uint32 stencilValue) override;
 
-	LatteTexture* texture_createTextureEx(uint32 textureUnit, Latte::E_DIM dim, MPTR physAddress, MPTR physMipAddress, Latte::E_GX2SURFFMT format, uint32 width, uint32 height, uint32 depth, uint32 pitch, uint32 mipLevels, uint32 swizzle, Latte::E_HWTILEMODE tileMode, bool isDepth) override;
+	LatteTexture* texture_createTextureEx(Latte::E_DIM dim, MPTR physAddress, MPTR physMipAddress, Latte::E_GX2SURFFMT format, uint32 width, uint32 height, uint32 depth, uint32 pitch, uint32 mipLevels, uint32 swizzle, Latte::E_HWTILEMODE tileMode, bool isDepth) override;
 
-	void texture_bindAndActivate(LatteTextureView* textureView, uint32 textureUnit) override;
-	void texture_bindAndActivateRawTex(LatteTexture* texture, uint32 textureUnit) override;
-	void texture_bindOnly(LatteTextureView* textureView, uint32 textureUnit) override;
-	void texture_rememberBoundTexture(uint32 textureUnit) override;
-	void texture_restoreBoundTexture(uint32 textureUnit) override;
+	void texture_setLatteTexture(LatteTextureView* textureView, uint32 textureUnit) override;
+	void texture_bindAndActivate(LatteTextureView* textureView, uint32 textureUnit);
 	void texture_copyImageSubData(LatteTexture* src, sint32 srcMip, sint32 effectiveSrcX, sint32 effectiveSrcY, sint32 srcSlice, LatteTexture* dst, sint32 dstMip, sint32 effectiveDstX, sint32 effectiveDstY, sint32 dstSlice, sint32 effectiveCopyWidth, sint32 effectiveCopyHeight, sint32 srcDepth) override;
 
 	void texture_notifyDelete(LatteTextureView* textureView);
@@ -110,16 +102,21 @@ public:
 	static void SetAttributeArrayState(uint32 index, bool isEnabled, sint32 aluDivisor);
 	static void SetArrayElementBuffer(GLuint arrayElementBuffer);
 
-	// index
-	void* indexData_reserveIndexMemory(uint32 size, uint32& offset, uint32& bufferIndex) override
+	// index (not used by OpenGL renderer yet)
+	IndexAllocation indexData_reserveIndexMemory(uint32 size) override
 	{
-		assert_dbg();
-		return nullptr;
+		cemu_assert_unimplemented();
+		return {};
 	}
 
-	void indexData_uploadIndexMemory(uint32 offset, uint32 size) override
+	void indexData_releaseIndexMemory(IndexAllocation& allocation) override
 	{
-		assert_dbg();
+		cemu_assert_unimplemented();
+	}
+
+	void indexData_uploadIndexMemory(IndexAllocation& allocation) override
+	{
+		cemu_assert_unimplemented();
 	}
 
 	// uniform
@@ -127,9 +124,8 @@ public:
 
 	// shader
 	RendererShader* shader_create(RendererShader::ShaderType type, uint64 baseHash, uint64 auxHash, const std::string& source, bool isGameShader, bool isGfxPackShader) override;
-	void shader_bind(RendererShader* shader) override;
-	void shader_bind(GLuint program, GLbitfield shaderType);
-	void shader_unbind(RendererShader::ShaderType shaderType) override;
+	void shader_bind(RendererShader* shader);
+	void shader_unbind(RendererShader::ShaderType shaderType);
 
 	// streamout
 	void streamout_setupXfbBuffer(uint32 bufferIndex, sint32 ringBufferOffset, uint32 rangeAddr, uint32 rangeSize) override;
@@ -165,7 +161,6 @@ private:
 	void texture_syncSliceSpecialBC4(LatteTexture* srcTexture, sint32 srcSliceIndex, sint32 srcMipIndex, LatteTexture* dstTexture, sint32 dstSliceIndex, sint32 dstMipIndex);
 	void texture_syncSliceSpecialIntegerToBC3(LatteTexture* srcTexture, sint32 srcSliceIndex, sint32 srcMipIndex, LatteTexture* dstTexture, sint32 dstSliceIndex, sint32 dstMipIndex);
 
-	GLuint m_defaultFramebufferId;
 	GLuint m_pipeline = 0;
 
 	bool m_isPadViewContext{};
@@ -190,14 +185,7 @@ private:
 	bool m_isXfbActive = false;
 
 	sint32 activeTextureUnit = 0;
-	void* LatteBoundTextures[Latte::GPU_LIMITS::NUM_TEXTURES_PER_STAGE * 3]{};
-	GLuint texUnitTexId[Latte::GPU_LIMITS::NUM_TEXTURES_PER_STAGE * 3]{};
-	GLenum texUnitTexTarget[Latte::GPU_LIMITS::NUM_TEXTURES_PER_STAGE * 3]{};
-
-	void* LatteBoundTexturesBackup[Latte::GPU_LIMITS::NUM_TEXTURES_PER_STAGE * 3]{};
-	GLuint texUnitTexIdBackup[Latte::GPU_LIMITS::NUM_TEXTURES_PER_STAGE * 3]{};
-	GLenum texUnitTexTargetBackup[Latte::GPU_LIMITS::NUM_TEXTURES_PER_STAGE * 3]{};
-	bool texUnitBackupSlotUsed[Latte::GPU_LIMITS::NUM_TEXTURES_PER_STAGE * 3]{};
+	void* m_latteBoundTextures[Latte::GPU_LIMITS::NUM_TEXTURES_PER_STAGE * 3]{};
 
 	// attribute stream
 	GLuint glAttributeCacheAB{};
@@ -207,7 +195,7 @@ private:
 	GLuint glStreamoutCacheRingBuffer;
 
 	// cfbo
-	GLuint prevBoundFBO = -1;
+	GLuint prevBoundFBO = 0;
 	GLuint glId_fbo = 0;
 
 	// renderstate
@@ -216,8 +204,6 @@ private:
 	uint32 prevLogicOp = 0;
 	uint32 prevBlendColorConstant[4] = { 0 };
 	uint8 prevAlphaTestEnable = 0;
-	uint8 prevAlphaTestFunc = 0;
-	uint32 prevAlphaTestRefU32 = 0;	
 	bool prevDepthEnable = 0;
 	bool prevDepthWriteEnable = 0;
 	Latte::LATTE_DB_DEPTH_CONTROL::E_ZFUNC prevDepthFunc = (Latte::LATTE_DB_DEPTH_CONTROL::E_ZFUNC)-1;
@@ -263,9 +249,9 @@ private:
 	std::vector<class LatteQueryObjectGL*> list_queryCacheOcclusion; // cache for unused queries
 
 	// resource garbage collection	
-	struct bufferCacheReleaseQueueEntry_t
+	struct BufferCacheReleaseQueueEntry
 	{
-		bufferCacheReleaseQueueEntry_t(VirtualBufferHeap_t* heap, VirtualBufferHeapEntry_t* entry) : m_heap(heap), m_entry(entry) {};
+		BufferCacheReleaseQueueEntry(VirtualBufferHeap_t* heap, VirtualBufferHeapEntry_t* entry) : m_heap(heap), m_entry(entry) {};
 		
 		void free()
 		{
@@ -279,7 +265,7 @@ private:
 	struct
 	{
 		sint32 index;
-		std::vector<bufferCacheReleaseQueueEntry_t> bufferCacheEntries;
+		std::vector<BufferCacheReleaseQueueEntry> bufferCacheEntries;
 	}m_destructionQueues;
 
-};
\ No newline at end of file
+};
diff --git a/src/Cafe/HW/Latte/Renderer/OpenGL/OpenGLRendererCore.cpp b/src/Cafe/HW/Latte/Renderer/OpenGL/OpenGLRendererCore.cpp
index f9f61646..571961f4 100644
--- a/src/Cafe/HW/Latte/Renderer/OpenGL/OpenGLRendererCore.cpp
+++ b/src/Cafe/HW/Latte/Renderer/OpenGL/OpenGLRendererCore.cpp
@@ -467,7 +467,7 @@ void LatteDrawGL_prepareIndicesWithGPUCache(MPTR indexDataMPTR, _INDEX_TYPE inde
 		uint32 h = LatteDrawGL_calculateIndexDataHash(memory_getPointerFromPhysicalOffset(indexDataMPTR), cacheEntryItr->physSize);
 		if (cacheEntryItr->hash != h)
 		{
-			forceLogDebug_printf("IndexData hash changed");
+			cemuLog_logDebug(LogType::Force, "IndexData hash changed");
 			_decodeAndUploadIndexData(cacheEntryItr);
 			cacheEntryItr->hash = h;
 		}
@@ -494,7 +494,7 @@ void LatteDrawGL_prepareIndicesWithGPUCache(MPTR indexDataMPTR, _INDEX_TYPE inde
 				break;
 			if (indexDataCacheFirst == nullptr)
 			{
-				forceLog_printf("Unable to allocate entry in index cache");
+				cemuLog_log(LogType::Force, "Unable to allocate entry in index cache");
 				assert_dbg();
 			}
 		}
@@ -527,7 +527,7 @@ void LatteDrawGL_prepareIndicesWithGPUCache(MPTR indexDataMPTR, _INDEX_TYPE inde
 void LatteDraw_handleSpecialState8_clearAsDepth()
 {
 	if (LatteGPUState.contextNew.GetSpecialStateValues()[0] == 0)
-		forceLogDebug_printf("Special state 8 requires special state 0 but it is not set?");
+		cemuLog_logDebug(LogType::Force, "Special state 8 requires special state 0 but it is not set?");
 	// get depth buffer information
 	uint32 regDepthBuffer = LatteGPUState.contextRegister[mmDB_HTILE_DATA_BASE];
 	uint32 regDepthSize = LatteGPUState.contextRegister[mmDB_DEPTH_SIZE];
@@ -580,7 +580,10 @@ void LatteDraw_handleSpecialState8_clearAsDepth()
 		}
 		else
 		{
-			g_renderer->texture_clearColorSlice(view->baseTexture, sliceIndex + view->firstSlice, mipIndex + view->firstMip, clearColor[0], clearColor[1], clearColor[2], clearColor[3]);
+			if (view->baseTexture->isDepth)
+				g_renderer->texture_clearDepthSlice(view->baseTexture, sliceIndex + view->firstSlice, mipIndex + view->firstMip, true, view->baseTexture->hasStencil, 0.0f, 0);
+			else
+				g_renderer->texture_clearColorSlice(view->baseTexture, sliceIndex + view->firstSlice, mipIndex + view->firstMip, clearColor[0], clearColor[1], clearColor[2], clearColor[3]);
 		}
 	}
 }
@@ -909,6 +912,21 @@ void OpenGLRenderer::draw_genericDrawHandler(uint32 baseVertex, uint32 baseInsta
 	{
 		beginPerfMonProfiling(performanceMonitor.gpuTime_dcStageShaderAndUniformMgr);
 		LatteSHRC_UpdateActiveShaders();
+		LatteDecompilerShader* vs = (LatteDecompilerShader*)LatteSHRC_GetActiveVertexShader();
+		LatteDecompilerShader* gs = (LatteDecompilerShader*)LatteSHRC_GetActiveGeometryShader();
+		LatteDecompilerShader* ps = (LatteDecompilerShader*)LatteSHRC_GetActivePixelShader();
+		if (vs)
+			shader_bind(vs->shader);
+		else
+			shader_unbind(RendererShader::ShaderType::kVertex);
+		if (ps && LatteGPUState.contextRegister[mmVGT_STRMOUT_EN] == 0)
+			shader_bind(ps->shader);
+		else
+			shader_unbind(RendererShader::ShaderType::kFragment);
+		if (gs)
+			shader_bind(gs->shader);
+		else
+			shader_unbind(RendererShader::ShaderType::kGeometry);
 		endPerfMonProfiling(performanceMonitor.gpuTime_dcStageShaderAndUniformMgr);
 	}
 	if (LatteGPUState.activeShaderHasError)
@@ -932,7 +950,7 @@ void OpenGLRenderer::draw_genericDrawHandler(uint32 baseVertex, uint32 baseInsta
 	bool streamoutEnable = LatteGPUState.contextRegister[mmVGT_STRMOUT_EN] != 0;
 	if (streamoutEnable)
 	{
-		if (glBeginTransformFeedback == nullptr || LatteGPUState.glVendor == GLVENDOR_INTEL_NOLEGACY)
+		if (glBeginTransformFeedback == nullptr)
 		{
 			cemu_assert_debug(false);
 			return; // transform feedback not supported
@@ -1039,7 +1057,7 @@ void OpenGLRenderer::draw_genericDrawHandler(uint32 baseVertex, uint32 baseInsta
 		LatteTextureView* rt_depth = LatteMRT::GetDepthAttachment();
 		if (!rt_depth || !rt_color)
 		{
-			cemuLog_force("GPU7 special state 5 used but render target not setup correctly");
+			cemuLog_log(LogType::Force, "GPU7 special state 5 used but render target not setup correctly");
 			return;
 		}
 		surfaceCopy_copySurfaceWithFormatConversion(rt_depth->baseTexture, rt_depth->firstMip, rt_depth->firstSlice, rt_color->baseTexture, rt_color->firstMip, rt_color->firstSlice, rt_depth->baseTexture->width, rt_depth->baseTexture->height);
@@ -1198,20 +1216,10 @@ void OpenGLRenderer::draw_beginSequence()
 void OpenGLRenderer::draw_execute(uint32 baseVertex, uint32 baseInstance, uint32 instanceCount, uint32 count, MPTR indexDataMPTR, Latte::LATTE_VGT_DMA_INDEX_TYPE::E_INDEX_TYPE indexType, bool isFirst)
 {
 	bool isMinimal = !isFirst;
-	if (ActiveSettings::FrameProfilerEnabled())
-	{
-		if (isMinimal)
-			draw_genericDrawHandler<true, true>(baseVertex, baseInstance, instanceCount, count, indexDataMPTR, indexType);
-		else
-			draw_genericDrawHandler<false, true>(baseVertex, baseInstance, instanceCount, count, indexDataMPTR, indexType);
-	}
-	else
-	{
-		if (isMinimal)
-			draw_genericDrawHandler<true, false>(baseVertex, baseInstance, instanceCount, count, indexDataMPTR, indexType);
-		else
-			draw_genericDrawHandler<false, false>(baseVertex, baseInstance, instanceCount, count, indexDataMPTR, indexType);
-	}	
+    if (isMinimal)
+        draw_genericDrawHandler<true, false>(baseVertex, baseInstance, instanceCount, count, indexDataMPTR, indexType);
+    else
+        draw_genericDrawHandler<false, false>(baseVertex, baseInstance, instanceCount, count, indexDataMPTR, indexType);
 }
 
 void OpenGLRenderer::draw_endSequence()
@@ -1334,7 +1342,7 @@ uint32 _correctTextureCompSelGL(Latte::E_GX2SURFFMT format, uint32 compSel)
 	return compSel;
 }
 
-#define quickBindTexture() 		if( textureIsActive == false ) { g_renderer->texture_bindAndActivate(hostTextureView, hostTextureUnit); textureIsActive = true; }
+#define quickBindTexture() 		if( textureIsActive == false ) { texture_bindAndActivate(hostTextureView, hostTextureUnit); textureIsActive = true; }
 
 uint32 _getGLMinFilter(Latte::LATTE_SQ_TEX_SAMPLER_WORD0_0::E_XY_FILTER filterMin, Latte::LATTE_SQ_TEX_SAMPLER_WORD0_0::E_Z_FILTER filterMip)
 {
@@ -1357,11 +1365,9 @@ uint32 _getGLMinFilter(Latte::LATTE_SQ_TEX_SAMPLER_WORD0_0::E_XY_FILTER filterMi
 /*
 * Update channel swizzling and other texture settings for a texture unit
 * hostTextureView is the texture unit view used on the host side
-* The baseGX2TexUnit parameter is used to identify the shader stage in which this texture is accessed
 */
 void OpenGLRenderer::renderstate_updateTextureSettingsGL(LatteDecompilerShader* shaderContext, LatteTextureView* _hostTextureView, uint32 hostTextureUnit, const Latte::LATTE_SQ_TEX_RESOURCE_WORD4_N texUnitWord4, uint32 texUnitIndex, bool isDepthSampler)
 {
-	// todo - this is OpenGL-specific, decouple this from the renderer-neutral backend
 	auto hostTextureView = (LatteTextureViewGL*)_hostTextureView;
 
 	LatteTexture* baseTexture = hostTextureView->baseTexture;
@@ -1598,4 +1604,4 @@ void OpenGLRenderer::renderstate_updateTextureSettingsGL(LatteDecompilerShader*
 		}
 		catchOpenGLError();
 	}
-}
\ No newline at end of file
+}
diff --git a/src/Cafe/HW/Latte/Renderer/OpenGL/OpenGLRendererStreamout.cpp b/src/Cafe/HW/Latte/Renderer/OpenGL/OpenGLRendererStreamout.cpp
index ef23a770..785dab79 100644
--- a/src/Cafe/HW/Latte/Renderer/OpenGL/OpenGLRendererStreamout.cpp
+++ b/src/Cafe/HW/Latte/Renderer/OpenGL/OpenGLRendererStreamout.cpp
@@ -41,7 +41,7 @@ void OpenGLRenderer::bufferCache_copyStreamoutToMainBuffer(uint32 srcOffset, uin
 	if (glCopyNamedBufferSubData)
 		glCopyNamedBufferSubData(glStreamoutCacheRingBuffer, glAttributeCacheAB, srcOffset, dstOffset, size);
 	else
-		forceLog_printf("glCopyNamedBufferSubData() not supported");
+		cemuLog_log(LogType::Force, "glCopyNamedBufferSubData() not supported");
 }
 
 void OpenGLRenderer::streamout_rendererFinishDrawcall()
@@ -55,4 +55,4 @@ void OpenGLRenderer::streamout_rendererFinishDrawcall()
 		m_isXfbActive = false;
 	}
 
-}
\ No newline at end of file
+}
diff --git a/src/Cafe/HW/Latte/Renderer/OpenGL/OpenGLSurfaceCopy.cpp b/src/Cafe/HW/Latte/Renderer/OpenGL/OpenGLSurfaceCopy.cpp
index 8c8c36d7..d578b842 100644
--- a/src/Cafe/HW/Latte/Renderer/OpenGL/OpenGLSurfaceCopy.cpp
+++ b/src/Cafe/HW/Latte/Renderer/OpenGL/OpenGLSurfaceCopy.cpp
@@ -30,9 +30,8 @@ void OpenGLRenderer::surfaceCopy_copySurfaceWithFormatConversion(LatteTexture* s
 	sint32 effectiveCopyWidth = width;
 	sint32 effectiveCopyHeight = height;
 	LatteTexture_scaleToEffectiveSize(sourceTexture, &effectiveCopyWidth, &effectiveCopyHeight, 0);
-	sint32 sourceEffectiveWidth;
-	sint32 sourceEffectiveHeight;
-	LatteTexture_getEffectiveSize(sourceTexture, &sourceEffectiveWidth, &sourceEffectiveHeight, nullptr, srcMip);
+	sint32 sourceEffectiveWidth, sourceEffectiveHeight;
+	sourceTexture->GetEffectiveSize(sourceEffectiveWidth, sourceEffectiveHeight, srcMip);
 	// reset everything
 	renderstate_resetColorControl();
 	renderstate_resetDepthControl();
@@ -52,7 +51,7 @@ void OpenGLRenderer::surfaceCopy_copySurfaceWithFormatConversion(LatteTexture* s
 	LatteTextureView* sourceView = sourceTexture->GetOrCreateView(srcMip, 1, srcSlice, 1);
 	LatteTextureView* destinationView = destinationTexture->GetOrCreateView(dstMip, 1, dstSlice, 1);
 
-	g_renderer->texture_bindAndActivate(sourceView, 0);
+	texture_bindAndActivate(sourceView, 0);
 	catchOpenGLError();
 	// setup texture attributes
 	_setDepthCompareMode((LatteTextureViewGL*)sourceView, 0);
diff --git a/src/Cafe/HW/Latte/Renderer/OpenGL/RendererShaderGL.cpp b/src/Cafe/HW/Latte/Renderer/OpenGL/RendererShaderGL.cpp
index e9e86f53..cae53140 100644
--- a/src/Cafe/HW/Latte/Renderer/OpenGL/RendererShaderGL.cpp
+++ b/src/Cafe/HW/Latte/Renderer/OpenGL/RendererShaderGL.cpp
@@ -13,7 +13,7 @@ bool s_isLoadingShaders{false};
 
 bool RendererShaderGL::loadBinary()
 {
-	if (!g_programBinaryCache)
+	if (!s_programBinaryCache)
 		return false;
 	if (m_isGameShader == false || m_isGfxPackShader)
 		return false; // only non-custom 
@@ -23,16 +23,13 @@ bool RendererShaderGL::loadBinary()
 	cemu_assert_debug(m_baseHash != 0);
 	uint64 h1, h2;
 	GenerateShaderPrecompiledCacheFilename(m_type, m_baseHash, m_auxHash, h1, h2);
-	sint32 fileSize = 0;
 	std::vector<uint8> cacheFileData;
-	if (!g_programBinaryCache->GetFile({ h1, h2 }, cacheFileData))
+	if (!s_programBinaryCache->GetFile({h1, h2 }, cacheFileData))
 		return false;
-	if (fileSize < sizeof(uint32))
-	{
+	if (cacheFileData.size() <= sizeof(uint32))
 		return false;
-	}
 
-	uint32 shaderBinFormat = *(uint32*)(cacheFileData.data() + 0);
+	uint32 shaderBinFormat = *(uint32*)(cacheFileData.data());
 
 	m_program = glCreateProgram();
 	glProgramBinary(m_program, shaderBinFormat, cacheFileData.data()+4, cacheFileData.size()-4);
@@ -51,7 +48,7 @@ bool RendererShaderGL::loadBinary()
 
 void RendererShaderGL::storeBinary()
 {
-	if (!g_programBinaryCache)
+	if (!s_programBinaryCache)
 		return;
 	if (!glGetProgramBinary)
 		return;
@@ -72,7 +69,7 @@ void RendererShaderGL::storeBinary()
 		glGetProgramBinary(m_program, binaryLength, NULL, &binaryFormat, storedBinary.data()+sizeof(uint32));		
 		*(uint32*)(storedBinary.data() + 0) = binaryFormat;
 		// store
-		g_programBinaryCache->AddFileAsync({ h1, h2 }, storedBinary.data(), storedBinary.size());
+		s_programBinaryCache->AddFileAsync({h1, h2 }, storedBinary.data(), storedBinary.size());
 	}
 }
 
@@ -119,8 +116,8 @@ RendererShaderGL::RendererShaderGL(ShaderType type, uint64 baseHash, uint64 auxH
 		char log[2048]{};
 		GLsizei log_size;
 		glGetShaderInfoLog(m_shader_object, std::min<uint32>(log_length, sizeof(log) - 1), &log_size, log);
-		forceLog_printf("Error/Warning in shader:");
-		forceLog_printf("%s", log);
+		cemuLog_log(LogType::Force, "Error/Warning in shader:");
+		cemuLog_log(LogType::Force, log);
 	}
 
 	// set debug name
@@ -192,8 +189,8 @@ bool RendererShaderGL::WaitForCompiled()
 			tempLength = sizeof(infoLog) - 1;
 			glGetShaderInfoLog(m_shader_object, std::min(infoLogLength, tempLength), (GLsizei*)&tempLength, (GLcharARB*)infoLog);
 			infoLog[tempLength] = '\0';
-			forceLog_printf("Compile error in shader. Log:", infoLog);
-			cafeLog_logLine(LOG_TYPE_FORCE, infoLog);
+			cemuLog_log(LogType::Force, "Compile error in shader. Log:");
+			cemuLog_log(LogType::Force, infoLog);
 		}
 		if (m_shader_object != 0)
 			glDeleteShader(m_shader_object);
@@ -212,8 +209,8 @@ bool RendererShaderGL::WaitForCompiled()
 			tempLength = sizeof(infoLog) - 1;
 			glGetProgramInfoLog(m_program, std::min(infoLogLength, tempLength), (GLsizei*)&tempLength, (GLcharARB*)infoLog);
 			infoLog[tempLength] = '\0';
-			forceLog_printf("Link error in shader. Log:", infoLog);
-			cafeLog_logLine(LOG_TYPE_FORCE, infoLog);
+			cemuLog_log(LogType::Force, "Link error in shader. Log:");
+			cemuLog_log(LogType::Force, infoLog);
 		}
 		m_isCompiled = true;
 		return false;
@@ -230,11 +227,6 @@ sint32 RendererShaderGL::GetUniformLocation(const char* name)
 	return glGetUniformLocation(m_program, name);
 }
 
-void RendererShaderGL::SetUniform1iv(sint32 location, void* data, sint32 count)
-{
-	glProgramUniform1iv(m_program, location, count, (const GLint*)data);
-}
-
 void RendererShaderGL::SetUniform2fv(sint32 location, void* data, sint32 count)
 {
 	glProgramUniform2fv(m_program, location, count, (const GLfloat*)data);
@@ -247,12 +239,7 @@ void RendererShaderGL::SetUniform4iv(sint32 location, void* data, sint32 count)
 
 void RendererShaderGL::ShaderCacheLoading_begin(uint64 cacheTitleId)
 {
-	if (g_programBinaryCache)
-	{
-		delete g_programBinaryCache;
-		g_programBinaryCache = nullptr;
-	}
-
+    cemu_assert_debug(!s_programBinaryCache); // should not be set, ShaderCacheLoading_Close() not called?
 	// determine if cache is enabled
 	bool usePrecompiled = false;
 	switch (ActiveSettings::GetPrecompiledShadersOption())
@@ -273,15 +260,14 @@ void RendererShaderGL::ShaderCacheLoading_begin(uint64 cacheTitleId)
 		UNREACHABLE;
 	}
 
-	forceLog_printf("Using precompiled shaders: %s", usePrecompiled ? "true" : "false");
+	cemuLog_log(LogType::Force, "Using precompiled shaders: {}", usePrecompiled ? "true" : "false");
 
 	if (usePrecompiled)
 	{
 		const uint32 cacheMagic = GeneratePrecompiledCacheId();
 		const std::string cacheFilename = fmt::format("{:016x}_gl.bin", cacheTitleId);
-		const std::wstring cachePath = ActiveSettings::GetPath("shaderCache/precompiled/{}", cacheFilename).generic_wstring();
-		g_programBinaryCache = FileCache::Open(cachePath, true, cacheMagic);
-		if (g_programBinaryCache == nullptr)
+        s_programBinaryCache = FileCache::Open(ActiveSettings::GetCachePath("shaderCache/precompiled/{}", cacheFilename), true, cacheMagic);
+		if (s_programBinaryCache == nullptr)
 			cemuLog_log(LogType::Force, "Unable to open OpenGL precompiled cache {}", cacheFilename);
 	}
 	s_isLoadingShaders = true;
@@ -292,4 +278,15 @@ void RendererShaderGL::ShaderCacheLoading_end()
 	s_isLoadingShaders = false;
 }
 
-FileCache* RendererShaderGL::g_programBinaryCache{};
\ No newline at end of file
+void RendererShaderGL::ShaderCacheLoading_Close()
+{
+    if(s_programBinaryCache)
+    {
+        delete s_programBinaryCache;
+        s_programBinaryCache = nullptr;
+    }
+    g_compiled_shaders_total = 0;
+    g_compiled_shaders_async = 0;
+}
+
+FileCache* RendererShaderGL::s_programBinaryCache{};
diff --git a/src/Cafe/HW/Latte/Renderer/OpenGL/RendererShaderGL.h b/src/Cafe/HW/Latte/Renderer/OpenGL/RendererShaderGL.h
index 1c0753dc..60c51cc1 100644
--- a/src/Cafe/HW/Latte/Renderer/OpenGL/RendererShaderGL.h
+++ b/src/Cafe/HW/Latte/Renderer/OpenGL/RendererShaderGL.h
@@ -18,12 +18,12 @@ public:
 	GLuint GetShaderObject() const { cemu_assert_debug(m_isCompiled); return m_shader_object; }
 
 	sint32 GetUniformLocation(const char* name) override;
-	void SetUniform1iv(sint32 location, void* data, sint32 count) override;
 	void SetUniform2fv(sint32 location, void* data, sint32 count) override;
 	void SetUniform4iv(sint32 location, void* data, sint32 count) override;
 
 	static void ShaderCacheLoading_begin(uint64 cacheTitleId);
 	static void ShaderCacheLoading_end();
+    static void ShaderCacheLoading_Close();
 
 private:
 	GLuint m_program;
@@ -37,6 +37,6 @@ private:
 	bool m_shader_attached{ false };
 	bool m_isCompiled{ false };
 
-	static class FileCache* g_programBinaryCache;
+	static class FileCache* s_programBinaryCache;
 };
 
diff --git a/src/Cafe/HW/Latte/Renderer/OpenGL/TextureReadbackGL.cpp b/src/Cafe/HW/Latte/Renderer/OpenGL/TextureReadbackGL.cpp
index 45fa9273..b2966706 100644
--- a/src/Cafe/HW/Latte/Renderer/OpenGL/TextureReadbackGL.cpp
+++ b/src/Cafe/HW/Latte/Renderer/OpenGL/TextureReadbackGL.cpp
@@ -1,4 +1,5 @@
 #include "Cafe/HW/Latte/Renderer/Renderer.h"
+#include "Cafe/HW/Latte/Renderer/OpenGL/OpenGLRenderer.h"
 #include "Cafe/HW/Latte/Renderer/OpenGL/OpenGLTextureReadback.h"
 #include "Cafe/HW/Latte/Renderer/OpenGL/LatteTextureViewGL.h"
 
@@ -76,7 +77,7 @@ LatteTextureReadbackInfoGL::LatteTextureReadbackInfoGL(LatteTextureView* texture
 	}
 	else
 	{
-		forceLogDebug_printf("Unsupported texture readback format %04x\n", (uint32)textureView->format);
+		cemuLog_logDebug(LogType::Force, "Unsupported texture readback format {:04x}", (uint32)textureView->format);
 		return;
 	}
 }
@@ -93,8 +94,7 @@ LatteTextureReadbackInfoGL::~LatteTextureReadbackInfoGL()
 void LatteTextureReadbackInfoGL::StartTransfer()
 {
 	cemu_assert(m_textureView);
-
-	g_renderer->texture_bindAndActivate(m_textureView, 0);
+	((OpenGLRenderer*)g_renderer.get())->texture_bindAndActivate(m_textureView, 0);
 	// create unsynchronized buffer
 	glGenBuffers(1, &texImageBufferGL);
 	glBindBuffer(GL_PIXEL_PACK_BUFFER, texImageBufferGL);
diff --git a/src/Cafe/HW/Latte/Renderer/Renderer.cpp b/src/Cafe/HW/Latte/Renderer/Renderer.cpp
index c7f7b814..4db88355 100644
--- a/src/Cafe/HW/Latte/Renderer/Renderer.cpp
+++ b/src/Cafe/HW/Latte/Renderer/Renderer.cpp
@@ -10,6 +10,11 @@
 
 #include "config/ActiveSettings.h"
 
+#include <wx/image.h>
+#include <wx/dataobj.h>
+#include <wx/clipbrd.h>
+#include <wx/log.h>
+
 std::unique_ptr<Renderer> g_renderer;
 
 bool Renderer::GetVRAMInfo(int& usageInMB, int& totalInMB) const
@@ -32,19 +37,51 @@ bool Renderer::GetVRAMInfo(int& usageInMB, int& totalInMB) const
 	return false;
 }
 
+
+void Renderer::Initialize()
+{
+	// imgui
+	imguiFontAtlas = new ImFontAtlas();
+	imguiFontAtlas->AddFontDefault();
+
+	auto setupContext = [](ImGuiContext* context){
+		ImGui::SetCurrentContext(context);
+		ImGuiIO& io = ImGui::GetIO();
+		io.WantSaveIniSettings = false;
+		io.IniFilename = nullptr;
+	};
+
+	imguiTVContext = ImGui::CreateContext(imguiFontAtlas);
+	imguiPadContext = ImGui::CreateContext(imguiFontAtlas);
+	setupContext(imguiTVContext);
+	setupContext(imguiPadContext);
+}
+
+void Renderer::Shutdown()
+{
+	// imgui
+	ImGui::DestroyContext(imguiTVContext);
+	ImGui::DestroyContext(imguiPadContext);
+    ImGui_ClearFonts();
+	delete imguiFontAtlas;
+}
+
 bool Renderer::ImguiBegin(bool mainWindow)
 {
 	sint32 w = 0, h = 0;
 	if(mainWindow)
-		gui_getWindowSize(&w, &h);
+		gui_getWindowPhysSize(w, h);
 	else if(gui_isPadWindowOpen())
-		gui_getPadWindowSize(&w, &h);
+		gui_getPadWindowPhysSize(w, h);
 	else
 		return false;
 		
 	if (w == 0 || h == 0)
 		return false;
 
+	// select the right context
+	ImGui::SetCurrentContext(mainWindow ? imguiTVContext : imguiPadContext);
+
 	const Vector2f window_size{ (float)w,(float)h };
 	auto& io = ImGui::GetIO();
 	io.DisplaySize = { window_size.x, window_size.y }; // should be only updated in the renderer and only when needed
@@ -77,126 +114,107 @@ uint8 Renderer::RGBComponentToSRGB(uint8 cli)
 	return (uint8)(cs * 255.0f);
 }
 
-void Renderer::SaveScreenshot(const std::vector<uint8>& rgb_data, int width, int height, bool mainWindow) const
+static std::optional<fs::path> GenerateScreenshotFilename(bool isDRC)
+{
+	fs::path screendir = ActiveSettings::GetUserDataPath("screenshots");
+	// build screenshot name with format Screenshot_YYYY-MM-DD_HH-MM-SS[_GamePad].png
+	// if the file already exists add a suffix counter (_2.png, _3.png etc)
+	std::time_t time_t = std::chrono::system_clock::to_time_t(std::chrono::system_clock::now());
+	std::tm* tm = std::localtime(&time_t);
+
+	std::string screenshotFileName = fmt::format("Screenshot_{:04}-{:02}-{:02}_{:02}-{:02}-{:02}", tm->tm_year+1900, tm->tm_mon+1, tm->tm_mday, tm->tm_hour, tm->tm_min, tm->tm_sec);
+	if (isDRC)
+		screenshotFileName.append("_GamePad");
+
+	fs::path screenshotPath;
+	for(sint32 i=0; i<999; i++)
+	{
+		screenshotPath = screendir;
+		if (i == 0)
+			screenshotPath.append(fmt::format("{}.png", screenshotFileName));
+		else
+			screenshotPath.append(fmt::format("{}_{}.png", screenshotFileName, i + 1));
+		
+		std::error_code ec;
+		bool exists = fs::exists(screenshotPath, ec);
+		
+		if (!ec && !exists)
+			return screenshotPath;
+	}
+	return std::nullopt;
+}
+
+std::mutex s_clipboardMutex;
+
+static bool SaveScreenshotToClipboard(const wxImage &image)
+{
+	bool success = false;
+
+	s_clipboardMutex.lock();
+	if (wxTheClipboard->Open())
+	{
+		wxTheClipboard->SetData(new wxImageDataObject(image));
+		wxTheClipboard->Close();
+		success = true;
+	}
+	s_clipboardMutex.unlock();
+
+	return success;
+}
+
+static bool SaveScreenshotToFile(const wxImage &image, bool mainWindow)
+{
+	auto path = GenerateScreenshotFilename(!mainWindow);
+	if (!path) return false;
+
+	std::error_code ec;
+	fs::create_directories(path->parent_path(), ec);
+	if (ec) return false;
+
+	// suspend wxWidgets logging for the lifetime this object, to prevent a message box if wxImage::SaveFile fails
+	wxLogNull _logNo;
+	return image.SaveFile(path->wstring());
+}
+
+static void ScreenshotThread(std::vector<uint8> data, bool save_screenshot, int width, int height, bool mainWindow)
 {
 #if BOOST_OS_WINDOWS
-	const bool save_screenshot = GetConfig().save_screenshot;
-	std::thread([](std::vector<uint8> data, bool save_screenshot, int width, int height, bool mainWindow)
-	{
-		if (mainWindow)
-		{
-			// copy to clipboard
-			std::vector<uint8> buffer(sizeof(BITMAPINFO) + data.size());
-			auto* bmpInfo = (BITMAPINFO*)buffer.data();
-			bmpInfo->bmiHeader.biSize = sizeof(BITMAPINFOHEADER);
-			bmpInfo->bmiHeader.biWidth = width;
-			bmpInfo->bmiHeader.biHeight = height;
-			bmpInfo->bmiHeader.biPlanes = 1;
-			bmpInfo->bmiHeader.biBitCount = 24;
-			bmpInfo->bmiHeader.biCompression = BI_RGB;
-
-			uint8* clipboard_image = buffer.data() + sizeof(BITMAPINFOHEADER);
-			// RGB -> BGR
-			for (sint32 iy = 0; iy < height; ++iy)
-			{
-				for (sint32 ix = 0; ix < width; ++ix)
-				{
-					uint8* pIn = data.data() + (ix + iy * width) * 3;
-					uint8* pOut = clipboard_image + (ix + (height - iy - 1) * width) * 3;
-
-					pOut[0] = pIn[2];
-					pOut[1] = pIn[1];
-					pOut[2] = pIn[0];
-				}
-			}
-
-			if (OpenClipboard(nullptr))
-			{
-				EmptyClipboard();
-
-				const HGLOBAL hGlobal = GlobalAlloc(GMEM_MOVEABLE, buffer.size());
-				if (hGlobal)
-				{
-					memcpy(GlobalLock(hGlobal), buffer.data(), buffer.size());
-					GlobalUnlock(hGlobal);
-
-					SetClipboardData(CF_DIB, hGlobal);
-					GlobalFree(hGlobal);
-				}
-
-				CloseClipboard();
-			}
-
-			LatteOverlay_pushNotification("Screenshot saved", 2500);
-		}
-
-		// save to png file
-		if (save_screenshot)
-		{
-			fs::path screendir = ActiveSettings::GetPath("screenshots");
-			if (!fs::exists(screendir))
-				fs::create_directory(screendir);
-
-			auto counter = 0;
-			for (const auto& it : fs::directory_iterator(screendir))
-			{
-				int tmp;
-				if (swscanf_s(it.path().filename().c_str(), L"screenshot_%d", &tmp) == 1)
-					counter = std::max(counter, tmp);
-			}
-
-			screendir /= fmt::format(L"screenshot_{}.png", ++counter);
-			FileStream* fs = FileStream::createFile2(screendir);
-			if (fs)
-			{
-				bool success = true;
-				auto png_ptr = png_create_write_struct(PNG_LIBPNG_VER_STRING, NULL, NULL, NULL);
-				if (png_ptr)
-				{
-					auto info_ptr = png_create_info_struct(png_ptr);
-					if (info_ptr)
-					{
-						if (!setjmp(png_jmpbuf(png_ptr)))
-						{
-							auto pngWriter = [](png_structp png_ptr, png_bytep data, png_size_t length) -> void
-							{
-								FileStream* fs = (FileStream*)png_get_io_ptr(png_ptr);
-								fs->writeData(data, length);
-							};
-
-							//png_init_io(png_ptr, file);
-							png_set_write_fn(png_ptr, (void*)fs, pngWriter, nullptr);
-
-							png_set_IHDR(png_ptr, info_ptr, width, height, 8, PNG_COLOR_TYPE_RGB, PNG_INTERLACE_NONE,
-							             PNG_COMPRESSION_TYPE_BASE, PNG_FILTER_TYPE_BASE);
-							png_write_info(png_ptr, info_ptr);
-							for (int i = 0; i < height; ++i)
-							{
-								uint8* pData = data.data() + (i * width) * 3;
-								png_write_row(png_ptr, pData);
-							}
-
-							png_write_end(png_ptr, nullptr);
-						}
-						else
-							success = false;
-
-						png_free_data(png_ptr, info_ptr, PNG_FREE_ALL, -1);
-					}
-
-					png_destroy_write_struct(&png_ptr, nullptr);
-				}
-				delete fs;
-				if (!success)
-				{
-					std::error_code ec;
-					fs::remove(screendir, ec);
-				}
-			}
-		}
-	}, rgb_data, save_screenshot, width, height, mainWindow).detach();
-
-#else
-cemuLog_log(LogType::Force, "Screenshot feature not implemented");
+	// on Windows wxWidgets uses OLE API for the clipboard
+	// to make this work we need to call OleInitialize() on the same thread
+	OleInitialize(nullptr);
 #endif
+	
+	wxImage image(width, height, data.data(), true);
+
+	if (mainWindow)
+	{
+		if(SaveScreenshotToClipboard(image))
+		{
+			if (!save_screenshot)
+				LatteOverlay_pushNotification("Screenshot saved to clipboard", 2500);
+		}
+		else
+		{
+			LatteOverlay_pushNotification("Failed to open clipboard", 2500);
+		}
+	}
+
+	if (save_screenshot)
+	{
+		if (SaveScreenshotToFile(image, mainWindow))
+		{
+			if (mainWindow)
+				LatteOverlay_pushNotification("Screenshot saved", 2500);
+		}
+		else
+		{
+			LatteOverlay_pushNotification("Failed to save screenshot to file", 2500);
+		}
+	}
+}
+
+void Renderer::SaveScreenshot(const std::vector<uint8>& rgb_data, int width, int height, bool mainWindow) const
+{
+	const bool save_screenshot = GetConfig().save_screenshot;
+	std::thread(ScreenshotThread, rgb_data, save_screenshot, width, height, mainWindow).detach();
 }
diff --git a/src/Cafe/HW/Latte/Renderer/Renderer.h b/src/Cafe/HW/Latte/Renderer/Renderer.h
index e58a4ae7..77d588b9 100644
--- a/src/Cafe/HW/Latte/Renderer/Renderer.h
+++ b/src/Cafe/HW/Latte/Renderer/Renderer.h
@@ -12,13 +12,15 @@
 #include "util/DXGIWrapper/DXGIWrapper.h"
 #endif
 
+// imgui forward declarations
+struct ImFontAtlas;
+struct ImGuiContext;
+
 enum class GfxVendor
 {
 	Generic,
 
 	AMD,
-	IntelLegacy,
-	IntelNoLegacy,
 	Intel,
 	Nvidia,
 	Apple,
@@ -51,14 +53,13 @@ public:
 
 	virtual RendererAPI GetType() = 0;
 
-	virtual void Initialize() {}
-	virtual void Shutdown() {}
+	virtual void Initialize();
+	virtual void Shutdown();
 	virtual bool IsPadWindowActive() = 0;
 
 	virtual bool GetVRAMInfo(int& usageInMB, int& totalInMB) const;
 
 	virtual void EnableDebugMode() {}
-	virtual void EnableVSync(int state) = 0;
 
 	virtual void ClearColorbuffer(bool padView) = 0;
 	virtual void DrawEmptyFrame(bool mainWindow) = 0;
@@ -94,26 +95,19 @@ public:
 	virtual void rendertarget_bindFramebufferObject(LatteCachedFBO* cfbo) = 0;
 
 	// texture functions
-	virtual void texture_destroy(LatteTexture* hostTexture) = 0;
-
 	virtual void* texture_acquireTextureUploadBuffer(uint32 size) = 0;
 	virtual void texture_releaseTextureUploadBuffer(uint8* mem) = 0;
 
 	virtual TextureDecoder* texture_chooseDecodedFormat(Latte::E_GX2SURFFMT format, bool isDepth, Latte::E_DIM dim, uint32 width, uint32 height) = 0;
 
-	virtual void texture_reserveTextureOnGPU(LatteTexture* hostTexture) = 0;
 	virtual void texture_clearSlice(LatteTexture* hostTexture, sint32 sliceIndex, sint32 mipIndex) = 0;
 	virtual void texture_loadSlice(LatteTexture* hostTexture, sint32 width, sint32 height, sint32 depth, void* pixelData, sint32 sliceIndex, sint32 mipIndex, uint32 compressedImageSize) = 0;
 	virtual void texture_clearColorSlice(LatteTexture* hostTexture, sint32 sliceIndex, sint32 mipIndex, float r, float g, float b, float a) = 0;
 	virtual void texture_clearDepthSlice(LatteTexture* hostTexture, uint32 sliceIndex, sint32 mipIndex, bool clearDepth, bool clearStencil, float depthValue, uint32 stencilValue) = 0;
 
-	virtual LatteTexture* texture_createTextureEx(uint32 textureUnit, Latte::E_DIM dim, MPTR physAddress, MPTR physMipAddress, Latte::E_GX2SURFFMT format, uint32 width, uint32 height, uint32 depth, uint32 pitch, uint32 mipLevels, uint32 swizzle, Latte::E_HWTILEMODE tileMode, bool isDepth) = 0;
+	virtual LatteTexture* texture_createTextureEx(Latte::E_DIM dim, MPTR physAddress, MPTR physMipAddress, Latte::E_GX2SURFFMT format, uint32 width, uint32 height, uint32 depth, uint32 pitch, uint32 mipLevels, uint32 swizzle, Latte::E_HWTILEMODE tileMode, bool isDepth) = 0;
 
-	virtual void texture_bindAndActivate(LatteTextureView* textureView, uint32 textureUnit) = 0;
-	virtual void texture_bindAndActivateRawTex(LatteTexture* texture, uint32 textureUnit) = 0;
-	virtual void texture_bindOnly(LatteTextureView* textureView, uint32 textureUnit) = 0;
-	virtual void texture_rememberBoundTexture(uint32 textureUnit) = 0;
-	virtual void texture_restoreBoundTexture(uint32 textureUnit) = 0;
+	virtual void texture_setLatteTexture(LatteTextureView* textureView, uint32 textureUnit) = 0;
 	virtual void texture_copyImageSubData(LatteTexture* src, sint32 srcMip, sint32 effectiveSrcX, sint32 effectiveSrcY, sint32 srcSlice, LatteTexture* dst, sint32 dstMip, sint32 effectiveDstX, sint32 effectiveDstY, sint32 dstSlice, sint32 effectiveCopyWidth, sint32 effectiveCopyHeight, sint32 srcDepth) = 0;
 
 	virtual LatteTextureReadbackInfo* texture_createReadback(LatteTextureView* textureView) = 0;
@@ -132,8 +126,6 @@ public:
 
 	// shader
 	virtual RendererShader* shader_create(RendererShader::ShaderType type, uint64 baseHash, uint64 auxHash, const std::string& source, bool compileAsync, bool isGfxPackSource) = 0;
-	virtual void shader_bind(RendererShader* shader) = 0;
-	virtual void shader_unbind(RendererShader::ShaderType shaderType) = 0;
 
 	// streamout
 	virtual void streamout_setupXfbBuffer(uint32 bufferIndex, sint32 ringBufferOffset, uint32 rangeAddr, uint32 rangeSize) = 0;
@@ -146,8 +138,15 @@ public:
 	virtual void draw_endSequence() = 0;
 
 	// index
-	virtual void* indexData_reserveIndexMemory(uint32 size, uint32& offset, uint32& bufferIndex) = 0;
-	virtual void indexData_uploadIndexMemory(uint32 offset, uint32 size) = 0;
+	struct IndexAllocation
+	{
+		void* mem; // pointer to index data inside buffer
+		void* rendererInternal; // for renderer use
+	};
+
+	virtual IndexAllocation indexData_reserveIndexMemory(uint32 size) = 0;
+	virtual void indexData_releaseIndexMemory(IndexAllocation& allocation) = 0;
+	virtual void indexData_uploadIndexMemory(IndexAllocation& allocation) = 0;
 
 	// occlusion queries
 	virtual LatteQueryObject* occlusionQuery_create() = 0;
@@ -171,9 +170,14 @@ protected:
 	ScreenshotState m_screenshot_state = ScreenshotState::None;
 	void SaveScreenshot(const std::vector<uint8>& rgb_data, int width, int height, bool mainWindow) const;
 
+
+	ImFontAtlas* imguiFontAtlas{};
+	ImGuiContext* imguiTVContext{};
+	ImGuiContext* imguiPadContext{};
+
 #if BOOST_OS_WINDOWS
 	std::unique_ptr<DXGIWrapper> m_dxgi_wrapper{};
 #endif
 };
 
-extern std::unique_ptr<Renderer> g_renderer;
\ No newline at end of file
+extern std::unique_ptr<Renderer> g_renderer;
diff --git a/src/Cafe/HW/Latte/Renderer/RendererOuputShader.cpp b/src/Cafe/HW/Latte/Renderer/RendererOuputShader.cpp
index 1f214802..afe53a16 100644
--- a/src/Cafe/HW/Latte/Renderer/RendererOuputShader.cpp
+++ b/src/Cafe/HW/Latte/Renderer/RendererOuputShader.cpp
@@ -2,18 +2,7 @@
 #include "Cafe/HW/Latte/Renderer/OpenGL/OpenGLRenderer.h"
 
 const std::string RendererOutputShader::s_copy_shader_source =
-R"(#version 420
-
-#ifdef VULKAN
-layout(location = 0) in vec2 passUV;
-layout(binding = 0) uniform sampler2D textureSrc;
-layout(location = 0) out vec4 colorOut0;
-#else
-in vec2 passUV;
-layout(binding=0) uniform sampler2D textureSrc;
-layout(location = 0) out vec4 colorOut0;
-#endif
-
+R"(
 void main()
 {
 	colorOut0 = vec4(texture(textureSrc, passUV).rgb,1.0);
@@ -22,20 +11,6 @@ void main()
 
 const std::string RendererOutputShader::s_bicubic_shader_source =
 R"(
-#version 420
-
-#ifdef VULKAN
-layout(location = 0) in vec2 passUV;
-layout(binding = 0)  uniform sampler2D textureSrc;
-layout(binding = 1)  uniform vec2 textureSrcResolution;
-layout(location = 0) out vec4 colorOut0;
-#else
-in vec2 passUV;
-layout(binding=0) uniform sampler2D textureSrc;
-uniform vec2 textureSrcResolution;
-layout(location = 0) out vec4 colorOut0;
-#endif
-
 vec4 cubic(float x)
 {
 	float x2 = x * x;
@@ -48,24 +23,23 @@ vec4 cubic(float x)
 	return w / 6.0;
 }
 
-vec4 bcFilter(vec2 texcoord, vec2 texscale)
+vec4 bcFilter(vec2 uv, vec4 texelSize)
 {
-	float fx = fract(texcoord.x);
-	float fy = fract(texcoord.y);
-	texcoord.x -= fx;
-	texcoord.y -= fy;
+	vec2 pixel = uv*texelSize.zw - 0.5;
+	vec2 pixelFrac = fract(pixel);
+	vec2 pixelInt = pixel - pixelFrac;
 
-	vec4 xcubic = cubic(fx);
-	vec4 ycubic = cubic(fy);
+	vec4 xcubic = cubic(pixelFrac.x);
+	vec4 ycubic = cubic(pixelFrac.y);
 
-	vec4 c = vec4(texcoord.x - 0.5, texcoord.x + 1.5, texcoord.y - 0.5, texcoord.y + 1.5);
+	vec4 c = vec4(pixelInt.x - 0.5, pixelInt.x + 1.5, pixelInt.y - 0.5, pixelInt.y + 1.5);
 	vec4 s = vec4(xcubic.x + xcubic.y, xcubic.z + xcubic.w, ycubic.x + ycubic.y, ycubic.z + ycubic.w);
 	vec4 offset = c + vec4(xcubic.y, xcubic.w, ycubic.y, ycubic.w) / s;
 
-	vec4 sample0 = texture(textureSrc, vec2(offset.x, offset.z) * texscale);
-	vec4 sample1 = texture(textureSrc, vec2(offset.y, offset.z) * texscale);
-	vec4 sample2 = texture(textureSrc, vec2(offset.x, offset.w) * texscale);
-	vec4 sample3 = texture(textureSrc, vec2(offset.y, offset.w) * texscale);
+	vec4 sample0 = texture(textureSrc, vec2(offset.x, offset.z) * texelSize.xy);
+	vec4 sample1 = texture(textureSrc, vec2(offset.y, offset.z) * texelSize.xy);
+	vec4 sample2 = texture(textureSrc, vec2(offset.x, offset.w) * texelSize.xy);
+	vec4 sample3 = texture(textureSrc, vec2(offset.y, offset.w) * texelSize.xy);
 
 	float sx = s.x / (s.x + s.y);
 	float sy = s.z / (s.z + s.w);
@@ -76,20 +50,13 @@ vec4 bcFilter(vec2 texcoord, vec2 texscale)
 }
 
 void main(){
-	colorOut0 = vec4(bcFilter(passUV*textureSrcResolution, vec2(1.0,1.0)/textureSrcResolution).rgb,1.0);
+	vec4 texelSize = vec4( 1.0 / textureSrcResolution.xy, textureSrcResolution.xy);
+	colorOut0 = vec4(bcFilter(passUV, texelSize).rgb,1.0);
 }
 )";
 
 const std::string RendererOutputShader::s_hermite_shader_source =
-R"(#version 420
-
-in vec4 gl_FragCoord;	
-in vec2 passUV;
-layout(binding=0) uniform sampler2D textureSrc;
-uniform vec2 textureSrcResolution;
-uniform vec2 outputResolution;
-layout(location = 0) out vec4 colorOut0;
-
+R"(
 // https://www.shadertoy.com/view/MllSzX
 
 vec3 CubicHermite (vec3 A, vec3 B, vec3 C, vec3 D, float t)
@@ -111,7 +78,7 @@ vec3 BicubicHermiteTexture(vec2 uv, vec4 texelSize)
 	vec2 frac = fract(pixel);	
     pixel = floor(pixel) / texelSize.zw - vec2(texelSize.xy/2.0);
 	
-	vec4 doubleSize = texelSize*texelSize;
+	vec4 doubleSize = texelSize*2.0;
 
 	vec3 C00 = texture(textureSrc, pixel + vec2(-texelSize.x ,-texelSize.y)).rgb;
     vec3 C10 = texture(textureSrc, pixel + vec2( 0.0        ,-texelSize.y)).rgb;
@@ -142,15 +109,17 @@ vec3 BicubicHermiteTexture(vec2 uv, vec4 texelSize)
 }
 
 void main(){
-	vec4 texelSize = vec4( 1.0 / outputResolution.xy, outputResolution.xy);
+	vec4 texelSize = vec4( 1.0 / textureSrcResolution.xy, textureSrcResolution.xy);
 	colorOut0 = vec4(BicubicHermiteTexture(passUV, texelSize), 1.0);
 }
 )";
 
 RendererOutputShader::RendererOutputShader(const std::string& vertex_source, const std::string& fragment_source)
 {
-	m_vertex_shader = g_renderer->shader_create(RendererShader::ShaderType::kVertex, 0, 0, vertex_source, false, false);
-	m_fragment_shader = g_renderer->shader_create(RendererShader::ShaderType::kFragment, 0, 0, fragment_source, false, false);
+	auto finalFragmentSrc = PrependFragmentPreamble(fragment_source);
+
+	m_vertex_shader.reset(g_renderer->shader_create(RendererShader::ShaderType::kVertex, 0, 0, vertex_source, false, false));
+	m_fragment_shader.reset(g_renderer->shader_create(RendererShader::ShaderType::kFragment, 0, 0, finalFragmentSrc, false, false));
 
 	m_vertex_shader->PreponeCompilation(true);
 	m_fragment_shader->PreponeCompilation(true);
@@ -163,80 +132,45 @@ RendererOutputShader::RendererOutputShader(const std::string& vertex_source, con
 
 	if (g_renderer->GetType() == RendererAPI::OpenGL)
 	{
-		m_attributes[0].m_loc_texture_src_resolution = m_vertex_shader->GetUniformLocation("textureSrcResolution");
-		m_attributes[0].m_loc_input_resolution = m_vertex_shader->GetUniformLocation("inputResolution");
-		m_attributes[0].m_loc_output_resolution = m_vertex_shader->GetUniformLocation("outputResolution");
+		m_uniformLocations[0].m_loc_textureSrcResolution = m_vertex_shader->GetUniformLocation("textureSrcResolution");
+		m_uniformLocations[0].m_loc_nativeResolution = m_vertex_shader->GetUniformLocation("nativeResolution");
+		m_uniformLocations[0].m_loc_outputResolution = m_vertex_shader->GetUniformLocation("outputResolution");
 
-		m_attributes[1].m_loc_texture_src_resolution = m_fragment_shader->GetUniformLocation("textureSrcResolution");
-		m_attributes[1].m_loc_input_resolution = m_fragment_shader->GetUniformLocation("inputResolution");
-		m_attributes[1].m_loc_output_resolution = m_fragment_shader->GetUniformLocation("outputResolution");
-	}
-	else
-	{
-		forceLogDebug_printf("RendererOutputShader() - todo for Vulkan");
-		m_attributes[0].m_loc_texture_src_resolution = -1;
-		m_attributes[0].m_loc_input_resolution = -1;
-		m_attributes[0].m_loc_output_resolution = -1;
-
-		m_attributes[1].m_loc_texture_src_resolution = -1;
-		m_attributes[1].m_loc_input_resolution = -1;
-		m_attributes[1].m_loc_output_resolution = -1;
-	}
-
-}
-
-void RendererOutputShader::SetUniformParameters(const LatteTextureView& texture_view, const Vector2i& input_res, const Vector2i& output_res) const
-{
-	float res[2];
-	// vertex shader
-	if (m_attributes[0].m_loc_texture_src_resolution != -1)
-	{ 
-		res[0] = (float)texture_view.baseTexture->width;
-		res[1] = (float)texture_view.baseTexture->height;
-		m_vertex_shader->SetUniform2fv(m_attributes[0].m_loc_texture_src_resolution, res, 1);
-	}
-
-	if (m_attributes[0].m_loc_input_resolution != -1)
-	{
-		res[0] = (float)input_res.x;
-		res[1] = (float)input_res.y;
-		m_vertex_shader->SetUniform2fv(m_attributes[0].m_loc_input_resolution, res, 1);
-	}
-
-	if (m_attributes[0].m_loc_output_resolution != -1)
-	{
-		res[0] = (float)output_res.x;
-		res[1] = (float)output_res.y;
-		m_vertex_shader->SetUniform2fv(m_attributes[0].m_loc_output_resolution, res, 1);
-	}
-
-	// fragment shader
-	if (m_attributes[1].m_loc_texture_src_resolution != -1)
-	{
-		res[0] = (float)texture_view.baseTexture->width;
-		res[1] = (float)texture_view.baseTexture->height;
-		m_fragment_shader->SetUniform2fv(m_attributes[1].m_loc_texture_src_resolution, res, 1);
-	}
-
-	if (m_attributes[1].m_loc_input_resolution != -1)
-	{
-		res[0] = (float)input_res.x;
-		res[1] = (float)input_res.y;
-		m_fragment_shader->SetUniform2fv(m_attributes[1].m_loc_input_resolution, res, 1);
-	}
-
-	if (m_attributes[1].m_loc_output_resolution != -1)
-	{
-		res[0] = (float)output_res.x;
-		res[1] = (float)output_res.y;
-		m_fragment_shader->SetUniform2fv(m_attributes[1].m_loc_output_resolution, res, 1);
+		m_uniformLocations[1].m_loc_textureSrcResolution = m_fragment_shader->GetUniformLocation("textureSrcResolution");
+		m_uniformLocations[1].m_loc_nativeResolution = m_fragment_shader->GetUniformLocation("nativeResolution");
+		m_uniformLocations[1].m_loc_outputResolution = m_fragment_shader->GetUniformLocation("outputResolution");
 	}
 }
 
-void RendererOutputShader::Bind() const
+void RendererOutputShader::SetUniformParameters(const LatteTextureView& texture_view, const Vector2i& output_res) const
 {
-	g_renderer->shader_bind(m_vertex_shader);
-	g_renderer->shader_bind(m_fragment_shader);
+	sint32 effectiveWidth, effectiveHeight;
+	texture_view.baseTexture->GetEffectiveSize(effectiveWidth, effectiveHeight, 0);
+	auto setUniforms = [&](RendererShader* shader, const UniformLocations& locations){
+	  float res[2];
+	  if (locations.m_loc_textureSrcResolution != -1)
+	  {
+		  res[0] = (float)effectiveWidth;
+		  res[1] = (float)effectiveHeight;
+		  shader->SetUniform2fv(locations.m_loc_textureSrcResolution, res, 1);
+	  }
+
+	  if (locations.m_loc_nativeResolution != -1)
+	  {
+		  res[0] = (float)texture_view.baseTexture->width;
+		  res[1] = (float)texture_view.baseTexture->height;
+		  shader->SetUniform2fv(locations.m_loc_nativeResolution, res, 1);
+	  }
+
+	  if (locations.m_loc_outputResolution != -1)
+	  {
+		  res[0] = (float)output_res.x;
+		  res[1] = (float)output_res.y;
+		  shader->SetUniform2fv(locations.m_loc_outputResolution, res, 1);
+	  }
+	};
+	setUniforms(m_vertex_shader.get(), m_uniformLocations[0]);
+	setUniforms(m_fragment_shader.get(), m_uniformLocations[1]);
 }
 
 RendererOutputShader* RendererOutputShader::s_copy_shader;
@@ -253,8 +187,8 @@ std::string RendererOutputShader::GetOpenGlVertexSource(bool render_upside_down)
 	// vertex shader
 	std::ostringstream vertex_source;
 		vertex_source <<
-			R"(#version 400
-out vec2 passUV;
+			R"(#version 420
+layout(location = 0) smooth out vec2 passUV;
 
 out gl_PerVertex 
 { 
@@ -347,6 +281,27 @@ void main(){
 )";
 		return vertex_source.str();
 }
+
+std::string RendererOutputShader::PrependFragmentPreamble(const std::string& shaderSrc)
+{
+	return R"(#version 430
+#ifdef VULKAN
+layout(push_constant) uniform pc {
+	vec2 textureSrcResolution;
+	vec2 nativeResolution;
+	vec2 outputResolution;
+};
+#else
+uniform vec2 textureSrcResolution;
+uniform vec2 nativeResolution;
+uniform vec2 outputResolution;
+#endif
+
+layout(location = 0) smooth in vec2 passUV;
+layout(binding = 0) uniform sampler2D textureSrc;
+layout(location = 0) out vec4 colorOut0;
+)" + shaderSrc;
+}
 void RendererOutputShader::InitializeStatic()
 {
 	std::string vertex_source, vertex_source_ud;
@@ -355,28 +310,30 @@ void RendererOutputShader::InitializeStatic()
 	{
 		vertex_source = GetOpenGlVertexSource(false);
 		vertex_source_ud = GetOpenGlVertexSource(true);
-
-		s_copy_shader = new RendererOutputShader(vertex_source, s_copy_shader_source);
-		s_copy_shader_ud = new RendererOutputShader(vertex_source_ud, s_copy_shader_source);
-
-		s_bicubic_shader = new RendererOutputShader(vertex_source, s_bicubic_shader_source);
-		s_bicubic_shader_ud = new RendererOutputShader(vertex_source_ud, s_bicubic_shader_source);
-
-		s_hermit_shader = new RendererOutputShader(vertex_source, s_hermite_shader_source);
-		s_hermit_shader_ud = new RendererOutputShader(vertex_source_ud, s_hermite_shader_source);
 	}
 	else
 	{
 		vertex_source = GetVulkanVertexSource(false);
 		vertex_source_ud = GetVulkanVertexSource(true);
-
-		s_copy_shader = new RendererOutputShader(vertex_source, s_copy_shader_source);
-		s_copy_shader_ud = new RendererOutputShader(vertex_source_ud, s_copy_shader_source);
-
-	/*	s_bicubic_shader = new RendererOutputShader(vertex_source, s_bicubic_shader_source); TODO
-		s_bicubic_shader_ud = new RendererOutputShader(vertex_source_ud, s_bicubic_shader_source);
-
-		s_hermit_shader = new RendererOutputShader(vertex_source, s_hermite_shader_source);
-		s_hermit_shader_ud = new RendererOutputShader(vertex_source_ud, s_hermite_shader_source);*/
 	}
+	s_copy_shader = new RendererOutputShader(vertex_source, s_copy_shader_source);
+	s_copy_shader_ud = new RendererOutputShader(vertex_source_ud, s_copy_shader_source);
+
+	s_bicubic_shader = new RendererOutputShader(vertex_source, s_bicubic_shader_source);
+	s_bicubic_shader_ud = new RendererOutputShader(vertex_source_ud, s_bicubic_shader_source);
+
+	s_hermit_shader = new RendererOutputShader(vertex_source, s_hermite_shader_source);
+	s_hermit_shader_ud = new RendererOutputShader(vertex_source_ud, s_hermite_shader_source);
+}
+
+void RendererOutputShader::ShutdownStatic()
+{
+	delete s_copy_shader;
+	delete s_copy_shader_ud;
+
+	delete s_bicubic_shader;
+	delete s_bicubic_shader_ud;
+
+	delete s_hermit_shader;
+	delete s_hermit_shader_ud;
 }
diff --git a/src/Cafe/HW/Latte/Renderer/RendererOuputShader.h b/src/Cafe/HW/Latte/Renderer/RendererOuputShader.h
index 253990e2..b12edf8b 100644
--- a/src/Cafe/HW/Latte/Renderer/RendererOuputShader.h
+++ b/src/Cafe/HW/Latte/Renderer/RendererOuputShader.h
@@ -17,20 +17,20 @@ public:
 	RendererOutputShader(const std::string& vertex_source, const std::string& fragment_source);
 	virtual ~RendererOutputShader() = default;
 
-	void SetUniformParameters(const LatteTextureView& texture_view, const Vector2i& input_res, const Vector2i& output_res) const;
-	void Bind() const;
+	void SetUniformParameters(const LatteTextureView& texture_view, const Vector2i& output_res) const;
 
 	RendererShader* GetVertexShader() const
 	{
-		return m_vertex_shader;
+		return m_vertex_shader.get();
 	}
 
 	RendererShader* GetFragmentShader() const
 	{
-		return m_fragment_shader;
+		return m_fragment_shader.get();
 	}
 
 	static void InitializeStatic();
+	static void ShutdownStatic();
 
 	static RendererOutputShader* s_copy_shader;
 	static RendererOutputShader* s_copy_shader_ud;
@@ -44,16 +44,18 @@ public:
 	static std::string GetVulkanVertexSource(bool render_upside_down);
 	static std::string GetOpenGlVertexSource(bool render_upside_down);
 
-protected:
-	RendererShader* m_vertex_shader;
-	RendererShader* m_fragment_shader;
+	static std::string PrependFragmentPreamble(const std::string& shaderSrc);
 
-	struct
+protected:
+	std::unique_ptr<RendererShader> m_vertex_shader;
+	std::unique_ptr<RendererShader> m_fragment_shader;
+
+	struct UniformLocations
 	{
-		sint32 m_loc_texture_src_resolution = -1;
-		sint32 m_loc_input_resolution = -1;
-		sint32 m_loc_output_resolution = -1;
-	} m_attributes[2]{};
+		sint32 m_loc_textureSrcResolution = -1;
+		sint32 m_loc_nativeResolution = -1;
+		sint32 m_loc_outputResolution = -1;
+	} m_uniformLocations[2]{};
 
 private:
 	static const std::string s_copy_shader_source;
diff --git a/src/Cafe/HW/Latte/Renderer/RendererShader.cpp b/src/Cafe/HW/Latte/Renderer/RendererShader.cpp
index 67b76b4e..23c8d0ea 100644
--- a/src/Cafe/HW/Latte/Renderer/RendererShader.cpp
+++ b/src/Cafe/HW/Latte/Renderer/RendererShader.cpp
@@ -12,12 +12,12 @@ uint32 RendererShader::GeneratePrecompiledCacheId()
 		v += (uint32)(*s);
 		s++;
 	}
-	v += (EMULATOR_VERSION_LEAD * 1000000u);
-	v += (EMULATOR_VERSION_MAJOR * 10000u);
-	v += (EMULATOR_VERSION_MINOR * 100u);
+	v += (EMULATOR_VERSION_MAJOR * 1000000u);
+	v += (EMULATOR_VERSION_MINOR * 10000u);
+	v += (EMULATOR_VERSION_PATCH * 100u);
 
 	// settings that can influence shaders
-	v += (uint32)g_current_game_profile->GetAccurateShaderMul() * 133; // this option modifies shaders
+	v += (uint32)g_current_game_profile->GetAccurateShaderMul() * 133;
 
 	return v;
 }
diff --git a/src/Cafe/HW/Latte/Renderer/RendererShader.h b/src/Cafe/HW/Latte/Renderer/RendererShader.h
index 1c15211f..e3f254c6 100644
--- a/src/Cafe/HW/Latte/Renderer/RendererShader.h
+++ b/src/Cafe/HW/Latte/Renderer/RendererShader.h
@@ -19,8 +19,7 @@ public:
 	virtual bool WaitForCompiled() = 0;
 
 	virtual sint32 GetUniformLocation(const char* name) = 0;
-	
-	virtual void SetUniform1iv(sint32 location, void* data, sint32 count) = 0;
+
 	virtual void SetUniform2fv(sint32 location, void* data, sint32 count) = 0;
 	virtual void SetUniform4iv(sint32 location, void* data, sint32 count) = 0;
 
diff --git a/src/Cafe/HW/Latte/Renderer/Vulkan/CachedFBOVk.cpp b/src/Cafe/HW/Latte/Renderer/Vulkan/CachedFBOVk.cpp
index 66f7ba95..8a999000 100644
--- a/src/Cafe/HW/Latte/Renderer/Vulkan/CachedFBOVk.cpp
+++ b/src/Cafe/HW/Latte/Renderer/Vulkan/CachedFBOVk.cpp
@@ -44,9 +44,9 @@ CachedFBOVk::~CachedFBOVk()
 	while (!m_usedByPipelines.empty())
 		delete m_usedByPipelines[0];
 	auto vkr = VulkanRenderer::GetInstance();
-	vkr->releaseDestructibleObject(m_vkrObjFramebuffer);
+	vkr->ReleaseDestructibleObject(m_vkrObjFramebuffer);
 	m_vkrObjFramebuffer = nullptr;
-	vkr->releaseDestructibleObject(m_vkrObjRenderPass);
+	vkr->ReleaseDestructibleObject(m_vkrObjRenderPass);
 	m_vkrObjRenderPass = nullptr;
 }
 
diff --git a/src/Cafe/HW/Latte/Renderer/Vulkan/CachedFBOVk.h b/src/Cafe/HW/Latte/Renderer/Vulkan/CachedFBOVk.h
index b83bd96c..bf72996e 100644
--- a/src/Cafe/HW/Latte/Renderer/Vulkan/CachedFBOVk.h
+++ b/src/Cafe/HW/Latte/Renderer/Vulkan/CachedFBOVk.h
@@ -37,16 +37,16 @@ public:
 
 	void TrackDependency(class PipelineInfo* pipelineInfo)
 	{
-		s_spinlockDependency.acquire();
+		s_spinlockDependency.lock();
 		m_usedByPipelines.emplace_back(pipelineInfo);
-		s_spinlockDependency.release();
+		s_spinlockDependency.unlock();
 	}
 
 	void RemoveDependency(class PipelineInfo* pipelineInfo)
 	{
-		s_spinlockDependency.acquire();
+		s_spinlockDependency.lock();
 		vectorRemoveByValue(m_usedByPipelines, pipelineInfo);
-		s_spinlockDependency.release();
+		s_spinlockDependency.unlock();
 	}
 
 	[[nodiscard]] const VkExtent2D& GetExtend() const { return m_extend;}
@@ -75,10 +75,6 @@ private:
 	VkRenderingAttachmentInfoKHR m_vkColorAttachments[8];
 	VkRenderingAttachmentInfoKHR m_vkDepthAttachment;
 	VkRenderingAttachmentInfoKHR m_vkStencilAttachment;
-	//uint8 m_vkColorAttachmentsCount{0};
-	bool m_vkHasDepthAttachment{ false };
-	bool m_vkHasStencilAttachment{ false };
-
 
 	std::vector<class PipelineInfo*> m_usedByPipelines; // PipelineInfo objects which use this renderpass/framebuffer
 };
diff --git a/src/Cafe/HW/Latte/Renderer/Vulkan/CocoaSurface.mm b/src/Cafe/HW/Latte/Renderer/Vulkan/CocoaSurface.mm
index 0dc3b3ec..731a6a26 100644
--- a/src/Cafe/HW/Latte/Renderer/Vulkan/CocoaSurface.mm
+++ b/src/Cafe/HW/Latte/Renderer/Vulkan/CocoaSurface.mm
@@ -13,8 +13,23 @@
 
 +(Class) layerClass { return [CAMetalLayer class]; }
 
--(CALayer*) makeBackingLayer { return [self.class.layerClass layer]; }
+// copied from https://github.com/KhronosGroup/MoltenVK/blob/master/Demos/Cube/macOS/DemoViewController.m
 
+-(CALayer*) makeBackingLayer
+{
+	CALayer* layer = [self.class.layerClass layer];
+	CGSize viewScale = [self convertSizeToBacking: CGSizeMake(1.0, 1.0)];
+	layer.contentsScale = MIN(viewScale.width, viewScale.height);
+	return layer;
+}
+
+-(BOOL) layer: (CALayer *)layer shouldInheritContentsScale: (CGFloat)newScale fromWindow: (NSWindow *)window
+{
+	if (newScale == layer.contentsScale) { return NO; }
+
+	layer.contentsScale = newScale;
+	return YES;
+}
 @end
 
 VkSurfaceKHR CreateCocoaSurface(VkInstance instance, void* handle)
@@ -37,7 +52,7 @@ VkSurfaceKHR CreateCocoaSurface(VkInstance instance, void* handle)
 	VkResult err;
 	if ((err = vkCreateMetalSurfaceEXT(instance, &surface, nullptr, &result)) != VK_SUCCESS)
 	{
-		forceLog_printf("Cannot create a Metal Vulkan surface: %d", (sint32)err);
+		cemuLog_log(LogType::Force, "Cannot create a Metal Vulkan surface: {}", (sint32)err);
 		throw std::runtime_error(fmt::format("Cannot create a Metal Vulkan surface: {}", err));
 	}
 
diff --git a/src/Cafe/HW/Latte/Renderer/Vulkan/LatteTextureViewVk.cpp b/src/Cafe/HW/Latte/Renderer/Vulkan/LatteTextureViewVk.cpp
index 62382290..de76f76d 100644
--- a/src/Cafe/HW/Latte/Renderer/Vulkan/LatteTextureViewVk.cpp
+++ b/src/Cafe/HW/Latte/Renderer/Vulkan/LatteTextureViewVk.cpp
@@ -57,7 +57,12 @@ uint32 LatteTextureVk_AdjustTextureCompSel(Latte::E_GX2SURFFMT format, uint32 co
 LatteTextureViewVk::LatteTextureViewVk(VkDevice device, LatteTextureVk* texture, Latte::E_DIM dim, Latte::E_GX2SURFFMT format, sint32 firstMip, sint32 mipCount, sint32 firstSlice, sint32 sliceCount)
 	: LatteTextureView(texture, firstMip, mipCount, firstSlice, sliceCount, dim, format), m_device(device)
 {
-	if (dim != texture->dim || format != texture->format)
+	if(texture->overwriteInfo.hasFormatOverwrite)
+	{
+		cemu_assert_debug(format == texture->format); // if format overwrite is used, the texture is no longer taking part in aliasing and the format of any view has to match
+		m_format = texture->GetFormat();
+	}
+	else if (dim != texture->dim || format != texture->format)
 	{
 		VulkanRenderer::FormatInfoVK texFormatInfo;
 		VulkanRenderer::GetInstance()->GetTextureFormatInfoVK(format, texture->isDepth, dim, 0, 0, &texFormatInfo);
@@ -74,14 +79,14 @@ LatteTextureViewVk::~LatteTextureViewVk()
 		delete list_descriptorSets[0];
 
 	if (m_smallCacheView0)
-		VulkanRenderer::GetInstance()->releaseDestructibleObject(m_smallCacheView0);
+		VulkanRenderer::GetInstance()->ReleaseDestructibleObject(m_smallCacheView0);
 	if (m_smallCacheView1)
-		VulkanRenderer::GetInstance()->releaseDestructibleObject(m_smallCacheView1);
+		VulkanRenderer::GetInstance()->ReleaseDestructibleObject(m_smallCacheView1);
 
 	if (m_fallbackCache)
 	{
 		for (auto& itr : *m_fallbackCache)
-			VulkanRenderer::GetInstance()->releaseDestructibleObject(itr.second);
+			VulkanRenderer::GetInstance()->ReleaseDestructibleObject(itr.second);
 		delete m_fallbackCache;
 		m_fallbackCache = nullptr;
 	}
@@ -197,6 +202,13 @@ VkSampler LatteTextureViewVk::GetDefaultTextureSampler(bool useLinearTexFilter)
 	VkSamplerCreateInfo samplerInfo{};
 	samplerInfo.sType = VK_STRUCTURE_TYPE_SAMPLER_CREATE_INFO;
 
+	// emulate OpenGL minFilters
+	// see note under: https://docs.vulkan.org/spec/latest/chapters/samplers.html#VkSamplerCreateInfo
+	// if maxLod = 0 then magnification is always performed
+	samplerInfo.mipmapMode = VK_SAMPLER_MIPMAP_MODE_NEAREST;
+	samplerInfo.minLod = 0.0f;
+	samplerInfo.maxLod = 0.25f;
+
 	if (useLinearTexFilter)
 	{
 		samplerInfo.magFilter = VK_FILTER_LINEAR;
@@ -207,10 +219,13 @@ VkSampler LatteTextureViewVk::GetDefaultTextureSampler(bool useLinearTexFilter)
 		samplerInfo.magFilter = VK_FILTER_NEAREST;
 		samplerInfo.minFilter = VK_FILTER_NEAREST;
 	}
+	samplerInfo.addressModeU = VK_SAMPLER_ADDRESS_MODE_CLAMP_TO_EDGE;
+	samplerInfo.addressModeV = VK_SAMPLER_ADDRESS_MODE_CLAMP_TO_EDGE;
+	samplerInfo.addressModeW = VK_SAMPLER_ADDRESS_MODE_CLAMP_TO_EDGE;
 
 	if (vkCreateSampler(m_device, &samplerInfo, nullptr, &sampler) != VK_SUCCESS)
 	{
-		forceLog_printf("Failed to create default sampler");
+		cemuLog_log(LogType::Force, "Failed to create default sampler");
 		throw std::runtime_error("failed to create texture sampler!");
 	}
 
@@ -236,4 +251,4 @@ VkImageViewType LatteTextureViewVk::GetImageViewTypeFromGX2Dim(Latte::E_DIM dim)
 		cemu_assert_unimplemented();
 	}
 	return VK_IMAGE_VIEW_TYPE_2D;
-}
\ No newline at end of file
+}
diff --git a/src/Cafe/HW/Latte/Renderer/Vulkan/LatteTextureVk.cpp b/src/Cafe/HW/Latte/Renderer/Vulkan/LatteTextureVk.cpp
index b41760bc..a62741e4 100644
--- a/src/Cafe/HW/Latte/Renderer/Vulkan/LatteTextureVk.cpp
+++ b/src/Cafe/HW/Latte/Renderer/Vulkan/LatteTextureVk.cpp
@@ -3,9 +3,9 @@
 #include "Cafe/HW/Latte/Renderer/Vulkan/VulkanRenderer.h"
 #include "Cafe/HW/Latte/Renderer/Vulkan/VulkanAPI.h"
 
-LatteTextureVk::LatteTextureVk(class VulkanRenderer* vkRenderer, uint32 textureUnit, Latte::E_DIM dim, MPTR physAddress, MPTR physMipAddress, Latte::E_GX2SURFFMT format, uint32 width, uint32 height, uint32 depth, uint32 pitch, uint32 mipLevels, uint32 swizzle,
+LatteTextureVk::LatteTextureVk(class VulkanRenderer* vkRenderer, Latte::E_DIM dim, MPTR physAddress, MPTR physMipAddress, Latte::E_GX2SURFFMT format, uint32 width, uint32 height, uint32 depth, uint32 pitch, uint32 mipLevels, uint32 swizzle,
 	Latte::E_HWTILEMODE tileMode, bool isDepth)
-	: LatteTexture(textureUnit, dim, physAddress, physMipAddress, format, width, height, depth, pitch, mipLevels, swizzle, tileMode, isDepth), m_vkr(vkRenderer)
+	: LatteTexture(dim, physAddress, physMipAddress, format, width, height, depth, pitch, mipLevels, swizzle, tileMode, isDepth), m_vkr(vkRenderer)
 {
 	vkObjTex = new VKRObjectTexture();
 
@@ -46,7 +46,7 @@ LatteTextureVk::LatteTextureVk(class VulkanRenderer* vkRenderer, uint32 textureU
 	
 	VulkanRenderer::FormatInfoVK texFormatInfo;
 	vkRenderer->GetTextureFormatInfoVK(format, isDepth, dim, effectiveBaseWidth, effectiveBaseHeight, &texFormatInfo);
-	hasStencil = (texFormatInfo.vkImageAspect & VK_IMAGE_ASPECT_STENCIL_BIT) != 0;
+	cemu_assert_debug(hasStencil == ((texFormatInfo.vkImageAspect & VK_IMAGE_ASPECT_STENCIL_BIT) != 0));
 	imageInfo.format = texFormatInfo.vkImageFormat;
 	vkObjTex->m_imageAspect = texFormatInfo.vkImageAspect;
 	
@@ -117,7 +117,7 @@ LatteTextureVk::~LatteTextureVk()
 
 	m_vkr->surfaceCopy_notifyTextureRelease(this);
 
-	VulkanRenderer::GetInstance()->releaseDestructibleObject(vkObjTex);
+	VulkanRenderer::GetInstance()->ReleaseDestructibleObject(vkObjTex);
 	vkObjTex = nullptr;
 }
 
@@ -130,12 +130,8 @@ LatteTextureView* LatteTextureVk::CreateView(Latte::E_DIM dim, Latte::E_GX2SURFF
 	return new LatteTextureViewVk(m_vkr->GetLogicalDevice(), this, dim, format, firstMip, mipCount, firstSlice, sliceCount);
 }
 
-void LatteTextureVk::setAllocation(struct VkImageMemAllocation* memAllocation)
+void LatteTextureVk::AllocateOnHost()
 {
-	vkObjTex->m_allocation = memAllocation;
-}
-
-struct VkImageMemAllocation* LatteTextureVk::getAllocation() const
-{
-	return vkObjTex->m_allocation;
+	auto allocationInfo = VulkanRenderer::GetInstance()->GetMemoryManager()->imageMemoryAllocate(GetImageObj()->m_image);
+	vkObjTex->m_allocation = allocationInfo;
 }
diff --git a/src/Cafe/HW/Latte/Renderer/Vulkan/LatteTextureVk.h b/src/Cafe/HW/Latte/Renderer/Vulkan/LatteTextureVk.h
index 2131ed9c..612e2e70 100644
--- a/src/Cafe/HW/Latte/Renderer/Vulkan/LatteTextureVk.h
+++ b/src/Cafe/HW/Latte/Renderer/Vulkan/LatteTextureVk.h
@@ -9,19 +9,18 @@
 class LatteTextureVk : public LatteTexture
 {
 public:
-	LatteTextureVk(class VulkanRenderer* vkRenderer, uint32 textureUnit, Latte::E_DIM dim, MPTR physAddress, MPTR physMipAddress, Latte::E_GX2SURFFMT format, uint32 width, uint32 height, uint32 depth, uint32 pitch, uint32 mipLevels,
+	LatteTextureVk(class VulkanRenderer* vkRenderer, Latte::E_DIM dim, MPTR physAddress, MPTR physMipAddress, Latte::E_GX2SURFFMT format, uint32 width, uint32 height, uint32 depth, uint32 pitch, uint32 mipLevels,
 		uint32 swizzle, Latte::E_HWTILEMODE tileMode, bool isDepth);
 
 	~LatteTextureVk();
 
+	void AllocateOnHost() override;
+
 	VKRObjectTexture* GetImageObj() const { return vkObjTex; };
 	
 	VkFormat GetFormat() const { return vkObjTex->m_format; }
 	VkImageAspectFlags GetImageAspect() const { return vkObjTex->m_imageAspect; }
 
-	void setAllocation(struct VkImageMemAllocation* memAllocation);
-	struct VkImageMemAllocation* getAllocation() const;
-
 	VkImageLayout GetImageLayout(VkImageSubresource& subresource)
 	{
 		cemu_assert_debug(subresource.mipLevel < m_layoutsMips);
diff --git a/src/Cafe/HW/Latte/Renderer/Vulkan/RendererShaderVk.cpp b/src/Cafe/HW/Latte/Renderer/Vulkan/RendererShaderVk.cpp
index 7af5204b..8a66c81b 100644
--- a/src/Cafe/HW/Latte/Renderer/Vulkan/RendererShaderVk.cpp
+++ b/src/Cafe/HW/Latte/Renderer/Vulkan/RendererShaderVk.cpp
@@ -1,31 +1,15 @@
 #include "Cafe/HW/Latte/Renderer/Vulkan/RendererShaderVk.h"
-
-#if __has_include(<glslang/build_info.h>)
-#include <glslang/build_info.h>
-#else
-#define GLSLANG_VERSION_LESS_OR_EQUAL_TO (false)
-#endif
-
-#include <glslang/Public/ShaderLang.h>
-#if GLSLANG_VERSION_LESS_OR_EQUAL_TO(11, 0, 0)
-#include <glslang/SPIRV/GlslangToSpv.h>
-#else
-#include <SPIRV/Logger.h>
-#include <SPIRV/GlslangToSpv.h>
-#endif
-
-
 #include "Cafe/HW/Latte/Renderer/Vulkan/VulkanAPI.h"
 #include "Cafe/HW/Latte/Renderer/Vulkan/VulkanRenderer.h"
-
-#include <thread>
-
 #include "config/ActiveSettings.h"
 #include "config/CemuConfig.h"
 #include "util/helpers/ConcurrentQueue.h"
-
 #include "Cemu/FileCache/FileCache.h"
 
+#include <glslang/Public/ShaderLang.h>
+#include <glslang/SPIRV/GlslangToSpv.h>
+#include <util/helpers/helpers.h>
+
 bool s_isLoadingShadersVk{ false };
 class FileCache* s_spirvCache{nullptr};
 
@@ -146,19 +130,18 @@ class _ShaderVkThreadPool
 public:
 	void StartThreads()
 	{
-		if (s_threads.empty())
-		{
-			// create thread pool
-			m_shutdownThread.store(false);
-			const uint32 threadCount = 2;
-			for (uint32 i = 0; i < threadCount; ++i)
-				s_threads.emplace_back(&_ShaderVkThreadPool::CompilerThreadFunc, this);
-		}
+		if (m_threadsActive.exchange(true))
+			return;
+		// create thread pool
+		const uint32 threadCount = 2;
+		for (uint32 i = 0; i < threadCount; ++i)
+			s_threads.emplace_back(&_ShaderVkThreadPool::CompilerThreadFunc, this);
 	}
 
-	~_ShaderVkThreadPool()
+	void StopThreads()
 	{
-		m_shutdownThread.store(true);
+		if (!m_threadsActive.exchange(false))
+			return;
 		for (uint32 i = 0; i < s_threads.size(); ++i)
 			s_compilationQueueCount.increment();
 		for (auto& it : s_threads)
@@ -166,9 +149,15 @@ public:
 		s_threads.clear();
 	}
 
+	~_ShaderVkThreadPool()
+	{
+		StopThreads();
+	}
+
 	void CompilerThreadFunc()
 	{
-		while (!m_shutdownThread.load(std::memory_order::relaxed))
+		SetThreadName("vkShaderComp");
+		while (m_threadsActive.load(std::memory_order::relaxed))
 		{
 			s_compilationQueueCount.decrementWithWait();
 			s_compilationQueueMutex.lock();
@@ -193,6 +182,8 @@ public:
 		}
 	}
 
+	bool HasThreadsRunning() const { return m_threadsActive; }
+
 public:
 	std::vector<std::thread> s_threads;
 
@@ -201,7 +192,7 @@ public:
 	std::mutex s_compilationQueueMutex;
 
 private:
-	std::atomic<bool> m_shutdownThread;
+	std::atomic<bool> m_threadsActive;
 }ShaderVkThreadPool;
 
 RendererShaderVk::RendererShaderVk(ShaderType type, uint64 baseHash, uint64 auxHash, bool isGameShader, bool isGfxPackShader, const std::string& glslCode)
@@ -212,13 +203,27 @@ RendererShaderVk::RendererShaderVk(ShaderType type, uint64 baseHash, uint64 auxH
 	m_compilationState.setValue(COMPILATION_STATE::QUEUED);
 	ShaderVkThreadPool.s_compilationQueue.push_back(this);
 	ShaderVkThreadPool.s_compilationQueueCount.increment();
-	ShaderVkThreadPool.StartThreads();
 	ShaderVkThreadPool.s_compilationQueueMutex.unlock();
+	cemu_assert_debug(ShaderVkThreadPool.HasThreadsRunning()); // make sure .StartThreads() was called
 }
 
 RendererShaderVk::~RendererShaderVk()
 {
-	VulkanRenderer::GetInstance()->destroyShader(this);
+	while (!list_pipelineInfo.empty())
+		delete list_pipelineInfo[0];
+
+	VkDevice vkDev = VulkanRenderer::GetInstance()->GetLogicalDevice();
+	vkDestroyShaderModule(vkDev, m_shader_module, nullptr);
+}
+
+void RendererShaderVk::Init()
+{
+	ShaderVkThreadPool.StartThreads();
+}
+
+void RendererShaderVk::Shutdown()
+{
+	ShaderVkThreadPool.StopThreads();
 }
 
 sint32 RendererShaderVk::GetUniformLocation(const char* name)
@@ -227,11 +232,6 @@ sint32 RendererShaderVk::GetUniformLocation(const char* name)
 	return 0;
 }
 
-void RendererShaderVk::SetUniform1iv(sint32 location, void* data, sint32 count)
-{
-	cemu_assert_suspicious();
-}
-
 void RendererShaderVk::SetUniform2fv(sint32 location, void* data, sint32 count)
 {
 	cemu_assert_suspicious();
@@ -256,7 +256,7 @@ void RendererShaderVk::CreateVkShaderModule(std::span<uint32> spirvBuffer)
 	VkResult result = vkCreateShaderModule(m_device, &createInfo, nullptr, &m_shader_module);
 	if (result != VK_SUCCESS)
 	{
-		forceLog_printf("Vulkan: Shader error");
+		cemuLog_log(LogType::Force, "Vulkan: Shader error");
 		throw std::runtime_error(fmt::format("Failed to create shader module: {}", result));
 	}
 
@@ -352,6 +352,7 @@ void RendererShaderVk::CompileInternal(bool isRenderThread)
 	if (!Shader.parse(&Resources, 100, false, messagesParseLink))
 	{
 		cemuLog_log(LogType::Force, fmt::format("GLSL parsing failed for {:016x}_{:016x}: \"{}\"", m_baseHash, m_auxHash, Shader.getInfoLog()));
+		cemuLog_logDebug(LogType::Force, "GLSL source:\n{}", m_glslCode);
 		cemu_assert_debug(false);
 		FinishCompilation();
 		return;
@@ -456,7 +457,7 @@ void RendererShaderVk::ShaderCacheLoading_begin(uint64 cacheTitleId)
 	}
 	uint32 spirvCacheMagic = GeneratePrecompiledCacheId();
 	const std::string cacheFilename = fmt::format("{:016x}_spirv.bin", cacheTitleId);
-	const std::wstring cachePath = ActiveSettings::GetPath("shaderCache/precompiled/{}", cacheFilename).generic_wstring();
+	const fs::path cachePath = ActiveSettings::GetCachePath("shaderCache/precompiled/{}", cacheFilename);
 	s_spirvCache = FileCache::Open(cachePath, true, spirvCacheMagic);
 	if (s_spirvCache == nullptr)
 		cemuLog_log(LogType::Force, "Unable to open SPIR-V cache {}", cacheFilename);
@@ -467,4 +468,10 @@ void RendererShaderVk::ShaderCacheLoading_end()
 {
 	// keep g_spirvCache open since we will write to it while the game is running
 	s_isLoadingShadersVk = false;
-}
\ No newline at end of file
+}
+
+void RendererShaderVk::ShaderCacheLoading_Close()
+{
+    delete s_spirvCache;
+    s_spirvCache = nullptr;
+}
diff --git a/src/Cafe/HW/Latte/Renderer/Vulkan/RendererShaderVk.h b/src/Cafe/HW/Latte/Renderer/Vulkan/RendererShaderVk.h
index 5be9ce1f..f9c3ede1 100644
--- a/src/Cafe/HW/Latte/Renderer/Vulkan/RendererShaderVk.h
+++ b/src/Cafe/HW/Latte/Renderer/Vulkan/RendererShaderVk.h
@@ -22,13 +22,16 @@ class RendererShaderVk : public RendererShader
 
 public:
 	static void ShaderCacheLoading_begin(uint64 cacheTitleId);
-	static void ShaderCacheLoading_end();
+    static void ShaderCacheLoading_end();
+    static void ShaderCacheLoading_Close();
 
 	RendererShaderVk(ShaderType type, uint64 baseHash, uint64 auxHash, bool isGameShader, bool isGfxPackShader, const std::string& glslCode);
 	virtual ~RendererShaderVk();
 
+	static void Init();
+	static void Shutdown();
+
 	sint32 GetUniformLocation(const char* name) override;
-	void SetUniform1iv(sint32 location, void* data, sint32 count) override;
 	void SetUniform2fv(sint32 location, void* data, sint32 count) override;
 	void SetUniform4iv(sint32 location, void* data, sint32 count) override;
 	VkShaderModule& GetShaderModule() { return m_shader_module; }
@@ -37,16 +40,16 @@ public:
 
 	void TrackDependency(class PipelineInfo* p)
 	{
-		s_dependencyLock.acquire();
+		s_dependencyLock.lock();
 		list_pipelineInfo.emplace_back(p);
-		s_dependencyLock.release();
+		s_dependencyLock.unlock();
 	}
 
 	void RemoveDependency(class PipelineInfo* p)
 	{
-		s_dependencyLock.acquire();
+		s_dependencyLock.lock();
 		vectorRemoveByValue(list_pipelineInfo, p);
-		s_dependencyLock.release();
+		s_dependencyLock.unlock();
 	}
 
 	void PreponeCompilation(bool isRenderThread) override;
diff --git a/src/Cafe/HW/Latte/Renderer/Vulkan/SwapchainInfoVk.cpp b/src/Cafe/HW/Latte/Renderer/Vulkan/SwapchainInfoVk.cpp
new file mode 100644
index 00000000..47dafc98
--- /dev/null
+++ b/src/Cafe/HW/Latte/Renderer/Vulkan/SwapchainInfoVk.cpp
@@ -0,0 +1,412 @@
+#include "SwapchainInfoVk.h"
+
+#include "config/CemuConfig.h"
+#include "gui/guiWrapper.h"
+#include "Cafe/HW/Latte/Core/Latte.h"
+#include "Cafe/HW/Latte/Core/LatteTiming.h"
+#include "Cafe/HW/Latte/Renderer/Vulkan/VulkanAPI.h"
+#include "Cafe/HW/Latte/Renderer/Vulkan/VulkanRenderer.h"
+
+SwapchainInfoVk::SwapchainInfoVk(bool mainWindow, Vector2i size) : mainWindow(mainWindow), m_desiredExtent(size)
+{
+	auto& windowHandleInfo = mainWindow ? gui_getWindowInfo().canvas_main : gui_getWindowInfo().canvas_pad;
+	auto renderer = VulkanRenderer::GetInstance();
+	m_instance = renderer->GetVkInstance();
+	m_logicalDevice = renderer->GetLogicalDevice();
+	m_physicalDevice = renderer->GetPhysicalDevice();
+
+	m_surface = renderer->CreateFramebufferSurface(m_instance, windowHandleInfo);
+}
+
+
+SwapchainInfoVk::~SwapchainInfoVk()
+{
+	Cleanup();
+	if(m_surface != VK_NULL_HANDLE)
+		vkDestroySurfaceKHR(m_instance, m_surface, nullptr);
+}
+
+void SwapchainInfoVk::Create()
+{
+	const auto details = QuerySwapchainSupport(m_surface, m_physicalDevice);
+	m_surfaceFormat = ChooseSurfaceFormat(details.formats);
+	m_actualExtent = ChooseSwapExtent(details.capabilities);
+
+	// use at least two swapchain images. fewer than that causes problems on some drivers
+	uint32_t image_count = std::max(2u, details.capabilities.minImageCount);
+	if(details.capabilities.maxImageCount > 0)
+		image_count = std::min(image_count, details.capabilities.maxImageCount);
+	if(image_count < 2)
+		cemuLog_log(LogType::Force, "Vulkan: Swapchain image count less than 2 may cause problems");
+
+	VkSwapchainCreateInfoKHR create_info = CreateSwapchainCreateInfo(m_surface, details, m_surfaceFormat, image_count, m_actualExtent);
+	create_info.oldSwapchain = nullptr;
+	create_info.imageUsage = VK_IMAGE_USAGE_COLOR_ATTACHMENT_BIT | VK_IMAGE_USAGE_TRANSFER_DST_BIT;
+
+	VkResult result = vkCreateSwapchainKHR(m_logicalDevice, &create_info, nullptr, &m_swapchain);
+	if (result != VK_SUCCESS)
+		UnrecoverableError("Error attempting to create a swapchain");
+
+	result = vkGetSwapchainImagesKHR(m_logicalDevice, m_swapchain, &image_count, nullptr);
+	if (result != VK_SUCCESS)
+		UnrecoverableError("Error attempting to retrieve the count of swapchain images");
+
+
+	m_swapchainImages.resize(image_count);
+	result = vkGetSwapchainImagesKHR(m_logicalDevice, m_swapchain, &image_count, m_swapchainImages.data());
+	if (result != VK_SUCCESS)
+		UnrecoverableError("Error attempting to retrieve swapchain images");
+	// create default renderpass
+	VkAttachmentDescription colorAttachment = {};
+	colorAttachment.format = m_surfaceFormat.format;
+	colorAttachment.samples = VK_SAMPLE_COUNT_1_BIT;
+	colorAttachment.loadOp = VK_ATTACHMENT_LOAD_OP_DONT_CARE;
+	colorAttachment.storeOp = VK_ATTACHMENT_STORE_OP_STORE;
+	colorAttachment.stencilLoadOp = VK_ATTACHMENT_LOAD_OP_DONT_CARE;
+	colorAttachment.stencilStoreOp = VK_ATTACHMENT_STORE_OP_DONT_CARE;
+	colorAttachment.initialLayout = VK_IMAGE_LAYOUT_UNDEFINED;
+	colorAttachment.finalLayout = VK_IMAGE_LAYOUT_PRESENT_SRC_KHR;
+
+	VkAttachmentReference colorAttachmentRef = {};
+	colorAttachmentRef.attachment = 0;
+	colorAttachmentRef.layout = VK_IMAGE_LAYOUT_COLOR_ATTACHMENT_OPTIMAL;
+	VkSubpassDescription subpass = {};
+	subpass.pipelineBindPoint = VK_PIPELINE_BIND_POINT_GRAPHICS;
+	subpass.colorAttachmentCount = 1;
+	subpass.pColorAttachments = &colorAttachmentRef;
+
+	VkRenderPassCreateInfo renderPassInfo = {};
+	renderPassInfo.sType = VK_STRUCTURE_TYPE_RENDER_PASS_CREATE_INFO;
+	renderPassInfo.attachmentCount = 1;
+	renderPassInfo.pAttachments = &colorAttachment;
+	renderPassInfo.subpassCount = 1;
+	renderPassInfo.pSubpasses = &subpass;
+	result = vkCreateRenderPass(m_logicalDevice, &renderPassInfo, nullptr, &m_swapchainRenderPass);
+	if (result != VK_SUCCESS)
+		UnrecoverableError("Failed to create renderpass for swapchain");
+
+	// create swapchain image views
+	m_swapchainImageViews.resize(m_swapchainImages.size());
+	for (sint32 i = 0; i < m_swapchainImages.size(); i++)
+	{
+		VkImageViewCreateInfo createInfo = {};
+		createInfo.sType = VK_STRUCTURE_TYPE_IMAGE_VIEW_CREATE_INFO;
+		createInfo.image = m_swapchainImages[i];
+		createInfo.viewType = VK_IMAGE_VIEW_TYPE_2D;
+		createInfo.format = m_surfaceFormat.format;
+		createInfo.components.r = VK_COMPONENT_SWIZZLE_IDENTITY;
+		createInfo.components.g = VK_COMPONENT_SWIZZLE_IDENTITY;
+		createInfo.components.b = VK_COMPONENT_SWIZZLE_IDENTITY;
+		createInfo.components.a = VK_COMPONENT_SWIZZLE_IDENTITY;
+		createInfo.subresourceRange.aspectMask = VK_IMAGE_ASPECT_COLOR_BIT;
+		createInfo.subresourceRange.baseMipLevel = 0;
+		createInfo.subresourceRange.levelCount = 1;
+		createInfo.subresourceRange.baseArrayLayer = 0;
+		createInfo.subresourceRange.layerCount = 1;
+		result = vkCreateImageView(m_logicalDevice, &createInfo, nullptr, &m_swapchainImageViews[i]);
+		if (result != VK_SUCCESS)
+			UnrecoverableError("Failed to create imageviews for swapchain");
+	}
+
+	// create swapchain framebuffers
+	m_swapchainFramebuffers.resize(m_swapchainImages.size());
+	for (size_t i = 0; i < m_swapchainImages.size(); i++)
+	{
+		VkImageView attachments[1];
+		attachments[0] = m_swapchainImageViews[i];
+		// create framebuffer
+		VkFramebufferCreateInfo framebufferInfo = {};
+		framebufferInfo.sType = VK_STRUCTURE_TYPE_FRAMEBUFFER_CREATE_INFO;
+		framebufferInfo.renderPass = m_swapchainRenderPass;
+		framebufferInfo.attachmentCount = 1;
+		framebufferInfo.pAttachments = attachments;
+		framebufferInfo.width = m_actualExtent.width;
+		framebufferInfo.height = m_actualExtent.height;
+		framebufferInfo.layers = 1;
+		result = vkCreateFramebuffer(m_logicalDevice, &framebufferInfo, nullptr, &m_swapchainFramebuffers[i]);
+		if (result != VK_SUCCESS)
+			UnrecoverableError("Failed to create framebuffer for swapchain");
+	}
+
+	m_presentSemaphores.resize(m_swapchainImages.size());
+	// create present semaphores
+	VkSemaphoreCreateInfo info = {};
+	info.sType = VK_STRUCTURE_TYPE_SEMAPHORE_CREATE_INFO;
+	for (auto& semaphore : m_presentSemaphores){
+		if (vkCreateSemaphore(m_logicalDevice, &info, nullptr, &semaphore) != VK_SUCCESS)
+			UnrecoverableError("Failed to create semaphore for swapchain present");
+	}
+
+	m_acquireSemaphores.resize(m_swapchainImages.size());
+	// create acquire semaphores
+	info = {};
+	info.sType = VK_STRUCTURE_TYPE_SEMAPHORE_CREATE_INFO;
+	for (auto& semaphore : m_acquireSemaphores){
+		if (vkCreateSemaphore(m_logicalDevice, &info, nullptr, &semaphore) != VK_SUCCESS)
+			UnrecoverableError("Failed to create semaphore for swapchain acquire");
+	}
+
+	VkFenceCreateInfo fenceInfo = {};
+	fenceInfo.sType = VK_STRUCTURE_TYPE_FENCE_CREATE_INFO;
+	fenceInfo.flags = VK_FENCE_CREATE_SIGNALED_BIT;
+	result = vkCreateFence(m_logicalDevice, &fenceInfo, nullptr, &m_imageAvailableFence);
+	if (result != VK_SUCCESS)
+		UnrecoverableError("Failed to create fence for swapchain");
+
+	m_acquireIndex = 0;
+	hasDefinedSwapchainImage = false;
+
+	m_queueDepth = 0;
+}
+
+void SwapchainInfoVk::Cleanup()
+{
+	m_swapchainImages.clear();
+
+	for (auto& sem: m_acquireSemaphores)
+		vkDestroySemaphore(m_logicalDevice, sem, nullptr);
+	m_acquireSemaphores.clear();
+
+	for (auto& sem: m_presentSemaphores)
+		vkDestroySemaphore(m_logicalDevice, sem, nullptr);
+	m_presentSemaphores.clear();
+
+	if (m_swapchainRenderPass)
+	{
+		vkDestroyRenderPass(m_logicalDevice, m_swapchainRenderPass, nullptr);
+		m_swapchainRenderPass = nullptr;
+	}
+
+	for (auto& imageView : m_swapchainImageViews)
+		vkDestroyImageView(m_logicalDevice, imageView, nullptr);
+	m_swapchainImageViews.clear();
+
+	for (auto& framebuffer : m_swapchainFramebuffers)
+		vkDestroyFramebuffer(m_logicalDevice, framebuffer, nullptr);
+	m_swapchainFramebuffers.clear();
+
+
+	if (m_imageAvailableFence)
+	{
+		WaitAvailableFence();
+		vkDestroyFence(m_logicalDevice, m_imageAvailableFence, nullptr);
+		m_imageAvailableFence = nullptr;
+	}
+	if (m_swapchain)
+	{
+		vkDestroySwapchainKHR(m_logicalDevice, m_swapchain, nullptr);
+		m_swapchain = VK_NULL_HANDLE;
+	}
+}
+
+bool SwapchainInfoVk::IsValid() const
+{
+	return m_swapchain && !m_acquireSemaphores.empty();
+}
+
+void SwapchainInfoVk::WaitAvailableFence()
+{
+	if(m_awaitableFence != VK_NULL_HANDLE)
+		vkWaitForFences(m_logicalDevice, 1, &m_awaitableFence, VK_TRUE, UINT64_MAX);
+	m_awaitableFence = VK_NULL_HANDLE;
+}
+
+void SwapchainInfoVk::ResetAvailableFence() const
+{
+	vkResetFences(m_logicalDevice, 1, &m_imageAvailableFence);
+}
+
+VkSemaphore SwapchainInfoVk::ConsumeAcquireSemaphore()
+{
+	VkSemaphore ret = m_currentSemaphore;
+	m_currentSemaphore = VK_NULL_HANDLE;
+	return ret;
+}
+
+bool SwapchainInfoVk::AcquireImage()
+{
+	ResetAvailableFence();
+
+	VkSemaphore acquireSemaphore = m_acquireSemaphores[m_acquireIndex];
+	VkResult result = vkAcquireNextImageKHR(m_logicalDevice, m_swapchain, 1'000'000'000, acquireSemaphore, m_imageAvailableFence, &swapchainImageIndex);
+	if (result == VK_ERROR_OUT_OF_DATE_KHR || result == VK_SUBOPTIMAL_KHR)
+		m_shouldRecreate = true;
+	if (result == VK_TIMEOUT)
+	{
+		swapchainImageIndex = -1;
+		return false;
+	}
+
+	if (result < 0)
+	{
+		swapchainImageIndex = -1;
+		if (result != VK_ERROR_OUT_OF_DATE_KHR)
+			throw std::runtime_error(fmt::format("Failed to acquire next image: {}", result));
+		return false;
+	}
+	m_currentSemaphore = acquireSemaphore;
+	m_awaitableFence = m_imageAvailableFence;
+	m_acquireIndex = (m_acquireIndex + 1) % m_swapchainImages.size();
+
+	return true;
+}
+
+void SwapchainInfoVk::UnrecoverableError(const char* errMsg)
+{
+	cemuLog_log(LogType::Force, "Unrecoverable error in Vulkan swapchain");
+	cemuLog_log(LogType::Force, "Msg: {}", errMsg);
+	throw std::runtime_error(errMsg);
+}
+
+
+SwapchainInfoVk::SwapchainSupportDetails SwapchainInfoVk::QuerySwapchainSupport(VkSurfaceKHR surface, const VkPhysicalDevice& device)
+{
+	SwapchainSupportDetails details;
+
+	VkResult result = vkGetPhysicalDeviceSurfaceCapabilitiesKHR(device, surface, &details.capabilities);
+	if (result != VK_SUCCESS)
+	{
+		if (result != VK_ERROR_SURFACE_LOST_KHR)
+			cemuLog_log(LogType::Force, "vkGetPhysicalDeviceSurfaceCapabilitiesKHR failed. Error {}", (sint32)result);
+		throw std::runtime_error(fmt::format("Unable to retrieve physical device surface capabilities: {}", result));
+	}
+
+	uint32_t formatCount = 0;
+	result = vkGetPhysicalDeviceSurfaceFormatsKHR(device, surface, &formatCount, nullptr);
+	if (result != VK_SUCCESS)
+	{
+		cemuLog_log(LogType::Force, "vkGetPhysicalDeviceSurfaceFormatsKHR failed. Error {}", (sint32)result);
+		throw std::runtime_error(fmt::format("Unable to retrieve the number of formats for a surface on a physical device: {}", result));
+	}
+
+	if (formatCount != 0)
+	{
+		details.formats.resize(formatCount);
+		result = vkGetPhysicalDeviceSurfaceFormatsKHR(device, surface, &formatCount, details.formats.data());
+		if (result != VK_SUCCESS)
+		{
+			cemuLog_log(LogType::Force, "vkGetPhysicalDeviceSurfaceFormatsKHR failed. Error {}", (sint32)result);
+			throw std::runtime_error(fmt::format("Unable to retrieve the formats for a surface on a physical device: {}", result));
+		}
+	}
+
+	uint32_t presentModeCount = 0;
+	result = vkGetPhysicalDeviceSurfacePresentModesKHR(device, surface, &presentModeCount, nullptr);
+	if (result != VK_SUCCESS)
+	{
+		cemuLog_log(LogType::Force, "vkGetPhysicalDeviceSurfacePresentModesKHR failed. Error {}", (sint32)result);
+		throw std::runtime_error(fmt::format("Unable to retrieve the count of present modes for a surface on a physical device: {}", result));
+	}
+
+	if (presentModeCount != 0)
+	{
+		details.presentModes.resize(presentModeCount);
+		result = vkGetPhysicalDeviceSurfacePresentModesKHR(device, surface, &presentModeCount, details.presentModes.data());
+		if (result != VK_SUCCESS)
+		{
+			cemuLog_log(LogType::Force, "vkGetPhysicalDeviceSurfacePresentModesKHR failed. Error {}", (sint32)result);
+			throw std::runtime_error(fmt::format("Unable to retrieve the present modes for a surface on a physical device: {}", result));
+		}
+	}
+
+	return details;
+}
+
+VkSurfaceFormatKHR SwapchainInfoVk::ChooseSurfaceFormat(const std::vector<VkSurfaceFormatKHR>& formats) const
+{
+	if (formats.size() == 1 && formats[0].format == VK_FORMAT_UNDEFINED)
+		return{ VK_FORMAT_B8G8R8A8_UNORM, VK_COLOR_SPACE_SRGB_NONLINEAR_KHR };
+
+	for (const auto& format : formats)
+	{
+		bool useSRGB = mainWindow ? LatteGPUState.tvBufferUsesSRGB : LatteGPUState.drcBufferUsesSRGB;
+
+		if (useSRGB)
+		{
+			if (format.format == VK_FORMAT_B8G8R8A8_SRGB && format.colorSpace == VK_COLOR_SPACE_SRGB_NONLINEAR_KHR)
+				return format;
+		}
+		else
+		{
+			if (format.format == VK_FORMAT_B8G8R8A8_UNORM && format.colorSpace == VK_COLOR_SPACE_SRGB_NONLINEAR_KHR)
+				return format;
+		}
+	}
+
+	return formats[0];
+}
+
+VkExtent2D SwapchainInfoVk::ChooseSwapExtent(const VkSurfaceCapabilitiesKHR& capabilities) const
+{
+	if (capabilities.currentExtent.width != std::numeric_limits<uint32>::max())
+		return capabilities.currentExtent;
+
+	VkExtent2D actualExtent = { (uint32)m_desiredExtent.x, (uint32)m_desiredExtent.y };
+	actualExtent.width = std::max(capabilities.minImageExtent.width, std::min(capabilities.maxImageExtent.width, actualExtent.width));
+	actualExtent.height = std::max(capabilities.minImageExtent.height, std::min(capabilities.maxImageExtent.height, actualExtent.height));
+	return actualExtent;
+}
+
+VkPresentModeKHR SwapchainInfoVk::ChoosePresentMode(const std::vector<VkPresentModeKHR>& modes)
+{
+	m_maxQueued = 0;
+	const auto vsyncState = (VSync)GetConfig().vsync.GetValue();
+	if (vsyncState == VSync::MAILBOX)
+	{
+		if (std::find(modes.cbegin(), modes.cend(), VK_PRESENT_MODE_MAILBOX_KHR) != modes.cend())
+			return VK_PRESENT_MODE_MAILBOX_KHR;
+
+		cemuLog_log(LogType::Force, "Vulkan: Can't find mailbox present mode");
+	}
+	else if (vsyncState == VSync::Immediate)
+	{
+		if (std::find(modes.cbegin(), modes.cend(), VK_PRESENT_MODE_IMMEDIATE_KHR) != modes.cend())
+			return VK_PRESENT_MODE_IMMEDIATE_KHR;
+
+		cemuLog_log(LogType::Force, "Vulkan: Can't find immediate present mode");
+	}
+	else if (vsyncState == VSync::SYNC_AND_LIMIT)
+	{
+		LatteTiming_EnableHostDrivenVSync();
+		// use immediate mode if available, other wise fall back to
+		//if (std::find(modes.cbegin(), modes.cend(), VK_PRESENT_MODE_IMMEDIATE_KHR) != modes.cend())
+		//	return VK_PRESENT_MODE_IMMEDIATE_KHR;
+		//else
+		//	cemuLog_log(LogType::Force, "Vulkan: Present mode 'immediate' not available. Vsync might not behave as intended");
+		return VK_PRESENT_MODE_FIFO_KHR;
+	}
+
+	m_maxQueued = 1;
+	return VK_PRESENT_MODE_FIFO_KHR;
+}
+
+VkSwapchainCreateInfoKHR SwapchainInfoVk::CreateSwapchainCreateInfo(VkSurfaceKHR surface, const SwapchainSupportDetails& swapchainSupport, const VkSurfaceFormatKHR& surfaceFormat, uint32 imageCount, const VkExtent2D& extent)
+{
+	VkSwapchainCreateInfoKHR createInfo{};
+	createInfo.sType = VK_STRUCTURE_TYPE_SWAPCHAIN_CREATE_INFO_KHR;
+	createInfo.surface = surface;
+	createInfo.minImageCount = imageCount;
+	createInfo.imageFormat = surfaceFormat.format;
+	createInfo.imageExtent = extent;
+	createInfo.imageArrayLayers = 1;
+	createInfo.imageUsage = VK_IMAGE_USAGE_COLOR_ATTACHMENT_BIT;
+
+	const VulkanRenderer::QueueFamilyIndices indices = VulkanRenderer::GetInstance()->FindQueueFamilies(surface, m_physicalDevice);
+	m_swapchainQueueFamilyIndices = { (uint32)indices.graphicsFamily, (uint32)indices.presentFamily };
+	if (indices.graphicsFamily != indices.presentFamily)
+	{
+		createInfo.imageSharingMode = VK_SHARING_MODE_CONCURRENT;
+		createInfo.queueFamilyIndexCount = m_swapchainQueueFamilyIndices.size();
+		createInfo.pQueueFamilyIndices = m_swapchainQueueFamilyIndices.data();
+	}
+	else
+		createInfo.imageSharingMode = VK_SHARING_MODE_EXCLUSIVE;
+
+	createInfo.preTransform = swapchainSupport.capabilities.currentTransform;
+	createInfo.compositeAlpha = VK_COMPOSITE_ALPHA_OPAQUE_BIT_KHR;
+	createInfo.presentMode = ChoosePresentMode(swapchainSupport.presentModes);
+	createInfo.clipped = VK_TRUE;
+
+	cemuLog_logDebug(LogType::Force, "vulkan presentation mode: {}", createInfo.presentMode);
+	return createInfo;
+}
diff --git a/src/Cafe/HW/Latte/Renderer/Vulkan/SwapchainInfoVk.h b/src/Cafe/HW/Latte/Renderer/Vulkan/SwapchainInfoVk.h
new file mode 100644
index 00000000..c4977c08
--- /dev/null
+++ b/src/Cafe/HW/Latte/Renderer/Vulkan/SwapchainInfoVk.h
@@ -0,0 +1,96 @@
+#pragma once
+
+#include "util/math/vector2.h"
+#include <vulkan/vulkan_core.h>
+
+struct SwapchainInfoVk
+{
+	enum class VSync
+	{
+		// values here must match GeneralSettings2::m_vsync
+		Immediate = 0,
+		FIFO = 1,
+		MAILBOX = 2,
+		SYNC_AND_LIMIT = 3, // synchronize emulated vsync events to monitor vsync. But skip events if rate higher than virtual vsync period
+	};
+
+	struct SwapchainSupportDetails
+	{
+		VkSurfaceCapabilitiesKHR capabilities;
+		std::vector<VkSurfaceFormatKHR> formats;
+		std::vector<VkPresentModeKHR> presentModes;
+	};
+
+	void Cleanup();
+	void Create();
+
+	bool IsValid() const;
+
+	void WaitAvailableFence();
+	void ResetAvailableFence() const;
+
+	bool AcquireImage();
+	// retrieve semaphore of last acquire for submitting a wait operation
+	// only one wait operation must be submitted per acquire (which submits a single signal operation)
+	// therefore subsequent calls will return a NULL handle
+	VkSemaphore ConsumeAcquireSemaphore();
+
+	static void UnrecoverableError(const char* errMsg);
+
+	static SwapchainSupportDetails QuerySwapchainSupport(VkSurfaceKHR surface, const VkPhysicalDevice& device);
+
+	VkPresentModeKHR ChoosePresentMode(const std::vector<VkPresentModeKHR>& modes);
+	VkSurfaceFormatKHR ChooseSurfaceFormat(const std::vector<VkSurfaceFormatKHR>& formats) const;
+	VkExtent2D ChooseSwapExtent(const VkSurfaceCapabilitiesKHR& capabilities) const;
+
+	VkSwapchainCreateInfoKHR CreateSwapchainCreateInfo(VkSurfaceKHR surface, const SwapchainSupportDetails& swapchainSupport, const VkSurfaceFormatKHR& surfaceFormat, uint32 imageCount, const VkExtent2D& extent);
+
+
+	VkExtent2D getExtent() const
+	{
+		return m_actualExtent;
+	}
+
+	SwapchainInfoVk(bool mainWindow, Vector2i size);
+	SwapchainInfoVk(const SwapchainInfoVk&) = delete;
+	SwapchainInfoVk(SwapchainInfoVk&&) noexcept = default;
+	~SwapchainInfoVk();
+
+	bool mainWindow{};
+
+	bool m_shouldRecreate = false;
+	bool m_usesSRGB = false;
+	VSync m_vsyncState = VSync::Immediate;
+	bool hasDefinedSwapchainImage{}; // indicates if the swapchain image is in a defined state
+
+	VkInstance m_instance{};
+	VkPhysicalDevice m_physicalDevice{};
+	VkDevice m_logicalDevice{};
+	VkSurfaceKHR m_surface{};
+	VkSurfaceFormatKHR m_surfaceFormat{};
+	VkSwapchainKHR m_swapchain{};
+	Vector2i m_desiredExtent{};
+	VkExtent2D m_actualExtent{};
+	uint32 swapchainImageIndex = (uint32)-1;
+	uint64 m_presentId = 1;
+	uint64 m_queueDepth = 0; // number of frames with pending presentation requests
+	uint64 m_maxQueued = 0; // the maximum number of frames with presentation requests.
+
+
+	// swapchain image ringbuffer (indexed by swapchainImageIndex)
+	std::vector<VkImage> m_swapchainImages;
+	std::vector<VkImageView> m_swapchainImageViews;
+	std::vector<VkFramebuffer> m_swapchainFramebuffers;
+	std::vector<VkSemaphore> m_presentSemaphores; // indexed by swapchainImageIndex
+
+	VkRenderPass m_swapchainRenderPass = nullptr;
+
+private:
+	uint32 m_acquireIndex = 0;
+	std::vector<VkSemaphore> m_acquireSemaphores; // indexed by m_acquireIndex
+	VkFence m_imageAvailableFence{};
+	VkFence m_awaitableFence = VK_NULL_HANDLE;
+	VkSemaphore m_currentSemaphore = VK_NULL_HANDLE;
+
+	std::array<uint32, 2> m_swapchainQueueFamilyIndices;
+};
diff --git a/src/Cafe/HW/Latte/Renderer/Vulkan/TextureReadbackVk.cpp b/src/Cafe/HW/Latte/Renderer/Vulkan/TextureReadbackVk.cpp
index 6acca716..bce23b59 100644
--- a/src/Cafe/HW/Latte/Renderer/Vulkan/TextureReadbackVk.cpp
+++ b/src/Cafe/HW/Latte/Renderer/Vulkan/TextureReadbackVk.cpp
@@ -22,7 +22,7 @@ uint32 LatteTextureReadbackInfoVk::GetImageSize(LatteTextureView* textureView)
 		cemu_assert(textureFormat == VK_FORMAT_R8G8B8A8_UNORM);
 		return baseTexture->width * baseTexture->height * 4;
 	}
-	else if (textureView->format == Latte::E_GX2SURFFMT::R8_UNORM)
+	else if (textureView->format == Latte::E_GX2SURFFMT::R8_UNORM )
 	{
 		cemu_assert(textureFormat == VK_FORMAT_R8_UNORM);
 		return baseTexture->width * baseTexture->height * 1;
@@ -79,9 +79,16 @@ uint32 LatteTextureReadbackInfoVk::GetImageSize(LatteTextureView* textureView)
 		// todo - if driver does not support VK_FORMAT_D24_UNORM_S8_UINT this is represented as VK_FORMAT_D32_SFLOAT_S8_UINT which is 8 bytes
 		return baseTexture->width * baseTexture->height * 4;
 	}
+	else if (textureView->format == Latte::E_GX2SURFFMT::R5_G6_B5_UNORM )
+	{
+		if(textureFormat == VK_FORMAT_R5G6B5_UNORM_PACK16){
+			return baseTexture->width * baseTexture->height * 2;
+		}	
+		return 0;
+	}
 	else
 	{
-		forceLog_printf("Unsupported texture readback format %04x\n", (uint32)textureView->format);
+		cemuLog_log(LogType::Force, "Unsupported texture readback format {:04x}", (uint32)textureView->format);
 		cemu_assert_debug(false);
 		return 0;
 	}
diff --git a/src/Cafe/HW/Latte/Renderer/Vulkan/VKRBase.h b/src/Cafe/HW/Latte/Renderer/Vulkan/VKRBase.h
index a8a1376f..7dcd3ebc 100644
--- a/src/Cafe/HW/Latte/Renderer/Vulkan/VKRBase.h
+++ b/src/Cafe/HW/Latte/Renderer/Vulkan/VKRBase.h
@@ -1,4 +1,5 @@
 #pragma once
+#include "Cafe/HW/Latte/ISA/LatteReg.h"
 #include "util/math/vector2.h"
 
 class VKRMoveableRefCounterRef
@@ -18,10 +19,10 @@ public:
 
 	virtual ~VKRMoveableRefCounter()
 	{
-		cemu_assert_debug(refCount == 0);
+		cemu_assert_debug(m_refCount == 0);
 
 		// remove references
-#ifndef PUBLIC_RELEASE
+#ifdef CEMU_DEBUG_ASSERT
 		for (auto itr : refs)
 		{
 			auto& rev = itr->ref->reverseRefs;
@@ -29,7 +30,11 @@ public:
 		}
 #endif
 		for (auto itr : refs)
-			itr->ref->refCount--;
+		{
+			itr->ref->m_refCount--;
+			if (itr->ref->m_refCount == 0)
+				itr->ref->RefCountReachedZero();
+		}
 		refs.clear();
 		delete selfRef;
 		selfRef = nullptr;
@@ -40,8 +45,8 @@ public:
 	VKRMoveableRefCounter(VKRMoveableRefCounter&& rhs) noexcept
 	{
 		this->refs = std::move(rhs.refs);
-		this->refCount = rhs.refCount;
-		rhs.refCount = 0;
+		this->m_refCount = rhs.m_refCount;
+		rhs.m_refCount = 0;
 		this->selfRef = rhs.selfRef;
 		rhs.selfRef = nullptr;
 		this->selfRef->ref = this;
@@ -56,9 +61,9 @@ public:
 	void addRef(VKRMoveableRefCounter* refTarget)
 	{
 		this->refs.emplace_back(refTarget->selfRef);
-		refTarget->refCount++;
+		refTarget->m_refCount++;
 
-#ifndef PUBLIC_RELEASE
+#ifdef CEMU_DEBUG_ASSERT
 		// add reverse ref
 		refTarget->reverseRefs.emplace_back(this->selfRef);
 #endif
@@ -67,27 +72,34 @@ public:
 	// methods to directly increment/decrement ref counter (for situations where no external object is available)
 	void incRef()
 	{
-		this->refCount++;
+		m_refCount++;
 	}
 
 	void decRef()
 	{
-		this->refCount--;
+		m_refCount--;
+		if (m_refCount == 0)
+			RefCountReachedZero();
 	}
 
 protected:
-	int refCount{};
+  	virtual void RefCountReachedZero()
+	{
+		// does nothing by default
+	}
+
+	int m_refCount{};
 private:
 	VKRMoveableRefCounterRef* selfRef;
 	std::vector<VKRMoveableRefCounterRef*> refs;
-#ifndef PUBLIC_RELEASE
+#ifdef CEMU_DEBUG_ASSERT
 	std::vector<VKRMoveableRefCounterRef*> reverseRefs;
 #endif
 
 	void moveObj(VKRMoveableRefCounter&& rhs)
 	{
 		this->refs = std::move(rhs.refs);
-		this->refCount = rhs.refCount;
+		this->m_refCount = rhs.m_refCount;
 		this->selfRef = rhs.selfRef;
 		this->selfRef->ref = this;
 	}
@@ -130,6 +142,25 @@ public:
 	VkSampler m_textureDefaultSampler[2] = { VK_NULL_HANDLE, VK_NULL_HANDLE }; // relict from LatteTextureViewVk, get rid of it eventually
 };
 
+
+class VKRObjectSampler : public VKRDestructibleObject
+{
+  public:
+	VKRObjectSampler(VkSamplerCreateInfo* samplerInfo);
+	~VKRObjectSampler() override;
+
+	static VKRObjectSampler* GetOrCreateSampler(VkSamplerCreateInfo* samplerInfo);
+	static void DestroyCache();
+
+	void RefCountReachedZero() override; // sampler objects are destroyed when not referenced anymore
+
+	VkSampler GetSampler() const { return m_sampler; }
+  private:
+	static std::unordered_map<uint64, VKRObjectSampler*> s_samplerCache;
+	VkSampler m_sampler{ VK_NULL_HANDLE };
+	uint64 m_hash;
+};
+
 class VKRObjectRenderPass : public VKRDestructibleObject
 {
 public:
@@ -150,14 +181,28 @@ public:
 
 	struct AttachmentInfo_t
 	{
-		AttachmentEntryColor_t colorAttachment[8];
+		AttachmentEntryColor_t colorAttachment[Latte::GPU_LIMITS::NUM_COLOR_ATTACHMENTS];
 		AttachmentEntryDepth_t depthAttachment;
 	};
 
+	VkFormat GetColorFormat(size_t index)
+	{
+		if (index >= Latte::GPU_LIMITS::NUM_COLOR_ATTACHMENTS)
+			return VK_FORMAT_UNDEFINED;
+		return m_colorAttachmentFormat[index];
+	}
+
+	VkFormat GetDepthFormat()
+	{
+		return m_depthAttachmentFormat;
+	}
+
 public:
-	VKRObjectRenderPass(AttachmentInfo_t& attachmentInfo, sint32 colorAttachmentCount = 8);
+	VKRObjectRenderPass(AttachmentInfo_t& attachmentInfo, sint32 colorAttachmentCount = Latte::GPU_LIMITS::NUM_COLOR_ATTACHMENTS);
 	~VKRObjectRenderPass() override;
 	VkRenderPass m_renderPass{ VK_NULL_HANDLE };
+	VkFormat m_colorAttachmentFormat[Latte::GPU_LIMITS::NUM_COLOR_ATTACHMENTS];
+	VkFormat m_depthAttachmentFormat;
 	uint64 m_hashForPipeline; // helper var. Holds hash of all the renderpass creation parameters (mainly the formats) that affect the pipeline state
 };
 
@@ -176,11 +221,14 @@ public:
 	VKRObjectPipeline();
 	~VKRObjectPipeline() override;
 
-	void setPipeline(VkPipeline newPipeline);
+	void SetPipeline(VkPipeline newPipeline);
+	VkPipeline GetPipeline() const { return m_pipeline; }
 
-	VkPipeline pipeline = VK_NULL_HANDLE;
-	VkDescriptorSetLayout vertexDSL = VK_NULL_HANDLE, pixelDSL = VK_NULL_HANDLE, geometryDSL = VK_NULL_HANDLE;
-	VkPipelineLayout pipeline_layout = VK_NULL_HANDLE;
+	VkDescriptorSetLayout m_vertexDSL = VK_NULL_HANDLE, m_pixelDSL = VK_NULL_HANDLE, m_geometryDSL = VK_NULL_HANDLE;
+	VkPipelineLayout m_pipelineLayout = VK_NULL_HANDLE;
+
+private:
+	VkPipeline m_pipeline = VK_NULL_HANDLE;
 };
 
 class VKRObjectDescriptorSet : public VKRDestructibleObject
diff --git a/src/Cafe/HW/Latte/Renderer/Vulkan/VKRMemoryManager.cpp b/src/Cafe/HW/Latte/Renderer/Vulkan/VKRMemoryManager.cpp
index 95a04315..54ca20cf 100644
--- a/src/Cafe/HW/Latte/Renderer/Vulkan/VKRMemoryManager.cpp
+++ b/src/Cafe/HW/Latte/Renderer/Vulkan/VKRMemoryManager.cpp
@@ -4,6 +4,14 @@
 
 /* VKRSynchronizedMemoryBuffer */
 
+VKRSynchronizedRingAllocator::~VKRSynchronizedRingAllocator()
+{
+	for(auto& buf : m_buffers)
+	{
+		m_vkrMemMgr->DeleteBuffer(buf.vk_buffer, buf.vk_mem);
+	}
+}
+
 void VKRSynchronizedRingAllocator::addUploadBufferSyncPoint(AllocatorBuffer_t& buffer, uint32 offset)
 {
 	auto cmdBufferId = m_vkr->GetCurrentCommandBufferId();
@@ -23,10 +31,12 @@ void VKRSynchronizedRingAllocator::allocateAdditionalUploadBuffer(uint32 sizeReq
 	AllocatorBuffer_t newBuffer{};
 	newBuffer.writeIndex = 0;
 	newBuffer.basePtr = nullptr;
-	if (m_bufferType == BUFFER_TYPE::STAGING)
+	if (m_bufferType == VKR_BUFFER_TYPE::STAGING)
 		m_vkrMemMgr->CreateBuffer(bufferAllocSize, VK_BUFFER_USAGE_TRANSFER_SRC_BIT, VK_MEMORY_PROPERTY_HOST_VISIBLE_BIT, newBuffer.vk_buffer, newBuffer.vk_mem);
-	else if (m_bufferType == BUFFER_TYPE::INDEX)
+	else if (m_bufferType == VKR_BUFFER_TYPE::INDEX)
 		m_vkrMemMgr->CreateBuffer(bufferAllocSize, VK_BUFFER_USAGE_INDEX_BUFFER_BIT, VK_MEMORY_PROPERTY_HOST_VISIBLE_BIT | VK_MEMORY_PROPERTY_HOST_COHERENT_BIT, newBuffer.vk_buffer, newBuffer.vk_mem);
+	else if (m_bufferType == VKR_BUFFER_TYPE::STRIDE)
+		m_vkrMemMgr->CreateBuffer(bufferAllocSize, VK_BUFFER_USAGE_VERTEX_BUFFER_BIT, VK_MEMORY_PROPERTY_HOST_VISIBLE_BIT | VK_MEMORY_PROPERTY_HOST_COHERENT_BIT, newBuffer.vk_buffer, newBuffer.vk_mem);
 	else
 		cemu_assert_debug(false);
 
@@ -51,7 +61,7 @@ VKRSynchronizedRingAllocator::AllocatorReservation_t VKRSynchronizedRingAllocato
 		uint32 distanceToSyncPoint;
 		if (!itr.queue_syncPoints.empty())
 		{
-			if(itr.queue_syncPoints.front().offset < itr.writeIndex)
+			if (itr.queue_syncPoints.front().offset < itr.writeIndex)
 				distanceToSyncPoint = 0xFFFFFFFF;
 			else
 				distanceToSyncPoint = itr.queue_syncPoints.front().offset - itr.writeIndex;
@@ -98,7 +108,7 @@ VKRSynchronizedRingAllocator::AllocatorReservation_t VKRSynchronizedRingAllocato
 
 void VKRSynchronizedRingAllocator::FlushReservation(AllocatorReservation_t& uploadReservation)
 {
-	cemu_assert_debug(m_bufferType == BUFFER_TYPE::STAGING); // only the staging buffer isn't coherent
+	cemu_assert_debug(m_bufferType == VKR_BUFFER_TYPE::STAGING); // only the staging buffer isn't coherent
 	// todo - use nonCoherentAtomSize for flush size (instead of hardcoded constant)
 	VkMappedMemoryRange flushedRange{};
 	flushedRange.sType = VK_STRUCTURE_TYPE_MAPPED_MEMORY_RANGE;
@@ -165,15 +175,88 @@ void VKRSynchronizedRingAllocator::GetStats(uint32& numBuffers, size_t& totalBuf
 	}
 }
 
+/* VKRSynchronizedHeapAllocator */
+
+VKRSynchronizedHeapAllocator::VKRSynchronizedHeapAllocator(class VKRMemoryManager* vkMemoryManager, VKR_BUFFER_TYPE bufferType, size_t minimumBufferAllocSize)
+	: m_vkrMemMgr(vkMemoryManager), m_chunkedHeap(bufferType, minimumBufferAllocSize) {};
+
+VKRSynchronizedHeapAllocator::AllocatorReservation* VKRSynchronizedHeapAllocator::AllocateBufferMemory(uint32 size, uint32 alignment)
+{
+	CHAddr addr = m_chunkedHeap.alloc(size, alignment);
+	m_activeAllocations.emplace_back(addr);
+	AllocatorReservation* res = m_poolAllocatorReservation.allocObj();
+	res->bufferIndex = addr.chunkIndex;
+	res->bufferOffset = addr.offset;
+	res->size = size;
+	res->memPtr = m_chunkedHeap.GetChunkPtr(addr.chunkIndex) + addr.offset;
+	m_chunkedHeap.GetChunkVkMemInfo(addr.chunkIndex, res->vkBuffer, res->vkMem);
+	return res;
+}
+
+void VKRSynchronizedHeapAllocator::FreeReservation(AllocatorReservation* uploadReservation)
+{
+	// put the allocation on a delayed release queue for the current command buffer
+	uint64 currentCommandBufferId = VulkanRenderer::GetInstance()->GetCurrentCommandBufferId();
+	auto it = std::find_if(m_activeAllocations.begin(), m_activeAllocations.end(), [&uploadReservation](const TrackedAllocation& allocation) { return allocation.allocation.chunkIndex == uploadReservation->bufferIndex && allocation.allocation.offset == uploadReservation->bufferOffset; });
+	cemu_assert_debug(it != m_activeAllocations.end());
+	m_releaseQueue[currentCommandBufferId].emplace_back(it->allocation);
+	m_activeAllocations.erase(it);
+	m_poolAllocatorReservation.freeObj(uploadReservation);
+}
+
+void VKRSynchronizedHeapAllocator::FlushReservation(AllocatorReservation* uploadReservation)
+{
+	if (m_chunkedHeap.RequiresFlush(uploadReservation->bufferIndex))
+	{
+		VkMappedMemoryRange flushedRange{};
+		flushedRange.sType = VK_STRUCTURE_TYPE_MAPPED_MEMORY_RANGE;
+		flushedRange.memory = uploadReservation->vkMem;
+		flushedRange.offset = uploadReservation->bufferOffset;
+		flushedRange.size = uploadReservation->size;
+		vkFlushMappedMemoryRanges(VulkanRenderer::GetInstance()->GetLogicalDevice(), 1, &flushedRange);
+	}
+}
+
+void VKRSynchronizedHeapAllocator::CleanupBuffer(uint64 latestFinishedCommandBufferId)
+{
+	auto it = m_releaseQueue.begin();
+	while (it != m_releaseQueue.end())
+	{
+		if (it->first <= latestFinishedCommandBufferId)
+		{
+			// release allocations
+			for(auto& addr : it->second)
+				m_chunkedHeap.free(addr);
+			it = m_releaseQueue.erase(it);
+			continue;
+		}
+		it++;
+	}
+}
+
+void VKRSynchronizedHeapAllocator::GetStats(uint32& numBuffers, size_t& totalBufferSize, size_t& freeBufferSize) const
+{
+	m_chunkedHeap.GetStats(numBuffers, totalBufferSize, freeBufferSize);
+}
+
 /* VkTextureChunkedHeap */
 
+VkTextureChunkedHeap::~VkTextureChunkedHeap()
+{
+	VkDevice device = VulkanRenderer::GetInstance()->GetLogicalDevice();
+	for (auto& i : m_list_chunkInfo)
+	{
+		vkFreeMemory(device, i.mem, nullptr);
+	}
+}
+
 uint32 VkTextureChunkedHeap::allocateNewChunk(uint32 chunkIndex, uint32 minimumAllocationSize)
 {
 	cemu_assert_debug(m_list_chunkInfo.size() == chunkIndex);
 	m_list_chunkInfo.resize(m_list_chunkInfo.size() + 1);
 
 	// pad minimumAllocationSize to 32KB alignment
-	minimumAllocationSize = (minimumAllocationSize + (32*1024-1)) & ~(32 * 1024 - 1);
+	minimumAllocationSize = (minimumAllocationSize + (32 * 1024 - 1)) & ~(32 * 1024 - 1);
 
 	uint32 allocationSize = 1024 * 1024 * 128;
 	if (chunkIndex == 0)
@@ -187,8 +270,7 @@ uint32 VkTextureChunkedHeap::allocateNewChunk(uint32 chunkIndex, uint32 minimumA
 	std::vector<uint32> deviceLocalMemoryTypeIndices = m_vkrMemoryManager->FindMemoryTypes(m_typeFilter, VK_MEMORY_PROPERTY_DEVICE_LOCAL_BIT);
 	std::vector<uint32> hostLocalMemoryTypeIndices = m_vkrMemoryManager->FindMemoryTypes(m_typeFilter, 0);
 	// remove device local memory types from host local vector
-	auto pred = [&deviceLocalMemoryTypeIndices](const uint32& v) ->bool
-	{
+	auto pred = [&deviceLocalMemoryTypeIndices](const uint32& v) -> bool {
 		return std::find(deviceLocalMemoryTypeIndices.begin(), deviceLocalMemoryTypeIndices.end(), v) != deviceLocalMemoryTypeIndices.end();
 	};
 	hostLocalMemoryTypeIndices.erase(std::remove_if(hostLocalMemoryTypeIndices.begin(), hostLocalMemoryTypeIndices.end(), pred), hostLocalMemoryTypeIndices.end());
@@ -204,10 +286,9 @@ uint32 VkTextureChunkedHeap::allocateNewChunk(uint32 chunkIndex, uint32 minimumA
 			allocInfo.memoryTypeIndex = memType;
 
 			VkDeviceMemory imageMemory;
-			VkResult r = vkAllocateMemory(m_device, &allocInfo, nullptr, &imageMemory);
+			VkResult r = vkAllocateMemory(VulkanRenderer::GetInstance()->GetLogicalDevice(), &allocInfo, nullptr, &imageMemory);
 			if (r != VK_SUCCESS)
 				continue;
-			forceLog_printf("Vulkan-Info: Allocated additional memory for textures from device-local memory");
 			m_list_chunkInfo[chunkIndex].mem = imageMemory;
 			return allocationSize;
 		}
@@ -220,10 +301,9 @@ uint32 VkTextureChunkedHeap::allocateNewChunk(uint32 chunkIndex, uint32 minimumA
 			allocInfo.memoryTypeIndex = memType;
 
 			VkDeviceMemory imageMemory;
-			VkResult r = vkAllocateMemory(m_device, &allocInfo, nullptr, &imageMemory);
+			VkResult r = vkAllocateMemory(VulkanRenderer::GetInstance()->GetLogicalDevice(), &allocInfo, nullptr, &imageMemory);
 			if (r != VK_SUCCESS)
 				continue;
-			forceLog_printf("Vulkan-Info: Allocated additional memory for textures from host-local memory");
 			m_list_chunkInfo[chunkIndex].mem = imageMemory;
 			return allocationSize;
 		}
@@ -231,35 +311,83 @@ uint32 VkTextureChunkedHeap::allocateNewChunk(uint32 chunkIndex, uint32 minimumA
 		allocationSize /= 2;
 		if (allocationSize < minimumAllocationSize)
 			break;
-		forceLog_printf("Failed to allocate texture memory chunk with size %dMB. Trying again with smaller allocation size\n", allocationSize / 1024 / 1024);
+		cemuLog_log(LogType::Force, "Failed to allocate texture memory chunk with size {}MB. Trying again with smaller allocation size", allocationSize / 1024 / 1024);
 	}
-	forceLog_printf("Unable to allocate image memory chunk (%d heaps)", deviceLocalMemoryTypeIndices.size());
+	cemuLog_log(LogType::Force, "Unable to allocate image memory chunk ({} heaps)", deviceLocalMemoryTypeIndices.size());
 	throw std::runtime_error("failed to allocate image memory!");
 	return 0;
 }
 
-uint32_t VKRMemoryManager::FindMemoryType(uint32_t typeFilter, VkMemoryPropertyFlags properties) const
-{
-	VkPhysicalDeviceMemoryProperties memProperties;
-	vkGetPhysicalDeviceMemoryProperties(m_vkr->GetPhysicalDevice(), &memProperties);
+/* VkBufferChunkedHeap */
 
-	for (uint32 i = 0; i < memProperties.memoryTypeCount; i++)
+VKRBuffer* VKRBuffer::Create(VKR_BUFFER_TYPE bufferType, size_t bufferSize, VkMemoryPropertyFlags properties)
+{
+	auto* memMgr = VulkanRenderer::GetInstance()->GetMemoryManager();
+	VkBuffer buffer;
+	VkDeviceMemory bufferMemory;
+	bool allocSuccess;
+	if (bufferType == VKR_BUFFER_TYPE::STAGING)
+		allocSuccess = memMgr->CreateBuffer(bufferSize, VK_BUFFER_USAGE_TRANSFER_SRC_BIT, properties, buffer, bufferMemory);
+	else if (bufferType == VKR_BUFFER_TYPE::INDEX)
+		allocSuccess = memMgr->CreateBuffer(bufferSize, VK_BUFFER_USAGE_INDEX_BUFFER_BIT, properties, buffer, bufferMemory);
+	else if (bufferType == VKR_BUFFER_TYPE::STRIDE)
+		allocSuccess = memMgr->CreateBuffer(bufferSize, VK_BUFFER_USAGE_VERTEX_BUFFER_BIT, properties, buffer, bufferMemory);
+	else
+		cemu_assert_debug(false);
+	if (!allocSuccess)
+		return nullptr;
+
+	VKRBuffer* bufferObj = new VKRBuffer(buffer, bufferMemory);
+	// if host visible, then map buffer
+	void* data = nullptr;
+	if (properties & VK_MEMORY_PROPERTY_HOST_VISIBLE_BIT)
 	{
-		if ((typeFilter & (1 << i)) != 0 && (memProperties.memoryTypes[i].propertyFlags & properties) == properties)
-			return i;
+		vkMapMemory(VulkanRenderer::GetInstance()->GetLogicalDevice(), bufferMemory, 0, bufferSize, 0, &data);
+		bufferObj->m_requiresFlush = !HAS_FLAG(properties, VK_MEMORY_PROPERTY_HOST_COHERENT_BIT);
 	}
-	m_vkr->UnrecoverableError(fmt::format("failed to find suitable memory type ({0:#08x} {1:#08x})", typeFilter, properties).c_str());
-	return 0;
+	bufferObj->m_mappedMemory = (uint8*)data;
+	return bufferObj;
 }
 
-bool VKRMemoryManager::FindMemoryType2(uint32 typeFilter, VkMemoryPropertyFlags properties, uint32& memoryIndex) const
+VKRBuffer::~VKRBuffer()
+{
+	if (m_mappedMemory)
+		vkUnmapMemory(VulkanRenderer::GetInstance()->GetLogicalDevice(), m_bufferMemory);
+	if (m_bufferMemory != VK_NULL_HANDLE)
+		vkFreeMemory(VulkanRenderer::GetInstance()->GetLogicalDevice(), m_bufferMemory, nullptr);
+	if (m_buffer != VK_NULL_HANDLE)
+		vkDestroyBuffer(VulkanRenderer::GetInstance()->GetLogicalDevice(), m_buffer, nullptr);
+}
+
+VkBufferChunkedHeap::~VkBufferChunkedHeap()
+{
+	for (auto& chunk : m_chunkBuffers)
+		delete chunk;
+}
+
+uint32 VkBufferChunkedHeap::allocateNewChunk(uint32 chunkIndex, uint32 minimumAllocationSize)
+{
+	size_t allocationSize = std::max<size_t>(m_minimumBufferAllocationSize, minimumAllocationSize);
+	VKRBuffer* buffer = VKRBuffer::Create(m_bufferType, allocationSize, VK_MEMORY_PROPERTY_HOST_VISIBLE_BIT | VK_MEMORY_PROPERTY_HOST_COHERENT_BIT);
+	if(!buffer)
+		buffer = VKRBuffer::Create(m_bufferType, allocationSize, VK_MEMORY_PROPERTY_HOST_VISIBLE_BIT);
+	if(!buffer)
+		VulkanRenderer::GetInstance()->UnrecoverableError("Failed to allocate buffer memory for VkBufferChunkedHeap");
+	cemu_assert_debug(buffer);
+	cemu_assert_debug(m_chunkBuffers.size() == chunkIndex);
+	m_chunkBuffers.emplace_back(buffer);
+	// todo - VK_MEMORY_PROPERTY_DEVICE_LOCAL_BIT might be worth it?
+	return allocationSize;
+}
+
+bool VKRMemoryManager::FindMemoryType(uint32 typeFilter, VkMemoryPropertyFlags properties, uint32& memoryIndex) const
 {
 	VkPhysicalDeviceMemoryProperties memProperties;
 	vkGetPhysicalDeviceMemoryProperties(m_vkr->GetPhysicalDevice(), &memProperties);
 
 	for (uint32_t i = 0; i < memProperties.memoryTypeCount; i++)
 	{
-		if (typeFilter & (1 << i) && memProperties.memoryTypes[i].propertyFlags == properties)
+		if (typeFilter & (1 << i) && (memProperties.memoryTypes[i].propertyFlags & properties) == properties)
 		{
 			memoryIndex = i;
 			return true;
@@ -299,7 +427,7 @@ size_t VKRMemoryManager::GetTotalMemoryForBufferType(VkBufferUsageFlags usage, V
 	bufferInfo.sharingMode = VK_SHARING_MODE_EXCLUSIVE;
 	if (vkCreateBuffer(logicalDevice, &bufferInfo, nullptr, &temporaryBuffer) != VK_SUCCESS)
 	{
-		forceLog_printf("Vulkan: GetTotalMemoryForBufferType() failed to create temporary buffer");
+		cemuLog_log(LogType::Force, "Vulkan: GetTotalMemoryForBufferType() failed to create temporary buffer");
 		return 0;
 	}
 
@@ -330,31 +458,7 @@ size_t VKRMemoryManager::GetTotalMemoryForBufferType(VkBufferUsageFlags usage, V
 	return total;
 }
 
-void VKRMemoryManager::CreateBuffer(VkDeviceSize size, VkBufferUsageFlags usage, VkMemoryPropertyFlags properties, VkBuffer& buffer, VkDeviceMemory& bufferMemory) const
-{
-	VkBufferCreateInfo bufferInfo{};
-	bufferInfo.sType = VK_STRUCTURE_TYPE_BUFFER_CREATE_INFO;
-	bufferInfo.usage = usage;
-	bufferInfo.size = size;
-	bufferInfo.sharingMode = VK_SHARING_MODE_EXCLUSIVE;
-	if (vkCreateBuffer(m_vkr->GetLogicalDevice(), &bufferInfo, nullptr, &buffer) != VK_SUCCESS)
-		m_vkr->UnrecoverableError("Failed to create buffer");
-
-	VkMemoryRequirements memRequirements;
-	vkGetBufferMemoryRequirements(m_vkr->GetLogicalDevice(), buffer, &memRequirements);
-
-	VkMemoryAllocateInfo allocInfo{};
-	allocInfo.sType = VK_STRUCTURE_TYPE_MEMORY_ALLOCATE_INFO;
-	allocInfo.allocationSize = memRequirements.size;
-	allocInfo.memoryTypeIndex = FindMemoryType(memRequirements.memoryTypeBits, properties);
-
-	if (vkAllocateMemory(m_vkr->GetLogicalDevice(), &allocInfo, nullptr, &bufferMemory) != VK_SUCCESS)
-		m_vkr->UnrecoverableError("Failed to allocate buffer memory");
-	if (vkBindBufferMemory(m_vkr->GetLogicalDevice(), buffer, bufferMemory, 0) != VK_SUCCESS)
-		m_vkr->UnrecoverableError("Failed to bind buffer memory");
-}
-
-bool VKRMemoryManager::CreateBuffer2(VkDeviceSize size, VkBufferUsageFlags usage, VkMemoryPropertyFlags properties, VkBuffer& buffer, VkDeviceMemory& bufferMemory) const
+bool VKRMemoryManager::CreateBuffer(VkDeviceSize size, VkBufferUsageFlags usage, VkMemoryPropertyFlags properties, VkBuffer& buffer, VkDeviceMemory& bufferMemory) const
 {
 	VkBufferCreateInfo bufferInfo{};
 	bufferInfo.sType = VK_STRUCTURE_TYPE_BUFFER_CREATE_INFO;
@@ -363,7 +467,7 @@ bool VKRMemoryManager::CreateBuffer2(VkDeviceSize size, VkBufferUsageFlags usage
 	bufferInfo.sharingMode = VK_SHARING_MODE_EXCLUSIVE;
 	if (vkCreateBuffer(m_vkr->GetLogicalDevice(), &bufferInfo, nullptr, &buffer) != VK_SUCCESS)
 	{
-		cemuLog_log(LogType::Force, "Failed to create buffer (CreateBuffer2)");
+		cemuLog_log(LogType::Force, "Failed to create buffer (CreateBuffer)");
 		return false;
 	}
 
@@ -373,7 +477,7 @@ bool VKRMemoryManager::CreateBuffer2(VkDeviceSize size, VkBufferUsageFlags usage
 	VkMemoryAllocateInfo allocInfo{};
 	allocInfo.sType = VK_STRUCTURE_TYPE_MEMORY_ALLOCATE_INFO;
 	allocInfo.allocationSize = memRequirements.size;
-	if (!FindMemoryType2(memRequirements.memoryTypeBits, properties, allocInfo.memoryTypeIndex))
+	if (!FindMemoryType(memRequirements.memoryTypeBits, properties, allocInfo.memoryTypeIndex))
 	{
 		vkDestroyBuffer(m_vkr->GetLogicalDevice(), buffer, nullptr);
 		return false;
@@ -386,7 +490,7 @@ bool VKRMemoryManager::CreateBuffer2(VkDeviceSize size, VkBufferUsageFlags usage
 	if (vkBindBufferMemory(m_vkr->GetLogicalDevice(), buffer, bufferMemory, 0) != VK_SUCCESS)
 	{
 		vkDestroyBuffer(m_vkr->GetLogicalDevice(), buffer, nullptr);
-		cemuLog_log(LogType::Force, "Failed to bind buffer (CreateBuffer2)");
+		cemuLog_log(LogType::Force, "Failed to bind buffer (CreateBuffer)");
 		return false;
 	}
 	return true;
@@ -408,7 +512,7 @@ bool VKRMemoryManager::CreateBufferFromHostMemory(void* hostPointer, VkDeviceSiz
 
 	if (vkCreateBuffer(m_vkr->GetLogicalDevice(), &bufferInfo, nullptr, &buffer) != VK_SUCCESS)
 	{
-		cemuLog_log(LogType::Force, "Failed to create buffer (CreateBuffer2)");
+		cemuLog_log(LogType::Force, "Failed to create buffer (CreateBuffer)");
 		return false;
 	}
 
@@ -423,13 +527,13 @@ bool VKRMemoryManager::CreateBufferFromHostMemory(void* hostPointer, VkDeviceSiz
 	importHostMem.sType = VK_STRUCTURE_TYPE_IMPORT_MEMORY_HOST_POINTER_INFO_EXT;
 	importHostMem.handleType = VK_EXTERNAL_MEMORY_HANDLE_TYPE_HOST_ALLOCATION_BIT_EXT;
 	importHostMem.pHostPointer = hostPointer;
-	// VK_EXTERNAL_MEMORY_HANDLE_TYPE_HOST_ALLOCATION_BIT_EXT or 
+	// VK_EXTERNAL_MEMORY_HANDLE_TYPE_HOST_ALLOCATION_BIT_EXT or
 	// VK_EXTERNAL_MEMORY_HANDLE_TYPE_HOST_MAPPED_FOREIGN_MEMORY_BIT_EXT
 	// whats the difference ?
 
 	allocInfo.pNext = &importHostMem;
 
-	if (!FindMemoryType2(memRequirements.memoryTypeBits, properties, allocInfo.memoryTypeIndex))
+	if (!FindMemoryType(memRequirements.memoryTypeBits, properties, allocInfo.memoryTypeIndex))
 	{
 		vkDestroyBuffer(m_vkr->GetLogicalDevice(), buffer, nullptr);
 		return false;
@@ -469,11 +573,11 @@ VkImageMemAllocation* VKRMemoryManager::imageMemoryAllocate(VkImage image)
 	auto it = map_textureHeap.find(typeFilter);
 	if (it == map_textureHeap.end())
 	{
-		texHeap = new VkTextureChunkedHeap(this, typeFilter, m_vkr->GetLogicalDevice());
+		texHeap = new VkTextureChunkedHeap(this, typeFilter);
 		map_textureHeap.emplace(typeFilter, texHeap);
 	}
 	else
-		texHeap = it->second;
+		texHeap = it->second.get();
 
 	// alloc mem from heap
 	uint32 allocationSize = (uint32)memRequirements.size;
@@ -513,7 +617,7 @@ void VKRMemoryManager::imageMemoryFree(VkImageMemAllocation* imageMemAllocation)
 	auto heapItr = map_textureHeap.find(imageMemAllocation->typeFilter);
 	if (heapItr == map_textureHeap.end())
 	{
-		forceLog_printf("Internal texture heap error");
+		cemuLog_log(LogType::Force, "Internal texture heap error");
 		return;
 	}
 	heapItr->second->freeMem(imageMemAllocation->mem);
diff --git a/src/Cafe/HW/Latte/Renderer/Vulkan/VKRMemoryManager.h b/src/Cafe/HW/Latte/Renderer/Vulkan/VKRMemoryManager.h
index 47561159..b81b65ea 100644
--- a/src/Cafe/HW/Latte/Renderer/Vulkan/VKRMemoryManager.h
+++ b/src/Cafe/HW/Latte/Renderer/Vulkan/VKRMemoryManager.h
@@ -2,6 +2,36 @@
 #include "Cafe/HW/Latte/Renderer/Renderer.h"
 #include "Cafe/HW/Latte/Renderer/Vulkan/VulkanAPI.h"
 #include "util/ChunkedHeap/ChunkedHeap.h"
+#include "util/helpers/MemoryPool.h"
+
+enum class VKR_BUFFER_TYPE
+{
+	STAGING, // staging upload buffer
+	INDEX, // buffer for index data
+	STRIDE, // buffer for stride-adjusted vertex data
+};
+
+class VKRBuffer
+{
+  public:
+	static VKRBuffer* Create(VKR_BUFFER_TYPE bufferType, size_t bufferSize, VkMemoryPropertyFlags properties);
+	~VKRBuffer();
+
+	VkBuffer GetVkBuffer() const { return m_buffer; }
+	VkDeviceMemory GetVkBufferMemory() const { return m_bufferMemory; }
+
+	uint8* GetPtr() const { return m_mappedMemory; }
+
+	bool RequiresFlush() const { return m_requiresFlush; }
+
+  private:
+	VKRBuffer(VkBuffer buffer, VkDeviceMemory bufferMem) : m_buffer(buffer), m_bufferMemory(bufferMem) { };
+
+	VkBuffer m_buffer;
+	VkDeviceMemory m_bufferMemory;
+	uint8* m_mappedMemory;
+	bool m_requiresFlush{false};
+};
 
 struct VkImageMemAllocation
 {
@@ -14,18 +44,17 @@ struct VkImageMemAllocation
 	uint32 getAllocationSize() { return allocationSize; }
 };
 
-class VkTextureChunkedHeap : private ChunkedHeap
+class VkTextureChunkedHeap : private ChunkedHeap<>
 {
 public:
-	VkTextureChunkedHeap(class VKRMemoryManager* memoryManager, uint32 typeFilter, VkDevice device) : m_vkrMemoryManager(memoryManager), m_typeFilter(typeFilter), m_device(device) { };
+	VkTextureChunkedHeap(class VKRMemoryManager* memoryManager, uint32 typeFilter) : m_vkrMemoryManager(memoryManager), m_typeFilter(typeFilter) { };
+	~VkTextureChunkedHeap();
 
 	struct ChunkInfo
 	{
 		VkDeviceMemory mem;
 	};
 
-	uint32 allocateNewChunk(uint32 chunkIndex, uint32 minimumAllocationSize) override;
-
 	CHAddr allocMem(uint32 size, uint32 alignment)
 	{
 		if (alignment < 4)
@@ -33,7 +62,7 @@ public:
 		if ((alignment & (alignment - 1)) != 0)
 		{
 			// not a power of two
-			forceLog_printf("VkTextureChunkedHeap: Invalid alignment %d", alignment);
+			cemuLog_log(LogType::Force, "VkTextureChunkedHeap: Invalid alignment {}", alignment);
 		}
 		return this->alloc(size, alignment);
 	}
@@ -43,11 +72,6 @@ public:
 		this->free(addr);
 	}
 
-	void setDevice(VkDevice dev)
-	{
-		m_device = dev;
-	}
-
 	VkDeviceMemory getChunkMem(uint32 index)
 	{
 		if (index >= m_list_chunkInfo.size())
@@ -57,28 +81,75 @@ public:
 
 	void getStatistics(uint32& totalHeapSize, uint32& allocatedBytes) const
 	{
-		totalHeapSize = numHeapBytes;
-		allocatedBytes = numAllocatedBytes;
+		totalHeapSize = m_numHeapBytes;
+		allocatedBytes = m_numAllocatedBytes;
 	}
 
-	VkDevice m_device;
+  private:
+	uint32 allocateNewChunk(uint32 chunkIndex, uint32 minimumAllocationSize) override;
+
 	uint32 m_typeFilter{ 0xFFFFFFFF };
 	class VKRMemoryManager* m_vkrMemoryManager;
 	std::vector<ChunkInfo> m_list_chunkInfo;
 };
 
+class VkBufferChunkedHeap : private ChunkedHeap<>
+{
+  public:
+	VkBufferChunkedHeap(VKR_BUFFER_TYPE bufferType, size_t minimumBufferAllocationSize) : m_bufferType(bufferType), m_minimumBufferAllocationSize(minimumBufferAllocationSize) { };
+	~VkBufferChunkedHeap();
+
+	using ChunkedHeap::alloc;
+	using ChunkedHeap::free;
+
+	uint8* GetChunkPtr(uint32 index) const
+	{
+		if (index >= m_chunkBuffers.size())
+			return nullptr;
+		return m_chunkBuffers[index]->GetPtr();
+	}
+
+	void GetChunkVkMemInfo(uint32 index, VkBuffer& buffer, VkDeviceMemory& mem)
+	{
+		if (index >= m_chunkBuffers.size())
+		{
+			buffer = VK_NULL_HANDLE;
+			mem = VK_NULL_HANDLE;
+			return;
+		}
+		buffer = m_chunkBuffers[index]->GetVkBuffer();
+		mem = m_chunkBuffers[index]->GetVkBufferMemory();
+	}
+
+	void GetStats(uint32& numBuffers, size_t& totalBufferSize, size_t& freeBufferSize) const
+	{
+		numBuffers = m_chunkBuffers.size();
+		totalBufferSize = m_numHeapBytes;
+		freeBufferSize = m_numHeapBytes - m_numAllocatedBytes;
+	}
+
+	bool RequiresFlush(uint32 index) const
+	{
+		if (index >= m_chunkBuffers.size())
+			return false;
+		return m_chunkBuffers[index]->RequiresFlush();
+	}
+
+  private:
+	uint32 allocateNewChunk(uint32 chunkIndex, uint32 minimumAllocationSize) override;
+
+	VKR_BUFFER_TYPE m_bufferType;
+	std::vector<VKRBuffer*> m_chunkBuffers;
+	size_t m_minimumBufferAllocationSize;
+};
+
 // a circular ring-buffer which tracks and releases memory per command-buffer
 class VKRSynchronizedRingAllocator
 {
 public:
-	enum class BUFFER_TYPE
-	{
-		STAGING, // staging upload buffer
-		INDEX, // buffer for index data
-	};
-
-	VKRSynchronizedRingAllocator(class VulkanRenderer* vkRenderer, class VKRMemoryManager* vkMemoryManager, BUFFER_TYPE bufferType, uint32 minimumBufferAllocSize) : m_vkr(vkRenderer), m_vkrMemMgr(vkMemoryManager), m_bufferType(bufferType), m_minimumBufferAllocSize(minimumBufferAllocSize) {};
+	VKRSynchronizedRingAllocator(class VulkanRenderer* vkRenderer, class VKRMemoryManager* vkMemoryManager, VKR_BUFFER_TYPE bufferType, uint32 minimumBufferAllocSize) : m_vkr(vkRenderer), m_vkrMemMgr(vkMemoryManager), m_bufferType(bufferType), m_minimumBufferAllocSize(minimumBufferAllocSize) {};
 	VKRSynchronizedRingAllocator(const VKRSynchronizedRingAllocator&) = delete; // disallow copy
+	~VKRSynchronizedRingAllocator();
 
 	struct BufferSyncPoint_t
 	{
@@ -125,26 +196,69 @@ private:
 
 	const class VulkanRenderer* m_vkr;
 	const class VKRMemoryManager* m_vkrMemMgr;
-	const BUFFER_TYPE m_bufferType;
+	const VKR_BUFFER_TYPE m_bufferType;
 	const uint32 m_minimumBufferAllocSize;
 
 	std::vector<AllocatorBuffer_t> m_buffers;
 
 };
 
+// heap style allocator with released memory being freed after the current command buffer finishes
+class VKRSynchronizedHeapAllocator
+{
+	struct TrackedAllocation
+	{
+		TrackedAllocation(CHAddr allocation) : allocation(allocation) {};
+		CHAddr allocation;
+	};
+
+  public:
+	VKRSynchronizedHeapAllocator(class VKRMemoryManager* vkMemoryManager, VKR_BUFFER_TYPE bufferType, size_t minimumBufferAllocSize);
+	VKRSynchronizedHeapAllocator(const VKRSynchronizedHeapAllocator&) = delete; // disallow copy
+
+	struct AllocatorReservation
+	{
+		VkBuffer vkBuffer;
+		VkDeviceMemory vkMem;
+		uint8* memPtr;
+		uint32 bufferOffset;
+		uint32 size;
+		uint32 bufferIndex;
+	};
+
+	AllocatorReservation* AllocateBufferMemory(uint32 size, uint32 alignment);
+	void FreeReservation(AllocatorReservation* uploadReservation);
+	void FlushReservation(AllocatorReservation* uploadReservation);
+
+	void CleanupBuffer(uint64 latestFinishedCommandBufferId);
+
+	void GetStats(uint32& numBuffers, size_t& totalBufferSize, size_t& freeBufferSize) const;
+  private:
+	const class VKRMemoryManager* m_vkrMemMgr;
+	VkBufferChunkedHeap m_chunkedHeap;
+	// allocations
+	std::vector<TrackedAllocation> m_activeAllocations;
+	MemoryPool<AllocatorReservation> m_poolAllocatorReservation{32};
+	// release queue
+	std::unordered_map<uint64, std::vector<CHAddr>> m_releaseQueue;
+};
+
 void LatteIndices_invalidateAll();
 
 class VKRMemoryManager
 {
 	friend class VKRSynchronizedRingAllocator;
 public:
-	VKRMemoryManager(class VulkanRenderer* renderer) : m_stagingBuffer(renderer, this, VKRSynchronizedRingAllocator::BUFFER_TYPE::STAGING, 32u * 1024 * 1024), m_indexBuffer(renderer, this, VKRSynchronizedRingAllocator::BUFFER_TYPE::INDEX, 4u * 1024 * 1024)
+	VKRMemoryManager(class VulkanRenderer* renderer) :
+			m_stagingBuffer(renderer, this, VKR_BUFFER_TYPE::STAGING, 32u * 1024 * 1024),
+			m_indexBuffer(this, VKR_BUFFER_TYPE::INDEX, 4u * 1024 * 1024),
+			m_vertexStrideMetalBuffer(renderer, this, VKR_BUFFER_TYPE::STRIDE, 4u * 1024 * 1024)
 	{
 		m_vkr = renderer;
 	}
 
 	// texture memory management
-	std::unordered_map<uint32, VkTextureChunkedHeap*> map_textureHeap; // one heap per memory type
+	std::unordered_map<uint32, std::unique_ptr<VkTextureChunkedHeap>> map_textureHeap; // one heap per memory type
 	std::vector<uint8> m_textureUploadBuffer;
 
 	// texture upload buffer
@@ -163,18 +277,18 @@ public:
 	}
 
 	VKRSynchronizedRingAllocator& getStagingAllocator() { return m_stagingBuffer; }; // allocator for texture/attribute/uniform uploads
-	VKRSynchronizedRingAllocator& getIndexAllocator() { return m_indexBuffer; }; // allocator for index data
+	VKRSynchronizedHeapAllocator& GetIndexAllocator() { return m_indexBuffer; }; // allocator for index data
+	VKRSynchronizedRingAllocator& getMetalStrideWorkaroundAllocator() { return m_vertexStrideMetalBuffer; }; // allocator for stride-adjusted vertex data
 
 	void cleanupBuffers(uint64 latestFinishedCommandBufferId)
 	{
 		LatteIndices_invalidateAll();
 		m_stagingBuffer.CleanupBuffer(latestFinishedCommandBufferId);
 		m_indexBuffer.CleanupBuffer(latestFinishedCommandBufferId);
+		m_vertexStrideMetalBuffer.CleanupBuffer(latestFinishedCommandBufferId);
 	}
 
-	// memory helpers
-	uint32_t FindMemoryType(uint32_t typeFilter, VkMemoryPropertyFlags properties) const;
-	bool FindMemoryType2(uint32 typeFilter, VkMemoryPropertyFlags properties, uint32& memoryIndex) const; // searches for exact properties. Can gracefully fail without throwing exception (returns false)
+	bool FindMemoryType(uint32 typeFilter, VkMemoryPropertyFlags properties, uint32& memoryIndex) const; // searches for exact properties. Can gracefully fail without throwing exception (returns false)
 	std::vector<uint32> FindMemoryTypes(uint32_t typeFilter, VkMemoryPropertyFlags properties) const;
 
 	// image memory allocation
@@ -184,8 +298,7 @@ public:
 	// buffer management
 	size_t GetTotalMemoryForBufferType(VkBufferUsageFlags usage, VkMemoryPropertyFlags properties, size_t minimumBufferSize = 16 * 1024 * 1024);
 
-	void CreateBuffer(VkDeviceSize size, VkBufferUsageFlags usage, VkMemoryPropertyFlags properties, VkBuffer& buffer, VkDeviceMemory& bufferMemory) const;
-	bool CreateBuffer2(VkDeviceSize size, VkBufferUsageFlags usage, VkMemoryPropertyFlags properties, VkBuffer& buffer, VkDeviceMemory& bufferMemory) const; // same as CreateBuffer but doesn't throw exception on failure
+	bool CreateBuffer(VkDeviceSize size, VkBufferUsageFlags usage, VkMemoryPropertyFlags properties, VkBuffer& buffer, VkDeviceMemory& bufferMemory) const; // same as CreateBuffer but doesn't throw exception on failure
 	bool CreateBufferFromHostMemory(void* hostPointer, VkDeviceSize size, VkBufferUsageFlags usage, VkMemoryPropertyFlags properties, VkBuffer& buffer, VkDeviceMemory& bufferMemory) const;
 
 	void DeleteBuffer(VkBuffer& buffer, VkDeviceMemory& deviceMem) const;
@@ -196,5 +309,6 @@ public:
 	private:
 		class VulkanRenderer* m_vkr;
 		VKRSynchronizedRingAllocator m_stagingBuffer;
-		VKRSynchronizedRingAllocator m_indexBuffer;
+		VKRSynchronizedHeapAllocator m_indexBuffer;
+		VKRSynchronizedRingAllocator m_vertexStrideMetalBuffer;
 };
diff --git a/src/Cafe/HW/Latte/Renderer/Vulkan/VKRPipelineInfo.cpp b/src/Cafe/HW/Latte/Renderer/Vulkan/VKRPipelineInfo.cpp
index e9936c43..b316b9c5 100644
--- a/src/Cafe/HW/Latte/Renderer/Vulkan/VKRPipelineInfo.cpp
+++ b/src/Cafe/HW/Latte/Renderer/Vulkan/VKRPipelineInfo.cpp
@@ -3,7 +3,6 @@
 #include "Cafe/HW/Latte/Renderer/Vulkan/LatteTextureVk.h"
 #include "Cafe/HW/Latte/Renderer/Vulkan/RendererShaderVk.h"
 
-#include <glslang/Include/Types.h>
 #include "Cafe/HW/Latte/LegacyShaderDecompiler/LatteDecompiler.h"
 #include "Cafe/HW/Latte/Core/LattePerformanceMonitor.h"
 
@@ -27,7 +26,6 @@ PipelineInfo::PipelineInfo(uint64 minimalStateHash, uint64 pipelineHash, LatteFe
 
 	// init VKRObjPipeline
 	m_vkrObjPipeline = new VKRObjectPipeline();
-	m_vkrObjPipeline->pipeline = VK_NULL_HANDLE;
 
 	// track dependency with shaders
 	if (vertexShaderVk)
@@ -85,10 +83,10 @@ PipelineInfo::~PipelineInfo()
 	// queue pipeline for destruction
 	if (m_vkrObjPipeline)
 	{
-		VulkanRenderer::GetInstance()->releaseDestructibleObject(m_vkrObjPipeline);
+		VulkanRenderer::GetInstance()->ReleaseDestructibleObject(m_vkrObjPipeline);
 		m_vkrObjPipeline = nullptr;
 	}
 
 	// remove from cache
 	VulkanRenderer::GetInstance()->unregisterGraphicsPipeline(this);
-}
\ No newline at end of file
+}
diff --git a/src/Cafe/HW/Latte/Renderer/Vulkan/VsyncDriver.cpp b/src/Cafe/HW/Latte/Renderer/Vulkan/VsyncDriver.cpp
index 910ceff2..6ccca80f 100644
--- a/src/Cafe/HW/Latte/Renderer/Vulkan/VsyncDriver.cpp
+++ b/src/Cafe/HW/Latte/Renderer/Vulkan/VsyncDriver.cpp
@@ -129,7 +129,7 @@ private:
 			NTSTATUS r = pfnD3DKMTWaitForVerticalBlankEvent(&arg);
 			if (r != 0)
 			{
-				//forceLog_printf("Wait for VerticalBlank failed\n");
+				//cemuLog_log(LogType::Force, "Wait for VerticalBlank failed");
 				Sleep(1000 / 60);
 				failCount++;
 				if (failCount >= 10)
@@ -214,4 +214,4 @@ void VsyncDriver_notifyWindowPosChanged()
 
 }
 
-#endif
\ No newline at end of file
+#endif
diff --git a/src/Cafe/HW/Latte/Renderer/Vulkan/VulkanAPI.cpp b/src/Cafe/HW/Latte/Renderer/Vulkan/VulkanAPI.cpp
index fd5beb2f..ad32b541 100644
--- a/src/Cafe/HW/Latte/Renderer/Vulkan/VulkanAPI.cpp
+++ b/src/Cafe/HW/Latte/Renderer/Vulkan/VulkanAPI.cpp
@@ -1,13 +1,81 @@
 #include "Cafe/HW/Latte/Renderer/Vulkan/VulkanAPI.h"
 #define VKFUNC_DEFINE
 #include "Cafe/HW/Latte/Renderer/Vulkan/VulkanAPI.h"
+#include <numeric> // for std::iota
 
 #if BOOST_OS_LINUX || BOOST_OS_MACOS
 #include <dlfcn.h>
 #endif
 
+#define VULKAN_API_CPU_BENCHMARK 0	// if 1, Cemu will log the CPU time spent per Vulkan API function
+
 bool g_vulkan_available = false;
 
+#if VULKAN_API_CPU_BENCHMARK != 0
+uint64 s_vulkanBenchmarkLastResultsTime = 0;
+
+struct VulkanBenchmarkFuncInfo
+{
+	std::string funcName;
+	uint64 cycles;
+	uint32 numCalls;
+};
+
+std::vector<VulkanBenchmarkFuncInfo*> s_vulkanBenchmarkFuncs;
+
+template<typename TRet, typename... Args>
+auto VkWrapperFuncGenTest(TRet (*func)(Args...), const char* name)
+{
+	static VulkanBenchmarkFuncInfo _FuncInfo;
+	static auto _FuncPtrCopy = func;
+	TRet (*newFunc)(Args...);
+	if constexpr(std::is_void_v<TRet>)
+	{
+		newFunc = +[](Args... args) { uint64 t = __rdtsc(); _mm_mfence(); _FuncPtrCopy(args...); _mm_mfence(); _FuncInfo.cycles += (__rdtsc() - t); _FuncInfo.numCalls++; };
+	}
+	else
+		newFunc = +[](Args... args) -> TRet { uint64 t = __rdtsc(); _mm_mfence(); TRet r = _FuncPtrCopy(args...); _mm_mfence(); _FuncInfo.cycles += (__rdtsc() - t); _FuncInfo.numCalls++; return r; };
+	if(func && func != newFunc)
+		_FuncPtrCopy = func;
+	if(_FuncInfo.funcName.empty())
+	{
+		_FuncInfo = {.funcName = name, .cycles = 0, .numCalls = 0};
+		s_vulkanBenchmarkFuncs.emplace_back(&_FuncInfo);
+	}
+	return newFunc;
+};
+#endif
+
+// called when a TV SwapBuffers is called
+void VulkanBenchmarkPrintResults()
+{
+#if VULKAN_API_CPU_BENCHMARK != 0
+	// note: This could be done by hooking vk present functions
+	uint64 currentCycle = __rdtsc();
+	uint64 elapsedCycles = currentCycle - s_vulkanBenchmarkLastResultsTime;
+	s_vulkanBenchmarkLastResultsTime = currentCycle;
+	double elapsedCyclesDbl = (double)elapsedCycles;
+	cemuLog_log(LogType::Force, "--- Vulkan API CPU benchmark ---");
+	cemuLog_log(LogType::Force, "Elapsed cycles this frame: {:} | Current cycle {:} | NumFunc {:}", elapsedCycles, currentCycle, s_vulkanBenchmarkFuncs.size());
+
+	std::vector<sint32> sortedIndices(s_vulkanBenchmarkFuncs.size());
+	std::iota(sortedIndices.begin(), sortedIndices.end(), 0);
+	std::sort(sortedIndices.begin(), sortedIndices.end(),
+			  [](int32_t a, int32_t b) {
+				  return s_vulkanBenchmarkFuncs[a]->cycles > s_vulkanBenchmarkFuncs[b]->cycles;
+			  });
+	for (sint32 idx : sortedIndices)
+	{
+		auto& func = s_vulkanBenchmarkFuncs[idx];
+		if(func->cycles == 0)
+			return;
+		cemuLog_log(LogType::Force, "{}: {} cycles ({:.4}%) {} calls", func->funcName.c_str(), func->cycles, ((double)func->cycles / elapsedCyclesDbl) * 100.0, func->numCalls);
+		func->cycles = 0;
+		func->numCalls = 0;
+	}
+#endif
+}
+
 #if BOOST_OS_WINDOWS
 
 bool InitializeGlobalVulkan()
@@ -19,7 +87,7 @@ bool InitializeGlobalVulkan()
 
 	if (hmodule == nullptr)
 	{
-		forceLog_printf("Vulkan loader not available. Outdated graphics driver or Vulkan runtime not installed?");
+		cemuLog_log(LogType::Force, "Vulkan loader not available. Outdated graphics driver or Vulkan runtime not installed?");
 		return false;
 	}
 
@@ -28,7 +96,7 @@ bool InitializeGlobalVulkan()
 
 	if(!vkEnumerateInstanceVersion)
 	{
-		forceLog_printf("vkEnumerateInstanceVersion not available. Outdated graphics driver or Vulkan runtime?");
+		cemuLog_log(LogType::Force, "vkEnumerateInstanceVersion not available. Outdated graphics driver or Vulkan runtime?");
 		FreeLibrary(hmodule);
 		return false;
 	}
@@ -57,7 +125,12 @@ bool InitializeDeviceVulkan(VkDevice device)
 
 	#define VKFUNC_DEVICE_INIT
 	#include "Cafe/HW/Latte/Renderer/Vulkan/VulkanAPI.h"
-	
+
+#if VULKAN_API_CPU_BENCHMARK != 0
+	#define VKFUNC_DEFINE_CUSTOM(__func) __func = VkWrapperFuncGenTest(__func, #__func)
+	#include "Cafe/HW/Latte/Renderer/Vulkan/VulkanAPI.h"
+#endif
+
 	return true;
 }
 
@@ -84,7 +157,7 @@ bool InitializeGlobalVulkan()
 
 	if (!vulkan_so)
 	{
-		forceLog_printf("Vulkan loader not available.");
+		cemuLog_log(LogType::Force, "Vulkan loader not available.");
 		return false;
 	}
 
@@ -93,7 +166,7 @@ bool InitializeGlobalVulkan()
 
 	if(!vkEnumerateInstanceVersion)
 	{
-		forceLog_printf("vkEnumerateInstanceVersion not available. Outdated graphics driver or Vulkan runtime?");
+		cemuLog_log(LogType::Force, "vkEnumerateInstanceVersion not available. Outdated graphics driver or Vulkan runtime?");
 		return false;
 	}
 	
@@ -121,8 +194,13 @@ bool InitializeDeviceVulkan(VkDevice device)
 
 	#define VKFUNC_DEVICE_INIT
 	#include "Cafe/HW/Latte/Renderer/Vulkan/VulkanAPI.h"
-	
+
+#if VULKAN_API_CPU_BENCHMARK != 0
+	#define VKFUNC_DEFINE_CUSTOM(__func) __func = VkWrapperFuncGenTest(__func, #__func)
+	#include "Cafe/HW/Latte/Renderer/Vulkan/VulkanAPI.h"
+#endif
+
 	return true;
 }
 
-#endif
\ No newline at end of file
+#endif
diff --git a/src/Cafe/HW/Latte/Renderer/Vulkan/VulkanAPI.h b/src/Cafe/HW/Latte/Renderer/Vulkan/VulkanAPI.h
index c1f2dee6..ae2a62f2 100644
--- a/src/Cafe/HW/Latte/Renderer/Vulkan/VulkanAPI.h
+++ b/src/Cafe/HW/Latte/Renderer/Vulkan/VulkanAPI.h
@@ -14,10 +14,14 @@ extern bool g_vulkan_available;
 
 #endif
 
-#ifdef VKFUNC_DEFINE
-	#define VKFUNC(__FUNC__) PFN_##__FUNC__ __FUNC__ = nullptr
-	#define VKFUNC_INSTANCE(__FUNC__) PFN_##__FUNC__ __FUNC__ = nullptr
-	#define VKFUNC_DEVICE(__FUNC__) PFN_##__FUNC__ __FUNC__ = nullptr
+#ifdef VKFUNC_DEFINE_CUSTOM
+	#define VKFUNC(__FUNC__) VKFUNC_DEFINE_CUSTOM(__FUNC__)
+	#define VKFUNC_INSTANCE(__FUNC__) VKFUNC_DEFINE_CUSTOM(__FUNC__)
+	#define VKFUNC_DEVICE(__FUNC__) VKFUNC_DEFINE_CUSTOM(__FUNC__)
+#elif defined(VKFUNC_DEFINE)
+	#define VKFUNC(__FUNC__) NOEXPORT PFN_##__FUNC__ __FUNC__ = nullptr
+	#define VKFUNC_INSTANCE(__FUNC__) NOEXPORT PFN_##__FUNC__ __FUNC__ = nullptr
+	#define VKFUNC_DEVICE(__FUNC__) NOEXPORT PFN_##__FUNC__ __FUNC__ = nullptr
 #else
 	#if defined(VKFUNC_INIT)
 		#if BOOST_OS_WINDOWS
@@ -129,6 +133,9 @@ VKFUNC_DEVICE(vkCmdBindPipeline);
 #if BOOST_OS_LINUX
 VKFUNC_INSTANCE(vkCreateXlibSurfaceKHR);
 VKFUNC_INSTANCE(vkCreateXcbSurfaceKHR);
+#ifdef HAS_WAYLAND
+VKFUNC_INSTANCE(vkCreateWaylandSurfaceKHR);
+#endif
 #endif
 
 #if BOOST_OS_WINDOWS
@@ -158,6 +165,7 @@ VKFUNC_DEVICE(vkCmdDraw);
 VKFUNC_DEVICE(vkCmdCopyBufferToImage);
 VKFUNC_DEVICE(vkCmdCopyImageToBuffer);
 VKFUNC_DEVICE(vkCmdClearColorImage);
+VKFUNC_DEVICE(vkCmdClearAttachments);
 VKFUNC_DEVICE(vkCmdBindIndexBuffer);
 VKFUNC_DEVICE(vkCmdBindVertexBuffers);
 VKFUNC_DEVICE(vkCmdDrawIndexed);
@@ -181,6 +189,9 @@ VKFUNC_DEVICE(vkCmdPipelineBarrier2KHR);
 VKFUNC_DEVICE(vkCmdBeginRenderingKHR);
 VKFUNC_DEVICE(vkCmdEndRenderingKHR);
 
+// khr_present_wait
+VKFUNC_DEVICE(vkWaitForPresentKHR);
+
 // transform feedback extension
 VKFUNC_DEVICE(vkCmdBindTransformFeedbackBuffersEXT);
 VKFUNC_DEVICE(vkCmdBeginTransformFeedbackEXT);
@@ -188,6 +199,7 @@ VKFUNC_DEVICE(vkCmdEndTransformFeedbackEXT);
 
 // query
 VKFUNC_DEVICE(vkCreateQueryPool);
+VKFUNC_DEVICE(vkDestroyQueryPool);
 VKFUNC_DEVICE(vkCmdResetQueryPool);
 VKFUNC_DEVICE(vkCmdBeginQuery);
 VKFUNC_DEVICE(vkCmdEndQuery);
@@ -226,6 +238,7 @@ VKFUNC_DEVICE(vkAllocateDescriptorSets);
 VKFUNC_DEVICE(vkFreeDescriptorSets);
 VKFUNC_DEVICE(vkUpdateDescriptorSets);
 VKFUNC_DEVICE(vkCreateDescriptorPool);
+VKFUNC_DEVICE(vkDestroyDescriptorPool);
 VKFUNC_DEVICE(vkDestroyDescriptorSetLayout);
 
 #undef VKFUNC_INIT
@@ -235,4 +248,5 @@ VKFUNC_DEVICE(vkDestroyDescriptorSetLayout);
 
 #undef VKFUNC
 #undef VKFUNC_INSTANCE
-#undef VKFUNC_DEVICE
\ No newline at end of file
+#undef VKFUNC_DEVICE
+#undef VKFUNC_DEFINE_CUSTOM
diff --git a/src/Cafe/HW/Latte/Renderer/Vulkan/VulkanPipelineCompiler.cpp b/src/Cafe/HW/Latte/Renderer/Vulkan/VulkanPipelineCompiler.cpp
index 7fb506b7..7555c03a 100644
--- a/src/Cafe/HW/Latte/Renderer/Vulkan/VulkanPipelineCompiler.cpp
+++ b/src/Cafe/HW/Latte/Renderer/Vulkan/VulkanPipelineCompiler.cpp
@@ -225,7 +225,7 @@ VkFormat PipelineCompiler::GetVertexFormat(uint8 format)
 	case FMT_2_10_10_10:
 		return VK_FORMAT_R32_UINT; // verified to match OpenGL
 	default:
-		forceLog_printf("Unsupported vertex format: %02x", format);
+		cemuLog_log(LogType::Force, "Unsupported vertex format: {:02x}", format);
 		assert_dbg();
 		return VK_FORMAT_UNDEFINED;
 	}
@@ -398,7 +398,7 @@ bool PipelineCompiler::InitShaderStages(VulkanRenderer* vkRenderer, RendererShad
 		(vkGeometryShader && vkGeometryShader->GetShaderModule() == VK_NULL_HANDLE) ||
 		(vkPixelShader && vkPixelShader->GetShaderModule() == VK_NULL_HANDLE))
 	{
-		forceLog_printf("Vulkan-Info: Pipeline creation failed due to invalid shader(s)");
+		cemuLog_log(LogType::Force, "Vulkan-Info: Pipeline creation failed due to invalid shader(s)");
 		return false;
 	}
 
@@ -457,6 +457,11 @@ void PipelineCompiler::InitVertexInputState(const LatteContextRegister& latteReg
 		uint32 bufferStride = (latteRegister.GetRawView()[bufferBaseRegisterIndex + 2] >> 11) & 0xFFFF;
 
 		VkVertexInputBindingDescription entry{};
+#if BOOST_OS_MACOS
+		if (bufferStride % 4 != 0) {
+			bufferStride = bufferStride + (4-(bufferStride % 4));
+		}
+#endif
 		entry.stride = bufferStride;
 		if (!fetchType.has_value() || fetchType == LatteConst::VertexFetchType2::VERTEX_DATA)
 			entry.inputRate = VK_VERTEX_INPUT_RATE_VERTEX;
@@ -523,7 +528,7 @@ void PipelineCompiler::InitInputAssemblyState(const Latte::LATTE_VGT_PRIMITIVE_T
 		inputAssembly.primitiveRestartEnable = false;
 		break;
 	default:
-		forceLogDebug_printf("Vulkan-Unsupported: Graphics pipeline with primitive mode %d created", primitiveMode);
+		cemuLog_logDebug(LogType::Force, "Vulkan-Unsupported: Graphics pipeline with primitive mode {} created", primitiveMode);
 		cemu_assert_debug(false);
 	}
 }
@@ -553,8 +558,8 @@ void PipelineCompiler::InitRasterizerState(const LatteContextRegister& latteRegi
 	rasterizerExt.flags = 0;
 
 	rasterizer.sType = VK_STRUCTURE_TYPE_PIPELINE_RASTERIZATION_STATE_CREATE_INFO;
-	rasterizer.pNext = &rasterizerExt;
 	rasterizer.rasterizerDiscardEnable = LatteGPUState.contextNew.PA_CL_CLIP_CNTL.get_DX_RASTERIZATION_KILL();
+	rasterizer.pNext = VulkanRenderer::GetInstance()->m_featureControl.deviceExtensions.depth_clip_enable ? &rasterizerExt : nullptr;
 	// GX2SetSpecialState(0, true) workaround
 	if (!LatteGPUState.contextNew.PA_CL_VTE_CNTL.get_VPORT_X_OFFSET_ENA())
 		rasterizer.rasterizerDiscardEnable = false;
@@ -609,7 +614,29 @@ void PipelineCompiler::InitRasterizerState(const LatteContextRegister& latteRegi
 	multisampling.rasterizationSamples = VK_SAMPLE_COUNT_1_BIT;
 }
 
-void PipelineCompiler::InitBlendState(const LatteContextRegister& latteRegister, PipelineInfo* pipelineInfo, bool& usesBlendConstants)
+bool _IsVkIntegerFormat(VkFormat fmt)
+{
+	return
+		// 8bit integer formats
+		fmt == VK_FORMAT_R8_UINT || fmt == VK_FORMAT_R8_SINT ||
+		fmt == VK_FORMAT_R8G8_UINT || fmt == VK_FORMAT_R8G8_SINT ||
+		fmt == VK_FORMAT_R8G8B8_UINT || fmt == VK_FORMAT_R8G8B8_SINT ||
+		fmt == VK_FORMAT_R8G8B8A8_UINT || fmt == VK_FORMAT_R8G8B8A8_SINT ||
+		fmt == VK_FORMAT_B8G8R8A8_UINT || fmt == VK_FORMAT_B8G8R8A8_SINT ||
+		// 16bit integer formats
+		fmt == VK_FORMAT_R16_UINT || fmt == VK_FORMAT_R16_SINT ||
+		fmt == VK_FORMAT_R16G16_UINT || fmt == VK_FORMAT_R16G16_SINT ||
+		fmt == VK_FORMAT_R16G16B16_UINT || fmt == VK_FORMAT_R16G16B16_SINT ||
+		fmt == VK_FORMAT_R16G16B16A16_UINT || fmt == VK_FORMAT_R16G16B16A16_SINT ||
+		// 32bit integer formats
+		fmt == VK_FORMAT_R32_UINT || fmt == VK_FORMAT_R32_SINT ||
+		fmt == VK_FORMAT_R32G32_UINT || fmt == VK_FORMAT_R32G32_SINT ||
+		fmt == VK_FORMAT_R32G32B32_UINT || fmt == VK_FORMAT_R32G32B32_SINT ||
+		fmt == VK_FORMAT_R32G32B32A32_UINT || fmt == VK_FORMAT_R32G32B32A32_SINT;
+}
+
+
+void PipelineCompiler::InitBlendState(const LatteContextRegister& latteRegister, PipelineInfo* pipelineInfo, bool& usesBlendConstants, VKRObjectRenderPass* renderPassObj)
 {
 	const Latte::LATTE_CB_COLOR_CONTROL& colorControlReg = latteRegister.CB_COLOR_CONTROL;
 	uint32 blendEnableMask = colorControlReg.get_BLEND_MASK();
@@ -625,6 +652,12 @@ void PipelineCompiler::InitBlendState(const LatteContextRegister& latteRegister,
 		else
 			entry.blendEnable = VK_FALSE;
 
+		if (entry.blendEnable != VK_FALSE && _IsVkIntegerFormat(renderPassObj->GetColorFormat(i)))
+		{
+			// force-disable blending for integer formats
+			entry.blendEnable = VK_FALSE;
+		}
+		
 		const auto& blendControlReg = latteRegister.CB_BLENDN_CONTROL[i];
 
 		entry.colorWriteMask = (renderTargetMask >> (i * 4)) & 0xF;
@@ -697,7 +730,7 @@ void PipelineCompiler::InitDescriptorSetLayouts(VulkanRenderer* vkRenderer, Pipe
 	{
 		cemu_assert_debug(descriptorSetLayoutCount == 0);
 		CreateDescriptorSetLayout(vkRenderer, vertexShader, descriptorSetLayout[descriptorSetLayoutCount], vkrPipelineInfo);
-		vkObjPipeline->vertexDSL = descriptorSetLayout[descriptorSetLayoutCount];
+		vkObjPipeline->m_vertexDSL = descriptorSetLayout[descriptorSetLayoutCount];
 		descriptorSetLayoutCount++;
 	}
 
@@ -705,7 +738,7 @@ void PipelineCompiler::InitDescriptorSetLayouts(VulkanRenderer* vkRenderer, Pipe
 	{
 		cemu_assert_debug(descriptorSetLayoutCount == 1);
 		CreateDescriptorSetLayout(vkRenderer, pixelShader, descriptorSetLayout[descriptorSetLayoutCount], vkrPipelineInfo);
-		vkObjPipeline->pixelDSL = descriptorSetLayout[descriptorSetLayoutCount];
+		vkObjPipeline->m_pixelDSL = descriptorSetLayout[descriptorSetLayoutCount];
 		descriptorSetLayoutCount++;
 	}
 	else if (geometryShader)
@@ -724,7 +757,7 @@ void PipelineCompiler::InitDescriptorSetLayouts(VulkanRenderer* vkRenderer, Pipe
 	{
 		cemu_assert_debug(descriptorSetLayoutCount == 2);
 		CreateDescriptorSetLayout(vkRenderer, geometryShader, descriptorSetLayout[descriptorSetLayoutCount], vkrPipelineInfo);
-		vkObjPipeline->geometryDSL = descriptorSetLayout[descriptorSetLayoutCount];
+		vkObjPipeline->m_geometryDSL = descriptorSetLayout[descriptorSetLayoutCount];
 		descriptorSetLayoutCount++;
 	}
 }
@@ -793,7 +826,7 @@ void PipelineCompiler::InitDepthStencilState()
 
 	depthStencilState.front.reference = stencilRefFront;
 	depthStencilState.front.compareMask = stencilCompareMaskFront;
-	depthStencilState.front.writeMask = stencilWriteMaskBack;
+	depthStencilState.front.writeMask = stencilWriteMaskFront;
 	depthStencilState.front.compareOp = vkDepthCompareTable[(size_t)frontStencilFunc];
 	depthStencilState.front.depthFailOp = stencilOpTable[(size_t)frontStencilZFail];
 	depthStencilState.front.failOp = stencilOpTable[(size_t)frontStencilFail];
@@ -840,7 +873,7 @@ void PipelineCompiler::InitDynamicState(PipelineInfo* pipelineInfo, bool usesBle
 	dynamicState.pDynamicStates = dynamicStates.data();
 }
 
-bool PipelineCompiler::InitFromCurrentGPUState(PipelineInfo* pipelineInfo, const LatteContextRegister& latteRegister, VKRObjectRenderPass* renderPassObj)
+bool PipelineCompiler::InitFromCurrentGPUState(PipelineInfo* pipelineInfo, const LatteContextRegister& latteRegister, VKRObjectRenderPass* renderPassObj, bool requireRobustBufferAccess)
 {
 	VulkanRenderer* vkRenderer = VulkanRenderer::GetInstance();
 
@@ -855,6 +888,7 @@ bool PipelineCompiler::InitFromCurrentGPUState(PipelineInfo* pipelineInfo, const
 	m_vkGeometryShader = pipelineInfo->geometryShaderVk;
 	m_vkrObjPipeline = pipelineInfo->m_vkrObjPipeline;
 	m_renderPassObj = renderPassObj;
+	m_requestRobustBufferAccess = requireRobustBufferAccess;
 
 	// if required generate RECT emulation geometry shader
 	if (!vkRenderer->m_featureControl.deviceExtensions.nv_fill_rectangle && isPrimitiveRect)
@@ -873,7 +907,7 @@ bool PipelineCompiler::InitFromCurrentGPUState(PipelineInfo* pipelineInfo, const
 	bool usesDepthBias = false;
 	InitRasterizerState(latteRegister, vkRenderer, isPrimitiveRect, usesDepthBias);
 	bool usesBlendConstants = false;
-	InitBlendState(latteRegister, pipelineInfo, usesBlendConstants);
+	InitBlendState(latteRegister, pipelineInfo, usesBlendConstants, renderPassObj);
 	InitDescriptorSetLayouts(vkRenderer, pipelineInfo, pipelineInfo->vertexShader, pipelineInfo->pixelShader, pipelineInfo->geometryShader);
 
 	// ##########################################################################################################################################
@@ -885,10 +919,10 @@ bool PipelineCompiler::InitFromCurrentGPUState(PipelineInfo* pipelineInfo, const
 	pipelineLayoutInfo.pPushConstantRanges = nullptr;
 	pipelineLayoutInfo.pushConstantRangeCount = 0;
 
-	VkResult result = vkCreatePipelineLayout(vkRenderer->m_logicalDevice, &pipelineLayoutInfo, nullptr, &m_pipeline_layout);
+	VkResult result = vkCreatePipelineLayout(vkRenderer->m_logicalDevice, &pipelineLayoutInfo, nullptr, &m_pipelineLayout);
 	if (result != VK_SUCCESS)
 	{
-		forceLog_printf("%s", fmt::format("Failed to create pipeline layout: {}", result).c_str());
+		cemuLog_log(LogType::Force, "Failed to create pipeline layout: {}", result);
 		s_nvidiaWorkaround.unlock();
 		return false;
 	}
@@ -903,7 +937,7 @@ bool PipelineCompiler::InitFromCurrentGPUState(PipelineInfo* pipelineInfo, const
 
 	// ##########################################################################################################################################
 
-	pipelineInfo->m_vkrObjPipeline->pipeline_layout = m_pipeline_layout;
+	pipelineInfo->m_vkrObjPipeline->m_pipelineLayout = m_pipelineLayout;
 
 	// increment ref counter for vkrObjPipeline and renderpass object to make sure they dont get released while we are using them
 	m_vkrObjPipeline->incRef();
@@ -956,7 +990,7 @@ bool PipelineCompiler::Compile(bool forceCompile, bool isRenderThread, bool show
 	pipelineInfo.pRasterizationState = &rasterizer;
 	pipelineInfo.pMultisampleState = &multisampling;
 	pipelineInfo.pColorBlendState = &colorBlending;
-	pipelineInfo.layout = m_pipeline_layout;
+	pipelineInfo.layout = m_pipelineLayout;
 	pipelineInfo.renderPass = m_renderPassObj->m_renderPass;
 	pipelineInfo.pDepthStencilState = &depthStencilState;
 	pipelineInfo.subpass = 0;
@@ -965,6 +999,8 @@ bool PipelineCompiler::Compile(bool forceCompile, bool isRenderThread, bool show
 	if (!forceCompile)
 		pipelineInfo.flags |= VK_PIPELINE_CREATE_FAIL_ON_PIPELINE_COMPILE_REQUIRED_BIT_EXT;
 
+	void* prevStruct = nullptr;
+
 	VkPipelineCreationFeedbackCreateInfoEXT creationFeedbackInfo;
 	VkPipelineCreationFeedbackEXT creationFeedback;
 	std::vector<VkPipelineCreationFeedbackEXT> creationStageFeedback(0);
@@ -982,9 +1018,25 @@ bool PipelineCompiler::Compile(bool forceCompile, bool isRenderThread, bool show
 		creationFeedbackInfo.pPipelineCreationFeedback = &creationFeedback;
 		creationFeedbackInfo.pPipelineStageCreationFeedbacks = creationStageFeedback.data();
 		creationFeedbackInfo.pipelineStageCreationFeedbackCount = pipelineInfo.stageCount;
-		pipelineInfo.pNext = &creationFeedbackInfo;
+		creationFeedbackInfo.pNext = prevStruct;
+		prevStruct = &creationFeedbackInfo;
 	}
 
+	VkPipelineRobustnessCreateInfoEXT pipelineRobustnessCreateInfo{};
+	if (vkRenderer->m_featureControl.deviceExtensions.pipeline_robustness && m_requestRobustBufferAccess)
+	{
+		// per-pipeline handling of robust buffer access, if the extension is not available then we fall back to device feature robustBufferAccess
+		pipelineRobustnessCreateInfo.sType = VK_STRUCTURE_TYPE_PIPELINE_ROBUSTNESS_CREATE_INFO_EXT;
+		pipelineRobustnessCreateInfo.pNext = prevStruct;
+		prevStruct = &pipelineRobustnessCreateInfo;
+		pipelineRobustnessCreateInfo.storageBuffers = VK_PIPELINE_ROBUSTNESS_BUFFER_BEHAVIOR_ROBUST_BUFFER_ACCESS_EXT;
+		pipelineRobustnessCreateInfo.uniformBuffers = VK_PIPELINE_ROBUSTNESS_BUFFER_BEHAVIOR_ROBUST_BUFFER_ACCESS_EXT;
+		pipelineRobustnessCreateInfo.vertexInputs = VK_PIPELINE_ROBUSTNESS_BUFFER_BEHAVIOR_DEVICE_DEFAULT_EXT;
+		pipelineRobustnessCreateInfo.images = VK_PIPELINE_ROBUSTNESS_IMAGE_BEHAVIOR_DEVICE_DEFAULT_EXT;
+	}
+
+	pipelineInfo.pNext = prevStruct;
+
 	VkPipeline pipeline = VK_NULL_HANDLE;
 	VkResult result;
 	uint8 retryCount = 0;
@@ -1004,11 +1056,11 @@ bool PipelineCompiler::Compile(bool forceCompile, bool isRenderThread, bool show
 	}
 	else if (result == VK_SUCCESS)
 	{
-		m_vkrObjPipeline->setPipeline(pipeline);
+		m_vkrObjPipeline->SetPipeline(pipeline);
 	}
 	else
 	{
-		forceLog_printf("Failed to create graphics pipeline. Error %d", (sint32)result);
+		cemuLog_log(LogType::Force, "Failed to create graphics pipeline. Error {}", (sint32)result);
 		cemu_assert_debug(false);
 		return true; // true indicates that caller should no longer attempt to compile this pipeline again
 	}
@@ -1042,3 +1094,31 @@ void PipelineCompiler::TrackAsCached(uint64 baseHash, uint64 pipelineStateHash)
 		return;
 	pipelineCache.AddCurrentStateToCache(baseHash, pipelineStateHash);
 }
+
+// calculate whether the pipeline requires robust buffer access
+// if there is a potential risk for a shader to do out-of-bounds reads or writes we need to enable robust buffer access
+// this can happen when:
+// - Streamout is used with too small of a buffer (probably? Could also be some issue with how the streamout array index is calculated -> We can maybe fix this in the future)
+// - The shader uses dynamic indices for uniform access. This will trigger the uniform mode to be FULL_CBANK
+bool PipelineCompiler::CalcRobustBufferAccessRequirement(LatteDecompilerShader* vertexShader, LatteDecompilerShader* pixelShader, LatteDecompilerShader* geometryShader)
+{
+	bool requiresRobustBufferAcces = false;
+	if (vertexShader)
+	{
+		cemu_assert_debug(vertexShader->shaderType == LatteConst::ShaderType::Vertex);
+		requiresRobustBufferAcces |= vertexShader->hasStreamoutBufferWrite;
+		requiresRobustBufferAcces |= vertexShader->uniformMode == LATTE_DECOMPILER_UNIFORM_MODE_FULL_CBANK;
+	}
+	if (geometryShader)
+	{
+		cemu_assert_debug(geometryShader->shaderType == LatteConst::ShaderType::Geometry);
+		requiresRobustBufferAcces |= geometryShader->hasStreamoutBufferWrite;
+		requiresRobustBufferAcces |= geometryShader->uniformMode == LATTE_DECOMPILER_UNIFORM_MODE_FULL_CBANK;
+	}
+	if (pixelShader)
+	{
+		cemu_assert_debug(pixelShader->shaderType == LatteConst::ShaderType::Pixel);
+		requiresRobustBufferAcces |= pixelShader->uniformMode == LATTE_DECOMPILER_UNIFORM_MODE_FULL_CBANK;
+	}
+	return requiresRobustBufferAcces;
+}
diff --git a/src/Cafe/HW/Latte/Renderer/Vulkan/VulkanPipelineCompiler.h b/src/Cafe/HW/Latte/Renderer/Vulkan/VulkanPipelineCompiler.h
index 4020b27e..7297049e 100644
--- a/src/Cafe/HW/Latte/Renderer/Vulkan/VulkanPipelineCompiler.h
+++ b/src/Cafe/HW/Latte/Renderer/Vulkan/VulkanPipelineCompiler.h
@@ -23,7 +23,7 @@ private:
 	void InitInputAssemblyState(const Latte::LATTE_VGT_PRIMITIVE_TYPE::E_PRIMITIVE_TYPE primitiveMode);
 	void InitViewportState();
 	void InitRasterizerState(const LatteContextRegister& latteRegister, VulkanRenderer* vkRenderer, bool isPrimitiveRect, bool& usesDepthBias);
-	void InitBlendState(const LatteContextRegister& latteRegister, PipelineInfo* pipelineInfo, bool& usesBlendConstants);
+	void InitBlendState(const LatteContextRegister& latteRegister, PipelineInfo* pipelineInfo, bool& usesBlendConstants, VKRObjectRenderPass* renderPassObj);
 	void InitDescriptorSetLayouts(VulkanRenderer* vkRenderer, PipelineInfo* vkrPipelineInfo, LatteDecompilerShader* vertexShader, LatteDecompilerShader* pixelShader, LatteDecompilerShader* geometryShader);
 	void InitDepthStencilState();
 	void InitDynamicState(PipelineInfo* pipelineInfo, bool usesBlendConstants, bool usesDepthBias);
@@ -38,11 +38,14 @@ public:
 	RendererShaderVk* m_vkPixelShader{};
 	RendererShaderVk* m_vkGeometryShader{};
 
-	bool InitFromCurrentGPUState(PipelineInfo* pipelineInfo, const LatteContextRegister& latteRegister, VKRObjectRenderPass* renderPassObj);
+	bool InitFromCurrentGPUState(PipelineInfo* pipelineInfo, const LatteContextRegister& latteRegister, VKRObjectRenderPass* renderPassObj, bool requireRobustBufferAccess);
 	void TrackAsCached(uint64 baseHash, uint64 pipelineStateHash); // stores pipeline to permanent cache if not yet cached. Must be called synchronously from render thread due to dependency on GPU state
 
-	VkPipelineLayout m_pipeline_layout;
+	static bool CalcRobustBufferAccessRequirement(LatteDecompilerShader* vertexShader, LatteDecompilerShader* pixelShader, LatteDecompilerShader* geometryShader);
+
+	VkPipelineLayout m_pipelineLayout;
 	VKRObjectRenderPass* m_renderPassObj{};
+	bool m_requestRobustBufferAccess{false};
 
 	/* shader stages */
 	std::vector<VkPipelineShaderStageCreateInfo> shaderStages;
diff --git a/src/Cafe/HW/Latte/Renderer/Vulkan/VulkanPipelineStableCache.cpp b/src/Cafe/HW/Latte/Renderer/Vulkan/VulkanPipelineStableCache.cpp
index 50d5a256..9f8f4491 100644
--- a/src/Cafe/HW/Latte/Renderer/Vulkan/VulkanPipelineStableCache.cpp
+++ b/src/Cafe/HW/Latte/Renderer/Vulkan/VulkanPipelineStableCache.cpp
@@ -32,8 +32,8 @@ VulkanPipelineStableCache& VulkanPipelineStableCache::GetInstance()
 uint32 VulkanPipelineStableCache::BeginLoading(uint64 cacheTitleId)
 {
 	std::error_code ec;
-	fs::create_directories(ActiveSettings::GetPath("shaderCache/transferable"), ec);
-	const auto pathCacheFile = ActiveSettings::GetPath("shaderCache/transferable/{:016x}_vkpipeline.bin", cacheTitleId);
+	fs::create_directories(ActiveSettings::GetCachePath("shaderCache/transferable"), ec);
+	const auto pathCacheFile = ActiveSettings::GetCachePath("shaderCache/transferable/{:016x}_vkpipeline.bin", cacheTitleId);
 	
 	// init cache loader state
 	g_vkCacheState.pipelineLoadIndex = 0;
@@ -59,11 +59,10 @@ uint32 VulkanPipelineStableCache::BeginLoading(uint64 cacheTitleId)
 
 	// open cache file or create it
 	cemu_assert_debug(s_cache == nullptr);
-	const uint32 cacheFileVersion = 1;
-	s_cache = FileCache::Open(pathCacheFile.generic_wstring(), true, LatteShaderCache_getPipelineCacheExtraVersion(cacheTitleId));
+	s_cache = FileCache::Open(pathCacheFile, true, LatteShaderCache_getPipelineCacheExtraVersion(cacheTitleId));
 	if (!s_cache)
 	{
-		cemuLog_log(LogType::Force, "Failed to open or create Vulkan pipeline cache file: {}", pathCacheFile.generic_string());
+		cemuLog_log(LogType::Force, "Failed to open or create Vulkan pipeline cache file: {}", _pathToUtf8(pathCacheFile));
 		return 0;
 	}
 	else
@@ -118,6 +117,15 @@ void VulkanPipelineStableCache::EndLoading()
 	// keep cache file open for writing of new pipelines
 }
 
+void VulkanPipelineStableCache::Close()
+{
+    if(s_cache)
+    {
+        delete s_cache;
+        s_cache = nullptr;
+    }
+}
+
 struct CachedPipeline
 {
 	struct ShaderHash
@@ -206,14 +214,18 @@ void VulkanPipelineStableCache::LoadPipelineFromCache(std::span<uint8> fileData)
 
 	// deserialize file
 	LatteContextRegister* lcr = new LatteContextRegister();
-	s_spinlockSharedInternal.acquire();
+	s_spinlockSharedInternal.lock();
 	CachedPipeline* cachedPipeline = new CachedPipeline();
-	s_spinlockSharedInternal.release();
+	s_spinlockSharedInternal.unlock();
 
 	MemStreamReader streamReader(fileData.data(), fileData.size());
 	if (!DeserializePipeline(streamReader, *cachedPipeline))
 	{
 		// failed to deserialize
+		s_spinlockSharedInternal.lock();
+		delete lcr;
+		delete cachedPipeline;
+		s_spinlockSharedInternal.unlock();
 		return;
 	}
 	// restored register view from compacted state
@@ -228,7 +240,7 @@ void VulkanPipelineStableCache::LoadPipelineFromCache(std::span<uint8> fileData)
 		vertexShader = LatteSHRC_FindVertexShader(cachedPipeline->vsHash.baseHash, cachedPipeline->vsHash.auxHash);
 		if (!vertexShader)
 		{
-			forceLogDebug_printf("Vertex shader not found in cache");
+			cemuLog_logDebug(LogType::Force, "Vertex shader not found in cache");
 			return;
 		}
 	}
@@ -238,7 +250,7 @@ void VulkanPipelineStableCache::LoadPipelineFromCache(std::span<uint8> fileData)
 		geometryShader = LatteSHRC_FindGeometryShader(cachedPipeline->gsHash.baseHash, cachedPipeline->gsHash.auxHash);
 		if (!geometryShader)
 		{
-			forceLogDebug_printf("Geometry shader not found in cache");
+			cemuLog_logDebug(LogType::Force, "Geometry shader not found in cache");
 			return;
 		}
 	}
@@ -248,7 +260,7 @@ void VulkanPipelineStableCache::LoadPipelineFromCache(std::span<uint8> fileData)
 		pixelShader = LatteSHRC_FindPixelShader(cachedPipeline->psHash.baseHash, cachedPipeline->psHash.auxHash);
 		if (!pixelShader)
 		{
-			forceLogDebug_printf("Pixel shader not found in cache");
+			cemuLog_logDebug(LogType::Force, "Pixel shader not found in cache");
 			return;
 		}
 	}
@@ -260,36 +272,36 @@ void VulkanPipelineStableCache::LoadPipelineFromCache(std::span<uint8> fileData)
 	}
 	auto renderPass = __CreateTemporaryRenderPass(pixelShader, *lcr);
 	// create pipeline info
-	m_pipelineIsCachedLock.acquire();
+	m_pipelineIsCachedLock.lock();
 	PipelineInfo* pipelineInfo = new PipelineInfo(0, 0, vertexShader->compatibleFetchShader, vertexShader, pixelShader, geometryShader);
-	m_pipelineIsCachedLock.release();
+	m_pipelineIsCachedLock.unlock();
 	// compile
 	{
-		PipelineCompiler pp;
-		if (!pp.InitFromCurrentGPUState(pipelineInfo, *lcr, renderPass))
+		PipelineCompiler pipelineCompiler;
+		bool requiresRobustBufferAccess = PipelineCompiler::CalcRobustBufferAccessRequirement(vertexShader, pixelShader, geometryShader);
+		if (!pipelineCompiler.InitFromCurrentGPUState(pipelineInfo, *lcr, renderPass, requiresRobustBufferAccess))
 		{
-			s_spinlockSharedInternal.acquire();
+			s_spinlockSharedInternal.lock();
 			delete lcr;
 			delete cachedPipeline;
-			s_spinlockSharedInternal.release();
+			s_spinlockSharedInternal.unlock();
 			return;
 		}
-		pp.Compile(true, true, false);
-		// destroy pp early
+		pipelineCompiler.Compile(true, true, false);
 	}
 	// on success, calculate pipeline hash and flag as present in cache
 	uint64 pipelineBaseHash = vertexShader->baseHash;
 	uint64 pipelineStateHash = VulkanRenderer::draw_calculateGraphicsPipelineHash(vertexShader->compatibleFetchShader, vertexShader, geometryShader, pixelShader, renderPass, *lcr);
-	m_pipelineIsCachedLock.acquire();
+	m_pipelineIsCachedLock.lock();
 	m_pipelineIsCached.emplace(pipelineBaseHash, pipelineStateHash);
-	m_pipelineIsCachedLock.release();
+	m_pipelineIsCachedLock.unlock();
 	// clean up
-	s_spinlockSharedInternal.acquire();
+	s_spinlockSharedInternal.lock();
 	delete pipelineInfo;
 	delete lcr;
 	delete cachedPipeline;
-	VulkanRenderer::GetInstance()->releaseDestructibleObject(renderPass);
-	s_spinlockSharedInternal.release();
+	VulkanRenderer::GetInstance()->ReleaseDestructibleObject(renderPass);
+	s_spinlockSharedInternal.unlock();
 }
 
 bool VulkanPipelineStableCache::HasPipelineCached(uint64 baseHash, uint64 pipelineStateHash)
@@ -396,6 +408,7 @@ bool VulkanPipelineStableCache::DeserializePipeline(MemStreamReader& memReader,
 
 int VulkanPipelineStableCache::CompilerThread()
 {
+	SetThreadName("plCacheCompiler");
 	while (m_numCompilationThreads != 0)
 	{
 		std::vector<uint8> pipelineData = m_compilationQueue.pop();
@@ -409,6 +422,7 @@ int VulkanPipelineStableCache::CompilerThread()
 
 void VulkanPipelineStableCache::WorkerThread()
 {
+	SetThreadName("plCacheWriter");
 	while (true)
 	{
 		CachedPipeline* job;
@@ -430,4 +444,4 @@ void VulkanPipelineStableCache::WorkerThread()
 		s_cache->AddFileAsync({ nameA, nameB }, blob.data(), blob.size());
 		delete job;
 	}
-}
\ No newline at end of file
+}
diff --git a/src/Cafe/HW/Latte/Renderer/Vulkan/VulkanPipelineStableCache.h b/src/Cafe/HW/Latte/Renderer/Vulkan/VulkanPipelineStableCache.h
index dbf64614..7cba2930 100644
--- a/src/Cafe/HW/Latte/Renderer/Vulkan/VulkanPipelineStableCache.h
+++ b/src/Cafe/HW/Latte/Renderer/Vulkan/VulkanPipelineStableCache.h
@@ -3,7 +3,7 @@
 
 struct VulkanPipelineHash
 {
-	VulkanPipelineHash() {};
+	VulkanPipelineHash() = default;
 	VulkanPipelineHash(uint64 h0, uint64 h1) : h0(h0), h1(h1) {};
 
 	uint64 h0;
@@ -41,6 +41,7 @@ public:
 	bool UpdateLoading(uint32& pipelinesLoadedTotal, uint32& pipelinesMissingShaders);
 	void EndLoading();
 	void LoadPipelineFromCache(std::span<uint8> fileData);
+    void Close(); // called on title exit
 
 	bool HasPipelineCached(uint64 baseHash, uint64 pipelineStateHash);
 	void AddCurrentStateToCache(uint64 baseHash, uint64 pipelineStateHash);
diff --git a/src/Cafe/HW/Latte/Renderer/Vulkan/VulkanQuery.cpp b/src/Cafe/HW/Latte/Renderer/Vulkan/VulkanQuery.cpp
index 18e5e407..f9788c9c 100644
--- a/src/Cafe/HW/Latte/Renderer/Vulkan/VulkanQuery.cpp
+++ b/src/Cafe/HW/Latte/Renderer/Vulkan/VulkanQuery.cpp
@@ -112,7 +112,7 @@ uint32 LatteQueryObjectVk::acquireQueryIndex()
 {
 	if (m_rendererVk->m_occlusionQueries.list_availableQueryIndices.empty())
 	{
-		forceLog_printf("Vulkan-Error: Exhausted query pool");
+		cemuLog_log(LogType::Force, "Vulkan-Error: Exhausted query pool");
 		assert_dbg();
 	}
 	uint32 queryIndex = m_rendererVk->m_occlusionQueries.list_availableQueryIndices.back();
@@ -152,7 +152,7 @@ LatteQueryObject* VulkanRenderer::occlusionQuery_create()
 		auto r = vkCreateQueryPool(m_logicalDevice, &queryPoolCreateInfo, nullptr, &m_occlusionQueries.queryPool);
 		if (r != VK_SUCCESS)
 		{
-			forceLog_printf("Vulkan-Error: Failed to create query pool with error %d", (sint32)r);
+			cemuLog_log(LogType::Force, "Vulkan-Error: Failed to create query pool with error {}", (sint32)r);
 			return nullptr;
 		}
 	}
@@ -209,4 +209,4 @@ void VulkanRenderer::occlusionQuery_notifyBeginCommandBuffer()
 	for (auto& it : m_occlusionQueries.list_currentlyActiveQueries)
 		if (it->m_hasActiveQuery)
 			it->beginFragment();
-}
\ No newline at end of file
+}
diff --git a/src/Cafe/HW/Latte/Renderer/Vulkan/VulkanRenderer.cpp b/src/Cafe/HW/Latte/Renderer/Vulkan/VulkanRenderer.cpp
index 7c81a3c9..aed0db25 100644
--- a/src/Cafe/HW/Latte/Renderer/Vulkan/VulkanRenderer.cpp
+++ b/src/Cafe/HW/Latte/Renderer/Vulkan/VulkanRenderer.cpp
@@ -7,6 +7,7 @@
 
 #include "Cafe/HW/Latte/Core/LatteBufferCache.h"
 #include "Cafe/HW/Latte/Core/LattePerformanceMonitor.h"
+#include "Cafe/HW/Latte/Core/LatteOverlay.h"
 
 #include "Cafe/HW/Latte/LegacyShaderDecompiler/LatteDecompiler.h"
 
@@ -26,24 +27,31 @@
 
 #include "Cafe/HW/Latte/Core/LatteTiming.h" // vsync control
 
-#include <glslang/Include/Types.h>
+#include <glslang/Public/ShaderLang.h>
 
 #include <wx/msgdlg.h>
+#include <wx/intl.h> // for localization
 
+#ifndef VK_API_VERSION_MAJOR
 #define VK_API_VERSION_MAJOR(version) (((uint32_t)(version) >> 22) & 0x7FU)
 #define VK_API_VERSION_MINOR(version) (((uint32_t)(version) >> 12) & 0x3FFU)
+#endif
 
 extern std::atomic_int g_compiling_pipelines;
 
 const  std::vector<const char*> kOptionalDeviceExtensions =
 {
-	//VK_EXT_TRANSFORM_FEEDBACK_EXTENSION_NAME,
 	VK_EXT_DEPTH_RANGE_UNRESTRICTED_EXTENSION_NAME,
 	VK_NV_FILL_RECTANGLE_EXTENSION_NAME,
 	VK_EXT_PIPELINE_CREATION_FEEDBACK_EXTENSION_NAME,
 	VK_EXT_FILTER_CUBIC_EXTENSION_NAME, // not supported by any device yet
 	VK_EXT_EXTERNAL_MEMORY_HOST_EXTENSION_NAME,
 	VK_KHR_SYNCHRONIZATION_2_EXTENSION_NAME,
+	VK_KHR_SHADER_FLOAT_CONTROLS_EXTENSION_NAME,
+	VK_KHR_PRESENT_WAIT_EXTENSION_NAME,
+	VK_KHR_PRESENT_ID_EXTENSION_NAME,
+	VK_EXT_DEPTH_CLIP_ENABLE_EXTENSION_NAME,
+	VK_EXT_PIPELINE_ROBUSTNESS_EXTENSION_NAME
 };
 
 const std::vector<const char*> kRequiredDeviceExtensions =
@@ -54,7 +62,7 @@ const std::vector<const char*> kRequiredDeviceExtensions =
 
 VKAPI_ATTR VkBool32 VKAPI_CALL DebugUtilsCallback(VkDebugUtilsMessageSeverityFlagBitsEXT messageSeverity, VkDebugUtilsMessageTypeFlagsEXT messageTypes, const VkDebugUtilsMessengerCallbackDataEXT* pCallbackData, void* pUserData)
 {
-#ifndef PUBLIC_RELEASE
+#ifdef CEMU_DEBUG_ASSERT
 
 	if (strstr(pCallbackData->pMessage, "consumes input location"))
 		return VK_FALSE; // false means we dont care
@@ -76,11 +84,9 @@ VKAPI_ATTR VkBool32 VKAPI_CALL DebugUtilsCallback(VkDebugUtilsMessageSeverityFla
 	if (strstr(pCallbackData->pMessage, "Number of currently valid sampler objects is not less than the maximum allowed"))
 		return VK_FALSE;
 
-	assert_dbg();
-
 #endif
 
-	cafeLog_logLine(LOG_TYPE_FORCE, (char*)pCallbackData->pMessage);
+	cemuLog_log(LogType::Force, (char*)pCallbackData->pMessage);
 
 	return VK_FALSE;
 }
@@ -107,7 +113,13 @@ std::vector<VulkanRenderer::DeviceInfo> VulkanRenderer::GetDevices()
 	#if BOOST_OS_WINDOWS
 	requiredExtensions.emplace_back(VK_KHR_WIN32_SURFACE_EXTENSION_NAME);
 	#elif BOOST_OS_LINUX
-	requiredExtensions.emplace_back(VK_KHR_XLIB_SURFACE_EXTENSION_NAME);
+	auto backend = gui_getWindowInfo().window_main.backend;
+	if(backend == WindowHandleInfo::Backend::X11)
+		requiredExtensions.emplace_back(VK_KHR_XLIB_SURFACE_EXTENSION_NAME);
+	#ifdef HAS_WAYLAND
+	else if (backend == WindowHandleInfo::Backend::WAYLAND)
+		requiredExtensions.emplace_back(VK_KHR_WAYLAND_SURFACE_EXTENSION_NAME);
+	#endif
 	#elif BOOST_OS_MACOS
 	requiredExtensions.emplace_back(VK_EXT_METAL_SURFACE_EXTENSION_NAME);
 	#endif
@@ -115,7 +127,7 @@ std::vector<VulkanRenderer::DeviceInfo> VulkanRenderer::GetDevices()
 	VkApplicationInfo app_info{};
 	app_info.sType = VK_STRUCTURE_TYPE_APPLICATION_INFO;
 	app_info.pApplicationName = EMULATOR_NAME;
-	app_info.applicationVersion = VK_MAKE_VERSION(EMULATOR_VERSION_LEAD, EMULATOR_VERSION_MAJOR, EMULATOR_VERSION_MINOR);
+	app_info.applicationVersion = VK_MAKE_VERSION(EMULATOR_VERSION_MAJOR, EMULATOR_VERSION_MINOR, EMULATOR_VERSION_PATCH);
 	app_info.pEngineName = EMULATOR_NAME;
 	app_info.engineVersion = app_info.applicationVersion;
 	app_info.apiVersion = apiVersion;
@@ -159,6 +171,7 @@ std::vector<VulkanRenderer::DeviceInfo> VulkanRenderer::GetDevices()
 				result.emplace_back(physDeviceProps.properties.deviceName, physDeviceIDProps.deviceUUID);
 			}
 		}
+		vkDestroySurfaceKHR(instance, surface, nullptr);
 	}
 	catch (...)
 	{
@@ -171,7 +184,6 @@ std::vector<VulkanRenderer::DeviceInfo> VulkanRenderer::GetDevices()
 
 }
 
-bool IsRunningInWine();
 void VulkanRenderer::DetermineVendor()
 {
 	VkPhysicalDeviceProperties2 properties{};
@@ -180,7 +192,7 @@ void VulkanRenderer::DetermineVendor()
 	if (m_featureControl.deviceExtensions.driver_properties)
 		properties.pNext = &driverProperties;
 
-	vkGetPhysicalDeviceProperties2(m_physical_device, &properties);
+	vkGetPhysicalDeviceProperties2(m_physicalDevice, &properties);
 	switch (properties.properties.vendorID)
 	{
 	case 0x10DE:
@@ -202,11 +214,11 @@ void VulkanRenderer::DetermineVendor()
 	if(driverId == VK_DRIVER_ID_MESA_RADV || driverId == VK_DRIVER_ID_INTEL_OPEN_SOURCE_MESA)
 		m_vendor = GfxVendor::Mesa;
 
-	forceLog_printf("Using GPU: %s", properties.properties.deviceName);
+	cemuLog_log(LogType::Force, "Using GPU: {}", properties.properties.deviceName);
 
 	if (m_featureControl.deviceExtensions.driver_properties)
 	{
-		forceLog_printf("Driver version: %s", driverProperties.driverInfo);
+		cemuLog_log(LogType::Force, "Driver version: {}", driverProperties.driverInfo);
 
 		if(m_vendor == GfxVendor::Nvidia)
 		{
@@ -217,7 +229,7 @@ void VulkanRenderer::DetermineVendor()
 
 	else
 	{
-		forceLog_printf("Driver version (as stored in device info): %08X", properties.properties.driverVersion);
+		cemuLog_log(LogType::Force, "Driver version (as stored in device info): {:08}", properties.properties.driverVersion);
 
 		if(m_vendor == GfxVendor::Nvidia)
 		{
@@ -230,58 +242,110 @@ void VulkanRenderer::DetermineVendor()
 
 void VulkanRenderer::GetDeviceFeatures()
 {
+	/* Get Vulkan features via GetPhysicalDeviceFeatures2 */
+	void* prevStruct = nullptr;
 	VkPhysicalDeviceCustomBorderColorFeaturesEXT bcf{};
 	bcf.sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_CUSTOM_BORDER_COLOR_FEATURES_EXT;
+	bcf.sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_CUSTOM_BORDER_COLOR_FEATURES_EXT;
+	prevStruct = &bcf;
 
 	VkPhysicalDevicePipelineCreationCacheControlFeaturesEXT pcc{};
 	pcc.sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PIPELINE_CREATION_CACHE_CONTROL_FEATURES_EXT;
-	pcc.pNext = &bcf;
+	pcc.pNext = prevStruct;
+	prevStruct = &pcc;
+
+	VkPhysicalDevicePresentIdFeaturesKHR pidf{};
+	pidf.sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PRESENT_ID_FEATURES_KHR;
+	pidf.pNext = prevStruct;
+	prevStruct = &pidf;
+
+	VkPhysicalDevicePresentWaitFeaturesKHR pwf{};
+	pwf.sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PRESENT_WAIT_FEATURES_KHR;
+	pwf.pNext = prevStruct;
+	prevStruct = &pwf;
+
+	VkPhysicalDevicePipelineRobustnessFeaturesEXT pprf{};
+	if (m_featureControl.deviceExtensions.pipeline_robustness)
+	{
+		pprf.sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PIPELINE_ROBUSTNESS_FEATURES_EXT;
+		pprf.pNext = prevStruct;
+		prevStruct = &pprf;
+	}
 
 	VkPhysicalDeviceFeatures2 physicalDeviceFeatures2{};
 	physicalDeviceFeatures2.sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FEATURES_2;
-	physicalDeviceFeatures2.pNext = &pcc;
+	physicalDeviceFeatures2.pNext = prevStruct;
 
-	vkGetPhysicalDeviceFeatures2(m_physical_device, &physicalDeviceFeatures2);
+	vkGetPhysicalDeviceFeatures2(m_physicalDevice, &physicalDeviceFeatures2);
+
+	cemuLog_log(LogType::Force, "Vulkan: present_wait extension: {}", (pwf.presentWait && pidf.presentId) ? "supported" : "unsupported");
+
+	/* Get Vulkan device properties and limits */
+	VkPhysicalDeviceFloatControlsPropertiesKHR pfcp{};
+	prevStruct = nullptr;
+	if (m_featureControl.deviceExtensions.shader_float_controls)
+	{
+		pfcp.sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FLOAT_CONTROLS_PROPERTIES_KHR;
+		pfcp.pNext = prevStruct;
+		prevStruct = &pfcp;
+	}
+
+	VkPhysicalDeviceProperties2 prop2{};
+	prop2.sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PROPERTIES_2;
+	prop2.pNext = prevStruct;
+
+	vkGetPhysicalDeviceProperties2(m_physicalDevice, &prop2);
+
+	/* Determine which subfeatures we can use */
 
 	m_featureControl.deviceExtensions.pipeline_creation_cache_control = pcc.pipelineCreationCacheControl;
 	m_featureControl.deviceExtensions.custom_border_color_without_format = m_featureControl.deviceExtensions.custom_border_color && bcf.customBorderColorWithoutFormat;
+	m_featureControl.shaderFloatControls.shaderRoundingModeRTEFloat32 = m_featureControl.deviceExtensions.shader_float_controls && pfcp.shaderRoundingModeRTEFloat32;
+	if(!m_featureControl.shaderFloatControls.shaderRoundingModeRTEFloat32)
+		cemuLog_log(LogType::Force, "Shader round mode control not available on this device or driver. Some rendering issues might occur.");
 
 	if (!m_featureControl.deviceExtensions.pipeline_creation_cache_control)
 	{
-		forceLogDebug_printf("VK_EXT_pipeline_creation_cache_control not supported. Cannot use asynchronous shader and pipeline compilation");
+		cemuLog_log(LogType::Force, "VK_EXT_pipeline_creation_cache_control not supported. Cannot use asynchronous shader and pipeline compilation");
 		// if async shader compilation is enabled show warning message
 		if (GetConfig().async_compile)
-			wxMessageBox(_("The currently installed graphics driver does not support the Vulkan extension necessary for asynchronous shader compilation. Asynchronous compilation cannot be used.\n \nRequired extension: VK_EXT_pipeline_creation_cache_control\n\nInstalling the latest graphics driver may solve this error."), _("Information"), wxOK | wxCENTRE);
+			LatteOverlay_pushNotification(_("Async shader compile is enabled but not supported by the graphics driver\nCemu will use synchronous compilation which can cause additional stutter").utf8_string(), 10000);
 	}
 	if (!m_featureControl.deviceExtensions.custom_border_color_without_format)
 	{
 		if (m_featureControl.deviceExtensions.custom_border_color)
 		{
-			forceLog_printf("VK_EXT_custom_border_color is present but only with limited support. Cannot emulate arbitrary border color");
+			cemuLog_log(LogType::Force, "VK_EXT_custom_border_color is present but only with limited support. Cannot emulate arbitrary border color");
 		}
 		else
 		{
-			forceLog_printf("VK_EXT_custom_border_color not supported. Cannot emulate arbitrary border color");
+			cemuLog_log(LogType::Force, "VK_EXT_custom_border_color not supported. Cannot emulate arbitrary border color");
 		}
 	}
-	// retrieve limits
-	VkPhysicalDeviceProperties2 p2{};
-	p2.sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PROPERTIES_2;
-	vkGetPhysicalDeviceProperties2(m_physical_device, &p2);
-	m_featureControl.limits.minUniformBufferOffsetAlignment = std::max(p2.properties.limits.minUniformBufferOffsetAlignment, (VkDeviceSize)4);
-	m_featureControl.limits.nonCoherentAtomSize = std::max(p2.properties.limits.nonCoherentAtomSize, (VkDeviceSize)4);
-	cemuLog_log(LogType::Force, fmt::format("VulkanLimits: UBAlignment {0} nonCoherentAtomSize {1}", p2.properties.limits.minUniformBufferOffsetAlignment, p2.properties.limits.nonCoherentAtomSize));
+	if (!m_featureControl.deviceExtensions.depth_clip_enable)
+	{
+		cemuLog_log(LogType::Force, "VK_EXT_depth_clip_enable not supported");
+	}
+	if (m_featureControl.deviceExtensions.pipeline_robustness)
+	{
+		if ( pprf.pipelineRobustness != VK_TRUE )
+			m_featureControl.deviceExtensions.pipeline_robustness = false;
+	}
+	// get limits
+	m_featureControl.limits.minUniformBufferOffsetAlignment = std::max(prop2.properties.limits.minUniformBufferOffsetAlignment, (VkDeviceSize)4);
+	m_featureControl.limits.nonCoherentAtomSize = std::max(prop2.properties.limits.nonCoherentAtomSize, (VkDeviceSize)4);
+	cemuLog_log(LogType::Force, fmt::format("VulkanLimits: UBAlignment {0} nonCoherentAtomSize {1}", prop2.properties.limits.minUniformBufferOffsetAlignment, prop2.properties.limits.nonCoherentAtomSize));
 }
 
 VulkanRenderer::VulkanRenderer()
 {
 	glslang::InitializeProcess();
 
-	forceLog_printf("------- Init Vulkan graphics backend -------");
+	cemuLog_log(LogType::Force, "------- Init Vulkan graphics backend -------");
 
-	const bool useValidationLayer = cafeLog_isLoggingFlagEnabled(LOG_TYPE_VULKAN_VALIDATION);
+	const bool useValidationLayer = cemuLog_isLoggingEnabled(LogType::VulkanValidation);
 	if (useValidationLayer)
-		forceLog_printf("Validation layer is enabled");
+		cemuLog_log(LogType::Force, "Validation layer is enabled");
 
 	VkResult err;
 
@@ -305,7 +369,7 @@ VulkanRenderer::VulkanRenderer()
 	VkApplicationInfo app_info{};
 	app_info.sType = VK_STRUCTURE_TYPE_APPLICATION_INFO;
 	app_info.pApplicationName = EMULATOR_NAME;
-	app_info.applicationVersion = VK_MAKE_VERSION(EMULATOR_VERSION_LEAD, EMULATOR_VERSION_MAJOR, EMULATOR_VERSION_MINOR);
+	app_info.applicationVersion = VK_MAKE_VERSION(EMULATOR_VERSION_MAJOR, EMULATOR_VERSION_MINOR, EMULATOR_VERSION_PATCH);
 	app_info.pEngineName = EMULATOR_NAME;
 	app_info.engineVersion = app_info.applicationVersion;
 	app_info.apiVersion = apiVersion;
@@ -318,7 +382,15 @@ VulkanRenderer::VulkanRenderer()
 	create_info.ppEnabledLayerNames = m_layerNames.data();
 	create_info.enabledLayerCount = m_layerNames.size();
 
-	if ((err = vkCreateInstance(&create_info, nullptr, &m_instance)) != VK_SUCCESS)
+	err = vkCreateInstance(&create_info, nullptr, &m_instance);
+
+	if (err == VK_ERROR_LAYER_NOT_PRESENT) {
+		cemuLog_log(LogType::Force, "Failed to enable vulkan validation (VK_LAYER_KHRONOS_validation)");
+		create_info.enabledLayerCount = 0;
+		err = vkCreateInstance(&create_info, nullptr, &m_instance);
+	}
+
+	if (err != VK_SUCCESS)
 		throw std::runtime_error(fmt::format("Unable to create a Vulkan instance: {}", err));
 
 	if (!InitializeInstanceVulkan(m_instance))
@@ -358,39 +430,39 @@ VulkanRenderer::VulkanRenderer()
 					continue;
 			}
 
-			m_physical_device = device;
+			m_physicalDevice = device;
 			break;
 		}
 	}
 
-	if (m_physical_device == VK_NULL_HANDLE && fallbackDevice != VK_NULL_HANDLE)
+	if (m_physicalDevice == VK_NULL_HANDLE && fallbackDevice != VK_NULL_HANDLE)
 	{
-		forceLog_printf("The selected GPU could not be found or is not suitable. Falling back to first available device instead");
-		m_physical_device = fallbackDevice;
+		cemuLog_log(LogType::Force, "The selected GPU could not be found or is not suitable. Falling back to first available device instead");
+		m_physicalDevice = fallbackDevice;
 		config.graphic_device_uuid = {}; // resetting device selection
 	}
-	else if (m_physical_device == VK_NULL_HANDLE)
+	else if (m_physicalDevice == VK_NULL_HANDLE)
 	{
-		forceLog_printf("No physical GPU could be found with the required extensions and swap chain support.");
+		cemuLog_log(LogType::Force, "No physical GPU could be found with the required extensions and swap chain support.");
 		throw std::runtime_error("No physical GPU could be found with the required extensions and swap chain support.");
 	}
 
-	CheckDeviceExtensionSupport(m_physical_device, m_featureControl); // todo - merge this with GetDeviceFeatures and separate from IsDeviceSuitable?
+	CheckDeviceExtensionSupport(m_physicalDevice, m_featureControl); // todo - merge this with GetDeviceFeatures and separate from IsDeviceSuitable?
 	if (m_featureControl.debugMarkersSupported)
-		forceLog_printf("Debug: Frame debugger attached, will use vkDebugMarkerSetObjectNameEXT");
+		cemuLog_log(LogType::Force, "Debug: Frame debugger attached, will use vkDebugMarkerSetObjectNameEXT");
 
 	DetermineVendor();
 	GetDeviceFeatures();
 
 	// init memory manager
-	memoryManager = new VKRMemoryManager(this);
+	memoryManager.reset(new VKRMemoryManager(this));
 
 	try
 	{
 		VkPhysicalDeviceIDProperties physDeviceIDProps = { VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_ID_PROPERTIES };
 		VkPhysicalDeviceProperties2 physDeviceProps = { VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PROPERTIES_2 };
 		physDeviceProps.pNext = &physDeviceIDProps;
-		vkGetPhysicalDeviceProperties2(m_physical_device, &physDeviceProps);
+		vkGetPhysicalDeviceProperties2(m_physicalDevice, &physDeviceProps);
 
 		#if BOOST_OS_WINDOWS
 		m_dxgi_wrapper = std::make_unique<DXGIWrapper>(physDeviceIDProps.deviceLUID);
@@ -398,11 +470,11 @@ VulkanRenderer::VulkanRenderer()
 	}
 	catch (const std::exception& ex)
 	{
-		forceLog_printf("can't create dxgi wrapper: %s", ex.what());
+		cemuLog_log(LogType::Force, "can't create dxgi wrapper: {}", ex.what());
 	}
 
 	// create logical device
-	m_indices = FindQueueFamilies(surface, m_physical_device);
+	m_indices = FindQueueFamilies(surface, m_physicalDevice);
 	std::set<int> uniqueQueueFamilies = { m_indices.graphicsFamily, m_indices.presentFamily };
 	std::vector<VkDeviceQueueCreateInfo> queueCreateInfos = CreateQueueCreateInfos(uniqueQueueFamilies);
 	VkPhysicalDeviceFeatures deviceFeatures = {};
@@ -417,11 +489,17 @@ VulkanRenderer::VulkanRenderer()
 	deviceFeatures.occlusionQueryPrecise = VK_TRUE;
 	deviceFeatures.depthClamp = VK_TRUE;
 	deviceFeatures.depthBiasClamp = VK_TRUE;
-	if (m_vendor == GfxVendor::AMD)
+
+	if (m_featureControl.deviceExtensions.pipeline_robustness)
 	{
-		deviceFeatures.robustBufferAccess = VK_TRUE;
-		forceLog_printf("Enable robust buffer access");
+		deviceFeatures.robustBufferAccess = VK_FALSE;
 	}
+	else
+	{
+		cemuLog_log(LogType::Force, "VK_EXT_pipeline_robustness not supported. Falling back to robustBufferAccess");
+		deviceFeatures.robustBufferAccess = VK_TRUE;
+	}
+
 	if (m_featureControl.mode.useTFEmulationViaSSBO)
 	{
 		deviceFeatures.vertexPipelineStoresAndAtomics = true;
@@ -448,14 +526,41 @@ VulkanRenderer::VulkanRenderer()
 		customBorderColorFeature.customBorderColors = VK_TRUE;
 		customBorderColorFeature.customBorderColorWithoutFormat = VK_TRUE;
 	}
+	// enable VK_KHR_present_id
+	VkPhysicalDevicePresentIdFeaturesKHR presentIdFeature{};
+	if(m_featureControl.deviceExtensions.present_wait)
+	{
+		presentIdFeature.sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PRESENT_ID_FEATURES_KHR;
+		presentIdFeature.pNext = deviceExtensionFeatures;
+		deviceExtensionFeatures = &presentIdFeature;
+		presentIdFeature.presentId = VK_TRUE;
+	}
+	// enable VK_KHR_present_wait
+	VkPhysicalDevicePresentWaitFeaturesKHR presentWaitFeature{};
+	if(m_featureControl.deviceExtensions.present_wait)
+	{
+		presentWaitFeature.sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PRESENT_WAIT_FEATURES_KHR;
+		presentWaitFeature.pNext = deviceExtensionFeatures;
+		deviceExtensionFeatures = &presentWaitFeature;
+		presentWaitFeature.presentWait = VK_TRUE;
+	}
+	// enable VK_EXT_pipeline_robustness
+	VkPhysicalDevicePipelineRobustnessFeaturesEXT pipelineRobustnessFeature{};
+	if (m_featureControl.deviceExtensions.pipeline_robustness)
+	{
+		pipelineRobustnessFeature.sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PIPELINE_ROBUSTNESS_FEATURES_EXT;
+		pipelineRobustnessFeature.pNext = deviceExtensionFeatures;
+		deviceExtensionFeatures = &pipelineRobustnessFeature;
+		pipelineRobustnessFeature.pipelineRobustness = VK_TRUE;
+	}
 
 	std::vector<const char*> used_extensions;
 	VkDeviceCreateInfo createInfo = CreateDeviceCreateInfo(queueCreateInfos, deviceFeatures, deviceExtensionFeatures, used_extensions);
 
-	VkResult result = vkCreateDevice(m_physical_device, &createInfo, nullptr, &m_logicalDevice);
+	VkResult result = vkCreateDevice(m_physicalDevice, &createInfo, nullptr, &m_logicalDevice);
 	if (result != VK_SUCCESS)
 	{
-		forceLog_printf("Vulkan: Unable to create a logical device. Error %d", (sint32)result);
+		cemuLog_log(LogType::Force, "Vulkan: Unable to create a logical device. Error {}", (sint32)result);
 		throw std::runtime_error(fmt::format("Unable to create a logical device: {}", result));
 	}
 
@@ -471,7 +576,7 @@ VulkanRenderer::VulkanRenderer()
 		PFN_vkCreateDebugUtilsMessengerEXT vkCreateDebugUtilsMessengerEXT = reinterpret_cast<PFN_vkCreateDebugUtilsMessengerEXT>(vkGetInstanceProcAddr(m_instance, "vkCreateDebugUtilsMessengerEXT"));
 
 		VkDebugUtilsMessengerCreateInfoEXT debugCallback{};
-		debugCallback.sType = VK_STRUCTURE_TYPE_DEBUG_REPORT_CREATE_INFO_EXT;
+		debugCallback.sType = VK_STRUCTURE_TYPE_DEBUG_UTILS_MESSENGER_CREATE_INFO_EXT;
 		debugCallback.pNext = nullptr;
 		debugCallback.flags = 0;
 		debugCallback.messageSeverity = VK_DEBUG_UTILS_MESSAGE_SEVERITY_ERROR_BIT_EXT | VK_DEBUG_UTILS_MESSAGE_SEVERITY_WARNING_BIT_EXT | VK_DEBUG_UTILS_MESSAGE_SEVERITY_INFO_BIT_EXT | VK_DEBUG_UTILS_MESSAGE_SEVERITY_VERBOSE_BIT_EXT;
@@ -482,7 +587,7 @@ VulkanRenderer::VulkanRenderer()
 	}
 
 	if (m_featureControl.instanceExtensions.debug_utils)
-		forceLog_printf("Using available debug function: vkCreateDebugUtilsMessengerEXT()");
+		cemuLog_log(LogType::Force, "Using available debug function: vkCreateDebugUtilsMessengerEXT()");
 
 	// set initial viewport and scissor box size
 	m_state.currentViewport.width = 4;
@@ -492,27 +597,26 @@ VulkanRenderer::VulkanRenderer()
 
 	QueryMemoryInfo();
 	QueryAvailableFormats();
-	CreateBackbufferIndexBuffer();
 	CreateCommandPool();
 	CreateCommandBuffers();
 	CreateDescriptorPool();
 	swapchain_createDescriptorSetLayout();
 
 	// extension info
-	// cemuLog_force("VK_KHR_dynamic_rendering: {}", m_featureControl.deviceExtensions.dynamic_rendering?"supported":"not supported");
+	// cemuLog_log(LogType::Force, "VK_KHR_dynamic_rendering: {}", m_featureControl.deviceExtensions.dynamic_rendering?"supported":"not supported");
 
 	void* bufferPtr;
 	// init ringbuffer for uniform vars
 	m_uniformVarBufferMemoryIsCoherent = false;
-	if (memoryManager->CreateBuffer2(UNIFORMVAR_RINGBUFFER_SIZE, VK_BUFFER_USAGE_UNIFORM_BUFFER_BIT, VK_MEMORY_PROPERTY_HOST_VISIBLE_BIT | VK_MEMORY_PROPERTY_HOST_COHERENT_BIT | VK_MEMORY_PROPERTY_HOST_CACHED_BIT, m_uniformVarBuffer, m_uniformVarBufferMemory))
+	if (memoryManager->CreateBuffer(UNIFORMVAR_RINGBUFFER_SIZE, VK_BUFFER_USAGE_UNIFORM_BUFFER_BIT, VK_MEMORY_PROPERTY_HOST_VISIBLE_BIT | VK_MEMORY_PROPERTY_HOST_COHERENT_BIT | VK_MEMORY_PROPERTY_HOST_CACHED_BIT, m_uniformVarBuffer, m_uniformVarBufferMemory))
 		m_uniformVarBufferMemoryIsCoherent = true;
-	else if (memoryManager->CreateBuffer2(UNIFORMVAR_RINGBUFFER_SIZE, VK_BUFFER_USAGE_UNIFORM_BUFFER_BIT, VK_MEMORY_PROPERTY_HOST_VISIBLE_BIT | VK_MEMORY_PROPERTY_HOST_COHERENT_BIT | VK_MEMORY_PROPERTY_HOST_CACHED_BIT | VK_MEMORY_PROPERTY_DEVICE_LOCAL_BIT, m_uniformVarBuffer, m_uniformVarBufferMemory))
+	else if (memoryManager->CreateBuffer(UNIFORMVAR_RINGBUFFER_SIZE, VK_BUFFER_USAGE_UNIFORM_BUFFER_BIT, VK_MEMORY_PROPERTY_HOST_VISIBLE_BIT | VK_MEMORY_PROPERTY_HOST_COHERENT_BIT | VK_MEMORY_PROPERTY_HOST_CACHED_BIT | VK_MEMORY_PROPERTY_DEVICE_LOCAL_BIT, m_uniformVarBuffer, m_uniformVarBufferMemory))
 		m_uniformVarBufferMemoryIsCoherent = true; // unified memory
-	else if (memoryManager->CreateBuffer2(UNIFORMVAR_RINGBUFFER_SIZE, VK_BUFFER_USAGE_UNIFORM_BUFFER_BIT, VK_MEMORY_PROPERTY_HOST_VISIBLE_BIT | VK_MEMORY_PROPERTY_HOST_COHERENT_BIT, m_uniformVarBuffer, m_uniformVarBufferMemory))
+	else if (memoryManager->CreateBuffer(UNIFORMVAR_RINGBUFFER_SIZE, VK_BUFFER_USAGE_UNIFORM_BUFFER_BIT, VK_MEMORY_PROPERTY_HOST_VISIBLE_BIT | VK_MEMORY_PROPERTY_HOST_COHERENT_BIT, m_uniformVarBuffer, m_uniformVarBufferMemory))
 		m_uniformVarBufferMemoryIsCoherent = true;
 	else
 	{
-		memoryManager->CreateBuffer2(UNIFORMVAR_RINGBUFFER_SIZE, VK_BUFFER_USAGE_UNIFORM_BUFFER_BIT, VK_MEMORY_PROPERTY_HOST_VISIBLE_BIT, m_uniformVarBuffer, m_uniformVarBufferMemory);
+		memoryManager->CreateBuffer(UNIFORMVAR_RINGBUFFER_SIZE, VK_BUFFER_USAGE_UNIFORM_BUFFER_BIT, VK_MEMORY_PROPERTY_HOST_VISIBLE_BIT, m_uniformVarBuffer, m_uniformVarBufferMemory);
 	}
 
 	if (!m_uniformVarBufferMemoryIsCoherent)
@@ -539,31 +643,47 @@ VulkanRenderer::VulkanRenderer()
 	for (sint32 i = 0; i < OCCLUSION_QUERY_POOL_SIZE; i++)
 		m_occlusionQueries.list_availableQueryIndices.emplace_back(i);
 
-	// enable surface copies via buffer if we have plenty of memory available (otherwise use drawcalls)
-	size_t availableSurfaceCopyBufferMem = memoryManager->GetTotalMemoryForBufferType(VK_BUFFER_USAGE_TRANSFER_SRC_BIT | VK_BUFFER_USAGE_TRANSFER_DST_BIT, VK_MEMORY_PROPERTY_DEVICE_LOCAL_BIT);
-	//m_featureControl.mode.useBufferSurfaceCopies = availableSurfaceCopyBufferMem >= 2000ull * 1024ull * 1024ull; // enable if at least 2000MB VRAM
-	m_featureControl.mode.useBufferSurfaceCopies = false;
-
-	if (m_featureControl.mode.useBufferSurfaceCopies)
-	{
-		//forceLog_printf("Enable surface copies via buffer");
-	}
-	else
-	{
-		//forceLog_printf("Disable surface copies via buffer (Requires 2GB. Has only %lluMB available)", availableSurfaceCopyBufferMem / 1024ull / 1024ull);
-	}
+	// start compilation threads
+	RendererShaderVk::Init();
 }
 
 VulkanRenderer::~VulkanRenderer()
 {
 	SubmitCommandBuffer();
-	vkDeviceWaitIdle(m_logicalDevice);
+	WaitDeviceIdle();
 	WaitCommandBufferFinished(GetCurrentCommandBufferId());
+	// make sure compilation threads have been shut down
+	RendererShaderVk::Shutdown();
 	// shut down pipeline save thread
 	m_destructionRequested = true;
 	m_pipeline_cache_semaphore.notify();
 	m_pipeline_cache_save_thread.join();
 
+	vkDestroyPipelineCache(m_logicalDevice, m_pipeline_cache, nullptr);
+
+	if(!m_backbufferBlitDescriptorSetCache.empty())
+	{
+		std::vector<VkDescriptorSet> freeVector;
+		freeVector.reserve(m_backbufferBlitDescriptorSetCache.size());
+		std::transform(m_backbufferBlitDescriptorSetCache.begin(), m_backbufferBlitDescriptorSetCache.end(), std::back_inserter(freeVector), [](auto& i) {
+		  return i.second;
+		});
+		vkFreeDescriptorSets(m_logicalDevice, m_descriptorPool, freeVector.size(), freeVector.data());
+	}
+
+	vkDestroyDescriptorPool(m_logicalDevice, m_descriptorPool, nullptr);
+
+	for(auto& i : m_backbufferBlitPipelineCache)
+	{
+		vkDestroyPipeline(m_logicalDevice, i.second, nullptr);
+	}
+	m_backbufferBlitPipelineCache = {};
+
+	if(m_occlusionQueries.queryPool != VK_NULL_HANDLE)
+		vkDestroyQueryPool(m_logicalDevice, m_occlusionQueries.queryPool, nullptr);
+
+	vkDestroyDescriptorSetLayout(m_logicalDevice, m_swapchainDescriptorSetLayout, nullptr);
+
 	// shut down imgui
 	ImGui_ImplVulkan_Shutdown();
 
@@ -571,16 +691,11 @@ VulkanRenderer::~VulkanRenderer()
 	DeleteNullObjects();
 
 	// delete buffers
-	memoryManager->DeleteBuffer(m_indexBuffer, m_indexBufferMemory);
 	memoryManager->DeleteBuffer(m_uniformVarBuffer, m_uniformVarBufferMemory);
 	memoryManager->DeleteBuffer(m_textureReadbackBuffer, m_textureReadbackBufferMemory);
 	memoryManager->DeleteBuffer(m_xfbRingBuffer, m_xfbRingBufferMemory);
 	memoryManager->DeleteBuffer(m_occlusionQueries.bufferQueryResults, m_occlusionQueries.memoryQueryResults);
 	memoryManager->DeleteBuffer(m_bufferCache, m_bufferCacheMemory);
-	// texture memory
-	// todo
-	// upload buffers
-	// todo
 
 	m_padSwapchainInfo = nullptr;
 	m_mainSwapchainInfo = nullptr;
@@ -603,12 +718,20 @@ VulkanRenderer::~VulkanRenderer()
 		it = VK_NULL_HANDLE;
 	}
 
+	for(auto& sem : m_commandBufferSemaphores)
+	{
+		vkDestroySemaphore(m_logicalDevice, sem, nullptr);
+		sem = VK_NULL_HANDLE;
+	}
+
 	if (m_pipelineLayout != VK_NULL_HANDLE)
 		vkDestroyPipelineLayout(m_logicalDevice, m_pipelineLayout, nullptr);
 
 	if (m_commandPool != VK_NULL_HANDLE)
 		vkDestroyCommandPool(m_logicalDevice, m_commandPool, nullptr);
 
+	VKRObjectSampler::DestroyCache();
+
 	// destroy debug callback
 	if (m_debugCallback)
 	{
@@ -616,6 +739,12 @@ VulkanRenderer::~VulkanRenderer()
 		vkDestroyDebugUtilsMessengerEXT(m_instance, m_debugCallback, nullptr);
 	}
 
+	while(!m_destructionQueue.empty())
+		ProcessDestructionQueue();
+
+	// destroy memory manager
+	memoryManager.reset();
+
 	// destroy instance, devices
 	if (m_instance != VK_NULL_HANDLE)
 	{
@@ -627,42 +756,53 @@ VulkanRenderer::~VulkanRenderer()
 		vkDestroyInstance(m_instance, nullptr);
 	}
 
-	// destroy memory manager
-	delete memoryManager;
-
 	// crashes?
 	//glslang::FinalizeProcess();
 }
 
 VulkanRenderer* VulkanRenderer::GetInstance()
 {
-#ifndef PUBLIC_RELEASE
+#ifdef CEMU_DEBUG_ASSERT
 	cemu_assert_debug(g_renderer && dynamic_cast<VulkanRenderer*>(g_renderer.get()));
 	// Use #if here because dynamic_casts dont get optimized away even if the result is not stored as with cemu_assert_debug
 #endif
 	return (VulkanRenderer*)g_renderer.get();
 }
 
-void VulkanRenderer::Initialize(const Vector2i& size, bool isMainWindow)
+void VulkanRenderer::InitializeSurface(const Vector2i& size, bool mainWindow)
 {
-	auto& windowHandleInfo = isMainWindow ? gui_getWindowInfo().canvas_main : gui_getWindowInfo().canvas_pad;
-
-	const auto surface = CreateFramebufferSurface(m_instance, windowHandleInfo);
-	if (isMainWindow)
+	if (mainWindow)
 	{
-		m_mainSwapchainInfo = std::make_unique<SwapChainInfo>(m_logicalDevice, surface);
-		CreateSwapChain(*m_mainSwapchainInfo, size, isMainWindow);
+		m_mainSwapchainInfo = std::make_unique<SwapchainInfoVk>(mainWindow, size);
+		m_mainSwapchainInfo->Create();
 
 		// aquire first command buffer
 		InitFirstCommandBuffer();
 	}
 	else
 	{
-		m_padSwapchainInfo = std::make_unique<SwapChainInfo>(m_logicalDevice, surface);
-		CreateSwapChain(*m_padSwapchainInfo, size, isMainWindow);
+		m_padSwapchainInfo = std::make_unique<SwapchainInfoVk>(mainWindow, size);
+		// todo: figure out a way to exclusively create swapchain on main LatteThread
+		m_padSwapchainInfo->Create();
 	}
 }
 
+const std::unique_ptr<SwapchainInfoVk>& VulkanRenderer::GetChainInfoPtr(bool mainWindow) const
+{
+	return mainWindow ? m_mainSwapchainInfo : m_padSwapchainInfo;
+}
+
+SwapchainInfoVk& VulkanRenderer::GetChainInfo(bool mainWindow) const
+{
+	return *GetChainInfoPtr(mainWindow);
+}
+
+void VulkanRenderer::StopUsingPadAndWait()
+{
+	m_destroyPadSwapchainNextAcquire.test_and_set();
+	m_destroyPadSwapchainNextAcquire.wait(true);
+}
+
 bool VulkanRenderer::IsPadWindowActive()
 {
 	return IsSwapchainInfoValid(false);
@@ -703,7 +843,7 @@ void VulkanRenderer::HandleScreenshotRequest(LatteTextureView* texView, bool pad
 	//dumpImage->flagForCurrentCommandBuffer();
 
 	int width, height;
-	LatteTexture_getEffectiveSize(baseImageTex, &width, &height, nullptr, 0);
+	baseImageTex->GetEffectiveSize(width, height, 0);
 
 	VkImage image = nullptr;
 	VkDeviceMemory imageMemory = nullptr;;
@@ -712,13 +852,13 @@ void VulkanRenderer::HandleScreenshotRequest(LatteTextureView* texView, bool pad
 	if (format != VK_FORMAT_R8G8B8A8_UNORM && format != VK_FORMAT_R8G8B8A8_SRGB && format != VK_FORMAT_R8G8B8_UNORM && format != VK_FORMAT_R8G8B8_SNORM)
 	{
 		VkFormatProperties formatProps;
-		vkGetPhysicalDeviceFormatProperties(m_physical_device, format, &formatProps);
+		vkGetPhysicalDeviceFormatProperties(m_physicalDevice, format, &formatProps);
 		bool supportsBlit = (formatProps.optimalTilingFeatures & VK_FORMAT_FEATURE_BLIT_SRC_BIT) != 0;
 
 		const bool dstUsesSRGB = (!padView && LatteGPUState.tvBufferUsesSRGB) || (padView && LatteGPUState.drcBufferUsesSRGB);
 		const auto blitFormat = dstUsesSRGB ? VK_FORMAT_R8G8B8A8_SRGB : VK_FORMAT_R8G8B8A8_UNORM;
 
-		vkGetPhysicalDeviceFormatProperties(m_physical_device, blitFormat, &formatProps);
+		vkGetPhysicalDeviceFormatProperties(m_physicalDevice, blitFormat, &formatProps);
 		supportsBlit &= (formatProps.optimalTilingFeatures & VK_FORMAT_FEATURE_BLIT_DST_BIT) != 0;
 
 		// convert texture using blitting
@@ -746,7 +886,14 @@ void VulkanRenderer::HandleScreenshotRequest(LatteTextureView* texView, bool pad
 			VkMemoryAllocateInfo allocInfo{};
 			allocInfo.sType = VK_STRUCTURE_TYPE_MEMORY_ALLOCATE_INFO;
 			allocInfo.allocationSize = memRequirements.size;
-			allocInfo.memoryTypeIndex = memoryManager->FindMemoryType(memRequirements.memoryTypeBits, VK_MEMORY_PROPERTY_DEVICE_LOCAL_BIT);
+			uint32 memIndex;
+			bool foundMemory = memoryManager->FindMemoryType(memRequirements.memoryTypeBits, VK_MEMORY_PROPERTY_DEVICE_LOCAL_BIT, memIndex);
+			if(!foundMemory)
+			{
+				cemuLog_log(LogType::Force, "Screenshot request failed due to incompatible vulkan memory types.");
+				return;
+			}
+			allocInfo.memoryTypeIndex = memIndex;
 
 			if (vkAllocateMemory(m_logicalDevice, &allocInfo, nullptr, &imageMemory) != VK_SUCCESS)
 			{
@@ -958,20 +1105,6 @@ void VulkanRenderer::HandleScreenshotRequest(LatteTextureView* texView, bool pad
 		SaveScreenshot(rgb_data, width, height, !padView);
 }
 
-void VulkanRenderer::ResizeSwapchain(const Vector2i& size, bool isMainWindow)
-{
-	if (isMainWindow)
-	{
-		m_swapchainState.newExtentMainWindow = size;
-		m_swapchainState.resizeRequestedMainWindow = true;
-	}
-	else
-	{
-		m_swapchainState.newExtentPadWindow = size;
-		m_swapchainState.resizeRequestedPadWindow = true;
-	}
-}
-
 static const float kQueuePriority = 1.0f;
 
 std::vector<VkDeviceQueueCreateInfo> VulkanRenderer::CreateQueueCreateInfos(const std::set<sint32>& uniqueQueueFamilies) const
@@ -1014,6 +1147,17 @@ VkDeviceCreateInfo VulkanRenderer::CreateDeviceCreateInfo(const std::vector<VkDe
 		used_extensions.emplace_back(VK_KHR_SYNCHRONIZATION_2_EXTENSION_NAME);
 	if (m_featureControl.deviceExtensions.dynamic_rendering)
 		used_extensions.emplace_back(VK_KHR_DYNAMIC_RENDERING_EXTENSION_NAME);
+	if (m_featureControl.deviceExtensions.shader_float_controls)
+		used_extensions.emplace_back(VK_KHR_SHADER_FLOAT_CONTROLS_EXTENSION_NAME);
+	if (m_featureControl.deviceExtensions.depth_clip_enable)
+		used_extensions.emplace_back(VK_EXT_DEPTH_CLIP_ENABLE_EXTENSION_NAME);
+	if (m_featureControl.deviceExtensions.present_wait)
+	{
+		used_extensions.emplace_back(VK_KHR_PRESENT_ID_EXTENSION_NAME);
+		used_extensions.emplace_back(VK_KHR_PRESENT_WAIT_EXTENSION_NAME);
+	}
+	if (m_featureControl.deviceExtensions.pipeline_robustness)
+		used_extensions.emplace_back(VK_EXT_PIPELINE_ROBUSTNESS_EXTENSION_NAME);
 
 	VkDeviceCreateInfo createInfo{};
 	createInfo.sType = VK_STRUCTURE_TYPE_DEVICE_CREATE_INFO;
@@ -1039,18 +1183,7 @@ RendererShader* VulkanRenderer::shader_create(RendererShader::ShaderType type, u
 	return new RendererShaderVk(type, baseHash, auxHash, isGameShader, isGfxPackShader, source);
 }
 
-void VulkanRenderer::shader_bind(RendererShader* shader)
-{
-	// does nothing on Vulkan
-	// remove from main render backend and internalize into GL backend
-}
-
-void VulkanRenderer::shader_unbind(RendererShader::ShaderType shaderType)
-{
-	// does nothing on Vulkan
-}
-
-VulkanRenderer::QueueFamilyIndices VulkanRenderer::FindQueueFamilies(VkSurfaceKHR surface, const VkPhysicalDevice& device)
+VulkanRenderer::QueueFamilyIndices VulkanRenderer::FindQueueFamilies(VkSurfaceKHR surface, VkPhysicalDevice device)
 {
 	uint32_t queueFamilyCount = 0;
 	vkGetPhysicalDeviceQueueFamilyProperties(device, &queueFamilyCount, nullptr);
@@ -1119,8 +1252,12 @@ bool VulkanRenderer::CheckDeviceExtensionSupport(const VkPhysicalDevice device,
 	info.deviceExtensions.driver_properties = isExtensionAvailable(VK_KHR_DRIVER_PROPERTIES_EXTENSION_NAME);
 	info.deviceExtensions.external_memory_host = isExtensionAvailable(VK_EXT_EXTERNAL_MEMORY_HOST_EXTENSION_NAME);
 	info.deviceExtensions.synchronization2 = isExtensionAvailable(VK_KHR_SYNCHRONIZATION_2_EXTENSION_NAME);
+	info.deviceExtensions.shader_float_controls = isExtensionAvailable(VK_KHR_SHADER_FLOAT_CONTROLS_EXTENSION_NAME);
 	info.deviceExtensions.dynamic_rendering = false; // isExtensionAvailable(VK_KHR_DYNAMIC_RENDERING_EXTENSION_NAME);
+	info.deviceExtensions.depth_clip_enable = isExtensionAvailable(VK_EXT_DEPTH_CLIP_ENABLE_EXTENSION_NAME);
+	info.deviceExtensions.pipeline_robustness = isExtensionAvailable(VK_EXT_PIPELINE_ROBUSTNESS_EXTENSION_NAME);
 	// dynamic rendering doesn't provide any benefits for us right now. Driver implementations are very unoptimized as of Feb 2022
+	info.deviceExtensions.present_wait = isExtensionAvailable(VK_KHR_PRESENT_WAIT_EXTENSION_NAME) && isExtensionAvailable(VK_KHR_PRESENT_ID_EXTENSION_NAME);
 
 	// check for framedebuggers
 	info.debugMarkersSupported = false;
@@ -1174,11 +1311,17 @@ std::vector<const char*> VulkanRenderer::CheckInstanceExtensionSupport(FeatureCo
 	#if BOOST_OS_WINDOWS
 	requiredInstanceExtensions.emplace_back(VK_KHR_WIN32_SURFACE_EXTENSION_NAME);
 	#elif BOOST_OS_LINUX
-	requiredInstanceExtensions.emplace_back(VK_KHR_XLIB_SURFACE_EXTENSION_NAME);
+	auto backend = gui_getWindowInfo().window_main.backend;
+	if(backend == WindowHandleInfo::Backend::X11)
+		requiredInstanceExtensions.emplace_back(VK_KHR_XLIB_SURFACE_EXTENSION_NAME);
+	#if HAS_WAYLAND
+	else if (backend == WindowHandleInfo::Backend::WAYLAND)
+		requiredInstanceExtensions.emplace_back(VK_KHR_WAYLAND_SURFACE_EXTENSION_NAME);
+	#endif
 	#elif BOOST_OS_MACOS
 	requiredInstanceExtensions.emplace_back(VK_EXT_METAL_SURFACE_EXTENSION_NAME);
 	#endif
-	if (cafeLog_isLoggingFlagEnabled(LOG_TYPE_VULKAN_VALIDATION))
+	if (cemuLog_isLoggingEnabled(LogType::VulkanValidation))
 		requiredInstanceExtensions.emplace_back(VK_EXT_DEBUG_REPORT_EXTENSION_NAME);
 
 	// make sure all required extensions are supported
@@ -1196,11 +1339,11 @@ std::vector<const char*> VulkanRenderer::CheckInstanceExtensionSupport(FeatureCo
 	}
 	if (!requiredInstanceExtensions.empty())
 	{
-		forceLog_printf("The following required Vulkan instance extensions are not supported:");
+		cemuLog_log(LogType::Force, "The following required Vulkan instance extensions are not supported:");
 
 		std::stringstream ss;
 		for (const auto& extension : requiredInstanceExtensions)
-			forceLog_printf("%s", extension);
+			cemuLog_log(LogType::Force, "{}", extension);
 		cemuLog_waitForFlush();
 		throw std::runtime_error(ss.str());
 	}
@@ -1212,59 +1355,6 @@ std::vector<const char*> VulkanRenderer::CheckInstanceExtensionSupport(FeatureCo
 	return enabledInstanceExtensions;
 }
 
-VulkanRenderer::SwapChainSupportDetails VulkanRenderer::QuerySwapChainSupport(VkSurfaceKHR surface, const VkPhysicalDevice& device)
-{
-	SwapChainSupportDetails details;
-
-	VkResult result = vkGetPhysicalDeviceSurfaceCapabilitiesKHR(device, surface, &details.capabilities);
-	if (result != VK_SUCCESS)
-	{
-		if (result != VK_ERROR_SURFACE_LOST_KHR)
-			forceLog_printf("vkGetPhysicalDeviceSurfaceCapabilitiesKHR failed. Error %d", (sint32)result);
-		throw std::runtime_error(fmt::format("Unable to retrieve physical device surface capabilities: {}", result));
-	}
-
-	uint32_t formatCount = 0;
-	result = vkGetPhysicalDeviceSurfaceFormatsKHR(device, surface, &formatCount, nullptr);
-	if (result != VK_SUCCESS)
-	{
-		forceLog_printf("vkGetPhysicalDeviceSurfaceFormatsKHR failed. Error %d", (sint32)result);
-		throw std::runtime_error(fmt::format("Unable to retrieve the number of formats for a surface on a physical device: {}", result));
-	}
-
-	if (formatCount != 0)
-	{
-		details.formats.resize(formatCount);
-		result = vkGetPhysicalDeviceSurfaceFormatsKHR(device, surface, &formatCount, details.formats.data());
-		if (result != VK_SUCCESS)
-		{
-			forceLog_printf("vkGetPhysicalDeviceSurfaceFormatsKHR failed. Error %d", (sint32)result);
-			throw std::runtime_error(fmt::format("Unable to retrieve the formats for a surface on a physical device: {}", result));
-		}
-	}
-
-	uint32_t presentModeCount = 0;
-	result = vkGetPhysicalDeviceSurfacePresentModesKHR(device, surface, &presentModeCount, nullptr);
-	if (result != VK_SUCCESS)
-	{
-		forceLog_printf("vkGetPhysicalDeviceSurfacePresentModesKHR failed. Error %d", (sint32)result);
-		throw std::runtime_error(fmt::format("Unable to retrieve the count of present modes for a surface on a physical device: {}", result));
-	}
-
-	if (presentModeCount != 0)
-	{
-		details.presentModes.resize(presentModeCount);
-		result = vkGetPhysicalDeviceSurfacePresentModesKHR(device, surface, &presentModeCount, details.presentModes.data());
-		if (result != VK_SUCCESS)
-		{
-			forceLog_printf("vkGetPhysicalDeviceSurfacePresentModesKHR failed. Error %d", (sint32)result);
-			throw std::runtime_error(fmt::format("Unable to retrieve the present modes for a surface on a physical device: {}", result));
-		}
-	}
-
-	return details;
-}
-
 bool VulkanRenderer::IsDeviceSuitable(VkSurfaceKHR surface, const VkPhysicalDevice& device)
 {
 	if (!FindQueueFamilies(surface, device).IsComplete())
@@ -1275,16 +1365,16 @@ bool VulkanRenderer::IsDeviceSuitable(VkSurfaceKHR surface, const VkPhysicalDevi
 	vkGetPhysicalDeviceProperties(device, &properties);
 	uint32 vkVersionMajor = VK_API_VERSION_MAJOR(properties.apiVersion);
 	uint32 vkVersionMinor = VK_API_VERSION_MINOR(properties.apiVersion);
-	if (vkVersionMajor < 1 || vkVersionMinor < 1)
+	if (vkVersionMajor < 1 || (vkVersionMajor == 1 && vkVersionMinor < 1))
 		return false; // minimum required version is Vulkan 1.1
 
 	FeatureControl info;
 	if (!CheckDeviceExtensionSupport(device, info))
 		return false;
 
-	const SwapChainSupportDetails swapChainSupport = QuerySwapChainSupport(surface, device);
+	const auto swapchainSupport = SwapchainInfoVk::QuerySwapchainSupport(surface, device);
 
-	return !swapChainSupport.formats.empty() && !swapChainSupport.presentModes.empty();
+	return !swapchainSupport.formats.empty() && !swapchainSupport.presentModes.empty();
 }
 
 #if BOOST_OS_WINDOWS
@@ -1299,7 +1389,7 @@ VkSurfaceKHR VulkanRenderer::CreateWinSurface(VkInstance instance, HWND hwindow)
 	VkResult err;
 	if ((err = vkCreateWin32SurfaceKHR(instance, &sci, nullptr, &result)) != VK_SUCCESS)
 	{
-		forceLog_printf("Cannot create a Win32 Vulkan surface: %d", (sint32)err);
+		cemuLog_log(LogType::Force, "Cannot create a Win32 Vulkan surface: {}", (sint32)err);
 		throw std::runtime_error(fmt::format("Cannot create a Win32 Vulkan surface: {}", err));
 	}
 
@@ -1320,7 +1410,7 @@ VkSurfaceKHR VulkanRenderer::CreateXlibSurface(VkInstance instance, Display* dpy
     VkResult err;
     if ((err = vkCreateXlibSurfaceKHR(instance, &sci, nullptr, &result)) != VK_SUCCESS)
     {
-		forceLog_printf("Cannot create a X11 Vulkan surface: %d", (sint32)err);
+		cemuLog_log(LogType::Force, "Cannot create a X11 Vulkan surface: {}", (sint32)err);
         throw std::runtime_error(fmt::format("Cannot create a X11 Vulkan surface: {}", err));
     }
 
@@ -1339,89 +1429,51 @@ VkSurfaceKHR VulkanRenderer::CreateXcbSurface(VkInstance instance, xcb_connectio
     VkResult err;
     if ((err = vkCreateXcbSurfaceKHR(instance, &sci, nullptr, &result)) != VK_SUCCESS)
     {
-        forceLog_printf("Cannot create a XCB Vulkan surface: %d", (sint32)err);
+        cemuLog_log(LogType::Force, "Cannot create a XCB Vulkan surface: {}", (sint32)err);
         throw std::runtime_error(fmt::format("Cannot create a XCB Vulkan surface: {}", err));
     }
 
     return result;
 }
-#endif
+#ifdef HAS_WAYLAND
+VkSurfaceKHR VulkanRenderer::CreateWaylandSurface(VkInstance instance, wl_display* display, wl_surface* surface)
+{
+    VkWaylandSurfaceCreateInfoKHR sci{};
+    sci.sType = VK_STRUCTURE_TYPE_WAYLAND_SURFACE_CREATE_INFO_KHR;
+    sci.flags = 0;
+	sci.display = display;
+	sci.surface = surface;
+
+    VkSurfaceKHR result;
+    VkResult err;
+    if ((err = vkCreateWaylandSurfaceKHR(instance, &sci, nullptr, &result)) != VK_SUCCESS)
+    {
+        cemuLog_log(LogType::Force, "Cannot create a Wayland Vulkan surface: {}", (sint32)err);
+        throw std::runtime_error(fmt::format("Cannot create a Wayland Vulkan surface: {}", err));
+    }
+
+    return result;
+}
+#endif // HAS_WAYLAND
+#endif // BOOST_OS_LINUX
 
 VkSurfaceKHR VulkanRenderer::CreateFramebufferSurface(VkInstance instance, struct WindowHandleInfo& windowInfo)
 {
 #if BOOST_OS_WINDOWS
 	return CreateWinSurface(instance, windowInfo.hwnd);
 #elif BOOST_OS_LINUX
-	return CreateXlibSurface(instance, windowInfo.xlib_display, windowInfo.xlib_window);
+	if(windowInfo.backend == WindowHandleInfo::Backend::X11)
+		return CreateXlibSurface(instance, windowInfo.xlib_display, windowInfo.xlib_window);
+	#ifdef HAS_WAYLAND
+	if(windowInfo.backend == WindowHandleInfo::Backend::WAYLAND)
+		return CreateWaylandSurface(instance, windowInfo.display, windowInfo.surface);
+	#endif
+	return {};
 #elif BOOST_OS_MACOS
 	return CreateCocoaSurface(instance, windowInfo.handle);
 #endif
 }
 
-VkSurfaceFormatKHR VulkanRenderer::ChooseSwapSurfaceFormat(const std::vector<VkSurfaceFormatKHR>& formats, bool mainWindow) const
-{
-	if (formats.size() == 1 && formats[0].format == VK_FORMAT_UNDEFINED)
-		return{ VK_FORMAT_B8G8R8A8_UNORM, VK_COLOR_SPACE_SRGB_NONLINEAR_KHR };
-
-	for (const auto& format : formats)
-	{
-		if ((mainWindow && LatteGPUState.tvBufferUsesSRGB) || (!mainWindow && LatteGPUState.drcBufferUsesSRGB))
-		{
-			if (format.format == VK_FORMAT_B8G8R8A8_SRGB && format.colorSpace == VK_COLOR_SPACE_SRGB_NONLINEAR_KHR)
-				return format;
-		}
-		else
-		{
-			if (format.format == VK_FORMAT_B8G8R8A8_UNORM && format.colorSpace == VK_COLOR_SPACE_SRGB_NONLINEAR_KHR)
-				return format;
-		}
-	}
-
-	return formats[0];
-}
-
-VkPresentModeKHR VulkanRenderer::ChooseSwapPresentMode(const std::vector<VkPresentModeKHR>& modes)
-{
-	m_vsync_state = (VSync)GetConfig().vsync.GetValue();
-	if (m_vsync_state == VSync::MAILBOX)
-	{
-		if (std::find(modes.cbegin(), modes.cend(), VK_PRESENT_MODE_MAILBOX_KHR) != modes.cend())
-			return VK_PRESENT_MODE_MAILBOX_KHR;
-
-		forceLog_printf("Vulkan: Can't find mailbox present mode");
-	}
-	else if (m_vsync_state == VSync::Immediate)
-	{
-		if (std::find(modes.cbegin(), modes.cend(), VK_PRESENT_MODE_IMMEDIATE_KHR) != modes.cend())
-			return VK_PRESENT_MODE_IMMEDIATE_KHR;
-
-		forceLog_printf("Vulkan: Can't find immediate present mode");
-	}
-	else if (m_vsync_state == VSync::SYNC_AND_LIMIT)
-	{
-		LatteTiming_EnableHostDrivenVSync();
-		// use immediate mode if available, other wise fall back to 
-		//if (std::find(modes.cbegin(), modes.cend(), VK_PRESENT_MODE_IMMEDIATE_KHR) != modes.cend())
-		//	return VK_PRESENT_MODE_IMMEDIATE_KHR;
-		//else
-		//	forceLog_printf("Vulkan: Present mode 'immediate' not available. Vsync might not behave as intended");
-		return VK_PRESENT_MODE_FIFO_KHR;
-	}
-
-	return VK_PRESENT_MODE_FIFO_KHR;
-}
-
-VkExtent2D VulkanRenderer::ChooseSwapExtent(const VkSurfaceCapabilitiesKHR& capabilities, const Vector2i& size) const
-{
-	if (capabilities.currentExtent.width != std::numeric_limits<uint32>::max())
-		return capabilities.currentExtent;
-
-	VkExtent2D actualExtent = { (uint32)size.x, (uint32)size.y };
-	actualExtent.width = std::max(capabilities.minImageExtent.width, std::min(capabilities.maxImageExtent.width, actualExtent.width));
-	actualExtent.height = std::max(capabilities.minImageExtent.height, std::min(capabilities.maxImageExtent.height, actualExtent.height));
-	return actualExtent;
-}
-
 void VulkanRenderer::CreateCommandPool()
 {
 	VkCommandPoolCreateInfo poolInfo{};
@@ -1457,7 +1509,7 @@ void VulkanRenderer::CreateCommandBuffers()
 	const VkResult result = vkAllocateCommandBuffers(m_logicalDevice, &allocInfo, m_commandBuffers.data());
 	if (result != VK_SUCCESS)
 	{
-		forceLog_printf("Failed to allocate command buffers: %d", result);
+		cemuLog_log(LogType::Force, "Failed to allocate command buffers: {}", result);
 		throw std::runtime_error(fmt::format("Failed to allocate command buffers: {}", result));
 	}
 
@@ -1470,214 +1522,16 @@ void VulkanRenderer::CreateCommandBuffers()
 	}
 }
 
-VkSwapchainCreateInfoKHR VulkanRenderer::CreateSwapchainCreateInfo(VkSurfaceKHR surface, const SwapChainSupportDetails& swapChainSupport, const VkSurfaceFormatKHR& surfaceFormat, uint32 imageCount, const VkExtent2D& extent)
-{
-	VkSwapchainCreateInfoKHR createInfo{};
-	createInfo.sType = VK_STRUCTURE_TYPE_SWAPCHAIN_CREATE_INFO_KHR;
-	createInfo.surface = surface;
-	createInfo.minImageCount = imageCount;
-	createInfo.imageFormat = surfaceFormat.format;
-	createInfo.imageExtent = extent;
-	createInfo.imageArrayLayers = 1;
-	createInfo.imageUsage = VK_IMAGE_USAGE_COLOR_ATTACHMENT_BIT;
-
-	const QueueFamilyIndices indices = FindQueueFamilies(surface, m_physical_device);
-	uint32_t queueFamilyIndices[] = { (uint32)indices.graphicsFamily, (uint32)indices.presentFamily };
-	if (indices.graphicsFamily != indices.presentFamily)
-	{
-		createInfo.imageSharingMode = VK_SHARING_MODE_CONCURRENT;
-		createInfo.queueFamilyIndexCount = 2;
-		createInfo.pQueueFamilyIndices = queueFamilyIndices;
-	}
-	else
-		createInfo.imageSharingMode = VK_SHARING_MODE_EXCLUSIVE;
-
-	createInfo.preTransform = swapChainSupport.capabilities.currentTransform;
-	createInfo.compositeAlpha = VK_COMPOSITE_ALPHA_OPAQUE_BIT_KHR;
-	createInfo.presentMode = ChooseSwapPresentMode(swapChainSupport.presentModes);
-	createInfo.clipped = VK_TRUE;
-
-	forceLogDebug_printf("vulkan presentation mode: %d", createInfo.presentMode);
-	return createInfo;
-}
-
 bool VulkanRenderer::IsSwapchainInfoValid(bool mainWindow) const
 {
-	if (mainWindow)
-		return m_mainSwapchainInfo && m_mainSwapchainInfo->swapChain && m_mainSwapchainInfo->m_imageAvailableFence;
-
-	return m_padSwapchainInfo && m_padSwapchainInfo->swapChain && m_padSwapchainInfo->m_imageAvailableFence;
+	auto& chainInfo = GetChainInfoPtr(mainWindow);
+	return chainInfo && chainInfo->IsValid();
 }
 
-VkSwapchainKHR VulkanRenderer::CreateSwapChain(SwapChainInfo& swap_chain_info, const Vector2i& size, bool mainwindow)
-{
-	const SwapChainSupportDetails details = QuerySwapChainSupport(swap_chain_info.surface, m_physical_device);
-	m_swapchainFormat = ChooseSwapSurfaceFormat(details.formats, mainwindow);
-	swap_chain_info.swapchainExtend = ChooseSwapExtent(details.capabilities, size);
-	// calculate number of swapchain presentation images
-	uint32_t image_count = details.capabilities.minImageCount + 1;
-	if (details.capabilities.maxImageCount > 0 && image_count > details.capabilities.maxImageCount)
-		image_count = details.capabilities.maxImageCount;
-
-	VkSwapchainCreateInfoKHR create_info = CreateSwapchainCreateInfo(swap_chain_info.surface, details, m_swapchainFormat, image_count, swap_chain_info.swapchainExtend);
-	create_info.oldSwapchain = swap_chain_info.swapChain;
-	swap_chain_info.swapChain = nullptr;
-	create_info.imageUsage = VK_IMAGE_USAGE_COLOR_ATTACHMENT_BIT | VK_IMAGE_USAGE_TRANSFER_DST_BIT;
-
-	VkResult result = vkCreateSwapchainKHR(m_logicalDevice, &create_info, nullptr, &swap_chain_info.swapChain);
-	if (result != VK_SUCCESS)
-		UnrecoverableError("Error attempting to create a swapchain");
-
-	result = vkGetSwapchainImagesKHR(m_logicalDevice, swap_chain_info.swapChain, &image_count, nullptr);
-	if (result != VK_SUCCESS)
-		UnrecoverableError("Error attempting to retrieve the count of swapchain images");
-
-	// clean up previously initialized swapchain
-	for (const auto& image : swap_chain_info.m_swapchainImages)
-		vkDestroyImage(m_logicalDevice, image, nullptr);
-	swap_chain_info.m_swapchainImages.clear();
-	for (auto& sem : swap_chain_info.m_swapchainPresentSemaphores)
-		vkDestroySemaphore(m_logicalDevice, sem, nullptr);
-	swap_chain_info.m_swapchainPresentSemaphores.clear();
-
-
-	swap_chain_info.m_swapchainImages.resize(image_count);
-	result = vkGetSwapchainImagesKHR(m_logicalDevice, swap_chain_info.swapChain, &image_count, swap_chain_info.m_swapchainImages.data());
-	if (result != VK_SUCCESS)
-		UnrecoverableError("Error attempting to retrieve swapchain images");
-	// create default renderpass
-	VkAttachmentDescription colorAttachment = {};
-	colorAttachment.format = m_swapchainFormat.format;
-	colorAttachment.samples = VK_SAMPLE_COUNT_1_BIT;
-	colorAttachment.loadOp = VK_ATTACHMENT_LOAD_OP_DONT_CARE;
-	colorAttachment.storeOp = VK_ATTACHMENT_STORE_OP_STORE;
-	colorAttachment.stencilLoadOp = VK_ATTACHMENT_LOAD_OP_DONT_CARE;
-	colorAttachment.stencilStoreOp = VK_ATTACHMENT_STORE_OP_DONT_CARE;
-	colorAttachment.initialLayout = VK_IMAGE_LAYOUT_UNDEFINED;
-	colorAttachment.finalLayout = VK_IMAGE_LAYOUT_PRESENT_SRC_KHR;
-	
-	VkAttachmentReference colorAttachmentRef = {};
-	colorAttachmentRef.attachment = 0;
-	colorAttachmentRef.layout = VK_IMAGE_LAYOUT_COLOR_ATTACHMENT_OPTIMAL;
-	VkSubpassDescription subpass = {};
-	subpass.pipelineBindPoint = VK_PIPELINE_BIND_POINT_GRAPHICS;
-	subpass.colorAttachmentCount = 1;
-	subpass.pColorAttachments = &colorAttachmentRef;
-
-	if (swap_chain_info.m_swapChainRenderPass)
-	{
-		vkDestroyRenderPass(m_logicalDevice, swap_chain_info.m_swapChainRenderPass, nullptr);
-		swap_chain_info.m_swapChainRenderPass = nullptr;
-	}
-
-	VkRenderPassCreateInfo renderPassInfo = {};
-	renderPassInfo.sType = VK_STRUCTURE_TYPE_RENDER_PASS_CREATE_INFO;
-	renderPassInfo.attachmentCount = 1;
-	renderPassInfo.pAttachments = &colorAttachment;
-	renderPassInfo.subpassCount = 1;
-	renderPassInfo.pSubpasses = &subpass;
-	result = vkCreateRenderPass(m_logicalDevice, &renderPassInfo, nullptr, &swap_chain_info.m_swapChainRenderPass);
-	if (result != VK_SUCCESS)
-		UnrecoverableError("Failed to create renderpass for swapchain");
-
-	// create swapchain image views
-	for (const auto& image_view : swap_chain_info.m_swapchainImageViews)
-	{
-		vkDestroyImageView(m_logicalDevice, image_view, nullptr);
-	}
-	swap_chain_info.m_swapchainImageViews.clear();
-
-	swap_chain_info.m_swapchainImageViews.resize(swap_chain_info.m_swapchainImages.size());
-	for (sint32 i = 0; i < swap_chain_info.m_swapchainImages.size(); i++)
-	{
-		VkImageViewCreateInfo createInfo = {};
-		createInfo.sType = VK_STRUCTURE_TYPE_IMAGE_VIEW_CREATE_INFO;
-		createInfo.image = swap_chain_info.m_swapchainImages[i];
-		createInfo.viewType = VK_IMAGE_VIEW_TYPE_2D;
-		createInfo.format = m_swapchainFormat.format;
-		createInfo.components.r = VK_COMPONENT_SWIZZLE_IDENTITY;
-		createInfo.components.g = VK_COMPONENT_SWIZZLE_IDENTITY;
-		createInfo.components.b = VK_COMPONENT_SWIZZLE_IDENTITY;
-		createInfo.components.a = VK_COMPONENT_SWIZZLE_IDENTITY;
-		createInfo.subresourceRange.aspectMask = VK_IMAGE_ASPECT_COLOR_BIT;
-		createInfo.subresourceRange.baseMipLevel = 0;
-		createInfo.subresourceRange.levelCount = 1;
-		createInfo.subresourceRange.baseArrayLayer = 0;
-		createInfo.subresourceRange.layerCount = 1;
-		result = vkCreateImageView(m_logicalDevice, &createInfo, nullptr, &swap_chain_info.m_swapchainImageViews[i]);
-		if (result != VK_SUCCESS)
-			UnrecoverableError("Failed to create imageviews for swapchain");
-	}
-
-	// create swapchain framebuffers
-	for (const auto& framebuffer : swap_chain_info.m_swapchainFramebuffers)
-	{
-		vkDestroyFramebuffer(m_logicalDevice, framebuffer, nullptr);
-	}
-	swap_chain_info.m_swapchainFramebuffers.clear();
-
-	swap_chain_info.m_swapchainFramebuffers.resize(swap_chain_info.m_swapchainImages.size());
-	swap_chain_info.m_swapchainPresentSemaphores.resize(swap_chain_info.m_swapchainImages.size());
-	for (size_t i = 0; i < swap_chain_info.m_swapchainImages.size(); i++)
-	{
-		VkImageView attachments[1];
-		attachments[0] = swap_chain_info.m_swapchainImageViews[i];
-		// create framebuffer
-		VkFramebufferCreateInfo framebufferInfo = {};
-		framebufferInfo.sType = VK_STRUCTURE_TYPE_FRAMEBUFFER_CREATE_INFO;
-		framebufferInfo.renderPass = swap_chain_info.m_swapChainRenderPass;
-		framebufferInfo.attachmentCount = 1;
-		framebufferInfo.pAttachments = attachments;
-		framebufferInfo.width = swap_chain_info.swapchainExtend.width;
-		framebufferInfo.height = swap_chain_info.swapchainExtend.height;
-		framebufferInfo.layers = 1;
-		result = vkCreateFramebuffer(m_logicalDevice, &framebufferInfo, nullptr, &swap_chain_info.m_swapchainFramebuffers[i]);
-		if (result != VK_SUCCESS)
-			UnrecoverableError("Failed to create framebuffer for swapchain");
-		// create present semaphore
-		VkSemaphoreCreateInfo info = {};
-		info.sType = VK_STRUCTURE_TYPE_SEMAPHORE_CREATE_INFO;
-		if (vkCreateSemaphore(m_logicalDevice, &info, nullptr, &swap_chain_info.m_swapchainPresentSemaphores[i]) != VK_SUCCESS)
-			UnrecoverableError("Failed to create semaphore for swapchain present");
-	}
-
-	// init m_acquireInfo
-	for (auto& itr : swap_chain_info.m_acquireInfo)
-	{
-		vkDestroySemaphore(m_logicalDevice, itr.acquireSemaphore, nullptr);
-	}
-	swap_chain_info.m_acquireInfo.clear();
-	swap_chain_info.m_acquireInfo.resize(swap_chain_info.m_swapchainImages.size());
-	for (auto& itr : swap_chain_info.m_acquireInfo)
-	{
-		VkSemaphoreCreateInfo info = {};
-		info.sType = VK_STRUCTURE_TYPE_SEMAPHORE_CREATE_INFO;
-		if (vkCreateSemaphore(m_logicalDevice, &info, nullptr, &itr.acquireSemaphore) != VK_SUCCESS)
-			UnrecoverableError("Failed to create semaphore for swapchain acquire");
-	}
-	swap_chain_info.m_acquireIndex = 0;
-
-
-	if (swap_chain_info.m_imageAvailableFence)
-	{
-		vkDestroyFence(m_logicalDevice, swap_chain_info.m_imageAvailableFence, nullptr);
-		swap_chain_info.m_imageAvailableFence = nullptr;
-	}
-
-	VkFenceCreateInfo fenceInfo = {};
-	fenceInfo.sType = VK_STRUCTURE_TYPE_FENCE_CREATE_INFO;
-	fenceInfo.flags = VK_FENCE_CREATE_SIGNALED_BIT;
-	result = vkCreateFence(m_logicalDevice, &fenceInfo, nullptr, &swap_chain_info.m_imageAvailableFence);
-	if (result != VK_SUCCESS)
-		UnrecoverableError("Failed to create fence for swapchain");
-
-	return swap_chain_info.swapChain;
-}
 
 void VulkanRenderer::CreateNullTexture(NullTexture& nullTex, VkImageType imageType)
 {
-	// these are used when the game requests NULL ptr textures or buffers
-	// texture
+	// these are used when the game requests NULL ptr textures
 	VkImageCreateInfo imageInfo{};
 	imageInfo.sType = VK_STRUCTURE_TYPE_IMAGE_CREATE_INFO;
 	if (imageType == VK_IMAGE_TYPE_1D)
@@ -1773,9 +1627,10 @@ void VulkanRenderer::DeleteNullObjects()
 
 void VulkanRenderer::ImguiInit()
 {
-	// TODO: renderpass swapchain format may change between srgb and rgb -> need reinit
+	VkRenderPass prevRenderPass = m_imguiRenderPass;
+
 	VkAttachmentDescription colorAttachment = {};
-	colorAttachment.format = m_swapchainFormat.format;
+	colorAttachment.format = m_mainSwapchainInfo->m_surfaceFormat.format;
 	colorAttachment.samples = VK_SAMPLE_COUNT_1_BIT;
 	colorAttachment.loadOp = VK_ATTACHMENT_LOAD_OP_LOAD;
 	colorAttachment.storeOp = VK_ATTACHMENT_STORE_OP_STORE;
@@ -1798,13 +1653,13 @@ void VulkanRenderer::ImguiInit()
 	renderPassInfo.pAttachments = &colorAttachment;
 	renderPassInfo.subpassCount = 1;
 	renderPassInfo.pSubpasses = &subpass;
-	const auto result = vkCreateRenderPass(m_logicalDevice, &renderPassInfo, nullptr, &m_mainSwapchainInfo->m_imguiRenderPass);
+	const auto result = vkCreateRenderPass(m_logicalDevice, &renderPassInfo, nullptr, &m_imguiRenderPass);
 	if (result != VK_SUCCESS)
 		throw VkException(result, "can't create imgui renderpass");
 
 	ImGui_ImplVulkan_InitInfo info{};
 	info.Instance = m_instance;
-	info.PhysicalDevice = m_physical_device;
+	info.PhysicalDevice = m_physicalDevice;
 	info.Device = m_logicalDevice;
 	info.QueueFamily = m_indices.presentFamily;
 	info.Queue = m_presentQueue;
@@ -1813,11 +1668,15 @@ void VulkanRenderer::ImguiInit()
 	info.MinImageCount = m_mainSwapchainInfo->m_swapchainImages.size();
 	info.ImageCount = info.MinImageCount;
 
-	ImGui_ImplVulkan_Init(&info, m_mainSwapchainInfo->m_imguiRenderPass);
+	ImGui_ImplVulkan_Init(&info, m_imguiRenderPass);
+
+	if (prevRenderPass != VK_NULL_HANDLE)
+		vkDestroyRenderPass(GetLogicalDevice(), prevRenderPass, nullptr);
 }
 
 void VulkanRenderer::Initialize()
 {
+	Renderer::Initialize();
 	CreatePipelineCache();
 	ImguiInit();
 	CreateNullObjects();
@@ -1826,13 +1685,21 @@ void VulkanRenderer::Initialize()
 void VulkanRenderer::Shutdown()
 {
 	SubmitCommandBuffer();
-	vkDeviceWaitIdle(m_logicalDevice);
+	WaitDeviceIdle();
+	DeleteFontTextures();
+	Renderer::Shutdown();
+	if (m_imguiRenderPass != VK_NULL_HANDLE)
+	{
+		vkDestroyRenderPass(m_logicalDevice, m_imguiRenderPass, nullptr);
+		m_imguiRenderPass = VK_NULL_HANDLE;
+	}
+	RendererShaderVk::Shutdown();
 }
 
 void VulkanRenderer::UnrecoverableError(const char* errMsg) const
 {
-	forceLog_printf("Unrecoverable error in Vulkan renderer");
-	forceLog_printf("Msg: %s", errMsg);
+	cemuLog_log(LogType::Force, "Unrecoverable error in Vulkan renderer");
+	cemuLog_log(LogType::Force, "Msg: {}", errMsg);
 	throw std::runtime_error(errMsg);
 }
 
@@ -1901,22 +1768,22 @@ VulkanRequestedFormat_t requestedFormatList[] =
 void VulkanRenderer::QueryMemoryInfo()
 {
 	VkPhysicalDeviceMemoryProperties memProperties;
-	vkGetPhysicalDeviceMemoryProperties(m_physical_device, &memProperties);
-	forceLog_printf("Vulkan device memory info:");
+	vkGetPhysicalDeviceMemoryProperties(m_physicalDevice, &memProperties);
+	cemuLog_log(LogType::Force, "Vulkan device memory info:");
 	for (uint32 i = 0; i < memProperties.memoryHeapCount; i++)
 	{
-		forceLog_printf("Heap %d - Size %dMB Flags 0x%08x", i, (sint32)(memProperties.memoryHeaps[i].size / 1024ll / 1024ll), (uint32)memProperties.memoryHeaps[i].flags);
+		cemuLog_log(LogType::Force, "Heap {} - Size {}MB Flags 0x{:08x}", i, (sint32)(memProperties.memoryHeaps[i].size / 1024ll / 1024ll), (uint32)memProperties.memoryHeaps[i].flags);
 	}
 	for (uint32 i = 0; i < memProperties.memoryTypeCount; i++)
 	{
-		forceLog_printf("Memory %d - HeapIndex %d Flags 0x%08x", i, (sint32)memProperties.memoryTypes[i].heapIndex, (uint32)memProperties.memoryTypes[i].propertyFlags);
+		cemuLog_log(LogType::Force, "Memory {} - HeapIndex {} Flags 0x{:08x}", i, (sint32)memProperties.memoryTypes[i].heapIndex, (uint32)memProperties.memoryTypes[i].propertyFlags);
 	}
 }
 
 void VulkanRenderer::QueryAvailableFormats()
 {
 	VkFormatProperties fmtProp{};
-	vkGetPhysicalDeviceFormatProperties(m_physical_device, VK_FORMAT_D24_UNORM_S8_UINT, &fmtProp);
+	vkGetPhysicalDeviceFormatProperties(m_physicalDevice, VK_FORMAT_D24_UNORM_S8_UINT, &fmtProp);
 	// D24S8
 	if (fmtProp.optimalTilingFeatures != 0) // todo - more restrictive check
 	{
@@ -1924,16 +1791,37 @@ void VulkanRenderer::QueryAvailableFormats()
 	}
 	// R4G4
 	fmtProp = {};
-	vkGetPhysicalDeviceFormatProperties(m_physical_device, VK_FORMAT_R4G4_UNORM_PACK8, &fmtProp);
+	vkGetPhysicalDeviceFormatProperties(m_physicalDevice, VK_FORMAT_R4G4_UNORM_PACK8, &fmtProp);
 	if (fmtProp.optimalTilingFeatures != 0)
 	{
 		m_supportedFormatInfo.fmt_r4g4_unorm_pack = true;
 	}
+	// R5G6B5
+	fmtProp = {};
+	vkGetPhysicalDeviceFormatProperties(m_physicalDevice, VK_FORMAT_R5G6B5_UNORM_PACK16, &fmtProp);
+	if (fmtProp.optimalTilingFeatures != 0)
+	{
+		m_supportedFormatInfo.fmt_r5g6b5_unorm_pack = true;
+	}
+	// R4G4B4A4
+	fmtProp = {};
+	vkGetPhysicalDeviceFormatProperties(m_physicalDevice, VK_FORMAT_R4G4B4A4_UNORM_PACK16, &fmtProp);
+	if (fmtProp.optimalTilingFeatures != 0)
+	{
+		m_supportedFormatInfo.fmt_r4g4b4a4_unorm_pack = true;
+	}
+	// A1R5G5B5
+	fmtProp = {};
+	vkGetPhysicalDeviceFormatProperties(m_physicalDevice, VK_FORMAT_A1R5G5B5_UNORM_PACK16, &fmtProp);
+	if (fmtProp.optimalTilingFeatures != 0)
+	{
+		m_supportedFormatInfo.fmt_a1r5g5b5_unorm_pack = true;
+	}
 	// print info about unsupported formats to log
 	for (auto& it : requestedFormatList)
 	{
 		fmtProp = {};
-		vkGetPhysicalDeviceFormatProperties(m_physical_device, it.fmt, &fmtProp);
+		vkGetPhysicalDeviceFormatProperties(m_physicalDevice, it.fmt, &fmtProp);
 		VkFormatFeatureFlags requestedBits = 0;
 		if (it.mustSupportAttachment)
 		{
@@ -1949,7 +1837,7 @@ void VulkanRenderer::QueryAvailableFormats()
 
 		if (fmtProp.optimalTilingFeatures == 0)
 		{
-			forceLog_printf("%s not supported", it.name);
+			cemuLog_log(LogType::Force, "{} not supported", it.name);
 		}
 		else if ((fmtProp.optimalTilingFeatures & requestedBits) != requestedBits)
 		{
@@ -1965,47 +1853,31 @@ void VulkanRenderer::QueryAvailableFormats()
 			//	missingStr.append(" TRANSFER_DST");
 			//if (!(fmtProp.optimalTilingFeatures & VK_FORMAT_FEATURE_SAMPLED_IMAGE_BIT))
 			//	missingStr.append(" SAMPLED_IMAGE");
-			//forceLog_printf("%s", missingStr.c_str());
+			//cemuLog_log(LogType::Force, "{}", missingStr.c_str());
 		}
 	}
 }
 
-void VulkanRenderer::EnableVSync(int state)
-{
-	if (m_vsync_state == (VSync)state)
-		return;
-
-	m_vsync_state = (VSync)state;
-
-	// recreate spawn chains (vsync state is checked from config in ChooseSwapPresentMode)
-	RecreateSwapchain(true);
-	if (m_padSwapchainInfo)
-		RecreateSwapchain(false);
-}
-
 bool VulkanRenderer::ImguiBegin(bool mainWindow)
 {
 	if (!Renderer::ImguiBegin(mainWindow))
 		return false;
 
-	if (!IsSwapchainInfoValid(mainWindow))
+	auto& chainInfo = GetChainInfo(mainWindow);
+
+	if (!AcquireNextSwapchainImage(mainWindow))
 		return false;
 
 	draw_endRenderPass();
 	m_state.currentPipeline = VK_NULL_HANDLE;
 
-	AcquireNextSwapchainImage(mainWindow);
-
-	auto& swapchain_info = mainWindow ? *m_mainSwapchainInfo : *m_padSwapchainInfo;
-
 	ImGui_ImplVulkan_CreateFontsTexture(m_state.currentCommandBuffer);
-	ImGui_ImplVulkan_NewFrame(m_state.currentCommandBuffer, swapchain_info.m_swapchainFramebuffers[swapchain_info.swapchainImageIndex], swapchain_info.swapchainExtend);
+	ImGui_ImplVulkan_NewFrame(m_state.currentCommandBuffer, chainInfo.m_swapchainFramebuffers[chainInfo.swapchainImageIndex], chainInfo.getExtent());
 	ImGui_UpdateWindowInformation(mainWindow);
 	ImGui::NewFrame();
 	return true;
 }
 
-
 void VulkanRenderer::ImguiEnd()
 {
 	ImGui::Render();
@@ -2013,12 +1885,10 @@ void VulkanRenderer::ImguiEnd()
 	vkCmdEndRenderPass(m_state.currentCommandBuffer);
 }
 
-std::vector<LatteTextureVk*> g_imgui_textures; // TODO manage better
 ImTextureID VulkanRenderer::GenerateTexture(const std::vector<uint8>& data, const Vector2i& size)
 {
 	try
 	{
-		//	g_imgui_textures.emplace_back(texture);
 		std::vector <uint8> tmp(size.x * size.y * 4);
 		for (size_t i = 0; i < data.size() / 3; ++i)
 		{
@@ -2031,40 +1901,36 @@ ImTextureID VulkanRenderer::GenerateTexture(const std::vector<uint8>& data, cons
 	}
 	catch (const std::exception& ex)
 	{
-		forceLog_printf("can't generate imgui texture: %s", ex.what());
+		cemuLog_log(LogType::Force, "can't generate imgui texture: {}", ex.what());
 		return nullptr;
 	}
 }
 
 void VulkanRenderer::DeleteTexture(ImTextureID id)
 {
-	vkDeviceWaitIdle(m_logicalDevice);
+	WaitDeviceIdle();
 	ImGui_ImplVulkan_DeleteTexture(id);
 }
 
 void VulkanRenderer::DeleteFontTextures()
 {
+	WaitDeviceIdle();
 	ImGui_ImplVulkan_DestroyFontsTexture();
 }
 
 
 bool VulkanRenderer::BeginFrame(bool mainWindow)
 {
-	if (!IsSwapchainInfoValid(mainWindow))
+	if (!AcquireNextSwapchainImage(mainWindow))
 		return false;
 
-	AcquireNextSwapchainImage(mainWindow);
-
-	auto& swap_info = mainWindow ? *m_mainSwapchainInfo : *m_padSwapchainInfo;
+	auto& chainInfo = GetChainInfo(mainWindow);
 
 	VkClearColorValue clearColor{ 0, 0, 0, 0 };
-	ClearColorImageRaw(swap_info.m_swapchainImages[swap_info.swapchainImageIndex], 0, 0, clearColor, VK_IMAGE_LAYOUT_UNDEFINED, VK_IMAGE_LAYOUT_PRESENT_SRC_KHR);
+	ClearColorImageRaw(chainInfo.m_swapchainImages[chainInfo.swapchainImageIndex], 0, 0, clearColor, VK_IMAGE_LAYOUT_UNDEFINED, VK_IMAGE_LAYOUT_PRESENT_SRC_KHR);
 
 	// mark current swapchain image as well defined
-	if (!mainWindow)
-		m_swapchainState.drcHasDefinedSwapchainImage = true;
-	else
-		m_swapchainState.tvHasDefinedSwapchainImage = true;
+	chainInfo.hasDefinedSwapchainImage = true;
 
 	return true;
 }
@@ -2076,52 +1942,6 @@ void VulkanRenderer::DrawEmptyFrame(bool mainWindow)
 	SwapBuffers(mainWindow, !mainWindow);
 }
 
-void VulkanRenderer::PreparePresentationFrame(bool mainWindow)
-{
-	if (!IsSwapchainInfoValid(mainWindow))
-		return;
-
-	AcquireNextSwapchainImage(mainWindow);
-}
-
-void VulkanRenderer::ProcessDestructionQueues(size_t commandBufferIndex)
-{
-	auto& current_descriptor_cache = m_destructionQueues.m_cmd_descriptor_set_objects[commandBufferIndex];
-	if (!current_descriptor_cache.empty())
-	{
-		assert_dbg();
-		//for (const auto& descriptor : current_descriptor_cache)
-		//{
-		//	vkFreeDescriptorSets(m_logicalDevice, m_descriptorPool, 1, &descriptor);
-		//	performanceMonitor.vk.numDescriptorSets.decrement();
-		//}
-
-		current_descriptor_cache.clear();
-	}
-
-	// destroy buffers
-	for (auto& itr : m_destructionQueues.m_buffers[commandBufferIndex])
-		vkDestroyBuffer(m_logicalDevice, itr, nullptr);
-	m_destructionQueues.m_buffers[commandBufferIndex].clear();
-
-	// destroy device memory objects
-	for (auto& itr : m_destructionQueues.m_memory[commandBufferIndex])
-		vkFreeMemory(m_logicalDevice, itr, nullptr);
-	m_destructionQueues.m_memory[commandBufferIndex].clear();
-
-	// destroy image views
-	for (auto& itr : m_destructionQueues.m_cmd_image_views[commandBufferIndex])
-		vkDestroyImageView(m_logicalDevice, itr, nullptr);
-	m_destructionQueues.m_cmd_image_views[commandBufferIndex].clear();
-
-	// destroy host textures
-	for (auto itr : m_destructionQueues.m_host_textures[commandBufferIndex])
-		delete itr;
-	m_destructionQueues.m_host_textures[commandBufferIndex].clear();
-
-	ProcessDestructionQueue2();
-}
-
 void VulkanRenderer::InitFirstCommandBuffer()
 {
 	cemu_assert_debug(m_state.currentCommandBuffer == nullptr);
@@ -2133,7 +1953,7 @@ void VulkanRenderer::InitFirstCommandBuffer()
 	vkResetFences(m_logicalDevice, 1, &m_cmd_buffer_fences[m_commandBufferIndex]);
 	VkCommandBufferBeginInfo beginInfo{};
 	beginInfo.sType = VK_STRUCTURE_TYPE_COMMAND_BUFFER_BEGIN_INFO;
-	beginInfo.flags = VK_COMMAND_BUFFER_USAGE_SIMULTANEOUS_USE_BIT;
+	beginInfo.flags = VK_COMMAND_BUFFER_USAGE_ONE_TIME_SUBMIT_BIT;
 	vkBeginCommandBuffer(m_state.currentCommandBuffer, &beginInfo);
 
 	vkCmdSetViewport(m_state.currentCommandBuffer, 0, 1, &m_state.currentViewport);
@@ -2150,7 +1970,8 @@ void VulkanRenderer::ProcessFinishedCommandBuffers()
 		VkResult fenceStatus = vkGetFenceStatus(m_logicalDevice, m_cmd_buffer_fences[m_commandBufferSyncIndex]);
 		if (fenceStatus == VK_SUCCESS)
 		{
-			ProcessDestructionQueues(m_commandBufferSyncIndex);
+			ProcessDestructionQueue();
+			m_uniformVarBufferReadIndex = m_cmdBufferUniformRingbufIndices[m_commandBufferSyncIndex];
 			m_commandBufferSyncIndex = (m_commandBufferSyncIndex + 1) % m_commandBuffers.size();
 			memoryManager->cleanupBuffers(m_countCommandBufferFinished);
 			m_countCommandBufferFinished++;
@@ -2162,7 +1983,7 @@ void VulkanRenderer::ProcessFinishedCommandBuffers()
 			// not signaled
 			break;
 		}
-		forceLog_printf("vkGetFenceStatus returned unexpected error %d", (sint32)fenceStatus);
+		cemuLog_log(LogType::Force, "vkGetFenceStatus returned unexpected error {}", (sint32)fenceStatus);
 		cemu_assert_debug(false);
 	}
 	if (finishedCmdBuffers)
@@ -2178,17 +1999,17 @@ void VulkanRenderer::WaitForNextFinishedCommandBuffer()
 	VkResult result = vkWaitForFences(m_logicalDevice, 1, &m_cmd_buffer_fences[m_commandBufferSyncIndex], true, UINT64_MAX);
 	if (result == VK_TIMEOUT)
 	{
-		forceLog_printf("vkWaitForFences: Returned VK_TIMEOUT on infinite fence");
+		cemuLog_log(LogType::Force, "vkWaitForFences: Returned VK_TIMEOUT on infinite fence");
 	}
 	else if (result != VK_SUCCESS)
 	{
-		forceLog_printf("vkWaitForFences: Returned unhandled error %d", (sint32)result);
+		cemuLog_log(LogType::Force, "vkWaitForFences: Returned unhandled error {}", (sint32)result);
 	}
 	// process
 	ProcessFinishedCommandBuffers();
 }
 
-void VulkanRenderer::SubmitCommandBuffer(VkSemaphore* signalSemaphore, VkSemaphore* waitSemaphore)
+void VulkanRenderer::SubmitCommandBuffer(VkSemaphore signalSemaphore, VkSemaphore waitSemaphore)
 {
 	draw_endRenderPass();
 
@@ -2203,11 +2024,11 @@ void VulkanRenderer::SubmitCommandBuffer(VkSemaphore* signalSemaphore, VkSemapho
 
 	// signal current command buffer semaphore
 	VkSemaphore signalSemArray[2];
-	if (signalSemaphore)
+	if (signalSemaphore != VK_NULL_HANDLE)
 	{
 		submitInfo.signalSemaphoreCount = 2;
 		signalSemArray[0] = m_commandBufferSemaphores[m_commandBufferIndex]; // signal current
-		signalSemArray[1] = *signalSemaphore; // signal current
+		signalSemArray[1] = signalSemaphore; // signal current
 		submitInfo.pSignalSemaphores = signalSemArray;
 	}
 	else
@@ -2223,8 +2044,8 @@ void VulkanRenderer::SubmitCommandBuffer(VkSemaphore* signalSemaphore, VkSemapho
 	submitInfo.waitSemaphoreCount = 0;
 	if (m_numSubmittedCmdBuffers > 0)
 		waitSemArray[submitInfo.waitSemaphoreCount++] = prevSem; // wait on semaphore from previous submit
-	if (waitSemaphore)
-		waitSemArray[submitInfo.waitSemaphoreCount++] = *waitSemaphore;
+	if (waitSemaphore != VK_NULL_HANDLE)
+		waitSemArray[submitInfo.waitSemaphoreCount++] = waitSemaphore;
 	submitInfo.pWaitDstStageMask = semWaitStageMask;
 	submitInfo.pWaitSemaphores = waitSemArray;
 
@@ -2241,9 +2062,10 @@ void VulkanRenderer::SubmitCommandBuffer(VkSemaphore* signalSemaphore, VkSemapho
 	if (nextCmdBufferIndex == m_commandBufferSyncIndex)
 	{
 		// force wait for the next command buffer
-		forceLogDebug_printf("Vulkan: Waiting for available command buffer...");
+		cemuLog_logDebug(LogType::Force, "Vulkan: Waiting for available command buffer...");
 		WaitForNextFinishedCommandBuffer();
 	}
+	m_cmdBufferUniformRingbufIndices[nextCmdBufferIndex] = m_cmdBufferUniformRingbufIndices[m_commandBufferIndex];
 	m_commandBufferIndex = nextCmdBufferIndex;
 
 
@@ -2253,7 +2075,7 @@ void VulkanRenderer::SubmitCommandBuffer(VkSemaphore* signalSemaphore, VkSemapho
 
 	VkCommandBufferBeginInfo beginInfo{};
 	beginInfo.sType = VK_STRUCTURE_TYPE_COMMAND_BUFFER_BEGIN_INFO;
-	beginInfo.flags = VK_COMMAND_BUFFER_USAGE_SIMULTANEOUS_USE_BIT;
+	beginInfo.flags = VK_COMMAND_BUFFER_USAGE_ONE_TIME_SUBMIT_BIT;
 	vkBeginCommandBuffer(m_state.currentCommandBuffer, &beginInfo);
 
 	// make sure some states are set for this command buffer
@@ -2269,7 +2091,7 @@ void VulkanRenderer::SubmitCommandBuffer(VkSemaphore* signalSemaphore, VkSemapho
 	occlusionQuery_notifyBeginCommandBuffer();
 
 	m_recordedDrawcalls = 0;
-	m_submitThreshold = 500; // this used to be 750 before 1.25.5, but more frequent submission is actually better for latency
+	m_submitThreshold = 300;
 	m_submitOnIdle = false;
 }
 
@@ -2305,7 +2127,8 @@ void VulkanRenderer::WaitCommandBufferFinished(uint64 commandBufferId)
 
 void VulkanRenderer::PipelineCacheSaveThread(size_t cache_size)
 {
-	const auto dir = ActiveSettings::GetPath("shaderCache/driver/vk");
+	SetThreadName("vkDriverPlCache");
+	const auto dir = ActiveSettings::GetCachePath("shaderCache/driver/vk");
 	if (!fs::exists(dir))
 	{
 		try
@@ -2314,7 +2137,7 @@ void VulkanRenderer::PipelineCacheSaveThread(size_t cache_size)
 		}
 		catch (const std::exception& ex)
 		{
-			forceLog_printf("can't create vulkan pipeline cache directory \"%s\": %s", dir.generic_string().c_str(), ex.what());
+			cemuLog_log(LogType::Force, "can't create vulkan pipeline cache directory \"{}\": {}", _pathToUtf8(dir), ex.what());
 			return;
 		}
 	}
@@ -2359,16 +2182,16 @@ void VulkanRenderer::PipelineCacheSaveThread(size_t cache_size)
 					file.close();
 
 					cache_size = size;
-					forceLogDebug_printf("pipeline cache saved");
+					cemuLog_logDebug(LogType::Force, "pipeline cache saved");
 				}
 				else
 				{
-					forceLog_printf("can't write pipeline cache to disk");
+					cemuLog_log(LogType::Force, "can't write pipeline cache to disk");
 				}
 			}
 			else
 			{
-				forceLog_printf("can't retrieve pipeline cache data: 0x%x", res);
+				cemuLog_log(LogType::Force, "can't retrieve pipeline cache data: 0x{:x}", res);
 			}
 		}
 		else
@@ -2382,22 +2205,18 @@ void VulkanRenderer::PipelineCacheSaveThread(size_t cache_size)
 void VulkanRenderer::CreatePipelineCache()
 {
 	std::vector<uint8_t> cacheData;
-	const auto dir = ActiveSettings::GetPath("shaderCache/driver/vk");
+	const auto dir = ActiveSettings::GetCachePath("shaderCache/driver/vk");
 	if (fs::exists(dir))
 	{
 		const auto filename = dir / fmt::format("{:016x}.bin", CafeSystem::GetForegroundTitleId());
-
 		auto file = std::ifstream(filename, std::ios::in | std::ios::binary | std::ios::ate);
 		if (file.is_open())
 		{
 			const size_t fileSize = file.tellg();
 			file.seekg(0, std::ifstream::beg);
-
 			cacheData.resize(fileSize);
 			file.read((char*)cacheData.data(), cacheData.size());
 			file.close();
-
-			forceLogDebug_printf("pipeline cache loaded");
 		}
 	}
 
@@ -2407,7 +2226,16 @@ void VulkanRenderer::CreatePipelineCache()
 	createInfo.pInitialData = cacheData.data();
 	VkResult result = vkCreatePipelineCache(m_logicalDevice, &createInfo, nullptr, &m_pipeline_cache);
 	if (result != VK_SUCCESS)
-		UnrecoverableError(fmt::format("Failed to create pipeline cache: {}", result).c_str());
+	{
+		cemuLog_log(LogType::Force, "Failed to open Vulkan pipeline cache: {}", result);
+		// unable to load the existing cache, start with an empty cache instead
+		createInfo.sType = VK_STRUCTURE_TYPE_PIPELINE_CACHE_CREATE_INFO;
+		createInfo.initialDataSize = 0;
+		createInfo.pInitialData = nullptr;
+		result = vkCreatePipelineCache(m_logicalDevice, &createInfo, nullptr, &m_pipeline_cache);
+		if (result != VK_SUCCESS)
+			UnrecoverableError(fmt::format("Failed to create new Vulkan pipeline cache: {}", result).c_str());
+	}
 
 	size_t cache_size = 0;
 	vkGetPipelineCacheData(m_logicalDevice, m_pipeline_cache, &cache_size, nullptr);
@@ -2479,7 +2307,7 @@ void VulkanRenderer::GetTextureFormatInfoVK(Latte::E_GX2SURFFMT format, bool isD
 			formatInfoOut->decoder = TextureDecoder_D32_S8_UINT_X24::getInstance();
 			break;
 		default:
-			forceLog_printf("Unsupported depth texture format %04x", (uint32)format);
+			cemuLog_log(LogType::Force, "Unsupported depth texture format {:04x}", (uint32)format);
 			// default to placeholder format
 			formatInfoOut->vkImageFormat = VK_FORMAT_D16_UNORM;
 			formatInfoOut->vkImageAspect = VK_IMAGE_ASPECT_DEPTH_BIT;
@@ -2490,6 +2318,8 @@ void VulkanRenderer::GetTextureFormatInfoVK(Latte::E_GX2SURFFMT format, bool isD
 	else
 	{
 		formatInfoOut->vkImageAspect = VK_IMAGE_ASPECT_COLOR_BIT;
+		if(format == (Latte::E_GX2SURFFMT::R16_G16_B16_A16_FLOAT | Latte::E_GX2SURFFMT::FMT_BIT_SRGB)) // Seen in Sonic Transformed level Starry Speedway. SRGB should just be ignored for native float formats?
+			format = Latte::E_GX2SURFFMT::R16_G16_B16_A16_FLOAT;
 		switch (format)
 		{
 			// RGBA formats
@@ -2565,13 +2395,19 @@ void VulkanRenderer::GetTextureFormatInfoVK(Latte::E_GX2SURFFMT format, bool isD
 		case Latte::E_GX2SURFFMT::R4_G4_UNORM:
 			if (m_supportedFormatInfo.fmt_r4g4_unorm_pack == false)
 			{
-				formatInfoOut->vkImageFormat = VK_FORMAT_R4G4B4A4_UNORM_PACK16;
-				formatInfoOut->decoder = TextureDecoder_R4_G4_UNORM_toRGBA4444_vk::getInstance();
+				if (m_supportedFormatInfo.fmt_r4g4b4a4_unorm_pack == false) {
+					formatInfoOut->vkImageFormat = VK_FORMAT_R8G8B8A8_UNORM;
+					formatInfoOut->decoder = TextureDecoder_R4G4_UNORM_To_RGBA8::getInstance();
+				}
+				else {
+					formatInfoOut->vkImageFormat = VK_FORMAT_R4G4B4A4_UNORM_PACK16;
+					formatInfoOut->decoder = TextureDecoder_R4_G4_UNORM_To_RGBA4_vk::getInstance();
+				}
 			}
 			else
 			{
 				formatInfoOut->vkImageFormat = VK_FORMAT_R4G4_UNORM_PACK8;
-				formatInfoOut->decoder = TextureDecoder_R4_G4::getInstance(); // todo - verify if order of R/G matches between GX2/Vulkan
+				formatInfoOut->decoder = TextureDecoder_R4_G4::getInstance();
 			}
 			break;
 			// R formats
@@ -2613,28 +2449,52 @@ void VulkanRenderer::GetTextureFormatInfoVK(Latte::E_GX2SURFFMT format, bool isD
 			break;
 			// special formats
 		case Latte::E_GX2SURFFMT::R5_G6_B5_UNORM:
-			// Vulkan has R in MSB, GPU7 has it in LSB
-			formatInfoOut->vkImageFormat = VK_FORMAT_R5G6B5_UNORM_PACK16;
-			formatInfoOut->decoder = TextureDecoder_R5_G6_B5_swappedRB::getInstance();
+			if (m_supportedFormatInfo.fmt_r5g6b5_unorm_pack == false) {
+				formatInfoOut->vkImageFormat = VK_FORMAT_R8G8B8A8_UNORM;
+				formatInfoOut->decoder = TextureDecoder_R5G6B5_UNORM_To_RGBA8::getInstance();
+			}
+			else {
+				// Vulkan has R in MSB, GPU7 has it in LSB
+				formatInfoOut->vkImageFormat = VK_FORMAT_R5G6B5_UNORM_PACK16;
+				formatInfoOut->decoder = TextureDecoder_R5_G6_B5_swappedRB::getInstance();
+			}
 			break;
 		case Latte::E_GX2SURFFMT::R5_G5_B5_A1_UNORM:
-			// used in Super Mario 3D World for the hidden Luigi sprites
-			// since order of channels is reversed in Vulkan compared to GX2 the format we need is A1B5G5R5
-			formatInfoOut->vkImageFormat = VK_FORMAT_A1R5G5B5_UNORM_PACK16;
-			formatInfoOut->decoder = TextureDecoder_R5_G5_B5_A1_UNORM_swappedRB::getInstance();
+			if (m_supportedFormatInfo.fmt_a1r5g5b5_unorm_pack == false) {
+				formatInfoOut->vkImageFormat = VK_FORMAT_R8G8B8A8_UNORM;
+				formatInfoOut->decoder = TextureDecoder_R5_G5_B5_A1_UNORM_swappedRB_To_RGBA8::getInstance();
+			}
+			else {
+				// used in Super Mario 3D World for the hidden Luigi sprites
+				// since order of channels is reversed in Vulkan compared to GX2 the format we need is A1B5G5R5
+				formatInfoOut->vkImageFormat = VK_FORMAT_A1R5G5B5_UNORM_PACK16;
+				formatInfoOut->decoder = TextureDecoder_R5_G5_B5_A1_UNORM_swappedRB::getInstance();
+			}
 			break;
 		case Latte::E_GX2SURFFMT::A1_B5_G5_R5_UNORM:
-			// used by VC64 (e.g. Ocarina of Time)
-			formatInfoOut->vkImageFormat = VK_FORMAT_A1R5G5B5_UNORM_PACK16; // A 15 R 10..14, G 5..9 B 0..4
-			formatInfoOut->decoder = TextureDecoder_A1_B5_G5_R5_UNORM_vulkan::getInstance();
+			if (m_supportedFormatInfo.fmt_a1r5g5b5_unorm_pack == false) {
+				formatInfoOut->vkImageFormat = VK_FORMAT_R8G8B8A8_UNORM;
+				formatInfoOut->decoder = TextureDecoder_A1_B5_G5_R5_UNORM_vulkan_To_RGBA8::getInstance();
+			}
+			else {
+				// used by VC64 (e.g. Ocarina of Time)
+				formatInfoOut->vkImageFormat = VK_FORMAT_A1R5G5B5_UNORM_PACK16; // A 15 R 10..14, G 5..9 B 0..4
+				formatInfoOut->decoder = TextureDecoder_A1_B5_G5_R5_UNORM_vulkan::getInstance();
+			}
 			break;
 		case Latte::E_GX2SURFFMT::R11_G11_B10_FLOAT:
 			formatInfoOut->vkImageFormat = VK_FORMAT_B10G11R11_UFLOAT_PACK32; // verify if order of channels is still the same as GX2
 			formatInfoOut->decoder = TextureDecoder_R11_G11_B10_FLOAT::getInstance();
 			break;
 		case Latte::E_GX2SURFFMT::R4_G4_B4_A4_UNORM:
-			formatInfoOut->vkImageFormat = VK_FORMAT_R4G4B4A4_UNORM_PACK16; // verify order of channels
-			formatInfoOut->decoder = TextureDecoder_R4_G4_B4_A4_UNORM::getInstance();
+			if (m_supportedFormatInfo.fmt_r4g4b4a4_unorm_pack == false) {
+				formatInfoOut->vkImageFormat = VK_FORMAT_R8G8B8A8_UNORM;
+				formatInfoOut->decoder = TextureDecoder_R4G4B4A4_UNORM_To_RGBA8::getInstance();
+			}
+			else {
+				formatInfoOut->vkImageFormat = VK_FORMAT_R4G4B4A4_UNORM_PACK16;
+ 				formatInfoOut->decoder = TextureDecoder_R4_G4_B4_A4_UNORM::getInstance();
+			}
 			break;
 			// special formats - R10G10B10_A2
 		case Latte::E_GX2SURFFMT::R10_G10_B10_A2_UNORM:
@@ -2643,11 +2503,11 @@ void VulkanRenderer::GetTextureFormatInfoVK(Latte::E_GX2SURFFMT format, bool isD
 			break;
 		case Latte::E_GX2SURFFMT::R10_G10_B10_A2_SNORM:
 			formatInfoOut->vkImageFormat = VK_FORMAT_R16G16B16A16_SNORM; // Vulkan has VK_FORMAT_A2R10G10B10_SNORM_PACK32 but it doesnt work?
-			formatInfoOut->decoder = TextureDecoder_R10_G10_B10_A2_SNORM_toRGBA16::getInstance();
+			formatInfoOut->decoder = TextureDecoder_R10_G10_B10_A2_SNORM_To_RGBA16::getInstance();
 			break;
 		case Latte::E_GX2SURFFMT::R10_G10_B10_A2_SRGB:
 			//formatInfoOut->vkImageFormat = VK_FORMAT_R16G16B16A16_SNORM; // Vulkan has no uncompressed SRGB format with more than 8 bits per channel
-			//formatInfoOut->decoder = TextureDecoder_R10_G10_B10_A2_SNORM_toRGBA16::getInstance();
+			//formatInfoOut->decoder = TextureDecoder_R10_G10_B10_A2_SNORM_To_RGBA16::getInstance();
 			//break;
 			formatInfoOut->vkImageFormat = VK_FORMAT_A2B10G10R10_UNORM_PACK32; // todo - verify
 			formatInfoOut->decoder = TextureDecoder_R10_G10_B10_A2_UNORM::getInstance();
@@ -2701,8 +2561,13 @@ void VulkanRenderer::GetTextureFormatInfoVK(Latte::E_GX2SURFFMT format, bool isD
 			// used by Color Splash and Resident Evil
 			formatInfoOut->vkImageFormat = VK_FORMAT_R8G8B8A8_UINT; // todo - should we use ABGR format?
 			formatInfoOut->decoder = TextureDecoder_X24_G8_UINT::getInstance(); // todo - verify
+		case Latte::E_GX2SURFFMT::R32_X8_FLOAT:
+			// seen in Disney Infinity 3.0
+			formatInfoOut->vkImageFormat = VK_FORMAT_R32_SFLOAT;
+			formatInfoOut->decoder = TextureDecoder_NullData64::getInstance();
+			break;
 		default:
-			forceLog_printf("Unsupported color texture format %04x\n", (uint32)format);
+			cemuLog_log(LogType::Force, "Unsupported color texture format {:04x}", (uint32)format);
 			cemu_assert_debug(false);
 		}
 	}
@@ -2720,7 +2585,7 @@ VkPipelineShaderStageCreateInfo VulkanRenderer::CreatePipelineShaderStageCreateI
 
 VkPipeline VulkanRenderer::backbufferBlit_createGraphicsPipeline(VkDescriptorSetLayout descriptorLayout, bool padView, RendererOutputShader* shader)
 {
-	auto& swap_info = !padView ? *m_mainSwapchainInfo : *m_padSwapchainInfo;
+	auto& chainInfo = GetChainInfo(!padView);
 
 	RendererShaderVk* vertexRendererShader = static_cast<RendererShaderVk*>(shader->GetVertexShader());
 	RendererShaderVk* fragmentRendererShader = static_cast<RendererShaderVk*>(shader->GetFragmentShader());
@@ -2728,12 +2593,11 @@ VkPipeline VulkanRenderer::backbufferBlit_createGraphicsPipeline(VkDescriptorSet
 	uint64 hash = 0;
 	hash += (uint64)vertexRendererShader;
 	hash += (uint64)fragmentRendererShader;
-	hash += (uint64)(padView ? m_drvBufferUsesSRGB : m_tvBufferUsesSRGB);
+	hash += (uint64)(chainInfo.m_usesSRGB);
 	hash += ((uint64)padView) << 1;
 
-	static std::unordered_map<uint64, VkPipeline> s_pipeline_cache;
-	const auto it = s_pipeline_cache.find(hash);
-	if (it != s_pipeline_cache.cend())
+	const auto it = m_backbufferBlitPipelineCache.find(hash);
+	if (it != m_backbufferBlitPipelineCache.cend())
 		return it->second;
 
 	std::vector<VkPipelineShaderStageCreateInfo> shaderStages;
@@ -2795,10 +2659,18 @@ VkPipeline VulkanRenderer::backbufferBlit_createGraphicsPipeline(VkDescriptorSet
 	colorBlending.blendConstants[2] = 0.0f;
 	colorBlending.blendConstants[3] = 0.0f;
 
+	VkPushConstantRange pushConstantRange{
+		.stageFlags = VK_SHADER_STAGE_FRAGMENT_BIT,
+		.offset = 0,
+		.size = 3 * sizeof(float) * 2 // 3 vec2's
+	};
+
 	VkPipelineLayoutCreateInfo pipelineLayoutInfo{};
 	pipelineLayoutInfo.sType = VK_STRUCTURE_TYPE_PIPELINE_LAYOUT_CREATE_INFO;
 	pipelineLayoutInfo.setLayoutCount = 1;
 	pipelineLayoutInfo.pSetLayouts = &descriptorLayout;
+	pipelineLayoutInfo.pushConstantRangeCount = 1;
+	pipelineLayoutInfo.pPushConstantRanges = &pushConstantRange;
 
 	VkResult result = vkCreatePipelineLayout(m_logicalDevice, &pipelineLayoutInfo, nullptr, &m_pipelineLayout);
 	if (result != VK_SUCCESS)
@@ -2816,7 +2688,7 @@ VkPipeline VulkanRenderer::backbufferBlit_createGraphicsPipeline(VkDescriptorSet
 	pipelineInfo.pMultisampleState = &multisampling;
 	pipelineInfo.pColorBlendState = &colorBlending;
 	pipelineInfo.layout = m_pipelineLayout;
-	pipelineInfo.renderPass = swap_info.m_swapChainRenderPass;
+	pipelineInfo.renderPass = chainInfo.m_swapchainRenderPass;
 	pipelineInfo.subpass = 0;
 	pipelineInfo.basePipelineHandle = VK_NULL_HANDLE;
 
@@ -2825,207 +2697,188 @@ VkPipeline VulkanRenderer::backbufferBlit_createGraphicsPipeline(VkDescriptorSet
 	result = vkCreateGraphicsPipelines(m_logicalDevice, m_pipeline_cache, 1, &pipelineInfo, nullptr, &pipeline);
 	if (result != VK_SUCCESS)
 	{
-		forceLog_printf("Failed to create graphics pipeline. Error %d", result);
+		cemuLog_log(LogType::Force, "Failed to create graphics pipeline. Error {}", result);
 		throw std::runtime_error(fmt::format("Failed to create graphics pipeline: {}", result));
 	}
 
-	s_pipeline_cache[hash] = pipeline;
+	m_backbufferBlitPipelineCache[hash] = pipeline;
 	m_pipeline_cache_semaphore.notify();
 
 	return pipeline;
 }
 
-void VulkanRenderer::AcquireNextSwapchainImage(bool main_window)
+bool VulkanRenderer::AcquireNextSwapchainImage(bool mainWindow)
 {
-	auto& swapInfo = main_window ? *m_mainSwapchainInfo : *m_padSwapchainInfo;
-	if (swapInfo.swapchainImageIndex != -1)
-		return; // image already reserved
+	if(!IsSwapchainInfoValid(mainWindow))
+		return false;
 
-
-	vkWaitForFences(m_logicalDevice, 1, &swapInfo.m_imageAvailableFence, VK_TRUE, std::numeric_limits<uint64_t>::max());
-	vkResetFences(m_logicalDevice, 1, &swapInfo.m_imageAvailableFence);
-
-	auto& acquireInfo = swapInfo.m_acquireInfo[swapInfo.m_acquireIndex];
-
-	VkResult result = vkAcquireNextImageKHR(m_logicalDevice, swapInfo.swapChain, std::numeric_limits<uint64_t>::max(), acquireInfo.acquireSemaphore, swapInfo.m_imageAvailableFence, &swapInfo.swapchainImageIndex);
-	if (result != VK_SUCCESS)
+	if(!mainWindow && m_destroyPadSwapchainNextAcquire.test())
 	{
-		while (result == VK_ERROR_OUT_OF_DATE_KHR || result == VK_SUBOPTIMAL_KHR) // todo: handle error state correctly. Looping doesnt always make sense?
-		{
-			try
-			{
-				RecreateSwapchain(main_window);
-				if (vkWaitForFences(m_logicalDevice, 1, &swapInfo.m_imageAvailableFence, VK_TRUE, 0) == VK_SUCCESS)
-					vkResetFences(m_logicalDevice, 1, &swapInfo.m_imageAvailableFence);
-				result = vkAcquireNextImageKHR(m_logicalDevice, swapInfo.swapChain, std::numeric_limits<uint64_t>::max(), acquireInfo.acquireSemaphore, swapInfo.m_imageAvailableFence, &swapInfo.swapchainImageIndex);
-				if (result == VK_SUCCESS)
-					return;
-			}
-			catch (std::exception&) {}
-
-			std::this_thread::yield();
-			std::this_thread::sleep_for(std::chrono::milliseconds(1));
-		}
-
-		throw std::runtime_error(fmt::format("Failed to acquire next image: {}", result));
+		RecreateSwapchain(mainWindow, true);
+		m_destroyPadSwapchainNextAcquire.clear();
+		m_destroyPadSwapchainNextAcquire.notify_all();
+		return false;
 	}
 
-	swapInfo.m_acquireIndex = (swapInfo.m_acquireIndex + 1) % swapInfo.m_acquireInfo.size();
+	auto& chainInfo = GetChainInfo(mainWindow);
 
-	SubmitCommandBuffer(nullptr, &acquireInfo.acquireSemaphore);
+	if (chainInfo.swapchainImageIndex != -1)
+		return true; // image already reserved
+
+	if (!UpdateSwapchainProperties(mainWindow))
+		return false;
+
+	bool result = chainInfo.AcquireImage();
+	if (!result)
+		return false;
+
+	SubmitCommandBuffer(VK_NULL_HANDLE, chainInfo.ConsumeAcquireSemaphore());
+	return true;
 }
 
-void VulkanRenderer::RecreateSwapchain(bool main_window)
+void VulkanRenderer::RecreateSwapchain(bool mainWindow, bool skipCreate)
 {
 	SubmitCommandBuffer();
-	vkDeviceWaitIdle(m_logicalDevice);
-	auto& swapinfo = main_window ? *m_mainSwapchainInfo : *m_padSwapchainInfo;
-	vkWaitForFences(m_logicalDevice, 1, &swapinfo.m_imageAvailableFence, VK_TRUE,
-		std::chrono::duration_cast<std::chrono::nanoseconds>(std::chrono::milliseconds(10)).count()
-	);
+	WaitDeviceIdle();
+	auto& chainInfo = GetChainInfo(mainWindow);
 
 	Vector2i size;
-	if (main_window)
+	if (mainWindow)
 	{
 		ImGui_ImplVulkan_Shutdown();
-		gui_getWindowSize(&size.x, &size.y);
+		gui_getWindowPhysSize(size.x, size.y);
 	}
 	else
 	{
-		gui_getPadWindowSize(&size.x, &size.y);
+		gui_getPadWindowPhysSize(size.x, size.y);
 	}
 
-	if (swapinfo.swapChain != VK_NULL_HANDLE)
+	chainInfo.swapchainImageIndex = -1;
+	chainInfo.Cleanup();
+	chainInfo.m_desiredExtent = size;
+	if(!skipCreate)
 	{
-		// todo - for some reason using the swapchain replacement method (old var being set) causes crashes and other issues
-		vkDestroySwapchainKHR(m_logicalDevice, swapinfo.swapChain, nullptr);
-		swapinfo.m_swapchainImages.clear(); // swapchain images are automatically destroyed
-		swapinfo.swapChain = VK_NULL_HANDLE;
+		chainInfo.Create();
 	}
 
-	swapinfo.swapChain = nullptr;
-	swapinfo.swapChain = CreateSwapChain(swapinfo, size, main_window);
-	swapinfo.swapchainImageIndex = -1;
-
-	if (main_window)
+	if (mainWindow)
 		ImguiInit();
 }
 
-void VulkanRenderer::SwapBuffer(bool main_window)
+bool VulkanRenderer::UpdateSwapchainProperties(bool mainWindow)
 {
-	auto& swapInfo = main_window ? *m_mainSwapchainInfo : *m_padSwapchainInfo;
+	auto& chainInfo = GetChainInfo(mainWindow);
+	bool stateChanged = chainInfo.m_shouldRecreate;
 
-	if (main_window)
-	{
-		const bool resize = m_swapchainState.resizeRequestedMainWindow;
-		m_swapchainState.resizeRequestedMainWindow = false;
+	const auto configValue =  (VSync)GetConfig().vsync.GetValue();
+	if(chainInfo.m_vsyncState != configValue)
+		stateChanged = true;
 
-		if (resize || m_tvBufferUsesSRGB != LatteGPUState.tvBufferUsesSRGB)
-		{
-			try
-			{
-				RecreateSwapchain(main_window);
-				m_tvBufferUsesSRGB = LatteGPUState.tvBufferUsesSRGB;
-			}
-			catch (std::exception&) { cemu_assert_debug(false); }
-			return;
-		}
-	}
+	const bool latteBufferUsesSRGB = mainWindow ? LatteGPUState.tvBufferUsesSRGB : LatteGPUState.drcBufferUsesSRGB;
+	if (chainInfo.m_usesSRGB != latteBufferUsesSRGB)
+		stateChanged = true;
+
+	int width, height;
+	if (mainWindow)
+		gui_getWindowPhysSize(width, height);
 	else
-	{
-		const bool resize = m_swapchainState.resizeRequestedPadWindow;
-		m_swapchainState.resizeRequestedPadWindow = false;
+		gui_getPadWindowPhysSize(width, height);
+	auto extent = chainInfo.getExtent();
+	if (width != extent.width || height != extent.height)
+		stateChanged = true;
 
-		if (resize || m_drvBufferUsesSRGB != LatteGPUState.drcBufferUsesSRGB)
+	if(stateChanged)
+	{
+		try
 		{
-			try
-			{
-				RecreateSwapchain(main_window);
-				m_drvBufferUsesSRGB = LatteGPUState.drcBufferUsesSRGB;
-			}
-			catch (std::exception&) { cemu_assert_debug(false); }
-			return;
+			RecreateSwapchain(mainWindow);
+		}
+		catch (std::exception&)
+		{
+			cemu_assert_debug(false);
+			return false;
 		}
 	}
 
-	auto& swapinfo = main_window ? *m_mainSwapchainInfo : *m_padSwapchainInfo;
-	AcquireNextSwapchainImage(main_window);
+	chainInfo.m_shouldRecreate = false;
+	chainInfo.m_vsyncState = configValue;
+	chainInfo.m_usesSRGB = latteBufferUsesSRGB;
+	return true;
+}
 
-	if ((main_window && m_swapchainState.tvHasDefinedSwapchainImage == false) ||
-		(!main_window && m_swapchainState.drcHasDefinedSwapchainImage == false))
+void VulkanRenderer::SwapBuffer(bool mainWindow)
+{
+	if(!AcquireNextSwapchainImage(mainWindow))
+		return;
+
+	auto& chainInfo = GetChainInfo(mainWindow);
+
+	if (!chainInfo.hasDefinedSwapchainImage)
 	{
 		// set the swapchain image to a defined state
 		VkClearColorValue clearColor{ 0, 0, 0, 0 };
-		ClearColorImageRaw(swapInfo.m_swapchainImages[swapInfo.swapchainImageIndex], 0, 0, clearColor, VK_IMAGE_LAYOUT_UNDEFINED, VK_IMAGE_LAYOUT_PRESENT_SRC_KHR);
+		ClearColorImageRaw(chainInfo.m_swapchainImages[chainInfo.swapchainImageIndex], 0, 0, clearColor, VK_IMAGE_LAYOUT_UNDEFINED, VK_IMAGE_LAYOUT_PRESENT_SRC_KHR);
 	}
 
-	// make sure any writes to the image have finished (is this necessary? End of command buffer implicitly flushes everything?)
-	VkMemoryBarrier memoryBarrier{};
-	memoryBarrier.sType = VK_STRUCTURE_TYPE_MEMORY_BARRIER;
-	memoryBarrier.srcAccessMask = VK_ACCESS_COLOR_ATTACHMENT_WRITE_BIT;
-	memoryBarrier.dstAccessMask = 0;
-	VkPipelineStageFlags srcStage = VK_PIPELINE_STAGE_COLOR_ATTACHMENT_OUTPUT_BIT;
-	VkPipelineStageFlags dstStage = VK_PIPELINE_STAGE_TOP_OF_PIPE_BIT;
-	vkCmdPipelineBarrier(m_state.currentCommandBuffer, srcStage, dstStage, 0, 1, &memoryBarrier, 0, nullptr, 0, nullptr);
+	const size_t currentFrameCmdBufferID = GetCurrentCommandBufferId();
 
-
-	VkSemaphore presentSemaphore = swapInfo.m_swapchainPresentSemaphores[swapInfo.swapchainImageIndex];
-	SubmitCommandBuffer(&presentSemaphore); // submit all command and signal semaphore
+	VkSemaphore presentSemaphore = chainInfo.m_presentSemaphores[chainInfo.swapchainImageIndex];
+	SubmitCommandBuffer(presentSemaphore); // submit all command and signal semaphore
 
 	cemu_assert_debug(m_numSubmittedCmdBuffers > 0);
 
+	// wait for the previous frame to finish rendering
+	WaitCommandBufferFinished(m_commandBufferIDOfPrevFrame);
+	m_commandBufferIDOfPrevFrame = currentFrameCmdBufferID;
+
+	chainInfo.WaitAvailableFence();
+
+	VkPresentIdKHR presentId = {};
 
 	VkPresentInfoKHR presentInfo = {};
 	presentInfo.sType = VK_STRUCTURE_TYPE_PRESENT_INFO_KHR;
 	presentInfo.swapchainCount = 1;
-	presentInfo.pSwapchains = &swapinfo.swapChain;
-	presentInfo.pImageIndices = &swapinfo.swapchainImageIndex;
+	presentInfo.pSwapchains = &chainInfo.m_swapchain;
+	presentInfo.pImageIndices = &chainInfo.swapchainImageIndex;
 	// wait on command buffer semaphore
 	presentInfo.waitSemaphoreCount = 1;
 	presentInfo.pWaitSemaphores = &presentSemaphore;
 
-	VkResult result = vkQueuePresentKHR(m_presentQueue, &presentInfo);
-	if (result != VK_SUCCESS)
+	// if present_wait is available and enabled, add frame markers to present requests
+	// and limit the number of queued present operations
+	if (m_featureControl.deviceExtensions.present_wait && chainInfo.m_maxQueued > 0)
 	{
-		if (result == VK_ERROR_OUT_OF_DATE_KHR || result == VK_SUBOPTIMAL_KHR) // todo: dont loop but handle error state?
+		presentId.sType = VK_STRUCTURE_TYPE_PRESENT_ID_KHR;
+		presentId.swapchainCount = 1;
+		presentId.pPresentIds = &chainInfo.m_presentId;
+
+		presentInfo.pNext = &presentId;
+
+		if(chainInfo.m_queueDepth >= chainInfo.m_maxQueued)
 		{
-			int counter = 0;
-			while (true)
-			{
-				try
-				{
-					RecreateSwapchain(main_window);
-					return;
-				}
-				catch (std::exception&)
-				{
-					// loop until successful
-					counter++;
-					if (counter > 25)
-					{
-						cemuLog_log(LogType::Force, "Failed to recreate swapchain during SwapBuffer");
-						cemuLog_waitForFlush();
-						exit(0);
-					}
-				}
-
-				std::this_thread::yield();
-				std::this_thread::sleep_for(std::chrono::milliseconds(1));
-			}
+			uint64 waitFrameId = chainInfo.m_presentId - chainInfo.m_queueDepth;
+			vkWaitForPresentKHR(m_logicalDevice, chainInfo.m_swapchain, waitFrameId, 40'000'000);
+			chainInfo.m_queueDepth--;
 		}
-
-		cemuLog_log(LogType::Force, fmt::format("vkQueuePresentKHR failed with error {}", result));
-		cemuLog_waitForFlush();
-
-		throw std::runtime_error(fmt::format("Failed to present draw command buffer: {}", result));
 	}
 
-	if (main_window)
-		m_swapchainState.tvHasDefinedSwapchainImage = false;
-	else
-		m_swapchainState.drcHasDefinedSwapchainImage = false;
+	VkResult result = vkQueuePresentKHR(m_presentQueue, &presentInfo);
+	if (result < 0 && result != VK_ERROR_OUT_OF_DATE_KHR)
+	{
+		throw std::runtime_error(fmt::format("Failed to present image: {}", result));
+	}
+	if(result == VK_ERROR_OUT_OF_DATE_KHR || result == VK_SUBOPTIMAL_KHR)
+		chainInfo.m_shouldRecreate = true;
 
-	swapinfo.swapchainImageIndex = -1;
+	if(result >= 0)
+	{
+		chainInfo.m_queueDepth++;
+		chainInfo.m_presentId++;
+	}
+
+	chainInfo.hasDefinedSwapchainImage = false;
+
+	chainInfo.swapchainImageIndex = -1;
 }
 
 void VulkanRenderer::Flush(bool waitIdle)
@@ -3042,6 +2895,8 @@ void VulkanRenderer::NotifyLatteCommandProcessorIdle()
 		SubmitCommandBuffer();
 }
 
+void VulkanBenchmarkPrintResults();
+
 void VulkanRenderer::SwapBuffers(bool swapTV, bool swapDRC)
 {
 	SubmitCommandBuffer();
@@ -3051,6 +2906,9 @@ void VulkanRenderer::SwapBuffers(bool swapTV, bool swapDRC)
 
 	if (swapDRC && IsSwapchainInfoValid(false))
 		SwapBuffer(false);
+
+	if(swapTV)
+		VulkanBenchmarkPrintResults();
 }
 
 void VulkanRenderer::ClearColorbuffer(bool padView)
@@ -3058,63 +2916,63 @@ void VulkanRenderer::ClearColorbuffer(bool padView)
 	if (!IsSwapchainInfoValid(!padView))
 		return;
 
-	auto& swap_info = padView ? *m_padSwapchainInfo : *m_mainSwapchainInfo;
-	if (swap_info.swapchainImageIndex == -1)
+	auto& chainInfo = GetChainInfo(!padView);
+	if (chainInfo.swapchainImageIndex == -1)
 		return;
 
 	VkClearColorValue clearColor{ 0, 0, 0, 0 };
-	ClearColorImageRaw(swap_info.m_swapchainImages[swap_info.swapchainImageIndex], 0, 0, clearColor, VK_IMAGE_LAYOUT_UNDEFINED, VK_IMAGE_LAYOUT_GENERAL);
+	ClearColorImageRaw(chainInfo.m_swapchainImages[chainInfo.swapchainImageIndex], 0, 0, clearColor, VK_IMAGE_LAYOUT_UNDEFINED, VK_IMAGE_LAYOUT_GENERAL);
 }
 
 void VulkanRenderer::ClearColorImageRaw(VkImage image, uint32 sliceIndex, uint32 mipIndex, const VkClearColorValue& color, VkImageLayout inputLayout, VkImageLayout outputLayout)
 {
 	draw_endRenderPass();
 
-	VkImageMemoryBarrier barrier = {};
-	barrier.sType = VK_STRUCTURE_TYPE_IMAGE_MEMORY_BARRIER;
-	barrier.oldLayout = inputLayout;
-	barrier.newLayout = VK_IMAGE_LAYOUT_TRANSFER_DST_OPTIMAL;
-	barrier.srcQueueFamilyIndex = VK_QUEUE_FAMILY_IGNORED;
-	barrier.dstQueueFamilyIndex = VK_QUEUE_FAMILY_IGNORED;
-	barrier.image = image;
-	barrier.subresourceRange.aspectMask = VK_IMAGE_ASPECT_COLOR_BIT;
-	barrier.subresourceRange.baseMipLevel = mipIndex;
-	barrier.subresourceRange.levelCount = 1;
-	barrier.subresourceRange.baseArrayLayer = sliceIndex;
-	barrier.subresourceRange.layerCount = 1;
+	VkImageSubresourceRange subresourceRange{};
+	subresourceRange.aspectMask = VK_IMAGE_ASPECT_COLOR_BIT;
+	subresourceRange.baseMipLevel = mipIndex;
+	subresourceRange.levelCount = 1;
+	subresourceRange.baseArrayLayer = sliceIndex;
+	subresourceRange.layerCount = 1;
 
-	VkPipelineStageFlags srcStages = 0;
-	VkPipelineStageFlags dstStages = 0;
-	barrier.srcAccessMask = 0;
-	barrier.dstAccessMask = 0;
-	barrier_calcStageAndMask<SYNC_OP::ANY_TRANSFER | SYNC_OP::IMAGE_READ | SYNC_OP::IMAGE_WRITE>(srcStages, barrier.srcAccessMask);
-	barrier_calcStageAndMask<SYNC_OP::ANY_TRANSFER>(dstStages, barrier.dstAccessMask);
+	barrier_image<SYNC_OP::ANY_TRANSFER | SYNC_OP::IMAGE_READ | SYNC_OP::IMAGE_WRITE, SYNC_OP::ANY_TRANSFER>(image, subresourceRange, inputLayout, VK_IMAGE_LAYOUT_TRANSFER_DST_OPTIMAL);
 
-	vkCmdPipelineBarrier(m_state.currentCommandBuffer, srcStages, dstStages, 0, 0, nullptr, 0, nullptr, 1, &barrier);
+	vkCmdClearColorImage(m_state.currentCommandBuffer, image, VK_IMAGE_LAYOUT_TRANSFER_DST_OPTIMAL, &color, 1, &subresourceRange);
 
-	VkImageSubresourceRange imageRange{};
-	imageRange.aspectMask = VK_IMAGE_ASPECT_COLOR_BIT;
-	imageRange.baseArrayLayer = sliceIndex;
-	imageRange.layerCount = 1;
-	imageRange.baseMipLevel = mipIndex;
-	imageRange.levelCount = 1;
-
-	vkCmdClearColorImage(m_state.currentCommandBuffer, image, VK_IMAGE_LAYOUT_TRANSFER_DST_OPTIMAL, &color, 1, &imageRange);
-
-	barrier.oldLayout = VK_IMAGE_LAYOUT_TRANSFER_DST_OPTIMAL;
-	barrier.newLayout = outputLayout;
-
-	srcStages = 0;
-	dstStages = 0;
-	barrier.srcAccessMask = 0;
-	barrier.dstAccessMask = 0;
-	barrier_calcStageAndMask<SYNC_OP::ANY_TRANSFER>(srcStages, barrier.srcAccessMask);
-	barrier_calcStageAndMask<SYNC_OP::ANY_TRANSFER | SYNC_OP::IMAGE_READ | SYNC_OP::IMAGE_WRITE>(dstStages, barrier.dstAccessMask);
-	vkCmdPipelineBarrier(m_state.currentCommandBuffer, srcStages, dstStages, 0, 0, nullptr, 0, nullptr, 1, &barrier);
+    barrier_image<ANY_TRANSFER, SYNC_OP::ANY_TRANSFER | SYNC_OP::IMAGE_READ | SYNC_OP::IMAGE_WRITE>(image, subresourceRange, VK_IMAGE_LAYOUT_TRANSFER_DST_OPTIMAL, outputLayout);
 }
 
 void VulkanRenderer::ClearColorImage(LatteTextureVk* vkTexture, uint32 sliceIndex, uint32 mipIndex, const VkClearColorValue& color, VkImageLayout outputLayout)
 {
+	if(vkTexture->isDepth)
+	{
+		cemu_assert_suspicious();
+		return;
+	}
+	if (vkTexture->IsCompressedFormat())
+	{
+		// vkCmdClearColorImage cannot be called on compressed formats
+		// for now we ignore affected clears but still transition the image to the correct layout
+		auto imageObj = vkTexture->GetImageObj();
+		imageObj->flagForCurrentCommandBuffer();
+		VkImageSubresourceLayers subresourceRange{};
+		subresourceRange.aspectMask = VK_IMAGE_ASPECT_COLOR_BIT;
+		subresourceRange.mipLevel = mipIndex;
+		subresourceRange.baseArrayLayer = sliceIndex;
+		subresourceRange.layerCount = 1;
+		barrier_image<ANY_TRANSFER | IMAGE_READ, ANY_TRANSFER | IMAGE_READ | IMAGE_WRITE>(vkTexture, subresourceRange, outputLayout);
+		if(color.float32[0] == 0.0f && color.float32[1] == 0.0f && color.float32[2] == 0.0f && color.float32[3] == 0.0f)
+		{
+			static bool dbgMsgPrinted = false;
+			if(!dbgMsgPrinted)
+			{
+				cemuLog_logDebug(LogType::Force, "Unsupported compressed texture clear to zero");
+				dbgMsgPrinted = true;
+			}
+		}
+		return;
+	}
+
 	VkImageSubresourceRange subresourceRange;
 
 	subresourceRange.aspectMask = VK_IMAGE_ASPECT_COLOR_BIT;
@@ -3131,32 +2989,15 @@ void VulkanRenderer::ClearColorImage(LatteTextureVk* vkTexture, uint32 sliceInde
 	vkTexture->SetImageLayout(subresourceRange, outputLayout);
 }
 
-void VulkanRenderer::CreateBackbufferIndexBuffer()
-{
-	const VkDeviceSize bufferSize = sizeof(uint16) * 6;
-	memoryManager->CreateBuffer(bufferSize, VK_BUFFER_USAGE_INDEX_BUFFER_BIT, VK_MEMORY_PROPERTY_HOST_VISIBLE_BIT, m_indexBuffer, m_indexBufferMemory);
-
-	uint16* data;
-	vkMapMemory(m_logicalDevice, m_indexBufferMemory, 0, bufferSize, 0, (void**)&data);
-	const uint16 tmp[] = { 0, 1, 2, 3, 4, 5 };
-	std::copy(std::begin(tmp), std::end(tmp), data);
-	vkUnmapMemory(m_logicalDevice, m_indexBufferMemory);
-}
-
 void VulkanRenderer::DrawBackbufferQuad(LatteTextureView* texView, RendererOutputShader* shader, bool useLinearTexFilter, sint32 imageX, sint32 imageY, sint32 imageWidth, sint32 imageHeight, bool padView, bool clearBackground)
 {
-	if (!IsSwapchainInfoValid(!padView))
+	if(!AcquireNextSwapchainImage(!padView))
 		return;
 
-	auto& swapInfo = !padView ? *m_mainSwapchainInfo : *m_padSwapchainInfo;
+	auto& chainInfo = GetChainInfo(!padView);
 	LatteTextureViewVk* texViewVk = (LatteTextureViewVk*)texView;
 	draw_endRenderPass();
 
-	if (clearBackground)
-		ClearColorbuffer(padView);
-
-	AcquireNextSwapchainImage(!padView);
-
 	// barrier for input texture
 	VkMemoryBarrier memoryBarrier{};
 	memoryBarrier.sType = VK_STRUCTURE_TYPE_MEMORY_BARRIER;
@@ -3170,10 +3011,10 @@ void VulkanRenderer::DrawBackbufferQuad(LatteTextureView* texView, RendererOutpu
 
 	VkRenderPassBeginInfo renderPassInfo = {};
 	renderPassInfo.sType = VK_STRUCTURE_TYPE_RENDER_PASS_BEGIN_INFO;
-	renderPassInfo.renderPass = swapInfo.m_swapChainRenderPass;
-	renderPassInfo.framebuffer = swapInfo.m_swapchainFramebuffers[swapInfo.swapchainImageIndex];
+	renderPassInfo.renderPass = chainInfo.m_swapchainRenderPass;
+	renderPassInfo.framebuffer = chainInfo.m_swapchainFramebuffers[chainInfo.swapchainImageIndex];
 	renderPassInfo.renderArea.offset = { 0, 0 };
-	renderPassInfo.renderArea.extent = swapInfo.swapchainExtend;
+	renderPassInfo.renderArea.extent = chainInfo.getExtent();
 	renderPassInfo.clearValueCount = 0;
 
 	VkViewport viewport{};
@@ -3186,21 +3027,48 @@ void VulkanRenderer::DrawBackbufferQuad(LatteTextureView* texView, RendererOutpu
 	vkCmdSetViewport(m_state.currentCommandBuffer, 0, 1, &viewport);
 
 	VkRect2D scissor{};
-	scissor.extent = swapInfo.swapchainExtend;
+	scissor.extent = chainInfo.getExtent();
 	vkCmdSetScissor(m_state.currentCommandBuffer, 0, 1, &scissor);
 
 	auto descriptSet = backbufferBlit_createDescriptorSet(m_swapchainDescriptorSetLayout, texViewVk, useLinearTexFilter);
 
 	vkCmdBeginRenderPass(m_state.currentCommandBuffer, &renderPassInfo, VK_SUBPASS_CONTENTS_INLINE);
 
+	if (clearBackground)
+	{
+		VkClearAttachment clearAttachment{};
+		clearAttachment.clearValue = {0,0,0,0};
+		clearAttachment.colorAttachment = 0;
+		clearAttachment.aspectMask = VK_IMAGE_ASPECT_COLOR_BIT;
+		VkClearRect clearExtent = {{{0,0},chainInfo.m_actualExtent}, 0, 1};
+		vkCmdClearAttachments(m_state.currentCommandBuffer, 1, &clearAttachment, 1, &clearExtent);
+	}
+
 	vkCmdBindPipeline(m_state.currentCommandBuffer, VK_PIPELINE_BIND_POINT_GRAPHICS, pipeline);
 	m_state.currentPipeline = pipeline;
 
-	vkCmdBindIndexBuffer(m_state.currentCommandBuffer, m_indexBuffer, 0, VK_INDEX_TYPE_UINT16);
-
 	vkCmdBindDescriptorSets(m_state.currentCommandBuffer, VK_PIPELINE_BIND_POINT_GRAPHICS, m_pipelineLayout, 0, 1, &descriptSet, 0, nullptr);
 
-	vkCmdDrawIndexed(m_state.currentCommandBuffer, 6, 1, 0, 0, 0);
+	// update push constants
+	Vector2f pushData[3];
+
+	// textureSrcResolution
+	sint32 effectiveWidth, effectiveHeight;
+	texView->baseTexture->GetEffectiveSize(effectiveWidth, effectiveHeight, 0);
+	pushData[0] = {(float)effectiveWidth, (float)effectiveHeight};
+
+	// nativeResolution
+	pushData[1] = {
+		(float)texViewVk->baseTexture->width,
+		(float)texViewVk->baseTexture->height,
+	};
+
+	// outputResolution
+	pushData[2] = {(float)imageWidth,(float)imageHeight};
+
+	vkCmdPushConstants(m_state.currentCommandBuffer, m_pipelineLayout, VK_SHADER_STAGE_FRAGMENT_BIT, 0, sizeof(float) * 2 * 3, &pushData);
+
+	vkCmdDraw(m_state.currentCommandBuffer, 6, 1, 0, 0);
 
 	vkCmdEndRenderPass(m_state.currentCommandBuffer);
 
@@ -3208,10 +3076,7 @@ void VulkanRenderer::DrawBackbufferQuad(LatteTextureView* texView, RendererOutpu
 	vkCmdSetViewport(m_state.currentCommandBuffer, 0, 1, &m_state.currentViewport);
 
 	// mark current swapchain image as well defined
-	if (padView)
-		m_swapchainState.drcHasDefinedSwapchainImage = true;
-	else
-		m_swapchainState.tvHasDefinedSwapchainImage = true;
+	chainInfo.hasDefinedSwapchainImage = true;
 }
 
 void VulkanRenderer::CreateDescriptorPool()
@@ -3243,9 +3108,8 @@ VkDescriptorSet VulkanRenderer::backbufferBlit_createDescriptorSet(VkDescriptorS
 	hash += (uint64)texViewVk->GetViewRGBA();
 	hash += (uint64)texViewVk->GetDefaultTextureSampler(useLinearTexFilter);
 
-	static std::unordered_map<uint64, VkDescriptorSet> s_set_cache;
-	const auto it = s_set_cache.find(hash);
-	if (it != s_set_cache.cend())
+	const auto it = m_backbufferBlitDescriptorSetCache.find(hash);
+	if (it != m_backbufferBlitDescriptorSetCache.cend())
 		return it->second;
 
 	VkDescriptorSetAllocateInfo allocInfo = {};
@@ -3276,7 +3140,7 @@ VkDescriptorSet VulkanRenderer::backbufferBlit_createDescriptorSet(VkDescriptorS
 	vkUpdateDescriptorSets(m_logicalDevice, 1, &descriptorWrites, 0, nullptr);
 	performanceMonitor.vk.numDescriptorSamplerTextures.increment();
 
-	s_set_cache[hash] = result;
+	m_backbufferBlitDescriptorSetCache[hash] = result;
 	return result;
 }
 
@@ -3346,48 +3210,7 @@ TextureDecoder* VulkanRenderer::texture_chooseDecodedFormat(Latte::E_GX2SURFFMT
 	return texFormatInfo.decoder;
 }
 
-void VulkanRenderer::texture_reserveTextureOnGPU(LatteTexture* hostTexture)
-{
-	LatteTextureVk* vkTexture = (LatteTextureVk*)hostTexture;
-	auto allocationInfo = memoryManager->imageMemoryAllocate(vkTexture->GetImageObj()->m_image);
-	vkTexture->setAllocation(allocationInfo);
-}
-
-void VulkanRenderer::texture_destroy(LatteTexture* hostTexture)
-{
-	LatteTextureVk* texVk = (LatteTextureVk*)hostTexture;
-	delete texVk;
-}
-
-void VulkanRenderer::destroyViewDepr(VkImageView imageView)
-{
-	cemu_assert_debug(false);
-
-	m_destructionQueues.m_cmd_image_views[m_commandBufferIndex].emplace_back(imageView);
-}
-
-void VulkanRenderer::destroyBuffer(VkBuffer buffer)
-{
-	m_destructionQueues.m_buffers[m_commandBufferIndex].emplace_back(buffer);
-}
-
-void VulkanRenderer::destroyDeviceMemory(VkDeviceMemory mem)
-{
-	m_destructionQueues.m_memory[m_commandBufferIndex].emplace_back(mem);
-}
-
-void VulkanRenderer::destroyPipelineInfo(PipelineInfo* pipelineInfo)
-{
-	cemu_assert_debug(false);
-}
-
-void VulkanRenderer::destroyShader(RendererShaderVk* shader)
-{
-	while (!shader->list_pipelineInfo.empty())
-		delete shader->list_pipelineInfo[0];
-}
-
-void VulkanRenderer::releaseDestructibleObject(VKRDestructibleObject* destructibleObject)
+void VulkanRenderer::ReleaseDestructibleObject(VKRDestructibleObject* destructibleObject)
 {
 	// destroy immediately if possible
 	if (destructibleObject->canDestroy())
@@ -3396,14 +3219,14 @@ void VulkanRenderer::releaseDestructibleObject(VKRDestructibleObject* destructib
 		return;
 	}
 	// otherwise put on queue
-	m_spinlockDestructionQueue.acquire();
+	m_spinlockDestructionQueue.lock();
 	m_destructionQueue.emplace_back(destructibleObject);
-	m_spinlockDestructionQueue.release();
+	m_spinlockDestructionQueue.unlock();
 }
 
-void VulkanRenderer::ProcessDestructionQueue2()
+void VulkanRenderer::ProcessDestructionQueue()
 {
-	m_spinlockDestructionQueue.acquire();
+	m_spinlockDestructionQueue.lock();
 	for (auto it = m_destructionQueue.begin(); it != m_destructionQueue.end();)
 	{
 		if ((*it)->canDestroy())
@@ -3414,7 +3237,7 @@ void VulkanRenderer::ProcessDestructionQueue2()
 		}
 		++it;
 	}
-	m_spinlockDestructionQueue.release();
+	m_spinlockDestructionQueue.unlock();
 }
 
 VkDescriptorSetInfo::~VkDescriptorSetInfo()
@@ -3450,7 +3273,8 @@ VkDescriptorSetInfo::~VkDescriptorSetInfo()
 	performanceMonitor.vk.numDescriptorDynUniformBuffers.decrement(statsNumDynUniformBuffers);
 	performanceMonitor.vk.numDescriptorStorageBuffers.decrement(statsNumStorageBuffers);
 
-	VulkanRenderer::GetInstance()->releaseDestructibleObject(m_vkObjDescriptorSet);
+	auto renderer = VulkanRenderer::GetInstance();
+	renderer->ReleaseDestructibleObject(m_vkObjDescriptorSet);
 	m_vkObjDescriptorSet = nullptr;
 }
 
@@ -3463,32 +3287,18 @@ void VulkanRenderer::texture_clearSlice(LatteTexture* hostTexture, sint32 sliceI
 	else
 	{
 		cemu_assert_debug(vkTexture->dim != Latte::E_DIM::DIM_3D);
-		if (hostTexture->IsCompressedFormat())
-		{
-			auto imageObj = vkTexture->GetImageObj();
-			imageObj->flagForCurrentCommandBuffer();
-
-			forceLogDebug_printf("Compressed texture (%d/%d fmt %04x) unsupported clear", vkTexture->width, vkTexture->height, (uint32)vkTexture->format);
-
-			VkImageSubresourceLayers subresourceRange{};
-			subresourceRange.aspectMask = VK_IMAGE_ASPECT_COLOR_BIT;
-			subresourceRange.mipLevel = mipIndex;
-			subresourceRange.baseArrayLayer = sliceIndex;
-			subresourceRange.layerCount = 1;
-			barrier_image<ANY_TRANSFER | IMAGE_READ, ANY_TRANSFER | IMAGE_READ | IMAGE_WRITE>(vkTexture, subresourceRange, VK_IMAGE_LAYOUT_GENERAL);
-		}
-		else
-		{
-			ClearColorImage(vkTexture, sliceIndex, mipIndex, { 0,0,0,0 }, VK_IMAGE_LAYOUT_GENERAL);
-		}
+		ClearColorImage(vkTexture, sliceIndex, mipIndex, { 0,0,0,0 }, VK_IMAGE_LAYOUT_GENERAL);
 	}
 }
 
 void VulkanRenderer::texture_clearColorSlice(LatteTexture* hostTexture, sint32 sliceIndex, sint32 mipIndex, float r, float g, float b, float a)
 {
 	auto vkTexture = (LatteTextureVk*)hostTexture;
-	cemu_assert_debug(vkTexture->dim != Latte::E_DIM::DIM_3D);
-	ClearColorImage(vkTexture, sliceIndex, mipIndex, { r,g,b,a }, VK_IMAGE_LAYOUT_GENERAL);
+	if(vkTexture->dim == Latte::E_DIM::DIM_3D)
+	{
+		cemu_assert_unimplemented();
+	}
+	ClearColorImage(vkTexture, sliceIndex, mipIndex, {r, g, b, a}, VK_IMAGE_LAYOUT_GENERAL);
 }
 
 void VulkanRenderer::texture_clearDepthSlice(LatteTexture* hostTexture, uint32 sliceIndex, sint32 mipIndex, bool clearDepth, bool clearStencil, float depthValue, uint32 stencilValue)
@@ -3635,18 +3445,13 @@ void VulkanRenderer::texture_loadSlice(LatteTexture* hostTexture, sint32 width,
 	barrier_image<ANY_TRANSFER, ANY_TRANSFER | IMAGE_READ | IMAGE_WRITE>(vkTexture, barrierSubresourceRange, VK_IMAGE_LAYOUT_GENERAL);
 }
 
-LatteTexture* VulkanRenderer::texture_createTextureEx(uint32 textureUnit, Latte::E_DIM dim, MPTR physAddress, MPTR physMipAddress, Latte::E_GX2SURFFMT format, uint32 width, uint32 height, uint32 depth, uint32 pitch, uint32 mipLevels,
+LatteTexture* VulkanRenderer::texture_createTextureEx(Latte::E_DIM dim, MPTR physAddress, MPTR physMipAddress, Latte::E_GX2SURFFMT format, uint32 width, uint32 height, uint32 depth, uint32 pitch, uint32 mipLevels,
 	uint32 swizzle, Latte::E_HWTILEMODE tileMode, bool isDepth)
 {
-	return new LatteTextureVk(this, textureUnit, dim, physAddress, physMipAddress, format, width, height, depth, pitch, mipLevels, swizzle, tileMode, isDepth);
+	return new LatteTextureVk(this, dim, physAddress, physMipAddress, format, width, height, depth, pitch, mipLevels, swizzle, tileMode, isDepth);
 }
 
-void VulkanRenderer::texture_bindAndActivate(LatteTextureView* textureView, uint32 textureUnit)
-{
-	m_state.boundTexture[textureUnit] = static_cast<LatteTextureViewVk*>(textureView);
-}
-
-void VulkanRenderer::texture_bindOnly(LatteTextureView* textureView, uint32 textureUnit)
+void VulkanRenderer::texture_setLatteTexture(LatteTextureView* textureView, uint32 textureUnit)
 {
 	m_state.boundTexture[textureUnit] = static_cast<LatteTextureViewVk*>(textureView);
 }
@@ -3718,7 +3523,7 @@ void VulkanRenderer::texture_copyImageSubData(LatteTexture* src, sint32 srcMip,
 
 		if (mipWidth < 4 || mipHeight < 4)
 		{
-			forceLogDebug_printf("vkCmdCopyImage - blocked copy for unsupported uncompressed->compressed copy with dst smaller than 4x4");
+			cemuLog_logDebug(LogType::Force, "vkCmdCopyImage - blocked copy for unsupported uncompressed->compressed copy with dst smaller than 4x4");
 			return;
 		}
 
@@ -3834,6 +3639,36 @@ void VulkanRenderer::buffer_bindVertexBuffer(uint32 bufferIndex, uint32 offset,
 	vkCmdBindVertexBuffers(m_state.currentCommandBuffer, bufferIndex, 1, &attrBuffer, &attrOffset);
 }
 
+void VulkanRenderer::buffer_bindVertexStrideWorkaroundBuffer(VkBuffer fixedBuffer, uint32 offset, uint32 bufferIndex, uint32 size)
+{
+	cemu_assert_debug(bufferIndex < LATTE_MAX_VERTEX_BUFFERS);
+	m_state.currentVertexBinding[bufferIndex].offset = 0xFFFFFFFF;
+	VkBuffer attrBuffer = fixedBuffer;
+	VkDeviceSize attrOffset = offset;
+	vkCmdBindVertexBuffers(m_state.currentCommandBuffer, bufferIndex, 1, &attrBuffer, &attrOffset);
+}
+
+std::pair<VkBuffer, uint32> VulkanRenderer::buffer_genStrideWorkaroundVertexBuffer(MPTR buffer, uint32 size, uint32 oldStride)
+{
+	cemu_assert_debug(oldStride % 4 != 0);
+
+	std::span<uint8> old_buffer{memory_getPointerFromPhysicalOffset(buffer), size};
+
+	//new stride is the nearest multiple of 4
+	uint32 newStride = oldStride + (4-(oldStride % 4));
+	uint32 newSize = size / oldStride * newStride;
+
+	auto new_buffer_alloc = memoryManager->getMetalStrideWorkaroundAllocator().AllocateBufferMemory(newSize, 128);
+
+	std::span<uint8> new_buffer{new_buffer_alloc.memPtr, new_buffer_alloc.size};
+
+	for(size_t elem = 0; elem < size / oldStride; elem++)
+	{
+		memcpy(&new_buffer[elem * newStride], &old_buffer[elem * oldStride], oldStride);
+	}
+	return {new_buffer_alloc.vkBuffer, new_buffer_alloc.bufferOffset};
+}
+
 void VulkanRenderer::buffer_bindUniformBuffer(LatteConst::ShaderType shaderType, uint32 bufferIndex, uint32 offset, uint32 size)
 {
 	cemu_assert_debug(!m_useHostMemoryForCache);
@@ -3841,13 +3676,13 @@ void VulkanRenderer::buffer_bindUniformBuffer(LatteConst::ShaderType shaderType,
 	switch (shaderType)
 	{
 	case LatteConst::ShaderType::Vertex:
-		dynamicOffsetInfo.shaderUB[VulkanRendererConst::SHADER_STAGE_INDEX_VERTEX].unformBufferOffset[bufferIndex] = offset;
+		dynamicOffsetInfo.shaderUB[VulkanRendererConst::SHADER_STAGE_INDEX_VERTEX].uniformBufferOffset[bufferIndex] = offset;
 		break;
 	case LatteConst::ShaderType::Geometry:
-		dynamicOffsetInfo.shaderUB[VulkanRendererConst::SHADER_STAGE_INDEX_GEOMETRY].unformBufferOffset[bufferIndex] = offset;
+		dynamicOffsetInfo.shaderUB[VulkanRendererConst::SHADER_STAGE_INDEX_GEOMETRY].uniformBufferOffset[bufferIndex] = offset;
 		break;
 	case LatteConst::ShaderType::Pixel:
-		dynamicOffsetInfo.shaderUB[VulkanRendererConst::SHADER_STAGE_INDEX_FRAGMENT].unformBufferOffset[bufferIndex] = offset;
+		dynamicOffsetInfo.shaderUB[VulkanRendererConst::SHADER_STAGE_INDEX_FRAGMENT].uniformBufferOffset[bufferIndex] = offset;
 		break;
 	default:
 		cemu_assert_debug(false);
@@ -3866,7 +3701,7 @@ void VulkanRenderer::bufferCache_init(const sint32 bufferSize)
 		m_useHostMemoryForCache = memoryManager->CreateBufferFromHostMemory(memory_getPointerFromVirtualOffset(m_importedMemBaseAddress), hostAllocationSize, VK_BUFFER_USAGE_VERTEX_BUFFER_BIT | VK_BUFFER_USAGE_UNIFORM_BUFFER_BIT | VK_BUFFER_USAGE_TRANSFER_DST_BIT | VK_BUFFER_USAGE_TRANSFER_SRC_BIT, 0, m_importedMem, m_importedMemMemory);
 		if (!m_useHostMemoryForCache)
 		{
-			cemuLog_force("Unable to import host memory to Vulkan buffer. Use default cache system instead");
+			cemuLog_log(LogType::Force, "Unable to import host memory to Vulkan buffer. Use default cache system instead");
 		}
 	}
 	if(!m_useHostMemoryForCache)
@@ -3949,7 +3784,7 @@ void VulkanRenderer::bufferCache_copyStreamoutToMainBuffer(uint32 srcOffset, uin
 
 void VulkanRenderer::AppendOverlayDebugInfo()
 {
-	ImGui::Text("--- Vulkan info ---");
+	ImGui::Text("--- Vulkan debug info ---");
 	ImGui::Text("GfxPipelines   %u", performanceMonitor.vk.numGraphicPipelines.get());
 	ImGui::Text("DescriptorSets %u", performanceMonitor.vk.numDescriptorSets.get());
 	ImGui::Text("DS ImgSamplers %u", performanceMonitor.vk.numDescriptorSamplerTextures.get());
@@ -3957,16 +3792,17 @@ void VulkanRenderer::AppendOverlayDebugInfo()
 	ImGui::Text("DS StorageBuf  %u", performanceMonitor.vk.numDescriptorStorageBuffers.get());
 	ImGui::Text("Images         %u", performanceMonitor.vk.numImages.get());
 	ImGui::Text("ImageView      %u", performanceMonitor.vk.numImageViews.get());
+	ImGui::Text("ImageSampler   %u", performanceMonitor.vk.numSamplers.get());
 	ImGui::Text("RenderPass     %u", performanceMonitor.vk.numRenderPass.get());
 	ImGui::Text("Framebuffer    %u", performanceMonitor.vk.numFramebuffer.get());
-	m_spinlockDestructionQueue.acquire();
+	m_spinlockDestructionQueue.lock();
 	ImGui::Text("DestructionQ   %u", (unsigned int)m_destructionQueue.size());
-	m_spinlockDestructionQueue.release();
+	m_spinlockDestructionQueue.unlock();
 
 
 	ImGui::Text("BeginRP/f      %u", performanceMonitor.vk.numBeginRenderpassPerFrame.get());
 	ImGui::Text("Barriers/f     %u", performanceMonitor.vk.numDrawBarriersPerFrame.get());
-	ImGui::Text("--- Cache info ---");
+	ImGui::Text("--- Cache debug info ---");
 
 	uint32 bufferCacheHeapSize = 0;
 	uint32 bufferCacheAllocationSize = 0;
@@ -3986,7 +3822,7 @@ void VulkanRenderer::AppendOverlayDebugInfo()
 	ImGui::SameLine(60.0f);
 	ImGui::Text("%06uKB / %06uKB Buffers: %u", ((uint32)(totalSize - freeSize) + 1023) / 1024, ((uint32)totalSize + 1023) / 1024, (uint32)numBuffers);
 
-	memoryManager->getIndexAllocator().GetStats(numBuffers, totalSize, freeSize);
+	memoryManager->GetIndexAllocator().GetStats(numBuffers, totalSize, freeSize);
 	ImGui::Text("Index");
 	ImGui::SameLine(60.0f);
 	ImGui::Text("%06uKB / %06uKB Buffers: %u", ((uint32)(totalSize - freeSize) + 1023) / 1024, ((uint32)totalSize + 1023) / 1024, (uint32)numBuffers);
@@ -4002,7 +3838,7 @@ void VKRDestructibleObject::flagForCurrentCommandBuffer()
 
 bool VKRDestructibleObject::canDestroy()
 {
-	if (refCount > 0)
+	if (m_refCount > 0)
 		return false;
 	return VulkanRenderer::GetInstance()->HasCommandBufferFinished(m_lastCmdBufferId);
 }
@@ -4043,11 +3879,116 @@ VKRObjectTextureView::~VKRObjectTextureView()
 	performanceMonitor.vk.numImageViews.decrement();
 }
 
+static uint64 CalcHashSamplerCreateInfo(const VkSamplerCreateInfo& info)
+{
+	uint64 h = 0xcbf29ce484222325ULL;
+	auto fnvHashCombine = [](uint64_t &h, auto val) {
+		using T = decltype(val);
+		static_assert(sizeof(T) <= 8);
+		uint64_t val64 = 0;
+		std::memcpy(&val64, &val, sizeof(val));
+		h ^= val64;
+		h *= 0x100000001b3ULL;
+	};
+	cemu_assert_debug(info.sType == VK_STRUCTURE_TYPE_SAMPLER_CREATE_INFO);
+	fnvHashCombine(h, info.flags);
+	fnvHashCombine(h, info.magFilter);
+	fnvHashCombine(h, info.minFilter);
+	fnvHashCombine(h, info.mipmapMode);
+	fnvHashCombine(h, info.addressModeU);
+	fnvHashCombine(h, info.addressModeV);
+	fnvHashCombine(h, info.addressModeW);
+	fnvHashCombine(h, info.mipLodBias);
+	fnvHashCombine(h, info.anisotropyEnable);
+	if(info.anisotropyEnable == VK_TRUE)
+		fnvHashCombine(h, info.maxAnisotropy);
+	fnvHashCombine(h, info.compareEnable);
+	if(info.compareEnable == VK_TRUE)
+		fnvHashCombine(h, info.compareOp);
+	fnvHashCombine(h, info.minLod);
+	fnvHashCombine(h, info.maxLod);
+	fnvHashCombine(h, info.borderColor);
+	fnvHashCombine(h, info.unnormalizedCoordinates);
+	// handle custom border color
+	VkBaseOutStructure* ext = (VkBaseOutStructure*)info.pNext;
+	while(ext)
+	{
+		if(ext->sType == VK_STRUCTURE_TYPE_SAMPLER_CUSTOM_BORDER_COLOR_CREATE_INFO_EXT)
+		{
+			auto* extInfo = (VkSamplerCustomBorderColorCreateInfoEXT*)ext;
+			fnvHashCombine(h, extInfo->customBorderColor.uint32[0]);
+			fnvHashCombine(h, extInfo->customBorderColor.uint32[1]);
+			fnvHashCombine(h, extInfo->customBorderColor.uint32[2]);
+			fnvHashCombine(h, extInfo->customBorderColor.uint32[3]);
+		}
+		else
+		{
+			cemu_assert_unimplemented();
+		}
+		ext = ext->pNext;
+	}
+	return h;
+}
+
+std::unordered_map<uint64, VKRObjectSampler*> VKRObjectSampler::s_samplerCache;
+
+VKRObjectSampler::VKRObjectSampler(VkSamplerCreateInfo* samplerInfo)
+{
+	auto* vulkanRenderer = VulkanRenderer::GetInstance();
+	if (vkCreateSampler(vulkanRenderer->GetLogicalDevice(), samplerInfo, nullptr, &m_sampler) != VK_SUCCESS)
+		vulkanRenderer->UnrecoverableError("Failed to create texture sampler");
+	performanceMonitor.vk.numSamplers.increment();
+	m_hash = CalcHashSamplerCreateInfo(*samplerInfo);
+}
+
+VKRObjectSampler::~VKRObjectSampler()
+{
+	vkDestroySampler(VulkanRenderer::GetInstance()->GetLogicalDevice(), m_sampler, nullptr);
+	performanceMonitor.vk.numSamplers.decrement();
+	// remove from cache
+	auto it = s_samplerCache.find(m_hash);
+	if(it != s_samplerCache.end())
+		s_samplerCache.erase(it);
+}
+
+void VKRObjectSampler::RefCountReachedZero()
+{
+	VulkanRenderer::GetInstance()->ReleaseDestructibleObject(this);
+}
+
+VKRObjectSampler* VKRObjectSampler::GetOrCreateSampler(VkSamplerCreateInfo* samplerInfo)
+{
+	auto* vulkanRenderer = VulkanRenderer::GetInstance();
+	uint64 hash = CalcHashSamplerCreateInfo(*samplerInfo);
+	auto it = s_samplerCache.find(hash);
+	if (it != s_samplerCache.end())
+	{
+		auto* sampler = it->second;
+		return sampler;
+	}
+	auto* sampler = new VKRObjectSampler(samplerInfo);
+	s_samplerCache[hash] = sampler;
+	return sampler;
+}
+
+void VKRObjectSampler::DestroyCache()
+{
+	// assuming all other objects which depend on vkSampler are destroyed, this cache should also have been emptied already
+	// but just to be sure lets still clear the cache
+	cemu_assert_debug(s_samplerCache.empty());
+	for(auto& sampler : s_samplerCache)
+	{
+		cemu_assert_debug(sampler.second->m_refCount == 0);
+		delete sampler.second;
+	}
+	s_samplerCache.clear();
+}
+
 VKRObjectRenderPass::VKRObjectRenderPass(AttachmentInfo_t& attachmentInfo, sint32 colorAttachmentCount)
 {
 	// generate helper hash for pipeline state
 	uint64 stateHash = 0;
-	for (int i = 0; i < 8; ++i)
+	for (int i = 0; i < Latte::GPU_LIMITS::NUM_COLOR_ATTACHMENTS; ++i)
 	{
 		if (attachmentInfo.colorAttachment[i].isPresent || attachmentInfo.colorAttachment[i].viewObj)
 		{
@@ -4064,7 +4005,7 @@ VKRObjectRenderPass::VKRObjectRenderPass(AttachmentInfo_t& attachmentInfo, sint3
 
 	// setup Vulkan renderpass
 	std::vector<VkAttachmentDescription> attachments_descriptions;
-	std::array<VkAttachmentReference, 8> color_attachments_references{};
+	std::array<VkAttachmentReference, Latte::GPU_LIMITS::NUM_COLOR_ATTACHMENTS> color_attachments_references{};
 	cemu_assert(colorAttachmentCount <= color_attachments_references.size());
 	sint32 numColorAttachments = 0;
 	for (int i = 0; i < 8; ++i)
@@ -4072,8 +4013,10 @@ VKRObjectRenderPass::VKRObjectRenderPass(AttachmentInfo_t& attachmentInfo, sint3
 		if (attachmentInfo.colorAttachment[i].viewObj == nullptr && attachmentInfo.colorAttachment[i].isPresent == false)
 		{
 			color_attachments_references[i].attachment = VK_ATTACHMENT_UNUSED;
+			m_colorAttachmentFormat[i] = VK_FORMAT_UNDEFINED;
 			continue;
 		}
+		m_colorAttachmentFormat[i] = attachmentInfo.colorAttachment[i].format;
 
 		color_attachments_references[i].attachment = (uint32)attachments_descriptions.size();
 		color_attachments_references[i].layout = VK_IMAGE_LAYOUT_GENERAL;
@@ -4097,12 +4040,14 @@ VKRObjectRenderPass::VKRObjectRenderPass(AttachmentInfo_t& attachmentInfo, sint3
 	if (attachmentInfo.depthAttachment.viewObj == nullptr && attachmentInfo.depthAttachment.isPresent == false)
 	{
 		depth_stencil_attachments_references.attachment = VK_ATTACHMENT_UNUSED;
+		m_depthAttachmentFormat = VK_FORMAT_UNDEFINED;
 	}
 	else
 	{
 		hasDepthStencilAttachment = true;
 		depth_stencil_attachments_references.attachment = (uint32)attachments_descriptions.size();
 		depth_stencil_attachments_references.layout = VK_IMAGE_LAYOUT_GENERAL;
+		m_depthAttachmentFormat = attachmentInfo.depthAttachment.format;
 
 		VkAttachmentDescription entry{};
 		entry.format = attachmentInfo.depthAttachment.format;
@@ -4148,7 +4093,7 @@ VKRObjectRenderPass::VKRObjectRenderPass(AttachmentInfo_t& attachmentInfo, sint3
 
 	if (vkCreateRenderPass(VulkanRenderer::GetInstance()->GetLogicalDevice(), &renderPassInfo, nullptr, &m_renderPass) != VK_SUCCESS)
 	{
-		forceLog_printf("Vulkan-Error: Failed to create render pass");
+		cemuLog_log(LogType::Force, "Vulkan-Error: Failed to create render pass");
 		throw std::runtime_error("failed to create render pass!");
 	}
 
@@ -4206,33 +4151,36 @@ VKRObjectFramebuffer::~VKRObjectFramebuffer()
 
 VKRObjectPipeline::VKRObjectPipeline()
 {
-	// todo
 }
 
-void VKRObjectPipeline::setPipeline(VkPipeline newPipeline)
+void VKRObjectPipeline::SetPipeline(VkPipeline newPipeline)
 {
-	cemu_assert_debug(pipeline == VK_NULL_HANDLE);
-	pipeline = newPipeline;
-	if(newPipeline != VK_NULL_HANDLE)
+	if (m_pipeline == newPipeline)
+		return;
+	cemu_assert_debug(m_pipeline == VK_NULL_HANDLE); // replacing an already assigned pipeline is not intended
+	if(m_pipeline == VK_NULL_HANDLE && newPipeline != VK_NULL_HANDLE)
 		performanceMonitor.vk.numGraphicPipelines.increment();
+	else if(m_pipeline != VK_NULL_HANDLE && newPipeline == VK_NULL_HANDLE)
+		performanceMonitor.vk.numGraphicPipelines.decrement();
+	m_pipeline = newPipeline;
 }
 
 VKRObjectPipeline::~VKRObjectPipeline()
 {
 	auto vkr = VulkanRenderer::GetInstance();
-	if (pipeline != VK_NULL_HANDLE)
+	if (m_pipeline != VK_NULL_HANDLE)
 	{
-		vkDestroyPipeline(vkr->GetLogicalDevice(), pipeline, nullptr);
+		vkDestroyPipeline(vkr->GetLogicalDevice(), m_pipeline, nullptr);
 		performanceMonitor.vk.numGraphicPipelines.decrement();
 	}
-	if (vertexDSL != VK_NULL_HANDLE)
-		vkDestroyDescriptorSetLayout(vkr->GetLogicalDevice(), vertexDSL, nullptr);
-	if (pixelDSL != VK_NULL_HANDLE)
-		vkDestroyDescriptorSetLayout(vkr->GetLogicalDevice(), pixelDSL, nullptr);
-	if (geometryDSL != VK_NULL_HANDLE)
-		vkDestroyDescriptorSetLayout(vkr->GetLogicalDevice(), geometryDSL, nullptr);
-	if (pipeline_layout != VK_NULL_HANDLE)
-		vkDestroyPipelineLayout(vkr->GetLogicalDevice(), pipeline_layout, nullptr);
+	if (m_vertexDSL != VK_NULL_HANDLE)
+		vkDestroyDescriptorSetLayout(vkr->GetLogicalDevice(), m_vertexDSL, nullptr);
+	if (m_pixelDSL != VK_NULL_HANDLE)
+		vkDestroyDescriptorSetLayout(vkr->GetLogicalDevice(), m_pixelDSL, nullptr);
+	if (m_geometryDSL != VK_NULL_HANDLE)
+		vkDestroyDescriptorSetLayout(vkr->GetLogicalDevice(), m_geometryDSL, nullptr);
+	if (m_pipelineLayout != VK_NULL_HANDLE)
+		vkDestroyPipelineLayout(vkr->GetLogicalDevice(), m_pipelineLayout, nullptr);
 }
 
 VKRObjectDescriptorSet::VKRObjectDescriptorSet()
diff --git a/src/Cafe/HW/Latte/Renderer/Vulkan/VulkanRenderer.h b/src/Cafe/HW/Latte/Renderer/Vulkan/VulkanRenderer.h
index 6b6abf7a..5cc0a6f1 100644
--- a/src/Cafe/HW/Latte/Renderer/Vulkan/VulkanRenderer.h
+++ b/src/Cafe/HW/Latte/Renderer/Vulkan/VulkanRenderer.h
@@ -1,4 +1,5 @@
 #pragma once
+
 #include "Cafe/HW/Latte/Renderer/Renderer.h"
 #include "Cafe/HW/Latte/Renderer/Vulkan/VulkanAPI.h"
 #include "Cafe/HW/Latte/Renderer/Vulkan/RendererShaderVk.h"
@@ -6,6 +7,7 @@
 #include "Cafe/HW/Latte/Renderer/Vulkan/LatteTextureViewVk.h"
 #include "Cafe/HW/Latte/Renderer/Vulkan/CachedFBOVk.h"
 #include "Cafe/HW/Latte/Renderer/Vulkan/VKRMemoryManager.h"
+#include "Cafe/HW/Latte/Renderer/Vulkan/SwapchainInfoVk.h"
 #include "util/math/vector2.h"
 #include "util/helpers/Semaphore.h"
 #include "util/containers/flat_hash_map.hpp"
@@ -15,6 +17,9 @@ struct VkSupportedFormatInfo_t
 {
 	bool fmt_d24_unorm_s8_uint{};
 	bool fmt_r4g4_unorm_pack{};
+	bool fmt_r5g6b5_unorm_pack{};
+	bool fmt_r4g4b4a4_unorm_pack{};
+	bool fmt_a1r5g5b5_unorm_pack{};
 };
 
 struct VkDescriptorSetInfo
@@ -121,26 +126,19 @@ class VulkanRenderer : public Renderer
 	friend class LatteTextureReadbackInfoVk;
 	friend class PipelineCompiler;
 
+	using VSync = SwapchainInfoVk::VSync;
+
 	static const inline int UNIFORMVAR_RINGBUFFER_SIZE = 1024 * 1024 * 16; // 16MB
-	static const inline int INDEX_STREAM_BUFFER_SIZE = 16 * 1024 * 1024; // 16 MB
 
 	static const inline int TEXTURE_READBACK_SIZE = 32 * 1024 * 1024; // 32 MB
 
 	static const inline int OCCLUSION_QUERY_POOL_SIZE = 1024;
 
 public:
-	enum class VSync
-	{
-		// values here must match GeneralSettings2::m_vsync
-		Immediate = 0,
-		FIFO = 1,
-		MAILBOX = 2,
-		SYNC_AND_LIMIT = 3, // synchronize emulated vsync events to monitor vsync. But skip events if rate higher than virtual vsync period
-	};
-	
+
 	// memory management
-	VKRMemoryManager* memoryManager{};
-	VKRMemoryManager* GetMemoryManager() const { return memoryManager; };
+	std::unique_ptr<VKRMemoryManager> memoryManager;
+	VKRMemoryManager* GetMemoryManager() const { return memoryManager.get(); };
 
 	VkSupportedFormatInfo_t m_supportedFormatInfo;
 
@@ -182,24 +180,28 @@ public:
 
 	void GetDeviceFeatures();
 	void DetermineVendor();
-	void Initialize(const Vector2i& size, bool isMainWindow);
+	void InitializeSurface(const Vector2i& size, bool mainWindow);
 
+	const std::unique_ptr<SwapchainInfoVk>& GetChainInfoPtr(bool mainWindow) const;
+	SwapchainInfoVk& GetChainInfo(bool mainWindow) const;
+
+	void StopUsingPadAndWait();
 	bool IsPadWindowActive() override;
 
 	void HandleScreenshotRequest(LatteTextureView* texView, bool padView) override;
-	void ResizeSwapchain(const Vector2i& size, bool isMainWindow);
 
 	void QueryMemoryInfo();
 	void QueryAvailableFormats();
 
-	void EnableVSync(int state) override;
-
 #if BOOST_OS_WINDOWS
 	static VkSurfaceKHR CreateWinSurface(VkInstance instance, HWND hwindow);
 #endif
 #if BOOST_OS_LINUX
 	static VkSurfaceKHR CreateXlibSurface(VkInstance instance, Display* dpy, Window window);
     static VkSurfaceKHR CreateXcbSurface(VkInstance instance, xcb_connection_t* connection, xcb_window_t window);
+	#ifdef HAS_WAYLAND
+	static VkSurfaceKHR CreateWaylandSurface(VkInstance instance, wl_display* display, wl_surface* surface);
+	#endif
 #endif
 
 	static VkSurfaceKHR CreateFramebufferSurface(VkInstance instance, struct WindowHandleInfo& windowInfo);
@@ -209,7 +211,7 @@ public:
 	void ImguiInit();
 	VkInstance GetVkInstance() const { return m_instance; }
 	VkDevice GetLogicalDevice() const { return m_logicalDevice; }
-	VkPhysicalDevice GetPhysicalDevice() const { return m_physical_device; }
+	VkPhysicalDevice GetPhysicalDevice() const { return m_physicalDevice; }
 
 	VkDescriptorPool GetDescriptorPool() const { return m_descriptorPool; }
 
@@ -226,13 +228,11 @@ public:
 	uint64 GenUniqueId(); // return unique id (uses incrementing counter)
 
 	void DrawEmptyFrame(bool mainWindow) override;
-	void PreparePresentationFrame(bool mainWindow);
 
-	void ProcessDestructionQueues(size_t commandBufferIndex);
 	void InitFirstCommandBuffer();
 	void ProcessFinishedCommandBuffers();
 	void WaitForNextFinishedCommandBuffer();
-	void SubmitCommandBuffer(VkSemaphore* signalSemaphore = nullptr, VkSemaphore* waitSemaphore = nullptr);
+	void SubmitCommandBuffer(VkSemaphore signalSemaphore = VK_NULL_HANDLE, VkSemaphore waitSemaphore = VK_NULL_HANDLE);
 	void RequestSubmitSoon();
 	void RequestSubmitOnIdle();
 
@@ -241,15 +241,9 @@ public:
 	bool HasCommandBufferFinished(uint64 commandBufferId) const;
 	void WaitCommandBufferFinished(uint64 commandBufferId);
 
-	// clean up (deprecated)
-	void destroyViewDepr(VkImageView imageView);
-	void destroyBuffer(VkBuffer buffer);
-	void destroyDeviceMemory(VkDeviceMemory mem);
-	void destroyPipelineInfo(PipelineInfo* pipelineInfo);
-	void destroyShader(RendererShaderVk* shader);
-	// clean up (new)
-	void releaseDestructibleObject(VKRDestructibleObject* destructibleObject);
-	void ProcessDestructionQueue2();
+	// resource destruction queue
+	void ReleaseDestructibleObject(VKRDestructibleObject* destructibleObject);
+	void ProcessDestructionQueue();
 
 	FSpinlock m_spinlockDestructionQueue;
 	std::vector<VKRDestructibleObject*> m_destructionQueue;
@@ -287,24 +281,16 @@ public:
 
 	TextureDecoder* texture_chooseDecodedFormat(Latte::E_GX2SURFFMT format, bool isDepth, Latte::E_DIM dim, uint32 width, uint32 height) override;
 
-	void texture_reserveTextureOnGPU(LatteTexture* hostTexture) override;
-	void texture_destroy(LatteTexture* hostTexture) override;
-
 	void texture_clearSlice(LatteTexture* hostTexture, sint32 sliceIndex, sint32 mipIndex) override;
 	void texture_clearColorSlice(LatteTexture* hostTexture, sint32 sliceIndex, sint32 mipIndex, float r, float g, float b, float a) override;
 	void texture_clearDepthSlice(LatteTexture* hostTexture, uint32 sliceIndex, sint32 mipIndex, bool clearDepth, bool clearStencil, float depthValue, uint32 stencilValue) override;
 
 	void texture_loadSlice(LatteTexture* hostTexture, sint32 width, sint32 height, sint32 depth, void* pixelData, sint32 sliceIndex, sint32 mipIndex, uint32 compressedImageSize) override;
 
-	LatteTexture* texture_createTextureEx(uint32 textureUnit, Latte::E_DIM dim, MPTR physAddress, MPTR physMipAddress, Latte::E_GX2SURFFMT format, uint32 width, uint32 height, uint32 depth, uint32 pitch, uint32 mipLevels, uint32 swizzle, Latte::E_HWTILEMODE tileMode, bool isDepth) override;
+	LatteTexture* texture_createTextureEx(Latte::E_DIM dim, MPTR physAddress, MPTR physMipAddress, Latte::E_GX2SURFFMT format, uint32 width, uint32 height, uint32 depth, uint32 pitch, uint32 mipLevels, uint32 swizzle, Latte::E_HWTILEMODE tileMode, bool isDepth) override;
 
-	void texture_bindAndActivate(LatteTextureView* textureView, uint32 textureUnit) override;
-	void texture_bindOnly(LatteTextureView* textureView, uint32 textureUnit) override;
+	void texture_setLatteTexture(LatteTextureView* textureView, uint32 textureUnit) override;
 
-	void texture_bindAndActivateRawTex(LatteTexture* texture, uint32 textureUnit) override {};
-	
-	void texture_rememberBoundTexture(uint32 textureUnit) override {};
-	void texture_restoreBoundTexture(uint32 textureUnit) override {};
 	void texture_copyImageSubData(LatteTexture* src, sint32 srcMip, sint32 effectiveSrcX, sint32 effectiveSrcY, sint32 srcSlice, LatteTexture* dst, sint32 dstMip, sint32 effectiveDstX, sint32 effectiveDstY, sint32 dstSlice, sint32 effectiveCopyWidth, sint32 effectiveCopyHeight, sint32 srcDepth) override;
 	LatteTextureReadbackInfo* texture_createReadback(LatteTextureView* textureView) override;
 
@@ -313,7 +299,6 @@ public:
 	void surfaceCopy_notifyTextureRelease(LatteTextureVk* hostTexture);
 
 	private:
-	void surfaceCopy_viaBuffer(LatteTextureVk* srcTextureVk, sint32 texSrcMip, sint32 texSrcLevel, LatteTextureVk* dstTextureVk, sint32 texDstMip, sint32 texDstLevel, sint32 effectiveCopyWidth, sint32 effectiveCopyHeight);
 	void surfaceCopy_viaDrawcall(LatteTextureVk* srcTextureVk, sint32 texSrcMip, sint32 texSrcSlice, LatteTextureVk* dstTextureVk, sint32 texDstMip, sint32 texDstSlice, sint32 effectiveCopyWidth, sint32 effectiveCopyHeight);
 
 	void surfaceCopy_cleanup();
@@ -330,10 +315,6 @@ private:
 
 	std::unordered_map<uint64, struct CopySurfacePipelineInfo*> m_copySurfacePipelineCache;
 
-	VkBuffer m_surfaceCopyBuffer = VK_NULL_HANDLE;
-	VkDeviceMemory m_surfaceCopyBufferMemory = VK_NULL_HANDLE;
-	size_t m_surfaceCopyBufferSize{};
-
 public:
 	// renderer interface
 	void bufferCache_init(const sint32 bufferSize) override;
@@ -341,14 +322,15 @@ public:
 	void bufferCache_copy(uint32 srcOffset, uint32 dstOffset, uint32 size) override;
 
 	void buffer_bindVertexBuffer(uint32 bufferIndex, uint32 buffer, uint32 size) override;
+	void buffer_bindVertexStrideWorkaroundBuffer(VkBuffer fixedBuffer, uint32 offset, uint32 bufferIndex, uint32 size);
+	std::pair<VkBuffer, uint32> buffer_genStrideWorkaroundVertexBuffer(MPTR buffer, uint32 size, uint32 oldStride);
 	void buffer_bindUniformBuffer(LatteConst::ShaderType shaderType, uint32 bufferIndex, uint32 offset, uint32 size) override;
 
 	RendererShader* shader_create(RendererShader::ShaderType type, uint64 baseHash, uint64 auxHash, const std::string& source, bool isGameShader, bool isGfxPackShader) override;
-	void shader_bind(RendererShader* shader) override;
-	void shader_unbind(RendererShader::ShaderType shaderType) override;
 
-	void* indexData_reserveIndexMemory(uint32 size, uint32& offset, uint32& bufferIndex) override;
-	void indexData_uploadIndexMemory(uint32 offset, uint32 size) override;
+	IndexAllocation indexData_reserveIndexMemory(uint32 size) override;
+	void indexData_releaseIndexMemory(IndexAllocation& allocation) override;
+	void indexData_uploadIndexMemory(IndexAllocation& allocation) override;
 
 	// externally callable
 	void GetTextureFormatInfoVK(Latte::E_GX2SURFFMT format, bool isDepth, Latte::E_DIM dim, sint32 width, sint32 height, FormatInfoVK* formatInfoOut);
@@ -430,85 +412,25 @@ private:
 		bool drawSequenceSkip; // if true, skip draw_execute()
 	}m_state;
 
-	// swapchain - todo move this to m_swapchainState
-	struct SwapChainInfo
-	{
-		SwapChainInfo(VkDevice device, VkSurfaceKHR surface) : m_device(device), surface(surface) {}
-		SwapChainInfo(const SwapChainInfo&) = delete;
-		SwapChainInfo(SwapChainInfo&&) noexcept = default;
-		~SwapChainInfo()
-		{
-			if (m_swapChainRenderPass)
-			{
-				vkDestroyRenderPass(m_device, m_swapChainRenderPass, nullptr);
-				m_swapChainRenderPass = VK_NULL_HANDLE;
-			}
-			if (swapChain)
-			{
-				vkDestroySwapchainKHR(m_device, swapChain, nullptr);
-				swapChain = VK_NULL_HANDLE;
-			}
-			for (auto& imageView : m_swapchainImageViews)
-				vkDestroyImageView(m_device, imageView, nullptr);
-			m_swapchainImageViews.clear();
-			for (auto& framebuffer : m_swapchainFramebuffers)
-				vkDestroyFramebuffer(m_device, framebuffer, nullptr);
-			m_swapchainFramebuffers.clear();
-		}
-
-		VkDevice m_device;
-
-		VkSurfaceKHR surface{};
-		VkSwapchainKHR swapChain{};
-		VkExtent2D swapchainExtend{};
-		uint32 swapchainImageIndex = (uint32)-1;
-		uint32 m_acquireIndex = 0; // increases with every successful vkAcquireNextImageKHR
-
-		struct AcquireInfo
-		{
-			// move fence here?
-			VkSemaphore acquireSemaphore;
-		};
-		std::vector<AcquireInfo> m_acquireInfo; // indexed by acquireIndex
-
-		// swapchain image ringbuffer (indexed by swapchainImageIndex)
-		std::vector<VkImage> m_swapchainImages;
-		std::vector<VkImageView> m_swapchainImageViews;
-		std::vector<VkFramebuffer> m_swapchainFramebuffers;
-		std::vector<VkSemaphore> m_swapchainPresentSemaphores;
-
-		VkFence m_imageAvailableFence = nullptr;
-		VkRenderPass m_swapChainRenderPass = nullptr;
-		VkRenderPass m_imguiRenderPass = nullptr;
-	};
-	std::unique_ptr<SwapChainInfo> m_mainSwapchainInfo{}, m_padSwapchainInfo{};
+	std::unique_ptr<SwapchainInfoVk> m_mainSwapchainInfo{}, m_padSwapchainInfo{};
+	std::atomic_flag m_destroyPadSwapchainNextAcquire{};
 	bool IsSwapchainInfoValid(bool mainWindow) const;
-	VkSwapchainKHR CreateSwapChain(SwapChainInfo& swap_chain_info, const Vector2i& size, bool mainwindow);
 
-	struct
-	{
-		bool resizeRequestedMainWindow{};
-		Vector2i newExtentMainWindow;
-		bool resizeRequestedPadWindow{};
-		Vector2i newExtentPadWindow;
-		bool tvHasDefinedSwapchainImage{}; // indicates if the swapchain image is in a defined state
-		bool drcHasDefinedSwapchainImage{};
-	}m_swapchainState;
+	VkRenderPass m_imguiRenderPass = VK_NULL_HANDLE;
 
 	VkDescriptorPool m_descriptorPool;
-	VkSurfaceFormatKHR m_swapchainFormat;
 
-	bool m_tvBufferUsesSRGB = false;
-	bool m_drvBufferUsesSRGB = false;
-
-	struct QueueFamilyIndices 
+  public:
+	struct QueueFamilyIndices
 	{
 		int32_t graphicsFamily = -1;
 		int32_t presentFamily = -1;
 
 		bool IsComplete() const	{ return graphicsFamily >= 0 && presentFamily >= 0;	}
 	};
-	static QueueFamilyIndices FindQueueFamilies(VkSurfaceKHR surface, const VkPhysicalDevice& device);
+	static QueueFamilyIndices FindQueueFamilies(VkSurfaceKHR surface, VkPhysicalDevice device);
+
+  private:
 
 	struct FeatureControl
 	{
@@ -528,16 +450,24 @@ private:
 			bool external_memory_host = false; // VK_EXT_external_memory_host
 			bool synchronization2 = false; // VK_KHR_synchronization2
 			bool dynamic_rendering = false; // VK_KHR_dynamic_rendering
+			bool shader_float_controls = false; // VK_KHR_shader_float_controls
+			bool present_wait = false; // VK_KHR_present_wait
+			bool depth_clip_enable = false; // VK_EXT_depth_clip_enable
+			bool pipeline_robustness = false; // VK_EXT_pipeline_robustness
 		}deviceExtensions;
 
-		struct  
+		struct
+		{
+			bool shaderRoundingModeRTEFloat32{ false };
+		}shaderFloatControls; // from VK_KHR_shader_float_controls
+
+		struct
 		{
 			bool debug_utils = false; // VK_EXT_DEBUG_UTILS
 		}instanceExtensions;
 
 		struct  
 		{
-			bool useBufferSurfaceCopies; // if GPU has enough VRAM to spare, allow to use a buffer to copy surfaces (instead of drawcalls)
 			bool useTFEmulationViaSSBO = true; // emulate transform feedback via shader writes to a storage buffer
 		}mode;
 
@@ -547,22 +477,15 @@ private:
 			uint32 nonCoherentAtomSize = 256;
 		}limits;
 
-		bool debugMarkersSupported = false; // frame debugger is attached
-		bool disableMultithreadedCompilation = false; // for old nvidia drivers
+		bool debugMarkersSupported{ false }; // frame debugger is attached
+		bool disableMultithreadedCompilation{ false }; // for old nvidia drivers
 
 	}m_featureControl{};
 	static bool CheckDeviceExtensionSupport(const VkPhysicalDevice device, FeatureControl& info);
 	static std::vector<const char*> CheckInstanceExtensionSupport(FeatureControl& info);
 
-	void SwapBuffer(bool main_window);
-	VSync m_vsync_state = VSync::Immediate;
-
-	struct SwapChainSupportDetails 
-	{
-		VkSurfaceCapabilitiesKHR capabilities;
-		std::vector<VkSurfaceFormatKHR> formats;
-		std::vector<VkPresentModeKHR> presentModes;
-	};
+	bool UpdateSwapchainProperties(bool mainWindow);
+	void SwapBuffer(bool mainWindow);
 
 	VkDescriptorSetLayout m_swapchainDescriptorSetLayout;
 
@@ -570,14 +493,9 @@ private:
 
 	// swapchain
 
-	static SwapChainSupportDetails QuerySwapChainSupport(VkSurfaceKHR surface, const VkPhysicalDevice& device);
 	std::vector<VkDeviceQueueCreateInfo> CreateQueueCreateInfos(const std::set<int>& uniqueQueueFamilies) const;
 	VkDeviceCreateInfo CreateDeviceCreateInfo(const std::vector<VkDeviceQueueCreateInfo>& queueCreateInfos, const VkPhysicalDeviceFeatures& deviceFeatures, const void* deviceExtensionStructs, std::vector<const char*>& used_extensions) const;
 	static bool IsDeviceSuitable(VkSurfaceKHR surface, const VkPhysicalDevice& device);
-	VkSurfaceFormatKHR ChooseSwapSurfaceFormat(const std::vector<VkSurfaceFormatKHR>& formats, bool mainWindow) const;
-	VkPresentModeKHR ChooseSwapPresentMode(const std::vector<VkPresentModeKHR>& modes);
-	VkExtent2D ChooseSwapExtent(const VkSurfaceCapabilitiesKHR& capabilities, const Vector2i& size) const;
-	VkSwapchainCreateInfoKHR CreateSwapchainCreateInfo(VkSurfaceKHR surface, const SwapChainSupportDetails& swapChainSupport, const VkSurfaceFormatKHR& surfaceFormat, uint32 imageCount, const VkExtent2D& extent);
 
 	void CreateCommandPool();
 	void CreateCommandBuffers();
@@ -626,21 +544,17 @@ private:
 	void sync_RenderPassStoreTextures(CachedFBOVk* fboVk);
 
 	// command buffer
-
 	VkCommandBuffer getCurrentCommandBuffer() const { return m_state.currentCommandBuffer; }
 
 	// uniform
 	void uniformData_updateUniformVars(uint32 shaderStageIndex, LatteDecompilerShader* shader);
 
-	// indices
-	void CreateBackbufferIndexBuffer();
-
 	// misc
 	void CreatePipelineCache();
 	VkPipelineShaderStageCreateInfo CreatePipelineShaderStageCreateInfo(VkShaderStageFlagBits stage, VkShaderModule& module, const char* entryName) const;
 	VkPipeline backbufferBlit_createGraphicsPipeline(VkDescriptorSetLayout descriptorLayout, bool padView, RendererOutputShader* shader);
-	void AcquireNextSwapchainImage(bool main_window);
-	void RecreateSwapchain(bool mainwindow);
+	bool AcquireNextSwapchainImage(bool mainWindow);
+	void RecreateSwapchain(bool mainWindow, bool skipCreate = false);
 
 	// streamout
 	void streamout_setupXfbBuffer(uint32 bufferIndex, sint32 ringBufferOffset, uint32 rangeAddr, uint32 rangeSize) override;
@@ -658,12 +572,9 @@ private:
 	void occlusionQuery_notifyBeginCommandBuffer();
 
 private:
-	VkBuffer m_indexBuffer = VK_NULL_HANDLE;
-	VkDeviceMemory m_indexBufferMemory = VK_NULL_HANDLE;
-	
 	std::vector<const char*> m_layerNames;
 	VkInstance m_instance = VK_NULL_HANDLE;
-	VkPhysicalDevice m_physical_device = VK_NULL_HANDLE;
+	VkPhysicalDevice m_physicalDevice = VK_NULL_HANDLE;
 	VkDevice  m_logicalDevice = VK_NULL_HANDLE;
 	VkDebugUtilsMessengerEXT m_debugCallback = nullptr;
 	volatile bool m_destructionRequested = false;
@@ -674,6 +585,8 @@ private:
 	std::shared_mutex m_pipeline_cache_save_mutex;
 	std::thread m_pipeline_cache_save_thread;
 	VkPipelineCache m_pipeline_cache{ nullptr };
+	std::unordered_map<uint64, VkPipeline> m_backbufferBlitPipelineCache;
+	std::unordered_map<uint64, VkDescriptorSet> m_backbufferBlitDescriptorSetCache;
 	VkPipelineLayout m_pipelineLayout{nullptr};
 	VkCommandPool m_commandPool{ nullptr };
 	
@@ -683,6 +596,7 @@ private:
 	bool m_uniformVarBufferMemoryIsCoherent{false};
 	uint8* m_uniformVarBufferPtr = nullptr;
 	uint32 m_uniformVarBufferWriteIndex = 0;
+	uint32 m_uniformVarBufferReadIndex = 0;
 
 	// transform feedback ringbuffer
 	VkBuffer m_xfbRingBuffer = VK_NULL_HANDLE;
@@ -726,17 +640,10 @@ private:
 	// command buffer, garbage collection, synchronization
 	static constexpr uint32 kCommandBufferPoolSize = 128;
 
-	struct
-	{
-		std::array<std::vector<VkDescriptorSet>, kCommandBufferPoolSize> m_cmd_descriptor_set_objects;
-		std::array<std::vector<VkImageView>, kCommandBufferPoolSize> m_cmd_image_views;
-		std::array<std::vector<LatteTextureVk*>, kCommandBufferPoolSize> m_host_textures;
-		std::array<std::vector<VkBuffer>, kCommandBufferPoolSize> m_buffers;
-		std::array<std::vector<VkDeviceMemory>, kCommandBufferPoolSize> m_memory;
-	}m_destructionQueues;
-
 	size_t m_commandBufferIndex = 0; // current buffer being filled
 	size_t m_commandBufferSyncIndex = 0; // latest buffer that finished execution (updated on submit)
+	size_t m_commandBufferIDOfPrevFrame = 0;
+	std::array<size_t, kCommandBufferPoolSize> m_cmdBufferUniformRingbufIndices {}; // index in the uniform ringbuffer
 	std::array<VkFence, kCommandBufferPoolSize> m_cmd_buffer_fences;
 	std::array<VkCommandBuffer, kCommandBufferPoolSize> m_commandBuffers;
 	std::array<VkSemaphore, kCommandBufferPoolSize> m_commandBufferSemaphores;
@@ -759,7 +666,7 @@ private:
 		uint32 uniformVarBufferOffset[VulkanRendererConst::SHADER_STAGE_INDEX_COUNT];
 		struct  
 		{
-			uint32 unformBufferOffset[LATTE_NUM_MAX_UNIFORM_BUFFERS];
+			uint32 uniformBufferOffset[LATTE_NUM_MAX_UNIFORM_BUFFERS];
 		}shaderUB[VulkanRendererConst::SHADER_STAGE_INDEX_COUNT];
 	}dynamicOffsetInfo{};
 
@@ -957,7 +864,7 @@ private:
 		memBarrier.pNext = nullptr;
 
 		VkPipelineStageFlags srcStages = VK_PIPELINE_STAGE_TRANSFER_BIT;
-		VkPipelineStageFlags dstStages = VK_PIPELINE_STAGE_TOP_OF_PIPE_BIT;
+		VkPipelineStageFlags dstStages = VK_PIPELINE_STAGE_ALL_COMMANDS_BIT;
 
 		memBarrier.srcAccessMask = VK_ACCESS_TRANSFER_READ_BIT | VK_ACCESS_TRANSFER_WRITE_BIT;
 		memBarrier.dstAccessMask = 0;
@@ -977,10 +884,8 @@ private:
 	}
 
 	template<uint32 TSrcSyncOp, uint32 TDstSyncOp>
-	void barrier_image(LatteTextureVk* vkTexture, VkImageSubresourceLayers& subresourceLayers, VkImageLayout newLayout)
+	void barrier_image(VkImage imageVk, VkImageSubresourceRange& subresourceRange, VkImageLayout oldLayout, VkImageLayout newLayout)
 	{
-		VkImage imageVk = vkTexture->GetImageObj()->m_image;
-
 		VkPipelineStageFlags srcStages = 0;
 		VkPipelineStageFlags dstStages = 0;
 
@@ -993,32 +898,41 @@ private:
 		barrier_calcStageAndMask<TSrcSyncOp>(srcStages, imageMemBarrier.srcAccessMask);
 		barrier_calcStageAndMask<TDstSyncOp>(dstStages, imageMemBarrier.dstAccessMask);
 		imageMemBarrier.image = imageVk;
-		imageMemBarrier.subresourceRange.aspectMask = subresourceLayers.aspectMask;
-		imageMemBarrier.subresourceRange.baseArrayLayer = subresourceLayers.baseArrayLayer;
-		imageMemBarrier.subresourceRange.layerCount = subresourceLayers.layerCount;
-		imageMemBarrier.subresourceRange.baseMipLevel = subresourceLayers.mipLevel;
-		imageMemBarrier.subresourceRange.levelCount = 1;
-		imageMemBarrier.oldLayout = vkTexture->GetImageLayout(imageMemBarrier.subresourceRange);
+		imageMemBarrier.subresourceRange = subresourceRange;
+		imageMemBarrier.oldLayout = oldLayout;
 		imageMemBarrier.newLayout = newLayout;
 
 		vkCmdPipelineBarrier(m_state.currentCommandBuffer,
-			srcStages, dstStages,
-			0,
-			0, NULL,
-			0, NULL,
-			1, &imageMemBarrier);
+							 srcStages, dstStages,
+							 0,
+							 0, NULL,
+							 0, NULL,
+							 1, &imageMemBarrier);
+	}
 
-		vkTexture->SetImageLayout(imageMemBarrier.subresourceRange, newLayout);
+	template<uint32 TSrcSyncOp, uint32 TDstSyncOp>
+	void barrier_image(LatteTextureVk* vkTexture, VkImageSubresourceLayers& subresourceLayers, VkImageLayout newLayout)
+	{
+		VkImage imageVk = vkTexture->GetImageObj()->m_image;
+
+		VkImageSubresourceRange subresourceRange;
+		subresourceRange.aspectMask = subresourceLayers.aspectMask;
+		subresourceRange.baseArrayLayer = subresourceLayers.baseArrayLayer;
+		subresourceRange.layerCount = subresourceLayers.layerCount;
+		subresourceRange.baseMipLevel = subresourceLayers.mipLevel;
+		subresourceRange.levelCount = 1;
+
+		barrier_image<TSrcSyncOp, TDstSyncOp>(imageVk, subresourceRange, vkTexture->GetImageLayout(subresourceRange), newLayout);
+
+		vkTexture->SetImageLayout(subresourceRange, newLayout);
 	}
 
 
 public:
-	bool GetDisableMultithreadedCompilation() { return m_featureControl.disableMultithreadedCompilation; }
-	bool useTFViaSSBO() { return m_featureControl.mode.useTFEmulationViaSSBO; }
-	bool IsDebugUtilsEnabled() const
-	{
-		return m_featureControl.debugMarkersSupported && m_featureControl.instanceExtensions.debug_utils;
-	}
+	bool GetDisableMultithreadedCompilation() const { return m_featureControl.disableMultithreadedCompilation; }
+	bool UseTFViaSSBO() const { return m_featureControl.mode.useTFEmulationViaSSBO; }
+	bool HasSPRIVRoundingModeRTE32() const { return m_featureControl.shaderFloatControls.shaderRoundingModeRTEFloat32; }
+	bool IsDebugUtilsEnabled() const { return m_featureControl.debugMarkersSupported && m_featureControl.instanceExtensions.debug_utils; }
 
 private:
 
diff --git a/src/Cafe/HW/Latte/Renderer/Vulkan/VulkanRendererCore.cpp b/src/Cafe/HW/Latte/Renderer/Vulkan/VulkanRendererCore.cpp
index 2417f797..32ef7007 100644
--- a/src/Cafe/HW/Latte/Renderer/Vulkan/VulkanRendererCore.cpp
+++ b/src/Cafe/HW/Latte/Renderer/Vulkan/VulkanRendererCore.cpp
@@ -55,7 +55,7 @@ uint64 VulkanRenderer::draw_calculateGraphicsPipelineHash(const LatteFetchShader
 	// An alternative would be to use VK_EXT_vertex_input_dynamic_state but it comes with minor overhead
 	// Regardless, the extension is not well supported as of writing this (July 2021, only 10% of GPUs support it on Windows. Nvidia only)
 
-	cemu_assert_debug(fetchShader->key == fetchShader->key); // fetch shaders must be layout compatible, but may have different offsets
+	cemu_assert_debug(vertexShader->compatibleFetchShader->key == fetchShader->key); // fetch shaders must be layout compatible, but may have different offsets
 
 	uint64 stateHash;
 	stateHash = draw_calculateMinimalGraphicsPipelineHash(fetchShader, lcr);
@@ -190,6 +190,7 @@ std::queue<PipelineCompiler*> g_compilePipelineRequests;
 
 void compilePipeline_thread(sint32 threadIndex)
 {
+	SetThreadName("compilePl");
 #ifdef _WIN32
 	// one thread runs at normal priority while the others run at lower priority
 	if(threadIndex != 0)
@@ -297,7 +298,8 @@ PipelineInfo* VulkanRenderer::draw_createGraphicsPipeline(uint32 indexCount)
 	// init pipeline compiler
 	PipelineCompiler* pipelineCompiler = new PipelineCompiler();
 
-	pipelineCompiler->InitFromCurrentGPUState(pipelineInfo, LatteGPUState.contextNew, vkFBO->GetRenderPassObj());
+	bool requiresRobustBufferAccess = PipelineCompiler::CalcRobustBufferAccessRequirement(vertexShader, pixelShader, geometryShader);
+	pipelineCompiler->InitFromCurrentGPUState(pipelineInfo, LatteGPUState.contextNew, vkFBO->GetRenderPassObj(), requiresRobustBufferAccess);
 	pipelineCompiler->TrackAsCached(vsBaseHash, pipelineHash);
 
 	// use heuristics based on parameter patterns to determine if the current drawcall is essential (non-skipable)
@@ -334,7 +336,7 @@ PipelineInfo* VulkanRenderer::draw_getOrCreateGraphicsPipeline(uint32 indexCount
 	if (cache_object != nullptr)
 	{
 
-#ifndef PUBLIC_RELEASE
+#ifdef CEMU_DEBUG_ASSERT
 		cemu_assert_debug(cache_object->vertexShader == LatteSHRC_GetActiveVertexShader());
 		cemu_assert_debug(cache_object->geometryShader == LatteSHRC_GetActiveGeometryShader());
 		cemu_assert_debug(cache_object->pixelShader == LatteSHRC_GetActivePixelShader());
@@ -356,61 +358,59 @@ PipelineInfo* VulkanRenderer::draw_getOrCreateGraphicsPipeline(uint32 indexCount
 	return draw_createGraphicsPipeline(indexCount);
 }
 
-void* VulkanRenderer::indexData_reserveIndexMemory(uint32 size, uint32& offset, uint32& bufferIndex)
+Renderer::IndexAllocation VulkanRenderer::indexData_reserveIndexMemory(uint32 size)
 {
-	auto& indexAllocator = this->memoryManager->getIndexAllocator();
-	auto resv = indexAllocator.AllocateBufferMemory(size, 32);
-	offset = resv.bufferOffset;
-	bufferIndex = resv.bufferIndex;
-	return resv.memPtr;
+	VKRSynchronizedHeapAllocator::AllocatorReservation* resv = memoryManager->GetIndexAllocator().AllocateBufferMemory(size, 32);
+	return { resv->memPtr, resv };
 }
 
-void VulkanRenderer::indexData_uploadIndexMemory(uint32 offset, uint32 size)
+void VulkanRenderer::indexData_releaseIndexMemory(IndexAllocation& allocation)
 {
-	// does nothing since the index buffer memory is coherent
+	memoryManager->GetIndexAllocator().FreeReservation((VKRSynchronizedHeapAllocator::AllocatorReservation*)allocation.rendererInternal);
 }
 
+void VulkanRenderer::indexData_uploadIndexMemory(IndexAllocation& allocation)
+{
+	memoryManager->GetIndexAllocator().FlushReservation((VKRSynchronizedHeapAllocator::AllocatorReservation*)allocation.rendererInternal);
+}
+
+float s_vkUniformData[512 * 4];
+
 void VulkanRenderer::uniformData_updateUniformVars(uint32 shaderStageIndex, LatteDecompilerShader* shader)
 {
+	auto GET_UNIFORM_DATA_PTR = [](size_t index) { return s_vkUniformData + (index / 4); };
+
 	sint32 shaderAluConst;
-	sint32 shaderUniformRegisterOffset;
 
 	switch (shader->shaderType)
 	{
 	case LatteConst::ShaderType::Vertex:
 		shaderAluConst = 0x400;
-		shaderUniformRegisterOffset = mmSQ_VTX_UNIFORM_BLOCK_START;
 		break;
 	case LatteConst::ShaderType::Pixel:
 		shaderAluConst = 0;
-		shaderUniformRegisterOffset = mmSQ_PS_UNIFORM_BLOCK_START;
 		break;
 	case LatteConst::ShaderType::Geometry:
 		shaderAluConst = 0; // geometry shader has no ALU const
-		shaderUniformRegisterOffset = mmSQ_GS_UNIFORM_BLOCK_START;
 		break;
 	default:
-		cemu_assert_debug(false);
+		UNREACHABLE;
 	}
 
 	if (shader->resourceMapping.uniformVarsBufferBindingPoint >= 0)
 	{
-		float uniformData[512 * 4];
-
 		if (shader->uniform.list_ufTexRescale.empty() == false)
 		{
 			for (auto& entry : shader->uniform.list_ufTexRescale)
 			{
 				float* xyScale = LatteTexture_getEffectiveTextureScale(shader->shaderType, entry.texUnit);
-				float* v = uniformData + (entry.uniformLocation / 4);
 				memcpy(entry.currentValue, xyScale, sizeof(float) * 2);
-				memcpy(v, xyScale, sizeof(float) * 2);
+				memcpy(GET_UNIFORM_DATA_PTR(entry.uniformLocation), xyScale, sizeof(float) * 2);
 			}
 		}
 		if (shader->uniform.loc_alphaTestRef >= 0)
 		{
-			float* v = uniformData + (shader->uniform.loc_alphaTestRef / 4);
-			v[0] = LatteGPUState.contextNew.SX_ALPHA_REF.get_ALPHA_TEST_REF();
+			*GET_UNIFORM_DATA_PTR(shader->uniform.loc_alphaTestRef) = LatteGPUState.contextNew.SX_ALPHA_REF.get_ALPHA_TEST_REF();
 		}
 		if (shader->uniform.loc_pointSize >= 0)
 		{
@@ -418,65 +418,99 @@ void VulkanRenderer::uniformData_updateUniformVars(uint32 shaderStageIndex, Latt
 			float pointWidth = (float)pointSizeReg.get_WIDTH() / 8.0f;
 			if (pointWidth == 0.0f)
 				pointWidth = 1.0f / 8.0f; // minimum size
-			float* v = uniformData + (shader->uniform.loc_pointSize / 4);
-			v[0] = pointWidth;
+			*GET_UNIFORM_DATA_PTR(shader->uniform.loc_pointSize) = pointWidth;
 		}
 		if (shader->uniform.loc_remapped >= 0)
 		{
-			LatteBufferCache_LoadRemappedUniforms(shader, uniformData + (shader->uniform.loc_remapped / 4));
+			LatteBufferCache_LoadRemappedUniforms(shader, GET_UNIFORM_DATA_PTR(shader->uniform.loc_remapped));
 		}
 		if (shader->uniform.loc_uniformRegister >= 0)
 		{
 			uint32* uniformRegData = (uint32*)(LatteGPUState.contextRegister + mmSQ_ALU_CONSTANT0_0 + shaderAluConst);
-			float* v = uniformData + (shader->uniform.loc_uniformRegister / 4);
-			memcpy(v, uniformRegData, shader->uniform.count_uniformRegister * 16);
+			memcpy(GET_UNIFORM_DATA_PTR(shader->uniform.loc_uniformRegister), uniformRegData, shader->uniform.count_uniformRegister * 16);
 		}
 		if (shader->uniform.loc_windowSpaceToClipSpaceTransform >= 0)
 		{
 			sint32 viewportWidth;
 			sint32 viewportHeight;
 			LatteRenderTarget_GetCurrentVirtualViewportSize(&viewportWidth, &viewportHeight); // always call after _updateViewport()
-			float* v = uniformData + (shader->uniform.loc_windowSpaceToClipSpaceTransform / 4);
+			float* v = GET_UNIFORM_DATA_PTR(shader->uniform.loc_windowSpaceToClipSpaceTransform);
 			v[0] = 2.0f / (float)viewportWidth;
 			v[1] = 2.0f / (float)viewportHeight;
 		}
 		if (shader->uniform.loc_fragCoordScale >= 0)
 		{
-			float* coordScale = uniformData + (shader->uniform.loc_fragCoordScale / 4);
-			LatteMRT::GetCurrentFragCoordScale(coordScale);
+			LatteMRT::GetCurrentFragCoordScale(GET_UNIFORM_DATA_PTR(shader->uniform.loc_fragCoordScale));
 		}
 		if (shader->uniform.loc_verticesPerInstance >= 0)
 		{
-			*(int*)(uniformData + (shader->uniform.loc_verticesPerInstance / 4)) = m_streamoutState.verticesPerInstance;
+			*(int*)GET_UNIFORM_DATA_PTR(shader->uniform.loc_verticesPerInstance) = m_streamoutState.verticesPerInstance;
 			for (sint32 b = 0; b < LATTE_NUM_STREAMOUT_BUFFER; b++)
 			{
 				if (shader->uniform.loc_streamoutBufferBase[b] >= 0)
 				{
-					*(int*)(uniformData + (shader->uniform.loc_streamoutBufferBase[b] / 4)) = m_streamoutState.buffer[b].ringBufferOffset;
+					*(uint32*)GET_UNIFORM_DATA_PTR(shader->uniform.loc_streamoutBufferBase[b]) = m_streamoutState.buffer[b].ringBufferOffset;
 				}
 			}
 		}
 		// upload
-		if ((m_uniformVarBufferWriteIndex + shader->uniform.uniformRangeSize + 1024) > UNIFORMVAR_RINGBUFFER_SIZE)
+		const uint32 bufferAlignmentM1 = std::max(m_featureControl.limits.minUniformBufferOffsetAlignment, m_featureControl.limits.nonCoherentAtomSize) - 1;
+		const uint32 uniformSize = (shader->uniform.uniformRangeSize + bufferAlignmentM1) & ~bufferAlignmentM1;
+
+		auto waitWhileCondition = [&](std::function<bool()> condition) {
+			while (condition())
+			{
+				if (m_commandBufferSyncIndex == m_commandBufferIndex)
+				{
+					if (m_cmdBufferUniformRingbufIndices[m_commandBufferIndex] != m_uniformVarBufferReadIndex)
+					{
+						draw_endRenderPass();
+						SubmitCommandBuffer();
+					}
+					else
+					{
+						// submitting work would not change readIndex, so there's no way for conditions based on it to change
+						cemuLog_log(LogType::Force, "draw call overflowed and corrupted uniform ringbuffer. expect visual corruption");
+						cemu_assert_suspicious();
+						break;
+					}
+				}
+				WaitForNextFinishedCommandBuffer();
+			}
+		};
+
+		// wrap around if it doesnt fit consecutively
+		if (m_uniformVarBufferWriteIndex + uniformSize > UNIFORMVAR_RINGBUFFER_SIZE)
 		{
+			waitWhileCondition([&]() {
+				return m_uniformVarBufferReadIndex > m_uniformVarBufferWriteIndex || m_uniformVarBufferReadIndex == 0;
+			});
 			m_uniformVarBufferWriteIndex = 0;
 		}
-		uint32 bufferAlignmentM1 = std::max(m_featureControl.limits.minUniformBufferOffsetAlignment, m_featureControl.limits.nonCoherentAtomSize) - 1;
+
+		auto ringBufRemaining = [&]() {
+			ssize_t ringBufferUsedBytes = (ssize_t)m_uniformVarBufferWriteIndex - m_uniformVarBufferReadIndex;
+			if (ringBufferUsedBytes < 0)
+				ringBufferUsedBytes += UNIFORMVAR_RINGBUFFER_SIZE;
+			return UNIFORMVAR_RINGBUFFER_SIZE - 1 - ringBufferUsedBytes;
+		};
+		waitWhileCondition([&]() {
+			return ringBufRemaining() < uniformSize;
+		});
+
 		const uint32 uniformOffset = m_uniformVarBufferWriteIndex;
-		memcpy(m_uniformVarBufferPtr + uniformOffset, uniformData, shader->uniform.uniformRangeSize);
-		m_uniformVarBufferWriteIndex += shader->uniform.uniformRangeSize;
-		m_uniformVarBufferWriteIndex = (m_uniformVarBufferWriteIndex + bufferAlignmentM1) & ~bufferAlignmentM1;
+		memcpy(m_uniformVarBufferPtr + uniformOffset, s_vkUniformData, shader->uniform.uniformRangeSize);
+		m_uniformVarBufferWriteIndex += uniformSize;
 		// update dynamic offset
 		dynamicOffsetInfo.uniformVarBufferOffset[shaderStageIndex] = uniformOffset;
 		// flush if not coherent
 		if (!m_uniformVarBufferMemoryIsCoherent)
 		{
-			uint32 nonCoherentAtomSizeM1 = m_featureControl.limits.nonCoherentAtomSize - 1;
 			VkMappedMemoryRange flushedRange{};
 			flushedRange.sType = VK_STRUCTURE_TYPE_MAPPED_MEMORY_RANGE;
 			flushedRange.memory = m_uniformVarBufferMemory;
 			flushedRange.offset = uniformOffset;
-			flushedRange.size = (shader->uniform.uniformRangeSize + nonCoherentAtomSizeM1) & ~nonCoherentAtomSizeM1;
+			flushedRange.size = uniformSize;
 			vkFlushMappedMemoryRanges(m_logicalDevice, 1, &flushedRange);
 		}
 	}
@@ -496,7 +530,7 @@ void VulkanRenderer::draw_prepareDynamicOffsetsForDescriptorSet(uint32 shaderSta
 	{
 		for (auto& itr : pipeline_info->dynamicOffsetInfo.list_uniformBuffers[shaderStageIndex])
 		{
-			dynamicOffsets[numDynOffsets] = dynamicOffsetInfo.shaderUB[shaderStageIndex].unformBufferOffset[itr];
+			dynamicOffsets[numDynOffsets] = dynamicOffsetInfo.shaderUB[shaderStageIndex].uniformBufferOffset[itr];
 			numDynOffsets++;
 		}
 	}
@@ -516,15 +550,15 @@ uint64 VulkanRenderer::GetDescriptorSetStateHash(LatteDecompilerShader* shader)
 		switch (shader->shaderType)
 		{
 		case LatteConst::ShaderType::Vertex:
-			hostTextureUnit += CEMU_VS_TEX_UNIT_BASE;
+			hostTextureUnit += LATTE_CEMU_VS_TEX_UNIT_BASE;
 			texUnitRegIndex += Latte::REGADDR::SQ_TEX_RESOURCE_WORD0_N_VS;
 			break;
 		case LatteConst::ShaderType::Pixel:
-			hostTextureUnit += CEMU_PS_TEX_UNIT_BASE;
+			hostTextureUnit += LATTE_CEMU_PS_TEX_UNIT_BASE;
 			texUnitRegIndex += Latte::REGADDR::SQ_TEX_RESOURCE_WORD0_N_PS;
 			break;
 		case LatteConst::ShaderType::Geometry:
-			hostTextureUnit += CEMU_GS_TEX_UNIT_BASE;
+			hostTextureUnit += LATTE_CEMU_GS_TEX_UNIT_BASE;
 			texUnitRegIndex += Latte::REGADDR::SQ_TEX_RESOURCE_WORD0_N_GS;
 			break;
 		default:
@@ -570,7 +604,7 @@ VkDescriptorSetInfo* VulkanRenderer::draw_getOrCreateDescriptorSet(PipelineInfo*
 		const auto it = pipeline_info->vertex_ds_cache.find(stateHash);
 		if (it != pipeline_info->vertex_ds_cache.cend())
 			return it->second;
-		descriptor_set_layout = pipeline_info->m_vkrObjPipeline->vertexDSL;
+		descriptor_set_layout = pipeline_info->m_vkrObjPipeline->m_vertexDSL;
 		break;
 	}
 	case LatteConst::ShaderType::Pixel:
@@ -578,7 +612,7 @@ VkDescriptorSetInfo* VulkanRenderer::draw_getOrCreateDescriptorSet(PipelineInfo*
 		const auto it = pipeline_info->pixel_ds_cache.find(stateHash);
 		if (it != pipeline_info->pixel_ds_cache.cend())
 			return it->second;
-		descriptor_set_layout = pipeline_info->m_vkrObjPipeline->pixelDSL;
+		descriptor_set_layout = pipeline_info->m_vkrObjPipeline->m_pixelDSL;
 		break;
 	}
 	case LatteConst::ShaderType::Geometry:
@@ -586,7 +620,7 @@ VkDescriptorSetInfo* VulkanRenderer::draw_getOrCreateDescriptorSet(PipelineInfo*
 		const auto it = pipeline_info->geometry_ds_cache.find(stateHash);
 		if (it != pipeline_info->geometry_ds_cache.cend())
 			return it->second;
-		descriptor_set_layout = pipeline_info->m_vkrObjPipeline->geometryDSL;
+		descriptor_set_layout = pipeline_info->m_vkrObjPipeline->m_geometryDSL;
 		break;
 	}
 	default:
@@ -634,15 +668,15 @@ VkDescriptorSetInfo* VulkanRenderer::draw_getOrCreateDescriptorSet(PipelineInfo*
 		switch (shader->shaderType)
 		{
 		case LatteConst::ShaderType::Vertex:
-			hostTextureUnit += CEMU_VS_TEX_UNIT_BASE;
+			hostTextureUnit += LATTE_CEMU_VS_TEX_UNIT_BASE;
 			texUnitRegIndex += Latte::REGADDR::SQ_TEX_RESOURCE_WORD0_N_VS;
 			break;
 		case LatteConst::ShaderType::Pixel:
-			hostTextureUnit += CEMU_PS_TEX_UNIT_BASE;
+			hostTextureUnit += LATTE_CEMU_PS_TEX_UNIT_BASE;
 			texUnitRegIndex += Latte::REGADDR::SQ_TEX_RESOURCE_WORD0_N_PS;
 			break;
 		case LatteConst::ShaderType::Geometry:
-			hostTextureUnit += CEMU_GS_TEX_UNIT_BASE;
+			hostTextureUnit += LATTE_CEMU_GS_TEX_UNIT_BASE;
 			texUnitRegIndex += Latte::REGADDR::SQ_TEX_RESOURCE_WORD0_N_GS;
 			break;
 		default:
@@ -677,7 +711,7 @@ VkDescriptorSetInfo* VulkanRenderer::draw_getOrCreateDescriptorSet(PipelineInfo*
 			info.imageView = nullTexture1D.view;
 			info.sampler = nullTexture1D.sampler;
 			textureArray.emplace_back(info);
-			// forceLog_printf("Vulkan-Info: Shader 0x%016llx uses 1D texture but bound texture has mismatching type (dim: 0x%02x)", shader->baseHash, textureView->gx2Dim);
+			// cemuLog_log(LogType::Force, "Vulkan-Info: Shader 0x{:016x} uses 1D texture but bound texture has mismatching type (dim: 0x{:02x})", shader->baseHash, textureView->gx2Dim);
 			continue;
 		}
 		else if (textureDim == Latte::E_DIM::DIM_2D && (textureView->dim != Latte::E_DIM::DIM_2D && textureView->dim != Latte::E_DIM::DIM_2D_MSAA))
@@ -688,7 +722,7 @@ VkDescriptorSetInfo* VulkanRenderer::draw_getOrCreateDescriptorSet(PipelineInfo*
 			info.imageView = nullTexture2D.view;
 			info.sampler = nullTexture2D.sampler;
 			textureArray.emplace_back(info);
-			// forceLog_printf("Vulkan-Info: Shader 0x%016llx uses 2D texture but bound texture has mismatching type (dim: 0x%02x)", shader->baseHash, textureView->gx2Dim);
+			// cemuLog_log(LogType::Force, "Vulkan-Info: Shader 0x{:016x} uses 2D texture but bound texture has mismatching type (dim: 0x{:02x})", shader->baseHash, textureView->gx2Dim);
 			continue;
 		}
 
@@ -696,7 +730,6 @@ VkDescriptorSetInfo* VulkanRenderer::draw_getOrCreateDescriptorSet(PipelineInfo*
 
 		VkSamplerCustomBorderColorCreateInfoEXT samplerCustomBorderColor{};
 
-		VkSampler sampler;
 		VkSamplerCreateInfo samplerInfo{};
 		samplerInfo.sType = VK_STRUCTURE_TYPE_SAMPLER_CREATE_INFO;
 
@@ -869,9 +902,9 @@ VkDescriptorSetInfo* VulkanRenderer::draw_getOrCreateDescriptorSet(PipelineInfo*
 			}
 		}
 
-		if (vkCreateSampler(m_logicalDevice, &samplerInfo, nullptr, &sampler) != VK_SUCCESS)
-			UnrecoverableError("Failed to create texture sampler");
-		info.sampler = sampler;
+		VKRObjectSampler* samplerObj = VKRObjectSampler::GetOrCreateSampler(&samplerInfo);
+		vkObjDS->addRef(samplerObj);
+		info.sampler = samplerObj->GetSampler();
 		textureArray.emplace_back(info);
 	}
 
@@ -1132,28 +1165,17 @@ void VulkanRenderer::draw_prepareDescriptorSets(PipelineInfo* pipeline_info, VkD
 	const auto geometryShader = LatteSHRC_GetActiveGeometryShader();
 	const auto pixelShader = LatteSHRC_GetActivePixelShader();
 
-
-	if (vertexShader)
-	{
-		auto descriptorSetInfo = draw_getOrCreateDescriptorSet(pipeline_info, vertexShader);
+	auto prepareShaderDescriptors = [this, &pipeline_info](LatteDecompilerShader* shader) -> VkDescriptorSetInfo* {
+		if (!shader)
+			return nullptr;
+		auto descriptorSetInfo = draw_getOrCreateDescriptorSet(pipeline_info, shader);
 		descriptorSetInfo->m_vkObjDescriptorSet->flagForCurrentCommandBuffer();
-		vertexDS = descriptorSetInfo;
-	}
+		return descriptorSetInfo;
+	};
 
-	if (pixelShader)
-	{
-		auto descriptorSetInfo = draw_getOrCreateDescriptorSet(pipeline_info, pixelShader);
-		descriptorSetInfo->m_vkObjDescriptorSet->flagForCurrentCommandBuffer();
-		pixelDS = descriptorSetInfo;
-
-	}
-
-	if (geometryShader)
-	{
-		auto descriptorSetInfo = draw_getOrCreateDescriptorSet(pipeline_info, geometryShader);
-		descriptorSetInfo->m_vkObjDescriptorSet->flagForCurrentCommandBuffer();
-		geometryDS = descriptorSetInfo;
-	}
+	vertexDS = prepareShaderDescriptors(vertexShader);
+	pixelDS = prepareShaderDescriptors(pixelShader);
+	geometryDS = prepareShaderDescriptors(geometryShader);
 }
 
 void VulkanRenderer::draw_updateVkBlendConstants()
@@ -1196,30 +1218,15 @@ void VulkanRenderer::draw_setRenderPass()
 	// update self-dependency flag
 	if (m_state.descriptorSetsChanged || m_state.activeRenderpassFBO != fboVk)
 	{
-		bool hadDep = m_state.hasRenderSelfDependency;
 		m_state.hasRenderSelfDependency = fboVk->CheckForCollision(m_state.activeVertexDS, m_state.activeGeometryDS, m_state.activePixelDS);
 	}
 
 	auto vkObjRenderPass = fboVk->GetRenderPassObj();
 	auto vkObjFramebuffer = fboVk->GetFramebufferObj();
 
-	if (m_state.hasRenderSelfDependency)
-	{
-		bool triggerBarrier = GetConfig().vk_accurate_barriers || m_state.activePipelineInfo->neverSkipAccurateBarrier;
-		if (triggerBarrier)
-		{
-			VkMemoryBarrier memoryBarrier{};
-			memoryBarrier.sType = VK_STRUCTURE_TYPE_MEMORY_BARRIER;
-			memoryBarrier.srcAccessMask = VK_ACCESS_COLOR_ATTACHMENT_WRITE_BIT;
-			memoryBarrier.dstAccessMask = VK_ACCESS_SHADER_READ_BIT;
-			VkPipelineStageFlags srcStage = VK_PIPELINE_STAGE_COLOR_ATTACHMENT_OUTPUT_BIT;
-			VkPipelineStageFlags dstStage = VK_PIPELINE_STAGE_VERTEX_SHADER_BIT | VK_PIPELINE_STAGE_GEOMETRY_SHADER_BIT | VK_PIPELINE_STAGE_FRAGMENT_SHADER_BIT;
-			vkCmdPipelineBarrier(m_state.currentCommandBuffer, srcStage, dstStage, 0, 1, &memoryBarrier, 0, nullptr, 0, nullptr);
-			performanceMonitor.vk.numDrawBarriersPerFrame.increment();
-		}
-	}
+	bool overridePassReuse = m_state.hasRenderSelfDependency && (GetConfig().vk_accurate_barriers || m_state.activePipelineInfo->neverSkipAccurateBarrier);
 
-	if (m_state.activeRenderpassFBO == fboVk)
+	if (!overridePassReuse && m_state.activeRenderpassFBO == fboVk)
 	{
 		if (m_state.descriptorSetsChanged)
 			sync_inputTexturesChanged();
@@ -1302,9 +1309,9 @@ void VulkanRenderer::draw_beginSequence()
 
 	// update shader state
 	LatteSHRC_UpdateActiveShaders();
-	if (m_state.drawSequenceSkip)
+	if (LatteGPUState.activeShaderHasError)
 	{
-		debug_printf("Skipping drawcalls due to shader error\n");
+		cemuLog_logDebugOnce(LogType::Force, "Skipping drawcalls due to shader error");
 		m_state.drawSequenceSkip = true;
 		cemu_assert_debug(false);
 		return;
@@ -1374,6 +1381,24 @@ void VulkanRenderer::draw_execute(uint32 baseVertex, uint32 baseInstance, uint32
 		return;
 	}
 
+	// prepare streamout
+	m_streamoutState.verticesPerInstance = count;
+	LatteStreamout_PrepareDrawcall(count, instanceCount);
+
+	// update uniform vars
+	LatteDecompilerShader* vertexShader = LatteSHRC_GetActiveVertexShader();
+	LatteDecompilerShader* pixelShader = LatteSHRC_GetActivePixelShader();
+	LatteDecompilerShader* geometryShader = LatteSHRC_GetActiveGeometryShader();
+
+	if (vertexShader)
+		uniformData_updateUniformVars(VulkanRendererConst::SHADER_STAGE_INDEX_VERTEX, vertexShader);
+	if (pixelShader)
+		uniformData_updateUniformVars(VulkanRendererConst::SHADER_STAGE_INDEX_FRAGMENT, pixelShader);
+	if (geometryShader)
+		uniformData_updateUniformVars(VulkanRendererConst::SHADER_STAGE_INDEX_GEOMETRY, geometryShader);
+	// store where the read pointer should go after command buffer execution
+	m_cmdBufferUniformRingbufIndices[m_commandBufferIndex] = m_uniformVarBufferWriteIndex;
+
 	// process index data
 	const LattePrimitiveMode primitiveMode = static_cast<LattePrimitiveMode>(LatteGPUState.contextRegister[mmVGT_PRIMITIVE_TYPE]);
 
@@ -1381,14 +1406,15 @@ void VulkanRenderer::draw_execute(uint32 baseVertex, uint32 baseInstance, uint32
 	uint32 hostIndexCount;
 	uint32 indexMin = 0;
 	uint32 indexMax = 0;
-	uint32 indexBufferOffset = 0;
-	uint32 indexBufferIndex = 0;
-	LatteIndices_decode(memory_getPointerFromVirtualOffset(indexDataMPTR), indexType, count, primitiveMode, indexMin, indexMax, hostIndexType, hostIndexCount, indexBufferOffset, indexBufferIndex);
-
+	Renderer::IndexAllocation indexAllocation;
+	LatteIndices_decode(memory_getPointerFromVirtualOffset(indexDataMPTR), indexType, count, primitiveMode, indexMin, indexMax, hostIndexType, hostIndexCount, indexAllocation);
+	VKRSynchronizedHeapAllocator::AllocatorReservation* indexReservation = (VKRSynchronizedHeapAllocator::AllocatorReservation*)indexAllocation.rendererInternal;
 	// update index binding
 	bool isPrevIndexData = false;
 	if (hostIndexType != INDEX_TYPE::NONE)
 	{
+		uint32 indexBufferIndex = indexReservation->bufferIndex;
+		uint32 indexBufferOffset = indexReservation->bufferOffset;
 		if (m_state.activeIndexBufferOffset != indexBufferOffset || m_state.activeIndexBufferIndex != indexBufferIndex || m_state.activeIndexType != hostIndexType)
 		{
 			m_state.activeIndexType = hostIndexType;
@@ -1401,7 +1427,7 @@ void VulkanRenderer::draw_execute(uint32 baseVertex, uint32 baseInstance, uint32
 				vkType = VK_INDEX_TYPE_UINT32;
 			else
 				cemu_assert(false);
-			vkCmdBindIndexBuffer(m_state.currentCommandBuffer, memoryManager->getIndexAllocator().GetBufferByIndex(indexBufferIndex), indexBufferOffset, vkType);
+			vkCmdBindIndexBuffer(m_state.currentCommandBuffer, indexReservation->vkBuffer, indexBufferOffset, vkType);
 		}
 		else
 			isPrevIndexData = true;
@@ -1427,22 +1453,6 @@ void VulkanRenderer::draw_execute(uint32 baseVertex, uint32 baseInstance, uint32
 		LatteBufferCache_Sync(indexMin + baseVertex, indexMax + baseVertex, baseInstance, instanceCount);
 	}
 
-	// prepare streamout
-	m_streamoutState.verticesPerInstance = count;
-	LatteStreamout_PrepareDrawcall(count, instanceCount);
-
-	// update uniform vars
-	LatteDecompilerShader* vertexShader = LatteSHRC_GetActiveVertexShader();
-	LatteDecompilerShader* pixelShader = LatteSHRC_GetActivePixelShader();
-	LatteDecompilerShader* geometryShader = LatteSHRC_GetActiveGeometryShader();
-
-	if (vertexShader)
-		uniformData_updateUniformVars(VulkanRendererConst::SHADER_STAGE_INDEX_VERTEX, vertexShader);
-	if (pixelShader)
-		uniformData_updateUniformVars(VulkanRendererConst::SHADER_STAGE_INDEX_FRAGMENT, pixelShader);
-	if (geometryShader)
-		uniformData_updateUniformVars(VulkanRendererConst::SHADER_STAGE_INDEX_GEOMETRY, geometryShader);
-
 	PipelineInfo* pipeline_info;
 
 	if (!isFirst)
@@ -1456,7 +1466,7 @@ void VulkanRenderer::draw_execute(uint32 baseVertex, uint32 baseInstance, uint32
 		else
 		{
 			pipeline_info = m_state.activePipelineInfo;
-#ifndef PUBLIC_RELEASE
+#ifdef CEMU_DEBUG_ASSERT
 			auto pipeline_info2 = draw_getOrCreateGraphicsPipeline(count);
 			if (pipeline_info != pipeline_info2)
 			{
@@ -1472,8 +1482,7 @@ void VulkanRenderer::draw_execute(uint32 baseVertex, uint32 baseInstance, uint32
 	}
 
 	auto vkObjPipeline = pipeline_info->m_vkrObjPipeline;
-
-	if (vkObjPipeline->pipeline == VK_NULL_HANDLE)
+	if (vkObjPipeline->GetPipeline() == VK_NULL_HANDLE)
 	{
 		// invalid/uninitialized pipeline
 		m_state.activeVertexDS = nullptr;
@@ -1500,11 +1509,11 @@ void VulkanRenderer::draw_execute(uint32 baseVertex, uint32 baseInstance, uint32
 
 	draw_setRenderPass();
 
-	if (m_state.currentPipeline != vkObjPipeline->pipeline)
+	if (m_state.currentPipeline != vkObjPipeline->GetPipeline())
 	{
-		vkCmdBindPipeline(m_state.currentCommandBuffer, VK_PIPELINE_BIND_POINT_GRAPHICS, vkObjPipeline->pipeline);
+		vkCmdBindPipeline(m_state.currentCommandBuffer, VK_PIPELINE_BIND_POINT_GRAPHICS, vkObjPipeline->GetPipeline());
 		vkObjPipeline->flagForCurrentCommandBuffer();
-		m_state.currentPipeline = vkObjPipeline->pipeline;
+		m_state.currentPipeline = vkObjPipeline->GetPipeline();
 		// depth bias
 		if (pipeline_info->usesDepthBias)
 			draw_updateDepthBias(true);
@@ -1536,7 +1545,7 @@ void VulkanRenderer::draw_execute(uint32 baseVertex, uint32 baseInstance, uint32
 		dsArray[1] = pixelDS->m_vkObjDescriptorSet->descriptorSet;
 
 		vkCmdBindDescriptorSets(m_state.currentCommandBuffer, VK_PIPELINE_BIND_POINT_GRAPHICS,
-			vkObjPipeline->pipeline_layout, 0, 2, dsArray, numDynOffsetsVS + numDynOffsetsPS,
+			vkObjPipeline->m_pipelineLayout, 0, 2, dsArray, numDynOffsetsVS + numDynOffsetsPS,
 			dynamicOffsets);
 	}
 	else if (vertexDS)
@@ -1545,7 +1554,7 @@ void VulkanRenderer::draw_execute(uint32 baseVertex, uint32 baseInstance, uint32
 		draw_prepareDynamicOffsetsForDescriptorSet(VulkanRendererConst::SHADER_STAGE_INDEX_VERTEX, dynamicOffsets, numDynOffsets,
 			pipeline_info);
 		vkCmdBindDescriptorSets(m_state.currentCommandBuffer, VK_PIPELINE_BIND_POINT_GRAPHICS,
-			vkObjPipeline->pipeline_layout, 0, 1, &vertexDS->m_vkObjDescriptorSet->descriptorSet, numDynOffsets,
+			vkObjPipeline->m_pipelineLayout, 0, 1, &vertexDS->m_vkObjDescriptorSet->descriptorSet, numDynOffsets,
 			dynamicOffsets);
 	}
 	else if (pixelDS)
@@ -1554,7 +1563,7 @@ void VulkanRenderer::draw_execute(uint32 baseVertex, uint32 baseInstance, uint32
 		draw_prepareDynamicOffsetsForDescriptorSet(VulkanRendererConst::SHADER_STAGE_INDEX_FRAGMENT, dynamicOffsets, numDynOffsets,
 			pipeline_info);
 		vkCmdBindDescriptorSets(m_state.currentCommandBuffer, VK_PIPELINE_BIND_POINT_GRAPHICS,
-			vkObjPipeline->pipeline_layout, 1, 1, &pixelDS->m_vkObjDescriptorSet->descriptorSet, numDynOffsets,
+			vkObjPipeline->m_pipelineLayout, 1, 1, &pixelDS->m_vkObjDescriptorSet->descriptorSet, numDynOffsets,
 			dynamicOffsets);
 	}
 	if (geometryDS)
@@ -1563,7 +1572,7 @@ void VulkanRenderer::draw_execute(uint32 baseVertex, uint32 baseInstance, uint32
 		draw_prepareDynamicOffsetsForDescriptorSet(VulkanRendererConst::SHADER_STAGE_INDEX_GEOMETRY, dynamicOffsets, numDynOffsets,
 			pipeline_info);
 		vkCmdBindDescriptorSets(m_state.currentCommandBuffer, VK_PIPELINE_BIND_POINT_GRAPHICS,
-			vkObjPipeline->pipeline_layout, 2, 1, &geometryDS->m_vkObjDescriptorSet->descriptorSet, numDynOffsets,
+			vkObjPipeline->m_pipelineLayout, 2, 1, &geometryDS->m_vkObjDescriptorSet->descriptorSet, numDynOffsets,
 			dynamicOffsets);
 	}
 
@@ -1592,9 +1601,9 @@ void VulkanRenderer::draw_updateVertexBuffersDirectAccess()
 		uint32 bufferSize = LatteGPUState.contextRegister[bufferBaseRegisterIndex + 1] + 1;
 		uint32 bufferStride = (LatteGPUState.contextRegister[bufferBaseRegisterIndex + 2] >> 11) & 0xFFFF;
 
-		if (bufferAddress == MPTR_NULL)
+		if (bufferAddress == MPTR_NULL) [[unlikely]]
 		{
-			cemu_assert_unimplemented();
+			bufferAddress = 0x10000000;
 		}
 		if (m_state.currentVertexBinding[bufferIndex].offset == bufferAddress)
 			continue;
@@ -1609,18 +1618,18 @@ void VulkanRenderer::draw_updateUniformBuffersDirectAccess(LatteDecompilerShader
 {
 	if (shader->uniformMode == LATTE_DECOMPILER_UNIFORM_MODE_FULL_CBANK)
 	{
-		// use full uniform buffers
-		for (sint32 t = 0; t < shader->uniformBufferListCount; t++)
+		for(const auto& buf : shader->list_quickBufferList)
 		{
-			sint32 i = shader->uniformBufferList[t];
+			sint32 i = buf.index;
 			MPTR physicalAddr = LatteGPUState.contextRegister[uniformBufferRegOffset + i * 7 + 0];
 			uint32 uniformSize = LatteGPUState.contextRegister[uniformBufferRegOffset + i * 7 + 1] + 1;
 
-			if (physicalAddr == MPTR_NULL)
+			if (physicalAddr == MPTR_NULL) [[unlikely]]
 			{
 				cemu_assert_unimplemented();
 				continue;
 			}
+			uniformSize = std::min<uint32>(uniformSize, buf.size);
 
 			cemu_assert_debug(physicalAddr < 0x50000000);
 
@@ -1630,16 +1639,16 @@ void VulkanRenderer::draw_updateUniformBuffersDirectAccess(LatteDecompilerShader
 			switch (shaderType)
 			{
 			case LatteConst::ShaderType::Vertex:
-				dynamicOffsetInfo.shaderUB[VulkanRendererConst::SHADER_STAGE_INDEX_VERTEX].unformBufferOffset[bufferIndex] = physicalAddr - m_importedMemBaseAddress;
+				dynamicOffsetInfo.shaderUB[VulkanRendererConst::SHADER_STAGE_INDEX_VERTEX].uniformBufferOffset[bufferIndex] = physicalAddr - m_importedMemBaseAddress;
 				break;
 			case LatteConst::ShaderType::Geometry:
-				dynamicOffsetInfo.shaderUB[VulkanRendererConst::SHADER_STAGE_INDEX_GEOMETRY].unformBufferOffset[bufferIndex] = physicalAddr - m_importedMemBaseAddress;
+				dynamicOffsetInfo.shaderUB[VulkanRendererConst::SHADER_STAGE_INDEX_GEOMETRY].uniformBufferOffset[bufferIndex] = physicalAddr - m_importedMemBaseAddress;
 				break;
 			case LatteConst::ShaderType::Pixel:
-				dynamicOffsetInfo.shaderUB[VulkanRendererConst::SHADER_STAGE_INDEX_FRAGMENT].unformBufferOffset[bufferIndex] = physicalAddr - m_importedMemBaseAddress;
+				dynamicOffsetInfo.shaderUB[VulkanRendererConst::SHADER_STAGE_INDEX_FRAGMENT].uniformBufferOffset[bufferIndex] = physicalAddr - m_importedMemBaseAddress;
 				break;
 			default:
-				cemu_assert_debug(false);
+				UNREACHABLE;
 			}
 		}
 	}
diff --git a/src/Cafe/HW/Latte/Renderer/Vulkan/VulkanSurfaceCopy.cpp b/src/Cafe/HW/Latte/Renderer/Vulkan/VulkanSurfaceCopy.cpp
index 1f123ce9..e3e42012 100644
--- a/src/Cafe/HW/Latte/Renderer/Vulkan/VulkanSurfaceCopy.cpp
+++ b/src/Cafe/HW/Latte/Renderer/Vulkan/VulkanSurfaceCopy.cpp
@@ -76,6 +76,30 @@ struct CopySurfacePipelineInfo
 	CopySurfacePipelineInfo() = default;
 	CopySurfacePipelineInfo(VkDevice device) : m_device(device) {}
 	CopySurfacePipelineInfo(const CopySurfacePipelineInfo& info) = delete;
+	~CopySurfacePipelineInfo()
+	{
+		auto renderer = VulkanRenderer::GetInstance();
+		renderer->ReleaseDestructibleObject(vkObjRenderPass);
+		renderer->ReleaseDestructibleObject(vkObjPipeline);
+
+		for(auto& i : map_framebuffers)
+		{
+			for(auto& fb : i.second.m_array)
+			{
+				renderer->ReleaseDestructibleObject(fb->vkObjFramebuffer);
+				renderer->ReleaseDestructibleObject(fb->vkObjImageView);
+			}
+		}
+
+		for(auto& i : map_descriptors)
+		{
+			for(auto& descriptor : i.second.m_array)
+			{
+				renderer->ReleaseDestructibleObject(descriptor->vkObjImageView);
+				renderer->ReleaseDestructibleObject(descriptor->vkObjDescriptorSet);
+			}
+		}
+	}
 
 	VkDevice m_device = nullptr;
 
@@ -333,7 +357,7 @@ CopySurfacePipelineInfo* VulkanRenderer::copySurface_getOrCreateGraphicsPipeline
 	layoutInfo.bindingCount = (uint32_t)descriptorSetLayoutBindings.size();
 	layoutInfo.pBindings = descriptorSetLayoutBindings.data();
 
-	if (vkCreateDescriptorSetLayout(m_logicalDevice, &layoutInfo, nullptr, &vkObjPipeline->pixelDSL) != VK_SUCCESS)
+	if (vkCreateDescriptorSetLayout(m_logicalDevice, &layoutInfo, nullptr, &vkObjPipeline->m_pixelDSL) != VK_SUCCESS)
 		UnrecoverableError(fmt::format("Failed to create descriptor set layout for surface copy shader").c_str());
 
 	// ##########################################################################################################################################
@@ -346,15 +370,15 @@ CopySurfacePipelineInfo* VulkanRenderer::copySurface_getOrCreateGraphicsPipeline
 	VkPipelineLayoutCreateInfo pipelineLayoutInfo{};
 	pipelineLayoutInfo.sType = VK_STRUCTURE_TYPE_PIPELINE_LAYOUT_CREATE_INFO;
 	pipelineLayoutInfo.setLayoutCount = 1;
-	pipelineLayoutInfo.pSetLayouts = &vkObjPipeline->pixelDSL;
+	pipelineLayoutInfo.pSetLayouts = &vkObjPipeline->m_pixelDSL;
 	pipelineLayoutInfo.pPushConstantRanges = &pushConstantRange;
 	pipelineLayoutInfo.pushConstantRangeCount = 1;
 
-	VkResult result = vkCreatePipelineLayout(m_logicalDevice, &pipelineLayoutInfo, nullptr, &vkObjPipeline->pipeline_layout);
+	VkResult result = vkCreatePipelineLayout(m_logicalDevice, &pipelineLayoutInfo, nullptr, &vkObjPipeline->m_pipelineLayout);
 	if (result != VK_SUCCESS)
 	{
-		forceLog_printf("%s", fmt::format("Failed to create pipeline layout: {}", result).c_str());
-		vkObjPipeline->pipeline = VK_NULL_HANDLE;
+		cemuLog_log(LogType::Force, "Failed to create pipeline layout: {}", result);
+		vkObjPipeline->SetPipeline(VK_NULL_HANDLE);
 		return copyPipeline;
 	}
 
@@ -401,7 +425,7 @@ CopySurfacePipelineInfo* VulkanRenderer::copySurface_getOrCreateGraphicsPipeline
 	pipelineInfo.pRasterizationState = &rasterizer;
 	pipelineInfo.pMultisampleState = &multisampling;
 	pipelineInfo.pColorBlendState = state.destinationTexture->isDepth?nullptr:&colorBlending;
-	pipelineInfo.layout = vkObjPipeline->pipeline_layout;
+	pipelineInfo.layout = vkObjPipeline->m_pipelineLayout;
 	pipelineInfo.renderPass = copyPipeline->vkObjRenderPass->m_renderPass;
 	pipelineInfo.pDepthStencilState = &depthStencilState;
 	pipelineInfo.subpass = 0;
@@ -410,17 +434,16 @@ CopySurfacePipelineInfo* VulkanRenderer::copySurface_getOrCreateGraphicsPipeline
 
 	copyPipeline->vkObjPipeline = vkObjPipeline;
 
-	result = vkCreateGraphicsPipelines(m_logicalDevice, m_pipeline_cache, 1, &pipelineInfo, nullptr, &copyPipeline->vkObjPipeline->pipeline);
+	VkPipeline pipeline = VK_NULL_HANDLE;
+	result = vkCreateGraphicsPipelines(m_logicalDevice, m_pipeline_cache, 1, &pipelineInfo, nullptr, &pipeline);
 	if (result != VK_SUCCESS)
 	{
-		forceLog_printf("Failed to create graphics pipeline for surface copy. Error %d Info:", (sint32)result);
-		cemu_assert_debug(false);
-		copyPipeline->vkObjPipeline->pipeline = VK_NULL_HANDLE;
+		copyPipeline->vkObjPipeline->SetPipeline(nullptr);
+		cemuLog_log(LogType::Force, "Failed to create graphics pipeline for surface copy. Error {} Info:", (sint32)result);
+		cemu_assert_suspicious();
 	}
-	//performanceMonitor.vk.numGraphicPipelines.increment();
-
-	//m_pipeline_cache_semaphore.notify();
-
+	else
+		copyPipeline->vkObjPipeline->SetPipeline(pipeline);
 	return copyPipeline;
 }
 
@@ -464,9 +487,8 @@ VKRObjectFramebuffer* VulkanRenderer::surfaceCopy_getOrCreateFramebuffer(VkCopyS
 	VKRObjectTextureView* vkObjTextureView = surfaceCopy_createImageView(state.destinationTexture, state.dstSlice, state.dstMip);
 
 	// create new framebuffer
-	sint32 effectiveWidth = 0;
-	sint32 effectiveHeight = 0;
-	LatteTexture_getEffectiveSize(state.destinationTexture, &effectiveWidth, &effectiveHeight, nullptr, state.dstMip);
+	sint32 effectiveWidth, effectiveHeight;
+	state.destinationTexture->GetEffectiveSize(effectiveWidth, effectiveHeight, state.dstMip);
 
 	std::array<VKRObjectTextureView*, 1> fbAttachments;
 	fbAttachments[0] = vkObjTextureView;
@@ -499,7 +521,7 @@ VKRObjectDescriptorSet* VulkanRenderer::surfaceCopy_getOrCreateDescriptorSet(VkC
 	allocInfo.sType = VK_STRUCTURE_TYPE_DESCRIPTOR_SET_ALLOCATE_INFO;
 	allocInfo.descriptorPool = m_descriptorPool;
 	allocInfo.descriptorSetCount = 1;
-	allocInfo.pSetLayouts = &(pipelineInfo->vkObjPipeline->pixelDSL);
+	allocInfo.pSetLayouts = &pipelineInfo->vkObjPipeline->m_pixelDSL;
 
 	if (vkAllocateDescriptorSets(m_logicalDevice, &allocInfo, &vkObjDescriptorSet->descriptorSet) != VK_SUCCESS)
 	{
@@ -595,15 +617,11 @@ void VulkanRenderer::surfaceCopy_viaDrawcall(LatteTextureVk* srcTextureVk, sint3
 	// get descriptor set
 	VKRObjectDescriptorSet* vkObjDescriptorSet = surfaceCopy_getOrCreateDescriptorSet(copySurfaceState, copySurfacePipelineInfo);
 	
-	// get extend
-	sint32 effectiveWidth = 0;
-	sint32 effectiveHeight = 0;
-	LatteTexture_getEffectiveSize(dstTextureVk, &effectiveWidth, &effectiveHeight, nullptr, texDstMip);
+	sint32 dstEffectiveWidth, dstEffectiveHeight;
+	dstTextureVk->GetEffectiveSize(dstEffectiveWidth, dstEffectiveHeight, texDstMip);
 
-	// get extend
-	sint32 srcEffectiveWidth = 0;
-	sint32 srcEffectiveHeight = 0;
-	LatteTexture_getEffectiveSize(srcTextureVk, &srcEffectiveWidth, &srcEffectiveHeight, nullptr, texSrcMip);
+	sint32 srcEffectiveWidth, srcEffectiveHeight;
+	srcTextureVk->GetEffectiveSize(srcEffectiveWidth, srcEffectiveHeight, texSrcMip);
 
 	CopyShaderPushConstantData_t pushConstantData;
 
@@ -625,7 +643,7 @@ void VulkanRenderer::surfaceCopy_viaDrawcall(LatteTextureVk* srcTextureVk, sint3
 	pushConstantData.srcTexelOffset[0] = 0;
 	pushConstantData.srcTexelOffset[1] = 0;
 
-	vkCmdPushConstants(m_state.currentCommandBuffer, copySurfacePipelineInfo->vkObjPipeline->pipeline_layout, VK_SHADER_STAGE_VERTEX_BIT, 0, sizeof(pushConstantData), &pushConstantData);
+	vkCmdPushConstants(m_state.currentCommandBuffer, copySurfacePipelineInfo->vkObjPipeline->m_pipelineLayout, VK_SHADER_STAGE_VERTEX_BIT, 0, sizeof(pushConstantData), &pushConstantData);
 
 	// draw
 	VkRenderPassBeginInfo renderPassInfo{};
@@ -661,13 +679,13 @@ void VulkanRenderer::surfaceCopy_viaDrawcall(LatteTextureVk* srcTextureVk, sint3
 	
 	vkCmdBeginRenderPass(m_state.currentCommandBuffer, &renderPassInfo, VK_SUBPASS_CONTENTS_INLINE);
 
-	vkCmdBindPipeline(m_state.currentCommandBuffer, VK_PIPELINE_BIND_POINT_GRAPHICS, copySurfacePipelineInfo->vkObjPipeline->pipeline);
+	vkCmdBindPipeline(m_state.currentCommandBuffer, VK_PIPELINE_BIND_POINT_GRAPHICS, copySurfacePipelineInfo->vkObjPipeline->GetPipeline());
 	copySurfacePipelineInfo->vkObjPipeline->flagForCurrentCommandBuffer();
 
-	m_state.currentPipeline = copySurfacePipelineInfo->vkObjPipeline->pipeline;
+	m_state.currentPipeline = copySurfacePipelineInfo->vkObjPipeline->GetPipeline();
 
 	vkCmdBindDescriptorSets(m_state.currentCommandBuffer, VK_PIPELINE_BIND_POINT_GRAPHICS,
-		copySurfacePipelineInfo->vkObjPipeline->pipeline_layout, 0, 1, &vkObjDescriptorSet->descriptorSet, 0, nullptr);
+		copySurfacePipelineInfo->vkObjPipeline->m_pipelineLayout, 0, 1, &vkObjDescriptorSet->descriptorSet, 0, nullptr);
 	vkObjDescriptorSet->flagForCurrentCommandBuffer();
 
 	vkCmdDraw(m_state.currentCommandBuffer, 6, 1, 0, 0);
@@ -768,119 +786,14 @@ bool vkIsBitCompatibleColorDepthFormat(VkFormat format1, VkFormat format2)
 	return false;
 }
 
-void VulkanRenderer::surfaceCopy_viaBuffer(LatteTextureVk* srcTextureVk, sint32 texSrcMip, sint32 texSrcSlice, LatteTextureVk* dstTextureVk, sint32 texDstMip, sint32 texDstSlice, sint32 effectiveCopyWidth, sint32 effectiveCopyHeight)
-{
-	cemu_assert_debug(false); // not used currently
-
-	cemu_assert_debug(m_featureControl.mode.useBufferSurfaceCopies);
-
-	if (srcTextureVk->dim == Latte::E_DIM::DIM_3D)
-	{
-		cemu_assert_debug(false);
-		return;
-	}
-	if (dstTextureVk->dim == Latte::E_DIM::DIM_3D)
-	{
-		cemu_assert_debug(false);
-		return;
-	}
-
-	draw_endRenderPass();
-
-	// calculate buffer size required for copy
-	VkDeviceSize copySize = std::max(srcTextureVk->getAllocation()->getAllocationSize(), dstTextureVk->getAllocation()->getAllocationSize());
-
-	// make sure allocated buffer is large enough
-	if (m_surfaceCopyBuffer == VK_NULL_HANDLE || copySize > m_surfaceCopyBufferSize)
-	{
-		if (m_surfaceCopyBuffer != VK_NULL_HANDLE)
-		{
-			// free existing buffer
-			destroyDeviceMemory(m_surfaceCopyBufferMemory);
-			m_surfaceCopyBufferMemory = VK_NULL_HANDLE;
-			destroyBuffer(m_surfaceCopyBuffer);
-			m_surfaceCopyBuffer = VK_NULL_HANDLE;
-		}
-		VkDeviceSize allocSize = (copySize + 1024ull * 1024ull - 1ull) & ~(1024ull * 1024ull - 1ull); // align to whole MB
-		m_surfaceCopyBufferSize = allocSize;
-		memoryManager->CreateBuffer(m_surfaceCopyBufferSize, VK_BUFFER_USAGE_TRANSFER_SRC_BIT | VK_BUFFER_USAGE_TRANSFER_DST_BIT, VK_MEMORY_PROPERTY_DEVICE_LOCAL_BIT, m_surfaceCopyBuffer, m_surfaceCopyBufferMemory);
-		if (m_surfaceCopyBuffer == VK_NULL_HANDLE)
-		{
-			forceLog_printf("Vulkan: Failed to allocate surface copy buffer with size %llu", allocSize);
-			return;
-		}
-	}
-	if (m_surfaceCopyBuffer == VK_NULL_HANDLE)
-		return;
-
-	auto vkObjSrcTexture = srcTextureVk->GetImageObj();
-	auto vkObjDstTexture = dstTextureVk->GetImageObj();
-	vkObjSrcTexture->flagForCurrentCommandBuffer();
-	vkObjDstTexture->flagForCurrentCommandBuffer();
-
-	VkBufferImageCopy region{};
-	region.bufferOffset = 0;
-	region.bufferRowLength = effectiveCopyWidth;
-	region.bufferImageHeight = effectiveCopyHeight;
-
-	if (srcTextureVk->isDepth)
-		region.imageSubresource.aspectMask = VK_IMAGE_ASPECT_DEPTH_BIT;
-	else
-		region.imageSubresource.aspectMask = VK_IMAGE_ASPECT_COLOR_BIT;
-	region.imageSubresource.baseArrayLayer = texSrcSlice;
-	region.imageSubresource.layerCount = 1;
-	region.imageSubresource.mipLevel = texSrcMip;
-
-	region.imageOffset = { 0,0,0 };
-	region.imageExtent = { (uint32)effectiveCopyWidth, (uint32)effectiveCopyHeight, 1 };
-
-	// make sure all write operations to the src image have finished
-	barrier_image<SYNC_OP::IMAGE_WRITE | SYNC_OP::ANY_TRANSFER, SYNC_OP::ANY_TRANSFER>(srcTextureVk, region.imageSubresource, VK_IMAGE_LAYOUT_GENERAL);
-
-	vkCmdCopyImageToBuffer(getCurrentCommandBuffer(), vkObjSrcTexture->m_image, VK_IMAGE_LAYOUT_GENERAL, m_surfaceCopyBuffer, 1, &region);
-
-	// copy buffer to image
-
-	VkBufferImageCopy imageRegion[2]{};
-	sint32 imageRegionCount = 0;
-
-	// color or depth only copy
-	imageRegion[0].bufferOffset = 0;
-	imageRegion[0].imageExtent.width = effectiveCopyWidth;
-	imageRegion[0].imageExtent.height = effectiveCopyHeight;
-	imageRegion[0].imageExtent.depth = 1;
-
-	imageRegion[0].imageSubresource.mipLevel = texDstMip;
-	if (dstTextureVk->isDepth)
-		imageRegion[0].imageSubresource.aspectMask = VK_IMAGE_ASPECT_DEPTH_BIT;
-	else
-		imageRegion[0].imageSubresource.aspectMask = VK_IMAGE_ASPECT_COLOR_BIT;
-	imageRegion[0].imageSubresource.baseArrayLayer = texDstSlice;
-	imageRegion[0].imageSubresource.layerCount = 1;
-
-	imageRegionCount = 1;
-
-	// make sure the transfer to the buffer finished
-	barrier_bufferRange<SYNC_OP::ANY_TRANSFER, SYNC_OP::ANY_TRANSFER>(m_surfaceCopyBuffer, 0, VK_WHOLE_SIZE);
-
-	// make sure all read and write operations to the dst image have finished
-	barrier_image<SYNC_OP::IMAGE_READ | SYNC_OP::IMAGE_WRITE | SYNC_OP::ANY_TRANSFER, SYNC_OP::ANY_TRANSFER>(dstTextureVk, imageRegion[0].imageSubresource, VK_IMAGE_LAYOUT_TRANSFER_DST_OPTIMAL);
-
-	vkCmdCopyBufferToImage(m_state.currentCommandBuffer, m_surfaceCopyBuffer, vkObjDstTexture->m_image, VK_IMAGE_LAYOUT_TRANSFER_DST_OPTIMAL, imageRegionCount, imageRegion);
-
-	// make sure transfer has finished before any other operation
-	barrier_image<SYNC_OP::ANY_TRANSFER, SYNC_OP::ANY_TRANSFER | SYNC_OP::IMAGE_READ | SYNC_OP::IMAGE_WRITE>(dstTextureVk, imageRegion[0].imageSubresource, VK_IMAGE_LAYOUT_GENERAL);
-}
-
 void VulkanRenderer::surfaceCopy_copySurfaceWithFormatConversion(LatteTexture* sourceTexture, sint32 srcMip, sint32 srcSlice, LatteTexture* destinationTexture, sint32 dstMip, sint32 dstSlice, sint32 width, sint32 height)
 {
 	// scale copy size to effective size
 	sint32 effectiveCopyWidth = width;
 	sint32 effectiveCopyHeight = height;
 	LatteTexture_scaleToEffectiveSize(sourceTexture, &effectiveCopyWidth, &effectiveCopyHeight, 0);
-	sint32 sourceEffectiveWidth;
-	sint32 sourceEffectiveHeight;
-	LatteTexture_getEffectiveSize(sourceTexture, &sourceEffectiveWidth, &sourceEffectiveHeight, nullptr, srcMip);
+	sint32 sourceEffectiveWidth, sourceEffectiveHeight;
+	sourceTexture->GetEffectiveSize(sourceEffectiveWidth, sourceEffectiveHeight, srcMip);
 
 	sint32 texSrcMip = srcMip;
 	sint32 texSrcSlice = srcSlice;
@@ -894,39 +807,18 @@ void VulkanRenderer::surfaceCopy_copySurfaceWithFormatConversion(LatteTexture* s
 	// todo - if not, we have to use drawcall based copying
 	if (!LatteTexture_doesEffectiveRescaleRatioMatch(srcTextureVk, texSrcMip, dstTextureVk, texDstMip))
 	{
-		forceLogDebug_printf("surfaceCopy_copySurfaceViaDrawcall(): Mismatching dimensions");
+		cemuLog_logDebug(LogType::Force, "surfaceCopy_copySurfaceViaDrawcall(): Mismatching dimensions");
 		return;
 	}
 
 	// check if bpp size matches
 	if (srcTextureVk->GetBPP() != dstTextureVk->GetBPP())
 	{
-		forceLogDebug_printf("surfaceCopy_copySurfaceViaDrawcall(): Mismatching BPP");
+		cemuLog_logDebug(LogType::Force, "surfaceCopy_copySurfaceViaDrawcall(): Mismatching BPP");
 		return;
 	}
 
-	VkFormat srcFormatVk = srcTextureVk->GetFormat();
-	VkFormat dstFormatVk = dstTextureVk->GetFormat();
-
-	if ((srcTextureVk->isDepth && !dstTextureVk->isDepth) ||
-		!srcTextureVk->isDepth && dstTextureVk->isDepth)
-	{
-		// depth to color or
-		// color to depth
-		if (m_featureControl.mode.useBufferSurfaceCopies && vkIsBitCompatibleColorDepthFormat(srcFormatVk, dstFormatVk))
-			surfaceCopy_viaBuffer(srcTextureVk, texSrcMip, texSrcSlice, dstTextureVk, texDstMip, texDstSlice, effectiveCopyWidth, effectiveCopyHeight);
-		else
-			surfaceCopy_viaDrawcall(srcTextureVk, texSrcMip, texSrcSlice, dstTextureVk, texDstMip, texDstSlice, effectiveCopyWidth, effectiveCopyHeight);
-	}
-	else
-	{
-		// depth to depth or
-		// color to color
-		if (m_featureControl.mode.useBufferSurfaceCopies && srcFormatVk == dstFormatVk)
-			surfaceCopy_viaBuffer(srcTextureVk, texSrcMip, texSrcSlice, dstTextureVk, texDstMip, texDstSlice, effectiveCopyWidth, effectiveCopyHeight);
-		else
-			surfaceCopy_viaDrawcall(srcTextureVk, texSrcMip, texSrcSlice, dstTextureVk, texDstMip, texDstSlice, effectiveCopyWidth, effectiveCopyHeight);
-	}
+	surfaceCopy_viaDrawcall(srcTextureVk, texSrcMip, texSrcSlice, dstTextureVk, texDstMip, texDstSlice, effectiveCopyWidth, effectiveCopyHeight);
 }
 
 // called whenever a texture is destroyed
@@ -944,9 +836,9 @@ void VulkanRenderer::surfaceCopy_notifyTextureRelease(LatteTextureVk* hostTextur
 			{
 				if (p)
 				{
-					VulkanRenderer::GetInstance()->releaseDestructibleObject(p->vkObjDescriptorSet);
+					VulkanRenderer::GetInstance()->ReleaseDestructibleObject(p->vkObjDescriptorSet);
 					p->vkObjDescriptorSet = nullptr;
-					VulkanRenderer::GetInstance()->releaseDestructibleObject(p->vkObjImageView);
+					VulkanRenderer::GetInstance()->ReleaseDestructibleObject(p->vkObjImageView);
 					p->vkObjImageView = nullptr;
 				}
 			}
@@ -960,9 +852,9 @@ void VulkanRenderer::surfaceCopy_notifyTextureRelease(LatteTextureVk* hostTextur
 			{
 				if (p)
 				{
-					VulkanRenderer::GetInstance()->releaseDestructibleObject(p->vkObjFramebuffer);
+					VulkanRenderer::GetInstance()->ReleaseDestructibleObject(p->vkObjFramebuffer);
 					p->vkObjFramebuffer = nullptr;
-					VulkanRenderer::GetInstance()->releaseDestructibleObject(p->vkObjImageView);
+					VulkanRenderer::GetInstance()->ReleaseDestructibleObject(p->vkObjImageView);
 					p->vkObjImageView = nullptr;
 				}
 			}
@@ -973,5 +865,9 @@ void VulkanRenderer::surfaceCopy_notifyTextureRelease(LatteTextureVk* hostTextur
 
 void VulkanRenderer::surfaceCopy_cleanup()
 {
-	// todo - release m_copySurfacePipelineCache etc
+	for(auto& i : m_copySurfacePipelineCache)
+	{
+		delete i.second;
+	}
+	m_copySurfacePipelineCache = {};
 }
diff --git a/src/Cafe/HW/MMU/MMU.cpp b/src/Cafe/HW/MMU/MMU.cpp
index 87bf5722..f88c3d0d 100644
--- a/src/Cafe/HW/MMU/MMU.cpp
+++ b/src/Cafe/HW/MMU/MMU.cpp
@@ -103,7 +103,7 @@ void MMURange::mapMem()
 
 void MMURange::unmapMem()
 {
-	cemu_assert_debug(false);
+    MemMapper::FreeMemory(memory_base + baseAddress, size, true);
 	m_isMapped = false;
 }
 
@@ -196,6 +196,15 @@ void memory_mapForCurrentTitle()
 	}
 }
 
+void memory_unmapForCurrentTitle()
+{
+    for (auto& itr : g_mmuRanges)
+    {
+        if (itr->isMapped() && !itr->isMappedEarly())
+            itr->unmapMem();
+    }
+}
+
 void memory_logModifiedMemoryRanges()
 {
 	auto gfxPackMappings = GraphicPack2::GetActiveRAMMappings();
@@ -293,11 +302,6 @@ uint8* memory_getPointerFromVirtualOffsetAllowNull(uint32 virtualOffset)
 	return memory_getPointerFromVirtualOffset(virtualOffset);
 }
 
-void memory_writeU32Direct(uint32 address, uint32 v)
-{
-	*(uint32*)(memory_getPointerFromVirtualOffset(address)) = CPU_swapEndianU32(v);
-}
-
 // write access
 void memory_writeDouble(uint32 address, double vf)
 {
@@ -320,12 +324,6 @@ void memory_writeU32(uint32 address, uint32 v)
 	*(uint32*)(memory_getPointerFromVirtualOffset(address)) = CPU_swapEndianU32(v);
 }
 
-void memory_writeU64Slow(uint32 address, uint64 v)
-{
-	memory_writeU32(address+0, (v>>32)&0xFFFFFFFF);
-	memory_writeU32(address+4, (v)&0xFFFFFFFF);
-}
-
 void memory_writeU64(uint32 address, uint64 v)
 {
 	*(uint64*)(memory_getPointerFromVirtualOffset(address)) = CPU_swapEndianU64(v);
@@ -372,12 +370,6 @@ uint32 memory_readU32(uint32 address)
 	return CPU_swapEndianU32(v);
 }
 
-uint32 memory_readU32Direct(uint32 address)
-{
-	uint32 v = *(uint32*)(memory_getPointerFromVirtualOffset(address));
-	return CPU_swapEndianU32(v);
-}
-
 uint16 memory_readU16(uint32 address)
 {
 	uint16 v = *(uint16*)(memory_getPointerFromVirtualOffset(address));
@@ -409,7 +401,7 @@ void memory_writeDumpFile(uint32 startAddr, uint32 size, const fs::path& path)
 void memory_createDump()
 {
 	const uint32 pageSize = MemMapper::GetPageSize();
-	fs::path path = ActiveSettings::GetPath("dump/ramDump{:}", (uint32)time(nullptr));
+	fs::path path = ActiveSettings::GetUserDataPath("dump/ramDump{:}", (uint32)time(nullptr));
 	fs::create_directories(path);
 
 	for (auto& itr : g_mmuRanges)
@@ -487,7 +479,7 @@ namespace MMU
 		auto itr = g_mmioHandlerW32->find(address);
 		if (itr == g_mmioHandlerW32->end())
 		{
-			//forceLogDebug_printf("[MMU] MMIO write u32 0x%08x from unhandeled address 0x%08x", value, address);
+			//cemuLog_logDebug(LogType::Force, "[MMU] MMIO write u32 0x{:08x} from unhandled address 0x{:08x}", value, address);
 			return;
 		}
 		return itr->second(address, value);
@@ -499,7 +491,7 @@ namespace MMU
 		auto itr = g_mmioHandlerW16->find(address);
 		if (itr == g_mmioHandlerW16->end())
 		{
-			//forceLogDebug_printf("[MMU] MMIO write u16 0x%04x from unhandeled address 0x%08x", (uint32)value, address);
+			//cemuLog_logDebug(LogType::Force, "[MMU] MMIO write u16 0x{:04x} from unhandled address 0x{:08x}", (uint32)value, address);
 			return;
 		}
 		return itr->second(address, value);
@@ -508,13 +500,13 @@ namespace MMU
 
 	// todo - instead of passing the physical address to Read/WriteMMIO we should pass an interface id and a relative address? This would allow remapping the hardware address (tho we can just unregister + register at different addresses)
 
-	uint16 ReadMMIO_32(PAddr address)
+	uint32 ReadMMIO_32(PAddr address)
 	{
 		cemu_assert_debug((address & 0x3) == 0);
 		auto itr = g_mmioHandlerR32->find(address);
 		if(itr == g_mmioHandlerR32->end())
 		{
-			//forceLogDebug_printf("[MMU] MMIO read u32 from unhandeled address 0x%08x", address);
+			//cemuLog_logDebug(LogType::Force, "[MMU] MMIO read u32 from unhandled address 0x{:08x}", address);
 			return 0;
 		}
 		return itr->second(address);
@@ -526,11 +518,11 @@ namespace MMU
 		auto itr = g_mmioHandlerR16->find(address);
 		if (itr == g_mmioHandlerR16->end())
 		{
-			//forceLogDebug_printf("[MMU] MMIO read u16 from unhandeled address 0x%08x", address);
+			//cemuLog_logDebug(LogType::Force, "[MMU] MMIO read u16 from unhandled address 0x{:08x}", address);
 			return 0;
 		}
 		return itr->second(address);
 	}
 
 
-}
\ No newline at end of file
+}
diff --git a/src/Cafe/HW/MMU/MMU.h b/src/Cafe/HW/MMU/MMU.h
index 0e27d81a..a8367f88 100644
--- a/src/Cafe/HW/MMU/MMU.h
+++ b/src/Cafe/HW/MMU/MMU.h
@@ -2,6 +2,7 @@
 
 void memory_init();
 void memory_mapForCurrentTitle();
+void memory_unmapForCurrentTitle();
 void memory_logModifiedMemoryRanges();
 
 void memory_enableOverlayArena();
@@ -15,7 +16,7 @@ uint8* memory_getPointerFromPhysicalOffset(uint32 physicalOffset);
 uint32 memory_virtualToPhysical(uint32 virtualOffset);
 uint32 memory_physicalToVirtual(uint32 physicalOffset);
 
-extern uint8* memory_base; // points to 0x00000000
+extern uint8* memory_base; // points to base of PowerPC address space
 
 enum class MMU_MEM_AREA_ID
 {
@@ -138,8 +139,6 @@ MMURange* memory_getMMURangeByAddress(MPTR address);
 
 bool memory_isAddressRangeAccessible(MPTR virtualAddress, uint32 size);
 
-#define MEMORY_PAGE_SIZE					(0x20000)
-
 #define MEMORY_CODELOW0_ADDR				(0x00010000)
 #define MEMORY_CODELOW0_SIZE				(0x000F0000) // ~1MB
 
@@ -158,27 +157,11 @@ bool memory_isAddressRangeAccessible(MPTR virtualAddress, uint32 size);
 #define MEMORY_FGBUCKET_AREA_ADDR			(0xE0000000) // actual offset is 0xE0000000 according to PPC kernel
 #define MEMORY_FGBUCKET_AREA_SIZE			(0x04000000) // 64MB split up into multiple subareas, size is verified with value from PPC kernel
 
-// move these to rpl loader
-#define MEMORY_SDA_SIZE						(0x10000)
-#define MEMORY_SDA2_SIZE					(0x10000)
-
-//#define MEMORY_SYSTEM_AREA_ADDR				(0x90000000)
-//#define MEMORY_SYSTEM_AREA_SIZE				(0x02000000) // 32MB of memory area that can't be allocated by the game directly - this is emulator specific.
-
-//#define MEMORY_SYSTEM_AREA_ADDR				(0x7C000000)
-//#define MEMORY_SYSTEM_AREA_SIZE				(0x02000000) // 32MB of memory area that can't be allocated by the game directly - this is emulator specific.
-// moved the sys area below 0x80000000. Turns out that some games treat stack/os-object pointers as signed and run into issues if the highest bit is set (e.g. Monster Hunter Frontier G)
-
 #define MEMORY_TILINGAPERTURE_AREA_ADDR		(0xE8000000)
 #define MEMORY_TILINGAPERTURE_AREA_SIZE		(0x02000000) // 32MB
 
 #define MEMORY_OVERLAY_AREA_OFFSET			(0xA0000000)
-#define MEMORY_OVERLAY_AREA_SIZE			(448*1024*1024) // 448MB (todo: verify if correct)
-
-#define MEMORY_MAPABLE_PHYS_AREA_OFFSET		(0x80000000) // todo: verify offset
-#define MEMORY_MAPABLE_PHYS_AREA_SIZE		(32*1024*1024) // todo: verify size
-#define MEMORY_MAPABLE_VIRT_AREA_OFFSET		(0x70000000) // todo: verify offset
-#define MEMORY_MAPABLE_VIRT_AREA_SIZE		(32*1024*1024) // todo: verify size
+#define MEMORY_OVERLAY_AREA_SIZE			(448*1024*1024) // 448MB (recycled background app memory)
 
 #define MEMORY_MEM1_AREA_ADDR				(0xF4000000)
 #define MEMORY_MEM1_AREA_SIZE				(0x02000000) // 32MB
@@ -189,34 +172,26 @@ bool memory_isAddressRangeAccessible(MPTR virtualAddress, uint32 size);
 #define MEMORY_SHAREDDATA_AREA_ADDR			(0xF8000000)
 #define MEMORY_SHAREDDATA_AREA_SIZE			(0x02000000) // 32MB
 
-static uint16 CPU_swapEndianU16(uint16 v)
-{
-	//return _byteswap_ushort(v);
-	return (v>>8)|(v<<8);
-}
-
 #if BOOST_OS_WINDOWS
 #define CPU_swapEndianU64(_v) _byteswap_uint64((uint64)(_v))
 #define CPU_swapEndianU32(_v) _byteswap_ulong((uint32)(_v))
+#define CPU_swapEndianU16(_v) _byteswap_ushort((uint16)(_v))
 #elif BOOST_OS_LINUX
 #define CPU_swapEndianU64(_v) bswap_64((uint64)(_v))
 #define CPU_swapEndianU32(_v) bswap_32((uint32)(_v))
+#define CPU_swapEndianU16(_v) bswap_16((uint16)(_v))
 #elif BOOST_OS_MACOS
 #define CPU_swapEndianU64(_v) OSSwapInt64((uint64)(_v))
 #define CPU_swapEndianU32(_v) OSSwapInt32((uint32)(_v))
+#define CPU_swapEndianU16(_v) OSSwapInt16((uint16)(_v))
 #endif
 
-// direct memory access (no hardware interface access)
-void memory_writeU32Direct(uint32 address, uint32 v);
-uint32 memory_readU32Direct(uint32 address);
-
-// memory access (includes hardware interface, slower)
+// C-style memory access, deprecated. Use memory_read<> and memory_write<> templates instead
 void memory_writeDouble(uint32 address, double vf);
 void memory_writeFloat(uint32 address, float vf);
 void memory_writeU32(uint32 address, uint32 v);
 void memory_writeU16(uint32 address, uint16 v);
 void memory_writeU8(uint32 address, uint8 v);
-void memory_writeU64Slow(uint32 address, uint64 v);
 void memory_writeU64(uint32 address, uint64 v);
 
 double memory_readDouble(uint32 address);
@@ -229,43 +204,24 @@ uint8 memory_readU8(uint32 address);
 void memory_createDump();
 
 template<size_t count>
-void memory_readBytes(uint32 address, std::array<uint8, count>& buffer)
+void memory_readBytes(VAddr address, std::array<uint8, count>& buffer)
 {
 	memcpy(buffer.data(), memory_getPointerFromVirtualOffset(address), count);
 }
 
-template <typename T> T memory_read(uint32 address)
+template <typename T> inline T memory_read(VAddr address)
 {
-	if constexpr(std::is_floating_point<T>::value)
-	{
-		if constexpr(sizeof(T) == sizeof(float))
-			return memory_readFloat(address);
-		else
-			return memory_readDouble(address);
-	}
-	else if(std::is_integral<T>::value)
-	{
-		if constexpr (sizeof(T) == sizeof(uint8))
-			return (T)memory_readU8(address);
-		else if constexpr (sizeof(T) == sizeof(uint16))
-			return (T)memory_readU16(address);
-		else if constexpr (sizeof(T) == sizeof(uint32))
-			return (T)memory_readU32(address);
-		else if constexpr (sizeof(T) == sizeof(uint64))
-			return (T)memory_readU64(address);
-	}
+	return *(betype<T>*)(memory_base + address);
+}
 
-	debugBreakpoint(); 
-	return {};
+template <typename T> inline void memory_write(VAddr address, T value)
+{
+	*(betype<T>*)(memory_base + address) = value;
 }
 
 // LLE implementation
 void memory_initPhysicalLayout();
 
-// updated code
-using EAddr = uint32; // effective address
-using PAddr = uint32; // physical address
-
 namespace MMU
 {
 	using MMIOFuncWrite32 = void (*)(PAddr addr, uint32 value);
@@ -305,7 +261,9 @@ namespace MMU
 
 	void WriteMMIO_32(PAddr address, uint32 value);
 	void WriteMMIO_16(PAddr address, uint16 value);
-	uint16 ReadMMIO_32(PAddr address);
+	uint32 ReadMMIO_32(PAddr address);
 	uint16 ReadMMIO_16(PAddr address);
 
-}
\ No newline at end of file
+}
+
+#define MMU_IsInPPCMemorySpace(__ptr) ((const uint8*)(__ptr) >= memory_base && (const uint8*)(__ptr) < (memory_base + 0x100000000))
\ No newline at end of file
diff --git a/src/Cafe/HW/SI/SI.cpp b/src/Cafe/HW/SI/SI.cpp
index e36bd868..026543d8 100644
--- a/src/Cafe/HW/SI/SI.cpp
+++ b/src/Cafe/HW/SI/SI.cpp
@@ -87,7 +87,6 @@ namespace HW_SI
 
 	HWREG::SICOMCSR SI_COMCSR_R32(PAddr addr)
 	{
-		//forceLogDebug_printf("Read SICOMCSR");
 		return g_si.registerState.sicomcsr;
 	}
 
diff --git a/src/Cafe/IOSU/ODM/iosu_odm.cpp b/src/Cafe/IOSU/ODM/iosu_odm.cpp
new file mode 100644
index 00000000..aae3c503
--- /dev/null
+++ b/src/Cafe/IOSU/ODM/iosu_odm.cpp
@@ -0,0 +1,157 @@
+#include <util/helpers/helpers.h>
+#include "iosu_odm.h"
+#include "config/ActiveSettings.h"
+#include "Common/FileStream.h"
+#include "util/helpers/Semaphore.h"
+#include "../kernel/iosu_kernel.h"
+
+namespace iosu
+{
+	namespace odm
+	{
+		using namespace iosu::kernel;
+
+		std::string s_devicePath = "/dev/odm";
+		std::thread s_serviceThread;
+		std::atomic_bool s_requestStop{false};
+		std::atomic_bool s_isRunning{false};
+		std::atomic_bool s_threadInitialized{ false };
+
+		IOSMsgQueueId s_msgQueueId;
+		SysAllocator<iosu::kernel::IOSMessage, 128> _s_msgBuffer;
+
+		enum class ODM_CMD_OPERATION_TYPE
+		{
+			CHECK_STATE = 4,
+			UKN_5 = 5,
+		};
+
+		enum class ODM_STATE
+		{
+			NONE = 0,
+			INITIAL = 1,
+			AUTHENTICATION = 2,
+			WAIT_FOR_DISC_READY = 3,
+			CAFE_DISC = 4,
+			RVL_DISC = 5,
+			CLEANING_DISC = 6,
+			INVALID_DISC = 8,
+			DIRTY_DISC = 9,
+			NO_DISC = 10,
+			INVALID_DRIVE = 11,
+			FATAL = 12,
+			HARD_FATAL = 13,
+			SHUTDOWN = 14,
+		};
+
+		void ODMHandleCommandIoctl(uint32 clientHandle, IPCCommandBody* cmd, ODM_CMD_OPERATION_TYPE operationId, void* ptrIn, uint32 sizeIn, void* ptrOut, uint32 sizeOut)
+		{
+			switch(operationId)
+			{
+				case ODM_CMD_OPERATION_TYPE::CHECK_STATE:
+				{
+					*(uint32be*)ptrOut = (uint32)ODM_STATE::NO_DISC;
+					break;
+				}
+				case ODM_CMD_OPERATION_TYPE::UKN_5:
+				{
+					// does this return anything?
+					break;
+				}
+				default:
+				{
+					cemuLog_log(LogType::Force, "ODMHandleCommandIoctl: Unknown operationId %d\n", (uint32)operationId);
+					break;
+				}
+			}
+
+			IOS_ResourceReply(cmd, IOS_ERROR_OK);
+		}
+
+		uint32 CreateClientHandle()
+		{
+			return 1; // we dont care about handles for now
+		}
+
+		void CloseClientHandle(uint32 handle)
+		{
+
+		}
+
+		void ODMServiceThread()
+		{
+			SetThreadName("ODMService");
+			s_msgQueueId = IOS_CreateMessageQueue(_s_msgBuffer.GetPtr(), _s_msgBuffer.GetCount());
+			cemu_assert(!IOS_ResultIsError((IOS_ERROR)s_msgQueueId));
+			IOS_ERROR r = IOS_RegisterResourceManager(s_devicePath.c_str(), s_msgQueueId);
+			cemu_assert(!IOS_ResultIsError(r));
+			s_threadInitialized = true;
+			while (true)
+			{
+				IOSMessage msg;
+				IOS_ERROR r = IOS_ReceiveMessage(s_msgQueueId, &msg, 0);
+				cemu_assert(!IOS_ResultIsError(r));
+				if (msg == 0)
+				{
+					cemu_assert_debug(s_requestStop);
+					break;
+				}
+				IPCCommandBody* cmd = MEMPTR<IPCCommandBody>(msg).GetPtr();
+				uint32 clientHandle = (uint32)cmd->devHandle;
+				if (cmd->cmdId == IPCCommandId::IOS_OPEN)
+				{
+					IOS_ResourceReply(cmd, (IOS_ERROR)CreateClientHandle());
+					continue;
+				}
+				else if (cmd->cmdId == IPCCommandId::IOS_CLOSE)
+				{
+					CloseClientHandle((IOSDevHandle)(uint32)cmd->devHandle);
+					IOS_ResourceReply(cmd, IOS_ERROR_OK);
+					continue;
+				}
+				else if (cmd->cmdId == IPCCommandId::IOS_IOCTLV)
+				{
+					uint32 requestId = cmd->args[0];
+					uint32 numIn = cmd->args[1];
+					uint32 numOut = cmd->args[2];
+					IPCIoctlVector* vec = MEMPTR<IPCIoctlVector>{ cmd->args[3] }.GetPtr();
+					IPCIoctlVector* vecIn = vec + numIn;
+					IPCIoctlVector* vecOut = vec + 0;
+					cemuLog_log(LogType::Force, "{}: Received unsupported Ioctlv cmd", s_devicePath);
+					IOS_ResourceReply(cmd, IOS_ERROR_INVALID);
+					continue;
+				}
+				else if (cmd->cmdId == IPCCommandId::IOS_IOCTL)
+				{
+					ODMHandleCommandIoctl(clientHandle, cmd, (ODM_CMD_OPERATION_TYPE)cmd->args[0].value(), MEMPTR<void>(cmd->args[1]), cmd->args[2], MEMPTR<void>(cmd->args[3]), cmd->args[4]);
+				}
+				else
+				{
+					cemuLog_log(LogType::Force, "{}: Unsupported cmdId", s_devicePath);
+					cemu_assert_unimplemented();
+					IOS_ResourceReply(cmd, IOS_ERROR_INVALID);
+				}
+			}
+			s_threadInitialized = false;
+		}
+
+		void Initialize()
+		{
+			if (s_isRunning.exchange(true))
+				return;
+			s_threadInitialized = false;
+			s_requestStop = false;
+			s_serviceThread = std::thread(&ODMServiceThread);
+			while (!s_threadInitialized) std::this_thread::sleep_for(std::chrono::milliseconds(10));
+		}
+
+		void Shutdown()
+		{
+			if (!s_isRunning.exchange(false))
+				return;
+			s_requestStop = true;
+			IOS_SendMessage(s_msgQueueId, 0, 0);
+			s_serviceThread.join();
+		}
+	}
+}
diff --git a/src/Cafe/IOSU/ODM/iosu_odm.h b/src/Cafe/IOSU/ODM/iosu_odm.h
new file mode 100644
index 00000000..f5f721a1
--- /dev/null
+++ b/src/Cafe/IOSU/ODM/iosu_odm.h
@@ -0,0 +1,10 @@
+#pragma once
+
+namespace iosu
+{
+	namespace odm
+	{
+		void Initialize();
+		void Shutdown();
+	}
+}
\ No newline at end of file
diff --git a/src/Cafe/IOSU/PDM/iosu_pdm.cpp b/src/Cafe/IOSU/PDM/iosu_pdm.cpp
index 89be4de2..b9dda445 100644
--- a/src/Cafe/IOSU/PDM/iosu_pdm.cpp
+++ b/src/Cafe/IOSU/PDM/iosu_pdm.cpp
@@ -1,4 +1,6 @@
+#include <util/helpers/helpers.h>
 #include "iosu_pdm.h"
+#include "Cafe/CafeSystem.h"
 #include "config/ActiveSettings.h"
 #include "Common/FileStream.h"
 #include "util/helpers/Semaphore.h"
@@ -17,7 +19,8 @@ namespace iosu
 {
 	namespace pdm
 	{
-		std::mutex sDiaryLock;
+		std::recursive_mutex sPlaystatsLock;
+		std::recursive_mutex sDiaryLock;
 
 		fs::path GetPDFile(const char* filename)
 		{
@@ -80,14 +83,16 @@ namespace iosu
 			static_assert((NUM_PLAY_STATS_ENTRIES * sizeof(PlayStatsEntry)) == 0x1400);
 		}
 
-		void LoadPlaystats()
+		void OpenPlaystats()
 		{
+			std::unique_lock _l(sPlaystatsLock);
 			PlayStats.numEntries = 0;
 			for (size_t i = 0; i < NUM_PLAY_STATS_ENTRIES; i++)
 			{
 				auto& e = PlayStats.entry[i];
 				memset(&e, 0, sizeof(PlayStatsEntry));
 			}
+			cemu_assert_debug(!PlayStats.fs);
 			PlayStats.fs = FileStream::openFile2(GetPDFile("PlayStats.dat"), true);
 			if (!PlayStats.fs)
 			{
@@ -98,18 +103,39 @@ namespace iosu
 			{
 				delete PlayStats.fs;
 				PlayStats.fs = nullptr;
-				cemuLog_log(LogType::Force, "PlayStats.dat malformed");
+				cemuLog_log(LogType::Force, "PlayStats.dat malformed. Time tracking wont be used");
 				// dont delete the existing file in case it could still be salvaged (todo) and instead just dont track play time
 				return;
 			}
+			PlayStats.numEntries = 0;
 			PlayStats.fs->readData(&PlayStats.numEntries, sizeof(uint32be));
 			if (PlayStats.numEntries > NUM_PLAY_STATS_ENTRIES)
 				PlayStats.numEntries = NUM_PLAY_STATS_ENTRIES;
 			PlayStats.fs->readData(PlayStats.entry, NUM_PLAY_STATS_ENTRIES * 20);
 		}
 
+		void ClosePlaystats()
+		{
+			std::unique_lock _l(sPlaystatsLock);
+			if (PlayStats.fs)
+			{
+				delete PlayStats.fs;
+				PlayStats.fs = nullptr;
+			}
+		}
+
+		void UnloadPlaystats()
+		{
+			std::unique_lock _l(sPlaystatsLock);
+			cemu_assert_debug(!PlayStats.fs); // unloading expects that file is closed
+			PlayStats.numEntries = 0;
+			for(auto& it : PlayStats.entry)
+				it = PlayStatsEntry{};
+		}
+
 		PlayStatsEntry* PlayStats_GetEntry(uint64 titleId)
 		{
+			std::unique_lock _l(sPlaystatsLock);
 			uint32be titleIdHigh = (uint32)(titleId>>32);
 			uint32be titleIdLow = (uint32)(titleId & 0xFFFFFFFF);
 			size_t numEntries = PlayStats.numEntries;
@@ -121,7 +147,7 @@ namespace iosu
 			return nullptr;
 		}
 
-		void PlayStats_WriteEntry(PlayStatsEntry* entry, bool writeEntryCount = false)
+		void PlayStats_WriteEntryNoLock(PlayStatsEntry* entry, bool writeEntryCount = false)
 		{
 			if (!PlayStats.fs)
 				return;
@@ -141,8 +167,15 @@ namespace iosu
 			}
 		}
 
+		void PlayStats_WriteEntry(PlayStatsEntry* entry, bool writeEntryCount = false)
+		{
+			std::unique_lock _l(sPlaystatsLock);
+			PlayStats_WriteEntryNoLock(entry, writeEntryCount);
+		}
+
 		PlayStatsEntry* PlayStats_CreateEntry(uint64 titleId)
 		{
+			std::unique_lock _l(sPlaystatsLock);
 			bool entryCountChanged = false;
 			PlayStatsEntry* newEntry;
 			if(PlayStats.numEntries < NUM_PLAY_STATS_ENTRIES)
@@ -168,7 +201,7 @@ namespace iosu
 			newEntry->numTimesLaunched = 1;
 			newEntry->totalMinutesPlayed = 0;
 			newEntry->ukn12 = 0;
-			PlayStats_WriteEntry(newEntry, entryCountChanged);
+			PlayStats_WriteEntryNoLock(newEntry, entryCountChanged);
 			return newEntry;
 		}
 
@@ -176,6 +209,7 @@ namespace iosu
 		// if it does not exist it creates a new entry with first and last played set to today
 		PlayStatsEntry* PlayStats_BeginNewTracking(uint64 titleId)
 		{
+			std::unique_lock _l(sPlaystatsLock);
 			PlayStatsEntry* entry = PlayStats_GetEntry(titleId);
 			if (entry)
 			{
@@ -189,11 +223,12 @@ namespace iosu
 
 		void PlayStats_CountAdditionalMinutes(PlayStatsEntry* entry, uint32 additionalMinutes)
 		{
+			std::unique_lock _l(sPlaystatsLock);
 			if (additionalMinutes == 0)
 				return;
 			entry->totalMinutesPlayed += additionalMinutes;
 			entry->mostRecentDayIndex = GetTodaysDayIndex();
-			PlayStats_WriteEntry(entry);
+			PlayStats_WriteEntryNoLock(entry);
 		}
 
 		struct PlayDiaryHeader
@@ -218,6 +253,7 @@ namespace iosu
 		void CreatePlayDiary()
 		{
 			MakeDirectory();
+			cemu_assert_debug(!PlayDiaryData.fs);
 			PlayDiaryData.fs = FileStream::createFile2(GetPDFile("PlayDiary.dat"));
 			if (!PlayDiaryData.fs)
 			{
@@ -230,7 +266,7 @@ namespace iosu
 				PlayDiaryData.fs->writeData(&PlayDiaryData.header, sizeof(PlayDiaryHeader));
 		}
 
-		void LoadPlayDiary()
+		void OpenPlayDiary()
 		{
 			std::unique_lock _lock(sDiaryLock);
 			cemu_assert_debug(!PlayDiaryData.fs);
@@ -268,6 +304,26 @@ namespace iosu
 			}
 		}
 
+		void ClosePlayDiary()
+		{
+			std::unique_lock _lock(sDiaryLock);
+			if (PlayDiaryData.fs)
+			{
+				delete PlayDiaryData.fs;
+				PlayDiaryData.fs = nullptr;
+			}
+		}
+
+		void UnloadDiaryData()
+		{
+			std::unique_lock _lock(sDiaryLock);
+			cemu_assert_debug(!PlayDiaryData.fs); // unloading expects that file is closed
+			PlayDiaryData.header.readIndex = 0;
+			PlayDiaryData.header.writeIndex = 0;
+			for (auto& it : PlayDiaryData.entry)
+				it = PlayDiaryEntry{};
+		}
+
 		uint32 GetDiaryEntries(uint8 accountSlot, PlayDiaryEntry* diaryEntries, uint32 maxEntries)
 		{
 			std::unique_lock _lock(sDiaryLock);
@@ -332,6 +388,7 @@ namespace iosu
 
 		void TimeTrackingThread(uint64 titleId)
 		{
+			SetThreadName("PlayDiaryThread");
 			PlayStatsEntry* playStatsEntry = PlayStats_BeginNewTracking(titleId);
 
 			auto startTime = std::chrono::steady_clock::now();
@@ -352,25 +409,89 @@ namespace iosu
 			}
 		}
 
-		void Initialize()
+		class : public ::IOSUModule
 		{
-			// todo - add support for per-account handling
-			LoadPlaystats();
-			LoadPlayDiary();
-		}
-		
-		void StartTrackingTime(uint64 titleId)
+			void PDMLoadAll()
+			{
+				OpenPlaystats();
+				OpenPlayDiary();
+			}
+
+			void PDMUnloadAll()
+			{
+				UnloadPlaystats();
+				UnloadDiaryData();
+			}
+
+			void PDMCloseAll()
+			{
+				ClosePlaystats();
+				ClosePlayDiary();
+			}
+
+			void SystemLaunch() override
+			{
+				// todo - add support for per-account handling
+				PDMLoadAll();
+				PDMCloseAll(); // close the files again, user may mess with MLC files or change MLC path while no game is running
+			}
+			void SystemExit() override
+			{
+				PDMCloseAll();
+				PDMUnloadAll();
+			}
+			void TitleStart() override
+			{
+				// reload data and keep files open
+				PDMUnloadAll();
+				PDMLoadAll();
+				auto titleId = CafeSystem::GetForegroundTitleId();
+				sPDMRequestExitThread = false;
+				sPDMTimeTrackingThread = std::thread(TimeTrackingThread, titleId);
+			}
+			void TitleStop() override
+			{
+				sPDMRequestExitThread.store(true);
+				sPDMSem.increment();
+				if(sPDMTimeTrackingThread.joinable())
+					sPDMTimeTrackingThread.join();
+				PDMCloseAll();
+			}
+		}sIOSUModuleNNPDM;
+
+		IOSUModule* GetModule()
 		{
-			sPDMRequestExitThread = false;
-			sPDMTimeTrackingThread = std::thread(TimeTrackingThread, titleId);
+			return static_cast<IOSUModule*>(&sIOSUModuleNNPDM);
 		}
 
-		void Stop()
+
+		bool GameListStat::LastPlayDate::operator<(const LastPlayDate& b) const
 		{
-			sPDMRequestExitThread.store(true);
-			sPDMSem.increment();
-			sPDMTimeTrackingThread.join();
+			const auto& a = *this;
+
+			if(a.year < b.year)
+				return true;
+			if(a.year > b.year)
+				return false;
+
+			// same year
+			if(a.month < b.month)
+				return true;
+			if(a.month > b.month)
+				return false;
+
+			// same year and month
+			return a.day < b.day;
 		}
 
+		bool GameListStat::LastPlayDate::operator==(const LastPlayDate& b) const
+		{
+			const auto& a = *this;
+			return a.year == b.year &&
+				   a.month == b.month &&
+				   a.day == b.day;
+		}
+		std::weak_ordering GameListStat::LastPlayDate::operator<=>(const LastPlayDate& b) const = default;
+
 	};
 };
diff --git a/src/Cafe/IOSU/PDM/iosu_pdm.h b/src/Cafe/IOSU/PDM/iosu_pdm.h
index fbafbc02..63f99a4a 100644
--- a/src/Cafe/IOSU/PDM/iosu_pdm.h
+++ b/src/Cafe/IOSU/PDM/iosu_pdm.h
@@ -1,13 +1,10 @@
 #pragma once
+#include "Cafe/IOSU/iosu_types_common.h"
 
 namespace iosu
 {
 	namespace pdm
 	{
-		void Initialize();
-		void StartTrackingTime(uint64 titleId);
-		void Stop();
-
 		inline constexpr size_t NUM_PLAY_STATS_ENTRIES = 256;
 		inline constexpr size_t NUM_PLAY_DIARY_ENTRIES_MAX = 18250; // 0x474A
 
@@ -24,15 +21,21 @@ namespace iosu
 		/* Helper for UI game list */
 		struct GameListStat
 		{
-			struct
+			struct LastPlayDate
 			{
 				uint32 year; // if 0 -> never played
 				uint32 month;
 				uint32 day;
+
+				bool operator<(const LastPlayDate& b) const;
+				bool operator==(const LastPlayDate& b) const;
+				std::weak_ordering operator<=>(const LastPlayDate& b) const;
 			}last_played;
 			uint32 numMinutesPlayed;
 		};
 
 		bool GetStatForGamelist(uint64 titleId, GameListStat& stat);
+
+		IOSUModule* GetModule();
 	};
 };
\ No newline at end of file
diff --git a/src/Cafe/IOSU/ccr_nfc/iosu_ccr_nfc.cpp b/src/Cafe/IOSU/ccr_nfc/iosu_ccr_nfc.cpp
new file mode 100644
index 00000000..1ceb16dc
--- /dev/null
+++ b/src/Cafe/IOSU/ccr_nfc/iosu_ccr_nfc.cpp
@@ -0,0 +1,406 @@
+#include "iosu_ccr_nfc.h"
+#include "Cafe/IOSU/kernel/iosu_kernel.h"
+#include "util/crypto/aes128.h"
+#include <openssl/evp.h>
+#include <openssl/hmac.h>
+
+namespace iosu
+{
+	namespace ccr_nfc
+	{
+		IOSMsgQueueId sCCRNFCMsgQueue;
+		SysAllocator<iosu::kernel::IOSMessage, 0x20> sCCRNFCMsgQueueMsgBuffer;
+		std::thread sCCRNFCThread;
+
+		constexpr uint8 sNfcKey[] = { 0xC1, 0x2B, 0x07, 0x10, 0xD7, 0x2C, 0xEB, 0x5D, 0x43, 0x49, 0xB7, 0x43, 0xE3, 0xCA, 0xD2, 0x24 };
+		constexpr uint8 sNfcKeyIV[] = { 0x4F, 0xD3, 0x9A, 0x6E, 0x79, 0xFC, 0xEA, 0xAD, 0x99, 0x90, 0x4D, 0xB8, 0xEE, 0x38, 0xE9, 0xDB };
+
+		constexpr uint8 sUnfixedInfosMagicBytes[] = { 0x00, 0x00, 0xDB, 0x4B, 0x9E, 0x3F, 0x45, 0x27, 0x8F, 0x39, 0x7E, 0xFF, 0x9B, 0x4F, 0xB9, 0x93 };
+		constexpr uint8 sLockedSecretMagicBytes[] = { 0xFD, 0xC8, 0xA0, 0x76, 0x94, 0xB8, 0x9E, 0x4C, 0x47, 0xD3, 0x7D, 0xE8, 0xCE, 0x5C, 0x74, 0xC1 };
+		constexpr uint8 sUnfixedInfosString[] = { 0x75, 0x6E, 0x66, 0x69, 0x78, 0x65, 0x64, 0x20, 0x69, 0x6E, 0x66, 0x6F, 0x73, 0x00, 0x00, 0x00 };
+		constexpr uint8 sLockedSecretString[] = { 0x6C, 0x6F, 0x63, 0x6B, 0x65, 0x64, 0x20, 0x73, 0x65, 0x63, 0x72, 0x65, 0x74, 0x00, 0x00, 0x00 };
+
+		constexpr uint8 sLockedSecretHmacKey[] = { 0x7F, 0x75, 0x2D, 0x28, 0x73, 0xA2, 0x00, 0x17, 0xFE, 0xF8, 0x5C, 0x05, 0x75, 0x90, 0x4B, 0x6D };
+		constexpr uint8 sUnfixedInfosHmacKey[] = { 0x1D, 0x16, 0x4B, 0x37, 0x5B, 0x72, 0xA5, 0x57, 0x28, 0xB9, 0x1D, 0x64, 0xB6, 0xA3, 0xC2, 0x05 };
+
+		uint8 sLockedSecretInternalKey[0x10];
+		uint8 sLockedSecretInternalNonce[0x10];
+		uint8 sLockedSecretInternalHmacKey[0x10];
+
+		uint8 sUnfixedInfosInternalKey[0x10];
+		uint8 sUnfixedInfosInternalNonce[0x10];
+		uint8 sUnfixedInfosInternalHmacKey[0x10];
+
+		sint32 __CCRNFCValidateCryptData(CCRNFCCryptData* data, uint32 size, bool validateOffsets)
+		{
+			if (!data)
+			{
+				return CCR_NFC_ERROR;
+			}
+
+			if (size != sizeof(CCRNFCCryptData))
+			{
+				return CCR_NFC_ERROR;
+			}
+
+			if (!validateOffsets)
+			{
+				return 0;
+			}
+
+			// Make sure all offsets are within bounds
+			if (data->version == 0)
+			{
+				if (data->unfixedInfosHmacOffset < 0x1C9 && data->unfixedInfosOffset < 0x1C9 &&
+					data->lockedSecretHmacOffset < 0x1C9 && data->lockedSecretOffset < 0x1C9 &&
+					data->lockedSecretSize < 0x1C9 && data->unfixedInfosSize < 0x1C9)
+				{
+					return 0;
+				}
+			}
+			else if (data->version == 2)
+			{
+				if (data->unfixedInfosHmacOffset < 0x21D && data->unfixedInfosOffset < 0x21D &&
+					data->lockedSecretHmacOffset < 0x21D && data->lockedSecretOffset < 0x21D &&
+					data->lockedSecretSize < 0x21D && data->unfixedInfosSize < 0x21D)
+				{
+					return 0;
+				}
+			}
+
+			return CCR_NFC_ERROR;
+		}
+
+		sint32 CCRNFCAESCTRCrypt(const uint8* key, const void* ivNonce, const void* inData, uint32 inSize, void* outData, uint32 outSize)
+		{
+			uint8 tmpIv[0x10];
+			memcpy(tmpIv, ivNonce, sizeof(tmpIv));
+
+			memcpy(outData, inData, inSize);
+			AES128CTR_transform((uint8*)outData, outSize, (uint8*)key, tmpIv);
+			return 0;
+		}
+
+		sint32 __CCRNFCGenerateKey(const uint8* hmacKey, uint32 hmacKeySize, const uint8* name, uint32 nameSize, const uint8* inData, uint32 inSize, uint8* outData, uint32 outSize)
+		{
+			if (nameSize != 0xe || outSize != 0x40)
+			{
+				return CCR_NFC_ERROR;
+			}
+
+   			// Create a buffer containing 2 counter bytes, the key name, and the key data
+			uint8 buffer[0x50];
+			buffer[0] = 0;
+			buffer[1] = 0;
+			memcpy(buffer + 2, name, nameSize);
+			memcpy(buffer + nameSize + 2, inData, inSize);
+
+			uint16 counter = 0;
+			while (outSize > 0)
+			{
+        		// Set counter bytes and increment counter
+				buffer[0] = (counter >> 8) & 0xFF;
+				buffer[1] = counter & 0xFF;
+				counter++;
+
+				uint32 dataSize = outSize;
+				if (!HMAC(EVP_sha256(), hmacKey, hmacKeySize, buffer, sizeof(buffer), outData, &dataSize))
+				{
+					return CCR_NFC_ERROR;
+				}
+
+				outSize -= 0x20;
+				outData += 0x20;
+			}
+
+			return 0;
+		}
+
+		sint32 __CCRNFCGenerateInternalKeys(const CCRNFCCryptData* in, const uint8* keyGenSalt)
+		{
+			uint8 lockedSecretBuffer[0x40] = { 0 };
+			uint8 unfixedInfosBuffer[0x40] = { 0 };
+			uint8 outBuffer[0x40] = { 0 };
+
+			// Fill the locked secret buffer
+			memcpy(lockedSecretBuffer, sLockedSecretMagicBytes, sizeof(sLockedSecretMagicBytes));
+			if (in->version == 0)
+			{
+				// For Version 0 this is the 16-byte Format Info
+				memcpy(lockedSecretBuffer + 0x10, in->data + in->uuidOffset, 0x10);
+			}
+			else if (in->version == 2)
+			{
+				// For Version 2 this is 2 times the 7-byte UID + 1 check byte
+				memcpy(lockedSecretBuffer + 0x10, in->data + in->uuidOffset, 8);
+				memcpy(lockedSecretBuffer + 0x18, in->data + in->uuidOffset, 8);
+			}
+			else
+			{
+				return CCR_NFC_ERROR;
+			}
+			// Append key generation salt
+			memcpy(lockedSecretBuffer + 0x20, keyGenSalt, 0x20);
+
+			// Generate the key output
+			sint32 res = __CCRNFCGenerateKey(sLockedSecretHmacKey, sizeof(sLockedSecretHmacKey), sLockedSecretString, 0xe, lockedSecretBuffer, sizeof(lockedSecretBuffer), outBuffer, sizeof(outBuffer));
+			if (res != 0)
+			{
+				return res;
+			}
+
+			// Unpack the key buffer
+			memcpy(sLockedSecretInternalKey, outBuffer, 0x10);
+			memcpy(sLockedSecretInternalNonce, outBuffer + 0x10, 0x10);
+			memcpy(sLockedSecretInternalHmacKey, outBuffer + 0x20, 0x10);
+
+			// Fill the unfixed infos buffer
+			memcpy(unfixedInfosBuffer, in->data + in->seedOffset, 2);
+			memcpy(unfixedInfosBuffer + 2, sUnfixedInfosMagicBytes + 2, 0xe);
+			if (in->version == 0)
+			{
+				// For Version 0 this is the 16-byte Format Info
+				memcpy(unfixedInfosBuffer + 0x10, in->data + in->uuidOffset, 0x10);
+			}
+			else if (in->version == 2)
+			{
+				// For Version 2 this is 2 times the 7-byte UID + 1 check byte
+				memcpy(unfixedInfosBuffer + 0x10, in->data + in->uuidOffset, 8);
+				memcpy(unfixedInfosBuffer + 0x18, in->data + in->uuidOffset, 8);
+			}
+			else
+			{
+				return CCR_NFC_ERROR;
+			}
+			// Append key generation salt
+			memcpy(unfixedInfosBuffer + 0x20, keyGenSalt, 0x20);
+
+			// Generate the key output
+			res = __CCRNFCGenerateKey(sUnfixedInfosHmacKey, sizeof(sUnfixedInfosHmacKey), sUnfixedInfosString, 0xe, unfixedInfosBuffer, sizeof(unfixedInfosBuffer), outBuffer, sizeof(outBuffer));
+			if (res != 0)
+			{
+				return res;
+			}
+
+			// Unpack the key buffer
+			memcpy(sUnfixedInfosInternalKey, outBuffer, 0x10);
+			memcpy(sUnfixedInfosInternalNonce, outBuffer + 0x10, 0x10);
+			memcpy(sUnfixedInfosInternalHmacKey, outBuffer + 0x20, 0x10);
+
+			return 0;
+		}
+
+		sint32 __CCRNFCCryptData(const CCRNFCCryptData* in, CCRNFCCryptData* out, bool decrypt)
+		{
+			// Decrypt key generation salt
+			uint8 keyGenSalt[0x20];
+			sint32 res = CCRNFCAESCTRCrypt(sNfcKey, sNfcKeyIV, in->data + in->keyGenSaltOffset, 0x20, keyGenSalt, sizeof(keyGenSalt));
+			if (res != 0)
+			{
+				return res;
+			}
+
+			// Prepare internal keys
+			res = __CCRNFCGenerateInternalKeys(in, keyGenSalt);
+			if (res != 0)
+			{
+				return res;
+			}
+
+			if (decrypt)
+			{
+				// Only version 0 tags have an encrypted locked secret area
+				if (in->version == 0)
+				{
+					res = CCRNFCAESCTRCrypt(sLockedSecretInternalKey, sLockedSecretInternalNonce, in->data + in->lockedSecretOffset, in->lockedSecretSize, out->data + in->lockedSecretOffset, in->lockedSecretSize);
+					if (res != 0)
+					{
+						return res;
+					}
+				}
+
+				// Decrypt unfxied infos
+				res = CCRNFCAESCTRCrypt(sUnfixedInfosInternalKey, sUnfixedInfosInternalNonce, in->data + in->unfixedInfosOffset, in->unfixedInfosSize, out->data + in->unfixedInfosOffset, in->unfixedInfosSize);
+				if (res != 0)
+				{
+					return res;
+				}
+
+				// Verify HMACs
+				uint8 hmacBuffer[0x20];
+				uint32 hmacLen = sizeof(hmacBuffer);
+
+				if (!HMAC(EVP_sha256(), sLockedSecretInternalHmacKey, sizeof(sLockedSecretInternalHmacKey), out->data + in->lockedSecretHmacOffset + 0x20, (in->dataSize - in->lockedSecretHmacOffset) - 0x20, hmacBuffer, &hmacLen))
+				{
+					return CCR_NFC_ERROR;
+				}
+
+				if (memcmp(in->data + in->lockedSecretHmacOffset, hmacBuffer, 0x20) != 0)
+				{
+					return CCR_NFC_INVALID_LOCKED_SECRET;
+				}
+
+				if (in->version == 0)
+				{
+					hmacLen = sizeof(hmacBuffer);
+					res = HMAC(EVP_sha256(), sUnfixedInfosInternalHmacKey, sizeof(sUnfixedInfosInternalHmacKey), out->data + in->unfixedInfosHmacOffset + 0x20, (in->dataSize - in->unfixedInfosHmacOffset) - 0x20, hmacBuffer, &hmacLen) ? 0 : CCR_NFC_ERROR;
+				}
+				else
+				{
+					hmacLen = sizeof(hmacBuffer);
+					res = HMAC(EVP_sha256(), sUnfixedInfosInternalHmacKey, sizeof(sUnfixedInfosInternalHmacKey), out->data + in->unfixedInfosHmacOffset + 0x21, (in->dataSize - in->unfixedInfosHmacOffset) - 0x21, hmacBuffer, &hmacLen) ? 0 : CCR_NFC_ERROR;
+				}
+
+				if (memcmp(in->data + in->unfixedInfosHmacOffset, hmacBuffer, 0x20) != 0)
+				{
+					return CCR_NFC_INVALID_UNFIXED_INFOS;
+				}
+			}
+			else
+			{
+				uint8 hmacBuffer[0x20];
+				uint32 hmacLen = sizeof(hmacBuffer);
+
+				if (!HMAC(EVP_sha256(), sLockedSecretInternalHmacKey, sizeof(sLockedSecretInternalHmacKey), out->data + in->lockedSecretHmacOffset + 0x20, (in->dataSize - in->lockedSecretHmacOffset) - 0x20, hmacBuffer, &hmacLen))
+				{
+					return CCR_NFC_ERROR;
+				}
+
+				if (memcmp(in->data + in->lockedSecretHmacOffset, hmacBuffer, 0x20) != 0)
+				{
+					return CCR_NFC_INVALID_LOCKED_SECRET;
+				}
+
+				// Only version 0 tags have an encrypted locked secret area
+				if (in->version == 0)
+				{
+					uint32 hmacLen = 0x20;
+					if (!HMAC(EVP_sha256(), sUnfixedInfosInternalHmacKey, sizeof(sUnfixedInfosInternalHmacKey), out->data + in->unfixedInfosHmacOffset + 0x20, (in->dataSize - in->unfixedInfosHmacOffset) - 0x20, out->data + in->unfixedInfosHmacOffset, &hmacLen))
+					{
+						return CCR_NFC_ERROR;
+					}
+
+					res = CCRNFCAESCTRCrypt(sLockedSecretInternalKey, sLockedSecretInternalNonce, in->data + in->lockedSecretOffset, in->lockedSecretSize, out->data + in->lockedSecretOffset, in->lockedSecretSize);
+					if (res != 0)
+					{
+						return res;
+					}
+				}
+				else
+				{
+					uint32 hmacLen = 0x20;
+					if (!HMAC(EVP_sha256(), sUnfixedInfosInternalHmacKey, sizeof(sUnfixedInfosInternalHmacKey), out->data + in->unfixedInfosHmacOffset + 0x21, (in->dataSize - in->unfixedInfosHmacOffset) - 0x21, out->data + in->unfixedInfosHmacOffset, &hmacLen))
+					{
+						return CCR_NFC_ERROR;
+					}
+				}
+
+				res = CCRNFCAESCTRCrypt(sUnfixedInfosInternalKey, sUnfixedInfosInternalNonce, in->data + in->unfixedInfosOffset, in->unfixedInfosSize, out->data + in->unfixedInfosOffset, in->unfixedInfosSize);
+				if (res != 0)
+				{
+					return res;
+				}
+			}
+
+			return res;
+		}
+
+		void CCRNFCThread()
+		{
+			iosu::kernel::IOSMessage msg;
+			while (true)
+			{
+				IOS_ERROR error = iosu::kernel::IOS_ReceiveMessage(sCCRNFCMsgQueue, &msg, 0);
+				cemu_assert(!IOS_ResultIsError(error));
+
+				// Check for system exit
+				if (msg == 0xf00dd00d)
+				{
+					return;
+				}
+
+				IPCCommandBody* cmd = MEMPTR<IPCCommandBody>(msg).GetPtr();
+				if (cmd->cmdId == IPCCommandId::IOS_OPEN)
+				{
+					iosu::kernel::IOS_ResourceReply(cmd, IOS_ERROR_OK);
+				}
+				else if (cmd->cmdId == IPCCommandId::IOS_CLOSE)
+				{
+					iosu::kernel::IOS_ResourceReply(cmd, IOS_ERROR_OK);
+				}
+				else if (cmd->cmdId == IPCCommandId::IOS_IOCTL)
+				{
+					sint32 result;
+					uint32 requestId = cmd->args[0];
+					void* ptrIn = MEMPTR<void>(cmd->args[1]);
+					uint32 sizeIn = cmd->args[2];
+					void* ptrOut = MEMPTR<void>(cmd->args[3]);
+					uint32 sizeOut = cmd->args[4];
+
+					if ((result = __CCRNFCValidateCryptData(static_cast<CCRNFCCryptData*>(ptrIn), sizeIn, true)) == 0 && 
+						(result = __CCRNFCValidateCryptData(static_cast<CCRNFCCryptData*>(ptrOut), sizeOut, false)) == 0)
+					{
+						// Initialize outData with inData
+						memcpy(ptrOut, ptrIn, sizeIn);
+
+						switch (requestId)
+						{
+						case 1: // encrypt
+							result = __CCRNFCCryptData(static_cast<CCRNFCCryptData*>(ptrIn), static_cast<CCRNFCCryptData*>(ptrOut), false);
+							break;
+						case 2: // decrypt
+							result = __CCRNFCCryptData(static_cast<CCRNFCCryptData*>(ptrIn), static_cast<CCRNFCCryptData*>(ptrOut), true);
+							break;
+						default:
+							cemuLog_log(LogType::Force, "/dev/ccr_nfc: Unsupported IOCTL requestId");
+							cemu_assert_suspicious();
+							result = IOS_ERROR_INVALID;
+							break;
+						}
+					}
+
+					iosu::kernel::IOS_ResourceReply(cmd, static_cast<IOS_ERROR>(result));
+				}
+				else
+				{
+					cemuLog_log(LogType::Force, "/dev/ccr_nfc: Unsupported IPC cmdId");
+					cemu_assert_suspicious();
+					iosu::kernel::IOS_ResourceReply(cmd, IOS_ERROR_INVALID);
+				}
+			}
+		}
+
+		class : public ::IOSUModule
+		{
+			void SystemLaunch() override
+			{
+				sCCRNFCMsgQueue = iosu::kernel::IOS_CreateMessageQueue(sCCRNFCMsgQueueMsgBuffer.GetPtr(), sCCRNFCMsgQueueMsgBuffer.GetCount());
+				cemu_assert(!IOS_ResultIsError(static_cast<IOS_ERROR>(sCCRNFCMsgQueue)));
+
+				IOS_ERROR error = iosu::kernel::IOS_RegisterResourceManager("/dev/ccr_nfc", sCCRNFCMsgQueue);
+				cemu_assert(!IOS_ResultIsError(error));
+
+				sCCRNFCThread = std::thread(CCRNFCThread);
+			}
+
+			void SystemExit() override
+			{
+				if (sCCRNFCMsgQueue < 0)
+				{
+					return;
+				}
+
+				iosu::kernel::IOS_SendMessage(sCCRNFCMsgQueue, 0xf00dd00d, 0);
+				sCCRNFCThread.join();
+
+				iosu::kernel::IOS_DestroyMessageQueue(sCCRNFCMsgQueue);
+				sCCRNFCMsgQueue = -1;
+			}
+		} sIOSUModuleCCRNFC;
+
+		IOSUModule* GetModule()
+		{
+			return &sIOSUModuleCCRNFC;
+		}
+	}
+}
diff --git a/src/Cafe/IOSU/ccr_nfc/iosu_ccr_nfc.h b/src/Cafe/IOSU/ccr_nfc/iosu_ccr_nfc.h
new file mode 100644
index 00000000..ae99d645
--- /dev/null
+++ b/src/Cafe/IOSU/ccr_nfc/iosu_ccr_nfc.h
@@ -0,0 +1,31 @@
+#pragma once
+#include "Cafe/IOSU/iosu_types_common.h"
+
+#define CCR_NFC_ERROR 					(-0x2F001E)
+#define CCR_NFC_INVALID_LOCKED_SECRET	(-0x2F0029)
+#define CCR_NFC_INVALID_UNFIXED_INFOS	(-0x2F002A)
+
+namespace iosu
+{
+	namespace ccr_nfc
+	{
+		struct CCRNFCCryptData
+		{
+			uint32 version;
+			uint32 dataSize;
+			uint32 seedOffset;
+			uint32 keyGenSaltOffset;
+			uint32 uuidOffset;
+			uint32 unfixedInfosOffset;
+			uint32 unfixedInfosSize;
+			uint32 lockedSecretOffset;
+			uint32 lockedSecretSize;
+			uint32 unfixedInfosHmacOffset;
+			uint32 lockedSecretHmacOffset;
+			uint8 data[540];
+		};
+		static_assert(sizeof(CCRNFCCryptData) == 0x248);
+
+		IOSUModule* GetModule();
+	}
+}
diff --git a/src/Cafe/IOSU/fsa/fsa_types.h b/src/Cafe/IOSU/fsa/fsa_types.h
index 2d2daa50..a7757486 100644
--- a/src/Cafe/IOSU/fsa/fsa_types.h
+++ b/src/Cafe/IOSU/fsa/fsa_types.h
@@ -4,48 +4,89 @@ enum class FS_RESULT : sint32 // aka FSStatus
 {
 	SUCCESS = 0,
 	END_ITERATION = -2, // used by FSGetMountSource / FSGetMountSourceNext to indicate when last element was reached
-	FATAL_ERROR = -0x400,
-
+	MAX_HANDLES = -3,
 	ALREADY_EXISTS = -5,
 	NOT_FOUND = -6,
 	NOT_FILE = -7,
 	NOT_DIR = -8,
 	PERMISSION_ERROR = -10,
 
-	INVALID_CLIENT_HANDLE = -0x30000 - 37,
-
+	FATAL_ERROR = -0x400,
 	ERR_PLACEHOLDER = -9999, // used when exact error code has yet to be determined
 };
 
 enum class FSA_RESULT : sint32 // aka FSError/FSAStatus
 {
-	SUCCESS = 0,
-	INVALID_CLIENT_HANDLE = -0x30000 - 37,
-	INVALID_HANDLE_UKN38 = -0x30000 - 38,
+	OK = 0,
+	NOT_INIT = -0x30000 - 0x01,
+	END_OF_DIRECTORY = -0x30000 - 0x04,
+	END_OF_FILE = -0x30000 - 0x05,
+	MAX_CLIENTS = -0x30000 - 0x12,
+	MAX_FILES = -0x30000 - 0x13,
+	MAX_DIRS = -0x30000 - 0x14,
+	ALREADY_EXISTS = -0x30000 - 0x16,
+	NOT_FOUND = -0x30000 - 0x17,
+	PERMISSION_ERROR = -0x30000 - 0x1A,
+	INVALID_PARAM = -0x30000 - 0x21,
+	INVALID_PATH = -0x30000 - 0x22,
+	INVALID_BUFFER = -0x30000 - 0x23,
+	INVALID_ALIGNMENT = -0x30000 - 0x24,
+	INVALID_CLIENT_HANDLE = -0x30000 - 0x25,
+	INVALID_FILE_HANDLE = -0x30000 - 0x26,
+	INVALID_DIR_HANDLE = -0x30000 - 0x27,
+	NOT_FILE = -0x30000 - 0x28,
+	NOT_DIR = -0x30000 - 0x29,
+	OUT_OF_RESOURCES = -0x30000 - 0x2C,
 	FATAL_ERROR = -0x30000 - 0x400,
 };
-// todo - error handling in the IOSU part is pretty hacky right now and we use FS_RESULT in most places which we shouldn't be doing. Rework it
+
+enum class FSA_CMD_OPERATION_TYPE : uint32
+{
+	CHANGEDIR = 0x5,
+	GETCWD = 0x6,
+	MAKEDIR = 0x7,
+	REMOVE = 0x8,
+	RENAME = 0x9,
+	OPENDIR = 0xA,
+	READDIR = 0xB,
+	REWINDDIR = 0xC,
+	CLOSEDIR = 0xD,
+	OPENFILE = 0xE,
+	READ = 0xF,
+	WRITE = 0x10,
+	GETPOS = 0x11,
+	SETPOS = 0x12,
+	ISEOF = 0x13,
+	GETSTATFILE = 0x14,
+	CLOSEFILE = 0x15,
+	FLUSHFILE = 0x17,
+	QUERYINFO = 0x18,
+	APPENDFILE = 0x19,
+	TRUNCATEFILE = 0x1A,
+	FLUSHQUOTA = 0x1E,
+};
 
 using FSResHandle = sint32;
 using FSFileHandle2 = FSResHandle;
 using FSDirHandle2 = FSResHandle;
-#define FS_INVALID_HANDLE_VALUE         -1
+#define FS_INVALID_HANDLE_VALUE -1
 
-#define FSA_FILENAME_SIZE_MAX			128
-#define FSA_PATH_SIZE_MAX				(512 + FSA_FILENAME_SIZE_MAX)
-#define FSA_CMD_PATH_MAX_LENGTH			FSA_PATH_SIZE_MAX
-#define FSA_MAX_CLIENTS					32
+#define FSA_FILENAME_SIZE_MAX 128
+#define FSA_PATH_SIZE_MAX (512 + FSA_FILENAME_SIZE_MAX)
+#define FSA_CMD_PATH_MAX_LENGTH FSA_PATH_SIZE_MAX
+#define FSA_MAX_CLIENTS 32
 
-typedef sint32                 FSStatus; // DEPR - replaced by FS_RESULT
-typedef uint32				   FS_ERROR_MASK; // replace with enum bitmask
-typedef uint32                 FSFileSize;
-typedef uint64                 FSLargeSize;
-typedef uint64                 FSTime;
+typedef sint32 FSStatus;	  // DEPR - replaced by FS_RESULT
+typedef uint32 FS_ERROR_MASK; // replace with enum bitmask
+typedef uint32 FSFileSize;
+typedef uint64 FSLargeSize;
+typedef uint64 FSTime;
 
 enum class FSFlag : uint32
 {
-	NONE		= 0,
-	IS_DIR		= 0x80000000,
+	NONE = 0,
+	IS_DIR = 0x80000000,
+	IS_FILE = 0x01000000,
 };
 DEFINE_ENUM_FLAG_OPERATORS(FSFlag);
 
@@ -53,31 +94,41 @@ DEFINE_ENUM_FLAG_OPERATORS(FSFlag);
 
 struct FSStat_t
 {
-	/* +0x000 */ betype<FSFlag>			flag;
-	/* +0x004 */ uint32be				permissions;
-	/* +0x008 */ uint32be				ownerId;
-	/* +0x00C */ uint32be				groupId;
-	/* +0x010 */ betype<FSFileSize>		size;
-	/* +0x014 */ betype<FSFileSize>		allocatedSize;
-	/* +0x018 */ betype<FSLargeSize>	quotaSize;
-	/* +0x020 */ uint32be				entryId;
-	/* +0x024 */ betype<FSTime>			createdTime;
-	/* +0x02C */ betype<FSTime>			modifiedTime;
-	/* +0x034 */ uint8					attributes[0x30];
+	/* +0x000 */ betype<FSFlag> flag;
+	/* +0x004 */ uint32be permissions;
+	/* +0x008 */ uint32be ownerId;
+	/* +0x00C */ uint32be groupId;
+	/* +0x010 */ betype<FSFileSize> size;
+	/* +0x014 */ betype<FSFileSize> allocatedSize;
+	/* +0x018 */ betype<FSLargeSize> quotaSize;
+	/* +0x020 */ uint32be entryId;
+	/* +0x024 */ betype<FSTime> createdTime;
+	/* +0x02C */ betype<FSTime> modifiedTime;
+	/* +0x034 */ uint8 attributes[0x30];
 };
 
 static_assert(sizeof(FSStat_t) == 0x64);
 
 struct FSDirEntry_t
 {
-	/* +0x00 */ FSStat_t    stat;
-	/* +0x64 */ char        name[FSA_FILENAME_SIZE_MAX];
+	/* +0x00 */ FSStat_t stat;
+	/* +0x64 */ char name[FSA_FILENAME_SIZE_MAX];
 };
 
 static_assert(sizeof(FSDirEntry_t) == 0xE4);
 
+struct FSADeviceInfo_t
+{
+	uint8 ukn0[0x8];
+	uint64be deviceSizeInSectors;
+	uint32be deviceSectorSize;
+	uint8 ukn014[0x14];
+};
+static_assert(sizeof(FSADeviceInfo_t) == 0x28);
+
 #pragma pack()
 
 // query types for QueryInfo
-#define FSA_QUERY_TYPE_FREESPACE		0
-#define FSA_QUERY_TYPE_STAT				5
+#define FSA_QUERY_TYPE_FREESPACE 0
+#define FSA_QUERY_TYPE_DEVICE_INFO 4
+#define FSA_QUERY_TYPE_STAT 5
diff --git a/src/Cafe/IOSU/fsa/iosu_fsa.cpp b/src/Cafe/IOSU/fsa/iosu_fsa.cpp
index aa2ad553..1429d083 100644
--- a/src/Cafe/IOSU/fsa/iosu_fsa.cpp
+++ b/src/Cafe/IOSU/fsa/iosu_fsa.cpp
@@ -4,7 +4,7 @@
 #include "Cafe/Filesystem/fsc.h"
 #include "util/helpers/helpers.h"
 
-#include "Cafe/OS/libs/coreinit/coreinit_FS.h" // get rid of this dependency, requires reworking some of the IPC stuff. See locations where we use coreinit::FSCmdBlockBody_t
+#include "Cafe/OS/libs/coreinit/coreinit_FS.h"	 // get rid of this dependency, requires reworking some of the IPC stuff. See locations where we use coreinit::FSCmdBlockBody_t
 #include "Cafe/HW/Latte/Core/LatteBufferCache.h" // also remove this dependency
 
 #include "Cafe/HW/MMU/MMU.h"
@@ -19,10 +19,10 @@ namespace iosu
 		SysAllocator<iosu::kernel::IOSMessage, 352> _m_sFSAIoMsgQueueMsgBuffer;
 		std::thread sFSAIoThread;
 
-		struct FSAClient // IOSU's counterpart to the coreinit FSClient struct 
+		struct FSAClient // IOSU's counterpart to the coreinit FSClient struct
 		{
 			std::string workingDirectory;
-			bool isAllocated{ false };
+			bool isAllocated{false};
 
 			void AllocateAndInitialize()
 			{
@@ -42,7 +42,7 @@ namespace iosu
 		{
 			for (size_t i = 0; i < sFSAClientArray.size(); i++)
 			{
-				if(sFSAClientArray[i].isAllocated)
+				if (sFSAClientArray[i].isAllocated)
 					continue;
 				sFSAClientArray[i].AllocateAndInitialize();
 				indexOut = (sint32)i;
@@ -51,16 +51,16 @@ namespace iosu
 			return (IOS_ERROR)0xFFFCFFEE;
 		}
 
-		sint32 FSA_convertFSCtoFSStatus(sint32 fscError)
+		FSA_RESULT FSA_convertFSCtoFSAStatus(sint32 fscError)
 		{
 			if (fscError == FSC_STATUS_OK)
-				return (FSStatus)FS_RESULT::SUCCESS;
+				return FSA_RESULT::OK;
 			else if (fscError == FSC_STATUS_FILE_NOT_FOUND)
-				return (sint32)FS_RESULT::NOT_FOUND;
+				return FSA_RESULT::NOT_FOUND;
 			else if (fscError == FSC_STATUS_ALREADY_EXISTS)
-				return (sint32)FS_RESULT::ALREADY_EXISTS;
+				return FSA_RESULT::ALREADY_EXISTS;
 			cemu_assert_unimplemented();
-			return -1;
+			return FSA_RESULT::FATAL_ERROR;
 		}
 
 		std::string __FSATranslatePath(FSAClient* fsaClient, std::string_view input, bool endWithSlash = false)
@@ -108,14 +108,30 @@ namespace iosu
 					if ((input.size() - idx) >= 3 && input[idx + 1] == '.' && input[idx + 2] == '/')
 					{
 						// "../"
-						cemu_assert_unimplemented();
+                        while(!tmp.empty())
+                        {
+                            if(tmp.back() == '/')
+                            {
+                                tmp.pop_back();
+                                break;
+                            }
+                            tmp.pop_back();
+                        }
 						idx += 3;
 						continue;
 					}
 					else if ((input.size() - idx) == 2 && input[idx + 1] == '.')
 					{
 						// ".." at the end
-						cemu_assert_unimplemented();
+                        while(!tmp.empty())
+                        {
+                            if(tmp.back() == '/')
+                            {
+                                tmp.pop_back();
+                                break;
+                            }
+                            tmp.pop_back();
+                        }
 						idx += 2;
 						continue;
 					}
@@ -152,21 +168,21 @@ namespace iosu
 			return fsc_open(translatedPath.c_str(), accessFlags, &fscStatus);
 		}
 
-		class _FSAHandleTable 
-		{
+		class _FSAHandleTable {
 			struct _FSAHandleResource
 			{
-				bool isAllocated{ false };
+				bool isAllocated{false};
 				FSCVirtualFile* fscFile;
 				uint16 handleCheckValue;
 			};
+
 		public:
 			FSA_RESULT AllocateHandle(FSResHandle& handleOut, FSCVirtualFile* fscFile)
 			{
 				for (size_t i = 0; i < m_handleTable.size(); i++)
 				{
 					auto& it = m_handleTable.at(i);
-					if(it.isAllocated)
+					if (it.isAllocated)
 						continue;
 					uint16 checkValue = (uint16)m_currentCounter;
 					m_currentCounter++;
@@ -175,7 +191,7 @@ namespace iosu
 					it.isAllocated = true;
 					uint32 handleVal = ((uint32)i << 16) | (uint32)checkValue;
 					handleOut = (FSResHandle)handleVal;
-					return FSA_RESULT::SUCCESS;
+					return FSA_RESULT::OK;
 				}
 				cemuLog_log(LogType::Force, "FSA: Ran out of file handles");
 				return FSA_RESULT::FATAL_ERROR;
@@ -186,15 +202,15 @@ namespace iosu
 				uint16 index = (uint16)((uint32)handle >> 16);
 				uint16 checkValue = (uint16)(handle & 0xFFFF);
 				if (index >= m_handleTable.size())
-					return FSA_RESULT::INVALID_HANDLE_UKN38;
+					return FSA_RESULT::INVALID_FILE_HANDLE;
 				auto& it = m_handleTable.at(index);
-				if(!it.isAllocated)
-					return FSA_RESULT::INVALID_HANDLE_UKN38;
-				if(it.handleCheckValue != checkValue)
-					return FSA_RESULT::INVALID_HANDLE_UKN38;
+				if (!it.isAllocated)
+					return FSA_RESULT::INVALID_FILE_HANDLE;
+				if (it.handleCheckValue != checkValue)
+					return FSA_RESULT::INVALID_FILE_HANDLE;
 				it.fscFile = nullptr;
 				it.isAllocated = false;
-				return FSA_RESULT::SUCCESS;
+				return FSA_RESULT::OK;
 			}
 
 			FSCVirtualFile* GetByHandle(FSResHandle handle)
@@ -210,7 +226,7 @@ namespace iosu
 					return nullptr;
 				return it.fscFile;
 			}
-		
+
 		private:
 			uint32 m_currentCounter = 1;
 			std::array<_FSAHandleResource, 0x3C0> m_handleTable;
@@ -219,21 +235,19 @@ namespace iosu
 		_FSAHandleTable sFileHandleTable;
 		_FSAHandleTable sDirHandleTable;
 
-
-		FSStatus __FSAOpenFile(FSAClient* client, const char* path, const char* accessModifierStr, sint32* fileHandle)
+		FSA_RESULT __FSAOpenFile(FSAClient* client, const char* path, const char* accessModifierStr, sint32* fileHandle)
 		{
 			*fileHandle = FS_INVALID_HANDLE_VALUE;
 			FSC_ACCESS_FLAG accessModifier = FSC_ACCESS_FLAG::NONE;
 			bool truncateFile = false; // todo: Support for this
-			bool isAppend = false; // todo: proper support for this (all write operations should move cursor to the end of the file?)
+			bool isAppend = false;	   // todo: proper support for this (all write operations should move cursor to the end of the file?)
 			if (strcmp(accessModifierStr, "r") == 0 || strcmp(accessModifierStr, "rb") == 0)
 				accessModifier = FSC_ACCESS_FLAG::READ_PERMISSION;
 			else if (strcmp(accessModifierStr, "r+") == 0)
 			{
-				// r+ will create a new file if it doesn't exist
 				// the cursor will be set to the beginning of the file
 				// allows read and write access
-				accessModifier = FSC_ACCESS_FLAG::READ_PERMISSION | FSC_ACCESS_FLAG::WRITE_PERMISSION | FSC_ACCESS_FLAG::FILE_ALLOW_CREATE; // create if non exists, read, write
+				accessModifier = FSC_ACCESS_FLAG::READ_PERMISSION | FSC_ACCESS_FLAG::WRITE_PERMISSION; // read, write
 			}
 			else if (strcmp(accessModifierStr, "w") == 0)
 			{
@@ -253,10 +267,12 @@ namespace iosu
 			}
 			else if (strcmp(accessModifierStr, "a+") == 0)
 			{
-				cemu_assert_debug(false); // a+ is kind of special. Writing always happens at the end but the read cursor can dynamically move
-				// but Cafe OS might not support this. Needs investigation.
-				// this also used to be FILE_ALWAYS_CREATE in 1.26.2 and before
-				accessModifier = FSC_ACCESS_FLAG::READ_PERMISSION | FSC_ACCESS_FLAG::WRITE_PERMISSION | FSC_ACCESS_FLAG::FILE_ALLOW_CREATE;
+				accessModifier = FSC_ACCESS_FLAG::READ_PERMISSION | FSC_ACCESS_FLAG::WRITE_PERMISSION | FSC_ACCESS_FLAG::FILE_ALLOW_CREATE | FSC_ACCESS_FLAG::IS_APPEND;
+				isAppend = true;
+			}
+			else if (strcmp(accessModifierStr, "a") == 0)
+			{
+				accessModifier = FSC_ACCESS_FLAG::WRITE_PERMISSION | FSC_ACCESS_FLAG::FILE_ALLOW_CREATE | FSC_ACCESS_FLAG::IS_APPEND;
 				isAppend = true;
 			}
 			else
@@ -266,89 +282,89 @@ namespace iosu
 			sint32 fscStatus;
 			FSCVirtualFile* fscFile = __FSAOpenNode(client, path, accessModifier, fscStatus);
 			if (!fscFile)
-				return (sint32)FS_RESULT::NOT_FOUND;
+				return FSA_RESULT::NOT_FOUND;
 			if (fscFile->fscGetType() != FSC_TYPE_FILE)
 			{
 				delete fscFile;
-				return (sint32)FS_RESULT::NOT_FILE;
+				return FSA_RESULT::NOT_FILE;
 			}
 			if (isAppend)
 				fsc_setFileSeek(fscFile, fsc_getFileSize(fscFile));
 			FSResHandle fsFileHandle;
 			FSA_RESULT r = sFileHandleTable.AllocateHandle(fsFileHandle, fscFile);
-			if (r != FSA_RESULT::SUCCESS)
+			if (r != FSA_RESULT::OK)
 			{
 				cemuLog_log(LogType::Force, "Exceeded maximum number of FSA file handles");
 				delete fscFile;
-				return -0x400;
+				return FSA_RESULT::MAX_FILES;
 			}
 			*fileHandle = fsFileHandle;
-			cemuLog_log(LogType::File, "Open file {} (access: {} result: ok handle: 0x{})", path, accessModifierStr, (uint32)*fileHandle);
-			return (FSStatus)FS_RESULT::SUCCESS;
+			cemuLog_log(LogType::CoreinitFile, "Open file {} (access: {} result: ok handle: 0x{})", path, accessModifierStr, (uint32)*fileHandle);
+			return FSA_RESULT::OK;
 		}
 
-		FSStatus __FSAOpenDirectory(FSAClient* client, std::string_view path, sint32* dirHandle)
+		FSA_RESULT __FSAOpenDirectory(FSAClient* client, std::string_view path, sint32* dirHandle)
 		{
 			*dirHandle = FS_INVALID_HANDLE_VALUE;
 			sint32 fscStatus;
 			FSCVirtualFile* fscFile = __FSAOpenNode(client, path, FSC_ACCESS_FLAG::OPEN_DIR | FSC_ACCESS_FLAG::OPEN_FILE, fscStatus);
 			if (!fscFile)
-				return (FSStatus)FS_RESULT::NOT_FOUND;
+				return FSA_RESULT::NOT_FOUND;
 			if (fscFile->fscGetType() != FSC_TYPE_DIRECTORY)
 			{
 				delete fscFile;
-				return (FSStatus)(FS_RESULT::NOT_DIR);
+				return FSA_RESULT::NOT_DIR;
 			}
 			FSResHandle fsDirHandle;
 			FSA_RESULT r = sDirHandleTable.AllocateHandle(fsDirHandle, fscFile);
-			if (r != FSA_RESULT::SUCCESS)
+			if (r != FSA_RESULT::OK)
 			{
 				delete fscFile;
-				return -0x400;
+				return FSA_RESULT::MAX_DIRS;
 			}
 			*dirHandle = fsDirHandle;
-			cemuLog_log(LogType::File, "Open directory {} (result: ok handle: 0x{})", path, (uint32)*dirHandle);
-			return (FSStatus)FS_RESULT::SUCCESS;
+			cemuLog_log(LogType::CoreinitFile, "Open directory {} (result: ok handle: 0x{})", path, (uint32)*dirHandle);
+			return FSA_RESULT::OK;
 		}
 
-		FSStatus __FSACloseFile(uint32 fileHandle)
+		FSA_RESULT __FSACloseFile(uint32 fileHandle)
 		{
 			uint8 handleType = 0;
 			FSCVirtualFile* fscFile = sFileHandleTable.GetByHandle(fileHandle);
 			if (!fscFile)
 			{
-				forceLogDebug_printf("__FSACloseFile(): Invalid handle (0x%08x)", fileHandle);
-				return (FSStatus)FS_RESULT::ERR_PLACEHOLDER;
+				cemuLog_logDebug(LogType::Force, "__FSACloseFile(): Invalid handle (0x{:08x})", fileHandle);
+				return FSA_RESULT::INVALID_FILE_HANDLE;
 			}
 			// unregister file
 			sFileHandleTable.ReleaseHandle(fileHandle); // todo - use the error code of this
 			fsc_close(fscFile);
-			return (FSStatus)FS_RESULT::SUCCESS;
+			return FSA_RESULT::OK;
 		}
 
-		FSStatus FSAProcessCmd_remove(FSAClient* client, FSAIpcCommand* cmd)
+		FSA_RESULT FSAProcessCmd_remove(FSAClient* client, FSAShimBuffer* shimBuffer)
 		{
-			char* path = (char*)cmd->cmdRemove.path;
+			std::string path = __FSATranslatePath(client, (char*)shimBuffer->request.cmdRemove.path);
 			sint32 fscStatus = FSC_STATUS_FILE_NOT_FOUND;
-			fsc_remove(path, &fscStatus);
-			return FSA_convertFSCtoFSStatus(fscStatus);
+			fsc_remove(path.c_str(), &fscStatus);
+			return FSA_convertFSCtoFSAStatus(fscStatus);
 		}
 
-		FSStatus FSAProcessCmd_makeDir(FSAClient* client, FSAIpcCommand* cmd)
+		FSA_RESULT FSAProcessCmd_makeDir(FSAClient* client, FSAShimBuffer* shimBuffer)
 		{
-			char* path = (char*)cmd->cmdMakeDir.path;
+			std::string path = __FSATranslatePath(client, (char*)shimBuffer->request.cmdMakeDir.path);
 			sint32 fscStatus = FSC_STATUS_FILE_NOT_FOUND;
-			fsc_createDir(path, &fscStatus);
-			return FSA_convertFSCtoFSStatus(fscStatus);
+			fsc_createDir(path.c_str(), &fscStatus);
+			return FSA_convertFSCtoFSAStatus(fscStatus);
 		}
 
-		FSStatus FSAProcessCmd_rename(FSAClient* client, FSAIpcCommand* cmd)
+		FSA_RESULT FSAProcessCmd_rename(FSAClient* client, FSAShimBuffer* shimBuffer)
 		{
-			char* srcPath = (char*)cmd->cmdRename.srcPath;
-			char* dstPath = (char*)cmd->cmdRename.dstPath;
+			std::string srcPath = __FSATranslatePath(client, (char*)shimBuffer->request.cmdRename.srcPath);
+			std::string dstPath = __FSATranslatePath(client, (char*)shimBuffer->request.cmdRename.dstPath);
 			sint32 fscStatus = FSC_STATUS_FILE_NOT_FOUND;
-			fsc_rename(srcPath, dstPath, &fscStatus);
-			return FSA_convertFSCtoFSStatus(fscStatus);
+			fsc_rename(srcPath.c_str(), dstPath.c_str(), &fscStatus);
+			return FSA_convertFSCtoFSAStatus(fscStatus);
 		}
 
 		bool __FSA_GetStatFromFSCFile(FSCVirtualFile* fscFile, FSStat_t* fsStatOut)
@@ -366,6 +382,7 @@ namespace iosu
 			else if (fsc_isFile(fscFile))
 			{
 				fsStatOut->size = fsc_getFileSize(fscFile);
+                statFlag |= FSFlag::IS_FILE;
 			}
 			else
 			{
@@ -376,88 +393,77 @@ namespace iosu
 			return true;
 		}
 
-		FSStatus __FSA_GetFileStat(FSAClient* client, const char* path, FSStat_t* fsStatOut)
+		FSA_RESULT __FSA_GetFileStat(FSAClient* client, const char* path, FSStat_t* fsStatOut)
 		{
 			sint32 fscStatus;
 			FSCVirtualFile* fscFile = __FSAOpenNode(client, path, FSC_ACCESS_FLAG::OPEN_FILE | FSC_ACCESS_FLAG::OPEN_DIR, fscStatus);
 			if (!fscFile)
-				return FSA_convertFSCtoFSStatus(fscStatus);
+				return FSA_convertFSCtoFSAStatus(fscStatus);
 			__FSA_GetStatFromFSCFile(fscFile, fsStatOut);
 			delete fscFile;
-			return (FSStatus)FS_RESULT::SUCCESS;
+			return FSA_RESULT::OK;
 		}
 
-		FSStatus FSAProcessCmd_queryInfo(FSAClient* client, FSAIpcCommand* cmd)
+		FSA_RESULT FSAProcessCmd_queryInfo(FSAClient* client, FSAShimBuffer* shimBuffer)
 		{
-			coreinit::FSCmdBlockBody_t* fullCmd = (coreinit::FSCmdBlockBody_t*)cmd;
-
-			char* path = (char*)cmd->cmdQueryInfo.query;
-			uint32 queryType = _swapEndianU32(cmd->cmdQueryInfo.queryType);
-			void* queryResult = memory_getPointerFromVirtualOffset(_swapEndianU32(fullCmd->returnValueMPTR));
+			char* path = (char*)shimBuffer->request.cmdQueryInfo.query;
+			uint32 queryType = shimBuffer->request.cmdQueryInfo.queryType;
 			// handle query
 			sint32 fscStatus = FSC_STATUS_OK;
 			if (queryType == FSA_QUERY_TYPE_STAT)
 			{
-				FSStat_t* fsStat = (FSStat_t*)queryResult;
-				FSStatus fsStatus = __FSA_GetFileStat(client, path, fsStat);
-				return fsStatus;
+				FSStat_t* fsStat = &shimBuffer->response.cmdQueryInfo.queryStat.stat;
+				FSA_RESULT fsaStatus = __FSA_GetFileStat(client, path, fsStat);
+				return fsaStatus;
 			}
 			else if (queryType == FSA_QUERY_TYPE_FREESPACE)
 			{
 				sint32 fscStatus;
 				FSCVirtualFile* fscFile = __FSAOpenNode(client, path, FSC_ACCESS_FLAG::OPEN_FILE | FSC_ACCESS_FLAG::OPEN_DIR, fscStatus);
 				if (!fscFile)
-					return FSA_convertFSCtoFSStatus(fscStatus);
-				betype<uint64>* fsStatSize = (betype<uint64>*)queryResult;
+					return FSA_convertFSCtoFSAStatus(fscStatus);
+				betype<uint64>* fsStatSize = &shimBuffer->response.cmdQueryInfo.queryFreeSpace.freespace;
 				*fsStatSize = 30ull * 1024 * 1024 * 1024; // placeholder value. How is this determined?
 				delete fscFile;
-				return (FSStatus)FS_RESULT::SUCCESS;
+				return FSA_RESULT::OK;
+			}
+			else if (queryType == FSA_QUERY_TYPE_DEVICE_INFO)
+			{
+				FSADeviceInfo_t* deviceInfo = &shimBuffer->response.cmdQueryInfo.queryDeviceInfo.info;
+				// always report hardcoded values for now.
+				deviceInfo->deviceSectorSize = 512;
+				deviceInfo->deviceSizeInSectors = (32ull * 1024 * 1024 * 1024) / deviceInfo->deviceSectorSize;
+				cemu_assert_suspicious();
+				return FSA_RESULT::OK;
 			}
 			else
 				cemu_assert_unimplemented();
-			return FSA_convertFSCtoFSStatus(fscStatus);
+			return FSA_convertFSCtoFSAStatus(fscStatus);
 		}
 
-		FSStatus FSAProcessCmd_getStatFile(FSAClient* client, FSAIpcCommand* cmd)
+		FSA_RESULT FSAProcessCmd_getStatFile(FSAClient* client, FSAShimBuffer* shimBuffer)
 		{
-			coreinit::FSCmdBlockBody_t* fullCmd = (coreinit::FSCmdBlockBody_t*)cmd;
-
-			FSFileHandle2 fileHandle = cmd->cmdGetStatFile.fileHandle;
-			FSStat_t* statOut = (FSStat_t*)memory_getPointerFromVirtualOffset(_swapEndianU32(fullCmd->returnValueMPTR));
+			FSFileHandle2 fileHandle = shimBuffer->request.cmdGetStatFile.fileHandle;
+			FSStat_t* statOut = &shimBuffer->response.cmdStatFile.statOut;
 			FSCVirtualFile* fscFile = sFileHandleTable.GetByHandle(fileHandle);
 			if (!fscFile)
-				return (FSStatus)FS_RESULT::NOT_FOUND;
+				return FSA_RESULT::NOT_FOUND;
 			cemu_assert_debug(fsc_isFile(fscFile));
 			__FSA_GetStatFromFSCFile(fscFile, statOut);
-			return (FSStatus)FS_RESULT::SUCCESS;
+			return FSA_RESULT::OK;
 		}
 
-		FSStatus FSAProcessCmd_read(FSAClient* client, FSAIpcCommand* cmd)
+		FSA_RESULT FSAProcessCmd_read(FSAClient* client, FSAShimBuffer* shimBuffer, MEMPTR<void> destPtr, uint32be transferSize)
 		{
-			coreinit::FSCmdBlockBody_t* fullCmd = (coreinit::FSCmdBlockBody_t*)cmd;
+			uint32 transferElementSize = shimBuffer->request.cmdReadFile.size;
+			uint32 filePos = shimBuffer->request.cmdReadFile.filePos;
+			uint32 fileHandle = shimBuffer->request.cmdReadFile.fileHandle;
+			uint32 flags = shimBuffer->request.cmdReadFile.flag;
 
-			uint32 filePos = _swapEndianU32(cmd->cmdDefault.transferFilePos);
-			uint32 fileHandle = _swapEndianU32(cmd->cmdDefault.fileHandle);
-			MPTR destOffset = _swapEndianU32(cmd->cmdDefault.destBufferMPTR);
-			void* destPtr = memory_getPointerFromVirtualOffset(destOffset);
-			uint32 transferSize = _swapEndianU32(fullCmd->transferSize);
-			uint32 transferElementSize = _swapEndianU32(fullCmd->transferElemSize);
-			uint32 flags = _swapEndianU32(cmd->cmdDefault.cmdFlag);
-			uint32 errHandling = _swapEndianU32(fullCmd->errHandling);
 			FSCVirtualFile* fscFile = sFileHandleTable.GetByHandle(fileHandle);
 			if (!fscFile)
-				return (FSStatus)FS_RESULT::ERR_PLACEHOLDER;
-			uint32 elementSize = transferElementSize;
-			uint32 elementCount = 0;
-			if (transferElementSize != 0)
-			{
-				elementCount = transferSize / transferElementSize;
-				cemu_assert_debug((transferSize % transferElementSize) == 0);
-			}
-			else
-			{
-				cemu_assert_debug(transferSize == 0);
-			}
+				return FSA_RESULT::INVALID_FILE_HANDLE;
+
 			uint32 bytesToRead = transferSize;
 			// update file position if flag is set
 			if ((flags & FSA_CMD_FLAG_SET_POS) != 0)
@@ -465,107 +471,91 @@ namespace iosu
 			// todo: File permissions
 			uint32 bytesSuccessfullyRead = fsc_readFile(fscFile, destPtr, bytesToRead);
 			if (transferElementSize == 0)
-				return 0;
+				return FSA_RESULT::OK;
 
-			LatteBufferCache_notifyDCFlush(memory_getVirtualOffsetFromPointer(destPtr), bytesToRead);
+			LatteBufferCache_notifyDCFlush(destPtr.GetMPTR(), bytesToRead);
 
-			return bytesSuccessfullyRead / transferElementSize; // return number of elements read
+			return (FSA_RESULT)(bytesSuccessfullyRead / transferElementSize); // return number of elements read
 		}
 
-		FSStatus FSAProcessCmd_write(FSAClient* client, FSAIpcCommand* cmd)
+		FSA_RESULT FSAProcessCmd_write(FSAClient* client, FSAShimBuffer* shimBuffer, MEMPTR<void> destPtr, uint32be transferSize)
 		{
-			coreinit::FSCmdBlockBody_t* fullCmd = (coreinit::FSCmdBlockBody_t*)cmd;
+			uint32 transferElementSize = shimBuffer->request.cmdWriteFile.size;
+			uint32 filePos = shimBuffer->request.cmdWriteFile.filePos;
+			uint32 fileHandle = shimBuffer->request.cmdWriteFile.fileHandle;
+			uint32 flags = shimBuffer->request.cmdWriteFile.flag;
 
-			uint32 filePos = _swapEndianU32(cmd->cmdDefault.transferFilePos);
-			uint32 fileHandle = _swapEndianU32(cmd->cmdDefault.fileHandle);
-			MPTR destOffset = _swapEndianU32(cmd->cmdDefault.destBufferMPTR);
-			void* destPtr = memory_getPointerFromVirtualOffset(destOffset);
-			uint32 transferSize = _swapEndianU32(fullCmd->transferSize);
-			uint32 transferElementSize = _swapEndianU32(fullCmd->transferElemSize);
-			uint32 flags = _swapEndianU32(cmd->cmdDefault.cmdFlag);
-			uint32 errHandling = _swapEndianU32(fullCmd->errHandling);
 			FSCVirtualFile* fscFile = sFileHandleTable.GetByHandle(fileHandle);
 			if (!fscFile)
-				return (FSStatus)FS_RESULT::ERR_PLACEHOLDER;
-			uint32 elementSize = transferElementSize;
-			uint32 elementCount = transferSize / transferElementSize;
+				return FSA_RESULT::INVALID_FILE_HANDLE;
 			cemu_assert_debug((transferSize % transferElementSize) == 0);
 			uint32 bytesToWrite = transferSize;
 			// check for write permission (should this happen before or after setting file position?)
 			if (!fsc_isWritable(fscFile))
 			{
 				cemu_assert_debug(false);
-				return (FSStatus)FS_RESULT::PERMISSION_ERROR;
+				return FSA_RESULT::PERMISSION_ERROR;
 			}
 			// update file position if flag is set
 			if ((flags & FSA_CMD_FLAG_SET_POS) != 0)
 				fsc_setFileSeek(fscFile, filePos);
 			uint32 bytesSuccessfullyWritten = fsc_writeFile(fscFile, destPtr, bytesToWrite);
 			debug_printf("FSAProcessCmd_write(): Writing 0x%08x bytes (bytes actually written: 0x%08x)\n", bytesToWrite, bytesSuccessfullyWritten);
-			return bytesSuccessfullyWritten / transferElementSize; // return number of elements read
+			return (FSA_RESULT)(bytesSuccessfullyWritten / transferElementSize); // return number of elements read
 		}
 
-		FSStatus FSAProcessCmd_setPos(FSAClient* client, FSAIpcCommand* cmd)
+		FSA_RESULT FSAProcessCmd_setPos(FSAClient* client, FSAShimBuffer* shimBuffer)
 		{
-			uint32 fileHandle = _swapEndianU32(cmd->cmdDefault.destBufferMPTR);
-			uint32 filePos = _swapEndianU32(cmd->cmdDefault.ukn0008);
+			uint32 fileHandle = shimBuffer->request.cmdSetPosFile.fileHandle;
+			uint32 filePos = shimBuffer->request.cmdSetPosFile.filePos;
 			FSCVirtualFile* fscFile = sFileHandleTable.GetByHandle(fileHandle);
 			if (!fscFile)
-				return (FSStatus)FS_RESULT::ERR_PLACEHOLDER;
+				return FSA_RESULT::INVALID_FILE_HANDLE;
 			fsc_setFileSeek(fscFile, filePos);
-			return (FSStatus)FS_RESULT::SUCCESS;
+			return FSA_RESULT::OK;
 		}
 
-		FSStatus FSAProcessCmd_getPos(FSAClient* client, FSAIpcCommand* cmd)
+		FSA_RESULT FSAProcessCmd_getPos(FSAClient* client, FSAShimBuffer* shimBuffer)
 		{
-			coreinit::FSCmdBlockBody_t* fullCmd = (coreinit::FSCmdBlockBody_t*)cmd;
-
-			uint32 fileHandle = _swapEndianU32(cmd->cmdDefault.destBufferMPTR);
-			MPTR returnedFilePos = _swapEndianU32(fullCmd->returnValueMPTR);
+			uint32 fileHandle = shimBuffer->request.cmdGetPosFile.fileHandle;
 			FSCVirtualFile* fscFile = sFileHandleTable.GetByHandle(fileHandle);
 			if (!fscFile)
-				return (FSStatus)FS_RESULT::ERR_PLACEHOLDER;
+				return FSA_RESULT::INVALID_FILE_HANDLE;
 			uint32 filePos = fsc_getFileSeek(fscFile);
-			memory_writeU32(returnedFilePos, filePos);
-			return (FSStatus)FS_RESULT::SUCCESS;
+			shimBuffer->response.cmdGetPosFile.filePos = filePos;
+			return FSA_RESULT::OK;
 		}
 
-		FSStatus FSAProcessCmd_openFile(FSAClient* client, FSAIpcCommand* cmd)
+		FSA_RESULT FSAProcessCmd_openFile(FSAClient* client, FSAShimBuffer* shimBuffer)
 		{
-			coreinit::FSCmdBlockBody_t* fullCmd = (coreinit::FSCmdBlockBody_t*)cmd;
 			sint32 fileHandle = 0;
-			FSStatus fsStatus = __FSAOpenFile(client, (char*)cmd->cmdOpenFile.path, (char*)cmd->cmdOpenFile.mode, &fileHandle);
-			memory_writeU32(_swapEndianU32(fullCmd->returnValueMPTR), fileHandle);
-			cmd->cmdOpenFile.fileHandleOutput = fileHandle;
-			return fsStatus;
+			FSA_RESULT fsaResult = __FSAOpenFile(client, (char*)shimBuffer->request.cmdOpenFile.path, (char*)shimBuffer->request.cmdOpenFile.mode, &fileHandle);
+			shimBuffer->response.cmdOpenFile.fileHandleOutput = fileHandle;
+			return fsaResult;
 		}
 
-		FSStatus FSAProcessCmd_closeFile(FSAClient* client, FSAIpcCommand* cmd)
+		FSA_RESULT FSAProcessCmd_closeFile(FSAClient* client, FSAShimBuffer* shimBuffer)
 		{
-			return __FSACloseFile(cmd->cmdCloseFile.fileHandle);
+			return __FSACloseFile(shimBuffer->request.cmdCloseFile.fileHandle);
 		}
 
-		FSStatus FSAProcessCmd_openDir(FSAClient* client, FSAIpcCommand* cmd)
+		FSA_RESULT FSAProcessCmd_openDir(FSAClient* client, FSAShimBuffer* shimBuffer)
 		{
-			coreinit::FSCmdBlockBody_t* fullCmd = (coreinit::FSCmdBlockBody_t*)cmd;
 			sint32 dirHandle = 0;
-			FSStatus fsStatus = __FSAOpenDirectory(client, (const char*)cmd->cmdOpenFile.path, &dirHandle);
-			memory_writeU32(_swapEndianU32(fullCmd->returnValueMPTR), dirHandle);
-			cmd->cmdOpenDir.dirHandleOutput = dirHandle;
-			return fsStatus;
+			FSA_RESULT fsaResult = __FSAOpenDirectory(client, (const char*)shimBuffer->request.cmdOpenFile.path, &dirHandle);
+			shimBuffer->response.cmdOpenDir.dirHandleOutput = dirHandle;
+			return fsaResult;
 		}
 
-		FSStatus FSAProcessCmd_readDir(FSAClient* client, FSAIpcCommand* cmd)
+		FSA_RESULT FSAProcessCmd_readDir(FSAClient* client, FSAShimBuffer* shimBuffer)
 		{
-			coreinit::FSCmdBlockBody_t* fullCmd = (coreinit::FSCmdBlockBody_t*)cmd;
-
-			FSCVirtualFile* fscFile = sDirHandleTable.GetByHandle((sint32)cmd->cmdReadDir.dirHandle);
+			FSCVirtualFile* fscFile = sDirHandleTable.GetByHandle((sint32)shimBuffer->request.cmdReadDir.dirHandle);
 			if (!fscFile)
-				return (FSStatus)FS_RESULT::ERR_PLACEHOLDER;
-			FSDirEntry_t* dirEntryOut = (FSDirEntry_t*)memory_getPointerFromVirtualOffset(_swapEndianU32(fullCmd->returnValueMPTR));
+				return FSA_RESULT::INVALID_DIR_HANDLE;
+			FSDirEntry_t* dirEntryOut = &shimBuffer->response.cmdReadDir.dirEntry;
 			FSCDirEntry fscDirEntry;
 			if (fsc_nextDir(fscFile, &fscDirEntry) == false)
-				return (FSStatus)FS_RESULT::END_ITERATION;
+				return FSA_RESULT::END_OF_DIRECTORY;
 			strcpy(dirEntryOut->name, fscDirEntry.path);
 			FSFlag statFlag = FSFlag::NONE;
 			dirEntryOut->stat.size = 0;
@@ -575,177 +565,269 @@ namespace iosu
 			}
 			else if (fscDirEntry.isFile)
 			{
+				statFlag |= FSFlag::IS_FILE;
 				dirEntryOut->stat.size = fscDirEntry.fileSize;
 			}
 			dirEntryOut->stat.flag = statFlag;
 			dirEntryOut->stat.permissions = 0x777;
-			return (FSStatus)FS_RESULT::SUCCESS;
+			return FSA_RESULT::OK;
 		}
 
-		FSStatus FSAProcessCmd_closeDir(FSAClient* client, FSAIpcCommand* cmd)
+		FSA_RESULT FSAProcessCmd_closeDir(FSAClient* client, FSAShimBuffer* shimBuffer)
 		{
-			FSCVirtualFile* fscFile = sDirHandleTable.GetByHandle((sint32)cmd->cmdReadDir.dirHandle);
+			FSCVirtualFile* fscFile = sDirHandleTable.GetByHandle((sint32)shimBuffer->request.cmdReadDir.dirHandle);
 			if (!fscFile)
 			{
-				forceLogDebug_printf("CloseDir: Invalid handle (0x%08x)", (sint32)cmd->cmdReadDir.dirHandle);
-				return (FSStatus)FS_RESULT::ERR_PLACEHOLDER;
+				cemuLog_logDebug(LogType::Force, "CloseDir: Invalid handle (0x{:08x})", (sint32)shimBuffer->request.cmdReadDir.dirHandle);
+				return FSA_RESULT::INVALID_DIR_HANDLE;
 			}
-			sDirHandleTable.ReleaseHandle(cmd->cmdReadDir.dirHandle);
+			sDirHandleTable.ReleaseHandle(shimBuffer->request.cmdReadDir.dirHandle);
 			fsc_close(fscFile);
-			return (FSStatus)FS_RESULT::SUCCESS;
+			return FSA_RESULT::OK;
 		}
 
-		FSStatus FSAProcessCmd_flushQuota(FSAClient* client, FSAIpcCommand* cmd)
+		FSA_RESULT FSAProcessCmd_flushQuota(FSAClient* client, FSAShimBuffer* shimBuffer)
 		{
-			return (FSStatus)FS_RESULT::SUCCESS;
+			return FSA_RESULT::OK;
 		}
 
-		FSStatus FSAProcessCmd_appendFile(FSAClient* client, FSAIpcCommand* cmd)
+		FSA_RESULT FSAProcessCmd_rewindDir(FSAClient* client, FSAShimBuffer* shimBuffer)
 		{
-			uint32 fileHandle = _swapEndianU32(cmd->cmdDefault.destBufferMPTR);
-			FSCVirtualFile* fscFile = sFileHandleTable.GetByHandle(fileHandle);
+			FSCVirtualFile* fscFile = sDirHandleTable.GetByHandle((sint32)shimBuffer->request.cmdRewindDir.dirHandle);
 			if (!fscFile)
-				return (FSStatus)FS_RESULT::ERR_PLACEHOLDER;
-#ifndef PUBLIC_RELEASE
-			cemuLog_force("FSAProcessCmd_appendFile(): size 0x{:08x} count 0x{:08x} (todo)\n", _swapEndianU32(cmd->cmdAppendFile.size), _swapEndianU32(cmd->cmdAppendFile.count));
+			{
+				cemuLog_logDebug(LogType::Force, "RewindDir: Invalid handle (0x{:08x})", (sint32)shimBuffer->request.cmdRewindDir.dirHandle);
+				return FSA_RESULT::INVALID_DIR_HANDLE;
+			}
+			if (!fscFile->fscRewindDir())
+				return FSA_RESULT::FATAL_ERROR;
+
+			return FSA_RESULT::OK;
+		}
+
+		FSA_RESULT FSAProcessCmd_flushFile(FSAClient* client, FSAShimBuffer* shimBuffer)
+		{
+			return FSA_RESULT::OK;
+		}
+
+		FSA_RESULT FSAProcessCmd_appendFile(FSAClient* client, FSAShimBuffer* shimBuffer)
+		{
+			FSCVirtualFile* fscFile = sFileHandleTable.GetByHandle(shimBuffer->request.cmdAppendFile.fileHandle);
+			if (!fscFile)
+				return FSA_RESULT::INVALID_FILE_HANDLE;
+#ifdef CEMU_DEBUG_ASSERT
+			cemuLog_log(LogType::Force, "FSAProcessCmd_appendFile(): size 0x{:08x} count 0x{:08x} (todo)\n", shimBuffer->request.cmdAppendFile.size, shimBuffer->request.cmdAppendFile.count);
 #endif
-			return _swapEndianU32(cmd->cmdAppendFile.size) * _swapEndianU32(cmd->cmdAppendFile.count);
+			return (FSA_RESULT)(shimBuffer->request.cmdAppendFile.count.value());
 		}
 
-		FSStatus FSAProcessCmd_truncateFile(FSAClient* client, FSAIpcCommand* cmd)
+		FSA_RESULT FSAProcessCmd_truncateFile(FSAClient* client, FSAShimBuffer* shimBuffer)
 		{
-			FSFileHandle2 fileHandle = cmd->cmdTruncateFile.fileHandle;
+			FSFileHandle2 fileHandle = shimBuffer->request.cmdTruncateFile.fileHandle;
 			FSCVirtualFile* fscFile = sFileHandleTable.GetByHandle(fileHandle);
 			if (!fscFile)
-				return (FSStatus)FS_RESULT::ERR_PLACEHOLDER;
+				return FSA_RESULT::INVALID_FILE_HANDLE;
 			fsc_setFileLength(fscFile, fsc_getFileSeek(fscFile));
-			return (FSStatus)FS_RESULT::SUCCESS;
+			return FSA_RESULT::OK;
 		}
 
-		FSStatus FSAProcessCmd_isEof(FSAClient* client, FSAIpcCommand* cmd)
+		FSA_RESULT FSAProcessCmd_isEof(FSAClient* client, FSAShimBuffer* shimBuffer)
 		{
-			uint32 fileHandle = _swapEndianU32(cmd->cmdDefault.destBufferMPTR);
+			uint32 fileHandle = shimBuffer->request.cmdIsEof.fileHandle;
 			FSCVirtualFile* fscFile = sFileHandleTable.GetByHandle(fileHandle);
 			if (!fscFile)
-				return (FSStatus)FS_RESULT::ERR_PLACEHOLDER;
+				return FSA_RESULT::INVALID_FILE_HANDLE;
 			uint32 filePos = fsc_getFileSeek(fscFile);
 			uint32 fileSize = fsc_getFileSize(fscFile);
 			if (filePos >= fileSize)
-				return (FSStatus)FS_RESULT::END_ITERATION;
-			return (FSStatus)FS_RESULT::SUCCESS;
+				return FSA_RESULT::END_OF_FILE;
+			return FSA_RESULT::OK;
 		}
 
-		FSStatus FSAProcessCmd_getCwd(FSAClient* client, FSAIpcCommand* cmd)
+		FSA_RESULT FSAProcessCmd_getCwd(FSAClient* client, FSAShimBuffer* shimBuffer)
 		{
-			coreinit::FSCmdBlockBody_t* fullCmd = (coreinit::FSCmdBlockBody_t*)cmd;
-
-			char* pathOutput = (char*)memory_getPointerFromVirtualOffset(_swapEndianU32(fullCmd->returnValueMPTR));
-			sint32 pathOutputMaxLen = _swapEndianU32(fullCmd->transferSize);
+			char* pathOutput = shimBuffer->response.cmdGetCWD.path;
+			sint32 pathOutputMaxLen = sizeof(shimBuffer->response.cmdGetCWD.path);
 			cemu_assert(pathOutputMaxLen > 0);
 			sint32 fscStatus = FSC_STATUS_OK;
 			strncpy(pathOutput, client->workingDirectory.data(), std::min(client->workingDirectory.size() + 1, (size_t)pathOutputMaxLen));
 			pathOutput[pathOutputMaxLen - 1] = '\0';
-			return FSA_convertFSCtoFSStatus(fscStatus);
+			return FSA_convertFSCtoFSAStatus(fscStatus);
 		}
 
-		FSStatus FSAProcessCmd_changeDir(FSAClient* client, FSAIpcCommand* cmd)
+		FSA_RESULT FSAProcessCmd_changeDir(FSAClient* client, FSAShimBuffer* shimBuffer)
 		{
-			const char* path = (const char*)cmd->cmdChangeDir.path;
-			cmd->cmdChangeDir.path[sizeof(cmd->cmdChangeDir.path) - 1] = '\0';
+			const char* path = (const char*)shimBuffer->request.cmdChangeDir.path;
+			shimBuffer->request.cmdChangeDir.path[sizeof(shimBuffer->request.cmdChangeDir.path) - 1] = '\0';
 			sint32 fscStatus = FSC_STATUS_OK;
 			client->workingDirectory.assign(__FSATranslatePath(client, path, true));
-			return FSA_convertFSCtoFSStatus(fscStatus);
+			return FSA_convertFSCtoFSAStatus(fscStatus);
 		}
 
-		void FSAHandleCommandIoctl(FSAClient* client, IPCCommandBody* cmd, uint32 operationId, void* ptrIn, void* ptrOut)
+		void FSAHandleCommandIoctlv(FSAClient* client, IPCCommandBody* cmd, FSA_CMD_OPERATION_TYPE operationId, uint32 numIn, uint32 numOut, IPCIoctlVector* vec)
 		{
-			FSAIpcCommand* fsaCommand = (FSAIpcCommand*)ptrIn;
-			FSStatus fsStatus = (FSStatus)(FS_RESULT::FATAL_ERROR);
-			if (operationId == FSA_CMD_OPERATION_TYPE_REMOVE)
+			FSA_RESULT fsaResult = FSA_RESULT::FATAL_ERROR;
+
+			switch (operationId)
 			{
-				fsStatus = FSAProcessCmd_remove(client, fsaCommand);
-			}
-			else if (operationId == FSA_CMD_OPERATION_TYPE_MAKEDIR)
+			case FSA_CMD_OPERATION_TYPE::READ:
 			{
-				fsStatus = FSAProcessCmd_makeDir(client, fsaCommand);
+				fsaResult = FSAProcessCmd_read(client, (FSAShimBuffer*)vec[0].basePhys.GetPtr(), vec[1].basePhys, vec[1].size);
+				break;
 			}
-			else if (operationId == FSA_CMD_OPERATION_TYPE_RENAME)
+			case FSA_CMD_OPERATION_TYPE::WRITE:
 			{
-				fsStatus = FSAProcessCmd_rename(client, fsaCommand);
+				fsaResult = FSAProcessCmd_write(client, (FSAShimBuffer*)vec[0].basePhys.GetPtr(), vec[1].basePhys, vec[1].size);
+				break;
 			}
-			else if (operationId == FSA_CMD_OPERATION_TYPE_READ)
+			case FSA_CMD_OPERATION_TYPE::CHANGEDIR:
+			case FSA_CMD_OPERATION_TYPE::GETCWD:
+			case FSA_CMD_OPERATION_TYPE::MAKEDIR:
+			case FSA_CMD_OPERATION_TYPE::RENAME:
+			case FSA_CMD_OPERATION_TYPE::OPENDIR:
+			case FSA_CMD_OPERATION_TYPE::READDIR:
+			case FSA_CMD_OPERATION_TYPE::CLOSEDIR:
+			case FSA_CMD_OPERATION_TYPE::OPENFILE:
+			case FSA_CMD_OPERATION_TYPE::REMOVE:
+			case FSA_CMD_OPERATION_TYPE::GETPOS:
+			case FSA_CMD_OPERATION_TYPE::SETPOS:
+			case FSA_CMD_OPERATION_TYPE::ISEOF:
+			case FSA_CMD_OPERATION_TYPE::GETSTATFILE:
+			case FSA_CMD_OPERATION_TYPE::CLOSEFILE:
+			case FSA_CMD_OPERATION_TYPE::QUERYINFO:
+			case FSA_CMD_OPERATION_TYPE::APPENDFILE:
+			case FSA_CMD_OPERATION_TYPE::TRUNCATEFILE:
+			case FSA_CMD_OPERATION_TYPE::FLUSHQUOTA:
 			{
-				fsStatus = FSAProcessCmd_read(client, fsaCommand);
+				// These are IOCTL and no IOCTLV
+				cemu_assert_error();
+				break;
 			}
-			else if (operationId == FSA_CMD_OPERATION_TYPE_WRITE)
-			{
-				fsStatus = FSAProcessCmd_write(client, fsaCommand);
-			}
-			else if (operationId == FSA_CMD_OPERATION_TYPE_SETPOS)
-			{
-				fsStatus = FSAProcessCmd_setPos(client, fsaCommand);
-			}
-			else if (operationId == FSA_CMD_OPERATION_TYPE_GETPOS)
-			{
-				fsStatus = FSAProcessCmd_getPos(client, fsaCommand);
-			}
-			else if (operationId == FSA_CMD_OPERATION_TYPE_OPENFILE)
-			{
-				fsStatus = FSAProcessCmd_openFile(client, fsaCommand);
-			}
-			else if (operationId == FSA_CMD_OPERATION_TYPE_CLOSEFILE)
-			{
-				fsStatus = FSAProcessCmd_closeFile(client, fsaCommand);
-			}
-			else if (operationId == FSA_CMD_OPERATION_TYPE_APPENDFILE)
-			{
-				fsStatus = FSAProcessCmd_appendFile(client, fsaCommand);
-			}
-			else if (operationId == FSA_CMD_OPERATION_TYPE_TRUNCATEFILE)
-			{
-				fsStatus = FSAProcessCmd_truncateFile(client, fsaCommand);
-			}
-			else if (operationId == FSA_CMD_OPERATION_TYPE_ISEOF)
-			{
-				fsStatus = FSAProcessCmd_isEof(client, fsaCommand);
-			}
-			else if (operationId == FSA_CMD_OPERATION_TYPE_QUERYINFO)
-			{
-				fsStatus = FSAProcessCmd_queryInfo(client, fsaCommand);
-			}
-			else if (operationId == FSA_CMD_OPERATION_TYPE_GETSTATFILE)
-			{
-				fsStatus = FSAProcessCmd_getStatFile(client, fsaCommand);
-			}
-			else if (operationId == FSA_CMD_OPERATION_TYPE_GETCWD)
-			{
-				fsStatus = FSAProcessCmd_getCwd(client, fsaCommand);
-			}
-			else if (operationId == FSA_CMD_OPERATION_TYPE_CHANGEDIR)
-			{
-				fsStatus = FSAProcessCmd_changeDir(client, fsaCommand);
-			}
-			else if (operationId == FSA_CMD_OPERATION_TYPE_OPENDIR)
-			{
-				fsStatus = FSAProcessCmd_openDir(client, fsaCommand);
-			}
-			else if (operationId == FSA_CMD_OPERATION_TYPE_READDIR)
-			{
-				fsStatus = FSAProcessCmd_readDir(client, fsaCommand);
-			}
-			else if (operationId == FSA_CMD_OPERATION_TYPE_CLOSEDIR)
-			{
-				fsStatus = FSAProcessCmd_closeDir(client, fsaCommand);
-			}
-			else if (operationId == FSA_CMD_OPERATION_TYPE_FLUSHQUOTA)
-			{
-				fsStatus = FSAProcessCmd_flushQuota(client, fsaCommand);
-			}
-			else
+			default:
 			{
 				cemu_assert_unimplemented();
+				break;
 			}
-			IOS_ResourceReply(cmd, (IOS_ERROR)fsStatus);
+			}
+
+			IOS_ResourceReply(cmd, (IOS_ERROR)fsaResult);
+		}
+
+		void FSAHandleCommandIoctl(FSAClient* client, IPCCommandBody* cmd, FSA_CMD_OPERATION_TYPE operationId, void* ptrIn, void* ptrOut)
+		{
+			FSAShimBuffer* shimBuffer = (FSAShimBuffer*)ptrIn;
+			FSA_RESULT fsaResult = FSA_RESULT::FATAL_ERROR;
+
+			switch (operationId)
+			{
+			case FSA_CMD_OPERATION_TYPE::REMOVE:
+			{
+				fsaResult = FSAProcessCmd_remove(client, shimBuffer);
+				break;
+			}
+			case FSA_CMD_OPERATION_TYPE::CHANGEDIR:
+			{
+				fsaResult = FSAProcessCmd_changeDir(client, shimBuffer);
+				break;
+			}
+			case FSA_CMD_OPERATION_TYPE::GETCWD:
+			{
+				fsaResult = FSAProcessCmd_getCwd(client, shimBuffer);
+				break;
+			}
+			case FSA_CMD_OPERATION_TYPE::MAKEDIR:
+			{
+				fsaResult = FSAProcessCmd_makeDir(client, shimBuffer);
+				break;
+			}
+			case FSA_CMD_OPERATION_TYPE::RENAME:
+			{
+				fsaResult = FSAProcessCmd_rename(client, shimBuffer);
+				break;
+			}
+			case FSA_CMD_OPERATION_TYPE::OPENDIR:
+			{
+				fsaResult = FSAProcessCmd_openDir(client, shimBuffer);
+				break;
+			}
+			case FSA_CMD_OPERATION_TYPE::READDIR:
+			{
+				fsaResult = FSAProcessCmd_readDir(client, shimBuffer);
+				break;
+			}
+			case FSA_CMD_OPERATION_TYPE::CLOSEDIR:
+			{
+				fsaResult = FSAProcessCmd_closeDir(client, shimBuffer);
+				break;
+			}
+			case FSA_CMD_OPERATION_TYPE::OPENFILE:
+			{
+				fsaResult = FSAProcessCmd_openFile(client, shimBuffer);
+				break;
+			}
+			case FSA_CMD_OPERATION_TYPE::GETPOS:
+			{
+				fsaResult = FSAProcessCmd_getPos(client, shimBuffer);
+				break;
+			}
+			case FSA_CMD_OPERATION_TYPE::SETPOS:
+			{
+				fsaResult = FSAProcessCmd_setPos(client, shimBuffer);
+				break;
+			}
+			case FSA_CMD_OPERATION_TYPE::ISEOF:
+			{
+				fsaResult = FSAProcessCmd_isEof(client, shimBuffer);
+				break;
+			}
+			case FSA_CMD_OPERATION_TYPE::GETSTATFILE:
+			{
+				fsaResult = FSAProcessCmd_getStatFile(client, shimBuffer);
+				break;
+			}
+			case FSA_CMD_OPERATION_TYPE::CLOSEFILE:
+			{
+				fsaResult = FSAProcessCmd_closeFile(client, shimBuffer);
+				break;
+			}
+			case FSA_CMD_OPERATION_TYPE::QUERYINFO:
+			{
+				fsaResult = FSAProcessCmd_queryInfo(client, shimBuffer);
+				break;
+			}
+			case FSA_CMD_OPERATION_TYPE::APPENDFILE:
+			{
+				fsaResult = FSAProcessCmd_appendFile(client, shimBuffer);
+				break;
+			}
+			case FSA_CMD_OPERATION_TYPE::TRUNCATEFILE:
+			{
+				fsaResult = FSAProcessCmd_truncateFile(client, shimBuffer);
+				break;
+			}
+			case FSA_CMD_OPERATION_TYPE::FLUSHQUOTA:
+			{
+				fsaResult = FSAProcessCmd_flushQuota(client, shimBuffer);
+				break;
+			}
+			case FSA_CMD_OPERATION_TYPE::REWINDDIR:
+			{
+				fsaResult = FSAProcessCmd_rewindDir(client, shimBuffer);
+				break;
+			}
+			case FSA_CMD_OPERATION_TYPE::FLUSHFILE:
+			{
+				fsaResult = FSAProcessCmd_flushFile(client, shimBuffer);
+				break;
+			}
+			case FSA_CMD_OPERATION_TYPE::READ:
+			case FSA_CMD_OPERATION_TYPE::WRITE:
+			{
+				// These commands are IOCTLVs not IOCTL
+				cemu_assert_error();
+			}
+			}
+			IOS_ResourceReply(cmd, (IOS_ERROR)fsaResult);
 		}
 
 		void FSAIoThread()
@@ -783,17 +865,17 @@ namespace iosu
 				{
 					cemu_assert(clientHandle < sFSAClientArray.size());
 					cemu_assert(sFSAClientArray[clientHandle].isAllocated);
-					FSAHandleCommandIoctl(sFSAClientArray.data() + clientHandle, cmd, cmd->args[0], MEMPTR<void>(cmd->args[1]), MEMPTR<void>(cmd->args[3]));
+					FSAHandleCommandIoctl(sFSAClientArray.data() + clientHandle, cmd, (FSA_CMD_OPERATION_TYPE)cmd->args[0].value(), MEMPTR<void>(cmd->args[1]), MEMPTR<void>(cmd->args[3]));
 				}
 				else if (cmd->cmdId == IPCCommandId::IOS_IOCTLV)
 				{
-					cemu_assert_unimplemented();
-					//uint32 requestId = cmd->args[0];
-					//uint32 numIn = cmd->args[1];
-					//uint32 numOut = cmd->args[2];
-					//IPCIoctlVector* vec = MEMPTR<IPCIoctlVector>{ cmd->args[3] }.GetPtr();
-					IOS_ResourceReply(cmd, IOS_ERROR_INVALID);
-					continue;
+					cemu_assert(clientHandle < sFSAClientArray.size());
+					cemu_assert(sFSAClientArray[clientHandle].isAllocated);
+					FSA_CMD_OPERATION_TYPE requestId = (FSA_CMD_OPERATION_TYPE)cmd->args[0].value();
+					uint32 numIn = cmd->args[1];
+					uint32 numOut = cmd->args[2];
+					IPCIoctlVector* vec = MEMPTR<IPCIoctlVector>{cmd->args[3]}.GetPtr();
+					FSAHandleCommandIoctlv(sFSAClientArray.data() + clientHandle, cmd, requestId, numIn, numOut, vec);
 				}
 				else
 				{
@@ -820,5 +902,5 @@ namespace iosu
 			IOS_SendMessage(sFSAIoMsgQueue, 0, 0);
 			sFSAIoThread.join();
 		}
-	}
-}
+	} // namespace fsa
+} // namespace iosu
diff --git a/src/Cafe/IOSU/fsa/iosu_fsa.h b/src/Cafe/IOSU/fsa/iosu_fsa.h
index 35b53d46..8181a4a8 100644
--- a/src/Cafe/IOSU/fsa/iosu_fsa.h
+++ b/src/Cafe/IOSU/fsa/iosu_fsa.h
@@ -1,162 +1,217 @@
 #pragma once
+#include <IOSU/iosu_ipc_common.h>
 #include "fsa_types.h"
 
 namespace iosu
 {
 	namespace fsa
 	{
-		struct FSAIpcCommand
+
+		struct FSARequest
 		{
+			uint32be ukn0;
 			union
 			{
+				uint8 ukn04[0x51C];
 				struct
 				{
-					uint32 ukn0000;
-					uint32 destBufferMPTR; // used as fileHandle for FSSetFilePosAsync
-					uint32 ukn0008; // used as filePos for FSSetFilePosAsync
-					uint32 ukn000C;
-					uint32 transferFilePos; // used as filePos for read/write operation
-					uint32 fileHandle;
-					uint32 cmdFlag;
-					uint32 ukn001C;
-					uint8 ukn0020[0x10];
-					uint8 ukn0030[0x10];
-					uint8 ukn0040[0x10];
-					uint8 ukn0050[0x10];
-					uint8 ukn0060[0x10];
-					uint8 ukn0070[0x10];
-					uint8 ukn0080[0x10];
-					uint8 ukn0090[0x10];
-					uint8 ukn00A0[0x10];
-					uint8 ukn00B0[0x10];
-					uint8 ukn00C0[0x10];
-					uint8 ukn00D0[0x10];
-					uint8 ukn00E0[0x10];
-					uint8 ukn00F0[0x10];
-					uint8 ukn0100[0x100];
-					uint8 ukn0200[0x100];
-					uint8 ukn0300[0x100];
-					uint8 ukn0400[0x100];
-					uint8 ukn0500[0x100];
-					uint8 ukn0600[0x100];
-				}cmdDefault;
+					MEMPTR<void> dest;
+					uint32be size;
+					uint32be count;
+					uint32be filePos;
+					uint32be fileHandle;
+					uint32be flag;
+				} cmdReadFile;
+				struct
+				{
+					MEMPTR<void> dest;
+					uint32be size;
+					uint32be count;
+					uint32be filePos;
+					uint32be fileHandle;
+					uint32be flag;
+				} cmdWriteFile;
 				struct
 				{
-					uint32 ukn0000;
 					uint8 path[FSA_CMD_PATH_MAX_LENGTH];
-					uint8 mode[12]; // +0x284 note: code seems to access this value like it has a size of 0x10 but the actual struct element is only 12 bytes? Maybe a typo (10 instead of 0x10 in the struct def)
-					uint32 createMode; // +0x290
-					uint32 openFlags; // +0x294
-					uint32 preallocSize; // +0x298
-					uint8 ukn[0x2E8]; // +0x29C
-					// output
-					uint32be fileHandleOutput; // +0x584 used to return file handle on success
-				}cmdOpenFile;
+					uint8 mode[12];		   // +0x284 note: code seems to access this value like it has a size of 0x10 but the actual struct element is only 12 bytes? Maybe a typo (10 instead of 0x10 in the struct def)
+					uint32be createMode;   // +0x290
+					uint32be openFlags;	   // +0x294
+					uint32be preallocSize; // +0x298
+				} cmdOpenFile;
 				struct
 				{
-					uint32 ukn0000; // +0x000
-					uint32be fileHandle; // +0x004
-				}cmdCloseFile;
+					uint32be fileHandle;
+				} cmdCloseFile;
 				struct
 				{
-					uint32 ukn0000;
 					uint8 path[FSA_CMD_PATH_MAX_LENGTH];
-					uint32 ukn0284;
-					uint8 ukn0288[0x80 - 8];
-					uint8 ukn0300[0x100];
-					uint8 ukn0400[0x100];
-					uint32 ukn0500;
-				}cmdRemove;
+				} cmdRemove;
 				struct
 				{
-					uint32 ukn0000;
 					uint8 path[FSA_CMD_PATH_MAX_LENGTH];
 					uint8 ukn0284[12]; // +0x284
-					uint32 ukn0290; // +0x290
-					uint32 ukn0294; // +0x294
-					uint32 ukn0298; // +0x298
-					uint8 ukn[0x2E8]; // +0x29C
-					// output
-					uint32be dirHandleOutput; // +0x584 used to return dir handle on success
-				}cmdOpenDir;
+				} cmdOpenDir;
 				struct
 				{
-					uint32 ukn0000;
 					betype<uint32> dirHandle;
-				}cmdReadDir;
+				} cmdReadDir;
 				struct
 				{
-					uint32 ukn0000;
 					betype<uint32> dirHandle;
-				}cmdCloseDir;
+				} cmdCloseDir;
 				struct
 				{
-					uint32 ukn0000;
 					uint8 path[FSA_CMD_PATH_MAX_LENGTH];
-					uint32 uknParam;
-					uint8 ukn0288[0x80 - 8];
-					uint8 ukn0300[0x100];
-					uint8 ukn0400[0x100];
-					uint32 ukn0500;
-				}cmdMakeDir;
+					uint32be uknParam;
+				} cmdMakeDir;
 				struct
 				{
-					uint32 ukn0000;
 					uint8 path[FSA_CMD_PATH_MAX_LENGTH];
-					uint8 ukn0284[0x80 - 4];
-					uint8 ukn0300[0x100];
-					uint8 ukn0400[0x100];
-					uint32 ukn0500;
-				}cmdChangeDir;
+				} cmdChangeDir;
 				struct
 				{
-					uint32 ukn0000;
 					uint8 query[FSA_CMD_PATH_MAX_LENGTH];
-					uint32 queryType;
-					uint8 ukn0288[0x80 - 8];
-					uint8 ukn0300[0x100];
-					uint8 ukn0400[0x100];
-					uint32 ukn0500;
-				}cmdQueryInfo;
+					uint32be queryType;
+				} cmdQueryInfo;
 				struct
 				{
-					uint32 ukn0000;
 					uint8 srcPath[FSA_CMD_PATH_MAX_LENGTH];
 					uint8 dstPath[FSA_CMD_PATH_MAX_LENGTH];
-				}cmdRename;
+				} cmdRename;
 				struct
 				{
-					uint32 ukn0000;
-					uint32 size;
-					uint32 count;
-					uint32 fileHandle;
-					uint32 uknParam;
-				}cmdAppendFile;
+					uint32be size;
+					uint32be count;
+					uint32be fileHandle;
+					uint32be uknParam;
+				} cmdAppendFile;
 				struct
 				{
-					uint32 ukn0000;
-					betype<uint32> fileHandle;
-					uint32be ukn0008;
-				}cmdTruncateFile;
+					uint32be fileHandle;
+				} cmdTruncateFile;
 				struct
 				{
-					uint32 ukn0000;
-					betype<uint32> fileHandle;
-				}cmdGetStatFile;
+					uint32be fileHandle;
+				} cmdGetStatFile;
 				struct
 				{
-					uint32 ukn0000;
 					uint8 path[FSA_CMD_PATH_MAX_LENGTH];
-				}cmdFlushQuota;
+				} cmdFlushQuota;
+				struct
+				{
+					uint32be fileHandle;
+					uint32be filePos;
+				} cmdSetPosFile;
+				struct
+				{
+					uint32be fileHandle;
+				} cmdGetPosFile;
+				struct
+				{
+					uint32be fileHandle;
+				} cmdIsEof;
+				struct
+				{
+					uint32be dirHandle;
+				} cmdRewindDir;
+				struct
+				{
+					uint32be fileHandle;
+				} cmdFlushFile;
+				struct
+				{
+					uint8 path[FSA_CMD_PATH_MAX_LENGTH];
+					uint32be mode1;
+					uint32be mode2;
+				} cmdChangeMode;
 			};
-			uint8 ukn0700[0x100];
-			uint8 ukn0800[0x10];
-			uint8 ukn0810[0x10];
 		};
+		static_assert(sizeof(FSARequest) == 0x520);
 
-		static_assert(sizeof(FSAIpcCommand) == 0x820); // exact size of this is not known
+#pragma pack(1)
+		struct FSAResponse
+		{
+			uint32be ukn0;
+			union
+			{
+				uint8 ukn04[0x28F];
+				struct
+				{
+					uint32be fileHandleOutput; // +0x584 used to return file handle on success
+				} cmdOpenFile;
+				struct
+				{
+					uint32be dirHandleOutput; // +0x584 used to return dir handle on success
+				} cmdOpenDir;
+				struct
+				{
+					uint32be filePos;
+				} cmdGetPosFile;
+				struct
+				{
+					FSStat_t statOut;
+				} cmdStatFile;
+				struct
+				{
+					FSDirEntry_t dirEntry;
+				} cmdReadDir;
+				struct
+				{
+					char path[FSA_CMD_PATH_MAX_LENGTH];
+				} cmdGetCWD;
+				struct
+				{
+					union
+					{
+						uint8 ukn04[0x64];
+						struct
+						{
+							uint64be freespace;
+						} queryFreeSpace;
+						struct
+						{
+							FSStat_t stat;
+						} queryStat;
+						struct
+						{
+							FSADeviceInfo_t info;
+						} queryDeviceInfo;
+					};
+				} cmdQueryInfo;
+			};
+		};
+		static_assert(sizeof(FSAResponse) == 0x293);
+#pragma pack()
+
+		struct FSAShimBuffer
+		{
+			FSARequest request;
+			uint8 ukn0520[0x60];
+			FSAResponse response;
+			uint8 ukn0813[0x6D];
+			IPCIoctlVector ioctlvVec[3];
+			uint8 ukn08A4[0x5C];
+			/* +0x0900 */ uint32be operationType;
+			betype<IOSDevHandle> fsaDevHandle;
+			/* +0x0908 */ uint16be ipcReqType; // 0 -> IoctlAsync, 1 -> IoctlvAsync
+			uint8 ioctlvVecIn;
+			uint8 ioctlvVecOut;
+			uint32 ukn090C;
+			uint32 ukn0910;
+			uint32 ukn0914;
+			uint32 ukn0918;
+			uint32 ukn091C;
+			uint32 ukn0920;
+			uint32 ukn0924;
+			uint32 ukn0928;
+			uint32 ukn092C;
+			uint32 ukn0930;
+			uint32 ukn0934;
+		};
+		static_assert(sizeof(FSAShimBuffer) == 0x938); // exact size of this is not known
 
 		void Initialize();
 		void Shutdown();
-	}
-}
+	} // namespace fsa
+} // namespace iosu
diff --git a/src/Cafe/IOSU/iosu_types_common.h b/src/Cafe/IOSU/iosu_types_common.h
index 94c0cd2c..1f7f78f8 100644
--- a/src/Cafe/IOSU/iosu_types_common.h
+++ b/src/Cafe/IOSU/iosu_types_common.h
@@ -1,6 +1,9 @@
 #pragma once
 
 using IOSMsgQueueId = uint32;
+using IOSTimerId = uint32;
+
+static constexpr IOSTimerId IOSInvalidTimerId = 0xFFFFFFFF;
 
 // returned for syscalls
 // maybe also shared with IPC?
@@ -19,4 +22,13 @@ enum IOS_ERROR : sint32
 inline bool IOS_ResultIsError(const IOS_ERROR err)
 {
 	return (err & 0x80000000) != 0;
-}
\ No newline at end of file
+}
+
+class IOSUModule
+{
+  public:
+	virtual void SystemLaunch() {}; // CafeSystem is initialized
+	virtual void SystemExit() {}; // CafeSystem is shutdown
+	virtual void TitleStart() {}; // foreground title is launched
+	virtual void TitleStop() {}; // foreground title is closed
+};
diff --git a/src/Cafe/IOSU/kernel/iosu_kernel.cpp b/src/Cafe/IOSU/kernel/iosu_kernel.cpp
index fb9a0191..666e0373 100644
--- a/src/Cafe/IOSU/kernel/iosu_kernel.cpp
+++ b/src/Cafe/IOSU/kernel/iosu_kernel.cpp
@@ -1,6 +1,8 @@
 #include "iosu_kernel.h"
 #include "util/helpers/fspinlock.h"
+#include "util/helpers/helpers.h"
 #include "Cafe/OS/libs/coreinit/coreinit_IPC.h"
+#include "util/highresolutiontimer/HighResolutionTimer.h"
 
 namespace iosu
 {
@@ -8,9 +10,12 @@ namespace iosu
 	{
 		std::mutex sInternalMutex;
 
+		void IOS_DestroyResourceManagerForQueueId(IOSMsgQueueId msgQueueId);
+		void _IPCDestroyAllHandlesForMsgQueue(IOSMsgQueueId msgQueueId);
+
 		static void _assume_lock()
 		{
-#ifndef PUBLIC_RELEASE
+#ifdef CEMU_DEBUG_ASSERT
 			cemu_assert_debug(!sInternalMutex.try_lock());
 #endif
 		}
@@ -84,6 +89,19 @@ namespace iosu
 			return queueHandle;
 		}
 
+		IOS_ERROR IOS_DestroyMessageQueue(IOSMsgQueueId msgQueueId)
+		{
+			std::unique_lock _l(sInternalMutex);
+			IOSMessageQueue* msgQueue = nullptr;
+			IOS_ERROR r = _IOS_GetMessageQueue(msgQueueId, msgQueue);
+			if (r != IOS_ERROR_OK)
+				return r;
+			msgQueue->msgArraySize = 0;
+			msgQueue->queueHandle = 0;
+			IOS_DestroyResourceManagerForQueueId(msgQueueId);
+			return IOS_ERROR_OK;
+		}
+
 		IOS_ERROR IOS_SendMessage(IOSMsgQueueId msgQueueId, IOSMessage message, uint32 flags)
 		{
 			std::unique_lock _l(sInternalMutex);
@@ -146,6 +164,133 @@ namespace iosu
 			return IOS_ERROR_OK;
 		}
 
+		/* timer */
+
+		std::mutex sTimerMutex;
+		std::condition_variable sTimerCV;
+		std::atomic_bool sTimerThreadStop;
+
+		struct IOSTimer
+		{
+			IOSMsgQueueId queueId;
+			uint32 message;
+			HRTick nextFire;
+			HRTick repeat;
+			bool isValid;
+		};
+
+		std::vector<IOSTimer> sTimers;
+		std::vector<IOSTimerId> sTimersFreeHandles;
+
+		auto sTimerSortComparator = [](const IOSTimerId& idA, const IOSTimerId& idB)
+		{
+			// order by nextFire, then by timerId to avoid duplicate keys
+			IOSTimer& timerA = sTimers[idA];
+			IOSTimer& timerB = sTimers[idB];
+			if (timerA.nextFire != timerB.nextFire)
+				return timerA.nextFire < timerB.nextFire;
+			return idA < idB;
+		};
+		std::set<IOSTimerId, decltype(sTimerSortComparator)> sTimerByFireTime;
+
+		IOSTimer& IOS_GetFreeTimer()
+		{
+			cemu_assert_debug(!sTimerMutex.try_lock()); // lock must be held by current thread
+			if (sTimersFreeHandles.empty())
+				return sTimers.emplace_back();
+			IOSTimerId timerId = sTimersFreeHandles.back();
+			sTimersFreeHandles.pop_back();
+			return sTimers[timerId];
+		}
+
+		void IOS_TimerSetNextFireTime(IOSTimer& timer, HRTick nextFire)
+		{
+			cemu_assert_debug(!sTimerMutex.try_lock()); // lock must be held by current thread
+			IOSTimerId timerId = &timer - sTimers.data();
+			auto it = sTimerByFireTime.find(timerId);
+			if(it != sTimerByFireTime.end())
+				sTimerByFireTime.erase(it);
+			timer.nextFire = nextFire;
+			if(nextFire != 0)
+				sTimerByFireTime.insert(timerId);
+		}
+
+		void IOS_StopTimerInternal(IOSTimerId timerId)
+		{
+			cemu_assert_debug(!sTimerMutex.try_lock());
+			IOS_TimerSetNextFireTime(sTimers[timerId], 0);
+		}
+
+		IOS_ERROR IOS_CreateTimer(uint32 startMicroseconds, uint32 repeatMicroseconds, uint32 queueId, uint32 message)
+		{
+			std::unique_lock _l(sTimerMutex);
+			IOSTimer& timer = IOS_GetFreeTimer();
+			timer.queueId = queueId;
+			timer.message = message;
+			HRTick nextFire = HighResolutionTimer::now().getTick() + HighResolutionTimer::microsecondsToTicks(startMicroseconds);
+			timer.repeat = HighResolutionTimer::microsecondsToTicks(repeatMicroseconds);
+			IOS_TimerSetNextFireTime(timer, nextFire);
+			timer.isValid = true;
+			sTimerCV.notify_one();
+			return (IOS_ERROR)(&timer - sTimers.data());
+		}
+
+		IOS_ERROR IOS_StopTimer(IOSTimerId timerId)
+		{
+			std::unique_lock _l(sTimerMutex);
+			if (timerId >= sTimers.size() || !sTimers[timerId].isValid)
+				return IOS_ERROR_INVALID;
+			IOS_StopTimerInternal(timerId);
+			return IOS_ERROR_OK;
+		}
+
+		IOS_ERROR IOS_DestroyTimer(IOSTimerId timerId)
+		{
+			std::unique_lock _l(sTimerMutex);
+			if (timerId >= sTimers.size() || !sTimers[timerId].isValid)
+				return IOS_ERROR_INVALID;
+			IOS_StopTimerInternal(timerId);
+			sTimers[timerId].isValid = false;
+			sTimersFreeHandles.push_back(timerId);
+			return IOS_ERROR_OK;
+		}
+
+		void IOSTimerThread()
+		{
+			SetThreadName("IOS-Timer");
+			std::unique_lock _l(sTimerMutex);
+			while (!sTimerThreadStop)
+			{
+				if (sTimerByFireTime.empty())
+				{
+					sTimerCV.wait_for(_l, std::chrono::milliseconds(10000));
+					continue;
+				}
+				IOSTimerId timerId = *sTimerByFireTime.begin();
+				IOSTimer& timer = sTimers[timerId];
+				HRTick now = HighResolutionTimer::now().getTick();
+				if (now >= timer.nextFire)
+				{
+					if(timer.repeat == 0)
+						IOS_TimerSetNextFireTime(timer, 0);
+					else
+						IOS_TimerSetNextFireTime(timer, timer.nextFire + timer.repeat);
+					IOSMsgQueueId queueId = timer.queueId;
+					uint32 message = timer.message;
+					// fire timer
+					_l.unlock();
+					IOSMessage msg;
+					IOS_SendMessage(queueId, message, 1);
+					_l.lock();
+					continue;
+				}
+				else
+				{
+					sTimerCV.wait_for(_l, std::chrono::microseconds(HighResolutionTimer::ticksToMicroseconds(timer.nextFire - now)));
+				}
+			}
+		}
+
 		/* devices and IPC */
 
 		struct IOSResourceManager
@@ -209,6 +354,23 @@ namespace iosu
 			return IOS_ERROR_OK;
 		}
 
+		void IOS_DestroyResourceManagerForQueueId(IOSMsgQueueId msgQueueId)
+		{
+			_assume_lock();
+			// destroy all IPC handles associated with this queue
+			_IPCDestroyAllHandlesForMsgQueue(msgQueueId);
+			// destroy device resource manager
+			for (auto& it : sDeviceResources)
+			{
+				if (it.isSet && it.msgQueueId == msgQueueId)
+				{
+					it.isSet = false;
+					it.path.clear();
+					it.msgQueueId = 0;
+				}
+			}
+		}
+
 		IOS_ERROR IOS_DeviceAssociateId(const char* devicePath, uint32 id)
 		{
 			// not yet implemented
@@ -234,38 +396,38 @@ namespace iosu
 
 		void _IPCInitDispatchablePool()
 		{
-			sIPCDispatchableCommandPoolLock.acquire();
+			sIPCDispatchableCommandPoolLock.lock();
 			while (!sIPCFreeDispatchableCommands.empty())
 				sIPCFreeDispatchableCommands.pop();
 			for (size_t i = 0; i < sIPCDispatchableCommandPool.GetCount(); i++)
 				sIPCFreeDispatchableCommands.push(sIPCDispatchableCommandPool.GetPtr()+i);
-			sIPCDispatchableCommandPoolLock.release();
+			sIPCDispatchableCommandPoolLock.unlock();
 		}
 
 		IOSDispatchableCommand* _IPCAllocateDispatchableCommand()
 		{
-			sIPCDispatchableCommandPoolLock.acquire();
+			sIPCDispatchableCommandPoolLock.lock();
 			if (sIPCFreeDispatchableCommands.empty())
 			{
 				cemuLog_log(LogType::Force, "IOS: Exhausted pool of dispatchable commands");
-				sIPCDispatchableCommandPoolLock.release();
+				sIPCDispatchableCommandPoolLock.unlock();
 				return nullptr;
 			}
 			IOSDispatchableCommand* cmd = sIPCFreeDispatchableCommands.front();
 			sIPCFreeDispatchableCommands.pop();
 			cemu_assert_debug(!cmd->isAllocated);
 			cmd->isAllocated = true;
-			sIPCDispatchableCommandPoolLock.release();
+			sIPCDispatchableCommandPoolLock.unlock();
 			return cmd;
 		}
 
 		void _IPCReleaseDispatchableCommand(IOSDispatchableCommand* cmd)
 		{
-			sIPCDispatchableCommandPoolLock.acquire();
+			sIPCDispatchableCommandPoolLock.lock();
 			cemu_assert_debug(cmd->isAllocated);
 			cmd->isAllocated = false;
 			sIPCFreeDispatchableCommands.push(cmd);
-			sIPCDispatchableCommandPoolLock.release();
+			sIPCDispatchableCommandPoolLock.unlock();
 		}
 
 		static constexpr size_t MAX_NUM_ACTIVE_DEV_HANDLES = 96; // per process
@@ -344,6 +506,22 @@ namespace iosu
 			return IOS_ERROR_OK;
 		}
 
+		void _IPCDestroyAllHandlesForMsgQueue(IOSMsgQueueId msgQueueId)
+		{
+			_assume_lock();
+			for (auto& it : sActiveDeviceHandles)
+			{
+				if (it.isSet && it.msgQueueId == msgQueueId)
+				{
+					it.isSet = false;
+					it.path.clear();
+					it.handleCheckValue = 0;
+					it.hasDispatchTargetHandle = false;
+					it.msgQueueId = 0;
+				}
+			}
+		}
+
 		IOS_ERROR _IPCAssignDispatchTargetHandle(IOSDevHandle devHandle, IOSDevHandle internalHandle)
 		{
 			std::unique_lock _lock(sInternalMutex);
@@ -400,8 +578,12 @@ namespace iosu
 			return r;
 		}
 
+		std::mutex sMtxReply[3];
+
 		void _IPCReplyAndRelease(IOSDispatchableCommand* dispatchCmd, uint32 result)
 		{
+			cemu_assert(dispatchCmd->ppcCoreIndex < 3);
+			std::unique_lock _l(sMtxReply[(uint32)dispatchCmd->ppcCoreIndex]);
 			cemu_assert(dispatchCmd >= sIPCDispatchableCommandPool.GetPtr() && dispatchCmd < sIPCDispatchableCommandPool.GetPtr() + sIPCDispatchableCommandPool.GetCount());	
 			dispatchCmd->originalBody->result = result;
 			// submit to COS
@@ -453,7 +635,6 @@ namespace iosu
 			uint32 numIn = dispatchCmd->body.args[1];
 			uint32 numOut = dispatchCmd->body.args[2];
 			IPCIoctlVector* vec = MEMPTR<IPCIoctlVector>(cmd.args[3]).GetPtr();
-
 			// copy the vector array
 			uint32 numVec = numIn + numOut;
 			if (numVec <= 8)
@@ -466,8 +647,23 @@ namespace iosu
 				// reuse the original vector pointer
 				cemuLog_log(LogType::Force, "Info: Ioctlv command with more than 8 vectors");
 			}
-			IOS_ERROR r = _IPCDispatchToResourceManager(dispatchCmd->body.devHandle, dispatchCmd);
-			return r;
+			return _IPCDispatchToResourceManager(dispatchCmd->body.devHandle, dispatchCmd);
+		}
+
+		// normally COS kernel handles this, but currently we skip the IPC getting proxied through it
+		IOS_ERROR _IPCHandlerIn_TranslateVectorAddresses(IOSDispatchableCommand* dispatchCmd)
+		{
+			uint32 numIn = dispatchCmd->body.args[1];
+			uint32 numOut = dispatchCmd->body.args[2];
+			IPCIoctlVector* vec = MEMPTR<IPCIoctlVector>(dispatchCmd->body.args[3]).GetPtr();
+			for (uint32 i = 0; i < numIn + numOut; i++)
+			{
+				if (vec[i].baseVirt == nullptr && vec[i].size != 0)
+					return IOS_ERROR_INVALID;
+				// todo - check for valid pointer range
+				vec[i].basePhys = vec[i].baseVirt;
+			}
+			return IOS_ERROR_OK;
 		}
 
 		// called by COS directly
@@ -494,7 +690,11 @@ namespace iosu
 				r = _IPCHandlerIn_IOS_Ioctl(dispatchCmd);
 				break;
 			case IPCCommandId::IOS_IOCTLV:
-				r = _IPCHandlerIn_IOS_Ioctlv(dispatchCmd);
+				r = _IPCHandlerIn_TranslateVectorAddresses(dispatchCmd);
+				if(r < 0)
+					cemuLog_log(LogType::Force, "Ioctlv error");
+				else
+					r = _IPCHandlerIn_IOS_Ioctlv(dispatchCmd);
 				break;
 			default:
 				cemuLog_log(LogType::Force, "Invalid IPC command {}", (uint32)(IPCCommandId)cmd->cmdId);
@@ -547,10 +747,34 @@ namespace iosu
 			return IOS_ERROR_OK;
 		}
 
-		void Initialize()
+		class : public ::IOSUModule
 		{
-			_IPCInitDispatchablePool();
+			void SystemLaunch() override
+			{
+				_IPCInitDispatchablePool();
+				// start timer thread
+				sTimerThreadStop = false;
+				m_timerThread = std::thread(IOSTimerThread);
+			}
+
+			void SystemExit() override
+			{
+				// stop timer thread
+				sTimerThreadStop = true;
+				sTimerCV.notify_one();
+				m_timerThread.join();
+				// reset resources
+				// todo
+			}
+
+			std::thread m_timerThread;
+		}sIOSUModuleKernel;
+
+		IOSUModule* GetModule()
+		{
+			return static_cast<IOSUModule*>(&sIOSUModuleKernel);
 		}
 
+
 	}
 }
\ No newline at end of file
diff --git a/src/Cafe/IOSU/kernel/iosu_kernel.h b/src/Cafe/IOSU/kernel/iosu_kernel.h
index 2b82374e..0355c118 100644
--- a/src/Cafe/IOSU/kernel/iosu_kernel.h
+++ b/src/Cafe/IOSU/kernel/iosu_kernel.h
@@ -9,15 +9,20 @@ namespace iosu
 		using IOSMessage = uint32;
 
 		IOSMsgQueueId IOS_CreateMessageQueue(IOSMessage* messageArray, uint32 messageCount);
+		IOS_ERROR IOS_DestroyMessageQueue(IOSMsgQueueId msgQueueId);
 		IOS_ERROR IOS_SendMessage(IOSMsgQueueId msgQueueId, IOSMessage message, uint32 flags);
 		IOS_ERROR IOS_ReceiveMessage(IOSMsgQueueId msgQueueId, IOSMessage* messageOut, uint32 flags);
 
+		IOS_ERROR IOS_CreateTimer(uint32 startMicroseconds, uint32 repeatMicroseconds, uint32 queueId, uint32 message);
+		IOS_ERROR IOS_StopTimer(IOSTimerId timerId);
+		IOS_ERROR IOS_DestroyTimer(IOSTimerId timerId);
+
 		IOS_ERROR IOS_RegisterResourceManager(const char* devicePath, IOSMsgQueueId msgQueueId);
 		IOS_ERROR IOS_DeviceAssociateId(const char* devicePath, uint32 id);
 		IOS_ERROR IOS_ResourceReply(IPCCommandBody* cmd, IOS_ERROR result);
 
 		void IPCSubmitFromCOS(uint32 ppcCoreIndex, IPCCommandBody* cmd);
 
-		void Initialize();
+		IOSUModule* GetModule();
 	}
 }
\ No newline at end of file
diff --git a/src/Cafe/IOSU/legacy/iosu_acp.cpp b/src/Cafe/IOSU/legacy/iosu_acp.cpp
index 8637d88d..6a9e6b89 100644
--- a/src/Cafe/IOSU/legacy/iosu_acp.cpp
+++ b/src/Cafe/IOSU/legacy/iosu_acp.cpp
@@ -8,10 +8,19 @@
 #include "Cafe/OS/libs/nn_acp/nn_acp.h"
 #include "Cafe/OS/libs/coreinit/coreinit_FS.h"
 #include "Cafe/Filesystem/fsc.h"
-#include "Cafe/HW/Espresso/PPCState.h"
+//#include "Cafe/HW/Espresso/PPCState.h"
+
+#include "Cafe/IOSU/iosu_types_common.h"
+#include "Cafe/IOSU/nn/iosu_nn_service.h"
+
+#include "Cafe/IOSU/legacy/iosu_act.h"
+#include "Cafe/CafeSystem.h"
+#include "config/ActiveSettings.h"
 
 #include <inttypes.h>
 
+using ACPDeviceType = iosu::acp::ACPDeviceType;
+
 static_assert(sizeof(acpMetaXml_t) == 0x3440);
 static_assert(offsetof(acpMetaXml_t, title_id) == 0x0000);
 static_assert(offsetof(acpMetaXml_t, boss_id) == 0x0008);
@@ -309,7 +318,7 @@ namespace iosu
 						}
 						else
 						{
-							forceLogDebug_printf("ACPGetSaveDataTitleIdList(): Missing meta.xml for save %08x-%08x", titleIdHigh, titleIdLow);
+							cemuLog_logDebug(LogType::Force, "ACPGetSaveDataTitleIdList(): Missing meta.xml for save {:08x}-{:08x}", titleIdHigh, titleIdLow);
 						}
 					}
 					fsc_close(fscDirIteratorTitleIdLow);
@@ -339,7 +348,7 @@ namespace iosu
 		}
 		else
 		{
-			forceLog_printf("ACPGetTitleSaveMetaXml(): Meta file \"%s\" does not exist", xmlPath);
+			cemuLog_log(LogType::Force, "ACPGetTitleSaveMetaXml(): Meta file \"{}\" does not exist", xmlPath);
 			memset(acpMetaXml, 0, sizeof(acpMetaXml_t));
 		}
 		return 0;
@@ -373,7 +382,7 @@ namespace iosu
 			free(metaBootMovieData);
 		}
 		else
-			forceLog_printf("ACPGetTitleMetaData(): Unable to load \"%s\"", filePath);
+			cemuLog_log(LogType::Force, "ACPGetTitleMetaData(): Unable to load \"{}\"", filePath);
 		// bootLogoTex.tga
 		sprintf(filePath, "%smeta/bootLogoTex.tga", titlePath);
 		uint32 metaBootLogoSize = 0;
@@ -384,7 +393,7 @@ namespace iosu
 			free(metaBootLogoData);
 		}
 		else
-			forceLog_printf("ACPGetTitleMetaData(): Unable to load \"%s\"", filePath);
+			cemuLog_log(LogType::Force, "ACPGetTitleMetaData(): Unable to load \"{}\"", filePath);
 
 
 		return 0;
@@ -418,7 +427,7 @@ namespace iosu
 		}
 		else
 		{
-			forceLog_printf("ACPGetTitleMetaXml(): Meta file \"%s\" does not exist", filePath);
+			cemuLog_log(LogType::Force, "ACPGetTitleMetaXml(): Meta file \"{}\" does not exist", filePath);
 		}
 
 		return 0;
@@ -460,7 +469,7 @@ namespace iosu
 				entry->ukn0C = 0;
 				entry->sizeA = _swapEndianU64(0); // ukn
 				entry->sizeB = _swapEndianU64(dirSize);
-				entry->time = _swapEndianU64((coreinit::coreinit_getOSTime() / ESPRESSO_TIMER_CLOCK));
+				entry->time = _swapEndianU64((coreinit::OSGetTime() / ESPRESSO_TIMER_CLOCK));
 				sprintf(entry->path, "%susr/save/%08x/%08x/meta/", devicePath, (uint32)(titleId >> 32), (uint32)(titleId & 0xFFFFFFFF));
 				count++;
 			}
@@ -470,7 +479,7 @@ namespace iosu
 		FSCVirtualFile* fscDirIterator = fsc_openDirIterator(searchPath, &fscStatus);
 		if (fscDirIterator == nullptr)
 		{
-			forceLog_printf("ACPGetTitleSaveDirEx(): Failed to iterate directories in \"%s\"", searchPath);
+			cemuLog_log(LogType::Force, "ACPGetTitleSaveDirEx(): Failed to iterate directories in \"{}\"", searchPath);
 			*countOut = 0;
 		}
 		else
@@ -495,7 +504,7 @@ namespace iosu
 					entry->ukn0C = 0;
 					entry->sizeA = _swapEndianU64(0);
 					entry->sizeB = _swapEndianU64(0);
-					entry->time = _swapEndianU64((coreinit::coreinit_getOSTime() / ESPRESSO_TIMER_CLOCK));
+					entry->time = _swapEndianU64((coreinit::OSGetTime() / ESPRESSO_TIMER_CLOCK));
 					sprintf(entry->path, "%susr/save/%08x/%08x/meta/", devicePath, (uint32)(titleId >> 32), (uint32)(titleId & 0xFFFFFFFF));
 					count++;
 				}
@@ -506,48 +515,6 @@ namespace iosu
 		return 0;
 	}
 
-	sint32 ACPCreateSaveDirEx(uint8 accountSlot, uint64 titleId)
-	{
-		uint32 persistentId = 0;
-		nn::save::GetPersistentIdEx(accountSlot, &persistentId);
-
-		uint32 high = GetTitleIdHigh(titleId) & (~0xC);
-		uint32 low = GetTitleIdLow(titleId);
-
-		sint32 fscStatus = FSC_STATUS_FILE_NOT_FOUND;
-		char path[256];
-
-		sprintf(path, "%susr/boss/", "/vol/storage_mlc01/");
-		fsc_createDir(path, &fscStatus);
-		sprintf(path, "%susr/boss/%08x/", "/vol/storage_mlc01/", high);
-		fsc_createDir(path, &fscStatus);
-		sprintf(path, "%susr/boss/%08x/%08x/", "/vol/storage_mlc01/", high, low);
-		fsc_createDir(path, &fscStatus);
-		sprintf(path, "%susr/boss/%08x/%08x/user/", "/vol/storage_mlc01/", high, low);
-		fsc_createDir(path, &fscStatus);
-		sprintf(path, "%susr/boss/%08x/%08x/user/common", "/vol/storage_mlc01/", high, low);
-		fsc_createDir(path, &fscStatus);
-		sprintf(path, "%susr/boss/%08x/%08x/user/%08x/", "/vol/storage_mlc01/", high, low, persistentId == 0 ? 0x80000001 : persistentId);
-		fsc_createDir(path, &fscStatus);
-
-		sprintf(path, "%susr/save/%08x/", "/vol/storage_mlc01/", high);
-		fsc_createDir(path, &fscStatus);
-		sprintf(path, "%susr/save/%08x/%08x/", "/vol/storage_mlc01/", high, low);
-		fsc_createDir(path, &fscStatus);
-		sprintf(path, "%susr/save/%08x/%08x/meta/", "/vol/storage_mlc01/", high, low);
-		fsc_createDir(path, &fscStatus);
-		sprintf(path, "%susr/save/%08x/%08x/user/", "/vol/storage_mlc01/", high, low);
-		fsc_createDir(path, &fscStatus);
-		sprintf(path, "%susr/save/%08x/%08x/user/common", "/vol/storage_mlc01/", high, low);
-		fsc_createDir(path, &fscStatus);
-		sprintf(path, "%susr/save/%08x/%08x/user/%08x", "/vol/storage_mlc01/", high, low, persistentId == 0 ? 0x80000001 : persistentId);
-		fsc_createDir(path, &fscStatus);
-
-		// copy xml meta files
-		nn::acp::CreateSaveMetaFiles(persistentId, titleId);
-		return 0;
-	}
-
 	int iosuAcp_thread()
 	{
 		SetThreadName("iosuAcp_thread");
@@ -584,7 +551,7 @@ namespace iosu
 				}
 				else if (acpCemuRequest->requestCode == IOSU_ACP_CREATE_SAVE_DIR_EX)
 				{
-					acpCemuRequest->returnCode = ACPCreateSaveDirEx(acpCemuRequest->accountSlot, acpCemuRequest->titleId);
+					acpCemuRequest->returnCode = acp::ACPCreateSaveDirEx(acpCemuRequest->accountSlot, acpCemuRequest->titleId);
 				}
 				else
 					cemu_assert_unimplemented();
@@ -610,5 +577,237 @@ namespace iosu
 		return iosuAcp.isInitialized;
 	}
 
+	/* Above is the legacy implementation. Below is the new style implementation which also matches the official IPC protocol and works with the real nn_acp.rpl */
 
-}
\ No newline at end of file
+	namespace acp
+	{
+
+		uint64 _ACPGetTimestamp()
+		{
+			return coreinit::OSGetTime() / ESPRESSO_TIMER_CLOCK;
+		}
+
+		nnResult ACPUpdateSaveTimeStamp(uint32 persistentId, uint64 titleId, ACPDeviceType deviceType)
+		{
+			if (deviceType == ACPDeviceType::UnknownType)
+			{
+				return (nnResult)0xA030FB80;
+			}
+
+			// create or modify the saveinfo
+			const auto saveinfoPath = ActiveSettings::GetMlcPath("usr/save/{:08x}/{:08x}/meta/saveinfo.xml", GetTitleIdHigh(titleId), GetTitleIdLow(titleId));
+			auto saveinfoData = FileStream::LoadIntoMemory(saveinfoPath);
+			if (saveinfoData && !saveinfoData->empty())
+			{
+				namespace xml = tinyxml2;
+				xml::XMLDocument doc;
+				tinyxml2::XMLError xmlError = doc.Parse((const char*)saveinfoData->data(), saveinfoData->size());
+				if (xmlError == xml::XML_SUCCESS || xmlError == xml::XML_ERROR_EMPTY_DOCUMENT)
+				{
+					xml::XMLNode* child = doc.FirstChild();
+					// check for declaration -> <?xml version="1.0" encoding="utf-8"?>
+					if (!child || !child->ToDeclaration())
+					{
+						xml::XMLDeclaration* decl = doc.NewDeclaration();
+						doc.InsertFirstChild(decl);
+					}
+
+					xml::XMLElement* info = doc.FirstChildElement("info");
+					if (!info)
+					{
+						info = doc.NewElement("info");
+						doc.InsertEndChild(info);
+					}
+
+					// find node with persistentId
+					char tmp[64];
+					sprintf(tmp, "%08x", persistentId);
+					bool foundNode = false;
+					for (xml::XMLElement* account = info->FirstChildElement("account"); account; account = account->NextSiblingElement("account"))
+					{
+						if (account->Attribute("persistentId", tmp))
+						{
+							// found the entry! -> update timestamp
+							xml::XMLElement* timestamp = account->FirstChildElement("timestamp");
+							sprintf(tmp, "%" PRIx64, _ACPGetTimestamp());
+							if (timestamp)
+								timestamp->SetText(tmp);
+							else
+							{
+								timestamp = doc.NewElement("timestamp");
+								account->InsertFirstChild(timestamp);
+							}
+
+							foundNode = true;
+							break;
+						}
+					}
+
+					if (!foundNode)
+					{
+						tinyxml2::XMLElement* account = doc.NewElement("account");
+						{
+							sprintf(tmp, "%08x", persistentId);
+							account->SetAttribute("persistentId", tmp);
+
+							tinyxml2::XMLElement* timestamp = doc.NewElement("timestamp");
+							{
+								sprintf(tmp, "%" PRIx64, _ACPGetTimestamp());
+								timestamp->SetText(tmp);
+							}
+
+							account->InsertFirstChild(timestamp);
+						}
+
+						info->InsertFirstChild(account);
+					}
+
+					// update file
+					tinyxml2::XMLPrinter printer;
+					doc.Print(&printer);
+					FileStream* fs = FileStream::createFile2(saveinfoPath);
+					if (fs)
+					{
+						fs->writeString(printer.CStr());
+						delete fs;
+					}
+				}
+			}
+			return NN_RESULT_SUCCESS;
+		}
+
+		void CreateSaveMetaFiles(uint32 persistentId, uint64 titleId)
+		{
+			std::string titlePath = CafeSystem::GetMlcStoragePath(CafeSystem::GetForegroundTitleId());
+
+			sint32 fscStatus;
+			FSCVirtualFile* fscFile = fsc_open((titlePath + "/meta/meta.xml").c_str(), FSC_ACCESS_FLAG::OPEN_FILE | FSC_ACCESS_FLAG::READ_PERMISSION, &fscStatus);
+			if (fscFile)
+			{
+				sint32 fileSize = fsc_getFileSize(fscFile);
+
+				std::unique_ptr<uint8[]> fileContent = std::make_unique<uint8[]>(fileSize);
+				fsc_readFile(fscFile, fileContent.get(), fileSize);
+				fsc_close(fscFile);
+
+				const auto outPath = ActiveSettings::GetMlcPath("usr/save/{:08x}/{:08x}/meta/meta.xml", GetTitleIdHigh(titleId), GetTitleIdLow(titleId));
+
+				std::ofstream myFile(outPath, std::ios::out | std::ios::binary);
+				myFile.write((char*)fileContent.get(), fileSize);
+				myFile.close();
+			}
+
+			fscFile = fsc_open((titlePath + "/meta/iconTex.tga").c_str(), FSC_ACCESS_FLAG::OPEN_FILE | FSC_ACCESS_FLAG::READ_PERMISSION, &fscStatus);
+			if (fscFile)
+			{
+				sint32 fileSize = fsc_getFileSize(fscFile);
+
+				std::unique_ptr<uint8[]> fileContent = std::make_unique<uint8[]>(fileSize);
+				fsc_readFile(fscFile, fileContent.get(), fileSize);
+				fsc_close(fscFile);
+
+				const auto outPath = ActiveSettings::GetMlcPath("usr/save/{:08x}/{:08x}/meta/iconTex.tga", GetTitleIdHigh(titleId), GetTitleIdLow(titleId));
+
+				std::ofstream myFile(outPath, std::ios::out | std::ios::binary);
+				myFile.write((char*)fileContent.get(), fileSize);
+				myFile.close();
+			}
+
+			ACPUpdateSaveTimeStamp(persistentId, titleId, iosu::acp::ACPDeviceType::InternalDeviceType);
+		}
+
+
+		sint32 _ACPCreateSaveDir(uint32 persistentId, uint64 titleId, ACPDeviceType type)
+		{
+			uint32 high = GetTitleIdHigh(titleId) & (~0xC);
+			uint32 low = GetTitleIdLow(titleId);
+
+			sint32 fscStatus = FSC_STATUS_FILE_NOT_FOUND;
+			char path[256];
+
+			sprintf(path, "%susr/boss/", "/vol/storage_mlc01/");
+			fsc_createDir(path, &fscStatus);
+			sprintf(path, "%susr/boss/%08x/", "/vol/storage_mlc01/", high);
+			fsc_createDir(path, &fscStatus);
+			sprintf(path, "%susr/boss/%08x/%08x/", "/vol/storage_mlc01/", high, low);
+			fsc_createDir(path, &fscStatus);
+			sprintf(path, "%susr/boss/%08x/%08x/user/", "/vol/storage_mlc01/", high, low);
+			fsc_createDir(path, &fscStatus);
+			sprintf(path, "%susr/boss/%08x/%08x/user/common", "/vol/storage_mlc01/", high, low);
+			fsc_createDir(path, &fscStatus);
+			sprintf(path, "%susr/boss/%08x/%08x/user/%08x/", "/vol/storage_mlc01/", high, low, persistentId == 0 ? 0x80000001 : persistentId);
+			fsc_createDir(path, &fscStatus);
+
+			sprintf(path, "%susr/save/%08x/", "/vol/storage_mlc01/", high);
+			fsc_createDir(path, &fscStatus);
+			sprintf(path, "%susr/save/%08x/%08x/", "/vol/storage_mlc01/", high, low);
+			fsc_createDir(path, &fscStatus);
+			sprintf(path, "%susr/save/%08x/%08x/meta/", "/vol/storage_mlc01/", high, low);
+			fsc_createDir(path, &fscStatus);
+			sprintf(path, "%susr/save/%08x/%08x/user/", "/vol/storage_mlc01/", high, low);
+			fsc_createDir(path, &fscStatus);
+			sprintf(path, "%susr/save/%08x/%08x/user/common", "/vol/storage_mlc01/", high, low);
+			fsc_createDir(path, &fscStatus);
+			sprintf(path, "%susr/save/%08x/%08x/user/%08x", "/vol/storage_mlc01/", high, low, persistentId == 0 ? 0x80000001 : persistentId);
+			fsc_createDir(path, &fscStatus);
+
+			// copy xml meta files
+			CreateSaveMetaFiles(persistentId, titleId);
+			return 0;
+		}
+
+		nnResult ACPCreateSaveDir(uint32 persistentId, ACPDeviceType type)
+		{
+			uint64 titleId = CafeSystem::GetForegroundTitleId();
+			return _ACPCreateSaveDir(persistentId, titleId, type);
+		}
+
+		sint32 ACPCreateSaveDirEx(uint8 accountSlot, uint64 titleId)
+		{
+			uint32 persistentId = 0;
+			cemu_assert_debug(accountSlot >= 1 && accountSlot <= 13); // outside valid slot range?
+			bool r = iosu::act::GetPersistentId(accountSlot, &persistentId);
+			cemu_assert_debug(r);
+			return _ACPCreateSaveDir(persistentId, titleId, ACPDeviceType::InternalDeviceType);
+		}
+
+		nnResult ACPGetOlvAccesskey(uint32be* accessKey)
+		{
+			*accessKey = CafeSystem::GetForegroundTitleOlvAccesskey();
+			return 0;
+		}
+
+		class AcpMainService : public iosu::nn::IPCService
+		{
+		  public:
+			AcpMainService() : iosu::nn::IPCService("/dev/acp_main") {}
+
+			nnResult ServiceCall(uint32 serviceId, void* request, void* response) override
+			{
+				cemuLog_log(LogType::Force, "Unsupported service call to /dev/acp_main");
+				cemu_assert_unimplemented();
+				return BUILD_NN_RESULT(NN_RESULT_LEVEL_SUCCESS, NN_RESULT_MODULE_NN_ACP, 0);
+			}
+		};
+
+		AcpMainService gACPMainService;
+
+		class : public ::IOSUModule
+		{
+			void TitleStart() override
+			{
+				gACPMainService.Start();
+				// gACPMainService.SetTimerUpdate(1000); // call TimerUpdate() once a second
+			}
+			void TitleStop() override
+			{
+				gACPMainService.Stop();
+			}
+		}sIOSUModuleNNACP;
+
+		IOSUModule* GetModule()
+		{
+			return static_cast<IOSUModule*>(&sIOSUModuleNNACP);
+		}
+	} // namespace acp
+} // namespace iosu
diff --git a/src/Cafe/IOSU/legacy/iosu_acp.h b/src/Cafe/IOSU/legacy/iosu_acp.h
index 18197bd8..a6fb6bfd 100644
--- a/src/Cafe/IOSU/legacy/iosu_acp.h
+++ b/src/Cafe/IOSU/legacy/iosu_acp.h
@@ -1,5 +1,8 @@
 #pragma once
 
+#include "Cafe/IOSU/iosu_types_common.h"
+#include "Cafe/OS/libs/nn_common.h" // for nnResult
+
 typedef struct
 {
 	/* +0x0000 */ uint64 title_id; // parsed via GetHex64
@@ -192,4 +195,24 @@ typedef struct
 namespace iosu
 {
 	void iosuAcp_init();
+
+	namespace acp
+	{
+		enum ACPDeviceType
+		{
+			UnknownType = 0,
+			InternalDeviceType = 1,
+			USBDeviceType = 3,
+		};
+
+		class IOSUModule* GetModule();
+
+		void CreateSaveMetaFiles(uint32 persistentId, uint64 titleId);
+		nnResult ACPUpdateSaveTimeStamp(uint32 persistentId, uint64 titleId, ACPDeviceType deviceType);
+
+		nnResult ACPCreateSaveDir(uint32 persistentId, ACPDeviceType type);
+		sint32 ACPCreateSaveDirEx(uint8 accountSlot, uint64 titleId);
+		nnResult ACPGetOlvAccesskey(uint32be* accessKey);
+	}
+
 }
\ No newline at end of file
diff --git a/src/Cafe/IOSU/legacy/iosu_act.cpp b/src/Cafe/IOSU/legacy/iosu_act.cpp
index 852dbfba..a115d6f1 100644
--- a/src/Cafe/IOSU/legacy/iosu_act.cpp
+++ b/src/Cafe/IOSU/legacy/iosu_act.cpp
@@ -21,14 +21,18 @@
 
 using namespace iosu::kernel;
 
+using NexToken = NAPI::ACTNexToken;
+static_assert(sizeof(NexToken) == 0x25C);
+
 struct  
 {
 	bool isInitialized;
+	std::mutex actMutex;
 }iosuAct = { };
 
 // account manager
 
-typedef struct  
+struct actAccountData_t
 {
 	bool isValid;
 	// options
@@ -49,7 +53,12 @@ typedef struct
 	// Mii
 	FFLData_t miiData;
 	uint16le miiNickname[ACT_NICKNAME_LENGTH];
-}actAccountData_t;
+
+	bool IsNetworkAccount() const
+	{
+		return isNetworkAccount; // todo - IOSU only checks if accountId is not empty?
+	}
+};
 
 #define IOSU_ACT_ACCOUNT_MAX_COUNT (0xC)
 
@@ -113,7 +122,7 @@ void iosuAct_loadAccounts()
 	//	}
 	//}
 
-	cemuLog_force(L"IOSU_ACT: using account {} in first slot", first_acc.GetMiiName());
+	cemuLog_log(LogType::Force, "IOSU_ACT: using account {} in first slot", boost::nowide::narrow(first_acc.GetMiiName()));
 	
 	_actAccountDataInitialized = true;
 }
@@ -159,140 +168,11 @@ uint32 iosuAct_getAccountIdOfCurrentAccount()
 
 // IOSU act API interface
 
-namespace iosu
-{
-	namespace act
-	{
-		uint8 getCurrentAccountSlot()
-		{
-			return 1;
-		}
-
-		bool getPrincipalId(uint8 slot, uint32* principalId)
-		{
-			sint32 accountIndex = iosuAct_getAccountIndexBySlot(slot);
-			if (_actAccountData[accountIndex].isValid == false)
-			{
-				*principalId = 0;
-				return false;
-			}
-			*principalId = _actAccountData[accountIndex].principalId;
-			return true;
-		}
-
-		bool getAccountId(uint8 slot, char* accountId)
-		{
-			sint32 accountIndex = iosuAct_getAccountIndexBySlot(slot);
-			if (_actAccountData[accountIndex].isValid == false)
-			{
-				*accountId = '\0';
-				return false;
-			}
-			strcpy(accountId, _actAccountData[accountIndex].accountId);
-			return true;
-		}
-
-		bool getMii(uint8 slot, FFLData_t* fflData)
-		{
-			sint32 accountIndex = iosuAct_getAccountIndexBySlot(slot);
-			if (_actAccountData[accountIndex].isValid == false)
-			{
-				return false;
-			}
-			memcpy(fflData, &_actAccountData[accountIndex].miiData, sizeof(FFLData_t));
-			return true;
-		}
-
-		// return screenname in little-endian wide characters
-		bool getScreenname(uint8 slot, uint16 screenname[ACT_NICKNAME_LENGTH])
-		{
-			sint32 accountIndex = iosuAct_getAccountIndexBySlot(slot);
-			if (_actAccountData[accountIndex].isValid == false)
-			{
-				screenname[0] = '\0';
-				return false;
-			}
-			for (sint32 i = 0; i < ACT_NICKNAME_LENGTH; i++)
-			{
-				screenname[i] = (uint16)_actAccountData[accountIndex].miiNickname[i];
-			}
-			return true;
-		}
-
-		bool getCountryIndex(uint8 slot, uint32* countryIndex)
-		{
-			sint32 accountIndex = iosuAct_getAccountIndexBySlot(slot);
-			if (_actAccountData[accountIndex].isValid == false)
-			{
-				*countryIndex = 0;
-				return false;
-			}
-			*countryIndex = _actAccountData[accountIndex].countryIndex;
-			return true;
-		}
-
-		class ActService : public iosu::nn::IPCService
-		{
-		public:
-			ActService() : iosu::nn::IPCService("/dev/act") {}
-
-			nnResult ServiceCall(uint32 serviceId, void* request, void* response) override
-			{
-				cemuLog_log(LogType::Force, "Unsupported service call to /dec/act");
-				cemu_assert_unimplemented();
-				return BUILD_NN_RESULT(NN_RESULT_LEVEL_SUCCESS, NN_RESULT_MODULE_NN_ACT, 0);
-			}
-		};
-
-		ActService gActService;
-
-		void Initialize()
-		{
-			gActService.Start();
-		}
-
-		void Stop()
-		{
-			gActService.Stop();
-		}
-	}
-}
-
-
-// IOSU act IO
-
-typedef struct  
-{
-	/* +0x00 */ uint32be ukn00;
-	/* +0x04 */ uint32be ukn04;
-	/* +0x08 */ uint32be ukn08;
-	/* +0x0C */ uint32be subcommandCode;
-	/* +0x10 */ uint8 ukn10;
-	/* +0x11 */ uint8 ukn11;
-	/* +0x12 */ uint8 ukn12;
-	/* +0x13 */ uint8 accountSlot;
-	/* +0x14 */ uint32be unique; // is this command specific?
-}cmdActRequest00_t;
-
-typedef struct  
-{
-	uint32be returnCode;
-	uint8 transferableIdBase[8];
-}cmdActGetTransferableIDResult_t;
-
-#define ACT_SUBCMD_GET_TRANSFERABLE_ID		4
-#define ACT_SUBCMD_INITIALIZE				0x14
-
-#define _cancelIfAccountDoesNotExist() \
-if (_actAccountData[accountIndex].isValid == false) \
-{ \
-	/* account does not exist*/  \
-	ioctlReturnValue = 0; \
-	actCemuRequest->setACTReturnCode(BUILD_NN_RESULT(NN_RESULT_LEVEL_STATUS, NN_RESULT_MODULE_NN_ACT, NN_ACT_RESULT_ACCOUNT_DOES_NOT_EXIST)); /* 0xA071F480 */ \
-	actCemuRequest->resultU64.u64 = 0; \
-	iosuIoctl_completeRequest(ioQueueEntry, ioctlReturnValue); \
-	continue; \
-}
+static const auto ACTResult_Ok = 0;
+static const auto ACTResult_InvalidValue = BUILD_NN_RESULT(NN_RESULT_LEVEL_LVL6, NN_RESULT_MODULE_NN_ACT, 0x12F00); // 0xC0712F00
+static const auto ACTResult_OutOfRange = BUILD_NN_RESULT(NN_RESULT_LEVEL_LVL6, NN_RESULT_MODULE_NN_ACT, 0x12D80); // 0xC0712D80
+static const auto ACTResult_AccountDoesNotExist = BUILD_NN_RESULT(NN_RESULT_LEVEL_STATUS, NN_RESULT_MODULE_NN_ACT, NN_ACT_RESULT_ACCOUNT_DOES_NOT_EXIST); // 0xA071F480
+static const auto ACTResult_NotANetworkAccount = BUILD_NN_RESULT(NN_RESULT_LEVEL_STATUS, NN_RESULT_MODULE_NN_ACT, 0x1FE80); // 0xA071FE80
 
 nnResult ServerActErrorCodeToNNResult(NAPI::ACT_ERROR_CODE ec)
 {
@@ -497,6 +377,291 @@ nnResult ServerActErrorCodeToNNResult(NAPI::ACT_ERROR_CODE ec)
 	return nnResultStatus(NN_RESULT_MODULE_NN_ACT, NN_ERROR_CODE::ACT_UNKNOWN_SERVER_ERROR);
 }
 
+namespace iosu
+{
+	namespace act
+	{
+		uint8 getCurrentAccountSlot()
+		{
+			return 1;
+		}
+
+		actAccountData_t* GetAccountBySlotNo(uint8 slotNo)
+		{
+			// only call this while holding actMutex
+			uint8 accIndex;
+			if(slotNo == iosu::act::ACT_SLOT_CURRENT)
+			{
+				accIndex = getCurrentAccountSlot() - 1;
+				cemu_assert_debug(accIndex >= 0 && accIndex < IOSU_ACT_ACCOUNT_MAX_COUNT);
+			}
+			else if(slotNo > 0 && slotNo <= IOSU_ACT_ACCOUNT_MAX_COUNT)
+				accIndex = slotNo - 1;
+			else
+			{
+				return nullptr;
+			}
+			if(!_actAccountData[accIndex].isValid)
+				return nullptr;
+			return &_actAccountData[accIndex];
+		}
+
+		// has ownership of account data
+		// while any thread has a LockedAccount in non-null state no other thread can access the account data
+		class LockedAccount
+		{
+		  public:
+			LockedAccount(uint8 slotNo)
+			{
+				iosuAct.actMutex.lock();
+				m_account = GetAccountBySlotNo(slotNo);
+				if(!m_account)
+					iosuAct.actMutex.unlock();
+			}
+
+			~LockedAccount()
+			{
+				if(m_account)
+					iosuAct.actMutex.unlock();
+			}
+
+			void Release()
+			{
+				if(m_account)
+					iosuAct.actMutex.unlock();
+				m_account = nullptr;
+			}
+
+			actAccountData_t* operator->()
+			{
+				return m_account;
+			}
+
+			actAccountData_t& operator*()
+			{
+				return *m_account;
+			}
+
+			LockedAccount(const LockedAccount&) = delete;
+			LockedAccount& operator=(const LockedAccount&) = delete;
+
+			operator bool() const { return m_account != nullptr; }
+
+		  private:
+			actAccountData_t* m_account{nullptr};
+		};
+
+		bool getPrincipalId(uint8 slot, uint32* principalId)
+		{
+			sint32 accountIndex = iosuAct_getAccountIndexBySlot(slot);
+			if (_actAccountData[accountIndex].isValid == false)
+			{
+				*principalId = 0;
+				return false;
+			}
+			*principalId = _actAccountData[accountIndex].principalId;
+			return true;
+		}
+
+		bool getAccountId(uint8 slot, char* accountId)
+		{
+			sint32 accountIndex = iosuAct_getAccountIndexBySlot(slot);
+			if (_actAccountData[accountIndex].isValid == false)
+			{
+				*accountId = '\0';
+				return false;
+			}
+			strcpy(accountId, _actAccountData[accountIndex].accountId);
+			return true;
+		}
+
+		// returns empty string if invalid
+		std::string getAccountId2(uint8 slot)
+		{
+			sint32 accountIndex = iosuAct_getAccountIndexBySlot(slot);
+			if (_actAccountData[accountIndex].isValid == false)
+				return {};
+			return {_actAccountData[accountIndex].accountId};
+		}
+
+		bool getMii(uint8 slot, FFLData_t* fflData)
+		{
+			sint32 accountIndex = iosuAct_getAccountIndexBySlot(slot);
+			if (_actAccountData[accountIndex].isValid == false)
+			{
+				return false;
+			}
+			memcpy(fflData, &_actAccountData[accountIndex].miiData, sizeof(FFLData_t));
+			return true;
+		}
+
+		// return screenname in little-endian wide characters
+		bool getScreenname(uint8 slot, uint16 screenname[ACT_NICKNAME_LENGTH])
+		{
+			sint32 accountIndex = iosuAct_getAccountIndexBySlot(slot);
+			if (_actAccountData[accountIndex].isValid == false)
+			{
+				screenname[0] = '\0';
+				return false;
+			}
+			for (sint32 i = 0; i < ACT_NICKNAME_LENGTH; i++)
+			{
+				screenname[i] = (uint16)_actAccountData[accountIndex].miiNickname[i];
+			}
+			return true;
+		}
+
+		bool getCountryIndex(uint8 slot, uint32* countryIndex)
+		{
+			sint32 accountIndex = iosuAct_getAccountIndexBySlot(slot);
+			if (_actAccountData[accountIndex].isValid == false)
+			{
+				*countryIndex = 0;
+				return false;
+			}
+			*countryIndex = _actAccountData[accountIndex].countryIndex;
+			return true;
+		}
+
+		bool GetPersistentId(uint8 slot, uint32* persistentId)
+		{
+			sint32 accountIndex = iosuAct_getAccountIndexBySlot(slot);
+			if(!_actAccountData[accountIndex].isValid)
+			{
+				*persistentId = 0;
+				return false;
+			}
+			*persistentId = _actAccountData[accountIndex].persistentId;
+			return true;
+		}
+
+		nnResult AcquireNexToken(uint8 accountSlot, uint64 titleId, uint16 titleVersion, uint32 serverId, uint8* tokenOut, uint32 tokenLen)
+		{
+			if (accountSlot != ACT_SLOT_CURRENT)
+				return ACTResult_InvalidValue;
+			LockedAccount account(accountSlot);
+			if (!account)
+				return ACTResult_AccountDoesNotExist;
+			if (!account->IsNetworkAccount())
+				return ACTResult_NotANetworkAccount;
+			cemu_assert_debug(ActiveSettings::IsOnlineEnabled());
+			if (tokenLen != sizeof(NexToken))
+				return ACTResult_OutOfRange;
+
+			NAPI::AuthInfo authInfo;
+			NAPI::NAPI_MakeAuthInfoFromCurrentAccount(authInfo);
+			NAPI::ACTGetNexTokenResult nexTokenResult = NAPI::ACT_GetNexToken_WithCache(authInfo, titleId, titleVersion, serverId);
+			if (nexTokenResult.isValid())
+			{
+				memcpy(tokenOut, &nexTokenResult.nexToken, sizeof(NexToken));
+				return ACTResult_Ok;
+			}
+			else if (nexTokenResult.apiError == NAPI_RESULT::SERVICE_ERROR)
+			{
+				nnResult returnCode = ServerActErrorCodeToNNResult(nexTokenResult.serviceError);
+				cemu_assert_debug((returnCode&0x80000000) != 0);
+				return returnCode;
+			}
+			return nnResultStatus(NN_RESULT_MODULE_NN_ACT, NN_ERROR_CODE::ACT_UNKNOWN_SERVER_ERROR);
+		}
+
+		nnResult AcquireIndependentServiceToken(uint8 accountSlot, uint64 titleId, uint16 titleVersion, std::string_view clientId, uint8* tokenOut, uint32 tokenLen)
+		{
+			static constexpr size_t IndependentTokenMaxLength = 512+1; // 512 bytes + null terminator
+			if(accountSlot != ACT_SLOT_CURRENT)
+				return ACTResult_InvalidValue;
+			LockedAccount account(accountSlot);
+			if (!account)
+				return ACTResult_AccountDoesNotExist;
+			if (!account->IsNetworkAccount())
+				return ACTResult_NotANetworkAccount;
+			cemu_assert_debug(ActiveSettings::IsOnlineEnabled());
+			if (tokenLen < IndependentTokenMaxLength)
+				return ACTResult_OutOfRange;
+			NAPI::AuthInfo authInfo;
+			NAPI::NAPI_MakeAuthInfoFromCurrentAccount(authInfo);
+			account.Release();
+			NAPI::ACTGetIndependentTokenResult tokenResult = NAPI::ACT_GetIndependentToken_WithCache(authInfo, titleId, titleVersion, clientId);
+			uint32 returnCode = 0;
+			if (tokenResult.isValid())
+			{
+				for (size_t i = 0; i < std::min(tokenResult.token.size(), (size_t)IndependentTokenMaxLength); i++)
+				{
+					tokenOut[i] = tokenResult.token[i];
+					tokenOut[i + 1] = '\0';
+				}
+				returnCode = 0;
+			}
+			else
+			{
+				returnCode = 0x80000000; // todo - proper error codes
+			}
+			return returnCode;
+		}
+
+		class ActService : public iosu::nn::IPCService
+		{
+		public:
+			ActService() : iosu::nn::IPCService("/dev/act") {}
+
+			nnResult ServiceCall(uint32 serviceId, void* request, void* response) override
+			{
+				cemuLog_log(LogType::Force, "Unsupported service call to /dev/act");
+				cemu_assert_unimplemented();
+				return BUILD_NN_RESULT(NN_RESULT_LEVEL_SUCCESS, NN_RESULT_MODULE_NN_ACT, 0);
+			}
+		};
+
+		ActService gActService;
+
+		void Initialize()
+		{
+			gActService.Start();
+		}
+
+		void Stop()
+		{
+			gActService.Stop();
+		}
+	}
+}
+
+
+// IOSU act IO
+
+typedef struct  
+{
+	/* +0x00 */ uint32be ukn00;
+	/* +0x04 */ uint32be ukn04;
+	/* +0x08 */ uint32be ukn08;
+	/* +0x0C */ uint32be subcommandCode;
+	/* +0x10 */ uint8 ukn10;
+	/* +0x11 */ uint8 ukn11;
+	/* +0x12 */ uint8 ukn12;
+	/* +0x13 */ uint8 accountSlot;
+	/* +0x14 */ uint32be unique; // is this command specific?
+}cmdActRequest00_t;
+
+typedef struct  
+{
+	uint32be returnCode;
+	uint8 transferableIdBase[8];
+}cmdActGetTransferableIDResult_t;
+
+#define ACT_SUBCMD_GET_TRANSFERABLE_ID		4
+#define ACT_SUBCMD_INITIALIZE				0x14
+
+#define _cancelIfAccountDoesNotExist() \
+if (_actAccountData[accountIndex].isValid == false) \
+{ \
+	/* account does not exist*/  \
+	ioctlReturnValue = 0; \
+	actCemuRequest->setACTReturnCode(BUILD_NN_RESULT(NN_RESULT_LEVEL_STATUS, NN_RESULT_MODULE_NN_ACT, NN_ACT_RESULT_ACCOUNT_DOES_NOT_EXIST)); /* 0xA071F480 */ \
+	actCemuRequest->resultU64.u64 = 0; \
+	iosuIoctl_completeRequest(ioQueueEntry, ioctlReturnValue); \
+	continue; \
+}
+
 int iosuAct_thread()
 {
 	SetThreadName("iosuAct_thread");
@@ -595,7 +760,7 @@ int iosuAct_thread()
 				}
 				else
 				{
-					forceLogDebug_printf("Gen UUID unknown mode %d", actCemuRequest->uuidName);
+					cemuLog_logDebug(LogType::Force, "Gen UUID unknown mode {}", actCemuRequest->uuidName);
 				}
 				actCemuRequest->setACTReturnCode(0);
 			}
@@ -623,10 +788,19 @@ int iosuAct_thread()
 			}
 			else if (actCemuRequest->requestCode == IOSU_ARC_PERSISTENTID)
 			{
-				accountIndex = iosuAct_getAccountIndexBySlot(actCemuRequest->accountSlot);
-				_cancelIfAccountDoesNotExist();
-				actCemuRequest->resultU32.u32 = _actAccountData[accountIndex].persistentId;
-				actCemuRequest->setACTReturnCode(0);
+				if(actCemuRequest->accountSlot != 0)
+				{
+					accountIndex = iosuAct_getAccountIndexBySlot(actCemuRequest->accountSlot);
+					_cancelIfAccountDoesNotExist();
+					actCemuRequest->resultU32.u32 = _actAccountData[accountIndex].persistentId;
+					actCemuRequest->setACTReturnCode(0);
+				}
+				else
+				{
+					// F1 Race Stars calls IsSlotOccupied and indirectly GetPersistentId on slot 0 which is not valid
+					actCemuRequest->resultU32.u32 = 0;
+					actCemuRequest->setACTReturnCode(0);
+				}
 			}
 			else if (actCemuRequest->requestCode == IOSU_ARC_COUNTRY)
 			{
@@ -644,47 +818,13 @@ int iosuAct_thread()
 			}
 			else if (actCemuRequest->requestCode == IOSU_ARC_ACQUIRENEXTOKEN)
 			{
-				NAPI::AuthInfo authInfo;
-				NAPI::NAPI_MakeAuthInfoFromCurrentAccount(authInfo);
-				NAPI::ACTGetNexTokenResult nexTokenResult = NAPI::ACT_GetNexToken_WithCache(authInfo, actCemuRequest->titleId, actCemuRequest->titleVersion, actCemuRequest->serverId);
-				uint32 returnCode = 0;
-				if (nexTokenResult.isValid())
-				{
-					*(NAPI::ACTNexToken*)actCemuRequest->resultBinary.binBuffer = nexTokenResult.nexToken;
-					returnCode = NN_RESULT_SUCCESS;
-				}
-				else if (nexTokenResult.apiError == NAPI_RESULT::SERVICE_ERROR)
-				{
-					returnCode = ServerActErrorCodeToNNResult(nexTokenResult.serviceError);
-					cemu_assert_debug((returnCode&0x80000000) != 0);
-				}
-				else
-				{
-					returnCode = nnResultStatus(NN_RESULT_MODULE_NN_ACT, NN_ERROR_CODE::ACT_UNKNOWN_SERVER_ERROR);
-				}				
-				actCemuRequest->setACTReturnCode(returnCode);
+				nnResult r = iosu::act::AcquireNexToken(actCemuRequest->accountSlot, actCemuRequest->titleId, actCemuRequest->titleVersion, actCemuRequest->serverId, actCemuRequest->resultBinary.binBuffer, sizeof(NexToken));
+				actCemuRequest->setACTReturnCode(r);
 			}
 			else if (actCemuRequest->requestCode == IOSU_ARC_ACQUIREINDEPENDENTTOKEN)
 			{
-				NAPI::AuthInfo authInfo;
-				NAPI::NAPI_MakeAuthInfoFromCurrentAccount(authInfo);
-				NAPI::ACTGetIndependentTokenResult tokenResult = NAPI::ACT_GetIndependentToken_WithCache(authInfo, actCemuRequest->titleId, actCemuRequest->titleVersion, actCemuRequest->clientId);
-
-				uint32 returnCode = 0;
-				if (tokenResult.isValid())
-				{
-					for (size_t i = 0; i < std::min(tokenResult.token.size(), (size_t)200); i++)
-					{
-						actCemuRequest->resultBinary.binBuffer[i] = tokenResult.token[i];
-						actCemuRequest->resultBinary.binBuffer[i + 1] = '\0';
-					}
-					returnCode = 0;
-				}
-				else
-				{
-					returnCode = 0x80000000; // todo - proper error codes
-				}
-				actCemuRequest->setACTReturnCode(returnCode);
+				nnResult r = iosu::act::AcquireIndependentServiceToken(actCemuRequest->accountSlot, actCemuRequest->titleId, actCemuRequest->titleVersion, actCemuRequest->clientId, actCemuRequest->resultBinary.binBuffer, sizeof(actCemuRequest->resultBinary.binBuffer));
+				actCemuRequest->setACTReturnCode(r);
 			}
 			else if (actCemuRequest->requestCode == IOSU_ARC_ACQUIREPIDBYNNID)
 			{				
diff --git a/src/Cafe/IOSU/legacy/iosu_act.h b/src/Cafe/IOSU/legacy/iosu_act.h
index 04dd579f..8ed408a4 100644
--- a/src/Cafe/IOSU/legacy/iosu_act.h
+++ b/src/Cafe/IOSU/legacy/iosu_act.h
@@ -3,6 +3,8 @@
 void iosuAct_init_depr();
 bool iosuAct_isInitialized();
 
+#define ACT_ACCOUNTID_LENGTH 	(17) // includes '\0'
+
 // Mii
 
 #define MII_FFL_STORAGE_SIZE	(96)
@@ -47,8 +49,11 @@ namespace iosu
 		bool getMii(uint8 slot, FFLData_t* fflData);
 		bool getScreenname(uint8 slot, uint16 screenname[ACT_NICKNAME_LENGTH]);
 		bool getCountryIndex(uint8 slot, uint32* countryIndex);
+		bool GetPersistentId(uint8 slot, uint32* persistentId);
 
-		const uint8 ACT_SLOT_CURRENT = 0xFE;
+		std::string getAccountId2(uint8 slot);
+
+		static constexpr uint8 ACT_SLOT_CURRENT = 0xFE;
 
 		void Initialize();
 		void Stop();
diff --git a/src/Cafe/IOSU/legacy/iosu_boss.cpp b/src/Cafe/IOSU/legacy/iosu_boss.cpp
index 22c11eba..212d42a0 100644
--- a/src/Cafe/IOSU/legacy/iosu_boss.cpp
+++ b/src/Cafe/IOSU/legacy/iosu_boss.cpp
@@ -10,6 +10,7 @@
 #include <fstream>
 
 #include "config/ActiveSettings.h"
+#include "config/NetworkSettings.h"
 #include "curl/curl.h"
 #include "openssl/bn.h"
 #include "openssl/x509.h"
@@ -118,7 +119,7 @@ namespace iosu
 		uint32 turn_state = 0;
 		uint32 wait_state = 0;
 
-		uint32 http_status_code = 0;
+		long http_status_code = 0;
 		ContentType content_type = ContentType::kUnknownContent;
 
 		std::vector<uint8> result_buffer;
@@ -136,6 +137,10 @@ namespace iosu
 			this->task_settings.taskType = settings->taskType;
 
 			curl = std::shared_ptr<CURL>(curl_easy_init(), curl_easy_cleanup);
+			if(GetConfig().proxy_server.GetValue() != "")
+			{
+			  curl_easy_setopt(curl.get(), CURLOPT_PROXY, GetConfig().proxy_server.GetValue().c_str());
+			}
 		}
 	};
 
@@ -238,7 +243,7 @@ namespace iosu
 		//	task->result_buffer.resize(task->result_buffer.size() + writeByteSize);
 		//writeByteSize = min(writeByteSize, task->result_buffer.capacity() - task->processed_length);
 
-		//forceLogDebug_printf("task_write_callback: %d (processed: %d)", writeByteSize, task->processed_length);
+		//cemuLog_logDebug(LogType::Force, "task_write_callback: {} (processed: {})", writeByteSize, task->processed_length);
 		if (writeByteSize > 0)
 		{
 			//memcpy(task->result_buffer.data() + task->processed_length, ptr, writeByteSize);
@@ -251,7 +256,7 @@ namespace iosu
 
 	size_t task_download_header_callback(char* ptr, size_t size, size_t nitems, void* userdata)
 	{
-		//forceLogDebug_printf("\tHeader: %s", ptr);
+		//cemuLog_logDebug(LogType::Force, "\tHeader: {}", ptr);
 
 		return size * nitems;
 	}
@@ -283,7 +288,7 @@ namespace iosu
 		else if (starts_with(ptr, "Content-Type: "))
 		{
 			const char* type = &ptr[14];
-			if (starts_with(type, "application/xml"))
+			if (starts_with(type, "application/xml") || starts_with(type, "text/xml"))
 				task->content_type = ContentType::kXmlContent;
 			else if (starts_with(type, "x-application/octet-stream"))
 				task->content_type = ContentType::kBinaryFile;
@@ -291,7 +296,7 @@ namespace iosu
 				task->content_type = ContentType::kText;
 			else
 			{
-				forceLogDebug_printf("task_header_callback: unknown content type > %s", type);
+				cemuLog_logDebug(LogType::Force, "task_header_callback: unknown content type > {}", type);
 			}
 		}
 		else if (starts_with(ptr, "Last-Modified: "))
@@ -299,8 +304,8 @@ namespace iosu
 			// TODO timestamp (?)
 		}
 
-		//forceLogDebug_printf("task_header_callback: len %d (%d) and type %d", task->content_length, task->result_buffer.capacity(), task->content_type);
-		//forceLogDebug_printf("\t%s", ptr);
+		//cemuLog_logDebug(LogType::Force, "task_header_callback: len {} ({}) and type {}", task->content_length, task->result_buffer.capacity(), task->content_type);
+		//cemuLog_logDebug(LogType::Force, "\t{}", ptr);
 		return size * nitems;
 	}
 
@@ -309,7 +314,7 @@ namespace iosu
 		auto task_settings = (TaskSetting*)param;
 		if (task_settings->taskType == kRawDlTaskSetting)
 		{
-			forceLogDebug_printf("sslctx_function: adding client cert: %d", (int)task_settings->settings[TaskSetting::kClientCert]);
+			cemuLog_logDebug(LogType::Force, "sslctx_function: adding client cert: {}", (int)task_settings->settings[TaskSetting::kClientCert]);
 			if (!iosuCrypto_addClientCertificate(sslctx, task_settings->settings[TaskSetting::kClientCert]))
 				assert_dbg();
 
@@ -318,10 +323,10 @@ namespace iosu
 			{
 				if (task_settings->settings[location] != 0)
 				{
-					forceLogDebug_printf("sslctx_function: adding ca cert: %d", (int)task_settings->settings[location]);
+					cemuLog_logDebug(LogType::Force, "sslctx_function: adding ca cert: {}", (int)task_settings->settings[location]);
 					if (!iosuCrypto_addCACertificate(sslctx, task_settings->settings[location]))
 					{
-						forceLog_printf("Failed to load CA certificate file");
+						cemuLog_log(LogType::Force, "Failed to load CA certificate file");
 						assert_dbg();
 					}
 				}
@@ -333,13 +338,13 @@ namespace iosu
 		{
 			if (!iosuCrypto_addCACertificate(sslctx, 105))
 			{
-				forceLog_printf("Failed to load certificate file");
+				cemuLog_log(LogType::Force, "Failed to load certificate file");
 				assert_dbg();
 			}
 
 			if (!iosuCrypto_addClientCertificate(sslctx, 3))
 			{
-				forceLog_printf("Failed to load client certificate file");
+				cemuLog_log(LogType::Force, "Failed to load client certificate file");
 				assert_dbg();
 			}
 		}
@@ -366,7 +371,7 @@ namespace iosu
 	bool parse_xml_content(Task& task)
 	{
 		tinyxml2::XMLDocument doc;
-		//cafeLog_writeLineToLog((char*)task.result_buffer.data());
+		//cemuLog_log(LogType::Force, (char*)task.result_buffer.data());
 		if (doc.Parse((const char*)task.result_buffer.data(), task.processed_length) != tinyxml2::XML_SUCCESS)
 			return false;
 
@@ -456,7 +461,7 @@ namespace iosu
 			it->wait_state = TRUE;
 			return BUILD_NN_RESULT(NN_RESULT_LEVEL_SUCCESS, NN_RESULT_MODULE_NN_BOSS, 0);
 		}
-		forceLogDebug_printf("task run state: %d | exec: %d (tasks: %d)", it->turn_state, it->exec_count, g_boss.tasks.size());
+		cemuLog_logDebug(LogType::Force, "task run state: {} | exec: {} (tasks: {})", it->turn_state, it->exec_count, g_boss.tasks.size());
 		it->turn_state = kRunning;
 		it->exec_count++;
 
@@ -485,7 +490,7 @@ namespace iosu
 		CURL* curl = it->curl.get();
 		curl_easy_setopt(curl, CURLOPT_FOLLOWLOCATION, 1);
 		curl_easy_setopt(curl, CURLOPT_MAXREDIRS, 2);
-#ifndef PUBLIC_RELEASE
+#ifdef CEMU_DEBUG_ASSERT
 		curl_easy_setopt(curl, CURLOPT_VERBOSE, 1);
 		char errbuf[CURL_ERROR_SIZE]{};
 		curl_easy_setopt(curl, CURLOPT_ERRORBUFFER, errbuf);
@@ -497,19 +502,28 @@ namespace iosu
 		curl_easy_setopt(curl, CURLOPT_HEADERFUNCTION, task_header_callback);
 		curl_easy_setopt(curl, CURLOPT_HEADERDATA, &(*it));
 		curl_easy_setopt(curl, CURLOPT_TIMEOUT, 0x3C);
-		curl_easy_setopt(curl, CURLOPT_SSL_CTX_FUNCTION, task_sslctx_function);
-		curl_easy_setopt(curl, CURLOPT_SSL_CTX_DATA, &it->task_settings);
-		curl_easy_setopt(curl, CURLOPT_SSLVERSION, CURL_SSLVERSION_TLSv1_0);
+		curl_easy_setopt(curl, CURLOPT_HTTP_VERSION, CURL_HTTP_VERSION_1_1);
+		if (IsNetworkServiceSSLDisabled(ActiveSettings::GetNetworkService()))
+		{ 
+			curl_easy_setopt(curl,CURLOPT_SSL_VERIFYPEER,0L);
+		}
+		else 
+		{
+			curl_easy_setopt(curl, CURLOPT_SSL_CTX_FUNCTION, task_sslctx_function);
+			curl_easy_setopt(curl, CURLOPT_SSL_CTX_DATA, &it->task_settings);
+			curl_easy_setopt(curl, CURLOPT_SSLVERSION, CURL_SSLVERSION_TLSv1_0);
+		}
 
-		char url[512];
+		std::string requestUrl;
 		if(it->task_settings.taskType == kRawDlTaskSetting)
 		{
 			char serviceToken[TaskSetting::kServiceTokenLen];
 			strncpy(serviceToken, (char*)&it->task_settings.settings[TaskSetting::kServiceToken], TaskSetting::kServiceTokenLen);
 			list_headerParam = append_header_param(list_headerParam, "X-Nintendo-ServiceToken: {}", serviceToken);
 
+			char url[TaskSetting::kURLLen + 1]{};
 			strncpy(url, (char*)&it->task_settings.settings[TaskSetting::kURL], TaskSetting::kURLLen);
-			forceLogDebug_printf("\tserviceToken: %s", serviceToken);
+			requestUrl.assign(url);
 		}
 		else
 		{
@@ -562,15 +576,28 @@ namespace iosu
 			char boss_code[0x20];
 			strncpy(boss_code, (char*)&it->task_settings.settings[TaskSetting::kBossCode], TaskSetting::kBossCodeLen);
 
-			sprintf(url, "https://npts.app.nintendo.net/p01/tasksheet/%s/%s/%s?c=%s&l=%s", "1", boss_code, it->task_id, countryCode, languageCode);
+			switch (ActiveSettings::GetNetworkService())
+			{
+			case NetworkService::Pretendo:
+				requestUrl = PretendoURLs::BOSSURL;
+				break;
+			case NetworkService::Custom:
+				requestUrl = GetNetworkConfig().urls.BOSS.GetValue();
+				break;
+			case NetworkService::Nintendo:
+			default:
+				requestUrl = NintendoURLs::BOSSURL;
+				break;
+			}
+			requestUrl.append(fmt::format(fmt::runtime("/{}/{}/{}?c={}&l={}"), "1", boss_code, it->task_id, countryCode, languageCode));
 		}
 
 		curl_easy_setopt(curl, CURLOPT_HTTPHEADER, list_headerParam);
-		curl_easy_setopt(curl, CURLOPT_URL, url);
-		forceLogDebug_printf("task_run url %s", url);
+		curl_easy_setopt(curl, CURLOPT_URL, requestUrl.c_str());
 
 		int curl_result = curl_easy_perform(curl);
 		curl_easy_getinfo(curl, CURLINFO_RESPONSE_CODE, &it->http_status_code);
+		static_assert(sizeof(it->http_status_code) == sizeof(long));
 
 		//it->turn_state = kFinished;
 
@@ -579,26 +606,26 @@ namespace iosu
 
 		if (curl_result != CURLE_OK)
 		{
-#ifndef PUBLIC_RELEASE
-			forceLogDebug_printf("curl error buff: %s", errbuf);
+#ifdef CEMU_DEBUG_ASSERT
+			cemuLog_logDebug(LogType::Force, "curl error buff: {}", errbuf);
 #endif
 			it->turn_state = kError;
 			it->wait_state = TRUE;
-			forceLogDebug_printf("task_run curl fail: %d", curl_result);
+			cemuLog_logDebug(LogType::Force, "task_run curl fail: {}", curl_result);
 			return BUILD_NN_RESULT(NN_RESULT_LEVEL_FATAL, NN_RESULT_MODULE_NN_BOSS, 0);
 		}
 		else
 		{
 			if (it->http_status_code != 200)
 			{
-				forceLogDebug_printf("BOSS task_run: Received unexpected HTTP response code");
+				cemuLog_logDebug(LogType::Force, "BOSS task_run: Received unexpected HTTP response code");
 			}
 			if (it->http_status_code == 404)
 			{
 				// todo - is this correct behavior?
 				it->turn_state = kError;
 				it->wait_state = TRUE;
-				forceLogDebug_printf("task_run failed due to 404 error");
+				cemuLog_logDebug(LogType::Force, "task_run failed due to 404 error");
 				return BUILD_NN_RESULT(NN_RESULT_LEVEL_FATAL, NN_RESULT_MODULE_NN_BOSS, 0);
 			}
 		}
@@ -612,7 +639,7 @@ namespace iosu
 
 			break;
 		case ContentType::kText:
-			forceLogDebug_printf("task_run returns text: %.*s", it->content_length, it->result_buffer.data());
+			cemuLog_logDebug(LogType::Force, "task_run returns text: {}", fmt::ptr(it->result_buffer.data()));
 			break;
 		}
 
@@ -632,7 +659,7 @@ namespace iosu
 
 				char targetFileName[TaskSetting::kFileNameLen + 1]{};
 				strncpy(targetFileName, (char*)&it->task_settings.settings[TaskSetting::kNbdlFileName], TaskSetting::kFileNameLen);
-				forceLogDebug_printf("\tnbdl task target filename: \"%s\"", targetFileName);
+				cemuLog_logDebug(LogType::Force, "\tnbdl task target filename: \"{}\"", targetFileName);
 				const bool hasFileName = targetFileName[0] != '\0';
 
 				while (!it->queued_files.empty())
@@ -664,7 +691,8 @@ namespace iosu
 					}
 
 					auto currentEntry = boss_storage_fad_find_entry(fad_content, file.data_id);
-					if(currentEntry)
+					//TODO deep dive into IOSU to figure out how caching actually works on th Wii U
+					if(currentEntry && fs::exists(path / fmt::format(L"{:08x}", file.data_id)))
 					{
 						uint64 timestamp = (uint64)currentEntry->timestampRelated + kTimeStampConvertSeconds;
 						curl_easy_setopt(curl, CURLOPT_TIMEVALUE, timestamp);
@@ -682,7 +710,7 @@ namespace iosu
 					curl_result = curl_easy_perform(curl);
 					if (curl_result != CURLE_OK)
 					{
-						forceLogDebug_printf("task_run curl failed on file download (%d): %s > %s", curl_result, file.file_name.c_str(), file.url.c_str());
+						cemuLog_logDebug(LogType::Force, "task_run curl failed on file download ({}): {} > {}", curl_result, file.file_name, file.url);
 						if (hasFileName)
 						{
 							turnstate = kError;
@@ -705,7 +733,7 @@ namespace iosu
 
 					if(it->processed_file_size != file.size)
 					{
-						forceLogDebug_printf("task_run file download size mismatch: %s > %s > %d from %d bytes", file.file_name.c_str(), file.url.c_str(), it->processed_file_size, file.size);
+						cemuLog_logDebug(LogType::Force, "task_run file download size mismatch: {} > {} > {} from {} bytes", file.file_name, file.url, it->processed_file_size, file.size);
 						if (hasFileName)
 						{
 							turnstate = kError;
@@ -774,7 +802,7 @@ namespace iosu
 					}
 					catch (const std::exception& ex)
 					{
-						forceLogDebug_printf("file error: %s", ex.what());
+						cemuLog_logDebug(LogType::Force, "file error: {}", ex.what());
 					}
 
 					if (hasFileName)
@@ -783,7 +811,7 @@ namespace iosu
 			}
 			catch (const std::exception& ex)
 			{
-				forceLogDebug_printf("dir error: %s", ex.what());
+				cemuLog_logDebug(LogType::Force, "dir error: {}", ex.what());
 			}
 		}
 
@@ -843,7 +871,7 @@ namespace iosu
 		{
 			if (timeout != 0 && (uint32)std::chrono::duration_cast<std::chrono::seconds>(tick_cached() - start).count() >= timeout)
 			{
-				forceLogDebug_printf("task_wait: timeout reached -> %d seconds passed", timeout);
+				cemuLog_logDebug(LogType::Force, "task_wait: timeout reached -> {} seconds passed", timeout);
 				return false;
 			}
 
@@ -887,10 +915,10 @@ namespace iosu
 		return it != g_boss.tasks.cend() ? std::make_pair(it->exec_count, it->processed_length) : std::make_pair(0u, (uint64)0);
 	}
 
-	std::pair<uint32, uint32> task_get_http_status_code(const char* taskId, uint32 accountId, uint64 titleId)
+	std::pair<uint32, long> task_get_http_status_code(const char* taskId, uint32 accountId, uint64 titleId)
 	{
 		const auto it = get_task(taskId, accountId, titleId);
-		return it != g_boss.tasks.cend() ? std::make_pair(it->exec_count, it->http_status_code) : std::make_pair(0u, (uint32)0);
+		return it != g_boss.tasks.cend() ? std::make_pair(it->exec_count, it->http_status_code) : std::make_pair(0u, (long)0);
 	}
 
 	std::pair<uint32, uint32> task_get_turn_state(const char* taskId, uint32 accountId, uint64 titleId)
diff --git a/src/Cafe/IOSU/legacy/iosu_crypto.cpp b/src/Cafe/IOSU/legacy/iosu_crypto.cpp
index e74a93e2..a4f75430 100644
--- a/src/Cafe/IOSU/legacy/iosu_crypto.cpp
+++ b/src/Cafe/IOSU/legacy/iosu_crypto.cpp
@@ -273,7 +273,7 @@ void iosuCrypto_generateDeviceCertificate()
 	BIGNUM* bn_x = BN_CTX_get(context);
 	BIGNUM* bn_y = BN_CTX_get(context);	
 
-	EC_POINT_get_affine_coordinates_GF2m(group, pubkey, bn_x, bn_y, NULL);
+	EC_POINT_get_affine_coordinates(group, pubkey, bn_x, bn_y, NULL);
 
 	uint8 publicKeyOutput[0x3C];
 	memset(publicKeyOutput, 0, sizeof(publicKeyOutput));
@@ -292,16 +292,6 @@ void iosuCrypto_generateDeviceCertificate()
 	BN_CTX_free(context);
 }
 
-bool iosuCrypto_hasAllDataForLogin()
-{
-	if (hasOtpMem == false)
-		return false;
-	if (hasSeepromMem == false)
-		return false;
-	// todo - check if certificates are available
-	return true;
-}
-
 sint32 iosuCrypto_getDeviceCertificateBase64Encoded(char* output)
 {
 	iosuCrypto_base64Encode((uint8*)&g_wiiuDeviceCert, sizeof(g_wiiuDeviceCert), output);
@@ -326,12 +316,12 @@ bool iosuCrypto_loadCertificate(uint32 id, std::wstring_view mlcSubpath, std::ws
 		pkeyData = FileStream::LoadIntoMemory(pkeyPath);
 		if (!pkeyData || pkeyData->empty())
 		{
-			cemuLog_force("Unable to load private key file {}", pkeyPath.generic_string());
+			cemuLog_log(LogType::Force, "Unable to load private key file {}", pkeyPath.generic_string());
 			return false;
 		}
 		else if ((pkeyData->size() % 16) != 0)
 		{
-			cemuLog_force("Private key file has invalid length. Possibly corrupted? File: {}", pkeyPath.generic_string());
+			cemuLog_log(LogType::Force, "Private key file has invalid length. Possibly corrupted? File: {}", pkeyPath.generic_string());
 			return false;
 		}
 	}
@@ -393,24 +383,24 @@ bool iosuCrypto_addClientCertificate(void* sslctx, sint32 certificateId)
 		{
 			if (SSL_CTX_use_certificate(ctx, iosuCryptoCertificates.certList[i].cert) != 1)
 			{
-				forceLog_printf("Unable to setup certificate %d", certificateId);
+				cemuLog_log(LogType::Force, "Unable to setup certificate {}", certificateId);
 				return false;
 			}
 			if (SSL_CTX_use_RSAPrivateKey(ctx, iosuCryptoCertificates.certList[i].pkey) != 1)
 			{
-				forceLog_printf("Unable to setup certificate %d RSA private key", certificateId);
+				cemuLog_log(LogType::Force, "Unable to setup certificate {} RSA private key", certificateId);
 				return false;
 			}
 
 			if (SSL_CTX_check_private_key(ctx) == false)
 			{
-				forceLog_printf("Certificate private key could not be validated (verify required files for online mode or disable online mode)");
+				cemuLog_log(LogType::Force, "Certificate private key could not be validated (verify required files for online mode or disable online mode)");
 			}
 
 			return true;
 		}
 	}
-	forceLog_printf("Certificate not found (verify required files for online mode or disable online mode)");
+	cemuLog_log(LogType::Force, "Certificate not found (verify required files for online mode or disable online mode)");
 	return false;
 }
 
@@ -438,7 +428,7 @@ bool iosuCrypto_addCustomCACertificate(void* sslctx, uint8* certData, sint32 cer
 	X509* cert = d2i_X509(NULL, (const unsigned char**)&tempPtr, certLength);
 	if (cert == nullptr)
 	{
-		forceLog_printf("Invalid custom server PKI certificate");
+		cemuLog_log(LogType::Force, "Invalid custom server PKI certificate");
 		return false;
 	}
 	X509_STORE_add_cert(store, cert);
@@ -563,7 +553,7 @@ void iosuCrypto_loadSSLCertificates()
 void iosuCrypto_init()
 {
 	// load OTP dump
-	if (std::ifstream otp_file(ActiveSettings::GetPath("otp.bin"), std::ifstream::in | std::ios::binary); otp_file.is_open())
+	if (std::ifstream otp_file(ActiveSettings::GetUserDataPath("otp.bin"), std::ifstream::in | std::ios::binary); otp_file.is_open())
 	{
 		otp_file.seekg(0, std::ifstream::end);
 		const auto length = otp_file.tellg();
@@ -571,7 +561,7 @@ void iosuCrypto_init()
 		// verify if OTP is ok
 		if (length != 1024) // todo - should also check some fixed values to verify integrity of otp dump
 		{
-			forceLog_printf("IOSU_CRYPTO: otp.bin has wrong size (must be 1024 bytes)");
+			cemuLog_log(LogType::Force, "IOSU_CRYPTO: otp.bin has wrong size (must be 1024 bytes)");
 			hasOtpMem = false;
 		}
 		else
@@ -582,11 +572,11 @@ void iosuCrypto_init()
 	}
 	else
 	{
-		forceLog_printf("IOSU_CRYPTO: No otp.bin found. Online mode cannot be used");
+		cemuLog_log(LogType::Force, "IOSU_CRYPTO: No otp.bin found. Online mode cannot be used");
 		hasOtpMem = false;
 	}
 
-	if (std::ifstream seeprom_file(ActiveSettings::GetPath("seeprom.bin"), std::ifstream::in | std::ios::binary); seeprom_file.is_open())
+	if (std::ifstream seeprom_file(ActiveSettings::GetUserDataPath("seeprom.bin"), std::ifstream::in | std::ios::binary); seeprom_file.is_open())
 	{
 		seeprom_file.seekg(0, std::ifstream::end);
 		const auto length = seeprom_file.tellg();
@@ -615,10 +605,10 @@ void iosuCrypto_init()
 	iosuCrypto_loadSSLCertificates();
 }
 
-bool iosuCrypto_checkRequirementMLCFile(std::string_view mlcSubpath, std::wstring& additionalErrorInfo_filePath)
+bool iosuCrypto_checkRequirementMLCFile(std::string_view mlcSubpath, std::string& additionalErrorInfo_filePath)
 {
 	const auto path = ActiveSettings::GetMlcPath(mlcSubpath);
-	additionalErrorInfo_filePath = path.generic_wstring();
+	additionalErrorInfo_filePath = _pathToUtf8(path);
 	sint32 fileDataSize = 0;
 	auto fileData = FileStream::LoadIntoMemory(path);
 	if (!fileData)
@@ -626,17 +616,17 @@ bool iosuCrypto_checkRequirementMLCFile(std::string_view mlcSubpath, std::wstrin
 	return true;
 }
 
-sint32 iosuCrypt_checkRequirementsForOnlineMode(std::wstring& additionalErrorInfo)
+sint32 iosuCrypt_checkRequirementsForOnlineMode(std::string& additionalErrorInfo)
 {
 	std::error_code ec;
 	// check if otp.bin is present
-	const auto otp_file = ActiveSettings::GetPath("otp.bin");
+	const auto otp_file = ActiveSettings::GetUserDataPath("otp.bin");
 	if(!fs::exists(otp_file, ec))
 		return IOS_CRYPTO_ONLINE_REQ_OTP_MISSING;
 	if(fs::file_size(otp_file, ec) != 1024)
 		return IOS_CRYPTO_ONLINE_REQ_OTP_CORRUPTED;
 	// check if seeprom.bin is present
-	const auto seeprom_file = ActiveSettings::GetPath("seeprom.bin");
+	const auto seeprom_file = ActiveSettings::GetUserDataPath("seeprom.bin");
 	if (!fs::exists(seeprom_file, ec))
 		return IOS_CRYPTO_ONLINE_REQ_SEEPROM_MISSING;
 	if (fs::file_size(seeprom_file, ec) != 512)
diff --git a/src/Cafe/IOSU/legacy/iosu_crypto.h b/src/Cafe/IOSU/legacy/iosu_crypto.h
index bf3d7e2f..d4fc49b9 100644
--- a/src/Cafe/IOSU/legacy/iosu_crypto.h
+++ b/src/Cafe/IOSU/legacy/iosu_crypto.h
@@ -2,7 +2,6 @@
 
 void iosuCrypto_init();
 
-bool iosuCrypto_hasAllDataForLogin();
 bool iosuCrypto_getDeviceId(uint32* deviceId);
 void iosuCrypto_getDeviceSerialString(char* serialString);
 
@@ -74,7 +73,7 @@ enum
 	IOS_CRYPTO_ONLINE_REQ_MISSING_FILE
 };
 
-sint32 iosuCrypt_checkRequirementsForOnlineMode(std::wstring& additionalErrorInfo);
+sint32 iosuCrypt_checkRequirementsForOnlineMode(std::string& additionalErrorInfo);
 void iosuCrypto_readOtpData(void* output, sint32 wordIndex, sint32 size);
 
 std::vector<const wchar_t*> iosuCrypt_getCertificateKeys();
diff --git a/src/Cafe/IOSU/legacy/iosu_fpd.cpp b/src/Cafe/IOSU/legacy/iosu_fpd.cpp
index ec8733ab..a667e61c 100644
--- a/src/Cafe/IOSU/legacy/iosu_fpd.cpp
+++ b/src/Cafe/IOSU/legacy/iosu_fpd.cpp
@@ -1,4 +1,3 @@
-#include "iosu_ioctl.h"
 #include "iosu_act.h"
 #include "iosu_fpd.h"
 #include "Cemu/nex/nex.h"
@@ -9,12 +8,10 @@
 #include "config/ActiveSettings.h"
 #include "Cemu/napi/napi.h"
 #include "util/helpers/StringHelpers.h"
-#include "Cafe/OS/libs/coreinit/coreinit.h"
+#include "Cafe/IOSU/iosu_types_common.h"
+#include "Cafe/IOSU/nn/iosu_nn_service.h"
 
-uint32 memory_getVirtualOffsetFromPointer(void* ptr); // remove once we updated everything to MEMPTR
-
-SysAllocator<uint32be> _fpdAsyncLoginRetCode;
-SysAllocator<uint32be> _fpdAsyncAddFriendRetCode;
+#include "Common/CafeString.h"
 
 std::mutex g_friend_notification_mutex;
 std::vector< std::pair<std::string, int> > g_friend_notifications;
@@ -23,83 +20,119 @@ namespace iosu
 {
 	namespace fpd
 	{
+		using NotificationRunningId = uint64;
+
+		struct NotificationEntry
+		{
+			NotificationEntry(uint64 index, NexFriends::NOTIFICATION_TYPE type, uint32 pid) : timestamp(std::chrono::steady_clock::now()), runningId(index), type(type), pid(pid) {}
+			std::chrono::steady_clock::time_point timestamp;
+			NotificationRunningId runningId;
+			NexFriends::NOTIFICATION_TYPE type;
+			uint32 pid;
+		};
+
+		class
+		{
+		  public:
+			void TrackNotification(NexFriends::NOTIFICATION_TYPE type, uint32 pid)
+			{
+				std::unique_lock _l(m_mtxNotificationQueue);
+				m_notificationQueue.emplace_back(m_notificationQueueIndex++, type, pid);
+			}
+
+			void RemoveExpired()
+			{
+				// remove entries older than 10 seconds
+				std::chrono::steady_clock::time_point expireTime = std::chrono::steady_clock::now() - std::chrono::seconds(10);
+				std::erase_if(m_notificationQueue, [expireTime](const auto& notification) {
+					return notification.timestamp < expireTime;
+				});
+			}
+
+			std::optional<NotificationEntry> GetNextNotification(NotificationRunningId& previousRunningId)
+			{
+				std::unique_lock _l(m_mtxNotificationQueue);
+				auto it = std::lower_bound(m_notificationQueue.begin(), m_notificationQueue.end(), previousRunningId, [](const auto& notification, const auto& runningId) {
+					return notification.runningId <= runningId;
+				});
+				size_t itIndex = it - m_notificationQueue.begin();
+				if(it == m_notificationQueue.end())
+					return std::nullopt;
+				previousRunningId = it->runningId;
+				return *it;
+			}
+
+		  private:
+			std::vector<NotificationEntry> m_notificationQueue;
+			std::mutex m_mtxNotificationQueue;
+			std::atomic_uint64_t m_notificationQueueIndex{1};
+		}g_NotificationQueue;
 
 		struct  
 		{
 			bool isThreadStarted;
 			bool isInitialized2;
 			NexFriends* nexFriendSession;
-			// notification handler
-			MPTR notificationFunc;
-			MPTR notificationCustomParam;
-			uint32 notificationMask;
-			// login callback
-			struct  
-			{
-				MPTR func;
-				MPTR customParam;
-			}asyncLoginCallback;
+			std::mutex mtxFriendSession;
+			// session state
+			std::atomic_bool sessionStarted{false};
 			// current state
 			nexPresenceV2 myPresence;
 		}g_fpd = {};
 
-		void notificationHandler(NexFriends::NOTIFICATION_TYPE type, uint32 pid)
+		void OverlayNotificationHandler(NexFriends::NOTIFICATION_TYPE type, uint32 pid)
 		{
-			forceLogDebug_printf("Friends::Notification %02x pid %08x", type, pid);
-			if(GetConfig().notification.friends)
+			cemuLog_logDebug(LogType::Force, "Friends::Notification {:02x} pid {:08x}", type, pid);
+			if(!GetConfig().notification.friends)
+				return;
+			std::unique_lock lock(g_friend_notification_mutex);
+			std::string message;
+			if(type == NexFriends::NOTIFICATION_TYPE::NOTIFICATION_TYPE_ONLINE)
 			{
-				std::unique_lock lock(g_friend_notification_mutex);
-				std::string message;
-				if(type == NexFriends::NOTIFICATION_TYPE::NOTIFICATION_TYPE_ONLINE)
+				g_friend_notifications.emplace_back("Connected to friend service", 5000);
+				if(g_fpd.nexFriendSession && g_fpd.nexFriendSession->getPendingFriendRequestCount() > 0)
+					g_friend_notifications.emplace_back(fmt::format("You have {} pending friend request(s)", g_fpd.nexFriendSession->getPendingFriendRequestCount()), 5000);
+			}
+			else
+			{
+				std::string msg_format;
+				switch(type)
 				{
-					g_friend_notifications.emplace_back("Connected to friend service", 5000);
-					if(g_fpd.nexFriendSession && g_fpd.nexFriendSession->getPendingFriendRequestCount() > 0)
-						g_friend_notifications.emplace_back(fmt::format("You have {} pending friend request(s)", g_fpd.nexFriendSession->getPendingFriendRequestCount()), 5000);
+				case NexFriends::NOTIFICATION_TYPE_ONLINE: break;
+				case NexFriends::NOTIFICATION_TYPE_FRIEND_LOGIN: msg_format = "{} is now online"; break;
+				case NexFriends::NOTIFICATION_TYPE_FRIEND_LOGOFF: msg_format = "{} is now offline"; break;
+				case NexFriends::NOTIFICATION_TYPE_FRIEND_PRESENCE_CHANGE: break;
+				case NexFriends::NOTIFICATION_TYPE_ADDED_FRIEND: msg_format = "{} has been added to your friend list"; break;
+				case NexFriends::NOTIFICATION_TYPE_REMOVED_FRIEND: msg_format = "{} has been removed from your friend list"; break;
+				case NexFriends::NOTIFICATION_TYPE_ADDED_OUTGOING_REQUEST: break;
+				case NexFriends::NOTIFICATION_TYPE_REMOVED_OUTGOING_REQUEST: break;
+				case NexFriends::NOTIFICATION_TYPE_ADDED_INCOMING_REQUEST: msg_format = "{} wants to add you to his friend list"; break;
+				case NexFriends::NOTIFICATION_TYPE_REMOVED_INCOMING_REQUEST: break;
+				default: ;
 				}
-				else
+				if (!msg_format.empty())
 				{
-					std::string msg_format;
-					switch(type)
+					std::string name = fmt::format("{:#x}", pid);
+					if (g_fpd.nexFriendSession)
 					{
-					case NexFriends::NOTIFICATION_TYPE_ONLINE: break;
-					case NexFriends::NOTIFICATION_TYPE_FRIEND_LOGIN: msg_format = "{} is now online"; break;
-					case NexFriends::NOTIFICATION_TYPE_FRIEND_LOGOFF: msg_format = "{} is now offline"; break;
-					case NexFriends::NOTIFICATION_TYPE_FRIEND_PRESENCE_CHANGE: break;
-					case NexFriends::NOTIFICATION_TYPE_ADDED_FRIEND: msg_format = "{} has been added to your friend list"; break;
-					case NexFriends::NOTIFICATION_TYPE_REMOVED_FRIEND: msg_format = "{} has been removed from your friend list"; break;
-					case NexFriends::NOTIFICATION_TYPE_ADDED_OUTGOING_REQUEST: break;
-					case NexFriends::NOTIFICATION_TYPE_REMOVED_OUTGOING_REQUEST: break;
-					case NexFriends::NOTIFICATION_TYPE_ADDED_INCOMING_REQUEST: msg_format = "{} wants to add you to his friend list"; break;
-					case NexFriends::NOTIFICATION_TYPE_REMOVED_INCOMING_REQUEST: break;
-					default: ;
-					}
-					
-					if (!msg_format.empty())
-					{
-						std::string name = fmt::format("{:#x}", pid);
-						if (g_fpd.nexFriendSession)
-						{
-							const std::string tmp = g_fpd.nexFriendSession->getAccountNameByPid(pid);
-							if (!tmp.empty())
-								name = tmp;
-						}
-
-						g_friend_notifications.emplace_back(fmt::format(fmt::runtime(msg_format), name), 5000);
+						const std::string tmp = g_fpd.nexFriendSession->getAccountNameByPid(pid);
+						if (!tmp.empty())
+							name = tmp;
 					}
+					g_friend_notifications.emplace_back(fmt::format(fmt::runtime(msg_format), name), 5000);
 				}
 			}
+		}
 
-			if (g_fpd.notificationFunc == MPTR_NULL)
-				return;
-			uint32 notificationFlag = 1 << (type - 1);
-			if ( (notificationFlag&g_fpd.notificationMask) == 0 )
-				return;
-			coreinitAsyncCallback_add(g_fpd.notificationFunc, 3, type, pid, g_fpd.notificationCustomParam);
+		void NotificationHandler(NexFriends::NOTIFICATION_TYPE type, uint32 pid)
+		{
+			OverlayNotificationHandler(type, pid);
+			g_NotificationQueue.TrackNotification(type, pid);
 		}
 
 		void convertMultiByteStringToBigEndianWidechar(const char* input, uint16be* output, sint32 maxOutputLength)
 		{
-			std::basic_string<uint16be> beStr = StringHelpers::FromUtf8(input);
+			std::vector<uint16be> beStr = StringHelpers::FromUtf8(input);
 			if (beStr.size() >= maxOutputLength - 1)
 				beStr.resize(maxOutputLength-1);
 			for (size_t i = 0; i < beStr.size(); i++)
@@ -107,7 +140,7 @@ namespace iosu
 			output[beStr.size()] = '\0';
 		}
 
-		void convertFPDTimestampToDate(uint64 timestamp, fpdDate_t* fpdDate)
+		void convertFPDTimestampToDate(uint64 timestamp, FPDDate* fpdDate)
 		{
 			// if the timestamp is zero then still return a valid date
 			if (timestamp == 0)
@@ -128,7 +161,7 @@ namespace iosu
 			fpdDate->year = (uint16)((timestamp >> 26));
 		}
 
-		uint64 convertDateToFPDTimestamp(fpdDate_t* fpdDate)
+		uint64 convertDateToFPDTimestamp(FPDDate* fpdDate)
 		{
 			uint64 t = 0;
 			t |= (uint64)fpdDate->second;
@@ -140,92 +173,33 @@ namespace iosu
 			return t;
 		}
 
-		void startFriendSession()
+		void NexPresenceToGameMode(const nexPresenceV2* presence, GameMode* gameMode)
 		{
-			cemu_assert(!g_fpd.nexFriendSession);
-
-			NAPI::AuthInfo authInfo;
-			NAPI::NAPI_MakeAuthInfoFromCurrentAccount(authInfo);
-			NAPI::ACTGetNexTokenResult nexTokenResult = NAPI::ACT_GetNexToken_WithCache(authInfo, 0x0005001010001C00, 0x0000, 0x00003200);
-			if (nexTokenResult.isValid())
-			{
-				// get values needed for friend session
-				uint32 myPid;
-				uint8 currentSlot = iosu::act::getCurrentAccountSlot();
-				iosu::act::getPrincipalId(currentSlot, &myPid);
-				char accountId[256] = { 0 };
-				iosu::act::getAccountId(currentSlot, accountId);
-				FFLData_t miiData;
-				act::getMii(currentSlot, &miiData);
-				uint16 screenName[ACT_NICKNAME_LENGTH + 1] = { 0 };
-				act::getScreenname(currentSlot, screenName);
-				uint32 countryCode = 0;
-				act::getCountryIndex(currentSlot, &countryCode);
-				// init presence
-				g_fpd.myPresence.isOnline = 1;
-				g_fpd.myPresence.gameKey.titleId = CafeSystem::GetForegroundTitleId();
-				g_fpd.myPresence.gameKey.ukn = CafeSystem::GetForegroundTitleVersion();
-				// start session
-				uint32 hostIp;
-				inet_pton(AF_INET, nexTokenResult.nexToken.host, &hostIp);
-				g_fpd.nexFriendSession = new NexFriends(hostIp, nexTokenResult.nexToken.port, "ridfebb9", myPid, nexTokenResult.nexToken.nexPassword, nexTokenResult.nexToken.token, accountId, (uint8*)&miiData, (wchar_t*)screenName, (uint8)countryCode, g_fpd.myPresence);
-				g_fpd.nexFriendSession->setNotificationHandler(notificationHandler);
-				forceLog_printf("IOSU_FPD: Created friend server session");
-			}
-			else
-			{
-				forceLogDebug_printf("IOSU_FPD: Failed to acquire nex token for friend server");
-			}
+			memset(gameMode, 0, sizeof(GameMode));
+			gameMode->joinFlagMask = presence->joinFlagMask;
+			gameMode->matchmakeType = presence->joinAvailability;
+			gameMode->joinGameId = presence->gameId;
+			gameMode->joinGameMode = presence->gameMode;
+			gameMode->hostPid = presence->hostPid;
+			gameMode->groupId = presence->groupId;
+			memcpy(gameMode->appSpecificData, presence->appSpecificData, 0x14);
 		}
 
-		void handleRequest_GetFriendList(iosuFpdCemuRequest_t* fpdCemuRequest, bool getAll)
+		void GameModeToNexPresence(const GameMode* gameMode, nexPresenceV2* presence)
 		{
-			if (g_fpd.nexFriendSession == nullptr || g_fpd.nexFriendSession->isOnline() == false)
-			{
-				fpdCemuRequest->returnCode = 0;
-				fpdCemuRequest->resultU32.u32 = 0; // zero entries returned
-				return;
-			}
-
-			uint32 temporaryPidList[800];
-			uint32 pidCount = 0;
-			g_fpd.nexFriendSession->getFriendPIDs(temporaryPidList, &pidCount, fpdCemuRequest->getFriendList.startIndex, std::min<uint32>(sizeof(temporaryPidList) / sizeof(temporaryPidList[0]), fpdCemuRequest->getFriendList.maxCount), getAll);
-			uint32be* pidListOutput = fpdCemuRequest->getFriendList.pidList.GetPtr();
-			if (pidListOutput)
-			{
-				for (uint32 i = 0; i < pidCount; i++)
-					pidListOutput[i] = temporaryPidList[i];
-			}
-			fpdCemuRequest->returnCode = 0;
-			fpdCemuRequest->resultU32.u32 = pidCount;
+			*presence = {};
+			presence->joinFlagMask = gameMode->joinFlagMask;
+			presence->joinAvailability = (uint8)(uint32)gameMode->matchmakeType;
+			presence->gameId = gameMode->joinGameId;
+			presence->gameMode = gameMode->joinGameMode;
+			presence->hostPid = gameMode->hostPid;
+			presence->groupId = gameMode->groupId;
+			memcpy(presence->appSpecificData, gameMode->appSpecificData, 0x14);
 		}
 
-		void handleRequest_GetFriendRequestList(iosuFpdCemuRequest_t* fpdCemuRequest)
+		void NexFriendToFPDFriendData(const nexFriend* frd, FriendData* friendData)
 		{
-			if (g_fpd.nexFriendSession == nullptr || g_fpd.nexFriendSession->isOnline() == false)
-			{
-				fpdCemuRequest->returnCode = 0;
-				fpdCemuRequest->resultU32.u32 = 0; // zero entries returned
-				return;
-			}
-
-			uint32 temporaryPidList[800];
-			uint32 pidCount = 0;
-			// get only incoming friend requests
-			g_fpd.nexFriendSession->getFriendRequestPIDs(temporaryPidList, &pidCount, fpdCemuRequest->getFriendList.startIndex, std::min<uint32>(sizeof(temporaryPidList) / sizeof(temporaryPidList[0]), fpdCemuRequest->getFriendList.maxCount), true, false);
-			uint32be* pidListOutput = fpdCemuRequest->getFriendList.pidList.GetPtr();
-			if (pidListOutput)
-			{
-				for (uint32 i = 0; i < pidCount; i++)
-					pidListOutput[i] = temporaryPidList[i];
-			}
-			fpdCemuRequest->returnCode = 0;
-			fpdCemuRequest->resultU32.u32 = pidCount;
-		}
-
-		void setFriendDataFromNexFriend(friendData_t* friendData, nexFriend* frd)
-		{
-			memset(friendData, 0, sizeof(friendData_t));
+			memset(friendData, 0, sizeof(FriendData));
 			// setup friend data
 			friendData->type = 1; // friend
 			friendData->pid = frd->nnaInfo.principalInfo.principalId;
@@ -234,14 +208,18 @@ namespace iosu
 			// screenname
 			convertMultiByteStringToBigEndianWidechar(frd->nnaInfo.principalInfo.mii.miiNickname, friendData->screenname, sizeof(friendData->screenname) / sizeof(uint16be));
 
-			//friendData->friendExtraData.ukn0E4 = 0;
 			friendData->friendExtraData.isOnline = frd->presence.isOnline != 0 ? 1 : 0;
 
-			friendData->friendExtraData.gameKeyTitleId = _swapEndianU64(frd->presence.gameKey.titleId);
-			friendData->friendExtraData.gameKeyUkn = frd->presence.gameKey.ukn;
-
-			friendData->friendExtraData.statusMessage[0] = '\0';
+			friendData->friendExtraData.gameKey.titleId = frd->presence.gameKey.titleId;
+			friendData->friendExtraData.gameKey.ukn08 = frd->presence.gameKey.ukn;
+			NexPresenceToGameMode(&frd->presence, &friendData->friendExtraData.gameMode);
 
+			auto fixed_presence_msg = '\0' + frd->presence.msg; // avoid first character of comment from being cut off
+			friendData->friendExtraData.gameModeDescription.assignFromUTF8(fixed_presence_msg);
+			
+			auto fixed_comment = '\0' + frd->comment.commentString; // avoid first character of comment from being cut off
+			friendData->friendExtraData.comment.assignFromUTF8(fixed_comment);
+			
 			// set valid dates
 			friendData->uknDate.year = 2018;
 			friendData->uknDate.day = 1;
@@ -250,19 +228,19 @@ namespace iosu
 			friendData->uknDate.minute = 1;
 			friendData->uknDate.second = 1;
 
-			friendData->friendExtraData.uknDate218.year = 2018;
-			friendData->friendExtraData.uknDate218.day = 1;
-			friendData->friendExtraData.uknDate218.month = 1;
-			friendData->friendExtraData.uknDate218.hour = 1;
-			friendData->friendExtraData.uknDate218.minute = 1;
-			friendData->friendExtraData.uknDate218.second = 1;
+			friendData->friendExtraData.approvalTime.year = 2018;
+			friendData->friendExtraData.approvalTime.day = 1;
+			friendData->friendExtraData.approvalTime.month = 1;
+			friendData->friendExtraData.approvalTime.hour = 1;
+			friendData->friendExtraData.approvalTime.minute = 1;
+			friendData->friendExtraData.approvalTime.second = 1;
 
 			convertFPDTimestampToDate(frd->lastOnlineTimestamp, &friendData->friendExtraData.lastOnline);
 		}
 
-		void setFriendDataFromNexFriendRequest(friendData_t* friendData, nexFriendRequest* frdReq, bool isIncoming)
+		void NexFriendRequestToFPDFriendData(const nexFriendRequest* frdReq, bool isIncoming, FriendData* friendData)
 		{
-			memset(friendData, 0, sizeof(friendData_t));
+			memset(friendData, 0, sizeof(FriendData));
 			// setup friend data
 			friendData->type = 0; // friend request
 			friendData->pid = frdReq->principalInfo.principalId;
@@ -273,7 +251,7 @@ namespace iosu
 
 			convertMultiByteStringToBigEndianWidechar(frdReq->message.commentStr.c_str(), friendData->requestExtraData.comment, sizeof(friendData->requestExtraData.comment) / sizeof(uint16be));
 
-			fpdDate_t expireDate;
+			FPDDate expireDate;
 			convertFPDTimestampToDate(frdReq->message.expireTimestamp, &expireDate);
 
 			bool isProvisional = frdReq->message.expireTimestamp == 0;
@@ -282,10 +260,7 @@ namespace iosu
 			//friendData->requestExtraData.ukn0A0 = 0; // if not set -> provisional friend request
 			//friendData->requestExtraData.ukn0A4 = isProvisional ? 0 : 123; // no change?
 
-			friendData->requestExtraData.messageId = _swapEndianU64(frdReq->message.messageId);
-			
-
-			//find the value for 'markedAsReceived'
+			friendData->requestExtraData.messageId = frdReq->message.messageId;
 
 			///* +0x0A8 */ uint8 ukn0A8;
 			///* +0x0A9 */ uint8 ukn0A9; // comment language? (guessed)
@@ -313,9 +288,9 @@ namespace iosu
 			convertFPDTimestampToDate(frdReq->message.expireTimestamp, &friendData->requestExtraData.uknData1);
 		}
 
-		void setFriendRequestFromNexFriendRequest(friendRequest_t* friendRequest, nexFriendRequest* frdReq, bool isIncoming)
+		void NexFriendRequestToFPDFriendRequest(const nexFriendRequest* frdReq, bool isIncoming, FriendRequest* friendRequest)
 		{
-			memset(friendRequest, 0, sizeof(friendRequest_t));
+			memset(friendRequest, 0, sizeof(FriendRequest));
 
 			friendRequest->pid = frdReq->principalInfo.principalId;
 			
@@ -336,715 +311,1225 @@ namespace iosu
 			convertFPDTimestampToDate(frdReq->message.expireTimestamp, &friendRequest->expireDate);
 		}
 
-		void handleRequest_GetFriendListEx(iosuFpdCemuRequest_t* fpdCemuRequest)
+		struct FPProfile
 		{
-			fpdCemuRequest->returnCode = 0;
-			if (g_fpd.nexFriendSession == nullptr || g_fpd.nexFriendSession->isOnline() == false)
-			{
-				fpdCemuRequest->returnCode = 0x80000000;
-				return;
-			}
-			for (uint32 i = 0; i < fpdCemuRequest->getFriendListEx.count; i++)
-			{
-				uint32 pid = fpdCemuRequest->getFriendListEx.pidList[i];
-				friendData_t* friendData = fpdCemuRequest->getFriendListEx.friendData.GetPtr() + i;
-				nexFriend frd;
-				nexFriendRequest frdReq;
-				if (g_fpd.nexFriendSession->getFriendByPID(frd, pid))
-				{
-					setFriendDataFromNexFriend(friendData, &frd);
-					continue;
-				}
-				bool incoming = false;
-				if (g_fpd.nexFriendSession->getFriendRequestByPID(frdReq, &incoming, pid))
-				{
-					setFriendDataFromNexFriendRequest(friendData, &frdReq, incoming);
-					continue;
-				}
-				fpdCemuRequest->returnCode = 0x80000000;
-				return;
-			}
-		}
+			uint8be country;
+			uint8be area;
+			uint16be unused;
+		};
+		static_assert(sizeof(FPProfile) == 4);
 
-		void handleRequest_GetFriendRequestListEx(iosuFpdCemuRequest_t* fpdCemuRequest)
+		struct SelfPresence
 		{
-			fpdCemuRequest->returnCode = 0;
-			if (g_fpd.nexFriendSession == nullptr || g_fpd.nexFriendSession->isOnline() == false)
+			uint8be ukn[0x130]; // todo
+		};
+		static_assert(sizeof(SelfPresence) == 0x130);
+
+		struct SelfPlayingGame
+		{
+			uint8be ukn0[0x10];
+		};
+		static_assert(sizeof(SelfPlayingGame) == 0x10);
+
+		static const auto FPResult_Ok = 0;
+		static const auto FPResult_InvalidIPCParam = BUILD_NN_RESULT(NN_RESULT_LEVEL_LVL6, NN_RESULT_MODULE_NN_FP, 0x680);
+		static const auto FPResult_RequestFailed = BUILD_NN_RESULT(NN_RESULT_LEVEL_FATAL, NN_RESULT_MODULE_NN_FP, 0); // figure out proper error code
+		static const auto FPResult_Aborted = BUILD_NN_RESULT(NN_RESULT_LEVEL_STATUS, NN_RESULT_MODULE_NN_FP, 0x3480);
+
+		class FPDService : public iosu::nn::IPCSimpleService
+		{
+
+			struct NotificationAsyncRequest
 			{
-				fpdCemuRequest->returnCode = 0x80000000;
-				return;
-			}
-			for (uint32 i = 0; i < fpdCemuRequest->getFriendRequestListEx.count; i++)
-			{
-				uint32 pid = fpdCemuRequest->getFriendListEx.pidList[i];
-				friendRequest_t* friendRequest = fpdCemuRequest->getFriendRequestListEx.friendRequest.GetPtr() + i;
-				nexFriendRequest frdReq;
-				bool incoming = false;
-				if (!g_fpd.nexFriendSession->getFriendRequestByPID(frdReq, &incoming, pid))
+				NotificationAsyncRequest(IPCCommandBody* cmd, uint32 maxNumEntries, FPDNotification* notificationsOut, uint32be* countOut)
+					: cmd(cmd), maxNumEntries(maxNumEntries), notificationsOut(notificationsOut), countOut(countOut)
 				{
-					cemuLog_log(LogType::Force, "Failed to get friend request");
-					fpdCemuRequest->returnCode = 0x80000000;
+				}
+
+				IPCCommandBody* cmd;
+				uint32 maxNumEntries;
+				FPDNotification* notificationsOut;
+				uint32be* countOut;
+			};
+
+			struct FPDClient
+			{
+				bool hasLoggedIn{false};
+				uint32 notificationMask{0};
+				NotificationRunningId prevRunningId{0};
+				std::vector<NotificationAsyncRequest> notificationRequests;
+			};
+
+			// storage for async IPC requests
+			std::vector<IPCCommandBody*> m_asyncLoginRequests;
+			std::vector<FPDClient*> m_clients;
+
+		  public:
+			FPDService() : iosu::nn::IPCSimpleService("/dev/fpd") {}
+
+			std::string GetThreadName() override
+			{
+				return "IOSUModule::FPD";
+			}
+
+			void StartService() override
+			{
+				cemu_assert_debug(m_asyncLoginRequests.empty());
+			}
+
+			void StopService() override
+			{
+				m_asyncLoginRequests.clear();
+				for(auto& it : m_clients)
+					delete it;
+				m_clients.clear();
+			}
+
+			void* CreateClientObject() override
+			{
+				FPDClient* client = new FPDClient();
+				m_clients.push_back(client);
+				return client;
+			}
+
+			void DestroyClientObject(void* clientObject) override
+			{
+				FPDClient* client = (FPDClient*)clientObject;
+				std::erase(m_clients, client);
+				delete client;
+			}
+
+			void SendQueuedNotifications(FPDClient* client)
+			{
+				if (client->notificationRequests.empty())
 					return;
+				if (client->notificationRequests.size() > 1)
+					cemuLog_log(LogType::Force, "FPD: More than one simultanous notification query not supported");
+				NotificationAsyncRequest& request = client->notificationRequests[0];
+				uint32 numNotifications = 0;
+				while(numNotifications < request.maxNumEntries)
+				{
+					auto notification = g_NotificationQueue.GetNextNotification(client->prevRunningId);
+					if (!notification)
+						break;
+					uint32 flag = 1 << static_cast<uint32>(notification->type);
+					if((client->notificationMask & flag) == 0)
+						continue;
+					request.notificationsOut[numNotifications].type = static_cast<uint32>(notification->type);
+					request.notificationsOut[numNotifications].pid = notification->pid;
+					numNotifications++;
 				}
-				setFriendRequestFromNexFriendRequest(friendRequest, &frdReq, incoming);
-			}
-		}
-
-		typedef struct  
-		{
-			MPTR funcMPTR;
-			MPTR customParam;
-		}fpAsyncCallback_t;
-
-		typedef struct 
-		{
-			nexPrincipalBasicInfo* principalBasicInfo;
-			uint32* pidList;
-			sint32 count;
-			friendBasicInfo_t* friendBasicInfo;
-			fpAsyncCallback_t fpCallback;
-		}getBasicInfoAsyncParams_t;
-
-		SysAllocator<uint32, 32> _fpCallbackResultArray; // use a ring buffer of results to avoid overwriting the result when multiple callbacks are queued at the same time
-		sint32 fpCallbackResultIndex = 0;
-
-		void handleFPCallback(fpAsyncCallback_t* fpCallback, uint32 resultCode)
-		{
-			fpCallbackResultIndex = (fpCallbackResultIndex + 1) % 32;
-			uint32* resultPtr = _fpCallbackResultArray.GetPtr() + fpCallbackResultIndex;
-
-			*resultPtr = resultCode;
-
-			coreinitAsyncCallback_add(fpCallback->funcMPTR, 2, memory_getVirtualOffsetFromPointer(resultPtr), fpCallback->customParam);
-		}
-
-		void handleFPCallback2(MPTR funcMPTR, MPTR custom, uint32 resultCode)
-		{
-			fpCallbackResultIndex = (fpCallbackResultIndex + 1) % 32;
-			uint32* resultPtr = _fpCallbackResultArray.GetPtr() + fpCallbackResultIndex;
-
-			*resultPtr = resultCode;
-
-			coreinitAsyncCallback_add(funcMPTR, 2, memory_getVirtualOffsetFromPointer(resultPtr), custom);
-		}
-
-		void handleResultCB_GetBasicInfoAsync(NexFriends* nexFriends, uint32 result, void* custom)
-		{
-			getBasicInfoAsyncParams_t* cbInfo = (getBasicInfoAsyncParams_t*)custom;
-			if (result != 0)
-			{
-				handleFPCallback(&cbInfo->fpCallback, 0x80000000); // todo - properly translate internal error to nn::fp error code
-				free(cbInfo->principalBasicInfo);
-				free(cbInfo->pidList);
-				free(cbInfo);
-				return;
+				if (numNotifications == 0)
+					return;
+				*request.countOut = numNotifications;
+				ServiceCallAsyncRespond(request.cmd, FPResult_Ok);
+				client->notificationRequests.erase(client->notificationRequests.begin());
 			}
 
-			// convert PrincipalBasicInfo into friendBasicInfo
-			for (sint32 i = 0; i < cbInfo->count; i++)
+			void TimerUpdate() override
 			{
-				friendBasicInfo_t* basicInfo = cbInfo->friendBasicInfo + i;
-				nexPrincipalBasicInfo* principalBasicInfo = cbInfo->principalBasicInfo + i;
+				// called once a second while service is running
+				std::unique_lock _l(g_fpd.mtxFriendSession);
+				if (!g_fpd.nexFriendSession)
+					return;
+				g_fpd.nexFriendSession->update();
+				while(!m_asyncLoginRequests.empty())
+				{
+					if(g_fpd.nexFriendSession->isOnline())
+					{
+						ServiceCallAsyncRespond(m_asyncLoginRequests.front(), FPResult_Ok);
+						m_asyncLoginRequests.erase(m_asyncLoginRequests.begin());
+					}
+					else
+						break;
+				}
+				// handle notification responses
+				g_NotificationQueue.RemoveExpired();
+				for(auto& client : m_clients)
+					SendQueuedNotifications(client);
+			}
 
-				memset(basicInfo, 0, sizeof(friendBasicInfo_t));
-				basicInfo->pid = principalBasicInfo->principalId;
-				strcpy(basicInfo->nnid, principalBasicInfo->nnid);
+			uint32 ServiceCall(void* clientObject, uint32 requestId, IPCIoctlVector* vecIn, uint32 numVecIn, IPCIoctlVector* vecOut, uint32 numVecOut) override
+			{
+				// for /dev/fpd input and output vectors are swapped
+				std::swap(vecIn, vecOut);
+				std::swap(numVecIn, numVecOut);
 
-				convertMultiByteStringToBigEndianWidechar(principalBasicInfo->mii.miiNickname, basicInfo->screenname, sizeof(basicInfo->screenname) / sizeof(uint16be));
-				memcpy(basicInfo->miiData, principalBasicInfo->mii.miiData, FFL_SIZE);
+				FPDClient* fpdClient = (FPDClient*)clientObject;
+				switch(static_cast<FPD_REQUEST_ID>(requestId))
+				{
+				case FPD_REQUEST_ID::SetNotificationMask:
+					return CallHandler_SetNotificationMask(fpdClient, vecIn, numVecIn, vecOut, numVecOut);
+				case FPD_REQUEST_ID::GetNotificationAsync:
+					return CallHandler_GetNotificationAsync(fpdClient, vecIn, numVecIn, vecOut, numVecOut);
+				case FPD_REQUEST_ID::SetLedEventMask:
+					cemuLog_logDebug(LogType::Force, "[/dev/fpd] SetLedEventMask is todo");
+					return FPResult_Ok;
+				case FPD_REQUEST_ID::LoginAsync:
+					return CallHandler_LoginAsync(fpdClient, vecIn, numVecIn, vecOut, numVecOut);
+				case FPD_REQUEST_ID::HasLoggedIn:
+					return CallHandler_HasLoggedIn(fpdClient, vecIn, numVecIn, vecOut, numVecOut);
+				case FPD_REQUEST_ID::IsOnline:
+					return CallHandler_IsOnline(fpdClient, vecIn, numVecIn, vecOut, numVecOut);
+				case FPD_REQUEST_ID::GetMyPrincipalId:
+					return CallHandler_GetMyPrincipalId(fpdClient, vecIn, numVecIn, vecOut, numVecOut);
+				case FPD_REQUEST_ID::GetMyAccountId:
+					return CallHandler_GetMyAccountId(fpdClient, vecIn, numVecIn, vecOut, numVecOut);
+				case FPD_REQUEST_ID::GetMyScreenName:
+					return CallHandler_GetMyScreenName(fpdClient, vecIn, numVecIn, vecOut, numVecOut);
+				case FPD_REQUEST_ID::GetMyMii:
+					return CallHandler_GetMyMii(fpdClient, vecIn, numVecIn, vecOut, numVecOut);
+				case FPD_REQUEST_ID::GetMyProfile:
+					return CallHandler_GetMyProfile(fpdClient, vecIn, numVecIn, vecOut, numVecOut);
+				case FPD_REQUEST_ID::GetMyPresence:
+					return CallHandler_GetMyPresence(fpdClient, vecIn, numVecIn, vecOut, numVecOut);
+				case FPD_REQUEST_ID::GetMyComment:
+					return CallHandler_GetMyComment(fpdClient, vecIn, numVecIn, vecOut, numVecOut);
+				case FPD_REQUEST_ID::GetMyPreference:
+					return CallHandler_GetMyPreference(fpdClient, vecIn, numVecIn, vecOut, numVecOut);
+				case FPD_REQUEST_ID::GetMyPlayingGame:
+					return CallHandler_GetMyPlayingGame(fpdClient, vecIn, numVecIn, vecOut, numVecOut);
+				case FPD_REQUEST_ID::GetFriendAccountId:
+					return CallHandler_GetFriendAccountId(fpdClient, vecIn, numVecIn, vecOut, numVecOut);
+				case FPD_REQUEST_ID::GetFriendScreenName:
+					return CallHandler_GetFriendScreenName(fpdClient, vecIn, numVecIn, vecOut, numVecOut);
+				case FPD_REQUEST_ID::GetFriendMii:
+					return CallHandler_GetFriendMii(fpdClient, vecIn, numVecIn, vecOut, numVecOut);
+				case FPD_REQUEST_ID::GetFriendPresence:
+					return CallHandler_GetFriendPresence(fpdClient, vecIn, numVecIn, vecOut, numVecOut);
+				case FPD_REQUEST_ID::GetFriendRelationship:
+					return CallHandler_GetFriendRelationship(fpdClient, vecIn, numVecIn, vecOut, numVecOut);
+				case FPD_REQUEST_ID::GetFriendList:
+					return CallHandler_GetFriendList_GetFriendListAll(fpdClient, vecIn, numVecIn, vecOut, numVecOut, false);
+				case FPD_REQUEST_ID::GetFriendListAll:
+					return CallHandler_GetFriendList_GetFriendListAll(fpdClient, vecIn, numVecIn, vecOut, numVecOut, true);
+				case FPD_REQUEST_ID::GetFriendRequestList:
+					return CallHandler_GetFriendRequestList(fpdClient, vecIn, numVecIn, vecOut, numVecOut);
+				case FPD_REQUEST_ID::GetFriendRequestListEx:
+					return CallHandler_GetFriendRequestListEx(fpdClient, vecIn, numVecIn, vecOut, numVecOut);
+				case FPD_REQUEST_ID::GetBlackList:
+					return CallHandler_GetBlackList(fpdClient, vecIn, numVecIn, vecOut, numVecOut);
+				case FPD_REQUEST_ID::GetFriendListEx:
+					return CallHandler_GetFriendListEx(fpdClient, vecIn, numVecIn, vecOut, numVecOut);
+				case FPD_REQUEST_ID::UpdateCommentAsync:
+					return CallHandler_UpdateCommentAsync(fpdClient, vecIn, numVecIn, vecOut, numVecOut);
+				case FPD_REQUEST_ID::UpdatePreferenceAsync:
+					return CallHandler_UpdatePreferenceAsync(fpdClient, vecIn, numVecIn, vecOut, numVecOut);
+				case FPD_REQUEST_ID::AddFriendRequestByPlayRecordAsync:
+					return CallHandler_AddFriendRequestAsync(fpdClient, vecIn, numVecIn, vecOut, numVecOut);
+				case FPD_REQUEST_ID::AcceptFriendRequestAsync:
+					return CallHandler_AcceptFriendRequestAsync(fpdClient, vecIn, numVecIn, vecOut, numVecOut);
+				case FPD_REQUEST_ID::DeleteFriendRequestAsync:
+					return CallHandler_DeleteFriendRequestAsync(fpdClient, vecIn, numVecIn, vecOut, numVecOut);
+				case FPD_REQUEST_ID::CancelFriendRequestAsync:
+					return CallHandler_CancelFriendRequestAsync(fpdClient, vecIn, numVecIn, vecOut, numVecOut);
+				case FPD_REQUEST_ID::MarkFriendRequestsAsReceivedAsync:
+					return CallHandler_MarkFriendRequestsAsReceivedAsync(fpdClient, vecIn, numVecIn, vecOut, numVecOut);
+				case FPD_REQUEST_ID::RemoveFriendAsync:
+					return CallHandler_RemoveFriendAsync(fpdClient, vecIn, numVecIn, vecOut, numVecOut);
+				case FPD_REQUEST_ID::DeleteFriendFlagsAsync:
+					return CallHandler_DeleteFriendFlagsAsync(fpdClient, vecIn, numVecIn, vecOut, numVecOut);
+				case FPD_REQUEST_ID::GetBasicInfoAsync:
+					return CallHandler_GetBasicInfoAsync(fpdClient, vecIn, numVecIn, vecOut, numVecOut);
+				case FPD_REQUEST_ID::CheckSettingStatusAsync:
+					return CallHandler_CheckSettingStatusAsync(fpdClient, vecIn, numVecIn, vecOut, numVecOut);
+				case FPD_REQUEST_ID::IsPreferenceValid:
+					return CallHandler_IsPreferenceValid(fpdClient, vecIn, numVecIn, vecOut, numVecOut);
+				case FPD_REQUEST_ID::GetRequestBlockSettingAsync:
+					return CallHandler_GetRequestBlockSettingAsync(fpdClient, vecIn, numVecIn, vecOut, numVecOut);
+				case FPD_REQUEST_ID::AddFriendAsyncByPid:
+					return CallHandler_AddFriendAsyncByPid(fpdClient, vecIn, numVecIn, vecOut, numVecOut);
+				case FPD_REQUEST_ID::UpdateGameModeVariation1:
+				case FPD_REQUEST_ID::UpdateGameModeVariation2:
+					return CallHandler_UpdateGameMode(fpdClient, vecIn, numVecIn, vecOut, numVecOut);
+				default:
+					cemuLog_log(LogType::Force, "Unsupported service call {} to /dev/fpd", requestId);
+					return BUILD_NN_RESULT(NN_RESULT_LEVEL_FATAL, NN_RESULT_MODULE_NN_FP, 0);
+				}
+			}
 
-				basicInfo->uknDate90.day = 1;
-				basicInfo->uknDate90.month = 1;
-				basicInfo->uknDate90.hour = 1;
-				basicInfo->uknDate90.minute = 1;
-				basicInfo->uknDate90.second = 1;
+			#define DeclareInputPtr(__Name, __T, __count, __vecIndex) if(sizeof(__T)*(__count) != vecIn[__vecIndex].size) { cemuLog_log(LogType::Force, "FPD: IPC buffer has incorrect size"); return FPResult_InvalidIPCParam;};  __T* __Name = ((__T*)vecIn[__vecIndex].basePhys.GetPtr())
+			#define DeclareInput(__Name, __T, __vecIndex) if(sizeof(__T) != vecIn[__vecIndex].size) { cemuLog_log(LogType::Force, "FPD: IPC buffer has incorrect size"); return FPResult_InvalidIPCParam;}; __T __Name = *((__T*)vecIn[__vecIndex].basePhys.GetPtr())
+			#define DeclareOutputPtr(__Name, __T, __count, __vecIndex) if(sizeof(__T)*(__count) != vecOut[__vecIndex].size) { cemuLog_log(LogType::Force, "FPD: IPC buffer has incorrect size"); return FPResult_InvalidIPCParam;}; __T* __Name = ((__T*)vecOut[__vecIndex].basePhys.GetPtr())
+
+			template<typename T>
+			static nnResult WriteValueOutput(IPCIoctlVector* vec, const T& value)
+			{
+				if(vec->size != sizeof(T))
+					return FPResult_InvalidIPCParam;
+				*(T*)vec->basePhys.GetPtr() = value;
+				return FPResult_Ok;
+			}
+
+			nnResult CallHandler_SetNotificationMask(FPDClient* fpdClient, IPCIoctlVector* vecIn, uint32 numVecIn, IPCIoctlVector* vecOut, uint32 numVecOut)
+			{
+				if(numVecIn != 1 || numVecOut != 0)
+					return FPResult_InvalidIPCParam;
+				DeclareInput(notificationMask, uint32be, 0);
+				fpdClient->notificationMask = notificationMask;
+				return FPResult_Ok;
+			}
+
+			nnResult CallHandler_GetNotificationAsync(FPDClient* fpdClient, IPCIoctlVector* vecIn, uint32 numVecIn, IPCIoctlVector* vecOut, uint32 numVecOut)
+			{
+				if(numVecIn != 0 || numVecOut != 2)
+					return FPResult_InvalidIPCParam;
+				if((vecOut[0].size % sizeof(FPDNotification)) != 0 || vecOut[0].size < sizeof(FPDNotification))
+				{
+					cemuLog_log(LogType::Force, "FPD GetNotificationAsync: Unexpected output size");
+					return FPResult_InvalidIPCParam;
+				}
+				IPCCommandBody* cmd = ServiceCallDelayCurrentResponse();
+				DeclareOutputPtr(countOut, uint32be, 1, 1);
+				uint32 maxCount = vecOut[0].size / sizeof(FPDNotification);
+				DeclareOutputPtr(notificationList, FPDNotification, maxCount, 0);
+				fpdClient->notificationRequests.emplace_back(cmd, maxCount, notificationList, countOut);
+				SendQueuedNotifications(fpdClient); // if any notifications are queued, send them immediately
+				return FPResult_Ok;
+			}
+
+			nnResult CallHandler_LoginAsync(FPDClient* fpdClient, IPCIoctlVector* vecIn, uint32 numVecIn, IPCIoctlVector* vecOut, uint32 numVecOut)
+			{
+				if(numVecIn != 0 || numVecOut != 0)
+					return FPResult_InvalidIPCParam;
+				if (!ActiveSettings::IsOnlineEnabled())
+				{
+					// not online, fail immediately
+					return FPResult_Ok; // Splatoon expects this to always return success otherwise it will softlock. This should be FPResult_Aborted?
+				}
+				StartFriendSession();
+				fpdClient->hasLoggedIn = true;
+				IPCCommandBody* cmd = ServiceCallDelayCurrentResponse();
+				m_asyncLoginRequests.emplace_back(cmd);
+				return FPResult_Ok;
+			}
+
+			nnResult CallHandler_HasLoggedIn(FPDClient* fpdClient, IPCIoctlVector* vecIn, uint32 numVecIn, IPCIoctlVector* vecOut, uint32 numVecOut)
+			{
+				if(numVecIn != 0 || numVecOut != 1)
+					return FPResult_InvalidIPCParam;
+				return WriteValueOutput<uint32be>(vecOut, fpdClient->hasLoggedIn ? 1 : 0);
+			}
+
+			nnResult CallHandler_IsOnline(FPDClient* fpdClient, IPCIoctlVector* vecIn, uint32 numVecIn, IPCIoctlVector* vecOut, uint32 numVecOut)
+			{
+				if(numVecIn != 0 || numVecOut != 1)
+					return FPResult_InvalidIPCParam;
+				bool isOnline = g_fpd.nexFriendSession ? g_fpd.nexFriendSession->isOnline() : false;
+				return WriteValueOutput<uint32be>(vecOut, isOnline?1:0);
+			}
+
+			nnResult CallHandler_GetMyPrincipalId(FPDClient* fpdClient, IPCIoctlVector* vecIn, uint32 numVecIn, IPCIoctlVector* vecOut, uint32 numVecOut)
+			{
+				if(numVecIn != 0 || numVecOut != 1)
+					return FPResult_InvalidIPCParam;
+				uint8 slot = iosu::act::getCurrentAccountSlot();
+				uint32 pid = 0;
+				iosu::act::getPrincipalId(slot, &pid);
+				return WriteValueOutput<uint32be>(vecOut, pid);
+			}
+
+			nnResult CallHandler_GetMyAccountId(FPDClient* fpdClient, IPCIoctlVector* vecIn, uint32 numVecIn, IPCIoctlVector* vecOut, uint32 numVecOut)
+			{
+				if(numVecIn != 0 || numVecOut != 1)
+					return FPResult_InvalidIPCParam;
+				uint8 slot = iosu::act::getCurrentAccountSlot();
+				std::string accountId = iosu::act::getAccountId2(slot);
+				if(vecOut->size != ACT_ACCOUNTID_LENGTH)
+				{
+					cemuLog_log(LogType::Force, "GetMyAccountId: Unexpected output size");
+					return FPResult_InvalidIPCParam;
+				}
+				if(accountId.length() > ACT_ACCOUNTID_LENGTH-1)
+				{
+					cemuLog_log(LogType::Force, "GetMyAccountId: AccountID is too long");
+					return FPResult_InvalidIPCParam;
+				}
+				if(accountId.empty())
+				{
+					cemuLog_log(LogType::Force, "GetMyAccountId: AccountID is empty");
+					return FPResult_InvalidIPCParam; // should return 0xC0C00800 ?
+				}
+				char* outputStr = (char*)vecOut->basePhys.GetPtr();
+				memset(outputStr, 0, ACT_ACCOUNTID_LENGTH);
+				memcpy(outputStr, accountId.data(), accountId.length());
+				return FPResult_Ok;
+			}
+
+			nnResult CallHandler_GetMyScreenName(FPDClient* fpdClient, IPCIoctlVector* vecIn, uint32 numVecIn, IPCIoctlVector* vecOut, uint32 numVecOut)
+			{
+				if(numVecIn != 0 || numVecOut != 1)
+					return FPResult_InvalidIPCParam;
+				uint8 slot = iosu::act::getCurrentAccountSlot();
+				if(vecOut->size != ACT_NICKNAME_SIZE*sizeof(uint16be))
+				{
+					cemuLog_log(LogType::Force, "GetMyScreenName: Unexpected output size");
+					return FPResult_InvalidIPCParam;
+				}
+				uint16 screenname[ACT_NICKNAME_SIZE]{0};
+				bool r = iosu::act::getScreenname(slot, screenname);
+				if (!r)
+				{
+					cemuLog_log(LogType::Force, "GetMyScreenName: Screenname is empty");
+					return FPResult_InvalidIPCParam; // should return 0xC0C00800 ?
+				}
+				uint16be* outputStr = (uint16be*)vecOut->basePhys.GetPtr();
+				for(sint32 i = 0; i < ACT_NICKNAME_SIZE; i++)
+					outputStr[i] = screenname[i];
+				return FPResult_Ok;
+			}
+
+			nnResult CallHandler_GetMyMii(FPDClient* fpdClient, IPCIoctlVector* vecIn, uint32 numVecIn, IPCIoctlVector* vecOut, uint32 numVecOut)
+			{
+				if(numVecIn != 0 || numVecOut != 1)
+					return FPResult_InvalidIPCParam;
+				uint8 slot = iosu::act::getCurrentAccountSlot();
+				if(vecOut->size != FFL_SIZE)
+				{
+					cemuLog_log(LogType::Force, "GetMyMii: Unexpected output size");
+					return FPResult_InvalidIPCParam;
+				}
+				bool r = iosu::act::getMii(slot, (FFLData_t*)vecOut->basePhys.GetPtr());
+				if (!r)
+				{
+					cemuLog_log(LogType::Force, "GetMyMii: Mii is empty");
+					return FPResult_InvalidIPCParam; // should return 0xC0C00800 ?
+				}
+				return FPResult_Ok;
+			}
+
+			nnResult CallHandler_GetMyProfile(FPDClient* fpdClient, IPCIoctlVector* vecIn, uint32 numVecIn, IPCIoctlVector* vecOut, uint32 numVecOut)
+			{
+				if(numVecIn != 0 || numVecOut != 1)
+					return FPResult_InvalidIPCParam;
+				uint8 slot = iosu::act::getCurrentAccountSlot();
+				FPProfile profile{0};
+				// todo
+				cemuLog_log(LogType::Force, "GetMyProfile is todo");
+				return WriteValueOutput<FPProfile>(vecOut, profile);
+			}
+
+			nnResult CallHandler_GetMyPresence(FPDClient* fpdClient, IPCIoctlVector* vecIn, uint32 numVecIn, IPCIoctlVector* vecOut, uint32 numVecOut)
+			{
+				if(numVecIn != 0 || numVecOut != 1)
+					return FPResult_InvalidIPCParam;
+				uint8 slot = iosu::act::getCurrentAccountSlot();
+				SelfPresence selfPresence{0};
+				cemuLog_log(LogType::Force, "GetMyPresence is todo");
+				return WriteValueOutput<SelfPresence>(vecOut, selfPresence);
+			}
+
+			nnResult CallHandler_GetMyComment(FPDClient* fpdClient, IPCIoctlVector* vecIn, uint32 numVecIn, IPCIoctlVector* vecOut, uint32 numVecOut)
+			{
+				if(numVecIn != 0 || numVecOut != 1)
+					return FPResult_InvalidIPCParam;
+				std::vector<uint16be> myComment;
+				if(g_fpd.nexFriendSession)
+				{
+					if(vecOut->size != MY_COMMENT_LENGTH * sizeof(uint16be))
+					{
+						cemuLog_log(LogType::Force, "GetMyComment: Unexpected output size");
+						return FPResult_InvalidIPCParam;
+					}
+					nexComment myNexComment;
+					g_fpd.nexFriendSession->getMyComment(myNexComment);
+					myComment = StringHelpers::FromUtf8(myNexComment.commentString);
+				}
+				myComment.insert(myComment.begin(), '\0');
+				memcpy(vecOut->basePhys.GetPtr(), myComment.data(), MY_COMMENT_LENGTH * sizeof(uint16be));
+				return FPResult_Ok;
+			}
+
+			nnResult CallHandler_GetMyPreference(FPDClient* fpdClient, IPCIoctlVector* vecIn, uint32 numVecIn, IPCIoctlVector* vecOut, uint32 numVecOut)
+			{
+				if(numVecIn != 0 || numVecOut != 1)
+					return FPResult_InvalidIPCParam;
+				FPDPreference selfPreference{0};
+				if(g_fpd.nexFriendSession)
+				{
+					nexPrincipalPreference nexPreference;
+					g_fpd.nexFriendSession->getMyPreference(nexPreference);
+					selfPreference.showOnline = nexPreference.showOnline;
+					selfPreference.showGame = nexPreference.showGame;
+					selfPreference.blockFriendRequests = nexPreference.blockFriendRequests;
+					selfPreference.ukn = 0;
+				}
+				else
+					memset(&selfPreference, 0, sizeof(FPDPreference));
+				return WriteValueOutput<FPDPreference>(vecOut, selfPreference);
+			}
+
+			nnResult CallHandler_GetMyPlayingGame(FPDClient* fpdClient, IPCIoctlVector* vecIn, uint32 numVecIn, IPCIoctlVector* vecOut, uint32 numVecOut)
+			{
+				if(numVecIn != 0 || numVecOut != 1)
+					return FPResult_InvalidIPCParam;
+				GameKey selfPlayingGame
+				{
+					CafeSystem::GetForegroundTitleId(),
+					CafeSystem::GetForegroundTitleVersion(),
+					{0,0,0,0,0,0}
+				};
+				if (GetTitleIdHigh(CafeSystem::GetForegroundTitleId()) != 0x00050000)
+				{
+					selfPlayingGame.titleId = 0;
+					selfPlayingGame.ukn08 = 0;
+				}
+				return WriteValueOutput<GameKey>(vecOut, selfPlayingGame);
+			}
+
+			nnResult CallHandler_GetFriendAccountId(FPDClient* fpdClient, IPCIoctlVector* vecIn, uint32 numVecIn, IPCIoctlVector* vecOut, uint32 numVecOut)
+			{
+				if(numVecIn != 2 || numVecOut != 1)
+					return FPResult_InvalidIPCParam;
+				// todo - online check
+				DeclareInput(count, uint32be, 1);
+				DeclareInputPtr(pidList, uint32be, count, 0);
+				DeclareOutputPtr(accountId, CafeString<ACT_ACCOUNTID_LENGTH>, count, 0);
+				memset(accountId, 0, ACT_ACCOUNTID_LENGTH * count);
+				if (g_fpd.nexFriendSession)
+				{
+					for (uint32 i = 0; i < count; i++)
+					{
+						const uint32 pid = pidList[i];
+						auto& nnidOutput = accountId[i];
+						nexFriend frd;
+						nexFriendRequest frdReq;
+						if (g_fpd.nexFriendSession->getFriendByPID(frd, pid))
+						{
+							nnidOutput.assign(frd.nnaInfo.principalInfo.nnid);
+							continue;
+						}
+						bool incoming = false;
+						if (g_fpd.nexFriendSession->getFriendRequestByPID(frdReq, &incoming, pid))
+						{
+							nnidOutput.assign(frdReq.principalInfo.nnid);
+							continue;
+						}
+						cemuLog_log(LogType::Force, "GetFriendAccountId: PID {} not found", pid);
+					}
+				}
+				return FPResult_Ok;
+			}
+
+			nnResult CallHandler_GetFriendScreenName(FPDClient* fpdClient, IPCIoctlVector* vecIn, uint32 numVecIn, IPCIoctlVector* vecOut, uint32 numVecOut)
+			{
+				static_assert(sizeof(CafeWideString<ACT_NICKNAME_SIZE>) == 11*2);
+				if(numVecIn != 3 || numVecOut != 2)
+					return FPResult_InvalidIPCParam;
+				DeclareInput(count, uint32be, 1);
+				DeclareInputPtr(pidList, uint32be, count, 0);
+				DeclareInput(replaceNonAscii, uint8be, 2);
+				DeclareOutputPtr(nameList, CafeWideString<ACT_NICKNAME_SIZE>, count, 0);
+				uint8be* languageList = nullptr;
+				if(vecOut[1].size > 0) // languageList is optional
+				{
+					DeclareOutputPtr(_languageList, uint8be, count, 1);
+					languageList = _languageList;
+				}
+				memset(nameList, 0, ACT_NICKNAME_SIZE * sizeof(CafeWideString<ACT_NICKNAME_SIZE>));
+				if (g_fpd.nexFriendSession)
+				{
+					for (uint32 i = 0; i < count; i++)
+					{
+						const uint32 pid = pidList[i];
+						CafeWideString<ACT_NICKNAME_SIZE>& screennameOutput = nameList[i];
+						if (languageList)
+							languageList[i] = 0; // unknown
+						nexFriend frd;
+						nexFriendRequest frdReq;
+						if (g_fpd.nexFriendSession->getFriendByPID(frd, pid))
+						{
+							screennameOutput.assignFromUTF8(frd.nnaInfo.principalInfo.mii.miiNickname);
+							if (languageList)
+								languageList[i] = frd.nnaInfo.principalInfo.regionGuessed;
+							continue;
+						}
+						bool incoming = false;
+						if (g_fpd.nexFriendSession->getFriendRequestByPID(frdReq, &incoming, pid))
+						{
+							screennameOutput.assignFromUTF8(frdReq.principalInfo.mii.miiNickname);
+							if (languageList)
+								languageList[i] = frdReq.principalInfo.regionGuessed;
+							continue;
+						}
+						cemuLog_log(LogType::Force, "GetFriendScreenName: PID {} not found", pid);
+					}
+				}
+				return FPResult_Ok;
+			}
+
+			nnResult CallHandler_GetFriendMii(FPDClient* fpdClient, IPCIoctlVector* vecIn, uint32 numVecIn, IPCIoctlVector* vecOut, uint32 numVecOut)
+			{
+				if(numVecIn != 2 || numVecOut != 1)
+					return FPResult_InvalidIPCParam;
+				DeclareInput(count, uint32be, 1);
+				DeclareInputPtr(pidList, uint32be, count, 0);
+				DeclareOutputPtr(miiList, FFLData_t, count, 0);
+				memset(miiList, 0, sizeof(FFLData_t) * count);
+				if (g_fpd.nexFriendSession)
+				{
+					for (uint32 i = 0; i < count; i++)
+					{
+						const uint32 pid = pidList[i];
+						FFLData_t& miiOutput = miiList[i];
+						nexFriend frd;
+						nexFriendRequest frdReq;
+						if (g_fpd.nexFriendSession->getFriendByPID(frd, pid))
+						{
+							memcpy(&miiOutput, frd.nnaInfo.principalInfo.mii.miiData, FFL_SIZE);
+							continue;
+						}
+						bool incoming = false;
+						if (g_fpd.nexFriendSession->getFriendRequestByPID(frdReq, &incoming, pid))
+						{
+							memcpy(&miiOutput, frdReq.principalInfo.mii.miiData, FFL_SIZE);
+							continue;
+						}
+					}
+				}
+				return FPResult_Ok;
+			}
+
+			nnResult CallHandler_GetFriendPresence(FPDClient* fpdClient, IPCIoctlVector* vecIn, uint32 numVecIn, IPCIoctlVector* vecOut, uint32 numVecOut)
+			{
+				if(numVecIn != 2 || numVecOut != 1)
+					return FPResult_InvalidIPCParam;
+				DeclareInput(count, uint32be, 1);
+				DeclareInputPtr(pidList, uint32be, count, 0);
+				DeclareOutputPtr(presenceList, FriendPresence, count, 0);
+				memset(presenceList, 0, sizeof(FriendPresence) * count);
+				if (g_fpd.nexFriendSession)
+				{
+					for (uint32 i = 0; i < count; i++)
+					{
+						FriendPresence& presenceOutput = presenceList[i];
+						const uint32 pid = pidList[i];
+						nexFriend frd;
+						if (g_fpd.nexFriendSession->getFriendByPID(frd, pid))
+						{
+							presenceOutput.isOnline = frd.presence.isOnline ? 1 : 0;
+							presenceOutput.isValid = 1;
+							// todo - region and subregion
+							presenceOutput.gameMode.joinFlagMask = frd.presence.joinFlagMask;
+							presenceOutput.gameMode.matchmakeType = frd.presence.joinAvailability;
+							presenceOutput.gameMode.joinGameId = frd.presence.gameId;
+							presenceOutput.gameMode.joinGameMode = frd.presence.gameMode;
+							presenceOutput.gameMode.hostPid = frd.presence.hostPid;
+							presenceOutput.gameMode.groupId = frd.presence.groupId;
+
+							memcpy(presenceOutput.gameMode.appSpecificData, frd.presence.appSpecificData, 0x14);
+						}
+						else
+						{
+							cemuLog_log(LogType::Force, "GetFriendPresence: PID {} not found", pid);
+						}
+					}
+				}
+				return FPResult_Ok;
+			}
+
+			nnResult CallHandler_GetFriendRelationship(FPDClient* fpdClient, IPCIoctlVector* vecIn, uint32 numVecIn, IPCIoctlVector* vecOut, uint32 numVecOut)
+			{
+				if(numVecIn != 2 || numVecOut != 1)
+					return FPResult_InvalidIPCParam;
+				// todo - check for valid session (same for all GetFriend* functions)
+				DeclareInput(count, uint32be, 1);
+				DeclareInputPtr(pidList, uint32be, count, 0);
+				DeclareOutputPtr(relationshipList, uint8be, count, 0); // correct?
+				for(uint32 i=0; i<count; i++)
+					relationshipList[i] = RELATIONSHIP_INVALID;
+				if (g_fpd.nexFriendSession)
+				{
+					for (uint32 i = 0; i < count; i++)
+					{
+						const uint32 pid = pidList[i];
+						uint8be& relationshipOutput = relationshipList[i];
+						nexFriend frd;
+						nexFriendRequest frdReq;
+						bool incoming;
+						if (g_fpd.nexFriendSession->getFriendByPID(frd, pid))
+						{
+							relationshipOutput = RELATIONSHIP_FRIEND;
+							continue;
+						}
+						else if (g_fpd.nexFriendSession->getFriendRequestByPID(frdReq, &incoming, pid))
+						{
+							if (incoming)
+								relationshipOutput = RELATIONSHIP_FRIENDREQUEST_IN;
+							else
+								relationshipOutput = RELATIONSHIP_FRIENDREQUEST_OUT;
+						}
+					}
+				}
+				return FPResult_Ok;
+			}
+
+			nnResult CallHandler_GetFriendList_GetFriendListAll(FPDClient* fpdClient, IPCIoctlVector* vecIn, uint32 numVecIn, IPCIoctlVector* vecOut, uint32 numVecOut, bool isAll)
+			{
+				std::unique_lock _l(g_fpd.mtxFriendSession);
+				if(numVecIn != 2 || numVecOut != 2)
+					return FPResult_InvalidIPCParam;
+				DeclareInput(startIndex, uint32be, 0);
+				DeclareInput(maxCount, uint32be, 1);
+				if (maxCount * sizeof(FriendPID) != vecOut[0].size || vecOut[0].basePhys.IsNull())
+				{
+					cemuLog_log(LogType::Force, "GetFriendListAll: pid list buffer size is incorrect");
+					return FPResult_InvalidIPCParam;
+				}
+				if (!g_fpd.nexFriendSession)
+					return WriteValueOutput<uint32be>(vecOut+1, 0);
+				betype<FriendPID>* pidList = (betype<FriendPID>*)vecOut[0].basePhys.GetPtr();
+				std::vector<FriendPID> temporaryPidList;
+				temporaryPidList.resize(std::min<size_t>(maxCount, 500));
+				uint32 pidCount = 0;
+				g_fpd.nexFriendSession->getFriendPIDs(temporaryPidList.data(), &pidCount, startIndex, temporaryPidList.size(), isAll);
+				std::copy(temporaryPidList.begin(), temporaryPidList.begin() + pidCount, pidList);
+				return WriteValueOutput<uint32be>(vecOut+1, pidCount);
+			}
+
+			nnResult CallHandler_GetFriendRequestList(FPDClient* fpdClient, IPCIoctlVector* vecIn, uint32 numVecIn, IPCIoctlVector* vecOut, uint32 numVecOut)
+			{
+				std::unique_lock _l(g_fpd.mtxFriendSession);
+				if(numVecIn != 2 || numVecOut != 2)
+					return FPResult_InvalidIPCParam;
+				DeclareInput(startIndex, uint32be, 0);
+				DeclareInput(maxCount, uint32be, 1);
+				if(maxCount * sizeof(FriendPID) != vecOut[0].size || vecOut[0].basePhys.IsNull())
+				{
+					cemuLog_log(LogType::Force, "GetFriendRequestList: pid list buffer size is incorrect");
+					return FPResult_InvalidIPCParam;
+				}
+				if (!g_fpd.nexFriendSession)
+					return WriteValueOutput<uint32be>(vecOut+1, 0);
+				betype<FriendPID>* pidList = (betype<FriendPID>*)vecOut[0].basePhys.GetPtr();
+				std::vector<FriendPID> temporaryPidList;
+				temporaryPidList.resize(std::min<size_t>(maxCount, 500));
+				uint32 pidCount = 0;
+				g_fpd.nexFriendSession->getFriendRequestPIDs(temporaryPidList.data(), &pidCount, startIndex, temporaryPidList.size(), true, false);
+				std::copy(temporaryPidList.begin(), temporaryPidList.begin() + pidCount, pidList);
+				return WriteValueOutput<uint32be>(vecOut+1, pidCount);
+			}
+
+			nnResult CallHandler_GetFriendRequestListEx(FPDClient* fpdClient, IPCIoctlVector* vecIn, uint32 numVecIn, IPCIoctlVector* vecOut, uint32 numVecOut)
+			{
+				std::unique_lock _l(g_fpd.mtxFriendSession);
+				if(numVecIn != 2 || numVecOut != 1)
+					return FPResult_InvalidIPCParam;
+				DeclareInput(count, uint32be, 1);
+				DeclareInputPtr(pidList, uint32be, count, 0);
+				DeclareOutputPtr(friendRequests, FriendRequest, count, 0);
+				memset(friendRequests, 0, sizeof(FriendRequest) * count);
+				if (!g_fpd.nexFriendSession)
+					return FPResult_Ok;
+				for(uint32 i=0; i<count; i++)
+				{
+					nexFriendRequest frdReq;
+					bool incoming = false;
+					if (!g_fpd.nexFriendSession->getFriendRequestByPID(frdReq, &incoming, pidList[i]))
+					{
+						cemuLog_log(LogType::Force, "GetFriendRequestListEx: Failed to get friend request");
+						return FPResult_RequestFailed;
+					}
+					NexFriendRequestToFPDFriendRequest(&frdReq, incoming, friendRequests + i);
+				}
+				return FPResult_Ok;
+			}
+
+			nnResult CallHandler_GetBlackList(FPDClient* fpdClient, IPCIoctlVector* vecIn, uint32 numVecIn, IPCIoctlVector* vecOut, uint32 numVecOut)
+			{
+				std::unique_lock _l(g_fpd.mtxFriendSession);
+				if(numVecIn != 2 || numVecOut != 2)
+					return FPResult_InvalidIPCParam;
+				DeclareInput(startIndex, uint32be, 0);
+				DeclareInput(maxCount, uint32be, 1);
+				if(maxCount * sizeof(FriendPID) != vecOut[0].size)
+				{
+					cemuLog_log(LogType::Force, "GetBlackList: pid list buffer size is incorrect");
+					return FPResult_InvalidIPCParam;
+				}
+				if (!g_fpd.nexFriendSession)
+					return WriteValueOutput<uint32be>(vecOut+1, 0);
+				betype<FriendPID>* pidList = (betype<FriendPID>*)vecOut[0].basePhys.GetPtr();
+				// todo!
+				cemuLog_logDebug(LogType::Force, "GetBlackList is todo");
+				uint32 countOut = 0;
+
+				return WriteValueOutput<uint32be>(vecOut+1, countOut);
+			}
+
+			nnResult CallHandler_GetFriendListEx(FPDClient* fpdClient, IPCIoctlVector* vecIn, uint32 numVecIn, IPCIoctlVector* vecOut, uint32 numVecOut)
+			{
+				std::unique_lock _l(g_fpd.mtxFriendSession);
+				if(numVecIn != 2 || numVecOut != 1)
+					return FPResult_InvalidIPCParam;
+				DeclareInput(count, uint32be, 1);
+				DeclareInputPtr(pidList, betype<FriendPID>, count, 0);
+				if(count * sizeof(FriendPID) != vecIn[0].size)
+				{
+					cemuLog_log(LogType::Force, "GetFriendListEx: pid input list buffer size is incorrect");
+					return FPResult_InvalidIPCParam;
+				}
+				if(count * sizeof(FriendData) != vecOut[0].size)
+				{
+					cemuLog_log(LogType::Force, "GetFriendListEx: Friend output list buffer size is incorrect");
+					return FPResult_InvalidIPCParam;
+				}
+				FriendData* friendOutput = (FriendData*)vecOut[0].basePhys.GetPtr();
+				memset(friendOutput, 0, sizeof(FriendData) * count);
+				if (g_fpd.nexFriendSession)
+				{
+					for (uint32 i = 0; i < count; i++)
+					{
+						uint32 pid = pidList[i];
+						FriendData* friendData = friendOutput + i;
+						nexFriend frd;
+						nexFriendRequest frdReq;
+						if (g_fpd.nexFriendSession->getFriendByPID(frd, pid))
+						{
+							NexFriendToFPDFriendData(&frd, friendData);
+							continue;
+						}
+						bool incoming = false;
+						if (g_fpd.nexFriendSession->getFriendRequestByPID(frdReq, &incoming, pid))
+						{
+							NexFriendRequestToFPDFriendData(&frdReq, incoming, friendData);
+							continue;
+						}
+						cemuLog_logDebug(LogType::Force, "GetFriendListEx: Failed to find friend or request with pid {}", pid);
+						memset(friendData, 0, sizeof(FriendData));
+					}
+				}
+				return FPResult_Ok;
+			}
+
+			static void NexBasicInfoToBasicInfo(const nexPrincipalBasicInfo& nexBasicInfo, FriendBasicInfo& basicInfo)
+			{
+				memset(&basicInfo, 0, sizeof(FriendBasicInfo));
+				basicInfo.pid = nexBasicInfo.principalId;
+				strcpy(basicInfo.nnid, nexBasicInfo.nnid);
+
+				convertMultiByteStringToBigEndianWidechar(nexBasicInfo.mii.miiNickname, basicInfo.screenname, sizeof(basicInfo.screenname) / sizeof(uint16be));
+				memcpy(basicInfo.miiData, nexBasicInfo.mii.miiData, FFL_SIZE);
+
+				basicInfo.uknDate90.day = 1;
+				basicInfo.uknDate90.month = 1;
+				basicInfo.uknDate90.hour = 1;
+				basicInfo.uknDate90.minute = 1;
+				basicInfo.uknDate90.second = 1;
 
 				// unknown values not set:
 				// ukn15
 				// ukn2E
 				// ukn2F
 			}
-			// success
-			handleFPCallback(&cbInfo->fpCallback, 0x00000000);
 
-			free(cbInfo->principalBasicInfo);
-			free(cbInfo->pidList);
-			free(cbInfo);
-		}
-
-		void handleRequest_GetBasicInfoAsync(iosuFpdCemuRequest_t* fpdCemuRequest)
-		{
-			fpdCemuRequest->returnCode = 0;
-			if (g_fpd.nexFriendSession == nullptr || g_fpd.nexFriendSession->isOnline() == false)
+			nnResult CallHandler_GetBasicInfoAsync(FPDClient* fpdClient, IPCIoctlVector* vecIn, uint32 numVecIn, IPCIoctlVector* vecOut, uint32 numVecOut)
 			{
-				fpdCemuRequest->returnCode = 0x80000000;
-				return;
-			}
-			sint32 count = fpdCemuRequest->getBasicInfo.count;
-
-			nexPrincipalBasicInfo* principalBasicInfo = new nexPrincipalBasicInfo[count];
-			uint32* pidList = (uint32*)malloc(sizeof(uint32)*count);
-			for (sint32 i = 0; i < count; i++)
-				pidList[i] = fpdCemuRequest->getBasicInfo.pidList[i];
-			getBasicInfoAsyncParams_t* cbInfo = (getBasicInfoAsyncParams_t*)malloc(sizeof(getBasicInfoAsyncParams_t));
-			cbInfo->principalBasicInfo = principalBasicInfo;
-			cbInfo->pidList = pidList;
-			cbInfo->count = count;
-			cbInfo->friendBasicInfo = fpdCemuRequest->getBasicInfo.basicInfo.GetPtr();
-			cbInfo->fpCallback.funcMPTR = fpdCemuRequest->getBasicInfo.funcPtr;
-			cbInfo->fpCallback.customParam = fpdCemuRequest->getBasicInfo.custom;
-			g_fpd.nexFriendSession->requestPrincipleBaseInfoByPID(principalBasicInfo, pidList, count, handleResultCB_GetBasicInfoAsync, cbInfo);
-		}
-
-		void handleResponse_addOrRemoveFriend(uint32 errorCode, MPTR funcMPTR, MPTR custom)
-		{
-			if (errorCode == 0)
-			{
-				handleFPCallback2(funcMPTR, custom, 0);
-				g_fpd.nexFriendSession->requestGetAllInformation(); // refresh list
-			}
-			else
-				handleFPCallback2(funcMPTR, custom, 0x80000000);
-		}
-
-		void handleRequest_RemoveFriendAsync(iosuFpdCemuRequest_t* fpdCemuRequest)
-		{
-			fpdCemuRequest->returnCode = 0;
-			if (g_fpd.nexFriendSession == nullptr || g_fpd.nexFriendSession->isOnline() == false)
-			{
-				fpdCemuRequest->returnCode = 0x80000000;
-				return;
-			}
-			g_fpd.nexFriendSession->removeFriend(fpdCemuRequest->addOrRemoveFriend.pid, std::bind(handleResponse_addOrRemoveFriend, std::placeholders::_1, fpdCemuRequest->addOrRemoveFriend.funcPtr, fpdCemuRequest->addOrRemoveFriend.custom));
-		}
-
-		void handleResponse_MarkFriendRequestAsReceivedAsync(uint32 errorCode, MPTR funcMPTR, MPTR custom)
-		{
-			if (errorCode == 0)
-				handleFPCallback2(funcMPTR, custom, 0);
-			else
-				handleFPCallback2(funcMPTR, custom, 0x80000000);
-		}
-
-		void handleRequest_MarkFriendRequestAsReceivedAsync(iosuFpdCemuRequest_t* fpdCemuRequest)
-		{
-			fpdCemuRequest->returnCode = 0;
-			if (g_fpd.nexFriendSession == nullptr || g_fpd.nexFriendSession->isOnline() == false)
-			{
-				fpdCemuRequest->returnCode = 0x80000000;
-				return;
-			}
-			// convert messageId list to little endian
-			uint64 messageIds[100];
-			sint32 count = 0;
-			for (uint32 i = 0; i < fpdCemuRequest->markFriendRequest.count; i++)
-			{
-				uint64 mid = _swapEndianU64(fpdCemuRequest->markFriendRequest.messageIdList.GetPtr()[i]);
-				if (mid == 0)
+				std::unique_lock _l(g_fpd.mtxFriendSession);
+				if (numVecIn != 2 || numVecOut != 1)
+					return FPResult_InvalidIPCParam;
+				DeclareInput(count, uint32be, 1);
+				DeclareInputPtr(pidListBE, betype<FriendPID>, count, 0);
+				DeclareOutputPtr(basicInfoList, FriendBasicInfo, count, 0);
+				if (!g_fpd.nexFriendSession)
 				{
-					forceLogDebug_printf("MarkFriendRequestAsReceivedAsync - Invalid messageId");
-					continue;
+					memset(basicInfoList, 0, sizeof(FriendBasicInfo) * sizeof(count));
+					return FPResult_Ok;
 				}
-				messageIds[count] = mid;
-				count++;
-				if (count >= sizeof(messageIds)/sizeof(messageIds[0]))
-					break;
-			}
-			// skipped for now
-			g_fpd.nexFriendSession->markFriendRequestsAsReceived(messageIds, count, std::bind(handleResponse_MarkFriendRequestAsReceivedAsync, std::placeholders::_1, fpdCemuRequest->markFriendRequest.funcPtr, fpdCemuRequest->markFriendRequest.custom));
-		}
-
-		void handleResponse_cancelMyFriendRequest(uint32 errorCode, uint32 pid, MPTR funcMPTR, MPTR custom)
-		{
-			if (errorCode == 0)
-			{
-				handleFPCallback2(funcMPTR, custom, 0);
-			}
-			else
-				handleFPCallback2(funcMPTR, custom, 0x80000000);
-		}
-
-		void handleRequest_CancelFriendRequestAsync(iosuFpdCemuRequest_t* fpdCemuRequest)
-		{
-			fpdCemuRequest->returnCode = 0;
-			if (g_fpd.nexFriendSession == nullptr || g_fpd.nexFriendSession->isOnline() == false)
-			{
-				fpdCemuRequest->returnCode = 0x80000000;
-				return;
-			}
-			// find friend request with matching pid
-			nexFriendRequest frq;
-			bool isIncoming;
-			if (g_fpd.nexFriendSession->getFriendRequestByMessageId(frq, &isIncoming, fpdCemuRequest->cancelOrAcceptFriendRequest.messageId))
-			{
-				g_fpd.nexFriendSession->removeFriend(frq.principalInfo.principalId, std::bind(handleResponse_cancelMyFriendRequest, std::placeholders::_1, frq.principalInfo.principalId, fpdCemuRequest->cancelOrAcceptFriendRequest.funcPtr, fpdCemuRequest->cancelOrAcceptFriendRequest.custom));
-			}
-			else
-			{
-				fpdCemuRequest->returnCode = 0x80000000;
-				return;
-			}
-		}
-
-		void handleResponse_acceptFriendRequest(uint32 errorCode, uint32 pid, MPTR funcMPTR, MPTR custom)
-		{
-			if (errorCode == 0)
-			{
-				handleFPCallback2(funcMPTR, custom, 0);
-				g_fpd.nexFriendSession->requestGetAllInformation(); // refresh list
-			}
-			else
-				handleFPCallback2(funcMPTR, custom, 0x80000000);
-		}
-
-		void handleRequest_AcceptFriendRequestAsync(iosuFpdCemuRequest_t* fpdCemuRequest)
-		{
-			fpdCemuRequest->returnCode = 0;
-			if (g_fpd.nexFriendSession == nullptr || g_fpd.nexFriendSession->isOnline() == false)
-			{
-				fpdCemuRequest->returnCode = 0x80000000;
-				return;
-			}
-			// find friend request with matching pid
-			nexFriendRequest frq;
-			bool isIncoming;
-			if (g_fpd.nexFriendSession->getFriendRequestByMessageId(frq, &isIncoming, fpdCemuRequest->cancelOrAcceptFriendRequest.messageId))
-			{
-				g_fpd.nexFriendSession->acceptFriendRequest(fpdCemuRequest->cancelOrAcceptFriendRequest.messageId, std::bind(handleResponse_acceptFriendRequest, std::placeholders::_1, frq.principalInfo.principalId, fpdCemuRequest->cancelOrAcceptFriendRequest.funcPtr, fpdCemuRequest->cancelOrAcceptFriendRequest.custom));
-			}
-			else
-			{
-				fpdCemuRequest->returnCode = 0x80000000;
-				return;
-			}
-		}
-
-		void handleResponse_addFriendRequest(uint32 errorCode, MPTR funcMPTR, MPTR custom)
-		{
-			if (errorCode == 0)
-			{
-				handleFPCallback2(funcMPTR, custom, 0);
-				g_fpd.nexFriendSession->requestGetAllInformation(); // refresh list
-			}
-			else
-				handleFPCallback2(funcMPTR, custom, 0x80000000);
-		}
-
-		void handleRequest_AddFriendRequest(iosuFpdCemuRequest_t* fpdCemuRequest)
-		{
-			fpdCemuRequest->returnCode = 0;
-			if (g_fpd.nexFriendSession == nullptr || g_fpd.nexFriendSession->isOnline() == false)
-			{
-				fpdCemuRequest->returnCode = 0x80000000;
-				return;
+				IPCCommandBody* cmd = ServiceCallDelayCurrentResponse();
+				std::vector<uint32> pidList;
+				std::copy(pidListBE, pidListBE + count, std::back_inserter(pidList));
+				g_fpd.nexFriendSession->requestPrincipleBaseInfoByPID(pidList.data(), count, [cmd, basicInfoList, count](NexFriends::RpcErrorCode result, std::span<nexPrincipalBasicInfo> basicInfo) -> void {
+					if (result != NexFriends::ERR_NONE)
+						return ServiceCallAsyncRespond(cmd, FPResult_RequestFailed);
+					cemu_assert_debug(basicInfo.size() == count);
+					for(uint32 i = 0; i < count; i++)
+						NexBasicInfoToBasicInfo(basicInfo[i], basicInfoList[i]);
+					ServiceCallAsyncRespond(cmd, FPResult_Ok);
+				});
+				return FPResult_Ok;
 			}
 
-			uint16be* input = fpdCemuRequest->addFriendRequest.message.GetPtr();
-			size_t inputLen = 0;
-			while (input[inputLen] != 0)
-				inputLen++;
-			std::string msg = StringHelpers::ToUtf8({ input, inputLen });
-
-			g_fpd.nexFriendSession->addFriendRequest(fpdCemuRequest->addFriendRequest.pid, msg.data(), std::bind(handleResponse_addFriendRequest, std::placeholders::_1, fpdCemuRequest->addFriendRequest.funcPtr, fpdCemuRequest->addFriendRequest.custom));
-		}
-
-		// called once a second to handle state checking and updates of the friends service
-		void iosuFpd_updateFriendsService()
-		{
-			if (g_fpd.nexFriendSession)
+			nnResult CallHandler_UpdateCommentAsync(FPDClient* fpdClient, IPCIoctlVector* vecIn, uint32 numVecIn, IPCIoctlVector* vecOut, uint32 numVecOut)
 			{
-				g_fpd.nexFriendSession->update();
-
-				if (g_fpd.asyncLoginCallback.func != MPTR_NULL)
+				std::unique_lock _l(g_fpd.mtxFriendSession);
+				if (numVecIn != 1 || numVecOut != 0)
+					return FPResult_InvalidIPCParam;
+				if (!g_fpd.nexFriendSession)
+					return FPResult_RequestFailed;
+				uint32 messageLength = vecIn[0].size / sizeof(uint16be);
+				DeclareInputPtr(newComment, uint16be, messageLength, 0);
+				if (messageLength == 0 || newComment[messageLength-1] != 0)
 				{
-					if (g_fpd.nexFriendSession->isOnline())
-					{
-						*_fpdAsyncLoginRetCode.GetPtr() = 0x00000000;
-						coreinitAsyncCallback_add(g_fpd.asyncLoginCallback.func, 2, _fpdAsyncLoginRetCode.GetMPTR(), g_fpd.asyncLoginCallback.customParam);
-						g_fpd.asyncLoginCallback.func = MPTR_NULL;
-						g_fpd.asyncLoginCallback.customParam = MPTR_NULL;
-					}
+					cemuLog_log(LogType::Force, "UpdateCommentAsync: Message must contain at least a null-termination character");
+					return FPResult_InvalidIPCParam;
 				}
+				IPCCommandBody* cmd = ServiceCallDelayCurrentResponse();
+
+				auto utf8_comment = StringHelpers::ToUtf8(newComment, messageLength);
+				nexComment temporaryComment;
+				temporaryComment.ukn0 = 0;
+				temporaryComment.commentString = utf8_comment;
+				temporaryComment.ukn1 = 0;
+
+				g_fpd.nexFriendSession->updateCommentAsync(temporaryComment, [cmd](NexFriends::RpcErrorCode result) {
+					if (result != NexFriends::ERR_NONE)
+						return ServiceCallAsyncRespond(cmd, FPResult_RequestFailed);
+					ServiceCallAsyncRespond(cmd, FPResult_Ok);
+				});
+				return FPResult_Ok;
 			}
-		}
 
-		void iosuFpd_thread()
-		{
-			SetThreadName("iosuFpd_thread");
-			while (true)
+			nnResult CallHandler_UpdatePreferenceAsync(FPDClient* fpdClient, IPCIoctlVector* vecIn, uint32 numVecIn, IPCIoctlVector* vecOut, uint32 numVecOut)
 			{
-				uint32 returnValue = 0; // Ioctl return value
-				ioQueueEntry_t* ioQueueEntry = iosuIoctl_getNextWithTimeout(IOS_DEVICE_FPD, 1000);
-				if (ioQueueEntry == nullptr)
+				std::unique_lock _l(g_fpd.mtxFriendSession);
+				if (numVecIn != 1 || numVecOut != 0)
+					return FPResult_InvalidIPCParam;
+				if (!g_fpd.nexFriendSession)
+					return FPResult_RequestFailed;
+				DeclareInputPtr(newPreference, FPDPreference, 1, 0);
+				IPCCommandBody* cmd = ServiceCallDelayCurrentResponse();
+				g_fpd.nexFriendSession->updatePreferencesAsync(nexPrincipalPreference(newPreference->showOnline != 0 ? 1 : 0, newPreference->showGame != 0 ? 1 : 0, newPreference->blockFriendRequests != 0 ? 1 : 0), [cmd](NexFriends::RpcErrorCode result){
+					if (result != NexFriends::ERR_NONE)
+						return ServiceCallAsyncRespond(cmd, FPResult_RequestFailed);
+					ServiceCallAsyncRespond(cmd, FPResult_Ok);
+				});
+				return FPResult_Ok;
+			}
+
+			nnResult CallHandler_AddFriendRequestAsync(FPDClient* fpdClient, IPCIoctlVector* vecIn, uint32 numVecIn, IPCIoctlVector* vecOut, uint32 numVecOut)
+			{
+				std::unique_lock _l(g_fpd.mtxFriendSession);
+				if (numVecIn != 2 || numVecOut != 0)
+					return FPResult_InvalidIPCParam;
+				if (!g_fpd.nexFriendSession)
+					return FPResult_RequestFailed;
+				DeclareInputPtr(playRecord, RecentPlayRecordEx, 1, 0);
+				uint32 msgLength = vecIn[1].size/sizeof(uint16be);
+				DeclareInputPtr(msgBE, uint16be, msgLength, 1);
+				if(msgLength == 0 || msgBE[msgLength-1] != 0)
 				{
-					iosuFpd_updateFriendsService();
-					continue;
+					cemuLog_log(LogType::Force, "AddFriendRequestAsync: Message must contain at least a null-termination character and end with one");
+					return FPResult_InvalidIPCParam;
 				}
-				if (ioQueueEntry->request == IOSU_FPD_REQUEST_CEMU)
+				std::string msg = StringHelpers::ToUtf8({ msgBE, msgLength-1 });
+				IPCCommandBody* cmd = ServiceCallDelayCurrentResponse();
+				g_fpd.nexFriendSession->addFriendRequest(playRecord->pid, msg.data(), [cmd](NexFriends::RpcErrorCode result){
+					if (result != NexFriends::ERR_NONE)
+						return ServiceCallAsyncRespond(cmd, FPResult_RequestFailed);
+					ServiceCallAsyncRespond(cmd, FPResult_Ok);
+				});
+				return FPResult_Ok;
+			}
+
+			nnResult CallHandler_AcceptFriendRequestAsync(FPDClient* fpdClient, IPCIoctlVector* vecIn, uint32 numVecIn, IPCIoctlVector* vecOut, uint32 numVecOut)
+			{
+				std::unique_lock _l(g_fpd.mtxFriendSession);
+				if (numVecIn != 1 || numVecOut != 0)
+					return FPResult_InvalidIPCParam;
+				if (!g_fpd.nexFriendSession)
+					return FPResult_RequestFailed;
+				DeclareInput(requestId, uint64be, 0);
+				nexFriendRequest frq;
+				bool isIncoming;
+				if (!g_fpd.nexFriendSession->getFriendRequestByMessageId(frq, &isIncoming, requestId))
+					return FPResult_RequestFailed;
+				if(!isIncoming)
 				{
-					iosuFpdCemuRequest_t* fpdCemuRequest = (iosuFpdCemuRequest_t*)ioQueueEntry->bufferVectors[0].buffer.GetPtr();
-					if (fpdCemuRequest->requestCode == IOSU_FPD_INITIALIZE)
-					{
-						if (g_fpd.isInitialized2 == false)
-						{
-							if(ActiveSettings::IsOnlineEnabled())
-								startFriendSession();
-							
-							g_fpd.isInitialized2 = true;
-						}
-					}
-					else if (fpdCemuRequest->requestCode == IOSU_FPD_SET_NOTIFICATION_HANDLER)
-					{
-						g_fpd.notificationFunc = fpdCemuRequest->setNotificationHandler.funcPtr;
-						g_fpd.notificationCustomParam = fpdCemuRequest->setNotificationHandler.custom;
-						g_fpd.notificationMask = fpdCemuRequest->setNotificationHandler.notificationMask;
-					}
-					else if (fpdCemuRequest->requestCode == IOSU_FPD_LOGIN_ASYNC)
-					{
-						if (g_fpd.nexFriendSession)
-						{
-							g_fpd.asyncLoginCallback.func = fpdCemuRequest->loginAsync.funcPtr;
-							g_fpd.asyncLoginCallback.customParam = fpdCemuRequest->loginAsync.custom;
-						}
-						else
-						{
-							// offline mode
-							*_fpdAsyncLoginRetCode.GetPtr() = 0; // if we return 0x80000000 here then Splatoon softlocks during boot
-							coreinitAsyncCallback_add(fpdCemuRequest->loginAsync.funcPtr, 2, _fpdAsyncLoginRetCode.GetMPTR(), fpdCemuRequest->loginAsync.custom);
-						}
-					}
-					else if (fpdCemuRequest->requestCode == IOSU_FPD_IS_ONLINE)
-					{
-						fpdCemuRequest->resultU32.u32 = g_fpd.nexFriendSession ? g_fpd.nexFriendSession->isOnline() : 0;
-					}
-					else if (fpdCemuRequest->requestCode == IOSU_FPD_IS_PREFERENCE_VALID)
-					{
-						fpdCemuRequest->resultU32.u32 = 1; // todo (if this returns 0, the friend app will show the first-time-setup screen and ask the user to configure preferences)
-					}
-					else if (fpdCemuRequest->requestCode == IOSU_FPD_GET_MY_PRINCIPAL_ID)
-					{
-						uint8 slot = iosu::act::getCurrentAccountSlot();
-						iosu::act::getPrincipalId(slot, &fpdCemuRequest->resultU32.u32);
-					}
-					else if (fpdCemuRequest->requestCode == IOSU_FPD_GET_MY_ACCOUNT_ID)
-					{
-						char* accountId = (char*)fpdCemuRequest->common.ptr.GetPtr();
-						uint8 slot = iosu::act::getCurrentAccountSlot();
-						if (iosu::act::getAccountId(slot, accountId) == false)
-							fpdCemuRequest->returnCode = 0x80000000; // todo - proper error code
-						else
-							fpdCemuRequest->returnCode = 0;
-					}
-					else if (fpdCemuRequest->requestCode == IOSU_FPD_GET_MY_MII)
-					{
-						FFLData_t* fflData = (FFLData_t*)fpdCemuRequest->common.ptr.GetPtr();
-						uint8 slot = iosu::act::getCurrentAccountSlot();
-						if (iosu::act::getMii(slot, fflData) == false)
-							fpdCemuRequest->returnCode = 0x80000000; // todo - proper error code
-						else
-							fpdCemuRequest->returnCode = 0;
-					}
-					else if (fpdCemuRequest->requestCode == IOSU_FPD_GET_MY_SCREENNAME)
-					{
-						uint16be* screennameOutput = (uint16be*)fpdCemuRequest->common.ptr.GetPtr();
-						uint8 slot = iosu::act::getCurrentAccountSlot();
-						uint16 screennameTemp[ACT_NICKNAME_LENGTH];
-						if (iosu::act::getScreenname(slot, screennameTemp))
-						{
-							for (sint32 i = 0; i < ACT_NICKNAME_LENGTH; i++)
-							{
-								screennameOutput[i] = screennameTemp[i];
-							}
-							screennameOutput[ACT_NICKNAME_LENGTH] = '\0'; // length is ACT_NICKNAME_LENGTH+1
-							fpdCemuRequest->returnCode = 0;
-						}
-						else
-						{
-							fpdCemuRequest->returnCode = 0x80000000; // todo - proper error code
-							screennameOutput[0] = '\0';
-						}
-					}
-					else if (fpdCemuRequest->requestCode == IOSU_FPD_GET_FRIEND_ACCOUNT_ID)
-					{
-						if (g_fpd.nexFriendSession == nullptr)
-						{
-							fpdCemuRequest->returnCode = 0x80000000; // todo - proper error code
-							iosuIoctl_completeRequest(ioQueueEntry, returnValue);
-							return;
-						}
-						fpdCemuRequest->returnCode = 0;
-						for (sint32 i = 0; i < fpdCemuRequest->getFriendAccountId.count; i++)
-						{
-							char* nnidOutput = fpdCemuRequest->getFriendAccountId.accountIds.GetPtr()+i*17;
-							uint32 pid = fpdCemuRequest->getFriendAccountId.pidList[i];
-							if (g_fpd.nexFriendSession == nullptr)
-							{
-								nnidOutput[0] = '\0';
-								continue;
-							}
-							nexFriend frd;
-							nexFriendRequest frdReq;
-							if (g_fpd.nexFriendSession->getFriendByPID(frd, pid))
-							{
-								strcpy(nnidOutput, frd.nnaInfo.principalInfo.nnid);
-								continue;
-							}
-							bool incoming = false;
-							if (g_fpd.nexFriendSession->getFriendRequestByPID(frdReq, &incoming, pid))
-							{
-								strcpy(nnidOutput, frdReq.principalInfo.nnid);
-								continue;
-							}
-							nnidOutput[0] = '\0';
-						}
-					}
-					else if (fpdCemuRequest->requestCode == IOSU_FPD_GET_FRIEND_SCREENNAME)
-					{
-						if (g_fpd.nexFriendSession == nullptr)
-						{
-							fpdCemuRequest->returnCode = 0x80000000; // todo - proper error code
-							iosuIoctl_completeRequest(ioQueueEntry, returnValue);
-							return;
-						}
-						fpdCemuRequest->returnCode = 0;
-						for (sint32 i = 0; i < fpdCemuRequest->getFriendScreenname.count; i++)
-						{
-							uint16be* screennameOutput = fpdCemuRequest->getFriendScreenname.nameList.GetPtr()+i*11;
-							uint32 pid = fpdCemuRequest->getFriendScreenname.pidList[i];
-							if(fpdCemuRequest->getFriendScreenname.languageList.IsNull() == false)
-								fpdCemuRequest->getFriendScreenname.languageList.GetPtr()[i] = 0;
-							if (g_fpd.nexFriendSession == nullptr)
-							{
-								screennameOutput[0] = '\0';
-								continue;
-							}
-							nexFriend frd;
-							nexFriendRequest frdReq;
-							if (g_fpd.nexFriendSession->getFriendByPID(frd, pid))
-							{
-								convertMultiByteStringToBigEndianWidechar(frd.nnaInfo.principalInfo.mii.miiNickname, screennameOutput, 11);
-								if (fpdCemuRequest->getFriendScreenname.languageList.IsNull() == false)
-									fpdCemuRequest->getFriendScreenname.languageList.GetPtr()[i] = frd.nnaInfo.principalInfo.regionGuessed;
-								continue;
-							}
-							bool incoming = false;
-							if (g_fpd.nexFriendSession->getFriendRequestByPID(frdReq, &incoming, pid))
-							{
-								convertMultiByteStringToBigEndianWidechar(frdReq.principalInfo.mii.miiNickname, screennameOutput, 11);
-								if (fpdCemuRequest->getFriendScreenname.languageList.IsNull() == false)
-									fpdCemuRequest->getFriendScreenname.languageList.GetPtr()[i] = frdReq.principalInfo.regionGuessed;
-								continue;
-							}
-							screennameOutput[0] = '\0';
-						}
-					}
-					else if (fpdCemuRequest->requestCode == IOSU_FPD_GET_FRIEND_MII)
-					{
-						if (g_fpd.nexFriendSession == nullptr)
-						{
-							fpdCemuRequest->returnCode = 0x80000000; // todo - proper error code
-							iosuIoctl_completeRequest(ioQueueEntry, returnValue);
-							return;
-						}
-						fpdCemuRequest->returnCode = 0;
-						for (sint32 i = 0; i < fpdCemuRequest->getFriendMii.count; i++)
-						{
-							uint8* miiOutput = fpdCemuRequest->getFriendMii.miiList + i * FFL_SIZE;
-							uint32 pid = fpdCemuRequest->getFriendMii.pidList[i];
-							if (g_fpd.nexFriendSession == nullptr)
-							{
-								memset(miiOutput, 0, FFL_SIZE);
-								continue;
-							}
-							nexFriend frd;
-							nexFriendRequest frdReq;
-							if (g_fpd.nexFriendSession->getFriendByPID(frd, pid))
-							{
-								memcpy(miiOutput, frd.nnaInfo.principalInfo.mii.miiData, FFL_SIZE);
-								continue;
-							}
-							bool incoming = false;
-							if (g_fpd.nexFriendSession->getFriendRequestByPID(frdReq, &incoming, pid))
-							{
-								memcpy(miiOutput, frdReq.principalInfo.mii.miiData, FFL_SIZE);
-								continue;
-							}
-							memset(miiOutput, 0, FFL_SIZE);
-						}
-					}
-					else if (fpdCemuRequest->requestCode == IOSU_FPD_GET_FRIEND_PRESENCE)
-					{
-						if (g_fpd.nexFriendSession == nullptr)
-						{
-							fpdCemuRequest->returnCode = 0x80000000; // todo - proper error code
-							iosuIoctl_completeRequest(ioQueueEntry, returnValue);
-							return;
-						}
-						fpdCemuRequest->returnCode = 0;
-						for (sint32 i = 0; i < fpdCemuRequest->getFriendPresence.count; i++)
-						{
-							friendPresence_t* presenceOutput = (friendPresence_t*)(fpdCemuRequest->getFriendPresence.presenceList + i * sizeof(friendPresence_t));
-							memset(presenceOutput, 0, sizeof(friendPresence_t));
-							uint32 pid = fpdCemuRequest->getFriendPresence.pidList[i];
-							if (g_fpd.nexFriendSession == nullptr)
-							{
-								continue;
-							}
-							nexFriend frd;
-							nexFriendRequest frdReq;
-							if (g_fpd.nexFriendSession->getFriendByPID(frd, pid))
-							{
-								presenceOutput->isOnline = frd.presence.isOnline ? 1 : 0;
-								presenceOutput->isValid = 1;
+					cemuLog_log(LogType::Force, "AcceptFriendRequestAsync: Trying to accept outgoing friend request");
+					return FPResult_RequestFailed;
+				}
+				IPCCommandBody* cmd = ServiceCallDelayCurrentResponse();
+				g_fpd.nexFriendSession->acceptFriendRequest(requestId, [cmd](NexFriends::RpcErrorCode result){
+					if (result != NexFriends::ERR_NONE)
+						return ServiceCallAsyncRespond(cmd, FPResult_RequestFailed);
+					return ServiceCallAsyncRespond(cmd, FPResult_Ok);
+				});
+				return FPResult_Ok;
+			}
 
-								presenceOutput->gameMode.joinFlagMask = frd.presence.joinFlagMask;
-								presenceOutput->gameMode.matchmakeType = frd.presence.joinAvailability;
-								presenceOutput->gameMode.joinGameId = frd.presence.gameId;
-								presenceOutput->gameMode.joinGameMode = frd.presence.gameMode;
-								presenceOutput->gameMode.hostPid = frd.presence.hostPid;
-								presenceOutput->gameMode.groupId = frd.presence.groupId;
+			nnResult CallHandler_DeleteFriendRequestAsync(FPDClient* fpdClient, IPCIoctlVector* vecIn, uint32 numVecIn, IPCIoctlVector* vecOut, uint32 numVecOut)
+			{
+				// reject incoming friend request
+				std::unique_lock _l(g_fpd.mtxFriendSession);
+				if (numVecIn != 1 || numVecOut != 0)
+					return FPResult_InvalidIPCParam;
+				if (!g_fpd.nexFriendSession)
+					return FPResult_RequestFailed;
+				DeclareInput(requestId, uint64be, 0);
+				nexFriendRequest frq;
+				bool isIncoming;
+				if (!g_fpd.nexFriendSession->getFriendRequestByMessageId(frq, &isIncoming, requestId))
+					return FPResult_RequestFailed;
+				if(!isIncoming)
+				{
+					cemuLog_log(LogType::Force, "CancelFriendRequestAsync: Trying to block outgoing friend request");
+					return FPResult_RequestFailed;
+				}
+				IPCCommandBody* cmd = ServiceCallDelayCurrentResponse();
+				g_fpd.nexFriendSession->deleteFriendRequest(requestId, [cmd](NexFriends::RpcErrorCode result){
+					if (result != NexFriends::ERR_NONE)
+						return ServiceCallAsyncRespond(cmd, FPResult_RequestFailed);
+					return ServiceCallAsyncRespond(cmd, FPResult_Ok);
+				});
+				return FPResult_Ok;
+			}
 
-								memcpy(presenceOutput->gameMode.appSpecificData, frd.presence.appSpecificData, 0x14);
+			nnResult CallHandler_CancelFriendRequestAsync(FPDClient* fpdClient, IPCIoctlVector* vecIn, uint32 numVecIn, IPCIoctlVector* vecOut, uint32 numVecOut)
+			{
+				// retract outgoing friend request
+				std::unique_lock _l(g_fpd.mtxFriendSession);
+				if (numVecIn != 1 || numVecOut != 0)
+					return FPResult_InvalidIPCParam;
+				if (!g_fpd.nexFriendSession)
+					return FPResult_RequestFailed;
+				DeclareInput(requestId, uint64be, 0);
+				nexFriendRequest frq;
+				bool isIncoming;
+				if (!g_fpd.nexFriendSession->getFriendRequestByMessageId(frq, &isIncoming, requestId))
+					return FPResult_RequestFailed;
+				if(isIncoming)
+				{
+					cemuLog_log(LogType::Force, "CancelFriendRequestAsync: Trying to cancel incoming friend request");
+					return FPResult_RequestFailed;
+				}
+				IPCCommandBody* cmd = ServiceCallDelayCurrentResponse();
+				g_fpd.nexFriendSession->removeFriend(frq.principalInfo.principalId, [cmd](NexFriends::RpcErrorCode result){
+					if (result != NexFriends::ERR_NONE)
+						return ServiceCallAsyncRespond(cmd, FPResult_RequestFailed);
+					return ServiceCallAsyncRespond(cmd, FPResult_Ok);
+				});
+				return FPResult_Ok;
+			}
 
-								continue;
-							}
-						}
-					}
-					else if (fpdCemuRequest->requestCode == IOSU_FPD_GET_FRIEND_RELATIONSHIP)
-					{
-						if (g_fpd.nexFriendSession == nullptr)
-						{
-							fpdCemuRequest->returnCode = 0x80000000; // todo - proper error code
-							iosuIoctl_completeRequest(ioQueueEntry, returnValue);
-							return;
-						}
-						fpdCemuRequest->returnCode = 0;
-						for (sint32 i = 0; i < fpdCemuRequest->getFriendRelationship.count; i++)
-						{
-							uint8* relationshipOutput = (fpdCemuRequest->getFriendRelationship.relationshipList + i);
-							uint32 pid = fpdCemuRequest->getFriendRelationship.pidList[i];
-							*relationshipOutput = RELATIONSHIP_INVALID;
-							if (g_fpd.nexFriendSession == nullptr)
-							{
-								continue;
-							}
-							nexFriend frd;
-							nexFriendRequest frdReq;
-							bool incoming;
-							if (g_fpd.nexFriendSession->getFriendByPID(frd, pid))
-							{
-								*relationshipOutput = RELATIONSHIP_FRIEND;
-								continue;
-							}
-							else if (g_fpd.nexFriendSession->getFriendRequestByPID(frdReq, &incoming, pid))
-							{
-								if(incoming)
-									*relationshipOutput = RELATIONSHIP_FRIENDREQUEST_IN;
-								else
-									*relationshipOutput = RELATIONSHIP_FRIENDREQUEST_OUT;
-							}
-						}
-					}
-					else if (fpdCemuRequest->requestCode == IOSU_FPD_GET_FRIEND_LIST)
-					{
-						handleRequest_GetFriendList(fpdCemuRequest, false);
-					}
-					else if (fpdCemuRequest->requestCode == IOSU_FPD_GET_FRIENDREQUEST_LIST)
-					{
-						handleRequest_GetFriendRequestList(fpdCemuRequest);
-					}
-					else if (fpdCemuRequest->requestCode == IOSU_FPD_GET_FRIEND_LIST_ALL)
-					{
-						handleRequest_GetFriendList(fpdCemuRequest, true);
-					}
-					else if (fpdCemuRequest->requestCode == IOSU_FPD_GET_FRIEND_LIST_EX)
-					{
-						if (g_fpd.nexFriendSession == nullptr)
-						{
-							fpdCemuRequest->returnCode = 0x80000000; // todo - proper error code
-							iosuIoctl_completeRequest(ioQueueEntry, returnValue);
-							return;
-						}
-						handleRequest_GetFriendListEx(fpdCemuRequest);
-					}
-					else if (fpdCemuRequest->requestCode == IOSU_FPD_GET_FRIENDREQUEST_LIST_EX)
-					{
-						if (g_fpd.nexFriendSession == nullptr)
-						{
-							fpdCemuRequest->returnCode = 0x80000000; // todo - proper error code
-							iosuIoctl_completeRequest(ioQueueEntry, returnValue);
-							return;
-						}
-						handleRequest_GetFriendRequestListEx(fpdCemuRequest);
-					}
-					else if (fpdCemuRequest->requestCode == IOSU_FPD_ADD_FRIEND)
-					{
-						// todo - figure out how this works
-						*_fpdAsyncAddFriendRetCode.GetPtr() = 0;
-						coreinitAsyncCallback_add(fpdCemuRequest->addOrRemoveFriend.funcPtr, 2, _fpdAsyncAddFriendRetCode.GetMPTR(), fpdCemuRequest->addOrRemoveFriend.custom);
-					}
-					else if (fpdCemuRequest->requestCode == IOSU_FPD_ADD_FRIEND_REQUEST)
-					{
-						handleRequest_AddFriendRequest(fpdCemuRequest);
-					}
-					else if (fpdCemuRequest->requestCode == IOSU_FPD_REMOVE_FRIEND_ASYNC)
-					{
-						handleRequest_RemoveFriendAsync(fpdCemuRequest);
-					}
-					else if (fpdCemuRequest->requestCode == IOSU_FPD_MARK_FRIEND_REQUEST_AS_RECEIVED_ASYNC)
-					{
-						handleRequest_MarkFriendRequestAsReceivedAsync(fpdCemuRequest);
-					}
-					else if (fpdCemuRequest->requestCode == IOSU_FPD_CANCEL_FRIEND_REQUEST_ASYNC)
-					{
-						handleRequest_CancelFriendRequestAsync(fpdCemuRequest);
-					}
-					else if (fpdCemuRequest->requestCode == IOSU_FPD_ACCEPT_FRIEND_REQUEST_ASYNC)
-					{
-						handleRequest_AcceptFriendRequestAsync(fpdCemuRequest);
-					}
-					else if (fpdCemuRequest->requestCode == IOSU_FPD_GET_BASIC_INFO_ASYNC)
-					{
-						handleRequest_GetBasicInfoAsync(fpdCemuRequest);
-					}
-					else if (fpdCemuRequest->requestCode == IOSU_FPD_UPDATE_GAMEMODE)
-					{
-						gameMode_t* gameMode = fpdCemuRequest->updateGameMode.gameMode.GetPtr();
-						uint16be* gameModeMessage = fpdCemuRequest->updateGameMode.gameModeMessage.GetPtr();
+			nnResult CallHandler_MarkFriendRequestsAsReceivedAsync(FPDClient* fpdClient, IPCIoctlVector* vecIn, uint32 numVecIn, IPCIoctlVector* vecOut, uint32 numVecOut)
+			{
+				std::unique_lock _l(g_fpd.mtxFriendSession);
+				if (numVecIn != 2 || numVecOut != 0)
+					return FPResult_InvalidIPCParam;
+				if (!g_fpd.nexFriendSession)
+					return FPResult_RequestFailed;
+				DeclareInput(count, uint32be, 1);
+				DeclareInputPtr(requestIdsBE, uint64be, count, 0);
+				IPCCommandBody* cmd = ServiceCallDelayCurrentResponse();
+				// endian convert
+				std::vector<uint64> requestIds;
+				std::copy(requestIdsBE, requestIdsBE + count, std::back_inserter(requestIds));
+				g_fpd.nexFriendSession->markFriendRequestsAsReceived(requestIds.data(), requestIds.size(), [cmd](NexFriends::RpcErrorCode result){
+					if (result != NexFriends::ERR_NONE)
+						return ServiceCallAsyncRespond(cmd, FPResult_RequestFailed);
+					return ServiceCallAsyncRespond(cmd, FPResult_Ok);
+				});
+				return FPResult_Ok;
+			}
 
-						g_fpd.myPresence.joinFlagMask = gameMode->joinFlagMask;
+			nnResult CallHandler_RemoveFriendAsync(FPDClient* fpdClient, IPCIoctlVector* vecIn, uint32 numVecIn, IPCIoctlVector* vecOut, uint32 numVecOut)
+			{
+				std::unique_lock _l(g_fpd.mtxFriendSession);
+				if (numVecIn != 1 || numVecOut != 0)
+					return FPResult_InvalidIPCParam;
+				if (!g_fpd.nexFriendSession)
+					return FPResult_RequestFailed;
+				DeclareInput(pid, uint32be, 0);
+				IPCCommandBody* cmd = ServiceCallDelayCurrentResponse();
+				g_fpd.nexFriendSession->removeFriend(pid, [cmd](NexFriends::RpcErrorCode result){
+					if (result != NexFriends::ERR_NONE)
+						return ServiceCallAsyncRespond(cmd, FPResult_RequestFailed);
+					return ServiceCallAsyncRespond(cmd, FPResult_Ok);
+				});
+				return FPResult_Ok;
+			}
 
-						g_fpd.myPresence.joinAvailability = (uint8)(uint32)gameMode->matchmakeType;
-						g_fpd.myPresence.gameId = gameMode->joinGameId;
-						g_fpd.myPresence.gameMode = gameMode->joinGameMode;
-						g_fpd.myPresence.hostPid = gameMode->hostPid;
-						g_fpd.myPresence.groupId = gameMode->groupId;
-						memcpy(g_fpd.myPresence.appSpecificData, gameMode->appSpecificData, 0x14);
+			nnResult CallHandler_DeleteFriendFlagsAsync(FPDClient* fpdClient, IPCIoctlVector* vecIn, uint32 numVecIn, IPCIoctlVector* vecOut, uint32 numVecOut)
+			{
+				std::unique_lock _l(g_fpd.mtxFriendSession);
+				if (numVecIn != 3 || numVecOut != 0)
+					return FPResult_InvalidIPCParam;
+				if (!g_fpd.nexFriendSession)
+					return FPResult_RequestFailed;
+				DeclareInput(pid, uint32be, 0);
+				cemuLog_logDebug(LogType::Force, "DeleteFriendFlagsAsync is todo");
+				return FPResult_Ok;
+			}
 
-						if (g_fpd.nexFriendSession)
-						{
-							g_fpd.nexFriendSession->updateMyPresence(g_fpd.myPresence);
-						}
-						
-						fpdCemuRequest->returnCode = 0;
-					}
-					else
-						cemu_assert_unimplemented();
+			nnResult CallHandler_CheckSettingStatusAsync(FPDClient* fpdClient, IPCIoctlVector* vecIn, uint32 numVecIn, IPCIoctlVector* vecOut, uint32 numVecOut)
+			{
+				if (numVecIn != 0 || numVecOut != 1)
+					return FPResult_InvalidIPCParam;
+				if (vecOut[0].size != sizeof(uint8be))
+					return FPResult_InvalidIPCParam;
+				if (!g_fpd.nexFriendSession)
+					return FPResult_RequestFailed;
+				IPCCommandBody* cmd = ServiceCallDelayCurrentResponse();
+
+				// for now we respond immediately
+				uint8 settingsStatus = 1; // todo - figure out what this status means
+				auto r = WriteValueOutput<uint8be>(vecOut, settingsStatus);
+				ServiceCallAsyncRespond(cmd, r);
+				cemuLog_log(LogType::Force, "CheckSettingStatusAsync is todo");
+
+				return FPResult_Ok;
+			}
+
+			nnResult CallHandler_IsPreferenceValid(FPDClient* fpdClient, IPCIoctlVector* vecIn, uint32 numVecIn, IPCIoctlVector* vecOut, uint32 numVecOut)
+			{
+				if (numVecIn != 0 || numVecOut != 1)
+					return 0;
+				if (!g_fpd.nexFriendSession)
+					return 0;
+				// we currently automatically put the preferences into a valid state on session creation if they are not set yet
+				return WriteValueOutput<uint32be>(vecOut, 1); // if we return 0, the friend app will show the first time setup screen
+			}
+
+			nnResult CallHandler_GetRequestBlockSettingAsync(FPDClient* fpdClient, IPCIoctlVector* vecIn, uint32 numVecIn, IPCIoctlVector* vecOut, uint32 numVecOut) // todo
+			{
+				if (numVecIn != 2 || numVecOut != 1)
+					return FPResult_InvalidIPCParam;
+				if (!g_fpd.nexFriendSession)
+					return FPResult_RequestFailed;
+				DeclareInput(count, uint32be, 1);
+				DeclareInputPtr(pidList, betype<FriendPID>, count, 0);
+				DeclareOutputPtr(settingList, uint8be, count, 0);
+				cemuLog_log(LogType::Force, "GetRequestBlockSettingAsync is todo");
+
+				for (uint32 i = 0; i < count; i++)
+					settingList[i] = 0;
+				// implementation is todo. Used by friend list app when adding a friend
+				// 0 means not blocked. Friend app will continue with GetBasicInformation()
+				// 1 means blocked. Friend app will continue with AddFriendAsync to add the user as a provisional friend
+
+				return FPResult_Ok;
+			}
+
+			nnResult CallHandler_AddFriendAsyncByPid(FPDClient* fpdClient, IPCIoctlVector* vecIn, uint32 numVecIn, IPCIoctlVector* vecOut, uint32 numVecOut)
+			{
+				if (numVecIn != 1 || numVecOut != 0)
+					return FPResult_InvalidIPCParam;
+				if (!g_fpd.nexFriendSession)
+					return FPResult_RequestFailed;
+				DeclareInput(pid, uint32be, 0);
+				cemuLog_log(LogType::Force, "AddFriendAsyncByPid is todo");
+				return FPResult_Ok;
+			}
+
+			nnResult CallHandler_UpdateGameMode(FPDClient* fpdClient, IPCIoctlVector* vecIn, uint32 numVecIn, IPCIoctlVector* vecOut, uint32 numVecOut)
+			{
+				if (numVecIn != 2 || numVecOut != 0)
+					return FPResult_InvalidIPCParam;
+				if (!g_fpd.nexFriendSession)
+					return FPResult_RequestFailed;
+				DeclareInputPtr(gameMode, iosu::fpd::GameMode, 1, 0);
+				uint32 messageLength = vecIn[1].size / sizeof(uint16be);
+				if(messageLength == 0 || (vecIn[1].size%sizeof(uint16be)) != 0)
+				{
+					cemuLog_log(LogType::Force, "UpdateGameMode: Message must contain at least a null-termination character");
+					return FPResult_InvalidIPCParam;
+				}
+				DeclareInputPtr(gameModeMessage, uint16be, messageLength, 1);
+				messageLength--;
+				GameModeToNexPresence(gameMode, &g_fpd.myPresence);
+				g_fpd.nexFriendSession->updateMyPresence(g_fpd.myPresence);
+				// todo - message
+				return FPResult_Ok;
+			}
+
+			void StartFriendSession()
+			{
+				bool expected = false;
+				if (!g_fpd.sessionStarted.compare_exchange_strong(expected, true))
+					return;
+				cemu_assert(!g_fpd.nexFriendSession);
+				NAPI::AuthInfo authInfo;
+				NAPI::NAPI_MakeAuthInfoFromCurrentAccount(authInfo);
+				NAPI::ACTGetNexTokenResult nexTokenResult = NAPI::ACT_GetNexToken_WithCache(authInfo, 0x0005001010001C00, 0x0000, 0x00003200);
+				if (!nexTokenResult.isValid())
+				{
+					cemuLog_logDebug(LogType::Force, "IOSU_FPD: Failed to acquire nex token for friend server");
+					g_fpd.myPresence.isOnline = 0;
+					return;
+				}
+				// get values needed for friend session
+				uint32 myPid;
+				uint8 currentSlot = iosu::act::getCurrentAccountSlot();
+				iosu::act::getPrincipalId(currentSlot, &myPid);
+				char accountId[256] = { 0 };
+				iosu::act::getAccountId(currentSlot, accountId);
+				FFLData_t miiData;
+				act::getMii(currentSlot, &miiData);
+				uint16 screenName[ACT_NICKNAME_LENGTH + 1] = { 0 };
+				act::getScreenname(currentSlot, screenName);
+				uint32 countryCode = 0;
+				act::getCountryIndex(currentSlot, &countryCode);
+				// init presence
+				g_fpd.myPresence.isOnline = 1;
+				if (GetTitleIdHigh(CafeSystem::GetForegroundTitleId()) == 0x00050000)
+				{
+					g_fpd.myPresence.gameKey.titleId = CafeSystem::GetForegroundTitleId();
+					g_fpd.myPresence.gameKey.ukn = CafeSystem::GetForegroundTitleVersion();
 				}
 				else
-					assert_dbg();
-				iosuIoctl_completeRequest(ioQueueEntry, returnValue);
+				{
+					g_fpd.myPresence.gameKey.titleId = 0; // icon will not be ??? or invalid to others
+					g_fpd.myPresence.gameKey.ukn = 0;
+				}
+				// resolve potential domain to IP address
+				struct addrinfo hints = {0}, *addrs;
+				hints.ai_family = AF_INET;
+				const int status = getaddrinfo(nexTokenResult.nexToken.host, NULL, &hints, &addrs);
+				if (status != 0)
+				{
+					cemuLog_log(LogType::Force, "IOSU_FPD: Failed to resolve hostname {}", nexTokenResult.nexToken.host);
+					return;
+				}
+				char addrstr[NI_MAXHOST];
+				getnameinfo(addrs->ai_addr, addrs->ai_addrlen, addrstr, sizeof addrstr, NULL, 0, NI_NUMERICHOST);
+				cemuLog_log(LogType::Force, "IOSU_FPD: Resolved IP for hostname {}, {}", nexTokenResult.nexToken.host, addrstr);
+				// start session
+				const uint32_t hostIp = ((struct sockaddr_in*)addrs->ai_addr)->sin_addr.s_addr;
+				freeaddrinfo(addrs);
+				g_fpd.mtxFriendSession.lock();
+				g_fpd.nexFriendSession = new NexFriends(hostIp, nexTokenResult.nexToken.port, "ridfebb9", myPid, nexTokenResult.nexToken.nexPassword, nexTokenResult.nexToken.token, accountId, (uint8*)&miiData, (wchar_t*)screenName, (uint8)countryCode, g_fpd.myPresence);
+				g_fpd.nexFriendSession->setNotificationHandler(NotificationHandler);
+				g_fpd.mtxFriendSession.unlock();
+				cemuLog_log(LogType::Force, "IOSU_FPD: Created friend server session");
 			}
-			return;
+
+			void StopFriendSession()
+			{
+				std::unique_lock _l(g_fpd.mtxFriendSession);
+				bool expected = true;
+				if (!g_fpd.sessionStarted.compare_exchange_strong(expected, false) )
+					return;
+				delete g_fpd.nexFriendSession;
+				g_fpd.nexFriendSession = nullptr;
+			}
+
+		  private:
+
+
+		};
+
+		FPDService gFPDService;
+
+		class : public ::IOSUModule
+		{
+			void TitleStart() override
+			{
+				gFPDService.Start();
+				gFPDService.SetTimerUpdate(1000); // call TimerUpdate() once a second
+			}
+			void TitleStop() override
+			{
+				gFPDService.StopFriendSession();
+				gFPDService.Stop();
+			}
+		}sIOSUModuleNNFPD;
+
+		IOSUModule* GetModule()
+		{
+			return static_cast<IOSUModule*>(&sIOSUModuleNNFPD);
 		}
 
-		void Initialize()
-		{
-			if (g_fpd.isThreadStarted)
-				return;
-			std::thread t1(iosuFpd_thread);
-			t1.detach();
-			g_fpd.isThreadStarted = true;
-		}
 	}
-}
\ No newline at end of file
+}
+
diff --git a/src/Cafe/IOSU/legacy/iosu_fpd.h b/src/Cafe/IOSU/legacy/iosu_fpd.h
index bd52035c..b1c30765 100644
--- a/src/Cafe/IOSU/legacy/iosu_fpd.h
+++ b/src/Cafe/IOSU/legacy/iosu_fpd.h
@@ -1,10 +1,12 @@
 #pragma once
+#include "Cafe/IOSU/iosu_types_common.h"
+#include "Common/CafeString.h"
 
 namespace iosu
 {
 	namespace fpd
 	{
-		typedef struct
+		struct FPDDate
 		{
 			/* +0x0 */ uint16be year;
 			/* +0x2 */ uint8 month;
@@ -13,13 +15,61 @@ namespace iosu
 			/* +0x5 */ uint8 minute;
 			/* +0x6 */ uint8 second;
 			/* +0x7 */ uint8 padding;
-		}fpdDate_t;
+		};
 
-		static_assert(sizeof(fpdDate_t) == 8);
+		static_assert(sizeof(FPDDate) == 8);
 
-		typedef struct
+		struct RecentPlayRecordEx
 		{
-			/* +0x000 */ uint8 type; // type(Non-Zero -> Friend, 0 -> Friend request ? )
+			/* +0x00 */ uint32be pid;
+			/* +0x04 */ uint8 ukn04;
+			/* +0x05 */ uint8 ukn05;
+			/* +0x06 */ uint8 ukn06[0x22];
+			/* +0x28 */ uint8 ukn28[0x22];
+			/* +0x4A */ uint8 _uknOrPadding4A[6];
+			/* +0x50 */ uint32be ukn50;
+			/* +0x54 */ uint32be ukn54;
+			/* +0x58 */ uint16be ukn58;
+			/* +0x5C */ uint8 _padding5C[4];
+			/* +0x60 */ iosu::fpd::FPDDate date;
+		};
+
+		static_assert(sizeof(RecentPlayRecordEx) == 0x68, "");
+		static_assert(offsetof(RecentPlayRecordEx, ukn06) == 0x06, "");
+		static_assert(offsetof(RecentPlayRecordEx, ukn50) == 0x50, "");
+
+		struct GameKey
+		{
+			/* +0x00 */ uint64be titleId;
+			/* +0x08 */ uint16be ukn08;
+			/* +0x0A */ uint8 _padding0A[6];
+		};
+		static_assert(sizeof(GameKey) == 0x10);
+
+		struct Profile
+		{
+			uint8be region;
+			uint8be regionSubcode;
+			uint8be platform;
+			uint8be ukn3;
+		};
+		static_assert(sizeof(Profile) == 0x4);
+
+		struct GameMode
+		{
+			/* +0x00 */ uint32be joinFlagMask;
+			/* +0x04 */ uint32be matchmakeType;
+			/* +0x08 */ uint32be joinGameId;
+			/* +0x0C */ uint32be joinGameMode;
+			/* +0x10 */ uint32be hostPid;
+			/* +0x14 */ uint32be groupId;
+			/* +0x18 */ uint8    appSpecificData[0x14];
+		};
+		static_assert(sizeof(GameMode) == 0x2C);
+
+		struct FriendData
+		{
+			/* +0x000 */ uint8 type; // type (Non-Zero -> Friend, 0 -> Friend request ? )
 			/* +0x001 */ uint8 _padding1[7];
 			/* +0x008 */ uint32be pid;
 			/* +0x00C */ char nnid[0x10 + 1];
@@ -29,43 +79,29 @@ namespace iosu
 			/* +0x036 */ uint8 ukn036;
 			/* +0x037 */ uint8 _padding037;
 			/* +0x038 */ uint8 mii[0x60];
-			/* +0x098 */ fpdDate_t uknDate;
+			/* +0x098 */ FPDDate uknDate;
 			// sub struct (the part above seems to be shared with friend requests)
 			union
 			{
 				struct 
 				{
-					/* +0x0A0 */ uint8 ukn0A0; // country code?
-					/* +0x0A1 */ uint8 ukn0A1; // country subcode?
-					/* +0x0A2 */ uint8 _paddingA2[2];
+					/* +0x0A0 */ Profile profile; // this is returned for nn_fp.GetFriendProfile
 					/* +0x0A4 */ uint32be ukn0A4;
-					/* +0x0A8 */ uint64 gameKeyTitleId;
-					/* +0x0B0 */ uint16be gameKeyUkn;
-					/* +0x0B2 */ uint8 _paddingB2[6];
-					/* +0x0B8 */ uint32 ukn0B8;
-					/* +0x0BC */ uint32 ukn0BC;
-					/* +0x0C0 */ uint32 ukn0C0;
-					/* +0x0C4 */ uint32 ukn0C4;
-					/* +0x0C8 */ uint32 ukn0C8;
-					/* +0x0CC */ uint32 ukn0CC;
-					/* +0x0D0 */ uint8  appSpecificData[0x14];
-					/* +0x0E4 */ uint8  ukn0E4;
-					/* +0x0E5 */ uint8  _paddingE5;
-					/* +0x0E6 */ uint16 uknStr[0x80]; // game mode description (could be larger)
-					/* +0x1E6 */ uint8 _padding1E6[0x1EC - 0x1E6];
+					/* +0x0A8 */ GameKey gameKey;
+					/* +0x0B8 */ GameMode gameMode;
+					/* +0x0E4 */ CafeWideString<0x82> gameModeDescription;
+					/* +0x1E8 */ Profile profile1E8; // how does it differ from the one at 0xA0? Returned by GetFriendPresence
 					/* +0x1EC */ uint8 isOnline;
 					/* +0x1ED */ uint8 _padding1ED[3];
 					// some other sub struct?
-					/* +0x1F0 */ uint8 ukn1F0;
-					/* +0x1F1 */ uint8 _padding1F1;
-					/* +0x1F2 */ uint16be statusMessage[16 + 1]; // pops up every few seconds in friend list (ingame character name?)
-					/* +0x214 */ uint8 _padding214[4];
-					/* +0x218 */ fpdDate_t uknDate218;
-					/* +0x220 */ fpdDate_t lastOnline;
+					/* +0x1F0 */ CafeWideString<0x12> comment; // pops up every few seconds in friend list
+					/* +0x214 */ uint32be _padding214;
+					/* +0x218 */ FPDDate approvalTime;
+					/* +0x220 */ FPDDate lastOnline;
 				}friendExtraData;
 				struct 
 				{
-					/* +0x0A0 */ uint64 messageId; // guessed
+					/* +0x0A0 */ uint64be messageId; // guessed. If 0, then relationship is FRIENDSHIP_REQUEST_OUT, otherwise FRIENDSHIP_REQUEST_IN
 					/* +0x0A8 */ uint8 ukn0A8;
 					/* +0x0A9 */ uint8 ukn0A9; // comment language? (guessed)
 					/* +0x0AA */ uint16be comment[0x40];
@@ -75,26 +111,23 @@ namespace iosu
 					/* +0x150 */ uint64 gameKeyTitleId;
 					/* +0x158 */ uint16be gameKeyUkn;
 					/* +0x15A */ uint8 _padding[6];
-					/* +0x160 */ fpdDate_t uknData0;
-					/* +0x168 */ fpdDate_t uknData1;
+					/* +0x160 */ FPDDate uknData0;
+					/* +0x168 */ FPDDate uknData1;
 				}requestExtraData;
 			};
-		}friendData_t;
-
-		static_assert(sizeof(friendData_t) == 0x228, "");
-		static_assert(offsetof(friendData_t, nnid) == 0x00C, "");
-		static_assert(offsetof(friendData_t, friendExtraData.gameKeyTitleId) == 0x0A8, "");
-		static_assert(offsetof(friendData_t, friendExtraData.appSpecificData) == 0x0D0, "");
-		static_assert(offsetof(friendData_t, friendExtraData.uknStr) == 0x0E6, "");
-		static_assert(offsetof(friendData_t, friendExtraData.ukn1F0) == 0x1F0, "");
+		};
+		static_assert(sizeof(FriendData) == 0x228);
+		static_assert(offsetof(FriendData, friendExtraData.gameKey) == 0x0A8);
+		static_assert(offsetof(FriendData, friendExtraData.gameModeDescription) == 0x0E4);
+		static_assert(offsetof(FriendData, friendExtraData.comment) == 0x1F0);
 		
-		static_assert(offsetof(friendData_t, requestExtraData.messageId) == 0x0A0, "");
-		static_assert(offsetof(friendData_t, requestExtraData.comment) == 0x0AA, "");
-		static_assert(offsetof(friendData_t, requestExtraData.uknMessage) == 0x12C, "");
-		static_assert(offsetof(friendData_t, requestExtraData.gameKeyTitleId) == 0x150, "");
-		static_assert(offsetof(friendData_t, requestExtraData.uknData1) == 0x168, "");
+		static_assert(offsetof(FriendData, requestExtraData.messageId) == 0x0A0);
+		static_assert(offsetof(FriendData, requestExtraData.comment) == 0x0AA);
+		static_assert(offsetof(FriendData, requestExtraData.uknMessage) == 0x12C);
+		static_assert(offsetof(FriendData, requestExtraData.gameKeyTitleId) == 0x150);
+		static_assert(offsetof(FriendData, requestExtraData.uknData1) == 0x168);
 
-		typedef struct
+		struct FriendBasicInfo
 		{
 			/* +0x00 */ uint32be pid;
 			/* +0x04 */ char nnid[0x11];
@@ -104,17 +137,17 @@ namespace iosu
 			/* +0x2E */ uint8 ukn2E; // bool option
 			/* +0x2F */ uint8 ukn2F;
 			/* +0x30 */ uint8 miiData[0x60];
-			/* +0x90 */ fpdDate_t uknDate90;
-		}friendBasicInfo_t; // size is 0x98
+			/* +0x90 */ FPDDate uknDate90;
+		};
 
-		static_assert(sizeof(friendBasicInfo_t) == 0x98, "");
-		static_assert(offsetof(friendBasicInfo_t, nnid) == 0x04, "");
-		static_assert(offsetof(friendBasicInfo_t, ukn15) == 0x15, "");
-		static_assert(offsetof(friendBasicInfo_t, screenname) == 0x18, "");
-		static_assert(offsetof(friendBasicInfo_t, ukn2E) == 0x2E, "");
-		static_assert(offsetof(friendBasicInfo_t, miiData) == 0x30, "");
+		static_assert(sizeof(FriendBasicInfo) == 0x98);
+		static_assert(offsetof(FriendBasicInfo, nnid) == 0x04);
+		static_assert(offsetof(FriendBasicInfo, ukn15) == 0x15);
+		static_assert(offsetof(FriendBasicInfo, screenname) == 0x18);
+		static_assert(offsetof(FriendBasicInfo, ukn2E) == 0x2E);
+		static_assert(offsetof(FriendBasicInfo, miiData) == 0x30);
 
-		typedef struct  
+		struct FriendRequest
 		{
 			/* +0x000 */ uint32be pid;
 			/* +0x004 */ uint8 nnid[17]; // guessed type
@@ -125,7 +158,7 @@ namespace iosu
 			/* +0x02E */ uint8 ukn2E; // bool option
 			/* +0x02F */ uint8 ukn2F;  // ukn
 			/* +0x030 */ uint8 miiData[0x60];
-			/* +0x090 */ fpdDate_t uknDate;
+			/* +0x090 */ FPDDate uknDate;
 			/* +0x098 */ uint64 ukn98;
 			/* +0x0A0 */ uint8 isMarkedAsReceived;
 			/* +0x0A1 */ uint8 uknA1;
@@ -136,216 +169,100 @@ namespace iosu
 			/* +0x148 */ uint64 gameKeyTitleId;
 			/* +0x150 */ uint16be gameKeyUkn;
 			/* +0x152 */ uint8 _padding152[6];
-			/* +0x158 */ fpdDate_t uknDate2;
-			/* +0x160 */ fpdDate_t expireDate;
-		}friendRequest_t;
+			/* +0x158 */ FPDDate uknDate2;
+			/* +0x160 */ FPDDate expireDate;
+		};
 
-		static_assert(sizeof(friendRequest_t) == 0x168, "");
-		static_assert(offsetof(friendRequest_t, uknDate) == 0x090, "");
-		static_assert(offsetof(friendRequest_t, message) == 0x0A2, "");
-		static_assert(offsetof(friendRequest_t, uknString2) == 0x124, "");
-		static_assert(offsetof(friendRequest_t, gameKeyTitleId) == 0x148, "");
+		static_assert(sizeof(FriendRequest) == 0x168);
+		static_assert(offsetof(FriendRequest, uknDate) == 0x090);
+		static_assert(offsetof(FriendRequest, message) == 0x0A2);
+		static_assert(offsetof(FriendRequest, uknString2) == 0x124);
+		static_assert(offsetof(FriendRequest, gameKeyTitleId) == 0x148);
 
-		typedef struct
+		struct FriendPresence
 		{
-			/* +0x00 */ uint32be joinFlagMask;
-			/* +0x04 */ uint32be matchmakeType;
-			/* +0x08 */ uint32be joinGameId;
-			/* +0x0C */ uint32be joinGameMode;
-			/* +0x10 */ uint32be hostPid;
-			/* +0x14 */ uint32be groupId;
-			/* +0x18 */ uint8    appSpecificData[0x14];
-		}gameMode_t;
-
-		static_assert(sizeof(gameMode_t) == 0x2C, "");
-
-		typedef struct  
-		{
-			gameMode_t gameMode;
-			/* +0x2C */ uint8    region;
-			/* +0x2D */ uint8    regionSubcode;
-			/* +0x2E */ uint8    platform;
-			/* +0x2F */ uint8    _padding2F;
+			GameMode gameMode;
+			/* +0x2C */ Profile  profile;
 			/* +0x30 */ uint8	 isOnline;
 			/* +0x31 */ uint8    isValid;
 			/* +0x32 */ uint8	 padding[2]; // guessed
-		}friendPresence_t;
+		};
+		static_assert(sizeof(FriendPresence) == 0x34);
+		static_assert(offsetof(FriendPresence, isOnline) == 0x30);
 
-		static_assert(sizeof(friendPresence_t) == 0x34, "");
-		static_assert(offsetof(friendPresence_t, region) == 0x2C, "");
-		static_assert(offsetof(friendPresence_t, isOnline) == 0x30, "");
+		struct FPDNotification
+		{
+			betype<uint32> type;
+			betype<uint32> pid;
+		};
+		static_assert(sizeof(FPDNotification) == 8);
+
+		struct FPDPreference
+		{
+			uint8be showOnline; // show online status to others
+			uint8be showGame; // show played game to others
+			uint8be blockFriendRequests; // block friend requests
+			uint8be ukn; // probably padding?
+		};
+		static_assert(sizeof(FPDPreference) == 4);
 
 		static const int RELATIONSHIP_INVALID = 0;
 		static const int RELATIONSHIP_FRIENDREQUEST_OUT = 1;
 		static const int RELATIONSHIP_FRIENDREQUEST_IN = 2;
 		static const int RELATIONSHIP_FRIEND = 3;
 
-		typedef struct
+		static const int GAMEMODE_MAX_MESSAGE_LENGTH = 0x80; // limit includes null-terminator character, so only 0x7F actual characters can be used
+		static const int MY_COMMENT_LENGTH = 0x12;
+
+		enum class FPD_REQUEST_ID
 		{
-			uint32 requestCode;
-			union
-			{
-				struct  
-				{
-					MEMPTR<void> ptr;
-				}common;
-				struct  
-				{
-					MPTR funcPtr;
-					MPTR custom;
-				}loginAsync;
-				struct  
-				{
-					MEMPTR<uint32be> pidList;
-					uint32 startIndex;
-					uint32 maxCount;
-				}getFriendList;
-				struct
-				{
-					MEMPTR<friendData_t> friendData;
-					MEMPTR<uint32be> pidList;
-					uint32 count;
-				}getFriendListEx;
-				struct
-				{
-					MEMPTR<friendRequest_t> friendRequest;
-					MEMPTR<uint32be> pidList;
-					uint32 count;
-				}getFriendRequestListEx;
-				struct
-				{
-					uint32 pid;
-					MPTR funcPtr;
-					MPTR custom;
-				}addOrRemoveFriend;
-				struct
-				{
-					uint64 messageId;
-					MPTR funcPtr;
-					MPTR custom;
-				}cancelOrAcceptFriendRequest;
-				struct
-				{
-					uint32 pid;
-					MEMPTR<uint16be> message;
-					MPTR funcPtr;
-					MPTR custom;
-				}addFriendRequest;
-				struct
-				{
-					MEMPTR<uint64> messageIdList;
-					uint32 count;
-					MPTR funcPtr;
-					MPTR custom;
-				}markFriendRequest;
-				struct
-				{
-					MEMPTR<friendBasicInfo_t> basicInfo;
-					MEMPTR<uint32be> pidList;
-					sint32 count;
-					MPTR funcPtr;
-					MPTR custom;
-				}getBasicInfo;
-				struct  
-				{
-					uint32 notificationMask;
-					MPTR funcPtr;
-					MPTR custom;
-				}setNotificationHandler;
-				struct  
-				{
-					MEMPTR<char> accountIds;
-					MEMPTR<uint32be> pidList;
-					sint32 count;
-				}getFriendAccountId;
-				struct  
-				{
-					MEMPTR<uint16be> nameList;
-					MEMPTR<uint32be> pidList;
-					sint32 count;
-					bool replaceNonAscii;
-					MEMPTR<uint8> languageList;
-				}getFriendScreenname;
-				struct
-				{
-					uint8* miiList;
-					MEMPTR<uint32be> pidList;
-					sint32 count;
-				}getFriendMii;
-				struct
-				{
-					uint8* presenceList;
-					MEMPTR<uint32be> pidList;
-					sint32 count;
-				}getFriendPresence;
-				struct
-				{
-					uint8* relationshipList;
-					MEMPTR<uint32be> pidList;
-					sint32 count;
-				}getFriendRelationship;
-				struct
-				{
-					MEMPTR<gameMode_t> gameMode;
-					MEMPTR<uint16be> gameModeMessage;
-				}updateGameMode;
-			};
-
-			// output
-			uint32 returnCode; // return value
-			union
-			{
-				struct  
-				{
-					uint32 numReturnedCount;
-				}resultGetFriendList;
-				struct
-				{
-					uint32 u32;
-				}resultU32;
-			};
-		}iosuFpdCemuRequest_t;
-
-		// custom dev/fpd protocol (Cemu only)
-		#define IOSU_FPD_REQUEST_CEMU			(0xEE)
-
-		// FPD request Cemu subcodes
-		enum
-		{
-			_IOSU_FPD_NONE,
-			IOSU_FPD_INITIALIZE,
-			IOSU_FPD_SET_NOTIFICATION_HANDLER,
-			IOSU_FPD_LOGIN_ASYNC,
-			IOSU_FPD_IS_ONLINE,
-			IOSU_FPD_IS_PREFERENCE_VALID,
-
-			IOSU_FPD_UPDATE_GAMEMODE,
-
-			IOSU_FPD_GET_MY_PRINCIPAL_ID,
-			IOSU_FPD_GET_MY_ACCOUNT_ID,
-			IOSU_FPD_GET_MY_MII,
-			IOSU_FPD_GET_MY_SCREENNAME,
-			
-			IOSU_FPD_GET_FRIEND_ACCOUNT_ID,
-			IOSU_FPD_GET_FRIEND_SCREENNAME,
-			IOSU_FPD_GET_FRIEND_MII,
-			IOSU_FPD_GET_FRIEND_PRESENCE,
-			IOSU_FPD_GET_FRIEND_RELATIONSHIP,
-			
-			IOSU_FPD_GET_FRIEND_LIST,
-			IOSU_FPD_GET_FRIENDREQUEST_LIST,
-			IOSU_FPD_GET_FRIEND_LIST_ALL,
-			IOSU_FPD_GET_FRIEND_LIST_EX,
-			IOSU_FPD_GET_FRIENDREQUEST_LIST_EX,
-			IOSU_FPD_ADD_FRIEND,
-			IOSU_FPD_ADD_FRIEND_REQUEST,
-			IOSU_FPD_REMOVE_FRIEND_ASYNC,
-			IOSU_FPD_CANCEL_FRIEND_REQUEST_ASYNC,
-			IOSU_FPD_ACCEPT_FRIEND_REQUEST_ASYNC,
-			IOSU_FPD_MARK_FRIEND_REQUEST_AS_RECEIVED_ASYNC,
-			IOSU_FPD_GET_BASIC_INFO_ASYNC,
+			LoginAsync = 0x2775,
+			HasLoggedIn = 0x2777,
+			IsOnline = 0x2778,
+			GetMyPrincipalId = 0x27D9,
+			GetMyAccountId = 0x27DA,
+			GetMyScreenName = 0x27DB,
+			GetMyMii = 0x27DC,
+			GetMyProfile = 0x27DD,
+			GetMyPreference = 0x27DE,
+			GetMyPresence = 0x27DF,
+			IsPreferenceValid = 0x27E0,
+			GetFriendList = 0x283D,
+			GetFriendListAll = 0x283E,
+			GetFriendAccountId = 0x283F,
+			GetFriendScreenName = 0x2840,
+			GetFriendPresence = 0x2845,
+			GetFriendRelationship = 0x2846,
+			GetFriendMii = 0x2841,
+			GetBlackList = 0x28A1,
+			GetFriendRequestList = 0x2905,
+			UpdateGameModeVariation1 = 0x2969, // there seem to be two different requestIds for the 2-param and 3-param version of UpdateGameMode,
+			UpdateGameModeVariation2 = 0x296A, // but the third parameter is never used and the same handler is used for both
+			AddFriendAsyncByPid = 0x29CD,
+			AddFriendAsyncByXXX = 0x29CE, // probably by name?
+			GetRequestBlockSettingAsync = 0x2B5D,
+			GetMyComment = 0x4EE9,
+			GetMyPlayingGame = 0x4EEA,
+			CheckSettingStatusAsync = 0x7596,
+			GetFriendListEx = 0x75F9,
+			GetFriendRequestListEx = 0x76C1,
+			UpdateCommentAsync = 0x7726,
+			UpdatePreferenceAsync = 0x7727,
+			RemoveFriendAsync = 0x7789,
+			DeleteFriendFlagsAsync = 0x778A,
+			AddFriendRequestByPlayRecordAsync = 0x778B,
+			CancelFriendRequestAsync = 0x778C,
+			AcceptFriendRequestAsync = 0x7851,
+			DeleteFriendRequestAsync = 0x7852,
+			MarkFriendRequestsAsReceivedAsync = 0x7854,
+			GetBasicInfoAsync = 0x7919,
+			SetLedEventMask = 0x9D0B,
+			SetNotificationMask = 0x15ff5,
+			GetNotificationAsync = 0x15FF6,
 		};
 
-		void Initialize();
+		using FriendPID = uint32;
+
+		IOSUModule* GetModule();
 	}
-}
\ No newline at end of file
+}
diff --git a/src/Cafe/IOSU/legacy/iosu_ioctl.cpp b/src/Cafe/IOSU/legacy/iosu_ioctl.cpp
index e81fd018..22e5a55d 100644
--- a/src/Cafe/IOSU/legacy/iosu_ioctl.cpp
+++ b/src/Cafe/IOSU/legacy/iosu_ioctl.cpp
@@ -1,6 +1,5 @@
 #include "Cafe/OS/common/OSCommon.h"
 #include "Cafe/OS/libs/coreinit/coreinit_Thread.h"
-#include "Cafe/OS/libs/coreinit/coreinit.h"
 #include "iosu_ioctl.h"
 #include "util/helpers/ringbuffer.h"
 
@@ -17,13 +16,13 @@ sint32 iosuIoctl_pushAndWait(uint32 ioctlHandle, ioQueueEntry_t* ioQueueEntry)
 {
 	if (ioctlHandle != IOS_DEVICE_ACT && ioctlHandle != IOS_DEVICE_ACP_MAIN && ioctlHandle != IOS_DEVICE_MCP && ioctlHandle != IOS_DEVICE_BOSS && ioctlHandle != IOS_DEVICE_NIM && ioctlHandle != IOS_DEVICE_FPD)
 	{
-		forceLogDebug_printf("Unsupported IOSU device %d", ioctlHandle);
+		cemuLog_logDebug(LogType::Force, "Unsupported IOSU device {}", ioctlHandle);
 		cemu_assert_debug(false);
 		return 0;
 	}
 	__OSLockScheduler();
 	ioctlMutex.lock();
-	ioQueueEntry->ppcThread = coreinitThread_getCurrentThreadDepr(ppcInterpreterCurrentInstance);
+	ioQueueEntry->ppcThread = coreinit::OSGetCurrentThread();
 	
 	_ioctlRingbuffer[ioctlHandle].Push(ioQueueEntry);
 	ioctlMutex.unlock();
diff --git a/src/Cafe/IOSU/legacy/iosu_mcp.cpp b/src/Cafe/IOSU/legacy/iosu_mcp.cpp
index 0b99496a..3108e1f2 100644
--- a/src/Cafe/IOSU/legacy/iosu_mcp.cpp
+++ b/src/Cafe/IOSU/legacy/iosu_mcp.cpp
@@ -53,8 +53,10 @@ namespace iosu
 				std::string titlePath = CafeSystem::GetMlcStoragePath(titleId);
 				strcpy(titleOut.appPath, titlePath.c_str());
 
+				strcpy((char*)titleOut.deviceName, "mlc");
+
 				titleOut.osVersion = 0; // todo
-				titleOut.sdkVersion = 0;
+				titleOut.sdkVersion = it->GetAppSDKVersion();
 			}
 
 			numTitlesCopied++;
@@ -73,7 +75,8 @@ namespace iosu
 	sint32 mcpGetTitleList(MCPTitleInfo* titleList, uint32 titleListBufferSize, uint32be* titleCount)
 	{
 		std::unique_lock _lock(sTitleInfoMutex);
-		*titleCount = mcpBuildTitleList(titleList, *titleCount, [](const TitleInfo& titleInfo) -> bool { return true; });
+		uint32 maxEntryCount = titleListBufferSize / sizeof(MCPTitleInfo);
+		*titleCount = mcpBuildTitleList(titleList, maxEntryCount, [](const TitleInfo& titleInfo) -> bool { return true; });
 		return 0;
 	}
 
@@ -86,7 +89,7 @@ namespace iosu
 	sint32 mcpGetTitleListByAppType(MCPTitleInfo* titleList, uint32 titleListBufferSize, uint32be* titleCount, uint32 appType)
 	{
 		std::unique_lock _lock(sTitleInfoMutex);
-		uint32 maxEntryCount = (uint32)*titleCount;
+		uint32 maxEntryCount = titleListBufferSize / sizeof(MCPTitleInfo);
 		*titleCount = mcpBuildTitleList(titleList, maxEntryCount, [appType](const TitleInfo& titleInfo) -> bool { return titleInfo.GetAppType() == appType; });
 		return 0;
 	}
@@ -94,7 +97,7 @@ namespace iosu
 	sint32 mcpGetTitleListByTitleId(MCPTitleInfo* titleList, uint32 titleListBufferSize, uint32be* titleCount, uint64 titleId)
 	{
 		std::unique_lock _lock(sTitleInfoMutex);
-		uint32 maxEntryCount = (uint32)*titleCount;
+		uint32 maxEntryCount = titleListBufferSize / sizeof(MCPTitleInfo);
 		*titleCount = mcpBuildTitleList(titleList, maxEntryCount, [titleId](const TitleInfo& titleInfo) -> bool { return titleInfo.GetAppTitleId() == titleId; });
 		return 0;
 	}
@@ -143,11 +146,11 @@ namespace iosu
 		return 0;
 	}
 
+    // deprecated
 	void iosuMcp_init()
 	{
 		if (iosuMcp.isInitialized)
 			return;
-		// start the act thread
 		std::thread t(iosuMcp_thread);
 		t.detach();
 		iosuMcp.isInitialized = true;
diff --git a/src/Cafe/IOSU/legacy/iosu_mcp.h b/src/Cafe/IOSU/legacy/iosu_mcp.h
index bca301a4..64e75fdc 100644
--- a/src/Cafe/IOSU/legacy/iosu_mcp.h
+++ b/src/Cafe/IOSU/legacy/iosu_mcp.h
@@ -13,7 +13,8 @@ struct MCPTitleInfo
 	// everything below is uncertain
 	/* +0x4A */ uint64be osVersion; // app.xml
 	/* +0x52 */ uint32be sdkVersion; // app.xml
-	/* +0x56 */ uint8 ukn[0x61 - 0x56];
+	/* +0x56 */ uint8 deviceName[10];
+	/* +0x60 */ uint8 uknPadding; // possibly the index of the device?
 	//move this and the stuff below
 };
 
diff --git a/src/Cafe/IOSU/legacy/iosu_nim.cpp b/src/Cafe/IOSU/legacy/iosu_nim.cpp
index 8d916329..b529640d 100644
--- a/src/Cafe/IOSU/legacy/iosu_nim.cpp
+++ b/src/Cafe/IOSU/legacy/iosu_nim.cpp
@@ -8,11 +8,9 @@
 #include "openssl/x509.h"
 #include "openssl/ssl.h"
 #include "util/helpers/helpers.h"
-
-#include <thread>
-
 #include "Cemu/napi/napi.h"
 #include "Cemu/ncrypto/ncrypto.h"
+#include "Cafe/CafeSystem.h"
 
 namespace iosu
 {
@@ -47,6 +45,13 @@ namespace iosu
 			bool backgroundThreadStarted;
 		} g_nim = {};
 
+		bool nim_CheckDownloadsDisabled()
+		{
+			// currently for the Wii U menu we disable NIM to speed up boot times
+			uint64 tid = CafeSystem::GetForegroundTitleId();
+			return tid == 0x0005001010040000 || tid == 0x0005001010040100 || tid == 0x0005001010040200;
+		}
+
 		bool nim_getLatestVersion()
 		{
 			g_nim.latestVersion = -1;
@@ -58,7 +63,7 @@ namespace iosu
 				return false;
 			if (versionListVersionResult.fqdnURL.size() >= 256)
 			{
-				cemuLog_force("NIM: fqdn URL too long");
+				cemuLog_log(LogType::Force, "NIM: fqdn URL too long");
 				return false;
 			}
 			g_nim.latestVersion = (sint32)versionListVersionResult.version;
@@ -101,6 +106,13 @@ namespace iosu
 
 		void nim_buildDownloadList()
 		{
+			if(nim_CheckDownloadsDisabled())
+			{
+				cemuLog_logDebug(LogType::Force, "nim_buildDownloadList: Downloads are disabled for this title");
+				g_nim.packages.clear();
+				return;
+			}
+
 			sint32 titleCount = mcpGetTitleCount();
 			MCPTitleInfo* titleList = (MCPTitleInfo*)malloc(titleCount * sizeof(MCPTitleInfo));
 			memset(titleList, 0, titleCount * sizeof(MCPTitleInfo));
@@ -108,7 +120,7 @@ namespace iosu
 			uint32be titleCountBE = titleCount;
 			if (mcpGetTitleList(titleList, titleCount * sizeof(MCPTitleInfo), &titleCountBE) != 0)
 			{
-				forceLog_printf("IOSU: nim failed to acquire title list");
+				cemuLog_log(LogType::Force, "IOSU: nim failed to acquire title list");
 				free(titleList);
 				return;
 			}
@@ -141,6 +153,8 @@ namespace iosu
 		void nim_getPackagesInfo(uint64* titleIdList, sint32 count, titlePackageInfo_t* packageInfoList)
 		{
 			memset(packageInfoList, 0, sizeof(titlePackageInfo_t)*count);
+			if(nim_CheckDownloadsDisabled())
+				return;
 			for (sint32 i = 0; i < count; i++)
 			{
 				uint64 titleId = _swapEndianU64(titleIdList[i]);
@@ -214,11 +228,11 @@ namespace iosu
 				}
 			}
 
-			auto result = NAPI::IDBE_Request(titleId);
+			auto result = NAPI::IDBE_Request(ActiveSettings::GetNetworkService(), titleId);
 			if (!result)
 			{
 				memset(idbeIconOutput, 0, sizeof(NAPI::IDBEIconDataV0));
-				forceLog_printf("NIM: Unable to download IDBE icon");
+				cemuLog_log(LogType::Force, "NIM: Unable to download IDBE icon");
 				return 0;
 			}
 			// add new cache entry
@@ -249,7 +263,7 @@ namespace iosu
 		{
 			if (g_nim.backgroundThreadStarted == false)
 			{
-				forceLog_printf("IOSU: Starting nim background thread");
+				cemuLog_log(LogType::Force, "IOSU: Starting nim background thread");
 				std::thread t(nim_backgroundThread);
 				t.detach();
 				g_nim.backgroundThreadStarted = true;
diff --git a/src/Cafe/IOSU/nn/iosu_nn_service.cpp b/src/Cafe/IOSU/nn/iosu_nn_service.cpp
index ade1fa2b..c888b4fb 100644
--- a/src/Cafe/IOSU/nn/iosu_nn_service.cpp
+++ b/src/Cafe/IOSU/nn/iosu_nn_service.cpp
@@ -1,5 +1,6 @@
 #include "iosu_nn_service.h"
 #include "../kernel/iosu_kernel.h"
+#include "util/helpers/helpers.h"
 
 using namespace iosu::kernel;
 
@@ -7,6 +8,132 @@ namespace iosu
 {
 	namespace nn
 	{
+		/* IPCSimpleService */
+		void IPCSimpleService::Start()
+		{
+			if (m_isRunning.exchange(true))
+				return;
+			m_threadInitialized = false;
+			m_requestStop = false;
+			m_serviceThread = std::thread(&IPCSimpleService::ServiceThread, this);
+			while (!m_threadInitialized) std::this_thread::sleep_for(std::chrono::milliseconds(10));
+			StartService();
+		}
+
+		void IPCSimpleService::Stop()
+		{
+			if (!m_isRunning.exchange(false))
+				return;
+			m_requestStop = true;
+			StopService();
+			if(m_timerId != IOSInvalidTimerId)
+				IOS_DestroyTimer(m_timerId);
+			m_timerId = IOSInvalidTimerId;
+			IOS_SendMessage(m_msgQueueId, 0, 0); // wake up thread
+			m_serviceThread.join();
+		}
+
+		void IPCSimpleService::ServiceThread()
+		{
+			if(!GetThreadName().empty())
+				SetThreadName(GetThreadName().c_str());
+			m_msgQueueId = IOS_CreateMessageQueue(_m_msgBuffer.GetPtr(), _m_msgBuffer.GetCount());
+			cemu_assert(!IOS_ResultIsError((IOS_ERROR)m_msgQueueId));
+			IOS_ERROR r = IOS_RegisterResourceManager(m_devicePath.c_str(), m_msgQueueId);
+			cemu_assert(!IOS_ResultIsError(r));
+			m_threadInitialized = true;
+			while (true)
+			{
+				IOSMessage msg;
+				r = IOS_ReceiveMessage(m_msgQueueId, &msg, 0);
+				cemu_assert(!IOS_ResultIsError(r));
+				if (msg == 0)
+				{
+					cemu_assert_debug(m_requestStop);
+					break;
+				}
+				else if(msg == 1)
+				{
+					TimerUpdate();
+					continue;
+				}
+				IPCCommandBody* cmd = MEMPTR<IPCCommandBody>(msg).GetPtr();
+				if (cmd->cmdId == IPCCommandId::IOS_OPEN)
+				{
+					void* clientObject = CreateClientObject();
+					if(clientObject == nullptr)
+					{
+						cemuLog_log(LogType::Force, "IPCSimpleService[{}]: Maximum handle count reached or handle rejected", m_devicePath);
+						IOS_ResourceReply(cmd, IOS_ERROR_MAXIMUM_REACHED);
+						continue;
+					}
+					IOSDevHandle newHandle = GetFreeHandle();
+					m_clientObjects[newHandle] = clientObject;
+					IOS_ResourceReply(cmd, (IOS_ERROR)newHandle);
+					continue;
+				}
+				else if (cmd->cmdId == IPCCommandId::IOS_CLOSE)
+				{
+					void* clientObject = GetClientObjectByHandle(cmd->devHandle);
+					if (clientObject)
+						DestroyClientObject(clientObject);
+					IOS_ResourceReply(cmd, IOS_ERROR_OK);
+					continue;
+				}
+				else if (cmd->cmdId == IPCCommandId::IOS_IOCTLV)
+				{
+					void* clientObject = GetClientObjectByHandle(cmd->devHandle);
+					if (!clientObject)
+					{
+						cemuLog_log(LogType::Force, "IPCSimpleService[{}]: Invalid IPC handle", m_devicePath);
+						IOS_ResourceReply(cmd, IOS_ERROR_INVALID);
+						continue;
+					}
+					uint32 requestId = cmd->args[0];
+					uint32 numIn = cmd->args[1];
+					uint32 numOut = cmd->args[2];
+					IPCIoctlVector* vec = MEMPTR<IPCIoctlVector>{ cmd->args[3] }.GetPtr();
+					IPCIoctlVector* vecIn = vec + 0; // the ordering of vecIn/vecOut differs from IPCService
+					IPCIoctlVector* vecOut = vec + numIn;
+					m_delayResponse = false;
+					m_activeCmd = cmd;
+					uint32 result = ServiceCall(clientObject, requestId, vecIn, numIn, vecOut, numOut);
+					if (!m_delayResponse)
+						IOS_ResourceReply(cmd, (IOS_ERROR)result);
+					m_activeCmd = nullptr;
+					continue;
+				}
+				else
+				{
+					cemuLog_log(LogType::Force, "IPCSimpleService[{}]: Unsupported IPC cmdId {}", m_devicePath, (uint32)cmd->cmdId.value());
+					cemu_assert_unimplemented();
+					IOS_ResourceReply(cmd, IOS_ERROR_INVALID);
+				}
+			}
+			IOS_DestroyMessageQueue(m_msgQueueId);
+			m_threadInitialized = false;
+		}
+
+		void IPCSimpleService::SetTimerUpdate(uint32 milliseconds)
+		{
+			if(m_timerId != IOSInvalidTimerId)
+				IOS_DestroyTimer(m_timerId);
+			m_timerId = IOS_CreateTimer(milliseconds * 1000, milliseconds * 1000, m_msgQueueId, 1);
+		}
+
+		IPCCommandBody* IPCSimpleService::ServiceCallDelayCurrentResponse()
+		{
+			cemu_assert_debug(m_activeCmd);
+			m_delayResponse = true;
+			return m_activeCmd;
+		}
+
+		void IPCSimpleService::ServiceCallAsyncRespond(IPCCommandBody* response, uint32 r)
+		{
+			IOS_ResourceReply(response, (IOS_ERROR)r);
+		}
+
+		/* IPCService */
 		void IPCService::Start()
 		{
 			if (m_isRunning.exchange(true))
@@ -28,6 +155,9 @@ namespace iosu
 
 		void IPCService::ServiceThread()
 		{
+			std::string serviceName = m_devicePath.substr(m_devicePath.find_last_of('/') == std::string::npos ? 0 : m_devicePath.find_last_of('/') + 1);
+			serviceName.insert(0, "NNsvc_");
+			SetThreadName(serviceName.c_str());
 			m_msgQueueId = IOS_CreateMessageQueue(_m_msgBuffer.GetPtr(), _m_msgBuffer.GetCount());
 			cemu_assert(!IOS_ResultIsError((IOS_ERROR)m_msgQueueId));
 			IOS_ERROR r = IOS_RegisterResourceManager(m_devicePath.c_str(), m_msgQueueId);
@@ -80,7 +210,8 @@ namespace iosu
 					IOS_ResourceReply(cmd, IOS_ERROR_INVALID);
 				}
 			}
+			IOS_DestroyMessageQueue(m_msgQueueId);
 			m_threadInitialized = false;
 		}
 	};
-};
\ No newline at end of file
+};
diff --git a/src/Cafe/IOSU/nn/iosu_nn_service.h b/src/Cafe/IOSU/nn/iosu_nn_service.h
index 7f06139f..d7d4cb01 100644
--- a/src/Cafe/IOSU/nn/iosu_nn_service.h
+++ b/src/Cafe/IOSU/nn/iosu_nn_service.h
@@ -8,6 +8,71 @@ namespace iosu
 {
 	namespace nn
 	{
+		// a simple service interface which wraps handle management and Ioctlv/IoctlvAsync (used by /dev/fpd and others are still to be determined)
+		class IPCSimpleService
+		{
+		  public:
+			IPCSimpleService(std::string_view devicePath) : m_devicePath(devicePath) {};
+			virtual ~IPCSimpleService() {};
+
+			virtual void StartService() {};
+			virtual void StopService() {};
+
+			virtual std::string GetThreadName() = 0;
+
+			virtual void* CreateClientObject() = 0;
+			virtual void DestroyClientObject(void* clientObject) = 0;
+			virtual uint32 ServiceCall(void* clientObject, uint32 requestId, IPCIoctlVector* vecIn, uint32 numVecIn, IPCIoctlVector* vecOut, uint32 numVecOut) = 0;
+			virtual void TimerUpdate() {};
+
+			IPCCommandBody* ServiceCallDelayCurrentResponse();
+			static void ServiceCallAsyncRespond(IPCCommandBody* response, uint32 r);
+
+			void Start();
+			void Stop();
+
+			void SetTimerUpdate(uint32 milliseconds);
+
+		  private:
+			void ServiceThread();
+
+			IOSDevHandle GetFreeHandle()
+			{
+				while(m_clientObjects.find(m_nextHandle) != m_clientObjects.end() || m_nextHandle == 0)
+				{
+					m_nextHandle++;
+					m_nextHandle &= 0x7FFFFFFF;
+				}
+				IOSDevHandle newHandle = m_nextHandle;
+				m_nextHandle++;
+				m_nextHandle &= 0x7FFFFFFF;
+				return newHandle;
+			}
+
+			void* GetClientObjectByHandle(IOSDevHandle handle) const
+			{
+				auto it = m_clientObjects.find(handle);
+				if(it == m_clientObjects.end())
+					return nullptr;
+				return it->second;
+			}
+
+			std::string m_devicePath;
+			std::thread m_serviceThread;
+			std::atomic_bool m_requestStop{false};
+			std::atomic_bool m_isRunning{false};
+			std::atomic_bool m_threadInitialized{ false };
+			std::unordered_map<IOSDevHandle, void*> m_clientObjects;
+			IOSDevHandle m_nextHandle{1};
+			IOSTimerId m_timerId{IOSInvalidTimerId};
+
+			IPCCommandBody* m_activeCmd{nullptr};
+			bool m_delayResponse{false};
+
+			IOSMsgQueueId m_msgQueueId;
+			SysAllocator<iosu::kernel::IOSMessage, 128> _m_msgBuffer;
+		};
+
 		struct IPCServiceRequest
 		{
 			uint32be ukn00;
@@ -23,6 +88,7 @@ namespace iosu
 			uint32be nnResultCode;
 		};
 
+		// a complex service interface which wraps Ioctlv and adds an additional service channel, used by /dev/act, /dev/acp_main, ?
 		class IPCService
 		{
 		public:
@@ -60,5 +126,6 @@ namespace iosu
 			IOSMsgQueueId m_msgQueueId;
 			SysAllocator<iosu::kernel::IOSMessage, 128> _m_msgBuffer;
 		};
+
 	};
 };
\ No newline at end of file
diff --git a/src/Cafe/OS/RPL/elf.cpp b/src/Cafe/OS/RPL/elf.cpp
index e4f4218d..7ee3ba47 100644
--- a/src/Cafe/OS/RPL/elf.cpp
+++ b/src/Cafe/OS/RPL/elf.cpp
@@ -50,6 +50,10 @@ typedef struct
 
 static_assert(sizeof(elfSectionEntry_t) == 0x28, "");
 
+#define PF_X		(1 << 0)	/* Segment is executable */
+#define PF_W		(1 << 1)	/* Segment is writable */
+#define PF_R		(1 << 2)	/* Segment is readable */
+
 // Map elf into memory
 uint32 ELF_LoadFromMemory(uint8* elfData, sint32 size, const char* name)
 {
@@ -68,10 +72,11 @@ uint32 ELF_LoadFromMemory(uint8* elfData, sint32 size, const char* name)
 		uint32 shSize = (uint32)sectionTable[i].shSize;
 		uint32 shOffset = (uint32)sectionTable[i].shOffset;
 		uint32 shType = (uint32)sectionTable[i].shType;
+		uint32 shFlags = (uint32)sectionTable[i].shFlags;
 
 		if (shOffset > (uint32)size)
 		{
-			forceLog_printf("ELF section %d out of bounds", i);
+			cemuLog_log(LogType::Force, "ELF section {} out of bounds", i);
 			continue;
 		}
 		uint32 copySize = std::min(shSize, size - shOffset);
@@ -89,6 +94,8 @@ uint32 ELF_LoadFromMemory(uint8* elfData, sint32 size, const char* name)
 			}
 			//  	SHT_NOBITS
 		}
+		if((shFlags & PF_X) > 0)
+			PPCRecompiler_allocateRange(shAddr, shSize);
 	}
 	return header->entrypoint;
 }
@@ -126,4 +133,4 @@ uint32 ELF_LoadFromMemory(uint8* elfData, sint32 size, const char* name)
 //	unsigned int addr_sgIsLoadingBuffer;
 //	unsigned int addr_gDynloadInitialized;
 //	unsigned int orig_LiWaitOneChunkInstr;
-//} OsSpecifics;
\ No newline at end of file
+//} OsSpecifics;
diff --git a/src/Cafe/OS/RPL/rpl.cpp b/src/Cafe/OS/RPL/rpl.cpp
index 90f9225b..f0703290 100644
--- a/src/Cafe/OS/RPL/rpl.cpp
+++ b/src/Cafe/OS/RPL/rpl.cpp
@@ -39,20 +39,22 @@ VHeap rplLoaderHeap_workarea(nullptr, MEMORY_RPLLOADER_AREA_SIZE);
 PPCCodeHeap rplLoaderHeap_lowerAreaCodeMem2(nullptr, MEMORY_CODE_TRAMPOLINE_AREA_SIZE);
 PPCCodeHeap rplLoaderHeap_codeArea2(nullptr, MEMORY_CODEAREA_SIZE);
 
-bool rplLoader_applicationHasMemoryControl = false;
-uint32 rplLoader_maxCodeAddress = 0; // highest used code address
-
 ChunkedFlatAllocator<64 * 1024> g_heapTrampolineArea;
 
-std::vector<rplDependency_t*> rplDependencyList = std::vector<rplDependency_t*>();
+std::vector<RPLDependency*> rplDependencyList;
 
 RPLModule* rplModuleList[256];
 sint32 rplModuleCount = 0;
 
-uint32 _currentTLSModuleIndex = 1; // value 0 is reserved
-
+bool rplLoader_applicationHasMemoryControl = false;
+uint32 rplLoader_maxCodeAddress = 0; // highest used code address
+uint32 rplLoader_currentTLSModuleIndex = 1; // value 0 is reserved
+uint32 rplLoader_currentHandleCounter = 0x00001000;
+sint16 rplLoader_currentTlsModuleIndex = 0x0001;
+RPLModule* rplLoader_mainModule = nullptr;
 uint32 rplLoader_sdataAddr = MPTR_NULL; // r13
 uint32 rplLoader_sdata2Addr = MPTR_NULL; // r2
+uint32 rplLoader_currentDataAllocatorAddr = 0x10000000;
 
 std::map<void(*)(PPCInterpreter_t* hCPU), uint32> g_map_callableExports;
 
@@ -76,13 +78,6 @@ struct RPLRegionMappingTable
 void RPLLoader_UnloadModule(RPLModule* rpl);
 void RPLLoader_RemoveDependency(const char* name);
 
-char _ansiToLower(char c)
-{
-	if (c >= 'A' && c <= 'Z')
-		c -= ('A' - 'a');
-	return c;
-}
-
 uint8* RPLLoader_AllocateTrampolineCodeSpace(RPLModule* rplLoaderContext, sint32 size)
 {	
 	if (rplLoaderContext)
@@ -110,8 +105,6 @@ MPTR RPLLoader_AllocateCodeSpace(uint32 size, uint32 alignment)
 	return codeAddr;
 }
 
-uint32 rpl3_currentDataAllocatorAddr = 0x10000000;
-
 uint32 RPLLoader_AllocateDataSpace(RPLModule* rpl, uint32 size, uint32 alignment)
 {
 	if (rplLoader_applicationHasMemoryControl)
@@ -121,9 +114,9 @@ uint32 RPLLoader_AllocateDataSpace(RPLModule* rpl, uint32 size, uint32 alignment
 		PPCCoreCallback(rpl->funcAlloc.value(), size, alignment, memPtr.GetPointer());
 		return (uint32)*(memPtr.GetPointer());
 	}
-	rpl3_currentDataAllocatorAddr = (rpl3_currentDataAllocatorAddr + alignment - 1)&~(alignment-1);
-	uint32 mem = rpl3_currentDataAllocatorAddr;
-	rpl3_currentDataAllocatorAddr += size;
+	rplLoader_currentDataAllocatorAddr = (rplLoader_currentDataAllocatorAddr + alignment - 1) & ~(alignment - 1);
+	uint32 mem = rplLoader_currentDataAllocatorAddr;
+	rplLoader_currentDataAllocatorAddr += size;
 	return mem;
 }
 
@@ -134,7 +127,7 @@ void RPLLoader_FreeData(RPLModule* rpl, void* ptr)
 
 uint32 RPLLoader_GetDataAllocatorAddr()
 {
-	return (rpl3_currentDataAllocatorAddr + 0xFFF)&(~0xFFF);
+	return (rplLoader_currentDataAllocatorAddr + 0xFFF) & (~0xFFF);
 }
 
 uint32 RPLLoader_GetMaxCodeOffset()
@@ -217,7 +210,6 @@ bool RPLLoader_ProcessHeaders(std::string_view moduleName, uint8* rplData, uint3
 	// setup RPL info struct
 	RPLModule* rplLoaderContext = new RPLModule();
 	rplLoaderContext->RPLRawData = std::span<uint8>(rplData, rplSize);
-	rplLoaderContext->rplData_depr = rplData;
 	rplLoaderContext->heapTrampolineArea.setBaseAllocator(&rplLoaderHeap_lowerAreaCodeMem2);
 	// load section table
 	if ((uint32)rplHeader->sectionTableEntrySize != sizeof(rplSectionEntryNew_t))
@@ -232,18 +224,19 @@ bool RPLLoader_ProcessHeaders(std::string_view moduleName, uint8* rplData, uint3
 	rplSectionEntryNew_t* fileinfoSection = rplLoaderContext->sectionTablePtr + ((uint32)rplLoaderContext->rplHeader.sectionTableEntryCount - 1);
 	if (fileinfoSection->fileOffset == 0 || (uint32)fileinfoSection->fileOffset >= rplSize || (uint32)fileinfoSection->type != SHT_RPL_FILEINFO)
 	{
-		forceLogDebug_printf("RPLLoader: Last section not FILEINFO");
+		cemuLog_logDebug(LogType::Force, "RPLLoader: Last section not FILEINFO");
 	}
 	// verify that section n-2 is CRCs
 	rplSectionEntryNew_t* crcSection = rplLoaderContext->sectionTablePtr + ((uint32)rplLoaderContext->rplHeader.sectionTableEntryCount - 2);
 	if (crcSection->fileOffset == 0 || (uint32)crcSection->fileOffset >= rplSize || (uint32)crcSection->type != SHT_RPL_CRCS)
 	{
-		forceLogDebug_printf("RPLLoader: The section before FILEINFO must be CRCs");
+		cemuLog_logDebug(LogType::Force, "RPLLoader: The section before FILEINFO must be CRCs");
 	}
 	// load FILEINFO section
 	if (fileinfoSection->sectionSize < sizeof(RPLFileInfoData))
 	{
-		cemuLog_force("RPLLoader: FILEINFO section size is below expected size");
+		cemuLog_log(LogType::Force, "RPLLoader: FILEINFO section size is below expected size");
+		delete rplLoaderContext;
 		return false;
 	}
 
@@ -251,7 +244,7 @@ bool RPLLoader_ProcessHeaders(std::string_view moduleName, uint8* rplData, uint3
 	uint8* fileInfoRawPtr = (uint8*)(rplData + fileinfoSection->fileOffset);
 	if (((uint64)fileinfoSection->fileOffset+fileinfoSection->sectionSize) > (uint64)rplSize)
 	{
-		cemuLog_force("RPLLoader: FILEINFO section outside of RPL file bounds");
+		cemuLog_log(LogType::Force, "RPLLoader: FILEINFO section outside of RPL file bounds");
 		return false;
 	}
 	rplLoaderContext->sectionData_fileInfo.resize(fileinfoSection->sectionSize);
@@ -260,7 +253,7 @@ bool RPLLoader_ProcessHeaders(std::string_view moduleName, uint8* rplData, uint3
 	RPLFileInfoData* fileInfoPtr = (RPLFileInfoData*)rplLoaderContext->sectionData_fileInfo.data();
 	if (fileInfoPtr->fileInfoMagic != 0xCAFE0402)
 	{
-		cemuLog_force("RPLLoader: Invalid FILEINFO magic");
+		cemuLog_log(LogType::Force, "RPLLoader: Invalid FILEINFO magic");
 		return false;
 	}
 
@@ -282,27 +275,21 @@ bool RPLLoader_ProcessHeaders(std::string_view moduleName, uint8* rplData, uint3
 	// convert modulename to lower-case
 	for(auto& c : rplLoaderContext->moduleName2)
 		c = _ansiToLower(c);
-	// cemuhook compatibility
-	rplLoaderContext->moduleNamePtr__depr = rplLoaderContext->moduleName2.data();
-	rplLoaderContext->moduleNameLength__depr = rplLoaderContext->moduleName2.size();
-	rplLoaderContext->moduleNameSize = 0;
-	rplLoaderContext->sectionAddressTable__depr = rplLoaderContext->sectionAddressTable2.data();
-	rplLoaderContext->sectionAddressTableSize__depr = rplLoaderContext->sectionAddressTable2.size() * sizeof(rplSectionAddressEntry_t);
 
 	// load CRC section
 	uint32 crcTableExpectedSize = sectionCount * sizeof(uint32be);
 	if (!RPLLoader_CheckBounds(rplLoaderContext, crcSection->fileOffset, crcTableExpectedSize))
 	{
-		cemuLog_force("RPLLoader: CRC section outside of RPL file bounds");
+		cemuLog_log(LogType::Force, "RPLLoader: CRC section outside of RPL file bounds");
 		crcSection->sectionSize = 0;
 	}
 	else if (crcSection->sectionSize < crcTableExpectedSize)
 	{
-		cemuLog_force("RPLLoader: CRC section size (0x{:x}) less than required (0x{:x})", (uint32)crcSection->sectionSize, crcTableExpectedSize);
+		cemuLog_log(LogType::Force, "RPLLoader: CRC section size (0x{:x}) less than required (0x{:x})", (uint32)crcSection->sectionSize, crcTableExpectedSize);
 	}
 	else if (crcSection->sectionSize != crcTableExpectedSize)
 	{
-		cemuLog_force("RPLLoader: CRC section size (0x{:x}) does not match expected size (0x{:x})", (uint32)crcSection->sectionSize, crcTableExpectedSize);
+		cemuLog_log(LogType::Force, "RPLLoader: CRC section size (0x{:x}) does not match expected size (0x{:x})", (uint32)crcSection->sectionSize, crcTableExpectedSize);
 	}
 
 	uint32 crcActualSectionCount = crcSection->sectionSize / sizeof(uint32); // how many CRCs are actually stored
@@ -320,7 +307,7 @@ bool RPLLoader_ProcessHeaders(std::string_view moduleName, uint8* rplData, uint3
 	uint32 crcFileinfo = rplLoaderContext->GetSectionCRC(sectionCount - 1);
 	if (crcCalcFileinfo != crcFileinfo)
 	{
-		cemuLog_force("RPLLoader: FILEINFO section has CRC mismatch - Calculated: {:08x} Actual: {:08x}", crcCalcFileinfo, crcFileinfo);
+		cemuLog_log(LogType::Force, "RPLLoader: FILEINFO section has CRC mismatch - Calculated: {:08x} Actual: {:08x}", crcCalcFileinfo, crcFileinfo);
 	}
 
 	rplLoaderContext->sectionAddressTable2[sectionCount - 1].ptr = rplLoaderContext->sectionData_fileInfo.data();
@@ -342,7 +329,7 @@ rplSectionEntryNew_t* RPLLoader_GetSection(RPLModule* rplLoaderContext, sint32 s
 	sint32 sectionCount = rplLoaderContext->rplHeader.sectionTableEntryCount;
 	if (sectionIndex < 0 || sectionIndex >= sectionCount)
 	{
-		forceLog_printf("RPLLoader: Section index out of bounds");
+		cemuLog_log(LogType::Force, "RPLLoader: Section index out of bounds");
 		rplLoaderContext->hasError = true;
 		return nullptr;
 	}
@@ -369,7 +356,7 @@ RPLUncompressedSection* RPLLoader_LoadUncompressedSection(RPLModule* rplLoaderCo
 	if (!RPLLoader_CheckBounds(rplLoaderContext, section->fileOffset, section->sectionSize))
 	{
 		// BSS
-		forceLog_printf("RPLLoader: Raw data for section %d exceeds bounds of RPL file", sectionIndex);
+		cemuLog_log(LogType::Force, "RPLLoader: Raw data for section {} exceeds bounds of RPL file", sectionIndex);
 		rplLoaderContext->hasError = true;
 		delete uSection;
 		return nullptr;
@@ -381,7 +368,7 @@ RPLUncompressedSection* RPLLoader_LoadUncompressedSection(RPLModule* rplLoaderCo
 		// decompress
 		if (!RPLLoader_CheckBounds(rplLoaderContext, section->fileOffset, sizeof(uint32be)) )
 		{
-			forceLog_printf("RPLLoader: Uncompressed data of section %d is too large", sectionIndex);
+			cemuLog_log(LogType::Force, "RPLLoader: Uncompressed data of section {} is too large", sectionIndex);
 			rplLoaderContext->hasError = true;
 			delete uSection;
 			return nullptr;
@@ -389,7 +376,7 @@ RPLUncompressedSection* RPLLoader_LoadUncompressedSection(RPLModule* rplLoaderCo
 		uint32 uncompressedSize = *(uint32be*)(rplLoaderContext->RPLRawData.data() + (uint32)section->fileOffset);
 		if (uncompressedSize >= 1*1024*1024*1024) // sections bigger than 1GB not allowed
 		{
-			forceLog_printf("RPLLoader: Uncompressed data of section %d is too large", sectionIndex);
+			cemuLog_log(LogType::Force, "RPLLoader: Uncompressed data of section {} is too large", sectionIndex);
 			rplLoaderContext->hasError = true;
 			delete uSection;
 			return nullptr;
@@ -411,7 +398,7 @@ RPLUncompressedSection* RPLLoader_LoadUncompressedSection(RPLModule* rplLoaderCo
 			inflateEnd(&strm);
 			if ((ret != Z_OK && ret != Z_STREAM_END) || strm.avail_in != 0 || strm.avail_out != 0)
 			{
-				forceLog_printf("RPLLoader: Error while inflating data for section %d", sectionIndex);
+				cemuLog_log(LogType::Force, "RPLLoader: Error while inflating data for section {}", sectionIndex);
 				rplLoaderContext->hasError = true;
 				delete uSection;
 				return nullptr;
@@ -436,7 +423,7 @@ bool RPLLoader_LoadSingleSection(RPLModule* rplLoaderContext, sint32 sectionInde
 
 	uint32 mappingOffset = (uint32)section->virtualAddress - (uint32)regionMappingInfo->baseAddress;
 	if (mappingOffset >= 0x10000000)
-		forceLogDebug_printf("Suspicious section mapping offset: 0x%08x", mappingOffset);
+		cemuLog_logDebug(LogType::Force, "Suspicious section mapping offset: 0x{:08x}", mappingOffset);
 	uint32 sectionAddress = mappedAddress + mappingOffset;
 
 	rplLoaderContext->sectionAddressTable2[sectionIndex].ptr = memory_getPointerFromVirtualOffset(sectionAddress);
@@ -454,13 +441,13 @@ bool RPLLoader_LoadSingleSection(RPLModule* rplLoaderContext, sint32 sectionInde
 
 	// copy to mapped address
 	if(section->virtualAddress < regionMappingInfo->baseAddress || (section->virtualAddress + uncompressedSection->sectionData.size()) > regionMappingInfo->endAddress)
-		cemuLog_force("RPLLoader: Section {} (0x{:08x} to 0x{:08x}) is not fully contained in it's bounding region (0x{:08x} to 0x{:08x})", sectionIndex, section->virtualAddress, section->virtualAddress + uncompressedSection->sectionData.size(), regionMappingInfo->baseAddress, regionMappingInfo->endAddress);
+		cemuLog_log(LogType::Force, "RPLLoader: Section {} (0x{:08x} to 0x{:08x}) is not fully contained in it's bounding region (0x{:08x} to 0x{:08x})", sectionIndex, section->virtualAddress, section->virtualAddress + uncompressedSection->sectionData.size(), regionMappingInfo->baseAddress, regionMappingInfo->endAddress);
 	uint8* sectionAddressPtr = memory_getPointerFromVirtualOffset(sectionAddress);
 	std::copy(uncompressedSection->sectionData.begin(), uncompressedSection->sectionData.end(), sectionAddressPtr);
 
 	// update size in section (todo - use separate field)
 	if (uncompressedSection->sectionData.size() < section->sectionSize)
-		forceLog_printf("RPLLoader: Section %d uncompresses to %d bytes but sectionSize is %d", sectionIndex, uncompressedSection->sectionData.size(), (uint32)section->sectionSize);
+		cemuLog_log(LogType::Force, "RPLLoader: Section {} uncompresses to {} bytes but sectionSize is {}", sectionIndex, uncompressedSection->sectionData.size(), (uint32)section->sectionSize);
 
 	section->sectionSize = uncompressedSection->sectionData.size();
 
@@ -618,7 +605,7 @@ bool RPLLoader_LoadSections(sint32 aProcId, RPLModule* rplLoaderContext)
 
 		if (section->type == 0x8)
 		{
-			cemuLog_force("RPLLoader: Unsupported text section type 0x8");
+			cemuLog_log(LogType::Force, "RPLLoader: Unsupported text section type 0x8");
 			cemu_assert_debug(false);
 		}
 
@@ -737,10 +724,10 @@ uint32 RPLLoader_MakePPCCallable(void(*ppcCallableExport)(PPCInterpreter_t* hCPU
 	if (it != g_map_callableExports.end())
 		return it->second;
 	// get HLE function index
-	sint32 functionIndex = PPCInterpreter_registerHLECall(ppcCallableExport);
+	sint32 functionIndex = PPCInterpreter_registerHLECall(ppcCallableExport, fmt::format("PPCCallback{:x}", (uintptr_t)ppcCallableExport));
 	MPTR codeAddr = memory_getVirtualOffsetFromPointer(RPLLoader_AllocateTrampolineCodeSpace(4));
 	uint32 opcode = (1 << 26) | functionIndex;
-	memory_writeU32Direct(codeAddr, opcode);
+	memory_write<uint32>(codeAddr, opcode);
 	g_map_callableExports[ppcCallableExport] = codeAddr;
 	return codeAddr;
 }
@@ -778,7 +765,7 @@ uint32 rpl_mapHLEImport(RPLModule* rplLoaderContext, const char* rplName, const
 	{
 		MPTR codeAddr = memory_getVirtualOffsetFromPointer(RPLLoader_AllocateTrampolineCodeSpace(4));
 		uint32 opcode = (1 << 26) | functionIndex;
-		memory_writeU32Direct(codeAddr, opcode);
+		memory_write<uint32>(codeAddr, opcode);
 		// register mapped import
 		mappedFunctionImport_t newImport;
 		newImport.hash1 = mappedImportHash1;
@@ -798,8 +785,8 @@ uint32 rpl_mapHLEImport(RPLModule* rplLoaderContext, const char* rplName, const
 	uint32 codeStart = memory_getVirtualOffsetFromPointer(RPLLoader_AllocateTrampolineCodeSpace(256));
 	uint32 currentAddress = codeStart;
 	uint32 opcode = (1 << 26) | (0xFFD0); // opcode for HLE: Unsupported import
-	memory_writeU32Direct(codeStart + 0, opcode);
-	memory_writeU32Direct(codeStart + 4, 0x4E800020);
+	memory_write<uint32>(codeStart + 0, opcode);
+	memory_write<uint32>(codeStart + 4, 0x4E800020);
 	currentAddress += 8;
 	// write name of lib/function
 	sint32 libNameLength = std::min(128, (sint32)strlen(libName));
@@ -937,7 +924,7 @@ bool RPLLoader_FixImportSymbols(RPLModule* rplLoaderContext, sint32 symtabSectio
 		
 		if (symSectionIndex >= sharedImportTracking.size())
 		{
-			cemuLog_force("RPL-Loader: Symbol {} references invalid section", i);
+			cemuLog_log(LogType::Force, "RPL-Loader: Symbol {} references invalid section", i);
 		}
 		else if (sharedImportTracking[symSectionIndex].rplLoaderContext != nullptr)
 		{
@@ -962,7 +949,7 @@ bool RPLLoader_FixImportSymbols(RPLModule* rplLoaderContext, sint32 symtabSectio
 				char* symbolName = (char*)strtabData + nameOffset;
 				if (nameOffset >= strtabSize)
 				{
-					forceLog_printf("RPLLoader: Symbol %d in section %d has out-of-bounds name offset", i, symSectionIndex);
+					cemuLog_log(LogType::Force, "RPLLoader: Symbol {} in section {} has out-of-bounds name offset", i, symSectionIndex);
 					continue;
 				}
 
@@ -1021,10 +1008,10 @@ bool RPLLoader_FixImportSymbols(RPLModule* rplLoaderContext, sint32 symtabSectio
 				}
 				if (foundExport == false)
 				{
-#ifndef PUBLIC_RELEASE
+#ifdef CEMU_DEBUG_ASSERT
 					if (nameOffset > 0)
 					{
-						forceLogDebug_printf("export not found - force lookup in function exports");
+						cemuLog_logDebug(LogType::Force, "export not found - force lookup in function exports");
 						// workaround - force look up export in function exports
 						char* exportNameData = (char*)((uint8*)ctxExportModule->exportFDataPtr - 8);
 						for (uint32 f = 0; f < ctxExportModule->exportFCount; f++)
@@ -1110,7 +1097,7 @@ bool RPLLoader_ApplySingleReloc(RPLModule* rplLoaderContext, uint32 uknR3, uint8
 		{
 			// within range, update jump opcode
 			if ((jumpDistance & 3) != 0)
-				cemuLog_force("RPL-Loader: Encountered unaligned RPL_RELOC_REL24");
+				cemuLog_log(LogType::Force, "RPL-Loader: Encountered unaligned RPL_RELOC_REL24");
 			opc &= ~0x03fffffc;
 			opc |= (jumpDistance &0x03fffffc);
 			*(uint32be*)relocAddr = opc;
@@ -1131,7 +1118,7 @@ bool RPLLoader_ApplySingleReloc(RPLModule* rplLoaderContext, uint32 uknR3, uint8
 		{
 			// within range, update jump opcode
 			if ((jumpDistance & 3) != 0)
-				cemuLog_force("RPL-Loader: Encountered unaligned RPL_RELOC_REL14");
+				cemuLog_log(LogType::Force, "RPL-Loader: Encountered unaligned RPL_RELOC_REL14");
 			opc &= ~0xfffc;
 			opc |= (jumpDistance & 0xfffc);
 			*(uint32be*)relocAddr = opc;
@@ -1196,7 +1183,7 @@ bool RPLLoader_ApplySingleReloc(RPLModule* rplLoaderContext, uint32 uknR3, uint8
 		}
 		else
 		{
-			cemuLog_force("RPLLoader: sdata reloc uses register other than r2/r13");
+			cemuLog_log(LogType::Force, "RPLLoader: sdata reloc uses register other than r2/r13");
 			cemu_assert(false);
 		}
 	}
@@ -1230,7 +1217,7 @@ bool RPLLoader_ApplySingleReloc(RPLModule* rplLoaderContext, uint32 uknR3, uint8
 	}
 	else
 	{
-		cemuLog_force("RPLLoader: Unsupported reloc type 0x{:02x}", relocType);
+		cemuLog_log(LogType::Force, "RPLLoader: Unsupported reloc type 0x{:02x}", relocType);
 		cemu_assert_debug(false); // unknown reloc type
 	}
 	return true;
@@ -1293,7 +1280,7 @@ bool RPLLoader_ApplyRelocs(RPLModule* rplLoaderContext, sint32 relaSectionIndex,
 	uint32 crc = rplLoaderContext->GetSectionCRC(relaSectionIndex);
 	if (calcCRC != crc)
 	{
-		forceLog_printf("RPLLoader %s - Relocation section %d has CRC mismatch - Calc: %08x Actual: %08x", rplLoaderContext->moduleName2.c_str(), relaSectionIndex, calcCRC, crc);
+		cemuLog_log(LogType::Force, "RPLLoader {} - Relocation section {} has CRC mismatch - Calc: {:08x} Actual: {:08x}", rplLoaderContext->moduleName2.c_str(), relaSectionIndex, calcCRC, crc);
 	}
 	// process relocations
 	sint32 relocCount = relocSize / sizeof(rplRelocNew_t);
@@ -1310,7 +1297,7 @@ bool RPLLoader_ApplyRelocs(RPLModule* rplLoaderContext, sint32 relaSectionIndex,
 		}
 		if (relocSymbolIndex >= symbolCount)
 		{
-			forceLogDebug_printf("reloc with symbol index out of range 0x%04x", (uint32)relocSymbolIndex);
+			cemuLog_logDebug(LogType::Force, "reloc with symbol index out of range 0x{:04x}", (uint32)relocSymbolIndex);
 			reloc++;
 			continue;
 		}
@@ -1319,7 +1306,7 @@ bool RPLLoader_ApplyRelocs(RPLModule* rplLoaderContext, sint32 relaSectionIndex,
 
 		if ((uint32)sym->sectionIndex >= (uint32)rplLoaderContext->rplHeader.sectionTableEntryCount)
 		{
-			forceLogDebug_printf("reloc with sectionIndex out of range 0x%04x", (uint32)sym->sectionIndex);
+			cemuLog_logDebug(LogType::Force, "reloc with sectionIndex out of range 0x{:04x}", (uint32)sym->sectionIndex);
 			reloc++;
 			continue;
 		}
@@ -1350,7 +1337,7 @@ bool RPLLoader_ApplyRelocs(RPLModule* rplLoaderContext, sint32 relaSectionIndex,
 				assert_dbg(); // not a TLS symbol
 			if (rplLoaderContext->fileInfo.tlsModuleIndex == -1)
 			{
-				cemuLog_force("RPLLoader: TLS relocs applied to non-TLS module");
+				cemuLog_log(LogType::Force, "RPLLoader: TLS relocs applied to non-TLS module");
 				cemu_assert_debug(false); // module not a TLS-module
 			}
 			tlsModuleIndex = rplLoaderContext->fileInfo.tlsModuleIndex;
@@ -1391,12 +1378,11 @@ bool RPLLoader_HandleRelocs(RPLModule* rplLoaderContext, std::span<RPLSharedImpo
 	return true;
 }
 
-void _RPLLoader_ExtractModuleNameFromPath(char* output, const char* input)
+void _RPLLoader_ExtractModuleNameFromPath(char* output, std::string_view input)
 {
 	// scan to last '/'
-	sint32 inputLen = (sint32)strlen(input);
-	cemu_assert(inputLen > 0);
-	sint32 startIndex = inputLen - 1;
+	cemu_assert(!input.empty());
+	size_t startIndex = input.size() - 1;
 	while (startIndex > 0)
 	{
 		if (input[startIndex] == '/')
@@ -1407,23 +1393,20 @@ void _RPLLoader_ExtractModuleNameFromPath(char* output, const char* input)
 		startIndex--;
 	}
 	// cut off after '.'
-	sint32 endIndex = startIndex;
-	while (endIndex <= inputLen)
+	size_t endIndex = startIndex;
+	while (endIndex < input.size())
 	{
 		if (input[endIndex] == '.')
 			break;
 		endIndex++;
 	}
-	sint32 nameLen = endIndex - startIndex;
+	size_t nameLen = endIndex - startIndex;
 	cemu_assert(nameLen != 0);
-	nameLen = std::min(nameLen, RPL_MODULE_NAME_LENGTH-1);
-	memcpy(output, input + startIndex, nameLen);
+	nameLen = std::min<size_t>(nameLen, RPL_MODULE_NAME_LENGTH-1);
+	memcpy(output, input.data() + startIndex, nameLen);
 	output[nameLen] = '\0';
 	// convert to lower case
-	for (sint32 i = 0; i < nameLen; i++)
-	{
-		output[i] = _ansiToLower(output[i]);
-	}
+	std::for_each(output, output + nameLen, [](char& c) {c = _ansiToLower(c);});
 }
 
 void RPLLoader_InitState()
@@ -1435,30 +1418,7 @@ void RPLLoader_InitState()
 	rplLoaderHeap_codeArea2.setHeapBase(memory_getPointerFromVirtualOffset(MEMORY_CODEAREA_ADDR));
 	rplLoaderHeap_workarea.setHeapBase(memory_getPointerFromVirtualOffset(MEMORY_RPLLOADER_AREA_ADDR));
 	g_heapTrampolineArea.setBaseAllocator(&rplLoaderHeap_lowerAreaCodeMem2);
-}
-
-void RPLLoader_ResetState()
-{
-	// unload all RPL modules
-	while (rplModuleCount > 0)
-		RPLLoader_UnloadModule(rplModuleList[0]);
-	// clear dependency list
-	cemu_assert_debug(false);
-	// unload all remaining symbols
-	rplSymbolStorage_unloadAll();
-	// free all code imports
-	g_heapTrampolineArea.releaseAll();
-	list_mappedFunctionImports.clear();
-	g_map_callableExports.clear();
-
-	rplLoader_applicationHasMemoryControl = false;
-	rplLoader_maxCodeAddress = 0;
-	rpl3_currentDataAllocatorAddr = 0x10000000;
-	cemu_assert_debug(rplDependencyList.empty());
-	rplDependencyList.clear();
-	_currentTLSModuleIndex = 1;
-	rplLoader_sdataAddr = MPTR_NULL;
-	rplLoader_sdata2Addr = MPTR_NULL;
+    RPLLoader_ResetState();
 }
 
 void RPLLoader_BeginCemuhookCRC(RPLModule* rpl)
@@ -1509,14 +1469,14 @@ void RPLLoader_BeginCemuhookCRC(RPLModule* rpl)
 			rawSize = decompressedSize;
 			if (rawSize >= 1024*1024*1024)
 			{
-				forceLogDebug_printf("RPLLoader-CRC: Cannot load section %d which is too large (%u bytes)", i, decompressedSize);
+				cemuLog_logDebug(LogType::Force, "RPLLoader-CRC: Cannot load section {} which is too large ({} bytes)", i, decompressedSize);
 				cemu_assert_debug(false);
 				continue;
 			}
 			rawData = (uint8*)malloc(decompressedSize);
 			if (rawData == nullptr)
 			{
-				forceLogDebug_printf("RPLLoader-CRC: Failed to allocate memory for uncompressed section %d (%u bytes)", i, decompressedSize);
+				cemuLog_logDebug(LogType::Force, "RPLLoader-CRC: Failed to allocate memory for uncompressed section {} ({} bytes)", i, decompressedSize);
 				cemu_assert_debug(false);
 				continue;
 			}
@@ -1534,8 +1494,8 @@ void RPLLoader_BeginCemuhookCRC(RPLModule* rpl)
 			auto ret = inflate(&strm, Z_FULL_FLUSH);
 			if (ret != Z_OK && ret != Z_STREAM_END || strm.avail_in != 0 || strm.avail_out != 0)
 			{
-				forceLogDebug_printf("RPLLoader-CRC: Unable to decompress section %d", i);
-				forceLogDebug_printf("zRet %d availIn %d availOut %d", ret, (sint32)strm.avail_in, (sint32)strm.avail_out);
+				cemuLog_logDebug(LogType::Force, "RPLLoader-CRC: Unable to decompress section {}", i);
+				cemuLog_logDebug(LogType::Force, "zRet {} availIn {} availOut {}", ret, (sint32)strm.avail_in, (sint32)strm.avail_out);
 				cemu_assert_debug(false);
 				free(rawData);
 				inflateEnd(&strm);
@@ -1618,7 +1578,7 @@ void RPLLoader_InitModuleAllocator(RPLModule* rpl)
 }
 
 // map rpl into memory, but do not resolve relocs and imports yet
-RPLModule* rpl_loadFromMem(uint8* rplData, sint32 size, char* name)
+RPLModule* RPLLoader_LoadFromMemory(uint8* rplData, sint32 size, char* name)
 {
 	char moduleName[RPL_MODULE_NAME_LENGTH];
 	_RPLLoader_ExtractModuleNameFromPath(moduleName, name);
@@ -1636,7 +1596,7 @@ RPLModule* rpl_loadFromMem(uint8* rplData, sint32 size, char* name)
 		return nullptr;
 	}
 
-	forceLogDebug_printf("Load %s Code-Offset: -0x%x", name, rpl->regionMappingBase_text.GetMPTR() - 0x02000000);
+	cemuLog_logDebug(LogType::Force, "Load {} Code-Offset: -0x{:x}", name, rpl->regionMappingBase_text.GetMPTR() - 0x02000000);
 
 	// sdata (r2/r13)
 	uint32 sdataBaseAddress = rpl->fileInfo.sdataBase1; // base + 0x8000
@@ -1670,7 +1630,7 @@ RPLModule* rpl_loadFromMem(uint8* rplData, sint32 size, char* name)
 	// cancel if error
 	if (rpl->hasError)
 	{
-		forceLog_printf("RPLLoader: Unable to load RPL due to errors");
+		cemuLog_log(LogType::Force, "RPLLoader: Unable to load RPL due to errors");
 		delete rpl;
 		return nullptr;
 	}
@@ -1707,7 +1667,7 @@ RPLModule* rpl_loadFromMem(uint8* rplData, sint32 size, char* name)
 	return rpl;
 }
 
-void RPLLoader_flushMemory(RPLModule* rpl)
+void RPLLoader_FlushMemory(RPLModule* rpl)
 {
 	// invalidate recompiler cache
 	PPCRecompiler_invalidateRange(rpl->regionMappingBase_text.GetMPTR(), rpl->regionMappingBase_text.GetMPTR() + rpl->regionSize_text);
@@ -1763,7 +1723,7 @@ void RPLLoader_LinkSingleModule(RPLModule* rplLoaderContext, bool resolveOnlyExp
 	else
 		RPLLoader_HandleRelocs(rplLoaderContext, sharedImportTracking, 0);
 
-	RPLLoader_flushMemory(rplLoaderContext);
+	RPLLoader_FlushMemory(rplLoaderContext);
 }
 
 void RPLLoader_LoadSectionDebugSymbols(RPLModule* rplLoaderContext, rplSectionEntryNew_t* section, int symtabSectionIndex)
@@ -1927,8 +1887,24 @@ uint32 RPLLoader_GetModuleEntrypoint(RPLModule* rplLoaderContext)
 	return rplLoaderContext->entrypoint;
 }
 
-uint32 rplLoader_currentHandleCounter = 0x00001000;
-sint16 rplLoader_currentTlsModuleIndex = 0x0001;
+// takes a module name without extension, returns true if the RPL module is a known Cafe OS module
+bool RPLLoader_IsKnownCafeOSModule(std::string_view name)
+{
+	static std::unordered_set<std::string> s_systemModules556 = {
+			"avm","camera","coreinit","dc","dmae","drmapp","erreula",
+			"gx2","h264","lzma920","mic","nfc","nio_prof","nlibcurl",
+			"nlibnss","nlibnss2","nn_ac","nn_acp","nn_act","nn_aoc","nn_boss",
+			"nn_ccr","nn_cmpt","nn_dlp","nn_ec","nn_fp","nn_hai","nn_hpad",
+			"nn_idbe","nn_ndm","nn_nets2","nn_nfp","nn_nim","nn_olv","nn_pdm",
+			"nn_save","nn_sl","nn_spm","nn_temp","nn_uds","nn_vctl","nsysccr",
+			"nsyshid","nsyskbd","nsysnet","nsysuhs","nsysuvd","ntag","padscore",
+			"proc_ui","sndcore2","snduser2","snd_core","snd_user","swkbd","sysapp",
+			"tcl","tve","uac","uac_rpl","usb_mic","uvc","uvd","vpad","vpadbase",
+			"zlib125"};
+	std::string nameLower{name};
+	std::transform(nameLower.begin(), nameLower.end(), nameLower.begin(), _ansiToLower);
+	return s_systemModules556.contains(nameLower);
+}
 
 // increment reference counter for module
 void RPLLoader_AddDependency(const char* name)
@@ -1954,23 +1930,23 @@ void RPLLoader_AddDependency(const char* name)
 	{
 		if (strcmp(moduleName, dep->modulename) == 0)
 		{
-			// entry already exists, increment reference counter
 			dep->referenceCount++;
 			return;
 		}
 	}
 	// add new entry
-	rplDependency_t* newDependency = new rplDependency_t();
+	RPLDependency* newDependency = new RPLDependency();
 	strcpy(newDependency->modulename, moduleName);
 	newDependency->referenceCount = 1;
 	newDependency->coreinitHandle = rplLoader_currentHandleCounter;
 	newDependency->tlsModuleIndex = rplLoader_currentTlsModuleIndex;
-	rplLoader_currentTlsModuleIndex++;
+	newDependency->isCafeOSModule = RPLLoader_IsKnownCafeOSModule(moduleName);
+	rplLoader_currentTlsModuleIndex++; // todo - delay handle and tls allocation until the module is actually loaded. It may not exist
 	rplLoader_currentHandleCounter++;
 	if (rplLoader_currentTlsModuleIndex == 0x7FFF)
-		cemuLog_force("RPLLoader: Exhausted TLS module indices pool");
+		cemuLog_log(LogType::Force, "RPLLoader: Exhausted TLS module indices pool");
 	// convert name to path/filename if it isn't already one
-	if (strstr(name, "."))
+	if (strchr(name, '.'))
 	{
 		strcpy_s(newDependency->filepath, name);
 	}
@@ -2013,6 +1989,18 @@ void RPLLoader_RemoveDependency(const char* name)
 	}
 }
 
+bool RPLLoader_HasDependency(std::string_view name)
+{
+	char moduleName[RPL_MODULE_NAME_LENGTH];
+	_RPLLoader_ExtractModuleNameFromPath(moduleName, name);
+	for (const auto& dep : rplDependencyList)
+	{
+		if (strcmp(moduleName, dep->modulename) == 0)
+			return true;
+	}
+	return false;
+}
+
 // decrement reference counter for dependency by module handle
 void RPLLoader_RemoveDependency(uint32 handle)
 {
@@ -2038,6 +2026,9 @@ uint32 RPLLoader_GetHandleByModuleName(const char* name)
 	{
 		if (strcmp(moduleName, dep->modulename) == 0)
 		{
+			cemu_assert_debug(dep->loadAttempted);
+			if (!dep->isCafeOSModule && !dep->rplLoaderContext)
+				return RPL_INVALID_HANDLE; // module not found
 			return dep->coreinitHandle;
 		}
 	}
@@ -2070,21 +2061,21 @@ bool RPLLoader_GetTLSDataByTLSIndex(sint16 tlsModuleIndex, uint8** tlsData, sint
 	return true;
 }
 
-bool RPLLoader_LoadFromVirtualPath(rplDependency_t* dependency, char* filePath)
+bool RPLLoader_LoadFromVirtualPath(RPLDependency* dependency, char* filePath)
 {
 	uint32 rplSize = 0;
 	uint8* rplData = fsc_extractFile(filePath, &rplSize);
 	if (rplData)
 	{
-		forceLogDebug_printf("Loading: %s", filePath);
-		dependency->rplLoaderContext = rpl_loadFromMem(rplData, rplSize, filePath);
+		cemuLog_logDebug(LogType::Force, "Loading: {}", filePath);
+		dependency->rplLoaderContext = RPLLoader_LoadFromMemory(rplData, rplSize, filePath);
 		free(rplData);
 		return true;
 	}
 	return false;
 }
 
-void RPLLoader_LoadDependency(rplDependency_t* dependency)
+void RPLLoader_LoadDependency(RPLDependency* dependency)
 {
 	dependency->loadAttempted = true;
 	// check if module is already loaded
@@ -2092,11 +2083,9 @@ void RPLLoader_LoadDependency(rplDependency_t* dependency)
 	{
 		if(!boost::iequals(rplModuleList[i]->moduleName2, dependency->modulename))
 			continue;
-		// already loaded
 		dependency->rplLoaderContext = rplModuleList[i];
 		return;
 	}
-	// attempt to load rpl from various locations
 	char filePath[RPL_MODULE_PATH_LENGTH];
 	// check if path is absolute
 	if (dependency->filepath[0] == '/')
@@ -2105,7 +2094,7 @@ void RPLLoader_LoadDependency(rplDependency_t* dependency)
 		RPLLoader_LoadFromVirtualPath(dependency, filePath);
 		return;
 	}
-	// attempt to load rpl from internal folder
+	// attempt to load rpl from code directory of current title
 	strcpy_s(filePath, "/internal/current_title/code/");
 	strcat_s(filePath, dependency->filepath);
 	// except if it is blacklisted
@@ -2122,12 +2111,13 @@ void RPLLoader_LoadDependency(rplDependency_t* dependency)
 	// attempt to load rpl from Cemu's /cafeLibs/ directory
 	if (ActiveSettings::LoadSharedLibrariesEnabled())
 	{
-		const auto filePath = ActiveSettings::GetPath("cafeLibs/{}", dependency->filepath);
+		const auto filePath = ActiveSettings::GetUserDataPath("cafeLibs/{}", dependency->filepath);
 		auto fileData = FileStream::LoadIntoMemory(filePath);
 		if (fileData)
 		{
-			forceLog_printf("Loading RPL: /cafeLibs/%s", dependency->filepath);
-			dependency->rplLoaderContext = rpl_loadFromMem(fileData->data(), fileData->size(), dependency->filepath);
+			cemuLog_log(LogType::Force, "Loading RPL: /cafeLibs/{}", dependency->filepath);
+			dependency->rplLoaderContext = RPLLoader_LoadFromMemory(fileData->data(), fileData->size(),
+																	dependency->filepath);
 			return;
 		}
 	}
@@ -2176,8 +2166,6 @@ void RPLLoader_UpdateDependencies()
 	RPLLoader_Link();
 }
 
-RPLModule* rplLoader_mainModule = nullptr;
-
 void RPLLoader_SetMainModule(RPLModule* rplLoaderContext)
 {
 	rplLoaderContext->entrypointCalled = true;
@@ -2258,7 +2246,7 @@ uint32 RPLLoader_FindModuleOrHLEExport(uint32 moduleHandle, bool isData, const c
 {
 	// find dependency from handle
 	RPLModule* rplLoaderContext = nullptr;
-	rplDependency_t* dependency = nullptr;
+	RPLDependency* dependency = nullptr;
 	for (auto& dep : rplDependencyList)
 	{
 		if (dep->coreinitHandle == moduleHandle)
@@ -2387,3 +2375,24 @@ void RPLLoader_ReleaseCodeCaveMem(MEMPTR<void> addr)
 {
 	heapCodeCaveArea.free(addr.GetMPTR());
 }
+
+void RPLLoader_ResetState()
+{
+	// unload all RPL modules
+	while (rplModuleCount > 0)
+		RPLLoader_UnloadModule(rplModuleList[0]);
+	rplDependencyList.clear();
+	// unload all remaining symbols
+	rplSymbolStorage_unloadAll();
+	// free all code imports
+	g_heapTrampolineArea.releaseAll();
+	list_mappedFunctionImports.clear();
+	g_map_callableExports.clear();
+	rplLoader_applicationHasMemoryControl = false;
+	rplLoader_maxCodeAddress = 0;
+	rplLoader_currentDataAllocatorAddr = 0x10000000;
+	rplLoader_currentTLSModuleIndex = 1;
+	rplLoader_sdataAddr = MPTR_NULL;
+	rplLoader_sdata2Addr = MPTR_NULL;
+	rplLoader_mainModule = nullptr;
+}
diff --git a/src/Cafe/OS/RPL/rpl.h b/src/Cafe/OS/RPL/rpl.h
index ced7e83c..1075ee58 100644
--- a/src/Cafe/OS/RPL/rpl.h
+++ b/src/Cafe/OS/RPL/rpl.h
@@ -2,7 +2,7 @@
 
 struct RPLModule;
 
-#define RPL_INVALID_HANDLE	(0xFFFFFFFF)
+#define RPL_INVALID_HANDLE		0xFFFFFFFF
 
 void RPLLoader_InitState();
 void RPLLoader_ResetState();
@@ -14,7 +14,7 @@ MPTR RPLLoader_AllocateCodeSpace(uint32 size, uint32 alignment);
 uint32 RPLLoader_GetMaxCodeOffset();
 uint32 RPLLoader_GetDataAllocatorAddr();
 
-RPLModule* rpl_loadFromMem(uint8* rplData, sint32 size, char* name);
+RPLModule* RPLLoader_LoadFromMemory(uint8* rplData, sint32 size, char* name);
 uint32 rpl_mapHLEImport(RPLModule* rplLoaderContext, const char* rplName, const char* funcName, bool functionMustExist);
 void RPLLoader_Link();
 
@@ -29,6 +29,7 @@ void RPLLoader_NotifyControlPassedToApplication();
 
 void RPLLoader_AddDependency(const char* name);
 void RPLLoader_RemoveDependency(uint32 handle);
+bool RPLLoader_HasDependency(std::string_view name);
 void RPLLoader_UpdateDependencies();
 
 uint32 RPLLoader_GetHandleByModuleName(const char* name);
diff --git a/src/Cafe/OS/RPL/rpl_structs.h b/src/Cafe/OS/RPL/rpl_structs.h
index 18413049..c66f6136 100644
--- a/src/Cafe/OS/RPL/rpl_structs.h
+++ b/src/Cafe/OS/RPL/rpl_structs.h
@@ -116,7 +116,7 @@ typedef struct
 	/* +0x34 */ uint32be ukn34;
 	/* +0x38 */ uint32be ukn38;
 	/* +0x3C */ uint32be ukn3C;
-	/* +0x40 */ uint32be toolkitVersion;
+	/* +0x40 */ uint32be minimumToolkitVersion;
 	/* +0x44 */ uint32be ukn44;
 	/* +0x48 */ uint32be ukn48;
 	/* +0x4C */ uint32be ukn4C;
@@ -144,25 +144,13 @@ struct RPLModule
 {
 	uint32 ukn00; // pointer to shared memory region? (0xEFE01000)
 	uint32 ukn04; // related to text region size?
-	char* moduleNamePtr__depr; // converted to lower case
-	uint32 moduleNameLength__depr; // length of module name
-	uint32 moduleNameSize; // aligned alloc size, not the same as actual length
 	uint32 padding14;
 	uint32 padding18;
 	rplHeaderNew_t rplHeader;
 	rplSectionEntryNew_t* sectionTablePtr; // copy of section table
 
-	RPLFileInfoData* fileInfoPtr__depr{}; // copy of fileinfo section
-	uint32 fileInfoSize__depr{}; // size of fileInfo section
-	uint32 fileInfoAllocSize__depr{}; // aligned alloc size
-
-	uint32be* crcTablePtr_depr{}; // copy of CRC section
-	uint32 crcTableAllocSize_depr{};
-
 	uint32 entrypoint;
 
-	uint8* rplData_depr; // Cemuhook might still read this
-
 	MPTR textRegionTemp; // temporary memory for text section?
 
 	MEMPTR<void> regionMappingBase_text; // base destination address for text region
@@ -171,15 +159,11 @@ struct RPLModule
 	uint8* tempRegionPtr;
 	uint32 tempRegionAllocSize;
 
-	rplSectionAddressEntry_t* sectionAddressTable__depr;
-	uint32 sectionAddressTableSize__depr;
-
 	uint32 exportDCount;
 	rplExportTableEntry_t* exportDDataPtr;
 	uint32 exportFCount;
 	rplExportTableEntry_t* exportFDataPtr;
 
-	/* above are hardcoded in Cemuhook */
 	std::string moduleName2;
 	
 	std::vector<rplSectionAddressEntry_t> sectionAddressTable2;
@@ -241,17 +225,17 @@ struct RPLModule
 
 };
 
-typedef struct
+struct RPLDependency
 {
 	char modulename[RPL_MODULE_NAME_LENGTH];
 	char filepath[RPL_MODULE_PATH_LENGTH];
 	bool loadAttempted;
-	//bool isHLEModule; // determined to be a HLE module
-	RPLModule* rplLoaderContext; // context of loaded module
+	bool isCafeOSModule; // name is a known Cafe OS RPL
+	RPLModule* rplLoaderContext; // context of loaded module, can be nullptr for HLE COS modules
 	sint32 referenceCount;
 	uint32 coreinitHandle; // fake handle for coreinit
 	sint16 tlsModuleIndex; // tls module index assigned to this dependency
-}rplDependency_t;
+};
 
 RPLModule* RPLLoader_FindModuleByCodeAddr(uint32 addr);
 RPLModule* RPLLoader_FindModuleByDataAddr(uint32 addr);
diff --git a/src/Cafe/OS/RPL/rpl_symbol_storage.cpp b/src/Cafe/OS/RPL/rpl_symbol_storage.cpp
index f4797c97..5d3046e3 100644
--- a/src/Cafe/OS/RPL/rpl_symbol_storage.cpp
+++ b/src/Cafe/OS/RPL/rpl_symbol_storage.cpp
@@ -83,6 +83,20 @@ RPLStoredSymbol* rplSymbolStorage_getByAddress(MPTR address)
 	return rplSymbolStorage.map_symbolByAddress[address];
 }
 
+RPLStoredSymbol* rplSymbolStorage_getByClosestAddress(MPTR address)
+{
+    // highly inefficient but doesn't matter for now
+    std::unique_lock<std::mutex> lck(rplSymbolStorage.m_symbolStorageMutex);
+    for(uint32 i=0; i<4096; i++)
+    {
+        RPLStoredSymbol* symbol = rplSymbolStorage.map_symbolByAddress[address];
+        if(symbol)
+            return symbol;
+        address -= 4;
+    }
+    return nullptr;
+}
+
 void rplSymbolStorage_remove(RPLStoredSymbol* storedSymbol)
 {
 	std::unique_lock<std::mutex> lck(rplSymbolStorage.m_symbolStorageMutex);
@@ -145,6 +159,7 @@ void rplSymbolStorage_unloadAll()
 	// free strings
 	for (auto it : rplSymbolStorage.list_strAllocatedBlocks)
 		free(it);
+    rplSymbolStorage.list_strAllocatedBlocks.clear();
 	rplSymbolStorage.strAllocatorBlock = nullptr;
 	rplSymbolStorage.strAllocatorOffset = 0;
 }
diff --git a/src/Cafe/OS/RPL/rpl_symbol_storage.h b/src/Cafe/OS/RPL/rpl_symbol_storage.h
index 0f179f59..d940186a 100644
--- a/src/Cafe/OS/RPL/rpl_symbol_storage.h
+++ b/src/Cafe/OS/RPL/rpl_symbol_storage.h
@@ -12,6 +12,7 @@ RPLStoredSymbol* rplSymbolStorage_store(const char* libName, const char* symbolN
 void rplSymbolStorage_remove(RPLStoredSymbol* storedSymbol);
 void rplSymbolStorage_removeRange(MPTR address, sint32 length);
 RPLStoredSymbol* rplSymbolStorage_getByAddress(MPTR address);
+RPLStoredSymbol* rplSymbolStorage_getByClosestAddress(MPTR address);
 void rplSymbolStorage_createJumpProxySymbol(MPTR jumpAddress, MPTR destAddress);
 
 std::unordered_map<uint32, RPLStoredSymbol*>& rplSymbolStorage_lockSymbolMap();
diff --git a/src/Cafe/OS/common/OSCommon.cpp b/src/Cafe/OS/common/OSCommon.cpp
index b41ab865..5297f201 100644
--- a/src/Cafe/OS/common/OSCommon.cpp
+++ b/src/Cafe/OS/common/OSCommon.cpp
@@ -10,8 +10,10 @@
 #include "Cafe/OS/libs/nn_uds/nn_uds.h"
 #include "Cafe/OS/libs/nn_nim/nn_nim.h"
 #include "Cafe/OS/libs/nn_ndm/nn_ndm.h"
+#include "Cafe/OS/libs/nn_spm/nn_spm.h"
 #include "Cafe/OS/libs/nn_ec/nn_ec.h"
 #include "Cafe/OS/libs/nn_boss/nn_boss.h"
+#include "Cafe/OS/libs/nn_sl/nn_sl.h"
 #include "Cafe/OS/libs/nn_fp/nn_fp.h"
 #include "Cafe/OS/libs/nn_olv/nn_olv.h"
 #include "Cafe/OS/libs/nn_idbe/nn_idbe.h"
@@ -84,6 +86,7 @@ void osLib_addFunctionInternal(const char* libraryName, const char* functionName
 	uint32 funcHashA, funcHashB;
 	osLib_generateHashFromName(libraryName, &libHashA, &libHashB);
 	osLib_generateHashFromName(functionName, &funcHashA, &funcHashB);
+	std::string hleName = fmt::format("{}.{}", libraryName, functionName);
 	// if entry already exists, update it
 	for (auto& it : *s_osFunctionTable)
 	{
@@ -92,11 +95,11 @@ void osLib_addFunctionInternal(const char* libraryName, const char* functionName
 			it.funcHashA == funcHashA &&
 			it.funcHashB == funcHashB)
 		{
-			it.hleFunc = PPCInterpreter_registerHLECall(osFunction);
+			it.hleFunc = PPCInterpreter_registerHLECall(osFunction, hleName);
 			return;
 		}
 	}
-	s_osFunctionTable->emplace_back(libHashA, libHashB, funcHashA, funcHashB, fmt::format("{}.{}", libraryName, functionName), PPCInterpreter_registerHLECall(osFunction));
+	s_osFunctionTable->emplace_back(libHashA, libHashB, funcHashA, funcHashB, hleName, PPCInterpreter_registerHLECall(osFunction, hleName));
 }
 
 extern "C" DLLEXPORT void osLib_registerHLEFunction(const char* libraryName, const char* functionName, void(*osFunction)(PPCInterpreter_t * hCPU))
@@ -204,7 +207,9 @@ void osLib_load()
 	nnUds_load();
 	nn::nim::load();
 	nn::ndm::load();
+	nn::spm::load();
 	nn::save::load();
+	nnSL_load();
 	nsysnet_load();
 	nn::fp::load();
 	nn::olv::load();
@@ -216,5 +221,5 @@ void osLib_load()
 	nsyskbd::nsyskbd_load();
 	swkbd::load();
 	camera::load();
-	procui_load();
+	proc_ui::load();
 }
diff --git a/src/Cafe/OS/common/OSCommon.h b/src/Cafe/OS/common/OSCommon.h
index 4fb65a47..34f207bb 100644
--- a/src/Cafe/OS/common/OSCommon.h
+++ b/src/Cafe/OS/common/OSCommon.h
@@ -23,3 +23,86 @@ void osLib_returnFromFunction64(PPCInterpreter_t* hCPU, uint64 returnValue64);
 
 // utility functions
 #include "Cafe/OS/common/OSUtil.h"
+
+// va_list
+struct ppc_va_list
+{
+	uint8be gprIndex;
+	uint8be fprIndex;
+	uint8be _padding2[2];
+	MEMPTR<uint8be> overflow_arg_area;
+	MEMPTR<uint8be> reg_save_area;
+};
+static_assert(sizeof(ppc_va_list) == 0xC);
+
+struct ppc_va_list_reg_storage
+{
+	uint32be gpr_save_area[8]; // 32 bytes, r3 to r10
+	float64be fpr_save_area[8]; // 64 bytes, f1 to f8
+	ppc_va_list vargs;
+	uint32be padding;
+};
+static_assert(sizeof(ppc_va_list_reg_storage) == 0x70);
+
+// Equivalent of va_start for PPC HLE functions. Must be called before any StackAllocator<> definitions
+#define ppc_define_va_list(__gprIndex, __fprIndex) \
+	MPTR vaOriginalR1 = PPCInterpreter_getCurrentInstance()->gpr[1]; \
+	StackAllocator<ppc_va_list_reg_storage> va_list_storage; \
+	for(int i=3; i<=10; i++) va_list_storage->gpr_save_area[i-3] = PPCInterpreter_getCurrentInstance()->gpr[i]; \
+	for(int i=1; i<=8; i++) va_list_storage->fpr_save_area[i-1] = PPCInterpreter_getCurrentInstance()->fpr[i].fp0; \
+	va_list_storage->vargs.gprIndex = __gprIndex; \
+	va_list_storage->vargs.fprIndex = __fprIndex; \
+	va_list_storage->vargs.reg_save_area = (uint8be*)&va_list_storage; \
+	va_list_storage->vargs.overflow_arg_area = {vaOriginalR1 + 8}; \
+	ppc_va_list& vargs = va_list_storage->vargs;
+
+enum class ppc_va_type
+{
+	INT32 = 1,
+	INT64 = 2,
+	FLOAT_OR_DOUBLE = 3,
+};
+
+static void* _ppc_va_arg(ppc_va_list* vargs, ppc_va_type argType)
+{
+	void* r;
+	switch ( argType )
+	{
+	default:
+		cemu_assert_suspicious();
+	case ppc_va_type::INT32:
+		if ( vargs[0].gprIndex < 8u )
+		{
+			r = &vargs->reg_save_area[4 * vargs->gprIndex];
+			vargs->gprIndex++;
+			return r;
+		}
+		r = vargs->overflow_arg_area;
+		vargs->overflow_arg_area += 4;
+		return r;
+	case ppc_va_type::INT64:
+		if ( (vargs->gprIndex & 1) != 0 )
+			vargs->gprIndex++;
+		if ( vargs->gprIndex < 8 )
+		{
+			r = &vargs->reg_save_area[4 * vargs->gprIndex];
+			vargs->gprIndex += 2;
+			return r;
+		}
+		vargs->overflow_arg_area = {(vargs->overflow_arg_area.GetMPTR()+7) & 0xFFFFFFF8};
+		r = vargs->overflow_arg_area;
+		vargs->overflow_arg_area += 8;
+		return r;
+	case ppc_va_type::FLOAT_OR_DOUBLE:
+		if ( vargs->fprIndex < 8 )
+		{
+			r = &vargs->reg_save_area[0x20 + 8 * vargs->fprIndex];
+			vargs->fprIndex++;
+			return r;
+		}
+		vargs->overflow_arg_area = {(vargs->overflow_arg_area.GetMPTR()+7) & 0xFFFFFFF8};
+		r = vargs->overflow_arg_area;
+		vargs->overflow_arg_area += 8;
+		return r;
+	}
+}
\ No newline at end of file
diff --git a/src/Cafe/OS/common/OSUtil.h b/src/Cafe/OS/common/OSUtil.h
index 9bf8480b..84e38a6c 100644
--- a/src/Cafe/OS/common/OSUtil.h
+++ b/src/Cafe/OS/common/OSUtil.h
@@ -65,7 +65,7 @@ public:
 		}
 		else if constexpr (std::is_floating_point_v<T>)
 		{
-			v = (T)ppcInterpreterCurrentInstance->fpr[1 + fprIndex].fpr;
+			v = (T)hCPU->fpr[1 + fprIndex].fpr;
 			fprIndex++;
 		}
 		else
@@ -140,6 +140,17 @@ static std::tuple<Args...> cafeExportBuildArgTuple(PPCInterpreter_t* hCPU, R(fn)
 	return std::tuple<Args...>{ cafeExportGetParamWrapper<Args>(hCPU, gprIndex, fprIndex)... };
 }
 
+template<typename T>
+T cafeExportGetFormatParamWrapper(PPCInterpreter_t* hCPU, int& gprIndex, int& fprIndex)
+{
+	T v;
+	cafeExportParamWrapper::getParamWrapper(hCPU, gprIndex, fprIndex, v);
+	// if T is char* or const char*, return "null" instead of nullptr since newer fmtlib would throw otherwise
+	if constexpr (std::is_same_v<T, char*> || std::is_same_v<T, const char*>)
+		return v ? v : (T)"null";
+	return v;
+}
+
 template<typename T>
 using _CAFE_FORMAT_ARG = std::conditional_t<std::is_pointer_v<T>,
 	std::conditional_t<std::is_same_v<T, char*> || std::is_same_v<T, const char*>, T, MEMPTR<T>>, T>;
@@ -150,7 +161,7 @@ static auto cafeExportBuildFormatTuple(PPCInterpreter_t* hCPU, R(fn)(Args...))
 	int gprIndex = 0;
 	int fprIndex = 0;
 	return std::tuple<_CAFE_FORMAT_ARG<Args>...>{
-		cafeExportGetParamWrapper<_CAFE_FORMAT_ARG<Args>>(hCPU, gprIndex, fprIndex)...
+		cafeExportGetFormatParamWrapper<_CAFE_FORMAT_ARG<Args>>(hCPU, gprIndex, fprIndex)...
 	};
 }
 
diff --git a/src/Cafe/OS/common/PPCConcurrentQueue.h b/src/Cafe/OS/common/PPCConcurrentQueue.h
index 089515c5..a21c0eb2 100644
--- a/src/Cafe/OS/common/PPCConcurrentQueue.h
+++ b/src/Cafe/OS/common/PPCConcurrentQueue.h
@@ -10,7 +10,7 @@ template <typename T>
 class PPCConcurrentQueue
 {
 public:
-	PPCConcurrentQueue() {}
+	PPCConcurrentQueue() = default;
 	PPCConcurrentQueue(const PPCConcurrentQueue&) = delete;
 	PPCConcurrentQueue& operator=(const PPCConcurrentQueue&) = delete;
 
@@ -21,7 +21,7 @@ public:
 		//OSThread_t* currentThread = coreinit::OSGetCurrentThread();
 		//cemu_assert_debug(thread == nullptr || currentThread == thread);
 
-		// forceLogDebug_printf("push suspend count: %d", _swapEndianU32(thread->suspend) - m_suspendCount);
+		// cemuLog_logDebug(LogType::Force, "push suspend count: {}", _swapEndianU32(thread->suspend) - m_suspendCount);
 
 		//__OSLockScheduler();
 
@@ -46,7 +46,7 @@ public:
 
 		//thread = coreinitThread_getCurrentThread(ppcInterpreterCurrentInstance);
 
-		// forceLogDebug_printf("pop suspend count: %d", _swapEndianU32(thread->suspend) + m_suspendCount);
+		// cemuLog_logDebug(LogType::Force, "pop suspend count: {}", _swapEndianU32(thread->suspend) + m_suspendCount);
 
 		__OSLockScheduler();
 		if (m_queue.empty())
diff --git a/src/Cafe/OS/libs/TCL/TCL.cpp b/src/Cafe/OS/libs/TCL/TCL.cpp
index d0c29d44..8b345b5e 100644
--- a/src/Cafe/OS/libs/TCL/TCL.cpp
+++ b/src/Cafe/OS/libs/TCL/TCL.cpp
@@ -1,28 +1,161 @@
 #include "Cafe/OS/common/OSCommon.h"
 #include "Cafe/OS/libs/TCL/TCL.h"
 
+#include "HW/Latte/Core/LattePM4.h"
+
 namespace TCL
 {
+	SysAllocator<coreinit::OSEvent> s_updateRetirementEvent;
+	uint64 s_currentRetireMarker = 0;
 
-	enum class TCL_SUBMISSION_FLAG : uint32
+	struct TCLStatePPC // mapped into PPC space
 	{
-		SURFACE_SYNC = 0x400000, // submit surface sync packet before cmd
-		TRIGGER_INTERRUPT = 0x200000, // probably
-		UKN_20000000 = 0x20000000,
+		uint64be gpuRetireMarker; // written by GPU
 	};
 
-	int TCLSubmitToRing(uint32be* cmd, uint32 cmdLen, uint32be* controlFlags, uint64* submissionTimestamp)
+	SysAllocator<TCLStatePPC> s_tclStatePPC;
+
+	// called from GPU for timestamp EOP event
+	void TCLGPUNotifyNewRetirementTimestamp()
 	{
-		// todo - figure out all the bits of *controlFlags
-		// if submissionTimestamp != nullptr then set it to the timestamp of the submission. Note: We should make sure that uint64's are written atomically by the GPU command processor
+		// gpuRetireMarker is updated via event eop command
+		__OSLockScheduler();
+		coreinit::OSSignalEventAllInternal(s_updateRetirementEvent.GetPtr());
+		__OSUnlockScheduler();
+	}
 
-		cemu_assert_debug(false);
+	int TCLTimestamp(TCLTimestampId id, uint64be* timestampOut)
+	{
+		if (id == TCLTimestampId::TIMESTAMP_LAST_BUFFER_RETIRED)
+		{
+			MEMPTR<uint32> b;
+			// this is the timestamp of the last buffer that was retired by the GPU
+			stdx::atomic_ref<uint64be> retireTimestamp(s_tclStatePPC->gpuRetireMarker);
+			*timestampOut = retireTimestamp.load();
+			return 0;
+		}
+		else
+		{
+			cemuLog_log(LogType::Force, "TCLTimestamp(): Unsupported timestamp ID {}", (uint32)id);
+			*timestampOut = 0;
+			return 0;
+		}
+	}
 
+	int TCLWaitTimestamp(TCLTimestampId id, uint64 waitTs, uint64 timeout)
+	{
+		if (id == TCLTimestampId::TIMESTAMP_LAST_BUFFER_RETIRED)
+		{
+			while ( true )
+			{
+				stdx::atomic_ref<uint64be> retireTimestamp(s_tclStatePPC->gpuRetireMarker);
+				uint64 currentTimestamp = retireTimestamp.load();
+				if (currentTimestamp >= waitTs)
+					return 0;
+				coreinit::OSWaitEvent(s_updateRetirementEvent.GetPtr());
+			}
+		}
+		else
+		{
+			cemuLog_log(LogType::Force, "TCLWaitTimestamp(): Unsupported timestamp ID {}", (uint32)id);
+		}
+		return 0;
+	}
+
+	static constexpr uint32 TCL_RING_BUFFER_SIZE = 4096; // in U32s
+
+	std::atomic<uint32> tclRingBufferA[TCL_RING_BUFFER_SIZE];
+	std::atomic<uint32> tclRingBufferA_readIndex{0};
+	uint32 tclRingBufferA_writeIndex{0};
+
+	// GPU code calls this to grab the next command word
+	bool TCLGPUReadRBWord(uint32& cmdWord)
+	{
+		if (tclRingBufferA_readIndex == tclRingBufferA_writeIndex)
+			return false;
+		cmdWord = tclRingBufferA[tclRingBufferA_readIndex];
+		tclRingBufferA_readIndex = (tclRingBufferA_readIndex+1) % TCL_RING_BUFFER_SIZE;
+		return true;
+	}
+
+	void TCLWaitForRBSpace(uint32be numU32s)
+	{
+		while ( true )
+		{
+			uint32 distance = (tclRingBufferA_readIndex + TCL_RING_BUFFER_SIZE - tclRingBufferA_writeIndex) & (TCL_RING_BUFFER_SIZE - 1);
+			if (tclRingBufferA_writeIndex == tclRingBufferA_readIndex) // buffer completely empty
+				distance = TCL_RING_BUFFER_SIZE;
+			if (distance >= numU32s+1) // assume distance minus one, because we are never allowed to completely wrap around
+				break;
+			_mm_pause();
+		}
+	}
+
+	// this function assumes that TCLWaitForRBSpace was called and that there is enough space
+	void TCLWriteCmd(uint32be* cmd, uint32 cmdLen)
+	{
+		while (cmdLen > 0)
+		{
+			tclRingBufferA[tclRingBufferA_writeIndex] = *cmd;
+			tclRingBufferA_writeIndex++;
+			tclRingBufferA_writeIndex &= (TCL_RING_BUFFER_SIZE - 1);
+			cmd++;
+			cmdLen--;
+		}
+	}
+
+	#define EVENT_TYPE_TS		5
+
+	void TCLSubmitRetireMarker(bool triggerEventInterrupt)
+	{
+		s_currentRetireMarker++;
+		uint32be cmd[6];
+		cmd[0] = pm4HeaderType3(IT_EVENT_WRITE_EOP, 5);
+		cmd[1] = (4 | (EVENT_TYPE_TS << 8)); // event type (bits 8-15) and event index (bits 0-7).
+		cmd[2] = MEMPTR<void>(&s_tclStatePPC->gpuRetireMarker).GetMPTR(); // address lower 32bits + data sel bits
+		cmd[3] = 0x40000000; // select 64bit write, lower 16 bits are the upper bits of the address
+		if (triggerEventInterrupt)
+			cmd[3] |= 0x2000000; // trigger interrupt after value has been written
+		cmd[4] = (uint32)s_currentRetireMarker; // data lower 32 bits
+		cmd[5] = (uint32)(s_currentRetireMarker>>32); // data higher 32 bits
+		TCLWriteCmd(cmd, 6);
+	}
+
+	int TCLSubmitToRing(uint32be* cmd, uint32 cmdLen, betype<TCLSubmissionFlag>* controlFlags, uint64be* timestampValueOut)
+	{
+		TCLSubmissionFlag flags = *controlFlags;
+		cemu_assert_debug(timestampValueOut); // handle case where this is null
+
+		// make sure there is enough space to submit all commands at one
+		uint32 totalCommandLength = cmdLen;
+		totalCommandLength += 6; // space needed for TCLSubmitRetireMarker
+
+		TCLWaitForRBSpace(totalCommandLength);
+
+		// submit command buffer
+		TCLWriteCmd(cmd, cmdLen);
+
+		// create new marker timestamp and tell GPU to write it to our variable after its done processing the command
+		if ((HAS_FLAG(flags, TCLSubmissionFlag::USE_RETIRED_MARKER)))
+		{
+			TCLSubmitRetireMarker(!HAS_FLAG(flags, TCLSubmissionFlag::NO_MARKER_INTERRUPT));
+			*timestampValueOut = s_currentRetireMarker; // incremented before each submit
+		}
+		else
+		{
+			cemu_assert_unimplemented();
+		}
 		return 0;
 	}
 
 	void Initialize()
 	{
 		cafeExportRegister("TCL", TCLSubmitToRing, LogType::Placeholder);
+		cafeExportRegister("TCL", TCLTimestamp, LogType::Placeholder);
+		cafeExportRegister("TCL", TCLWaitTimestamp, LogType::Placeholder);
+
+		s_currentRetireMarker = 0;
+		s_tclStatePPC->gpuRetireMarker = 0;
+		coreinit::OSInitEvent(s_updateRetirementEvent.GetPtr(), coreinit::OSEvent::EVENT_STATE::STATE_NOT_SIGNALED, coreinit::OSEvent::EVENT_MODE::MODE_AUTO);
 	}
 }
diff --git a/src/Cafe/OS/libs/TCL/TCL.h b/src/Cafe/OS/libs/TCL/TCL.h
index ab5358b0..35f0a6bf 100644
--- a/src/Cafe/OS/libs/TCL/TCL.h
+++ b/src/Cafe/OS/libs/TCL/TCL.h
@@ -1,4 +1,25 @@
 namespace TCL
 {
+	enum class TCLTimestampId
+	{
+		TIMESTAMP_LAST_BUFFER_RETIRED = 1,
+	};
+
+	enum class TCLSubmissionFlag : uint32
+	{
+		SURFACE_SYNC = 0x400000, // submit surface sync packet before cmd
+		NO_MARKER_INTERRUPT = 0x200000,
+		USE_RETIRED_MARKER = 0x20000000, // Controls whether the timer is updated before or after (retired) the cmd. Also controls which timestamp is returned for the submission. Before and after using separate counters
+	};
+
+	int TCLTimestamp(TCLTimestampId id, uint64be* timestampOut);
+	int TCLWaitTimestamp(TCLTimestampId id, uint64 waitTs, uint64 timeout);
+	int TCLSubmitToRing(uint32be* cmd, uint32 cmdLen, betype<TCLSubmissionFlag>* controlFlags, uint64be* timestampValueOut);
+
+	// called from Latte code
+	bool TCLGPUReadRBWord(uint32& cmdWord);
+	void TCLGPUNotifyNewRetirementTimestamp();
+
 	void Initialize();
-}
\ No newline at end of file
+}
+ENABLE_BITMASK_OPERATORS(TCL::TCLSubmissionFlag);
diff --git a/src/Cafe/OS/libs/camera/camera.cpp b/src/Cafe/OS/libs/camera/camera.cpp
index 4debb37f..efb8013d 100644
--- a/src/Cafe/OS/libs/camera/camera.cpp
+++ b/src/Cafe/OS/libs/camera/camera.cpp
@@ -181,12 +181,12 @@ namespace camera
 	sint32 CAMInit(uint32 cameraId, CAMInitInfo_t* camInitInfo, uint32be* error)
 	{
 		CameraInstance* camInstance = new CameraInstance(camInitInfo->width, camInitInfo->height, camInitInfo->handlerFuncPtr);
-
+		*error = 0; // Hunter's Trophy 2 will fail to boot if we don't set this
 		std::unique_lock<std::recursive_mutex> _lock(g_mutex_camera);
 		if (g_cameraCounter == 0)
 		{
 			coreinit::OSCreateAlarm(g_alarm_camera.GetPtr());
-			coreinit::OSSetPeriodicAlarm(g_alarm_camera.GetPtr(), coreinit::coreinit_getOSTime(), (uint64)ESPRESSO_TIMER_CLOCK / 60ull, RPLLoader_MakePPCCallable(ppcCAMUpdate60));
+			coreinit::OSSetPeriodicAlarm(g_alarm_camera.GetPtr(), coreinit::OSGetTime(), (uint64)ESPRESSO_TIMER_CLOCK / 60ull, RPLLoader_MakePPCCallable(ppcCAMUpdate60));
 		}
 		g_cameraCounter++;
 
diff --git a/src/Cafe/OS/libs/coreinit/coreinit.cpp b/src/Cafe/OS/libs/coreinit/coreinit.cpp
index 4a9f3f30..00327a97 100644
--- a/src/Cafe/OS/libs/coreinit/coreinit.cpp
+++ b/src/Cafe/OS/libs/coreinit/coreinit.cpp
@@ -1,6 +1,6 @@
 #include "Cafe/OS/common/OSCommon.h"
 #include "Common/SysAllocator.h"
-#include "Cafe/OS/RPL/rpl.h"
+#include "Cafe/OS/RPL/rpl_symbol_storage.h"
 
 #include "Cafe/OS/libs/coreinit/coreinit_Misc.h"
 
@@ -35,12 +35,12 @@
 #include "Cafe/OS/libs/coreinit/coreinit_MEM_BlockHeap.h"
 #include "Cafe/OS/libs/coreinit/coreinit_MEM_ExpHeap.h"
 
-coreinitData_t* gCoreinitData = NULL;
+CoreinitSharedData* gCoreinitData = nullptr;
 
 sint32 ScoreStackTrace(OSThread_t* thread, MPTR sp)
 {
-	uint32 stackMinAddr = _swapEndianU32(thread->stackEnd);
-	uint32 stackMaxAddr = _swapEndianU32(thread->stackBase);
+	uint32 stackMinAddr = thread->stackEnd.GetMPTR();
+	uint32 stackMaxAddr = thread->stackBase.GetMPTR();
 
 	sint32 score = 0;
 	uint32 currentStackPtr = sp;
@@ -69,7 +69,7 @@ sint32 ScoreStackTrace(OSThread_t* thread, MPTR sp)
 	return score;
 }
 
-void DebugLogStackTrace(OSThread_t* thread, MPTR sp)
+void DebugLogStackTrace(OSThread_t* thread, MPTR sp, bool printSymbols)
 {
 	// sp might not point to a valid stackframe
 	// scan stack and evaluate which sp is most likely the beginning of the stackframe
@@ -95,8 +95,8 @@ void DebugLogStackTrace(OSThread_t* thread, MPTR sp)
 
 	// print stack trace
 	uint32 currentStackPtr = highestScoreSP;
-	uint32 stackMinAddr = _swapEndianU32(thread->stackEnd);
-	uint32 stackMaxAddr = _swapEndianU32(thread->stackBase);
+	uint32 stackMinAddr = thread->stackEnd.GetMPTR();
+	uint32 stackMaxAddr = thread->stackBase.GetMPTR();
 	for (sint32 i = 0; i < 20; i++)
 	{
 		uint32 nextStackPtr = memory_readU32(currentStackPtr);
@@ -107,25 +107,20 @@ void DebugLogStackTrace(OSThread_t* thread, MPTR sp)
 
 		uint32 returnAddress = 0;
 		returnAddress = memory_readU32(nextStackPtr + 4);
-		cemuLog_log(LogType::Force, fmt::format("SP {0:08x} ReturnAddr {1:08x}", nextStackPtr, returnAddress));
+
+		RPLStoredSymbol* symbol = nullptr;
+		if(printSymbols)
+			symbol = rplSymbolStorage_getByClosestAddress(returnAddress);
+
+		if(symbol)
+			cemuLog_log(LogType::Force, fmt::format("SP {:08x} ReturnAddr {:08x}   ({}.{}+0x{:x})", nextStackPtr, returnAddress, (const char*)symbol->libName, (const char*)symbol->symbolName, returnAddress - symbol->address));
+		else
+			cemuLog_log(LogType::Force, fmt::format("SP {:08x} ReturnAddr {:08x}", nextStackPtr, returnAddress));
 
 		currentStackPtr = nextStackPtr;
 	}
 }
 
-void coreinitExport_OSPanic(PPCInterpreter_t* hCPU)
-{
-	debug_printf("OSPanic!\n");
-	debug_printf("File: %s:%d\n", memory_getPointerFromVirtualOffset(hCPU->gpr[3]), hCPU->gpr[4]);
-	debug_printf("Msg: %s\n", memory_getPointerFromVirtualOffset(hCPU->gpr[5]));
-	DebugLogStackTrace(coreinit::OSGetCurrentThread(), coreinit::OSGetStackPointer());
-#ifndef PUBLIC_RELEASE
-	assert_dbg();
-	while (true) std::this_thread::sleep_for(std::chrono::milliseconds(100));
-#endif
-	osLib_returnFromFunction(hCPU, 0);
-}
-
 typedef struct
 {
 	/* +0x00 */ uint32be name;
@@ -175,14 +170,14 @@ void coreinitExport_OSGetSharedData(PPCInterpreter_t* hCPU)
 		}
 	}
 	// some games require a valid result or they will crash, return a pointer to our placeholder font
-	forceLog_printf("OSGetSharedData() called by game but no shareddata fonts loaded. Use placeholder font");
+	cemuLog_log(LogType::Force, "OSGetSharedData() called by game but no shareddata fonts loaded. Use placeholder font");
 	if (placeholderFont == MPTR_NULL)
 	{
 		// load and then return placeholder font
 		uint8* placeholderFontPtr = extractCafeDefaultFont(&placeholderFontSize);
 		placeholderFont = coreinit_allocFromSysArea(placeholderFontSize, 256);
 		if (placeholderFont == MPTR_NULL)
-			forceLog_printf("Failed to alloc placeholder font sys memory");
+			cemuLog_log(LogType::Force, "Failed to alloc placeholder font sys memory");
 		memcpy(memory_getPointerFromVirtualOffset(placeholderFont), placeholderFontPtr, placeholderFontSize);
 		free(placeholderFontPtr);
 	}
@@ -192,32 +187,11 @@ void coreinitExport_OSGetSharedData(PPCInterpreter_t* hCPU)
 	osLib_returnFromFunction(hCPU, 1);
 }
 
-typedef struct
-{
-	MPTR getDriverName;
-	MPTR ukn04;
-	MPTR onAcquiredForeground;
-	MPTR onReleaseForeground;
-	MPTR ukn10;
-}OSDriverCallbacks_t;
-
-void coreinitExport_OSDriver_Register(PPCInterpreter_t* hCPU)
-{
-#ifndef PUBLIC_RELEASE
-	forceLog_printf("OSDriver_Register(0x%08x,0x%08x,0x%08x,0x%08x,0x%08x,0x%08x)", hCPU->gpr[3], hCPU->gpr[4], hCPU->gpr[5], hCPU->gpr[6], hCPU->gpr[7], hCPU->gpr[8]);
-#endif
-	OSDriverCallbacks_t* driverCallbacks = (OSDriverCallbacks_t*)memory_getPointerFromVirtualOffset(hCPU->gpr[5]);
-
-	// todo
-
-	osLib_returnFromFunction(hCPU, 0);
-}
-
 namespace coreinit
 {
 	sint32 OSGetCoreId()
 	{
-		return PPCInterpreter_getCoreIndex(ppcInterpreterCurrentInstance);
+		return PPCInterpreter_getCoreIndex(PPCInterpreter_getCurrentInstance());
 	}
 
 	uint32 OSGetCoreCount()
@@ -230,6 +204,11 @@ namespace coreinit
 		return 0;
 	}
 
+	uint32 OSIsDebuggerPresent()
+	{
+		return 0;
+	}
+
 	uint32 OSGetConsoleType()
 	{
 		return 0x03000050;
@@ -247,12 +226,12 @@ namespace coreinit
 
 	uint32 OSGetStackPointer()
 	{
-		return ppcInterpreterCurrentInstance->gpr[1];
+		return PPCInterpreter_getCurrentInstance()->gpr[1];
 	}
 
 	void coreinitExport_ENVGetEnvironmentVariable(PPCInterpreter_t* hCPU)
 	{
-		forceLogDebug_printf("ENVGetEnvironmentVariable(\"%s\",0x08x,0x%x)\n", (char*)memory_getPointerFromVirtualOffset(hCPU->gpr[3]), hCPU->gpr[4], hCPU->gpr[5]);
+		cemuLog_logDebug(LogType::Force, "ENVGetEnvironmentVariable(\"{}\",0x08x,0x{:x})", (char*)memory_getPointerFromVirtualOffset(hCPU->gpr[3]), hCPU->gpr[4], hCPU->gpr[5]);
 		char* envKeyStr = (char*)memory_getPointerFromVirtualOffset(hCPU->gpr[3]);
 		char* outputString = (char*)memory_getPointerFromVirtualOffset(hCPU->gpr[4]);
 		sint32 outputStringMaxLen = (sint32)hCPU->gpr[5];
@@ -266,7 +245,8 @@ namespace coreinit
 
 	void coreinit_exit(uint32 r)
 	{
-		forceLog_printf("coreinit.exit(%d)", r);
+		cemuLog_log(LogType::Force, "The title terminated the process by calling coreinit.exit({})", (sint32)r);
+        DebugLogStackTrace(coreinit::OSGetCurrentThread(), coreinit::OSGetStackPointer());
 		cemu_assert_debug(false);
 		// never return
 		while (true) std::this_thread::sleep_for(std::chrono::milliseconds(100));
@@ -279,22 +259,34 @@ namespace coreinit
 
 	uint32 OSGetBootPMFlags()
 	{
-		forceLogDebug_printf("OSGetBootPMFlags() - placeholder");
+		cemuLog_logDebug(LogType::Force, "OSGetBootPMFlags() - placeholder");
 		return 0;
 	}
 
 	uint32 OSGetSystemMode()
 	{
-		forceLogDebug_printf("OSGetSystemMode() - placeholder");
+		cemuLog_logDebug(LogType::Force, "OSGetSystemMode() - placeholder");
 		// if this returns 2, barista softlocks shortly after boot
 		return 0;
 	}
 
+	void OSPanic(const char* file, sint32 lineNumber, const char* msg)
+	{
+		cemuLog_log(LogType::Force, "OSPanic!");
+		cemuLog_log(LogType::Force, "File: {}:{}", file, lineNumber);
+		cemuLog_log(LogType::Force, "Msg: {}", msg);
+		DebugLogStackTrace(coreinit::OSGetCurrentThread(), coreinit::OSGetStackPointer());
+#ifdef CEMU_DEBUG_ASSERT
+		while (true) std::this_thread::sleep_for(std::chrono::milliseconds(100));
+#endif
+	}
+
 	void InitializeCore()
 	{
 		cafeExportRegister("coreinit", OSGetCoreId, LogType::CoreinitThread);
 		cafeExportRegister("coreinit", OSGetCoreCount, LogType::CoreinitThread);
 		cafeExportRegister("coreinit", OSIsDebuggerInitialized, LogType::CoreinitThread);
+		cafeExportRegister("coreinit", OSIsDebuggerPresent, LogType::CoreinitThread);
 		cafeExportRegister("coreinit", OSGetConsoleType, LogType::CoreinitThread);
 		cafeExportRegister("coreinit", OSGetMainCoreId, LogType::CoreinitThread);
 		cafeExportRegister("coreinit", OSIsMainCore, LogType::CoreinitThread);
@@ -306,6 +298,8 @@ namespace coreinit
 		cafeExportRegister("coreinit", OSIsOffBoot, LogType::CoreinitThread);
 		cafeExportRegister("coreinit", OSGetBootPMFlags, LogType::CoreinitThread);
 		cafeExportRegister("coreinit", OSGetSystemMode, LogType::CoreinitThread);
+
+		cafeExportRegister("coreinit", OSPanic, LogType::Placeholder);
 	}
 };
 
@@ -316,8 +310,8 @@ void coreinit_load()
 	coreinit::InitializeSysHeap();
 
 	// allocate coreinit global data
-	gCoreinitData = (coreinitData_t*)memory_getPointerFromVirtualOffset(coreinit_allocFromSysArea(sizeof(coreinitData_t), 32));
-	memset(gCoreinitData, 0x00, sizeof(coreinitData_t));
+	gCoreinitData = (CoreinitSharedData*)memory_getPointerFromVirtualOffset(coreinit_allocFromSysArea(sizeof(CoreinitSharedData), 32));
+	memset(gCoreinitData, 0x00, sizeof(CoreinitSharedData));
 
 	// coreinit weak links
 	osLib_addVirtualPointer("coreinit", "MEMAllocFromDefaultHeap", memory_getVirtualOffsetFromPointer(&gCoreinitData->MEMAllocFromDefaultHeap));
@@ -360,10 +354,11 @@ void coreinit_load()
 	coreinit::InitializeMessageQueue();
 	coreinit::InitializeIPC();
 	coreinit::InitializeIPCBuf();
+	coreinit::InitializeMemoryMapping();
 	coreinit::InitializeCodeGen();
 	coreinit::InitializeCoroutine();
 	coreinit::InitializeOSScreen();
-
+	
 	// legacy mem stuff
 	coreinit::expheap_load();
 
@@ -371,7 +366,6 @@ void coreinit_load()
 	coreinit::miscInit();
 	osLib_addFunction("coreinit", "OSGetSharedData", coreinitExport_OSGetSharedData);
 	osLib_addFunction("coreinit", "UCReadSysConfig", coreinitExport_UCReadSysConfig);
-	osLib_addFunction("coreinit", "OSDriver_Register", coreinitExport_OSDriver_Register);
 
 	// async callbacks
 	InitializeAsyncCallback();
diff --git a/src/Cafe/OS/libs/coreinit/coreinit.h b/src/Cafe/OS/libs/coreinit/coreinit.h
index 046ffe1e..74aab9b2 100644
--- a/src/Cafe/OS/libs/coreinit/coreinit.h
+++ b/src/Cafe/OS/libs/coreinit/coreinit.h
@@ -16,8 +16,7 @@ void coreinitAsyncCallback_addWithLock(MPTR functionMPTR, uint32 numParameters,
 void coreinit_load();
 
 // coreinit shared memory
-
-typedef struct  
+struct CoreinitSharedData
 {
 	MEMPTR<void> MEMAllocFromDefaultHeap;
 	MEMPTR<void> MEMAllocFromDefaultHeapEx;
@@ -26,11 +25,9 @@ typedef struct
 	MPTR __cpp_exception_init_ptr;
 	MPTR __cpp_exception_cleanup_ptr;
 	MPTR __stdio_cleanup;
-}coreinitData_t;
+};
 
-extern coreinitData_t* gCoreinitData;
-
-#include "Cafe/OS/libs/coreinit/coreinit_Spinlock.h"
+extern CoreinitSharedData* gCoreinitData;
 
 // coreinit init
 void coreinit_start(PPCInterpreter_t* hCPU);
diff --git a/src/Cafe/OS/libs/coreinit/coreinit_Alarm.cpp b/src/Cafe/OS/libs/coreinit/coreinit_Alarm.cpp
index a498e40a..ae2d1e63 100644
--- a/src/Cafe/OS/libs/coreinit/coreinit_Alarm.cpp
+++ b/src/Cafe/OS/libs/coreinit/coreinit_Alarm.cpp
@@ -70,7 +70,7 @@ namespace coreinit
 				return;
 
 			// debug begin
-#ifndef PUBLIC_RELEASE
+#ifdef CEMU_DEBUG_ASSERT
 			uint64 prevTick = 0;
 			auto itr = g_activeAlarmList.begin();
 			while (itr != g_activeAlarmList.end())
@@ -117,6 +117,12 @@ namespace coreinit
 			return currentTick >= g_soonestAlarm;
 		}
 
+        static void Reset()
+        {
+            g_activeAlarmList.clear();
+            g_soonestAlarm = 0;
+        }
+
 	public:
 		struct ComparatorFireTime
 		{
@@ -160,7 +166,7 @@ namespace coreinit
 	void alarm_update()
 	{	
 		cemu_assert_debug(!__OSHasSchedulerLock());
-		uint64 currentTick = coreinit::coreinit_getOSTime();
+		uint64 currentTick = coreinit::OSGetTime();
 		if (!OSHostAlarm::quickCheckForAlarm(currentTick))
 			return;
 		__OSLockScheduler();
@@ -176,12 +182,11 @@ namespace coreinit
 		alarm->setMagic();
 	}
 
-	void coreinitExport_OSCreateAlarmEx(PPCInterpreter_t* hCPU)
+	void OSCreateAlarmEx(OSAlarm_t* alarm, const char* alarmName)
 	{
-		OSAlarm_t* OSAlarm = (OSAlarm_t*)memory_getPointerFromVirtualOffset(hCPU->gpr[3]);
-		OSCreateAlarm(OSAlarm);
-		OSAlarm->name = _swapEndianU32(hCPU->gpr[4]);
-		osLib_returnFromFunction(hCPU, 0);
+		memset(alarm, 0, sizeof(OSAlarm_t));
+		alarm->setMagic();
+		alarm->name = alarmName;
 	}
 
 	std::unordered_map<OSAlarm_t*, OSHostAlarm*> g_activeAlarms;
@@ -212,6 +217,7 @@ namespace coreinit
 
 	void __OSInitiateAlarm(OSAlarm_t* alarm, uint64 startTime, uint64 period, MPTR handlerFunc, bool isPeriodic)
 	{
+        cemu_assert_debug(MMU_IsInPPCMemorySpace(alarm));
 		cemu_assert_debug(__OSHasSchedulerLock());
 
 		uint64 nextTime = startTime;
@@ -227,7 +233,7 @@ namespace coreinit
 			if (period == 0)
 				return;
 
-			uint64 currentTime = coreinit_getOSTime();
+			uint64 currentTime = OSGetTime();
 
 			uint64 ticksSinceStart = currentTime - startTime;
 			uint64 numPeriods = ticksSinceStart / period;
@@ -250,7 +256,7 @@ namespace coreinit
 		if (existingAlarmItr != g_activeAlarms.end())
 		{
 			// delete existing alarm
-			forceLogDebug_printf("__OSInitiateAlarm() called on alarm which was already active");
+			cemuLog_logDebug(LogType::Force, "__OSInitiateAlarm() called on alarm which was already active");
 			OSHostAlarmDestroy(existingAlarmItr->second);
 			g_activeAlarms.erase(existingAlarmItr);
 		}
@@ -261,7 +267,7 @@ namespace coreinit
 	void OSSetAlarm(OSAlarm_t* alarm, uint64 delayInTicks, MPTR handlerFunc)
 	{
 		__OSLockScheduler();
-		__OSInitiateAlarm(alarm, coreinit_getOSTime() + delayInTicks, 0, handlerFunc, false);
+		__OSInitiateAlarm(alarm, OSGetTime() + delayInTicks, 0, handlerFunc, false);
 		__OSUnlockScheduler();
 	}
 
@@ -274,21 +280,29 @@ namespace coreinit
 
 	void OSSetAlarmUserData(OSAlarm_t* alarm, uint32 userData)
 	{
-		alarm->userData = _swapEndianU32(userData);
+		alarm->userData = userData;
 	}
 
-	void coreinitExport_OSGetAlarmUserData(PPCInterpreter_t* hCPU)
+	uint32 OSGetAlarmUserData(OSAlarm_t* alarm)
 	{
-		OSAlarm_t* OSAlarmBE = (OSAlarm_t*)memory_getPointerFromVirtualOffset(hCPU->gpr[3]);
-		MPTR userData = _swapEndianU32(OSAlarmBE->userData);
-		osLib_returnFromFunction(hCPU, userData);
+		return alarm->userData;
 	}
 
-	void OSAlarm_resetAll()
+	void OSAlarm_Shutdown()
 	{
-		cemu_assert_debug(g_activeAlarms.empty());
-
-		cemu_assert_debug(false);
+        __OSLockScheduler();
+        if(g_activeAlarms.empty())
+        {
+            __OSUnlockScheduler();
+            return;
+        }
+        for(auto& itr : g_activeAlarms)
+        {
+            OSHostAlarmDestroy(itr.second);
+        }
+        g_activeAlarms.clear();
+        OSHostAlarm::Reset();
+        __OSUnlockScheduler();
 	}
 
 	void _OSAlarmThread(PPCInterpreter_t* hCPU)
@@ -296,7 +310,7 @@ namespace coreinit
 		while( true )
 		{
 			OSWaitEvent(g_alarmEvent.GetPtr());
-			uint64 currentTick = coreinit_getOSTime();
+			uint64 currentTick = OSGetTime();
 			while (true)
 			{
 				// get alarm to fire
@@ -337,15 +351,13 @@ namespace coreinit
 
 	void InitializeAlarm()
 	{
-		cafeExportRegister("coreinit", OSCreateAlarm, LogType::Placeholder);
-		cafeExportRegister("coreinit", OSCancelAlarm, LogType::Placeholder);
-		cafeExportRegister("coreinit", OSSetAlarm, LogType::Placeholder);
-		cafeExportRegister("coreinit", OSSetPeriodicAlarm, LogType::Placeholder);
-
-		cafeExportRegister("coreinit", OSSetAlarmUserData, LogType::Placeholder);
-
-		osLib_addFunction("coreinit", "OSCreateAlarmEx", coreinitExport_OSCreateAlarmEx);
-		osLib_addFunction("coreinit", "OSGetAlarmUserData", coreinitExport_OSGetAlarmUserData);
+		cafeExportRegister("coreinit", OSCreateAlarm, LogType::CoreinitAlarm);
+		cafeExportRegister("coreinit", OSCreateAlarmEx, LogType::CoreinitAlarm);
+		cafeExportRegister("coreinit", OSCancelAlarm, LogType::CoreinitAlarm);
+		cafeExportRegister("coreinit", OSSetAlarm, LogType::CoreinitAlarm);
+		cafeExportRegister("coreinit", OSSetPeriodicAlarm, LogType::CoreinitAlarm);
+		cafeExportRegister("coreinit", OSSetAlarmUserData, LogType::CoreinitAlarm);
+		cafeExportRegister("coreinit", OSGetAlarmUserData, LogType::CoreinitAlarm);
 
 		// init event
 		OSInitEvent(g_alarmEvent.GetPtr(), OSEvent::EVENT_STATE::STATE_NOT_SIGNALED, OSEvent::EVENT_MODE::MODE_AUTO);
diff --git a/src/Cafe/OS/libs/coreinit/coreinit_Alarm.h b/src/Cafe/OS/libs/coreinit/coreinit_Alarm.h
index 717ecc90..472d4f21 100644
--- a/src/Cafe/OS/libs/coreinit/coreinit_Alarm.h
+++ b/src/Cafe/OS/libs/coreinit/coreinit_Alarm.h
@@ -3,7 +3,6 @@
 
 namespace coreinit
 {
-
 	class OSHostAlarm;
 	OSHostAlarm* OSHostAlarmCreate(uint64 nextFire, uint64 period, void(*callbackFunc)(uint64 currentTick, void* context), void* context);
 	void OSHostAlarmDestroy(OSHostAlarm* hostAlarm);
@@ -11,7 +10,7 @@ namespace coreinit
 	struct OSAlarm_t
 	{
 		/* +0x00 */ betype<uint32>  magic;
-		/* +0x04 */ MPTR_UINT8      name;
+		/* +0x04 */ MEMPTR<const char> name;
 		/* +0x08 */ uint32	        ukn08;
 		/* +0x0C */ MPTR			handler;
 		/* +0x10 */ uint32          ukn10;
@@ -21,7 +20,7 @@ namespace coreinit
 		/* +0x24 */ MPTR			next; // pointer to OSAlarm
 		/* +0x28 */ uint64          period; // period (zero for non-periodic timer)
 		/* +0x30 */ uint64          startTime; // period start
-		/* +0x38 */ MPTR            userData;
+		/* +0x38 */ uint32be        userData;
 		/* +0x3C */ uint32		    ukn3C;
 		/* +0x40 */ OSThreadQueue   uknThreadQueue;
 		/* +0x50 */ MPTR			alarmQueue;
@@ -46,7 +45,7 @@ namespace coreinit
 	void OSSetAlarmUserData(OSAlarm_t* alarm, uint32 userData);
 	void OSSetPeriodicAlarm(OSAlarm_t* OSAlarm, uint64 startTick, uint64 periodTick, MPTR OSAlarmHandler);
 
-	void OSAlarm_resetAll();
+	void OSAlarm_Shutdown();
 
 	void alarm_update();
 
diff --git a/src/Cafe/OS/libs/coreinit/coreinit_Atomic.cpp b/src/Cafe/OS/libs/coreinit/coreinit_Atomic.cpp
index 6ac781c0..accce552 100644
--- a/src/Cafe/OS/libs/coreinit/coreinit_Atomic.cpp
+++ b/src/Cafe/OS/libs/coreinit/coreinit_Atomic.cpp
@@ -33,10 +33,11 @@ namespace coreinit
 
 	uint32 OSAddAtomic(std::atomic<uint32be>* mem, uint32 adder)
 	{
+        // used by SDL Wii U port
 		uint32be knownValue;
 		while (true)
 		{
-			uint32be knownValue = mem->load();
+			knownValue = mem->load();
 			uint32be newValue = knownValue + adder;
 			if (mem->compare_exchange_strong(knownValue, newValue))
 				break;
@@ -68,7 +69,7 @@ namespace coreinit
 		uint64be knownValue;
 		while (true)
 		{
-			uint64be knownValue = mem->load();
+			knownValue = mem->load();
 			uint64be newValue = knownValue + adder;
 			if (mem->compare_exchange_strong(knownValue, newValue))
 				break;
@@ -81,7 +82,7 @@ namespace coreinit
 		uint64be knownValue;
 		while (true)
 		{
-			uint64be knownValue = mem->load();
+			knownValue = mem->load();
 			uint64be newValue = knownValue & val;
 			if (mem->compare_exchange_strong(knownValue, newValue))
 				break;
@@ -94,7 +95,7 @@ namespace coreinit
 		uint64be knownValue;
 		while (true)
 		{
-			uint64be knownValue = mem->load();
+			knownValue = mem->load();
 			uint64be newValue = knownValue | val;
 			if (mem->compare_exchange_strong(knownValue, newValue))
 				break;
diff --git a/src/Cafe/OS/libs/coreinit/coreinit_Callbacks.cpp b/src/Cafe/OS/libs/coreinit/coreinit_Callbacks.cpp
index 403bec61..aef7e5aa 100644
--- a/src/Cafe/OS/libs/coreinit/coreinit_Callbacks.cpp
+++ b/src/Cafe/OS/libs/coreinit/coreinit_Callbacks.cpp
@@ -8,27 +8,27 @@ struct CoreinitAsyncCallback
 
 	static void queue(MPTR functionMPTR, uint32 numParameters, uint32 r3, uint32 r4, uint32 r5, uint32 r6, uint32 r7, uint32 r8, uint32 r9, uint32 r10)
 	{
-		s_asyncCallbackSpinlock.acquire();
+		s_asyncCallbackSpinlock.lock();
 		s_asyncCallbackQueue.emplace_back(allocateAndInitFromPool(functionMPTR, numParameters, r3, r4, r5, r6, r7, r8, r9, r10));
-		s_asyncCallbackSpinlock.release();
+		s_asyncCallbackSpinlock.unlock();
 	}
 
 	static void callNextFromQueue()
 	{
-		s_asyncCallbackSpinlock.acquire();
+		s_asyncCallbackSpinlock.lock();
 		if (s_asyncCallbackQueue.empty())
 		{
 			cemuLog_log(LogType::Force, "AsyncCallbackQueue is empty. Unexpected behavior");
-			s_asyncCallbackSpinlock.release();
+			s_asyncCallbackSpinlock.unlock();
 			return;
 		}
 		CoreinitAsyncCallback* cb = s_asyncCallbackQueue[0];
 		s_asyncCallbackQueue.erase(s_asyncCallbackQueue.begin());
-		s_asyncCallbackSpinlock.release();
+		s_asyncCallbackSpinlock.unlock();
 		cb->doCall();
-		s_asyncCallbackSpinlock.acquire();
+		s_asyncCallbackSpinlock.lock();
 		releaseToPool(cb);
-		s_asyncCallbackSpinlock.release();
+		s_asyncCallbackSpinlock.unlock();
 	}
 
 private:
@@ -39,7 +39,7 @@ private:
 	
 	static CoreinitAsyncCallback* allocateAndInitFromPool(MPTR functionMPTR, uint32 numParameters, uint32 r3, uint32 r4, uint32 r5, uint32 r6, uint32 r7, uint32 r8, uint32 r9, uint32 r10)
 	{
-		cemu_assert_debug(s_asyncCallbackSpinlock.isHolding());
+		cemu_assert_debug(s_asyncCallbackSpinlock.is_locked());
 		if (s_asyncCallbackPool.empty())
 		{
 			CoreinitAsyncCallback* cb = new CoreinitAsyncCallback(functionMPTR, numParameters, r3, r4, r5, r6, r7, r8, r9, r10);
@@ -54,7 +54,7 @@ private:
 
 	static void releaseToPool(CoreinitAsyncCallback* cb)
 	{
-		cemu_assert_debug(s_asyncCallbackSpinlock.isHolding());
+		cemu_assert_debug(s_asyncCallbackSpinlock.is_locked());
 		s_asyncCallbackPool.emplace_back(cb);
 	}
 
diff --git a/src/Cafe/OS/libs/coreinit/coreinit_CodeGen.cpp b/src/Cafe/OS/libs/coreinit/coreinit_CodeGen.cpp
index 31b184d8..f0e0bd80 100644
--- a/src/Cafe/OS/libs/coreinit/coreinit_CodeGen.cpp
+++ b/src/Cafe/OS/libs/coreinit/coreinit_CodeGen.cpp
@@ -129,7 +129,7 @@ namespace coreinit
 	{
 		if (!_avoidCodeGenJIT)
 		{
-			forceLog_printf("Disable JIT on dynamic code area");
+			cemuLog_log(LogType::Force, "Disable JIT on dynamic code area");
 		}
 		_avoidCodeGenJIT = true; // this function getting called is usually a sign that 
 		// does this have a return value?
@@ -145,4 +145,4 @@ namespace coreinit
 
 		cafeExportRegister("coreinit", OSSwitchSecCodeGenMode, LogType::Placeholder);
 	}
-}
\ No newline at end of file
+}
diff --git a/src/Cafe/OS/libs/coreinit/coreinit_Coroutine.cpp b/src/Cafe/OS/libs/coreinit/coreinit_Coroutine.cpp
index b1f4abb7..49c46831 100644
--- a/src/Cafe/OS/libs/coreinit/coreinit_Coroutine.cpp
+++ b/src/Cafe/OS/libs/coreinit/coreinit_Coroutine.cpp
@@ -3,9 +3,13 @@
 #include "Cafe/HW/Espresso/PPCState.h"
 #include "Cafe/HW/Espresso/Interpreter/PPCInterpreterInternal.h"
 #include "Cafe/HW/MMU/MMU.h"
+#include "Cafe/OS/RPL/rpl.h"
 
 namespace coreinit
 {
+	static_assert(sizeof(OSCoroutine) == 0x180);
+
+	static uint32 s_PPCAddrOSSwitchCoroutineAfterOSLoadCoroutine = 0;
 
 	void coreinitExport_OSInitCoroutine(PPCInterpreter_t* hCPU)
 	{
@@ -57,14 +61,30 @@ namespace coreinit
 
 	void coreinitExport_OSSwitchCoroutine(PPCInterpreter_t* hCPU)
 	{
-		OSCoroutine* coroutineCurrent = (OSCoroutine*)memory_getPointerFromVirtualOffset(hCPU->gpr[3]);
-		OSCoroutine* coroutineNext = (OSCoroutine*)memory_getPointerFromVirtualOffsetAllowNull(hCPU->gpr[4]);
+		// OSSwitchCoroutine is a wrapper for OSSaveCoroutine + OSLoadCoroutine but it has side effects that we need to care about:
+		// r31 is saved and restored via the stack in OSSwitchCoroutine
+		// r4 is stored in the r31 field of coroutineCurrent. Injustice: Gods Among Us reads the r31 field and expects it to match coroutineCurrent (0x027183D4 @ EU v16)
+		OSCoroutine* coroutineCurrent = MEMPTR<OSCoroutine>(hCPU->gpr[3]);
+		OSCoroutine* coroutineNext = MEMPTR<OSCoroutine>(hCPU->gpr[4]);
+		hCPU->gpr[1] -= 0x10;
+		memory_writeU32(hCPU->gpr[1]+0xC, hCPU->gpr[31]);
+		memory_writeU32(hCPU->gpr[1]+0x14, hCPU->spr.LR);
+		hCPU->spr.LR = s_PPCAddrOSSwitchCoroutineAfterOSLoadCoroutine;
+		hCPU->gpr[31] = hCPU->gpr[4];
 		coreinitCoroutine_OSSaveCoroutine(coroutineCurrent, hCPU);
-		if (coroutineNext != NULL)
-		{
-			coreinitCoroutine_OSLoadCoroutine(coroutineNext, hCPU);
-		}
-		osLib_returnFromFunction(hCPU, 0);
+		hCPU->gpr[3] = hCPU->gpr[31];
+		hCPU->gpr[4] = 1;
+		coreinitCoroutine_OSLoadCoroutine(coroutineNext, hCPU);
+		hCPU->instructionPointer = hCPU->spr.LR;
+	}
+
+	void coreinitExport_OSSwitchCoroutineAfterOSLoadCoroutine(PPCInterpreter_t* hCPU)
+	{
+		// resuming after OSSaveCoroutine
+		hCPU->gpr[31] = memory_readU32(hCPU->gpr[1]+0xC);
+		hCPU->spr.LR = memory_readU32(hCPU->gpr[1]+0x14);
+		hCPU->gpr[1] += 0x10;
+		hCPU->instructionPointer = hCPU->spr.LR;
 	}
 
 	void coreinitExport_OSSwitchFiberEx(PPCInterpreter_t* hCPU)
@@ -96,5 +116,7 @@ namespace coreinit
 		osLib_addFunction("coreinit", "OSInitCoroutine", coreinitExport_OSInitCoroutine);
 		osLib_addFunction("coreinit", "OSSwitchCoroutine", coreinitExport_OSSwitchCoroutine);
 		osLib_addFunction("coreinit", "OSSwitchFiberEx", coreinitExport_OSSwitchFiberEx);
+
+		s_PPCAddrOSSwitchCoroutineAfterOSLoadCoroutine = RPLLoader_MakePPCCallable(coreinitExport_OSSwitchCoroutineAfterOSLoadCoroutine);
 	}
 }
\ No newline at end of file
diff --git a/src/Cafe/OS/libs/coreinit/coreinit_DynLoad.cpp b/src/Cafe/OS/libs/coreinit/coreinit_DynLoad.cpp
index aae17dfe..546501b6 100644
--- a/src/Cafe/OS/libs/coreinit/coreinit_DynLoad.cpp
+++ b/src/Cafe/OS/libs/coreinit/coreinit_DynLoad.cpp
@@ -86,34 +86,32 @@ namespace coreinit
 		}
 		// search for loaded modules with matching name
 		uint32 rplHandle = RPLLoader_GetHandleByModuleName(libName);
-
-		if (rplHandle == RPL_INVALID_HANDLE)
+		if (rplHandle == RPL_INVALID_HANDLE && !RPLLoader_HasDependency(libName))
 		{
 			RPLLoader_AddDependency(libName);
 			RPLLoader_UpdateDependencies();
 			RPLLoader_Link();
 			RPLLoader_CallEntrypoints();
 			rplHandle = RPLLoader_GetHandleByModuleName(libName);
-			if (rplHandle == RPL_INVALID_HANDLE)
-				rplHandle = 0;
 		}
-
-		*moduleHandleOut = rplHandle;
-		// return module not found error code
 		if (rplHandle == RPL_INVALID_HANDLE)
-			return 0xFFFCFFE9;
+			*moduleHandleOut = 0;
+		else
+			*moduleHandleOut = rplHandle;
+		if (rplHandle == RPL_INVALID_HANDLE)
+		{
+			cemuLog_logDebug(LogType::Force, "OSDynLoad_Acquire() failed to load module '{}'", libName);
+			return 0xFFFCFFE9; // module not found
+		}
 		return 0;
 	}
 
-	uint32 OSDynLoad_Release(uint32 moduleHandle)
+	void OSDynLoad_Release(uint32 moduleHandle)
 	{
 		if (moduleHandle == RPL_INVALID_HANDLE)
-			return 0;
+			return;
 		RPLLoader_RemoveDependency(moduleHandle);
 		RPLLoader_UpdateDependencies();
-
-		// this function isn't supposed to return anything, but early versions of Cemu did and Cemuhook (up to 0.5.7.6) now relies on it. We still keep the return value around for compatibility
-		return 0;
 	}
 
 	uint32 OSDynLoad_FindExport(uint32 moduleHandle, uint32 isData, const char* exportName, betype<MPTR>* addrOut)
diff --git a/src/Cafe/OS/libs/coreinit/coreinit_DynLoad.h b/src/Cafe/OS/libs/coreinit/coreinit_DynLoad.h
index 061be002..2a3172c7 100644
--- a/src/Cafe/OS/libs/coreinit/coreinit_DynLoad.h
+++ b/src/Cafe/OS/libs/coreinit/coreinit_DynLoad.h
@@ -2,6 +2,12 @@
 
 namespace coreinit
 {
+	enum class RplEntryReason
+	{
+		Loaded = 1,
+		Unloaded = 2,
+	};
+
 	uint32 OSDynLoad_SetAllocator(MPTR allocFunc, MPTR freeFunc);
 	void OSDynLoad_SetTLSAllocator(MPTR allocFunc, MPTR freeFunc);
 	uint32 OSDynLoad_GetAllocator(betype<MPTR>* funcAlloc, betype<MPTR>* funcFree);
@@ -11,7 +17,7 @@ namespace coreinit
 	void OSDynLoad_AllocatorFree(void* mem);
 
 	uint32 OSDynLoad_Acquire(const char* libName, uint32be* moduleHandleOut);
-	uint32 OSDynLoad_Release(uint32 moduleHandle);
+	void OSDynLoad_Release(uint32 moduleHandle);
 	uint32 OSDynLoad_FindExport(uint32 moduleHandle, uint32 isData, const char* exportName, betype<MPTR>* addrOut);
 
 	void InitializeDynLoad();
diff --git a/src/Cafe/OS/libs/coreinit/coreinit_FG.cpp b/src/Cafe/OS/libs/coreinit/coreinit_FG.cpp
index 4b716373..e22c3eb3 100644
--- a/src/Cafe/OS/libs/coreinit/coreinit_FG.cpp
+++ b/src/Cafe/OS/libs/coreinit/coreinit_FG.cpp
@@ -55,19 +55,18 @@ namespace coreinit
 	{
 		// return full size of foreground bucket area
 		if (offset)
-			*offset = MEMPTR<void>{ (uint32)MEMORY_FGBUCKET_AREA_ADDR };
+			*offset = { (MPTR)MEMORY_FGBUCKET_AREA_ADDR };
 		if (size)
 			*size = MEMORY_FGBUCKET_AREA_SIZE;
 		// return true if in foreground
 		return true;
 	}
 
-	bool OSGetForegroundBucketFreeArea(MPTR* offset, MPTR* size)
+	bool OSGetForegroundBucketFreeArea(MEMPTR<void>* offset, uint32be* size)
 	{
 		uint8* freeAreaAddr = GetFGMemByArea(FG_BUCKET_AREA_FREE).GetPtr();
-
-		*offset = _swapEndianU32(memory_getVirtualOffsetFromPointer(freeAreaAddr));
-		*size = _swapEndianU32(FG_BUCKET_AREA_FREE_SIZE);
+		*offset = freeAreaAddr;
+		*size = FG_BUCKET_AREA_FREE_SIZE;
 		// return true if in foreground
 		return (fgAddr != nullptr);
 	}
@@ -82,15 +81,6 @@ namespace coreinit
 		osLib_returnFromFunction(hCPU, r ? 1 : 0);
 	}
 
-	void coreinitExport_OSGetForegroundBucketFreeArea(PPCInterpreter_t* hCPU)
-	{
-		debug_printf("OSGetForegroundBucketFreeArea(0x%x,0x%x)\n", hCPU->gpr[3], hCPU->gpr[4]);
-		ppcDefineParamMPTR(areaOutput, 0);
-		ppcDefineParamMPTR(areaSize, 1);
-		bool r = OSGetForegroundBucketFreeArea((MPTR*)memory_getPointerFromVirtualOffsetAllowNull(areaOutput), (MPTR*)memory_getPointerFromVirtualOffsetAllowNull(areaSize));
-		osLib_returnFromFunction(hCPU, r ? 1 : 0);
-	}
-
 	void InitForegroundBucket()
 	{
 		uint32be fgSize;
@@ -184,7 +174,7 @@ namespace coreinit
 
 	void coreinitExport_OSCopyFromClipboard(PPCInterpreter_t* hCPU)
 	{
-		forceLogDebug_printf("OSCopyFromClipboard(0x%x,0x%x)\n", hCPU->gpr[3], hCPU->gpr[4]);
+		cemuLog_logDebug(LogType::Force, "OSCopyFromClipboard(0x{:x},0x{:x})", hCPU->gpr[3], hCPU->gpr[4]);
 		ppcDefineParamMEMPTR(buffer, void, 0);
 		ppcDefineParamMEMPTR(size, uint32be, 1);
 		bool r = OSCopyFromClipboard(buffer.GetPtr(), size.GetPtr());
@@ -194,7 +184,8 @@ namespace coreinit
 	void InitializeFG()
 	{
 		osLib_addFunction("coreinit", "OSGetForegroundBucket", coreinitExport_OSGetForegroundBucket);
-		osLib_addFunction("coreinit", "OSGetForegroundBucketFreeArea", coreinitExport_OSGetForegroundBucketFreeArea);
+		cafeExportRegister("coreinit", OSGetForegroundBucket, LogType::CoreinitMem);
+		cafeExportRegister("coreinit", OSGetForegroundBucketFreeArea, LogType::CoreinitMem);
 		osLib_addFunction("coreinit", "OSCopyFromClipboard", coreinitExport_OSCopyFromClipboard);
 	}
 }
diff --git a/src/Cafe/OS/libs/coreinit/coreinit_FG.h b/src/Cafe/OS/libs/coreinit/coreinit_FG.h
index 846001b9..0c2a3ee3 100644
--- a/src/Cafe/OS/libs/coreinit/coreinit_FG.h
+++ b/src/Cafe/OS/libs/coreinit/coreinit_FG.h
@@ -9,7 +9,7 @@ namespace coreinit
 	bool __OSResizeCopyData(sint32 length);
 
 	bool OSGetForegroundBucket(MEMPTR<void>* offset, uint32be* size);
-	bool OSGetForegroundBucketFreeArea(MPTR* offset, MPTR* size);
+	bool OSGetForegroundBucketFreeArea(MEMPTR<void>* offset, uint32be* size);
 
 	void InitForegroundBucket();
 
diff --git a/src/Cafe/OS/libs/coreinit/coreinit_FS.cpp b/src/Cafe/OS/libs/coreinit/coreinit_FS.cpp
index 1598429f..12ddb8df 100644
--- a/src/Cafe/OS/libs/coreinit/coreinit_FS.cpp
+++ b/src/Cafe/OS/libs/coreinit/coreinit_FS.cpp
@@ -1,3 +1,4 @@
+#include <OS/RPL/rpl.h>
 #include "config/ActiveSettings.h"
 #include "Cafe/OS/libs/coreinit/coreinit_SystemInfo.h"
 #include "Cafe/OS/common/OSCommon.h"
@@ -9,12 +10,15 @@
 #include "Cafe/IOSU/iosu_ipc_common.h"
 #include "coreinit_IPC.h"
 #include "Cafe/Filesystem/fsc.h"
+#include "coreinit_IPCBuf.h"
+#include "Cafe/CafeSystem.h"
+#include "Cafe/TitleList/TitleInfo.h"
 
-#define FS_CB_PLACEHOLDER_FINISHCMD	(MPTR)(0xF122330E)
+#define FS_CB_PLACEHOLDER_FINISHCMD (MPTR)(0xF122330E)
 
 // return false if src+'\0' does not fit into dst
 template<std::size_t Size>
-bool strcpy_whole(char(&dst)[Size], const char* src)
+bool strcpy_whole(char (&dst)[Size], const char* src)
 {
 	size_t inputLength = strlen(src);
 	if ((inputLength + 1) > Size)
@@ -40,20 +44,19 @@ bool strcpy_whole(char* dst, size_t dstLength, const char* src)
 
 namespace coreinit
 {
-	std::mutex sFSClientLock;
-	std::recursive_mutex sFSGlobalMutex;
+	SysAllocator<OSMutex> s_fsGlobalMutex;
 
 	inline void FSLockMutex()
 	{
-		sFSGlobalMutex.lock();
+		OSLockMutex(&s_fsGlobalMutex);
 	}
 
 	inline void FSUnlockMutex()
 	{
-		sFSGlobalMutex.unlock();
+		OSUnlockMutex(&s_fsGlobalMutex);
 	}
 
-	void _debugVerifyCommand(const char* stage, FSCmdBlockBody_t* fsCmdBlockBody);
+	void _debugVerifyCommand(const char* stage, FSCmdBlockBody* fsCmdBlockBody);
 
 	bool sFSInitialized = true; // this should be false but it seems like some games rely on FSInit being called before main()? Twilight Princess for example reads files before it calls FSInit
 	bool sFSShutdown = false;
@@ -64,30 +67,24 @@ namespace coreinit
 		// 1 = usb?
 	};
 
-	struct FS_MOUNT_SOURCE 
+	struct FS_MOUNT_SOURCE
 	{
 		uint32be sourceType; // ukn values
-		char path[128]; // todo - determine correct length
+		char path[128];		 // todo - determine correct length
 	};
 
 	FS_RESULT FSGetMountSourceNext(FSClient_t* fsClient, FSCmdBlock_t* fsCmdBlock, MOUNT_TYPE mountSourceType, FS_MOUNT_SOURCE* mountSourceInfo, FS_ERROR_MASK errMask)
 	{
-		// hacky
-		static FS_MOUNT_SOURCE* s_last_source = nullptr;
-		if(s_last_source != mountSourceInfo)
+		if (mountSourceType == MOUNT_TYPE::SD)
 		{
-			s_last_source = mountSourceInfo;
-			fsCmdBlock->data.mount_it = 0;
+			// This function is supposed to be called after an initial FSGetMountSource call => always returns FS_RESULT::END_ITERATION because we only have one SD Card
+			// It *might* causes issues if this function is called for getting the first MountSource (instead of "FSGetMountSource")
+			cemu_assert_suspicious();
+			return FS_RESULT::END_ITERATION;
 		}
-
-		fsCmdBlock->data.mount_it++;
-		
-		// SD
-		if (mountSourceType == MOUNT_TYPE::SD && fsCmdBlock->data.mount_it == 1)
+		else
 		{
-			mountSourceInfo->sourceType = 0;
-			strcpy(mountSourceInfo->path, "/sd");
-			return FS_RESULT::SUCCESS;
+			cemu_assert_unimplemented();
 		}
 
 		return FS_RESULT::END_ITERATION;
@@ -95,7 +92,28 @@ namespace coreinit
 
 	FS_RESULT FSGetMountSource(FSClient_t* fsClient, FSCmdBlock_t* fsCmdBlock, MOUNT_TYPE mountSourceType, FS_MOUNT_SOURCE* mountSourceInfo, FS_ERROR_MASK errMask)
 	{
-		return FSGetMountSourceNext(fsClient, fsCmdBlock, mountSourceType, mountSourceInfo, errMask);
+		// This implementation is simplified A LOT compared to what the Wii U is actually doing. On Cemu we expect to only have one mountable source (SD Card) anyway,
+		// so we can just hard code it. Other mount types are not (yet) supported.
+		if (mountSourceType == MOUNT_TYPE::SD)
+		{
+			// check for SD card permissions (from cos.xml)
+			// One Piece relies on failing here, otherwise it will call FSGetMountSource in an infinite loop
+			CosCapabilityBitsFS perms = static_cast<CosCapabilityBitsFS>(CafeSystem::GetForegroundTitleCosCapabilities(CosCapabilityGroup::FS));
+			if(!HAS_FLAG(perms, CosCapabilityBitsFS::SDCARD_MOUNT))
+			{
+				cemuLog_logOnce(LogType::Force, "Title is trying to access SD card mount info without having SD card permissions. This may not be a bug");
+				return FS_RESULT::END_ITERATION;
+			}
+			mountSourceInfo->sourceType = 0;
+			strcpy(mountSourceInfo->path, "/sd");
+			return FS_RESULT::SUCCESS;
+		}
+		else
+		{
+			cemu_assert_unimplemented();
+		}
+
+		return FS_RESULT::END_ITERATION;
 	}
 
 	bool _sdCard01Mounted = false;
@@ -107,7 +125,7 @@ namespace coreinit
 			return;
 
 		std::error_code ec;
-		const auto path = ActiveSettings::GetPath("sdcard/");
+		const auto path = ActiveSettings::GetUserDataPath("sdcard/");
 		fs::create_directories(path, ec);
 		FSCDeviceHostFS_Mount("/vol/external01", _pathToUtf8(path), FSC_PRIORITY_BASE);
 
@@ -135,18 +153,20 @@ namespace coreinit
 
 	FS_RESULT FSBindMount(FSClient_t* fsClient, FSCmdBlock_t* fsCmdBlock, char* mountPathSrc, char* mountPathOut, FS_ERROR_MASK errMask)
 	{
-		if (strcmp(mountPathSrc, "/dev/sdcard01") == 0) {
+		if (strcmp(mountPathSrc, "/dev/sdcard01") == 0)
+		{
 			if (_sdCard01Mounted)
 				return FS_RESULT::ERR_PLACEHOLDER;
 
 			std::error_code ec;
-			const auto path = ActiveSettings::GetPath("sdcard/");
+			const auto path = ActiveSettings::GetUserDataPath("sdcard/");
 			fs::create_directories(path, ec);
 			if (!FSCDeviceHostFS_Mount(mountPathOut, _pathToUtf8(path), FSC_PRIORITY_BASE))
 				return FS_RESULT::ERR_PLACEHOLDER;
 			_sdCard01Mounted = true;
 		}
-		else if (strcmp(mountPathSrc, "/dev/mlc01") == 0) {
+		else if (strcmp(mountPathSrc, "/dev/mlc01") == 0)
+		{
 			if (_mlc01Mounted)
 				return FS_RESULT::ERR_PLACEHOLDER;
 
@@ -154,7 +174,8 @@ namespace coreinit
 				return FS_RESULT::ERR_PLACEHOLDER;
 			_mlc01Mounted = true;
 		}
-		else {
+		else
+		{
 			return FS_RESULT::ERR_PLACEHOLDER;
 		}
 
@@ -173,20 +194,19 @@ namespace coreinit
 	}
 
 	// return the aligned FSClientBody struct inside a FSClient struct
-	FSCmdBlockBody_t* __FSGetCmdBlockBody(FSCmdBlock_t* fsCmdBlock)
+	FSCmdBlockBody* __FSGetCmdBlockBody(FSCmdBlock_t* fsCmdBlock)
 	{
 		// align pointer to 64 bytes
 		if (fsCmdBlock == nullptr)
 			return nullptr;
-		FSCmdBlockBody_t* fsCmdBlockBody = (FSCmdBlockBody_t*)(((uintptr_t)fsCmdBlock + 0x3F) & ~0x3F);
+		FSCmdBlockBody* fsCmdBlockBody = (FSCmdBlockBody*)(((uintptr_t)fsCmdBlock + 0x3F) & ~0x3F);
 		fsCmdBlockBody->selfCmdBlock = fsCmdBlock;
 		return fsCmdBlockBody;
 	}
 
-
 	void __FSErrorAndBlock(std::string_view msg)
 	{
-		forceLog_printf("Critical error in FS: %s", msg.data());
+		cemuLog_log(LogType::Force, "Critical error in FS: {}", msg);
 		while (true)
 			std::this_thread::sleep_for(std::chrono::milliseconds(1000));
 	}
@@ -240,9 +260,9 @@ namespace coreinit
 		fsCmdQueueBE->dequeueHandlerFuncMPTR = _swapEndianU32(dequeueHandlerFuncMPTR);
 		fsCmdQueueBE->numCommandsInFlight = 0;
 		fsCmdQueueBE->numMaxCommandsInFlight = numMaxCommandsInFlight;
-		coreinit::OSInitMutexEx(&fsCmdQueueBE->mutex, nullptr);
-		fsCmdQueueBE->firstMPTR = _swapEndianU32(0);
-		fsCmdQueueBE->lastMPTR = _swapEndianU32(0);
+		coreinit::OSFastMutex_Init(&fsCmdQueueBE->fastMutex, nullptr);
+		fsCmdQueueBE->first = nullptr;
+		fsCmdQueueBE->last = nullptr;
 	}
 
 	void FSInit()
@@ -349,7 +369,7 @@ namespace coreinit
 			}
 			if (entryFound == false)
 			{
-#ifndef PUBLIC_RELEASE
+#ifdef CEMU_DEBUG_ASSERT
 				assert_dbg();
 #endif
 			}
@@ -362,114 +382,224 @@ namespace coreinit
 
 	Semaphore g_semaphoreQueuedCmds;
 
-	void __FSQueueCmdByPriority(FSCmdQueue* fsCmdQueueBE, FSCmdBlockBody_t* fsCmdBlockBody, bool stopAtEqualPriority)
+	void __FSQueueCmdByPriority(FSCmdQueue* fsCmdQueueBE, FSCmdBlockBody* fsCmdBlockBody, bool stopAtEqualPriority)
 	{
-		MPTR fsCmdBlockBodyMPTR = memory_getVirtualOffsetFromPointer(fsCmdBlockBody);
-		if (_swapEndianU32(fsCmdQueueBE->firstMPTR) == MPTR_NULL)
+		if (!fsCmdQueueBE->first)
 		{
 			// queue is currently empty
-			cemu_assert(fsCmdQueueBE->lastMPTR == MPTR_NULL);
-			fsCmdQueueBE->firstMPTR = _swapEndianU32(fsCmdBlockBodyMPTR);
-			fsCmdQueueBE->lastMPTR = _swapEndianU32(fsCmdBlockBodyMPTR);
-			fsCmdBlockBody->nextMPTR = _swapEndianU32(MPTR_NULL);
-			fsCmdBlockBody->previousMPTR = _swapEndianU32(MPTR_NULL);
+			cemu_assert(!fsCmdQueueBE->last);
+			fsCmdQueueBE->first = fsCmdBlockBody;
+			fsCmdQueueBE->last = fsCmdBlockBody;
+			fsCmdBlockBody->next = nullptr;
+			fsCmdBlockBody->previous = nullptr;
 			return;
 		}
 		// iterate from last to first element as long as iterated priority is lower
-		FSCmdBlockBody_t* fsCmdBlockBodyItrPrev = NULL;
-		FSCmdBlockBody_t* fsCmdBlockBodyItr = (FSCmdBlockBody_t*)memory_getPointerFromVirtualOffsetAllowNull(_swapEndianU32(fsCmdQueueBE->lastMPTR));
+		FSCmdBlockBody* fsCmdBlockBodyItrPrev = nullptr;
+		FSCmdBlockBody* fsCmdBlockBodyItr = fsCmdQueueBE->last;
 		while (true)
 		{
-			if (fsCmdBlockBodyItr == NULL)
+			if (!fsCmdBlockBodyItr)
 			{
 				// insert at the head of the list
-				fsCmdQueueBE->firstMPTR = _swapEndianU32(fsCmdBlockBodyMPTR);
-				fsCmdBlockBody->nextMPTR = _swapEndianU32(memory_getVirtualOffsetFromPointer(fsCmdBlockBodyItrPrev));
-				fsCmdBlockBody->previousMPTR = _swapEndianU32(MPTR_NULL);
-				fsCmdBlockBodyItrPrev->previousMPTR = _swapEndianU32(memory_getVirtualOffsetFromPointer(fsCmdBlockBody));
+				fsCmdQueueBE->first = fsCmdBlockBody;
+				fsCmdBlockBody->next = fsCmdBlockBodyItrPrev;
+				fsCmdBlockBody->previous = nullptr;
+				fsCmdBlockBodyItrPrev->previous = fsCmdBlockBody;
 				return;
 			}
 			// compare priority
 			if ((stopAtEqualPriority && fsCmdBlockBodyItr->priority >= fsCmdBlockBody->priority) || (stopAtEqualPriority == false && fsCmdBlockBodyItr->priority > fsCmdBlockBody->priority))
 			{
 				// insert cmd here
-				if (fsCmdBlockBodyItrPrev != NULL)
+				if (fsCmdBlockBodyItrPrev)
 				{
-					fsCmdBlockBody->nextMPTR = _swapEndianU32(memory_getVirtualOffsetFromPointer(fsCmdBlockBodyItrPrev));
+					fsCmdBlockBody->next = fsCmdBlockBodyItrPrev;
 				}
 				else
 				{
-					fsCmdBlockBody->nextMPTR = _swapEndianU32(MPTR_NULL);
-					fsCmdQueueBE->lastMPTR = _swapEndianU32(fsCmdBlockBodyMPTR);
+					fsCmdBlockBody->next = nullptr;
+					fsCmdQueueBE->last = fsCmdBlockBody;
 				}
-				fsCmdBlockBody->previousMPTR = _swapEndianU32(memory_getVirtualOffsetFromPointer(fsCmdBlockBodyItr));
+				fsCmdBlockBody->previous = fsCmdBlockBodyItr;
 				if (fsCmdBlockBodyItrPrev)
-					fsCmdBlockBodyItrPrev->previousMPTR = _swapEndianU32(memory_getVirtualOffsetFromPointer(fsCmdBlockBody));
-				fsCmdBlockBodyItr->nextMPTR = _swapEndianU32(memory_getVirtualOffsetFromPointer(fsCmdBlockBody));
+					fsCmdBlockBodyItrPrev->previous = fsCmdBlockBody;
+				fsCmdBlockBodyItr->next = fsCmdBlockBody;
 				return;
 			}
 			// next
 			fsCmdBlockBodyItrPrev = fsCmdBlockBodyItr;
-			fsCmdBlockBodyItr = (FSCmdBlockBody_t*)memory_getPointerFromVirtualOffsetAllowNull(_swapEndianU32(fsCmdBlockBodyItr->previousMPTR));
+			fsCmdBlockBodyItr = fsCmdBlockBodyItr->previous;
 		}
 	}
 
-	FSCmdBlockBody_t* __FSTakeCommandFromQueue(FSCmdQueue* cmdQueue)
+	FSCmdBlockBody* __FSTakeCommandFromQueue(FSCmdQueue* cmdQueue)
 	{
-		FSCmdBlockBody_t* dequeuedCmd = nullptr;
-		if (_swapEndianU32(cmdQueue->firstMPTR) != MPTR_NULL)
+		if (!cmdQueue->first)
+			return nullptr;
+		// dequeue cmd
+		FSCmdBlockBody* dequeuedCmd = cmdQueue->first;
+		if (cmdQueue->first == cmdQueue->last)
+			cmdQueue->last = nullptr;
+		cmdQueue->first = dequeuedCmd->next;
+		dequeuedCmd->next = nullptr;
+		if (dequeuedCmd->next)
 		{
-			dequeuedCmd = (FSCmdBlockBody_t*)memory_getPointerFromVirtualOffset(_swapEndianU32(cmdQueue->firstMPTR));
-			// dequeue cmd
-			if (cmdQueue->firstMPTR == cmdQueue->lastMPTR)
-				cmdQueue->lastMPTR = _swapEndianU32(MPTR_NULL);
-			cmdQueue->firstMPTR = dequeuedCmd->nextMPTR;
-			dequeuedCmd->nextMPTR = _swapEndianU32(MPTR_NULL);
-			if (_swapEndianU32(dequeuedCmd->nextMPTR) != MPTR_NULL)
-			{
-				FSCmdBlockBody_t* fsCmdBodyNext = (FSCmdBlockBody_t*)memory_getPointerFromVirtualOffset(_swapEndianU32(dequeuedCmd->nextMPTR));
-				fsCmdBodyNext->previousMPTR = _swapEndianU32(MPTR_NULL);
-			}
+			FSCmdBlockBody* fsCmdBodyNext = dequeuedCmd->next;
+			fsCmdBodyNext->previous = nullptr;
 		}
 		return dequeuedCmd;
 	}
 
 	void __FSAIoctlResponseCallback(PPCInterpreter_t* hCPU);
 
-	void __FSAIPCSubmitCommand(FSCmdBlockBody_t* cmd)
+	void __FSAIPCSubmitCommandAsync(iosu::fsa::FSAShimBuffer* shimBuffer, const MEMPTR<void>& callback, void* context)
 	{
-		if (cmd->ipcReqType == 0)
+		if (shimBuffer->ipcReqType == 0)
 		{
-			IOS_ERROR r = IOS_IoctlAsync(cmd->fsaDevHandle, cmd->operationType, cmd, 0x520, (uint8*)cmd + 0x580, 0x293, MEMPTR<void>(PPCInterpreter_makeCallableExportDepr(__FSAIoctlResponseCallback)), cmd);
+			IOS_ERROR r = IOS_IoctlAsync(shimBuffer->fsaDevHandle, shimBuffer->operationType, &shimBuffer->request, sizeof(shimBuffer->request), &shimBuffer->response, sizeof(shimBuffer->response), callback, context);
+			cemu_assert(!IOS_ResultIsError(r));
+		}
+		else if (shimBuffer->ipcReqType == 1)
+		{
+			IOS_ERROR r = IOS_IoctlvAsync(shimBuffer->fsaDevHandle, shimBuffer->operationType, shimBuffer->ioctlvVecIn, shimBuffer->ioctlvVecOut, shimBuffer->ioctlvVec, callback, context);
 			cemu_assert(!IOS_ResultIsError(r));
 		}
 		else
 		{
-			cemu_assert_unimplemented(); // IOS_IoctlvAsync
+			cemu_assert_error();
 		}
 	}
 
+	FSA_RESULT __FSADecodeIOSErrorToFSA(IOS_ERROR result)
+	{
+		return (FSA_RESULT)result;
+	}
+
+	FSA_RESULT __FSAIPCSubmitCommand(iosu::fsa::FSAShimBuffer* shimBuffer)
+	{
+		if (shimBuffer->ipcReqType == 0)
+		{
+			IOS_ERROR result = IOS_Ioctl(shimBuffer->fsaDevHandle, shimBuffer->operationType, &shimBuffer->request, sizeof(shimBuffer->request), &shimBuffer->response, sizeof(shimBuffer->response));
+			return __FSADecodeIOSErrorToFSA(result);
+		}
+		else if (shimBuffer->ipcReqType == 1)
+		{
+			IOS_ERROR result = IOS_Ioctlv(shimBuffer->fsaDevHandle, shimBuffer->operationType, shimBuffer->ioctlvVecIn, shimBuffer->ioctlvVecOut, shimBuffer->ioctlvVec);
+			return __FSADecodeIOSErrorToFSA(result);
+		}
+		return FSA_RESULT::FATAL_ERROR;
+	}
+
 	void __FSUpdateQueue(FSCmdQueue* cmdQueue)
 	{
 		FSLockMutex();
 		if (cmdQueue->numCommandsInFlight < cmdQueue->numMaxCommandsInFlight)
 		{
-			FSCmdBlockBody_t* dequeuedCommand = __FSTakeCommandFromQueue(cmdQueue);
+			FSCmdBlockBody* dequeuedCommand = __FSTakeCommandFromQueue(cmdQueue);
 			if (dequeuedCommand)
 			{
 				cmdQueue->numCommandsInFlight += 1;
 				if (cmdQueue->numCommandsInFlight >= cmdQueue->numMaxCommandsInFlight)
 					cmdQueue->queueFlags = cmdQueue->queueFlags | FSCmdQueue::QUEUE_FLAG::IS_FULL;
 				cemu_assert_debug(cmdQueue->dequeueHandlerFuncMPTR == 0); // not supported. We HLE call the handler here
-				__FSAIPCSubmitCommand(dequeuedCommand);
+				__FSAIPCSubmitCommandAsync(&dequeuedCommand->fsaShimBuffer, MEMPTR<void>(PPCInterpreter_makeCallableExportDepr(__FSAIoctlResponseCallback)), &dequeuedCommand->fsaShimBuffer);
 			}
 		}
 		FSUnlockMutex();
 	}
 
-	void __FSQueueCmd(FSCmdQueue* cmdQueue, FSCmdBlockBody_t* fsCmdBlockBody, MPTR finishCmdFunc)
+	void __FSQueueDefaultFinishFunc(FSCmdBlockBody* fsCmdBlockBody, FS_RESULT result)
 	{
-		fsCmdBlockBody->cmdFinishFuncMPTR = _swapEndianU32(finishCmdFunc);
+		switch ((FSA_CMD_OPERATION_TYPE)fsCmdBlockBody->fsaShimBuffer.operationType.value())
+		{
+		case FSA_CMD_OPERATION_TYPE::OPENFILE:
+		{
+			*fsCmdBlockBody->returnValues.cmdOpenFile.handlePtr = fsCmdBlockBody->fsaShimBuffer.response.cmdOpenFile.fileHandleOutput;
+			break;
+		}
+
+		case FSA_CMD_OPERATION_TYPE::GETCWD:
+		{
+			auto transferSize = fsCmdBlockBody->returnValues.cmdGetCwd.transferSize;
+			if (transferSize < 0 && transferSize > sizeof(fsCmdBlockBody->fsaShimBuffer.response.cmdGetCWD.path))
+			{
+				cemu_assert_error();
+			}
+			memcpy(fsCmdBlockBody->returnValues.cmdGetCwd.pathPtr, fsCmdBlockBody->fsaShimBuffer.response.cmdGetCWD.path, transferSize);
+			break;
+		}
+
+		case FSA_CMD_OPERATION_TYPE::OPENDIR:
+		{
+			*fsCmdBlockBody->returnValues.cmdOpenDir.handlePtr = fsCmdBlockBody->fsaShimBuffer.response.cmdOpenDir.dirHandleOutput;
+			break;
+		}
+		case FSA_CMD_OPERATION_TYPE::READDIR:
+		{
+			*fsCmdBlockBody->returnValues.cmdReadDir.dirEntryPtr = fsCmdBlockBody->fsaShimBuffer.response.cmdReadDir.dirEntry;
+			break;
+		}
+		case FSA_CMD_OPERATION_TYPE::GETPOS:
+		{
+			*fsCmdBlockBody->returnValues.cmdGetPosFile.filePosPtr = fsCmdBlockBody->fsaShimBuffer.response.cmdGetPosFile.filePos;
+			break;
+		}
+		case FSA_CMD_OPERATION_TYPE::GETSTATFILE:
+		{
+			*((FSStat_t*)fsCmdBlockBody->returnValues.cmdStatFile.resultPtr.GetPtr()) = fsCmdBlockBody->fsaShimBuffer.response.cmdStatFile.statOut;
+			break;
+		}
+		case FSA_CMD_OPERATION_TYPE::QUERYINFO:
+		{
+			if (fsCmdBlockBody->fsaShimBuffer.request.cmdQueryInfo.queryType == FSA_QUERY_TYPE_FREESPACE)
+			{
+				*((uint64be*)fsCmdBlockBody->returnValues.cmdQueryInfo.queryResultPtr.GetPtr()) = fsCmdBlockBody->fsaShimBuffer.response.cmdQueryInfo.queryFreeSpace.freespace;
+			}
+			else if (fsCmdBlockBody->fsaShimBuffer.request.cmdQueryInfo.queryType == FSA_QUERY_TYPE_STAT)
+			{
+				*((FSStat_t*)fsCmdBlockBody->returnValues.cmdQueryInfo.queryResultPtr.GetPtr()) = fsCmdBlockBody->fsaShimBuffer.response.cmdQueryInfo.queryStat.stat;
+			}
+			else
+			{
+				cemu_assert_unimplemented();
+			}
+			break;
+		}
+		case FSA_CMD_OPERATION_TYPE::CHANGEDIR:
+		case FSA_CMD_OPERATION_TYPE::MAKEDIR:
+		case FSA_CMD_OPERATION_TYPE::REMOVE:
+		case FSA_CMD_OPERATION_TYPE::RENAME:
+		case FSA_CMD_OPERATION_TYPE::CLOSEDIR:
+		case FSA_CMD_OPERATION_TYPE::READ:
+		case FSA_CMD_OPERATION_TYPE::WRITE:
+		case FSA_CMD_OPERATION_TYPE::SETPOS:
+		case FSA_CMD_OPERATION_TYPE::ISEOF:
+		case FSA_CMD_OPERATION_TYPE::CLOSEFILE:
+		case FSA_CMD_OPERATION_TYPE::APPENDFILE:
+		case FSA_CMD_OPERATION_TYPE::TRUNCATEFILE:
+		case FSA_CMD_OPERATION_TYPE::FLUSHQUOTA:
+		{
+			break;
+		}
+		default:
+		{
+			cemu_assert_unimplemented();
+		}
+		}
+	}
+
+	void export___FSQueueDefaultFinishFunc(PPCInterpreter_t* hCPU)
+	{
+		ppcDefineParamPtr(cmd, FSCmdBlockBody, 0);
+		FS_RESULT result = (FS_RESULT)PPCInterpreter_getCallParamU32(hCPU, 1);
+		__FSQueueDefaultFinishFunc(cmd, static_cast<FS_RESULT>(result));
+		osLib_returnFromFunction(hCPU, 0);
+	}
+
+	void __FSQueueCmd(FSCmdQueue* cmdQueue, FSCmdBlockBody* fsCmdBlockBody, MPTR finishCmdFunc)
+	{
+		fsCmdBlockBody->cmdFinishFuncMPTR = finishCmdFunc;
 		FSLockMutex();
 		fsCmdBlockBody->statusCode = _swapEndianU32(FSA_CMD_STATUS_CODE_D900A22);
 		__FSQueueCmdByPriority(cmdQueue, fsCmdBlockBody, true);
@@ -484,22 +614,76 @@ namespace coreinit
 
 	FS_RESULT _FSAStatusToFSStatus(FSA_RESULT err)
 	{
-		// todo
-		// currently /dev/fsa uses FS status codes internally. We should refactor everything to use FSA error codes (which are compatible with IOS_ERROR) and then translate them here to FS status
-		return (FS_RESULT)err;
+		if ((int)err > 0)
+		{
+			return (FS_RESULT)err;
+		}
+		switch (err)
+		{
+		case FSA_RESULT::OK:
+		{
+			return FS_RESULT::SUCCESS;
+		}
+		case FSA_RESULT::END_OF_DIRECTORY:
+		case FSA_RESULT::END_OF_FILE:
+		{
+			return FS_RESULT::END_ITERATION;
+		}
+		case FSA_RESULT::ALREADY_EXISTS:
+		{
+			return FS_RESULT::ALREADY_EXISTS;
+		}
+		case FSA_RESULT::NOT_FOUND:
+		{
+			return FS_RESULT::NOT_FOUND;
+		}
+		case FSA_RESULT::PERMISSION_ERROR:
+		{
+			return FS_RESULT::PERMISSION_ERROR;
+		}
+		case FSA_RESULT::NOT_FILE:
+		{
+			return FS_RESULT::NOT_FILE;
+		}
+		case FSA_RESULT::NOT_DIR:
+		{
+			return FS_RESULT::NOT_DIR;
+		}
+		case FSA_RESULT::MAX_FILES:
+		case FSA_RESULT::MAX_DIRS:
+		{
+			return FS_RESULT::MAX_HANDLES;
+		}
+		case FSA_RESULT::INVALID_CLIENT_HANDLE:
+		case FSA_RESULT::INVALID_FILE_HANDLE:
+		case FSA_RESULT::INVALID_DIR_HANDLE:
+		case FSA_RESULT::INVALID_PARAM:
+		case FSA_RESULT::INVALID_PATH:
+		case FSA_RESULT::INVALID_BUFFER:
+		case FSA_RESULT::INVALID_ALIGNMENT:
+		case FSA_RESULT::NOT_INIT:
+		case FSA_RESULT::MAX_CLIENTS:
+		case FSA_RESULT::OUT_OF_RESOURCES:
+		case FSA_RESULT::FATAL_ERROR:
+		{
+			return FS_RESULT::FATAL_ERROR;
+		}
+		}
+		cemu_assert_unimplemented();
+		return FS_RESULT::FATAL_ERROR;
 	}
 
-	void __FSCmdSubmitResult(FSCmdBlockBody_t* fsCmdBlockBody, FS_RESULT result)
+	void __FSCmdSubmitResult(FSCmdBlockBody* fsCmdBlockBody, FS_RESULT result)
 	{
 		_debugVerifyCommand("FSCmdSubmitResult", fsCmdBlockBody);
 
 		FSClientBody_t* fsClientBody = fsCmdBlockBody->fsClientBody.GetPtr();
-		sFSClientLock.lock(); // OSFastMutex_Lock(&fsClientBody->fsCmdQueue.mutex)
+		OSFastMutex_Lock(&fsClientBody->fsCmdQueue.fastMutex);
 		fsCmdBlockBody->cancelState &= ~(1 << 0); // clear cancel bit
 		if (fsClientBody->currentCmdBlockBody.GetPtr() == fsCmdBlockBody)
 			fsClientBody->currentCmdBlockBody = nullptr;
 		fsCmdBlockBody->statusCode = _swapEndianU32(FSA_CMD_STATUS_CODE_D900A24);
-		sFSClientLock.unlock();
+		OSFastMutex_Unlock(&fsClientBody->fsCmdQueue.fastMutex);
 		// send result via msg queue or callback
 		cemu_assert_debug(!fsCmdBlockBody->asyncResult.fsAsyncParamsNew.ioMsgQueue != !fsCmdBlockBody->asyncResult.fsAsyncParamsNew.userCallback); // either must be set
 		fsCmdBlockBody->ukn09EA = 0;
@@ -513,8 +697,8 @@ namespace coreinit
 			fsCmdBlockBody->asyncResult.fsStatusNew = (uint32)result;
 			while (OSSendMessage(ioMsgQueue, &fsCmdBlockBody->asyncResult.msgUnion.osMsg, 0) == 0)
 			{
-				forceLog_printf("FS driver: Failed to add message to result queue. Retrying...");
-				if (ppcInterpreterCurrentInstance)
+				cemuLog_log(LogType::Force, "FS driver: Failed to add message to result queue. Retrying...");
+				if (PPCInterpreter_getCurrentInstance())
 					PPCCore_switchToScheduler();
 				else
 					std::this_thread::sleep_for(std::chrono::milliseconds(10));
@@ -533,7 +717,7 @@ namespace coreinit
 	void __FSAIoctlResponseCallback(PPCInterpreter_t* hCPU)
 	{
 		ppcDefineParamU32(iosResult, 0);
-		ppcDefineParamPtr(cmd, FSCmdBlockBody_t, 1);
+		ppcDefineParamPtr(cmd, FSCmdBlockBody, 1);
 
 		FSA_RESULT fsaStatus = _FSIosErrorToFSAStatus((IOS_ERROR)iosResult);
 
@@ -550,8 +734,16 @@ namespace coreinit
 		cmdQueue.numCommandsInFlight -= 1;
 		cmdQueue.queueFlags = cmdQueue.queueFlags & ~FSCmdQueue::QUEUE_FLAG::IS_FULL;
 		FSUnlockMutex();
+
+		if (cmd->cmdFinishFuncMPTR)
+		{
+			if (cmd->cmdFinishFuncMPTR != FS_CB_PLACEHOLDER_FINISHCMD)
+				PPCCoreCallback(MEMPTR<void>(cmd->cmdFinishFuncMPTR), cmd, fsStatus);
+		}
+
 		__FSCmdSubmitResult(cmd, fsStatus);
-		__FSUpdateQueue(&cmd->fsClientBody->fsCmdQueue);
+		// dont read from cmd after this point, since the game could already have modified it
+		__FSUpdateQueue(&client->fsCmdQueue);
 		osLib_returnFromFunction(hCPU, 0);
 	}
 
@@ -560,25 +752,25 @@ namespace coreinit
 	void FSInitCmdBlock(FSCmdBlock_t* fsCmdBlock)
 	{
 		memset(fsCmdBlock, 0x00, sizeof(FSCmdBlock_t));
-		FSCmdBlockBody_t* fsCmdBlockBody = __FSGetCmdBlockBody(fsCmdBlock);
+		FSCmdBlockBody* fsCmdBlockBody = __FSGetCmdBlockBody(fsCmdBlock);
 		fsCmdBlockBody->statusCode = _swapEndianU32(FSA_CMD_STATUS_CODE_D900A21);
 		fsCmdBlockBody->priority = 0x10;
 	}
 
-	void __FSAsyncToSyncInit(FSClient_t* fsClient, FSCmdBlock_t* fsCmdBlock, FSAsyncParamsNew_t* asyncParams)
+	void __FSAsyncToSyncInit(FSClient_t* fsClient, FSCmdBlock_t* fsCmdBlock, FSAsyncParams* asyncParams)
 	{
 		if (fsClient == nullptr || fsCmdBlock == nullptr || asyncParams == nullptr)
 			assert_dbg();
-		FSCmdBlockBody_t* fsCmdBlockBody = __FSGetCmdBlockBody(fsCmdBlock);
+		FSCmdBlockBody* fsCmdBlockBody = __FSGetCmdBlockBody(fsCmdBlock);
 		coreinit::OSInitMessageQueue(&fsCmdBlockBody->syncTaskMsgQueue, fsCmdBlockBody->_syncTaskMsg, 1);
 		asyncParams->userCallback = nullptr;
 		asyncParams->userContext = nullptr;
 		asyncParams->ioMsgQueue = &fsCmdBlockBody->syncTaskMsgQueue;
 	}
 
-	void __FSPrepareCmdAsyncResult(FSClientBody_t* fsClientBody, FSCmdBlockBody_t* fsCmdBlockBody, FSAsyncResult* fsCmdBlockAsyncResult, FSAsyncParamsNew_t* fsAsyncParams)
+	void __FSPrepareCmdAsyncResult(FSClientBody_t* fsClientBody, FSCmdBlockBody* fsCmdBlockBody, FSAsyncResult* fsCmdBlockAsyncResult, FSAsyncParams* fsAsyncParams)
 	{
-		memcpy(&fsCmdBlockAsyncResult->fsAsyncParamsNew, fsAsyncParams, sizeof(FSAsyncParamsNew_t));
+		memcpy(&fsCmdBlockAsyncResult->fsAsyncParamsNew, fsAsyncParams, sizeof(FSAsyncParams));
 
 		fsCmdBlockAsyncResult->fsClient = fsClientBody->selfClient;
 		fsCmdBlockAsyncResult->fsCmdBlock = fsCmdBlockBody->selfCmdBlock;
@@ -587,7 +779,7 @@ namespace coreinit
 		fsCmdBlockAsyncResult->msgUnion.fsMsg.commandType = _swapEndianU32(8);
 	}
 
-	sint32 __FSPrepareCmd(FSClientBody_t* fsClientBody, FSCmdBlockBody_t* fsCmdBlockBody, uint32 errHandling, FSAsyncParamsNew_t* fsAsyncParams)
+	sint32 __FSPrepareCmd(FSClientBody_t* fsClientBody, FSCmdBlockBody* fsCmdBlockBody, uint32 errHandling, FSAsyncParams* fsAsyncParams)
 	{
 		if (sFSInitialized == false || sFSShutdown == true)
 			return -0x400;
@@ -612,36 +804,38 @@ namespace coreinit
 		fsCmdBlockBody->errHandling = _swapEndianU32(errHandling);
 		fsCmdBlockBody->uknStatusGuessed09E9 = 0;
 		fsCmdBlockBody->cancelState &= ~(1 << 0); // clear cancel bit
-		fsCmdBlockBody->fsaDevHandle = fsClientBody->iosuFSAHandle;
-		__FSPrepareCmdAsyncResult(fsClientBody, fsCmdBlockBody , &fsCmdBlockBody->asyncResult, fsAsyncParams);
+		fsCmdBlockBody->fsaShimBuffer.fsaDevHandle = fsClientBody->iosuFSAHandle;
+		__FSPrepareCmdAsyncResult(fsClientBody, fsCmdBlockBody, &fsCmdBlockBody->asyncResult, fsAsyncParams);
 		return 0;
 	}
 
-#define _FSCmdIntro()		FSClientBody_t* fsClientBody = __FSGetClientBody(fsClient); \
-							FSCmdBlockBody_t* fsCmdBlockBody = __FSGetCmdBlockBody(fsCmdBlock); \
-							sint32 fsError = __FSPrepareCmd(fsClientBody, fsCmdBlockBody, errorMask, fsAsyncParams); \
-							if (fsError != 0) return fsError;
+#define _FSCmdIntro()                                                                        \
+	FSClientBody_t* fsClientBody = __FSGetClientBody(fsClient);                              \
+	FSCmdBlockBody* fsCmdBlockBody = __FSGetCmdBlockBody(fsCmdBlock);                      \
+	sint32 fsError = __FSPrepareCmd(fsClientBody, fsCmdBlockBody, errorMask, fsAsyncParams); \
+	if (fsError != 0)                                                                        \
+		return fsError;
 
-	void _debugVerifyCommand(const char* stage, FSCmdBlockBody_t* fsCmdBlockBody)
+	void _debugVerifyCommand(const char* stage, FSCmdBlockBody* fsCmdBlockBody)
 	{
 		if (fsCmdBlockBody->asyncResult.msgUnion.fsMsg.commandType != _swapEndianU32(8))
 		{
-			forceLog_printf("Corrupted FS command detected in stage %s", stage);
-			forceLog_printf("Printing CMD block: ");
-			for (uint32 i = 0; i < (sizeof(FSCmdBlockBody_t) + 31) / 32; i++)
+			cemuLog_log(LogType::Force, "Corrupted FS command detected in stage {}", stage);
+			cemuLog_log(LogType::Force, "Printing CMD block: ");
+			for (uint32 i = 0; i < (sizeof(FSCmdBlockBody) + 31) / 32; i++)
 			{
 				uint8* p = ((uint8*)fsCmdBlockBody) + i * 32;
-				forceLog_printf("%04x: %02x %02x %02x %02x - %02x %02x %02x %02x - %02x %02x %02x %02x - %02x %02x %02x %02x | %02x %02x %02x %02x - %02x %02x %02x %02x - %02x %02x %02x %02x - %02x %02x %02x %02x",
-					i * 32,
-					p[0], p[1], p[2], p[3], p[4], p[5], p[6], p[7], p[8], p[9], p[10], p[11], p[12], p[13], p[14], p[15],
-					p[16], p[17], p[18], p[19], p[20], p[21], p[22], p[23], p[24], p[25], p[26], p[27], p[28], p[29], p[30], p[31]);
+				cemuLog_log(LogType::Force, "{:04x}: {:02x} {:02x} {:02x} {:02x} - {:02x} {:02x} {:02x} {:02x} - {:02x} {:02x} {:02x} {:02x} - {:02x} {:02x} {:02x} {:02x} | {:02x} {:02x} {:02x} {:02x} - {:02x} {:02x} {:02x} {:02x} - {:02x} {:02x} {:02x} {:02x} - {:02x} {:02x} {:02x} {:02x}",
+							i * 32,
+							p[0], p[1], p[2], p[3], p[4], p[5], p[6], p[7], p[8], p[9], p[10], p[11], p[12], p[13], p[14], p[15],
+							p[16], p[17], p[18], p[19], p[20], p[21], p[22], p[23], p[24], p[25], p[26], p[27], p[28], p[29], p[30], p[31]);
 			}
 		}
 	}
 
 	FSAsyncResult* FSGetAsyncResult(OSMessage* msg)
 	{
-		return (FSAsyncResult*)memory_getPointerFromVirtualOffset(_swapEndianU32(msg->message));
+		return (FSAsyncResult*)memory_getPointerFromVirtualOffset(msg->message);
 	}
 
 	sint32 __FSProcessAsyncResult(FSClient_t* fsClient, FSCmdBlock_t* fsCmdBlock, sint32 fsStatus, uint32 errHandling)
@@ -649,7 +843,7 @@ namespace coreinit
 		// a positive result (or zero) means success. Most operations return zero in case of success. Read and write operations return the number of transferred units
 		if (fsStatus >= 0)
 		{
-			FSCmdBlockBody_t* fsCmdBlockBody = __FSGetCmdBlockBody(fsCmdBlock);
+			FSCmdBlockBody* fsCmdBlockBody = __FSGetCmdBlockBody(fsCmdBlock);
 			OSMessage msg;
 			OSReceiveMessage(&fsCmdBlockBody->syncTaskMsgQueue, &msg, OS_MESSAGE_BLOCK);
 			_debugVerifyCommand("handleAsyncResult", fsCmdBlockBody);
@@ -659,24 +853,23 @@ namespace coreinit
 		else
 		{
 			// todo - error handling
-			forceLog_printf("FS handleAsyncResult(): unexpected error %08x", errHandling);
+			cemuLog_log(LogType::Force, "FS handleAsyncResult(): unexpected error {:08x}", errHandling);
 			cemu_assert_debug(false);
 			return 0;
 		}
 	}
 
-	uint32 __FSPrepareCmd_OpenFile(FSCmdBlockBody_t* fsCmdBlockBody, char* path, char* mode, uint32 createMode, uint32 openFlags, uint32 preallocSize)
+	FSA_RESULT __FSPrepareCmd_OpenFile(iosu::fsa::FSAShimBuffer* fsaShimBuffer, IOSDevHandle fsaHandle, char* path, char* mode, uint32 createMode, uint32 openFlags, uint32 preallocSize)
 	{
-		fsCmdBlockBody->fsCmdBlockBodyMPTR = _swapEndianU32(memory_getVirtualOffsetFromPointer(fsCmdBlockBody));
-		if (fsCmdBlockBody == NULL)
-			return 0xFFFCFFDD;
+		if (fsaShimBuffer == NULL)
+			return FSA_RESULT::INVALID_BUFFER;
 		if (path == NULL)
-			return 0xFFFCFFDD + 1;
+			return FSA_RESULT::INVALID_PATH;
 		if (mode == NULL)
-			return 0xFFFCFFDD + 2;
-		fsCmdBlockBody->fsCmdBlockBodyMPTR = _swapEndianU32(memory_getVirtualOffsetFromPointer(fsCmdBlockBody));
-		fsCmdBlockBody->ipcData.cmdOpenFile.fileHandleOutput = _swapEndianU32(0xFFFFFFFF);
-		fsCmdBlockBody->operationType = FSA_CMD_OPERATION_TYPE_OPENFILE;
+			return FSA_RESULT::INVALID_PARAM;
+		fsaShimBuffer->fsaDevHandle = fsaHandle;
+		fsaShimBuffer->ipcReqType = 0;
+		fsaShimBuffer->operationType = (uint32)FSA_CMD_OPERATION_TYPE::OPENFILE;
 		// path
 		size_t pathLen = strlen((char*)path);
 		if (pathLen >= FSA_CMD_PATH_MAX_LENGTH)
@@ -685,9 +878,9 @@ namespace coreinit
 			pathLen = FSA_CMD_PATH_MAX_LENGTH - 1;
 		}
 		for (sint32 i = 0; i < pathLen; i++)
-			fsCmdBlockBody->ipcData.cmdOpenFile.path[i] = path[i];
+			fsaShimBuffer->request.cmdOpenFile.path[i] = path[i];
 		for (size_t i = pathLen; i < FSA_CMD_PATH_MAX_LENGTH; i++)
-			fsCmdBlockBody->ipcData.cmdOpenFile.path[i] = '\0';
+			fsaShimBuffer->request.cmdOpenFile.path[i] = '\0';
 		// mode
 		size_t modeLen = strlen((char*)mode);
 		if (modeLen >= 12)
@@ -696,40 +889,43 @@ namespace coreinit
 			modeLen = 12 - 1;
 		}
 		for (sint32 i = 0; i < modeLen; i++)
-			fsCmdBlockBody->ipcData.cmdOpenFile.mode[i] = mode[i];
+			fsaShimBuffer->request.cmdOpenFile.mode[i] = mode[i];
 		for (size_t i = modeLen; i < 12; i++)
-			fsCmdBlockBody->ipcData.cmdOpenFile.mode[i] = '\0';
+			fsaShimBuffer->request.cmdOpenFile.mode[i] = '\0';
 		// createMode
-		fsCmdBlockBody->ipcData.cmdOpenFile.createMode = createMode;
+		fsaShimBuffer->request.cmdOpenFile.createMode = createMode;
 		// openFlags
-		fsCmdBlockBody->ipcData.cmdOpenFile.openFlags = openFlags;
+		fsaShimBuffer->request.cmdOpenFile.openFlags = openFlags;
 		// preallocSize
-		fsCmdBlockBody->ipcData.cmdOpenFile.preallocSize = preallocSize;
-		return 0;
+		fsaShimBuffer->request.cmdOpenFile.preallocSize = preallocSize;
+
+		fsaShimBuffer->response.cmdOpenFile.fileHandleOutput = 0xFFFFFFFF;
+
+		return FSA_RESULT::OK;
 	}
 
-	sint32 FSOpenFileAsync(FSClient_t* fsClient, FSCmdBlock_t* fsCmdBlock, char* path, char* mode, FSFileHandleDepr_t* fileHandle, uint32 errorMask, FSAsyncParamsNew_t* fsAsyncParams)
+	sint32 FSOpenFileAsync(FSClient_t* fsClient, FSCmdBlock_t* fsCmdBlock, char* path, char* mode, FSFileHandlePtr outFileHandle, uint32 errorMask, FSAsyncParams* fsAsyncParams)
 	{
 		_FSCmdIntro();
-		if (fileHandle == nullptr || path == nullptr || mode == nullptr)
+		if (outFileHandle == nullptr || path == nullptr || mode == nullptr)
 			return -0x400;
-		fsCmdBlockBody->returnValueMPTR = _swapEndianU32(memory_getVirtualOffsetFromPointer(fileHandle));
-		fsError = __FSPrepareCmd_OpenFile(fsCmdBlockBody, path, mode, 0x660, 0, 0);
+		fsCmdBlockBody->returnValues.cmdOpenFile.handlePtr = outFileHandle;
+		fsError = (FSStatus)__FSPrepareCmd_OpenFile(&fsCmdBlockBody->fsaShimBuffer, fsClientBody->iosuFSAHandle, path, mode, 0x660, 0, 0);
 		if (fsError != (FSStatus)FS_RESULT::SUCCESS)
 			return fsError;
-		__FSQueueCmd(&fsClientBody->fsCmdQueue, fsCmdBlockBody, FS_CB_PLACEHOLDER_FINISHCMD);
+		__FSQueueCmd(&fsClientBody->fsCmdQueue, fsCmdBlockBody, RPLLoader_MakePPCCallable(export___FSQueueDefaultFinishFunc));
 		return (FSStatus)FS_RESULT::SUCCESS;
 	}
 
-	sint32 FSOpenFile(FSClient_t* fsClient, FSCmdBlock_t* fsCmdBlock, char* path, char* mode, FSFileHandleDepr_t* fileHandle, uint32 errHandling)
+	sint32 FSOpenFile(FSClient_t* fsClient, FSCmdBlock_t* fsCmdBlock, char* path, char* mode, FSFileHandlePtr outFileHandle, uint32 errHandling)
 	{
-		StackAllocator<FSAsyncParamsNew_t, 1> asyncParams;
-		__FSAsyncToSyncInit(fsClient, fsCmdBlock, asyncParams);
-		sint32 fsAsyncRet = FSOpenFileAsync(fsClient, fsCmdBlock, path, mode, fileHandle, errHandling, asyncParams);
+		StackAllocator<FSAsyncParams, 1> asyncParams;
+		__FSAsyncToSyncInit(fsClient, fsCmdBlock, &asyncParams);
+		sint32 fsAsyncRet = FSOpenFileAsync(fsClient, fsCmdBlock, path, mode, outFileHandle, errHandling, &asyncParams);
 		return __FSProcessAsyncResult(fsClient, fsCmdBlock, fsAsyncRet, errHandling);
 	}
 
-	sint32 FSOpenFileExAsync(FSClient_t* fsClient, FSCmdBlock_t* fsCmdBlock, char* path, char* mode, uint32 createMode, uint32 openFlag, uint32 preallocSize, FSFileHandleDepr_t* fileHandle, uint32 errorMask, FSAsyncParamsNew_t* fsAsyncParams)
+	sint32 FSOpenFileExAsync(FSClient_t* fsClient, FSCmdBlock_t* fsCmdBlock, char* path, char* mode, uint32 createMode, uint32 openFlag, uint32 preallocSize, FSFileHandlePtr outFileHandle, uint32 errorMask, FSAsyncParams* fsAsyncParams)
 	{
 		if (openFlag != 0)
 		{
@@ -738,76 +934,131 @@ namespace coreinit
 		}
 
 		_FSCmdIntro();
-		if (fileHandle == nullptr || path == nullptr || mode == nullptr)
+		if (outFileHandle == nullptr || path == nullptr || mode == nullptr)
 			return -0x400;
-		fsCmdBlockBody->returnValueMPTR = _swapEndianU32(memory_getVirtualOffsetFromPointer(fileHandle));
-		fsError = __FSPrepareCmd_OpenFile(fsCmdBlockBody, path, mode, createMode, openFlag, preallocSize);
-		if (fsError != (FSStatus)FS_RESULT::SUCCESS)
-			return fsError;
-		__FSQueueCmd(&fsClientBody->fsCmdQueue, fsCmdBlockBody, FS_CB_PLACEHOLDER_FINISHCMD);
+		fsCmdBlockBody->returnValues.cmdOpenFile.handlePtr = outFileHandle;
+
+		FSA_RESULT prepareResult = __FSPrepareCmd_OpenFile(&fsCmdBlockBody->fsaShimBuffer, fsClientBody->iosuFSAHandle, path, mode, createMode, openFlag, preallocSize);
+		if (prepareResult != FSA_RESULT::OK)
+			return (FSStatus)_FSAStatusToFSStatus(prepareResult);
+
+		__FSQueueCmd(&fsClientBody->fsCmdQueue, fsCmdBlockBody, RPLLoader_MakePPCCallable(export___FSQueueDefaultFinishFunc));
 		return (FSStatus)FS_RESULT::SUCCESS;
 	}
 
-	sint32 FSOpenFileEx(FSClient_t* fsClient, FSCmdBlock_t* fsCmdBlock, char* path, char* mode, uint32 createMode, uint32 openFlag, uint32 preallocSize, FSFileHandleDepr_t* fileHandle, uint32 errHandling)
+	sint32 FSOpenFileEx(FSClient_t* fsClient, FSCmdBlock_t* fsCmdBlock, char* path, char* mode, uint32 createMode, uint32 openFlag, uint32 preallocSize, FSFileHandlePtr outFileHandle, uint32 errHandling)
 	{
-		StackAllocator<FSAsyncParamsNew_t, 1> asyncParams;
-		__FSAsyncToSyncInit(fsClient, fsCmdBlock, asyncParams);
-		sint32 fsAsyncRet = FSOpenFileExAsync(fsClient, fsCmdBlock, path, mode, createMode, openFlag, preallocSize, fileHandle, errHandling, asyncParams);
+		StackAllocator<FSAsyncParams, 1> asyncParams;
+		__FSAsyncToSyncInit(fsClient, fsCmdBlock, &asyncParams);
+		sint32 fsAsyncRet = FSOpenFileExAsync(fsClient, fsCmdBlock, path, mode, createMode, openFlag, preallocSize, outFileHandle, errHandling, &asyncParams);
 		return __FSProcessAsyncResult(fsClient, fsCmdBlock, fsAsyncRet, errHandling);
 	}
 
-	void __FSPrepareCmd_CloseFile(FSCmdBlockBody_t* fsCmdBlockBody, uint32 fileHandle)
+	FSA_RESULT __FSPrepareCmd_CloseFile(iosu::fsa::FSAShimBuffer* fsaShimBuffer, IOSDevHandle fsaHandle, uint32 fileHandle)
 	{
-		fsCmdBlockBody->operationType = FSA_CMD_OPERATION_TYPE_CLOSEFILE;
-		fsCmdBlockBody->ipcData.cmdCloseFile.fileHandle = fileHandle;
+		if (fsaShimBuffer == nullptr)
+			return FSA_RESULT::INVALID_BUFFER;
+
+		fsaShimBuffer->fsaDevHandle = fsaHandle;
+		fsaShimBuffer->ipcReqType = 0;
+		fsaShimBuffer->operationType = (uint32)FSA_CMD_OPERATION_TYPE::CLOSEFILE;
+
+		fsaShimBuffer->request.cmdCloseFile.fileHandle = fileHandle;
+
+		return FSA_RESULT::OK;
 	}
 
-	sint32 FSCloseFileAsync(FSClient_t* fsClient, FSCmdBlock_t* fsCmdBlock, uint32 fileHandle, uint32 errorMask, FSAsyncParamsNew_t* fsAsyncParams)
+	sint32 FSCloseFileAsync(FSClient_t* fsClient, FSCmdBlock_t* fsCmdBlock, uint32 fileHandle, uint32 errorMask, FSAsyncParams* fsAsyncParams)
 	{
 		_FSCmdIntro();
-		__FSPrepareCmd_CloseFile(fsCmdBlockBody, fileHandle);
-		__FSQueueCmd(&fsClientBody->fsCmdQueue, fsCmdBlockBody, FS_CB_PLACEHOLDER_FINISHCMD);
+
+		FSA_RESULT prepareResult = __FSPrepareCmd_CloseFile(&fsCmdBlockBody->fsaShimBuffer, fsClientBody->iosuFSAHandle, fileHandle);
+		if (prepareResult != FSA_RESULT::OK)
+			return (FSStatus)_FSAStatusToFSStatus(prepareResult);
+
+		__FSQueueCmd(&fsClientBody->fsCmdQueue, fsCmdBlockBody, RPLLoader_MakePPCCallable(export___FSQueueDefaultFinishFunc));
 		return (FSStatus)FS_RESULT::SUCCESS;
 	}
 
 	sint32 FSCloseFile(FSClient_t* fsClient, FSCmdBlock_t* fsCmdBlock, uint32 fileHandle, uint32 errHandling)
 	{
-		StackAllocator<FSAsyncParamsNew_t, 1> asyncParams;
-		__FSAsyncToSyncInit(fsClient, fsCmdBlock, asyncParams);
-		sint32 fsAsyncRet = FSCloseFileAsync(fsClient, fsCmdBlock, fileHandle, errHandling, asyncParams);
+		StackAllocator<FSAsyncParams, 1> asyncParams;
+		__FSAsyncToSyncInit(fsClient, fsCmdBlock, &asyncParams);
+		sint32 fsAsyncRet = FSCloseFileAsync(fsClient, fsCmdBlock, fileHandle, errHandling, &asyncParams);
 		return __FSProcessAsyncResult(fsClient, fsCmdBlock, fsAsyncRet, errHandling);
 	}
 
-	uint32 __FSPrepareCmd_ReadFile(FSCmdBlockBody_t* fsCmdBlockBody, void* dest, uint32 uknR6, uint32 transferSizeUknAligned, uint32 filePos, uint32 fileHandle, uint32 flag)
+	FSA_RESULT __FSPrepareCmd_FlushFile(iosu::fsa::FSAShimBuffer* fsaShimBuffer, IOSDevHandle fsaHandle, uint32 fileHandle)
 	{
-		fsCmdBlockBody->fsCmdBlockBodyMPTR = _swapEndianU32(memory_getVirtualOffsetFromPointer(fsCmdBlockBody));
-		if (fsCmdBlockBody == NULL || dest == NULL)
-			return 0xFFFCFFDD;
+		if (fsaShimBuffer == nullptr)
+			return FSA_RESULT::INVALID_BUFFER;
+
+		fsaShimBuffer->fsaDevHandle = fsaHandle;
+		fsaShimBuffer->ipcReqType = 0;
+		fsaShimBuffer->operationType = (uint32)FSA_CMD_OPERATION_TYPE::FLUSHFILE;
+
+		fsaShimBuffer->request.cmdFlushFile.fileHandle = fileHandle;
+
+		return FSA_RESULT::OK;
+	}
+
+	sint32 FSFlushFileAsync(FSClient_t* fsClient, FSCmdBlock_t* fsCmdBlock, uint32 fileHandle, uint32 errorMask, FSAsyncParams* fsAsyncParams)
+	{
+		_FSCmdIntro();
+
+		FSA_RESULT prepareResult = __FSPrepareCmd_FlushFile(&fsCmdBlockBody->fsaShimBuffer, fsClientBody->iosuFSAHandle, fileHandle);
+		if (prepareResult != FSA_RESULT::OK)
+			return (FSStatus)_FSAStatusToFSStatus(prepareResult);
+
+		__FSQueueCmd(&fsClientBody->fsCmdQueue, fsCmdBlockBody, RPLLoader_MakePPCCallable(export___FSQueueDefaultFinishFunc));
+		return (FSStatus)FS_RESULT::SUCCESS;
+	}
+
+	sint32 FSFlushFile(FSClient_t* fsClient, FSCmdBlock_t* fsCmdBlock, uint32 fileHandle, uint32 errHandling)
+	{
+		StackAllocator<FSAsyncParams, 1> asyncParams;
+		__FSAsyncToSyncInit(fsClient, fsCmdBlock, &asyncParams);
+		sint32 fsAsyncRet = FSFlushFileAsync(fsClient, fsCmdBlock, fileHandle, errHandling, &asyncParams);
+		return __FSProcessAsyncResult(fsClient, fsCmdBlock, fsAsyncRet, errHandling);
+	}
+
+	FSA_RESULT __FSPrepareCmd_ReadFile(iosu::fsa::FSAShimBuffer* fsaShimBuffer, IOSDevHandle fsaHandle, void* dest, uint32 size, uint32 count, uint32 filePos, uint32 fileHandle, uint32 flag)
+	{
+		if (fsaShimBuffer == NULL || dest == NULL)
+			return FSA_RESULT::INVALID_BUFFER;
 		MPTR destMPTR = memory_getVirtualOffsetFromPointer(dest);
 		if ((destMPTR & 0x3F) != 0)
-			return 0xFFFCFFDC;
-		fsCmdBlockBody->fsCmdBlockBodyMPTR = _swapEndianU32(memory_getVirtualOffsetFromPointer(fsCmdBlockBody));
-		fsCmdBlockBody->ipcData.cmdDefault.fileHandle = _swapEndianU32(fileHandle);
-		fsCmdBlockBody->ukn0898 = _swapEndianU32(memory_getVirtualOffsetFromPointer(fsCmdBlockBody) + 0x580);
-		fsCmdBlockBody->ipcData.cmdDefault.ukn0008 = _swapEndianU32(uknR6);
-		fsCmdBlockBody->ipcData.cmdDefault.ukn000C = _swapEndianU32(transferSizeUknAligned);
-		uint32 fullTransferSize = transferSizeUknAligned * uknR6;
-		fsCmdBlockBody->ukn090B = 2; // byte
-		fsCmdBlockBody->ukn089C = _swapEndianU32(0x293);
-		fsCmdBlockBody->ukn0890 = _swapEndianU32(fullTransferSize);
-		fsCmdBlockBody->ukn0884 = _swapEndianU32(0x520);
-		fsCmdBlockBody->destBuffer88CMPTR = _swapEndianU32(destMPTR);
-		fsCmdBlockBody->ukn090A = 1;
-		fsCmdBlockBody->operationType = FSA_CMD_OPERATION_TYPE_READ;
-		fsCmdBlockBody->ipcData.cmdDefault.destBufferMPTR = _swapEndianU32(destMPTR);
-		fsCmdBlockBody->ipcData.cmdDefault.transferFilePos = _swapEndianU32(filePos);
-		fsCmdBlockBody->ipcData.cmdDefault.cmdFlag = _swapEndianU32(flag);
-		return 0;
+			return FSA_RESULT::INVALID_ALIGNMENT;
+
+		fsaShimBuffer->fsaDevHandle = fsaHandle;
+		fsaShimBuffer->ipcReqType = 1;
+		fsaShimBuffer->operationType = (uint32)FSA_CMD_OPERATION_TYPE::READ;
+
+		fsaShimBuffer->ioctlvVecIn = 1;
+		fsaShimBuffer->ioctlvVecOut = 2;
+
+		fsaShimBuffer->ioctlvVec[0].baseVirt = fsaShimBuffer;
+		fsaShimBuffer->ioctlvVec[0].size = sizeof(iosu::fsa::FSARequest);
+
+		fsaShimBuffer->ioctlvVec[1].baseVirt = destMPTR;
+		fsaShimBuffer->ioctlvVec[1].size = size * count;
+
+		fsaShimBuffer->ioctlvVec[2].baseVirt = &fsaShimBuffer->response;
+		fsaShimBuffer->ioctlvVec[2].size = sizeof(iosu::fsa::FSAResponse);
+
+		fsaShimBuffer->request.cmdReadFile.dest = dest;
+		fsaShimBuffer->request.cmdReadFile.size = size;
+		fsaShimBuffer->request.cmdReadFile.count = count;
+		fsaShimBuffer->request.cmdReadFile.filePos = filePos;
+		fsaShimBuffer->request.cmdReadFile.fileHandle = fileHandle;
+		fsaShimBuffer->request.cmdReadFile.flag = flag;
+
+		return FSA_RESULT::OK;
 	}
 
 	SysAllocator<uint8, 128, 64> _tempFSSpace;
 
-	sint32 __FSReadFileAsyncEx(FSClient_t* fsClient, FSCmdBlock_t* fsCmdBlock, void* dest, uint32 size, uint32 count, bool usePos, uint32 filePos, uint32 fileHandle, uint32 flag, uint32 errorMask, FSAsyncParamsNew_t* fsAsyncParams)
+	sint32 __FSReadFileAsyncEx(FSClient_t* fsClient, FSCmdBlock_t* fsCmdBlock, void* dest, uint32 size, uint32 count, bool usePos, uint32 filePos, uint32 fileHandle, uint32 flag, uint32 errorMask, FSAsyncParams* fsAsyncParams)
 	{
 		_FSCmdIntro();
 		if (size == 0 || count == 0 || dest == NULL)
@@ -819,25 +1070,26 @@ namespace coreinit
 			cemu_assert(false);
 			return -0x400;
 		}
-		uint32 transferSize = (uint32)transferSizeS64;
-		fsCmdBlockBody->transferSize = _swapEndianU32(transferSize);
-		fsCmdBlockBody->transferElemSize = _swapEndianU32(size);
-		fsCmdBlockBody->uknVal094C = _swapEndianU32(0);
-		if (transferSize < 0x10)
-			transferSize = 0x10;
-		fsCmdBlockBody->uknVal0954 = _swapEndianU32(transferSize);
-		if(usePos)
+
+		// coreinit.rpl splits up each read into smaller chunks (probably to support canceling big writes). This is handled by a specific
+		// callback for the __FSQueueCmd functions. Whenever a chunk is read, it's getting re-queued until the reading has been completed.
+		// For this it writes values into the fsCmdBlockBody->returnValues struct. At the moment we go the lazy route of just reading everything
+		// at once, so we can skip the initialization of these values.
+
+		if (usePos)
 			flag |= FSA_CMD_FLAG_SET_POS;
 		else
 			flag &= ~FSA_CMD_FLAG_SET_POS;
-		fsError = __FSPrepareCmd_ReadFile(fsCmdBlockBody, dest, 1, transferSize, filePos, fileHandle, flag);
-		if (fsError != (FSStatus)FS_RESULT::SUCCESS)
-			return fsError;
-		__FSQueueCmd(&fsClientBody->fsCmdQueue, fsCmdBlockBody, FS_CB_PLACEHOLDER_FINISHCMD);
+
+		FSA_RESULT prepareResult = __FSPrepareCmd_ReadFile(&fsCmdBlockBody->fsaShimBuffer, fsClientBody->iosuFSAHandle, dest, size, count, filePos, fileHandle, flag);
+		if (prepareResult != FSA_RESULT::OK)
+			return (FSStatus)_FSAStatusToFSStatus(prepareResult);
+
+		__FSQueueCmd(&fsClientBody->fsCmdQueue, fsCmdBlockBody, RPLLoader_MakePPCCallable(export___FSQueueDefaultFinishFunc));
 		return (FSStatus)FS_RESULT::SUCCESS;
 	}
 
-	sint32 FSReadFileAsync(FSClient_t* fsClient, FSCmdBlock_t* fsCmdBlock, void* dst, uint32 size, uint32 count, uint32 fileHandle, uint32 flag, uint32 errorMask, FSAsyncParamsNew_t* fsAsyncParams)
+	sint32 FSReadFileAsync(FSClient_t* fsClient, FSCmdBlock_t* fsCmdBlock, void* dst, uint32 size, uint32 count, uint32 fileHandle, uint32 flag, uint32 errorMask, FSAsyncParams* fsAsyncParams)
 	{
 		cemu_assert_debug(flag == 0); // todo
 		return __FSReadFileAsyncEx(fsClient, fsCmdBlock, dst, size, count, false, 0, fileHandle, flag, errorMask, fsAsyncParams);
@@ -845,13 +1097,13 @@ namespace coreinit
 
 	sint32 FSReadFile(FSClient_t* fsClient, FSCmdBlock_t* fsCmdBlock, void* dst, uint32 size, uint32 count, uint32 fileHandle, uint32 flag, uint32 errorMask)
 	{
-		StackAllocator<FSAsyncParamsNew_t, 1> asyncParams;
-		__FSAsyncToSyncInit(fsClient, fsCmdBlock, asyncParams);
+		StackAllocator<FSAsyncParams, 1> asyncParams;
+		__FSAsyncToSyncInit(fsClient, fsCmdBlock, &asyncParams);
 		sint32 fsAsyncRet = FSReadFileAsync(fsClient, fsCmdBlock, dst, size, count, fileHandle, flag, errorMask, asyncParams.GetPointer());
 		return __FSProcessAsyncResult(fsClient, fsCmdBlock, fsAsyncRet, errorMask);
 	}
 
-	sint32 FSReadFileWithPosAsync(FSClient_t* fsClient, FSCmdBlock_t* fsCmdBlock, void* dst, uint32 size, uint32 count, uint32 filePos, uint32 fileHandle, uint32 flag, uint32 errorMask, FSAsyncParamsNew_t* fsAsyncParams)
+	sint32 FSReadFileWithPosAsync(FSClient_t* fsClient, FSCmdBlock_t* fsCmdBlock, void* dst, uint32 size, uint32 count, uint32 filePos, uint32 fileHandle, uint32 flag, uint32 errorMask, FSAsyncParams* fsAsyncParams)
 	{
 		cemu_assert_debug(flag == 0); // todo
 		sint32 fsStatus = __FSReadFileAsyncEx(fsClient, fsCmdBlock, dst, size, count, true, filePos, fileHandle, flag, errorMask, fsAsyncParams);
@@ -860,41 +1112,47 @@ namespace coreinit
 
 	sint32 FSReadFileWithPos(FSClient_t* fsClient, FSCmdBlock_t* fsCmdBlock, void* dst, uint32 size, uint32 count, uint32 filePos, uint32 fileHandle, uint32 flag, uint32 errorMask)
 	{
-		StackAllocator<FSAsyncParamsNew_t, 1> asyncParams;
-		__FSAsyncToSyncInit(fsClient, fsCmdBlock, asyncParams);
+		StackAllocator<FSAsyncParams, 1> asyncParams;
+		__FSAsyncToSyncInit(fsClient, fsCmdBlock, &asyncParams);
 		sint32 fsAsyncRet = FSReadFileWithPosAsync(fsClient, fsCmdBlock, dst, size, count, filePos, fileHandle, flag, errorMask, asyncParams.GetPointer());
 		return __FSProcessAsyncResult(fsClient, fsCmdBlock, fsAsyncRet, errorMask);
 	}
 
-	uint32 __FSPrepareCmd_WriteFile(FSCmdBlockBody_t* fsCmdBlockBody, void* dest, uint32 uknR6, uint32 transferSizeUknAligned, uint32 filePos, uint32 fileHandle, uint32 flag)
+	FSA_RESULT __FSPrepareCmd_WriteFile(iosu::fsa::FSAShimBuffer* fsaShimBuffer, IOSDevHandle fsaHandle, void* dest, uint32 size, uint32 count, uint32 filePos, uint32 fileHandle, uint32 flag)
 	{
-		fsCmdBlockBody->fsCmdBlockBodyMPTR = _swapEndianU32(memory_getVirtualOffsetFromPointer(fsCmdBlockBody));
-		if (fsCmdBlockBody == NULL && dest == NULL)
-			return 0xFFFCFFDD;
+		if (fsaShimBuffer == NULL || dest == NULL)
+			return FSA_RESULT::INVALID_BUFFER;
 		MPTR destMPTR = memory_getVirtualOffsetFromPointer(dest);
 		if ((destMPTR & 0x3F) != 0)
-			return 0xFFFCFFDC;
-		cemu_assert_debug((uknR6 * transferSizeUknAligned) != 0); // todo: do zero-sized writes need special treatment?
-		fsCmdBlockBody->fsCmdBlockBodyMPTR = _swapEndianU32(memory_getVirtualOffsetFromPointer(fsCmdBlockBody));
-		fsCmdBlockBody->ipcData.cmdDefault.fileHandle = _swapEndianU32(fileHandle);
-		fsCmdBlockBody->ukn0898 = _swapEndianU32(memory_getVirtualOffsetFromPointer(fsCmdBlockBody) + 0x580); // verified
-		fsCmdBlockBody->ipcData.cmdDefault.ukn0008 = _swapEndianU32(uknR6);
-		fsCmdBlockBody->ipcData.cmdDefault.ukn000C = _swapEndianU32(transferSizeUknAligned);
-		uint32 fullTransferSize = transferSizeUknAligned * uknR6;
-		fsCmdBlockBody->ukn090B = 1; // byte - verified (note: This member holds 2 for read operations)
-		fsCmdBlockBody->ukn089C = _swapEndianU32(0x293);
-		fsCmdBlockBody->ukn0890 = _swapEndianU32(fullTransferSize);
-		fsCmdBlockBody->ukn0884 = _swapEndianU32(0x520); // verified
-		fsCmdBlockBody->destBuffer88CMPTR = _swapEndianU32(destMPTR);
-		fsCmdBlockBody->ukn090A = 1;
-		fsCmdBlockBody->operationType = FSA_CMD_OPERATION_TYPE_WRITE;
-		fsCmdBlockBody->ipcData.cmdDefault.destBufferMPTR = _swapEndianU32(destMPTR);
-		fsCmdBlockBody->ipcData.cmdDefault.transferFilePos = _swapEndianU32(filePos);
-		fsCmdBlockBody->ipcData.cmdDefault.cmdFlag = _swapEndianU32(flag);
-		return (FSStatus)FS_RESULT::SUCCESS;
+			return FSA_RESULT::INVALID_ALIGNMENT;
+
+		fsaShimBuffer->fsaDevHandle = fsaHandle;
+		fsaShimBuffer->ipcReqType = 1;
+		fsaShimBuffer->operationType = (uint32)FSA_CMD_OPERATION_TYPE::WRITE;
+
+		fsaShimBuffer->ioctlvVecIn = 2;
+		fsaShimBuffer->ioctlvVecOut = 1;
+
+		fsaShimBuffer->ioctlvVec[0].baseVirt = fsaShimBuffer;
+		fsaShimBuffer->ioctlvVec[0].size = sizeof(iosu::fsa::FSARequest);
+
+		fsaShimBuffer->ioctlvVec[1].baseVirt = destMPTR;
+		fsaShimBuffer->ioctlvVec[1].size = size * count;
+
+		fsaShimBuffer->ioctlvVec[2].baseVirt = &fsaShimBuffer->response;
+		fsaShimBuffer->ioctlvVec[2].size = sizeof(iosu::fsa::FSAResponse);
+
+		fsaShimBuffer->request.cmdWriteFile.dest = dest;
+		fsaShimBuffer->request.cmdWriteFile.size = size;
+		fsaShimBuffer->request.cmdWriteFile.count = count;
+		fsaShimBuffer->request.cmdWriteFile.filePos = filePos;
+		fsaShimBuffer->request.cmdWriteFile.fileHandle = fileHandle;
+		fsaShimBuffer->request.cmdWriteFile.flag = flag;
+
+		return FSA_RESULT::OK;
 	}
 
-	sint32 __FSWriteFileWithPosAsync(FSClient_t* fsClient, FSCmdBlock_t* fsCmdBlock, void* dest, uint32 size, uint32 count, bool useFilePos, uint32 filePos, uint32 fileHandle, uint32 flag, uint32 errorMask, FSAsyncParamsNew_t* fsAsyncParams)
+	sint32 __FSWriteFileWithPosAsync(FSClient_t* fsClient, FSCmdBlock_t* fsCmdBlock, void* dest, uint32 size, uint32 count, bool useFilePos, uint32 filePos, uint32 fileHandle, uint32 flag, uint32 errorMask, FSAsyncParams* fsAsyncParams)
 	{
 		_FSCmdIntro();
 		if (size == 0 || count == 0 || dest == nullptr)
@@ -906,117 +1164,125 @@ namespace coreinit
 			cemu_assert(false);
 			return -0x400;
 		}
-		uint32 transferSize = (uint32)transferSizeS64;
-		fsCmdBlockBody->transferSize = _swapEndianU32(transferSize);
-		fsCmdBlockBody->transferElemSize = _swapEndianU32(size);
-		fsCmdBlockBody->uknVal094C = _swapEndianU32(0);
-		fsCmdBlockBody->uknVal0954 = _swapEndianU32(transferSize);
+
+		// coreinit.rpl splits up each write into smaller chunks (probably to support canceling big writes). This is handled by a specific
+		// callback for the __FSQueueCmd functions. Whenever a chunk is written, it's getting re-queued until the writing has been completed.
+		// For this it writes values into the fsCmdBlockBody->returnValues struct. At the moment we go the lazy route of just writing everything
+		// at once, so we can skip the initialization of these values.
+
 		if (useFilePos)
 			flag |= FSA_CMD_FLAG_SET_POS;
 		else
 			flag &= ~FSA_CMD_FLAG_SET_POS;
-		fsError = __FSPrepareCmd_WriteFile(fsCmdBlockBody, dest, 1, transferSize, filePos, fileHandle, flag);
-		if (fsError != (FSStatus)FS_RESULT::SUCCESS)
-			return fsError;
-		__FSQueueCmd(&fsClientBody->fsCmdQueue, fsCmdBlockBody, FS_CB_PLACEHOLDER_FINISHCMD);
+
+		FSA_RESULT prepareResult = __FSPrepareCmd_WriteFile(&fsCmdBlockBody->fsaShimBuffer, fsClientBody->iosuFSAHandle, dest, size, count, filePos, fileHandle, flag);
+		if (prepareResult != FSA_RESULT::OK)
+			return (FSStatus)_FSAStatusToFSStatus(prepareResult);
+
+		__FSQueueCmd(&fsClientBody->fsCmdQueue, fsCmdBlockBody, RPLLoader_MakePPCCallable(export___FSQueueDefaultFinishFunc));
 		return (FSStatus)FS_RESULT::SUCCESS;
 	}
 
-	sint32 FSWriteFileAsync(FSClient_t* fsClient, FSCmdBlock_t* fsCmdBlock, void* src, uint32 size, uint32 count, uint32 fileHandle, uint32 flag, uint32 errorMask, FSAsyncParamsNew_t* fsAsyncParams)
+	sint32 FSWriteFileAsync(FSClient_t* fsClient, FSCmdBlock_t* fsCmdBlock, void* src, uint32 size, uint32 count, uint32 fileHandle, uint32 flag, uint32 errorMask, FSAsyncParams* fsAsyncParams)
 	{
 		return __FSWriteFileWithPosAsync(fsClient, fsCmdBlock, src, size, count, false, 0, fileHandle, flag, errorMask, fsAsyncParams);
 	}
 
 	sint32 FSWriteFile(FSClient_t* fsClient, FSCmdBlock_t* fsCmdBlock, void* src, uint32 size, uint32 count, uint32 fileHandle, uint32 flag, uint32 errorMask)
 	{
-		StackAllocator<FSAsyncParamsNew_t, 1> asyncParams;
-		__FSAsyncToSyncInit(fsClient, fsCmdBlock, asyncParams);
+		StackAllocator<FSAsyncParams, 1> asyncParams;
+		__FSAsyncToSyncInit(fsClient, fsCmdBlock, &asyncParams);
 		sint32 fsAsyncRet = FSWriteFileAsync(fsClient, fsCmdBlock, src, size, count, fileHandle, flag, errorMask, asyncParams.GetPointer());
 		return __FSProcessAsyncResult(fsClient, fsCmdBlock, fsAsyncRet, errorMask);
 	}
 
-	sint32 FSWriteFileWithPosAsync(FSClient_t* fsClient, FSCmdBlock_t* fsCmdBlock, void* src, uint32 size, uint32 count, uint32 filePos, uint32 fileHandle, uint32 flag, uint32 errorMask, FSAsyncParamsNew_t* fsAsyncParams)
+	sint32 FSWriteFileWithPosAsync(FSClient_t* fsClient, FSCmdBlock_t* fsCmdBlock, void* src, uint32 size, uint32 count, uint32 filePos, uint32 fileHandle, uint32 flag, uint32 errorMask, FSAsyncParams* fsAsyncParams)
 	{
 		return __FSWriteFileWithPosAsync(fsClient, fsCmdBlock, src, size, count, true, filePos, fileHandle, flag, errorMask, fsAsyncParams);
 	}
 
 	sint32 FSWriteFileWithPos(FSClient_t* fsClient, FSCmdBlock_t* fsCmdBlock, void* src, uint32 size, uint32 count, uint32 filePos, uint32 fileHandle, uint32 flag, uint32 errorMask)
 	{
-		StackAllocator<FSAsyncParamsNew_t, 1> asyncParams;
-		__FSAsyncToSyncInit(fsClient, fsCmdBlock, asyncParams);
+		StackAllocator<FSAsyncParams, 1> asyncParams;
+		__FSAsyncToSyncInit(fsClient, fsCmdBlock, &asyncParams);
 		sint32 fsAsyncRet = FSWriteFileWithPosAsync(fsClient, fsCmdBlock, src, size, count, filePos, fileHandle, flag, errorMask, asyncParams.GetPointer());
 		return __FSProcessAsyncResult(fsClient, fsCmdBlock, fsAsyncRet, errorMask);
 	}
 
-	uint32 __FSPrepareCmd_SetPosFile(FSCmdBlockBody_t* fsCmdBlockBody, uint32 fileHandle, uint32 filePos)
+	FSA_RESULT __FSPrepareCmd_SetPosFile(iosu::fsa::FSAShimBuffer* fsaShimBuffer, IOSDevHandle fsaHandle, uint32 fileHandle, uint32 filePos)
 	{
-		if (fsCmdBlockBody == NULL)
-			return 0xFFFCFFDD;
-		fsCmdBlockBody->ipcData.cmdDefault.destBufferMPTR = _swapEndianU32(fileHandle);
-		fsCmdBlockBody->ipcData.cmdDefault.ukn0008 = _swapEndianU32(filePos);
-		fsCmdBlockBody->operationType = FSA_CMD_OPERATION_TYPE_SETPOS;
-		return 0;
+		if (fsaShimBuffer == NULL)
+			return FSA_RESULT::INVALID_BUFFER;
+
+		fsaShimBuffer->fsaDevHandle = fsaHandle;
+		fsaShimBuffer->ipcReqType = 0;
+		fsaShimBuffer->request.cmdSetPosFile.fileHandle = fileHandle;
+		fsaShimBuffer->request.cmdSetPosFile.filePos = filePos;
+		fsaShimBuffer->operationType = (uint32)FSA_CMD_OPERATION_TYPE::SETPOS;
+		return FSA_RESULT::OK;
 	}
 
-	sint32 FSSetPosFileAsync(FSClient_t* fsClient, FSCmdBlock_t* fsCmdBlock, uint32 fileHandle, uint32 filePos, uint32 errorMask, FSAsyncParamsNew_t* fsAsyncParams)
+	sint32 FSSetPosFileAsync(FSClient_t* fsClient, FSCmdBlock_t* fsCmdBlock, uint32 fileHandle, uint32 filePos, uint32 errorMask, FSAsyncParams* fsAsyncParams)
 	{
 		_FSCmdIntro();
-		fsError = __FSPrepareCmd_SetPosFile(fsCmdBlockBody, fileHandle, filePos);
-		if (fsError != (FSStatus)FS_RESULT::SUCCESS)
-			return fsError;
-		__FSQueueCmd(&fsClientBody->fsCmdQueue, fsCmdBlockBody, FS_CB_PLACEHOLDER_FINISHCMD);
+		FSA_RESULT prepareResult = __FSPrepareCmd_SetPosFile(&fsCmdBlockBody->fsaShimBuffer, fsClientBody->iosuFSAHandle, fileHandle, filePos);
+		if (prepareResult != FSA_RESULT::OK)
+			return (FSStatus)_FSAStatusToFSStatus(prepareResult);
+		__FSQueueCmd(&fsClientBody->fsCmdQueue, fsCmdBlockBody, RPLLoader_MakePPCCallable(export___FSQueueDefaultFinishFunc));
 		return (FSStatus)FS_RESULT::SUCCESS;
 	}
 
 	sint32 FSSetPosFile(FSClient_t* fsClient, FSCmdBlock_t* fsCmdBlock, uint32 fileHandle, uint32 filePos, uint32 errorMask)
 	{
 		// used by games: Mario Kart 8
-		StackAllocator<FSAsyncParamsNew_t, 1> asyncParams;
-		__FSAsyncToSyncInit(fsClient, fsCmdBlock, asyncParams);
+		StackAllocator<FSAsyncParams, 1> asyncParams;
+		__FSAsyncToSyncInit(fsClient, fsCmdBlock, &asyncParams);
 		sint32 fsAsyncRet = FSSetPosFileAsync(fsClient, fsCmdBlock, fileHandle, filePos, errorMask, asyncParams.GetPointer());
 		return __FSProcessAsyncResult(fsClient, fsCmdBlock, fsAsyncRet, errorMask);
 	}
 
-	uint32 __FSPrepareCmd_GetPosFile(FSCmdBlockBody_t* fsCmdBlockBody, uint32 fileHandle)
+	FSA_RESULT __FSPrepareCmd_GetPosFile(iosu::fsa::FSAShimBuffer* fsaShimBuffer, IOSDevHandle fsaHandle, uint32 fileHandle)
 	{
-		if (fsCmdBlockBody == NULL)
-			return 0xFFFCFFDD;
-		fsCmdBlockBody->ipcData.cmdDefault.destBufferMPTR = _swapEndianU32(fileHandle);
-		fsCmdBlockBody->operationType = FSA_CMD_OPERATION_TYPE_GETPOS;
-		return 0;
+		if (fsaShimBuffer == NULL)
+			return FSA_RESULT::INVALID_BUFFER;
+		fsaShimBuffer->fsaDevHandle = fsaHandle;
+		fsaShimBuffer->ipcReqType = 0;
+		fsaShimBuffer->request.cmdGetPosFile.fileHandle = fileHandle;
+		fsaShimBuffer->operationType = (uint32)FSA_CMD_OPERATION_TYPE::GETPOS;
+		return FSA_RESULT::OK;
 	}
 
-	sint32 FSGetPosFileAsync(FSClient_t* fsClient, FSCmdBlock_t* fsCmdBlock, uint32 fileHandle, uint32be* returnedFilePos, uint32 errorMask, FSAsyncParamsNew_t* fsAsyncParams)
+	sint32 FSGetPosFileAsync(FSClient_t* fsClient, FSCmdBlock_t* fsCmdBlock, uint32 fileHandle, uint32be* returnedFilePos, uint32 errorMask, FSAsyncParams* fsAsyncParams)
 	{
 		// games using this: Darksiders Warmastered Edition
 		_FSCmdIntro();
-		fsCmdBlockBody->returnValueMPTR = _swapEndianU32(memory_getVirtualOffsetFromPointer(returnedFilePos));
-		fsError = __FSPrepareCmd_GetPosFile(fsCmdBlockBody, fileHandle);
-		if (fsError != (FSStatus)FS_RESULT::SUCCESS)
-			return fsError;
-		__FSQueueCmd(&fsClientBody->fsCmdQueue, fsCmdBlockBody, FS_CB_PLACEHOLDER_FINISHCMD);
+		fsCmdBlockBody->returnValues.cmdGetPosFile.filePosPtr = returnedFilePos;
+		FSA_RESULT prepareResult = __FSPrepareCmd_GetPosFile(&fsCmdBlockBody->fsaShimBuffer, fsClientBody->iosuFSAHandle, fileHandle);
+		if (prepareResult != FSA_RESULT::OK)
+			return (FSStatus)_FSAStatusToFSStatus(prepareResult);
+		__FSQueueCmd(&fsClientBody->fsCmdQueue, fsCmdBlockBody, RPLLoader_MakePPCCallable(export___FSQueueDefaultFinishFunc));
 		return (FSStatus)FS_RESULT::SUCCESS;
 	}
 
 	sint32 FSGetPosFile(FSClient_t* fsClient, FSCmdBlock_t* fsCmdBlock, uint32 fileHandle, uint32be* returnedFilePos, uint32 errorMask)
 	{
-		StackAllocator<FSAsyncParamsNew_t, 1> asyncParams;
-		__FSAsyncToSyncInit(fsClient, fsCmdBlock, asyncParams);
+		StackAllocator<FSAsyncParams, 1> asyncParams;
+		__FSAsyncToSyncInit(fsClient, fsCmdBlock, &asyncParams);
 		sint32 fsAsyncRet = FSGetPosFileAsync(fsClient, fsCmdBlock, fileHandle, returnedFilePos, errorMask, asyncParams.GetPointer());
 		return __FSProcessAsyncResult(fsClient, fsCmdBlock, fsAsyncRet, errorMask);
 	}
 
-	sint32 __FSPrepareCmd_OpenDir(FSCmdBlockBody_t* fsCmdBlockBody, char* path)
+	FSA_RESULT __FSPrepareCmd_OpenDir(iosu::fsa::FSAShimBuffer* fsaShimBuffer, IOSDevHandle fsaHandle, char* path)
 	{
-		fsCmdBlockBody->fsCmdBlockBodyMPTR = _swapEndianU32(memory_getVirtualOffsetFromPointer(fsCmdBlockBody));
-		if (fsCmdBlockBody == nullptr)
-			return 0xFFFCFFDD;
+		if (fsaShimBuffer == nullptr)
+			return FSA_RESULT::INVALID_BUFFER;
 		if (path == nullptr)
-			return 0xFFFCFFDD + 1;
+			return FSA_RESULT::INVALID_PATH;
+
+		fsaShimBuffer->fsaDevHandle = fsaHandle;
+		fsaShimBuffer->ipcReqType = 0;
+		fsaShimBuffer->operationType = (uint32)FSA_CMD_OPERATION_TYPE::OPENDIR;
 
-		fsCmdBlockBody->fsCmdBlockBodyMPTR = _swapEndianU32(memory_getVirtualOffsetFromPointer(fsCmdBlockBody));
-		fsCmdBlockBody->ipcData.cmdOpenDir.dirHandleOutput = -1;
-		fsCmdBlockBody->operationType = FSA_CMD_OPERATION_TYPE_OPENDIR;
 		// path
 		sint32 pathLen = (sint32)strlen((char*)path);
 		if (pathLen >= FSA_CMD_PATH_MAX_LENGTH)
@@ -1025,131 +1291,206 @@ namespace coreinit
 			pathLen = FSA_CMD_PATH_MAX_LENGTH - 1;
 		}
 		for (sint32 i = 0; i < pathLen; i++)
-			fsCmdBlockBody->ipcData.cmdOpenDir.path[i] = path[i];
+			fsaShimBuffer->request.cmdOpenDir.path[i] = path[i];
 		for (sint32 i = pathLen; i < FSA_CMD_PATH_MAX_LENGTH; i++)
-			fsCmdBlockBody->ipcData.cmdOpenDir.path[i] = '\0';
-		return 0;
+			fsaShimBuffer->request.cmdOpenDir.path[i] = '\0';
+
+		fsaShimBuffer->response.cmdOpenDir.dirHandleOutput = -1;
+
+		return FSA_RESULT::OK;
 	}
 
-	sint32 FSOpenDirAsync(FSClient_t* fsClient, FSCmdBlock_t* fsCmdBlock, char* path, FSDirHandlePtr dirHandleOut, uint32 errorMask, FSAsyncParamsNew_t* fsAsyncParams)
+	sint32 FSOpenDirAsync(FSClient_t* fsClient, FSCmdBlock_t* fsCmdBlock, char* path, FSDirHandlePtr dirHandleOut, uint32 errorMask, FSAsyncParams* fsAsyncParams)
 	{
 		_FSCmdIntro();
 		cemu_assert(dirHandleOut && path);
-		fsCmdBlockBody->returnValueMPTR = _swapEndianU32(dirHandleOut.GetMPTR());
-		fsError = __FSPrepareCmd_OpenDir(fsCmdBlockBody, path);
-		if (fsError != (FSStatus)FS_RESULT::SUCCESS)
-			return fsError;
-		__FSQueueCmd(&fsClientBody->fsCmdQueue, fsCmdBlockBody, FS_CB_PLACEHOLDER_FINISHCMD);
+		fsCmdBlockBody->returnValues.cmdOpenDir.handlePtr = dirHandleOut.GetMPTR();
+		FSA_RESULT prepareResult = __FSPrepareCmd_OpenDir(&fsCmdBlockBody->fsaShimBuffer, fsClientBody->iosuFSAHandle, path);
+		if (prepareResult != FSA_RESULT::OK)
+			return (FSStatus)_FSAStatusToFSStatus(prepareResult);
+		__FSQueueCmd(&fsClientBody->fsCmdQueue, fsCmdBlockBody, RPLLoader_MakePPCCallable(export___FSQueueDefaultFinishFunc));
 		return (FSStatus)FS_RESULT::SUCCESS;
 	}
 
 	sint32 FSOpenDir(FSClient_t* fsClient, FSCmdBlock_t* fsCmdBlock, char* path, FSDirHandlePtr dirHandleOut, uint32 errorMask)
 	{
-		StackAllocator<FSAsyncParamsNew_t, 1> asyncParams;
-		__FSAsyncToSyncInit(fsClient, fsCmdBlock, asyncParams);
-		sint32 fsAsyncRet = FSOpenDirAsync(fsClient, fsCmdBlock, path, dirHandleOut, errorMask, asyncParams);
+		StackAllocator<FSAsyncParams, 1> asyncParams;
+		__FSAsyncToSyncInit(fsClient, fsCmdBlock, &asyncParams);
+		sint32 fsAsyncRet = FSOpenDirAsync(fsClient, fsCmdBlock, path, dirHandleOut, errorMask, &asyncParams);
 		return __FSProcessAsyncResult(fsClient, fsCmdBlock, fsAsyncRet, errorMask);
 	}
 
-	void __FSPrepareCmd_ReadDir(FSCmdBlockBody_t* fsCmdBlockBody, FSDirHandle2 dirHandle, FSDirEntry_t* dirEntryOut)
+	FSA_RESULT __FSPrepareCmd_ReadDir(iosu::fsa::FSAShimBuffer* fsaShimBuffer, IOSDevHandle fsaHandle, FSDirHandle2 dirHandle)
 	{
-		fsCmdBlockBody->returnValueMPTR = _swapEndianU32(memory_getVirtualOffsetFromPointer(dirEntryOut));
-		fsCmdBlockBody->operationType = FSA_CMD_OPERATION_TYPE_READDIR;
-		fsCmdBlockBody->ipcData.cmdReadDir.dirHandle = dirHandle;
+		if (fsaShimBuffer == nullptr)
+			return FSA_RESULT::INVALID_BUFFER;
+		fsaShimBuffer->fsaDevHandle = fsaHandle;
+		fsaShimBuffer->ipcReqType = 0;
+		fsaShimBuffer->operationType = (uint32)FSA_CMD_OPERATION_TYPE::READDIR;
+		fsaShimBuffer->request.cmdReadDir.dirHandle = dirHandle;
+		return FSA_RESULT::OK;
 	}
 
-	sint32 FSReadDirAsync(FSClient_t* fsClient, FSCmdBlock_t* fsCmdBlock, FSDirHandle2 dirHandle, FSDirEntry_t* dirEntryOut, uint32 errorMask, FSAsyncParamsNew_t* fsAsyncParams)
+	sint32 FSReadDirAsync(FSClient_t* fsClient, FSCmdBlock_t* fsCmdBlock, FSDirHandle2 dirHandle, FSDirEntry_t* dirEntryOut, uint32 errorMask, FSAsyncParams* fsAsyncParams)
 	{
 		_FSCmdIntro();
-		__FSPrepareCmd_ReadDir(fsCmdBlockBody, dirHandle, dirEntryOut);
-		__FSQueueCmd(&fsClientBody->fsCmdQueue, fsCmdBlockBody, FS_CB_PLACEHOLDER_FINISHCMD);
+		FSA_RESULT prepareResult = __FSPrepareCmd_ReadDir(&fsCmdBlockBody->fsaShimBuffer, fsClientBody->iosuFSAHandle, dirHandle);
+		if (prepareResult != FSA_RESULT::OK)
+			return (FSStatus)_FSAStatusToFSStatus(prepareResult);
+		fsCmdBlockBody->returnValues.cmdReadDir.dirEntryPtr = dirEntryOut;
+		__FSQueueCmd(&fsClientBody->fsCmdQueue, fsCmdBlockBody, RPLLoader_MakePPCCallable(export___FSQueueDefaultFinishFunc));
 		return (FSStatus)FS_RESULT::SUCCESS;
 	}
 
-	sint32 FSReadDir(FSClient_t* fsClient, FSCmdBlock_t* fsCmdBlock, FSDirHandle2 dirHandle, FSDirEntry_t* dirEntryOut, uint32 errorMask, FSAsyncParamsNew_t* fsAsyncParams)
+	sint32 FSReadDir(FSClient_t* fsClient, FSCmdBlock_t* fsCmdBlock, FSDirHandle2 dirHandle, FSDirEntry_t* dirEntryOut, uint32 errorMask, FSAsyncParams* fsAsyncParams)
 	{
-		StackAllocator<FSAsyncParamsNew_t, 1> asyncParams;
-		__FSAsyncToSyncInit(fsClient, fsCmdBlock, asyncParams);
-		sint32 fsAsyncRet = FSReadDirAsync(fsClient, fsCmdBlock, dirHandle, dirEntryOut, errorMask, asyncParams);
+		StackAllocator<FSAsyncParams, 1> asyncParams;
+		__FSAsyncToSyncInit(fsClient, fsCmdBlock, &asyncParams);
+		sint32 fsAsyncRet = FSReadDirAsync(fsClient, fsCmdBlock, dirHandle, dirEntryOut, errorMask, &asyncParams);
 		return __FSProcessAsyncResult(fsClient, fsCmdBlock, fsAsyncRet, errorMask);
 	}
 
-	void __FSPrepareCmd_CloseDir(FSCmdBlockBody_t* fsCmdBlockBody, FSDirHandle2 dirHandle)
+	FSA_RESULT __FSPrepareCmd_CloseDir(iosu::fsa::FSAShimBuffer* fsaShimBuffer, IOSDevHandle fsaHandle, FSDirHandle2 dirHandle)
 	{
-		fsCmdBlockBody->operationType = FSA_CMD_OPERATION_TYPE_CLOSEDIR;
-		fsCmdBlockBody->ipcData.cmdCloseDir.dirHandle = dirHandle;
+		if (fsaShimBuffer == nullptr)
+			return FSA_RESULT::INVALID_BUFFER;
+		fsaShimBuffer->fsaDevHandle = fsaHandle;
+		fsaShimBuffer->ipcReqType = 0;
+		fsaShimBuffer->operationType = (uint32)FSA_CMD_OPERATION_TYPE::CLOSEDIR;
+		fsaShimBuffer->request.cmdCloseDir.dirHandle = dirHandle;
+		return FSA_RESULT::OK;
 	}
 
-	sint32 FSCloseDirAsync(FSClient_t* fsClient, FSCmdBlock_t* fsCmdBlock, FSDirHandle2 dirHandle, uint32 errorMask, FSAsyncParamsNew_t* fsAsyncParams)
+	sint32 FSCloseDirAsync(FSClient_t* fsClient, FSCmdBlock_t* fsCmdBlock, FSDirHandle2 dirHandle, uint32 errorMask, FSAsyncParams* fsAsyncParams)
 	{
 		_FSCmdIntro();
-		__FSPrepareCmd_CloseDir(fsCmdBlockBody, dirHandle);
-		__FSQueueCmd(&fsClientBody->fsCmdQueue, fsCmdBlockBody, FS_CB_PLACEHOLDER_FINISHCMD);
+		FSA_RESULT prepareResult = __FSPrepareCmd_CloseDir(&fsCmdBlockBody->fsaShimBuffer, fsClientBody->iosuFSAHandle, dirHandle);
+		if (prepareResult != FSA_RESULT::OK)
+			return (FSStatus)_FSAStatusToFSStatus(prepareResult);
+
+		__FSQueueCmd(&fsClientBody->fsCmdQueue, fsCmdBlockBody, RPLLoader_MakePPCCallable(export___FSQueueDefaultFinishFunc));
 		return (FSStatus)FS_RESULT::SUCCESS;
 	}
 
 	sint32 FSCloseDir(FSClient_t* fsClient, FSCmdBlock_t* fsCmdBlock, FSDirHandle2 dirHandle, uint32 errorMask)
 	{
-		StackAllocator<FSAsyncParamsNew_t, 1> asyncParams;
-		__FSAsyncToSyncInit(fsClient, fsCmdBlock, asyncParams);
-		sint32 fsAsyncRet = FSCloseDirAsync(fsClient, fsCmdBlock, dirHandle, errorMask, asyncParams);
+		StackAllocator<FSAsyncParams, 1> asyncParams;
+		__FSAsyncToSyncInit(fsClient, fsCmdBlock, &asyncParams);
+		sint32 fsAsyncRet = FSCloseDirAsync(fsClient, fsCmdBlock, dirHandle, errorMask, &asyncParams);
 		return __FSProcessAsyncResult(fsClient, fsCmdBlock, fsAsyncRet, errorMask);
 	}
 
-	void __FSPrepareCmd_AppendFile(FSCmdBlockBody_t* fsCmdBlockBody, uint32 fileHandle, uint32 size, uint32 count, uint32 uknParam)
+	FSA_RESULT __FSPrepareCmd_RewindDir(iosu::fsa::FSAShimBuffer* fsaShimBuffer, IOSDevHandle fsaHandle, FSDirHandle2 dirHandle)
 	{
-		fsCmdBlockBody->ipcData.cmdAppendFile.fileHandle = _swapEndianU32(fileHandle);
-		fsCmdBlockBody->ipcData.cmdAppendFile.count = _swapEndianU32(size);
-		fsCmdBlockBody->ipcData.cmdAppendFile.size = _swapEndianU32(count);
-		fsCmdBlockBody->ipcData.cmdAppendFile.uknParam = _swapEndianU32(uknParam);
-		fsCmdBlockBody->operationType = FSA_CMD_OPERATION_TYPE_APPENDFILE;
+		if (fsaShimBuffer == nullptr)
+			return FSA_RESULT::INVALID_BUFFER;
+
+		fsaShimBuffer->fsaDevHandle = fsaHandle;
+		fsaShimBuffer->ipcReqType = 0;
+		fsaShimBuffer->operationType = (uint32)FSA_CMD_OPERATION_TYPE::REWINDDIR;
+
+		fsaShimBuffer->request.cmdRewindDir.dirHandle = dirHandle;
+
+		return FSA_RESULT::OK;
 	}
 
-	sint32 FSAppendFileAsync(FSClient_t* fsClient, FSCmdBlock_t* fsCmdBlock, uint32 fileHandle, uint32 size, uint32 count, uint32 errorMask, FSAsyncParamsNew_t* fsAsyncParams)
+	sint32 FSRewindDirAsync(FSClient_t* fsClient, FSCmdBlock_t* fsCmdBlock, FSDirHandle2 dirHandle, uint32 errorMask, FSAsyncParams* fsAsyncParams)
 	{
 		_FSCmdIntro();
-		__FSPrepareCmd_AppendFile(fsCmdBlockBody, fileHandle, size, count, 0);
-		__FSQueueCmd(&fsClientBody->fsCmdQueue, fsCmdBlockBody, FS_CB_PLACEHOLDER_FINISHCMD);
+		FSA_RESULT prepareResult = __FSPrepareCmd_RewindDir(&fsCmdBlockBody->fsaShimBuffer, fsClientBody->iosuFSAHandle, dirHandle);
+		if (prepareResult != FSA_RESULT::OK)
+			return (FSStatus)_FSAStatusToFSStatus(prepareResult);
+
+		__FSQueueCmd(&fsClientBody->fsCmdQueue, fsCmdBlockBody, RPLLoader_MakePPCCallable(export___FSQueueDefaultFinishFunc));
 		return (FSStatus)FS_RESULT::SUCCESS;
 	}
 
-	sint32 FSAppendFile(FSClient_t* fsClient, FSCmdBlock_t* fsCmdBlock, uint32 fileHandle, uint32 size, uint32 count, uint32 errorMask)
+	sint32 FSRewindDir(FSClient_t* fsClient, FSCmdBlock_t* fsCmdBlock, FSDirHandle2 dirHandle, uint32 errorMask)
 	{
-		StackAllocator<FSAsyncParamsNew_t> asyncParams;
-		__FSAsyncToSyncInit(fsClient, fsCmdBlock, asyncParams);
-		sint32 fsAsyncRet = FSAppendFileAsync(fsClient, fsCmdBlock, fileHandle, size, count, errorMask, asyncParams.GetPointer());
+		StackAllocator<FSAsyncParams, 1> asyncParams;
+		__FSAsyncToSyncInit(fsClient, fsCmdBlock, &asyncParams);
+		sint32 fsAsyncRet = FSRewindDirAsync(fsClient, fsCmdBlock, dirHandle, errorMask, &asyncParams);
 		return __FSProcessAsyncResult(fsClient, fsCmdBlock, fsAsyncRet, errorMask);
 	}
 
-	void __FSPrepareCmd_TruncateFile(FSCmdBlockBody_t* fsCmdBlockBody, FSFileHandle2 fileHandle)
+	FSA_RESULT __FSPrepareCmd_AppendFile(iosu::fsa::FSAShimBuffer* fsaShimBuffer, IOSDevHandle fsaHandle, uint32 size, uint32 count, uint32 fileHandle, uint32 uknParam)
 	{
-		fsCmdBlockBody->ipcData.cmdTruncateFile.fileHandle = fileHandle;
-		fsCmdBlockBody->ipcData.cmdTruncateFile.ukn0008 = 0;
-		fsCmdBlockBody->operationType = FSA_CMD_OPERATION_TYPE_TRUNCATEFILE;
+		if (fsaShimBuffer == nullptr)
+			return FSA_RESULT::INVALID_BUFFER;
+		fsaShimBuffer->fsaDevHandle = fsaHandle;
+		fsaShimBuffer->ipcReqType = 0;
+		fsaShimBuffer->operationType = (uint32)FSA_CMD_OPERATION_TYPE::APPENDFILE;
+
+		fsaShimBuffer->request.cmdAppendFile.fileHandle = fileHandle;
+		fsaShimBuffer->request.cmdAppendFile.count = count;
+		fsaShimBuffer->request.cmdAppendFile.size = size;
+		fsaShimBuffer->request.cmdAppendFile.uknParam = uknParam;
+
+		return FSA_RESULT::OK;
 	}
 
-	sint32 FSTruncateFileAsync(FSClient_t* fsClient, FSCmdBlock_t* fsCmdBlock, FSFileHandle2 fileHandle, uint32 errorMask, FSAsyncParamsNew_t* fsAsyncParams)
+	sint32 FSAppendFileAsync(FSClient_t* fsClient, FSCmdBlock_t* fsCmdBlock, uint32 size, uint32 count, uint32 fileHandle, uint32 errorMask, FSAsyncParams* fsAsyncParams)
 	{
 		_FSCmdIntro();
-		__FSPrepareCmd_TruncateFile(fsCmdBlockBody, fileHandle);
-		__FSQueueCmd(&fsClientBody->fsCmdQueue, fsCmdBlockBody, FS_CB_PLACEHOLDER_FINISHCMD);
+		FSA_RESULT prepareResult = __FSPrepareCmd_AppendFile(&fsCmdBlockBody->fsaShimBuffer, fsClientBody->iosuFSAHandle, size, count, fileHandle, 0);
+		if (prepareResult != FSA_RESULT::OK)
+			return (FSStatus)_FSAStatusToFSStatus(prepareResult);
+
+		__FSQueueCmd(&fsClientBody->fsCmdQueue, fsCmdBlockBody, RPLLoader_MakePPCCallable(export___FSQueueDefaultFinishFunc));
+		return (FSStatus)FS_RESULT::SUCCESS;
+	}
+
+	sint32 FSAppendFile(FSClient_t* fsClient, FSCmdBlock_t* fsCmdBlock, uint32 size, uint32 count, uint32 fileHandle, uint32 errorMask)
+	{
+		StackAllocator<FSAsyncParams> asyncParams;
+		__FSAsyncToSyncInit(fsClient, fsCmdBlock, &asyncParams);
+		sint32 fsAsyncRet = FSAppendFileAsync(fsClient, fsCmdBlock, size, count, fileHandle, errorMask, asyncParams.GetPointer());
+		return __FSProcessAsyncResult(fsClient, fsCmdBlock, fsAsyncRet, errorMask);
+	}
+
+	FSA_RESULT __FSPrepareCmd_TruncateFile(iosu::fsa::FSAShimBuffer* fsaShimBuffer, IOSDevHandle fsaHandle, FSFileHandle2 fileHandle)
+	{
+		if (fsaShimBuffer == nullptr)
+			return FSA_RESULT::INVALID_BUFFER;
+		fsaShimBuffer->fsaDevHandle = fsaHandle;
+		fsaShimBuffer->ipcReqType = 0;
+		fsaShimBuffer->operationType = (uint32)FSA_CMD_OPERATION_TYPE::TRUNCATEFILE;
+
+		fsaShimBuffer->request.cmdTruncateFile.fileHandle = fileHandle;
+
+		return FSA_RESULT::OK;
+	}
+
+	sint32 FSTruncateFileAsync(FSClient_t* fsClient, FSCmdBlock_t* fsCmdBlock, FSFileHandle2 fileHandle, uint32 errorMask, FSAsyncParams* fsAsyncParams)
+	{
+		_FSCmdIntro();
+		FSA_RESULT prepareResult = __FSPrepareCmd_TruncateFile(&fsCmdBlockBody->fsaShimBuffer, fsClientBody->iosuFSAHandle, fileHandle);
+		if (prepareResult != FSA_RESULT::OK)
+			return (FSStatus)_FSAStatusToFSStatus(prepareResult);
+
+		__FSQueueCmd(&fsClientBody->fsCmdQueue, fsCmdBlockBody, RPLLoader_MakePPCCallable(export___FSQueueDefaultFinishFunc));
 		return (FSStatus)FS_RESULT::SUCCESS;
 	}
 
 	sint32 FSTruncateFile(FSClient_t* fsClient, FSCmdBlock_t* fsCmdBlock, FSFileHandle2 fileHandle, uint32 errorMask)
 	{
-		StackAllocator<FSAsyncParamsNew_t> asyncParams;
-		__FSAsyncToSyncInit(fsClient, fsCmdBlock, asyncParams);
+		StackAllocator<FSAsyncParams> asyncParams;
+		__FSAsyncToSyncInit(fsClient, fsCmdBlock, &asyncParams);
 		sint32 fsAsyncRet = FSTruncateFileAsync(fsClient, fsCmdBlock, fileHandle, errorMask, asyncParams.GetPointer());
 		return __FSProcessAsyncResult(fsClient, fsCmdBlock, fsAsyncRet, errorMask);
 	}
 
-	sint32 __FSPrepareCmd_Rename(FSCmdBlockBody_t* fsCmdBlockBody, char* srcPath, char* dstPath)
+	FSA_RESULT __FSPrepareCmd_Rename(iosu::fsa::FSAShimBuffer* fsaShimBuffer, IOSDevHandle fsaHandle, char* srcPath, char* dstPath)
 	{
-		if (fsCmdBlockBody == NULL)
-			return 0xFFFCFFDD;
+		if (fsaShimBuffer == nullptr)
+			return FSA_RESULT::INVALID_BUFFER;
 		if (srcPath == NULL || dstPath == NULL)
-			return 0xFFFCFFDE;
+			return FSA_RESULT::INVALID_PATH;
+
+		fsaShimBuffer->fsaDevHandle = fsaHandle;
+		fsaShimBuffer->ipcReqType = 0;
+		fsaShimBuffer->operationType = (uint32)FSA_CMD_OPERATION_TYPE::RENAME;
+
 		// source path
 		size_t stringLen = strlen((char*)srcPath);
 		if (stringLen >= FSA_CMD_PATH_MAX_LENGTH)
@@ -1159,9 +1500,9 @@ namespace coreinit
 		}
 		for (sint32 i = 0; i < stringLen; i++)
 		{
-			fsCmdBlockBody->ipcData.cmdRename.srcPath[i] = srcPath[i];
+			fsaShimBuffer->request.cmdRename.srcPath[i] = srcPath[i];
 		}
-		fsCmdBlockBody->ipcData.cmdRename.srcPath[stringLen] = '\0';
+		fsaShimBuffer->request.cmdRename.srcPath[stringLen] = '\0';
 		// destination path
 		stringLen = strlen((char*)dstPath);
 		if (stringLen >= FSA_CMD_PATH_MAX_LENGTH)
@@ -1171,14 +1512,14 @@ namespace coreinit
 		}
 		for (sint32 i = 0; i < stringLen; i++)
 		{
-			fsCmdBlockBody->ipcData.cmdRename.dstPath[i] = dstPath[i];
+			fsaShimBuffer->request.cmdRename.dstPath[i] = dstPath[i];
 		}
-		fsCmdBlockBody->ipcData.cmdRename.dstPath[stringLen] = '\0';
-		fsCmdBlockBody->operationType = FSA_CMD_OPERATION_TYPE_RENAME;
-		return 0;
+		fsaShimBuffer->request.cmdRename.dstPath[stringLen] = '\0';
+
+		return FSA_RESULT::OK;
 	}
 
-	sint32 FSRenameAsync(FSClient_t* fsClient, FSCmdBlock_t* fsCmdBlock, char* srcPath, char* dstPath, uint32 errorMask, FSAsyncParamsNew_t* fsAsyncParams)
+	sint32 FSRenameAsync(FSClient_t* fsClient, FSCmdBlock_t* fsCmdBlock, char* srcPath, char* dstPath, uint32 errorMask, FSAsyncParams* fsAsyncParams)
 	{
 		// used by titles: XCX (via SAVERenameAsync)
 		_FSCmdIntro();
@@ -1187,27 +1528,33 @@ namespace coreinit
 			cemu_assert_debug(false); // path must not be NULL
 			return -0x400;
 		}
-		fsError = __FSPrepareCmd_Rename(fsCmdBlockBody, srcPath, dstPath);
-		if (fsError != (FSStatus)FS_RESULT::SUCCESS)
-			return fsError;
-		__FSQueueCmd(&fsClientBody->fsCmdQueue, fsCmdBlockBody, FS_CB_PLACEHOLDER_FINISHCMD);
+		FSA_RESULT prepareResult = __FSPrepareCmd_Rename(&fsCmdBlockBody->fsaShimBuffer, fsClientBody->iosuFSAHandle, srcPath, dstPath);
+		if (prepareResult != FSA_RESULT::OK)
+			return (FSStatus)_FSAStatusToFSStatus(prepareResult);
+
+		__FSQueueCmd(&fsClientBody->fsCmdQueue, fsCmdBlockBody, RPLLoader_MakePPCCallable(export___FSQueueDefaultFinishFunc));
 		return (FSStatus)FS_RESULT::SUCCESS;
 	}
 
 	sint32 FSRename(FSClient_t* fsClient, FSCmdBlock_t* fsCmdBlock, char* srcPath, char* dstPath, uint32 errorMask)
 	{
-		StackAllocator<FSAsyncParamsNew_t> asyncParams;
-		__FSAsyncToSyncInit(fsClient, fsCmdBlock, asyncParams);
+		StackAllocator<FSAsyncParams> asyncParams;
+		__FSAsyncToSyncInit(fsClient, fsCmdBlock, &asyncParams);
 		sint32 fsAsyncRet = FSRenameAsync(fsClient, fsCmdBlock, srcPath, dstPath, errorMask, asyncParams.GetPointer());
 		return __FSProcessAsyncResult(fsClient, fsCmdBlock, fsAsyncRet, errorMask);
 	}
 
-	sint32 __FSPrepareCmd_Remove(FSCmdBlockBody_t* fsCmdBlockBody, uint8* path)
+	FSA_RESULT __FSPrepareCmd_Remove(iosu::fsa::FSAShimBuffer* fsaShimBuffer, IOSDevHandle devHandle, uint8* path)
 	{
-		if (fsCmdBlockBody == NULL)
-			return 0xFFFCFFDD;
+		if (fsaShimBuffer == NULL)
+			return FSA_RESULT::INVALID_BUFFER;
 		if (path == NULL)
-			return 0xFFFCFFDE;
+			return FSA_RESULT::INVALID_PATH;
+
+		fsaShimBuffer->fsaDevHandle = devHandle;
+		fsaShimBuffer->ipcReqType = 0;
+		fsaShimBuffer->operationType = (uint32)FSA_CMD_OPERATION_TYPE::REMOVE;
+
 		size_t pathLen = strlen((char*)path);
 		if (pathLen >= FSA_CMD_PATH_MAX_LENGTH)
 		{
@@ -1216,14 +1563,14 @@ namespace coreinit
 		}
 		for (sint32 i = 0; i < pathLen; i++)
 		{
-			fsCmdBlockBody->ipcData.cmdRemove.path[i] = path[i];
+			fsaShimBuffer->request.cmdRemove.path[i] = path[i];
 		}
-		fsCmdBlockBody->ipcData.cmdRemove.path[pathLen] = '\0';
-		fsCmdBlockBody->operationType = FSA_CMD_OPERATION_TYPE_REMOVE;
-		return 0;
+		fsaShimBuffer->request.cmdRemove.path[pathLen] = '\0';
+
+		return FSA_RESULT::OK;
 	}
 
-	sint32 FSRemoveAsync(FSClient_t* fsClient, FSCmdBlock_t* fsCmdBlock, uint8* filePath, uint32 errorMask, FSAsyncParamsNew_t* fsAsyncParams)
+	sint32 FSRemoveAsync(FSClient_t* fsClient, FSCmdBlock_t* fsCmdBlock, uint8* filePath, uint32 errorMask, FSAsyncParams* fsAsyncParams)
 	{
 		// used by titles: XCX (via SAVERemoveAsync)
 		_FSCmdIntro();
@@ -1232,31 +1579,33 @@ namespace coreinit
 			cemu_assert_debug(false); // path must not be NULL
 			return -0x400;
 		}
-		uint32 ukn1444 = _swapEndianU32(fsClientBody->iosuFSAHandle);
-		fsError = __FSPrepareCmd_Remove(fsCmdBlockBody, filePath);
-		if (fsError != (FSStatus)FS_RESULT::SUCCESS)
-		{
-			cemu_assert_debug(false);
-			return fsError;
-		}
-		__FSQueueCmd(&fsClientBody->fsCmdQueue, fsCmdBlockBody, FS_CB_PLACEHOLDER_FINISHCMD);
+		FSA_RESULT prepareResult = __FSPrepareCmd_Remove(&fsCmdBlockBody->fsaShimBuffer, fsClientBody->iosuFSAHandle, filePath);
+		if (prepareResult != FSA_RESULT::OK)
+			return (FSStatus)_FSAStatusToFSStatus(prepareResult);
+
+		__FSQueueCmd(&fsClientBody->fsCmdQueue, fsCmdBlockBody, RPLLoader_MakePPCCallable(export___FSQueueDefaultFinishFunc));
 		return (FSStatus)FS_RESULT::SUCCESS;
 	}
 
 	sint32 FSRemove(FSClient_t* fsClient, FSCmdBlock_t* fsCmdBlock, uint8* filePath, uint32 errorMask)
 	{
-		StackAllocator<FSAsyncParamsNew_t> asyncParams;
-		__FSAsyncToSyncInit(fsClient, fsCmdBlock, asyncParams);
-		sint32 fsAsyncRet = FSRemoveAsync(fsClient, fsCmdBlock, filePath, errorMask, asyncParams);
+		StackAllocator<FSAsyncParams> asyncParams;
+		__FSAsyncToSyncInit(fsClient, fsCmdBlock, &asyncParams);
+		sint32 fsAsyncRet = FSRemoveAsync(fsClient, fsCmdBlock, filePath, errorMask, &asyncParams);
 		return __FSProcessAsyncResult(fsClient, fsCmdBlock, fsAsyncRet, errorMask);
 	}
 
-	uint32 __FSPrepareCmd_MakeDir(FSCmdBlockBody_t* fsCmdBlockBody, const uint8* path, uint32 uknVal660)
+	FSA_RESULT __FSPrepareCmd_MakeDir(iosu::fsa::FSAShimBuffer* fsaShimBuffer, IOSDevHandle devHandle, const char* path, uint32 uknVal660)
 	{
-		if (fsCmdBlockBody == NULL)
-			return 0xFFFCFFDD;
+		if (fsaShimBuffer == NULL)
+			return FSA_RESULT::INVALID_BUFFER;
 		if (path == NULL)
-			return 0xFFFCFFDE;
+			return FSA_RESULT::INVALID_PATH;
+
+		fsaShimBuffer->fsaDevHandle = devHandle;
+		fsaShimBuffer->ipcReqType = 0;
+		fsaShimBuffer->operationType = (uint32)FSA_CMD_OPERATION_TYPE::MAKEDIR;
+
 		size_t pathLen = strlen((char*)path);
 		if (pathLen >= FSA_CMD_PATH_MAX_LENGTH)
 		{
@@ -1265,15 +1614,15 @@ namespace coreinit
 		}
 		for (sint32 i = 0; i < pathLen; i++)
 		{
-			fsCmdBlockBody->ipcData.cmdMakeDir.path[i] = path[i];
+			fsaShimBuffer->request.cmdMakeDir.path[i] = path[i];
 		}
-		fsCmdBlockBody->ipcData.cmdMakeDir.path[pathLen] = '\0';
-		fsCmdBlockBody->ipcData.cmdMakeDir.uknParam = _swapEndianU32(uknVal660);
-		fsCmdBlockBody->operationType = FSA_CMD_OPERATION_TYPE_MAKEDIR;
-		return 0;
+		fsaShimBuffer->request.cmdMakeDir.path[pathLen] = '\0';
+		fsaShimBuffer->request.cmdMakeDir.uknParam = uknVal660;
+
+		return FSA_RESULT::OK;
 	}
 
-	sint32 FSMakeDirAsync(FSClient_t* fsClient, FSCmdBlock_t* fsCmdBlock, const uint8* dirPath, uint32 errorMask, FSAsyncParamsNew_t* fsAsyncParams)
+	sint32 FSMakeDirAsync(FSClient_t* fsClient, FSCmdBlock_t* fsCmdBlock, const char* dirPath, uint32 errorMask, FSAsyncParams* fsAsyncParams)
 	{
 		// used by titles: XCX (via SAVEMakeDirAsync)
 		_FSCmdIntro();
@@ -1282,31 +1631,33 @@ namespace coreinit
 			cemu_assert_debug(false); // path must not be NULL
 			return -0x400;
 		}
-		uint32 ukn1444 = _swapEndianU32(fsClientBody->iosuFSAHandle);
-		fsError = __FSPrepareCmd_MakeDir(fsCmdBlockBody, dirPath, 0x660);
-		if (fsError != (FSStatus)FS_RESULT::SUCCESS)
-		{
-			cemu_assert_debug(false);
-			return fsError;
-		}
-		__FSQueueCmd(&fsClientBody->fsCmdQueue, fsCmdBlockBody, FS_CB_PLACEHOLDER_FINISHCMD);
+		FSA_RESULT prepareResult = __FSPrepareCmd_MakeDir(&fsCmdBlockBody->fsaShimBuffer, fsClientBody->iosuFSAHandle, dirPath, 0x660);
+		if (prepareResult != FSA_RESULT::OK)
+			return (FSStatus)_FSAStatusToFSStatus(prepareResult);
+
+		__FSQueueCmd(&fsClientBody->fsCmdQueue, fsCmdBlockBody, RPLLoader_MakePPCCallable(export___FSQueueDefaultFinishFunc));
 		return (FSStatus)FS_RESULT::SUCCESS;
 	}
 
-	sint32 FSMakeDir(FSClient_t* fsClient, FSCmdBlock_t* fsCmdBlock, const uint8* path, uint32 errorMask)
+	sint32 FSMakeDir(FSClient_t* fsClient, FSCmdBlock_t* fsCmdBlock, const char* path, uint32 errorMask)
 	{
-		StackAllocator<FSAsyncParamsNew_t> asyncParams;
-		__FSAsyncToSyncInit(fsClient, fsCmdBlock, asyncParams);
-		sint32 fsAsyncRet = FSMakeDirAsync(fsClient, fsCmdBlock, path, errorMask, asyncParams);
+		StackAllocator<FSAsyncParams> asyncParams;
+		__FSAsyncToSyncInit(fsClient, fsCmdBlock, &asyncParams);
+		sint32 fsAsyncRet = FSMakeDirAsync(fsClient, fsCmdBlock, path, errorMask, &asyncParams);
 		return __FSProcessAsyncResult(fsClient, fsCmdBlock, fsAsyncRet, errorMask);
 	}
 
-	sint32 __FSPrepareCmd_ChangeDir(FSCmdBlockBody_t* fsCmdBlockBody, uint8* path)
+	FSA_RESULT __FSPrepareCmd_ChangeDir(iosu::fsa::FSAShimBuffer* fsaShimBuffer, IOSDevHandle devHandle, uint8* path)
 	{
-		if (fsCmdBlockBody == NULL)
-			return 0xFFFCFFDD;
+		if (fsaShimBuffer == NULL)
+			return FSA_RESULT::INVALID_BUFFER;
 		if (path == NULL)
-			return 0xFFFCFFDE;
+			return FSA_RESULT::INVALID_PATH;
+
+		fsaShimBuffer->fsaDevHandle = devHandle;
+		fsaShimBuffer->ipcReqType = 0;
+		fsaShimBuffer->operationType = (uint32)FSA_CMD_OPERATION_TYPE::CHANGEDIR;
+
 		size_t pathLen = strlen((char*)path);
 		if (pathLen >= FSA_CMD_PATH_MAX_LENGTH)
 		{
@@ -1314,13 +1665,14 @@ namespace coreinit
 			pathLen = FSA_CMD_PATH_MAX_LENGTH - 1;
 		}
 		for (sint32 i = 0; i < pathLen; i++)
-			fsCmdBlockBody->ipcData.cmdChangeDir.path[i] = path[i];
-		fsCmdBlockBody->ipcData.cmdChangeDir.path[pathLen] = '\0';
-		fsCmdBlockBody->operationType = FSA_CMD_OPERATION_TYPE_CHANGEDIR;
-		return 0;
+			fsaShimBuffer->request.cmdChangeDir.path[i] = path[i];
+
+		fsaShimBuffer->request.cmdChangeDir.path[pathLen] = '\0';
+
+		return FSA_RESULT::OK;
 	}
 
-	sint32 FSChangeDirAsync(FSClient_t* fsClient, FSCmdBlock_t* fsCmdBlock, char* path, uint32 errorMask, FSAsyncParamsNew_t* fsAsyncParams)
+	sint32 FSChangeDirAsync(FSClient_t* fsClient, FSCmdBlock_t* fsCmdBlock, char* path, uint32 errorMask, FSAsyncParams* fsAsyncParams)
 	{
 		_FSCmdIntro();
 		if (path == NULL)
@@ -1328,53 +1680,69 @@ namespace coreinit
 			cemu_assert_debug(false); // path must not be NULL
 			return -0x400;
 		}
-		fsError = __FSPrepareCmd_ChangeDir(fsCmdBlockBody, (uint8*)path);
-		if (fsError != (FSStatus)FS_RESULT::SUCCESS)
-			return fsError;
-		__FSQueueCmd(&fsClientBody->fsCmdQueue, fsCmdBlockBody, FS_CB_PLACEHOLDER_FINISHCMD);
+		FSA_RESULT prepareResult = __FSPrepareCmd_ChangeDir(&fsCmdBlockBody->fsaShimBuffer, fsClientBody->iosuFSAHandle, (uint8*)path);
+		if (prepareResult != FSA_RESULT::OK)
+			return (FSStatus)_FSAStatusToFSStatus(prepareResult);
+
+		__FSQueueCmd(&fsClientBody->fsCmdQueue, fsCmdBlockBody, RPLLoader_MakePPCCallable(export___FSQueueDefaultFinishFunc));
 		return (FSStatus)FS_RESULT::SUCCESS;
 	}
 
 	sint32 FSChangeDir(FSClient_t* fsClient, FSCmdBlock_t* fsCmdBlock, char* path, uint32 errorMask)
 	{
-		StackAllocator<FSAsyncParamsNew_t> asyncParams;
-		__FSAsyncToSyncInit(fsClient, fsCmdBlock, asyncParams);
-		sint32 fsAsyncRet = FSChangeDirAsync(fsClient, fsCmdBlock, path, errorMask, asyncParams);
+		StackAllocator<FSAsyncParams> asyncParams;
+		__FSAsyncToSyncInit(fsClient, fsCmdBlock, &asyncParams);
+		sint32 fsAsyncRet = FSChangeDirAsync(fsClient, fsCmdBlock, path, errorMask, &asyncParams);
 		return __FSProcessAsyncResult(fsClient, fsCmdBlock, fsAsyncRet, errorMask);
 	}
 
-	sint32 __FSPrepareCmd_GetCwd(FSCmdBlockBody_t* fsCmdBlockBody)
+	FSA_RESULT __FSPrepareCmd_GetCwd(iosu::fsa::FSAShimBuffer* fsaShimBuffer, IOSDevHandle devHandle)
 	{
-		if (fsCmdBlockBody == NULL)
-			return 0xFFFCFFDD;
-		fsCmdBlockBody->operationType = FSA_CMD_OPERATION_TYPE_GETCWD;
-		return 0;
+		if (fsaShimBuffer == NULL)
+			return FSA_RESULT::INVALID_BUFFER;
+
+		fsaShimBuffer->fsaDevHandle = devHandle;
+		fsaShimBuffer->ipcReqType = 0;
+		fsaShimBuffer->operationType = (uint32)FSA_CMD_OPERATION_TYPE::GETCWD;
+
+		return FSA_RESULT::OK;
 	}
 
-	sint32 FSGetCwdAsync(FSClient_t* fsClient, FSCmdBlock_t* fsCmdBlock, char* dirPathOut, sint32 dirPathMaxLen, uint32 errorMask, FSAsyncParamsNew_t* fsAsyncParams)
+	sint32 FSGetCwdAsync(FSClient_t* fsClient, FSCmdBlock_t* fsCmdBlock, char* dirPathOut, sint32 dirPathMaxLen, uint32 errorMask, FSAsyncParams* fsAsyncParams)
 	{
 		// used by titles: Super Mario Maker
 		_FSCmdIntro();
-		fsCmdBlockBody->returnValueMPTR = _swapEndianU32(memory_getVirtualOffsetFromPointer(dirPathOut));
-		fsCmdBlockBody->transferSize = _swapEndianU32(dirPathMaxLen);
-		fsError = __FSPrepareCmd_GetCwd(fsCmdBlockBody);
-		if (fsError != (FSStatus)FS_RESULT::SUCCESS)
-			return fsError;
-		__FSQueueCmd(&fsClientBody->fsCmdQueue, fsCmdBlockBody, FS_CB_PLACEHOLDER_FINISHCMD);
+		fsCmdBlockBody->returnValues.cmdGetCwd.pathPtr = dirPathOut;
+		fsCmdBlockBody->returnValues.cmdGetCwd.transferSize = dirPathMaxLen;
+
+		FSA_RESULT prepareResult = __FSPrepareCmd_GetCwd(&fsCmdBlockBody->fsaShimBuffer, fsClientBody->iosuFSAHandle);
+		if (prepareResult != FSA_RESULT::OK)
+			return (FSStatus)_FSAStatusToFSStatus(prepareResult);
+
+		__FSQueueCmd(&fsClientBody->fsCmdQueue, fsCmdBlockBody, RPLLoader_MakePPCCallable(export___FSQueueDefaultFinishFunc));
 		return (FSStatus)FS_RESULT::SUCCESS;
 	}
 
 	sint32 FSGetCwd(FSClient_t* fsClient, FSCmdBlock_t* fsCmdBlock, char* dirPathOut, sint32 dirPathMaxLen, uint32 errorMask)
 	{
-		StackAllocator<FSAsyncParamsNew_t> asyncParams;
-		__FSAsyncToSyncInit(fsClient, fsCmdBlock, asyncParams);
-		sint32 fsAsyncRet = FSGetCwdAsync(fsClient, fsCmdBlock, dirPathOut, dirPathMaxLen, errorMask, asyncParams);
+		StackAllocator<FSAsyncParams> asyncParams;
+		__FSAsyncToSyncInit(fsClient, fsCmdBlock, &asyncParams);
+		sint32 fsAsyncRet = FSGetCwdAsync(fsClient, fsCmdBlock, dirPathOut, dirPathMaxLen, errorMask, &asyncParams);
 		auto r = __FSProcessAsyncResult(fsClient, fsCmdBlock, fsAsyncRet, errorMask);
 		return r;
 	}
 
-	void __FSPrepareCmd_FlushQuota(FSCmdBlockBody_t* fsCmdBlockBody, char* path)
+	FSA_RESULT __FSPrepareCmd_FlushQuota(iosu::fsa::FSAShimBuffer* fsaShimBuffer, IOSDevHandle devHandle, char* path)
 	{
+		if (fsaShimBuffer == NULL)
+			return FSA_RESULT::INVALID_BUFFER;
+		if (path == NULL)
+			return FSA_RESULT::INVALID_PATH;
+
+		fsaShimBuffer->fsaDevHandle = devHandle;
+		fsaShimBuffer->ipcReqType = 0;
+		fsaShimBuffer->operationType = (uint32)FSA_CMD_OPERATION_TYPE::FLUSHQUOTA;
+
 		size_t pathLen = strlen((char*)path);
 		if (pathLen >= FSA_CMD_PATH_MAX_LENGTH)
 		{
@@ -1382,31 +1750,45 @@ namespace coreinit
 			pathLen = FSA_CMD_PATH_MAX_LENGTH - 1;
 		}
 		for (sint32 i = 0; i < pathLen; i++)
-			fsCmdBlockBody->ipcData.cmdFlushQuota.path[i] = path[i];
-		fsCmdBlockBody->ipcData.cmdFlushQuota.path[pathLen] = '\0';
-		fsCmdBlockBody->operationType = FSA_CMD_OPERATION_TYPE_FLUSHQUOTA;
+			fsaShimBuffer->request.cmdFlushQuota.path[i] = path[i];
+		fsaShimBuffer->request.cmdFlushQuota.path[pathLen] = '\0';
+
+		return FSA_RESULT::OK;
 	}
 
-	sint32 FSFlushQuotaAsync(FSClient_t* fsClient, FSCmdBlock_t* fsCmdBlock, char* path, uint32 errorMask, FSAsyncParamsNew_t* fsAsyncParams)
+	sint32 FSFlushQuotaAsync(FSClient_t* fsClient, FSCmdBlock_t* fsCmdBlock, char* path, uint32 errorMask, FSAsyncParams* fsAsyncParams)
 	{
 		_FSCmdIntro();
-		fsCmdBlockBody->returnValueMPTR = 0;
-		__FSPrepareCmd_FlushQuota(fsCmdBlockBody, path);
-		__FSQueueCmd(&fsClientBody->fsCmdQueue, fsCmdBlockBody, FS_CB_PLACEHOLDER_FINISHCMD);
+
+		FSA_RESULT prepareResult = __FSPrepareCmd_FlushQuota(&fsCmdBlockBody->fsaShimBuffer, fsClientBody->iosuFSAHandle, path);
+		if (prepareResult != FSA_RESULT::OK)
+			return (FSStatus)_FSAStatusToFSStatus(prepareResult);
+
+		__FSQueueCmd(&fsClientBody->fsCmdQueue, fsCmdBlockBody, RPLLoader_MakePPCCallable(export___FSQueueDefaultFinishFunc));
 		return (FSStatus)FS_RESULT::SUCCESS;
 	}
 
 	sint32 FSFlushQuota(FSClient_t* fsClient, FSCmdBlock_t* fsCmdBlock, char* path, uint32 errorMask)
 	{
-		StackAllocator<FSAsyncParamsNew_t> asyncParams;
-		__FSAsyncToSyncInit(fsClient, fsCmdBlock, asyncParams);
-		sint32 fsAsyncRet = FSFlushQuotaAsync(fsClient, fsCmdBlock, path, errorMask, asyncParams);
+		StackAllocator<FSAsyncParams> asyncParams;
+		__FSAsyncToSyncInit(fsClient, fsCmdBlock, &asyncParams);
+		sint32 fsAsyncRet = FSFlushQuotaAsync(fsClient, fsCmdBlock, path, errorMask, &asyncParams);
 		return __FSProcessAsyncResult(fsClient, fsCmdBlock, fsAsyncRet, errorMask);
 	}
 
-	uint32 __FSPrepareCmd_QueryInfo(FSCmdBlockBody_t* fsCmdBlockBody, uint8* queryString, uint32 queryType)
+	FSA_RESULT __FSPrepareCmd_QueryInfo(iosu::fsa::FSAShimBuffer* fsaShimBuffer, IOSDevHandle devHandle, uint8* queryString, uint32 queryType)
 	{
-		// note: The output result is stored to fsCmdBlockBody+0x944
+		if (fsaShimBuffer == NULL)
+			return FSA_RESULT::INVALID_BUFFER;
+		if (queryString == NULL)
+			return FSA_RESULT::INVALID_PATH;
+		if (queryType > 8)
+			return FSA_RESULT::INVALID_PARAM;
+
+		fsaShimBuffer->fsaDevHandle = devHandle;
+		fsaShimBuffer->ipcReqType = 0;
+		fsaShimBuffer->operationType = (uint32)FSA_CMD_OPERATION_TYPE::QUERYINFO;
+
 		size_t stringLen = strlen((char*)queryString);
 		if (stringLen >= FSA_CMD_PATH_MAX_LENGTH)
 		{
@@ -1415,27 +1797,30 @@ namespace coreinit
 		}
 		for (sint32 i = 0; i < stringLen; i++)
 		{
-			fsCmdBlockBody->ipcData.cmdQueryInfo.query[i] = queryString[i];
+			fsaShimBuffer->request.cmdQueryInfo.query[i] = queryString[i];
 		}
-		fsCmdBlockBody->ipcData.cmdQueryInfo.query[stringLen] = '\0';
-		fsCmdBlockBody->ipcData.cmdQueryInfo.queryType = _swapEndianU32(queryType);
-		fsCmdBlockBody->operationType = FSA_CMD_OPERATION_TYPE_QUERYINFO;
-		return 0;
+
+		fsaShimBuffer->request.cmdQueryInfo.query[stringLen] = '\0';
+		fsaShimBuffer->request.cmdQueryInfo.queryType = queryType;
+
+		return FSA_RESULT::OK;
 	}
 
-	sint32 __FSQueryInfoAsync(FSClient_t* fsClient, FSCmdBlock_t* fsCmdBlock, uint8* queryString, uint32 queryType, void* queryResult, uint32 errorMask, FSAsyncParamsNew_t* fsAsyncParams)
+	sint32 __FSQueryInfoAsync(FSClient_t* fsClient, FSCmdBlock_t* fsCmdBlock, uint8* queryString, uint32 queryType, void* queryResult, uint32 errorMask, FSAsyncParams* fsAsyncParams)
 	{
 		_FSCmdIntro();
 		cemu_assert(queryString && queryResult); // query string and result must not be null
-		fsCmdBlockBody->returnValueMPTR = _swapEndianU32(memory_getVirtualOffsetFromPointer(queryResult));
-		fsError = __FSPrepareCmd_QueryInfo(fsCmdBlockBody, queryString, queryType);
-		if (fsError != (FSStatus)FS_RESULT::SUCCESS)
-			return fsError;
-		__FSQueueCmd(&fsClientBody->fsCmdQueue, fsCmdBlockBody, FS_CB_PLACEHOLDER_FINISHCMD);
+		fsCmdBlockBody->returnValues.cmdQueryInfo.queryResultPtr = queryResult;
+
+		FSA_RESULT prepareResult = __FSPrepareCmd_QueryInfo(&fsCmdBlockBody->fsaShimBuffer, fsClientBody->iosuFSAHandle, queryString, queryType);
+		if (prepareResult != FSA_RESULT::OK)
+			return (FSStatus)_FSAStatusToFSStatus(prepareResult);
+
+		__FSQueueCmd(&fsClientBody->fsCmdQueue, fsCmdBlockBody, RPLLoader_MakePPCCallable(export___FSQueueDefaultFinishFunc));
 		return (FSStatus)FS_RESULT::SUCCESS;
 	}
 
-	sint32 FSGetStatAsync(FSClient_t* fsClient, FSCmdBlock_t* fsCmdBlock, const char* path, FSStat_t* statOut, uint32 errorMask, FSAsyncParamsNew_t* fsAsyncParams)
+	sint32 FSGetStatAsync(FSClient_t* fsClient, FSCmdBlock_t* fsCmdBlock, const char* path, FSStat_t* statOut, uint32 errorMask, FSAsyncParams* fsAsyncParams)
 	{
 		sint32 fsStatus = __FSQueryInfoAsync(fsClient, fsCmdBlock, (uint8*)path, FSA_QUERY_TYPE_STAT, statOut, errorMask, fsAsyncParams);
 		return fsStatus;
@@ -1443,38 +1828,50 @@ namespace coreinit
 
 	sint32 FSGetStat(FSClient_t* fsClient, FSCmdBlock_t* fsCmdBlock, const char* path, FSStat_t* statOut, uint32 errorMask)
 	{
-		StackAllocator<FSAsyncParamsNew_t, 1> asyncParams;
-		__FSAsyncToSyncInit(fsClient, fsCmdBlock, asyncParams);
-		sint32 fsAsyncRet = FSGetStatAsync(fsClient, fsCmdBlock, path, statOut, errorMask, asyncParams);
+		StackAllocator<FSAsyncParams, 1> asyncParams;
+		__FSAsyncToSyncInit(fsClient, fsCmdBlock, &asyncParams);
+		sint32 fsAsyncRet = FSGetStatAsync(fsClient, fsCmdBlock, path, statOut, errorMask, &asyncParams);
 		sint32 ret = __FSProcessAsyncResult(fsClient, fsCmdBlock, fsAsyncRet, errorMask);
 		return ret;
 	}
 
-	void __FSPrepareCmd_GetStatFile(FSCmdBlockBody_t* fsCmdBlockBody, FSFileHandle2 fileHandle, FSStat_t* statOut)
+	FSA_RESULT __FSPrepareCmd_GetStatFile(iosu::fsa::FSAShimBuffer* fsaShimBuffer, IOSDevHandle devHandle, FSFileHandle2 fileHandle)
 	{
-		fsCmdBlockBody->ipcData.cmdGetStatFile.fileHandle = fileHandle;
-		fsCmdBlockBody->operationType = FSA_CMD_OPERATION_TYPE_GETSTATFILE;
-		fsCmdBlockBody->returnValueMPTR = _swapEndianU32(memory_getVirtualOffsetFromPointer(statOut));
+		if (fsaShimBuffer == NULL)
+			return FSA_RESULT::INVALID_BUFFER;
+
+		fsaShimBuffer->fsaDevHandle = devHandle;
+		fsaShimBuffer->ipcReqType = 0;
+		fsaShimBuffer->operationType = (uint32)FSA_CMD_OPERATION_TYPE::GETSTATFILE;
+
+		fsaShimBuffer->request.cmdGetStatFile.fileHandle = fileHandle;
+
+		return FSA_RESULT::OK;
 	}
 
-	sint32 FSGetStatFileAsync(FSClient_t* fsClient, FSCmdBlock_t* fsCmdBlock, FSFileHandle2 fileHandle, FSStat_t* statOut, uint32 errorMask, FSAsyncParamsNew_t* fsAsyncParams)
+	sint32 FSGetStatFileAsync(FSClient_t* fsClient, FSCmdBlock_t* fsCmdBlock, FSFileHandle2 fileHandle, FSStat_t* statOut, uint32 errorMask, FSAsyncParams* fsAsyncParams)
 	{
 		_FSCmdIntro();
 		cemu_assert(statOut); // statOut must not be null
-		__FSPrepareCmd_GetStatFile(fsCmdBlockBody, fileHandle, statOut);
-		__FSQueueCmd(&fsClientBody->fsCmdQueue, fsCmdBlockBody, FS_CB_PLACEHOLDER_FINISHCMD);
+		fsCmdBlockBody->returnValues.cmdStatFile.resultPtr = statOut;
+
+		FSA_RESULT prepareResult = __FSPrepareCmd_GetStatFile(&fsCmdBlockBody->fsaShimBuffer, fsClientBody->iosuFSAHandle, fileHandle);
+		if (prepareResult != FSA_RESULT::OK)
+			return (FSStatus)_FSAStatusToFSStatus(prepareResult);
+
+		__FSQueueCmd(&fsClientBody->fsCmdQueue, fsCmdBlockBody, RPLLoader_MakePPCCallable(export___FSQueueDefaultFinishFunc));
 		return (FSStatus)FS_RESULT::SUCCESS;
 	}
 
 	sint32 FSGetStatFile(FSClient_t* fsClient, FSCmdBlock_t* fsCmdBlock, FSFileHandle2 fileHandle, FSStat_t* statOut, uint32 errorMask)
 	{
-		StackAllocator<FSAsyncParamsNew_t, 1> asyncParams;
-		__FSAsyncToSyncInit(fsClient, fsCmdBlock, asyncParams);
-		sint32 fsAsyncRet = FSGetStatFileAsync(fsClient, fsCmdBlock, fileHandle, statOut, errorMask, asyncParams);
+		StackAllocator<FSAsyncParams, 1> asyncParams;
+		__FSAsyncToSyncInit(fsClient, fsCmdBlock, &asyncParams);
+		sint32 fsAsyncRet = FSGetStatFileAsync(fsClient, fsCmdBlock, fileHandle, statOut, errorMask, &asyncParams);
 		return __FSProcessAsyncResult(fsClient, fsCmdBlock, fsAsyncRet, errorMask);
 	}
 
-	sint32 FSGetFreeSpaceSizeAsync(FSClient_t* fsClient, FSCmdBlock_t* fsCmdBlock, const char* path, FSLargeSize* returnedFreeSize, uint32 errorMask, FSAsyncParamsNew_t* fsAsyncParams)
+	sint32 FSGetFreeSpaceSizeAsync(FSClient_t* fsClient, FSCmdBlock_t* fsCmdBlock, const char* path, FSLargeSize* returnedFreeSize, uint32 errorMask, FSAsyncParams* fsAsyncParams)
 	{
 		// used by: Wii U system settings app, Art Academy, Unity (e.g. Snoopy's Grand Adventure), Super Smash Bros
 		sint32 fsStatus = __FSQueryInfoAsync(fsClient, fsCmdBlock, (uint8*)path, FSA_QUERY_TYPE_FREESPACE, returnedFreeSize, errorMask, fsAsyncParams);
@@ -1483,46 +1880,57 @@ namespace coreinit
 
 	sint32 FSGetFreeSpaceSize(FSClient_t* fsClient, FSCmdBlock_t* fsCmdBlock, const char* path, FSLargeSize* returnedFreeSize, uint32 errorMask)
 	{
-		StackAllocator<FSAsyncParamsNew_t, 1> asyncParams;
-		__FSAsyncToSyncInit(fsClient, fsCmdBlock, asyncParams);
-		sint32 fsAsyncRet = FSGetFreeSpaceSizeAsync(fsClient, fsCmdBlock, path, returnedFreeSize, errorMask, asyncParams);
+		StackAllocator<FSAsyncParams, 1> asyncParams;
+		__FSAsyncToSyncInit(fsClient, fsCmdBlock, &asyncParams);
+		sint32 fsAsyncRet = FSGetFreeSpaceSizeAsync(fsClient, fsCmdBlock, path, returnedFreeSize, errorMask, &asyncParams);
 		return __FSProcessAsyncResult(fsClient, fsCmdBlock, fsAsyncRet, errorMask);
 	}
 
-	uint32 __FSPrepareCmd_IsEof(FSCmdBlockBody_t* fsCmdBlockBody, uint32 fileHandle)
+	FSA_RESULT __FSPrepareCmd_IsEof(iosu::fsa::FSAShimBuffer* fsaShimBuffer, IOSDevHandle devHandle, uint32 fileHandle)
 	{
-		fsCmdBlockBody->ipcData.cmdDefault.destBufferMPTR = _swapEndianU32(fileHandle);
-		fsCmdBlockBody->operationType = FSA_CMD_OPERATION_TYPE_ISEOF;
-		return 0;
+		if (fsaShimBuffer == NULL)
+			return FSA_RESULT::INVALID_BUFFER;
+
+		fsaShimBuffer->fsaDevHandle = devHandle;
+		fsaShimBuffer->ipcReqType = 0;
+		fsaShimBuffer->operationType = (uint32)FSA_CMD_OPERATION_TYPE::ISEOF;
+
+		fsaShimBuffer->request.cmdIsEof.fileHandle = fileHandle;
+
+		return FSA_RESULT::OK;
 	}
 
-	sint32 FSIsEofAsync(FSClient_t* fsClient, FSCmdBlock_t* fsCmdBlock, uint32 fileHandle, uint32 errorMask, FSAsyncParamsNew_t* fsAsyncParams)
+	sint32 FSIsEofAsync(FSClient_t* fsClient, FSCmdBlock_t* fsCmdBlock, uint32 fileHandle, uint32 errorMask, FSAsyncParams* fsAsyncParams)
 	{
 		// used by Paper Monsters Recut
 		_FSCmdIntro();
-		__FSPrepareCmd_IsEof(fsCmdBlockBody, fileHandle);
-		__FSQueueCmd(&fsClientBody->fsCmdQueue, fsCmdBlockBody, FS_CB_PLACEHOLDER_FINISHCMD);
+
+		FSA_RESULT prepareResult = __FSPrepareCmd_IsEof(&fsCmdBlockBody->fsaShimBuffer, fsClientBody->iosuFSAHandle, fileHandle);
+		if (prepareResult != FSA_RESULT::OK)
+			return (FSStatus)_FSAStatusToFSStatus(prepareResult);
+
+		__FSQueueCmd(&fsClientBody->fsCmdQueue, fsCmdBlockBody, RPLLoader_MakePPCCallable(export___FSQueueDefaultFinishFunc));
 		return (FSStatus)FS_RESULT::SUCCESS;
 	}
 
 	sint32 FSIsEof(FSClient_t* fsClient, FSCmdBlock_t* fsCmdBlock, uint32 fileHandle, uint32 errorMask)
 	{
-		StackAllocator<FSAsyncParamsNew_t, 1> asyncParams;
-		__FSAsyncToSyncInit(fsClient, fsCmdBlock, asyncParams);
-		sint32 fsAsyncRet = FSIsEofAsync(fsClient, fsCmdBlock, fileHandle, errorMask, asyncParams);
+		StackAllocator<FSAsyncParams, 1> asyncParams;
+		__FSAsyncToSyncInit(fsClient, fsCmdBlock, &asyncParams);
+		sint32 fsAsyncRet = FSIsEofAsync(fsClient, fsCmdBlock, fileHandle, errorMask, &asyncParams);
 		return __FSProcessAsyncResult(fsClient, fsCmdBlock, fsAsyncRet, errorMask);
 	}
 
 	void FSSetUserData(FSCmdBlock_t* fsCmdBlock, void* userData)
 	{
-		FSCmdBlockBody_t* fsCmdBlockBody = __FSGetCmdBlockBody(fsCmdBlock);
+		FSCmdBlockBody* fsCmdBlockBody = __FSGetCmdBlockBody(fsCmdBlock);
 		if (fsCmdBlockBody)
 			fsCmdBlockBody->userData = userData;
 	}
 
 	void* FSGetUserData(FSCmdBlock_t* fsCmdBlock)
 	{
-		FSCmdBlockBody_t* fsCmdBlockBody = __FSGetCmdBlockBody(fsCmdBlock);
+		FSCmdBlockBody* fsCmdBlockBody = __FSGetCmdBlockBody(fsCmdBlock);
 		void* userData = nullptr;
 		if (fsCmdBlockBody)
 			userData = fsCmdBlockBody->userData.GetPtr();
@@ -1546,7 +1954,7 @@ namespace coreinit
 		FSClientBody_t* fsClientBody = __FSGetClientBody(fsClient);
 		if (!fsClientBody)
 			return nullptr;
-		FSCmdBlockBody_t* cmdBlockBody = fsClientBody->currentCmdBlockBody;
+		FSCmdBlockBody* cmdBlockBody = fsClientBody->currentCmdBlockBody;
 		if (!cmdBlockBody)
 			return nullptr;
 		return cmdBlockBody->selfCmdBlock;
@@ -1562,101 +1970,808 @@ namespace coreinit
 		return 0; // no error
 	}
 
+	std::vector<FSAClientHandle> s_fsa_activeClients;
+	std::mutex s_fsa_activeClientsMutex;
+
+	FSAClientHandle FSAAddClientEx(void* data)
+	{
+		if (data != NULL)
+		{
+			// TODO
+			cemu_assert_unimplemented();
+		}
+
+		IOSDevHandle handle = IOS_Open("/dev/fsa", 0);
+		if (handle < IOS_ERROR::IOS_ERROR_OK)
+		{
+			return (FSAClientHandle)FSA_RESULT::PERMISSION_ERROR;
+		}
+
+		s_fsa_activeClientsMutex.lock();
+		s_fsa_activeClients.push_back((FSAClientHandle)handle);
+		s_fsa_activeClientsMutex.unlock();
+
+		return (FSAClientHandle)handle;
+	}
+
+	FSAClientHandle FSAAddClient(void* data)
+	{
+		return FSAAddClientEx(data);
+	}
+
+	FSA_RESULT FSADelClient(FSAClientHandle clientHandle)
+	{
+		if (clientHandle == 0)
+		{
+			return FSA_RESULT::INVALID_CLIENT_HANDLE;
+		}
+		s_fsa_activeClientsMutex.lock();
+
+		auto it = std::find(s_fsa_activeClients.begin(), s_fsa_activeClients.end(), clientHandle);
+		if (it != s_fsa_activeClients.end())
+		{
+			IOS_Close(clientHandle);
+			s_fsa_activeClients.erase(it);
+		}
+
+		s_fsa_activeClientsMutex.unlock();
+
+		return FSA_RESULT::OK;
+	}
+
+	SysAllocator<coreinit::IPCBufPool_t*> s_fsaIpcPool;
+	SysAllocator<uint8, 0x37500> s_fsaIpcPoolBuffer;
+	SysAllocator<uint32be> s_fsaIpcPoolBufferNumItems;
+
+	std::mutex sFSAIPCBufferLock;
+	bool s_fsaInitDone = false;
+
+	void FSAInit()
+	{
+		if (!s_fsaInitDone)
+		{
+			s_fsaIpcPool = IPCBufPoolCreate(s_fsaIpcPoolBuffer.GetPtr(), s_fsaIpcPoolBuffer.GetByteSize(), sizeof(iosu::fsa::FSAShimBuffer), &s_fsaIpcPoolBufferNumItems, 0);
+			s_fsaInitDone = true;
+		}
+	}
+
+	bool FSAShimCheckClientHandle(FSAClientHandle clientHandle)
+	{
+		std::scoped_lock lock(s_fsa_activeClientsMutex);
+		if (std::find(s_fsa_activeClients.begin(), s_fsa_activeClients.end(), clientHandle) != s_fsa_activeClients.end())
+		{
+			return true;
+		}
+		return false;
+	}
+
+	FSA_RESULT FSAShimAllocateBuffer(MEMPTR<MEMPTR<iosu::fsa::FSAShimBuffer>> outBuffer)
+	{
+		if (!s_fsaInitDone)
+			return FSA_RESULT::NOT_INIT;
+
+		sFSAIPCBufferLock.lock();
+		auto ptr = IPCBufPoolAllocate(s_fsaIpcPool, sizeof(iosu::fsa::FSAShimBuffer));
+		sFSAIPCBufferLock.unlock();
+
+		if (!ptr)
+			return FSA_RESULT::OUT_OF_RESOURCES;
+
+		std::memset(ptr, 0, sizeof(iosu::fsa::FSAShimBuffer));
+		outBuffer[0] = reinterpret_cast<iosu::fsa::FSAShimBuffer*>(ptr);
+		return FSA_RESULT::OK;
+	}
+
+	FSA_RESULT FSAShimFreeBuffer(iosu::fsa::FSAShimBuffer* buffer)
+	{
+		sFSAIPCBufferLock.lock();
+		IPCBufPoolFree(s_fsaIpcPool, (uint8_t*)buffer);
+		sFSAIPCBufferLock.unlock();
+		return FSA_RESULT::OK;
+	}
+
+	FSA_RESULT FSACloseFile(FSAClientHandle client, uint32 fileHandle)
+	{
+		if (!FSAShimCheckClientHandle(client))
+			return FSA_RESULT::INVALID_CLIENT_HANDLE;
+
+		StackAllocator<MEMPTR<iosu::fsa::FSAShimBuffer>, 1> shimBuffer;
+		FSA_RESULT result = FSAShimAllocateBuffer(shimBuffer.GetPointer());
+		if (result != FSA_RESULT::OK)
+			return result;
+
+		result = __FSPrepareCmd_CloseFile(shimBuffer->GetPtr(), client, fileHandle);
+		if (result == FSA_RESULT::OK)
+			result = __FSAIPCSubmitCommand(shimBuffer->GetPtr());
+
+		FSAShimFreeBuffer(shimBuffer->GetPtr());
+		return result;
+	}
+
+	FSA_RESULT FSAFlushFile(FSAClientHandle client, uint32_t fileHandle)
+	{
+		if (!FSAShimCheckClientHandle(client))
+			return FSA_RESULT::INVALID_CLIENT_HANDLE;
+
+		StackAllocator<MEMPTR<iosu::fsa::FSAShimBuffer>, 1> shimBuffer;
+		FSA_RESULT result = FSAShimAllocateBuffer(shimBuffer.GetPointer());
+		if (result != FSA_RESULT::OK)
+			return result;
+
+		result = __FSPrepareCmd_FlushFile(shimBuffer->GetPtr(), client, fileHandle);
+		if (result == FSA_RESULT::OK)
+			result = __FSAIPCSubmitCommand(shimBuffer->GetPtr());
+
+		FSAShimFreeBuffer(shimBuffer->GetPtr());
+		return result;
+	}
+
+	FSA_RESULT FSAMakeDir(FSAClientHandle client, const char* path, uint32 uknVal660)
+	{
+		if (!FSAShimCheckClientHandle(client))
+			return FSA_RESULT::INVALID_CLIENT_HANDLE;
+
+		StackAllocator<MEMPTR<iosu::fsa::FSAShimBuffer>, 1> shimBuffer;
+		FSA_RESULT result = FSAShimAllocateBuffer(shimBuffer.GetPointer());
+		if (result != FSA_RESULT::OK)
+			return result;
+
+		result = __FSPrepareCmd_MakeDir(shimBuffer->GetPtr(), client, path, uknVal660);
+		if (result == FSA_RESULT::OK)
+			result = __FSAIPCSubmitCommand(shimBuffer->GetPtr());
+
+		FSAShimFreeBuffer(shimBuffer->GetPtr());
+		return result;
+	}
+
+	FSA_RESULT FSARename(FSAClientHandle client, char* oldPath, char* newPath)
+	{
+		if (!FSAShimCheckClientHandle(client))
+			return FSA_RESULT::INVALID_CLIENT_HANDLE;
+
+		StackAllocator<MEMPTR<iosu::fsa::FSAShimBuffer>, 1> shimBuffer;
+		FSA_RESULT result = FSAShimAllocateBuffer(shimBuffer.GetPointer());
+		if (result != FSA_RESULT::OK)
+			return result;
+
+		result = __FSPrepareCmd_Rename(shimBuffer->GetPtr(), client, oldPath, newPath);
+		if (result == FSA_RESULT::OK)
+			result = __FSAIPCSubmitCommand(shimBuffer->GetPtr());
+
+		FSAShimFreeBuffer(shimBuffer->GetPtr());
+		return result;
+	}
+
+	FSA_RESULT FSAChangeDir(FSAClientHandle client, char* path)
+	{
+		if (!FSAShimCheckClientHandle(client))
+			return FSA_RESULT::INVALID_CLIENT_HANDLE;
+
+		StackAllocator<MEMPTR<iosu::fsa::FSAShimBuffer>, 1> shimBuffer;
+		FSA_RESULT result = FSAShimAllocateBuffer(shimBuffer.GetPointer());
+		if (result != FSA_RESULT::OK)
+			return result;
+
+		result = __FSPrepareCmd_ChangeDir(shimBuffer->GetPtr(), client, (uint8_t*)path);
+		if (result == FSA_RESULT::OK)
+			result = __FSAIPCSubmitCommand(shimBuffer->GetPtr());
+
+		FSAShimFreeBuffer(shimBuffer->GetPtr());
+		return result;
+	}
+
+	FSA_RESULT FSAReadDir(FSAClientHandle client, FSDirHandle2 dirHandle, MEMPTR<FSDirEntry_t> directoryEntry)
+	{
+		if (directoryEntry.IsNull())
+			return FSA_RESULT::INVALID_BUFFER;
+
+		if (!FSAShimCheckClientHandle(client))
+			return FSA_RESULT::INVALID_CLIENT_HANDLE;
+
+		StackAllocator<MEMPTR<iosu::fsa::FSAShimBuffer>, 1> shimBuffer;
+		FSA_RESULT result = FSAShimAllocateBuffer(shimBuffer.GetPointer());
+		if (result != FSA_RESULT::OK)
+			return result;
+
+		result = __FSPrepareCmd_ReadDir(shimBuffer->GetPtr(), client, dirHandle);
+		if (result == FSA_RESULT::OK)
+		{
+			result = __FSAIPCSubmitCommand(shimBuffer->GetPtr());
+			if (result == FSA_RESULT::OK)
+			{
+				*directoryEntry = shimBuffer->GetPtr()->response.cmdReadDir.dirEntry;
+			}
+		}
+
+		FSAShimFreeBuffer(shimBuffer->GetPtr());
+		return result;
+	}
+
+	FSA_RESULT FSAOpenDir(FSAClientHandle client, char* path, MEMPTR<uint32be> dirHandle)
+	{
+		if (dirHandle.IsNull())
+			return FSA_RESULT::INVALID_BUFFER;
+
+		if (!FSAShimCheckClientHandle(client))
+			return FSA_RESULT::INVALID_CLIENT_HANDLE;
+
+		StackAllocator<MEMPTR<iosu::fsa::FSAShimBuffer>, 1> shimBuffer;
+		FSA_RESULT result = FSAShimAllocateBuffer(shimBuffer.GetPointer());
+		if (result != FSA_RESULT::OK)
+			return result;
+
+		result = __FSPrepareCmd_OpenDir(shimBuffer->GetPtr(), client, path);
+		if (result == FSA_RESULT::OK)
+		{
+			result = __FSAIPCSubmitCommand(shimBuffer->GetPtr());
+			if (result == FSA_RESULT::OK)
+			{
+				*dirHandle = shimBuffer->GetPtr()->response.cmdOpenDir.dirHandleOutput;
+			}
+		}
+
+		FSAShimFreeBuffer(shimBuffer->GetPtr());
+		return result;
+	}
+
+	FSA_RESULT FSACloseDir(FSAClientHandle client, FSDirHandle2 dirHandle)
+	{
+		if (!FSAShimCheckClientHandle(client))
+			return FSA_RESULT::INVALID_CLIENT_HANDLE;
+
+		StackAllocator<MEMPTR<iosu::fsa::FSAShimBuffer>, 1> shimBuffer;
+		FSA_RESULT result = FSAShimAllocateBuffer(shimBuffer.GetPointer());
+		if (result != FSA_RESULT::OK)
+			return result;
+
+		result = __FSPrepareCmd_CloseDir(shimBuffer->GetPtr(), client, dirHandle);
+		if (result == FSA_RESULT::OK)
+		{
+			result = __FSAIPCSubmitCommand(shimBuffer->GetPtr());
+		}
+
+		FSAShimFreeBuffer(shimBuffer->GetPtr());
+		return result;
+	}
+
+	FSA_RESULT FSARewindDir(FSAClientHandle client, FSDirHandle2 dirHandle)
+	{
+		if (!FSAShimCheckClientHandle(client))
+			return FSA_RESULT::INVALID_CLIENT_HANDLE;
+
+		StackAllocator<MEMPTR<iosu::fsa::FSAShimBuffer>, 1> shimBuffer;
+		FSA_RESULT result = FSAShimAllocateBuffer(shimBuffer.GetPointer());
+		if (result != FSA_RESULT::OK)
+			return result;
+
+		result = __FSPrepareCmd_RewindDir(shimBuffer->GetPtr(), client, dirHandle);
+		if (result == FSA_RESULT::OK)
+		{
+			result = __FSAIPCSubmitCommand(shimBuffer->GetPtr());
+		}
+
+		FSAShimFreeBuffer(shimBuffer->GetPtr());
+		return result;
+	}
+
+	FSA_RESULT FSAOpenFileEx(FSAClientHandle client, char* path, char* mode, uint32 createMode, uint32 openFlag, uint32_t preallocSize, MEMPTR<uint32be> outFileHandle)
+	{
+		if (outFileHandle.IsNull())
+			return FSA_RESULT::INVALID_BUFFER;
+
+		if (!FSAShimCheckClientHandle(client))
+			return FSA_RESULT::INVALID_CLIENT_HANDLE;
+
+		StackAllocator<MEMPTR<iosu::fsa::FSAShimBuffer>, 1> shimBuffer;
+		FSA_RESULT result = FSAShimAllocateBuffer(shimBuffer.GetPointer());
+		if (result != FSA_RESULT::OK)
+			return result;
+
+		result = __FSPrepareCmd_OpenFile(shimBuffer->GetPtr(), client, path, mode, createMode, openFlag, preallocSize);
+		if (result == FSA_RESULT::OK)
+		{
+			result = __FSAIPCSubmitCommand(shimBuffer->GetPtr());
+			if (result == FSA_RESULT::OK)
+			{
+				*outFileHandle = shimBuffer->GetPtr()->response.cmdOpenFile.fileHandleOutput;
+			}
+		}
+
+		FSAShimFreeBuffer(shimBuffer->GetPtr());
+		return result;
+	}
+
+	FSA_RESULT FSAGetStatFile(FSAClientHandle client, FSFileHandle2 fileHandle, MEMPTR<FSStat_t> outStat)
+	{
+		if (outStat.IsNull())
+			return FSA_RESULT::INVALID_BUFFER;
+
+		if (!FSAShimCheckClientHandle(client))
+			return FSA_RESULT::INVALID_CLIENT_HANDLE;
+
+		StackAllocator<MEMPTR<iosu::fsa::FSAShimBuffer>, 1> shimBuffer;
+		FSA_RESULT result = FSAShimAllocateBuffer(shimBuffer.GetPointer());
+		if (result != FSA_RESULT::OK)
+			return result;
+
+		result = __FSPrepareCmd_GetStatFile(shimBuffer->GetPtr(), client, fileHandle);
+		if (result == FSA_RESULT::OK)
+		{
+			result = __FSAIPCSubmitCommand(shimBuffer->GetPtr());
+			if (result == FSA_RESULT::OK)
+			{
+				*outStat = shimBuffer->GetPtr()->response.cmdStatFile.statOut;
+			}
+		}
+
+		FSAShimFreeBuffer(shimBuffer->GetPtr());
+		return result;
+	}
+
+	FSA_RESULT FSASetPosFile(FSAClientHandle client, FSFileHandle2 fileHandle, uint32_t pos)
+	{
+		if (!FSAShimCheckClientHandle(client))
+			return FSA_RESULT::INVALID_CLIENT_HANDLE;
+
+		StackAllocator<MEMPTR<iosu::fsa::FSAShimBuffer>, 1> shimBuffer;
+		FSA_RESULT result = FSAShimAllocateBuffer(shimBuffer.GetPointer());
+		if (result != FSA_RESULT::OK)
+			return result;
+
+		result = __FSPrepareCmd_SetPosFile(shimBuffer->GetPtr(), client, fileHandle, pos);
+		if (result == FSA_RESULT::OK)
+		{
+			result = __FSAIPCSubmitCommand(shimBuffer->GetPtr());
+		}
+
+		FSAShimFreeBuffer(shimBuffer->GetPtr());
+		return result;
+	}
+
+	FSA_RESULT FSATruncateFile(FSAClientHandle client, FSFileHandle2 fileHandle)
+	{
+		if (!FSAShimCheckClientHandle(client))
+			return FSA_RESULT::INVALID_CLIENT_HANDLE;
+
+		StackAllocator<MEMPTR<iosu::fsa::FSAShimBuffer>, 1> shimBuffer;
+		FSA_RESULT result = FSAShimAllocateBuffer(shimBuffer.GetPointer());
+		if (result != FSA_RESULT::OK)
+			return result;
+
+		result = __FSPrepareCmd_TruncateFile(shimBuffer->GetPtr(), client, fileHandle);
+		if (result == FSA_RESULT::OK)
+		{
+			result = __FSAIPCSubmitCommand(shimBuffer->GetPtr());
+		}
+
+		FSAShimFreeBuffer(shimBuffer->GetPtr());
+		return result;
+	}
+
+	FSA_RESULT FSARemove(FSAClientHandle client, char* path)
+	{
+		if (!FSAShimCheckClientHandle(client))
+			return FSA_RESULT::INVALID_CLIENT_HANDLE;
+
+		StackAllocator<MEMPTR<iosu::fsa::FSAShimBuffer>, 1> shimBuffer;
+		FSA_RESULT result = FSAShimAllocateBuffer(shimBuffer.GetPointer());
+		if (result != FSA_RESULT::OK)
+			return result;
+
+		result = __FSPrepareCmd_Remove(shimBuffer->GetPtr(), client, (uint8_t*)path);
+		if (result == FSA_RESULT::OK)
+		{
+			result = __FSAIPCSubmitCommand(shimBuffer->GetPtr());
+		}
+
+		FSAShimFreeBuffer(shimBuffer->GetPtr());
+		return result;
+	}
+
+	FSA_RESULT __FSPrepareCmd_ChangeMode(iosu::fsa::FSAShimBuffer* fsaShimBuffer, IOSDevHandle fsaHandle, uint8_t* path, uint32 permission, uint32 permissionMask)
+	{
+		if (fsaShimBuffer == nullptr)
+			return FSA_RESULT::INVALID_BUFFER;
+		if (path == nullptr)
+			return FSA_RESULT::INVALID_PATH;
+
+		fsaShimBuffer->fsaDevHandle = fsaHandle;
+		fsaShimBuffer->ipcReqType = 0;
+		fsaShimBuffer->operationType = (uint32)FSA_CMD_OPERATION_TYPE::REWINDDIR;
+
+		size_t pathLen = strlen((char*)path);
+
+		for (sint32 i = 0; i < pathLen; i++)
+			fsaShimBuffer->request.cmdChangeMode.path[i] = path[i];
+		for (size_t i = pathLen; i < FSA_CMD_PATH_MAX_LENGTH; i++)
+			fsaShimBuffer->request.cmdChangeMode.path[i] = '\0';
+
+		fsaShimBuffer->request.cmdChangeMode.mode1 = permission;
+		fsaShimBuffer->request.cmdChangeMode.mode2 = permissionMask;
+
+		return FSA_RESULT::OK;
+	}
+
+	FSA_RESULT FSAChangeMode(FSAClientHandle client, const char* path, uint32 permission)
+	{
+		if (!FSAShimCheckClientHandle(client))
+			return FSA_RESULT::INVALID_CLIENT_HANDLE;
+
+		StackAllocator<MEMPTR<iosu::fsa::FSAShimBuffer>, 1> shimBuffer;
+		FSA_RESULT result = FSAShimAllocateBuffer(shimBuffer.GetPointer());
+		if (result != FSA_RESULT::OK)
+			return result;
+
+		result = __FSPrepareCmd_ChangeMode(shimBuffer->GetPtr(), client, (uint8_t*)path, permission, 0x666);
+		if (result == FSA_RESULT::OK)
+		{
+			result = __FSAIPCSubmitCommand(shimBuffer->GetPtr());
+		}
+
+		FSAShimFreeBuffer(shimBuffer->GetPtr());
+		return result;
+	}
+
+	FSA_RESULT FSAReadFile(FSAClientHandle client, void* buffer, uint32_t size, uint32_t count, FSFileHandle2 handle, uint32_t flags)
+	{
+		if (!FSAShimCheckClientHandle(client))
+			return FSA_RESULT::INVALID_CLIENT_HANDLE;
+
+		StackAllocator<MEMPTR<iosu::fsa::FSAShimBuffer>, 1> shimBuffer;
+		FSA_RESULT result = FSAShimAllocateBuffer(shimBuffer.GetPointer());
+		if (result != FSA_RESULT::OK)
+			return result;
+
+		result = __FSPrepareCmd_ReadFile(shimBuffer->GetPtr(), client, buffer, size, count, 0, handle, flags & ~0x2);
+		if (result == FSA_RESULT::OK)
+		{
+			result = __FSAIPCSubmitCommand(shimBuffer->GetPtr());
+		}
+
+		FSAShimFreeBuffer(shimBuffer->GetPtr());
+		return result;
+	}
+
+	FSA_RESULT FSAWriteFile(FSAClientHandle client, void* buffer, uint32_t size, uint32_t count, FSFileHandle2 handle, uint32_t flags)
+	{
+		if (!FSAShimCheckClientHandle(client))
+			return FSA_RESULT::INVALID_CLIENT_HANDLE;
+
+		StackAllocator<MEMPTR<iosu::fsa::FSAShimBuffer>, 1> shimBuffer;
+		FSA_RESULT result = FSAShimAllocateBuffer(shimBuffer.GetPointer());
+		if (result != FSA_RESULT::OK)
+			return result;
+
+		result = __FSPrepareCmd_WriteFile(shimBuffer->GetPtr(), client, buffer, size, count, 0, handle, flags & ~0x2);
+		if (result == FSA_RESULT::OK)
+		{
+			result = __FSAIPCSubmitCommand(shimBuffer->GetPtr());
+		}
+
+		FSAShimFreeBuffer(shimBuffer->GetPtr());
+		return result;
+	}
+
+	FSA_RESULT FSAGetInfoByQuery(FSAClientHandle client, char* path, uint32_t queryType, MEMPTR<void> outData)
+	{
+		if (outData.IsNull())
+			return FSA_RESULT::INVALID_BUFFER;
+
+		StackAllocator<MEMPTR<iosu::fsa::FSAShimBuffer>, 1> shimBuffer;
+		FSA_RESULT result = FSAShimAllocateBuffer(shimBuffer.GetPointer());
+		if (result != FSA_RESULT::OK)
+			return result;
+
+		result = __FSPrepareCmd_QueryInfo(shimBuffer->GetPtr(), client, (uint8_t*)path, queryType);
+		if (result == FSA_RESULT::OK)
+		{
+			result = __FSAIPCSubmitCommand(shimBuffer->GetPtr());
+			if (result == FSA_RESULT::OK)
+			{
+				if (queryType == FSA_QUERY_TYPE_FREESPACE)
+				{
+					*MEMPTR<uint64be>(outData.GetMPTR()) = shimBuffer->GetPtr()->response.cmdQueryInfo.queryFreeSpace.freespace;
+				}
+				else if (queryType == FSA_QUERY_TYPE_DEVICE_INFO)
+				{
+					*MEMPTR<FSADeviceInfo_t>(outData.GetMPTR()) = shimBuffer->GetPtr()->response.cmdQueryInfo.queryDeviceInfo.info;
+				}
+				else if (queryType == FSA_QUERY_TYPE_STAT)
+				{
+					*MEMPTR<FSStat_t>(outData.GetMPTR()) = shimBuffer->GetPtr()->response.cmdQueryInfo.queryStat.stat;
+				}
+				else
+				{
+					// TODO: implement other query types
+					cemu_assert_unimplemented();
+					result = FSA_RESULT::FATAL_ERROR;
+				}
+			}
+		}
+
+		FSAShimFreeBuffer(shimBuffer->GetPtr());
+		return result;
+	}
+
+	FSA_RESULT FSAGetStat(FSAClientHandle client, char* path, FSStat_t* outStat)
+	{
+		return FSAGetInfoByQuery(client, path, FSA_QUERY_TYPE_STAT, outStat);
+	}
+
+	FSA_RESULT FSAGetFreeSpaceSize(FSAClientHandle client, char* path, uint64* outSize)
+	{
+		return FSAGetInfoByQuery(client, path, FSA_QUERY_TYPE_DEVICE_INFO, outSize);
+	}
+
+	FSA_RESULT FSAGetDeviceInfo(FSAClientHandle client, char* path, void* outSize)
+	{
+		return FSAGetInfoByQuery(client, path, FSA_QUERY_TYPE_FREESPACE, outSize);
+	}
+
+	SysAllocator s_fsaStr_OK("FSA_STATUS_OK");
+	SysAllocator s_fsaStr_NOT_INIT("FSA_STATUS_NOT_INIT");
+	SysAllocator s_fsaStr_END_OF_DIRECTORY("FSA_STATUS_END_OF_DIRECTORY");
+	SysAllocator s_fsaStr_END_OF_FILE("FSA_STATUS_END_OF_FILE");
+	SysAllocator s_fsaStr_MAX_CLIENTS("FSA_STATUS_MAX_CLIENTS");
+	SysAllocator s_fsaStr_MAX_FILES("FSA_STATUS_MAX_FILES");
+	SysAllocator s_fsaStr_MAX_DIRS("FSA_STATUS_MAX_DIRS");
+	SysAllocator s_fsaStr_ALREADY_EXISTS("FSA_STATUS_ALREADY_EXISTS");
+	SysAllocator s_fsaStr_NOT_FOUND("FSA_STATUS_NOT_FOUND");
+	SysAllocator s_fsaStr_PERMISSION_ERROR("FSA_STATUS_PERMISSION_ERROR");
+	SysAllocator s_fsaStr_INVALID_PARAM("FSA_STATUS_INVALID_PARAM");
+	SysAllocator s_fsaStr_INVALID_PATH("FSA_STATUS_INVALID_PATH");
+	SysAllocator s_fsaStr_INVALID_BUFFER("FSA_STATUS_INVALID_BUFFER");
+	SysAllocator s_fsaStr_INVALID_ALIGNMENT("FSA_STATUS_INVALID_ALIGNMENT");
+	SysAllocator s_fsaStr_INVALID_CLIENT_HANDLE("FSA_STATUS_INVALID_CLIENT_HANDLE");
+	SysAllocator s_fsaStr_INVALID_FILE_HANDLE("FSA_STATUS_INVALID_FILE_HANDLE");
+	SysAllocator s_fsaStr_INVALID_DIR_HANDLE("FSA_STATUS_INVALID_DIR_HANDLE");
+	SysAllocator s_fsaStr_NOT_FILE("FSA_STATUS_NOT_FILE");
+	SysAllocator s_fsaStr_NOT_DIR("FSA_STATUS_NOT_DIR");
+	SysAllocator s_fsaStr_OUT_OF_RESOURCES("FSA_STATUS_OUT_OF_RESOURCES");
+	SysAllocator s_fsaStr_UNKNOWN("FSA_STATUS_???");
+
+	const char* FSAGetStatusStr(FSA_RESULT status)
+	{
+		switch (status)
+		{
+		case FSA_RESULT::OK:
+		{
+			return s_fsaStr_OK.GetPtr();
+		}
+		case FSA_RESULT::NOT_INIT:
+		{
+			return s_fsaStr_NOT_INIT.GetPtr();
+		}
+		case FSA_RESULT::END_OF_DIRECTORY:
+		{
+			return s_fsaStr_END_OF_DIRECTORY.GetPtr();
+		}
+		case FSA_RESULT::END_OF_FILE:
+		{
+			return s_fsaStr_END_OF_FILE.GetPtr();
+		}
+		case FSA_RESULT::MAX_CLIENTS:
+		{
+			return s_fsaStr_MAX_CLIENTS.GetPtr();
+		}
+		case FSA_RESULT::MAX_FILES:
+		{
+			return s_fsaStr_MAX_FILES.GetPtr();
+		}
+		case FSA_RESULT::MAX_DIRS:
+		{
+			return s_fsaStr_MAX_DIRS.GetPtr();
+		}
+		case FSA_RESULT::ALREADY_EXISTS:
+		{
+			return s_fsaStr_ALREADY_EXISTS.GetPtr();
+		}
+		case FSA_RESULT::NOT_FOUND:
+		{
+			return s_fsaStr_NOT_FOUND.GetPtr();
+		}
+		case FSA_RESULT::PERMISSION_ERROR:
+		{
+			return s_fsaStr_PERMISSION_ERROR.GetPtr();
+		}
+		case FSA_RESULT::INVALID_PARAM:
+		{
+			return s_fsaStr_INVALID_PARAM.GetPtr();
+		}
+		case FSA_RESULT::INVALID_PATH:
+		{
+			return s_fsaStr_INVALID_PATH.GetPtr();
+		}
+		case FSA_RESULT::INVALID_BUFFER:
+		{
+			return s_fsaStr_INVALID_BUFFER.GetPtr();
+		}
+		case FSA_RESULT::INVALID_ALIGNMENT:
+		{
+			return s_fsaStr_INVALID_ALIGNMENT.GetPtr();
+		}
+		case FSA_RESULT::INVALID_CLIENT_HANDLE:
+		{
+			return s_fsaStr_INVALID_CLIENT_HANDLE.GetPtr();
+		}
+		case FSA_RESULT::INVALID_FILE_HANDLE:
+		{
+			return s_fsaStr_INVALID_FILE_HANDLE.GetPtr();
+		}
+		case FSA_RESULT::INVALID_DIR_HANDLE:
+		{
+			return s_fsaStr_INVALID_DIR_HANDLE.GetPtr();
+		}
+		case FSA_RESULT::NOT_FILE:
+		{
+			return s_fsaStr_NOT_FILE.GetPtr();
+		}
+		case FSA_RESULT::NOT_DIR:
+		{
+			return s_fsaStr_NOT_DIR.GetPtr();
+		}
+		case FSA_RESULT::OUT_OF_RESOURCES:
+		{
+			return s_fsaStr_OUT_OF_RESOURCES.GetPtr();
+		}
+		case FSA_RESULT::FATAL_ERROR:
+		{
+			return s_fsaStr_UNKNOWN.GetPtr();
+		}
+		}
+		cemu_assert_unimplemented();
+		return s_fsaStr_UNKNOWN.GetPtr();
+	}
+
+	FSA_RESULT FSAMount(FSAClientHandle client, const char* source, const char* target, uint32 flags, void* arg_buf, uint32_t arg_len)
+	{
+		if ("/dev/sdcard01" == std::string_view(source) && "/vol/external01" == std::string_view(target) && flags == 0 && arg_buf == nullptr && arg_len == 0)
+		{
+			mountSDCard();
+			return FSA_RESULT::OK;
+		}
+		else
+		{
+			cemu_assert_unimplemented();
+		}
+
+		return FSA_RESULT::FATAL_ERROR;
+	}
+
+	FSA_RESULT FSAUnmount(FSAClientHandle client,
+						  const char* mountedTarget,
+						  uint32 flags)
+	{
+		return FSA_RESULT::OK;
+	}
+
 	void InitializeFS()
 	{
-		cafeExportRegister("coreinit", FSInit, LogType::File);
-		cafeExportRegister("coreinit", FSShutdown, LogType::File);
+		OSInitMutex(&s_fsGlobalMutex);
 
-		cafeExportRegister("coreinit", FSGetMountSource, LogType::File);
-		cafeExportRegister("coreinit", FSGetMountSourceNext, LogType::File);
+		cafeExportRegister("coreinit", FSInit, LogType::CoreinitFile);
+		cafeExportRegister("coreinit", FSShutdown, LogType::CoreinitFile);
 
-		cafeExportRegister("coreinit", FSMount, LogType::File);
-		cafeExportRegister("coreinit", FSBindMount, LogType::File);
+		cafeExportRegister("coreinit", FSGetMountSource, LogType::CoreinitFile);
+		cafeExportRegister("coreinit", FSGetMountSourceNext, LogType::CoreinitFile);
+
+		cafeExportRegister("coreinit", FSMount, LogType::CoreinitFile);
+		cafeExportRegister("coreinit", FSBindMount, LogType::CoreinitFile);
 
 		// client management
-		cafeExportRegister("coreinit", FSAddClientEx, LogType::File);
-		cafeExportRegister("coreinit", FSAddClient, LogType::File);
-		cafeExportRegister("coreinit", FSDelClient, LogType::File);
-		cafeExportRegister("coreinit", FSGetClientNum, LogType::File);
+		cafeExportRegister("coreinit", FSAddClientEx, LogType::CoreinitFile);
+		cafeExportRegister("coreinit", FSAddClient, LogType::CoreinitFile);
+		cafeExportRegister("coreinit", FSDelClient, LogType::CoreinitFile);
+		cafeExportRegister("coreinit", FSGetClientNum, LogType::CoreinitFile);
 
 		// cmd
-		cafeExportRegister("coreinit", FSInitCmdBlock, LogType::File);
-		cafeExportRegister("coreinit", FSGetAsyncResult, LogType::File);
+		cafeExportRegister("coreinit", FSInitCmdBlock, LogType::CoreinitFile);
+		cafeExportRegister("coreinit", FSGetAsyncResult, LogType::CoreinitFile);
 
 		// file operations
-		cafeExportRegister("coreinit", FSOpenFileAsync, LogType::File);
-		cafeExportRegister("coreinit", FSOpenFile, LogType::File);
-		cafeExportRegister("coreinit", FSOpenFileExAsync, LogType::File);
-		cafeExportRegister("coreinit", FSOpenFileEx, LogType::File);
-		cafeExportRegister("coreinit", FSCloseFileAsync, LogType::File);
-		cafeExportRegister("coreinit", FSCloseFile, LogType::File);
+		cafeExportRegister("coreinit", FSOpenFileAsync, LogType::CoreinitFile);
+		cafeExportRegister("coreinit", FSOpenFile, LogType::CoreinitFile);
+		cafeExportRegister("coreinit", FSOpenFileExAsync, LogType::CoreinitFile);
+		cafeExportRegister("coreinit", FSOpenFileEx, LogType::CoreinitFile);
+		cafeExportRegister("coreinit", FSCloseFileAsync, LogType::CoreinitFile);
+		cafeExportRegister("coreinit", FSCloseFile, LogType::CoreinitFile);
 
-		cafeExportRegister("coreinit", FSReadFileAsync, LogType::File);
-		cafeExportRegister("coreinit", FSReadFile, LogType::File);
-		cafeExportRegister("coreinit", FSReadFileWithPosAsync, LogType::File);
-		cafeExportRegister("coreinit", FSReadFileWithPos, LogType::File);
+		cafeExportRegister("coreinit", FSReadFileAsync, LogType::CoreinitFile);
+		cafeExportRegister("coreinit", FSReadFile, LogType::CoreinitFile);
+		cafeExportRegister("coreinit", FSReadFileWithPosAsync, LogType::CoreinitFile);
+		cafeExportRegister("coreinit", FSReadFileWithPos, LogType::CoreinitFile);
 
-		cafeExportRegister("coreinit", FSWriteFileAsync, LogType::File);
-		cafeExportRegister("coreinit", FSWriteFile, LogType::File);
-		cafeExportRegister("coreinit", FSWriteFileWithPosAsync, LogType::File);
-		cafeExportRegister("coreinit", FSWriteFileWithPos, LogType::File);
+		cafeExportRegister("coreinit", FSWriteFileAsync, LogType::CoreinitFile);
+		cafeExportRegister("coreinit", FSWriteFile, LogType::CoreinitFile);
+		cafeExportRegister("coreinit", FSWriteFileWithPosAsync, LogType::CoreinitFile);
+		cafeExportRegister("coreinit", FSWriteFileWithPos, LogType::CoreinitFile);
 
-		cafeExportRegister("coreinit", FSSetPosFileAsync, LogType::File);
-		cafeExportRegister("coreinit", FSSetPosFile, LogType::File);
-		cafeExportRegister("coreinit", FSGetPosFileAsync, LogType::File);
-		cafeExportRegister("coreinit", FSGetPosFile, LogType::File);
+		cafeExportRegister("coreinit", FSSetPosFileAsync, LogType::CoreinitFile);
+		cafeExportRegister("coreinit", FSSetPosFile, LogType::CoreinitFile);
+		cafeExportRegister("coreinit", FSGetPosFileAsync, LogType::CoreinitFile);
+		cafeExportRegister("coreinit", FSGetPosFile, LogType::CoreinitFile);
 
-		cafeExportRegister("coreinit", FSAppendFileAsync, LogType::File);
-		cafeExportRegister("coreinit", FSAppendFile, LogType::File);
+		cafeExportRegister("coreinit", FSAppendFileAsync, LogType::CoreinitFile);
+		cafeExportRegister("coreinit", FSAppendFile, LogType::CoreinitFile);
 
-		cafeExportRegister("coreinit", FSTruncateFileAsync, LogType::File);
-		cafeExportRegister("coreinit", FSTruncateFile, LogType::File);
+		cafeExportRegister("coreinit", FSTruncateFileAsync, LogType::CoreinitFile);
+		cafeExportRegister("coreinit", FSTruncateFile, LogType::CoreinitFile);
 
-		cafeExportRegister("coreinit", FSRenameAsync, LogType::File);
-		cafeExportRegister("coreinit", FSRename, LogType::File);
-		cafeExportRegister("coreinit", FSRemoveAsync, LogType::File);
-		cafeExportRegister("coreinit", FSRemove, LogType::File);
-		cafeExportRegister("coreinit", FSMakeDirAsync, LogType::File);
-		cafeExportRegister("coreinit", FSMakeDir, LogType::File);
-		cafeExportRegister("coreinit", FSChangeDirAsync, LogType::File);
-		cafeExportRegister("coreinit", FSChangeDir, LogType::File);
-		cafeExportRegister("coreinit", FSGetCwdAsync, LogType::File);
-		cafeExportRegister("coreinit", FSGetCwd, LogType::File);		
+		cafeExportRegister("coreinit", FSRenameAsync, LogType::CoreinitFile);
+		cafeExportRegister("coreinit", FSRename, LogType::CoreinitFile);
+		cafeExportRegister("coreinit", FSRemoveAsync, LogType::CoreinitFile);
+		cafeExportRegister("coreinit", FSRemove, LogType::CoreinitFile);
+		cafeExportRegister("coreinit", FSMakeDirAsync, LogType::CoreinitFile);
+		cafeExportRegister("coreinit", FSMakeDir, LogType::CoreinitFile);
+		cafeExportRegister("coreinit", FSChangeDirAsync, LogType::CoreinitFile);
+		cafeExportRegister("coreinit", FSChangeDir, LogType::CoreinitFile);
+		cafeExportRegister("coreinit", FSGetCwdAsync, LogType::CoreinitFile);
+		cafeExportRegister("coreinit", FSGetCwd, LogType::CoreinitFile);
 
-		cafeExportRegister("coreinit", FSIsEofAsync, LogType::File);
-		cafeExportRegister("coreinit", FSIsEof, LogType::File);
+		cafeExportRegister("coreinit", FSIsEofAsync, LogType::CoreinitFile);
+		cafeExportRegister("coreinit", FSIsEof, LogType::CoreinitFile);
 
 		// directory operations
-		cafeExportRegister("coreinit", FSOpenDirAsync, LogType::File);
-		cafeExportRegister("coreinit", FSOpenDir, LogType::File);
-		cafeExportRegister("coreinit", FSReadDirAsync, LogType::File);
-		cafeExportRegister("coreinit", FSReadDir, LogType::File);
-		cafeExportRegister("coreinit", FSCloseDirAsync, LogType::File);
-		cafeExportRegister("coreinit", FSCloseDir, LogType::File);
-		
+		cafeExportRegister("coreinit", FSOpenDirAsync, LogType::CoreinitFile);
+		cafeExportRegister("coreinit", FSOpenDir, LogType::CoreinitFile);
+		cafeExportRegister("coreinit", FSReadDirAsync, LogType::CoreinitFile);
+		cafeExportRegister("coreinit", FSReadDir, LogType::CoreinitFile);
+		cafeExportRegister("coreinit", FSCloseDirAsync, LogType::CoreinitFile);
+		cafeExportRegister("coreinit", FSCloseDir, LogType::CoreinitFile);
+
 		// stat
-		cafeExportRegister("coreinit", FSGetFreeSpaceSizeAsync, LogType::File);
-		cafeExportRegister("coreinit", FSGetFreeSpaceSize, LogType::File);
+		cafeExportRegister("coreinit", FSGetFreeSpaceSizeAsync, LogType::CoreinitFile);
+		cafeExportRegister("coreinit", FSGetFreeSpaceSize, LogType::CoreinitFile);
 
-		cafeExportRegister("coreinit", FSGetStatAsync, LogType::File);
-		cafeExportRegister("coreinit", FSGetStat, LogType::File);
+		cafeExportRegister("coreinit", FSGetStatAsync, LogType::CoreinitFile);
+		cafeExportRegister("coreinit", FSGetStat, LogType::CoreinitFile);
 
-		cafeExportRegister("coreinit", FSGetStatFileAsync, LogType::File);
-		cafeExportRegister("coreinit", FSGetStatFile, LogType::File);
+		cafeExportRegister("coreinit", FSGetStatFileAsync, LogType::CoreinitFile);
+		cafeExportRegister("coreinit", FSGetStatFile, LogType::CoreinitFile);
 
 		// misc
-		cafeExportRegister("coreinit", FSFlushQuotaAsync, LogType::File);
-		cafeExportRegister("coreinit", FSFlushQuota, LogType::File);
+		cafeExportRegister("coreinit", FSFlushQuotaAsync, LogType::CoreinitFile);
+		cafeExportRegister("coreinit", FSFlushQuota, LogType::CoreinitFile);
 
-		cafeExportRegister("coreinit", FSSetUserData, LogType::File);
-		cafeExportRegister("coreinit", FSGetUserData, LogType::File);
+		cafeExportRegister("coreinit", FSSetUserData, LogType::CoreinitFile);
+		cafeExportRegister("coreinit", FSGetUserData, LogType::CoreinitFile);
 
-		cafeExportRegister("coreinit", FSGetCurrentCmdBlock, LogType::File);
+		cafeExportRegister("coreinit", FSGetCurrentCmdBlock, LogType::CoreinitFile);
 
-		cafeExportRegister("coreinit", FSGetVolumeState, LogType::File);
+		cafeExportRegister("coreinit", FSGetVolumeState, LogType::CoreinitFile);
 		cafeExportRegister("coreinit", FSGetErrorCodeForViewer, LogType::Placeholder);
 		cafeExportRegister("coreinit", FSGetLastErrorCodeForViewer, LogType::Placeholder);
 
+		cafeExportRegister("coreinit", FSAMakeDir, LogType::Placeholder);
+		cafeExportRegister("coreinit", FSAInit, LogType::Placeholder);
+		cafeExportRegister("coreinit", FSAAddClient, LogType::Placeholder);
+		cafeExportRegister("coreinit", FSADelClient, LogType::Placeholder);
+		cafeExportRegister("coreinit", FSARewindDir, LogType::Placeholder);
+		cafeExportRegister("coreinit", FSAGetDeviceInfo, LogType::Placeholder);
+		cafeExportRegister("coreinit", FSARename, LogType::Placeholder);
+
+		cafeExportRegister("coreinit", FSAChangeDir, LogType::Placeholder);
+
+		cafeExportRegister("coreinit", FSAMount, LogType::Placeholder);
+		cafeExportRegister("coreinit", FSAUnmount, LogType::Placeholder);
+
+		cafeExportRegister("coreinit", FSAChangeMode, LogType::Placeholder);
+		cafeExportRegister("coreinit", FSAReadDir, LogType::Placeholder);
+		cafeExportRegister("coreinit", FSAOpenDir, LogType::Placeholder);
+		cafeExportRegister("coreinit", FSACloseDir, LogType::Placeholder);
+		cafeExportRegister("coreinit", FSACloseFile, LogType::Placeholder);
+		cafeExportRegister("coreinit", FSAFlushFile, LogType::Placeholder);
+		cafeExportRegister("coreinit", FSAOpenFileEx, LogType::Placeholder);
+		cafeExportRegister("coreinit", FSAGetStatFile, LogType::Placeholder);
+		cafeExportRegister("coreinit", FSAGetFreeSpaceSize, LogType::Placeholder);
+		cafeExportRegister("coreinit", FSASetPosFile, LogType::Placeholder);
+		cafeExportRegister("coreinit", FSATruncateFile, LogType::Placeholder);
+		cafeExportRegister("coreinit", FSARemove, LogType::Placeholder);
+		cafeExportRegister("coreinit", FSAReadFile, LogType::Placeholder);
+		cafeExportRegister("coreinit", FSAWriteFile, LogType::Placeholder);
+		cafeExportRegister("coreinit", FSAGetStat, LogType::Placeholder);
+		cafeExportRegister("coreinit", FSAGetStatusStr, LogType::Placeholder);
+
 		g_fsRegisteredClientBodies = nullptr;
 	}
-}
+} // namespace coreinit
diff --git a/src/Cafe/OS/libs/coreinit/coreinit_FS.h b/src/Cafe/OS/libs/coreinit/coreinit_FS.h
index cdda692a..bf12e33c 100644
--- a/src/Cafe/OS/libs/coreinit/coreinit_FS.h
+++ b/src/Cafe/OS/libs/coreinit/coreinit_FS.h
@@ -5,31 +5,23 @@
 #include "Cafe/IOSU/fsa/iosu_fsa.h"
 #include "coreinit_MessageQueue.h"
 
-typedef struct
-{
-	uint32be fileHandle;
-}FSFileHandleDepr_t;
-
+typedef MEMPTR<betype<FSFileHandle2>> FSFileHandlePtr;
 typedef MEMPTR<betype<FSDirHandle2>> FSDirHandlePtr;
 
-typedef struct
-{
-	MEMPTR<void>				userCallback;
-	MEMPTR<void>				userContext;
-	MEMPTR<coreinit::OSMessageQueue>	ioMsgQueue;
-}FSAsyncParamsNew_t;
+typedef uint32 FSAClientHandle;
 
-static_assert(sizeof(FSAsyncParamsNew_t) == 0xC);
-
-typedef struct
+struct FSAsyncParams
 {
-	MPTR					userCallback; // 0x96C
-	MPTR					userContext;
-	MPTR					ioMsgQueue;
-}FSAsyncParams_t; // legacy struct. Replace with FSAsyncParamsNew_t
+	MEMPTR<void> userCallback;
+	MEMPTR<void> userContext;
+	MEMPTR<coreinit::OSMessageQueue> ioMsgQueue;
+};
+static_assert(sizeof(FSAsyncParams) == 0xC);
 
 namespace coreinit
 {
+	struct FSCmdBlockBody;
+
 	struct FSCmdQueue
 	{
 		enum class QUEUE_FLAG : uint32
@@ -38,9 +30,9 @@ namespace coreinit
 			CANCEL_ALL = (1 << 4),
 		};
 
-		/* +0x00 */ MPTR firstMPTR;
-		/* +0x04 */ MPTR lastMPTR;
-		/* +0x08 */ OSMutex mutex;
+		/* +0x00 */ MEMPTR<FSCmdBlockBody> first;
+		/* +0x04 */ MEMPTR<FSCmdBlockBody> last;
+		/* +0x08 */ OSFastMutex fastMutex;
 		/* +0x34 */ MPTR dequeueHandlerFuncMPTR;
 		/* +0x38 */ uint32be numCommandsInFlight;
 		/* +0x3C */ uint32 numMaxCommandsInFlight;
@@ -48,8 +40,10 @@ namespace coreinit
 	};
 	DEFINE_ENUM_FLAG_OPERATORS(FSCmdQueue::QUEUE_FLAG);
 
-	#define FS_CLIENT_BUFFER_SIZE           (5888)
-	#define FS_CMD_BLOCK_SIZE               (2688)
+	static_assert(sizeof(FSCmdQueue) == 0x44);
+
+#define FS_CLIENT_BUFFER_SIZE (5888)
+#define FS_CMD_BLOCK_SIZE (2688)
 
 	struct FSClient_t
 	{
@@ -64,7 +58,7 @@ namespace coreinit
 			struct
 			{
 				uint32 mount_it;
-			}data;
+			} data;
 		};
 	};
 
@@ -104,7 +98,7 @@ namespace coreinit
 		uint8 ukn1460[0x10];
 		uint8 ukn1470[0x10];
 		FSCmdQueue fsCmdQueue;
-		/* +0x14C4 */ MEMPTR<struct FSCmdBlockBody_t> currentCmdBlockBody; // set to currently active cmd
+		/* +0x14C4 */ MEMPTR<struct FSCmdBlockBody> currentCmdBlockBody; // set to currently active cmd
 		uint32 ukn14C8;
 		uint32 ukn14CC;
 		uint8 ukn14D0[0x10];
@@ -116,7 +110,7 @@ namespace coreinit
 		uint32 ukn1608;
 		uint32 ukn160C;
 		uint32 ukn1610;
-		MEMPTR<FSClientBody_t> fsClientBodyNext; // next FSClientBody_t* in list of registered clients (list is circular, the last element points to the first element)
+		MEMPTR<FSClientBody_t> fsClientBodyNext;	 // next FSClientBody_t* in list of registered clients (list is circular, the last element points to the first element)
 		uint32 ukn1618;
 		/* +0x161C */ MEMPTR<FSClient_t> selfClient; // pointer to FSClient struct which holds this FSClientBody
 		uint32 ukn1620;
@@ -124,86 +118,93 @@ namespace coreinit
 
 	struct FSAsyncResult
 	{
-		/* +0x00 */ FSAsyncParamsNew_t fsAsyncParamsNew;
+		/* +0x00 */ FSAsyncParams fsAsyncParamsNew;
 
 		// fs message storage
-		struct FSMessage 
+		struct FSMessage
 		{
-			/* +0x0C / 0x0978 */ MEMPTR<FSAsyncResult>	fsAsyncResult;
-			/* +0x10 */ MPTR	fsClientMPTR2;		// 0x097C 
-			/* +0x14 */ MPTR	fsCmdBlockMPTR;		// 0x0980
-			/* +0x18 */ MPTR	commandType;		// 0x0984
+			/* +0x0C / 0x0978 */ MEMPTR<FSAsyncResult> fsAsyncResult;
+			/* +0x10 */ MPTR fsClientMPTR2;	 // 0x097C
+			/* +0x14 */ MPTR fsCmdBlockMPTR; // 0x0980
+			/* +0x18 */ MPTR commandType;	 // 0x0984
 		};
 
 		union
 		{
 			OSMessage osMsg;
 			FSMessage fsMsg;
-		}msgUnion;
+		} msgUnion;
 
-		/* +0x1C */ MEMPTR<FSClient_t> fsClient; // 0x0988
+		/* +0x1C */ MEMPTR<FSClient_t> fsClient;	 // 0x0988
 		/* +0x20 */ MEMPTR<FSCmdBlock_t> fsCmdBlock; // 0x98C
-		/* +0x24 */ uint32be fsStatusNew; // 0x990
+		/* +0x24 */ uint32be fsStatusNew;			 // 0x990
 	};
 
 	static_assert(sizeof(FSAsyncResult) == 0x28);
 
-	struct FSCmdBlockBody_t
+	struct FSCmdBlockReturnValues_t
 	{
-		iosu::fsa::FSAIpcCommand ipcData;
-		uint8 ukn0820[0x10];
-		uint8 ukn0830[0x10];
-		uint8 ukn0840[0x10];
-		uint8 ukn0850[0x10];
-		uint8 ukn0860[0x10];
-		uint8 ukn0870[0x10];
-		MPTR fsCmdBlockBodyMPTR;
-		uint32 ukn0884;
-		uint32 ukn0888;
-		uint32 destBuffer88CMPTR;
-		uint32 ukn0890;
-		uint32 ukn0894;
-		uint32 ukn0898;
-		uint32 ukn089C;
-		uint32 ukn08A0;
-		uint32 ukn08A4;
-		uint32 ukn08A8;
-		uint32 ukn08AC;
-		uint8 ukn08B0[0x10];
-		uint8 ukn08C0[0x10];
-		uint8 ukn08D0[0x10];
-		uint8 ukn08E0[0x10];
-		uint8 ukn08F0[0x10];
-		/* +0x0900 */ uint32be operationType;
-		betype<IOSDevHandle> fsaDevHandle;
-		/* +0x0908 */ uint16be ipcReqType; // 0 -> IoctlAsync, 1 -> IoctlvAsync
-		uint8 ukn090A;
-		uint8 ukn090B;
-		uint32 ukn090C;
-		uint32 ukn0910;
-		uint32 ukn0914;
-		uint32 ukn0918;
-		uint32 ukn091C;
-		uint32 ukn0920;
-		uint32 ukn0924;
-		uint32 ukn0928;
-		uint32 ukn092C;
-		uint32 ukn0930;
-		uint32 ukn0934;
-		/* +0x0938 */ MEMPTR<FSClientBody_t> fsClientBody;
-		/* +0x093C */ uint32 statusCode; // not a status code but rather the state? Uses weird values for some reason
-		/* +0x0940 */ uint32be cancelState; // bitmask. Bit 0 -> If set command has been canceled
-		// return values
-		/* +0x0944 */ uint32 returnValueMPTR; // returnedFilePos (used to store pointer to variable that holds return value?), also used by QUERYINFO to store pointer for result. Also used for GetCwd() to hold the pointer for the returned dir path. Also used by OPENFILE to hold returned fileHandle
-		/* +0x0948 */ uint32 transferSize; // number of bytes to transfer
-		// transfer control?
-		uint32 uknVal094C;
-		uint32 transferElemSize; // number of bytes of a single transferred element (count of elements can be calculated via count = transferSize/transferElemSize)
-		uint32 uknVal0954; // this is set to max(0x10, transferSize) for reads and to min(0x40000, transferSize) for writes?
-		// link for cmd queue
-		MPTR nextMPTR;  // points towards FSCmdQueue->first
-		MPTR previousMPTR; // points towards FSCmdQueue->last
+		union
+		{
+			uint8 ukn0[0x14];
+			struct
+			{
+				MEMPTR<betype<FSResHandle>> handlePtr;
+			} cmdOpenFile;
+			struct
+			{
+				MEMPTR<uint32be> filePosPtr;
+			} cmdGetPosFile;
+			struct
+			{
+				uint32be transferSize;
+				uint32be uknVal094C;
+				uint32be transferElemSize;
+				uint32be uknVal0954;
+			} cmdReadFile;
+			struct
+			{
+				uint32be transferSize;
+				uint32be uknVal094C;
+				uint32be transferElemSize;
+				uint32be uknVal0954;
+			} cmdWriteFile;
+			struct
+			{
+				MEMPTR<uint32be> handlePtr;
+			} cmdOpenDir;
+			struct
+			{
+				MEMPTR<FSDirEntry_t> dirEntryPtr;
+			} cmdReadDir;
+			struct
+			{
+				MEMPTR<char> pathPtr;
+				uint32be transferSize;
+			} cmdGetCwd;
+			struct
+			{
+				MEMPTR<void> queryResultPtr;
+			} cmdQueryInfo;
+			struct
+			{
+				MEMPTR<void> resultPtr;
+			} cmdStatFile;
+		};
+	};
 
+	static_assert(sizeof(FSCmdBlockReturnValues_t) == 0x14);
+
+	struct FSCmdBlockBody
+	{
+		iosu::fsa::FSAShimBuffer fsaShimBuffer;
+		/* +0x0938 */ MEMPTR<FSClientBody_t> fsClientBody;
+		/* +0x093C */ uint32 statusCode;	// not a status code but rather the state? Uses weird values for some reason
+		/* +0x0940 */ uint32be cancelState; // bitmask. Bit 0 -> If set command has been canceled
+		FSCmdBlockReturnValues_t returnValues;
+		// link for cmd queue
+		MEMPTR<FSCmdBlockBody> next;
+		MEMPTR<FSCmdBlockBody> previous;
 		/* +0x960 */ betype<FSA_RESULT> lastFSAStatus;
 		uint32 ukn0964;
 		/* +0x0968 */ uint8 errHandling; // return error flag mask
@@ -223,37 +224,14 @@ namespace coreinit
 		uint32 ukn9FC;
 	};
 
-	static_assert(sizeof(FSAsyncParams_t) == 0xC);
 	static_assert(sizeof(FSCmdBlock_t) == 0xA80);
 
-	#define FSA_CMD_FLAG_SET_POS					(1<<0)
+#define FSA_CMD_FLAG_SET_POS (1 << 0)
 
-	#define FSA_CMD_OPERATION_TYPE_CHANGEDIR		(0x5)
-	#define FSA_CMD_OPERATION_TYPE_GETCWD			(0x6)
-	#define FSA_CMD_OPERATION_TYPE_MAKEDIR			(0x7)
-	#define FSA_CMD_OPERATION_TYPE_REMOVE			(0x8)
-	#define FSA_CMD_OPERATION_TYPE_RENAME			(0x9)
-	#define FSA_CMD_OPERATION_TYPE_OPENDIR			(0xA)
-	#define FSA_CMD_OPERATION_TYPE_READDIR			(0xB)
-	#define FSA_CMD_OPERATION_TYPE_CLOSEDIR			(0xD)
-	#define FSA_CMD_OPERATION_TYPE_OPENFILE			(0xE)
-	#define FSA_CMD_OPERATION_TYPE_READ				(0xF)
-	#define FSA_CMD_OPERATION_TYPE_WRITE			(0x10)
-	#define FSA_CMD_OPERATION_TYPE_GETPOS			(0x11)
-	#define FSA_CMD_OPERATION_TYPE_SETPOS			(0x12)
-	#define FSA_CMD_OPERATION_TYPE_ISEOF			(0x13)
-	#define FSA_CMD_OPERATION_TYPE_GETSTATFILE		(0x14)
-	#define FSA_CMD_OPERATION_TYPE_CLOSEFILE		(0x15)
-	#define FSA_CMD_OPERATION_TYPE_QUERYINFO	(0x18)
-	#define FSA_CMD_OPERATION_TYPE_APPENDFILE		(0x19)
-	#define FSA_CMD_OPERATION_TYPE_TRUNCATEFILE		(0x1A)
-	#define FSA_CMD_OPERATION_TYPE_FLUSHQUOTA		(0x1E)
-
-
-	#define FSA_CMD_STATUS_CODE_D900A21				0xD900A21	// cmd block is initialized
-	#define FSA_CMD_STATUS_CODE_D900A22				0xD900A22	// cmd block is queued
-	#define FSA_CMD_STATUS_CODE_D900A24				0xD900A24	// cmd block was processed and is available again
-	#define FSA_CMD_STATUS_CODE_D900A26				0xD900A26	// cmd block result is being processed
+#define FSA_CMD_STATUS_CODE_D900A21 0xD900A21 // cmd block is initialized
+#define FSA_CMD_STATUS_CODE_D900A22 0xD900A22 // cmd block is queued
+#define FSA_CMD_STATUS_CODE_D900A24 0xD900A24 // cmd block was processed and is available again
+#define FSA_CMD_STATUS_CODE_D900A26 0xD900A26 // cmd block result is being processed
 
 	enum FS_VOLSTATE : sint32
 	{
@@ -261,7 +239,7 @@ namespace coreinit
 	};
 
 	// internal interface
-	sint32 __FSQueryInfoAsync(FSClient_t* fsClient, FSCmdBlock_t* fsCmdBlock, uint8* queryString, uint32 queryType, void* queryResult, uint32 errHandling, FSAsyncParamsNew_t* fsAsyncParams);
+	sint32 __FSQueryInfoAsync(FSClient_t* fsClient, FSCmdBlock_t* fsCmdBlock, uint8* queryString, uint32 queryType, void* queryResult, uint32 errHandling, FSAsyncParams* fsAsyncParams);
 
 	// coreinit exports
 	FS_RESULT FSAddClientEx(FSClient_t* fsClient, uint32 uknR4, uint32 errHandling);
@@ -270,56 +248,55 @@ namespace coreinit
 
 	void FSInitCmdBlock(FSCmdBlock_t* fsCmdBlock);
 
-	sint32 FSOpenFileAsync(FSClient_t* fsClient, FSCmdBlock_t* fsCmdBlock, char* path, char* mode, FSFileHandleDepr_t* fileHandle, uint32 errHandling, FSAsyncParamsNew_t* asyncParams);
-	sint32 FSOpenFile(FSClient_t* fsClient, FSCmdBlock_t* fsCmdBlock, char* path, char* mode, FSFileHandleDepr_t* fileHandle, uint32 errHandling);
-	
-	sint32 FSReadFileAsync(FSClient_t* fsClient, FSCmdBlock_t* fsCmdBlock, void* dst, uint32 size, uint32 count, uint32 fileHandle, uint32 flag, uint32 errorMask, FSAsyncParamsNew_t* fsAsyncParams);
+	sint32 FSOpenFileAsync(FSClient_t* fsClient, FSCmdBlock_t* fsCmdBlock, char* path, char* mode, FSFileHandlePtr outFileHandle, uint32 errHandling, FSAsyncParams* asyncParams);
+	sint32 FSOpenFile(FSClient_t* fsClient, FSCmdBlock_t* fsCmdBlock, char* path, char* mode, FSFileHandlePtr outFileHandle, uint32 errHandling);
+
+	sint32 FSReadFileAsync(FSClient_t* fsClient, FSCmdBlock_t* fsCmdBlock, void* dst, uint32 size, uint32 count, uint32 fileHandle, uint32 flag, uint32 errorMask, FSAsyncParams* fsAsyncParams);
 	sint32 FSReadFile(FSClient_t* fsClient, FSCmdBlock_t* fsCmdBlock, void* dst, uint32 size, uint32 count, uint32 fileHandle, uint32 flag, uint32 errorMask);
-	sint32 FSReadFileWithPosAsync(FSClient_t* fsClient, FSCmdBlock_t* fsCmdBlock, void* dst, uint32 size, uint32 count, uint32 filePos, uint32 fileHandle, uint32 flag, uint32 errorMask, FSAsyncParamsNew_t* fsAsyncParams);
+	sint32 FSReadFileWithPosAsync(FSClient_t* fsClient, FSCmdBlock_t* fsCmdBlock, void* dst, uint32 size, uint32 count, uint32 filePos, uint32 fileHandle, uint32 flag, uint32 errorMask, FSAsyncParams* fsAsyncParams);
 	sint32 FSReadFileWithPos(FSClient_t* fsClient, FSCmdBlock_t* fsCmdBlock, void* dst, uint32 size, uint32 count, uint32 filePos, uint32 fileHandle, uint32 flag, uint32 errorMask);
-	
-	sint32 FSWriteFileAsync(FSClient_t* fsClient, FSCmdBlock_t* fsCmdBlock, void* src, uint32 size, uint32 count, uint32 fileHandle, uint32 flag, uint32 errorMask, FSAsyncParamsNew_t* fsAsyncParams);
+
+	sint32 FSWriteFileAsync(FSClient_t* fsClient, FSCmdBlock_t* fsCmdBlock, void* src, uint32 size, uint32 count, uint32 fileHandle, uint32 flag, uint32 errorMask, FSAsyncParams* fsAsyncParams);
 	sint32 FSWriteFile(FSClient_t* fsClient, FSCmdBlock_t* fsCmdBlock, void* src, uint32 size, uint32 count, uint32 fileHandle, uint32 flag, uint32 errorMask);
-	sint32 FSWriteFileWithPosAsync(FSClient_t* fsClient, FSCmdBlock_t* fsCmdBlock, void* src, uint32 size, uint32 count, uint32 filePos, uint32 fileHandle, uint32 flag, uint32 errorMask, FSAsyncParamsNew_t* fsAsyncParams);
+	sint32 FSWriteFileWithPosAsync(FSClient_t* fsClient, FSCmdBlock_t* fsCmdBlock, void* src, uint32 size, uint32 count, uint32 filePos, uint32 fileHandle, uint32 flag, uint32 errorMask, FSAsyncParams* fsAsyncParams);
 	sint32 FSWriteFileWithPos(FSClient_t* fsClient, FSCmdBlock_t* fsCmdBlock, void* src, uint32 size, uint32 count, uint32 filePos, uint32 fileHandle, uint32 flag, uint32 errorMask);
 
-	sint32 FSSetPosFileAsync(FSClient_t* fsClient, FSCmdBlock_t* fsCmdBlock, uint32 fileHandle, uint32 filePos, uint32 errorMask, FSAsyncParamsNew_t* fsAsyncParams);
+	sint32 FSSetPosFileAsync(FSClient_t* fsClient, FSCmdBlock_t* fsCmdBlock, uint32 fileHandle, uint32 filePos, uint32 errorMask, FSAsyncParams* fsAsyncParams);
 	sint32 FSSetPosFile(FSClient_t* fsClient, FSCmdBlock_t* fsCmdBlock, uint32 fileHandle, uint32 filePos, uint32 errorMask);
-	sint32 FSGetPosFileAsync(FSClient_t* fsClient, FSCmdBlock_t* fsCmdBlock, uint32 fileHandle, uint32be* returnedFilePos, uint32 errorMask, FSAsyncParamsNew_t* fsAsyncParams);
+	sint32 FSGetPosFileAsync(FSClient_t* fsClient, FSCmdBlock_t* fsCmdBlock, uint32 fileHandle, uint32be* returnedFilePos, uint32 errorMask, FSAsyncParams* fsAsyncParams);
 	sint32 FSGetPosFile(FSClient_t* fsClient, FSCmdBlock_t* fsCmdBlock, uint32 fileHandle, uint32be* returnedFilePos, uint32 errorMask);
 
-	sint32 FSAppendFileAsync(FSClient_t* fsClient, FSCmdBlock_t* fsCmdBlock, uint32 fileHandle, uint32 size, uint32 count, uint32 errorMask, FSAsyncParamsNew_t* fsAsyncParams);
+	sint32 FSAppendFileAsync(FSClient_t* fsClient, FSCmdBlock_t* fsCmdBlock, uint32 fileHandle, uint32 size, uint32 count, uint32 errorMask, FSAsyncParams* fsAsyncParams);
 	sint32 FSAppendFile(FSClient_t* fsClient, FSCmdBlock_t* fsCmdBlock, uint32 fileHandle, uint32 size, uint32 count, uint32 errorMask);
 
-	sint32 FSIsEofAsync(FSClient_t* fsClient, FSCmdBlock_t* fsCmdBlock, uint32 fileHandle, uint32 errorMask, FSAsyncParamsNew_t* fsAsyncParams);
+	sint32 FSIsEofAsync(FSClient_t* fsClient, FSCmdBlock_t* fsCmdBlock, uint32 fileHandle, uint32 errorMask, FSAsyncParams* fsAsyncParams);
 	sint32 FSIsEof(FSClient_t* fsClient, FSCmdBlock_t* fsCmdBlock, uint32 fileHandle, uint32 errorMask);
 
-	sint32 FSRenameAsync(FSClient_t* fsClient, FSCmdBlock_t* fsCmdBlock, char* srcPath, char* dstPath, uint32 errorMask, FSAsyncParamsNew_t* fsAsyncParams);
+	sint32 FSRenameAsync(FSClient_t* fsClient, FSCmdBlock_t* fsCmdBlock, char* srcPath, char* dstPath, uint32 errorMask, FSAsyncParams* fsAsyncParams);
 	sint32 FSRename(FSClient_t* fsClient, FSCmdBlock_t* fsCmdBlock, char* srcPath, char* dstPath, uint32 errorMask);
-	sint32 FSRemoveAsync(FSClient_t* fsClient, FSCmdBlock_t* fsCmdBlock, uint8* filePath, uint32 errorMask, FSAsyncParamsNew_t* fsAsyncParams);
+	sint32 FSRemoveAsync(FSClient_t* fsClient, FSCmdBlock_t* fsCmdBlock, uint8* filePath, uint32 errorMask, FSAsyncParams* fsAsyncParams);
 	sint32 FSRemove(FSClient_t* fsClient, FSCmdBlock_t* fsCmdBlock, uint8* filePath, uint32 errorMask);
-	sint32 FSMakeDirAsync(FSClient_t* fsClient, FSCmdBlock_t* fsCmdBlock, const uint8* dirPath, uint32 errorMask, FSAsyncParamsNew_t* fsAsyncParams);
-	sint32 FSMakeDir(FSClient_t* fsClient, FSCmdBlock_t* fsCmdBlock, const uint8* path, uint32 errorMask);
-	sint32 FSChangeDirAsync(FSClient_t* fsClient, FSCmdBlock_t* fsCmdBlock, char* path, uint32 errorMask, FSAsyncParamsNew_t* fsAsyncParams);
+	sint32 FSMakeDirAsync(FSClient_t* fsClient, FSCmdBlock_t* fsCmdBlock, const char* dirPath, uint32 errorMask, FSAsyncParams* fsAsyncParams);
+	sint32 FSMakeDir(FSClient_t* fsClient, FSCmdBlock_t* fsCmdBlock, const char* path, uint32 errorMask);
+	sint32 FSChangeDirAsync(FSClient_t* fsClient, FSCmdBlock_t* fsCmdBlock, char* path, uint32 errorMask, FSAsyncParams* fsAsyncParams);
 	sint32 FSChangeDir(FSClient_t* fsClient, FSCmdBlock_t* fsCmdBlock, char* path, uint32 errorMask);
-	sint32 FSGetCwdAsync(FSClient_t* fsClient, FSCmdBlock_t* fsCmdBlock, char* dirPathOut, sint32 dirPathMaxLen, uint32 errorMask, FSAsyncParamsNew_t* fsAsyncParams);
+	sint32 FSGetCwdAsync(FSClient_t* fsClient, FSCmdBlock_t* fsCmdBlock, char* dirPathOut, sint32 dirPathMaxLen, uint32 errorMask, FSAsyncParams* fsAsyncParams);
 	sint32 FSGetCwd(FSClient_t* fsClient, FSCmdBlock_t* fsCmdBlock, char* dirPathOut, sint32 dirPathMaxLen, uint32 errorMask);
 
-	sint32 FSGetFreeSpaceSizeAsync(FSClient_t* fsClient, FSCmdBlock_t* fsCmdBlock, const char* path, FSLargeSize* returnedFreeSize, uint32 errorMask, FSAsyncParamsNew_t* fsAsyncParams);
+	sint32 FSGetFreeSpaceSizeAsync(FSClient_t* fsClient, FSCmdBlock_t* fsCmdBlock, const char* path, FSLargeSize* returnedFreeSize, uint32 errorMask, FSAsyncParams* fsAsyncParams);
 	sint32 FSGetFreeSpaceSize(FSClient_t* fsClient, FSCmdBlock_t* fsCmdBlock, const char* path, FSLargeSize* returnedFreeSize, uint32 errorMask);
 
-	sint32 FSOpenDirAsync(FSClient_t* fsClient, FSCmdBlock_t* fsCmdBlock, char* path, FSDirHandlePtr dirHandleOut, uint32 errorMask, FSAsyncParamsNew_t* fsAsyncParams);
+	sint32 FSOpenDirAsync(FSClient_t* fsClient, FSCmdBlock_t* fsCmdBlock, char* path, FSDirHandlePtr dirHandleOut, uint32 errorMask, FSAsyncParams* fsAsyncParams);
 	sint32 FSOpenDir(FSClient_t* fsClient, FSCmdBlock_t* fsCmdBlock, char* path, FSDirHandlePtr dirHandleOut, uint32 errorMask);
-	sint32 FSReadDirAsync(FSClient_t* fsClient, FSCmdBlock_t* fsCmdBlock, FSDirHandle2 dirHandle, FSDirEntry_t* dirEntryOut, uint32 errorMask, FSAsyncParamsNew_t* fsAsyncParams);
-	sint32 FSReadDir(FSClient_t* fsClient, FSCmdBlock_t* fsCmdBlock, FSDirHandle2 dirHandle, FSDirEntry_t* dirEntryOut, uint32 errorMask, FSAsyncParamsNew_t* fsAsyncParams);
-	sint32 FSCloseDirAsync(FSClient_t* fsClient, FSCmdBlock_t* fsCmdBlock, FSDirHandle2 dirHandle, uint32 errorMask, FSAsyncParamsNew_t* fsAsyncParams);
+	sint32 FSReadDirAsync(FSClient_t* fsClient, FSCmdBlock_t* fsCmdBlock, FSDirHandle2 dirHandle, FSDirEntry_t* dirEntryOut, uint32 errorMask, FSAsyncParams* fsAsyncParams);
+	sint32 FSReadDir(FSClient_t* fsClient, FSCmdBlock_t* fsCmdBlock, FSDirHandle2 dirHandle, FSDirEntry_t* dirEntryOut, uint32 errorMask, FSAsyncParams* fsAsyncParams);
+	sint32 FSCloseDirAsync(FSClient_t* fsClient, FSCmdBlock_t* fsCmdBlock, FSDirHandle2 dirHandle, uint32 errorMask, FSAsyncParams* fsAsyncParams);
 	sint32 FSCloseDir(FSClient_t* fsClient, FSCmdBlock_t* fsCmdBlock, FSDirHandle2 dirHandle, uint32 errorMask);
 
-	sint32 FSFlushQuotaAsync(FSClient_t* fsClient, FSCmdBlock_t* fsCmdBlock, char* path, uint32 errorMask, FSAsyncParamsNew_t* fsAsyncParams);
+	sint32 FSFlushQuotaAsync(FSClient_t* fsClient, FSCmdBlock_t* fsCmdBlock, char* path, uint32 errorMask, FSAsyncParams* fsAsyncParams);
 	sint32 FSFlushQuota(FSClient_t* fsClient, FSCmdBlock_t* fsCmdBlock, char* path, uint32 errorMask);
 
 	FS_VOLSTATE FSGetVolumeState(FSClient_t* fsClient);
 
 	void InitializeFS();
-};
-
+}; // namespace coreinit
diff --git a/src/Cafe/OS/libs/coreinit/coreinit_GHS.cpp b/src/Cafe/OS/libs/coreinit/coreinit_GHS.cpp
index d7952053..33c8eedc 100644
--- a/src/Cafe/OS/libs/coreinit/coreinit_GHS.cpp
+++ b/src/Cafe/OS/libs/coreinit/coreinit_GHS.cpp
@@ -22,7 +22,7 @@ namespace coreinit
 		MPTR _iob_lock[GHS_FOPEN_MAX];
 		uint16be __gh_FOPEN_MAX;
 		MEMPTR<void> ghs_environ;
-		uint32 ghs_Errno; // exposed by __gh_errno_ptr() or via 'errno' data export
+		uint32 ghs_Errno; // exposed as 'errno' data export
 	};
 
 	SysAllocator<GHSAccessibleData> g_ghs_data;
@@ -86,7 +86,7 @@ namespace coreinit
 		}
 		if (mutexIndex == -1)
 		{
-			forceLog_printf("__ghs_flock_create(): No flock available");
+			cemuLog_log(LogType::Force, "__ghs_flock_create(): No flock available");
 			cemu_assert(false); // no available mutex
 		}
 		// mark mutex as reserved
@@ -156,10 +156,20 @@ namespace coreinit
 		return &currentThread->crt.eh_mem_manage;
 	}
 
-	void* __gh_errno_ptr()
+	sint32be* __gh_errno_ptr()
 	{
 		OSThread_t* currentThread = coreinit::OSGetCurrentThread();
-		return &currentThread->context.error;
+		return &currentThread->context.ghs_errno;
+	}
+
+	void __gh_set_errno(sint32 errNo)
+	{
+		*__gh_errno_ptr() = errNo;
+	}
+
+	sint32 __gh_get_errno()
+	{
+		return *__gh_errno_ptr();
 	}
 
 	void* __get_eh_store_globals()
@@ -272,6 +282,8 @@ namespace coreinit
 		cafeExportRegister("coreinit", __get_eh_globals, LogType::Placeholder);
 		cafeExportRegister("coreinit", __get_eh_mem_manage, LogType::Placeholder);
 		cafeExportRegister("coreinit", __gh_errno_ptr, LogType::Placeholder);
+		cafeExportRegister("coreinit", __gh_set_errno, LogType::Placeholder);
+		cafeExportRegister("coreinit", __gh_get_errno, LogType::Placeholder);
 		cafeExportRegister("coreinit", __get_eh_store_globals, LogType::Placeholder);
 		cafeExportRegister("coreinit", __get_eh_store_globals_tdeh, LogType::Placeholder);
 
@@ -282,4 +294,4 @@ namespace coreinit
 
 		cafeExportRegister("coreinit", __tls_get_addr, LogType::Placeholder);
 	}
-};
\ No newline at end of file
+};
diff --git a/src/Cafe/OS/libs/coreinit/coreinit_GHS.h b/src/Cafe/OS/libs/coreinit/coreinit_GHS.h
index 0ac09e94..5f000732 100644
--- a/src/Cafe/OS/libs/coreinit/coreinit_GHS.h
+++ b/src/Cafe/OS/libs/coreinit/coreinit_GHS.h
@@ -4,5 +4,9 @@ namespace coreinit
 {
 	void PrepareGHSRuntime();
 
+	sint32be* __gh_errno_ptr();
+	void __gh_set_errno(sint32 errNo);
+	sint32 __gh_get_errno();
+
 	void InitializeGHS();
 };
\ No newline at end of file
diff --git a/src/Cafe/OS/libs/coreinit/coreinit_IM.cpp b/src/Cafe/OS/libs/coreinit/coreinit_IM.cpp
index 2f4779fe..85e811c5 100644
--- a/src/Cafe/OS/libs/coreinit/coreinit_IM.cpp
+++ b/src/Cafe/OS/libs/coreinit/coreinit_IM.cpp
@@ -48,7 +48,7 @@ namespace coreinit
 
 	void coreinitExport_IMGetAPDPeriod(PPCInterpreter_t* hCPU)
 	{
-		forceLogDebug_printf("IMGetAPDPeriod(0x%08x)\n", hCPU->gpr[3]);
+		cemuLog_logDebug(LogType::Force, "IMGetAPDPeriod(0x{:08x})", hCPU->gpr[3]);
 		// parameters:
 		// r3	uint32*		returns the number of seconds until auto-shutdown occurs
 		memory_writeU32(hCPU->gpr[3], 600);
@@ -57,7 +57,7 @@ namespace coreinit
 
 	void coreinitExport_IM_GetParameter(PPCInterpreter_t* hCPU)
 	{
-		forceLogDebug_printf("IM_GetParameter()");
+		cemuLog_logDebug(LogType::Force, "IM_GetParameter()");
 
 		ppcDefineParamS32(imHandle, 0); // handle from IM_Open()
 		ppcDefineParamS32(uknR4, 1);
@@ -81,7 +81,7 @@ namespace coreinit
 
 	void coreinitExport_IM_GetRuntimeParameter(PPCInterpreter_t* hCPU)
 	{
-		forceLogDebug_printf("IM_GetRuntimeParameter()");
+		cemuLog_logDebug(LogType::Force, "IM_GetRuntimeParameter()");
 
 		ppcDefineParamS32(parameterId, 0);
 		ppcDefineParamStructPtr(output, void, 1);
@@ -134,4 +134,4 @@ namespace coreinit
 		osLib_addFunction("coreinit", "IM_GetRuntimeParameter", coreinitExport_IM_GetRuntimeParameter);
 	}
 
-};
\ No newline at end of file
+};
diff --git a/src/Cafe/OS/libs/coreinit/coreinit_IOS.cpp b/src/Cafe/OS/libs/coreinit/coreinit_IOS.cpp
index 2815bf83..737bcf7d 100644
--- a/src/Cafe/OS/libs/coreinit/coreinit_IOS.cpp
+++ b/src/Cafe/OS/libs/coreinit/coreinit_IOS.cpp
@@ -58,7 +58,7 @@ sint32 __depr__IOS_Ioctl(uint32 fd, uint32 request, void* inBuffer, uint32 inSiz
 		default:
 		{
 			// todo
-			forceLogDebug_printf("Unsupported Ioctl command");
+			cemuLog_logDebug(LogType::Force, "Unsupported Ioctl command");
 		}
 	}
 	return 0;
diff --git a/src/Cafe/OS/libs/coreinit/coreinit_IPC.cpp b/src/Cafe/OS/libs/coreinit/coreinit_IPC.cpp
index ef847f26..12d83afc 100644
--- a/src/Cafe/OS/libs/coreinit/coreinit_IPC.cpp
+++ b/src/Cafe/OS/libs/coreinit/coreinit_IPC.cpp
@@ -204,7 +204,7 @@ namespace coreinit
 		// and a message queue large enough to hold the maximum number of commands (IPC_NUM_RESOURCE_BUFFERS)
 		OSInitMessageQueue(gIPCThreadMsgQueue.GetPtr() + coreIndex, _gIPCThreadSemaphoreStorage.GetPtr() + coreIndex * IPC_NUM_RESOURCE_BUFFERS, IPC_NUM_RESOURCE_BUFFERS);
 		OSThread_t* ipcThread = gIPCThread.GetPtr() + coreIndex;
-		OSCreateThreadType(ipcThread, PPCInterpreter_makeCallableExportDepr(__IPCDriverThreadFunc), 0, nullptr, _gIPCThreadStack.GetPtr() + 0x4000 * coreIndex + 0x4000, 0x4000, 15, (1 << coreIndex), OSThread_t::THREAD_TYPE::TYPE_DRIVER);
+		__OSCreateThreadType(ipcThread, PPCInterpreter_makeCallableExportDepr(__IPCDriverThreadFunc), 0, nullptr, _gIPCThreadStack.GetPtr() + 0x4000 * coreIndex + 0x4000, 0x4000, 15, (1 << coreIndex), OSThread_t::THREAD_TYPE::TYPE_DRIVER);
 		sprintf((char*)_gIPCThreadNameStorage.GetPtr()+coreIndex*0x18, "{SYS IPC Core %d}", coreIndex);
 		OSSetThreadName(ipcThread, (char*)_gIPCThreadNameStorage.GetPtr() + coreIndex * 0x18);
 		OSResumeThread(ipcThread);
@@ -355,23 +355,6 @@ namespace coreinit
 	IOS_ERROR _IPCDriver_SetupCmd_IOSIoctlv(IPCDriver& ipcDriver, IPCResourceBufferDescriptor* requestDescriptor, uint32 requestId, uint32 numIn, uint32 numOut, IPCIoctlVector* vec)
 	{
 		IPCCommandBody& cmdBody = requestDescriptor->resourcePtr->commandBody;
-		// verify input and output vectors
-		IPCIoctlVector* vecIn = vec;
-		IPCIoctlVector* vecOut = vec + numIn;
-		for (uint32 i = 0; i < numIn; i++)
-		{
-			if (vecIn[i].baseVirt == nullptr && vecIn[i].size != 0)
-				return IOS_ERROR_INVALID_ARG;
-			vecIn[i].basePhys = vecIn[i].baseVirt;
-			vecIn[i].baseVirt = nullptr;
-		}
-		for (uint32 i = 0; i < numOut; i++)
-		{
-			if (vecOut[i].baseVirt == nullptr && vecOut[i].size != 0)
-				return IOS_ERROR_INVALID_ARG;
-			vecOut[i].basePhys = vecOut[i].baseVirt;
-			vecOut[i].baseVirt = nullptr;
-		}
 		// set args
 		cmdBody.ppcVirt0 = MEMPTR<void>(vec).GetMPTR();
 		cmdBody.args[0] = requestId;
diff --git a/src/Cafe/OS/libs/coreinit/coreinit_IPCBuf.cpp b/src/Cafe/OS/libs/coreinit/coreinit_IPCBuf.cpp
index 33f3e7c2..9345d58f 100644
--- a/src/Cafe/OS/libs/coreinit/coreinit_IPCBuf.cpp
+++ b/src/Cafe/OS/libs/coreinit/coreinit_IPCBuf.cpp
@@ -1,40 +1,9 @@
 #include "Cafe/OS/common/OSCommon.h"
 #include "Cafe/OS/libs/coreinit/coreinit_Thread.h"
+#include "coreinit_IPCBuf.h"
 
 namespace coreinit
 {
-
-	struct FIFOEntry_t
-	{
-		MEMPTR<uint8> p;
-	};
-
-	struct IPCFifo_t
-	{
-		uint32be writeIndex;
-		uint32be readIndex;
-		uint32be availableEntries; // number of available entries
-		uint32be entryCount;
-		MEMPTR<FIFOEntry_t> entryArray;
-	};
-
-	struct IPCBufPool_t
-	{
-		/* +0x00 */ uint32be		magic;
-		/* +0x04 */	MEMPTR<void>	fullBufferPtr;
-		/* +0x08 */ uint32be		fullBufferSize;
-		/* +0x0C */ uint32be		uknFromParamR7; // boolean?
-		/* +0x10 */ uint32be		ukn10; // set to zero on init
-		/* +0x14 */ uint32be		entrySize1;
-		/* +0x18 */ uint32be		entrySize2; // set to same value as entrySize1
-		/* +0x1C */ uint32be		entryCount; // actual number of used entries
-		/* +0x20 */	MEMPTR<uint8>	entryStartPtr;
-		/* +0x24 */ uint32be		entryCountMul4;
-		/* +0x28 */ IPCFifo_t		fifo;
-		/* +0x3C */ coreinit::OSMutex mutex;
-		// full size is 0x68
-	};
-
 	void FIFOInit(IPCFifo_t* fifo, uint32 entryCount, void* entryArray)
 	{
 		fifo->entryCount = entryCount;
@@ -90,8 +59,6 @@ namespace coreinit
 		return (uint8*)v;
 	}
 
-	static_assert(sizeof(IPCBufPool_t) == 0x68);
-
 	IPCBufPool_t* IPCBufPoolCreate(uint8* bufferArea, uint32 bufferSize, uint32 entrySize, uint32be* entryCountOutput, uint32 uknR7)
 	{
 		memset(bufferArea, 0, bufferSize);
diff --git a/src/Cafe/OS/libs/coreinit/coreinit_IPCBuf.h b/src/Cafe/OS/libs/coreinit/coreinit_IPCBuf.h
index 004fb178..bfb29397 100644
--- a/src/Cafe/OS/libs/coreinit/coreinit_IPCBuf.h
+++ b/src/Cafe/OS/libs/coreinit/coreinit_IPCBuf.h
@@ -2,5 +2,43 @@
 
 namespace coreinit
 {
+	struct FIFOEntry_t
+	{
+		MEMPTR<uint8> p;
+	};
+
+	struct IPCFifo_t
+	{
+		uint32be writeIndex;
+		uint32be readIndex;
+		uint32be availableEntries; // number of available entries
+		uint32be entryCount;
+		MEMPTR<FIFOEntry_t> entryArray;
+	};
+
+	struct IPCBufPool_t
+	{
+		/* +0x00 */ uint32be magic;
+		/* +0x04 */ MEMPTR<void> fullBufferPtr;
+		/* +0x08 */ uint32be fullBufferSize;
+		/* +0x0C */ uint32be uknFromParamR7; // boolean?
+		/* +0x10 */ uint32be ukn10;			 // set to zero on init
+		/* +0x14 */ uint32be entrySize1;
+		/* +0x18 */ uint32be entrySize2;	 // set to same value as entrySize1
+		/* +0x1C */ uint32be entryCount;	 // actual number of used entries
+		/* +0x20 */ MEMPTR<uint8> entryStartPtr;
+		/* +0x24 */ uint32be entryCountMul4;
+		/* +0x28 */ IPCFifo_t fifo;
+		/* +0x3C */ coreinit::OSMutex mutex;
+		/* +0x68 */ uint32 ukn68;
+		// full size is 0x6C
+	};
+
+	static_assert(sizeof(IPCBufPool_t) == 0x6C);
+
+	uint8* IPCBufPoolAllocate(IPCBufPool_t* ipcBufPool, uint32 size);
+	IPCBufPool_t* IPCBufPoolCreate(uint8* bufferArea, uint32 bufferSize, uint32 entrySize, uint32be* entryCountOutput, uint32 uknR7);
+	sint32 IPCBufPoolFree(IPCBufPool_t* ipcBufPool, uint8* entry);
+
 	void InitializeIPCBuf();
-}
+} // namespace coreinit
diff --git a/src/Cafe/OS/libs/coreinit/coreinit_Init.cpp b/src/Cafe/OS/libs/coreinit/coreinit_Init.cpp
index 9bb49741..72f6ac11 100644
--- a/src/Cafe/OS/libs/coreinit/coreinit_Init.cpp
+++ b/src/Cafe/OS/libs/coreinit/coreinit_Init.cpp
@@ -64,6 +64,24 @@ sint32 _GetArgLength(const char* arg)
 	return c;
 }
 
+static std::string GetLaunchArgs()
+{
+	std::string argStr = CafeSystem::GetForegroundTitleArgStr();
+	if(std::vector<std::string> overrideArgs; CafeSystem::GetOverrideArgStr(overrideArgs))
+	{
+		// args are overriden by launch directive (OSLaunchTitleByPath)
+		// keep the rpx path but use the arguments from the override
+		if (size_t pos = argStr.find(' '); pos != std::string::npos)
+			argStr.resize(pos);
+		for(size_t i=0; i<overrideArgs.size(); i++)
+		{
+			argStr += " ";
+			argStr += overrideArgs[i];
+		}
+	}
+	return argStr;
+}
+
 void CafeInit()
 {
 	// extract executable filename
@@ -85,7 +103,8 @@ void CafeInit()
 	_AddArg(rpxFileName.data(), rpxFileName.size());
 	strcpy((char*)_coreinitInfo->argStorage, std::string(rpxFileName).c_str());
 
-	std::string _argStr = CafeSystem::GetForegroundTitleArgStr();
+	std::string _argStr = GetLaunchArgs();
+	CafeSystem::UnsetOverrideArgs(); // make sure next launch doesn't accidentally use the same arguments
 	const char* argString = _argStr.c_str();
 	// attach parameters from arg string
 	if (argString && argString[0] != '\0')
@@ -119,14 +138,15 @@ void CafeInit()
 		}
 		else
 		{
-			forceLogDebug_printf("Unable to find end of rpx file name in arg string");
+			cemuLog_logDebug(LogType::Force, "Unable to find end of rpx file name in arg string");
 		}
 	}
 	// setup UGQR
-	ppcInterpreterCurrentInstance->spr.UGQR[0 + 2] = 0x00040004;
-	ppcInterpreterCurrentInstance->spr.UGQR[0 + 3] = 0x00050005;
-	ppcInterpreterCurrentInstance->spr.UGQR[0 + 4] = 0x00060006;
-	ppcInterpreterCurrentInstance->spr.UGQR[0 + 5] = 0x00070007;
+	PPCInterpreter_t* hCPU = PPCInterpreter_getCurrentInstance();
+	hCPU->spr.UGQR[0 + 2] = 0x00040004;
+	hCPU->spr.UGQR[0 + 3] = 0x00050005;
+	hCPU->spr.UGQR[0 + 4] = 0x00060006;
+	hCPU->spr.UGQR[0 + 5] = 0x00070007;
 	coreinit::InitForegroundBucket();
 	coreinit::InitSysHeap();
 }
diff --git a/src/Cafe/OS/libs/coreinit/coreinit_LockedCache.cpp b/src/Cafe/OS/libs/coreinit/coreinit_LockedCache.cpp
index 9ab614c3..a051fce1 100644
--- a/src/Cafe/OS/libs/coreinit/coreinit_LockedCache.cpp
+++ b/src/Cafe/OS/libs/coreinit/coreinit_LockedCache.cpp
@@ -99,8 +99,8 @@ namespace coreinit
 		if (deallocAddr < lcAddr[coreIndex] || deallocAddr >= (lcAddr[coreIndex] + LC_LOCKED_CACHE_SIZE))
 		{
 			// out of bounds
-#ifndef PUBLIC_RELEASE
-			forceLog_printf("LCDealloc(): Out of bounds");
+#ifdef CEMU_DEBUG_ASSERT
+			cemuLog_log(LogType::Force, "LCDealloc(): Out of bounds");
 #endif
 			osLib_returnFromFunction(hCPU, 0);
 			return;
@@ -198,7 +198,7 @@ namespace coreinit
 			assert_dbg();
 #endif
 		LCIsEnabled[PPCInterpreter_getCoreIndex(hCPU)]--;
-#ifndef PUBLIC_RELEASE
+#ifdef CEMU_DEBUG_ASSERT
 		if (LCIsEnabled[PPCInterpreter_getCoreIndex(hCPU)] == 0)
 		{
 			uint32 coreIndex = PPCInterpreter_getCoreIndex(hCPU);
@@ -209,7 +209,7 @@ namespace coreinit
 				{
 					if (_lcDisableErrorCounter < 15)
 					{
-						forceLog_printf("LC disabled but there is still memory allocated");
+						cemuLog_log(LogType::Force, "LC disabled but there is still memory allocated");
 						_lcDisableErrorCounter++;
 					}
 				}
diff --git a/src/Cafe/OS/libs/coreinit/coreinit_MCP.cpp b/src/Cafe/OS/libs/coreinit/coreinit_MCP.cpp
index f4080a23..330663ac 100644
--- a/src/Cafe/OS/libs/coreinit/coreinit_MCP.cpp
+++ b/src/Cafe/OS/libs/coreinit/coreinit_MCP.cpp
@@ -71,14 +71,13 @@ sint32 MCP_GetSysProdSettings(MCPHANDLE mcpHandle, SysProdSettings* sysProdSetti
 
 void coreinitExport_MCP_GetSysProdSettings(PPCInterpreter_t* hCPU)
 {
-	forceLogDebug_printf("MCP_GetSysProdSettings(0x%08x,0x%08x)", hCPU->gpr[3], hCPU->gpr[4]);
 	sint32 result = MCP_GetSysProdSettings(hCPU->gpr[3], (SysProdSettings*)memory_getPointerFromVirtualOffset(hCPU->gpr[4]));
 	osLib_returnFromFunction(hCPU, result);
 }
 
 void coreinitExport_MCP_TitleListByAppType(PPCInterpreter_t* hCPU)
 {
-	forceLogDebug_printf("MCP_TitleListByAppType(0x%08x,0x%08x,0x%08x,0x%08x,0x%08x)", hCPU->gpr[3], hCPU->gpr[4], hCPU->gpr[5], hCPU->gpr[6], hCPU->gpr[7]);
+	cemuLog_logDebug(LogType::Force, "MCP_TitleListByAppType(0x{:08x},0x{:08x},0x{:08x},0x{:08x},0x{:08x})", hCPU->gpr[3], hCPU->gpr[4], hCPU->gpr[5], hCPU->gpr[6], hCPU->gpr[7]);
 
 	ppcDefineParamU32(mcpHandle, 0);
 	ppcDefineParamU32(appType, 1);
@@ -103,13 +102,12 @@ void coreinitExport_MCP_TitleListByAppType(PPCInterpreter_t* hCPU)
 
 void coreinitExport_MCP_TitleList(PPCInterpreter_t* hCPU)
 {
-	forceLogDebug_printf("MCP_TitleList(...) unimplemented");
 	ppcDefineParamU32(mcpHandle, 0);
 	ppcDefineParamU32BEPtr(countOutput, 1);
 	ppcDefineParamStructPtr(titleList, MCPTitleInfo, 2);
 	ppcDefineParamU32(titleListBufferSize, 3);
 
-	// todo -> Other parameters
+	// todo -> Other parameters?
 
 	mcpPrepareRequest();
 	mcpRequest->requestCode = IOSU_MCP_GET_TITLE_LIST;
@@ -120,12 +118,14 @@ void coreinitExport_MCP_TitleList(PPCInterpreter_t* hCPU)
 
 	*countOutput = mcpRequest->titleListRequest.titleCount;
 
+	cemuLog_logDebug(LogType::Force, "MCP_TitleList(...) returned {} titles", (uint32)mcpRequest->titleListRequest.titleCount);
+
 	osLib_returnFromFunction(hCPU, mcpRequest->returnCode);
 }
 
 void coreinitExport_MCP_TitleCount(PPCInterpreter_t* hCPU)
 {
-	forceLogDebug_printf("MCP_TitleCount(): Untested");
+	cemuLog_logDebug(LogType::Force, "MCP_TitleCount(): Untested");
 	ppcDefineParamU32(mcpHandle, 0);
 
 	mcpPrepareRequest();
@@ -142,7 +142,7 @@ void coreinitExport_MCP_GetTitleInfo(PPCInterpreter_t* hCPU)
 	ppcDefineParamU64(titleId, 2);
 	ppcDefineParamStructPtr(titleList, MCPTitleInfo, 4);
 
-	forceLogDebug_printf("MCP_GetTitleInfo() called");
+	cemuLog_logDebug(LogType::Force, "MCP_GetTitleInfo() called");
 
 	mcpPrepareRequest();
 	mcpRequest->requestCode = IOSU_MCP_GET_TITLE_INFO;
@@ -154,7 +154,7 @@ void coreinitExport_MCP_GetTitleInfo(PPCInterpreter_t* hCPU)
 
 	if (mcpRequest->titleListRequest.titleCount == 0)
 	{
-		forceLog_printf("MCP_GetTitleInfo() failed to get title info");
+		cemuLog_log(LogType::Force, "MCP_GetTitleInfo() failed to get title info");
 	}
 
 	osLib_returnFromFunction(hCPU, mcpRequest->returnCode);
@@ -168,7 +168,7 @@ void coreinitExport_MCP_GetTitleInfoByTitleAndDevice(PPCInterpreter_t* hCPU)
 	ppcDefineParamStr(device, 4); // e.g. "odd"
 	ppcDefineParamStructPtr(titleList, MCPTitleInfo, 5);
 
-	forceLogDebug_printf("MCP_GetTitleInfoByTitleAndDevice() called (todo - device type support)");
+	cemuLog_logDebug(LogType::Force, "MCP_GetTitleInfoByTitleAndDevice() called (todo - device type support)");
 
 	mcpPrepareRequest();
 	mcpRequest->requestCode = IOSU_MCP_GET_TITLE_INFO;
@@ -180,13 +180,12 @@ void coreinitExport_MCP_GetTitleInfoByTitleAndDevice(PPCInterpreter_t* hCPU)
 
 	if (mcpRequest->titleListRequest.titleCount == 0)
 	{
-		forceLogDebug_printf("MCP_GetTitleInfoByTitleAndDevice() no title found");
+		cemuLog_logDebug(LogType::Force, "MCP_GetTitleInfoByTitleAndDevice() no title found");
 		osLib_returnFromFunction(hCPU, BUILD_NN_RESULT(NN_RESULT_LEVEL_STATUS, NN_RESULT_MODULE_MCP, 0)); // E-Shop/nn_vctl.rpl expects error to be returned when no title is found
 		return;
 	}
 
 	osLib_returnFromFunction(hCPU, mcpRequest->returnCode);
-
 }
 
 namespace coreinit
@@ -194,13 +193,13 @@ namespace coreinit
 
 	void export_MCP_GetSystemVersion(PPCInterpreter_t* hCPU)
 	{
-		forceLogDebug_printf("MCP_GetSystemVersion(%d,0x%08x)", hCPU->gpr[3], hCPU->gpr[4]);
+		cemuLog_logDebug(LogType::Force, "MCP_GetSystemVersion({},0x{:08x})", hCPU->gpr[3], hCPU->gpr[4]);
 		ppcDefineParamU32(mcpHandle, 0);
 		ppcDefineParamStructPtr(systemVersion, mcpSystemVersion_t, 1);
 
 		systemVersion->n0 = 0x5;
 		systemVersion->n1 = 0x5;
-		systemVersion->n2 = 0x2;
+		systemVersion->n2 = 0x5;
 		// todo: Load this from \sys\title\00050010\10041200\content\version.bin
 
 		osLib_returnFromFunction(hCPU, 0);
@@ -209,7 +208,7 @@ namespace coreinit
 	void export_MCP_Get4SecondOffStatus(PPCInterpreter_t* hCPU)
 	{
 		// r3 = mcpHandle
-		forceLogDebug_printf("MCP_Get4SecondOffStatus(...) placeholder");
+		cemuLog_logDebug(LogType::Force, "MCP_Get4SecondOffStatus(...) placeholder");
 		// if this returns 1 then Barista will display the warning about cold-shutdown ('Holding the POWER button for at least four seconds...')
 		osLib_returnFromFunction(hCPU, 0);
 	}
@@ -230,63 +229,62 @@ namespace coreinit
 
 		*titleCount = 1;
 
-		forceLogDebug_printf("MCP_TitleListByDevice() - placeholder");
+		cemuLog_logDebug(LogType::Force, "MCP_TitleListByDevice() - placeholder");
 
 		osLib_returnFromFunction(hCPU, 0);
 	}
 
 #pragma pack(1)
-	typedef struct
+	struct MCPDevice_t
 	{
-		/* +0x000 */ char storageName[0x90]; // the name in the storage path
+		/* +0x000 */ char storageName[0x8]; // the name in the storage path (mlc, slc, usb?) // volumeId at +8
+		/* +0x008 */ char volumeId[16]; //
+		/* +0x018 */ char ukn[0x90 - 0x18];
 		/* +0x090 */ char storagePath[0x280 - 1]; // /vol/storage_%s%02x
-		/* +0x30F */ uint32be storageSubindexOrMask; // the id in the storage path, but this might also be a MASK of indices (e.g. 1 -> Only device 1, 7 -> Device 1,2,3) men.rpx expects 0xF (or 0x7?) to be set for MLC, SLC and USB for MLC_FullDeviceList
+		/* +0x30F */ uint32be flags; // men.rpx checks for 0x2 and 0x8
 		uint8 ukn313[4];
 		uint8 ukn317[4];
-	}MCPDevice_t;
+	};
 #pragma pack()
 
-	static_assert(sizeof(MCPDevice_t) == 0x31B, "MCPDevice_t has invalid size");
-	static_assert(offsetof(MCPDevice_t, storagePath) == 0x090, "MCPDevice_t.storagePath has invalid offset");
-	static_assert(offsetof(MCPDevice_t, storageSubindexOrMask) == 0x30F, "MCPDevice_t.storageSubindex has invalid offset");
-	static_assert(offsetof(MCPDevice_t, ukn313) == 0x313, "MCPDevice_t.ukn313 has invalid offset");
-	static_assert(offsetof(MCPDevice_t, ukn317) == 0x317, "MCPDevice_t.ukn317 has invalid offset");
+	static_assert(sizeof(MCPDevice_t) == 0x31B);
+
+	static_assert(sizeof(MCPDevice_t) == 0x31B);
+	static_assert(offsetof(MCPDevice_t, storagePath) == 0x90);
+	static_assert(offsetof(MCPDevice_t, flags) == 0x30F);
+	static_assert(offsetof(MCPDevice_t, ukn313) == 0x313);
+	static_assert(offsetof(MCPDevice_t, ukn317) == 0x317);
 
 	void MCP_DeviceListEx(uint32 mcpHandle, uint32be* deviceCount, MCPDevice_t* deviceList, uint32 deviceListSize, bool returnFullList)
 	{
 		sint32 maxDeviceCount = deviceListSize / sizeof(MCPDevice_t);
 
-		if (maxDeviceCount < 3*3)
-			assert_dbg();
+		cemu_assert(maxDeviceCount >= 2);
 
-		// if this doesnt return both MLC and SLC friendlist (frd.rpx) will softlock during boot
-
-		memset(deviceList, 0, sizeof(MCPDevice_t) * 1);
+		memset(deviceList, 0, deviceListSize);
 		sint32 index = 0;
-		for (sint32 f = 0; f < 1; f++)
-		{
-			// 0
-			strcpy(deviceList[index].storageName, "mlc");
-			deviceList[index].storageSubindexOrMask = 0xF; // bitmask?
-			sprintf(deviceList[index].storagePath, "/vol/storage_%s%02x", deviceList[index].storageName, (sint32)deviceList[index].storageSubindexOrMask);
-			index++;
-			// 1
-			strcpy(deviceList[index].storageName, "slc");
-			deviceList[index].storageSubindexOrMask = 0xF; // bitmask?
-			sprintf(deviceList[index].storagePath, "/vol/storage_%s%02x", deviceList[index].storageName, (sint32)deviceList[index].storageSubindexOrMask);
-			index++;
-			// 2
-			strcpy(deviceList[index].storageName, "usb");
-			deviceList[index].storageSubindexOrMask = 0xF;
-			sprintf(deviceList[index].storagePath, "/vol/storage_%s%02x", deviceList[index].storageName, (sint32)deviceList[index].storageSubindexOrMask);
-			index++;
-		}
 
+		uint32 flags = 2 | 8;
+		// flag 2 is necessary for Wii U menu and Friend List to load
+		// if we dont set flag 0x8 then Wii U menu will show a disk loading icon and screen
+		// slc
+		strcpy(deviceList[index].storageName, "slc");
+		strcpy(deviceList[index].volumeId, "VOLID_SLC");
+		deviceList[index].flags = flags;
+		strcpy(deviceList[index].storagePath, "/vol/system_slc"); // unsure
+		index++;
+		// mlc
+		strcpy(deviceList[index].storageName, "mlc");
+		strcpy(deviceList[index].volumeId, "VOLID_MLC");
+		deviceList[index].flags = flags;
+		sprintf(deviceList[index].storagePath, "/vol/storage_mlc01");
+		index++;
+
+		// we currently dont emulate USB storage
 
 		*deviceCount = index;
 	}
 
-
 	void export_MCP_DeviceList(PPCInterpreter_t* hCPU)
 	{
 		ppcDefineParamU32(mcpHandle, 0);
@@ -294,7 +292,7 @@ namespace coreinit
 		ppcDefineParamStructPtr(deviceList, MCPDevice_t, 2);
 		ppcDefineParamU32(deviceListSize, 3);
 
-		forceLogDebug_printf("MCP_DeviceList() - placeholder LR %08x", hCPU->spr.LR);
+		cemuLog_logDebug(LogType::Force, "MCP_DeviceList()");
 
 		sint32 maxDeviceCount = deviceListSize / sizeof(MCPDevice_t);
 
@@ -306,12 +304,12 @@ namespace coreinit
 		memset(deviceList, 0, sizeof(MCPDevice_t) * 1);
 		// 0
 		strcpy(deviceList[0].storageName, "mlc");
-		deviceList[0].storageSubindexOrMask = (0x01); // bitmask?
-		sprintf(deviceList[0].storagePath, "/vol/storage_%s%02x", deviceList[0].storageName, (sint32)deviceList[0].storageSubindexOrMask);
+		deviceList[0].flags = (0x01); // bitmask?
+		sprintf(deviceList[0].storagePath, "/vol/storage_%s%02x", deviceList[0].storageName, (sint32)deviceList[0].flags);
 		// 1
 		strcpy(deviceList[1].storageName, "slc");
-		deviceList[1].storageSubindexOrMask = (0x01); // bitmask?
-		sprintf(deviceList[1].storagePath, "/vol/storage_%s%02x", deviceList[1].storageName, (sint32)deviceList[1].storageSubindexOrMask);
+		deviceList[1].flags = (0x01); // bitmask?
+		sprintf(deviceList[1].storagePath, "/vol/storage_%s%02x", deviceList[1].storageName, (sint32)deviceList[1].flags);
 
 		// 2
 		//strcpy(deviceList[2].storageName, "usb");
@@ -331,7 +329,7 @@ namespace coreinit
 		ppcDefineParamStructPtr(deviceList, MCPDevice_t, 2);
 		ppcDefineParamU32(deviceListSize, 3);
 
-		forceLogDebug_printf("MCP_FullDeviceList() - placeholder LR %08x", hCPU->spr.LR);
+		cemuLog_logDebug(LogType::Force, "MCP_FullDeviceList()");
 
 		MCP_DeviceListEx(mcpHandle, deviceCount, deviceList, deviceListSize, true);
 
@@ -343,7 +341,7 @@ namespace coreinit
 		ppcDefineParamU32(mcpHandle, 0);
 		ppcDefineParamU32BEPtr(unknownParam, 1);
 
-		forceLogDebug_printf("MCP_UpdateCheckContext() - placeholder (might be wrong)");
+		cemuLog_logDebug(LogType::Force, "MCP_UpdateCheckContext() - placeholder (might be wrong)");
 
 		*unknownParam = 1;
 
@@ -356,16 +354,18 @@ namespace coreinit
 		ppcDefineParamU32(mcpHandle, 0);
 		ppcDefineParamMPTR(callbackMPTR, 1);
 
-		forceLogDebug_printf("MCP_TitleListUpdateGetNext() - placeholder/unimplemented");
+		cemuLog_logDebug(LogType::Force, "MCP_TitleListUpdateGetNext() - placeholder/unimplemented");
 
 		// this callback is to let the app know when the title list changed?
 
+		//PPCCoreCallback(callbackMPTR); // -> If we trigger the callback then the menu will repeat with a call to MCP_GetTitleList(), MCP_DeviceList() and MCP_TitleListUpdateGetNext
+
 		osLib_returnFromFunction(hCPU, 0);
 	}
 
 	void export_MCP_GetOverlayAppInfo(PPCInterpreter_t* hCPU)
 	{
-		forceLogDebug_printf("MCP_GetOverlayAppInfo(...) placeholder");
+		cemuLog_logDebug(LogType::Force, "MCP_GetOverlayAppInfo(...) placeholder");
 		ppcDefineParamU32(mcpHandle, 0);
 		ppcDefineParamU32(appType, 1);
 		ppcDefineParamU32(uknR5, 2);
@@ -387,6 +387,40 @@ namespace coreinit
 		osLib_returnFromFunction(hCPU, 0);
 	}
 
+	uint32 MCP_UpdateClearContextAsync(uint32 mcpHandle, betype<MPTR>* callbackPtr)
+	{
+		cemuLog_logDebug(LogType::Force, "MCP_UpdateClearContextAsync() - stubbed");
+		uint32 clearContextResult = 0;
+		PPCCoreCallback(*callbackPtr, clearContextResult);
+		return 0;
+	}
+
+	uint32 MCP_InstallUtilGetTitleEnability(uint32 mcpHandle, uint32be* enabilityOutput, MCPTitleInfo* title)
+	{
+		*enabilityOutput = 1;
+		return 0;
+	}
+
+	uint32 MCP_GetEcoSettings(uint32 mcpHandle, uint32be* flagCaffeineEnable, uint32be* uknFlag2, uint32be* uknFlag3)
+	{
+		*flagCaffeineEnable = 1; // returning 1 here will stop the Wii U Menu from showing the Quick Start setup dialogue
+		*uknFlag2 = 0;
+		*uknFlag3 = 0;
+		return 0;
+	}
+
+	uint32 MCP_RightCheckLaunchable(uint32 mcpHandle, uint64 titleId, uint32be* launchableOut)
+	{
+		*launchableOut = 1;
+		return 0;
+	}
+
+	uint32 MCP_GetTitleId(uint32 mcpHandle, uint64be* outTitleId)
+	{
+		*outTitleId = CafeSystem::GetForegroundTitleId();
+		return 0;
+	}
+
 	void InitializeMCP()
 	{
 		osLib_addFunction("coreinit", "MCP_Open", coreinitExport_MCP_Open);
@@ -408,6 +442,14 @@ namespace coreinit
 		osLib_addFunction("coreinit", "MCP_UpdateCheckContext", export_MCP_UpdateCheckContext);
 		osLib_addFunction("coreinit", "MCP_TitleListUpdateGetNext", export_MCP_TitleListUpdateGetNext);
 		osLib_addFunction("coreinit", "MCP_GetOverlayAppInfo", export_MCP_GetOverlayAppInfo);
+		cafeExportRegister("coreinit", MCP_UpdateClearContextAsync, LogType::Placeholder);
+
+		cafeExportRegister("coreinit", MCP_InstallUtilGetTitleEnability, LogType::Placeholder);
+		cafeExportRegister("coreinit", MCP_RightCheckLaunchable, LogType::Placeholder);
+
+		cafeExportRegister("coreinit", MCP_GetEcoSettings, LogType::Placeholder);
+
+		cafeExportRegister("coreinit", MCP_GetTitleId, LogType::Placeholder);
 	}
 
 }
@@ -511,6 +553,7 @@ void coreinitExport_UCReadSysConfig(PPCInterpreter_t* hCPU)
 		{
 			// get parental online control for online features
 			// note: This option is account-bound, the p_acct1 prefix indicates that the account in slot 1 is used
+			// a non-zero value means network access is restricted through parental access. 0 means allowed
 			// account in slot 1
 			if (ucParam->resultPtr != _swapEndianU32(MPTR_NULL))
 				memory_writeU8(_swapEndianU32(ucParam->resultPtr), 0); // data type is guessed
@@ -526,7 +569,7 @@ void coreinitExport_UCReadSysConfig(PPCInterpreter_t* hCPU)
 		{
 			// miiverse restrictions
 			if (ucParam->resultPtr != _swapEndianU32(MPTR_NULL))
-				memory_writeU8(_swapEndianU32(ucParam->resultPtr), 0); // data type is guessed (0 -> no restrictions, 1 -> read only?, 2 -> no access?)
+				memory_writeU8(_swapEndianU32(ucParam->resultPtr), 0); // data type is guessed (0 -> no restrictions, 1 -> read only, 2 -> no access)
 		}
 		else if (_strcmpi(ucParam->settingName, "s_acct01.uuid") == 0)
 		{
@@ -552,10 +595,31 @@ void coreinitExport_UCReadSysConfig(PPCInterpreter_t* hCPU)
 			if (ucParam->resultPtr != _swapEndianU32(MPTR_NULL))
 				memory_writeU8(_swapEndianU32(ucParam->resultPtr), 0);
 		}
+		/* caffeine settings (Quick Start) */
+		else if (_strcmpi(ucParam->settingName, "caffeine.enable") == 0)
+		{
+			if (ucParam->resultPtr != _swapEndianU32(MPTR_NULL))
+				memory_writeU8(_swapEndianU32(ucParam->resultPtr), 1);
+		}
+		else if (_strcmpi(ucParam->settingName, "caffeine.ad_enable") == 0)
+		{
+			if (ucParam->resultPtr != _swapEndianU32(MPTR_NULL))
+				memory_writeU8(_swapEndianU32(ucParam->resultPtr), 0);
+		}
+		else if (_strcmpi(ucParam->settingName, "caffeine.push_enable") == 0)
+		{
+			if (ucParam->resultPtr != _swapEndianU32(MPTR_NULL))
+				memory_writeU8(_swapEndianU32(ucParam->resultPtr), 0);
+		}
+		else if (_strcmpi(ucParam->settingName, "caffeine.drcled_enable") == 0)
+		{
+			if (ucParam->resultPtr != _swapEndianU32(MPTR_NULL))
+				memory_writeU8(_swapEndianU32(ucParam->resultPtr), 0);
+		}
 		else
 		{
-			forceLogDebug_printf("Unsupported SCI value: %s Size %08x\n", ucParam->settingName, ucParam->ukn4_size);
+			cemuLog_logDebug(LogType::Force, "Unsupported SCI value: {} Size {:08x}", ucParam->settingName, ucParam->ukn4_size);
 		}
 	}
 	osLib_returnFromFunction(hCPU, 0); // 0 -> success
-}
\ No newline at end of file
+}
diff --git a/src/Cafe/OS/libs/coreinit/coreinit_MEM.cpp b/src/Cafe/OS/libs/coreinit/coreinit_MEM.cpp
index a9f9f3a8..83658f3c 100644
--- a/src/Cafe/OS/libs/coreinit/coreinit_MEM.cpp
+++ b/src/Cafe/OS/libs/coreinit/coreinit_MEM.cpp
@@ -23,7 +23,7 @@ MPTR coreinit_allocFromSysArea(uint32 size, uint32 alignment)
 	sysAreaAllocatorOffset += (size+3)&~3;
 	if( sysAreaAllocatorOffset >= mmuRange_CEMU_AREA.getSize() )
 	{
-		forceLog_printf("Ran out of system memory");
+		cemuLog_log(LogType::Force, "Ran out of system memory");
 		cemu_assert(false); // out of bounds
 	}
 	s_allocator_mutex.unlock();
@@ -50,7 +50,7 @@ namespace coreinit
 	MEMList g_list3;
 
 	std::array<uint32, 3> gHeapFillValues{ 0xC3C3C3C3, 0xF3F3F3F3, 0xD3D3D3D3 };
-	OSSpinLock gHeapGlobalLock;
+	SysAllocator<OSSpinLock> gHeapGlobalLock;
 	MEMHeapBase* gDefaultHeap;
 
 	bool MEMHeapTable_Add(MEMHeapBase* heap)
@@ -128,7 +128,7 @@ namespace coreinit
 	{
 		MEMPTR<void> memBound;
 		uint32be memBoundSize;
-		OSGetMemBound(1, (MPTR*)memBound.GetBEPtr(), (uint32*)&memBoundSize);
+		OSGetMemBound(1, &memBound, &memBoundSize);
 
 		MEMPTR<void> bucket;
 		uint32be bucketSize;
@@ -257,7 +257,7 @@ namespace coreinit
 	{
 		MEMPTR<void> memBound;
 		uint32be memBoundSize;
-		OSGetMemBound(1, (MPTR*)memBound.GetBEPtr(), (uint32*)&memBoundSize);
+		OSGetMemBound(1, &memBound, &memBoundSize);
 
 		MEMPTR<void> bucket;
 		uint32be bucketSize;
@@ -464,7 +464,7 @@ namespace coreinit
 	void* default_MEMAllocFromDefaultHeap(uint32 size)
 	{
 		void* mem = MEMAllocFromExpHeapEx(gDefaultHeap, size, 0x40);
-		coreinitMemLog_printf("MEMAllocFromDefaultHeap(0x%08x) Result: 0x%08x", size, memory_getVirtualOffsetFromPointer(mem));
+		cemuLog_logDebug(LogType::CoreinitMem, "MEMAllocFromDefaultHeap(0x{:08x}) Result: 0x{:08x}", size, memory_getVirtualOffsetFromPointer(mem));
 		return mem;
 	}
 
@@ -478,7 +478,7 @@ namespace coreinit
 	void* default_MEMAllocFromDefaultHeapEx(uint32 size, sint32 alignment)
 	{
 		void* mem = MEMAllocFromExpHeapEx(gDefaultHeap, size, alignment);
-		coreinitMemLog_printf("MEMAllocFromDefaultHeap(0x%08x,%d) Result: 0x%08x", size, alignment, memory_getVirtualOffsetFromPointer(mem));
+		cemuLog_logDebug(LogType::CoreinitMem, "MEMAllocFromDefaultHeap(0x{:08x},{}) Result: 0x{:08x}", size, alignment, memory_getVirtualOffsetFromPointer(mem));
 		return mem;
 	}
 
@@ -593,16 +593,16 @@ namespace coreinit
 		{
 			MEMPTR<void> memBound;
 			uint32be memBoundSize;
-			OSGetMemBound(1, (MPTR*)memBound.GetBEPtr(), (uint32*)&memBoundSize);
+			OSGetMemBound(1, &memBound, &memBoundSize);
 			mem1Heap = MEMCreateFrmHeapEx(memBound.GetPtr(), (uint32)memBoundSize, 0);
 
-			OSGetForegroundBucketFreeArea((MPTR*)memBound.GetBEPtr(), (MPTR*)&memBoundSize);
+			OSGetForegroundBucketFreeArea(&memBound, &memBoundSize);
 			memFGHeap = MEMCreateFrmHeapEx(memBound.GetPtr(), (uint32)memBoundSize, 0);
 		}
 
 		MEMPTR<void> memBound;
 		uint32be memBoundSize;
-		OSGetMemBound(2, (MPTR*)memBound.GetBEPtr(), (uint32*)&memBoundSize);
+		OSGetMemBound(2, &memBound, &memBoundSize);
 		mem2Heap = MEMDefaultHeap_Init(memBound.GetPtr(), (uint32)memBoundSize);
 
 		// set DynLoad allocators
@@ -615,10 +615,24 @@ namespace coreinit
 		cemu_assert_unimplemented();
 	}
 
+    void MEMResetToDefaultState()
+    {
+        for (auto& it : sHeapBaseHandle)
+            it = nullptr;
+
+        g_heapTableCount = 0;
+        g_slockInitialized = false;
+        g_listsInitialized = false;
+        gDefaultHeap = nullptr;
+
+        memset(&g_list1, 0, sizeof(g_list1));
+        memset(&g_list2, 0, sizeof(g_list2));
+        memset(&g_list3, 0, sizeof(g_list3));
+    }
+
 	void InitializeMEM()
 	{
-		for (auto& it : sHeapBaseHandle)
-			it = nullptr;
+        MEMResetToDefaultState();
 
 		cafeExportRegister("coreinit", CoreInitDefaultHeap, LogType::CoreinitMem);
 
@@ -645,4 +659,4 @@ namespace coreinit
 		cafeExportRegister("coreinit", MEMGetPrevListObject, LogType::CoreinitMem);
 	}
 
-}
\ No newline at end of file
+}
diff --git a/src/Cafe/OS/libs/coreinit/coreinit_MEM_BlockHeap.cpp b/src/Cafe/OS/libs/coreinit/coreinit_MEM_BlockHeap.cpp
index 33767ddf..06d76e43 100644
--- a/src/Cafe/OS/libs/coreinit/coreinit_MEM_BlockHeap.cpp
+++ b/src/Cafe/OS/libs/coreinit/coreinit_MEM_BlockHeap.cpp
@@ -236,7 +236,7 @@ namespace coreinit
 		blockHeapHead->nextFreeBlock = _swapEndianU32(nextFreeBlockMPTR);
 		if (_swapEndianU32(blockHeapHead->freeBlocksLeft) == 0)
 		{
-			forceLog_printf("BlockHeap: No free blocks left\n");
+			cemuLog_log(LogType::Force, "BlockHeap: No free blocks left");
 			assert_dbg();
 		}
 		blockHeapHead->freeBlocksLeft = _swapEndianU32(_swapEndianU32(blockHeapHead->freeBlocksLeft) - 1);
@@ -462,7 +462,7 @@ namespace coreinit
 		if (block != NULL)
 		{
 			MPTR blockMPTR = memory_getVirtualOffsetFromPointer(block);
-#ifndef PUBLIC_RELEASE
+#ifdef CEMU_DEBUG_ASSERT
 			if (block->isFree != 0)
 				assert_dbg();
 			_blockHeapDebugVerifyLinkOrder(blockHeapHead);
diff --git a/src/Cafe/OS/libs/coreinit/coreinit_MEM_ExpHeap.cpp b/src/Cafe/OS/libs/coreinit/coreinit_MEM_ExpHeap.cpp
index c587b879..552a610f 100644
--- a/src/Cafe/OS/libs/coreinit/coreinit_MEM_ExpHeap.cpp
+++ b/src/Cafe/OS/libs/coreinit/coreinit_MEM_ExpHeap.cpp
@@ -2,8 +2,6 @@
 #include "Cafe/HW/Espresso/PPCCallback.h"
 #include "Cafe/OS/libs/coreinit/coreinit_MEM_ExpHeap.h"
 
-void DebugLogStackTrace(OSThread_t* thread, MPTR sp);
-
 #define EXP_HEAP_GET_FROM_FREE_BLOCKCHAIN(__blockchain__) (MEMExpHeapHead2*)((uintptr_t)__blockchain__ - offsetof(MEMExpHeapHead2, expHeapHead) - offsetof(MEMExpHeapHead40_t, chainFreeBlocks))
 
 namespace coreinit
@@ -452,7 +450,7 @@ void* MEMAllocFromExpHeapEx(MEMHeapHandle heap, uint32 size, sint32 alignment)
 	if (alignment == 0)
 	{
 		// this is a guaranteed crash on the actual console
-		forceLog_printf("MEMAllocFromExpHeapEx(): Alignment 0 not allowed");
+		cemuLog_log(LogType::Force, "MEMAllocFromExpHeapEx(): Alignment 0 not allowed");
 		alignment = 4;
 		return nullptr;
 	}
@@ -850,14 +848,14 @@ void export_MEMCreateExpHeapEx(PPCInterpreter_t* hCPU)
 	ppcDefineParamU32(size, 1);
 	ppcDefineParamU16(options, 2);
 	MEMPTR<MEMHeapBase> heap = MEMCreateExpHeapEx(startAddress.GetPtr(), size, options);
-	coreinitMemLog_printf("MEMCreateExpHeapEx(0x%08x, 0x%x, 0x%x) Result: 0x%08x", startAddress.GetMPTR(), size, options, heap.GetMPTR());
+	cemuLog_logDebug(LogType::CoreinitMem, "MEMCreateExpHeapEx(0x{:08x}, 0x{:x}, 0x{:x}) Result: 0x{:08x}", startAddress.GetMPTR(), size, options, heap.GetMPTR());
 	osLib_returnFromFunction(hCPU, heap.GetMPTR());
 }
 
 void export_MEMDestroyExpHeap(PPCInterpreter_t* hCPU)
 {
 	ppcDefineParamMEMPTR(heap, MEMHeapBase, 0);
-	coreinitMemLog_printf("MEMDestroyExpHeap(0x%08x)", heap.GetMPTR());
+	cemuLog_logDebug(LogType::CoreinitMem, "MEMDestroyExpHeap(0x{:08x})", heap.GetMPTR());
 	MEMPTR<MEMHeapBase> oldHeap = (MEMHeapBase*)MEMDestroyExpHeap(heap.GetPtr());
 	osLib_returnFromFunction(hCPU, oldHeap.GetMPTR());
 }
@@ -868,7 +866,7 @@ void export_MEMAllocFromExpHeapEx(PPCInterpreter_t* hCPU)
 	ppcDefineParamU32(size, 1);
 	ppcDefineParamS32(alignment, 2);
 	MEMPTR<void> mem = MEMAllocFromExpHeapEx(heap.GetPtr(), size, alignment);
-	coreinitMemLog_printf("MEMAllocFromExpHeapEx(0x%08x, 0x%x, %d) Result: 0x%08x", heap.GetMPTR(), size, alignment, mem.GetMPTR());
+	cemuLog_logDebug(LogType::CoreinitMem, "MEMAllocFromExpHeapEx(0x{:08x}, 0x{:x}, {}) Result: 0x{:08x}", heap.GetMPTR(), size, alignment, mem.GetMPTR());
 	osLib_returnFromFunction(hCPU, mem.GetMPTR());
 }
 
@@ -876,7 +874,7 @@ void export_MEMFreeToExpHeap(PPCInterpreter_t* hCPU)
 {
 	ppcDefineParamMEMPTR(heap, MEMHeapBase, 0);
 	ppcDefineParamMEMPTR(mem, void, 1);
-	coreinitMemLog_printf("MEMFreeToExpHeap(0x%08x, 0x%08x)", heap.GetMPTR(), mem.GetMPTR());
+	cemuLog_logDebug(LogType::CoreinitMem, "MEMFreeToExpHeap(0x{:08x}, 0x{:08x})", heap.GetMPTR(), mem.GetMPTR());
 	MEMFreeToExpHeap(heap.GetPtr(), mem.GetPtr());
 	osLib_returnFromFunction(hCPU, 0);
 }
@@ -885,7 +883,7 @@ void export_MEMSetAllocModeForExpHeap(PPCInterpreter_t* hCPU)
 {
 	ppcDefineParamMEMPTR(heap, MEMHeapBase, 0);
 	ppcDefineParamU16(mode, 1);
-	coreinitMemLog_printf("MEMSetAllocModeForExpHeap(0x%08x, %d)", heap.GetMPTR(), mode);
+	cemuLog_logDebug(LogType::CoreinitMem, "MEMSetAllocModeForExpHeap(0x{:08x}, {})", heap.GetMPTR(), mode);
 	uint16 oldMode = MEMSetAllocModeForExpHeap(heap.GetPtr(), mode);
 	osLib_returnFromFunction(hCPU, oldMode);
 }
@@ -893,7 +891,7 @@ void export_MEMSetAllocModeForExpHeap(PPCInterpreter_t* hCPU)
 void export_MEMGetAllocModeForExpHeap(PPCInterpreter_t* hCPU)
 {
 	ppcDefineParamMEMPTR(heap, MEMHeapBase, 0);
-	coreinitMemLog_printf("MEMGetAllocModeForExpHeap(0x%08x)", heap.GetMPTR());
+	cemuLog_logDebug(LogType::CoreinitMem, "MEMGetAllocModeForExpHeap(0x{:08x})", heap.GetMPTR());
 	uint16 oldMode = MEMGetAllocModeForExpHeap(heap.GetPtr());
 	osLib_returnFromFunction(hCPU, oldMode);
 }
@@ -901,7 +899,7 @@ void export_MEMGetAllocModeForExpHeap(PPCInterpreter_t* hCPU)
 void export_MEMAdjustExpHeap(PPCInterpreter_t* hCPU)
 {
 	ppcDefineParamMEMPTR(heap, MEMHeapBase, 0);
-	coreinitMemLog_printf("MEMAdjustExpHeap(0x%08x)", heap.GetMPTR());
+	cemuLog_logDebug(LogType::CoreinitMem, "MEMAdjustExpHeap(0x{:08x})", heap.GetMPTR());
 	uint32 newSize = MEMAdjustExpHeap(heap.GetPtr());
 	osLib_returnFromFunction(hCPU, newSize);
 }
@@ -912,7 +910,7 @@ void export_MEMResizeForMBlockExpHeap(PPCInterpreter_t* hCPU)
 	ppcDefineParamMEMPTR(mem, void, 1);
 	ppcDefineParamU32(size, 2);
 	uint32 newSize = MEMResizeForMBlockExpHeap(heap.GetPtr(), mem.GetPtr(), size);
-	coreinitMemLog_printf("MEMResizeForMBlockExpHeap(0x%08x, 0x%08x, 0x%x) Result: 0x%x", heap.GetMPTR(), mem.GetMPTR(), size, newSize);
+	cemuLog_logDebug(LogType::CoreinitMem, "MEMResizeForMBlockExpHeap(0x{:08x}, 0x{:08x}, 0x{:x}) Result: 0x{:x}", heap.GetMPTR(), mem.GetMPTR(), size, newSize);
 	osLib_returnFromFunction(hCPU, newSize);
 }
 
@@ -920,7 +918,7 @@ void export_MEMGetTotalFreeSizeForExpHeap(PPCInterpreter_t* hCPU)
 {
 	ppcDefineParamMEMPTR(heap, MEMHeapBase, 0);
 	uint32 size = MEMGetTotalFreeSizeForExpHeap(heap.GetPtr());
-	coreinitMemLog_printf("MEMGetTotalFreeSizeForExpHeap(0x%08x) Result: 0x%x", heap.GetMPTR(), size);
+	cemuLog_logDebug(LogType::CoreinitMem, "MEMGetTotalFreeSizeForExpHeap(0x{:08x}) Result: 0x{:x}", heap.GetMPTR(), size);
 	osLib_returnFromFunction(hCPU, size);
 }
 
@@ -929,7 +927,7 @@ void export_MEMGetAllocatableSizeForExpHeapEx(PPCInterpreter_t* hCPU)
 	ppcDefineParamMEMPTR(heap, MEMHeapBase, 0);
 	ppcDefineParamS32(alignment, 1);
 	uint32 size = MEMGetAllocatableSizeForExpHeapEx(heap.GetPtr(), alignment);
-	coreinitMemLog_printf("MEMGetAllocatableSizeForExpHeapEx(0x%08x, 0x%x) Result: 0x%x", heap.GetMPTR(), alignment, size);
+	cemuLog_logDebug(LogType::CoreinitMem, "MEMGetAllocatableSizeForExpHeapEx(0x{:08x}, 0x{:x}) Result: 0x{:x}", heap.GetMPTR(), alignment, size);
 	osLib_returnFromFunction(hCPU, size);
 }
 
@@ -937,8 +935,8 @@ void export_MEMSetGroupIDForExpHeap(PPCInterpreter_t* hCPU)
 {
 	ppcDefineParamMEMPTR(heap, MEMHeapBase, 0);
 	ppcDefineParamU16(groupId, 1);
-	coreinitMemLog_printf("MEMSetGroupIDForExpHeap(0x%08x, %d)", heap.GetMPTR(), groupId);
-#ifndef PUBLIC_RELEASE
+	cemuLog_logDebug(LogType::CoreinitMem, "MEMSetGroupIDForExpHeap(0x{:08x}, {})", heap.GetMPTR(), groupId);
+#ifdef CEMU_DEBUG_ASSERT
 	assert_dbg(); // someone test this and the entire groupId feature
 #endif
 	uint16 oldGroupId = MEMSetGroupIDForExpHeap(heap.GetPtr(), groupId);
@@ -948,7 +946,7 @@ void export_MEMSetGroupIDForExpHeap(PPCInterpreter_t* hCPU)
 void export_MEMGetGroupIDForExpHeap(PPCInterpreter_t* hCPU)
 {
 	ppcDefineParamMEMPTR(heap, MEMHeapBase, 0);
-	forceLogDebug_printf("MEMGetGroupIDForExpHeap(0x%08x)", heap.GetMPTR());
+	cemuLog_logDebug(LogType::Force, "MEMGetGroupIDForExpHeap(0x{:08x})", heap.GetMPTR());
 	uint16 oldGroupId = MEMGetGroupIDForExpHeap(heap.GetPtr());
 	osLib_returnFromFunction(hCPU, oldGroupId);
 }
@@ -958,7 +956,7 @@ void export_MEMVisitAllocatedForExpHeap(PPCInterpreter_t* hCPU)
 	ppcDefineParamMEMPTR(heap, MEMHeapBase, 0);
 	ppcDefineParamMEMPTR(visitor, void, 1);
 	ppcDefineParamU32(userParam, 2);
-	coreinitMemLog_printf("MEMVisitAllocatedForExpHeap(0x%08x, 0x%08x, 0x%x)", heap.GetMPTR(), visitor.GetMPTR(), userParam);
+	cemuLog_logDebug(LogType::CoreinitMem, "MEMVisitAllocatedForExpHeap(0x{:08x}, 0x{:08x}, 0x{:x})", heap.GetMPTR(), visitor.GetMPTR(), userParam);
 	MEMVisitAllocatedForExpHeap(heap.GetPtr(), visitor, userParam);
 	osLib_returnFromFunction(hCPU, 0);
 }
@@ -967,14 +965,14 @@ void export_MEMGetSizeForMBlockExpHeap(PPCInterpreter_t* hCPU)
 {
 	ppcDefineParamMEMPTR(memBlock, void, 0);
 	uint32 size = MEMGetSizeForMBlockExpHeap(memBlock.GetPtr());
-	coreinitMemLog_printf("MEMGetSizeForMBlockExpHeap(0x%08x) Result: 0x%x", memBlock.GetMPTR(), size);
+	cemuLog_logDebug(LogType::CoreinitMem, "MEMGetSizeForMBlockExpHeap(0x{:08x}) Result: 0x{:x}", memBlock.GetMPTR(), size);
 	osLib_returnFromFunction(hCPU, size);
 }
 
 void export_MEMGetGroupIDForMBlockExpHeap(PPCInterpreter_t* hCPU)
 {
 	ppcDefineParamMEMPTR(memBlock, void, 0);
-	coreinitMemLog_printf("MEMGetGroupIDForMBlockExpHeap(0x%08x)", memBlock.GetMPTR());
+	cemuLog_logDebug(LogType::CoreinitMem, "MEMGetGroupIDForMBlockExpHeap(0x{:08x})", memBlock.GetMPTR());
 	uint16 groupId = MEMGetGroupIDForMBlockExpHeap(memBlock.GetPtr());
 	osLib_returnFromFunction(hCPU, groupId);
 }
@@ -982,7 +980,7 @@ void export_MEMGetGroupIDForMBlockExpHeap(PPCInterpreter_t* hCPU)
 void export_MEMGetAllocDirForMBlockExpHeap(PPCInterpreter_t* hCPU)
 {
 	ppcDefineParamMEMPTR(memBlock, void, 0);
-	coreinitMemLog_printf("MEMGetAllocDirForMBlockExpHeap(0x%08x)", memBlock.GetMPTR());
+	cemuLog_logDebug(LogType::CoreinitMem, "MEMGetAllocDirForMBlockExpHeap(0x{:08x})", memBlock.GetMPTR());
 	uint16 allocDir = MEMGetAllocDirForMBlockExpHeap(memBlock.GetPtr());
 	osLib_returnFromFunction(hCPU, allocDir);
 }
@@ -991,7 +989,7 @@ void export_MEMCheckExpHeap(PPCInterpreter_t* hCPU)
 {
 	ppcDefineParamMEMPTR(heap, MEMHeapBase, 0);
 	ppcDefineParamU32(options, 1);
-	coreinitMemLog_printf("MEMCheckExpHeap(0x%08x, 0x%x)", heap.GetMPTR(), options);
+	cemuLog_logDebug(LogType::CoreinitMem, "MEMCheckExpHeap(0x{:08x}, 0x{:x})", heap.GetMPTR(), options);
 	bool result = MEMCheckExpHeap(heap.GetPtr(), options);
 	osLib_returnFromFunction(hCPU, result ? 1 : 0);
 }
@@ -1002,7 +1000,7 @@ void export_MEMCheckForMBlockExpHeap(PPCInterpreter_t* hCPU)
 	ppcDefineParamMEMPTR(heap, MEMHeapBase, 1);
 	ppcDefineParamU32(options, 2);
 	bool result = MEMCheckForMBlockExpHeap(memBlock.GetPtr(), heap.GetPtr(), options);
-	coreinitMemLog_printf("MEMCheckForMBlockExpHeap(0x%08x, 0x%08x, 0x%x) Result: %d", memBlock.GetMPTR(), heap.GetMPTR(), options, result);
+	cemuLog_logDebug(LogType::CoreinitMem, "MEMCheckForMBlockExpHeap(0x{:08x}, 0x{:08x}, 0x{:x}) Result: {}", memBlock.GetMPTR(), heap.GetMPTR(), options, result);
 	osLib_returnFromFunction(hCPU, result ? 1 : 0);
 }
 
@@ -1011,7 +1009,7 @@ void export_MEMInitAllocatorForExpHeap(PPCInterpreter_t* hCPU)
 	ppcDefineParamMEMPTR(allocator, MEMAllocator, 0);
 	ppcDefineParamMEMPTR(heap, MEMHeapBase, 1);
 	ppcDefineParamS32(alignment, 2);
-	coreinitMemLog_printf("MEMInitAllocatorForExpHeap(0x%08x, 0x%08x, %d)", allocator.GetMPTR(), heap.GetMPTR(), alignment);
+	cemuLog_logDebug(LogType::CoreinitMem, "MEMInitAllocatorForExpHeap(0x{:08x}, 0x{:08x}, {})", allocator.GetMPTR(), heap.GetMPTR(), alignment);
 	MEMInitAllocatorForExpHeap(allocator.GetPtr(), heap.GetPtr(), alignment);
 	osLib_returnFromFunction(hCPU, 0);
 }
diff --git a/src/Cafe/OS/libs/coreinit/coreinit_MPQueue.cpp b/src/Cafe/OS/libs/coreinit/coreinit_MPQueue.cpp
index 8fc5a935..1816ef24 100644
--- a/src/Cafe/OS/libs/coreinit/coreinit_MPQueue.cpp
+++ b/src/Cafe/OS/libs/coreinit/coreinit_MPQueue.cpp
@@ -6,8 +6,8 @@
 
 // titles that utilize MP task queue: Yoshi's Woolly World, Fast Racing Neo, Tokyo Mirage Sessions, Mii Maker
 
-#define AcquireMPQLock() s_workaroundSpinlock.acquire()
-#define ReleaseMPQLock() s_workaroundSpinlock.release()
+#define AcquireMPQLock() s_workaroundSpinlock.lock()
+#define ReleaseMPQLock() s_workaroundSpinlock.unlock()
 
 namespace coreinit
 {
@@ -35,7 +35,7 @@ namespace coreinit
 
 	void MPInitTask(MPTask* task, void* func, void* data, uint32 size)
 	{
-		s_workaroundSpinlock.acquire();
+		s_workaroundSpinlock.lock();
 		task->thisptr = task;
 		
 		task->coreIndex = PPC_CORE_COUNT;
@@ -48,7 +48,7 @@ namespace coreinit
 		
 		task->userdata = nullptr;
 		task->runtime = 0;
-		s_workaroundSpinlock.release();
+		s_workaroundSpinlock.unlock();
 	}
 
 	bool MPTermTask(MPTask* task)
diff --git a/src/Cafe/OS/libs/coreinit/coreinit_Memory.cpp b/src/Cafe/OS/libs/coreinit/coreinit_Memory.cpp
index f6ac1116..80ec212d 100644
--- a/src/Cafe/OS/libs/coreinit/coreinit_Memory.cpp
+++ b/src/Cafe/OS/libs/coreinit/coreinit_Memory.cpp
@@ -126,12 +126,12 @@ namespace coreinit
 		return physicalAddr;
 	}
 
-	void OSMemoryBarrier(PPCInterpreter_t* hCPU)
+	void OSMemoryBarrier()
 	{
 		// no-op
 	}
 
-	void OSGetMemBound(sint32 memType, MPTR* offsetOutput, uint32* sizeOutput)
+	void OSGetMemBound(sint32 memType, MEMPTR<void>* offsetOutput, uint32be* sizeOutput)
 	{
 		MPTR memAddr = MPTR_NULL;
 		uint32 memSize = 0;
@@ -184,7 +184,7 @@ namespace coreinit
 				titleId == 0x0005000010135E00 // US
 				)
 			{
-				forceLogDebug_printf("Hack: Reduce available memory to simulate loaded RPLs");
+				cemuLog_logDebug(LogType::Force, "Hack: Reduce available memory to simulate loaded RPLs");
 				currentRPLAllocatorOffset += (48 * 1024 * 1024); // 48MB
 			}
 			memAddr = currentRPLAllocatorOffset;
@@ -195,9 +195,9 @@ namespace coreinit
 			cemu_assert_debug(false);
 		}
 		if (offsetOutput)
-			*offsetOutput = _swapEndianU32(memAddr);
+			*offsetOutput = memAddr;
 		if (sizeOutput)
-			*sizeOutput = _swapEndianU32(memSize);
+			*sizeOutput = memSize;
 	}
 
 	void InitializeMemory()
diff --git a/src/Cafe/OS/libs/coreinit/coreinit_Memory.h b/src/Cafe/OS/libs/coreinit/coreinit_Memory.h
index cfb3ed06..62c9f135 100644
--- a/src/Cafe/OS/libs/coreinit/coreinit_Memory.h
+++ b/src/Cafe/OS/libs/coreinit/coreinit_Memory.h
@@ -4,5 +4,10 @@ namespace coreinit
 {
 	void InitializeMemory();
 
-	void OSGetMemBound(sint32 memType, MPTR* offsetOutput, uint32* sizeOutput);
+	void OSGetMemBound(sint32 memType, MEMPTR<void>* offsetOutput, uint32be* sizeOutput);
+
+	void* OSBlockMove(MEMPTR<void> dst, MEMPTR<void> src, uint32 size, bool flushDC);
+	void* OSBlockSet(MEMPTR<void> dst, uint32 value, uint32 size);
+
+	void OSMemoryBarrier();
 }
\ No newline at end of file
diff --git a/src/Cafe/OS/libs/coreinit/coreinit_MemoryMapping.cpp b/src/Cafe/OS/libs/coreinit/coreinit_MemoryMapping.cpp
index fe7f4d0b..d32a105c 100644
--- a/src/Cafe/OS/libs/coreinit/coreinit_MemoryMapping.cpp
+++ b/src/Cafe/OS/libs/coreinit/coreinit_MemoryMapping.cpp
@@ -4,24 +4,34 @@
 #define OS_MAP_READ_ONLY		(1)
 #define OS_MAP_READ_WRITE		(2)
 
+#define VIRT_RANGE_ADDR			(0xA0000000) // todo: Process specific. For the main ram pid this overlaps with the overlay arena?
+#define VIRT_RANGE_SIZE			(0x40000000)
+
+#define PHYS_RANGE_ADDR			(0x10000000) // todo: Process specific
+#define PHYS_RANGE_SIZE			(0x40000000)
+
 namespace coreinit
 {
+	std::mutex s_memMappingMtx;
 
-	struct OSVirtMemory
+	struct OSVirtMemoryEntry
 	{
+		OSVirtMemoryEntry(MPTR virtualAddress, uint32 size, uint32 alignment) : virtualAddress(virtualAddress), size(size), alignment(alignment) {};
+
 		MPTR virtualAddress;
 		uint32 size;
 		uint32 alignment;
-		OSVirtMemory* next;
 	};
 
-	OSVirtMemory* virtualMemoryList = nullptr;
+	std::vector<OSVirtMemoryEntry> s_allocatedVirtMemory;
 
-	MPTR _VirtualMemoryAlloc(uint32 size, uint32 alignment)
+	MPTR _OSAllocVirtAddr(uint32 size, uint32 alignment)
 	{
-		uint32 currentAddress = MEMORY_MAPABLE_VIRT_AREA_OFFSET;
-		uint32 endAddress = MEMORY_MAPABLE_VIRT_AREA_OFFSET + MEMORY_MAPABLE_VIRT_AREA_SIZE;
+		std::lock_guard _l(s_memMappingMtx);
+		uint32 currentAddress = VIRT_RANGE_ADDR;
+		uint32 endAddress = VIRT_RANGE_ADDR + VIRT_RANGE_SIZE;
 		uint32 pageSize = (uint32)MemMapper::GetPageSize();
+		pageSize = std::max<uint32>(pageSize, Espresso::MEM_PAGE_SIZE);
 		while (true)
 		{
 			// calculated aligned start and end address for current region
@@ -30,95 +40,85 @@ namespace coreinit
 			uint32 currentEndAddress = currentAddress + size;
 			currentEndAddress = (currentEndAddress + pageSize - 1) & ~(pageSize - 1);
 			// check if out of available space
-			if (currentEndAddress >= endAddress)
+			if (currentEndAddress > endAddress)
 			{
-				debug_printf("coreinitVirtualMemory_alloc(): Unable to allocate memory\n");
-				debugBreakpoint();
+				cemuLog_log(LogType::APIErrors, "_OSAllocVirtAddr(): Unable to allocate memory\n");
 				return MPTR_NULL;
 			}
 			// check for overlapping regions
-			OSVirtMemory* virtMemItr = virtualMemoryList;
 			bool emptySpaceFound = true;
-			while (virtMemItr)
+			for(auto& virtMemIt : s_allocatedVirtMemory)
 			{
 				// check for range collision
-				if (currentAddress < (virtMemItr->virtualAddress + virtMemItr->size) && currentEndAddress > virtMemItr->virtualAddress)
+				if (currentAddress < (virtMemIt.virtualAddress + virtMemIt.size) && currentEndAddress > virtMemIt.virtualAddress)
 				{
 					// regions overlap
-					// adjust current address and try again
-					currentAddress = virtMemItr->virtualAddress + virtMemItr->size;
+					// adjust current address and keep looking
+					currentAddress = virtMemIt.virtualAddress + virtMemIt.size;
 					emptySpaceFound = false;
 					break;
 				}
-				// next
-				virtMemItr = virtMemItr->next;
 			}
 			if (emptySpaceFound)
 			{
 				// add entry
-				OSVirtMemory* virtMemory = (OSVirtMemory*)malloc(sizeof(OSVirtMemory));
-				memset(virtMemory, 0x00, sizeof(OSVirtMemory));
-				virtMemory->virtualAddress = currentAddress;
-				virtMemory->size = currentEndAddress - currentAddress;
-				virtMemory->alignment = alignment;
-				virtMemory->next = virtualMemoryList;
-				virtualMemoryList = virtMemory;
+				s_allocatedVirtMemory.emplace_back(currentAddress, currentEndAddress - currentAddress, alignment);
 				return currentAddress;
 			}
 		}
 		return MPTR_NULL;
 	}
 
-	void coreinitExport_OSGetAvailPhysAddrRange(PPCInterpreter_t* hCPU)
+	bool _OSFreeVirtAddr(MPTR virtAddr)
 	{
-		// parameters:
-		// r3	MPTR*		areaStart
-		// r4	uint32		areaSize
-		memory_writeU32(hCPU->gpr[3], MEMORY_MAPABLE_PHYS_AREA_OFFSET);
-		memory_writeU32(hCPU->gpr[4], MEMORY_MAPABLE_PHYS_AREA_SIZE);
-
-		osLib_returnFromFunction(hCPU, 0);
+		std::lock_guard _l(s_memMappingMtx);
+		auto it = s_allocatedVirtMemory.begin();
+		while (it != s_allocatedVirtMemory.end())
+		{
+			if (it->virtualAddress == virtAddr)
+			{
+				s_allocatedVirtMemory.erase(it);
+				return true;
+			}
+			++it;
+		}
+		return false;
 	}
 
-	void coreinitExport_OSAllocVirtAddr(PPCInterpreter_t* hCPU)
+	void OSGetAvailPhysAddrRange(uint32be* physRangeStart, uint32be* physRangeSize)
 	{
-		// parameters:
-		// r3	MPTR		address
-		// r4	uint32		size
-		// r5	uint32		align
+		*physRangeStart = PHYS_RANGE_ADDR;
+		*physRangeSize = PHYS_RANGE_SIZE;
+	}
 
-		uint32 address = hCPU->gpr[3];
-		uint32 size = hCPU->gpr[4];
-		uint32 align = hCPU->gpr[5];
-		if (address != MPTR_NULL)
-		{
-			debug_printf("coreinitExport_OSAllocVirtAddr(): Unsupported address != NULL\n");
-			debugBreakpoint();
-		}
+	void* OSAllocVirtAddr(MEMPTR<void> address, uint32 size, uint32 align)
+	{
 		if (align == 0)
 			align = 1;
 		if (align != 0 && align != 1)
 			assert_dbg();
+		cemu_assert_debug(address == nullptr); // todo - support for allocation with fixed address
 
-		address = _VirtualMemoryAlloc(size, align);
-		debug_printf("coreinitExport_OSAllocVirtAddr(): Allocated virtual memory at 0x%08x\n", address);
-		osLib_returnFromFunction(hCPU, address);
+		address = _OSAllocVirtAddr(size, align);
+		debug_printf("OSAllocVirtAddr(): Allocated virtual memory at 0x%08x\n", address.GetMPTR());
+		return MEMPTR<void>(address);
 	}
 
-	void coreinitExport_OSMapMemory(PPCInterpreter_t* hCPU)
+	uint32 OSFreeVirtAddr(MEMPTR<void> address)
 	{
-		// parameters:
-		// r3	MPTR		virtualAddress
-		// r4	MPTR		physicalAddress
-		// r5	uint32		size
-		// r6	uint32		mode
-		MPTR virtualAddress = hCPU->gpr[3];
-		MPTR physicalAddress = hCPU->gpr[4];
-		uint32 size = hCPU->gpr[5];
-		uint32 mode = hCPU->gpr[6];
+		bool r = _OSFreeVirtAddr(address.GetMPTR());
+		if(!r)
+			cemuLog_log(LogType::APIErrors, "OSFreeVirtAddr: Could not find allocation with address 0x{:08x}\n", address.GetMPTR());
+		return r ? 1 : 0;
+	}
 
-		if (virtualAddress < MEMORY_MAPABLE_VIRT_AREA_OFFSET || virtualAddress >= (MEMORY_MAPABLE_VIRT_AREA_OFFSET + MEMORY_MAPABLE_VIRT_AREA_SIZE))
-			cemu_assert_suspicious();
+	uint32 OSMapMemory(MPTR virtualAddress, MPTR physicalAddress, uint32 size, uint32 mode)
+	{
+		if (virtualAddress < VIRT_RANGE_ADDR || virtualAddress >= (VIRT_RANGE_ADDR + VIRT_RANGE_SIZE))
+		{
+			cemuLog_log(LogType::APIErrors, "OSMapMemory: Virtual address out of bounds\n");
+			return 0;
+		}
 
 		uint8* virtualPtr = memory_getPointerFromVirtualOffset(virtualAddress);
 
@@ -133,21 +133,14 @@ namespace coreinit
 		if (!allocationResult)
 		{
 			cemuLog_log(LogType::Force, "OSMapMemory failed");
-			osLib_returnFromFunction(hCPU, 0);
-			return;
+			return 0;
 		}
-		osLib_returnFromFunction(hCPU, 1);
+		return 1;
 	}
 
-	void coreinitExport_OSUnmapMemory(PPCInterpreter_t* hCPU)
+	uint32 OSUnmapMemory(MPTR virtualAddress, uint32 size)
 	{
-		// parameters:
-		// r3	MPTR		virtualAddress
-		// r4	uint32		size
-		MPTR virtualAddress = hCPU->gpr[3];
-		uint32 size = hCPU->gpr[4];
-
-		if (virtualAddress < MEMORY_MAPABLE_VIRT_AREA_OFFSET || virtualAddress >= (MEMORY_MAPABLE_VIRT_AREA_OFFSET + MEMORY_MAPABLE_VIRT_AREA_SIZE))
+		if (virtualAddress < VIRT_RANGE_ADDR || virtualAddress >= (VIRT_RANGE_ADDR + VIRT_RANGE_SIZE))
 			cemu_assert_suspicious();
 
 		cemu_assert((size % MemMapper::GetPageSize()) == 0);
@@ -155,14 +148,16 @@ namespace coreinit
 		uint8* virtualPtr = memory_getPointerFromVirtualOffset(virtualAddress);
 
 		MemMapper::FreeMemory(virtualPtr, size, true);
-		osLib_returnFromFunction(hCPU, 1);
+		return 1;
 	}
 
 	void InitializeMemoryMapping()
 	{
-		osLib_addFunction("coreinit", "OSGetAvailPhysAddrRange", coreinitExport_OSGetAvailPhysAddrRange);
-		osLib_addFunction("coreinit", "OSAllocVirtAddr", coreinitExport_OSAllocVirtAddr);
-		osLib_addFunction("coreinit", "OSMapMemory", coreinitExport_OSMapMemory);
-		osLib_addFunction("coreinit", "OSUnmapMemory", coreinitExport_OSUnmapMemory);
+		s_allocatedVirtMemory.clear();
+		cafeExportRegister("coreinit", OSGetAvailPhysAddrRange, LogType::CoreinitMemoryMapping);
+		cafeExportRegister("coreinit", OSAllocVirtAddr, LogType::CoreinitMemoryMapping);
+		cafeExportRegister("coreinit", OSFreeVirtAddr, LogType::CoreinitMemoryMapping);
+		cafeExportRegister("coreinit", OSMapMemory, LogType::CoreinitMemoryMapping);
+		cafeExportRegister("coreinit", OSUnmapMemory, LogType::CoreinitMemoryMapping);
 	}
 }
\ No newline at end of file
diff --git a/src/Cafe/OS/libs/coreinit/coreinit_MessageQueue.cpp b/src/Cafe/OS/libs/coreinit/coreinit_MessageQueue.cpp
index 6e6a7bc1..cbcfa4d1 100644
--- a/src/Cafe/OS/libs/coreinit/coreinit_MessageQueue.cpp
+++ b/src/Cafe/OS/libs/coreinit/coreinit_MessageQueue.cpp
@@ -3,6 +3,8 @@
 
 namespace coreinit
 {
+	void UpdateSystemMessageQueue();
+	void HandleReceivedSystemMessage(OSMessage* msg);
 
 	SysAllocator<OSMessageQueue> g_systemMessageQueue;
 	SysAllocator<OSMessage, 16> _systemMessageQueueArray;
@@ -27,6 +29,9 @@ namespace coreinit
 
 	bool OSReceiveMessage(OSMessageQueue* msgQueue, OSMessage* msg, uint32 flags)
 	{
+		bool isSystemMessageQueue = (msgQueue == g_systemMessageQueue);
+		if(isSystemMessageQueue)
+			UpdateSystemMessageQueue();
 		__OSLockScheduler(msgQueue);
 		while (msgQueue->usedCount == (uint32be)0)
 		{
@@ -50,6 +55,8 @@ namespace coreinit
 		if (!msgQueue->threadQueueSend.isEmpty())
 			msgQueue->threadQueueSend.wakeupSingleThreadWaitQueue(true);
 		__OSUnlockScheduler(msgQueue);
+		if(isSystemMessageQueue)
+			HandleReceivedSystemMessage(msg);
 		return true;
 	}
 
diff --git a/src/Cafe/OS/libs/coreinit/coreinit_MessageQueue.h b/src/Cafe/OS/libs/coreinit/coreinit_MessageQueue.h
index 6741ab84..35fdc3e7 100644
--- a/src/Cafe/OS/libs/coreinit/coreinit_MessageQueue.h
+++ b/src/Cafe/OS/libs/coreinit/coreinit_MessageQueue.h
@@ -3,12 +3,21 @@
 
 namespace coreinit
 {
+	enum class SysMessageId : uint32
+	{
+		MsgAcquireForeground = 0xFACEF000,
+		MsgReleaseForeground = 0xFACEBACC,
+		MsgExit = 0xD1E0D1E0,
+		HomeButtonDenied = 0xCCC0FFEE,
+		NetIoStartOrStop = 0xAAC0FFEE,
+	};
+
 	struct OSMessage
 	{
-		MPTR           message;
-		uint32         data0;
-		uint32         data1;
-		uint32         data2;
+		uint32be		message;
+		uint32be		data0;
+		uint32be		data1;
+		uint32be		data2;
 	};
 
 	struct OSMessageQueue
@@ -36,5 +45,7 @@ namespace coreinit
 	bool OSPeekMessage(OSMessageQueue* msgQueue, OSMessage* msg);
 	sint32 OSSendMessage(OSMessageQueue* msgQueue, OSMessage* msg, uint32 flags);
 
+	OSMessageQueue* OSGetSystemMessageQueue();
+
 	void InitializeMessageQueue();
 };
\ No newline at end of file
diff --git a/src/Cafe/OS/libs/coreinit/coreinit_Misc.cpp b/src/Cafe/OS/libs/coreinit/coreinit_Misc.cpp
index b8a964ce..71a7d6e2 100644
--- a/src/Cafe/OS/libs/coreinit/coreinit_Misc.cpp
+++ b/src/Cafe/OS/libs/coreinit/coreinit_Misc.cpp
@@ -1,16 +1,15 @@
 #include "Cafe/OS/common/OSCommon.h"
 #include "Cafe/OS/libs/coreinit/coreinit_Misc.h"
+#include "Cafe/OS/libs/coreinit/coreinit_MessageQueue.h"
+#include "Cafe/CafeSystem.h"
+#include "Cafe/Filesystem/fsc.h"
+#include <pugixml.hpp>
 
 namespace coreinit
 {
-
-	/* coreinit logging and string format */
-
-	sint32 ppcSprintf(const char* formatStr, char* strOut, sint32 maxLength, PPCInterpreter_t* hCPU, sint32 initialParamIndex)
+	sint32 ppc_vprintf(const char* formatStr, char* strOut, sint32 maxLength, ppc_va_list* vargs)
 	{
 		char tempStr[4096];
-		sint32 integerParamIndex = initialParamIndex;
-		sint32 floatParamIndex = 0;
 		sint32 writeIndex = 0;
 		while (*formatStr)
 		{
@@ -97,8 +96,7 @@ namespace coreinit
 						tempFormat[(formatStr - formatStart)] = '\0';
 					else
 						tempFormat[sizeof(tempFormat) - 1] = '\0';
-					sint32 tempLen = sprintf(tempStr, tempFormat, PPCInterpreter_getCallParamU32(hCPU, integerParamIndex));
-					integerParamIndex++;
+					sint32 tempLen = sprintf(tempStr, tempFormat, (uint32)*(uint32be*)_ppc_va_arg(vargs, ppc_va_type::INT32));
 					for (sint32 i = 0; i < tempLen; i++)
 					{
 						if (writeIndex >= maxLength)
@@ -116,13 +114,12 @@ namespace coreinit
 						tempFormat[(formatStr - formatStart)] = '\0';
 					else
 						tempFormat[sizeof(tempFormat) - 1] = '\0';
-					MPTR strOffset = PPCInterpreter_getCallParamU32(hCPU, integerParamIndex);
+					MPTR strOffset = *(uint32be*)_ppc_va_arg(vargs, ppc_va_type::INT32);
 					sint32 tempLen = 0;
 					if (strOffset == MPTR_NULL)
 						tempLen = sprintf(tempStr, "NULL");
 					else
 						tempLen = sprintf(tempStr, tempFormat, memory_getPointerFromVirtualOffset(strOffset));
-					integerParamIndex++;
 					for (sint32 i = 0; i < tempLen; i++)
 					{
 						if (writeIndex >= maxLength)
@@ -132,25 +129,6 @@ namespace coreinit
 					}
 					strOut[std::min(maxLength - 1, writeIndex)] = '\0';
 				}
-				else if (*formatStr == 'f')
-				{
-					// float
-					formatStr++;
-					strncpy(tempFormat, formatStart, std::min((std::ptrdiff_t)sizeof(tempFormat) - 1, formatStr - formatStart));
-					if ((formatStr - formatStart) < sizeof(tempFormat))
-						tempFormat[(formatStr - formatStart)] = '\0';
-					else
-						tempFormat[sizeof(tempFormat) - 1] = '\0';
-					sint32 tempLen = sprintf(tempStr, tempFormat, (float)hCPU->fpr[1 + floatParamIndex].fp0);
-					floatParamIndex++;
-					for (sint32 i = 0; i < tempLen; i++)
-					{
-						if (writeIndex >= maxLength)
-							break;
-						strOut[writeIndex] = tempStr[i];
-						writeIndex++;
-					}
-				}
 				else if (*formatStr == 'c')
 				{
 					// character
@@ -160,8 +138,24 @@ namespace coreinit
 						tempFormat[(formatStr - formatStart)] = '\0';
 					else
 						tempFormat[sizeof(tempFormat) - 1] = '\0';
-					sint32 tempLen = sprintf(tempStr, tempFormat, PPCInterpreter_getCallParamU32(hCPU, integerParamIndex));
-					integerParamIndex++;
+					sint32 tempLen = sprintf(tempStr, tempFormat, (uint32)*(uint32be*)_ppc_va_arg(vargs, ppc_va_type::INT32));
+					for (sint32 i = 0; i < tempLen; i++)
+					{
+						if (writeIndex >= maxLength)
+							break;
+						strOut[writeIndex] = tempStr[i];
+						writeIndex++;
+					}
+				}
+				else if (*formatStr == 'f' || *formatStr == 'g' || *formatStr == 'G')
+				{
+					formatStr++;
+					strncpy(tempFormat, formatStart, std::min((std::ptrdiff_t)sizeof(tempFormat) - 1, formatStr - formatStart));
+					if ((formatStr - formatStart) < sizeof(tempFormat))
+						tempFormat[(formatStr - formatStart)] = '\0';
+					else
+						tempFormat[sizeof(tempFormat) - 1] = '\0';
+					sint32 tempLen = sprintf(tempStr, tempFormat, (double)*(betype<double>*)_ppc_va_arg(vargs, ppc_va_type::FLOAT_OR_DOUBLE));
 					for (sint32 i = 0; i < tempLen; i++)
 					{
 						if (writeIndex >= maxLength)
@@ -179,8 +173,7 @@ namespace coreinit
 						tempFormat[(formatStr - formatStart)] = '\0';
 					else
 						tempFormat[sizeof(tempFormat) - 1] = '\0';
-					sint32 tempLen = sprintf(tempStr, tempFormat, (double)hCPU->fpr[1 + floatParamIndex].fp0);
-					floatParamIndex++;
+					sint32 tempLen = sprintf(tempStr, tempFormat, (double)*(betype<double>*)_ppc_va_arg(vargs, ppc_va_type::FLOAT_OR_DOUBLE));
 					for (sint32 i = 0; i < tempLen; i++)
 					{
 						if (writeIndex >= maxLength)
@@ -192,16 +185,31 @@ namespace coreinit
 				else if ((formatStr[0] == 'l' && formatStr[1] == 'l' && (formatStr[2] == 'x' || formatStr[2] == 'X')))
 				{
 					formatStr += 3;
-					// number (64bit)
+					// 64bit int
 					strncpy(tempFormat, formatStart, std::min((std::ptrdiff_t)sizeof(tempFormat) - 1, formatStr - formatStart));
 					if ((formatStr - formatStart) < sizeof(tempFormat))
 						tempFormat[(formatStr - formatStart)] = '\0';
 					else
 						tempFormat[sizeof(tempFormat) - 1] = '\0';
-					if (integerParamIndex & 1)
-						integerParamIndex++;
-					sint32 tempLen = sprintf(tempStr, tempFormat, PPCInterpreter_getCallParamU64(hCPU, integerParamIndex));
-					integerParamIndex += 2;
+					sint32 tempLen = sprintf(tempStr, tempFormat, (uint64)*(uint64be*)_ppc_va_arg(vargs, ppc_va_type::INT64));
+					for (sint32 i = 0; i < tempLen; i++)
+					{
+						if (writeIndex >= maxLength)
+							break;
+						strOut[writeIndex] = tempStr[i];
+						writeIndex++;
+					}
+				}
+				else if ((formatStr[0] == 'l' && formatStr[1] == 'l' && formatStr[2] == 'd'))
+				{
+					formatStr += 3;
+					// signed integer (64bit)
+					strncpy(tempFormat, formatStart, std::min((std::ptrdiff_t)sizeof(tempFormat) - 1, formatStr - formatStart));
+					if ((formatStr - formatStart) < sizeof(tempFormat))
+						tempFormat[(formatStr - formatStart)] = '\0';
+					else
+						tempFormat[sizeof(tempFormat) - 1] = '\0';
+					sint32 tempLen = sprintf(tempStr, tempFormat, (sint64)*(sint64be*)_ppc_va_arg(vargs, ppc_va_type::INT64));
 					for (sint32 i = 0; i < tempLen; i++)
 					{
 						if (writeIndex >= maxLength)
@@ -230,9 +238,12 @@ namespace coreinit
 		return std::min(writeIndex, maxLength - 1);
 	}
 
+	/* coreinit logging and string format */
+
 	sint32 __os_snprintf(char* outputStr, sint32 maxLength, const char* formatStr)
 	{
-		sint32 r = ppcSprintf(formatStr, outputStr, maxLength, ppcInterpreterCurrentInstance, 3);
+		ppc_define_va_list(3, 0);
+		sint32 r = ppc_vprintf(formatStr, outputStr, maxLength, &vargs);
 		return r;
 	}
 
@@ -297,26 +308,40 @@ namespace coreinit
 		}
 	}
 
+	void COSVReport(COSReportModule module, COSReportLevel level, const char* format, ppc_va_list* vargs)
+	{
+		char tmpBuffer[1024];
+		sint32 len = ppc_vprintf(format, tmpBuffer, sizeof(tmpBuffer), vargs);
+		WriteCafeConsole(CafeLogType::OSCONSOLE, tmpBuffer, len);
+	}
+
 	void OSReport(const char* format)
 	{
-		char buffer[1024 * 2];
-		sint32 len = ppcSprintf(format, buffer, sizeof(buffer), ppcInterpreterCurrentInstance, 1);
-		WriteCafeConsole(CafeLogType::OSCONSOLE, buffer, len);
+		ppc_define_va_list(1, 0);
+		COSVReport(COSReportModule::coreinit, COSReportLevel::Info, format, &vargs);
 	}
 
-	void OSVReport(const char* format, MPTR vaArgs)
+	void OSVReport(const char* format, ppc_va_list* vargs)
 	{
-		cemu_assert_unimplemented();
+		COSVReport(COSReportModule::coreinit, COSReportLevel::Info, format, vargs);
 	}
 
-	void COSWarn()
+	void COSWarn(int moduleId, const char* format)
 	{
-		cemu_assert_debug(false);
+		ppc_define_va_list(2, 0);
+		char tmpBuffer[1024];
+		int prefixLen = sprintf(tmpBuffer, "[COSWarn-%d] ", moduleId);
+		sint32 len = ppc_vprintf(format, tmpBuffer + prefixLen, sizeof(tmpBuffer) - prefixLen, &vargs);
+		WriteCafeConsole(CafeLogType::OSCONSOLE, tmpBuffer, len + prefixLen);
 	}
 
-	void OSLogPrintf()
+	void OSLogPrintf(int ukn1, int ukn2, int ukn3, const char* format)
 	{
-		cemu_assert_debug(false);
+		ppc_define_va_list(4, 0);
+		char tmpBuffer[1024];
+		int prefixLen = sprintf(tmpBuffer, "[OSLogPrintf-%d-%d-%d] ", ukn1, ukn2, ukn3);
+		sint32 len = ppc_vprintf(format, tmpBuffer + prefixLen, sizeof(tmpBuffer) - prefixLen, &vargs);
+		WriteCafeConsole(CafeLogType::OSCONSOLE, tmpBuffer, len + prefixLen);
 	}
 
 	void OSConsoleWrite(const char* strPtr, sint32 length)
@@ -341,19 +366,221 @@ namespace coreinit
 		return true;
 	}
 
+	uint32 OSGetPFID()
+	{
+		return 15; // hardcoded as game
+	}
+
+	uint32 OSGetUPID()
+	{
+		return OSGetPFID();
+	}
+
+	uint64 s_currentTitleId;
+
+	uint64 OSGetTitleID()
+	{
+		return s_currentTitleId;
+	}
+
+	uint32 s_sdkVersion;
+
+	uint32 __OSGetProcessSDKVersion()
+	{
+		return s_sdkVersion;
+	}
+
+	// move this to CafeSystem.cpp?
+	void OSLauncherThread(uint64 titleId)
+	{
+		CafeSystem::ShutdownTitle();
+		CafeSystem::PrepareForegroundTitle(titleId);
+		CafeSystem::RequestRecreateCanvas();
+		CafeSystem::LaunchForegroundTitle();
+	}
+
+	uint32 __LaunchByTitleId(uint64 titleId, uint32 argc, MEMPTR<char>* argv)
+	{
+		// prepare argument buffer
+		#if 0
+		char argumentBuffer[4096];
+		uint32 argumentBufferLength = 0;
+		char* argWriter = argumentBuffer;
+		for(uint32 i=0; i<argc; i++)
+		{
+			const char* arg = argv[i];
+			uint32 argLength = strlen(arg);
+			if((argumentBufferLength + argLength + 1) >= sizeof(argumentBuffer))
+			{
+				// argument buffer full
+				cemuLog_logDebug(LogType::Force, "LaunchByTitleId: argument buffer full");
+				return 0x80000000;
+			}
+			memcpy(argWriter, arg, argLength);
+			argWriter[argLength] = '\0';
+			argWriter += argLength + 1;
+			argumentBufferLength += argLength + 1;
+		}
+		#endif
+		// normally the above buffer is passed to the PPC kernel via syscall 0x2B and then
+		// the kernel forwards it to IOSU MCP when requesting a title launch
+		// but for now we HLE most of the launching code and can just set the argument array directly
+		std::vector<std::string> argArray;
+		for(uint32 i=0; i<argc; i++)
+			argArray.emplace_back(argv[i]);
+		CafeSystem::SetOverrideArgs(argArray);
+		// spawn launcher thread (this current thread will be destroyed during relaunch)
+		std::thread launcherThread(OSLauncherThread, titleId);
+		launcherThread.detach();
+		// suspend this thread
+		coreinit::OSSuspendThread(coreinit::OSGetCurrentThread());
+		return 0;
+	}
+
+	uint32 OSLaunchTitleByPathl(const char* path, uint32 pathLength, uint32 argc)
+	{
+		char appXmlPath[1024];
+		cemu_assert_debug(argc == 0); // custom args not supported yet
+		if(pathLength >= (sizeof(appXmlPath) - 32))
+		{
+			// path too long
+			cemuLog_logDebug(LogType::Force, "OSLaunchTitleByPathl: path too long");
+			return 0x80000000;
+		}
+		// read app.xml to get the titleId
+		memcpy(appXmlPath, path, pathLength);
+		appXmlPath[pathLength] = '\0';
+		strcat(appXmlPath, "/code/app.xml");
+		sint32 status;
+		auto fscfile = fsc_open(appXmlPath, FSC_ACCESS_FLAG::OPEN_FILE | FSC_ACCESS_FLAG::READ_PERMISSION, &status);
+		if (!fscfile)
+		{
+			cemuLog_logDebug(LogType::Force, "OSLaunchTitleByPathl: failed to open target app.xml");
+			return 0x80000000;
+		}
+		uint32 size = fsc_getFileSize(fscfile);
+		std::vector<uint8> tmpData(size);
+		fsc_readFile(fscfile, tmpData.data(), size);
+		fsc_close(fscfile);
+		// parse app.xml to get the titleId
+		pugi::xml_document app_doc;
+		if (!app_doc.load_buffer_inplace(tmpData.data(), tmpData.size()))
+			return false;
+		uint64 titleId = std::stoull(app_doc.child("app").child("title_id").child_value(), nullptr, 16);
+		if(titleId == 0)
+		{
+			cemuLog_logDebug(LogType::Force, "OSLaunchTitleByPathl: failed to parse titleId from app.xml");
+			return 0x80000000;
+		}
+		__LaunchByTitleId(titleId, 0, nullptr);
+		return 0;
+	}
+
+	uint32 OSRestartGame(uint32 argc, MEMPTR<char>* argv)
+	{
+		__LaunchByTitleId(CafeSystem::GetForegroundTitleId(), argc, argv);
+		return 0;
+	}
+
+	void OSReleaseForeground()
+	{
+		cemuLog_logDebug(LogType::Force, "OSReleaseForeground not implemented");
+	}
+
+	bool s_transitionToBackground = false;
+	bool s_transitionToForeground = false;
+
+	void StartBackgroundForegroundTransition()
+	{
+		s_transitionToBackground = true;
+		s_transitionToForeground = true;
+	}
+
+	// called at the beginning of OSReceiveMessage if the queue is the system message queue
+	void UpdateSystemMessageQueue()
+	{
+		if(!OSIsInterruptEnabled())
+			return;
+		cemu_assert_debug(!__OSHasSchedulerLock());
+		// normally syscall 0x2E is used to get the next message
+		// for now we just have some preliminary logic here to allow a fake transition to background & foreground
+		if(s_transitionToBackground)
+		{
+			// add transition to background message
+			OSMessage msg{};
+			msg.data0 = stdx::to_underlying(SysMessageId::MsgReleaseForeground);
+			msg.data1 = 0; // 1 -> System is shutting down 0 -> Begin transitioning to background
+			OSMessageQueue* systemMessageQueue = coreinit::OSGetSystemMessageQueue();
+			if(OSSendMessage(systemMessageQueue, &msg, 0))
+				s_transitionToBackground = false;
+			return;
+		}
+		if(s_transitionToForeground)
+		{
+			// add transition to foreground message
+			OSMessage msg{};
+			msg.data0 = stdx::to_underlying(SysMessageId::MsgAcquireForeground);
+			msg.data1 = 1; // ?
+			msg.data2 = 1; // ?
+			OSMessageQueue* systemMessageQueue = coreinit::OSGetSystemMessageQueue();
+			if(OSSendMessage(systemMessageQueue, &msg, 0))
+				s_transitionToForeground = false;
+			return;
+		}
+	}
+
+	// called when OSReceiveMessage returns a message from the system message queue
+	void HandleReceivedSystemMessage(OSMessage* msg)
+	{
+		cemu_assert_debug(!__OSHasSchedulerLock());
+		cemuLog_log(LogType::Force, "Receiving message: {:08x}", (uint32)msg->data0);
+	}
+
+	uint32 OSDriver_Register(uint32 moduleHandle, sint32 priority, OSDriverInterface* driverCallbacks, sint32 driverId, uint32be* outUkn1, uint32be* outUkn2, uint32be* outUkn3)
+	{
+		cemuLog_logDebug(LogType::Force, "OSDriver_Register stubbed");
+		return 0;
+	}
+
+	uint32 OSDriver_Deregister(uint32 moduleHandle, sint32 driverId)
+	{
+		cemuLog_logDebug(LogType::Force, "OSDriver_Deregister stubbed");
+		return 0;
+	}
+
 	void miscInit()
 	{
+		s_currentTitleId = CafeSystem::GetForegroundTitleId();
+		s_sdkVersion = CafeSystem::GetForegroundTitleSDKVersion();
+		s_transitionToBackground = false;
+		s_transitionToForeground = false;
+
 		cafeExportRegister("coreinit", __os_snprintf, LogType::Placeholder);
+
+		cafeExportRegister("coreinit", COSVReport, LogType::Placeholder);
+		cafeExportRegister("coreinit", COSWarn, LogType::Placeholder);
 		cafeExportRegister("coreinit", OSReport, LogType::Placeholder);
 		cafeExportRegister("coreinit", OSVReport, LogType::Placeholder);
-		cafeExportRegister("coreinit", COSWarn, LogType::Placeholder);
 		cafeExportRegister("coreinit", OSLogPrintf, LogType::Placeholder);
 		cafeExportRegister("coreinit", OSConsoleWrite, LogType::Placeholder);
 
+		cafeExportRegister("coreinit", OSGetPFID, LogType::Placeholder);
+		cafeExportRegister("coreinit", OSGetUPID, LogType::Placeholder);
+		cafeExportRegister("coreinit", OSGetTitleID, LogType::Placeholder);
+		cafeExportRegister("coreinit", __OSGetProcessSDKVersion, LogType::Placeholder);
+
 		g_homeButtonMenuEnabled = true; // enabled by default
 		// Disney Infinity 2.0 actually relies on home button menu being enabled by default. If it's false it will crash due to calling erreula->IsAppearHomeNixSign() before initializing erreula
 		cafeExportRegister("coreinit", OSIsHomeButtonMenuEnabled, LogType::CoreinitThread);
 		cafeExportRegister("coreinit", OSEnableHomeButtonMenu, LogType::CoreinitThread);
+
+		cafeExportRegister("coreinit", OSLaunchTitleByPathl, LogType::Placeholder);
+		cafeExportRegister("coreinit", OSRestartGame, LogType::Placeholder);
+
+		cafeExportRegister("coreinit", OSReleaseForeground, LogType::Placeholder);
+
+		cafeExportRegister("coreinit", OSDriver_Register, LogType::Placeholder);
+		cafeExportRegister("coreinit", OSDriver_Deregister, LogType::Placeholder);
 	}
 
 };
diff --git a/src/Cafe/OS/libs/coreinit/coreinit_Misc.h b/src/Cafe/OS/libs/coreinit/coreinit_Misc.h
index 5cb0ee10..36f6b06a 100644
--- a/src/Cafe/OS/libs/coreinit/coreinit_Misc.h
+++ b/src/Cafe/OS/libs/coreinit/coreinit_Misc.h
@@ -2,5 +2,43 @@
 
 namespace coreinit
 {
+	uint32 OSGetUPID();
+	uint32 OSGetPFID();
+	uint64 OSGetTitleID();
+	uint32 __OSGetProcessSDKVersion();
+	uint32 OSLaunchTitleByPathl(const char* path, uint32 pathLength, uint32 argc);
+	uint32 OSRestartGame(uint32 argc, MEMPTR<char>* argv);
+
+	void OSReleaseForeground();
+
+	void StartBackgroundForegroundTransition();
+
+	struct OSDriverInterface
+	{
+		MEMPTR<void> getDriverName;
+		MEMPTR<void> init;
+		MEMPTR<void> onAcquireForeground;
+		MEMPTR<void> onReleaseForeground;
+		MEMPTR<void> done;
+	};
+	static_assert(sizeof(OSDriverInterface) == 0x14);
+
+	uint32 OSDriver_Register(uint32 moduleHandle, sint32 priority, OSDriverInterface* driverCallbacks, sint32 driverId, uint32be* outUkn1, uint32be* outUkn2, uint32be* outUkn3);
+	uint32 OSDriver_Deregister(uint32 moduleHandle, sint32 driverId);
+
+	enum class COSReportModule
+	{
+		coreinit = 0,
+	};
+
+	enum class COSReportLevel
+	{
+		Error = 0,
+		Warn = 1,
+		Info = 2
+	};
+
+	sint32 ppc_vprintf(const char* formatStr, char* strOut, sint32 maxLength, ppc_va_list* vargs);
+
 	void miscInit();
 };
\ No newline at end of file
diff --git a/src/Cafe/OS/libs/coreinit/coreinit_OSScreen.cpp b/src/Cafe/OS/libs/coreinit/coreinit_OSScreen.cpp
index 23b8f76b..7b51629e 100644
--- a/src/Cafe/OS/libs/coreinit/coreinit_OSScreen.cpp
+++ b/src/Cafe/OS/libs/coreinit/coreinit_OSScreen.cpp
@@ -96,7 +96,6 @@ namespace coreinit
 	{
 		ppcDefineParamU32(screenIndex, 0);
 		cemu_assert(screenIndex < 2);
-		forceLogDebug_printf("OSScreenFlipBuffersEx %d", screenIndex);
 		LatteGPUState.osScreen.screen[screenIndex].flipRequestCount++;
 		_updateCurrentDrawScreen(screenIndex);
 		osLib_returnFromFunction(hCPU, 0);
diff --git a/src/Cafe/OS/libs/coreinit/coreinit_Scheduler.cpp b/src/Cafe/OS/libs/coreinit/coreinit_Scheduler.cpp
index d166690e..bb310778 100644
--- a/src/Cafe/OS/libs/coreinit/coreinit_Scheduler.cpp
+++ b/src/Cafe/OS/libs/coreinit/coreinit_Scheduler.cpp
@@ -68,7 +68,6 @@ namespace coreinit
 	// disables interrupts and scheduling
 	uint32 OSDisableInterrupts()
 	{
-		// todo - rename SchedulerLock.cpp/h to Scheduler.cpp and move this there?
 		PPCInterpreter_t* hCPU = PPCInterpreter_getCurrentInstance();
 		if (hCPU == nullptr)
 			return 0;
@@ -77,9 +76,7 @@ namespace coreinit
 		{
 			// we have no efficient method to turn off scheduling completely, so instead we just increase the remaining cycles
 			if (hCPU->remainingCycles >= 0x40000000)
-			{
-				forceLogDebug_printf("OSDisableInterrupts(): Warning - Interrupts already disabled? remCycles %08x LR %08x", hCPU->remainingCycles, hCPU->spr.LR);
-			}
+				cemuLog_log(LogType::Force, "OSDisableInterrupts(): Warning - Interrupts already disabled but the mask was still set? remCycles {:08x} LR {:08x}", hCPU->remainingCycles, hCPU->spr.LR);
 			hCPU->remainingCycles += 0x40000000;
 		}
 		hCPU->coreInterruptMask = 0;
diff --git a/src/Cafe/OS/libs/coreinit/coreinit_Spinlock.cpp b/src/Cafe/OS/libs/coreinit/coreinit_Spinlock.cpp
index 16827d0f..3d235107 100644
--- a/src/Cafe/OS/libs/coreinit/coreinit_Spinlock.cpp
+++ b/src/Cafe/OS/libs/coreinit/coreinit_Spinlock.cpp
@@ -86,11 +86,11 @@ namespace coreinit
 		else
 		{
 			// loop until lock acquired or timeout occurred
-			uint64 timeoutValue = coreinit_getTimerTick() + coreinit::EspressoTime::ConvertNsToTimerTicks(timeout);
+			uint64 timeoutValue = OSGetSystemTime() + coreinit::EspressoTime::ConvertNsToTimerTicks(timeout);
 			while (!spinlock->ownerThread.atomic_compare_exchange(nullptr, currentThread))
 			{
 				OSYieldThread();
-				if (coreinit_getTimerTick() >= timeoutValue)
+				if (OSGetSystemTime() >= timeoutValue)
 				{
 					return false;
 				}
@@ -128,9 +128,23 @@ namespace coreinit
 		else
 		{
 			// loop until lock acquired
-			while (!spinlock->ownerThread.atomic_compare_exchange(nullptr, currentThread))
+			if (coreinit::__CemuIsMulticoreMode())
 			{
-				OSYieldThread();
+				while (!spinlock->ownerThread.atomic_compare_exchange(nullptr, currentThread))
+				{
+					_mm_pause();
+				}
+			}
+			else
+			{
+				// we are in single-core mode and the lock will never be released unless we let other threads resume work
+				// to avoid an infinite loop we have no choice but to yield the thread even it is in an uninterruptible state
+				if( !OSIsInterruptEnabled() )
+					cemuLog_logOnce(LogType::APIErrors, "OSUninterruptibleSpinLock_Acquire(): Lock is occupied which requires a wait but current thread is already in an uninterruptible state (Avoid cascaded OSDisableInterrupts and/or OSUninterruptibleSpinLock)");
+				while (!spinlock->ownerThread.atomic_compare_exchange(nullptr, currentThread))
+				{
+					OSYieldThread();
+				}
 			}
 		}
 		__OSBoostThread(currentThread);
@@ -168,11 +182,11 @@ namespace coreinit
 		else
 		{
 			// loop until lock acquired or timeout occurred
-			uint64 timeoutValue = coreinit_getTimerTick() + coreinit::EspressoTime::ConvertNsToTimerTicks(timeout);
+			uint64 timeoutValue = OSGetSystemTime() + coreinit::EspressoTime::ConvertNsToTimerTicks(timeout);
 			while (!spinlock->ownerThread.atomic_compare_exchange(nullptr, currentThread))
 			{
 				OSYieldThread();
-				if (coreinit_getTimerTick() >= timeoutValue)
+				if (OSGetSystemTime() >= timeoutValue)
 				{
 					return false;
 				}
diff --git a/src/Cafe/OS/libs/coreinit/coreinit_Synchronization.cpp b/src/Cafe/OS/libs/coreinit/coreinit_Synchronization.cpp
index 84f7c5cf..e81cc577 100644
--- a/src/Cafe/OS/libs/coreinit/coreinit_Synchronization.cpp
+++ b/src/Cafe/OS/libs/coreinit/coreinit_Synchronization.cpp
@@ -73,8 +73,6 @@ namespace coreinit
 		}
 	}
 
-	uint64 coreinit_getOSTime();
-
 	bool OSWaitEventWithTimeout(OSEvent* event, uint64 timeout)
 	{
 		__OSLockScheduler();
@@ -95,14 +93,14 @@ namespace coreinit
 
 			// workaround for a bad implementation in some Unity games (like Qube Directors Cut, see FEventWiiU::Wait)
 			// where the the return value of OSWaitEventWithTimeout is ignored and instead the game measures the elapsed time to determine if a timeout occurred
-			timeout = timeout * 98ULL / 100ULL; // 98% (we want the function to return slightly before the actual timeout)
+			if (timeout < 0x00FFFFFFFFFFFFFFULL)
+				timeout = timeout * 98ULL / 100ULL; // 98% (we want the function to return slightly before the actual timeout)
 
 			WaitEventWithTimeoutData data;
 			data.thread = OSGetCurrentThread();
 			data.threadQueue = &event->threadQueue;
 			data.hasTimeout = false;
-
-			auto hostAlarm = coreinit::OSHostAlarmCreate(coreinit::coreinit_getOSTime() + coreinit::EspressoTime::ConvertNsToTimerTicks(timeout), 0, _OSWaitEventWithTimeoutHandler, &data);
+			auto hostAlarm = coreinit::OSHostAlarmCreate(OSGetTime() + coreinit::EspressoTime::ConvertNsToTimerTicks(timeout), 0, _OSWaitEventWithTimeoutHandler, &data);
 			event->threadQueue.queueAndWait(OSGetCurrentThread());
 			coreinit::OSHostAlarmDestroy(hostAlarm);
 			if (data.hasTimeout)
@@ -254,7 +252,7 @@ namespace coreinit
 			else
 			{
 				if (failedAttempts >= 0x800)
-					cemuLog_force("Detected long-term contested OSLockMutex");
+					cemuLog_log(LogType::Force, "Detected long-term contested OSLockMutex");
 				currentThread->waitingForMutex = mutex;
 				mutex->threadQueue.queueAndWait(currentThread);
 				currentThread->waitingForMutex = nullptr;
@@ -310,7 +308,7 @@ namespace coreinit
 			currentThread->mutexQueue.removeMutex(mutex);
 			mutex->owner = nullptr;
 			if (!mutex->threadQueue.isEmpty())
-				mutex->threadQueue.wakeupSingleThreadWaitQueue(true);
+				mutex->threadQueue.wakeupSingleThreadWaitQueue(true, true);
 		}
 		// currentThread->cancelState = currentThread->cancelState & ~0x10000;
 	}
@@ -465,12 +463,12 @@ namespace coreinit
 
 	void _OSFastMutex_AcquireContention(OSFastMutex* fastMutex)
 	{
-		g_fastMutexSpinlock.acquire();
+		g_fastMutexSpinlock.lock();
 	}
 
 	void _OSFastMutex_ReleaseContention(OSFastMutex* fastMutex)
 	{
-		g_fastMutexSpinlock.release();
+		g_fastMutexSpinlock.unlock();
 	}
 
 	void OSFastMutex_LockInternal(OSFastMutex* fastMutex)
@@ -550,7 +548,7 @@ namespace coreinit
 		if (fastMutex->owner != currentThread)
 		{
 			// seen in Paper Mario Color Splash
-			//forceLog_printf("OSFastMutex_Unlock() called on mutex which is not owned by current thread");
+			//cemuLog_log(LogType::Force, "OSFastMutex_Unlock() called on mutex which is not owned by current thread");
 			_OSFastMutex_ReleaseContention(fastMutex);
 			return;
 		}
@@ -621,49 +619,49 @@ namespace coreinit
 		OSInitEvent(g_rendezvousEvent.GetPtr(), OSEvent::EVENT_STATE::STATE_NOT_SIGNALED, OSEvent::EVENT_MODE::MODE_AUTO);
 
 		// OSEvent
-		cafeExportRegister("coreinit", OSInitEvent, LogType::ThreadSync);
-		cafeExportRegister("coreinit", OSInitEventEx, LogType::ThreadSync);
-		cafeExportRegister("coreinit", OSResetEvent, LogType::ThreadSync);
-		cafeExportRegister("coreinit", OSWaitEvent, LogType::ThreadSync);
-		cafeExportRegister("coreinit", OSWaitEventWithTimeout, LogType::ThreadSync);
-		cafeExportRegister("coreinit", OSSignalEvent, LogType::ThreadSync);
-		cafeExportRegister("coreinit", OSSignalEventAll, LogType::ThreadSync);
+		cafeExportRegister("coreinit", OSInitEvent, LogType::CoreinitThreadSync);
+		cafeExportRegister("coreinit", OSInitEventEx, LogType::CoreinitThreadSync);
+		cafeExportRegister("coreinit", OSResetEvent, LogType::CoreinitThreadSync);
+		cafeExportRegister("coreinit", OSWaitEvent, LogType::CoreinitThreadSync);
+		cafeExportRegister("coreinit", OSWaitEventWithTimeout, LogType::CoreinitThreadSync);
+		cafeExportRegister("coreinit", OSSignalEvent, LogType::CoreinitThreadSync);
+		cafeExportRegister("coreinit", OSSignalEventAll, LogType::CoreinitThreadSync);
 
 		// OSRendezvous
-		cafeExportRegister("coreinit", OSInitRendezvous, LogType::ThreadSync);
-		cafeExportRegister("coreinit", OSWaitRendezvous, LogType::ThreadSync);
+		cafeExportRegister("coreinit", OSInitRendezvous, LogType::CoreinitThreadSync);
+		cafeExportRegister("coreinit", OSWaitRendezvous, LogType::CoreinitThreadSync);
 
 		// OSMutex
-		cafeExportRegister("coreinit", OSInitMutex, LogType::ThreadSync);
-		cafeExportRegister("coreinit", OSInitMutexEx, LogType::ThreadSync);
-		cafeExportRegister("coreinit", OSLockMutex, LogType::ThreadSync);
-		cafeExportRegister("coreinit", OSTryLockMutex, LogType::ThreadSync);
-		cafeExportRegister("coreinit", OSUnlockMutex, LogType::ThreadSync);
+		cafeExportRegister("coreinit", OSInitMutex, LogType::CoreinitThreadSync);
+		cafeExportRegister("coreinit", OSInitMutexEx, LogType::CoreinitThreadSync);
+		cafeExportRegister("coreinit", OSLockMutex, LogType::CoreinitThreadSync);
+		cafeExportRegister("coreinit", OSTryLockMutex, LogType::CoreinitThreadSync);
+		cafeExportRegister("coreinit", OSUnlockMutex, LogType::CoreinitThreadSync);
 
 		// OSCond
-		cafeExportRegister("coreinit", OSInitCond, LogType::ThreadSync);
-		cafeExportRegister("coreinit", OSInitCondEx, LogType::ThreadSync);
-		cafeExportRegister("coreinit", OSSignalCond, LogType::ThreadSync);
-		cafeExportRegister("coreinit", OSWaitCond, LogType::ThreadSync);
+		cafeExportRegister("coreinit", OSInitCond, LogType::CoreinitThreadSync);
+		cafeExportRegister("coreinit", OSInitCondEx, LogType::CoreinitThreadSync);
+		cafeExportRegister("coreinit", OSSignalCond, LogType::CoreinitThreadSync);
+		cafeExportRegister("coreinit", OSWaitCond, LogType::CoreinitThreadSync);
 
 		// OSSemaphore
-		cafeExportRegister("coreinit", OSInitSemaphore, LogType::ThreadSync);
-		cafeExportRegister("coreinit", OSInitSemaphoreEx, LogType::ThreadSync);
-		cafeExportRegister("coreinit", OSWaitSemaphore, LogType::ThreadSync);
-		cafeExportRegister("coreinit", OSTryWaitSemaphore, LogType::ThreadSync);
-		cafeExportRegister("coreinit", OSSignalSemaphore, LogType::ThreadSync);
-		cafeExportRegister("coreinit", OSGetSemaphoreCount, LogType::ThreadSync);
+		cafeExportRegister("coreinit", OSInitSemaphore, LogType::CoreinitThreadSync);
+		cafeExportRegister("coreinit", OSInitSemaphoreEx, LogType::CoreinitThreadSync);
+		cafeExportRegister("coreinit", OSWaitSemaphore, LogType::CoreinitThreadSync);
+		cafeExportRegister("coreinit", OSTryWaitSemaphore, LogType::CoreinitThreadSync);
+		cafeExportRegister("coreinit", OSSignalSemaphore, LogType::CoreinitThreadSync);
+		cafeExportRegister("coreinit", OSGetSemaphoreCount, LogType::CoreinitThreadSync);
 
 		// OSFastMutex
-		cafeExportRegister("coreinit", OSFastMutex_Init, LogType::ThreadSync);
-		cafeExportRegister("coreinit", OSFastMutex_Lock, LogType::ThreadSync);
-		cafeExportRegister("coreinit", OSFastMutex_TryLock, LogType::ThreadSync);
-		cafeExportRegister("coreinit", OSFastMutex_Unlock, LogType::ThreadSync);
+		cafeExportRegister("coreinit", OSFastMutex_Init, LogType::CoreinitThreadSync);
+		cafeExportRegister("coreinit", OSFastMutex_Lock, LogType::CoreinitThreadSync);
+		cafeExportRegister("coreinit", OSFastMutex_TryLock, LogType::CoreinitThreadSync);
+		cafeExportRegister("coreinit", OSFastMutex_Unlock, LogType::CoreinitThreadSync);
 
 		// OSFastCond
-		cafeExportRegister("coreinit", OSFastCond_Init, LogType::ThreadSync);
-		cafeExportRegister("coreinit", OSFastCond_Wait, LogType::ThreadSync);
-		cafeExportRegister("coreinit", OSFastCond_Signal, LogType::ThreadSync);
+		cafeExportRegister("coreinit", OSFastCond_Init, LogType::CoreinitThreadSync);
+		cafeExportRegister("coreinit", OSFastCond_Wait, LogType::CoreinitThreadSync);
+		cafeExportRegister("coreinit", OSFastCond_Signal, LogType::CoreinitThreadSync);
 	}
 
 };
diff --git a/src/Cafe/OS/libs/coreinit/coreinit_SysHeap.cpp b/src/Cafe/OS/libs/coreinit/coreinit_SysHeap.cpp
index caa3d76d..2f819c50 100644
--- a/src/Cafe/OS/libs/coreinit/coreinit_SysHeap.cpp
+++ b/src/Cafe/OS/libs/coreinit/coreinit_SysHeap.cpp
@@ -14,13 +14,10 @@ namespace coreinit
 		return coreinit::MEMAllocFromExpHeapEx(_sysHeapHandle, size, alignment);
 	}
 
-	void export_OSAllocFromSystem(PPCInterpreter_t* hCPU)
+	void OSFreeToSystem(void* ptr)
 	{
-		ppcDefineParamU32(size, 0);
-		ppcDefineParamS32(alignment, 1);
-		MEMPTR<void> mem = OSAllocFromSystem(size, alignment);
-		forceLogDebug_printf("OSAllocFromSystem(0x%x, %d) -> 0x%08x", size, alignment, mem.GetMPTR());
-		osLib_returnFromFunction(hCPU, mem.GetMPTR());
+		_sysHeapFreeCounter++;
+		coreinit::MEMFreeToExpHeap(_sysHeapHandle, ptr);
 	}
 
 	void InitSysHeap()
@@ -34,7 +31,8 @@ namespace coreinit
 
 	void InitializeSysHeap()
 	{
-		osLib_addFunction("coreinit", "OSAllocFromSystem", export_OSAllocFromSystem);
+		cafeExportRegister("h264", OSAllocFromSystem, LogType::CoreinitMem);
+		cafeExportRegister("h264", OSFreeToSystem, LogType::CoreinitMem);
 	}
 
 }
diff --git a/src/Cafe/OS/libs/coreinit/coreinit_SysHeap.h b/src/Cafe/OS/libs/coreinit/coreinit_SysHeap.h
index 428224af..ad115754 100644
--- a/src/Cafe/OS/libs/coreinit/coreinit_SysHeap.h
+++ b/src/Cafe/OS/libs/coreinit/coreinit_SysHeap.h
@@ -4,5 +4,8 @@ namespace coreinit
 {
 	void InitSysHeap();
 
+	void* OSAllocFromSystem(uint32 size, uint32 alignment);
+	void OSFreeToSystem(void* ptr);
+
 	void InitializeSysHeap();
 }
\ No newline at end of file
diff --git a/src/Cafe/OS/libs/coreinit/coreinit_Thread.cpp b/src/Cafe/OS/libs/coreinit/coreinit_Thread.cpp
index e01fda73..2f89000b 100644
--- a/src/Cafe/OS/libs/coreinit/coreinit_Thread.cpp
+++ b/src/Cafe/OS/libs/coreinit/coreinit_Thread.cpp
@@ -5,6 +5,7 @@
 #include "Cafe/OS/libs/coreinit/coreinit_Time.h"
 #include "Cafe/OS/libs/coreinit/coreinit_Alarm.h"
 #include "Cafe/OS/libs/snd_core/ax.h"
+#include "Cafe/HW/Espresso/Debugger/GDBStub.h"
 #include "Cafe/HW/Espresso/Interpreter/PPCInterpreterInternal.h"
 #include "Cafe/HW/Espresso/Recompiler/PPCRecompiler.h"
 
@@ -20,13 +21,15 @@ SlimRWLock srwlock_activeThreadList;
 MPTR activeThread[256];
 sint32 activeThreadCount = 0;
 
-MPTR exitThreadPtr = 0;
-
 void nnNfp_update();
 
 namespace coreinit
 {
+#ifdef __arm64__
+	void __OSFiberThreadEntry(uint32, uint32);
+#else
 	void __OSFiberThreadEntry(void* thread);
+#endif
 	void __OSAddReadyThreadToRunQueue(OSThread_t* thread);
 	void __OSRemoveThreadFromRunQueues(OSThread_t* thread);
 };
@@ -50,13 +53,11 @@ namespace coreinit
 
 	struct OSHostThread
 	{
-		OSHostThread(OSThread_t* thread) : m_thread(thread), m_fiber(__OSFiberThreadEntry, this, this)
+		OSHostThread(OSThread_t* thread) : m_thread(thread), m_fiber((void(*)(void*))__OSFiberThreadEntry, this, this)
 		{
 		}
 
-		~OSHostThread()
-		{
-		}
+		~OSHostThread() = default;
 
 		OSThread_t* m_thread;
 		Fiber m_fiber;
@@ -68,6 +69,11 @@ namespace coreinit
 
 	std::unordered_map<OSThread_t*, OSHostThread*> s_threadToFiber;
 
+	bool __CemuIsMulticoreMode()
+	{
+		return g_isMulticoreMode;
+	}
+
 	// create host thread (fiber) that will be used to run the PPC instance
 	// note that host threads are fibers and not actual threads
 	void __OSCreateHostThread(OSThread_t* thread)
@@ -195,11 +201,9 @@ namespace coreinit
 		return __currentCoreThread[currentInstance->spr.UPIR];
 	}
 
-	MPTR funcPtr_threadEntry = 0;
-
 	void threadEntry(PPCInterpreter_t* hCPU)
 	{
-		OSThread_t* currentThread = coreinitThread_getCurrentThreadDepr(hCPU);
+		OSThread_t* currentThread = coreinit::OSGetCurrentThread();
 		uint32 r3 = hCPU->gpr[3];
 		uint32 r4 = hCPU->gpr[4];
 		uint32 lr = hCPU->spr.LR;
@@ -215,27 +219,178 @@ namespace coreinit
 		hCPU->spr.LR = lr;
 		hCPU->gpr[3] = r3;
 		hCPU->gpr[4] = r4;
-		hCPU->instructionPointer = _swapEndianU32(currentThread->entrypoint);
+		hCPU->instructionPointer = currentThread->entrypoint.GetMPTR();
 	}
 
 	void coreinitExport_OSExitThreadDepr(PPCInterpreter_t* hCPU);
 
-	void initFunctionPointers()
+	void __OSInitContext(OSContext_t* ctx, MEMPTR<void> initialIP, MEMPTR<void> initialStackPointer)
 	{
-		exitThreadPtr = PPCInterpreter_makeCallableExportDepr(coreinitExport_OSExitThreadDepr);
-		funcPtr_threadEntry = PPCInterpreter_makeCallableExportDepr(threadEntry);
+		ctx->SetContextMagic();
+		ctx->gpr[0] = 0; // r0 is left uninitialized on console?
+		for(auto& it : ctx->gpr)
+			it = 0;
+		ctx->gpr[1] = _swapEndianU32(initialStackPointer.GetMPTR());
+		ctx->gpr[2] = _swapEndianU32(RPLLoader_GetSDA2Base());
+		ctx->gpr[13] = _swapEndianU32(RPLLoader_GetSDA1Base());
+		ctx->srr0 = initialIP.GetMPTR();
+		ctx->cr = 0;
+		ctx->ukn0A8 = 0;
+		ctx->ukn0AC = 0;
+		ctx->gqr[0] = 0;
+		ctx->gqr[1] = 0;
+		ctx->gqr[2] = 0;
+		ctx->gqr[3] = 0;
+		ctx->gqr[4] = 0;
+		ctx->gqr[5] = 0;
+		ctx->gqr[6] = 0;
+		ctx->gqr[7] = 0;
+		ctx->dsi_dar = 0;
+		ctx->srr1 = 0x9032;
+		ctx->xer = 0;
+		ctx->dsi_dsisr = 0;
+		ctx->upir = 0;
+		ctx->boostCount = 0;
+		ctx->state = 0;
+		for(auto& it : ctx->coretime)
+			it = 0;
+		ctx->starttime = 0;
+		ctx->ghs_errno = 0;
+		ctx->upmc1 = 0;
+		ctx->upmc2 = 0;
+		ctx->upmc3 = 0;
+		ctx->upmc4 = 0;
+		ctx->ummcr0 = 0;
+		ctx->ummcr1 = 0;
 	}
 
-	void OSCreateThreadInternal(OSThread_t* thread, uint32 entryPoint, MPTR stackLowerBaseAddr, uint32 stackSize, uint8 affinityMask, OSThread_t::THREAD_TYPE threadType)
+	void __OSThreadInit(OSThread_t* thread, MEMPTR<void> entrypoint, uint32 argInt, MEMPTR<void> argPtr, MEMPTR<void> stackTop, uint32 stackSize, sint32 priority, uint32 upirCoreIndex, OSThread_t::THREAD_TYPE threadType)
+	{
+		thread->effectivePriority = priority;
+		thread->type = threadType;
+		thread->basePriority = priority;
+		thread->SetThreadMagic();
+		thread->id = 0x8000;
+		thread->waitAlarm = nullptr;
+		thread->entrypoint = entrypoint;
+		thread->quantumTicks = 0;
+		if(entrypoint)
+		{
+			thread->state = OSThread_t::THREAD_STATE::STATE_READY;
+			thread->suspendCounter = 1;
+		}
+		else
+		{
+			thread->state = OSThread_t::THREAD_STATE::STATE_NONE;
+			thread->suspendCounter = 0;
+		}
+		thread->exitValue = (uint32)-1;
+		thread->requestFlags = OSThread_t::REQUEST_FLAG_BIT::REQUEST_FLAG_NONE;
+		thread->pendingSuspend = 0;
+		thread->suspendResult = 0xFFFFFFFF;
+		thread->coretimeSumQuantumStart = 0;
+		thread->deallocatorFunc = nullptr;
+		thread->cleanupCallback = nullptr;
+		thread->waitingForFastMutex = nullptr;
+		thread->stateFlags = 0;
+		thread->waitingForMutex = nullptr;
+		memset(&thread->crt, 0, sizeof(thread->crt));
+		static_assert(sizeof(thread->crt) == 0x1D8);
+		thread->tlsBlocksMPTR = 0;
+		thread->numAllocatedTLSBlocks = 0;
+		thread->tlsStatus = 0;
+		OSInitThreadQueueEx(&thread->joinQueue, thread);
+		OSInitThreadQueueEx(&thread->suspendQueue, thread);
+		thread->mutexQueue.ukn08 = thread;
+		thread->mutexQueue.ukn0C = 0;
+		thread->mutexQueue.tail = nullptr;
+		thread->mutexQueue.head = nullptr;
+		thread->ownedFastMutex.next = nullptr;
+		thread->ownedFastMutex.prev = nullptr;
+		thread->contendedFastMutex.next = nullptr;
+		thread->contendedFastMutex.prev = nullptr;
+
+		MEMPTR<void> alignedStackTop{MEMPTR<void>(stackTop).GetMPTR() & 0xFFFFFFF8};
+		MEMPTR<uint32be> alignedStackTop32{alignedStackTop};
+		alignedStackTop32[-1] = 0;
+		alignedStackTop32[-2] = 0;
+
+		__OSInitContext(&thread->context, MEMPTR<void>(PPCInterpreter_makeCallableExportDepr(threadEntry)), (void*)(alignedStackTop32.GetPtr() - 2));
+		thread->stackBase = stackTop; // without alignment
+		thread->stackEnd = ((uint8*)stackTop.GetPtr() - stackSize);
+		thread->context.upir = upirCoreIndex;
+		thread->context.lr = _swapEndianU32(PPCInterpreter_makeCallableExportDepr(coreinitExport_OSExitThreadDepr));
+		thread->context.gpr[3] = _swapEndianU32(argInt);
+		thread->context.gpr[4] = _swapEndianU32(argPtr.GetMPTR());
+
+		*(uint32be*)((uint8*)stackTop.GetPtr() - stackSize) = 0xDEADBABE;
+		thread->alarmRelatedUkn = 0;
+		for(auto& it : thread->specificArray)
+			it = nullptr;
+		thread->context.fpscr.fpscr = 4;
+		for(sint32 i=0; i<32; i++)
+		{
+			thread->context.fp_ps0[i] = 0.0;
+			thread->context.fp_ps1[i] = 0.0;
+		}
+		thread->context.gqr[2] = 0x40004;
+		thread->context.gqr[3] = 0x50005;
+		thread->context.gqr[4] = 0x60006;
+		thread->context.gqr[5] = 0x70007;
+
+		for(sint32 i=0; i<Espresso::CORE_COUNT; i++)
+			thread->context.coretime[i] = 0;
+
+		// currentRunQueue and waitQueueLink is not initialized by COS and instead overwritten without validation
+		// since we already have integrity checks in other functions, lets initialize it here
+		for(sint32 i=0; i<Espresso::CORE_COUNT; i++)
+			thread->currentRunQueue[i] = nullptr;
+		thread->waitQueueLink.prev = nullptr;
+		thread->waitQueueLink.next = nullptr;
+
+		thread->wakeTimeRelatedUkn2 = 0;
+		thread->wakeUpCount = 0;
+		thread->wakeUpTime = 0;
+		thread->wakeTimeRelatedUkn1 = 0x7FFFFFFFFFFFFFFF;
+		thread->quantumTicks = 0;
+		thread->coretimeSumQuantumStart = 0;
+		thread->totalCycles = 0;
+
+		for(auto& it : thread->padding68C)
+			it = 0;
+	}
+
+	void SetThreadAffinityToCore(OSThread_t* thread, uint32 coreIndex)
+	{
+		cemu_assert_debug(coreIndex < 3);
+		thread->attr &= ~(OSThread_t::ATTR_BIT::ATTR_AFFINITY_CORE0 | OSThread_t::ATTR_BIT::ATTR_AFFINITY_CORE1 | OSThread_t::ATTR_BIT::ATTR_AFFINITY_CORE2 | OSThread_t::ATTR_BIT::ATTR_UKN_010);
+		thread->context.affinity &= 0xFFFFFFF8;
+		if (coreIndex == 0)
+		{
+			thread->attr |= OSThread_t::ATTR_BIT::ATTR_AFFINITY_CORE0;
+			thread->context.affinity |= (1<<0);
+		}
+		else if (coreIndex == 1)
+		{
+			thread->attr |= OSThread_t::ATTR_BIT::ATTR_AFFINITY_CORE1;
+			thread->context.affinity |= (1<<1);
+		}
+		else // if (coreIndex == 2)
+		{
+			thread->attr |= OSThread_t::ATTR_BIT::ATTR_AFFINITY_CORE2;
+			thread->context.affinity |= (1<<2);
+		}
+	}
+
+	void __OSCreateThreadOnActiveThreadWorkaround(OSThread_t* thread)
 	{
-		cemu_assert_debug(thread != nullptr); // make thread struct mandatory. Caller can always use SysAllocator
 		__OSLockScheduler();
 		bool isThreadStillActive = __OSIsThreadActive(thread);
 		if (isThreadStillActive)
 		{
-			// workaround for games that restart threads to quickly
+			// workaround for games that restart threads before they correctly entered stopped/moribund state
 			// seen in Fast Racing Neo at boot (0x020617BC OSCreateThread)
-			forceLog_printf("Game attempting to re-initialize existing thread");
+			cemuLog_log(LogType::Force, "Game attempting to re-initialize existing thread");
 			while ((thread->state == OSThread_t::THREAD_STATE::STATE_READY || thread->state == OSThread_t::THREAD_STATE::STATE_RUNNING) && thread->suspendCounter == 0)
 			{
 				// wait for thread to finish
@@ -245,7 +400,7 @@ namespace coreinit
 			}
 			if (__OSIsThreadActive(thread) && thread->state == OSThread_t::THREAD_STATE::STATE_MORIBUND)
 			{
-				forceLog_printf("Calling OSCreateThread() on thread which is still active (Thread exited without detached flag). Forcing OSDetachThread()...");
+				cemuLog_log(LogType::Force, "Calling OSCreateThread() on thread which is still active (Thread exited without detached flag). Forcing OSDetachThread()...");
 				__OSUnlockScheduler();
 				OSDetachThread(thread);
 				__OSLockScheduler();
@@ -254,96 +409,109 @@ namespace coreinit
 		}
 		cemu_assert_debug(__OSIsThreadActive(thread) == false);
 		__OSUnlockScheduler();
-
-		initFunctionPointers();
-		if (thread == nullptr)
-			thread = (OSThread_t*)memory_getPointerFromVirtualOffset(coreinit_allocFromSysArea(sizeof(OSThread_t), 32));
-		memset(thread, 0x00, sizeof(OSThread_t));
-		// init signatures
-		thread->context.magic0 = OS_CONTEXT_MAGIC_0;
-		thread->context.magic1 = OS_CONTEXT_MAGIC_1;
-		thread->magic = 'tHrD';
-		thread->type = threadType;
-		thread->state = (entryPoint != MPTR_NULL) ? OSThread_t::THREAD_STATE::STATE_READY : OSThread_t::THREAD_STATE::STATE_NONE;
-		thread->entrypoint = _swapEndianU32(entryPoint);
-		__OSSetThreadBasePriority(thread, 0);
-		__OSUpdateThreadEffectivePriority(thread);
-		// untested, but seems to work (Batman Arkham City uses these values to calculate the stack size for duplicated threads)
-		thread->stackBase = _swapEndianU32(stackLowerBaseAddr + stackSize); // these fields are quite important and lots of games rely on them being accurate (Examples: Darksiders 2, SMW3D, Batman Arkham City)
-		thread->stackEnd = _swapEndianU32(stackLowerBaseAddr);
-		// init stackpointer
-		thread->context.gpr[GPR_SP] = _swapEndianU32(stackLowerBaseAddr + stackSize - 0x20); // how many free bytes should there be at the beginning of the stack?
-		// init misc stuff
-		thread->attr = affinityMask;
-		thread->context.setAffinity(affinityMask);
-		thread->context.srr0 = funcPtr_threadEntry;
-		thread->context.lr = _swapEndianU32(exitThreadPtr);
-		thread->id = 0x8000; // Warriors Orochi 3 softlocks if this is zero due to confusing threads (_OSActivateThread should set this?)
-		// init ugqr
-		thread->context.gqr[0] = 0x00000000;
-		thread->context.gqr[1] = 0x00000000;
-		thread->context.gqr[2] = 0x00040004;
-		thread->context.gqr[3] = 0x00050005;
-		thread->context.gqr[4] = 0x00060006;
-		thread->context.gqr[5] = 0x00070007;
-		thread->context.gqr[6] = 0x00000000;
-		thread->context.gqr[7] = 0x00000000;
-		// init r2 (SDA2) and r3 (SDA)
-		thread->context.gpr[2] = _swapEndianU32(RPLLoader_GetSDA2Base());
-		thread->context.gpr[13] = _swapEndianU32(RPLLoader_GetSDA1Base());
-		// GHS related thread init?
-
-		__OSLockScheduler();
-		// if entrypoint is non-zero then put the thread on the active list and suspend it
-		if (entryPoint != MPTR_NULL)
-		{
-			thread->suspendCounter = 1;
-			__OSActivateThread(thread);
-			thread->state = OSThread_t::THREAD_STATE::STATE_READY;
-		}
-		else
-			thread->suspendCounter = 0;
-		__OSUnlockScheduler();
 	}
 
-	bool OSCreateThreadType(OSThread_t* thread, MPTR entryPoint, sint32 numParam, void* ptrParam, void* stackTop2, sint32 stackSize, sint32 priority, uint32 attr, OSThread_t::THREAD_TYPE threadType)
+	bool __OSCreateThreadInternal2(OSThread_t* thread, MEMPTR<void> entrypoint, uint32 argInt, MEMPTR<void> argPtr, MEMPTR<void> stackBase, uint32 stackSize, sint32 priority, uint32 attrBits, OSThread_t::THREAD_TYPE threadType)
 	{
-		OSCreateThreadInternal(thread, entryPoint, memory_getVirtualOffsetFromPointer(stackTop2) - stackSize, stackSize, attr, threadType);
-		thread->context.gpr[3] = _swapEndianU32(numParam); // num arguments
-		thread->context.gpr[4] = _swapEndianU32(memory_getVirtualOffsetFromPointer(ptrParam)); // arguments pointer
-		__OSSetThreadBasePriority(thread, priority);
-		__OSUpdateThreadEffectivePriority(thread);
-		// set affinity
-		uint8 affinityMask = 0;
-		affinityMask = attr & 0x7;
-		// if no core is selected -> set current one
-		if (affinityMask == 0)
-			affinityMask |= (1 << PPCInterpreter_getCoreIndex(ppcInterpreterCurrentInstance));
-		// set attr
-		// todo: Support for other attr bits
-		thread->attr = (affinityMask & 0xFF) | (attr & OSThread_t::ATTR_BIT::ATTR_DETACHED);
-		thread->context.setAffinity(affinityMask);
+		__OSCreateThreadOnActiveThreadWorkaround(thread);
+		OSThread_t* currentThread = OSGetCurrentThread();
+		if (priority < 0 || priority >= 32)
+		{
+			cemuLog_log(LogType::APIErrors, "OSCreateThreadInternal: Thread priority must be in range 0-31");
+			return false;
+		}
+		if (threadType == OSThread_t::THREAD_TYPE::TYPE_IO)
+		{
+			priority = priority + 0x20;
+		}
+		else if (threadType == OSThread_t::THREAD_TYPE::TYPE_APP)
+		{
+			priority = priority + 0x40;
+		}
+		if(attrBits >= 0x20 || stackBase == nullptr || stackSize == 0)
+		{
+			cemuLog_logDebug(LogType::APIErrors, "OSCreateThreadInternal: Invalid attributes, stack base or size");
+			return false;
+		}
+		uint32 im = OSDisableInterrupts();
+		__OSLockScheduler(thread);
+
+		uint32 coreIndex = PPCInterpreter_getCurrentInstance() ? OSGetCoreId() : 1;
+		__OSThreadInit(thread, entrypoint, argInt, argPtr, stackBase, stackSize, priority, coreIndex, threadType);
+		thread->threadName = nullptr;
+		thread->context.affinity = attrBits & 7;
+		thread->attr = attrBits;
+		if ((attrBits & 7) == 0) // if no explicit affinity is given, use the current core
+			SetThreadAffinityToCore(thread, OSGetCoreId());
+		if(currentThread)
+		{
+			for(sint32 i=0; i<Espresso::CORE_COUNT; i++)
+			{
+				thread->dsiCallback[i] = currentThread->dsiCallback[i];
+				thread->isiCallback[i] = currentThread->isiCallback[i];
+				thread->programCallback[i] = currentThread->programCallback[i];
+				thread->perfMonCallback[i] = currentThread->perfMonCallback[i];
+				thread->alignmentExceptionCallback[i] = currentThread->alignmentExceptionCallback[i];
+			}
+			thread->context.srr1 = thread->context.srr1 | (currentThread->context.srr1 & 0x900);
+			thread->context.fpscr.fpscr = thread->context.fpscr.fpscr | (currentThread->context.fpscr.fpscr & 0xF8);
+		}
+		else
+		{
+			for(sint32 i=0; i<Espresso::CORE_COUNT; i++)
+			{
+				thread->dsiCallback[i] = 0;
+				thread->isiCallback[i] = 0;
+				thread->programCallback[i] = 0;
+				thread->perfMonCallback[i] = 0;
+				thread->alignmentExceptionCallback[i] = nullptr;
+			}
+		}
+		if (entrypoint)
+		{
+			thread->id = 0x8000;
+			__OSActivateThread(thread); // also handles adding the thread to g_activeThreadQueue
+		}
+		__OSUnlockScheduler(thread);
+		OSRestoreInterrupts(im);
 		// recompile entry point function
-		if (entryPoint != MPTR_NULL)
-			PPCRecompiler_recompileIfUnvisited(entryPoint);
+		if (entrypoint)
+			PPCRecompiler_recompileIfUnvisited(entrypoint.GetMPTR());
 		return true;
 	}
 
-	bool OSCreateThread(OSThread_t* thread, MPTR entryPoint, sint32 numParam, void* ptrParam, void* stackTop2, sint32 stackSize, sint32 priority, uint32 attr)
+	bool OSCreateThreadType(OSThread_t* thread, MPTR entryPoint, sint32 numParam, void* ptrParam, void* stackTop, sint32 stackSize, sint32 priority, uint32 attr, OSThread_t::THREAD_TYPE threadType)
 	{
-		return OSCreateThreadType(thread, entryPoint, numParam, ptrParam, stackTop2, stackSize, priority, attr, OSThread_t::THREAD_TYPE::TYPE_APP);
+		if(threadType != OSThread_t::THREAD_TYPE::TYPE_APP && threadType != OSThread_t::THREAD_TYPE::TYPE_IO)
+		{
+			cemuLog_logDebug(LogType::APIErrors, "OSCreateThreadType: Invalid thread type");
+			cemu_assert_suspicious();
+			return false;
+		}
+		return __OSCreateThreadInternal2(thread, MEMPTR<void>(entryPoint), numParam, ptrParam, stackTop, stackSize, priority, attr, threadType);
+	}
+
+	bool OSCreateThread(OSThread_t* thread, MPTR entryPoint, sint32 numParam, void* ptrParam, void* stackTop, sint32 stackSize, sint32 priority, uint32 attr)
+	{
+		return __OSCreateThreadInternal2(thread, MEMPTR<void>(entryPoint), numParam, ptrParam, stackTop, stackSize, priority, attr, OSThread_t::THREAD_TYPE::TYPE_APP);
+	}
+
+	// similar to OSCreateThreadType, but can be used to create any type of thread
+	bool __OSCreateThreadType(OSThread_t* thread, MPTR entryPoint, sint32 numParam, void* ptrParam, void* stackTop, sint32 stackSize, sint32 priority, uint32 attr, OSThread_t::THREAD_TYPE threadType)
+	{
+		return __OSCreateThreadInternal2(thread, MEMPTR<void>(entryPoint), numParam, ptrParam, stackTop, stackSize, priority, attr, threadType);
 	}
 
 	bool OSRunThread(OSThread_t* thread, MPTR funcAddress, sint32 numParam, void* ptrParam)
 	{
 		__OSLockScheduler();
 
-		cemu_assert_debug(ppcInterpreterCurrentInstance == nullptr || OSGetCurrentThread() != thread); // called on self, what should this function do?
+		cemu_assert_debug(PPCInterpreter_getCurrentInstance() == nullptr || OSGetCurrentThread() != thread); // called on self, what should this function do?
 
 		if (thread->state != OSThread_t::THREAD_STATE::STATE_NONE && thread->state != OSThread_t::THREAD_STATE::STATE_MORIBUND)
 		{
 			// unsure about this case
-			forceLogDebug_printf("OSRunThread called on thread which cannot be ran");
+			cemuLog_logDebug(LogType::Force, "OSRunThread called on thread which cannot be ran");
 			__OSUnlockScheduler();
 			return false;
 		}
@@ -358,9 +526,9 @@ namespace coreinit
 		// set thread state
 		// todo - this should fully reinitialize the thread?
 
-		thread->entrypoint = _swapEndianU32(funcAddress);
-		thread->context.srr0 = coreinit::funcPtr_threadEntry;
-		thread->context.lr = _swapEndianU32(exitThreadPtr);
+		thread->entrypoint = funcAddress;
+		thread->context.srr0 = PPCInterpreter_makeCallableExportDepr(threadEntry);
+		thread->context.lr = _swapEndianU32(PPCInterpreter_makeCallableExportDepr(coreinitExport_OSExitThreadDepr));
 		thread->context.gpr[3] = _swapEndianU32(numParam);
 		thread->context.gpr[4] = _swapEndianU32(memory_getVirtualOffsetFromPointer(ptrParam));
 		thread->suspendCounter = 0;	// verify
@@ -381,39 +549,38 @@ namespace coreinit
 	{
 		PPCInterpreter_t* hCPU = PPCInterpreter_getCurrentInstance();
 		hCPU->gpr[3] = exitValue;
-		OSThread_t* threadBE = coreinitThread_getCurrentThreadDepr(hCPU);
-		MPTR t = memory_getVirtualOffsetFromPointer(threadBE);
+		OSThread_t* currentThread = coreinit::OSGetCurrentThread();
 
 		// thread cleanup callback
-		if (!threadBE->cleanupCallback2.IsNull())
+		if (currentThread->cleanupCallback)
 		{
-			threadBE->stateFlags = _swapEndianU32(_swapEndianU32(threadBE->stateFlags) | 0x00000001);
-			PPCCoreCallback(threadBE->cleanupCallback2.GetMPTR(), threadBE, _swapEndianU32(threadBE->stackEnd));
+			currentThread->stateFlags = _swapEndianU32(_swapEndianU32(currentThread->stateFlags) | 0x00000001);
+			PPCCoreCallback(currentThread->cleanupCallback.GetMPTR(), currentThread, currentThread->stackEnd);
 		}
 		// cpp exception cleanup
-		if (gCoreinitData->__cpp_exception_cleanup_ptr != 0 && threadBE->crt.eh_globals != nullptr)
+		if (gCoreinitData->__cpp_exception_cleanup_ptr != 0 && currentThread->crt.eh_globals != nullptr)
 		{
-			PPCCoreCallback(_swapEndianU32(gCoreinitData->__cpp_exception_cleanup_ptr), &threadBE->crt.eh_globals);
-			threadBE->crt.eh_globals = nullptr;
+			PPCCoreCallback(_swapEndianU32(gCoreinitData->__cpp_exception_cleanup_ptr), &currentThread->crt.eh_globals);
+			currentThread->crt.eh_globals = nullptr;
 		}
 		// set exit code
-		threadBE->exitValue = exitValue;
+		currentThread->exitValue = exitValue;
 
 		__OSLockScheduler();
 
 		// release held synchronization primitives
-		if (!threadBE->mutexQueue.isEmpty())
+		if (!currentThread->mutexQueue.isEmpty())
 		{
-			cemuLog_force("OSExitThread: Thread is holding mutexes");
+			cemuLog_log(LogType::Force, "OSExitThread: Thread is holding mutexes");
 			while (true)
 			{
-				OSMutex* mutex = threadBE->mutexQueue.getFirst();
+				OSMutex* mutex = currentThread->mutexQueue.getFirst();
 				if (!mutex)
 					break;
-				if (mutex->owner != threadBE)
+				if (mutex->owner != currentThread)
 				{
-					cemuLog_force("OSExitThread: Thread is holding mutex which it doesn't own");
-					threadBE->mutexQueue.removeMutex(mutex);
+					cemuLog_log(LogType::Force, "OSExitThread: Thread is holding mutex which it doesn't own");
+					currentThread->mutexQueue.removeMutex(mutex);
 					continue;
 				}
 				coreinit::OSUnlockMutexInternal(mutex);
@@ -422,22 +589,22 @@ namespace coreinit
 		// todo - release all fast mutexes
 
 		// handle join queue
-		if (!threadBE->joinQueue.isEmpty())
-			threadBE->joinQueue.wakeupEntireWaitQueue(false);
+		if (!currentThread->joinQueue.isEmpty())
+			currentThread->joinQueue.wakeupEntireWaitQueue(false);
 	
-		if ((threadBE->attr & 8) != 0)
+		if ((currentThread->attr & 8) != 0)
 		{
 			// deactivate thread since it is detached
-			threadBE->state = OSThread_t::THREAD_STATE::STATE_NONE;
-			coreinit::__OSDeactivateThread(threadBE);
+			currentThread->state = OSThread_t::THREAD_STATE::STATE_NONE;
+			coreinit::__OSDeactivateThread(currentThread);
 			// queue call to thread deallocator if set
-			if (!threadBE->deallocatorFunc.IsNull())
-				__OSQueueThreadDeallocation(threadBE);
+			if (!currentThread->deallocatorFunc.IsNull())
+				__OSQueueThreadDeallocation(currentThread);
 		}
 		else
 		{
 			// non-detached threads remain active
-			threadBE->state = OSThread_t::THREAD_STATE::STATE_MORIBUND;
+			currentThread->state = OSThread_t::THREAD_STATE::STATE_MORIBUND;
 		}
 		PPCCore_switchToSchedulerWithLock();
 	}
@@ -458,12 +625,12 @@ namespace coreinit
 		return currentThread->specificArray[index].GetPtr();
 	}
 
-	void OSSetThreadName(OSThread_t* thread, char* name)
+	void OSSetThreadName(OSThread_t* thread, const char* name)
 	{
 		thread->threadName = name;
 	}
 
-	char* OSGetThreadName(OSThread_t* thread)
+	const char* OSGetThreadName(OSThread_t* thread)
 	{
 		return thread->threadName.GetPtr();
 	}
@@ -492,7 +659,7 @@ namespace coreinit
 		StackAllocator<OSThreadQueue> _threadQueue;
 		OSInitThreadQueue(_threadQueue.GetPointer());
 		__OSLockScheduler();
-		OSHostAlarm* hostAlarm = OSHostAlarmCreate(coreinit_getOSTime() + ticks, 0, _OSSleepTicks_alarmHandler, _threadQueue.GetPointer());
+		OSHostAlarm* hostAlarm = OSHostAlarmCreate(OSGetTime() + ticks, 0, _OSSleepTicks_alarmHandler, _threadQueue.GetPointer());
 		_threadQueue.GetPointer()->queueAndWait(OSGetCurrentThread());
 		OSHostAlarmDestroy(hostAlarm);
 		__OSUnlockScheduler();
@@ -533,7 +700,7 @@ namespace coreinit
 		else if (thread->state != OSThread_t::THREAD_STATE::STATE_MORIBUND)
 		{
 			// cannot join detached and active threads
-			forceLogDebug_printf("Cannot join detached active thread");
+			cemuLog_logDebug(LogType::Force, "Cannot join detached active thread");
 			__OSUnlockScheduler();
 			return false;
 		}
@@ -550,7 +717,10 @@ namespace coreinit
 		thread->id = 0x8000;
 
 		if (!thread->deallocatorFunc.IsNull())
+		{
 			__OSQueueThreadDeallocation(thread);
+			PPCCore_switchToSchedulerWithLock(); // make sure the deallocation function runs before we return
+		}
 
 		__OSUnlockScheduler();
 
@@ -560,7 +730,10 @@ namespace coreinit
 	// adds the thread to each core's run queue if in runable state
 	void __OSAddReadyThreadToRunQueue(OSThread_t* thread)
 	{
+        cemu_assert_debug(MMU_IsInPPCMemorySpace(thread));
+        cemu_assert_debug(thread->IsValidMagic());
 		cemu_assert_debug(__OSHasSchedulerLock());
+
 		if (thread->state != OSThread_t::THREAD_STATE::STATE_READY)
 			return;
 		if (thread->suspendCounter != 0)
@@ -592,11 +765,16 @@ namespace coreinit
 	}
 
 	// returns true if thread runs on same core and has higher priority
-	bool __OSCoreShouldSwitchToThread(OSThread_t* currentThread, OSThread_t* newThread)
+	bool __OSCoreShouldSwitchToThread(OSThread_t* currentThread, OSThread_t* newThread, bool sharedPriorityAndAffinityWorkaround)
 	{
 		uint32 coreIndex = OSGetCoreId();
 		if (!newThread->context.hasCoreAffinitySet(coreIndex))
 			return false;
+		// special case: if current and new thread are running only on the same core then reschedule even if priority is equal
+		// this resolves a deadlock in Just Dance 2019 where one thread would always reacquire the same mutex within it's timeslice, blocking another thread on the same core from acquiring it
+		if (sharedPriorityAndAffinityWorkaround && (1<<coreIndex) == newThread->context.affinity && currentThread->context.affinity == newThread->context.affinity && currentThread->effectivePriority == newThread->effectivePriority)
+			return true;
+		// otherwise reschedule if new thread has higher priority
 		return newThread->effectivePriority < currentThread->effectivePriority;
 	}
 
@@ -606,7 +784,10 @@ namespace coreinit
 		sint32 previousSuspendCount = thread->suspendCounter;
 		cemu_assert_debug(previousSuspendCount >= 0);
 		if (previousSuspendCount == 0)
+		{
+			cemuLog_log(LogType::APIErrors, "OSResumeThread: Resuming thread 0x{:08x} which isn't suspended", MEMPTR<OSThread_t>(thread).GetMPTR());
 			return 0;
+		}
 		thread->suspendCounter = previousSuspendCount - resumeCount;
 		if (thread->suspendCounter < 0)
 			thread->suspendCounter = 0;
@@ -617,7 +798,7 @@ namespace coreinit
 			// todo - only set this once?
 			thread->wakeUpTime = PPCInterpreter_getMainCoreCycleCounter();
 			// reschedule if thread has higher priority
-			if (ppcInterpreterCurrentInstance && __OSCoreShouldSwitchToThread(coreinit::OSGetCurrentThread(), thread))
+			if (PPCInterpreter_getCurrentInstance() && __OSCoreShouldSwitchToThread(coreinit::OSGetCurrentThread(), thread, false))
 				PPCCore_switchToSchedulerWithLock();
 		}
 		return previousSuspendCount;
@@ -668,6 +849,11 @@ namespace coreinit
 		__OSUnlockScheduler();
 	}
 
+    void __OSSuspendThreadNolock(OSThread_t* thread)
+    {
+        __OSSuspendThreadInternal(thread);
+    }
+
 	void OSSleepThread(OSThreadQueue* threadQueue)
 	{
 		__OSLockScheduler();
@@ -695,10 +881,18 @@ namespace coreinit
 		}
 		else if (prevAffinityMask != affinityMask)
 		{
-			__OSRemoveThreadFromRunQueues(thread);
-			thread->attr = (thread->attr & ~7) | (affinityMask & 7);
-			thread->context.setAffinity(affinityMask);
-			__OSAddReadyThreadToRunQueue(thread);
+            if(thread->state != OSThread_t::THREAD_STATE::STATE_NONE)
+            {
+                __OSRemoveThreadFromRunQueues(thread);
+                thread->attr = (thread->attr & ~7) | (affinityMask & 7);
+                thread->context.setAffinity(affinityMask);
+                __OSAddReadyThreadToRunQueue(thread);
+            }
+            else
+            {
+                thread->attr = (thread->attr & ~7) | (affinityMask & 7);
+                thread->context.setAffinity(affinityMask);
+            }
 		}
 		__OSUnlockScheduler();
 		return true;
@@ -723,8 +917,8 @@ namespace coreinit
 	void* OSSetThreadCleanupCallback(OSThread_t* thread, void* cleanupCallback)
 	{
 		__OSLockScheduler();
-		void* previousFunc = thread->cleanupCallback2.GetPtr();
-		thread->cleanupCallback2 = cleanupCallback;
+		void* previousFunc = thread->cleanupCallback.GetPtr();
+		thread->cleanupCallback = cleanupCallback;
 		__OSUnlockScheduler();
 		return previousFunc;
 	}
@@ -761,7 +955,7 @@ namespace coreinit
 		OSThread_t* currentThread = OSGetCurrentThread();
 		if (currentThread && currentThread != thread)
 		{
-			if (__OSCoreShouldSwitchToThread(currentThread, thread))
+			if (__OSCoreShouldSwitchToThread(currentThread, thread, false))
 				PPCCore_switchToSchedulerWithLock();
 		}
 		__OSUnlockScheduler();
@@ -795,7 +989,22 @@ namespace coreinit
 		return suspendCounter > 0;
 	}
 
-	void OSCancelThread(OSThread_t* thread)
+    bool OSIsThreadRunningNoLock(OSThread_t* thread)
+    {
+        cemu_assert_debug(__OSHasSchedulerLock());
+        return thread->state == OSThread_t::THREAD_STATE::STATE_RUNNING;
+    }
+
+    bool OSIsThreadRunning(OSThread_t* thread)
+    {
+        bool isRunning = false;
+        __OSLockScheduler();
+        isRunning = OSIsThreadRunningNoLock(thread);
+        __OSUnlockScheduler();
+        return isRunning;
+    }
+
+    void OSCancelThread(OSThread_t* thread)
 	{
 		__OSLockScheduler();
 		cemu_assert_debug(thread->requestFlags == 0 || thread->requestFlags == OSThread_t::REQUEST_FLAG_CANCEL); // todo - how to handle cases where other flags are already set?
@@ -912,17 +1121,17 @@ namespace coreinit
 		thread->requestFlags = (OSThread_t::REQUEST_FLAG_BIT)(thread->requestFlags & OSThread_t::REQUEST_FLAG_CANCEL); // remove all flags except cancel flag
 
 		// update total cycles
-		uint64 remainingCycles = std::min((uint64)ppcInterpreterCurrentInstance->remainingCycles, (uint64)thread->quantumTicks);
-		uint64 executedCycles = thread->quantumTicks - remainingCycles;
-		if (executedCycles < ppcInterpreterCurrentInstance->skippedCycles)
+		sint64 executedCycles = (sint64)thread->quantumTicks - (sint64)hCPU->remainingCycles;
+		executedCycles = std::max<sint64>(executedCycles, 0);
+		if (executedCycles < (sint64)hCPU->skippedCycles)
 			executedCycles = 0;
 		else
-			executedCycles -= ppcInterpreterCurrentInstance->skippedCycles;
-		thread->totalCycles += executedCycles;
+			executedCycles -= hCPU->skippedCycles;
+		thread->totalCycles += (uint64)executedCycles;
 		// store context and set current thread to null
 		__OSThreadStoreContext(hCPU, thread);
 		OSSetCurrentThread(OSGetCoreId(), nullptr);
-		ppcInterpreterCurrentInstance = nullptr;
+		PPCInterpreter_setCurrentInstance(nullptr);
 	}
 
 	void __OSLoadThread(OSThread_t* thread, PPCInterpreter_t* hCPU, uint32 coreIndex)
@@ -933,7 +1142,7 @@ namespace coreinit
 		hCPU->reservedMemValue = 0;
 		hCPU->spr.UPIR = coreIndex;
 		hCPU->coreInterruptMask = 1;
-		ppcInterpreterCurrentInstance = hCPU;
+		PPCInterpreter_setCurrentInstance(hCPU);
 		OSSetCurrentThread(OSGetCoreId(), thread);
 		__OSThreadLoadContext(hCPU, thread);
 		thread->context.upir = coreIndex;
@@ -943,6 +1152,22 @@ namespace coreinit
 		thread->wakeUpCount = thread->wakeUpCount + 1;
 	}
 
+	uint32 s_lehmer_lcg[PPC_CORE_COUNT] = { 0 };
+
+	void __OSThreadStartTimeslice(OSThread_t* thread, PPCInterpreter_t* hCPU)
+	{
+		uint32 coreIndex = PPCInterpreter_getCoreIndex(hCPU);
+		// run one timeslice
+		hCPU->remainingCycles = ppcThreadQuantum;
+		hCPU->skippedCycles = 0;
+		// we add a slight randomized variance to the thread quantum to avoid getting stuck in repeated code sequences where one or multiple threads always unload inside a lock
+		// this was seen in Mario Party 10 during early boot where several OSLockMutex operations would align in such a way that one thread would never successfully acquire the lock
+		if (s_lehmer_lcg[coreIndex] == 0)
+			s_lehmer_lcg[coreIndex] = 12345;
+		hCPU->remainingCycles += (s_lehmer_lcg[coreIndex] & 0x7F);
+		s_lehmer_lcg[coreIndex] = (uint32)((uint64)s_lehmer_lcg[coreIndex] * 279470273ull % 0xfffffffbull);
+	}
+
 	OSThread_t* __OSGetNextRunableThread(uint32 coreIndex)
 	{
 		cemu_assert_debug(__OSHasSchedulerLock());
@@ -970,6 +1195,18 @@ namespace coreinit
 		return selectedThread;
 	}
 
+    void __OSDeleteAllActivePPCThreads()
+    {
+        __OSLockScheduler();
+        while(activeThreadCount > 0)
+        {
+            MEMPTR<OSThread_t> t{activeThread[0]};
+            t->state = OSThread_t::THREAD_STATE::STATE_NONE;
+            __OSDeactivateThread(t.GetPtr());
+        }
+        __OSUnlockScheduler();
+    }
+
 	void __OSCheckSystemEvents()
 	{
 		// AX update
@@ -1030,7 +1267,7 @@ namespace coreinit
 
 		// store context of current thread
 		__OSStoreThread(OSGetCurrentThread(), &hostThread->ppcInstance);
-		cemu_assert_debug(ppcInterpreterCurrentInstance == nullptr);
+		cemu_assert_debug(PPCInterpreter_getCurrentInstance() == nullptr);
 
 		if (!sSchedulerActive.load(std::memory_order::relaxed))
 		{
@@ -1069,31 +1306,31 @@ namespace coreinit
 		cemu_assert_debug(__OSHasSchedulerLock());	
 		cemu_assert_debug(g_isMulticoreMode == false || hostThread->selectedCore == t_assignedCoreIndex);
 
-		// load self thread
+		// received next time slice, load self again
 		__OSLoadThread(hostThread->m_thread, &hostThread->ppcInstance, hostThread->selectedCore);
+		__OSThreadStartTimeslice(hostThread->m_thread, &hostThread->ppcInstance);
 	}
 
+#ifdef __arm64__
+	void __OSFiberThreadEntry(uint32 _high, uint32 _low)
+	{
+		uint64 _thread = (uint64) _high << 32 | _low;
+#else
 	void __OSFiberThreadEntry(void* _thread)
 	{
+#endif
 		OSHostThread* hostThread = (OSHostThread*)_thread;
 
+        #if defined(ARCH_X86_64)
 		_mm_setcsr(_mm_getcsr() | 0x8000); // flush denormals to zero
-
-		uint32 lehmer_lcg = 12345;
+        #endif
 
 		PPCInterpreter_t* hCPU = &hostThread->ppcInstance;
 		__OSLoadThread(hostThread->m_thread, hCPU, hostThread->selectedCore);
+		__OSThreadStartTimeslice(hostThread->m_thread, &hostThread->ppcInstance);
 		__OSUnlockScheduler(); // lock is always held when switching to a fiber, so we need to unlock it here
 		while (true)
 		{
-			// run one timeslice
-			hCPU->remainingCycles = ppcThreadQuantum;
-			hCPU->skippedCycles = 0;
-			// we add a slight randomized variance to the thread quantum to avoid getting stuck in repeated code sequences where the duration matches the thread quantum perfectly
-			// this was seen in Mario Party 10 on launch where several OSLockMutex operations would align in such a way that one thread would never successfully acquire the lock
-			hCPU->remainingCycles += (lehmer_lcg & 0x7F);
-			lehmer_lcg = (uint32)((uint64)lehmer_lcg * 279470273ull % 0xfffffffbull);
-
 			if (hCPU->remainingCycles > 0)
 			{
 				// try to enter recompiler immediately
@@ -1114,16 +1351,48 @@ namespace coreinit
 		}
 	}
 
+#if BOOST_OS_LINUX
+	#include <unistd.h>
+	#include <sys/prctl.h>
+
+	std::vector<pid_t> g_schedulerThreadIds;
+	std::mutex g_schedulerThreadIdsLock;
+
+	std::vector<pid_t>& OSGetSchedulerThreadIds()
+	{
+		std::lock_guard schedulerThreadIdsLockGuard(g_schedulerThreadIdsLock);
+		return g_schedulerThreadIds;
+	}
+#endif
+
 	void OSSchedulerCoreEmulationThread(void* _assignedCoreIndex)
 	{
-		SetThreadName(fmt::format("OSSchedulerThread[core={}]", (uintptr_t)_assignedCoreIndex).c_str());
+		SetThreadName(fmt::format("OSSched[core={}]", (uintptr_t)_assignedCoreIndex).c_str());
 		t_assignedCoreIndex = (sint32)(uintptr_t)_assignedCoreIndex;
+        #if defined(ARCH_X86_64)
 		_mm_setcsr(_mm_getcsr() | 0x8000); // flush denormals to zero
+        #endif
+
+#if BOOST_OS_LINUX
+		if (g_gdbstub)
+		{
+			// need to allow the GDBStub to attach to our thread
+			prctl(PR_SET_DUMPABLE, (unsigned long)1);
+			prctl(PR_SET_PTRACER, PR_SET_PTRACER_ANY);
+		}
+
+		pid_t tid = gettid();
+		{
+			std::lock_guard schedulerThreadIdsLockGuard(g_schedulerThreadIdsLock);
+			g_schedulerThreadIds.emplace_back(tid);
+		}
+#endif
+
 		t_schedulerFiber = Fiber::PrepareCurrentThread();
-		
+
 		// create scheduler idle fiber and switch to it
 		g_idleLoopFiber[t_assignedCoreIndex] = new Fiber(__OSThreadCoreIdle, nullptr, nullptr);
-		cemu_assert_debug(ppcInterpreterCurrentInstance == nullptr);
+		cemu_assert_debug(PPCInterpreter_getCurrentInstance() == nullptr);
 		__OSLockScheduler();
 		Fiber::Switch(*g_idleLoopFiber[t_assignedCoreIndex]);
 		// returned from scheduler loop, exit thread
@@ -1158,7 +1427,7 @@ namespace coreinit
 			g_schedulerThreadHandles.emplace_back(it.native_handle());
 	}
 
-	// shuts down all scheduler host threads and deletes all fibers and their state
+    // shuts down all scheduler host threads and deletes all fibers and ppc threads
 	void OSSchedulerEnd()
 	{
 		std::unique_lock _lock(sSchedulerStateMtx);
@@ -1170,6 +1439,12 @@ namespace coreinit
 			threadItr.join();
 		sSchedulerThreads.clear();
 		g_schedulerThreadHandles.clear();
+#if BOOST_OS_LINUX
+		{
+			std::lock_guard schedulerThreadIdsLockGuard(g_schedulerThreadIdsLock);
+			g_schedulerThreadIds.clear();
+		}
+#endif
 		// clean up all fibers
 		for (auto& it : g_idleLoopFiber)
 		{
@@ -1223,7 +1498,7 @@ namespace coreinit
 	{
 		struct DeallocatorQueueEntry
 		{
-			DeallocatorQueueEntry() {};
+			DeallocatorQueueEntry() = default;
 			DeallocatorQueueEntry(OSThread_t* thread, MEMPTR<void> stack, MEMPTR<void> deallocatorFunc) : thread(thread), stack(stack), deallocatorFunc(deallocatorFunc) {};
 
 			OSThread_t* thread{};
@@ -1253,11 +1528,11 @@ namespace coreinit
 	}
 
 	// queue thread deallocation to run after current thread finishes
-	// the termination threads run at a higher priority on the same threads
+	// the termination threads run at a higher priority on the same core
 	void __OSQueueThreadDeallocation(OSThread_t* thread)
 	{
 		uint32 coreIndex = OSGetCoreId();
-		TerminatorThread::DeallocatorQueueEntry queueEntry(thread, memory_getPointerFromVirtualOffset(_swapEndianU32(thread->stackEnd)), thread->deallocatorFunc);
+		TerminatorThread::DeallocatorQueueEntry queueEntry(thread, thread->stackEnd, thread->deallocatorFunc);
 		s_terminatorThreads[coreIndex].queueDeallocators.push(queueEntry);
 		OSSignalSemaphoreInternal(s_terminatorThreads[coreIndex].semaphoreQueuedDeallocators.GetPtr(), false); // do not reschedule here! Current thread must not be interrupted otherwise deallocator will run too early
 	}
@@ -1293,6 +1568,7 @@ namespace coreinit
 	{
 		cafeExportRegister("coreinit", OSCreateThreadType, LogType::CoreinitThread);
 		cafeExportRegister("coreinit", OSCreateThread, LogType::CoreinitThread);
+		cafeExportRegister("coreinit", __OSCreateThreadType, LogType::CoreinitThread);
 		cafeExportRegister("coreinit", OSExitThread, LogType::CoreinitThread);
 
 		cafeExportRegister("coreinit", OSGetCurrentThread, LogType::CoreinitThread);
@@ -1308,6 +1584,7 @@ namespace coreinit
 		cafeExportRegister("coreinit", OSResumeThread, LogType::CoreinitThread);
 		cafeExportRegister("coreinit", OSContinueThread, LogType::CoreinitThread);
 		cafeExportRegister("coreinit", OSSuspendThread, LogType::CoreinitThread);
+		cafeExportRegister("coreinit", __OSSuspendThreadNolock, LogType::CoreinitThread);
 		cafeExportRegister("coreinit", OSSleepThread, LogType::CoreinitThread);
 		cafeExportRegister("coreinit", OSWakeupThread, LogType::CoreinitThread);
 
@@ -1339,30 +1616,8 @@ namespace coreinit
 		for (sint32 i = 0; i < PPC_CORE_COUNT; i++)
 			__currentCoreThread[i] = nullptr;
 
-		__OSInitDefaultThreads();
+        __OSInitDefaultThreads();
 		__OSInitTerminatorThreads();
-	}
-}
 
-void coreinit_suspendThread(OSThread_t* OSThreadBE, sint32 count)
-{
-	// for legacy source
-	OSThreadBE->suspendCounter += count;
-}
-
-void coreinit_resumeThread(OSThread_t* OSThreadBE, sint32 count)
-{
-	__OSLockScheduler();
-	coreinit::__OSResumeThreadInternal(OSThreadBE, count);
-	__OSUnlockScheduler();
-}
-
-MPTR coreinitThread_getCurrentThreadMPTRDepr(PPCInterpreter_t* hCPU)
-{
-	return memory_getVirtualOffsetFromPointer(coreinit::__currentCoreThread[PPCInterpreter_getCoreIndex(hCPU)]);
-}
-
-OSThread_t* coreinitThread_getCurrentThreadDepr(PPCInterpreter_t* hCPU)
-{
-	return coreinit::__currentCoreThread[PPCInterpreter_getCoreIndex(hCPU)];
+    }
 }
diff --git a/src/Cafe/OS/libs/coreinit/coreinit_Thread.h b/src/Cafe/OS/libs/coreinit/coreinit_Thread.h
index a0561f41..1a93022b 100644
--- a/src/Cafe/OS/libs/coreinit/coreinit_Thread.h
+++ b/src/Cafe/OS/libs/coreinit/coreinit_Thread.h
@@ -2,9 +2,6 @@
 #include "Cafe/HW/Espresso/Const.h"
 #include "Cafe/OS/libs/coreinit/coreinit_Scheduler.h"
 
-#define OS_CONTEXT_MAGIC_0					'OSCo'
-#define OS_CONTEXT_MAGIC_1					'ntxt'
-
 struct OSThread_t;
 
 struct OSContextRegFPSCR_t
@@ -16,6 +13,9 @@ struct OSContextRegFPSCR_t
 
 struct OSContext_t
 {
+	static constexpr uint32 OS_CONTEXT_MAGIC_0 = 0x4f53436f; // "OSCo"
+	static constexpr uint32 OS_CONTEXT_MAGIC_1 = 0x6e747874; // "ntxt"
+
 	/* +0x000 */ betype<uint32> magic0;
 	/* +0x004 */ betype<uint32> magic1;
 	/* +0x008 */ uint32 gpr[32];
@@ -36,24 +36,29 @@ struct OSContext_t
 	/* +0x1BC */ uint32 gqr[8];			// GQR/UGQR
 	/* +0x1DC */ uint32be upir;			// set to current core index
 	/* +0x1E0 */ uint64be fp_ps1[32];
-	/* +0x2E0 */ uint64 uknTime2E0;
-	/* +0x2E8 */ uint64 uknTime2E8;
-	/* +0x2F0 */ uint64 uknTime2F0;
-	/* +0x2F8 */ uint64 uknTime2F8;
-	/* +0x300 */ uint32 error;         // returned by __gh_errno_ptr() (used by socketlasterr)
+	/* +0x2E0 */ uint64be coretime[3];
+	/* +0x2F8 */ uint64be starttime;
+	/* +0x300 */ sint32be ghs_errno;         // returned by __gh_errno_ptr() (used by socketlasterr)
 	/* +0x304 */ uint32be affinity;
-	/* +0x308 */ uint32 ukn0308;
-	/* +0x30C */ uint32 ukn030C;
-	/* +0x310 */ uint32 ukn0310;
-	/* +0x314 */ uint32 ukn0314;
-	/* +0x318 */ uint32 ukn0318;
-	/* +0x31C */ uint32 ukn031C;
+	/* +0x308 */ uint32be upmc1;
+	/* +0x30C */ uint32be upmc2;
+	/* +0x310 */ uint32be upmc3;
+	/* +0x314 */ uint32be upmc4;
+	/* +0x318 */ uint32be ummcr0;
+	/* +0x31C */ uint32be ummcr1;
 
 	bool checkMagic()
 	{
 		return magic0 == (uint32)OS_CONTEXT_MAGIC_0 && magic1 == (uint32)OS_CONTEXT_MAGIC_1;
 	}
 
+	void SetContextMagic()
+	{
+		magic0 = OS_CONTEXT_MAGIC_0;
+		magic1 = OS_CONTEXT_MAGIC_1;
+	}
+
+
 	bool hasCoreAffinitySet(uint32 coreIndex) const
 	{
 		return (((uint32)affinity >> coreIndex) & 1) != 0;
@@ -121,8 +126,8 @@ namespace coreinit
 
 		// counterparts for queueAndWait
 		void cancelWait(OSThread_t* thread);
-		void wakeupEntireWaitQueue(bool reschedule);
-		void wakeupSingleThreadWaitQueue(bool reschedule);
+		void wakeupEntireWaitQueue(bool reschedule, bool sharedPriorityAndAffinityWorkaround = false);
+		void wakeupSingleThreadWaitQueue(bool reschedule, bool sharedPriorityAndAffinityWorkaround = false);
 
 	private:
 		OSThread_t* takeFirstFromQueue(size_t linkOffset)
@@ -149,7 +154,7 @@ namespace coreinit
 
 		void _debugCheckChain(OSThread_t* thread, OSThreadLink* threadLink)
 		{
-#ifndef PUBLIC_RELEASE
+#ifdef CEMU_DEBUG_ASSERT
 			cemu_assert_debug(tail.IsNull() == head.IsNull());
 			size_t linkOffset = getLinkOffset(thread, threadLink);
 			// expects thread to be in the chain
@@ -361,6 +366,8 @@ namespace coreinit
 
 struct OSThread_t
 {
+	static constexpr uint32 MAGIC_THREAD = 0x74487244; // "tHrD"
+
 	enum class THREAD_TYPE : uint32
 	{
 		TYPE_DRIVER = 0,
@@ -383,7 +390,7 @@ struct OSThread_t
 		ATTR_AFFINITY_CORE1 = 0x2,
 		ATTR_AFFINITY_CORE2 = 0x4,
 		ATTR_DETACHED		= 0x8,
-		// more flags?
+		ATTR_UKN_010		= 0x10,
 	};
 
 	enum REQUEST_FLAG_BIT : uint32
@@ -404,11 +411,21 @@ struct OSThread_t
 		return 0;
 	}
 
+    void SetThreadMagic()
+    {
+        magic = MAGIC_THREAD;
+    }
+
+    bool IsValidMagic() const
+    {
+        return magic == MAGIC_THREAD && context.magic0 == OSContext_t::OS_CONTEXT_MAGIC_0 && context.magic1 == OSContext_t::OS_CONTEXT_MAGIC_1;
+    }
+
 	/* +0x000 */ OSContext_t						context;
-	/* +0x320 */ uint32be							magic;								// 'tHrD'
+	/* +0x320 */ uint32be							magic;								// "tHrD" (0x74487244)
 	/* +0x324 */ betype<THREAD_STATE>				state;
 	/* +0x325 */ uint8								attr;
-	/* +0x326 */ uint16be							id;									// Warriors Orochi 3 uses this to identify threads. Seems like this is always set to 0x8000 ?
+	/* +0x326 */ uint16be							id;									// Warriors Orochi 3 uses this to identify threads
 	/* +0x328 */ betype<sint32>						suspendCounter;
 	/* +0x32C */ sint32be							effectivePriority;					// effective priority (lower is higher)
 	/* +0x330 */ sint32be							basePriority;						// base priority (lower is higher)
@@ -428,23 +445,22 @@ struct OSThread_t
 
 	/* +0x38C */ coreinit::OSThreadLink				activeThreadChain;					// queue of active threads (g_activeThreadQueue)
 
-	/* +0x394 */ MPTR_UINT8							stackBase;							// upper limit of stack
-	/* +0x398 */ MPTR_UINT32						stackEnd;							// lower limit of stack
+	/* +0x394 */ MEMPTR<void>						stackBase;							// upper limit of stack
+	/* +0x398 */ MEMPTR<void>						stackEnd;							// lower limit of stack
 
-	/* +0x39C */ MPTR								entrypoint;
+	/* +0x39C */ MEMPTR<void>						entrypoint;
 	/* +0x3A0 */ crt_t								crt;
 
 	/* +0x578 */ sint32								alarmRelatedUkn;
 	/* +0x57C */ std::array<MEMPTR<void>, 16>		specificArray;
 	/* +0x5BC */ betype<THREAD_TYPE>				type;
-	/* +0x5C0 */ MEMPTR<char>						threadName;
-	/* +0x5C4 */ MPTR								waitAlarm;							// used only by OSWaitEventWithTimeout/OSSignalEvent ?
+	/* +0x5C0 */ MEMPTR<const char>					threadName;
+	/* +0x5C4 */ MEMPTR<void>						waitAlarm;							// used only by OSWaitEventWithTimeout/OSSignalEvent ?
 
 	/* +0x5C8 */ uint32								userStackPointer;
 
-	/* +0x5CC */ MEMPTR<void>						cleanupCallback2;
-	/* +0x5D0 */ //MPTR								deallocator;
-	MEMPTR<void> deallocatorFunc;
+	/* +0x5CC */ MEMPTR<void>						cleanupCallback;
+	/* +0x5D0 */ MEMPTR<void>						deallocatorFunc;
 
 	/* +0x5D4 */ uint32								stateFlags;						// 0x5D4 | various flags? Controls if canceling/suspension is allowed (at cancel points) or not? If 1 -> Cancel/Suspension not allowed, if 0 -> Cancel/Suspension allowed
 	/* +0x5D8 */ betype<REQUEST_FLAG_BIT>			requestFlags;
@@ -462,36 +478,41 @@ struct OSThread_t
 	/* +0x628 */ uint64								wakeTimeRelatedUkn2;
 
 	// set via OSSetExceptionCallback
-	/* +0x630 */ MPTR								ukn630Callback[Espresso::CORE_COUNT];
-	/* +0x63C */ MPTR								ukn63CCallback[Espresso::CORE_COUNT];
-	/* +0x648 */ MPTR								ukn648Callback[Espresso::CORE_COUNT];
-	/* +0x654 */ MPTR								ukn654Callback[Espresso::CORE_COUNT];
+	/* +0x630 */ MPTR								dsiCallback[Espresso::CORE_COUNT];
+	/* +0x63C */ MPTR								isiCallback[Espresso::CORE_COUNT];
+	/* +0x648 */ MPTR								programCallback[Espresso::CORE_COUNT];
+	/* +0x654 */ MPTR								perfMonCallback[Espresso::CORE_COUNT];
 
 	/* +0x660 */ uint32								ukn660;
 
+	// todo - some of the members towards the end of the struct were only added in later COS versions. Figure out the mapping between version and members
+
 	// TLS
 	/* +0x664 */ uint16								numAllocatedTLSBlocks;
 	/* +0x666 */ sint16								tlsStatus;
 	/* +0x668 */ MPTR								tlsBlocksMPTR;
-
+	
 	/* +0x66C */ MEMPTR<coreinit::OSFastMutex>		waitingForFastMutex;
-	/* +0x670 */ coreinit::OSFastMutexLink			contendedFastMutex; // link or queue?
-	/* +0x678 */ coreinit::OSFastMutexLink			ownedFastMutex; // link or queue?
+	/* +0x670 */ coreinit::OSFastMutexLink			contendedFastMutex;
+	/* +0x678 */ coreinit::OSFastMutexLink			ownedFastMutex;
+	/* +0x680 */ MEMPTR<void>						alignmentExceptionCallback[Espresso::CORE_COUNT];
 
-	/* +0x680 */ uint32								padding680[28 / 4];
+	/* +0x68C */ uint32								padding68C[20 / 4];
 };
-
-static_assert(sizeof(OSThread_t) == 0x6A0-4); // todo - determine correct size
+static_assert(sizeof(OSThread_t) == 0x6A0);
 
 namespace coreinit
 {
 	void InitializeThread();
 	void InitializeConcurrency();
 
+	bool __CemuIsMulticoreMode();
+
 	OSThread_t* OSGetDefaultThread(sint32 coreIndex);
 	void* OSGetDefaultThreadStack(sint32 coreIndex, uint32& size);
 
 	bool OSCreateThreadType(OSThread_t* thread, MPTR entryPoint, sint32 numParam, void* ptrParam, void* stackTop2, sint32 stackSize, sint32 priority, uint32 attr, OSThread_t::THREAD_TYPE threadType);
+	bool __OSCreateThreadType(OSThread_t* thread, MPTR entryPoint, sint32 numParam, void* ptrParam, void* stackTop, sint32 stackSize, sint32 priority, uint32 attr, OSThread_t::THREAD_TYPE threadType);
 	void OSCreateThreadInternal(OSThread_t* thread, uint32 entryPoint, MPTR stackLowerBaseAddr, uint32 stackSize, uint8 affinityMask, OSThread_t::THREAD_TYPE threadType);
 	bool OSRunThread(OSThread_t* thread, MPTR funcAddress, sint32 numParam, void* ptrParam);
 	void OSExitThread(sint32 exitValue);
@@ -506,16 +527,18 @@ namespace coreinit
 	bool OSSetThreadPriority(OSThread_t* thread, sint32 newPriority);
 	uint32 OSGetThreadAffinity(OSThread_t* thread);
 
-	void OSSetThreadName(OSThread_t* thread, char* name);
-	char* OSGetThreadName(OSThread_t* thread);
+	void OSSetThreadName(OSThread_t* thread, const char* name);
+	const char* OSGetThreadName(OSThread_t* thread);
 
 	sint32 __OSResumeThreadInternal(OSThread_t* thread, sint32 resumeCount);
 	sint32 OSResumeThread(OSThread_t* thread);
 	void OSContinueThread(OSThread_t* thread);
 	void __OSSuspendThreadInternal(OSThread_t* thread);
+	void __OSSuspendThreadNolock(OSThread_t* thread);
 	void OSSuspendThread(OSThread_t* thread);
 	void OSSleepThread(OSThreadQueue* threadQueue);
 	void OSWakeupThread(OSThreadQueue* threadQueue);
+	bool OSJoinThread(OSThread_t* thread, uint32be* exitValue);
 
 	void OSTestThreadCancelInternal();
 
@@ -524,6 +547,8 @@ namespace coreinit
 
 	bool OSIsThreadTerminated(OSThread_t* thread);
 	bool OSIsThreadSuspended(OSThread_t* thread);
+    bool OSIsThreadRunningNoLock(OSThread_t* thread);
+	bool OSIsThreadRunning(OSThread_t* thread);
 
 	// OSThreadQueue
 	void OSInitThreadQueue(OSThreadQueue* threadQueue);
@@ -586,19 +611,16 @@ namespace coreinit
 
 	// internal
 	void __OSAddReadyThreadToRunQueue(OSThread_t* thread);
-	bool __OSCoreShouldSwitchToThread(OSThread_t* currentThread, OSThread_t* newThread);
+	bool __OSCoreShouldSwitchToThread(OSThread_t* currentThread, OSThread_t* newThread, bool sharedPriorityAndAffinityWorkaround);
 	void __OSQueueThreadDeallocation(OSThread_t* thread);
+
+    bool __OSIsThreadActive(OSThread_t* thread);
+	void __OSDeleteAllActivePPCThreads();
 }
 
 #pragma pack()
 
 // deprecated / clean up required
-void coreinit_suspendThread(OSThread_t* OSThreadBE, sint32 count = 1);
-void coreinit_resumeThread(OSThread_t* OSThreadBE, sint32 count = 1);
-
-MPTR coreinitThread_getCurrentThreadMPTRDepr(PPCInterpreter_t* hCPU);
-OSThread_t* coreinitThread_getCurrentThreadDepr(PPCInterpreter_t* hCPU);
-
 extern MPTR activeThread[256];
 extern sint32 activeThreadCount;
 
diff --git a/src/Cafe/OS/libs/coreinit/coreinit_ThreadQueue.cpp b/src/Cafe/OS/libs/coreinit/coreinit_ThreadQueue.cpp
index 79318c55..b33aa888 100644
--- a/src/Cafe/OS/libs/coreinit/coreinit_ThreadQueue.cpp
+++ b/src/Cafe/OS/libs/coreinit/coreinit_ThreadQueue.cpp
@@ -128,18 +128,19 @@ namespace coreinit
 
 	// counterpart for queueAndWait
 	// if reschedule is true then scheduler will switch to woken up thread (if it is runnable on the same core)
-	void OSThreadQueueInternal::wakeupEntireWaitQueue(bool reschedule)
+	// sharedPriorityAndAffinityWorkaround is currently a hack/placeholder for some special cases. A proper fix likely involves handling all the nuances of thread effective priority
+	void OSThreadQueueInternal::wakeupEntireWaitQueue(bool reschedule, bool sharedPriorityAndAffinityWorkaround)
 	{
 		cemu_assert_debug(__OSHasSchedulerLock());
 		bool shouldReschedule = false;
 		while (OSThread_t* thread = takeFirstFromQueue(offsetof(OSThread_t, waitQueueLink)))
 		{
 			cemu_assert_debug(thread->state == OSThread_t::THREAD_STATE::STATE_WAITING);
-			cemu_assert_debug(thread->suspendCounter == 0);
+			//cemu_assert_debug(thread->suspendCounter == 0);
 			thread->state = OSThread_t::THREAD_STATE::STATE_READY;
 			thread->currentWaitQueue = nullptr;
 			coreinit::__OSAddReadyThreadToRunQueue(thread);
-			if (reschedule && thread->suspendCounter == 0 && ppcInterpreterCurrentInstance && __OSCoreShouldSwitchToThread(coreinit::OSGetCurrentThread(), thread))
+			if (reschedule && thread->suspendCounter == 0 && PPCInterpreter_getCurrentInstance() && __OSCoreShouldSwitchToThread(coreinit::OSGetCurrentThread(), thread, sharedPriorityAndAffinityWorkaround))
 				shouldReschedule = true;
 		}
 		if (shouldReschedule)
@@ -148,7 +149,7 @@ namespace coreinit
 
 	// counterpart for queueAndWait
 	// if reschedule is true then scheduler will switch to woken up thread (if it is runnable on the same core)
-	void OSThreadQueueInternal::wakeupSingleThreadWaitQueue(bool reschedule)
+	void OSThreadQueueInternal::wakeupSingleThreadWaitQueue(bool reschedule, bool sharedPriorityAndAffinityWorkaround)
 	{
 		cemu_assert_debug(__OSHasSchedulerLock());
 		OSThread_t* thread = takeFirstFromQueue(offsetof(OSThread_t, waitQueueLink));
@@ -159,7 +160,7 @@ namespace coreinit
 			thread->state = OSThread_t::THREAD_STATE::STATE_READY;
 			thread->currentWaitQueue = nullptr;
 			coreinit::__OSAddReadyThreadToRunQueue(thread);
-			if (reschedule && thread->suspendCounter == 0 && ppcInterpreterCurrentInstance && __OSCoreShouldSwitchToThread(coreinit::OSGetCurrentThread(), thread))
+			if (reschedule && thread->suspendCounter == 0 && PPCInterpreter_getCurrentInstance() && __OSCoreShouldSwitchToThread(coreinit::OSGetCurrentThread(), thread, sharedPriorityAndAffinityWorkaround))
 				shouldReschedule = true;
 		}
 		if (shouldReschedule)
diff --git a/src/Cafe/OS/libs/coreinit/coreinit_Time.cpp b/src/Cafe/OS/libs/coreinit/coreinit_Time.cpp
index e85b6adb..50a404f4 100644
--- a/src/Cafe/OS/libs/coreinit/coreinit_Time.cpp
+++ b/src/Cafe/OS/libs/coreinit/coreinit_Time.cpp
@@ -3,44 +3,32 @@
 
 namespace coreinit
 {
-
-	uint64 coreinit_getTimerTick()
+	uint64 coreinit_GetMFTB()
 	{
 		// bus clock is 1/5th of core clock
 		// timer clock is 1/4th of bus clock
 		return PPCInterpreter_getMainCoreCycleCounter() / 20ULL;
 	}
 
-	uint64 coreinit_getOSTime()
+	uint64 OSGetSystemTime()
 	{
-		return coreinit_getTimerTick() + ppcCyclesSince2000TimerClock;
+		return coreinit_GetMFTB();
 	}
 
-	void export_OSGetTick(PPCInterpreter_t* hCPU)
+	uint64 OSGetTime()
 	{
-		uint64 osTime = coreinit_getOSTime();
-		osLib_returnFromFunction(hCPU, (uint32)osTime);
+		return OSGetSystemTime() + ppcCyclesSince2000TimerClock;
 	}
 
-	void export_OSGetTime(PPCInterpreter_t* hCPU)
+	uint32 OSGetSystemTick()
 	{
-		uint64 osTime = coreinit_getOSTime();
-		osLib_returnFromFunction64(hCPU, osTime);
+		return static_cast<uint32>(coreinit_GetMFTB());
 	}
 
-	uint64 coreinit_getTimeBase_dummy()
+	uint32 OSGetTick()
 	{
-		return __rdtsc();
-	}
-
-	void export_OSGetSystemTimeDummy(PPCInterpreter_t* hCPU)
-	{
-		osLib_returnFromFunction64(hCPU, coreinit_getTimeBase_dummy());
-	}
-
-	void export_OSGetSystemTime(PPCInterpreter_t* hCPU)
-	{
-		osLib_returnFromFunction64(hCPU, coreinit_getTimerTick());
+		uint64 osTime = OSGetTime();
+		return static_cast<uint32>(osTime);
 	}
 
 	uint32 getLeapDaysUntilYear(uint32 year)
@@ -365,15 +353,14 @@ namespace coreinit
 
 	void InitializeTimeAndCalendar()
 	{
-		osLib_addFunction("coreinit", "OSGetTime", export_OSGetTime);
-		osLib_addFunction("coreinit", "OSGetSystemTime", export_OSGetSystemTimeDummy);
-		osLib_addFunction("coreinit", "OSGetTick", export_OSGetTick);
+		cafeExportRegister("coreinit", OSGetTime, LogType::Placeholder);
+		cafeExportRegister("coreinit", OSGetSystemTime, LogType::Placeholder);
+		cafeExportRegister("coreinit", OSGetTick, LogType::Placeholder);
+		cafeExportRegister("coreinit", OSGetSystemTick, LogType::Placeholder);
 
 		cafeExportRegister("coreinit", OSTicksToCalendarTime, LogType::Placeholder);
 		cafeExportRegister("coreinit", OSCalendarTimeToTicks, LogType::Placeholder);
 
-		osLib_addFunction("coreinit", "OSGetSystemTime", export_OSGetSystemTime);
-
 		//timeTest();
 	}
 };
\ No newline at end of file
diff --git a/src/Cafe/OS/libs/coreinit/coreinit_Time.h b/src/Cafe/OS/libs/coreinit/coreinit_Time.h
index f5dcf22e..380ccf1d 100644
--- a/src/Cafe/OS/libs/coreinit/coreinit_Time.h
+++ b/src/Cafe/OS/libs/coreinit/coreinit_Time.h
@@ -40,19 +40,21 @@ namespace coreinit
 
 		inline TimerTicks ConvertNsToTimerTicks(uint64 ns)
 		{
-			return ((GetTimerClock() / 31250LL) * ((ns)) / 32000LL);
+			return static_cast<TimerTicks>((static_cast<uint64>(GetTimerClock()) / 31250ULL) * (ns) / 32000ULL);
+		}
+
+		inline TimerTicks ConvertMsToTimerTicks(uint64 ms)
+		{
+			return static_cast<TimerTicks>(ms * static_cast<uint64>(GetTimerClock()) / 1000ULL);
 		}
 	};
 
 	void OSTicksToCalendarTime(uint64 ticks, OSCalendarTime_t* calenderStruct);
-	
-	uint64 coreinit_getOSTime();
-	uint64 coreinit_getTimerTick();
 
-	static uint64 OSGetSystemTime()
-	{
-		return coreinit_getTimerTick();
-	}
+	uint64 OSGetSystemTime();
+	uint64 OSGetTime();
+	uint32 OSGetSystemTick();
+	uint32 OSGetTick();
 
 	void InitializeTimeAndCalendar();
 };
diff --git a/src/Cafe/OS/libs/dmae/dmae.cpp b/src/Cafe/OS/libs/dmae/dmae.cpp
index 0d193d33..c35fce2e 100644
--- a/src/Cafe/OS/libs/dmae/dmae.cpp
+++ b/src/Cafe/OS/libs/dmae/dmae.cpp
@@ -11,7 +11,7 @@ uint64 dmaeRetiredTimestamp = 0;
 
 uint64 dmae_getTimestamp()
 {
-	return coreinit::coreinit_getTimerTick();
+	return coreinit::OSGetSystemTime();
 }
 
 void dmae_setRetiredTimestamp(uint64 timestamp)
@@ -36,6 +36,16 @@ void dmaeExport_DMAECopyMem(PPCInterpreter_t* hCPU)
 			dstBuffer[i] = _swapEndianU32(srcBuffer[i]);
 		}
 	}
+	else if( hCPU->gpr[6] == DMAE_ENDIAN_16 )
+	{
+		// swap per uint16
+		uint16* srcBuffer = (uint16*)memory_getPointerFromVirtualOffset(hCPU->gpr[4]);
+		uint16* dstBuffer = (uint16*)memory_getPointerFromVirtualOffset(hCPU->gpr[3]);
+		for(uint32 i=0; i<hCPU->gpr[5]*2; i++)
+		{
+			dstBuffer[i] = _swapEndianU16(srcBuffer[i]);
+		}
+	}
 	else
 	{
 		cemuLog_logDebug(LogType::Force, "DMAECopyMem(): Unsupported endian swap\n");
@@ -88,12 +98,12 @@ void dmaeExport_DMAESemaphore(PPCInterpreter_t* hCPU)
 	}
 	else if (actionType == 0) // wait
 	{
-		forceLogDebug_printf("DMAESemaphore: Unsupported wait operation");
+		cemuLog_logDebug(LogType::Force, "DMAESemaphore: Unsupported wait operation");
 		semaphore->fetch_sub(1);
 	}
 	else
 	{
-		forceLogDebug_printf("DMAESemaphore unknown action type %d", actionType);
+		cemuLog_logDebug(LogType::Force, "DMAESemaphore unknown action type {}", actionType);
 		cemu_assert_debug(false);
 	}
 
@@ -116,4 +126,4 @@ void dmae_load()
 	osLib_addFunction("dmae", "DMAEWaitDone", dmaeExport_DMAEWaitDone);
 	osLib_addFunction("dmae", "DMAESemaphore", dmaeExport_DMAESemaphore);
 	osLib_addFunction("dmae", "DMAEGetRetiredTimeStamp", dmaeExport_DMAEGetRetiredTimeStamp);
-}
\ No newline at end of file
+}
diff --git a/src/Cafe/OS/libs/drmapp/drmapp.cpp b/src/Cafe/OS/libs/drmapp/drmapp.cpp
index 8fa5db8a..6c57b209 100644
--- a/src/Cafe/OS/libs/drmapp/drmapp.cpp
+++ b/src/Cafe/OS/libs/drmapp/drmapp.cpp
@@ -5,12 +5,33 @@ namespace drmapp
 {
 	uint32 NupChkIsFinished(uint32 ukn)
 	{
-		forceLogDebug_printf("drmapp.NupChkIsFinished() - placeholder");
+		cemuLog_logDebug(LogType::Force, "drmapp.NupChkIsFinished() - placeholder");
+		return 1;
+	}
+
+	uint32 PatchChkIsFinished()
+	{
+		cemuLog_logDebug(LogType::Force, "drmapp.PatchChkIsFinished() - placeholder");
+		return 1;
+	}
+
+	uint32 AocChkIsFinished()
+	{
+		cemuLog_logDebug(LogType::Force, "drmapp.AocChkIsFinished() - placeholder");
+		return 1;
+	}
+
+	uint32 TicketChkIsFinished()
+	{
+		cemuLog_logDebug(LogType::Force, "drmapp.TicketChkIsFinished__3RplFv() - placeholder");
 		return 1;
 	}
 
 	void Initialize()
 	{
 		cafeExportRegisterFunc(NupChkIsFinished, "drmapp", "NupChkIsFinished__3RplFv", LogType::Placeholder);
+		cafeExportRegisterFunc(PatchChkIsFinished, "drmapp", "PatchChkIsFinished__3RplFv", LogType::Placeholder);
+		cafeExportRegisterFunc(AocChkIsFinished, "drmapp", "AocChkIsFinished__3RplFv", LogType::Placeholder);
+		cafeExportRegisterFunc(TicketChkIsFinished, "drmapp", "TicketChkIsFinished__3RplFv", LogType::Placeholder);
 	}
-}
+} // namespace drmapp
diff --git a/src/Cafe/OS/libs/erreula/erreula.cpp b/src/Cafe/OS/libs/erreula/erreula.cpp
index 1d1e67fb..342e8b64 100644
--- a/src/Cafe/OS/libs/erreula/erreula.cpp
+++ b/src/Cafe/OS/libs/erreula/erreula.cpp
@@ -9,32 +9,45 @@
 #include <wx/msgdlg.h>
 
 #include "Cafe/OS/libs/coreinit/coreinit_FS.h"
+#include "Cafe/OS/libs/coreinit/coreinit_Time.h"
 #include "Cafe/OS/libs/vpad/vpad.h"
 
 namespace nn
 {
 namespace erreula
 {
-#define RESULTTYPE_NONE		0
-#define RESULTTYPE_FINISH	1
-#define RESULTTYPE_NEXT		2
-#define RESULTTYPE_JUMP		3
-#define RESULTTYPE_PASSWORD 4
 
-#define ERRORTYPE_CODE 0
-#define ERRORTYPE_TEXT 1
-#define ERRORTYPE_TEXT_ONE_BUTTON 2
-#define ERRORTYPE_TEXT_TWO_BUTTON 3
-
-#define ERREULA_STATE_HIDDEN		0
-#define ERREULA_STATE_APPEARING		1
-#define ERREULA_STATE_VISIBLE		2
-#define ERREULA_STATE_DISAPPEARING	3
-
-	struct AppearArg_t
+	enum class ErrorDialogType : uint32
 	{
-		AppearArg_t() = default;
-		AppearArg_t(const AppearArg_t& o)
+		Code = 0,
+		Text = 1,
+		TextOneButton = 2,
+		TextTwoButton = 3
+	};
+
+	static const sint32 FADE_TIME = 80;
+
+	enum class ErrEulaState : uint32
+	{
+		Hidden = 0,
+		Appearing = 1,
+		Visible = 2,
+		Disappearing = 3
+	};
+
+	enum class ResultType : uint32
+	{
+		None = 0,
+		Finish = 1,
+		Next = 2,
+		Jump = 3,
+		Password = 4
+	};
+
+	struct AppearError
+	{
+		AppearError() = default;
+		AppearError(const AppearError& o)
 		{
 			errorType = o.errorType;
 			screenType = o.screenType;
@@ -49,7 +62,7 @@ namespace erreula
 			drawCursor = o.drawCursor;
 		}
 
-		uint32be errorType;
+		betype<ErrorDialogType> errorType;
 		uint32be screenType;
 		uint32be controllerType;
 		uint32be holdType;
@@ -63,7 +76,9 @@ namespace erreula
 		bool drawCursor{};
 	};
 
-	static_assert(sizeof(AppearArg_t) == 0x2C); // maybe larger
+	using AppearArg = AppearError;
+
+	static_assert(sizeof(AppearError) == 0x2C); // maybe larger
 
 	struct HomeNixSignArg_t
 	{
@@ -80,24 +95,144 @@ namespace erreula
 
 	static_assert(sizeof(ControllerInfo_t) == 0x14); // maybe larger
 
+	class ErrEulaInstance
+	{
+	  public:
+		enum class BUTTON_SELECTION : uint32
+		{
+			NONE = 0xFFFFFFFF,
+			LEFT = 0,
+			RIGHT = 1,
+		};
+
+		void Init()
+		{
+			m_buttonSelection = BUTTON_SELECTION::NONE;
+			m_resultCode = -1;
+			m_resultCodeForLeftButton = 0;
+			m_resultCodeForRightButton = 0;
+			SetState(ErrEulaState::Hidden);
+		}
+
+		void DoAppearError(AppearArg* arg)
+		{
+			m_buttonSelection = BUTTON_SELECTION::NONE;
+			m_resultCode = -1;
+			m_resultCodeForLeftButton = -1;
+			m_resultCodeForRightButton = -1;
+			// for standard dialog its 0 and 1?
+			m_resultCodeForLeftButton = 0;
+			m_resultCodeForRightButton = 1;
+			SetState(ErrEulaState::Appearing);
+		}
+
+		void DoDisappearError()
+		{
+			if(m_state != ErrEulaState::Visible)
+				return;
+			SetState(ErrEulaState::Disappearing);
+		}
+
+		void DoCalc()
+		{
+			// appearing and disappearing state will automatically advance after some time
+			if (m_state == ErrEulaState::Appearing || m_state == ErrEulaState::Disappearing)
+			{
+				uint32 elapsedTick = coreinit::OSGetTime() - m_lastStateChange;
+				if (elapsedTick > coreinit::EspressoTime::ConvertMsToTimerTicks(FADE_TIME))
+				{
+					SetState(m_state == ErrEulaState::Appearing ? ErrEulaState::Visible : ErrEulaState::Hidden);
+				}
+			}
+		}
+
+		bool IsDecideSelectButtonError() const
+		{
+			return m_buttonSelection != BUTTON_SELECTION::NONE;
+		}
+
+		bool IsDecideSelectLeftButtonError() const
+		{
+			return m_buttonSelection != BUTTON_SELECTION::LEFT;
+		}
+
+		bool IsDecideSelectRightButtonError() const
+		{
+			return m_buttonSelection != BUTTON_SELECTION::RIGHT;
+		}
+
+		void SetButtonSelection(BUTTON_SELECTION selection)
+		{
+			cemu_assert_debug(m_buttonSelection == BUTTON_SELECTION::NONE);
+			m_buttonSelection = selection;
+			cemu_assert_debug(selection == BUTTON_SELECTION::LEFT || selection == BUTTON_SELECTION::RIGHT);
+			m_resultCode = selection == BUTTON_SELECTION::LEFT ? m_resultCodeForLeftButton : m_resultCodeForRightButton;
+		}
+
+		ErrEulaState GetState() const
+		{
+			return m_state;
+		}
+
+		sint32 GetResultCode() const
+		{
+			return m_resultCode;
+		}
+
+		ResultType GetResultType() const
+		{
+		  if(m_resultCode == -1)
+			  return ResultType::None;
+		  if(m_resultCode < 10)
+			  return ResultType::Finish;
+		  if(m_resultCode >= 9999)
+			  return ResultType::Next;
+		  if(m_resultCode == 40)
+			  return ResultType::Password;
+		  return ResultType::Jump;
+		}
+
+		float GetFadeTransparency() const
+		{
+			if(m_state == ErrEulaState::Appearing || m_state == ErrEulaState::Disappearing)
+			{
+				uint32 elapsedTick = coreinit::OSGetTime() - m_lastStateChange;
+				if(m_state == ErrEulaState::Appearing)
+					return std::min<float>(1.0f, (float)elapsedTick / (float)coreinit::EspressoTime::ConvertMsToTimerTicks(FADE_TIME));
+				else
+					return std::max<float>(0.0f, 1.0f - (float)elapsedTick / (float)coreinit::EspressoTime::ConvertMsToTimerTicks(FADE_TIME));
+			}
+			return 1.0f;
+		}
+
+	  private:
+		void SetState(ErrEulaState state)
+		{
+			m_state = state;
+			m_lastStateChange = coreinit::OSGetTime();
+		}
+
+		ErrEulaState m_state;
+		uint32 m_lastStateChange;
+
+		/* +0x30 */ betype<sint32> m_resultCode;
+		/* +0x239C */ betype<BUTTON_SELECTION> m_buttonSelection;
+		/* +0x23A0 */ betype<sint32> m_resultCodeForLeftButton;
+		/* +0x23A4 */ betype<sint32> m_resultCodeForRightButton;
+	};
+
 	struct ErrEula_t
 	{
-		coreinit::OSMutex mutex;
+		SysAllocator<coreinit::OSMutex> mutex;
 		uint32 regionType;
 		uint32 langType;
 		MEMPTR<coreinit::FSClient_t> fsClient;
 
-		AppearArg_t currentDialog;
-		uint32 state;
-		bool buttonPressed;
-		bool rightButtonPressed;
+		std::unique_ptr<ErrEulaInstance> errEulaInstance;
 
+		AppearError currentDialog;
 		bool homeNixSignVisible;
-
-		std::chrono::steady_clock::time_point stateTimer{};
 	} g_errEula = {};
-
-
 	
 	std::wstring GetText(uint16be* text)
 	{
@@ -113,22 +248,61 @@ namespace erreula
 	}
 	
 
-	void export_ErrEulaCreate(PPCInterpreter_t* hCPU)
+	void ErrEulaCreate(void* workmem, uint32 regionType, uint32 langType, coreinit::FSClient_t* fsClient)
 	{
-		ppcDefineParamMEMPTR(thisptr, uint8, 0);
-		ppcDefineParamU32(regionType, 1);
-		ppcDefineParamU32(langType, 2);
-		ppcDefineParamMEMPTR(fsClient, coreinit::FSClient_t, 3);
-
 		coreinit::OSLockMutex(&g_errEula.mutex);
 
 		g_errEula.regionType = regionType;
 		g_errEula.langType = langType;
 		g_errEula.fsClient = fsClient;
+		cemu_assert_debug(!g_errEula.errEulaInstance);
+		g_errEula.errEulaInstance = std::make_unique<ErrEulaInstance>();
+		g_errEula.errEulaInstance->Init();
 
 		coreinit::OSUnlockMutex(&g_errEula.mutex);
+	}
 
-		osLib_returnFromFunction(hCPU, 0);
+	void ErrEulaDestroy()
+	{
+		g_errEula.errEulaInstance.reset();
+	}
+
+	// check if any dialog button was selected
+	bool IsDecideSelectButtonError()
+	{
+		if(!g_errEula.errEulaInstance)
+			return false;
+		return g_errEula.errEulaInstance->IsDecideSelectButtonError();
+	}
+
+	// check if left dialog button was selected
+	bool IsDecideSelectLeftButtonError()
+	{
+		if(!g_errEula.errEulaInstance)
+			return false;
+		return g_errEula.errEulaInstance->IsDecideSelectLeftButtonError();
+	}
+
+	// check if right dialog button was selected
+	bool IsDecideSelectRightButtonError()
+	{
+		if(!g_errEula.errEulaInstance)
+			return false;
+		return g_errEula.errEulaInstance->IsDecideSelectRightButtonError();
+	}
+
+	sint32 GetResultCode()
+	{
+		if(!g_errEula.errEulaInstance)
+			return -1;
+		return g_errEula.errEulaInstance->GetResultCode();
+	}
+
+	ResultType GetResultType()
+	{
+		if(!g_errEula.errEulaInstance)
+			return ResultType::None;
+		return g_errEula.errEulaInstance->GetResultType();
 	}
 
 	void export_AppearHomeNixSign(PPCInterpreter_t* hCPU)
@@ -137,28 +311,24 @@ namespace erreula
 		osLib_returnFromFunction(hCPU, 0);
 	}
 
-	void export_AppearError(PPCInterpreter_t* hCPU)
+	void ErrEulaAppearError(AppearArg* arg)
 	{
-		ppcDefineParamMEMPTR(arg, AppearArg_t, 0);
-
-		g_errEula.currentDialog = *arg.GetPtr();
-		g_errEula.state = ERREULA_STATE_APPEARING;
-		g_errEula.buttonPressed = false;
-		g_errEula.rightButtonPressed = false;
-
-		g_errEula.stateTimer = tick_cached();
-
-		osLib_returnFromFunction(hCPU, 0);
+		g_errEula.currentDialog = *arg;
+		if(g_errEula.errEulaInstance)
+			g_errEula.errEulaInstance->DoAppearError(arg);
 	}
 
-	void export_GetStateErrorViewer(PPCInterpreter_t* hCPU)
+	void ErrEulaDisappearError()
 	{
-		osLib_returnFromFunction(hCPU, g_errEula.state);
+		if(g_errEula.errEulaInstance)
+			g_errEula.errEulaInstance->DoDisappearError();
 	}
-	void export_DisappearError(PPCInterpreter_t* hCPU)
+
+	ErrEulaState ErrEulaGetStateErrorViewer()
 	{
-		g_errEula.state = ERREULA_STATE_HIDDEN;
-		osLib_returnFromFunction(hCPU, 0);
+		if(!g_errEula.errEulaInstance)
+			return ErrEulaState::Hidden;
+		return g_errEula.errEulaInstance->GetState();
 	}
 
 	void export_ChangeLang(PPCInterpreter_t* hCPU)
@@ -168,27 +338,6 @@ namespace erreula
 		osLib_returnFromFunction(hCPU, 0);
 	}
 
-	void export_IsDecideSelectButtonError(PPCInterpreter_t* hCPU)
-	{
-		if (g_errEula.buttonPressed)
-			forceLogDebug_printf("IsDecideSelectButtonError: TRUE");
-		osLib_returnFromFunction(hCPU, g_errEula.buttonPressed);
-	}
-
-	void export_IsDecideSelectLeftButtonError(PPCInterpreter_t* hCPU)
-	{
-		if (g_errEula.buttonPressed)
-			forceLogDebug_printf("IsDecideSelectLeftButtonError: TRUE");
-		osLib_returnFromFunction(hCPU, g_errEula.buttonPressed);
-	}
-
-	void export_IsDecideSelectRightButtonError(PPCInterpreter_t* hCPU)
-	{
-		if (g_errEula.rightButtonPressed)
-			forceLogDebug_printf("IsDecideSelectRightButtonError: TRUE");
-		osLib_returnFromFunction(hCPU, g_errEula.rightButtonPressed);
-	}
-
 	void export_IsAppearHomeNixSign(PPCInterpreter_t* hCPU)
 	{
 		osLib_returnFromFunction(hCPU, g_errEula.homeNixSignVisible);
@@ -200,61 +349,19 @@ namespace erreula
 		osLib_returnFromFunction(hCPU, 0);
 	}
 
-	void export_GetResultType(PPCInterpreter_t* hCPU)
+	void ErrEulaCalc(ControllerInfo_t* controllerInfo)
 	{
-		uint32 result = RESULTTYPE_NONE;
-		if (g_errEula.buttonPressed || g_errEula.rightButtonPressed)
-		{
-			forceLogDebug_printf("GetResultType: FINISH");
-			result = RESULTTYPE_FINISH;
-		}
-
-		osLib_returnFromFunction(hCPU, result);
-	}
-
-	void export_Calc(PPCInterpreter_t* hCPU)
-	{
-		ppcDefineParamMEMPTR(controllerInfo, ControllerInfo_t, 0);
-		// TODO: check controller buttons bla to accept dialog?
-		osLib_returnFromFunction(hCPU, 0);
+		if(g_errEula.errEulaInstance)
+			g_errEula.errEulaInstance->DoCalc();
 	}
 
 	void render(bool mainWindow)
 	{
-		if(g_errEula.state == ERREULA_STATE_HIDDEN)
+		if(!g_errEula.errEulaInstance)
 			return;
-
-		if(g_errEula.state == ERREULA_STATE_APPEARING)
-		{
-			if(std::chrono::duration_cast<std::chrono::milliseconds>(tick_cached() - g_errEula.stateTimer).count() <= 1000)
-			{
-				return;
-			}
-
-			g_errEula.state = ERREULA_STATE_VISIBLE;
-			g_errEula.stateTimer = tick_cached();
-		}
-		/*else if(g_errEula.state == STATE_VISIBLE)
-		{
-			if (std::chrono::duration_cast<std::chrono::milliseconds>(tick_cached() - g_errEula.stateTimer).count() >= 1000)
-			{
-				g_errEula.state = STATE_DISAPPEARING;
-				g_errEula.stateTimer = tick_cached();
-				return;
-			}
-		}*/
-		else if(g_errEula.state == ERREULA_STATE_DISAPPEARING)
-		{
-			if (std::chrono::duration_cast<std::chrono::milliseconds>(tick_cached() - g_errEula.stateTimer).count() >= 2000)
-			{
-				g_errEula.state = ERREULA_STATE_HIDDEN;
-				g_errEula.stateTimer = tick_cached();
-			}
-
+		if(g_errEula.errEulaInstance->GetState() != ErrEulaState::Visible && g_errEula.errEulaInstance->GetState() != ErrEulaState::Appearing && g_errEula.errEulaInstance->GetState() != ErrEulaState::Disappearing)
 			return;
-		}
-		
-		const AppearArg_t& appearArg = g_errEula.currentDialog;
+		const AppearError& appearArg = g_errEula.currentDialog;
 		std::string text;
 		const uint32 errorCode = (uint32)appearArg.errorCode;
 		if (errorCode != 0)
@@ -276,16 +383,28 @@ namespace erreula
 		ImGui::SetNextWindowPos(position, ImGuiCond_Always, pivot);
 		ImGui::SetNextWindowBgAlpha(0.9f);
 		ImGui::PushFont(font);
-		
-		std::string title = "ErrEula";
+
+		std::string title;
 		if (appearArg.title)
 			title = boost::nowide::narrow(GetText(appearArg.title.GetPtr()));
-		
+		if (title.empty()) // ImGui doesn't allow empty titles, so set one if appearArg.title is not set or empty
+			title = "ErrEula";
+
+		float fadeTransparency = 1.0f;
+		if (g_errEula.errEulaInstance->GetState() == ErrEulaState::Appearing || g_errEula.errEulaInstance->GetState() == ErrEulaState::Disappearing)
+		{
+			fadeTransparency = g_errEula.errEulaInstance->GetFadeTransparency();
+		}
+
+		float originalAlpha = ImGui::GetStyle().Alpha;
+		ImGui::GetStyle().Alpha = fadeTransparency;
+		ImGui::SetNextWindowBgAlpha(0.9f * fadeTransparency);
 		if (ImGui::Begin(title.c_str(), nullptr, kPopupFlags))
 		{
 			const float startx = ImGui::GetWindowSize().x / 2.0f;
+			bool hasLeftButtonPressed = false, hasRightButtonPressed = false;
 
-			switch ((uint32)appearArg.errorType)
+			switch (appearArg.errorType)
 			{
 			default:
 			{
@@ -293,11 +412,10 @@ namespace erreula
 				ImGui::TextUnformatted(text.c_str(), text.c_str() + text.size());
 				ImGui::Spacing();
 				ImGui::SetCursorPosX(startx - 50);
-				g_errEula.buttonPressed |= ImGui::Button("OK", {100, 0});
-				
+				hasLeftButtonPressed = ImGui::Button("OK", {100, 0});
 				break;
 			}
-			case ERRORTYPE_TEXT:
+			case ErrorDialogType::Text:
 			{
 				std::string txtTmp = "Unknown Error";
 				if (appearArg.text)
@@ -308,10 +426,10 @@ namespace erreula
 				ImGui::Spacing();
 					
 				ImGui::SetCursorPosX(startx - 50);
-				g_errEula.buttonPressed |= ImGui::Button("OK", { 100, 0 });
+				hasLeftButtonPressed = ImGui::Button("OK", { 100, 0 });
 				break;
 			}
-			case ERRORTYPE_TEXT_ONE_BUTTON:
+			case ErrorDialogType::TextOneButton:
 			{
 				std::string txtTmp = "Unknown Error";
 				if (appearArg.text)
@@ -327,10 +445,10 @@ namespace erreula
 
 				float width = std::max(100.0f, ImGui::CalcTextSize(button1.c_str()).x + 10.0f);
 				ImGui::SetCursorPosX(startx - (width / 2.0f));
-				g_errEula.buttonPressed |= ImGui::Button(button1.c_str(), { width, 0 });
+				hasLeftButtonPressed = ImGui::Button(button1.c_str(), { width, 0 });
 				break;
 			}
-			case ERRORTYPE_TEXT_TWO_BUTTON:
+			case ErrorDialogType::TextTwoButton:
 			{
 				std::string txtTmp = "Unknown Error";
 				if (appearArg.text)
@@ -346,50 +464,57 @@ namespace erreula
 				std::string button2 = "No";
 				if (appearArg.button2Text)
 					button2 = boost::nowide::narrow(GetText(appearArg.button2Text.GetPtr()));
-					
 
 				float width1 = std::max(100.0f, ImGui::CalcTextSize(button1.c_str()).x + 10.0f);
 				float width2 = std::max(100.0f, ImGui::CalcTextSize(button2.c_str()).x + 10.0f);
 				ImGui::SetCursorPosX(startx - (width1 / 2.0f) - (width2 / 2.0f) - 10);
 					
-				g_errEula.buttonPressed |= ImGui::Button(button1.c_str(), { width1, 0 });
+				hasLeftButtonPressed = ImGui::Button(button1.c_str(), { width1, 0 });
 				ImGui::SameLine();
 					
-				g_errEula.rightButtonPressed |= ImGui::Button(button2.c_str(), { width2, 0 });
+				hasRightButtonPressed = ImGui::Button(button2.c_str(), { width2, 0 });
 				break;
 			}
 			}
-
-			ImGui::End();
+			if (!g_errEula.errEulaInstance->IsDecideSelectButtonError())
+			{
+				if (hasLeftButtonPressed)
+					g_errEula.errEulaInstance->SetButtonSelection(ErrEulaInstance::BUTTON_SELECTION::LEFT);
+				if (hasRightButtonPressed)
+					g_errEula.errEulaInstance->SetButtonSelection(ErrEulaInstance::BUTTON_SELECTION::RIGHT);
+			}
 		}
-
+		ImGui::End();
 		ImGui::PopFont();
-
-		if(g_errEula.buttonPressed || g_errEula.rightButtonPressed)
-		{
-			g_errEula.state = ERREULA_STATE_DISAPPEARING;
-			g_errEula.stateTimer = tick_cached();
-		}
+		ImGui::GetStyle().Alpha = originalAlpha;
 	}
 
 	void load()
 	{
+		g_errEula.errEulaInstance.reset();
+
 		OSInitMutexEx(&g_errEula.mutex, nullptr);
 
-		//osLib_addFunction("erreula", "ErrEulaCreate__3RplFPUcQ3_2nn7erreula10", export_ErrEulaCreate); // copy ctor?
-		osLib_addFunction("erreula", "ErrEulaCreate__3RplFPUcQ3_2nn7erreula10RegionTypeQ3_2nn7erreula8LangTypeP8FSClient", export_ErrEulaCreate);
+		cafeExportRegisterFunc(ErrEulaCreate, "erreula", "ErrEulaCreate__3RplFPUcQ3_2nn7erreula10RegionTypeQ3_2nn7erreula8LangTypeP8FSClient", LogType::Placeholder);
+		cafeExportRegisterFunc(ErrEulaDestroy, "erreula", "ErrEulaDestroy__3RplFv", LogType::Placeholder);
+
+		cafeExportRegisterFunc(IsDecideSelectButtonError, "erreula", "ErrEulaIsDecideSelectButtonError__3RplFv", LogType::Placeholder);
+		cafeExportRegisterFunc(IsDecideSelectLeftButtonError, "erreula", "ErrEulaIsDecideSelectLeftButtonError__3RplFv", LogType::Placeholder);
+		cafeExportRegisterFunc(IsDecideSelectRightButtonError, "erreula", "ErrEulaIsDecideSelectRightButtonError__3RplFv", LogType::Placeholder);
+
+		cafeExportRegisterFunc(GetResultCode, "erreula", "ErrEulaGetResultCode__3RplFv", LogType::Placeholder);
+		cafeExportRegisterFunc(GetResultType, "erreula", "ErrEulaGetResultType__3RplFv", LogType::Placeholder);
+
+		cafeExportRegisterFunc(ErrEulaAppearError, "erreula", "ErrEulaAppearError__3RplFRCQ3_2nn7erreula9AppearArg", LogType::Placeholder);
+		cafeExportRegisterFunc(ErrEulaDisappearError, "erreula", "ErrEulaDisappearError__3RplFv", LogType::Placeholder);
+		cafeExportRegisterFunc(ErrEulaGetStateErrorViewer, "erreula", "ErrEulaGetStateErrorViewer__3RplFv", LogType::Placeholder);
+
+		cafeExportRegisterFunc(ErrEulaCalc, "erreula", "ErrEulaCalc__3RplFRCQ3_2nn7erreula14ControllerInfo", LogType::Placeholder);
+
 		osLib_addFunction("erreula", "ErrEulaAppearHomeNixSign__3RplFRCQ3_2nn7erreula14HomeNixSignArg", export_AppearHomeNixSign);
-		osLib_addFunction("erreula", "ErrEulaAppearError__3RplFRCQ3_2nn7erreula9AppearArg", export_AppearError);
-		osLib_addFunction("erreula", "ErrEulaGetStateErrorViewer__3RplFv", export_GetStateErrorViewer);
 		osLib_addFunction("erreula", "ErrEulaChangeLang__3RplFQ3_2nn7erreula8LangType", export_ChangeLang);
-		osLib_addFunction("erreula", "ErrEulaIsDecideSelectButtonError__3RplFv", export_IsDecideSelectButtonError);
-		osLib_addFunction("erreula", "ErrEulaCalc__3RplFRCQ3_2nn7erreula14ControllerInfo", export_Calc);
-		osLib_addFunction("erreula", "ErrEulaIsDecideSelectLeftButtonError__3RplFv", export_IsDecideSelectLeftButtonError);
-		osLib_addFunction("erreula", "ErrEulaIsDecideSelectRightButtonError__3RplFv", export_IsDecideSelectRightButtonError);
 		osLib_addFunction("erreula", "ErrEulaIsAppearHomeNixSign__3RplFv", export_IsAppearHomeNixSign);
 		osLib_addFunction("erreula", "ErrEulaDisappearHomeNixSign__3RplFv", export_DisappearHomeNixSign);
-		osLib_addFunction("erreula", "ErrEulaGetResultType__3RplFv", export_GetResultType);
-		osLib_addFunction("erreula", "ErrEulaDisappearError__3RplFv", export_DisappearError);
 	}
 }
 }
diff --git a/src/Cafe/OS/libs/gx2/GX2.cpp b/src/Cafe/OS/libs/gx2/GX2.cpp
index 0945d5dc..1c3a8dcc 100644
--- a/src/Cafe/OS/libs/gx2/GX2.cpp
+++ b/src/Cafe/OS/libs/gx2/GX2.cpp
@@ -4,8 +4,8 @@
 #include "GX2.h"
 #include "Cafe/HW/Latte/Core/Latte.h"
 #include "Cafe/OS/libs/coreinit/coreinit_Time.h"
+#include "Cafe/OS/libs/coreinit/coreinit_Thread.h"
 #include "Cafe/CafeSystem.h"
-
 #include "Cafe/HW/Latte/Core/LattePM4.h"
 
 #include "GX2_Command.h"
@@ -21,6 +21,8 @@
 #include "GX2_Surface_Copy.h"
 #include "GX2_Texture.h"
 
+#include <cinttypes>
+
 #define GX2_TV_RENDER_NONE			0
 #define GX2_TV_RENDER_480			1
 #define GX2_TV_RENDER_480_WIDE		2
@@ -46,7 +48,7 @@ uint64 lastSwapTime = 0;
 
 void gx2Export_GX2SwapScanBuffers(PPCInterpreter_t* hCPU)
 {
-	gx2Log_printf("GX2SwapScanBuffers()");
+	cemuLog_log(LogType::GX2, "GX2SwapScanBuffers()");
 
 	bool isPokken = false;
 
@@ -57,7 +59,7 @@ void gx2Export_GX2SwapScanBuffers(PPCInterpreter_t* hCPU)
 	if (isPokken)
 		GX2::GX2DrawDone();
 
-	GX2ReserveCmdSpace(5+2);
+	GX2::GX2ReserveCmdSpace(5+2);
 
 	uint64 tick64 = PPCInterpreter_getMainCoreCycleCounter() / 20ULL;
 	lastSwapTime = tick64;
@@ -66,7 +68,7 @@ void gx2Export_GX2SwapScanBuffers(PPCInterpreter_t* hCPU)
 
 	// Orochi Warriors seems to call GX2SwapScanBuffers on arbitrary threads/cores. The PM4 commands should go through to the GPU as long as there is no active display list and no other core is submitting commands simultaneously
 	// right now, we work around this by avoiding the infinite loop below (request counter incremented, but PM4 not sent)
-	uint32 coreIndex = PPCInterpreter_getCoreIndex(ppcInterpreterCurrentInstance);
+	uint32 coreIndex = coreinit::OSGetCoreId();
 	if (GX2::sGX2MainCoreIndex == coreIndex)
 		LatteGPUState.sharedArea->flipRequestCountBE = _swapEndianU32(_swapEndianU32(LatteGPUState.sharedArea->flipRequestCountBE) + 1);
 
@@ -84,24 +86,16 @@ void gx2Export_GX2SwapScanBuffers(PPCInterpreter_t* hCPU)
 		GX2::GX2WaitForFlip();
 	}
 
-	GX2::GX2WriteGather_checkAndInsertWrapAroundMark();
 	osLib_returnFromFunction(hCPU, 0);
 }
 
 void gx2Export_GX2CopyColorBufferToScanBuffer(PPCInterpreter_t* hCPU)
 {
-	gx2Log_printf("GX2CopyColorBufferToScanBuffer(0x%08x,%d)\n", hCPU->gpr[3], hCPU->gpr[4]);
-	GX2ReserveCmdSpace(5);
+	cemuLog_log(LogType::GX2, "GX2CopyColorBufferToScanBuffer(0x{:08x},{})", hCPU->gpr[3], hCPU->gpr[4]);
+	GX2::GX2ReserveCmdSpace(10);
 
 	// todo: proper implementation
 
-	// hack: Avoid running to far ahead of GPU. Normally this would be guaranteed by the circular buffer model, which we currently dont fully emulate
-	if(GX2::GX2WriteGather_getReadWriteDistance() > 32*1024*1024 )
-	{
-		debug_printf("Waiting for GPU to catch up...\n");
-		PPCInterpreter_relinquishTimeslice(); // release current thread
-		return;
-	}
 	GX2ColorBuffer* colorBuffer = (GX2ColorBuffer*)memory_getPointerFromVirtualOffset(hCPU->gpr[3]);
 
 	gx2WriteGather_submitU32AsBE(pm4HeaderType3(IT_HLE_COPY_COLORBUFFER_TO_SCANBUFFER, 9));
@@ -260,7 +254,7 @@ void gx2Export_GX2CalcDRCSize(PPCInterpreter_t* hCPU)
 
 void gx2Export_GX2SetDRCScale(PPCInterpreter_t* hCPU)
 {
-	gx2Log_printf("GX2SetDRCScale(%d,%d)", hCPU->gpr[3], hCPU->gpr[4]);
+	cemuLog_log(LogType::GX2, "GX2SetDRCScale({},{})", hCPU->gpr[3], hCPU->gpr[4]);
 	osLib_returnFromFunction(hCPU, 0);
 }
 
@@ -268,7 +262,7 @@ void gx2Export_GX2SetDRCConnectCallback(PPCInterpreter_t* hCPU)
 {
 	ppcDefineParamS32(channel, 0);
 	ppcDefineParamMEMPTR(callback, void, 1);
-	gx2Log_printf("GX2SetDRCConnectCallback(%d, 0x%08x)", channel, callback.GetMPTR());
+	cemuLog_log(LogType::GX2, "GX2SetDRCConnectCallback({}, 0x{:08x})", channel, callback.GetMPTR());
 	if(callback.GetPtr())
 		PPCCoreCallback(callback, channel, TRUE);
 	osLib_returnFromFunction(hCPU, 0);
@@ -276,7 +270,7 @@ void gx2Export_GX2SetDRCConnectCallback(PPCInterpreter_t* hCPU)
 
 void gx2Export_GX2SetSemaphore(PPCInterpreter_t* hCPU)
 {
-	gx2Log_printf("GX2SetSemaphore(0x%08x,%d)", hCPU->gpr[3], hCPU->gpr[4]);
+	cemuLog_log(LogType::GX2, "GX2SetSemaphore(0x{:08x},{})", hCPU->gpr[3], hCPU->gpr[4]);
 	ppcDefineParamMPTR(semaphoreMPTR, 0);
 	ppcDefineParamS32(mode, 1);
 
@@ -307,81 +301,6 @@ void gx2Export_GX2SetSemaphore(PPCInterpreter_t* hCPU)
 	osLib_returnFromFunction(hCPU, 0);
 }
 
-void gx2Export_GX2Flush(PPCInterpreter_t* hCPU)
-{
-	gx2Log_printf("GX2Flush()");
-	_GX2SubmitToTCL();
-	osLib_returnFromFunction(hCPU, 0);
-}
-
-uint8* _GX2LastFlushPtr[PPC_CORE_COUNT] = {NULL};
-
-uint64 _prevReturnedGPUTime = 0;
-
-uint64 Latte_GetTime()
-{
-	uint64 gpuTime = coreinit::coreinit_getTimerTick();
-	gpuTime *= 20000ULL;
-	if (gpuTime <= _prevReturnedGPUTime)
-		gpuTime = _prevReturnedGPUTime + 1; // avoid ever returning identical timestamps
-	_prevReturnedGPUTime = gpuTime;
-	return gpuTime;
-}
-
-void _GX2SubmitToTCL()
-{
-	uint32 coreIndex = PPCInterpreter_getCoreIndex(ppcInterpreterCurrentInstance);
-	// do nothing if called from non-main GX2 core
-	if (GX2::sGX2MainCoreIndex != coreIndex)
-	{
-		forceLogDebug_printf("_GX2SubmitToTCL() called on non-main GX2 core");
-		return;
-	}
-	if( gx2WriteGatherPipe.displayListStart[coreIndex] != MPTR_NULL )
-		return; // quit if in display list
-	_GX2LastFlushPtr[coreIndex] = (gx2WriteGatherPipe.writeGatherPtrGxBuffer[coreIndex]);
-	// update last submitted CB timestamp
-	uint64 commandBufferTimestamp = Latte_GetTime();
-	LatteGPUState.lastSubmittedCommandBufferTimestamp.store(commandBufferTimestamp);
-	gx2Log_printf("Submitting GX2 command buffer with timestamp %016I64x", commandBufferTimestamp);
-	// submit HLE packet to write retirement timestamp
-	gx2WriteGather_submitU32AsBE(pm4HeaderType3(IT_HLE_SET_CB_RETIREMENT_TIMESTAMP, 2));
-	gx2WriteGather_submitU32AsBE((uint32)(commandBufferTimestamp>>32ULL));
-	gx2WriteGather_submitU32AsBE((uint32)(commandBufferTimestamp&0xFFFFFFFFULL));
-}
-
-uint32 _GX2GetUnflushedBytes(uint32 coreIndex)
-{
-	uint32 unflushedBytes = 0;
-	if (_GX2LastFlushPtr[coreIndex] != NULL)
-	{
-		if (_GX2LastFlushPtr[coreIndex] > gx2WriteGatherPipe.writeGatherPtrGxBuffer[coreIndex])
-			unflushedBytes = (uint32)(gx2WriteGatherPipe.writeGatherPtrGxBuffer[coreIndex] - gx2WriteGatherPipe.gxRingBuffer + 4); // this isn't 100% correct since we ignore the bytes between the last flush address and the start of the wrap around
-		else
-			unflushedBytes = (uint32)(gx2WriteGatherPipe.writeGatherPtrGxBuffer[coreIndex] - _GX2LastFlushPtr[coreIndex]);
-	}
-	else
-		unflushedBytes = (uint32)(gx2WriteGatherPipe.writeGatherPtrGxBuffer[coreIndex] - gx2WriteGatherPipe.gxRingBuffer);
-	return unflushedBytes;
-}
-
-/*
- * Guarantees that the requested amount of space is available on the current command buffer
- * If the space is not available, the current command buffer is pushed to the GPU and a new one is allocated
- */
-void GX2ReserveCmdSpace(uint32 reservedFreeSpaceInU32)
-{
-	uint32 coreIndex = PPCInterpreter_getCoreIndex(ppcInterpreterCurrentInstance);
-	// if we are in a display list then do nothing
-	if( gx2WriteGatherPipe.displayListStart[coreIndex] != MPTR_NULL )
-		return;
-	uint32 unflushedBytes = _GX2GetUnflushedBytes(coreIndex);
-	if( unflushedBytes >= 0x1000 )
-	{
-		_GX2SubmitToTCL();
-	}
-}
-
 void gx2_load()
 {
 	osLib_addFunction("gx2", "GX2GetContextStateDisplayList", gx2Export_GX2GetContextStateDisplayList);
@@ -394,21 +313,13 @@ void gx2_load()
 	osLib_addFunction("gx2", "GX2GetCurrentScanBuffer", gx2Export_GX2GetCurrentScanBuffer);
 
 	// shader stuff
-	osLib_addFunction("gx2", "GX2GetVertexShaderGPRs", gx2Export_GX2GetVertexShaderGPRs);
-	osLib_addFunction("gx2", "GX2GetVertexShaderStackEntries", gx2Export_GX2GetVertexShaderStackEntries);
-	osLib_addFunction("gx2", "GX2GetPixelShaderGPRs", gx2Export_GX2GetPixelShaderGPRs);
-	osLib_addFunction("gx2", "GX2GetPixelShaderStackEntries", gx2Export_GX2GetPixelShaderStackEntries);
-	osLib_addFunction("gx2", "GX2SetFetchShader", gx2Export_GX2SetFetchShader);
-	osLib_addFunction("gx2", "GX2SetVertexShader", gx2Export_GX2SetVertexShader);
 	osLib_addFunction("gx2", "GX2SetPixelShader", gx2Export_GX2SetPixelShader);
 	osLib_addFunction("gx2", "GX2SetGeometryShader", gx2Export_GX2SetGeometryShader);
 	osLib_addFunction("gx2", "GX2SetComputeShader", gx2Export_GX2SetComputeShader);
-	osLib_addFunction("gx2", "GX2SetVertexUniformReg", gx2Export_GX2SetVertexUniformReg);
 	osLib_addFunction("gx2", "GX2SetVertexUniformBlock", gx2Export_GX2SetVertexUniformBlock);
 	osLib_addFunction("gx2", "GX2RSetVertexUniformBlock", gx2Export_GX2RSetVertexUniformBlock);
 
 	osLib_addFunction("gx2", "GX2SetPixelUniformBlock", gx2Export_GX2SetPixelUniformBlock);
-	osLib_addFunction("gx2", "GX2SetPixelUniformReg", gx2Export_GX2SetPixelUniformReg);
 	osLib_addFunction("gx2", "GX2SetGeometryUniformBlock", gx2Export_GX2SetGeometryUniformBlock);
 	osLib_addFunction("gx2", "GX2SetShaderModeEx", gx2Export_GX2SetShaderModeEx);
 
@@ -451,10 +362,6 @@ void gx2_load()
 	// semaphore
 	osLib_addFunction("gx2", "GX2SetSemaphore", gx2Export_GX2SetSemaphore);
 
-	// command buffer
-	osLib_addFunction("gx2", "GX2Flush", gx2Export_GX2Flush);
-
-	GX2::GX2Init_writeGather();
 	GX2::GX2MemInit();
 	GX2::GX2ResourceInit();
 	GX2::GX2CommandInit();
diff --git a/src/Cafe/OS/libs/gx2/GX2.h b/src/Cafe/OS/libs/gx2/GX2.h
index c9607ee4..92452864 100644
--- a/src/Cafe/OS/libs/gx2/GX2.h
+++ b/src/Cafe/OS/libs/gx2/GX2.h
@@ -7,11 +7,6 @@
 #define GX2_ENABLE	1
 #define GX2_DISABLE	0
 
-// tex unit base for render backends
-#define CEMU_PS_TEX_UNIT_BASE	0
-#define CEMU_VS_TEX_UNIT_BASE	32
-#define CEMU_GS_TEX_UNIT_BASE	64
-
 #include "GX2_Surface.h"
 
 // general
@@ -20,20 +15,12 @@ void gx2_load();
 
 // shader
 
-void gx2Export_GX2SetFetchShader(PPCInterpreter_t* hCPU);
-void gx2Export_GX2GetVertexShaderGPRs(PPCInterpreter_t* hCPU);
-void gx2Export_GX2GetVertexShaderStackEntries(PPCInterpreter_t* hCPU);
-void gx2Export_GX2GetPixelShaderGPRs(PPCInterpreter_t* hCPU);
-void gx2Export_GX2GetPixelShaderStackEntries(PPCInterpreter_t* hCPU);
-void gx2Export_GX2SetVertexShader(PPCInterpreter_t* hCPU);
 void gx2Export_GX2SetPixelShader(PPCInterpreter_t* hCPU);
 void gx2Export_GX2SetGeometryShader(PPCInterpreter_t* hCPU);
 void gx2Export_GX2SetComputeShader(PPCInterpreter_t* hCPU);
-void gx2Export_GX2SetVertexUniformReg(PPCInterpreter_t* hCPU);
 void gx2Export_GX2SetVertexUniformBlock(PPCInterpreter_t* hCPU);
 void gx2Export_GX2RSetVertexUniformBlock(PPCInterpreter_t* hCPU);
 void gx2Export_GX2SetPixelUniformBlock(PPCInterpreter_t* hCPU);
-void gx2Export_GX2SetPixelUniformReg(PPCInterpreter_t* hCPU);
 void gx2Export_GX2SetGeometryUniformBlock(PPCInterpreter_t* hCPU);
 void gx2Export_GX2SetShaderModeEx(PPCInterpreter_t* hCPU);
 void gx2Export_GX2CalcGeometryShaderInputRingBufferSize(PPCInterpreter_t* hCPU);
@@ -80,10 +67,4 @@ void gx2Export_GX2MarkScanBufferCopied(PPCInterpreter_t* hCPU);
 
 void gx2Export_GX2SetDefaultState(PPCInterpreter_t* hCPU);
 void gx2Export_GX2SetupContextStateEx(PPCInterpreter_t* hCPU);
-void gx2Export_GX2SetContextState(PPCInterpreter_t* hCPU);
-
-// command buffer
-
-uint32 _GX2GetUnflushedBytes(uint32 coreIndex);
-void _GX2SubmitToTCL();
-void GX2ReserveCmdSpace(uint32 reservedFreeSpaceInU32);
\ No newline at end of file
+void gx2Export_GX2SetContextState(PPCInterpreter_t* hCPU);
\ No newline at end of file
diff --git a/src/Cafe/OS/libs/gx2/GX2_Blit.cpp b/src/Cafe/OS/libs/gx2/GX2_Blit.cpp
index c8080f38..6e0db6aa 100644
--- a/src/Cafe/OS/libs/gx2/GX2_Blit.cpp
+++ b/src/Cafe/OS/libs/gx2/GX2_Blit.cpp
@@ -82,35 +82,88 @@ namespace GX2
 		}
 	}
 
-	void GX2ClearColor(GX2ColorBuffer* colorBuffer, float r, float g, float b, float a)
+	void SubmitHLEClear(GX2ColorBuffer* colorBuffer, float colorRGBA[4], GX2DepthBuffer* depthBuffer, float depthClearValue, uint8 stencilClearValue, bool clearColor, bool clearDepth, bool clearStencil)
 	{
 		GX2ReserveCmdSpace(50);
+		uint32 hleClearFlags = 0;
+		if (clearColor)
+			hleClearFlags |= 1;
+		if (clearDepth)
+			hleClearFlags |= 2;
+		if (clearStencil)
+			hleClearFlags |= 4;
+		// color buffer
+		MPTR colorPhysAddr = MPTR_NULL;
+		uint32 colorFormat = 0;
+		uint32 colorTileMode = 0;
+		uint32 colorWidth = 0;
+		uint32 colorHeight = 0;
+		uint32 colorPitch = 0;
+		uint32 colorFirstSlice = 0;
+		uint32 colorNumSlices = 0;
+		if (colorBuffer != nullptr)
+		{
+			colorPhysAddr = memory_virtualToPhysical(colorBuffer->surface.imagePtr);
+			colorFormat = (uint32)colorBuffer->surface.format.value();
+			colorTileMode = (uint32)colorBuffer->surface.tileMode.value();
+			colorWidth = colorBuffer->surface.width;
+			colorHeight = colorBuffer->surface.height;
+			colorPitch = colorBuffer->surface.pitch;
+			colorFirstSlice = _swapEndianU32(colorBuffer->viewFirstSlice);
+			colorNumSlices = _swapEndianU32(colorBuffer->viewNumSlices);
+		}
+		// depth buffer
+		MPTR depthPhysAddr = MPTR_NULL;
+		uint32 depthFormat = 0;
+		uint32 depthTileMode = 0;
+		uint32 depthWidth = 0;
+		uint32 depthHeight = 0;
+		uint32 depthPitch = 0;
+		uint32 depthFirstSlice = 0;
+		uint32 depthNumSlices = 0;
+		if (depthBuffer != nullptr)
+		{
+			depthPhysAddr = memory_virtualToPhysical(depthBuffer->surface.imagePtr);
+			depthFormat = (uint32)depthBuffer->surface.format.value();
+			depthTileMode = (uint32)depthBuffer->surface.tileMode.value();
+			depthWidth = depthBuffer->surface.width;
+			depthHeight = depthBuffer->surface.height;
+			depthPitch = depthBuffer->surface.pitch;
+			depthFirstSlice = _swapEndianU32(depthBuffer->viewFirstSlice);
+			depthNumSlices = _swapEndianU32(depthBuffer->viewNumSlices);
+		}
+		gx2WriteGather_submit(pm4HeaderType3(IT_HLE_CLEAR_COLOR_DEPTH_STENCIL, 23),
+		hleClearFlags,
+		colorPhysAddr,
+		colorFormat,
+		colorTileMode,
+		colorWidth,
+		colorHeight,
+		colorPitch,
+		colorFirstSlice,
+		colorNumSlices,
+		depthPhysAddr,
+		depthFormat,
+		depthTileMode,
+		depthWidth,
+		depthHeight,
+		depthPitch,
+		depthFirstSlice,
+		depthNumSlices,
+		(uint32)(colorRGBA[0] * 255.0f),
+		(uint32)(colorRGBA[1] * 255.0f),
+		(uint32)(colorRGBA[2] * 255.0f),
+		(uint32)(colorRGBA[3] * 255.0f),
+		*(uint32*)&depthClearValue,
+		stencilClearValue&0xFF);
+	}
+
+	void GX2ClearColor(GX2ColorBuffer* colorBuffer, float r, float g, float b, float a)
+	{
 		if ((colorBuffer->surface.resFlag & GX2_RESFLAG_USAGE_COLOR_BUFFER) != 0)
 		{
-			gx2WriteGather_submitU32AsBE(pm4HeaderType3(IT_HLE_CLEAR_COLOR_DEPTH_STENCIL, 23));
-			gx2WriteGather_submitU32AsBE(1); // color (1)
-			gx2WriteGather_submitU32AsBE(memory_virtualToPhysical(colorBuffer->surface.imagePtr));
-			gx2WriteGather_submitU32AsBE((uint32)colorBuffer->surface.format.value());
-			gx2WriteGather_submitU32AsBE((uint32)colorBuffer->surface.tileMode.value());
-			gx2WriteGather_submitU32AsBE(colorBuffer->surface.width);
-			gx2WriteGather_submitU32AsBE(colorBuffer->surface.height);
-			gx2WriteGather_submitU32AsBE(colorBuffer->surface.pitch);
-			gx2WriteGather_submitU32AsBE(_swapEndianU32(colorBuffer->viewFirstSlice));
-			gx2WriteGather_submitU32AsBE(_swapEndianU32(colorBuffer->viewNumSlices));
-			gx2WriteGather_submitU32AsBE(MPTR_NULL);
-			gx2WriteGather_submitU32AsBE(0); // depth buffer format
-			gx2WriteGather_submitU32AsBE(0); // tilemode for depth buffer
-			gx2WriteGather_submitU32AsBE(0);
-			gx2WriteGather_submitU32AsBE(0);
-			gx2WriteGather_submitU32AsBE(0);
-			gx2WriteGather_submitU32AsBE(0);
-			gx2WriteGather_submitU32AsBE(0);
-			gx2WriteGather_submitU32AsBE((uint32)(r * 255.0f));
-			gx2WriteGather_submitU32AsBE((uint32)(g * 255.0f));
-			gx2WriteGather_submitU32AsBE((uint32)(b * 255.0f));
-			gx2WriteGather_submitU32AsBE((uint32)(a * 255.0f));
-			gx2WriteGather_submitU32AsBE(0); // clear depth
-			gx2WriteGather_submitU32AsBE(0); // clear stencil
+			float colorRGBA[4] = { r, g, b, a };
+			SubmitHLEClear(colorBuffer, colorRGBA, nullptr, 0.0f, 0, true, false, false);
 		}
 		else
 		{
@@ -120,7 +173,6 @@ namespace GX2
 
 	void GX2ClearBuffersEx(GX2ColorBuffer* colorBuffer, GX2DepthBuffer* depthBuffer, float r, float g, float b, float a, float depthClearValue, uint8 stencilClearValue, GX2ClearFlags clearFlags)
 	{
-		GX2ReserveCmdSpace(50);
 		_updateDepthStencilClearRegs(depthClearValue, stencilClearValue, clearFlags);
 
 		uint32 hleClearFlags = 0;
@@ -130,42 +182,13 @@ namespace GX2
 			hleClearFlags |= 4;
 		hleClearFlags |= 1;
 
-		// send command to clear color, depth and stencil
-		if (_swapEndianU32(colorBuffer->viewFirstSlice) != 0)
-			debugBreakpoint();
-		gx2WriteGather_submitU32AsBE(pm4HeaderType3(IT_HLE_CLEAR_COLOR_DEPTH_STENCIL, 23));
-		gx2WriteGather_submitU32AsBE(hleClearFlags); // color (1), depth (2), stencil (4)
-		gx2WriteGather_submitU32AsBE(memory_virtualToPhysical(colorBuffer->surface.imagePtr));
-		gx2WriteGather_submitU32AsBE((uint32)colorBuffer->surface.format.value());
-		gx2WriteGather_submitU32AsBE((uint32)colorBuffer->surface.tileMode.value());
-		gx2WriteGather_submitU32AsBE((uint32)colorBuffer->surface.width);
-		gx2WriteGather_submitU32AsBE((uint32)colorBuffer->surface.height);
-		gx2WriteGather_submitU32AsBE((uint32)colorBuffer->surface.pitch);
-		gx2WriteGather_submitU32AsBE(_swapEndianU32(colorBuffer->viewFirstSlice));
-		gx2WriteGather_submitU32AsBE(_swapEndianU32(colorBuffer->viewNumSlices));
-		gx2WriteGather_submitU32AsBE(memory_virtualToPhysical(depthBuffer->surface.imagePtr));
-		gx2WriteGather_submitU32AsBE((uint32)depthBuffer->surface.format.value());
-		gx2WriteGather_submitU32AsBE((uint32)depthBuffer->surface.tileMode.value());
-		gx2WriteGather_submitU32AsBE((uint32)depthBuffer->surface.width);
-		gx2WriteGather_submitU32AsBE((uint32)depthBuffer->surface.height);
-		gx2WriteGather_submitU32AsBE((uint32)depthBuffer->surface.pitch);
-		gx2WriteGather_submitU32AsBE(_swapEndianU32(depthBuffer->viewFirstSlice));
-		gx2WriteGather_submitU32AsBE(_swapEndianU32(depthBuffer->viewNumSlices));
-
-		gx2WriteGather_submitU32AsBE((uint32)(r * 255.0f));
-		gx2WriteGather_submitU32AsBE((uint32)(g * 255.0f));
-		gx2WriteGather_submitU32AsBE((uint32)(b * 255.0f));
-		gx2WriteGather_submitU32AsBE((uint32)(a * 255.0f));
-
-		gx2WriteGather_submitU32AsBE(*(uint32*)&depthClearValue); // clear depth
-		gx2WriteGather_submitU32AsBE(stencilClearValue&0xFF); // clear stencil
+		float colorRGBA[4] = { r, g, b, a };
+		SubmitHLEClear(colorBuffer, colorRGBA, depthBuffer, depthClearValue, stencilClearValue, true, (clearFlags & GX2ClearFlags::CLEAR_DEPTH) != 0, (clearFlags & GX2ClearFlags::CLEAR_STENCIL) != 0);
 	}
 
 	// always uses passed depthClearValue/stencilClearValue for clearing, even if clear flags dont specify value updates
 	void GX2ClearDepthStencilEx(GX2DepthBuffer* depthBuffer, float depthClearValue, uint8 stencilClearValue, GX2ClearFlags clearFlags)
 	{
-		GX2ReserveCmdSpace(50);
-
 		if (!depthBuffer && (depthBuffer->surface.width == 0 || depthBuffer->surface.height == 0))
 		{
 			// Super Smash Bros tries to clear an uninitialized depth surface?
@@ -175,41 +198,8 @@ namespace GX2
 
 		_updateDepthStencilClearRegs(depthClearValue, stencilClearValue, clearFlags);
 
-		uint32 hleClearFlags = 0;
-		if ((clearFlags & GX2ClearFlags::CLEAR_DEPTH) != 0)
-			hleClearFlags |= 2;
-		if ((clearFlags & GX2ClearFlags::CLEAR_STENCIL) != 0)
-			hleClearFlags |= 4;
-
-		// send command to clear color, depth and stencil
-		if (hleClearFlags != 0)
-		{
-			gx2WriteGather_submitU32AsBE(pm4HeaderType3(IT_HLE_CLEAR_COLOR_DEPTH_STENCIL, 23));
-			gx2WriteGather_submitU32AsBE(hleClearFlags); // color (1), depth (2), stencil (4)
-			gx2WriteGather_submitU32AsBE(MPTR_NULL);
-			gx2WriteGather_submitU32AsBE(0); // format for color buffer
-			gx2WriteGather_submitU32AsBE(0); // tilemode for color buffer
-			gx2WriteGather_submitU32AsBE(0);
-			gx2WriteGather_submitU32AsBE(0);
-			gx2WriteGather_submitU32AsBE(0);
-			gx2WriteGather_submitU32AsBE(0);
-			gx2WriteGather_submitU32AsBE(0);
-			gx2WriteGather_submitU32AsBE(memory_virtualToPhysical(depthBuffer->surface.imagePtr));
-			gx2WriteGather_submitU32AsBE((uint32)depthBuffer->surface.format.value());
-			gx2WriteGather_submitU32AsBE((uint32)depthBuffer->surface.tileMode.value());
-			gx2WriteGather_submitU32AsBE((uint32)depthBuffer->surface.width);
-			gx2WriteGather_submitU32AsBE((uint32)depthBuffer->surface.height);
-			gx2WriteGather_submitU32AsBE((uint32)depthBuffer->surface.pitch);
-			gx2WriteGather_submitU32AsBE(_swapEndianU32(depthBuffer->viewFirstSlice));
-			gx2WriteGather_submitU32AsBE(_swapEndianU32(depthBuffer->viewNumSlices));
-			gx2WriteGather_submitU32AsBE(0);
-			gx2WriteGather_submitU32AsBE(0);
-			gx2WriteGather_submitU32AsBE(0);
-			gx2WriteGather_submitU32AsBE(0);
-
-			gx2WriteGather_submitU32AsBE(*(uint32*)&depthClearValue); // clear depth
-			gx2WriteGather_submitU32AsBE(stencilClearValue & 0xFF); // clear stencil
-		}
+		float colorRGBA[4] = { 0.0f, 0.0f, 0.0f, 0.0f };
+		SubmitHLEClear(nullptr, colorRGBA, depthBuffer, depthClearValue, stencilClearValue, false, (clearFlags & GX2ClearFlags::CLEAR_DEPTH) != 0, (clearFlags & GX2ClearFlags::CLEAR_STENCIL) != 0);
 	}
 
 	void GX2BlitInit()
diff --git a/src/Cafe/OS/libs/gx2/GX2_Command.cpp b/src/Cafe/OS/libs/gx2/GX2_Command.cpp
index 0f4f1343..d12bf210 100644
--- a/src/Cafe/OS/libs/gx2/GX2_Command.cpp
+++ b/src/Cafe/OS/libs/gx2/GX2_Command.cpp
@@ -3,196 +3,419 @@
 #include "Cafe/OS/common/OSCommon.h"
 #include "Cafe/HW/Latte/Core/LattePM4.h"
 #include "Cafe/OS/libs/coreinit/coreinit.h"
+#include "Cafe/OS/libs/coreinit/coreinit_Thread.h"
+#include "Cafe/OS/libs/TCL/TCL.h"
 #include "Cafe/HW/Latte/ISA/RegDefines.h"
 #include "GX2.h"
 #include "GX2_Command.h"
 #include "GX2_Shader.h"
 #include "GX2_Misc.h"
+#include "OS/libs/coreinit/coreinit_MEM.h"
 
-extern uint8* gxRingBufferReadPtr;
-
-GX2WriteGatherPipeState gx2WriteGatherPipe = { 0 };
+namespace GX2
+{
+	GX2PerCoreCBState s_perCoreCBState[Espresso::CORE_COUNT];
+}
 
 void gx2WriteGather_submitU32AsBE(uint32 v)
 {
-	uint32 coreIndex = PPCInterpreter_getCoreIndex(ppcInterpreterCurrentInstance);
-	if (gx2WriteGatherPipe.writeGatherPtrWrite[coreIndex] == NULL)
+	uint32 coreIndex = PPCInterpreter_getCoreIndex(PPCInterpreter_getCurrentInstance());
+	if (GX2::s_perCoreCBState[coreIndex].currentWritePtr == nullptr)
 		return;
-	*(uint32*)(*gx2WriteGatherPipe.writeGatherPtrWrite[coreIndex]) = _swapEndianU32(v);
-	(*gx2WriteGatherPipe.writeGatherPtrWrite[coreIndex]) += 4;
+	*(uint32*)(GX2::s_perCoreCBState[coreIndex].currentWritePtr) = _swapEndianU32(v);
+	GX2::s_perCoreCBState[coreIndex].currentWritePtr++;
+	cemu_assert_debug(GX2::s_perCoreCBState[coreIndex].currentWritePtr <= (GX2::s_perCoreCBState[coreIndex].bufferPtr + GX2::s_perCoreCBState[coreIndex].bufferSizeInU32s));
 }
 
 void gx2WriteGather_submitU32AsLE(uint32 v)
 {
-	uint32 coreIndex = PPCInterpreter_getCoreIndex(ppcInterpreterCurrentInstance);
-	if (gx2WriteGatherPipe.writeGatherPtrWrite[coreIndex] == NULL)
+	uint32 coreIndex = PPCInterpreter_getCoreIndex(PPCInterpreter_getCurrentInstance());
+	if (GX2::s_perCoreCBState[coreIndex].currentWritePtr == nullptr)
 		return;
-	*(uint32*)(*gx2WriteGatherPipe.writeGatherPtrWrite[coreIndex]) = v;
-	(*gx2WriteGatherPipe.writeGatherPtrWrite[coreIndex]) += 4;
+	*(uint32*)(GX2::s_perCoreCBState[coreIndex].currentWritePtr) = v;
+	GX2::s_perCoreCBState[coreIndex].currentWritePtr++;
+	cemu_assert_debug(GX2::s_perCoreCBState[coreIndex].currentWritePtr <= (GX2::s_perCoreCBState[coreIndex].bufferPtr + GX2::s_perCoreCBState[coreIndex].bufferSizeInU32s));
 }
 
 void gx2WriteGather_submitU32AsLEArray(uint32* v, uint32 numValues)
 {
-	uint32 coreIndex = PPCInterpreter_getCoreIndex(ppcInterpreterCurrentInstance);
-	if (gx2WriteGatherPipe.writeGatherPtrWrite[coreIndex] == NULL)
+	uint32 coreIndex = PPCInterpreter_getCoreIndex(PPCInterpreter_getCurrentInstance());
+	if (GX2::s_perCoreCBState[coreIndex].currentWritePtr == nullptr)
 		return;
-	memcpy_dwords((*gx2WriteGatherPipe.writeGatherPtrWrite[coreIndex]), v, numValues);
-	(*gx2WriteGatherPipe.writeGatherPtrWrite[coreIndex]) += 4 * numValues;
+	memcpy_dwords(GX2::s_perCoreCBState[coreIndex].currentWritePtr, v, numValues);
+	GX2::s_perCoreCBState[coreIndex].currentWritePtr += numValues;
+	cemu_assert_debug(GX2::s_perCoreCBState[coreIndex].currentWritePtr <= (GX2::s_perCoreCBState[coreIndex].bufferPtr + GX2::s_perCoreCBState[coreIndex].bufferSizeInU32s));
 }
 
 namespace GX2
 {
-	sint32 gx2WriteGatherCurrentMainCoreIndex = -1;
-	bool gx2WriteGatherInited = false;
 
-	void GX2Init_writeGather() // init write gather, make current core 
+	struct GX2CommandState // mapped to PPC space since the GPU writes here
+    {
+    	// command pool
+		MEMPTR<uint32be> commandPoolBase;
+    	uint32 commandPoolSizeInU32s;
+		MEMPTR<uint32be> gpuCommandReadPtr;
+		// timestamp
+		uint64be lastSubmissionTime;
+    };
+
+	SysAllocator<GX2CommandState> s_commandState;
+	GX2PerCoreCBState s_mainCoreLastCommandState;
+	bool s_cbBufferIsInternallyAllocated;
+
+	void GX2Command_StartNewCommandBuffer(uint32 numU32s);
+
+	// called from GX2Init. Allocates a 4MB memory chunk from which command buffers are suballocated from
+	void GX2Init_commandBufferPool(void* bufferBase, uint32 bufferSize)
 	{
-		if (gx2WriteGatherPipe.gxRingBuffer == NULL)
-			gx2WriteGatherPipe.gxRingBuffer = (uint8*)malloc(GX2_COMMAND_RING_BUFFER_SIZE);
-		if (gx2WriteGatherCurrentMainCoreIndex == sGX2MainCoreIndex)
-			return; // write gather already configured for same core
-		for (sint32 i = 0; i < PPC_CORE_COUNT; i++)
+		cemu_assert_debug(!s_commandState->commandPoolBase); // should not be allocated already
+    	// setup command buffer pool. If not provided allocate a 4MB or custom size buffer
+		uint32 poolSize = bufferSize ? bufferSize : 0x400000; // 4MB (can be overwritten by custom GX2Init parameters?)
+		if (bufferBase)
 		{
-			if (i == sGX2MainCoreIndex)
+			s_commandState->commandPoolBase = (uint32be*)bufferBase;
+			s_cbBufferIsInternallyAllocated = false;
+		}
+		else
+		{
+			s_commandState->commandPoolBase = (uint32be*)coreinit::_weak_MEMAllocFromDefaultHeapEx(poolSize, 0x100);
+			s_cbBufferIsInternallyAllocated = true;
+		}
+		if (!s_commandState->commandPoolBase)
+		{
+			cemuLog_log(LogType::Force, "GX2: Failed to allocate command buffer pool");
+		}
+		s_commandState->commandPoolSizeInU32s = poolSize / sizeof(uint32be);
+		s_commandState->gpuCommandReadPtr = s_commandState->commandPoolBase;
+		// init per-core command buffer state
+		for (uint32 i = 0; i < Espresso::CORE_COUNT; i++)
+		{
+			s_perCoreCBState[i].bufferPtr = nullptr;
+			s_perCoreCBState[i].bufferSizeInU32s = 0;
+			s_perCoreCBState[i].currentWritePtr = nullptr;
+		}
+		// start first command buffer for main core
+		GX2Command_StartNewCommandBuffer(0x100);
+	}
+
+	void GX2Shutdown_commandBufferPool()
+	{
+		if (!s_commandState->commandPoolBase)
+			return;
+		if (s_cbBufferIsInternallyAllocated)
+			coreinit::_weak_MEMFreeToDefaultHeap(s_commandState->commandPoolBase.GetPtr());
+		s_cbBufferIsInternallyAllocated = false;
+		s_commandState->commandPoolBase = nullptr;
+		s_commandState->commandPoolSizeInU32s = 0;
+		s_commandState->gpuCommandReadPtr = nullptr;
+	}
+
+	// current position of where the GPU is reading from. Updated via a memory write command submitted to the GPU
+	uint32 GX2Command_GetPoolGPUReadIndex()
+	{
+		stdx::atomic_ref<MEMPTR<uint32be>> _readPtr(s_commandState->gpuCommandReadPtr);
+		MEMPTR<uint32be> currentReadPtr = _readPtr.load();
+		cemu_assert_debug(currentReadPtr);
+		return (uint32)(currentReadPtr.GetPtr() - s_commandState->commandPoolBase.GetPtr());
+	}
+
+	void GX2Command_WaitForNextBufferRetired()
+	{
+		uint64 retiredTimeStamp = GX2GetRetiredTimeStamp();
+		retiredTimeStamp += 1;
+		// but cant be higher than the submission timestamp
+		stdx::atomic_ref<uint64be> _lastSubmissionTime(s_commandState->lastSubmissionTime);
+		uint64 submissionTimeStamp = _lastSubmissionTime.load();
+		if (retiredTimeStamp > submissionTimeStamp)
+			retiredTimeStamp = submissionTimeStamp;
+		GX2WaitTimeStamp(retiredTimeStamp);
+	}
+
+	void GX2Command_SetupCoreCommandBuffer(uint32be* buffer, uint32 sizeInU32s, bool isDisplayList)
+	{
+		uint32 coreIndex = coreinit::OSGetCoreId();
+		auto& coreCBState = s_perCoreCBState[coreIndex];
+		coreCBState.bufferPtr = buffer;
+		coreCBState.bufferSizeInU32s = sizeInU32s;
+		coreCBState.currentWritePtr = buffer;
+		coreCBState.isDisplayList = isDisplayList;
+	}
+
+	void GX2Command_StartNewCommandBuffer(uint32 numU32s)
+	{
+		// On submission command buffers are padded to 32 byte alignment
+		// but nowhere is it guaranteed that internal command buffers have their size aligned to 32 byte (even on console, but testing is required)
+		// Thus the padding can write out of bounds but this seems to trigger only very rarely in partice. As a workaround we always pad the command buffer size to 32 bytes here
+		numU32s = (numU32s + 7) & ~0x7;
+
+		uint32 coreIndex = coreinit::OSGetCoreId();
+		auto& coreCBState = s_perCoreCBState[coreIndex];
+		numU32s = std::max<uint32>(numU32s, 0x100);
+		// grab space from command buffer pool and if necessary wait for it
+		uint32be* bufferPtr = nullptr;
+		uint32 bufferSizeInU32s = 0;
+		uint32 readIndex;
+		while (true)
+		{
+			// try to grab buffer data from first available spot:
+			// 1. At the current write location up to the end of the buffer (avoiding an overlap with the read location)
+			// 2. From the start of the buffer up to the read location
+			readIndex = GX2Command_GetPoolGPUReadIndex();
+			uint32be* nextWritePos = coreCBState.bufferPtr ? coreCBState.bufferPtr + coreCBState.bufferSizeInU32s : s_commandState->commandPoolBase.GetPtr();
+			uint32 writeIndex = nextWritePos - s_commandState->commandPoolBase;
+			uint32 poolSizeInU32s = s_commandState->commandPoolSizeInU32s;
+			// readIndex == writeIndex can mean either buffer full or buffer empty
+			// we could use GX2GetRetiredTimeStamp() == GX2GetLastSubmittedTimeStamp() to determine if the buffer is truly empty
+			// but this can have false negatives since the last submission timestamp is updated independently of the read index
+			// so instead we just avoid ever filling the buffer completely
+			cemu_assert_debug(readIndex < poolSizeInU32s);
+			cemu_assert_debug(writeIndex < poolSizeInU32s);
+			if (writeIndex < readIndex)
 			{
-				gx2WriteGatherPipe.writeGatherPtrGxBuffer[i] = gx2WriteGatherPipe.gxRingBuffer;
-				gx2WriteGatherPipe.writeGatherPtrWrite[i] = &gx2WriteGatherPipe.writeGatherPtrGxBuffer[i];
+				// writeIndex has wrapped around
+				uint32 wordsAvailable = readIndex - writeIndex;
+				if (wordsAvailable > 0)
+					wordsAvailable--; // avoid writeIndex becoming equal to readIndex
+				if (wordsAvailable >= numU32s)
+				{
+					bufferPtr = s_commandState->commandPoolBase + writeIndex;
+					bufferSizeInU32s = wordsAvailable;
+					break;
+				}
 			}
 			else
 			{
-				gx2WriteGatherPipe.writeGatherPtrGxBuffer[i] = NULL;
-				gx2WriteGatherPipe.writeGatherPtrWrite[i] = NULL;
+				uint32 wordsAvailable = poolSizeInU32s - writeIndex;
+				if (wordsAvailable > 0)
+					wordsAvailable--; // avoid writeIndex becoming equal to readIndex
+				if (wordsAvailable >= numU32s)
+				{
+					bufferPtr = nextWritePos;
+					bufferSizeInU32s = wordsAvailable;
+					break;
+				}
+				// not enough space at end of buffer, try to grab from the beginning of the buffer
+				wordsAvailable = readIndex;
+				if (wordsAvailable > 0)
+					wordsAvailable--; // avoid writeIndex becoming equal to readIndex
+				if (wordsAvailable >= numU32s)
+				{
+					bufferPtr = s_commandState->commandPoolBase;
+					bufferSizeInU32s = wordsAvailable;
+					break;
+				}
 			}
-			gx2WriteGatherPipe.displayListStart[i] = MPTR_NULL;
-			gx2WriteGatherPipe.writeGatherPtrDisplayList[i] = NULL;
-			gx2WriteGatherPipe.displayListMaxSize[i] = 0;
+			GX2Command_WaitForNextBufferRetired();
+		}
+		cemu_assert_debug(bufferPtr);
+		bufferSizeInU32s = std::min<uint32>(numU32s, 0x20000); // size cap
+#ifdef CEMU_DEBUG_ASSERT
+		uint32 newWriteIndex = ((bufferPtr - s_commandState->commandPoolBase) + bufferSizeInU32s) % s_commandState->commandPoolSizeInU32s;
+		cemu_assert_debug(newWriteIndex != readIndex);
+#endif
+		// setup buffer and make it the current write gather target
+		cemu_assert_debug(bufferPtr >= s_commandState->commandPoolBase && (bufferPtr + bufferSizeInU32s) <= s_commandState->commandPoolBase + s_commandState->commandPoolSizeInU32s);
+		GX2Command_SetupCoreCommandBuffer(bufferPtr, bufferSizeInU32s, false);
+	}
+
+	void GX2Command_SubmitCommandBuffer(uint32be* buffer, uint32 sizeInU32s, MEMPTR<uint32be>* completionGPUReadPointer, bool triggerMarkerInterrupt)
+	{
+		uint32be cmd[10];
+		uint32 cmdLen = 4;
+		cmd[0] = pm4HeaderType3(IT_INDIRECT_BUFFER_PRIV, 3);
+		cmd[1] = memory_virtualToPhysical(MEMPTR<void>(buffer).GetMPTR());
+		cmd[2] = 0x00000000; // address high bits
+		cmd[3] = sizeInU32s;
+		if (completionGPUReadPointer)
+		{
+			// append command to update completionGPUReadPointer after the GPU is done with the command buffer
+			cmd[4] = pm4HeaderType3(IT_MEM_WRITE, 4);
+			cmd[5] = memory_virtualToPhysical(MEMPTR<void>(completionGPUReadPointer).GetMPTR()) | 2;
+			cmd[6] = 0x40000;
+			cmd[7] = MEMPTR<void>(buffer + sizeInU32s).GetMPTR(); // value to write
+			cmd[8] = 0x00000000;
+			cmdLen = 9;
+		}
+
+		betype<TCL::TCLSubmissionFlag> submissionFlags{};
+		if (!triggerMarkerInterrupt)
+			submissionFlags |= TCL::TCLSubmissionFlag::NO_MARKER_INTERRUPT;
+		submissionFlags |= TCL::TCLSubmissionFlag::USE_RETIRED_MARKER;
+
+		TCL::TCLSubmitToRing(cmd, cmdLen, &submissionFlags, &s_commandState->lastSubmissionTime);
+	}
+
+	void GX2Command_PadCurrentBuffer()
+	{
+		uint32 coreIndex = coreinit::OSGetCoreId();
+		auto& coreCBState = s_perCoreCBState[coreIndex];
+		if (!coreCBState.currentWritePtr)
+			return;
+		uint32 writeDistance = (uint32)(coreCBState.currentWritePtr - coreCBState.bufferPtr);
+		if ((writeDistance&7) != 0)
+		{
+			uint32 distanceToPad = 0x8 - (writeDistance & 0x7);
+			while (distanceToPad)
+			{
+				*coreCBState.currentWritePtr = pm4HeaderType2Filler();
+				coreCBState.currentWritePtr++;
+				distanceToPad--;
+			}
+		}
+	}
+
+	void GX2Command_Flush(uint32 numU32sForNextBuffer, bool triggerMarkerInterrupt)
+	{
+		uint32 coreIndex = coreinit::OSGetCoreId();
+		auto& coreCBState = s_perCoreCBState[coreIndex];
+		if (coreCBState.isDisplayList)
+		{
+			// display list
+			cemu_assert_debug((uint32)(coreCBState.currentWritePtr - coreCBState.bufferPtr) < coreCBState.bufferSizeInU32s);
+			cemuLog_logDebugOnce(LogType::Force, "GX2 flush called on display list");
+		}
+		else
+		{
+			// command buffer
+			if (coreCBState.currentWritePtr != coreCBState.bufferPtr)
+			{
+				// pad the command buffer to 32 byte alignment
+				GX2Command_PadCurrentBuffer();
+				// submit it to the GPU
+				uint32 bufferLength = (uint32)(coreCBState.currentWritePtr - coreCBState.bufferPtr);
+				cemu_assert_debug(bufferLength <= coreCBState.bufferSizeInU32s);
+				GX2Command_SubmitCommandBuffer(coreCBState.bufferPtr, bufferLength, &s_commandState->gpuCommandReadPtr, triggerMarkerInterrupt);
+				GX2Command_StartNewCommandBuffer(numU32sForNextBuffer);
+			}
+			else
+			{
+				// current buffer is empty so we dont need to queue it
+				if (numU32sForNextBuffer > s_commandState->commandPoolSizeInU32s)
+					GX2Command_StartNewCommandBuffer(numU32sForNextBuffer);
+			}
+		}
+	}
+
+	void GX2Flush()
+	{
+		GX2Command_Flush(256, true);
+	}
+
+	uint64 GX2GetLastSubmittedTimeStamp()
+	{
+		stdx::atomic_ref<uint64be> _lastSubmissionTime(s_commandState->lastSubmissionTime);
+		return _lastSubmissionTime.load();
+	}
+
+	uint64 GX2GetRetiredTimeStamp()
+	{
+		uint64be ts = 0;
+		TCL::TCLTimestamp(TCL::TCLTimestampId::TIMESTAMP_LAST_BUFFER_RETIRED, &ts);
+		return ts;
+	}
+
+	bool GX2WaitTimeStamp(uint64 tsWait)
+	{
+		// handle GPU timeout here? But for now we timeout after 60 seconds
+		TCL::TCLWaitTimestamp(TCL::TCLTimestampId::TIMESTAMP_LAST_BUFFER_RETIRED, tsWait, Espresso::TIMER_CLOCK * 60);
+		return true;
+	}
+
+	/*
+	 * Guarantees that the requested amount of space is available on the current command buffer
+	 * If the space is not available, the current command buffer is pushed to the GPU and a new one is allocated
+	 */
+	void GX2ReserveCmdSpace(uint32 reservedFreeSpaceInU32)
+	{
+		uint32 coreIndex = coreinit::OSGetCoreId();
+		auto& coreCBState = s_perCoreCBState[coreIndex];
+		if (coreCBState.currentWritePtr == nullptr)
+			return;
+		uint32 writeDistance = (uint32)(coreCBState.currentWritePtr - coreCBState.bufferPtr);
+		if (writeDistance + reservedFreeSpaceInU32 > coreCBState.bufferSizeInU32s)
+		{
+			GX2Command_Flush(reservedFreeSpaceInU32, true);
 		}
-		gx2WriteGatherCurrentMainCoreIndex = sGX2MainCoreIndex;
-		gx2WriteGatherInited = true;
 	}
 
 	void GX2WriteGather_beginDisplayList(PPCInterpreter_t* hCPU, MPTR buffer, uint32 maxSize)
 	{
 		uint32 coreIndex = PPCInterpreter_getCoreIndex(hCPU);
-		gx2WriteGatherPipe.displayListStart[coreIndex] = buffer;
-		gx2WriteGatherPipe.displayListMaxSize[coreIndex] = maxSize;
-		// set new write gather ptr
-		gx2WriteGatherPipe.writeGatherPtrDisplayList[coreIndex] = memory_getPointerFromVirtualOffset(gx2WriteGatherPipe.displayListStart[coreIndex]);
-		gx2WriteGatherPipe.writeGatherPtrWrite[coreIndex] = &gx2WriteGatherPipe.writeGatherPtrDisplayList[coreIndex];
+		if (coreIndex == sGX2MainCoreIndex)
+		{
+			GX2Command_PadCurrentBuffer();
+			cemu_assert_debug(!s_perCoreCBState[coreIndex].isDisplayList);
+			s_mainCoreLastCommandState = s_perCoreCBState[coreIndex];
+		}
+		GX2Command_SetupCoreCommandBuffer(MEMPTR<uint32be>(buffer), maxSize/4, true);
 	}
 
 	uint32 GX2WriteGather_getDisplayListWriteDistance(sint32 coreIndex)
 	{
-		return (uint32)(*gx2WriteGatherPipe.writeGatherPtrWrite[coreIndex] - memory_getPointerFromVirtualOffset(gx2WriteGatherPipe.displayListStart[coreIndex]));
-	}
-
-	uint32 GX2WriteGather_getFifoWriteDistance(uint32 coreIndex)
-	{
-		uint32 writeDistance = (uint32)(gx2WriteGatherPipe.writeGatherPtrGxBuffer[coreIndex] - gx2WriteGatherPipe.gxRingBuffer);
-		return writeDistance;
+		auto& coreCBState = s_perCoreCBState[coreIndex];
+		cemu_assert_debug(coreCBState.isDisplayList);
+		if (coreCBState.currentWritePtr == nullptr)
+			return 0;
+		return (uint32)(coreCBState.currentWritePtr - coreCBState.bufferPtr) * 4;
 	}
 
 	uint32 GX2WriteGather_endDisplayList(PPCInterpreter_t* hCPU, MPTR buffer)
 	{
-		uint32 coreIndex = PPCInterpreter_getCoreIndex(hCPU);
-		if (gx2WriteGatherPipe.displayListStart[coreIndex] != MPTR_NULL)
+		uint32 coreIndex = coreinit::OSGetCoreId();
+		auto& coreCBState = s_perCoreCBState[coreIndex];
+		GX2Command_PadCurrentBuffer();
+		uint32 finalWriteIndex = coreCBState.currentWritePtr - coreCBState.bufferPtr;
+		cemu_assert_debug(finalWriteIndex <= coreCBState.bufferSizeInU32s);
+		// if we are on the main GX2 core then restore the GPU command buffer
+		if (coreIndex == sGX2MainCoreIndex)
 		{
-			uint32 currentWriteSize = GX2WriteGather_getDisplayListWriteDistance(coreIndex);
-			// pad to 32 byte
-			if (gx2WriteGatherPipe.displayListMaxSize[coreIndex] >= ((gx2WriteGatherPipe.displayListMaxSize[coreIndex] + 0x1F) & ~0x1F))
-			{
-				while ((currentWriteSize & 0x1F) != 0)
-				{
-					gx2WriteGather_submitU32AsBE(pm4HeaderType2Filler());
-					currentWriteSize += 4;
-				}
-			}
-			// get size of written data
-			currentWriteSize = GX2WriteGather_getDisplayListWriteDistance(coreIndex);
-			// disable current display list and restore write gather ptr
-			gx2WriteGatherPipe.displayListStart[coreIndex] = MPTR_NULL;
-			if (sGX2MainCoreIndex == coreIndex)
-				gx2WriteGatherPipe.writeGatherPtrWrite[coreIndex] = &gx2WriteGatherPipe.writeGatherPtrGxBuffer[coreIndex];
-			else
-				gx2WriteGatherPipe.writeGatherPtrWrite[coreIndex] = NULL;
-			// return size of (written) display list
-			return currentWriteSize;
+  			coreCBState = s_mainCoreLastCommandState;
 		}
 		else
 		{
-			// no active display list
-			// return a size of 0
-			return 0;
+			coreCBState.bufferPtr = nullptr;
+			coreCBState.currentWritePtr = nullptr;
+			coreCBState.bufferSizeInU32s = 0;
+			coreCBState.isDisplayList = false;
 		}
+		return finalWriteIndex * 4;
 	}
 
-	bool GX2GetCurrentDisplayList(betype<MPTR>* displayListAddr, uint32be* displayListSize)
+	bool GX2GetCurrentDisplayList(MEMPTR<uint32be>* displayListAddr, uint32be* displayListSize)
 	{
-		uint32 coreIndex = PPCInterpreter_getCoreIndex(ppcInterpreterCurrentInstance);
-		if (gx2WriteGatherPipe.displayListStart[coreIndex] == MPTR_NULL)
+		uint32 coreIndex = coreinit::OSGetCoreId();
+		auto& coreCBState = s_perCoreCBState[coreIndex];
+		if (!coreCBState.isDisplayList)
 			return false;
-
 		if (displayListAddr)
-			*displayListAddr = gx2WriteGatherPipe.displayListStart[coreIndex];
+			*displayListAddr = coreCBState.bufferPtr;
 		if (displayListSize)
-			*displayListSize = gx2WriteGatherPipe.displayListMaxSize[coreIndex];
-
+			*displayListSize = coreCBState.bufferSizeInU32s * sizeof(uint32be);
 		return true;
 	}
 
+	// returns true if we are writing to a display list
 	bool GX2GetDisplayListWriteStatus()
 	{
-		// returns true if we are writing to a display list
-		uint32 coreIndex = PPCInterpreter_getCoreIndex(ppcInterpreterCurrentInstance);
-		return gx2WriteGatherPipe.displayListStart[coreIndex] != MPTR_NULL;
-	}
-
-	bool GX2WriteGather_isDisplayListActive()
-	{
-		uint32 coreIndex = PPCInterpreter_getCoreIndex(ppcInterpreterCurrentInstance);
-		if (gx2WriteGatherPipe.displayListStart[coreIndex] != MPTR_NULL)
-			return true;
-		return false;
-	}
-
-	uint32 GX2WriteGather_getReadWriteDistance()
-	{
-		uint32 coreIndex = sGX2MainCoreIndex;
-		uint32 writeDistance = (uint32)(gx2WriteGatherPipe.writeGatherPtrGxBuffer[coreIndex] + GX2_COMMAND_RING_BUFFER_SIZE - gxRingBufferReadPtr);
-		writeDistance %= GX2_COMMAND_RING_BUFFER_SIZE;
-		return writeDistance;
-	}
-
-	void GX2WriteGather_checkAndInsertWrapAroundMark()
-	{
-		uint32 coreIndex = PPCInterpreter_getCoreIndex(ppcInterpreterCurrentInstance);
-		if (coreIndex != sGX2MainCoreIndex) // only if main gx2 core
-			return;
-		if (gx2WriteGatherPipe.displayListStart[coreIndex] != MPTR_NULL)
-			return;
-		uint32 writeDistance = GX2WriteGather_getFifoWriteDistance(coreIndex);
-		if (writeDistance >= (GX2_COMMAND_RING_BUFFER_SIZE * 3 / 5))
-		{
-			gx2WriteGather_submitU32AsBE(pm4HeaderType3(IT_HLE_FIFO_WRAP_AROUND, 1));
-			gx2WriteGather_submitU32AsBE(0); // empty word since we can't send commands with zero data words
-			gx2WriteGatherPipe.writeGatherPtrGxBuffer[coreIndex] = gx2WriteGatherPipe.gxRingBuffer;
-		}
+		uint32 coreIndex = coreinit::OSGetCoreId();
+		return s_perCoreCBState[coreIndex].isDisplayList;
 	}
 
 	void GX2BeginDisplayList(MEMPTR<void> displayListAddr, uint32 size)
 	{
-		GX2WriteGather_beginDisplayList(ppcInterpreterCurrentInstance, displayListAddr.GetMPTR(), size);
+		GX2WriteGather_beginDisplayList(PPCInterpreter_getCurrentInstance(), displayListAddr.GetMPTR(), size);
 	}
 
 	void GX2BeginDisplayListEx(MEMPTR<void> displayListAddr, uint32 size, bool profiling)
 	{
-		GX2WriteGather_beginDisplayList(ppcInterpreterCurrentInstance, displayListAddr.GetMPTR(), size);
+		GX2WriteGather_beginDisplayList(PPCInterpreter_getCurrentInstance(), displayListAddr.GetMPTR(), size);
 	}
 
 	uint32 GX2EndDisplayList(MEMPTR<void> displayListAddr)
 	{
 		cemu_assert_debug(displayListAddr != nullptr);
-		uint32 displayListSize = GX2WriteGather_endDisplayList(ppcInterpreterCurrentInstance, displayListAddr.GetMPTR());
+		uint32 displayListSize = GX2WriteGather_endDisplayList(PPCInterpreter_getCurrentInstance(), displayListAddr.GetMPTR());
 		return displayListSize;
 	}
 
@@ -205,28 +428,23 @@ namespace GX2
 			memory_virtualToPhysical(addr),
 			0, // high address bits
 			size / 4);
-		GX2::GX2WriteGather_checkAndInsertWrapAroundMark();
 	}
 
 	void GX2DirectCallDisplayList(void* addr, uint32 size)
 	{
 		// this API submits to TCL directly and bypasses write-gatherer
 		// its basically a way to manually submit a command buffer to the GPU
-		// as such it also affects the submission and retire timestamps
-
-		uint32 coreIndex = PPCInterpreter_getCoreIndex(ppcInterpreterCurrentInstance);
-		cemu_assert_debug(coreIndex == sGX2MainCoreIndex);
-		coreIndex = sGX2MainCoreIndex; // always submit to main queue which is owned by GX2 main core (TCLSubmitToRing does not need this workaround)
-
-		uint32be* cmdStream = (uint32be*)(gx2WriteGatherPipe.writeGatherPtrGxBuffer[coreIndex]);
-		cmdStream[0] = pm4HeaderType3(IT_INDIRECT_BUFFER_PRIV, 3);
-		cmdStream[1] = memory_virtualToPhysical(MEMPTR<void>(addr).GetMPTR());
-		cmdStream[2] = 0;
-		cmdStream[3] = size / 4;
-		gx2WriteGatherPipe.writeGatherPtrGxBuffer[coreIndex] += 16;
-
-		// update submission timestamp and retired timestamp
-		_GX2SubmitToTCL();
+		uint32 coreIndex = coreinit::OSGetCoreId();
+		if (coreIndex != sGX2MainCoreIndex)
+		{
+			cemuLog_logDebugOnce(LogType::Force, "GX2DirectCallDisplayList() called on non-main GX2 core");
+		}
+		if (!s_perCoreCBState[coreIndex].isDisplayList)
+		{
+			// make sure any preceeding commands are submitted first
+			GX2Command_Flush(0x100, false);
+		}
+		GX2Command_SubmitCommandBuffer(static_cast<uint32be*>(addr), size / 4, nullptr, false);
 	}
 
 	void GX2CopyDisplayList(MEMPTR<uint32be*> addr, uint32 size)
@@ -257,7 +475,7 @@ namespace GX2
 
 		if (patchType == GX2_PATCH_TYPE::VERTEX_SHADER)
 		{
-			GX2VertexShader_t* vertexShader = (GX2VertexShader_t*)obj;
+			GX2VertexShader* vertexShader = (GX2VertexShader*)obj;
 			displayData[patchOffset / 4 + 2] = memory_virtualToPhysical(vertexShader->GetProgramAddr()) >> 8;
 		}
 		else if (patchType == GX2_PATCH_TYPE::PIXEL_SHADER)
@@ -267,7 +485,7 @@ namespace GX2
 		}
 		else if (patchType == GX2_PATCH_TYPE::FETCH_SHADER)
 		{
-			GX2FetchShader_t* fetchShader = (GX2FetchShader_t*)obj;
+			GX2FetchShader* fetchShader = (GX2FetchShader*)obj;
 			displayData[patchOffset / 4 + 2] = memory_virtualToPhysical(fetchShader->GetProgramAddr()) >> 8;
 		}
 		else if (patchType == GX2_PATCH_TYPE::GEOMETRY_COPY_SHADER)
@@ -282,13 +500,18 @@ namespace GX2
 		}
 		else
 		{
-			forceLog_printf("GX2PatchDisplayList(): unsupported patchType %d", (uint32)patchType);
+			cemuLog_log(LogType::Force, "GX2PatchDisplayList(): unsupported patchType {}", (uint32)patchType);
 			cemu_assert_debug(false);
 		}
 	}
 
 	void GX2CommandInit()
 	{
+		cafeExportRegister("gx2", GX2Flush, LogType::GX2);
+
+		cafeExportRegister("gx2", GX2GetLastSubmittedTimeStamp, LogType::GX2);
+		cafeExportRegister("gx2", GX2GetRetiredTimeStamp, LogType::GX2);
+		cafeExportRegister("gx2", GX2WaitTimeStamp, LogType::GX2);
 
 		cafeExportRegister("gx2", GX2BeginDisplayList, LogType::GX2);
 		cafeExportRegister("gx2", GX2BeginDisplayListEx, LogType::GX2);
@@ -297,7 +520,6 @@ namespace GX2
 		cafeExportRegister("gx2", GX2GetCurrentDisplayList, LogType::GX2);
 		cafeExportRegister("gx2", GX2GetDisplayListWriteStatus, LogType::GX2);
 
-
 		cafeExportRegister("gx2", GX2CallDisplayList, LogType::GX2);
 		cafeExportRegister("gx2", GX2DirectCallDisplayList, LogType::GX2);
 		cafeExportRegister("gx2", GX2CopyDisplayList, LogType::GX2);
@@ -305,4 +527,12 @@ namespace GX2
 		cafeExportRegister("gx2", GX2PatchDisplayList, LogType::GX2);
 	}
 
-}
\ No newline at end of file
+    void GX2CommandResetToDefaultState()
+    {
+		s_commandState->commandPoolBase = nullptr;
+		s_commandState->commandPoolSizeInU32s = 0;
+		s_commandState->gpuCommandReadPtr = nullptr;
+		s_cbBufferIsInternallyAllocated = false;
+    }
+
+}
diff --git a/src/Cafe/OS/libs/gx2/GX2_Command.h b/src/Cafe/OS/libs/gx2/GX2_Command.h
index a8d3671f..00f5d427 100644
--- a/src/Cafe/OS/libs/gx2/GX2_Command.h
+++ b/src/Cafe/OS/libs/gx2/GX2_Command.h
@@ -2,21 +2,19 @@
 #include "Cafe/HW/Latte/ISA/LatteReg.h"
 #include "Cafe/HW/Espresso/Const.h"
 
-struct GX2WriteGatherPipeState
+namespace GX2
 {
-	uint8* gxRingBuffer;
-	// each core has it's own write gatherer and display list state (writing)
-	uint8* writeGatherPtrGxBuffer[Espresso::CORE_COUNT];
-	uint8** writeGatherPtrWrite[Espresso::CORE_COUNT];
-	uint8* writeGatherPtrDisplayList[Espresso::CORE_COUNT];
-	MPTR displayListStart[Espresso::CORE_COUNT];
-	uint32 displayListMaxSize[Espresso::CORE_COUNT];
+	struct GX2PerCoreCBState
+	{
+		uint32be* bufferPtr;
+		uint32 bufferSizeInU32s;
+		uint32be* currentWritePtr;
+		bool isDisplayList;
+	};
+
+	extern GX2PerCoreCBState s_perCoreCBState[Espresso::CORE_COUNT];
 };
 
-extern GX2WriteGatherPipeState gx2WriteGatherPipe;
-
-void GX2ReserveCmdSpace(uint32 reservedFreeSpaceInU32); // move to GX2 namespace eventually
-
 void gx2WriteGather_submitU32AsBE(uint32 v);
 void gx2WriteGather_submitU32AsLE(uint32 v);
 void gx2WriteGather_submitU32AsLEArray(uint32* v, uint32 numValues);
@@ -27,7 +25,8 @@ uint32 PPCInterpreter_getCurrentCoreIndex();
 template <typename ...Targs>
 inline void gx2WriteGather_submit_(uint32 coreIndex, uint32be* writePtr)
 {
-	(*gx2WriteGatherPipe.writeGatherPtrWrite[coreIndex]) = (uint8*)writePtr;
+	GX2::s_perCoreCBState[coreIndex].currentWritePtr = writePtr;
+	cemu_assert_debug(GX2::s_perCoreCBState[coreIndex].currentWritePtr <= (GX2::s_perCoreCBState[coreIndex].bufferPtr + GX2::s_perCoreCBState[coreIndex].bufferSizeInU32s));
 }
 
 template <typename T, typename ...Targs>
@@ -75,19 +74,23 @@ template <typename ...Targs>
 inline void gx2WriteGather_submit(Targs... args)
 {
 	uint32 coreIndex = PPCInterpreter_getCurrentCoreIndex();
-	if (gx2WriteGatherPipe.writeGatherPtrWrite[coreIndex] == nullptr)
+	if (GX2::s_perCoreCBState[coreIndex].currentWritePtr == nullptr)
+	{
+		cemu_assert_suspicious(); // writing to command buffer without valid write pointer?
 		return;
-
-	uint32be* writePtr = (uint32be*)(*gx2WriteGatherPipe.writeGatherPtrWrite[coreIndex]);
+	}
+	uint32be* writePtr = GX2::s_perCoreCBState[coreIndex].currentWritePtr;
 	gx2WriteGather_submit_(coreIndex, writePtr, std::forward<Targs>(args)...);
 }
 
 namespace GX2
 {
+	void GX2Command_Flush(uint32 numU32sForNextBuffer, bool triggerMarkerInterrupt = true);
+	void GX2ReserveCmdSpace(uint32 reservedFreeSpaceInU32);
 
-	bool GX2WriteGather_isDisplayListActive();
-	uint32 GX2WriteGather_getReadWriteDistance();
-	void GX2WriteGather_checkAndInsertWrapAroundMark();
+	uint64 GX2GetLastSubmittedTimeStamp();
+	uint64 GX2GetRetiredTimeStamp();
+	bool GX2WaitTimeStamp(uint64 tsWait);
 
 	void GX2BeginDisplayList(MEMPTR<void> displayListAddr, uint32 size);
 	void GX2BeginDisplayListEx(MEMPTR<void> displayListAddr, uint32 size, bool profiling);
@@ -96,6 +99,10 @@ namespace GX2
 	void GX2CallDisplayList(MPTR addr, uint32 size);
 	void GX2DirectCallDisplayList(void* addr, uint32 size);
 
-	void GX2Init_writeGather();
-	void GX2CommandInit();
+	bool GX2GetDisplayListWriteStatus();
+
+    void GX2CommandInit();
+	void GX2Init_commandBufferPool(void* bufferBase, uint32 bufferSize);
+	void GX2Shutdown_commandBufferPool();
+    void GX2CommandResetToDefaultState();
 }
\ No newline at end of file
diff --git a/src/Cafe/OS/libs/gx2/GX2_ContextState.cpp b/src/Cafe/OS/libs/gx2/GX2_ContextState.cpp
index 5650999f..fb631a11 100644
--- a/src/Cafe/OS/libs/gx2/GX2_ContextState.cpp
+++ b/src/Cafe/OS/libs/gx2/GX2_ContextState.cpp
@@ -168,7 +168,7 @@ uint32 _GX2Context_CalcStateSize()
 
 void _GX2Context_CreateLoadDL()
 {
-	GX2ReserveCmdSpace(3);
+	GX2::GX2ReserveCmdSpace(3);
 	gx2WriteGather_submitU32AsBE(pm4HeaderType3(IT_CONTEXT_CONTROL, 2));
 	gx2WriteGather_submitU32AsBE(0x80000077);
 	gx2WriteGather_submitU32AsBE(0x80000077);
@@ -176,7 +176,7 @@ void _GX2Context_CreateLoadDL()
 
 void _GX2Context_WriteCmdDisableStateShadowing()
 {
-	GX2ReserveCmdSpace(3);
+	GX2::GX2ReserveCmdSpace(3);
 	gx2WriteGather_submitU32AsBE(pm4HeaderType3(IT_CONTEXT_CONTROL, 2));
 	gx2WriteGather_submitU32AsBE(0x80000000);
 	gx2WriteGather_submitU32AsBE(0x80000000);
@@ -184,7 +184,7 @@ void _GX2Context_WriteCmdDisableStateShadowing()
 
 void _GX2Context_cmdLoad(void* gx2ukn, uint32 pm4Header, MPTR physAddrRegArea, uint32 waitForIdle, uint32 numRegOffsetEntries, GX2RegLoadPktEntry_t* regOffsetEntries)
 {
-	GX2ReserveCmdSpace(3 + numRegOffsetEntries*2);
+	GX2::GX2ReserveCmdSpace(3 + numRegOffsetEntries*2);
 	gx2WriteGather_submitU32AsBE(pm4Header);
 	gx2WriteGather_submitU32AsBE(physAddrRegArea);
 	gx2WriteGather_submitU32AsBE(waitForIdle);
@@ -199,7 +199,6 @@ void _GX2Context_cmdLoad(void* gx2ukn, uint32 pm4Header, MPTR physAddrRegArea, u
 
 void _GX2Context_WriteCmdRestoreState(GX2ContextState_t* gx2ContextState, uint32 ukn)
 {
-	GX2::GX2WriteGather_checkAndInsertWrapAroundMark();
 	MPTR physAddrContextState = memory_virtualToPhysical(memory_getVirtualOffsetFromPointer(gx2ContextState));
 	_GX2Context_CreateLoadDL();
 	__cmdStateLoad(NULL, IT_LOAD_CONFIG_REG, gx2ContextState->hwContext.areaConfigReg, 0x80000000, configReg_loadPktEntries);
@@ -212,7 +211,7 @@ void _GX2Context_WriteCmdRestoreState(GX2ContextState_t* gx2ContextState, uint32
 
 void GX2SetDefaultState()
 {
-	GX2ReserveCmdSpace(0x100);
+	GX2::GX2ReserveCmdSpace(0x100);
 
 	Latte::LATTE_PA_CL_VTE_CNTL reg{};
 	reg.set_VPORT_X_OFFSET_ENA(true).set_VPORT_X_SCALE_ENA(true);
@@ -283,7 +282,7 @@ void GX2SetDefaultState()
 
 void gx2Export_GX2SetDefaultState(PPCInterpreter_t* hCPU)
 {
-	gx2Log_printf("GX2SetDefaultState()");
+	cemuLog_log(LogType::GX2, "GX2SetDefaultState()");
 	GX2SetDefaultState();
 	osLib_returnFromFunction(hCPU, 0);
 }
@@ -291,8 +290,7 @@ void gx2Export_GX2SetDefaultState(PPCInterpreter_t* hCPU)
 void _GX2ContextCreateRestoreStateDL(GX2ContextState_t* gx2ContextState)
 {
 	// begin display list
-	if (GX2::GX2WriteGather_isDisplayListActive())
-		assert_dbg();
+	cemu_assert_debug(!GX2::GX2GetDisplayListWriteStatus()); // must not already be writing to a display list
 	GX2::GX2BeginDisplayList((void*)gx2ContextState->loadDL_buffer, sizeof(gx2ContextState->loadDL_buffer));
 	_GX2Context_WriteCmdRestoreState(gx2ContextState, 0);
 	uint32 displayListSize = GX2::GX2EndDisplayList((void*)gx2ContextState->loadDL_buffer);
@@ -301,7 +299,7 @@ void _GX2ContextCreateRestoreStateDL(GX2ContextState_t* gx2ContextState)
 
 void gx2Export_GX2SetupContextStateEx(PPCInterpreter_t* hCPU)
 {
-	gx2Log_printf("GX2SetupContextStateEx(0x%08x)\n", hCPU->gpr[3]);
+	cemuLog_log(LogType::GX2, "GX2SetupContextStateEx(0x{:08x})", hCPU->gpr[3]);
 	cemu_assert_debug(hCPU->gpr[4] == 0 || hCPU->gpr[4] == 1);
 
 	GX2ContextState_t* gx2ContextState = (GX2ContextState_t*)memory_getPointerFromVirtualOffset(hCPU->gpr[3]);
@@ -329,7 +327,7 @@ void gx2Export_GX2SetupContextStateEx(PPCInterpreter_t* hCPU)
 
 void gx2Export_GX2SetContextState(PPCInterpreter_t* hCPU)
 {
-	gx2Log_printf("GX2SetContextState(0x%08x)\n", hCPU->gpr[3]);
+	cemuLog_log(LogType::GX2, "GX2SetContextState(0x{:08x})", hCPU->gpr[3]);
 	// parameters:
 	if( hCPU->gpr[3] == MPTR_NULL )
 	{
@@ -377,10 +375,9 @@ void gx2Export_GX2SetContextState(PPCInterpreter_t* hCPU)
 	osLib_returnFromFunction(hCPU, 0);
 }
 
-
 void gx2Export_GX2GetContextStateDisplayList(PPCInterpreter_t* hCPU)
 {
-	gx2Log_printf("GX2GetContextStateDisplayList(0x%08x, 0x%08x, 0x%08x)\n", hCPU->gpr[3], hCPU->gpr[4], hCPU->gpr[5]);
+	cemuLog_log(LogType::GX2, "GX2GetContextStateDisplayList(0x{:08x}, 0x{:08x}, 0x{:08x})", hCPU->gpr[3], hCPU->gpr[4], hCPU->gpr[5]);
 	ppcDefineParamStructPtr(gx2ContextState, GX2ContextState_t, 0);
 	ppcDefineParamU32BEPtr(displayListPtrOut, 1);
 	ppcDefineParamU32BEPtr(displayListSizeOut, 2);
diff --git a/src/Cafe/OS/libs/gx2/GX2_Draw.cpp b/src/Cafe/OS/libs/gx2/GX2_Draw.cpp
index 053b787b..958978e1 100644
--- a/src/Cafe/OS/libs/gx2/GX2_Draw.cpp
+++ b/src/Cafe/OS/libs/gx2/GX2_Draw.cpp
@@ -52,7 +52,6 @@ namespace GX2
 			0,
 			count,
 			0);
-		GX2::GX2WriteGather_checkAndInsertWrapAroundMark();
 	}
 
 	void GX2DrawIndexedEx2(GX2PrimitiveMode2 primitiveMode, uint32 count, GX2IndexType indexType, void* indexData, uint32 baseVertex, uint32 numInstances, uint32 baseInstance)
@@ -85,7 +84,6 @@ namespace GX2
 			pm4HeaderType3(IT_SET_CTL_CONST, 2), 1,
 			0 // baseInstance
 		);
-		GX2::GX2WriteGather_checkAndInsertWrapAroundMark();
 	}
 
 	void GX2DrawEx(GX2PrimitiveMode2 primitiveMode, uint32 count, uint32 baseVertex, uint32 numInstances)
@@ -109,7 +107,6 @@ namespace GX2
 			count,
 			0 // DRAW_INITIATOR
 		);
-		GX2::GX2WriteGather_checkAndInsertWrapAroundMark();
 	}
 
 	void GX2DrawIndexedImmediateEx(GX2PrimitiveMode2 primitiveMode, uint32 count, GX2IndexType indexType, void* indexData, uint32 baseVertex, uint32 numInstances)
@@ -177,7 +174,6 @@ namespace GX2
 			}
 		}
 
-		GX2::GX2WriteGather_checkAndInsertWrapAroundMark();
 	}
 
 	struct GX2DispatchComputeParam
diff --git a/src/Cafe/OS/libs/gx2/GX2_Event.cpp b/src/Cafe/OS/libs/gx2/GX2_Event.cpp
index ffba8ba5..645f0a79 100644
--- a/src/Cafe/OS/libs/gx2/GX2_Event.cpp
+++ b/src/Cafe/OS/libs/gx2/GX2_Event.cpp
@@ -16,18 +16,6 @@ namespace GX2
 	SysAllocator<coreinit::OSThreadQueue> g_vsyncThreadQueue;
 	SysAllocator<coreinit::OSThreadQueue> g_flipThreadQueue;
 
-	SysAllocator<coreinit::OSEvent> s_updateRetirementEvent;
-	std::atomic<uint64> s_lastRetirementTimestamp = 0;
-
-	// called from GPU code when a command buffer is retired
-	void __GX2NotifyNewRetirementTimestamp(uint64 tsRetire)
-	{
-		__OSLockScheduler();
-		s_lastRetirementTimestamp = tsRetire;
-		coreinit::OSSignalEventAllInternal(s_updateRetirementEvent.GetPtr());
-		__OSUnlockScheduler();
-	}
-
 	void GX2SetGPUFence(uint32be* fencePtr, uint32 mask, uint32 compareOp, uint32 compareValue)
 	{
 		GX2ReserveCmdSpace(7);
@@ -133,7 +121,7 @@ namespace GX2
 	{
 		if ((size_t)eventType >= GX2CallbackEventTypeCount)
 		{
-			forceLog_printf("GX2SetEventCallback(): Unknown eventType\n");
+			cemuLog_log(LogType::Force, "GX2SetEventCallback(): Unknown eventType");
 			return;
 		}
 		s_eventCallback[(size_t)eventType].callbackFuncPtr = callbackFuncPtr;
@@ -144,7 +132,7 @@ namespace GX2
 	{
 		if ((size_t)eventType >= GX2CallbackEventTypeCount)
 		{
-			forceLog_printf("GX2GetEventCallback(): Unknown eventType\n");
+			cemuLog_log(LogType::Force, "GX2GetEventCallback(): Unknown eventType");
 			return;
 		}
 		if (callbackFuncPtrOut)
@@ -210,16 +198,6 @@ namespace GX2
 		osLib_returnFromFunction(hCPU, 0);
 	}
 
-	uint64 GX2GetLastSubmittedTimeStamp()
-	{
-		return LatteGPUState.lastSubmittedCommandBufferTimestamp.load();
-	}
-
-	uint64 GX2GetRetiredTimeStamp()
-	{
-		return s_lastRetirementTimestamp;
-	}
-
 	void GX2WaitForVsync()
 	{
 		__OSLockScheduler();
@@ -236,19 +214,6 @@ namespace GX2
 		__OSUnlockScheduler();
 	}
 
-	bool GX2WaitTimeStamp(uint64 tsWait)
-	{
-		__OSLockScheduler();
-		while (tsWait > s_lastRetirementTimestamp)
-		{
-			// GPU hasn't caught up yet
-			coreinit::OSWaitEventInternal(s_updateRetirementEvent.GetPtr());
-		}
-		__OSUnlockScheduler();
-		// return true to indicate no timeout
-		return true;
-	}
-
 	void GX2DrawDone()
 	{
 		// optional force full sync (texture readback and occlusion queries)
@@ -263,13 +228,10 @@ namespace GX2
 			gx2WriteGather_submitU32AsBE(0x00000000); // unused
 		}
 		// flush pipeline
-		if (_GX2GetUnflushedBytes(PPCInterpreter_getCoreIndex(ppcInterpreterCurrentInstance)) > 0)
-			_GX2SubmitToTCL();
+		GX2Command_Flush(0x100, true);
 
 		uint64 ts = GX2GetLastSubmittedTimeStamp();
 		GX2WaitTimeStamp(ts);
-
-		GX2::GX2WriteGather_checkAndInsertWrapAroundMark();
 	}
 
 	void GX2Init_event()
@@ -294,18 +256,23 @@ namespace GX2
 		cafeExportRegister("gx2", GX2SetEventCallback, LogType::GX2);
 		cafeExportRegister("gx2", GX2GetEventCallback, LogType::GX2);
 
-		cafeExportRegister("gx2", GX2GetLastSubmittedTimeStamp, LogType::GX2);
-		cafeExportRegister("gx2", GX2GetRetiredTimeStamp, LogType::GX2);
-
 		cafeExportRegister("gx2", GX2WaitForVsync, LogType::GX2);
 		cafeExportRegister("gx2", GX2WaitForFlip, LogType::GX2);
-		cafeExportRegister("gx2", GX2WaitTimeStamp, LogType::GX2);
 		cafeExportRegister("gx2", GX2DrawDone, LogType::GX2);
 
 		coreinit::OSInitThreadQueue(g_vsyncThreadQueue.GetPtr());
 		coreinit::OSInitThreadQueue(g_flipThreadQueue.GetPtr());
 
-		coreinit::OSInitEvent(s_updateRetirementEvent, coreinit::OSEvent::EVENT_STATE::STATE_NOT_SIGNALED, coreinit::OSEvent::EVENT_MODE::MODE_AUTO);
 		coreinit::OSInitSemaphore(s_eventCbQueueSemaphore, 0);
 	}
-}
\ No newline at end of file
+
+    void GX2EventResetToDefaultState()
+    {
+        s_callbackThreadLaunched = false;
+        for(auto& it : s_eventCallback)
+        {
+            it.callbackFuncPtr = nullptr;
+            it.userData = nullptr;
+        }
+    }
+}
diff --git a/src/Cafe/OS/libs/gx2/GX2_Event.h b/src/Cafe/OS/libs/gx2/GX2_Event.h
index 70c4ba61..09cb073c 100644
--- a/src/Cafe/OS/libs/gx2/GX2_Event.h
+++ b/src/Cafe/OS/libs/gx2/GX2_Event.h
@@ -2,9 +2,10 @@
 
 namespace GX2
 {
-	void GX2EventInit();
 	void GX2Init_event();
+	void GX2EventResetToDefaultState();
 
+	void GX2EventInit();
 	void GX2WaitForVsync();
 	void GX2WaitForFlip();
 	void GX2DrawDone();
diff --git a/src/Cafe/OS/libs/gx2/GX2_Memory.cpp b/src/Cafe/OS/libs/gx2/GX2_Memory.cpp
index 977fcbac..d5054784 100644
--- a/src/Cafe/OS/libs/gx2/GX2_Memory.cpp
+++ b/src/Cafe/OS/libs/gx2/GX2_Memory.cpp
@@ -34,7 +34,7 @@ void _GX2DefaultAlloc_Free(PPCInterpreter_t* hCPU)
 
 void gx2Export_GX2SetDefaultAllocator(PPCInterpreter_t* hCPU)
 {
-	gx2Log_printf("GX2SetDefaultAllocator(0x%08x, 0x%08x)\n", hCPU->gpr[3], hCPU->gpr[4]);
+	cemuLog_log(LogType::GX2, "GX2SetDefaultAllocator(0x{:08x}, 0x{:08x})", hCPU->gpr[3], hCPU->gpr[4]);
 	gx2Mem_defaultAlloc = hCPU->gpr[3];
 	gx2Mem_defaultFree = hCPU->gpr[4];
 	osLib_returnFromFunction(hCPU, 0);
@@ -42,7 +42,7 @@ void gx2Export_GX2SetDefaultAllocator(PPCInterpreter_t* hCPU)
 
 void _GX2DefaultAllocR_Alloc(PPCInterpreter_t* hCPU)
 {
-	gx2Log_printf("GX2DefaultAllocate(0x%08x, 0x%08x, 0x%08x)\n", hCPU->gpr[3], hCPU->gpr[4], hCPU->gpr[5]);
+	cemuLog_log(LogType::GX2, "GX2DefaultAllocate(0x{:08x}, 0x{:08x}, 0x{:08x})", hCPU->gpr[3], hCPU->gpr[4], hCPU->gpr[5]);
 	// parameters:
 	// r3	uint32	userParam
 	// r4	uint32  size
@@ -52,7 +52,7 @@ void _GX2DefaultAllocR_Alloc(PPCInterpreter_t* hCPU)
 
 void _GX2DefaultAllocR_Free(PPCInterpreter_t* hCPU)
 {
-	gx2Log_printf("GX2DefaultFree(0x%08x, 0x%08x)\n", hCPU->gpr[3], hCPU->gpr[4]);
+	cemuLog_log(LogType::GX2, "GX2DefaultFree(0x{:08x}, 0x{:08x})", hCPU->gpr[3], hCPU->gpr[4]);
 	// parameters:
 	// r3	uint32	userParam
 	// r4	void*	mem
@@ -74,4 +74,4 @@ namespace GX2
 	{
 		osLib_addFunction("gx2", "GX2SetDefaultAllocator", gx2Export_GX2SetDefaultAllocator);
 	}
-};
\ No newline at end of file
+};
diff --git a/src/Cafe/OS/libs/gx2/GX2_Misc.cpp b/src/Cafe/OS/libs/gx2/GX2_Misc.cpp
index ae079dc1..e7830cd8 100644
--- a/src/Cafe/OS/libs/gx2/GX2_Misc.cpp
+++ b/src/Cafe/OS/libs/gx2/GX2_Misc.cpp
@@ -15,10 +15,10 @@
 
 void gx2Export_GX2SetSwapInterval(PPCInterpreter_t* hCPU)
 {
-	gx2Log_printf("GX2SetSwapInterval(%d)\n", hCPU->gpr[3]);
+	cemuLog_log(LogType::GX2, "GX2SetSwapInterval({})", hCPU->gpr[3]);
 	if( hCPU->gpr[3] >= 20 )
 	{
-		forceLog_printf("GX2SetSwapInterval() called with out of range value (%d)\n", hCPU->gpr[3]);
+		cemuLog_log(LogType::Force, "GX2SetSwapInterval() called with out of range value ({})", hCPU->gpr[3]);
 	}
 	else
 		LatteGPUState.sharedArea->swapInterval = hCPU->gpr[3];
@@ -27,7 +27,7 @@ void gx2Export_GX2SetSwapInterval(PPCInterpreter_t* hCPU)
 
 void gx2Export_GX2GetSwapInterval(PPCInterpreter_t* hCPU)
 {
-	gx2Log_printf("GX2GetSwapInterval()\n");
+	cemuLog_log(LogType::GX2, "GX2GetSwapInterval()");
 	osLib_returnFromFunction(hCPU, LatteGPUState.sharedArea->swapInterval);
 }
 
@@ -37,15 +37,15 @@ void gx2Export_GX2GetSwapStatus(PPCInterpreter_t* hCPU)
 {
 	memory_writeU32(hCPU->gpr[3], _swapEndianU32(LatteGPUState.sharedArea->flipRequestCountBE));
 	memory_writeU32(hCPU->gpr[4], _swapEndianU32(LatteGPUState.sharedArea->flipExecuteCountBE));
-	memory_writeU64Slow(hCPU->gpr[5], lastSwapTime);
-	memory_writeU64Slow(hCPU->gpr[6], lastSwapTime);
+	memory_writeU64(hCPU->gpr[5], lastSwapTime);
+	memory_writeU64(hCPU->gpr[6], lastSwapTime);
 
 	osLib_returnFromFunction(hCPU, 0);
 }
 
 void gx2Export_GX2GetGPUTimeout(PPCInterpreter_t* hCPU)
 {
-	gx2Log_printf("GX2GetGPUTimeout()\n");
+	cemuLog_log(LogType::GX2, "GX2GetGPUTimeout()");
 	osLib_returnFromFunction(hCPU, 0x3E8);
 }
 
@@ -53,15 +53,15 @@ void gx2Export_GX2GetGPUTimeout(PPCInterpreter_t* hCPU)
 
 void gx2Export_GX2SampleTopGPUCycle(PPCInterpreter_t* hCPU)
 {
-	gx2Log_printf("GX2SampleTopGPUCycle(0x%08x)\n", hCPU->gpr[3]);
-	memory_writeU64Slow(hCPU->gpr[3], coreinit::coreinit_getTimerTick());
+	cemuLog_log(LogType::GX2, "GX2SampleTopGPUCycle(0x{:08x})", hCPU->gpr[3]);
+	memory_writeU64(hCPU->gpr[3], coreinit::OSGetSystemTime());
 	osLib_returnFromFunction(hCPU, 0);
 }
 
 void gx2Export_GX2SampleBottomGPUCycle(PPCInterpreter_t* hCPU)
 {
-	gx2Log_printf("GX2SampleBottomGPUCycle(0x%08x)\n", hCPU->gpr[3]);
-	memory_writeU64Slow(hCPU->gpr[3], GX2_INVALID_COUNTER_VALUE_U64);
+	cemuLog_log(LogType::GX2, "GX2SampleBottomGPUCycle(0x{:08x})", hCPU->gpr[3]);
+	memory_writeU64(hCPU->gpr[3], GX2_INVALID_COUNTER_VALUE_U64);
 
 	osLib_returnFromFunction(hCPU, 0);
 	return;
@@ -81,19 +81,68 @@ namespace GX2
 
 	void _test_AddrLib();
 
-	void GX2Init(void* initSettings)
+	using GX2InitArg = uint32;
+	enum class GX2InitArgId : GX2InitArg
+	{
+		EndOfArgs = 0,
+		CommandPoolBase = 1,
+		CommandPoolSize = 2,
+		UknArg7 = 7,
+		UknArg8 = 8,
+		UknArg9 = 9,
+		UknArg11 = 11,
+	};
+
+	void GX2Init(betype<GX2InitArg>* initArgStream)
 	{
 		if (LatteGPUState.gx2InitCalled)
 		{
 			cemuLog_logDebug(LogType::Force, "GX2Init() called while already initialized");
 			return;
 		}
+		// parse init params from the stream
+		MEMPTR<void> commandPoolBase = nullptr;
+		uint32 commandPoolSize = 0;
+		if (initArgStream)
+		{
+			while (true)
+			{
+				GX2InitArgId paramId = static_cast<GX2InitArgId>((GX2InitArg)*initArgStream);
+				initArgStream++;
+				if (paramId == GX2InitArgId::EndOfArgs)
+				{
+					break;
+				}
+				else if (paramId == GX2InitArgId::CommandPoolBase)
+				{
+					commandPoolBase = MEMPTR<void>(*initArgStream);
+					initArgStream++;
+				}
+				else if (paramId == GX2InitArgId::CommandPoolSize)
+				{
+					commandPoolSize = *initArgStream;
+					initArgStream++;
+				}
+				else if (paramId == GX2InitArgId::UknArg7 ||
+					paramId == GX2InitArgId::UknArg8 ||
+					paramId == GX2InitArgId::UknArg9 ||
+					paramId == GX2InitArgId::UknArg11)
+				{
+					initArgStream++;
+				}
+				else
+				{
+					cemuLog_log(LogType::Force, "GX2Init: Unsupported init arg {}", (uint32)paramId);
+				}
+			}
+		}
+		// init main core
 		uint32 coreIndex = coreinit::OSGetCoreId();
 		cemuLog_log(LogType::GX2, "GX2Init() on core {} by thread 0x{:08x}", coreIndex, MEMPTR<OSThread_t>(coreinit::OSGetCurrentThread()).GetMPTR());
 		sGX2MainCoreIndex = coreIndex;
 		// init submodules
 		GX2::GX2Init_event();
-		GX2::GX2Init_writeGather();
+		GX2::GX2Init_commandBufferPool(commandPoolBase, commandPoolSize);
 		// init shared area
 		if (LatteGPUState.sharedAreaAddr == MPTR_NULL)
 		{
@@ -112,9 +161,27 @@ namespace GX2
 		_test_AddrLib();
 	}
 
+	void GX2Shutdown()
+	{
+		if (!LatteGPUState.gx2InitCalled)
+		{
+			cemuLog_logDebug(LogType::Force, "GX2Shutdown() called while not initialized");
+			return;
+		}
+		LatteGPUState.gx2InitCalled--;
+		if (LatteGPUState.gx2InitCalled != 0)
+			return;
+		GX2DrawDone();
+		GX2Shutdown_commandBufferPool();
+		cemuLog_log(LogType::Force, "GX2 shutdown");
+	}
+
 	void _GX2DriverReset()
 	{
 		LatteGPUState.gx2InitCalled = 0;
+        sGX2MainCoreIndex = 0;
+        GX2CommandResetToDefaultState();
+        GX2EventResetToDefaultState();
 	}
 
 	sint32 GX2GetMainCoreId(PPCInterpreter_t* hCPU)
@@ -234,6 +301,7 @@ namespace GX2
 	void GX2MiscInit()
 	{
 		cafeExportRegister("gx2", GX2Init, LogType::GX2);
+		cafeExportRegister("gx2", GX2Shutdown, LogType::GX2);
 		cafeExportRegister("gx2", GX2GetMainCoreId, LogType::GX2);
 		cafeExportRegister("gx2", GX2ResetGPU, LogType::GX2);
 
diff --git a/src/Cafe/OS/libs/gx2/GX2_Misc.h b/src/Cafe/OS/libs/gx2/GX2_Misc.h
index e6ac8010..38a728c1 100644
--- a/src/Cafe/OS/libs/gx2/GX2_Misc.h
+++ b/src/Cafe/OS/libs/gx2/GX2_Misc.h
@@ -19,5 +19,7 @@ namespace GX2
 	void GX2SetTVBuffer(void* imageBuffePtr, uint32 imageBufferSize, E_TVRES tvResolutionMode, uint32 surfaceFormat, E_TVBUFFERMODE bufferMode);
 	void GX2SetTVGamma(float gamma);
 
+	void GX2Invalidate(uint32 invalidationFlags, MPTR invalidationAddr, uint32 invalidationSize);
+
 	void GX2MiscInit();
 };
\ No newline at end of file
diff --git a/src/Cafe/OS/libs/gx2/GX2_RenderTarget.cpp b/src/Cafe/OS/libs/gx2/GX2_RenderTarget.cpp
index 1b3cc185..8abc3613 100644
--- a/src/Cafe/OS/libs/gx2/GX2_RenderTarget.cpp
+++ b/src/Cafe/OS/libs/gx2/GX2_RenderTarget.cpp
@@ -13,22 +13,22 @@
 
 void gx2Export_GX2InitColorBufferRegs(PPCInterpreter_t* hCPU)
 {
-	gx2Log_printf("GX2InitColorBufferRegs(0x%08x)\n", hCPU->gpr[3]);
+	cemuLog_log(LogType::GX2, "GX2InitColorBufferRegs(0x{:08x})", hCPU->gpr[3]);
 	ppcDefineParamStructPtr(colorBuffer, GX2ColorBuffer, 0);
 
 	LatteAddrLib::AddrSurfaceInfo_OUT surfaceInfo;
 	LatteAddrLib::GX2CalculateSurfaceInfo(colorBuffer->surface.format, colorBuffer->surface.width, colorBuffer->surface.height, colorBuffer->surface.depth, colorBuffer->surface.dim, colorBuffer->surface.tileMode, colorBuffer->surface.aa, _swapEndianU32(colorBuffer->viewMip), &surfaceInfo);
 
 	uint32 pitchHeight = (surfaceInfo.height * surfaceInfo.pitch) >> 6;
-#ifndef PUBLIC_RELEASE
+#ifdef CEMU_DEBUG_ASSERT
 	if (colorBuffer->viewNumSlices != _swapEndianU32(1))
-		forceLogDebug_printf("GX2InitColorBufferRegs(): With unsupported slice count %d", _swapEndianU32(colorBuffer->viewNumSlices));
+		cemuLog_logDebug(LogType::Force, "GX2InitColorBufferRegs(): With unsupported slice count {}", _swapEndianU32(colorBuffer->viewNumSlices));
 	if (surfaceInfo.pitch < 7)
-		forceLogDebug_printf("GX2InitColorBufferRegs(): Pitch too small (pitch = %d)", surfaceInfo.pitch);
+		cemuLog_logDebug(LogType::Force, "GX2InitColorBufferRegs(): Pitch too small (pitch = {})", surfaceInfo.pitch);
 	if ((surfaceInfo.pitch & 7) != 0)
-		forceLogDebug_printf("GX2InitColorBufferRegs(): Pitch has invalid alignment (pitch = %d)", surfaceInfo.pitch);
+		cemuLog_logDebug(LogType::Force, "GX2InitColorBufferRegs(): Pitch has invalid alignment (pitch = {})", surfaceInfo.pitch);
 	if (pitchHeight == 0)
-		forceLogDebug_printf("GX2InitColorBufferRegs(): Invalid value (pitchHeight = %d)", pitchHeight);
+		cemuLog_logDebug(LogType::Force, "GX2InitColorBufferRegs(): Invalid value (pitchHeight = {})", pitchHeight);
 #endif
 
 	uint32 cSize = ((surfaceInfo.pitch >> 3) - 1) & 0x3FF;
@@ -114,7 +114,7 @@ void gx2Export_GX2InitColorBufferRegs(PPCInterpreter_t* hCPU)
 
 void gx2Export_GX2InitDepthBufferRegs(PPCInterpreter_t* hCPU)
 {
-	gx2Log_printf("GX2InitDepthBufferRegs(0x%08x)\n", hCPU->gpr[3]);
+	cemuLog_log(LogType::GX2, "GX2InitDepthBufferRegs(0x{:08x})", hCPU->gpr[3]);
 	ppcDefineParamStructPtr(depthBuffer, GX2DepthBuffer, 0);
 
 	LatteAddrLib::AddrSurfaceInfo_OUT surfaceInfo;
@@ -134,13 +134,13 @@ void gx2Export_GX2InitDepthBufferRegs(PPCInterpreter_t* hCPU)
 
 void gx2Export_GX2SetColorBuffer(PPCInterpreter_t* hCPU)
 {
-	gx2Log_printf("GX2SetColorBuffer(0x%08x, %d)", hCPU->gpr[3], hCPU->gpr[4]);
-	GX2ReserveCmdSpace(20);
+	cemuLog_log(LogType::GX2, "GX2SetColorBuffer(0x{:08x}, {})", hCPU->gpr[3], hCPU->gpr[4]);
+	GX2::GX2ReserveCmdSpace(20);
 
 	GX2ColorBuffer* colorBufferBE = (GX2ColorBuffer*)memory_getPointerFromVirtualOffset(hCPU->gpr[3]);
 
-#ifndef PUBLIC_RELEASE
-	gx2Log_printf("ColorBuffer tileMode %01x PhysAddr %08x fmt %04x res %dx%d Mip %d Slice %d", (uint32)colorBufferBE->surface.tileMode.value(), (uint32)colorBufferBE->surface.imagePtr, (uint32)colorBufferBE->surface.format.value(), (uint32)colorBufferBE->surface.width, (uint32)colorBufferBE->surface.height, _swapEndianU32(colorBufferBE->viewMip), _swapEndianU32(colorBufferBE->viewFirstSlice));
+#ifdef CEMU_DEBUG_ASSERT
+	cemuLog_log(LogType::GX2, "ColorBuffer tileMode {:01x} PhysAddr {:08x} fmt {:04x} res {}x{} Mip {} Slice {}", (uint32)colorBufferBE->surface.tileMode.value(), (uint32)colorBufferBE->surface.imagePtr, (uint32)colorBufferBE->surface.format.value(), (uint32)colorBufferBE->surface.width, (uint32)colorBufferBE->surface.height, _swapEndianU32(colorBufferBE->viewMip), _swapEndianU32(colorBufferBE->viewFirstSlice));
 #endif
 
 	// regs[0] = mmCB_COLOR0_SIZE
@@ -198,19 +198,17 @@ void gx2Export_GX2SetColorBuffer(PPCInterpreter_t* hCPU)
 		mmCB_COLOR0_INFO - 0xA000 + hCPU->gpr[4],
 		colorBufferBE->reg_info);
 
-	GX2::GX2WriteGather_checkAndInsertWrapAroundMark();
-
 	osLib_returnFromFunction(hCPU, 0);
 }
 
 void gx2Export_GX2SetDepthBuffer(PPCInterpreter_t* hCPU)
 {
-	gx2Log_printf("GX2SetDepthBuffer(0x%08x)\n", hCPU->gpr[3]);
-	GX2ReserveCmdSpace(20);
+	cemuLog_log(LogType::GX2, "GX2SetDepthBuffer(0x{:08x})", hCPU->gpr[3]);
+	GX2::GX2ReserveCmdSpace(20);
 
 	GX2DepthBuffer* depthBufferBE = (GX2DepthBuffer*)memory_getPointerFromVirtualOffset(hCPU->gpr[3]);
 
-	gx2Log_printf("DepthBuffer tileMode %01x PhysAddr %08x fmt %04x res %dx%d", (uint32)depthBufferBE->surface.tileMode.value(), (uint32)depthBufferBE->surface.imagePtr, (uint32)depthBufferBE->surface.format.value(), (uint32)depthBufferBE->surface.width, (uint32)depthBufferBE->surface.height);
+	cemuLog_log(LogType::GX2, "DepthBuffer tileMode {:01x} PhysAddr {:08x} fmt {:04x} res {}x{}", (uint32)depthBufferBE->surface.tileMode.value(), (uint32)depthBufferBE->surface.imagePtr, (uint32)depthBufferBE->surface.format.value(), (uint32)depthBufferBE->surface.width, (uint32)depthBufferBE->surface.height);
 
 	uint32 viewMip = _swapEndianU32(depthBufferBE->viewMip);
 
@@ -220,7 +218,7 @@ void gx2Export_GX2SetDepthBuffer(PPCInterpreter_t* hCPU)
 
 	if( viewMip > 0 )
 	{
-		forceLogDebug_printf("GX2SetDepthBuffer: Unsupported non-zero mip (%d) Pointer: %08X Base: %08X", viewMip, regHTileDataBase, 0);
+		cemuLog_logDebug(LogType::Force, "GX2SetDepthBuffer: Unsupported non-zero mip ({}) Pointer: {:08x} Base: {:08x}", viewMip, regHTileDataBase, 0);
 	}
 
 	// setup depthbuffer info register
@@ -264,8 +262,6 @@ void gx2Export_GX2SetDepthBuffer(PPCInterpreter_t* hCPU)
 	gx2WriteGather_submitU32AsBE(mmDB_DEPTH_VIEW - 0xA000);
 	gx2WriteGather_submitU32AsBE(db_view);
 
-	GX2::GX2WriteGather_checkAndInsertWrapAroundMark();
-
 	osLib_returnFromFunction(hCPU, 0);
 }
 
@@ -281,7 +277,7 @@ void gx2Export_GX2MarkScanBufferCopied(PPCInterpreter_t* hCPU)
 	uint32 scanTarget = hCPU->gpr[3];
 	if( scanTarget == GX2_SCAN_TARGET_TV )
 	{
-		GX2ReserveCmdSpace(10);
+		GX2::GX2ReserveCmdSpace(10);
 
 		uint32 physAddr = (MEMORY_TILINGAPERTURE_AREA_ADDR+0x200000);
 
@@ -300,4 +296,4 @@ void gx2Export_GX2MarkScanBufferCopied(PPCInterpreter_t* hCPU)
 	}
 
 	osLib_returnFromFunction(hCPU, 0);
-}
\ No newline at end of file
+}
diff --git a/src/Cafe/OS/libs/gx2/GX2_Resource.cpp b/src/Cafe/OS/libs/gx2/GX2_Resource.cpp
index 70390921..a6029de9 100644
--- a/src/Cafe/OS/libs/gx2/GX2_Resource.cpp
+++ b/src/Cafe/OS/libs/gx2/GX2_Resource.cpp
@@ -87,6 +87,11 @@ namespace GX2
 		return true;
 	}
 
+	void GX2RSetBufferName(GX2RBuffer* buffer, const char* name)
+	{
+		// no-op in production builds
+	}
+
 	void* GX2RLockBufferEx(GX2RBuffer* buffer, uint32 resFlags)
 	{
 		return buffer->GetPtr();
@@ -114,7 +119,7 @@ namespace GX2
 
 	void GX2RSetStreamOutBuffer(uint32 bufferIndex, GX2StreamOutBuffer* soBuffer)
 	{
-		// seen in CoD: Ghosts
+		// seen in CoD: Ghosts and CoD: Black Ops 2
 		GX2SetStreamOutBuffer(bufferIndex, soBuffer);
 	}
 
@@ -226,6 +231,7 @@ namespace GX2
 		cafeExportRegister("gx2", GX2RCreateBufferUserMemory, LogType::GX2);
 		cafeExportRegister("gx2", GX2RDestroyBufferEx, LogType::GX2);
 		cafeExportRegister("gx2", GX2RBufferExists, LogType::GX2);
+		cafeExportRegister("gx2", GX2RSetBufferName, LogType::GX2);
 		cafeExportRegister("gx2", GX2RLockBufferEx, LogType::GX2);
 		cafeExportRegister("gx2", GX2RUnlockBufferEx, LogType::GX2);
 		cafeExportRegister("gx2", GX2RInvalidateBuffer, LogType::GX2);
diff --git a/src/Cafe/OS/libs/gx2/GX2_Shader.cpp b/src/Cafe/OS/libs/gx2/GX2_Shader.cpp
index c63688eb..20a773e0 100644
--- a/src/Cafe/OS/libs/gx2/GX2_Shader.cpp
+++ b/src/Cafe/OS/libs/gx2/GX2_Shader.cpp
@@ -3,6 +3,7 @@
 #include "GX2_Shader.h"
 #include "Cafe/HW/Latte/Core/LatteConst.h"
 #include "Cafe/HW/Latte/Core/LattePM4.h"
+#include "Cafe/HW/Latte/ISA/LatteReg.h"
 #include "Cafe/HW/Latte/ISA/LatteInstructions.h"
 
 uint32 memory_getVirtualOffsetFromPointer(void* ptr); // remove once we updated everything to MEMPTR
@@ -70,9 +71,9 @@ namespace GX2
 	static_assert(sizeof(betype<LatteConst::VertexFetchEndianMode>) == 0x4);
 
 	// calculate size of CF program subpart, includes alignment padding for clause instructions
-	size_t _calcFetchShaderCFCodeSize(uint32 attributeCount, GX2FetchShader_t::FetchShaderType fetchShaderType, uint32 tessellationMode)
+	size_t _calcFetchShaderCFCodeSize(uint32 attributeCount, GX2FetchShader::FetchShaderType fetchShaderType, uint32 tessellationMode)
 	{
-		cemu_assert_debug(fetchShaderType == GX2FetchShader_t::FetchShaderType::NO_TESSELATION);
+		cemu_assert_debug(fetchShaderType == GX2FetchShader::FetchShaderType::NO_TESSELATION);
 		cemu_assert_debug(tessellationMode == 0);
 		uint32 numCFInstructions = ((attributeCount + 15) / 16) + 1; // one VTX clause can have up to 16 instructions + final CF instruction is RETURN
 		size_t cfSize = numCFInstructions * 8;
@@ -80,16 +81,16 @@ namespace GX2
 		return cfSize;
 	}
 
-	size_t _calcFetchShaderClauseCodeSize(uint32 attributeCount, GX2FetchShader_t::FetchShaderType fetchShaderType, uint32 tessellationMode)
+	size_t _calcFetchShaderClauseCodeSize(uint32 attributeCount, GX2FetchShader::FetchShaderType fetchShaderType, uint32 tessellationMode)
 	{
-		cemu_assert_debug(fetchShaderType == GX2FetchShader_t::FetchShaderType::NO_TESSELATION);
+		cemu_assert_debug(fetchShaderType == GX2FetchShader::FetchShaderType::NO_TESSELATION);
 		cemu_assert_debug(tessellationMode == 0);
 		uint32 numClauseInstructions = attributeCount;
 		size_t clauseSize = numClauseInstructions * 16;
 		return clauseSize;
 	}
 
-	void _writeFetchShaderCFCode(void* programBufferOut, uint32 attributeCount, GX2FetchShader_t::FetchShaderType fetchShaderType, uint32 tessellationMode)
+	void _writeFetchShaderCFCode(void* programBufferOut, uint32 attributeCount, GX2FetchShader::FetchShaderType fetchShaderType, uint32 tessellationMode)
 	{
 		LatteCFInstruction* cfInstructionWriter = (LatteCFInstruction*)programBufferOut;
 		uint32 attributeIndex = 0;
@@ -111,7 +112,7 @@ namespace GX2
 		memcpy(cfInstructionWriter, &returnInstr, sizeof(LatteCFInstruction));
 	}
 
-	void _writeFetchShaderVTXCode(GX2FetchShader_t* fetchShader, void* programOut, uint32 attributeCount, GX2AttribDescription* attributeDescription, GX2FetchShader_t::FetchShaderType fetchShaderType, uint32 tessellationMode)
+	void _writeFetchShaderVTXCode(GX2FetchShader* fetchShader, void* programOut, uint32 attributeCount, GX2AttribDescription* attributeDescription, GX2FetchShader::FetchShaderType fetchShaderType, uint32 tessellationMode)
 	{
 		uint8* writePtr = (uint8*)programOut;
 		// one instruction per attribute (hardcoded into _writeFetchShaderCFCode)
@@ -151,7 +152,7 @@ namespace GX2
 					bool divisorFound = false;
 					for (uint32 i = 0; i < numDivisors; i++)
 					{
-						if (_swapEndianU32(fetchShader->divisors[i]) == attrAluDivisor)
+						if (fetchShader->divisors[i] == attrAluDivisor)
 						{
 							srcSelX = i != 0 ? 2 : 1;
 							divisorFound = true;
@@ -168,7 +169,7 @@ namespace GX2
 						else
 						{
 							srcSelX = numDivisors != 0 ? 2 : 1;
-							fetchShader->divisors[numDivisors] = _swapEndianU32(attrAluDivisor);
+							fetchShader->divisors[numDivisors] = attrAluDivisor;
 							numDivisors++;
 							fetchShader->divisorCount = _swapEndianU32(numDivisors);
 						}
@@ -213,9 +214,9 @@ namespace GX2
 		}
 	}
 
-	uint32 GX2CalcFetchShaderSizeEx(uint32 attributeCount, GX2FetchShader_t::FetchShaderType fetchShaderType, uint32 tessellationMode)
+	uint32 GX2CalcFetchShaderSizeEx(uint32 attributeCount, GX2FetchShader::FetchShaderType fetchShaderType, uint32 tessellationMode)
 	{
-		cemu_assert_debug(fetchShaderType == GX2FetchShader_t::FetchShaderType::NO_TESSELATION); // other types are todo
+		cemu_assert_debug(fetchShaderType == GX2FetchShader::FetchShaderType::NO_TESSELATION); // other types are todo
 		cemu_assert_debug(tessellationMode == 0); // other modes are todo
 
 		uint32 finalSize =
@@ -225,9 +226,9 @@ namespace GX2
 		return finalSize;
 	}
 
-	void GX2InitFetchShaderEx(GX2FetchShader_t* fetchShader, void* programBufferOut, uint32 attributeCount, GX2AttribDescription* attributeDescription, GX2FetchShader_t::FetchShaderType fetchShaderType, uint32 tessellationMode)
+	void GX2InitFetchShaderEx(GX2FetchShader* fetchShader, void* programBufferOut, uint32 attributeCount, GX2AttribDescription* attributeDescription, GX2FetchShader::FetchShaderType fetchShaderType, uint32 tessellationMode)
 	{
-		cemu_assert_debug(fetchShaderType == GX2FetchShader_t::FetchShaderType::NO_TESSELATION);
+		cemu_assert_debug(fetchShaderType == GX2FetchShader::FetchShaderType::NO_TESSELATION);
 		cemu_assert_debug(tessellationMode == 0);
 
 		/*
@@ -238,7 +239,7 @@ namespace GX2
 			[CLAUSES]
 		*/
 
-		memset(fetchShader, 0x00, sizeof(GX2FetchShader_t));
+		memset(fetchShader, 0x00, sizeof(GX2FetchShader));
 		fetchShader->attribCount = _swapEndianU32(attributeCount);
 		fetchShader->shaderPtr = (MPTR)_swapEndianU32(memory_getVirtualOffsetFromPointer(programBufferOut));
 
@@ -251,14 +252,232 @@ namespace GX2
 		shaderOutput += _calcFetchShaderClauseCodeSize(attributeCount, fetchShaderType, tessellationMode);
 
 		uint32 shaderSize = (uint32)(shaderOutput - shaderStart);
-		cemu_assert_debug(shaderSize == GX2CalcFetchShaderSizeEx(attributeCount, GX2FetchShader_t::FetchShaderType::NO_TESSELATION, tessellationMode));
+		cemu_assert_debug(shaderSize == GX2CalcFetchShaderSizeEx(attributeCount, GX2FetchShader::FetchShaderType::NO_TESSELATION, tessellationMode));
 
 		fetchShader->shaderSize = _swapEndianU32((uint32)(shaderOutput - shaderStart));
+
+		fetchShader->reg_SQ_PGM_RESOURCES_FS = Latte::LATTE_SQ_PGM_RESOURCES_FS().set_NUM_GPRS(2); // todo - affected by tesselation params?
+	}
+
+	uint32 GX2GetVertexShaderGPRs(GX2VertexShader* vertexShader)
+	{
+		return vertexShader->regs.SQ_PGM_RESOURCES_VS.value().get_NUM_GPRS();
+	}
+
+	uint32 GX2GetVertexShaderStackEntries(GX2VertexShader* vertexShader)
+	{
+		return vertexShader->regs.SQ_PGM_RESOURCES_VS.value().get_NUM_STACK_ENTRIES();
+	}
+
+	uint32 GX2GetPixelShaderGPRs(GX2PixelShader_t* pixelShader)
+	{
+		return _swapEndianU32(pixelShader->regs[0])&0xFF;
+	}
+
+	uint32 GX2GetPixelShaderStackEntries(GX2PixelShader_t* pixelShader)
+	{
+		return (_swapEndianU32(pixelShader->regs[0]>>8))&0xFF;
+	}
+
+	void GX2SetFetchShader(GX2FetchShader* fetchShaderPtr)
+	{
+		GX2ReserveCmdSpace(11);
+		cemu_assert_debug((_swapEndianU32(fetchShaderPtr->shaderPtr) & 0xFF) == 0);
+
+		gx2WriteGather_submit(
+				// setup fetch shader
+				pm4HeaderType3(IT_SET_CONTEXT_REG, 1+5),
+				Latte::REGADDR::SQ_PGM_START_FS-0xA000,
+				_swapEndianU32(fetchShaderPtr->shaderPtr)>>8,
+				_swapEndianU32(fetchShaderPtr->shaderSize)>>3,
+				0x10000, // ukn (ring buffer size?)
+				0x10000, // ukn (ring buffer size?)
+				fetchShaderPtr->reg_SQ_PGM_RESOURCES_FS,
+
+				// write instance step
+				pm4HeaderType3(IT_SET_CONTEXT_REG, 1+2),
+				Latte::REGADDR::VGT_INSTANCE_STEP_RATE_0-0xA000,
+				fetchShaderPtr->divisors[0],
+				fetchShaderPtr->divisors[1]);
+	}
+
+	void GX2SetVertexShader(GX2VertexShader* vertexShader)
+	{
+		uint32 numOutputIds = vertexShader->regs.vsOutIdTableSize;
+		numOutputIds = std::min<uint32>(numOutputIds, 0xA);
+		uint32 vsSemanticTableSize = vertexShader->regs.semanticTableSize;
+
+		uint32 reserveSize = 31;
+		if (vertexShader->shaderMode == GX2_SHADER_MODE::GEOMETRY_SHADER)
+		{
+			reserveSize += 7;
+		}
+		else
+		{
+			reserveSize += 18;
+			reserveSize += numOutputIds;
+			if (vertexShader->usesStreamOut != 0)
+				reserveSize += 2+12;
+		}
+		if (vsSemanticTableSize > 0)
+		{
+			reserveSize += 5 + vsSemanticTableSize;
+		}
+		GX2ReserveCmdSpace(reserveSize);
+
+		MPTR shaderProgramAddr;
+		uint32 shaderProgramSize;
+		if (vertexShader->shaderPtr)
+		{
+			// without R API
+			shaderProgramAddr = vertexShader->shaderPtr.GetMPTR();
+			shaderProgramSize = vertexShader->shaderSize;
+		}
+		else
+		{
+			shaderProgramAddr = vertexShader->rBuffer.GetVirtualAddr();
+			shaderProgramSize = vertexShader->rBuffer.GetSize();
+		}
+
+		cemu_assert_debug(shaderProgramAddr != 0);
+		cemu_assert_debug(shaderProgramSize != 0);
+
+		if (vertexShader->shaderMode == GX2_SHADER_MODE::GEOMETRY_SHADER)
+		{
+			// in geometry shader mode the vertex shader is written to _ES register and almost all vs control registers are set by GX2SetGeometryShader
+			gx2WriteGather_submit(
+					pm4HeaderType3(IT_SET_CONTEXT_REG, 6),
+					Latte::REGADDR::SQ_PGM_START_ES-0xA000,
+					memory_virtualToPhysical(shaderProgramAddr)>>8,
+					shaderProgramSize>>3,
+					0x100000,
+					0x100000,
+					vertexShader->regs.SQ_PGM_RESOURCES_VS); // SQ_PGM_RESOURCES_VS/SQ_PGM_RESOURCES_ES
+		}
+		else
+		{
+			gx2WriteGather_submit(
+					/* vertex shader program */
+					pm4HeaderType3(IT_SET_CONTEXT_REG, 6),
+					Latte::REGADDR::SQ_PGM_START_VS-0xA000,
+					memory_virtualToPhysical(shaderProgramAddr)>>8, // physical address
+					shaderProgramSize>>3,
+					0x100000,
+					0x100000,
+					vertexShader->regs.SQ_PGM_RESOURCES_VS, // SQ_PGM_RESOURCES_VS/ES
+					/* primitive id enable */
+					pm4HeaderType3(IT_SET_CONTEXT_REG, 2),
+					Latte::REGADDR::VGT_PRIMITIVEID_EN-0xA000,
+					vertexShader->regs.VGT_PRIMITIVEID_EN,
+					/* output config */
+					pm4HeaderType3(IT_SET_CONTEXT_REG, 2),
+					Latte::REGADDR::SPI_VS_OUT_CONFIG-0xA000,
+					vertexShader->regs.SPI_VS_OUT_CONFIG,
+					/* PA_CL_VS_OUT_CNTL */
+					pm4HeaderType3(IT_SET_CONTEXT_REG, 2),
+					Latte::REGADDR::PA_CL_VS_OUT_CNTL-0xA000,
+					vertexShader->regs.PA_CL_VS_OUT_CNTL
+					);
+
+			cemu_assert_debug(vertexShader->regs.SPI_VS_OUT_CONFIG.value().get_VS_PER_COMPONENT() == false); // not handled on the GPU side
+
+			gx2WriteGather_submitU32AsBE(pm4HeaderType3(IT_SET_CONTEXT_REG, 1+numOutputIds));
+			gx2WriteGather_submitU32AsBE(Latte::REGADDR::SPI_VS_OUT_ID_0-0xA000);
+			for(uint32 i=0; i<numOutputIds; i++)
+				gx2WriteGather_submitU32AsBE(vertexShader->regs.LATTE_SPI_VS_OUT_ID_N[i].value().getRawValue());
+
+			// todo: SQ_PGM_CF_OFFSET_VS
+			// todo: VGT_STRMOUT_BUFFER_EN
+			// stream out
+			if (vertexShader->usesStreamOut != 0)
+			{
+				// stride 0
+				gx2WriteGather_submit(pm4HeaderType3(IT_SET_CONTEXT_REG, 2),
+				Latte::REGADDR::VGT_STRMOUT_VTX_STRIDE_0-0xA000,
+				vertexShader->streamOutVertexStride[0]>>2,
+				// stride 1
+				pm4HeaderType3(IT_SET_CONTEXT_REG, 2),
+				Latte::REGADDR::VGT_STRMOUT_VTX_STRIDE_1-0xA000,
+				vertexShader->streamOutVertexStride[1]>>2,
+				// stride 2
+				pm4HeaderType3(IT_SET_CONTEXT_REG, 2),
+				Latte::REGADDR::VGT_STRMOUT_VTX_STRIDE_2-0xA000,
+				vertexShader->streamOutVertexStride[2]>>2,
+				// stride 3
+				pm4HeaderType3(IT_SET_CONTEXT_REG, 2),
+				Latte::REGADDR::VGT_STRMOUT_VTX_STRIDE_3-0xA000,
+				vertexShader->streamOutVertexStride[3]>>2);
+			}
+		}
+		// update semantic table
+		if (vsSemanticTableSize > 0)
+		{
+			gx2WriteGather_submit(
+					pm4HeaderType3(IT_SET_CONTEXT_REG, 1+1),
+					Latte::REGADDR::SQ_VTX_SEMANTIC_CLEAR-0xA000,
+					0xFFFFFFFF);
+			if (vsSemanticTableSize == 0)
+			{
+				gx2WriteGather_submit(
+						pm4HeaderType3(IT_SET_CONTEXT_REG, 1+1),
+						Latte::REGADDR::SQ_VTX_SEMANTIC_0-0xA000,
+						0xFFFFFFFF);
+			}
+			else
+			{
+				uint32* vsSemanticTable = (uint32*)vertexShader->regs.SQ_VTX_SEMANTIC_N;
+				vsSemanticTableSize = std::min<uint32>(vsSemanticTableSize, 32);
+				gx2WriteGather_submitU32AsBE(pm4HeaderType3(IT_SET_CONTEXT_REG, 1+vsSemanticTableSize));
+				gx2WriteGather_submitU32AsBE(Latte::REGADDR::SQ_VTX_SEMANTIC_0-0xA000);
+				gx2WriteGather_submitU32AsLEArray(vsSemanticTable, vsSemanticTableSize);
+			}
+		}
+	}
+
+	void _GX2SubmitUniformReg(uint32 offsetRegBase, uint32 aluRegisterOffset, uint32be* dataWords, uint32 sizeInU32s)
+	{
+		if(aluRegisterOffset&0x8000)
+		{
+			cemuLog_logDebugOnce(LogType::Force, "_GX2SubmitUniformReg(): Unhandled loop const special case or invalid offset");
+			return;
+		}
+		if((aluRegisterOffset+sizeInU32s) > 0x400)
+		{
+			cemuLog_logOnce(LogType::APIErrors, "GX2SetVertexUniformReg values are out of range (offset {} + size {} must be equal or smaller than 1024)", aluRegisterOffset, sizeInU32s);
+		}
+		if( (sizeInU32s&3) != 0)
+		{
+			cemuLog_logOnce(LogType::APIErrors, "GX2Set*UniformReg must be called with a size that is a multiple of 4 (size: {:})", sizeInU32s);
+			sizeInU32s &= ~3;
+		}
+		GX2ReserveCmdSpace(2 + sizeInU32s);
+		gx2WriteGather_submit(pm4HeaderType3(IT_SET_ALU_CONST, 1 + sizeInU32s), offsetRegBase + aluRegisterOffset);
+		gx2WriteGather_submitU32AsLEArray((uint32*)dataWords, sizeInU32s);
+	}
+
+	void GX2SetVertexUniformReg(uint32 offset, uint32 sizeInU32s, uint32be* values)
+	{
+		_GX2SubmitUniformReg(0x400, offset, values, sizeInU32s);
+	}
+
+	void GX2SetPixelUniformReg(uint32 offset, uint32 sizeInU32s, uint32be* values)
+	{
+		_GX2SubmitUniformReg(0, offset, values, sizeInU32s);
 	}
 
 	void GX2ShaderInit()
 	{
 		cafeExportRegister("gx2", GX2CalcFetchShaderSizeEx, LogType::GX2);
 		cafeExportRegister("gx2", GX2InitFetchShaderEx, LogType::GX2);
+
+		cafeExportRegister("gx2", GX2GetVertexShaderGPRs, LogType::GX2);
+		cafeExportRegister("gx2", GX2GetVertexShaderStackEntries, LogType::GX2);
+		cafeExportRegister("gx2", GX2GetPixelShaderGPRs, LogType::GX2);
+		cafeExportRegister("gx2", GX2GetPixelShaderStackEntries, LogType::GX2);
+		cafeExportRegister("gx2", GX2SetFetchShader, LogType::GX2);
+		cafeExportRegister("gx2", GX2SetVertexShader, LogType::GX2);
+
+		cafeExportRegister("gx2", GX2SetVertexUniformReg, LogType::GX2);
+		cafeExportRegister("gx2", GX2SetPixelUniformReg, LogType::GX2);
 	}
 }
\ No newline at end of file
diff --git a/src/Cafe/OS/libs/gx2/GX2_Shader.h b/src/Cafe/OS/libs/gx2/GX2_Shader.h
index 1d1c79cc..960bdf95 100644
--- a/src/Cafe/OS/libs/gx2/GX2_Shader.h
+++ b/src/Cafe/OS/libs/gx2/GX2_Shader.h
@@ -2,7 +2,7 @@
 #include "Cafe/HW/Latte/ISA/LatteReg.h"
 #include "GX2_Streamout.h"
 
-struct GX2FetchShader_t
+struct GX2FetchShader
 {
 	enum class FetchShaderType : uint32
 	{
@@ -10,12 +10,12 @@ struct GX2FetchShader_t
 	};
 
 	/* +0x00 */ betype<FetchShaderType> fetchShaderType;
-	/* +0x04 */ uint32 _regs[1];
+	/* +0x04 */ betype<Latte::LATTE_SQ_PGM_RESOURCES_FS> reg_SQ_PGM_RESOURCES_FS;
 	/* +0x08 */ uint32 shaderSize;
 	/* +0x0C */ MPTR shaderPtr;
 	/* +0x10 */ uint32 attribCount;
 	/* +0x14 */ uint32 divisorCount;
-	/* +0x18 */ uint32 divisors[2];
+	/* +0x18 */ uint32be divisors[2];
 
 	MPTR GetProgramAddr() const
 	{
@@ -23,8 +23,8 @@ struct GX2FetchShader_t
 	}
 };
 
-static_assert(sizeof(GX2FetchShader_t) == 0x20);
-static_assert(sizeof(betype<GX2FetchShader_t::FetchShaderType>) == 4);
+static_assert(sizeof(GX2FetchShader) == 0x20);
+static_assert(sizeof(betype<GX2FetchShader::FetchShaderType>) == 4);
 
 namespace GX2
 {
@@ -32,19 +32,43 @@ namespace GX2
 	void GX2ShaderInit();
 }
 
-// code below still needs to be modernized (use betype, enum classes)
+// code below still needs to be modernized (use betype, enum classes, move to namespace)
 
+// deprecated, use GX2_SHADER_MODE enum class instead
 #define GX2_SHADER_MODE_UNIFORM_REGISTER	0
 #define GX2_SHADER_MODE_UNIFORM_BLOCK		1
 #define GX2_SHADER_MODE_GEOMETRY_SHADER		2
 #define GX2_SHADER_MODE_COMPUTE_SHADER		3
 
-struct GX2VertexShader_t
+enum class GX2_SHADER_MODE : uint32
 {
-	/* +0x000 */ uint32 regs[52];
-	/* +0x0D0 */ uint32 shaderSize;
-	/* +0x0D4 */ MPTR shaderPtr;
-	/* +0x0D8 */ uint32 shaderMode; // GX2_SHADER_MODE_*
+	UNIFORM_REGISTER = 0,
+	UNIFORM_BLOCK = 1,
+	GEOMETRY_SHADER = 2,
+	COMPUTE_SHADER = 3,
+};
+
+struct GX2VertexShader
+{
+	/* +0x000 */
+	struct
+	{
+		/* +0x00 */ betype<Latte::LATTE_SQ_PGM_RESOURCES_VS> SQ_PGM_RESOURCES_VS; // compatible with SQ_PGM_RESOURCES_ES
+		/* +0x04 */ betype<Latte::LATTE_VGT_PRIMITIVEID_EN> VGT_PRIMITIVEID_EN;
+		/* +0x08 */ betype<Latte::LATTE_SPI_VS_OUT_CONFIG> SPI_VS_OUT_CONFIG;
+		/* +0x0C */ uint32be vsOutIdTableSize;
+		/* +0x10 */ betype<Latte::LATTE_SPI_VS_OUT_ID_N> LATTE_SPI_VS_OUT_ID_N[10];
+		/* +0x38 */ betype<Latte::LATTE_PA_CL_VS_OUT_CNTL> PA_CL_VS_OUT_CNTL;
+		/* +0x3C */ uint32be uknReg15; // ?
+		/* +0x40 */ uint32be semanticTableSize;
+		/* +0x44 */ betype<Latte::LATTE_SQ_VTX_SEMANTIC_X> SQ_VTX_SEMANTIC_N[32];
+		/* +0xC4 */ uint32be uknReg49; // ?
+		/* +0xC8 */ uint32be uknReg50; // vgt_vertex_reuse_block_cntl
+		/* +0xCC */ uint32be uknReg51; // vgt_hos_reuse_depth
+	}regs;
+	/* +0x0D0 */ uint32be shaderSize;
+	/* +0x0D4 */ MEMPTR<void> shaderPtr;
+	/* +0x0D8 */ betype<GX2_SHADER_MODE> shaderMode;
 	/* +0x0DC */ uint32 uniformBlockCount;
 	/* +0x0E0 */ MPTR uniformBlockInfo;
 	/* +0x0E4 */ uint32 uniformVarCount;
@@ -57,20 +81,20 @@ struct GX2VertexShader_t
 	/* +0x100 */ MPTR samplerInfo;
 	/* +0x104 */ uint32 attribCount;
 	/* +0x108 */ MPTR attribInfo;
-	/* +0x10C */ uint32 ringItemsize; // for GS
-	/* +0x110 */ uint32 usesStreamOut;
-	/* +0x114 */ uint32 streamOutVertexStride[GX2_MAX_STREAMOUT_BUFFERS];
+	/* +0x10C */ uint32be ringItemsize; // for GS
+	/* +0x110 */ uint32be usesStreamOut;
+	/* +0x114 */ uint32be streamOutVertexStride[GX2_MAX_STREAMOUT_BUFFERS];
 	/* +0x124 */ GX2RBuffer rBuffer;
 
 	MPTR GetProgramAddr() const
 	{
-		if (_swapEndianU32(this->shaderPtr) != MPTR_NULL)
-			return _swapEndianU32(this->shaderPtr);
+		if (this->shaderPtr)
+			return this->shaderPtr.GetMPTR();
 		return this->rBuffer.GetVirtualAddr();
 	}
 };
 
-static_assert(sizeof(GX2VertexShader_t) == 0x134);
+static_assert(sizeof(GX2VertexShader) == 0x134);
 
 typedef struct _GX2PixelShader
 {
diff --git a/src/Cafe/OS/libs/gx2/GX2_State.cpp b/src/Cafe/OS/libs/gx2/GX2_State.cpp
index d9c0420f..795ff527 100644
--- a/src/Cafe/OS/libs/gx2/GX2_State.cpp
+++ b/src/Cafe/OS/libs/gx2/GX2_State.cpp
@@ -213,7 +213,6 @@ namespace GX2
 
 	void GX2SetViewportReg(GX2ViewportReg* viewportReg)
 	{
-		GX2::GX2WriteGather_checkAndInsertWrapAroundMark();
 		GX2ReserveCmdSpace(2 + 6);
 
 		gx2WriteGather_submit(pm4HeaderType3(IT_SET_CONTEXT_REG, 1 + 6),
diff --git a/src/Cafe/OS/libs/gx2/GX2_Surface.cpp b/src/Cafe/OS/libs/gx2/GX2_Surface.cpp
index 5ce8a453..1d858e18 100644
--- a/src/Cafe/OS/libs/gx2/GX2_Surface.cpp
+++ b/src/Cafe/OS/libs/gx2/GX2_Surface.cpp
@@ -112,8 +112,34 @@ namespace GX2
 		return levels;
 	}
 
+	void _GX2CalcSurfaceSizeAndAlignmentWorkaround(GX2Surface* surface)
+	{
+		// this workaround catches an issue where the FFL (Mii) library embedded into games tries to use an uninitialized texture
+		// and subsequently crashes. It only happens when FFL files are not present in mlc.
+		// seen in Sonic Lost World and in Super Mario 3D World
+		if ((uint32)surface->dim.value() >= 50 || surface->aa.value() >= 0x100 || (uint32)surface->width.value() >= 0x01000000 || 
+			(uint32)surface->height.value() >= 0x01000000 || (uint32)surface->depth.value() >= 0x01000000 || (uint32)surface->format.value() >= 0x10000)
+		{
+			cemuLog_log(LogType::Force, "GX2CalcSurfaceSizeAndAlignment(): Uninitialized surface encountered\n");
+			// overwrite surface parameters with placeholder values to avoid crashing later down the line
+			surface->dim = Latte::E_DIM::DIM_2D;
+			surface->width = 8;
+			surface->height = 8;
+			surface->depth = 1;
+			surface->tileMode = Latte::E_GX2TILEMODE::TM_2D_TILED_THIN1;
+			surface->pitch = 8;
+			surface->numLevels = 0;
+			surface->imagePtr = MEMORY_TILINGAPERTURE_AREA_ADDR;
+			surface->swizzle = 0;
+			surface->aa = 0;
+			surface->format = Latte::E_GX2SURFFMT::R8_G8_B8_A8_UNORM;
+			surface->alignment = 0x400;
+		}
+	}
+
 	void GX2CalcSurfaceSizeAndAlignment(GX2Surface* surface)
 	{
+		_GX2CalcSurfaceSizeAndAlignmentWorkaround(surface);
 		LatteAddrLib::AddrSurfaceInfo_OUT surfOut = { 0 };
 		uint32 firstMipOffset = 0;
 		bool changeTilemode = false;
diff --git a/src/Cafe/OS/libs/gx2/GX2_Surface_Copy.cpp b/src/Cafe/OS/libs/gx2/GX2_Surface_Copy.cpp
index 9bbc1b80..ce85048e 100644
--- a/src/Cafe/OS/libs/gx2/GX2_Surface_Copy.cpp
+++ b/src/Cafe/OS/libs/gx2/GX2_Surface_Copy.cpp
@@ -208,7 +208,7 @@ void gx2Surface_GX2CopySurface(GX2Surface* srcSurface, uint32 srcMip, uint32 src
 	if( srcHwFormat != dstHwFormat )
 	{
 		// mismatching format
-		forceLogDebug_printf("GX2CopySurface(): Format mismatch\n");
+		cemuLog_logDebug(LogType::Force, "GX2CopySurface(): Format mismatch");
 		return;
 	}
 
@@ -264,7 +264,7 @@ void gx2Surface_GX2CopySurface(GX2Surface* srcSurface, uint32 srcMip, uint32 src
 	// send copy command to GPU
 	if( srcHwTileMode > 0 && srcHwTileMode < 16 && dstHwTileMode > 0 && dstHwTileMode < 16 || requestGPURAMCopy )
 	{
-		GX2ReserveCmdSpace(1+13*2);
+		GX2::GX2ReserveCmdSpace(1+13*2);
 
 		gx2WriteGather_submit(pm4HeaderType3(IT_HLE_COPY_SURFACE_NEW, 13*2),
 		// src
@@ -379,7 +379,7 @@ typedef struct
 
 void gx2Export_GX2CopySurfaceEx(PPCInterpreter_t* hCPU)
 {
-	forceLogDebug_printf("GX2CopySurfaceEx(0x%08x,%d,%d,0x%08x,%d,%d,%d,0x%08x,0x%08x)", hCPU->gpr[3], hCPU->gpr[4], hCPU->gpr[5], hCPU->gpr[6], hCPU->gpr[7], hCPU->gpr[8], hCPU->gpr[9], hCPU->gpr[10], memory_readU32(hCPU->gpr[1]+0x8));
+	cemuLog_logDebug(LogType::Force, "GX2CopySurfaceEx(0x{:08x},{},{},0x{:08x},{},{},{},0x{:08x},0x{:08x})", hCPU->gpr[3], hCPU->gpr[4], hCPU->gpr[5], hCPU->gpr[6], hCPU->gpr[7], hCPU->gpr[8], hCPU->gpr[9], hCPU->gpr[10], memory_readU32(hCPU->gpr[1]+0x8));
 	GX2Surface* srcSurface = (GX2Surface*)memory_getPointerFromVirtualOffset(hCPU->gpr[3]);
 	uint32 srcMip = hCPU->gpr[4];
 	uint32 srcSlice = hCPU->gpr[5];
@@ -394,10 +394,10 @@ void gx2Export_GX2CopySurfaceEx(PPCInterpreter_t* hCPU)
 	GX2Point_t* rectDst = (GX2Point_t*)memory_getPointerFromVirtualOffset(pointDstArrayMPTR);
 	for (sint32 i = 0; i < rectCount; i++)
 	{
-		forceLogDebug_printf("rect left-top: %d/%d size: %d/%d", _swapEndianU32(rectSrc->left), _swapEndianU32(rectSrc->top), _swapEndianU32(rectSrc->right) - _swapEndianU32(rectSrc->left), _swapEndianU32(rectSrc->bottom) - _swapEndianU32(rectSrc->top));
+		cemuLog_logDebug(LogType::Force, "rect left-top: {}/{} size: {}/{}", _swapEndianU32(rectSrc->left), _swapEndianU32(rectSrc->top), _swapEndianU32(rectSrc->right) - _swapEndianU32(rectSrc->left), _swapEndianU32(rectSrc->bottom) - _swapEndianU32(rectSrc->top));
 	}
 
-#ifndef PUBLIC_RELEASE
+#ifdef CEMU_DEBUG_ASSERT
 	if( rectCount != 1 )
 		assert_dbg();
 	if( srcMip != 0 )
@@ -440,7 +440,7 @@ void gx2Export_GX2ResolveAAColorBuffer(PPCInterpreter_t* hCPU)
 	uint32 srcSlice = _swapEndianU32(srcColorBuffer->viewFirstSlice);
 	uint32 dstSlice = hCPU->gpr[6];
 
-#ifndef PUBLIC_RELEASE
+#ifdef CEMU_DEBUG_ASSERT
 	if( _swapEndianU32(srcColorBuffer->viewMip) != 0 || _swapEndianU32(srcColorBuffer->viewFirstSlice) != 0 )
 		assert_dbg();
 #endif
@@ -540,7 +540,7 @@ void gx2Export_GX2ResolveAAColorBuffer(PPCInterpreter_t* hCPU)
 	uint32 dstDepth = std::max<uint32>(surfOutDst.depth, 1);
 
 	// send copy command to GPU
-	GX2ReserveCmdSpace(1 + 13 * 2);
+	GX2::GX2ReserveCmdSpace(1 + 13 * 2);
 	gx2WriteGather_submit(pm4HeaderType3(IT_HLE_COPY_SURFACE_NEW, 13 * 2),
 		// src
 		(uint32)srcSurface->imagePtr,
@@ -576,7 +576,7 @@ void gx2Export_GX2ResolveAAColorBuffer(PPCInterpreter_t* hCPU)
 
 void gx2Export_GX2ConvertDepthBufferToTextureSurface(PPCInterpreter_t* hCPU)
 {
-	gx2Log_printf("GX2ConvertDepthBufferToTextureSurface(0x%x, 0x%x, %d, %d)\n", hCPU->gpr[3], hCPU->gpr[4], hCPU->gpr[5], hCPU->gpr[6]);
+	cemuLog_log(LogType::GX2, "GX2ConvertDepthBufferToTextureSurface(0x{:x}, 0x{:x}, {}, {})", hCPU->gpr[3], hCPU->gpr[4], hCPU->gpr[5], hCPU->gpr[6]);
 	GX2DepthBuffer* depthBuffer = (GX2DepthBuffer*)memory_getPointerFromVirtualOffset(hCPU->gpr[3]);
 	GX2Surface* dstSurface = (GX2Surface*)memory_getPointerFromVirtualOffset(hCPU->gpr[4]);
 	uint32 dstMip = hCPU->gpr[5];
@@ -619,7 +619,7 @@ void gx2Export_GX2ConvertDepthBufferToTextureSurface(PPCInterpreter_t* hCPU)
 	sint32 srcMip = 0;
 
 	uint32 numSlices = std::max<uint32>(_swapEndianU32(depthBuffer->viewNumSlices), 1);
-	GX2ReserveCmdSpace((1 + 13 * 2) * numSlices);
+	GX2::GX2ReserveCmdSpace((1 + 13 * 2) * numSlices);
 	for (uint32 subSliceIndex = 0; subSliceIndex < numSlices; subSliceIndex++)
 	{
 		// send copy command to GPU
diff --git a/src/Cafe/OS/libs/gx2/GX2_TilingAperture.cpp b/src/Cafe/OS/libs/gx2/GX2_TilingAperture.cpp
index 5b68a00d..baa91ee9 100644
--- a/src/Cafe/OS/libs/gx2/GX2_TilingAperture.cpp
+++ b/src/Cafe/OS/libs/gx2/GX2_TilingAperture.cpp
@@ -370,15 +370,15 @@ void GX2TilingAperature_RetileTexture(ActiveTilingAperature* tilingAperture, boo
 	}
 
 	//double benchmarkTime = benchmarkTimer_stop(timerTilingStart);
-	//forceLogDebug_printf("TilingAperture res %04dx%04d fmt %04x tm %02x mip %d isWrite %d", (uint32)tilingAperture->surface.width, (uint32)tilingAperture->surface.height, (uint32)tilingAperture->surface.format, (uint32)tilingAperture->surface.tileMode, tilingAperture->mipLevel, doWrite?1:0);
-	//forceLogDebug_printf("Tiling took %.4lfms", benchmarkTime);
+	//cemuLog_logDebug(LogType::Force, "TilingAperture res {:04}x{:04} fmt {:04x} tm {:02x} mip {} isWrite {}", (uint32)tilingAperture->surface.width, (uint32)tilingAperture->surface.height, (uint32)tilingAperture->surface.format, (uint32)tilingAperture->surface.tileMode, tilingAperture->mipLevel, doWrite?1:0);
+	//cemuLog_logDebug(LogType::Force, "Tiling took {:.4}ms", benchmarkTime);
 }
 
 void gx2Export_GX2AllocateTilingApertureEx(PPCInterpreter_t* hCPU)
 {
-	gx2Log_printf("GX2AllocateTilingApertureEx(0x%08x, %d, %d, %d, 0x%08x, 0x%08x)", hCPU->gpr[3], hCPU->gpr[4], hCPU->gpr[5], hCPU->gpr[6], hCPU->gpr[7], hCPU->gpr[8]);
+	cemuLog_log(LogType::GX2, "GX2AllocateTilingApertureEx(0x{:08x}, {}, {}, {}, 0x{:08x}, 0x{:08x})", hCPU->gpr[3], hCPU->gpr[4], hCPU->gpr[5], hCPU->gpr[6], hCPU->gpr[7], hCPU->gpr[8]);
 	GX2Surface* surface = (GX2Surface*)memory_getPointerFromVirtualOffset(hCPU->gpr[3]);
-	gx2Log_printf("Tiling Tex: %08X %dx%d Swizzle: %08x tm: %d fmt: %04x use: %02x", (uint32)surface->imagePtr, (uint32)surface->width, (uint32)surface->height, (uint32)surface->swizzle, (uint32)surface->tileMode.value(), (uint32)surface->format.value(), (uint32)surface->resFlag);
+	cemuLog_log(LogType::GX2, "Tiling Tex: {:08x} {}x{} Swizzle: {:08x} tm: {} fmt: {:04x} use: {:02x}", (uint32)surface->imagePtr, (uint32)surface->width, (uint32)surface->height, (uint32)surface->swizzle, (uint32)surface->tileMode.value(), (uint32)surface->format.value(), (uint32)surface->resFlag);
 
 	if( activeTilingAperatureCount >= GX2_MAX_ACTIVE_TILING_APERATURES )
 	{
@@ -437,7 +437,7 @@ void gx2Export_GX2AllocateTilingApertureEx(PPCInterpreter_t* hCPU)
 
 void gx2Export_GX2FreeTilingAperture(PPCInterpreter_t* hCPU)
 {
-	gx2Log_printf("GX2FreeTilingAperture(0x%08x)\n", hCPU->gpr[3]);
+	cemuLog_log(LogType::GX2, "GX2FreeTilingAperture(0x{:08x})", hCPU->gpr[3]);
 	uint32 handle = hCPU->gpr[3];
 	for(sint32 i=0; i<activeTilingAperatureCount; i++)
 	{
diff --git a/src/Cafe/OS/libs/gx2/GX2_shader_legacy.cpp b/src/Cafe/OS/libs/gx2/GX2_shader_legacy.cpp
index b4555fae..d91a8529 100644
--- a/src/Cafe/OS/libs/gx2/GX2_shader_legacy.cpp
+++ b/src/Cafe/OS/libs/gx2/GX2_shader_legacy.cpp
@@ -8,210 +8,17 @@
 #include "GX2.h"
 #include "GX2_Shader.h"
 
-void gx2Export_GX2SetFetchShader(PPCInterpreter_t* hCPU)
-{
-	gx2Log_printf("GX2SetFetchShader(0x%08x)\n", hCPU->gpr[3]);
-	GX2ReserveCmdSpace(11);
-	GX2FetchShader_t* fetchShaderPtr = (GX2FetchShader_t*)memory_getPointerFromVirtualOffset(hCPU->gpr[3]);
-	cemu_assert_debug((_swapEndianU32(fetchShaderPtr->shaderPtr) & 0xFF) == 0);
-
-	gx2WriteGather_submit(
-	// setup fetch shader
-	pm4HeaderType3(IT_SET_CONTEXT_REG, 1+5),
-	mmSQ_PGM_START_FS-0xA000,
-	_swapEndianU32(fetchShaderPtr->shaderPtr)>>8, // pointer divided by 256
-	_swapEndianU32(fetchShaderPtr->shaderSize)>>3, // size divided by 8
-	0x10000, // ukn (ring buffer size?)
-	0x10000, // ukn (ring buffer size?)
-	*(uint32be*)&(fetchShaderPtr->_regs[0]),
-
-	// write instance step
-	pm4HeaderType3(IT_SET_CONTEXT_REG, 1+2),
-	mmVGT_INSTANCE_STEP_RATE_0-0xA000,
-	*(uint32be*)&(fetchShaderPtr->divisors[0]),
-	*(uint32be*)&(fetchShaderPtr->divisors[1]));
-
-	osLib_returnFromFunction(hCPU, 0);
-}
-
-void gx2Export_GX2GetVertexShaderGPRs(PPCInterpreter_t* hCPU)
-{
-	gx2Log_printf("GX2GetVertexShaderGPRs(0x%08x)\n", hCPU->gpr[3]);
-	GX2VertexShader_t* vertexShader = (GX2VertexShader_t*)memory_getPointerFromVirtualOffset(hCPU->gpr[3]);
-	uint8 numGPRs = _swapEndianU32(vertexShader->regs[0])&0xFF;
-	osLib_returnFromFunction(hCPU, numGPRs);
-}
-
-void gx2Export_GX2GetVertexShaderStackEntries(PPCInterpreter_t* hCPU)
-{
-	gx2Log_printf("GX2GetVertexShaderStackEntries(0x%08x)\n", hCPU->gpr[3]);
-	GX2VertexShader_t* vertexShader = (GX2VertexShader_t*)memory_getPointerFromVirtualOffset(hCPU->gpr[3]);
-	uint8 stackEntries = (_swapEndianU32(vertexShader->regs[0])>>8)&0xFF;
-	osLib_returnFromFunction(hCPU, stackEntries);
-}
-
-void gx2Export_GX2GetPixelShaderGPRs(PPCInterpreter_t* hCPU)
-{
-	gx2Log_printf("GX2GetPixelShaderGPRs(0x%08x)\n", hCPU->gpr[3]);
-	GX2PixelShader_t* pixelShader = (GX2PixelShader_t*)memory_getPointerFromVirtualOffset(hCPU->gpr[3]);
-	uint8 stackEntries = (_swapEndianU32(pixelShader->regs[0]))&0xFF;
-	osLib_returnFromFunction(hCPU, stackEntries);
-}
-
-void gx2Export_GX2GetPixelShaderStackEntries(PPCInterpreter_t* hCPU)
-{
-	gx2Log_printf("GX2GetPixelShaderStackEntries(0x%08x)\n", hCPU->gpr[3]);
-	GX2PixelShader_t* pixelShader = (GX2PixelShader_t*)memory_getPointerFromVirtualOffset(hCPU->gpr[3]);
-	uint8 numGPRs = (_swapEndianU32(pixelShader->regs[0]>>8))&0xFF;
-	osLib_returnFromFunction(hCPU, numGPRs);
-}
-
-void gx2Export_GX2SetVertexShader(PPCInterpreter_t* hCPU)
-{
-	gx2Log_printf("GX2SetVertexShader(0x%08x)\n", hCPU->gpr[3]);
-	GX2ReserveCmdSpace(100);
-
-	GX2VertexShader_t* vertexShader = (GX2VertexShader_t*)memory_getPointerFromVirtualOffset(hCPU->gpr[3]);
-
-	MPTR shaderProgramAddr;
-	uint32 shaderProgramSize;
-
-	if( _swapEndianU32(vertexShader->shaderPtr) != MPTR_NULL )
-	{
-		// without R API
-		shaderProgramAddr = _swapEndianU32(vertexShader->shaderPtr);
-		shaderProgramSize = _swapEndianU32(vertexShader->shaderSize);
-	}
-	else
-	{
-		shaderProgramAddr = vertexShader->rBuffer.GetVirtualAddr();
-		shaderProgramSize = vertexShader->rBuffer.GetSize();
-	}
-
-	cemu_assert_debug(shaderProgramAddr != 0);
-	cemu_assert_debug(shaderProgramSize != 0);
-
-	if( _swapEndianU32(vertexShader->shaderMode) == GX2_SHADER_MODE_GEOMETRY_SHADER )
-	{
-		// in geometry shader mode the vertex shader is written to _ES register and almost all vs control registers are set by GX2SetGeometryShader
-		gx2WriteGather_submitU32AsBE(pm4HeaderType3(IT_SET_CONTEXT_REG, 6));
-		gx2WriteGather_submitU32AsBE(mmSQ_PGM_START_ES-0xA000);
-		gx2WriteGather_submitU32AsBE(memory_virtualToPhysical(shaderProgramAddr)>>8);
-		gx2WriteGather_submitU32AsBE(shaderProgramSize>>3);
-		gx2WriteGather_submitU32AsBE(0x100000);
-		gx2WriteGather_submitU32AsBE(0x100000);
-		gx2WriteGather_submitU32AsBE(_swapEndianU32(vertexShader->regs[0])); // unknown
-	}
-	else
-	{
-		gx2WriteGather_submit(
-			/* vertex shader program */
-			pm4HeaderType3(IT_SET_CONTEXT_REG, 6),
-			mmSQ_PGM_START_VS-0xA000,
-			memory_virtualToPhysical(shaderProgramAddr)>>8, // physical address
-			shaderProgramSize>>3, // size
-			0x100000,
-			0x100000,
-			_swapEndianU32(vertexShader->regs[0]), // unknown
-			/* primitive id enable */
-			pm4HeaderType3(IT_SET_CONTEXT_REG, 2),
-			mmVGT_PRIMITIVEID_EN-0xA000,
-			_swapEndianU32(vertexShader->regs[1]),
-			/* output config */
-			pm4HeaderType3(IT_SET_CONTEXT_REG, 2),
-			mmSPI_VS_OUT_CONFIG-0xA000,
-			_swapEndianU32(vertexShader->regs[2]));
-
-		if( (_swapEndianU32(vertexShader->regs[2]) & 1) != 0 )
-			debugBreakpoint(); // per-component flag?
-
-		// ukn
-		gx2WriteGather_submitU32AsBE(pm4HeaderType3(IT_SET_CONTEXT_REG, 2));
-		gx2WriteGather_submitU32AsBE(mmPA_CL_VS_OUT_CNTL-0xA000);
-		gx2WriteGather_submitU32AsBE(_swapEndianU32(vertexShader->regs[14]));
-		
-		uint32 numOutputIds = _swapEndianU32(vertexShader->regs[3]);
-		numOutputIds = std::min<uint32>(numOutputIds, 0xA);
-		gx2WriteGather_submitU32AsBE(pm4HeaderType3(IT_SET_CONTEXT_REG, 1+numOutputIds));
-		gx2WriteGather_submitU32AsBE(mmSPI_VS_OUT_ID_0-0xA000);
-		for(uint32 i=0; i<numOutputIds; i++)
-		{
-			gx2WriteGather_submitU32AsBE(_swapEndianU32(vertexShader->regs[4+i]));
-		}
-
-		/*
-		 VS _regs[]:
-		 0			?
-		 1			mmVGT_PRIMITIVEID_EN (?)
-		 2			mmSPI_VS_OUT_CONFIG
-		 3			Number of used SPI_VS_OUT_ID_* entries
-		 4 - 13		SPI_VS_OUT_ID_0 - SPI_VS_OUT_ID_9
-		 14			pa_cl_vs_out_cntl
-		 ...
-		 17 - ??	semantic table entry (input)
-
-		 ...
-		 50			vgt_vertex_reuse_block_cntl
-		 51			vgt_hos_reuse_depth
-		 */
-
-		// todo: mmSQ_PGM_CF_OFFSET_VS
-		// todo: mmVGT_STRMOUT_BUFFER_EN
-		// stream out
-		if( _swapEndianU32(vertexShader->usesStreamOut) != 0 )
-		{
-			// stride 0
-			gx2WriteGather_submitU32AsBE(pm4HeaderType3(IT_SET_CONTEXT_REG, 2));
-			gx2WriteGather_submitU32AsBE(mmVGT_STRMOUT_VTX_STRIDE_0-0xA000);
-			gx2WriteGather_submitU32AsBE(_swapEndianU32(vertexShader->streamOutVertexStride[0])>>2);
-			// stride 1
-			gx2WriteGather_submitU32AsBE(pm4HeaderType3(IT_SET_CONTEXT_REG, 2));
-			gx2WriteGather_submitU32AsBE(mmVGT_STRMOUT_VTX_STRIDE_1-0xA000);
-			gx2WriteGather_submitU32AsBE(_swapEndianU32(vertexShader->streamOutVertexStride[1])>>2);
-			// stride 2
-			gx2WriteGather_submitU32AsBE(pm4HeaderType3(IT_SET_CONTEXT_REG, 2));
-			gx2WriteGather_submitU32AsBE(mmVGT_STRMOUT_VTX_STRIDE_2-0xA000);
-			gx2WriteGather_submitU32AsBE(_swapEndianU32(vertexShader->streamOutVertexStride[2])>>2);
-			// stride 3
-			gx2WriteGather_submitU32AsBE(pm4HeaderType3(IT_SET_CONTEXT_REG, 2));
-			gx2WriteGather_submitU32AsBE(mmVGT_STRMOUT_VTX_STRIDE_3-0xA000);
-			gx2WriteGather_submitU32AsBE(_swapEndianU32(vertexShader->streamOutVertexStride[3])>>2);
-		}
-	}
-	// update semantic table
-	uint32 vsSemanticTableSize = _swapEndianU32(vertexShader->regs[0x40/4]);
-	if( vsSemanticTableSize > 0 )
-	{
-		gx2WriteGather_submitU32AsBE(pm4HeaderType3(IT_SET_CONTEXT_REG, 1+1));
-		gx2WriteGather_submitU32AsBE(mmSQ_VTX_SEMANTIC_CLEAR-0xA000);
-		gx2WriteGather_submitU32AsBE(0xFFFFFFFF);
-		if( vsSemanticTableSize == 0 )
-		{
-			// todo: Figure out how this is done on real SW/HW (some vertex shaders don't have a semantic table)
-			gx2WriteGather_submitU32AsBE(pm4HeaderType3(IT_SET_CONTEXT_REG, 1+1));
-			gx2WriteGather_submitU32AsBE(mmSQ_VTX_SEMANTIC_0-0xA000);
-			gx2WriteGather_submitU32AsBE(0xFFFFFFFF);
-		}
-		else
-		{
-			uint32* vsSemanticTable = vertexShader->regs+(0x44/4);
-			vsSemanticTableSize = std::min<uint32>(vsSemanticTableSize, 0x20);
-			gx2WriteGather_submitU32AsBE(pm4HeaderType3(IT_SET_CONTEXT_REG, 1+vsSemanticTableSize));
-			gx2WriteGather_submitU32AsBE(mmSQ_VTX_SEMANTIC_0-0xA000);
-			for(uint32 i=0; i<vsSemanticTableSize; i++)
-				gx2WriteGather_submitU32AsLE(vsSemanticTable[i]);
-		}
-	}
-
-	osLib_returnFromFunction(hCPU, 0);
-}
-
 void gx2Export_GX2SetPixelShader(PPCInterpreter_t* hCPU)
 {
-	gx2Log_printf("GX2SetPixelShader(0x%08x)\n", hCPU->gpr[3]);
-	GX2ReserveCmdSpace(100);
-
+	cemuLog_log(LogType::GX2, "GX2SetPixelShader(0x{:08x})", hCPU->gpr[3]);
 	GX2PixelShader_t* pixelShader = (GX2PixelShader_t*)memory_getPointerFromVirtualOffset(hCPU->gpr[3]);
+
+	uint32 numInputs = _swapEndianU32(pixelShader->regs[4]);
+	if( numInputs > 0x20 )
+		numInputs = 0x20;
+
+	GX2::GX2ReserveCmdSpace(26 + numInputs);
+
 	MPTR shaderProgramAddr;
 	uint32 shaderProgramSize;
 
@@ -242,9 +49,6 @@ void gx2Export_GX2SetPixelShader(PPCInterpreter_t* hCPU)
 		_swapEndianU32(pixelShader->regs[2]),
 		_swapEndianU32(pixelShader->regs[3]));
 	// setup pixel shader extended inputs control
-	uint32 numInputs = _swapEndianU32(pixelShader->regs[4]);
-	if( numInputs > 0x20 )
-		numInputs = 0x20;
 	gx2WriteGather_submitU32AsBE(pm4HeaderType3(IT_SET_CONTEXT_REG, 1+numInputs));
 	gx2WriteGather_submitU32AsBE(mmSPI_PS_INPUT_CNTL_0-0xA000);
 	for(uint32 i=0; i<numInputs; i++)
@@ -276,10 +80,18 @@ void gx2Export_GX2SetPixelShader(PPCInterpreter_t* hCPU)
 
 void gx2Export_GX2SetGeometryShader(PPCInterpreter_t* hCPU)
 {
-	gx2Log_printf("GX2SetGeometryShader(0x%08x)\n", hCPU->gpr[3]);
-	GX2ReserveCmdSpace(100);
+	cemuLog_log(LogType::GX2, "GX2SetGeometryShader(0x{:08x})", hCPU->gpr[3]);
 
 	GX2GeometryShader_t* geometryShader = (GX2GeometryShader_t*)memory_getPointerFromVirtualOffset(hCPU->gpr[3]);
+	uint32 numOutputIds = _swapEndianU32(geometryShader->regs[7]);
+	numOutputIds = std::min<uint32>(numOutputIds, 0xA);
+	uint32 reserveSize = 38; // 38 fixed parameters
+	if (numOutputIds != 0)
+		reserveSize += 2 + numOutputIds;
+	if( _swapEndianU32(geometryShader->useStreamout) != 0 )
+		reserveSize += 2 + 12;
+
+	GX2::GX2ReserveCmdSpace(reserveSize);
 
 	MPTR shaderProgramAddr;
 	uint32 shaderProgramSize;
@@ -326,6 +138,7 @@ void gx2Export_GX2SetGeometryShader(PPCInterpreter_t* hCPU)
 	
 	if( _swapEndianU32(geometryShader->useStreamout) != 0 )
 	{
+		// todo - IT_EVENT_WRITE packet here
 		// stride 0
 		gx2WriteGather_submitU32AsBE(pm4HeaderType3(IT_SET_CONTEXT_REG, 2));
 		gx2WriteGather_submitU32AsBE(mmVGT_STRMOUT_VTX_STRIDE_0-0xA000);
@@ -378,8 +191,6 @@ void gx2Export_GX2SetGeometryShader(PPCInterpreter_t* hCPU)
 	gx2WriteGather_submitU32AsBE(_swapEndianU32(geometryShader->regs[3]));
 
 	// GS outputs
-	uint32 numOutputIds = _swapEndianU32(geometryShader->regs[7]);
-	numOutputIds = std::min<uint32>(numOutputIds, 0xA);
 	if( numOutputIds != 0 )
 	{
 		gx2WriteGather_submitU32AsBE(pm4HeaderType3(IT_SET_CONTEXT_REG, 1+numOutputIds));
@@ -415,14 +226,14 @@ void gx2Export_GX2SetGeometryShader(PPCInterpreter_t* hCPU)
 	osLib_returnFromFunction(hCPU, 0);
 }
 
-struct GX2ComputeShader_t
+struct GX2ComputeShader
 {
 	/* +0x00 */ uint32be regs[12];
 	/* +0x30 */ uint32be programSize;
 	/* +0x34 */ uint32be programPtr;
-	/* +0x38 */ uint32   ukn38;
-	/* +0x3C */ uint32   ukn3C;
-	/* +0x40 */ uint32   ukn40[8];
+	/* +0x38 */ uint32be ukn38;
+	/* +0x3C */ uint32be ukn3C;
+	/* +0x40 */ uint32be ukn40[8];
 	/* +0x60 */ uint32be workgroupSizeX;
 	/* +0x64 */ uint32be workgroupSizeY;
 	/* +0x68 */ uint32be workgroupSizeZ;
@@ -431,14 +242,14 @@ struct GX2ComputeShader_t
 	/* +0x74 */ GX2RBuffer rBuffer;
 };
 
-static_assert(offsetof(GX2ComputeShader_t, programSize) == 0x30);
-static_assert(offsetof(GX2ComputeShader_t, workgroupSizeX) == 0x60);
-static_assert(offsetof(GX2ComputeShader_t, rBuffer) == 0x74);
+static_assert(offsetof(GX2ComputeShader, programSize) == 0x30);
+static_assert(offsetof(GX2ComputeShader, workgroupSizeX) == 0x60);
+static_assert(offsetof(GX2ComputeShader, rBuffer) == 0x74);
 
 void gx2Export_GX2SetComputeShader(PPCInterpreter_t* hCPU)
 {
-	ppcDefineParamTypePtr(computeShader, GX2ComputeShader_t, 0);
-	gx2Log_printf("GX2SetComputeShader(0x%08x)", hCPU->gpr[3]);
+	ppcDefineParamTypePtr(computeShader, GX2ComputeShader, 0);
+	cemuLog_log(LogType::GX2, "GX2SetComputeShader(0x{:08x})", hCPU->gpr[3]);
 
 	MPTR shaderPtr;
 	uint32 shaderSize;
@@ -452,8 +263,7 @@ void gx2Export_GX2SetComputeShader(PPCInterpreter_t* hCPU)
 		shaderPtr = computeShader->rBuffer.GetVirtualAddr();
 		shaderSize = computeShader->rBuffer.GetSize();
 	}
-
-	GX2ReserveCmdSpace(0x11);
+	GX2::GX2ReserveCmdSpace(0x11);
 
 	gx2WriteGather_submit(pm4HeaderType3(IT_SET_CONTEXT_REG, 6),
 		mmSQ_PGM_START_ES-0xA000,
@@ -468,44 +278,9 @@ void gx2Export_GX2SetComputeShader(PPCInterpreter_t* hCPU)
 	osLib_returnFromFunction(hCPU, 0);
 }
 
-void _GX2SubmitUniformReg(uint32 aluRegisterOffset, MPTR virtualAddress, uint32 count)
-{
-	uint32* dataWords = (uint32*)memory_getPointerFromVirtualOffset(virtualAddress);
-	GX2ReserveCmdSpace(2 + (count / 0xFF) * 2 + count);
-	// write PM4 command(s)
-	uint32 currentRegisterOffset = aluRegisterOffset;
-	while (count > 0)
-	{
-		uint32 subCount = std::min(count, 0xFFu); // a single command can write at most 0xFF values
-		gx2WriteGather_submit(pm4HeaderType3(IT_SET_ALU_CONST, 1 + subCount),
-			currentRegisterOffset);
-		gx2WriteGather_submitU32AsLEArray(dataWords, subCount);
-
-		dataWords += subCount;
-		count -= subCount;
-		currentRegisterOffset += subCount;
-	}
-}
-
-void gx2Export_GX2SetVertexUniformReg(PPCInterpreter_t* hCPU)
-{
-	gx2Log_printf("GX2SetVertexUniformReg(0x%08x,0x%x,0x%08x)", hCPU->gpr[3], hCPU->gpr[4], hCPU->gpr[5]);
-	_GX2SubmitUniformReg(hCPU->gpr[3] + 0x400, hCPU->gpr[5], hCPU->gpr[4]);
-	cemu_assert_debug((hCPU->gpr[3] + hCPU->gpr[4]) <= 0x400);
-	osLib_returnFromFunction(hCPU, 0);
-}
-
-void gx2Export_GX2SetPixelUniformReg(PPCInterpreter_t* hCPU)
-{
-	gx2Log_printf("GX2SetPixelUniformReg(0x%08x,0x%x,0x%08x)", hCPU->gpr[3], hCPU->gpr[4], hCPU->gpr[5]);
-	_GX2SubmitUniformReg(hCPU->gpr[3], hCPU->gpr[5], hCPU->gpr[4]);
-	cemu_assert_debug((hCPU->gpr[3] + hCPU->gpr[4]) <= 0x400);
-	osLib_returnFromFunction(hCPU, 0);
-}
-
 void _GX2SubmitUniformBlock(uint32 registerBase, uint32 index, MPTR virtualAddress, uint32 size)
 {
-	GX2ReserveCmdSpace(9);
+	GX2::GX2ReserveCmdSpace(9);
 	gx2WriteGather_submit(pm4HeaderType3(IT_SET_RESOURCE, 8),
 		registerBase + index * 7,
 		memory_virtualToPhysical(virtualAddress),
@@ -519,28 +294,28 @@ void _GX2SubmitUniformBlock(uint32 registerBase, uint32 index, MPTR virtualAddre
 
 void gx2Export_GX2SetVertexUniformBlock(PPCInterpreter_t* hCPU)
 {
-	gx2Log_printf("GX2SetVertexUniformBlock(0x%08x,0x%x,0x%08x)", hCPU->gpr[3], hCPU->gpr[4], hCPU->gpr[5]);
+	cemuLog_log(LogType::GX2, "GX2SetVertexUniformBlock(0x{:08x},0x{:x},0x{:08x})", hCPU->gpr[3], hCPU->gpr[4], hCPU->gpr[5]);
 	_GX2SubmitUniformBlock(mmSQ_VTX_UNIFORM_BLOCK_START - mmSQ_TEX_RESOURCE_WORD0, hCPU->gpr[3], hCPU->gpr[5], hCPU->gpr[4]);
 	osLib_returnFromFunction(hCPU, 0);
 }
 
 void gx2Export_GX2SetPixelUniformBlock(PPCInterpreter_t* hCPU)
 {
-	gx2Log_printf("GX2SetPixelUniformBlock(0x%08x,0x%x,0x%08x)", hCPU->gpr[3], hCPU->gpr[4], hCPU->gpr[5]);
+	cemuLog_log(LogType::GX2, "GX2SetPixelUniformBlock(0x{:08x},0x{:x},0x{:08x})", hCPU->gpr[3], hCPU->gpr[4], hCPU->gpr[5]);
 	_GX2SubmitUniformBlock(mmSQ_PS_UNIFORM_BLOCK_START - mmSQ_TEX_RESOURCE_WORD0, hCPU->gpr[3], hCPU->gpr[5], hCPU->gpr[4]);
 	osLib_returnFromFunction(hCPU, 0);
 }
 
 void gx2Export_GX2SetGeometryUniformBlock(PPCInterpreter_t* hCPU)
 {
-	gx2Log_printf("GX2SetGeometryUniformBlock(0x%08x,0x%x,0x%08x)", hCPU->gpr[3], hCPU->gpr[4], hCPU->gpr[5]);
+	cemuLog_log(LogType::GX2, "GX2SetGeometryUniformBlock(0x{:08x},0x{:x},0x{:08x})", hCPU->gpr[3], hCPU->gpr[4], hCPU->gpr[5]);
 	_GX2SubmitUniformBlock(mmSQ_GS_UNIFORM_BLOCK_START - mmSQ_TEX_RESOURCE_WORD0, hCPU->gpr[3], hCPU->gpr[5], hCPU->gpr[4]);
 	osLib_returnFromFunction(hCPU, 0);
 }
 
 void gx2Export_GX2RSetVertexUniformBlock(PPCInterpreter_t* hCPU)
 {
-	GX2ReserveCmdSpace(9);
+	GX2::GX2ReserveCmdSpace(9);
 
 	GX2RBuffer* bufferPtr = (GX2RBuffer*)memory_getPointerFromVirtualOffset(hCPU->gpr[3]);
 	uint32 index = hCPU->gpr[4];
@@ -553,7 +328,7 @@ void gx2Export_GX2RSetVertexUniformBlock(PPCInterpreter_t* hCPU)
 
 void gx2Export_GX2SetShaderModeEx(PPCInterpreter_t* hCPU)
 {
-	GX2ReserveCmdSpace(8+4);
+	GX2::GX2ReserveCmdSpace(8+4);
 	uint32 mode = hCPU->gpr[3];
 
 	uint32 sqConfig = hCPU->gpr[3] == 0 ? 4 : 0;
diff --git a/src/Cafe/OS/libs/h264_avc/H264Dec.cpp b/src/Cafe/OS/libs/h264_avc/H264Dec.cpp
index 085a2e69..82db039b 100644
--- a/src/Cafe/OS/libs/h264_avc/H264Dec.cpp
+++ b/src/Cafe/OS/libs/h264_avc/H264Dec.cpp
@@ -1,17 +1,12 @@
 #include "Cafe/OS/common/OSCommon.h"
 #include "Cafe/HW/Espresso/PPCCallback.h"
 #include "Cafe/OS/libs/h264_avc/parser/H264Parser.h"
+#include "Cafe/OS/libs/h264_avc/H264DecInternal.h"
 #include "util/highresolutiontimer/HighResolutionTimer.h"
 #include "Cafe/CafeSystem.h"
 
 #include "h264dec.h"
 
-extern "C"
-{
-#include "../dependencies/ih264d/common/ih264_typedefs.h"
-#include "../dependencies/ih264d/decoder/ih264d.h"
-};
-
 enum class H264DEC_STATUS : uint32
 {
 	SUCCESS = 0x0,
@@ -33,10 +28,35 @@ namespace H264
 		return false;
 	}
 
+	struct H264Context
+	{
+		struct
+		{
+			MEMPTR<void> ptr{ nullptr };
+			uint32be length{ 0 };
+			float64be timestamp;
+		}BitStream;
+		struct
+		{
+			MEMPTR<void> outputFunc{ nullptr };
+			uint8be outputPerFrame{ 0 }; // whats the default?
+			MEMPTR<void> userMemoryParam{ nullptr };
+		}Param;
+		// misc
+		uint32be sessionHandle;
+
+		// decoder state
+		struct
+		{
+			uint32 numFramesInFlight{0};
+		}decoderState;
+	};
+
 	uint32 H264DECMemoryRequirement(uint32 codecProfile, uint32 codecLevel, uint32 width, uint32 height, uint32be* sizeRequirementOut)
 	{
 		if (H264_IsBotW())
 		{
+			static_assert(sizeof(H264Context) < 256);
 			*sizeRequirementOut = 256;
 			return 0;
 		}
@@ -169,561 +189,47 @@ namespace H264
 		return H264DEC_STATUS::BAD_STREAM;
 	}
 
-	struct H264Context 
-	{
-		struct  
-		{
-			MEMPTR<void> ptr{ nullptr };
-			uint32be length{ 0 };
-			float64be timestamp;
-		}BitStream;
-		struct  
-		{
-			MEMPTR<void> outputFunc{ nullptr };
-			uint8be outputPerFrame{ 0 }; // whats the default?
-			MEMPTR<void> userMemoryParam{ nullptr };
-		}Param;
-		// misc
-		uint32be sessionHandle;
-	};
-
-	class H264AVCDecoder
-	{
-		static void* ivd_aligned_malloc(void* ctxt, WORD32 alignment, WORD32 size)
-		{
-#ifdef _WIN32
-			return _aligned_malloc(size, alignment);
-#else
-			return aligned_alloc(alignment, size);
-#endif
-		}
-
-		static void ivd_aligned_free(void* ctxt, void* buf) 
-		{
-#ifdef _WIN32
-			_aligned_free(buf);
-#else
-			free(buf);
-#endif
-			return;
-		}
-
-	public:
-		struct DecodeResult
-		{
-			bool frameReady{ false };
-			double timestamp;
-			void* imageOutput;
-			ivd_video_decode_op_t decodeOutput;
-		};
-
-		void Init(bool isBufferedMode)
-		{
-			ih264d_create_ip_t s_create_ip{ 0 };
-			ih264d_create_op_t s_create_op{ 0 };
-
-			s_create_ip.s_ivd_create_ip_t.u4_size = sizeof(ih264d_create_ip_t);
-			s_create_ip.s_ivd_create_ip_t.e_cmd = IVD_CMD_CREATE;
-			s_create_ip.s_ivd_create_ip_t.u4_share_disp_buf = 1; // shared display buffer mode -> We give the decoder a list of buffers that it will use (?)
-			
-			s_create_op.s_ivd_create_op_t.u4_size = sizeof(ih264d_create_op_t);
-			s_create_ip.s_ivd_create_ip_t.e_output_format = IV_YUV_420SP_UV;
-			s_create_ip.s_ivd_create_ip_t.pf_aligned_alloc = ivd_aligned_malloc;
-			s_create_ip.s_ivd_create_ip_t.pf_aligned_free = ivd_aligned_free;
-			s_create_ip.s_ivd_create_ip_t.pv_mem_ctxt = NULL;
-
-			WORD32 status = ih264d_api_function(m_codecCtx, &s_create_ip, &s_create_op);
-			cemu_assert(!status);
-
-			m_codecCtx = (iv_obj_t*)s_create_op.s_ivd_create_op_t.pv_handle;
-			m_codecCtx->pv_fxns = (void*)&ih264d_api_function;
-			m_codecCtx->u4_size = sizeof(iv_obj_t);
-
-			m_isBufferedMode = isBufferedMode;
-
-			UpdateParameters(false);
-
-			m_bufferedResults.clear();
-			m_numDecodedFrames = 0;
-			m_hasBufferSizeInfo = false;
-			m_timestampIndex = 0;
-		}
-
-		void Destroy()
-		{
-			if (!m_codecCtx)
-				return;
-			ih264d_delete_ip_t s_delete_ip{ 0 };
-			ih264d_delete_op_t s_delete_op{ 0 };
-			s_delete_ip.s_ivd_delete_ip_t.u4_size = sizeof(ih264d_delete_ip_t);
-			s_delete_ip.s_ivd_delete_ip_t.e_cmd = IVD_CMD_DELETE;
-			s_delete_op.s_ivd_delete_op_t.u4_size = sizeof(ih264d_delete_op_t);
-			WORD32 status = ih264d_api_function(m_codecCtx, &s_delete_ip, &s_delete_op);
-			cemu_assert_debug(!status);
-			m_codecCtx = nullptr;
-		}
-
-		static bool GetImageInfo(uint8* stream, uint32 length, uint32& imageWidth, uint32& imageHeight)
-		{
-			// create temporary decoder
-			ih264d_create_ip_t s_create_ip{ 0 };
-			ih264d_create_op_t s_create_op{ 0 };
-			s_create_ip.s_ivd_create_ip_t.u4_size = sizeof(ih264d_create_ip_t);
-			s_create_ip.s_ivd_create_ip_t.e_cmd = IVD_CMD_CREATE;
-			s_create_ip.s_ivd_create_ip_t.u4_share_disp_buf = 0;
-			s_create_op.s_ivd_create_op_t.u4_size = sizeof(ih264d_create_op_t);
-			s_create_ip.s_ivd_create_ip_t.e_output_format = IV_YUV_420SP_UV;
-			s_create_ip.s_ivd_create_ip_t.pf_aligned_alloc = ivd_aligned_malloc;
-			s_create_ip.s_ivd_create_ip_t.pf_aligned_free = ivd_aligned_free;
-			s_create_ip.s_ivd_create_ip_t.pv_mem_ctxt = NULL;
-			iv_obj_t* ctx = nullptr;
-			WORD32 status = ih264d_api_function(ctx, &s_create_ip, &s_create_op);
-			cemu_assert_debug(!status);
-			if (status != IV_SUCCESS)
-				return false;
-			ctx = (iv_obj_t*)s_create_op.s_ivd_create_op_t.pv_handle;
-			ctx->pv_fxns = (void*)&ih264d_api_function;
-			ctx->u4_size = sizeof(iv_obj_t);
-			// set header-only mode
-			ih264d_ctl_set_config_ip_t s_h264d_ctl_ip{ 0 };
-			ih264d_ctl_set_config_op_t s_h264d_ctl_op{ 0 };
-			ivd_ctl_set_config_ip_t* ps_ctl_ip = &s_h264d_ctl_ip.s_ivd_ctl_set_config_ip_t;
-			ivd_ctl_set_config_op_t* ps_ctl_op = &s_h264d_ctl_op.s_ivd_ctl_set_config_op_t;
-			ps_ctl_ip->u4_disp_wd = 0;
-			ps_ctl_ip->e_frm_skip_mode = IVD_SKIP_NONE;
-			ps_ctl_ip->e_frm_out_mode = IVD_DISPLAY_FRAME_OUT;
-			ps_ctl_ip->e_vid_dec_mode = IVD_DECODE_HEADER;
-			ps_ctl_ip->e_cmd = IVD_CMD_VIDEO_CTL;
-			ps_ctl_ip->e_sub_cmd = IVD_CMD_CTL_SETPARAMS;
-			ps_ctl_ip->u4_size = sizeof(ih264d_ctl_set_config_ip_t);
-			ps_ctl_op->u4_size = sizeof(ih264d_ctl_set_config_op_t);
-			status = ih264d_api_function(ctx, &s_h264d_ctl_ip, &s_h264d_ctl_op);
-			cemu_assert(!status);
-			// decode stream
-			ivd_video_decode_ip_t s_dec_ip{ 0 };
-			ivd_video_decode_op_t s_dec_op{ 0 };
-			s_dec_ip.u4_size = sizeof(ivd_video_decode_ip_t);
-			s_dec_op.u4_size = sizeof(ivd_video_decode_op_t);
-			s_dec_ip.e_cmd = IVD_CMD_VIDEO_DECODE;
-			s_dec_ip.pv_stream_buffer = stream;
-			s_dec_ip.u4_num_Bytes = length;
-			s_dec_ip.s_out_buffer.u4_num_bufs = 0;
-
-			s_dec_op.u4_raw_wd = 0;
-			s_dec_op.u4_raw_ht = 0;
-
-			status = ih264d_api_function(ctx, &s_dec_ip, &s_dec_op);
-			//cemu_assert(status == 0); -> This errors when not both the headers are present, but it will still set the parameters we need
-			bool isValid = false;
-			if (true)//status == 0)
-			{
-				imageWidth = s_dec_op.u4_raw_wd;
-				imageHeight = s_dec_op.u4_raw_ht;
-				cemu_assert_debug(imageWidth != 0 && imageHeight != 0);
-				isValid = true;
-			}
-			// destroy decoder
-			ih264d_delete_ip_t s_delete_ip{ 0 };
-			ih264d_delete_op_t s_delete_op{ 0 };
-			s_delete_ip.s_ivd_delete_ip_t.u4_size = sizeof(ih264d_delete_ip_t);
-			s_delete_ip.s_ivd_delete_ip_t.e_cmd = IVD_CMD_DELETE;
-			s_delete_op.s_ivd_delete_op_t.u4_size = sizeof(ih264d_delete_op_t);
-			status = ih264d_api_function(ctx, &s_delete_ip, &s_delete_op);
-			cemu_assert_debug(!status);
-			return isValid;
-		}
-
-		void Decode(void* data, uint32 length, double timestamp, void* imageOutput, DecodeResult& decodeResult)
-		{
-			if (!m_hasBufferSizeInfo)
-			{
-				uint32 numByteConsumed = 0;
-				if (!DetermineBufferSizes(data, length, numByteConsumed))
-				{
-					cemuLog_force("H264: Unable to determine picture size. Ignoring decode input");
-					decodeResult.frameReady = false;
-					return;
-				}
-				length -= numByteConsumed;
-				data = (uint8*)data + numByteConsumed;
-				m_hasBufferSizeInfo = true;
-			}
-
-			ivd_video_decode_ip_t s_dec_ip{ 0 };
-			ivd_video_decode_op_t s_dec_op{ 0 };
-			s_dec_ip.u4_size = sizeof(ivd_video_decode_ip_t);
-			s_dec_op.u4_size = sizeof(ivd_video_decode_op_t);
-
-			s_dec_ip.e_cmd = IVD_CMD_VIDEO_DECODE;
-
-			// remember timestamp and associated output buffer
-			m_timestamps[m_timestampIndex] = timestamp;
-			m_imageBuffers[m_timestampIndex] = imageOutput;
-			s_dec_ip.u4_ts = m_timestampIndex;
-			m_timestampIndex = (m_timestampIndex + 1) % 64;
-
-			s_dec_ip.pv_stream_buffer = (uint8*)data;
-			s_dec_ip.u4_num_Bytes = length;
-
-			s_dec_ip.s_out_buffer.u4_min_out_buf_size[0] = 0;
-			s_dec_ip.s_out_buffer.u4_min_out_buf_size[1] = 0;
-			s_dec_ip.s_out_buffer.u4_num_bufs = 0;
-
-			BenchmarkTimer bt;
-			bt.Start();
-			WORD32 status = ih264d_api_function(m_codecCtx, &s_dec_ip, &s_dec_op);
-			if (status != 0 && (s_dec_op.u4_error_code&0xFF) == IVD_RES_CHANGED)
-			{
-				// resolution change
-				ResetDecoder();
-				m_hasBufferSizeInfo = false;
-				Decode(data, length, timestamp, imageOutput, decodeResult);
-				return;
-			}
-			else if (status != 0)
-			{
-				cemuLog_force("H264: Failed to decode frame (error 0x{:08x})", status);
-				decodeResult.frameReady = false;
-				return;
-			}
-
-			bt.Stop();
-			double decodeTime = bt.GetElapsedMilliseconds();
-
-			cemu_assert(s_dec_op.u4_frame_decoded_flag);
-			cemu_assert_debug(s_dec_op.u4_num_bytes_consumed == length);
-
-			cemu_assert_debug(m_isBufferedMode || s_dec_op.u4_output_present); // if buffered mode is disabled, then every input should output a frame (except for partial slices?)
-
-			if (s_dec_op.u4_output_present)
-			{
-				cemu_assert(s_dec_op.e_output_format == IV_YUV_420SP_UV);
-				if (H264_IsBotW())
-				{
-					if (s_dec_op.s_disp_frm_buf.u4_y_wd == 1920 && s_dec_op.s_disp_frm_buf.u4_y_ht == 1088)
-						s_dec_op.s_disp_frm_buf.u4_y_ht = 1080;
-				}
-				DecodeResult tmpResult;
-				tmpResult.frameReady = s_dec_op.u4_output_present != 0;
-				tmpResult.timestamp = m_timestamps[s_dec_op.u4_ts];
-				tmpResult.imageOutput = m_imageBuffers[s_dec_op.u4_ts];
-				tmpResult.decodeOutput = s_dec_op;
-				AddBufferedResult(tmpResult);
-				// transfer image to PPC output buffer and also correct stride
-				bt.Start();
-				CopyImageToResultBuffer((uint8*)s_dec_op.s_disp_frm_buf.pv_y_buf, (uint8*)s_dec_op.s_disp_frm_buf.pv_u_buf, (uint8*)m_imageBuffers[s_dec_op.u4_ts], s_dec_op);
-				bt.Stop();
-				double copyTime = bt.GetElapsedMilliseconds();
-				// release buffer
-				sint32 bufferId = -1;
-				for (size_t i = 0; i < m_displayBuf.size(); i++)
-				{
-					if (s_dec_op.s_disp_frm_buf.pv_y_buf >= m_displayBuf[i].data() && s_dec_op.s_disp_frm_buf.pv_y_buf < (m_displayBuf[i].data() + m_displayBuf[i].size()))
-					{
-						bufferId = (sint32)i;
-						break;
-					}
-				}
-				cemu_assert_debug(bufferId == s_dec_op.u4_disp_buf_id);
-				cemu_assert(bufferId >= 0);
-				ivd_rel_display_frame_ip_t s_video_rel_disp_ip{ 0 };
-				ivd_rel_display_frame_op_t s_video_rel_disp_op{ 0 };
-				s_video_rel_disp_ip.e_cmd = IVD_CMD_REL_DISPLAY_FRAME;
-				s_video_rel_disp_ip.u4_size = sizeof(ivd_rel_display_frame_ip_t);
-				s_video_rel_disp_op.u4_size = sizeof(ivd_rel_display_frame_op_t);
-				s_video_rel_disp_ip.u4_disp_buf_id = bufferId;
-				status = ih264d_api_function(m_codecCtx, &s_video_rel_disp_ip, &s_video_rel_disp_op);
-				cemu_assert(!status);
-
-				cemuLog_log(LogType::H264, "H264Bench | DecodeTime {}ms CopyTime {}ms", decodeTime, copyTime);
-			}
-			else
-			{
-				cemuLog_log(LogType::H264, "H264Bench | DecodeTime{}ms", decodeTime);
-			}
-
-			if (s_dec_op.u4_frame_decoded_flag)
-				m_numDecodedFrames++;
-
-			if (m_isBufferedMode)
-			{
-				// in buffered mode, always buffer 5 frames regardless of actual reordering and decoder latency
-				if (m_numDecodedFrames > 5)
-					GetCurrentBufferedResult(decodeResult);
-			}
-			else if(m_numDecodedFrames > 0)
-				GetCurrentBufferedResult(decodeResult);
-
-			// get VUI
-			//ih264d_ctl_get_vui_params_ip_t s_ctl_get_vui_params_ip;
-			//ih264d_ctl_get_vui_params_op_t s_ctl_get_vui_params_op;
-
-			//s_ctl_get_vui_params_ip.e_cmd = IVD_CMD_VIDEO_CTL;
-			//s_ctl_get_vui_params_ip.e_sub_cmd = (IVD_CONTROL_API_COMMAND_TYPE_T)IH264D_CMD_CTL_GET_VUI_PARAMS;
-			//s_ctl_get_vui_params_ip.u4_size = sizeof(ih264d_ctl_get_vui_params_ip_t);
-			//s_ctl_get_vui_params_op.u4_size = sizeof(ih264d_ctl_get_vui_params_op_t);
-
-			//status = ih264d_api_function(mCodecCtx, &s_ctl_get_vui_params_ip, &s_ctl_get_vui_params_op);
-			//cemu_assert(status == 0);
-		}
-
-		std::vector<DecodeResult> Flush()
-		{
-			std::vector<DecodeResult> results;
-			// set flush mode
-			ivd_ctl_flush_ip_t s_video_flush_ip{ 0 };
-			ivd_ctl_flush_op_t s_video_flush_op{ 0 };
-			s_video_flush_ip.e_cmd = IVD_CMD_VIDEO_CTL;
-			s_video_flush_ip.e_sub_cmd = IVD_CMD_CTL_FLUSH;
-			s_video_flush_ip.u4_size = sizeof(ivd_ctl_flush_ip_t);
-			s_video_flush_op.u4_size = sizeof(ivd_ctl_flush_op_t);
-			WORD32 status = ih264d_api_function(m_codecCtx, &s_video_flush_ip, &s_video_flush_op);
-			if (status != 0)
-				cemuLog_log(LogType::Force, "H264Dec: Unexpected error during flush ({})", status);
-			// get all frames from the codec
-			while (true)
-			{
-				ivd_video_decode_ip_t s_dec_ip{ 0 };
-				ivd_video_decode_op_t s_dec_op{ 0 };
-				s_dec_ip.u4_size = sizeof(ivd_video_decode_ip_t);
-				s_dec_op.u4_size = sizeof(ivd_video_decode_op_t);
-				s_dec_ip.e_cmd = IVD_CMD_VIDEO_DECODE;
-				s_dec_ip.pv_stream_buffer = NULL;
-				s_dec_ip.u4_num_Bytes = 0;
-				s_dec_ip.s_out_buffer.u4_min_out_buf_size[0] = 0;
-				s_dec_ip.s_out_buffer.u4_min_out_buf_size[1] = 0;
-				s_dec_ip.s_out_buffer.u4_num_bufs = 0;
-				status = ih264d_api_function(m_codecCtx, &s_dec_ip, &s_dec_op);
-				if (status != 0)
-					break;
-				cemu_assert_debug(s_dec_op.u4_output_present != 0); // should never be zero?
-				if(s_dec_op.u4_output_present == 0)
-					continue;
-				if (H264_IsBotW())
-				{
-					if (s_dec_op.s_disp_frm_buf.u4_y_wd == 1920 && s_dec_op.s_disp_frm_buf.u4_y_ht == 1088)
-						s_dec_op.s_disp_frm_buf.u4_y_ht = 1080;
-				}
-				DecodeResult tmpResult;
-				tmpResult.frameReady = s_dec_op.u4_output_present != 0;
-				tmpResult.timestamp = m_timestamps[s_dec_op.u4_ts];
-				tmpResult.imageOutput = m_imageBuffers[s_dec_op.u4_ts];
-				tmpResult.decodeOutput = s_dec_op;
-				AddBufferedResult(tmpResult);
-				CopyImageToResultBuffer((uint8*)s_dec_op.s_disp_frm_buf.pv_y_buf, (uint8*)s_dec_op.s_disp_frm_buf.pv_u_buf, (uint8*)m_imageBuffers[s_dec_op.u4_ts], s_dec_op);
-			}
-			results = std::move(m_bufferedResults);
-			return results;
-		}
-
-		void CopyImageToResultBuffer(uint8* yIn, uint8* uvIn, uint8* bufOut, ivd_video_decode_op_t& decodeInfo)
-		{
-			uint32 imageWidth = decodeInfo.s_disp_frm_buf.u4_y_wd;
-			uint32 imageHeight = decodeInfo.s_disp_frm_buf.u4_y_ht;
-
-			size_t inputStride = decodeInfo.s_disp_frm_buf.u4_y_strd;
-			size_t outputStride = (imageWidth + 0xFF) & ~0xFF;
-
-			// copy Y
-			uint8* yOut = bufOut;
-			for (uint32 row = 0; row < imageHeight; row++)
-			{
-				memcpy(yOut, yIn, imageWidth);
-				yIn += inputStride;
-				yOut += outputStride;
-			}
-
-			// copy UV
-			uint8* uvOut = bufOut + outputStride * imageHeight;
-			for (uint32 row = 0; row < imageHeight/2; row++)
-			{
-				memcpy(uvOut, uvIn, imageWidth);
-				uvIn += inputStride;
-				uvOut += outputStride;
-			}
-		}
-
-	private:
-
-		bool DetermineBufferSizes(void* data, uint32 length, uint32& numByteConsumed)
-		{
-			numByteConsumed = 0;
-			UpdateParameters(true);
-
-			ivd_video_decode_ip_t s_dec_ip{ 0 };
-			ivd_video_decode_op_t s_dec_op{ 0 };
-			s_dec_ip.u4_size = sizeof(ivd_video_decode_ip_t);
-			s_dec_op.u4_size = sizeof(ivd_video_decode_op_t);
-
-			s_dec_ip.e_cmd = IVD_CMD_VIDEO_DECODE;
-			s_dec_ip.pv_stream_buffer =	(uint8*)data;
-			s_dec_ip.u4_num_Bytes = length;
-			s_dec_ip.s_out_buffer.u4_num_bufs = 0;
-			WORD32 status = ih264d_api_function(m_codecCtx, &s_dec_ip, &s_dec_op);
-			if (status != 0)
-			{
-				forceLog_printf("H264: Unable to determine buffer sizes for stream");
-				return false;
-			}
-			numByteConsumed = s_dec_op.u4_num_bytes_consumed;
-			cemu_assert(status == 0);
-			if (s_dec_op.u4_pic_wd == 0 || s_dec_op.u4_pic_ht == 0)
-				return false;
-			UpdateParameters(false);	
-			ReinitBuffers();
-			return true;
-		}
-
-		void ReinitBuffers()
-		{
-			ivd_ctl_getbufinfo_ip_t s_ctl_ip{ 0 };
-			ivd_ctl_getbufinfo_op_t s_ctl_op{ 0 };
-			WORD32 outlen = 0;
-
-			s_ctl_ip.e_cmd = IVD_CMD_VIDEO_CTL;
-			s_ctl_ip.e_sub_cmd = IVD_CMD_CTL_GETBUFINFO;
-			s_ctl_ip.u4_size = sizeof(ivd_ctl_getbufinfo_ip_t);
-			s_ctl_op.u4_size = sizeof(ivd_ctl_getbufinfo_op_t);
-
-			WORD32 status = ih264d_api_function(m_codecCtx, &s_ctl_ip, &s_ctl_op);
-			cemu_assert(!status);
-
-			// allocate
-			for (uint32 i = 0; i < s_ctl_op.u4_num_disp_bufs; i++)
-			{
-				m_displayBuf.emplace_back().resize(s_ctl_op.u4_min_out_buf_size[0] + s_ctl_op.u4_min_out_buf_size[1]);
-			}
-			// set
-			ivd_set_display_frame_ip_t s_set_display_frame_ip{ 0 }; // make sure to zero-initialize this. The codec seems to check the first 3 pointers/sizes per frame, regardless of the value of u4_num_bufs
-			ivd_set_display_frame_op_t s_set_display_frame_op{ 0 };
-
-			s_set_display_frame_ip.e_cmd = IVD_CMD_SET_DISPLAY_FRAME;
-			s_set_display_frame_ip.u4_size = sizeof(ivd_set_display_frame_ip_t);
-			s_set_display_frame_op.u4_size = sizeof(ivd_set_display_frame_op_t);
-
-			cemu_assert_debug(s_ctl_op.u4_min_num_out_bufs == 2);
-			cemu_assert_debug(s_ctl_op.u4_min_out_buf_size[0] != 0 && s_ctl_op.u4_min_out_buf_size[1] != 0);
-
-			s_set_display_frame_ip.num_disp_bufs = s_ctl_op.u4_num_disp_bufs;
-
-			for (uint32 i = 0; i < s_ctl_op.u4_num_disp_bufs; i++)
-			{
-				s_set_display_frame_ip.s_disp_buffer[i].u4_num_bufs = 2;
-				s_set_display_frame_ip.s_disp_buffer[i].u4_min_out_buf_size[0] = s_ctl_op.u4_min_out_buf_size[0];
-				s_set_display_frame_ip.s_disp_buffer[i].u4_min_out_buf_size[1] = s_ctl_op.u4_min_out_buf_size[1];
-				s_set_display_frame_ip.s_disp_buffer[i].pu1_bufs[0] = m_displayBuf[i].data() + 0;
-				s_set_display_frame_ip.s_disp_buffer[i].pu1_bufs[1] = m_displayBuf[i].data() + s_ctl_op.u4_min_out_buf_size[0];
-			}
-
-			status = ih264d_api_function(m_codecCtx, &s_set_display_frame_ip, &s_set_display_frame_op);
-			cemu_assert(!status);
-
-
-			// mark all as released (available)
-			for (uint32 i = 0; i < s_ctl_op.u4_num_disp_bufs; i++)
-			{
-				ivd_rel_display_frame_ip_t s_video_rel_disp_ip{ 0 };
-				ivd_rel_display_frame_op_t s_video_rel_disp_op{ 0 };
-
-				s_video_rel_disp_ip.e_cmd = IVD_CMD_REL_DISPLAY_FRAME;
-				s_video_rel_disp_ip.u4_size = sizeof(ivd_rel_display_frame_ip_t);
-				s_video_rel_disp_op.u4_size = sizeof(ivd_rel_display_frame_op_t);
-				s_video_rel_disp_ip.u4_disp_buf_id = i;
-
-				status = ih264d_api_function(m_codecCtx, &s_video_rel_disp_ip, &s_video_rel_disp_op);
-				cemu_assert(!status);
-			}
-		}
-
-		void ResetDecoder()
-		{
-			ivd_ctl_reset_ip_t s_ctl_ip;
-			ivd_ctl_reset_op_t s_ctl_op;
-
-			s_ctl_ip.e_cmd = IVD_CMD_VIDEO_CTL;
-			s_ctl_ip.e_sub_cmd = IVD_CMD_CTL_RESET;
-			s_ctl_ip.u4_size = sizeof(ivd_ctl_reset_ip_t);
-			s_ctl_op.u4_size = sizeof(ivd_ctl_reset_op_t);
-
-			WORD32 status = ih264d_api_function(m_codecCtx, (void*)&s_ctl_ip, (void*)&s_ctl_op);
-			cemu_assert_debug(status == 0);
-		}
-
-		void UpdateParameters(bool headerDecodeOnly)
-		{
-			ih264d_ctl_set_config_ip_t s_h264d_ctl_ip{ 0 };
-			ih264d_ctl_set_config_op_t s_h264d_ctl_op{ 0 };
-			ivd_ctl_set_config_ip_t* ps_ctl_ip = &s_h264d_ctl_ip.s_ivd_ctl_set_config_ip_t;
-			ivd_ctl_set_config_op_t* ps_ctl_op = &s_h264d_ctl_op.s_ivd_ctl_set_config_op_t;
-
-			ps_ctl_ip->u4_disp_wd = 0;
-			ps_ctl_ip->e_frm_skip_mode = IVD_SKIP_NONE;
-			ps_ctl_ip->e_frm_out_mode = m_isBufferedMode ? IVD_DISPLAY_FRAME_OUT : IVD_DECODE_FRAME_OUT;
-			ps_ctl_ip->e_vid_dec_mode = headerDecodeOnly ? IVD_DECODE_HEADER : IVD_DECODE_FRAME;
-			ps_ctl_ip->e_cmd = IVD_CMD_VIDEO_CTL;
-			ps_ctl_ip->e_sub_cmd = IVD_CMD_CTL_SETPARAMS;
-			ps_ctl_ip->u4_size = sizeof(ih264d_ctl_set_config_ip_t);
-			ps_ctl_op->u4_size = sizeof(ih264d_ctl_set_config_op_t);
-
-			WORD32 status = ih264d_api_function(m_codecCtx, &s_h264d_ctl_ip, &s_h264d_ctl_op);
-			cemu_assert(status == 0);
-		}
-
-		/* In non-flush mode we have a delay of (at least?) 5 frames */
-		void AddBufferedResult(DecodeResult& decodeResult)
-		{
-			if (decodeResult.frameReady)
-				m_bufferedResults.emplace_back(decodeResult);
-		}
-
-		void GetCurrentBufferedResult(DecodeResult& decodeResult)
-		{
-			cemu_assert(!m_bufferedResults.empty());
-			if (m_bufferedResults.empty())
-			{
-				decodeResult.frameReady = false;
-				return;
-			}
-			decodeResult = m_bufferedResults.front();
-			m_bufferedResults.erase(m_bufferedResults.begin());
-		}
-
-	private:
-		iv_obj_t* m_codecCtx{nullptr};
-		bool m_hasBufferSizeInfo{ false };
-		bool m_isBufferedMode{ false };
-		double m_timestamps[64];
-		void* m_imageBuffers[64];
-		uint32 m_timestampIndex{0};
-		std::vector<DecodeResult> m_bufferedResults;
-		uint32 m_numDecodedFrames{0};
-		std::vector<std::vector<uint8>> m_displayBuf;
-	};
-
 	H264DEC_STATUS H264DECGetImageSize(uint8* stream, uint32 length, uint32 offset, uint32be* outputWidth, uint32be* outputHeight)
 	{
-		cemu_assert(offset <= length);
-
-		uint32 imageWidth, imageHeight;
-		
-		if (H264AVCDecoder::GetImageInfo(stream, length, imageWidth, imageHeight))
+		if(!stream || length < 4 || !outputWidth || !outputHeight)
+			return H264DEC_STATUS::INVALID_PARAM;
+		if( (offset+4) > length )
+			return H264DEC_STATUS::INVALID_PARAM;
+		uint8* cur = stream + offset;
+		uint8* end = stream + length;
+		cur += 2; // we access cur[-2] and cur[-1] so we need to start at offset 2
+		while(cur < end-2)
 		{
-			if (H264_IsBotW())
+			// check for start code
+			if(*cur != 1)
 			{
-				if (imageWidth == 1920 && imageHeight == 1088)
-					imageHeight = 1080;
+				cur++;
+				continue;
 			}
-			*outputWidth = imageWidth;
-			*outputHeight = imageHeight;
+			// check if this is a valid NAL header
+			if(cur[-2] != 0 || cur[-1] != 0 || cur[0] != 1)
+			{
+				cur++;
+				continue;
+			}
+			uint8 nalHeader = cur[1];
+			if((nalHeader & 0x1F) != 7)
+			{
+				cur++;
+				continue;
+			}
+			h264State_seq_parameter_set_t psp;
+			bool r = h264Parser_ParseSPS(cur+2, end-cur-2, psp);
+			if(!r)
+			{
+				cemu_assert_suspicious(); // should not happen
+				return H264DEC_STATUS::BAD_STREAM;
+			}
+			*outputWidth = (psp.pic_width_in_mbs_minus1 + 1) * 16;
+			*outputHeight = (psp.pic_height_in_map_units_minus1 + 1) * 16; // affected by frame_mbs_only_flag?
+			return H264DEC_STATUS::SUCCESS;
 		}
-		else
-		{
-			*outputWidth = 0;
-			*outputHeight = 0;
-			return H264DEC_STATUS::BAD_STREAM;
-		}
-
-		return H264DEC_STATUS::SUCCESS;
+		return H264DEC_STATUS::BAD_STREAM;
 	}
 
 	uint32 H264DECInitParam(uint32 workMemorySize, void* workMemory)
@@ -733,26 +239,28 @@ namespace H264
 		return 0;
 	}
 
-	std::unordered_map<uint32, H264AVCDecoder*> sDecoderSessions;
+	std::unordered_map<uint32, H264DecoderBackend*> sDecoderSessions;
 	std::mutex sDecoderSessionsMutex;
 	std::atomic_uint32_t sCurrentSessionHandle{ 1 };
 
-	static H264AVCDecoder* _CreateDecoderSession(uint32& handleOut)
+	H264DecoderBackend* CreateAVCDecoder();
+
+	static H264DecoderBackend* _CreateDecoderSession(uint32& handleOut)
 	{
 		std::unique_lock _lock(sDecoderSessionsMutex);
 		handleOut = sCurrentSessionHandle.fetch_add(1);
-		H264AVCDecoder* session = new H264AVCDecoder();
+		H264DecoderBackend* session = CreateAVCDecoder();
 		sDecoderSessions.try_emplace(handleOut, session);
 		return session;
 	}
 
-	static H264AVCDecoder* _AcquireDecoderSession(uint32 handle)
+	static H264DecoderBackend* _AcquireDecoderSession(uint32 handle)
 	{
 		std::unique_lock _lock(sDecoderSessionsMutex);
 		auto it = sDecoderSessions.find(handle);
 		if (it == sDecoderSessions.end())
 			return nullptr;
-		H264AVCDecoder* session = it->second;
+		H264DecoderBackend* session = it->second;
 		if (sDecoderSessions.size() >= 5)
 		{
 			cemuLog_log(LogType::Force, "H264: Warning - more than 5 active sessions");
@@ -761,7 +269,7 @@ namespace H264
 		return session;
 	}
 
-	static void _ReleaseDecoderSession(H264AVCDecoder* session)
+	static void _ReleaseDecoderSession(H264DecoderBackend* session)
 	{
 		std::unique_lock _lock(sDecoderSessionsMutex);
 
@@ -773,7 +281,7 @@ namespace H264
 		auto it = sDecoderSessions.find(handle);
 		if (it == sDecoderSessions.end())
 			return;
-		H264AVCDecoder* session = it->second;
+		H264DecoderBackend* session = it->second;
 		session->Destroy();
 		delete session;
 		sDecoderSessions.erase(it);
@@ -801,42 +309,44 @@ namespace H264
 	uint32 H264DECBegin(void* workMemory)
 	{
 		H264Context* ctx = (H264Context*)workMemory;
-		H264AVCDecoder* session = _AcquireDecoderSession(ctx->sessionHandle);
+		H264DecoderBackend* session = _AcquireDecoderSession(ctx->sessionHandle);
 		if (!session)
 		{
 			cemuLog_log(LogType::Force, "H264DECBegin(): Invalid session");
 			return 0;
 		}
 		session->Init(ctx->Param.outputPerFrame == 0);
+		ctx->decoderState.numFramesInFlight = 0;
 		_ReleaseDecoderSession(session);
 		return 0;
 	}
 
-	void H264DoFrameOutputCallback(H264Context* ctx, H264AVCDecoder::DecodeResult& decodeResult);
-
-	void _async_H264DECEnd(coreinit::OSEvent* executeDoneEvent, H264AVCDecoder* session, H264Context* ctx, std::vector<H264AVCDecoder::DecodeResult>* decodeResultsOut)
-	{
-		*decodeResultsOut = session->Flush();
-		coreinit::OSSignalEvent(executeDoneEvent);
-	}
+	void H264DoFrameOutputCallback(H264Context* ctx, H264DecoderBackend::DecodeResult& decodeResult);
 
 	H264DEC_STATUS H264DECEnd(void* workMemory)
 	{
 		H264Context* ctx = (H264Context*)workMemory;
-		H264AVCDecoder* session = _AcquireDecoderSession(ctx->sessionHandle);
+		H264DecoderBackend* session = _AcquireDecoderSession(ctx->sessionHandle);
 		if (!session)
 		{
 			cemuLog_log(LogType::Force, "H264DECEnd(): Invalid session");
 			return H264DEC_STATUS::SUCCESS;
 		}
-		StackAllocator<coreinit::OSEvent> executeDoneEvent;
-		coreinit::OSInitEvent(executeDoneEvent, coreinit::OSEvent::EVENT_STATE::STATE_NOT_SIGNALED, coreinit::OSEvent::EVENT_MODE::MODE_MANUAL);
-		std::vector<H264AVCDecoder::DecodeResult> results;
-		auto asyncTask = std::async(std::launch::async, _async_H264DECEnd, executeDoneEvent.GetPointer(), session, ctx, &results);
-		coreinit::OSWaitEvent(executeDoneEvent);
+		coreinit::OSEvent* flushEvt = &session->GetFlushEvent();
+		coreinit::OSResetEvent(flushEvt);
+		session->QueueFlush();
+		coreinit::OSWaitEvent(flushEvt);
+		while(true)
+		{
+			H264DecoderBackend::DecodeResult decodeResult;
+			if( !session->GetFrameOutputIfReady(decodeResult) )
+				break;
+			// todo - output all frames in a single callback?
+			H264DoFrameOutputCallback(ctx, decodeResult);
+			ctx->decoderState.numFramesInFlight--;
+		}
+		cemu_assert_debug(ctx->decoderState.numFramesInFlight == 0); // no frames should be in flight anymore. Exact behavior is not well understood but we may have to output dummy frames if necessary
 		_ReleaseDecoderSession(session);
-		for (auto& itr : results)
-			H264DoFrameOutputCallback(ctx, itr);
 		return H264DEC_STATUS::SUCCESS;
 	}
 
@@ -883,7 +393,7 @@ namespace H264
 		}
 		else
 		{
-			cemuLog_force("h264Export_H264DECSetParam(): Unsupported parameterId 0x{:08x}\n", paramId);
+			cemuLog_log(LogType::Force, "h264Export_H264DECSetParam(): Unsupported parameterId 0x{:08x}\n", paramId);
 			cemu_assert_unimplemented();
 		}
 		return H264DEC_STATUS::SUCCESS;
@@ -898,7 +408,6 @@ namespace H264
 		return 0;
 	}
 
-
 	struct H264DECFrameOutput
 	{
 		/* +0x00 */ uint32be result;
@@ -935,7 +444,7 @@ namespace H264
 
 	static_assert(sizeof(H264OutputCBStruct) == 12);
 
-	void H264DoFrameOutputCallback(H264Context* ctx, H264AVCDecoder::DecodeResult& decodeResult)
+	void H264DoFrameOutputCallback(H264Context* ctx, H264DecoderBackend::DecodeResult& decodeResult)
 	{
 		sint32 outputFrameCount = 1;
 
@@ -945,21 +454,21 @@ namespace H264
 		StackAllocator<H264DECFrameOutput, 8> stack_decodedFrameResult;
 
 		for (sint32 i = 0; i < outputFrameCount; i++)
-			stack_resultPtrArray[i] = stack_decodedFrameResult + i;
+			stack_resultPtrArray[i] = &stack_decodedFrameResult + i;
 
-		H264DECFrameOutput* frameOutput = stack_decodedFrameResult + 0;
+		H264DECFrameOutput* frameOutput = &stack_decodedFrameResult + 0;
 		memset(frameOutput, 0x00, sizeof(H264DECFrameOutput));
 		frameOutput->imagePtr = (uint8*)decodeResult.imageOutput;
 		frameOutput->result = 100;
 		frameOutput->timestamp = decodeResult.timestamp;
-		frameOutput->frameWidth = decodeResult.decodeOutput.u4_pic_wd;
-		frameOutput->frameHeight = decodeResult.decodeOutput.u4_pic_ht;
-		frameOutput->bytesPerRow = (decodeResult.decodeOutput.u4_pic_wd + 0xFF) & ~0xFF;
-		frameOutput->cropEnable = decodeResult.decodeOutput.u1_frame_cropping_flag;
-		frameOutput->cropTop = decodeResult.decodeOutput.u1_frame_cropping_rect_top_ofst;
-		frameOutput->cropBottom = decodeResult.decodeOutput.u1_frame_cropping_rect_bottom_ofst;
-		frameOutput->cropLeft = decodeResult.decodeOutput.u1_frame_cropping_rect_left_ofst;
-		frameOutput->cropRight = decodeResult.decodeOutput.u1_frame_cropping_rect_right_ofst;
+		frameOutput->frameWidth = decodeResult.frameWidth;
+		frameOutput->frameHeight = decodeResult.frameHeight;
+		frameOutput->bytesPerRow = decodeResult.bytesPerRow;
+		frameOutput->cropEnable = decodeResult.cropEnable;
+		frameOutput->cropTop = decodeResult.cropTop;
+		frameOutput->cropBottom = decodeResult.cropBottom;
+		frameOutput->cropLeft = decodeResult.cropLeft;
+		frameOutput->cropRight = decodeResult.cropRight;
 
 		StackAllocator<H264OutputCBStruct> stack_fptrOutputData;
 		stack_fptrOutputData->frameCount = outputFrameCount;
@@ -974,29 +483,41 @@ namespace H264
 		}
 	}
 
-	void _async_H264DECExecute(coreinit::OSEvent* executeDoneEvent, H264AVCDecoder* session, H264Context* ctx, void* imageOutput, H264AVCDecoder::DecodeResult* decodeResult)
-	{
-		session->Decode(ctx->BitStream.ptr.GetPtr(), ctx->BitStream.length, ctx->BitStream.timestamp, imageOutput, *decodeResult);
-		coreinit::OSSignalEvent(executeDoneEvent);
-	}
-
 	uint32 H264DECExecute(void* workMemory, void* imageOutput)
 	{
+		BenchmarkTimer bt;
+		bt.Start();
 		H264Context* ctx = (H264Context*)workMemory;
-		H264AVCDecoder* session = _AcquireDecoderSession(ctx->sessionHandle);
+		H264DecoderBackend* session = _AcquireDecoderSession(ctx->sessionHandle);
 		if (!session)
 		{
 			cemuLog_log(LogType::Force, "H264DECExecute(): Invalid session");
 			return 0;
 		}
-		StackAllocator<coreinit::OSEvent> executeDoneEvent;
-		coreinit::OSInitEvent(executeDoneEvent, coreinit::OSEvent::EVENT_STATE::STATE_NOT_SIGNALED, coreinit::OSEvent::EVENT_MODE::MODE_MANUAL);
-		H264AVCDecoder::DecodeResult decodeResult;
-		auto asyncTask = std::async(std::launch::async, _async_H264DECExecute, executeDoneEvent.GetPointer(), session, ctx, imageOutput , &decodeResult);
-		coreinit::OSWaitEvent(executeDoneEvent);
+		// feed data to backend
+		session->QueueForDecode((uint8*)ctx->BitStream.ptr.GetPtr(), ctx->BitStream.length, ctx->BitStream.timestamp, imageOutput);
+		ctx->decoderState.numFramesInFlight++;
+		// H264DECExecute is synchronous and will return a frame after either every call (non-buffered) or after 6 calls (buffered)
+		// normally frame decoding happens only during H264DECExecute, but in order to hide the latency of our CPU decoder we will decode asynchronously in buffered mode
+		uint32 numFramesToBuffer = (ctx->Param.outputPerFrame == 0) ? 5 : 0;
+		if(ctx->decoderState.numFramesInFlight > numFramesToBuffer)
+		{
+			ctx->decoderState.numFramesInFlight--;
+			while(true)
+			{
+				coreinit::OSEvent& evt = session->GetFrameOutputEvent();
+				coreinit::OSWaitEvent(&evt);
+				H264DecoderBackend::DecodeResult decodeResult;
+				if( !session->GetFrameOutputIfReady(decodeResult) )
+					continue;
+				H264DoFrameOutputCallback(ctx, decodeResult);
+				break;
+			}
+		}
 		_ReleaseDecoderSession(session);
-		if(decodeResult.frameReady)
-			H264DoFrameOutputCallback(ctx, decodeResult);
+		bt.Stop();
+		double callTime = bt.GetElapsedMilliseconds();
+		cemuLog_log(LogType::H264, "H264Bench | H264DECExecute took {}ms", callTime);
 		return 0x80 | 100;
 	}
 
@@ -1087,7 +608,7 @@ namespace H264
 				// end of sequence
 				break;
 			default:
-				forceLogDebug_printf("Unsupported NAL unit type %d", nal_unit_type);
+				cemuLog_logDebug(LogType::Force, "Unsupported NAL unit type {}", nal_unit_type);
 				cemu_assert_unimplemented();
 				// todo
 				break;
diff --git a/src/Cafe/OS/libs/h264_avc/H264DecBackendAVC.cpp b/src/Cafe/OS/libs/h264_avc/H264DecBackendAVC.cpp
new file mode 100644
index 00000000..228f65a5
--- /dev/null
+++ b/src/Cafe/OS/libs/h264_avc/H264DecBackendAVC.cpp
@@ -0,0 +1,502 @@
+#include "H264DecInternal.h"
+#include "util/highresolutiontimer/HighResolutionTimer.h"
+
+extern "C"
+{
+#include "../dependencies/ih264d/common/ih264_typedefs.h"
+#include "../dependencies/ih264d/decoder/ih264d.h"
+};
+
+namespace H264
+{
+	bool H264_IsBotW();
+
+	class H264AVCDecoder : public H264DecoderBackend
+	{
+		static void* ivd_aligned_malloc(void* ctxt, WORD32 alignment, WORD32 size)
+		{
+#ifdef _WIN32
+			return _aligned_malloc(size, alignment);
+#else
+			// alignment is atleast sizeof(void*)
+			alignment = std::max<WORD32>(alignment, sizeof(void*));
+
+			//smallest multiple of 2 at least as large as alignment
+			alignment--;
+			alignment |= alignment << 1;
+			alignment |= alignment >> 1;
+			alignment |= alignment >> 2;
+			alignment |= alignment >> 4;
+			alignment |= alignment >> 8;
+			alignment |= alignment >> 16;
+			alignment ^= (alignment >> 1);
+
+			void* temp;
+			posix_memalign(&temp, (size_t)alignment, (size_t)size);
+			return temp;
+#endif
+		}
+
+		static void ivd_aligned_free(void* ctxt, void* buf)
+		{
+#ifdef _WIN32
+			_aligned_free(buf);
+#else
+			free(buf);
+#endif
+		}
+
+	  public:
+		H264AVCDecoder()
+		{
+			m_decoderThread = std::thread(&H264AVCDecoder::DecoderThread, this);
+		}
+
+		~H264AVCDecoder()
+		{
+			m_threadShouldExit = true;
+			m_decodeSem.increment();
+			if (m_decoderThread.joinable())
+				m_decoderThread.join();
+		}
+
+		void Init(bool isBufferedMode)
+		{
+			ih264d_create_ip_t s_create_ip{ 0 };
+			ih264d_create_op_t s_create_op{ 0 };
+
+			s_create_ip.s_ivd_create_ip_t.u4_size = sizeof(ih264d_create_ip_t);
+			s_create_ip.s_ivd_create_ip_t.e_cmd = IVD_CMD_CREATE;
+			s_create_ip.s_ivd_create_ip_t.u4_share_disp_buf = 1; // shared display buffer mode -> We give the decoder a list of buffers that it will use (?)
+
+			s_create_op.s_ivd_create_op_t.u4_size = sizeof(ih264d_create_op_t);
+			s_create_ip.s_ivd_create_ip_t.e_output_format = IV_YUV_420SP_UV;
+			s_create_ip.s_ivd_create_ip_t.pf_aligned_alloc = ivd_aligned_malloc;
+			s_create_ip.s_ivd_create_ip_t.pf_aligned_free = ivd_aligned_free;
+			s_create_ip.s_ivd_create_ip_t.pv_mem_ctxt = NULL;
+
+			WORD32 status = ih264d_api_function(m_codecCtx, &s_create_ip, &s_create_op);
+			cemu_assert(!status);
+
+			m_codecCtx = (iv_obj_t*)s_create_op.s_ivd_create_op_t.pv_handle;
+			m_codecCtx->pv_fxns = (void*)&ih264d_api_function;
+			m_codecCtx->u4_size = sizeof(iv_obj_t);
+
+			SetDecoderCoreCount(1);
+
+			m_isBufferedMode = isBufferedMode;
+
+			UpdateParameters(false);
+
+			m_numDecodedFrames = 0;
+			m_hasBufferSizeInfo = false;
+		}
+
+		void Destroy()
+		{
+			if (!m_codecCtx)
+				return;
+			ih264d_delete_ip_t s_delete_ip{ 0 };
+			ih264d_delete_op_t s_delete_op{ 0 };
+			s_delete_ip.s_ivd_delete_ip_t.u4_size = sizeof(ih264d_delete_ip_t);
+			s_delete_ip.s_ivd_delete_ip_t.e_cmd = IVD_CMD_DELETE;
+			s_delete_op.s_ivd_delete_op_t.u4_size = sizeof(ih264d_delete_op_t);
+			WORD32 status = ih264d_api_function(m_codecCtx, &s_delete_ip, &s_delete_op);
+			cemu_assert_debug(!status);
+			m_codecCtx = nullptr;
+		}
+
+		void PushDecodedFrame(ivd_video_decode_op_t& s_dec_op)
+		{
+			// copy image data outside of lock since its an expensive operation
+			CopyImageToResultBuffer((uint8*)s_dec_op.s_disp_frm_buf.pv_y_buf, (uint8*)s_dec_op.s_disp_frm_buf.pv_u_buf, (uint8*)m_decodedSliceArray[s_dec_op.u4_ts].result.imageOutput, s_dec_op);
+
+			std::unique_lock _l(m_decodeQueueMtx);
+			cemu_assert(s_dec_op.u4_ts < m_decodedSliceArray.size());
+			auto& result = m_decodedSliceArray[s_dec_op.u4_ts];
+			cemu_assert_debug(result.isUsed);
+			cemu_assert_debug(s_dec_op.u4_output_present != 0);
+
+			result.result.isDecoded = true;
+			result.result.hasFrame = s_dec_op.u4_output_present != 0;
+			result.result.frameWidth = s_dec_op.u4_pic_wd;
+			result.result.frameHeight = s_dec_op.u4_pic_ht;
+			result.result.bytesPerRow = (s_dec_op.u4_pic_wd + 0xFF) & ~0xFF;
+			result.result.cropEnable = s_dec_op.u1_frame_cropping_flag;
+			result.result.cropTop = s_dec_op.u1_frame_cropping_rect_top_ofst;
+			result.result.cropBottom = s_dec_op.u1_frame_cropping_rect_bottom_ofst;
+			result.result.cropLeft = s_dec_op.u1_frame_cropping_rect_left_ofst;
+			result.result.cropRight = s_dec_op.u1_frame_cropping_rect_right_ofst;
+
+			m_displayQueue.push_back(s_dec_op.u4_ts);
+
+			_l.unlock();
+			coreinit::OSSignalEvent(m_displayQueueEvt);
+		}
+
+		// called from async worker thread
+		void Decode(DecodedSlice& decodedSlice)
+		{
+			if (!m_hasBufferSizeInfo)
+			{
+				uint32 numByteConsumed = 0;
+				if (!DetermineBufferSizes(decodedSlice.dataToDecode.m_data, decodedSlice.dataToDecode.m_length, numByteConsumed))
+				{
+					cemuLog_log(LogType::Force, "H264AVC: Unable to determine picture size. Ignoring decode input");
+					std::unique_lock _l(m_decodeQueueMtx);
+					decodedSlice.result.isDecoded = true;
+					decodedSlice.result.hasFrame = false;
+					coreinit::OSSignalEvent(m_displayQueueEvt);
+					return;
+				}
+				decodedSlice.dataToDecode.m_length -= numByteConsumed;
+				decodedSlice.dataToDecode.m_data = (uint8*)decodedSlice.dataToDecode.m_data + numByteConsumed;
+				m_hasBufferSizeInfo = true;
+			}
+
+			ivd_video_decode_ip_t s_dec_ip{ 0 };
+			ivd_video_decode_op_t s_dec_op{ 0 };
+			s_dec_ip.u4_size = sizeof(ivd_video_decode_ip_t);
+			s_dec_op.u4_size = sizeof(ivd_video_decode_op_t);
+
+			s_dec_ip.e_cmd = IVD_CMD_VIDEO_DECODE;
+
+			s_dec_ip.u4_ts = std::distance(m_decodedSliceArray.data(), &decodedSlice);
+			cemu_assert_debug(s_dec_ip.u4_ts < m_decodedSliceArray.size());
+
+			s_dec_ip.pv_stream_buffer = (uint8*)decodedSlice.dataToDecode.m_data;
+			s_dec_ip.u4_num_Bytes = decodedSlice.dataToDecode.m_length;
+
+			s_dec_ip.s_out_buffer.u4_min_out_buf_size[0] = 0;
+			s_dec_ip.s_out_buffer.u4_min_out_buf_size[1] = 0;
+			s_dec_ip.s_out_buffer.u4_num_bufs = 0;
+
+			BenchmarkTimer bt;
+			bt.Start();
+			WORD32 status = ih264d_api_function(m_codecCtx, &s_dec_ip, &s_dec_op);
+			if (status != 0 && (s_dec_op.u4_error_code&0xFF) == IVD_RES_CHANGED)
+			{
+				// resolution change
+				ResetDecoder();
+				m_hasBufferSizeInfo = false;
+				Decode(decodedSlice);
+				return;
+			}
+			else if (status != 0)
+			{
+				cemuLog_log(LogType::Force, "H264: Failed to decode frame (error 0x{:08x})", status);
+				decodedSlice.result.hasFrame = false;
+				cemu_assert_unimplemented();
+				return;
+			}
+
+			bt.Stop();
+			double decodeTime = bt.GetElapsedMilliseconds();
+
+			cemu_assert(s_dec_op.u4_frame_decoded_flag);
+			cemu_assert_debug(s_dec_op.u4_num_bytes_consumed == decodedSlice.dataToDecode.m_length);
+
+			cemu_assert_debug(m_isBufferedMode || s_dec_op.u4_output_present); // if buffered mode is disabled, then every input should output a frame (except for partial slices?)
+
+			if (s_dec_op.u4_output_present)
+			{
+				cemu_assert(s_dec_op.e_output_format == IV_YUV_420SP_UV);
+				if (H264_IsBotW())
+				{
+					if (s_dec_op.s_disp_frm_buf.u4_y_wd == 1920 && s_dec_op.s_disp_frm_buf.u4_y_ht == 1088)
+						s_dec_op.s_disp_frm_buf.u4_y_ht = 1080;
+				}
+				bt.Start();
+				PushDecodedFrame(s_dec_op);
+				bt.Stop();
+				double copyTime = bt.GetElapsedMilliseconds();
+				// release buffer
+				sint32 bufferId = -1;
+				for (size_t i = 0; i < m_displayBuf.size(); i++)
+				{
+					if (s_dec_op.s_disp_frm_buf.pv_y_buf >= m_displayBuf[i].data() && s_dec_op.s_disp_frm_buf.pv_y_buf < (m_displayBuf[i].data() + m_displayBuf[i].size()))
+					{
+						bufferId = (sint32)i;
+						break;
+					}
+				}
+				cemu_assert_debug(bufferId == s_dec_op.u4_disp_buf_id);
+				cemu_assert(bufferId >= 0);
+				ivd_rel_display_frame_ip_t s_video_rel_disp_ip{ 0 };
+				ivd_rel_display_frame_op_t s_video_rel_disp_op{ 0 };
+				s_video_rel_disp_ip.e_cmd = IVD_CMD_REL_DISPLAY_FRAME;
+				s_video_rel_disp_ip.u4_size = sizeof(ivd_rel_display_frame_ip_t);
+				s_video_rel_disp_op.u4_size = sizeof(ivd_rel_display_frame_op_t);
+				s_video_rel_disp_ip.u4_disp_buf_id = bufferId;
+				status = ih264d_api_function(m_codecCtx, &s_video_rel_disp_ip, &s_video_rel_disp_op);
+				cemu_assert(!status);
+
+				cemuLog_log(LogType::H264, "H264Bench | DecodeTime {}ms CopyTime {}ms", decodeTime, copyTime);
+			}
+			else
+			{
+				cemuLog_log(LogType::H264, "H264Bench | DecodeTime {}ms (no frame output)", decodeTime);
+			}
+
+			if (s_dec_op.u4_frame_decoded_flag)
+				m_numDecodedFrames++;
+			// get VUI
+			//ih264d_ctl_get_vui_params_ip_t s_ctl_get_vui_params_ip;
+			//ih264d_ctl_get_vui_params_op_t s_ctl_get_vui_params_op;
+
+			//s_ctl_get_vui_params_ip.e_cmd = IVD_CMD_VIDEO_CTL;
+			//s_ctl_get_vui_params_ip.e_sub_cmd = (IVD_CONTROL_API_COMMAND_TYPE_T)IH264D_CMD_CTL_GET_VUI_PARAMS;
+			//s_ctl_get_vui_params_ip.u4_size = sizeof(ih264d_ctl_get_vui_params_ip_t);
+			//s_ctl_get_vui_params_op.u4_size = sizeof(ih264d_ctl_get_vui_params_op_t);
+
+			//status = ih264d_api_function(mCodecCtx, &s_ctl_get_vui_params_ip, &s_ctl_get_vui_params_op);
+			//cemu_assert(status == 0);
+		}
+
+		void Flush()
+		{
+			// set flush mode
+			ivd_ctl_flush_ip_t s_video_flush_ip{ 0 };
+			ivd_ctl_flush_op_t s_video_flush_op{ 0 };
+			s_video_flush_ip.e_cmd = IVD_CMD_VIDEO_CTL;
+			s_video_flush_ip.e_sub_cmd = IVD_CMD_CTL_FLUSH;
+			s_video_flush_ip.u4_size = sizeof(ivd_ctl_flush_ip_t);
+			s_video_flush_op.u4_size = sizeof(ivd_ctl_flush_op_t);
+			WORD32 status = ih264d_api_function(m_codecCtx, &s_video_flush_ip, &s_video_flush_op);
+			if (status != 0)
+				cemuLog_log(LogType::Force, "H264Dec: Unexpected error during flush ({})", status);
+			// get all frames from the decoder
+			while (true)
+			{
+				ivd_video_decode_ip_t s_dec_ip{ 0 };
+				ivd_video_decode_op_t s_dec_op{ 0 };
+				s_dec_ip.u4_size = sizeof(ivd_video_decode_ip_t);
+				s_dec_op.u4_size = sizeof(ivd_video_decode_op_t);
+				s_dec_ip.e_cmd = IVD_CMD_VIDEO_DECODE;
+				s_dec_ip.pv_stream_buffer = NULL;
+				s_dec_ip.u4_num_Bytes = 0;
+				s_dec_ip.s_out_buffer.u4_min_out_buf_size[0] = 0;
+				s_dec_ip.s_out_buffer.u4_min_out_buf_size[1] = 0;
+				s_dec_ip.s_out_buffer.u4_num_bufs = 0;
+				status = ih264d_api_function(m_codecCtx, &s_dec_ip, &s_dec_op);
+				if (status != 0)
+					break;
+				cemu_assert_debug(s_dec_op.u4_output_present != 0); // should never be false?
+				if(s_dec_op.u4_output_present == 0)
+					continue;
+				if (H264_IsBotW())
+				{
+					if (s_dec_op.s_disp_frm_buf.u4_y_wd == 1920 && s_dec_op.s_disp_frm_buf.u4_y_ht == 1088)
+						s_dec_op.s_disp_frm_buf.u4_y_ht = 1080;
+				}
+				PushDecodedFrame(s_dec_op);
+			}
+		}
+
+		void CopyImageToResultBuffer(uint8* yIn, uint8* uvIn, uint8* bufOut, ivd_video_decode_op_t& decodeInfo)
+		{
+			uint32 imageWidth = decodeInfo.s_disp_frm_buf.u4_y_wd;
+			uint32 imageHeight = decodeInfo.s_disp_frm_buf.u4_y_ht;
+
+			size_t inputStride = decodeInfo.s_disp_frm_buf.u4_y_strd;
+			size_t outputStride = (imageWidth + 0xFF) & ~0xFF;
+
+			// copy Y
+			uint8* yOut = bufOut;
+			for (uint32 row = 0; row < imageHeight; row++)
+			{
+				memcpy(yOut, yIn, imageWidth);
+				yIn += inputStride;
+				yOut += outputStride;
+			}
+
+			// copy UV
+			uint8* uvOut = bufOut + outputStride * imageHeight;
+			for (uint32 row = 0; row < imageHeight/2; row++)
+			{
+				memcpy(uvOut, uvIn, imageWidth);
+				uvIn += inputStride;
+				uvOut += outputStride;
+			}
+		}
+	  private:
+		void SetDecoderCoreCount(uint32 coreCount)
+		{
+			ih264d_ctl_set_num_cores_ip_t s_set_cores_ip;
+			ih264d_ctl_set_num_cores_op_t s_set_cores_op;
+			s_set_cores_ip.e_cmd = IVD_CMD_VIDEO_CTL;
+			s_set_cores_ip.e_sub_cmd = (IVD_CONTROL_API_COMMAND_TYPE_T)IH264D_CMD_CTL_SET_NUM_CORES;
+			s_set_cores_ip.u4_num_cores = coreCount; // valid numbers are 1-4
+			s_set_cores_ip.u4_size = sizeof(ih264d_ctl_set_num_cores_ip_t);
+			s_set_cores_op.u4_size = sizeof(ih264d_ctl_set_num_cores_op_t);
+			IV_API_CALL_STATUS_T status = ih264d_api_function(m_codecCtx, (void *)&s_set_cores_ip, (void *)&s_set_cores_op);
+			cemu_assert(status == IV_SUCCESS);
+		}
+
+		bool DetermineBufferSizes(void* data, uint32 length, uint32& numByteConsumed)
+		{
+			numByteConsumed = 0;
+			UpdateParameters(true);
+
+			ivd_video_decode_ip_t s_dec_ip{ 0 };
+			ivd_video_decode_op_t s_dec_op{ 0 };
+			s_dec_ip.u4_size = sizeof(ivd_video_decode_ip_t);
+			s_dec_op.u4_size = sizeof(ivd_video_decode_op_t);
+
+			s_dec_ip.e_cmd = IVD_CMD_VIDEO_DECODE;
+			s_dec_ip.pv_stream_buffer =	(uint8*)data;
+			s_dec_ip.u4_num_Bytes = length;
+			s_dec_ip.s_out_buffer.u4_num_bufs = 0;
+			WORD32 status = ih264d_api_function(m_codecCtx, &s_dec_ip, &s_dec_op);
+			if (status != 0)
+			{
+				cemuLog_log(LogType::Force, "H264: Unable to determine buffer sizes for stream");
+				return false;
+			}
+			numByteConsumed = s_dec_op.u4_num_bytes_consumed;
+			cemu_assert(status == 0);
+			if (s_dec_op.u4_pic_wd == 0 || s_dec_op.u4_pic_ht == 0)
+				return false;
+			UpdateParameters(false);
+			ReinitBuffers();
+			return true;
+		}
+
+		void ReinitBuffers()
+		{
+			ivd_ctl_getbufinfo_ip_t s_ctl_ip{ 0 };
+			ivd_ctl_getbufinfo_op_t s_ctl_op{ 0 };
+			WORD32 outlen = 0;
+
+			s_ctl_ip.e_cmd = IVD_CMD_VIDEO_CTL;
+			s_ctl_ip.e_sub_cmd = IVD_CMD_CTL_GETBUFINFO;
+			s_ctl_ip.u4_size = sizeof(ivd_ctl_getbufinfo_ip_t);
+			s_ctl_op.u4_size = sizeof(ivd_ctl_getbufinfo_op_t);
+
+			WORD32 status = ih264d_api_function(m_codecCtx, &s_ctl_ip, &s_ctl_op);
+			cemu_assert(!status);
+
+			// allocate
+			for (uint32 i = 0; i < s_ctl_op.u4_num_disp_bufs; i++)
+			{
+				m_displayBuf.emplace_back().resize(s_ctl_op.u4_min_out_buf_size[0] + s_ctl_op.u4_min_out_buf_size[1]);
+			}
+			// set
+			ivd_set_display_frame_ip_t s_set_display_frame_ip{ 0 }; // make sure to zero-initialize this. The codec seems to check the first 3 pointers/sizes per frame, regardless of the value of u4_num_bufs
+			ivd_set_display_frame_op_t s_set_display_frame_op{ 0 };
+
+			s_set_display_frame_ip.e_cmd = IVD_CMD_SET_DISPLAY_FRAME;
+			s_set_display_frame_ip.u4_size = sizeof(ivd_set_display_frame_ip_t);
+			s_set_display_frame_op.u4_size = sizeof(ivd_set_display_frame_op_t);
+
+			cemu_assert_debug(s_ctl_op.u4_min_num_out_bufs == 2);
+			cemu_assert_debug(s_ctl_op.u4_min_out_buf_size[0] != 0 && s_ctl_op.u4_min_out_buf_size[1] != 0);
+
+			s_set_display_frame_ip.num_disp_bufs = s_ctl_op.u4_num_disp_bufs;
+
+			for (uint32 i = 0; i < s_ctl_op.u4_num_disp_bufs; i++)
+			{
+				s_set_display_frame_ip.s_disp_buffer[i].u4_num_bufs = 2;
+				s_set_display_frame_ip.s_disp_buffer[i].u4_min_out_buf_size[0] = s_ctl_op.u4_min_out_buf_size[0];
+				s_set_display_frame_ip.s_disp_buffer[i].u4_min_out_buf_size[1] = s_ctl_op.u4_min_out_buf_size[1];
+				s_set_display_frame_ip.s_disp_buffer[i].pu1_bufs[0] = m_displayBuf[i].data() + 0;
+				s_set_display_frame_ip.s_disp_buffer[i].pu1_bufs[1] = m_displayBuf[i].data() + s_ctl_op.u4_min_out_buf_size[0];
+			}
+
+			status = ih264d_api_function(m_codecCtx, &s_set_display_frame_ip, &s_set_display_frame_op);
+			cemu_assert(!status);
+
+
+			// mark all as released (available)
+			for (uint32 i = 0; i < s_ctl_op.u4_num_disp_bufs; i++)
+			{
+				ivd_rel_display_frame_ip_t s_video_rel_disp_ip{ 0 };
+				ivd_rel_display_frame_op_t s_video_rel_disp_op{ 0 };
+
+				s_video_rel_disp_ip.e_cmd = IVD_CMD_REL_DISPLAY_FRAME;
+				s_video_rel_disp_ip.u4_size = sizeof(ivd_rel_display_frame_ip_t);
+				s_video_rel_disp_op.u4_size = sizeof(ivd_rel_display_frame_op_t);
+				s_video_rel_disp_ip.u4_disp_buf_id = i;
+
+				status = ih264d_api_function(m_codecCtx, &s_video_rel_disp_ip, &s_video_rel_disp_op);
+				cemu_assert(!status);
+			}
+		}
+
+		void ResetDecoder()
+		{
+			ivd_ctl_reset_ip_t s_ctl_ip;
+			ivd_ctl_reset_op_t s_ctl_op;
+
+			s_ctl_ip.e_cmd = IVD_CMD_VIDEO_CTL;
+			s_ctl_ip.e_sub_cmd = IVD_CMD_CTL_RESET;
+			s_ctl_ip.u4_size = sizeof(ivd_ctl_reset_ip_t);
+			s_ctl_op.u4_size = sizeof(ivd_ctl_reset_op_t);
+
+			WORD32 status = ih264d_api_function(m_codecCtx, (void*)&s_ctl_ip, (void*)&s_ctl_op);
+			cemu_assert_debug(status == 0);
+		}
+
+		void UpdateParameters(bool headerDecodeOnly)
+		{
+			ih264d_ctl_set_config_ip_t s_h264d_ctl_ip{ 0 };
+			ih264d_ctl_set_config_op_t s_h264d_ctl_op{ 0 };
+			ivd_ctl_set_config_ip_t* ps_ctl_ip = &s_h264d_ctl_ip.s_ivd_ctl_set_config_ip_t;
+			ivd_ctl_set_config_op_t* ps_ctl_op = &s_h264d_ctl_op.s_ivd_ctl_set_config_op_t;
+
+			ps_ctl_ip->u4_disp_wd = 0;
+			ps_ctl_ip->e_frm_skip_mode = IVD_SKIP_NONE;
+			ps_ctl_ip->e_frm_out_mode = m_isBufferedMode ? IVD_DISPLAY_FRAME_OUT : IVD_DECODE_FRAME_OUT;
+			ps_ctl_ip->e_vid_dec_mode = headerDecodeOnly ? IVD_DECODE_HEADER : IVD_DECODE_FRAME;
+			ps_ctl_ip->e_cmd = IVD_CMD_VIDEO_CTL;
+			ps_ctl_ip->e_sub_cmd = IVD_CMD_CTL_SETPARAMS;
+			ps_ctl_ip->u4_size = sizeof(ih264d_ctl_set_config_ip_t);
+			ps_ctl_op->u4_size = sizeof(ih264d_ctl_set_config_op_t);
+
+			WORD32 status = ih264d_api_function(m_codecCtx, &s_h264d_ctl_ip, &s_h264d_ctl_op);
+			cemu_assert(status == 0);
+		}
+
+	  private:
+		void DecoderThread()
+		{
+			while(!m_threadShouldExit)
+			{
+				m_decodeSem.decrementWithWait();
+				std::unique_lock _l(m_decodeQueueMtx);
+				if (m_decodeQueue.empty())
+					continue;
+				uint32 decodeIndex = m_decodeQueue.front();
+				m_decodeQueue.erase(m_decodeQueue.begin());
+				_l.unlock();
+				if(decodeIndex == CMD_FLUSH)
+				{
+					Flush();
+					_l.lock();
+					cemu_assert_debug(m_decodeQueue.empty()); // after flushing the queue should be empty since the sender is waiting for the flush to complete
+					_l.unlock();
+					coreinit::OSSignalEvent(m_flushEvt);
+				}
+				else
+				{
+					auto& decodedSlice = m_decodedSliceArray[decodeIndex];
+					Decode(decodedSlice);
+				}
+			}
+		}
+
+		iv_obj_t* m_codecCtx{nullptr};
+		bool m_hasBufferSizeInfo{ false };
+		bool m_isBufferedMode{ false };
+		uint32 m_numDecodedFrames{0};
+		std::vector<std::vector<uint8>> m_displayBuf;
+
+		std::thread m_decoderThread;
+		std::atomic_bool m_threadShouldExit{false};
+	};
+
+	H264DecoderBackend* CreateAVCDecoder()
+	{
+		return new H264AVCDecoder();
+	}
+};
diff --git a/src/Cafe/OS/libs/h264_avc/H264DecInternal.h b/src/Cafe/OS/libs/h264_avc/H264DecInternal.h
new file mode 100644
index 00000000..498cccfa
--- /dev/null
+++ b/src/Cafe/OS/libs/h264_avc/H264DecInternal.h
@@ -0,0 +1,139 @@
+#pragma once
+
+#include "util/helpers/Semaphore.h"
+#include "Cafe/OS/libs/coreinit/coreinit_Thread.h"
+#include "Cafe/OS/libs/coreinit/coreinit_SysHeap.h"
+
+#include "Cafe/OS/libs/h264_avc/parser/H264Parser.h"
+
+namespace H264
+{
+	class H264DecoderBackend
+	{
+	  protected:
+		struct DataToDecode
+		{
+			uint8* m_data;
+			uint32 m_length;
+			std::vector<uint8> m_buffer;
+		};
+
+		static constexpr uint32 CMD_FLUSH = 0xFFFFFFFF;
+
+	  public:
+		struct DecodeResult
+		{
+			bool isDecoded{false};
+			bool hasFrame{false}; // set to true if a full frame was successfully decoded
+			double timestamp{};
+			void* imageOutput{nullptr};
+			sint32 frameWidth{0};
+			sint32 frameHeight{0};
+			uint32 bytesPerRow{0};
+			bool cropEnable{false};
+			sint32 cropTop{0};
+			sint32 cropBottom{0};
+			sint32 cropLeft{0};
+			sint32 cropRight{0};
+		};
+
+		struct DecodedSlice
+		{
+			bool isUsed{false};
+			DecodeResult result;
+			DataToDecode dataToDecode;
+		};
+
+		H264DecoderBackend()
+		{
+			m_displayQueueEvt = (coreinit::OSEvent*)coreinit::OSAllocFromSystem(sizeof(coreinit::OSEvent), 4);
+			coreinit::OSInitEvent(m_displayQueueEvt, coreinit::OSEvent::EVENT_STATE::STATE_NOT_SIGNALED, coreinit::OSEvent::EVENT_MODE::MODE_AUTO);
+			m_flushEvt = (coreinit::OSEvent*)coreinit::OSAllocFromSystem(sizeof(coreinit::OSEvent), 4);
+			coreinit::OSInitEvent(m_flushEvt, coreinit::OSEvent::EVENT_STATE::STATE_NOT_SIGNALED, coreinit::OSEvent::EVENT_MODE::MODE_AUTO);
+		};
+
+		virtual ~H264DecoderBackend()
+		{
+			coreinit::OSFreeToSystem(m_displayQueueEvt);
+			coreinit::OSFreeToSystem(m_flushEvt);
+		};
+
+		virtual void Init(bool isBufferedMode) = 0;
+		virtual void Destroy() = 0;
+
+		void QueueForDecode(uint8* data, uint32 length, double timestamp, void* imagePtr)
+		{
+			std::unique_lock _l(m_decodeQueueMtx);
+
+			DecodedSlice& ds = GetFreeDecodedSliceEntry();
+
+			ds.dataToDecode.m_buffer.assign(data, data + length);
+			ds.dataToDecode.m_data = ds.dataToDecode.m_buffer.data();
+			ds.dataToDecode.m_length = length;
+
+			ds.result.isDecoded = false;
+			ds.result.imageOutput = imagePtr;
+			ds.result.timestamp = timestamp;
+
+			m_decodeQueue.push_back(std::distance(m_decodedSliceArray.data(), &ds));
+			m_decodeSem.increment();
+		}
+
+		void QueueFlush()
+		{
+			std::unique_lock _l(m_decodeQueueMtx);
+			m_decodeQueue.push_back(CMD_FLUSH);
+			m_decodeSem.increment();
+		}
+
+		bool GetFrameOutputIfReady(DecodeResult& result)
+		{
+			std::unique_lock _l(m_decodeQueueMtx);
+			if(m_displayQueue.empty())
+				return false;
+			uint32 sliceIndex = m_displayQueue.front();
+			DecodedSlice& ds = m_decodedSliceArray[sliceIndex];
+			cemu_assert_debug(ds.result.isDecoded);
+			std::swap(result, ds.result);
+			ds.isUsed = false;
+			m_displayQueue.erase(m_displayQueue.begin());
+			return true;
+		}
+
+		coreinit::OSEvent& GetFrameOutputEvent()
+		{
+			return *m_displayQueueEvt;
+		}
+
+		coreinit::OSEvent& GetFlushEvent()
+		{
+			return *m_flushEvt;
+		}
+
+	  protected:
+		DecodedSlice& GetFreeDecodedSliceEntry()
+		{
+			for (auto& slice : m_decodedSliceArray)
+			{
+				if (!slice.isUsed)
+				{
+					slice.isUsed = true;
+					return slice;
+				}
+			}
+			cemu_assert_suspicious();
+			return m_decodedSliceArray[0];
+		}
+
+		std::mutex m_decodeQueueMtx;
+		std::vector<uint32> m_decodeQueue; // indices into m_decodedSliceArray, in order of decode input
+		CounterSemaphore m_decodeSem;
+		std::vector<uint32> m_displayQueue; // indices into m_decodedSliceArray, in order of frame display output
+		coreinit::OSEvent* m_displayQueueEvt; // signalled when a new frame is ready for display
+		coreinit::OSEvent* m_flushEvt; // signalled after flush operation finished and all queued slices are decoded
+
+		// frame output queue
+		std::mutex m_frameOutputMtx;
+		std::array<DecodedSlice, 32> m_decodedSliceArray;
+	};
+}
\ No newline at end of file
diff --git a/src/Cafe/OS/libs/h264_avc/parser/H264Parser.cpp b/src/Cafe/OS/libs/h264_avc/parser/H264Parser.cpp
index 23e388ff..36f70f81 100644
--- a/src/Cafe/OS/libs/h264_avc/parser/H264Parser.cpp
+++ b/src/Cafe/OS/libs/h264_avc/parser/H264Parser.cpp
@@ -319,6 +319,17 @@ bool parseNAL_pic_parameter_set_rbsp(h264ParserState_t* h264ParserState, h264Par
 	return true;
 }
 
+bool h264Parser_ParseSPS(uint8* data, uint32 length, h264State_seq_parameter_set_t& sps)
+{
+	h264ParserState_t parserState;
+	RBSPInputBitstream nalStream(data, length);
+	bool r = parseNAL_seq_parameter_set_rbsp(&parserState, nullptr, nalStream);
+	if(!r || !parserState.hasSPS)
+		return false;
+	sps = parserState.sps;
+	return true;
+}
+
 void parseNAL_ref_pic_list_modification(const h264State_seq_parameter_set_t& sps, const h264State_pic_parameter_set_t& pps, RBSPInputBitstream& nalStream, nal_slice_header_t* sliceHeader)
 {
 	if (!sliceHeader->slice_type.isSliceTypeI() && !sliceHeader->slice_type.isSliceTypeSI())
@@ -395,7 +406,7 @@ void parseNAL_ref_pic_list_modification(const h264State_seq_parameter_set_t& sps
 			}
 			if (sliceHeader->pic_list_modification1Count > 0)
 			{
-				forceLogDebug_printf("sliceHeader->pic_list_modification1Count non-zero is not supported");
+				cemuLog_logDebug(LogType::Force, "sliceHeader->pic_list_modification1Count non-zero is not supported");
 				cemu_assert_unimplemented();
 			}
 		}
@@ -688,9 +699,8 @@ void _calculateFrameOrder(h264ParserState_t* h264ParserState, const h264State_se
 	else if (sps.pic_order_cnt_type == 2)
 	{
 		// display order matches decode order
-
 		uint32 prevFrameNum = h264ParserState->picture_order.prevFrameNum;
-		;
+
 		uint32 FrameNumOffset;
 		if (sliceHeader->IdrPicFlag)
 		{
@@ -706,9 +716,6 @@ void _calculateFrameOrder(h264ParserState_t* h264ParserState, const h264State_se
 				FrameNumOffset = prevFrameNumOffset + sps.getMaxFrameNum();
 			else
 				FrameNumOffset = prevFrameNumOffset;
-
-
-
 		}
 
 		uint32 tempPicOrderCnt;
@@ -855,7 +862,7 @@ void h264Parse(h264ParserState_t* h264ParserState, h264ParserOutput_t* output, u
 			// seen in Cocoto Magic Circus 2 intro video
 			break;
 		default:
-			forceLogDebug_printf("Unsupported NAL unit type %d", nal_unit_type);
+			cemuLog_logDebug(LogType::Force, "Unsupported NAL unit type {}", nal_unit_type);
 			cemu_assert_debug(false);
 			// todo
 			break;
@@ -945,7 +952,7 @@ sint32 h264GetUnitLength(h264ParserState_t* h264ParserState, uint8* data, uint32
 			// end of sequence
 			break;
 		default:
-			forceLogDebug_printf("Unsupported NAL unit type %d", nal_unit_type);
+			cemuLog_logDebug(LogType::Force, "Unsupported NAL unit type {}", nal_unit_type);
 			assert_dbg(); // todo - NAL 10 is used in DKC TF
 			// todo
 			break;
@@ -1072,4 +1079,4 @@ void h264Parser_getScalingMatrix8x8(h264State_seq_parameter_set_t* sps, h264Stat
 	}
 	// default (Flat_8x8_16)
 	memset(matrix8x8, 16, 8 * 8 * sizeof(uint8));
-}
\ No newline at end of file
+}
diff --git a/src/Cafe/OS/libs/h264_avc/parser/H264Parser.h b/src/Cafe/OS/libs/h264_avc/parser/H264Parser.h
index ee32ca8b..6f2b3cf6 100644
--- a/src/Cafe/OS/libs/h264_avc/parser/H264Parser.h
+++ b/src/Cafe/OS/libs/h264_avc/parser/H264Parser.h
@@ -513,6 +513,8 @@ typedef struct
 void h264Parse(h264ParserState_t* h264ParserState, h264ParserOutput_t* output, uint8* data, uint32 length, bool parseSlices = true);
 sint32 h264GetUnitLength(h264ParserState_t* h264ParserState, uint8* data, uint32 length);
 
+bool h264Parser_ParseSPS(uint8* data, uint32 length, h264State_seq_parameter_set_t& sps);
+
 void h264Parser_getScalingMatrix4x4(h264State_seq_parameter_set_t* sps, h264State_pic_parameter_set_t* pps, nal_slice_header_t* sliceHeader, sint32 index, uint8* matrix4x4);
 void h264Parser_getScalingMatrix8x8(h264State_seq_parameter_set_t* sps, h264State_pic_parameter_set_t* pps, nal_slice_header_t* sliceHeader, sint32 index, uint8* matrix8x8);
 
diff --git a/src/Cafe/OS/libs/mic/mic.cpp b/src/Cafe/OS/libs/mic/mic.cpp
index 4bc6a969..f7b5ba5a 100644
--- a/src/Cafe/OS/libs/mic/mic.cpp
+++ b/src/Cafe/OS/libs/mic/mic.cpp
@@ -1,5 +1,7 @@
 #include "Cafe/OS/common/OSCommon.h"
 #include "input/InputManager.h"
+#include "audio/IAudioInputAPI.h"
+#include "config/CemuConfig.h"
 
 enum class MIC_RESULT
 {
@@ -13,6 +15,7 @@ enum class MIC_RESULT
 
 #define MIC_SAMPLERATE				32000
 
+const int MIC_SAMPLES_PER_3MS_32KHZ = (96);  // 32000*3/1000
 
 enum class MIC_STATUS_FLAGS : uint32
 {
@@ -22,8 +25,8 @@ enum class MIC_STATUS_FLAGS : uint32
 };
 DEFINE_ENUM_FLAG_OPERATORS(MIC_STATUS_FLAGS);
 
-#define MIC_HANDLE_DRC0				100
-#define MIC_HANDLE_DRC1				101
+#define MIC_HANDLE_DRC0				0
+#define MIC_HANDLE_DRC1				1
 
 enum class MIC_STATEID
 {
@@ -139,6 +142,36 @@ void micExport_MICInit(PPCInterpreter_t* hCPU)
 	// return status
 	memory_writeU32(hCPU->gpr[6], 0); // no error
 	osLib_returnFromFunction(hCPU, (drcIndex==0)?MIC_HANDLE_DRC0:MIC_HANDLE_DRC1); // success
+
+	auto& config = GetConfig();
+	const auto audio_api = IAudioInputAPI::Cubeb; // change this if more input apis get implemented
+
+	std::unique_lock lock(g_audioInputMutex);
+	if (!g_inputAudio)
+	{
+		IAudioInputAPI::DeviceDescriptionPtr device_description;
+		if (IAudioInputAPI::IsAudioInputAPIAvailable(audio_api))
+		{
+			auto devices = IAudioInputAPI::GetDevices(audio_api);
+			const auto it = std::find_if(devices.begin(), devices.end(), [&config](const auto& d) {return d->GetIdentifier() == config.input_device; });
+			if (it != devices.end())
+				device_description = *it;
+		}
+
+		if (device_description)
+		{
+			try
+			{
+				g_inputAudio = IAudioInputAPI::CreateDevice(audio_api, device_description, MIC_SAMPLERATE, 1, MIC_SAMPLES_PER_3MS_32KHZ, 16);
+				g_inputAudio->SetVolume(config.input_volume);
+			}
+			catch (std::runtime_error& ex)
+			{
+				cemuLog_log(LogType::Force, "can't initialize audio input: {}", ex.what());
+				exit(0);
+			}
+		}
+	}
 }
 
 void micExport_MICOpen(PPCInterpreter_t* hCPU)
@@ -172,6 +205,10 @@ void micExport_MICOpen(PPCInterpreter_t* hCPU)
 	// success
 	MICStatus.drc[drcIndex].isOpen = true;
 	osLib_returnFromFunction(hCPU, (uint32)MIC_RESULT::SUCCESS);
+
+	std::shared_lock lock(g_audioInputMutex);
+	if(g_inputAudio)
+		g_inputAudio->Play();
 }
 
 void micExport_MICClose(PPCInterpreter_t* hCPU)
@@ -198,6 +235,10 @@ void micExport_MICClose(PPCInterpreter_t* hCPU)
 	// success
 	MICStatus.drc[drcIndex].isOpen = false;
 	osLib_returnFromFunction(hCPU, (uint32)MIC_RESULT::SUCCESS);
+
+	std::shared_lock lock(g_audioInputMutex);
+	if (g_inputAudio)
+		g_inputAudio->Stop();
 }
 
 void micExport_MICGetStatus(PPCInterpreter_t* hCPU)
@@ -360,6 +401,17 @@ void micExport_MICSetDataConsumed(PPCInterpreter_t* hCPU)
 	return;
 }
 
+void mic_updateDevicePlayState(bool isPlaying)
+{
+	if (g_inputAudio)
+	{
+		if (isPlaying)
+			g_inputAudio->Play();
+		else
+			g_inputAudio->Stop();
+	}
+}
+
 void mic_updateOnAXFrame()
 {
 	sint32 drcIndex = 0;
@@ -368,26 +420,39 @@ void mic_updateOnAXFrame()
 		drcIndex = 1;
 		if (mic_isActive(1) == false) 
 		{
+			std::shared_lock lock(g_audioInputMutex);
+			mic_updateDevicePlayState(false);
 			return;
 		}
 	}
 
-	const sint32 micSampleCount = 32000/32;
-	sint16 micSampleData[micSampleCount];
-
-	auto controller = InputManager::instance().get_vpad_controller(drcIndex);
-	if( controller && controller->is_mic_active() )
+	std::shared_lock lock(g_audioInputMutex);
+	mic_updateDevicePlayState(true);
+	if (g_inputAudio)
 	{
-		for(sint32 i=0; i<micSampleCount; i++)
-		{
-			micSampleData[i] = (sint16)(sin((float)GetTickCount()*0.1f+sin((float)GetTickCount()*0.0001f)*100.0f)*30000.0f);
-		}
+		sint16 micSampleData[MIC_SAMPLES_PER_3MS_32KHZ];
+		g_inputAudio->ConsumeBlock(micSampleData);
+		mic_feedSamples(0, micSampleData, MIC_SAMPLES_PER_3MS_32KHZ);
 	}
 	else
 	{
-		memset(micSampleData, 0x00, sizeof(micSampleData));
+		const sint32 micSampleCount = 32000 / 32;
+		sint16 micSampleData[micSampleCount];
+
+		auto controller = InputManager::instance().get_vpad_controller(drcIndex);
+		if( controller && controller->is_mic_active() )
+		{
+			for(sint32 i=0; i<micSampleCount; i++)
+			{
+				micSampleData[i] = (sint16)(sin((float)GetTickCount()*0.1f+sin((float)GetTickCount()*0.0001f)*100.0f)*30000.0f);
+			}
+		}
+		else
+		{
+			memset(micSampleData, 0x00, sizeof(micSampleData));
+		}
+		mic_feedSamples(0, micSampleData, micSampleCount);
 	}
-	mic_feedSamples(0, micSampleData, micSampleCount);
 }
 
 namespace mic
@@ -402,4 +467,4 @@ namespace mic
 		osLib_addFunction("mic", "MICSetState", micExport_MICSetState);
 		osLib_addFunction("mic", "MICSetDataConsumed", micExport_MICSetDataConsumed);
 	}
-};
\ No newline at end of file
+};
diff --git a/src/Cafe/OS/libs/nfc/TLV.cpp b/src/Cafe/OS/libs/nfc/TLV.cpp
new file mode 100644
index 00000000..2650858d
--- /dev/null
+++ b/src/Cafe/OS/libs/nfc/TLV.cpp
@@ -0,0 +1,139 @@
+#include "TLV.h"
+#include "stream.h"
+
+#include <cassert>
+
+TLV::TLV()
+{
+}
+
+TLV::TLV(Tag tag, std::vector<std::byte> value)
+ : mTag(tag), mValue(std::move(value))
+{
+}
+
+TLV::~TLV()
+{
+}
+
+std::vector<TLV> TLV::FromBytes(const std::span<std::byte>& data)
+{
+	bool hasTerminator = false;
+	std::vector<TLV> tlvs;
+	SpanStream stream(data, std::endian::big);
+
+	while (stream.GetRemaining() > 0 && !hasTerminator)
+	{
+		// Read the tag
+		uint8 byte;
+		stream >> byte;
+		Tag tag = static_cast<Tag>(byte);
+
+		switch (tag)
+		{
+			case TLV::TAG_NULL:
+				// Don't need to do anything for NULL tags
+				break;
+			
+			case TLV::TAG_TERMINATOR:
+				tlvs.emplace_back(tag, std::vector<std::byte>{});
+				hasTerminator = true;
+				break;
+
+			default:
+			{
+				// Read the length
+				uint16 length;
+				stream >> byte;
+				length = byte;
+
+				// If the length is 0xff, 2 bytes with length follow
+				if (length == 0xff) {
+					stream >> length;
+				}
+
+				std::vector<std::byte> value;
+				value.resize(length);
+				stream.Read(value);
+
+				tlvs.emplace_back(tag, value);
+				break;
+			}
+		}
+
+		if (stream.GetError() != Stream::ERROR_OK)
+		{
+			cemuLog_log(LogType::Force, "Error: TLV parsing read past end of stream");
+			// Clear tlvs to prevent further havoc while parsing ndef data
+			tlvs.clear();
+			break;
+		}
+	}
+
+	// This seems to be okay, at least NTAGs don't add a terminator tag
+	// if (!hasTerminator)
+	// {
+	//     cemuLog_log(LogType::Force, "Warning: TLV parsing reached end of stream without terminator tag");
+	// }
+
+	return tlvs;
+}
+
+std::vector<std::byte> TLV::ToBytes() const
+{
+	std::vector<std::byte> bytes;
+	VectorStream stream(bytes, std::endian::big);
+
+	// Write tag
+	stream << uint8(mTag);
+
+	switch (mTag)
+	{
+		case TLV::TAG_NULL:
+		case TLV::TAG_TERMINATOR:
+			// Nothing to do here
+			break;
+
+		default:
+		{
+			// Write length (decide if as a 8-bit or 16-bit value)
+			if (mValue.size() >= 0xff)
+			{
+				stream << uint8(0xff);
+				stream << uint16(mValue.size());
+			}
+			else
+			{
+				stream << uint8(mValue.size());
+			}
+
+			// Write value
+			stream.Write(mValue);
+		}
+	}
+
+	return bytes;
+}
+
+TLV::Tag TLV::GetTag() const
+{
+	return mTag;
+}
+
+const std::vector<std::byte>& TLV::GetValue() const
+{
+	return mValue;
+}
+
+void TLV::SetTag(Tag tag)
+{
+	mTag = tag;
+}
+
+void TLV::SetValue(const std::span<const std::byte>& value)
+{
+	// Can only write max 16-bit lengths into TLV
+	cemu_assert(value.size() < 0x10000);
+
+	mValue.assign(value.begin(), value.end());
+}
diff --git a/src/Cafe/OS/libs/nfc/TLV.h b/src/Cafe/OS/libs/nfc/TLV.h
new file mode 100644
index 00000000..f582128f
--- /dev/null
+++ b/src/Cafe/OS/libs/nfc/TLV.h
@@ -0,0 +1,37 @@
+#pragma once
+
+#include <cstdint>
+#include <span>
+#include <vector>
+
+class TLV
+{
+public:
+	enum Tag
+	{
+		TAG_NULL        = 0x00,
+		TAG_LOCK_CTRL   = 0x01,
+		TAG_MEM_CTRL    = 0x02,
+		TAG_NDEF        = 0x03,
+		TAG_PROPRIETARY = 0xFD,
+		TAG_TERMINATOR  = 0xFE,
+	};
+
+public:
+	TLV();
+	TLV(Tag tag, std::vector<std::byte> value);
+	virtual ~TLV();
+
+	static std::vector<TLV> FromBytes(const std::span<std::byte>& data);
+	std::vector<std::byte> ToBytes() const;
+
+	Tag GetTag() const;
+	const std::vector<std::byte>& GetValue() const;
+
+	void SetTag(Tag tag);
+	void SetValue(const std::span<const std::byte>& value);
+
+private:
+	Tag mTag;
+	std::vector<std::byte> mValue;
+};
diff --git a/src/Cafe/OS/libs/nfc/TagV0.cpp b/src/Cafe/OS/libs/nfc/TagV0.cpp
new file mode 100644
index 00000000..41b5c7a0
--- /dev/null
+++ b/src/Cafe/OS/libs/nfc/TagV0.cpp
@@ -0,0 +1,301 @@
+#include "TagV0.h"
+#include "TLV.h"
+
+#include <algorithm>
+
+namespace
+{
+
+constexpr std::size_t kTagSize = 512u;
+constexpr std::size_t kMaxBlockCount = kTagSize / sizeof(TagV0::Block);
+
+constexpr uint8 kLockbyteBlock0 = 0xe;
+constexpr uint8 kLockbytesStart0 = 0x0;
+constexpr uint8 kLockbytesEnd0 = 0x2;
+constexpr uint8 kLockbyteBlock1 = 0xf;
+constexpr uint8 kLockbytesStart1 = 0x2;
+constexpr uint8 kLockbytesEnd1 = 0x8;
+
+constexpr uint8 kNDEFMagicNumber = 0xe1;
+
+// These blocks are not part of the locked area
+constexpr bool IsBlockLockedOrReserved(uint8 blockIdx)
+{
+	// Block 0 is the UID
+	if (blockIdx == 0x0)
+	{
+		return true;
+	}
+
+	// Block 0xd is reserved
+	if (blockIdx == 0xd)
+	{
+		return true;
+	}
+
+	// Block 0xe and 0xf contains lock / reserved bytes
+	if (blockIdx == 0xe || blockIdx == 0xf)
+	{
+		return true;
+	}
+
+	return false;
+}
+
+} // namespace
+
+TagV0::TagV0()
+{
+}
+
+TagV0::~TagV0()
+{
+}
+
+std::shared_ptr<TagV0> TagV0::FromBytes(const std::span<const std::byte>& data)
+{
+	// Version 0 tags need at least 512 bytes
+	if (data.size() != kTagSize)
+	{
+		cemuLog_log(LogType::Force, "Error: Version 0 tags should be {} bytes in size", kTagSize);
+		return {};
+	}
+
+	std::shared_ptr<TagV0> tag = std::make_shared<TagV0>();
+
+	// Parse the locked area before continuing
+	if (!tag->ParseLockedArea(data))
+	{
+		cemuLog_log(LogType::Force, "Error: Failed to parse locked area");
+		return {};
+	}
+
+	// Now that the locked area is known, parse the data area
+	std::vector<std::byte> dataArea;
+	if (!tag->ParseDataArea(data, dataArea))
+	{
+		cemuLog_log(LogType::Force, "Error: Failed to parse data area");
+		return {};
+	}
+
+	// The first few bytes in the dataArea make up the capability container
+	std::copy_n(dataArea.begin(), tag->mCapabilityContainer.size(), std::as_writable_bytes(std::span(tag->mCapabilityContainer)).begin());
+	if (!tag->ValidateCapabilityContainer())
+	{
+		cemuLog_log(LogType::Force, "Error: Failed to validate capability container");
+		return {};
+	}
+
+	// The rest of the dataArea contains the TLVs
+	tag->mTLVs = TLV::FromBytes(std::span(dataArea).subspan(tag->mCapabilityContainer.size()));
+	if (tag->mTLVs.empty())
+	{
+		cemuLog_log(LogType::Force, "Error: Tag contains no TLVs");
+		return {};
+	}
+
+	// Look for the NDEF tlv
+	tag->mNdefTlvIdx = static_cast<size_t>(-1);
+	for (std::size_t i = 0; i < tag->mTLVs.size(); i++)
+	{
+		if (tag->mTLVs[i].GetTag() == TLV::TAG_NDEF)
+		{
+			tag->mNdefTlvIdx = i;
+			break;
+		}
+	}
+
+	if (tag->mNdefTlvIdx == static_cast<size_t>(-1))
+	{
+		cemuLog_log(LogType::Force, "Error: Tag contains no NDEF TLV");
+		return {};
+	}
+
+	// Append locked data
+	for (const auto& [key, value] : tag->mLockedBlocks)
+	{
+		tag->mLockedArea.insert(tag->mLockedArea.end(), value.begin(), value.end());
+	}
+
+	return tag;
+}
+
+std::vector<std::byte> TagV0::ToBytes() const
+{
+	std::vector<std::byte> bytes(kTagSize);
+
+	// Insert locked or reserved blocks
+	for (const auto& [key, value] : mLockedOrReservedBlocks)
+	{
+		std::copy(value.begin(), value.end(), bytes.begin() + key * sizeof(Block));
+	}
+
+	// Insert locked area
+	auto lockedDataIterator = mLockedArea.begin();
+	for (const auto& [key, value] : mLockedBlocks)
+	{
+		std::copy_n(lockedDataIterator, sizeof(Block), bytes.begin() + key * sizeof(Block));
+		lockedDataIterator += sizeof(Block);
+	}
+
+	// Pack the dataArea into a linear buffer
+	std::vector<std::byte> dataArea;
+	const auto ccBytes = std::as_bytes(std::span(mCapabilityContainer));
+	dataArea.insert(dataArea.end(), ccBytes.begin(), ccBytes.end());
+	for (const TLV& tlv : mTLVs)
+	{
+		const auto tlvBytes = tlv.ToBytes();
+		dataArea.insert(dataArea.end(), tlvBytes.begin(), tlvBytes.end());
+	}
+
+	// Make sure the dataArea is block size aligned
+	dataArea.resize((dataArea.size() + (sizeof(Block)-1)) & ~(sizeof(Block)-1));
+
+	// The rest will be the data area
+	auto dataIterator = dataArea.begin();
+	for (uint8 currentBlock = 0; currentBlock < kMaxBlockCount; currentBlock++)
+	{
+		// All blocks which aren't locked make up the dataArea
+		if (!IsBlockLocked(currentBlock))
+		{
+			std::copy_n(dataIterator, sizeof(Block), bytes.begin() + currentBlock * sizeof(Block));
+			dataIterator += sizeof(Block);
+		}
+	}
+
+	return bytes;
+}
+
+const TagV0::Block& TagV0::GetUIDBlock() const
+{
+	return mLockedOrReservedBlocks.at(0);
+}
+
+const std::vector<std::byte>& TagV0::GetNDEFData() const
+{
+	return mTLVs[mNdefTlvIdx].GetValue();
+}
+
+const std::vector<std::byte>& TagV0::GetLockedArea() const
+{
+	return mLockedArea;
+}
+
+void TagV0::SetNDEFData(const std::span<const std::byte>& data)
+{
+	// Update the ndef value
+	mTLVs[mNdefTlvIdx].SetValue(data);
+}
+
+bool TagV0::ParseLockedArea(const std::span<const std::byte>& data)
+{
+	uint8 currentBlock = 0;
+
+	// Start by parsing the first set of lock bytes
+	for (uint8 i = kLockbytesStart0; i < kLockbytesEnd0; i++)
+	{
+		uint8 lockByte = uint8(data[kLockbyteBlock0 * sizeof(Block) + i]);
+
+		// Iterate over the individual bits in the lock byte
+		for (uint8 j = 0; j < 8; j++)
+		{
+			// Is block locked?
+			if (lockByte & (1u << j))
+			{
+				Block blk;
+				std::copy_n(data.begin() + currentBlock * sizeof(Block), sizeof(Block), blk.begin());
+
+				// The lock bytes themselves are not part of the locked area
+				if (!IsBlockLockedOrReserved(currentBlock))
+				{
+					mLockedBlocks.emplace(currentBlock, blk);
+				}
+				else
+				{
+					mLockedOrReservedBlocks.emplace(currentBlock, blk);
+				}
+			}
+
+			currentBlock++;
+		}
+	}
+
+	// Parse the second set of lock bytes
+	for (uint8 i = kLockbytesStart1; i < kLockbytesEnd1; i++) {
+		uint8 lockByte = uint8(data[kLockbyteBlock1 * sizeof(Block) + i]);
+
+		// Iterate over the individual bits in the lock byte
+		for (uint8 j = 0; j < 8; j++)
+		{
+			// Is block locked?
+			if (lockByte & (1u << j))
+			{
+				Block blk;
+				std::copy_n(data.begin() + currentBlock * sizeof(Block), sizeof(Block), blk.begin());
+
+				// The lock bytes themselves are not part of the locked area
+				if (!IsBlockLockedOrReserved(currentBlock))
+				{
+					mLockedBlocks.emplace(currentBlock, blk);
+				}
+				else
+				{
+					mLockedOrReservedBlocks.emplace(currentBlock, blk);
+				}
+			}
+
+			currentBlock++;
+		}
+	}
+
+	return true;
+}
+
+bool TagV0::IsBlockLocked(uint8 blockIdx) const
+{
+	return mLockedBlocks.contains(blockIdx) || IsBlockLockedOrReserved(blockIdx);
+}
+
+bool TagV0::ParseDataArea(const std::span<const std::byte>& data, std::vector<std::byte>& dataArea)
+{
+	for (uint8 currentBlock = 0; currentBlock < kMaxBlockCount; currentBlock++)
+	{
+		// All blocks which aren't locked make up the dataArea
+		if (!IsBlockLocked(currentBlock))
+		{
+			auto blockOffset = data.begin() + sizeof(Block) * currentBlock;
+			dataArea.insert(dataArea.end(), blockOffset, blockOffset + sizeof(Block));
+		}
+	}
+
+	return true;
+}
+
+bool TagV0::ValidateCapabilityContainer()
+{
+	// NDEF Magic Number
+	uint8 nmn = mCapabilityContainer[0];
+	if (nmn != kNDEFMagicNumber)
+	{
+		cemuLog_log(LogType::Force, "Error: CC: Invalid NDEF Magic Number");
+		return false;
+	}
+
+	// Version Number
+	uint8 vno = mCapabilityContainer[1];
+	if (vno >> 4 != 1)
+	{
+		cemuLog_log(LogType::Force, "Error: CC: Invalid Version Number");
+		return false;
+	}
+
+	// Tag memory size
+	uint8 tms = mCapabilityContainer[2];
+	if (8u * (tms + 1) < kTagSize)
+	{
+		cemuLog_log(LogType::Force, "Error: CC: Incomplete tag memory size");
+		return false;
+	}
+
+	return true;
+}
diff --git a/src/Cafe/OS/libs/nfc/TagV0.h b/src/Cafe/OS/libs/nfc/TagV0.h
new file mode 100644
index 00000000..72c321b6
--- /dev/null
+++ b/src/Cafe/OS/libs/nfc/TagV0.h
@@ -0,0 +1,39 @@
+#pragma once
+
+#include <memory>
+#include <span>
+#include <map>
+
+#include "TLV.h"
+
+class TagV0
+{
+public:
+	using Block = std::array<std::byte, 0x8>;
+
+public:
+	TagV0();
+	virtual ~TagV0();
+
+	static std::shared_ptr<TagV0> FromBytes(const std::span<const std::byte>& data);
+	std::vector<std::byte> ToBytes() const;
+
+	const Block& GetUIDBlock() const;
+	const std::vector<std::byte>& GetNDEFData() const;
+	const std::vector<std::byte>& GetLockedArea() const;
+
+	void SetNDEFData(const std::span<const std::byte>& data);
+
+private:
+	bool ParseLockedArea(const std::span<const std::byte>& data);
+	bool IsBlockLocked(uint8 blockIdx) const;
+	bool ParseDataArea(const std::span<const std::byte>& data, std::vector<std::byte>& dataArea);
+	bool ValidateCapabilityContainer();
+
+	std::map<uint8, Block> mLockedOrReservedBlocks;
+	std::map<uint8, Block> mLockedBlocks;
+	std::array<uint8, 0x4> mCapabilityContainer;
+	std::vector<TLV> mTLVs;
+	std::size_t mNdefTlvIdx;
+	std::vector<std::byte> mLockedArea;
+};
diff --git a/src/Cafe/OS/libs/nfc/ndef.cpp b/src/Cafe/OS/libs/nfc/ndef.cpp
new file mode 100644
index 00000000..60be5811
--- /dev/null
+++ b/src/Cafe/OS/libs/nfc/ndef.cpp
@@ -0,0 +1,278 @@
+#include "ndef.h"
+
+#include <cassert>
+
+namespace ndef
+{
+
+	Record::Record()
+	 : mFlags(0), mTNF(NDEF_TNF_EMPTY)
+	{
+	}
+
+	Record::~Record()
+	{
+	}
+
+	std::optional<Record> Record::FromStream(Stream& stream)
+	{
+		Record rec;
+
+		// Read record header
+		uint8 recHdr;
+		stream >> recHdr;
+		rec.mFlags = recHdr & ~NDEF_TNF_MASK;
+		rec.mTNF = static_cast<TypeNameFormat>(recHdr & NDEF_TNF_MASK);
+
+		// Type length
+		uint8 typeLen;
+		stream >> typeLen;
+
+		// Payload length;
+		uint32 payloadLen;
+		if (recHdr & NDEF_SR)
+		{
+			uint8 len;
+			stream >> len;
+			payloadLen = len;
+		}
+		else
+		{
+			stream >> payloadLen;
+		}
+
+		// Some sane limits for the payload size
+		if (payloadLen > 2 * 1024 * 1024)
+		{
+			return {};
+		}
+
+		// ID length
+		uint8 idLen = 0;
+		if (recHdr & NDEF_IL)
+		{
+			stream >> idLen;
+		}
+
+		// Make sure we didn't read past the end of the stream yet
+		if (stream.GetError() != Stream::ERROR_OK)
+		{
+			return {};
+		}
+
+		// Type
+		rec.mType.resize(typeLen);
+		stream.Read(rec.mType);
+
+		// ID
+		rec.mID.resize(idLen);
+		stream.Read(rec.mID);
+
+		// Payload
+		rec.mPayload.resize(payloadLen);
+		stream.Read(rec.mPayload);
+
+		// Make sure we didn't read past the end of the stream again
+		if (stream.GetError() != Stream::ERROR_OK)
+		{
+			return {};
+		}
+
+		return rec;
+	}
+
+	std::vector<std::byte> Record::ToBytes(uint8 flags) const
+	{
+		std::vector<std::byte> bytes;
+		VectorStream stream(bytes, std::endian::big);
+
+		// Combine flags (clear message begin and end flags)
+		uint8 finalFlags = mFlags & ~(NDEF_MB | NDEF_ME);
+		finalFlags |= flags;
+
+		// Write flags + tnf
+		stream << uint8(finalFlags | uint8(mTNF));
+
+		// Type length
+		stream << uint8(mType.size());
+
+		// Payload length
+		if (IsShort())
+		{
+			stream << uint8(mPayload.size());
+		}
+		else
+		{
+			stream << uint32(mPayload.size());
+		}
+
+		// ID length
+		if (mFlags & NDEF_IL)
+		{
+			stream << uint8(mID.size());
+		}
+
+		// Type
+		stream.Write(mType);
+
+		// ID
+		stream.Write(mID);
+
+		// Payload
+		stream.Write(mPayload);
+
+		return bytes;
+	}
+
+	Record::TypeNameFormat Record::GetTNF() const
+	{
+		return mTNF;
+	}
+
+	const std::vector<std::byte>& Record::GetID() const
+	{
+		return mID;
+	}
+
+	const std::vector<std::byte>& Record::GetType() const
+	{
+		return mType;
+	}
+
+	const std::vector<std::byte>& Record::GetPayload() const
+	{
+		return mPayload;
+	}
+
+	void Record::SetTNF(TypeNameFormat tnf)
+	{
+		mTNF = tnf;
+	}
+
+	void Record::SetID(const std::span<const std::byte>& id)
+	{
+		cemu_assert(id.size() < 0x100);
+
+		if (id.size() > 0)
+		{
+			mFlags |= NDEF_IL;
+		}
+		else
+		{
+			mFlags &= ~NDEF_IL;
+		}
+
+		mID.assign(id.begin(), id.end());
+	}
+
+	void Record::SetType(const std::span<const std::byte>& type)
+	{
+		cemu_assert(type.size() < 0x100);
+
+		mType.assign(type.begin(), type.end());
+	}
+
+	void Record::SetPayload(const std::span<const std::byte>& payload)
+	{
+		// Update short record flag
+		if (payload.size() < 0xff)
+		{
+			mFlags |= NDEF_SR;
+		}
+		else
+		{
+			mFlags &= ~NDEF_SR;
+		}
+
+		mPayload.assign(payload.begin(), payload.end());
+	}
+
+	bool Record::IsLast() const
+	{
+		return mFlags & NDEF_ME;
+	}
+
+	bool Record::IsShort() const
+	{
+		return mFlags & NDEF_SR;
+	}
+
+	Message::Message()
+	{
+	}
+
+	Message::~Message()
+	{
+	}
+
+	std::optional<Message> Message::FromBytes(const std::span<const std::byte>& data)
+	{
+		Message msg;
+		SpanStream stream(data, std::endian::big);
+
+		while (stream.GetRemaining() > 0)
+		{
+			std::optional<Record> rec = Record::FromStream(stream);
+			if (!rec)
+			{
+				cemuLog_log(LogType::Force, "Warning: Failed to parse NDEF Record #{}."
+							"Ignoring the remaining {} bytes in NDEF message", msg.mRecords.size(), stream.GetRemaining());
+				break;
+			}
+
+			msg.mRecords.emplace_back(*rec);
+
+			if ((*rec).IsLast() && stream.GetRemaining() > 0)
+			{
+				cemuLog_log(LogType::Force, "Warning: Ignoring {} bytes in NDEF message", stream.GetRemaining());
+				break;
+			}
+		}
+
+		if (msg.mRecords.empty())
+		{
+			return {};
+		}
+
+		if (!msg.mRecords.back().IsLast())
+		{
+			cemuLog_log(LogType::Force, "Error: NDEF message missing end record");
+			return {}; 
+		}
+
+		return msg;
+	}
+
+	std::vector<std::byte> Message::ToBytes() const
+	{
+		std::vector<std::byte> bytes;
+
+		for (std::size_t i = 0; i < mRecords.size(); i++)
+		{
+			uint8 flags = 0;
+
+			// Add message begin flag to first record
+			if (i == 0)
+			{
+				flags |= Record::NDEF_MB;
+			}
+
+			// Add message end flag to last record
+			if (i == mRecords.size() - 1)
+			{
+				flags |= Record::NDEF_ME;
+			}
+
+			std::vector<std::byte> recordBytes = mRecords[i].ToBytes(flags);
+			bytes.insert(bytes.end(), recordBytes.begin(), recordBytes.end());
+		}
+
+		return bytes;
+	}
+
+	void Message::append(const Record& r)
+	{
+		mRecords.push_back(r);
+	}
+
+} // namespace ndef
diff --git a/src/Cafe/OS/libs/nfc/ndef.h b/src/Cafe/OS/libs/nfc/ndef.h
new file mode 100644
index 00000000..398feb54
--- /dev/null
+++ b/src/Cafe/OS/libs/nfc/ndef.h
@@ -0,0 +1,88 @@
+#pragma once
+
+#include <span>
+#include <vector>
+#include <optional>
+
+#include "stream.h"
+
+namespace ndef
+{
+
+	class Record
+	{
+	public:
+		enum HeaderFlag
+		{
+			NDEF_IL         = 0x08,
+			NDEF_SR         = 0x10,
+			NDEF_CF         = 0x20,
+			NDEF_ME         = 0x40,
+			NDEF_MB         = 0x80,
+			NDEF_TNF_MASK   = 0x07,
+		};
+
+		enum TypeNameFormat
+		{
+			NDEF_TNF_EMPTY      = 0,
+			NDEF_TNF_WKT        = 1,
+			NDEF_TNF_MEDIA      = 2,
+			NDEF_TNF_URI        = 3,
+			NDEF_TNF_EXT        = 4,
+			NDEF_TNF_UNKNOWN    = 5,
+			NDEF_TNF_UNCHANGED  = 6,
+			NDEF_TNF_RESERVED   = 7,
+		};
+
+	public:
+		Record();
+		virtual ~Record();
+
+		static std::optional<Record> FromStream(Stream& stream);
+		std::vector<std::byte> ToBytes(uint8 flags = 0) const;
+
+		TypeNameFormat GetTNF() const;
+		const std::vector<std::byte>& GetID() const;
+		const std::vector<std::byte>& GetType() const;
+		const std::vector<std::byte>& GetPayload() const;
+
+		void SetTNF(TypeNameFormat tnf);
+		void SetID(const std::span<const std::byte>& id);
+		void SetType(const std::span<const std::byte>& type);
+		void SetPayload(const std::span<const std::byte>& payload);
+
+		bool IsLast() const;
+		bool IsShort() const;
+
+	private:
+		uint8 mFlags;
+		TypeNameFormat mTNF;
+		std::vector<std::byte> mID;
+		std::vector<std::byte> mType;
+		std::vector<std::byte> mPayload;
+	};
+
+	class Message
+	{
+	public:
+		Message();
+		virtual ~Message();
+
+		static std::optional<Message> FromBytes(const std::span<const std::byte>& data);
+		std::vector<std::byte> ToBytes() const;
+
+		Record& operator[](int i) { return mRecords[i]; }
+		const Record& operator[](int i) const { return mRecords[i]; }
+
+		void append(const Record& r);
+
+		auto begin() { return mRecords.begin(); }
+		auto end() { return mRecords.end(); }
+		auto begin() const { return mRecords.begin(); }
+		auto end() const { return mRecords.end(); }
+
+	private:
+		std::vector<Record> mRecords;
+	};
+
+} // namespace ndef
diff --git a/src/Cafe/OS/libs/nfc/nfc.cpp b/src/Cafe/OS/libs/nfc/nfc.cpp
new file mode 100644
index 00000000..fcb1d8d0
--- /dev/null
+++ b/src/Cafe/OS/libs/nfc/nfc.cpp
@@ -0,0 +1,690 @@
+#include "Cafe/OS/common/OSCommon.h"
+#include "Cafe/OS/RPL/rpl.h"
+#include "Cafe/OS/libs/nfc/nfc.h"
+#include "Cafe/OS/libs/nn_nfp/nn_nfp.h"
+#include "Common/FileStream.h"
+
+#include "TagV0.h"
+#include "ndef.h"
+
+#define NFC_MODE_INVALID	-1
+#define NFC_MODE_IDLE		0
+#define NFC_MODE_ACTIVE		1
+
+#define NFC_STATE_UNINITIALIZED		0x0
+#define NFC_STATE_INITIALIZED		0x1
+#define NFC_STATE_IDLE			0x2
+#define NFC_STATE_READ			0x3
+#define NFC_STATE_WRITE			0x4
+#define NFC_STATE_ABORT			0x5
+#define NFC_STATE_FORMAT		0x6
+#define NFC_STATE_SET_READ_ONLY		0x7
+#define NFC_STATE_TAG_PRESENT		0x8
+#define NFC_STATE_DETECT		0x9
+#define NFC_STATE_SEND_RAW_DATA		0xA
+
+#define NFC_STATUS_COMMAND_COMPLETE	0x1
+#define NFC_STATUS_READY		0x2
+#define NFC_STATUS_HAS_TAG		0x4
+
+namespace nfc
+{
+	struct NFCContext
+	{
+		bool isInitialized;
+		uint32 state;
+		sint32 mode;
+		bool hasTag;
+
+		uint32 nfcStatus;
+		std::chrono::time_point<std::chrono::system_clock> touchTime;
+		std::chrono::time_point<std::chrono::system_clock> discoveryTimeout;
+		struct {
+			NFCUid uid;
+			NFCUid mask;
+		} filter;
+
+		MPTR tagDetectCallback;
+		void* tagDetectContext;
+		MPTR abortCallback;
+		void* abortContext;
+		MPTR rawCallback;
+		void* rawContext;
+		MPTR readCallback;
+		void* readContext;
+		MPTR writeCallback;
+		void* writeContext;
+		MPTR getTagInfoCallback;
+
+		SysAllocator<NFCTagInfo> tagInfo;
+
+		fs::path tagPath;
+		std::shared_ptr<TagV0> tag;
+
+		ndef::Message writeMessage;
+	};
+	NFCContext gNFCContexts[2];
+
+	sint32 NFCInit(uint32 chan)
+	{
+		return NFCInitEx(chan, 0);
+	}
+
+	void __NFCClearContext(NFCContext* context)
+	{
+		context->isInitialized = false;
+		context->state = NFC_STATE_UNINITIALIZED;
+		context->mode = NFC_MODE_IDLE;
+		context->hasTag = false;
+
+		context->nfcStatus = NFC_STATUS_READY;
+		context->discoveryTimeout = {};
+
+		context->tagDetectCallback = MPTR_NULL;
+		context->tagDetectContext = nullptr;
+		context->abortCallback = MPTR_NULL;
+		context->abortContext = nullptr;
+		context->rawCallback = MPTR_NULL;
+		context->rawContext = nullptr;
+		context->readCallback = MPTR_NULL;
+		context->readContext = nullptr;
+		context->writeCallback = MPTR_NULL;
+		context->writeContext = nullptr;
+
+		context->tagPath = "";
+		context->tag = {};
+	}
+
+	sint32 NFCInitEx(uint32 chan, uint32 powerMode)
+	{
+		cemu_assert(chan < 2);
+
+		NFCContext* ctx = &gNFCContexts[chan];
+
+		__NFCClearContext(ctx);
+		ctx->isInitialized = true;
+		ctx->state = NFC_STATE_INITIALIZED;
+
+		return NFC_RESULT_SUCCESS;
+	}
+
+	sint32 NFCShutdown(uint32 chan)
+	{
+		cemu_assert(chan < 2);
+
+		NFCContext* ctx = &gNFCContexts[chan];
+
+		__NFCClearContext(ctx);
+
+		return NFC_RESULT_SUCCESS;
+	}
+
+	bool NFCIsInit(uint32 chan)
+	{
+		cemu_assert(chan < 2);
+
+		return gNFCContexts[chan].isInitialized;
+	}
+
+	bool __NFCCompareUid(NFCUid* uid, NFCUid* filterUid, NFCUid* filterMask)
+	{
+		for (int i = 0; i < sizeof(uid->uid); i++)
+		{
+			if ((uid->uid[i] & filterMask->uid[i]) != filterUid->uid[i])
+			{
+				return false;
+			}
+		}
+
+		return true;
+	}
+
+	void __NFCHandleRead(uint32 chan)
+	{
+		NFCContext* ctx = &gNFCContexts[chan];
+
+		ctx->state = NFC_STATE_IDLE;
+
+		sint32 result;
+		StackAllocator<NFCUid> uid;
+		bool readOnly = false;
+		uint32 dataSize = 0;
+		StackAllocator<uint8, 0x200> data;
+		uint32 lockedDataSize = 0;
+		StackAllocator<uint8, 0x200> lockedData;
+
+		if (ctx->tag)
+		{
+			// Compare UID
+			memcpy(uid.GetPointer(), ctx->tag->GetUIDBlock().data(), sizeof(NFCUid));
+			if (__NFCCompareUid(uid.GetPointer(), &ctx->filter.uid, &ctx->filter.mask))
+			{
+				// Try to parse ndef message
+				auto ndefMsg = ndef::Message::FromBytes(ctx->tag->GetNDEFData());
+				if (ndefMsg)
+				{
+					// Look for the unknown TNF which contains the data we care about
+					for (const auto& rec : *ndefMsg)
+					{
+						if (rec.GetTNF() == ndef::Record::NDEF_TNF_UNKNOWN)
+						{
+							dataSize = rec.GetPayload().size();
+							cemu_assert(dataSize < 0x200);
+							memcpy(data.GetPointer(), rec.GetPayload().data(), dataSize);
+							break;
+						}
+					}
+
+					if (dataSize)
+					{
+						// Get locked data
+						lockedDataSize = ctx->tag->GetLockedArea().size();
+						memcpy(lockedData.GetPointer(), ctx->tag->GetLockedArea().data(), lockedDataSize);
+
+						result = NFC_RESULT_SUCCESS;
+					}
+					else
+					{
+						result = NFC_MAKE_RESULT(NFC_RESULT_BASE_TAG_PARSE, NFC_RESULT_INVALID_TAG);
+					}
+				}
+				else
+				{
+					result = NFC_MAKE_RESULT(NFC_RESULT_BASE_TAG_PARSE, NFC_RESULT_INVALID_TAG);
+				}
+			}
+			else
+			{
+				result = NFC_MAKE_RESULT(NFC_RESULT_BASE_READ, NFC_RESULT_UID_MISMATCH);
+			}
+		}
+		else
+		{
+			result = NFC_MAKE_RESULT(NFC_RESULT_BASE_READ, NFC_RESULT_NO_TAG);
+		}
+
+		PPCCoreCallback(ctx->readCallback, chan, result, uid.GetPointer(), readOnly, dataSize, data.GetPointer(), lockedDataSize, lockedData.GetPointer(), ctx->readContext);
+	}
+
+	void __NFCHandleWrite(uint32 chan)
+	{
+		NFCContext* ctx = &gNFCContexts[chan];
+
+		ctx->state = NFC_STATE_IDLE;
+
+		sint32 result;
+
+		if (ctx->tag)
+		{
+			NFCUid uid;
+			memcpy(&uid, ctx->tag->GetUIDBlock().data(), sizeof(NFCUid));
+			if (__NFCCompareUid(&uid, &ctx->filter.uid, &ctx->filter.mask))
+			{
+				// Update tag NDEF data
+				ctx->tag->SetNDEFData(ctx->writeMessage.ToBytes());
+
+				// open file for writing
+				FileStream* fs = FileStream::openFile2(ctx->tagPath, true);
+				if (!fs)
+				{
+					result = NFC_MAKE_RESULT(NFC_RESULT_BASE_WRITE, 0x22);
+				}
+				else
+				{
+					auto tagBytes = ctx->tag->ToBytes();
+					fs->writeData(tagBytes.data(), tagBytes.size());
+					delete fs;
+
+					result = NFC_RESULT_SUCCESS;
+				}
+			}
+			else
+			{
+				result = NFC_MAKE_RESULT(NFC_RESULT_BASE_WRITE, NFC_RESULT_UID_MISMATCH);
+			}
+		}
+		else
+		{
+			result = NFC_MAKE_RESULT(NFC_RESULT_BASE_WRITE, NFC_RESULT_NO_TAG);
+		}
+
+		PPCCoreCallback(ctx->writeCallback, chan, result, ctx->writeContext);
+	}
+
+	void __NFCHandleAbort(uint32 chan)
+	{
+		NFCContext* ctx = &gNFCContexts[chan];
+
+		ctx->state = NFC_STATE_IDLE;
+
+		PPCCoreCallback(ctx->abortCallback, chan, 0, ctx->abortContext);
+	}
+
+	void __NFCHandleRaw(uint32 chan)
+	{
+		NFCContext* ctx = &gNFCContexts[chan];
+
+		ctx->state = NFC_STATE_IDLE;
+
+		sint32 result;
+		if (ctx->nfcStatus & NFC_STATUS_HAS_TAG)
+		{
+			result = NFC_RESULT_SUCCESS;
+		}
+		else
+		{
+			result = NFC_MAKE_RESULT(NFC_RESULT_BASE_SEND_RAW_DATA, NFC_RESULT_NO_TAG);
+		}
+
+		// We don't actually send any commands/responses
+		uint32 responseSize = 0;
+		void* responseData = nullptr;
+
+		PPCCoreCallback(ctx->rawCallback, chan, result, responseSize, responseData, ctx->rawContext);
+	}
+
+	bool __NFCShouldHandleState(NFCContext* ctx)
+	{
+		// Always handle abort
+		if (ctx->state == NFC_STATE_ABORT)
+		{
+			return true;
+		}
+
+		// Do we have a tag?
+		if (ctx->nfcStatus & NFC_STATUS_HAS_TAG)
+		{
+			return true;
+		}
+
+		// Did the timeout expire?
+		if (ctx->discoveryTimeout < std::chrono::system_clock::now())
+		{
+			return true;
+		}
+
+		return false;
+	}
+
+	void NFCProc(uint32 chan)
+	{
+		cemu_assert(chan < 2);
+
+		NFCContext* ctx = &gNFCContexts[chan];
+
+		if (!ctx->isInitialized)
+		{
+			return;
+		}
+
+		if (ctx->state == NFC_STATE_INITIALIZED)
+		{
+			ctx->state = NFC_STATE_IDLE;
+		}
+
+		// Check if the detect callback should be called
+		if (ctx->nfcStatus & NFC_STATUS_HAS_TAG)
+		{
+			if (!ctx->hasTag && ctx->state > NFC_STATE_IDLE && ctx->state != NFC_STATE_ABORT)
+			{
+				if (ctx->tagDetectCallback)
+				{
+					PPCCoreCallback(ctx->tagDetectCallback, chan, true, ctx->tagDetectContext);
+				}
+
+				ctx->hasTag = true;
+			}
+
+			// Check if the tag should be removed again
+			if (ctx->touchTime + std::chrono::seconds(2) < std::chrono::system_clock::now())
+			{
+				ctx->nfcStatus &= ~NFC_STATUS_HAS_TAG;
+				ctx->tag = {};
+				ctx->tagPath = "";
+			}
+		}
+		else
+		{
+			if (ctx->hasTag && ctx->state == NFC_STATE_IDLE)
+			{
+				if (ctx->tagDetectCallback)
+				{
+					PPCCoreCallback(ctx->tagDetectCallback, chan, false, ctx->tagDetectContext);
+				}
+
+				ctx->hasTag = false;
+			}
+		}
+
+		if (__NFCShouldHandleState(ctx))
+		{
+			switch (ctx->state)
+			{
+			case NFC_STATE_READ:
+				__NFCHandleRead(chan);
+				break;
+			case NFC_STATE_WRITE:
+				__NFCHandleWrite(chan);
+				break;
+			case NFC_STATE_ABORT:
+				__NFCHandleAbort(chan);
+				break;
+			case NFC_STATE_SEND_RAW_DATA:
+				__NFCHandleRaw(chan);
+				break;
+			default:
+				break;
+			}
+
+			// Return back to idle mode
+			ctx->mode = NFC_MODE_IDLE;
+		}
+	}
+
+	sint32 NFCGetMode(uint32 chan)
+	{
+		cemu_assert(chan < 2);
+
+		NFCContext* ctx = &gNFCContexts[chan];
+
+		if (!NFCIsInit(chan) || ctx->state == NFC_STATE_UNINITIALIZED)
+		{
+			return NFC_MODE_INVALID;
+		}
+
+		return ctx->mode;
+	}
+
+	sint32 NFCSetMode(uint32 chan, sint32 mode)
+	{
+		cemu_assert(chan < 2);
+
+		NFCContext* ctx = &gNFCContexts[chan];
+
+		if (!NFCIsInit(chan))
+		{
+			return NFC_MAKE_RESULT(NFC_RESULT_BASE_SET_MODE, NFC_RESULT_UNINITIALIZED);
+		}
+
+		if (ctx->state == NFC_STATE_UNINITIALIZED)
+		{
+			return NFC_MAKE_RESULT(NFC_RESULT_BASE_SET_MODE, NFC_RESULT_INVALID_STATE);
+		}
+
+		ctx->mode = mode;
+
+		return NFC_RESULT_SUCCESS;
+	}
+
+	void NFCSetTagDetectCallback(uint32 chan, MPTR callback, void* context)
+	{
+		cemu_assert(chan < 2);
+
+		NFCContext* ctx = &gNFCContexts[chan];
+		ctx->tagDetectCallback = callback;
+		ctx->tagDetectContext = context;
+	}
+
+	sint32 NFCAbort(uint32 chan, MPTR callback, void* context)
+	{
+		cemu_assert(chan < 2);
+
+		NFCContext* ctx = &gNFCContexts[chan];
+
+		if (!NFCIsInit(chan))
+		{
+			return NFC_MAKE_RESULT(NFC_RESULT_BASE_ABORT, NFC_RESULT_UNINITIALIZED);
+		}
+
+		if (ctx->state <= NFC_STATE_IDLE)
+		{
+			return NFC_MAKE_RESULT(NFC_RESULT_BASE_ABORT, NFC_RESULT_INVALID_STATE);
+		}
+
+		ctx->state = NFC_STATE_ABORT;
+		ctx->abortCallback = callback;
+		ctx->abortContext = context;
+
+		return NFC_RESULT_SUCCESS;
+	}
+
+	sint32 __NFCConvertGetTagInfoResult(sint32 result)
+	{
+		if (result == NFC_MAKE_RESULT(NFC_RESULT_BASE_SEND_RAW_DATA, NFC_RESULT_NO_TAG))
+		{
+			return NFC_MAKE_RESULT(NFC_RESULT_BASE_GET_TAG_INFO, NFC_RESULT_TAG_INFO_TIMEOUT);
+		}
+
+		// TODO convert the rest of the results
+		return result;
+	}
+
+	void __NFCGetTagInfoCallback(PPCInterpreter_t* hCPU)
+	{
+		ppcDefineParamU32(chan, 0);
+		ppcDefineParamS32(error, 1);
+		ppcDefineParamU32(responseSize, 2);
+		ppcDefineParamPtr(responseData, void, 3);
+		ppcDefineParamPtr(context, void, 4);
+
+		NFCContext* ctx = &gNFCContexts[chan];
+
+		error = __NFCConvertGetTagInfoResult(error);
+		if (error == 0 && ctx->tag)
+		{
+			// this is usually parsed from response data
+			ctx->tagInfo->uidSize = sizeof(NFCUid);
+			memcpy(ctx->tagInfo->uid, ctx->tag->GetUIDBlock().data(), ctx->tagInfo->uidSize);
+			ctx->tagInfo->technology = NFC_TECHNOLOGY_A;
+			ctx->tagInfo->protocol = NFC_PROTOCOL_T1T;            
+		}
+
+		PPCCoreCallback(ctx->getTagInfoCallback, chan, error, ctx->tagInfo.GetPtr(), context);
+		osLib_returnFromFunction(hCPU, 0);
+	}
+
+	sint32 NFCGetTagInfo(uint32 chan, uint32 discoveryTimeout, MPTR callback, void* context)
+	{
+		cemu_assert(chan < 2);
+
+		// Forward this request to nn_nfp, if the title initialized it
+		// TODO integrate nn_nfp/ntag/nfc
+		if (nnNfp_isInitialized())
+		{
+			return nn::nfp::NFCGetTagInfo(chan, discoveryTimeout, callback, context);
+		}
+
+		NFCContext* ctx = &gNFCContexts[chan];
+
+		ctx->getTagInfoCallback = callback;
+
+		sint32 result = NFCSendRawData(chan, true, discoveryTimeout, 1000U, 0, 0, nullptr, RPLLoader_MakePPCCallable(__NFCGetTagInfoCallback), context);
+		return __NFCConvertGetTagInfoResult(result);
+	}
+
+	sint32 NFCSendRawData(uint32 chan, bool startDiscovery, uint32 discoveryTimeout, uint32 commandTimeout, uint32 commandSize, uint32 responseSize, void* commandData, MPTR callback, void* context)
+	{
+		cemu_assert(chan < 2);
+
+		NFCContext* ctx = &gNFCContexts[chan];
+
+		if (!NFCIsInit(chan))
+		{
+			return NFC_MAKE_RESULT(NFC_RESULT_BASE_SEND_RAW_DATA, NFC_RESULT_UNINITIALIZED);
+		}
+
+		// Only allow discovery
+		if (!startDiscovery)
+		{
+			return NFC_MAKE_RESULT(NFC_RESULT_BASE_SEND_RAW_DATA, NFC_RESULT_INVALID_MODE);
+		}
+
+		if (NFCGetMode(chan) == NFC_MODE_ACTIVE && NFCSetMode(chan, NFC_MODE_IDLE) < 0)
+		{
+			return NFC_MAKE_RESULT(NFC_RESULT_BASE_SEND_RAW_DATA, NFC_RESULT_INVALID_MODE);
+		}
+
+		if (ctx->state != NFC_STATE_IDLE)
+		{
+			return NFC_MAKE_RESULT(NFC_RESULT_BASE_SEND_RAW_DATA, NFC_RESULT_INVALID_STATE);
+		}
+
+		ctx->state = NFC_STATE_SEND_RAW_DATA;
+		ctx->rawCallback = callback;
+		ctx->rawContext = context;
+
+		// If the discoveryTimeout is 0, no timeout
+		if (discoveryTimeout == 0)
+		{
+			ctx->discoveryTimeout = std::chrono::time_point<std::chrono::system_clock>::max();
+		}
+		else
+		{
+			ctx->discoveryTimeout = std::chrono::system_clock::now() + std::chrono::milliseconds(discoveryTimeout);
+		}
+
+		return NFC_RESULT_SUCCESS;
+	}
+
+	sint32 NFCRead(uint32 chan, uint32 discoveryTimeout, NFCUid* uid, NFCUid* uidMask, MPTR callback, void* context)
+	{
+		cemu_assert(chan < 2);
+
+		NFCContext* ctx = &gNFCContexts[chan];
+
+		if (!NFCIsInit(chan))
+		{
+			return NFC_MAKE_RESULT(NFC_RESULT_BASE_READ, NFC_RESULT_UNINITIALIZED);
+		}
+
+		if (NFCGetMode(chan) == NFC_MODE_ACTIVE && NFCSetMode(chan, NFC_MODE_IDLE) < 0)
+		{
+			return NFC_MAKE_RESULT(NFC_RESULT_BASE_READ, NFC_RESULT_INVALID_MODE);
+		}
+
+		if (ctx->state != NFC_STATE_IDLE)
+		{
+			return NFC_MAKE_RESULT(NFC_RESULT_BASE_READ, NFC_RESULT_INVALID_STATE);
+		}
+
+		ctx->state = NFC_STATE_READ;
+		ctx->readCallback = callback;
+		ctx->readContext = context;
+
+		// If the discoveryTimeout is 0, no timeout
+		if (discoveryTimeout == 0)
+		{
+			ctx->discoveryTimeout = std::chrono::time_point<std::chrono::system_clock>::max();
+		}
+		else
+		{
+			ctx->discoveryTimeout = std::chrono::system_clock::now() + std::chrono::milliseconds(discoveryTimeout);
+		}
+
+		memcpy(&ctx->filter.uid, uid, sizeof(*uid));
+		memcpy(&ctx->filter.mask, uidMask, sizeof(*uidMask));
+
+		return NFC_RESULT_SUCCESS;
+	}
+
+	sint32 NFCWrite(uint32 chan, uint32 discoveryTimeout, NFCUid* uid, NFCUid* uidMask, uint32 size, void* data, MPTR callback, void* context)
+	{
+		cemu_assert(chan < 2);
+
+		NFCContext* ctx = &gNFCContexts[chan];
+
+		if (!NFCIsInit(chan))
+		{
+			return NFC_MAKE_RESULT(NFC_RESULT_BASE_WRITE, NFC_RESULT_UNINITIALIZED);
+		}
+
+		if (NFCGetMode(chan) == NFC_MODE_ACTIVE && NFCSetMode(chan, NFC_MODE_IDLE) < 0)
+		{
+			return NFC_MAKE_RESULT(NFC_RESULT_BASE_WRITE, NFC_RESULT_INVALID_MODE);
+		}
+
+		if (ctx->state != NFC_STATE_IDLE)
+		{
+			return NFC_MAKE_RESULT(NFC_RESULT_BASE_WRITE, NFC_RESULT_INVALID_STATE);
+		}
+
+		// Create unknown record which contains the rw area
+		ndef::Record rec;
+		rec.SetTNF(ndef::Record::NDEF_TNF_UNKNOWN);
+		rec.SetPayload(std::span(reinterpret_cast<std::byte*>(data), size));
+
+		// Create ndef message which contains the record
+		ndef::Message msg;
+		msg.append(rec);
+		ctx->writeMessage = msg; 
+
+		ctx->state = NFC_STATE_WRITE;
+		ctx->writeCallback = callback;
+		ctx->writeContext = context;
+
+		// If the discoveryTimeout is 0, no timeout
+		if (discoveryTimeout == 0)
+		{
+			ctx->discoveryTimeout = std::chrono::time_point<std::chrono::system_clock>::max();
+		}
+		else
+		{
+			ctx->discoveryTimeout = std::chrono::system_clock::now() + std::chrono::milliseconds(discoveryTimeout);
+		}
+
+		memcpy(&ctx->filter.uid, uid, sizeof(*uid));
+		memcpy(&ctx->filter.mask, uidMask, sizeof(*uidMask));
+
+		return NFC_RESULT_SUCCESS;
+	}
+
+	void Initialize()
+	{
+		cafeExportRegister("nfc", NFCInit, LogType::NFC);
+		cafeExportRegister("nfc", NFCInitEx, LogType::NFC);
+		cafeExportRegister("nfc", NFCShutdown, LogType::NFC);
+		cafeExportRegister("nfc", NFCIsInit, LogType::NFC);
+		cafeExportRegister("nfc", NFCProc, LogType::NFC);
+		cafeExportRegister("nfc", NFCGetMode, LogType::NFC);
+		cafeExportRegister("nfc", NFCSetMode, LogType::NFC);
+		cafeExportRegister("nfc", NFCSetTagDetectCallback, LogType::NFC);
+		cafeExportRegister("nfc", NFCGetTagInfo, LogType::NFC);
+		cafeExportRegister("nfc", NFCSendRawData, LogType::NFC);
+		cafeExportRegister("nfc", NFCAbort, LogType::NFC);
+		cafeExportRegister("nfc", NFCRead, LogType::NFC);
+		cafeExportRegister("nfc", NFCWrite, LogType::NFC);
+	}
+
+	bool TouchTagFromFile(const fs::path& filePath, uint32* nfcError)
+	{
+		// Forward this request to nn_nfp, if the title initialized it
+		// TODO integrate nn_nfp/ntag/nfc
+		if (nnNfp_isInitialized())
+		{
+			return nnNfp_touchNfcTagFromFile(filePath, nfcError);
+		}
+
+		NFCContext* ctx = &gNFCContexts[0];
+
+		auto nfcData = FileStream::LoadIntoMemory(filePath);
+		if (!nfcData)
+		{
+			*nfcError = NFC_TOUCH_TAG_ERROR_NO_ACCESS;
+			return false;
+		}
+
+		ctx->tag = TagV0::FromBytes(std::as_bytes(std::span(nfcData->data(), nfcData->size())));
+		if (!ctx->tag)
+		{
+			*nfcError = NFC_TOUCH_TAG_ERROR_INVALID_FILE_FORMAT;
+			return false;
+		}
+
+		ctx->nfcStatus |= NFC_STATUS_HAS_TAG;
+		ctx->tagPath = filePath;
+		ctx->touchTime = std::chrono::system_clock::now();
+
+		*nfcError = NFC_TOUCH_TAG_ERROR_NONE;
+		return true;
+	}
+}
diff --git a/src/Cafe/OS/libs/nfc/nfc.h b/src/Cafe/OS/libs/nfc/nfc.h
new file mode 100644
index 00000000..ea959cd1
--- /dev/null
+++ b/src/Cafe/OS/libs/nfc/nfc.h
@@ -0,0 +1,92 @@
+#pragma once
+
+// CEMU NFC error codes
+#define NFC_TOUCH_TAG_ERROR_NONE			(0)
+#define NFC_TOUCH_TAG_ERROR_NO_ACCESS			(1)
+#define NFC_TOUCH_TAG_ERROR_INVALID_FILE_FORMAT		(2)
+
+// NFC result base
+#define NFC_RESULT_BASE_INIT		(-0x100)
+#define NFC_RESULT_BASE_READ		(-0x200)
+#define NFC_RESULT_BASE_WRITE		(-0x300)
+#define NFC_RESULT_BASE_FORMAT		(-0x400)
+#define NFC_RESULT_BASE_SET_READ_ONLY	(-0x500)
+#define NFC_RESULT_BASE_IS_TAG_PRESENT	(-0x600)
+#define NFC_RESULT_BASE_ABORT		(-0x700)
+#define NFC_RESULT_BASE_SHUTDOWN	(-0x800)
+#define NFC_RESULT_BASE_DETECT		(-0x900)
+#define NFC_RESULT_BASE_SEND_RAW_DATA	(-0xA00)
+#define NFC_RESULT_BASE_SET_MODE	(-0xB00)
+#define NFC_RESULT_BASE_TAG_PARSE	(-0xC00)
+#define NFC_RESULT_BASE_GET_TAG_INFO	(-0x1400)
+
+// NFC result status
+#define NFC_RESULT_NO_TAG		(0x01)
+#define NFC_RESULT_INVALID_TAG		(0x02)
+#define NFC_RESULT_UID_MISMATCH		(0x0A)
+#define NFC_RESULT_UNINITIALIZED	(0x20)
+#define NFC_RESULT_INVALID_STATE	(0x21)
+#define NFC_RESULT_INVALID_MODE		(0x24)
+#define NFC_RESULT_TAG_INFO_TIMEOUT	(0x7A)
+
+// Result macros
+#define NFC_RESULT_SUCCESS		(0)
+#define NFC_RESULT_BASE_MASK		(0xFFFFFF00)
+#define NFC_RESULT_MASK			(0x000000FF)
+#define NFC_MAKE_RESULT(base, result)	((base) | (result))
+
+#define NFC_PROTOCOL_T1T	0x1
+#define NFC_PROTOCOL_T2T	0x2
+
+#define NFC_TECHNOLOGY_A	0x0
+#define NFC_TECHNOLOGY_B	0x1
+#define NFC_TECHNOLOGY_F	0x2
+
+namespace nfc
+{
+	struct NFCUid
+	{
+		/* +0x00 */ uint8 uid[7];
+	};
+	static_assert(sizeof(NFCUid) == 0x7);
+
+	struct NFCTagInfo
+	{
+		/* +0x00 */ uint8 uidSize;
+		/* +0x01 */ uint8 uid[10];
+		/* +0x0B */ uint8 technology;
+		/* +0x0C */ uint8 protocol;
+		/* +0x0D */ uint8 reserved[0x20];
+	};
+	static_assert(sizeof(NFCTagInfo) == 0x2D);
+
+	sint32 NFCInit(uint32 chan);
+
+	sint32 NFCInitEx(uint32 chan, uint32 powerMode);
+
+	sint32 NFCShutdown(uint32 chan);
+
+	bool NFCIsInit(uint32 chan);
+
+	void NFCProc(uint32 chan);
+
+	sint32 NFCGetMode(uint32 chan);
+
+	sint32 NFCSetMode(uint32 chan, sint32 mode);
+
+	void NFCSetTagDetectCallback(uint32 chan, MPTR callback, void* context);
+
+	sint32 NFCGetTagInfo(uint32 chan, uint32 discoveryTimeout, MPTR callback, void* context);
+
+	sint32 NFCSendRawData(uint32 chan, bool startDiscovery, uint32 discoveryTimeout, uint32 commandTimeout, uint32 commandSize, uint32 responseSize, void* commandData, MPTR callback, void* context);
+
+	sint32 NFCAbort(uint32 chan, MPTR callback, void* context);
+
+	sint32 NFCRead(uint32 chan, uint32 discoveryTimeout, NFCUid* uid, NFCUid* uidMask, MPTR callback, void* context);
+
+	sint32 NFCWrite(uint32 chan, uint32 discoveryTimeout, NFCUid* uid, NFCUid* uidMask, uint32 size, void* data, MPTR callback, void* context);
+
+	void Initialize();
+
+	bool TouchTagFromFile(const fs::path& filePath, uint32* nfcError);
+}
diff --git a/src/Cafe/OS/libs/nfc/stream.cpp b/src/Cafe/OS/libs/nfc/stream.cpp
new file mode 100644
index 00000000..dd6de7ad
--- /dev/null
+++ b/src/Cafe/OS/libs/nfc/stream.cpp
@@ -0,0 +1,201 @@
+#include "stream.h"
+
+#include <algorithm>
+
+Stream::Stream(std::endian endianness)
+ : mError(ERROR_OK), mEndianness(endianness)
+{
+}
+
+Stream::~Stream()
+{
+}
+
+Stream::Error Stream::GetError() const
+{
+	return mError;
+}
+
+void Stream::SetEndianness(std::endian endianness)
+{
+	mEndianness = endianness;
+}
+
+std::endian Stream::GetEndianness() const
+{
+	return mEndianness;
+}
+
+Stream& Stream::operator>>(bool& val)
+{
+	uint8 i;
+	*this >> i;
+	val = !!i;
+
+	return *this;
+}
+
+Stream& Stream::operator>>(float& val)
+{
+	uint32 i;
+	*this >> i;
+	val = std::bit_cast<float>(i);
+
+	return *this;
+}
+
+Stream& Stream::operator>>(double& val)
+{
+	uint64 i;
+	*this >> i;
+	val = std::bit_cast<double>(i);
+
+	return *this;
+}
+
+Stream& Stream::operator<<(bool val)
+{
+	uint8 i = val;
+	*this >> i;
+
+	return *this;
+}
+
+Stream& Stream::operator<<(float val)
+{
+	uint32 i = std::bit_cast<uint32>(val);
+	*this >> i;
+
+	return *this;
+}
+
+Stream& Stream::operator<<(double val)
+{
+	uint64 i = std::bit_cast<uint64>(val);
+	*this >> i;
+
+	return *this;
+}
+
+void Stream::SetError(Error error)
+{
+	mError = error;
+}
+
+bool Stream::NeedsSwap()
+{
+	return mEndianness != std::endian::native;
+}
+
+VectorStream::VectorStream(std::vector<std::byte>& vector, std::endian endianness)
+ : Stream(endianness), mVector(vector), mPosition(0)
+{
+}
+
+VectorStream::~VectorStream()
+{
+}
+
+std::size_t VectorStream::Read(const std::span<std::byte>& data)
+{
+	if (data.size() > GetRemaining())
+	{
+		SetError(ERROR_READ_FAILED);
+		std::fill(data.begin(), data.end(), std::byte(0));
+		return 0;
+	}
+
+	std::copy_n(mVector.get().begin() + mPosition, data.size(), data.begin());
+	mPosition += data.size();
+	return data.size();
+}
+
+std::size_t VectorStream::Write(const std::span<const std::byte>& data)
+{
+	// Resize vector if not enough bytes remain
+	if (mPosition + data.size() > mVector.get().size())
+	{
+		mVector.get().resize(mPosition + data.size());
+	}
+
+	std::copy(data.begin(), data.end(), mVector.get().begin() + mPosition);
+	mPosition += data.size();
+	return data.size();
+}
+
+bool VectorStream::SetPosition(std::size_t position)
+{
+	if (position >= mVector.get().size())
+	{
+		return false;
+	}
+
+	mPosition = position;
+	return true;
+}
+
+std::size_t VectorStream::GetPosition() const
+{
+	return mPosition;
+}
+
+std::size_t VectorStream::GetRemaining() const
+{
+	return mVector.get().size() - mPosition;
+}
+
+SpanStream::SpanStream(std::span<const std::byte> span, std::endian endianness)
+ : Stream(endianness), mSpan(std::move(span)), mPosition(0)
+{
+}
+
+SpanStream::~SpanStream()
+{
+}
+
+std::size_t SpanStream::Read(const std::span<std::byte>& data)
+{
+	if (data.size() > GetRemaining())
+	{
+		SetError(ERROR_READ_FAILED);
+		std::fill(data.begin(), data.end(), std::byte(0));
+		return 0;
+	}
+
+	std::copy_n(mSpan.begin() + mPosition, data.size(), data.begin());
+	mPosition += data.size();
+	return data.size();
+}
+
+std::size_t SpanStream::Write(const std::span<const std::byte>& data)
+{
+	// Cannot write to const span
+	SetError(ERROR_WRITE_FAILED);
+	return 0;
+}
+
+bool SpanStream::SetPosition(std::size_t position)
+{
+	if (position >= mSpan.size())
+	{
+		return false;
+	}
+
+	mPosition = position;
+	return true;
+}
+
+std::size_t SpanStream::GetPosition() const
+{
+	return mPosition;
+}
+
+std::size_t SpanStream::GetRemaining() const
+{
+	if (mPosition > mSpan.size())
+	{
+		return 0;
+	}
+
+	return mSpan.size() - mPosition;
+}
diff --git a/src/Cafe/OS/libs/nfc/stream.h b/src/Cafe/OS/libs/nfc/stream.h
new file mode 100644
index 00000000..e666b480
--- /dev/null
+++ b/src/Cafe/OS/libs/nfc/stream.h
@@ -0,0 +1,139 @@
+#pragma once
+
+#include <cstdint>
+#include <vector>
+#include <span>
+#include <bit>
+
+#include "Common/precompiled.h"
+
+class Stream
+{
+public:
+	enum Error
+	{
+		ERROR_OK,
+		ERROR_READ_FAILED,
+		ERROR_WRITE_FAILED,
+	};
+
+public:
+	Stream(std::endian endianness = std::endian::native);
+	virtual ~Stream();
+
+	Error GetError() const;
+
+	void SetEndianness(std::endian endianness);
+	std::endian GetEndianness() const;
+
+	virtual std::size_t Read(const std::span<std::byte>& data) = 0;
+	virtual std::size_t Write(const std::span<const std::byte>& data) = 0;
+
+	virtual bool SetPosition(std::size_t position) = 0;
+	virtual std::size_t GetPosition() const = 0;
+
+	virtual std::size_t GetRemaining() const = 0;
+
+	// Stream read operators
+	template<std::integral T>
+	Stream& operator>>(T& val)
+	{
+		val = 0;
+		if (Read(std::as_writable_bytes(std::span(std::addressof(val), 1))) == sizeof(val))
+		{
+			if (NeedsSwap())
+			{
+				if (sizeof(T) == 2)
+				{
+					val = _swapEndianU16(val);
+				}
+				else if (sizeof(T) == 4)
+				{
+					val = _swapEndianU32(val);
+				}
+				else if (sizeof(T) == 8)
+				{
+					val = _swapEndianU64(val);
+				}
+			}
+		}
+
+		return *this;
+	}
+	Stream& operator>>(bool& val);
+	Stream& operator>>(float& val);
+	Stream& operator>>(double& val);
+
+	// Stream write operators
+	template<std::integral T>
+	Stream& operator<<(T val)
+	{
+		if (NeedsSwap())
+		{
+			if (sizeof(T) == 2)
+			{
+				val = _swapEndianU16(val);
+			}
+			else if (sizeof(T) == 4)
+			{
+				val = _swapEndianU32(val);
+			}
+			else if (sizeof(T) == 8)
+			{
+				val = _swapEndianU64(val);
+			}
+		}
+
+		Write(std::as_bytes(std::span(std::addressof(val), 1)));
+		return *this;
+	}
+	Stream& operator<<(bool val);
+	Stream& operator<<(float val);
+	Stream& operator<<(double val);
+
+protected:
+	void SetError(Error error);
+
+	bool NeedsSwap();
+
+	Error mError;
+	std::endian mEndianness;
+};
+
+class VectorStream : public Stream
+{
+public:
+	VectorStream(std::vector<std::byte>& vector, std::endian endianness = std::endian::native);
+	virtual ~VectorStream();
+
+	virtual std::size_t Read(const std::span<std::byte>& data) override;
+	virtual std::size_t Write(const std::span<const std::byte>& data) override;
+
+	virtual bool SetPosition(std::size_t position) override;
+	virtual std::size_t GetPosition() const override;
+
+	virtual std::size_t GetRemaining() const override;
+
+private:
+	std::reference_wrapper<std::vector<std::byte>> mVector;
+	std::size_t mPosition;
+};
+
+class SpanStream : public Stream
+{
+public:
+	SpanStream(std::span<const std::byte> span, std::endian endianness = std::endian::native);
+	virtual ~SpanStream();
+
+	virtual std::size_t Read(const std::span<std::byte>& data) override;
+	virtual std::size_t Write(const std::span<const std::byte>& data) override;
+
+	virtual bool SetPosition(std::size_t position) override;
+	virtual std::size_t GetPosition() const override;
+
+	virtual std::size_t GetRemaining() const override;
+
+private:
+	std::span<const std::byte> mSpan;
+	std::size_t mPosition;
+};
diff --git a/src/Cafe/OS/libs/nlibcurl/nlibcurl.cpp b/src/Cafe/OS/libs/nlibcurl/nlibcurl.cpp
index 9078ecc2..a992665c 100644
--- a/src/Cafe/OS/libs/nlibcurl/nlibcurl.cpp
+++ b/src/Cafe/OS/libs/nlibcurl/nlibcurl.cpp
@@ -1,4 +1,5 @@
 #include "Cafe/OS/common/OSCommon.h"
+#include "Cafe/OS/common/OSUtil.h"
 #include "Cafe/HW/Espresso/PPCCallback.h"
 #include "nlibcurl.h"
 
@@ -6,6 +7,8 @@
 #include "openssl/x509.h"
 #include "openssl/ssl.h"
 
+#define CURL_STRICTER
+
 #include "curl/curl.h"
 #include <unordered_map>
 #include <atomic>
@@ -98,6 +101,17 @@ struct MEMPTRHash_t
 	}
 };
 
+struct WU_curl_slist
+{
+	MEMPTR<char> data;
+	MEMPTR<WU_curl_slist> next;
+};
+
+enum class WU_CURLcode
+{
+	placeholder = 0,
+};
+
 struct
 {
 	sint32 initialized;
@@ -110,8 +124,53 @@ struct
 	MEMPTR<curl_calloc_callback> calloc;
 } g_nlibcurl = {};
 
+using WU_CURL_off_t = uint64be;
 
-#pragma pack(1)
+enum class WU_HTTPREQ : uint32
+{
+	HTTPREQ_GET = 0x1,
+	HTTPREQ_POST = 0x2,
+	UKN_3 = 0x3,
+};
+
+struct WU_UserDefined
+{
+	// starting at 0xD8 (probably) in CURL_t
+	/* 0x0D8 / +0x00 */ uint32be ukn0D8;
+	/* 0x0DC / +0x04 */ uint32be ukn0DC;
+	/* 0x0E0 / +0x08 */ MEMPTR<WU_curl_slist> headers;
+	/* 0x0E4 / +0x0C */ uint32be ukn0E4;
+	/* 0x0E8 / +0x10 */ uint32be ukn0E8;
+	/* 0x0EC / +0x14 */ uint32be ukn0EC;
+	/* 0x0F0 / +0x18 */ uint32be ukn0F0[4];
+	/* 0x100 / +0x28 */ uint32be ukn100[4];
+	/* 0x110 / +0x38 */ uint32be ukn110[4]; // +0x40 -> WU_CURL_off_t postfieldsize ?
+	/* 0x120 / +0x48 */ uint32be ukn120[4];
+	/* 0x130 / +0x58 */ uint32be ukn130[4];
+	/* 0x140 / +0x68 */ uint32be ukn140[4];
+	/* 0x150 / +0x78 */ uint32be ukn150[4];
+	/* 0x160 / +0x88 */ uint32be ukn160[4];
+	/* 0x170 / +0x98 */ uint32be ukn170[4];
+	/* 0x180 / +0xA8 */ uint32be ukn180[4];
+	/* 0x190 / +0xB0 */ sint64be infilesize_190{0};
+	/* 0x198 / +0xB8 */ uint32be ukn198;
+	/* 0x19C / +0xBC */ uint32be ukn19C;
+	/* 0x1A0 / +0xC8 */ uint32be ukn1A0[4];
+	/* 0x1B0 / +0xD8 */ uint32be ukn1B0[4];
+	/* 0x1C0 / +0xE8 */ uint32be ukn1C0[4];
+	/* 0x1D0 / +0xF8 */ uint32be ukn1D0[4];
+	/* 0x1E0 / +0x108 */ uint32be ukn1E0;
+	/* 0x1E4 / +0x108 */ uint32be ukn1E4;
+	/* 0x1E8 / +0x108 */ uint32be ukn1E8;
+	/* 0x1EC / +0x108 */ betype<WU_HTTPREQ> httpreq_1EC;
+	/* 0x1F0 / +0x118 */ uint32be ukn1F0[4];
+
+	void SetToDefault()
+	{
+		memset(this, 0, sizeof(WU_UserDefined));
+		httpreq_1EC = WU_HTTPREQ::HTTPREQ_GET;
+	}
+};
 
 struct CURL_t
 {
@@ -137,6 +196,7 @@ struct CURL_t
 	OSThread_t* curlThread;
 	MEMPTR<char> info_redirectUrl; // stores CURLINFO_REDIRECT_URL ptr
 	MEMPTR<char> info_contentType; // stores CURLINFO_CONTENT_TYPE ptr
+	bool isDirty{true};
 
 	// debug
 	struct  
@@ -149,10 +209,44 @@ struct CURL_t
 		FileStream* file_responseRaw{};
 	}debug;
 
+	// fields below match the actual memory layout, above still needs refactoring
+	/* 0x78 */ uint32be ukn078;
+	/* 0x7C */ uint32be ukn07C;
+	/* 0x80 */ uint32be ukn080;
+	/* 0x84 */ uint32be ukn084;
+	/* 0x88 */ uint32be ukn088;
+	/* 0x8C */ uint32be ukn08C;
+	/* 0x90 */ uint32be ukn090[4];
+	/* 0xA0 */ uint32be ukn0A0[4];
+	/* 0xB0 */ uint32be ukn0B0[4];
+	/* 0xC0 */ uint32be ukn0C0[4];
+	/* 0xD0 */ uint32be ukn0D0;
+	/* 0xD4 */ uint32be ukn0D4;
+	/* 0xD8 */ WU_UserDefined set;
+	/* 0x200 */ uint32be ukn200[4];
+	/* 0x210 */ uint32be ukn210[4];
+	/* 0x220 */ uint32be ukn220[4];
+	/* 0x230 */ uint32be ukn230[4];
+	/* 0x240 */ uint32be ukn240[4];
+	/* 0x250 */ uint32be ukn250[4];
+	/* 0x260 */ uint32be ukn260[4];
+	/* 0x270 */ uint32be ukn270[4];
+	/* 0x280 */ uint8be ukn280;
+	/* 0x281 */ uint8be opt_no_body_281;
+	/* 0x282 */ uint8be ukn282;
+	/* 0x283 */ uint8be upload_283;
 };
 static_assert(sizeof(CURL_t) <= 0x8698);
+static_assert(offsetof(CURL_t, ukn078) == 0x78);
+static_assert(offsetof(CURL_t, set) == 0xD8);
+static_assert(offsetof(CURL_t, set) + offsetof(WU_UserDefined, headers) == 0xE0);
+static_assert(offsetof(CURL_t, set) + offsetof(WU_UserDefined, infilesize_190) == 0x190);
+static_assert(offsetof(CURL_t, set) + offsetof(WU_UserDefined, httpreq_1EC) == 0x1EC);
+static_assert(offsetof(CURL_t, opt_no_body_281) == 0x281);
 typedef MEMPTR<CURL_t> CURLPtr;
 
+#pragma pack(1) // may affect structs below, we can probably remove this but lets keep it for now as the code below is fragile
+
 typedef struct
 {
 	//uint32be specifier; // 0x00
@@ -173,18 +267,12 @@ typedef MEMPTR<CURLSH_t> CURLSHPtr;
 typedef struct
 {
 	CURLM* curlm;
-	std::vector< MEMPTR<CURL> > curl;
+	std::vector<MEMPTR<CURL_t>> curl;
 }CURLM_t;
 static_assert(sizeof(CURLM_t) <= 0x80, "sizeof(CURLM_t)");
 typedef MEMPTR<CURLM_t> CURLMPtr;
 
-struct curl_slist_t
-{
-	MEMPTR<char> data;
-	MEMPTR<curl_slist_t> next;
-};
-
-static_assert(sizeof(curl_slist_t) <= 0x8, "sizeof(curl_slist_t)");
+static_assert(sizeof(WU_curl_slist) <= 0x8, "sizeof(curl_slist_t)");
 
 struct CURLMsg_t
 {
@@ -225,10 +313,10 @@ void CurlWorkerThread(CURL_t* curl, PPCConcurrentQueue<QueueMsg_t>* callerQueue,
 
 uint32 SendOrderToWorker(CURL_t* curl, QueueOrder order, uint32 arg1 = 0)
 {
-	OSThread_t* currentThread = coreinitThread_getCurrentThreadDepr(ppcInterpreterCurrentInstance);
+	OSThread_t* currentThread = coreinit::OSGetCurrentThread();
 	curl->curlThread = currentThread;
 
-	// forceLogDebug_printf("CURRENTTHREAD: 0x%p -> %d",currentThread, order)
+	// cemuLog_logDebug(LogType::Force, "CURRENTTHREAD: 0x{} -> {}",currentThread, order)
 
 	PPCConcurrentQueue<QueueMsg_t> callerQueue;
 	ConcurrentQueue<QueueMsg_t> threadQueue;
@@ -270,9 +358,9 @@ uint32 SendOrderToWorker(CURL_t* curl, QueueOrder order, uint32 arg1 = 0)
 
 			QueueMsg_t sendMsg = {};
 			sendMsg.order = QueueOrder_CBDone;
-			forceLogDebug_printf("QueueOrder_ReadCB size: %d nitems: %d", msg.read_cb.size, msg.read_cb.nitems);
+			cemuLog_logDebug(LogType::Force, "QueueOrder_ReadCB size: {} nitems: {}", msg.read_cb.size, msg.read_cb.nitems);
 			sendMsg.result = PPCCoreCallback(curl->fread_func_set.GetMPTR(), tmp.GetMPTR(), msg.read_cb.size, msg.read_cb.nitems, curl->in_set.GetMPTR());
-			forceLogDebug_printf("readcb size: %d", (sint32)sendMsg.result);
+			cemuLog_logDebug(LogType::Force, "readcb size: {}", (sint32)sendMsg.result);
 			if (sendMsg.result > 0)
 				memcpy(msg.read_cb.buffer, tmp.GetPointer(), sendMsg.result);
 
@@ -298,6 +386,94 @@ uint32 SendOrderToWorker(CURL_t* curl, QueueOrder order, uint32 arg1 = 0)
 	return result;
 }
 
+static int curl_closesocket(void *clientp, curl_socket_t item)
+{
+	nsysnet_notifyCloseSharedSocket((SOCKET)item);
+	closesocket(item);
+	return 0;
+}
+
+void _curl_set_default_parameters(CURL_t* curl)
+{
+	curl->set.SetToDefault();
+
+	// default parameters
+	curl_easy_setopt(curl->curl, CURLOPT_HEADERFUNCTION, header_callback);
+	curl_easy_setopt(curl->curl, CURLOPT_HEADERDATA, curl);
+
+	curl_easy_setopt(curl->curl, CURLOPT_CLOSESOCKETFUNCTION, curl_closesocket);
+	curl_easy_setopt(curl->curl, CURLOPT_CLOSESOCKETDATA, nullptr);
+}
+
+void _curl_sync_parameters(CURL_t* curl)
+{
+	// sync ppc curl to actual curl state
+	// not all parameters are covered yet, many are still set directly in easy_setopt
+	bool isPost = curl->set.httpreq_1EC == WU_HTTPREQ::HTTPREQ_POST;
+	// http request type
+	if(curl->set.httpreq_1EC == WU_HTTPREQ::HTTPREQ_GET)
+	{
+		::curl_easy_setopt(curl->curl, CURLOPT_HTTPGET, 1);
+		cemu_assert_debug(curl->opt_no_body_281 == 0);
+		cemu_assert_debug(curl->upload_283 == 0);
+	}
+	else if(curl->set.httpreq_1EC == WU_HTTPREQ::HTTPREQ_POST)
+	{
+		::curl_easy_setopt(curl->curl, CURLOPT_POST, 1);
+		cemu_assert_debug(curl->upload_283 == 0);
+		::curl_easy_setopt(curl->curl, CURLOPT_NOBODY, curl->opt_no_body_281 ? 1 : 0);
+	}
+	else
+	{
+		cemu_assert_unimplemented();
+	}
+
+	// CURLOPT_HTTPHEADER
+	std::optional<uint64> manualHeaderContentLength;
+	if (curl->set.headers)
+	{
+		struct curl_slist* list = nullptr;
+		WU_curl_slist* ppcList = curl->set.headers;
+		while(ppcList)
+		{
+			if(isPost)
+			{
+				// for recent libcurl manually adding Content-Length header is undefined behavior. Instead CURLOPT_INFILESIZE(_LARGE) should be set
+				// here we remove Content-Length and instead substitute it with CURLOPT_INFILESIZE (NEX DataStore in Super Mario Maker requires this)
+				if(strncmp(ppcList->data.GetPtr(), "Content-Length:", 15) == 0)
+				{
+					manualHeaderContentLength = std::stoull(ppcList->data.GetPtr() + 15);
+					ppcList = ppcList->next;
+					continue;
+				}
+			}
+
+			cemuLog_logDebug(LogType::Force, "curl_slist_append: {}", ppcList->data.GetPtr());
+			curlDebug_logEasySetOptStr(curl, "CURLOPT_HTTPHEADER", (const char*)ppcList->data.GetPtr());
+			list = ::curl_slist_append(list, ppcList->data.GetPtr());
+			ppcList = ppcList->next;
+		}
+		::curl_easy_setopt(curl->curl, CURLOPT_HTTPHEADER, list);
+		// todo - prevent leaking of list (maybe store in host curl object, similar to how our zlib implementation does stuff)
+	}
+	else
+		::curl_easy_setopt(curl->curl, CURLOPT_HTTPHEADER, nullptr);
+
+	// infile size (post data size)
+	if (curl->set.infilesize_190)
+	{
+		cemu_assert_debug(manualHeaderContentLength == 0); // should not have both?
+		::curl_easy_setopt(curl->curl, CURLOPT_INFILESIZE_LARGE, curl->set.infilesize_190);
+	}
+	else
+	{
+		if(isPost && manualHeaderContentLength > 0)
+			::curl_easy_setopt(curl->curl, CURLOPT_INFILESIZE_LARGE, manualHeaderContentLength);
+		else
+			::curl_easy_setopt(curl->curl, CURLOPT_INFILESIZE_LARGE, 0);
+	}
+}
+
 void export_malloc(PPCInterpreter_t* hCPU)
 {
 	ppcDefineParamU32(size, 0);
@@ -340,7 +516,6 @@ void export_realloc(PPCInterpreter_t* hCPU)
 	osLib_returnFromFunction(hCPU, result.GetMPTR());
 }
 
-
 CURLcode curl_global_init(uint32 flags)
 {
 	if (g_nlibcurl.initialized++)
@@ -362,7 +537,7 @@ CURLcode curl_global_init(uint32 flags)
 void export_curl_multi_init(PPCInterpreter_t* hCPU)
 {
 	CURLMPtr result{ PPCCoreCallback(g_nlibcurl.calloc, 1, ppcsizeof<CURLM_t>()) };
-	forceLogDebug_printf("curl_multi_init() -> 0x%08x", result.GetMPTR());
+	cemuLog_logDebug(LogType::Force, "curl_multi_init() -> 0x{:08x}", result.GetMPTR());
 	if (result)
 	{
 		memset(result.GetPtr(), 0, sizeof(CURLM_t));
@@ -385,7 +560,7 @@ void export_curl_multi_add_handle(PPCInterpreter_t* hCPU)
 	if (result == CURLM_OK)
 		curlm->curl.push_back(curl.GetPtr());
 
-	forceLogDebug_printf("curl_multi_add_handle(0x%08x, 0x%08x) -> 0x%x", curlm.GetMPTR(), curl.GetMPTR(), result);
+	cemuLog_logDebug(LogType::Force, "curl_multi_add_handle(0x{:08x}, 0x{:08x}) -> 0x{:x}", curlm.GetMPTR(), curl.GetMPTR(), result);
 	osLib_returnFromFunction(hCPU, result);
 }
 
@@ -401,7 +576,7 @@ void export_curl_multi_remove_handle(PPCInterpreter_t* hCPU)
 		curlm->curl.erase(std::remove(curlm->curl.begin(), curlm->curl.end(), (void*)curl.GetPtr()), curlm->curl.end());
 	}
 
-	forceLogDebug_printf("curl_multi_remove_handle(0x%08x, 0x%08x) -> 0x%x", curlm.GetMPTR(), curl.GetMPTR(), result);
+	cemuLog_logDebug(LogType::Force, "curl_multi_remove_handle(0x{:08x}, 0x{:08x}) -> 0x{:x}", curlm.GetMPTR(), curl.GetMPTR(), result);
 	osLib_returnFromFunction(hCPU, result);
 }
 
@@ -415,7 +590,7 @@ void export_curl_multi_timeout(PPCInterpreter_t* hCPU)
 	CURLMcode result = ::curl_multi_timeout(curlm->curlm, &timeoutLE);
 	*timeoParam = (uint32)timeoutLE;
 
-	forceLogDebug_printf("curl_multi_timeout(0x%08x, 0x%08x [%d]) -> 0x%x", curlm.GetMPTR(), timeoParam.GetMPTR(), timeoutLE, result);
+	cemuLog_logDebug(LogType::Force, "curl_multi_timeout(0x{:08x}, 0x{:08x} [{}]) -> 0x{:x}", curlm.GetMPTR(), timeoParam.GetMPTR(), timeoutLE, result);
 	osLib_returnFromFunction(hCPU, result);
 }
 
@@ -423,7 +598,7 @@ void export_curl_multi_cleanup(PPCInterpreter_t* hCPU)
 {
 	ppcDefineParamMEMPTR(curlm, CURLM_t, 0);
 	CURLMcode result = ::curl_multi_cleanup(curlm->curlm);
-	forceLogDebug_printf("curl_multi_cleanup(0x%08x) -> 0x%x", curlm.GetMPTR(), result);
+	cemuLog_logDebug(LogType::Force, "curl_multi_cleanup(0x{:08x}) -> 0x{:x}", curlm.GetMPTR(), result);
 	curlm->curl.clear();
 	PPCCoreCallback(g_nlibcurl.free.GetMPTR(), curlm.GetMPTR());
 	osLib_returnFromFunction(hCPU, result);
@@ -434,14 +609,26 @@ void export_curl_multi_perform(PPCInterpreter_t* hCPU)
 	ppcDefineParamMEMPTR(curlm, CURLM_t, 0);
 	ppcDefineParamMEMPTR(runningHandles, uint32be, 1);
 
-	//forceLogDebug_printf("curl_multi_perform(0x%08x, 0x%08x)", curlm.GetMPTR(), runningHandles.GetMPTR());
+	//cemuLog_logDebug(LogType::Force, "curl_multi_perform(0x{:08x}, 0x{:08x})", curlm.GetMPTR(), runningHandles.GetMPTR());
+
+	//curl_multi_get_handles(curlm->curlm);
+
+	for(auto _curl : curlm->curl)
+	{
+		CURL_t* curl = (CURL_t*)_curl.GetPtr();
+		if(curl->isDirty)
+		{
+			curl->isDirty = false;
+			_curl_sync_parameters(curl);
+		}
+	}
 
 	//g_callerQueue = curlm->callerQueue;
 	//g_threadQueue = curlm->threadQueue;
 	int tempRunningHandles = 0;
 	CURLMcode result = curl_multi_perform(curlm->curlm, &tempRunningHandles);
 	*(runningHandles.GetPtr()) = tempRunningHandles;
-	forceLogDebug_printf("curl_multi_perform(0x%08x, 0x%08x) -> 0x%x (running handles: %d) LR: 0x%08x", curlm.GetMPTR(), runningHandles.GetMPTR(), result, tempRunningHandles, hCPU->spr.LR);
+	cemuLog_logDebug(LogType::Force, "curl_multi_perform(0x{:08x}, 0x{:08x}) -> 0x{:x} (running handles: {})", curlm.GetMPTR(), runningHandles.GetMPTR(), result, tempRunningHandles);
 	//const uint32 result = SendOrderToWorker(curlm.GetPtr(), QueueOrder_MultiPerform);
 
 	osLib_returnFromFunction(hCPU, result);
@@ -455,11 +642,6 @@ void export_curl_multi_fdset(PPCInterpreter_t* hCPU)
 	ppcDefineParamMEMPTR(exceptionFd, wu_fd_set, 3);
 	ppcDefineParamU32BEPtr(maxFd, 4);
 
-#if BOOST_OS_LINUX || BOOST_OS_MACOS
-	cemuLog_log(LogType::Force, "curl_multi_fdset(...) - todo");
-
-	osLib_returnFromFunction(hCPU, 0);
-#else
 	fd_set h_readFd;
 	fd_set h_writeFd;
 	fd_set h_exceptionFd;
@@ -475,33 +657,51 @@ void export_curl_multi_fdset(PPCInterpreter_t* hCPU)
 	nsysnet::wuResetFD(exceptionFd.GetPtr());
 
 	sint32 c_maxFD = -1;
-	// fd read set
-	for (uint32 i = 0; i < h_readFd.fd_count; i++)
+
+	auto hostFdSet = [&](SOCKET s, wu_fd_set* fds)
 	{
-		sint32 wuSocket = nsysnet_getVirtualSocketHandleFromHostHandle(h_readFd.fd_array[i]);
+		sint32 wuSocket = nsysnet_getVirtualSocketHandleFromHostHandle(s);
 		if (wuSocket < 0)
-			wuSocket = nsysnet_createVirtualSocketFromExistingSocket(h_readFd.fd_array[i]);
+			wuSocket = nsysnet_createVirtualSocketFromExistingSocket(s);
 		if (wuSocket >= 0)
 		{
 			c_maxFD = std::max(wuSocket, c_maxFD);
-			nsysnet::wuSetFD(readFd.GetPtr(), wuSocket);
+			nsysnet::wuSetFD(fds, wuSocket);
 		}
+	};
+
+#if BOOST_OS_UNIX
+	for (int s = 0; s < h_maxFd + 1; s++) 
+	{
+		if(FD_ISSET(s, &h_readFd))
+			hostFdSet(s, readFd.GetPtr());
+
+		if(FD_ISSET(s, &h_writeFd))
+			hostFdSet(s, writeFd.GetPtr());
+
+		if(FD_ISSET(s, &h_exceptionFd))
+			hostFdSet(s, exceptionFd.GetPtr());
+	}
+#else
+	// fd read set
+	for (uint32 i = 0; i < h_readFd.fd_count; i++)
+	{
+		hostFdSet(h_readFd.fd_array[i], readFd.GetPtr());
 	}
 	// fd write set
 	for (uint32 i = 0; i < h_writeFd.fd_count; i++)
 	{
-		cemu_assert_debug(false);
+		hostFdSet(h_writeFd.fd_array[i], writeFd.GetPtr());
 	}
 	// fd exception set
 	for (uint32 i = 0; i < h_exceptionFd.fd_count; i++)
 	{
 		cemu_assert_debug(false);
 	}
+#endif
 
 	*maxFd = c_maxFD;
 	osLib_returnFromFunction(hCPU, result);
-#endif
-
 }
 
 void export_curl_multi_setopt(PPCInterpreter_t* hCPU)
@@ -518,10 +718,10 @@ void export_curl_multi_setopt(PPCInterpreter_t* hCPU)
 		result = ::curl_multi_setopt(curlm->curlm, (CURLMoption)option, parameter.GetMPTR());
 		break;
 	default:
-		forceLogDebug_printf("curl_multi_setopt(0x%08x, %d, 0x%08x) unsupported option", curlm.GetMPTR(), option, parameter.GetMPTR());
+		cemuLog_logDebug(LogType::Force, "curl_multi_setopt(0x{:08x}, {}, 0x{:08x}) unsupported option", curlm.GetMPTR(), option, parameter.GetMPTR());
 	}
 
-	forceLogDebug_printf("curl_multi_setopt(0x%08x, %d, 0x%08x) -> 0x%x", curlm.GetMPTR(), option, parameter.GetMPTR(), result);
+	cemuLog_logDebug(LogType::Force, "curl_multi_setopt(0x{:08x}, {}, 0x{:08x}) -> 0x{:x}", curlm.GetMPTR(), option, parameter.GetMPTR(), result);
 
 	osLib_returnFromFunction(hCPU, result);
 }
@@ -533,7 +733,7 @@ void export_curl_multi_info_read(PPCInterpreter_t* hCPU)
 
 	CURLMsg* msg = ::curl_multi_info_read(curlm->curlm, msgsInQueue.GetPtr());
 
-	forceLogDebug_printf("curl_multi_info_read - todo");
+	cemuLog_logDebug(LogType::Force, "curl_multi_info_read - todo");
 	if (msg)
 	{
 		MEMPTR<CURLMsg_t> result{ PPCCoreCallback(g_nlibcurl.malloc.GetMPTR(), ppcsizeof<CURLMsg_t>()) };
@@ -542,7 +742,7 @@ void export_curl_multi_info_read(PPCInterpreter_t* hCPU)
 		if (msg->easy_handle)
 		{
 			const auto it = find_if(curlm->curl.cbegin(), curlm->curl.cend(),
-				[msg](const MEMPTR<void>& curl)
+				[msg](const MEMPTR<CURL_t>& curl)
 			{
 				const MEMPTR<CURL_t> _curl{ curl };
 				return _curl->curl = msg->easy_handle;
@@ -555,7 +755,7 @@ void export_curl_multi_info_read(PPCInterpreter_t* hCPU)
 		else
 			result->curl = nullptr;
 
-		forceLogDebug_printf("curl_multi_info_read(0x%08x, 0x%08x [%d]) -> 0x%08x (0x%x, 0x%08x, 0x%x)", curlm.GetMPTR(), msgsInQueue.GetMPTR(), *msgsInQueue.GetPtr(),
+		cemuLog_logDebug(LogType::Force, "curl_multi_info_read(0x{:08x}, 0x{:08x} [{}]) -> 0x{:08x} (0x{:x}, 0x{:08x}, 0x{:x})", curlm.GetMPTR(), msgsInQueue.GetMPTR(), *msgsInQueue.GetPtr(),			
 			result.GetMPTR(), msg->msg, result->curl.GetMPTR(), msg->data.result);
 		osLib_returnFromFunction(hCPU, result.GetMPTR());
 	}
@@ -621,14 +821,14 @@ void export_curl_share_setopt(PPCInterpreter_t* hCPU)
 		default:
 			cemu_assert_unimplemented();
 	}
-	forceLogDebug_printf("curl_share_setopt(0x%08x, 0x%x, 0x%08x) -> 0x%x", share.GetMPTR(), option, parameter.GetMPTR(), result);
+	cemuLog_logDebug(LogType::Force, "curl_share_setopt(0x{:08x}, 0x{:x}, 0x{:08x}) -> 0x{:x}", share.GetMPTR(), option, parameter.GetMPTR(), result);
 	osLib_returnFromFunction(hCPU, result);
 }
 
 void export_curl_share_init(PPCInterpreter_t* hCPU)
 {
 	CURLSHPtr result{ PPCCoreCallback(g_nlibcurl.calloc.GetMPTR(), (uint32)1, ppcsizeof<CURLSH_t>()) };
-	forceLogDebug_printf("curl_share_init() -> 0x%08x", result.GetMPTR());
+	cemuLog_logDebug(LogType::Force, "curl_share_init() -> 0x{:08x}", result.GetMPTR());
 	if (result)
 	{
 		memset(result.GetPtr(), 0, sizeof(CURLSH_t));
@@ -643,68 +843,35 @@ void export_curl_share_cleanup(PPCInterpreter_t* hCPU)
 {
 	ppcDefineParamMEMPTR(curlsh, CURLSH_t, 0);
 	uint32 result = ::curl_share_cleanup(curlsh->curlsh);
-	forceLogDebug_printf("curl_share_cleanup(0x%08x) -> 0x%x", curlsh.GetMPTR(), result);
+	cemuLog_logDebug(LogType::Force, "curl_share_cleanup(0x{:08x}) -> 0x{:x}", curlsh.GetMPTR(), result);
 	PPCCoreCallback(g_nlibcurl.free.GetMPTR(), curlsh.GetMPTR());
 	osLib_returnFromFunction(hCPU, 0);
 }
 
-int my_trace(CURL *handle, curl_infotype type, char *ptr, size_t size,
-	void *userp)
-{
-	FILE* f = (FILE*)userp;
-
-	//if (type == CURLINFO_TEXT)
-	{
-		char tmp[1024] = {};
-		sprintf(tmp, "0x%p: ", handle);
-		fwrite(tmp, 1, strlen(tmp), f);
-
-		memcpy(tmp, ptr, std::min(size, (size_t)990));
-		fwrite(tmp, 1, std::min(size + 1, (size_t)991), f);
-
-		fflush(f);
-		
-	}
-	return 0;
-}
-
-static int curl_closesocket(void *clientp, curl_socket_t item)
-{
-	nsysnet_notifyCloseSharedSocket((SOCKET)item);
-	closesocket(item);
-	return 0;
-}
-
-void export_curl_easy_init(PPCInterpreter_t* hCPU)
+CURL_t* curl_easy_init()
 {
 	if (g_nlibcurl.initialized == 0)
 	{
 		if (curl_global_init(CURL_GLOBAL_DEFAULT) != CURLE_OK)
 		{
-			osLib_returnFromFunction(hCPU, 0);
-			return;
+			return nullptr;
 		}
 	}
 
 	// Curl_open
-	CURLPtr result{ PPCCoreCallback(g_nlibcurl.calloc.GetMPTR(), (uint32)1, ppcsizeof<CURL_t>()) };
-	forceLogDebug_printf("curl_easy_init() -> 0x%08x", result.GetMPTR());
+	MEMPTR<CURL_t> result{ PPCCoreCallback(g_nlibcurl.calloc.GetMPTR(), (uint32)1, ppcsizeof<CURL_t>()) };
+	cemuLog_logDebug(LogType::Force, "curl_easy_init() -> 0x{:08x}", result.GetMPTR());
 	if (result)
 	{
 		memset(result.GetPtr(), 0, sizeof(CURL_t));
 		*result = {};
-		result->curl = curl_easy_init();
-		result->curlThread = coreinitThread_getCurrentThreadDepr(ppcInterpreterCurrentInstance);
+		result->curl = ::curl_easy_init();
+		result->curlThread = coreinit::OSGetCurrentThread();
 
 		result->info_contentType = nullptr;
 		result->info_redirectUrl = nullptr;
 
-		// default parameters
-		curl_easy_setopt(result->curl, CURLOPT_HEADERFUNCTION, header_callback);
-		curl_easy_setopt(result->curl, CURLOPT_HEADERDATA, result.GetPtr());
-
-		curl_easy_setopt(result->curl, CURLOPT_CLOSESOCKETFUNCTION, curl_closesocket);
-		curl_easy_setopt(result->curl, CURLOPT_CLOSESOCKETDATA, nullptr);
+		_curl_set_default_parameters(result.GetPtr());
 
 		if (g_nlibcurl.proxyConfig)
 		{
@@ -712,25 +879,30 @@ void export_curl_easy_init(PPCInterpreter_t* hCPU)
 		}
 	}
 
-	osLib_returnFromFunction(hCPU, result.GetMPTR());
+	return result;
+}
+
+CURL_t* mw_curl_easy_init()
+{
+	return curl_easy_init();
 }
 
 void export_curl_easy_pause(PPCInterpreter_t* hCPU)
 {
 	ppcDefineParamMEMPTR(curl, CURL_t, 0);
 	ppcDefineParamS32(bitmask, 1);
-	forceLogDebug_printf("curl_easy_pause(0x%08x, 0x%x)", curl.GetMPTR(), bitmask);
+	cemuLog_logDebug(LogType::Force, "curl_easy_pause(0x{:08x}, 0x{:x})", curl.GetMPTR(), bitmask);
 
 	//const CURLcode result = ::curl_easy_pause(curl->curl, bitmask);
 	const uint32 result = SendOrderToWorker(curl.GetPtr(), QueueOrder_Pause, bitmask);
-	forceLogDebug_printf("curl_easy_pause(0x%08x, 0x%x) DONE", curl.GetMPTR(), bitmask);
+	cemuLog_logDebug(LogType::Force, "curl_easy_pause(0x{:08x}, 0x{:x}) DONE", curl.GetMPTR(), bitmask);
 	osLib_returnFromFunction(hCPU, result);
 }
 
 void export_curl_easy_cleanup(PPCInterpreter_t* hCPU)
 {
 	ppcDefineParamMEMPTR(curl, CURL_t, 0);
-	forceLogDebug_printf("curl_easy_cleanup(0x%08x)", curl.GetMPTR());
+	cemuLog_logDebug(LogType::Force, "curl_easy_cleanup(0x{:08x})", curl.GetMPTR());
 
 	curlDebug_cleanup(curl.GetPtr());
 
@@ -748,7 +920,7 @@ void export_curl_easy_cleanup(PPCInterpreter_t* hCPU)
 void export_curl_easy_reset(PPCInterpreter_t* hCPU)
 {
 	ppcDefineParamMEMPTR(curl, CURL_t, 0);
-	forceLogDebug_printf("curl_easy_reset(0x%08x)", curl.GetMPTR());
+	cemuLog_logDebug(LogType::Force, "curl_easy_reset(0x{:08x})", curl.GetMPTR());
 	// curl_apply_default_proxy_config();
 	::curl_easy_reset(curl->curl);
 	osLib_returnFromFunction(hCPU, 0);
@@ -759,7 +931,7 @@ int ssl_verify_callback(int preverify_ok, X509_STORE_CTX* ctx)
 	if (preverify_ok) return preverify_ok;
 	int err = X509_STORE_CTX_get_error(ctx);
 	if(err != 0)
-		forceLogDebug_printf("ssl_verify_callback: Error %d but allow certificate anyway", err);
+		cemuLog_logDebug(LogType::Force, "ssl_verify_callback: Error {} but allow certificate anyway", err);
 	X509_STORE_CTX_set_error(ctx, 0);
 	return 1;
 }
@@ -839,12 +1011,12 @@ size_t header_callback(char* buffer, size_t size, size_t nitems, void* userdata)
 	if (msg.order != QueueOrder_CBDone)
 		cemu_assert_suspicious();
 
-#ifndef PUBLIC_RELEASE
+#ifdef CEMU_DEBUG_ASSERT
 	char debug[500];
 	cemu_assert_debug((size*nitems) < 500);
 	memcpy(debug, buffer, size*nitems);
 	debug[size*nitems] = 0;
-	forceLogDebug_printf("header_callback(0x%p, 0x%x, 0x%x, 0x%08x) [%s]", (void*)buffer, size, nitems, curl->writeheader.GetMPTR(), debug);
+	cemuLog_logDebug(LogType::Force, "header_callback(0x{}, 0x{:x}, 0x{:x}, 0x{:08x}) [{}]", (void*)buffer, size, nitems, curl->writeheader.GetMPTR(), debug);
 #endif
 	return msg.result;
 }
@@ -857,7 +1029,7 @@ size_t write_callback(char* ptr, size_t size, size_t nmemb, void* userdata)
 	//StackAllocator<char> tmp(size * nmemb);
 	//memcpy(tmp.GetPointer(), ptr, size * nmemb);
 
-	forceLogDebug_printf("write_callback(0x%p 0x%x, 0x%x, 0x%08x)", (void*)ptr, size, nmemb, curl->out.GetMPTR());
+	cemuLog_logDebug(LogType::Force, "write_callback(0x{} 0x{:x}, 0x{:x}, 0x{:08x})", (void*)ptr, size, nmemb, curl->out.GetMPTR());
 
 	if (g_callerQueue == nullptr || g_threadQueue == nullptr)
 	{
@@ -885,7 +1057,7 @@ int sockopt_callback(void* clientp, curl_socket_t curlfd, curlsocktype purpose)
 {
 	CURL_t* curl = (CURL_t*)clientp;
 
-	forceLogDebug_printf("sockopt_callback called!");
+	cemuLog_logDebug(LogType::Force, "sockopt_callback called!");
 
 	sint32 r = 0;
 
@@ -893,10 +1065,11 @@ int sockopt_callback(void* clientp, curl_socket_t curlfd, curlsocktype purpose)
 }
 
 size_t read_callback(char* buffer, size_t size, size_t nitems, void* instream)
-{
+{	
+	nitems = std::min<uint32>(nitems, 0x4000);
 	CURL_t* curl = (CURL_t*)instream;
 
-	forceLogDebug_printf("read_callback(0x%p, 0x%x, 0x%x, 0x%08x) [func: 0x%x]", (void*)buffer, size, nitems, curl->in_set.GetMPTR(), curl->fread_func_set.GetMPTR());
+	cemuLog_logDebug(LogType::Force, "read_callback(0x{}, 0x{:x}, 0x{:x}, 0x{:08x}) [func: 0x{:x}]", (void*)buffer, size, nitems, curl->in_set.GetMPTR(), curl->fread_func_set.GetMPTR());
 
 	if (g_callerQueue == nullptr || g_threadQueue == nullptr)
 	{
@@ -912,14 +1085,14 @@ size_t read_callback(char* buffer, size_t size, size_t nitems, void* instream)
 	msg.read_cb.size = (uint32)size;
 	msg.read_cb.nitems = (uint32)std::min<uint32>(nitems, 0x4000); // limit this to 16KB which is the limit in nlibcurl.rpl (Super Mario Maker crashes on level upload if the size is too big)
 
-	forceLogDebug_printf("read_callback(0x%p, 0x%x, 0x%x, 0x%08x) [func: 0x%x] PUSH", (void*)buffer, size, nitems, curl->in_set.GetMPTR(), curl->fread_func_set.GetMPTR());
+	cemuLog_logDebug(LogType::Force, "read_callback(0x{}, 0x{:x}, 0x{:x}, 0x{:08x}) [func: 0x{:x}] PUSH", (void*)buffer, size, nitems, curl->in_set.GetMPTR(), curl->fread_func_set.GetMPTR());
 	g_callerQueue->push(msg, curl->curlThread);
 
 	msg = g_threadQueue->pop();
 	if (msg.order != QueueOrder_CBDone)
 		cemu_assert_suspicious();
 
-	forceLogDebug_printf("read_callback(0x%p, 0x%x, 0x%x, 0x%08x) DONE Result: %d", (void*)buffer, size, nitems, curl->in_set.GetMPTR(), msg.result);
+	cemuLog_logDebug(LogType::Force, "read_callback(0x{}, 0x{:x}, 0x{:x}, 0x{:08x}) DONE Result: {}", (void*)buffer, size, nitems, curl->in_set.GetMPTR(), msg.result);
 
 	return msg.result;
 }
@@ -945,7 +1118,7 @@ int progress_callback(void* clientp, double dltotal, double dlnow, double ultota
 	if (msg.order != QueueOrder_CBDone)
 		cemu_assert_suspicious();
 	
-	forceLogDebug_printf("progress_callback(%.02lf, %.02lf, %.02lf, %.02lf) -> %d", dltotal, dlnow, ultotal, ulnow, msg.result);
+	cemuLog_logDebug(LogType::Force, "progress_callback({:.02}, {:.02}, {:.02}, {:.02}) -> {}", dltotal, dlnow, ultotal, ulnow, msg.result);
 	return msg.result;
 }
 
@@ -957,18 +1130,47 @@ void export_curl_easy_setopt(PPCInterpreter_t* hCPU)
 	ppcDefineParamU64(parameterU64, 2);
 
 	CURL* curlObj = curl->curl;
+	curl->isDirty = true;
 
 	CURLcode result = CURLE_OK;
 	switch (option)
 	{
-		case CURLOPT_NOSIGNAL:
+		case CURLOPT_POST:
+		{
+			if(parameter)
+			{
+				curl->set.httpreq_1EC = WU_HTTPREQ::HTTPREQ_POST;
+				curl->opt_no_body_281 = 0;
+			}
+			else
+				curl->set.httpreq_1EC = WU_HTTPREQ::HTTPREQ_GET;
+			break;
+		}
 		case CURLOPT_HTTPGET:
+		{
+			if (parameter)
+			{
+				curl->set.httpreq_1EC = WU_HTTPREQ::HTTPREQ_GET;
+				curl->opt_no_body_281 = 0;
+				curl->upload_283 = 0;
+			}
+			break;
+		}
+		case CURLOPT_INFILESIZE:
+		{
+			curl->set.infilesize_190 = (sint64)(sint32)(uint32)parameter.GetBEValue();
+			break;
+		}
+		case CURLOPT_INFILESIZE_LARGE:
+		{
+			curl->set.infilesize_190 = (sint64)(uint64)parameterU64;
+			break;
+		}
+		case CURLOPT_NOSIGNAL:
 		case CURLOPT_FOLLOWLOCATION:
 		case CURLOPT_BUFFERSIZE:
 		case CURLOPT_TIMEOUT:
 		case CURLOPT_CONNECTTIMEOUT_MS:
-		case CURLOPT_POST:
-		case CURLOPT_INFILESIZE:
 		case CURLOPT_NOPROGRESS:
 		case CURLOPT_LOW_SPEED_LIMIT:
 		case CURLOPT_LOW_SPEED_TIME:
@@ -980,7 +1182,7 @@ void export_curl_easy_setopt(PPCInterpreter_t* hCPU)
 		case CURLOPT_URL:
 		{
 			curlDebug_logEasySetOptStr(curl.GetPtr(), "CURLOPT_URL", (const char*)parameter.GetPtr());
-			forceLogDebug_printf("curl_easy_setopt(%d) [%s]", option, parameter.GetPtr());
+			cemuLog_logDebug(LogType::Force, "curl_easy_setopt({}) [{}]", option, parameter.GetPtr());
 			result = ::curl_easy_setopt(curlObj, (CURLoption)option, parameter.GetPtr());
 			break;
 		}
@@ -988,7 +1190,7 @@ void export_curl_easy_setopt(PPCInterpreter_t* hCPU)
 		case CURLOPT_PROXY:
 		case CURLOPT_USERAGENT:
 		{
-			forceLogDebug_printf("curl_easy_setopt(%d) [%s]", option, parameter.GetPtr());
+			cemuLog_logDebug(LogType::Force, "curl_easy_setopt({}) [{}]", option, parameter.GetPtr());
 			result = ::curl_easy_setopt(curlObj, (CURLoption)option, parameter.GetPtr());
 			break;
 		}
@@ -996,7 +1198,7 @@ void export_curl_easy_setopt(PPCInterpreter_t* hCPU)
 		case CURLOPT_POSTFIELDS:
 		{
 			curlDebug_logEasySetOptStr(curl.GetPtr(), "CURLOPT_POSTFIELDS", (const char*)parameter.GetPtr());
-			forceLogDebug_printf("curl_easy_setopt(%d) [%s]", option, parameter.GetPtr());
+			cemuLog_logDebug(LogType::Force, "curl_easy_setopt({}) [{}]", option, parameter.GetPtr());
 			result = ::curl_easy_setopt(curlObj, (CURLoption)option, parameter.GetPtr());
 			break;
 		}
@@ -1054,8 +1256,6 @@ void export_curl_easy_setopt(PPCInterpreter_t* hCPU)
 				curlSh->curl = curl;
 				shObj = curlSh->curlsh;
 			}
-				
-
 			result = ::curl_easy_setopt(curlObj, CURLOPT_SHARE, shObj);
 			break;
 		}
@@ -1087,17 +1287,8 @@ void export_curl_easy_setopt(PPCInterpreter_t* hCPU)
 		}
 		case CURLOPT_HTTPHEADER:
 		{
-			struct curl_slist* list = nullptr;
-			bool isFirst = true;
-			for (curl_slist_t* ppcList = (curl_slist_t*)parameter.GetPtr(); ppcList; ppcList = ppcList->next.GetPtr())
-			{
-				forceLogDebug_printf("curl_slist_append: %s", ppcList->data.GetPtr());
-				curlDebug_logEasySetOptStr(curl.GetPtr(), isFirst?"CURLOPT_HTTPHEADER" : "CURLOPT_HTTPHEADER(continue)", (const char*)ppcList->data.GetPtr());
-				list = ::curl_slist_append(list, ppcList->data.GetPtr());
-				isFirst = false;
-			}
-
-			result = ::curl_easy_setopt(curlObj, CURLOPT_HTTPHEADER, list);
+			curl->set.headers = (WU_curl_slist*)parameter.GetPtr();
+			result = CURLE_OK;
 			break;
 		}
 		case CURLOPT_SOCKOPTFUNCTION:
@@ -1141,23 +1332,26 @@ void export_curl_easy_setopt(PPCInterpreter_t* hCPU)
 			break;
 		}
 		default:
-			forceLogDebug_printf("curl_easy_setopt(0x%08x, %d, 0x%08x) unsupported option", curl.GetMPTR(), option, parameter.GetMPTR());
+			cemuLog_logDebug(LogType::Force, "curl_easy_setopt(0x{:08x}, {}, 0x{:08x}) unsupported option", curl.GetMPTR(), option, parameter.GetMPTR());
 	}
 
-	forceLogDebug_printf("curl_easy_setopt(0x%08x, %d, 0x%08x) -> 0x%x", curl.GetMPTR(), option, parameter.GetMPTR(), result);
+	cemuLog_logDebug(LogType::Force, "curl_easy_setopt(0x{:08x}, {}, 0x{:08x}) -> 0x{:x}", curl.GetMPTR(), option, parameter.GetMPTR(), result);
 
 	osLib_returnFromFunction(hCPU, result);
 }
 
-void export_curl_easy_perform(PPCInterpreter_t* hCPU)
+WU_CURLcode curl_easy_perform(CURL_t* curl)
 {
-	ppcDefineParamMEMPTR(curl, CURL_t, 0);
-	curlDebug_markActiveRequest(curl.GetPtr());
-	curlDebug_notifySubmitRequest(curl.GetPtr());
-	forceLogDebug_printf("curl_easy_perform(0x%08x)", curl.GetMPTR());
-	const uint32 result = SendOrderToWorker(curl.GetPtr(), QueueOrder_Perform);
-	forceLogDebug_printf("curl_easy_perform(0x%08x) -> 0x%x DONE", curl.GetMPTR(), result);
-	osLib_returnFromFunction(hCPU, result);
+	curlDebug_markActiveRequest(curl);
+	curlDebug_notifySubmitRequest(curl);
+
+	if(curl->isDirty)
+	{
+		curl->isDirty = false;
+		_curl_sync_parameters(curl);
+	}
+	const uint32 result = SendOrderToWorker(curl, QueueOrder_Perform);
+	return static_cast<WU_CURLcode>(result);
 }
 
 void _updateGuestString(CURL_t* curl, MEMPTR<char>& ppcStr, char* hostStr)
@@ -1207,12 +1401,10 @@ void export_curl_easy_getinfo(PPCInterpreter_t* hCPU)
 		}
 		case CURLINFO_CONTENT_TYPE:
 		{
-			//forceLogDebug_printf("CURLINFO_CONTENT_TYPE not supported");
-			//*(uint32*)parameter.GetPtr() = MPTR_NULL;
 			char* contentType = nullptr;
 			result = curl_easy_getinfo(curlObj, CURLINFO_REDIRECT_URL, &contentType);
 			_updateGuestString(curl.GetPtr(), curl->info_contentType, contentType);
-			*(uint32*)parameter.GetPtr() = curl->info_contentType.GetMPTRBE();
+			*(MEMPTR<char>*)parameter.GetPtr() = curl->info_contentType;
 			break;
 		}
 		case CURLINFO_REDIRECT_URL:
@@ -1220,7 +1412,7 @@ void export_curl_easy_getinfo(PPCInterpreter_t* hCPU)
 			char* redirectUrl = nullptr;
 			result = curl_easy_getinfo(curlObj, CURLINFO_REDIRECT_URL, &redirectUrl);
 			_updateGuestString(curl.GetPtr(), curl->info_redirectUrl, redirectUrl);
-			*(uint32*)parameter.GetPtr() = curl->info_redirectUrl.GetMPTRBE();
+			*(MEMPTR<char>*)parameter.GetPtr() = curl->info_redirectUrl;
 			break;
 		}
 		default:
@@ -1228,18 +1420,10 @@ void export_curl_easy_getinfo(PPCInterpreter_t* hCPU)
 			result = curl_easy_getinfo(curlObj, (CURLINFO)info, (double*)parameter.GetPtr());
 	}
 
-	forceLogDebug_printf("curl_easy_getinfo(0x%08x, 0x%x, 0x%08x) -> 0x%x", curl.GetMPTR(), info, parameter.GetMPTR(), result);
+	cemuLog_logDebug(LogType::Force, "curl_easy_getinfo(0x{:08x}, 0x{:x}, 0x{:08x}) -> 0x{:x}", curl.GetMPTR(), info, parameter.GetMPTR(), result);
 	osLib_returnFromFunction(hCPU, result);
 }
 
-
-
-void export_curl_global_init(PPCInterpreter_t* hCPU)
-{
-	ppcDefineParamU32(flags, 0);
-	osLib_returnFromFunction(hCPU, curl_global_init(flags));
-}
-
 void export_curl_easy_strerror(PPCInterpreter_t* hCPU)
 {
 	ppcDefineParamU32(code, 0);
@@ -1248,7 +1432,7 @@ void export_curl_easy_strerror(PPCInterpreter_t* hCPU)
 	const char* error = curl_easy_strerror((CURLcode)code);
 	if (error)
 	{
-		forceLogDebug_printf("curl_easy_strerror: %s", error);
+		cemuLog_logDebug(LogType::Force, "curl_easy_strerror: {}", error);
 		int len = (int)strlen(error) + 1;
 		result = coreinit_allocFromSysArea(len, 4);
 		memcpy(result.GetPtr(), error, len);
@@ -1256,21 +1440,16 @@ void export_curl_easy_strerror(PPCInterpreter_t* hCPU)
 	osLib_returnFromFunction(hCPU, result.GetMPTR());
 }
 
-void export_curl_slist_append(PPCInterpreter_t* hCPU)
+WU_curl_slist* curl_slist_append(WU_curl_slist* list, const char* data)
 {
-	ppcDefineParamMEMPTR(list, curl_slist_t, 0);
-	ppcDefineParamMEMPTR(data, const char, 1);
-
-
-	MEMPTR<char> dupdata{ PPCCoreCallback(g_nlibcurl.strdup.GetMPTR(), data.GetMPTR()) };
+	MEMPTR<char> dupdata{ PPCCoreCallback(g_nlibcurl.strdup.GetMPTR(), data) };
 	if (!dupdata)
 	{
-		forceLogDebug_printf("curl_slist_append(0x%08x, 0x%08x [%s]) -> 0x00000000", list.GetMPTR(), data.GetMPTR(), data.GetPtr());
-		osLib_returnFromFunction(hCPU, 0);
-		return;
+		cemuLog_logDebug(LogType::Force, "curl_slist_append(): Failed to duplicate string");
+		return nullptr;
 	}
 
-	MEMPTR<curl_slist_t> result{ PPCCoreCallback(g_nlibcurl.malloc.GetMPTR(), ppcsizeof<curl_slist_t>()) };
+	MEMPTR<WU_curl_slist> result{ PPCCoreCallback(g_nlibcurl.malloc.GetMPTR(), ppcsizeof<WU_curl_slist>()) };
 	if (result)
 	{
 		result->data = dupdata;
@@ -1279,7 +1458,7 @@ void export_curl_slist_append(PPCInterpreter_t* hCPU)
 		// update last obj of list
 		if (list)
 		{
-			MEMPTR<curl_slist_t> tmp = list;
+			MEMPTR<WU_curl_slist> tmp = list;
 			while (tmp->next)
 			{
 				tmp = tmp->next;
@@ -1289,38 +1468,24 @@ void export_curl_slist_append(PPCInterpreter_t* hCPU)
 		}
 	}
 	else
+	{
+		cemuLog_logDebug(LogType::Force, "curl_slist_append(): Failed to allocate memory");
 		PPCCoreCallback(g_nlibcurl.free.GetMPTR(), dupdata.GetMPTR());
-
-	forceLogDebug_printf("curl_slist_append(0x%08x, 0x%08x [%s]) -> 0x%08x", list.GetMPTR(), data.GetMPTR(), data.GetPtr(), result.GetMPTR());
+	}
 	if(list)
-		osLib_returnFromFunction(hCPU, list.GetMPTR());
-	else
-		osLib_returnFromFunction(hCPU, result.GetMPTR());
+		return list;
+	return result;
 }
 	
-void export_curl_slist_free_all(PPCInterpreter_t* hCPU)
+void curl_slist_free_all(WU_curl_slist* list)
 {
-	ppcDefineParamMEMPTR(list, curl_slist_t, 0);
-
-	forceLogDebug_printf("export_curl_slist_free_all: TODO");
-
-	osLib_returnFromFunction(hCPU, 0);
+	cemuLog_logDebug(LogType::Force, "export_curl_slist_free_all: TODO");
 }
 
-void export_curl_global_init_mem(PPCInterpreter_t* hCPU)
+CURLcode curl_global_init_mem(uint32 flags, MEMPTR<curl_malloc_callback> malloc_callback, MEMPTR<curl_free_callback> free_callback, MEMPTR<curl_realloc_callback> realloc_callback, MEMPTR<curl_strdup_callback> strdup_callback, MEMPTR<curl_calloc_callback> calloc_callback)
 {
-	ppcDefineParamU32(flags, 0);
-	ppcDefineParamMEMPTR(m, curl_malloc_callback, 1);
-	ppcDefineParamMEMPTR(f, curl_free_callback, 2);
-	ppcDefineParamMEMPTR(r, curl_realloc_callback, 3);
-	ppcDefineParamMEMPTR(s, curl_strdup_callback, 4);
-	ppcDefineParamMEMPTR(c, curl_calloc_callback, 5);
-
-	if (!m || !f || !r || !s || !c)
-	{
-		osLib_returnFromFunction(hCPU, CURLE_FAILED_INIT);
-		return;
-	}
+	if(!malloc_callback || !free_callback || !realloc_callback || !strdup_callback || !calloc_callback)
+		return CURLE_FAILED_INIT;
 
 	CURLcode result = CURLE_OK;
 	if (g_nlibcurl.initialized == 0)
@@ -1328,31 +1493,30 @@ void export_curl_global_init_mem(PPCInterpreter_t* hCPU)
 		result = curl_global_init(flags);
 		if (result == CURLE_OK)
 		{
-			g_nlibcurl.malloc = m;
-			g_nlibcurl.free = f;
-			g_nlibcurl.realloc = r;
-			g_nlibcurl.strdup = s;
-			g_nlibcurl.calloc = c;
+			g_nlibcurl.malloc = malloc_callback;
+			g_nlibcurl.free = free_callback;
+			g_nlibcurl.realloc = realloc_callback;
+			g_nlibcurl.strdup = strdup_callback;
+			g_nlibcurl.calloc = calloc_callback;
 		}
 	}
-
-	forceLogDebug_printf("curl_global_init_mem(0x%x, 0x%08x, 0x%08x, 0x%08x, 0x%08x, 0x%08x) -> 0x%08x", flags, m.GetMPTR(), f.GetMPTR(), r.GetMPTR(), s.GetMPTR(), c.GetMPTR(), result);
-	osLib_returnFromFunction(hCPU, result);
+	return result;
 }
 
 void load()
 {
-	osLib_addFunction("nlibcurl", "curl_global_init_mem", export_curl_global_init_mem);
-	osLib_addFunction("nlibcurl", "curl_global_init", export_curl_global_init);
+	cafeExportRegister("nlibcurl", curl_global_init_mem, LogType::nlibcurl);
+	cafeExportRegister("nlibcurl", curl_global_init, LogType::nlibcurl);
 
-	osLib_addFunction("nlibcurl", "curl_slist_append", export_curl_slist_append);
-	osLib_addFunction("nlibcurl", "curl_slist_free_all", export_curl_slist_free_all);
+	cafeExportRegister("nlibcurl", curl_slist_append, LogType::nlibcurl);
+	cafeExportRegister("nlibcurl", curl_slist_free_all, LogType::nlibcurl);
 	osLib_addFunction("nlibcurl", "curl_easy_strerror", export_curl_easy_strerror);
 
 	osLib_addFunction("nlibcurl", "curl_share_init", export_curl_share_init);
 	osLib_addFunction("nlibcurl", "curl_share_setopt", export_curl_share_setopt);
 	osLib_addFunction("nlibcurl", "curl_share_cleanup", export_curl_share_cleanup);
 
+	cafeExportRegister("nlibcurl", mw_curl_easy_init, LogType::nlibcurl);
 	osLib_addFunction("nlibcurl", "curl_multi_init", export_curl_multi_init);
 	osLib_addFunction("nlibcurl", "curl_multi_add_handle", export_curl_multi_add_handle);
 	osLib_addFunction("nlibcurl", "curl_multi_perform", export_curl_multi_perform);
@@ -1363,13 +1527,15 @@ void load()
 	osLib_addFunction("nlibcurl", "curl_multi_cleanup", export_curl_multi_cleanup);
 	osLib_addFunction("nlibcurl", "curl_multi_timeout", export_curl_multi_timeout);
 
-	osLib_addFunction("nlibcurl", "curl_easy_init", export_curl_easy_init);
-	osLib_addFunction("nlibcurl", "mw_curl_easy_init", export_curl_easy_init);
+	cafeExportRegister("nlibcurl", curl_easy_init, LogType::nlibcurl);
 	osLib_addFunction("nlibcurl", "curl_easy_reset", export_curl_easy_reset);
 	osLib_addFunction("nlibcurl", "curl_easy_setopt", export_curl_easy_setopt);
 	osLib_addFunction("nlibcurl", "curl_easy_getinfo", export_curl_easy_getinfo);
-	osLib_addFunction("nlibcurl", "curl_easy_perform", export_curl_easy_perform);
+	cafeExportRegister("nlibcurl", curl_easy_perform, LogType::nlibcurl);
+
+
+
 	osLib_addFunction("nlibcurl", "curl_easy_cleanup", export_curl_easy_cleanup);
 	osLib_addFunction("nlibcurl", "curl_easy_pause", export_curl_easy_pause);
 }
-}
+}
\ No newline at end of file
diff --git a/src/Cafe/OS/libs/nlibnss/nlibnss.cpp b/src/Cafe/OS/libs/nlibnss/nlibnss.cpp
index b4ea77dc..0c8ee288 100644
--- a/src/Cafe/OS/libs/nlibnss/nlibnss.cpp
+++ b/src/Cafe/OS/libs/nlibnss/nlibnss.cpp
@@ -5,7 +5,7 @@ namespace nlibnss
 {
 	int NSSExportDeviceCertChain(uint8* uknPtr1, uint32be* uknLength1, uint8* uknPtr2, uint32be* uknLength2, uint32 uknR7, uint32 uknR8)
 	{
-		forceLogDebug_printf("NSSExportDeviceCertChain called but not implemented");
+		cemuLog_logDebug(LogType::Force, "NSSExportDeviceCertChain called but not implemented");
 		cemu_assert_debug(false);
 
 		// uknR3 = pointer (can be null, in which case only length is written)
@@ -34,4 +34,4 @@ namespace nlibnss
 		cafeExportRegister("nlibnss", NSSSignatureGetSignatureLength, LogType::Placeholder);
 		cafeExportRegister("nlibnss", NSSExportDeviceCertChain, LogType::Placeholder);
 	}
-}
\ No newline at end of file
+}
diff --git a/src/Cafe/OS/libs/nn_ac/nn_ac.cpp b/src/Cafe/OS/libs/nn_ac/nn_ac.cpp
index 42d1b268..5f231499 100644
--- a/src/Cafe/OS/libs/nn_ac/nn_ac.cpp
+++ b/src/Cafe/OS/libs/nn_ac/nn_ac.cpp
@@ -8,83 +8,14 @@
 
 // AC lib (manages internet connection)
 
-#define AC_STATUS_FAILED (-1)
-#define AC_STATUS_OK (0)
-
-void nn_acExport_ConnectAsync(PPCInterpreter_t* hCPU)
+enum class AC_STATUS : uint32
 {
-	forceLogDebug_printf("nn_ac.ConnectAsync();");
-	uint32 nnResultCode = BUILD_NN_RESULT(NN_RESULT_LEVEL_SUCCESS, NN_RESULT_MODULE_NN_AC, 0);
-	osLib_returnFromFunction(hCPU, nnResultCode);
-}
-
-void nn_acExport_Connect(PPCInterpreter_t* hCPU)
-{
-	forceLogDebug_printf("nn_ac.Connect();");
-
-	// Terraria expects this (or GetLastErrorCode) to return 0 on success
-	// investigate on the actual console
-	// maybe all success codes are always 0 and dont have any of the other fields set?
-
-	uint32 nnResultCode = 0;// BUILD_NN_RESULT(NN_RESULT_LEVEL_SUCCESS, NN_RESULT_MODULE_NN_AC, 0); // Splatoon freezes if this function fails?
-	osLib_returnFromFunction(hCPU, nnResultCode);
-}
+	FAILED = (uint32)-1,
+	OK = 0,
+};
 
 static_assert(TRUE == 1, "TRUE not 1");
 
-void nn_acExport_IsApplicationConnected(PPCInterpreter_t* hCPU)
-{
-	//forceLogDebug_printf("nn_ac.IsApplicationConnected(0x%08x)", hCPU->gpr[3]);
-	ppcDefineParamMEMPTR(connected, uint8, 0);
-	if (connected)
-		*connected = TRUE;
-	//memory_writeU8(hCPU->gpr[3], 1); // always return true regardless of actual online state
-
-	const uint32 nnResultCode = BUILD_NN_RESULT(NN_RESULT_LEVEL_SUCCESS, NN_RESULT_MODULE_NN_AC, 0);
-	osLib_returnFromFunction(hCPU, nnResultCode);
-}
-
-void nn_acExport_GetConnectStatus(PPCInterpreter_t* hCPU)
-{
-	ppcDefineParamMEMPTR(status, uint32, 0);
-	if (status)
-		*status = AC_STATUS_OK;
-
-	const uint32 nnResultCode = BUILD_NN_RESULT(NN_RESULT_LEVEL_SUCCESS, NN_RESULT_MODULE_NN_AC, 0);
-	osLib_returnFromFunction(hCPU, nnResultCode);
-}
-
-void nn_acExport_GetLastErrorCode(PPCInterpreter_t* hCPU)
-{
-	//forceLogDebug_printf("nn_ac.GetLastErrorCode();");
-	ppcDefineParamMEMPTR(errorCode, uint32, 0);
-	if (errorCode)
-		*errorCode = 0;
-	const uint32 nnResultCode = BUILD_NN_RESULT(NN_RESULT_LEVEL_SUCCESS, NN_RESULT_MODULE_NN_AC, 0);
-	osLib_returnFromFunction(hCPU, nnResultCode);
-}
-
-void nn_acExport_GetStatus(PPCInterpreter_t* hCPU)
-{
-	forceLogDebug_printf("nn_ac.GetStatus();");
-	ppcDefineParamMEMPTR(status, uint32, 0);
-	if (status)
-		*status = AC_STATUS_OK;
-	const uint32 nnResultCode = BUILD_NN_RESULT(NN_RESULT_LEVEL_SUCCESS, NN_RESULT_MODULE_NN_AC, 0);
-	osLib_returnFromFunction(hCPU, nnResultCode);
-}
-
-void nn_acExport_GetConnectResult(PPCInterpreter_t* hCPU)
-{
-	// GetConnectStatus__Q2_2nn2acFPQ3_2nn2ac6Status
-	forceLogDebug_printf("nn_ac.GetConnectResult(0x%08x) LR %08x", hCPU->spr.LR, hCPU->gpr[3]);
-	ppcDefineParamMEMPTR(result, uint32, 0);
-	const uint32 nnResultCode = BUILD_NN_RESULT(NN_RESULT_LEVEL_SUCCESS, NN_RESULT_MODULE_NN_AC, 0);
-	if (result)
-		*result = nnResultCode;
-	osLib_returnFromFunction(hCPU, nnResultCode);
-}
-
 void _GetLocalIPAndSubnetMaskFallback(uint32& localIp, uint32& subnetMask)
 {
 	// default to some hardcoded values
@@ -159,7 +90,7 @@ void _GetLocalIPAndSubnetMask(uint32& localIp, uint32& subnetMask)
 
 void nnAcExport_GetAssignedAddress(PPCInterpreter_t* hCPU)
 {
-	forceLogDebug_printf("GetAssignedAddress() called");
+	cemuLog_logDebug(LogType::Force, "GetAssignedAddress() called");
 	ppcDefineParamU32BEPtr(ipAddrOut, 0);
 
 	uint32 localIp;
@@ -174,7 +105,7 @@ void nnAcExport_GetAssignedAddress(PPCInterpreter_t* hCPU)
 
 void nnAcExport_GetAssignedSubnet(PPCInterpreter_t* hCPU)
 {
-	forceLogDebug_printf("GetAssignedSubnet() called");
+	cemuLog_logDebug(LogType::Force, "GetAssignedSubnet() called");
 
 	ppcDefineParamU32BEPtr(subnetMaskOut, 0);
 
@@ -206,7 +137,7 @@ void nnAcExport_IsSystemConnected(PPCInterpreter_t* hCPU)
 	ppcDefineParamTypePtr(isConnectedOut, uint8, 0);
 	ppcDefineParamTypePtr(apTypeOut, uint32be, 1);
 
-	forceLogDebug_printf("nn_ac.IsSystemConnected() - placeholder");
+	cemuLog_logDebug(LogType::Force, "nn_ac.IsSystemConnected() - placeholder");
 	*apTypeOut = 0; // ukn
 	*isConnectedOut = 1;
 
@@ -215,7 +146,7 @@ void nnAcExport_IsSystemConnected(PPCInterpreter_t* hCPU)
 
 void nnAcExport_IsConfigExisting(PPCInterpreter_t* hCPU)
 {
-	forceLogDebug_printf("nn_ac.IsConfigExisting() - placeholder");
+	cemuLog_logDebug(LogType::Force, "nn_ac.IsConfigExisting() - placeholder");
 
 	ppcDefineParamU32(configId, 0);
 	ppcDefineParamTypePtr(isConfigExisting, uint8, 1);
@@ -227,37 +158,127 @@ void nnAcExport_IsConfigExisting(PPCInterpreter_t* hCPU)
 
 namespace nn_ac
 {
+	nnResult Initialize()
+	{
+		return BUILD_NN_RESULT(NN_RESULT_LEVEL_SUCCESS, NN_RESULT_MODULE_NN_AC, 0);
+	}
+
+	nnResult ConnectAsync()
+	{
+		return BUILD_NN_RESULT(NN_RESULT_LEVEL_SUCCESS, NN_RESULT_MODULE_NN_AC, 0);
+	}
+
+	nnResult IsApplicationConnected(uint8be* connected)
+	{
+		if (connected)
+			*connected = TRUE;
+		return BUILD_NN_RESULT(NN_RESULT_LEVEL_SUCCESS, NN_RESULT_MODULE_NN_AC, 0);
+	}
+
+	uint32 Connect()
+	{
+		// Terraria expects this (or GetLastErrorCode) to return 0 on success
+		// investigate on the actual console
+		// maybe all success codes are always 0 and dont have any of the other fields set?
+		uint32 nnResultCode = 0;// BUILD_NN_RESULT(NN_RESULT_LEVEL_SUCCESS, NN_RESULT_MODULE_NN_AC, 0); // Splatoon freezes if this function fails?
+		return nnResultCode;
+	}
+
+	nnResult GetConnectStatus(betype<AC_STATUS>* status)
+	{
+		if (status)
+			*status = AC_STATUS::OK;
+		return BUILD_NN_RESULT(NN_RESULT_LEVEL_SUCCESS, NN_RESULT_MODULE_NN_AC, 0);
+	}
+
+	nnResult GetStatus(betype<AC_STATUS>* status)
+	{
+		return GetConnectStatus(status);
+	}
+
+	nnResult GetLastErrorCode(uint32be* errorCode)
+	{
+		if (errorCode)
+			*errorCode = 0;
+		return BUILD_NN_RESULT(NN_RESULT_LEVEL_SUCCESS, NN_RESULT_MODULE_NN_AC, 0);
+	}
+
+	nnResult GetConnectResult(uint32be* connectResult)
+	{
+		const uint32 nnResultCode = BUILD_NN_RESULT(NN_RESULT_LEVEL_SUCCESS, NN_RESULT_MODULE_NN_AC, 0);
+		if (connectResult)
+			*connectResult = nnResultCode;
+		return nnResultCode;
+	}
+
+	static_assert(sizeof(betype<AC_STATUS>) == 4);
+	static_assert(sizeof(betype<nnResult>) == 4);
+
+	nnResult ACInitialize()
+	{
+		return Initialize();
+	}
+
 	bool ACIsSuccess(betype<nnResult>* r)
 	{
 		return NN_RESULT_IS_SUCCESS(*r) ? 1 : 0;
 	}
 
-	nnResult ACGetConnectStatus(uint32be* connectionStatus)
+	bool ACIsFailure(betype<nnResult>* r)
 	{
+		return NN_RESULT_IS_FAILURE(*r) ? 1 : 0;
+	}
 
-		*connectionStatus = 0; // 0 means connected?
+	nnResult ACGetConnectStatus(betype<AC_STATUS>* connectionStatus)
+	{
+		return GetConnectStatus(connectionStatus);
+	}
 
-		return NN_RESULT_SUCCESS;
+	nnResult ACGetStatus(betype<AC_STATUS>* connectionStatus)
+	{
+		return GetStatus(connectionStatus);
+	}
+
+	nnResult ACConnectAsync()
+	{
+		return ConnectAsync();
+	}
+
+	nnResult ACIsApplicationConnected(uint32be* connectedU32)
+	{
+		uint8be connected = 0;
+		nnResult r = IsApplicationConnected(&connected);
+		*connectedU32 = connected; // convert to uint32
+		return r;
 	}
 
 	void load()
 	{
+		cafeExportRegisterFunc(Initialize, "nn_ac", "Initialize__Q2_2nn2acFv", LogType::Placeholder);
+
+		cafeExportRegisterFunc(Connect, "nn_ac", "Connect__Q2_2nn2acFv", LogType::Placeholder);
+		cafeExportRegisterFunc(ConnectAsync, "nn_ac", "ConnectAsync__Q2_2nn2acFv", LogType::Placeholder);
+
+		cafeExportRegisterFunc(GetConnectResult, "nn_ac", "GetConnectResult__Q2_2nn2acFPQ2_2nn6Result", LogType::Placeholder);
+		cafeExportRegisterFunc(GetLastErrorCode, "nn_ac", "GetLastErrorCode__Q2_2nn2acFPUi", LogType::Placeholder);
+		cafeExportRegisterFunc(GetConnectStatus, "nn_ac", "GetConnectStatus__Q2_2nn2acFPQ3_2nn2ac6Status", LogType::Placeholder);
+		cafeExportRegisterFunc(GetStatus, "nn_ac", "GetStatus__Q2_2nn2acFPQ3_2nn2ac6Status", LogType::Placeholder);
+		cafeExportRegisterFunc(IsApplicationConnected, "nn_ac", "IsApplicationConnected__Q2_2nn2acFPb", LogType::Placeholder);
+
+		// AC also offers C-style wrappers
+		cafeExportRegister("nn_ac", ACInitialize, LogType::Placeholder);
 		cafeExportRegister("nn_ac", ACIsSuccess, LogType::Placeholder);
+		cafeExportRegister("nn_ac", ACIsFailure, LogType::Placeholder);
 		cafeExportRegister("nn_ac", ACGetConnectStatus, LogType::Placeholder);
+		cafeExportRegister("nn_ac", ACGetStatus, LogType::Placeholder);
+		cafeExportRegister("nn_ac", ACConnectAsync, LogType::Placeholder);
+		cafeExportRegister("nn_ac", ACIsApplicationConnected, LogType::Placeholder);
 	}
 
 }
 
 void nnAc_load()
 {
-	osLib_addFunction("nn_ac", "Connect__Q2_2nn2acFv", nn_acExport_Connect);
-	osLib_addFunction("nn_ac", "ConnectAsync__Q2_2nn2acFv", nn_acExport_ConnectAsync);
-	osLib_addFunction("nn_ac", "IsApplicationConnected__Q2_2nn2acFPb", nn_acExport_IsApplicationConnected);
-	osLib_addFunction("nn_ac", "GetConnectStatus__Q2_2nn2acFPQ3_2nn2ac6Status", nn_acExport_GetConnectStatus);
-	osLib_addFunction("nn_ac", "GetConnectResult__Q2_2nn2acFPQ2_2nn6Result", nn_acExport_GetConnectResult);
-	osLib_addFunction("nn_ac", "GetLastErrorCode__Q2_2nn2acFPUi", nn_acExport_GetLastErrorCode);
-	osLib_addFunction("nn_ac", "GetStatus__Q2_2nn2acFPQ3_2nn2ac6Status", nn_acExport_GetStatus);
-
 	osLib_addFunction("nn_ac", "GetAssignedAddress__Q2_2nn2acFPUl", nnAcExport_GetAssignedAddress);
 	osLib_addFunction("nn_ac", "GetAssignedSubnet__Q2_2nn2acFPUl", nnAcExport_GetAssignedSubnet);
 
diff --git a/src/Cafe/OS/libs/nn_acp/nn_acp.cpp b/src/Cafe/OS/libs/nn_acp/nn_acp.cpp
index 3200cf62..9cde0213 100644
--- a/src/Cafe/OS/libs/nn_acp/nn_acp.cpp
+++ b/src/Cafe/OS/libs/nn_acp/nn_acp.cpp
@@ -17,6 +17,8 @@
 #include "Common/FileStream.h"
 #include "Cafe/CafeSystem.h"
 
+using ACPDeviceType = iosu::acp::ACPDeviceType;
+
 #define acpPrepareRequest() \
 StackAllocator<iosuAcpCemuRequest_t> _buf_acpRequest; \
 StackAllocator<ioBufferVector_t> _buf_bufferVector; \
@@ -30,12 +32,14 @@ namespace nn
 {
 namespace acp
 {
-	ACPStatus _ACPConvertResultToACPStatus(uint32* nnResult, const char* functionName, uint32 someConstant)
+	ACPStatus ACPConvertResultToACPStatus(uint32* nnResult, const char* functionName, uint32 lineNumber)
 	{
 		// todo
 		return ACPStatus::SUCCESS;
 	}
 
+	#define _ACPConvertResultToACPStatus(nnResult) ACPConvertResultToACPStatus(nnResult, __func__, __LINE__)
+
 	ACPStatus ACPGetApplicationBox(uint32be* applicationBox, uint64 titleId)
 	{
 		// todo
@@ -43,8 +47,17 @@ namespace acp
 		return ACPStatus::SUCCESS;
 	}
 
+	ACPStatus ACPGetOlvAccesskey(uint32be* accessKey)
+	{
+		nnResult r = iosu::acp::ACPGetOlvAccesskey(accessKey);
+		return _ACPConvertResultToACPStatus(&r);
+	}
+
+    bool sSaveDirMounted{false};
+
 	ACPStatus ACPMountSaveDir()
 	{
+        cemu_assert_debug(!sSaveDirMounted);
 		uint64 titleId = CafeSystem::GetForegroundTitleId();
 		uint32 high = GetTitleIdHigh(titleId) & (~0xC);
 		uint32 low = GetTitleIdLow(titleId);
@@ -53,204 +66,34 @@ namespace acp
 		const auto mlc = ActiveSettings::GetMlcPath("usr/save/{:08x}/{:08x}/user/", high, low);
 		FSCDeviceHostFS_Mount("/vol/save/", _pathToUtf8(mlc), FSC_PRIORITY_BASE);
 		nnResult mountResult = BUILD_NN_RESULT(NN_RESULT_LEVEL_SUCCESS, NN_RESULT_MODULE_NN_ACP, 0);
-		return _ACPConvertResultToACPStatus(&mountResult, "ACPMountSaveDir", 0x60);
+		return _ACPConvertResultToACPStatus(&mountResult);
 	}
 
-	uint64 _acpGetTimestamp()
-	{
-		return coreinit::coreinit_getOSTime() / ESPRESSO_TIMER_CLOCK;
-	}
-
-	nnResult __ACPUpdateSaveTimeStamp(uint32 persistentId, uint64 titleId, ACPDeviceType deviceType)
-	{
-		if (deviceType == UnknownType)
-		{
-			return (nnResult)0xA030FB80;
-		}
-
-		// create or modify the saveinfo
-		const auto saveinfoPath = ActiveSettings::GetMlcPath("usr/save/{:08x}/{:08x}/meta/saveinfo.xml", GetTitleIdHigh(titleId), GetTitleIdLow(titleId));
-		auto saveinfoData = FileStream::LoadIntoMemory(saveinfoPath);
-		if (saveinfoData && !saveinfoData->empty())
-		{
-			namespace xml = tinyxml2;
-			xml::XMLDocument doc;
-			tinyxml2::XMLError xmlError = doc.Parse((const char*)saveinfoData->data(), saveinfoData->size());
-			if (xmlError == xml::XML_SUCCESS || xmlError == xml::XML_ERROR_EMPTY_DOCUMENT)
-			{
-				xml::XMLNode* child = doc.FirstChild();
-				// check for declaration -> <?xml version="1.0" encoding="utf-8"?>
-				if (!child || !child->ToDeclaration())
-				{
-					xml::XMLDeclaration* decl = doc.NewDeclaration();
-					doc.InsertFirstChild(decl);
-				}
-
-				xml::XMLElement* info = doc.FirstChildElement("info");
-				if (!info)
-				{
-					info = doc.NewElement("info");
-					doc.InsertEndChild(info);
-				}
-
-				// find node with persistentId
-				char tmp[64];
-				sprintf(tmp, "%08x", persistentId);
-				bool foundNode = false;
-				for (xml::XMLElement* account = info->FirstChildElement("account"); account; account = account->NextSiblingElement("account"))
-				{
-					if (account->Attribute("persistentId", tmp))
-					{
-						// found the entry! -> update timestamp
-						xml::XMLElement* timestamp = account->FirstChildElement("timestamp");
-						sprintf(tmp, "%" PRIx64, _acpGetTimestamp());
-						if (timestamp)
-							timestamp->SetText(tmp);
-						else
-						{
-							timestamp = doc.NewElement("timestamp");
-							account->InsertFirstChild(timestamp);
-						}
-
-						foundNode = true;
-						break;
-					}
-				}
-
-				if (!foundNode)
-				{
-					tinyxml2::XMLElement* account = doc.NewElement("account");
-					{
-						sprintf(tmp, "%08x", persistentId);
-						account->SetAttribute("persistentId", tmp);
-
-						tinyxml2::XMLElement* timestamp = doc.NewElement("timestamp");
-						{
-							sprintf(tmp, "%" PRIx64, _acpGetTimestamp());
-							timestamp->SetText(tmp);
-						}
-
-						account->InsertFirstChild(timestamp);
-					}
-
-					info->InsertFirstChild(account);
-				}
-
-				// update file
-				tinyxml2::XMLPrinter printer;
-				doc.Print(&printer);
-				FileStream* fs = FileStream::createFile2(saveinfoPath);
-				if (fs)
-				{
-					fs->writeString(printer.CStr());
-					delete fs;
-				}
-			}
-		}
-		return NN_RESULT_SUCCESS;
-	}
+    ACPStatus ACPUnmountSaveDir()
+    {
+        cemu_assert_debug(!sSaveDirMounted);
+        fsc_unmount("/vol/save/", FSC_PRIORITY_BASE);
+        return ACPStatus::SUCCESS;
+    }
 
 	ACPStatus ACPUpdateSaveTimeStamp(uint32 persistentId, uint64 titleId, ACPDeviceType deviceType)
 	{
-		nnResult r = __ACPUpdateSaveTimeStamp(persistentId, titleId, deviceType);
+		nnResult r = iosu::acp::ACPUpdateSaveTimeStamp(persistentId, titleId, deviceType);
 		return ACPStatus::SUCCESS;
 	}
 
-	void CreateSaveMetaFiles(uint32 persistentId, uint64 titleId)
-	{
-		std::string titlePath = CafeSystem::GetMlcStoragePath(CafeSystem::GetForegroundTitleId());
-
-		sint32 fscStatus;
-		FSCVirtualFile* fscFile = fsc_open((titlePath + "/meta/meta.xml").c_str(), FSC_ACCESS_FLAG::OPEN_FILE | FSC_ACCESS_FLAG::READ_PERMISSION, &fscStatus);
-		if (fscFile)
-		{
-			sint32 fileSize = fsc_getFileSize(fscFile);
-
-			std::unique_ptr<uint8[]> fileContent = std::make_unique<uint8[]>(fileSize);
-			fsc_readFile(fscFile, fileContent.get(), fileSize);
-			fsc_close(fscFile);
-
-			const auto outPath = ActiveSettings::GetMlcPath("usr/save/{:08x}/{:08x}/meta/meta.xml", GetTitleIdHigh(titleId), GetTitleIdLow(titleId));
-
-			std::ofstream myFile(outPath, std::ios::out | std::ios::binary);
-			myFile.write((char*)fileContent.get(), fileSize);
-			myFile.close();
-		}
-
-		fscFile = fsc_open((titlePath + "/meta/iconTex.tga").c_str(), FSC_ACCESS_FLAG::OPEN_FILE | FSC_ACCESS_FLAG::READ_PERMISSION, &fscStatus);
-		if (fscFile)
-		{
-			sint32 fileSize = fsc_getFileSize(fscFile);
-
-			std::unique_ptr<uint8[]> fileContent = std::make_unique<uint8[]>(fileSize);
-			fsc_readFile(fscFile, fileContent.get(), fileSize);
-			fsc_close(fscFile);
-
-			const auto outPath = ActiveSettings::GetMlcPath("usr/save/{:08x}/{:08x}/meta/iconTex.tga", GetTitleIdHigh(titleId), GetTitleIdLow(titleId));
-
-			std::ofstream myFile(outPath, std::ios::out | std::ios::binary);
-			myFile.write((char*)fileContent.get(), fileSize);
-			myFile.close();
-		}
-
-		ACPUpdateSaveTimeStamp(persistentId, titleId, InternalDeviceType);
-	}
-
-	nnResult CreateSaveDir(uint32 persistentId, ACPDeviceType type)
-	{
-		uint64 titleId = CafeSystem::GetForegroundTitleId();
-		uint32 high = GetTitleIdHigh(titleId) & (~0xC);
-		uint32 low = GetTitleIdLow(titleId);
-
-		sint32 fscStatus = FSC_STATUS_FILE_NOT_FOUND;
-		char path[256];
-
-		sprintf(path, "%susr/save/%08x/", "/vol/storage_mlc01/", high);
-		fsc_createDir(path, &fscStatus);
-		sprintf(path, "%susr/save/%08x/%08x/", "/vol/storage_mlc01/", high, low);
-		fsc_createDir(path, &fscStatus);
-		sprintf(path, "%susr/save/%08x/%08x/meta/", "/vol/storage_mlc01/", high, low);
-		fsc_createDir(path, &fscStatus);
-		sprintf(path, "%susr/save/%08x/%08x/user/", "/vol/storage_mlc01/", high, low);
-		fsc_createDir(path, &fscStatus);
-		sprintf(path, "%susr/save/%08x/%08x/user/common", "/vol/storage_mlc01/", high, low);
-		fsc_createDir(path, &fscStatus);
-		sprintf(path, "%susr/save/%08x/%08x/user/%08x", "/vol/storage_mlc01/", high, low, persistentId == 0 ? 0x80000001 : persistentId);
-		fsc_createDir(path, &fscStatus);
-
-		// not sure about this
-		sprintf(path, "%susr/boss/", "/vol/storage_mlc01/");
-		fsc_createDir(path, &fscStatus);
-		sprintf(path, "%susr/boss/%08x/", "/vol/storage_mlc01/", high);
-		fsc_createDir(path, &fscStatus);
-		sprintf(path, "%susr/boss/%08x/%08x/", "/vol/storage_mlc01/", high, low);
-		fsc_createDir(path, &fscStatus);
-		sprintf(path, "%susr/boss/%08x/%08x/user/", "/vol/storage_mlc01/", high, low);
-		fsc_createDir(path, &fscStatus);
-		sprintf(path, "%susr/boss/%08x/%08x/user/common", "/vol/storage_mlc01/", high, low);
-		fsc_createDir(path, &fscStatus);
-		sprintf(path, "%susr/boss/%08x/%08x/user/%08x/", "/vol/storage_mlc01/", high, low, persistentId == 0 ? 0x80000001 : persistentId);
-		fsc_createDir(path, &fscStatus);
-
-		// copy xml meta files
-		CreateSaveMetaFiles(persistentId, titleId);
-
-		nnResult result = BUILD_NN_RESULT(NN_RESULT_LEVEL_SUCCESS, NN_RESULT_MODULE_NN_ACP, 0);
-		return result;
-	}
-
-	ACPStatus ACPCreateSaveDir(uint32 persistentId, ACPDeviceType type)
-	{
-		nnResult result = CreateSaveDir(persistentId, type);
-		return _ACPConvertResultToACPStatus(&result, "ACPCreateSaveDir", 0x2FA);
-	}
-
 	ACPStatus ACPCheckApplicationDeviceEmulation(uint32be* isEmulated)
 	{
 		*isEmulated = 0;
 		return ACPStatus::SUCCESS;
 	}
 
+	ACPStatus ACPCreateSaveDir(uint32 persistentId, ACPDeviceType type)
+	{
+		nnResult result = iosu::acp::ACPCreateSaveDir(persistentId, type);
+		return _ACPConvertResultToACPStatus(&result);
+	}
+
 	nnResult ACPCreateSaveDirEx(uint8 accountSlot, uint64 titleId)
 	{
 		acpPrepareRequest();
@@ -269,7 +112,7 @@ namespace acp
 		ppcDefineParamU8(accountSlot, 0);
 		ppcDefineParamU64(titleId, 2); // index 2 because of alignment -> guessed parameters
 		nnResult result = ACPCreateSaveDirEx(accountSlot, titleId);
-		osLib_returnFromFunction(hCPU, _ACPConvertResultToACPStatus(&result, "ACPCreateSaveDirEx", 0x300));
+		osLib_returnFromFunction(hCPU, _ACPConvertResultToACPStatus(&result));
 	}
 
 	void export_ACPGetSaveDataTitleIdList(PPCInterpreter_t* hCPU)
@@ -350,7 +193,7 @@ namespace acp
 	void export_ACPCheckTitleNotReferAccountLaunch(PPCInterpreter_t* hCPU)
 	{
 		ppcDefineParamU64(titleId, 0);
-		forceLogDebug_printf("ACPCheckTitleNotReferAccountLaunch(): Placeholder");
+		cemuLog_logDebug(LogType::Force, "ACPCheckTitleNotReferAccountLaunch(): Placeholder");
 
 		osLib_returnFromFunction(hCPU, 0);
 	}
@@ -359,7 +202,7 @@ namespace acp
 	{
 		ppcDefineParamStructPtr(acpMetaData, acpMetaData_t, 0);
 		
-		forceLogDebug_printf("ACPGetLaunchMetaData(): Placeholder");
+		cemuLog_logDebug(LogType::Force, "ACPGetLaunchMetaData(): Placeholder");
 
 		acpPrepareRequest();
 		acpRequest->requestCode = IOSU_ACP_GET_TITLE_META_DATA;
@@ -375,7 +218,7 @@ namespace acp
 	{
 		ppcDefineParamStructPtr(acpMetaXml, acpMetaXml_t, 0);
 
-		forceLogDebug_printf("ACPGetLaunchMetaXml(): Placeholder");
+		cemuLog_logDebug(LogType::Force, "ACPGetLaunchMetaXml(): Placeholder");
 
 		acpPrepareRequest();
 		acpRequest->requestCode = IOSU_ACP_GET_TITLE_META_XML;
@@ -434,18 +277,30 @@ namespace acp
 		ppcDefineParamU32(deviceId, 3);
 
 		if (deviceId != 3)
-			assert_dbg();
+			cemuLog_logDebug(LogType::Force, "ACPGetTitleMetaXmlByDevice(): Unsupported deviceId");
 
 		acpPrepareRequest();
 		acpRequest->requestCode = IOSU_ACP_GET_TITLE_META_XML;
 		acpRequest->ptr = acpMetaXml;
-		acpRequest->titleId = CafeSystem::GetForegroundTitleId();
+		acpRequest->titleId = titleId;//CafeSystem::GetForegroundTitleId();
 
 		__depr__IOS_Ioctlv(IOS_DEVICE_ACP_MAIN, IOSU_ACP_REQUEST_CEMU, 1, 1, acpBufferVector);
 
 		osLib_returnFromFunction(hCPU, acpRequest->returnCode);
 	}
 
+	uint32 ACPGetTitleMetaXml(uint64 titleId, acpMetaXml_t* acpMetaXml)
+	{
+		acpPrepareRequest();
+		acpRequest->requestCode = IOSU_ACP_GET_TITLE_META_XML;
+		acpRequest->ptr = acpMetaXml;
+		acpRequest->titleId = titleId;
+
+		__depr__IOS_Ioctlv(IOS_DEVICE_ACP_MAIN, IOSU_ACP_REQUEST_CEMU, 1, 1, acpBufferVector);
+
+		return acpRequest->returnCode;
+	}
+
 	void export_ACPIsOverAgeEx(PPCInterpreter_t* hCPU)
 	{
 		ppcDefineParamU32(age, 0);
@@ -460,7 +315,7 @@ namespace acp
 		ppcDefineParamU32BEPtr(timestamp64, 0);
 		ppcDefineParamU32BEPtr(ukn, 1); // probably timezone or offset? Could also be a bool for success/failed
 
-		uint64 t = coreinit::coreinit_getOSTime() + (uint64)((sint64)(ppcCyclesSince2000_UTC - ppcCyclesSince2000) / 20LL);
+		uint64 t = coreinit::OSGetTime() + (uint64)((sint64)(ppcCyclesSince2000_UTC - ppcCyclesSince2000) / 20LL);
 
 		timestamp64[0] = (uint32)(t >> 32);
 		timestamp64[1] = (uint32)(t & 0xFFFFFFFF);
@@ -498,9 +353,12 @@ namespace acp
 
 		osLib_addFunction("nn_acp", "ACPGetTitleMetaDirByDevice", export_ACPGetTitleMetaDirByDevice);
 		osLib_addFunction("nn_acp", "ACPGetTitleMetaXmlByDevice", export_ACPGetTitleMetaXmlByDevice);
+		cafeExportRegister("nn_acp", ACPGetTitleMetaXml, LogType::Placeholder);
 
 		cafeExportRegister("nn_acp", ACPGetApplicationBox, LogType::Placeholder);
 
+		cafeExportRegister("nn_acp", ACPGetOlvAccesskey, LogType::Placeholder);
+
 		osLib_addFunction("nn_acp", "ACPIsOverAgeEx", export_ACPIsOverAgeEx);
 
 		osLib_addFunction("nn_acp", "ACPGetNetworkTime", export_ACPGetNetworkTime);
diff --git a/src/Cafe/OS/libs/nn_acp/nn_acp.h b/src/Cafe/OS/libs/nn_acp/nn_acp.h
index 33a9c487..9890a6df 100644
--- a/src/Cafe/OS/libs/nn_acp/nn_acp.h
+++ b/src/Cafe/OS/libs/nn_acp/nn_acp.h
@@ -1,4 +1,5 @@
 #pragma once
+#include "Cafe/IOSU/legacy/iosu_acp.h"
 
 namespace nn
 {
@@ -9,19 +10,13 @@ namespace acp
 		SUCCESS = 0,
 	};
 
-	enum ACPDeviceType
-	{
-		UnknownType = 0,
-		InternalDeviceType = 1,
-		USBDeviceType = 3,
-	};
-
-	void CreateSaveMetaFiles(uint32 persistentId, uint64 titleId);
+	using ACPDeviceType = iosu::acp::ACPDeviceType;
 
 	ACPStatus ACPGetApplicationBox(uint32be* applicationBox, uint64 titleId);
 	ACPStatus ACPMountSaveDir();
-	ACPStatus ACPCreateSaveDir(uint32 persistentId, ACPDeviceType type);
-	ACPStatus ACPUpdateSaveTimeStamp(uint32 persistentId, uint64 titleId, ACPDeviceType deviceType);;
+    ACPStatus ACPUnmountSaveDir();
+	ACPStatus ACPCreateSaveDir(uint32 persistentId, iosu::acp::ACPDeviceType type);
+	ACPStatus ACPUpdateSaveTimeStamp(uint32 persistentId, uint64 titleId, iosu::acp::ACPDeviceType deviceType);
 
 	void load();
 }
diff --git a/src/Cafe/OS/libs/nn_act/nn_act.cpp b/src/Cafe/OS/libs/nn_act/nn_act.cpp
index 9ca33754..f9e74355 100644
--- a/src/Cafe/OS/libs/nn_act/nn_act.cpp
+++ b/src/Cafe/OS/libs/nn_act/nn_act.cpp
@@ -5,6 +5,7 @@
 #include "nn_act.h"
 #include "Cafe/OS/libs/nn_common.h"
 #include "Cafe/CafeSystem.h"
+#include "Common/CafeString.h"
 
 sint32 numAccounts = 1;
 
@@ -95,6 +96,60 @@ namespace act
 			return result;
 		}
 
+		uint32 GetTransferableIdEx(uint64* transferableId, uint32 unique, uint8 slot)
+		{
+			actPrepareRequest2();
+			actRequest->requestCode = IOSU_ARC_TRANSFERABLEID;
+			actRequest->accountSlot = slot;
+			actRequest->unique = unique;
+
+			uint32 result = _doCemuActRequest(actRequest);
+
+			*transferableId = _swapEndianU64(actRequest->resultU64.u64);
+
+			return result;
+		}
+
+		uint32 AcquireIndependentServiceToken(independentServiceToken_t* token, const char* clientId, uint32 cacheDurationInSeconds)
+		{
+			memset(token, 0, sizeof(independentServiceToken_t));
+			actPrepareRequest();
+			actRequest->accountSlot = iosu::act::ACT_SLOT_CURRENT;
+			actRequest->requestCode = IOSU_ARC_ACQUIREINDEPENDENTTOKEN;
+			actRequest->titleId = CafeSystem::GetForegroundTitleId();
+			actRequest->titleVersion = CafeSystem::GetForegroundTitleVersion();
+			actRequest->expiresIn = cacheDurationInSeconds;
+			strcpy(actRequest->clientId, clientId);
+
+			uint32 resultCode = __depr__IOS_Ioctlv(IOS_DEVICE_ACT, IOSU_ACT_REQUEST_CEMU, 1, 1, actBufferVector);
+
+			memcpy(token, actRequest->resultBinary.binBuffer, sizeof(independentServiceToken_t));
+			return getNNReturnCode(resultCode, actRequest);
+		}
+
+		sint64 GetUtcOffset()
+		{
+			return ((ppcCyclesSince2000 / ESPRESSO_CORE_CLOCK) - (ppcCyclesSince2000_UTC / ESPRESSO_CORE_CLOCK)) * 1'000'000;
+		}
+
+		sint32 GetUtcOffsetEx(sint64be* pOutOffset, uint8 slotNo)
+		{
+
+			if (!pOutOffset)
+				return 0xc0712c80;
+
+			*pOutOffset = GetUtcOffset();
+			return 0;
+		}
+
+		nnResult GetTimeZoneId(CafeString<65>* outTimezoneId)
+		{
+			// return a placeholder timezone id for now
+			// in the future we should emulated this correctly and read the timezone from the account via IOSU
+			outTimezoneId->assign("Europe/London");
+			return 0;
+		}
+
 		sint32 g_initializeCount = 0; // inc in Initialize and dec in Finalize
 		uint32 Initialize()
 		{
@@ -117,27 +172,26 @@ namespace act
 			NN_ERROR_CODE errCode = NNResultToErrorCode(*nnResult, NN_RESULT_MODULE_NN_ACT);
 			return errCode;
 		}
-
 	}
 }
 
 
 void nnActExport_CreateConsoleAccount(PPCInterpreter_t* hCPU)
 {
-	forceLogDebug_printf("CreateConsoleAccount(...) LR %08x", hCPU->spr.LR);
+	cemuLog_logDebug(LogType::Force, "CreateConsoleAccount(...)");
 	//numAccounts++;
 	osLib_returnFromFunction(hCPU, 0);
 }
 
 void nnActExport_GetNumOfAccounts(PPCInterpreter_t* hCPU)
 {
-	forceLogDebug_printf("nn_act.GetNumOfAccounts()\n");
+	cemuLog_logDebug(LogType::Force, "nn_act.GetNumOfAccounts()");
 	osLib_returnFromFunction(hCPU, numAccounts); // account count
 }
 
 void nnActExport_IsSlotOccupied(PPCInterpreter_t* hCPU)
 {
-	forceLogDebug_printf("nn_act.IsSlotOccupied(%d)\n", hCPU->gpr[3]);
+	cemuLog_logDebug(LogType::Force, "nn_act.IsSlotOccupied({})", hCPU->gpr[3]);
 	ppcDefineParamU8(slot, 0);
 	
 	osLib_returnFromFunction(hCPU, nn::act::GetPersistentIdEx(slot) != 0 ? 1 : 0);
@@ -170,21 +224,6 @@ uint32 GetPrincipalIdEx(uint32be* principalId, uint8 slot)
 	return result;
 }
 
-
-uint32 GetTransferableIdEx(uint64* transferableId, uint32 unique, uint8 slot)
-{
-	actPrepareRequest2();
-	actRequest->requestCode = IOSU_ARC_TRANSFERABLEID;
-	actRequest->accountSlot = slot;
-	actRequest->unique = unique;
-
-	uint32 result = _doCemuActRequest(actRequest);
-
-	*transferableId = _swapEndianU64(actRequest->resultU64.u64);
-
-	return result;
-}
-
 uint32 GetCountryEx(char* country, uint8 slot)
 {
 	actPrepareRequest2();
@@ -213,7 +252,7 @@ uint32 IsNetworkAccount(uint8* isNetworkAccount, uint8 slot)
 
 void nnActExport_IsNetworkAccount(PPCInterpreter_t* hCPU)
 {
-	//forceLogDebug_printf("nn_act.IsNetworkAccount()\n");
+	//cemuLog_logDebug(LogType::Force, "nn_act.IsNetworkAccount()");
 	uint8 isNetAcc = 0;
 	IsNetworkAccount(&isNetAcc, 0xFE);
 	osLib_returnFromFunction(hCPU, isNetAcc);
@@ -222,7 +261,7 @@ void nnActExport_IsNetworkAccount(PPCInterpreter_t* hCPU)
 void nnActExport_IsNetworkAccountEx(PPCInterpreter_t* hCPU)
 {
 	ppcDefineParamU8(slot, 0);
-	forceLogDebug_printf("nn_act.IsNetworkAccountEx(%d)\n", slot);
+	cemuLog_logDebug(LogType::Force, "nn_act.IsNetworkAccountEx({})", slot);
 	uint8 isNetAcc = 0;
 	IsNetworkAccount(&isNetAcc, slot);
 	osLib_returnFromFunction(hCPU, isNetAcc);
@@ -230,7 +269,7 @@ void nnActExport_IsNetworkAccountEx(PPCInterpreter_t* hCPU)
 
 void nnActExport_GetSimpleAddressId(PPCInterpreter_t* hCPU)
 {
-	forceLogDebug_printf("nn_act.GetSimpleAddressId()\n");
+	cemuLog_logDebug(LogType::Force, "nn_act.GetSimpleAddressId()");
 
 	uint32be simpleAddressId;
 	nn::act::GetSimpleAddressIdEx(&simpleAddressId, iosu::act::ACT_SLOT_CURRENT);
@@ -240,7 +279,7 @@ void nnActExport_GetSimpleAddressId(PPCInterpreter_t* hCPU)
 
 void nnActExport_GetSimpleAddressIdEx(PPCInterpreter_t* hCPU)
 {
-	forceLogDebug_printf("nn_act.GetSimpleAddressIdEx(0x%08x, %d)\n", hCPU->gpr[3], hCPU->gpr[4] & 0xFF);
+	cemuLog_logDebug(LogType::Force, "nn_act.GetSimpleAddressIdEx(0x{:08x}, {})", hCPU->gpr[3], hCPU->gpr[4] & 0xFF);
 
 	ppcDefineParamU32BEPtr(simpleAddressId, 0);
 	ppcDefineParamU8(slot, 1);
@@ -253,7 +292,6 @@ void nnActExport_GetSimpleAddressIdEx(PPCInterpreter_t* hCPU)
 void nnActExport_GetPrincipalId(PPCInterpreter_t* hCPU)
 {
 	// return error for non-nnid accounts?
-	forceLogDebug_printf("nn_act.GetPrincipalId()\n");
 	uint32be principalId;
 	GetPrincipalIdEx(&principalId, iosu::act::ACT_SLOT_CURRENT);
 	osLib_returnFromFunction(hCPU, (uint32)principalId);
@@ -262,7 +300,7 @@ void nnActExport_GetPrincipalId(PPCInterpreter_t* hCPU)
 void nnActExport_GetPrincipalIdEx(PPCInterpreter_t* hCPU)
 {
 	// return error for non-nnid accounts?
-	forceLogDebug_printf("nn_act.GetPrincipalIdEx(0x%08x, %d)\n", hCPU->gpr[3], hCPU->gpr[4]&0xFF);
+	cemuLog_logDebug(LogType::Force, "nn_act.GetPrincipalIdEx(0x{:08x}, {})", hCPU->gpr[3], hCPU->gpr[4]&0xFF);
 	ppcDefineParamU32BEPtr(principalId, 0);
 	ppcDefineParamU8(slot, 1);
 	GetPrincipalIdEx(principalId, slot);
@@ -270,22 +308,38 @@ void nnActExport_GetPrincipalIdEx(PPCInterpreter_t* hCPU)
 	osLib_returnFromFunction(hCPU, 0); // ResultSuccess
 }
 
+void nnActExport_GetTransferableId(PPCInterpreter_t* hCPU)
+{
+	ppcDefineParamU32(unique, 0);
+
+	cemuLog_logDebug(LogType::Force, "nn_act.GetTransferableId(0x{:08x})", hCPU->gpr[3]);
+
+	uint64 transferableId;
+	uint32 r = nn::act::GetTransferableIdEx(&transferableId, unique, iosu::act::ACT_SLOT_CURRENT);
+	if (NN_RESULT_IS_FAILURE(r))
+	{
+		transferableId = 0;
+	}
+
+	osLib_returnFromFunction64(hCPU, _swapEndianU64(transferableId));
+}
+
 void nnActExport_GetTransferableIdEx(PPCInterpreter_t* hCPU)
 {
 	ppcDefineParamStructPtr(transferableId, uint64, 0);
 	ppcDefineParamU32(unique, 1);
 	ppcDefineParamU8(slot, 2);
 
-	forceLogDebug_printf("nn_act.GetTransferableIdEx(0x%08x, 0x%08x, %d)", hCPU->gpr[3], hCPU->gpr[4], hCPU->gpr[5] & 0xFF);
+	cemuLog_logDebug(LogType::Force, "nn_act.GetTransferableIdEx(0x{:08x}, 0x{:08x}, {})", hCPU->gpr[3], hCPU->gpr[4], hCPU->gpr[5] & 0xFF);
 	
-	uint32 r = GetTransferableIdEx(transferableId, unique, slot);
+	uint32 r = nn::act::GetTransferableIdEx(transferableId, unique, slot);
 
 	osLib_returnFromFunction(hCPU, 0); // ResultSuccess
 }
 
 void nnActExport_GetPersistentId(PPCInterpreter_t* hCPU)
 {
-	forceLogDebug_printf("nn_act.GetPersistentId()");
+	cemuLog_logDebug(LogType::Force, "nn_act.GetPersistentId()");
 	uint32 persistentId = nn::act::GetPersistentIdEx(iosu::act::ACT_SLOT_CURRENT);
 	osLib_returnFromFunction(hCPU, persistentId);
 }
@@ -293,7 +347,7 @@ void nnActExport_GetPersistentId(PPCInterpreter_t* hCPU)
 void nnActExport_GetPersistentIdEx(PPCInterpreter_t* hCPU)
 {
 	ppcDefineParamU8(slot, 0);
-	forceLogDebug_printf("nn_act.GetPersistentIdEx(%d)", slot);
+	cemuLog_logDebug(LogType::Force, "nn_act.GetPersistentIdEx({})", slot);
 
 	uint32 persistentId = nn::act::GetPersistentIdEx(slot);
 
@@ -302,7 +356,7 @@ void nnActExport_GetPersistentIdEx(PPCInterpreter_t* hCPU)
 
 void nnActExport_GetCountry(PPCInterpreter_t* hCPU)
 {
-	forceLogDebug_printf("nn_act.GetCountry(0x%08x)", hCPU->gpr[3]);
+	cemuLog_logDebug(LogType::Force, "nn_act.GetCountry(0x{:08x})", hCPU->gpr[3]);
 	ppcDefineParamStr(country, 0);
 	uint32 r = GetCountryEx(country, iosu::act::ACT_SLOT_CURRENT);
 	osLib_returnFromFunction(hCPU, r);
@@ -311,7 +365,7 @@ void nnActExport_GetCountry(PPCInterpreter_t* hCPU)
 bool g_isParentalControlCheckEnabled = false;
 void nnActExport_EnableParentalControlCheck(PPCInterpreter_t* hCPU)
 {
-	forceLogDebug_printf("nn_act.EnableParentalControlCheck(%d)", hCPU->gpr[3]);
+	cemuLog_logDebug(LogType::Force, "nn_act.EnableParentalControlCheck({})", hCPU->gpr[3]);
 	ppcDefineParamU8(isEnabled, 0);
 	g_isParentalControlCheckEnabled = isEnabled != 0;
 	osLib_returnFromFunction(hCPU, 0);
@@ -319,13 +373,13 @@ void nnActExport_EnableParentalControlCheck(PPCInterpreter_t* hCPU)
 
 void nnActExport_IsParentalControlCheckEnabled(PPCInterpreter_t* hCPU)
 {
-	forceLogDebug_printf("nn_act.IsParentalControlCheckEnabled() -> %d", g_isParentalControlCheckEnabled);
+	cemuLog_logDebug(LogType::Force, "nn_act.IsParentalControlCheckEnabled() -> {}", g_isParentalControlCheckEnabled);
 	osLib_returnFromFunction(hCPU, g_isParentalControlCheckEnabled);
 }
 
 void nnActExport_GetHostServerSettings(PPCInterpreter_t* hCPU)
 {
-	forceLogDebug_printf("GetHostServerSettings() - stub");
+	cemuLog_logDebug(LogType::Force, "GetHostServerSettings() - stub");
 	ppcDefineParamStr(ukn, 1);
 	strcpy(ukn, "");
 	osLib_returnFromFunction(hCPU, 0x00000000);
@@ -333,7 +387,7 @@ void nnActExport_GetHostServerSettings(PPCInterpreter_t* hCPU)
 
 void nnActExport_GetMii(PPCInterpreter_t* hCPU)
 {
-	forceLogDebug_printf("nn_act.GetMii(...)\n");
+	cemuLog_logDebug(LogType::Force, "nn_act.GetMii(...)");
 	ppcDefineParamUStr(miiData, 0);
 	uint32 r = nn::act::GetMiiEx(miiData, iosu::act::ACT_SLOT_CURRENT);
 	osLib_returnFromFunction(hCPU, r);
@@ -341,7 +395,7 @@ void nnActExport_GetMii(PPCInterpreter_t* hCPU)
 
 void nnActExport_GetMiiEx(PPCInterpreter_t* hCPU)
 {
-	forceLogDebug_printf("nn_act.GetMiiEx(...)\n");
+	cemuLog_logDebug(LogType::Force, "nn_act.GetMiiEx(...)");
 	ppcDefineParamUStr(miiData, 0);
 	ppcDefineParamU8(slot, 1);
 	uint32 r = nn::act::GetMiiEx(miiData, slot);
@@ -350,19 +404,19 @@ void nnActExport_GetMiiEx(PPCInterpreter_t* hCPU)
 
 void nnActExport_GetMiiImageEx(PPCInterpreter_t* hCPU)
 {
-	forceLogDebug_printf("GetMiiImageEx unimplemented LR %08x", hCPU->spr.LR);
+	cemuLog_logDebug(LogType::Force, "GetMiiImageEx unimplemented");
 
 	osLib_returnFromFunction(hCPU, 0);
 }
 
 void nnActExport_GetMiiName(PPCInterpreter_t* hCPU)
 {
-	forceLogDebug_printf("GetMiiName(0x%08x)", hCPU->gpr[3]);
+	cemuLog_logDebug(LogType::Force, "GetMiiName(0x{:08x})", hCPU->gpr[3]);
 	ppcDefineParamWStrBE(miiName, 0);
 
 	StackAllocator<FFLData_t> miiData;
 
-	uint32 r = nn::act::GetMiiEx(miiData, iosu::act::ACT_SLOT_CURRENT);
+	uint32 r = nn::act::GetMiiEx(&miiData, iosu::act::ACT_SLOT_CURRENT);
 	// extract name
 	sint32 miiNameLength = 0;
 	for (sint32 i = 0; i < MII_FFL_NAME_LENGTH; i++)
@@ -379,13 +433,13 @@ void nnActExport_GetMiiName(PPCInterpreter_t* hCPU)
 
 void nnActExport_GetMiiNameEx(PPCInterpreter_t* hCPU)
 {
-	forceLogDebug_printf("GetMiiNameEx(0x%08x, %d)", hCPU->gpr[3], hCPU->gpr[4] & 0xFF);
+	cemuLog_logDebug(LogType::Force, "GetMiiNameEx(0x{:08x}, {})", hCPU->gpr[3], hCPU->gpr[4] & 0xFF);
 	ppcDefineParamWStrBE(miiName, 0);
 	ppcDefineParamU8(slot, 1);
 
 	StackAllocator<FFLData_t> miiData;
 
-	uint32 r = nn::act::GetMiiEx(miiData, slot);
+	uint32 r = nn::act::GetMiiEx(&miiData, slot);
 	// extract name
 	sint32 miiNameLength = 0;
 	for (sint32 i = 0; i < MII_FFL_NAME_LENGTH; i++)
@@ -452,7 +506,7 @@ void nnActExport_UpdateMii(PPCInterpreter_t* hCPU)
 
 void nnActExport_GetUuid(PPCInterpreter_t* hCPU)
 {
-	forceLogDebug_printf("nn_act.GetUuid(0x%08x)", hCPU->gpr[3]);
+	cemuLog_logDebug(LogType::Force, "nn_act.GetUuid(0x{:08x})", hCPU->gpr[3]);
 	ppcDefineParamUStr(uuid, 0);
 	nn::act::GetUuidEx(uuid, iosu::act::ACT_SLOT_CURRENT);
 	osLib_returnFromFunction(hCPU, 0); // 0 -> result ok
@@ -460,7 +514,7 @@ void nnActExport_GetUuid(PPCInterpreter_t* hCPU)
 
 void nnActExport_GetUuidEx(PPCInterpreter_t* hCPU)
 {
-	forceLogDebug_printf("nn_act.GetUuidEx(0x%08x,0x%02x)", hCPU->gpr[3], hCPU->gpr[3]&0xFF);
+	cemuLog_logDebug(LogType::Force, "nn_act.GetUuidEx(0x{:08x},0x{:02x})", hCPU->gpr[3], hCPU->gpr[3]&0xFF);
 	ppcDefineParamUStr(uuid, 0);
 	ppcDefineParamU8(slot, 1);
 	nn::act::GetUuidEx(uuid, slot);
@@ -469,7 +523,7 @@ void nnActExport_GetUuidEx(PPCInterpreter_t* hCPU)
 
 void nnActExport_GetUuidEx2(PPCInterpreter_t* hCPU)
 {
-	forceLogDebug_printf("nn_act.GetUuidEx(0x%08x,0x%02x,0x%08x)", hCPU->gpr[3], hCPU->gpr[4], hCPU->gpr[5]);
+	cemuLog_logDebug(LogType::Force, "nn_act.GetUuidEx(0x{:08x},0x{:02x},0x{:08x})", hCPU->gpr[3], hCPU->gpr[4], hCPU->gpr[5]);
 	ppcDefineParamUStr(uuid, 0);
 	ppcDefineParamU8(slot, 1);
 	ppcDefineParamS32(name, 2);
@@ -479,7 +533,7 @@ void nnActExport_GetUuidEx2(PPCInterpreter_t* hCPU)
 
 void nnActExport_GetAccountId(PPCInterpreter_t* hCPU)
 {
-	forceLogDebug_printf("nn_act.GetAccountId(0x%08x)", hCPU->gpr[3]);
+	cemuLog_logDebug(LogType::Force, "nn_act.GetAccountId(0x{:08x})", hCPU->gpr[3]);
 	ppcDefineParamUStr(accId, 0);
 	GetAccountIdEx((char*)accId, iosu::act::ACT_SLOT_CURRENT);
 	osLib_returnFromFunction(hCPU, 0);
@@ -487,7 +541,7 @@ void nnActExport_GetAccountId(PPCInterpreter_t* hCPU)
 
 void nnActExport_GetAccountIdEx(PPCInterpreter_t* hCPU)
 {
-	forceLogDebug_printf("nn_act.GetAccountIdEx(0x%08x, 0x%02x)", hCPU->gpr[3], hCPU->gpr[3] & 0xFF);
+	cemuLog_logDebug(LogType::Force, "nn_act.GetAccountIdEx(0x{:08x}, 0x{:02x})", hCPU->gpr[3], hCPU->gpr[3] & 0xFF);
 	ppcDefineParamUStr(accId, 0);
 	ppcDefineParamU8(slot, 1);
 	GetAccountIdEx((char*)accId, slot);
@@ -497,7 +551,7 @@ void nnActExport_GetAccountIdEx(PPCInterpreter_t* hCPU)
 void nnActExport_GetParentalControlSlotNoEx(PPCInterpreter_t* hCPU)
 {
 	// GetParentalControlSlotNoEx(uint8* output, uint8 slot)
-	forceLogDebug_printf("nn_act.GetParentalControlSlotNoEx(0x%08x, 0x%02x)", hCPU->gpr[3], hCPU->gpr[4]);
+	cemuLog_logDebug(LogType::Force, "nn_act.GetParentalControlSlotNoEx(0x{:08x}, 0x{:02x})", hCPU->gpr[3], hCPU->gpr[4]);
 	//memory_writeU8(hCPU->gpr[3], 0x01); // returned slot no (slot indices start at 1)
 	memory_writeU8(hCPU->gpr[3], 1); // 0 -> No parental control for slot?
 	//memory_writeU8(hCPU->gpr[3], 0); // 0 -> No parental control for slot?
@@ -507,21 +561,19 @@ void nnActExport_GetParentalControlSlotNoEx(PPCInterpreter_t* hCPU)
 void nnActExport_GetDefaultAccount(PPCInterpreter_t* hCPU)
 {
 	// todo
-	forceLogDebug_printf("GetDefaultAccount(): Return 1?");
+	cemuLog_logDebug(LogType::Force, "GetDefaultAccount(): Return 1?");
 	osLib_returnFromFunction(hCPU, 1);
 }
 
 void nnActExport_GetSlotNo(PPCInterpreter_t* hCPU)
 {
 	// id of active account
-	// uint8 GetSlotNo(void);
-	forceLogDebug_printf("nn_act.GetSlotNo()");
 	osLib_returnFromFunction(hCPU, 1); // 1 is the first slot (0 is invalid)
 }
 
 void nnActExport_GetSlotNoEx(PPCInterpreter_t* hCPU)
 {
-	forceLogDebug_printf("nn_act.GetSlotNoEx(...)");
+	cemuLog_logDebug(LogType::Force, "nn_act.GetSlotNoEx(...)");
 	// get slot no by uuid
 	ppcDefineParamUStr(uuid, 0);
 
@@ -544,7 +596,7 @@ void nnActExport_GetSlotNoEx(PPCInterpreter_t* hCPU)
 
 void nnActExport_Initialize(PPCInterpreter_t* hCPU)
 {
-	forceLogDebug_printf("nn_act.Initialize()");
+	cemuLog_logDebug(LogType::Force, "nn_act.Initialize()");
 
 	nn::act::Initialize();
 
@@ -553,7 +605,7 @@ void nnActExport_Initialize(PPCInterpreter_t* hCPU)
 
 void nnActExport_HasNfsAccount(PPCInterpreter_t* hCPU)
 {
-	forceLogDebug_printf("Called nn_act.HasNfsAccount LR %08x", hCPU->spr.LR);
+	cemuLog_logDebug(LogType::Force, "Called nn_act.HasNfsAccount");
 	osLib_returnFromFunction(hCPU, 1); // Nfs = Nintendo Friend System? (Splatoon tries to call nn_fp.RegisterAccount if we set this to false)
 }
 
@@ -576,6 +628,7 @@ void nnActExport_AcquireNexServiceToken(PPCInterpreter_t* hCPU)
 	ppcDefineParamU32(serverId, 1);
 	memset(token, 0, sizeof(nexServiceToken_t));
 	actPrepareRequest();
+	actRequest->accountSlot = iosu::act::ACT_SLOT_CURRENT;
 	actRequest->requestCode = IOSU_ARC_ACQUIRENEXTOKEN;
 	actRequest->titleId = CafeSystem::GetForegroundTitleId();
 	actRequest->titleVersion = CafeSystem::GetForegroundTitleVersion();
@@ -585,39 +638,15 @@ void nnActExport_AcquireNexServiceToken(PPCInterpreter_t* hCPU)
 
 	memcpy(token, actRequest->resultBinary.binBuffer, sizeof(nexServiceToken_t));
 
-	forceLogDebug_printf("Called nn_act.AcquireNexServiceToken LR %08x", hCPU->spr.LR);
+	cemuLog_logDebug(LogType::Force, "Called nn_act.AcquireNexServiceToken");
 	osLib_returnFromFunction(hCPU, getNNReturnCode(resultCode, actRequest));
 }
 
-struct independentServiceToken_t
-{
-	/* +0x000 */ char token[0x201];
-};
-static_assert(sizeof(independentServiceToken_t) == 0x201); // todo - verify size
-
-uint32 AcquireIndependentServiceToken(independentServiceToken_t* token, const char* clientId, uint32 cacheDurationInSeconds)
-{
-	memset(token, 0, sizeof(independentServiceToken_t));
-	actPrepareRequest();
-	actRequest->requestCode = IOSU_ARC_ACQUIREINDEPENDENTTOKEN;
-	actRequest->titleId = CafeSystem::GetForegroundTitleId();
-	actRequest->titleVersion = CafeSystem::GetForegroundTitleVersion();
-	actRequest->expiresIn = cacheDurationInSeconds;
-	strcpy(actRequest->clientId, clientId);
-
-	uint32 resultCode = __depr__IOS_Ioctlv(IOS_DEVICE_ACT, IOSU_ACT_REQUEST_CEMU, 1, 1, actBufferVector);
-
-	memcpy(token, actRequest->resultBinary.binBuffer, sizeof(independentServiceToken_t));
-	return getNNReturnCode(resultCode, actRequest);
-}
-
 void nnActExport_AcquireIndependentServiceToken(PPCInterpreter_t* hCPU)
 {
 	ppcDefineParamMEMPTR(token, independentServiceToken_t, 0);
-	ppcDefineParamMEMPTR(serviceToken, const char, 1);
-	uint32 result =  AcquireIndependentServiceToken(token.GetPtr(), serviceToken.GetPtr(), 0);
-	forceLogDebug_printf("nn_act.AcquireIndependentServiceToken(0x%p, %s) -> %x | LR %08x", (void*)token.GetPtr(), serviceToken.GetPtr(), result, hCPU->spr.LR);
-	forceLogDebug_printf("Token: %s", serviceToken.GetPtr());
+	ppcDefineParamMEMPTR(clientId, const char, 1);
+	uint32 result = nn::act::AcquireIndependentServiceToken(token.GetPtr(), clientId.GetPtr(), 0);
 	osLib_returnFromFunction(hCPU, result);
 }
 
@@ -626,16 +655,14 @@ void nnActExport_AcquireIndependentServiceToken2(PPCInterpreter_t* hCPU)
 	ppcDefineParamStructPtr(token, independentServiceToken_t, 0);
 	ppcDefineParamMEMPTR(clientId, const char, 1);
 	ppcDefineParamU32(cacheDurationInSeconds, 2); 
-	uint32 result = AcquireIndependentServiceToken(token, clientId.GetPtr(), cacheDurationInSeconds);
-	forceLogDebug_printf("Called nn_act.AcquireIndependentServiceToken2 LR %08x", hCPU->spr.LR);
+	uint32 result = nn::act::AcquireIndependentServiceToken(token, clientId.GetPtr(), cacheDurationInSeconds);
 	osLib_returnFromFunction(hCPU, result);
 }
 
 void nnActExport_AcquireEcServiceToken(PPCInterpreter_t* hCPU)
 {
 	ppcDefineParamMEMPTR(pEcServiceToken, independentServiceToken_t, 0);
-	uint32 result = AcquireIndependentServiceToken(pEcServiceToken.GetPtr(), "71a6f5d6430ea0183e3917787d717c46", 0);
-	forceLogDebug_printf("Called nn_act.AcquireEcServiceToken LR %08x", hCPU->spr.LR);
+	uint32 result = nn::act::AcquireIndependentServiceToken(pEcServiceToken.GetPtr(), "71a6f5d6430ea0183e3917787d717c46", 0);
 	osLib_returnFromFunction(hCPU, result);
 }
 
@@ -644,7 +671,7 @@ void nnActExport_AcquirePrincipalIdByAccountId(PPCInterpreter_t* hCPU)
 	ppcDefineParamMEMPTR(principalId, uint32be, 0);
 	ppcDefineParamMEMPTR(nnid, char, 1);
 	ppcDefineParamU32(ukn, 2); // some option, can be 0 or 1 ?
-	forceLogDebug_printf("nn_act.AcquirePrincipalIdByAccountId(0x%08x,\"%s\", %d) - last param unknown", principalId.GetMPTR(), nnid.GetPtr(), ukn);
+	cemuLog_logDebug(LogType::Force, "nn_act.AcquirePrincipalIdByAccountId(0x{:08x},\"{}\", {}) - last param unknown", principalId.GetMPTR(), nnid.GetPtr(), ukn);
 	actPrepareRequest2();
 	actRequest->requestCode = IOSU_ARC_ACQUIREPIDBYNNID;
 	strcpy(actRequest->clientId, nnid.GetPtr());
@@ -656,30 +683,6 @@ void nnActExport_AcquirePrincipalIdByAccountId(PPCInterpreter_t* hCPU)
 	osLib_returnFromFunction(hCPU, result);
 }
 
-void nnActExport_GetUtcOffsetEx(PPCInterpreter_t* hCPU)
-{
-	// GetUtcOffsetEx__Q2_2nn3actFPLUc
-	ppcDefineParamU32BEPtr(utcOffsetOut, 0);
-	ppcDefineParamU32(uknParam, 1);
-
-	forceLogDebug_printf("Called nn_act.GetUtcOffsetEx LR %08x", hCPU->spr.LR);
-
-	*utcOffsetOut = 0;
-
-	forceLogDebug_printf("GetUtcOffsetEx stub");
-
-	osLib_returnFromFunction(hCPU, 0);
-}
-
-void nnActExport_GetUtcOffset(PPCInterpreter_t* hCPU)
-{
-	uint64 utcOffset = 0;
-
-	uint64 utcDifferenceInSeconds = (ppcCyclesSince2000_UTC / ESPRESSO_CORE_CLOCK) - (ppcCyclesSince2000 / ESPRESSO_CORE_CLOCK);
-
-	osLib_returnFromFunction64(hCPU, utcDifferenceInSeconds * 1000000ULL);
-}
-
 // register account functions
 void nnAct_load()
 {
@@ -704,12 +707,15 @@ void nnAct_load()
 	osLib_addFunction("nn_act", "GetPrincipalId__Q2_2nn3actFv", nnActExport_GetPrincipalId);
 	osLib_addFunction("nn_act", "GetPrincipalIdEx__Q2_2nn3actFPUiUc", nnActExport_GetPrincipalIdEx);
 	// transferable id
+	osLib_addFunction("nn_act", "GetTransferableId__Q2_2nn3actFUi", nnActExport_GetTransferableId);
 	osLib_addFunction("nn_act", "GetTransferableIdEx__Q2_2nn3actFPULUiUc", nnActExport_GetTransferableIdEx);
 	// persistent id
 	osLib_addFunction("nn_act", "GetPersistentId__Q2_2nn3actFv", nnActExport_GetPersistentId);
 	osLib_addFunction("nn_act", "GetPersistentIdEx__Q2_2nn3actFUc", nnActExport_GetPersistentIdEx);
 	// country
 	osLib_addFunction("nn_act", "GetCountry__Q2_2nn3actFPc", nnActExport_GetCountry);
+	// timezone
+	cafeExportRegisterFunc(nn::act::GetTimeZoneId, "nn_act", "GetTimeZoneId__Q2_2nn3actFPc", LogType::Placeholder);
 
 	// parental
 	osLib_addFunction("nn_act", "EnableParentalControlCheck__Q2_2nn3actFb", nnActExport_EnableParentalControlCheck);
@@ -744,8 +750,8 @@ void nnAct_load()
 	// placeholders / incomplete implementations
 	osLib_addFunction("nn_act", "HasNfsAccount__Q2_2nn3actFv", nnActExport_HasNfsAccount);
 	osLib_addFunction("nn_act", "GetHostServerSettings__Q2_2nn3actFPcT1Uc", nnActExport_GetHostServerSettings);
-	osLib_addFunction("nn_act", "GetUtcOffset__Q2_2nn3actFv", nnActExport_GetUtcOffset);
-	osLib_addFunction("nn_act", "GetUtcOffsetEx__Q2_2nn3actFPLUc", nnActExport_GetUtcOffsetEx);
+	cafeExportRegisterFunc(nn::act::GetUtcOffset, "nn_act", "GetUtcOffset__Q2_2nn3actFv", LogType::Placeholder);
+	cafeExportRegisterFunc(nn::act::GetUtcOffsetEx, "nn_act", "GetUtcOffsetEx__Q2_2nn3actFPLUc", LogType::Placeholder);
 
 }
 
diff --git a/src/Cafe/OS/libs/nn_act/nn_act.h b/src/Cafe/OS/libs/nn_act/nn_act.h
index 06df4af1..6b0a1236 100644
--- a/src/Cafe/OS/libs/nn_act/nn_act.h
+++ b/src/Cafe/OS/libs/nn_act/nn_act.h
@@ -1,5 +1,13 @@
 #pragma once
 
+#include "Cafe/IOSU/legacy/iosu_act.h"
+
+struct independentServiceToken_t
+{
+	/* +0x000 */ char token[0x201];
+};
+static_assert(sizeof(independentServiceToken_t) == 0x201); // todo - verify size
+
 namespace nn
 {
 namespace act
@@ -9,6 +17,12 @@ namespace act
 	uint32 GetPersistentIdEx(uint8 slot);
 	uint32 GetUuidEx(uint8* uuid, uint8 slot, sint32 name = -2);
 	uint32 GetSimpleAddressIdEx(uint32be* simpleAddressId, uint8 slot);
+	uint32 GetTransferableIdEx(uint64* transferableId, uint32 unique, uint8 slot);
+
+	sint64 GetUtcOffset();
+	sint32 GetUtcOffsetEx(sint64be* pOutOffset, uint8 slotNo);
+
+	uint32 AcquireIndependentServiceToken(independentServiceToken_t* token, const char* clientId, uint32 cacheDurationInSeconds);
 
 	static uint32 getCountryCodeFromSimpleAddress(uint32 simpleAddressId)
 	{
diff --git a/src/Cafe/OS/libs/nn_boss/nn_boss.cpp b/src/Cafe/OS/libs/nn_boss/nn_boss.cpp
index 045fa82f..2a05fa7a 100644
--- a/src/Cafe/OS/libs/nn_boss/nn_boss.cpp
+++ b/src/Cafe/OS/libs/nn_boss/nn_boss.cpp
@@ -9,7 +9,7 @@
 #include "Cafe/CafeSystem.h"
 #include "Cafe/Filesystem/fsc.h"
 
-namespace nn 
+namespace nn
 {
 	typedef uint32 Result;
 namespace boss
@@ -23,17 +23,248 @@ memset(bossRequest, 0, sizeof(iosuBossCemuRequest_t)); \
 memset(bossBufferVector, 0, sizeof(ioBufferVector_t)); \
 bossBufferVector->buffer = (uint8*)bossRequest;
 
-	coreinit::OSMutex g_mutex;
+	SysAllocator<coreinit::OSMutex> g_mutex;
 	sint32 g_initCounter = 0;
 	bool g_isInitialized = false;
 
-	void freeMem(void* mem)
+	struct VTableEntry
 	{
-		if(mem)
-			coreinit::default_MEMFreeToDefaultHeap((uint8*)mem - 8);
+		uint16be offsetA{0};
+		uint16be offsetB{0};
+		MEMPTR<void> ptr;
+	};
+	static_assert(sizeof(VTableEntry) == 8);
+
+	#define DTOR_WRAPPER(__TYPE) RPLLoader_MakePPCCallable([](PPCInterpreter_t* hCPU) { dtor(MEMPTR<__TYPE>(hCPU->gpr[3]), hCPU->gpr[4]); osLib_returnFromFunction(hCPU, 0); })
+
+	constexpr uint32 BOSS_MEM_MAGIC = 0xCAFE4321;
+
+	template<typename T>
+	MEMPTR<T> boss_new()
+	{
+		uint32 objSize = sizeof(T);
+		uint32be* basePtr = (uint32be*)coreinit::_weak_MEMAllocFromDefaultHeapEx(objSize + 8, 0x8);
+		basePtr[0] = BOSS_MEM_MAGIC;
+		basePtr[1] = objSize;
+		return (T*)(basePtr+2);
 	}
 
-	struct TaskSetting_t
+	void boss_delete(MEMPTR<void> mem)
+	{
+		if(!mem)
+			return;
+		uint32be* basePtr = (uint32be*)mem.GetPtr() - 2;
+		if(basePtr[0] != BOSS_MEM_MAGIC)
+		{
+			cemuLog_log(LogType::Force, "nn_boss: Detected memory corruption");
+			cemu_assert_suspicious();
+		}
+		coreinit::_weak_MEMFreeToDefaultHeap(basePtr);
+	}
+
+	Result Initialize() // Initialize__Q2_2nn4bossFv
+	{
+		coreinit::OSLockMutex(&g_mutex);
+		Result result = 0;
+		if(g_initCounter == 0)
+		{
+			g_isInitialized = true;
+			// IPC init here etc.
+			result = 0x200080; // init result
+		}
+		g_initCounter++;
+		coreinit::OSUnlockMutex(&g_mutex);
+		return NN_RESULT_IS_SUCCESS(result) ? 0 : result;
+	}
+
+	uint32 IsInitialized() // IsInitialized__Q2_2nn4bossFv
+	{
+		return g_isInitialized;
+	}
+
+	void Finalize() // Finalize__Q2_2nn4bossFv
+	{
+		coreinit::OSLockMutex(&g_mutex);
+		if(g_initCounter == 0)
+			cemuLog_log(LogType::Force, "nn_boss: Finalize() called without corresponding Initialize()");
+		if(g_initCounter == 1)
+		{
+			g_isInitialized = false;
+			// IPC deinit here etc.
+		}
+		g_initCounter--;
+		coreinit::OSUnlockMutex(&g_mutex);
+	}
+
+	uint32 GetBossState(PPCInterpreter_t* hCPU)
+	{
+		cemuLog_logDebug(LogType::Force, "nn_boss.GetBossState() - stub");
+		return 7;
+	}
+
+	struct TitleId
+	{
+		uint64be u64{};
+
+		static TitleId* ctor(TitleId* _thisptr, uint64 titleId)
+		{
+			if (!_thisptr)
+				_thisptr = boss_new<TitleId>();
+			_thisptr->u64 = titleId;
+			return _thisptr;
+		}
+
+		static TitleId* ctor(TitleId* _thisptr)
+		{
+			return ctor(_thisptr, 0);
+		}
+
+		static bool IsValid(TitleId* _thisptr)
+		{
+			return _thisptr->u64 != 0;
+		}
+
+		static TitleId* ctor1(TitleId* _thisptr, uint32 filler, uint64 titleId)
+		{
+			return ctor(_thisptr);
+		}
+
+		static TitleId* ctor2(TitleId* _thisptr, uint32 filler, uint64 titleId)
+		{
+			cemuLog_logDebug(LogType::Force, "nn_boss_TitleId_ctor2(0x{:x})", MEMPTR(_thisptr).GetMPTR());
+			if (!_thisptr)
+			{
+				// _thisptr = new Task_t
+				assert_dbg();
+			}
+
+			_thisptr->u64 = titleId;
+			return _thisptr;
+		}
+
+		static TitleId* ctor3(TitleId* _thisptr, TitleId* titleId)
+		{
+			cemuLog_logDebug(LogType::Force, "nn_boss_TitleId_cctor(0x{:x})", MEMPTR(_thisptr).GetMPTR());
+			if (!_thisptr)
+				_thisptr = boss_new<TitleId>();
+			_thisptr->u64 = titleId->u64;
+			return _thisptr;
+		}
+
+		static bool operator_ne(TitleId* _thisptr, TitleId* titleId)
+		{
+			cemuLog_logDebug(LogType::Force, "nn_boss_TitleId_operator_ne(0x{:x})", MEMPTR(_thisptr).GetMPTR());
+			return _thisptr->u64 != titleId->u64;
+		}
+	};
+	static_assert(sizeof(TitleId) == 8);
+
+	struct TaskId
+	{
+		char id[0x8]{};
+
+		static TaskId* ctor(TaskId* _thisptr)
+		{
+			if(!_thisptr)
+				_thisptr = boss_new<TaskId>();
+			_thisptr->id[0] = '\0';
+			return _thisptr;
+		}
+	};
+	static_assert(sizeof(TaskId) == 8);
+
+	struct Title
+	{
+		uint32be accountId{}; // 0x00
+		TitleId titleId{}; // 0x8
+		MEMPTR<void> vTablePtr{}; // 0x10
+
+		struct VTable
+		{
+			VTableEntry rtti;
+			VTableEntry dtor;
+		};
+		static inline SysAllocator<VTable> s_titleVTable;
+
+		static Title* ctor(Title* _this)
+		{
+			if (!_this)
+				_this = boss_new<Title>();
+			*_this = {};
+			_this->vTablePtr = s_titleVTable;
+			return _this;
+		}
+
+		static void dtor(Title* _this, uint32 options)
+		{
+			if (_this && (options & 1))
+				boss_delete(_this);
+		}
+
+		static void InitVTable()
+		{
+			s_titleVTable->rtti.ptr = nullptr; // todo
+			s_titleVTable->dtor.ptr = DTOR_WRAPPER(Title);
+		}
+	};
+	static_assert(sizeof(Title) == 0x18);
+
+	struct DirectoryName
+	{
+		char name[0x8]{};
+
+		static DirectoryName* ctor(DirectoryName* _thisptr)
+		{
+			if (!_thisptr)
+				_thisptr = boss_new<DirectoryName>();
+			memset(_thisptr->name, 0x00, 0x8);
+			return _thisptr;
+		}
+
+		static const char* operator_const_char(DirectoryName* _thisptr)
+		{
+			return _thisptr->name;
+		}
+	};
+	static_assert(sizeof(DirectoryName) == 8);
+
+	struct BossAccount // the actual class name is "Account" and while the boss namespace helps us separate this from Account(.h) we use an alternative name to avoid confusion
+	{
+		struct VTable
+		{
+			VTableEntry rtti;
+			VTableEntry dtor;
+		};
+		static inline SysAllocator<VTable> s_VTable;
+
+		uint32be accountId;
+		MEMPTR<void> vTablePtr;
+
+		static BossAccount* ctor(BossAccount* _this, uint32 accountId)
+		{
+			if (!_this)
+				_this = boss_new<BossAccount>();
+			_this->accountId = accountId;
+			_this->vTablePtr = s_VTable;
+			return _this;
+		}
+
+		static void dtor(BossAccount* _this, uint32 options)
+		{
+			if(_this && options & 1)
+				boss_delete(_this);
+		}
+
+		static void InitVTable()
+		{
+			s_VTable->rtti.ptr = nullptr; // todo
+			s_VTable->dtor.ptr = DTOR_WRAPPER(BossAccount);
+		}
+
+	};
+	static_assert(sizeof(BossAccount) == 8);
+
+	struct TaskSetting
 	{
 		static const uint32 kBossCode = 0x7C0;
 		static const uint32 kBossCodeLen = 0x20;
@@ -46,8 +277,6 @@ bossBufferVector->buffer = (uint8*)bossRequest;
 		static const uint32 kNbdlFileName = 0x7F8;
 		static const uint32 kFileNameLen = 0x20;
 
-		
-
 		static const uint32 kURL = 0x48;
 		static const uint32 kURLLen = 0x100;
 
@@ -57,249 +286,79 @@ bossBufferVector->buffer = (uint8*)bossRequest;
 		static const uint32 kServiceToken = 0x590;
 		static const uint32 kServiceTokenLen = 0x200;
 
-
 		uint8 settings[0x1000];
-		uint32be uknExt_vTableProbably; // +0x1000
-	};
-	static_assert(sizeof(TaskSetting_t) == 0x1004);
-	static_assert(offsetof(TaskSetting_t, uknExt_vTableProbably) == 0x1000, "offsetof(TaskSetting_t, uknExt)");
+		MEMPTR<void> vTablePtr; // +0x1000
 
-	struct NetTaskSetting_t : TaskSetting_t
+		struct VTableTaskSetting
+		{
+			VTableEntry rtti;
+			VTableEntry dtor;
+			VTableEntry RegisterPreprocess;
+			VTableEntry unk1;
+		};
+		static inline SysAllocator<VTableTaskSetting> s_VTable;
+
+		static TaskSetting* ctor(TaskSetting* _thisptr)
+		{
+			if(!_thisptr)
+				_thisptr = boss_new<TaskSetting>();
+			_thisptr->vTablePtr = s_VTable;
+			InitializeSetting(_thisptr);
+			return _thisptr;
+		}
+
+		static void dtor(TaskSetting* _this, uint32 options)
+		{
+			cemuLog_logDebug(LogType::Force, "nn::boss::TaskSetting::dtor(0x{:08x}, 0x{:08x})", MEMPTR(_this).GetMPTR(), options);
+			if(options & 1)
+				boss_delete(_this);
+		}
+
+		static bool IsPrivileged(TaskSetting* _thisptr)
+		{
+			const uint16 value = *(uint16be*)&_thisptr->settings[0x28];
+			return value == 1 || value == 9 || value == 5;
+		}
+
+		static void InitializeSetting(TaskSetting* _thisptr)
+		{
+			memset(_thisptr, 0x00, sizeof(TaskSetting::settings));
+			*(uint32*)&_thisptr->settings[0x0C] = 0;
+			*(uint8*)&_thisptr->settings[0x2A] = 0x7D; // timeout?
+			*(uint32*)&_thisptr->settings[0x30] = 0x7080;
+			*(uint32*)&_thisptr->settings[0x8] = 0;
+			*(uint32*)&_thisptr->settings[0x38] = 0;
+			*(uint32*)&_thisptr->settings[0x3C] = 0x76A700;
+			*(uint32*)&_thisptr->settings[0] = 0x76A700;
+		}
+
+		static void InitVTable()
+		{
+			s_VTable->rtti.ptr = nullptr; // todo
+			s_VTable->dtor.ptr = DTOR_WRAPPER(TaskSetting);
+			s_VTable->RegisterPreprocess.ptr = nullptr; // todo
+			s_VTable->unk1.ptr = nullptr; // todo
+		}
+	};
+	static_assert(sizeof(TaskSetting) == 0x1004);
+	static_assert(offsetof(TaskSetting, vTablePtr) == 0x1000);
+
+	struct NetTaskSetting : TaskSetting
 	{
 		// 0x188 cert1 + 0x188 cert2 + 0x188 cert3
 		// 0x190 AddCaCert (3times) char cert[0x80];
 		// SetConnectionSetting
 		// SetFirstLastModifiedTime
-	};
-	static_assert(sizeof(NetTaskSetting_t) == 0x1004);
 
-	struct NbdlTaskSetting_t : NetTaskSetting_t
-	{
-		//char fileName[0x20]; // @0x7F8
-	};
-	static_assert(sizeof(NbdlTaskSetting_t) == 0x1004);
+		struct VTableNetTaskSetting : public VTableTaskSetting
+		{ };
+		static inline SysAllocator<VTableNetTaskSetting> s_VTable;
 
-	struct RawUlTaskSetting_t : NetTaskSetting_t
-	{
-		static const uint32 kType = 0x12340000;
-		uint32be ukRaw1; // 0x1004
-		uint32be ukRaw2; // 0x1008
-		uint32be ukRaw3; // 0x100C
-		uint8 rawSpace[0x200]; // 0x1010
-	};
-	static_assert(sizeof(RawUlTaskSetting_t) == 0x1210);
-
-	struct PlayReportSetting_t : RawUlTaskSetting_t
-	{
-		static const uint32 kType = 0x12340001;
-		MEMPTR<void*> ukPlay1; // 0x1210
-		uint32be ukPlay2; // 0x1214
-		uint32be ukPlay3; // 0x1218
-		uint32be ukPlay4; // 0x121C
-	};
-	static_assert(sizeof(PlayReportSetting_t) == 0x1220);
-
-	struct RawDlTaskSetting_t : NetTaskSetting_t
-	{
-		static const uint32 kType = 0x12340002;
-		//char fileName[0x20]; // 0x7F8
-	};
-	static_assert(sizeof(RawDlTaskSetting_t) == 0x1004);
-
-	struct TitleId_t
-	{
-		uint64be u64{};
-	};
-	static_assert(sizeof(TitleId_t) == 8);
-
-	struct TaskId_t
-	{
-		char id[0x8]{};
-	};
-	static_assert(sizeof(TaskId_t) == 8);
-
-	struct Title_t
-	{
-		uint32be accountId{}; // 0x00
-		TitleId_t titleId{}; // 0x8
-		uint32be someValue = 0x12341000; // 0x10
-	};
-	static_assert(sizeof(Title_t) == 0x18);
-
-	struct DirectoryName_t
-	{
-		char name[0x8]{};
-	};
-	static_assert(sizeof(DirectoryName_t) == 8);
-
-	struct Account_t
-	{
-		uint32be accountId;
-		uint32be uk1; // global struct
-	};
-	static_assert(sizeof(Account_t) == 8);
-	
-	struct Task_t
-	{
-		uint32be accountId; // 0x00
-		uint32be uk2; // 0x04
-		TaskId_t taskId; // 0x08
-		TitleId_t titleId; // 0x10
-		uint32be ext; // 0x18
-		uint32be padding; // 0x1C
-	};
-	static_assert(sizeof(Task_t) == 0x20, "sizeof(Task_t)");
-
-	namespace TaskId
-	{
-		TaskId_t* ctor(TaskId_t* thisptr)
-		{
-			if(!thisptr)
-			{
-				// thisptr = new TaskId_t
-				assert_dbg();
-			}
-
-			if(thisptr)
-			{
-				thisptr->id[0] = 0;
-			}
-
-			return thisptr;
-		}
-	}
-
-	namespace Account
-	{
-		Account_t* ctor(Account_t* thisptr, uint32 accountId)
-		{
-			if (!thisptr)
-			{
-				// thisptr = new TaskId_t
-				assert_dbg();
-			}
-
-			thisptr->accountId = accountId;
-			thisptr->uk1 = 0x12340010;
-			return thisptr;
-		}
-	}
-	
-	namespace TitleId
-	{
-		TitleId_t* ctor(TitleId_t* thisptr, uint64 titleId)
-		{
-			if (!thisptr)
-			{
-				// thisptr = new TaskId_t
-				assert_dbg();
-			}
-
-			if (thisptr)
-			{
-				thisptr->u64 = titleId;
-			}
-
-			return thisptr;
-		}
-
-		TitleId_t* ctor(TitleId_t* thisptr)
-		{
-			return ctor(thisptr, 0);
-		}
-
-		bool IsValid(TitleId_t* thisptr)
-		{
-			return thisptr->u64 != 0;
-		}
-
-		TitleId_t* ctor1(TitleId_t* thisptr, uint32 filler, uint64 titleId)
-		{
-			return ctor(thisptr);
-		}
-
-		TitleId_t* ctor2(TitleId_t* thisptr, uint32 filler, uint64 titleId)
-		{
-			forceLogDebug_printf("nn_boss_TitleId_ctor2(0x%x)", MEMPTR(thisptr).GetMPTR());
-			if (!thisptr)
-			{
-				// thisptr = new Task_t
-				assert_dbg();
-			}
-
-			thisptr->u64 = titleId;
-			return thisptr;
-		}
-
-
-		TitleId_t* cctor(TitleId_t* thisptr, TitleId_t* titleId)
-		{
-			forceLogDebug_printf("nn_boss_TitleId_cctor(0x%x)", MEMPTR(thisptr).GetMPTR());
-			if (!thisptr)
-			{
-				// thisptr = new Task_t
-				assert_dbg();
-			}
-
-			thisptr->u64 = titleId->u64;
-
-			return thisptr;
-		}
-
-		bool operator_ne(TitleId_t* thisptr, TitleId_t* titleId)
-		{
-			forceLogDebug_printf("nn_boss_TitleId_operator_ne(0x%x)", MEMPTR(thisptr).GetMPTR());
-			return thisptr->u64 != titleId->u64;
-		}
-	}
-
-	namespace TaskSetting
-	{
-		bool IsPrivilegedTaskSetting(TaskSetting_t* thisptr)
-		{
-			const uint16 value = *(uint16*)&thisptr->settings[0x28];
-			return value == 1 || value == 9 || value == 5;
-		}
-
-		void InitializeSetting(TaskSetting_t* thisptr)
-		{
-			memset(thisptr, 0x00, sizeof(TaskSetting_t::settings));
-			*(uint32*)&thisptr->settings[0x0C] = 0;
-			*(uint8*)&thisptr->settings[0x2A] = 0x7D; // timeout?
-			*(uint32*)&thisptr->settings[0x30] = 0x7080;
-			*(uint32*)&thisptr->settings[0x8] = 0;
-			*(uint32*)&thisptr->settings[0x38] = 0;
-			*(uint32*)&thisptr->settings[0x3C] = 0x76A700;
-			*(uint32*)&thisptr->settings[0] = 0x76A700;
-		}
-
-		TaskSetting_t* ctor(TaskSetting_t* thisptr)
-		{
-			if(!thisptr)
-			{
-				// thisptr = new TaskSetting_t
-				assert_dbg();
-			}
-
-			if (thisptr)
-			{
-				thisptr->uknExt_vTableProbably = 0;
-				InitializeSetting(thisptr);
-			}
-
-			return thisptr;
-		}
-
-		
-	}
-
-	namespace NetTaskSetting
-	{
-		Result AddCaCert(NetTaskSetting_t* thisptr, const char* name)
+		static Result AddCaCert(NetTaskSetting* _thisptr, const char* name)
 		{
 			if(name == nullptr || strnlen(name, 0x80) == 0x80)
 			{
-				forceLogDebug_printf("nn_boss_NetTaskSetting_AddCaCert: name size is invalid");
+				cemuLog_logDebug(LogType::Force, "nn_boss_NetTaskSetting_AddCaCert: name size is invalid");
 				return 0xC0203780;
 			}
 
@@ -308,1497 +367,1383 @@ bossBufferVector->buffer = (uint8*)bossRequest;
 			return 0xA0220D00;
 		}
 
-		NetTaskSetting_t* ctor(NetTaskSetting_t* thisptr)
+		static NetTaskSetting* ctor(NetTaskSetting* _thisptr)
 		{
-			if (!thisptr)
-			{
-				// thisptr = new NetTaskSetting_t
-				assert_dbg();
-			}
-
-			if (thisptr)
-			{
-				TaskSetting::ctor(thisptr);
-				*(uint32*)&thisptr->settings[0x18C] = 0x78;
-				thisptr->uknExt_vTableProbably = 0;
-			}
-
-			return thisptr;
+			if (!_thisptr)
+				_thisptr = boss_new<NetTaskSetting>();
+			TaskSetting::ctor(_thisptr);
+			*(uint32*)&_thisptr->settings[0x18C] = 0x78;
+			_thisptr->vTablePtr = s_VTable;
+			return _thisptr;
 		}
 
-		Result SetServiceToken(NetTaskSetting_t* thisptr, const uint8* serviceToken)
+		static Result SetServiceToken(NetTaskSetting* _thisptr, const uint8* serviceToken)
 		{
-			forceLogDebug_printf("nn_boss_NetTaskSetting_SetServiceToken(0x%x, 0x%x)", MEMPTR(thisptr).GetMPTR(), MEMPTR(serviceToken).GetMPTR());
-			forceLogDebug_printf("\t->%s", serviceToken);
-			memcpy(&thisptr->settings[TaskSetting_t::kServiceToken], serviceToken, TaskSetting_t::kServiceTokenLen);
+			cemuLog_logDebug(LogType::Force, "nn_boss_NetTaskSetting_SetServiceToken(0x{:x}, 0x{:x})", MEMPTR(_thisptr).GetMPTR(), MEMPTR(serviceToken).GetMPTR());
+			cemuLog_logDebug(LogType::Force, "\t->{}", fmt::ptr(serviceToken));
+			memcpy(&_thisptr->settings[TaskSetting::kServiceToken], serviceToken, TaskSetting::kServiceTokenLen);
 			return 0x200080;
 		}
 
-		Result AddInternalCaCert(NetTaskSetting_t* thisptr, char certId)
+		static Result AddInternalCaCert(NetTaskSetting* _thisptr, char certId)
 		{
-			forceLogDebug_printf("nn_boss_NetTaskSetting_AddInternalCaCert(0x%x, 0x%x)", MEMPTR(thisptr).GetMPTR(), (int)certId);
+			cemuLog_logDebug(LogType::Force, "nn_boss_NetTaskSetting_AddInternalCaCert(0x{:x}, 0x{:x})", MEMPTR(_thisptr).GetMPTR(), (int)certId);
 
-			uint32 location = TaskSetting_t::kCACert;
+			uint32 location = TaskSetting::kCACert;
 			for(int i = 0; i < 3; ++i)
 			{
-				if(thisptr->settings[location] == 0)
+				if(_thisptr->settings[location] == 0)
 				{
-					thisptr->settings[location] = (uint8)certId;
+					_thisptr->settings[location] = (uint8)certId;
 					return 0x200080;
 				}
 
-				location += TaskSetting_t::kCACert;
+				location += TaskSetting::kCACert;
 			}
-		
-			forceLogDebug_printf("nn_boss_NetTaskSetting_AddInternalCaCert: can't store certificate");
+
+			cemuLog_logDebug(LogType::Force, "nn_boss_NetTaskSetting_AddInternalCaCert: can't store certificate");
 			return 0xA0220D00;
 		}
 
-		void SetInternalClientCert(NetTaskSetting_t* thisptr, char certId)
+		static void SetInternalClientCert(NetTaskSetting* _thisptr, char certId)
 		{
-			forceLogDebug_printf("nn_boss_NetTaskSetting_SetInternalClientCert(0x%x, 0x%x)", MEMPTR(thisptr).GetMPTR(), (int)certId);
-			thisptr->settings[TaskSetting_t::kClientCert] = (uint8)certId;
+			cemuLog_logDebug(LogType::Force, "nn_boss_NetTaskSetting_SetInternalClientCert(0x{:x}, 0x{:x})", MEMPTR(_thisptr).GetMPTR(), (int)certId);
+			_thisptr->settings[TaskSetting::kClientCert] = (uint8)certId;
 		}
-	}
 
-	namespace NbdlTaskSetting // : NetTaskSetting
+		static void InitVTable()
+		{
+			s_VTable->rtti.ptr = nullptr; // todo
+			s_VTable->dtor.ptr = DTOR_WRAPPER(NetTaskSetting);
+			s_VTable->RegisterPreprocess.ptr = nullptr; // todo
+			s_VTable->unk1.ptr = nullptr; // todo
+		}
+	};
+	static_assert(sizeof(NetTaskSetting) == 0x1004);
+
+	struct NbdlTaskSetting : NetTaskSetting
 	{
-		NbdlTaskSetting_t* ctor(NbdlTaskSetting_t* thisptr)
+		struct VTableNbdlTaskSetting : public VTableNetTaskSetting
 		{
-			if (!thisptr)
-			{
-				// thisptr = new NbdlTaskSetting_t
-				assert_dbg();
-			}
+			VTableEntry rttiNetTaskSetting; // unknown
+		};
+		static_assert(sizeof(VTableNbdlTaskSetting) == 8*5);
+		static inline SysAllocator<VTableNbdlTaskSetting> s_VTable;
 
-			if (thisptr)
-			{
-				NetTaskSetting::ctor(thisptr);
-				thisptr->uknExt_vTableProbably = 0;
-			}
-
-			return thisptr;
+		static NbdlTaskSetting* ctor(NbdlTaskSetting* _thisptr)
+		{
+			if (!_thisptr)
+				_thisptr = boss_new<NbdlTaskSetting>();
+			NetTaskSetting::ctor(_thisptr);
+			_thisptr->vTablePtr = s_VTable;
+			return _thisptr;
 		}
 
-		void export_ctor(PPCInterpreter_t* hCPU)
+		static Result Initialize(NbdlTaskSetting* _thisptr, const char* bossCode, uint64 directorySizeLimit, const char* directoryName) // Initialize__Q3_2nn4boss15NbdlTaskSettingFPCcLT1
 		{
-			ppcDefineParamMEMPTR(thisptr, NbdlTaskSetting_t, 0);
-			forceLogDebug_printf("nn_boss_NbdlTaskSetting_ctor");
-			ctor(thisptr.GetPtr());
-			osLib_returnFromFunction(hCPU, thisptr.GetMPTR());
-		}
-
-		void export_Initialize(PPCInterpreter_t* hCPU)
-		{
-			ppcDefineParamMEMPTR(thisptr, NbdlTaskSetting_t, 0);
-			ppcDefineParamMEMPTR(bossCode, const char, 1);
-			ppcDefineParamU64(directorySizeLimit, 2);
-			ppcDefineParamMEMPTR(directoryName, const char, 4);
-			forceLogDebug_printf("nn_boss_NbdlTaskSetting_Initialize(0x%08x, %s, 0x%llx, 0x%08x)", thisptr.GetMPTR(), bossCode.GetPtr(), directorySizeLimit, directoryName.GetMPTR());
-
-			if(!bossCode || strnlen(bossCode.GetPtr(), 0x20) == 0x20)
-			{
-				osLib_returnFromFunction(hCPU, BUILD_NN_RESULT(NN_RESULT_LEVEL_LVL6, NN_RESULT_MODULE_NN_BOSS, 0x3780));
-				return;
-			}
-
-			if (directoryName && strnlen(directoryName.GetPtr(), 0x8) == 0x8)
-			{
-				osLib_returnFromFunction(hCPU, BUILD_NN_RESULT(NN_RESULT_LEVEL_LVL6, NN_RESULT_MODULE_NN_BOSS, 0x3780));
-				return;
-			}
-
-			strncpy((char*)&thisptr->settings[TaskSetting_t::kBossCode], bossCode.GetPtr(), TaskSetting_t::kBossCodeLen);
-			
-			*(uint64be*)&thisptr->settings[TaskSetting_t::kDirectorySizeLimit] = directorySizeLimit; // uint64be
-			if(directoryName)
-				strncpy((char*)&thisptr->settings[TaskSetting_t::kDirectoryName], directoryName.GetPtr(), TaskSetting_t::kDirectoryNameLen);
-
-			osLib_returnFromFunction(hCPU, BUILD_NN_RESULT(NN_RESULT_LEVEL_SUCCESS, NN_RESULT_MODULE_NN_BOSS, 0x80));
-		}
-
-		Result SetFileName(NbdlTaskSetting_t* thisptr, const char* fileName)
-		{
-			forceLogDebug_printf("nn_boss_NbdlTaskSetting_t_SetFileName(0x%08x, %s)", MEMPTR(thisptr).GetMPTR(), fileName ? fileName : "\"\"");
-
-			if (!fileName || strnlen(fileName, TaskSetting_t::kFileNameLen) == TaskSetting_t::kFileNameLen)
-			{
+			if(!bossCode || strnlen(bossCode, TaskSetting::kBossCodeLen) == TaskSetting::kBossCodeLen)
 				return BUILD_NN_RESULT(NN_RESULT_LEVEL_LVL6, NN_RESULT_MODULE_NN_BOSS, 0x3780);
-			}
-			
-			strncpy((char*)&thisptr->settings[TaskSetting_t::kNbdlFileName], fileName, TaskSetting_t::kFileNameLen);
+
+			if (directoryName && strnlen(directoryName, TaskSetting::kDirectoryNameLen) == TaskSetting::kDirectoryNameLen)
+				return BUILD_NN_RESULT(NN_RESULT_LEVEL_LVL6, NN_RESULT_MODULE_NN_BOSS, 0x3780);
+
+			strncpy((char*)&_thisptr->settings[TaskSetting::kBossCode], bossCode, TaskSetting::kBossCodeLen);
+
+			*(uint64be*)&_thisptr->settings[TaskSetting::kDirectorySizeLimit] = directorySizeLimit; // uint64be
+			if(directoryName)
+				strncpy((char*)&_thisptr->settings[TaskSetting::kDirectoryName], directoryName, TaskSetting::kDirectoryNameLen);
+
 			return BUILD_NN_RESULT(NN_RESULT_LEVEL_SUCCESS, NN_RESULT_MODULE_NN_BOSS, 0x80);
 		}
 
-	}
-
-	namespace RawUlTaskSetting
-	{
-		RawUlTaskSetting_t* ctor(RawUlTaskSetting_t* thisptr)
+		static Result SetFileName(NbdlTaskSetting* _thisptr, const char* fileName)
 		{
-			forceLogDebug_printf("nn_boss_RawUlTaskSetting_ctor(0x%x) TODO", MEMPTR(thisptr).GetMPTR());
-			if (!thisptr)
-			{
-				// thisptr = new RawUlTaskSetting_t
-				assert_dbg();
-			}
+			cemuLog_logDebug(LogType::Force, "nn_boss_NbdlTaskSetting_t_SetFileName(0x{:08x}, {})", MEMPTR(_thisptr).GetMPTR(), fileName ? fileName : "\"\"");
+			if (!fileName || strnlen(fileName, TaskSetting::kFileNameLen) == TaskSetting::kFileNameLen)
+				return BUILD_NN_RESULT(NN_RESULT_LEVEL_LVL6, NN_RESULT_MODULE_NN_BOSS, 0x3780);
 
-			if (thisptr)
-			{
-				NetTaskSetting::ctor(thisptr);
-				thisptr->uknExt_vTableProbably = RawUlTaskSetting_t::kType;
-				thisptr->ukRaw1 = 0;
-				thisptr->ukRaw2 = 0;
-				thisptr->ukRaw3 = 0;
-				memset(thisptr->rawSpace, 0x00, 0x200);
-			}
-
-			return thisptr;
-		}
-	}
-
-	namespace RawDlTaskSetting
-	{
-		RawDlTaskSetting_t* ctor(RawDlTaskSetting_t* thisptr)
-		{
-			forceLogDebug_printf("nn_boss_RawDlTaskSetting_ctor(0x%x) TODO", MEMPTR(thisptr).GetMPTR());
-			if (!thisptr)
-			{
-				// thisptr = new RawDlTaskSetting_t
-				assert_dbg();
-			}
-
-			if (thisptr)
-			{
-				NetTaskSetting::ctor(thisptr);
-				thisptr->uknExt_vTableProbably = RawDlTaskSetting_t::kType;
-			}
-
-			return thisptr;
+			strncpy((char*)&_thisptr->settings[TaskSetting::kNbdlFileName], fileName, TaskSetting::kFileNameLen);
+			// also sets byte at +0x817 to zero?
+			return BUILD_NN_RESULT(NN_RESULT_LEVEL_SUCCESS, NN_RESULT_MODULE_NN_BOSS, 0x80);
 		}
 
-		Result Initialize(RawDlTaskSetting_t* thisptr, const char* url, bool newArrival, bool led, const char* fileName, const char* directoryName)
+		static void InitVTable()
 		{
-			forceLogDebug_printf("nn_boss_RawDlTaskSetting_Initialize(0x%x, 0x%x, %d, %d, 0x%x, 0x%x)", MEMPTR(thisptr).GetMPTR(), MEMPTR(url).GetMPTR(), newArrival, led, MEMPTR(fileName).GetMPTR(), MEMPTR(directoryName).GetMPTR());
+			s_VTable->rtti.ptr = nullptr; // todo
+			s_VTable->dtor.ptr = DTOR_WRAPPER(NbdlTaskSetting);
+			s_VTable->RegisterPreprocess.ptr = nullptr; // todo
+			s_VTable->unk1.ptr = nullptr; // todo
+			s_VTable->rttiNetTaskSetting.ptr = nullptr; // todo
+		}
+	};
+	static_assert(sizeof(NbdlTaskSetting) == 0x1004);
+
+	struct RawUlTaskSetting : NetTaskSetting
+	{
+		uint32be ukRaw1; // 0x1004
+		uint32be ukRaw2; // 0x1008
+		uint32be ukRaw3; // 0x100C
+		uint8 rawSpace[0x200]; // 0x1010
+
+		struct VTableRawUlTaskSetting : public VTableNetTaskSetting
+		{
+			VTableEntry rttiNetTaskSetting; // unknown
+		};
+		static_assert(sizeof(VTableRawUlTaskSetting) == 8*5);
+		static inline SysAllocator<VTableRawUlTaskSetting> s_VTable;
+
+		static RawUlTaskSetting* ctor(RawUlTaskSetting* _thisptr)
+		{
+			if (!_thisptr)
+				_thisptr = boss_new<RawUlTaskSetting>();
+			NetTaskSetting::ctor(_thisptr);
+			_thisptr->vTablePtr = s_VTable;
+			_thisptr->ukRaw1 = 0;
+			_thisptr->ukRaw2 = 0;
+			_thisptr->ukRaw3 = 0;
+			memset(_thisptr->rawSpace, 0x00, 0x200);
+			return _thisptr;
+		}
+
+		static void dtor(RawUlTaskSetting* _this, uint32 options)
+		{
+			cemuLog_logDebug(LogType::Force, "nn::boss::RawUlTaskSetting::dtor() is todo");
+		}
+
+		static void InitVTable()
+		{
+			s_VTable->rtti.ptr = nullptr; // todo
+			s_VTable->dtor.ptr = DTOR_WRAPPER(RawUlTaskSetting);
+			s_VTable->RegisterPreprocess.ptr = nullptr; // todo
+			s_VTable->unk1.ptr = nullptr; // todo
+			s_VTable->rttiNetTaskSetting.ptr = nullptr; // todo
+		}
+	};
+	static_assert(sizeof(RawUlTaskSetting) == 0x1210);
+
+	struct RawDlTaskSetting : NetTaskSetting
+	{
+		struct VTableRawDlTaskSetting : public VTableNetTaskSetting
+		{
+			VTableEntry rttiNetTaskSetting; // unknown
+		};
+		static_assert(sizeof(VTableRawDlTaskSetting) == 8*5);
+		static inline SysAllocator<VTableRawDlTaskSetting> s_VTable;
+
+		static RawDlTaskSetting* ctor(RawDlTaskSetting* _thisptr)
+		{
+			cemuLog_logDebug(LogType::Force, "nn_boss_RawDlTaskSetting_ctor(0x{:x}) TODO", MEMPTR(_thisptr).GetMPTR());
+			if (!_thisptr)
+				_thisptr = boss_new<RawDlTaskSetting>();
+			NetTaskSetting::ctor(_thisptr);
+			_thisptr->vTablePtr = s_VTable;
+			return _thisptr;
+		}
+
+		static Result Initialize(RawDlTaskSetting* _thisptr, const char* url, bool newArrival, bool led, const char* fileName, const char* directoryName)
+		{
+			cemuLog_logDebug(LogType::Force, "nn_boss_RawDlTaskSetting_Initialize(0x{:x}, 0x{:x}, {}, {}, 0x{:x}, 0x{:x})", MEMPTR(_thisptr).GetMPTR(), MEMPTR(url).GetMPTR(), newArrival, led, MEMPTR(fileName).GetMPTR(), MEMPTR(directoryName).GetMPTR());
 			if (!url)
 			{
 				return 0xC0203780;
 			}
 
-			if (strnlen(url, TaskSetting_t::kURLLen) == TaskSetting_t::kURLLen)
+			if (strnlen(url, TaskSetting::kURLLen) == TaskSetting::kURLLen)
 			{
 				return 0xC0203780;
 			}
 
-			forceLogDebug_printf("\t-> url: %s", url);
+			cemuLog_logDebug(LogType::Force, "\t-> url: {}", url);
 
-			if (fileName && strnlen(fileName, TaskSetting_t::kFileNameLen) == TaskSetting_t::kFileNameLen)
+			if (fileName && strnlen(fileName, TaskSetting::kFileNameLen) == TaskSetting::kFileNameLen)
 			{
 				return 0xC0203780;
 			}
 
-			if (directoryName && strnlen(directoryName, TaskSetting_t::kDirectoryNameLen) == TaskSetting_t::kDirectoryNameLen)
+			if (directoryName && strnlen(directoryName, TaskSetting::kDirectoryNameLen) == TaskSetting::kDirectoryNameLen)
 			{
 				return 0xC0203780;
 			}
 
-			strncpy((char*)thisptr + TaskSetting_t::kURL, url, TaskSetting_t::kURLLen);
-			thisptr->settings[0x147] = '\0';
+			strncpy((char*)_thisptr + TaskSetting::kURL, url, TaskSetting::kURLLen);
+			_thisptr->settings[0x147] = '\0';
 
 			if (fileName)
-				strncpy((char*)thisptr + 0x7D0, fileName, TaskSetting_t::kFileNameLen);
+				strncpy((char*)_thisptr + 0x7D0, fileName, TaskSetting::kFileNameLen);
 			else
-				strncpy((char*)thisptr + 0x7D0, "rawcontent.dat", TaskSetting_t::kFileNameLen);
-			thisptr->settings[0x7EF] = '\0';
+				strncpy((char*)_thisptr + 0x7D0, "rawcontent.dat", TaskSetting::kFileNameLen);
+			_thisptr->settings[0x7EF] = '\0';
 
-			forceLogDebug_printf("\t-> filename: %s", (char*)thisptr + 0x7D0);
+			cemuLog_logDebug(LogType::Force, "\t-> filename: {}", (char*)_thisptr + 0x7D0);
 
 			if (directoryName)
 			{
-				strncpy((char*)thisptr + 0x7C8, directoryName, TaskSetting_t::kDirectoryNameLen);
-				thisptr->settings[0x7CF] = '\0';
-				forceLogDebug_printf("\t-> directoryName: %s", (char*)thisptr + 0x7C8);
+				strncpy((char*)_thisptr + 0x7C8, directoryName, TaskSetting::kDirectoryNameLen);
+				_thisptr->settings[0x7CF] = '\0';
+				cemuLog_logDebug(LogType::Force, "\t-> directoryName: {}", (char*)_thisptr + 0x7C8);
 			}
 
-			thisptr->settings[0x7C0] = newArrival;
-			thisptr->settings[0x7C1] = led;
-			*(uint16be*)&thisptr->settings[0x28] = 0x3;
+			_thisptr->settings[0x7C0] = newArrival;
+			_thisptr->settings[0x7C1] = led;
+			*(uint16be*)&_thisptr->settings[0x28] = 0x3;
 			return 0x200080;
 		}
-	}
 
-	namespace PlayReportSetting // : NetTaskSetting
-	{
-		void export_ctor(PPCInterpreter_t* hCPU)
+		static void InitVTable()
 		{
-			ppcDefineParamMEMPTR(thisptr, PlayReportSetting_t, 0);
-			forceLogDebug_printf("nn_boss_PlayReportSetting_ctor TODO");
-			if (!thisptr)
-			{
-				assert_dbg();
-			}
+			s_VTable->rtti.ptr = nullptr; // todo
+			s_VTable->dtor.ptr = DTOR_WRAPPER(RawDlTaskSetting);
+			s_VTable->RegisterPreprocess.ptr = nullptr; // todo
+			s_VTable->unk1.ptr = nullptr; // todo
+			s_VTable->rttiNetTaskSetting.ptr = nullptr; // todo
+		}
+	};
+	static_assert(sizeof(RawDlTaskSetting) == 0x1004);
 
-			if (thisptr)
-			{
-				RawUlTaskSetting::ctor(thisptr.GetPtr());
-				thisptr->uknExt_vTableProbably = PlayReportSetting_t::kType;
-				thisptr->ukPlay1 = nullptr;
-				thisptr->ukPlay2 = 0;
-				thisptr->ukPlay3 = 0;
-				thisptr->ukPlay4 = 0;
-			}
+	struct PlayReportSetting : RawUlTaskSetting
+	{
+		MEMPTR<uint8> ukn1210_ptr; // 0x1210
+		uint32be ukn1214_size; // 0x1214
+		uint32be ukPlay3; // 0x1218
+		uint32be ukPlay4; // 0x121C
 
-			osLib_returnFromFunction(hCPU, thisptr.GetMPTR());
+		struct VTablePlayReportSetting : public VTableRawUlTaskSetting
+		{};
+		static_assert(sizeof(VTablePlayReportSetting) == 8*5);
+		static inline SysAllocator<VTablePlayReportSetting> s_VTable;
+
+		static PlayReportSetting* ctor(PlayReportSetting* _this)
+		{
+			if(!_this)
+				_this = boss_new<PlayReportSetting>();
+			RawUlTaskSetting::ctor(_this);
+			_this->vTablePtr = s_VTable;
+			_this->ukn1210_ptr = nullptr;
+			_this->ukn1214_size = 0;
+			_this->ukPlay3 = 0;
+			_this->ukPlay4 = 0;
+			return _this;
 		}
 
-		void export_Initialize(PPCInterpreter_t* hCPU)
+		static void dtor(PlayReportSetting* _this, uint32 options)
 		{
-			ppcDefineParamMEMPTR(thisptr, PlayReportSetting_t, 0);
-			ppcDefineParamMEMPTR(ptr, void*, 1);
-			ppcDefineParamU32(value, 2);
-			ppcDefineParamMEMPTR(directoryName, const char, 4);
-			//forceLogDebug_printf("nn_boss_PlayReportSetting_Initialize(0x%08x, %s, 0x%llx, 0x%08x)", thisptr.GetMPTR(), ptr.GetPtr(), directorySizeLimit, directoryName.GetMPTR());
+			RawUlTaskSetting::dtor(_this, 0);
+			if(options&1)
+				boss_delete(_this->ukn1210_ptr.GetPtr());
+		}
 
-			if(!ptr || value == 0 || value > 0x19000)
+		static void Initialize(PlayReportSetting* _this, uint8* ptr, uint32 size)
+		{
+			if(!ptr || size == 0 || size > 0x19000)
 			{
-				forceLogDebug_printf("nn_boss_PlayReportSetting_Initialize: invalid parameter");
-				osLib_returnFromFunction(hCPU, 0);
+				cemuLog_logDebug(LogType::Force, "nn::boss::PlayReportSetting::Initialize: invalid parameter");
+				return;
 			}
 
-			*ptr.GetPtr<uint8>() = 0;
+			*ptr = 0;
 
-			*(uint16be*)&thisptr->settings[0x28] = 6;
-			*(uint16be*)&thisptr->settings[0x2B] |= 0x3;
-			*(uint16be*)&thisptr->settings[0x2C] |= 0xA;
-			*(uint32be*)&thisptr->settings[0x7C0] |= 2;
-		
-			thisptr->ukPlay1 = ptr;
-			thisptr->ukPlay2 = value;
-			thisptr->ukPlay3 = 0;
-			thisptr->ukPlay4 = 0;
+			*(uint16be*)&_this->settings[0x28] = 6;
+			*(uint16be*)&_this->settings[0x2B] |= 0x3;
+			*(uint16be*)&_this->settings[0x2C] |= 0xA;
+			*(uint32be*)&_this->settings[0x7C0] |= 2;
+
+			_this->ukn1210_ptr = ptr;
+			_this->ukn1214_size = size;
+			_this->ukPlay3 = 0;
+			_this->ukPlay4 = 0;
 
 			// TODO
-			osLib_returnFromFunction(hCPU, 0);
 		}
 
-		void export_Set(PPCInterpreter_t* hCPU)
+		static bool Set(PlayReportSetting* _this, const char* keyname, uint32 value)
 		{
-			ppcDefineParamMEMPTR(thisptr, PlayReportSetting_t, 0);
-			ppcDefineParamMEMPTR(key, const char, 1);
-			ppcDefineParamU32(value, 2);
-			
 			// TODO
-			forceLogDebug_printf("nn_boss_PlayReportSetting_Set(0x%08x, %s, 0x%x) TODO", thisptr.GetMPTR(), key.GetPtr(), value);
-			
-			osLib_returnFromFunction(hCPU, 1);
+			return true;
 		}
 
-		
-	}
-
-	namespace Title
-	{
-		Title_t* ctor(Title_t* thisptr)
+		static void InitVTable()
 		{
-			forceLogDebug_printf("nn_boss_Title_ctor(0x%x)", MEMPTR(thisptr).GetMPTR());
-			if (!thisptr)
-			{
-				// thisptr = new Task_t
-				assert_dbg();
-			}
-
-			*thisptr = {};
-
-			return thisptr;
+			s_VTable->rtti.ptr = nullptr; // todo
+			s_VTable->dtor.ptr = DTOR_WRAPPER(PlayReportSetting);
+			s_VTable->RegisterPreprocess.ptr = nullptr; // todo
+			s_VTable->unk1.ptr = nullptr; // todo
+			s_VTable->rttiNetTaskSetting.ptr = nullptr; // todo
 		}
-	}
+	};
+	static_assert(sizeof(PlayReportSetting) == 0x1220);
 
-	namespace DirectoryName
+	struct Task
 	{
-		DirectoryName_t* ctor(DirectoryName_t* thisptr)
+		struct VTableTask
 		{
-			forceLogDebug_printf("nn_boss_DirectoryName_ctor(0x%x)", MEMPTR(thisptr).GetMPTR());
-			if (!thisptr)
-			{
-				// thisptr = new Task_t
-				assert_dbg();
-			}
+			VTableEntry rtti;
+			VTableEntry dtor;
+		};
+		static inline SysAllocator<VTableTask> s_vTable;
 
-			memset(thisptr->name, 0x00, 0x8);
+		uint32be accountId; // 0x00
+		uint32be uk2; // 0x04
+		TaskId taskId; // 0x08
+		TitleId titleId; // 0x10
+		MEMPTR<VTableTask> vTablePtr; // 0x18
+		uint32be padding; // 0x1C
 
-			return thisptr;
-		}
-		
-		const char* operator_const_char(DirectoryName_t* thisptr)
-		{
-			forceLogDebug_printf("nn_boss_DirectoryName_operator_const_char(0x%x)", MEMPTR(thisptr).GetMPTR());
-			return thisptr->name;
-		}
-	}
-
-	namespace Task
-	{
-
-		Result Initialize(Task_t* thisptr, const char* taskId, uint32 accountId)
+		static Result Initialize1(Task* _thisptr, const char* taskId, uint32 accountId) // Initialize__Q3_2nn4boss4TaskFPCcUi
 		{
 			if(!taskId || strnlen(taskId, 0x8) == 8)
 			{
 				return BUILD_NN_RESULT(NN_RESULT_LEVEL_LVL6, NN_RESULT_MODULE_NN_BOSS, 0x3780);
 			}
-
-			thisptr->accountId = accountId;
-			strncpy(thisptr->taskId.id, taskId, 0x08);
+			_thisptr->accountId = accountId;
+			strncpy(_thisptr->taskId.id, taskId, 0x08);
 			return BUILD_NN_RESULT(NN_RESULT_LEVEL_SUCCESS, NN_RESULT_MODULE_NN_BOSS, 0x80);
 		}
 
-		Result Initialize(Task_t* thisptr, uint8 slot, const char* taskId)
+		static Result Initialize2(Task* _thisptr, uint8 slot, const char* taskId) // Initialize__Q3_2nn4boss4TaskFUcPCc
 		{
 			const uint32 accountId = slot == 0 ? 0 : act::GetPersistentIdEx(slot);
-			return Initialize(thisptr, taskId, accountId);
+			return Initialize1(_thisptr, taskId, accountId);
 		}
 
-		Result Initialize(Task_t* thisptr, const char* taskId)
+		static Result Initialize3(Task* _thisptr, const char* taskId) // Initialize__Q3_2nn4boss4TaskFPCc
 		{
-			return Initialize(thisptr, taskId, 0);
+			return Initialize1(_thisptr, taskId, 0);
 		}
 
-		void export_Initialize3(PPCInterpreter_t* hCPU)
+		static Task* ctor2(Task* _thisptr, const char* taskId, uint32 accountId) // __ct__Q3_2nn4boss4TaskFPCcUi
 		{
-			ppcDefineParamMEMPTR(thisptr, Task_t, 0);
-			ppcDefineParamMEMPTR(taskId, const char, 1);
-			ppcDefineParamU32(accountId, 2);
-			forceLogDebug_printf("nn_boss_Task_Initialize3(0x%08x, %s, 0x%x)", thisptr.GetMPTR(), taskId.GetPtr(), accountId);
-			const Result result = Initialize(thisptr.GetPtr(), taskId.GetPtr(), accountId);
-			osLib_returnFromFunction(hCPU, result);
+			if (!_thisptr)
+				_thisptr = boss_new<Task>();
+			_thisptr->accountId = 0;
+			_thisptr->vTablePtr = s_vTable;
+			TaskId::ctor(&_thisptr->taskId);
+			TitleId::ctor(&_thisptr->titleId, 0);
+			auto r = Initialize1(_thisptr, taskId, accountId);
+			cemu_assert_debug(NN_RESULT_IS_SUCCESS(r));
+			return _thisptr;
 		}
 
-		void export_Initialize2(PPCInterpreter_t* hCPU)
+		static Task* ctor1(Task* _thisptr, uint8 slot, const char* taskId) // __ct__Q3_2nn4boss4TaskFUcPCc
 		{
-			ppcDefineParamMEMPTR(thisptr, Task_t, 0);
-			ppcDefineParamU8(slotId, 1);
-			ppcDefineParamMEMPTR(taskId, const char, 2);
-			forceLogDebug_printf("nn_boss_Task_Initialize2(0x%08x, %d, %s)", thisptr.GetMPTR(), slotId, taskId.GetPtr());
-			const Result result = Initialize(thisptr.GetPtr(), slotId, taskId.GetPtr());
-			osLib_returnFromFunction(hCPU, result);
-		}
-		
-		void export_Initialize1(PPCInterpreter_t* hCPU)
-		{
-			ppcDefineParamMEMPTR(thisptr, Task_t, 0);
-			ppcDefineParamMEMPTR(taskId, const char, 1);
-			forceLogDebug_printf("nn_boss_Task_Initialize1(0x%08x, %s)", thisptr.GetMPTR(), taskId.GetPtr());
-			const Result result = Initialize(thisptr.GetPtr(), taskId.GetPtr());
-			osLib_returnFromFunction(hCPU, result);
+			if (!_thisptr)
+				_thisptr = boss_new<Task>();
+			_thisptr->accountId = 0;
+			_thisptr->vTablePtr = s_vTable;
+			TaskId::ctor(&_thisptr->taskId);
+			TitleId::ctor(&_thisptr->titleId, 0);
+			auto r = Initialize2(_thisptr, slot, taskId);
+			cemu_assert_debug(NN_RESULT_IS_SUCCESS(r));
+			return _thisptr;
 		}
 
-	
-		Task_t* ctor(Task_t* thisptr, const char* taskId, uint32 accountId)
+		static Task* ctor3(Task* _thisptr, const char* taskId) // __ct__Q3_2nn4boss4TaskFPCc
 		{
-			if (!thisptr)
-			{
-				// thisptr = new Task_t
-				assert_dbg();
-			}
-
-			if (thisptr)
-			{
-				thisptr->accountId = 0;
-				thisptr->ext = 0; // dword_10002174
-				TaskId::ctor(&thisptr->taskId);
-				TitleId::ctor(&thisptr->titleId, 0);
-				cemu_assert_debug(NN_RESULT_IS_SUCCESS(Initialize(thisptr, taskId, accountId)));
-			}
-
-			return thisptr;
+			if (!_thisptr)
+				_thisptr = boss_new<Task>();
+			_thisptr->accountId = 0;
+			_thisptr->vTablePtr = s_vTable;
+			TaskId::ctor(&_thisptr->taskId);
+			TitleId::ctor(&_thisptr->titleId, 0);
+			auto r = Initialize3(_thisptr, taskId);
+			cemu_assert_debug(NN_RESULT_IS_SUCCESS(r));
+			return _thisptr;
 		}
 
-		Task_t* ctor(Task_t* thisptr, uint8 slot, const char* taskId)
+		static Task* ctor4(Task* _thisptr) // __ct__Q3_2nn4boss4TaskFv
 		{
-			if (!thisptr)
-			{
-				// thisptr = new Task_t
-				assert_dbg();
-			}
-
-			if (thisptr)
-			{
-				thisptr->accountId = 0;
-				thisptr->ext = 0; // dword_10002174
-				TaskId::ctor(&thisptr->taskId);
-				TitleId::ctor(&thisptr->titleId, 0);
-				cemu_assert_debug(NN_RESULT_IS_SUCCESS(Initialize(thisptr, slot, taskId)));
-			}
-
-			return thisptr;
+			if (!_thisptr)
+				_thisptr = boss_new<Task>();
+			_thisptr->accountId = 0;
+			_thisptr->vTablePtr = s_vTable;
+			TaskId::ctor(&_thisptr->taskId);
+			TitleId::ctor(&_thisptr->titleId, 0);
+			memset(&_thisptr->taskId, 0x00, sizeof(TaskId));
+			return _thisptr;
 		}
 
-		Task_t* ctor(Task_t* thisptr, const char* taskId)
+		static void dtor(Task* _this, uint32 options) // __dt__Q3_2nn4boss4TaskFv
 		{
-			if (!thisptr)
-			{
-				// thisptr = new Task_t
-				assert_dbg();
-			}
-
-			if (thisptr)
-			{
-				thisptr->accountId = 0;
-				thisptr->ext = 0; // dword_10002174
-				TaskId::ctor(&thisptr->taskId);
-				TitleId::ctor(&thisptr->titleId, 0);
-				cemu_assert_debug(NN_RESULT_IS_SUCCESS(Initialize(thisptr, taskId)));
-			}
-			
-			return thisptr;
+			cemuLog_logDebug(LogType::Force, "nn::boss::Task::dtor(0x{:08x}, 0x{:08x})", MEMPTR(_this).GetMPTR(), options);
+			// todo - Task::Finalize
+			if(options & 1)
+				boss_delete(_this);
 		}
 
-		Task_t* ctor(Task_t* thisptr)
+		static Result Run(Task* _thisptr, bool isForegroundRun)
 		{
-			if (!thisptr)
-			{
-				// thisptr = new Task_t
-				assert_dbg();
-			}
-
-			if (thisptr)
-			{
-				thisptr->accountId = 0;
-				thisptr->ext = 0; // dword_10002174
-				TaskId::ctor(&thisptr->taskId);
-				TitleId::ctor(&thisptr->titleId, 0);
-				memset(&thisptr->taskId, 0x00, sizeof(TaskId_t));
-			}
-
-			return thisptr;
-		}
-
-		void export_ctor(PPCInterpreter_t* hCPU)
-		{
-			ppcDefineParamMEMPTR(thisptr, Task_t, 0);
-			forceLogDebug_printf("nn_boss_Task_ctor(0x%08x)", thisptr.GetMPTR());
-			ctor(thisptr.GetPtr());
-			osLib_returnFromFunction(hCPU, thisptr.GetMPTR());
-		}
-
-		void export_Run(PPCInterpreter_t* hCPU)
-		{
-			ppcDefineParamMEMPTR(thisptr, Task_t, 0);
-			ppcDefineParamU8(isForegroundRun, 1);
-			forceLogDebug_printf("nn_boss_Task_Run(0x%08x, %d)", thisptr.GetMPTR(), isForegroundRun);
 			if (isForegroundRun != 0)
 			{
-				//peterBreak();
-				forceLogDebug_printf("export_Run foreground run");
+				cemuLog_logDebug(LogType::Force, "export_Run foreground run");
 			}
 
 			bossPrepareRequest();
 			bossRequest->requestCode = IOSU_NN_BOSS_TASK_RUN;
-			bossRequest->accountId = thisptr->accountId;
-			bossRequest->taskId = thisptr->taskId.id;
-			bossRequest->titleId = thisptr->titleId.u64;
+			bossRequest->accountId = _thisptr->accountId;
+			bossRequest->taskId = _thisptr->taskId.id;
+			bossRequest->titleId = _thisptr->titleId.u64;
 			bossRequest->bool_parameter = isForegroundRun != 0;
-			
+
 			__depr__IOS_Ioctlv(IOS_DEVICE_BOSS, IOSU_BOSS_REQUEST_CEMU, 1, 1, bossBufferVector);
-	
-			osLib_returnFromFunction(hCPU, 0);
+
+			return 0;
 		}
 
-		void export_StartScheduling(PPCInterpreter_t* hCPU)
+		static Result StartScheduling(Task* _thisptr, uint8 executeImmediately)
 		{
-			ppcDefineParamMEMPTR(thisptr, Task_t, 0);
-			ppcDefineParamU8(executeImmediately, 1);
-			forceLogDebug_printf("nn_boss_Task_StartScheduling(0x%08x, %d)", thisptr.GetMPTR(), executeImmediately);
-
 			bossPrepareRequest();
 			bossRequest->requestCode = IOSU_NN_BOSS_TASK_START_SCHEDULING;
-			bossRequest->accountId = thisptr->accountId;
-			bossRequest->taskId = thisptr->taskId.id;
-			bossRequest->titleId = thisptr->titleId.u64;
+			bossRequest->accountId = _thisptr->accountId;
+			bossRequest->taskId = _thisptr->taskId.id;
+			bossRequest->titleId = _thisptr->titleId.u64;
 			bossRequest->bool_parameter = executeImmediately != 0;
-			
+
 			__depr__IOS_Ioctlv(IOS_DEVICE_BOSS, IOSU_BOSS_REQUEST_CEMU, 1, 1, bossBufferVector);
-	
-			osLib_returnFromFunction(hCPU, 0);
+
+			return 0;
 		}
 
-		void export_StopScheduling(PPCInterpreter_t* hCPU)
+		static Result StopScheduling(Task* _thisptr)
 		{
-			ppcDefineParamMEMPTR(thisptr, Task_t, 0);
-			forceLogDebug_printf("nn_boss_Task_StopScheduling(0x%08x)", thisptr.GetMPTR());
-
 			bossPrepareRequest();
 			bossRequest->requestCode = IOSU_NN_BOSS_TASK_STOP_SCHEDULING;
-			bossRequest->accountId = thisptr->accountId;
-			bossRequest->taskId = thisptr->taskId.id;
-			bossRequest->titleId = thisptr->titleId.u64;
-			
+			bossRequest->accountId = _thisptr->accountId;
+			bossRequest->taskId = _thisptr->taskId.id;
+			bossRequest->titleId = _thisptr->titleId.u64;
+
 			__depr__IOS_Ioctlv(IOS_DEVICE_BOSS, IOSU_BOSS_REQUEST_CEMU, 1, 1, bossBufferVector);
-	
-			osLib_returnFromFunction(hCPU, 0);
+
+			return 0;
 		}
 
-		void export_IsRegistered(PPCInterpreter_t* hCPU)
+		static Result IsRegistered(Task* _thisptr)
 		{
-			ppcDefineParamMEMPTR(thisptr, Task_t, 0);
-			
 			bossPrepareRequest();
 			bossRequest->requestCode = IOSU_NN_BOSS_TASK_IS_REGISTERED;
-			bossRequest->accountId = thisptr->accountId;
-			bossRequest->titleId = thisptr->titleId.u64;
-			bossRequest->taskId = thisptr->taskId.id;
+			bossRequest->accountId = _thisptr->accountId;
+			bossRequest->titleId = _thisptr->titleId.u64;
+			bossRequest->taskId = _thisptr->taskId.id;
 
 			__depr__IOS_Ioctlv(IOS_DEVICE_BOSS, IOSU_BOSS_REQUEST_CEMU, 1, 1, bossBufferVector);
 
-			forceLogDebug_printf("nn_boss_Task_IsRegistered(0x%08x) -> %d", thisptr.GetMPTR(), bossRequest->returnCode);
-
-			osLib_returnFromFunction(hCPU, bossRequest->returnCode);
+			return bossRequest->returnCode;
 		}
 
-		void export_Wait(PPCInterpreter_t* hCPU)
+		static Result Wait(Task* _thisptr, uint32 timeout, uint32 waitState) // Wait__Q3_2nn4boss4TaskFUiQ3_2nn4boss13TaskWaitState
 		{
-			// Wait__Q3_2nn4boss4TaskFUiQ3_2nn4boss13TaskWaitState
-			ppcDefineParamMEMPTR(thisptr, Task_t, 0);
-			ppcDefineParamU32(timeout, 1);
-			ppcDefineParamU32(waitState, 2);
-			forceLogDebug_printf("nn_boss_Task_Wait(0x%08x, 0x%x, %d)", thisptr.GetMPTR(), timeout, waitState);
-
 			bossPrepareRequest();
 			bossRequest->requestCode = IOSU_NN_BOSS_TASK_WAIT;
-			bossRequest->titleId = thisptr->titleId.u64;
-			bossRequest->taskId = thisptr->taskId.id;
+			bossRequest->titleId = _thisptr->titleId.u64;
+			bossRequest->taskId = _thisptr->taskId.id;
 			bossRequest->timeout = timeout;
 			bossRequest->waitState = waitState;
 
 			__depr__IOS_Ioctlv(IOS_DEVICE_BOSS, IOSU_BOSS_REQUEST_CEMU, 1, 1, bossBufferVector);
 
-			osLib_returnFromFunction(hCPU, bossRequest->returnCode);
-
-			//osLib_returnFromFunction(hCPU, 1); // 0 -> timeout, 1 -> wait condition met
+			return bossRequest->returnCode;
 		}
 
-		void export_RegisterForImmediateRun(PPCInterpreter_t* hCPU)
+		static Result RegisterForImmediateRun(Task* _thisptr, TaskSetting* settings) // RegisterForImmediateRun__Q3_2nn4boss4TaskFRCQ3_2nn4boss11TaskSetting
 		{
-			// RegisterForImmediateRun__Q3_2nn4boss4TaskFRCQ3_2nn4boss11TaskSetting
-			ppcDefineParamMEMPTR(thisptr, Task_t, 0);
-			ppcDefineParamMEMPTR(settings, TaskSetting_t, 1);
-			forceLogDebug_printf("nn_boss_Task_RegisterForImmediateRun(0x%08x, 0x%08x)", thisptr.GetMPTR(), settings.GetMPTR());
-
 			bossPrepareRequest();
 			bossRequest->requestCode = IOSU_NN_BOSS_TASK_REGISTER;
-			bossRequest->accountId = thisptr->accountId;
-			bossRequest->taskId = thisptr->taskId.id;
-			bossRequest->settings = settings.GetPtr();
+			bossRequest->accountId = _thisptr->accountId;
+			bossRequest->taskId = _thisptr->taskId.id;
+			bossRequest->settings = settings;
 			bossRequest->uk1 = 0xC00;
 
-			if (TaskSetting::IsPrivilegedTaskSetting(settings.GetPtr()))
-				bossRequest->titleId = thisptr->titleId.u64;
+			if (TaskSetting::IsPrivileged(settings))
+				bossRequest->titleId = _thisptr->titleId.u64;
 
-			const sint32 result = __depr__IOS_Ioctlv(IOS_DEVICE_BOSS, IOSU_BOSS_REQUEST_CEMU, 1, 1, bossBufferVector);
-			osLib_returnFromFunction(hCPU, result);
+			Result result = __depr__IOS_Ioctlv(IOS_DEVICE_BOSS, IOSU_BOSS_REQUEST_CEMU, 1, 1, bossBufferVector);
+			return result;
 		}
 
-		void export_Unregister(PPCInterpreter_t* hCPU)
+		static Result Unregister(Task* _thisptr)
 		{
-			ppcDefineParamMEMPTR(thisptr, Task_t, 0);
-			forceLogDebug_printf("nn_boss_Task_Unregister(0x%08x)", thisptr.GetMPTR());
-
 			bossPrepareRequest();
 			bossRequest->requestCode = IOSU_NN_BOSS_TASK_UNREGISTER;
-			bossRequest->accountId = thisptr->accountId;
-			bossRequest->taskId = thisptr->taskId.id;
-			bossRequest->titleId = thisptr->titleId.u64;
+			bossRequest->accountId = _thisptr->accountId;
+			bossRequest->taskId = _thisptr->taskId.id;
+			bossRequest->titleId = _thisptr->titleId.u64;
 
 			const sint32 result = __depr__IOS_Ioctlv(IOS_DEVICE_BOSS, IOSU_BOSS_REQUEST_CEMU, 1, 1, bossBufferVector);
-			osLib_returnFromFunction(hCPU, result);
+			return result;
 		}
 
-		void export_Register(PPCInterpreter_t* hCPU)
+		static Result Register(Task* _thisptr, TaskSetting* settings)
 		{
-			ppcDefineParamMEMPTR(thisptr, Task_t, 0);
-			ppcDefineParamMEMPTR(settings, TaskSetting_t, 1);
-			forceLogDebug_printf("nn_boss_Task_Register(0x%08x, 0x%08x)", thisptr.GetMPTR(), settings.GetMPTR());
-
-			if (hCPU->gpr[4] == 0)
+			if (!settings)
 			{
-				forceLogDebug_printf("nn_boss_Task_Register - crash workaround (fix me)");
-				osLib_returnFromFunction(hCPU, 0);
-				return;
+				cemuLog_logDebug(LogType::Force, "nn_boss_Task_Register - crash workaround (fix me)"); // settings should never be zero
+				return 0;
 			}
 
 			bossPrepareRequest();
 			bossRequest->requestCode = IOSU_NN_BOSS_TASK_REGISTER_FOR_IMMEDIATE_RUN;
-			bossRequest->accountId = thisptr->accountId;
-			bossRequest->taskId = thisptr->taskId.id;
-			bossRequest->settings = settings.GetPtr();
+			bossRequest->accountId = _thisptr->accountId;
+			bossRequest->taskId = _thisptr->taskId.id;
+			bossRequest->settings = settings;
 			bossRequest->uk1 = 0xC00;
 
-			if(TaskSetting::IsPrivilegedTaskSetting(settings.GetPtr()))
-				bossRequest->titleId = thisptr->titleId.u64;
+			if(TaskSetting::IsPrivileged(settings))
+				bossRequest->titleId = _thisptr->titleId.u64;
 
 			__depr__IOS_Ioctlv(IOS_DEVICE_BOSS, IOSU_BOSS_REQUEST_CEMU, 1, 1, bossBufferVector);
 
-			osLib_returnFromFunction(hCPU, bossRequest->returnCode);
+			return bossRequest->returnCode;
 		}
-		
-		
-		void export_GetTurnState(PPCInterpreter_t* hCPU)
+
+		static uint32 GetTurnState(Task* _this, uint32be* executionCountOut)
 		{
-			ppcDefineParamMEMPTR(thisptr, Task_t, 0);
-			ppcDefineParamMEMPTR(execCount, uint32be, 1);
-			
 			bossPrepareRequest();
 			bossRequest->requestCode = IOSU_NN_BOSS_TASK_GET_TURN_STATE;
-			bossRequest->accountId = thisptr->accountId;
-			bossRequest->taskId = thisptr->taskId.id;
-			bossRequest->titleId = thisptr->titleId.u64;
+			bossRequest->accountId = _this->accountId;
+			bossRequest->taskId = _this->taskId.id;
+			bossRequest->titleId = _this->titleId.u64;
 
 			__depr__IOS_Ioctlv(IOS_DEVICE_BOSS, IOSU_BOSS_REQUEST_CEMU, 1, 1, bossBufferVector);
 
-			if (execCount)
-				*execCount = bossRequest->u32.exec_count;
+			if (executionCountOut)
+				*executionCountOut = bossRequest->u32.exec_count;
 
-			forceLogDebug_printf("nn_boss_Task_GetTurnState(0x%08x, 0x%08x) -> %d", thisptr.GetMPTR(), execCount.GetMPTR(), bossRequest->u32.result);
-
-			osLib_returnFromFunction(hCPU, bossRequest->u32.result);
-			//osLib_returnFromFunction(hCPU, 7); // 7 -> finished? 0x11 -> Error (Splatoon doesn't like it when we return 0x11 for Nbdl tasks) RETURN FINISHED
+			return bossRequest->u32.result;
+			// 7 -> finished? 0x11 -> Error (Splatoon doesn't like it when we return 0x11 for Nbdl tasks)
 		}
 
-		void export_GetContentLength(PPCInterpreter_t* hCPU)
+		static uint64 GetContentLength(Task* _this, uint32be* executionCountOut)
 		{
-			ppcDefineParamMEMPTR(thisptr, Task_t, 0);
-			ppcDefineParamMEMPTR(execCount, uint32be, 1);
-			
 			bossPrepareRequest();
 			bossRequest->requestCode = IOSU_NN_BOSS_TASK_GET_CONTENT_LENGTH;
-			bossRequest->accountId = thisptr->accountId;
-			bossRequest->taskId = thisptr->taskId.id;
-			bossRequest->titleId = thisptr->titleId.u64;
+			bossRequest->accountId = _this->accountId;
+			bossRequest->taskId = _this->taskId.id;
+			bossRequest->titleId = _this->titleId.u64;
 
 			__depr__IOS_Ioctlv(IOS_DEVICE_BOSS, IOSU_BOSS_REQUEST_CEMU, 1, 1, bossBufferVector);
 
-			if (execCount)
-				*execCount = bossRequest->u64.exec_count;
+			if (executionCountOut)
+				*executionCountOut = bossRequest->u64.exec_count;
 
-			forceLogDebug_printf("nn_boss_Task_GetContentLength(0x%08x, 0x%08x) -> 0x%llx", thisptr.GetMPTR(), execCount.GetMPTR(), bossRequest->u64.result);
-
-			osLib_returnFromFunction64(hCPU, bossRequest->u64.result);
+			return bossRequest->u64.result;
 		}
 
-		void export_GetProcessedLength(PPCInterpreter_t* hCPU)
+		static uint64 GetProcessedLength(Task* _this, uint32be* executionCountOut)
 		{
-			ppcDefineParamMEMPTR(thisptr, Task_t, 0);
-			ppcDefineParamMEMPTR(execCount, uint32be, 1);
-			
 			bossPrepareRequest();
 			bossRequest->requestCode = IOSU_NN_BOSS_TASK_GET_PROCESSED_LENGTH;
-			bossRequest->accountId = thisptr->accountId;
-			bossRequest->taskId = thisptr->taskId.id;
-			bossRequest->titleId = thisptr->titleId.u64;
+			bossRequest->accountId = _this->accountId;
+			bossRequest->taskId = _this->taskId.id;
+			bossRequest->titleId = _this->titleId.u64;
 
 			__depr__IOS_Ioctlv(IOS_DEVICE_BOSS, IOSU_BOSS_REQUEST_CEMU, 1, 1, bossBufferVector);
 
-			if (execCount)
-				*execCount = bossRequest->u64.exec_count;
-
-			forceLogDebug_printf("nn_boss_Task_GetProcessedLength(0x%08x, 0x%08x) -> 0x%llx", thisptr.GetMPTR(), execCount.GetMPTR(), bossRequest->u64.result);
-
-			osLib_returnFromFunction64(hCPU, bossRequest->u64.result);
+			if (executionCountOut)
+				*executionCountOut = bossRequest->u64.exec_count;
+			return bossRequest->u64.result;
 		}
 
-		void export_GetHttpStatusCode(PPCInterpreter_t* hCPU)
+		static uint32 GetHttpStatusCode(Task* _this, uint32be* executionCountOut)
 		{
-			ppcDefineParamMEMPTR(thisptr, Task_t, 0);
-			ppcDefineParamMEMPTR(execCount, uint32be, 1);
-			
 			bossPrepareRequest();
 			bossRequest->requestCode = IOSU_NN_BOSS_TASK_GET_HTTP_STATUS_CODE;
-			bossRequest->accountId = thisptr->accountId;
-			bossRequest->taskId = thisptr->taskId.id;
-			bossRequest->titleId = thisptr->titleId.u64;
+			bossRequest->accountId = _this->accountId;
+			bossRequest->taskId = _this->taskId.id;
+			bossRequest->titleId = _this->titleId.u64;
 
 			__depr__IOS_Ioctlv(IOS_DEVICE_BOSS, IOSU_BOSS_REQUEST_CEMU, 1, 1, bossBufferVector);
 
-			if (execCount)
-				*execCount = bossRequest->u32.exec_count;
+			if (executionCountOut)
+				*executionCountOut = bossRequest->u32.exec_count;
 
-			forceLogDebug_printf("nn_boss_Task_GetHttpStatusCode(0x%08x, 0x%08x) -> %d", thisptr.GetMPTR(), execCount.GetMPTR(), bossRequest->u32.result);
-
-			osLib_returnFromFunction(hCPU, bossRequest->u32.result);
+			return bossRequest->u32.result;
 		}
-	}
 
-	struct PrivilegedTask_t : Task_t
-	{
-		
+		static void InitVTable()
+		{
+			s_vTable->rtti.ptr = nullptr; // todo
+			s_vTable->dtor.ptr = RPLLoader_MakePPCCallable([](PPCInterpreter_t* hCPU) { Task::dtor(MEMPTR<Task>(hCPU->gpr[3]), hCPU->gpr[4]); osLib_returnFromFunction(hCPU, 0); });
+		}
 	};
-	static_assert(sizeof(PrivilegedTask_t) == 0x20);
-	
-	struct AlmightyTask_t : PrivilegedTask_t
+
+	static_assert(sizeof(Task) == 0x20);
+
+	struct PrivilegedTask : Task
 	{
-		
+		struct VTablePrivilegedTask : public VTableTask
+		{
+			VTableEntry rttiTask;
+		};
+		static_assert(sizeof(VTablePrivilegedTask) == 8*3);
+		static inline SysAllocator<VTablePrivilegedTask> s_VTable;
+
+		static PrivilegedTask* ctor(PrivilegedTask* _thisptr)
+		{
+			if (!_thisptr)
+				_thisptr = boss_new<PrivilegedTask>();
+			Task::ctor4(_thisptr);
+			_thisptr->vTablePtr = s_VTable;
+			return _thisptr;
+		}
+
+		static void dtor(PrivilegedTask* _this, uint32 options)
+		{
+			if(!_this)
+				return;
+			Task::dtor(_this, 0);
+			if(options & 1)
+				boss_delete(_this);
+		}
+
+		static void InitVTable()
+		{
+			s_VTable->rtti.ptr = nullptr; // todo
+			s_VTable->dtor.ptr = DTOR_WRAPPER(PrivilegedTask);
+			s_VTable->rttiTask.ptr = nullptr; // todo
+		}
 	};
-	static_assert(sizeof(AlmightyTask_t) == 0x20);
+	static_assert(sizeof(PrivilegedTask) == 0x20);
 
-	namespace PrivilegedTask
+	struct AlmightyTask : PrivilegedTask
 	{
-		PrivilegedTask_t* ctor(PrivilegedTask_t*thisptr)
-		{
-			if (!thisptr)
-				assert_dbg(); // new
+		struct VTableAlmightyTask : public VTablePrivilegedTask
+		{};
+		static_assert(sizeof(VTableAlmightyTask) == 8*3);
+		static inline SysAllocator<VTableAlmightyTask> s_VTable;
 
-			Task::ctor(thisptr);
-			thisptr->ext = 0x10003a50;
-			return thisptr;
-		}
-	}
-	
-	namespace AlmightyTask
-	{
-		AlmightyTask_t* ctor(AlmightyTask_t* thisptr)
+		static AlmightyTask* ctor(AlmightyTask* _thisptr)
 		{
-			if (!thisptr)
-				assert_dbg(); // new
+			if (!_thisptr)
+				_thisptr = boss_new<AlmightyTask>();
+			PrivilegedTask::ctor(_thisptr);
+			_thisptr->vTablePtr = s_VTable;
+			return _thisptr;
+		}
 
-			PrivilegedTask::ctor(thisptr);
-			thisptr->ext = 0x10002a0c;
-			return thisptr;
-		}
-		void dtor(AlmightyTask_t* thisptr)
+		static void dtor(AlmightyTask* _thisptr, uint32 options)
 		{
-			if (thisptr)
-				freeMem(thisptr);
+			if (!_thisptr)
+				return;
+			PrivilegedTask::dtor(_thisptr, 0);
+			if(options&1)
+				boss_delete(_thisptr);
 		}
-		
-		uint32 Initialize(AlmightyTask_t* thisptr, TitleId_t* titleId, const char* taskId, uint32 accountId)
+
+		static uint32 Initialize(AlmightyTask* _thisptr, TitleId* titleId, const char* taskId, uint32 accountId)
 		{
-			if (!thisptr)
+			if (!_thisptr)
 				return 0xc0203780;
 
-			thisptr->accountId = accountId;
-			thisptr->titleId.u64 = titleId->u64;
-			strncpy(thisptr->taskId.id, taskId, 8);
-			thisptr->taskId.id[7] = 0x00;
-			
+			_thisptr->accountId = accountId;
+			_thisptr->titleId.u64 = titleId->u64;
+			strncpy(_thisptr->taskId.id, taskId, 8);
+			_thisptr->taskId.id[7] = 0x00;
+
 			return 0x200080;
 		}
-	}
 
-	Result InitializeImpl()
-	{
-		// if( Initialize(IpcClientCafe*) ) ...
-		g_isInitialized = true;
-		return 0;
-	}
-
-	void export_IsInitialized(PPCInterpreter_t* hCPU)
-	{
-		osLib_returnFromFunction(hCPU, (uint32)g_isInitialized);
-	}
-
-	Result Initialize()
-	{
-		Result result;
-		coreinit::OSLockMutex(&g_mutex);
-
-		if(g_initCounter != 0 || NN_RESULT_IS_SUCCESS((result=InitializeImpl())))
+		static void InitVTable()
 		{
-			g_initCounter++;
-			result = 0;
+			s_VTable->rtti.ptr = nullptr; // todo
+			s_VTable->dtor.ptr = DTOR_WRAPPER(AlmightyTask);
+			s_VTable->rttiTask.ptr = nullptr; // todo
+		}
+	};
+	static_assert(sizeof(AlmightyTask) == 0x20);
+
+	struct DataName
+	{
+		char name[32];
+
+		static DataName* ctor(DataName* _this) // __ct__Q3_2nn4boss8DataNameFv
+		{
+			if(!_this)
+				_this = boss_new<DataName>();
+			memset(_this->name, 0, sizeof(name));
+			return _this;
 		}
 
-		coreinit::OSUnlockMutex(&g_mutex);
-		return result;
-	}
+		static const char* operator_const_char(DataName* _this) // __opPCc__Q3_2nn4boss8DataNameCFv
+		{
+			return _this->name;
+		}
+	};
+	static_assert(sizeof(DataName) == 0x20);
 
-	void export_Initialize(PPCInterpreter_t* hCPU)
+	struct BossStorageFadEntry
 	{
-		forceLogDebug_printf("nn_boss_Initialize()");
-		osLib_returnFromFunction(hCPU, Initialize());
-	}
-
-	void export_GetBossState(PPCInterpreter_t* hCPU)
-	{
-		forceLogDebug_printf("nn_boss.GetBossState() - stub");
-		osLib_returnFromFunction(hCPU, 7);
-	}
-
-	enum StorageKind
-	{
-		kStorageKind_NBDL,
-		kStorageKind_RawDl,
+		char name[32];
+		uint32be fileNameId;
+		uint32 ukn24;
+		uint32 ukn28;
+		uint32 ukn2C;
+		uint32 ukn30;
+		uint32be timestampRelated; // guessed
 	};
 
-	namespace Storage
+#define FAD_ENTRY_MAX_COUNT		512
+
+	struct Storage
 	{
-		struct bossStorage_t
+		struct VTableStorage
 		{
-			/* +0x00 */ uint32be accountId;
-			/* +0x04 */ uint32be storageKind;
-			/* +0x08 */ uint8 ukn08Array[3];
-			/* +0x0B */ char storageName[8];
-			uint8 ukn13;
-			uint8 ukn14;
-			uint8 ukn15;
-			uint8 ukn16;
-			uint8 ukn17;
-			/* +0x18 */
-			nn::boss::TitleId_t titleId;
-			uint32be ukn20; // pointer to some global struct
-			uint32be ukn24;
+			VTableEntry rtti;
+			VTableEntry dtor;
 		};
-		
-		static_assert(sizeof(bossStorage_t) == 0x28);
-		static_assert(offsetof(bossStorage_t, storageKind) == 0x04);
-		static_assert(offsetof(bossStorage_t, ukn08Array) == 0x08);
-		static_assert(offsetof(bossStorage_t, storageName) == 0x0B);
-		static_assert(offsetof(bossStorage_t, titleId) == 0x18);
+		static inline SysAllocator<VTableStorage> s_vTable;
 
-		bossStorage_t* ctor(bossStorage_t* thisptr)
+		enum StorageKind
 		{
-			forceLogDebug_printf("nn_boss_Storage_ctor(0x%x)", MEMPTR(thisptr).GetMPTR());
-			if (!thisptr)
-			{
-				// thisptr = new RawDlTaskSetting_t
-				assert_dbg();
-			}
+			kStorageKind_NBDL,
+			kStorageKind_RawDl,
+		};
 
-			if (thisptr)
-			{
-				thisptr->titleId.u64 = 0;
-				thisptr->ukn20 = 0x10000a64;
-			}
+		/* +0x00 */ uint32be accountId;
+		/* +0x04 */ uint32be storageKind;
+		/* +0x08 */ uint8 ukn08Array[3];
+		/* +0x0B */ char storageName[8];
+		uint8 ukn13;
+		uint8 ukn14;
+		uint8 ukn15;
+		uint8 ukn16;
+		uint8 ukn17;
+		/* +0x18 */ nn::boss::TitleId titleId;
+		/* +0x20 */ MEMPTR<VTableStorage> vTablePtr;
+		/* +0x24 */ uint32be ukn24;
 
-			return thisptr;
+		static nn::boss::Storage* ctor1(nn::boss::Storage* _this) // __ct__Q3_2nn4boss7StorageFv
+		{
+			if(!_this)
+				_this = boss_new<nn::boss::Storage>();
+			_this->vTablePtr = s_vTable;
+			_this->titleId.u64 = 0;
+			return _this;
 		}
 
-		void nnBossStorage_prepareTitleId(bossStorage_t* storage)
+		static void dtor(nn::boss::Storage* _this, uint32 options) // __dt__Q3_2nn4boss7StorageFv
+		{
+			cemuLog_logDebug(LogType::Force, "nn::boss::Storage::dtor(0x{:08x}, 0x{:08x})", MEMPTR(_this).GetMPTR(), options);
+			Finalize(_this);
+			if(options & 1)
+				boss_delete(_this);
+		}
+
+		static void nnBossStorage_prepareTitleId(Storage* storage)
 		{
 			if (storage->titleId.u64 != 0)
 				return;
 			storage->titleId.u64 = CafeSystem::GetForegroundTitleId();
 		}
 
-		Result Initialize(bossStorage_t* thisptr, const char* dirName, uint32 accountId, StorageKind type)
+		static Result Initialize(Storage* _thisptr, const char* dirName, uint32 accountId, StorageKind type)
 		{
 			if (!dirName)
 				return 0xC0203780;
 
-			forceLogDebug_printf("boss::Storage::Initialize(%s, 0x%08x, %d)", dirName, accountId, type);
+			cemuLog_logDebug(LogType::Force, "boss::Storage::Initialize({}, 0x{:08x}, {})", dirName, accountId, type);
 
-			thisptr->storageKind = type;
-			thisptr->titleId.u64 = 0;
+			_thisptr->storageKind = type;
+			_thisptr->titleId.u64 = 0;
 
-			memset(thisptr->storageName, 0, 0x8);
-			strncpy(thisptr->storageName, dirName, 0x8);
-			thisptr->storageName[7] = '\0';
+			memset(_thisptr->storageName, 0, 0x8);
+			strncpy(_thisptr->storageName, dirName, 0x8);
+			_thisptr->storageName[7] = '\0';
 
-			thisptr->accountId = accountId;
+			_thisptr->accountId = accountId;
 
-			nnBossStorage_prepareTitleId(thisptr); // usually not done like this
+			nnBossStorage_prepareTitleId(_thisptr); // usually not done like this
 
 			return 0x200080;
 		}
 
-		Result Initialize2(bossStorage_t* thisptr, const char* dirName, StorageKind type)
+		static Result Initialize2(Storage* _thisptr, const char* dirName, StorageKind type)
 		{
-			return Initialize(thisptr, dirName, 0, type);
+			return Initialize(_thisptr, dirName, 0, type);
 		}
-	}
 
-	using Storage_t = Storage::bossStorage_t;
-	struct AlmightyStorage_t : Storage_t
-	{
-	};
-	static_assert(sizeof(AlmightyStorage_t) == 0x28);
-
-	namespace AlmightyStorage
-	{
-		AlmightyStorage_t* ctor(AlmightyStorage_t* thisptr)
+		static void Finalize(Storage* _this)
 		{
-			forceLogDebug_printf("nn_boss_AlmightyStorage_ctor(0x%x)", MEMPTR(thisptr).GetMPTR());
-			if (!thisptr)
-			{
-				// thisptr = new RawDlTaskSetting_t
-				assert_dbg();
+			memset(_this, 0, sizeof(Storage)); // todo - not all fields might be cleared
+		}
+
+		static Result GetDataList(nn::boss::Storage* storage, DataName* dataList, sint32 maxEntries, uint32be* outputEntryCount, uint32 startIndex) // GetDataList__Q3_2nn4boss7StorageCFPQ3_2nn4boss8DataNameUiPUiT2
+		{
+			// initialize titleId of storage if not already done
+			nnBossStorage_prepareTitleId(storage);
+
+			if(startIndex >= FAD_ENTRY_MAX_COUNT) {
+				*outputEntryCount = 0;
+				return 0;
 			}
 
-			if (thisptr)
+			// load fad.db
+			BossStorageFadEntry* fadTable = nnBossStorageFad_getTable(storage);
+			if (fadTable)
 			{
-				Storage::ctor(thisptr);
-				thisptr->ukn20 = 0x100028a4;
+				sint32 validEntryCount = 0;
+				for (sint32 i = startIndex; i < FAD_ENTRY_MAX_COUNT; i++)
+				{
+					if( fadTable[i].name[0] == '\0' )
+						continue;
+					memcpy(dataList[validEntryCount].name, fadTable[i].name, 0x20);
+					validEntryCount++;
+					if (validEntryCount >= maxEntries)
+						break;
+				}
+				*outputEntryCount = validEntryCount;
+				free(fadTable);
 			}
-
-			return thisptr;
+			else
+			{
+				// could not load fad table
+				*outputEntryCount = 0;
+			}
+			return 0; // todo
 		}
 
-		uint32 Initialize(AlmightyStorage_t* thisptr, TitleId_t* titleId, const char* storageName, uint32 accountId, StorageKind storageKind)
+		static bool Exist(nn::boss::Storage* storage)
 		{
-			forceLogDebug_printf("nn_boss_AlmightyStorage_Initialize(0x%x)", MEMPTR(thisptr).GetMPTR());
-			if (!thisptr)
-				return 0xc0203780;
-
-			thisptr->accountId = accountId;
-			thisptr->storageKind = storageKind;
-			thisptr->titleId.u64 = titleId->u64;
-			
-			strncpy(thisptr->storageName, storageName, 8);
-			thisptr->storageName[0x7] = 0x00;
-	
-			return 0x200080;
-		}
-	}
-} 
-}
-
-// Storage
-
-struct bossDataName_t
-{
-	char name[32];
-};
-
-static_assert(sizeof(bossDataName_t) == 0x20);
-
-struct bossStorageFadEntry_t
-{
-	char name[32];
-	uint32be fileNameId;
-	uint32 ukn24;
-	uint32 ukn28;
-	uint32 ukn2C;
-	uint32 ukn30;
-	uint32be timestampRelated; // guessed
-};
-
-// __ct__Q3_2nn4boss8DataNameFv
-void nnBossDataNameExport_ct(PPCInterpreter_t* hCPU)
-{
-	ppcDefineParamStructPtr(dataName, bossDataName_t, 0);
-	memset(dataName, 0, sizeof(bossDataName_t));
-	osLib_returnFromFunction(hCPU, memory_getVirtualOffsetFromPointer(dataName));
-}
-
-// __opPCc__Q3_2nn4boss8DataNameCFv
-void nnBossDataNameExport_opPCc(PPCInterpreter_t* hCPU)
-{
-	ppcDefineParamStructPtr(dataName, bossDataName_t, 0);
-	osLib_returnFromFunction(hCPU, memory_getVirtualOffsetFromPointer(dataName->name));
-}
-
-void nnBossStorageExport_ct(PPCInterpreter_t* hCPU)
-{
-	ppcDefineParamStructPtr(storage, nn::boss::Storage::bossStorage_t, 0);
-	forceLogDebug_printf("Constructor for boss storage called");
-	// todo
-	memset(storage, 0, sizeof(nn::boss::Storage::bossStorage_t));
-	osLib_returnFromFunction(hCPU, memory_getVirtualOffsetFromPointer(storage));
-}
-
-void nnBossStorageExport_exist(PPCInterpreter_t* hCPU)
-{
-	ppcDefineParamStructPtr(storage, nn::boss::Storage::bossStorage_t, 0);
-	forceLogDebug_printf("nn_boss.Storage_Exist(...) TODO");
-
-	// todo
-	osLib_returnFromFunction(hCPU, 1);
-}
-
-#define FAD_ENTRY_MAX_COUNT		512
-
-FSCVirtualFile* nnBossStorageFile_open(nn::boss::Storage::bossStorage_t* storage, uint32 fileNameId)
-{
-	char storageFilePath[1024];
-	sprintf(storageFilePath, "/cemuBossStorage/%08x/%08x/user/common/data/%s/%08x", (uint32)(storage->titleId.u64 >> 32), (uint32)(storage->titleId.u64), storage->storageName, fileNameId);
-	sint32 fscStatus;
-	FSCVirtualFile* fscStorageFile = fsc_open(storageFilePath, FSC_ACCESS_FLAG::OPEN_FILE | FSC_ACCESS_FLAG::READ_PERMISSION | FSC_ACCESS_FLAG::WRITE_PERMISSION, &fscStatus);
-	return fscStorageFile;
-}
-
-bossStorageFadEntry_t* nnBossStorageFad_getTable(nn::boss::Storage::bossStorage_t* storage)
-{
-	const auto accountId = ActiveSettings::GetPersistentId();
-	char fadPath[1024];
-	sprintf(fadPath, "/cemuBossStorage/%08x/%08x/user/common/%08x/%s/fad.db", (uint32)(storage->titleId.u64 >> 32), (uint32)(storage->titleId.u64), accountId, storage->storageName);
-
-	sint32 fscStatus;
-	FSCVirtualFile* fscFadFile = fsc_open(fadPath, FSC_ACCESS_FLAG::OPEN_FILE | FSC_ACCESS_FLAG::READ_PERMISSION, &fscStatus);
-	if (!fscFadFile)
-	{
-		return nullptr;
-	}
-	// skip first 8 bytes
-	fsc_setFileSeek(fscFadFile, 8);
-	// read entries
-	bossStorageFadEntry_t* fadTable = (bossStorageFadEntry_t*)malloc(sizeof(bossStorageFadEntry_t)*FAD_ENTRY_MAX_COUNT);
-	memset(fadTable, 0, sizeof(bossStorageFadEntry_t)*FAD_ENTRY_MAX_COUNT);
-	fsc_readFile(fscFadFile, fadTable, sizeof(bossStorageFadEntry_t)*FAD_ENTRY_MAX_COUNT);
-	fsc_close(fscFadFile);
-	return fadTable;
-}
-
-// Find index of entry by name. Returns -1 if not found
-sint32 nnBossStorageFad_getIndexByName(bossStorageFadEntry_t* fadTable, char* name)
-{
-	for (sint32 i = 0; i < FAD_ENTRY_MAX_COUNT; i++)
-	{
-		if (fadTable[i].name[0] == '\0')
-			continue;
-		if (strncmp(name, fadTable[i].name, 0x20) == 0)
-		{
-			return i;
-		}
-	}
-	return -1;
-}
-
-bool nnBossStorageFad_getEntryByName(nn::boss::Storage::bossStorage_t* storage, char* name, bossStorageFadEntry_t* fadEntry)
-{
-	bossStorageFadEntry_t* fadTable = nnBossStorageFad_getTable(storage);
-	if (fadTable)
-	{
-		sint32 entryIndex = nnBossStorageFad_getIndexByName(fadTable, name);
-		if (entryIndex >= 0)
-		{
-			memcpy(fadEntry, fadTable + entryIndex, sizeof(bossStorageFadEntry_t));
-			free(fadTable);
+			cemuLog_logDebug(LogType::Force, "nn_boss::Storage::Exist() TODO");
 			return true;
 		}
-		free(fadTable);
-	}
-	return false;
-}
 
-void nnBossStorageExport_getDataList(PPCInterpreter_t* hCPU)
-{
-	ppcDefineParamStructPtr(storage, nn::boss::Storage::bossStorage_t, 0);
-	ppcDefineParamStructPtr(dataList, bossDataName_t, 1);
-	ppcDefineParamS32(maxEntries, 2);
-	ppcDefineParamU32BEPtr(outputEntryCount, 3);
-	forceLogDebug_printf("boss storage getDataList()");
+		/* FAD access */
 
-	// initialize titleId of storage if not already done
-	nnBossStorage_prepareTitleId(storage);
-
-	// load fad.db
-	bossStorageFadEntry_t* fadTable = nnBossStorageFad_getTable(storage);
-	if (fadTable)
-	{
-		sint32 validEntryCount = 0;
-		for (sint32 i = 0; i < FAD_ENTRY_MAX_COUNT; i++)
+		static FSCVirtualFile* nnBossStorageFile_open(nn::boss::Storage* storage, uint32 fileNameId)
 		{
-			if( fadTable[i].name[0] == '\0' )
-				continue;
-			memcpy(dataList[validEntryCount].name, fadTable[i].name, 0x20);
-			validEntryCount++;
-			if (validEntryCount >= maxEntries)
-				break;
+			char storageFilePath[1024];
+			sprintf(storageFilePath, "/cemuBossStorage/%08x/%08x/user/common/data/%s/%08x", (uint32)(storage->titleId.u64 >> 32), (uint32)(storage->titleId.u64), storage->storageName, fileNameId);
+			sint32 fscStatus;
+			FSCVirtualFile* fscStorageFile = fsc_open(storageFilePath, FSC_ACCESS_FLAG::OPEN_FILE | FSC_ACCESS_FLAG::READ_PERMISSION | FSC_ACCESS_FLAG::WRITE_PERMISSION, &fscStatus);
+			return fscStorageFile;
 		}
-		*outputEntryCount = validEntryCount;
-		free(fadTable);
-	}
-	else
-	{
-		// could not load fad table
-		*outputEntryCount = 0;
-	}
-	osLib_returnFromFunction(hCPU, 0); // error code
-}
 
-// NsData
-
-typedef struct  
-{
-	/* +0x00 */ char name[0x20];
-	/* +0x20 */ nn::boss::Storage::bossStorage_t storage;
-	/* +0x48 */ uint64 readIndex;
-	/* +0x50 */ uint32 ukn50; // some pointer to a global struct
-	/* +0x54 */ uint32 ukn54;
-}nsData_t;
-
-void nnBossNsDataExport_ct(PPCInterpreter_t* hCPU)
-{
-	forceLogDebug_printf("nnBossNsDataExport_ct");
-	ppcDefineParamStructPtr(nsData, nsData_t, 0);
-	if (!nsData)
-		assert_dbg();
-
-
-	nsData->ukn50 = 0x10000530;
-
-	memset(nsData->name, 0, 0x20);
-	
-	nsData->storage.ukn20 = 0x10000798;
-	nsData->storage.titleId.u64 = 0;
-
-	nsData->readIndex = 0;
-
-	osLib_returnFromFunction(hCPU, memory_getVirtualOffsetFromPointer(nsData));
-}
-
-void nnBossNsDataExport_initialize(PPCInterpreter_t* hCPU)
-{
-	ppcDefineParamStructPtr(nsData, nsData_t, 0);
-	ppcDefineParamStructPtr(storage, nn::boss::Storage::bossStorage_t, 1);
-	ppcDefineParamStr(dataName, 2);
-
-	if(dataName == nullptr)
-	{
-		if (storage->storageKind != 1)
+		static BossStorageFadEntry* nnBossStorageFad_getTable(nn::boss::Storage* storage)
 		{
-			osLib_returnFromFunction(hCPU, 0xC0203780);
-			return;
+			const auto accountId = ActiveSettings::GetPersistentId();
+			char fadPath[1024];
+			sprintf(fadPath, "/cemuBossStorage/%08x/%08x/user/common/%08x/%s/fad.db", (uint32)(storage->titleId.u64 >> 32), (uint32)(storage->titleId.u64), accountId, storage->storageName);
+
+			sint32 fscStatus;
+			FSCVirtualFile* fscFadFile = fsc_open(fadPath, FSC_ACCESS_FLAG::OPEN_FILE | FSC_ACCESS_FLAG::READ_PERMISSION, &fscStatus);
+			if (!fscFadFile)
+			{
+				return nullptr;
+			}
+			// skip first 8 bytes
+			fsc_setFileSeek(fscFadFile, 8);
+			// read entries
+			BossStorageFadEntry* fadTable = (BossStorageFadEntry*)malloc(sizeof(BossStorageFadEntry)*FAD_ENTRY_MAX_COUNT);
+			memset(fadTable, 0, sizeof(BossStorageFadEntry)*FAD_ENTRY_MAX_COUNT);
+			fsc_readFile(fscFadFile, fadTable, sizeof(BossStorageFadEntry)*FAD_ENTRY_MAX_COUNT);
+			fsc_close(fscFadFile);
+			return fadTable;
 		}
-	}
-	
-	nsData->storage.accountId = storage->accountId;
-	nsData->storage.storageKind = storage->storageKind;
 
-	memcpy(nsData->storage.ukn08Array, storage->ukn08Array, 3);
-	memcpy(nsData->storage.storageName, storage->storageName, 8);
-
-	nsData->storage.titleId.u64 = storage->titleId.u64;
-
-	nsData->storage = *storage;
-
-	if (dataName != nullptr || storage->storageKind != 1)
-		strncpy(nsData->name, dataName, 0x20);
-	else
-		strncpy(nsData->name, "rawcontent.dat", 0x20);
-	nsData->name[0x1F] = '\0';
-
-	nsData->readIndex = 0;
-
-	forceLogDebug_printf("nnBossNsDataExport_initialize: %s", nsData->name);
-	
-	osLib_returnFromFunction(hCPU, 0x200080);
-}
-
-std::string nnBossNsDataExport_GetPath(nsData_t* nsData)
-{
-	uint32 accountId = nsData->storage.accountId;
-	if (accountId == 0)
-		accountId = iosuAct_getAccountIdOfCurrentAccount();
-
-	uint64 title_id = nsData->storage.titleId.u64;
-	if (title_id == 0)
-		title_id = CafeSystem::GetForegroundTitleId();
-
-	fs::path path = fmt::format(L"cemuBossStorage/{:08x}/{:08x}/user/{:08x}", (uint32)(title_id >> 32), (uint32)(title_id & 0xFFFFFFFF), accountId);
-	path /= nsData->storage.storageName;
-	path /= nsData->name;
-	return path.string();
-}
-
-void nnBossNsDataExport_DeleteRealFileWithHistory(PPCInterpreter_t* hCPU)
-{
-	ppcDefineParamStructPtr(nsData, nsData_t, 0);
-	forceLogDebug_printf("nn_boss.NsData_DeleteRealFileWithHistory(...)");
-
-	if (nsData->storage.storageKind == nn::boss::kStorageKind_NBDL)
-	{
-		// todo
-		forceLog_printf("BOSS NBDL: Unsupported delete");
-	}
-	else
-	{
-		sint32 fscStatus = FSC_STATUS_OK;
-		std::string filePath = nnBossNsDataExport_GetPath(nsData).c_str();
-		fsc_remove((char*)filePath.c_str(), &fscStatus);
-		if (fscStatus != 0)
-			forceLog_printf("Unhandeled FSC status in BOSS DeleteRealFileWithHistory()");
-	}
-	osLib_returnFromFunction(hCPU, 0);
-}
-
-void nnBossNsDataExport_Exist(PPCInterpreter_t* hCPU)
-{
-	forceLogDebug_printf("nn_boss.NsData_Exist(...)");
-	ppcDefineParamStructPtr(nsData, nsData_t, 0);
-
-	bool fileExists = false;
-	if(nsData->storage.storageKind == nn::boss::kStorageKind_NBDL)
-	{
-		// check if name is present in fad table
-		bossStorageFadEntry_t* fadTable = nnBossStorageFad_getTable(&nsData->storage);
-		if (fadTable)
+		// Find index of entry by name. Returns -1 if not found
+		static sint32 nnBossStorageFad_getIndexByName(BossStorageFadEntry* fadTable, char* name)
 		{
-			fileExists = nnBossStorageFad_getIndexByName(fadTable, nsData->name) >= 0;
-			forceLogDebug_printf("\t(%s) -> %d", nsData->name, fileExists);
-			free(fadTable);
+			for (sint32 i = 0; i < FAD_ENTRY_MAX_COUNT; i++)
+			{
+				if (fadTable[i].name[0] == '\0')
+					continue;
+				if (strncmp(name, fadTable[i].name, 0x20) == 0)
+				{
+					return i;
+				}
+			}
+			return -1;
 		}
-	}
-	else
-	{
-		sint32 fscStatus;
-		auto fscStorageFile = fsc_open((char*)nnBossNsDataExport_GetPath(nsData).c_str(), FSC_ACCESS_FLAG::OPEN_FILE, &fscStatus);
-		if (fscStorageFile != nullptr)
+
+		static bool nnBossStorageFad_getEntryByName(nn::boss::Storage* storage, char* name, BossStorageFadEntry* fadEntry)
 		{
-			fileExists = true;
+			BossStorageFadEntry* fadTable = nnBossStorageFad_getTable(storage);
+			if (fadTable)
+			{
+				sint32 entryIndex = nnBossStorageFad_getIndexByName(fadTable, name);
+				if (entryIndex >= 0)
+				{
+					memcpy(fadEntry, fadTable + entryIndex, sizeof(BossStorageFadEntry));
+					free(fadTable);
+					return true;
+				}
+				free(fadTable);
+			}
+			return false;
+		}
+
+		static void InitVTable()
+		{
+			s_vTable->rtti.ptr = nullptr; // todo
+			s_vTable->dtor.ptr = DTOR_WRAPPER(Storage);
+		}
+	};
+
+	static_assert(sizeof(Storage) == 0x28);
+	static_assert(offsetof(Storage, storageKind) == 0x04);
+	static_assert(offsetof(Storage, ukn08Array) == 0x08);
+	static_assert(offsetof(Storage, storageName) == 0x0B);
+	static_assert(offsetof(Storage, titleId) == 0x18);
+
+	struct AlmightyStorage : Storage
+	{
+		struct VTableAlmightyStorage : public VTableStorage
+		{
+			VTableEntry rttiStorage;
+		};
+		static_assert(sizeof(VTableAlmightyStorage) == 8*3);
+		static inline SysAllocator<VTableAlmightyStorage> s_VTable;
+
+		static AlmightyStorage* ctor(AlmightyStorage* _thisptr)
+		{
+			cemuLog_logDebug(LogType::Force, "nn_boss_AlmightyStorage_ctor(0x{:x})", MEMPTR(_thisptr).GetMPTR());
+			if (!_thisptr)
+				_thisptr = boss_new<AlmightyStorage>();
+			Storage::ctor1(_thisptr);
+			_thisptr->vTablePtr = s_VTable;
+			return _thisptr;
+		}
+
+		static uint32 Initialize(AlmightyStorage* _thisptr, TitleId* titleId, const char* storageName, uint32 accountId, StorageKind storageKind)
+		{
+			cemuLog_logDebug(LogType::Force, "nn_boss_AlmightyStorage_Initialize(0x{:x})", MEMPTR(_thisptr).GetMPTR());
+			if (!_thisptr)
+				return 0xc0203780;
+
+			_thisptr->accountId = accountId;
+			_thisptr->storageKind = storageKind;
+			_thisptr->titleId.u64 = titleId->u64;
+
+			strncpy(_thisptr->storageName, storageName, 8);
+			_thisptr->storageName[0x7] = 0x00;
+
+			return 0x200080;
+		}
+
+		static void InitVTable()
+		{
+			s_VTable->rtti.ptr = nullptr; // todo
+			s_VTable->dtor.ptr = DTOR_WRAPPER(AlmightyStorage);
+			s_VTable->rttiStorage.ptr = nullptr; // todo
+		}
+	};
+	static_assert(sizeof(AlmightyStorage) == 0x28);
+
+	// NsData
+
+	struct NsData
+	{
+		struct VTableNsData
+		{
+			VTableEntry rtti;
+			VTableEntry dtor;
+		};
+		static inline SysAllocator<VTableNsData> s_vTable;
+
+		/* +0x00 */ char name[0x20]; // DataName ?
+		/* +0x20 */ nn::boss::Storage storage;
+		/* +0x48 */ uint64 readIndex;
+		/* +0x50 */ MEMPTR<void> vTablePtr;
+		/* +0x54 */ uint32 ukn54;
+
+		static NsData* ctor(NsData* _this)
+		{
+			if (!_this)
+				_this = boss_new<NsData>();
+			_this->vTablePtr = s_vTable;
+			memset(_this->name, 0, sizeof(_this->name));
+			_this->storage.ctor1(&_this->storage);
+			_this->readIndex = 0;
+			return _this;
+		}
+
+		static void dtor(NsData* _this, uint32 options) // __dt__Q3_2nn4boss6NsDataFv
+		{
+			_this->storage.dtor(&_this->storage, 0);
+			// todo
+			if(options & 1)
+				boss_delete(_this);
+		}
+
+		static Result Initialize(NsData* _this, nn::boss::Storage* storage, const char* dataName)
+		{
+			if(dataName == nullptr)
+			{
+				if (storage->storageKind != 1)
+				{
+					return 0xC0203780;
+				}
+			}
+
+			_this->storage.accountId = storage->accountId;
+			_this->storage.storageKind = storage->storageKind;
+
+			memcpy(_this->storage.ukn08Array, storage->ukn08Array, 3);
+			memcpy(_this->storage.storageName, storage->storageName, 8);
+
+			_this->storage.titleId.u64 = storage->titleId.u64;
+
+			_this->storage = *storage;
+
+			if (dataName != nullptr || storage->storageKind != 1)
+				strncpy(_this->name, dataName, 0x20);
+			else
+				strncpy(_this->name, "rawcontent.dat", 0x20);
+			_this->name[0x1F] = '\0';
+
+			_this->readIndex = 0;
+
+			cemuLog_logDebug(LogType::Force, "initialize: {}", _this->name);
+
+			return 0x200080;
+		}
+
+		static std::string _GetPath(NsData* nsData)
+		{
+			uint32 accountId = nsData->storage.accountId;
+			if (accountId == 0)
+				accountId = iosuAct_getAccountIdOfCurrentAccount();
+
+			uint64 title_id = nsData->storage.titleId.u64;
+			if (title_id == 0)
+				title_id = CafeSystem::GetForegroundTitleId();
+
+			fs::path path = fmt::format("cemuBossStorage/{:08x}/{:08x}/user/{:08x}", (uint32)(title_id >> 32), (uint32)(title_id & 0xFFFFFFFF), accountId);
+			path /= nsData->storage.storageName;
+			path /= nsData->name;
+			return path.string();
+		}
+
+		static Result DeleteRealFileWithHistory(NsData* nsData)
+		{
+			if (nsData->storage.storageKind == nn::boss::Storage::kStorageKind_NBDL)
+			{
+				// todo
+				cemuLog_log(LogType::Force, "BOSS NBDL: Unsupported delete");
+			}
+			else
+			{
+				sint32 fscStatus = FSC_STATUS_OK;
+				std::string filePath = _GetPath(nsData).c_str();
+				fsc_remove((char*)filePath.c_str(), &fscStatus);
+				if (fscStatus != 0)
+					cemuLog_log(LogType::Force, "Unhandeled FSC status in BOSS DeleteRealFileWithHistory()");
+			}
+			return 0;
+		}
+
+		static uint32 Exist(NsData* nsData)
+		{
+			bool fileExists = false;
+			if(nsData->storage.storageKind == nn::boss::Storage::kStorageKind_NBDL)
+			{
+				// check if name is present in fad table
+				BossStorageFadEntry* fadTable = nn::boss::Storage::nnBossStorageFad_getTable(&nsData->storage);
+				if (fadTable)
+				{
+					fileExists = nn::boss::Storage::nnBossStorageFad_getIndexByName(fadTable, nsData->name) >= 0;
+					cemuLog_logDebug(LogType::Force, "\t({}) -> {}", nsData->name, fileExists);
+					free(fadTable);
+				}
+			}
+			else
+			{
+				sint32 fscStatus;
+				auto fscStorageFile = fsc_open(_GetPath(nsData).c_str(), FSC_ACCESS_FLAG::OPEN_FILE, &fscStatus);
+				if (fscStorageFile != nullptr)
+				{
+					fileExists = true;
+					fsc_close(fscStorageFile);
+				}
+			}
+			return fileExists?1:0;
+		}
+
+		static uint64 GetSize(NsData* nsData)
+		{
+			FSCVirtualFile* fscStorageFile = nullptr;
+			if (nsData->storage.storageKind == nn::boss::Storage::kStorageKind_NBDL)
+			{
+				BossStorageFadEntry fadEntry;
+				if (nn::boss::Storage::nnBossStorageFad_getEntryByName(&nsData->storage, nsData->name, &fadEntry) == false)
+				{
+					cemuLog_log(LogType::Force, "BOSS storage cant find file {}", nsData->name);
+					return 0;
+				}
+				// open file
+				fscStorageFile = nn::boss::Storage::nnBossStorageFile_open(&nsData->storage, fadEntry.fileNameId);
+			}
+			else
+			{
+				sint32 fscStatus;
+				fscStorageFile = fsc_open(_GetPath(nsData).c_str(), FSC_ACCESS_FLAG::OPEN_FILE | FSC_ACCESS_FLAG::READ_PERMISSION, &fscStatus);
+			}
+
+			if (fscStorageFile == nullptr)
+			{
+				cemuLog_log(LogType::Force, "BOSS storage cant open file alias {}", nsData->name);
+				return 0;
+			}
+
+			// get size
+			const sint32 fileSize = fsc_getFileSize(fscStorageFile);
+			// close file
 			fsc_close(fscStorageFile);
+			return fileSize;
 		}
-	}
 
-	osLib_returnFromFunction(hCPU, fileExists?1:0);
-}
-
-void nnBossNsDataExport_getSize(PPCInterpreter_t* hCPU)
-{
-	ppcDefineParamStructPtr(nsData, nsData_t, 0);
-
-	FSCVirtualFile* fscStorageFile = nullptr;
-	if (nsData->storage.storageKind == nn::boss::kStorageKind_NBDL)
-	{
-		bossStorageFadEntry_t fadEntry;
-		if (nnBossStorageFad_getEntryByName(&nsData->storage, nsData->name, &fadEntry) == false)
+		static uint64 GetCreatedTime(NsData* nsData)
 		{
-			forceLog_printf("BOSS storage cant find file %s", nsData->name);
-			osLib_returnFromFunction(hCPU, 0);
-			return;
+			cemuLog_logDebug(LogType::Force, "nn_boss.NsData_GetCreatedTime() not implemented. Returning 0");
+			uint64 createdTime = 0;
+			return createdTime;
 		}
-		// open file
-		fscStorageFile = nnBossStorageFile_open(&nsData->storage, fadEntry.fileNameId);
-	}
-	else
-	{
-		sint32 fscStatus;
-		fscStorageFile = fsc_open((char*)nnBossNsDataExport_GetPath(nsData).c_str(), FSC_ACCESS_FLAG::OPEN_FILE | FSC_ACCESS_FLAG::READ_PERMISSION, &fscStatus);
-	}
 
-	if (fscStorageFile == nullptr)
-	{
-		forceLog_printf("BOSS storage cant open file alias %s", nsData->name);
-		osLib_returnFromFunction(hCPU, 0);
-		return;
-	}
-
-	// get size
-	const sint32 fileSize = fsc_getFileSize(fscStorageFile);
-	// close file
-	fsc_close(fscStorageFile);
-	osLib_returnFromFunction64(hCPU, fileSize);
-}
-
-uint32 nnBossNsData_read(nsData_t* nsData, uint64* sizeOutBE, void* buffer, sint32 length)
-{
-	FSCVirtualFile* fscStorageFile = nullptr;
-	if (nsData->storage.storageKind == nn::boss::kStorageKind_NBDL)
-	{
-		bossStorageFadEntry_t fadEntry;
-		if (nnBossStorageFad_getEntryByName(&nsData->storage, nsData->name, &fadEntry) == false)
+		static uint32 nnBossNsData_read(NsData* nsData, uint64be* sizeOutBE, void* buffer, sint32 length)
 		{
-			forceLog_printf("BOSS storage cant find file %s for reading", nsData->name);
-			return 0x80000000; // todo - proper error code
+			FSCVirtualFile* fscStorageFile = nullptr;
+			if (nsData->storage.storageKind == nn::boss::Storage::kStorageKind_NBDL)
+			{
+				BossStorageFadEntry fadEntry;
+				if (nn::boss::Storage::nnBossStorageFad_getEntryByName(&nsData->storage, nsData->name, &fadEntry) == false)
+				{
+					cemuLog_log(LogType::Force, "BOSS storage cant find file {} for reading", nsData->name);
+					return 0x80000000; // todo - proper error code
+				}
+				// open file
+				fscStorageFile = nn::boss::Storage::nnBossStorageFile_open(&nsData->storage, fadEntry.fileNameId);
+			}
+			else
+			{
+				sint32 fscStatus;
+				fscStorageFile = fsc_open(_GetPath(nsData).c_str(), FSC_ACCESS_FLAG::OPEN_FILE | FSC_ACCESS_FLAG::READ_PERMISSION, &fscStatus);
+			}
+
+			if (!fscStorageFile)
+			{
+				cemuLog_log(LogType::Force, "BOSS storage cant open file alias {} for reading", nsData->name);
+				return 0x80000000; // todo - proper error code
+			}
+			// get size
+			sint32 fileSize = fsc_getFileSize(fscStorageFile);
+			// verify read is within bounds
+			sint32 readEndOffset = (sint32)_swapEndianU64(nsData->readIndex) + length;
+			sint32 readBytes = length;
+			if (readEndOffset > fileSize)
+			{
+				readBytes = fileSize - (sint32)_swapEndianU64(nsData->readIndex);
+				cemu_assert_debug(readBytes != 0);
+			}
+			// read
+			fsc_setFileSeek(fscStorageFile, (uint32)_swapEndianU64(nsData->readIndex));
+			fsc_readFile(fscStorageFile, buffer, readBytes);
+			nsData->readIndex = _swapEndianU64((sint32)_swapEndianU64(nsData->readIndex) + readBytes);
+
+			// close file
+			fsc_close(fscStorageFile);
+			if (sizeOutBE)
+				*sizeOutBE = readBytes;
+			return 0;
 		}
-		// open file
-		fscStorageFile = nnBossStorageFile_open(&nsData->storage, fadEntry.fileNameId);
-	}
-	else
-	{
-		sint32 fscStatus;
-		fscStorageFile = fsc_open((char*)nnBossNsDataExport_GetPath(nsData).c_str(), FSC_ACCESS_FLAG::OPEN_FILE | FSC_ACCESS_FLAG::READ_PERMISSION, &fscStatus);
-	}
-
-	if (!fscStorageFile)
-	{
-		forceLog_printf("BOSS storage cant open file alias %s for reading", nsData->name);
-		return 0x80000000; // todo - proper error code
-	}
-	// get size
-	sint32 fileSize = fsc_getFileSize(fscStorageFile);
-	// verify read is within bounds
-	sint32 readEndOffset = (sint32)_swapEndianU64(nsData->readIndex) + length;
-	sint32 readBytes = length;
-	if (readEndOffset > fileSize)
-	{
-		readBytes = fileSize - (sint32)_swapEndianU64(nsData->readIndex);
-		cemu_assert_debug(readBytes != 0);
-	}
-	// read
-	fsc_setFileSeek(fscStorageFile, (uint32)_swapEndianU64(nsData->readIndex));
-	fsc_readFile(fscStorageFile, buffer, readBytes);
-	nsData->readIndex = _swapEndianU64((sint32)_swapEndianU64(nsData->readIndex) + readBytes);
-
-	// close file
-	fsc_close(fscStorageFile);
-	if (sizeOutBE)
-		*sizeOutBE = _swapEndianU64(readBytes);
-	return 0;
-}
 
 #define NSDATA_SEEK_MODE_BEGINNING	(0)
 
-uint32 nnBossNsData_seek(nsData_t* nsData, uint64 seek, uint32 mode)
-{
-	FSCVirtualFile* fscStorageFile = nullptr;
-	if (nsData->storage.storageKind == nn::boss::kStorageKind_NBDL)
-	{
-		bossStorageFadEntry_t fadEntry;
-		if (nnBossStorageFad_getEntryByName(&nsData->storage, nsData->name, &fadEntry) == false)
+		static uint32 nnBossNsData_seek(NsData* nsData, uint64 seek, uint32 mode)
 		{
-			forceLog_printf("BOSS storage cant find file %s for reading", nsData->name);
-			return 0x80000000; // todo - proper error code
+			FSCVirtualFile* fscStorageFile = nullptr;
+			if (nsData->storage.storageKind == nn::boss::Storage::kStorageKind_NBDL)
+			{
+				BossStorageFadEntry fadEntry;
+				if (nn::boss::Storage::nnBossStorageFad_getEntryByName(&nsData->storage, nsData->name, &fadEntry) == false)
+				{
+					cemuLog_log(LogType::Force, "BOSS storage cant find file {} for reading", nsData->name);
+					return 0x80000000; // todo - proper error code
+				}
+				// open file
+				fscStorageFile = nn::boss::Storage::nnBossStorageFile_open(&nsData->storage, fadEntry.fileNameId);
+			}
+			else
+			{
+				sint32 fscStatus;
+				fscStorageFile = fsc_open(_GetPath(nsData).c_str(), FSC_ACCESS_FLAG::OPEN_FILE | FSC_ACCESS_FLAG::READ_PERMISSION, &fscStatus);
+			}
+
+			if (fscStorageFile == nullptr)
+			{
+				cemuLog_log(LogType::Force, "BOSS storage cant open file alias {} for reading",  nsData->name);
+				return 0x80000000; // todo - proper error code
+			}
+			// get size
+			sint32 fileSize = fsc_getFileSize(fscStorageFile);
+			// handle seek
+			if (mode == NSDATA_SEEK_MODE_BEGINNING)
+			{
+				seek = std::min(seek, (uint64)fileSize);
+				nsData->readIndex = _swapEndianU64((uint64)seek);
+			}
+			else
+			{
+				cemu_assert_unimplemented();
+			}
+			fsc_close(fscStorageFile);
+			return 0;
 		}
-		// open file
-		fscStorageFile = nnBossStorageFile_open(&nsData->storage, fadEntry.fileNameId);
-	}
-	else
-	{
-		sint32 fscStatus;
-		fscStorageFile = fsc_open((char*)nnBossNsDataExport_GetPath(nsData).c_str(), FSC_ACCESS_FLAG::OPEN_FILE | FSC_ACCESS_FLAG::READ_PERMISSION, &fscStatus);
-	}
 
-	if (fscStorageFile == nullptr)
-	{
-		forceLog_printf("BOSS storage cant open file alias %s for reading",  nsData->name);
-		return 0x80000000; // todo - proper error code
-	}
-	// get size
-	sint32 fileSize = fsc_getFileSize(fscStorageFile);
-	// handle seek
-	if (mode == NSDATA_SEEK_MODE_BEGINNING)
-	{
-		seek = std::min(seek, (uint64)fileSize);
-		nsData->readIndex = _swapEndianU64((uint64)seek);
-	}
-	else
-	{
-		cemu_assert_unimplemented();
-	}
-	fsc_close(fscStorageFile);
-	return 0;
+		static sint32 Read(NsData* nsData, uint8* buffer, sint32 length)
+		{
+			cemuLog_logDebug(LogType::Force, "nsData read (filename {})", nsData->name);
+			return nnBossNsData_read(nsData, nullptr, buffer, length);
+		}
+
+		static sint32 ReadWithSizeOut(NsData* nsData, uint64be* sizeOut, uint8* buffer, sint32 length)
+		{
+			uint32 r = nnBossNsData_read(nsData, sizeOut, buffer, length);
+			cemuLog_logDebug(LogType::Force, "nsData readWithSizeOut (filename {} length 0x{:x}) Result: {} Sizeout: {:x}", nsData->name, length, r, _swapEndianU64(*sizeOut));
+			return r;
+		}
+
+		static Result Seek(NsData* nsData, uint64 seekPos, uint32 mode)
+		{
+			uint32 r = nnBossNsData_seek(nsData, seekPos, mode);
+			cemuLog_logDebug(LogType::Force, "nsData seek (filename {} seek 0x{:x}) Result: {}", nsData->name, (uint32)seekPos, r);
+			return r;
+		}
+
+		static void InitVTable()
+		{
+			s_vTable->rtti.ptr = nullptr; // todo
+			s_vTable->dtor.ptr = DTOR_WRAPPER(NsData);
+		}
+	};
+	static_assert(sizeof(NsData) == 0x58);
+
 }
-
-void nnBossNsDataExport_read(PPCInterpreter_t* hCPU)
-{
-	ppcDefineParamStructPtr(nsData, nsData_t, 0);
-	ppcDefineParamStr(buffer, 1);
-	ppcDefineParamS32(length, 2);
-
-	forceLogDebug_printf("nsData read LR %08x (filename %s)", hCPU->spr.LR, nsData->name);
-
-	uint32 r = nnBossNsData_read(nsData, nullptr, buffer, length);
-
-	osLib_returnFromFunction(hCPU, r);
 }
-
-void nnBossNsDataExport_readWithSizeOut(PPCInterpreter_t* hCPU)
-{
-	ppcDefineParamStructPtr(nsData, nsData_t, 0);
-	ppcDefineParamTypePtr(sizeOut, uint64, 1);
-	ppcDefineParamStr(buffer, 2);
-	ppcDefineParamS32(length, 3);
-
-	uint32 r = nnBossNsData_read(nsData, sizeOut, buffer, length);
-	forceLogDebug_printf("nsData readWithSizeOut LR %08x (filename %s length 0x%x) Result: %d Sizeout: %llx", hCPU->spr.LR, nsData->name, length, r, _swapEndianU64(*sizeOut));
-
-	osLib_returnFromFunction(hCPU, r);
-}
-
-void nnBossNsDataExport_seek(PPCInterpreter_t* hCPU)
-{
-	ppcDefineParamStructPtr(nsData, nsData_t, 0);
-	ppcDefineParamU64(seekPos, 2);
-	ppcDefineParamU32(mode, 4);
-
-	uint32 r = nnBossNsData_seek(nsData, seekPos, mode);
-
-	forceLogDebug_printf("nsData seek LR %08x (filename %s seek 0x%x) Result: %d", hCPU->spr.LR, nsData->name, (uint32)seekPos, r);
-
-	osLib_returnFromFunction(hCPU, r);
-}
-
 void nnBoss_load()
 {
 	OSInitMutexEx(&nn::boss::g_mutex, nullptr);
 
-	osLib_addFunction("nn_boss", "Initialize__Q2_2nn4bossFv", nn::boss::export_Initialize);
-	osLib_addFunction("nn_boss", "GetBossState__Q2_2nn4bossFv", nn::boss::export_GetBossState);
-	
+	nn::boss::g_initCounter = 0;
+	nn::boss::g_isInitialized = false;
+
+	cafeExportRegisterFunc(nn::boss::GetBossState, "nn_boss", "GetBossState__Q2_2nn4bossFv", LogType::NN_BOSS);
+
+	// boss lib
+	cafeExportRegisterFunc(nn::boss::Initialize, "nn_boss", "Initialize__Q2_2nn4bossFv", LogType::NN_BOSS);
+	cafeExportRegisterFunc(nn::boss::IsInitialized, "nn_boss", "IsInitialized__Q2_2nn4bossFv", LogType::NN_BOSS);
+	cafeExportRegisterFunc(nn::boss::Finalize, "nn_boss", "Finalize__Q2_2nn4bossFv", LogType::NN_BOSS);
+
 	// task
-	osLib_addFunction("nn_boss", "__ct__Q3_2nn4boss4TaskFv", nn::boss::Task::export_ctor);
-	osLib_addFunction("nn_boss", "Run__Q3_2nn4boss4TaskFb", nn::boss::Task::export_Run);
-	osLib_addFunction("nn_boss", "Wait__Q3_2nn4boss4TaskFUiQ3_2nn4boss13TaskWaitState", nn::boss::Task::export_Wait);
-	osLib_addFunction("nn_boss", "GetTurnState__Q3_2nn4boss4TaskCFPUi", nn::boss::Task::export_GetTurnState);
-	osLib_addFunction("nn_boss", "GetHttpStatusCode__Q3_2nn4boss4TaskCFPUi", nn::boss::Task::export_GetHttpStatusCode);
-	osLib_addFunction("nn_boss", "GetContentLength__Q3_2nn4boss4TaskCFPUi", nn::boss::Task::export_GetContentLength);
-	osLib_addFunction("nn_boss", "GetProcessedLength__Q3_2nn4boss4TaskCFPUi", nn::boss::Task::export_GetProcessedLength);
-	osLib_addFunction("nn_boss", "Register__Q3_2nn4boss4TaskFRQ3_2nn4boss11TaskSetting", nn::boss::Task::export_Register);
-	osLib_addFunction("nn_boss", "Unregister__Q3_2nn4boss4TaskFv", nn::boss::Task::export_Unregister);
-	osLib_addFunction("nn_boss", "Initialize__Q3_2nn4boss4TaskFPCc", nn::boss::Task::export_Initialize1);
-	osLib_addFunction("nn_boss", "Initialize__Q3_2nn4boss4TaskFUcPCc", nn::boss::Task::export_Initialize2);
-	osLib_addFunction("nn_boss", "Initialize__Q3_2nn4boss4TaskFPCcUi", nn::boss::Task::export_Initialize3);
-	osLib_addFunction("nn_boss", "IsRegistered__Q3_2nn4boss4TaskCFv", nn::boss::Task::export_IsRegistered);
-	osLib_addFunction("nn_boss", "RegisterForImmediateRun__Q3_2nn4boss4TaskFRCQ3_2nn4boss11TaskSetting", nn::boss::Task::export_RegisterForImmediateRun);
-	osLib_addFunction("nn_boss", "StartScheduling__Q3_2nn4boss4TaskFb", nn::boss::Task::export_StartScheduling);
-	osLib_addFunction("nn_boss", "StopScheduling__Q3_2nn4boss4TaskFv", nn::boss::Task::export_StopScheduling);
+	nn::boss::Task::InitVTable();
+	cafeExportRegisterFunc(nn::boss::Task::ctor1, "nn_boss", "__ct__Q3_2nn4boss4TaskFUcPCc", LogType::NN_BOSS);
+	cafeExportRegisterFunc(nn::boss::Task::ctor2, "nn_boss", "__ct__Q3_2nn4boss4TaskFPCcUi", LogType::NN_BOSS);
+	cafeExportRegisterFunc(nn::boss::Task::ctor3, "nn_boss", "__ct__Q3_2nn4boss4TaskFPCc", LogType::NN_BOSS);
+	cafeExportRegisterFunc(nn::boss::Task::ctor4, "nn_boss", "__ct__Q3_2nn4boss4TaskFv", LogType::NN_BOSS);
+	cafeExportRegisterFunc(nn::boss::Task::dtor, "nn_boss", "__dt__Q3_2nn4boss4TaskFv", LogType::NN_BOSS);
+	cafeExportRegisterFunc(nn::boss::Task::Initialize1, "nn_boss", "Initialize__Q3_2nn4boss4TaskFPCcUi", LogType::NN_BOSS);
+	cafeExportRegisterFunc(nn::boss::Task::Initialize2, "nn_boss", "Initialize__Q3_2nn4boss4TaskFUcPCc", LogType::NN_BOSS);
+	cafeExportRegisterFunc(nn::boss::Task::Initialize3, "nn_boss", "Initialize__Q3_2nn4boss4TaskFPCc", LogType::NN_BOSS);
+	cafeExportRegisterFunc(nn::boss::Task::Run, "nn_boss", "Run__Q3_2nn4boss4TaskFb", LogType::NN_BOSS);
+	cafeExportRegisterFunc(nn::boss::Task::Wait, "nn_boss", "Wait__Q3_2nn4boss4TaskFUiQ3_2nn4boss13TaskWaitState", LogType::NN_BOSS);
+	cafeExportRegisterFunc(nn::boss::Task::GetTurnState, "nn_boss", "GetTurnState__Q3_2nn4boss4TaskCFPUi", LogType::NN_BOSS);
+	cafeExportRegisterFunc(nn::boss::Task::GetHttpStatusCode, "nn_boss", "GetHttpStatusCode__Q3_2nn4boss4TaskCFPUi", LogType::NN_BOSS);
+	cafeExportRegisterFunc(nn::boss::Task::GetContentLength, "nn_boss", "GetContentLength__Q3_2nn4boss4TaskCFPUi", LogType::NN_BOSS);
+	cafeExportRegisterFunc(nn::boss::Task::GetProcessedLength, "nn_boss", "GetProcessedLength__Q3_2nn4boss4TaskCFPUi", LogType::NN_BOSS);
+	cafeExportRegisterFunc(nn::boss::Task::Register, "nn_boss", "Register__Q3_2nn4boss4TaskFRQ3_2nn4boss11TaskSetting", LogType::NN_BOSS);
+	cafeExportRegisterFunc(nn::boss::Task::Unregister, "nn_boss", "Unregister__Q3_2nn4boss4TaskFv", LogType::NN_BOSS);
+	cafeExportRegisterFunc(nn::boss::Task::IsRegistered, "nn_boss", "IsRegistered__Q3_2nn4boss4TaskCFv", LogType::NN_BOSS);
+	cafeExportRegisterFunc(nn::boss::Task::RegisterForImmediateRun, "nn_boss", "RegisterForImmediateRun__Q3_2nn4boss4TaskFRCQ3_2nn4boss11TaskSetting", LogType::NN_BOSS);
+	cafeExportRegisterFunc(nn::boss::Task::StartScheduling, "nn_boss", "StartScheduling__Q3_2nn4boss4TaskFb", LogType::NN_BOSS);
+	cafeExportRegisterFunc(nn::boss::Task::StopScheduling, "nn_boss", "StopScheduling__Q3_2nn4boss4TaskFv", LogType::NN_BOSS);
 
-	// Nbdl task setting
-	osLib_addFunction("nn_boss", "__ct__Q3_2nn4boss15NbdlTaskSettingFv", nn::boss::NbdlTaskSetting::export_ctor);
-	osLib_addFunction("nn_boss", "Initialize__Q3_2nn4boss15NbdlTaskSettingFPCcLT1", nn::boss::NbdlTaskSetting::export_Initialize);
-	//osLib_addFunction("nn_boss", "SetFileName__Q3_2nn4boss15NbdlTaskSettingFPCc", nn::boss::NbdlTaskSetting::export_SetFileName);
-	cafeExportRegisterFunc(nn::boss::NbdlTaskSetting::SetFileName, "nn_boss", "SetFileName__Q3_2nn4boss15NbdlTaskSettingFPCc", LogType::Placeholder);
-	
-	// play task setting
-	osLib_addFunction("nn_boss", "__ct__Q3_2nn4boss17PlayReportSettingFv", nn::boss::PlayReportSetting::export_ctor); 
-	osLib_addFunction("nn_boss", "Set__Q3_2nn4boss17PlayReportSettingFPCcUi", nn::boss::PlayReportSetting::export_Set); 
-	//osLib_addFunction("nn_boss", "Set__Q3_2nn4boss17PlayReportSettingFUiT1", nn::boss::PlayReportSetting::export_Set); 
-	osLib_addFunction("nn_boss", "Initialize__Q3_2nn4boss17PlayReportSettingFPvUi", nn::boss::PlayReportSetting::export_Initialize); 
+	// TaskSetting
+	nn::boss::TaskSetting::InitVTable();
+	cafeExportRegisterFunc(nn::boss::TaskSetting::ctor, "nn_boss", "__ct__Q3_2nn4boss11TaskSettingFv", LogType::NN_BOSS);
+	cafeExportRegisterFunc(nn::boss::TaskSetting::dtor, "nn_boss", "__dt__Q3_2nn4boss11TaskSettingFv", LogType::NN_BOSS);
+	cafeExportRegisterFunc(nn::boss::TaskSetting::IsPrivileged, "nn_boss", "Initialize__Q3_2nn4boss11TaskSettingFPCcUi", LogType::NN_BOSS);
 
-	cafeExportRegisterFunc(nn::boss::RawDlTaskSetting::ctor, "nn_boss", "__ct__Q3_2nn4boss16RawDlTaskSettingFv", LogType::Placeholder);
-	cafeExportRegisterFunc(nn::boss::RawDlTaskSetting::Initialize, "nn_boss", "Initialize__Q3_2nn4boss16RawDlTaskSettingFPCcbT2N21", LogType::Placeholder);
+	// NbdlTaskSetting
+	nn::boss::NbdlTaskSetting::InitVTable();
+	cafeExportRegisterFunc(nn::boss::NbdlTaskSetting::ctor, "nn_boss", "__ct__Q3_2nn4boss15NbdlTaskSettingFv", LogType::NN_BOSS);
+	cafeExportRegisterFunc(nn::boss::NbdlTaskSetting::dtor, "nn_boss", "__dt__Q3_2nn4boss15NbdlTaskSettingFv", LogType::NN_BOSS);
+	cafeExportRegisterFunc(nn::boss::NbdlTaskSetting::Initialize, "nn_boss", "Initialize__Q3_2nn4boss15NbdlTaskSettingFPCcLT1", LogType::NN_BOSS);
+	cafeExportRegisterFunc(nn::boss::NbdlTaskSetting::SetFileName, "nn_boss", "SetFileName__Q3_2nn4boss15NbdlTaskSettingFPCc", LogType::NN_BOSS);
 
-	cafeExportRegisterFunc(nn::boss::NetTaskSetting::SetServiceToken, "nn_boss", "SetServiceToken__Q3_2nn4boss14NetTaskSettingFPCUc", LogType::Placeholder);
-	cafeExportRegisterFunc(nn::boss::NetTaskSetting::AddInternalCaCert, "nn_boss", "AddInternalCaCert__Q3_2nn4boss14NetTaskSettingFSc", LogType::Placeholder);
-	cafeExportRegisterFunc(nn::boss::NetTaskSetting::SetInternalClientCert, "nn_boss", "SetInternalClientCert__Q3_2nn4boss14NetTaskSettingFSc", LogType::Placeholder);
+	// PlayReportSetting
+	nn::boss::PlayReportSetting::InitVTable();
+	cafeExportRegisterFunc(nn::boss::PlayReportSetting::ctor, "nn_boss", "__ct__Q3_2nn4boss17PlayReportSettingFv", LogType::NN_BOSS);
+	cafeExportRegisterFunc(nn::boss::PlayReportSetting::dtor, "nn_boss", "__dt__Q3_2nn4boss17PlayReportSettingFv", LogType::NN_BOSS);
+	cafeExportRegisterFunc(nn::boss::PlayReportSetting::Initialize, "nn_boss", "Initialize__Q3_2nn4boss17PlayReportSettingFPvUi", LogType::NN_BOSS);
+	cafeExportRegisterFunc(nn::boss::PlayReportSetting::Set, "nn_boss", "Set__Q3_2nn4boss17PlayReportSettingFPCcUi", LogType::NN_BOSS);
+
+	// RawDlTaskSetting
+	nn::boss::RawDlTaskSetting::InitVTable();
+	cafeExportRegisterFunc(nn::boss::RawDlTaskSetting::ctor, "nn_boss", "__ct__Q3_2nn4boss16RawDlTaskSettingFv", LogType::NN_BOSS);
+	cafeExportRegisterFunc(nn::boss::RawDlTaskSetting::dtor, "nn_boss", "__dt__Q3_2nn4boss16RawDlTaskSettingFv", LogType::NN_BOSS);
+	cafeExportRegisterFunc(nn::boss::RawDlTaskSetting::Initialize, "nn_boss", "Initialize__Q3_2nn4boss16RawDlTaskSettingFPCcbT2N21", LogType::NN_BOSS);
+
+	// NetTaskSetting
+	nn::boss::NetTaskSetting::InitVTable();
+	cafeExportRegisterFunc(nn::boss::NetTaskSetting::ctor, "nn_boss", "__ct__Q3_2nn4boss14NetTaskSettingFv", LogType::NN_BOSS);
+	cafeExportRegisterFunc(nn::boss::NetTaskSetting::dtor, "nn_boss", "__dt__Q3_2nn4boss14NetTaskSettingFv", LogType::NN_BOSS);
+	cafeExportRegisterFunc(nn::boss::NetTaskSetting::SetServiceToken, "nn_boss", "SetServiceToken__Q3_2nn4boss14NetTaskSettingFPCUc", LogType::NN_BOSS);
+	cafeExportRegisterFunc(nn::boss::NetTaskSetting::AddInternalCaCert, "nn_boss", "AddInternalCaCert__Q3_2nn4boss14NetTaskSettingFSc", LogType::NN_BOSS);
+	cafeExportRegisterFunc(nn::boss::NetTaskSetting::SetInternalClientCert, "nn_boss", "SetInternalClientCert__Q3_2nn4boss14NetTaskSettingFSc", LogType::NN_BOSS);
 
 	// Title
-	cafeExportRegisterFunc(nn::boss::Title::ctor, "nn_boss", "__ct__Q3_2nn4boss5TitleFv", LogType::Placeholder);
+	nn::boss::Title::InitVTable();
+	cafeExportRegisterFunc(nn::boss::Title::ctor, "nn_boss", "__ct__Q3_2nn4boss5TitleFv", LogType::NN_BOSS);
+	cafeExportRegisterFunc(nn::boss::Title::dtor, "nn_boss", "__dt__Q3_2nn4boss5TitleFv", LogType::NN_BOSS);
 	// cafeExportMakeWrapper<nn::boss::Title::SetNewArrivalFlagOff>("nn_boss", "SetNewArrivalFlagOff__Q3_2nn4boss5TitleFv"); SMM bookmarks
 
 	// TitleId
-	cafeExportRegisterFunc(nn::boss::TitleId::ctor1, "nn_boss", "__ct__Q3_2nn4boss7TitleIDFv", LogType::Placeholder);
-	cafeExportRegisterFunc(nn::boss::TitleId::ctor2, "nn_boss", "__ct__Q3_2nn4boss7TitleIDFUL", LogType::Placeholder);
-	cafeExportRegisterFunc(nn::boss::TitleId::cctor, "nn_boss", "__ct__Q3_2nn4boss7TitleIDFRCQ3_2nn4boss7TitleID", LogType::Placeholder);
-	cafeExportRegisterFunc(nn::boss::TitleId::operator_ne, "nn_boss", "__ne__Q3_2nn4boss7TitleIDCFRCQ3_2nn4boss7TitleID", LogType::Placeholder);
+	cafeExportRegisterFunc(nn::boss::TitleId::ctor1, "nn_boss", "__ct__Q3_2nn4boss7TitleIDFv", LogType::NN_BOSS);
+	cafeExportRegisterFunc(nn::boss::TitleId::ctor2, "nn_boss", "__ct__Q3_2nn4boss7TitleIDFUL", LogType::NN_BOSS);
+	cafeExportRegisterFunc(nn::boss::TitleId::ctor3, "nn_boss", "__ct__Q3_2nn4boss7TitleIDFRCQ3_2nn4boss7TitleID", LogType::NN_BOSS);
+	cafeExportRegisterFunc(nn::boss::TitleId::operator_ne, "nn_boss", "__ne__Q3_2nn4boss7TitleIDCFRCQ3_2nn4boss7TitleID", LogType::NN_BOSS);
 
 	// DataName
-	osLib_addFunction("nn_boss", "__ct__Q3_2nn4boss8DataNameFv", nnBossDataNameExport_ct);
-	osLib_addFunction("nn_boss", "__opPCc__Q3_2nn4boss8DataNameCFv", nnBossDataNameExport_opPCc);
+	cafeExportRegisterFunc(nn::boss::DataName::ctor, "nn_boss", "__ct__Q3_2nn4boss8DataNameFv", LogType::NN_BOSS);
+	cafeExportRegisterFunc(nn::boss::DataName::operator_const_char, "nn_boss", "__opPCc__Q3_2nn4boss8DataNameCFv", LogType::NN_BOSS);
 
 	// DirectoryName
-	cafeExportRegisterFunc(nn::boss::DirectoryName::ctor, "nn_boss", "__ct__Q3_2nn4boss13DirectoryNameFv", LogType::Placeholder);
-	cafeExportRegisterFunc(nn::boss::DirectoryName::operator_const_char, "nn_boss", "__opPCc__Q3_2nn4boss13DirectoryNameCFv", LogType::Placeholder);
+	cafeExportRegisterFunc(nn::boss::DirectoryName::ctor, "nn_boss", "__ct__Q3_2nn4boss13DirectoryNameFv", LogType::NN_BOSS);
+	cafeExportRegisterFunc(nn::boss::DirectoryName::operator_const_char, "nn_boss", "__opPCc__Q3_2nn4boss13DirectoryNameCFv", LogType::NN_BOSS);
 
 	// Account
-	cafeExportRegisterFunc(nn::boss::Account::ctor, "nn_boss", "__ct__Q3_2nn4boss7AccountFUi", LogType::Placeholder);
-	
-	
-	// storage
-	osLib_addFunction("nn_boss", "__ct__Q3_2nn4boss7StorageFv", nnBossStorageExport_ct);
-	//osLib_addFunction("nn_boss", "Initialize__Q3_2nn4boss7StorageFPCcQ3_2nn4boss11StorageKind", nnBossStorageExport_initialize);
-	osLib_addFunction("nn_boss", "Exist__Q3_2nn4boss7StorageCFv", nnBossStorageExport_exist);
-	osLib_addFunction("nn_boss", "GetDataList__Q3_2nn4boss7StorageCFPQ3_2nn4boss8DataNameUiPUiT2", nnBossStorageExport_getDataList);
-	osLib_addFunction("nn_boss", "GetDataList__Q3_2nn4boss7StorageCFPQ3_2nn4boss8DataNameUiPUiT2", nnBossStorageExport_getDataList);
-	cafeExportRegisterFunc(nn::boss::Storage::Initialize, "nn_boss", "Initialize__Q3_2nn4boss7StorageFPCcUiQ3_2nn4boss11StorageKind", LogType::Placeholder);
-	cafeExportRegisterFunc(nn::boss::Storage::Initialize2, "nn_boss", "Initialize__Q3_2nn4boss7StorageFPCcQ3_2nn4boss11StorageKind", LogType::Placeholder);
-
-	// AlmightyStorage
-	cafeExportRegisterFunc(nn::boss::AlmightyStorage::ctor, "nn_boss", "__ct__Q3_2nn4boss15AlmightyStorageFv", LogType::Placeholder );
-	cafeExportRegisterFunc(nn::boss::AlmightyStorage::Initialize, "nn_boss", "Initialize__Q3_2nn4boss15AlmightyStorageFQ3_2nn4boss7TitleIDPCcUiQ3_2nn4boss11StorageKind", LogType::Placeholder );
+	nn::boss::BossAccount::InitVTable();
+	cafeExportRegisterFunc(nn::boss::BossAccount::ctor, "nn_boss", "__ct__Q3_2nn4boss7AccountFUi", LogType::NN_BOSS);
+	cafeExportRegisterFunc(nn::boss::BossAccount::dtor, "nn_boss", "__dt__Q3_2nn4boss7AccountFv", LogType::NN_BOSS);
 
 	// AlmightyTask
-	cafeExportRegisterFunc(nn::boss::AlmightyTask::ctor, "nn_boss", "__ct__Q3_2nn4boss12AlmightyTaskFv", LogType::Placeholder);
-	cafeExportRegisterFunc(nn::boss::AlmightyTask::Initialize, "nn_boss", "Initialize__Q3_2nn4boss12AlmightyTaskFQ3_2nn4boss7TitleIDPCcUi", LogType::Placeholder);
-	// cafeExportRegisterFunc(nn::boss::AlmightyTask::dtor, "nn_boss", "__dt__Q3_2nn4boss12AlmightyTaskFv", LogType::Placeholder);
+	nn::boss::AlmightyTask::InitVTable();
+	cafeExportRegisterFunc(nn::boss::AlmightyTask::ctor, "nn_boss", "__ct__Q3_2nn4boss12AlmightyTaskFv", LogType::NN_BOSS);
+	cafeExportRegisterFunc(nn::boss::AlmightyTask::Initialize, "nn_boss", "Initialize__Q3_2nn4boss12AlmightyTaskFQ3_2nn4boss7TitleIDPCcUi", LogType::NN_BOSS);
+	cafeExportRegisterFunc(nn::boss::AlmightyTask::dtor, "nn_boss", "__dt__Q3_2nn4boss12AlmightyTaskFv", LogType::NN_BOSS);
+
+	// Storage
+	nn::boss::Storage::InitVTable();
+	cafeExportRegisterFunc(nn::boss::Storage::ctor1, "nn_boss", "__ct__Q3_2nn4boss7StorageFv", LogType::NN_BOSS);
+	cafeExportRegisterFunc(nn::boss::Storage::dtor, "nn_boss", "__dt__Q3_2nn4boss7StorageFv", LogType::NN_BOSS);
+	cafeExportRegisterFunc(nn::boss::Storage::Finalize, "nn_boss", "Finalize__Q3_2nn4boss7StorageFv", LogType::NN_BOSS);
+	cafeExportRegisterFunc(nn::boss::Storage::Exist, "nn_boss", "Exist__Q3_2nn4boss7StorageCFv", LogType::NN_BOSS);
+	cafeExportRegisterFunc(nn::boss::Storage::GetDataList, "nn_boss", "GetDataList__Q3_2nn4boss7StorageCFPQ3_2nn4boss8DataNameUiPUiT2", LogType::NN_BOSS);
+	cafeExportRegisterFunc(nn::boss::Storage::Initialize, "nn_boss", "Initialize__Q3_2nn4boss7StorageFPCcUiQ3_2nn4boss11StorageKind", LogType::NN_BOSS);
+	cafeExportRegisterFunc(nn::boss::Storage::Initialize2, "nn_boss", "Initialize__Q3_2nn4boss7StorageFPCcQ3_2nn4boss11StorageKind", LogType::NN_BOSS);
+
+	// AlmightyStorage
+	nn::boss::AlmightyStorage::InitVTable();
+	cafeExportRegisterFunc(nn::boss::AlmightyStorage::ctor, "nn_boss", "__ct__Q3_2nn4boss15AlmightyStorageFv", LogType::NN_BOSS);
+	cafeExportRegisterFunc(nn::boss::AlmightyStorage::Initialize, "nn_boss", "Initialize__Q3_2nn4boss15AlmightyStorageFQ3_2nn4boss7TitleIDPCcUiQ3_2nn4boss11StorageKind", LogType::NN_BOSS);
 
 	// NsData
-	osLib_addFunction("nn_boss", "__ct__Q3_2nn4boss6NsDataFv", nnBossNsDataExport_ct);
-	osLib_addFunction("nn_boss", "Initialize__Q3_2nn4boss6NsDataFRCQ3_2nn4boss7StoragePCc", nnBossNsDataExport_initialize);
-	osLib_addFunction("nn_boss", "DeleteRealFileWithHistory__Q3_2nn4boss6NsDataFv", nnBossNsDataExport_DeleteRealFileWithHistory);
-	osLib_addFunction("nn_boss", "Exist__Q3_2nn4boss6NsDataCFv", nnBossNsDataExport_Exist);
-	osLib_addFunction("nn_boss", "GetSize__Q3_2nn4boss6NsDataCFv", nnBossNsDataExport_getSize);
-	osLib_addFunction("nn_boss", "Read__Q3_2nn4boss6NsDataFPvUi", nnBossNsDataExport_read);
-	osLib_addFunction("nn_boss", "Read__Q3_2nn4boss6NsDataFPLPvUi", nnBossNsDataExport_readWithSizeOut);
-	osLib_addFunction("nn_boss", "Seek__Q3_2nn4boss6NsDataFLQ3_2nn4boss12PositionBase", nnBossNsDataExport_seek);
-
-}
\ No newline at end of file
+	nn::boss::NsData::InitVTable();
+	cafeExportRegisterFunc(nn::boss::NsData::ctor, "nn_boss", "__ct__Q3_2nn4boss6NsDataFv", LogType::NN_BOSS);
+	cafeExportRegisterFunc(nn::boss::NsData::dtor, "nn_boss", "__dt__Q3_2nn4boss6NsDataFv", LogType::NN_BOSS);
+	cafeExportRegisterFunc(nn::boss::NsData::Initialize, "nn_boss", "Initialize__Q3_2nn4boss6NsDataFRCQ3_2nn4boss7StoragePCc", LogType::NN_BOSS);
+	cafeExportRegisterFunc(nn::boss::NsData::DeleteRealFileWithHistory, "nn_boss", "DeleteRealFileWithHistory__Q3_2nn4boss6NsDataFv", LogType::NN_BOSS);
+	cafeExportRegisterFunc(nn::boss::NsData::Exist, "nn_boss", "Exist__Q3_2nn4boss6NsDataCFv", LogType::NN_BOSS);
+	cafeExportRegisterFunc(nn::boss::NsData::GetSize, "nn_boss", "GetSize__Q3_2nn4boss6NsDataCFv", LogType::NN_BOSS);
+	cafeExportRegisterFunc(nn::boss::NsData::GetCreatedTime, "nn_boss", "GetCreatedTime__Q3_2nn4boss6NsDataCFv", LogType::NN_BOSS);
+	cafeExportRegisterFunc(nn::boss::NsData::Read, "nn_boss", "Read__Q3_2nn4boss6NsDataFPvUi", LogType::NN_BOSS);
+	cafeExportRegisterFunc(nn::boss::NsData::ReadWithSizeOut, "nn_boss", "Read__Q3_2nn4boss6NsDataFPLPvUi", LogType::NN_BOSS);
+	cafeExportRegisterFunc(nn::boss::NsData::Seek, "nn_boss", "Seek__Q3_2nn4boss6NsDataFLQ3_2nn4boss12PositionBase", LogType::NN_BOSS);
+}
diff --git a/src/Cafe/OS/libs/nn_ccr/nn_ccr.cpp b/src/Cafe/OS/libs/nn_ccr/nn_ccr.cpp
index fd87a8a0..6053462f 100644
--- a/src/Cafe/OS/libs/nn_ccr/nn_ccr.cpp
+++ b/src/Cafe/OS/libs/nn_ccr/nn_ccr.cpp
@@ -5,7 +5,7 @@ namespace nn::ccr
 {
 	sint32 CCRSysCaffeineBootCheck()
 	{
-		forceLogDebug_printf("CCRSysCaffeineBootCheck()");
+		cemuLog_logDebug(LogType::Force, "CCRSysCaffeineBootCheck()");
 		return -1;
 	}
 
diff --git a/src/Cafe/OS/libs/nn_cmpt/nn_cmpt.cpp b/src/Cafe/OS/libs/nn_cmpt/nn_cmpt.cpp
index 5566e57e..8d1ce6ad 100644
--- a/src/Cafe/OS/libs/nn_cmpt/nn_cmpt.cpp
+++ b/src/Cafe/OS/libs/nn_cmpt/nn_cmpt.cpp
@@ -5,7 +5,7 @@ namespace nn::cmpt
 {
 	uint32 CMPTAcctGetPcConf(uint32be* pcConf)
 	{
-		forceLogDebug_printf("CMPTAcctGetPcConf() - todo");
+		cemuLog_logDebug(LogType::Force, "CMPTAcctGetPcConf() - todo");
 		pcConf[0] = 0;
 		pcConf[1] = 0;
 		pcConf[2] = 0;
diff --git a/src/Cafe/OS/libs/nn_fp/nn_fp.cpp b/src/Cafe/OS/libs/nn_fp/nn_fp.cpp
index 2df51a94..86ca4708 100644
--- a/src/Cafe/OS/libs/nn_fp/nn_fp.cpp
+++ b/src/Cafe/OS/libs/nn_fp/nn_fp.cpp
@@ -1,426 +1,571 @@
 #include "Cafe/OS/common/OSCommon.h"
-#include "Cafe/IOSU/legacy/iosu_ioctl.h"
 #include "Cafe/IOSU/legacy/iosu_act.h"
 #include "Cafe/IOSU/legacy/iosu_fpd.h"
+#include "Cafe/IOSU/legacy/iosu_ioctl.h" // deprecated
+#include "Cafe/IOSU/iosu_ipc_common.h"
 #include "Cafe/OS/libs/coreinit/coreinit_IOS.h"
-
-#define fpdPrepareRequest() \
-StackAllocator<iosu::fpd::iosuFpdCemuRequest_t> _buf_fpdRequest; \
-StackAllocator<ioBufferVector_t> _buf_bufferVector; \
-iosu::fpd::iosuFpdCemuRequest_t* fpdRequest = _buf_fpdRequest.GetPointer(); \
-ioBufferVector_t* fpdBufferVector = _buf_bufferVector.GetPointer(); \
-memset(fpdRequest, 0, sizeof(iosu::fpd::iosuFpdCemuRequest_t)); \
-memset(fpdBufferVector, 0, sizeof(ioBufferVector_t)); \
-fpdBufferVector->buffer = (uint8*)fpdRequest;
+#include "Cafe/OS/libs/coreinit/coreinit_IPC.h"
+#include "Cafe/OS/libs/nn_common.h"
+#include "util/ChunkedHeap/ChunkedHeap.h"
+#include "Common/CafeString.h"
 
 namespace nn
 {
 	namespace fp
 	{
+		static const auto FPResult_OkZero = 0;
+		static const auto FPResult_Ok = BUILD_NN_RESULT(NN_RESULT_LEVEL_SUCCESS, NN_RESULT_MODULE_NN_FP, 0);
+		static const auto FPResult_InvalidIPCParam = BUILD_NN_RESULT(NN_RESULT_LEVEL_LVL6, NN_RESULT_MODULE_NN_FP, 0x680);
+		static const auto FPResult_RequestFailed = BUILD_NN_RESULT(NN_RESULT_LEVEL_FATAL, NN_RESULT_MODULE_NN_FP, 0); // figure out proper error code
 
-		struct  
+		struct
 		{
-			bool isInitialized;
+			uint32 initCounter;
 			bool isAdminMode;
+			bool isLoggedIn;
+			IOSDevHandle fpdHandle;
+			SysAllocator<coreinit::OSMutex> fpMutex;
+			SysAllocator<uint8, 0x12000> g_fpdAllocatorSpace;
+			VHeap* fpBufferHeap{nullptr};
+			// PPC buffers for async notification query
+			SysAllocator<uint32be> notificationCount;
+			SysAllocator<iosu::fpd::FPDNotification, 256> notificationBuffer;
+			bool getNotificationCalled{false};
+			// notification handler
+			MEMPTR<void> notificationHandler{nullptr};
+			MEMPTR<void> notificationHandlerParam{nullptr};
 		}g_fp = { };
 
-		void Initialize()
+		class
 		{
-			if (g_fp.isInitialized == false)
+		  public:
+			void Init()
 			{
-				g_fp.isInitialized = true;
-				fpdPrepareRequest();
-				fpdRequest->requestCode = iosu::fpd::IOSU_FPD_INITIALIZE;
-				__depr__IOS_Ioctlv(IOS_DEVICE_FPD, IOSU_FPD_REQUEST_CEMU, 1, 1, fpdBufferVector);
+				std::unique_lock _l(m_mtx);
+				g_fp.fpBufferHeap = new VHeap(g_fp.g_fpdAllocatorSpace.GetPtr(), g_fp.g_fpdAllocatorSpace.GetByteSize());
 			}
-		}
 
-
-
-
-		void export_IsInitialized(PPCInterpreter_t* hCPU)
-		{
-			forceLogDebug_printf("Called nn_fp.IsInitialized LR %08x", hCPU->spr.LR);
-			osLib_returnFromFunction(hCPU, g_fp.isInitialized ? 1 : 0);
-		}
-
-		void export_Initialize(PPCInterpreter_t* hCPU)
-		{
-			forceLogDebug_printf("Called nn_fp.Initialize LR %08x", hCPU->spr.LR);
-
-			Initialize();
-
-			osLib_returnFromFunction(hCPU, 0);
-		}
-
-		void export_InitializeAdmin(PPCInterpreter_t* hCPU)
-		{
-			forceLogDebug_printf("Called nn_fp.InitializeAdmin LR %08x", hCPU->spr.LR);
-			Initialize();
-			g_fp.isAdminMode = true;
-			osLib_returnFromFunction(hCPU, 0);
-		}
-
-		void export_IsInitializedAdmin(PPCInterpreter_t* hCPU)
-		{
-			forceLogDebug_printf("nn_fp.IsInitializedAdmin()");
-			osLib_returnFromFunction(hCPU, g_fp.isInitialized ? 1 : 0);
-		}
-
-		void export_SetNotificationHandler(PPCInterpreter_t* hCPU)
-		{
-			ppcDefineParamU32(notificationMask, 0);
-			ppcDefineParamMPTR(funcMPTR, 1);
-			ppcDefineParamMPTR(customParam, 2);
-
-			forceLogDebug_printf("nn_fp.SetNotificationHandler(0x%08x,0x%08x,0x%08x)", hCPU->gpr[3], hCPU->gpr[4], hCPU->gpr[5]);
-
-			fpdPrepareRequest();
-			fpdRequest->requestCode = iosu::fpd::IOSU_FPD_SET_NOTIFICATION_HANDLER;
-			fpdRequest->setNotificationHandler.notificationMask = notificationMask;
-			fpdRequest->setNotificationHandler.funcPtr = funcMPTR;
-			fpdRequest->setNotificationHandler.custom = customParam;
-			__depr__IOS_Ioctlv(IOS_DEVICE_FPD, IOSU_FPD_REQUEST_CEMU, 1, 1, fpdBufferVector);
-
-			osLib_returnFromFunction(hCPU, 0);
-		}
-
-		void export_LoginAsync(PPCInterpreter_t* hCPU)
-		{
-			ppcDefineParamMPTR(funcPtr, 0);
-			ppcDefineParamMPTR(custom, 1);
-			forceLogDebug_printf("nn_fp.LoginAsync(0x%08x,0x%08x)", funcPtr, custom);
-			if (g_fp.isInitialized == false)
+			void Destroy()
 			{
-				osLib_returnFromFunction(hCPU, 0xC0C00580);
+				std::unique_lock _l(m_mtx);
+				delete g_fp.fpBufferHeap;
+			}
+
+			void* Allocate(uint32 size, uint32 alignment)
+			{
+				std::unique_lock _l(m_mtx);
+				void* p = g_fp.fpBufferHeap->alloc(size, 32);
+				if (!p)
+					cemuLog_log(LogType::Force, "nn_fp: Internal heap is full");
+				return p;
+			}
+
+			void Free(void* ptr)
+			{
+				std::unique_lock _l(m_mtx);
+				g_fp.fpBufferHeap->free(ptr);
+			}
+
+		  private:
+			std::mutex m_mtx;
+		}FPIpcBufferAllocator;
+
+		class FPIpcContext {
+			static inline constexpr uint32 MAX_VEC_COUNT = 8;
+		  public:
+			// use FP heap for this class
+			static void* operator new(size_t size)
+			{
+				return FPIpcBufferAllocator.Allocate(size, (uint32)alignof(FPIpcContext));
+			}
+
+			static void operator delete(void* ptr)
+			{
+				FPIpcBufferAllocator.Free(ptr);
+			}
+
+			FPIpcContext(iosu::fpd::FPD_REQUEST_ID requestId) : m_requestId(requestId)
+			{
+			}
+
+			~FPIpcContext()
+			{
+				if(m_dataBuffer)
+					FPIpcBufferAllocator.Free(m_dataBuffer);
+			}
+
+			void AddInput(void* ptr, uint32 size)
+			{
+				size_t vecIndex = GetVecInIndex(m_numVecIn);
+				m_vec[vecIndex].baseVirt = ptr;
+				m_vec[vecIndex].size = size;
+				m_numVecIn = m_numVecIn + 1;
+			}
+
+			void AddOutput(void* ptr, uint32 size)
+			{
+				cemu_assert_debug(m_numVecIn == 0); // all outputs need to be added before any inputs
+				size_t vecIndex = GetVecOutIndex(m_numVecOut);
+				m_vec[vecIndex].baseVirt = ptr;
+				m_vec[vecIndex].size = size;
+				m_numVecOut = m_numVecOut + 1;
+			}
+
+			uint32 Submit(std::unique_ptr<FPIpcContext> owner)
+			{
+				InitSubmissionBuffer();
+				// note: While generally, Ioctlv() usage has the order as input (app->IOSU) followed by output (IOSU->app), FP uses it the other way around
+				nnResult r = coreinit::IOS_Ioctlv(g_fp.fpdHandle, (uint32)m_requestId.value(), m_numVecOut, m_numVecIn, m_vec);
+				CopyBackOutputs();
+				owner.reset();
+				return r;
+			}
+
+			nnResult SubmitAsync(std::unique_ptr<FPIpcContext> owner, MEMPTR<void> callbackFunc, MEMPTR<void> callbackParam)
+			{
+				InitSubmissionBuffer();
+				this->m_callbackFunc = callbackFunc;
+				this->m_callbackParam = callbackParam;
+				nnResult r = coreinit::IOS_IoctlvAsync(g_fp.fpdHandle, (uint32)m_requestId.value(), m_numVecOut, m_numVecIn, m_vec, MEMPTR<void>(PPCInterpreter_makeCallableExportDepr(AsyncHandler)), MEMPTR<void>(this));
+				owner.release();
+				return r;
+			}
+
+		  private:
+			size_t GetVecInIndex(uint8 inIndex)
+			{
+				return m_numVecOut + inIndex;
+			}
+
+			size_t GetVecOutIndex(uint8 outIndex)
+			{
+				return outIndex;
+			}
+
+			void InitSubmissionBuffer()
+			{
+				// allocate a chunk of memory to hold the input/output vectors and their data
+				uint32 vecOffset[MAX_VEC_COUNT];
+				uint32 totalBufferSize = 0;
+				for(uint8 i=0; i<m_numVecIn + m_numVecOut; i++)
+				{
+					vecOffset[i] = totalBufferSize;
+					totalBufferSize += m_vec[i].size;
+					totalBufferSize = (totalBufferSize+31)&~31;
+				}
+				if(totalBufferSize > 0)
+				{
+					m_dataBuffer = FPIpcBufferAllocator.Allocate(totalBufferSize, 32);
+					cemu_assert_debug(m_dataBuffer);
+				}
+				// update Ioctl vector addresses
+				for(uint8 i=0; i<m_numVecIn + m_numVecOut; i++)
+				{
+					void* bufferAddr = (uint8be*)m_dataBuffer.GetPtr() + vecOffset[i];
+					m_vecOriginalAddress[i] = m_vec[i].baseVirt;
+					m_vec[i].baseVirt = bufferAddr;
+				}
+				// copy input data to buffer
+				for(uint8 i=0; i<m_numVecIn; i++)
+				{
+					uint8 vecIndex = GetVecInIndex(i);
+					memcpy(MEMPTR<void>(m_vec[vecIndex].baseVirt).GetPtr(), MEMPTR<void>(m_vecOriginalAddress[vecIndex]).GetPtr(), m_vec[vecIndex].size);
+				}
+			}
+
+			static void AsyncHandler(PPCInterpreter_t* hCPU)
+			{
+				ppcDefineParamU32(result, 0);
+				ppcDefineParamPtr(ipcCtx, FPIpcContext, 1);
+				ipcCtx->m_asyncResult = result; // store result in variable since FP callbacks pass a pointer to nnResult and not the value directly
+				ipcCtx->CopyBackOutputs();
+				PPCCoreCallback(ipcCtx->m_callbackFunc, &ipcCtx->m_asyncResult, ipcCtx->m_callbackParam);
+				delete ipcCtx;
+				osLib_returnFromFunction(hCPU, 0);
+			}
+
+			void CopyBackOutputs()
+			{
+				if(m_numVecOut > 0)
+				{
+					// copy output from temporary output buffers to the original addresses
+					for(uint8 i=0; i<m_numVecOut; i++)
+					{
+						uint32 vecOffset = (uint32)m_vec[GetVecOutIndex(i)].baseVirt.GetMPTR() - (uint32)m_vec[0].baseVirt.GetMPTR();
+						memcpy(m_vecOriginalAddress[GetVecOutIndex(i)].GetPtr(), (uint8be*)m_dataBuffer.GetPtr() + vecOffset, m_vec[GetVecOutIndex(i)].size);
+					}
+				}
+			}
+
+			betype<iosu::fpd::FPD_REQUEST_ID> m_requestId;
+			uint8be m_numVecIn{0};
+			uint8be m_numVecOut{0};
+			IPCIoctlVector m_vec[MAX_VEC_COUNT];
+			MEMPTR<void> m_vecOriginalAddress[MAX_VEC_COUNT]{};
+			MEMPTR<void> m_dataBuffer{nullptr};
+			MEMPTR<void> m_callbackFunc{nullptr};
+			MEMPTR<void> m_callbackParam{nullptr};
+			betype<nnResult> m_asyncResult;
+		};
+
+		struct FPGlobalLock
+		{
+			FPGlobalLock()
+			{
+				coreinit::OSLockMutex(&g_fp.fpMutex);
+			}
+			~FPGlobalLock()
+			{
+				coreinit::OSUnlockMutex(&g_fp.fpMutex);
+			}
+		};
+		#define FP_API_BASE() if (g_fp.initCounter == 0) return 0xC0C00580; FPGlobalLock _fpLock;
+		#define FP_API_BASE_ZeroOnError() if (g_fp.initCounter == 0) return 0; FPGlobalLock _fpLock;
+
+		nnResult Initialize()
+		{
+			FPGlobalLock _fpLock;
+			if (g_fp.initCounter == 0)
+			{
+				g_fp.fpdHandle = coreinit::IOS_Open("/dev/fpd", 0);
+			}
+			g_fp.initCounter++;
+			return FPResult_OkZero;
+		}
+
+		uint32 IsInitialized()
+		{
+			FPGlobalLock _fpLock;
+			return g_fp.initCounter > 0 ? 1 : 0;
+		}
+
+		nnResult InitializeAdmin(PPCInterpreter_t* hCPU)
+		{
+			FPGlobalLock _fpLock;
+			g_fp.isAdminMode = true;
+			return Initialize();
+		}
+
+		uint32 IsInitializedAdmin()
+		{
+			FPGlobalLock _fpLock;
+			return g_fp.initCounter > 0 ? 1 : 0;
+		}
+
+		nnResult Finalize()
+		{
+			FPGlobalLock _fpLock;
+			if (g_fp.initCounter == 1)
+			{
+				g_fp.initCounter = 0;
+				g_fp.isAdminMode = false;
+				g_fp.isLoggedIn = false;
+				coreinit::IOS_Close(g_fp.fpdHandle);
+				g_fp.getNotificationCalled = false;
+			}
+			else if (g_fp.initCounter > 0)
+				g_fp.initCounter--;
+			return FPResult_OkZero;
+		}
+
+		nnResult FinalizeAdmin()
+		{
+			return Finalize();
+		}
+
+		void GetNextNotificationAsync();
+
+		nnResult SetNotificationHandler(uint32 notificationMask, void* funcPtr, void* userParam)
+		{
+			FP_API_BASE();
+			g_fp.notificationHandler = funcPtr;
+			g_fp.notificationHandlerParam = userParam;
+			StackAllocator<uint32be> notificationMaskBuf; notificationMaskBuf = notificationMask;
+			auto ipcCtx = std::make_unique<FPIpcContext>(iosu::fpd::FPD_REQUEST_ID::SetNotificationMask);
+			ipcCtx->AddInput(&notificationMaskBuf, sizeof(uint32be));
+			nnResult r = ipcCtx->Submit(std::move(ipcCtx));
+			if (NN_RESULT_IS_SUCCESS(r))
+			{
+				// async query for notifications
+				GetNextNotificationAsync();
+			}
+			return r;
+		}
+
+		void GetNextNotificationAsyncHandler(PPCInterpreter_t* hCPU)
+		{
+			coreinit::OSLockMutex(&g_fp.fpMutex);
+			cemu_assert_debug(g_fp.getNotificationCalled);
+			g_fp.getNotificationCalled = false;
+			auto bufPtr = g_fp.notificationBuffer.GetPtr();
+			uint32 count = g_fp.notificationCount->value();
+			if (count == 0)
+			{
+				GetNextNotificationAsync();
+				coreinit::OSUnlockMutex(&g_fp.fpMutex);
+				osLib_returnFromFunction(hCPU, 0);
 				return;
 			}
-			fpdPrepareRequest();
-			fpdRequest->requestCode = iosu::fpd::IOSU_FPD_LOGIN_ASYNC;
-			fpdRequest->loginAsync.funcPtr = funcPtr;
-			fpdRequest->loginAsync.custom = custom;
-			__depr__IOS_Ioctlv(IOS_DEVICE_FPD, IOSU_FPD_REQUEST_CEMU, 1, 1, fpdBufferVector);
+			// copy notifications to temporary buffer using std::copy
+			iosu::fpd::FPDNotification tempBuffer[256];
+			std::copy(g_fp.notificationBuffer.GetPtr(), g_fp.notificationBuffer.GetPtr() + count, tempBuffer);
+			// call handler for each notification, but do it outside of the lock
+			void* notificationHandler = g_fp.notificationHandler;
+			void* notificationHandlerParam = g_fp.notificationHandlerParam;
+			coreinit::OSUnlockMutex(&g_fp.fpMutex);
+			iosu::fpd::FPDNotification* notificationBuffer = g_fp.notificationBuffer.GetPtr();
+			for (uint32 i = 0; i < count; i++)
+				PPCCoreCallback(notificationHandler, (uint32)notificationBuffer[i].type, notificationBuffer[i].pid, notificationHandlerParam);
+			coreinit::OSLockMutex(&g_fp.fpMutex);
+			// query more notifications
+			GetNextNotificationAsync();
+			coreinit::OSUnlockMutex(&g_fp.fpMutex);
 			osLib_returnFromFunction(hCPU, 0);
 		}
 
-		void export_HasLoggedIn(PPCInterpreter_t* hCPU)
+		void GetNextNotificationAsync()
 		{
-			// Sonic All Star Racing needs this
-			forceLogDebug_printf("nn_fp.HasLoggedIn()");
-			osLib_returnFromFunction(hCPU, 1);
+			if (g_fp.getNotificationCalled)
+				return;
+			g_fp.getNotificationCalled = true;
+			g_fp.notificationCount = 0;
+			auto ipcCtx = std::make_unique<FPIpcContext>(iosu::fpd::FPD_REQUEST_ID::GetNotificationAsync);
+			ipcCtx->AddOutput(g_fp.notificationBuffer.GetPtr(), g_fp.notificationBuffer.GetByteSize());
+			ipcCtx->AddOutput(g_fp.notificationCount.GetPtr(), sizeof(uint32be));
+			cemu_assert_debug(g_fp.notificationBuffer.GetByteSize() == 0x800);
+			nnResult r = ipcCtx->SubmitAsync(std::move(ipcCtx), MEMPTR<void>(PPCInterpreter_makeCallableExportDepr(GetNextNotificationAsyncHandler)), nullptr);
 		}
 
-		void export_IsOnline(PPCInterpreter_t* hCPU)
+		nnResult LoginAsync(void* funcPtr, void* userParam)
 		{
-			//forceLogDebug_printf("nn_fp.IsOnline();\n");
-			fpdPrepareRequest();
-			fpdRequest->requestCode = iosu::fpd::IOSU_FPD_IS_ONLINE;
-			__depr__IOS_Ioctlv(IOS_DEVICE_FPD, IOSU_FPD_REQUEST_CEMU, 1, 1, fpdBufferVector);
-			forceLogDebug_printf("nn_fp.IsOnline() -> %d", fpdRequest->resultU32.u32);
-
-			osLib_returnFromFunction(hCPU, fpdRequest->resultU32.u32);
+			FP_API_BASE();
+			auto ipcCtx = std::make_unique<FPIpcContext>(iosu::fpd::FPD_REQUEST_ID::LoginAsync);
+			return ipcCtx->SubmitAsync(std::move(ipcCtx), funcPtr, userParam);
 		}
 
-		void export_GetFriendList(PPCInterpreter_t* hCPU)
+		uint32 HasLoggedIn()
 		{
-			ppcDefineParamMEMPTR(pidList, uint32be, 0);
-			ppcDefineParamMEMPTR(returnedCount, uint32be, 1);
-			ppcDefineParamU32(startIndex, 2);
-			ppcDefineParamU32(maxCount, 3);
-
-			forceLogDebug_printf("nn_fp.GetFriendList(...)");
-			//debug_printf("nn_fp.GetFriendList(0x%08x, 0x%08x, %d, %d)\n", hCPU->gpr[3], hCPU->gpr[4], hCPU->gpr[5], hCPU->gpr[6]);
-			fpdPrepareRequest();
-			fpdRequest->requestCode = iosu::fpd::IOSU_FPD_GET_FRIEND_LIST;
-
-			fpdRequest->getFriendList.pidList = pidList;
-			fpdRequest->getFriendList.startIndex = startIndex;
-			fpdRequest->getFriendList.maxCount = maxCount;
-
-			__depr__IOS_Ioctlv(IOS_DEVICE_FPD, IOSU_FPD_REQUEST_CEMU, 1, 1, fpdBufferVector);
-
-			*returnedCount = fpdRequest->resultU32.u32;
-
-			osLib_returnFromFunction(hCPU, fpdRequest->returnCode);
+			FP_API_BASE_ZeroOnError();
+			// Sonic All Star Racing uses this
+			// and Monster Hunter 3 Ultimate needs this to return false at least once to initiate login and not get stuck
+			// this returns false until LoginAsync was called and has completed (?) even if the user is already logged in
+			StackAllocator<uint32be> resultBuf;
+			auto ipcCtx = std::make_unique<FPIpcContext>(iosu::fpd::FPD_REQUEST_ID::HasLoggedIn);
+			ipcCtx->AddOutput(&resultBuf, sizeof(uint32be));
+			ipcCtx->Submit(std::move(ipcCtx));
+			return resultBuf != 0 ? 1 : 0;
 		}
 
-		void export_GetFriendRequestList(PPCInterpreter_t* hCPU)
+		uint32 IsOnline()
 		{
-			// GetFriendRequestList__Q2_2nn2fpFPUiT1UiT3
-			ppcDefineParamMEMPTR(pidList, uint32be, 0);
-			ppcDefineParamMEMPTR(returnedCount, uint32be, 1);
-			ppcDefineParamU32(startIndex, 2);
-			ppcDefineParamU32(maxCount, 3);
-
-			forceLogDebug_printf("nn_fp.GetFriendRequestList(...)");
-			//debug_printf("nn_fp.GetFriendList(0x%08x, 0x%08x, %d, %d)\n", hCPU->gpr[3], hCPU->gpr[4], hCPU->gpr[5], hCPU->gpr[6]);
-			fpdPrepareRequest();
-			fpdRequest->requestCode = iosu::fpd::IOSU_FPD_GET_FRIENDREQUEST_LIST;
-
-			fpdRequest->getFriendList.pidList = pidList;
-			fpdRequest->getFriendList.startIndex = startIndex;
-			fpdRequest->getFriendList.maxCount = maxCount;
-
-			__depr__IOS_Ioctlv(IOS_DEVICE_FPD, IOSU_FPD_REQUEST_CEMU, 1, 1, fpdBufferVector);
-
-			*returnedCount = fpdRequest->resultU32.u32;
-
-			osLib_returnFromFunction(hCPU, fpdRequest->returnCode);
+			FP_API_BASE_ZeroOnError();
+			StackAllocator<uint32be> resultBuf;
+			auto ipcCtx = std::make_unique<FPIpcContext>(iosu::fpd::FPD_REQUEST_ID::IsOnline);
+			ipcCtx->AddOutput(&resultBuf, sizeof(uint32be));
+			ipcCtx->Submit(std::move(ipcCtx));
+			return resultBuf != 0 ? 1 : 0;
 		}
 
-		void export_GetFriendListAll(PPCInterpreter_t* hCPU)
+		nnResult GetFriendList(uint32be* pidList, uint32be* returnedCount, uint32 startIndex, uint32 maxCount)
 		{
-			ppcDefineParamMEMPTR(pidList, uint32be, 0);
-			ppcDefineParamMEMPTR(returnedCount, uint32be, 1);
-			ppcDefineParamU32(startIndex, 2);
-			ppcDefineParamU32(maxCount, 3);
-
-			forceLogDebug_printf("nn_fp.GetFriendListAll(...)");
-
-			//debug_printf("nn_fp.GetFriendListAll(0x%08x, 0x%08x, %d, %d)\n", hCPU->gpr[3], hCPU->gpr[4], hCPU->gpr[5], hCPU->gpr[6]);
-			fpdPrepareRequest();
-			fpdRequest->requestCode = iosu::fpd::IOSU_FPD_GET_FRIEND_LIST_ALL;
-
-			fpdRequest->getFriendList.pidList = pidList;
-			fpdRequest->getFriendList.startIndex = startIndex;
-			fpdRequest->getFriendList.maxCount = maxCount;
-
-			__depr__IOS_Ioctlv(IOS_DEVICE_FPD, IOSU_FPD_REQUEST_CEMU, 1, 1, fpdBufferVector);
-
-			*returnedCount = fpdRequest->resultU32.u32;
-
-			osLib_returnFromFunction(hCPU, fpdRequest->returnCode);
+			FP_API_BASE();
+			StackAllocator<uint32be> startIndexBuf; startIndexBuf = startIndex;
+			StackAllocator<uint32be> maxCountBuf; maxCountBuf = maxCount;
+			auto ipcCtx = std::make_unique<FPIpcContext>(iosu::fpd::FPD_REQUEST_ID::GetFriendList);
+			ipcCtx->AddOutput(pidList, sizeof(uint32be) * maxCount);
+			ipcCtx->AddOutput(returnedCount, sizeof(uint32be));
+			ipcCtx->AddInput(&startIndexBuf, sizeof(uint32be));
+			ipcCtx->AddInput(&maxCountBuf, sizeof(uint32be));
+			return ipcCtx->Submit(std::move(ipcCtx));
 		}
 
-		void export_GetFriendListEx(PPCInterpreter_t* hCPU)
+		nnResult GetFriendRequestList(uint32be* pidList, uint32be* returnedCount, uint32 startIndex, uint32 maxCount)
 		{
-			ppcDefineParamMEMPTR(friendData, iosu::fpd::friendData_t, 0);
-			ppcDefineParamMEMPTR(pidList, uint32be, 1);
-			ppcDefineParamU32(count, 2);
-
-			forceLogDebug_printf("nn_fp.GetFriendListEx(...)");
-
-			fpdPrepareRequest();
-			fpdRequest->requestCode = iosu::fpd::IOSU_FPD_GET_FRIEND_LIST_EX;
-
-			fpdRequest->getFriendListEx.friendData = friendData;
-			fpdRequest->getFriendListEx.pidList = pidList;
-			fpdRequest->getFriendListEx.count = count;
-
-			__depr__IOS_Ioctlv(IOS_DEVICE_FPD, IOSU_FPD_REQUEST_CEMU, 1, 1, fpdBufferVector);
-
-			osLib_returnFromFunction(hCPU, fpdRequest->returnCode);
+			FP_API_BASE();
+			StackAllocator<uint32be> startIndexBuf; startIndexBuf = startIndex;
+			StackAllocator<uint32be> maxCountBuf; maxCountBuf = maxCount;
+			auto ipcCtx = std::make_unique<FPIpcContext>(iosu::fpd::FPD_REQUEST_ID::GetFriendRequestList);
+			ipcCtx->AddOutput(pidList, sizeof(uint32be) * maxCount);
+			ipcCtx->AddOutput(returnedCount, sizeof(uint32be));
+			ipcCtx->AddInput(&startIndexBuf, sizeof(uint32be));
+			ipcCtx->AddInput(&maxCountBuf, sizeof(uint32be));
+			return ipcCtx->Submit(std::move(ipcCtx));
 		}
 
-		void export_GetFriendRequestListEx(PPCInterpreter_t* hCPU)
+		nnResult GetFriendListAll(uint32be* pidList, uint32be* returnedCount, uint32 startIndex, uint32 maxCount)
 		{
-			ppcDefineParamMEMPTR(friendRequest, iosu::fpd::friendRequest_t, 0);
-			ppcDefineParamMEMPTR(pidList, uint32be, 1);
-			ppcDefineParamU32(count, 2);
-
-			forceLogDebug_printf("nn_fp.GetFriendRequestListEx(...)");
-
-			fpdPrepareRequest();
-			fpdRequest->requestCode = iosu::fpd::IOSU_FPD_GET_FRIENDREQUEST_LIST_EX;
-
-			fpdRequest->getFriendRequestListEx.friendRequest = friendRequest;
-			fpdRequest->getFriendRequestListEx.pidList = pidList;
-			fpdRequest->getFriendRequestListEx.count = count;
-
-			__depr__IOS_Ioctlv(IOS_DEVICE_FPD, IOSU_FPD_REQUEST_CEMU, 1, 1, fpdBufferVector);
-
-			osLib_returnFromFunction(hCPU, fpdRequest->returnCode);
+			FP_API_BASE();
+			StackAllocator<uint32be> startIndexBuf; startIndexBuf = startIndex;
+			StackAllocator<uint32be> maxCountBuf; maxCountBuf = maxCount;
+			auto ipcCtx = std::make_unique<FPIpcContext>(iosu::fpd::FPD_REQUEST_ID::GetFriendListAll);
+			ipcCtx->AddOutput(pidList, sizeof(uint32be) * maxCount);
+			ipcCtx->AddOutput(returnedCount, sizeof(uint32be));
+			ipcCtx->AddInput(&startIndexBuf, sizeof(uint32be));
+			ipcCtx->AddInput(&maxCountBuf, sizeof(uint32be));
+			return ipcCtx->Submit(std::move(ipcCtx));
 		}
 
-		void export_GetBasicInfoAsync(PPCInterpreter_t* hCPU)
+		nnResult GetFriendListEx(iosu::fpd::FriendData* friendData, uint32be* pidList, uint32 count)
 		{
-			ppcDefineParamMEMPTR(basicInfo, iosu::fpd::friendBasicInfo_t, 0);
-			ppcDefineParamTypePtr(pidList, uint32be, 1);
-			ppcDefineParamU32(count, 2);
-			ppcDefineParamMPTR(funcMPTR, 3);
-			ppcDefineParamU32(customParam, 4);
-
-			fpdPrepareRequest();
-			fpdRequest->requestCode = iosu::fpd::IOSU_FPD_GET_BASIC_INFO_ASYNC;
-			fpdRequest->getBasicInfo.basicInfo = basicInfo;
-			fpdRequest->getBasicInfo.pidList = pidList;
-			fpdRequest->getBasicInfo.count = count;
-			fpdRequest->getBasicInfo.funcPtr = funcMPTR;
-			fpdRequest->getBasicInfo.custom = customParam;
-			__depr__IOS_Ioctlv(IOS_DEVICE_FPD, IOSU_FPD_REQUEST_CEMU, 1, 1, fpdBufferVector);;
-
-			osLib_returnFromFunction(hCPU, fpdRequest->returnCode);
+			FP_API_BASE();
+			StackAllocator<uint32be> countBuf; countBuf = count;
+			auto ipcCtx = std::make_unique<FPIpcContext>(iosu::fpd::FPD_REQUEST_ID::GetFriendListEx);
+			ipcCtx->AddOutput(friendData, sizeof(iosu::fpd::FriendData) * count);
+			ipcCtx->AddInput(pidList, sizeof(uint32be) * count);
+			ipcCtx->AddInput(&countBuf, sizeof(uint32be));
+			return ipcCtx->Submit(std::move(ipcCtx));
 		}
 
-		void export_GetMyPrincipalId(PPCInterpreter_t* hCPU)
+		nnResult GetFriendRequestListEx(iosu::fpd::FriendRequest* friendRequest, uint32be* pidList, uint32 count)
 		{
-			forceLogDebug_printf("nn_fp.GetMyPrincipalId()");
-
-			fpdPrepareRequest();
-			fpdRequest->requestCode = iosu::fpd::IOSU_FPD_GET_MY_PRINCIPAL_ID;
-			__depr__IOS_Ioctlv(IOS_DEVICE_FPD, IOSU_FPD_REQUEST_CEMU, 1, 1, fpdBufferVector);
-
-			uint32 principalId = fpdRequest->resultU32.u32;
-
-			osLib_returnFromFunction(hCPU, principalId);
+			FP_API_BASE();
+			StackAllocator<uint32be> countBuf; countBuf = count;
+			auto ipcCtx = std::make_unique<FPIpcContext>(iosu::fpd::FPD_REQUEST_ID::GetFriendRequestListEx);
+			ipcCtx->AddOutput(friendRequest, sizeof(iosu::fpd::FriendRequest) * count);
+			ipcCtx->AddInput(pidList, sizeof(uint32be) * count);
+			ipcCtx->AddInput(&countBuf, sizeof(uint32be));
+			return ipcCtx->Submit(std::move(ipcCtx));
 		}
 
-		void export_GetMyAccountId(PPCInterpreter_t* hCPU)
+		nnResult GetBasicInfoAsync(iosu::fpd::FriendBasicInfo* basicInfo, uint32be* pidList, uint32 count, void* funcPtr, void* customParam)
 		{
-			forceLogDebug_printf("nn_fp.GetMyAccountId(0x%08x)", hCPU->gpr[3]);
-			ppcDefineParamTypePtr(accountId, uint8, 0);
-
-			fpdPrepareRequest();
-			fpdRequest->requestCode = iosu::fpd::IOSU_FPD_GET_MY_ACCOUNT_ID;
-			fpdRequest->common.ptr = (void*)accountId;
-			__depr__IOS_Ioctlv(IOS_DEVICE_FPD, IOSU_FPD_REQUEST_CEMU, 1, 1, fpdBufferVector);
-
-			osLib_returnFromFunction(hCPU, fpdRequest->returnCode);
+			FP_API_BASE();
+			StackAllocator<uint32be> countBuf; countBuf = count;
+			auto ipcCtx = std::make_unique<FPIpcContext>(iosu::fpd::FPD_REQUEST_ID::GetBasicInfoAsync);
+			ipcCtx->AddOutput(basicInfo, sizeof(iosu::fpd::FriendBasicInfo) * count);
+			ipcCtx->AddInput(pidList, sizeof(uint32be) * count);
+			ipcCtx->AddInput(&countBuf, sizeof(uint32be));
+			return ipcCtx->SubmitAsync(std::move(ipcCtx), funcPtr, customParam);
 		}
 
-		void export_GetMyScreenName(PPCInterpreter_t* hCPU)
+		uint32 GetMyPrincipalId()
 		{
-			forceLogDebug_printf("nn_fp.GetMyScreenName(0x%08x)", hCPU->gpr[3]);
-			ppcDefineParamTypePtr(screenname, uint16be, 0);
-
-			screenname[0] = '\0';
-			fpdPrepareRequest();
-			fpdRequest->requestCode = iosu::fpd::IOSU_FPD_GET_MY_SCREENNAME;
-			fpdRequest->common.ptr = (void*)screenname;
-			__depr__IOS_Ioctlv(IOS_DEVICE_FPD, IOSU_FPD_REQUEST_CEMU, 1, 1, fpdBufferVector);
-
-			osLib_returnFromFunction(hCPU, 0);
+			FP_API_BASE_ZeroOnError();
+			StackAllocator<uint32be> resultBuf;
+			auto ipcCtx = std::make_unique<FPIpcContext>(iosu::fpd::FPD_REQUEST_ID::GetMyPrincipalId);
+			ipcCtx->AddOutput(&resultBuf, sizeof(uint32be));
+			ipcCtx->Submit(std::move(ipcCtx));
+			return resultBuf->value();
 		}
 
-		typedef struct  
+		nnResult GetMyAccountId(uint8be* accountId)
 		{
-			uint8 showOnline; // show online status to others
-			uint8 showGame; // show played game to others
-			uint8 blockFriendRequests; // block friend requests
-		}fpPerference_t;
-
-		void export_GetMyPreference(PPCInterpreter_t* hCPU)
-		{
-			forceLogDebug_printf("nn_fp.GetMyPreference(0x%08x) - placeholder", hCPU->gpr[3]);
-			ppcDefineParamTypePtr(pref, fpPerference_t, 0);
-
-			pref->showOnline = 1;
-			pref->showGame = 1;
-			pref->blockFriendRequests = 0;
-
-			osLib_returnFromFunction(hCPU, 0);
+			FP_API_BASE();
+			auto ipcCtx = std::make_unique<FPIpcContext>(iosu::fpd::FPD_REQUEST_ID::GetMyAccountId);
+			ipcCtx->AddOutput(accountId, ACT_ACCOUNTID_LENGTH);
+			return ipcCtx->Submit(std::move(ipcCtx));
 		}
 
-		// GetMyPreference__Q2_2nn2fpFPQ3_2nn2fp10Preference
-
-		void export_GetMyMii(PPCInterpreter_t* hCPU)
+		nnResult GetMyScreenName(uint16be* screenname)
 		{
-			forceLogDebug_printf("nn_fp.GetMyMii(0x%08x)", hCPU->gpr[3]);
-			ppcDefineParamTypePtr(fflData, FFLData_t, 0);
-
-			fpdPrepareRequest();
-			fpdRequest->requestCode = iosu::fpd::IOSU_FPD_GET_MY_MII;
-			fpdRequest->common.ptr = (void*)fflData;
-			__depr__IOS_Ioctlv(IOS_DEVICE_FPD, IOSU_FPD_REQUEST_CEMU, 1, 1, fpdBufferVector);
-
-			osLib_returnFromFunction(hCPU, fpdRequest->returnCode);
+			FP_API_BASE();
+			auto ipcCtx = std::make_unique<FPIpcContext>(iosu::fpd::FPD_REQUEST_ID::GetMyScreenName);
+			ipcCtx->AddOutput(screenname, ACT_NICKNAME_SIZE*sizeof(uint16));
+			return ipcCtx->Submit(std::move(ipcCtx));
 		}
 
-		void export_GetFriendAccountId(PPCInterpreter_t* hCPU)
+		nnResult GetMyPlayingGame(iosu::fpd::GameKey* myPlayingGame)
 		{
-			forceLogDebug_printf("nn_fp.GetFriendAccountId(0x%08x,0x%08x,0x%08x)", hCPU->gpr[3], hCPU->gpr[4], hCPU->gpr[5]);
-			ppcDefineParamMEMPTR(accountIds, char, 0);
-			ppcDefineParamMEMPTR(pidList, uint32be, 1);
-			ppcDefineParamU32(count, 2);
-
-			fpdPrepareRequest();
-			fpdRequest->requestCode = iosu::fpd::IOSU_FPD_GET_FRIEND_ACCOUNT_ID;
-			fpdRequest->getFriendAccountId.accountIds = accountIds;
-			fpdRequest->getFriendAccountId.pidList = pidList;
-			fpdRequest->getFriendAccountId.count = count;
-			__depr__IOS_Ioctlv(IOS_DEVICE_FPD, IOSU_FPD_REQUEST_CEMU, 1, 1, fpdBufferVector);
-
-			osLib_returnFromFunction(hCPU, fpdRequest->returnCode);
+			FP_API_BASE();
+			auto ipcCtx = std::make_unique<FPIpcContext>(iosu::fpd::FPD_REQUEST_ID::GetMyPlayingGame);
+			ipcCtx->AddOutput(myPlayingGame, sizeof(iosu::fpd::GameKey));
+			return ipcCtx->Submit(std::move(ipcCtx));
 		}
 
-		void export_GetFriendScreenName(PPCInterpreter_t* hCPU)
+		nnResult GetMyPreference(iosu::fpd::FPDPreference* myPreference)
 		{
-			// GetFriendScreenName__Q2_2nn2fpFPA11_wPCUiUibPUc
-			forceLogDebug_printf("nn_fp.GetFriendScreenName(0x%08x,0x%08x,0x%08x,%d,0x%08x)", hCPU->gpr[3], hCPU->gpr[4], hCPU->gpr[5], hCPU->gpr[6], hCPU->gpr[7]);
-			ppcDefineParamMEMPTR(nameList, uint16be, 0);
-			ppcDefineParamMEMPTR(pidList, uint32be, 1);
-			ppcDefineParamU32(count, 2);
-			ppcDefineParamU32(replaceNonAscii, 3);
-			ppcDefineParamMEMPTR(languageList, uint8, 4);
-
-			fpdPrepareRequest();
-			fpdRequest->requestCode = iosu::fpd::IOSU_FPD_GET_FRIEND_SCREENNAME;
-			fpdRequest->getFriendScreenname.nameList = nameList;
-			fpdRequest->getFriendScreenname.pidList = pidList;
-			fpdRequest->getFriendScreenname.count = count;
-			fpdRequest->getFriendScreenname.replaceNonAscii = replaceNonAscii != 0;
-			fpdRequest->getFriendScreenname.languageList = languageList;
-			__depr__IOS_Ioctlv(IOS_DEVICE_FPD, IOSU_FPD_REQUEST_CEMU, 1, 1, fpdBufferVector);
-
-			osLib_returnFromFunction(hCPU, fpdRequest->returnCode);
+			FP_API_BASE();
+			auto ipcCtx = std::make_unique<FPIpcContext>(iosu::fpd::FPD_REQUEST_ID::GetMyPreference);
+			ipcCtx->AddOutput(myPreference, sizeof(iosu::fpd::FPDPreference));
+			return ipcCtx->Submit(std::move(ipcCtx));
 		}
 
-		void export_GetFriendMii(PPCInterpreter_t* hCPU)
+		nnResult GetMyComment(uint16be* myComment)
 		{
-			forceLogDebug_printf("nn_fp.GetFriendMii(0x%08x,0x%08x,0x%08x)", hCPU->gpr[3], hCPU->gpr[4], hCPU->gpr[5]);
-			ppcDefineParamMEMPTR(miiList, FFLData_t, 0);
-			ppcDefineParamMEMPTR(pidList, uint32be, 1);
-			ppcDefineParamU32(count, 2);
-
-			fpdPrepareRequest();
-			fpdRequest->requestCode = iosu::fpd::IOSU_FPD_GET_FRIEND_MII;
-			fpdRequest->getFriendMii.miiList = (uint8*)miiList.GetPtr();
-			fpdRequest->getFriendMii.pidList = pidList;
-			fpdRequest->getFriendMii.count = count;
-			__depr__IOS_Ioctlv(IOS_DEVICE_FPD, IOSU_FPD_REQUEST_CEMU, 1, 1, fpdBufferVector);
-
-			osLib_returnFromFunction(hCPU, fpdRequest->returnCode);
+			FP_API_BASE();
+			auto ipcCtx = std::make_unique<FPIpcContext>(iosu::fpd::FPD_REQUEST_ID::GetMyComment);
+			ipcCtx->AddOutput(myComment, iosu::fpd::MY_COMMENT_LENGTH * sizeof(uint16be));
+			return ipcCtx->Submit(std::move(ipcCtx));
 		}
 
-		void export_GetFriendPresence(PPCInterpreter_t* hCPU)
+		nnResult GetMyMii(FFLData_t* fflData)
 		{
-			forceLogDebug_printf("nn_fp.GetFriendPresence(0x%08x,0x%08x,0x%08x)", hCPU->gpr[3], hCPU->gpr[4], hCPU->gpr[5]);
-			ppcDefineParamMEMPTR(presenceList, uint8, 0);
-			ppcDefineParamMEMPTR(pidList, uint32be, 1);
-			ppcDefineParamU32(count, 2);
-
-			fpdPrepareRequest();
-			fpdRequest->requestCode = iosu::fpd::IOSU_FPD_GET_FRIEND_PRESENCE;
-			fpdRequest->getFriendPresence.presenceList = (uint8*)presenceList.GetPtr();
-			fpdRequest->getFriendPresence.pidList = pidList;
-			fpdRequest->getFriendPresence.count = count;
-			__depr__IOS_Ioctlv(IOS_DEVICE_FPD, IOSU_FPD_REQUEST_CEMU, 1, 1, fpdBufferVector);
-
-			osLib_returnFromFunction(hCPU, fpdRequest->returnCode);
+			FP_API_BASE();
+			auto ipcCtx = std::make_unique<FPIpcContext>(iosu::fpd::FPD_REQUEST_ID::GetMyMii);
+			ipcCtx->AddOutput(fflData, sizeof(FFLData_t));
+			return ipcCtx->Submit(std::move(ipcCtx));
 		}
 
-		void export_GetFriendRelationship(PPCInterpreter_t* hCPU)
+		nnResult GetFriendAccountId(uint8be* accountIdArray, uint32be* pidList, uint32 count)
 		{
-			forceLogDebug_printf("nn_fp.GetFriendRelationship(0x%08x,0x%08x,0x%08x)", hCPU->gpr[3], hCPU->gpr[4], hCPU->gpr[5]);
-			ppcDefineParamMEMPTR(relationshipList, uint8, 0);
-			ppcDefineParamMEMPTR(pidList, uint32be, 1);
-			ppcDefineParamU32(count, 2);
-
-			fpdPrepareRequest();
-			fpdRequest->requestCode = iosu::fpd::IOSU_FPD_GET_FRIEND_RELATIONSHIP;
-			fpdRequest->getFriendRelationship.relationshipList = (uint8*)relationshipList.GetPtr();
-			fpdRequest->getFriendRelationship.pidList = pidList;
-			fpdRequest->getFriendRelationship.count = count;
-			__depr__IOS_Ioctlv(IOS_DEVICE_FPD, IOSU_FPD_REQUEST_CEMU, 1, 1, fpdBufferVector);
-
-			osLib_returnFromFunction(hCPU, fpdRequest->returnCode);
+			FP_API_BASE();
+			if (count == 0)
+				return 0;
+			StackAllocator<uint32be> countBuf; countBuf = count;
+			auto ipcCtx = std::make_unique<FPIpcContext>(iosu::fpd::FPD_REQUEST_ID::GetFriendAccountId);
+			ipcCtx->AddOutput(accountIdArray, ACT_ACCOUNTID_LENGTH * count);
+			ipcCtx->AddInput(pidList, sizeof(uint32be) * count);
+			ipcCtx->AddInput(&countBuf, sizeof(uint32be));
+			return ipcCtx->Submit(std::move(ipcCtx));
 		}
 
-		void export_IsJoinable(PPCInterpreter_t* hCPU)
+		nnResult GetFriendScreenName(uint16be* nameList, uint32be* pidList, uint32 count, uint8 replaceNonAscii, uint8be* languageList)
 		{
-			ppcDefineParamTypePtr(presence, iosu::fpd::friendPresence_t, 0);
-			ppcDefineParamU64(joinMask, 2);
+			FP_API_BASE();
+			if (count == 0)
+				return 0;
+			StackAllocator<uint32be> countBuf; countBuf = count;
+			StackAllocator<uint32be> replaceNonAsciiBuf; replaceNonAsciiBuf = replaceNonAscii;
+			auto ipcCtx = std::make_unique<FPIpcContext>(iosu::fpd::FPD_REQUEST_ID::GetFriendScreenName);
+			ipcCtx->AddOutput(nameList, ACT_NICKNAME_SIZE * sizeof(uint16be) * count);
+			ipcCtx->AddOutput(languageList, languageList ? sizeof(uint8be) * count : 0);
+			ipcCtx->AddInput(pidList, sizeof(uint32be) * count);
+			ipcCtx->AddInput(&countBuf, sizeof(uint32be));
+			ipcCtx->AddInput(&replaceNonAsciiBuf, sizeof(uint8be));
+			return ipcCtx->Submit(std::move(ipcCtx));
+		}
 
+		nnResult GetFriendMii(FFLData_t* miiList, uint32be* pidList, uint32 count)
+		{
+			FP_API_BASE();
+			if(count == 0)
+				return 0;
+			StackAllocator<uint32be> countBuf; countBuf = count;
+			auto ipcCtx = std::make_unique<FPIpcContext>(iosu::fpd::FPD_REQUEST_ID::GetFriendMii);
+			ipcCtx->AddOutput(miiList, sizeof(FFLData_t) * count);
+			ipcCtx->AddInput(pidList, sizeof(uint32be) * count);
+			ipcCtx->AddInput(&countBuf, sizeof(uint32be));
+			return ipcCtx->Submit(std::move(ipcCtx));
+		}
+
+		nnResult GetFriendPresence(iosu::fpd::FriendPresence* presenceList, uint32be* pidList, uint32 count)
+		{
+			FP_API_BASE();
+			if(count == 0)
+				return 0;
+			StackAllocator<uint32be> countBuf; countBuf = count;
+			auto ipcCtx = std::make_unique<FPIpcContext>(iosu::fpd::FPD_REQUEST_ID::GetFriendPresence);
+			ipcCtx->AddOutput(presenceList, sizeof(iosu::fpd::FriendPresence) * count);
+			ipcCtx->AddInput(pidList, sizeof(uint32be) * count);
+			ipcCtx->AddInput(&countBuf, sizeof(uint32be));
+			return ipcCtx->Submit(std::move(ipcCtx));
+		}
+
+		nnResult GetFriendRelationship(uint8* relationshipList, uint32be* pidList, uint32 count)
+		{
+			FP_API_BASE();
+			if(count == 0)
+				return 0;
+			StackAllocator<uint32be> countBuf; countBuf = count;
+			auto ipcCtx = std::make_unique<FPIpcContext>(iosu::fpd::FPD_REQUEST_ID::GetFriendRelationship);
+			ipcCtx->AddOutput(relationshipList, sizeof(uint8) * count);
+			ipcCtx->AddInput(pidList, sizeof(uint32be) * count);
+			ipcCtx->AddInput(&countBuf, sizeof(uint32be));
+			return ipcCtx->Submit(std::move(ipcCtx));
+		}
+
+		uint32 IsJoinable(iosu::fpd::FriendPresence* presence, uint64 joinMask)
+		{
 			if (presence->isValid == 0 ||
 				presence->isOnline == 0 ||
 				presence->gameMode.joinGameId == 0 ||
@@ -428,368 +573,254 @@ namespace nn
 				presence->gameMode.groupId == 0 ||
 				presence->gameMode.joinGameMode >= 64 )
 			{
-				osLib_returnFromFunction(hCPU, 0);
-				return;
+				return 0;
 			}
 
 			uint32 joinGameMode = presence->gameMode.joinGameMode;
 			uint64 joinModeMask = (1ULL<<joinGameMode);
 			if ((joinModeMask&joinMask) == 0)
-			{
-				osLib_returnFromFunction(hCPU, 0);
-				return;
-			}
+				return 0;
 
 			// check relation ship
 			uint32 joinFlagMask = presence->gameMode.joinFlagMask;
 			if (joinFlagMask == 0)
-			{
-				osLib_returnFromFunction(hCPU, 0);
-				return;
-			}
+				return 0;
 			if (joinFlagMask == 1)
-			{
-				osLib_returnFromFunction(hCPU, 1);
-				return;
-			}
+				return 1;
 			if (joinFlagMask == 2)
 			{
-				//  check relationship
+				// check relationship
 				uint8 relationship[1] = { 0 };
 				StackAllocator<uint32be, 1> pidList;
-				pidList[0] = presence->gameMode.hostPid;
-				fpdPrepareRequest();
-				fpdRequest->requestCode = iosu::fpd::IOSU_FPD_GET_FRIEND_RELATIONSHIP;
-				fpdRequest->getFriendRelationship.relationshipList = relationship;
-				fpdRequest->getFriendRelationship.pidList = pidList.GetPointer();
-				fpdRequest->getFriendRelationship.count = 1;
-				__depr__IOS_Ioctlv(IOS_DEVICE_FPD, IOSU_FPD_REQUEST_CEMU, 1, 1, fpdBufferVector);
-
+				pidList = presence->gameMode.hostPid;
+				GetFriendRelationship(relationship, &pidList, 1);
 				if(relationship[0] == iosu::fpd::RELATIONSHIP_FRIEND)
-					osLib_returnFromFunction(hCPU, 1);
-				else
-					osLib_returnFromFunction(hCPU, 0);
-				return;
+					return 1;
+				return 0;
 			}
 			if (joinFlagMask == 0x65 || joinFlagMask == 0x66)
 			{
-				forceLog_printf("Unsupported friend invite");
+				cemuLog_log(LogType::Force, "Unsupported friend invite");
 			}
-
-			osLib_returnFromFunction(hCPU, 0);
+			return 0;
 		}
 
-		void export_CheckSettingStatusAsync(PPCInterpreter_t* hCPU)
+		nnResult CheckSettingStatusAsync(uint8* status, void* funcPtr, void* customParam)
 		{
-			forceLogDebug_printf("nn_fp.CheckSettingStatusAsync(0x%08x,0x%08x,0x%08x) - placeholder", hCPU->gpr[3], hCPU->gpr[4], hCPU->gpr[5]);
-			ppcDefineParamTypePtr(uknR3, uint8, 0);
-			ppcDefineParamMPTR(funcMPTR, 1);
-			ppcDefineParamU32(customParam, 2);
+			FP_API_BASE();
+			auto ipcCtx = std::make_unique<FPIpcContext>(iosu::fpd::FPD_REQUEST_ID::CheckSettingStatusAsync);
+			ipcCtx->AddOutput(status, sizeof(uint8be));
+			return ipcCtx->SubmitAsync(std::move(ipcCtx), funcPtr, customParam);
+		}
 
-			if (g_fp.isAdminMode == false)
+		uint32 IsPreferenceValid()
+		{
+			FP_API_BASE_ZeroOnError();
+			StackAllocator<uint32be> resultBuf;
+			auto ipcCtx = std::make_unique<FPIpcContext>(iosu::fpd::FPD_REQUEST_ID::IsPreferenceValid);
+			ipcCtx->AddOutput(&resultBuf, sizeof(uint32be));
+			ipcCtx->Submit(std::move(ipcCtx));
+			return resultBuf != 0 ? 1 : 0;
+		}
+
+		nnResult UpdateCommentAsync(uint16be* newComment, void* funcPtr, void* customParam)
+		{
+			FP_API_BASE();
+			auto ipcCtx = std::make_unique<FPIpcContext>(iosu::fpd::FPD_REQUEST_ID::UpdateCommentAsync);
+			uint32 commentLen = CafeStringHelpers::Length(newComment, iosu::fpd::MY_COMMENT_LENGTH-1);
+			if (commentLen >= iosu::fpd::MY_COMMENT_LENGTH-1)
 			{
-
-				osLib_returnFromFunction(hCPU, 0xC0C00800);
-				return;
+				cemuLog_log(LogType::Force, "UpdateCommentAsync: message too long");
+				return FPResult_InvalidIPCParam;
 			}
-
-			*uknR3 = 1;
-
-			StackAllocator<uint32be> callbackResultCode;
-
-			*callbackResultCode.GetPointer() = 0;
-
-			hCPU->gpr[3] = callbackResultCode.GetMPTR();
-			hCPU->gpr[4] = customParam;
-			PPCCore_executeCallbackInternal(funcMPTR);
-
-			osLib_returnFromFunction(hCPU, 0);
+			ipcCtx->AddInput(newComment, sizeof(uint16be) * commentLen + 2);    
+			return ipcCtx->SubmitAsync(std::move(ipcCtx), funcPtr, customParam);
 		}
 
-		void export_IsPreferenceValid(PPCInterpreter_t* hCPU)
+		nnResult UpdatePreferenceAsync(iosu::fpd::FPDPreference* newPreference, void* funcPtr, void* customParam)
 		{
-			forceLogDebug_printf("nn_fp.IsPreferenceValid()");
-			fpdPrepareRequest();
-			fpdRequest->requestCode = iosu::fpd::IOSU_FPD_IS_PREFERENCE_VALID;
-			__depr__IOS_Ioctlv(IOS_DEVICE_FPD, IOSU_FPD_REQUEST_CEMU, 1, 1, fpdBufferVector);
-
-			osLib_returnFromFunction(hCPU, fpdRequest->resultU32.u32);
+			FP_API_BASE();
+			auto ipcCtx = std::make_unique<FPIpcContext>(iosu::fpd::FPD_REQUEST_ID::UpdatePreferenceAsync);
+			ipcCtx->AddInput(newPreference, sizeof(iosu::fpd::FPDPreference));
+			return ipcCtx->SubmitAsync(std::move(ipcCtx), funcPtr, customParam);
 		}
 
-		void export_UpdatePreferenceAsync(PPCInterpreter_t* hCPU)
+		nnResult UpdateGameModeWithUnusedParam(iosu::fpd::GameMode* gameMode, uint16be* gameModeMessage, uint32 unusedParam)
 		{
-			forceLogDebug_printf("nn_fp.UpdatePreferenceAsync(0x%08x,0x%08x,0x%08x) - placeholder", hCPU->gpr[3], hCPU->gpr[4], hCPU->gpr[5]);
-			ppcDefineParamTypePtr(uknR3, uint8, 0);
-			ppcDefineParamMPTR(funcMPTR, 1);
-			ppcDefineParamU32(customParam, 2);
-
-			if (g_fp.isAdminMode == false)
+			FP_API_BASE();
+			uint32 messageLen = CafeStringHelpers::Length(gameModeMessage, iosu::fpd::GAMEMODE_MAX_MESSAGE_LENGTH);
+			if(messageLen >= iosu::fpd::GAMEMODE_MAX_MESSAGE_LENGTH)
 			{
-
-				osLib_returnFromFunction(hCPU, 0xC0C00800);
-				return;
+				cemuLog_log(LogType::Force, "UpdateGameMode: message too long");
+				return FPResult_InvalidIPCParam;
 			}
-
-			//*uknR3 = 0;	// seems to be 3 bytes (nn::fp::Preference const *)
-
-			StackAllocator<uint32be> callbackResultCode;
-
-			*callbackResultCode.GetPointer() = 0;
-
-			hCPU->gpr[3] = callbackResultCode.GetMPTR();
-			hCPU->gpr[4] = customParam;
-			PPCCore_executeCallbackInternal(funcMPTR);
-
-			osLib_returnFromFunction(hCPU, 0);
+			auto ipcCtx = std::make_unique<FPIpcContext>(iosu::fpd::FPD_REQUEST_ID::UpdateGameModeVariation2);
+			ipcCtx->AddInput(gameMode, sizeof(iosu::fpd::GameMode));
+			ipcCtx->AddInput(gameModeMessage, sizeof(uint16be) * (messageLen + 1));
+			return ipcCtx->Submit(std::move(ipcCtx));
 		}
 
-		void export_UpdateGameMode(PPCInterpreter_t* hCPU)
+		nnResult UpdateGameMode(iosu::fpd::GameMode* gameMode, uint16be* gameModeMessage)
 		{
-			forceLogDebug_printf("nn_fp.UpdateGameMode(0x%08x,0x%08x,%d)", hCPU->gpr[3], hCPU->gpr[4], hCPU->gpr[5]);
-			ppcDefineParamMEMPTR(gameMode, iosu::fpd::gameMode_t, 0);
-			ppcDefineParamMEMPTR(gameModeMessage, uint16be, 1);
-			ppcDefineParamU32(uknR5, 2);
-
-			fpdPrepareRequest();
-			fpdRequest->requestCode = iosu::fpd::IOSU_FPD_UPDATE_GAMEMODE;
-			fpdRequest->updateGameMode.gameMode = gameMode;
-			fpdRequest->updateGameMode.gameModeMessage = gameModeMessage;
-			__depr__IOS_Ioctlv(IOS_DEVICE_FPD, IOSU_FPD_REQUEST_CEMU, 1, 1, fpdBufferVector);
-
-			osLib_returnFromFunction(hCPU, 0);
+			return UpdateGameModeWithUnusedParam(gameMode, gameModeMessage, 0);
 		}
 
-		void export_GetRequestBlockSettingAsync(PPCInterpreter_t* hCPU)
+		nnResult GetRequestBlockSettingAsync(uint8* blockSettingList, uint32be* pidList, uint32 count, void* funcPtr, void* customParam)
 		{
-			ppcDefineParamTypePtr(settingList, uint8, 0);
-			ppcDefineParamTypePtr(pidList, uint32be, 1);
-			ppcDefineParamU32(pidCount, 2);
-			ppcDefineParamMPTR(funcMPTR, 3);
-			ppcDefineParamMPTR(customParam, 4);
-
-			forceLogDebug_printf("GetRequestBlockSettingAsync(...) - todo");
-
-			for (uint32 i = 0; i < pidCount; i++)
-				settingList[i] = 0;
-			// 0 means not blocked. Friend app will continue with GetBasicInformation()
-			// 1 means blocked. Friend app will continue with AddFriendAsync to add the user as a provisional friend
-			
-			StackAllocator<uint32be> callbackResultCode;
-
-			*callbackResultCode.GetPointer() = 0;
-
-			hCPU->gpr[3] = callbackResultCode.GetMPTR();
-			hCPU->gpr[4] = customParam;
-			PPCCore_executeCallbackInternal(funcMPTR);
-
-			osLib_returnFromFunction(hCPU, 0);
+			FP_API_BASE();
+			StackAllocator<uint32be> countBuf; countBuf = count;
+			auto ipcCtx = std::make_unique<FPIpcContext>(iosu::fpd::FPD_REQUEST_ID::GetRequestBlockSettingAsync);
+			ipcCtx->AddOutput(blockSettingList, sizeof(uint8be) * count);
+			ipcCtx->AddInput(pidList, sizeof(uint32be) * count);
+			ipcCtx->AddInput(&countBuf, sizeof(uint32be));
+			return ipcCtx->SubmitAsync(std::move(ipcCtx), funcPtr, customParam);
 		}
 
-		void export_AddFriendAsync(PPCInterpreter_t* hCPU)
+		// overload of AddFriendAsync
+		nnResult AddFriendAsyncByPid(uint32 pid, void* funcPtr, void* customParam)
 		{
-			// AddFriendAsync__Q2_2nn2fpFPCcPFQ2_2nn6ResultPv_vPv
-			ppcDefineParamU32(principalId, 0);
-			ppcDefineParamMPTR(funcMPTR, 1);
-			ppcDefineParamMPTR(customParam, 2);
-
-#ifndef PUBLIC_RELEASE
-			assert_dbg();
-#endif
-			fpdPrepareRequest();
-			fpdRequest->requestCode = iosu::fpd::IOSU_FPD_ADD_FRIEND;
-			fpdRequest->addOrRemoveFriend.pid = principalId;
-			fpdRequest->addOrRemoveFriend.funcPtr = funcMPTR;
-			fpdRequest->addOrRemoveFriend.custom = customParam;
-			__depr__IOS_Ioctlv(IOS_DEVICE_FPD, IOSU_FPD_REQUEST_CEMU, 1, 1, fpdBufferVector);
-
-			osLib_returnFromFunction(hCPU, fpdRequest->returnCode);
+			FP_API_BASE();
+			StackAllocator<uint32be> pidBuf; pidBuf = pid;
+			auto ipcCtx = std::make_unique<FPIpcContext>(iosu::fpd::FPD_REQUEST_ID::AddFriendAsyncByPid);
+			ipcCtx->AddInput(&pidBuf, sizeof(uint32be));
+			return ipcCtx->SubmitAsync(std::move(ipcCtx), funcPtr, customParam);
 		}
 
-
-		void export_DeleteFriendFlagsAsync(PPCInterpreter_t* hCPU)
+		nnResult DeleteFriendFlagsAsync(uint32be* pidList, uint32 pidCount, uint32 ukn, void* funcPtr, void* customParam)
 		{
-			forceLogDebug_printf("nn_fp.DeleteFriendFlagsAsync(...) - todo");
-			ppcDefineParamU32(uknR3, 0); // example value: pointer
-			ppcDefineParamU32(uknR4, 1); // example value: 1
-			ppcDefineParamU32(uknR5, 2); // example value: 1
-			ppcDefineParamMPTR(funcMPTR, 3);
-			ppcDefineParamU32(customParam, 4);
-
-			if (g_fp.isAdminMode == false)
-			{
-				osLib_returnFromFunction(hCPU, 0xC0C00800);
-				return;
-			}
-
-			StackAllocator<uint32be> callbackResultCode;
-
-			*callbackResultCode.GetPointer() = 0;
-
-			hCPU->gpr[3] = callbackResultCode.GetMPTR();
-			hCPU->gpr[4] = customParam;
-			PPCCore_executeCallbackInternal(funcMPTR);
-
-			osLib_returnFromFunction(hCPU, 0);
+			// admin function?
+			FP_API_BASE();
+			StackAllocator<uint32be> pidCountBuf; pidCountBuf = pidCount;
+			StackAllocator<uint32be> uknBuf; uknBuf = ukn;
+			auto ipcCtx = std::make_unique<FPIpcContext>(iosu::fpd::FPD_REQUEST_ID::DeleteFriendFlagsAsync);
+			ipcCtx->AddInput(pidList, sizeof(uint32be) * pidCount);
+			ipcCtx->AddInput(&pidCountBuf, sizeof(uint32be));
+			ipcCtx->AddInput(&uknBuf, sizeof(uint32be));
+			return ipcCtx->SubmitAsync(std::move(ipcCtx), funcPtr, customParam);
 		}
 
-
-		typedef struct  
+		// overload of AddFriendRequestAsync
+		nnResult AddFriendRequestByPlayRecordAsync(iosu::fpd::RecentPlayRecordEx* playRecord, uint16be* message, void* funcPtr, void* customParam)
 		{
-			/* +0x00 */ uint32be pid;
-			/* +0x04 */ uint8 ukn04;
-			/* +0x05 */ uint8 ukn05;
-			/* +0x06 */ uint8 ukn06[0x22];
-			/* +0x28 */ uint8 ukn28[0x22];
-			/* +0x4A */ uint8 _uknOrPadding4A[6];
-			/* +0x50 */ uint32be ukn50;
-			/* +0x54 */ uint32be ukn54;
-			/* +0x58 */ uint16be ukn58;
-			/* +0x5C */ uint8 _padding5C[4];
-			/* +0x60 */ iosu::fpd::fpdDate_t date;
-		}RecentPlayRecordEx_t;
-
-		static_assert(sizeof(RecentPlayRecordEx_t) == 0x68, "");
-		static_assert(offsetof(RecentPlayRecordEx_t, ukn06) == 0x06, "");
-		static_assert(offsetof(RecentPlayRecordEx_t, ukn50) == 0x50, "");
-
-		void export_AddFriendRequestAsync(PPCInterpreter_t* hCPU)
-		{
-			ppcDefineParamTypePtr(playRecord, RecentPlayRecordEx_t, 0);
-			ppcDefineParamTypePtr(message, uint16be, 1);
-			ppcDefineParamMPTR(funcMPTR, 2);
-			ppcDefineParamMPTR(customParam, 3);
-
-			fpdPrepareRequest();
-
-			uint8* uknData = (uint8*)playRecord;
-
-			fpdRequest->requestCode = iosu::fpd::IOSU_FPD_ADD_FRIEND_REQUEST;
-			fpdRequest->addFriendRequest.pid = playRecord->pid;
-			fpdRequest->addFriendRequest.message = message;
-			fpdRequest->addFriendRequest.funcPtr = funcMPTR;
-			fpdRequest->addFriendRequest.custom = customParam;
-			__depr__IOS_Ioctlv(IOS_DEVICE_FPD, IOSU_FPD_REQUEST_CEMU, 1, 1, fpdBufferVector);
-
-			osLib_returnFromFunction(hCPU, fpdRequest->returnCode);
+			FP_API_BASE();
+			auto ipcCtx = std::make_unique<FPIpcContext>(iosu::fpd::FPD_REQUEST_ID::AddFriendRequestByPlayRecordAsync);
+			uint32 messageLen = 0;
+			while(message[messageLen] != 0)
+				messageLen++;
+			ipcCtx->AddInput(playRecord, sizeof(iosu::fpd::RecentPlayRecordEx));
+			ipcCtx->AddInput(message, sizeof(uint16be) * (messageLen+1));
+			return ipcCtx->SubmitAsync(std::move(ipcCtx), funcPtr, customParam);
 		}
 
-		void export_RemoveFriendAsync(PPCInterpreter_t* hCPU)
+		nnResult RemoveFriendAsync(uint32 pid, void* funcPtr, void* customParam)
 		{
-			ppcDefineParamU32(principalId, 0);
-			ppcDefineParamMPTR(funcMPTR, 1);
-			ppcDefineParamMPTR(customParam, 2);
-
-			fpdPrepareRequest();
-			fpdRequest->requestCode = iosu::fpd::IOSU_FPD_REMOVE_FRIEND_ASYNC;
-			fpdRequest->addOrRemoveFriend.pid = principalId;
-			fpdRequest->addOrRemoveFriend.funcPtr = funcMPTR;
-			fpdRequest->addOrRemoveFriend.custom = customParam;
-			__depr__IOS_Ioctlv(IOS_DEVICE_FPD, IOSU_FPD_REQUEST_CEMU, 1, 1, fpdBufferVector);
-
-			osLib_returnFromFunction(hCPU, fpdRequest->returnCode);
+			FP_API_BASE();
+			StackAllocator<uint32be> pidBuf; pidBuf = pid;
+			auto ipcCtx = std::make_unique<FPIpcContext>(iosu::fpd::FPD_REQUEST_ID::RemoveFriendAsync);
+			ipcCtx->AddInput(&pidBuf, sizeof(uint32be));
+			return ipcCtx->SubmitAsync(std::move(ipcCtx), funcPtr, customParam);
 		}
 
-		void export_MarkFriendRequestsAsReceivedAsync(PPCInterpreter_t* hCPU)
+		nnResult MarkFriendRequestsAsReceivedAsync(uint64be* messageIdList, uint32 count, void* funcPtr, void* customParam)
 		{
-			ppcDefineParamTypePtr(messageIdList, uint64, 0);
-			ppcDefineParamU32(count, 1);
-			ppcDefineParamMPTR(funcMPTR, 2);
-			ppcDefineParamMPTR(customParam, 3);
-
-			fpdPrepareRequest();
-			fpdRequest->requestCode = iosu::fpd::IOSU_FPD_MARK_FRIEND_REQUEST_AS_RECEIVED_ASYNC;
-			fpdRequest->markFriendRequest.messageIdList = messageIdList;
-			fpdRequest->markFriendRequest.count = count;
-			fpdRequest->markFriendRequest.funcPtr = funcMPTR;
-			fpdRequest->markFriendRequest.custom = customParam;
-			__depr__IOS_Ioctlv(IOS_DEVICE_FPD, IOSU_FPD_REQUEST_CEMU, 1, 1, fpdBufferVector);
-
-			osLib_returnFromFunction(hCPU, fpdRequest->returnCode);
+			FP_API_BASE();
+			StackAllocator<uint32be> countBuf; countBuf = count;
+			auto ipcCtx = std::make_unique<FPIpcContext>(iosu::fpd::FPD_REQUEST_ID::MarkFriendRequestsAsReceivedAsync);
+			ipcCtx->AddInput(messageIdList, sizeof(uint64be) * count);
+			ipcCtx->AddInput(&countBuf, sizeof(uint32be));
+			return ipcCtx->SubmitAsync(std::move(ipcCtx), funcPtr, customParam);
 		}
 
-		void export_CancelFriendRequestAsync(PPCInterpreter_t* hCPU)
+		nnResult CancelFriendRequestAsync(uint64 requestId, void* funcPtr, void* customParam)
 		{
-			ppcDefineParamU64(frqMessageId, 0);
-			ppcDefineParamMPTR(funcMPTR, 2);
-			ppcDefineParamMPTR(customParam, 3);
-
-			fpdPrepareRequest();
-			fpdRequest->requestCode = iosu::fpd::IOSU_FPD_CANCEL_FRIEND_REQUEST_ASYNC;
-			fpdRequest->cancelOrAcceptFriendRequest.messageId = frqMessageId;
-			fpdRequest->cancelOrAcceptFriendRequest.funcPtr = funcMPTR;
-			fpdRequest->cancelOrAcceptFriendRequest.custom = customParam;
-			__depr__IOS_Ioctlv(IOS_DEVICE_FPD, IOSU_FPD_REQUEST_CEMU, 1, 1, fpdBufferVector);
-
-			osLib_returnFromFunction(hCPU, fpdRequest->returnCode);
+			FP_API_BASE();
+			StackAllocator<uint64be> requestIdBuf; requestIdBuf = requestId;
+			auto ipcCtx = std::make_unique<FPIpcContext>(iosu::fpd::FPD_REQUEST_ID::CancelFriendRequestAsync);
+			ipcCtx->AddInput(&requestIdBuf, sizeof(uint64be));
+			return ipcCtx->SubmitAsync(std::move(ipcCtx), funcPtr, customParam);
 		}
 
-		void export_AcceptFriendRequestAsync(PPCInterpreter_t* hCPU)
+		nnResult DeleteFriendRequestAsync(uint64 requestId, void* funcPtr, void* customParam)
 		{
-			ppcDefineParamU64(frqMessageId, 0);
-			ppcDefineParamMPTR(funcMPTR, 2);
-			ppcDefineParamMPTR(customParam, 3);
+			FP_API_BASE();
+			StackAllocator<uint64be> requestIdBuf; requestIdBuf = requestId;
+			auto ipcCtx = std::make_unique<FPIpcContext>(iosu::fpd::FPD_REQUEST_ID::DeleteFriendRequestAsync);
+			ipcCtx->AddInput(&requestIdBuf, sizeof(uint64be));
+			return ipcCtx->SubmitAsync(std::move(ipcCtx), funcPtr, customParam);
+		}
 
-			fpdPrepareRequest();
-			fpdRequest->requestCode = iosu::fpd::IOSU_FPD_ACCEPT_FRIEND_REQUEST_ASYNC;
-			fpdRequest->cancelOrAcceptFriendRequest.messageId = frqMessageId;
-			fpdRequest->cancelOrAcceptFriendRequest.funcPtr = funcMPTR;
-			fpdRequest->cancelOrAcceptFriendRequest.custom = customParam;
-			__depr__IOS_Ioctlv(IOS_DEVICE_FPD, IOSU_FPD_REQUEST_CEMU, 1, 1, fpdBufferVector);
-
-			osLib_returnFromFunction(hCPU, fpdRequest->returnCode);
+		nnResult AcceptFriendRequestAsync(uint64 requestId, void* funcPtr, void* customParam)
+		{
+			FP_API_BASE();
+			StackAllocator<uint64be> requestIdBuf; requestIdBuf = requestId;
+			auto ipcCtx = std::make_unique<FPIpcContext>(iosu::fpd::FPD_REQUEST_ID::AcceptFriendRequestAsync);
+			ipcCtx->AddInput(&requestIdBuf, sizeof(uint64be));
+			return ipcCtx->SubmitAsync(std::move(ipcCtx), funcPtr, customParam);
 		}
 
 		void load()
 		{
-			osLib_addFunction("nn_fp", "Initialize__Q2_2nn2fpFv", export_Initialize);
-			osLib_addFunction("nn_fp", "InitializeAdmin__Q2_2nn2fpFv", export_InitializeAdmin);
-			osLib_addFunction("nn_fp", "IsInitialized__Q2_2nn2fpFv", export_IsInitialized);
-			osLib_addFunction("nn_fp", "IsInitializedAdmin__Q2_2nn2fpFv", export_IsInitializedAdmin);
+			g_fp.initCounter = 0;
+			g_fp.isAdminMode = false;
+			g_fp.isLoggedIn = false;
+			g_fp.getNotificationCalled = false;
+			g_fp.notificationHandler = nullptr;
+			g_fp.notificationHandlerParam = nullptr;
 
-			osLib_addFunction("nn_fp", "SetNotificationHandler__Q2_2nn2fpFUiPFQ3_2nn2fp16NotificationTypeUiPv_vPv", export_SetNotificationHandler);
+			coreinit::OSInitMutex(&g_fp.fpMutex);
+			FPIpcBufferAllocator.Init();
 
-			osLib_addFunction("nn_fp", "LoginAsync__Q2_2nn2fpFPFQ2_2nn6ResultPv_vPv", export_LoginAsync);
-			osLib_addFunction("nn_fp", "HasLoggedIn__Q2_2nn2fpFv", export_HasLoggedIn);
+			cafeExportRegisterFunc(Initialize, "nn_fp", "Initialize__Q2_2nn2fpFv", LogType::NN_FP);
+			cafeExportRegisterFunc(InitializeAdmin, "nn_fp", "InitializeAdmin__Q2_2nn2fpFv", LogType::NN_FP);
+			cafeExportRegisterFunc(IsInitialized, "nn_fp", "IsInitialized__Q2_2nn2fpFv", LogType::NN_FP);
+			cafeExportRegisterFunc(IsInitializedAdmin, "nn_fp", "IsInitializedAdmin__Q2_2nn2fpFv", LogType::NN_FP);
+			cafeExportRegisterFunc(Finalize, "nn_fp", "Finalize__Q2_2nn2fpFv", LogType::NN_FP);
+			cafeExportRegisterFunc(FinalizeAdmin, "nn_fp", "FinalizeAdmin__Q2_2nn2fpFv", LogType::NN_FP);
 
-			osLib_addFunction("nn_fp", "IsOnline__Q2_2nn2fpFv", export_IsOnline);
+			cafeExportRegisterFunc(SetNotificationHandler, "nn_fp", "SetNotificationHandler__Q2_2nn2fpFUiPFQ3_2nn2fp16NotificationTypeUiPv_vPv", LogType::NN_FP);
 
-			osLib_addFunction("nn_fp", "GetFriendList__Q2_2nn2fpFPUiT1UiT3", export_GetFriendList);
-			osLib_addFunction("nn_fp", "GetFriendRequestList__Q2_2nn2fpFPUiT1UiT3", export_GetFriendRequestList);
-			osLib_addFunction("nn_fp", "GetFriendListAll__Q2_2nn2fpFPUiT1UiT3", export_GetFriendListAll);
-			osLib_addFunction("nn_fp", "GetFriendListEx__Q2_2nn2fpFPQ3_2nn2fp10FriendDataPCUiUi", export_GetFriendListEx);
-			osLib_addFunction("nn_fp", "GetFriendRequestListEx__Q2_2nn2fpFPQ3_2nn2fp13FriendRequestPCUiUi", export_GetFriendRequestListEx);
-			osLib_addFunction("nn_fp", "GetBasicInfoAsync__Q2_2nn2fpFPQ3_2nn2fp9BasicInfoPCUiUiPFQ2_2nn6ResultPv_vPv", export_GetBasicInfoAsync);
+			cafeExportRegisterFunc(LoginAsync, "nn_fp", "LoginAsync__Q2_2nn2fpFPFQ2_2nn6ResultPv_vPv", LogType::NN_FP);
+			cafeExportRegisterFunc(HasLoggedIn, "nn_fp", "HasLoggedIn__Q2_2nn2fpFv", LogType::NN_FP);
+			cafeExportRegisterFunc(IsOnline, "nn_fp", "IsOnline__Q2_2nn2fpFv", LogType::NN_FP);
+			cafeExportRegisterFunc(GetFriendList, "nn_fp", "GetFriendList__Q2_2nn2fpFPUiT1UiT3", LogType::NN_FP);
+			cafeExportRegisterFunc(GetFriendRequestList, "nn_fp", "GetFriendRequestList__Q2_2nn2fpFPUiT1UiT3", LogType::NN_FP);
+			cafeExportRegisterFunc(GetFriendListAll, "nn_fp", "GetFriendListAll__Q2_2nn2fpFPUiT1UiT3", LogType::NN_FP);
+			cafeExportRegisterFunc(GetFriendListEx, "nn_fp", "GetFriendListEx__Q2_2nn2fpFPQ3_2nn2fp10FriendDataPCUiUi", LogType::NN_FP);
+			cafeExportRegisterFunc(GetFriendRequestListEx, "nn_fp", "GetFriendRequestListEx__Q2_2nn2fpFPQ3_2nn2fp13FriendRequestPCUiUi", LogType::NN_FP);
+			cafeExportRegisterFunc(GetBasicInfoAsync, "nn_fp", "GetBasicInfoAsync__Q2_2nn2fpFPQ3_2nn2fp9BasicInfoPCUiUiPFQ2_2nn6ResultPv_vPv", LogType::NN_FP);
 
-			osLib_addFunction("nn_fp", "GetMyPrincipalId__Q2_2nn2fpFv", export_GetMyPrincipalId);
-			osLib_addFunction("nn_fp", "GetMyAccountId__Q2_2nn2fpFPc", export_GetMyAccountId);
-			osLib_addFunction("nn_fp", "GetMyScreenName__Q2_2nn2fpFPw", export_GetMyScreenName);
-			osLib_addFunction("nn_fp", "GetMyMii__Q2_2nn2fpFP12FFLStoreData", export_GetMyMii);
-			osLib_addFunction("nn_fp", "GetMyPreference__Q2_2nn2fpFPQ3_2nn2fp10Preference", export_GetMyPreference);
+			cafeExportRegisterFunc(GetMyPrincipalId, "nn_fp", "GetMyPrincipalId__Q2_2nn2fpFv", LogType::NN_FP);
+			cafeExportRegisterFunc(GetMyAccountId, "nn_fp", "GetMyAccountId__Q2_2nn2fpFPc", LogType::NN_FP);
+			cafeExportRegisterFunc(GetMyScreenName, "nn_fp", "GetMyScreenName__Q2_2nn2fpFPw", LogType::NN_FP);
+			cafeExportRegisterFunc(GetMyMii, "nn_fp", "GetMyMii__Q2_2nn2fpFP12FFLStoreData", LogType::NN_FP);
+			cafeExportRegisterFunc(GetMyPlayingGame, "nn_fp", "GetMyPlayingGame__Q2_2nn2fpFPQ3_2nn2fp7GameKey", LogType::NN_FP);
+			cafeExportRegisterFunc(GetMyPreference, "nn_fp", "GetMyPreference__Q2_2nn2fpFPQ3_2nn2fp10Preference", LogType::NN_FP);
+			cafeExportRegisterFunc(GetMyComment, "nn_fp", "GetMyComment__Q2_2nn2fpFPQ3_2nn2fp7Comment", LogType::NN_FP);
 
-			osLib_addFunction("nn_fp", "GetFriendAccountId__Q2_2nn2fpFPA17_cPCUiUi", export_GetFriendAccountId);
-			osLib_addFunction("nn_fp", "GetFriendScreenName__Q2_2nn2fpFPA11_wPCUiUibPUc", export_GetFriendScreenName);
-			osLib_addFunction("nn_fp", "GetFriendMii__Q2_2nn2fpFP12FFLStoreDataPCUiUi", export_GetFriendMii);
-			osLib_addFunction("nn_fp", "GetFriendPresence__Q2_2nn2fpFPQ3_2nn2fp14FriendPresencePCUiUi", export_GetFriendPresence);
-			osLib_addFunction("nn_fp", "GetFriendRelationship__Q2_2nn2fpFPUcPCUiUi", export_GetFriendRelationship);
-			osLib_addFunction("nn_fp", "IsJoinable__Q2_2nn2fpFPCQ3_2nn2fp14FriendPresenceUL", export_IsJoinable);
+			cafeExportRegisterFunc(GetFriendAccountId, "nn_fp", "GetFriendAccountId__Q2_2nn2fpFPA17_cPCUiUi", LogType::NN_FP);
+			cafeExportRegisterFunc(GetFriendScreenName, "nn_fp", "GetFriendScreenName__Q2_2nn2fpFPA11_wPCUiUibPUc", LogType::NN_FP);
+			cafeExportRegisterFunc(GetFriendMii, "nn_fp", "GetFriendMii__Q2_2nn2fpFP12FFLStoreDataPCUiUi", LogType::NN_FP);
+			cafeExportRegisterFunc(GetFriendPresence, "nn_fp", "GetFriendPresence__Q2_2nn2fpFPQ3_2nn2fp14FriendPresencePCUiUi", LogType::NN_FP);
+			cafeExportRegisterFunc(GetFriendRelationship, "nn_fp", "GetFriendRelationship__Q2_2nn2fpFPUcPCUiUi", LogType::NN_FP);
+			cafeExportRegisterFunc(IsJoinable, "nn_fp", "IsJoinable__Q2_2nn2fpFPCQ3_2nn2fp14FriendPresenceUL", LogType::NN_FP);
 
-			osLib_addFunction("nn_fp", "CheckSettingStatusAsync__Q2_2nn2fpFPUcPFQ2_2nn6ResultPv_vPv", export_CheckSettingStatusAsync);
-			osLib_addFunction("nn_fp", "IsPreferenceValid__Q2_2nn2fpFv", export_IsPreferenceValid);
-			osLib_addFunction("nn_fp", "UpdatePreferenceAsync__Q2_2nn2fpFPCQ3_2nn2fp10PreferencePFQ2_2nn6ResultPv_vPv", export_UpdatePreferenceAsync);
+			cafeExportRegisterFunc(CheckSettingStatusAsync, "nn_fp", "CheckSettingStatusAsync__Q2_2nn2fpFPUcPFQ2_2nn6ResultPv_vPv", LogType::NN_FP);
+			cafeExportRegisterFunc(IsPreferenceValid, "nn_fp", "IsPreferenceValid__Q2_2nn2fpFv", LogType::NN_FP);
+			cafeExportRegisterFunc(UpdateCommentAsync, "nn_fp", "UpdateCommentAsync__Q2_2nn2fpFPCwPFQ2_2nn6ResultPv_vPv", LogType::NN_FP);
+			cafeExportRegisterFunc(UpdatePreferenceAsync, "nn_fp", "UpdatePreferenceAsync__Q2_2nn2fpFPCQ3_2nn2fp10PreferencePFQ2_2nn6ResultPv_vPv", LogType::NN_FP);
+			cafeExportRegisterFunc(GetRequestBlockSettingAsync, "nn_fp", "GetRequestBlockSettingAsync__Q2_2nn2fpFPUcPCUiUiPFQ2_2nn6ResultPv_vPv", LogType::NN_FP);
 
-			osLib_addFunction("nn_fp", "UpdateGameMode__Q2_2nn2fpFPCQ3_2nn2fp8GameModePCwUi", export_UpdateGameMode);
-
-			osLib_addFunction("nn_fp", "GetRequestBlockSettingAsync__Q2_2nn2fpFPUcPCUiUiPFQ2_2nn6ResultPv_vPv", export_GetRequestBlockSettingAsync);
-
-			osLib_addFunction("nn_fp", "AddFriendAsync__Q2_2nn2fpFPCcPFQ2_2nn6ResultPv_vPv", export_AddFriendAsync);
-			osLib_addFunction("nn_fp", "AddFriendRequestAsync__Q2_2nn2fpFPCQ3_2nn2fp18RecentPlayRecordExPCwPFQ2_2nn6ResultPv_vPv", export_AddFriendRequestAsync);
-			osLib_addFunction("nn_fp", "DeleteFriendFlagsAsync__Q2_2nn2fpFPCUiUiT2PFQ2_2nn6ResultPv_vPv", export_DeleteFriendFlagsAsync);
-
-			osLib_addFunction("nn_fp", "RemoveFriendAsync__Q2_2nn2fpFUiPFQ2_2nn6ResultPv_vPv", export_RemoveFriendAsync);
-			osLib_addFunction("nn_fp", "MarkFriendRequestsAsReceivedAsync__Q2_2nn2fpFPCULUiPFQ2_2nn6ResultPv_vPv", export_MarkFriendRequestsAsReceivedAsync);
-			osLib_addFunction("nn_fp", "CancelFriendRequestAsync__Q2_2nn2fpFULPFQ2_2nn6ResultPv_vPv", export_CancelFriendRequestAsync);
-			osLib_addFunction("nn_fp", "AcceptFriendRequestAsync__Q2_2nn2fpFULPFQ2_2nn6ResultPv_vPv", export_AcceptFriendRequestAsync);
+			cafeExportRegisterFunc(UpdateGameModeWithUnusedParam, "nn_fp", "UpdateGameMode__Q2_2nn2fpFPCQ3_2nn2fp8GameModePCwUi", LogType::NN_FP);
+			cafeExportRegisterFunc(UpdateGameMode, "nn_fp", "UpdateGameMode__Q2_2nn2fpFPCQ3_2nn2fp8GameModePCw", LogType::NN_FP);
 
+			cafeExportRegisterFunc(AddFriendAsyncByPid, "nn_fp", "AddFriendAsync__Q2_2nn2fpFUiPFQ2_2nn6ResultPv_vPv", LogType::NN_FP);
+			cafeExportRegisterFunc(AddFriendRequestByPlayRecordAsync, "nn_fp", "AddFriendRequestAsync__Q2_2nn2fpFPCQ3_2nn2fp18RecentPlayRecordExPCwPFQ2_2nn6ResultPv_vPv", LogType::NN_FP);
+			cafeExportRegisterFunc(DeleteFriendFlagsAsync, "nn_fp", "DeleteFriendFlagsAsync__Q2_2nn2fpFPCUiUiT2PFQ2_2nn6ResultPv_vPv", LogType::NN_FP);
+			cafeExportRegisterFunc(RemoveFriendAsync, "nn_fp", "RemoveFriendAsync__Q2_2nn2fpFUiPFQ2_2nn6ResultPv_vPv", LogType::NN_FP);
+			cafeExportRegisterFunc(MarkFriendRequestsAsReceivedAsync, "nn_fp", "MarkFriendRequestsAsReceivedAsync__Q2_2nn2fpFPCULUiPFQ2_2nn6ResultPv_vPv", LogType::NN_FP);
+			cafeExportRegisterFunc(CancelFriendRequestAsync, "nn_fp", "CancelFriendRequestAsync__Q2_2nn2fpFULPFQ2_2nn6ResultPv_vPv", LogType::NN_FP);
+			cafeExportRegisterFunc(DeleteFriendRequestAsync, "nn_fp", "DeleteFriendRequestAsync__Q2_2nn2fpFULPFQ2_2nn6ResultPv_vPv", LogType::NN_FP);
+			cafeExportRegisterFunc(AcceptFriendRequestAsync, "nn_fp", "AcceptFriendRequestAsync__Q2_2nn2fpFULPFQ2_2nn6ResultPv_vPv", LogType::NN_FP);
 		}
 	}
 }
diff --git a/src/Cafe/OS/libs/nn_idbe/nn_idbe.cpp b/src/Cafe/OS/libs/nn_idbe/nn_idbe.cpp
index 72ea5231..eb0178fe 100644
--- a/src/Cafe/OS/libs/nn_idbe/nn_idbe.cpp
+++ b/src/Cafe/OS/libs/nn_idbe/nn_idbe.cpp
@@ -40,19 +40,19 @@ namespace nn
 		static_assert(offsetof(nnIdbeEncryptedIcon_t, iconData) == 0x22, "");
 		static_assert(sizeof(nnIdbeEncryptedIcon_t) == 0x12082);
 
-		void asyncDownloadIconFile(uint64 titleId, nnIdbeEncryptedIcon_t* iconOut, OSThread_t* thread)
+		void asyncDownloadIconFile(uint64 titleId, nnIdbeEncryptedIcon_t* iconOut, coreinit::OSEvent* event)
 		{
-			std::vector<uint8> idbeData = NAPI::IDBE_RequestRawEncrypted(titleId);
+			std::vector<uint8> idbeData = NAPI::IDBE_RequestRawEncrypted(ActiveSettings::GetNetworkService(), titleId);
 			if (idbeData.size() != sizeof(nnIdbeEncryptedIcon_t))
 			{
 				// icon does not exist or has the wrong size
-				cemuLog_force("IDBE: Failed to retrieve icon for title {:016x}", titleId);
+				cemuLog_log(LogType::Force, "IDBE: Failed to retrieve icon for title {:016x}", titleId);
 				memset(iconOut, 0, sizeof(nnIdbeEncryptedIcon_t));
-				coreinit_resumeThread(thread);
+				coreinit::OSSignalEvent(event);
 				return;
 			}
 			memcpy(iconOut, idbeData.data(), sizeof(nnIdbeEncryptedIcon_t));
-			coreinit_resumeThread(thread);
+			coreinit::OSSignalEvent(event);
 		}
 
 		void export_DownloadIconFile(PPCInterpreter_t* hCPU)
@@ -62,9 +62,10 @@ namespace nn
 			ppcDefineParamU32(uknR7, 4);
 			ppcDefineParamU32(uknR8, 5);
 
-			auto asyncTask = std::async(std::launch::async, asyncDownloadIconFile, titleId, encryptedIconData, coreinit::OSGetCurrentThread());
-			coreinit::OSSuspendThread(coreinit::OSGetCurrentThread());
-			PPCCore_switchToScheduler();
+			StackAllocator<coreinit::OSEvent> event;
+			coreinit::OSInitEvent(&event, coreinit::OSEvent::EVENT_STATE::STATE_NOT_SIGNALED, coreinit::OSEvent::EVENT_MODE::MODE_AUTO);
+			auto asyncTask = std::async(std::launch::async, asyncDownloadIconFile, titleId, encryptedIconData, &event);
+			coreinit::OSWaitEvent(&event);
 			osLib_returnFromFunction(hCPU, 1);
 		}
 
@@ -89,12 +90,12 @@ namespace nn
 			nnIdbeHeader_t* idbeHeader = (nnIdbeHeader_t*)iconInput;
 			if (idbeHeader->formatVersion != 0)
 			{
-				forceLog_printf("idbe header version unknown (%d)", (sint32)idbeHeader->formatVersion);
+				cemuLog_log(LogType::Force, "idbe header version unknown ({})", (sint32)idbeHeader->formatVersion);
 				return false;
 			}
 			if (idbeHeader->keyIndex >= 4)
 			{
-				forceLog_printf("idbe header key count invalid (%d)", (sint32)idbeHeader->keyIndex);
+				cemuLog_log(LogType::Force, "idbe header key count invalid ({})", (sint32)idbeHeader->keyIndex);
 				return false;
 			}
 			// decrypt data
@@ -108,7 +109,7 @@ namespace nn
 			SHA256((const unsigned char*)iconOutput, sizeof(nnIdbeIconDataV0_t), calculatedSHA256);
 			if (memcmp(calculatedSHA256, decryptedSHA256, SHA256_DIGEST_LENGTH) != 0)
 			{
-				forceLogDebug_printf("Idbe icon has incorrect sha256 hash");
+				cemuLog_logDebug(LogType::Force, "Idbe icon has incorrect sha256 hash");
 				return false;
 			}
 			return true;
@@ -141,14 +142,14 @@ namespace nn
 			ppcDefineParamTypePtr(input, nnIdbeEncryptedIcon_t, 1);
 			ppcDefineParamU32(platformMode, 2);
 
-			forceLogDebug_printf("nn_idbe.DecryptIconFile(...)");
+			cemuLog_logDebug(LogType::Force, "nn_idbe.DecryptIconFile(...)");
 
 			if (decryptIcon(input, output))
 			{
 				osLib_returnFromFunction(hCPU, 1);
 				return;
 			}
-			forceLogDebug_printf("Unable to decrypt idbe icon file, using default icon");
+			cemuLog_logDebug(LogType::Force, "Unable to decrypt idbe icon file, using default icon");
 
 			// return default icon
 			TGAHeader* tgaHeader = (TGAHeader*)(output->GetTGAData());
@@ -175,4 +176,4 @@ namespace nn
 		}
 
 	}
-}
\ No newline at end of file
+}
diff --git a/src/Cafe/OS/libs/nn_ndm/nn_ndm.cpp b/src/Cafe/OS/libs/nn_ndm/nn_ndm.cpp
index e87e8e69..5a69b787 100644
--- a/src/Cafe/OS/libs/nn_ndm/nn_ndm.cpp
+++ b/src/Cafe/OS/libs/nn_ndm/nn_ndm.cpp
@@ -1,27 +1,91 @@
 #include "nn_ndm.h"
 #include "Cafe/OS/common/OSCommon.h"
+#include "Cafe/OS/libs/nn_common.h"
 
 namespace nn
 {
 	namespace ndm
 	{
-		void nnNdmExport_GetDaemonStatus(PPCInterpreter_t* hCPU)
+
+		enum class DAEMON_NAME : uint32
 		{
-			// parameters:
-			// r3	pointer to status integer (out)
-			// r4	daemon name (integer)
-			forceLogDebug_printf("nn_ndm.GetDaemonStatus(...) - hack\n");
-			// status codes:
-			// 1 - running? Download Manager (scope.rpx) expects this to return 1 (or zero). Otherwise it will display downloads as disabled
-			memory_writeU32(hCPU->gpr[3], 1);
-			// 2 - running?
-			// 3 - suspended?
-			osLib_returnFromFunction(hCPU, 0);
+			UKN_0, // Boss related?
+			UKN_1, // Download Manager? scope.rpx (Download Manager app) expects this to have status 0 or 1. Otherwise it will display downloads as disabled
+			UKN_2,
+		};
+
+		enum class DAEMON_STATUS : uint32
+		{
+			STATUS_UKN_0 = 0, // probably: Ready or initializing?
+			RUNNING = 1, // most likely running, but not 100% sure
+			STATUS_UKN_2 = 2, // probably: ready, starting or something like that?
+			SUSPENDED = 3,
+		};
+
+		constexpr size_t NUM_DAEMONS = 3;
+		DAEMON_STATUS s_daemonStatus[NUM_DAEMONS];
+		uint32 s_initializeRefCount;
+
+		uint32 Initialize()
+		{
+			s_initializeRefCount++;
+			return BUILD_NN_RESULT(NN_RESULT_LEVEL_SUCCESS, NN_RESULT_MODULE_NN_NDM, 0);
+		}
+
+		uint32 IsInitialized()
+		{
+			return s_initializeRefCount != 0 ? 1 : 0;
+		}
+
+		uint32 Finalize()
+		{
+			if(s_initializeRefCount == 0)
+				return BUILD_NN_RESULT(NN_RESULT_LEVEL_STATUS, NN_RESULT_MODULE_NN_NDM, 0);
+			s_initializeRefCount++;
+			return BUILD_NN_RESULT(NN_RESULT_LEVEL_SUCCESS, NN_RESULT_MODULE_NN_NDM, 0);
+		}
+
+		uint32 GetDaemonStatus(betype<DAEMON_STATUS>* statusOut, DAEMON_NAME daemonName)
+		{
+			size_t daemonIndex = (size_t)daemonName;
+			if(daemonIndex >= NUM_DAEMONS)
+				return BUILD_NN_RESULT(NN_RESULT_LEVEL_STATUS, NN_RESULT_MODULE_NN_NDM, 0);
+			*statusOut = s_daemonStatus[daemonIndex];
+			return BUILD_NN_RESULT(NN_RESULT_LEVEL_SUCCESS, NN_RESULT_MODULE_NN_NDM, 0);
+		}
+
+		uint32 SuspendDaemons(uint32 daemonNameBitmask)
+		{
+			for(size_t i=0; i<NUM_DAEMONS; i++)
+			{
+				if(daemonNameBitmask & (1 << i))
+					s_daemonStatus[i] = DAEMON_STATUS::SUSPENDED;
+			}
+			return BUILD_NN_RESULT(NN_RESULT_LEVEL_SUCCESS, NN_RESULT_MODULE_NN_NDM, 0);
+		}
+
+		uint32 ResumeDaemons(uint32 daemonNameBitmask)
+		{
+			for(size_t i=0; i<NUM_DAEMONS; i++)
+			{
+				if(daemonNameBitmask & (1 << i))
+					s_daemonStatus[i] = DAEMON_STATUS::RUNNING;
+			}
+			return BUILD_NN_RESULT(NN_RESULT_LEVEL_SUCCESS, NN_RESULT_MODULE_NN_NDM, 0);
 		}
 
 		void load()
 		{
-			osLib_addFunction("nn_ndm", "GetDaemonStatus__Q2_2nn3ndmFPQ4_2nn3ndm7IDaemon6StatusQ4_2nn3ndm4Cafe10DaemonName", nnNdmExport_GetDaemonStatus);
+			for(size_t i=0; i<NUM_DAEMONS; i++)
+				s_daemonStatus[i] = DAEMON_STATUS::RUNNING;
+			s_initializeRefCount = 0;
+
+			cafeExportRegisterFunc(Initialize, "nn_ndm", "Initialize__Q2_2nn3ndmFv", LogType::Placeholder);
+			cafeExportRegisterFunc(Finalize, "nn_ndm", "Finalize__Q2_2nn3ndmFv", LogType::Placeholder);
+			cafeExportRegisterFunc(IsInitialized, "nn_ndm", "IsInitialized__Q2_2nn3ndmFv", LogType::Placeholder);
+			cafeExportRegisterFunc(GetDaemonStatus, "nn_ndm", "GetDaemonStatus__Q2_2nn3ndmFPQ4_2nn3ndm7IDaemon6StatusQ4_2nn3ndm4Cafe10DaemonName", LogType::Placeholder);
+			cafeExportRegisterFunc(SuspendDaemons, "nn_ndm", "SuspendDaemons__Q2_2nn3ndmFUi", LogType::Placeholder);
+			cafeExportRegisterFunc(ResumeDaemons, "nn_ndm", "ResumeDaemons__Q2_2nn3ndmFUi", LogType::Placeholder);
 		}
 	}
-}
\ No newline at end of file
+}
diff --git a/src/Cafe/OS/libs/nn_nfp/AmiiboCrypto.h b/src/Cafe/OS/libs/nn_nfp/AmiiboCrypto.h
index 1c918e1e..2d7bd7c5 100644
--- a/src/Cafe/OS/libs/nn_nfp/AmiiboCrypto.h
+++ b/src/Cafe/OS/libs/nn_nfp/AmiiboCrypto.h
@@ -214,9 +214,9 @@ void amiiboDecrypt()
 	bool isValidTagHMAC = memcmp(nfp_data.amiiboNFCData.tagHMAC, nfp_data.amiiboInternal.tagHMAC, 32) == 0;
 	bool isValidDataHMAC = memcmp(nfp_data.amiiboNFCData.dataHMAC, nfp_data.amiiboInternal.dataHMAC, 32) == 0;
 	if (!isValidTagHMAC)
-		forceLog_printf("Decrypt amiibo has invalid tag HMAC");
+		cemuLog_log(LogType::Force, "Decrypt amiibo has invalid tag HMAC");
 	if (!isValidDataHMAC)
-		forceLog_printf("Decrypt amiibo has invalid data HMAC");
+		cemuLog_log(LogType::Force, "Decrypt amiibo has invalid data HMAC");
 	nfp_data.hasInvalidHMAC = !isValidTagHMAC || !isValidDataHMAC;
 }
 
@@ -261,7 +261,7 @@ void amiiboEncrypt(AmiiboRawNFCData* nfcOutput)
 	amiiboCrypto_internalToNfcFormat(&internalCopy, nfcOutput);
 
 	// restore NFC values that aren't part of the internal representation
-	memcpy(nfcOutput->lockBytes, nfp_data.amiiboNFCData.lockBytes, 4);
+	memcpy(nfcOutput->dynamicLock, nfp_data.amiiboNFCData.dynamicLock, 4);
 	memcpy(nfcOutput->cfg0, nfp_data.amiiboNFCData.cfg0, 4);
 	memcpy(nfcOutput->cfg1, nfp_data.amiiboNFCData.cfg1, 4);
-}
\ No newline at end of file
+}
diff --git a/src/Cafe/OS/libs/nn_nfp/nn_nfp.cpp b/src/Cafe/OS/libs/nn_nfp/nn_nfp.cpp
index 0c567b5a..38e0c4fe 100644
--- a/src/Cafe/OS/libs/nn_nfp/nn_nfp.cpp
+++ b/src/Cafe/OS/libs/nn_nfp/nn_nfp.cpp
@@ -25,16 +25,20 @@ void nnNfpUnlock()
 
 struct AmiiboInternal
 {
-	/* +0x000 */ uint32 ukn000;
-	/* +0x004 */ uint32 ukn004;
+	/* +0x000 */ uint16 lockBytes;
+	/* +0x002 */ uint16 staticLock;
+	/* +0x004 */ uint32 cc;
 	/* +0x008 */ uint8 dataHMAC[32];
-	/* +0x028 */ uint32 ukn028;
+	/* +0x028 */ uint8 ukn_A5; // always 0xA5
+	/* +0x029 */ uint8 writeCounterHigh;
+	/* +0x029 */ uint8 writeCounterLow;
+	/* +0x02B */ uint8 unk02B;
 	/* encrypted region starts here */
-	struct  
+	struct
 	{
 		/* +0x02C */ uint8 flags;
 		/* +0x02D */ uint8 countryCode;
-		/* +0x02E */ uint16be writeCounter;
+		/* +0x02E */ uint16be crcWriteCounter;
 		/* +0x030 */ uint16be date1;
 		/* +0x032 */ uint16be date2;
 		/* +0x034 */ uint32be crc;
@@ -42,7 +46,7 @@ struct AmiiboInternal
 		/* +0x04C */ uint8 mii[0x60];
 		/* +0x0AC */ uint32be appDataTitleIdHigh;
 		/* +0x0B0 */ uint32be appDataTitleIdLow;
-		/* +0x0B4 */ uint16be writeCounter2;
+		/* +0x0B4 */ uint16be appWriteCounter;
 		/* +0x0B6 */ uint16be appDataIdHigh;
 		/* +0x0B8 */ uint16be appDataIdLow;
 		/* +0x0BA */ uint16be ukn0BA;
@@ -70,11 +74,19 @@ struct AmiiboInternal
 	/* +0x0DC */ uint8 applicationData[0xD8];
 	/* encrypted region ends here */
 	/* +0x1B4 */ uint8 tagHMAC[32];
-	/* +0x1D4 */ uint32 ukn1D4;
-	/* +0x1D8 */ uint32 ukn1D8;
-	/* +0x1DC */ uint32 ukn1DC;
-	/* +0x1E0 */ uint8 ukn1E0[0x20];
-	/* +0x200 */ uint8 ukn200[0x8];
+	/* +0x1D4 */ uint8 ntagSerial[7];
+	/* +0x1DB */ uint8 nintendoId;
+	struct
+	{
+		/* +0x1DC */ uint8 gameAndCharacterId[2];
+		/* +0x1DE */ uint8 characterVariation;
+		/* +0x1DF */ uint8 amiiboFigureType;
+		/* +0x1E0 */ uint8 amiiboModelNumber[2];
+		/* +0x1E2 */ uint8 amiiboSeries;
+		/* +0x1E3 */ uint8 ukn_02; // always 0x02 ?
+		/* +0x1E4 */ uint8 ukn5C[4];
+	}amiiboIdentificationBlock;
+	/* +0x1E8 */ uint8 keygenSalt[32];
 };
 
 static_assert(sizeof(AmiiboInternal) == 0x208);
@@ -87,7 +99,7 @@ static_assert(offsetof(AmiiboInternal, tagHMAC) == 0x1B4);
 union AmiiboRawNFCData
 {
 	// each page is 4 bytes
-	struct  
+	struct
 	{
 		uint8 page0[4];
 		uint8 page1[4];
@@ -107,21 +119,24 @@ union AmiiboRawNFCData
 		uint8 page15[4];
 		uint8 page16[4];
 	};
-	struct  
+	struct
 	{
-		uint8 rawByte[16*4];
+		uint8 rawByte[16 * 4];
 	};
-	struct  
+	struct
 	{
-		/*+0x000 */ uint8 ntagSerial[9];
-		/*+0x009 */ uint8 ukn009;
-		/*+0x00A */ uint8 lockBytes[2];
-		/*+0x00C */ uint8 cc[4];
-		/*+0x010 */ uint8 ukn010[4];
-		/*+0x014 */ uint8 ukn014[32]; // crypto related?
-		/*+0x034 */ uint8 tagHMAC[32]; // data hmac
-		/*+0x054 */ 
-		struct  
+		/* +0x000 */ uint8 ntagSerial[7];
+		/* +0x007 */ uint8 nintendoId;
+		/* +0x008 */ uint8 lockBytes[2];
+		/* +0x00A */ uint8 staticLock[2];
+		/* +0x00C */ uint8 cc[4]; // compatibility container
+		/* +0x010 */ uint8 ukn_A5; // always 0xA5
+		/* +0x011 */ uint8 writeCounter[2];
+		/* +0x013 */ uint8 unk013;
+		/* +0x014 */ uint8 encryptedSettings[32];
+		/* +0x034 */ uint8 tagHMAC[32]; // data hmac
+		/* +0x054 */
+		struct
 		{
 			/* +0x54 */ uint8 gameAndCharacterId[2];
 			/* +0x56 */ uint8 characterVariation;
@@ -129,15 +144,20 @@ union AmiiboRawNFCData
 			/* +0x58 */ uint8 amiiboModelNumber[2];
 			/* +0x5A */ uint8 amiiboSeries;
 			/* +0x5B */ uint8 ukn_02; // always 0x02 ?
-
-			/* +0x5C */ uint8 ukn00[0x80-0x5C]; // not part of identification block?
+			/* +0x5C */ uint8 ukn5C[4];
 		}amiiboIdentificationBlock;
-		/*+0x080 */ uint8 dataHMAC[32];
-		/*+0x0A0 */ uint8 ukn0A0[0x114];
-		/*+0x1B4 */ uint8 ukn1B4[0x54];
-		/*+0x208 */ uint8 lockBytes208[4];
-		/*+0x20C */ uint8 cfg0[4];
-		/*+0x210 */ uint8 cfg1[4];
+		/* +0x060 */ uint8 keygenSalt[32];
+		/* +0x080 */ uint8 dataHMAC[32];
+		/* +0x0A0 */ uint8 encryptedMii[0x60];
+		/* +0x100 */ uint8 encryptedTitleId[8];
+		/* +0x108 */ uint8 encryptedApplicationWriteCounter[2];
+		/* +0x10A */ uint8 encryptedApplicationAreaId[4];
+		/* +0x10E */ uint8 ukn10E[2];
+		/* +0x110 */ uint8 unk110[32];
+		/* +0x130 */ uint8 encryptedApplicationArea[0xD8];
+		/* +0x208 */ uint8 dynamicLock[4];
+		/* +0x20C */ uint8 cfg0[4];
+		/* +0x210 */ uint8 cfg1[4];
 	};
 };
 
@@ -160,7 +180,7 @@ struct
 	bool hasOpenApplicationArea; // set to true if application area was opened or created
 	// currently active Amiibo
 	bool hasActiveAmiibo;
-	std::wstring amiiboPath;
+	fs::path amiiboPath;
 	bool hasInvalidHMAC;
 	uint32 amiiboTouchTime;
 	AmiiboRawNFCData amiiboNFCData; // raw data
@@ -168,7 +188,6 @@ struct
 	AmiiboProcessedData amiiboProcessedData;
 }nfp_data = { 0 };
 
-bool nnNfp_touchNfcTagFromFile(const wchar_t* filePath, uint32* nfcError);
 bool nnNfp_writeCurrentAmiibo();
 
 #include "AmiiboCrypto.h"
@@ -196,7 +215,7 @@ void nnNfpExport_SetDeactivateEvent(PPCInterpreter_t* hCPU)
 	ppcDefineParamStructPtr(osEvent, coreinit::OSEvent, 0);
 	ppcDefineParamMPTR(osEventMPTR, 0);
 
-	nfpLog_printf("SetDeactivateEvent(0x%08x)", osEventMPTR);
+	cemuLog_log(LogType::NN_NFP, "SetDeactivateEvent(0x{:08x})", osEventMPTR);
 
 	coreinit::OSInitEvent(osEvent, coreinit::OSEvent::EVENT_STATE::STATE_NOT_SIGNALED, coreinit::OSEvent::EVENT_MODE::MODE_AUTO);
 
@@ -221,7 +240,7 @@ void nnNfpExport_Initialize(PPCInterpreter_t* hCPU)
 
 void nnNfpExport_StartDetection(PPCInterpreter_t* hCPU)
 {
-	nfpLog_printf("StartDetection()");
+	cemuLog_log(LogType::NN_NFP, "StartDetection()");
 	nnNfpLock();
 	nfp_data.isDetecting = true;
 	nnNfpUnlock();
@@ -230,7 +249,7 @@ void nnNfpExport_StartDetection(PPCInterpreter_t* hCPU)
 
 void nnNfpExport_StopDetection(PPCInterpreter_t* hCPU)
 {
-	nfpLog_printf("StopDetection()");
+	cemuLog_log(LogType::NN_NFP, "StopDetection()");
 	nnNfpLock();
 	nfp_data.isDetecting = false;
 	nnNfpUnlock();
@@ -254,7 +273,7 @@ static_assert(sizeof(nfpTagInfo_t) == 0x54, "nfpTagInfo_t has invalid size");
 
 void nnNfpExport_GetTagInfo(PPCInterpreter_t* hCPU)
 {
-	nfpLog_printf("GetTagInfo(0x%08x)", hCPU->gpr[3]);
+	cemuLog_log(LogType::NN_NFP, "GetTagInfo(0x{:08x})", hCPU->gpr[3]);
 	ppcDefineParamStructPtr(tagInfo, nfpTagInfo_t, 0);
 
 	nnNfpLock();
@@ -274,44 +293,9 @@ void nnNfpExport_GetTagInfo(PPCInterpreter_t* hCPU)
 	osLib_returnFromFunction(hCPU, BUILD_NN_RESULT(NN_RESULT_LEVEL_SUCCESS, NN_RESULT_MODULE_NN_NFP, 0));
 }
 
-typedef struct  
-{
-	/* +0x00 */ uint8 uidLength;
-	/* +0x01 */ uint8 uid[0xA];
-	/* +0x0B */ uint8 ukn0B;
-	/* +0x0C */ uint8 ukn0C;
-	/* +0x0D */ uint8 ukn0D;
-	// more?
-}NFCTagInfoCallbackParam_t;
-
-uint32 NFCGetTagInfo(uint32 index, uint32 timeout, MPTR functionPtr, void* userParam)
-{
-	nfpLog_printf("NFCGetTagInfo(%d,%d,0x%08x,0x%08x)", index, timeout, functionPtr, userParam?memory_getVirtualOffsetFromPointer(userParam):0);
-
-
-	cemu_assert(index == 0);
-
-	nnNfpLock();
-
-	StackAllocator<NFCTagInfoCallbackParam_t> _callbackParam;
-	NFCTagInfoCallbackParam_t* callbackParam = _callbackParam.GetPointer();
-
-	memset(callbackParam, 0x00, sizeof(NFCTagInfoCallbackParam_t));
-
-	memcpy(callbackParam->uid, nfp_data.amiiboProcessedData.uid, nfp_data.amiiboProcessedData.uidLength);
-	callbackParam->uidLength = (uint8)nfp_data.amiiboProcessedData.uidLength;
-
-	PPCCoreCallback(functionPtr, index, 0, _callbackParam.GetPointer(), userParam);
-
-	nnNfpUnlock();
-
-
-	return 0; // 0 -> success
-}
-
 void nnNfpExport_Mount(PPCInterpreter_t* hCPU)
 {
-	nfpLog_printf("Mount()");
+	cemuLog_log(LogType::NN_NFP, "Mount()");
 	nnNfpLock();
 	if (nfp_data.hasActiveAmiibo == false)
 	{
@@ -328,14 +312,14 @@ void nnNfpExport_Mount(PPCInterpreter_t* hCPU)
 
 void nnNfpExport_Unmount(PPCInterpreter_t* hCPU)
 {
-	nfpLog_printf("Unmount()");
+	cemuLog_log(LogType::NN_NFP, "Unmount()");
 	nfp_data.hasOpenApplicationArea = false;
 	osLib_returnFromFunction(hCPU, BUILD_NN_RESULT(NN_RESULT_LEVEL_SUCCESS, NN_RESULT_MODULE_NN_NFP, 0));
 }
 
 void nnNfpExport_MountRom(PPCInterpreter_t* hCPU)
 {
-	nfpLog_printf("MountRom()");
+	cemuLog_log(LogType::NN_NFP, "MountRom()");
 	nnNfpLock();
 	if (nfp_data.hasActiveAmiibo == false)
 	{
@@ -350,45 +334,63 @@ void nnNfpExport_MountRom(PPCInterpreter_t* hCPU)
 	osLib_returnFromFunction(hCPU, BUILD_NN_RESULT(NN_RESULT_LEVEL_SUCCESS, NN_RESULT_MODULE_NN_NFP, 0));
 }
 
-typedef struct
+namespace nn::nfp
 {
-	/* +0x00 */ uint8 characterId[3];
-	/* +0x03 */ uint8 amiiboSeries;
-	/* +0x04 */ uint16be number;
-	/* +0x06 */ uint8 nfpType;
-	/* +0x07 */ uint8 unused[0x2F];
-}nfpRomInfo_t;
-
-static_assert(offsetof(nfpRomInfo_t, amiiboSeries) == 0x3, "nfpRomInfo.seriesId has invalid offset");
-static_assert(offsetof(nfpRomInfo_t, number) == 0x4, "nfpRomInfo.number has invalid offset");
-static_assert(offsetof(nfpRomInfo_t, nfpType) == 0x6, "nfpRomInfo.nfpType has invalid offset");
-static_assert(sizeof(nfpRomInfo_t) == 0x36, "nfpRomInfo_t has invalid size");
-
-void nnNfpExport_GetNfpRomInfo(PPCInterpreter_t* hCPU)
-{
-	nfpLog_printf("GetNfpRomInfo(0x%08x)", hCPU->gpr[3]);
-	ppcDefineParamStructPtr(romInfo, nfpRomInfo_t, 0);
-
-	nnNfpLock();
-	if (nfp_data.hasActiveAmiibo == false)
+	struct RomInfo
 	{
-		nnNfpUnlock();
-		osLib_returnFromFunction(hCPU, BUILD_NN_RESULT(NN_RESULT_LEVEL_STATUS, NN_RESULT_MODULE_NN_NFP, 0)); // todo: Return correct error code
-		return;
+		/* +0x00 */ uint8 characterId[3];
+		/* +0x03 */ uint8 amiiboSeries;
+		/* +0x04 */ uint16be number;
+		/* +0x06 */ uint8 nfpType;
+		/* +0x07 */ uint8 unused[0x2F];
+	};
+
+	static_assert(offsetof(RomInfo, amiiboSeries) == 0x3);
+	static_assert(offsetof(RomInfo, number) == 0x4);
+	static_assert(offsetof(RomInfo, nfpType) == 0x6);
+	static_assert(sizeof(RomInfo) == 0x36);
+
+	using ReadOnlyInfo = RomInfo; // same layout
+
+	void GetRomInfo(RomInfo* romInfo)
+	{
+		cemu_assert_debug(nfp_data.hasActiveAmiibo);
+		memset(romInfo, 0x00, sizeof(RomInfo));
+		romInfo->characterId[0] = nfp_data.amiiboNFCData.amiiboIdentificationBlock.gameAndCharacterId[0];
+		romInfo->characterId[1] = nfp_data.amiiboNFCData.amiiboIdentificationBlock.gameAndCharacterId[1];
+		romInfo->characterId[2] = nfp_data.amiiboNFCData.amiiboIdentificationBlock.characterVariation; // guessed
+		romInfo->amiiboSeries = nfp_data.amiiboNFCData.amiiboIdentificationBlock.amiiboSeries; // guessed
+		romInfo->number = *(uint16be*)nfp_data.amiiboNFCData.amiiboIdentificationBlock.amiiboModelNumber; // guessed
+		romInfo->nfpType = nfp_data.amiiboNFCData.amiiboIdentificationBlock.amiiboFigureType; // guessed
+		memset(romInfo->unused, 0x00, sizeof(romInfo->unused));
 	}
-	memset(romInfo, 0x00, sizeof(nfpRomInfo_t));
 
-	romInfo->characterId[0] = nfp_data.amiiboNFCData.amiiboIdentificationBlock.gameAndCharacterId[0];
-	romInfo->characterId[1] = nfp_data.amiiboNFCData.amiiboIdentificationBlock.gameAndCharacterId[1];
-	romInfo->characterId[2] = nfp_data.amiiboNFCData.amiiboIdentificationBlock.characterVariation; // guessed
+	nnResult GetNfpRomInfo(RomInfo* romInfo)
+	{
+		nnNfpLock();
+		if (nfp_data.hasActiveAmiibo == false)
+		{
+			nnNfpUnlock();
+			return BUILD_NN_RESULT(NN_RESULT_LEVEL_STATUS, NN_RESULT_MODULE_NN_NFP, 0); // todo: Return correct error code
+		}
+		GetRomInfo(romInfo);
+		nnNfpUnlock();
+		return BUILD_NN_RESULT(NN_RESULT_LEVEL_SUCCESS, NN_RESULT_MODULE_NN_NFP, 0);
+	}
 
-	romInfo->amiiboSeries = nfp_data.amiiboNFCData.amiiboIdentificationBlock.amiiboSeries; // guessed
-	romInfo->number = *(uint16be*)nfp_data.amiiboNFCData.amiiboIdentificationBlock.amiiboModelNumber; // guessed
-	romInfo->nfpType = nfp_data.amiiboNFCData.amiiboIdentificationBlock.amiiboFigureType; // guessed
-
-	nnNfpUnlock();
-	osLib_returnFromFunction(hCPU, BUILD_NN_RESULT(NN_RESULT_LEVEL_SUCCESS, NN_RESULT_MODULE_NN_NFP, 0));
-}
+	nnResult GetNfpReadOnlyInfo(ReadOnlyInfo* readOnlyInfo)
+	{
+		nnNfpLock();
+		if (nfp_data.hasActiveAmiibo == false)
+		{
+			nnNfpUnlock();
+			return BUILD_NN_RESULT(NN_RESULT_LEVEL_STATUS, NN_RESULT_MODULE_NN_NFP, 0); // todo: Return correct error code
+		}
+		GetRomInfo(readOnlyInfo);
+		nnNfpUnlock();
+		return BUILD_NN_RESULT(NN_RESULT_LEVEL_SUCCESS, NN_RESULT_MODULE_NN_NFP, 0);
+	}
+};
 
 typedef struct  
 {
@@ -400,7 +402,7 @@ typedef struct
 typedef struct  
 {
 	/* +0x00 */ nfpDate_t date;
-	/* +0x04 */ uint16be writeCount;
+	/* +0x04 */ uint8 writeCount[2];
 	/* +0x06 */ uint8 characterId[3];
 	/* +0x09 */ uint8 amiiboSeries;
 	/* +0x0A */ uint16be number;
@@ -418,7 +420,7 @@ static_assert(offsetof(nfpCommonData_t, applicationAreaSize) == 0xE, "nfpCommonD
 
 void nnNfpExport_GetNfpCommonInfo(PPCInterpreter_t* hCPU)
 {
-	nfpLog_printf("GetNfpCommonInfo(0x%08x)", hCPU->gpr[3]);
+	cemuLog_log(LogType::NN_NFP, "GetNfpCommonInfo(0x{:08x})", hCPU->gpr[3]);
 	ppcDefineParamStructPtr(commonInfo, nfpCommonData_t, 0);
 
 	nnNfpLock();
@@ -433,7 +435,10 @@ void nnNfpExport_GetNfpCommonInfo(PPCInterpreter_t* hCPU)
 		assert_dbg();
 	memset(commonInfo, 0x00, sizeof(nfpCommonData_t));
 
-	forceLogDebug_printf("GetNfpCommonInfo(0x%08x)");
+	cemuLog_logDebug(LogType::Force, "GetNfpCommonInfo(0x{:08x})");
+
+	commonInfo->writeCount[0] = nfp_data.amiiboNFCData.writeCounter[0];
+	commonInfo->writeCount[1] = nfp_data.amiiboNFCData.writeCounter[1];
 
 	commonInfo->characterId[0] = nfp_data.amiiboNFCData.amiiboIdentificationBlock.gameAndCharacterId[0];
 	commonInfo->characterId[1] = nfp_data.amiiboNFCData.amiiboIdentificationBlock.gameAndCharacterId[1];
@@ -469,7 +474,7 @@ typedef struct
 
 void nnNfpExport_GetNfpRegisterInfo(PPCInterpreter_t* hCPU)
 {
-	nfpLog_printf("GetNfpRegisterInfo(0x%08x)", hCPU->gpr[3]);
+	cemuLog_log(LogType::NN_NFP, "GetNfpRegisterInfo(0x{:08x})", hCPU->gpr[3]);
 	ppcDefineParamStructPtr(registerInfo, nfpRegisterInfo_t, 0);
 
 	if(!registerInfo)
@@ -492,7 +497,7 @@ void nnNfpExport_GetNfpRegisterInfo(PPCInterpreter_t* hCPU)
 
 void nnNfpExport_InitializeRegisterInfoSet(PPCInterpreter_t* hCPU)
 {
-	nfpLog_printf("InitializeRegisterInfoSet(0x%08x)", hCPU->gpr[3]);
+	cemuLog_log(LogType::NN_NFP, "InitializeRegisterInfoSet(0x{:08x})", hCPU->gpr[3]);
 	ppcDefineParamStructPtr(registerInfoSet, nfpRegisterInfoSet_t, 0);
 
 	memset(registerInfoSet, 0, sizeof(nfpRegisterInfoSet_t));
@@ -502,7 +507,7 @@ void nnNfpExport_InitializeRegisterInfoSet(PPCInterpreter_t* hCPU)
 
 void nnNfpExport_SetNfpRegisterInfo(PPCInterpreter_t* hCPU)
 {
-	nfpLog_printf("SetNfpRegisterInfo(0x%08x)", hCPU->gpr[3]);
+	cemuLog_log(LogType::NN_NFP, "SetNfpRegisterInfo(0x{:08x})", hCPU->gpr[3]);
 	ppcDefineParamStructPtr(registerInfoSet, nfpRegisterInfoSet_t, 0);
 
 	memcpy(nfp_data.amiiboInternal.amiiboSettings.mii, registerInfoSet->ownerMii, sizeof(nfp_data.amiiboInternal.amiiboSettings.mii));
@@ -515,7 +520,7 @@ void nnNfpExport_SetNfpRegisterInfo(PPCInterpreter_t* hCPU)
 
 void nnNfpExport_IsExistApplicationArea(PPCInterpreter_t* hCPU)
 {
-	nfpLog_printf("IsExistApplicationArea()");
+	cemuLog_log(LogType::NN_NFP, "IsExistApplicationArea()");
 	if (!nfp_data.hasActiveAmiibo || !nfp_data.isMounted)
 	{
 		osLib_returnFromFunction(hCPU, 0);
@@ -527,7 +532,7 @@ void nnNfpExport_IsExistApplicationArea(PPCInterpreter_t* hCPU)
 
 void nnNfpExport_OpenApplicationArea(PPCInterpreter_t* hCPU)
 {
-	nfpLog_printf("OpenApplicationArea(0x%08x)", hCPU->gpr[3]);
+	cemuLog_log(LogType::NN_NFP, "OpenApplicationArea(0x{:08x})", hCPU->gpr[3]);
 	ppcDefineParamU32(appAreaId, 0);
 
 	// note - this API doesn't fail if the application area has already been opened?
@@ -552,7 +557,7 @@ void nnNfpExport_OpenApplicationArea(PPCInterpreter_t* hCPU)
 
 void nnNfpExport_ReadApplicationArea(PPCInterpreter_t* hCPU)
 {
-	nfpLog_printf("ReadApplicationArea(0x%08x, 0x%x)", hCPU->gpr[3], hCPU->gpr[4]);
+	cemuLog_log(LogType::NN_NFP, "ReadApplicationArea(0x{:08x}, 0x{:x})", hCPU->gpr[3], hCPU->gpr[4]);
 	ppcDefineParamPtr(bufferPtr, uint8*, 0);
 	ppcDefineParamU32(len, 1);
 
@@ -569,7 +574,7 @@ void nnNfpExport_ReadApplicationArea(PPCInterpreter_t* hCPU)
 
 void nnNfpExport_WriteApplicationArea(PPCInterpreter_t* hCPU)
 {
-	nfpLog_printf("WriteApplicationArea(0x%08x, 0x%x, 0x%08x)", hCPU->gpr[3], hCPU->gpr[4], hCPU->gpr[5]);
+	cemuLog_log(LogType::NN_NFP, "WriteApplicationArea(0x{:08x}, 0x{:x}, 0x{:08x})", hCPU->gpr[3], hCPU->gpr[4], hCPU->gpr[5]);
 	ppcDefineParamPtr(bufferPtr, uint8*, 0);
 	ppcDefineParamU32(len, 1);
 	
@@ -590,6 +595,8 @@ void nnNfpExport_WriteApplicationArea(PPCInterpreter_t* hCPU)
 	for (uint32 i = len; i < sizeof(nfp_data.amiiboInternal.applicationData); i++)
 		nfp_data.amiiboInternal.applicationData[i] = rand() & 0xFF;
 
+	nfp_data.amiiboInternal.amiiboSettings.appWriteCounter = nfp_data.amiiboInternal.amiiboSettings.appWriteCounter + 1;
+
 	osLib_returnFromFunction(hCPU, BUILD_NN_RESULT(NN_RESULT_LEVEL_SUCCESS, NN_RESULT_MODULE_NN_NFP, 0));
 }
 
@@ -603,7 +610,7 @@ typedef struct
 
 void nnNfpExport_CreateApplicationArea(PPCInterpreter_t* hCPU)
 {
-	nfpLog_printf("CreateApplicationArea(0x%08x)", hCPU->gpr[3]);
+	cemuLog_log(LogType::NN_NFP, "CreateApplicationArea(0x{:08x})", hCPU->gpr[3]);
 	ppcDefineParamPtr(createInfo, NfpCreateInfo_t, 0);
 
 	if (nfp_data.hasOpenApplicationArea || (nfp_data.amiiboInternal.amiiboSettings.flags&0x20))
@@ -629,6 +636,7 @@ void nnNfpExport_CreateApplicationArea(PPCInterpreter_t* hCPU)
 
 	nfp_data.amiiboInternal.amiiboSettings.setAppDataAppId(createInfo->appAreaId);
 	nfp_data.amiiboInternal.amiiboSettings.flags |= 0x20; // set application data exists bit
+	nfp_data.amiiboInternal.amiiboSettings.appWriteCounter = nfp_data.amiiboInternal.amiiboSettings.appWriteCounter + 1;
 
 	nfp_data.hasOpenApplicationArea = false;
 
@@ -641,7 +649,7 @@ void nnNfpExport_CreateApplicationArea(PPCInterpreter_t* hCPU)
 	// this API forces a flush (unsure, but without this data written by Smash doesn't stick)
 	if (!nnNfp_writeCurrentAmiibo())
 	{
-		forceLog_printf("Failed to write Amiibo file data when trying to remove appArea");
+		cemuLog_log(LogType::Force, "Failed to write Amiibo file data when trying to remove appArea");
 		osLib_returnFromFunction(hCPU, BUILD_NN_RESULT(NN_RESULT_LEVEL_STATUS, NN_RESULT_MODULE_NN_NFP, 0));
 		return;
 	}
@@ -651,7 +659,7 @@ void nnNfpExport_CreateApplicationArea(PPCInterpreter_t* hCPU)
 
 void nnNfpExport_DeleteApplicationArea(PPCInterpreter_t* hCPU)
 {
-	nfpLog_printf("DeleteApplicationArea()");
+	cemuLog_log(LogType::NN_NFP, "DeleteApplicationArea()");
 
 	if (nfp_data.isReadOnly)
 	{
@@ -666,11 +674,12 @@ void nnNfpExport_DeleteApplicationArea(PPCInterpreter_t* hCPU)
 
 	nfp_data.amiiboInternal.amiiboSettings.setAppDataAppId(0);
 	nfp_data.amiiboInternal.amiiboSettings.flags &= ~0x20;
+	nfp_data.amiiboInternal.amiiboSettings.appWriteCounter = nfp_data.amiiboInternal.amiiboSettings.appWriteCounter + 1;
 
 	// this API forces a flush
 	if (!nnNfp_writeCurrentAmiibo())
 	{
-		forceLog_printf("Failed to write Amiibo file data when trying to remove appArea");
+		cemuLog_log(LogType::Force, "Failed to write Amiibo file data when trying to remove appArea");
 		osLib_returnFromFunction(hCPU, BUILD_NN_RESULT(NN_RESULT_LEVEL_STATUS, NN_RESULT_MODULE_NN_NFP, 0));
 		return;
 	}
@@ -680,19 +689,19 @@ void nnNfpExport_DeleteApplicationArea(PPCInterpreter_t* hCPU)
 
 void nnNfpExport_Flush(PPCInterpreter_t* hCPU)
 {
-	nfpLog_printf("Flush()");
+	cemuLog_log(LogType::NN_NFP, "Flush()");
 
 	// write Amiibo data
 	if (nfp_data.isReadOnly) 
 	{
-		forceLog_printf("Cannot write to Amiibo when it is mounted in read-only mode");
+		cemuLog_log(LogType::Force, "Cannot write to Amiibo when it is mounted in read-only mode");
 		osLib_returnFromFunction(hCPU, BUILD_NN_RESULT(NN_RESULT_LEVEL_STATUS, NN_RESULT_MODULE_NN_NFP, 0));
 		return;
 	}
 
 	if (!nnNfp_writeCurrentAmiibo())
 	{
-		forceLog_printf("Failed to write Amiibo data");
+		cemuLog_log(LogType::Force, "Failed to write Amiibo data");
 		osLib_returnFromFunction(hCPU, BUILD_NN_RESULT(NN_RESULT_LEVEL_STATUS, NN_RESULT_MODULE_NN_NFP, 0));
 		return;
 	}
@@ -721,7 +730,7 @@ static_assert(offsetof(AmiiboSettingsArgs_t, commonInfo) == 0x114);
 
 void nnNfpExport_GetAmiiboSettingsArgs(PPCInterpreter_t* hCPU)
 {
-	nfpLog_printf("GetAmiiboSettingsArgs(0x%08x)", hCPU->gpr[3]);
+	cemuLog_log(LogType::NN_NFP, "GetAmiiboSettingsArgs(0x{:08x})", hCPU->gpr[3]);
 	ppcDefineParamStructPtr(settingsArg, AmiiboSettingsArgs_t, 0);
 
 	memset(settingsArg, 0, sizeof(AmiiboSettingsArgs_t));
@@ -743,7 +752,17 @@ void nnNfp_unloadAmiibo()
 	nnNfpUnlock();
 }
 
-bool nnNfp_touchNfcTagFromFile(const wchar_t* filePath, uint32* nfcError)
+bool nnNfp_isInitialized()
+{
+	return nfp_data.nfpIsInitialized;
+}
+
+// CEMU NFC error codes
+#define NFC_ERROR_NONE					(0)
+#define NFC_ERROR_NO_ACCESS				(1)
+#define NFC_ERROR_INVALID_FILE_FORMAT	(2)
+
+bool nnNfp_touchNfcTagFromFile(const fs::path& filePath, uint32* nfcError)
 {
 	AmiiboRawNFCData rawData = { 0 };
 	auto nfcData = FileStream::LoadIntoMemory(filePath);
@@ -760,6 +779,17 @@ bool nnNfp_touchNfcTagFromFile(const wchar_t* filePath, uint32* nfcError)
 	memcpy(&rawData, nfcData->data(), sizeof(AmiiboRawNFCData));
 
 	// verify if the file is a valid ntag215/amiibo file
+	if (rawData.dynamicLock[0] != 0x01 || rawData.dynamicLock[1] != 0x00 || rawData.dynamicLock[2] != 0x0F || rawData.dynamicLock[3] != 0xBD)
+	{
+		// Temporary workaround to fix corrupted files by old cemu versions
+		rawData.dynamicLock[0] = 0x01;
+		rawData.dynamicLock[1] = 0x00;
+		rawData.dynamicLock[2] = 0x0F;
+		rawData.dynamicLock[3] = 0xBD;
+
+		// *nfcError = NFC_ERROR_INVALID_FILE_FORMAT;
+		// return false;
+	}
 	if (rawData.cfg0[0] != 0x00 || rawData.cfg0[1] != 0x00 || rawData.cfg0[2] != 0x00 || rawData.cfg0[3] != 0x04)
 	{
 		*nfcError = NFC_ERROR_INVALID_FILE_FORMAT;
@@ -770,7 +800,7 @@ bool nnNfp_touchNfcTagFromFile(const wchar_t* filePath, uint32* nfcError)
 		*nfcError = NFC_ERROR_INVALID_FILE_FORMAT;
 		return false;
 	}
-	if (rawData.lockBytes[0] != 0x0F || rawData.lockBytes[1] != 0xE0 )
+	if (rawData.staticLock[0] != 0x0F || rawData.staticLock[1] != 0xE0)
 	{
 		*nfcError = NFC_ERROR_INVALID_FILE_FORMAT;
 		return false;
@@ -789,17 +819,17 @@ bool nnNfp_touchNfcTagFromFile(const wchar_t* filePath, uint32* nfcError)
 	serialNumber[3] = rawData.ntagSerial[4];
 	serialNumber[4] = rawData.ntagSerial[5];
 	serialNumber[5] = rawData.ntagSerial[6];
-	serialNumber[6] = rawData.ntagSerial[7];
+	serialNumber[6] = rawData.nintendoId;
 
 	uint8 serialCheckByte0 = rawData.ntagSerial[3];
-	uint8 serialCheckByte1 = rawData.ntagSerial[8];
+	uint8 serialCheckByte1 = rawData.lockBytes[0];
 
 	uint8 bcc0 = serialNumber[0] ^ serialNumber[1] ^ serialNumber[2] ^ 0x88;
 	uint8 bcc1 = serialNumber[3] ^ serialNumber[4] ^ serialNumber[5] ^ serialNumber[6];
 
 	if (serialCheckByte0 != bcc0 || serialCheckByte1 != bcc1)
 	{
-		forceLog_printf("nn_nfp: Mismatch in serial checksum of scanned NFC tag");
+		cemuLog_log(LogType::Force, "nn_nfp: Mismatch in serial checksum of scanned NFC tag");
 	}
 	nfp_data.amiiboProcessedData.uidLength = 7;
 	memcpy(nfp_data.amiiboProcessedData.uid, serialNumber, 7);
@@ -809,11 +839,11 @@ bool nnNfp_touchNfcTagFromFile(const wchar_t* filePath, uint32* nfcError)
 	memcpy(&nfp_data.amiiboNFCData, &rawData, sizeof(AmiiboRawNFCData));
 	// decrypt amiibo
 	amiiboDecrypt();
-	nfp_data.amiiboPath = std::wstring(filePath);
+	nfp_data.amiiboPath = filePath;
 	nfp_data.hasActiveAmiibo = true;
 	if (nfp_data.activateEvent)
 	{
-		coreinit::OSEvent* osEvent = (coreinit::OSEvent*)memory_getPointerFromVirtualOffset(nfp_data.activateEvent);
+		MEMPTR<coreinit::OSEvent> osEvent(nfp_data.activateEvent);
 		coreinit::OSSignalEvent(osEvent);
 	}
 	nfp_data.amiiboTouchTime = GetTickCount();
@@ -830,6 +860,12 @@ bool nnNfp_writeCurrentAmiibo()
 		nnNfpUnlock();
 		return false;
 	}
+
+	uint16 writeCounter = nfp_data.amiiboInternal.writeCounterLow + (nfp_data.amiiboInternal.writeCounterHigh << 8);
+	writeCounter++;
+	nfp_data.amiiboInternal.writeCounterLow = writeCounter & 0xFF;
+	nfp_data.amiiboInternal.writeCounterHigh = (writeCounter >> 8) & 0xFF;
+
 	// open file for writing
 	FileStream* fs = FileStream::openFile2(nfp_data.amiiboPath, true);
 	if (!fs)
@@ -862,18 +898,18 @@ void nnNfp_update()
 	if (amiiboElapsedTouchTime >= 1500)
 	{
 		nnNfp_unloadAmiibo();
+		if (nfp_data.deactivateEvent)
+		{
+			coreinit::OSEvent* osEvent = (coreinit::OSEvent*)memory_getPointerFromVirtualOffset(nfp_data.deactivateEvent);
+			coreinit::OSSignalEvent(osEvent);
+		}
 	}
 	nnNfpUnlock();
-	if (nfp_data.deactivateEvent)
-	{
-		coreinit::OSEvent* osEvent = (coreinit::OSEvent*)memory_getPointerFromVirtualOffset(nfp_data.deactivateEvent);
-		coreinit::OSSignalEvent(osEvent);
-	}
 }
 
 void nnNfpExport_GetNfpState(PPCInterpreter_t* hCPU)
 {
-	nfpLog_printf("GetNfpState()");
+	cemuLog_log(LogType::NN_NFP, "GetNfpState()");
 
 	// workaround for Mario Party 10 eating CPU cycles in an infinite loop (maybe due to incorrect NFP detection handling?)
 	uint64 titleId = CafeSystem::GetForegroundTitleId();
@@ -917,6 +953,41 @@ void nnNfpExport_GetNfpState(PPCInterpreter_t* hCPU)
 
 namespace nn::nfp
 {
+	typedef struct  
+	{
+		/* +0x00 */ uint8 uidLength;
+		/* +0x01 */ uint8 uid[0xA];
+		/* +0x0B */ uint8 ukn0B;
+		/* +0x0C */ uint8 ukn0C;
+		/* +0x0D */ uint8 ukn0D;
+		// more?
+	}NFCTagInfoCallbackParam_t;
+
+	uint32 NFCGetTagInfo(uint32 index, uint32 timeout, MPTR functionPtr, void* userParam)
+	{
+		cemuLog_log(LogType::NN_NFP, "NFCGetTagInfo({},{},0x{:08x},0x{:08x})", index, timeout, functionPtr, userParam ? memory_getVirtualOffsetFromPointer(userParam) : 0);
+
+
+		cemu_assert(index == 0);
+
+		nnNfpLock();
+
+		StackAllocator<NFCTagInfoCallbackParam_t> _callbackParam;
+		NFCTagInfoCallbackParam_t* callbackParam = _callbackParam.GetPointer();
+
+		memset(callbackParam, 0x00, sizeof(NFCTagInfoCallbackParam_t));
+
+		memcpy(callbackParam->uid, nfp_data.amiiboProcessedData.uid, nfp_data.amiiboProcessedData.uidLength);
+		callbackParam->uidLength = (uint8)nfp_data.amiiboProcessedData.uidLength;
+
+		PPCCoreCallback(functionPtr, index, 0, _callbackParam.GetPointer(), userParam);
+
+		nnNfpUnlock();
+
+
+		return 0; // 0 -> success
+	}
+
 	uint32 GetErrorCode(uint32 result)
 	{
 		uint32 level = (result >> 0x1b) & 3;
@@ -948,8 +1019,6 @@ namespace nn::nfp
 		osLib_addFunction("nn_nfp", "Mount__Q2_2nn3nfpFv", nnNfpExport_Mount);
 		osLib_addFunction("nn_nfp", "MountRom__Q2_2nn3nfpFv", nnNfpExport_MountRom);
 		osLib_addFunction("nn_nfp", "Unmount__Q2_2nn3nfpFv", nnNfpExport_Unmount);
-
-		osLib_addFunction("nn_nfp", "GetNfpRomInfo__Q2_2nn3nfpFPQ3_2nn3nfp7RomInfo", nnNfpExport_GetNfpRomInfo);
 		osLib_addFunction("nn_nfp", "GetNfpCommonInfo__Q2_2nn3nfpFPQ3_2nn3nfp10CommonInfo", nnNfpExport_GetNfpCommonInfo);
 		osLib_addFunction("nn_nfp", "GetNfpRegisterInfo__Q2_2nn3nfpFPQ3_2nn3nfp12RegisterInfo", nnNfpExport_GetNfpRegisterInfo);
 
@@ -975,10 +1044,9 @@ namespace nn::nfp
 	{
 		nnNfp_load(); // legacy interface, update these to use cafeExportRegister / cafeExportRegisterFunc
 
-		cafeExportRegisterFunc(nn::nfp::GetErrorCode, "nn_nfp", "GetErrorCode__Q2_2nn3nfpFRCQ2_2nn6Result", LogType::Placeholder);
-
-		// NFC API 
-		cafeExportRegister("nn_nfp", NFCGetTagInfo, LogType::Placeholder);
+		cafeExportRegisterFunc(nn::nfp::GetErrorCode, "nn_nfp", "GetErrorCode__Q2_2nn3nfpFRCQ2_2nn6Result", LogType::NN_NFP);
+		cafeExportRegisterFunc(nn::nfp::GetNfpRomInfo, "nn_nfp", "GetNfpRomInfo__Q2_2nn3nfpFPQ3_2nn3nfp7RomInfo", LogType::NN_NFP);
+		cafeExportRegisterFunc(nn::nfp::GetNfpReadOnlyInfo, "nn_nfp", "GetNfpReadOnlyInfo__Q2_2nn3nfpFPQ3_2nn3nfp12ReadOnlyInfo", LogType::NN_NFP);
 	}
 
 }
diff --git a/src/Cafe/OS/libs/nn_nfp/nn_nfp.h b/src/Cafe/OS/libs/nn_nfp/nn_nfp.h
index 793b3bc3..25b36cc9 100644
--- a/src/Cafe/OS/libs/nn_nfp/nn_nfp.h
+++ b/src/Cafe/OS/libs/nn_nfp/nn_nfp.h
@@ -2,13 +2,16 @@
 
 namespace nn::nfp
 {
+	uint32 NFCGetTagInfo(uint32 index, uint32 timeout, MPTR functionPtr, void* userParam);
+
 	void load();
 }
 
 void nnNfp_load();
 void nnNfp_update();
 
-bool nnNfp_touchNfcTagFromFile(const wchar_t* filePath, uint32* nfcError);
+bool nnNfp_isInitialized();
+bool nnNfp_touchNfcTagFromFile(const fs::path& filePath, uint32* nfcError);
 
 #define NFP_STATE_NONE			(0)
 #define NFP_STATE_INIT			(1)
@@ -18,8 +21,3 @@ bool nnNfp_touchNfcTagFromFile(const wchar_t* filePath, uint32* nfcError);
 #define NFP_STATE_RW_MOUNT		(5)
 #define NFP_STATE_UNEXPECTED	(6)
 #define NFP_STATE_RW_MOUNT_ROM	(7)
-
-// CEMU NFC error codes
-#define NFC_ERROR_NONE					(0)
-#define NFC_ERROR_NO_ACCESS				(1)
-#define NFC_ERROR_INVALID_FILE_FORMAT	(2)
diff --git a/src/Cafe/OS/libs/nn_nim/nn_nim.cpp b/src/Cafe/OS/libs/nn_nim/nn_nim.cpp
index 565f3fa6..239ef757 100644
--- a/src/Cafe/OS/libs/nn_nim/nn_nim.cpp
+++ b/src/Cafe/OS/libs/nn_nim/nn_nim.cpp
@@ -2,6 +2,7 @@
 #include "Cafe/IOSU/legacy/iosu_ioctl.h"
 #include "Cafe/IOSU/legacy/iosu_nim.h"
 #include "Cafe/OS/libs/coreinit/coreinit_IOS.h"
+#include "Cafe/OS/libs/nn_common.h"
 
 #define nimPrepareRequest() \
 StackAllocator<iosu::nim::iosuNimCemuRequest_t> _buf_nimRequest; \
@@ -19,7 +20,7 @@ namespace nn
 
 		void export_NeedsNetworkUpdate(PPCInterpreter_t* hCPU)
 		{
-			forceLogDebug_printf("NeedsNetworkUpdate() - placeholder");
+			cemuLog_logDebug(LogType::Force, "NeedsNetworkUpdate() - placeholder");
 			ppcDefineParamTypePtr(needsUpdate, uint8, 0);
 
 			*needsUpdate = 0;
@@ -40,7 +41,7 @@ namespace nn
 
 		void export_GetUpdatePackageProgress(PPCInterpreter_t* hCPU)
 		{
-			forceLogDebug_printf("GetUpdatePackageProgress() - placeholder");
+			cemuLog_logDebug(LogType::Force, "GetUpdatePackageProgress() - placeholder");
 			ppcDefineParamTypePtr(updatePackageProgress, updatePackageProgress_t, 0);
 			// status of system update download
 			// values are unknown
@@ -53,7 +54,7 @@ namespace nn
 
 		void export_NeedsNotifyToUsers(PPCInterpreter_t* hCPU)
 		{
-			forceLogDebug_printf("NeedsNotifyToUsers() - placeholder");
+			cemuLog_logDebug(LogType::Force, "NeedsNotifyToUsers() - placeholder");
 			ppcDefineParamTypePtr(updatePackageProgress, updatePackageProgress_t, 0);
 
 			osLib_returnFromFunction(hCPU, 0);
@@ -61,8 +62,6 @@ namespace nn
 
 		void export_GetNumTitlePackages(PPCInterpreter_t* hCPU)
 		{
-			forceLogDebug_printf("GetNumTitlePackages() - placeholder");
-
 			nimPrepareRequest();
 
 			nimRequest->requestCode = IOSU_NIM_GET_PACKAGE_COUNT;
@@ -79,7 +78,7 @@ namespace nn
 
 		void export_ListTitlePackagesStatically(PPCInterpreter_t* hCPU)
 		{
-			forceLogDebug_printf("ListTitlePackagesStatically() - placeholder");
+			cemuLog_logDebug(LogType::Force, "ListTitlePackagesStatically() - placeholder");
 			ppcDefineParamTypePtr(titleIdList, uint64, 0);
 			ppcDefineParamS32(maxCount, 1);
 
@@ -96,7 +95,7 @@ namespace nn
 
 		void export_GetTitlePackageInfos(PPCInterpreter_t* hCPU)
 		{
-			forceLogDebug_printf("GetTitlePackageInfos() - placeholder");
+			cemuLog_logDebug(LogType::Force, "GetTitlePackageInfos() - placeholder");
 			ppcDefineParamTypePtr(titlePackageInfo, iosu::nim::titlePackageInfo_t, 0);
 			ppcDefineParamTypePtr(titleIdList, uint64, 1);
 			ppcDefineParamU32(count, 2);
@@ -115,7 +114,7 @@ namespace nn
 
 		void export_NeedsNotifyToUsersTitlePackage(PPCInterpreter_t* hCPU)
 		{
-			forceLogDebug_printf("NeedsNotifyToUsers() - placeholder");
+			cemuLog_logDebug(LogType::Force, "NeedsNotifyToUsers() - placeholder");
 			ppcDefineParamTypePtr(titlePackageInfo, iosu::nim::titlePackageInfo_t, 0);
 
 			osLib_returnFromFunction(hCPU, 0);
@@ -125,7 +124,7 @@ namespace nn
 
 		void export_GetIconDatabaseEntries(PPCInterpreter_t* hCPU)
 		{
-			forceLogDebug_printf("GetIconDatabaseEntries() - placeholder");
+			cemuLog_logDebug(LogType::Force, "GetIconDatabaseEntries() - placeholder");
 			ppcDefineParamTypePtr(iconDatabaseEntries, IDBE_DATA, 0);
 			ppcDefineParamTypePtr(titleIdList, uint64, 1);
 			ppcDefineParamS32(count, 2);
@@ -150,11 +149,12 @@ namespace nn
 
 		void export_QuerySchedulerStatus(PPCInterpreter_t* hCPU)
 		{
-			forceLogDebug_printf("QuerySchedulerStatus() - placeholder");
+			cemuLog_logDebug(LogType::Force, "QuerySchedulerStatus() - placeholder");
 
-			// scheduler status seems to a be a 32bit value?
+			// scheduler status seems to be either a 4 byte array or 8 byte array (or structs)?
 			// scope.rpx only checks the second byte and if it matches 0x01 then the scheduler is considered paused/stopped (displays that downloads are inactive)
-			
+			// men.rpx checks the first byte for == 1 and if true, it will show the download manager icon as downloading
+
 			// downloads disabled:
 			//memory_writeU32(hCPU->gpr[3], (0x00010000));
 			// downloads enabled:
@@ -163,31 +163,51 @@ namespace nn
 			osLib_returnFromFunction(hCPU, 0);
 		}
 
-		typedef struct  
+		struct nimResultError
 		{
 			uint32be iosError;
 			uint32be ukn04;
-		}nimResultError_t; // size unknown, but probably is 0x8
+		};
 
-
-		void export_ConstructResultError(PPCInterpreter_t* hCPU)
+		void ConstructResultError(nimResultError* resultError, uint32be* nimErrorCodePtr, uint32 uknParam)
 		{
-			forceLogDebug_printf("Construct__Q3_2nn3nim11ResultErrorFQ2_2nn6Resulti() - placeholder");
-			ppcDefineParamTypePtr(resultError, nimResultError_t, 0);
-			ppcDefineParamU32BEPtr(nimErrorCodePtr, 1);
-			ppcDefineParamU32(uknParam, 2);
-
-			resultError->iosError = 0;
+			uint32 nnResultCode = *nimErrorCodePtr;
+			resultError->iosError = nnResultCode;
 			resultError->ukn04 = uknParam;
 
-			osLib_returnFromFunction(hCPU, 0);
+			if (nnResultCode == 0xFFFFFFFF)
+			{
+				// not a valid code, used by a Wii U menu
+				return;
+			}
+
+			// IOS errors need to be translated
+			if ( (nnResultCode&0x18000000) == 0x18000000)
+			{
+				// alternative error format
+				cemu_assert_unimplemented();
+			}
+			else
+			{
+				auto moduleId = nn::nnResult_GetModule(nnResultCode);
+				if (moduleId == NN_RESULT_MODULE_NN_IOS)
+				{
+					// ios error
+					cemu_assert_unimplemented();
+				}
+				else
+				{
+					// other error
+					resultError->iosError = 0;
+				}
+			}
 		}
 
 		void export_GetECommerceInfrastructureCountry(PPCInterpreter_t* hCPU)
 		{
 			ppcDefineParamU32BEPtr(country, 0);
 
-			forceLogDebug_printf("GetECommerceInfrastructureCountry - todo");
+			cemuLog_logDebug(LogType::Force, "GetECommerceInfrastructureCountry - todo");
 
 			*country = 0;
 
@@ -219,7 +239,7 @@ namespace nn
 			ppcDefineParamU32(regionOrLanguage, 4);
 			ppcDefineParamU32(uknR8, 5); // title type?
 
-			forceLogDebug_printf("MakeTitlePackageTaskConfigAutoUsingBgInstallPolicy - placeholder");
+			cemuLog_logDebug(LogType::Force, "MakeTitlePackageTaskConfigAutoUsingBgInstallPolicy - placeholder");
 
 			titlePackageTastConfig->titleIdHigh = (uint32)(titleId >> 32);
 			titlePackageTastConfig->titleIdLow = (uint32)(titleId & 0xFFFFFFFF);
@@ -246,7 +266,7 @@ namespace nn
 			ppcDefineParamPtr(titlePackageTastConfig, TitlePackageTaskConfig_t, 1);
 
 			// get install size of currently installed title, otherwise return -1 as size
-			forceLogDebug_printf("CalculateTitleInstallSize - todo\n");
+			cemuLog_logDebug(LogType::Force, "CalculateTitleInstallSize - todo");
 
 			*installSize = 0xFFFFFFFFFFFFFFFF;
 
@@ -272,11 +292,11 @@ namespace nn
 
 			osLib_addFunction("nn_nim", "GetIconDatabaseEntries__Q2_2nn3nimFPQ3_2nn3nim17IconDatabaseEntryPCULUi", export_GetIconDatabaseEntries);
 
-			osLib_addFunction("nn_nim", "Construct__Q3_2nn3nim11ResultErrorFQ2_2nn6Resulti", export_ConstructResultError);
+			cafeExportRegisterFunc(ConstructResultError, "nn_nim", "Construct__Q3_2nn3nim11ResultErrorFQ2_2nn6Resulti", LogType::Placeholder);
 
 			osLib_addFunction("nn_nim", "MakeTitlePackageTaskConfigAutoUsingBgInstallPolicy__Q3_2nn3nim4utilFULiQ3_2nn4Cafe9TitleType", export_MakeTitlePackageTaskConfigAutoUsingBgInstallPolicy);
 			osLib_addFunction("nn_nim", "CalculateTitleInstallSize__Q2_2nn3nimFPLRCQ3_2nn3nim22TitlePackageTaskConfigPCUsUi", export_CalculateTitleInstallSize);
 
 		}
 	}
-}
\ No newline at end of file
+}
diff --git a/src/Cafe/OS/libs/nn_olv/nn_olv.cpp b/src/Cafe/OS/libs/nn_olv/nn_olv.cpp
index b2533588..1916a18d 100644
--- a/src/Cafe/OS/libs/nn_olv/nn_olv.cpp
+++ b/src/Cafe/OS/libs/nn_olv/nn_olv.cpp
@@ -1,192 +1,20 @@
-#include "Cafe/OS/common/OSCommon.h"
-#include "Cafe/OS/libs/nn_common.h"
 #include "nn_olv.h"
 
+#include "nn_olv_InitializeTypes.h"
+#include "nn_olv_UploadCommunityTypes.h"
+#include "nn_olv_DownloadCommunityTypes.h"
+#include "nn_olv_UploadFavoriteTypes.h"
+#include "nn_olv_PostTypes.h"
+#include "nn_olv_OfflineDB.h"
+
+#include "Cafe/OS/libs/proc_ui/proc_ui.h"
+#include "Cafe/OS/libs/coreinit/coreinit_Time.h"
+#include "Cafe/OS/libs/coreinit/coreinit_Misc.h"
+
 namespace nn
 {
 	namespace olv
 	{
-		struct DownloadedPostData_t
-		{
-			/* +0x0000 */ uint32be flags;
-			/* +0x0004 */ uint32be userPrincipalId;
-			/* +0x0008 */ char postId[0x20]; // size guessed
-			/* +0x0028 */ uint64 postDate;
-			/* +0x0030 */ uint8 feeling;
-			/* +0x0031 */ uint8 padding0031[3];
-			/* +0x0034 */ uint32be regionId;
-			/* +0x0038 */ uint8 platformId;
-			/* +0x0039 */ uint8 languageId;
-			/* +0x003A */ uint8 countryId;
-			/* +0x003B */ uint8 padding003B[1];
-			/* +0x003C */ uint16be bodyText[0x100]; // actual size is unknown
-			/* +0x023C */ uint32be bodyTextLength; 
-			/* +0x0240 */ uint8 compressedMemoBody[0xA000]; // 40KB
-			/* +0xA240 */ uint32be compressedMemoBodyRelated; // size of compressed data?
-			/* +0xA244 */ uint16be topicTag[0x98];
-			// app data
-			/* +0xA374 */ uint8 appData[0x400];
-			/* +0xA774 */ uint32be appDataLength;
-			// external binary
-			/* +0xA778 */ uint8 externalBinaryUrl[0x100];
-			/* +0xA878 */ uint32be externalBinaryDataSize;
-			// external image
-			/* +0xA87C */ uint8 externalImageDataUrl[0x100];
-			/* +0xA97C */ uint32be externalImageDataSize;
-			// external url ?
-			/* +0xA980 */ char externalUrl[0x100];
-			// mii
-			/* +0xAA80 */ uint8 miiData[0x60];
-			/* +0xAAE0 */ uint16be miiNickname[0x20];
-			/* +0xAB20 */ uint8 unusedAB20[0x14E0];
-
-			// everything above is part of DownloadedDataBase
-			// everything below is part of DownloadedPostData
-			/* +0xC000 */ uint8 uknDataC000[8]; // ??
-			/* +0xC008 */ uint32be communityId;
-			/* +0xC00C */ uint32be empathyCount;
-			/* +0xC010 */ uint32be commentCount;
-			/* +0xC014 */ uint8 unused[0x1F4];
-		}; // size: 0xC208
-
-		static_assert(sizeof(DownloadedPostData_t) == 0xC208, "");
-		static_assert(offsetof(DownloadedPostData_t, postDate) == 0x0028, "");
-		static_assert(offsetof(DownloadedPostData_t, platformId) == 0x0038, "");
-		static_assert(offsetof(DownloadedPostData_t, bodyText) == 0x003C, "");
-		static_assert(offsetof(DownloadedPostData_t, compressedMemoBody) == 0x0240, "");
-		static_assert(offsetof(DownloadedPostData_t, topicTag) == 0xA244, "");
-		static_assert(offsetof(DownloadedPostData_t, appData) == 0xA374, "");
-		static_assert(offsetof(DownloadedPostData_t, externalBinaryUrl) == 0xA778, "");
-		static_assert(offsetof(DownloadedPostData_t, externalImageDataUrl) == 0xA87C, "");
-		static_assert(offsetof(DownloadedPostData_t, externalUrl) == 0xA980, "");
-		static_assert(offsetof(DownloadedPostData_t, miiData) == 0xAA80, "");
-		static_assert(offsetof(DownloadedPostData_t, miiNickname) == 0xAAE0, "");
-		static_assert(offsetof(DownloadedPostData_t, unusedAB20) == 0xAB20, "");
-		static_assert(offsetof(DownloadedPostData_t, communityId) == 0xC008, "");
-		static_assert(offsetof(DownloadedPostData_t, empathyCount) == 0xC00C, "");
-		static_assert(offsetof(DownloadedPostData_t, commentCount) == 0xC010, "");
-
-		const int POST_DATA_FLAG_HAS_BODY_TEXT = (0x0001);
-		const int POST_DATA_FLAG_HAS_BODY_MEMO = (0x0002);
-
-
-		void export_DownloadPostDataList(PPCInterpreter_t* hCPU)
-		{
-			ppcDefineParamTypePtr(downloadedTopicData, void, 0); // DownloadedTopicData
-			ppcDefineParamTypePtr(downloadedPostData, DownloadedPostData_t, 1); // DownloadedPostData
-			ppcDefineParamTypePtr(downloadedPostDataSize, uint32be, 2);
-			ppcDefineParamS32(maxCount, 3);
-			ppcDefineParamTypePtr(listParam, void, 4); // DownloadPostDataListParam
-
-			maxCount = 0; // DISABLED
-
-			// just some test
-			for (sint32 i = 0; i < maxCount; i++)
-			{
-				DownloadedPostData_t* postData = downloadedPostData + i;
-				memset(postData, 0, sizeof(DownloadedPostData_t));
-				postData->userPrincipalId = 0x1000 + i;
-				// post id
-				sprintf(postData->postId, "postid-%04x", i+(GetTickCount()%10000));
-				postData->bodyTextLength = 12;
-				postData->bodyText[0] = 'H';
-				postData->bodyText[1] = 'e';
-				postData->bodyText[2] = 'l';
-				postData->bodyText[3] = 'l';
-				postData->bodyText[4] = 'o';
-				postData->bodyText[5] = ' ';
-				postData->bodyText[6] = 'w';
-				postData->bodyText[7] = 'o';
-				postData->bodyText[8] = 'r';
-				postData->bodyText[9] = 'l';
-				postData->bodyText[10] = 'd';
-				postData->bodyText[11] = '!';
-
-				postData->miiNickname[0] = 'C';
-				postData->miiNickname[1] = 'e';
-				postData->miiNickname[2] = 'm';
-				postData->miiNickname[3] = 'u';
-				postData->miiNickname[4] = '-';
-				postData->miiNickname[5] = 'M';
-				postData->miiNickname[6] = 'i';
-				postData->miiNickname[7] = 'i';
-
-				postData->topicTag[0] = 't';
-				postData->topicTag[1] = 'o';
-				postData->topicTag[2] = 'p';
-				postData->topicTag[3] = 'i';
-				postData->topicTag[4] = 'c';
-
-				postData->flags = POST_DATA_FLAG_HAS_BODY_TEXT;
-			}
-			*downloadedPostDataSize = maxCount;
-
-			osLib_returnFromFunction(hCPU, 0);
-		}
-
-		void export_DownloadCommunityDataList(PPCInterpreter_t* hCPU)
-		{
-			ppcDefineParamTypePtr(communityListSizeOut, uint32be, 1);
-
-			*communityListSizeOut = 0;
-			osLib_returnFromFunction(hCPU, 0);
-		}
-
-		void exportDownloadPostData_TestFlags(PPCInterpreter_t* hCPU)
-		{
-			ppcDefineParamTypePtr(downloadedPostData, DownloadedPostData_t, 0);
-			ppcDefineParamU32(testFlags, 1);
-
-			if (((uint32)downloadedPostData->flags) & testFlags)
-				osLib_returnFromFunction(hCPU, 1);
-			else
-				osLib_returnFromFunction(hCPU, 0);
-		}
-
-		void exportDownloadPostData_GetPostId(PPCInterpreter_t* hCPU)
-		{
-			ppcDefineParamTypePtr(downloadedPostData, DownloadedPostData_t, 0);
-			osLib_returnFromFunction(hCPU, memory_getVirtualOffsetFromPointer(downloadedPostData->postId));
-		}
-
-		void exportDownloadPostData_GetMiiNickname(PPCInterpreter_t* hCPU)
-		{
-			ppcDefineParamTypePtr(downloadedPostData, DownloadedPostData_t, 0);
-			if(downloadedPostData->miiNickname[0] == 0 )
-				osLib_returnFromFunction(hCPU, MPTR_NULL);
-			else
-				osLib_returnFromFunction(hCPU, memory_getVirtualOffsetFromPointer(downloadedPostData->miiNickname));
-		}
-
-		void exportDownloadPostData_GetTopicTag(PPCInterpreter_t* hCPU)
-		{
-			ppcDefineParamTypePtr(downloadedPostData, DownloadedPostData_t, 0);
-			osLib_returnFromFunction(hCPU, memory_getVirtualOffsetFromPointer(downloadedPostData->topicTag));
-		}
-
-		void exportDownloadPostData_GetBodyText(PPCInterpreter_t* hCPU)
-		{
-			ppcDefineParamTypePtr(downloadedPostData, DownloadedPostData_t, 0);
-			ppcDefineParamWStrBE(strOut, 1);
-			ppcDefineParamS32(maxLength, 2);
-
-			if (((uint32)downloadedPostData->flags&POST_DATA_FLAG_HAS_BODY_TEXT) == 0)
-			{
-				osLib_returnFromFunction(hCPU, 0xC1106800);
-				return;
-			}
-
-			memset(strOut, 0, sizeof(uint16be)*maxLength);
-			sint32 copyLen = std::min(maxLength - 1, (sint32)downloadedPostData->bodyTextLength);
-			for (sint32 i = 0; i < copyLen; i++)
-			{
-				strOut[i] = downloadedPostData->bodyText[i];
-			}
-			strOut[copyLen] = '\0';
-
-			osLib_returnFromFunction(hCPU, 0);
-		}
-
 		struct PortalAppParam_t
 		{
 			/* +0x1A663B */ char serviceToken[32]; // size is unknown
@@ -203,26 +31,118 @@ namespace nn
 			osLib_returnFromFunction(hCPU, memory_getVirtualOffsetFromPointer(&portalAppParam->serviceToken));
 		}
 
-		uint32 UploadPostDataByPostApp(void *postParam)
+		static SysAllocator<OSThread_t> s_OlvReleaseBgThread;
+		SysAllocator<uint8, 1024> s_OlvReleaseBgThreadStack;
+		SysAllocator<char, 32> s_OlvReleaseBgThreadName;
+
+		void StubPostAppReleaseBackground(PPCInterpreter_t* hCPU)
 		{
-			forceLog_printf("UploadPostDataByPostApp() called. Returning error");
-			return BUILD_NN_RESULT(NN_RESULT_LEVEL_STATUS, NN_RESULT_MODULE_NN_OLV, 0); // undefined error
+			coreinit::OSSleepTicks(ESPRESSO_TIMER_CLOCK * 2); // Sleep 2s
+			coreinit::StartBackgroundForegroundTransition();
 		}
 
+		sint32 StubPostApp(void* pAnyPostParam)
+		{
+			coreinit::OSCreateThreadType(s_OlvReleaseBgThread.GetPtr(), RPLLoader_MakePPCCallable(StubPostAppReleaseBackground), 0, nullptr, s_OlvReleaseBgThreadStack.GetPtr() + s_OlvReleaseBgThreadStack.GetByteSize(), (sint32)s_OlvReleaseBgThreadStack.GetByteSize(), 0, (1 << 1) | (1 << 3), OSThread_t::THREAD_TYPE::TYPE_APP);
+			coreinit::OSResumeThread(s_OlvReleaseBgThread.GetPtr());
+			strcpy(s_OlvReleaseBgThreadName.GetPtr(), "StubPostApp!");
+			coreinit::OSSetThreadName(s_OlvReleaseBgThread.GetPtr(),s_OlvReleaseBgThreadName.GetPtr());
+			return OLV_RESULT_SUCCESS;
+		}
+
+		sint32 StubPostAppResult()
+		{
+			return OLV_RESULT_STATUS(301); // Cancelled post app
+		}
+
+		// Somehow required, MK8 doesn't even seem to care about the error codes lol
+		char* UploadedPostData_GetPostId(char* pPostData)
+		{
+			pPostData[4] = '\0';
+			return &pPostData[4];
+		}
+
+		// https://github.com/kinnay/NintendoClients/wiki/Wii-U-Error-Codes#act-error-codes
+		constexpr uint32 GetErrorCodeImpl(uint32 in)
+		{
+			uint32_t errorCode = in;
+			uint32_t errorVersion = (errorCode >> 27) & 3;
+			uint32_t errorModuleMask = (errorVersion != 3) ? 0x1FF00000 : 0x7F00000;
+			bool isCodeFailure = errorCode & 0x80000000;
+
+			if (((errorCode & errorModuleMask) >> 20) == NN_RESULT_MODULE_NN_ACT)
+			{
+				// BANNED_ACCOUNT_IN_INDEPENDENT_SERVICE or BANNED_ACCOUNT_IN_INDEPENDENT_SERVICE_TEMPORARILY
+				if (errorCode == OLV_ACT_RESULT_STATUS(2805) || errorCode == OLV_ACT_RESULT_STATUS(2825))
+				{
+					uint32 tmpCode = OLV_RESULT_STATUS(1008);
+					return GetErrorCodeImpl(tmpCode);
+				}
+				// BANNED_DEVICE_IN_INDEPENDENT_SERVICE or  BANNED_DEVICE_IN_INDEPENDENT_SERVICE_TEMPORARILY
+				else if (errorCode == OLV_ACT_RESULT_STATUS(2815) || errorCode == OLV_ACT_RESULT_STATUS(2835))
+				{
+					uint32 tmpCode = OLV_RESULT_STATUS(1009);
+					return GetErrorCodeImpl(tmpCode);
+				}
+				else
+				{
+					// Check ACT error code
+					return 1159999;
+				}
+			}
+			else
+			{
+				if (((errorCode & errorModuleMask) >> 20) == NN_RESULT_MODULE_NN_OLV && isCodeFailure)
+				{
+					uint32_t errorValueMask = (errorVersion != 3) ? 0xFFFFF : 0x3FF;
+					return ((errorCode & errorValueMask) >> 7) + 1150000;
+				}
+				else
+				{
+					return 1159999;
+				}
+			}
+		}
+
+		uint32 GetErrorCode(uint32be* pResult)
+		{
+			return GetErrorCodeImpl(pResult->value());
+		}
+
+		static_assert(GetErrorCodeImpl(0xa119c600) == 1155004);
+
 		void load()
 		{
-			osLib_addFunction("nn_olv", "DownloadPostDataList__Q2_2nn3olvFPQ3_2nn3olv19DownloadedTopicDataPQ3_2nn3olv18DownloadedPostDataPUiUiPCQ3_2nn3olv25DownloadPostDataListParam", export_DownloadPostDataList);
-			osLib_addFunction("nn_olv", "TestFlags__Q3_2nn3olv18DownloadedDataBaseCFUi", exportDownloadPostData_TestFlags);
-			osLib_addFunction("nn_olv", "GetPostId__Q3_2nn3olv18DownloadedDataBaseCFv", exportDownloadPostData_GetPostId);
-			osLib_addFunction("nn_olv", "GetMiiNickname__Q3_2nn3olv18DownloadedDataBaseCFv", exportDownloadPostData_GetMiiNickname);
-			osLib_addFunction("nn_olv", "GetTopicTag__Q3_2nn3olv18DownloadedDataBaseCFv", exportDownloadPostData_GetTopicTag);
-			osLib_addFunction("nn_olv", "GetBodyText__Q3_2nn3olv18DownloadedDataBaseCFPwUi", exportDownloadPostData_GetBodyText);
+			g_ReportTypes = 0;
+			g_IsOnlineMode = false;
+			g_IsInitialized = false;
+			g_IsOfflineDBMode = false;
 
-			osLib_addFunction("nn_olv", "DownloadCommunityDataList__Q2_2nn3olvFPQ3_2nn3olv23DownloadedCommunityDataPUiUiPCQ3_2nn3olv30DownloadCommunityDataListParam", export_DownloadCommunityDataList);
+			loadOliveInitializeTypes();
+			loadOliveUploadCommunityTypes();
+			loadOliveDownloadCommunityTypes();
+			loadOliveUploadFavoriteTypes();
+			loadOlivePostAndTopicTypes();
+
+			cafeExportRegisterFunc(GetErrorCode, "nn_olv", "GetErrorCode__Q2_2nn3olvFRCQ2_2nn6Result", LogType::NN_OLV);
 
 			osLib_addFunction("nn_olv", "GetServiceToken__Q4_2nn3olv6hidden14PortalAppParamCFv", exportPortalAppParam_GetServiceToken);
 
-			cafeExportRegisterFunc(UploadPostDataByPostApp, "nn_olv", "UploadPostDataByPostApp__Q2_2nn3olvFPCQ3_2nn3olv28UploadPostDataByPostAppParam", LogType::Placeholder);
+			cafeExportRegisterFunc(StubPostApp, "nn_olv", "UploadPostDataByPostApp__Q2_2nn3olvFPCQ3_2nn3olv28UploadPostDataByPostAppParam", LogType::NN_OLV);
+			cafeExportRegisterFunc(StubPostApp, "nn_olv", "UploadCommentDataByPostApp__Q2_2nn3olvFPCQ3_2nn3olv31UploadCommentDataByPostAppParam", LogType::NN_OLV);
+			cafeExportRegisterFunc(StubPostApp, "nn_olv", "UploadDirectMessageDataByPostApp__Q2_2nn3olvFPCQ3_2nn3olv37UploadDirectMessageDataByPostAppParam", LogType::NN_OLV);
+
+			cafeExportRegisterFunc(StubPostAppResult, "nn_olv", "GetResultByPostApp__Q2_2nn3olvFv", LogType::NN_OLV);
+			cafeExportRegisterFunc(StubPostAppResult, "nn_olv", "GetResultWithUploadedPostDataByPostApp__Q2_2nn3olvFPQ3_2nn3olv16UploadedPostData", LogType::NN_OLV);
+			cafeExportRegisterFunc(StubPostAppResult, "nn_olv", "GetResultWithUploadedDirectMessageDataByPostApp__Q2_2nn3olvFPQ3_2nn3olv25UploadedDirectMessageData", LogType::NN_OLV);
+			cafeExportRegisterFunc(StubPostAppResult, "nn_olv", "GetResultWithUploadedCommentDataByPostApp__Q2_2nn3olvFPQ3_2nn3olv19UploadedCommentData", LogType::NN_OLV);
+
+			cafeExportRegisterFunc(UploadedPostData_GetPostId, "nn_olv", "GetPostId__Q3_2nn3olv16UploadedPostDataCFv", LogType::NN_OLV);
+		}
+
+		void unload() // not called yet
+		{
+			OfflineDB_Shutdown();
 		}
 
 	}
diff --git a/src/Cafe/OS/libs/nn_olv/nn_olv.h b/src/Cafe/OS/libs/nn_olv/nn_olv.h
index e8278136..52474b49 100644
--- a/src/Cafe/OS/libs/nn_olv/nn_olv.h
+++ b/src/Cafe/OS/libs/nn_olv/nn_olv.h
@@ -1,9 +1,24 @@
 #pragma once
 
+#include "Cafe/OS/common/OSCommon.h"
+#include "Cafe/OS/libs/nn_common.h"
+#include "Cafe/OS/libs/nn_act/nn_act.h"
+#include "Cafe/CafeSystem.h"
+#include "Cemu/napi/napi.h"
+
+#include "nn_olv_Common.h"
+
 namespace nn
 {
 	namespace olv
 	{
+
+		extern ParamPackStorage g_ParamPack;
+		extern DiscoveryResultStorage g_DiscoveryResults;
+
+		sint32 GetOlvAccessKey(uint32_t* pOutKey);
+
 		void load();
+		void unload();
 	}
 }
\ No newline at end of file
diff --git a/src/Cafe/OS/libs/nn_olv/nn_olv_Common.cpp b/src/Cafe/OS/libs/nn_olv/nn_olv_Common.cpp
new file mode 100644
index 00000000..839aa412
--- /dev/null
+++ b/src/Cafe/OS/libs/nn_olv/nn_olv_Common.cpp
@@ -0,0 +1,285 @@
+#include "nn_olv_Common.h"
+#include <zlib.h>
+
+namespace nn
+{
+	namespace olv
+	{
+
+		sint32 olv_copy_wstr(char16_t* dest, const char16_t* src, uint32_t maxSize, uint32_t destSize)
+		{
+			size_t len = maxSize + 1;
+			if (olv_wstrnlen(src, len) > maxSize)
+				return OLV_RESULT_NOT_ENOUGH_SIZE;
+
+			memset(dest, 0, 2 * destSize);
+			olv_wstrncpy(dest, src, len);
+			return OLV_RESULT_SUCCESS;
+		}
+
+		size_t olv_wstrnlen(const char16_t* str, size_t max_len)
+		{
+			size_t len = 0;
+			while (len < max_len && str[len] != u'\0')
+				len++;
+
+			return len;
+		}
+
+		char16_t* olv_wstrncpy(char16_t* dest, const char16_t* src, size_t n)
+		{
+			char16_t* ret = dest;
+			while (n > 0 && *src != u'\0')
+			{
+				*dest++ = *src++;
+				n--;
+			}
+			while (n > 0)
+			{
+				*dest++ = u'\0';
+				n--;
+			}
+			return ret;
+		}
+
+		bool CheckTGA(const uint8* pTgaFile, uint32 pTgaFileLen, TGACheckType checkType)
+		{
+			const TGAHeader* header = (const TGAHeader*)pTgaFile;
+			try
+			{
+				if (checkType == TGACheckType::CHECK_PAINTING)
+				{
+					if (
+						header->idLength ||
+						header->colorMapType ||
+						header->imageType != 2 || // Uncompressed true color
+						header->first_entry_idx ||
+						header->colormap_length ||
+						header->bpp ||
+						header->x_origin ||
+						header->y_origin ||
+						header->width != 320 ||
+						header->height != 120 ||
+						header->pixel_depth_bpp != 32 ||
+						header->image_desc_bits != 8
+						)
+					{
+						throw std::runtime_error("TGACheckType::CHECK_PAINTING - Invalid TGA file!");
+					}
+				}
+				else if (checkType == TGACheckType::CHECK_COMMUNITY_ICON)
+				{
+					if (header->width != 128 || header->height != 128 || header->pixel_depth_bpp != 32)
+						throw std::runtime_error("TGACheckType::CHECK_COMMUNITY_ICON - Invalid TGA file -> width, height or bpp is wrong");
+				}
+				else if (checkType == TGACheckType::CHECK_100x100_200x200)
+				{
+					if (header->pixel_depth_bpp != 32)
+						throw std::runtime_error("TGACheckType::CHECK_100x100_200x200 - Invalid TGA file -> bpp is wrong");
+
+					if (header->width == 100)
+					{
+						if (header->height != 100)
+							throw std::runtime_error("TGACheckType::CHECK_100x100_200x200 - Invalid TGA file -> Not 100x100");
+					}
+					else if (header->width != 200 || header->height != 200)
+						throw std::runtime_error("TGACheckType::CHECK_100x100_200x200 - Invalid TGA file -> Not 100x100 or 200x200");
+				}
+			}
+			catch (const std::runtime_error& error)
+			{
+				// TGA Check Error! illegal format
+				cemuLog_log(LogType::Force, error.what());
+				return false;
+			}
+			return true;
+		}
+
+		sint32 DecodeTGA(uint8* pInBuffer, uint32 inSize, uint8* pOutBuffer, uint32 outSize, TGACheckType checkType)
+		{
+			uint32 decompressedSize = outSize;
+			if (DecompressTGA(pOutBuffer, &decompressedSize, pInBuffer, inSize))
+			{
+				if (CheckTGA(pOutBuffer, decompressedSize, checkType))
+					return decompressedSize;
+				
+				return -2;
+			}
+			else
+			{
+				cemuLog_log(LogType::Force, "OLIVE uncompress error.\n");
+				return -1;
+			}
+		}
+
+		sint32 EncodeTGA(uint8* pInBuffer, uint32 inSize, uint8* pOutBuffer, uint32 outSize, TGACheckType checkType)
+		{
+			if (inSize == outSize)
+			{
+				if (!CheckTGA(pInBuffer, inSize, checkType))
+					return -1;
+				
+					uint32 compressedSize = outSize;
+					if (CompressTGA(pOutBuffer, &compressedSize, pInBuffer, inSize))
+						return compressedSize;
+					else
+					{
+						cemuLog_log(LogType::Force, "OLIVE compress error.\n");
+						return -1;
+					}
+			}
+			else
+			{
+				cemuLog_log(LogType::Force, "compress buffer size check error. uSrcBufSize({}) != uDstBufSize({})\n", inSize, outSize);
+				return -1;
+			}
+		}
+
+		bool DecompressTGA(uint8* pOutBuffer, uint32* pOutSize, uint8* pInBuffer, uint32 inSize)
+		{
+			if (pOutBuffer == nullptr || pOutSize == nullptr || pInBuffer == nullptr || inSize == 0)
+				return false;
+
+			uLongf bufferSize = *pOutSize;
+			int result = uncompress(pOutBuffer, &bufferSize, pInBuffer, inSize);
+
+			if (result == Z_OK)
+			{
+				*pOutSize = static_cast<unsigned int>(bufferSize);
+				return true;
+			}
+			else
+			{
+				const char* error_msg = (result == Z_MEM_ERROR) ? "Insufficient memory" : "Unknown decompression error";
+				cemuLog_log(LogType::Force, "OLIVE ZLIB - ERROR: {}\n", error_msg);
+				return false;
+			}
+		}
+
+		bool CompressTGA(uint8* pOutBuffer, uint32* pOutSize, uint8* pInBuffer, uint32 inSize)
+		{
+			if (pOutBuffer == nullptr || pOutSize == nullptr || pInBuffer == nullptr || inSize == 0)
+				return false;
+
+			uLongf bufferSize = *pOutSize;
+			int result = compress(pOutBuffer, &bufferSize, pInBuffer, inSize);
+
+			if (result == Z_OK)
+			{
+				*pOutSize = static_cast<unsigned int>(bufferSize);
+				return true;
+			}
+			else
+			{
+				const char* error_msg = (result == Z_MEM_ERROR) ? "Insufficient memory" : "Unknown compression error";
+				cemuLog_log(LogType::Force, "OLIVE ZLIB - ERROR: {}\n", error_msg);
+				return false;
+			}
+		}
+
+		constexpr uint32 CreateCommunityCodeById(uint32 communityId)
+		{
+			uint32 res = communityId ^ (communityId << 18) ^ (communityId << 24) ^ (communityId << 30);
+			return res ^ (16 * (res & 0xF0F0F0F)) ^ ((res ^ (16 * (res & 0xF0F0F0F))) >> 17) ^ ((res ^ (16 * (res & 0xF0F0F0F))) >> 23) ^ ((res ^ (16 * (res & 0xF0F0F0F))) >> 29) ^ 0x20121002;
+		}
+
+		constexpr uint32 CreateCommunityIdByCode(uint32 code)
+		{
+			uint32 res = code ^ 0x20121002 ^ ((code ^ 0x20121002u) >> 17) ^ ((code ^ 0x20121002u) >> 23) ^ ((code ^ 0x20121002u) >> 29);
+			return res ^ (16 * (res & 0xF0F0F0F)) ^ ((res ^ (16 * (res & 0xF0F0F0F))) << 18) ^ ((res ^ (16 * (res & 0xF0F0F0F))) << 24) ^ ((res ^ (16 * (res & 0xF0F0F0F))) << 30);
+		}
+
+
+		constexpr uint32 GetCommunityCodeTopByte(uint32 communityId)
+		{
+			uint8 code_byte3 = (uint8_t)(communityId >> 0x18);
+			uint8 code_byte2 = (uint8_t)(communityId >> 0x10);
+			uint8 code_byte1 = (uint8_t)(communityId >> 8);
+			uint8 code_byte0 = (uint8_t)(communityId >> 0);
+			return code_byte3 ^ code_byte2 ^ code_byte1 ^ code_byte0 ^ 0xff;
+		}
+
+		constexpr uint64 GetRealCommunityCode(uint32_t communityId)
+		{
+			uint64 topByte = GetCommunityCodeTopByte(communityId);
+			if ((0xe7 < topByte) && ((0xe8 < topByte || (0xd4a50fff < communityId))))
+				return ((topByte << 32) | communityId) & 0x7fffffffff;
+
+			return ((topByte << 32) | communityId);
+		}
+
+		void WriteCommunityCode(char* pOutCode, uint32 communityId)
+		{
+			uint32 code = CreateCommunityCodeById(communityId);
+			uint64 communityCode = GetRealCommunityCode(code);
+			sprintf(pOutCode, "%012llu", communityCode);
+		}
+
+		bool EnsureCommunityCode(char* pCode)
+		{
+			uint64 code;
+			if (sscanf(pCode, "%012llu", &code) > 0)
+			{
+				uint32 lowerCode = code;
+				uint64 newCode = GetRealCommunityCode(code);
+				return code == newCode;
+			}
+			return false;
+		}
+
+		bool FormatCommunityCode(char* pOutCode, uint32* outLen, uint32 communityId)
+		{
+			bool result = false;
+			if (communityId != -1)
+			{
+				if (communityId)
+				{
+					WriteCommunityCode(pOutCode, communityId);
+					*outLen = strnlen(pOutCode, 12);
+					if (EnsureCommunityCode(pOutCode))
+						result = 1;
+				}
+			}
+			return result;
+		}
+
+		static_assert(GetRealCommunityCode(CreateCommunityCodeById(140500)) == 717651734336, "Wrong community code generation code, result must match.");
+
+		uint32 ExtractCommunityIdFromCode(char* pCode)
+		{
+			uint32 id = 0;
+			uint64 code;
+			if (sscanf(pCode, "%012llu", &code) > 0)
+			{
+				uint32 lower_code = code;
+				id = CreateCommunityIdByCode(lower_code);
+			}
+			return id;
+		}
+
+		bool GetCommunityIdFromCode(uint32* pOutId, const char* pCode)
+		{
+			if (!EnsureCommunityCode((char*)pCode))
+				return false;
+
+			*pOutId = ExtractCommunityIdFromCode((char*)pCode);
+			return true;
+		}
+
+		sint32 olv_curlformcode_to_error(CURLFORMcode code)
+		{
+			switch (code)
+			{
+				case CURL_FORMADD_OK:
+					return OLV_RESULT_SUCCESS;
+
+				case CURL_FORMADD_MEMORY:
+					return OLV_RESULT_FATAL(25);
+
+				case CURL_FORMADD_OPTION_TWICE:
+				default:
+					return OLV_RESULT_LVL6(50);
+			}
+		}
+	}
+}
\ No newline at end of file
diff --git a/src/Cafe/OS/libs/nn_olv/nn_olv_Common.h b/src/Cafe/OS/libs/nn_olv/nn_olv_Common.h
new file mode 100644
index 00000000..c598e7ba
--- /dev/null
+++ b/src/Cafe/OS/libs/nn_olv/nn_olv_Common.h
@@ -0,0 +1,214 @@
+#pragma once
+
+#include "Cafe/OS/libs/nn_common.h"
+#include "Cafe/OS/common/OSCommon.h"
+#include "Cemu/napi/napi_helper.h"
+#include "util/helpers/StringHelpers.h"
+#include "pugixml.hpp"
+
+// https://github.com/kinnay/NintendoClients/wiki/Wii-U-Error-Codes#act-error-codes
+#define OLV_ACT_RESULT_STATUS(code) (BUILD_NN_RESULT(NN_RESULT_LEVEL_STATUS, NN_RESULT_MODULE_NN_OLV, ((code) << 7)))
+
+#define OLV_RESULT_STATUS(code) (BUILD_NN_RESULT(NN_RESULT_LEVEL_STATUS, NN_RESULT_MODULE_NN_OLV, ((code) << 7)))
+#define OLV_RESULT_LVL6(code) (BUILD_NN_RESULT(NN_RESULT_LEVEL_LVL6, NN_RESULT_MODULE_NN_OLV, ((code) << 7)))
+#define OLV_RESULT_FATAL(code) (BUILD_NN_RESULT(NN_RESULT_LEVEL_FATAL, NN_RESULT_MODULE_NN_OLV, ((code) << 7)))
+#define OLV_RESULT_SUCCESS (BUILD_NN_RESULT(0, NN_RESULT_MODULE_NN_OLV, 1 << 7))
+
+#define OLV_RESULT_INVALID_PARAMETER (OLV_RESULT_LVL6(201))
+#define OLV_RESULT_INVALID_DATA (OLV_RESULT_LVL6(202))
+#define OLV_RESULT_NOT_ENOUGH_SIZE (OLV_RESULT_LVL6(203))
+#define OLV_RESULT_INVALID_PTR (OLV_RESULT_LVL6(204))
+#define OLV_RESULT_NOT_INITIALIZED (OLV_RESULT_LVL6(205))
+#define OLV_RESULT_ALREADY_INITIALIZED (OLV_RESULT_LVL6(206))
+#define OLV_RESULT_OFFLINE_MODE_REQUEST (OLV_RESULT_LVL6(207))
+#define OLV_RESULT_MISSING_DATA (OLV_RESULT_LVL6(208))
+#define OLV_RESULT_INVALID_SIZE (OLV_RESULT_LVL6(209))
+
+#define OLV_RESULT_BAD_VERSION (OLV_RESULT_STATUS(2001))
+#define OLV_RESULT_FAILED_REQUEST (OLV_RESULT_STATUS(2003))
+#define OLV_RESULT_INVALID_XML (OLV_RESULT_STATUS(2004))
+#define OLV_RESULT_INVALID_TEXT_FIELD (OLV_RESULT_STATUS(2006))
+#define OLV_RESULT_INVALID_INTEGER_FIELD (OLV_RESULT_STATUS(2007))
+
+#define OLV_CLIENT_ID "87cd32617f1985439ea608c2746e4610"
+
+#define OLV_VERSION_MAJOR 5
+#define OLV_VERSION_MINOR 0
+#define OLV_VERSION_PATCH 3
+
+namespace nn
+{
+	namespace olv
+	{
+		struct ParamPackStorage
+		{
+			uint64_t titleId;
+			uint32_t accessKey;
+			uint32_t platformId;
+			uint8_t regionId, languageId, countryId, areaId;
+			uint8_t networkRestriction, friendRestriction;
+			uint32_t ratingRestriction;
+			uint8_t ratingOrganization;
+			uint64_t transferableId;
+			char tzName[72];
+			uint64_t utcOffset;
+			char encodedParamPack[512];
+		};
+
+		struct DiscoveryResultStorage
+		{
+			sint32 has_error;
+			char serviceToken[512];
+			char userAgent[64];
+			char apiEndpoint[256];
+			char portalEndpoint[256];
+		};
+
+		extern ParamPackStorage g_ParamPack;
+		extern DiscoveryResultStorage g_DiscoveryResults;
+		extern uint32_t g_ReportTypes;
+		extern bool g_IsInitialized;
+		extern bool g_IsOnlineMode;
+		extern bool g_IsOfflineDBMode; // use offline cache for posts
+
+		static void InitializeOliveRequest(CurlRequestHelper& req)
+		{
+			req.addHeaderField("X-Nintendo-ServiceToken", g_DiscoveryResults.serviceToken);
+			req.addHeaderField("X-Nintendo-ParamPack", g_ParamPack.encodedParamPack);
+			curl_easy_setopt(req.getCURL(), CURLOPT_USERAGENT, g_DiscoveryResults.userAgent);
+		}
+
+		static void appendQueryToURL(char* url, const char* query)
+		{
+			size_t urlLength = strlen(url);
+			size_t queryLength = strlen(query);
+
+			char* delimiter = strchr(url, '?');
+			if (delimiter)
+				snprintf(url + urlLength, queryLength + 2, "&%s", query);
+			else
+				snprintf(url + urlLength, queryLength + 2, "?%s", query);
+		}
+
+		static sint32 CheckOliveResponse(pugi::xml_document& doc)
+		{
+
+			/*
+				<result>
+					<has_error>1</has_error>
+					<version>1</version>
+					<code>400</code>
+					<error_code>4</error_code>
+					<message>SERVICE_CLOSED</message>
+				</result>
+			*/
+
+			pugi::xml_node resultNode = doc.child("result");
+			if (!resultNode)
+			{
+				cemuLog_log(LogType::Force, "Discovery response doesn't contain <result>...</result>");
+				return OLV_RESULT_INVALID_XML;
+			}
+
+			std::string_view has_error = resultNode.child_value("has_error");
+			std::string_view version = resultNode.child_value("version");
+			std::string_view code = resultNode.child_value("code");
+			std::string_view error_code = resultNode.child_value("error_code");
+
+			if (has_error.compare("1") == 0)
+			{
+				int codeVal = StringHelpers::ToInt(error_code, -1);
+				if (codeVal < 0)
+				{
+					codeVal = StringHelpers::ToInt(code, -1);
+					return OLV_RESULT_STATUS(codeVal + 4000);
+				}
+				return OLV_RESULT_STATUS(codeVal + 5000);
+
+			}
+
+			if (version.compare("1") != 0)
+				return OLV_RESULT_BAD_VERSION; // Version mismatch
+
+			return OLV_RESULT_SUCCESS;
+		}
+
+		sint32 olv_copy_wstr(char16_t* dest, const char16_t* src, uint32_t maxSize, uint32_t destSize);
+		size_t olv_wstrnlen(const char16_t* str, size_t max_len);
+		char16_t* olv_wstrncpy(char16_t* dest, const char16_t* src, size_t n);
+
+#pragma pack(push, 1)
+		struct TGAHeader
+		{
+			uint8 idLength;
+			uint8 colorMapType;
+			uint8 imageType;
+			uint16 first_entry_idx;
+			uint16 colormap_length;
+			uint8 bpp;
+			uint16 x_origin;
+			uint16 y_origin;
+			uint16 width;
+			uint16 height;
+			uint8 pixel_depth_bpp;
+			uint8 image_desc_bits;
+		};
+#pragma pack(pop)
+		static_assert(sizeof(nn::olv::TGAHeader) == 0x12, "sizeof(nn::olv::TGAHeader != 0x12");
+
+		enum TGACheckType : uint32
+		{
+			CHECK_PAINTING = 0,
+			CHECK_COMMUNITY_ICON = 1,
+			CHECK_100x100_200x200 = 2
+		};
+
+
+		bool CheckTGA(const uint8* pTgaFile, uint32 pTgaFileLen, TGACheckType checkType);
+		sint32 DecodeTGA(uint8* pInBuffer, uint32 inSize, uint8* pOutBuffer, uint32 outSize, TGACheckType checkType);
+		sint32 EncodeTGA(uint8* pInBuffer, uint32 inSize, uint8* pOutBuffer, uint32 outSize, TGACheckType checkTyp);
+		
+		bool CompressTGA(uint8* pOutBuffer, uint32* pOutSize, uint8* pInBuffer, uint32 inSize);
+		bool DecompressTGA(uint8* pOutBuffer, uint32* pOutSize, uint8* pInBuffer, uint32 inSize);
+
+
+		bool GetCommunityIdFromCode(uint32* pOutId, const char* pCode);
+		bool FormatCommunityCode(char* pOutCode, uint32* outLen, uint32 communityId);
+
+		sint32 olv_curlformcode_to_error(CURLFORMcode code);
+
+		// convert and copy utf8 string into UC2 big-endian array
+		template<size_t TLength>
+		uint32 SetStringUC2(uint16be(&str)[TLength], std::string_view sv, bool unescape = false)
+		{
+			if(unescape)
+			{
+				// todo
+			}
+			std::wstring ws = boost::nowide::widen(sv);
+			size_t copyLen = std::min<size_t>(TLength-1, ws.size());
+			for(size_t i=0; i<copyLen; i++)
+				str[i] = ws[i];
+			str[copyLen] = '\0';
+			return copyLen;
+		}
+
+		// safely copy null-terminated UC2 big-endian string into UC2 big-endian array
+		template<size_t TLength>
+		uint32 SetStringUC2(uint16be(&str)[TLength], const uint16be* strIn)
+		{
+			size_t copyLen = TLength-1;
+			for(size_t i=0; i<copyLen; i++)
+			{
+				if(strIn[i] == 0)
+				{
+					str[i] = 0;
+					return i;
+				}
+				str[i] = strIn[i];
+			}
+			str[copyLen] = '\0';
+			return copyLen;
+		}
+	}
+}
diff --git a/src/Cafe/OS/libs/nn_olv/nn_olv_DownloadCommunityTypes.cpp b/src/Cafe/OS/libs/nn_olv/nn_olv_DownloadCommunityTypes.cpp
new file mode 100644
index 00000000..6e7632e9
--- /dev/null
+++ b/src/Cafe/OS/libs/nn_olv/nn_olv_DownloadCommunityTypes.cpp
@@ -0,0 +1,234 @@
+#include "nn_olv_DownloadCommunityTypes.h"
+
+namespace nn
+{
+	namespace olv
+	{
+
+		sint32 DownloadCommunityDataList_AsyncRequestImpl(
+			CurlRequestHelper& req, const char* reqUrl,
+			DownloadedCommunityData* pOutList, uint32* pOutNum, uint32 numMaxList, const DownloadCommunityDataListParam* pParam);
+
+
+		sint32 DownloadCommunityDataList_AsyncRequest(
+			CurlRequestHelper& req, const char* reqUrl, coreinit::OSEvent* requestDoneEvent,
+			DownloadedCommunityData* pOutList, uint32* pOutNum, uint32 numMaxList, const DownloadCommunityDataListParam* pParam
+		)
+		{
+			sint32 res = DownloadCommunityDataList_AsyncRequestImpl(req, reqUrl, pOutList, pOutNum, numMaxList, pParam);
+			coreinit::OSSignalEvent(requestDoneEvent);
+			return res;
+		}
+
+		sint32 DownloadCommunityDataList(DownloadedCommunityData* pOutList, uint32* pOutNum, uint32 numMaxList, const DownloadCommunityDataListParam* pParam)
+		{
+			if (!g_IsInitialized)
+				return OLV_RESULT_NOT_INITIALIZED;
+
+			if (!g_IsOnlineMode)
+				return OLV_RESULT_OFFLINE_MODE_REQUEST;
+
+			if (!pOutList || !pOutNum || !pParam)
+				return OLV_RESULT_INVALID_PTR;
+
+			if (!numMaxList)
+				return OLV_RESULT_NOT_ENOUGH_SIZE;
+
+			for (int i = 0; i < numMaxList; i++)
+				DownloadedCommunityData::Clean(&pOutList[i]);
+
+			char reqUrl[2048];
+			sint32 res = pParam->GetRawDataUrl(reqUrl, sizeof(reqUrl));
+			if (res < 0)
+				return res;
+
+			CurlRequestHelper req;
+			req.initate(ActiveSettings::GetNetworkService(), reqUrl, CurlRequestHelper::SERVER_SSL_CONTEXT::OLIVE);
+			InitializeOliveRequest(req);
+
+			StackAllocator<coreinit::OSEvent> requestDoneEvent;
+			coreinit::OSInitEvent(&requestDoneEvent, coreinit::OSEvent::EVENT_STATE::STATE_NOT_SIGNALED, coreinit::OSEvent::EVENT_MODE::MODE_MANUAL);
+			std::future<sint32> requestRes = std::async(std::launch::async, DownloadCommunityDataList_AsyncRequest,
+				std::ref(req), reqUrl, requestDoneEvent.GetPointer(), pOutList, pOutNum, numMaxList, pParam);
+			coreinit::OSWaitEvent(&requestDoneEvent);
+
+			return requestRes.get();	
+		}
+
+		sint32 DownloadCommunityDataList_AsyncRequestImpl(
+			CurlRequestHelper& req, const char* reqUrl,
+			DownloadedCommunityData* pOutList, uint32* pOutNum, uint32 numMaxList, const DownloadCommunityDataListParam* pParam
+		)
+		{
+
+			bool reqResult = req.submitRequest();
+			long httpCode = 0;
+			curl_easy_getinfo(req.getCURL(), CURLINFO_RESPONSE_CODE, &httpCode);
+
+
+			if (!reqResult)
+			{
+				cemuLog_log(LogType::Force, "Failed request: {} ({})", reqUrl, httpCode);
+				if (!(httpCode >= 400))
+					return OLV_RESULT_FAILED_REQUEST;
+			}
+
+			pugi::xml_document doc;
+			if (!doc.load_buffer(req.getReceivedData().data(), req.getReceivedData().size()))
+			{
+				cemuLog_log(LogType::Force, fmt::format("Invalid XML in community download response"));
+				return OLV_RESULT_INVALID_XML;
+			}
+
+			sint32 responseError = CheckOliveResponse(doc);
+			if (responseError < 0)
+				return responseError;
+
+			if (httpCode != 200)
+				return OLV_RESULT_STATUS(httpCode + 4000);
+
+			std::string request_name = doc.select_single_node("//request_name").node().child_value();
+			if (request_name.size() == 0)
+			{
+				cemuLog_log(LogType::Force, "Community download response doesn't contain <request_name>");
+				return OLV_RESULT_INVALID_XML;
+			}
+
+			if ((request_name.compare("communities") != 0) && (request_name.compare("specified_communities") != 0))
+			{
+				cemuLog_log(LogType::Force, "Community download response <request_name> isn't \"communities\" or \"specified_communities\"");
+				return OLV_RESULT_INVALID_XML;
+			}
+
+			pugi::xml_node communities = doc.select_single_node("//communities").node();
+			if (!communities)
+			{
+				cemuLog_log(LogType::Force, "Community download response doesn't contain <communities>");
+				return OLV_RESULT_INVALID_XML;
+			}
+
+			int idx = 0;
+			for (pugi::xml_node communityNode : communities.children("community"))
+			{
+				if (idx >= numMaxList)
+					break;
+
+				DownloadedCommunityData* pOutData = &pOutList[idx];
+
+				std::string_view app_data = communityNode.child_value("app_data");
+				std::string_view community_id = communityNode.child_value("community_id");
+				std::string_view name = communityNode.child_value("name");
+				std::string_view description = communityNode.child_value("description");
+				std::string_view pid = communityNode.child_value("pid");
+				std::string_view icon = communityNode.child_value("icon");
+				std::string_view mii = communityNode.child_value("mii");
+				std::string_view screen_name = communityNode.child_value("screen_name");
+
+				if (app_data.size() != 0)
+				{
+					auto app_data_bin = NCrypto::base64Decode(app_data);
+					if (app_data_bin.size() != 0)
+					{
+						memcpy(pOutData->appData, app_data_bin.data(), std::min(size_t(0x400), app_data_bin.size()));
+						pOutData->flags |= DownloadedCommunityData::FLAG_HAS_APP_DATA;
+						pOutData->appDataLen = app_data_bin.size();
+					}
+					else
+						return OLV_RESULT_INVALID_TEXT_FIELD;
+				}
+
+				sint64 community_id_val = StringHelpers::ToInt64(community_id, -1);
+				if (community_id_val == -1)
+					return OLV_RESULT_INVALID_INTEGER_FIELD;
+
+				pOutData->communityId = community_id_val;
+
+				if (name.size() != 0)
+				{
+					auto name_utf16 = StringHelpers::FromUtf8(name);
+					name_utf16.resize(std::min<size_t>(name_utf16.size(), 128));
+					if (name_utf16.size() != 0)
+					{
+						for (int i = 0; i < name_utf16.size(); i++)
+							pOutData->titleText[i] = name_utf16.at(i).bevalue();
+
+						pOutData->flags |= DownloadedCommunityData::FLAG_HAS_TITLE_TEXT;
+						pOutData->titleTextMaxLen = name_utf16.size();
+					}
+					else
+						return OLV_RESULT_INVALID_TEXT_FIELD;
+				}
+
+				if (description.size() != 0)
+				{
+					auto description_utf16 = StringHelpers::FromUtf8(description);
+					description_utf16.resize(std::min<size_t>(description_utf16.size(), 256));
+					if (description_utf16.size() != 0)
+					{
+						for (int i = 0; i < description_utf16.size(); i++)
+							pOutData->description[i] = description_utf16.at(i).bevalue();
+
+						pOutData->flags |= DownloadedCommunityData::FLAG_HAS_DESC_TEXT;
+						pOutData->descriptionMaxLen = description_utf16.size();
+					}
+					else
+						return OLV_RESULT_INVALID_TEXT_FIELD;
+				}
+
+				sint64 pid_val = StringHelpers::ToInt64(pid, -1);
+				if (pid_val == -1)
+					return OLV_RESULT_INVALID_INTEGER_FIELD;
+
+				pOutData->pid = pid_val;
+
+				if (icon.size() != 0)
+				{
+					auto icon_bin = NCrypto::base64Decode(icon);
+					if (icon_bin.size() != 0)
+					{
+						memcpy(pOutData->iconData, icon_bin.data(), std::min(size_t(0x1002c), icon_bin.size()));
+						pOutData->flags |= DownloadedCommunityData::FLAG_HAS_ICON_DATA;
+						pOutData->iconDataSize = icon_bin.size();
+					}
+					else
+						return OLV_RESULT_INVALID_TEXT_FIELD;
+				}
+
+				if (mii.size() != 0)
+				{
+					auto mii_bin = NCrypto::base64Decode(mii);
+					if (mii_bin.size() != 0)
+					{
+						memcpy(pOutData->miiFFLStoreData, mii_bin.data(), std::min(size_t(96), mii_bin.size()));
+						pOutData->flags |= DownloadedCommunityData::FLAG_HAS_MII_DATA;
+					}
+					else
+						return OLV_RESULT_INVALID_TEXT_FIELD;
+				}
+
+				if (screen_name.size() != 0)
+				{
+					auto screen_name_utf16 = StringHelpers::FromUtf8(screen_name);
+					screen_name_utf16.resize(std::min<size_t>(screen_name_utf16.size(), 32));
+					if (screen_name_utf16.size() != 0)
+					{
+						for (int i = 0; i < screen_name_utf16.size(); i++)
+							pOutData->miiDisplayName[i] = screen_name_utf16.at(i).bevalue();
+					}
+					else
+						return OLV_RESULT_INVALID_TEXT_FIELD;
+				}
+
+				idx++;
+
+			}
+
+			*pOutNum = _swapEndianU32(idx);
+			sint32 res = OLV_RESULT_SUCCESS;
+			if (idx > 0)
+				res = 0; // nn_olv doesn't do it like that, but it's the same effect. I have no clue why it returns 0 when you have 1+ communities downloaded
+
+			return res;
+		}
+	}
+}
\ No newline at end of file
diff --git a/src/Cafe/OS/libs/nn_olv/nn_olv_DownloadCommunityTypes.h b/src/Cafe/OS/libs/nn_olv/nn_olv_DownloadCommunityTypes.h
new file mode 100644
index 00000000..794195a1
--- /dev/null
+++ b/src/Cafe/OS/libs/nn_olv/nn_olv_DownloadCommunityTypes.h
@@ -0,0 +1,530 @@
+#pragma once
+
+#include "Cemu/ncrypto/ncrypto.h"
+#include "config/ActiveSettings.h"
+
+#include "Cafe/OS/libs/nn_olv/nn_olv_Common.h"
+
+namespace nn
+{
+	namespace olv
+	{
+
+		class DownloadedCommunityData
+		{
+		public:
+			static const inline uint32 FLAG_HAS_TITLE_TEXT = (1 << 0);
+			static const inline uint32 FLAG_HAS_DESC_TEXT = (1 << 1);
+			static const inline uint32 FLAG_HAS_APP_DATA = (1 << 2);
+			static const inline uint32 FLAG_HAS_ICON_DATA = (1 << 3);
+			static const inline uint32 FLAG_HAS_MII_DATA = (1 << 4);
+
+			DownloadedCommunityData()
+			{
+				this->titleTextMaxLen = 0;
+				this->appDataLen = 0;
+				this->descriptionMaxLen = 0;
+				this->pid = 0;
+				this->communityId = 0;
+				this->flags = 0;
+				this->iconDataSize = 0;
+				this->miiDisplayName[0] = 0;
+			}
+			static DownloadedCommunityData* __ctor(DownloadedCommunityData* _this)
+			{
+				if (!_this)
+				{
+					assert_dbg(); // DO NOT CONTINUE, SHOULD NEVER HAPPEN
+					return nullptr;
+				}
+				else
+					return new (_this) DownloadedCommunityData();
+			}
+
+			static DownloadedCommunityData* Clean(DownloadedCommunityData* data)
+			{
+				data->flags = 0;
+				data->communityId = 0;
+				data->pid = 0;
+				data->iconData[0] = 0;
+				data->titleTextMaxLen = 0;
+				data->appData[0] = 0;
+				data->appDataLen = 0;
+				data->description[0] = 0;
+				data->descriptionMaxLen = 0;
+				data->iconDataSize = 0;
+				data->titleText[0] = 0;
+				data->miiDisplayName[0] = 0;
+				return data;
+			}
+
+			bool TestFlags(uint32 flags) const
+			{
+				return (this->flags & flags) != 0;
+			}
+			static bool __TestFlags(DownloadedCommunityData* _this, uint32 flags)
+			{
+				return _this->TestFlags(flags);
+			}
+
+			uint32 GetCommunityId() const
+			{
+				return this->communityId;
+			}
+			static uint32 __GetCommunityId(DownloadedCommunityData* _this)
+			{
+				return _this->GetCommunityId();
+			}
+
+			sint32 GetCommunityCode(char* pBuffer, uint32 bufferSize) const
+			{
+				if (!pBuffer)
+					return OLV_RESULT_INVALID_PTR;
+
+				if (bufferSize <= 12)
+					return OLV_RESULT_NOT_ENOUGH_SIZE;
+
+				uint32 len = 0;
+				if (FormatCommunityCode(pBuffer, &len, this->communityId))
+					return OLV_RESULT_SUCCESS;
+
+				return OLV_RESULT_INVALID_PARAMETER;
+			}
+			static sint32 __GetCommunityCode(DownloadedCommunityData* _this, char* pBuffer, uint32 bufferSize)
+			{
+				return _this->GetCommunityCode(pBuffer, bufferSize);
+			}
+
+			uint32 GetOwnerPid() const
+			{
+				return this->pid;
+			}
+			static uint32 __GetOwnerPid(DownloadedCommunityData* _this)
+			{
+				return _this->GetOwnerPid();
+			}
+
+			sint32 GetTitleText(char16_t* pBuffer, uint32 numChars)
+			{
+				if (!pBuffer)
+					return OLV_RESULT_INVALID_PTR;
+
+				if (numChars)
+				{
+					if (!this->TestFlags(FLAG_HAS_TITLE_TEXT))
+						return OLV_RESULT_MISSING_DATA;
+
+					memset(pBuffer, 0, 2 * numChars);
+					uint32 readSize = this->titleTextMaxLen;
+					if (numChars < readSize)
+						readSize = numChars;
+
+					olv_wstrncpy(pBuffer, this->titleText, readSize);
+					return OLV_RESULT_SUCCESS;
+				}
+
+				return OLV_RESULT_NOT_ENOUGH_SIZE;
+			}
+			static sint32 __GetTitleText(DownloadedCommunityData* _this, char16_t* pBuffer, uint32 numChars)
+			{
+				return _this->GetTitleText(pBuffer, numChars);
+			}
+
+			sint32 GetDescriptionText(char16_t* pBuffer, uint32 numChars)
+			{
+				if (!pBuffer)
+					return OLV_RESULT_INVALID_PTR;
+
+				if (numChars)
+				{
+					if (!this->TestFlags(FLAG_HAS_DESC_TEXT))
+						return OLV_RESULT_MISSING_DATA;
+
+					memset(pBuffer, 0, 2 * numChars);
+					olv_wstrncpy(pBuffer, this->description, numChars);
+					return OLV_RESULT_SUCCESS;
+				}
+
+				return OLV_RESULT_NOT_ENOUGH_SIZE;
+			}
+			static sint32 __GetDescriptionText(DownloadedCommunityData* _this, char16_t* pBuffer, uint32 numChars)
+			{
+				return _this->GetDescriptionText(pBuffer, numChars);
+			}
+
+			sint32 GetAppData(uint8* pBuffer, uint32be* pOutSize, uint32 bufferSize)
+			{
+				uint32 appDataSize = bufferSize;
+				if (!pBuffer)
+					return OLV_RESULT_INVALID_PTR;
+
+				if (bufferSize)
+				{
+					if (!this->TestFlags(FLAG_HAS_APP_DATA))
+						return OLV_RESULT_MISSING_DATA;
+
+					if (this->appDataLen < appDataSize)
+						appDataSize = this->appDataLen;
+
+					memcpy(pBuffer, this->appData, appDataSize);
+					if (pOutSize)
+						*pOutSize = appDataSize;
+
+					return OLV_RESULT_SUCCESS;
+				}
+
+				return OLV_RESULT_NOT_ENOUGH_SIZE;
+			}
+			static sint32 __GetAppData(DownloadedCommunityData* _this, uint8* pBuffer, uint32be* pOutSize, uint32 bufferSize)
+			{
+				return _this->GetAppData(pBuffer, pOutSize, bufferSize);
+			}
+
+			uint32 GetAppDataSize() const
+			{
+				if (this->TestFlags(FLAG_HAS_APP_DATA))
+					return this->appDataLen;
+
+				return 0;
+			}
+			static uint32 __GetAppDataSize(DownloadedCommunityData* _this)
+			{
+				return _this->GetAppDataSize();
+			}
+
+			sint32 GetIconData(uint8* pBuffer, uint32be* pOutSize, uint32 bufferSize)
+			{
+				if (!pBuffer)
+					return OLV_RESULT_INVALID_PTR;
+
+				if (bufferSize < sizeof(this->iconData))
+					return OLV_RESULT_NOT_ENOUGH_SIZE;
+
+				if (!this->TestFlags(FLAG_HAS_ICON_DATA))
+					return OLV_RESULT_MISSING_DATA;
+
+				sint32 decodeRes = DecodeTGA(this->iconData, this->iconDataSize, pBuffer, bufferSize, TGACheckType::CHECK_COMMUNITY_ICON);
+				if (decodeRes >= 0)
+				{
+					if (pOutSize)
+						*pOutSize = (uint32)decodeRes;
+
+					return OLV_RESULT_SUCCESS;
+				}
+
+				if (pOutSize)
+					*pOutSize = 0;
+
+				if (decodeRes == -1)
+					cemuLog_log(LogType::Force, "OLIVE - icon uncompress failed.\n");
+				else if (decodeRes == -2)
+					cemuLog_log(LogType::Force, "OLIVE - icon decode error. NOT TGA.\n");
+
+				return OLV_RESULT_INVALID_TEXT_FIELD;
+			}
+			static sint32 __GetIconData(DownloadedCommunityData* _this, uint8* pBuffer, uint32be* pOutSize, uint32 bufferSize)
+			{
+				return _this->GetIconData(pBuffer, pOutSize, bufferSize);
+			}
+
+			sint32 GetOwnerMiiData(/* FFLStoreData* */void* pBuffer) const
+			{
+				if (!this->TestFlags(FLAG_HAS_MII_DATA))
+					return OLV_RESULT_MISSING_DATA;
+
+				if (!pBuffer)
+					return OLV_RESULT_INVALID_PTR;
+
+				memcpy(pBuffer, this->miiFFLStoreData, sizeof(this->miiFFLStoreData));
+				return OLV_RESULT_SUCCESS;
+			}
+			static sint32 __GetOwnerMiiData(DownloadedCommunityData* _this, /* FFLStoreData* */void* pBuffer)
+			{
+				return _this->GetOwnerMiiData(pBuffer);
+			}
+
+			const char16_t* GetOwnerMiiNickname() const
+			{
+				if (this->miiDisplayName[0])
+					return this->miiDisplayName;
+
+				return nullptr;
+			}
+			static const char16_t* __GetOwnerMiiNickname(DownloadedCommunityData* _this)
+			{
+				return _this->GetOwnerMiiNickname();
+			}
+
+		public:
+			uint32be flags;
+			uint32be communityId;
+			uint32be pid;
+			char16_t titleText[128];
+			uint32be titleTextMaxLen;
+			char16_t description[256];
+			uint32be descriptionMaxLen;
+			uint8 appData[1024];
+			uint32be appDataLen;
+			uint8 iconData[65580];
+			uint32be iconDataSize;
+			uint8 miiFFLStoreData[96];
+			char16_t miiDisplayName[32];
+			uint8 unk[6168];
+		};
+		static_assert(sizeof(nn::olv::DownloadedCommunityData) == 0x12000, "sizeof(nn::olv::DownloadedCommunityData) != 0x12000");
+
+		class DownloadCommunityDataListParam
+		{
+		public:
+			static const inline uint32 FLAG_FILTER_FAVORITES = (1 << 0);
+			static const inline uint32 FLAG_FILTER_OFFICIALS = (1 << 1);
+			static const inline uint32 FLAG_FILTER_OWNED = (1 << 2);
+			static const inline uint32 FLAG_QUERY_MII_DATA = (1 << 3);
+			static const inline uint32 FLAG_QUERY_ICON_DATA = (1 << 4);
+
+			DownloadCommunityDataListParam()
+			{
+				this->flags = 0;
+				this->communityDownloadLimit = 0;
+				this->communityId = 0;
+
+				for (int i = 0; i < 20; i++)
+					this->additionalCommunityIdList[i] = -2;
+			}
+			static DownloadCommunityDataListParam* __ctor(DownloadCommunityDataListParam* _this)
+			{
+				if (!_this)
+				{
+					assert_dbg(); // DO NOT CONTINUE, SHOULD NEVER HAPPEN
+					return nullptr;
+				}
+				else
+					return new (_this) DownloadCommunityDataListParam();
+			}
+
+			sint32 SetFlags(uint32 flags)
+			{
+				this->flags = flags;
+				return OLV_RESULT_SUCCESS;
+			}
+			static sint32 __SetFlags(DownloadCommunityDataListParam* _this, uint32 flags)
+			{
+				return _this->SetFlags(flags);
+			}
+
+			sint32 SetCommunityId(uint32 communityId)
+			{
+				if (communityId == -1)
+					return OLV_RESULT_INVALID_PARAMETER;
+
+				this->communityId = communityId;
+				if (communityId)
+				{
+					if (!this->communityDownloadLimit)
+						this->communityDownloadLimit = 1;
+				}
+
+				return OLV_RESULT_SUCCESS;
+			}
+			static sint32 __SetCommunityId(DownloadCommunityDataListParam* _this, uint32 communityId)
+			{
+				return _this->SetCommunityId(communityId);
+			}
+
+			sint32 SetCommunityId(uint32 communityId, uint8 idx)
+			{
+				if (communityId == -1)
+					return OLV_RESULT_INVALID_PARAMETER;
+
+				if (idx >= 20)
+					return OLV_RESULT_INVALID_PARAMETER;
+
+				this->additionalCommunityIdList[idx] = communityId;
+				int validIdsCount = 0;
+				for (int i = 0; i < 20; i++ )
+				{
+					if (this->additionalCommunityIdList[i] != -2)
+						++validIdsCount;
+				}
+
+				if (validIdsCount > this->communityDownloadLimit)
+					this->communityDownloadLimit = validIdsCount;
+
+				return OLV_RESULT_SUCCESS;
+			}
+			static sint32 __SetCommunityId(DownloadCommunityDataListParam* _this, uint32 communityId, uint8 idx)
+			{
+				return _this->SetCommunityId(communityId, idx);
+			}
+
+			sint32 SetCommunityDataMaxNum(uint32 num)
+			{
+				if (!num)
+					return OLV_RESULT_INVALID_PARAMETER;
+
+				int validIdsCount = 0;
+				for (int i = 0; i < 20; ++i)
+				{
+					if (this->additionalCommunityIdList[i] != -2)
+						++validIdsCount;
+				}
+
+				if (validIdsCount > num)
+					return OLV_RESULT_INVALID_PARAMETER;
+
+				this->communityDownloadLimit = num;
+				return OLV_RESULT_SUCCESS;
+			}
+			static sint32 __SetCommunityDataMaxNum(DownloadCommunityDataListParam* _this, uint32 num)
+			{
+				return _this->SetCommunityDataMaxNum(num);
+			}
+
+			sint32 GetRawDataUrl(char* pBuffer, uint32 bufferSize) const
+			{
+				if (!g_IsOnlineMode)
+					return OLV_RESULT_OFFLINE_MODE_REQUEST;
+
+				if (!pBuffer)
+					return OLV_RESULT_INVALID_PTR;
+
+				if (!bufferSize)
+					return OLV_RESULT_NOT_ENOUGH_SIZE;
+
+				char tmpFormatBuffer[64];
+				char urlBuffer[1024];
+				memset(urlBuffer, 0, sizeof(urlBuffer));
+
+				uint32 communityId;
+				int validIdsCount = 0;
+				for (int i = 0; i < 20; ++i)
+				{
+					if (this->additionalCommunityIdList[i] != -2)
+					{
+						communityId = this->additionalCommunityIdList[i];
+						++validIdsCount;
+					}
+				}
+
+				if (validIdsCount)
+				{
+					if (this->communityId && this->communityId != -2)
+						return OLV_RESULT_INVALID_PARAMETER;
+
+					uint32 unkFlag = this->flags & 0xFFFFFFE7;
+					if (unkFlag)
+						return OLV_RESULT_INVALID_PARAMETER;
+
+					// It's how it's done in the real nn_olv, what even the fuck is this, never seen used yet.
+					snprintf(urlBuffer, sizeof(urlBuffer), "%s/v1/communities/%u.search", g_DiscoveryResults.apiEndpoint, communityId);
+
+					for (int i = 0; i < 20; ++i)
+					{
+						if (this->additionalCommunityIdList[i] != -2)
+						{
+							snprintf(tmpFormatBuffer, 64, "community_id=%u", this->additionalCommunityIdList[i].value());
+							appendQueryToURL(urlBuffer, tmpFormatBuffer);
+							++unkFlag;
+						}
+					}
+				}
+				else
+					snprintf(urlBuffer, sizeof(urlBuffer), "%s/v1/communities", g_DiscoveryResults.apiEndpoint);
+
+				if (this->communityId)
+				{
+					snprintf(tmpFormatBuffer, 64, "community_id=%u", this->communityId.value());
+					appendQueryToURL(urlBuffer, tmpFormatBuffer);
+				}
+				else
+				{
+					uint32 filterBy_favorite = (this->flags & FLAG_FILTER_FAVORITES) != 0;
+					uint32 filterBy_official = (this->flags & FLAG_FILTER_OFFICIALS) != 0;
+					uint32 filterBy_selfmade = (this->flags & FLAG_FILTER_OWNED) != 0;
+				
+					if ((filterBy_favorite + filterBy_official + filterBy_selfmade) != 1)
+						return OLV_RESULT_INVALID_PARAMETER;
+
+					snprintf(tmpFormatBuffer, 64, "limit=%u", this->communityDownloadLimit.value());
+					appendQueryToURL(urlBuffer, tmpFormatBuffer);
+
+					if (filterBy_favorite)
+					{
+						strncpy(tmpFormatBuffer, "type=favorite", 64);
+						appendQueryToURL(urlBuffer, tmpFormatBuffer);
+					}
+					else if (filterBy_official)
+					{
+						strncpy(tmpFormatBuffer, "type=official", 64);
+						appendQueryToURL(urlBuffer, tmpFormatBuffer);
+					}
+					else
+					{
+						strncpy(tmpFormatBuffer, "type=my", 64);
+						appendQueryToURL(urlBuffer, tmpFormatBuffer);
+					}
+				}
+
+				if (this->flags & FLAG_QUERY_MII_DATA)
+				{
+					strncpy(tmpFormatBuffer, "with_mii=1", 64);
+					appendQueryToURL(urlBuffer, tmpFormatBuffer);
+				}
+
+				if (this->flags & FLAG_QUERY_ICON_DATA)
+				{
+					strncpy(tmpFormatBuffer, "with_icon=1", 64);
+					appendQueryToURL(urlBuffer, tmpFormatBuffer);
+				}
+
+				int res = snprintf(pBuffer, bufferSize, "%s", urlBuffer);
+				if (res < 0)
+					return OLV_RESULT_NOT_ENOUGH_SIZE;
+
+				return OLV_RESULT_SUCCESS;
+			}
+			static sint32 __GetRawDataUrl(DownloadCommunityDataListParam* _this, char* pBuffer, uint32 bufferSize)
+			{
+				return _this->GetRawDataUrl(pBuffer, bufferSize);
+			}
+
+		public:
+			uint32be flags;
+			uint32be communityId;
+			uint32be communityDownloadLimit;
+			uint32be additionalCommunityIdList[20]; // Additional community ID filter list
+			uint8 unk[4004]; // Looks unused lol, probably reserved data
+		};
+		static_assert(sizeof(nn::olv::DownloadCommunityDataListParam) == 0x1000, "sizeof(nn::olv::DownloadCommunityDataListParam) != 0x1000");
+
+		sint32 DownloadCommunityDataList(DownloadedCommunityData* pOutList, uint32* pOutNum, uint32 numMaxList, const DownloadCommunityDataListParam* pParam);
+
+		static void loadOliveDownloadCommunityTypes()
+		{
+			cafeExportRegisterFunc(DownloadedCommunityData::__ctor, "nn_olv", "__ct__Q3_2nn3olv23DownloadedCommunityDataFv", LogType::NN_OLV);
+			cafeExportRegisterFunc(DownloadedCommunityData::__TestFlags, "nn_olv", "TestFlags__Q3_2nn3olv23DownloadedCommunityDataCFUi", LogType::NN_OLV);
+			cafeExportRegisterFunc(DownloadedCommunityData::__GetCommunityId, "nn_olv", "GetCommunityId__Q3_2nn3olv23DownloadedCommunityDataCFv", LogType::NN_OLV);
+			cafeExportRegisterFunc(DownloadedCommunityData::__GetCommunityCode, "nn_olv", "GetCommunityCode__Q3_2nn3olv23DownloadedCommunityDataCFPcUi", LogType::NN_OLV);
+			cafeExportRegisterFunc(DownloadedCommunityData::__GetOwnerPid, "nn_olv", "GetOwnerPid__Q3_2nn3olv23DownloadedCommunityDataCFv", LogType::NN_OLV);
+			cafeExportRegisterFunc(DownloadedCommunityData::__GetTitleText, "nn_olv", "GetTitleText__Q3_2nn3olv23DownloadedCommunityDataCFPwUi", LogType::NN_OLV);
+			cafeExportRegisterFunc(DownloadedCommunityData::__GetDescriptionText, "nn_olv", "GetDescriptionText__Q3_2nn3olv23DownloadedCommunityDataCFPwUi", LogType::NN_OLV);
+			cafeExportRegisterFunc(DownloadedCommunityData::__GetAppData, "nn_olv", "GetAppData__Q3_2nn3olv23DownloadedCommunityDataCFPUcPUiUi", LogType::NN_OLV);
+			cafeExportRegisterFunc(DownloadedCommunityData::__GetAppDataSize, "nn_olv", "GetAppDataSize__Q3_2nn3olv23DownloadedCommunityDataCFv", LogType::NN_OLV);
+			cafeExportRegisterFunc(DownloadedCommunityData::__GetIconData, "nn_olv", "GetIconData__Q3_2nn3olv23DownloadedCommunityDataCFPUcPUiUi", LogType::NN_OLV);
+			cafeExportRegisterFunc(DownloadedCommunityData::__GetOwnerMiiData, "nn_olv", "GetOwnerMiiData__Q3_2nn3olv23DownloadedCommunityDataCFP12FFLStoreData", LogType::NN_OLV);
+			cafeExportRegisterFunc(DownloadedCommunityData::__GetOwnerMiiNickname, "nn_olv", "GetOwnerMiiNickname__Q3_2nn3olv23DownloadedCommunityDataCFv", LogType::NN_OLV);
+
+			cafeExportRegisterFunc(DownloadCommunityDataListParam::__ctor, "nn_olv", "__ct__Q3_2nn3olv30DownloadCommunityDataListParamFv", LogType::NN_OLV);
+			cafeExportRegisterFunc(DownloadCommunityDataListParam::__SetFlags, "nn_olv", "SetFlags__Q3_2nn3olv30DownloadCommunityDataListParamFUi", LogType::NN_OLV);
+			cafeExportRegisterFunc(DownloadCommunityDataListParam::__SetCommunityDataMaxNum, "nn_olv", "SetCommunityDataMaxNum__Q3_2nn3olv30DownloadCommunityDataListParamFUi", LogType::NN_OLV);
+			cafeExportRegisterFunc(DownloadCommunityDataListParam::__GetRawDataUrl, "nn_olv", "GetRawDataUrl__Q3_2nn3olv30DownloadCommunityDataListParamCFPcUi", LogType::NN_OLV);
+
+			cafeExportRegisterFunc((sint32 (*)(DownloadCommunityDataListParam*, uint32))DownloadCommunityDataListParam::__SetCommunityId,
+				"nn_olv", "SetCommunityId__Q3_2nn3olv30DownloadCommunityDataListParamFUi", LogType::NN_OLV);
+			cafeExportRegisterFunc((sint32(*)(DownloadCommunityDataListParam*, uint32, uint8))DownloadCommunityDataListParam::__SetCommunityId,
+				"nn_olv", "SetCommunityId__Q3_2nn3olv30DownloadCommunityDataListParamFUiUc", LogType::NN_OLV);
+		
+			cafeExportRegisterFunc(DownloadCommunityDataList, "nn_olv", "DownloadCommunityDataList__Q2_2nn3olvFPQ3_2nn3olv23DownloadedCommunityDataPUiUiPCQ3_2nn3olv30DownloadCommunityDataListParam", LogType::NN_OLV);
+		}
+	}
+}
\ No newline at end of file
diff --git a/src/Cafe/OS/libs/nn_olv/nn_olv_InitializeTypes.cpp b/src/Cafe/OS/libs/nn_olv/nn_olv_InitializeTypes.cpp
new file mode 100644
index 00000000..ba657ff7
--- /dev/null
+++ b/src/Cafe/OS/libs/nn_olv/nn_olv_InitializeTypes.cpp
@@ -0,0 +1,300 @@
+#pragma once
+
+#include "nn_olv_InitializeTypes.h"
+#include "CafeSystem.h"
+#include "Cafe/OS/libs/nn_act/nn_act.h"
+#include <time.h>
+
+namespace nn
+{
+	namespace olv
+	{
+		uint32_t g_ReportTypes = 0;
+		bool g_IsOnlineMode = false;
+		bool g_IsInitialized = false;
+		bool g_IsOfflineDBMode = false;
+		ParamPackStorage g_ParamPack;
+		DiscoveryResultStorage g_DiscoveryResults;
+
+		sint32 GetOlvAccessKey(uint32_t* pOutKey)
+		{
+			*pOutKey = 0;
+			uint32_t accessKey = CafeSystem::GetForegroundTitleOlvAccesskey();
+			if (accessKey == -1)
+				return OLV_RESULT_STATUS(1102);
+
+			*pOutKey = accessKey;
+			return OLV_RESULT_SUCCESS;
+		}
+
+		sint32 CreateParamPack(uint64_t titleId, uint32_t accessKey)
+		{
+			g_ParamPack.languageId = uint8(GetConfig().console_language.GetValue());
+
+			uint32be simpleAddress = 0;
+			nn::act::GetSimpleAddressIdEx(&simpleAddress, nn::act::ACT_SLOT_CURRENT);
+			uint32 countryCode = nn::act::getCountryCodeFromSimpleAddress(simpleAddress);
+
+			g_ParamPack.countryId = countryCode;
+			g_ParamPack.titleId = titleId;
+			g_ParamPack.platformId = 1;
+
+			g_ParamPack.areaId = (simpleAddress >> 8) & 0xff;
+
+			MCPHANDLE handle = MCP_Open();
+			SysProdSettings sysProdSettings;
+			MCP_GetSysProdSettings(handle, &sysProdSettings);
+			MCP_Close(handle);
+
+			g_ParamPack.regionId = sysProdSettings.platformRegion;
+			g_ParamPack.accessKey = accessKey;
+
+			g_ParamPack.networkRestriction = 0;
+			g_ParamPack.friendRestriction = 0;
+			g_ParamPack.ratingRestriction = 18;
+			g_ParamPack.ratingOrganization = 4; // PEGI ?
+
+			uint64 transferrableId;
+			nn::act::GetTransferableIdEx(&transferrableId, (titleId >> 8) & 0xFFFFF, nn::act::ACT_SLOT_CURRENT);
+			g_ParamPack.transferableId = transferrableId;
+
+			strcpy(g_ParamPack.tzName, "CEMU/Olive"); // Should be nn::act::GetTimeZoneId
+			g_ParamPack.utcOffset = (uint64_t)nn::act::GetUtcOffset() / 1'000'000;
+
+			char paramPackStr[1024];
+			snprintf(
+				paramPackStr,
+				sizeof(paramPackStr),
+				"\\%s\\%llu\\%s\\%u\\%s\\%u\\%s\\%d\\%s\\%d\\%s\\%d\\%s\\%d\\%s\\%d\\%s\\%d\\%s\\%u\\%s\\%d\\%s\\%llu\\"
+				"%s\\%s\\%s\\%lld\\",
+				"title_id",
+				g_ParamPack.titleId,
+				"access_key",
+				g_ParamPack.accessKey,
+				"platform_id",
+				g_ParamPack.platformId,
+				"region_id",
+				g_ParamPack.regionId,
+				"language_id",
+				g_ParamPack.languageId,
+				"country_id",
+				g_ParamPack.countryId,
+				"area_id",
+				g_ParamPack.areaId,
+				"network_restriction",
+				g_ParamPack.networkRestriction,
+				"friend_restriction",
+				g_ParamPack.friendRestriction,
+				"rating_restriction",
+				g_ParamPack.ratingRestriction,
+				"rating_organization",
+				g_ParamPack.ratingOrganization,
+				"transferable_id",
+				g_ParamPack.transferableId,
+				"tz_name",
+				g_ParamPack.tzName,
+				"utc_offset",
+				g_ParamPack.utcOffset);
+			std::string encodedParamPack = NCrypto::base64Encode(paramPackStr, strnlen(paramPackStr, 1024));
+			memset(&g_ParamPack.encodedParamPack, 0, sizeof(g_ParamPack.encodedParamPack));
+			memcpy(&g_ParamPack.encodedParamPack, encodedParamPack.data(), encodedParamPack.size());
+
+			return OLV_RESULT_SUCCESS;
+		}
+
+		sint32 MakeDiscoveryRequest_AsyncRequestImpl(CurlRequestHelper& req, const char* reqUrl)
+		{
+			bool reqResult = req.submitRequest();
+			long httpCode = 0;
+			curl_easy_getinfo(req.getCURL(), CURLINFO_RESPONSE_CODE, &httpCode);
+			if (!reqResult)
+			{
+				cemuLog_log(LogType::Force, "Failed request: {} ({})", reqUrl, httpCode);
+				if (!(httpCode >= 400))
+					return OLV_RESULT_FAILED_REQUEST;
+			}
+
+			pugi::xml_document doc;
+			if (!doc.load_buffer(req.getReceivedData().data(), req.getReceivedData().size()))
+			{
+				cemuLog_log(LogType::Force, fmt::format("Invalid XML in discovery service response"));
+				return OLV_RESULT_INVALID_XML;
+			}
+
+			sint32 responseError = CheckOliveResponse(doc);
+			if (responseError < 0)
+				return responseError;
+
+			if (httpCode != 200)
+				return OLV_RESULT_STATUS(httpCode + 4000);
+
+
+			/*
+				<result>
+					<has_error>0</has_error>
+					<version>1</version>
+					<endpoint>
+						<host>api.olv.pretendo.cc</host>
+						<api_host>api.olv.pretendo.cc</api_host>
+						<portal_host>portal.olv.pretendo.cc</portal_host>
+						<n3ds_host>ctr.olv.pretendo.cc</n3ds_host>
+					</endpoint>
+				</result>
+			*/
+
+			pugi::xml_node resultNode = doc.child("result");
+			if (!resultNode)
+			{
+				cemuLog_log(LogType::Force, "Discovery response doesn't contain <result>");
+				return OLV_RESULT_INVALID_XML;
+			}
+
+			pugi::xml_node endpointNode = resultNode.child("endpoint");
+			if (!endpointNode)
+			{
+				cemuLog_log(LogType::Force, "Discovery response doesn't contain <result><endpoint>");
+				return OLV_RESULT_INVALID_XML;
+			}
+
+			// Yes it only uses <host> and <portal_host>
+			std::string_view host = endpointNode.child_value("host");
+			std::string_view portal_host = endpointNode.child_value("portal_host");
+
+			snprintf(g_DiscoveryResults.apiEndpoint, sizeof(g_DiscoveryResults.apiEndpoint), "https://%s", host.data());
+			snprintf(g_DiscoveryResults.portalEndpoint, sizeof(g_DiscoveryResults.portalEndpoint), "https://%s", portal_host.data());
+
+			return OLV_RESULT_SUCCESS;
+		}
+
+		sint32 MakeDiscoveryRequest_AsyncRequest(CurlRequestHelper& req, const char* reqUrl, coreinit::OSEvent* requestDoneEvent)
+		{
+			sint32 res = MakeDiscoveryRequest_AsyncRequestImpl(req, reqUrl);
+			coreinit::OSSignalEvent(requestDoneEvent);
+			return res;
+		}
+
+		sint32 MakeDiscoveryRequest()
+		{
+			// =============================================================================
+			// Discovery request | https://discovery.olv.nintendo.net/v1/endpoint
+			// =============================================================================
+
+			CurlRequestHelper req;
+			std::string requestUrl;
+			switch (ActiveSettings::GetNetworkService())
+			{
+				case NetworkService::Pretendo:
+					requestUrl = PretendoURLs::OLVURL;
+					break;
+				case NetworkService::Custom:
+					requestUrl = GetNetworkConfig().urls.OLV.GetValue();
+					break;
+				case NetworkService::Nintendo:
+				default:
+					requestUrl = NintendoURLs::OLVURL;
+					break;
+			}
+
+			req.initate(ActiveSettings::GetNetworkService(), requestUrl, CurlRequestHelper::SERVER_SSL_CONTEXT::OLIVE);
+			InitializeOliveRequest(req);
+
+			StackAllocator<coreinit::OSEvent> requestDoneEvent;
+			coreinit::OSInitEvent(&requestDoneEvent, coreinit::OSEvent::EVENT_STATE::STATE_NOT_SIGNALED, coreinit::OSEvent::EVENT_MODE::MODE_MANUAL);
+			std::future<sint32> requestRes = std::async(std::launch::async, MakeDiscoveryRequest_AsyncRequest, std::ref(req), requestUrl.c_str(), requestDoneEvent.GetPointer());
+			coreinit::OSWaitEvent(&requestDoneEvent);
+
+			return requestRes.get();
+		}
+
+		sint32 Initialize(nn::olv::InitializeParam* pParam)
+		{
+			if (g_IsInitialized)
+				return OLV_RESULT_ALREADY_INITIALIZED;
+
+			if (!pParam->m_Work)
+			{
+				g_IsInitialized = false;
+				return OLV_RESULT_INVALID_PTR;
+			}
+
+			if (pParam->m_WorkSize < 0x10000)
+			{
+				g_IsInitialized = false;
+				return OLV_RESULT_INVALID_SIZE;
+			}
+
+			uint32_t accessKey;
+			int32_t olvAccessKeyStatus = GetOlvAccessKey(&accessKey);
+			if (olvAccessKeyStatus < 0)
+			{
+				g_IsInitialized = false;
+				return olvAccessKeyStatus;
+			}
+
+			uint64_t tid = CafeSystem::GetForegroundTitleId();
+			int32_t createParamPackResult = CreateParamPack(tid, accessKey);
+			if (createParamPackResult < 0)
+			{
+				g_IsInitialized = false;
+				return createParamPackResult;
+			}
+
+			g_IsInitialized = true;
+
+			if(ActiveSettings::GetNetworkService() == NetworkService::Nintendo)
+			{
+				// since the official Miiverse was shut down, use local post archive instead
+				g_IsOnlineMode = true;
+				g_IsOfflineDBMode = true;
+				return OLV_RESULT_SUCCESS;
+			}
+			if ((pParam->m_Flags & InitializeParam::FLAG_OFFLINE_MODE) == 0)
+			{
+				g_IsOnlineMode = true;
+
+				independentServiceToken_t token;
+				sint32 res = (sint32)nn::act::AcquireIndependentServiceToken(&token, OLV_CLIENT_ID, 0);
+				if (res < 0)
+				{
+					g_IsInitialized = false;
+					return res;
+				}
+
+				// Assuming we're always a production WiiU (non-dev)
+				uint32 uniqueId = (CafeSystem::GetForegroundTitleId() >> 8) & 0xFFFFF;
+
+				char versionBuffer[32];
+				snprintf(versionBuffer, sizeof(versionBuffer), "%d.%d.%d", OLV_VERSION_MAJOR, OLV_VERSION_MINOR, OLV_VERSION_PATCH);
+				snprintf(g_DiscoveryResults.userAgent, sizeof(g_DiscoveryResults.userAgent), "%s/%s-%s/%d", "WiiU", "POLV", versionBuffer, uniqueId);
+
+				memcpy(g_DiscoveryResults.serviceToken, token.token, sizeof(g_DiscoveryResults.serviceToken));
+
+				sint32 discoveryRes = MakeDiscoveryRequest();
+				if (discoveryRes < 0)
+					g_IsInitialized = false;
+
+				return discoveryRes;
+			}
+
+			return OLV_RESULT_SUCCESS;
+		}
+
+		namespace Report
+		{
+			uint32 GetReportTypes()
+			{
+				return g_ReportTypes;
+			}
+
+			void SetReportTypes(uint32 reportTypes)
+			{
+				g_ReportTypes = reportTypes | 0x1000;
+			}
+		}
+
+		bool IsInitialized()
+		{
+			return g_IsInitialized;
+		}
+	}
+}
\ No newline at end of file
diff --git a/src/Cafe/OS/libs/nn_olv/nn_olv_InitializeTypes.h b/src/Cafe/OS/libs/nn_olv/nn_olv_InitializeTypes.h
new file mode 100644
index 00000000..51dce8fe
--- /dev/null
+++ b/src/Cafe/OS/libs/nn_olv/nn_olv_InitializeTypes.h
@@ -0,0 +1,128 @@
+#pragma once
+
+#include "Cemu/ncrypto/ncrypto.h"
+#include "config/ActiveSettings.h"
+
+#include "Cafe/OS/libs/nn_olv/nn_olv_Common.h"
+#include "Cafe/OS/libs/coreinit/coreinit_MCP.h"
+
+
+namespace nn
+{
+	namespace olv
+	{
+
+		class InitializeParam
+		{
+		public:
+			static const inline uint32 FLAG_OFFLINE_MODE = (1 << 0);
+
+			InitializeParam()
+			{
+				this->m_Flags = 0;
+				this->m_ReportTypes = 7039;
+				this->m_SysArgsSize = 0;
+				this->m_Work = MEMPTR<uint8_t>(nullptr);
+				this->m_SysArgs = MEMPTR<const void>(nullptr);
+				this->m_WorkSize = 0;
+			}
+			static InitializeParam* __ctor(InitializeParam* _this)
+			{
+				if (!_this)
+				{
+					assert_dbg(); // DO NOT CONTINUE, SHOULD NEVER HAPPEN
+					return nullptr;
+				}
+				else
+					return new (_this) InitializeParam();
+			}
+
+			sint32 SetFlags(uint32 flags)
+			{
+				this->m_Flags = flags;
+				return OLV_RESULT_SUCCESS;
+			}
+			static sint32 __SetFlags(InitializeParam* _this, uint32 flags)
+			{
+				return _this->SetFlags(flags);
+			}
+
+			sint32 SetWork(MEMPTR<uint8_t> pWorkData, uint32 workDataSize)
+			{
+				if (!pWorkData)
+					return OLV_RESULT_INVALID_PTR;
+				if (workDataSize < 0x10000)
+					return OLV_RESULT_NOT_ENOUGH_SIZE;
+
+				this->m_Work = pWorkData;
+				this->m_WorkSize = workDataSize;
+				return OLV_RESULT_SUCCESS;
+			}
+			static uint32 __SetWork(InitializeParam* _this, MEMPTR<uint8> pWorkData, uint32 workDataSize)
+			{
+				return _this->SetWork(pWorkData, workDataSize);
+			}
+
+			sint32 SetReportTypes(uint32 reportTypes)
+			{
+				this->m_ReportTypes = reportTypes;
+				return OLV_RESULT_SUCCESS;
+			}
+			static sint32 __SetReportTypes(InitializeParam* _this, uint32 reportTypes)
+			{
+				return _this->SetReportTypes(reportTypes);
+			}
+
+			sint32 SetSysArgs(MEMPTR<const void> pSysArgs, uint32 sysArgsSize)
+			{
+				if (!pSysArgs)
+					return OLV_RESULT_INVALID_PTR;
+
+				if (!sysArgsSize)
+					return OLV_RESULT_INVALID_PARAMETER;
+
+				this->m_SysArgs = pSysArgs;
+				this->m_SysArgsSize = sysArgsSize;
+
+				return OLV_RESULT_SUCCESS;
+			}
+			static sint32 __SetSysArgs(InitializeParam* _this, MEMPTR<const void> pSysArgs, uint32 sysArgsSize)
+			{
+				return _this->SetSysArgs(pSysArgs, sysArgsSize);
+			}
+
+			uint32be m_Flags;
+			uint32be m_ReportTypes;
+			MEMPTR<uint8_t> m_Work;
+			uint32be m_WorkSize;
+			MEMPTR<const void> m_SysArgs;
+			uint32be m_SysArgsSize;
+			char unk[0x28];
+		};
+		static_assert(sizeof(nn::olv::InitializeParam) == 0x40, "sizeof(nn::olv::InitializeParam) != 0x40");
+
+
+		namespace Report
+		{
+			uint32 GetReportTypes();
+			void SetReportTypes(uint32 reportTypes);
+		}
+
+		bool IsInitialized();
+		sint32 Initialize(nn::olv::InitializeParam* pParam);
+
+		static void loadOliveInitializeTypes()
+		{
+			cafeExportRegisterFunc(Initialize, "nn_olv", "Initialize__Q2_2nn3olvFPCQ3_2nn3olv15InitializeParam", LogType::NN_OLV);
+			cafeExportRegisterFunc(IsInitialized, "nn_olv", "IsInitialized__Q2_2nn3olvFv", LogType::NN_OLV);
+			cafeExportRegisterFunc(Report::GetReportTypes, "nn_olv", "GetReportTypes__Q3_2nn3olv6ReportFv", LogType::NN_OLV);
+			cafeExportRegisterFunc(Report::SetReportTypes, "nn_olv", "SetReportTypes__Q3_2nn3olv6ReportFUi", LogType::NN_OLV);
+
+			cafeExportRegisterFunc(InitializeParam::__ctor, "nn_olv", "__ct__Q3_2nn3olv15InitializeParamFv", LogType::NN_OLV);
+			cafeExportRegisterFunc(InitializeParam::__SetFlags, "nn_olv", "SetFlags__Q3_2nn3olv15InitializeParamFUi", LogType::NN_OLV);
+			cafeExportRegisterFunc(InitializeParam::__SetWork, "nn_olv", "SetWork__Q3_2nn3olv15InitializeParamFPUcUi", LogType::NN_OLV);
+			cafeExportRegisterFunc(InitializeParam::__SetReportTypes, "nn_olv", "SetReportTypes__Q3_2nn3olv15InitializeParamFUi", LogType::NN_OLV);
+			cafeExportRegisterFunc(InitializeParam::__SetSysArgs, "nn_olv", "SetSysArgs__Q3_2nn3olv15InitializeParamFPCvUi", LogType::NN_OLV);
+		}
+	}
+}
\ No newline at end of file
diff --git a/src/Cafe/OS/libs/nn_olv/nn_olv_OfflineDB.cpp b/src/Cafe/OS/libs/nn_olv/nn_olv_OfflineDB.cpp
new file mode 100644
index 00000000..c87cbd39
--- /dev/null
+++ b/src/Cafe/OS/libs/nn_olv/nn_olv_OfflineDB.cpp
@@ -0,0 +1,215 @@
+#include "nn_olv_Common.h"
+#include "nn_olv_PostTypes.h"
+#include "nn_olv_OfflineDB.h"
+#include "Cemu/ncrypto/ncrypto.h" // for base64 encoder/decoder
+#include "util/helpers/helpers.h"
+#include "config/ActiveSettings.h"
+#include "Cafe/CafeSystem.h"
+#include <pugixml.hpp>
+#include <zlib.h>
+#include <zarchive/zarchivereader.h>
+
+namespace nn
+{
+	namespace olv
+	{
+		std::mutex g_offlineDBMutex;
+		bool g_offlineDBInitialized = false;
+		ZArchiveReader* g_offlineDBArchive{nullptr};
+
+		void OfflineDB_LazyInit()
+		{
+			std::scoped_lock _l(g_offlineDBMutex);
+			if(g_offlineDBInitialized)
+				return;
+			// open archive
+			g_offlineDBArchive = ZArchiveReader::OpenFromFile(ActiveSettings::GetUserDataPath("resources/miiverse/OfflineDB.zar"));
+			if(!g_offlineDBArchive)
+				cemuLog_log(LogType::Force, "Offline miiverse posts are not available");
+			g_offlineDBInitialized = true;
+		}
+
+		void OfflineDB_Shutdown()
+		{
+			std::scoped_lock _l(g_offlineDBMutex);
+			if(!g_offlineDBInitialized)
+				return;
+			delete g_offlineDBArchive;
+			g_offlineDBInitialized = false;
+		}
+
+		bool CheckForOfflineDBFile(const char* filePath, uint32* fileSize)
+		{
+			if(!g_offlineDBArchive)
+				return false;
+			ZArchiveNodeHandle fileHandle = g_offlineDBArchive->LookUp(filePath);
+			if (!g_offlineDBArchive->IsFile(fileHandle))
+				return false;
+			if(fileSize)
+				*fileSize = g_offlineDBArchive->GetFileSize(fileHandle);
+			return true;
+		}
+
+		bool LoadOfflineDBFile(const char* filePath, std::vector<uint8>& fileData)
+		{
+			fileData.clear();
+			if(!g_offlineDBArchive)
+				return false;
+			ZArchiveNodeHandle fileHandle = g_offlineDBArchive->LookUp(filePath);
+			if (!g_offlineDBArchive->IsFile(fileHandle))
+				return false;
+			fileData.resize(g_offlineDBArchive->GetFileSize(fileHandle));
+			g_offlineDBArchive->ReadFromFile(fileHandle, 0, fileData.size(), fileData.data());
+			return true;
+		}
+
+		void TryLoadCompressedMemoImage(DownloadedPostData& downloadedPostData)
+		{
+			const unsigned char tgaHeader_320x120_32BPP[] = {0x0,0x0,0x2,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x40,0x1,0x78,0x0,0x20,0x8};
+			std::string memoImageFilename = fmt::format("memo/{}", (char*)downloadedPostData.downloadedDataBase.postId);
+			std::vector<uint8> bitmaskCompressedImg;
+			if (!LoadOfflineDBFile(memoImageFilename.c_str(), bitmaskCompressedImg))
+				return;
+			if (bitmaskCompressedImg.size() != (320*120)/8)
+				return;
+			std::vector<uint8> decompressedImage;
+			decompressedImage.resize(sizeof(tgaHeader_320x120_32BPP) + 320 * 120 * 4);
+			memcpy(decompressedImage.data(), tgaHeader_320x120_32BPP, sizeof(tgaHeader_320x120_32BPP));
+			uint8* pOut = decompressedImage.data() + sizeof(tgaHeader_320x120_32BPP);
+			for(int i=0; i<320*120; i++)
+			{
+				bool isWhite = (bitmaskCompressedImg[i/8] & (1 << (i%8))) != 0;
+				if(isWhite)
+				{
+					pOut[0] = pOut[1] = pOut[2] = pOut[3] = 0xFF;
+				}
+				else
+				{
+					pOut[0] = pOut[1] = pOut[2] = 0;
+					pOut[3] = 0xFF;
+				}
+				pOut += 4;
+			}
+			// store compressed image
+			uLongf compressedDestLen = 40960;
+			int r = compress((uint8*)downloadedPostData.downloadedDataBase.compressedMemoBody, &compressedDestLen, decompressedImage.data(), decompressedImage.size());
+			if( r != Z_OK)
+				return;
+			downloadedPostData.downloadedDataBase.compressedMemoBodySize = compressedDestLen;
+			downloadedPostData.downloadedDataBase.SetFlag(DownloadedDataBase::FLAGS::HAS_BODY_MEMO);
+		}
+
+		void CheckForExternalImage(DownloadedPostData& downloadedPostData)
+		{
+			std::string externalImageFilename = fmt::format("image/{}.jpg", (char*)downloadedPostData.downloadedDataBase.postId);
+			uint32 fileSize;
+			if (!CheckForOfflineDBFile(externalImageFilename.c_str(), &fileSize))
+				return;
+			strcpy((char*)downloadedPostData.downloadedDataBase.externalImageDataUrl, externalImageFilename.c_str());
+			downloadedPostData.downloadedDataBase.SetFlag(DownloadedDataBase::FLAGS::HAS_EXTERNAL_IMAGE);
+			downloadedPostData.downloadedDataBase.externalImageDataSize = fileSize;
+		}
+
+		nnResult _Async_OfflineDB_DownloadPostDataListParam_DownloadPostDataList(coreinit::OSEvent* event, DownloadedTopicData* downloadedTopicData, DownloadedPostData* downloadedPostData, uint32be* postCountOut, uint32 maxCount, DownloadPostDataListParam* param)
+		{
+			stdx::scope_exit _se([&](){coreinit::OSSignalEvent(event);});
+
+			uint64 titleId = CafeSystem::GetForegroundTitleId();
+
+			memset(downloadedTopicData, 0, sizeof(DownloadedTopicData));
+			memset(downloadedPostData, 0, sizeof(DownloadedPostData) * maxCount);
+			*postCountOut = 0;
+
+			const char* postXmlFilename = nullptr;
+			if(titleId == 0x0005000010143400 || titleId == 0x0005000010143500 || titleId == 0x0005000010143600)
+				postXmlFilename = "PostList_WindWakerHD.xml";
+
+			if (!postXmlFilename)
+				return OLV_RESULT_SUCCESS;
+
+			// load post XML
+			std::vector<uint8> xmlData;
+			if (!LoadOfflineDBFile(postXmlFilename, xmlData))
+				return OLV_RESULT_SUCCESS;
+			pugi::xml_document doc;
+			pugi::xml_parse_result result = doc.load_buffer(xmlData.data(), xmlData.size());
+			if (!result)
+				return OLV_RESULT_SUCCESS;
+			// collect list of all post xml nodes
+			std::vector<pugi::xml_node> postXmlNodes;
+			for (pugi::xml_node postNode = doc.child("posts").child("post"); postNode; postNode = postNode.next_sibling("post"))
+				postXmlNodes.push_back(postNode);
+
+			// randomly select up to maxCount posts
+			srand(GetTickCount());
+			uint32 postCount = 0;
+			while(!postXmlNodes.empty() && postCount < maxCount)
+			{
+				uint32 index = rand() % postXmlNodes.size();
+				pugi::xml_node& postNode = postXmlNodes[index];
+
+				auto& addedPost = downloadedPostData[postCount];
+				memset(&addedPost, 0, sizeof(DownloadedPostData));
+				if (!ParseXML_DownloadedPostData(addedPost, postNode) )
+					continue;
+				TryLoadCompressedMemoImage(addedPost);
+				CheckForExternalImage(addedPost);
+				postCount++;
+				// remove from post list
+				postXmlNodes[index] = postXmlNodes.back();
+				postXmlNodes.pop_back();
+			}
+			*postCountOut = postCount;
+			return OLV_RESULT_SUCCESS;
+		}
+
+		nnResult OfflineDB_DownloadPostDataListParam_DownloadPostDataList(DownloadedTopicData* downloadedTopicData, DownloadedPostData* downloadedPostData, uint32be* postCountOut, uint32 maxCount, DownloadPostDataListParam* param)
+		{
+			OfflineDB_LazyInit();
+
+			memset(downloadedTopicData, 0, sizeof(DownloadedTopicData));
+			downloadedTopicData->communityId = param->communityId;
+			*postCountOut = 0;
+
+			if(param->_HasFlag(DownloadPostDataListParam::FLAGS::SELF_ONLY))
+				return OLV_RESULT_SUCCESS; // the offlineDB doesn't contain any self posts
+
+			StackAllocator<coreinit::OSEvent> doneEvent;
+			coreinit::OSInitEvent(&doneEvent, coreinit::OSEvent::EVENT_STATE::STATE_NOT_SIGNALED, coreinit::OSEvent::EVENT_MODE::MODE_MANUAL);
+			auto asyncTask = std::async(std::launch::async, _Async_OfflineDB_DownloadPostDataListParam_DownloadPostDataList, doneEvent.GetPointer(), downloadedTopicData, downloadedPostData, postCountOut, maxCount, param);
+			coreinit::OSWaitEvent(&doneEvent);
+			nnResult r = asyncTask.get();
+			return r;
+		}
+
+		nnResult _Async_OfflineDB_DownloadPostDataListParam_DownloadExternalImageData(coreinit::OSEvent* event, DownloadedDataBase* _this, void* imageDataOut, uint32be* imageSizeOut, uint32 maxSize)
+		{
+			stdx::scope_exit _se([&](){coreinit::OSSignalEvent(event);});
+
+			if (!_this->TestFlags(_this, DownloadedDataBase::FLAGS::HAS_EXTERNAL_IMAGE))
+				return OLV_RESULT_MISSING_DATA;
+
+			// not all games may use JPEG files?
+			std::string externalImageFilename = fmt::format("image/{}.jpg", (char*)_this->postId);
+			std::vector<uint8> jpegData;
+			if (!LoadOfflineDBFile(externalImageFilename.c_str(), jpegData))
+				return OLV_RESULT_FAILED_REQUEST;
+
+			memcpy(imageDataOut, jpegData.data(), jpegData.size());
+			*imageSizeOut = jpegData.size();
+
+			return OLV_RESULT_SUCCESS;
+		}
+
+		nnResult OfflineDB_DownloadPostDataListParam_DownloadExternalImageData(DownloadedDataBase* _this, void* imageDataOut, uint32be* imageSizeOut, uint32 maxSize)
+		{
+			StackAllocator<coreinit::OSEvent> doneEvent;
+			coreinit::OSInitEvent(&doneEvent, coreinit::OSEvent::EVENT_STATE::STATE_NOT_SIGNALED, coreinit::OSEvent::EVENT_MODE::MODE_MANUAL);
+			auto asyncTask = std::async(std::launch::async, _Async_OfflineDB_DownloadPostDataListParam_DownloadExternalImageData, doneEvent.GetPointer(), _this, imageDataOut, imageSizeOut, maxSize);
+			coreinit::OSWaitEvent(&doneEvent);
+			nnResult r = asyncTask.get();
+			return r;
+		}
+
+	}
+}
\ No newline at end of file
diff --git a/src/Cafe/OS/libs/nn_olv/nn_olv_OfflineDB.h b/src/Cafe/OS/libs/nn_olv/nn_olv_OfflineDB.h
new file mode 100644
index 00000000..ed790479
--- /dev/null
+++ b/src/Cafe/OS/libs/nn_olv/nn_olv_OfflineDB.h
@@ -0,0 +1,16 @@
+#pragma once
+#include "Cafe/OS/libs/nn_common.h"
+#include "nn_olv_Common.h"
+
+namespace nn
+{
+	namespace olv
+	{
+		void OfflineDB_Init();
+		void OfflineDB_Shutdown();
+
+		nnResult OfflineDB_DownloadPostDataListParam_DownloadPostDataList(DownloadedTopicData* downloadedTopicData, DownloadedPostData* downloadedPostData, uint32be* postCountOut, uint32 maxCount, DownloadPostDataListParam* param);
+		nnResult OfflineDB_DownloadPostDataListParam_DownloadExternalImageData(DownloadedDataBase* _this, void* imageDataOut, uint32be* imageSizeOut, uint32 maxSize);
+
+	}
+}
\ No newline at end of file
diff --git a/src/Cafe/OS/libs/nn_olv/nn_olv_PostTypes.cpp b/src/Cafe/OS/libs/nn_olv/nn_olv_PostTypes.cpp
new file mode 100644
index 00000000..5257530d
--- /dev/null
+++ b/src/Cafe/OS/libs/nn_olv/nn_olv_PostTypes.cpp
@@ -0,0 +1,463 @@
+#include "Cafe/OS/libs/nn_olv/nn_olv_Common.h"
+#include "nn_olv_PostTypes.h"
+#include "nn_olv_OfflineDB.h"
+#include "Cemu/ncrypto/ncrypto.h" // for base64 decoder
+#include "util/helpers/helpers.h"
+#include <pugixml.hpp>
+#include <zlib.h>
+
+namespace nn
+{
+	namespace olv
+	{
+		bool ParseXml_DownloadedDataBase(DownloadedDataBase& obj, pugi::xml_node& xmlNode)
+		{
+			// todo:
+			// painting with url?
+
+			pugi::xml_node tokenNode;
+			if(tokenNode = xmlNode.child("body"); tokenNode)
+			{
+				obj.bodyTextLength = SetStringUC2(obj.bodyText, tokenNode.child_value(), true);
+				if(obj.bodyTextLength > 0)
+					obj.SetFlag(DownloadedDataBase::FLAGS::HAS_BODY_TEXT);
+			}
+			if(tokenNode = xmlNode.child("topic_tag"); tokenNode)
+			{
+				SetStringUC2(obj.topicTag, tokenNode.child_value(), true);
+			}
+			if(tokenNode = xmlNode.child("feeling_id"); tokenNode)
+			{
+				obj.feeling = ConvertString<sint8>(tokenNode.child_value());
+				if(obj.feeling < 0 || obj.feeling >= 5)
+				{
+					cemuLog_log(LogType::Force, "[Olive-XML] DownloadedDataBase::ParseXml: feeling_id out of range");
+					return false;
+				}
+			}
+			if(tokenNode = xmlNode.child("id"); tokenNode)
+			{
+				std::string_view id_sv = tokenNode.child_value();
+				if(id_sv.size() > 22)
+				{
+					cemuLog_log(LogType::Force, "[Olive-XML] DownloadedDataBase::ParseXml: id too long");
+					return false;
+				}
+				memcpy(obj.postId, id_sv.data(), id_sv.size());
+				obj.postId[id_sv.size()] = '\0';
+			}
+			if(tokenNode = xmlNode.child("is_autopost"); tokenNode)
+			{
+				uint8 isAutopost = ConvertString<sint8>(tokenNode.child_value());
+				if(isAutopost == 1)
+					obj.SetFlag(DownloadedDataBase::FLAGS::IS_AUTOPOST);
+				else if(isAutopost == 0)
+					obj.SetFlag(DownloadedDataBase::FLAGS::IS_NOT_AUTOPOST);
+				else
+				{
+					cemuLog_log(LogType::Force, "[Olive-XML] DownloadedDataBase::ParseXml: is_autopost has invalid value");
+					return false;
+				}
+			}
+			if(tokenNode = xmlNode.child("empathy_added"); tokenNode)
+			{
+				if(ConvertString<sint32>(tokenNode.child_value()) > 0)
+					obj.SetFlag(DownloadedDataBase::FLAGS::HAS_EMPATHY_ADDED);
+			}
+			if(tokenNode = xmlNode.child("is_spoiler"); tokenNode)
+			{
+				if(ConvertString<sint32>(tokenNode.child_value()) > 0)
+					obj.SetFlag(DownloadedDataBase::FLAGS::IS_SPOILER);
+			}
+			if(tokenNode = xmlNode.child("mii"); tokenNode)
+			{
+				std::vector<uint8> miiData = NCrypto::base64Decode(tokenNode.child_value());
+				if(miiData.size() != 96)
+				{
+					cemuLog_log(LogType::Force, "[Olive-XML] DownloadedSystemTopicData mii data is not valid (incorrect size)");
+					return false;
+				}
+				memcpy(obj.miiData, miiData.data(), miiData.size());
+				obj.SetFlag(DownloadedDataBase::FLAGS::HAS_MII_DATA);
+			}
+			if(tokenNode = xmlNode.child("pid"); tokenNode)
+			{
+				obj.userPid = ConvertString<uint32>(tokenNode.child_value());
+			}
+			if(tokenNode = xmlNode.child("screen_name"); tokenNode)
+			{
+				SetStringUC2(obj.miiNickname, tokenNode.child_value(), true);
+			}
+			if(tokenNode = xmlNode.child("region_id"); tokenNode)
+			{
+				obj.regionId = ConvertString<uint32>(tokenNode.child_value());
+			}
+			if(tokenNode = xmlNode.child("platform_id"); tokenNode)
+			{
+				obj.platformId = ConvertString<uint8>(tokenNode.child_value());
+			}
+			if(tokenNode = xmlNode.child("language_id"); tokenNode)
+			{
+				obj.languageId = ConvertString<uint8>(tokenNode.child_value());
+			}
+			if(tokenNode = xmlNode.child("country_id"); tokenNode)
+			{
+				obj.countryId = ConvertString<uint8>(tokenNode.child_value());
+			}
+			if(tokenNode = xmlNode.child("painting"); tokenNode)
+			{
+				if(pugi::xml_node subNode = tokenNode.child("content"); subNode)
+				{
+					std::vector<uint8> paintingData = NCrypto::base64Decode(subNode.child_value());
+					if (paintingData.size() > 0xA000)
+					{
+						cemuLog_log(LogType::Force, "[Olive-XML] DownloadedDataBase painting content is too large");
+						return false;
+					}
+					memcpy(obj.compressedMemoBody, paintingData.data(), paintingData.size());
+					obj.SetFlag(DownloadedDataBase::FLAGS::HAS_BODY_MEMO);
+				}
+				if(pugi::xml_node subNode = tokenNode.child("size"); subNode)
+				{
+					obj.compressedMemoBodySize = ConvertString<uint32>(subNode.child_value());
+				}
+			}
+			if(tokenNode = xmlNode.child("app_data"); tokenNode)
+			{
+				std::vector<uint8> appData = NCrypto::base64Decode(tokenNode.child_value());
+				if (appData.size() > 0x400)
+				{
+					cemuLog_log(LogType::Force, "[Olive-XML] DownloadedDataBase AppData is too large");
+					return false;
+				}
+				memcpy(obj.appData, appData.data(), appData.size());
+				obj.appDataLength = appData.size();
+				obj.SetFlag(DownloadedDataBase::FLAGS::HAS_APP_DATA);
+			}
+			return true;
+		}
+
+		bool ParseXML_DownloadedPostData(DownloadedPostData& obj, pugi::xml_node& xmlNode)
+		{
+			pugi::xml_node tokenNode;
+			if(tokenNode = xmlNode.child("community_id"); tokenNode)
+				obj.communityId = ConvertString<uint32>(tokenNode.child_value());
+			if(tokenNode = xmlNode.child("empathy_count"); tokenNode)
+				obj.empathyCount = ConvertString<uint32>(tokenNode.child_value());
+			if(tokenNode = xmlNode.child("reply_count"); tokenNode)
+				obj.commentCount = ConvertString<uint32>(tokenNode.child_value());
+			return ParseXml_DownloadedDataBase(obj.downloadedDataBase, xmlNode);
+		}
+
+		bool ParseXML_DownloadedSystemPostData(hidden::DownloadedSystemPostData& obj, pugi::xml_node& xmlNode)
+		{
+			pugi::xml_node tokenNode;
+			if(tokenNode = xmlNode.child("title_id"); tokenNode)
+				obj.titleId = ConvertString<uint64>(tokenNode.child_value());
+			return ParseXML_DownloadedPostData(obj.downloadedPostData, xmlNode);
+		}
+
+		bool ParseXML_DownloadedTopicData(DownloadedTopicData& obj, pugi::xml_node& xmlNode)
+		{
+			pugi::xml_node tokenNode;
+			if(tokenNode = xmlNode.child("community_id"); tokenNode)
+				obj.communityId = ConvertString<uint32>(tokenNode.child_value());
+			return true;
+		}
+
+		bool Parse_DownloadedSystemTopicData(hidden::DownloadedSystemTopicData& obj, pugi::xml_node& xmlNode)
+		{
+			if(!ParseXML_DownloadedTopicData(obj.downloadedTopicData, xmlNode))
+				return false;
+			pugi::xml_node tokenNode;
+			if(tokenNode = xmlNode.child("name"); tokenNode)
+			{
+				SetStringUC2(obj.titleText, tokenNode.child_value(), true);
+				obj.downloadedTopicData.SetFlag(DownloadedTopicData::FLAGS::HAS_TITLE);
+			}
+			if(tokenNode = xmlNode.child("is_recommended"); tokenNode)
+			{
+				uint32 isRecommended = ConvertString<uint32>(tokenNode.child_value());
+				if(isRecommended != 0)
+					obj.downloadedTopicData.SetFlag(DownloadedTopicData::FLAGS::IS_RECOMMENDED);
+			}
+			if(tokenNode = xmlNode.child("title_id"); tokenNode)
+			{
+				obj.titleId = ConvertString<uint64>(tokenNode.child_value());
+			}
+			if(tokenNode = xmlNode.child("title_ids"); tokenNode)
+			{
+				cemu_assert_unimplemented();
+			}
+			if(tokenNode = xmlNode.child("icon"); tokenNode)
+			{
+				std::vector<uint8> iconData = NCrypto::base64Decode(tokenNode.child_value());
+				if(iconData.size() > sizeof(obj.iconData))
+				{
+					cemuLog_log(LogType::Force, "[Olive-XML] DownloadedSystemTopicData icon data is not valid");
+					return false;
+				}
+				obj.iconDataSize = iconData.size();
+				memcpy(obj.iconData, iconData.data(), iconData.size());
+				obj.downloadedTopicData.SetFlag(DownloadedTopicData::FLAGS::HAS_ICON_DATA);
+			}
+			return true;
+		}
+
+		uint32 GetSystemTopicDataListFromRawData(hidden::DownloadedSystemTopicDataList* downloadedSystemTopicDataList, hidden::DownloadedSystemPostData* downloadedSystemPostData, uint32be* postCountOut, uint32 postCountMax, void* xmlData, uint32 xmlDataSize)
+		{
+			// copy xmlData into a temporary buffer since load_buffer_inplace will modify it
+			std::vector<uint8> buffer;
+			buffer.resize(xmlDataSize);
+			memcpy(buffer.data(), xmlData, xmlDataSize);
+			pugi::xml_document doc;
+			if (!doc.load_buffer_inplace(buffer.data(), xmlDataSize, pugi::parse_default, pugi::xml_encoding::encoding_utf8))
+				return -1;
+
+			memset(downloadedSystemTopicDataList, 0, sizeof(hidden::DownloadedSystemTopicDataList));
+			downloadedSystemTopicDataList->topicDataNum = 0;
+		
+			cemu_assert_debug(doc.child("result").child("topics"));
+
+			size_t postCount = 0;
+
+			// parse topics
+			for (pugi::xml_node topicsChildNode : doc.child("result").child("topics").children())
+			{
+				const char* name = topicsChildNode.name();
+				cemuLog_logDebug(LogType::Force, "topicsChildNode.name() = {}", name);
+				if (strcmp(topicsChildNode.name(), "topic"))
+					continue;
+				// parse topic
+				if(downloadedSystemTopicDataList->topicDataNum > 10)
+				{
+					cemuLog_log(LogType::Force, "[Olive-XML] DownloadedSystemTopicDataList exceeded maximum topic count (10)");
+					return false;
+				}
+				auto& topicEntry = downloadedSystemTopicDataList->topicData[downloadedSystemTopicDataList->topicDataNum];
+				memset(&topicEntry, 0, sizeof(hidden::DownloadedSystemTopicDataList::DownloadedSystemTopicWrapped));
+				Parse_DownloadedSystemTopicData(topicEntry.downloadedSystemTopicData, topicsChildNode);
+				downloadedSystemTopicDataList->topicDataNum = downloadedSystemTopicDataList->topicDataNum + 1;
+
+				topicEntry.postDataNum = 0;
+				// parse all posts within the current topic
+				for (pugi::xml_node personNode : topicsChildNode.child("people").children("person"))
+				{
+					for (pugi::xml_node postNode : personNode.child("posts").children("post"))
+					{
+						if(postCount >= postCountMax)
+						{
+							cemuLog_log(LogType::Force, "[Olive-XML] GetSystemTopicDataListFromRawData exceeded maximum post count");
+							return false;
+						}
+						auto& postEntry = downloadedSystemPostData[postCount];
+						memset(&postEntry, 0, sizeof(hidden::DownloadedSystemPostData));
+						bool r = ParseXML_DownloadedSystemPostData(postEntry, postNode);
+						if(!r)
+						{
+							cemuLog_log(LogType::Force, "[Olive-XML] DownloadedSystemPostData parsing failed");
+							return false;
+						}
+						postCount++;
+						// add post to topic
+						if(topicEntry.postDataNum >= hidden::DownloadedSystemTopicDataList::MAX_POSTS_PER_TOPIC)
+						{
+							cemuLog_log(LogType::Force, "[Olive-XML] DownloadedSystemTopicDataList has too many posts for a single topic (up to {})", hidden::DownloadedSystemTopicDataList::MAX_POSTS_PER_TOPIC);
+							return false;
+						}
+						topicEntry.postDataList[topicEntry.postDataNum] = &postEntry;
+						topicEntry.postDataNum = topicEntry.postDataNum + 1;
+					}
+				}
+			}
+			*postCountOut = postCount;
+			return 0;
+		}
+
+		nnResult DownloadedDataBase::DownloadExternalImageData(DownloadedDataBase* _this, void* imageDataOut, uint32be* imageSizeOut, uint32 maxSize)
+		{
+			if(g_IsOfflineDBMode)
+				return OfflineDB_DownloadPostDataListParam_DownloadExternalImageData(_this, imageDataOut, imageSizeOut, maxSize);
+
+			if(!g_IsOnlineMode)
+				return OLV_RESULT_OFFLINE_MODE_REQUEST;
+			if (!TestFlags(_this, FLAGS::HAS_EXTERNAL_IMAGE))
+				return OLV_RESULT_MISSING_DATA;
+
+			cemuLog_logDebug(LogType::Force, "DownloadedDataBase::DownloadExternalImageData not implemented");
+			return OLV_RESULT_FAILED_REQUEST; // placeholder error
+		}
+
+		nnResult DownloadPostDataListParam::GetRawDataUrl(DownloadPostDataListParam* _this, char* urlOut, uint32 urlMaxSize)
+		{
+			if(!g_IsOnlineMode)
+				return OLV_RESULT_OFFLINE_MODE_REQUEST;
+			//if(_this->communityId == 0)
+			//	cemuLog_log(LogType::Force, "DownloadPostDataListParam::GetRawDataUrl called with invalid communityId");
+
+			// get base url
+			std::string baseUrl;
+			baseUrl.append(g_DiscoveryResults.apiEndpoint);
+			//baseUrl.append(fmt::format("/v1/communities/{}/posts", (uint32)_this->communityId));
+			cemu_assert_debug(_this->communityId == 0);
+			baseUrl.append(fmt::format("/v1/posts.search", (uint32)_this->communityId));
+
+			// "v1/posts.search"
+
+			// build parameter string
+			std::string params;
+
+			// this function behaves differently for the Wii U menu? Where it can lookup posts by titleId?
+			if(_this->titleId != 0)
+			{
+				cemu_assert_unimplemented(); // Wii U menu mode
+			}
+
+			// todo: Generic parameters. Which includes: language_id, limit, type=text/memo
+
+			// handle postIds
+			for(size_t i=0; i<_this->MAX_NUM_POST_ID; i++)
+			{
+				if(_this->searchPostId[i].str[0] == '\0')
+					continue;
+				cemu_assert_unimplemented(); // todo
+				// todo - postId parameter
+				// handle filters
+				if(_this->_HasFlag(DownloadPostDataListParam::FLAGS::WITH_MII))
+					params.append("&with_mii=1");
+				if(_this->_HasFlag(DownloadPostDataListParam::FLAGS::WITH_EMPATHY))
+					params.append("&with_empathy_added=1");
+				if(_this->bodyTextMaxLength != 0)
+					params.append(fmt::format("&max_body_length={}", _this->bodyTextMaxLength));
+			}
+
+			if(_this->titleId != 0)
+				params.append(fmt::format("&title_id={}", (uint64)_this->titleId));
+
+			if (_this->_HasFlag(DownloadPostDataListParam::FLAGS::FRIENDS_ONLY))
+				params.append("&by=friend");
+			if (_this->_HasFlag(DownloadPostDataListParam::FLAGS::FOLLOWERS_ONLY))
+				params.append("&by=followings");
+			if (_this->_HasFlag(DownloadPostDataListParam::FLAGS::SELF_ONLY))
+				params.append("&by=self");
+
+			if(!params.empty())
+				params[0] = '?'; // replace the leading ampersand
+
+			baseUrl.append(params);
+			if(baseUrl.size()+1 > urlMaxSize)
+				return OLV_RESULT_NOT_ENOUGH_SIZE;
+			strncpy(urlOut, baseUrl.c_str(), urlMaxSize);
+			return OLV_RESULT_SUCCESS;
+		}
+
+		nnResult DownloadPostDataList(DownloadedTopicData* downloadedTopicData, DownloadedPostData* downloadedPostData, uint32be* postCountOut, uint32 maxCount, DownloadPostDataListParam* param)
+		{
+			if(g_IsOfflineDBMode)
+				return OfflineDB_DownloadPostDataListParam_DownloadPostDataList(downloadedTopicData, downloadedPostData, postCountOut, maxCount, param);
+			memset(downloadedTopicData, 0, sizeof(DownloadedTopicData));
+			downloadedTopicData->communityId = param->communityId;
+			*postCountOut = 0;
+
+			char urlBuffer[2048];
+			if (NN_RESULT_IS_FAILURE(DownloadPostDataListParam::GetRawDataUrl(param, urlBuffer, sizeof(urlBuffer))))
+				return OLV_RESULT_INVALID_PARAMETER;
+
+			/*
+			CurlRequestHelper req;
+			req.initate(urlBuffer, CurlRequestHelper::SERVER_SSL_CONTEXT::OLIVE);
+			InitializeOliveRequest(req);
+			bool reqResult = req.submitRequest();
+			if (!reqResult)
+			{
+				long httpCode = 0;
+				curl_easy_getinfo(req.getCURL(), CURLINFO_RESPONSE_CODE, &httpCode);
+				cemuLog_log(LogType::Force, "Failed request: {} ({})", urlBuffer, httpCode);
+				if (!(httpCode >= 400))
+					return OLV_RESULT_FAILED_REQUEST;
+			}
+			pugi::xml_document doc;
+			if (!doc.load_buffer(req.getReceivedData().data(), req.getReceivedData().size()))
+			{
+				cemuLog_log(LogType::Force, fmt::format("Invalid XML in community download response"));
+				return OLV_RESULT_INVALID_XML;
+			}
+			*/
+
+			*postCountOut = 0;
+
+			return OLV_RESULT_SUCCESS;
+		}
+
+		void loadOlivePostAndTopicTypes()
+		{
+			cafeExportRegisterFunc(GetSystemTopicDataListFromRawData, "nn_olv", "GetSystemTopicDataListFromRawData__Q3_2nn3olv6hiddenFPQ4_2nn3olv6hidden29DownloadedSystemTopicDataListPQ4_2nn3olv6hidden24DownloadedSystemPostDataPUiUiPCUcT4", LogType::NN_OLV);
+
+			// DownloadedDataBase getters
+			cafeExportRegisterFunc(DownloadedDataBase::TestFlags, "nn_olv", "TestFlags__Q3_2nn3olv18DownloadedDataBaseCFUi", LogType::NN_OLV);
+			cafeExportRegisterFunc(DownloadedDataBase::GetUserPid, "nn_olv", "GetUserPid__Q3_2nn3olv18DownloadedDataBaseCFv", LogType::NN_OLV);
+			cafeExportRegisterFunc(DownloadedDataBase::GetPostDate, "nn_olv", "GetPostDate__Q3_2nn3olv18DownloadedDataBaseCFv", LogType::NN_OLV);
+			cafeExportRegisterFunc(DownloadedDataBase::GetFeeling, "nn_olv", "GetFeeling__Q3_2nn3olv18DownloadedDataBaseCFv", LogType::NN_OLV);
+			cafeExportRegisterFunc(DownloadedDataBase::GetRegionId, "nn_olv", "GetRegionId__Q3_2nn3olv18DownloadedDataBaseCFv", LogType::NN_OLV);
+			cafeExportRegisterFunc(DownloadedDataBase::GetPlatformId, "nn_olv", "GetPlatformId__Q3_2nn3olv18DownloadedDataBaseCFv", LogType::NN_OLV);
+			cafeExportRegisterFunc(DownloadedDataBase::GetLanguageId, "nn_olv", "GetLanguageId__Q3_2nn3olv18DownloadedDataBaseCFv", LogType::NN_OLV);
+			cafeExportRegisterFunc(DownloadedDataBase::GetCountryId, "nn_olv", "GetCountryId__Q3_2nn3olv18DownloadedDataBaseCFv", LogType::NN_OLV);
+			cafeExportRegisterFunc(DownloadedDataBase::GetExternalUrl, "nn_olv", "GetExternalUrl__Q3_2nn3olv18DownloadedDataBaseCFv", LogType::NN_OLV);
+			cafeExportRegisterFunc(DownloadedDataBase::GetMiiData1, "nn_olv", "GetMiiData__Q3_2nn3olv18DownloadedDataBaseCFP12FFLStoreData", LogType::NN_OLV);
+			cafeExportRegisterFunc(DownloadedDataBase::GetMiiNickname, "nn_olv", "GetMiiNickname__Q3_2nn3olv18DownloadedDataBaseCFv", LogType::NN_OLV);
+			cafeExportRegisterFunc(DownloadedDataBase::GetBodyText, "nn_olv", "GetBodyText__Q3_2nn3olv18DownloadedDataBaseCFPwUi", LogType::NN_OLV);
+			cafeExportRegisterFunc(DownloadedDataBase::GetBodyMemo, "nn_olv", "GetBodyMemo__Q3_2nn3olv18DownloadedDataBaseCFPUcPUiUi", LogType::NN_OLV);
+			cafeExportRegisterFunc(DownloadedDataBase::GetTopicTag, "nn_olv", "GetTopicTag__Q3_2nn3olv18DownloadedDataBaseCFv", LogType::NN_OLV);
+			cafeExportRegisterFunc(DownloadedDataBase::GetAppData, "nn_olv", "GetAppData__Q3_2nn3olv18DownloadedDataBaseCFPUcPUiUi", LogType::NN_OLV);
+			cafeExportRegisterFunc(DownloadedDataBase::GetAppDataSize, "nn_olv", "GetAppDataSize__Q3_2nn3olv18DownloadedDataBaseCFv", LogType::NN_OLV);
+			cafeExportRegisterFunc(DownloadedDataBase::GetPostId, "nn_olv", "GetPostId__Q3_2nn3olv18DownloadedDataBaseCFv", LogType::NN_OLV);
+			cafeExportRegisterFunc(DownloadedDataBase::GetMiiData2, "nn_olv", "GetMiiData__Q3_2nn3olv18DownloadedDataBaseCFv", LogType::NN_OLV);
+			cafeExportRegisterFunc(DownloadedDataBase::DownloadExternalImageData, "nn_olv", "DownloadExternalImageData__Q3_2nn3olv18DownloadedDataBaseCFPvPUiUi", LogType::NN_OLV);
+			cafeExportRegisterFunc(DownloadedDataBase::GetExternalImageDataSize, "nn_olv", "GetExternalImageDataSize__Q3_2nn3olv18DownloadedDataBaseCFv", LogType::NN_OLV);
+
+			// DownloadedPostData getters
+			cafeExportRegisterFunc(DownloadedPostData::GetCommunityId, "nn_olv", "GetCommunityId__Q3_2nn3olv18DownloadedPostDataCFv", LogType::NN_OLV);
+			cafeExportRegisterFunc(DownloadedPostData::GetEmpathyCount, "nn_olv", "GetEmpathyCount__Q3_2nn3olv18DownloadedPostDataCFv", LogType::NN_OLV);
+			cafeExportRegisterFunc(DownloadedPostData::GetCommentCount, "nn_olv", "GetCommentCount__Q3_2nn3olv18DownloadedPostDataCFv", LogType::NN_OLV);
+			cafeExportRegisterFunc(DownloadedPostData::GetPostId, "nn_olv", "GetPostId__Q3_2nn3olv18DownloadedPostDataCFv", LogType::NN_OLV);
+
+			// DownloadedSystemPostData getters
+			cafeExportRegisterFunc(hidden::DownloadedSystemPostData::GetTitleId, "nn_olv", "GetTitleId__Q4_2nn3olv6hidden24DownloadedSystemPostDataCFv", LogType::NN_OLV);
+
+			// DownloadedTopicData getters
+			cafeExportRegisterFunc(DownloadedTopicData::GetCommunityId, "nn_olv", "GetCommunityId__Q3_2nn3olv19DownloadedTopicDataCFv", LogType::NN_OLV);
+
+			// DownloadedSystemTopicData getters
+			cafeExportRegisterFunc(hidden::DownloadedSystemTopicData::TestFlags, "nn_olv", "TestFlags__Q4_2nn3olv6hidden25DownloadedSystemTopicDataCFUi", LogType::NN_OLV);
+			cafeExportRegisterFunc(hidden::DownloadedSystemTopicData::GetTitleId, "nn_olv", "GetTitleId__Q4_2nn3olv6hidden25DownloadedSystemTopicDataCFv", LogType::NN_OLV);
+			cafeExportRegisterFunc(hidden::DownloadedSystemTopicData::GetTitleIdNum, "nn_olv", "GetTitleIdNum__Q4_2nn3olv6hidden25DownloadedSystemTopicDataCFv", LogType::NN_OLV);
+			cafeExportRegisterFunc(hidden::DownloadedSystemTopicData::GetTitleText, "nn_olv", "GetTitleText__Q4_2nn3olv6hidden25DownloadedSystemTopicDataCFPwUi", LogType::NN_OLV);
+			cafeExportRegisterFunc(hidden::DownloadedSystemTopicData::GetTitleIconData, "nn_olv", "GetTitleIconData__Q4_2nn3olv6hidden25DownloadedSystemTopicDataCFPUcPUiUi", LogType::NN_OLV);
+
+			// DownloadedSystemTopicDataList getters
+			cafeExportRegisterFunc(hidden::DownloadedSystemTopicDataList::GetDownloadedSystemTopicDataNum, "nn_olv", "GetDownloadedSystemTopicDataNum__Q4_2nn3olv6hidden29DownloadedSystemTopicDataListCFv", LogType::NN_OLV);
+			cafeExportRegisterFunc(hidden::DownloadedSystemTopicDataList::GetDownloadedSystemPostDataNum, "nn_olv", "GetDownloadedSystemPostDataNum__Q4_2nn3olv6hidden29DownloadedSystemTopicDataListCFi", LogType::NN_OLV);
+			cafeExportRegisterFunc(hidden::DownloadedSystemTopicDataList::GetDownloadedSystemTopicData, "nn_olv", "GetDownloadedSystemTopicData__Q4_2nn3olv6hidden29DownloadedSystemTopicDataListCFi", LogType::NN_OLV);
+			cafeExportRegisterFunc(hidden::DownloadedSystemTopicDataList::GetDownloadedSystemPostData, "nn_olv", "GetDownloadedSystemPostData__Q4_2nn3olv6hidden29DownloadedSystemTopicDataListCFiT1", LogType::NN_OLV);
+
+			// DownloadPostDataListParam constructor and getters
+			cafeExportRegisterFunc(DownloadPostDataListParam::Construct, "nn_olv", "__ct__Q3_2nn3olv25DownloadPostDataListParamFv", LogType::NN_OLV);
+			cafeExportRegisterFunc(DownloadPostDataListParam::SetFlags, "nn_olv", "SetFlags__Q3_2nn3olv25DownloadPostDataListParamFUi", LogType::NN_OLV);
+			cafeExportRegisterFunc(DownloadPostDataListParam::SetLanguageId, "nn_olv", "SetLanguageId__Q3_2nn3olv25DownloadPostDataListParamFUc", LogType::NN_OLV);
+			cafeExportRegisterFunc(DownloadPostDataListParam::SetCommunityId, "nn_olv", "SetCommunityId__Q3_2nn3olv25DownloadPostDataListParamFUi", LogType::NN_OLV);
+			cafeExportRegisterFunc(DownloadPostDataListParam::SetSearchKey, "nn_olv", "SetSearchKey__Q3_2nn3olv25DownloadPostDataListParamFPCwUc", LogType::NN_OLV);
+			cafeExportRegisterFunc(DownloadPostDataListParam::SetSearchKeySingle, "nn_olv", "SetSearchKey__Q3_2nn3olv25DownloadPostDataListParamFPCw", LogType::NN_OLV);
+			cafeExportRegisterFunc(DownloadPostDataListParam::SetSearchPid, "nn_olv", "SetSearchPid__Q3_2nn3olv25DownloadPostDataListParamFUi", LogType::NN_OLV);
+			cafeExportRegisterFunc(DownloadPostDataListParam::SetPostId, "nn_olv", "SetPostId__Q3_2nn3olv25DownloadPostDataListParamFPCcUi", LogType::NN_OLV);
+			cafeExportRegisterFunc(DownloadPostDataListParam::SetPostDate, "nn_olv", "SetPostDate__Q3_2nn3olv25DownloadPostDataListParamFL", LogType::NN_OLV);
+			cafeExportRegisterFunc(DownloadPostDataListParam::SetPostDataMaxNum, "nn_olv", "SetPostDataMaxNum__Q3_2nn3olv25DownloadPostDataListParamFUi", LogType::NN_OLV);
+			cafeExportRegisterFunc(DownloadPostDataListParam::SetBodyTextMaxLength, "nn_olv", "SetBodyTextMaxLength__Q3_2nn3olv25DownloadPostDataListParamFUi", LogType::NN_OLV);
+
+			// URL and downloading functions
+			cafeExportRegisterFunc(DownloadPostDataListParam::GetRawDataUrl, "nn_olv", "GetRawDataUrl__Q3_2nn3olv25DownloadPostDataListParamCFPcUi", LogType::NN_OLV);
+			cafeExportRegisterFunc(DownloadPostDataList, "nn_olv", "DownloadPostDataList__Q2_2nn3olvFPQ3_2nn3olv19DownloadedTopicDataPQ3_2nn3olv18DownloadedPostDataPUiUiPCQ3_2nn3olv25DownloadPostDataListParam", LogType::NN_OLV);
+
+		}
+
+	}
+}
\ No newline at end of file
diff --git a/src/Cafe/OS/libs/nn_olv/nn_olv_PostTypes.h b/src/Cafe/OS/libs/nn_olv/nn_olv_PostTypes.h
new file mode 100644
index 00000000..62dad755
--- /dev/null
+++ b/src/Cafe/OS/libs/nn_olv/nn_olv_PostTypes.h
@@ -0,0 +1,622 @@
+#pragma once
+#include <zlib.h>
+#include "nn_olv_Common.h"
+
+namespace nn
+{
+	namespace olv
+	{
+		struct DownloadedDataBase
+		{
+			enum class FLAGS : uint32
+			{
+				HAS_BODY_TEXT = 0x01,
+				HAS_BODY_MEMO = 0x02,
+				HAS_EXTERNAL_IMAGE = 0x04,
+				HAS_EXTERNAL_BINARY_DATA = 0x08,
+				HAS_MII_DATA = 0x10,
+				HAS_EXTERNAL_URL = 0x20,
+				HAS_APP_DATA = 0x40,
+				HAS_EMPATHY_ADDED = 0x80,
+				IS_AUTOPOST = 0x100,
+				IS_SPOILER = 0x200,
+				IS_NOT_AUTOPOST = 0x400, // autopost flag was explicitly set to false
+			};
+
+			void Reset()
+			{
+				memset(this, 0, sizeof(DownloadedDataBase));
+			}
+
+			void SetFlag(FLAGS flag)
+			{
+				flags =  (FLAGS)((uint32)flags.value() | (uint32)flag);
+			}
+
+			betype<FLAGS> flags;
+			uint32be userPid;
+			uint8be postId[32]; // string, up to 22 characters but the buffer is 32 bytes
+			uint64be postDate;
+			sint8be feeling;
+			uint8be _padding0031[3];
+			uint32be regionId;
+			uint8be platformId;
+			uint8be languageId;
+			uint8be countryId;
+			uint8be _padding003B;
+			uint16be bodyText[256];
+			uint32be bodyTextLength;
+			uint8be compressedMemoBody[40960];
+			uint32be compressedMemoBodySize;
+			uint16be topicTag[152];
+			uint8be appData[1024];
+			uint32be appDataLength;
+			uint8be externalBinaryUrl[256];
+			uint32be externalBinaryDataSize;
+			uint8be externalImageDataUrl[256];
+			uint32be externalImageDataSize;
+			uint8be externalURL[256];
+			uint8be miiData[96];
+			uint16be miiNickname[16];
+			uint32be _paddingAB00[1344];
+			uint32be uknC000_someVTableMaybe;
+			uint32be uknC004;
+
+			// getters
+			// TestFlags__Q3_2nn3olv18DownloadedDataBaseCFUi
+			static bool TestFlags(DownloadedDataBase* _this, DownloadedDataBase::FLAGS flag)
+			{
+				return HAS_FLAG((uint32)_this->flags.value(), (uint32)flag);
+			}
+
+			// GetUserPid__Q3_2nn3olv18DownloadedDataBaseCFv
+			static uint32 GetUserPid(DownloadedDataBase* _this)
+			{
+				return _this->userPid;
+			}
+
+			// GetPostDate__Q3_2nn3olv18DownloadedDataBaseCFv
+			static uint64 GetPostDate(DownloadedDataBase* _this)
+			{
+				return _this->postDate;
+			}
+
+			// GetFeeling__Q3_2nn3olv18DownloadedDataBaseCFv
+			static uint32 GetFeeling(DownloadedDataBase* _this)
+			{
+				if(_this->feeling >= 6)
+					return 0;
+				return _this->feeling;
+			}
+
+			// GetRegionId__Q3_2nn3olv18DownloadedDataBaseCFv
+			static uint32 GetRegionId(DownloadedDataBase* _this)
+			{
+				return _this->regionId;
+			}
+
+			// GetPlatformId__Q3_2nn3olv18DownloadedDataBaseCFv
+			static uint32 GetPlatformId(DownloadedDataBase* _this)
+			{
+				return _this->platformId;
+			}
+
+			// GetLanguageId__Q3_2nn3olv18DownloadedDataBaseCFv
+			static uint32 GetLanguageId(DownloadedDataBase* _this)
+			{
+				return _this->languageId;
+			}
+
+			// GetCountryId__Q3_2nn3olv18DownloadedDataBaseCFv
+			static uint32 GetCountryId(DownloadedDataBase* _this)
+			{
+				return _this->countryId;
+			}
+
+			// GetExternalUrl__Q3_2nn3olv18DownloadedDataBaseCFv
+			static uint8be* GetExternalUrl(DownloadedDataBase* _this)
+			{
+				if (!TestFlags(_this, FLAGS::HAS_EXTERNAL_URL))
+					return nullptr;
+				return _this->externalURL;
+			}
+
+			// GetMiiData__Q3_2nn3olv18DownloadedDataBaseCFP12FFLStoreData
+			static nnResult GetMiiData1(DownloadedDataBase* _this, void* miiDataOut)
+			{
+				if (!TestFlags(_this, FLAGS::HAS_MII_DATA))
+					return OLV_RESULT_MISSING_DATA;
+				if (!miiDataOut)
+					return OLV_RESULT_INVALID_PTR;
+				memcpy(miiDataOut, _this->miiData, 96);
+				return OLV_RESULT_SUCCESS;
+			}
+
+			// GetMiiData__Q3_2nn3olv18DownloadedDataBaseCFv
+			static uint8be* GetMiiData2(DownloadedDataBase* _this)
+			{
+				if (!TestFlags(_this, FLAGS::HAS_MII_DATA))
+					return nullptr;
+				return _this->miiData;
+			}
+
+			// GetMiiNickname__Q3_2nn3olv18DownloadedDataBaseCFv
+			static uint16be* GetMiiNickname(DownloadedDataBase* _this)
+			{
+				if (_this->miiNickname[0] == 0)
+					return nullptr;
+				return _this->miiNickname;
+			}
+
+			// GetBodyText__Q3_2nn3olv18DownloadedDataBaseCFPwUi
+			static nnResult GetBodyText(DownloadedDataBase* _this, uint16be* bodyTextOut, uint32 maxLength)
+			{
+				if (!bodyTextOut)
+					return OLV_RESULT_INVALID_PTR;
+				if (maxLength == 0)
+					return OLV_RESULT_NOT_ENOUGH_SIZE;
+				if (!TestFlags(_this, FLAGS::HAS_BODY_TEXT))
+					return OLV_RESULT_MISSING_DATA;
+				memset(bodyTextOut, 0, maxLength * sizeof(uint16));
+				uint32 outputLength = std::min<uint32>(_this->bodyTextLength, maxLength);
+				olv_wstrncpy((char16_t*)bodyTextOut, (char16_t*)_this->bodyText, outputLength);
+				return OLV_RESULT_SUCCESS;
+			}
+
+			// GetBodyMemo__Q3_2nn3olv18DownloadedDataBaseCFPUcPUiUi
+			static nnResult GetBodyMemo(DownloadedDataBase* _this, uint8be* bodyMemoOut, uint32* bodyMemoSizeOut, uint32 maxSize)
+			{
+				if (!bodyMemoOut)
+					return OLV_RESULT_INVALID_PTR;
+				if (maxSize < 0x2582C)
+					return OLV_RESULT_NOT_ENOUGH_SIZE;
+				if (!TestFlags(_this, FLAGS::HAS_BODY_MEMO))
+					return OLV_RESULT_MISSING_DATA;
+				// uncompress TGA
+				uLongf decompressedSize = maxSize;
+				if (uncompress((uint8*)bodyMemoOut, &decompressedSize, (uint8*)_this->compressedMemoBody, _this->compressedMemoBodySize) != Z_OK)
+				{
+					cemuLog_log(LogType::Force, "DownloadedSystemTopicData::GetTitleIconData: uncompress failed");
+					return OLV_RESULT_INVALID_TEXT_FIELD; // status
+				}
+				if(bodyMemoSizeOut)
+					*bodyMemoSizeOut = decompressedSize;
+				// todo - verify TGA header
+				return OLV_RESULT_SUCCESS;
+			}
+
+			// GetTopicTag__Q3_2nn3olv18DownloadedDataBaseCFv
+			static uint16be* GetTopicTag(DownloadedDataBase* _this)
+			{
+				return _this->topicTag;
+			}
+
+			// GetAppData__Q3_2nn3olv18DownloadedDataBaseCFPUcPUiUi
+			static nnResult GetAppData(DownloadedDataBase* _this, uint8be* appDataOut, uint32* appDataSizeOut, uint32 maxSize)
+			{
+				if (!appDataOut)
+					return OLV_RESULT_INVALID_PTR;
+				if (!TestFlags(_this, FLAGS::HAS_APP_DATA))
+					return OLV_RESULT_MISSING_DATA;
+				uint32 outputSize = std::min<uint32>(maxSize, _this->appDataLength);
+				memcpy(appDataOut, _this->appData, outputSize);
+				if(appDataSizeOut)
+					*appDataSizeOut = outputSize;
+				return OLV_RESULT_SUCCESS;
+			}
+
+			// GetAppDataSize__Q3_2nn3olv18DownloadedDataBaseCFv
+			static uint32 GetAppDataSize(DownloadedDataBase* _this)
+			{
+				return _this->appDataLength;
+			}
+
+			// GetPostId__Q3_2nn3olv18DownloadedDataBaseCFv
+			static uint8be* GetPostId(DownloadedDataBase* _this)
+			{
+				return _this->postId;
+			}
+
+			// DownloadExternalImageData__Q3_2nn3olv18DownloadedDataBaseCFPvPUiUi
+			static nnResult DownloadExternalImageData(DownloadedDataBase* _this, void* imageDataOut, uint32be* imageSizeOut, uint32 maxSize);
+
+			// GetExternalImageDataSize__Q3_2nn3olv18DownloadedDataBaseCFv
+			static uint32 GetExternalImageDataSize(DownloadedDataBase* _this)
+			{
+				if (!TestFlags(_this, FLAGS::HAS_EXTERNAL_IMAGE))
+					return 0;
+				return _this->externalImageDataSize;
+			}
+
+			// todo:
+			// DownloadExternalImageData__Q3_2nn3olv18DownloadedDataBaseCFPvPUiUi (implement downloading)
+			// DownloadExternalBinaryData__Q3_2nn3olv18DownloadedDataBaseCFPvPUiUi
+			// GetExternalBinaryDataSize__Q3_2nn3olv18DownloadedDataBaseCFv
+		};
+
+		static_assert(sizeof(DownloadedDataBase) == 0xC008);
+
+		struct DownloadedPostData
+		{
+			DownloadedDataBase downloadedDataBase;
+			uint32be communityId;
+			uint32be empathyCount;
+			uint32be commentCount;
+			uint32be paddingC014[125]; // probably unused?
+
+			// getters
+			// GetCommunityId__Q3_2nn3olv18DownloadedPostDataCFv
+			static uint32 GetCommunityId(DownloadedPostData* _this)
+			{
+				return _this->communityId;
+			}
+
+			// GetEmpathyCount__Q3_2nn3olv18DownloadedPostDataCFv
+			static uint32 GetEmpathyCount(DownloadedPostData* _this)
+			{
+				return _this->empathyCount;
+			}
+
+			// GetCommentCount__Q3_2nn3olv18DownloadedPostDataCFv
+			static uint32 GetCommentCount(DownloadedPostData* _this)
+			{
+				return _this->commentCount;
+			}
+
+			// GetPostId__Q3_2nn3olv18DownloadedPostDataCFv
+			static uint8be* GetPostId(DownloadedPostData* _this)
+			{
+				return _this->downloadedDataBase.postId;
+			}
+
+		};
+
+		static_assert(sizeof(DownloadedPostData) == 0xC208);
+
+		struct DownloadedTopicData
+		{
+			enum class FLAGS
+			{
+				IS_RECOMMENDED = 0x01,
+				HAS_TITLE = 0x02,
+				HAS_ICON_DATA = 0x04,
+			};
+			betype<FLAGS> flags;
+			uint32be communityId;
+			int ukn[1022];
+
+			void SetFlag(FLAGS flag)
+			{
+				flags = (FLAGS)((uint32)flags.value() | (uint32)flag);
+			}
+
+			// GetCommunityId__Q3_2nn3olv19DownloadedTopicDataCFv
+			static uint32 GetCommunityId(DownloadedTopicData* _this)
+			{
+				return _this->communityId;
+			}
+		};
+
+		static_assert(sizeof(DownloadedTopicData) == 0x1000);
+
+		namespace hidden
+		{
+			struct DownloadedSystemPostData
+			{
+				DownloadedPostData downloadedPostData;
+				uint64be titleId;
+				uint32be uknC210[124];
+				uint32be uknC400;
+				uint32be uknC404;
+
+				// getters
+				// GetTitleId__Q4_2nn3olv6hidden24DownloadedSystemPostDataCFv
+				static uint64 GetTitleId(DownloadedSystemPostData* _this)
+				{
+					return _this->titleId;
+				}
+			};
+
+			static_assert(sizeof(DownloadedSystemPostData) == 0xC408);
+
+			struct DownloadedSystemTopicData
+			{
+				DownloadedTopicData downloadedTopicData;
+				uint64be titleId;
+				uint16be titleText[128];
+				uint8be ukn1108[256];
+				uint8be iconData[0x1002C];
+				uint32be iconDataSize;
+				uint64be titleIds[32];
+				uint32be titleIdsCount;
+				uint32be ukn1133C[1841];
+
+				// implement getters as static methods for compatibility with CafeExportRegisterFunc()
+				// TestFlags__Q4_2nn3olv6hidden25DownloadedSystemTopicDataCFUi
+				static bool TestFlags(DownloadedSystemTopicData* _this, DownloadedTopicData::FLAGS flag)
+				{
+					return HAS_FLAG((uint32)_this->downloadedTopicData.flags.value(), (uint32)flag);
+				}
+
+				// GetTitleId__Q4_2nn3olv6hidden25DownloadedSystemTopicDataCFv
+				static uint64 GetTitleId(DownloadedSystemTopicData* _this)
+				{
+					return _this->titleId;
+				}
+
+				// GetTitleIdNum__Q4_2nn3olv6hidden25DownloadedSystemTopicDataCFv
+				static uint32 GetTitleIdNum(DownloadedSystemTopicData* _this)
+				{
+					return _this->titleIdsCount;
+				}
+
+				// GetTitleText__Q4_2nn3olv6hidden25DownloadedSystemTopicDataCFPwUi
+				static nnResult GetTitleText(DownloadedSystemTopicData* _this, uint16be* titleTextOut, uint32 maxLength)
+				{
+					if (!TestFlags(_this, DownloadedTopicData::FLAGS::HAS_TITLE))
+						return OLV_RESULT_MISSING_DATA;
+					if (!titleTextOut)
+						return OLV_RESULT_INVALID_PTR;
+					memset(titleTextOut, 0, maxLength * sizeof(uint16be));
+					if (maxLength > 128)
+						maxLength = 128;
+					olv_wstrncpy((char16_t*)titleTextOut, (char16_t*)_this->titleText, maxLength);
+					return OLV_RESULT_SUCCESS;
+				}
+
+				// GetTitleIconData__Q4_2nn3olv6hidden25DownloadedSystemTopicDataCFPUcPUiUi
+				static nnResult GetTitleIconData(DownloadedSystemTopicData* _this, void* iconDataOut, uint32be* iconSizeOut, uint32 iconDataMaxSize)
+				{
+					if (!TestFlags(_this, DownloadedTopicData::FLAGS::HAS_ICON_DATA))
+						return OLV_RESULT_MISSING_DATA;
+					if (!iconDataOut)
+						return OLV_RESULT_INVALID_PTR;
+					if (iconDataMaxSize < 0x1002C)
+						return OLV_RESULT_NOT_ENOUGH_SIZE;
+					uLongf decompressedSize = iconDataMaxSize;
+					if (uncompress((uint8*)iconDataOut, &decompressedSize, (uint8*)_this->iconData, _this->iconDataSize) != Z_OK)
+					{
+						cemuLog_log(LogType::Force, "DownloadedSystemTopicData::GetTitleIconData: uncompress failed");
+						return OLV_RESULT_INVALID_TEXT_FIELD; // status
+					}
+					*iconSizeOut = decompressedSize;
+					// todo - check for TGA
+					return OLV_RESULT_SUCCESS;
+				}
+			};
+
+			static_assert(sizeof(DownloadedSystemTopicData) == 0x13000);
+
+			struct DownloadedSystemTopicDataList
+			{
+				static constexpr size_t MAX_TOPIC_COUNT = 10;
+				static constexpr size_t MAX_POSTS_PER_TOPIC = 300;
+
+				// 0x134B8 sized wrapper of DownloadedSystemTopicData
+				struct DownloadedSystemTopicWrapped
+				{
+					DownloadedSystemTopicData downloadedSystemTopicData;
+					uint32be postDataNum;
+					MEMPTR<DownloadedSystemPostData> postDataList[MAX_POSTS_PER_TOPIC];
+					uint32 uknPadding;
+				};
+				static_assert(offsetof(DownloadedSystemTopicWrapped, postDataNum) == 0x13000);
+				static_assert(sizeof(DownloadedSystemTopicWrapped) == 0x134B8);
+
+				static uint32 GetDownloadedSystemTopicDataNum(DownloadedSystemTopicDataList* _this)
+				{
+					return _this->topicDataNum;
+				};
+
+				static uint32 GetDownloadedSystemPostDataNum(DownloadedSystemTopicDataList* _this, uint32 topicIndex)
+				{
+					if(topicIndex >= MAX_TOPIC_COUNT)
+						return 0;
+					return _this->topicData[topicIndex].postDataNum;
+				};
+
+				static DownloadedSystemTopicData* GetDownloadedSystemTopicData(DownloadedSystemTopicDataList* _this, uint32 topicIndex)
+				{
+					if(topicIndex >= MAX_TOPIC_COUNT)
+						return nullptr;
+					return &_this->topicData[topicIndex].downloadedSystemTopicData;
+				};
+
+				static DownloadedSystemPostData* GetDownloadedSystemPostData(DownloadedSystemTopicDataList* _this, sint32 topicIndex, sint32 postIndex)
+				{
+					if (topicIndex >= MAX_TOPIC_COUNT || postIndex >= MAX_POSTS_PER_TOPIC)
+						return nullptr;
+					return _this->topicData[topicIndex].postDataList[postIndex];
+				}
+
+				// member variables
+				uint32be topicDataNum;
+				uint32be ukn4;
+				DownloadedSystemTopicWrapped topicData[MAX_TOPIC_COUNT];
+				uint32be uknC0F38[50];
+			};
+
+			static_assert(sizeof(DownloadedSystemTopicDataList) == 0xC1000);
+		}
+
+
+		struct DownloadPostDataListParam
+		{
+			static constexpr size_t MAX_NUM_SEARCH_PID = 12;
+			static constexpr size_t MAX_NUM_SEARCH_KEY = 5;
+			static constexpr size_t MAX_NUM_POST_ID = 20;
+
+			enum class FLAGS
+			{
+				FRIENDS_ONLY = 0x01, // friends only
+				FOLLOWERS_ONLY = 0x02, // followers only
+				SELF_ONLY = 0x04, // self only
+				ONLY_TYPE_TEXT = 0x08,
+				ONLY_TYPE_MEMO = 0x10,
+				UKN_20 = 0x20,
+				WITH_MII = 0x40, // with mii
+				WITH_EMPATHY = 0x80, // with yeahs added
+				UKN_100 = 0x100,
+				UKN_200 = 0x200, // "is_delay" parameter
+				UKN_400 = 0x400, // "is_hot" parameter
+
+
+			};
+
+			struct SearchKey
+			{
+				uint16be str[152];
+			};
+
+			struct PostId
+			{
+				char str[32];
+			};
+
+			betype<FLAGS> flags;
+			uint32be communityId;
+			uint32be searchPid[MAX_NUM_SEARCH_PID];
+			uint8 languageId;
+			uint8 hasLanguageId_039;
+			uint8 padding03A[2];
+			uint32be postDataMaxNum;
+			SearchKey searchKeyArray[MAX_NUM_SEARCH_KEY];
+			PostId searchPostId[MAX_NUM_POST_ID];
+			uint64be postDate; // OSTime?
+			uint64be titleId; // only used by System posts?
+			uint32be bodyTextMaxLength;
+			uint8 padding8C4[1852];
+
+			bool _HasFlag(FLAGS flag)
+			{
+				return ((uint32)flags.value() & (uint32)flag) != 0;
+			}
+
+			void _SetFlags(FLAGS flag)
+			{
+				flags = (FLAGS)((uint32)flags.value() | (uint32)flag);
+			}
+
+			// constructor and getters
+			// __ct__Q3_2nn3olv25DownloadPostDataListParamFv
+			static DownloadPostDataListParam* Construct(DownloadPostDataListParam* _this)
+			{
+				memset(_this, 0, sizeof(DownloadPostDataListParam));
+				return _this;
+			}
+
+			// SetFlags__Q3_2nn3olv25DownloadPostDataListParamFUi
+			static nnResult SetFlags(DownloadPostDataListParam* _this, FLAGS flags)
+			{
+				// todo - verify flag combos
+				_this->flags = flags;
+				return OLV_RESULT_SUCCESS;
+			}
+
+			// SetLanguageId__Q3_2nn3olv25DownloadPostDataListParamFUc
+			static nnResult SetLanguageId(DownloadPostDataListParam* _this, uint8 languageId)
+			{
+				_this->languageId = languageId;
+				_this->hasLanguageId_039 = 1;
+				return OLV_RESULT_SUCCESS;
+			}
+
+			// SetCommunityId__Q3_2nn3olv25DownloadPostDataListParamFUi
+			static nnResult SetCommunityId(DownloadPostDataListParam* _this, uint32 communityId)
+			{
+				_this->communityId = communityId;
+				return OLV_RESULT_SUCCESS;
+			}
+
+			// SetSearchKey__Q3_2nn3olv25DownloadPostDataListParamFPCwUc
+			static nnResult SetSearchKey(DownloadPostDataListParam* _this, const uint16be* searchKey, uint8 searchKeyIndex)
+			{
+				if( !searchKey )
+				{
+					memset(&_this->searchKeyArray[searchKeyIndex], 0, sizeof(SearchKey));
+					return OLV_RESULT_SUCCESS;
+				}
+				if (searchKeyIndex >= MAX_NUM_SEARCH_KEY)
+					return OLV_RESULT_INVALID_PARAMETER;
+				memset(&_this->searchKeyArray[searchKeyIndex], 0, sizeof(SearchKey));
+				if(olv_wstrnlen((const char16_t*)searchKey, 152) > 50)
+				{
+					cemuLog_log(LogType::Force, "DownloadPostDataListParam::SetSearchKey: searchKey is too long\n");
+					return OLV_RESULT_INVALID_PARAMETER;
+				}
+				SetStringUC2(_this->searchKeyArray[searchKeyIndex].str, searchKey);
+				return OLV_RESULT_SUCCESS;
+			}
+
+			// SetSearchKey__Q3_2nn3olv25DownloadPostDataListParamFPCw
+			static nnResult SetSearchKeySingle(DownloadPostDataListParam* _this, const uint16be* searchKey)
+			{
+				if (searchKey == nullptr)
+				{
+					cemuLog_logDebug(LogType::NN_OLV, "DownloadPostDataListParam::SetSearchKeySingle: searchKeySingle is Null\n");			
+					return OLV_RESULT_INVALID_PARAMETER;
+				}
+				return SetSearchKey(_this, searchKey, 0);
+			}
+
+			// SetSearchPid__Q3_2nn3olv25DownloadPostDataListParamFUi
+			static nnResult SetSearchPid(DownloadPostDataListParam* _this, uint32 searchPid)
+			{
+				if(_this->_HasFlag(FLAGS::FRIENDS_ONLY) || _this->_HasFlag(FLAGS::FOLLOWERS_ONLY) || _this->_HasFlag(FLAGS::SELF_ONLY))
+					return OLV_RESULT_INVALID_PARAMETER;
+				_this->searchPid[0] = searchPid;
+				return OLV_RESULT_SUCCESS;
+			}
+
+			// SetPostId__Q3_2nn3olv25DownloadPostDataListParamFPCcUi
+			static nnResult SetPostId(DownloadPostDataListParam* _this, const char* postId, uint32 postIdIndex)
+			{
+				if (postIdIndex >= MAX_NUM_POST_ID)
+					return OLV_RESULT_INVALID_PARAMETER;
+				memset(&_this->searchPostId[postIdIndex], 0, sizeof(PostId));
+				if (strlen(postId) > 22)
+				{
+					cemuLog_log(LogType::Force, "DownloadPostDataListParam::SetPostId: postId is too long\n");
+					return OLV_RESULT_INVALID_PARAMETER;
+				}
+				strcpy(_this->searchPostId[postIdIndex].str, postId);
+				return OLV_RESULT_SUCCESS;
+			}
+
+			// SetPostDate__Q3_2nn3olv25DownloadPostDataListParamFL
+			static nnResult SetPostDate(DownloadPostDataListParam* _this, uint64 postDate)
+			{
+				_this->postDate = postDate;
+				return OLV_RESULT_SUCCESS;
+			}
+
+			// SetPostDataMaxNum__Q3_2nn3olv25DownloadPostDataListParamFUi
+			static nnResult SetPostDataMaxNum(DownloadPostDataListParam* _this, uint32 postDataMaxNum)
+			{
+				if(postDataMaxNum == 0)
+					return OLV_RESULT_INVALID_PARAMETER;
+				_this->postDataMaxNum = postDataMaxNum;
+				return OLV_RESULT_SUCCESS;
+			}
+
+			// SetBodyTextMaxLength__Q3_2nn3olv25DownloadPostDataListParamFUi
+			static nnResult SetBodyTextMaxLength(DownloadPostDataListParam* _this, uint32 bodyTextMaxLength)
+			{
+				if(bodyTextMaxLength >= 256)
+					return OLV_RESULT_INVALID_PARAMETER;
+				_this->bodyTextMaxLength = bodyTextMaxLength;
+				return OLV_RESULT_SUCCESS;
+			}
+
+			// GetRawDataUrl__Q3_2nn3olv25DownloadPostDataListParamCFPcUi
+			static nnResult GetRawDataUrl(DownloadPostDataListParam* _this, char* urlOut, uint32 urlMaxSize);
+		};
+
+		static_assert(sizeof(DownloadPostDataListParam) == 0x1000);
+
+		// parsing functions
+		bool ParseXML_DownloadedPostData(DownloadedPostData& obj, pugi::xml_node& xmlNode);
+
+		void loadOlivePostAndTopicTypes();
+	}
+}
\ No newline at end of file
diff --git a/src/Cafe/OS/libs/nn_olv/nn_olv_UploadCommunityTypes.cpp b/src/Cafe/OS/libs/nn_olv/nn_olv_UploadCommunityTypes.cpp
new file mode 100644
index 00000000..21952ceb
--- /dev/null
+++ b/src/Cafe/OS/libs/nn_olv/nn_olv_UploadCommunityTypes.cpp
@@ -0,0 +1,306 @@
+#include "nn_olv_UploadCommunityTypes.h"
+#include <algorithm>
+
+namespace nn
+{
+	namespace olv
+	{
+
+		sint32 UploadCommunityData_AsyncRequestImpl(CurlRequestHelper& req, const char* reqUrl,
+			UploadedCommunityData* pOutData, UploadCommunityDataParam const* pParam);
+
+		sint32 UploadCommunityData_AsyncRequest(CurlRequestHelper& req, const char* reqUrl, coreinit::OSEvent* requestDoneEvent,
+			UploadedCommunityData* pOutData, UploadCommunityDataParam const* pParam
+		)
+		{
+			sint32 res = UploadCommunityData_AsyncRequestImpl(req, reqUrl, pOutData, pParam);
+			coreinit::OSSignalEvent(requestDoneEvent);
+			return res;
+		}
+
+		sint32 UploadCommunityData(UploadedCommunityData* pOutData, UploadCommunityDataParam const* pParam)
+		{
+			if (!nn::olv::g_IsInitialized)
+				return OLV_RESULT_NOT_INITIALIZED;
+			
+			if (!nn::olv::g_IsOnlineMode)
+				return OLV_RESULT_OFFLINE_MODE_REQUEST;
+
+			if (!pParam)
+				return OLV_RESULT_INVALID_PTR;
+
+			if (pOutData)
+				UploadedCommunityData::Clean(pOutData);
+
+			char requestUrl[512];
+			if (pParam->flags & UploadCommunityDataParam::FLAG_DELETION)
+			{
+				if (!pParam->communityId)
+					return OLV_RESULT_INVALID_PARAMETER;
+
+				snprintf(requestUrl, sizeof(requestUrl), "%s/v1/communities/%lu.delete", g_DiscoveryResults.apiEndpoint, pParam->communityId.value());
+			}
+			else
+			{
+				if (pParam->communityId)
+					snprintf(requestUrl, sizeof(requestUrl), "%s/v1/communities/%lu", g_DiscoveryResults.apiEndpoint, pParam->communityId.value());
+				else
+					snprintf(requestUrl, sizeof(requestUrl), "%s/v1/communities", g_DiscoveryResults.apiEndpoint);
+			}
+
+			
+			CurlRequestHelper req;
+			req.initate(ActiveSettings::GetNetworkService(), requestUrl, CurlRequestHelper::SERVER_SSL_CONTEXT::OLIVE);
+			InitializeOliveRequest(req);
+
+			StackAllocator<coreinit::OSEvent> requestDoneEvent;
+			coreinit::OSInitEvent(&requestDoneEvent, coreinit::OSEvent::EVENT_STATE::STATE_NOT_SIGNALED, coreinit::OSEvent::EVENT_MODE::MODE_MANUAL);
+			std::future<sint32> requestRes = std::async(std::launch::async, UploadCommunityData_AsyncRequest, std::ref(req), requestUrl, requestDoneEvent.GetPointer(), pOutData, pParam);
+			coreinit::OSWaitEvent(&requestDoneEvent);
+
+			return requestRes.get();
+		}
+
+		sint32 UploadCommunityData(UploadCommunityDataParam const* pParam)
+		{
+			return UploadCommunityData(nullptr, pParam);
+		}
+
+		sint32 UploadCommunityData_AsyncRequestImpl(CurlRequestHelper& req, const char* reqUrl,
+			UploadedCommunityData* pOutData, UploadCommunityDataParam const* pParam)
+		{
+			sint32 res = OLV_RESULT_SUCCESS;
+
+			std::string base64icon;
+			std::string form_name;
+			std::string form_desc;
+			std::string form_searchKey[5];
+			std::string encodedAppData;
+			uint8* encodedIcon = nullptr;
+
+			struct curl_httppost* post = nullptr;
+			struct curl_httppost* last = nullptr;
+
+			try
+			{
+				if (!pParam->iconData.IsNull())
+				{
+					encodedIcon = new uint8[pParam->iconDataLen];
+					if (encodedIcon)
+					{
+						sint32 iconEncodeRes = EncodeTGA(pParam->iconData.GetPtr(), pParam->iconDataLen, encodedIcon, pParam->iconDataLen, TGACheckType::CHECK_COMMUNITY_ICON);
+						if (iconEncodeRes <= 0)
+						{
+							delete[] encodedIcon;
+							return OLV_RESULT_NOT_ENOUGH_SIZE; // ?
+						}
+
+						base64icon = NCrypto::base64Encode(encodedIcon, iconEncodeRes);
+						res = olv_curlformcode_to_error(
+							curl_formadd(&post, &last,
+								CURLFORM_COPYNAME, "icon",
+								CURLFORM_PTRCONTENTS, base64icon.data(),
+								CURLFORM_CONTENTSLENGTH, base64icon.size(),
+								CURLFORM_END)
+						);
+
+						if (res < 0)
+							throw std::runtime_error("curl_formadd() error! - icon");
+					}
+				}
+
+				if (pParam->titleText[0])
+				{
+					form_name = StringHelpers::ToUtf8((const uint16be*)pParam->titleText, 127);
+					res = olv_curlformcode_to_error(
+						curl_formadd(&post, &last,
+							CURLFORM_COPYNAME, "name",
+							CURLFORM_PTRCONTENTS, form_name.data(),
+							CURLFORM_CONTENTSLENGTH, form_name.size(),
+							CURLFORM_END)
+					);
+
+					if (res < 0)
+						throw std::runtime_error("curl_formadd() error! - name");
+				}
+
+				if (pParam->description[0])
+				{
+					form_desc = StringHelpers::ToUtf8((const uint16be*)pParam->description, 255);
+					res = olv_curlformcode_to_error(
+						curl_formadd(&post, &last,
+							CURLFORM_COPYNAME, "description",
+							CURLFORM_PTRCONTENTS, form_desc.data(),
+							CURLFORM_CONTENTSLENGTH, form_desc.size(),
+							CURLFORM_END)
+					);
+
+
+					if (res < 0)
+						throw std::runtime_error("curl_formadd() error! - description");
+				}
+
+				for (int i = 0; i < 5; i++)
+				{
+					if (pParam->searchKeys[i][0])
+					{
+						form_searchKey[i] = StringHelpers::ToUtf8((const uint16be*)pParam->searchKeys[i], 151);
+						res = olv_curlformcode_to_error(
+							curl_formadd(&post, &last,
+								CURLFORM_COPYNAME, "search_key",
+								CURLFORM_PTRCONTENTS, form_searchKey[i].data(),
+								CURLFORM_CONTENTSLENGTH, form_searchKey[i].size(),
+								CURLFORM_END)
+						);
+
+						if (res < 0)
+							throw std::runtime_error("curl_formadd() error! - search_key");
+					}
+				}
+
+				if (!pParam->appData.IsNull())
+				{
+					encodedAppData = NCrypto::base64Encode(pParam->appData.GetPtr(), pParam->appDataLen);
+					if (encodedAppData.size() < pParam->appDataLen)
+						res = OLV_RESULT_FATAL(101);
+					else
+					{
+						res = olv_curlformcode_to_error(
+							curl_formadd(&post, &last,
+								CURLFORM_COPYNAME, "app_data",
+								CURLFORM_PTRCONTENTS, encodedAppData.data(),
+								CURLFORM_CONTENTSLENGTH, encodedAppData.size(),
+								CURLFORM_END)
+						);
+
+						if (res < 0)
+							throw std::runtime_error("curl_formadd() error! - app_data");
+					}
+				}
+			}
+			catch (const std::runtime_error& error)
+			{
+				cemuLog_log(LogType::Force, "Error in multipart curl -> {}", error.what());
+				curl_formfree(post);
+
+				if (encodedIcon)
+					delete[] encodedIcon;
+
+				return res;
+			}
+
+			curl_easy_setopt(req.getCURL(), CURLOPT_HTTPPOST, post);
+			req.setUseMultipartFormData(true);
+
+			bool reqResult = req.submitRequest(true);
+			long httpCode = 0;
+			curl_easy_getinfo(req.getCURL(), CURLINFO_RESPONSE_CODE, &httpCode);
+
+			if (encodedIcon)
+				delete[] encodedIcon;
+
+			if (!reqResult)
+			{
+				cemuLog_log(LogType::Force, "Failed request: {} ({})", reqUrl, httpCode);
+				if (!(httpCode >= 400))
+					return OLV_RESULT_FAILED_REQUEST;
+			}
+
+			pugi::xml_document doc;
+			if (!doc.load_buffer(req.getReceivedData().data(), req.getReceivedData().size()))
+			{
+				cemuLog_log(LogType::Force, fmt::format("Invalid XML in community upload response"));
+				return OLV_RESULT_INVALID_XML;
+			}
+
+			sint32 responseError = CheckOliveResponse(doc);
+			if (responseError < 0)
+				return responseError;
+
+			if (httpCode != 200)
+				return OLV_RESULT_STATUS(httpCode + 4000);
+			
+			if (pOutData)
+			{
+
+				std::string_view app_data = doc.select_single_node("//app_data").node().child_value();
+				std::string_view community_id = doc.select_single_node("//community_id").node().child_value();
+				std::string_view name = doc.select_single_node("//name").node().child_value();
+				std::string_view description = doc.select_single_node("//description").node().child_value();
+				std::string_view pid = doc.select_single_node("//pid").node().child_value();
+				std::string_view icon = doc.select_single_node("//icon").node().child_value();
+
+				if (app_data.size() != 0)
+				{
+					auto app_data_bin = NCrypto::base64Decode(app_data);
+					if (app_data_bin.size() != 0) {
+						memcpy(pOutData->appData, app_data_bin.data(), std::min(size_t(0x400), app_data_bin.size()));
+						pOutData->flags |= UploadedCommunityData::FLAG_HAS_APP_DATA;
+						pOutData->appDataLen = app_data_bin.size();
+					}
+					else
+						return OLV_RESULT_INVALID_TEXT_FIELD;
+				}
+
+				sint64 community_id_val = StringHelpers::ToInt64(community_id, -1);
+				if (community_id_val == -1)
+					return OLV_RESULT_INVALID_INTEGER_FIELD;
+
+				pOutData->communityId = community_id_val;
+
+				if (name.size() != 0)
+				{
+					auto name_utf16 = StringHelpers::FromUtf8(name);
+					name_utf16.resize(std::min<size_t>(name_utf16.size(), 128));
+					if (name_utf16.size() != 0)
+					{
+						for (int i = 0; i < name_utf16.size(); i++)
+							pOutData->titleText[i] = name_utf16.at(i);
+
+						pOutData->flags |= UploadedCommunityData::FLAG_HAS_TITLE_TEXT;
+						pOutData->titleTextMaxLen = name_utf16.size();
+					}
+					else
+						return OLV_RESULT_INVALID_TEXT_FIELD;
+				}
+
+				if (description.size() != 0)
+				{
+					auto description_utf16 = StringHelpers::FromUtf8(description);
+					description_utf16.resize(std::min<size_t>(description_utf16.size(), 256));
+					if (description_utf16.size() != 0)
+					{
+						for (int i = 0; i < description_utf16.size(); i++)
+							pOutData->description[i] = description_utf16.at(i);
+
+						pOutData->flags |= UploadedCommunityData::FLAG_HAS_DESC_TEXT;
+						pOutData->descriptionMaxLen = description_utf16.size();
+					}
+					else
+						return OLV_RESULT_INVALID_TEXT_FIELD;
+				}
+
+				sint64 pid_val = StringHelpers::ToInt64(pid, -1);
+				if (pid_val == -1)
+					return OLV_RESULT_INVALID_INTEGER_FIELD;
+
+				pOutData->pid = pid_val;
+
+				if (icon.size() != 0)
+				{
+					auto icon_bin = NCrypto::base64Decode(icon);
+					if (icon_bin.size() != 0)
+					{
+						memcpy(pOutData->iconData, icon_bin.data(), std::min(size_t(0x1002c), icon_bin.size()));
+						pOutData->flags |= UploadedCommunityData::FLAG_HAS_ICON_DATA;
+						pOutData->iconDataSize = icon_bin.size();
+					}
+					else
+						return OLV_RESULT_INVALID_TEXT_FIELD;
+				}
+			}
+
+			return OLV_RESULT_SUCCESS;
+		}
+	}
+}
\ No newline at end of file
diff --git a/src/Cafe/OS/libs/nn_olv/nn_olv_UploadCommunityTypes.h b/src/Cafe/OS/libs/nn_olv/nn_olv_UploadCommunityTypes.h
new file mode 100644
index 00000000..2c53f118
--- /dev/null
+++ b/src/Cafe/OS/libs/nn_olv/nn_olv_UploadCommunityTypes.h
@@ -0,0 +1,430 @@
+#pragma once
+
+#include "Cemu/ncrypto/ncrypto.h"
+#include "config/ActiveSettings.h"
+
+#include "Cafe/OS/libs/nn_olv/nn_olv_Common.h"
+
+namespace nn
+{
+	namespace olv
+	{
+		class UploadedCommunityData
+		{
+		public:
+			static const inline uint32 FLAG_HAS_TITLE_TEXT = (1 << 0);
+			static const inline uint32 FLAG_HAS_DESC_TEXT = (1 << 1);
+			static const inline uint32 FLAG_HAS_APP_DATA = (1 << 2);
+			static const inline uint32 FLAG_HAS_ICON_DATA = (1 << 3);
+		
+			UploadedCommunityData()
+			{
+				this->titleTextMaxLen = 0;
+				this->appDataLen = 0;
+				this->descriptionMaxLen = 0;
+				this->pid = 0;
+				this->communityId = 0;
+				this->flags = 0;
+				this->iconDataSize = 0;
+			}
+			static UploadedCommunityData* __ctor(UploadedCommunityData* _this)
+			{
+				if (!_this)
+				{
+					assert_dbg(); // DO NOT CONTINUE, SHOULD NEVER HAPPEN
+					return nullptr;
+				}
+				else
+					return new (_this) UploadedCommunityData();
+			}
+
+			static UploadedCommunityData* Clean(UploadedCommunityData* data)
+			{
+				data->appDataLen = 0;
+				data->pid = 0;
+				data->titleText[0] = 0;
+				data->description[0] = 0;
+				data->appData[0] = 0;
+				data->titleTextMaxLen = 0;
+				data->iconData[0] = 0;
+				data->descriptionMaxLen = 0;
+				data->communityId = 0;
+				data->flags = 0;
+				data->iconDataSize = 0;
+				return data;
+			}
+
+			bool TestFlags(uint32 flags) const
+			{
+				return (this->flags & flags) != 0;
+			}
+			static bool __TestFlags(UploadedCommunityData* _this, uint32 flags)
+			{
+				return _this->TestFlags(flags);
+			}
+
+			uint32 GetCommunityId() const
+			{
+				return this->communityId;
+			}
+			static uint32 __GetCommunityId(UploadedCommunityData* _this)
+			{
+				return _this->GetCommunityId();
+			}
+
+			sint32 GetCommunityCode(char* pBuffer, uint32 bufferSize) const
+			{
+				if (!pBuffer)
+					return OLV_RESULT_INVALID_PTR;
+
+				if (bufferSize <= 12)
+					return OLV_RESULT_NOT_ENOUGH_SIZE;
+
+				uint32 len = 0;
+				if (FormatCommunityCode(pBuffer, &len, this->communityId))
+					return OLV_RESULT_SUCCESS;
+				
+				return OLV_RESULT_INVALID_PARAMETER;
+			}
+			static sint32 __GetCommunityCode(UploadedCommunityData* _this, char* pBuffer, uint32 bufferSize)
+			{
+				return _this->GetCommunityCode(pBuffer, bufferSize);
+			}
+
+			uint32 GetOwnerPid() const
+			{
+				return this->pid;
+			}
+			static uint32 __GetOwnerPid(UploadedCommunityData* _this)
+			{
+				return _this->GetOwnerPid();
+			}
+
+			sint32 GetTitleText(char16_t* pBuffer, uint32 numChars)
+			{
+				if (!pBuffer)
+					return OLV_RESULT_INVALID_PTR;
+				
+				if (numChars)
+				{
+					if (!this->TestFlags(FLAG_HAS_TITLE_TEXT))
+						return OLV_RESULT_MISSING_DATA;
+
+					memset(pBuffer, 0, 2 * numChars);
+					uint32 readSize = this->titleTextMaxLen;
+					if (numChars < readSize)
+						readSize = numChars;
+
+					olv_wstrncpy(pBuffer, this->titleText, readSize);
+					return  OLV_RESULT_SUCCESS;
+				}
+
+				return OLV_RESULT_NOT_ENOUGH_SIZE;
+			}
+			static sint32 __GetTitleText(UploadedCommunityData* _this, char16_t* pBuffer, uint32 numChars)
+			{
+				return _this->GetTitleText(pBuffer, numChars);
+			}
+
+			sint32 GetDescriptionText(char16_t* pBuffer, uint32 numChars)
+			{
+				if (!pBuffer)
+					return OLV_RESULT_INVALID_PTR;
+
+				if (numChars)
+				{
+					if (!this->TestFlags(FLAG_HAS_DESC_TEXT))
+						return OLV_RESULT_MISSING_DATA;
+
+					memset(pBuffer, 0, 2 * numChars);
+					olv_wstrncpy(pBuffer, this->description, numChars);
+					return OLV_RESULT_SUCCESS;
+				}
+
+				return OLV_RESULT_NOT_ENOUGH_SIZE;
+			}
+			static sint32 __GetDescriptionText(UploadedCommunityData* _this, char16_t* pBuffer, uint32 numChars)
+			{
+				return _this->GetDescriptionText(pBuffer, numChars);
+			}
+
+			sint32 GetAppData(uint8* pBuffer, uint32be* pOutSize, uint32 bufferSize)
+			{
+				uint32 appDataSize = bufferSize;
+				if (!pBuffer)
+					return OLV_RESULT_INVALID_PTR;
+				
+				if (bufferSize)
+				{
+					if (!this->TestFlags(FLAG_HAS_APP_DATA))
+						return OLV_RESULT_MISSING_DATA;
+
+					if (this->appDataLen < appDataSize)
+						appDataSize = this->appDataLen;
+
+					memcpy(pBuffer, this->appData, appDataSize);
+					if (pOutSize)
+						*pOutSize = appDataSize;
+
+					return OLV_RESULT_SUCCESS;
+				}
+
+				return OLV_RESULT_NOT_ENOUGH_SIZE;
+			}
+			static sint32 __GetAppData(UploadedCommunityData* _this, uint8* pBuffer, uint32be* pOutSize, uint32 bufferSize)
+			{
+				return _this->GetAppData(pBuffer, pOutSize, bufferSize);
+			}
+
+			uint32 GetAppDataSize() const
+			{
+				if (this->TestFlags(FLAG_HAS_APP_DATA))
+					return this->appDataLen;
+
+				return 0;
+			}
+			static uint32 __GetAppDataSize(UploadedCommunityData* _this)
+			{
+				return _this->GetAppDataSize();
+			}
+
+			sint32 GetIconData(uint8* pBuffer, uint32be* pOutSize, uint32 bufferSize)
+			{
+				if (!pBuffer)
+					return OLV_RESULT_INVALID_PTR;
+
+				if (bufferSize < sizeof(this->iconData))
+					return OLV_RESULT_NOT_ENOUGH_SIZE;
+
+				if (!this->TestFlags(FLAG_HAS_ICON_DATA))
+					return OLV_RESULT_MISSING_DATA;
+
+				sint32 decodeRes = DecodeTGA(this->iconData, this->iconDataSize, pBuffer, bufferSize, TGACheckType::CHECK_COMMUNITY_ICON);
+				if (decodeRes >= 0)
+				{
+					if (pOutSize)
+						*pOutSize = (uint32)decodeRes;
+
+					return OLV_RESULT_SUCCESS;
+				}
+
+				if (pOutSize)
+					*pOutSize = 0;
+
+				if (decodeRes == -1)
+					cemuLog_log(LogType::Force, "OLIVE - icon uncompress failed.\n");
+				else if (decodeRes == -2)
+					cemuLog_log(LogType::Force, "OLIVE - icon decode error. NOT TGA.\n");
+
+				return OLV_RESULT_INVALID_TEXT_FIELD;
+			}
+			static sint32 __GetIconData(UploadedCommunityData* _this, uint8* pBuffer, uint32be* pOutSize, uint32 bufferSize)
+			{
+				return _this->GetIconData(pBuffer, pOutSize, bufferSize);
+			}
+
+		public:
+			uint32be flags;
+			uint32be communityId;
+			uint32be pid;
+			char16_t titleText[128];
+			uint32be titleTextMaxLen;
+			char16_t description[256];
+			uint32be descriptionMaxLen;
+			uint8 appData[1024];
+			uint32be appDataLen;
+			uint8 iconData[65580];
+			uint32be iconDataSize;
+			uint8 unk[6328];
+		};
+		static_assert(sizeof(nn::olv::UploadedCommunityData) == 0x12000, "sizeof(nn::olv::UploadedCommunityData) != 0x12000");
+
+
+		class UploadCommunityDataParam
+		{
+		public:
+			static const inline uint32 FLAG_DELETION = (1 << 0);
+		
+			UploadCommunityDataParam()
+			{
+				this->appDataLen = 0;
+				this->communityId = 0;
+				this->titleId = 0;
+				this->iconData = MEMPTR<uint8>(nullptr);
+				this->appData = MEMPTR<uint8>(nullptr);
+				this->iconDataLen = 0;
+				this->flags = 0;
+				memset(this->titleText, 0, sizeof(this->titleText));
+				memset(this->description, 0, sizeof(this->description));
+				for (int i = 0; i < 5; i++)
+					memset(this->searchKeys[i], 0, sizeof(this->searchKeys[0]));
+			}
+			static UploadCommunityDataParam* __ctor(UploadCommunityDataParam* _this)
+			{
+				if (!_this)
+				{
+					assert_dbg(); // DO NOT CONTINUE, SHOULD NEVER HAPPEN
+					return nullptr;
+				}
+				else
+					return new (_this) UploadCommunityDataParam();
+			}
+
+			sint32 SetFlags(uint32 flags)
+			{
+				this->flags = flags;
+				return OLV_RESULT_SUCCESS;
+			}
+			static sint32 __SetFlags(UploadCommunityDataParam* _this, uint32 flags)
+			{
+				return _this->SetFlags(flags);
+			}
+
+			sint32 SetCommunityId(uint32 communityId)
+			{
+				if (communityId == -1)
+					return OLV_RESULT_INVALID_PARAMETER;
+
+				this->communityId = communityId;
+				return OLV_RESULT_SUCCESS;
+			}
+			static sint32 __SetCommunityId(UploadCommunityDataParam* _this, uint32 communityId)
+			{
+				return _this->SetCommunityId(communityId);
+			}
+
+			sint32 SetAppData(MEMPTR<uint8> pBuffer, uint32 bufferSize)
+			{
+				if (!pBuffer.IsNull())
+				{
+					if (bufferSize - 1 >= 0x400)
+						return OLV_RESULT_NOT_ENOUGH_SIZE;
+
+					this->appData = pBuffer;
+					this->appDataLen = bufferSize;
+				}
+				else
+				{
+					this->appData = MEMPTR<uint8>(nullptr);
+					this->appDataLen = 0;
+				}
+				return OLV_RESULT_SUCCESS;
+			}
+			static sint32 __SetAppData(UploadCommunityDataParam* _this, MEMPTR<uint8> pBuffer, uint32 bufferSize)
+			{
+				return _this->SetAppData(pBuffer, bufferSize);
+			}
+
+			sint32 SetTitleText(char16_t const* pText)
+			{
+				if (pText)
+					return olv_copy_wstr(this->titleText, pText, 127, 128);
+			
+				memset(this->titleText, 0, sizeof(this->titleText));
+				return OLV_RESULT_SUCCESS;
+			}
+			static sint32 __SetTitleText(UploadCommunityDataParam* _this, char16_t const* pText)
+			{
+				return _this->SetTitleText(pText);
+			}
+
+			sint32 SetDescriptionText(char16_t const* pText)
+			{
+				if (pText)
+					return olv_copy_wstr(this->description, pText, 255, 256);
+
+				memset(this->description, 0, sizeof(this->description));
+				return OLV_RESULT_SUCCESS;
+			}
+			static sint32 __SetDescriptionText(UploadCommunityDataParam* _this, char16_t const* pText)
+			{
+				return _this->SetDescriptionText(pText);
+			}
+
+			sint32 SetIconData(MEMPTR<uint8> pBuffer, uint32 bufferSize)
+			{
+				if (!pBuffer.IsNull())
+				{
+					if (bufferSize)
+					{
+						if (bufferSize - 0x10012 < 0x1B)
+						{
+							if (CheckTGA(pBuffer.GetPtr(), bufferSize, TGACheckType::CHECK_COMMUNITY_ICON))
+							{
+								this->iconData = pBuffer;
+								this->iconDataLen = bufferSize;
+								return OLV_RESULT_SUCCESS;
+							}
+							else
+							{
+								cemuLog_log(LogType::Force, "OLIVE - SetIconData: TGA Check Failed.\n");
+								return OLV_RESULT_INVALID_DATA;
+							}
+						}
+						else
+							return OLV_RESULT_NOT_ENOUGH_SIZE;
+					}
+					else
+						return OLV_RESULT_NOT_ENOUGH_SIZE;
+				}
+				else
+				{
+					this->iconData = MEMPTR<uint8>(nullptr);
+					this->iconDataLen = 0;
+					return OLV_RESULT_SUCCESS;
+				}
+			}
+			static sint32 __SetIconData(UploadCommunityDataParam* _this, MEMPTR<uint8> pBuffer, uint32 bufferSize)
+			{
+				return _this->SetIconData(pBuffer, bufferSize);
+			}
+
+		public:
+			uint32be flags;
+			sint32be ___padding_0c;
+			uint64be titleId;
+			uint32be communityId;
+			char16_t titleText[128];
+			char16_t description[256];
+			char16_t searchKeys[5][152];
+			MEMPTR<uint8_t> appData;
+			uint32be appDataLen;
+			MEMPTR<uint8_t> iconData;
+			uint32be iconDataLen;
+			char unk3[1772];
+		};
+		static_assert(sizeof(nn::olv::UploadCommunityDataParam) == 0x1000, "sizeof(nn::olv::UploadCommunityDataParam) != 0x1000");
+
+		sint32 UploadCommunityData(UploadCommunityDataParam const* pParam);
+		sint32 UploadCommunityData(UploadedCommunityData* pOutData, UploadCommunityDataParam const* pParam);
+
+		static void loadOliveUploadCommunityTypes()
+		{
+			cafeExportRegisterFunc(UploadedCommunityData::__ctor, "nn_olv", "__ct__Q3_2nn3olv21UploadedCommunityDataFv", LogType::NN_OLV);
+			cafeExportRegisterFunc(UploadedCommunityData::__TestFlags, "nn_olv", "TestFlags__Q3_2nn3olv21UploadedCommunityDataCFUi", LogType::NN_OLV);
+			cafeExportRegisterFunc(UploadedCommunityData::__GetCommunityId, "nn_olv", "GetCommunityId__Q3_2nn3olv21UploadedCommunityDataCFv", LogType::NN_OLV);
+			cafeExportRegisterFunc(UploadedCommunityData::__GetCommunityCode, "nn_olv", "GetCommunityCode__Q3_2nn3olv21UploadedCommunityDataCFPcUi", LogType::NN_OLV);
+			cafeExportRegisterFunc(UploadedCommunityData::__GetOwnerPid, "nn_olv", "GetOwnerPid__Q3_2nn3olv21UploadedCommunityDataCFv", LogType::NN_OLV);
+			cafeExportRegisterFunc(UploadedCommunityData::__GetTitleText, "nn_olv", "GetTitleText__Q3_2nn3olv21UploadedCommunityDataCFPwUi", LogType::NN_OLV);
+			cafeExportRegisterFunc(UploadedCommunityData::__GetDescriptionText, "nn_olv", "GetDescriptionText__Q3_2nn3olv21UploadedCommunityDataCFPwUi", LogType::NN_OLV);
+			cafeExportRegisterFunc(UploadedCommunityData::__GetAppData, "nn_olv", "GetAppData__Q3_2nn3olv21UploadedCommunityDataCFPUcPUiUi", LogType::NN_OLV);
+			cafeExportRegisterFunc(UploadedCommunityData::__GetAppDataSize, "nn_olv", "GetAppDataSize__Q3_2nn3olv21UploadedCommunityDataCFv", LogType::NN_OLV);
+			cafeExportRegisterFunc(UploadedCommunityData::__GetIconData, "nn_olv", "GetIconData__Q3_2nn3olv21UploadedCommunityDataCFPUcPUiUi", LogType::NN_OLV);
+		
+			cafeExportRegisterFunc(UploadCommunityDataParam::__ctor, "nn_olv", "__ct__Q3_2nn3olv24UploadCommunityDataParamFv", LogType::NN_OLV);
+			cafeExportRegisterFunc(UploadCommunityDataParam::__SetFlags, "nn_olv", "SetFlags__Q3_2nn3olv24UploadCommunityDataParamFUi", LogType::NN_OLV);
+			cafeExportRegisterFunc(UploadCommunityDataParam::__SetCommunityId, "nn_olv", "SetCommunityId__Q3_2nn3olv24UploadCommunityDataParamFUi", LogType::NN_OLV);
+			cafeExportRegisterFunc(UploadCommunityDataParam::__SetAppData, "nn_olv", "SetAppData__Q3_2nn3olv24UploadCommunityDataParamFPCUcUi", LogType::NN_OLV);
+			cafeExportRegisterFunc(UploadCommunityDataParam::__SetTitleText, "nn_olv", "SetTitleText__Q3_2nn3olv24UploadCommunityDataParamFPCw", LogType::NN_OLV);
+			cafeExportRegisterFunc(UploadCommunityDataParam::__SetDescriptionText, "nn_olv", "SetDescriptionText__Q3_2nn3olv24UploadCommunityDataParamFPCw", LogType::NN_OLV);
+			cafeExportRegisterFunc(UploadCommunityDataParam::__SetIconData, "nn_olv", "SetIconData__Q3_2nn3olv24UploadCommunityDataParamFPCUcUi", LogType::NN_OLV);
+
+			cafeExportRegisterFunc((sint32(*)(UploadCommunityDataParam const*))UploadCommunityData,
+				"nn_olv", "UploadCommunityData__Q2_2nn3olvFPCQ3_2nn3olv24UploadCommunityDataParam", LogType::NN_OLV);
+		
+			cafeExportRegisterFunc((sint32(*)(UploadedCommunityData *, UploadCommunityDataParam const*))UploadCommunityData,
+				"nn_olv", "UploadCommunityData__Q2_2nn3olvFPQ3_2nn3olv21UploadedCommunityDataPCQ3_2nn3olv24UploadCommunityDataParam", LogType::NN_OLV);
+		}
+
+	}
+}
\ No newline at end of file
diff --git a/src/Cafe/OS/libs/nn_olv/nn_olv_UploadFavoriteTypes.cpp b/src/Cafe/OS/libs/nn_olv/nn_olv_UploadFavoriteTypes.cpp
new file mode 100644
index 00000000..912e7a11
--- /dev/null
+++ b/src/Cafe/OS/libs/nn_olv/nn_olv_UploadFavoriteTypes.cpp
@@ -0,0 +1,172 @@
+#include "nn_olv_UploadFavoriteTypes.h"
+#include <algorithm>
+#include <cstddef>
+
+namespace nn
+{
+	namespace olv
+	{
+	
+		sint32 UploadFavoriteToCommunityData_AsyncRequestImpl(CurlRequestHelper& req, const char* reqUrl,
+			UploadedFavoriteToCommunityData* pOutData, const UploadFavoriteToCommunityDataParam* pParam
+		);
+
+		sint32 UploadFavoriteToCommunityData_AsyncRequest(CurlRequestHelper& req, const char* reqUrl, coreinit::OSEvent* requestDoneEvent,
+			UploadedFavoriteToCommunityData* pOutData, const UploadFavoriteToCommunityDataParam* pParam
+		)
+		{
+			sint32 res = UploadFavoriteToCommunityData_AsyncRequestImpl(req, reqUrl, pOutData, pParam);
+			coreinit::OSSignalEvent(requestDoneEvent);
+			return res;
+		}
+
+		sint32 UploadFavoriteToCommunityData(UploadedFavoriteToCommunityData* pOutData, const UploadFavoriteToCommunityDataParam* pParam)
+		{
+			if (!nn::olv::g_IsInitialized)
+				return OLV_RESULT_NOT_INITIALIZED;
+
+			if (!nn::olv::g_IsOnlineMode)
+				return OLV_RESULT_OFFLINE_MODE_REQUEST;
+
+			if (!pParam)
+				return OLV_RESULT_INVALID_PTR;
+
+			if (pOutData)
+				UploadedFavoriteToCommunityData::Clean(pOutData);
+
+			char requestUrl[512];
+			if (pParam->flags & UploadFavoriteToCommunityDataParam::FLAG_DELETION)
+				snprintf(requestUrl, sizeof(requestUrl), "%s/v1/communities/%lu.unfavorite", g_DiscoveryResults.apiEndpoint, pParam->communityId.value());
+			else 
+				snprintf(requestUrl, sizeof(requestUrl), "%s/v1/communities/%lu.favorite", g_DiscoveryResults.apiEndpoint, pParam->communityId.value());
+			
+			CurlRequestHelper req;
+			req.initate(ActiveSettings::GetNetworkService(), requestUrl, CurlRequestHelper::SERVER_SSL_CONTEXT::OLIVE);
+			InitializeOliveRequest(req);
+
+			StackAllocator<coreinit::OSEvent> requestDoneEvent;
+			coreinit::OSInitEvent(&requestDoneEvent, coreinit::OSEvent::EVENT_STATE::STATE_NOT_SIGNALED, coreinit::OSEvent::EVENT_MODE::MODE_MANUAL);
+			std::future<sint32> requestRes = std::async(std::launch::async, UploadFavoriteToCommunityData_AsyncRequest, std::ref(req), requestUrl, requestDoneEvent.GetPointer(), pOutData, pParam);
+			coreinit::OSWaitEvent(&requestDoneEvent);
+
+			return requestRes.get();
+		}
+
+		sint32 UploadFavoriteToCommunityData(const UploadFavoriteToCommunityDataParam* pParam)
+		{
+			return UploadFavoriteToCommunityData(nullptr, pParam);
+		}
+
+		sint32 UploadFavoriteToCommunityData_AsyncRequestImpl(CurlRequestHelper& req, const char* reqUrl,
+			UploadedFavoriteToCommunityData* pOutData, const UploadFavoriteToCommunityDataParam* pParam
+		)
+		{
+			bool reqResult = req.submitRequest(true);
+			long httpCode = 0;
+			curl_easy_getinfo(req.getCURL(), CURLINFO_RESPONSE_CODE, &httpCode);
+
+			if (!reqResult)
+			{
+				cemuLog_log(LogType::Force, "Failed request: {} ({})", reqUrl, httpCode);
+				if (!(httpCode >= 400))
+					return OLV_RESULT_FAILED_REQUEST;
+			}
+
+			pugi::xml_document doc;
+			if (!doc.load_buffer(req.getReceivedData().data(), req.getReceivedData().size()))
+			{
+				cemuLog_log(LogType::Force, fmt::format("Invalid XML in community favorite upload response"));
+				return OLV_RESULT_INVALID_XML;
+			}
+
+			sint32 responseError = CheckOliveResponse(doc);
+			if (responseError < 0)
+				return responseError;
+
+			if (httpCode != 200)
+				return OLV_RESULT_STATUS(httpCode + 4000);
+
+			if (pOutData)
+			{
+				std::string_view app_data = doc.select_single_node("//app_data").node().child_value();
+				std::string_view community_id = doc.select_single_node("//community_id").node().child_value();
+				std::string_view name = doc.select_single_node("//name").node().child_value();
+				std::string_view description = doc.select_single_node("//description").node().child_value();
+				std::string_view pid = doc.select_single_node("//pid").node().child_value();
+				std::string_view icon = doc.select_single_node("//icon").node().child_value();
+
+				if (app_data.size() != 0)
+				{
+					auto app_data_bin = NCrypto::base64Decode(app_data);
+					if (app_data_bin.size() != 0)
+					{
+						memcpy(pOutData->appData, app_data_bin.data(), std::min(size_t(0x400), app_data_bin.size()));
+						pOutData->flags |= UploadedFavoriteToCommunityData::FLAG_HAS_APP_DATA;
+						pOutData->appDataLen = app_data_bin.size();
+					}
+					else
+						return OLV_RESULT_INVALID_TEXT_FIELD;
+				}
+
+				sint64 community_id_val = StringHelpers::ToInt64(community_id, -1);
+				if (community_id_val == -1)
+					return OLV_RESULT_INVALID_INTEGER_FIELD;
+
+				pOutData->communityId = community_id_val;
+
+				if (name.size() != 0)
+				{
+					auto name_utf16 = StringHelpers::FromUtf8(name);
+					name_utf16.resize(std::min<size_t>(name_utf16.size(), 128));
+					if (name_utf16.size() != 0)
+					{
+						for (int i = 0; i < name_utf16.size(); i++)
+							pOutData->titleText[i] = name_utf16.at(i);
+
+						pOutData->flags |= UploadedFavoriteToCommunityData::FLAG_HAS_TITLE_TEXT;
+						pOutData->titleTextMaxLen = name_utf16.size();
+					}
+					else
+						return OLV_RESULT_INVALID_TEXT_FIELD;
+				}
+
+				if (description.size() != 0)
+				{
+					auto description_utf16 = StringHelpers::FromUtf8(description);
+					description_utf16.resize(std::min<size_t>(description_utf16.size(), 256));
+					if (description_utf16.size() != 0)
+					{
+						for (int i = 0; i < description_utf16.size(); i++)
+							pOutData->description[i] = description_utf16.at(i);
+
+						pOutData->flags |= UploadedFavoriteToCommunityData::FLAG_HAS_DESC_TEXT;
+						pOutData->descriptionMaxLen = description_utf16.size();
+					}
+					else
+						return OLV_RESULT_INVALID_TEXT_FIELD;
+				}
+
+				sint64 pid_val = StringHelpers::ToInt64(pid, -1);
+				if (pid_val == -1)
+					return OLV_RESULT_INVALID_INTEGER_FIELD;
+
+				pOutData->pid = pid_val;
+
+				if (icon.size() != 0)
+				{
+					auto icon_bin = NCrypto::base64Decode(icon);
+					if (icon_bin.size() != 0)
+					{
+						memcpy(pOutData->iconData, icon_bin.data(), std::min(size_t(0x1002c), icon_bin.size()));
+						pOutData->flags |= UploadedFavoriteToCommunityData::FLAG_HAS_ICON_DATA;
+						pOutData->iconDataSize = icon_bin.size();
+					}
+					else
+						return OLV_RESULT_INVALID_TEXT_FIELD;
+				}
+			}
+
+			return OLV_RESULT_SUCCESS;
+		}
+	}
+}
\ No newline at end of file
diff --git a/src/Cafe/OS/libs/nn_olv/nn_olv_UploadFavoriteTypes.h b/src/Cafe/OS/libs/nn_olv/nn_olv_UploadFavoriteTypes.h
new file mode 100644
index 00000000..dfa43ec3
--- /dev/null
+++ b/src/Cafe/OS/libs/nn_olv/nn_olv_UploadFavoriteTypes.h
@@ -0,0 +1,342 @@
+#pragma once
+
+#include "Cemu/ncrypto/ncrypto.h"
+#include "config/ActiveSettings.h"
+
+#include "Cafe/OS/libs/nn_olv/nn_olv_Common.h"
+
+namespace nn
+{
+	namespace olv
+	{
+		class UploadedFavoriteToCommunityData
+		{
+		public:
+			static const inline uint32 FLAG_HAS_TITLE_TEXT = (1 << 0);
+			static const inline uint32 FLAG_HAS_DESC_TEXT = (1 << 1);
+			static const inline uint32 FLAG_HAS_APP_DATA = (1 << 2);
+			static const inline uint32 FLAG_HAS_ICON_DATA = (1 << 3);
+		
+			UploadedFavoriteToCommunityData()
+			{
+				this->titleTextMaxLen = 0;
+				this->appDataLen = 0;
+				this->descriptionMaxLen = 0;
+				this->pid = 0;
+				this->communityId = 0;
+				this->flags = 0;
+				this->iconDataSize = 0;
+			}
+			static UploadedFavoriteToCommunityData* __ctor(UploadedFavoriteToCommunityData* _this)
+			{
+				if (!_this)
+				{
+					assert_dbg(); // DO NOT CONTINUE, SHOULD NEVER HAPPEN
+					return nullptr;
+				} 
+				else
+					return new (_this) UploadedFavoriteToCommunityData();
+			}
+
+			static UploadedFavoriteToCommunityData* Clean(UploadedFavoriteToCommunityData* data)
+			{
+				data->appDataLen = 0;
+				data->pid = 0;
+				data->titleText[0] = 0;
+				data->description[0] = 0;
+				data->appData[0] = 0;
+				data->titleTextMaxLen = 0;
+				data->iconData[0] = 0;
+				data->descriptionMaxLen = 0;
+				data->communityId = 0;
+				data->flags = 0;
+				data->iconDataSize = 0;
+				return data;
+			}
+
+			bool TestFlags(uint32 flags) const
+			{
+				return (this->flags & flags) != 0;
+			}
+			static bool __TestFlags(UploadedFavoriteToCommunityData* _this, uint32 flags)
+			{
+				return _this->TestFlags(flags);
+			}
+
+			uint32 GetCommunityId() const
+			{
+				return this->communityId;
+			}
+			static uint32 __GetCommunityId(UploadedFavoriteToCommunityData* _this)
+			{
+				return _this->GetCommunityId();
+			}
+
+			sint32 GetCommunityCode(char* pBuffer, uint32 bufferSize) const
+			{
+				if (!pBuffer)
+					return OLV_RESULT_INVALID_PTR;
+
+				if (bufferSize <= 12)
+					return OLV_RESULT_NOT_ENOUGH_SIZE;
+
+				uint32 len = 0;
+				if (FormatCommunityCode(pBuffer, &len, this->communityId))
+					return OLV_RESULT_SUCCESS;
+				
+				return OLV_RESULT_INVALID_PARAMETER;
+			}
+			static sint32 __GetCommunityCode(UploadedFavoriteToCommunityData* _this, char* pBuffer, uint32 bufferSize)
+			{
+				return _this->GetCommunityCode(pBuffer, bufferSize);
+			}
+
+			uint32 GetOwnerPid() const
+			{
+				return this->pid;
+			}
+			static uint32 __GetOwnerPid(UploadedFavoriteToCommunityData* _this)
+			{
+				return _this->GetOwnerPid();
+			}
+
+			sint32 GetTitleText(char16_t* pBuffer, uint32 numChars)
+			{
+				if (!pBuffer)
+					return OLV_RESULT_INVALID_PTR;
+				
+				if (numChars)
+				{
+					if (!this->TestFlags(FLAG_HAS_TITLE_TEXT))
+						return OLV_RESULT_MISSING_DATA;
+
+					memset(pBuffer, 0, 2 * numChars);
+					uint32 readSize = this->titleTextMaxLen;
+					if (numChars < readSize)
+						readSize = numChars;
+
+					olv_wstrncpy(pBuffer, this->titleText, readSize);
+					return OLV_RESULT_SUCCESS;
+				}
+
+				return OLV_RESULT_NOT_ENOUGH_SIZE;
+			}
+			static sint32 __GetTitleText(UploadedFavoriteToCommunityData* _this, char16_t* pBuffer, uint32 numChars)
+			{
+				return _this->GetTitleText(pBuffer, numChars);
+			}
+
+			sint32 GetDescriptionText(char16_t* pBuffer, uint32 numChars)
+			{
+				if (!pBuffer)
+					return OLV_RESULT_INVALID_PTR;
+
+				if (numChars)
+				{
+					if (!this->TestFlags(FLAG_HAS_DESC_TEXT))
+						return OLV_RESULT_MISSING_DATA;
+
+					memset(pBuffer, 0, 2 * numChars);
+					olv_wstrncpy(pBuffer, this->description, numChars);
+					return OLV_RESULT_SUCCESS;
+				}
+
+				return OLV_RESULT_NOT_ENOUGH_SIZE;
+			}
+			static sint32 __GetDescriptionText(UploadedFavoriteToCommunityData* _this, char16_t* pBuffer, uint32 numChars)
+			{
+				return _this->GetDescriptionText(pBuffer, numChars);
+			}
+
+			sint32 GetAppData(uint8* pBuffer, uint32be* pOutSize, uint32 bufferSize)
+			{
+				uint32 appDataSize = bufferSize;
+				if (!pBuffer)
+					return OLV_RESULT_INVALID_PTR;
+				
+				if (bufferSize)
+				{
+					if (!this->TestFlags(FLAG_HAS_APP_DATA))
+						return OLV_RESULT_MISSING_DATA;
+
+					if (this->appDataLen < appDataSize)
+						appDataSize = this->appDataLen;
+
+					memcpy(pBuffer, this->appData, appDataSize);
+					if (pOutSize)
+						*pOutSize = appDataSize;
+
+					return OLV_RESULT_SUCCESS;
+				}
+
+				return OLV_RESULT_NOT_ENOUGH_SIZE;
+			}
+			static sint32 __GetAppData(UploadedFavoriteToCommunityData* _this, uint8* pBuffer, uint32be* pOutSize, uint32 bufferSize)
+			{
+				return _this->GetAppData(pBuffer, pOutSize, bufferSize);
+			}
+
+			uint32 GetAppDataSize() const
+			{
+				if (this->TestFlags(FLAG_HAS_APP_DATA))
+					return this->appDataLen;
+
+				return 0;
+			}
+			static uint32 __GetAppDataSize(UploadedFavoriteToCommunityData* _this)
+			{
+				return _this->GetAppDataSize();
+			}
+
+			sint32 GetIconData(uint8* pBuffer, uint32be* pOutSize, uint32 bufferSize)
+			{
+				if (!pBuffer)
+					return OLV_RESULT_INVALID_PTR;
+
+				if (bufferSize < sizeof(this->iconData))
+					return OLV_RESULT_NOT_ENOUGH_SIZE;
+
+				if (!this->TestFlags(FLAG_HAS_ICON_DATA))
+					return OLV_RESULT_MISSING_DATA;
+
+				sint32 decodeRes = DecodeTGA(this->iconData, this->iconDataSize, pBuffer, bufferSize, TGACheckType::CHECK_COMMUNITY_ICON);
+				if (decodeRes >= 0)
+				{
+					if (pOutSize)
+						*pOutSize = (uint32)decodeRes;
+
+					return OLV_RESULT_SUCCESS;
+				}
+
+				if (pOutSize)
+					*pOutSize = 0;
+
+				if (decodeRes == -1)
+					cemuLog_log(LogType::Force, "OLIVE - icon uncompress failed.\n");
+				else if (decodeRes == -2)
+					cemuLog_log(LogType::Force, "OLIVE - icon decode error. NOT TGA.\n");
+
+				return OLV_RESULT_INVALID_TEXT_FIELD;
+			}
+			static sint32 __GetIconData(UploadedFavoriteToCommunityData* _this, uint8* pBuffer, uint32be* pOutSize, uint32 bufferSize)
+			{
+				return _this->GetIconData(pBuffer, pOutSize, bufferSize);
+			}
+
+		public:
+			uint32be flags;
+			uint32be communityId;
+			uint32be pid;
+			char16_t titleText[128];
+			uint32be titleTextMaxLen;
+			char16_t description[256];
+			uint32be descriptionMaxLen;
+			uint8 appData[1024];
+			uint32be appDataLen;
+			uint8 iconData[65580];
+			uint32be iconDataSize;
+			uint8 unk[6328];
+		};
+		static_assert(sizeof(nn::olv::UploadedFavoriteToCommunityData) == 0x12000, "sizeof(nn::olv::UploadedFavoriteToCommunityData) != 0x12000");
+
+		class UploadFavoriteToCommunityDataParam
+		{
+
+		public:
+			static const inline uint32 FLAG_DELETION = (1 << 0);
+
+			UploadFavoriteToCommunityDataParam()
+			{
+				this->communityId = 0;
+				this->flags = 0;
+			}
+			static UploadFavoriteToCommunityDataParam* __ctor(UploadFavoriteToCommunityDataParam* _this)
+			{
+				if (!_this)
+				{
+					assert_dbg(); // DO NOT CONTINUE, SHOULD NEVER HAPPEN
+					return nullptr;
+				}
+				else
+					return new (_this) UploadFavoriteToCommunityDataParam();
+			}
+
+			sint32 SetFlags(uint32 flags)
+			{
+				this->flags = flags;
+				return OLV_RESULT_SUCCESS;
+			}
+			static sint32 __SetFlags(UploadFavoriteToCommunityDataParam* _this, uint32 flags)
+			{
+				return _this->SetFlags(flags);
+			}
+
+			sint32 SetCommunityCode(const char* pBuffer)
+			{
+				if (strnlen(pBuffer, 13) != 12)
+					return OLV_RESULT_INVALID_TEXT_FIELD;
+
+				uint32_t id;
+				if (GetCommunityIdFromCode(&id, pBuffer))
+				{
+					this->communityId = id;
+					return OLV_RESULT_SUCCESS;
+				}
+
+				return OLV_RESULT_STATUS(1901);
+			}
+			static sint32 __SetCommunityCode(UploadFavoriteToCommunityDataParam* _this, char* pBuffer)
+			{
+				return _this->SetCommunityCode(pBuffer);
+			}
+
+			sint32 SetCommunityId(uint32 communityId)
+			{
+				if (communityId == -1)
+					return OLV_RESULT_INVALID_PARAMETER;
+
+				this->communityId = communityId;
+				return OLV_RESULT_SUCCESS;
+			}
+			static sint32 __SetCommunityId(UploadFavoriteToCommunityDataParam* _this, uint32 communityId)
+			{
+				return _this->SetCommunityId(communityId);
+			}
+
+		public:
+			uint32be flags;
+			uint32be communityId;
+			uint8 unk[54]; // Unused
+		};
+		static_assert(sizeof(nn::olv::UploadFavoriteToCommunityDataParam) == 64, "sizeof(nn::olv::UploadFavoriteToCommunityDataParam) != 64");
+
+		sint32 UploadFavoriteToCommunityData(const UploadFavoriteToCommunityDataParam* pParam);
+		sint32 UploadFavoriteToCommunityData(UploadedFavoriteToCommunityData* pOutData, const UploadFavoriteToCommunityDataParam* pParam);
+
+		static void loadOliveUploadFavoriteTypes()
+		{
+			cafeExportRegisterFunc(UploadedFavoriteToCommunityData::__ctor, "nn_olv", "__ct__Q3_2nn3olv31UploadedFavoriteToCommunityDataFv", LogType::NN_OLV);
+			cafeExportRegisterFunc(UploadedFavoriteToCommunityData::__TestFlags, "nn_olv", "TestFlags__Q3_2nn3olv31UploadedFavoriteToCommunityDataCFUi", LogType::NN_OLV);
+			cafeExportRegisterFunc(UploadedFavoriteToCommunityData::__GetCommunityId, "nn_olv", "GetCommunityId__Q3_2nn3olv31UploadedFavoriteToCommunityDataCFv", LogType::NN_OLV);
+			cafeExportRegisterFunc(UploadedFavoriteToCommunityData::__GetCommunityCode, "nn_olv", "GetCommunityCode__Q3_2nn3olv31UploadedFavoriteToCommunityDataCFPcUi", LogType::NN_OLV);
+			cafeExportRegisterFunc(UploadedFavoriteToCommunityData::__GetOwnerPid, "nn_olv", "GetOwnerPid__Q3_2nn3olv31UploadedFavoriteToCommunityDataCFv", LogType::NN_OLV);
+			cafeExportRegisterFunc(UploadedFavoriteToCommunityData::__GetTitleText, "nn_olv", "GetTitleText__Q3_2nn3olv31UploadedFavoriteToCommunityDataCFPwUi", LogType::NN_OLV);
+			cafeExportRegisterFunc(UploadedFavoriteToCommunityData::__GetDescriptionText, "nn_olv", "GetDescriptionText__Q3_2nn3olv31UploadedFavoriteToCommunityDataCFPwUi", LogType::NN_OLV);
+			cafeExportRegisterFunc(UploadedFavoriteToCommunityData::__GetAppData, "nn_olv", "GetAppData__Q3_2nn3olv31UploadedFavoriteToCommunityDataCFPUcPUiUi", LogType::NN_OLV);
+			cafeExportRegisterFunc(UploadedFavoriteToCommunityData::__GetAppDataSize, "nn_olv", "GetAppDataSize__Q3_2nn3olv31UploadedFavoriteToCommunityDataCFv", LogType::NN_OLV);
+			cafeExportRegisterFunc(UploadedFavoriteToCommunityData::__GetIconData, "nn_olv", "GetIconData__Q3_2nn3olv31UploadedFavoriteToCommunityDataCFPUcPUiUi", LogType::NN_OLV);
+			
+			cafeExportRegisterFunc(UploadFavoriteToCommunityDataParam::__ctor, "nn_olv", "__ct__Q3_2nn3olv34UploadFavoriteToCommunityDataParamFv", LogType::NN_OLV);
+			cafeExportRegisterFunc(UploadFavoriteToCommunityDataParam::__SetFlags, "nn_olv", "SetFlags__Q3_2nn3olv34UploadFavoriteToCommunityDataParamFUi", LogType::NN_OLV);
+			cafeExportRegisterFunc(UploadFavoriteToCommunityDataParam::__SetCommunityCode, "nn_olv", "SetCommunityCode__Q3_2nn3olv34UploadFavoriteToCommunityDataParamFPCc", LogType::NN_OLV);
+			cafeExportRegisterFunc(UploadFavoriteToCommunityDataParam::__SetCommunityId, "nn_olv", "SetCommunityId__Q3_2nn3olv34UploadFavoriteToCommunityDataParamFUi", LogType::NN_OLV);
+
+			cafeExportRegisterFunc((sint32(*)(const UploadFavoriteToCommunityDataParam*))UploadFavoriteToCommunityData,
+				"nn_olv", "UploadFavoriteToCommunityData__Q2_2nn3olvFPCQ3_2nn3olv34UploadFavoriteToCommunityDataParam", LogType::NN_OLV);
+
+			cafeExportRegisterFunc((sint32(*)(UploadedFavoriteToCommunityData*, const UploadFavoriteToCommunityDataParam*))UploadFavoriteToCommunityData,
+				"nn_olv", "UploadFavoriteToCommunityData__Q2_2nn3olvFPQ3_2nn3olv31UploadedFavoriteToCommunityDataPCQ3_2nn3olv34UploadFavoriteToCommunityDataParam", LogType::NN_OLV);
+		}
+
+	}
+}
\ No newline at end of file
diff --git a/src/Cafe/OS/libs/nn_save/nn_save.cpp b/src/Cafe/OS/libs/nn_save/nn_save.cpp
index a0a8ff7b..31f8ac8e 100644
--- a/src/Cafe/OS/libs/nn_save/nn_save.cpp
+++ b/src/Cafe/OS/libs/nn_save/nn_save.cpp
@@ -72,11 +72,11 @@ namespace save
 		return result != 0;
 	}
 
-	bool GetCurrentTitleApplicationBox(acp::ACPDeviceType* deviceType)
+	bool GetCurrentTitleApplicationBox(nn::acp::ACPDeviceType* deviceType)
 	{
 		if (deviceType)
 		{
-			*deviceType = acp::InternalDeviceType;
+			*deviceType = nn::acp::ACPDeviceType::InternalDeviceType;
 			return true;
 		}
 		return false;
@@ -84,7 +84,7 @@ namespace save
 
 	void UpdateSaveTimeStamp(uint32 persistentId)
 	{
-		acp::ACPDeviceType deviceType;
+		nn::acp::ACPDeviceType deviceType;
 		if (GetCurrentTitleApplicationBox(&deviceType))
 			ACPUpdateSaveTimeStamp(persistentId, CafeSystem::GetForegroundTitleId(), deviceType);
 	}
@@ -118,11 +118,11 @@ namespace save
 		return false;
 	}
 
-	SAVEStatus GetAbsoluteFullPathOtherApplication(uint32 persistentId, uint64 titleId, const char* subDir, char* outPath)
+	FS_RESULT GetAbsoluteFullPathOtherApplication(uint32 persistentId, uint64 titleId, const char* subDir, char* outPath)
 	{
 		uint32be applicationBox;
 		if(acp::ACPGetApplicationBox(&applicationBox, titleId) != acp::ACPStatus::SUCCESS)
-			return (FSStatus)FS_RESULT::NOT_FOUND;
+			return FS_RESULT::NOT_FOUND;
 
 		sint32 written = 0;
 		if(applicationBox == 3)	
@@ -151,48 +151,69 @@ namespace save
 			cemu_assert_unimplemented();
 		}
 		else 
-			return (FSStatus)FS_RESULT::NOT_FOUND;
+			return FS_RESULT::NOT_FOUND;
 
 		if (written < SAVE_MAX_PATH_SIZE - 1)
-			return (FSStatus)FS_RESULT::SUCCESS;
+			return FS_RESULT::SUCCESS;
 
 		cemu_assert_suspicious();
-		return (FSStatus)(FS_RESULT::FATAL_ERROR);
+		return FS_RESULT::FATAL_ERROR;
 	}
 
-	typedef struct
+	struct AsyncResultData
 	{
-		coreinit::OSEvent* event;
-		SAVEStatus returnStatus;
+		MEMPTR<coreinit::OSEvent> event;
+		betype<SAVEStatus> returnStatus;
+	};
 
-		MEMPTR<OSThread_t> thread; // own stuff until cond + event rewritten
-	} AsyncCallbackParam_t;
+	void SaveAsyncFinishCallback(PPCInterpreter_t* hCPU);
 
-	void AsyncCallback(coreinit::FSClient_t* client, coreinit::FSCmdBlock_t* block, uint32 returnStatus, void* p)
+	struct AsyncToSyncWrapper : public FSAsyncParams
 	{
-		cemu_assert_debug(p && ((AsyncCallbackParam_t*)p)->event);
+		AsyncToSyncWrapper()
+		{
+			coreinit::OSInitEvent(&_event, coreinit::OSEvent::EVENT_STATE::STATE_NOT_SIGNALED, coreinit::OSEvent::EVENT_MODE::MODE_AUTO);
+			ioMsgQueue = nullptr;
+			userContext = &_result;
+			userCallback = RPLLoader_MakePPCCallable(SaveAsyncFinishCallback);
+			_result.returnStatus = 0;
+			_result.event = &_event;
+		}
 
-		AsyncCallbackParam_t* param = (AsyncCallbackParam_t*)p;
-		param->returnStatus = returnStatus;
-		coreinit::OSSignalEvent(param->event);
-	}
+		~AsyncToSyncWrapper()
+		{
 
-	void AsyncCallback(PPCInterpreter_t* hCPU)
+		}
+
+		FSAsyncParams* GetAsyncParams()
+		{
+			return this;
+		}
+
+		SAVEStatus GetResult()
+		{
+			return _result.returnStatus;
+		}
+
+		void WaitForEvent()
+		{
+			coreinit::OSWaitEvent(&_event);
+		}
+	  private:
+		coreinit::OSEvent _event;
+		AsyncResultData _result;
+	};
+
+	void SaveAsyncFinishCallback(PPCInterpreter_t* hCPU)
 	{
 		ppcDefineParamMEMPTR(client, coreinit::FSClient_t, 0);
 		ppcDefineParamMEMPTR(block, coreinit::FSCmdBlock_t, 1);
 		ppcDefineParamU32(returnStatus, 2);
 		ppcDefineParamMEMPTR(userContext, void, 3);
 
-		MEMPTR<AsyncCallbackParam_t> param{ userContext };
-
-		// wait till thread is actually suspended
-		OSThread_t* thread = param->thread.GetPtr();
-		while (thread->suspendCounter == 0 || thread->state == OSThread_t::THREAD_STATE::STATE_RUNNING)
-			coreinit::OSYieldThread();
-
-		param->returnStatus = returnStatus;
-		coreinit_resumeThread(param->thread.GetPtr(), 1000);
+		MEMPTR<AsyncResultData> resultPtr{ userContext };
+		resultPtr->returnStatus = returnStatus;
+		coreinit::OSSignalEvent(resultPtr->event);
 
 		osLib_returnFromFunction(hCPU, 0);
 	}
@@ -203,6 +224,11 @@ namespace save
 		return ConvertACPToSaveStatus(status);
 	}
 
+    SAVEStatus SAVEUnmountSaveDir()
+    {
+        return ConvertACPToSaveStatus(acp::ACPUnmountSaveDir());
+    }
+
 	void _CheckAndMoveLegacySaves()
 	{
 		const uint64 titleId = CafeSystem::GetForegroundTitleId();
@@ -309,24 +335,22 @@ namespace save
 			sprintf(path, "%susr/save/%08x/%08x/meta/", "/vol/storage_mlc01/", high, low);
 			fsc_createDir(path, &fscStatus);
 
-			acp::CreateSaveMetaFiles(ActiveSettings::GetPersistentId(), titleId);
+			iosu::acp::CreateSaveMetaFiles(ActiveSettings::GetPersistentId(), titleId);
 		}
 
 		return SAVE_STATUS_OK;
 	}
 
-	SAVEStatus SAVERemoveAsync(coreinit::FSClient_t* client, coreinit::FSCmdBlock_t* block, uint8 accountSlot, const char* path, FS_ERROR_MASK errHandling, const FSAsyncParams_t* asyncParams)
+	SAVEStatus SAVEInitSaveDir(uint8 accountSlot)
 	{
 		SAVEStatus result = (FSStatus)(FS_RESULT::FATAL_ERROR);
-
 		OSLockMutex(&g_nn_save->mutex);
 
 		uint32 persistentId;
 		if (GetPersistentIdEx(accountSlot, &persistentId))
 		{
-			char fullPath[SAVE_MAX_PATH_SIZE];
-			if (GetAbsoluteFullPath(persistentId, path, fullPath))
-				result = coreinit::FSRemoveAsync(client, block, (uint8*)fullPath, errHandling, (FSAsyncParamsNew_t*)asyncParams);
+			acp::ACPStatus status = nn::acp::ACPCreateSaveDir(persistentId, iosu::acp::ACPDeviceType::InternalDeviceType);
+			result = ConvertACPToSaveStatus(status);
 		}
 		else
 			result = (FSStatus)FS_RESULT::NOT_FOUND;
@@ -335,7 +359,7 @@ namespace save
 		return result;
 	}
 
-	SAVEStatus SAVEMakeDirAsync(coreinit::FSClient_t* client, coreinit::FSCmdBlock_t* block, uint8 accountSlot, const char* path, FS_ERROR_MASK errHandling, const FSAsyncParams_t* asyncParams)
+	SAVEStatus SAVEOpenDirAsync(coreinit::FSClient_t* client, coreinit::FSCmdBlock_t* block, uint8 accountSlot, const char* path, FSDirHandlePtr hDir, FS_ERROR_MASK errHandling, const FSAsyncParams* asyncParams)
 	{
 		SAVEStatus result = (FSStatus)(FS_RESULT::FATAL_ERROR);
 
@@ -346,28 +370,7 @@ namespace save
 		{
 			char fullPath[SAVE_MAX_PATH_SIZE];
 			if (GetAbsoluteFullPath(persistentId, path, fullPath))
-				result = coreinit::FSMakeDirAsync(client, block, (uint8*)fullPath, errHandling, (FSAsyncParamsNew_t*)asyncParams);
-		}
-		else
-			result = (FSStatus)FS_RESULT::NOT_FOUND;
-
-		OSUnlockMutex(&g_nn_save->mutex);
-
-		return result;
-	}
-
-	SAVEStatus SAVEOpenDirAsync(coreinit::FSClient_t* client, coreinit::FSCmdBlock_t* block, uint8 accountSlot, const char* path, FSDirHandlePtr hDir, FS_ERROR_MASK errHandling, const FSAsyncParams_t* asyncParams)
-	{
-		SAVEStatus result = (FSStatus)(FS_RESULT::FATAL_ERROR);
-
-		OSLockMutex(&g_nn_save->mutex);
-
-		uint32 persistentId;
-		if (GetPersistentIdEx(accountSlot, &persistentId))
-		{
-			char fullPath[SAVE_MAX_PATH_SIZE];
-			if (GetAbsoluteFullPath(persistentId, path, fullPath))
-				result = coreinit::FSOpenDirAsync(client, block, fullPath, hDir, errHandling, (FSAsyncParamsNew_t*)asyncParams);
+				result = coreinit::FSOpenDirAsync(client, block, fullPath, hDir, errHandling, (FSAsyncParams*)asyncParams);
 			
 		}
 		else
@@ -378,7 +381,70 @@ namespace save
 		return result;
 	}
 
-	SAVEStatus SAVEOpenFileAsync(coreinit::FSClient_t* client, coreinit::FSCmdBlock_t* block, uint8 accountSlot, const char* path,  const char* mode, FSFileHandleDepr_t* hFile, FS_ERROR_MASK errHandling, const FSAsyncParamsNew_t* asyncParams)
+	SAVEStatus SAVEOpenDir(coreinit::FSClient_t* client, coreinit::FSCmdBlock_t* block, uint8 accountSlot, const char* path, FSDirHandlePtr hDir, FS_ERROR_MASK errHandling)
+	{
+		StackAllocator<AsyncToSyncWrapper> asyncData;
+		SAVEStatus status = SAVEOpenDirAsync(client, block, accountSlot, path, hDir, errHandling, asyncData->GetAsyncParams());
+		if (status != (FSStatus)FS_RESULT::SUCCESS)
+			return status;
+		asyncData->WaitForEvent();
+		return asyncData->GetResult();
+	}
+
+	SAVEStatus SAVEOpenDirOtherApplicationAsync(coreinit::FSClient_t* client, coreinit::FSCmdBlock_t* block, uint64 titleId, uint8 accountSlot, const char* path, FSDirHandlePtr hDir, FS_ERROR_MASK errHandling, const FSAsyncParams* asyncParams)
+	{
+		SAVEStatus result = (FSStatus)(FS_RESULT::FATAL_ERROR);
+
+		OSLockMutex(&g_nn_save->mutex);
+		uint32 persistentId;
+		if (GetPersistentIdEx(accountSlot, &persistentId))
+		{
+			char fullPath[SAVE_MAX_PATH_SIZE];
+			if (GetAbsoluteFullPathOtherApplication(persistentId, titleId, path, fullPath) == FS_RESULT::SUCCESS)
+				result = coreinit::FSOpenDirAsync(client, block, fullPath, hDir, errHandling, (FSAsyncParams*)asyncParams);
+		}
+		else
+			result = (FSStatus)FS_RESULT::NOT_FOUND;
+		OSUnlockMutex(&g_nn_save->mutex);
+
+		return result;
+	}
+
+	SAVEStatus SAVEOpenDirOtherApplication(coreinit::FSClient_t* client, coreinit::FSCmdBlock_t* block, uint64 titleId, uint8 accountSlot, const char* path, FSDirHandlePtr hDir, FS_ERROR_MASK errHandling)
+	{
+		StackAllocator<AsyncToSyncWrapper> asyncData;
+		SAVEStatus status = SAVEOpenDirOtherApplicationAsync(client, block, titleId, accountSlot, path, hDir, errHandling, asyncData->GetAsyncParams());
+		if (status != (FSStatus)FS_RESULT::SUCCESS)
+			return status;
+		asyncData->WaitForEvent();
+		return asyncData->GetResult();
+	}
+
+	SAVEStatus SAVEOpenDirOtherNormalApplicationAsync(coreinit::FSClient_t* client, coreinit::FSCmdBlock_t* block, uint32 uniqueId, uint8 accountSlot, const char* path, FSDirHandlePtr hDir, FS_ERROR_MASK errHandling, const FSAsyncParams* asyncParams)
+	{
+		uint64 titleId = SAVE_UNIQUE_TO_TITLE_ID(uniqueId);
+		return SAVEOpenDirOtherApplicationAsync(client, block, titleId, accountSlot, path, hDir, errHandling, asyncParams);
+	}
+
+	SAVEStatus SAVEOpenDirOtherNormalApplication(coreinit::FSClient_t* client, coreinit::FSCmdBlock_t* block, uint32 uniqueId, uint8 accountSlot, const char* path, FSDirHandlePtr hDir, FS_ERROR_MASK errHandling)
+	{
+		uint64 titleId = SAVE_UNIQUE_TO_TITLE_ID(uniqueId);
+		return SAVEOpenDirOtherApplication(client, block, titleId, accountSlot, path, hDir, errHandling);
+	}
+
+	SAVEStatus SAVEOpenDirOtherNormalApplicationVariationAsync(coreinit::FSClient_t* client, coreinit::FSCmdBlock_t* block, uint32 uniqueId, uint8 variation, uint8 accountSlot, const char* path, FSDirHandlePtr hDir, FS_ERROR_MASK errHandling, const FSAsyncParams* asyncParams)
+	{
+		uint64 titleId = SAVE_UNIQUE_TO_TITLE_ID_VARIATION(uniqueId, variation);
+		return SAVEOpenDirOtherApplicationAsync(client, block, titleId, accountSlot, path, hDir, errHandling, asyncParams);
+	}
+
+	SAVEStatus SAVEOpenDirOtherNormalApplicationVariation(coreinit::FSClient_t* client, coreinit::FSCmdBlock_t* block, uint32 uniqueId, uint8 variation, uint8 accountSlot, const char* path, FSDirHandlePtr hDir, FS_ERROR_MASK errHandling)
+	{
+		uint64 titleId = SAVE_UNIQUE_TO_TITLE_ID_VARIATION(uniqueId, variation);
+		return SAVEOpenDirOtherApplication(client, block, titleId, accountSlot, path, hDir, errHandling);
+	}
+
+	SAVEStatus SAVEOpenFileAsync(coreinit::FSClient_t* client, coreinit::FSCmdBlock_t* block, uint8 accountSlot, const char* path, const char* mode, FSFileHandlePtr outFileHandle, FS_ERROR_MASK errHandling, const FSAsyncParams* asyncParams)
 	{
 		SAVEStatus result = (FSStatus)(FS_RESULT::FATAL_ERROR);
 
@@ -389,7 +455,7 @@ namespace save
 		{
 			char fullPath[SAVE_MAX_PATH_SIZE];
 			if (GetAbsoluteFullPath(persistentId, path, fullPath))
-				result = coreinit::FSOpenFileAsync(client, block, fullPath, (char*)mode, hFile, errHandling, (FSAsyncParamsNew_t*)asyncParams);
+				result = coreinit::FSOpenFileAsync(client, block, fullPath, (char*)mode, outFileHandle, errHandling, (FSAsyncParams*)asyncParams);
 		}
 		else
 			result = (FSStatus)FS_RESULT::NOT_FOUND;
@@ -399,7 +465,7 @@ namespace save
 		return result;
 	}
 
-	SAVEStatus SAVEOpenFileOtherApplicationAsync(coreinit::FSClient_t* client, coreinit::FSCmdBlock_t* block, uint64 titleId, uint8 accountSlot, const char* path, const char* mode, FSFileHandleDepr_t* hFile, FS_ERROR_MASK errHandling, const FSAsyncParamsNew_t* asyncParams)
+	SAVEStatus SAVEOpenFileOtherApplicationAsync(coreinit::FSClient_t* client, coreinit::FSCmdBlock_t* block, uint64 titleId, uint8 accountSlot, const char* path, const char* mode, FSFileHandlePtr outFileHandle, FS_ERROR_MASK errHandling, const FSAsyncParams* asyncParams)
 	{
 		if (strcmp(mode, "r") != 0)
 			return (SAVEStatus)(FS_RESULT::PERMISSION_ERROR);
@@ -412,8 +478,8 @@ namespace save
 		if (GetPersistentIdEx(accountSlot, &persistentId))
 		{
 			char fullPath[SAVE_MAX_PATH_SIZE];
-			if (GetAbsoluteFullPathOtherApplication(persistentId, titleId, path, fullPath))
-				result = coreinit::FSOpenFileAsync(client, block, fullPath, (char*)mode, hFile, errHandling, (FSAsyncParamsNew_t*)asyncParams);
+			if (GetAbsoluteFullPathOtherApplication(persistentId, titleId, path, fullPath) == FS_RESULT::SUCCESS)
+				result = coreinit::FSOpenFileAsync(client, block, fullPath, (char*)mode, outFileHandle, errHandling, (FSAsyncParams*)asyncParams);
 		}
 		else
 			result = (FSStatus)FS_RESULT::NOT_FOUND;
@@ -423,173 +489,41 @@ namespace save
 		return result;
 	}
 
-	void export_SAVEOpenFileOtherApplicationAsync(PPCInterpreter_t* hCPU)
+	SAVEStatus SAVEOpenFileOtherApplication(coreinit::FSClient_t* client, coreinit::FSCmdBlock_t* block, uint64 titleId, uint8 accountSlot, const char* path, const char* mode, FSFileHandlePtr outFileHandle, FS_ERROR_MASK errHandling)
 	{
-		ppcDefineParamMEMPTR(fsClient, coreinit::FSClient_t, 0);
-		ppcDefineParamMEMPTR(fsCmdBlock, coreinit::FSCmdBlock_t, 1);
-		ppcDefineParamU64(titleId, 2);
-		ppcDefineParamU8(accountSlot, 4);
-		ppcDefineParamMEMPTR(path, const char, 5);
-		ppcDefineParamMEMPTR(mode, const char, 6);
-		ppcDefineParamMEMPTR(hFile, FSFileHandleDepr_t, 7);
-		ppcDefineParamU32(errHandling, 8);
-		ppcDefineParamMEMPTR(asyncParams, FSAsyncParamsNew_t, 9);
-
-		const SAVEStatus result = SAVEOpenFileOtherApplicationAsync(fsClient.GetPtr(), fsCmdBlock.GetPtr(), titleId, accountSlot, path.GetPtr(), mode.GetPtr(), hFile.GetPtr(), errHandling, asyncParams.GetPtr());
-		osLib_returnFromFunction(hCPU, result);
+		StackAllocator<AsyncToSyncWrapper> asyncData;
+		SAVEStatus status = SAVEOpenFileOtherApplicationAsync(client, block, titleId, accountSlot, path, mode, outFileHandle, errHandling, asyncData->GetAsyncParams());
+		if (status != (FSStatus)FS_RESULT::SUCCESS)
+			return status;
+		asyncData->WaitForEvent();
+		return asyncData->GetResult();
 	}
 
-	SAVEStatus SAVEOpenFileOtherApplication(coreinit::FSClient_t* client, coreinit::FSCmdBlock_t* block, uint64 titleId, uint8 accountSlot, const char* path, const char* mode, FSFileHandleDepr_t* hFile, FS_ERROR_MASK errHandling)
-	{
-		FSAsyncParamsNew_t asyncParams;
-		asyncParams.ioMsgQueue = nullptr;
-		asyncParams.userCallback = PPCInterpreter_makeCallableExportDepr(AsyncCallback);
-
-		StackAllocator<AsyncCallbackParam_t> param;
-		param->thread = coreinitThread_getCurrentThreadMPTRDepr(ppcInterpreterCurrentInstance);
-		param->returnStatus = (FSStatus)FS_RESULT::SUCCESS;
-		asyncParams.userContext = param.GetPointer();
-
-		SAVEStatus status = SAVEOpenFileOtherApplicationAsync(client, block, titleId, accountSlot, path, mode, hFile, errHandling, &asyncParams);
-		if (status == (FSStatus)FS_RESULT::SUCCESS)
-		{
-			coreinit_suspendThread(coreinitThread_getCurrentThreadDepr(ppcInterpreterCurrentInstance), 1000);
-			PPCCore_switchToScheduler();
-			return param->returnStatus;
-		}
-
-		return status;
-	}
-
-	void export_SAVEOpenFileOtherApplication(PPCInterpreter_t* hCPU)
-	{
-		ppcDefineParamMEMPTR(fsClient, coreinit::FSClient_t, 0);
-		ppcDefineParamMEMPTR(fsCmdBlock, coreinit::FSCmdBlock_t, 1);
-		ppcDefineParamU64(titleId, 2);
-		ppcDefineParamU8(accountSlot, 4);
-		ppcDefineParamMEMPTR(path, const char, 5);
-		ppcDefineParamMEMPTR(mode, const char, 6);
-		ppcDefineParamMEMPTR(hFile, FSFileHandleDepr_t, 7);
-		ppcDefineParamU32(errHandling, 8);
-
-		const SAVEStatus result = SAVEOpenFileOtherApplication(fsClient.GetPtr(), fsCmdBlock.GetPtr(), titleId, accountSlot, path.GetPtr(), mode.GetPtr(), hFile.GetPtr(), errHandling);
-		osLib_returnFromFunction(hCPU, result);
-	}
-
-	SAVEStatus SAVEOpenFileOtherNormalApplicationAsync(coreinit::FSClient_t* client, coreinit::FSCmdBlock_t* block, uint32 uniqueId, uint8 accountSlot, const char* path, const char* mode, FSFileHandleDepr_t* hFile, FS_ERROR_MASK errHandling, const FSAsyncParamsNew_t* asyncParams)
+	SAVEStatus SAVEOpenFileOtherNormalApplicationAsync(coreinit::FSClient_t* client, coreinit::FSCmdBlock_t* block, uint32 uniqueId, uint8 accountSlot, const char* path, const char* mode, FSFileHandlePtr outFileHandle, FS_ERROR_MASK errHandling, const FSAsyncParams* asyncParams)
 	{
 		uint64 titleId = SAVE_UNIQUE_TO_TITLE_ID(uniqueId);
-		return SAVEOpenFileOtherApplicationAsync(client, block, titleId, accountSlot, path, mode, hFile, errHandling, asyncParams);
+		return SAVEOpenFileOtherApplicationAsync(client, block, titleId, accountSlot, path, mode, outFileHandle, errHandling, asyncParams);
 	}
 
-	void export_SAVEOpenFileOtherNormalApplicationAsync(PPCInterpreter_t* hCPU)
+	SAVEStatus SAVEOpenFileOtherNormalApplication(coreinit::FSClient_t* client, coreinit::FSCmdBlock_t* block, uint32 uniqueId, uint8 accountSlot, const char* path, const char* mode, FSFileHandlePtr outFileHandle, FS_ERROR_MASK errHandling)
 	{
-		ppcDefineParamMEMPTR(fsClient, coreinit::FSClient_t, 0);
-		ppcDefineParamMEMPTR(fsCmdBlock, coreinit::FSCmdBlock_t, 1);
-		ppcDefineParamU32(uniqueId, 2);
-		ppcDefineParamU8(accountSlot, 3);
-		ppcDefineParamMEMPTR(path, const char, 4);
-		ppcDefineParamMEMPTR(mode, const char, 5);
-		ppcDefineParamMEMPTR(hFile, FSFileHandleDepr_t, 6);
-		ppcDefineParamU32(errHandling, 7);
-		ppcDefineParamMEMPTR(asyncParams, FSAsyncParamsNew_t, 8);
-
-		const SAVEStatus result = SAVEOpenFileOtherNormalApplicationAsync(fsClient.GetPtr(), fsCmdBlock.GetPtr(), uniqueId, accountSlot, path.GetPtr(), mode.GetPtr(), hFile.GetPtr(), errHandling, asyncParams.GetPtr());
-		osLib_returnFromFunction(hCPU, result);
-	}
-	SAVEStatus SAVEOpenFileOtherNormalApplication(coreinit::FSClient_t* client, coreinit::FSCmdBlock_t* block, uint32 uniqueId, uint8 accountSlot, const char* path, const char* mode, FSFileHandleDepr_t* hFile, FS_ERROR_MASK errHandling)
-	{
-		//peterBreak();
-
 		uint64 titleId = SAVE_UNIQUE_TO_TITLE_ID(uniqueId);
-		return SAVEOpenFileOtherApplication(client, block, titleId, accountSlot, path, mode, hFile, errHandling);
+		return SAVEOpenFileOtherApplication(client, block, titleId, accountSlot, path, mode, outFileHandle, errHandling);
 	}
 
-	void export_SAVEOpenFileOtherNormalApplication(PPCInterpreter_t* hCPU)
-	{
-		ppcDefineParamMEMPTR(fsClient, coreinit::FSClient_t, 0);
-		ppcDefineParamMEMPTR(fsCmdBlock, coreinit::FSCmdBlock_t, 1);
-		ppcDefineParamU32(uniqueId, 2);
-		ppcDefineParamU8(accountSlot, 3);
-		ppcDefineParamMEMPTR(path, const char, 4);
-		ppcDefineParamMEMPTR(mode, const char, 5);
-		ppcDefineParamMEMPTR(hFile, FSFileHandleDepr_t, 6);
-		ppcDefineParamU32(errHandling, 7);
-
-		const SAVEStatus result = SAVEOpenFileOtherNormalApplication(fsClient.GetPtr(), fsCmdBlock.GetPtr(), uniqueId, accountSlot, path.GetPtr(), mode.GetPtr(), hFile.GetPtr(), errHandling);
-		osLib_returnFromFunction(hCPU, result);
-	}
-
-	SAVEStatus SAVEOpenFileOtherNormalApplicationVariationAsync(coreinit::FSClient_t* client, coreinit::FSCmdBlock_t* block, uint32 uniqueId, uint8 variation, uint8 accountSlot, const char* path, const char* mode, FSFileHandleDepr_t* hFile, FS_ERROR_MASK errHandling, const FSAsyncParamsNew_t* asyncParams)
-	{
-		//peterBreak();
-
-		uint64 titleId = SAVE_UNIQUE_TO_TITLE_ID_VARIATION(uniqueId, variation);
-		return SAVEOpenFileOtherApplicationAsync(client, block, titleId, accountSlot, path, mode, hFile, errHandling, asyncParams);
-	}
-
-	void export_SAVEOpenFileOtherNormalApplicationVariationAsync(PPCInterpreter_t* hCPU)
-	{
-		ppcDefineParamMEMPTR(fsClient, coreinit::FSClient_t, 0);
-		ppcDefineParamMEMPTR(fsCmdBlock, coreinit::FSCmdBlock_t, 1);
-		ppcDefineParamU32(uniqueId, 2);
-		ppcDefineParamU8(variation, 3);
-		ppcDefineParamU8(accountSlot, 4);
-		ppcDefineParamMEMPTR(path, const char, 5);
-		ppcDefineParamMEMPTR(mode, const char, 6);
-		ppcDefineParamMEMPTR(hFile, FSFileHandleDepr_t, 7);
-		ppcDefineParamU32(errHandling, 8);
-		ppcDefineParamMEMPTR(asyncParams, FSAsyncParamsNew_t, 9);
-
-		const SAVEStatus result = SAVEOpenFileOtherNormalApplicationVariationAsync(fsClient.GetPtr(), fsCmdBlock.GetPtr(), uniqueId, variation, accountSlot, path.GetPtr(), mode.GetPtr(), hFile.GetPtr(), errHandling, asyncParams.GetPtr());
-		osLib_returnFromFunction(hCPU, result);
-	}
-
-	SAVEStatus SAVEOpenFileOtherNormalApplicationVariation(coreinit::FSClient_t* client, coreinit::FSCmdBlock_t* block, uint32 uniqueId, uint8 variation, uint8 accountSlot, const char* path, const char* mode, FSFileHandleDepr_t* hFile, FS_ERROR_MASK errHandling)
+	SAVEStatus SAVEOpenFileOtherNormalApplicationVariationAsync(coreinit::FSClient_t* client, coreinit::FSCmdBlock_t* block, uint32 uniqueId, uint8 variation, uint8 accountSlot, const char* path, const char* mode, FSFileHandlePtr outFileHandle, FS_ERROR_MASK errHandling, const FSAsyncParams* asyncParams)
 	{
 		uint64 titleId = SAVE_UNIQUE_TO_TITLE_ID_VARIATION(uniqueId, variation);
-		return SAVEOpenFileOtherApplication(client, block, titleId, accountSlot, path, mode, hFile, errHandling);
+		return SAVEOpenFileOtherApplicationAsync(client, block, titleId, accountSlot, path, mode, outFileHandle, errHandling, asyncParams);
 	}
 
-	void export_SAVEOpenFileOtherNormalApplicationVariation(PPCInterpreter_t* hCPU)
+	SAVEStatus SAVEOpenFileOtherNormalApplicationVariation(coreinit::FSClient_t* client, coreinit::FSCmdBlock_t* block, uint32 uniqueId, uint8 variation, uint8 accountSlot, const char* path, const char* mode, FSFileHandlePtr outFileHandle, FS_ERROR_MASK errHandling)
 	{
-		ppcDefineParamMEMPTR(fsClient, coreinit::FSClient_t, 0);
-		ppcDefineParamMEMPTR(fsCmdBlock, coreinit::FSCmdBlock_t, 1);
-		ppcDefineParamU32(uniqueId, 2);
-		ppcDefineParamU8(variation, 3);
-		ppcDefineParamU8(accountSlot, 4);
-		ppcDefineParamMEMPTR(path, const char, 5);
-		ppcDefineParamMEMPTR(mode, const char, 6);
-		ppcDefineParamMEMPTR(hFile, FSFileHandleDepr_t, 7);
-		ppcDefineParamU32(errHandling, 8);
-
-		const SAVEStatus result = SAVEOpenFileOtherNormalApplicationVariation(fsClient.GetPtr(), fsCmdBlock.GetPtr(), uniqueId, variation, accountSlot, path.GetPtr(), mode.GetPtr(), hFile.GetPtr(), errHandling);
-		osLib_returnFromFunction(hCPU, result);
+		uint64 titleId = SAVE_UNIQUE_TO_TITLE_ID_VARIATION(uniqueId, variation);
+		return SAVEOpenFileOtherApplication(client, block, titleId, accountSlot, path, mode, outFileHandle, errHandling);
 	}
 
-	SAVEStatus SAVEGetFreeSpaceSizeAsync(coreinit::FSClient_t* client, coreinit::FSCmdBlock_t* block, uint8 accountSlot, FSLargeSize* freeSize, FS_ERROR_MASK errHandling, const FSAsyncParams_t* asyncParams)
-	{
-		SAVEStatus result = (FSStatus)(FS_RESULT::FATAL_ERROR);
-
-		OSLockMutex(&g_nn_save->mutex);
-
-		uint32 persistentId;
-		if (GetPersistentIdEx(accountSlot, &persistentId))
-		{
-			char fullPath[SAVE_MAX_PATH_SIZE];
-			// usually a pointer with '\0' instead of nullptr, but it's basically the same
-			if (GetAbsoluteFullPath(persistentId, nullptr, fullPath))
-				result = coreinit::FSGetFreeSpaceSizeAsync(client, block, fullPath, freeSize, errHandling, (FSAsyncParamsNew_t*)asyncParams);
-		}
-		else
-			result = (FSStatus)FS_RESULT::NOT_FOUND;
-
-		OSUnlockMutex(&g_nn_save->mutex);
-
-		return result;
-	}
-
-	SAVEStatus SAVEGetStatAsync(coreinit::FSClient_t* client, coreinit::FSCmdBlock_t* block, uint8 accountSlot, const char* path, FSStat_t* stat, FS_ERROR_MASK errHandling, const FSAsyncParams_t* asyncParams)
+	SAVEStatus SAVEGetStatAsync(coreinit::FSClient_t* client, coreinit::FSCmdBlock_t* block, uint8 accountSlot, const char* path, FSStat_t* stat, FS_ERROR_MASK errHandling, const FSAsyncParams* asyncParams)
 	{
 		SAVEStatus result = (FSStatus)(FS_RESULT::FATAL_ERROR);
 
@@ -600,7 +534,7 @@ namespace save
 		{
 			char fullPath[SAVE_MAX_PATH_SIZE];
 			if (GetAbsoluteFullPath(persistentId, path, fullPath))
-				result = coreinit::__FSQueryInfoAsync(client, block, (uint8*)fullPath, FSA_QUERY_TYPE_STAT, stat, errHandling, (FSAsyncParamsNew_t*)asyncParams); // FSGetStatAsync(...)
+				result = coreinit::__FSQueryInfoAsync(client, block, (uint8*)fullPath, FSA_QUERY_TYPE_STAT, stat, errHandling, (FSAsyncParams*)asyncParams); // FSGetStatAsync(...)
 		}
 		else
 			result = (FSStatus)FS_RESULT::NOT_FOUND;
@@ -610,7 +544,17 @@ namespace save
 		return result;
 	}
 
-	SAVEStatus SAVEGetStatOtherApplicationAsync(coreinit::FSClient_t* client, coreinit::FSCmdBlock_t* block, uint64 titleId, uint8 accountSlot, const char* path, FSStat_t* stat, FS_ERROR_MASK errHandling, const FSAsyncParams_t* asyncParams)
+	SAVEStatus SAVEGetStat(coreinit::FSClient_t* client, coreinit::FSCmdBlock_t* block, uint8 accountSlot, const char* path, FSStat_t* stat, FS_ERROR_MASK errHandling)
+	{
+		StackAllocator<AsyncToSyncWrapper> asyncData;
+		SAVEStatus status = SAVEGetStatAsync(client, block, accountSlot, path, stat, errHandling, asyncData->GetAsyncParams());
+		if (status != (FSStatus)FS_RESULT::SUCCESS)
+			return status;
+		asyncData->WaitForEvent();
+		return asyncData->GetResult();
+	}
+
+	SAVEStatus SAVEGetStatOtherApplicationAsync(coreinit::FSClient_t* client, coreinit::FSCmdBlock_t* block, uint64 titleId, uint8 accountSlot, const char* path, FSStat_t* stat, FS_ERROR_MASK errHandling, const FSAsyncParams* asyncParams)
 	{
 		SAVEStatus result = (FSStatus)(FS_RESULT::FATAL_ERROR);
 
@@ -620,8 +564,8 @@ namespace save
 		if (GetPersistentIdEx(accountSlot, &persistentId))
 		{
 			char fullPath[SAVE_MAX_PATH_SIZE];
-			if (GetAbsoluteFullPathOtherApplication(persistentId, titleId, path, fullPath) == (FSStatus)FS_RESULT::SUCCESS)
-				result = coreinit::__FSQueryInfoAsync(client, block, (uint8*)fullPath, FSA_QUERY_TYPE_STAT, stat, errHandling, (FSAsyncParamsNew_t*)asyncParams); // FSGetStatAsync(...)
+			if (GetAbsoluteFullPathOtherApplication(persistentId, titleId, path, fullPath) == FS_RESULT::SUCCESS)
+				result = coreinit::__FSQueryInfoAsync(client, block, (uint8*)fullPath, FSA_QUERY_TYPE_STAT, stat, errHandling, (FSAsyncParams*)asyncParams); // FSGetStatAsync(...)
 		}
 		else
 			result = (FSStatus)FS_RESULT::NOT_FOUND;
@@ -631,693 +575,46 @@ namespace save
 		return result;
 	}
 
-	SAVEStatus SAVEGetStatOtherNormalApplicationAsync(coreinit::FSClient_t* client, coreinit::FSCmdBlock_t* block, uint32 uniqueId, uint8 accountSlot, const char* path, FSStat_t* stat, FS_ERROR_MASK errHandling, const FSAsyncParams_t* asyncParams)
+	SAVEStatus SAVEGetStatOtherApplication(coreinit::FSClient_t* client, coreinit::FSCmdBlock_t* block, uint64 titleId, uint8 accountSlot, const char* path, FSStat_t* stat, FS_ERROR_MASK errHandling)
+	{
+		StackAllocator<AsyncToSyncWrapper> asyncData;
+		SAVEStatus status = SAVEGetStatOtherApplicationAsync(client, block, titleId, accountSlot, path, stat, errHandling, asyncData->GetAsyncParams());
+		if (status != (FSStatus)FS_RESULT::SUCCESS)
+			return status;
+		asyncData->WaitForEvent();
+		return asyncData->GetResult();
+	}
+
+	SAVEStatus SAVEGetStatOtherNormalApplicationAsync(coreinit::FSClient_t* client, coreinit::FSCmdBlock_t* block, uint32 uniqueId, uint8 accountSlot, const char* path, FSStat_t* stat, FS_ERROR_MASK errHandling, const FSAsyncParams* asyncParams)
 	{
 		uint64 titleId = SAVE_UNIQUE_TO_TITLE_ID(uniqueId);
 		return SAVEGetStatOtherApplicationAsync(client, block, titleId, accountSlot, path, stat, errHandling, asyncParams);
 	}
 
-	SAVEStatus SAVEGetStatOtherDemoApplicationAsync(coreinit::FSClient_t* client, coreinit::FSCmdBlock_t* block, uint32 uniqueId, uint8 accountSlot, const char* path, FSStat_t* stat, FS_ERROR_MASK errHandling, const FSAsyncParams_t* asyncParams)
+	SAVEStatus SAVEGetStatOtherNormalApplication(coreinit::FSClient_t* client, coreinit::FSCmdBlock_t* block, uint32 uniqueId, uint8 accountSlot, const char* path, FSStat_t* stat, FS_ERROR_MASK errHandling)
+	{
+		uint64 titleId = SAVE_UNIQUE_TO_TITLE_ID(uniqueId);
+		return SAVEGetStatOtherApplication(client, block, titleId, accountSlot, path, stat, errHandling);
+	}
+
+	SAVEStatus SAVEGetStatOtherDemoApplicationAsync(coreinit::FSClient_t* client, coreinit::FSCmdBlock_t* block, uint32 uniqueId, uint8 accountSlot, const char* path, FSStat_t* stat, FS_ERROR_MASK errHandling, const FSAsyncParams* asyncParams)
 	{
 		uint64 titleId = SAVE_UNIQUE_DEMO_TO_TITLE_ID(uniqueId);
 		return SAVEGetStatOtherApplicationAsync(client, block, titleId, accountSlot, path, stat, errHandling, asyncParams);
 	}
 
-	SAVEStatus SAVEGetStatOtherNormalApplicationVariationAsync(coreinit::FSClient_t* client, coreinit::FSCmdBlock_t* block, uint32 uniqueId, uint8 variation, uint8 accountSlot, const char* path, FSStat_t* stat, FS_ERROR_MASK errHandling, const FSAsyncParams_t* asyncParams)
+	SAVEStatus SAVEGetStatOtherNormalApplicationVariationAsync(coreinit::FSClient_t* client, coreinit::FSCmdBlock_t* block, uint32 uniqueId, uint8 variation, uint8 accountSlot, const char* path, FSStat_t* stat, FS_ERROR_MASK errHandling, const FSAsyncParams* asyncParams)
 	{
 		uint64 titleId = SAVE_UNIQUE_TO_TITLE_ID_VARIATION(uniqueId, variation);
 		return SAVEGetStatOtherApplicationAsync(client, block, titleId, accountSlot, path, stat, errHandling, asyncParams);
 	}
 
-	SAVEStatus SAVEGetStatOtherDemoApplicationVariationAsync(coreinit::FSClient_t* client, coreinit::FSCmdBlock_t* block, uint32 uniqueId, uint8 variation, uint8 accountSlot, const char* path, FSStat_t* stat, FS_ERROR_MASK errHandling, const FSAsyncParams_t* asyncParams)
+	SAVEStatus SAVEGetStatOtherDemoApplicationVariationAsync(coreinit::FSClient_t* client, coreinit::FSCmdBlock_t* block, uint32 uniqueId, uint8 variation, uint8 accountSlot, const char* path, FSStat_t* stat, FS_ERROR_MASK errHandling, const FSAsyncParams* asyncParams)
 	{
 		uint64 titleId = SAVE_UNIQUE_DEMO_TO_TITLE_ID_VARIATION(uniqueId, variation);
 		return SAVEGetStatOtherApplicationAsync(client, block, titleId, accountSlot, path, stat, errHandling, asyncParams);
 	}
 
-	SAVEStatus SAVEInitSaveDir(uint8 accountSlot)
-	{
-		SAVEStatus result = (FSStatus)(FS_RESULT::FATAL_ERROR);
-		OSLockMutex(&g_nn_save->mutex);
-
-		uint32 persistentId;
-		if (GetPersistentIdEx(accountSlot, &persistentId))
-		{
-			acp::ACPStatus status = ACPCreateSaveDir(persistentId, acp::InternalDeviceType);
-			result = ConvertACPToSaveStatus(status);
-		}
-		else
-			result = (FSStatus)FS_RESULT::NOT_FOUND;
-
-		OSUnlockMutex(&g_nn_save->mutex);
-		return result;
-	}
-
-	SAVEStatus SAVEGetFreeSpaceSize(coreinit::FSClient_t* client, coreinit::FSCmdBlock_t* block, uint8 accountSlot, FSLargeSize* freeSize, FS_ERROR_MASK errHandling)
-	{
-		FSAsyncParams_t asyncParams;
-		asyncParams.ioMsgQueue = MPTR_NULL;
-		asyncParams.userCallback = _swapEndianU32(PPCInterpreter_makeCallableExportDepr(AsyncCallback));
-
-		StackAllocator<AsyncCallbackParam_t> param;
-		param->thread = coreinitThread_getCurrentThreadMPTRDepr(ppcInterpreterCurrentInstance);
-		param->returnStatus = (FSStatus)FS_RESULT::SUCCESS;
-		asyncParams.userContext = param.GetMPTRBE();
-
-		SAVEStatus status = SAVEGetFreeSpaceSizeAsync(client, block, accountSlot, freeSize, errHandling, &asyncParams);
-		if (status == (FSStatus)FS_RESULT::SUCCESS)
-		{
-			coreinit_suspendThread(coreinitThread_getCurrentThreadDepr(ppcInterpreterCurrentInstance), 1000);
-			PPCCore_switchToScheduler();
-			return param->returnStatus;
-		}
-
-		return status;
-	}
-
-	void export_SAVEGetFreeSpaceSize(PPCInterpreter_t* hCPU)
-	{
-		ppcDefineParamMEMPTR(fsClient, coreinit::FSClient_t, 0);
-		ppcDefineParamMEMPTR(fsCmdBlock, coreinit::FSCmdBlock_t, 1);
-		ppcDefineParamU8(accountSlot, 2);
-		ppcDefineParamMEMPTR(returnedFreeSize, FSLargeSize, 3);
-		ppcDefineParamU32(errHandling, 4);
-
-		const SAVEStatus result = SAVEGetFreeSpaceSize(fsClient.GetPtr(), fsCmdBlock.GetPtr(), accountSlot, returnedFreeSize.GetPtr(), errHandling);
-		saveLog_printf("SAVEGetFreeSpaceSize(0x%08x, 0x%08x, %x, %x) -> %x", fsClient.GetMPTR(), fsCmdBlock.GetMPTR(), accountSlot, errHandling, result);
-		osLib_returnFromFunction(hCPU, result);
-	}
-
-	void export_SAVEGetFreeSpaceSizeAsync(PPCInterpreter_t* hCPU)
-	{
-		ppcDefineParamMEMPTR(fsClient, coreinit::FSClient_t, 0);
-		ppcDefineParamMEMPTR(fsCmdBlock, coreinit::FSCmdBlock_t, 1);
-		ppcDefineParamU8(accountSlot, 2);
-		ppcDefineParamMEMPTR(returnedFreeSize, FSLargeSize, 3);
-		ppcDefineParamU32(errHandling, 4);
-		ppcDefineParamMEMPTR(asyncParams, FSAsyncParams_t, 5);
-
-		const SAVEStatus result = SAVEGetFreeSpaceSizeAsync(fsClient.GetPtr(), fsCmdBlock.GetPtr(), accountSlot, returnedFreeSize.GetPtr(), errHandling, asyncParams.GetPtr());
-		saveLog_printf("SAVEGetFreeSpaceSizeAsync(0x%08x, 0x%08x, %x, %x) -> %x", fsClient.GetMPTR(), fsCmdBlock.GetMPTR(), accountSlot, errHandling, result);
-		osLib_returnFromFunction(hCPU, result);
-	}
-
-	void export_SAVEInit(PPCInterpreter_t* hCPU)
-	{
-		const SAVEStatus result = SAVEInit();
-		saveLog_printf("SAVEInit() -> %x", result);
-		osLib_returnFromFunction(hCPU, result);
-	}
-
-	void export_SAVERemoveAsync(PPCInterpreter_t* hCPU)
-	{
-		ppcDefineParamMEMPTR(fsClient, coreinit::FSClient_t, 0);
-		ppcDefineParamMEMPTR(fsCmdBlock, coreinit::FSCmdBlock_t, 1);
-		ppcDefineParamU8(accountSlot, 2);
-		ppcDefineParamMEMPTR(path, const char, 3);
-		ppcDefineParamU32(errHandling, 4);
-		ppcDefineParamMEMPTR(asyncParams, FSAsyncParams_t, 5);
-
-		const SAVEStatus result = SAVERemoveAsync(fsClient.GetPtr(), fsCmdBlock.GetPtr(), accountSlot, path.GetPtr(), errHandling, asyncParams.GetPtr());
-		osLib_returnFromFunction(hCPU, result);
-	}
-
-	SAVEStatus SAVERemove(coreinit::FSClient_t* client, coreinit::FSCmdBlock_t* block, uint8 accountSlot, const char* path, FS_ERROR_MASK errHandling)
-	{
-		FSAsyncParams_t asyncParams;
-		asyncParams.ioMsgQueue = MPTR_NULL;
-		asyncParams.userCallback = _swapEndianU32(PPCInterpreter_makeCallableExportDepr(AsyncCallback));
-
-		StackAllocator<AsyncCallbackParam_t> param;
-		param->thread = coreinitThread_getCurrentThreadMPTRDepr(ppcInterpreterCurrentInstance);
-		param->returnStatus = (FSStatus)FS_RESULT::SUCCESS;
-		asyncParams.userContext = param.GetMPTRBE();
-
-		SAVEStatus status = SAVERemoveAsync(client, block, accountSlot, path, errHandling, &asyncParams);
-		if (status == (FSStatus)FS_RESULT::SUCCESS)
-		{
-			coreinit_suspendThread(coreinitThread_getCurrentThreadDepr(ppcInterpreterCurrentInstance), 1000);
-			PPCCore_switchToScheduler();
-			return param->returnStatus;
-		}
-
-		return status;
-	}
-
-	void export_SAVERemove(PPCInterpreter_t* hCPU)
-	{
-		ppcDefineParamMEMPTR(fsClient, coreinit::FSClient_t, 0);
-		ppcDefineParamMEMPTR(fsCmdBlock, coreinit::FSCmdBlock_t, 1);
-		ppcDefineParamU8(accountSlot, 2);
-		ppcDefineParamMEMPTR(path, const char, 3);
-		ppcDefineParamU32(errHandling, 4);
-
-		const SAVEStatus result = SAVERemove(fsClient.GetPtr(), fsCmdBlock.GetPtr(), accountSlot, path.GetPtr(), errHandling);
-		osLib_returnFromFunction(hCPU, result);
-	}
-
-	SAVEStatus SAVERenameAsync(coreinit::FSClient_t* client, coreinit::FSCmdBlock_t* block, uint8 accountSlot, const char* oldPath, const char* newPath, FS_ERROR_MASK errHandling, const FSAsyncParams_t* asyncParams)
-	{
-		SAVEStatus result = (FSStatus)(FS_RESULT::FATAL_ERROR);
-
-		OSLockMutex(&g_nn_save->mutex);
-
-		uint32 persistentId;
-		if (GetPersistentIdEx(accountSlot, &persistentId))
-		{
-			char fullOldPath[SAVE_MAX_PATH_SIZE];
-			if (GetAbsoluteFullPath(persistentId, oldPath, fullOldPath))
-			{
-				char fullNewPath[SAVE_MAX_PATH_SIZE];
-				if (GetAbsoluteFullPath(persistentId, newPath, fullNewPath))
-					result = coreinit::FSRenameAsync(client, block, fullOldPath, fullNewPath, errHandling, (FSAsyncParamsNew_t*)asyncParams);
-			}
-		}
-		else
-			result = (FSStatus)FS_RESULT::NOT_FOUND;
-
-		OSUnlockMutex(&g_nn_save->mutex);
-
-		return result;
-	}
-
-	void export_SAVERenameAsync(PPCInterpreter_t* hCPU)
-	{
-		ppcDefineParamMEMPTR(fsClient, coreinit::FSClient_t, 0);
-		ppcDefineParamMEMPTR(fsCmdBlock, coreinit::FSCmdBlock_t, 1);
-		ppcDefineParamU8(accountSlot, 2);
-		ppcDefineParamMEMPTR(oldPath, const char, 3);
-		ppcDefineParamMEMPTR(newPath, const char, 4);
-		ppcDefineParamU32(errHandling, 5);
-		ppcDefineParamMEMPTR(asyncParams, FSAsyncParams_t, 6);
-
-		const SAVEStatus result = SAVERenameAsync(fsClient.GetPtr(), fsCmdBlock.GetPtr(), accountSlot, oldPath.GetPtr(), newPath.GetPtr(), errHandling, asyncParams.GetPtr());
-		saveLog_printf("SAVERenameAsync(0x%08x, 0x%08x, %x, %s, %s, %x) -> %x", fsClient.GetMPTR(), fsCmdBlock.GetMPTR(), accountSlot, oldPath.GetPtr(), newPath.GetPtr(), errHandling, result);
-		osLib_returnFromFunction(hCPU, result);
-	}
-
-	SAVEStatus SAVERename(coreinit::FSClient_t* client, coreinit::FSCmdBlock_t* block, uint8 accountSlot, const char* oldPath, const char* newPath, FS_ERROR_MASK errHandling)
-	{
-		SAVEStatus result = (FSStatus)(FS_RESULT::FATAL_ERROR);
-
-		OSLockMutex(&g_nn_save->mutex);
-		uint32 persistentId;
-		if (GetPersistentIdEx(accountSlot, &persistentId))
-		{
-			char fullOldPath[SAVE_MAX_PATH_SIZE];
-			if (GetAbsoluteFullPath(persistentId, oldPath, fullOldPath))
-			{
-				char fullNewPath[SAVE_MAX_PATH_SIZE];
-				if (GetAbsoluteFullPath(persistentId, newPath, fullNewPath))
-					result = coreinit::FSRename(client, block, fullOldPath, fullNewPath, errHandling);
-			}
-		}
-		else
-			result = (FSStatus)FS_RESULT::NOT_FOUND;
-		OSUnlockMutex(&g_nn_save->mutex);
-
-		return result;
-	}
-
-	void export_SAVEOpenDirAsync(PPCInterpreter_t* hCPU)
-	{
-		ppcDefineParamMEMPTR(fsClient, coreinit::FSClient_t, 0);
-		ppcDefineParamMEMPTR(fsCmdBlock, coreinit::FSCmdBlock_t, 1);
-		ppcDefineParamU8(accountSlot, 2);
-		ppcDefineParamMEMPTR(path, const char, 3);
-		ppcDefineParamMEMPTR(hDir, betype<FSDirHandle2>, 4);
-		ppcDefineParamU32(errHandling, 5);
-		ppcDefineParamMEMPTR(asyncParams, FSAsyncParams_t, 6);
-
-		const SAVEStatus result = SAVEOpenDirAsync(fsClient.GetPtr(), fsCmdBlock.GetPtr(), accountSlot, path.GetPtr(), hDir, errHandling, asyncParams.GetPtr());
-		saveLog_printf("SAVEOpenDirAsync(0x%08x, 0x%08x, %x, %s, 0x%08x (%x), %x) -> %x", fsClient.GetMPTR(), fsCmdBlock.GetMPTR(), accountSlot, path.GetPtr(), hDir.GetMPTR(),
-			(hDir.GetPtr() == nullptr ? 0 : (uint32)*hDir.GetPtr()), errHandling, result);
-		osLib_returnFromFunction(hCPU, result);
-	}
-
-	SAVEStatus SAVEOpenDir(coreinit::FSClient_t* client, coreinit::FSCmdBlock_t* block, uint8 accountSlot, const char* path, FSDirHandlePtr hDir, FS_ERROR_MASK errHandling)
-	{
-		FSAsyncParams_t asyncParams;
-		asyncParams.ioMsgQueue = MPTR_NULL;
-		asyncParams.userCallback = _swapEndianU32(PPCInterpreter_makeCallableExportDepr(AsyncCallback));
-
-		StackAllocator<AsyncCallbackParam_t> param;
-		param->thread = coreinitThread_getCurrentThreadMPTRDepr(ppcInterpreterCurrentInstance);
-		param->returnStatus = (FSStatus)FS_RESULT::SUCCESS;
-		asyncParams.userContext = param.GetMPTRBE();
-
-		SAVEStatus status = SAVEOpenDirAsync(client, block, accountSlot, path, hDir, errHandling, &asyncParams);
-		if (status == (FSStatus)FS_RESULT::SUCCESS)
-		{
-			coreinit_suspendThread(coreinitThread_getCurrentThreadDepr(ppcInterpreterCurrentInstance), 1000);
-			PPCCore_switchToScheduler();
-			return param->returnStatus;
-		}
-
-		return status;
-	}
-
-	void export_SAVEOpenDir(PPCInterpreter_t* hCPU)
-	{
-		ppcDefineParamMEMPTR(fsClient, coreinit::FSClient_t, 0);
-		ppcDefineParamMEMPTR(fsCmdBlock, coreinit::FSCmdBlock_t, 1);
-		ppcDefineParamU8(accountSlot, 2);
-		ppcDefineParamMEMPTR(path, const char, 3);
-		ppcDefineParamMEMPTR(hDir, betype<FSDirHandle2>, 4);
-		ppcDefineParamU32(errHandling, 5);
-
-		const SAVEStatus result = SAVEOpenDir(fsClient.GetPtr(), fsCmdBlock.GetPtr(), accountSlot, path.GetPtr(), hDir, errHandling);
-		saveLog_printf("SAVEOpenDir(0x%08x, 0x%08x, %x, %s, 0x%08x (%x), %x) -> %x", fsClient.GetMPTR(), fsCmdBlock.GetMPTR(), accountSlot, path.GetPtr(), hDir.GetMPTR(),
-			(hDir.GetPtr() == nullptr ? 0 : (uint32)*hDir.GetPtr()), errHandling, result);
-		osLib_returnFromFunction(hCPU, result);
-	}
-
-	SAVEStatus SAVEOpenDirOtherApplicationAsync(coreinit::FSClient_t* client, coreinit::FSCmdBlock_t* block, uint64 titleId, uint8 accountSlot, const char* path, FSDirHandlePtr hDir, FS_ERROR_MASK errHandling, const FSAsyncParams_t* asyncParams)
-	{
-		SAVEStatus result = (FSStatus)(FS_RESULT::FATAL_ERROR);
-
-		OSLockMutex(&g_nn_save->mutex);
-		uint32 persistentId;
-		if (GetPersistentIdEx(accountSlot, &persistentId))
-		{
-			char fullPath[SAVE_MAX_PATH_SIZE];
-			if (GetAbsoluteFullPathOtherApplication(persistentId, titleId, path, fullPath))
-				result = coreinit::FSOpenDirAsync(client, block, fullPath, hDir, errHandling, (FSAsyncParamsNew_t*)asyncParams);
-		}
-		else
-			result = (FSStatus)FS_RESULT::NOT_FOUND;
-		OSUnlockMutex(&g_nn_save->mutex);
-
-		return result;
-	}
-
-	void export_SAVEOpenDirOtherApplicationAsync(PPCInterpreter_t* hCPU)
-	{
-		ppcDefineParamMEMPTR(fsClient, coreinit::FSClient_t, 0);
-		ppcDefineParamMEMPTR(fsCmdBlock, coreinit::FSCmdBlock_t, 1);
-		ppcDefineParamU64(titleId, 2);
-		ppcDefineParamU8(accountSlot, 3);
-		ppcDefineParamMEMPTR(path, const char, 4);
-		ppcDefineParamMEMPTR(hDir, betype<FSDirHandle2>, 5);
-		ppcDefineParamU32(errHandling, 6);
-		ppcDefineParamMEMPTR(asyncParams, FSAsyncParams_t, 7);
-
-		const SAVEStatus result = SAVEOpenDirOtherApplicationAsync(fsClient.GetPtr(), fsCmdBlock.GetPtr(), titleId, accountSlot, path.GetPtr(), hDir, errHandling, asyncParams.GetPtr());
-		saveLog_printf("SAVEOpenDirOtherApplicationAsync(0x%08x, 0x%08x, %llx, %x, %s, 0x%08x (%x), %x) -> %x", fsClient.GetMPTR(), fsCmdBlock.GetMPTR(), titleId, accountSlot, path.GetPtr(), hDir.GetMPTR(),
-			(hDir.GetPtr() == nullptr ? 0 : (uint32)*hDir.GetPtr()), errHandling, result);
-		osLib_returnFromFunction(hCPU, result);
-	}
-
-	SAVEStatus SAVEOpenDirOtherApplication(coreinit::FSClient_t* client, coreinit::FSCmdBlock_t* block, uint64 titleId, uint8 accountSlot, const char* path, FSDirHandlePtr hDir, FS_ERROR_MASK errHandling)
-	{
-		FSAsyncParams_t asyncParams;
-		asyncParams.ioMsgQueue = MPTR_NULL;
-		asyncParams.userCallback = _swapEndianU32(PPCInterpreter_makeCallableExportDepr(AsyncCallback));
-
-		StackAllocator<AsyncCallbackParam_t> param;
-		param->thread = coreinitThread_getCurrentThreadMPTRDepr(ppcInterpreterCurrentInstance);
-		param->returnStatus = (FSStatus)FS_RESULT::SUCCESS;
-		asyncParams.userContext = param.GetMPTRBE();
-
-		SAVEStatus status = SAVEOpenDirOtherApplicationAsync(client, block, titleId, accountSlot, path, hDir, errHandling, &asyncParams);
-		if (status == (FSStatus)FS_RESULT::SUCCESS)
-		{
-			coreinit_suspendThread(coreinitThread_getCurrentThreadDepr(ppcInterpreterCurrentInstance), 1000);
-			PPCCore_switchToScheduler();
-			return param->returnStatus;
-		}
-
-		return status;
-	}
-
-	void export_SAVEOpenDirOtherApplication(PPCInterpreter_t* hCPU)
-	{
-		ppcDefineParamMEMPTR(fsClient, coreinit::FSClient_t, 0);
-		ppcDefineParamMEMPTR(fsCmdBlock, coreinit::FSCmdBlock_t, 1);
-		ppcDefineParamU64(titleId, 2);
-		ppcDefineParamU8(accountSlot, 3);
-		ppcDefineParamMEMPTR(path, const char, 4);
-		ppcDefineParamMEMPTR(hDir, betype<FSDirHandle2>, 5);
-		ppcDefineParamU32(errHandling, 6);
-
-		const SAVEStatus result = SAVEOpenDirOtherApplication(fsClient.GetPtr(), fsCmdBlock.GetPtr(), titleId, accountSlot, path.GetPtr(), hDir, errHandling);
-		saveLog_printf("SAVEOpenDirOtherApplication(0x%08x, 0x%08x, %llx, %x, %s, 0x%08x (%x), %x) -> %x", fsClient.GetMPTR(), fsCmdBlock.GetMPTR(), titleId, accountSlot, path.GetPtr(), hDir.GetMPTR(),
-			(hDir.GetPtr() == nullptr ? 0 : (uint32)*hDir.GetPtr()), errHandling, result);
-		osLib_returnFromFunction(hCPU, result);
-	}
-
-	SAVEStatus SAVEOpenDirOtherNormalApplicationAsync(coreinit::FSClient_t* client, coreinit::FSCmdBlock_t* block, uint32 uniqueId, uint8 accountSlot, const char* path, FSDirHandlePtr hDir, FS_ERROR_MASK errHandling, const FSAsyncParams_t* asyncParams)
-	{
-		uint64 titleId = SAVE_UNIQUE_TO_TITLE_ID(uniqueId);
-		return SAVEOpenDirOtherApplicationAsync(client, block, titleId, accountSlot, path, hDir, errHandling, asyncParams);
-	}
-
-	void export_SAVEOpenDirOtherNormalApplicationAsync(PPCInterpreter_t* hCPU)
-	{
-		ppcDefineParamMEMPTR(fsClient, coreinit::FSClient_t, 0);
-		ppcDefineParamMEMPTR(fsCmdBlock, coreinit::FSCmdBlock_t, 1);
-		ppcDefineParamU32(uniqueId, 2);
-		ppcDefineParamU8(accountSlot, 3);
-		ppcDefineParamMEMPTR(path, const char, 4);
-		ppcDefineParamMEMPTR(hDir, betype<FSDirHandle2>, 5);
-		ppcDefineParamU32(errHandling, 6);
-		ppcDefineParamMEMPTR(asyncParams, FSAsyncParams_t, 7);
-
-		const SAVEStatus result = SAVEOpenDirOtherNormalApplicationAsync(fsClient.GetPtr(), fsCmdBlock.GetPtr(), uniqueId, accountSlot, path.GetPtr(), hDir, errHandling, asyncParams.GetPtr());
-		osLib_returnFromFunction(hCPU, result);
-	}
-
-	SAVEStatus SAVEOpenDirOtherNormalApplication(coreinit::FSClient_t* client, coreinit::FSCmdBlock_t* block, uint32 uniqueId, uint8 accountSlot, const char* path, FSDirHandlePtr hDir, FS_ERROR_MASK errHandling)
-	{
-		uint64 titleId = SAVE_UNIQUE_TO_TITLE_ID(uniqueId);
-		return SAVEOpenDirOtherApplication(client, block, titleId, accountSlot, path, hDir, errHandling);
-	}
-
-	void export_SAVEOpenDirOtherNormalApplication(PPCInterpreter_t* hCPU)
-	{
-		ppcDefineParamMEMPTR(fsClient, coreinit::FSClient_t, 0);
-		ppcDefineParamMEMPTR(fsCmdBlock, coreinit::FSCmdBlock_t, 1);
-		ppcDefineParamU32(uniqueId, 2);
-		ppcDefineParamU8(accountSlot, 3);
-		ppcDefineParamMEMPTR(path, const char, 4);
-		ppcDefineParamMEMPTR(hDir, betype<FSDirHandle2>, 5);
-		ppcDefineParamU32(errHandling, 6);
-
-		const SAVEStatus result = SAVEOpenDirOtherNormalApplication(fsClient.GetPtr(), fsCmdBlock.GetPtr(), uniqueId, accountSlot, path.GetPtr(), hDir, errHandling);
-		osLib_returnFromFunction(hCPU, result);
-	}
-
-	SAVEStatus SAVEOpenDirOtherNormalApplicationVariationAsync(coreinit::FSClient_t* client, coreinit::FSCmdBlock_t* block, uint32 uniqueId, uint8 variation, uint8 accountSlot, const char* path, FSDirHandlePtr hDir, FS_ERROR_MASK errHandling, const FSAsyncParams_t* asyncParams)
-	{
-		uint64 titleId = SAVE_UNIQUE_TO_TITLE_ID_VARIATION(uniqueId, variation);
-		return SAVEOpenDirOtherApplicationAsync(client, block, titleId, accountSlot, path, hDir, errHandling, asyncParams);
-	}
-
-	void export_SAVEOpenDirOtherNormalApplicationVariationAsync(PPCInterpreter_t* hCPU)
-	{
-		ppcDefineParamMEMPTR(fsClient, coreinit::FSClient_t, 0);
-		ppcDefineParamMEMPTR(fsCmdBlock, coreinit::FSCmdBlock_t, 1);
-		ppcDefineParamU32(uniqueId, 2);
-		ppcDefineParamU8(variation, 3);
-		ppcDefineParamU8(accountSlot, 4);
-		ppcDefineParamMEMPTR(path, const char, 5);
-		ppcDefineParamMEMPTR(hDir, betype<FSDirHandle2>, 6);
-		ppcDefineParamU32(errHandling, 7);
-		ppcDefineParamMEMPTR(asyncParams, FSAsyncParams_t, 8);
-
-		const SAVEStatus result = SAVEOpenDirOtherNormalApplicationVariationAsync(fsClient.GetPtr(), fsCmdBlock.GetPtr(), uniqueId, variation, accountSlot, path.GetPtr(), hDir, errHandling, asyncParams.GetPtr());
-		osLib_returnFromFunction(hCPU, result);
-	}
-
-	SAVEStatus SAVEOpenDirOtherNormalApplicationVariation(coreinit::FSClient_t* client, coreinit::FSCmdBlock_t* block, uint32 uniqueId, uint8 variation, uint8 accountSlot, const char* path, FSDirHandlePtr hDir, FS_ERROR_MASK errHandling)
-	{
-		uint64 titleId = SAVE_UNIQUE_TO_TITLE_ID_VARIATION(uniqueId, variation);
-		return SAVEOpenDirOtherApplication(client, block, titleId, accountSlot, path, hDir, errHandling);
-	}
-
-	void export_SAVEOpenDirOtherNormalApplicationVariation(PPCInterpreter_t* hCPU)
-	{
-		ppcDefineParamMEMPTR(fsClient, coreinit::FSClient_t, 0);
-		ppcDefineParamMEMPTR(fsCmdBlock, coreinit::FSCmdBlock_t, 1);
-		ppcDefineParamU32(uniqueId, 2);
-		ppcDefineParamU8(variation, 3);
-		ppcDefineParamU8(accountSlot, 4);
-		ppcDefineParamMEMPTR(path, const char, 5);
-		ppcDefineParamMEMPTR(hDir, betype<FSDirHandle2>, 6);
-		ppcDefineParamU32(errHandling, 7);
-
-		const SAVEStatus result = SAVEOpenDirOtherNormalApplicationVariation(fsClient.GetPtr(), fsCmdBlock.GetPtr(), uniqueId, variation, accountSlot, path.GetPtr(), hDir, errHandling);
-		osLib_returnFromFunction(hCPU, result);
-	}
-
-	void export_SAVEMakeDirAsync(PPCInterpreter_t* hCPU)
-	{
-		ppcDefineParamMEMPTR(fsClient, coreinit::FSClient_t, 0);
-		ppcDefineParamMEMPTR(fsCmdBlock, coreinit::FSCmdBlock_t, 1);
-		ppcDefineParamU8(accountSlot, 2);
-		ppcDefineParamMEMPTR(path, const char, 3);
-		ppcDefineParamU32(errHandling, 4);
-		ppcDefineParamMEMPTR(asyncParams, FSAsyncParams_t, 5);
-
-		const SAVEStatus result = SAVEMakeDirAsync(fsClient.GetPtr(), fsCmdBlock.GetPtr(), accountSlot, path.GetPtr(), errHandling, asyncParams.GetPtr());
-		saveLog_printf("SAVEMakeDirAsync(0x%08x, 0x%08x, %x, %s,  %x) -> %x", fsClient.GetMPTR(), fsCmdBlock.GetMPTR(), accountSlot, path.GetPtr(), errHandling, result);
-		osLib_returnFromFunction(hCPU, result);
-	}
-
-	SAVEStatus SAVEMakeDir(coreinit::FSClient_t* client, coreinit::FSCmdBlock_t* block, uint8 accountSlot, const char* path, FS_ERROR_MASK errHandling)
-	{
-		FSAsyncParams_t asyncParams;
-		asyncParams.ioMsgQueue = MPTR_NULL;
-		asyncParams.userCallback = _swapEndianU32(PPCInterpreter_makeCallableExportDepr(AsyncCallback));
-
-		StackAllocator<AsyncCallbackParam_t> param;
-		param->thread = coreinitThread_getCurrentThreadMPTRDepr(ppcInterpreterCurrentInstance);
-		param->returnStatus = (FSStatus)FS_RESULT::SUCCESS;
-		asyncParams.userContext = param.GetMPTRBE();
-
-		SAVEStatus status = SAVEMakeDirAsync(client, block, accountSlot, path, errHandling, &asyncParams);
-		if (status == (FSStatus)FS_RESULT::SUCCESS)
-		{
-			coreinit_suspendThread(coreinitThread_getCurrentThreadDepr(ppcInterpreterCurrentInstance), 1000);
-			PPCCore_switchToScheduler();
-			return param->returnStatus;
-		}
-
-		return status;
-	}
-
-	void export_SAVEMakeDir(PPCInterpreter_t* hCPU)
-	{
-		ppcDefineParamMEMPTR(fsClient, coreinit::FSClient_t, 0);
-		ppcDefineParamMEMPTR(fsCmdBlock, coreinit::FSCmdBlock_t, 1);
-		ppcDefineParamU8(accountSlot, 2);
-		ppcDefineParamMEMPTR(path, const char, 3);
-		ppcDefineParamU32(errHandling, 4);
-
-		const SAVEStatus result = SAVEMakeDir(fsClient.GetPtr(), fsCmdBlock.GetPtr(), accountSlot, path.GetPtr(), errHandling);
-		saveLog_printf("SAVEMakeDir(0x%08x, 0x%08x, %x, %s,  %x) -> %x", fsClient.GetMPTR(), fsCmdBlock.GetMPTR(), accountSlot, path.GetPtr(), errHandling, result);
-		osLib_returnFromFunction(hCPU, result);
-	}
-
-	void export_SAVEOpenFileAsync(PPCInterpreter_t* hCPU)
-	{
-		ppcDefineParamMEMPTR(fsClient, coreinit::FSClient_t, 0);
-		ppcDefineParamMEMPTR(fsCmdBlock, coreinit::FSCmdBlock_t, 1);
-		ppcDefineParamU8(accountSlot, 2);
-		ppcDefineParamMEMPTR(path, const char, 3);
-		ppcDefineParamMEMPTR(mode, const char, 4);
-		ppcDefineParamMEMPTR(hFile, FSFileHandleDepr_t, 5);
-		ppcDefineParamU32(errHandling, 6);
-		ppcDefineParamMEMPTR(asyncParams, FSAsyncParamsNew_t, 7);
-
-		const SAVEStatus result = SAVEOpenFileAsync(fsClient.GetPtr(), fsCmdBlock.GetPtr(), accountSlot, path.GetPtr(), mode.GetPtr(), hFile.GetPtr(), errHandling, asyncParams.GetPtr());
-		saveLog_printf("SAVEOpenFileAsync(0x%08x, 0x%08x, %x, %s, %s, 0x%08x, %x) -> %x", fsClient.GetMPTR(), fsCmdBlock.GetMPTR(), accountSlot, path.GetPtr(), mode.GetPtr(), hFile.GetMPTR(), errHandling, result);
-		osLib_returnFromFunction(hCPU, result);
-	}
-
-	SAVEStatus SAVEOpenFile(coreinit::FSClient_t* client, coreinit::FSCmdBlock_t* block, uint8 accountSlot, const char* path, const char* mode, FSFileHandleDepr_t* hFile, FS_ERROR_MASK errHandling)
-	{
-		FSAsyncParamsNew_t asyncParams;
-		asyncParams.ioMsgQueue = nullptr;
-		asyncParams.userCallback = PPCInterpreter_makeCallableExportDepr(AsyncCallback);
-
-		StackAllocator<AsyncCallbackParam_t> param;
-		param->thread = coreinitThread_getCurrentThreadMPTRDepr(ppcInterpreterCurrentInstance);
-		param->returnStatus = (FSStatus)FS_RESULT::SUCCESS;
-		asyncParams.userContext = param.GetPointer();
-
-		SAVEStatus status = SAVEOpenFileAsync(client, block, accountSlot, path, mode, hFile, errHandling, &asyncParams);
-		if (status == (FSStatus)FS_RESULT::SUCCESS)
-		{
-			coreinit_suspendThread(coreinitThread_getCurrentThreadDepr(ppcInterpreterCurrentInstance), 1000);
-			PPCCore_switchToScheduler();
-			return param->returnStatus;
-		}
-
-		return status;
-	}
-
-	void export_SAVEOpenFile(PPCInterpreter_t* hCPU)
-	{
-		ppcDefineParamMEMPTR(fsClient, coreinit::FSClient_t, 0);
-		ppcDefineParamMEMPTR(fsCmdBlock, coreinit::FSCmdBlock_t, 1);
-		ppcDefineParamU8(accountSlot, 2);
-		ppcDefineParamMEMPTR(path, const char, 3);
-		ppcDefineParamMEMPTR(mode, const char, 4);
-		ppcDefineParamMEMPTR(hFile, FSFileHandleDepr_t, 5);
-		ppcDefineParamU32(errHandling, 6);
-
-		const SAVEStatus result = SAVEOpenFile(fsClient.GetPtr(), fsCmdBlock.GetPtr(), accountSlot, path.GetPtr(), mode.GetPtr(), hFile.GetPtr(), errHandling);
-		saveLog_printf("SAVEOpenFile(0x%08x, 0x%08x, %x, %s, %s, 0x%08x, %x) -> %x", fsClient.GetMPTR(), fsCmdBlock.GetMPTR(), accountSlot, path.GetPtr(), mode.GetPtr(), hFile.GetMPTR(), errHandling, result);
-		osLib_returnFromFunction(hCPU, result);
-	}
-
-	void export_SAVEInitSaveDir(PPCInterpreter_t* hCPU)
-	{
-		ppcDefineParamU8(accountSlot, 0);
-		const SAVEStatus result = SAVEInitSaveDir(accountSlot);
-		saveLog_printf("SAVEInitSaveDir(%x) -> %x", accountSlot, result);
-		osLib_returnFromFunction(hCPU, result);
-	}
-
-	void export_SAVEGetStatAsync(PPCInterpreter_t* hCPU)
-	{
-		ppcDefineParamMEMPTR(fsClient, coreinit::FSClient_t, 0);
-		ppcDefineParamMEMPTR(fsCmdBlock, coreinit::FSCmdBlock_t, 1);
-		ppcDefineParamU8(accountSlot, 2);
-		ppcDefineParamMEMPTR(path, const char, 3);
-		ppcDefineParamMEMPTR(stat, FSStat_t, 4);
-		ppcDefineParamU32(errHandling, 5);
-		ppcDefineParamMEMPTR(asyncParams, FSAsyncParams_t, 6);
-
-		const SAVEStatus result = SAVEGetStatAsync(fsClient.GetPtr(), fsCmdBlock.GetPtr(), accountSlot, path.GetPtr(), stat.GetPtr(), errHandling, asyncParams.GetPtr());
-		saveLog_printf("SAVEGetStatAsync(0x%08x, 0x%08x, %x, %s, 0x%08x, %x) -> %x", fsClient.GetMPTR(), fsCmdBlock.GetMPTR(), accountSlot, path.GetPtr(), stat.GetMPTR(), errHandling, result);
-		osLib_returnFromFunction(hCPU, result);
-	}
-
-	SAVEStatus SAVEGetStat(coreinit::FSClient_t* client, coreinit::FSCmdBlock_t* block, uint8 accountSlot, const char* path, FSStat_t* stat, FS_ERROR_MASK errHandling)
-	{
-		FSAsyncParams_t asyncParams;
-		asyncParams.ioMsgQueue = MPTR_NULL;
-		asyncParams.userCallback = _swapEndianU32(PPCInterpreter_makeCallableExportDepr(AsyncCallback));
-
-		StackAllocator<AsyncCallbackParam_t> param;
-		param->thread = coreinitThread_getCurrentThreadMPTRDepr(ppcInterpreterCurrentInstance);
-		param->returnStatus = (FSStatus)FS_RESULT::SUCCESS;
-		asyncParams.userContext = param.GetMPTRBE();
-
-		SAVEStatus status = SAVEGetStatAsync(client, block, accountSlot, path, stat, errHandling, &asyncParams);
-		if (status == (FSStatus)FS_RESULT::SUCCESS)
-		{
-			coreinit_suspendThread(coreinitThread_getCurrentThreadDepr(ppcInterpreterCurrentInstance), 1000);
-			PPCCore_switchToScheduler();
-			return param->returnStatus;
-		}
-
-		return status;
-	}
-
-	void export_SAVEGetStat(PPCInterpreter_t* hCPU)
-	{
-		ppcDefineParamMEMPTR(fsClient, coreinit::FSClient_t, 0);
-		ppcDefineParamMEMPTR(fsCmdBlock, coreinit::FSCmdBlock_t, 1);
-		ppcDefineParamU8(accountSlot, 2);
-		ppcDefineParamMEMPTR(path, const char, 3);
-		ppcDefineParamMEMPTR(stat, FSStat_t, 4);
-		ppcDefineParamU32(errHandling, 5);
-
-		const SAVEStatus result = SAVEGetStat(fsClient.GetPtr(), fsCmdBlock.GetPtr(), accountSlot, path.GetPtr(), stat.GetPtr(), errHandling);
-		saveLog_printf("SAVEGetStat(0x%08x, 0x%08x, %x, %s, 0x%08x, %x) -> %x", fsClient.GetMPTR(), fsCmdBlock.GetMPTR(), accountSlot, path.GetPtr(), stat.GetMPTR(), errHandling, result);
-		osLib_returnFromFunction(hCPU, result);
-	}
-
-	void export_SAVEGetStatOtherApplicationAsync(PPCInterpreter_t* hCPU)
-	{
-		ppcDefineParamMEMPTR(fsClient, coreinit::FSClient_t, 0);
-		ppcDefineParamMEMPTR(fsCmdBlock, coreinit::FSCmdBlock_t, 1);
-		ppcDefineParamU64(titleId, 2);
-		ppcDefineParamU8(accountSlot, 4);
-		ppcDefineParamMEMPTR(path, const char, 5);
-		ppcDefineParamMEMPTR(stat, FSStat_t, 6);
-		ppcDefineParamU32(errHandling, 7);
-		ppcDefineParamMEMPTR(asyncParams, FSAsyncParams_t, 8);
-
-		const SAVEStatus result = SAVEGetStatOtherApplicationAsync(fsClient.GetPtr(), fsCmdBlock.GetPtr(), titleId, accountSlot, path.GetPtr(), stat.GetPtr(), errHandling, asyncParams.GetPtr());
-		osLib_returnFromFunction(hCPU, result);
-	}
-
-	SAVEStatus SAVEGetStatOtherApplication(coreinit::FSClient_t* client, coreinit::FSCmdBlock_t* block, uint64 titleId, uint8 accountSlot, const char* path, FSStat_t* stat, FS_ERROR_MASK errHandling)
-	{
-		FSAsyncParams_t asyncParams;
-		asyncParams.ioMsgQueue = MPTR_NULL;
-		asyncParams.userCallback = _swapEndianU32(PPCInterpreter_makeCallableExportDepr(AsyncCallback));
-
-		StackAllocator<AsyncCallbackParam_t> param;
-		param->thread = coreinitThread_getCurrentThreadMPTRDepr(ppcInterpreterCurrentInstance);
-		param->returnStatus = (FSStatus)FS_RESULT::SUCCESS;
-		asyncParams.userContext = param.GetMPTRBE();
-
-		SAVEStatus status = SAVEGetStatOtherApplicationAsync(client, block, titleId, accountSlot, path, stat, errHandling, &asyncParams);
-		if (status == (FSStatus)FS_RESULT::SUCCESS)
-		{
-			coreinit_suspendThread(coreinitThread_getCurrentThreadDepr(ppcInterpreterCurrentInstance), 1000);
-			PPCCore_switchToScheduler();
-			return param->returnStatus;
-		}
-
-		return status;
-	}
-
-	void export_SAVEGetStatOtherApplication(PPCInterpreter_t* hCPU)
-	{
-		ppcDefineParamMEMPTR(fsClient, coreinit::FSClient_t, 0);
-		ppcDefineParamMEMPTR(fsCmdBlock, coreinit::FSCmdBlock_t, 1);
-		ppcDefineParamU64(titleId, 2);
-		ppcDefineParamU8(accountSlot, 4);
-		ppcDefineParamMEMPTR(path, const char, 5);
-		ppcDefineParamMEMPTR(stat, FSStat_t, 6);
-		ppcDefineParamU32(errHandling, 7);
-
-		const SAVEStatus result = SAVEGetStatOtherApplication(fsClient.GetPtr(), fsCmdBlock.GetPtr(), titleId, accountSlot, path.GetPtr(), stat.GetPtr(), errHandling);
-		osLib_returnFromFunction(hCPU, result);
-	}
-	
-
-	void export_SAVEGetStatOtherNormalApplicationAsync(PPCInterpreter_t* hCPU)
-	{
-		ppcDefineParamMEMPTR(fsClient, coreinit::FSClient_t, 0);
-		ppcDefineParamMEMPTR(fsCmdBlock, coreinit::FSCmdBlock_t, 1);
-		ppcDefineParamU32(uniqueId, 2);
-		ppcDefineParamU8(accountSlot, 3);
-		ppcDefineParamMEMPTR(path, const char, 4);
-		ppcDefineParamMEMPTR(stat, FSStat_t, 5);
-		ppcDefineParamU32(errHandling, 6);
-		ppcDefineParamMEMPTR(asyncParams, FSAsyncParams_t, 8);
-
-		const SAVEStatus result = SAVEGetStatOtherNormalApplicationAsync(fsClient.GetPtr(), fsCmdBlock.GetPtr(), uniqueId, accountSlot, path.GetPtr(), stat.GetPtr(), errHandling, asyncParams.GetPtr());
-		osLib_returnFromFunction(hCPU, result);
-	}
-
-	SAVEStatus SAVEGetStatOtherNormalApplication(coreinit::FSClient_t* client, coreinit::FSCmdBlock_t* block, uint32 uniqueId, uint8 accountSlot, const char* path, FSStat_t* stat, FS_ERROR_MASK errHandling)
-	{
-		//peterBreak();
-
-		uint64 titleId = SAVE_UNIQUE_TO_TITLE_ID(uniqueId);
-		return SAVEGetStatOtherApplication(client, block, titleId, accountSlot, path, stat, errHandling);
-	}
-
-	void export_SAVEGetStatOtherNormalApplication(PPCInterpreter_t* hCPU)
-	{
-		ppcDefineParamMEMPTR(fsClient, coreinit::FSClient_t, 0);
-		ppcDefineParamMEMPTR(fsCmdBlock, coreinit::FSCmdBlock_t, 1);
-		ppcDefineParamU32(uniqueId, 2);
-		ppcDefineParamU8(accountSlot, 3);
-		ppcDefineParamMEMPTR(path, const char, 4);
-		ppcDefineParamMEMPTR(stat, FSStat_t, 5);
-		ppcDefineParamU32(errHandling, 6);
-
-		const SAVEStatus result = SAVEGetStatOtherNormalApplication(fsClient.GetPtr(), fsCmdBlock.GetPtr(), uniqueId, accountSlot, path.GetPtr(), stat.GetPtr(), errHandling);
-		osLib_returnFromFunction(hCPU, result);
-	}
-
-
-
-	void export_SAVEGetStatOtherNormalApplicationVariationAsync(PPCInterpreter_t* hCPU)
-	{
-		ppcDefineParamMEMPTR(fsClient, coreinit::FSClient_t, 0);
-		ppcDefineParamMEMPTR(fsCmdBlock, coreinit::FSCmdBlock_t, 1);
-		ppcDefineParamU32(uniqueId, 2);
-		ppcDefineParamU8(variation, 3);
-		ppcDefineParamU8(accountSlot, 4);
-		ppcDefineParamMEMPTR(path, const char, 5);
-		ppcDefineParamMEMPTR(stat, FSStat_t, 6);
-		ppcDefineParamU32(errHandling, 7);
-		ppcDefineParamMEMPTR(asyncParams, FSAsyncParams_t, 8);
-
-		const SAVEStatus result = SAVEGetStatOtherNormalApplicationVariationAsync(fsClient.GetPtr(), fsCmdBlock.GetPtr(), uniqueId, variation, accountSlot, path.GetPtr(), stat.GetPtr(), errHandling, asyncParams.GetPtr());
-		osLib_returnFromFunction(hCPU, result);
-	}
-
 	SAVEStatus SAVEGetStatOtherNormalApplicationVariation(coreinit::FSClient_t* client, coreinit::FSCmdBlock_t* block, uint32 uniqueId, uint8 variation, uint8 accountSlot, const char* path, FSStat_t* stat, FS_ERROR_MASK errHandling)
 	{
 		//peterBreak();
@@ -1326,21 +623,140 @@ namespace save
 		return SAVEGetStatOtherApplication(client, block, titleId, accountSlot, path, stat, errHandling);
 	}
 
-	void export_SAVEGetStatOtherNormalApplicationVariation(PPCInterpreter_t* hCPU)
+	SAVEStatus SAVEGetFreeSpaceSizeAsync(coreinit::FSClient_t* client, coreinit::FSCmdBlock_t* block, uint8 accountSlot, FSLargeSize* freeSize, FS_ERROR_MASK errHandling, const FSAsyncParams* asyncParams)
 	{
-		ppcDefineParamMEMPTR(fsClient, coreinit::FSClient_t, 0);
-		ppcDefineParamMEMPTR(fsCmdBlock, coreinit::FSCmdBlock_t, 1);
-		ppcDefineParamU32(uniqueId, 2);
-		ppcDefineParamU8(variation, 3);
-		ppcDefineParamU8(accountSlot, 4);
-		ppcDefineParamMEMPTR(path, const char, 5);
-		ppcDefineParamMEMPTR(stat, FSStat_t, 6);
-		ppcDefineParamU32(errHandling, 7);
+		SAVEStatus result = (FSStatus)(FS_RESULT::FATAL_ERROR);
 
-		const SAVEStatus result = SAVEGetStatOtherNormalApplicationVariation(fsClient.GetPtr(), fsCmdBlock.GetPtr(), uniqueId, variation, accountSlot, path.GetPtr(), stat.GetPtr(), errHandling);
-		osLib_returnFromFunction(hCPU, result);
+		OSLockMutex(&g_nn_save->mutex);
+
+		uint32 persistentId;
+		if (GetPersistentIdEx(accountSlot, &persistentId))
+		{
+			char fullPath[SAVE_MAX_PATH_SIZE];
+			if (GetAbsoluteFullPath(persistentId, nullptr, fullPath))
+				result = coreinit::FSGetFreeSpaceSizeAsync(client, block, fullPath, freeSize, errHandling, (FSAsyncParams*)asyncParams);
+		}
+		else
+			result = (FSStatus)FS_RESULT::NOT_FOUND;
+
+		OSUnlockMutex(&g_nn_save->mutex);
+
+		return result;
 	}
 
+	SAVEStatus SAVEGetFreeSpaceSize(coreinit::FSClient_t* client, coreinit::FSCmdBlock_t* block, uint8 accountSlot, FSLargeSize* freeSize, FS_ERROR_MASK errHandling)
+	{
+		StackAllocator<AsyncToSyncWrapper> asyncData;
+		SAVEStatus status = SAVEGetFreeSpaceSizeAsync(client, block, accountSlot, freeSize, errHandling, asyncData->GetAsyncParams());
+		if (status != (FSStatus)FS_RESULT::SUCCESS)
+			return status;
+		asyncData->WaitForEvent();
+		return asyncData->GetResult();
+	}
+
+	SAVEStatus SAVERemoveAsync(coreinit::FSClient_t* client, coreinit::FSCmdBlock_t* block, uint8 accountSlot, const char* path, FS_ERROR_MASK errHandling, const FSAsyncParams* asyncParams)
+	{
+		SAVEStatus result = (FSStatus)(FS_RESULT::FATAL_ERROR);
+
+		OSLockMutex(&g_nn_save->mutex);
+
+		uint32 persistentId;
+		if (GetPersistentIdEx(accountSlot, &persistentId))
+		{
+			char fullPath[SAVE_MAX_PATH_SIZE];
+			if (GetAbsoluteFullPath(persistentId, path, fullPath))
+				result = coreinit::FSRemoveAsync(client, block, (uint8*)fullPath, errHandling, (FSAsyncParams*)asyncParams);
+		}
+		else
+			result = (FSStatus)FS_RESULT::NOT_FOUND;
+
+		OSUnlockMutex(&g_nn_save->mutex);
+		return result;
+	}
+
+	SAVEStatus SAVERemove(coreinit::FSClient_t* client, coreinit::FSCmdBlock_t* block, uint8 accountSlot, const char* path, FS_ERROR_MASK errHandling)
+	{
+		StackAllocator<AsyncToSyncWrapper> asyncData;
+		SAVEStatus status = SAVERemoveAsync(client, block, accountSlot, path, errHandling, asyncData->GetAsyncParams());
+		if (status != (FSStatus)FS_RESULT::SUCCESS)
+			return status;
+		asyncData->WaitForEvent();
+		return asyncData->GetResult();
+	}
+
+	SAVEStatus SAVERenameAsync(coreinit::FSClient_t* client, coreinit::FSCmdBlock_t* block, uint8 accountSlot, const char* oldPath, const char* newPath, FS_ERROR_MASK errHandling, FSAsyncParams* asyncParams)
+	{
+		SAVEStatus result = (FSStatus)(FS_RESULT::FATAL_ERROR);
+		OSLockMutex(&g_nn_save->mutex);
+
+		uint32 persistentId;
+		if (GetPersistentIdEx(accountSlot, &persistentId))
+		{
+			char fullOldPath[SAVE_MAX_PATH_SIZE];
+			if (GetAbsoluteFullPath(persistentId, oldPath, fullOldPath))
+			{
+				char fullNewPath[SAVE_MAX_PATH_SIZE];
+				if (GetAbsoluteFullPath(persistentId, newPath, fullNewPath))
+					result = coreinit::FSRenameAsync(client, block, fullOldPath, fullNewPath, errHandling, asyncParams);
+			}
+		}
+		else
+			result = (FSStatus)FS_RESULT::NOT_FOUND;
+
+		OSUnlockMutex(&g_nn_save->mutex);
+		return result;
+	}
+
+	SAVEStatus SAVERename(coreinit::FSClient_t* client, coreinit::FSCmdBlock_t* block, uint8 accountSlot, const char* oldPath, const char* newPath, FS_ERROR_MASK errHandling)
+	{
+		StackAllocator<AsyncToSyncWrapper> asyncData;
+		SAVEStatus status = SAVERenameAsync(client, block, accountSlot, oldPath, newPath, errHandling, asyncData->GetAsyncParams());
+		if (status != (FSStatus)FS_RESULT::SUCCESS)
+			return status;
+		asyncData->WaitForEvent();
+		return asyncData->GetResult();
+	}
+
+	SAVEStatus SAVEMakeDirAsync(coreinit::FSClient_t* client, coreinit::FSCmdBlock_t* block, uint8 accountSlot, const char* path, FS_ERROR_MASK errHandling, const FSAsyncParams* asyncParams)
+	{
+		SAVEStatus result = (FSStatus)(FS_RESULT::FATAL_ERROR);
+
+		OSLockMutex(&g_nn_save->mutex);
+
+		uint32 persistentId;
+		if (GetPersistentIdEx(accountSlot, &persistentId))
+		{
+			char fullPath[SAVE_MAX_PATH_SIZE];
+			if (GetAbsoluteFullPath(persistentId, path, fullPath))
+				result = coreinit::FSMakeDirAsync(client, block, fullPath, errHandling, (FSAsyncParams*)asyncParams);
+		}
+		else
+			result = (FSStatus)FS_RESULT::NOT_FOUND;
+
+		OSUnlockMutex(&g_nn_save->mutex);
+
+		return result;
+	}
+
+	SAVEStatus SAVEMakeDir(coreinit::FSClient_t* client, coreinit::FSCmdBlock_t* block, uint8 accountSlot, const char* path, FS_ERROR_MASK errHandling)
+	{
+		StackAllocator<AsyncToSyncWrapper> asyncData;
+		SAVEStatus status = SAVEMakeDirAsync(client, block, accountSlot, path, errHandling, asyncData->GetAsyncParams());
+		if (status != (FSStatus)FS_RESULT::SUCCESS)
+			return status;
+		asyncData->WaitForEvent();
+		return asyncData->GetResult();
+	}
+
+	SAVEStatus SAVEOpenFile(coreinit::FSClient_t* client, coreinit::FSCmdBlock_t* block, uint8 accountSlot, const char* path, const char* mode, FSFileHandlePtr outFileHandle, FS_ERROR_MASK errHandling)
+	{
+		StackAllocator<AsyncToSyncWrapper> asyncData;
+		SAVEStatus status = SAVEOpenFileAsync(client, block, accountSlot, path, mode, outFileHandle, errHandling, asyncData->GetAsyncParams());
+		if (status != (FSStatus)FS_RESULT::SUCCESS)
+			return status;
+		asyncData->WaitForEvent();
+		return asyncData->GetResult();
+	}
 
 	SAVEStatus SAVEGetSharedDataTitlePath(uint64 titleId, const char* dataFileName, char* output, sint32 outputLength)
 	{
@@ -1352,17 +768,6 @@ namespace save
 		return result;
 	}
 
-	void export_SAVEGetSharedDataTitlePath(PPCInterpreter_t* hCPU)
-	{
-		ppcDefineParamU64(titleId, 0);
-		ppcDefineParamMEMPTR(dataFileName, const char, 2);
-		ppcDefineParamMEMPTR(output, char, 3);
-		ppcDefineParamS32(outputLength, 4);
-		const SAVEStatus result = SAVEGetSharedDataTitlePath(titleId, dataFileName.GetPtr(), output.GetPtr(), outputLength);
-		saveLog_printf("SAVEGetSharedDataTitlePath(0x%llx, %s, %s, 0x%x) -> %x", titleId, dataFileName.GetPtr(), output.GetPtr(), outputLength, result);
-		osLib_returnFromFunction(hCPU, result);
-	}
-
 	SAVEStatus SAVEGetSharedSaveDataPath(uint64 titleId, const char* dataFileName, char* output, uint32 outputLength)
 	{
 		SAVEStatus result = (FSStatus)(FS_RESULT::FATAL_ERROR);
@@ -1373,17 +778,7 @@ namespace save
 		return result;
 	}
 
-	void export_SAVEGetSharedSaveDataPath(PPCInterpreter_t* hCPU)
-	{
-		ppcDefineParamU64(titleId, 0);
-		ppcDefineParamMEMPTR(dataFileName, const char, 2);
-		ppcDefineParamMEMPTR(output, char, 3);
-		ppcDefineParamU32(outputLength, 4);
-		const SAVEStatus result = SAVEGetSharedSaveDataPath(titleId, dataFileName.GetPtr(), output.GetPtr(), outputLength);
-		osLib_returnFromFunction(hCPU, result);
-	}
-
-	SAVEStatus SAVEChangeDirAsync(coreinit::FSClient_t* client, coreinit::FSCmdBlock_t* block, uint8 accountSlot, const char* path, FS_ERROR_MASK errHandling, const FSAsyncParams_t* asyncParams)
+	SAVEStatus SAVEChangeDirAsync(coreinit::FSClient_t* client, coreinit::FSCmdBlock_t* block, uint8 accountSlot, const char* path, FS_ERROR_MASK errHandling, const FSAsyncParams* asyncParams)
 	{
 		SAVEStatus result = (FSStatus)(FS_RESULT::FATAL_ERROR);
 
@@ -1393,7 +788,7 @@ namespace save
 		{
 			char fullPath[SAVE_MAX_PATH_SIZE];
 			if (GetAbsoluteFullPath(persistentId, path, fullPath))
-				result = coreinit::FSChangeDirAsync(client, block, fullPath, errHandling, (FSAsyncParamsNew_t*)asyncParams);
+				result = coreinit::FSChangeDirAsync(client, block, fullPath, errHandling, (FSAsyncParams*)asyncParams);
 		}
 		else
 			result = (FSStatus)FS_RESULT::NOT_FOUND;
@@ -1402,54 +797,17 @@ namespace save
 		return result;
 	}
 
-	void export_SAVEChangeDirAsync(PPCInterpreter_t* hCPU)
-	{
-		ppcDefineParamMEMPTR(fsClient, coreinit::FSClient_t, 0);
-		ppcDefineParamMEMPTR(fsCmdBlock, coreinit::FSCmdBlock_t, 1);
-		ppcDefineParamU8(accountSlot, 2);
-		ppcDefineParamMEMPTR(path, const char, 3);
-		ppcDefineParamU32(errHandling, 4);
-		ppcDefineParamMEMPTR(asyncParams, FSAsyncParams_t, 5);
-		const SAVEStatus result = SAVEChangeDirAsync(fsClient.GetPtr(), fsCmdBlock.GetPtr(), accountSlot, path.GetPtr(), errHandling, asyncParams.GetPtr());
-		saveLog_printf("SAVEChangeDirAsync(0x%08x, 0x%08x, %x, %s, %x) -> %x", fsClient.GetMPTR(), fsCmdBlock.GetMPTR(), accountSlot, path.GetPtr(), errHandling, result);
-		osLib_returnFromFunction(hCPU, result);
-	}
-
 	SAVEStatus SAVEChangeDir(coreinit::FSClient_t* client, coreinit::FSCmdBlock_t* block, uint8 accountSlot, const char* path, FS_ERROR_MASK errHandling)
 	{
-		FSAsyncParams_t asyncParams;
-		asyncParams.ioMsgQueue = MPTR_NULL;
-		asyncParams.userCallback = _swapEndianU32(PPCInterpreter_makeCallableExportDepr(AsyncCallback));
-
-		StackAllocator<AsyncCallbackParam_t> param;
-		param->thread = coreinitThread_getCurrentThreadMPTRDepr(ppcInterpreterCurrentInstance);
-		param->returnStatus = (FSStatus)FS_RESULT::SUCCESS;
-		asyncParams.userContext = param.GetMPTRBE();
-
-		SAVEStatus status = SAVEChangeDirAsync(client, block, accountSlot, path, errHandling, &asyncParams);
-		if (status == (FSStatus)FS_RESULT::SUCCESS)
-		{
-			coreinit_suspendThread(coreinitThread_getCurrentThreadDepr(ppcInterpreterCurrentInstance), 1000);
-			PPCCore_switchToScheduler();
-			return param->returnStatus;
-		}
-
-		return status;
+		StackAllocator<AsyncToSyncWrapper> asyncData;
+		SAVEStatus status = SAVEChangeDirAsync(client, block, accountSlot, path, errHandling, asyncData->GetAsyncParams());
+		if (status != (FSStatus)FS_RESULT::SUCCESS)
+			return status;
+		asyncData->WaitForEvent();
+		return asyncData->GetResult();
 	}
 
-	void export_SAVEChangeDir(PPCInterpreter_t* hCPU)
-	{
-		ppcDefineParamMEMPTR(fsClient, coreinit::FSClient_t, 0);
-		ppcDefineParamMEMPTR(fsCmdBlock, coreinit::FSCmdBlock_t, 1);
-		ppcDefineParamU8(accountSlot, 2);
-		ppcDefineParamMEMPTR(path, const char, 3);
-		ppcDefineParamU32(errHandling, 4);
-		const SAVEStatus result = SAVEChangeDir(fsClient.GetPtr(), fsCmdBlock.GetPtr(), accountSlot, path.GetPtr(), errHandling);
-		saveLog_printf("SAVEChangeDir(0x%08x, 0x%08x, %x, %s, %x) -> %x", fsClient.GetMPTR(), fsCmdBlock.GetMPTR(), accountSlot, path.GetPtr(), errHandling, result);
-		osLib_returnFromFunction(hCPU, result);
-	}
-
-	SAVEStatus SAVEFlushQuotaAsync(coreinit::FSClient_t* client, coreinit::FSCmdBlock_t* block, uint8 accountSlot, FS_ERROR_MASK errHandling, const FSAsyncParams_t* asyncParams)
+	SAVEStatus SAVEFlushQuotaAsync(coreinit::FSClient_t* client, coreinit::FSCmdBlock_t* block, uint8 accountSlot, FS_ERROR_MASK errHandling, const FSAsyncParams* asyncParams)
 	{
 		SAVEStatus result = (FSStatus)(FS_RESULT::FATAL_ERROR);
 
@@ -1460,7 +818,7 @@ namespace save
 			char fullPath[SAVE_MAX_PATH_SIZE];
 			if (GetAbsoluteFullPath(persistentId, nullptr, fullPath))
 			{
-				result = coreinit::FSFlushQuotaAsync(client, block, fullPath, errHandling, (FSAsyncParamsNew_t*)asyncParams);
+				result = coreinit::FSFlushQuotaAsync(client, block, fullPath, errHandling, (FSAsyncParams*)asyncParams);
 				// if(OSGetUPID != 0xF)
 				UpdateSaveTimeStamp(persistentId);
 			}
@@ -1472,103 +830,73 @@ namespace save
 		return result;
 	}
 
-	void export_SAVEFlushQuotaAsync(PPCInterpreter_t* hCPU)
-	{
-		ppcDefineParamMEMPTR(fsClient, coreinit::FSClient_t, 0);
-		ppcDefineParamMEMPTR(fsCmdBlock, coreinit::FSCmdBlock_t, 1);
-		ppcDefineParamU8(accountSlot, 2);
-		ppcDefineParamU32(errHandling, 3);
-		ppcDefineParamMEMPTR(asyncParams, FSAsyncParams_t, 4);
-		const SAVEStatus result = SAVEFlushQuotaAsync(fsClient.GetPtr(), fsCmdBlock.GetPtr(), accountSlot, errHandling, asyncParams.GetPtr());
-		saveLog_printf("SAVEFlushQuotaAsync(0x%08x, 0x%08x, %x, %x) -> %x", fsClient.GetMPTR(), fsCmdBlock.GetMPTR(), accountSlot, errHandling, result);
-		osLib_returnFromFunction(hCPU, result);
-	}
-
 	SAVEStatus SAVEFlushQuota(coreinit::FSClient_t* client, coreinit::FSCmdBlock_t* block, uint8 accountSlot,  FS_ERROR_MASK errHandling)
 	{
-		FSAsyncParams_t asyncParams;
-		asyncParams.ioMsgQueue = MPTR_NULL;
-		asyncParams.userCallback = _swapEndianU32(PPCInterpreter_makeCallableExportDepr(AsyncCallback));
-
-		StackAllocator<AsyncCallbackParam_t> param;
-		param->thread = coreinitThread_getCurrentThreadMPTRDepr(ppcInterpreterCurrentInstance);
-		param->returnStatus = (FSStatus)FS_RESULT::SUCCESS;
-		asyncParams.userContext = param.GetMPTRBE();
-
-		SAVEStatus status = SAVEFlushQuotaAsync(client, block, accountSlot, errHandling, &asyncParams);
-		if (status == (FSStatus)FS_RESULT::SUCCESS)
-		{
-			coreinit_suspendThread(coreinitThread_getCurrentThreadDepr(ppcInterpreterCurrentInstance), 1000);
-			PPCCore_switchToScheduler();
-			return param->returnStatus;
-		}
-		return status;
-	}
-
-	void export_SAVEFlushQuota(PPCInterpreter_t* hCPU)
-	{
-		ppcDefineParamMEMPTR(fsClient, coreinit::FSClient_t, 0);
-		ppcDefineParamMEMPTR(fsCmdBlock, coreinit::FSCmdBlock_t, 1);
-		ppcDefineParamU8(accountSlot, 2);
-		ppcDefineParamU32(errHandling, 3);
-		const SAVEStatus result = SAVEFlushQuota(fsClient.GetPtr(), fsCmdBlock.GetPtr(), accountSlot, errHandling);
-		saveLog_printf("SAVEFlushQuota(0x%08x, 0x%08x, %x, %x) -> %x", fsClient.GetMPTR(), fsCmdBlock.GetMPTR(), accountSlot, errHandling, result);
-		osLib_returnFromFunction(hCPU, result);
+		StackAllocator<AsyncToSyncWrapper> asyncData;
+		SAVEStatus status = SAVEFlushQuotaAsync(client, block, accountSlot, errHandling, asyncData->GetAsyncParams());
+		if (status != (FSStatus)FS_RESULT::SUCCESS)
+			return status;
+		asyncData->WaitForEvent();
+		return asyncData->GetResult();
 	}
 
 	void load()
 	{
-		osLib_addFunction("nn_save", "SAVEInit", export_SAVEInit);
-		osLib_addFunction("nn_save", "SAVEInitSaveDir", export_SAVEInitSaveDir);
-		osLib_addFunction("nn_save", "SAVEGetSharedDataTitlePath", export_SAVEGetSharedDataTitlePath);
-		osLib_addFunction("nn_save", "SAVEGetSharedSaveDataPath", export_SAVEGetSharedSaveDataPath);
+		cafeExportRegister("nn_save", SAVEInit, LogType::Save);
+		cafeExportRegister("nn_save", SAVEInitSaveDir, LogType::Save);
 
-		// sync functions
-		osLib_addFunction("nn_save", "SAVEGetFreeSpaceSize", export_SAVEGetFreeSpaceSize);
-		osLib_addFunction("nn_save", "SAVEMakeDir", export_SAVEMakeDir);
-		osLib_addFunction("nn_save", "SAVERemove", export_SAVERemove);
-		osLib_addFunction("nn_save", "SAVEChangeDir", export_SAVEChangeDir);
-		osLib_addFunction("nn_save", "SAVEFlushQuota", export_SAVEFlushQuota);
+		cafeExportRegister("nn_save", SAVEGetSharedDataTitlePath, LogType::Save);
+		cafeExportRegister("nn_save", SAVEGetSharedSaveDataPath, LogType::Save);
 
-		osLib_addFunction("nn_save", "SAVEGetStat", export_SAVEGetStat);
-		osLib_addFunction("nn_save", "SAVEGetStatOtherApplication", export_SAVEGetStatOtherApplication);
-		osLib_addFunction("nn_save", "SAVEGetStatOtherNormalApplication", export_SAVEGetStatOtherNormalApplication);
-		osLib_addFunction("nn_save", "SAVEGetStatOtherNormalApplicationVariation", export_SAVEGetStatOtherNormalApplicationVariation);
+		cafeExportRegister("nn_save", SAVEGetFreeSpaceSize, LogType::Save);
+		cafeExportRegister("nn_save", SAVEGetFreeSpaceSizeAsync, LogType::Save);
+		cafeExportRegister("nn_save", SAVEMakeDir, LogType::Save);
+		cafeExportRegister("nn_save", SAVEMakeDirAsync, LogType::Save);
+		cafeExportRegister("nn_save", SAVERemove, LogType::Save);
+		cafeExportRegister("nn_save", SAVERemoveAsync, LogType::Save);
+		cafeExportRegister("nn_save", SAVEChangeDir, LogType::Save);
+		cafeExportRegister("nn_save", SAVEChangeDirAsync, LogType::Save);
+		cafeExportRegister("nn_save", SAVERename, LogType::Save);
+		cafeExportRegister("nn_save", SAVERenameAsync, LogType::Save);
+		cafeExportRegister("nn_save", SAVEFlushQuota, LogType::Save);
+		cafeExportRegister("nn_save", SAVEFlushQuotaAsync, LogType::Save);
 
-		osLib_addFunction("nn_save", "SAVEOpenFile", export_SAVEOpenFile);
-		osLib_addFunction("nn_save", "SAVEOpenFileOtherApplication", export_SAVEOpenFileOtherApplication);
-		osLib_addFunction("nn_save", "SAVEOpenFileOtherNormalApplication", export_SAVEOpenFileOtherNormalApplication);
-		osLib_addFunction("nn_save", "SAVEOpenFileOtherNormalApplicationVariation", export_SAVEOpenFileOtherNormalApplicationVariation);
+		cafeExportRegister("nn_save", SAVEGetStat, LogType::Save);
+		cafeExportRegister("nn_save", SAVEGetStatAsync, LogType::Save);
+		cafeExportRegister("nn_save", SAVEGetStatOtherApplication, LogType::Save);
+		cafeExportRegister("nn_save", SAVEGetStatOtherApplicationAsync, LogType::Save);
+		cafeExportRegister("nn_save", SAVEGetStatOtherNormalApplication, LogType::Save);
+		cafeExportRegister("nn_save", SAVEGetStatOtherNormalApplicationAsync, LogType::Save);
+		cafeExportRegister("nn_save", SAVEGetStatOtherNormalApplicationVariation, LogType::Save);
+		cafeExportRegister("nn_save", SAVEGetStatOtherNormalApplicationVariationAsync, LogType::Save);
 
-		osLib_addFunction("nn_save", "SAVEOpenDir", export_SAVEOpenDir);
-		osLib_addFunction("nn_save", "SAVEOpenDirOtherApplication", export_SAVEOpenDirOtherApplication);
-		osLib_addFunction("nn_save", "SAVEOpenDirOtherNormalApplication", export_SAVEOpenDirOtherNormalApplication);
-		osLib_addFunction("nn_save", "SAVEOpenDirOtherNormalApplicationVariation", export_SAVEOpenDirOtherNormalApplicationVariation);
+		cafeExportRegister("nn_save", SAVEOpenFile, LogType::Save);
+		cafeExportRegister("nn_save", SAVEOpenFileAsync, LogType::Save);
+		cafeExportRegister("nn_save", SAVEOpenFileOtherApplication, LogType::Save);
+		cafeExportRegister("nn_save", SAVEOpenFileOtherApplicationAsync, LogType::Save);
+		cafeExportRegister("nn_save", SAVEOpenFileOtherNormalApplication, LogType::Save);
+		cafeExportRegister("nn_save", SAVEOpenFileOtherNormalApplicationAsync, LogType::Save);
+		cafeExportRegister("nn_save", SAVEOpenFileOtherNormalApplicationVariation, LogType::Save);
+		cafeExportRegister("nn_save", SAVEOpenFileOtherNormalApplicationVariationAsync, LogType::Save);
 
-		// async functions
-		osLib_addFunction("nn_save", "SAVEGetFreeSpaceSizeAsync", export_SAVEGetFreeSpaceSizeAsync);
-		osLib_addFunction("nn_save", "SAVEMakeDirAsync", export_SAVEMakeDirAsync);
-		osLib_addFunction("nn_save", "SAVERemoveAsync", export_SAVERemoveAsync);
-		osLib_addFunction("nn_save", "SAVERenameAsync", export_SAVERenameAsync);
-		cafeExportRegister("nn_save", SAVERename, LogType::Save);		
-
-		osLib_addFunction("nn_save", "SAVEChangeDirAsync", export_SAVEChangeDirAsync);
-		osLib_addFunction("nn_save", "SAVEFlushQuotaAsync", export_SAVEFlushQuotaAsync);
-
-		osLib_addFunction("nn_save", "SAVEGetStatAsync", export_SAVEGetStatAsync);
-		osLib_addFunction("nn_save", "SAVEGetStatOtherApplicationAsync", export_SAVEGetStatOtherApplicationAsync);
-		osLib_addFunction("nn_save", "SAVEGetStatOtherNormalApplicationAsync", export_SAVEGetStatOtherNormalApplicationAsync);
-		osLib_addFunction("nn_save", "SAVEGetStatOtherNormalApplicationVariationAsync", export_SAVEGetStatOtherNormalApplicationVariationAsync);
-
-		osLib_addFunction("nn_save", "SAVEOpenFileAsync", export_SAVEOpenFileAsync);
-		osLib_addFunction("nn_save", "SAVEOpenFileOtherApplicationAsync", export_SAVEOpenFileOtherApplicationAsync);
-		osLib_addFunction("nn_save", "SAVEOpenFileOtherNormalApplicationAsync", export_SAVEOpenFileOtherNormalApplicationAsync);
-		osLib_addFunction("nn_save", "SAVEOpenFileOtherNormalApplicationVariationAsync", export_SAVEOpenFileOtherNormalApplicationVariationAsync);
-		
-		osLib_addFunction("nn_save", "SAVEOpenDirAsync", export_SAVEOpenDirAsync);
-		osLib_addFunction("nn_save", "SAVEOpenDirOtherApplicationAsync", export_SAVEOpenDirOtherApplicationAsync);
-		osLib_addFunction("nn_save", "SAVEOpenDirOtherNormalApplicationAsync", export_SAVEOpenDirOtherNormalApplicationAsync);
-		osLib_addFunction("nn_save", "SAVEOpenDirOtherNormalApplicationVariationAsync", export_SAVEOpenDirOtherNormalApplicationVariationAsync);
+		cafeExportRegister("nn_save", SAVEOpenDir, LogType::Save);
+		cafeExportRegister("nn_save", SAVEOpenDirAsync, LogType::Save);
+		cafeExportRegister("nn_save", SAVEOpenDirOtherApplication, LogType::Save);
+		cafeExportRegister("nn_save", SAVEOpenDirOtherApplicationAsync, LogType::Save);
+		cafeExportRegister("nn_save", SAVEOpenDirOtherNormalApplication, LogType::Save);
+		cafeExportRegister("nn_save", SAVEOpenDirOtherNormalApplicationVariation, LogType::Save);
+		cafeExportRegister("nn_save", SAVEOpenDirOtherNormalApplicationAsync, LogType::Save);
+		cafeExportRegister("nn_save", SAVEOpenDirOtherNormalApplicationVariationAsync, LogType::Save);
 	}
+
+    void ResetToDefaultState()
+    {
+        if(g_nn_save->initialized)
+        {
+            SAVEUnmountSaveDir();
+            g_nn_save->initialized = false;
+        }
+    }
+
 }
 }
diff --git a/src/Cafe/OS/libs/nn_save/nn_save.h b/src/Cafe/OS/libs/nn_save/nn_save.h
index 088fb1b6..5c9b3b52 100644
--- a/src/Cafe/OS/libs/nn_save/nn_save.h
+++ b/src/Cafe/OS/libs/nn_save/nn_save.h
@@ -5,6 +5,7 @@ namespace nn
 namespace save
 {
 	void load();
+    void ResetToDefaultState();
 
 	bool GetPersistentIdEx(uint8 accountSlot, uint32* persistentId);
 }
diff --git a/src/Cafe/OS/libs/nn_sl/nn_sl.cpp b/src/Cafe/OS/libs/nn_sl/nn_sl.cpp
new file mode 100644
index 00000000..b25a91bc
--- /dev/null
+++ b/src/Cafe/OS/libs/nn_sl/nn_sl.cpp
@@ -0,0 +1,115 @@
+#include "Cafe/OS/common/OSCommon.h"
+#include "Cafe/OS/libs/coreinit/coreinit_IOS.h"
+#include "Cafe/OS/libs/coreinit/coreinit_MEM.h"
+#include "config/ActiveSettings.h"
+#include "Cafe/CafeSystem.h"
+
+namespace nn
+{
+	typedef uint32 Result;
+	namespace sl
+	{
+		struct VTableEntry
+		{
+			uint16be offsetA{0};
+			uint16be offsetB{0};
+			MEMPTR<void> ptr;
+		};
+		static_assert(sizeof(VTableEntry) == 8);
+
+		constexpr uint32 SL_MEM_MAGIC = 0xCAFE4321;
+
+#define DTOR_WRAPPER(__TYPE) RPLLoader_MakePPCCallable([](PPCInterpreter_t* hCPU) { dtor(MEMPTR<__TYPE>(hCPU->gpr[3]), hCPU->gpr[4]); osLib_returnFromFunction(hCPU, 0); })
+
+		template<typename T>
+		MEMPTR<T> sl_new()
+		{
+			uint32 objSize = sizeof(T);
+			uint32be* basePtr = (uint32be*)coreinit::_weak_MEMAllocFromDefaultHeapEx(objSize + 8, 0x8);
+			basePtr[0] = SL_MEM_MAGIC;
+			basePtr[1] = objSize;
+			return (T*)(basePtr + 2);
+		}
+
+		void sl_delete(MEMPTR<void> mem)
+		{
+			if (!mem)
+				return;
+			uint32be* basePtr = (uint32be*)mem.GetPtr() - 2;
+			if (basePtr[0] != SL_MEM_MAGIC)
+			{
+				cemuLog_log(LogType::Force, "nn_sl: Detected memory corruption");
+				cemu_assert_suspicious();
+			}
+			coreinit::_weak_MEMFreeToDefaultHeap(basePtr);
+		}
+
+#pragma pack(1)
+		struct WhiteList
+		{
+			uint32be titleTypes[50];
+			uint32be titleTypesCount;
+			uint32be padding;
+			uint64be titleIds[50];
+			uint32be titleIdCount;
+		};
+		static_assert(sizeof(WhiteList) == 0x264);
+#pragma pack()
+		
+		struct WhiteListAccessor
+		{
+			MEMPTR<void> vTablePtr{}; // 0x00
+
+			struct VTable
+			{
+				VTableEntry rtti;
+				VTableEntry dtor;
+				VTableEntry get;
+			};
+			static inline SysAllocator<VTable> s_titleVTable;
+
+			static WhiteListAccessor* ctor(WhiteListAccessor* _this)
+			{
+				if (!_this)
+					_this = sl_new<WhiteListAccessor>();
+				*_this = {};
+				_this->vTablePtr = s_titleVTable;
+				return _this;
+			}
+
+			static void dtor(WhiteListAccessor* _this, uint32 options)
+			{
+				if (_this && (options & 1))
+					sl_delete(_this);
+			}
+
+			static void Get(WhiteListAccessor* _this, nn::sl::WhiteList* outWhiteList)
+			{
+				*outWhiteList = {};
+			}
+
+			static void InitVTable()
+			{
+				s_titleVTable->rtti.ptr = nullptr; // todo
+				s_titleVTable->dtor.ptr = DTOR_WRAPPER(WhiteListAccessor);
+				s_titleVTable->get.ptr = RPLLoader_MakePPCCallable([](PPCInterpreter_t* hCPU) { Get(MEMPTR<WhiteListAccessor>(hCPU->gpr[3]), MEMPTR<WhiteList>(hCPU->gpr[4])); osLib_returnFromFunction(hCPU, 0); });
+			}
+		};
+		static_assert(sizeof(WhiteListAccessor) == 0x04);
+
+		SysAllocator<WhiteListAccessor> s_defaultWhiteListAccessor;
+
+		WhiteListAccessor* GetDefaultWhiteListAccessor()
+		{
+			return s_defaultWhiteListAccessor;
+		}
+	} // namespace sl
+} // namespace nn
+
+void nnSL_load()
+{
+	nn::sl::WhiteListAccessor::InitVTable();
+	nn::sl::WhiteListAccessor::ctor(nn::sl::s_defaultWhiteListAccessor);
+
+	cafeExportRegisterFunc(nn::sl::GetDefaultWhiteListAccessor, "nn_sl", "GetDefaultWhiteListAccessor__Q2_2nn2slFv", LogType::NN_SL);
+}
diff --git a/src/Cafe/OS/libs/nn_sl/nn_sl.h b/src/Cafe/OS/libs/nn_sl/nn_sl.h
new file mode 100644
index 00000000..08d936cb
--- /dev/null
+++ b/src/Cafe/OS/libs/nn_sl/nn_sl.h
@@ -0,0 +1 @@
+void nnSL_load();
\ No newline at end of file
diff --git a/src/Cafe/OS/libs/nn_spm/nn_spm.cpp b/src/Cafe/OS/libs/nn_spm/nn_spm.cpp
new file mode 100644
index 00000000..911296cd
--- /dev/null
+++ b/src/Cafe/OS/libs/nn_spm/nn_spm.cpp
@@ -0,0 +1,150 @@
+#include "nn_spm.h"
+#include "Cafe/OS/common/OSCommon.h"
+#include "Cafe/OS/libs/nn_common.h"
+
+namespace nn
+{
+	namespace spm
+	{
+
+		struct StorageIndex
+		{
+			void SetInvalid() { idHigh = 0; idLow = 0; }
+			void Set(uint64 id) { idHigh = id >> 32; idLow = id & 0xFFFFFFFF; }
+
+			uint64 Get() const { return ((uint64)idHigh << 32) | (uint64)idLow; }
+
+			uint32be idHigh;
+			uint32be idLow;
+		};
+
+		enum class CemuStorageIndex
+		{
+			MLC = 1,
+			SLC = 2,
+			USB = 3,
+		};
+
+		static_assert(sizeof(StorageIndex) == 8);
+
+		struct VolumeId
+		{
+			char id[16];
+		};
+
+		static_assert(sizeof(VolumeId) == 16);
+
+		enum class StorageType : uint32
+		{
+			RAW,
+			WFS,
+		};
+
+		struct StorageInfo
+		{
+			char mountPath[640]; // For example: /vol/storage_usb01
+			char connectionType[8]; // usb
+			char formatStr[8]; // raw / wfs
+			uint8 ukn[4];
+			betype<StorageType> type;
+			VolumeId volumeId;
+		};
+
+		static_assert(sizeof(StorageInfo) == 680);
+
+		struct StorageListItem
+		{
+			StorageIndex index;
+			uint32be ukn04;
+			betype<StorageType> type;
+		};
+
+		static_assert(sizeof(StorageListItem) == 16);
+
+		sint32 GetDefaultExtendedStorageVolumeId(StorageIndex* storageIndex)
+		{
+			cemuLog_logDebug(LogType::Force, "GetDefaultExtendedStorageVolumeId() - stub");
+			storageIndex->SetInvalid(); // we dont emulate USB storage yet
+			return 0;
+		}
+
+		sint32 GetExtendedStorageIndex(StorageIndex* storageIndex)
+		{
+			cemuLog_logDebug(LogType::Force, "GetExtendedStorageIndex() - stub");
+			storageIndex->SetInvalid(); // we dont emulate USB storage yet
+			return -1; // this fails if there is none?
+		}
+
+		// nn::spm::GetStorageList((nn::spm::StorageListItem *, unsigned int))
+
+		uint32 GetStorageList(StorageListItem* storageList, uint32 maxItems)
+		{
+			cemu_assert(maxItems >= 2);
+			uint32 numItems = 0;
+
+			// This should only return USB storages?
+			// If we return two entries (for SLC and MLC supposedly) then the Wii U menu will complain about two usb storages
+
+//			// mlc
+//			storageList[numItems].index.Set((uint32)CemuStorageIndex::MLC);
+//			storageList[numItems].ukn04 = 0;
+//			storageList[numItems].type = StorageType::WFS;
+//			numItems++;
+//			// slc
+//			storageList[numItems].index.Set((uint32)CemuStorageIndex::SLC);
+//			storageList[numItems].ukn04 = 0;
+//			storageList[numItems].type = StorageType::WFS;
+			numItems++;
+			return numItems;
+		}
+
+		sint32 GetStorageInfo(StorageInfo* storageInfo, StorageIndex* storageIndex)
+		{
+			cemuLog_logDebug(LogType::Force, "GetStorageInfo() - stub");
+			if(storageIndex->Get() == (uint64)CemuStorageIndex::MLC)
+			{
+				cemu_assert_unimplemented();
+			}
+			else if(storageIndex->Get() == (uint64)CemuStorageIndex::SLC)
+			{
+				cemu_assert_unimplemented();
+			}
+			else
+			{
+				cemu_assert_unimplemented();
+			}
+
+			return 0;
+		}
+
+		sint32 VolumeId_Compare(VolumeId* volumeIdThis, VolumeId* volumeIdOther)
+		{
+			auto r = strncmp(volumeIdThis->id, volumeIdOther->id, 16);
+			cemuLog_logDebug(LogType::Force, "VolumeId_Compare(\"{}\", \"{}\")", volumeIdThis->id, volumeIdOther->id);
+			return (sint32)r;
+		}
+
+		sint32 WaitStateUpdated(uint64be* waitState)
+		{
+			// WaitStateUpdated__Q2_2nn3spmFPUL
+			cemuLog_logDebug(LogType::Force, "WaitStateUpdated() called");
+			*waitState = 1;
+			return 0;
+		}
+
+		void load()
+		{
+			cafeExportRegisterFunc(GetDefaultExtendedStorageVolumeId, "nn_spm", "GetDefaultExtendedStorageVolumeId__Q2_2nn3spmFv", LogType::Placeholder);
+			cafeExportRegisterFunc(GetExtendedStorageIndex, "nn_spm", "GetExtendedStorageIndex__Q2_2nn3spmFPQ3_2nn3spm12StorageIndex", LogType::Placeholder);
+			cafeExportRegisterFunc(GetStorageList, "nn_spm", "GetStorageList__Q2_2nn3spmFPQ3_2nn3spm15StorageListItemUi", LogType::Placeholder);
+
+			cafeExportRegisterFunc(GetStorageInfo, "nn_spm", "GetStorageInfo__Q2_2nn3spmFPQ3_2nn3spm11StorageInfoQ3_2nn3spm12StorageIndex", LogType::Placeholder);
+
+
+
+			cafeExportRegisterFunc(VolumeId_Compare, "nn_spm", "Compare__Q3_2nn3spm8VolumeIdCFRCQ3_2nn3spm8VolumeId", LogType::Placeholder);
+
+			cafeExportRegisterFunc(WaitStateUpdated, "nn_spm", "WaitStateUpdated__Q2_2nn3spmFPUL", LogType::Placeholder);
+		}
+	}
+}
diff --git a/src/Cafe/OS/libs/nn_spm/nn_spm.h b/src/Cafe/OS/libs/nn_spm/nn_spm.h
new file mode 100644
index 00000000..27d7bec9
--- /dev/null
+++ b/src/Cafe/OS/libs/nn_spm/nn_spm.h
@@ -0,0 +1,9 @@
+#pragma once
+
+namespace nn
+{
+	namespace spm
+	{
+		void load();
+	}
+}
\ No newline at end of file
diff --git a/src/Cafe/OS/libs/nn_temp/nn_temp.cpp b/src/Cafe/OS/libs/nn_temp/nn_temp.cpp
index 7ed619ad..aaddabd2 100644
--- a/src/Cafe/OS/libs/nn_temp/nn_temp.cpp
+++ b/src/Cafe/OS/libs/nn_temp/nn_temp.cpp
@@ -6,10 +6,10 @@ namespace nn::temp
 
 	void nnTempExport_TEMPCreateAndInitTempDir(PPCInterpreter_t* hCPU)
 	{
-		forceLogDebug_printf("TEMPCreateAndInitTempDir(...) - placeholder");
+		cemuLog_logDebug(LogType::Force, "TEMPCreateAndInitTempDir(...) - placeholder");
 
 		// create random temp id
-		memory_writeU64Slow(hCPU->gpr[5], tempIdGenerator);
+		memory_writeU64(hCPU->gpr[5], tempIdGenerator);
 		tempIdGenerator = (tempIdGenerator << 3) | (tempIdGenerator >> 61);
 		tempIdGenerator += 0x56e28bd5f4ULL;
 
diff --git a/src/Cafe/OS/libs/nn_uds/nn_uds.cpp b/src/Cafe/OS/libs/nn_uds/nn_uds.cpp
index b28e4b64..08f67c7d 100644
--- a/src/Cafe/OS/libs/nn_uds/nn_uds.cpp
+++ b/src/Cafe/OS/libs/nn_uds/nn_uds.cpp
@@ -21,4 +21,4 @@ void nnUdsExport___sti___11_uds_Api_cpp_f5d9abb2(PPCInterpreter_t* hCPU)
 void nnUds_load()
 {
 	osLib_addFunction("nn_uds", "__sti___11_uds_Api_cpp_f5d9abb2", nnUdsExport___sti___11_uds_Api_cpp_f5d9abb2);
-}
\ No newline at end of file
+}
diff --git a/src/Cafe/OS/libs/nsyshid/AttachDefaultBackends.cpp b/src/Cafe/OS/libs/nsyshid/AttachDefaultBackends.cpp
new file mode 100644
index 00000000..67eb0240
--- /dev/null
+++ b/src/Cafe/OS/libs/nsyshid/AttachDefaultBackends.cpp
@@ -0,0 +1,27 @@
+#include "nsyshid.h"
+#include "Backend.h"
+#include "BackendEmulated.h"
+#include "BackendLibusb.h"
+
+namespace nsyshid::backend
+{
+	void AttachDefaultBackends()
+	{
+		// add libusb backend
+		{
+			auto backendLibusb = std::make_shared<backend::libusb::BackendLibusb>();
+			if (backendLibusb->IsInitialisedOk())
+			{
+				AttachBackend(backendLibusb);
+			}
+		}
+	   // add emulated backend
+		{
+			auto backendEmulated = std::make_shared<backend::emulated::BackendEmulated>();
+			if (backendEmulated->IsInitialisedOk())
+			{
+				AttachBackend(backendEmulated);
+			}
+		}
+	}
+} // namespace nsyshid::backend
diff --git a/src/Cafe/OS/libs/nsyshid/Backend.h b/src/Cafe/OS/libs/nsyshid/Backend.h
new file mode 100644
index 00000000..bfd7a235
--- /dev/null
+++ b/src/Cafe/OS/libs/nsyshid/Backend.h
@@ -0,0 +1,192 @@
+#pragma once
+
+#include <list>
+#include <memory>
+#include <mutex>
+
+#include "Common/precompiled.h"
+
+namespace nsyshid
+{
+	typedef struct
+	{
+		/* +0x00 */ uint32be handle;
+		/* +0x04 */ uint32 ukn04;
+		/* +0x08 */ uint16 vendorId;  // little-endian ?
+		/* +0x0A */ uint16 productId; // little-endian ?
+		/* +0x0C */ uint8 ifIndex;
+		/* +0x0D */ uint8 subClass;
+		/* +0x0E */ uint8 protocol;
+		/* +0x0F */ uint8 paddingGuessed0F;
+		/* +0x10 */ uint16be maxPacketSizeRX;
+		/* +0x12 */ uint16be maxPacketSizeTX;
+	} HID_t;
+
+	struct TransferCommand
+	{
+		uint8* data;
+		uint32 length;
+
+		TransferCommand(uint8* data, uint32 length)
+			: data(data), length(length)
+		{
+		}
+		virtual ~TransferCommand() = default;
+	};
+
+	struct ReadMessage final : TransferCommand
+	{
+		sint32 bytesRead;
+
+		ReadMessage(uint8* data, uint32 length, sint32 bytesRead)
+			: bytesRead(bytesRead), TransferCommand(data, length)
+		{
+		}
+		using TransferCommand::TransferCommand;
+	};
+
+	struct WriteMessage final : TransferCommand
+	{
+		sint32 bytesWritten;
+
+		WriteMessage(uint8* data, uint32 length, sint32 bytesWritten)
+			: bytesWritten(bytesWritten), TransferCommand(data, length)
+		{
+		}
+		using TransferCommand::TransferCommand;
+	};
+
+	struct ReportMessage final : TransferCommand
+	{
+		uint8 reportType;
+		uint8 reportId;
+
+		ReportMessage(uint8 reportType, uint8 reportId, uint8* data, uint32 length)
+			: reportType(reportType), reportId(reportId), TransferCommand(data, length)
+		{
+		}
+		using TransferCommand::TransferCommand;
+	};
+
+	static_assert(offsetof(HID_t, vendorId) == 0x8, "");
+	static_assert(offsetof(HID_t, productId) == 0xA, "");
+	static_assert(offsetof(HID_t, ifIndex) == 0xC, "");
+	static_assert(offsetof(HID_t, protocol) == 0xE, "");
+
+	class Device
+	{
+	  public:
+		Device() = delete;
+
+		Device(uint16 vendorId,
+			   uint16 productId,
+			   uint8 interfaceIndex,
+			   uint8 interfaceSubClass,
+			   uint8 protocol);
+
+		Device(const Device& device) = delete;
+
+		Device& operator=(const Device& device) = delete;
+
+		virtual ~Device() = default;
+
+		HID_t* m_hid; // this info is passed to applications and must remain intact
+
+		uint16 m_vendorId;
+		uint16 m_productId;
+		uint8 m_interfaceIndex;
+		uint8 m_interfaceSubClass;
+		uint8 m_protocol;
+		uint16 m_maxPacketSizeRX;
+		uint16 m_maxPacketSizeTX;
+
+		virtual void AssignHID(HID_t* hid);
+
+		virtual bool Open() = 0;
+
+		virtual void Close() = 0;
+
+		virtual bool IsOpened() = 0;
+
+		enum class ReadResult
+		{
+			Success,
+			Error,
+			ErrorTimeout,
+		};
+
+		virtual ReadResult Read(ReadMessage* message) = 0;
+
+		enum class WriteResult
+		{
+			Success,
+			Error,
+			ErrorTimeout,
+		};
+
+		virtual WriteResult Write(WriteMessage* message) = 0;
+
+		virtual bool GetDescriptor(uint8 descType,
+								   uint8 descIndex,
+								   uint16 lang,
+								   uint8* output,
+								   uint32 outputMaxLength) = 0;
+
+		virtual bool SetIdle(uint8 ifIndex,
+							 uint8 reportId,
+							 uint8 duration) = 0;
+
+		virtual bool SetProtocol(uint8 ifIndex, uint8 protocol) = 0;
+
+		virtual bool SetReport(ReportMessage* message) = 0;
+	};
+
+	class Backend
+	{
+	  public:
+		Backend();
+
+		Backend(const Backend& backend) = delete;
+
+		Backend& operator=(const Backend& backend) = delete;
+
+		virtual ~Backend() = default;
+
+		void DetachAllDevices();
+
+		// called from nsyshid when this backend is attached - do not call this yourself!
+		void OnAttach();
+
+		// called from nsyshid when this backend is detached - do not call this yourself!
+		void OnDetach();
+
+		bool IsBackendAttached();
+
+		virtual bool IsInitialisedOk() = 0;
+
+	  protected:
+		// try to attach a device - only works if this backend is attached
+		bool AttachDevice(const std::shared_ptr<Device>& device);
+
+		void DetachDevice(const std::shared_ptr<Device>& device);
+
+		std::shared_ptr<Device> FindDevice(std::function<bool(const std::shared_ptr<Device>&)> isWantedDevice);
+
+		std::shared_ptr<Device> FindDeviceById(uint16 vendorId, uint16 productId);
+
+		bool IsDeviceWhitelisted(uint16 vendorId, uint16 productId);
+
+		// called from OnAttach() - attach devices that your backend can see here
+		virtual void AttachVisibleDevices() = 0;
+
+	  private:
+		std::list<std::shared_ptr<Device>> m_devices;
+		std::recursive_mutex m_devicesMutex;
+		bool m_isAttached;
+	};
+
+	namespace backend
+	{
+		void AttachDefaultBackends();
+	}
+} // namespace nsyshid
diff --git a/src/Cafe/OS/libs/nsyshid/BackendEmulated.cpp b/src/Cafe/OS/libs/nsyshid/BackendEmulated.cpp
new file mode 100644
index 00000000..a5eb95c1
--- /dev/null
+++ b/src/Cafe/OS/libs/nsyshid/BackendEmulated.cpp
@@ -0,0 +1,54 @@
+#include "BackendEmulated.h"
+
+#include "Dimensions.h"
+#include "Infinity.h"
+#include "Skylander.h"
+#include "config/CemuConfig.h"
+#include "SkylanderXbox360.h"
+
+namespace nsyshid::backend::emulated
+{
+	BackendEmulated::BackendEmulated()
+	{
+		cemuLog_logDebug(LogType::Force, "nsyshid::BackendEmulated: emulated backend initialised");
+	}
+
+	BackendEmulated::~BackendEmulated() = default;
+
+	bool BackendEmulated::IsInitialisedOk()
+	{
+		return true;
+	}
+
+	void BackendEmulated::AttachVisibleDevices()
+	{
+		if (GetConfig().emulated_usb_devices.emulate_skylander_portal && !FindDeviceById(0x1430, 0x0150))
+		{
+			cemuLog_logDebug(LogType::Force, "Attaching Emulated Portal");
+			// Add Skylander Portal
+			auto device = std::make_shared<SkylanderPortalDevice>();
+			AttachDevice(device);
+		}
+		else if (auto usb_portal = FindDeviceById(0x1430, 0x1F17))
+		{
+			cemuLog_logDebug(LogType::Force, "Attaching Xbox 360 Portal");
+			// Add Skylander Xbox 360 Portal
+			auto device = std::make_shared<SkylanderXbox360PortalLibusb>(usb_portal);
+			AttachDevice(device);
+		}
+		if (GetConfig().emulated_usb_devices.emulate_infinity_base && !FindDeviceById(0x0E6F, 0x0129))
+		{
+			cemuLog_logDebug(LogType::Force, "Attaching Emulated Base");
+			// Add Infinity Base
+			auto device = std::make_shared<InfinityBaseDevice>();
+			AttachDevice(device);
+		}
+		if (GetConfig().emulated_usb_devices.emulate_dimensions_toypad && !FindDeviceById(0x0E6F, 0x0241))
+		{
+			cemuLog_logDebug(LogType::Force, "Attaching Emulated Toypad");
+			// Add Dimensions Toypad
+			auto device = std::make_shared<DimensionsToypadDevice>();
+			AttachDevice(device);
+		}
+	}
+} // namespace nsyshid::backend::emulated
\ No newline at end of file
diff --git a/src/Cafe/OS/libs/nsyshid/BackendEmulated.h b/src/Cafe/OS/libs/nsyshid/BackendEmulated.h
new file mode 100644
index 00000000..cf38a8b7
--- /dev/null
+++ b/src/Cafe/OS/libs/nsyshid/BackendEmulated.h
@@ -0,0 +1,16 @@
+#include "nsyshid.h"
+#include "Backend.h"
+
+namespace nsyshid::backend::emulated
+{
+	class BackendEmulated : public nsyshid::Backend {
+	  public:
+		BackendEmulated();
+		~BackendEmulated();
+
+		bool IsInitialisedOk() override;
+
+	  protected:
+		void AttachVisibleDevices() override;
+	};
+} // namespace nsyshid::backend::emulated
diff --git a/src/Cafe/OS/libs/nsyshid/BackendLibusb.cpp b/src/Cafe/OS/libs/nsyshid/BackendLibusb.cpp
new file mode 100644
index 00000000..b5dd0e0f
--- /dev/null
+++ b/src/Cafe/OS/libs/nsyshid/BackendLibusb.cpp
@@ -0,0 +1,906 @@
+#include "BackendLibusb.h"
+
+namespace nsyshid::backend::libusb
+{
+	BackendLibusb::BackendLibusb()
+		: m_ctx(nullptr),
+		  m_initReturnCode(0),
+		  m_callbackRegistered(false),
+		  m_hotplugCallbackHandle(0),
+		  m_hotplugThreadStop(false)
+	{
+		m_initReturnCode = libusb_init(&m_ctx);
+		if (m_initReturnCode < 0)
+		{
+			m_ctx = nullptr;
+			cemuLog_logDebug(LogType::Force, "nsyshid::BackendLibusb: failed to initialize libusb, return code: {}",
+						m_initReturnCode);
+			return;
+		}
+
+		if (libusb_has_capability(LIBUSB_CAP_HAS_HOTPLUG))
+		{
+			int ret = libusb_hotplug_register_callback(m_ctx,
+													   (libusb_hotplug_event)(LIBUSB_HOTPLUG_EVENT_DEVICE_ARRIVED |
+																			  LIBUSB_HOTPLUG_EVENT_DEVICE_LEFT),
+													   (libusb_hotplug_flag)0,
+													   LIBUSB_HOTPLUG_MATCH_ANY,
+													   LIBUSB_HOTPLUG_MATCH_ANY,
+													   LIBUSB_HOTPLUG_MATCH_ANY,
+													   HotplugCallback,
+													   this,
+													   &m_hotplugCallbackHandle);
+			if (ret != LIBUSB_SUCCESS)
+			{
+				cemuLog_logDebug(LogType::Force,
+							"nsyshid::BackendLibusb: failed to register hotplug callback with return code {}",
+							ret);
+			}
+			else
+			{
+				cemuLog_logDebug(LogType::Force, "nsyshid::BackendLibusb: registered hotplug callback");
+				m_callbackRegistered = true;
+				m_hotplugThread = std::thread([this] {
+					while (!m_hotplugThreadStop)
+					{
+						timeval timeout{
+							.tv_sec = 1,
+							.tv_usec = 0,
+						};
+						int ret = libusb_handle_events_timeout_completed(m_ctx, &timeout, nullptr);
+						if (ret != 0)
+						{
+							cemuLog_logDebug(LogType::Force,
+										"nsyshid::BackendLibusb: hotplug thread: error handling events: {}",
+										ret);
+							std::this_thread::sleep_for(std::chrono::milliseconds(1000));
+						}
+					}
+				});
+			}
+		}
+		else
+		{
+			cemuLog_logDebug(LogType::Force, "nsyshid::BackendLibusb: hotplug not supported by this version of libusb");
+		}
+	}
+
+	bool BackendLibusb::IsInitialisedOk()
+	{
+		return m_initReturnCode == 0;
+	}
+
+	void BackendLibusb::AttachVisibleDevices()
+	{
+		// add all currently connected devices
+		libusb_device** devices;
+		ssize_t deviceCount = libusb_get_device_list(m_ctx, &devices);
+		if (deviceCount < 0)
+		{
+			cemuLog_log(LogType::Force, "nsyshid::BackendLibusb: failed to get usb devices");
+			return;
+		}
+		libusb_device* dev;
+		for (int i = 0; (dev = devices[i]) != nullptr; i++)
+		{
+			auto device = CheckAndCreateDevice(dev);
+			if (device != nullptr)
+			{
+				if (IsDeviceWhitelisted(device->m_vendorId, device->m_productId))
+				{
+					if (!AttachDevice(device))
+					{
+						cemuLog_log(LogType::Force,
+									"nsyshid::BackendLibusb: failed to attach device: {:04x}:{:04x}",
+									device->m_vendorId,
+									device->m_productId);
+					}
+				}
+				else
+				{
+					cemuLog_log(LogType::Force,
+								"nsyshid::BackendLibusb: device not on whitelist: {:04x}:{:04x}",
+								device->m_vendorId,
+								device->m_productId);
+				}
+			}
+		}
+
+		libusb_free_device_list(devices, 1);
+	}
+
+	int BackendLibusb::HotplugCallback(libusb_context* ctx,
+									   libusb_device* dev,
+									   libusb_hotplug_event event,
+									   void* user_data)
+	{
+		if (user_data)
+		{
+			BackendLibusb* backend = static_cast<BackendLibusb*>(user_data);
+			return backend->OnHotplug(dev, event);
+		}
+		return 0;
+	}
+
+	int BackendLibusb::OnHotplug(libusb_device* dev, libusb_hotplug_event event)
+	{
+		struct libusb_device_descriptor desc;
+		int ret = libusb_get_device_descriptor(dev, &desc);
+		if (ret < 0)
+		{
+			cemuLog_logDebug(LogType::Force, "nsyshid::BackendLibusb::OnHotplug(): failed to get device descriptor");
+			return 0;
+		}
+
+		switch (event)
+		{
+		case LIBUSB_HOTPLUG_EVENT_DEVICE_ARRIVED:
+		{
+			cemuLog_logDebug(LogType::Force, "nsyshid::BackendLibusb::OnHotplug(): device arrived: {:04x}:{:04x}",
+						desc.idVendor,
+						desc.idProduct);
+			auto device = CheckAndCreateDevice(dev);
+			if (device != nullptr)
+			{
+				if (IsDeviceWhitelisted(device->m_vendorId, device->m_productId))
+				{
+					if (!AttachDevice(device))
+					{
+						cemuLog_log(LogType::Force,
+									"nsyshid::BackendLibusb::OnHotplug(): failed to attach device: {:04x}:{:04x}",
+									device->m_vendorId,
+									device->m_productId);
+					}
+				}
+				else
+				{
+					cemuLog_log(LogType::Force,
+								"nsyshid::BackendLibusb::OnHotplug(): device not on whitelist: {:04x}:{:04x}",
+								device->m_vendorId,
+								device->m_productId);
+				}
+			}
+		}
+		break;
+		case LIBUSB_HOTPLUG_EVENT_DEVICE_LEFT:
+		{
+			cemuLog_logDebug(LogType::Force, "nsyshid::BackendLibusb::OnHotplug(): device left: {:04x}:{:04x}",
+						desc.idVendor,
+						desc.idProduct);
+			auto device = FindLibusbDevice(dev);
+			if (device != nullptr)
+			{
+				DetachDevice(device);
+			}
+		}
+		break;
+		}
+
+		return 0;
+	}
+
+	BackendLibusb::~BackendLibusb()
+	{
+		if (m_callbackRegistered)
+		{
+			m_hotplugThreadStop = true;
+			libusb_hotplug_deregister_callback(m_ctx, m_hotplugCallbackHandle);
+			m_hotplugThread.join();
+		}
+		DetachAllDevices();
+		if (m_ctx)
+		{
+			libusb_exit(m_ctx);
+			m_ctx = nullptr;
+		}
+	}
+
+	std::shared_ptr<Device> BackendLibusb::FindLibusbDevice(libusb_device* dev)
+	{
+		libusb_device_descriptor desc;
+		int ret = libusb_get_device_descriptor(dev, &desc);
+		if (ret < 0)
+		{
+			cemuLog_logDebug(LogType::Force,
+						"nsyshid::BackendLibusb::FindLibusbDevice(): failed to get device descriptor");
+			return nullptr;
+		}
+		uint8 busNumber = libusb_get_bus_number(dev);
+		uint8 deviceAddress = libusb_get_device_address(dev);
+		auto device = FindDevice([desc, busNumber, deviceAddress](const std::shared_ptr<Device>& d) -> bool {
+			auto device = std::dynamic_pointer_cast<DeviceLibusb>(d);
+			if (device != nullptr &&
+				desc.idVendor == device->m_vendorId &&
+				desc.idProduct == device->m_productId &&
+				busNumber == device->m_libusbBusNumber &&
+				deviceAddress == device->m_libusbDeviceAddress)
+			{
+				// we found our device!
+				return true;
+			}
+			return false;
+		});
+
+		if (device != nullptr)
+		{
+			return device;
+		}
+		return nullptr;
+	}
+
+	std::pair<int, ConfigDescriptor> MakeConfigDescriptor(libusb_device* device, uint8 config_num)
+	{
+		libusb_config_descriptor* descriptor = nullptr;
+		const int ret = libusb_get_config_descriptor(device, config_num, &descriptor);
+		if (ret == LIBUSB_SUCCESS)
+			return {ret, ConfigDescriptor{descriptor, libusb_free_config_descriptor}};
+
+		return {ret, ConfigDescriptor{nullptr, [](auto) {
+									  }}};
+	}
+
+	std::shared_ptr<Device> BackendLibusb::CheckAndCreateDevice(libusb_device* dev)
+	{
+		struct libusb_device_descriptor desc;
+		int ret = libusb_get_device_descriptor(dev, &desc);
+		if (ret < 0)
+		{
+			cemuLog_log(LogType::Force,
+						"nsyshid::BackendLibusb::CheckAndCreateDevice(): failed to get device descriptor; return code: %i",
+						ret);
+			return nullptr;
+		}
+		std::vector<ConfigDescriptor> config_descriptors{};
+		for (uint8 i = 0; i < desc.bNumConfigurations; ++i)
+		{
+			auto [ret, config_descriptor] = MakeConfigDescriptor(dev, i);
+			if (ret != LIBUSB_SUCCESS || !config_descriptor)
+			{
+				cemuLog_log(LogType::Force, "Failed to make config descriptor {} for {:04x}:{:04x}: {}",
+							i, desc.idVendor, desc.idProduct, libusb_error_name(ret));
+			}
+			else
+			{
+				config_descriptors.emplace_back(std::move(config_descriptor));
+			}
+		}
+		if (desc.idVendor == 0x0e6f && desc.idProduct == 0x0241)
+		{
+			cemuLog_logDebug(LogType::Force,
+						"nsyshid::BackendLibusb::CheckAndCreateDevice(): lego dimensions portal detected");
+		}
+		auto device = std::make_shared<DeviceLibusb>(m_ctx,
+													 desc.idVendor,
+													 desc.idProduct,
+													 0,
+													 2,
+													 0,
+													 libusb_get_bus_number(dev),
+													 libusb_get_device_address(dev),
+													 std::move(config_descriptors));
+		// figure out device endpoints
+		if (!FindDefaultDeviceEndpoints(dev,
+										device->m_libusbHasEndpointIn,
+										device->m_libusbEndpointIn,
+										device->m_maxPacketSizeRX,
+										device->m_libusbHasEndpointOut,
+										device->m_libusbEndpointOut,
+										device->m_maxPacketSizeTX))
+		{
+			// most likely couldn't read config descriptor
+			cemuLog_log(LogType::Force,
+						"nsyshid::BackendLibusb::CheckAndCreateDevice(): failed to find default endpoints for device: {:04x}:{:04x}",
+						device->m_vendorId,
+						device->m_productId);
+			return nullptr;
+		}
+		return device;
+	}
+
+	bool BackendLibusb::FindDefaultDeviceEndpoints(libusb_device* dev, bool& endpointInFound, uint8& endpointIn,
+												   uint16& endpointInMaxPacketSize, bool& endpointOutFound,
+												   uint8& endpointOut, uint16& endpointOutMaxPacketSize)
+	{
+		endpointInFound = false;
+		endpointIn = 0;
+		endpointInMaxPacketSize = 0;
+		endpointOutFound = false;
+		endpointOut = 0;
+		endpointOutMaxPacketSize = 0;
+
+		struct libusb_config_descriptor* conf = nullptr;
+		int ret = libusb_get_active_config_descriptor(dev, &conf);
+
+		if (ret == 0)
+		{
+			for (uint8 interfaceIndex = 0; interfaceIndex < conf->bNumInterfaces; interfaceIndex++)
+			{
+				const struct libusb_interface& interface = conf->interface[interfaceIndex];
+				for (int altsettingIndex = 0; altsettingIndex < interface.num_altsetting; altsettingIndex++)
+				{
+					const struct libusb_interface_descriptor& altsetting = interface.altsetting[altsettingIndex];
+					for (uint8 endpointIndex = 0; endpointIndex < altsetting.bNumEndpoints; endpointIndex++)
+					{
+						const struct libusb_endpoint_descriptor& endpoint = altsetting.endpoint[endpointIndex];
+						// figure out direction
+						if ((endpoint.bEndpointAddress & (1 << 7)) != 0)
+						{
+							// in
+							if (!endpointInFound)
+							{
+								endpointInFound = true;
+								endpointIn = endpoint.bEndpointAddress;
+								endpointInMaxPacketSize = endpoint.wMaxPacketSize;
+							}
+						}
+						else
+						{
+							// out
+							if (!endpointOutFound)
+							{
+								endpointOutFound = true;
+								endpointOut = endpoint.bEndpointAddress;
+								endpointOutMaxPacketSize = endpoint.wMaxPacketSize;
+							}
+						}
+					}
+				}
+			}
+			libusb_free_config_descriptor(conf);
+			return true;
+		}
+		return false;
+	}
+
+	DeviceLibusb::DeviceLibusb(libusb_context* ctx,
+							   uint16 vendorId,
+							   uint16 productId,
+							   uint8 interfaceIndex,
+							   uint8 interfaceSubClass,
+							   uint8 protocol,
+							   uint8 libusbBusNumber,
+							   uint8 libusbDeviceAddress,
+							   std::vector<ConfigDescriptor> configs)
+		: Device(vendorId,
+				 productId,
+				 interfaceIndex,
+				 interfaceSubClass,
+				 protocol),
+		  m_ctx(ctx),
+		  m_libusbHandle(nullptr),
+		  m_handleInUseCounter(-1),
+		  m_libusbBusNumber(libusbBusNumber),
+		  m_libusbDeviceAddress(libusbDeviceAddress),
+		  m_libusbHasEndpointIn(false),
+		  m_libusbEndpointIn(0),
+		  m_libusbHasEndpointOut(false),
+		  m_libusbEndpointOut(0)
+	{
+		m_config_descriptors = std::move(configs);
+	}
+
+	DeviceLibusb::~DeviceLibusb()
+	{
+		CloseDevice();
+	}
+
+	bool DeviceLibusb::Open()
+	{
+		std::unique_lock<std::mutex> lock(m_handleMutex);
+		if (IsOpened())
+		{
+			return true;
+		}
+		// we may still be in the process of closing the device; wait for that to finish
+		while (m_handleInUseCounter != -1)
+		{
+			m_handleInUseCounterDecremented.wait(lock);
+		}
+
+		libusb_device** devices;
+		ssize_t deviceCount = libusb_get_device_list(m_ctx, &devices);
+		if (deviceCount < 0)
+		{
+			cemuLog_log(LogType::Force, "nsyshid::DeviceLibusb::open(): failed to get usb devices");
+			return false;
+		}
+		libusb_device* dev;
+		libusb_device* found = nullptr;
+		for (int i = 0; (dev = devices[i]) != nullptr; i++)
+		{
+			struct libusb_device_descriptor desc;
+			int ret = libusb_get_device_descriptor(dev, &desc);
+			if (ret < 0)
+			{
+				cemuLog_log(LogType::Force,
+							"nsyshid::DeviceLibusb::open(): failed to get device descriptor, return code: {}",
+							ret);
+				libusb_free_device_list(devices, 1);
+				return false;
+			}
+			if (desc.idVendor == this->m_vendorId &&
+				desc.idProduct == this->m_productId &&
+				libusb_get_bus_number(dev) == this->m_libusbBusNumber &&
+				libusb_get_device_address(dev) == this->m_libusbDeviceAddress)
+			{
+				// we found our device!
+				found = dev;
+				break;
+			}
+		}
+
+		if (found != nullptr)
+		{
+			{
+				int ret = libusb_open(dev, &(this->m_libusbHandle));
+				if (ret < 0)
+				{
+					this->m_libusbHandle = nullptr;
+					cemuLog_log(LogType::Force,
+								"nsyshid::DeviceLibusb::open(): failed to open device: {}",
+								libusb_strerror(ret));
+					libusb_free_device_list(devices, 1);
+					return false;
+				}
+				this->m_handleInUseCounter = 0;
+			}
+
+			int ret = ClaimAllInterfaces(0);
+
+			if (ret != 0)
+			{
+				cemuLog_log(LogType::Force, "nsyshid::DeviceLibusb::open(): cannot claim interface for config 0");
+				return false;
+			}
+		}
+
+		libusb_free_device_list(devices, 1);
+		return found != nullptr;
+	}
+
+	void DeviceLibusb::Close()
+	{
+		CloseDevice();
+	}
+
+	void DeviceLibusb::CloseDevice()
+	{
+		std::unique_lock<std::mutex> lock(m_handleMutex);
+		if (IsOpened())
+		{
+			auto handle = m_libusbHandle;
+			m_libusbHandle = nullptr;
+			while (m_handleInUseCounter > 0)
+			{
+				m_handleInUseCounterDecremented.wait(lock);
+			}
+			ReleaseAllInterfacesForCurrentConfig();
+			libusb_close(handle);
+			m_handleInUseCounter = -1;
+			m_handleInUseCounterDecremented.notify_all();
+		}
+	}
+
+	bool DeviceLibusb::IsOpened()
+	{
+		return m_libusbHandle != nullptr && m_handleInUseCounter >= 0;
+	}
+
+	Device::ReadResult DeviceLibusb::Read(ReadMessage* message)
+	{
+		auto handleLock = AquireHandleLock();
+		if (!handleLock->IsValid())
+		{
+			cemuLog_logDebug(LogType::Force,
+						"nsyshid::DeviceLibusb::read(): cannot read from a non-opened device\n");
+			return ReadResult::Error;
+		}
+
+		for (int i = 0; i < m_config_descriptors.size(); i++)
+		{
+			ClaimAllInterfaces(i);
+		}
+
+		const unsigned int timeout = 50;
+		int actualLength = 0;
+		int ret = 0;
+		do
+		{
+			ret = libusb_interrupt_transfer(handleLock->GetHandle(),
+											this->m_libusbEndpointIn,
+											message->data,
+											message->length,
+											&actualLength,
+											timeout);
+		}
+		while (ret == LIBUSB_ERROR_TIMEOUT && actualLength == 0 && IsOpened());
+
+		if (ret == 0 || ret == LIBUSB_ERROR_TIMEOUT)
+		{
+			// success
+			cemuLog_logDebug(LogType::Force, "nsyshid::DeviceLibusb::read(): read {} of {} bytes",
+							 actualLength,
+							 message->length);
+			message->bytesRead = actualLength;
+			return ReadResult::Success;
+		}
+		cemuLog_logDebug(LogType::Force,
+					"nsyshid::DeviceLibusb::read(): failed at endpoint 0x{:02x} with error message: {}", this->m_libusbEndpointIn,
+					libusb_error_name(ret));
+		return ReadResult::Error;
+	}
+
+	Device::WriteResult DeviceLibusb::Write(WriteMessage* message)
+	{
+		auto handleLock = AquireHandleLock();
+		if (!handleLock->IsValid())
+		{
+			cemuLog_logDebug(LogType::Force,
+						"nsyshid::DeviceLibusb::write(): cannot write to a non-opened device\n");
+			return WriteResult::Error;
+		}
+
+		for (int i = 0; i < m_config_descriptors.size(); i++)
+		{
+			ClaimAllInterfaces(i);
+		}
+
+		message->bytesWritten = 0;
+		int actualLength = 0;
+		int ret = libusb_interrupt_transfer(handleLock->GetHandle(),
+											this->m_libusbEndpointOut,
+											message->data,
+											message->length,
+											&actualLength,
+											0);
+
+		if (ret == 0)
+		{
+			// success
+			message->bytesWritten = actualLength;
+			cemuLog_logDebug(LogType::Force,
+							 "nsyshid::DeviceLibusb::write(): wrote {} of {} bytes",
+							 message->bytesWritten,
+							 message->length);
+			return WriteResult::Success;
+		}
+		cemuLog_logDebug(LogType::Force,
+					"nsyshid::DeviceLibusb::write(): failed with error code: {}",
+					ret);
+		return WriteResult::Error;
+	}
+
+	bool DeviceLibusb::GetDescriptor(uint8 descType,
+									 uint8 descIndex,
+									 uint16 lang,
+									 uint8* output,
+									 uint32 outputMaxLength)
+	{
+		auto handleLock = AquireHandleLock();
+		if (!handleLock->IsValid())
+		{
+			cemuLog_logDebug(LogType::Force, "nsyshid::DeviceLibusb::getDescriptor(): device is not opened");
+			return false;
+		}
+
+		if (descType == 0x02)
+		{
+			struct libusb_config_descriptor* conf = nullptr;
+			libusb_device* dev = libusb_get_device(handleLock->GetHandle());
+			int ret = libusb_get_active_config_descriptor(dev, &conf);
+			if (ret == 0)
+			{
+				std::vector<uint8> configurationDescriptor(conf->wTotalLength);
+				uint8* currentWritePtr = &configurationDescriptor[0];
+
+				// configuration descriptor
+				cemu_assert_debug(conf->bLength == LIBUSB_DT_CONFIG_SIZE);
+				*(uint8*)(currentWritePtr + 0) = conf->bLength;				// bLength
+				*(uint8*)(currentWritePtr + 1) = conf->bDescriptorType;		// bDescriptorType
+				*(uint16be*)(currentWritePtr + 2) = conf->wTotalLength;		// wTotalLength
+				*(uint8*)(currentWritePtr + 4) = conf->bNumInterfaces;		// bNumInterfaces
+				*(uint8*)(currentWritePtr + 5) = conf->bConfigurationValue; // bConfigurationValue
+				*(uint8*)(currentWritePtr + 6) = conf->iConfiguration;		// iConfiguration
+				*(uint8*)(currentWritePtr + 7) = conf->bmAttributes;		// bmAttributes
+				*(uint8*)(currentWritePtr + 8) = conf->MaxPower;			// MaxPower
+				currentWritePtr = currentWritePtr + conf->bLength;
+
+				for (uint8_t interfaceIndex = 0; interfaceIndex < conf->bNumInterfaces; interfaceIndex++)
+				{
+					const struct libusb_interface& interface = conf->interface[interfaceIndex];
+					for (int altsettingIndex = 0; altsettingIndex < interface.num_altsetting; altsettingIndex++)
+					{
+						// interface descriptor
+						const struct libusb_interface_descriptor& altsetting = interface.altsetting[altsettingIndex];
+						cemu_assert_debug(altsetting.bLength == LIBUSB_DT_INTERFACE_SIZE);
+						*(uint8*)(currentWritePtr + 0) = altsetting.bLength;			// bLength
+						*(uint8*)(currentWritePtr + 1) = altsetting.bDescriptorType;	// bDescriptorType
+						*(uint8*)(currentWritePtr + 2) = altsetting.bInterfaceNumber;	// bInterfaceNumber
+						*(uint8*)(currentWritePtr + 3) = altsetting.bAlternateSetting;	// bAlternateSetting
+						*(uint8*)(currentWritePtr + 4) = altsetting.bNumEndpoints;		// bNumEndpoints
+						*(uint8*)(currentWritePtr + 5) = altsetting.bInterfaceClass;	// bInterfaceClass
+						*(uint8*)(currentWritePtr + 6) = altsetting.bInterfaceSubClass; // bInterfaceSubClass
+						*(uint8*)(currentWritePtr + 7) = altsetting.bInterfaceProtocol; // bInterfaceProtocol
+						*(uint8*)(currentWritePtr + 8) = altsetting.iInterface;			// iInterface
+						currentWritePtr = currentWritePtr + altsetting.bLength;
+
+						if (altsetting.extra_length > 0)
+						{
+							// unknown descriptors - copy the ones that we can identify ourselves
+							const unsigned char* extraReadPointer = altsetting.extra;
+							while (extraReadPointer - altsetting.extra < altsetting.extra_length)
+							{
+								uint8 bLength = *(uint8*)(extraReadPointer + 0);
+								if (bLength == 0)
+								{
+									// prevent endless loop
+									break;
+								}
+								if (extraReadPointer + bLength - altsetting.extra > altsetting.extra_length)
+								{
+									// prevent out of bounds read
+									break;
+								}
+								uint8 bDescriptorType = *(uint8*)(extraReadPointer + 1);
+								// HID descriptor
+								if (bDescriptorType == LIBUSB_DT_HID && bLength == 9)
+								{
+									*(uint8*)(currentWritePtr + 0) =
+										*(uint8*)(extraReadPointer + 0); // bLength
+									*(uint8*)(currentWritePtr + 1) =
+										*(uint8*)(extraReadPointer + 1); // bDescriptorType
+									*(uint16be*)(currentWritePtr + 2) =
+										*(uint16*)(extraReadPointer + 2); // bcdHID
+									*(uint8*)(currentWritePtr + 4) =
+										*(uint8*)(extraReadPointer + 4); // bCountryCode
+									*(uint8*)(currentWritePtr + 5) =
+										*(uint8*)(extraReadPointer + 5); // bNumDescriptors
+									*(uint8*)(currentWritePtr + 6) =
+										*(uint8*)(extraReadPointer + 6); // bDescriptorType
+									*(uint16be*)(currentWritePtr + 7) =
+										*(uint16*)(extraReadPointer + 7); // wDescriptorLength
+									currentWritePtr += bLength;
+								}
+								extraReadPointer += bLength;
+							}
+						}
+						for (int endpointIndex = 0; endpointIndex < altsetting.bNumEndpoints; endpointIndex++)
+						{
+							// endpoint descriptor
+							const struct libusb_endpoint_descriptor& endpoint = altsetting.endpoint[endpointIndex];
+							cemu_assert_debug(endpoint.bLength == LIBUSB_DT_ENDPOINT_SIZE ||
+											  endpoint.bLength == LIBUSB_DT_ENDPOINT_AUDIO_SIZE);
+							*(uint8*)(currentWritePtr + 0) = endpoint.bLength;
+							*(uint8*)(currentWritePtr + 1) = endpoint.bDescriptorType;
+							*(uint8*)(currentWritePtr + 2) = endpoint.bEndpointAddress;
+							*(uint8*)(currentWritePtr + 3) = endpoint.bmAttributes;
+							*(uint16be*)(currentWritePtr + 4) = endpoint.wMaxPacketSize;
+							*(uint8*)(currentWritePtr + 6) = endpoint.bInterval;
+							if (endpoint.bLength == LIBUSB_DT_ENDPOINT_AUDIO_SIZE)
+							{
+								*(uint8*)(currentWritePtr + 7) = endpoint.bRefresh;
+								*(uint8*)(currentWritePtr + 8) = endpoint.bSynchAddress;
+							}
+							currentWritePtr += endpoint.bLength;
+						}
+					}
+				}
+				uint32 bytesWritten = currentWritePtr - &configurationDescriptor[0];
+				libusb_free_config_descriptor(conf);
+				cemu_assert_debug(bytesWritten <= conf->wTotalLength);
+				memcpy(output, &configurationDescriptor[0],
+					   std::min<uint32>(outputMaxLength, bytesWritten));
+				return true;
+			}
+		}
+		else
+		{
+			uint16 wValue = uint16(descType) << 8 | uint16(descIndex);
+			// HID Get_Descriptor requests are handled via libusb_control_transfer
+			int ret = libusb_control_transfer(handleLock->GetHandle(),
+											  LIBUSB_REQUEST_TYPE_STANDARD | LIBUSB_ENDPOINT_IN,
+											  LIBUSB_REQUEST_GET_DESCRIPTOR,
+											  wValue,
+											  lang,
+											  output,
+											  outputMaxLength,
+											  0);
+			if (ret != outputMaxLength)
+			{
+				cemuLog_logDebug(LogType::Force, "nsyshid::DeviceLibusb::GetDescriptor(): Control Transfer Failed: {}", libusb_error_name(ret));
+				return false;
+			}
+		}
+		return true;
+	}
+
+	bool DeviceLibusb::SetIdle(uint8 ifIndex,
+							   uint8 reportId,
+							   uint8 duration)
+	{
+		auto handleLock = AquireHandleLock();
+		if (!handleLock->IsValid())
+		{
+			cemuLog_log(LogType::Force, "nsyshid::DeviceLibusb::SetIdle(): device is not opened");
+			return false;
+		}
+
+		uint16 wValue = uint16(duration) << 8 | uint16(reportId);
+
+		// HID Set_Idle requests are handled via libusb_control_transfer
+		int ret = libusb_control_transfer(handleLock->GetHandle(),
+										  LIBUSB_REQUEST_TYPE_CLASS | LIBUSB_RECIPIENT_INTERFACE | LIBUSB_ENDPOINT_OUT,
+										  HID_CLASS_SET_IDLE, // Defined in HID Class Specific Requests (7.2)
+										  wValue,
+										  ifIndex,
+										  nullptr,
+										  0,
+										  0);
+
+		if (ret != 0)
+		{
+			cemuLog_logDebug(LogType::Force, "nsyshid::DeviceLibusb::SetIdle(): Control Transfer Failed: {}", libusb_error_name(ret));
+			return false;
+		}
+		return true;
+	}
+
+	template<typename Configs, typename Function>
+	static int DoForEachInterface(const Configs& configs, uint8 config_num, Function action)
+	{
+		int ret = LIBUSB_ERROR_NOT_FOUND;
+		if (configs.size() <= config_num || !configs[config_num])
+			return ret;
+		for (uint8 i = 0; i < configs[config_num]->bNumInterfaces; ++i)
+		{
+			ret = action(i);
+			if (ret < LIBUSB_SUCCESS)
+				break;
+		}
+		return ret;
+	}
+
+	int DeviceLibusb::ClaimAllInterfaces(uint8 config_num)
+	{
+		const int ret = DoForEachInterface(m_config_descriptors, config_num, [this](uint8 i) {
+			if (libusb_kernel_driver_active(this->m_libusbHandle, i))
+			{
+				const int ret2 = libusb_detach_kernel_driver(this->m_libusbHandle, i);
+				if (ret2 < LIBUSB_SUCCESS && ret2 != LIBUSB_ERROR_NOT_FOUND &&
+					ret2 != LIBUSB_ERROR_NOT_SUPPORTED)
+				{
+					cemuLog_log(LogType::Force, "Failed to detach kernel driver {}", libusb_error_name(ret2));
+					return ret2;
+				}
+			}
+			return libusb_claim_interface(this->m_libusbHandle, i);
+		});
+		if (ret < LIBUSB_SUCCESS)
+		{
+			cemuLog_log(LogType::Force, "Failed to release all interfaces for config {}", config_num);
+		}
+		return ret;
+	}
+
+	int DeviceLibusb::ReleaseAllInterfaces(uint8 config_num)
+	{
+		const int ret = DoForEachInterface(m_config_descriptors, config_num, [this](uint8 i) {
+			return libusb_release_interface(AquireHandleLock()->GetHandle(), i);
+		});
+		if (ret < LIBUSB_SUCCESS && ret != LIBUSB_ERROR_NO_DEVICE && ret != LIBUSB_ERROR_NOT_FOUND)
+		{
+			cemuLog_log(LogType::Force, "Failed to release all interfaces for config {}", config_num);
+		}
+		return ret;
+	}
+
+	int DeviceLibusb::ReleaseAllInterfacesForCurrentConfig()
+	{
+		int config_num;
+		const int get_config_ret = libusb_get_configuration(AquireHandleLock()->GetHandle(), &config_num);
+		if (get_config_ret < LIBUSB_SUCCESS)
+			return get_config_ret;
+		return ReleaseAllInterfaces(config_num);
+	}
+
+	bool DeviceLibusb::SetProtocol(uint8 ifIndex, uint8 protocol)
+	{
+		auto handleLock = AquireHandleLock();
+		if (!handleLock->IsValid())
+		{
+			cemuLog_logDebug(LogType::Force, "nsyshid::DeviceLibusb::SetProtocol(): device is not opened");
+			return false;
+		}
+
+		int ret = libusb_control_transfer(handleLock->GetHandle(),
+										  LIBUSB_REQUEST_TYPE_CLASS | LIBUSB_RECIPIENT_INTERFACE | LIBUSB_ENDPOINT_OUT,
+										  HID_CLASS_SET_PROTOCOL, // Defined in HID Class Specific Requests (7.2)
+										  protocol,
+										  ifIndex,
+										  nullptr,
+										  0,
+										  0);
+
+		if (ret != 0)
+		{
+			cemuLog_logDebug(LogType::Force, "nsyshid::DeviceLibusb::SetProtocol(): Control Transfer Failed: {}", libusb_error_name(ret));
+			return false;
+		}
+		return true;
+	}
+
+	bool DeviceLibusb::SetReport(ReportMessage* message)
+	{
+		auto handleLock = AquireHandleLock();
+		if (!handleLock->IsValid())
+		{
+			cemuLog_logDebug(LogType::Force, "nsyshid::DeviceLibusb::SetReport(): device is not opened");
+			return false;
+		}
+
+		uint16 wValue = uint16(message->reportType) << 8 | uint16(message->reportId);
+
+		int ret = libusb_control_transfer(handleLock->GetHandle(),
+										  LIBUSB_REQUEST_TYPE_CLASS | LIBUSB_RECIPIENT_INTERFACE | LIBUSB_ENDPOINT_OUT,
+										  HID_CLASS_SET_REPORT, // Defined in HID Class Specific Requests (7.2)
+										  wValue,
+										  m_interfaceIndex,
+										  message->data,
+										  uint16(message->length & 0xFFFF),
+										  0);
+
+		if (ret != message->length)
+		{
+			cemuLog_logDebug(LogType::Force, "nsyshid::DeviceLibusb::SetReport(): Control Transfer Failed at interface {} : {}", m_interfaceIndex, libusb_error_name(ret));
+			return false;
+		}
+		return true;
+	}
+
+	std::unique_ptr<DeviceLibusb::HandleLock> DeviceLibusb::AquireHandleLock()
+	{
+		return std::make_unique<HandleLock>(&m_libusbHandle,
+											m_handleMutex,
+											m_handleInUseCounter,
+											m_handleInUseCounterDecremented,
+											*this);
+	}
+
+	DeviceLibusb::HandleLock::HandleLock(libusb_device_handle** handle,
+										 std::mutex& handleMutex,
+										 std::atomic<sint32>& handleInUseCounter,
+										 std::condition_variable& handleInUseCounterDecremented,
+										 DeviceLibusb& device)
+		: m_handle(nullptr),
+		  m_handleMutex(handleMutex),
+		  m_handleInUseCounter(handleInUseCounter),
+		  m_handleInUseCounterDecremented(handleInUseCounterDecremented)
+	{
+		std::lock_guard<std::mutex> lock(handleMutex);
+		if (device.IsOpened() && handle != nullptr && handleInUseCounter >= 0)
+		{
+			this->m_handle = *handle;
+			this->m_handleInUseCounter++;
+		}
+	}
+
+	DeviceLibusb::HandleLock::~HandleLock()
+	{
+		if (IsValid())
+		{
+			std::lock_guard<std::mutex> lock(m_handleMutex);
+			m_handleInUseCounter--;
+			m_handleInUseCounterDecremented.notify_all();
+		}
+	}
+
+	bool DeviceLibusb::HandleLock::IsValid()
+	{
+		return m_handle != nullptr;
+	}
+
+	libusb_device_handle* DeviceLibusb::HandleLock::GetHandle()
+	{
+		return m_handle;
+	}
+} // namespace nsyshid::backend::libusb
diff --git a/src/Cafe/OS/libs/nsyshid/BackendLibusb.h b/src/Cafe/OS/libs/nsyshid/BackendLibusb.h
new file mode 100644
index 00000000..6b2d8e1a
--- /dev/null
+++ b/src/Cafe/OS/libs/nsyshid/BackendLibusb.h
@@ -0,0 +1,145 @@
+#include "nsyshid.h"
+
+#include <libusb-1.0/libusb.h>
+#include "Backend.h"
+
+namespace nsyshid::backend::libusb
+{
+	enum : uint8
+	{
+		HID_CLASS_GET_REPORT   = 0x01,
+		HID_CLASS_GET_IDLE     = 0x02,
+		HID_CLASS_GET_PROTOCOL = 0x03,
+		HID_CLASS_SET_REPORT   = 0x09,
+		HID_CLASS_SET_IDLE     = 0x0A,
+		HID_CLASS_SET_PROTOCOL = 0x0B
+	};
+
+	class BackendLibusb : public nsyshid::Backend {
+	  public:
+		BackendLibusb();
+
+		~BackendLibusb();
+
+		bool IsInitialisedOk() override;
+
+	  protected:
+		void AttachVisibleDevices() override;
+
+	  private:
+		libusb_context* m_ctx;
+		int m_initReturnCode;
+		bool m_callbackRegistered;
+		libusb_hotplug_callback_handle m_hotplugCallbackHandle;
+		std::thread m_hotplugThread;
+		std::atomic<bool> m_hotplugThreadStop;
+
+		// called by libusb
+		static int HotplugCallback(libusb_context* ctx, libusb_device* dev,
+								   libusb_hotplug_event event, void* user_data);
+
+		int OnHotplug(libusb_device* dev, libusb_hotplug_event event);
+
+		std::shared_ptr<Device> CheckAndCreateDevice(libusb_device* dev);
+
+		std::shared_ptr<Device> FindLibusbDevice(libusb_device* dev);
+
+		bool FindDefaultDeviceEndpoints(libusb_device* dev,
+										bool& endpointInFound, uint8& endpointIn, uint16& endpointInMaxPacketSize,
+										bool& endpointOutFound, uint8& endpointOut, uint16& endpointOutMaxPacketSize);
+	};
+
+	template<typename T>
+	using UniquePtr = std::unique_ptr<T, void (*)(T*)>;
+
+	using ConfigDescriptor = UniquePtr<libusb_config_descriptor>;
+
+	class DeviceLibusb : public nsyshid::Device {
+	  public:
+		DeviceLibusb(libusb_context* ctx,
+					 uint16 vendorId,
+					 uint16 productId,
+					 uint8 interfaceIndex,
+					 uint8 interfaceSubClass,
+					 uint8 protocol,
+					 uint8 libusbBusNumber,
+					 uint8 libusbDeviceAddress,
+					 std::vector<ConfigDescriptor> configs);
+
+		~DeviceLibusb() override;
+
+		bool Open() override;
+
+		void Close() override;
+
+		bool IsOpened() override;
+
+		ReadResult Read(ReadMessage* message) override;
+
+		WriteResult Write(WriteMessage* message) override;
+
+		bool GetDescriptor(uint8 descType,
+						   uint8 descIndex,
+						   uint16 lang,
+						   uint8* output,
+						   uint32 outputMaxLength) override;
+
+		bool SetIdle(uint8 ifIndex,
+					 uint8 reportId,
+					 uint8 duration) override;
+
+		bool SetProtocol(uint8 ifIndex, uint8 protocol) override;
+
+		int ClaimAllInterfaces(uint8 config_num);
+		int ReleaseAllInterfaces(uint8 config_num);
+		int ReleaseAllInterfacesForCurrentConfig();
+
+		bool SetReport(ReportMessage* message) override;
+
+		uint8 m_libusbBusNumber;
+		uint8 m_libusbDeviceAddress;
+		bool m_libusbHasEndpointIn;
+		uint8 m_libusbEndpointIn;
+		bool m_libusbHasEndpointOut;
+		uint8 m_libusbEndpointOut;
+
+	  private:
+		void CloseDevice();
+
+		libusb_context* m_ctx;
+		std::mutex m_handleMutex;
+		std::atomic<sint32> m_handleInUseCounter;
+		std::condition_variable m_handleInUseCounterDecremented;
+		libusb_device_handle* m_libusbHandle;
+		std::vector<ConfigDescriptor> m_config_descriptors;
+
+		class HandleLock {
+		  public:
+			HandleLock() = delete;
+
+			HandleLock(libusb_device_handle** handle,
+					   std::mutex& handleMutex,
+					   std::atomic<sint32>& handleInUseCounter,
+					   std::condition_variable& handleInUseCounterDecremented,
+					   DeviceLibusb& device);
+
+			~HandleLock();
+
+			HandleLock(const HandleLock&) = delete;
+
+			HandleLock& operator=(const HandleLock&) = delete;
+
+			bool IsValid();
+
+			libusb_device_handle* GetHandle();
+
+		  private:
+			libusb_device_handle* m_handle;
+			std::mutex& m_handleMutex;
+			std::atomic<sint32>& m_handleInUseCounter;
+			std::condition_variable& m_handleInUseCounterDecremented;
+		};
+
+		std::unique_ptr<HandleLock> AquireHandleLock();
+	};
+} // namespace nsyshid::backend::libusb
diff --git a/src/Cafe/OS/libs/nsyshid/Dimensions.cpp b/src/Cafe/OS/libs/nsyshid/Dimensions.cpp
new file mode 100644
index 00000000..b23560f1
--- /dev/null
+++ b/src/Cafe/OS/libs/nsyshid/Dimensions.cpp
@@ -0,0 +1,1170 @@
+#include "Dimensions.h"
+
+#include "nsyshid.h"
+#include "Backend.h"
+
+#include "Common/FileStream.h"
+
+#include <array>
+#include <random>
+
+namespace nsyshid
+{
+	static constexpr std::array<uint8, 16> COMMAND_KEY = {0x55, 0xFE, 0xF6, 0xB0, 0x62, 0xBF, 0x0B, 0x41,
+														  0xC9, 0xB3, 0x7C, 0xB4, 0x97, 0x3E, 0x29, 0x7B};
+
+	static constexpr std::array<uint8, 17> CHAR_CONSTANT = {0xB7, 0xD5, 0xD7, 0xE6, 0xE7, 0xBA, 0x3C, 0xA8,
+															0xD8, 0x75, 0x47, 0x68, 0xCF, 0x23, 0xE9, 0xFE, 0xAA};
+
+	static constexpr std::array<uint8, 25> PWD_CONSTANT = {0x28, 0x63, 0x29, 0x20, 0x43, 0x6F, 0x70, 0x79,
+														   0x72, 0x69, 0x67, 0x68, 0x74, 0x20, 0x4C, 0x45,
+														   0x47, 0x4F, 0x20, 0x32, 0x30, 0x31, 0x34, 0xAA, 0xAA};
+
+	DimensionsUSB g_dimensionstoypad;
+
+	const std::map<const uint32, const char*> s_listMinis = {
+		{0, "Blank Tag"},
+		{1, "Batman"},
+		{2, "Gandalf"},
+		{3, "Wyldstyle"},
+		{4, "Aquaman"},
+		{5, "Bad Cop"},
+		{6, "Bane"},
+		{7, "Bart Simpson"},
+		{8, "Benny"},
+		{9, "Chell"},
+		{10, "Cole"},
+		{11, "Cragger"},
+		{12, "Cyborg"},
+		{13, "Cyberman"},
+		{14, "Doc Brown"},
+		{15, "The Doctor"},
+		{16, "Emmet"},
+		{17, "Eris"},
+		{18, "Gimli"},
+		{19, "Gollum"},
+		{20, "Harley Quinn"},
+		{21, "Homer Simpson"},
+		{22, "Jay"},
+		{23, "Joker"},
+		{24, "Kai"},
+		{25, "ACU Trooper"},
+		{26, "Gamer Kid"},
+		{27, "Krusty the Clown"},
+		{28, "Laval"},
+		{29, "Legolas"},
+		{30, "Lloyd"},
+		{31, "Marty McFly"},
+		{32, "Nya"},
+		{33, "Owen Grady"},
+		{34, "Peter Venkman"},
+		{35, "Slimer"},
+		{36, "Scooby-Doo"},
+		{37, "Sensei Wu"},
+		{38, "Shaggy"},
+		{39, "Stay Puft"},
+		{40, "Superman"},
+		{41, "Unikitty"},
+		{42, "Wicked Witch of the West"},
+		{43, "Wonder Woman"},
+		{44, "Zane"},
+		{45, "Green Arrow"},
+		{46, "Supergirl"},
+		{47, "Abby Yates"},
+		{48, "Finn the Human"},
+		{49, "Ethan Hunt"},
+		{50, "Lumpy Space Princess"},
+		{51, "Jake the Dog"},
+		{52, "Harry Potter"},
+		{53, "Lord Voldemort"},
+		{54, "Michael Knight"},
+		{55, "B.A. Baracus"},
+		{56, "Newt Scamander"},
+		{57, "Sonic the Hedgehog"},
+		{58, "Future Update (unreleased)"},
+		{59, "Gizmo"},
+		{60, "Stripe"},
+		{61, "E.T."},
+		{62, "Tina Goldstein"},
+		{63, "Marceline the Vampire Queen"},
+		{64, "Batgirl"},
+		{65, "Robin"},
+		{66, "Sloth"},
+		{67, "Hermione Granger"},
+		{68, "Chase McCain"},
+		{69, "Excalibur Batman"},
+		{70, "Raven"},
+		{71, "Beast Boy"},
+		{72, "Betelgeuse"},
+		{73, "Lord Vortech (unreleased)"},
+		{74, "Blossom"},
+		{75, "Bubbles"},
+		{76, "Buttercup"},
+		{77, "Starfire"},
+		{78, "World 15 (unreleased)"},
+		{79, "World 16 (unreleased)"},
+		{80, "World 17 (unreleased)"},
+		{81, "World 18 (unreleased)"},
+		{82, "World 19 (unreleased)"},
+		{83, "World 20 (unreleased)"},
+		{768, "Unknown 768"},
+		{769, "Supergirl Red Lantern"},
+		{770, "Unknown 770"}};
+
+	const std::map<const uint32, const char*> s_listTokens = {
+		{1000, "Police Car"},
+		{1001, "Aerial Squad Car"},
+		{1002, "Missile Striker"},
+		{1003, "Gravity Sprinter"},
+		{1004, "Street Shredder"},
+		{1005, "Sky Clobberer"},
+		{1006, "Batmobile"},
+		{1007, "Batblaster"},
+		{1008, "Sonic Batray"},
+		{1009, "Benny's Spaceship"},
+		{1010, "Lasercraft"},
+		{1011, "The Annihilator"},
+		{1012, "DeLorean Time Machine"},
+		{1013, "Electric Time Machine"},
+		{1014, "Ultra Time Machine"},
+		{1015, "Hoverboard"},
+		{1016, "Cyclone Board"},
+		{1017, "Ultimate Hoverjet"},
+		{1018, "Eagle Interceptor"},
+		{1019, "Eagle Sky Blazer"},
+		{1020, "Eagle Swoop Diver"},
+		{1021, "Swamp Skimmer"},
+		{1022, "Cragger's Fireship"},
+		{1023, "Croc Command Sub"},
+		{1024, "Cyber-Guard"},
+		{1025, "Cyber-Wrecker"},
+		{1026, "Laser Robot Walker"},
+		{1027, "K-9"},
+		{1028, "K-9 Ruff Rover"},
+		{1029, "K-9 Laser Cutter"},
+		{1030, "TARDIS"},
+		{1031, "Laser-Pulse TARDIS"},
+		{1032, "Energy-Burst TARDIS"},
+		{1033, "Emmet's Excavator"},
+		{1034, "Destroy Dozer"},
+		{1035, "Destruct-o-Mech"},
+		{1036, "Winged Monkey"},
+		{1037, "Battle Monkey"},
+		{1038, "Commander Monkey"},
+		{1039, "Axe Chariot"},
+		{1040, "Axe Hurler"},
+		{1041, "Soaring Chariot"},
+		{1042, "Shelob the Great"},
+		{1043, "8-Legged Stalker"},
+		{1044, "Poison Slinger"},
+		{1045, "Homer's Car"},
+		{1047, "The SubmaHomer"},
+		{1046, "The Homercraft"},
+		{1048, "Taunt-o-Vision"},
+		{1050, "The MechaHomer"},
+		{1049, "Blast Cam"},
+		{1051, "Velociraptor"},
+		{1053, "Venom Raptor"},
+		{1052, "Spike Attack Raptor"},
+		{1054, "Gyrosphere"},
+		{1055, "Sonic Beam Gyrosphere"},
+		{1056, " Gyrosphere"},
+		{1057, "Clown Bike"},
+		{1058, "Cannon Bike"},
+		{1059, "Anti-Gravity Rocket Bike"},
+		{1060, "Mighty Lion Rider"},
+		{1061, "Lion Blazer"},
+		{1062, "Fire Lion"},
+		{1063, "Arrow Launcher"},
+		{1064, "Seeking Shooter"},
+		{1065, "Triple Ballista"},
+		{1066, "Mystery Machine"},
+		{1067, "Mystery Tow & Go"},
+		{1068, "Mystery Monster"},
+		{1069, "Boulder Bomber"},
+		{1070, "Boulder Blaster"},
+		{1071, "Cyclone Jet"},
+		{1072, "Storm Fighter"},
+		{1073, "Lightning Jet"},
+		{1074, "Electro-Shooter"},
+		{1075, "Blade Bike"},
+		{1076, "Flight Fire Bike"},
+		{1077, "Blades of Fire"},
+		{1078, "Samurai Mech"},
+		{1079, "Samurai Shooter"},
+		{1080, "Soaring Samurai Mech"},
+		{1081, "Companion Cube"},
+		{1082, "Laser Deflector"},
+		{1083, "Gold Heart Emitter"},
+		{1084, "Sentry Turret"},
+		{1085, "Turret Striker"},
+		{1086, "Flight Turret Carrier"},
+		{1087, "Scooby Snack"},
+		{1088, "Scooby Fire Snack"},
+		{1089, "Scooby Ghost Snack"},
+		{1090, "Cloud Cuckoo Car"},
+		{1091, "X-Stream Soaker"},
+		{1092, "Rainbow Cannon"},
+		{1093, "Invisible Jet"},
+		{1094, "Laser Shooter"},
+		{1095, "Torpedo Bomber"},
+		{1096, "NinjaCopter"},
+		{1097, "Glaciator"},
+		{1098, "Freeze Fighter"},
+		{1099, "Travelling Time Train"},
+		{1100, "Flight Time Train"},
+		{1101, "Missile Blast Time Train"},
+		{1102, "Aqua Watercraft"},
+		{1103, "Seven Seas Speeder"},
+		{1104, "Trident of Fire"},
+		{1105, "Drill Driver"},
+		{1106, "Bane Dig 'n' Drill"},
+		{1107, "Bane Drill 'n' Blast"},
+		{1108, "Quinn Mobile"},
+		{1109, "Quinn Ultra Racer"},
+		{1110, "Missile Launcher"},
+		{1111, "The Joker's Chopper"},
+		{1112, "Mischievous Missile Blaster"},
+		{1113, "Lock 'n' Laser Jet"},
+		{1114, "Hover Pod"},
+		{1115, "Krypton Striker"},
+		{1116, "Super Stealth Pod"},
+		{1117, "Dalek"},
+		{1118, "Fire 'n' Ride Dalek"},
+		{1119, "Silver Shooter Dalek"},
+		{1120, "Ecto-1"},
+		{1121, "Ecto-1 Blaster"},
+		{1122, "Ecto-1 Water Diver"},
+		{1123, "Ghost Trap"},
+		{1124, "Ghost Stun 'n' Trap"},
+		{1125, "Proton Zapper"},
+		{1126, "Unknown"},
+		{1127, "Unknown"},
+		{1128, "Unknown"},
+		{1129, "Unknown"},
+		{1130, "Unknown"},
+		{1131, "Unknown"},
+		{1132, "Lloyd's Golden Dragon"},
+		{1133, "Sword Projector Dragon"},
+		{1134, "Unknown"},
+		{1135, "Unknown"},
+		{1136, "Unknown"},
+		{1137, "Unknown"},
+		{1138, "Unknown"},
+		{1139, "Unknown"},
+		{1140, "Unknown"},
+		{1141, "Unknown"},
+		{1142, "Unknown"},
+		{1143, "Unknown"},
+		{1144, "Mega Flight Dragon"},
+		{1145, "Unknown"},
+		{1146, "Unknown"},
+		{1147, "Unknown"},
+		{1148, "Unknown"},
+		{1149, "Unknown"},
+		{1150, "Unknown"},
+		{1151, "Unknown"},
+		{1152, "Unknown"},
+		{1153, "Unknown"},
+		{1154, "Unknown"},
+		{1155, "Flying White Dragon"},
+		{1156, "Golden Fire Dragon"},
+		{1157, "Ultra Destruction Dragon"},
+		{1158, "Arcade Machine"},
+		{1159, "8-Bit Shooter"},
+		{1160, "The Pixelator"},
+		{1161, "G-6155 Spy Hunter"},
+		{1162, "Interdiver"},
+		{1163, "Aerial Spyhunter"},
+		{1164, "Slime Shooter"},
+		{1165, "Slime Exploder"},
+		{1166, "Slime Streamer"},
+		{1167, "Terror Dog"},
+		{1168, "Terror Dog Destroyer"},
+		{1169, "Soaring Terror Dog"},
+		{1170, "Ancient Psychic Tandem War Elephant"},
+		{1171, "Cosmic Squid"},
+		{1172, "Psychic Submarine"},
+		{1173, "BMO"},
+		{1174, "DOGMO"},
+		{1175, "SNAKEMO"},
+		{1176, "Jakemobile"},
+		{1177, "Snail Dude Jake"},
+		{1178, "Hover Jake"},
+		{1179, "Lumpy Car"},
+		{1181, "Lumpy Land Whale"},
+		{1180, "Lumpy Truck"},
+		{1182, "Lunatic Amp"},
+		{1183, "Shadow Scorpion"},
+		{1184, "Heavy Metal Monster"},
+		{1185, "B.A.'s Van"},
+		{1186, "Fool Smasher"},
+		{1187, "Pain Plane"},
+		{1188, "Phone Home"},
+		{1189, "Mobile Uplink"},
+		{1190, "Super-Charged Satellite"},
+		{1191, "Niffler"},
+		{1192, "Sinister Scorpion"},
+		{1193, "Vicious Vulture"},
+		{1194, "Swooping Evil"},
+		{1195, "Brutal Bloom"},
+		{1196, "Crawling Creeper"},
+		{1197, "Ecto-1 (2016)"},
+		{1198, "Ectozer"},
+		{1199, "PerfEcto"},
+		{1200, "Flash 'n' Finish"},
+		{1201, "Rampage Record Player"},
+		{1202, "Stripe's Throne"},
+		{1203, "R.C. Racer"},
+		{1204, "Gadget-O-Matic"},
+		{1205, "Scarlet Scorpion"},
+		{1206, "Hogwarts Express"},
+		{1208, "Steam Warrior"},
+		{1207, "Soaring Steam Plane"},
+		{1209, "Enchanted Car"},
+		{1210, "Shark Sub"},
+		{1211, "Monstrous Mouth"},
+		{1212, "IMF Scrambler"},
+		{1213, "Shock Cycle"},
+		{1214, "IMF Covert Jet"},
+		{1215, "IMF Sports Car"},
+		{1216, "IMF Tank"},
+		{1217, "IMF Splorer"},
+		{1218, "Sonic Speedster"},
+		{1219, "Blue Typhoon"},
+		{1220, "Moto Bug"},
+		{1221, "The Tornado"},
+		{1222, "Crabmeat"},
+		{1223, "Eggcatcher"},
+		{1224, "K.I.T.T."},
+		{1225, "Goliath Armored Semi"},
+		{1226, "K.I.T.T. Jet"},
+		{1227, "Police Helicopter"},
+		{1228, "Police Hovercraft"},
+		{1229, "Police Plane"},
+		{1230, "Bionic Steed"},
+		{1231, "Bat-Raptor"},
+		{1232, "Ultrabat"},
+		{1233, "Batwing"},
+		{1234, "The Black Thunder"},
+		{1235, "Bat-Tank"},
+		{1236, "Skeleton Organ"},
+		{1237, "Skeleton Jukebox"},
+		{1238, "Skele-Turkey"},
+		{1239, "One-Eyed Willy's Pirate Ship"},
+		{1240, "Fanged Fortune"},
+		{1241, "Inferno Cannon"},
+		{1242, "Buckbeak"},
+		{1243, "Giant Owl"},
+		{1244, "Fierce Falcon"},
+		{1245, "Saturn's Sandworm"},
+		{1247, "Haunted Vacuum"},
+		{1246, "Spooky Spider"},
+		{1248, "PPG Smartphone"},
+		{1249, "PPG Hotline"},
+		{1250, "Powerpuff Mag-Net"},
+		{1253, "Mega Blast Bot"},
+		{1251, "Ka-Pow Cannon"},
+		{1252, "Slammin' Guitar"},
+		{1254, "Octi"},
+		{1255, "Super Skunk"},
+		{1256, "Sonic Squid"},
+		{1257, "T-Car"},
+		{1258, "T-Forklift"},
+		{1259, "T-Plane"},
+		{1260, "Spellbook of Azarath"},
+		{1261, "Raven Wings"},
+		{1262, "Giant Hand"},
+		{1263, "Titan Robot"},
+		{1264, "T-Rocket"},
+		{1265, "Robot Retriever"}};
+
+	DimensionsToypadDevice::DimensionsToypadDevice()
+		: Device(0x0E6F, 0x0241, 1, 2, 0)
+	{
+		m_IsOpened = false;
+	}
+
+	bool DimensionsToypadDevice::Open()
+	{
+		if (!IsOpened())
+		{
+			m_IsOpened = true;
+		}
+		return true;
+	}
+
+	void DimensionsToypadDevice::Close()
+	{
+		if (IsOpened())
+		{
+			m_IsOpened = false;
+		}
+	}
+
+	bool DimensionsToypadDevice::IsOpened()
+	{
+		return m_IsOpened;
+	}
+
+	Device::ReadResult DimensionsToypadDevice::Read(ReadMessage* message)
+	{
+		memcpy(message->data, g_dimensionstoypad.GetStatus().data(), message->length);
+		message->bytesRead = message->length;
+		return Device::ReadResult::Success;
+	}
+
+	Device::WriteResult DimensionsToypadDevice::Write(WriteMessage* message)
+	{
+		if (message->length != 32)
+			return Device::WriteResult::Error;
+
+		g_dimensionstoypad.SendCommand(std::span<const uint8, 32>{message->data, 32});
+		message->bytesWritten = message->length;
+		return Device::WriteResult::Success;
+	}
+
+	bool DimensionsToypadDevice::GetDescriptor(uint8 descType,
+											   uint8 descIndex,
+											   uint16 lang,
+											   uint8* output,
+											   uint32 outputMaxLength)
+	{
+		uint8 configurationDescriptor[0x29];
+
+		uint8* currentWritePtr;
+
+		// configuration descriptor
+		currentWritePtr = configurationDescriptor + 0;
+		*(uint8*)(currentWritePtr + 0) = 9;			// bLength
+		*(uint8*)(currentWritePtr + 1) = 2;			// bDescriptorType
+		*(uint16be*)(currentWritePtr + 2) = 0x0029; // wTotalLength
+		*(uint8*)(currentWritePtr + 4) = 1;			// bNumInterfaces
+		*(uint8*)(currentWritePtr + 5) = 1;			// bConfigurationValue
+		*(uint8*)(currentWritePtr + 6) = 0;			// iConfiguration
+		*(uint8*)(currentWritePtr + 7) = 0x80;		// bmAttributes
+		*(uint8*)(currentWritePtr + 8) = 0xFA;		// MaxPower
+		currentWritePtr = currentWritePtr + 9;
+		// configuration descriptor
+		*(uint8*)(currentWritePtr + 0) = 9;	   // bLength
+		*(uint8*)(currentWritePtr + 1) = 0x04; // bDescriptorType
+		*(uint8*)(currentWritePtr + 2) = 0;	   // bInterfaceNumber
+		*(uint8*)(currentWritePtr + 3) = 0;	   // bAlternateSetting
+		*(uint8*)(currentWritePtr + 4) = 2;	   // bNumEndpoints
+		*(uint8*)(currentWritePtr + 5) = 3;	   // bInterfaceClass
+		*(uint8*)(currentWritePtr + 6) = 0;	   // bInterfaceSubClass
+		*(uint8*)(currentWritePtr + 7) = 0;	   // bInterfaceProtocol
+		*(uint8*)(currentWritePtr + 8) = 0;	   // iInterface
+		currentWritePtr = currentWritePtr + 9;
+		// configuration descriptor
+		*(uint8*)(currentWritePtr + 0) = 9;			// bLength
+		*(uint8*)(currentWritePtr + 1) = 0x21;		// bDescriptorType
+		*(uint16be*)(currentWritePtr + 2) = 0x0111; // bcdHID
+		*(uint8*)(currentWritePtr + 4) = 0x00;		// bCountryCode
+		*(uint8*)(currentWritePtr + 5) = 0x01;		// bNumDescriptors
+		*(uint8*)(currentWritePtr + 6) = 0x22;		// bDescriptorType
+		*(uint16be*)(currentWritePtr + 7) = 0x001D; // wDescriptorLength
+		currentWritePtr = currentWritePtr + 9;
+		// endpoint descriptor 1
+		*(uint8*)(currentWritePtr + 0) = 7;		  // bLength
+		*(uint8*)(currentWritePtr + 1) = 0x05;	  // bDescriptorType
+		*(uint8*)(currentWritePtr + 2) = 0x81;	  // bEndpointAddress
+		*(uint8*)(currentWritePtr + 3) = 0x03;	  // bmAttributes
+		*(uint16be*)(currentWritePtr + 4) = 0x40; // wMaxPacketSize
+		*(uint8*)(currentWritePtr + 6) = 0x01;	  // bInterval
+		currentWritePtr = currentWritePtr + 7;
+		// endpoint descriptor 2
+		*(uint8*)(currentWritePtr + 0) = 7;		  // bLength
+		*(uint8*)(currentWritePtr + 1) = 0x05;	  // bDescriptorType
+		*(uint8*)(currentWritePtr + 1) = 0x02;	  // bEndpointAddress
+		*(uint8*)(currentWritePtr + 2) = 0x03;	  // bmAttributes
+		*(uint16be*)(currentWritePtr + 3) = 0x40; // wMaxPacketSize
+		*(uint8*)(currentWritePtr + 5) = 0x01;	  // bInterval
+		currentWritePtr = currentWritePtr + 7;
+
+		cemu_assert_debug((currentWritePtr - configurationDescriptor) == 0x29);
+
+		memcpy(output, configurationDescriptor,
+			   std::min<uint32>(outputMaxLength, sizeof(configurationDescriptor)));
+		return true;
+	}
+
+	bool DimensionsToypadDevice::SetIdle(uint8 ifIndex,
+										 uint8 reportId,
+										 uint8 duration)
+	{
+		return true;
+	}
+
+	bool DimensionsToypadDevice::SetProtocol(uint8 ifIndex, uint8 protocol)
+	{
+		cemuLog_log(LogType::Force, "Toypad Protocol");
+		return true;
+	}
+
+	bool DimensionsToypadDevice::SetReport(ReportMessage* message)
+	{
+		cemuLog_log(LogType::Force, "Toypad Report");
+		return true;
+	}
+
+	std::array<uint8, 32> DimensionsUSB::GetStatus()
+	{
+		std::array<uint8, 32> response = {};
+
+		bool responded = false;
+		do
+		{
+			if (!m_queries.empty())
+			{
+				response = m_queries.front();
+				m_queries.pop();
+				responded = true;
+			}
+			else if (!m_figureAddedRemovedResponses.empty() && m_isAwake)
+			{
+				std::lock_guard lock(m_dimensionsMutex);
+				response = m_figureAddedRemovedResponses.front();
+				m_figureAddedRemovedResponses.pop();
+				responded = true;
+			}
+			else
+			{
+				std::this_thread::sleep_for(std::chrono::milliseconds(100));
+			}
+		}
+		while (responded == false);
+		return response;
+	}
+
+	void DimensionsUSB::SendCommand(std::span<const uint8, 32> buf)
+	{
+		const uint8 command = buf[2];
+		const uint8 sequence = buf[3];
+
+		std::array<uint8, 32> q_result{};
+
+		switch (command)
+		{
+		case 0xB0: // Wake
+		{
+			// Consistent device response to the wake command
+			q_result = {0x55, 0x0e, 0x01, 0x28, 0x63, 0x29,
+						0x20, 0x4c, 0x45, 0x47, 0x4f, 0x20,
+						0x32, 0x30, 0x31, 0x34, 0x46};
+			break;
+		}
+		case 0xB1: // Seed
+		{
+			// Initialise a random number generator using the seed provided
+			g_dimensionstoypad.GenerateRandomNumber(std::span<const uint8, 8>{buf.begin() + 4, 8}, sequence, q_result);
+			break;
+		}
+		case 0xB3: // Challenge
+		{
+			// Get the next number in the sequence based on the RNG from 0xB1 command
+			g_dimensionstoypad.GetChallengeResponse(std::span<const uint8, 8>{buf.begin() + 4, 8}, sequence, q_result);
+			break;
+		}
+		case 0xC0: // Color
+		case 0xC1: // Get Pad Color
+		case 0xC2: // Fade
+		case 0xC3: // Flash
+		case 0xC4: // Fade Random
+		case 0xC6: // Fade All
+		case 0xC7: // Flash All
+		case 0xC8: // Color All
+		{
+			// Send a blank response to acknowledge color has been sent to toypad
+			q_result = {0x55, 0x01, sequence};
+			q_result[3] = GenerateChecksum(q_result, 3);
+			break;
+		}
+		case 0xD2: // Read
+		{
+			// Read 4 pages from the figure at index (buf[4]), starting with page buf[5]
+			g_dimensionstoypad.QueryBlock(buf[4], buf[5], q_result, sequence);
+			break;
+		}
+		case 0xD3: // Write
+		{
+			// Write 4 bytes to page buf[5] to the figure at index buf[4]
+			g_dimensionstoypad.WriteBlock(buf[4], buf[5], std::span<const uint8, 4>{buf.begin() + 6, 4}, q_result, sequence);
+			break;
+		}
+		case 0xD4: // Model
+		{
+			// Get the model id of the figure at index buf[4]
+			g_dimensionstoypad.GetModel(std::span<const uint8, 8>{buf.begin() + 4, 8}, sequence, q_result);
+			break;
+		}
+		case 0xD0: // Tag List
+		case 0xE1: // PWD
+		case 0xE5: // Active
+		case 0xFF: // LEDS Query
+		{
+			// Further investigation required
+			cemuLog_log(LogType::Force, "Unimplemented LD Function: {:x}", command);
+			break;
+		}
+		default:
+		{
+			cemuLog_log(LogType::Force, "Unknown LD Function: {:x}", command);
+			break;
+		}
+		}
+
+		m_queries.push(q_result);
+	}
+
+	uint32 DimensionsUSB::LoadFigure(const std::array<uint8, 0x2D * 0x04>& buf, std::unique_ptr<FileStream> file, uint8 pad, uint8 index)
+	{
+		std::lock_guard lock(m_dimensionsMutex);
+
+		const uint32 id = GetFigureId(buf);
+
+		DimensionsMini& figure = GetFigureByIndex(index);
+		figure.dimFile = std::move(file);
+		figure.id = id;
+		figure.pad = pad;
+		figure.index = index + 1;
+		figure.data = buf;
+		// When a figure is added to the toypad, respond to the game with the pad they were added to, their index,
+		// the direction (0x00 in byte 6 for added) and their UID
+		std::array<uint8, 32> figureChangeResponse = {0x56, 0x0b, figure.pad, 0x00, figure.index, 0x00, buf[0], buf[1], buf[2], buf[4], buf[5], buf[6], buf[7]};
+		figureChangeResponse[13] = GenerateChecksum(figureChangeResponse, 13);
+		m_figureAddedRemovedResponses.push(figureChangeResponse);
+
+		return id;
+	}
+
+	bool DimensionsUSB::RemoveFigure(uint8 pad, uint8 index, bool fullRemove)
+	{
+		std::lock_guard lock(m_dimensionsMutex);
+
+		DimensionsMini& figure = GetFigureByIndex(index);
+		if (figure.index == 255)
+			return false;
+
+		// When a figure is removed from the toypad, respond to the game with the pad they were removed from, their index,
+		// the direction (0x01 in byte 6 for removed) and their UID
+		if (fullRemove)
+		{
+			std::array<uint8, 32> figureChangeResponse = {0x56, 0x0b, figure.pad, 0x00, figure.index, 0x01,
+														  figure.data[0], figure.data[1], figure.data[2],
+														  figure.data[4], figure.data[5], figure.data[6], figure.data[7]};
+			figureChangeResponse[13] = GenerateChecksum(figureChangeResponse, 13);
+			m_figureAddedRemovedResponses.push(figureChangeResponse);
+			figure.Save();
+			figure.dimFile.reset();
+		}
+
+		figure.index = 255;
+		figure.pad = 255;
+		figure.id = 0;
+
+		return true;
+	}
+
+	bool DimensionsUSB::TempRemove(uint8 index)
+	{
+		std::lock_guard lock(m_dimensionsMutex);
+
+		DimensionsMini& figure = GetFigureByIndex(index);
+		if (figure.index == 255)
+			return false;
+
+		// Send a response to the game that the figure has been "Picked up" from existing slot,
+		// until either the movement is cancelled, or user chooses a space to move to
+		std::array<uint8, 32> figureChangeResponse = {0x56, 0x0b, figure.pad, 0x00, figure.index, 0x01,
+													  figure.data[0], figure.data[1], figure.data[2],
+													  figure.data[4], figure.data[5], figure.data[6], figure.data[7]};
+
+		figureChangeResponse[13] = GenerateChecksum(figureChangeResponse, 13);
+		m_figureAddedRemovedResponses.push(figureChangeResponse);
+		return true;
+	}
+
+	bool DimensionsUSB::CancelRemove(uint8 index)
+	{
+		std::lock_guard lock(m_dimensionsMutex);
+
+		DimensionsMini& figure = GetFigureByIndex(index);
+		if (figure.index == 255)
+			return false;
+
+		// Cancel the previous movement of the figure
+		std::array<uint8, 32> figureChangeResponse = {0x56, 0x0b, figure.pad, 0x00, figure.index, 0x00,
+													  figure.data[0], figure.data[1], figure.data[2],
+													  figure.data[4], figure.data[5], figure.data[6], figure.data[7]};
+
+		figureChangeResponse[13] = GenerateChecksum(figureChangeResponse, 13);
+		m_figureAddedRemovedResponses.push(figureChangeResponse);
+
+		return true;
+	}
+
+	bool DimensionsUSB::CreateFigure(fs::path pathName, uint32 id)
+	{
+		FileStream* dimFile(FileStream::createFile2(pathName));
+		if (!dimFile)
+			return false;
+
+		std::array<uint8, 0x2D * 0x04> fileData{};
+		RandomUID(fileData);
+		fileData[3] = id & 0xFF;
+
+		std::array<uint8, 7> uid = {fileData[0], fileData[1], fileData[2], fileData[4], fileData[5], fileData[6], fileData[7]};
+
+		// Only characters are created with their ID encrypted and stored in pages 36 and 37,
+		// as well as a password stored in page 43. Blank tags have their information populated
+		// by the game when it calls the write_block command.
+		if (id != 0)
+		{
+			const std::array<uint8, 16> figureKey = GenerateFigureKey(fileData);
+
+			std::array<uint8, 8> valueToEncrypt = {uint8(id & 0xFF), uint8((id >> 8) & 0xFF), uint8((id >> 16) & 0xFF), uint8((id >> 24) & 0xFF),
+												   uint8(id & 0xFF), uint8((id >> 8) & 0xFF), uint8((id >> 16) & 0xFF), uint8((id >> 24) & 0xFF)};
+
+			std::array<uint8, 8> encrypted = Encrypt(valueToEncrypt, figureKey);
+
+			std::memcpy(&fileData[36 * 4], &encrypted[0], 4);
+			std::memcpy(&fileData[37 * 4], &encrypted[4], 4);
+
+			std::memcpy(&fileData[43 * 4], PWDGenerate(fileData).data(), 4);
+		}
+		else
+		{
+			// Page 38 is used as verification for blank tags
+			fileData[(38 * 4) + 1] = 1;
+		}
+
+		if (fileData.size() != dimFile->writeData(fileData.data(), fileData.size()))
+		{
+			delete dimFile;
+			return false;
+		}
+		delete dimFile;
+		return true;
+	}
+
+	bool DimensionsUSB::MoveFigure(uint8 pad, uint8 index, uint8 oldPad, uint8 oldIndex)
+	{
+		if (oldIndex == index)
+		{
+			// Don't bother removing and loading again, just send response to the game
+			CancelRemove(index);
+			return true;
+		}
+
+		// When moving figures between spaces on the toypad, remove any figure from the space they are moving to,
+		// then remove them from their current space, then load them to the space they are moving to
+		RemoveFigure(pad, index, true);
+
+		DimensionsMini& figure = GetFigureByIndex(oldIndex);
+		const std::array<uint8, 0x2D * 0x04> data = figure.data;
+		std::unique_ptr<FileStream> inFile = std::move(figure.dimFile);
+
+		RemoveFigure(oldPad, oldIndex, false);
+
+		LoadFigure(data, std::move(inFile), pad, index);
+
+		return true;
+	}
+
+	void DimensionsUSB::GenerateRandomNumber(std::span<const uint8, 8> buf, uint8 sequence,
+											 std::array<uint8, 32>& replyBuf)
+	{
+		// Decrypt payload into an 8 byte array
+		std::array<uint8, 8> value = Decrypt(buf, std::nullopt);
+		// Seed is the first 4 bytes (little endian) of the decrypted payload
+		uint32 seed = (uint32&)value[0];
+		// Confirmation is the second 4 bytes (big endian) of the decrypted payload
+		uint32 conf = (uint32be&)value[4];
+		// Initialize rng using the seed from decrypted payload
+		InitializeRNG(seed);
+		// Encrypt 8 bytes, first 4 bytes is the decrypted confirmation from payload, 2nd 4 bytes are blank
+		std::array<uint8, 8> valueToEncrypt = {value[4], value[5], value[6], value[7], 0, 0, 0, 0};
+		std::array<uint8, 8> encrypted = Encrypt(valueToEncrypt, std::nullopt);
+		replyBuf[0] = 0x55;
+		replyBuf[1] = 0x09;
+		replyBuf[2] = sequence;
+		// Copy encrypted value to response data
+		memcpy(&replyBuf[3], encrypted.data(), encrypted.size());
+		replyBuf[11] = GenerateChecksum(replyBuf, 11);
+	}
+
+	void DimensionsUSB::GetChallengeResponse(std::span<const uint8, 8> buf, uint8 sequence,
+											 std::array<uint8, 32>& replyBuf)
+	{
+		// Decrypt payload into an 8 byte array
+		std::array<uint8, 8> value = Decrypt(buf, std::nullopt);
+		// Confirmation is the first 4 bytes of the decrypted payload
+		uint32 conf = (uint32be&)value[0];
+		// Generate next random number based on RNG
+		uint32 nextRandom = GetNext();
+		// Encrypt an 8 byte array, first 4 bytes are the next random number (little endian)
+		// followed by the confirmation from the decrypted payload
+		std::array<uint8, 8> valueToEncrypt = {uint8(nextRandom & 0xFF), uint8((nextRandom >> 8) & 0xFF),
+											   uint8((nextRandom >> 16) & 0xFF), uint8((nextRandom >> 24) & 0xFF),
+											   value[0], value[1], value[2], value[3]};
+		std::array<uint8, 8> encrypted = Encrypt(valueToEncrypt, std::nullopt);
+		replyBuf[0] = 0x55;
+		replyBuf[1] = 0x09;
+		replyBuf[2] = sequence;
+		// Copy encrypted value to response data
+		memcpy(&replyBuf[3], encrypted.data(), encrypted.size());
+		replyBuf[11] = GenerateChecksum(replyBuf, 11);
+
+		if (!m_isAwake)
+			m_isAwake = true;
+	}
+
+	void DimensionsUSB::InitializeRNG(uint32 seed)
+	{
+		m_randomA = 0xF1EA5EED;
+		m_randomB = seed;
+		m_randomC = seed;
+		m_randomD = seed;
+
+		for (int i = 0; i < 42; i++)
+		{
+			GetNext();
+		}
+	}
+
+	uint32 DimensionsUSB::GetNext()
+	{
+		uint32 e = m_randomA - std::rotl(m_randomB, 21);
+		m_randomA = m_randomB ^ std::rotl(m_randomC, 19);
+		m_randomB = m_randomC + std::rotl(m_randomD, 6);
+		m_randomC = m_randomD + e;
+		m_randomD = e + m_randomA;
+		return m_randomD;
+	}
+
+	std::array<uint8, 8> DimensionsUSB::Decrypt(std::span<const uint8, 8> buf, std::optional<std::array<uint8, 16>> key)
+	{
+		// Value to decrypt is separated in to two little endian 32 bit unsigned integers
+		uint32 dataOne = (uint32&)buf[0];
+		uint32 dataTwo = (uint32&)buf[4];
+
+		// Use the key as 4 32 bit little endian unsigned integers
+		uint32 keyOne;
+		uint32 keyTwo;
+		uint32 keyThree;
+		uint32 keyFour;
+
+		if (key)
+		{
+			keyOne = (uint32&)key.value()[0];
+			keyTwo = (uint32&)key.value()[4];
+			keyThree = (uint32&)key.value()[8];
+			keyFour = (uint32&)key.value()[12];
+		}
+		else
+		{
+			keyOne = (uint32&)COMMAND_KEY[0];
+			keyTwo = (uint32&)COMMAND_KEY[4];
+			keyThree = (uint32&)COMMAND_KEY[8];
+			keyFour = (uint32&)COMMAND_KEY[12];
+		}
+
+		uint32 sum = 0xC6EF3720;
+		uint32 delta = 0x9E3779B9;
+
+		for (int i = 0; i < 32; i++)
+		{
+			dataTwo -= (((dataOne << 4) + keyThree) ^ (dataOne + sum) ^ ((dataOne >> 5) + keyFour));
+			dataOne -= (((dataTwo << 4) + keyOne) ^ (dataTwo + sum) ^ ((dataTwo >> 5) + keyTwo));
+			sum -= delta;
+		}
+
+		cemu_assert(sum == 0);
+
+		std::array<uint8, 8> decrypted = {uint8(dataOne & 0xFF), uint8((dataOne >> 8) & 0xFF),
+										  uint8((dataOne >> 16) & 0xFF), uint8((dataOne >> 24) & 0xFF),
+										  uint8(dataTwo & 0xFF), uint8((dataTwo >> 8) & 0xFF),
+										  uint8((dataTwo >> 16) & 0xFF), uint8((dataTwo >> 24) & 0xFF)};
+		return decrypted;
+	}
+	std::array<uint8, 8> DimensionsUSB::Encrypt(std::span<const uint8, 8> buf, std::optional<std::array<uint8, 16>> key)
+	{
+		// Value to encrypt is separated in to two little endian 32 bit unsigned integers
+		uint32 dataOne = (uint32&)buf[0];
+		uint32 dataTwo = (uint32&)buf[4];
+
+		// Use the key as 4 32 bit little endian unsigned integers
+		uint32 keyOne;
+		uint32 keyTwo;
+		uint32 keyThree;
+		uint32 keyFour;
+
+		if (key)
+		{
+			keyOne = (uint32&)key.value()[0];
+			keyTwo = (uint32&)key.value()[4];
+			keyThree = (uint32&)key.value()[8];
+			keyFour = (uint32&)key.value()[12];
+		}
+		else
+		{
+			keyOne = (uint32&)COMMAND_KEY[0];
+			keyTwo = (uint32&)COMMAND_KEY[4];
+			keyThree = (uint32&)COMMAND_KEY[8];
+			keyFour = (uint32&)COMMAND_KEY[12];
+		}
+
+		uint32 sum = 0;
+		uint32 delta = 0x9E3779B9;
+
+		for (int i = 0; i < 32; i++)
+		{
+			sum += delta;
+			dataOne += (((dataTwo << 4) + keyOne) ^ (dataTwo + sum) ^ ((dataTwo >> 5) + keyTwo));
+			dataTwo += (((dataOne << 4) + keyThree) ^ (dataOne + sum) ^ ((dataOne >> 5) + keyFour));
+		}
+
+		cemu_assert(sum == 0xC6EF3720);
+
+		std::array<uint8, 8> encrypted = {uint8(dataOne & 0xFF), uint8((dataOne >> 8) & 0xFF),
+										  uint8((dataOne >> 16) & 0xFF), uint8((dataOne >> 24) & 0xFF),
+										  uint8(dataTwo & 0xFF), uint8((dataTwo >> 8) & 0xFF),
+										  uint8((dataTwo >> 16) & 0xFF), uint8((dataTwo >> 24) & 0xFF)};
+		return encrypted;
+	}
+
+	std::array<uint8, 16> DimensionsUSB::GenerateFigureKey(const std::array<uint8, 0x2D * 0x04>& buf)
+	{
+		std::array<uint8, 7> uid = {buf[0], buf[1], buf[2], buf[4], buf[5], buf[6], buf[7]};
+
+		uint32 scrambleA = Scramble(uid, 3);
+		uint32 scrambleB = Scramble(uid, 4);
+		uint32 scrambleC = Scramble(uid, 5);
+		uint32 scrambleD = Scramble(uid, 6);
+
+		return {uint8((scrambleA >> 24) & 0xFF), uint8((scrambleA >> 16) & 0xFF),
+				uint8((scrambleA >> 8) & 0xFF), uint8(scrambleA & 0xFF),
+				uint8((scrambleB >> 24) & 0xFF), uint8((scrambleB >> 16) & 0xFF),
+				uint8((scrambleB >> 8) & 0xFF), uint8(scrambleB & 0xFF),
+				uint8((scrambleC >> 24) & 0xFF), uint8((scrambleC >> 16) & 0xFF),
+				uint8((scrambleC >> 8) & 0xFF), uint8(scrambleC & 0xFF),
+				uint8((scrambleD >> 24) & 0xFF), uint8((scrambleD >> 16) & 0xFF),
+				uint8((scrambleD >> 8) & 0xFF), uint8(scrambleD & 0xFF)};
+	}
+
+	uint32 DimensionsUSB::Scramble(const std::array<uint8, 7>& uid, uint8 count)
+	{
+		std::vector<uint8> toScramble;
+		toScramble.reserve(uid.size() + CHAR_CONSTANT.size());
+		for (uint8 x : uid)
+		{
+			toScramble.push_back(x);
+		}
+		for (uint8 c : CHAR_CONSTANT)
+		{
+			toScramble.push_back(c);
+		}
+		toScramble[(count * 4) - 1] = 0xaa;
+
+		std::array<uint8, 4> randomized = DimensionsRandomize(toScramble, count);
+
+		return (uint32be&)randomized[0];
+	}
+
+	std::array<uint8, 4> DimensionsUSB::PWDGenerate(const std::array<uint8, 0x2D * 0x04>& buf)
+	{
+		std::array<uint8, 7> uid = {buf[0], buf[1], buf[2], buf[4], buf[5], buf[6], buf[7]};
+
+		std::vector<uint8> pwdCalc = {PWD_CONSTANT.begin(), PWD_CONSTANT.end() - 1};
+		for (uint8 i = 0; i < uid.size(); i++)
+		{
+			pwdCalc.insert(pwdCalc.begin() + i, uid[i]);
+		}
+
+		return DimensionsRandomize(pwdCalc, 8);
+	}
+
+	std::array<uint8, 4> DimensionsUSB::DimensionsRandomize(const std::vector<uint8> key, uint8 count)
+	{
+		uint32 scrambled = 0;
+		for (uint8 i = 0; i < count; i++)
+		{
+			const uint32 v4 = std::rotr(scrambled, 25);
+			const uint32 v5 = std::rotr(scrambled, 10);
+			const uint32 b = (uint32&)key[i * 4];
+			scrambled = b + v4 + v5 - scrambled;
+		}
+		return {uint8(scrambled & 0xFF), uint8(scrambled >> 8 & 0xFF), uint8(scrambled >> 16 & 0xFF), uint8(scrambled >> 24 & 0xFF)};
+	}
+
+	uint32 DimensionsUSB::GetFigureId(const std::array<uint8, 0x2D * 0x04>& buf)
+	{
+		const std::array<uint8, 16> figureKey = GenerateFigureKey(buf);
+
+		const std::span<const uint8, 8> modelNumber = std::span<const uint8, 8>{buf.begin() + (36 * 4), 8};
+
+		const std::array<uint8, 8> decrypted = Decrypt(modelNumber, figureKey);
+
+		const uint32 figNum = (uint32&)decrypted[0];
+		// Characters have their model number encrypted in page 36
+		if (figNum < 1000)
+		{
+			return figNum;
+		}
+		// Vehicles/Gadgets have their model number written as little endian in page 36
+		return (uint32&)modelNumber[0];
+	}
+
+	DimensionsUSB::DimensionsMini&
+	DimensionsUSB::GetFigureByIndex(uint8 index)
+	{
+		return m_figures[index];
+	}
+
+	void DimensionsUSB::QueryBlock(uint8 index, uint8 page,
+								   std::array<uint8, 32>& replyBuf,
+								   uint8 sequence)
+	{
+		std::lock_guard lock(m_dimensionsMutex);
+
+		replyBuf[0] = 0x55;
+		replyBuf[1] = 0x12;
+		replyBuf[2] = sequence;
+		replyBuf[3] = 0x00;
+
+		// Index from game begins at 1 rather than 0, so minus 1 here
+		if (const uint8 figureIndex = index - 1; figureIndex < 7)
+		{
+			const DimensionsMini& figure = GetFigureByIndex(figureIndex);
+
+			// Query 4 pages of 4 bytes from the figure, copy this to the response
+			if (figure.index != 255 && (4 * page) < ((0x2D * 4) - 16))
+			{
+				std::memcpy(&replyBuf[4], figure.data.data() + (4 * page), 16);
+			}
+		}
+		replyBuf[20] = GenerateChecksum(replyBuf, 20);
+	}
+
+	void DimensionsUSB::WriteBlock(uint8 index, uint8 page, std::span<const uint8, 4> toWriteBuf,
+								   std::array<uint8, 32>& replyBuf, uint8 sequence)
+	{
+		std::lock_guard lock(m_dimensionsMutex);
+
+		replyBuf[0] = 0x55;
+		replyBuf[1] = 0x02;
+		replyBuf[2] = sequence;
+		replyBuf[3] = 0x00;
+
+		// Index from game begins at 1 rather than 0, so minus 1 here
+		if (const uint8 figureIndex = index - 1; figureIndex < 7)
+		{
+			DimensionsMini& figure = GetFigureByIndex(figureIndex);
+
+			// Copy 4 bytes to the page on the figure requested by the game
+			if (figure.index != 255 && page < 0x2D)
+			{
+				// Id is written to page 36
+				if (page == 36)
+				{
+					figure.id = (uint32&)toWriteBuf[0];
+				}
+				std::memcpy(figure.data.data() + (page * 4), toWriteBuf.data(), 4);
+				figure.Save();
+			}
+		}
+		replyBuf[4] = GenerateChecksum(replyBuf, 4);
+	}
+
+	void DimensionsUSB::GetModel(std::span<const uint8, 8> buf, uint8 sequence,
+								 std::array<uint8, 32>& replyBuf)
+	{
+		// Decrypt payload to 8 byte array, byte 1 is the index, 4-7 are the confirmation
+		std::array<uint8, 8> value = Decrypt(buf, std::nullopt);
+		uint8 index = value[0];
+		uint32 conf = (uint32be&)value[4];
+		// Response is the figure's id (little endian) followed by the confirmation from payload
+		// Index from game begins at 1 rather than 0, so minus 1 here
+		std::array<uint8, 8> valueToEncrypt = {};
+		if (const uint8 figureIndex = index - 1; figureIndex < 7)
+		{
+			const DimensionsMini& figure = GetFigureByIndex(figureIndex);
+			valueToEncrypt = {uint8(figure.id & 0xFF), uint8((figure.id >> 8) & 0xFF),
+							  uint8((figure.id >> 16) & 0xFF), uint8((figure.id >> 24) & 0xFF),
+							  value[4], value[5], value[6], value[7]};
+		}
+		std::array<uint8, 8> encrypted = Encrypt(valueToEncrypt, std::nullopt);
+		replyBuf[0] = 0x55;
+		replyBuf[1] = 0x0a;
+		replyBuf[2] = sequence;
+		replyBuf[3] = 0x00;
+		memcpy(&replyBuf[4], encrypted.data(), encrypted.size());
+		replyBuf[12] = GenerateChecksum(replyBuf, 12);
+	}
+
+	void DimensionsUSB::RandomUID(std::array<uint8, 0x2D * 0x04>& uid_buffer)
+	{
+		uid_buffer[0] = 0x04;
+		uid_buffer[7] = 0x80;
+
+		std::random_device rd;
+		std::mt19937 mt(rd());
+		std::uniform_int_distribution<int> dist(0, 255);
+
+		uid_buffer[1] = dist(mt);
+		uid_buffer[2] = dist(mt);
+		uid_buffer[4] = dist(mt);
+		uid_buffer[5] = dist(mt);
+		uid_buffer[6] = dist(mt);
+	}
+
+	uint8 DimensionsUSB::GenerateChecksum(const std::array<uint8, 32>& data,
+										  int num_of_bytes) const
+	{
+		int checksum = 0;
+		for (int i = 0; i < num_of_bytes; i++)
+		{
+			checksum += data[i];
+		}
+		return (checksum & 0xFF);
+	}
+
+	void DimensionsUSB::DimensionsMini::Save()
+	{
+		if (!dimFile)
+			return;
+
+		dimFile->SetPosition(0);
+		dimFile->writeData(data.data(), data.size());
+	}
+
+	std::map<const uint32, const char*> DimensionsUSB::GetListMinifigs()
+	{
+		return s_listMinis;
+	}
+
+	std::map<const uint32, const char*> DimensionsUSB::GetListTokens()
+	{
+		return s_listTokens;
+	}
+
+	std::string DimensionsUSB::FindFigure(uint32 figNum)
+	{
+		for (const auto& it : GetListMinifigs())
+		{
+			if (it.first == figNum)
+			{
+				return it.second;
+			}
+		}
+		for (const auto& it : GetListTokens())
+		{
+			if (it.first == figNum)
+			{
+				return it.second;
+			}
+		}
+		return fmt::format("Unknown ({})", figNum);
+	}
+} // namespace nsyshid
\ No newline at end of file
diff --git a/src/Cafe/OS/libs/nsyshid/Dimensions.h b/src/Cafe/OS/libs/nsyshid/Dimensions.h
new file mode 100644
index 00000000..00ceff9e
--- /dev/null
+++ b/src/Cafe/OS/libs/nsyshid/Dimensions.h
@@ -0,0 +1,112 @@
+#include <mutex>
+
+#include "nsyshid.h"
+#include "Backend.h"
+
+#include "Common/FileStream.h"
+
+namespace nsyshid
+{
+	class DimensionsToypadDevice final : public Device
+	{
+	  public:
+		DimensionsToypadDevice();
+		~DimensionsToypadDevice() = default;
+
+		bool Open() override;
+
+		void Close() override;
+
+		bool IsOpened() override;
+
+		ReadResult Read(ReadMessage* message) override;
+
+		WriteResult Write(WriteMessage* message) override;
+
+		bool GetDescriptor(uint8 descType,
+						   uint8 descIndex,
+						   uint16 lang,
+						   uint8* output,
+						   uint32 outputMaxLength) override;
+
+		bool SetIdle(uint8 ifIndex,
+					 uint8 reportId,
+					 uint8 duration) override;
+
+		bool SetProtocol(uint8 ifIndex, uint8 protocol) override;
+
+		bool SetReport(ReportMessage* message) override;
+
+	  private:
+		bool m_IsOpened;
+	};
+
+	class DimensionsUSB
+	{
+	  public:
+		struct DimensionsMini final
+		{
+			std::unique_ptr<FileStream> dimFile;
+			std::array<uint8, 0x2D * 0x04> data{};
+			uint8 index = 255;
+			uint8 pad = 255;
+			uint32 id = 0;
+			void Save();
+		};
+
+		void SendCommand(std::span<const uint8, 32> buf);
+		std::array<uint8, 32> GetStatus();
+
+		void GenerateRandomNumber(std::span<const uint8, 8> buf, uint8 sequence,
+								  std::array<uint8, 32>& replyBuf);
+		void InitializeRNG(uint32 seed);
+		void GetChallengeResponse(std::span<const uint8, 8> buf, uint8 sequence,
+								  std::array<uint8, 32>& replyBuf);
+		void QueryBlock(uint8 index, uint8 page, std::array<uint8, 32>& replyBuf,
+						uint8 sequence);
+		void WriteBlock(uint8 index, uint8 page, std::span<const uint8, 4> toWriteBuf, std::array<uint8, 32>& replyBuf,
+						uint8 sequence);
+		void GetModel(std::span<const uint8, 8> buf, uint8 sequence,
+					  std::array<uint8, 32>& replyBuf);
+
+		bool RemoveFigure(uint8 pad, uint8 index, bool fullRemove);
+		bool TempRemove(uint8 index);
+		bool CancelRemove(uint8 index);
+		uint32 LoadFigure(const std::array<uint8, 0x2D * 0x04>& buf, std::unique_ptr<FileStream> file, uint8 pad, uint8 index);
+		bool CreateFigure(fs::path pathName, uint32 id);
+		bool MoveFigure(uint8 pad, uint8 index, uint8 oldPad, uint8 oldIndex);
+		static std::map<const uint32, const char*> GetListMinifigs();
+		static std::map<const uint32, const char*> GetListTokens();
+		std::string FindFigure(uint32 figNum);
+
+	  protected:
+		std::mutex m_dimensionsMutex;
+		std::array<DimensionsMini, 7> m_figures{};
+
+	  private:
+		void RandomUID(std::array<uint8, 0x2D * 0x04>& uidBuffer);
+		uint8 GenerateChecksum(const std::array<uint8, 32>& data,
+							   int numOfBytes) const;
+		std::array<uint8, 8> Decrypt(std::span<const uint8, 8> buf, std::optional<std::array<uint8, 16>> key);
+		std::array<uint8, 8> Encrypt(std::span<const uint8, 8> buf, std::optional<std::array<uint8, 16>> key);
+		std::array<uint8, 16> GenerateFigureKey(const std::array<uint8, 0x2D * 0x04>& uid);
+		std::array<uint8, 4> PWDGenerate(const std::array<uint8, 0x2D * 0x04>& uid);
+		std::array<uint8, 4> DimensionsRandomize(const std::vector<uint8> key, uint8 count);
+		uint32 GetFigureId(const std::array<uint8, 0x2D * 0x04>& buf);
+		uint32 Scramble(const std::array<uint8, 7>& uid, uint8 count);
+		uint32 GetNext();
+		DimensionsMini& GetFigureByIndex(uint8 index);
+
+		uint32 m_randomA;
+		uint32 m_randomB;
+		uint32 m_randomC;
+		uint32 m_randomD;
+
+		bool m_isAwake = false;
+
+		std::queue<std::array<uint8, 32>> m_figureAddedRemovedResponses;
+		std::queue<std::array<uint8, 32>> m_queries;
+	};
+	extern DimensionsUSB g_dimensionstoypad;
+
+} // namespace nsyshid
\ No newline at end of file
diff --git a/src/Cafe/OS/libs/nsyshid/Infinity.cpp b/src/Cafe/OS/libs/nsyshid/Infinity.cpp
new file mode 100644
index 00000000..94ef817e
--- /dev/null
+++ b/src/Cafe/OS/libs/nsyshid/Infinity.cpp
@@ -0,0 +1,1105 @@
+#include "Infinity.h"
+
+#include <random>
+
+#include "nsyshid.h"
+#include "Backend.h"
+
+#include "util/crypto/aes128.h"
+
+#include <openssl/crypto.h>
+#include "openssl/sha.h"
+
+namespace nsyshid
+{
+	static constexpr std::array<uint8, 32> SHA1_CONSTANT = {
+		0xAF, 0x62, 0xD2, 0xEC, 0x04, 0x91, 0x96, 0x8C, 0xC5, 0x2A, 0x1A, 0x71, 0x65, 0xF8, 0x65, 0xFE,
+		0x28, 0x63, 0x29, 0x20, 0x44, 0x69, 0x73, 0x6e, 0x65, 0x79, 0x20, 0x32, 0x30, 0x31, 0x33};
+
+	InfinityUSB g_infinitybase;
+
+	const std::map<const uint32, const std::pair<const uint8, const char*>> s_listFigures = {
+		{0x0F4241, {1, "Mr. Incredible"}},
+		{0x0F4242, {1, "Sulley"}},
+		{0x0F4243, {1, "Jack Sparrow"}},
+		{0x0F4244, {1, "Lone Ranger"}},
+		{0x0F4245, {1, "Tonto"}},
+		{0x0F4246, {1, "Lightning McQueen"}},
+		{0x0F4247, {1, "Holley Shiftwell"}},
+		{0x0F4248, {1, "Buzz Lightyear"}},
+		{0x0F4249, {1, "Jessie"}},
+		{0x0F424A, {1, "Mike"}},
+		{0x0F424B, {1, "Mrs. Incredible"}},
+		{0x0F424C, {1, "Hector Barbossa"}},
+		{0x0F424D, {1, "Davy Jones"}},
+		{0x0F424E, {1, "Randy"}},
+		{0x0F424F, {1, "Syndrome"}},
+		{0x0F4250, {1, "Woody"}},
+		{0x0F4251, {1, "Mater"}},
+		{0x0F4252, {1, "Dash"}},
+		{0x0F4253, {1, "Violet"}},
+		{0x0F4254, {1, "Francesco Bernoulli"}},
+		{0x0F4255, {1, "Sorcerer's Apprentice Mickey"}},
+		{0x0F4256, {1, "Jack Skellington"}},
+		{0x0F4257, {1, "Rapunzel"}},
+		{0x0F4258, {1, "Anna"}},
+		{0x0F4259, {1, "Elsa"}},
+		{0x0F425A, {1, "Phineas"}},
+		{0x0F425B, {1, "Agent P"}},
+		{0x0F425C, {1, "Wreck-It Ralph"}},
+		{0x0F425D, {1, "Vanellope"}},
+		{0x0F425E, {1, "Mr. Incredible (Crystal)"}},
+		{0x0F425F, {1, "Jack Sparrow (Crystal)"}},
+		{0x0F4260, {1, "Sulley (Crystal)"}},
+		{0x0F4261, {1, "Lightning McQueen (Crystal)"}},
+		{0x0F4262, {1, "Lone Ranger (Crystal)"}},
+		{0x0F4263, {1, "Buzz Lightyear (Crystal)"}},
+		{0x0F4264, {1, "Agent P (Crystal)"}},
+		{0x0F4265, {1, "Sorcerer's Apprentice Mickey (Crystal)"}},
+		{0x0F4266, {1, "Buzz Lightyear (Glowing)"}},
+		{0x0F42A4, {2, "Captain America"}},
+		{0x0F42A5, {2, "Hulk"}},
+		{0x0F42A6, {2, "Iron Man"}},
+		{0x0F42A7, {2, "Thor"}},
+		{0x0F42A8, {2, "Groot"}},
+		{0x0F42A9, {2, "Rocket Raccoon"}},
+		{0x0F42AA, {2, "Star-Lord"}},
+		{0x0F42AB, {2, "Spider-Man"}},
+		{0x0F42AC, {2, "Nick Fury"}},
+		{0x0F42AD, {2, "Black Widow"}},
+		{0x0F42AE, {2, "Hawkeye"}},
+		{0x0F42AF, {2, "Drax"}},
+		{0x0F42B0, {2, "Gamora"}},
+		{0x0F42B1, {2, "Iron Fist"}},
+		{0x0F42B2, {2, "Nova"}},
+		{0x0F42B3, {2, "Venom"}},
+		{0x0F42B4, {2, "Donald Duck"}},
+		{0x0F42B5, {2, "Aladdin"}},
+		{0x0F42B6, {2, "Stitch"}},
+		{0x0F42B7, {2, "Merida"}},
+		{0x0F42B8, {2, "Tinker Bell"}},
+		{0x0F42B9, {2, "Maleficent"}},
+		{0x0F42BA, {2, "Hiro"}},
+		{0x0F42BB, {2, "Baymax"}},
+		{0x0F42BC, {2, "Loki"}},
+		{0x0F42BD, {2, "Ronan"}},
+		{0x0F42BE, {2, "Green Goblin"}},
+		{0x0F42BF, {2, "Falcon"}},
+		{0x0F42C0, {2, "Yondu"}},
+		{0x0F42C1, {2, "Jasmine"}},
+		{0x0F42C6, {2, "Black Suit Spider-Man"}},
+		{0x0F42D6, {3, "Sam Flynn"}},
+		{0x0F42D7, {3, "Quorra"}},
+		{0x0F4308, {3, "Anakin Skywalker"}},
+		{0x0F4309, {3, "Obi-Wan Kenobi"}},
+		{0x0F430A, {3, "Yoda"}},
+		{0x0F430B, {3, "Ahsoka Tano"}},
+		{0x0F430C, {3, "Darth Maul"}},
+		{0x0F430E, {3, "Luke Skywalker"}},
+		{0x0F430F, {3, "Han Solo"}},
+		{0x0F4310, {3, "Princess Leia"}},
+		{0x0F4311, {3, "Chewbacca"}},
+		{0x0F4312, {3, "Darth Vader"}},
+		{0x0F4313, {3, "Boba Fett"}},
+		{0x0F4314, {3, "Ezra Bridger"}},
+		{0x0F4315, {3, "Kanan Jarrus"}},
+		{0x0F4316, {3, "Sabine Wren"}},
+		{0x0F4317, {3, "Zeb Orrelios"}},
+		{0x0F4318, {3, "Joy"}},
+		{0x0F4319, {3, "Anger"}},
+		{0x0F431A, {3, "Fear"}},
+		{0x0F431B, {3, "Sadness"}},
+		{0x0F431C, {3, "Disgust"}},
+		{0x0F431D, {3, "Mickey Mouse"}},
+		{0x0F431E, {3, "Minnie Mouse"}},
+		{0x0F431F, {3, "Mulan"}},
+		{0x0F4320, {3, "Olaf"}},
+		{0x0F4321, {3, "Vision"}},
+		{0x0F4322, {3, "Ultron"}},
+		{0x0F4323, {3, "Ant-Man"}},
+		{0x0F4325, {3, "Captain America - The First Avenger"}},
+		{0x0F4326, {3, "Finn"}},
+		{0x0F4327, {3, "Kylo Ren"}},
+		{0x0F4328, {3, "Poe Dameron"}},
+		{0x0F4329, {3, "Rey"}},
+		{0x0F432B, {3, "Spot"}},
+		{0x0F432C, {3, "Nick Wilde"}},
+		{0x0F432D, {3, "Judy Hopps"}},
+		{0x0F432E, {3, "Hulkbuster"}},
+		{0x0F432F, {3, "Anakin Skywalker (Light FX)"}},
+		{0x0F4330, {3, "Obi-Wan Kenobi (Light FX)"}},
+		{0x0F4331, {3, "Yoda (Light FX)"}},
+		{0x0F4332, {3, "Luke Skywalker (Light FX)"}},
+		{0x0F4333, {3, "Darth Vader (Light FX)"}},
+		{0x0F4334, {3, "Kanan Jarrus (Light FX)"}},
+		{0x0F4335, {3, "Kylo Ren (Light FX)"}},
+		{0x0F4336, {3, "Black Panther"}},
+		{0x0F436C, {3, "Nemo"}},
+		{0x0F436D, {3, "Dory"}},
+		{0x0F436E, {3, "Baloo"}},
+		{0x0F436F, {3, "Alice"}},
+		{0x0F4370, {3, "Mad Hatter"}},
+		{0x0F4371, {3, "Time"}},
+		{0x0F4372, {3, "Peter Pan"}},
+		{0x1E8481, {1, "Starter Play Set"}},
+		{0x1E8482, {1, "Lone Ranger Play Set"}},
+		{0x1E8483, {1, "Cars Play Set"}},
+		{0x1E8484, {1, "Toy Story in Space Play Set"}},
+		{0x1E84E4, {2, "Marvel's The Avengers Play Set"}},
+		{0x1E84E5, {2, "Marvel's Spider-Man Play Set"}},
+		{0x1E84E6, {2, "Marvel's Guardians of the Galaxy Play Set"}},
+		{0x1E84E7, {2, "Assault on Asgard"}},
+		{0x1E84E8, {2, "Escape from the Kyln"}},
+		{0x1E84E9, {2, "Stitch's Tropical Rescue"}},
+		{0x1E84EA, {2, "Brave Forest Siege"}},
+		{0x1E8548, {3, "Inside Out Play Set"}},
+		{0x1E8549, {3, "Star Wars: Twilight of the Republic Play Set"}},
+		{0x1E854A, {3, "Star Wars: Rise Against the Empire Play Set"}},
+		{0x1E854B, {3, "Star Wars: The Force Awakens Play Set"}},
+		{0x1E854C, {3, "Marvel Battlegrounds Play Set"}},
+		{0x1E854D, {3, "Toy Box Speedway"}},
+		{0x1E854E, {3, "Toy Box Takeover"}},
+		{0x1E85AC, {3, "Finding Dory Play Set"}},
+		{0x2DC6C3, {1, "Bolt's Super Strength"}},
+		{0x2DC6C4, {1, "Ralph's Power of Destruction"}},
+		{0x2DC6C5, {1, "Chernabog's Power"}},
+		{0x2DC6C6, {1, "C.H.R.O.M.E. Damage Increaser"}},
+		{0x2DC6C7, {1, "Dr. Doofenshmirtz's Damage-Inator!"}},
+		{0x2DC6C8, {1, "Electro-Charge"}},
+		{0x2DC6C9, {1, "Fix-It Felix's Repair Power"}},
+		{0x2DC6CA, {1, "Rapunzel's Healing"}},
+		{0x2DC6CB, {1, "C.H.R.O.M.E. Armor Shield"}},
+		{0x2DC6CC, {1, "Star Command Shield"}},
+		{0x2DC6CD, {1, "Violet's Force Field"}},
+		{0x2DC6CE, {1, "Pieces of Eight"}},
+		{0x2DC6CF, {1, "Scrooge McDuck's Lucky Dime"}},
+		{0x2DC6D0, {1, "User Control"}},
+		{0x2DC6D1, {1, "Sorcerer Mickey's Hat"}},
+		{0x2DC6FE, {1, "Emperor Zurg's Wrath"}},
+		{0x2DC6FF, {1, "Merlin's Summon"}},
+		{0x2DC765, {2, "Enchanted Rose"}},
+		{0x2DC766, {2, "Mulan's Training Uniform"}},
+		{0x2DC767, {2, "Flubber"}},
+		{0x2DC768, {2, "S.H.I.E.L.D. Helicarrier Strike"}},
+		{0x2DC769, {2, "Zeus' Thunderbolts"}},
+		{0x2DC76A, {2, "King Louie's Monkeys"}},
+		{0x2DC76B, {2, "Infinity Gauntlet"}},
+		{0x2DC76D, {2, "Sorcerer Supreme"}},
+		{0x2DC76E, {2, "Maleficent's Spell Cast"}},
+		{0x2DC76F, {2, "Chernabog's Spirit Cyclone"}},
+		{0x2DC770, {2, "Marvel Team-Up: Capt. Marvel"}},
+		{0x2DC771, {2, "Marvel Team-Up: Iron Patriot"}},
+		{0x2DC772, {2, "Marvel Team-Up: Ant-Man"}},
+		{0x2DC773, {2, "Marvel Team-Up: White Tiger"}},
+		{0x2DC774, {2, "Marvel Team-Up: Yondu"}},
+		{0x2DC775, {2, "Marvel Team-Up: Winter Soldier"}},
+		{0x2DC776, {2, "Stark Arc Reactor"}},
+		{0x2DC777, {2, "Gamma Rays"}},
+		{0x2DC778, {2, "Alien Symbiote"}},
+		{0x2DC779, {2, "All for One"}},
+		{0x2DC77A, {2, "Sandy Claws Surprise"}},
+		{0x2DC77B, {2, "Glory Days"}},
+		{0x2DC77C, {2, "Cursed Pirate Gold"}},
+		{0x2DC77D, {2, "Sentinel of Liberty"}},
+		{0x2DC77E, {2, "The Immortal Iron Fist"}},
+		{0x2DC77F, {2, "Space Armor"}},
+		{0x2DC780, {2, "Rags to Riches"}},
+		{0x2DC781, {2, "Ultimate Falcon"}},
+		{0x2DC788, {3, "Tomorrowland Time Bomb"}},
+		{0x2DC78E, {3, "Galactic Team-Up: Mace Windu"}},
+		{0x2DC791, {3, "Luke's Rebel Alliance Flight Suit Costume"}},
+		{0x2DC798, {3, "Finn's Stormtrooper Costume"}},
+		{0x2DC799, {3, "Poe's Resistance Jacket"}},
+		{0x2DC79A, {3, "Resistance Tactical Strike"}},
+		{0x2DC79E, {3, "Officer Nick Wilde"}},
+		{0x2DC79F, {3, "Meter Maid Judy"}},
+		{0x2DC7A2, {3, "Darkhawk's Blast"}},
+		{0x2DC7A3, {3, "Cosmic Cube Blast"}},
+		{0x2DC7A4, {3, "Princess Leia's Boushh Disguise"}},
+		{0x2DC7A6, {3, "Nova Corps Strike"}},
+		{0x2DC7A7, {3, "King Mickey"}},
+		{0x3D0912, {1, "Mickey's Car"}},
+		{0x3D0913, {1, "Cinderella's Coach"}},
+		{0x3D0914, {1, "Electric Mayhem Bus"}},
+		{0x3D0915, {1, "Cruella De Vil's Car"}},
+		{0x3D0916, {1, "Pizza Planet Delivery Truck"}},
+		{0x3D0917, {1, "Mike's New Car"}},
+		{0x3D0919, {1, "Parking Lot Tram"}},
+		{0x3D091A, {1, "Captain Hook's Ship"}},
+		{0x3D091B, {1, "Dumbo"}},
+		{0x3D091C, {1, "Calico Helicopter"}},
+		{0x3D091D, {1, "Maximus"}},
+		{0x3D091E, {1, "Angus"}},
+		{0x3D091F, {1, "Abu the Elephant"}},
+		{0x3D0920, {1, "Headless Horseman's Horse"}},
+		{0x3D0921, {1, "Phillipe"}},
+		{0x3D0922, {1, "Khan"}},
+		{0x3D0923, {1, "Tantor"}},
+		{0x3D0924, {1, "Dragon Firework Cannon"}},
+		{0x3D0925, {1, "Stitch's Blaster"}},
+		{0x3D0926, {1, "Toy Story Mania Blaster"}},
+		{0x3D0927, {1, "Flamingo Croquet Mallet"}},
+		{0x3D0928, {1, "Carl Fredricksen's Cane"}},
+		{0x3D0929, {1, "Hangin' Ten Stitch With Surfboard"}},
+		{0x3D092A, {1, "Condorman Glider"}},
+		{0x3D092B, {1, "WALL-E's Fire Extinguisher"}},
+		{0x3D092C, {1, "On the Grid"}},
+		{0x3D092D, {1, "WALL-E's Collection"}},
+		{0x3D092E, {1, "King Candy's Dessert Toppings"}},
+		{0x3D0930, {1, "Victor's Experiments"}},
+		{0x3D0931, {1, "Jack's Scary Decorations"}},
+		{0x3D0933, {1, "Frozen Flourish"}},
+		{0x3D0934, {1, "Rapunzel's Kingdom"}},
+		{0x3D0935, {1, "TRON Interface"}},
+		{0x3D0936, {1, "Buy N Large Atmosphere"}},
+		{0x3D0937, {1, "Sugar Rush Sky"}},
+		{0x3D0939, {1, "New Holland Skyline"}},
+		{0x3D093A, {1, "Halloween Town Sky"}},
+		{0x3D093C, {1, "Chill in the Air"}},
+		{0x3D093D, {1, "Rapunzel's Birthday Sky"}},
+		{0x3D0940, {1, "Astro Blasters Space Cruiser"}},
+		{0x3D0941, {1, "Marlin's Reef"}},
+		{0x3D0942, {1, "Nemo's Seascape"}},
+		{0x3D0943, {1, "Alice's Wonderland"}},
+		{0x3D0944, {1, "Tulgey Wood"}},
+		{0x3D0945, {1, "Tri-State Area Terrain"}},
+		{0x3D0946, {1, "Danville Sky"}},
+		{0x3D0965, {2, "Stark Tech"}},
+		{0x3D0966, {2, "Spider-Streets"}},
+		{0x3D0967, {2, "World War Hulk"}},
+		{0x3D0968, {2, "Gravity Falls Forest"}},
+		{0x3D0969, {2, "Neverland"}},
+		{0x3D096A, {2, "Simba's Pridelands"}},
+		{0x3D096C, {2, "Calhoun's Command"}},
+		{0x3D096D, {2, "Star-Lord's Galaxy"}},
+		{0x3D096E, {2, "Dinosaur World"}},
+		{0x3D096F, {2, "Groot's Roots"}},
+		{0x3D0970, {2, "Mulan's Countryside"}},
+		{0x3D0971, {2, "The Sands of Agrabah"}},
+		{0x3D0974, {2, "A Small World"}},
+		{0x3D0975, {2, "View from the Suit"}},
+		{0x3D0976, {2, "Spider-Sky"}},
+		{0x3D0977, {2, "World War Hulk Sky"}},
+		{0x3D0978, {2, "Gravity Falls Sky"}},
+		{0x3D0979, {2, "Second Star to the Right"}},
+		{0x3D097A, {2, "The King's Domain"}},
+		{0x3D097C, {2, "CyBug Swarm"}},
+		{0x3D097D, {2, "The Rip"}},
+		{0x3D097E, {2, "Forgotten Skies"}},
+		{0x3D097F, {2, "Groot's View"}},
+		{0x3D0980, {2, "The Middle Kingdom"}},
+		{0x3D0984, {2, "Skies of the World"}},
+		{0x3D0985, {2, "S.H.I.E.L.D. Containment Truck"}},
+		{0x3D0986, {2, "Main Street Electrical Parade Float"}},
+		{0x3D0987, {2, "Mr. Toad's Motorcar"}},
+		{0x3D0988, {2, "Le Maximum"}},
+		{0x3D0989, {2, "Alice in Wonderland's Caterpillar"}},
+		{0x3D098A, {2, "Eglantine's Motorcycle"}},
+		{0x3D098B, {2, "Medusa's Swamp Mobile"}},
+		{0x3D098C, {2, "Hydra Motorcycle"}},
+		{0x3D098D, {2, "Darkwing Duck's Ratcatcher"}},
+		{0x3D098F, {2, "The USS Swinetrek"}},
+		{0x3D0991, {2, "Spider-Copter"}},
+		{0x3D0992, {2, "Aerial Area Rug"}},
+		{0x3D0993, {2, "Jack-O-Lantern's Glider"}},
+		{0x3D0994, {2, "Spider-Buggy"}},
+		{0x3D0995, {2, "Jack Skellington's Reindeer"}},
+		{0x3D0996, {2, "Fantasyland Carousel Horse"}},
+		{0x3D0997, {2, "Odin's Horse"}},
+		{0x3D0998, {2, "Gus the Mule"}},
+		{0x3D099A, {2, "Darkwing Duck's Grappling Gun"}},
+		{0x3D099C, {2, "Ghost Rider's Chain Whip"}},
+		{0x3D099D, {2, "Lew Zealand's Boomerang Fish"}},
+		{0x3D099E, {2, "Sergeant Calhoun's Blaster"}},
+		{0x3D09A0, {2, "Falcon's Wings"}},
+		{0x3D09A1, {2, "Mabel's Kittens for Fists"}},
+		{0x3D09A2, {2, "Jim Hawkins' Solar Board"}},
+		{0x3D09A3, {2, "Black Panther's Vibranium Knives"}},
+		{0x3D09A4, {2, "Cloak of Levitation"}},
+		{0x3D09A5, {2, "Aladdin's Magic Carpet"}},
+		{0x3D09A6, {2, "Honey Lemon's Ice Capsules"}},
+		{0x3D09A7, {2, "Jasmine's Palace View"}},
+		{0x3D09C1, {2, "Lola"}},
+		{0x3D09C2, {2, "Spider-Cycle"}},
+		{0x3D09C3, {2, "The Avenjet"}},
+		{0x3D09C4, {2, "Spider-Glider"}},
+		{0x3D09C5, {2, "Light Cycle"}},
+		{0x3D09C6, {2, "Light Jet"}},
+		{0x3D09C9, {3, "Retro Ray Gun"}},
+		{0x3D09CA, {3, "Tomorrowland Futurescape"}},
+		{0x3D09CB, {3, "Tomorrowland Stratosphere"}},
+		{0x3D09CC, {3, "Skies Over Felucia"}},
+		{0x3D09CD, {3, "Forests of Felucia"}},
+		{0x3D09CF, {3, "General Grievous' Wheel Bike"}},
+		{0x3D09D2, {3, "Slave I Flyer"}},
+		{0x3D09D3, {3, "Y-Wing Fighter"}},
+		{0x3D09D4, {3, "Arlo"}},
+		{0x3D09D5, {3, "Nash"}},
+		{0x3D09D6, {3, "Butch"}},
+		{0x3D09D7, {3, "Ramsey"}},
+		{0x3D09DC, {3, "Stars Over Sahara Square"}},
+		{0x3D09DD, {3, "Sahara Square Sands"}},
+		{0x3D09E0, {3, "Ghost Rider's Motorcycle"}},
+		{0x3D09E5, {3, "Quad Jumper"}}};
+
+	InfinityBaseDevice::InfinityBaseDevice()
+		: Device(0x0E6F, 0x0129, 1, 2, 0)
+	{
+		m_IsOpened = false;
+	}
+
+	bool InfinityBaseDevice::Open()
+	{
+		if (!IsOpened())
+		{
+			m_IsOpened = true;
+		}
+		return true;
+	}
+
+	void InfinityBaseDevice::Close()
+	{
+		if (IsOpened())
+		{
+			m_IsOpened = false;
+		}
+	}
+
+	bool InfinityBaseDevice::IsOpened()
+	{
+		return m_IsOpened;
+	}
+
+	Device::ReadResult InfinityBaseDevice::Read(ReadMessage* message)
+	{
+		memcpy(message->data, g_infinitybase.GetStatus().data(), message->length);
+		message->bytesRead = message->length;
+		std::this_thread::sleep_for(std::chrono::milliseconds(1));
+		return Device::ReadResult::Success;
+	}
+
+	Device::WriteResult InfinityBaseDevice::Write(WriteMessage* message)
+	{
+		g_infinitybase.SendCommand(message->data, message->length);
+		message->bytesWritten = message->length;
+		return Device::WriteResult::Success;
+	}
+
+	bool InfinityBaseDevice::GetDescriptor(uint8 descType,
+										   uint8 descIndex,
+										   uint16 lang,
+										   uint8* output,
+										   uint32 outputMaxLength)
+	{
+		uint8 configurationDescriptor[0x29];
+
+		uint8* currentWritePtr;
+
+		// configuration descriptor
+		currentWritePtr = configurationDescriptor + 0;
+		*(uint8*)(currentWritePtr + 0) = 9;			// bLength
+		*(uint8*)(currentWritePtr + 1) = 2;			// bDescriptorType
+		*(uint16be*)(currentWritePtr + 2) = 0x0029; // wTotalLength
+		*(uint8*)(currentWritePtr + 4) = 1;			// bNumInterfaces
+		*(uint8*)(currentWritePtr + 5) = 1;			// bConfigurationValue
+		*(uint8*)(currentWritePtr + 6) = 0;			// iConfiguration
+		*(uint8*)(currentWritePtr + 7) = 0x80;		// bmAttributes
+		*(uint8*)(currentWritePtr + 8) = 0xFA;		// MaxPower
+		currentWritePtr = currentWritePtr + 9;
+		// configuration descriptor
+		*(uint8*)(currentWritePtr + 0) = 9;	   // bLength
+		*(uint8*)(currentWritePtr + 1) = 0x04; // bDescriptorType
+		*(uint8*)(currentWritePtr + 2) = 0;	   // bInterfaceNumber
+		*(uint8*)(currentWritePtr + 3) = 0;	   // bAlternateSetting
+		*(uint8*)(currentWritePtr + 4) = 2;	   // bNumEndpoints
+		*(uint8*)(currentWritePtr + 5) = 3;	   // bInterfaceClass
+		*(uint8*)(currentWritePtr + 6) = 0;	   // bInterfaceSubClass
+		*(uint8*)(currentWritePtr + 7) = 0;	   // bInterfaceProtocol
+		*(uint8*)(currentWritePtr + 8) = 0;	   // iInterface
+		currentWritePtr = currentWritePtr + 9;
+		// configuration descriptor
+		*(uint8*)(currentWritePtr + 0) = 9;			// bLength
+		*(uint8*)(currentWritePtr + 1) = 0x21;		// bDescriptorType
+		*(uint16be*)(currentWritePtr + 2) = 0x0111; // bcdHID
+		*(uint8*)(currentWritePtr + 4) = 0x00;		// bCountryCode
+		*(uint8*)(currentWritePtr + 5) = 0x01;		// bNumDescriptors
+		*(uint8*)(currentWritePtr + 6) = 0x22;		// bDescriptorType
+		*(uint16be*)(currentWritePtr + 7) = 0x001D; // wDescriptorLength
+		currentWritePtr = currentWritePtr + 9;
+		// endpoint descriptor 1
+		*(uint8*)(currentWritePtr + 0) = 7;		  // bLength
+		*(uint8*)(currentWritePtr + 1) = 0x05;	  // bDescriptorType
+		*(uint8*)(currentWritePtr + 2) = 0x81;	  // bEndpointAddress
+		*(uint8*)(currentWritePtr + 3) = 0x03;	  // bmAttributes
+		*(uint16be*)(currentWritePtr + 4) = 0x40; // wMaxPacketSize
+		*(uint8*)(currentWritePtr + 6) = 0x01;	  // bInterval
+		currentWritePtr = currentWritePtr + 7;
+		// endpoint descriptor 2
+		*(uint8*)(currentWritePtr + 0) = 7;		  // bLength
+		*(uint8*)(currentWritePtr + 1) = 0x05;	  // bDescriptorType
+		*(uint8*)(currentWritePtr + 1) = 0x02;	  // bEndpointAddress
+		*(uint8*)(currentWritePtr + 2) = 0x03;	  // bmAttributes
+		*(uint16be*)(currentWritePtr + 3) = 0x40; // wMaxPacketSize
+		*(uint8*)(currentWritePtr + 5) = 0x01;	  // bInterval
+		currentWritePtr = currentWritePtr + 7;
+
+		cemu_assert_debug((currentWritePtr - configurationDescriptor) == 0x29);
+
+		memcpy(output, configurationDescriptor,
+			   std::min<uint32>(outputMaxLength, sizeof(configurationDescriptor)));
+		return true;
+	}
+
+	bool InfinityBaseDevice::SetIdle(uint8 ifIndex,
+										 uint8 reportId,
+										 uint8 duration)
+	{
+		return true;
+	}
+
+	bool InfinityBaseDevice::SetProtocol(uint8 ifIndex, uint8 protocol)
+	{
+		return true;
+	}
+
+	bool InfinityBaseDevice::SetReport(ReportMessage* message)
+	{
+		return true;
+	}
+
+	std::array<uint8, 32> InfinityUSB::GetStatus()
+	{
+		std::array<uint8, 32> response = {};
+
+		bool responded = false;
+
+		do
+		{
+			if (!m_figureAddedRemovedResponses.empty())
+			{
+				memcpy(response.data(), m_figureAddedRemovedResponses.front().data(),
+					   0x20);
+				m_figureAddedRemovedResponses.pop();
+				responded = true;
+			}
+			else if (!m_queries.empty())
+			{
+				memcpy(response.data(), m_queries.front().data(), 0x20);
+				m_queries.pop();
+				responded = true;
+			}
+			else
+			{
+				std::this_thread::sleep_for(std::chrono::milliseconds(100));
+			}
+			/* code */
+		}
+		while (!responded);
+
+		return response;
+	}
+
+	void InfinityUSB::SendCommand(uint8* buf, uint32 length)
+	{
+		const uint8 command = buf[2];
+		const uint8 sequence = buf[3];
+
+		std::array<uint8, 32> q_result{};
+
+		switch (command)
+		{
+		case 0x80:
+		{
+			q_result = {0xaa, 0x15, 0x00, 0x00, 0x0f, 0x01, 0x00, 0x03,
+						0x02, 0x09, 0x09, 0x43, 0x20, 0x32, 0x62, 0x36,
+						0x36, 0x4b, 0x34, 0x99, 0x67, 0x31, 0x93, 0x8c};
+			break;
+		}
+		case 0x81:
+		{
+			// Initiate Challenge
+			g_infinitybase.DescrambleAndSeed(buf, sequence, q_result);
+			break;
+		}
+		case 0x83:
+		{
+			// Challenge Response
+			g_infinitybase.GetNextAndScramble(sequence, q_result);
+			break;
+		}
+		case 0x90:
+		case 0x92:
+		case 0x93:
+		case 0x95:
+		case 0x96:
+		{
+			// Color commands
+			g_infinitybase.GetBlankResponse(sequence, q_result);
+			break;
+		}
+		case 0xA1:
+		{
+			// Get Present Figures
+			g_infinitybase.GetPresentFigures(sequence, q_result);
+			break;
+		}
+		case 0xA2:
+		{
+			// Read Block from Figure
+			g_infinitybase.QueryBlock(buf[4], buf[5], q_result, sequence);
+			break;
+		}
+		case 0xA3:
+		{
+			// Write block to figure
+			g_infinitybase.WriteBlock(buf[4], buf[5], &buf[7], q_result, sequence);
+			break;
+		}
+		case 0xB4:
+		{
+			// Get figure ID
+			g_infinitybase.GetFigureIdentifier(buf[4], sequence, q_result);
+			break;
+		}
+		case 0xB5:
+		{
+			// Get status?
+			g_infinitybase.GetBlankResponse(sequence, q_result);
+			break;
+		}
+		default:
+			cemu_assert_error();
+			break;
+		}
+
+		m_queries.push(q_result);
+	}
+
+	uint8 InfinityUSB::GenerateChecksum(const std::array<uint8, 32>& data,
+										int numOfBytes) const
+	{
+		int checksum = 0;
+		for (int i = 0; i < numOfBytes; i++)
+		{
+			checksum += data[i];
+		}
+		return (checksum & 0xFF);
+	}
+
+	void InfinityUSB::GetBlankResponse(uint8 sequence,
+									   std::array<uint8, 32>& replyBuf)
+	{
+		replyBuf[0] = 0xaa;
+		replyBuf[1] = 0x01;
+		replyBuf[2] = sequence;
+		replyBuf[3] = GenerateChecksum(replyBuf, 3);
+	}
+
+	void InfinityUSB::DescrambleAndSeed(uint8* buf, uint8 sequence,
+										std::array<uint8, 32>& replyBuf)
+	{
+		uint64 value = uint64(buf[4]) << 56 | uint64(buf[5]) << 48 |
+					   uint64(buf[6]) << 40 | uint64(buf[7]) << 32 |
+					   uint64(buf[8]) << 24 | uint64(buf[9]) << 16 |
+					   uint64(buf[10]) << 8 | uint64(buf[11]);
+		uint32 seed = Descramble(value);
+		GenerateSeed(seed);
+		GetBlankResponse(sequence, replyBuf);
+	}
+
+	void InfinityUSB::GetNextAndScramble(uint8 sequence,
+										 std::array<uint8, 32>& replyBuf)
+	{
+		const uint32 nextRandom = GetNext();
+		const uint64 scrambledNextRandom = Scramble(nextRandom, 0);
+		replyBuf = {0xAA, 0x09, sequence};
+		replyBuf[3] = uint8((scrambledNextRandom >> 56) & 0xFF);
+		replyBuf[4] = uint8((scrambledNextRandom >> 48) & 0xFF);
+		replyBuf[5] = uint8((scrambledNextRandom >> 40) & 0xFF);
+		replyBuf[6] = uint8((scrambledNextRandom >> 32) & 0xFF);
+		replyBuf[7] = uint8((scrambledNextRandom >> 24) & 0xFF);
+		replyBuf[8] = uint8((scrambledNextRandom >> 16) & 0xFF);
+		replyBuf[9] = uint8((scrambledNextRandom >> 8) & 0xFF);
+		replyBuf[10] = uint8(scrambledNextRandom & 0xFF);
+		replyBuf[11] = GenerateChecksum(replyBuf, 11);
+	}
+
+	uint32 InfinityUSB::Descramble(uint64 numToDescramble)
+	{
+		uint64 mask = 0x8E55AA1B3999E8AA;
+		uint32 ret = 0;
+
+		for (int i = 0; i < 64; i++)
+		{
+			if (mask & 0x8000000000000000)
+			{
+				ret = (ret << 1) | (numToDescramble & 0x01);
+			}
+
+			numToDescramble >>= 1;
+			mask <<= 1;
+		}
+
+		return ret;
+	}
+
+	uint64 InfinityUSB::Scramble(uint32 numToScramble, uint32 garbage)
+	{
+		uint64 mask = 0x8E55AA1B3999E8AA;
+		uint64 ret = 0;
+
+		for (int i = 0; i < 64; i++)
+		{
+			ret <<= 1;
+
+			if ((mask & 1) != 0)
+			{
+				ret |= (numToScramble & 1);
+				numToScramble >>= 1;
+			}
+			else
+			{
+				ret |= (garbage & 1);
+				garbage >>= 1;
+			}
+
+			mask >>= 1;
+		}
+
+		return ret;
+	}
+
+	void InfinityUSB::GenerateSeed(uint32 seed)
+	{
+		m_randomA = 0xF1EA5EED;
+		m_randomB = seed;
+		m_randomC = seed;
+		m_randomD = seed;
+
+		for (int i = 0; i < 23; i++)
+		{
+			GetNext();
+		}
+	}
+
+	uint32 InfinityUSB::GetNext()
+	{
+		uint32 a = m_randomA;
+		uint32 b = m_randomB;
+		uint32 c = m_randomC;
+		uint32 ret = std::rotl(m_randomB, 27);
+
+		const uint32 temp = (a + ((ret ^ 0xFFFFFFFF) + 1));
+		b ^= std::rotl(c, 17);
+		a = m_randomD;
+		c += a;
+		ret = b + temp;
+		a += temp;
+
+		m_randomC = a;
+		m_randomA = b;
+		m_randomB = c;
+		m_randomD = ret;
+
+		return ret;
+	}
+
+	void InfinityUSB::GetPresentFigures(uint8 sequence,
+										std::array<uint8, 32>& replyBuf)
+	{
+		int x = 3;
+		for (uint8 i = 0; i < m_figures.size(); i++)
+		{
+			uint8 slot = i == 0 ? 0x10 : (i < 4) ? 0x20
+												 : 0x30;
+			if (m_figures[i].present)
+			{
+				replyBuf[x] = slot + m_figures[i].orderAdded;
+				replyBuf[x + 1] = 0x09;
+				x += 2;
+			}
+		}
+		replyBuf[0] = 0xaa;
+		replyBuf[1] = x - 2;
+		replyBuf[2] = sequence;
+		replyBuf[x] = GenerateChecksum(replyBuf, x);
+	}
+
+	InfinityUSB::InfinityFigure&
+	InfinityUSB::GetFigureByOrder(uint8 orderAdded)
+	{
+		for (uint8 i = 0; i < m_figures.size(); i++)
+		{
+			if (m_figures[i].orderAdded == orderAdded)
+			{
+				return m_figures[i];
+			}
+		}
+		return m_figures[0];
+	}
+
+	void InfinityUSB::QueryBlock(uint8 fig_num, uint8 block,
+								 std::array<uint8, 32>& replyBuf,
+								 uint8 sequence)
+	{
+		std::lock_guard lock(m_infinityMutex);
+
+		InfinityFigure& figure = GetFigureByOrder(fig_num);
+
+		replyBuf[0] = 0xaa;
+		replyBuf[1] = 0x12;
+		replyBuf[2] = sequence;
+		replyBuf[3] = 0x00;
+		const uint8 file_block = (block == 0) ? 1 : (block * 4);
+		if (figure.present && file_block < 20)
+		{
+			memcpy(&replyBuf[4], figure.data.data() + (16 * file_block), 16);
+		}
+		replyBuf[20] = GenerateChecksum(replyBuf, 20);
+	}
+
+	void InfinityUSB::WriteBlock(uint8 fig_num, uint8 block,
+								 const uint8* to_write_buf,
+								 std::array<uint8, 32>& replyBuf,
+								 uint8 sequence)
+	{
+		std::lock_guard lock(m_infinityMutex);
+
+		InfinityFigure& figure = GetFigureByOrder(fig_num);
+
+		replyBuf[0] = 0xaa;
+		replyBuf[1] = 0x02;
+		replyBuf[2] = sequence;
+		replyBuf[3] = 0x00;
+		const uint8 file_block = (block == 0) ? 1 : (block * 4);
+		if (figure.present && file_block < 20)
+		{
+			memcpy(figure.data.data() + (file_block * 16), to_write_buf, 16);
+			figure.Save();
+		}
+		replyBuf[4] = GenerateChecksum(replyBuf, 4);
+	}
+
+	void InfinityUSB::GetFigureIdentifier(uint8 fig_num, uint8 sequence,
+										  std::array<uint8, 32>& replyBuf)
+	{
+		std::lock_guard lock(m_infinityMutex);
+
+		InfinityFigure& figure = GetFigureByOrder(fig_num);
+
+		replyBuf[0] = 0xaa;
+		replyBuf[1] = 0x09;
+		replyBuf[2] = sequence;
+		replyBuf[3] = 0x00;
+
+		if (figure.present)
+		{
+			memcpy(&replyBuf[4], figure.data.data(), 7);
+		}
+		replyBuf[11] = GenerateChecksum(replyBuf, 11);
+	}
+
+	std::pair<uint8, std::string> InfinityUSB::FindFigure(uint32 figNum)
+	{
+		for (const auto& it : GetFigureList())
+		{
+			if (it.first == figNum)
+			{
+				return it.second;
+			}
+		}
+		return {0, fmt::format("Unknown Figure ({})", figNum)};
+	}
+
+	std::map<const uint32, const std::pair<const uint8, const char*>> InfinityUSB::GetFigureList()
+	{
+		return s_listFigures;
+	}
+
+	void InfinityUSB::InfinityFigure::Save()
+	{
+		if (!infFile)
+			return;
+
+		infFile->SetPosition(0);
+		infFile->writeData(data.data(), data.size());
+	}
+
+	bool InfinityUSB::RemoveFigure(uint8 position)
+	{
+		std::lock_guard lock(m_infinityMutex);
+		InfinityFigure& figure = m_figures[position];
+
+		figure.Save();
+		figure.infFile.reset();
+
+		if (figure.present)
+		{
+			figure.present = false;
+
+			position = DeriveFigurePosition(position);
+			if (position == 0)
+			{
+				return false;
+			}
+
+			std::array<uint8, 32> figureChangeResponse = {0xab, 0x04, position, 0x09, figure.orderAdded,
+														  0x01};
+			figureChangeResponse[6] = GenerateChecksum(figureChangeResponse, 6);
+			m_figureAddedRemovedResponses.push(figureChangeResponse);
+
+			return true;
+		}
+		return false;
+	}
+
+	uint32
+	InfinityUSB::LoadFigure(const std::array<uint8, INF_FIGURE_SIZE>& buf,
+							std::unique_ptr<FileStream> inFile, uint8 position)
+	{
+		std::lock_guard lock(m_infinityMutex);
+		uint8 orderAdded;
+
+		std::vector<uint8> sha1Calc = {SHA1_CONSTANT.begin(), SHA1_CONSTANT.end() - 1};
+		for (int i = 0; i < 7; i++)
+		{
+			sha1Calc.push_back(buf[i]);
+		}
+
+		std::array<uint8, 16> key = GenerateInfinityFigureKey(sha1Calc);
+
+		std::array<uint8, 16> infinity_decrypted_block = {};
+		std::array<uint8, 16> encryptedBlock = {};
+		memcpy(encryptedBlock.data(), &buf[16], 16);
+
+		AES128_ECB_decrypt(encryptedBlock.data(), key.data(), infinity_decrypted_block.data());
+
+		uint32 number = uint32(infinity_decrypted_block[1]) << 16 | uint32(infinity_decrypted_block[2]) << 8 |
+						uint32(infinity_decrypted_block[3]);
+
+		InfinityFigure& figure = m_figures[position];
+
+		figure.infFile = std::move(inFile);
+		memcpy(figure.data.data(), buf.data(), figure.data.size());
+		figure.present = true;
+		if (figure.orderAdded == 255)
+		{
+			figure.orderAdded = m_figureOrder;
+			m_figureOrder++;
+		}
+		orderAdded = figure.orderAdded;
+
+		position = DeriveFigurePosition(position);
+		if (position == 0)
+		{
+			return 0;
+		}
+
+		std::array<uint8, 32> figureChangeResponse = {0xab, 0x04, position, 0x09, orderAdded, 0x00};
+		figureChangeResponse[6] = GenerateChecksum(figureChangeResponse, 6);
+		m_figureAddedRemovedResponses.push(figureChangeResponse);
+
+		return number;
+	}
+
+	static uint32 InfinityCRC32(const std::array<uint8, 16>& buffer)
+	{
+		static constexpr std::array<uint32, 256> CRC32_TABLE{
+			0x00000000, 0x77073096, 0xee0e612c, 0x990951ba, 0x076dc419, 0x706af48f, 0xe963a535,
+			0x9e6495a3, 0x0edb8832, 0x79dcb8a4, 0xe0d5e91e, 0x97d2d988, 0x09b64c2b, 0x7eb17cbd,
+			0xe7b82d07, 0x90bf1d91, 0x1db71064, 0x6ab020f2, 0xf3b97148, 0x84be41de, 0x1adad47d,
+			0x6ddde4eb, 0xf4d4b551, 0x83d385c7, 0x136c9856, 0x646ba8c0, 0xfd62f97a, 0x8a65c9ec,
+			0x14015c4f, 0x63066cd9, 0xfa0f3d63, 0x8d080df5, 0x3b6e20c8, 0x4c69105e, 0xd56041e4,
+			0xa2677172, 0x3c03e4d1, 0x4b04d447, 0xd20d85fd, 0xa50ab56b, 0x35b5a8fa, 0x42b2986c,
+			0xdbbbc9d6, 0xacbcf940, 0x32d86ce3, 0x45df5c75, 0xdcd60dcf, 0xabd13d59, 0x26d930ac,
+			0x51de003a, 0xc8d75180, 0xbfd06116, 0x21b4f4b5, 0x56b3c423, 0xcfba9599, 0xb8bda50f,
+			0x2802b89e, 0x5f058808, 0xc60cd9b2, 0xb10be924, 0x2f6f7c87, 0x58684c11, 0xc1611dab,
+			0xb6662d3d, 0x76dc4190, 0x01db7106, 0x98d220bc, 0xefd5102a, 0x71b18589, 0x06b6b51f,
+			0x9fbfe4a5, 0xe8b8d433, 0x7807c9a2, 0x0f00f934, 0x9609a88e, 0xe10e9818, 0x7f6a0dbb,
+			0x086d3d2d, 0x91646c97, 0xe6635c01, 0x6b6b51f4, 0x1c6c6162, 0x856530d8, 0xf262004e,
+			0x6c0695ed, 0x1b01a57b, 0x8208f4c1, 0xf50fc457, 0x65b0d9c6, 0x12b7e950, 0x8bbeb8ea,
+			0xfcb9887c, 0x62dd1ddf, 0x15da2d49, 0x8cd37cf3, 0xfbd44c65, 0x4db26158, 0x3ab551ce,
+			0xa3bc0074, 0xd4bb30e2, 0x4adfa541, 0x3dd895d7, 0xa4d1c46d, 0xd3d6f4fb, 0x4369e96a,
+			0x346ed9fc, 0xad678846, 0xda60b8d0, 0x44042d73, 0x33031de5, 0xaa0a4c5f, 0xdd0d7cc9,
+			0x5005713c, 0x270241aa, 0xbe0b1010, 0xc90c2086, 0x5768b525, 0x206f85b3, 0xb966d409,
+			0xce61e49f, 0x5edef90e, 0x29d9c998, 0xb0d09822, 0xc7d7a8b4, 0x59b33d17, 0x2eb40d81,
+			0xb7bd5c3b, 0xc0ba6cad, 0xedb88320, 0x9abfb3b6, 0x03b6e20c, 0x74b1d29a, 0xead54739,
+			0x9dd277af, 0x04db2615, 0x73dc1683, 0xe3630b12, 0x94643b84, 0x0d6d6a3e, 0x7a6a5aa8,
+			0xe40ecf0b, 0x9309ff9d, 0x0a00ae27, 0x7d079eb1, 0xf00f9344, 0x8708a3d2, 0x1e01f268,
+			0x6906c2fe, 0xf762575d, 0x806567cb, 0x196c3671, 0x6e6b06e7, 0xfed41b76, 0x89d32be0,
+			0x10da7a5a, 0x67dd4acc, 0xf9b9df6f, 0x8ebeeff9, 0x17b7be43, 0x60b08ed5, 0xd6d6a3e8,
+			0xa1d1937e, 0x38d8c2c4, 0x4fdff252, 0xd1bb67f1, 0xa6bc5767, 0x3fb506dd, 0x48b2364b,
+			0xd80d2bda, 0xaf0a1b4c, 0x36034af6, 0x41047a60, 0xdf60efc3, 0xa867df55, 0x316e8eef,
+			0x4669be79, 0xcb61b38c, 0xbc66831a, 0x256fd2a0, 0x5268e236, 0xcc0c7795, 0xbb0b4703,
+			0x220216b9, 0x5505262f, 0xc5ba3bbe, 0xb2bd0b28, 0x2bb45a92, 0x5cb36a04, 0xc2d7ffa7,
+			0xb5d0cf31, 0x2cd99e8b, 0x5bdeae1d, 0x9b64c2b0, 0xec63f226, 0x756aa39c, 0x026d930a,
+			0x9c0906a9, 0xeb0e363f, 0x72076785, 0x05005713, 0x95bf4a82, 0xe2b87a14, 0x7bb12bae,
+			0x0cb61b38, 0x92d28e9b, 0xe5d5be0d, 0x7cdcefb7, 0x0bdbdf21, 0x86d3d2d4, 0xf1d4e242,
+			0x68ddb3f8, 0x1fda836e, 0x81be16cd, 0xf6b9265b, 0x6fb077e1, 0x18b74777, 0x88085ae6,
+			0xff0f6a70, 0x66063bca, 0x11010b5c, 0x8f659eff, 0xf862ae69, 0x616bffd3, 0x166ccf45,
+			0xa00ae278, 0xd70dd2ee, 0x4e048354, 0x3903b3c2, 0xa7672661, 0xd06016f7, 0x4969474d,
+			0x3e6e77db, 0xaed16a4a, 0xd9d65adc, 0x40df0b66, 0x37d83bf0, 0xa9bcae53, 0xdebb9ec5,
+			0x47b2cf7f, 0x30b5ffe9, 0xbdbdf21c, 0xcabac28a, 0x53b39330, 0x24b4a3a6, 0xbad03605,
+			0xcdd70693, 0x54de5729, 0x23d967bf, 0xb3667a2e, 0xc4614ab8, 0x5d681b02, 0x2a6f2b94,
+			0xb40bbe37, 0xc30c8ea1, 0x5a05df1b, 0x2d02ef8d};
+
+		// Infinity m_figures calculate their CRC32 based on 12 bytes in the block of 16
+		uint32 ret = 0;
+		for (uint32 i = 0; i < 12; ++i)
+		{
+			uint8 index = uint8(ret & 0xFF) ^ buffer[i];
+			ret = ((ret >> 8) ^ CRC32_TABLE[index]);
+		}
+
+		return ret;
+	}
+
+	bool InfinityUSB::CreateFigure(fs::path pathName, uint32 figureNum, uint8 series)
+	{
+		FileStream* infFile(FileStream::createFile2(pathName));
+		if (!infFile)
+		{
+			return false;
+		}
+		std::array<uint8, INF_FIGURE_SIZE> fileData{};
+		uint32 firstBlock = 0x17878E;
+		uint32 otherBlocks = 0x778788;
+		for (sint8 i = 2; i >= 0; i--)
+		{
+			fileData[0x38 - i] = uint8((firstBlock >> i * 8) & 0xFF);
+		}
+		for (uint32 index = 1; index < 0x05; index++)
+		{
+			for (sint8 i = 2; i >= 0; i--)
+			{
+				fileData[((index * 0x40) + 0x38) - i] = uint8((otherBlocks >> i * 8) & 0xFF);
+			}
+		}
+		// Create the vector to calculate the SHA1 hash with
+		std::vector<uint8> sha1Calc = {SHA1_CONSTANT.begin(), SHA1_CONSTANT.end() - 1};
+
+		// Generate random UID, used for AES encrypt/decrypt
+		std::random_device rd;
+		std::mt19937 mt(rd());
+		std::uniform_int_distribution<int> dist(0, 255);
+		std::array<uint8, 16> uid_data = {0, 0, 0, 0, 0, 0, 0, 0x89, 0x44, 0x00, 0xC2};
+		uid_data[0] = dist(mt);
+		uid_data[1] = dist(mt);
+		uid_data[2] = dist(mt);
+		uid_data[3] = dist(mt);
+		uid_data[4] = dist(mt);
+		uid_data[5] = dist(mt);
+		uid_data[6] = dist(mt);
+		for (sint8 i = 0; i < 7; i++)
+		{
+			sha1Calc.push_back(uid_data[i]);
+		}
+		std::array<uint8, 16> figureData = GenerateBlankFigureData(figureNum, series);
+		if (figureData[1] == 0x00)
+			return false;
+
+		std::array<uint8, 16> key = GenerateInfinityFigureKey(sha1Calc);
+
+		std::array<uint8, 16> encryptedBlock = {};
+		std::array<uint8, 16> blankBlock = {};
+		std::array<uint8, 16> encryptedBlank = {};
+
+		AES128_ECB_encrypt(figureData.data(), key.data(), encryptedBlock.data());
+		AES128_ECB_encrypt(blankBlock.data(), key.data(), encryptedBlank.data());
+
+		memcpy(&fileData[0], uid_data.data(), uid_data.size());
+		memcpy(&fileData[16], encryptedBlock.data(), encryptedBlock.size());
+		memcpy(&fileData[16 * 0x04], encryptedBlank.data(), encryptedBlank.size());
+		memcpy(&fileData[16 * 0x08], encryptedBlank.data(), encryptedBlank.size());
+		memcpy(&fileData[16 * 0x0C], encryptedBlank.data(), encryptedBlank.size());
+		memcpy(&fileData[16 * 0x0D], encryptedBlank.data(), encryptedBlank.size());
+
+		infFile->writeData(fileData.data(), fileData.size());
+
+		delete infFile;
+
+		return true;
+	}
+
+	std::array<uint8, 16> InfinityUSB::GenerateInfinityFigureKey(const std::vector<uint8>& sha1Data)
+	{
+		std::array<uint8, 20> digest = {};
+		SHA1(sha1Data.data(), sha1Data.size(), digest.data());
+		// Infinity AES keys are the first 16 bytes of the SHA1 Digest, every set of 4 bytes need to be
+		// reversed due to endianness
+		std::array<uint8, 16> key = {};
+		for (int i = 0; i < 4; i++)
+		{
+			for (int x = 3; x >= 0; x--)
+			{
+				key[(3 - x) + (i * 4)] = digest[x + (i * 4)];
+			}
+		}
+		return key;
+	}
+
+	std::array<uint8, 16> InfinityUSB::GenerateBlankFigureData(uint32 figureNum, uint8 series)
+	{
+		std::array<uint8, 16> figureData = {0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+											0x00, 0x00, 0x00, 0x01, 0xD1, 0x1F};
+
+		// Figure Number, input by end user
+		figureData[1] = uint8((figureNum >> 16) & 0xFF);
+		figureData[2] = uint8((figureNum >> 8) & 0xFF);
+		figureData[3] = uint8(figureNum & 0xFF);
+
+		// Manufacture date, formatted as YY/MM/DD. Set to release date of figure's series
+		if (series == 1)
+		{
+			figureData[4] = 0x0D;
+			figureData[5] = 0x08;
+			figureData[6] = 0x12;
+		}
+		else if (series == 2)
+		{
+			figureData[4] = 0x0E;
+			figureData[5] = 0x09;
+			figureData[6] = 0x12;
+		}
+		else if (series == 3)
+		{
+			figureData[4] = 0x0F;
+			figureData[5] = 0x08;
+			figureData[6] = 0x1C;
+		}
+
+		uint32 checksum = InfinityCRC32(figureData);
+		for (sint8 i = 3; i >= 0; i--)
+		{
+			figureData[15 - i] = uint8((checksum >> i * 8) & 0xFF);
+		}
+		return figureData;
+	}
+
+	uint8 InfinityUSB::DeriveFigurePosition(uint8 position)
+	{
+		// In the added/removed response, position needs to be 1 for the hexagon, 2 for Player 1 and
+		// Player 1's abilities, and 3 for Player 2 and Player 2's abilities. In the UI, positions 0, 1
+		// and 2 represent the hexagon slot, 3, 4 and 5 represent Player 1's slot and 6, 7 and 8 represent
+		// Player 2's slot.
+
+		switch (position)
+		{
+		case 0:
+		case 1:
+		case 2:
+			return 1;
+		case 3:
+		case 4:
+		case 5:
+			return 2;
+		case 6:
+		case 7:
+		case 8:
+			return 3;
+
+		default:
+			return 0;
+		}
+	}
+} // namespace nsyshid
\ No newline at end of file
diff --git a/src/Cafe/OS/libs/nsyshid/Infinity.h b/src/Cafe/OS/libs/nsyshid/Infinity.h
new file mode 100644
index 00000000..81942abd
--- /dev/null
+++ b/src/Cafe/OS/libs/nsyshid/Infinity.h
@@ -0,0 +1,109 @@
+#pragma once
+
+#include <mutex>
+
+#include "nsyshid.h"
+#include "Backend.h"
+
+#include "Common/FileStream.h"
+
+namespace nsyshid
+{
+	class InfinityBaseDevice final : public Device {
+	  public:
+		InfinityBaseDevice();
+		~InfinityBaseDevice() = default;
+
+		bool Open() override;
+
+		void Close() override;
+
+		bool IsOpened() override;
+
+		ReadResult Read(ReadMessage* message) override;
+
+		WriteResult Write(WriteMessage* message) override;
+
+		bool GetDescriptor(uint8 descType,
+						   uint8 descIndex,
+						   uint16 lang,
+						   uint8* output,
+						   uint32 outputMaxLength) override;
+
+		bool SetIdle(uint8 ifIndex,
+					 uint8 reportId,
+					 uint8 duration) override;
+
+		bool SetProtocol(uint8 ifIndex, uint8 protocol) override;
+
+		bool SetReport(ReportMessage* message) override;
+
+	  private:
+		bool m_IsOpened;
+	};
+
+	constexpr uint16 INF_BLOCK_COUNT = 0x14;
+	constexpr uint16 INF_BLOCK_SIZE = 0x10;
+	constexpr uint16 INF_FIGURE_SIZE = INF_BLOCK_COUNT * INF_BLOCK_SIZE;
+	constexpr uint8 MAX_FIGURES = 9;
+	class InfinityUSB {
+	  public:
+		struct InfinityFigure final
+		{
+			std::unique_ptr<FileStream> infFile;
+			std::array<uint8, INF_FIGURE_SIZE> data{};
+			bool present = false;
+			uint8 orderAdded = 255;
+			void Save();
+		};
+
+		void SendCommand(uint8* buf, uint32 length);
+		std::array<uint8, 32> GetStatus();
+
+		void GetBlankResponse(uint8 sequence, std::array<uint8, 32>& replyBuf);
+		void DescrambleAndSeed(uint8* buf, uint8 sequence,
+							   std::array<uint8, 32>& replyBuf);
+		void GetNextAndScramble(uint8 sequence, std::array<uint8, 32>& replyBuf);
+		void GetPresentFigures(uint8 sequence, std::array<uint8, 32>& replyBuf);
+		void QueryBlock(uint8 figNum, uint8 block, std::array<uint8, 32>& replyBuf,
+						uint8 sequence);
+		void WriteBlock(uint8 figNum, uint8 block, const uint8* toWriteBuf,
+						std::array<uint8, 32>& replyBuf, uint8 sequence);
+		void GetFigureIdentifier(uint8 figNum, uint8 sequence,
+								 std::array<uint8, 32>& replyBuf);
+
+		bool RemoveFigure(uint8 position);
+		uint32 LoadFigure(const std::array<uint8, INF_FIGURE_SIZE>& buf,
+						  std::unique_ptr<FileStream>, uint8 position);
+		bool CreateFigure(fs::path pathName, uint32 figureNum, uint8 series);
+		static std::map<const uint32, const std::pair<const uint8, const char*>> GetFigureList();
+		std::pair<uint8, std::string> FindFigure(uint32 figNum);
+
+	  protected:
+		std::shared_mutex m_infinityMutex;
+		std::array<InfinityFigure, 9> m_figures;
+
+	  private:
+		uint8 GenerateChecksum(const std::array<uint8, 32>& data,
+							   int numOfBytes) const;
+		uint32 Descramble(uint64 numToDescramble);
+		uint64 Scramble(uint32 numToScramble, uint32 garbage);
+		void GenerateSeed(uint32 seed);
+		uint32 GetNext();
+		InfinityFigure& GetFigureByOrder(uint8 orderAdded);
+		uint8 DeriveFigurePosition(uint8 position);
+		std::array<uint8, 16> GenerateInfinityFigureKey(const std::vector<uint8>& sha1Data);
+		std::array<uint8, 16> GenerateBlankFigureData(uint32 figureNum, uint8 series);
+
+		uint32 m_randomA;
+		uint32 m_randomB;
+		uint32 m_randomC;
+		uint32 m_randomD;
+
+		uint8 m_figureOrder = 0;
+		std::queue<std::array<uint8, 32>> m_figureAddedRemovedResponses;
+		std::queue<std::array<uint8, 32>> m_queries;
+	};
+	extern InfinityUSB g_infinitybase;
+
+} // namespace nsyshid
\ No newline at end of file
diff --git a/src/Cafe/OS/libs/nsyshid/Skylander.cpp b/src/Cafe/OS/libs/nsyshid/Skylander.cpp
new file mode 100644
index 00000000..78337962
--- /dev/null
+++ b/src/Cafe/OS/libs/nsyshid/Skylander.cpp
@@ -0,0 +1,1031 @@
+#include "Skylander.h"
+
+#include <random>
+
+#include "nsyshid.h"
+#include "Backend.h"
+
+#include "Common/FileStream.h"
+#include "audio/IAudioAPI.h"
+#include "config/CemuConfig.h"
+
+namespace nsyshid
+{
+	SkylanderUSB g_skyportal;
+
+	const std::map<const std::pair<const uint16, const uint16>, const char*>
+		s_listSkylanders = {
+			{{0, 0x0000}, "Whirlwind"},
+			{{0, 0x1801}, "Series 2 Whirlwind"},
+			{{0, 0x1C02}, "Polar Whirlwind"},
+			{{0, 0x2805}, "Horn Blast Whirlwind"},
+			{{0, 0x3810}, "Eon's Elite Whirlwind"},
+			{{1, 0x0000}, "Sonic Boom"},
+			{{1, 0x1801}, "Series 2 Sonic Boom"},
+			{{2, 0x0000}, "Warnado"},
+			{{2, 0x2206}, "LightCore Warnado"},
+			{{3, 0x0000}, "Lightning Rod"},
+			{{3, 0x1801}, "Series 2 Lightning Rod"},
+			{{4, 0x0000}, "Bash"},
+			{{4, 0x1801}, "Series 2 Bash"},
+			{{5, 0x0000}, "Terrafin"},
+			{{5, 0x1801}, "Series 2 Terrafin"},
+			{{5, 0x2805}, "Knockout Terrafin"},
+			{{5, 0x3810}, "Eon's Elite Terrafin"},
+			{{6, 0x0000}, "Dino Rang"},
+			{{6, 0x4810}, "Eon's Elite Dino Rang"},
+			{{7, 0x0000}, "Prism Break"},
+			{{7, 0x1801}, "Series 2 Prism Break"},
+			{{7, 0x2805}, "Hyper Beam Prism Break"},
+			{{7, 0x1206}, "LightCore Prism Break"},
+			{{8, 0x0000}, "Sunburn"},
+			{{9, 0x0000}, "Eruptor"},
+			{{9, 0x1801}, "Series 2 Eruptor"},
+			{{9, 0x2C02}, "Volcanic Eruptor"},
+			{{9, 0x2805}, "Lava Barf Eruptor"},
+			{{9, 0x1206}, "LightCore Eruptor"},
+			{{9, 0x3810}, "Eon's Elite Eruptor"},
+			{{10, 0x0000}, "Ignitor"},
+			{{10, 0x1801}, "Series 2 Ignitor"},
+			{{10, 0x1C03}, "Legendary Ignitor"},
+			{{11, 0x0000}, "Flameslinger"},
+			{{11, 0x1801}, "Series 2 Flameslinger"},
+			{{12, 0x0000}, "Zap"},
+			{{12, 0x1801}, "Series 2 Zap"},
+			{{13, 0x0000}, "Wham Shell"},
+			{{13, 0x2206}, "LightCore Wham Shell"},
+			{{14, 0x0000}, "Gill Grunt"},
+			{{14, 0x1801}, "Series 2 Gill Grunt"},
+			{{14, 0x2805}, "Anchors Away Gill Grunt"},
+			{{14, 0x3805}, "Tidal Wave Gill Grunt"},
+			{{14, 0x3810}, "Eon's Elite Gill Grunt"},
+			{{15, 0x0000}, "Slam Bam"},
+			{{15, 0x1801}, "Series 2 Slam Bam"},
+			{{15, 0x1C03}, "Legendary Slam Bam"},
+			{{15, 0x4810}, "Eon's Elite Slam Bam"},
+			{{16, 0x0000}, "Spyro"},
+			{{16, 0x1801}, "Series 2 Spyro"},
+			{{16, 0x2C02}, "Dark Mega Ram Spyro"},
+			{{16, 0x2805}, "Mega Ram Spyro"},
+			{{16, 0x3810}, "Eon's Elite Spyro"},
+			{{17, 0x0000}, "Voodood"},
+			{{17, 0x4810}, "Eon's Elite Voodood"},
+			{{18, 0x0000}, "Double Trouble"},
+			{{18, 0x1801}, "Series 2 Double Trouble"},
+			{{18, 0x1C02}, "Royal Double Trouble"},
+			{{19, 0x0000}, "Trigger Happy"},
+			{{19, 0x1801}, "Series 2 Trigger Happy"},
+			{{19, 0x2C02}, "Springtime Trigger Happy"},
+			{{19, 0x2805}, "Big Bang Trigger Happy"},
+			{{19, 0x3810}, "Eon's Elite Trigger Happy"},
+			{{20, 0x0000}, "Drobot"},
+			{{20, 0x1801}, "Series 2 Drobot"},
+			{{20, 0x1206}, "LightCore Drobot"},
+			{{21, 0x0000}, "Drill Seargeant"},
+			{{21, 0x1801}, "Series 2 Drill Seargeant"},
+			{{22, 0x0000}, "Boomer"},
+			{{22, 0x4810}, "Eon's Elite Boomer"},
+			{{23, 0x0000}, "Wrecking Ball"},
+			{{23, 0x1801}, "Series 2 Wrecking Ball"},
+			{{24, 0x0000}, "Camo"},
+			{{24, 0x2805}, "Thorn Horn Camo"},
+			{{25, 0x0000}, "Zook"},
+			{{25, 0x1801}, "Series 2 Zook"},
+			{{25, 0x4810}, "Eon's Elite Zook"},
+			{{26, 0x0000}, "Stealth Elf"},
+			{{26, 0x1801}, "Series 2 Stealth Elf"},
+			{{26, 0x2C02}, "Dark Stealth Elf"},
+			{{26, 0x1C03}, "Legendary Stealth Elf"},
+			{{26, 0x2805}, "Ninja Stealth Elf"},
+			{{26, 0x3810}, "Eon's Elite Stealth Elf"},
+			{{27, 0x0000}, "Stump Smash"},
+			{{27, 0x1801}, "Series 2 Stump Smash"},
+			{{28, 0x0000}, "Dark Spyro"},
+			{{29, 0x0000}, "Hex"},
+			{{29, 0x1801}, "Series 2 Hex"},
+			{{29, 0x1206}, "LightCore Hex"},
+			{{30, 0x0000}, "Chop Chop"},
+			{{30, 0x1801}, "Series 2 Chop Chop"},
+			{{30, 0x2805}, "Twin Blade Chop Chop"},
+			{{30, 0x3810}, "Eon's Elite Chop Chop"},
+			{{31, 0x0000}, "Ghost Roaster"},
+			{{31, 0x4810}, "Eon's Elite Ghost Roaster"},
+			{{32, 0x0000}, "Cynder"},
+			{{32, 0x1801}, "Series 2 Cynder"},
+			{{32, 0x2805}, "Phantom Cynder"},
+			{{100, 0x0000}, "Jet Vac"},
+			{{100, 0x1403}, "Legendary Jet Vac"},
+			{{100, 0x2805}, "Turbo Jet Vac"},
+			{{100, 0x3805}, "Full Blast Jet Vac"},
+			{{100, 0x1206}, "LightCore Jet Vac"},
+			{{101, 0x0000}, "Swarm"},
+			{{102, 0x0000}, "Crusher"},
+			{{102, 0x1602}, "Granite Crusher"},
+			{{103, 0x0000}, "Flashwing"},
+			{{103, 0x1402}, "Jade Flash Wing"},
+			{{103, 0x2206}, "LightCore Flashwing"},
+			{{104, 0x0000}, "Hot Head"},
+			{{105, 0x0000}, "Hot Dog"},
+			{{105, 0x1402}, "Molten Hot Dog"},
+			{{105, 0x2805}, "Fire Bone Hot Dog"},
+			{{106, 0x0000}, "Chill"},
+			{{106, 0x1603}, "Legendary Chill"},
+			{{106, 0x2805}, "Blizzard Chill"},
+			{{106, 0x1206}, "LightCore Chill"},
+			{{107, 0x0000}, "Thumpback"},
+			{{108, 0x0000}, "Pop Fizz"},
+			{{108, 0x1402}, "Punch Pop Fizz"},
+			{{108, 0x3C02}, "Love Potion Pop Fizz"},
+			{{108, 0x2805}, "Super Gulp Pop Fizz"},
+			{{108, 0x3805}, "Fizzy Frenzy Pop Fizz"},
+			{{108, 0x1206}, "LightCore Pop Fizz"},
+			{{109, 0x0000}, "Ninjini"},
+			{{109, 0x1602}, "Scarlet Ninjini"},
+			{{110, 0x0000}, "Bouncer"},
+			{{110, 0x1603}, "Legendary Bouncer"},
+			{{111, 0x0000}, "Sprocket"},
+			{{111, 0x2805}, "Heavy Duty Sprocket"},
+			{{112, 0x0000}, "Tree Rex"},
+			{{112, 0x1602}, "Gnarly Tree Rex"},
+			{{113, 0x0000}, "Shroomboom"},
+			{{113, 0x3805}, "Sure Shot Shroomboom"},
+			{{113, 0x1206}, "LightCore Shroomboom"},
+			{{114, 0x0000}, "Eye Brawl"},
+			{{115, 0x0000}, "Fright Rider"},
+			{{200, 0x0000}, "Anvil Rain"},
+			{{201, 0x0000}, "Hidden Treasure"},
+			{{201, 0x2000}, "Platinum Hidden Treasure"},
+			{{202, 0x0000}, "Healing Elixir"},
+			{{203, 0x0000}, "Ghost Pirate Swords"},
+			{{204, 0x0000}, "Time Twist Hourglass"},
+			{{205, 0x0000}, "Sky Iron Shield"},
+			{{206, 0x0000}, "Winged Boots"},
+			{{207, 0x0000}, "Sparx the Dragonfly"},
+			{{208, 0x0000}, "Dragonfire Cannon"},
+			{{208, 0x1602}, "Golden Dragonfire Cannon"},
+			{{209, 0x0000}, "Scorpion Striker"},
+			{{210, 0x3002}, "Biter's Bane"},
+			{{210, 0x3008}, "Sorcerous Skull"},
+			{{210, 0x300B}, "Axe of Illusion"},
+			{{210, 0x300E}, "Arcane Hourglass"},
+			{{210, 0x3012}, "Spell Slapper"},
+			{{210, 0x3014}, "Rune Rocket"},
+			{{211, 0x3001}, "Tidal Tiki"},
+			{{211, 0x3002}, "Wet Walter"},
+			{{211, 0x3006}, "Flood Flask"},
+			{{211, 0x3406}, "Legendary Flood Flask"},
+			{{211, 0x3007}, "Soaking Staff"},
+			{{211, 0x300B}, "Aqua Axe"},
+			{{211, 0x3016}, "Frost Helm"},
+			{{212, 0x3003}, "Breezy Bird"},
+			{{212, 0x3006}, "Drafty Decanter"},
+			{{212, 0x300D}, "Tempest Timer"},
+			{{212, 0x3010}, "Cloudy Cobra"},
+			{{212, 0x3011}, "Storm Warning"},
+			{{212, 0x3018}, "Cyclone Saber"},
+			{{213, 0x3004}, "Spirit Sphere"},
+			{{213, 0x3404}, "Legendary Spirit Sphere"},
+			{{213, 0x3008}, "Spectral Skull"},
+			{{213, 0x3408}, "Legendary Spectral Skull"},
+			{{213, 0x300B}, "Haunted Hatchet"},
+			{{213, 0x300C}, "Grim Gripper"},
+			{{213, 0x3010}, "Spooky Snake"},
+			{{213, 0x3017}, "Dream Piercer"},
+			{{214, 0x3000}, "Tech Totem"},
+			{{214, 0x3007}, "Automatic Angel"},
+			{{214, 0x3009}, "Factory Flower"},
+			{{214, 0x300C}, "Grabbing Gadget"},
+			{{214, 0x3016}, "Makers Mana"},
+			{{214, 0x301A}, "Topsy Techy"},
+			{{215, 0x3005}, "Eternal Flame"},
+			{{215, 0x3009}, "Fire Flower"},
+			{{215, 0x3011}, "Scorching Stopper"},
+			{{215, 0x3012}, "Searing Spinner"},
+			{{215, 0x3017}, "Spark Spear"},
+			{{215, 0x301B}, "Blazing Belch"},
+			{{216, 0x3000}, "Banded Boulder"},
+			{{216, 0x3003}, "Rock Hawk"},
+			{{216, 0x300A}, "Slag Hammer"},
+			{{216, 0x300E}, "Dust Of Time"},
+			{{216, 0x3013}, "Spinning Sandstorm"},
+			{{216, 0x301A}, "Rubble Trouble"},
+			{{217, 0x3003}, "Oak Eagle"},
+			{{217, 0x3005}, "Emerald Energy"},
+			{{217, 0x300A}, "Weed Whacker"},
+			{{217, 0x3010}, "Seed Serpent"},
+			{{217, 0x3018}, "Jade Blade"},
+			{{217, 0x301B}, "Shrub Shrieker"},
+			{{218, 0x3000}, "Dark Dagger"},
+			{{218, 0x3014}, "Shadow Spider"},
+			{{218, 0x301A}, "Ghastly Grimace"},
+			{{219, 0x3000}, "Shining Ship"},
+			{{219, 0x300F}, "Heavenly Hawk"},
+			{{219, 0x301B}, "Beam Scream"},
+			{{220, 0x301E}, "Kaos Trap"},
+			{{220, 0x351F}, "Ultimate Kaos Trap"},
+			{{230, 0x0000}, "Hand of Fate"},
+			{{230, 0x3403}, "Legendary Hand of Fate"},
+			{{231, 0x0000}, "Piggy Bank"},
+			{{232, 0x0000}, "Rocket Ram"},
+			{{233, 0x0000}, "Tiki Speaky"},
+			{{300, 0x0000}, "Dragon’s Peak"},
+			{{301, 0x0000}, "Empire of Ice"},
+			{{302, 0x0000}, "Pirate Seas"},
+			{{303, 0x0000}, "Darklight Crypt"},
+			{{304, 0x0000}, "Volcanic Vault"},
+			{{305, 0x0000}, "Mirror of Mystery"},
+			{{306, 0x0000}, "Nightmare Express"},
+			{{307, 0x0000}, "Sunscraper Spire"},
+			{{308, 0x0000}, "Midnight Museum"},
+			{{404, 0x0000}, "Legendary Bash"},
+			{{416, 0x0000}, "Legendary Spyro"},
+			{{419, 0x0000}, "Legendary Trigger Happy"},
+			{{430, 0x0000}, "Legendary Chop Chop"},
+			{{450, 0x0000}, "Gusto"},
+			{{451, 0x0000}, "Thunderbolt"},
+			{{452, 0x0000}, "Fling Kong"},
+			{{453, 0x0000}, "Blades"},
+			{{453, 0x3403}, "Legendary Blades"},
+			{{454, 0x0000}, "Wallop"},
+			{{455, 0x0000}, "Head Rush"},
+			{{455, 0x3402}, "Nitro Head Rush"},
+			{{456, 0x0000}, "Fist Bump"},
+			{{457, 0x0000}, "Rocky Roll"},
+			{{458, 0x0000}, "Wildfire"},
+			{{458, 0x3402}, "Dark Wildfire"},
+			{{459, 0x0000}, "Ka Boom"},
+			{{460, 0x0000}, "Trail Blazer"},
+			{{461, 0x0000}, "Torch"},
+			{{462, 0x3000}, "Snap Shot"},
+			{{462, 0x3402}, "Dark Snap Shot"},
+			{{463, 0x0000}, "Lob Star"},
+			{{463, 0x3402}, "Winterfest Lob-Star"},
+			{{464, 0x0000}, "Flip Wreck"},
+			{{465, 0x0000}, "Echo"},
+			{{466, 0x0000}, "Blastermind"},
+			{{467, 0x0000}, "Enigma"},
+			{{468, 0x0000}, "Deja Vu"},
+			{{468, 0x3403}, "Legendary Deja Vu"},
+			{{469, 0x0000}, "Cobra Candabra"},
+			{{469, 0x3402}, "King Cobra Cadabra"},
+			{{470, 0x0000}, "Jawbreaker"},
+			{{470, 0x3403}, "Legendary Jawbreaker"},
+			{{471, 0x0000}, "Gearshift"},
+			{{472, 0x0000}, "Chopper"},
+			{{473, 0x0000}, "Tread Head"},
+			{{474, 0x0000}, "Bushwack"},
+			{{474, 0x3403}, "Legendary Bushwack"},
+			{{475, 0x0000}, "Tuff Luck"},
+			{{476, 0x0000}, "Food Fight"},
+			{{476, 0x3402}, "Dark Food Fight"},
+			{{477, 0x0000}, "High Five"},
+			{{478, 0x0000}, "Krypt King"},
+			{{478, 0x3402}, "Nitro Krypt King"},
+			{{479, 0x0000}, "Short Cut"},
+			{{480, 0x0000}, "Bat Spin"},
+			{{481, 0x0000}, "Funny Bone"},
+			{{482, 0x0000}, "Knight Light"},
+			{{483, 0x0000}, "Spotlight"},
+			{{484, 0x0000}, "Knight Mare"},
+			{{485, 0x0000}, "Blackout"},
+			{{502, 0x0000}, "Bop"},
+			{{505, 0x0000}, "Terrabite"},
+			{{506, 0x0000}, "Breeze"},
+			{{508, 0x0000}, "Pet Vac"},
+			{{508, 0x3402}, "Power Punch Pet Vac"},
+			{{507, 0x0000}, "Weeruptor"},
+			{{507, 0x3402}, "Eggcellent Weeruptor"},
+			{{509, 0x0000}, "Small Fry"},
+			{{510, 0x0000}, "Drobit"},
+			{{519, 0x0000}, "Trigger Snappy"},
+			{{526, 0x0000}, "Whisper Elf"},
+			{{540, 0x0000}, "Barkley"},
+			{{540, 0x3402}, "Gnarly Barkley"},
+			{{541, 0x0000}, "Thumpling"},
+			{{514, 0x0000}, "Gill Runt"},
+			{{542, 0x0000}, "Mini-Jini"},
+			{{503, 0x0000}, "Spry"},
+			{{504, 0x0000}, "Hijinx"},
+			{{543, 0x0000}, "Eye Small"},
+			{{601, 0x0000}, "King Pen"},
+			{{602, 0x0000}, "Tri-Tip"},
+			{{603, 0x0000}, "Chopscotch"},
+			{{604, 0x0000}, "Boom Bloom"},
+			{{605, 0x0000}, "Pit Boss"},
+			{{606, 0x0000}, "Barbella"},
+			{{607, 0x0000}, "Air Strike"},
+			{{608, 0x0000}, "Ember"},
+			{{609, 0x0000}, "Ambush"},
+			{{610, 0x0000}, "Dr. Krankcase"},
+			{{611, 0x0000}, "Hood Sickle"},
+			{{612, 0x0000}, "Tae Kwon Crow"},
+			{{613, 0x0000}, "Golden Queen"},
+			{{614, 0x0000}, "Wolfgang"},
+			{{615, 0x0000}, "Pain-Yatta"},
+			{{616, 0x0000}, "Mysticat"},
+			{{617, 0x0000}, "Starcast"},
+			{{618, 0x0000}, "Buckshot"},
+			{{619, 0x0000}, "Aurora"},
+			{{620, 0x0000}, "Flare Wolf"},
+			{{621, 0x0000}, "Chompy Mage"},
+			{{622, 0x0000}, "Bad Juju"},
+			{{623, 0x0000}, "Grave Clobber"},
+			{{624, 0x0000}, "Blaster-Tron"},
+			{{625, 0x0000}, "Ro-Bow"},
+			{{626, 0x0000}, "Chain Reaction"},
+			{{627, 0x0000}, "Kaos"},
+			{{628, 0x0000}, "Wild Storm"},
+			{{629, 0x0000}, "Tidepool"},
+			{{630, 0x0000}, "Crash Bandicoot"},
+			{{631, 0x0000}, "Dr. Neo Cortex"},
+			{{1000, 0x0000}, "Boom Jet (Bottom)"},
+			{{1001, 0x0000}, "Free Ranger (Bottom)"},
+			{{1001, 0x2403}, "Legendary Free Ranger (Bottom)"},
+			{{1002, 0x0000}, "Rubble Rouser (Bottom)"},
+			{{1003, 0x0000}, "Doom Stone (Bottom)"},
+			{{1004, 0x0000}, "Blast Zone (Bottom)"},
+			{{1004, 0x2402}, "Dark Blast Zone (Bottom)"},
+			{{1005, 0x0000}, "Fire Kraken (Bottom)"},
+			{{1005, 0x2402}, "Jade Fire Kraken (Bottom)"},
+			{{1006, 0x0000}, "Stink Bomb (Bottom)"},
+			{{1007, 0x0000}, "Grilla Drilla (Bottom)"},
+			{{1008, 0x0000}, "Hoot Loop (Bottom)"},
+			{{1008, 0x2402}, "Enchanted Hoot Loop (Bottom)"},
+			{{1009, 0x0000}, "Trap Shadow (Bottom)"},
+			{{1010, 0x0000}, "Magna Charge (Bottom)"},
+			{{1010, 0x2402}, "Nitro Magna Charge (Bottom)"},
+			{{1011, 0x0000}, "Spy Rise (Bottom)"},
+			{{1012, 0x0000}, "Night Shift (Bottom)"},
+			{{1012, 0x2403}, "Legendary Night Shift (Bottom)"},
+			{{1013, 0x0000}, "Rattle Shake (Bottom)"},
+			{{1013, 0x2402}, "Quick Draw Rattle Shake (Bottom)"},
+			{{1014, 0x0000}, "Freeze Blade (Bottom)"},
+			{{1014, 0x2402}, "Nitro Freeze Blade (Bottom)"},
+			{{1015, 0x0000}, "Wash Buckler (Bottom)"},
+			{{1015, 0x2402}, "Dark Wash Buckler (Bottom)"},
+			{{2000, 0x0000}, "Boom Jet (Top)"},
+			{{2001, 0x0000}, "Free Ranger (Top)"},
+			{{2001, 0x2403}, "Legendary Free Ranger (Top)"},
+			{{2002, 0x0000}, "Rubble Rouser (Top)"},
+			{{2003, 0x0000}, "Doom Stone (Top)"},
+			{{2004, 0x0000}, "Blast Zone (Top)"},
+			{{2004, 0x2402}, "Dark Blast Zone (Top)"},
+			{{2005, 0x0000}, "Fire Kraken (Top)"},
+			{{2005, 0x2402}, "Jade Fire Kraken (Top)"},
+			{{2006, 0x0000}, "Stink Bomb (Top)"},
+			{{2007, 0x0000}, "Grilla Drilla (Top)"},
+			{{2008, 0x0000}, "Hoot Loop (Top)"},
+			{{2008, 0x2402}, "Enchanted Hoot Loop (Top)"},
+			{{2009, 0x0000}, "Trap Shadow (Top)"},
+			{{2010, 0x0000}, "Magna Charge (Top)"},
+			{{2010, 0x2402}, "Nitro Magna Charge (Top)"},
+			{{2011, 0x0000}, "Spy Rise (Top)"},
+			{{2012, 0x0000}, "Night Shift (Top)"},
+			{{2012, 0x2403}, "Legendary Night Shift (Top)"},
+			{{2013, 0x0000}, "Rattle Shake (Top)"},
+			{{2013, 0x2402}, "Quick Draw Rattle Shake (Top)"},
+			{{2014, 0x0000}, "Freeze Blade (Top)"},
+			{{2014, 0x2402}, "Nitro Freeze Blade (Top)"},
+			{{2015, 0x0000}, "Wash Buckler (Top)"},
+			{{2015, 0x2402}, "Dark Wash Buckler (Top)"},
+			{{3000, 0x0000}, "Scratch"},
+			{{3001, 0x0000}, "Pop Thorn"},
+			{{3002, 0x0000}, "Slobber Tooth"},
+			{{3002, 0x2402}, "Dark Slobber Tooth"},
+			{{3003, 0x0000}, "Scorp"},
+			{{3004, 0x0000}, "Fryno"},
+			{{3004, 0x3805}, "Hog Wild Fryno"},
+			{{3005, 0x0000}, "Smolderdash"},
+			{{3005, 0x2206}, "LightCore Smolderdash"},
+			{{3006, 0x0000}, "Bumble Blast"},
+			{{3006, 0x2402}, "Jolly Bumble Blast"},
+			{{3006, 0x2206}, "LightCore Bumble Blast"},
+			{{3007, 0x0000}, "Zoo Lou"},
+			{{3007, 0x2403}, "Legendary Zoo Lou"},
+			{{3008, 0x0000}, "Dune Bug"},
+			{{3009, 0x0000}, "Star Strike"},
+			{{3009, 0x2602}, "Enchanted Star Strike"},
+			{{3009, 0x2206}, "LightCore Star Strike"},
+			{{3010, 0x0000}, "Countdown"},
+			{{3010, 0x2402}, "Kickoff Countdown"},
+			{{3010, 0x2206}, "LightCore Countdown"},
+			{{3011, 0x0000}, "Wind Up"},
+			{{3011, 0x2404}, "Gear Head VVind Up"},
+			{{3012, 0x0000}, "Roller Brawl"},
+			{{3013, 0x0000}, "Grim Creeper"},
+			{{3013, 0x2603}, "Legendary Grim Creeper"},
+			{{3013, 0x2206}, "LightCore Grim Creeper"},
+			{{3014, 0x0000}, "Rip Tide"},
+			{{3015, 0x0000}, "Punk Shock"},
+			{{3200, 0x0000}, "Battle Hammer"},
+			{{3201, 0x0000}, "Sky Diamond"},
+			{{3202, 0x0000}, "Platinum Sheep"},
+			{{3203, 0x0000}, "Groove Machine"},
+			{{3204, 0x0000}, "UFO Hat"},
+			{{3300, 0x0000}, "Sheep Wreck Island"},
+			{{3301, 0x0000}, "Tower of Time"},
+			{{3302, 0x0000}, "Fiery Forge"},
+			{{3303, 0x0000}, "Arkeyan Crossbow"},
+			{{3220, 0x0000}, "Jet Stream"},
+			{{3221, 0x0000}, "Tomb Buggy"},
+			{{3222, 0x0000}, "Reef Ripper"},
+			{{3223, 0x0000}, "Burn Cycle"},
+			{{3224, 0x0000}, "Hot Streak"},
+			{{3224, 0x4402}, "Dark Hot Streak"},
+			{{3224, 0x4004}, "E3 Hot Streak"},
+			{{3224, 0x441E}, "Golden Hot Streak"},
+			{{3225, 0x0000}, "Shark Tank"},
+			{{3226, 0x0000}, "Thump Truck"},
+			{{3227, 0x0000}, "Crypt Crusher"},
+			{{3228, 0x0000}, "Stealth Stinger"},
+			{{3228, 0x4402}, "Nitro Stealth Stinger"},
+			{{3231, 0x0000}, "Dive Bomber"},
+			{{3231, 0x4402}, "Spring Ahead Dive Bomber"},
+			{{3232, 0x0000}, "Sky Slicer"},
+			{{3233, 0x0000}, "Clown Cruiser (Nintendo Only)"},
+			{{3233, 0x4402}, "Dark Clown Cruiser (Nintendo Only)"},
+			{{3234, 0x0000}, "Gold Rusher"},
+			{{3234, 0x4402}, "Power Blue Gold Rusher"},
+			{{3235, 0x0000}, "Shield Striker"},
+			{{3236, 0x0000}, "Sun Runner"},
+			{{3236, 0x4403}, "Legendary Sun Runner"},
+			{{3237, 0x0000}, "Sea Shadow"},
+			{{3237, 0x4402}, "Dark Sea Shadow"},
+			{{3238, 0x0000}, "Splatter Splasher"},
+			{{3238, 0x4402}, "Power Blue Splatter Splasher"},
+			{{3239, 0x0000}, "Soda Skimmer"},
+			{{3239, 0x4402}, "Nitro Soda Skimmer"},
+			{{3240, 0x0000}, "Barrel Blaster (Nintendo Only)"},
+			{{3240, 0x4402}, "Dark Barrel Blaster (Nintendo Only)"},
+			{{3241, 0x0000}, "Buzz Wing"},
+			{{3400, 0x0000}, "Fiesta"},
+			{{3400, 0x4515}, "Frightful Fiesta"},
+			{{3401, 0x0000}, "High Volt"},
+			{{3402, 0x0000}, "Splat"},
+			{{3402, 0x4502}, "Power Blue Splat"},
+			{{3406, 0x0000}, "Stormblade"},
+			{{3411, 0x0000}, "Smash Hit"},
+			{{3411, 0x4502}, "Steel Plated Smash Hit"},
+			{{3412, 0x0000}, "Spitfire"},
+			{{3412, 0x4502}, "Dark Spitfire"},
+			{{3413, 0x0000}, "Hurricane Jet Vac"},
+			{{3413, 0x4503}, "Legendary Hurricane Jet Vac"},
+			{{3414, 0x0000}, "Double Dare Trigger Happy"},
+			{{3414, 0x4502}, "Power Blue Double Dare Trigger Happy"},
+			{{3415, 0x0000}, "Super Shot Stealth Elf"},
+			{{3415, 0x4502}, "Dark Super Shot Stealth Elf"},
+			{{3416, 0x0000}, "Shark Shooter Terrafin"},
+			{{3417, 0x0000}, "Bone Bash Roller Brawl"},
+			{{3417, 0x4503}, "Legendary Bone Bash Roller Brawl"},
+			{{3420, 0x0000}, "Big Bubble Pop Fizz"},
+			{{3420, 0x450E}, "Birthday Bash Big Bubble Pop Fizz"},
+			{{3421, 0x0000}, "Lava Lance Eruptor"},
+			{{3422, 0x0000}, "Deep Dive Gill Grunt"},
+			{{3423, 0x0000}, "Turbo Charge Donkey Kong (Nintendo Only)"},
+			{{3423, 0x4502}, "Dark Turbo Charge Donkey Kong (Nintendo Only)"},
+			{{3424, 0x0000}, "Hammer Slam Bowser (Nintendo Only)"},
+			{{3424, 0x4502}, "Dark Hammer Slam Bowser (Nintendo Only)"},
+			{{3425, 0x0000}, "Dive-Clops"},
+			{{3425, 0x450E}, "Missile-Tow Dive-Clops"},
+			{{3426, 0x0000}, "Astroblast"},
+			{{3426, 0x4503}, "Legendary Astroblast"},
+			{{3427, 0x0000}, "Nightfall"},
+			{{3428, 0x0000}, "Thrillipede"},
+			{{3428, 0x450D}, "Eggcited Thrillipede"},
+			{{3500, 0x0000}, "Sky Trophy"},
+			{{3501, 0x0000}, "Land Trophy"},
+			{{3502, 0x0000}, "Sea Trophy"},
+			{{3503, 0x0000}, "Kaos Trophy"},
+	};
+
+	uint16 SkylanderUSB::SkylanderCRC16(uint16 initValue, const uint8* buffer, uint32 size)
+	{
+		const unsigned short CRC_CCITT_TABLE[256] = {0x0000, 0x1021, 0x2042, 0x3063, 0x4084, 0x50A5, 0x60C6, 0x70E7, 0x8108, 0x9129, 0xA14A, 0xB16B, 0xC18C, 0xD1AD, 0xE1CE, 0xF1EF, 0x1231, 0x0210, 0x3273,
+													 0x2252, 0x52B5, 0x4294, 0x72F7, 0x62D6, 0x9339, 0x8318, 0xB37B, 0xA35A, 0xD3BD, 0xC39C, 0xF3FF, 0xE3DE, 0x2462, 0x3443, 0x0420, 0x1401, 0x64E6, 0x74C7, 0x44A4, 0x5485, 0xA56A, 0xB54B, 0x8528,
+													 0x9509, 0xE5EE, 0xF5CF, 0xC5AC, 0xD58D, 0x3653, 0x2672, 0x1611, 0x0630, 0x76D7, 0x66F6, 0x5695, 0x46B4, 0xB75B, 0xA77A, 0x9719, 0x8738, 0xF7DF, 0xE7FE, 0xD79D, 0xC7BC, 0x48C4, 0x58E5, 0x6886,
+													 0x78A7, 0x0840, 0x1861, 0x2802, 0x3823, 0xC9CC, 0xD9ED, 0xE98E, 0xF9AF, 0x8948, 0x9969, 0xA90A, 0xB92B, 0x5AF5, 0x4AD4, 0x7AB7, 0x6A96, 0x1A71, 0x0A50, 0x3A33, 0x2A12, 0xDBFD, 0xCBDC, 0xFBBF,
+													 0xEB9E, 0x9B79, 0x8B58, 0xBB3B, 0xAB1A, 0x6CA6, 0x7C87, 0x4CE4, 0x5CC5, 0x2C22, 0x3C03, 0x0C60, 0x1C41, 0xEDAE, 0xFD8F, 0xCDEC, 0xDDCD, 0xAD2A, 0xBD0B, 0x8D68, 0x9D49, 0x7E97, 0x6EB6, 0x5ED5,
+													 0x4EF4, 0x3E13, 0x2E32, 0x1E51, 0x0E70, 0xFF9F, 0xEFBE, 0xDFDD, 0xCFFC, 0xBF1B, 0xAF3A, 0x9F59, 0x8F78, 0x9188, 0x81A9, 0xB1CA, 0xA1EB, 0xD10C, 0xC12D, 0xF14E, 0xE16F, 0x1080, 0x00A1, 0x30C2,
+													 0x20E3, 0x5004, 0x4025, 0x7046, 0x6067, 0x83B9, 0x9398, 0xA3FB, 0xB3DA, 0xC33D, 0xD31C, 0xE37F, 0xF35E, 0x02B1, 0x1290, 0x22F3, 0x32D2, 0x4235, 0x5214, 0x6277, 0x7256, 0xB5EA, 0xA5CB, 0x95A8,
+													 0x8589, 0xF56E, 0xE54F, 0xD52C, 0xC50D, 0x34E2, 0x24C3, 0x14A0, 0x0481, 0x7466, 0x6447, 0x5424, 0x4405, 0xA7DB, 0xB7FA, 0x8799, 0x97B8, 0xE75F, 0xF77E, 0xC71D, 0xD73C, 0x26D3, 0x36F2, 0x0691,
+													 0x16B0, 0x6657, 0x7676, 0x4615, 0x5634, 0xD94C, 0xC96D, 0xF90E, 0xE92F, 0x99C8, 0x89E9, 0xB98A, 0xA9AB, 0x5844, 0x4865, 0x7806, 0x6827, 0x18C0, 0x08E1, 0x3882, 0x28A3, 0xCB7D, 0xDB5C, 0xEB3F,
+													 0xFB1E, 0x8BF9, 0x9BD8, 0xABBB, 0xBB9A, 0x4A75, 0x5A54, 0x6A37, 0x7A16, 0x0AF1, 0x1AD0, 0x2AB3, 0x3A92, 0xFD2E, 0xED0F, 0xDD6C, 0xCD4D, 0xBDAA, 0xAD8B, 0x9DE8, 0x8DC9, 0x7C26, 0x6C07, 0x5C64,
+													 0x4C45, 0x3CA2, 0x2C83, 0x1CE0, 0x0CC1, 0xEF1F, 0xFF3E, 0xCF5D, 0xDF7C, 0xAF9B, 0xBFBA, 0x8FD9, 0x9FF8, 0x6E17, 0x7E36, 0x4E55, 0x5E74, 0x2E93, 0x3EB2, 0x0ED1, 0x1EF0};
+
+		uint16 crc = initValue;
+
+		for (uint32 i = 0; i < size; i++)
+		{
+			const uint16 tmp = (crc >> 8) ^ buffer[i];
+			crc = (crc << 8) ^ CRC_CCITT_TABLE[tmp];
+		}
+
+		return crc;
+	}
+	SkylanderPortalDevice::SkylanderPortalDevice()
+		: Device(0x1430, 0x0150, 1, 2, 0)
+	{
+		m_IsOpened = false;
+	}
+
+	bool SkylanderPortalDevice::Open()
+	{
+		if (!IsOpened())
+		{
+			m_IsOpened = true;
+		}
+		return true;
+	}
+
+	void SkylanderPortalDevice::Close()
+	{
+		if (IsOpened())
+		{
+			m_IsOpened = false;
+		}
+	}
+
+	bool SkylanderPortalDevice::IsOpened()
+	{
+		return m_IsOpened;
+	}
+
+	Device::ReadResult SkylanderPortalDevice::Read(ReadMessage* message)
+	{
+		memcpy(message->data, g_skyportal.GetStatus().data(), message->length);
+		message->bytesRead = message->length;
+		std::this_thread::sleep_for(std::chrono::milliseconds(10));
+		return Device::ReadResult::Success;
+	}
+
+	Device::WriteResult SkylanderPortalDevice::Write(WriteMessage* message)
+	{
+		if (message->length != 64) {
+			cemu_assert_error();
+		}
+
+		if (!g_portalAudio)
+		{
+			// Portal audio is mono channel, 16 bit audio.
+			// Audio is unsigned 16 bit, supplied as 64 bytes which is 32 samples per block
+			g_portalAudio = IAudioAPI::CreateDeviceFromConfig(IAudioAPI::AudioType::Portal, 8000, 32, 16);
+		}
+		std::array<sint16, 32> mono_samples;
+		for (unsigned int i = 0; i < mono_samples.size(); ++i)
+		{
+			sint16 sample = static_cast<uint16>(message->data[i * 2 + 1]) << 8 | static_cast<uint16>(message->data[i * 2]);
+			mono_samples[i] = sample;
+		}
+		if (g_portalAudio)
+		{
+			g_portalAudio->FeedBlock(mono_samples.data());
+		}
+		message->bytesWritten = message->length;
+		return Device::WriteResult::Success;
+	}
+
+	bool SkylanderPortalDevice::GetDescriptor(uint8 descType,
+											  uint8 descIndex,
+											  uint16 lang,
+											  uint8* output,
+											  uint32 outputMaxLength)
+	{
+		uint8 configurationDescriptor[0x29];
+
+		uint8* currentWritePtr;
+
+		// configuration descriptor
+		currentWritePtr = configurationDescriptor + 0;
+		*(uint8*)(currentWritePtr + 0) = 9;			// bLength
+		*(uint8*)(currentWritePtr + 1) = 2;			// bDescriptorType
+		*(uint16be*)(currentWritePtr + 2) = 0x0029; // wTotalLength
+		*(uint8*)(currentWritePtr + 4) = 1;			// bNumInterfaces
+		*(uint8*)(currentWritePtr + 5) = 1;			// bConfigurationValue
+		*(uint8*)(currentWritePtr + 6) = 0;			// iConfiguration
+		*(uint8*)(currentWritePtr + 7) = 0x80;		// bmAttributes
+		*(uint8*)(currentWritePtr + 8) = 0xFA;		// MaxPower
+		currentWritePtr = currentWritePtr + 9;
+		// interface descriptor
+		*(uint8*)(currentWritePtr + 0) = 9;	   // bLength
+		*(uint8*)(currentWritePtr + 1) = 0x04; // bDescriptorType
+		*(uint8*)(currentWritePtr + 2) = 0;	   // bInterfaceNumber
+		*(uint8*)(currentWritePtr + 3) = 0;	   // bAlternateSetting
+		*(uint8*)(currentWritePtr + 4) = 2;	   // bNumEndpoints
+		*(uint8*)(currentWritePtr + 5) = 3;	   // bInterfaceClass
+		*(uint8*)(currentWritePtr + 6) = 0;	   // bInterfaceSubClass
+		*(uint8*)(currentWritePtr + 7) = 0;	   // bInterfaceProtocol
+		*(uint8*)(currentWritePtr + 8) = 0;	   // iInterface
+		currentWritePtr = currentWritePtr + 9;
+		// HID descriptor
+		*(uint8*)(currentWritePtr + 0) = 9;			// bLength
+		*(uint8*)(currentWritePtr + 1) = 0x21;		// bDescriptorType
+		*(uint16be*)(currentWritePtr + 2) = 0x0111; // bcdHID
+		*(uint8*)(currentWritePtr + 4) = 0x00;		// bCountryCode
+		*(uint8*)(currentWritePtr + 5) = 0x01;		// bNumDescriptors
+		*(uint8*)(currentWritePtr + 6) = 0x22;		// bDescriptorType
+		*(uint16be*)(currentWritePtr + 7) = 0x001D; // wDescriptorLength
+		currentWritePtr = currentWritePtr + 9;
+		// endpoint descriptor 1
+		*(uint8*)(currentWritePtr + 0) = 7;			// bLength
+		*(uint8*)(currentWritePtr + 1) = 0x05;		// bDescriptorType
+		*(uint8*)(currentWritePtr + 2) = 0x81;		// bEndpointAddress
+		*(uint8*)(currentWritePtr + 3) = 0x03;		// bmAttributes
+		*(uint16be*)(currentWritePtr + 4) = 0x0040; // wMaxPacketSize
+		*(uint8*)(currentWritePtr + 6) = 0x01;		// bInterval
+		currentWritePtr = currentWritePtr + 7;
+		// endpoint descriptor 2
+		*(uint8*)(currentWritePtr + 0) = 7;			// bLength
+		*(uint8*)(currentWritePtr + 1) = 0x05;		// bDescriptorType
+		*(uint8*)(currentWritePtr + 2) = 0x02;		// bEndpointAddress
+		*(uint8*)(currentWritePtr + 3) = 0x03;		// bmAttributes
+		*(uint16be*)(currentWritePtr + 4) = 0x0040; // wMaxPacketSize
+		*(uint8*)(currentWritePtr + 6) = 0x01;		// bInterval
+		currentWritePtr = currentWritePtr + 7;
+
+		cemu_assert_debug((currentWritePtr - configurationDescriptor) == 0x29);
+
+		memcpy(output, configurationDescriptor,
+			   std::min<uint32>(outputMaxLength, sizeof(configurationDescriptor)));
+		return true;
+	}
+
+	bool SkylanderPortalDevice::SetIdle(uint8 ifIndex,
+										uint8 reportId,
+										uint8 duration)
+	{
+		return true;
+	}
+
+	bool SkylanderPortalDevice::SetProtocol(uint8 ifIndex, uint8 protocol)
+	{
+		return true;
+	}
+
+	bool SkylanderPortalDevice::SetReport(ReportMessage* message)
+	{
+		g_skyportal.ControlTransfer(message->data, message->length);
+		std::this_thread::sleep_for(std::chrono::milliseconds(1));
+		return true;
+	}
+
+	void SkylanderUSB::ControlTransfer(uint8* buf, uint32 length)
+	{
+		std::array<uint8, 64> interruptResponse = {};
+		switch (buf[0])
+		{
+		case 'A':
+		{
+			interruptResponse = {buf[0], buf[1], 0xFF, 0x77};
+			g_skyportal.Activate();
+			break;
+		}
+		case 'C':
+		{
+			g_skyportal.SetLeds(0x01, buf[1], buf[2], buf[3]);
+			break;
+		}
+		case 'J':
+		{
+			g_skyportal.SetLeds(buf[1], buf[2], buf[3], buf[4]);
+			interruptResponse = {buf[0]};
+			break;
+		}
+		case 'L':
+		{
+			uint8 side = buf[1];
+			if (side == 0x02)
+			{
+				side = 0x04;
+			}
+			g_skyportal.SetLeds(side, buf[2], buf[3], buf[4]);
+			break;
+		}
+		case 'M':
+		{
+			interruptResponse = {buf[0], buf[1], 0x00, 0x19};
+			break;
+		}
+		case 'Q':
+		{
+			const uint8 skyNum = buf[1] & 0xF;
+			const uint8 block = buf[2];
+			g_skyportal.QueryBlock(skyNum, block, interruptResponse.data());
+			break;
+		}
+		case 'R':
+		{
+			interruptResponse = {buf[0], 0x02, 0x1b};
+			break;
+		}
+		case 'S':
+		case 'V':
+		{
+			// No response needed
+			break;
+		}
+		case 'W':
+		{
+			const uint8 skyNum = buf[1] & 0xF;
+			const uint8 block = buf[2];
+			g_skyportal.WriteBlock(skyNum, block, &buf[3], interruptResponse.data());
+			break;
+		}
+		default:
+			cemu_assert_error();
+			break;
+		}
+		if (interruptResponse[0] != 0)
+		{
+			std::lock_guard lock(m_queryMutex);
+			m_queries.push(interruptResponse);
+		}
+	}
+
+	void SkylanderUSB::Activate()
+	{
+		std::lock_guard lock(m_skyMutex);
+		if (m_activated)
+		{
+			// If the portal was already active no change is needed
+			return;
+		}
+
+		// If not we need to advertise change to all the figures present on the portal
+		for (auto& s : m_skylanders)
+		{
+			if (s.status & 1)
+			{
+				s.queuedStatus.push(3);
+				s.queuedStatus.push(1);
+			}
+		}
+
+		m_activated = true;
+	}
+
+	void SkylanderUSB::Deactivate()
+	{
+		std::lock_guard lock(m_skyMutex);
+
+		for (auto& s : m_skylanders)
+		{
+			// check if at the end of the updates there would be a figure on the portal
+			if (!s.queuedStatus.empty())
+			{
+				s.status = s.queuedStatus.back();
+				s.queuedStatus = std::queue<uint8>();
+			}
+
+			s.status &= 1;
+		}
+
+		m_activated = false;
+	}
+
+	void SkylanderUSB::SetLeds(uint8 side, uint8 r, uint8 g, uint8 b)
+	{
+		std::lock_guard lock(m_skyMutex);
+		if (side == 0x00)
+		{
+			m_colorRight.red = r;
+			m_colorRight.green = g;
+			m_colorRight.blue = b;
+		}
+		else if (side == 0x01)
+		{
+			m_colorRight.red = r;
+			m_colorRight.green = g;
+			m_colorRight.blue = b;
+
+			m_colorLeft.red = r;
+			m_colorLeft.green = g;
+			m_colorLeft.blue = b;
+		}
+		else if (side == 0x02)
+		{
+			m_colorLeft.red = r;
+			m_colorLeft.green = g;
+			m_colorLeft.blue = b;
+		}
+		else if (side == 0x03)
+		{
+			m_colorTrap.red = r;
+			m_colorTrap.green = g;
+			m_colorTrap.blue = b;
+		}
+	}
+
+	uint8 SkylanderUSB::LoadSkylander(uint8* buf, std::unique_ptr<FileStream> file)
+	{
+		std::lock_guard lock(m_skyMutex);
+
+		uint32 skySerial = 0;
+		for (int i = 3; i > -1; i--)
+		{
+			skySerial <<= 8;
+			skySerial |= buf[i];
+		}
+		uint8 foundSlot = 0xFF;
+
+		// mimics spot retaining on the portal
+		for (auto i = 0; i < 16; i++)
+		{
+			if ((m_skylanders[i].status & 1) == 0)
+			{
+				if (m_skylanders[i].lastId == skySerial)
+				{
+					foundSlot = i;
+					break;
+				}
+
+				if (i < foundSlot)
+				{
+					foundSlot = i;
+				}
+			}
+		}
+
+		if (foundSlot != 0xFF)
+		{
+			auto& skylander = m_skylanders[foundSlot];
+			memcpy(skylander.data.data(), buf, skylander.data.size());
+			skylander.skyFile = std::move(file);
+			skylander.status = Skylander::ADDED;
+			skylander.queuedStatus.push(Skylander::ADDED);
+			skylander.queuedStatus.push(Skylander::READY);
+			skylander.lastId = skySerial;
+		}
+		return foundSlot;
+	}
+
+	bool SkylanderUSB::RemoveSkylander(uint8 skyNum)
+	{
+		std::lock_guard lock(m_skyMutex);
+		auto& thesky = m_skylanders[skyNum];
+
+		if (thesky.status & 1)
+		{
+			thesky.status = 2;
+			thesky.queuedStatus.push(2);
+			thesky.queuedStatus.push(0);
+			thesky.Save();
+			thesky.skyFile.reset();
+			return true;
+		}
+
+		return false;
+	}
+
+	bool SkylanderUSB::CreateSkylander(fs::path pathName, uint16 skyId, uint16 skyVar)
+	{
+		FileStream* skyFile(FileStream::createFile2(pathName));
+		if (!skyFile)
+		{
+			return false;
+		}
+
+		std::array<uint8, SKY_FIGURE_SIZE> data{};
+
+		uint32 first_block = 0x690F0F0F;
+		uint32 other_blocks = 0x69080F7F;
+		memcpy(&data[0x36], &first_block, sizeof(first_block));
+		for (size_t index = 1; index < 0x10; index++)
+		{
+			memcpy(&data[(index * 0x40) + 0x36], &other_blocks, sizeof(other_blocks));
+		}
+		std::random_device rd;
+		std::mt19937 mt(rd());
+		std::uniform_int_distribution<int> dist(0, 255);
+		data[0] = dist(mt);
+		data[1] = dist(mt);
+		data[2] = dist(mt);
+		data[3] = dist(mt);
+		data[4] = data[0] ^ data[1] ^ data[2] ^ data[3];
+		data[5] = 0x81;
+		data[6] = 0x01;
+		data[7] = 0x0F;
+
+		memcpy(&data[0x10], &skyId, sizeof(skyId));
+		memcpy(&data[0x1C], &skyVar, sizeof(skyVar));
+
+		uint16 crc = nsyshid::g_skyportal.SkylanderCRC16(0xFFFF, data.data(), 0x1E);
+
+		memcpy(&data[0x1E], &crc, sizeof(crc));
+
+		skyFile->writeData(data.data(), data.size());
+
+		delete skyFile;
+
+		return true;
+	}
+
+	void SkylanderUSB::QueryBlock(uint8 skyNum, uint8 block, uint8* replyBuf)
+	{
+		std::lock_guard lock(m_skyMutex);
+
+		const auto& skylander = m_skylanders[skyNum];
+
+		replyBuf[0] = 'Q';
+		replyBuf[2] = block;
+		if (skylander.status & 1)
+		{
+			replyBuf[1] = (0x10 | skyNum);
+			memcpy(replyBuf + 3, skylander.data.data() + (16 * block), 16);
+		}
+		else
+		{
+			replyBuf[1] = skyNum;
+		}
+	}
+
+	void SkylanderUSB::WriteBlock(uint8 skyNum, uint8 block,
+								  const uint8* toWriteBuf, uint8* replyBuf)
+	{
+		std::lock_guard lock(m_skyMutex);
+
+		auto& skylander = m_skylanders[skyNum];
+
+		replyBuf[0] = 'W';
+		replyBuf[2] = block;
+
+		if (skylander.status & 1)
+		{
+			replyBuf[1] = (0x10 | skyNum);
+			memcpy(skylander.data.data() + (block * 16), toWriteBuf, 16);
+			skylander.Save();
+		}
+		else
+		{
+			replyBuf[1] = skyNum;
+		}
+	}
+
+	std::array<uint8, 64> SkylanderUSB::GetStatus()
+	{
+		std::lock_guard lock(m_queryMutex);
+		std::array<uint8, 64> interruptResponse = {};
+
+		if (!m_queries.empty())
+		{
+			interruptResponse = m_queries.front();
+			m_queries.pop();
+			// This needs to happen after ~22 milliseconds
+		}
+		else
+		{
+			uint32 status = 0;
+			uint8 active = 0x00;
+			if (m_activated)
+			{
+				active = 0x01;
+			}
+
+			for (int i = 16 - 1; i >= 0; i--)
+			{
+				auto& s = m_skylanders[i];
+
+				if (!s.queuedStatus.empty())
+				{
+					s.status = s.queuedStatus.front();
+					s.queuedStatus.pop();
+				}
+				status <<= 2;
+				status |= s.status;
+			}
+			interruptResponse = {0x53, 0x00, 0x00, 0x00, 0x00, m_interruptCounter++,
+								 active, 0x00, 0x00, 0x00, 0x00, 0x00,
+								 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+								 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+								 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+								 0x00, 0x00};
+			memcpy(&interruptResponse[1], &status, sizeof(status));
+		}
+		return interruptResponse;
+	}
+
+	std::string SkylanderUSB::FindSkylander(uint16 skyId, uint16 skyVar)
+	{
+		for (const auto& it : GetListSkylanders())
+		{
+			if (it.first.first == skyId && it.first.second == skyVar)
+			{
+				return it.second;
+			}
+		}
+		return fmt::format("Unknown ({} {})", skyId, skyVar);
+	}
+
+	std::map<const std::pair<const uint16, const uint16>, const char*> SkylanderUSB::GetListSkylanders()
+	{
+		return s_listSkylanders;
+	}
+
+	void SkylanderUSB::Skylander::Save()
+	{
+		if (!skyFile)
+			return;
+
+		skyFile->SetPosition(0);
+		skyFile->writeData(data.data(), data.size());
+	}
+} // namespace nsyshid
\ No newline at end of file
diff --git a/src/Cafe/OS/libs/nsyshid/Skylander.h b/src/Cafe/OS/libs/nsyshid/Skylander.h
new file mode 100644
index 00000000..9b9580b0
--- /dev/null
+++ b/src/Cafe/OS/libs/nsyshid/Skylander.h
@@ -0,0 +1,109 @@
+#pragma once
+
+#include <mutex>
+
+#include "nsyshid.h"
+#include "Backend.h"
+
+#include "Common/FileStream.h"
+
+namespace nsyshid
+{
+	class SkylanderPortalDevice final : public Device {
+	  public:
+		SkylanderPortalDevice();
+		~SkylanderPortalDevice() = default;
+
+		bool Open() override;
+
+		void Close() override;
+
+		bool IsOpened() override;
+
+		ReadResult Read(ReadMessage* message) override;
+
+		WriteResult Write(WriteMessage* message) override;
+
+		bool GetDescriptor(uint8 descType,
+						   uint8 descIndex,
+						   uint16 lang,
+						   uint8* output,
+						   uint32 outputMaxLength) override;
+
+		bool SetIdle(uint8 ifIndex,
+					 uint8 reportId,
+					 uint8 duration) override;
+
+		bool SetProtocol(uint8 ifIndex, uint8 protocol) override;
+
+		bool SetReport(ReportMessage* message) override;
+
+	  private:
+		bool m_IsOpened;
+	};
+
+	constexpr uint16 SKY_BLOCK_COUNT = 0x40;
+	constexpr uint16 SKY_BLOCK_SIZE = 0x10;
+	constexpr uint16 SKY_FIGURE_SIZE = SKY_BLOCK_COUNT * SKY_BLOCK_SIZE;
+	constexpr uint8 MAX_SKYLANDERS = 16;
+
+	class SkylanderUSB {
+	  public:
+		struct Skylander final
+		{
+			std::unique_ptr<FileStream> skyFile;
+			uint8 status = 0;
+			std::queue<uint8> queuedStatus;
+			std::array<uint8, SKY_FIGURE_SIZE> data{};
+			uint32 lastId = 0;
+			void Save();
+
+			enum : uint8
+			{
+				REMOVED = 0,
+				READY = 1,
+				REMOVING = 2,
+				ADDED = 3
+			};
+		};
+
+		struct SkylanderLEDColor final
+		{
+			uint8 red = 0;
+			uint8 green = 0;
+			uint8 blue = 0;
+		};
+
+		void ControlTransfer(uint8* buf, uint32 length);
+
+		void Activate();
+		void Deactivate();
+		void SetLeds(uint8 side, uint8 r, uint8 g, uint8 b);
+
+		std::array<uint8, 64> GetStatus();
+		void QueryBlock(uint8 skyNum, uint8 block, uint8* replyBuf);
+		void WriteBlock(uint8 skyNum, uint8 block, const uint8* toWriteBuf,
+						uint8* replyBuf);
+
+		uint8 LoadSkylander(uint8* buf, std::unique_ptr<FileStream> file);
+		bool RemoveSkylander(uint8 skyNum);
+		bool CreateSkylander(fs::path pathName, uint16 skyId, uint16 skyVar);
+		uint16 SkylanderCRC16(uint16 initValue, const uint8* buffer, uint32 size);
+		static std::map<const std::pair<const uint16, const uint16>, const char*> GetListSkylanders();
+		std::string FindSkylander(uint16 skyId, uint16 skyVar);
+
+	  protected:
+		std::mutex m_skyMutex;
+		std::mutex m_queryMutex;
+		std::array<Skylander, MAX_SKYLANDERS> m_skylanders;
+
+	  private:
+		std::queue<std::array<uint8, 64>> m_queries;
+		bool m_activated = true;
+		uint8 m_interruptCounter = 0;
+		SkylanderLEDColor m_colorRight = {};
+		SkylanderLEDColor m_colorLeft = {};
+		SkylanderLEDColor m_colorTrap = {};
+	};
+	extern SkylanderUSB g_skyportal;
+} // namespace nsyshid
\ No newline at end of file
diff --git a/src/Cafe/OS/libs/nsyshid/SkylanderXbox360.cpp b/src/Cafe/OS/libs/nsyshid/SkylanderXbox360.cpp
new file mode 100644
index 00000000..eba8ff9e
--- /dev/null
+++ b/src/Cafe/OS/libs/nsyshid/SkylanderXbox360.cpp
@@ -0,0 +1,160 @@
+#include "SkylanderXbox360.h"
+
+namespace nsyshid
+{
+	SkylanderXbox360PortalLibusb::SkylanderXbox360PortalLibusb(std::shared_ptr<Device> usbPortal)
+		: Device(0x1430, 0x0150, 1, 2, 0)
+	{
+		m_IsOpened = false;
+		m_usbPortal = std::static_pointer_cast<backend::libusb::DeviceLibusb>(usbPortal);
+	}
+
+	bool SkylanderXbox360PortalLibusb::Open()
+	{
+		return m_usbPortal->Open();
+	}
+
+	void SkylanderXbox360PortalLibusb::Close()
+	{
+		return m_usbPortal->Close();
+	}
+
+	bool SkylanderXbox360PortalLibusb::IsOpened()
+	{
+		return m_usbPortal->IsOpened();
+	}
+
+	Device::ReadResult SkylanderXbox360PortalLibusb::Read(ReadMessage* message)
+	{
+		std::vector<uint8> xboxData(std::min<uint32>(32, message->length + sizeof(XBOX_DATA_HEADER)));
+		memcpy(xboxData.data(), XBOX_DATA_HEADER, sizeof(XBOX_DATA_HEADER));
+		memcpy(xboxData.data() + sizeof(XBOX_DATA_HEADER), message->data, message->length - sizeof(XBOX_DATA_HEADER));
+
+		ReadMessage xboxMessage(xboxData.data(), xboxData.size(), 0);
+		auto result = m_usbPortal->Read(&xboxMessage);
+
+		memcpy(message->data, xboxData.data() + sizeof(XBOX_DATA_HEADER), message->length);
+		message->bytesRead = xboxMessage.bytesRead;
+
+		return result;
+	}
+
+	// Use InterruptTransfer instead of ControlTransfer
+	bool SkylanderXbox360PortalLibusb::SetReport(ReportMessage* message)
+	{
+		if (message->data[0] == 'M' && message->data[1] == 0x01) // Enables Speaker
+			g72x_init_state(&m_state);
+
+		std::vector<uint8> xboxData(message->length + sizeof(XBOX_DATA_HEADER));
+		memcpy(xboxData.data(), XBOX_DATA_HEADER, sizeof(XBOX_DATA_HEADER));
+		memcpy(xboxData.data() + sizeof(XBOX_DATA_HEADER), message->data, message->length);
+
+		WriteMessage xboxMessage(xboxData.data(), xboxData.size(), 0);
+		auto result = m_usbPortal->Write(&xboxMessage);
+
+		memcpy(message->data, xboxData.data() + sizeof(XBOX_DATA_HEADER), message->length);
+
+		return result == WriteResult::Success;
+	}
+
+	Device::WriteResult SkylanderXbox360PortalLibusb::Write(WriteMessage* message)
+	{
+		std::vector<uint8> audioData(message->data, message->data + message->length);
+
+		std::vector<uint8_t> xboxAudioData(audioData.size() / 4);
+		for (size_t i = 0; i < audioData.size(); i += 4)
+		{
+			int16_t sample1 = (static_cast<int16_t>(audioData[i + 1]) << 8) | audioData[i];
+			int16_t sample2 = (static_cast<int16_t>(audioData[i + 3]) << 8) | audioData[i + 2];
+
+			uint8_t encoded1 = g721_encoder(sample1, &m_state) & 0x0F;
+			uint8_t encoded2 = g721_encoder(sample2, &m_state) & 0x0F;
+
+			xboxAudioData[i / 4] = ((encoded2 << 4) | encoded1);
+		}
+
+		std::vector<uint8> xboxData(xboxAudioData.size() + sizeof(XBOX_AUDIO_DATA_HEADER));
+		memcpy(xboxData.data(), XBOX_AUDIO_DATA_HEADER, sizeof(XBOX_AUDIO_DATA_HEADER));
+		memcpy(xboxData.data() + sizeof(XBOX_AUDIO_DATA_HEADER), xboxAudioData.data(), xboxAudioData.size());
+
+		WriteMessage xboxMessage(xboxData.data(), xboxData.size(), 0);
+		auto result = m_usbPortal->Write(&xboxMessage);
+
+		memcpy(message->data, xboxData.data() + sizeof(XBOX_AUDIO_DATA_HEADER), xboxAudioData.size());
+		message->bytesWritten = xboxMessage.bytesWritten - sizeof(XBOX_AUDIO_DATA_HEADER);
+		return result;
+	}
+
+	bool SkylanderXbox360PortalLibusb::GetDescriptor(uint8 descType, uint8 descIndex, uint16 lang, uint8* output, uint32 outputMaxLength)
+	{
+		uint8 configurationDescriptor[0x29];
+
+		uint8* currentWritePtr;
+
+		// configuration descriptor
+		currentWritePtr = configurationDescriptor + 0;
+		*(uint8*)(currentWritePtr + 0) = 9;			// bLength
+		*(uint8*)(currentWritePtr + 1) = 2;			// bDescriptorType
+		*(uint16be*)(currentWritePtr + 2) = 0x0029; // wTotalLength
+		*(uint8*)(currentWritePtr + 4) = 1;			// bNumInterfaces
+		*(uint8*)(currentWritePtr + 5) = 1;			// bConfigurationValue
+		*(uint8*)(currentWritePtr + 6) = 0;			// iConfiguration
+		*(uint8*)(currentWritePtr + 7) = 0x80;		// bmAttributes
+		*(uint8*)(currentWritePtr + 8) = 0xFA;		// MaxPower
+		currentWritePtr = currentWritePtr + 9;
+		// interface descriptor
+		*(uint8*)(currentWritePtr + 0) = 9;	   // bLength
+		*(uint8*)(currentWritePtr + 1) = 0x04; // bDescriptorType
+		*(uint8*)(currentWritePtr + 2) = 0;	   // bInterfaceNumber
+		*(uint8*)(currentWritePtr + 3) = 0;	   // bAlternateSetting
+		*(uint8*)(currentWritePtr + 4) = 2;	   // bNumEndpoints
+		*(uint8*)(currentWritePtr + 5) = 3;	   // bInterfaceClass
+		*(uint8*)(currentWritePtr + 6) = 0;	   // bInterfaceSubClass
+		*(uint8*)(currentWritePtr + 7) = 0;	   // bInterfaceProtocol
+		*(uint8*)(currentWritePtr + 8) = 0;	   // iInterface
+		currentWritePtr = currentWritePtr + 9;
+		// HID descriptor
+		*(uint8*)(currentWritePtr + 0) = 9;			// bLength
+		*(uint8*)(currentWritePtr + 1) = 0x21;		// bDescriptorType
+		*(uint16be*)(currentWritePtr + 2) = 0x0111; // bcdHID
+		*(uint8*)(currentWritePtr + 4) = 0x00;		// bCountryCode
+		*(uint8*)(currentWritePtr + 5) = 0x01;		// bNumDescriptors
+		*(uint8*)(currentWritePtr + 6) = 0x22;		// bDescriptorType
+		*(uint16be*)(currentWritePtr + 7) = 0x001D; // wDescriptorLength
+		currentWritePtr = currentWritePtr + 9;
+		// endpoint descriptor 1
+		*(uint8*)(currentWritePtr + 0) = 7;			// bLength
+		*(uint8*)(currentWritePtr + 1) = 0x05;		// bDescriptorType
+		*(uint8*)(currentWritePtr + 2) = 0x81;		// bEndpointAddress
+		*(uint8*)(currentWritePtr + 3) = 0x03;		// bmAttributes
+		*(uint16be*)(currentWritePtr + 4) = 0x0040; // wMaxPacketSize
+		*(uint8*)(currentWritePtr + 6) = 0x01;		// bInterval
+		currentWritePtr = currentWritePtr + 7;
+		// endpoint descriptor 2
+		*(uint8*)(currentWritePtr + 0) = 7;			// bLength
+		*(uint8*)(currentWritePtr + 1) = 0x05;		// bDescriptorType
+		*(uint8*)(currentWritePtr + 2) = 0x02;		// bEndpointAddress
+		*(uint8*)(currentWritePtr + 3) = 0x03;		// bmAttributes
+		*(uint16be*)(currentWritePtr + 4) = 0x0040; // wMaxPacketSize
+		*(uint8*)(currentWritePtr + 6) = 0x01;		// bInterval
+		currentWritePtr = currentWritePtr + 7;
+
+		cemu_assert_debug((currentWritePtr - configurationDescriptor) == 0x29);
+
+		memcpy(output, configurationDescriptor,
+			   std::min<uint32>(outputMaxLength, sizeof(configurationDescriptor)));
+		return true;
+	}
+
+	bool SkylanderXbox360PortalLibusb::SetIdle(uint8 ifIndex,
+											   uint8 reportId,
+											   uint8 duration)
+	{
+		return true;
+	}
+
+	bool SkylanderXbox360PortalLibusb::SetProtocol(uint8 ifIndex, uint8 protocol)
+	{
+		return true;
+	}
+} // namespace nsyshid
\ No newline at end of file
diff --git a/src/Cafe/OS/libs/nsyshid/SkylanderXbox360.h b/src/Cafe/OS/libs/nsyshid/SkylanderXbox360.h
new file mode 100644
index 00000000..901c63f9
--- /dev/null
+++ b/src/Cafe/OS/libs/nsyshid/SkylanderXbox360.h
@@ -0,0 +1,46 @@
+#pragma once
+
+#include "nsyshid.h"
+#include "BackendLibusb.h"
+#include "g721/g721.h"
+
+namespace nsyshid
+{
+	class SkylanderXbox360PortalLibusb final : public Device {
+	  public:
+		SkylanderXbox360PortalLibusb(std::shared_ptr<Device> usbPortal);
+		~SkylanderXbox360PortalLibusb() = default;
+
+		bool Open() override;
+
+		void Close() override;
+
+		bool IsOpened() override;
+
+		ReadResult Read(ReadMessage* message) override;
+
+		WriteResult Write(WriteMessage* message) override;
+
+		bool GetDescriptor(uint8 descType,
+			uint8 descIndex,
+			uint16 lang,
+			uint8* output,
+			uint32 outputMaxLength) override;
+
+		bool SetIdle(uint8 ifIndex,
+			uint8 reportId,
+			uint8 duration) override;
+
+		bool SetProtocol(uint8 ifIndex, uint8 protocol) override;
+
+		bool SetReport(ReportMessage* message) override;
+		
+	  private:
+		std::shared_ptr<backend::libusb::DeviceLibusb> m_usbPortal;
+		bool m_IsOpened;
+		struct g72x_state m_state;
+	};
+
+	constexpr uint8 XBOX_DATA_HEADER[] = { 0x0B, 0x14 };
+	constexpr uint8 XBOX_AUDIO_DATA_HEADER[] = { 0x0B, 0x17 };
+} // namespace nsyshid
\ No newline at end of file
diff --git a/src/Cafe/OS/libs/nsyshid/Whitelist.cpp b/src/Cafe/OS/libs/nsyshid/Whitelist.cpp
new file mode 100644
index 00000000..783384ec
--- /dev/null
+++ b/src/Cafe/OS/libs/nsyshid/Whitelist.cpp
@@ -0,0 +1,57 @@
+#include "Whitelist.h"
+
+namespace nsyshid
+{
+	Whitelist& Whitelist::GetInstance()
+	{
+		static Whitelist whitelist;
+		return whitelist;
+	}
+
+	Whitelist::Whitelist()
+	{
+		// add known devices
+		{
+			// lego dimensions portal
+			m_devices.emplace_back(0x0e6f, 0x0241);
+			// skylanders portal
+			m_devices.emplace_back(0x1430, 0x0150);
+			// skylanders 360 portal
+			m_devices.emplace_back(0x1430, 0x1F17);
+			// disney infinity base
+			m_devices.emplace_back(0x0e6f, 0x0129);
+			// kamen rider ride gate
+			m_devices.emplace_back(0x0e6f, 0x200A);
+		}
+	}
+
+	bool Whitelist::IsDeviceWhitelisted(uint16 vendorId, uint16 productId)
+	{
+		auto it = std::find(m_devices.begin(), m_devices.end(),
+							std::tuple<uint16, uint16>(vendorId, productId));
+		return it != m_devices.end();
+	}
+
+	void Whitelist::AddDevice(uint16 vendorId, uint16 productId)
+	{
+		if (!IsDeviceWhitelisted(vendorId, productId))
+		{
+			m_devices.emplace_back(vendorId, productId);
+		}
+	}
+
+	void Whitelist::RemoveDevice(uint16 vendorId, uint16 productId)
+	{
+		m_devices.remove(std::tuple<uint16, uint16>(vendorId, productId));
+	}
+
+	std::list<std::tuple<uint16, uint16>> Whitelist::GetDevices()
+	{
+		return m_devices;
+	}
+
+	void Whitelist::RemoveAllDevices()
+	{
+		m_devices.clear();
+	}
+} // namespace nsyshid
diff --git a/src/Cafe/OS/libs/nsyshid/Whitelist.h b/src/Cafe/OS/libs/nsyshid/Whitelist.h
new file mode 100644
index 00000000..73b7742b
--- /dev/null
+++ b/src/Cafe/OS/libs/nsyshid/Whitelist.h
@@ -0,0 +1,32 @@
+#ifndef CEMU_NSYSHID_WHITELIST_H
+#define CEMU_NSYSHID_WHITELIST_H
+
+namespace nsyshid
+{
+	class Whitelist {
+	  public:
+		static Whitelist& GetInstance();
+
+		Whitelist(const Whitelist&) = delete;
+
+		Whitelist& operator=(const Whitelist&) = delete;
+
+		bool IsDeviceWhitelisted(uint16 vendorId, uint16 productId);
+
+		void AddDevice(uint16 vendorId, uint16 productId);
+
+		void RemoveDevice(uint16 vendorId, uint16 productId);
+
+		std::list<std::tuple<uint16, uint16>> GetDevices();
+
+		void RemoveAllDevices();
+
+	  private:
+		Whitelist();
+
+		// vendorId, productId
+		std::list<std::tuple<uint16, uint16>> m_devices;
+	};
+} // namespace nsyshid
+
+#endif // CEMU_NSYSHID_WHITELIST_H
diff --git a/src/Cafe/OS/libs/nsyshid/g721/g721.cpp b/src/Cafe/OS/libs/nsyshid/g721/g721.cpp
new file mode 100644
index 00000000..995212c2
--- /dev/null
+++ b/src/Cafe/OS/libs/nsyshid/g721/g721.cpp
@@ -0,0 +1,543 @@
+/*
+ * This source code is a product of Sun Microsystems, Inc. and is provided
+ * for unrestricted use.  Users may copy or modify this source code without
+ * charge.
+ *
+ * SUN SOURCE CODE IS PROVIDED AS IS WITH NO WARRANTIES OF ANY KIND INCLUDING
+ * THE WARRANTIES OF DESIGN, MERCHANTIBILITY AND FITNESS FOR A PARTICULAR
+ * PURPOSE, OR ARISING FROM A COURSE OF DEALING, USAGE OR TRADE PRACTICE.
+ *
+ * Sun source code is provided with no support and without any obligation on
+ * the part of Sun Microsystems, Inc. to assist in its use, correction,
+ * modification or enhancement.
+ *
+ * SUN MICROSYSTEMS, INC. SHALL HAVE NO LIABILITY WITH RESPECT TO THE
+ * INFRINGEMENT OF COPYRIGHTS, TRADE SECRETS OR ANY PATENTS BY THIS SOFTWARE
+ * OR ANY PART THEREOF.
+ *
+ * In no event will Sun Microsystems, Inc. be liable for any lost revenue
+ * or profits or other special, indirect and consequential damages, even if
+ * Sun has been advised of the possibility of such damages.
+ *
+ * Sun Microsystems, Inc.
+ * 2550 Garcia Avenue
+ * Mountain View, California  94043
+ */
+
+/*
+ * g721.c
+ *
+ * Description:
+ *
+ * g721_encoder(), g721_decoder()
+ *
+ * These routines comprise an implementation of the CCITT G.721 ADPCM
+ * coding algorithm.  Essentially, this implementation is identical to
+ * the bit level description except for a few deviations which
+ * take advantage of work station attributes, such as hardware 2's
+ * complement arithmetic and large memory.  Specifically, certain time
+ * consuming operations such as multiplications are replaced
+ * with lookup tables and software 2's complement operations are
+ * replaced with hardware 2's complement.
+ *
+ * The deviation from the bit level specification (lookup tables)
+ * preserves the bit level performance specifications.
+ *
+ * As outlined in the G.721 Recommendation, the algorithm is broken
+ * down into modules.  Each section of code below is preceded by
+ * the name of the module which it is implementing.
+ *
+ */
+#include "g721.h"
+#include <stdlib.h>
+
+static short qtab_721[7] = { -124, 80, 178, 246, 300, 349, 400 };
+/*
+ * Maps G.721 code word to reconstructed scale factor normalized log
+ * magnitude values.
+ */
+static short _dqlntab[16] = { -2048, 4,   135, 213, 273, 323, 373, 425,
+                              425,   373, 323, 273, 213, 135, 4,   -2048 };
+
+/* Maps G.721 code word to log of scale factor multiplier. */
+static short _witab[16] = { -12,  18,  41,  64,  112, 198, 355, 1122,
+                            1122, 355, 198, 112, 64,  41,  18,  -12 };
+/*
+ * Maps G.721 code words to a set of values whose long and short
+ * term averages are computed and then compared to give an indication
+ * how stationary (steady state) the signal is.
+ */
+static short _fitab[16] = { 0,     0,     0,     0x200, 0x200, 0x200, 0x600, 0xE00,
+                            0xE00, 0x600, 0x200, 0x200, 0x200, 0,     0,     0 };
+
+/*
+ * g721_encoder()
+ *
+ * Encodes the input value of linear PCM from sl and returns
+ * the resulting code. 
+ */
+int g721_encoder(int sl, struct g72x_state* state_ptr)
+{
+    short sezi, se, sez; /* ACCUM */
+    short d;             /* SUBTA */
+    short sr;            /* ADDB */
+    short y;             /* MIX */
+    short dqsez;         /* ADDC */
+    short dq, i;
+
+    sl >>= 2; /* linearize input sample to 14-bit PCM */
+
+    sezi = predictor_zero(state_ptr);
+    sez = sezi >> 1;
+    se = (sezi + predictor_pole(state_ptr)) >> 1; /* estimated signal */
+
+    d = sl - se; /* estimation difference */
+
+    /* quantize the prediction difference */
+    y = step_size(state_ptr);        /* quantizer step size */
+    i = quantize(d, y, qtab_721, 7); /* i = ADPCM code */
+
+    dq = reconstruct(i & 8, _dqlntab[i], y); /* quantized est diff */
+
+    sr = (dq < 0) ? se - (dq & 0x3FFF) : se + dq; /* reconst. signal */
+
+    dqsez = sr + sez - se; /* pole prediction diff. */
+
+    update(4, y, _witab[i] << 5, _fitab[i], dq, sr, dqsez, state_ptr);
+
+    return (i);
+}
+
+/*
+ * g721_decoder()
+ *
+ * Description:
+ *
+ * Decodes a 4-bit code of G.721 encoded data of i and
+ * returns the resulting linear PCM
+ */
+int g721_decoder(int i, struct g72x_state* state_ptr)
+{
+    short sezi, sei, sez, se; /* ACCUM */
+    short y;                  /* MIX */
+    short sr;                 /* ADDB */
+    short dq;
+    short dqsez;
+
+    i &= 0x0f; /* mask to get proper bits */
+    sezi = predictor_zero(state_ptr);
+    sez = sezi >> 1;
+    sei = sezi + predictor_pole(state_ptr);
+    se = sei >> 1; /* se = estimated signal */
+
+    y = step_size(state_ptr); /* dynamic quantizer step size */
+
+    dq = reconstruct(i & 0x08, _dqlntab[i], y); /* quantized diff. */
+
+    sr = (dq < 0) ? (se - (dq & 0x3FFF)) : se + dq; /* reconst. signal */
+
+    dqsez = sr - se + sez; /* pole prediction diff. */
+
+    update(4, y, _witab[i] << 5, _fitab[i], dq, sr, dqsez, state_ptr);
+
+    return (sr << 2);
+}
+
+
+static short power2[15] = { 1,     2,     4,     8,     0x10,   0x20,   0x40,  0x80,
+                            0x100, 0x200, 0x400, 0x800, 0x1000, 0x2000, 0x4000 };
+
+/*
+ * quan()
+ *
+ * quantizes the input val against the table of size short integers.
+ * It returns i if table[i - 1] <= val < table[i].
+ *
+ * Using linear search for simple coding.
+ */
+static int quan(int val, short* table, int size)
+{
+    int i;
+
+    for (i = 0; i < size; i++)
+        if (val < *table++)
+            break;
+    return (i);
+}
+
+/*
+ * fmult()
+ *
+ * returns the integer product of the 14-bit integer "an" and
+ * "floating point" representation (4-bit exponent, 6-bit mantessa) "srn".
+ */
+static int fmult(int an, int srn)
+{
+    short anmag, anexp, anmant;
+    short wanexp, wanmant;
+    short retval;
+
+    anmag = (an > 0) ? an : ((-an) & 0x1FFF);
+    anexp = quan(anmag, power2, 15) - 6;
+    anmant = (anmag == 0) ? 32 : (anexp >= 0) ? anmag >> anexp : anmag << -anexp;
+    wanexp = anexp + ((srn >> 6) & 0xF) - 13;
+
+    wanmant = (anmant * (srn & 077) + 0x30) >> 4;
+    retval = (wanexp >= 0) ? ((wanmant << wanexp) & 0x7FFF) : (wanmant >> -wanexp);
+
+    return (((an ^ srn) < 0) ? -retval : retval);
+}
+
+
+
+/*
+ * update()
+ *
+ * updates the state variables for each output code
+ */
+void update(int code_size,                /* distinguish 723_40 with others */
+            int y,                        /* quantizer step size */
+            int wi,                       /* scale factor multiplier */
+            int fi,                       /* for long/short term energies */
+            int dq,                       /* quantized prediction difference */
+            int sr,                       /* reconstructed signal */
+            int dqsez,                    /* difference from 2-pole predictor */
+            struct g72x_state* state_ptr) /* coder state pointer */
+{
+    int cnt;
+    short mag, exp; /* Adaptive predictor, FLOAT A */
+    short a2p = 0;  /* LIMC */
+    short a1ul;     /* UPA1 */
+    short pks1;     /* UPA2 */
+    short fa1;
+    char tr; /* tone/transition detector */
+    short ylint, thr2, dqthr;
+    short ylfrac, thr1;
+    short pk0;
+
+    pk0 = (dqsez < 0) ? 1 : 0; /* needed in updating predictor poles */
+
+    mag = dq & 0x7FFF; /* prediction difference magnitude */
+    /* TRANS */
+    ylint = state_ptr->yl >> 15;           /* exponent part of yl */
+    ylfrac = (state_ptr->yl >> 10) & 0x1F; /* fractional part of yl */
+    thr1 = (32 + ylfrac) << ylint;         /* threshold */
+    thr2 = (ylint > 9) ? 31 << 10 : thr1;  /* limit thr2 to 31 << 10 */
+    dqthr = (thr2 + (thr2 >> 1)) >> 1;     /* dqthr = 0.75 * thr2 */
+    if (state_ptr->td == 0)                /* signal supposed voice */
+        tr = 0;
+    else if (mag <= dqthr) /* supposed data, but small mag */
+        tr = 0;            /* treated as voice */
+    else                   /* signal is data (modem) */
+        tr = 1;
+
+    /*
+     * Quantizer scale factor adaptation.
+     */
+
+    /* FUNCTW & FILTD & DELAY */
+    /* update non-steady state step size multiplier */
+    state_ptr->yu = y + ((wi - y) >> 5);
+
+    /* LIMB */
+    if (state_ptr->yu < 544) /* 544 <= yu <= 5120 */
+        state_ptr->yu = 544;
+    else if (state_ptr->yu > 5120)
+        state_ptr->yu = 5120;
+
+    /* FILTE & DELAY */
+    /* update steady state step size multiplier */
+    state_ptr->yl += state_ptr->yu + ((-state_ptr->yl) >> 6);
+
+    /*
+     * Adaptive predictor coefficients.
+     */
+    if (tr == 1) { /* reset a's and b's for modem signal */
+        state_ptr->a[0] = 0;
+        state_ptr->a[1] = 0;
+        state_ptr->b[0] = 0;
+        state_ptr->b[1] = 0;
+        state_ptr->b[2] = 0;
+        state_ptr->b[3] = 0;
+        state_ptr->b[4] = 0;
+        state_ptr->b[5] = 0;
+    } else {                           /* update a's and b's */
+        pks1 = pk0 ^ state_ptr->pk[0]; /* UPA2 */
+
+        /* update predictor pole a[1] */
+        a2p = state_ptr->a[1] - (state_ptr->a[1] >> 7);
+        if (dqsez != 0) {
+            fa1 = (pks1) ? state_ptr->a[0] : -state_ptr->a[0];
+            if (fa1 < -8191) /* a2p = function of fa1 */
+                a2p -= 0x100;
+            else if (fa1 > 8191)
+                a2p += 0xFF;
+            else
+                a2p += fa1 >> 5;
+
+            if (pk0 ^ state_ptr->pk[1])
+                /* LIMC */
+                if (a2p <= -12160)
+                    a2p = -12288;
+                else if (a2p >= 12416)
+                    a2p = 12288;
+                else
+                    a2p -= 0x80;
+            else if (a2p <= -12416)
+                a2p = -12288;
+            else if (a2p >= 12160)
+                a2p = 12288;
+            else
+                a2p += 0x80;
+        }
+
+        /* TRIGB & DELAY */
+        state_ptr->a[1] = a2p;
+
+        /* UPA1 */
+        /* update predictor pole a[0] */
+        state_ptr->a[0] -= state_ptr->a[0] >> 8;
+        if (dqsez != 0) {
+            if (pks1 == 0)
+                state_ptr->a[0] += 192;
+            else
+                state_ptr->a[0] -= 192;
+        }
+
+        /* LIMD */
+        a1ul = 15360 - a2p;
+        if (state_ptr->a[0] < -a1ul)
+            state_ptr->a[0] = -a1ul;
+        else if (state_ptr->a[0] > a1ul)
+            state_ptr->a[0] = a1ul;
+
+        /* UPB : update predictor zeros b[6] */
+        for (cnt = 0; cnt < 6; cnt++) {
+            if (code_size == 5) /* for 40Kbps G.723 */
+                state_ptr->b[cnt] -= state_ptr->b[cnt] >> 9;
+            else /* for G.721 and 24Kbps G.723 */
+                state_ptr->b[cnt] -= state_ptr->b[cnt] >> 8;
+            if (dq & 0x7FFF) { /* XOR */
+                if ((dq ^ state_ptr->dq[cnt]) >= 0)
+                    state_ptr->b[cnt] += 128;
+                else
+                    state_ptr->b[cnt] -= 128;
+            }
+        }
+    }
+
+    for (cnt = 5; cnt > 0; cnt--)
+        state_ptr->dq[cnt] = state_ptr->dq[cnt - 1];
+    /* FLOAT A : convert dq[0] to 4-bit exp, 6-bit mantissa f.p. */
+    if (mag == 0) {
+        state_ptr->dq[0] = (dq >= 0) ? 0x20 : 0xFC20;
+    } else {
+        exp = quan(mag, power2, 15);
+        state_ptr->dq[0] = (dq >= 0) ? (exp << 6) + ((mag << 6) >> exp)
+                                     : (exp << 6) + ((mag << 6) >> exp) - 0x400;
+    }
+
+    state_ptr->sr[1] = state_ptr->sr[0];
+    /* FLOAT B : convert sr to 4-bit exp., 6-bit mantissa f.p. */
+    if (sr == 0) {
+        state_ptr->sr[0] = 0x20;
+    } else if (sr > 0) {
+        exp = quan(sr, power2, 15);
+        state_ptr->sr[0] = (exp << 6) + ((sr << 6) >> exp);
+    } else if (sr > -32768) {
+        mag = -sr;
+        exp = quan(mag, power2, 15);
+        state_ptr->sr[0] = (exp << 6) + ((mag << 6) >> exp) - 0x400;
+    } else
+        state_ptr->sr[0] = 0xFC20;
+
+    /* DELAY A */
+    state_ptr->pk[1] = state_ptr->pk[0];
+    state_ptr->pk[0] = pk0;
+
+    /* TONE */
+    if (tr == 1)           /* this sample has been treated as data */
+        state_ptr->td = 0; /* next one will be treated as voice */
+    else if (a2p < -11776) /* small sample-to-sample correlation */
+        state_ptr->td = 1; /* signal may be data */
+    else                   /* signal is voice */
+        state_ptr->td = 0;
+
+    /*
+     * Adaptation speed control.
+     */
+    state_ptr->dms += (fi - state_ptr->dms) >> 5;          /* FILTA */
+    state_ptr->dml += (((fi << 2) - state_ptr->dml) >> 7); /* FILTB */
+
+    if (tr == 1)
+        state_ptr->ap = 256;
+    else if (y < 1536) /* SUBTC */
+        state_ptr->ap += (0x200 - state_ptr->ap) >> 4;
+    else if (state_ptr->td == 1)
+        state_ptr->ap += (0x200 - state_ptr->ap) >> 4;
+    else if (abs((state_ptr->dms << 2) - state_ptr->dml) >= (state_ptr->dml >> 3))
+        state_ptr->ap += (0x200 - state_ptr->ap) >> 4;
+    else
+        state_ptr->ap += (-state_ptr->ap) >> 4;
+}
+
+
+/*
+ * g72x_init_state()
+ *
+ * This routine initializes and/or resets the g72x_state structure
+ * pointed to by 'state_ptr'.
+ * All the initial state values are specified in the CCITT G.721 document.
+ */
+void g72x_init_state(struct g72x_state* state_ptr)
+{
+    int cnta;
+
+    state_ptr->yl = 34816;
+    state_ptr->yu = 544;
+    state_ptr->dms = 0;
+    state_ptr->dml = 0;
+    state_ptr->ap = 0;
+    for (cnta = 0; cnta < 2; cnta++) {
+        state_ptr->a[cnta] = 0;
+        state_ptr->pk[cnta] = 0;
+        state_ptr->sr[cnta] = 32;
+    }
+    for (cnta = 0; cnta < 6; cnta++) {
+        state_ptr->b[cnta] = 0;
+        state_ptr->dq[cnta] = 32;
+    }
+    state_ptr->td = 0;
+}
+
+/*
+ * predictor_zero()
+ *
+ * computes the estimated signal from 6-zero predictor.
+ *
+ */
+int predictor_zero(struct g72x_state* state_ptr)
+{
+    int i;
+    int sezi;
+
+    sezi = fmult(state_ptr->b[0] >> 2, state_ptr->dq[0]);
+    for (i = 1; i < 6; i++) /* ACCUM */
+        sezi += fmult(state_ptr->b[i] >> 2, state_ptr->dq[i]);
+    return (sezi);
+}
+/*
+ * predictor_pole()
+ *
+ * computes the estimated signal from 2-pole predictor.
+ *
+ */
+int predictor_pole(struct g72x_state* state_ptr)
+{
+    return (fmult(state_ptr->a[1] >> 2, state_ptr->sr[1]) +
+            fmult(state_ptr->a[0] >> 2, state_ptr->sr[0]));
+}
+/*
+ * step_size()
+ *
+ * computes the quantization step size of the adaptive quantizer.
+ *
+ */
+int step_size(struct g72x_state* state_ptr)
+{
+    int y;
+    int dif;
+    int al;
+
+    if (state_ptr->ap >= 256)
+        return (state_ptr->yu);
+    else {
+        y = state_ptr->yl >> 6;
+        dif = state_ptr->yu - y;
+        al = state_ptr->ap >> 2;
+        if (dif > 0)
+            y += (dif * al) >> 6;
+        else if (dif < 0)
+            y += (dif * al + 0x3F) >> 6;
+        return (y);
+    }
+}
+
+/*
+ * quantize()
+ *
+ * Given a raw sample, 'd', of the difference signal and a
+ * quantization step size scale factor, 'y', this routine returns the
+ * ADPCM codeword to which that sample gets quantized.  The step
+ * size scale factor division operation is done in the log base 2 domain
+ * as a subtraction.
+ */
+int quantize(int d,        /* Raw difference signal sample */
+             int y,        /* Step size multiplier */
+             short* table, /* quantization table */
+             int size)     /* table size of short integers */
+{
+    short dqm;  /* Magnitude of 'd' */
+    short exp;  /* Integer part of base 2 log of 'd' */
+    short mant; /* Fractional part of base 2 log */
+    short dl;   /* Log of magnitude of 'd' */
+    short dln;  /* Step size scale factor normalized log */
+    int i;
+
+    /*
+     * LOG
+     *
+     * Compute base 2 log of 'd', and store in 'dl'.
+     */
+    dqm = abs(d);
+    exp = quan(dqm >> 1, power2, 15);
+    mant = ((dqm << 7) >> exp) & 0x7F; /* Fractional portion. */
+    dl = (exp << 7) + mant;
+
+    /*
+     * SUBTB
+     *
+     * "Divide" by step size multiplier.
+     */
+    dln = dl - (y >> 2);
+
+    /*
+     * QUAN
+     *
+     * Obtain codword i for 'd'.
+     */
+    i = quan(dln, table, size);
+    if (d < 0) /* take 1's complement of i */
+        return ((size << 1) + 1 - i);
+    else if (i == 0)              /* take 1's complement of 0 */
+        return ((size << 1) + 1); /* new in 1988 */
+    else
+        return (i);
+}
+/*
+ * reconstruct()
+ *
+ * Returns reconstructed difference signal 'dq' obtained from
+ * codeword 'i' and quantization step size scale factor 'y'.
+ * Multiplication is performed in log base 2 domain as addition.
+ */
+int reconstruct(int sign, /* 0 for non-negative value */
+                int dqln, /* G.72x codeword */
+                int y)    /* Step size multiplier */
+{
+    short dql; /* Log of 'dq' magnitude */
+    short dex; /* Integer part of log */
+    short dqt;
+    short dq; /* Reconstructed difference signal sample */
+
+    dql = dqln + (y >> 2); /* ADDA */
+
+    if (dql < 0) {
+        return ((sign) ? -0x8000 : 0);
+    } else { /* ANTILOG */
+        dex = (dql >> 7) & 15;
+        dqt = 128 + (dql & 127);
+        dq = (dqt << 7) >> (14 - dex);
+        return ((sign) ? (dq - 0x8000) : dq);
+    }
+}
\ No newline at end of file
diff --git a/src/Cafe/OS/libs/nsyshid/g721/g721.h b/src/Cafe/OS/libs/nsyshid/g721/g721.h
new file mode 100644
index 00000000..c764e5fd
--- /dev/null
+++ b/src/Cafe/OS/libs/nsyshid/g721/g721.h
@@ -0,0 +1,96 @@
+/*
+ * This source code is a product of Sun Microsystems, Inc. and is provided
+ * for unrestricted use.  Users may copy or modify this source code without
+ * charge.
+ *
+ * SUN SOURCE CODE IS PROVIDED AS IS WITH NO WARRANTIES OF ANY KIND INCLUDING
+ * THE WARRANTIES OF DESIGN, MERCHANTIBILITY AND FITNESS FOR A PARTICULAR
+ * PURPOSE, OR ARISING FROM A COURSE OF DEALING, USAGE OR TRADE PRACTICE.
+ *
+ * Sun source code is provided with no support and without any obligation on
+ * the part of Sun Microsystems, Inc. to assist in its use, correction,
+ * modification or enhancement.
+ *
+ * SUN MICROSYSTEMS, INC. SHALL HAVE NO LIABILITY WITH RESPECT TO THE
+ * INFRINGEMENT OF COPYRIGHTS, TRADE SECRETS OR ANY PATENTS BY THIS SOFTWARE
+ * OR ANY PART THEREOF.
+ *
+ * In no event will Sun Microsystems, Inc. be liable for any lost revenue
+ * or profits or other special, indirect and consequential damages, even if
+ * Sun has been advised of the possibility of such damages.
+ *
+ * Sun Microsystems, Inc.
+ * 2550 Garcia Avenue
+ * Mountain View, California  94043
+ */
+
+/*
+ * g72x.h
+ *
+ * Header file for CCITT conversion routines.
+ *
+ */
+#ifndef _G72X_H
+#define _G72X_H
+
+/*
+ * The following is the definition of the state structure
+ * used by the G.721/G.723 encoder and decoder to preserve their internal
+ * state between successive calls.  The meanings of the majority
+ * of the state structure fields are explained in detail in the
+ * CCITT Recommendation G.721.  The field names are essentially identical
+ * to variable names in the bit level description of the coding algorithm
+ * included in this Recommendation.
+ */
+struct g72x_state {
+    long yl;   /* Locked or steady state step size multiplier. */
+    short yu;  /* Unlocked or non-steady state step size multiplier. */
+    short dms; /* Short term energy estimate. */
+    short dml; /* Long term energy estimate. */
+    short ap;  /* Linear weighting coefficient of 'yl' and 'yu'. */
+
+    short a[2];  /* Coefficients of pole portion of prediction filter. */
+    short b[6];  /* Coefficients of zero portion of prediction filter. */
+    short pk[2]; /*
+                  * Signs of previous two samples of a partially
+                  * reconstructed signal.
+                  */
+    short dq[6]; /*
+                  * Previous 6 samples of the quantized difference
+                  * signal represented in an internal floating point
+                  * format.
+                  */
+    short sr[2]; /*
+                  * Previous 2 samples of the quantized difference
+                  * signal represented in an internal floating point
+                  * format.
+                  */
+    char td;     /* delayed tone detect, new in 1988 version */
+};
+
+/* External function definitions. */
+
+void g72x_init_state(struct g72x_state*);
+int g721_encoder(int sample, struct g72x_state* state_ptr);
+int g721_decoder(int code, struct g72x_state* state_ptr);
+
+
+int quantize(int d, int y, short* table, int size);
+int reconstruct(int, int, int);
+void
+
+    update(int code_size,
+                  int y,
+                  int wi,
+                  int fi,
+                  int dq,
+                  int sr,
+                  int dqsez,
+                  struct g72x_state* state_ptr);
+
+int predictor_zero(struct g72x_state* state_ptr);
+
+int predictor_pole(struct g72x_state* state_ptr);
+int step_size(struct g72x_state* state_ptr);
+#endif /* !_G72X_H */
+
diff --git a/src/Cafe/OS/libs/nsyshid/nsyshid.cpp b/src/Cafe/OS/libs/nsyshid/nsyshid.cpp
index d43b486e..93ee8c3d 100644
--- a/src/Cafe/OS/libs/nsyshid/nsyshid.cpp
+++ b/src/Cafe/OS/libs/nsyshid/nsyshid.cpp
@@ -1,306 +1,288 @@
 #include "Cafe/OS/common/OSCommon.h"
 #include "Cafe/HW/Espresso/PPCCallback.h"
 #include <bitset>
+#include <mutex>
 #include "nsyshid.h"
-
-#if BOOST_OS_WINDOWS
-
-#include <setupapi.h>
-#include <initguid.h>
-#include <hidsdi.h>
-
 #include "Cafe/OS/libs/coreinit/coreinit_Thread.h"
-
-#pragma comment(lib,"Setupapi.lib")
-#pragma comment(lib,"hid.lib")
-
-DEFINE_GUID(GUID_DEVINTERFACE_HID, 0x4D1E55B2L, 0xF16F, 0x11CF, 0x88, 0xCB, 0x00, 0x11, 0x11, 0x00, 0x00, 0x30);
+#include "Backend.h"
+#include "Whitelist.h"
 
 namespace nsyshid
 {
 
-	typedef struct
-	{
-		/* +0x00 */ uint32be handle;
-		/* +0x04 */ uint32 ukn04;
-		/* +0x08 */ uint16 vendorId; // little-endian ?
-		/* +0x0A */ uint16 productId; // little-endian ?
-		/* +0x0C */ uint8 ifIndex;
-		/* +0x0D */ uint8 subClass;
-		/* +0x0E */ uint8 protocol;
-		/* +0x0F */ uint8 paddingGuessed0F;
-		/* +0x10 */ uint16be maxPacketSizeRX;
-		/* +0x12 */ uint16be maxPacketSizeTX;
-	}HIDDevice_t;
-
-	static_assert(offsetof(HIDDevice_t, vendorId) == 0x8, "");
-	static_assert(offsetof(HIDDevice_t, productId) == 0xA, "");
-	static_assert(offsetof(HIDDevice_t, ifIndex) == 0xC, "");
-	static_assert(offsetof(HIDDevice_t, protocol) == 0xE, "");
-
-	typedef struct _HIDDeviceInfo_t
-	{
-		uint32 handle;
-		uint32 physicalDeviceInstance;
-		uint16 vendorId;
-		uint16 productId;
-		uint8 interfaceIndex;
-		uint8 interfaceSubClass;
-		uint8 protocol;
-		HIDDevice_t* hidDevice; // this info is passed to applications and must remain intact
-		wchar_t* devicePath;
-		_HIDDeviceInfo_t* next;
-		// host
-		HANDLE hFile;
-	}HIDDeviceInfo_t;
-
-	HIDDeviceInfo_t* firstDevice = nullptr;
+	std::list<std::shared_ptr<Backend>> backendList;
 
+	std::list<std::shared_ptr<Device>> deviceList;
 
 	typedef struct _HIDClient_t
 	{
-		MEMPTR<_HIDClient_t> next;
 		uint32be callbackFunc; // attach/detach callback
-	}HIDClient_t;
+	} HIDClient_t;
 
-	HIDClient_t* firstHIDClient = nullptr;
+	std::list<HIDClient_t*> HIDClientList;
 
-	HANDLE openDevice(wchar_t* devicePath)
-	{
-		return CreateFile(devicePath,
-			GENERIC_READ | GENERIC_WRITE,
-			FILE_SHARE_READ |
-			FILE_SHARE_WRITE,
-			NULL,
-			OPEN_EXISTING,
-			FILE_FLAG_OVERLAPPED,
-			NULL);
-	}
-
-	void attachClientToList(HIDClient_t* hidClient)
+	std::recursive_mutex hidMutex;
+
+	void AttachClientToList(HIDClient_t* hidClient)
 	{
+		std::lock_guard<std::recursive_mutex> lock(hidMutex);
 		// todo - append at the beginning or end of the list? List order matters because it also controls the order in which attach callbacks are called
-		if (firstHIDClient)
-		{
-			hidClient->next = firstHIDClient;
-			firstHIDClient = hidClient;
-		}
-		else
-		{
-			hidClient->next = nullptr;
-			firstHIDClient = hidClient;
-		}
+		HIDClientList.push_front(hidClient);
 	}
 
-	void attachDeviceToList(HIDDeviceInfo_t* hidDeviceInfo)
+	void DetachClientFromList(HIDClient_t* hidClient)
 	{
-		if (firstDevice)
-		{
-			hidDeviceInfo->next = firstDevice;
-			firstDevice = hidDeviceInfo;
-		}
-		else
-		{
-			hidDeviceInfo->next = nullptr;
-			firstDevice = hidDeviceInfo;
-		}
+		std::lock_guard<std::recursive_mutex> lock(hidMutex);
+		HIDClientList.remove(hidClient);
 	}
 
-	HIDDeviceInfo_t* getHIDDeviceInfoByHandle(uint32 handle, bool openFileHandle = false)
+	std::shared_ptr<Device> GetDeviceByHandle(uint32 handle, bool openIfClosed = false)
 	{
-		HIDDeviceInfo_t* deviceItr = firstDevice;
-		while (deviceItr)
+		std::shared_ptr<Device> device;
 		{
-			if (deviceItr->handle == handle)
+			std::lock_guard<std::recursive_mutex> lock(hidMutex);
+			for (const auto& d : deviceList)
 			{
-				if (openFileHandle && deviceItr->hFile == INVALID_HANDLE_VALUE)
+				if (d->m_hid->handle == handle)
 				{
-					deviceItr->hFile = openDevice(deviceItr->devicePath);
-					if (deviceItr->hFile == INVALID_HANDLE_VALUE)
-					{
-						forceLog_printfW(L"HID: Failed to open device \"%s\"", deviceItr->devicePath);
-						return nullptr;
-					}
-					HidD_SetNumInputBuffers(deviceItr->hFile, 2); // dont cache too many reports
+					device = d;
+					break;
 				}
-				return deviceItr;
 			}
-			deviceItr = deviceItr->next;
+		}
+		if (device != nullptr)
+		{
+			if (openIfClosed && !device->IsOpened())
+			{
+				if (!device->Open())
+				{
+					return nullptr;
+				}
+			}
+			return device;
 		}
 		return nullptr;
 	}
 
 	uint32 _lastGeneratedHidHandle = 1;
 
-	uint32 generateHIDHandle()
+	uint32 GenerateHIDHandle()
 	{
+		std::lock_guard<std::recursive_mutex> lock(hidMutex);
 		_lastGeneratedHidHandle++;
 		return _lastGeneratedHidHandle;
 	}
 
 	const int HID_MAX_NUM_DEVICES = 128;
 
-	SysAllocator<HIDDevice_t, HID_MAX_NUM_DEVICES> _devicePool;
-	std::bitset<HID_MAX_NUM_DEVICES> _devicePoolMask;
+	SysAllocator<HID_t, HID_MAX_NUM_DEVICES> HIDPool;
+	std::queue<size_t> HIDPoolIndexQueue;
 
-	HIDDevice_t* getFreeDevice()
+	void InitHIDPoolIndexQueue()
 	{
-		for (sint32 i = 0; i < HID_MAX_NUM_DEVICES; i++)
+		static bool HIDPoolIndexQueueInitialized = false;
+		std::lock_guard<std::recursive_mutex> lock(hidMutex);
+		if (HIDPoolIndexQueueInitialized)
 		{
-			if (_devicePoolMask.test(i) == false)
-			{
-				_devicePoolMask.set(i);
-				return _devicePool.GetPtr() + i;
-			}
+			return;
+		}
+		HIDPoolIndexQueueInitialized = true;
+		for (size_t i = 0; i < HID_MAX_NUM_DEVICES; i++)
+		{
+			HIDPoolIndexQueue.push(i);
 		}
-		return nullptr;
 	}
 
-	void checkAndAddDevice(wchar_t* devicePath, HANDLE hDevice)
+	HID_t* GetFreeHID()
 	{
-		HIDD_ATTRIBUTES hidAttr;
-		hidAttr.Size = sizeof(HIDD_ATTRIBUTES);
-		if (HidD_GetAttributes(hDevice, &hidAttr) == FALSE)
-			return;
-		HIDDevice_t* hidDevice = getFreeDevice();
-		if (hidDevice == nullptr)
+		std::lock_guard<std::recursive_mutex> lock(hidMutex);
+		InitHIDPoolIndexQueue();
+		if (HIDPoolIndexQueue.empty())
 		{
-			forceLog_printf("HID: Maximum number of supported devices exceeded");
-			return;
+			return nullptr;
 		}
-
-		HIDDeviceInfo_t* deviceInfo = (HIDDeviceInfo_t*)malloc(sizeof(HIDDeviceInfo_t));
-		memset(deviceInfo, 0, sizeof(HIDDeviceInfo_t));
-		deviceInfo->devicePath = _wcsdup(devicePath);
-		deviceInfo->vendorId = hidAttr.VendorID;
-		deviceInfo->productId = hidAttr.ProductID;
-		deviceInfo->hFile = INVALID_HANDLE_VALUE;
-		// generate handle
-		deviceInfo->handle = generateHIDHandle();
-		// get additional device info
-		sint32 maxPacketInputLength = -1;
-		sint32 maxPacketOutputLength = -1;
-		PHIDP_PREPARSED_DATA ppData = nullptr;
-		if (HidD_GetPreparsedData(hDevice, &ppData))
-		{
-			HIDP_CAPS caps;
-			if (HidP_GetCaps(ppData, &caps) == HIDP_STATUS_SUCCESS)
-			{
-				// length includes the report id byte
-				maxPacketInputLength = caps.InputReportByteLength - 1;
-				maxPacketOutputLength = caps.OutputReportByteLength - 1;
-			}
-			HidD_FreePreparsedData(ppData);
-		}
-		if (maxPacketInputLength <= 0 || maxPacketInputLength >= 0xF000)
-		{
-			forceLog_printf("HID: Input packet length not available or out of range (length = %d)", maxPacketInputLength);
-			maxPacketInputLength = 0x20;
-		}
-		if (maxPacketOutputLength <= 0 || maxPacketOutputLength >= 0xF000)
-		{
-			forceLog_printf("HID: Output packet length not available or out of range (length = %d)", maxPacketOutputLength);
-			maxPacketOutputLength = 0x20;
-		}
-		// setup HIDDevice struct
-		deviceInfo->hidDevice = hidDevice;
-		memset(hidDevice, 0, sizeof(HIDDevice_t));
-		hidDevice->handle = deviceInfo->handle;
-		hidDevice->vendorId = deviceInfo->vendorId;
-		hidDevice->productId = deviceInfo->productId;
-		hidDevice->maxPacketSizeRX = maxPacketInputLength;
-		hidDevice->maxPacketSizeTX = maxPacketOutputLength;
-
-		hidDevice->ukn04 = 0x11223344;
-
-		hidDevice->ifIndex = 1;
-		hidDevice->protocol = 0;
-		hidDevice->subClass = 2;
-
-		// todo - other values
-		//hidDevice->ifIndex = 1;
-
-
-		attachDeviceToList(deviceInfo);
-
+		size_t index = HIDPoolIndexQueue.front();
+		HIDPoolIndexQueue.pop();
+		return HIDPool.GetPtr() + index;
 	}
 
-	void initDeviceList()
+	void ReleaseHID(HID_t* device)
 	{
-		if (firstDevice)
-			return;
-		HDEVINFO                         hDevInfo;
-		SP_DEVICE_INTERFACE_DATA         DevIntfData;
-		PSP_DEVICE_INTERFACE_DETAIL_DATA DevIntfDetailData;
-		SP_DEVINFO_DATA                  DevData;
-
-		DWORD dwSize, dwMemberIdx;
-
-		hDevInfo = SetupDiGetClassDevs(&GUID_DEVINTERFACE_HID, NULL, 0, DIGCF_DEVICEINTERFACE | DIGCF_PRESENT);
-
-		if (hDevInfo != INVALID_HANDLE_VALUE)
+		// this should never happen, but having a safeguard can't hurt
+		if (device == nullptr)
 		{
-			DevIntfData.cbSize = sizeof(SP_DEVICE_INTERFACE_DATA);
-			dwMemberIdx = 0;
-
-			SetupDiEnumDeviceInterfaces(hDevInfo, NULL, &GUID_DEVINTERFACE_HID,
-				dwMemberIdx, &DevIntfData);
-
-			while (GetLastError() != ERROR_NO_MORE_ITEMS)
-			{
-				DevData.cbSize = sizeof(DevData);
-				SetupDiGetDeviceInterfaceDetail(
-					hDevInfo, &DevIntfData, NULL, 0, &dwSize, NULL);
-
-				DevIntfDetailData = (PSP_DEVICE_INTERFACE_DETAIL_DATA)HeapAlloc(GetProcessHeap(), HEAP_ZERO_MEMORY, dwSize);
-				DevIntfDetailData->cbSize = sizeof(SP_DEVICE_INTERFACE_DETAIL_DATA);
-
-				if (SetupDiGetDeviceInterfaceDetail(hDevInfo, &DevIntfData,
-					DevIntfDetailData, dwSize, &dwSize, &DevData))
-				{
-					HANDLE hHIDDevice = openDevice(DevIntfDetailData->DevicePath);
-					if (hHIDDevice != INVALID_HANDLE_VALUE)
-					{
-						checkAndAddDevice(DevIntfDetailData->DevicePath, hHIDDevice);
-						CloseHandle(hHIDDevice);
-					}
-				}
-				HeapFree(GetProcessHeap(), 0, DevIntfDetailData);
-				// next
-				SetupDiEnumDeviceInterfaces(hDevInfo, NULL, &GUID_DEVINTERFACE_HID, ++dwMemberIdx, &DevIntfData);
-			}
-			SetupDiDestroyDeviceInfoList(hDevInfo);
+			cemu_assert_error();
 		}
+		std::lock_guard<std::recursive_mutex> lock(hidMutex);
+		InitHIDPoolIndexQueue();
+		size_t index = device - HIDPool.GetPtr();
+		HIDPoolIndexQueue.push(index);
 	}
 
 	const int HID_CALLBACK_DETACH = 0;
 	const int HID_CALLBACK_ATTACH = 1;
 
-	uint32 doAttachCallback(HIDClient_t* hidClient, HIDDeviceInfo_t* deviceInfo)
+	uint32 DoAttachCallback(HIDClient_t* hidClient, const std::shared_ptr<Device>& device)
 	{
-		return PPCCoreCallback(hidClient->callbackFunc, memory_getVirtualOffsetFromPointer(hidClient), memory_getVirtualOffsetFromPointer(deviceInfo->hidDevice), HID_CALLBACK_ATTACH);
+		return PPCCoreCallback(hidClient->callbackFunc, memory_getVirtualOffsetFromPointer(hidClient),
+							   memory_getVirtualOffsetFromPointer(device->m_hid), HID_CALLBACK_ATTACH);
 	}
 
-	void doDetachCallback(HIDClient_t* hidClient, HIDDeviceInfo_t* deviceInfo)
+	void DoAttachCallbackAsync(HIDClient_t* hidClient, const std::shared_ptr<Device>& device)
 	{
-		PPCCoreCallback(hidClient->callbackFunc, memory_getVirtualOffsetFromPointer(hidClient), memory_getVirtualOffsetFromPointer(deviceInfo->hidDevice), HID_CALLBACK_DETACH);
+		coreinitAsyncCallback_add(hidClient->callbackFunc, 3, memory_getVirtualOffsetFromPointer(hidClient),
+								  memory_getVirtualOffsetFromPointer(device->m_hid), HID_CALLBACK_ATTACH);
+	}
+
+	void DoDetachCallback(HIDClient_t* hidClient, const std::shared_ptr<Device>& device)
+	{
+		PPCCoreCallback(hidClient->callbackFunc, memory_getVirtualOffsetFromPointer(hidClient),
+						memory_getVirtualOffsetFromPointer(device->m_hid), HID_CALLBACK_DETACH);
+	}
+
+	void DoDetachCallbackAsync(HIDClient_t* hidClient, const std::shared_ptr<Device>& device)
+	{
+		coreinitAsyncCallback_add(hidClient->callbackFunc, 3, memory_getVirtualOffsetFromPointer(hidClient),
+								  memory_getVirtualOffsetFromPointer(device->m_hid), HID_CALLBACK_DETACH);
+	}
+
+	void AttachBackend(const std::shared_ptr<Backend>& backend)
+	{
+		{
+			std::lock_guard<std::recursive_mutex> lock(hidMutex);
+			backendList.push_back(backend);
+		}
+		backend->OnAttach();
+	}
+
+	void DetachBackend(const std::shared_ptr<Backend>& backend)
+	{
+		{
+			std::lock_guard<std::recursive_mutex> lock(hidMutex);
+			backendList.remove(backend);
+		}
+		backend->OnDetach();
+	}
+
+	void DetachAllBackends()
+	{
+		std::list<std::shared_ptr<Backend>> backendListCopy;
+		{
+			std::lock_guard<std::recursive_mutex> lock(hidMutex);
+			backendListCopy = backendList;
+			backendList.clear();
+		}
+		for (const auto& backend : backendListCopy)
+		{
+			backend->OnDetach();
+		}
+	}
+
+	void AttachDefaultBackends()
+	{
+		backend::AttachDefaultBackends();
+	}
+
+	bool AttachDevice(const std::shared_ptr<Device>& device)
+	{
+		std::lock_guard<std::recursive_mutex> lock(hidMutex);
+
+		// is the device already attached?
+		{
+			auto it = std::find(deviceList.begin(), deviceList.end(), device);
+			if (it != deviceList.end())
+			{
+				cemuLog_logDebug(LogType::Force,
+								 "nsyshid.AttachDevice(): failed to attach device: {:04x}:{:04x}: already attached",
+								 device->m_vendorId,
+								 device->m_productId);
+				return false;
+			}
+		}
+
+		HID_t* hidDevice = GetFreeHID();
+		if (hidDevice == nullptr)
+		{
+			cemuLog_logDebug(LogType::Force,
+							 "nsyshid.AttachDevice(): failed to attach device: {:04x}:{:04x}: no free device slots left",
+							 device->m_vendorId,
+							 device->m_productId);
+			return false;
+		}
+		hidDevice->handle = GenerateHIDHandle();
+		device->AssignHID(hidDevice);
+		deviceList.push_back(device);
+
+		// do attach callbacks
+		for (auto client : HIDClientList)
+		{
+			DoAttachCallbackAsync(client, device);
+		}
+
+		cemuLog_logDebug(LogType::Force, "nsyshid.AttachDevice(): device attached: {:04x}:{:04x}",
+						 device->m_vendorId,
+						 device->m_productId);
+		return true;
+	}
+
+	void DetachDevice(const std::shared_ptr<Device>& device)
+	{
+		{
+			std::lock_guard<std::recursive_mutex> lock(hidMutex);
+
+			// remove from list
+			auto it = std::find(deviceList.begin(), deviceList.end(), device);
+			if (it == deviceList.end())
+			{
+				cemuLog_logDebug(LogType::Force, "nsyshid.DetachDevice(): device not found: {:04x}:{:04x}",
+								 device->m_vendorId,
+								 device->m_productId);
+				return;
+			}
+			deviceList.erase(it);
+
+			// do detach callbacks
+			for (auto client : HIDClientList)
+			{
+				DoDetachCallbackAsync(client, device);
+			}
+			ReleaseHID(device->m_hid);
+		}
+
+		device->Close();
+
+		cemuLog_logDebug(LogType::Force, "nsyshid.DetachDevice(): device removed: {:04x}:{:04x}",
+						 device->m_vendorId,
+						 device->m_productId);
+	}
+
+	std::shared_ptr<Device> FindDeviceById(uint16 vendorId, uint16 productId)
+	{
+		std::lock_guard<std::recursive_mutex> lock(hidMutex);
+		for (const auto& device : deviceList)
+		{
+			if (device->m_vendorId == vendorId && device->m_productId == productId)
+			{
+				return device;
+			}
+		}
+		return nullptr;
 	}
 
 	void export_HIDAddClient(PPCInterpreter_t* hCPU)
 	{
 		ppcDefineParamTypePtr(hidClient, HIDClient_t, 0);
 		ppcDefineParamMPTR(callbackFuncMPTR, 1);
-		forceLogDebug_printf("nsyshid.HIDAddClient(0x%08x,0x%08x)", hCPU->gpr[3], hCPU->gpr[4]);
+		cemuLog_logDebug(LogType::Force, "nsyshid.HIDAddClient(0x{:08x},0x{:08x})", hCPU->gpr[3], hCPU->gpr[4]);
 		hidClient->callbackFunc = callbackFuncMPTR;
-		attachClientToList(hidClient);
-		initDeviceList();
+
+		std::lock_guard<std::recursive_mutex> lock(hidMutex);
+		AttachClientToList(hidClient);
+
 		// do attach callbacks
-		HIDDeviceInfo_t* deviceItr = firstDevice;
-		while (deviceItr)
+		for (const auto& device : deviceList)
 		{
-			if (doAttachCallback(hidClient, deviceItr) != 0)
-				break;
-			deviceItr = deviceItr->next;
+			DoAttachCallback(hidClient, device);
 		}
 
 		osLib_returnFromFunction(hCPU, 0);
@@ -309,375 +291,411 @@ namespace nsyshid
 	void export_HIDDelClient(PPCInterpreter_t* hCPU)
 	{
 		ppcDefineParamTypePtr(hidClient, HIDClient_t, 0);
-		forceLogDebug_printf("nsyshid.HIDDelClient(0x%08x)", hCPU->gpr[3]);
-	
-		// todo
+		cemuLog_logDebug(LogType::Force, "nsyshid.HIDDelClient(0x{:08x})", hCPU->gpr[3]);
+
+		std::lock_guard<std::recursive_mutex> lock(hidMutex);
+		DetachClientFromList(hidClient);
+
 		// do detach callbacks
-		HIDDeviceInfo_t* deviceItr = firstDevice;
-		while (deviceItr)
+		for (const auto& device : deviceList)
 		{
-			doDetachCallback(hidClient, deviceItr);
-			deviceItr = deviceItr->next;
+			DoDetachCallback(hidClient, device);
 		}
 
 		osLib_returnFromFunction(hCPU, 0);
 	}
 
-	void export_HIDGetDescriptor(PPCInterpreter_t* hCPU)
+	void _debugPrintHex(const std::string prefix, const uint8* data, size_t size)
 	{
-		ppcDefineParamU32(hidHandle, 0); // r3
-		ppcDefineParamU8(descType, 1); // r4
-		ppcDefineParamU8(descIndex, 2); // r5
-		ppcDefineParamU8(lang, 3); // r6
-		ppcDefineParamUStr(output, 4); // r7
-		ppcDefineParamU32(outputMaxLength, 5); // r8
-		ppcDefineParamMPTR(cbFuncMPTR, 6); // r9
-		ppcDefineParamMPTR(cbParamMPTR, 7); // r10
+		constexpr size_t BYTES_PER_LINE = 16;
 
-		HIDDeviceInfo_t* hidDeviceInfo = getHIDDeviceInfoByHandle(hidHandle);
-		if (hidDeviceInfo)
+		std::string out;
+		for (size_t row_start = 0; row_start < size; row_start += BYTES_PER_LINE)
 		{
-			HANDLE hHIDDevice = openDevice(hidDeviceInfo->devicePath);
-			if (hHIDDevice != INVALID_HANDLE_VALUE)
+			out += fmt::format("{:06x}: ", row_start);
+			for (size_t i = 0; i < BYTES_PER_LINE; ++i)
 			{
-				if (descType == 0x02)
+				if (row_start + i < size)
 				{
-					uint8 configurationDescriptor[0x29];
-
-					uint8* currentWritePtr;
-
-					// configuration descriptor
-					currentWritePtr = configurationDescriptor + 0;
-					*(uint8*)(currentWritePtr + 0) = 9; // bLength
-					*(uint8*)(currentWritePtr + 1) = 2; // bDescriptorType
-					*(uint16be*)(currentWritePtr + 2) = 0x0029; // wTotalLength
-					*(uint8*)(currentWritePtr + 4) = 1; // bNumInterfaces
-					*(uint8*)(currentWritePtr + 5) = 1; // bConfigurationValue
-					*(uint8*)(currentWritePtr + 6) = 0; // iConfiguration
-					*(uint8*)(currentWritePtr + 7) = 0x80; // bmAttributes
-					*(uint8*)(currentWritePtr + 8) = 0xFA; // MaxPower
-					currentWritePtr = currentWritePtr + 9;
-					// configuration descriptor
-					*(uint8*)(currentWritePtr + 0) = 9; // bLength
-					*(uint8*)(currentWritePtr + 1) = 0x04; // bDescriptorType
-					*(uint8*)(currentWritePtr + 2) = 0; // bInterfaceNumber
-					*(uint8*)(currentWritePtr + 3) = 0; // bAlternateSetting
-					*(uint8*)(currentWritePtr + 4) = 2; // bNumEndpoints
-					*(uint8*)(currentWritePtr + 5) = 3; // bInterfaceClass
-					*(uint8*)(currentWritePtr + 6) = 0; // bInterfaceSubClass
-					*(uint8*)(currentWritePtr + 7) = 0; // bInterfaceProtocol
-					*(uint8*)(currentWritePtr + 8) = 0; // iInterface
-					currentWritePtr = currentWritePtr + 9;
-					// configuration descriptor
-					*(uint8*)(currentWritePtr + 0) = 9; // bLength
-					*(uint8*)(currentWritePtr + 1) = 0x21; // bDescriptorType
-					*(uint16be*)(currentWritePtr + 2) = 0x0111; // bcdHID
-					*(uint8*)(currentWritePtr + 4) = 0x00; // bCountryCode
-					*(uint8*)(currentWritePtr + 5) = 0x01; // bNumDescriptors
-					*(uint8*)(currentWritePtr + 6) = 0x22; // bDescriptorType
-					*(uint16be*)(currentWritePtr + 7) = 0x001D; // wDescriptorLength
-					currentWritePtr = currentWritePtr + 9;
-					// endpoint descriptor 1
-					*(uint8*)(currentWritePtr + 0) = 7; // bLength
-					*(uint8*)(currentWritePtr + 1) = 0x05; // bDescriptorType
-					*(uint8*)(currentWritePtr + 1) = 0x81; // bEndpointAddress
-					*(uint8*)(currentWritePtr + 2) = 0x03; // bmAttributes
-					*(uint16be*)(currentWritePtr + 3) = 0x40; // wMaxPacketSize
-					*(uint8*)(currentWritePtr + 5) = 0x01; // bInterval
-					currentWritePtr = currentWritePtr + 7;
-					// endpoint descriptor 2
-					*(uint8*)(currentWritePtr + 0) = 7; // bLength
-					*(uint8*)(currentWritePtr + 1) = 0x05; // bDescriptorType
-					*(uint8*)(currentWritePtr + 1) = 0x02; // bEndpointAddress
-					*(uint8*)(currentWritePtr + 2) = 0x03; // bmAttributes
-					*(uint16be*)(currentWritePtr + 3) = 0x40; // wMaxPacketSize
-					*(uint8*)(currentWritePtr + 5) = 0x01; // bInterval
-					currentWritePtr = currentWritePtr + 7;
-
-					cemu_assert_debug((currentWritePtr - configurationDescriptor) == 0x29);
-
-					memcpy(output, configurationDescriptor, std::min<uint32>(outputMaxLength, sizeof(configurationDescriptor)));
+					out += fmt::format("{:02x} ", data[row_start + i]);
 				}
 				else
 				{
-					cemu_assert_unimplemented();
+					out += "   ";
 				}
-				CloseHandle(hHIDDevice);
 			}
-			else
+			out += " ";
+			for (size_t i = 0; i < BYTES_PER_LINE; ++i)
 			{
-				cemu_assert_unimplemented();
+				if (row_start + i < size)
+				{
+					char c = static_cast<char>(data[row_start + i]);
+					out += std::isprint(c, std::locale::classic()) ? c : '.';
+				}
 			}
+			out += "\n";
 		}
-		else
-		{
-			cemu_assert_suspicious();
-		}
-		osLib_returnFromFunction(hCPU, 0);
+		cemuLog_logDebug(LogType::Force, "[{}] Data: \n{}", prefix, out);
 	}
 
-	void _debugPrintHex(std::string prefix, uint8* data, size_t len)
-	{
-		char debugOutput[1024] = { 0 };
-		len = std::min(len, (size_t)100);
-		for (sint32 i = 0; i < len; i++)
-		{
-			sprintf(debugOutput + i * 3, "%02x ", data[i]);
-		}
-		forceLogDebug_printf("[%s] Data: %s", prefix.c_str(), debugOutput);
-	}
-
-	void doHIDTransferCallback(MPTR callbackFuncMPTR, MPTR callbackParamMPTR, uint32 hidHandle, uint32 errorCode, MPTR buffer, sint32 length)
+	void DoHIDTransferCallback(MPTR callbackFuncMPTR, MPTR callbackParamMPTR, uint32 hidHandle, uint32 errorCode,
+							   MPTR buffer, sint32 length)
 	{
 		coreinitAsyncCallback_add(callbackFuncMPTR, 5, hidHandle, errorCode, buffer, length, callbackParamMPTR);
 	}
 
-	void export_HIDSetIdle(PPCInterpreter_t* hCPU)
+	void _hidGetDescriptorAsync(std::shared_ptr<Device> device, uint8 descType, uint8 descIndex, uint16 lang, uint8* output, uint32 outputMaxLength, MPTR callbackFuncMPTR, MPTR callbackParamMPTR)
 	{
-		ppcDefineParamU32(hidHandle, 0); // r3
-		ppcDefineParamU32(ifIndex, 1); // r4
-		ppcDefineParamU32(ukn, 2); // r5
-		ppcDefineParamU32(duration, 3); // r6
-		ppcDefineParamMPTR(callbackFuncMPTR, 4); // r7
-		ppcDefineParamMPTR(callbackParamMPTR, 5); // r8
-		forceLogDebug_printf("nsyshid.HIDSetIdle(...)");
-
-		// todo
-		if (callbackFuncMPTR)
+		if (device->GetDescriptor(descType, descIndex, lang, output, outputMaxLength))
 		{
-			doHIDTransferCallback(callbackFuncMPTR, callbackParamMPTR, hidHandle, 0, MPTR_NULL, 0);
+			DoHIDTransferCallback(callbackFuncMPTR,
+								  callbackParamMPTR,
+								  device->m_hid->handle,
+								  0,
+								  0,
+								  0);
 		}
 		else
 		{
-			cemu_assert_unimplemented();
+			DoHIDTransferCallback(callbackFuncMPTR,
+								  callbackParamMPTR,
+								  device->m_hid->handle,
+								  -1,
+								  0,
+								  0);
 		}
-		osLib_returnFromFunction(hCPU, 0); // for non-async version, return number of bytes transferred
 	}
 
-	void export_HIDSetProtocol(PPCInterpreter_t* hCPU)
+	void export_HIDGetDescriptor(PPCInterpreter_t* hCPU)
 	{
-		ppcDefineParamU32(hidHandle, 0); // r3
-		ppcDefineParamU32(ifIndex, 1); // r4
-		ppcDefineParamU32(protocol, 2); // r5
-		ppcDefineParamMPTR(callbackFuncMPTR, 3); // r6
-		ppcDefineParamMPTR(callbackParamMPTR, 4); // r7
-		forceLogDebug_printf("nsyshid.HIDSetProtocol(...)");
-		
-		if (callbackFuncMPTR)
+		ppcDefineParamU32(hidHandle, 0);	   // r3
+		ppcDefineParamU8(descType, 1);		   // r4
+		ppcDefineParamU8(descIndex, 2);		   // r5
+		ppcDefineParamU16(lang, 3);			   // r6
+		ppcDefineParamUStr(output, 4);		   // r7
+		ppcDefineParamU32(outputMaxLength, 5); // r8
+		ppcDefineParamMPTR(cbFuncMPTR, 6);	   // r9
+		ppcDefineParamMPTR(cbParamMPTR, 7);	   // r10
+		cemuLog_logDebug(LogType::Force, "nsyshid.HIDGetDescriptor(0x{:08x}, 0x{:02x}, 0x{:02x}, 0x{:04x}, 0x{:x}, 0x{:08x}, 0x{:08x}, 0x{:08x})",
+					hCPU->gpr[3], hCPU->gpr[4], hCPU->gpr[5], hCPU->gpr[6], hCPU->gpr[7], hCPU->gpr[8], hCPU->gpr[9], hCPU->gpr[10]);
+
+		std::shared_ptr<Device> device = GetDeviceByHandle(hidHandle, true);
+		if (device == nullptr)
 		{
-			doHIDTransferCallback(callbackFuncMPTR, callbackParamMPTR, hidHandle, 0, MPTR_NULL, 0);
-		}
-		else
-		{
-			cemu_assert_unimplemented();
-		}
-		osLib_returnFromFunction(hCPU, 0); // for non-async version, return number of bytes transferred
-	}
-
-	// handler for async HIDSetReport transfers
-	void _hidSetReportAsync(HIDDeviceInfo_t* hidDeviceInfo, uint8* reportData, sint32 length, uint8* originalData, sint32 originalLength, MPTR callbackFuncMPTR, MPTR callbackParamMPTR)
-	{
-		sint32 retryCount = 0;
-		while (true)
-		{
-			BOOL r = HidD_SetOutputReport(hidDeviceInfo->hFile, reportData, length);
-			if (r != FALSE)
-				break;
-			Sleep(20); // retry
-			retryCount++;
-			if (retryCount >= 40)
-			{
-				forceLog_printf("HID async SetReport failed");
-				sint32 errorCode = -1;
-				doHIDTransferCallback(callbackFuncMPTR, callbackParamMPTR, hidDeviceInfo->handle, errorCode, memory_getVirtualOffsetFromPointer(originalData), 0);
-				free(reportData);
-				return;
-			}
-		}
-		doHIDTransferCallback(callbackFuncMPTR, callbackParamMPTR, hidDeviceInfo->handle, 0, memory_getVirtualOffsetFromPointer(originalData), originalLength);
-		free(reportData);
-	}
-
-	// handler for synchronous HIDSetReport transfers
-	sint32 _hidSetReportSync(HIDDeviceInfo_t* hidDeviceInfo, uint8* reportData, sint32 length, uint8* originalData, sint32 originalLength, OSThread_t* osThread)
-	{
-		//forceLogDebug_printf("_hidSetReportSync begin");
-		_debugPrintHex("_hidSetReportSync Begin", reportData, length);
-		sint32 retryCount = 0;
-		sint32 returnCode = 0;
-		while (true)
-		{
-			BOOL r = HidD_SetOutputReport(hidDeviceInfo->hFile, reportData, length);
-			if (r != FALSE)
-			{
-				returnCode = originalLength;
-				break;
-			}
-			Sleep(100); // retry
-			retryCount++;
-			if (retryCount >= 10)
-				assert_dbg();
-		}
-		free(reportData);
-		forceLogDebug_printf("_hidSetReportSync end. returnCode: %d", returnCode);
-		coreinit_resumeThread(osThread, 1000);
-		return returnCode;
-	}
-
-	void export_HIDSetReport(PPCInterpreter_t* hCPU)
-	{
-		ppcDefineParamU32(hidHandle, 0); // r3
-		ppcDefineParamU32(reportRelatedUkn, 1); // r4
-		ppcDefineParamU32(reportId, 2); // r5
-		ppcDefineParamUStr(data, 3); // r6
-		ppcDefineParamU32(dataLength, 4); // r7
-		ppcDefineParamMPTR(callbackFuncMPTR, 5); // r8
-		ppcDefineParamMPTR(callbackParamMPTR, 6); // r9
-		forceLogDebug_printf("nsyshid.HIDSetReport(%d,0x%02x,0x%02x,...)", hidHandle, reportRelatedUkn, reportId);
-
-		_debugPrintHex("HIDSetReport", data, dataLength);
-
-#ifndef PUBLIC_RELEASE
-		if (reportRelatedUkn != 2 || reportId != 0)
-			assert_dbg();
-#endif
-
-		HIDDeviceInfo_t* hidDeviceInfo = getHIDDeviceInfoByHandle(hidHandle, true);
-		if (hidDeviceInfo == nullptr)
-		{
-			forceLog_printf("nsyshid.HIDSetReport(): Unable to find device with hid handle %d", hidHandle);
+			cemuLog_log(LogType::Force, "nsyshid.HIDGetDescriptor(): Unable to find device with hid handle {}", hidHandle);
 			osLib_returnFromFunction(hCPU, -1);
 			return;
 		}
 
-		// prepare report data
-		// note: Currently we need to pad the data to 0x20 bytes for it to work (plus one extra byte for HidD_SetOutputReport)
-		// Does IOSU pad data to 0x20 byte? Also check if this is specific to Skylanders portal 
-		sint32 paddedLength = (dataLength +0x1F)&~0x1F;
-		uint8* reportData = (uint8*)malloc(paddedLength+1);
-		memset(reportData, 0, paddedLength+1);
-		reportData[0] = 0;
-		memcpy(reportData + 1, data, dataLength);
+		// issue request (synchronous or asynchronous)
+		sint32 returnCode = 0;
+		if (cbFuncMPTR == MPTR_NULL)
+		{
+			// synchronous
+			returnCode = -1;
+			if (device->GetDescriptor(descType, descIndex, lang, output, outputMaxLength))
+			{
+				returnCode = outputMaxLength;
+			}
+		}
+		else
+		{
+			// asynchronous
+			std::thread(&_hidGetDescriptorAsync, device, descType, descIndex, lang, output, outputMaxLength, cbFuncMPTR, cbParamMPTR)
+				.detach();
+			returnCode = 0;
+		}
+		osLib_returnFromFunction(hCPU, returnCode);
+	}
 
+	void _hidSetIdleAsync(std::shared_ptr<Device> device, uint8 ifIndex, uint8 reportId, uint8 duration, MPTR callbackFuncMPTR, MPTR callbackParamMPTR)
+	{
+		if (device->SetIdle(ifIndex, reportId, duration))
+		{
+			DoHIDTransferCallback(callbackFuncMPTR,
+								  callbackParamMPTR,
+								  device->m_hid->handle,
+								  0,
+								  0,
+								  0);
+		}
+		else
+		{
+			DoHIDTransferCallback(callbackFuncMPTR,
+								  callbackParamMPTR,
+								  device->m_hid->handle,
+								  -1,
+								  0,
+								  0);
+		}
+	}
+
+	void export_HIDSetIdle(PPCInterpreter_t* hCPU)
+	{
+		ppcDefineParamU32(hidHandle, 0);		  // r3
+		ppcDefineParamU8(ifIndex, 1);			  // r4
+		ppcDefineParamU8(reportId, 2);			  // r5
+		ppcDefineParamU8(duration, 3);			  // r6
+		ppcDefineParamMPTR(callbackFuncMPTR, 4);  // r7
+		ppcDefineParamMPTR(callbackParamMPTR, 5); // r8
+		cemuLog_logDebug(LogType::Force, "nsyshid.HIDSetIdle(0x{:08x}, 0x{:02x}, 0x{:02x}, 0x{:02x}, 0x{:08x}, 0x{:08x})", hCPU->gpr[3],
+					hCPU->gpr[4], hCPU->gpr[5], hCPU->gpr[6], hCPU->gpr[7], hCPU->gpr[8]);
+
+		std::shared_ptr<Device> device = GetDeviceByHandle(hidHandle, true);
+		if (device == nullptr)
+		{
+			cemuLog_log(LogType::Force, "nsyshid.HIDSetIdle(): Unable to find device with hid handle {}", hidHandle);
+			osLib_returnFromFunction(hCPU, -1);
+			return;
+		}
 
 		// issue request (synchronous or asynchronous)
 		sint32 returnCode = 0;
 		if (callbackFuncMPTR == MPTR_NULL)
 		{
-			std::future<sint32> res = std::async(std::launch::async, &_hidSetReportSync, hidDeviceInfo, reportData, paddedLength + 1, data, dataLength, coreinitThread_getCurrentThreadDepr(hCPU));
-			coreinit_suspendThread(coreinitThread_getCurrentThreadDepr(hCPU), 1000);
-			PPCCore_switchToScheduler();
+			// synchronous
+			returnCode = -1;
+			if (device->SetIdle(ifIndex, reportId, duration))
+			{
+				returnCode = 0;
+			}
+		}
+		else
+		{
+			// asynchronous
+			std::thread(&_hidSetIdleAsync, device, ifIndex, reportId, duration, callbackFuncMPTR, callbackParamMPTR)
+				.detach();
+			returnCode = 0;
+		}
+		osLib_returnFromFunction(hCPU, returnCode);
+	}
+
+	void _hidSetProtocolAsync(std::shared_ptr<Device> device, uint8 ifIndex, uint8 protocol, MPTR callbackFuncMPTR, MPTR callbackParamMPTR)
+	{
+		if (device->SetProtocol(ifIndex, protocol))
+		{
+			DoHIDTransferCallback(callbackFuncMPTR,
+								  callbackParamMPTR,
+								  device->m_hid->handle,
+								  0,
+								  0,
+								  0);
+		}
+		else
+		{
+			DoHIDTransferCallback(callbackFuncMPTR,
+								  callbackParamMPTR,
+								  device->m_hid->handle,
+								  -1,
+								  0,
+								  0);
+		}
+	}
+
+	void export_HIDSetProtocol(PPCInterpreter_t* hCPU)
+	{
+		ppcDefineParamU32(hidHandle, 0);		  // r3
+		ppcDefineParamU8(ifIndex, 1);			  // r4
+		ppcDefineParamU8(protocol, 2);			  // r5
+		ppcDefineParamMPTR(callbackFuncMPTR, 3);  // r6
+		ppcDefineParamMPTR(callbackParamMPTR, 4); // r7
+		cemuLog_logDebug(LogType::Force, "nsyshid.HIDSetProtocol(0x{:08x}, 0x{:02x}, 0x{:02x}, 0x{:08x}, 0x{:08x})", hCPU->gpr[3],
+					hCPU->gpr[4], hCPU->gpr[5], hCPU->gpr[6], hCPU->gpr[7]);
+
+		std::shared_ptr<Device> device = GetDeviceByHandle(hidHandle, true);
+		if (device == nullptr)
+		{
+			cemuLog_log(LogType::Force, "nsyshid.HIDSetProtocol(): Unable to find device with hid handle {}", hidHandle);
+			osLib_returnFromFunction(hCPU, -1);
+			return;
+		}
+		// issue request (synchronous or asynchronous)
+		sint32 returnCode = 0;
+		if (callbackFuncMPTR == MPTR_NULL)
+		{
+			// synchronous
+			returnCode = -1;
+			if (device->SetProtocol(ifIndex, protocol))
+			{
+				returnCode = 0;
+			}
+		}
+		else
+		{
+			// asynchronous
+			std::thread(&_hidSetProtocolAsync, device, ifIndex, protocol, callbackFuncMPTR, callbackParamMPTR)
+				.detach();
+			returnCode = 0;
+		}
+		osLib_returnFromFunction(hCPU, returnCode);
+	}
+
+	// handler for async HIDSetReport transfers
+	void _hidSetReportAsync(std::shared_ptr<Device> device, uint8 reportType, uint8 reportId, uint8* data, uint32 length,
+							MPTR callbackFuncMPTR, MPTR callbackParamMPTR)
+	{
+		cemuLog_logDebug(LogType::Force, "_hidSetReportAsync begin");
+		ReportMessage message(reportType, reportId, data, length);
+		if (device->SetReport(&message))
+		{
+			DoHIDTransferCallback(callbackFuncMPTR,
+								  callbackParamMPTR,
+								  device->m_hid->handle,
+								  0,
+								  memory_getVirtualOffsetFromPointer(data),
+								  length);
+		}
+		else
+		{
+			DoHIDTransferCallback(callbackFuncMPTR,
+								  callbackParamMPTR,
+								  device->m_hid->handle,
+								  -1,
+								  memory_getVirtualOffsetFromPointer(data),
+								  length);
+		}
+	}
+
+	// handler for synchronous HIDSetReport transfers
+	sint32 _hidSetReportSync(std::shared_ptr<Device> device, uint8 reportType, uint8 reportId,
+							 uint8* data, uint32 length, coreinit::OSEvent* event)
+	{
+		_debugPrintHex("_hidSetReportSync Begin", data, length);
+		sint32 returnCode = 0;
+		ReportMessage message(reportType, reportId, data, length);
+		if (device->SetReport(&message))
+		{
+			returnCode = length;
+		}
+		cemuLog_logDebug(LogType::Force, "_hidSetReportSync end. returnCode: {}", returnCode);
+		coreinit::OSSignalEvent(event);
+		return returnCode;
+	}
+
+	void export_HIDSetReport(PPCInterpreter_t* hCPU)
+	{
+		ppcDefineParamU32(hidHandle, 0);		  // r3
+		ppcDefineParamU8(reportType, 1);		  // r4
+		ppcDefineParamU8(reportId, 2);			  // r5
+		ppcDefineParamUStr(data, 3);			  // r6
+		ppcDefineParamU32(dataLength, 4);		  // r7
+		ppcDefineParamMPTR(callbackFuncMPTR, 5);  // r8
+		ppcDefineParamMPTR(callbackParamMPTR, 6); // r9
+		cemuLog_logDebug(LogType::Force, "nsyshid.HIDSetReport(0x{:08x}, 0x{:02x}, 0x{:02x}, 0x{:08x}, 0x{:08x}, 0x{:08x}, 0x{:08x})", hCPU->gpr[3],
+					hCPU->gpr[4], hCPU->gpr[5], hCPU->gpr[6], hCPU->gpr[7], hCPU->gpr[8], hCPU->gpr[9]);
+
+		_debugPrintHex("HIDSetReport", data, dataLength);
+
+#ifdef CEMU_DEBUG_ASSERT
+		if (reportType != 2 || reportId != 0)
+			assert_dbg();
+#endif
+
+		std::shared_ptr<Device> device = GetDeviceByHandle(hidHandle, true);
+		if (device == nullptr)
+		{
+			cemuLog_log(LogType::Force, "nsyshid.HIDSetReport(): Unable to find device with hid handle {}", hidHandle);
+			osLib_returnFromFunction(hCPU, -1);
+			return;
+		}
+
+		// issue request (synchronous or asynchronous)
+		sint32 returnCode = 0;
+		if (callbackFuncMPTR == MPTR_NULL)
+		{
+			// synchronous
+			StackAllocator<coreinit::OSEvent> event;
+			coreinit::OSInitEvent(&event, coreinit::OSEvent::EVENT_STATE::STATE_NOT_SIGNALED, coreinit::OSEvent::EVENT_MODE::MODE_AUTO);
+			std::future<sint32> res = std::async(std::launch::async, &_hidSetReportSync, device, reportType, reportId, data, dataLength, &event);
+			coreinit::OSWaitEvent(&event);
 			returnCode = res.get();
 		}
 		else
 		{
 			// asynchronous
-			std::thread(&_hidSetReportAsync, hidDeviceInfo, reportData, paddedLength+1, data, dataLength, callbackFuncMPTR, callbackParamMPTR).detach();
+			std::thread(&_hidSetReportAsync, device, reportType, reportId, data, dataLength,
+						callbackFuncMPTR, callbackParamMPTR)
+				.detach();
 			returnCode = 0;
 		}
 		osLib_returnFromFunction(hCPU, returnCode);
 	}
 
-	sint32 _hidReadInternalSync(HIDDeviceInfo_t* hidDeviceInfo, uint8* data, sint32 maxLength)
+	sint32 _hidReadInternalSync(std::shared_ptr<Device> device, uint8* data, sint32 maxLength)
 	{
-		DWORD bt;
-		OVERLAPPED ovlp = { 0 };
-		ovlp.hEvent = CreateEvent(NULL, TRUE, FALSE, NULL);
-
-		uint8* tempBuffer = (uint8*)malloc(maxLength + 1);
-		sint32 transferLength = 0; // minus report byte
-
-		_debugPrintHex("HID_READ_BEFORE", data, maxLength);
-
-		forceLogDebug_printf("HidRead Begin (Length 0x%08x)", maxLength);
-		BOOL readResult = ReadFile(hidDeviceInfo->hFile, tempBuffer, maxLength + 1, &bt, &ovlp);
-		if (readResult != FALSE)
+		cemuLog_logDebug(LogType::Force, "HidRead Begin (Length 0x{:08x})", maxLength);
+		if (!device->IsOpened())
 		{
-			// sometimes we get the result immediately
-			if (bt == 0)
-				transferLength = 0;
-			else
-				transferLength = bt - 1;
-			forceLogDebug_printf("HidRead Result received immediately (error 0x%08x) Length 0x%08x", GetLastError(), transferLength);
+			cemuLog_logDebug(LogType::Force, "nsyshid.hidReadInternalSync(): cannot read from a non-opened device");
+			return -1;
 		}
-		else
+		memset(data, 0, maxLength);
+		ReadMessage message(data, maxLength, 0);
+		Device::ReadResult readResult = device->Read(&message);
+		switch (readResult)
 		{
-			// wait for result
-			forceLogDebug_printf("HidRead WaitForResult (error 0x%08x)", GetLastError());
-			// async hid read is never supposed to return unless there is an response? Lego Dimensions stops HIDRead calls as soon as one of them fails with a non-zero error (which includes time out)
-			DWORD r = WaitForSingleObject(ovlp.hEvent, 2000*100);
-			if (r == WAIT_TIMEOUT)
-			{
-				forceLogDebug_printf("HidRead internal timeout (error 0x%08x)", GetLastError());
-				// return -108 in case of timeout
-				free(tempBuffer);
-				CloseHandle(ovlp.hEvent);
-				return -108;
-			}
-
-
-			forceLogDebug_printf("HidRead WaitHalfComplete");
-			GetOverlappedResult(hidDeviceInfo->hFile, &ovlp, &bt, false);
-			if (bt == 0)
-				transferLength = 0;
-			else
-				transferLength = bt - 1;
-			forceLogDebug_printf("HidRead WaitComplete Length: 0x%08x", transferLength);
-		}
-		sint32 returnCode = 0;
-		if (bt != 0)
+		case Device::ReadResult::Success:
 		{
-			memcpy(data, tempBuffer + 1, transferLength);
-			sint32 hidReadLength = transferLength;
-
-			char debugOutput[1024] = { 0 };
-			for (sint32 i = 0; i < transferLength; i++)
-			{
-				sprintf(debugOutput + i * 3, "%02x ", tempBuffer[1 + i]);
-			}
-			forceLogDebug_printf("HIDRead data: %s", debugOutput);
-
-			returnCode = transferLength;
+			cemuLog_logDebug(LogType::Force, "nsyshid.hidReadInternalSync(): read {} of {} bytes",
+							 message.bytesRead,
+							 maxLength);
+			return message.bytesRead;
 		}
-		else
+		break;
+		case Device::ReadResult::Error:
 		{
-			forceLog_printf("Failed HID read");
-			returnCode = -1;
+			cemuLog_logDebug(LogType::Force, "nsyshid.hidReadInternalSync(): read error");
+			return -1;
 		}
-		free(tempBuffer);
-		CloseHandle(ovlp.hEvent);
-		return returnCode;
+		break;
+		case Device::ReadResult::ErrorTimeout:
+		{
+			cemuLog_logDebug(LogType::Force, "nsyshid.hidReadInternalSync(): read error: timeout");
+			return -108;
+		}
+		break;
+		}
+		cemuLog_logDebug(LogType::Force, "nsyshid.hidReadInternalSync(): read error: unknown");
+		return -1;
 	}
 
-	void _hidReadAsync(HIDDeviceInfo_t* hidDeviceInfo, uint8* data, sint32 maxLength, MPTR callbackFuncMPTR, MPTR callbackParamMPTR)
+	void _hidReadAsync(std::shared_ptr<Device> device,
+					   uint8* data, sint32 maxLength,
+					   MPTR callbackFuncMPTR,
+					   MPTR callbackParamMPTR)
 	{
-		sint32 returnCode = _hidReadInternalSync(hidDeviceInfo, data, maxLength);
+		sint32 returnCode = _hidReadInternalSync(device, data, maxLength);
 		sint32 errorCode = 0;
 		if (returnCode < 0)
-			errorCode = returnCode; // dont return number of bytes in error code
-		doHIDTransferCallback(callbackFuncMPTR, callbackParamMPTR, hidDeviceInfo->handle, errorCode, memory_getVirtualOffsetFromPointer(data), (returnCode>0)?returnCode:0);
+			errorCode = returnCode; // don't return number of bytes in error code
+		DoHIDTransferCallback(callbackFuncMPTR, callbackParamMPTR, device->m_hid->handle, errorCode,
+							  memory_getVirtualOffsetFromPointer(data), (returnCode > 0) ? returnCode : 0);
 	}
 
-	sint32 _hidReadSync(HIDDeviceInfo_t* hidDeviceInfo, uint8* data, sint32 maxLength, OSThread_t* osThread)
+	sint32 _hidReadSync(std::shared_ptr<Device> device,
+						uint8* data,
+						sint32 maxLength,
+						coreinit::OSEvent* event)
 	{
-		sint32 returnCode = _hidReadInternalSync(hidDeviceInfo, data, maxLength);
-		coreinit_resumeThread(osThread, 1000);
+		sint32 returnCode = _hidReadInternalSync(device, data, maxLength);
+		coreinit::OSSignalEvent(event);
 		return returnCode;
 	}
 
 	void export_HIDRead(PPCInterpreter_t* hCPU)
 	{
-		ppcDefineParamU32(hidHandle, 0); // r3
-		ppcDefineParamUStr(data, 1); // r4
-		ppcDefineParamU32(maxLength, 2); // r5
-		ppcDefineParamMPTR(callbackFuncMPTR, 3); // r6
+		ppcDefineParamU32(hidHandle, 0);		  // r3
+		ppcDefineParamUStr(data, 1);			  // r4
+		ppcDefineParamU32(maxLength, 2);		  // r5
+		ppcDefineParamMPTR(callbackFuncMPTR, 3);  // r6
 		ppcDefineParamMPTR(callbackParamMPTR, 4); // r7
-		forceLogDebug_printf("nsyshid.HIDRead(0x%x,0x%08x,0x%08x,0x%08x,0x%08x) LR %08x", hCPU->gpr[3], hCPU->gpr[4], hCPU->gpr[5], hCPU->gpr[6], hCPU->gpr[7], hCPU->spr.LR);
+		cemuLog_logDebug(LogType::Force, "nsyshid.HIDRead(0x{:x},0x{:08x},0x{:08x},0x{:08x},0x{:08x})", hCPU->gpr[3],
+					hCPU->gpr[4], hCPU->gpr[5], hCPU->gpr[6], hCPU->gpr[7]);
 
-		HIDDeviceInfo_t* hidDeviceInfo = getHIDDeviceInfoByHandle(hidHandle, true);
-		if (hidDeviceInfo == nullptr)
+		std::shared_ptr<Device> device = GetDeviceByHandle(hidHandle, true);
+		if (device == nullptr)
 		{
-			forceLog_printf("nsyshid.HIDRead(): Unable to find device with hid handle %d", hidHandle);
+			cemuLog_log(LogType::Force, "nsyshid.HIDRead(): Unable to find device with hid handle {}", hidHandle);
 			osLib_returnFromFunction(hCPU, -1);
 			return;
 		}
@@ -685,98 +703,96 @@ namespace nsyshid
 		if (callbackFuncMPTR != MPTR_NULL)
 		{
 			// asynchronous transfer
-			std::thread(&_hidReadAsync, hidDeviceInfo, data, maxLength, callbackFuncMPTR, callbackParamMPTR).detach();
+			std::thread(&_hidReadAsync, device, data, maxLength, callbackFuncMPTR, callbackParamMPTR).detach();
 			returnCode = 0;
 		}
 		else
 		{
 			// synchronous transfer
-			std::future<sint32> res = std::async(std::launch::async, &_hidReadSync, hidDeviceInfo, data, maxLength, coreinitThread_getCurrentThreadDepr(hCPU));
-			coreinit_suspendThread(coreinitThread_getCurrentThreadDepr(hCPU), 1000);
-			PPCCore_switchToScheduler();
+			StackAllocator<coreinit::OSEvent> event;
+			coreinit::OSInitEvent(&event, coreinit::OSEvent::EVENT_STATE::STATE_NOT_SIGNALED, coreinit::OSEvent::EVENT_MODE::MODE_AUTO);
+			std::future<sint32> res = std::async(std::launch::async, &_hidReadSync, device, data, maxLength, &event);
+			coreinit::OSWaitEvent(&event);
 			returnCode = res.get();
 		}
 
 		osLib_returnFromFunction(hCPU, returnCode);
 	}
 
-	sint32 _hidWriteInternalSync(HIDDeviceInfo_t* hidDeviceInfo, uint8* data, sint32 maxLength)
+	sint32 _hidWriteInternalSync(std::shared_ptr<Device> device, uint8* data, sint32 maxLength)
 	{
-		DWORD bt;
-		OVERLAPPED ovlp = { 0 };
-		ovlp.hEvent = CreateEvent(NULL, TRUE, FALSE, NULL);
-
-		uint8* tempBuffer = (uint8*)malloc(maxLength + 1);
-		memcpy(tempBuffer + 1, data, maxLength);
-		tempBuffer[0] = 0; // report byte?
-
-		forceLogDebug_printf("HidWrite Begin (Length 0x%08x)", maxLength);
-		BOOL WriteResult = WriteFile(hidDeviceInfo->hFile, tempBuffer, maxLength + 1, &bt, &ovlp);
-		if (WriteResult != FALSE)
+		cemuLog_logDebug(LogType::Force, "HidWrite Begin (Length 0x{:08x})", maxLength);
+		if (!device->IsOpened())
 		{
-			// sometimes we get the result immediately
-			forceLogDebug_printf("HidWrite Result received immediately (error 0x%08x) Length 0x%08x", GetLastError());
+			cemuLog_logDebug(LogType::Force, "nsyshid.hidWriteInternalSync(): cannot write to a non-opened device");
+			return -1;
 		}
-		else
+		WriteMessage message(data, maxLength, 0);
+		Device::WriteResult writeResult = device->Write(&message);
+		switch (writeResult)
 		{
-			// wait for result
-			forceLogDebug_printf("HidWrite WaitForResult (error 0x%08x)", GetLastError());
-			// todo - check for error type
-			DWORD r = WaitForSingleObject(ovlp.hEvent, 2000);
-			if (r == WAIT_TIMEOUT)
-			{
-				forceLogDebug_printf("HidWrite internal timeout");
-				// return -108 in case of timeout
-				free(tempBuffer);
-				CloseHandle(ovlp.hEvent);
-				return -108;
-			}
-
-
-			forceLogDebug_printf("HidWrite WaitHalfComplete");
-			GetOverlappedResult(hidDeviceInfo->hFile, &ovlp, &bt, false);
-			forceLogDebug_printf("HidWrite WaitComplete");
+		case Device::WriteResult::Success:
+		{
+			cemuLog_logDebug(LogType::Force, "nsyshid.hidWriteInternalSync(): wrote {} of {} bytes", message.bytesWritten,
+							 maxLength);
+			return message.bytesWritten;
 		}
-		sint32 returnCode = 0;
-		if (bt != 0)
-			returnCode = maxLength;
-		else
-			returnCode = -1;
-		
-		free(tempBuffer);
-		CloseHandle(ovlp.hEvent);
-		return returnCode;
+		break;
+		case Device::WriteResult::Error:
+		{
+			cemuLog_logDebug(LogType::Force, "nsyshid.hidWriteInternalSync(): write error");
+			return -1;
+		}
+		break;
+		case Device::WriteResult::ErrorTimeout:
+		{
+			cemuLog_logDebug(LogType::Force, "nsyshid.hidWriteInternalSync(): write error: timeout");
+			return -108;
+		}
+		break;
+		}
+		cemuLog_logDebug(LogType::Force, "nsyshid.hidWriteInternalSync(): write error: unknown");
+		return -1;
 	}
 
-	void _hidWriteAsync(HIDDeviceInfo_t* hidDeviceInfo, uint8* data, sint32 maxLength, MPTR callbackFuncMPTR, MPTR callbackParamMPTR)
+	void _hidWriteAsync(std::shared_ptr<Device> device,
+						uint8* data,
+						sint32 maxLength,
+						MPTR callbackFuncMPTR,
+						MPTR callbackParamMPTR)
 	{
-		sint32 returnCode = _hidWriteInternalSync(hidDeviceInfo, data, maxLength);
+		sint32 returnCode = _hidWriteInternalSync(device, data, maxLength);
 		sint32 errorCode = 0;
 		if (returnCode < 0)
-			errorCode = returnCode; // dont return number of bytes in error code
-		doHIDTransferCallback(callbackFuncMPTR, callbackParamMPTR, hidDeviceInfo->handle, errorCode, memory_getVirtualOffsetFromPointer(data), (returnCode > 0) ? returnCode : 0);
+			errorCode = returnCode; // don't return number of bytes in error code
+		DoHIDTransferCallback(callbackFuncMPTR, callbackParamMPTR, device->m_hid->handle, errorCode,
+							  memory_getVirtualOffsetFromPointer(data), (returnCode > 0) ? returnCode : 0);
 	}
 
-	sint32 _hidWriteSync(HIDDeviceInfo_t* hidDeviceInfo, uint8* data, sint32 maxLength, OSThread_t* osThread)
+	sint32 _hidWriteSync(std::shared_ptr<Device> device,
+						 uint8* data,
+						 sint32 maxLength,
+						 coreinit::OSEvent* event)
 	{
-		sint32 returnCode = _hidWriteInternalSync(hidDeviceInfo, data, maxLength);
-		coreinit_resumeThread(osThread, 1000);
+		sint32 returnCode = _hidWriteInternalSync(device, data, maxLength);
+		coreinit::OSSignalEvent(event);
 		return returnCode;
 	}
 
 	void export_HIDWrite(PPCInterpreter_t* hCPU)
 	{
-		ppcDefineParamU32(hidHandle, 0); // r3
-		ppcDefineParamUStr(data, 1); // r4
-		ppcDefineParamU32(maxLength, 2); // r5
-		ppcDefineParamMPTR(callbackFuncMPTR, 3); // r6
+		ppcDefineParamU32(hidHandle, 0);		  // r3
+		ppcDefineParamUStr(data, 1);			  // r4
+		ppcDefineParamU32(maxLength, 2);		  // r5
+		ppcDefineParamMPTR(callbackFuncMPTR, 3);  // r6
 		ppcDefineParamMPTR(callbackParamMPTR, 4); // r7
-		forceLogDebug_printf("nsyshid.HIDWrite(0x%x,0x%08x,0x%08x,0x%08x,0x%08x)", hCPU->gpr[3], hCPU->gpr[4], hCPU->gpr[5], hCPU->gpr[6], hCPU->gpr[7]);
+		cemuLog_logDebug(LogType::Force, "nsyshid.HIDWrite(0x{:x},0x{:08x},0x{:08x},0x{:08x},0x{:08x})", hCPU->gpr[3],
+					hCPU->gpr[4], hCPU->gpr[5], hCPU->gpr[6], hCPU->gpr[7]);
 
-		HIDDeviceInfo_t* hidDeviceInfo = getHIDDeviceInfoByHandle(hidHandle, true);
-		if (hidDeviceInfo == nullptr)
+		std::shared_ptr<Device> device = GetDeviceByHandle(hidHandle, true);
+		if (device == nullptr)
 		{
-			forceLog_printf("nsyshid.HIDWrite(): Unable to find device with hid handle %d", hidHandle);
+			cemuLog_log(LogType::Force, "nsyshid.HIDWrite(): Unable to find device with hid handle {}", hidHandle);
 			osLib_returnFromFunction(hCPU, -1);
 			return;
 		}
@@ -784,15 +800,16 @@ namespace nsyshid
 		if (callbackFuncMPTR != MPTR_NULL)
 		{
 			// asynchronous transfer
-			std::thread(&_hidWriteAsync, hidDeviceInfo, data, maxLength, callbackFuncMPTR, callbackParamMPTR).detach();
+			std::thread(&_hidWriteAsync, device, data, maxLength, callbackFuncMPTR, callbackParamMPTR).detach();
 			returnCode = 0;
 		}
 		else
 		{
 			// synchronous transfer
-			std::future<sint32> res = std::async(std::launch::async, &_hidWriteSync, hidDeviceInfo, data, maxLength, coreinitThread_getCurrentThreadDepr(hCPU));
-			coreinit_suspendThread(coreinitThread_getCurrentThreadDepr(hCPU), 1000);
-			PPCCore_switchToScheduler();
+			StackAllocator<coreinit::OSEvent> event;
+			coreinit::OSInitEvent(&event, coreinit::OSEvent::EVENT_STATE::STATE_NOT_SIGNALED, coreinit::OSEvent::EVENT_MODE::MODE_AUTO);
+			std::future<sint32> res = std::async(std::launch::async, &_hidWriteSync, device, data, maxLength, &event);
+			coreinit::OSWaitEvent(&event);
 			returnCode = res.get();
 		}
 
@@ -804,7 +821,8 @@ namespace nsyshid
 		ppcDefineParamU32(errorCode, 0);
 		ppcDefineParamTypePtr(ukn0, uint32be, 1);
 		ppcDefineParamTypePtr(ukn1, uint32be, 2);
-		forceLogDebug_printf("nsyshid.HIDDecodeError(0x%08x,0x%08x,0x%08x)", hCPU->gpr[3], hCPU->gpr[4], hCPU->gpr[5]);
+		cemuLog_logDebug(LogType::Force, "nsyshid.HIDDecodeError(0x{:08x},0x{:08x},0x{:08x})", hCPU->gpr[3],
+					hCPU->gpr[4], hCPU->gpr[5]);
 
 		// todo
 		*ukn0 = 0x3FF;
@@ -813,6 +831,119 @@ namespace nsyshid
 		osLib_returnFromFunction(hCPU, 0);
 	}
 
+	void Backend::DetachAllDevices()
+	{
+		std::lock_guard<std::recursive_mutex> lock(this->m_devicesMutex);
+		if (m_isAttached)
+		{
+			for (const auto& device : this->m_devices)
+			{
+				nsyshid::DetachDevice(device);
+			}
+			this->m_devices.clear();
+		}
+	}
+
+	bool Backend::AttachDevice(const std::shared_ptr<Device>& device)
+	{
+		std::lock_guard<std::recursive_mutex> lock(this->m_devicesMutex);
+		if (m_isAttached && nsyshid::AttachDevice(device))
+		{
+			this->m_devices.push_back(device);
+			return true;
+		}
+		return false;
+	}
+
+	void Backend::DetachDevice(const std::shared_ptr<Device>& device)
+	{
+		std::lock_guard<std::recursive_mutex> lock(this->m_devicesMutex);
+		if (m_isAttached)
+		{
+			nsyshid::DetachDevice(device);
+			this->m_devices.remove(device);
+		}
+	}
+
+	std::shared_ptr<Device> Backend::FindDevice(std::function<bool(const std::shared_ptr<Device>&)> isWantedDevice)
+	{
+		std::lock_guard<std::recursive_mutex> lock(this->m_devicesMutex);
+		auto it = std::find_if(this->m_devices.begin(), this->m_devices.end(), std::move(isWantedDevice));
+		if (it != this->m_devices.end())
+		{
+			return *it;
+		}
+		return nullptr;
+	}
+
+	std::shared_ptr<Device> Backend::FindDeviceById(uint16 vendorId, uint16 productId)
+	{
+		return nsyshid::FindDeviceById(vendorId, productId);
+	}
+
+	bool Backend::IsDeviceWhitelisted(uint16 vendorId, uint16 productId)
+	{
+		return Whitelist::GetInstance().IsDeviceWhitelisted(vendorId, productId);
+	}
+
+	Backend::Backend()
+		: m_isAttached(false)
+	{
+	}
+
+	void Backend::OnAttach()
+	{
+		std::lock_guard<std::recursive_mutex> lock(this->m_devicesMutex);
+		m_isAttached = true;
+		AttachVisibleDevices();
+	}
+
+	void Backend::OnDetach()
+	{
+		std::lock_guard<std::recursive_mutex> lock(this->m_devicesMutex);
+		DetachAllDevices();
+		m_isAttached = false;
+	}
+
+	bool Backend::IsBackendAttached()
+	{
+		std::lock_guard<std::recursive_mutex> lock(this->m_devicesMutex);
+		return m_isAttached;
+	}
+
+	Device::Device(uint16 vendorId,
+				   uint16 productId,
+				   uint8 interfaceIndex,
+				   uint8 interfaceSubClass,
+				   uint8 protocol)
+		: m_hid(nullptr),
+		  m_vendorId(vendorId),
+		  m_productId(productId),
+		  m_interfaceIndex(interfaceIndex),
+		  m_interfaceSubClass(interfaceSubClass),
+		  m_protocol(protocol),
+		  m_maxPacketSizeRX(0x20),
+		  m_maxPacketSizeTX(0x20)
+	{
+	}
+
+	void Device::AssignHID(HID_t* hid)
+	{
+		if (hid != nullptr)
+		{
+			hid->vendorId = this->m_vendorId;
+			hid->productId = this->m_productId;
+			hid->ifIndex = this->m_interfaceIndex;
+			hid->subClass = this->m_interfaceSubClass;
+			hid->protocol = this->m_protocol;
+			hid->ukn04 = 0x11223344;
+			hid->paddingGuessed0F = 0;
+			hid->maxPacketSizeRX = this->m_maxPacketSizeRX;
+			hid->maxPacketSizeTX = this->m_maxPacketSizeTX;
+		}
+		this->m_hid = hid;
+	}
+
 	void load()
 	{
 		osLib_addFunction("nsyshid", "HIDAddClient", export_HIDAddClient);
@@ -826,19 +957,10 @@ namespace nsyshid
 		osLib_addFunction("nsyshid", "HIDWrite", export_HIDWrite);
 
 		osLib_addFunction("nsyshid", "HIDDecodeError", export_HIDDecodeError);
-		firstHIDClient = nullptr;
+
+		// initialise whitelist
+		Whitelist::GetInstance();
+
+		AttachDefaultBackends();
 	}
-}
-
-#else
-
-namespace nsyshid
-{
-	void load()
-	{
-		// unimplemented
-	};
-};
-
-
-#endif
\ No newline at end of file
+} // namespace nsyshid
diff --git a/src/Cafe/OS/libs/nsyshid/nsyshid.h b/src/Cafe/OS/libs/nsyshid/nsyshid.h
index 051b4e7c..1478adf9 100644
--- a/src/Cafe/OS/libs/nsyshid/nsyshid.h
+++ b/src/Cafe/OS/libs/nsyshid/nsyshid.h
@@ -1,5 +1,12 @@
 #pragma once
+
 namespace nsyshid
 {
+	class Backend;
+
+	void AttachBackend(const std::shared_ptr<Backend>& backend);
+
+	void DetachBackend(const std::shared_ptr<Backend>& backend);
+
 	void load();
-}
\ No newline at end of file
+} // namespace nsyshid
diff --git a/src/Cafe/OS/libs/nsyskbd/nsyskbd.cpp b/src/Cafe/OS/libs/nsyskbd/nsyskbd.cpp
index fc1d5ad8..f1571cc0 100644
--- a/src/Cafe/OS/libs/nsyskbd/nsyskbd.cpp
+++ b/src/Cafe/OS/libs/nsyskbd/nsyskbd.cpp
@@ -3,12 +3,17 @@
 
 namespace nsyskbd
 {
+	bool IsValidChannel(uint32 channel)
+	{
+		return channel >= 0 && channel < 4;
+	}
+
 	uint32 KBDGetChannelStatus(uint32 channel, uint32be* status)
 	{
 		static bool loggedError = false;
 		if (loggedError == false)
 		{
-			forceLogDebug_printf("KBDGetChannelStatus() placeholder");
+			cemuLog_logDebug(LogType::Force, "KBDGetChannelStatus() placeholder");
 			loggedError = true;
 		}
 		*status = 1; // disconnected
@@ -16,8 +21,38 @@ namespace nsyskbd
 		return 0;
 	}
 
+#pragma pack(push, 1)
+	struct KeyState
+	{
+		uint8be channel;
+		uint8be ukn1;
+		uint8be _padding[2];
+		uint32be ukn4;
+		uint32be ukn8;
+		uint16be uknC;
+	};
+#pragma pack(pop)
+	static_assert(sizeof(KeyState) == 0xE); // actual size might be padded to 0x10?
+
+	uint32 KBDGetKey(uint32 channel, KeyState* keyState)
+	{
+		// used by MSX VC
+		if(!IsValidChannel(channel) || !keyState)
+		{
+			cemuLog_log(LogType::APIErrors, "KBDGetKey(): Invalid parameter");
+			return 0;
+		}
+		keyState->channel = channel;
+		keyState->ukn1 = 0;
+		keyState->ukn4 = 0;
+		keyState->ukn8 = 0;
+		keyState->uknC = 0;
+		return 0;
+	}
+
 	void nsyskbd_load()
 	{
 		cafeExportRegister("nsyskbd", KBDGetChannelStatus, LogType::Placeholder);
+		cafeExportRegister("nsyskbd", KBDGetKey, LogType::Placeholder);
 	}
-}
\ No newline at end of file
+}
diff --git a/src/Cafe/OS/libs/nsysnet/nsysnet.cpp b/src/Cafe/OS/libs/nsysnet/nsysnet.cpp
index b49d2e80..c83915db 100644
--- a/src/Cafe/OS/libs/nsysnet/nsysnet.cpp
+++ b/src/Cafe/OS/libs/nsysnet/nsysnet.cpp
@@ -3,11 +3,29 @@
 #include "Cafe/OS/libs/coreinit/coreinit_Thread.h"
 #include "Cafe/IOSU/legacy/iosu_crypto.h"
 #include "Cafe/OS/libs/coreinit/coreinit_Time.h"
+#include "Cafe/OS/libs/coreinit/coreinit_GHS.h"
 
 #include "Common/socket.h"
 
+#if BOOST_OS_UNIX
+
+#define WSAEWOULDBLOCK EWOULDBLOCK
+#define WSAEINPROGRESS EINPROGRESS
+#define WSAESHUTDOWN ESHUTDOWN
+#define WSAECONNABORTED ECONNABORTED
+#define WSAHOST_NOT_FOUND EAI_NONAME
+#define WSAENOTCONN ENOTCONN
+
+#define GETLASTERR errno
+
+#endif // BOOST_OS_UNIX
+
 #if BOOST_OS_WINDOWS
 
+#define GETLASTERR WSAGetLastError()
+
+#endif //BOOST_OS_WINDOWS
+
 #define WU_AF_INET			2
 
 #define WU_SOCK_STREAM		1
@@ -19,14 +37,46 @@
 
 #define WU_SO_REUSEADDR		0x0004
 #define WU_SO_KEEPALIVE		0x0008
+#define WU_SO_DONTROUTE		0x0010
+#define WU_SO_BROADCAST		0x0020
+#define WU_SO_LINGER		0x0080
+#define WU_SO_OOBINLINE		0x0100
+#define WU_SO_TCPSACK		0x0200
 #define WU_SO_WINSCALE		0x0400
 #define WU_SO_SNDBUF		0x1001
 #define WU_SO_RCVBUF		0x1002
+#define WU_SO_SNDLOWAT		0x1003
+#define WU_SO_RCVLOWAT		0x1004
 #define WU_SO_LASTERROR		0x1007
+#define WU_SO_TYPE			0x1008
+#define WU_SO_HOPCNT		0x1009
+#define WU_SO_MAXMSG		0x1010
+#define WU_SO_RXDATA		0x1011
+#define WU_SO_TXDATA		0x1012
+#define WU_SO_MYADDR		0x1013
 #define WU_SO_NBIO			0x1014
+#define WU_SO_BIO			0x1015
 #define WU_SO_NONBLOCK		0x1016
+#define WU_SO_UNKNOWN1019	0x1019 // tcp related
+#define WU_SO_UNKNOWN101A	0x101A // tcp related
+#define WU_SO_UNKNOWN101B	0x101B // tcp related
+#define WU_SO_NOSLOWSTART	0x4000
+#define WU_SO_RUSRBUF		0x10000
 
-#define WU_TCP_NODELAY		0x2004
+#define WU_TCP_ACKDELAYTIME		0x2001
+#define WU_TCP_NOACKDELAY		0x2002
+#define WU_TCP_MAXSEG			0x2003
+#define WU_TCP_NODELAY			0x2004
+#define WU_TCP_UNKNOWN			0x2005 // amount of mss received before sending an ack
+
+#define WU_IP_TOS				3
+#define WU_IP_TTL				4
+#define WU_IP_MULTICAST_IF		9
+#define WU_IP_MULTICAST_TTL		10
+#define WU_IP_MULTICAST_LOOP	11
+#define WU_IP_ADD_MEMBERSHIP	12
+#define WU_IP_DROP_MEMBERSHIP	13
+#define WU_IP_UNKNOWN			14
 
 #define WU_SOL_SOCKET		-1 // this constant differs from Win32 socket API
 
@@ -37,8 +87,10 @@
 #define WU_SO_SUCCESS		0x0000
 #define WU_SO_EWOULDBLOCK	0x0006
 #define WU_SO_ECONNRESET	0x0008
+#define WU_SO_ENOTCONN		0x0009
 #define WU_SO_EINVAL		0x000B
 #define WU_SO_EINPROGRESS	0x0016
+#define WU_SO_EAFNOSUPPORT  0x0021
 
 #define WU_SO_ESHUTDOWN		0x000F
 
@@ -50,28 +102,30 @@ bool sockLibReady = false;
 void nsysnetExport_socket_lib_init(PPCInterpreter_t* hCPU)
 {
 	sockLibReady = true;
+#if BOOST_OS_WINDOWS
 	WSADATA wsa;
 	WSAStartup(MAKEWORD(2, 2), &wsa);
+#endif // BOOST_OS_WINDOWS
 	osLib_returnFromFunction(hCPU, 0); // 0 -> Success
 }
 
-uint32* __gh_errno_ptr()
+void nsysnetExport_socket_lib_finish(PPCInterpreter_t* hCPU)
 {
-	OSThread_t* osThread = coreinitThread_getCurrentThreadDepr(PPCInterpreter_getCurrentInstance());
-	return &osThread->context.error;
+	sockLibReady = false;
+#if BOOST_OS_WINDOWS
+	WSACleanup();
+#endif // BOOST_OS_WINDOWS
+	osLib_returnFromFunction(hCPU, 0); // 0 -> Success
 }
 
 void _setSockError(sint32 errCode)
 {
-	// todo -> Call __gh_errno_ptr and then write 32bit error code
-	*(uint32*)__gh_errno_ptr() = _swapEndianU32(errCode);
-	//coreinitData->ghsErrno = _swapEndianU32(errCode);
+	coreinit::__gh_set_errno(errCode);
 }
 
 sint32 _getSockError()
 {
-	return (sint32)_swapEndianU32(*(uint32*)__gh_errno_ptr());
-	//return (sint32)_swapEndianU32(coreinitData->ghsErrno);
+	return coreinit::__gh_get_errno();
 }
 
 // error translation modes for _translateError
@@ -116,15 +170,18 @@ sint32 _translateError(sint32 returnCode, sint32 wsaError, sint32 mode = _ERROR_
 		break;
 	case WSAECONNABORTED:
 		debug_printf("WSAECONNABORTED\n");
-#ifndef PUBLIC_RELEASE
+#ifdef CEMU_DEBUG_ASSERT
 		assert_dbg();
 #endif
 		break;
 	case WSAESHUTDOWN:
 		_setSockError(WU_SO_ESHUTDOWN);
 		break;
+	case WSAENOTCONN:
+		_setSockError(WU_SO_ENOTCONN);
+		break;
 	default:
-		cemuLog_logDebug(LogType::Force, "Unhandled wsaError {}\n", wsaError);
+		cemuLog_logDebug(LogType::Force, "Unhandled wsaError {}", wsaError);
 		_setSockError(99999); // unhandled error
 	}
 	return -1;
@@ -132,7 +189,7 @@ sint32 _translateError(sint32 returnCode, sint32 wsaError, sint32 mode = _ERROR_
 
 void nsysnetExport_socketlasterr(PPCInterpreter_t* hCPU)
 {
-	socketLog_printf("socketlasterr() -> %d", _getSockError());
+	cemuLog_logDebug(LogType::Socket, "socketlasterr() -> {}", _getSockError());
 	osLib_returnFromFunction(hCPU, _getSockError());
 }
 
@@ -200,14 +257,16 @@ sint32 _getFreeSocketHandle()
 	return 0;
 }
 
+#if BOOST_OS_WINDOWS
 #define SIO_UDP_CONNRESET _WSAIOW(IOC_VENDOR,12)
+#endif // BOOST_OS_WINDOWS
 
 WUSOCKET nsysnet_createVirtualSocket(sint32 family, sint32 type, sint32 protocol)
 {
 	sint32 s = _getFreeSocketHandle();
 	if (s == 0)
 	{
-		forceLogDebug_printf("Ran out of socket handles");
+		cemuLog_logDebug(LogType::Force, "Ran out of socket handles");
 		cemu_assert(false);
 	}
 	virtualSocket_t* vs = (virtualSocket_t*)malloc(sizeof(virtualSocket_t));
@@ -219,6 +278,7 @@ WUSOCKET nsysnet_createVirtualSocket(sint32 family, sint32 type, sint32 protocol
 	virtualSocketTable[s - 1] = vs;
 	// init host socket
 	vs->s = socket(family, type, protocol);
+	#if BOOST_OS_WINDOWS
 	// disable reporting of PORT_UNREACHABLE for UDP sockets
 	if (protocol == IPPROTO_UDP)
 	{
@@ -226,12 +286,24 @@ WUSOCKET nsysnet_createVirtualSocket(sint32 family, sint32 type, sint32 protocol
 		DWORD dwBytesReturned = 0;
 		WSAIoctl(vs->s, SIO_UDP_CONNRESET, &bNewBehavior, sizeof bNewBehavior, NULL, 0, &dwBytesReturned, NULL, NULL);
 	}
+	#endif // BOOST_OS_WINDOWS
 	return vs->handle;
 }
 
 WUSOCKET nsysnet_createVirtualSocketFromExistingSocket(SOCKET existingSocket)
 {
-	forceLogDebug_printf("nsysnet_createVirtualSocketFromExistingSocket - incomplete");
+	cemuLog_logDebug(LogType::Force, "nsysnet_createVirtualSocketFromExistingSocket - incomplete");
+
+
+	sint32 s = _getFreeSocketHandle();
+	if (s == 0)
+	{
+		cemuLog_logDebug(LogType::Force, "Ran out of socket handles");
+		cemu_assert(false);
+	}
+	virtualSocket_t* vs = (virtualSocket_t*)malloc(sizeof(virtualSocket_t));
+	memset(vs, 0, sizeof(virtualSocket_t));
+#if BOOST_OS_WINDOWS
 	// SO_TYPE -> type
 	// SO_BSP_STATE -> protocol + other info
 	// SO_PROTOCOL_INFO -> protocol + type?
@@ -239,20 +311,26 @@ WUSOCKET nsysnet_createVirtualSocketFromExistingSocket(SOCKET existingSocket)
 	WSAPROTOCOL_INFO protocolInfo = { 0 };
 	int optLen = sizeof(protocolInfo);
 	getsockopt(existingSocket, SOL_SOCKET, SO_PROTOCOL_INFO, (char*)&protocolInfo, &optLen);
-
 	// todo - translate protocolInfo 
-
-	sint32 s = _getFreeSocketHandle();
-	if (s == 0)
-	{
-		forceLogDebug_printf("Ran out of socket handles");
-		cemu_assert(false);
-	}
-	virtualSocket_t* vs = (virtualSocket_t*)malloc(sizeof(virtualSocket_t));
-	memset(vs, 0, sizeof(virtualSocket_t));
 	vs->family = protocolInfo.iAddressFamily;
 	vs->type = protocolInfo.iSocketType;
 	vs->protocol = protocolInfo.iSocketType;
+#else
+	{
+		int type;
+		socklen_t optlen;
+		getsockopt(vs->s, SOL_SOCKET, SO_TYPE, &type, &optlen);
+		vs->type = type;
+		vs->protocol = type;
+	}
+	{
+		sockaddr saddr;
+		socklen_t len;
+		getsockname(vs->s, &saddr, &len);
+		vs->family = saddr.sa_family;
+	}
+#endif
+
 	vs->handle = s;
 	virtualSocketTable[s - 1] = vs;
 	vs->s = existingSocket;
@@ -294,7 +372,7 @@ sint32 nsysnet_getVirtualSocketHandleFromHostHandle(SOCKET s)
 
 void nsysnetExport_socket(PPCInterpreter_t* hCPU)
 {
-	socketLog_printf("socket(%d,%d,%d)", hCPU->gpr[3], hCPU->gpr[4], hCPU->gpr[5]);
+	cemuLog_log(LogType::Socket, "socket({},{},{})", hCPU->gpr[3], hCPU->gpr[4], hCPU->gpr[5]);
 	ppcDefineParamS32(family, 0);
 	ppcDefineParamS32(type, 1);
 	ppcDefineParamS32(protocol, 2);
@@ -310,7 +388,7 @@ void nsysnetExport_socket(PPCInterpreter_t* hCPU)
 	// check family param
 	if (family != WU_AF_INET)
 	{
-		forceLogDebug_printf("socket(): Unsupported family");
+		cemuLog_logDebug(LogType::Force, "socket(): Unsupported family");
 		// todo - error code
 		osLib_returnFromFunction(hCPU, -1);
 		return;
@@ -318,7 +396,7 @@ void nsysnetExport_socket(PPCInterpreter_t* hCPU)
 	// check type param
 	if (type != WU_SOCK_STREAM && type != WU_SOCK_DGRAM)
 	{
-		forceLogDebug_printf("socket(): Unsupported family");
+		cemuLog_logDebug(LogType::Force, "socket(): Unsupported family");
 		// todo - error code
 		osLib_returnFromFunction(hCPU, -1);
 		return;
@@ -326,26 +404,26 @@ void nsysnetExport_socket(PPCInterpreter_t* hCPU)
 
 	if (protocol != WU_IPPROTO_TCP && protocol != WU_IPPROTO_UDP && protocol != WU_IPPROTO_IP)
 	{
-		forceLogDebug_printf("socket(): Unsupported protocol");
+		cemuLog_logDebug(LogType::Force, "socket(): Unsupported protocol");
 		// todo - error code
 		osLib_returnFromFunction(hCPU, -1);
 		return;
 	}
 
 	WUSOCKET s = nsysnet_createVirtualSocket(family, type, protocol);
-	socketLog_printf("Created socket handle %d", s);
+	cemuLog_log(LogType::Socket, "Created socket handle {}", s);
 	osLib_returnFromFunction(hCPU, s);
 }
 
 void nsysnetExport_mw_socket(PPCInterpreter_t* hCPU)
 {
-	socketLog_printf("mw_socket");
+	cemuLog_log(LogType::Socket, "mw_socket");
 	nsysnetExport_socket(hCPU);
 }
 
 void nsysnetExport_shutdown(PPCInterpreter_t* hCPU)
 {
-	socketLog_printf("shutdown(%d,%d)", hCPU->gpr[3], hCPU->gpr[4]);
+	cemuLog_log(LogType::Socket, "shutdown({},{})", hCPU->gpr[3], hCPU->gpr[4]);
 	ppcDefineParamS32(s, 0);
 	ppcDefineParamS32(how, 1);
 
@@ -383,7 +461,7 @@ void nsysnetExport_shutdown(PPCInterpreter_t* hCPU)
 
 void nsysnetExport_socketclose(PPCInterpreter_t* hCPU)
 {
-	socketLog_printf("socketclose(%d)", hCPU->gpr[3]);
+	cemuLog_log(LogType::Socket, "socketclose({})", hCPU->gpr[3]);
 	ppcDefineParamS32(s, 0);
 
 	virtualSocket_t* vs = nsysnet_getVirtualSocketObject(s);
@@ -395,10 +473,22 @@ void nsysnetExport_socketclose(PPCInterpreter_t* hCPU)
 	}
 	osLib_returnFromFunction(hCPU, 0);
 }
-
+sint32 _socket_nonblock(SOCKET s, u_long mode)
+{
+#if BOOST_OS_WINDOWS
+	return ioctlsocket(s, FIONBIO, &mode);
+#else
+	int flags = fcntl(s, F_GETFL);
+	if(mode)
+		flags |= O_NONBLOCK;
+	else
+		flags &= ~O_NONBLOCK;
+	return fcntl(s, F_SETFL, flags);
+#endif
+}
 void nsysnetExport_setsockopt(PPCInterpreter_t* hCPU)
 {
-	socketLog_printf("setsockopt(%d,0x%x,0x%05x,0x%08x,%d)", hCPU->gpr[3], hCPU->gpr[4], hCPU->gpr[5], hCPU->gpr[6], hCPU->gpr[7]);
+	cemuLog_log(LogType::Socket, "setsockopt({},0x{:x},0x{:05x},0x{:08x},{})", hCPU->gpr[3], hCPU->gpr[4], hCPU->gpr[5], hCPU->gpr[6], hCPU->gpr[7]);
 	ppcDefineParamS32(s, 0);
 	ppcDefineParamS32(level, 1);
 	ppcDefineParamS32(optname, 2);
@@ -427,9 +517,9 @@ void nsysnetExport_setsockopt(PPCInterpreter_t* hCPU)
 				if (r != 0)
 					cemu_assert_suspicious();
 			}
-			else if (optname == WU_SO_NBIO)
+			else if (optname == WU_SO_NBIO || optname == WU_SO_BIO)
 			{
-				// similar to WU_SO_NONBLOCK but always sets non-blocking mode regardless of option value
+				// similar to WU_SO_NONBLOCK but always sets blocking (_BIO) or non-blocking (_NBIO) mode regardless of option value
 				if (optlen == 4)
 				{
 					sint32 optvalLE = _swapEndianU32(*(uint32*)optval);
@@ -440,9 +530,10 @@ void nsysnetExport_setsockopt(PPCInterpreter_t* hCPU)
 				}
 				else
 					cemu_assert_suspicious();
-				u_long mode = 1;
-				ioctlsocket(vs->s, FIONBIO, &mode);
-				vs->isNonBlocking = true;
+				bool setNonBlocking = optname == WU_SO_NBIO;
+				u_long mode = setNonBlocking ? 1 : 0;
+				_socket_nonblock(vs->s,  mode);
+				vs->isNonBlocking = setNonBlocking;
 			}
 			else if (optname == WU_SO_NONBLOCK)
 			{
@@ -450,20 +541,20 @@ void nsysnetExport_setsockopt(PPCInterpreter_t* hCPU)
 					assert_dbg();
 				sint32 optvalLE = _swapEndianU32(*(uint32*)optval);
 				u_long mode = optvalLE;  // 1 -> enable, 0 -> disable
-				ioctlsocket(vs->s, FIONBIO, &mode);
+				_socket_nonblock(vs->s,  mode);
 				vs->isNonBlocking = mode != 0;
 			}
 			else if (optname == WU_SO_KEEPALIVE)
 			{
-				// todo
+				cemuLog_logDebug(LogType::Socket, "todo: setsockopt() for WU_SO_KEEPALIVE");
 			}
 			else if (optname == WU_SO_WINSCALE)
 			{
-				// todo
+				cemuLog_logDebug(LogType::Socket, "todo: setsockopt() for WU_SO_WINSCALE");
 			}
 			else if (optname == WU_SO_RCVBUF)
 			{
-				socketLog_printf("Set receive buffer size to 0x%08x", _swapEndianU32(*(uint32*)optval));
+				cemuLog_log(LogType::Socket, "Set receive buffer size to 0x{:08x}", _swapEndianU32(*(uint32*)optval));
 				if (optlen != 4)
 					assert_dbg();
 				sint32 optvalLE = _swapEndianU32(*(uint32*)optval);
@@ -473,7 +564,7 @@ void nsysnetExport_setsockopt(PPCInterpreter_t* hCPU)
 			}
 			else if (optname == WU_SO_SNDBUF)
 			{
-				socketLog_printf("Set send buffer size to 0x%08x", _swapEndianU32(*(uint32*)optval));
+				cemuLog_log(LogType::Socket, "Set send buffer size to 0x{:08x}", _swapEndianU32(*(uint32*)optval));
 				if (optlen != 4)
 					assert_dbg();
 				sint32 optvalLE = _swapEndianU32(*(uint32*)optval);
@@ -483,7 +574,7 @@ void nsysnetExport_setsockopt(PPCInterpreter_t* hCPU)
 			}
 			else
 			{
-				forceLogDebug_printf("setsockopt(): Unsupported optname 0x%08x", optname);
+				cemuLog_logDebug(LogType::Force, "setsockopt(WU_SOL_SOCKET): Unsupported optname 0x{:08x}", optname);
 			}
 		}
 		else if (level == WU_IPPROTO_TCP)
@@ -499,18 +590,22 @@ void nsysnetExport_setsockopt(PPCInterpreter_t* hCPU)
 					assert_dbg();
 			}
 			else
-				assert_dbg();
+			{
+				cemuLog_logDebug(LogType::Force, "setsockopt(WU_IPPROTO_TCP): Unsupported optname 0x{:08x}", optname);
+			}
 		}
 		else if (level == WU_IPPROTO_IP)
 		{
 			hostLevel = IPPROTO_IP;
-			if (optname == 0xC)
+			if (optname == WU_IP_MULTICAST_IF || optname == WU_IP_MULTICAST_TTL ||
+				optname == WU_IP_MULTICAST_LOOP || optname == WU_IP_ADD_MEMBERSHIP ||
+				optname == WU_IP_DROP_MEMBERSHIP)
 			{
-				// unknown
+				cemuLog_logDebug(LogType::Socket, "todo: setsockopt() for multicast");
 			}
-			else if( optname == 0x4 )
+			else if(optname == WU_IP_TTL || optname == WU_IP_TOS)
 			{
-				forceLogDebug_printf("setsockopt with unsupported opname 4 for IPPROTO_IP");
+				cemuLog_logDebug(LogType::Force, "setsockopt(WU_IPPROTO_IP): Unsupported optname 0x{:08x}", optname);
 			}
 			else
 				assert_dbg();
@@ -524,7 +619,7 @@ void nsysnetExport_setsockopt(PPCInterpreter_t* hCPU)
 
 void nsysnetExport_getsockopt(PPCInterpreter_t* hCPU)
 {
-	socketLog_printf("getsockopt(%d,0x%x,0x%05x,0x%08x,0x%08x)", hCPU->gpr[3], hCPU->gpr[4], hCPU->gpr[5], hCPU->gpr[6], hCPU->gpr[7]);
+	cemuLog_log(LogType::Socket, "getsockopt({},0x{:x},0x{:05x},0x{:08x},0x{:08x})", hCPU->gpr[3], hCPU->gpr[4], hCPU->gpr[5], hCPU->gpr[6], hCPU->gpr[7]);
 	ppcDefineParamS32(s, 0);
 	ppcDefineParamS32(level, 1);
 	ppcDefineParamS32(optname, 2);
@@ -549,9 +644,9 @@ void nsysnetExport_getsockopt(PPCInterpreter_t* hCPU)
 		if (optname == WU_SO_LASTERROR)
 		{
 			int optvalLE = 0;
-			int optlenLE = 4;
+			socklen_t optlenLE = 4;
 			r = getsockopt(vs->s, hostLevel, SO_ERROR, (char*)&optvalLE, &optlenLE);
-			r = _translateError(r, WSAGetLastError());
+			r = _translateError(r, GETLASTERR);
 			if (memory_readU32(optlenMPTR) != 4)
 				assert_dbg();
 			memory_writeU32(optlenMPTR, 4);
@@ -563,9 +658,9 @@ void nsysnetExport_getsockopt(PPCInterpreter_t* hCPU)
 		else if (optname == WU_SO_RCVBUF)
 		{
 			int optvalLE = 0;
-			int optlenLE = 4;
+			socklen_t optlenLE = 4;
 			r = getsockopt(vs->s, hostLevel, SO_RCVBUF, (char*)&optvalLE, &optlenLE);
-			r = _translateError(r, WSAGetLastError());
+			r = _translateError(r, GETLASTERR);
 			if (memory_readU32(optlenMPTR) != 4)
 				assert_dbg();
 			memory_writeU32(optlenMPTR, 4);
@@ -575,23 +670,43 @@ void nsysnetExport_getsockopt(PPCInterpreter_t* hCPU)
 		else if (optname == WU_SO_SNDBUF)
 		{
 			int optvalLE = 0;
-			int optlenLE = 4;
+			socklen_t optlenLE = 4;
 			r = getsockopt(vs->s, hostLevel, SO_SNDBUF, (char*)&optvalLE, &optlenLE);
-			r = _translateError(r, WSAGetLastError());
+			r = _translateError(r, GETLASTERR);
 			if (memory_readU32(optlenMPTR) != 4)
 				assert_dbg();
 			memory_writeU32(optlenMPTR, 4);
 			*(uint32*)optval = _swapEndianU32(optvalLE);
 			// used by Lost Reavers after some loading screens
 		}
+		else if (optname == WU_SO_TYPE)
+		{
+			if (memory_readU32(optlenMPTR) != 4)
+				assert_dbg();
+			int optvalLE = 0;
+			socklen_t optlenLE = 4;
+			memory_writeU32(optlenMPTR, 4);
+			*(uint32*)optval = _swapEndianU32(vs->type);
+			r = WU_SO_SUCCESS;
+		}
+        else if (optname == WU_SO_NONBLOCK)
+        {
+            if (memory_readU32(optlenMPTR) != 4)
+                assert_dbg();
+            int optvalLE = 0;
+            socklen_t optlenLE = 4;
+            memory_writeU32(optlenMPTR, 4);
+            *(uint32*)optval = _swapEndianU32(vs->isNonBlocking ? 1 : 0);
+            r = WU_SO_SUCCESS;
+        }
 		else
 		{
-			cemu_assert_debug(false);
+			cemuLog_logDebug(LogType::Force, "getsockopt(WU_SOL_SOCKET): Unsupported optname 0x{:08x}", optname);
 		}
 	}
 	else
 	{
-		cemu_assert_debug(false);
+		cemuLog_logDebug(LogType::Force, "getsockopt(): Unsupported level 0x{:08x}", level);
 	}
 
 	osLib_returnFromFunction(hCPU, r);
@@ -601,7 +716,7 @@ void nsysnetExport_inet_aton(PPCInterpreter_t* hCPU)
 {
 	ppcDefineParamStr(ip, 0);
 	ppcDefineParamStructPtr(addr, wu_in_addr, 1);
-	socketLog_printf("inet_aton(\"%s\",0x%08x)", ip, hCPU->gpr[4]);
+	cemuLog_log(LogType::Socket, "inet_aton(\"{}\",0x{:08x})", ip, hCPU->gpr[4]);
 
 	// _parse_ipad -> todo
 	sint32 d0, d1, d2, d3;
@@ -635,7 +750,7 @@ void nsysnetExport_inet_pton(PPCInterpreter_t* hCPU)
 	
 	if (af != 2)
 	{
-		forceLog_printf("inet_pton() only supports AF_INET");
+		cemuLog_log(LogType::Force, "inet_pton() only supports AF_INET");
 		osLib_returnFromFunction(hCPU, 0);
 		return;
 	}
@@ -652,29 +767,52 @@ void nsysnetExport_inet_pton(PPCInterpreter_t* hCPU)
 		invalidIp = true;
 	if (d3 < 0 || d3 > 255)
 		invalidIp = true;
-#ifndef PUBLIC_RELEASE
-	if (invalidIp)
-		assert_dbg();
-#endif
 	if (invalidIp)
 	{
-		socketLog_printf("inet_pton(%d, \"%s\", 0x%08x) -> Invalid ip", af, ip, hCPU->gpr[5]);
+		cemuLog_log(LogType::Socket, "inet_pton({}, \"{}\", 0x{:08x}) -> Invalid ip", af, ip, hCPU->gpr[5]);
+        _setSockError(WU_SO_EAFNOSUPPORT);
 		osLib_returnFromFunction(hCPU, 0); // 0 -> invalid address
 		return;
 	}
 
 	addr->wu_s_addr = _swapEndianU32((d0 << 24) | (d1 << 16) | (d2 << 8) | (d3 << 0));
-	socketLog_printf("inet_pton(%d, \"%s\", 0x%08x) -> Ok", af, ip, hCPU->gpr[5]);
+	cemuLog_log(LogType::Socket, "inet_pton({}, \"{}\", 0x{:08x}) -> Ok", af, ip, hCPU->gpr[5]);
 
 	osLib_returnFromFunction(hCPU, 1); // 1 -> success
 }
 
+namespace nsysnet
+{
+    const char* inet_ntop(sint32 af, const void* src, char* dst, uint32 size)
+    {
+        if( af != WU_AF_INET)
+        {
+            // set error
+            _setSockError(WU_SO_EAFNOSUPPORT);
+            return nullptr;
+        }
+        const uint8* ip = (const uint8*)src;
+        char buf[32];
+        sprintf(buf, "%d.%d.%d.%d", ip[0], ip[1], ip[2], ip[3]);
+        size_t bufLen = strlen(buf);
+        if( (bufLen+1) > size )
+        {
+            // set error
+            _setSockError(WU_SO_EAFNOSUPPORT);
+            return nullptr;
+        }
+        strcpy(dst, buf);
+        cemuLog_log(LogType::Socket, "inet_ntop -> {}", buf);
+        return dst;
+    }
+}
+
 MEMPTR<char> _ntoa_tempString = nullptr;
 
 void nsysnetExport_inet_ntoa(PPCInterpreter_t* hCPU)
 {
 	ppcDefineParamStructPtr(addr, wu_in_addr, 0);
-	socketLog_printf("inet_ntoa(0x%08x)", hCPU->gpr[3]);
+	cemuLog_log(LogType::Socket, "inet_ntoa(0x{:08x})", hCPU->gpr[3]);
 
 	if (_ntoa_tempString == nullptr)
 		_ntoa_tempString = (char*)memory_getPointerFromVirtualOffset(OSAllocFromSystem(64, 4));
@@ -686,35 +824,35 @@ void nsysnetExport_inet_ntoa(PPCInterpreter_t* hCPU)
 
 void nsysnetExport_htons(PPCInterpreter_t* hCPU)
 {
-	socketLog_printf("htons(0x%04x)", hCPU->gpr[3]);
+	cemuLog_log(LogType::Socket, "htons(0x{:04x})", hCPU->gpr[3]);
 	ppcDefineParamU32(v, 0);
 	osLib_returnFromFunction(hCPU, v); // return value as-is
 }
 
 void nsysnetExport_htonl(PPCInterpreter_t* hCPU)
 {
-	socketLog_printf("htonl(0x%08x)", hCPU->gpr[3]);
+	cemuLog_log(LogType::Socket, "htonl(0x{:08x})", hCPU->gpr[3]);
 	ppcDefineParamU32(v, 0);
 	osLib_returnFromFunction(hCPU, v); // return value as-is
 }
 
 void nsysnetExport_ntohs(PPCInterpreter_t* hCPU)
 {
-	socketLog_printf("ntohs(0x%04x)", hCPU->gpr[3]);
+	cemuLog_log(LogType::Socket, "ntohs(0x{:04x})", hCPU->gpr[3]);
 	ppcDefineParamU32(v, 0);
 	osLib_returnFromFunction(hCPU, v); // return value as-is
 }
 
 void nsysnetExport_ntohl(PPCInterpreter_t* hCPU)
 {
-	socketLog_printf("ntohl(0x%08x)", hCPU->gpr[3]);
+	cemuLog_log(LogType::Socket, "ntohl(0x{:08x})", hCPU->gpr[3]);
 	ppcDefineParamU32(v, 0);
 	osLib_returnFromFunction(hCPU, v); // return value as-is
 }
 
 void nsysnetExport_bind(PPCInterpreter_t* hCPU)
 {
-	socketLog_printf("bind(%d,0x%08x,%d)", hCPU->gpr[3], hCPU->gpr[4], hCPU->gpr[5]);
+	cemuLog_log(LogType::Socket, "bind({},0x{:08x},{})", hCPU->gpr[3], hCPU->gpr[4], hCPU->gpr[5]);
 	ppcDefineParamS32(s, 0);
 	ppcDefineParamStructPtr(addr, struct wu_sockaddr, 1);
 	ppcDefineParamS32(len, 2);
@@ -737,10 +875,10 @@ void nsysnetExport_bind(PPCInterpreter_t* hCPU)
 		hostAddr.sa_family = _swapEndianU16(addr->sa_family);
 		memcpy(hostAddr.sa_data, addr->sa_data, 14);
 		sint32 hr = bind(vs->s, &hostAddr, sizeof(sockaddr));
-		r = _translateError(hr, WSAGetLastError());
+		r = _translateError(hr, GETLASTERR);
 
 
-		socketLog_printf("bind address: %d.%d.%d.%d:%d result: %d", addr->sa_data[2], addr->sa_data[3], addr->sa_data[4], addr->sa_data[5], _swapEndianU16(*(uint16*)addr->sa_data), hr);
+		cemuLog_log(LogType::Socket, "bind address: {}.{}.{}.{}:{} result: {}", addr->sa_data[2], addr->sa_data[3], addr->sa_data[4], addr->sa_data[5], _swapEndianU16(*(uint16*)addr->sa_data), hr);
 
 	}
 
@@ -749,7 +887,7 @@ void nsysnetExport_bind(PPCInterpreter_t* hCPU)
 
 void nsysnetExport_listen(PPCInterpreter_t* hCPU)
 {
-	socketLog_printf("listen(%d,%d)", hCPU->gpr[3], hCPU->gpr[4]);
+	cemuLog_log(LogType::Socket, "listen({},{})", hCPU->gpr[3], hCPU->gpr[4]);
 	ppcDefineParamS32(s, 0);
 	ppcDefineParamS32(queueSize, 1);
 
@@ -772,7 +910,7 @@ void nsysnetExport_listen(PPCInterpreter_t* hCPU)
 
 void nsysnetExport_accept(PPCInterpreter_t* hCPU)
 {
-	socketLog_printf("accept(%d,0x%08x,0x%08x)", hCPU->gpr[3], hCPU->gpr[4], hCPU->gpr[5]);
+	cemuLog_log(LogType::Socket, "accept({},0x{:08x},0x{:08x})", hCPU->gpr[3], hCPU->gpr[4], hCPU->gpr[5]);
 	ppcDefineParamS32(s, 0);
 	ppcDefineParamStructPtr(addr, struct wu_sockaddr, 1);
 	ppcDefineParamMPTR(lenMPTR, 2);
@@ -788,7 +926,7 @@ void nsysnetExport_accept(PPCInterpreter_t* hCPU)
 
 	if (memory_readU32(lenMPTR) != 16)
 	{
-		forceLog_printf("invalid sockaddr len in accept()");
+		cemuLog_log(LogType::Force, "invalid sockaddr len in accept()");
 		cemu_assert_debug(false);
 		osLib_returnFromFunction(hCPU, 0);
 		return;
@@ -797,7 +935,7 @@ void nsysnetExport_accept(PPCInterpreter_t* hCPU)
 	if (vs->isNonBlocking)
 	{
 		sockaddr hostAddr;
-		int hostLen = sizeof(sockaddr);
+		socklen_t hostLen = sizeof(sockaddr);
 		SOCKET hr = accept(vs->s, &hostAddr, &hostLen);
 		if (hr != SOCKET_ERROR)
 		{
@@ -806,24 +944,23 @@ void nsysnetExport_accept(PPCInterpreter_t* hCPU)
 		}
 		else
 		{
-			r = _translateError((sint32)hr, (sint32)WSAGetLastError(), _ERROR_MODE_ACCEPT);
+			r = _translateError((sint32)hr, (sint32)GETLASTERR, _ERROR_MODE_ACCEPT);
 		}
 		sockaddr_host2guest(&hostAddr, addr);
 	}
 	else
 	{
 		// blocking accept is not supported yet
-		forceLog_printf("blocking accept() not supported");
+		cemuLog_log(LogType::Force, "blocking accept() not supported");
 		cemu_assert_debug(false);
 	}
 
 	osLib_returnFromFunction(hCPU, r);
 }
 
-
 void nsysnetExport_connect(PPCInterpreter_t* hCPU)
 {
-	socketLog_printf("connect(%d,0x%08x,%d)", hCPU->gpr[3], hCPU->gpr[4], hCPU->gpr[5]);
+	cemuLog_log(LogType::Socket, "connect({},0x{:08x},{})", hCPU->gpr[3], hCPU->gpr[4], hCPU->gpr[5]);
 	ppcDefineParamS32(s, 0);
 	ppcDefineParamStructPtr(addr, struct wu_sockaddr, 1);
 	ppcDefineParamS32(len, 2);
@@ -842,9 +979,9 @@ void nsysnetExport_connect(PPCInterpreter_t* hCPU)
 	hostAddr.sa_family = _swapEndianU16(addr->sa_family);
 	memcpy(hostAddr.sa_data, addr->sa_data, 14);
 	sint32 hr = connect(vs->s, &hostAddr, sizeof(sockaddr));
-	forceLog_printf("Attempt connect to %d.%d.%d.%d:%d", (sint32)(uint8)hostAddr.sa_data[2], (sint32)(uint8)hostAddr.sa_data[3], (sint32)(uint8)hostAddr.sa_data[4], (sint32)(uint8)hostAddr.sa_data[5], _swapEndianU16(*(uint16*)hostAddr.sa_data+0));
+	cemuLog_log(LogType::Force, "Attempt connect to {}.{}.{}.{}:{}", (sint32)(uint8)hostAddr.sa_data[2], (sint32)(uint8)hostAddr.sa_data[3], (sint32)(uint8)hostAddr.sa_data[4], (sint32)(uint8)hostAddr.sa_data[5], _swapEndianU16(*(uint16*)hostAddr.sa_data+0));
 
-	r = _translateError(hr, WSAGetLastError(), _ERROR_MODE_CONNECT);
+	r = _translateError(hr, GETLASTERR, _ERROR_MODE_CONNECT);
 
 	osLib_returnFromFunction(hCPU, r);
 }
@@ -852,12 +989,12 @@ void nsysnetExport_connect(PPCInterpreter_t* hCPU)
 void _setSocketSendRecvNonBlockingMode(SOCKET s, bool isNonBlocking)
 {
 	u_long mode = isNonBlocking ? 1 : 0;
-	sint32 r = ioctlsocket(s, FIONBIO, &mode);
+	sint32 r = _socket_nonblock(s,  mode);
 }
 
 void nsysnetExport_send(PPCInterpreter_t* hCPU)
 {
-	socketLog_printf("send(%d,0x%08x,%d,0x%x)", hCPU->gpr[3], hCPU->gpr[4], hCPU->gpr[5], hCPU->gpr[6]);
+	cemuLog_log(LogType::Socket, "send({},0x{:08x},{},0x{:x})", hCPU->gpr[3], hCPU->gpr[4], hCPU->gpr[5], hCPU->gpr[6]);
 	ppcDefineParamS32(s, 0);
 	ppcDefineParamStr(msg, 1);
 	ppcDefineParamS32(len, 2);
@@ -880,8 +1017,8 @@ void nsysnetExport_send(PPCInterpreter_t* hCPU)
 		assert_dbg();
 
 	sint32 hr = send(vs->s, msg, len, hostFlags);
-	socketLog_printf("Sent %d bytes", hr);
-	_translateError(hr <= 0 ? -1 : 0, WSAGetLastError());
+	cemuLog_log(LogType::Socket, "Sent {} bytes", hr);
+	_translateError(hr <= 0 ? -1 : 0, GETLASTERR);
 	r = hr;
 
 	osLib_returnFromFunction(hCPU, r);
@@ -889,7 +1026,7 @@ void nsysnetExport_send(PPCInterpreter_t* hCPU)
 
 void nsysnetExport_recv(PPCInterpreter_t* hCPU)
 {
-	socketLog_printf("recv(%d,0x%08x,%d,0x%x) LR: 0x%08x Thread: 0x%08x", hCPU->gpr[3], hCPU->gpr[4], hCPU->gpr[5], hCPU->gpr[6], hCPU->spr.LR, coreinitThread_getCurrentThreadMPTRDepr(hCPU));
+	cemuLog_log(LogType::Socket, "recv({},0x{:08x},{},0x{:x})", hCPU->gpr[3], hCPU->gpr[4], hCPU->gpr[5], hCPU->gpr[6]);
 	ppcDefineParamS32(s, 0);
 	ppcDefineParamStr(msg, 1);
 	ppcDefineParamS32(len, 2);
@@ -930,7 +1067,7 @@ void nsysnetExport_recv(PPCInterpreter_t* hCPU)
 				break;
 			if (tr == 0)
 				break; // connection closed
-			if (tr < 0 && WSAGetLastError() != WSAEWOULDBLOCK)
+			if (tr < 0 && GETLASTERR != WSAEWOULDBLOCK)
 				break;
 			// yield thread
 			coreinit::OSSleepTicks(coreinit::EspressoTime::GetTimerClock() / 5000); // let thread wait 0.2ms to give other threads CPU time
@@ -940,10 +1077,10 @@ void nsysnetExport_recv(PPCInterpreter_t* hCPU)
 	}
 	// receive
 	sint32 hr = recv(vs->s, msg, len, hostFlags);
-	_translateError(hr <= 0 ? -1 : 0, WSAGetLastError());
+	_translateError(hr <= 0 ? -1 : 0, GETLASTERR);
 	if (requestIsNonBlocking != vs->isNonBlocking)
 		_setSocketSendRecvNonBlockingMode(vs->s, vs->isNonBlocking);
-	socketLog_printf("Received %d bytes", hr);
+	cemuLog_log(LogType::Socket, "Received {} bytes", hr);
 	r = hr;
 
 	osLib_returnFromFunction(hCPU, r);
@@ -955,11 +1092,20 @@ struct wu_timeval
 	uint32 tv_usec;
 };
 
-void _translateFDSet(fd_set* hostSet, struct wu_fd_set* fdset, sint32 nfds)
+void _translateFDSet(fd_set* hostSet, struct wu_fd_set* fdset, sint32 nfds, int *hostnfds)
 {
-	hostSet->fd_count = 0;
+	FD_ZERO(hostSet);
 	if (fdset == NULL)
 		return;
+
+#if BOOST_OS_UNIX
+	int maxfd;
+	if(hostnfds)
+		maxfd = *hostnfds;
+	else
+		maxfd = -1;
+#endif
+
 	uint32 mask = fdset->mask;
 	for (sint32 i = 0; i < nfds; i++)
 	{
@@ -969,9 +1115,19 @@ void _translateFDSet(fd_set* hostSet, struct wu_fd_set* fdset, sint32 nfds)
 		virtualSocket_t* vs = nsysnet_getVirtualSocketObject(socketHandle);
 		if(vs == NULL)
 			continue; // socket invalid
-		hostSet->fd_array[hostSet->fd_count] = vs->s;
-		hostSet->fd_count++;
+
+#if BOOST_OS_UNIX
+		if(vs->s > maxfd)
+			maxfd = vs->s;
+#endif
+
+		FD_SET(vs->s, hostSet);
 	}
+
+#if BOOST_OS_UNIX
+	if(hostnfds)
+		*hostnfds = maxfd;
+#endif
 }
 
 void _translateFDSetRev(struct wu_fd_set* fdset, fd_set* hostSet, sint32 nfds)
@@ -979,6 +1135,7 @@ void _translateFDSetRev(struct wu_fd_set* fdset, fd_set* hostSet, sint32 nfds)
 	if (fdset == NULL)
 		return;
 	uint32 mask = _swapEndianU32(0);
+#if BOOST_OS_WINDOWS
 	for (sint32 i = 0; i < (sint32)hostSet->fd_count; i++)
 	{
 		sint32 virtualSocketHandle = nsysnet_getVirtualSocketHandleFromHostHandle(hostSet->fd_array[i]);
@@ -986,19 +1143,27 @@ void _translateFDSetRev(struct wu_fd_set* fdset, fd_set* hostSet, sint32 nfds)
 			cemu_assert_debug(false);
 		mask |= (1<<virtualSocketHandle);
 	}
+#else
+	for (sint32 i = 0; i < WU_SOCKET_LIMIT; i++)
+	{
+		if (virtualSocketTable[i] && virtualSocketTable[i]->s && FD_ISSET(virtualSocketTable[i]->s, hostSet))
+			mask |= (1 << virtualSocketTable[i]->handle);
+	}
+#endif
 	fdset->mask = mask;
+
 }
 
 void nsysnetExport_select(PPCInterpreter_t* hCPU)
 {
-	socketLog_printf("select(%d,0x%08x,0x%08x,0x%08x,0x%08x) LR 0x%08x Thread 0x%08x", hCPU->gpr[3], hCPU->gpr[4], hCPU->gpr[5], hCPU->gpr[6], hCPU->gpr[7], hCPU->spr.LR, coreinitThread_getCurrentThreadMPTRDepr(hCPU));
+	cemuLog_log(LogType::Socket, "select({},0x{:08x},0x{:08x},0x{:08x},0x{:08x})", hCPU->gpr[3], hCPU->gpr[4], hCPU->gpr[5], hCPU->gpr[6], hCPU->gpr[7]);
 	ppcDefineParamS32(nfds, 0);
 	ppcDefineParamStructPtr(readfds, struct wu_fd_set, 1);
 	ppcDefineParamStructPtr(writefds, struct wu_fd_set, 2);
 	ppcDefineParamStructPtr(exceptfds, struct wu_fd_set, 3);
 	ppcDefineParamStructPtr(timeOut, struct wu_timeval, 4);
 
-	//socketLog_printf("rm %08x wm %08x em %08x", readfds ? _swapEndianU32(readfds->mask) : 0, writefds ? _swapEndianU32(writefds->mask) : 0, exceptfds ? _swapEndianU32(exceptfds->mask) : 0);
+	//cemuLog_log(LogType::Socket, "rm {:08x} wm {:08x} em {:08x}", readfds ? _swapEndianU32(readfds->mask) : 0, writefds ? _swapEndianU32(writefds->mask) : 0, exceptfds ? _swapEndianU32(exceptfds->mask) : 0);
 
 	sint32 r = 0;
 
@@ -1011,7 +1176,7 @@ void nsysnetExport_select(PPCInterpreter_t* hCPU)
 		if (timeOut == NULL || (timeOut->tv_sec == 0 && timeOut->tv_usec == 0))
 		{
 			// return immediately
-			socketLog_printf("select returned immediately because of empty fdsets without timeout");
+			cemuLog_log(LogType::Socket, "select returned immediately because of empty fdsets without timeout");
 			osLib_returnFromFunction(hCPU, 0);
 			return;
 		}
@@ -1020,14 +1185,16 @@ void nsysnetExport_select(PPCInterpreter_t* hCPU)
 			//// empty select with timeout is not allowed
 			//_setSockError(WU_SO_EINVAL);
 			//osLib_returnFromFunction(hCPU, -1);
-			//socketLog_printf("select returned SO_EINVAL because of empty fdsets with timeout");
+			//cemuLog_log(LogType::Socket, "select returned SO_EINVAL because of empty fdsets with timeout");
 
 			// when fd sets are empty but timeout is set, then just wait and do nothing?
 			// Lost Reavers seems to expect this case to return 0 (it hardcodes empty fd sets and timeout comes from curl_multi_timeout)
 
-			//_setSockError(WU_SO_EINVAL);
-			// todo - sleep here
-			socketLog_printf("select returned 0 because of empty fdsets with timeout");
+			timeval tv;
+			tv.tv_sec = timeOut->tv_sec;
+			tv.tv_usec = timeOut->tv_usec;
+			select(0, nullptr, nullptr, nullptr, &tv);
+			cemuLog_log(LogType::Socket, "select returned 0 because of empty fdsets with timeout");
 			osLib_returnFromFunction(hCPU, 0);
 			
 			return;
@@ -1038,19 +1205,28 @@ void nsysnetExport_select(PPCInterpreter_t* hCPU)
 
 	timeval tv = { 0 };
 
+	if (timeOut == NULL)
+	{
+		// return immediately
+		cemuLog_log(LogType::Socket, "select returned immediately because of null timeout");
+		osLib_returnFromFunction(hCPU, 0);
+		return;
+	}
+
 	uint64 msTimeout = (_swapEndianU32(timeOut->tv_usec) / 1000) + (_swapEndianU32(timeOut->tv_sec) * 1000);
 	uint32 startTime = GetTickCount();
 	while (true)
 	{
-		_translateFDSet(&_readfds, readfds, nfds);
-		_translateFDSet(&_writefds, writefds, nfds);
-		_translateFDSet(&_exceptfds, exceptfds, nfds);
-		r = select(0, readfds ? &_readfds : NULL, writefds ? &_writefds : NULL, exceptfds ? &_exceptfds : NULL, &tv);
+		int hostnfds = -1;
+		_translateFDSet(&_readfds, readfds, nfds, &hostnfds);
+		_translateFDSet(&_writefds, writefds, nfds, &hostnfds);
+		_translateFDSet(&_exceptfds, exceptfds, nfds, &hostnfds);
+		r = select(hostnfds + 1, readfds ? &_readfds : NULL, writefds ? &_writefds : NULL, exceptfds ? &_exceptfds : NULL, &tv);
 		if (r < 0)
 		{
-			forceLogDebug_printf("select() failed");
+			cemuLog_logDebug(LogType::Force, "select() failed");
 			// timeout
-			_translateError(r, WSAGetLastError());
+			_translateError(r, GETLASTERR);
 			//_setSockError(WU_SO_SUCCESS);
 			// in case of error, clear all FD sets (?)
 			if (readfds)
@@ -1083,26 +1259,28 @@ void nsysnetExport_select(PPCInterpreter_t* hCPU)
 		}
 		else
 		{
-			socketLog_printf("select returned %d. Read %d Write %d Except %d", r, _readfds.fd_count, _writefds.fd_count, _exceptfds.fd_count);
+			// cemuLog_log(LogType::Socket, "select returned {}. Read {} Write {} Except {}", r, _readfds.fd_count, _writefds.fd_count, _exceptfds.fd_count);
+			cemuLog_log(LogType::Socket, "select returned {}.", r);
+
 			_translateFDSetRev(readfds, &_readfds, nfds);
 			_translateFDSetRev(writefds, &_writefds, nfds);
 			_translateFDSetRev(exceptfds, &_exceptfds, nfds);
 			break;
 		}
 	}
-	//forceLog_printf("selectEndTime %d", timeGetTime());
+	//cemuLog_log(LogType::Force, "selectEndTime {}", timeGetTime());
 
 
 	//extern int select(int nfds, fd_set *readfds, fd_set *writefds, fd_set *exceptfds,
 	//	struct timeval *timeout);
 
-	socketLog_printf("select returned %d", r);
+	cemuLog_log(LogType::Socket, "select returned {}", r);
 	osLib_returnFromFunction(hCPU, r);
 }
 
 void nsysnetExport_getsockname(PPCInterpreter_t* hCPU)
 {
-	socketLog_printf("getsockname(%d,0x%08x,0x%08x)", hCPU->gpr[3], hCPU->gpr[4], hCPU->gpr[5]);
+	cemuLog_log(LogType::Socket, "getsockname({},0x{:08x},0x{:08x})", hCPU->gpr[3], hCPU->gpr[4], hCPU->gpr[5]);
 
 	ppcDefineParamS32(s, 0);
 	ppcDefineParamStructPtr(addr, struct wu_sockaddr, 1);
@@ -1116,7 +1294,7 @@ void nsysnetExport_getsockname(PPCInterpreter_t* hCPU)
 	else
 	{
 		struct sockaddr hostAddr;
-		sint32 hostLen = sizeof(struct sockaddr);
+		socklen_t hostLen = sizeof(struct sockaddr);
 		sint32 hr = getsockname(vs->s, &hostAddr, &hostLen);
 		if (hr == 0)
 		{
@@ -1151,13 +1329,13 @@ void nsysnetExport_getpeername(PPCInterpreter_t* hCPU)
 	}
 
 	sockaddr saddr;
-	int saddrLen = sizeof(sockaddr);
+	socklen_t saddrLen = sizeof(sockaddr);
 
 	if (*nameLen < (uint32be)16)
 		assert_dbg();
 
 	sint32 r = getpeername(vs->s, &saddr, &saddrLen);
-	r = _translateError(r, WSAGetLastError());
+	r = _translateError(r, GETLASTERR);
 
 	name->sa_family = _swapEndianU16(saddr.sa_family);
 	memcpy(name->sa_data, saddr.sa_data, 14);
@@ -1187,7 +1365,7 @@ void nsysnetExport_gethostbyname(PPCInterpreter_t* hCPU)
 {
 	ppcDefineParamStr(name, 0);
 
-	socketLog_printf("gethostbyname(\"%s\")", name);
+	cemuLog_log(LogType::Socket, "gethostbyname(\"{}\")", name);
 
 	hostent* he = gethostbyname(name);
 	if (he == NULL)
@@ -1235,17 +1413,17 @@ void nsysnetExport_gethostbyaddr(PPCInterpreter_t* hCPU)
 
 	sint32 maxNumEntries = 31;
 
-	socketLog_printf("gethostbyaddr(\"%s\", %d, %d)", addr, len, type);
+	cemuLog_log(LogType::Socket, "gethostbyaddr(\"{}\", {}, {})", addr, len, type);
 
 	hostent* he = gethostbyaddr(addr, len, type);
 	if (he == nullptr)
 	{
-		socketLog_printf("gethostbyaddr(\"%s\", %d, %d) failed", addr, len, type);
+		cemuLog_log(LogType::Socket, "gethostbyaddr(\"{}\", {}, {}) failed", addr, len, type);
 		osLib_returnFromFunction(hCPU, MPTR_NULL);
 		return;
 	}
 
-#ifndef PUBLIC_RELEASE
+#ifdef CEMU_DEBUG_ASSERT
 	if (he->h_addrtype != AF_INET)
 		assert_dbg();
 	if (he->h_length != sizeof(in_addr))
@@ -1261,7 +1439,7 @@ void nsysnetExport_gethostbyaddr(PPCInterpreter_t* hCPU)
 	}
 	else
 	{
-		forceLog_printf("he->h_name not set or name too long");
+		cemuLog_log(LogType::Force, "he->h_name not set or name too long");
 		strcpy(_staticHostentName.GetPtr(), "");
 	}
 	// setup wuHostent address list
@@ -1293,7 +1471,7 @@ void nsysnetExport_getaddrinfo(PPCInterpreter_t* hCPU)
 	ppcDefineParamStructPtr(hints, struct wu_addrinfo, 2);
 	ppcDefineParamMPTR(results, 3);
 
-	socketLog_printf("getaddrinfo(\"%s\",0x%08x,0x%08x,0x%08x)", nodeName, hCPU->gpr[4], hCPU->gpr[5], hCPU->gpr[6]);
+	cemuLog_log(LogType::Socket, "getaddrinfo(\"{}\",0x{:08x},0x{:08x},0x{:08x})", nodeName, hCPU->gpr[4], hCPU->gpr[5], hCPU->gpr[6]);
 	
 	sint32 r = 0;
 
@@ -1319,7 +1497,7 @@ void nsysnetExport_getaddrinfo(PPCInterpreter_t* hCPU)
 	sint32 hr = getaddrinfo(nodeName, serviceName, &hint, &result);
 	if (hr != 0)
 	{
-		socketLog_printf("getaddrinfo failed with error %d", hr);
+		cemuLog_log(LogType::Socket, "getaddrinfo failed with error {}", hr);
 		switch (hr)
 		{
 		case WSAHOST_NOT_FOUND:
@@ -1328,7 +1506,7 @@ void nsysnetExport_getaddrinfo(PPCInterpreter_t* hCPU)
 		default:
 			// unhandled error
 			cemu_assert_debug(false);
-			socketLog_printf("getaddrinfo unhandled error code");
+			cemuLog_log(LogType::Socket, "getaddrinfo unhandled error code");
 			r = 1;
 			break;
 		}
@@ -1403,7 +1581,7 @@ void nsysnetExport_getaddrinfo(PPCInterpreter_t* hCPU)
 
 void nsysnetExport_recvfrom(PPCInterpreter_t* hCPU)
 {
-	socketLog_printf("recvfrom(%d,0x%08x,%d,0x%x) LR: 0x%08x Thread: 0x%08x", hCPU->gpr[3], hCPU->gpr[4], hCPU->gpr[5], hCPU->gpr[6], hCPU->spr.LR, coreinitThread_getCurrentThreadMPTRDepr(hCPU));
+	cemuLog_log(LogType::Socket, "recvfrom({},0x{:08x},{},0x{:x},0x{:x},0x{:x})", hCPU->gpr[3], hCPU->gpr[4], hCPU->gpr[5], hCPU->gpr[6], hCPU->gpr[7], hCPU->gpr[8]);
 	ppcDefineParamS32(s, 0);
 	ppcDefineParamStr(msg, 1);
 	ppcDefineParamS32(len, 2);
@@ -1432,8 +1610,8 @@ void nsysnetExport_recvfrom(PPCInterpreter_t* hCPU)
 	if (vs->isNonBlocking)
 		requestIsNonBlocking = vs->isNonBlocking;
 
-	sint32 fromLenHost = *fromLen;
 	sockaddr fromAddrHost;
+	socklen_t fromLenHost = sizeof(fromAddrHost);
 	sint32 wsaError = 0;
 
 	while( true )
@@ -1447,16 +1625,20 @@ void nsysnetExport_recvfrom(PPCInterpreter_t* hCPU)
 			return;
 		}
 		// use select to check for exceptions and read data
-		FD_SET fd_read;
-		FD_SET fd_exceptions;
+		fd_set fd_read;
+		fd_set fd_exceptions;
 		FD_ZERO(&fd_read);
 		FD_ZERO(&fd_exceptions);
 		FD_SET(vs->s, &fd_read);
 		FD_SET(vs->s, &fd_exceptions);
-		TIMEVAL t;
+		timeval t;
 		t.tv_sec = 0;
 		t.tv_usec = 0;
-		sint32 count = select(0, &fd_read, NULL, &fd_exceptions, &t);
+		int nfds = 0;
+#if BOOST_OS_UNIX
+		nfds = vs->s + 1;
+#endif
+		sint32 count = select(nfds, &fd_read, NULL, &fd_exceptions, &t);
 		if (count > 0)
 		{
 			if (FD_ISSET(vs->s, &fd_exceptions))
@@ -1467,13 +1649,17 @@ void nsysnetExport_recvfrom(PPCInterpreter_t* hCPU)
 			{
 				// data available
 				r = recvfrom(vs->s, msg, len, hostFlags, &fromAddrHost, &fromLenHost);
-				wsaError = WSAGetLastError();
+				wsaError = GETLASTERR;
 				if (r < 0)
 					cemu_assert_debug(false);
-				forceLogDebug_printf("recvfrom returned %d bytes", r);
-				*fromLen = fromLenHost;
-				fromAddr->sa_family = _swapEndianU16(fromAddrHost.sa_family);
-				memcpy(fromAddr->sa_data, fromAddrHost.sa_data, 14);
+				cemuLog_logDebug(LogType::Force, "recvfrom returned {} bytes", r);
+
+				// fromAddr and fromLen can be NULL
+				if (fromAddr && fromLen) {
+					*fromLen = fromLenHost;
+					fromAddr->sa_family = _swapEndianU16(fromAddrHost.sa_family);
+					memcpy(fromAddr->sa_data, fromAddrHost.sa_data, 14);
+				}
 
 				_setSockError(0);
 				osLib_returnFromFunction(hCPU, r);
@@ -1504,7 +1690,7 @@ void nsysnetExport_recvfrom(PPCInterpreter_t* hCPU)
 		while (true)
 		{
 			r = recvfrom(vs->s, msg, len, hostFlags, &fromAddrHost, &fromLenHost);
-			wsaError = WSAGetLastError();
+			wsaError = GETLASTERR;
 			if (r < 0)
 			{
 				if (wsaError != WSAEWOULDBLOCK)
@@ -1523,9 +1709,12 @@ void nsysnetExport_recvfrom(PPCInterpreter_t* hCPU)
 		assert_dbg();
 	}
 
-	*fromLen = fromLenHost;
-	fromAddr->sa_family = _swapEndianU16(fromAddrHost.sa_family);
-	memcpy(fromAddr->sa_data, fromAddrHost.sa_data, 14);
+	// fromAddr and fromLen can be NULL
+	if (fromAddr && fromLen) {
+		*fromLen = fromLenHost;
+		fromAddr->sa_family = _swapEndianU16(fromAddrHost.sa_family);
+		memcpy(fromAddr->sa_data, fromAddrHost.sa_data, 14);
+	}
 
 	_translateError(r <= 0 ? -1 : 0, wsaError);
 
@@ -1535,7 +1724,7 @@ void nsysnetExport_recvfrom(PPCInterpreter_t* hCPU)
 
 void nsysnetExport_recvfrom_ex(PPCInterpreter_t* hCPU)
 {
-	socketLog_printf("recvfrom_ex(%d,0x%08x,%d,0x%x,0x%08x,0x%08x,0x%08x,%d) LR: 0x%08x Thread: 0x%08x", hCPU->gpr[3], hCPU->gpr[4], hCPU->gpr[5], hCPU->gpr[6], hCPU->gpr[7], hCPU->gpr[8], hCPU->gpr[9], hCPU->gpr[10], hCPU->spr.LR, coreinitThread_getCurrentThreadMPTRDepr(hCPU));
+	cemuLog_log(LogType::Socket, "recvfrom_ex({},0x{:08x},{},0x{:x},0x{:08x},0x{:08x},0x{:08x},{})", hCPU->gpr[3], hCPU->gpr[4], hCPU->gpr[5], hCPU->gpr[6], hCPU->gpr[7], hCPU->gpr[8], hCPU->gpr[9], hCPU->gpr[10]);
 	ppcDefineParamS32(s, 0);
 	ppcDefineParamStr(msg, 1);
 	ppcDefineParamS32(len, 2);
@@ -1576,7 +1765,7 @@ void nsysnetExport_recvfrom_ex(PPCInterpreter_t* hCPU)
 	if (vs->isNonBlocking)
 		requestIsNonBlocking = vs->isNonBlocking;
 
-	sint32 fromLenHost = *fromLen;
+	socklen_t fromLenHost = *fromLen;
 	sockaddr fromAddrHost;
 	sint32 wsaError = 0;
 
@@ -1591,16 +1780,20 @@ void nsysnetExport_recvfrom_ex(PPCInterpreter_t* hCPU)
 			return;
 		}
 		// use select to check for exceptions and read data
-		FD_SET fd_read;
-		FD_SET fd_exceptions;
+		fd_set fd_read;
+		fd_set fd_exceptions;
 		FD_ZERO(&fd_read);
 		FD_ZERO(&fd_exceptions);
 		FD_SET(vs->s, &fd_read);
 		FD_SET(vs->s, &fd_exceptions);
-		TIMEVAL t;
+		timeval t;
 		t.tv_sec = 0;
 		t.tv_usec = 0;
-		sint32 count = select(0, &fd_read, NULL, &fd_exceptions, &t);
+		int nfds = 0;
+#if BOOST_OS_UNIX
+		nfds = vs->s + 1;
+#endif
+		sint32 count = select(nfds, &fd_read, NULL, &fd_exceptions, &t);
 		if (count > 0)
 		{
 			if (FD_ISSET(vs->s, &fd_exceptions))
@@ -1611,7 +1804,7 @@ void nsysnetExport_recvfrom_ex(PPCInterpreter_t* hCPU)
 			{
 				// data available
 				r = recvfrom(vs->s, msg, len, hostFlags, &fromAddrHost, &fromLenHost);
-				wsaError = WSAGetLastError();
+				wsaError = GETLASTERR;
 				if (r < 0)
 				{
 					cemu_assert_debug(false);
@@ -1653,7 +1846,7 @@ void _convertSockaddrToHostFormat(wu_sockaddr* sockaddru, sockaddr* sockaddrHost
 
 void nsysnetExport_sendto(PPCInterpreter_t* hCPU)
 {
-	socketLog_printf("sendto(%d,0x%08x,%d,0x%x) LR: 0x%08x Thread: 0x%08x", hCPU->gpr[3], hCPU->gpr[4], hCPU->gpr[5], hCPU->gpr[6], hCPU->spr.LR, coreinitThread_getCurrentThreadMPTRDepr(hCPU));
+	cemuLog_log(LogType::Socket, "sendto({},0x{:08x},{},0x{:x})", hCPU->gpr[3], hCPU->gpr[4], hCPU->gpr[5], hCPU->gpr[6]);
 	ppcDefineParamS32(s, 0);
 	ppcDefineParamStr(msg, 1);
 	ppcDefineParamS32(len, 2);
@@ -1693,7 +1886,7 @@ void nsysnetExport_sendto(PPCInterpreter_t* hCPU)
 		while (true)
 		{
 			r = sendto(vs->s, msg, len, hostFlags, &toAddrHost, toLen);
-			wsaError = WSAGetLastError();
+			wsaError = GETLASTERR;
 			if (r < 0)
 			{
 				if (wsaError != WSAEWOULDBLOCK)
@@ -1711,7 +1904,7 @@ void nsysnetExport_sendto(PPCInterpreter_t* hCPU)
 		// non blocking
 		_setSocketSendRecvNonBlockingMode(vs->s, true);
 		r = sendto(vs->s, msg, len, hostFlags, &toAddrHost, toLen);
-		wsaError = WSAGetLastError();
+		wsaError = GETLASTERR;
 		_setSocketSendRecvNonBlockingMode(vs->s, vs->isNonBlocking);
 	}
 
@@ -1723,7 +1916,7 @@ void nsysnetExport_sendto(PPCInterpreter_t* hCPU)
 
 void nsysnetExport_sendto_multi(PPCInterpreter_t* hCPU)
 {
-	socketLog_printf("sendto_multi(%d,0x%08x,0x%08x,%d) LR: 0x%08x Thread: 0x%08x", hCPU->gpr[3], hCPU->gpr[4], hCPU->gpr[5], hCPU->gpr[6], hCPU->spr.LR, coreinitThread_getCurrentThreadMPTRDepr(hCPU));
+	cemuLog_log(LogType::Socket, "sendto_multi({},0x{:08x},0x{:08x},{})", hCPU->gpr[3], hCPU->gpr[4], hCPU->gpr[5], hCPU->gpr[6]);
 	ppcDefineParamS32(s, 0);
 	ppcDefineParamStr(data, 1);
 	ppcDefineParamS32(dataLen, 2);
@@ -1770,7 +1963,7 @@ typedef struct
 
 void nsysnetExport_sendto_multi_ex(PPCInterpreter_t* hCPU)
 {
-	socketLog_printf("sendto_multi_ex(%d,0x%08x,0x%08x,%d) LR: 0x%08x Thread: 0x%08x", hCPU->gpr[3], hCPU->gpr[4], hCPU->gpr[5], hCPU->gpr[6], hCPU->spr.LR, coreinitThread_getCurrentThreadMPTRDepr(hCPU));
+	cemuLog_log(LogType::Socket, "sendto_multi_ex({},0x{:08x},0x{:08x},{})", hCPU->gpr[3], hCPU->gpr[4], hCPU->gpr[5], hCPU->gpr[6]);
 	ppcDefineParamS32(s, 0);
 	ppcDefineParamU32(flags, 1);
 	ppcDefineParamStructPtr(multiBuf, sendtomultiBuffer_t, 2);
@@ -1818,8 +2011,6 @@ void nsysnetExport_sendto_multi_ex(PPCInterpreter_t* hCPU)
 	osLib_returnFromFunction(hCPU, sendLenSum); // return value correct?
 }
 
-#endif
-
 namespace nsysnet
 {
 	std::vector<NSSLInternalState_t> g_nsslInternalStates;
@@ -1845,7 +2036,7 @@ namespace nsysnet
 
 		uint32 nsslHandle = (uint32)g_nsslInternalStates.size() - 1;
 
-		forceLogDebug_printf("NSSLCreateContext(0x%x) -> 0x%x", version, nsslHandle);
+		cemuLog_logDebug(LogType::Force, "NSSLCreateContext(0x{:x}) -> 0x{:x}", version, nsslHandle);
 
 		osLib_returnFromFunction(hCPU, nsslHandle);
 	}
@@ -1854,7 +2045,7 @@ namespace nsysnet
 	{
 		ppcDefineParamU32(nsslHandle, 0);
 		ppcDefineParamU32(clientPKI, 1);
-		forceLogDebug_printf("NSSLSetClientPKI(0x%x, 0x%x)", nsslHandle, clientPKI);
+		cemuLog_logDebug(LogType::Force, "NSSLSetClientPKI(0x{:x}, 0x{:x})", nsslHandle, clientPKI);
 
 		if (g_nsslInternalStates.size() <= nsslHandle || g_nsslInternalStates[nsslHandle].destroyed)
 		{
@@ -1870,7 +2061,7 @@ namespace nsysnet
 	{
 		ppcDefineParamU32(nsslHandle, 0);
 		ppcDefineParamU32(serverPKI, 1);
-		forceLogDebug_printf("NSSLAddServerPKI(0x%x, 0x%x)", nsslHandle, serverPKI);
+		cemuLog_logDebug(LogType::Force, "NSSLAddServerPKI(0x{:x}, 0x{:x})", nsslHandle, serverPKI);
 
 		if (g_nsslInternalStates.size() <= nsslHandle || g_nsslInternalStates[nsslHandle].destroyed)
 		{
@@ -1889,7 +2080,7 @@ namespace nsysnet
 		ppcDefineParamS32(certLen, 2);
 		ppcDefineParamS32(certType, 3);
 
-		forceLogDebug_printf("NSSLAddServerPKIExternal(0x%x, 0x%08x, 0x%x, %d)", nsslHandle, certData.GetMPTR(), certLen, certType);
+		cemuLog_logDebug(LogType::Force, "NSSLAddServerPKIExternal(0x{:x}, 0x{:08x}, 0x{:x}, {})", nsslHandle, certData.GetMPTR(), certLen, certType);
 		if (g_nsslInternalStates.size() <= nsslHandle || g_nsslInternalStates[nsslHandle].destroyed)
 		{
 			osLib_returnFromFunction(hCPU, NSSL_INVALID_CTX);
@@ -1907,7 +2098,7 @@ namespace nsysnet
 		ppcDefineParamU32(groupMask, 1);
 		ppcDefineParamMEMPTR(validCountOut, sint32, 2);
 		ppcDefineParamMEMPTR(invalidCountOut, sint32, 3);
-		forceLogDebug_printf("NSSLAddServerPKIGroups(0x%x, 0x%x, 0x%08x, 0x%08x)", nsslHandle, groupMask, validCountOut.GetMPTR(), invalidCountOut.GetMPTR());
+		cemuLog_logDebug(LogType::Force, "NSSLAddServerPKIGroups(0x{:x}, 0x{:x}, 0x{:08x}, 0x{:08x})", nsslHandle, groupMask, validCountOut.GetMPTR(), invalidCountOut.GetMPTR());
 
 		if (g_nsslInternalStates.size() <= nsslHandle || g_nsslInternalStates[nsslHandle].destroyed)
 		{
@@ -1941,7 +2132,7 @@ namespace nsysnet
 	void export_NSSLDestroyContext(PPCInterpreter_t* hCPU)
 	{
 		ppcDefineParamU32(nsslHandle, 0);
-		forceLogDebug_printf("NSSLDestroyContext(0x%x)", nsslHandle);
+		cemuLog_logDebug(LogType::Force, "NSSLDestroyContext(0x{:x})", nsslHandle);
 
 		if (g_nsslInternalStates.size() <= nsslHandle || g_nsslInternalStates[nsslHandle].destroyed)
 		{
@@ -2024,14 +2215,23 @@ namespace nsysnet
 
 }
 
-
+namespace nsysnet
+{
+    void Initialize()
+    {
+        cafeExportRegister("nsysnet", inet_ntop, LogType::Socket);
+    }
+}
 
 // register nsysnet functions
 void nsysnet_load()
 {
-	
-	#if BOOST_OS_WINDOWS
-	osLib_addFunction("nsysnet", "socket_lib_init", nsysnetExport_socket_lib_init);
+    nsysnet::Initialize();
+
+    // the below code is the old way of registering API which is deprecated
+
+    osLib_addFunction("nsysnet", "socket_lib_init", nsysnetExport_socket_lib_init);
+	osLib_addFunction("nsysnet", "socket_lib_finish", nsysnetExport_socket_lib_finish);
 	
 	// socket API
 	osLib_addFunction("nsysnet", "socket", nsysnetExport_socket);
@@ -2071,7 +2271,6 @@ void nsysnet_load()
 	osLib_addFunction("nsysnet", "sendto_multi", nsysnetExport_sendto_multi);
 	osLib_addFunction("nsysnet", "sendto_multi_ex", nsysnetExport_sendto_multi_ex);
 
-#endif
 
 	// NSSL API
 	osLib_addFunction("nsysnet", "NSSLCreateContext", nsysnet::export_NSSLCreateContext);
@@ -2084,10 +2283,3 @@ void nsysnet_load()
 	osLib_addFunction("nsysnet", "NSSLExportInternalServerCertificate", nsysnet::export_NSSLExportInternalServerCertificate);
 	osLib_addFunction("nsysnet", "NSSLExportInternalClientCertificate", nsysnet::export_NSSLExportInternalClientCertificate);
 }
-
-#if BOOST_OS_LINUX || BOOST_OS_MACOS
-void nsysnet_notifyCloseSharedSocket(SOCKET existingSocket)
-{
-
-}
-#endif
\ No newline at end of file
diff --git a/src/Cafe/OS/libs/ntag/ntag.cpp b/src/Cafe/OS/libs/ntag/ntag.cpp
new file mode 100644
index 00000000..7c95a1a1
--- /dev/null
+++ b/src/Cafe/OS/libs/ntag/ntag.cpp
@@ -0,0 +1,647 @@
+#include "Cafe/OS/common/OSCommon.h"
+#include "Cafe/OS/RPL/rpl.h"
+#include "Cafe/OS/libs/ntag/ntag.h"
+#include "Cafe/OS/libs/nfc/nfc.h"
+#include "Cafe/OS/libs/coreinit/coreinit_IPC.h"
+#include "Cafe/IOSU/ccr_nfc/iosu_ccr_nfc.h"
+
+namespace ntag
+{
+	struct NTAGWriteData
+	{
+		uint16 size;
+		uint8 data[0x1C8];
+		nfc::NFCUid uid;
+		nfc::NFCUid uidMask;
+	};
+	NTAGWriteData gWriteData[2];
+
+	bool ccrNfcOpened = false;
+	IOSDevHandle gCcrNfcHandle;
+
+	NTAGFormatSettings gFormatSettings;
+
+	MPTR gDetectCallbacks[2];
+	MPTR gAbortCallbacks[2];
+	MPTR gReadCallbacks[2];
+	MPTR gWriteCallbacks[2];
+
+	sint32 __NTAGConvertNFCResult(sint32 result)
+	{
+		if (result == NFC_RESULT_SUCCESS)
+		{
+			return NTAG_RESULT_SUCCESS;
+		}
+
+		switch (result & NFC_RESULT_MASK)
+		{
+		case NFC_RESULT_UNINITIALIZED:
+			return NTAG_RESULT_UNINITIALIZED;
+		case NFC_RESULT_INVALID_STATE:
+			return NTAG_RESULT_INVALID_STATE;
+		case NFC_RESULT_NO_TAG:
+			return NTAG_RESULT_NO_TAG;
+		case NFC_RESULT_UID_MISMATCH:
+			return NTAG_RESULT_UID_MISMATCH;
+		}
+
+		// TODO convert more errors
+		return NTAG_RESULT_INVALID;
+	}
+
+	sint32 NTAGInit(uint32 chan)
+	{
+		return NTAGInitEx(chan);
+	}
+
+	sint32 NTAGInitEx(uint32 chan)
+	{
+		sint32 result = nfc::NFCInitEx(chan, 1);
+		return __NTAGConvertNFCResult(result);
+	}
+
+	sint32 NTAGShutdown(uint32 chan)
+	{
+		sint32 result = nfc::NFCShutdown(chan);
+
+		if (ccrNfcOpened)
+		{
+			coreinit::IOS_Close(gCcrNfcHandle);
+			ccrNfcOpened = false;
+		}
+
+		gDetectCallbacks[chan] = MPTR_NULL;
+		gAbortCallbacks[chan] = MPTR_NULL;
+		gReadCallbacks[chan] = MPTR_NULL;
+		gWriteCallbacks[chan] = MPTR_NULL;
+
+		return __NTAGConvertNFCResult(result);
+	}
+
+	bool NTAGIsInit(uint32 chan)
+	{
+		return nfc::NFCIsInit(chan);
+	}
+
+	void NTAGProc(uint32 chan)
+	{
+		nfc::NFCProc(chan);
+	}
+
+	void NTAGSetFormatSettings(NTAGFormatSettings* formatSettings)
+	{
+		gFormatSettings.version = formatSettings->version;
+		gFormatSettings.makerCode = _swapEndianU32(formatSettings->makerCode);
+		gFormatSettings.identifyCode = _swapEndianU32(formatSettings->identifyCode);
+	}
+
+	void __NTAGDetectCallback(PPCInterpreter_t* hCPU)
+	{
+		ppcDefineParamU32(chan, 0);
+		ppcDefineParamU32(hasTag, 1);
+		ppcDefineParamPtr(context, void, 2);
+
+		cemuLog_log(LogType::NTAG, "__NTAGDetectCallback: {} {} {}", chan, hasTag, context);
+
+		PPCCoreCallback(gDetectCallbacks[chan], chan, hasTag, context);
+
+		osLib_returnFromFunction(hCPU, 0);
+	}
+
+	void NTAGSetTagDetectCallback(uint32 chan, MPTR callback, void* context)
+	{
+		cemu_assert(chan < 2);
+
+		gDetectCallbacks[chan] = callback;
+		nfc::NFCSetTagDetectCallback(chan, RPLLoader_MakePPCCallable(__NTAGDetectCallback), context);
+	}
+
+	void __NTAGAbortCallback(PPCInterpreter_t* hCPU)
+	{
+		ppcDefineParamU32(chan, 0);
+		ppcDefineParamS32(error, 1);
+		ppcDefineParamPtr(context, void, 2);
+
+		PPCCoreCallback(gAbortCallbacks[chan], chan, __NTAGConvertNFCResult(error), context);
+
+		osLib_returnFromFunction(hCPU, 0);
+	}
+
+	sint32 NTAGAbort(uint32 chan, MPTR callback, void* context)
+	{
+		cemu_assert(chan < 2);
+		
+		// TODO is it normal that Rumble U calls this?
+
+		gAbortCallbacks[chan] = callback;
+		sint32 result = nfc::NFCAbort(chan, RPLLoader_MakePPCCallable(__NTAGAbortCallback), context);
+		return __NTAGConvertNFCResult(result);
+	}
+
+	bool __NTAGRawDataToNfcData(iosu::ccr_nfc::CCRNFCCryptData* raw, iosu::ccr_nfc::CCRNFCCryptData* nfc)
+	{  
+		memcpy(nfc, raw, sizeof(iosu::ccr_nfc::CCRNFCCryptData));
+
+		if (raw->version == 0)
+		{
+			nfc->version = 0;
+			nfc->dataSize = 0x1C8;
+			nfc->seedOffset = 0x25;
+			nfc->keyGenSaltOffset = 0x1A8;
+			nfc->uuidOffset = 0x198;
+			nfc->unfixedInfosOffset = 0x28;
+			nfc->unfixedInfosSize = 0x120;
+			nfc->lockedSecretOffset = 0x168;
+			nfc->lockedSecretSize = 0x30;
+			nfc->unfixedInfosHmacOffset = 0;
+			nfc->lockedSecretHmacOffset = 0x148;
+		}
+		else if (raw->version == 2)
+		{
+			nfc->version = 2;
+			nfc->dataSize = 0x208;
+			nfc->seedOffset = 0x29;
+			nfc->keyGenSaltOffset = 0x1E8;
+			nfc->uuidOffset = 0x1D4;
+			nfc->unfixedInfosOffset = 0x2C;
+			nfc->unfixedInfosSize = 0x188;
+			nfc->lockedSecretOffset = 0x1DC;
+			nfc->lockedSecretSize = 0;
+			nfc->unfixedInfosHmacOffset = 0x8;
+			nfc->lockedSecretHmacOffset = 0x1B4;
+
+			memcpy(nfc->data + 0x1d4, raw->data, 0x8);
+			memcpy(nfc->data, raw->data + 0x8, 0x8);
+			memcpy(nfc->data + 0x28, raw->data + 0x10, 0x4);
+			memcpy(nfc->data + nfc->unfixedInfosOffset, raw->data + 0x14, 0x20);
+			memcpy(nfc->data + nfc->lockedSecretHmacOffset, raw->data + 0x34, 0x20);
+			memcpy(nfc->data + nfc->lockedSecretOffset, raw->data + 0x54, 0xC);
+			memcpy(nfc->data + nfc->keyGenSaltOffset, raw->data + 0x60, 0x20);
+			memcpy(nfc->data + nfc->unfixedInfosHmacOffset, raw->data + 0x80, 0x20);
+			memcpy(nfc->data + nfc->unfixedInfosOffset + 0x20, raw->data + 0xa0, 0x168);
+			memcpy(nfc->data + 0x208, raw->data + 0x208, 0x14);
+		}
+		else
+		{
+			return false;
+		}
+
+		return true;
+	}
+
+	bool __NTAGNfcDataToRawData(iosu::ccr_nfc::CCRNFCCryptData* nfc, iosu::ccr_nfc::CCRNFCCryptData* raw)
+	{
+		memcpy(raw, nfc, sizeof(iosu::ccr_nfc::CCRNFCCryptData));
+
+		if (nfc->version == 0)
+		{
+			raw->version = 0;
+			raw->dataSize = 0x1C8;
+			raw->seedOffset = 0x25;
+			raw->keyGenSaltOffset = 0x1A8;
+			raw->uuidOffset = 0x198;
+			raw->unfixedInfosOffset = 0x28;
+			raw->unfixedInfosSize = 0x120;
+			raw->lockedSecretOffset = 0x168;
+			raw->lockedSecretSize = 0x30;
+			raw->unfixedInfosHmacOffset = 0;
+			raw->lockedSecretHmacOffset = 0x148;
+		}
+		else if (nfc->version == 2)
+		{
+			raw->version = 2;
+			raw->dataSize = 0x208;
+			raw->seedOffset = 0x11;
+			raw->keyGenSaltOffset = 0x60;
+			raw->uuidOffset = 0;
+			raw->unfixedInfosOffset = 0x14;
+			raw->unfixedInfosSize = 0x188;
+			raw->lockedSecretOffset = 0x54;
+			raw->lockedSecretSize = 0xC;
+			raw->unfixedInfosHmacOffset = 0x80;
+			raw->lockedSecretHmacOffset = 0x34;
+
+			memcpy(raw->data + 0x8, nfc->data, 0x8);
+			memcpy(raw->data + raw->unfixedInfosHmacOffset, nfc->data + 0x8, 0x20);
+			memcpy(raw->data + 0x10, nfc->data + 0x28, 0x4);
+			memcpy(raw->data + raw->unfixedInfosOffset, nfc->data + 0x2C, 0x20);
+			memcpy(raw->data + 0xa0, nfc->data + 0x4C, 0x168);
+			memcpy(raw->data + raw->lockedSecretHmacOffset, nfc->data + 0x1B4, 0x20);
+			memcpy(raw->data + raw->uuidOffset, nfc->data + 0x1D4, 0x8);
+			memcpy(raw->data + raw->lockedSecretOffset, nfc->data + 0x1DC, 0xC);
+			memcpy(raw->data + raw->keyGenSaltOffset, nfc->data + 0x1E8, 0x20);
+			memcpy(raw->data + 0x208, nfc->data + 0x208, 0x14);
+		}
+		else
+		{
+			return false;
+		}
+
+		return true;
+	}
+
+	sint32 __NTAGDecryptData(void* decryptedData, const void* rawData)
+	{
+		StackAllocator<iosu::ccr_nfc::CCRNFCCryptData> nfcRawData, nfcInData, nfcOutData;
+
+		if (!ccrNfcOpened)
+		{
+			gCcrNfcHandle = coreinit::IOS_Open("/dev/ccr_nfc", 0);
+		}
+
+		// Prepare nfc buffer
+		nfcRawData->version = 0;
+		memcpy(nfcRawData->data, rawData, 0x1C8);
+		__NTAGRawDataToNfcData(nfcRawData.GetPointer(), nfcInData.GetPointer());
+
+		// Decrypt
+		sint32 result = coreinit::IOS_Ioctl(gCcrNfcHandle, 2, nfcInData.GetPointer(), sizeof(iosu::ccr_nfc::CCRNFCCryptData), nfcOutData.GetPointer(), sizeof(iosu::ccr_nfc::CCRNFCCryptData));
+
+		// Unpack nfc buffer
+		__NTAGNfcDataToRawData(nfcOutData.GetPointer(), nfcRawData.GetPointer());
+		memcpy(decryptedData, nfcRawData->data, 0x1C8);
+
+		// Convert result
+		if (result == CCR_NFC_INVALID_UNFIXED_INFOS)
+		{
+			return -0x2708;
+		}
+		else if (result == CCR_NFC_INVALID_LOCKED_SECRET)
+		{
+			return -0x2707;
+		}
+
+		return result;
+	}
+
+	sint32 __NTAGValidateHeaders(NTAGNoftHeader* noftHeader, NTAGInfoHeader* infoHeader, NTAGAreaHeader* rwHeader, NTAGAreaHeader* roHeader)
+	{
+		if (infoHeader->formatVersion != gFormatSettings.version || noftHeader->version != 0x1)
+		{
+			cemuLog_log(LogType::Force, "Invalid format version");
+			return -0x2710;
+		}
+
+		if (_swapEndianU32(noftHeader->magic) != 0x4E4F4654 /* 'NOFT' */ ||
+			_swapEndianU16(rwHeader->magic) != 0x5257 /* 'RW' */ ||
+			_swapEndianU16(roHeader->magic) != 0x524F /* 'RO' */)
+		{
+			cemuLog_log(LogType::Force, "Invalid header magic");
+			return -0x270F;
+		}
+
+		if (_swapEndianU32(rwHeader->makerCode) != gFormatSettings.makerCode ||
+			_swapEndianU32(roHeader->makerCode) != gFormatSettings.makerCode)
+		{
+			cemuLog_log(LogType::Force, "Invalid maker code");
+			return -0x270E;
+		}
+
+		if (infoHeader->formatVersion != 0 &&
+			(_swapEndianU32(rwHeader->identifyCode) != gFormatSettings.identifyCode ||
+			 _swapEndianU32(roHeader->identifyCode) != gFormatSettings.identifyCode))
+		{
+			cemuLog_log(LogType::Force, "Invalid identify code");
+			return -0x2709;
+		}
+
+		if (_swapEndianU16(rwHeader->size) + _swapEndianU16(roHeader->size) != 0x130)
+		{
+			cemuLog_log(LogType::Force, "Invalid data size");
+			return -0x270D;
+		}
+
+		return 0;
+	}
+
+	sint32 __NTAGParseHeaders(const uint8* data, NTAGNoftHeader* noftHeader, NTAGInfoHeader* infoHeader, NTAGAreaHeader* rwHeader, NTAGAreaHeader* roHeader)
+	{
+		memcpy(noftHeader, data + 0x20, sizeof(NTAGNoftHeader));
+		memcpy(infoHeader, data + 0x198, sizeof(NTAGInfoHeader));
+
+		cemu_assert(_swapEndianU16(infoHeader->rwHeaderOffset) + sizeof(NTAGAreaHeader) < 0x200);
+		cemu_assert(_swapEndianU16(infoHeader->roHeaderOffset) + sizeof(NTAGAreaHeader) < 0x200);
+
+		memcpy(rwHeader, data + _swapEndianU16(infoHeader->rwHeaderOffset), sizeof(NTAGAreaHeader));
+		memcpy(roHeader, data + _swapEndianU16(infoHeader->roHeaderOffset), sizeof(NTAGAreaHeader));
+
+		return __NTAGValidateHeaders(noftHeader, infoHeader, rwHeader, roHeader);
+	}
+
+	sint32 __NTAGParseData(void* rawData, void* rwData, void* roData, nfc::NFCUid* uid, uint32 lockedDataSize, NTAGNoftHeader* noftHeader, NTAGInfoHeader* infoHeader, NTAGAreaHeader* rwHeader, NTAGAreaHeader* roHeader)
+	{
+		uint8 decryptedData[0x1C8];
+		sint32 result = __NTAGDecryptData(decryptedData, rawData);
+		if (result < 0)
+		{
+			return result;
+		}
+
+		result = __NTAGParseHeaders(decryptedData, noftHeader, infoHeader, rwHeader, roHeader);
+		if (result < 0)
+		{
+			return result;
+		}
+
+		if (_swapEndianU16(roHeader->size) + 0x70 != lockedDataSize)
+		{
+			cemuLog_log(LogType::Force, "Invalid locked area size");
+			return -0x270C;
+		}
+
+		if (memcmp(infoHeader->uid.uid, uid->uid, sizeof(nfc::NFCUid)) != 0)
+		{
+			cemuLog_log(LogType::Force, "UID mismatch");
+			return -0x270B;
+		}
+
+		cemu_assert(_swapEndianU16(rwHeader->offset) + _swapEndianU16(rwHeader->size) < 0x200);
+		cemu_assert(_swapEndianU16(roHeader->offset) + _swapEndianU16(roHeader->size) < 0x200);
+
+		memcpy(rwData, decryptedData + _swapEndianU16(rwHeader->offset), _swapEndianU16(rwHeader->size));
+		memcpy(roData, decryptedData + _swapEndianU16(roHeader->offset), _swapEndianU16(roHeader->size));
+
+		return 0;
+	}
+
+	void __NTAGReadCallback(PPCInterpreter_t* hCPU)
+	{
+		ppcDefineParamU32(chan, 0);
+		ppcDefineParamS32(error, 1);
+		ppcDefineParamPtr(uid, nfc::NFCUid, 2);
+		ppcDefineParamU32(readOnly, 3);
+		ppcDefineParamU32(dataSize, 4);
+		ppcDefineParamPtr(data, void, 5);
+		ppcDefineParamU32(lockedDataSize, 6);
+		ppcDefineParamPtr(lockedData, void, 7);
+		ppcDefineParamPtr(context, void, 8);
+
+		uint8 rawData[0x1C8]{};
+		StackAllocator<NTAGData> readResult;
+		StackAllocator<uint8, 0x1C8> rwData;
+		StackAllocator<uint8, 0x1C8> roData;
+		NTAGNoftHeader noftHeader;
+		NTAGInfoHeader infoHeader;
+		NTAGAreaHeader rwHeader;
+		NTAGAreaHeader roHeader;
+
+		readResult->readOnly = readOnly;
+
+		error = __NTAGConvertNFCResult(error);
+		if (error == 0)
+		{
+			memset(rwData.GetPointer(), 0, 0x1C8);
+			memset(roData.GetPointer(), 0, 0x1C8);
+
+			// Copy raw and locked data into a contigous buffer
+			memcpy(rawData, data, dataSize);
+			memcpy(rawData + dataSize, lockedData, lockedDataSize);
+
+			error = __NTAGParseData(rawData, rwData.GetPointer(), roData.GetPointer(), uid, lockedDataSize, &noftHeader, &infoHeader, &rwHeader, &roHeader);
+			if (error == 0)
+			{
+				memcpy(readResult->uid.uid, uid->uid, sizeof(uid->uid));
+				readResult->rwInfo.data = _swapEndianU32(rwData.GetMPTR());
+				readResult->roInfo.data = _swapEndianU32(roData.GetMPTR());
+				readResult->rwInfo.makerCode = rwHeader.makerCode;
+				readResult->rwInfo.size = rwHeader.size;
+				readResult->roInfo.makerCode = roHeader.makerCode;
+				readResult->rwInfo.identifyCode = rwHeader.identifyCode;
+				readResult->roInfo.identifyCode = roHeader.identifyCode;
+				readResult->formatVersion = infoHeader.formatVersion;
+				readResult->roInfo.size = roHeader.size;
+
+				cemuLog_log(LogType::NTAG, "__NTAGReadCallback: {} {} {}", chan, error, context);
+
+				PPCCoreCallback(gReadCallbacks[chan], chan, 0, readResult.GetPointer(), context);
+				osLib_returnFromFunction(hCPU, 0);
+				return;
+			}
+		}
+
+		if (uid)
+		{
+			memcpy(readResult->uid.uid, uid->uid, sizeof(uid->uid));
+		}
+		readResult->roInfo.size = 0;
+		readResult->rwInfo.size = 0;
+		readResult->roInfo.data = MPTR_NULL;
+		readResult->formatVersion = 0;
+		readResult->rwInfo.data = MPTR_NULL;
+		cemuLog_log(LogType::NTAG, "__NTAGReadCallback: {} {} {}", chan, error, context);
+		PPCCoreCallback(gReadCallbacks[chan], chan, error, readResult.GetPointer(), context);
+		osLib_returnFromFunction(hCPU, 0);
+	}
+
+	sint32 NTAGRead(uint32 chan, uint32 timeout, nfc::NFCUid* uid, nfc::NFCUid* uidMask, MPTR callback, void* context)
+	{
+		cemu_assert(chan < 2);
+
+		gReadCallbacks[chan] = callback;
+
+		nfc::NFCUid _uid{}, _uidMask{};
+		if (uid && uidMask)
+		{
+			memcpy(&_uid, uid, sizeof(*uid));
+			memcpy(&_uidMask, uidMask, sizeof(*uidMask));
+		}
+
+		sint32 result = nfc::NFCRead(chan, timeout, &_uid, &_uidMask, RPLLoader_MakePPCCallable(__NTAGReadCallback), context);
+		return __NTAGConvertNFCResult(result);
+	}
+
+	sint32 __NTAGEncryptData(void* encryptedData, const void* rawData)
+	{
+		StackAllocator<iosu::ccr_nfc::CCRNFCCryptData> nfcRawData, nfcInData, nfcOutData;
+
+		if (!ccrNfcOpened)
+		{
+			gCcrNfcHandle = coreinit::IOS_Open("/dev/ccr_nfc", 0);
+		}
+
+		// Prepare nfc buffer
+		nfcRawData->version = 0;
+		memcpy(nfcRawData->data, rawData, 0x1C8);
+		__NTAGRawDataToNfcData(nfcRawData.GetPointer(), nfcInData.GetPointer());
+
+		// Encrypt
+		sint32 result = coreinit::IOS_Ioctl(gCcrNfcHandle, 1, nfcInData.GetPointer(), sizeof(iosu::ccr_nfc::CCRNFCCryptData), nfcOutData.GetPointer(), sizeof(iosu::ccr_nfc::CCRNFCCryptData));
+
+		// Unpack nfc buffer
+		__NTAGNfcDataToRawData(nfcOutData.GetPointer(), nfcRawData.GetPointer());
+		memcpy(encryptedData, nfcRawData->data, 0x1C8);
+
+		return result;
+	}
+
+	sint32 __NTAGPrepareWriteData(void* outBuffer, uint32 dataSize, const void* data, const void* tagData, NTAGNoftHeader* noftHeader, NTAGAreaHeader* rwHeader)
+	{
+		uint8 decryptedBuffer[0x1C8];
+		uint8 encryptedBuffer[0x1C8];
+
+		memcpy(decryptedBuffer, tagData, 0x1C8);
+
+		// Fill the rest of the rw area with random data
+		if (dataSize < _swapEndianU16(rwHeader->size))
+		{
+			uint8 randomBuffer[0x1C8];
+			for (int i = 0; i < sizeof(randomBuffer); i++)
+			{
+				randomBuffer[i] = rand() & 0xFF;
+			}
+
+			memcpy(decryptedBuffer + _swapEndianU16(rwHeader->offset) + dataSize, randomBuffer, _swapEndianU16(rwHeader->size) - dataSize);
+		}
+		
+		// Make sure the data fits into the rw area
+		if (_swapEndianU16(rwHeader->size) < dataSize)
+		{
+			return -0x270D;
+		}
+
+		// Update write count (check for overflow)
+		if ((_swapEndianU16(noftHeader->writeCount) & 0x7fff) == 0x7fff)
+		{
+			noftHeader->writeCount = _swapEndianU16(_swapEndianU16(noftHeader->writeCount) & 0x8000);
+		}
+		else
+		{
+			noftHeader->writeCount = _swapEndianU16(_swapEndianU16(noftHeader->writeCount) + 1);
+		}
+
+		memcpy(decryptedBuffer + 0x20, noftHeader, sizeof(NTAGNoftHeader));
+		memcpy(decryptedBuffer + _swapEndianU16(rwHeader->offset), data, dataSize);
+
+		// Encrypt
+		sint32 result = __NTAGEncryptData(encryptedBuffer, decryptedBuffer);
+		if (result < 0)
+		{
+			return result;
+		}
+
+		memcpy(outBuffer, encryptedBuffer, _swapEndianU16(rwHeader->size) + 0x28);
+		return 0;
+	}
+
+	void __NTAGWriteCallback(PPCInterpreter_t* hCPU)
+	{
+		ppcDefineParamU32(chan, 0);
+		ppcDefineParamS32(error, 1);
+		ppcDefineParamPtr(context, void, 2);
+
+		PPCCoreCallback(gWriteCallbacks[chan], chan, __NTAGConvertNFCResult(error), context);
+
+		osLib_returnFromFunction(hCPU, 0);
+	}
+
+	void __NTAGReadBeforeWriteCallback(PPCInterpreter_t* hCPU)
+	{
+		ppcDefineParamU32(chan, 0);
+		ppcDefineParamS32(error, 1);
+		ppcDefineParamPtr(uid, nfc::NFCUid, 2);
+		ppcDefineParamU32(readOnly, 3);
+		ppcDefineParamU32(dataSize, 4);
+		ppcDefineParamPtr(data, void, 5);
+		ppcDefineParamU32(lockedDataSize, 6);
+		ppcDefineParamPtr(lockedData, void, 7);
+		ppcDefineParamPtr(context, void, 8);
+
+		uint8 rawData[0x1C8]{};
+		uint8 rwData[0x1C8]{};
+		uint8 roData[0x1C8]{};
+		NTAGNoftHeader noftHeader;
+		NTAGInfoHeader infoHeader;
+		NTAGAreaHeader rwHeader;
+		NTAGAreaHeader roHeader;
+		uint8 writeBuffer[0x1C8]{};
+
+		error = __NTAGConvertNFCResult(error);
+		if (error == 0)
+		{
+			// Copy raw and locked data into a contigous buffer
+			memcpy(rawData, data, dataSize);
+			memcpy(rawData + dataSize, lockedData, lockedDataSize);
+
+			error = __NTAGParseData(rawData, rwData, roData, uid, lockedDataSize, &noftHeader, &infoHeader, &rwHeader, &roHeader);
+			if (error < 0)
+			{
+				cemuLog_log(LogType::Force, "Failed to parse data before write");
+				PPCCoreCallback(gWriteCallbacks[chan], chan, -0x3E3, context);
+				osLib_returnFromFunction(hCPU, 0);
+				return;
+			}
+
+			// Prepare data
+			memcpy(rawData + _swapEndianU16(infoHeader.rwHeaderOffset), &rwHeader, sizeof(rwHeader));
+			memcpy(rawData + _swapEndianU16(infoHeader.roHeaderOffset), &roHeader, sizeof(roHeader));
+			memcpy(rawData + _swapEndianU16(roHeader.offset), roData, _swapEndianU16(roHeader.size));
+			error = __NTAGPrepareWriteData(writeBuffer, gWriteData[chan].size, gWriteData[chan].data, rawData, &noftHeader, &rwHeader);
+			if (error < 0)
+			{
+				cemuLog_log(LogType::Force, "Failed to prepare write data");
+				PPCCoreCallback(gWriteCallbacks[chan], chan, -0x3E3, context);
+				osLib_returnFromFunction(hCPU, 0);
+				return;
+			}
+
+			// Write data to tag
+			error = nfc::NFCWrite(chan, 200, &gWriteData[chan].uid, &gWriteData[chan].uidMask,
+				_swapEndianU16(rwHeader.size) + 0x28, writeBuffer, RPLLoader_MakePPCCallable(__NTAGWriteCallback), context);
+			if (error >= 0)
+			{
+				osLib_returnFromFunction(hCPU, 0);
+				return;
+			}
+
+			error = __NTAGConvertNFCResult(error);
+		}
+
+		PPCCoreCallback(gWriteCallbacks[chan], chan, error, context);
+		osLib_returnFromFunction(hCPU, 0);
+	}
+
+	sint32 NTAGWrite(uint32 chan, uint32 timeout, nfc::NFCUid* uid, uint32 rwSize, void* rwData, MPTR callback, void* context)
+	{
+		cemu_assert(chan < 2);
+		cemu_assert(rwSize < 0x1C8);
+
+		gWriteCallbacks[chan] = callback;
+
+		if (uid)
+		{
+			memcpy(&gWriteData[chan].uid, uid, sizeof(nfc::NFCUid));
+		}
+		memset(&gWriteData[chan].uidMask, 0xff, sizeof(nfc::NFCUid));
+
+		gWriteData[chan].size = rwSize;
+		memcpy(gWriteData[chan].data, rwData, rwSize);
+
+		sint32 result = nfc::NFCRead(chan, timeout, &gWriteData[chan].uid, &gWriteData[chan].uidMask, RPLLoader_MakePPCCallable(__NTAGReadBeforeWriteCallback), context);
+		return __NTAGConvertNFCResult(result);
+	}
+
+	sint32 NTAGFormat(uint32 chan, uint32 timeout, nfc::NFCUid* uid, uint32 rwSize, void* rwData, MPTR callback, void* context)
+	{
+		cemu_assert(chan < 2);
+
+		// TODO
+		cemu_assert_debug(false);
+
+		return NTAG_RESULT_INVALID;
+	}
+
+	void Initialize()
+	{
+		cafeExportRegister("ntag", NTAGInit, LogType::NTAG);
+		cafeExportRegister("ntag", NTAGInitEx, LogType::NTAG);
+		cafeExportRegister("ntag", NTAGShutdown, LogType::NTAG);
+		cafeExportRegister("ntag", NTAGIsInit, LogType::Placeholder); // disabled logging, since this gets spammed
+		cafeExportRegister("ntag", NTAGProc, LogType::Placeholder); // disabled logging, since this gets spammed
+		cafeExportRegister("ntag", NTAGSetFormatSettings, LogType::NTAG);
+		cafeExportRegister("ntag", NTAGSetTagDetectCallback, LogType::NTAG);
+		cafeExportRegister("ntag", NTAGAbort, LogType::NTAG);
+		cafeExportRegister("ntag", NTAGRead, LogType::NTAG);
+		cafeExportRegister("ntag", NTAGWrite, LogType::NTAG);
+		cafeExportRegister("ntag", NTAGFormat, LogType::NTAG);
+	}
+}
diff --git a/src/Cafe/OS/libs/ntag/ntag.h b/src/Cafe/OS/libs/ntag/ntag.h
new file mode 100644
index 00000000..68f1801b
--- /dev/null
+++ b/src/Cafe/OS/libs/ntag/ntag.h
@@ -0,0 +1,101 @@
+#pragma once
+#include "Cafe/OS/libs/nfc/nfc.h"
+
+#define NTAG_RESULT_SUCCESS		(0)
+#define NTAG_RESULT_UNINITIALIZED	(-0x3E7)
+#define NTAG_RESULT_INVALID_STATE	(-0x3E6)
+#define NTAG_RESULT_NO_TAG		(-0x3E5)
+#define NTAG_RESULT_INVALID		(-0x3E1)
+#define NTAG_RESULT_UID_MISMATCH	(-0x3DB)
+
+namespace ntag
+{
+	struct NTAGFormatSettings
+	{
+		/* +0x00 */ uint8 version;
+		/* +0x04 */ uint32 makerCode;
+		/* +0x08 */ uint32 identifyCode;
+		/* +0x0C */ uint8 reserved[0x1C];
+	};
+	static_assert(sizeof(NTAGFormatSettings) == 0x28);
+
+#pragma pack(1)
+	struct NTAGNoftHeader
+	{
+		/* +0x00 */ uint32 magic;
+		/* +0x04 */ uint8 version;
+		/* +0x05 */ uint16 writeCount;
+		/* +0x07 */ uint8 unknown;
+	};
+	static_assert(sizeof(NTAGNoftHeader) == 0x8);
+#pragma pack()
+
+	struct NTAGInfoHeader
+	{
+		/* +0x00 */ uint16 rwHeaderOffset;
+		/* +0x02 */ uint16 rwSize;
+		/* +0x04 */ uint16 roHeaderOffset;
+		/* +0x06 */ uint16 roSize;
+		/* +0x08 */ nfc::NFCUid uid;
+		/* +0x0F */ uint8 formatVersion;
+	};
+	static_assert(sizeof(NTAGInfoHeader) == 0x10);
+
+	struct NTAGAreaHeader
+	{
+		/* +0x00 */ uint16 magic;
+		/* +0x02 */ uint16 offset;
+		/* +0x04 */ uint16 size;
+		/* +0x06 */ uint16 padding;
+		/* +0x08 */ uint32 makerCode;
+		/* +0x0C */ uint32 identifyCode;
+	};
+	static_assert(sizeof(NTAGAreaHeader) == 0x10);
+
+	struct NTAGAreaInfo
+	{
+		/* +0x00 */ MPTR data;
+		/* +0x04 */ uint16 size;
+		/* +0x06 */ uint16 padding;
+		/* +0x08 */ uint32 makerCode;
+		/* +0x0C */ uint32 identifyCode;
+		/* +0x10 */ uint8 reserved[0x20];
+	};
+	static_assert(sizeof(NTAGAreaInfo) == 0x30);
+
+	struct NTAGData
+	{
+		/* +0x00 */ nfc::NFCUid uid;
+		/* +0x07 */ uint8 readOnly;
+		/* +0x08 */ uint8 formatVersion;
+		/* +0x09 */ uint8 padding[3];
+		/* +0x0C */ NTAGAreaInfo rwInfo;
+		/* +0x3C */ NTAGAreaInfo roInfo;
+		/* +0x6C */ uint8 reserved[0x20];
+	};
+	static_assert(sizeof(NTAGData) == 0x8C);
+
+	sint32 NTAGInit(uint32 chan);
+
+	sint32 NTAGInitEx(uint32 chan);
+
+	sint32 NTAGShutdown(uint32 chan);
+
+	bool NTAGIsInit(uint32 chan);
+
+	void NTAGProc(uint32 chan);
+
+	void NTAGSetFormatSettings(NTAGFormatSettings* formatSettings);
+
+	void NTAGSetTagDetectCallback(uint32 chan, MPTR callback, void* context);
+
+	sint32 NTAGAbort(uint32 chan, MPTR callback, void* context);
+
+	sint32 NTAGRead(uint32 chan, uint32 timeout, nfc::NFCUid* uid, nfc::NFCUid* uidMask, MPTR callback, void* context);
+
+	sint32 NTAGWrite(uint32 chan, uint32 timeout, nfc::NFCUid* uid, uint32 rwSize, void* rwData, MPTR callback, void* context);
+
+	sint32 NTAGFormat(uint32 chan, uint32 timeout, nfc::NFCUid* uid, uint32 rwSize, void* rwData, MPTR callback, void* context);
+
+	void Initialize();
+}
diff --git a/src/Cafe/OS/libs/padscore/padscore.cpp b/src/Cafe/OS/libs/padscore/padscore.cpp
index d14ad04b..2f359748 100644
--- a/src/Cafe/OS/libs/padscore/padscore.cpp
+++ b/src/Cafe/OS/libs/padscore/padscore.cpp
@@ -12,6 +12,7 @@
 enum class KPAD_ERROR : sint32
 {
 	NONE = 0,
+	NO_SAMPLE_DATA = -1,
 	NO_CONTROLLER = -2,
 	NOT_INITIALIZED = -5,
 };
@@ -54,7 +55,7 @@ namespace padscore
 	WPADState_t g_wpad_state = kWPADStateMaster;
 
 	struct {
-		coreinit::OSAlarm_t alarm;
+		SysAllocator<coreinit::OSAlarm_t> alarm;
 		bool kpad_initialized = false;
 
 		struct WPADData
@@ -79,14 +80,14 @@ namespace padscore
 
 void padscoreExport_WPADGetStatus(PPCInterpreter_t* hCPU)
 {
-	inputLog_printf("WPADGetStatus()");
+	cemuLog_log(LogType::InputAPI, "WPADGetStatus()");
 	uint32 status = 1;
 	osLib_returnFromFunction(hCPU, status);
 }
 
 void padscoreExport_WPADGetBatteryLevel(PPCInterpreter_t* hCPU)
 {
-	inputLog_printf("WPADGetBatteryLevel()");
+	cemuLog_log(LogType::InputAPI, "WPADGetBatteryLevel()");
 	osLib_returnFromFunction(hCPU, (uint32)WPADBatteryLevel::FULL);
 }
 
@@ -95,7 +96,7 @@ void padscoreExport_WPADProbe(PPCInterpreter_t* hCPU)
 	ppcDefineParamU32(channel, 0);
 	ppcDefineParamPtr(type, uint32be, 1);
 
-	inputLog_printf("WPADProbe(%d)", channel);
+	cemuLog_log(LogType::InputAPI, "WPADProbe({})", channel);
 
 	if(const auto controller = InputManager::instance().get_wpad_controller(channel))
 	{
@@ -106,6 +107,9 @@ void padscoreExport_WPADProbe(PPCInterpreter_t* hCPU)
 	}
 	else
 	{
+		if(type)
+			*type = 253;
+
 		osLib_returnFromFunction(hCPU, WPAD_ERR_NO_CONTROLLER);
 	}
 }
@@ -130,7 +134,7 @@ void padscoreExport_WPADGetInfoAsync(PPCInterpreter_t* hCPU)
 	ppcDefineParamU32(channel, 0);
 	ppcDefineParamStructPtr(wpadInfo, WPADInfo_t, 1);
 	ppcDefineParamMPTR(callbackFunc, 2);
-	inputLog_printf("WPADGetInfoAsync(%d, 0x%08x, 0x%08x)", channel, wpadInfo, callbackFunc);
+	cemuLog_log(LogType::InputAPI, "WPADGetInfoAsync({}, 0x{:08x}, 0x{:08x})", channel, fmt::ptr(wpadInfo), callbackFunc);
 
 	if (channel < InputManager::kMaxWPADControllers)
 	{
@@ -166,7 +170,7 @@ void padscoreExport_WPADRead(PPCInterpreter_t* hCPU)
 {
 	ppcDefineParamU32(channel, 0);
 	ppcDefineParamPtr(wpadStatus, WPADStatus_t, 1);
-	inputLog_printf("WPADRead(%d, %llx)", channel, wpadStatus);
+	cemuLog_log(LogType::InputAPI, "WPADRead({}, {:x})", channel, fmt::ptr(wpadStatus));
 
 	if (channel < InputManager::kMaxWPADControllers)
 	{
@@ -186,7 +190,7 @@ void padscoreExport_WPADSetDataFormat(PPCInterpreter_t* hCPU)
 {
 	ppcDefineParamU32(channel, 0);
 	ppcDefineParamU32(fmt, 1);
-	inputLog_printf("WPADSetDataFormat(%d, %d)", channel, fmt);
+	cemuLog_log(LogType::InputAPI, "WPADSetDataFormat({}, {})", channel, fmt);
 
 	if (channel < InputManager::kMaxWPADControllers)
 	{
@@ -200,7 +204,7 @@ void padscoreExport_WPADSetDataFormat(PPCInterpreter_t* hCPU)
 void padscoreExport_WPADGetDataFormat(PPCInterpreter_t* hCPU)
 {
 	ppcDefineParamU32(channel, 0);
-	inputLog_printf("WPADGetDataFormat(%d)", channel);
+	cemuLog_log(LogType::InputAPI, "WPADGetDataFormat({})", channel);
 
 	sint32 dataFormat = kDataFormat_CORE;
 	if (channel < InputManager::kMaxWPADControllers)
@@ -220,7 +224,7 @@ void padscoreExport_WPADGetInfo(PPCInterpreter_t* hCPU)
 {
 	ppcDefineParamU32(channel, 0);
 	ppcDefineParamStructPtr(wpadInfo, WPADInfo_t, 1);
-	inputLog_printf("WPADGetInfo(%d, 0x%08x)", channel, wpadInfo);
+	cemuLog_log(LogType::InputAPI, "WPADGetInfo({}, 0x{:08x})", channel, fmt::ptr(wpadInfo));
 
 	if (channel < InputManager::kMaxWPADControllers)
 	{
@@ -249,7 +253,7 @@ void padscoreExport_WPADGetInfo(PPCInterpreter_t* hCPU)
 
 void padscoreExport_WPADIsMotorEnabled(PPCInterpreter_t* hCPU)
 {
-	inputLog_printf("WPADIsMotorEnabled()");
+	cemuLog_log(LogType::InputAPI, "WPADIsMotorEnabled()");
 	osLib_returnFromFunction(hCPU, TRUE);
 }
 
@@ -257,7 +261,7 @@ void padscoreExport_WPADControlMotor(PPCInterpreter_t* hCPU)
 {
 	ppcDefineParamU32(channel, 0);
 	ppcDefineParamU32(command, 1);
-	inputLog_printf("WPADControlMotor(%d, %d)", channel, command);
+	cemuLog_log(LogType::InputAPI, "WPADControlMotor({}, {})", channel, command);
 	
 	if (channel < InputManager::kMaxWPADControllers)
 	{
@@ -287,7 +291,7 @@ void padscoreExport_KPADGetUnifiedWpadStatus(PPCInterpreter_t* hCPU)
 	ppcDefineParamPtr(status, KPADUnifiedWpadStatus_t, 1);
 	ppcDefineParamU32(count, 2);
 
-	inputLog_printf("KPADGetUnifiedWpadStatus(%d, 0x%llx, 0x%x)", channel, status, count);
+	cemuLog_log(LogType::InputAPI, "KPADGetUnifiedWpadStatus({}, 0x{:08x}, 0x{:x})", channel, MEMPTR<void>(status).GetMPTR(), count);
 
 	if (channel < InputManager::kMaxWPADControllers)
 	{
@@ -327,7 +331,7 @@ void padscoreExport_KPADSetBtnRepeat(PPCInterpreter_t* hCPU)
 	ppcDefineParamU32(channel, 0);
 	float delaySec = hCPU->fpr[1].fpr;
 	float pulseSec = hCPU->fpr[2].fpr;
-	inputLog_printf("KPADSetBtnRepeat(%d, %f, %f)", channel, delaySec, pulseSec);
+	cemuLog_log(LogType::InputAPI, "KPADSetBtnRepeat({}, {}, {})", channel, delaySec, pulseSec);
 
 	if (channel < InputManager::kMaxWPADControllers)
 	{
@@ -342,7 +346,7 @@ void padscoreExport_KPADSetSamplingCallback(PPCInterpreter_t* hCPU)
 	ppcDefineParamU32(channel, 0);
 	ppcDefineParamMPTR(callback, 1);
 
-	inputLog_printf("KPADSetSamplingCallback(%d, 0x%x)", channel, callback);
+	cemuLog_log(LogType::InputAPI, "KPADSetSamplingCallback({}, 0x{:x})", channel, callback);
 
 	if (channel >= InputManager::kMaxWPADControllers)
 	{
@@ -362,7 +366,7 @@ void padscoreExport_WPADControlDpd(PPCInterpreter_t* hCPU)
 	ppcDefineParamU32(command, 1);
 	ppcDefineParamMPTR(callback, 2);
 
-	inputLog_printf("WPADControlDpd(%d, %d, 0x%x)", channel, command, callback);
+	cemuLog_log(LogType::InputAPI, "WPADControlDpd({}, {}, 0x{:x})", channel, command, callback);
 
 	if (channel < InputManager::kMaxWPADControllers)
 	{
@@ -387,7 +391,7 @@ void padscoreExport_WPADSetExtensionCallback(PPCInterpreter_t* hCPU)
 	ppcDefineParamU32(channel, 0);
 	ppcDefineParamMPTR(callback, 1);
 
-	inputLog_printf("WPADSetExtensionCallback(%d, 0x%x)", channel, callback);
+	cemuLog_log(LogType::InputAPI, "WPADSetExtensionCallback({}, 0x{:x})", channel, callback);
 
 	if (channel >= InputManager::kMaxWPADControllers)
 	{
@@ -406,7 +410,7 @@ void padscoreExport_KPADSetConnectCallback(PPCInterpreter_t* hCPU)
 	ppcDefineParamU32(channel, 0);
 	ppcDefineParamMPTR(callback, 1);
 
-	inputLog_printf("KPADSetConnectCallback(%d, 0x%x)",channel, callback);
+	cemuLog_log(LogType::InputAPI, "KPADSetConnectCallback({}, 0x{:x})",channel, callback);
 
 	if (channel >= InputManager::kMaxWPADControllers)
 	{
@@ -420,9 +424,12 @@ void padscoreExport_KPADSetConnectCallback(PPCInterpreter_t* hCPU)
 	osLib_returnFromFunction(hCPU, old_callback.GetMPTR());
 }
 
+uint64 g_kpadLastRead[InputManager::kMaxWPADControllers] = {0};
 bool g_kpadIsInited = true;
+
 sint32 _KPADRead(uint32 channel, KPADStatus_t* samplingBufs, uint32 length, betype<KPAD_ERROR>* errResult)
 {
+
 	if (channel >= InputManager::kMaxWPADControllers)
 	{
 		debugBreakpoint();
@@ -446,6 +453,19 @@ sint32 _KPADRead(uint32 channel, KPADStatus_t* samplingBufs, uint32 length, bety
 		return 0;
 	}
 
+	// On console new input samples are only received every few ms and calling KPADRead(Ex) clears the internal queue regardless of length value
+	// thus calling KPADRead(Ex) again too soon on the same channel will result in no data being returned
+	// Games that depend on this: Affordable Space Adventures
+	uint64 currentTime = coreinit::OSGetTime();
+	uint64 timeDif = currentTime - g_kpadLastRead[channel];
+	if(length == 0 || timeDif < coreinit::EspressoTime::ConvertNsToTimerTicks(1000000))
+	{
+		if (errResult)
+			*errResult = KPAD_ERROR::NO_SAMPLE_DATA;
+		return 0;
+	}
+	g_kpadLastRead[channel] = currentTime;
+
 	memset(samplingBufs, 0x00, sizeof(KPADStatus_t));
 	samplingBufs->wpadErr = WPAD_ERR_NONE;
 	samplingBufs->data_format = controller->get_data_format();
@@ -468,19 +488,18 @@ void padscoreExport_KPADReadEx(PPCInterpreter_t* hCPU)
 	ppcDefineParamPtr(kpadStatus, KPADStatus_t, 1);
 	ppcDefineParamU32(length, 2);
 	ppcDefineParamPtr(errResult, betype<KPAD_ERROR>, 3);
-	inputLog_printf("KPADReadEx(%d, 0x%x)", channel, length);
+	cemuLog_log(LogType::InputAPI, "KPADReadEx({}, 0x{:x})", channel, length);
 
 	sint32 samplesRead = _KPADRead(channel, kpadStatus, length, errResult);
 	osLib_returnFromFunction(hCPU, samplesRead);
 }
 
-bool debugUseDRC1 = true;
 void padscoreExport_KPADRead(PPCInterpreter_t* hCPU)
 {
 	ppcDefineParamU32(channel, 0);
 	ppcDefineParamPtr(kpadStatus, KPADStatus_t, 1);
 	ppcDefineParamU32(length, 2);
-	inputLog_printf("KPADRead(%d, 0x%x)", channel, length);
+	cemuLog_log(LogType::InputAPI, "KPADRead({}, 0x{:x})", channel, length);
 
 	sint32 samplesRead = _KPADRead(channel, kpadStatus, length, nullptr);
 	osLib_returnFromFunction(hCPU, samplesRead);
@@ -500,7 +519,7 @@ namespace padscore
 	void export_KPADEnableDPD(PPCInterpreter_t* hCPU)
 	{
 		ppcDefineParamS32(channel, 0);
-		inputLog_printf("KPADEnableDPD(%d)", channel);
+		cemuLog_log(LogType::InputAPI, "KPADEnableDPD({})", channel);
 		cemu_assert_debug(0 <= channel && channel < InputManager::kMaxWPADControllers);
 
 		if(const auto controller = InputManager::instance().get_wpad_controller(channel))
@@ -515,7 +534,7 @@ namespace padscore
 
 	void export_KPADGetMplsWorkSize(PPCInterpreter_t* hCPU)
 	{
-		inputLog_printf("KPADGetMplsWorkSize()");
+		cemuLog_log(LogType::InputAPI, "KPADGetMplsWorkSize()");
 		osLib_returnFromFunction(hCPU, 0x5FE0);
 	}
 
@@ -538,7 +557,7 @@ namespace padscore
 
 	void export_KPADInit(PPCInterpreter_t* hCPU)
 	{
-		inputLog_printf("KPADInit()");
+		cemuLog_log(LogType::InputAPI, "KPADInit()");
 		KPADInitEx(nullptr, 0);
 		osLib_returnFromFunction(hCPU, 0);
 	}
@@ -547,7 +566,7 @@ namespace padscore
 	{
 		ppcDefineParamMEMPTR(ring_buffer, KPADUnifiedWpadStatus_t, 0);
 		ppcDefineParamU32(length, 1);
-		inputLog_printf("KPADInitEx(0x%08x, 0x%x)", ring_buffer.GetMPTR(), length);
+		cemuLog_log(LogType::InputAPI, "KPADInitEx(0x{:08x}, 0x{:x})", ring_buffer.GetMPTR(), length);
 		KPADInitEx(ring_buffer.GetPtr(), length);
 		osLib_returnFromFunction(hCPU, 0);
 	}
@@ -560,14 +579,14 @@ namespace padscore
 	void export_WPADSetCallbackByKPAD(PPCInterpreter_t* hCPU)
 	{
 		ppcDefineParamU32(state, 0);
-		inputLog_printf("WPADSetCallbackByKPAD(%d)", state);
+		cemuLog_log(LogType::InputAPI, "WPADSetCallbackByKPAD({})", state);
 		WPADSetCallbackByKPAD(state);
 		osLib_returnFromFunction(hCPU, 0);
 	}
 
 	void export_KPADGetMaxControllers(PPCInterpreter_t* hCPU)
 	{
-		inputLog_printf("KPADGetMaxControllers()");
+		cemuLog_log(LogType::InputAPI, "KPADGetMaxControllers()");
 		sint32 max_controllers = g_padscore.max_controllers;
 		osLib_returnFromFunction(hCPU, max_controllers);
 	}
@@ -589,7 +608,7 @@ namespace padscore
 	void export_KPADSetMaxControllers(PPCInterpreter_t* hCPU)
 	{
 		ppcDefineParamU32(new_max_count, 0);
-		inputLog_printf("KPADSetMaxControllers(%d)", new_max_count);
+		cemuLog_log(LogType::InputAPI, "KPADSetMaxControllers({})", new_max_count);
 
 		if (new_max_count != kKPADMaxControllers && new_max_count != kWPADMaxControllers)
 		{
@@ -681,7 +700,7 @@ namespace padscore
 				if(!g_padscore.controller_data[i].disconnectCalled)
 				{
 					g_padscore.controller_data[i].disconnectCalled = true;
-					inputLog_printf("Calling WPADConnectCallback(%d, %d)", i, WPAD_ERR_NO_CONTROLLER);
+					cemuLog_log(LogType::InputAPI, "Calling WPADConnectCallback({}, {})", i, WPAD_ERR_NO_CONTROLLER);
 					PPCCoreCallback(g_padscore.controller_data[i].connectCallback, i, WPAD_ERR_NO_CONTROLLER);
 					continue;
 				}
@@ -692,14 +711,14 @@ namespace padscore
 					{
 						controller->m_status = WPADController::ConnectCallbackStatus::ReportConnect;
 
-						inputLog_printf("Calling WPADConnectCallback(%d, %d)", i, WPAD_ERR_NO_CONTROLLER);
+						cemuLog_log(LogType::InputAPI, "Calling WPADConnectCallback({}, {})", i, WPAD_ERR_NO_CONTROLLER);
 						PPCCoreCallback(g_padscore.controller_data[i].connectCallback, i, WPAD_ERR_NO_CONTROLLER);
 						
 					}
 					else if (controller->m_status == WPADController::ConnectCallbackStatus::ReportConnect) 
 					{
 						controller->m_status = WPADController::ConnectCallbackStatus::None;
-						inputLog_printf("Calling WPADConnectCallback(%d, %d)", i, WPAD_ERR_NONE);
+						cemuLog_log(LogType::InputAPI, "Calling WPADConnectCallback({}, {})", i, WPAD_ERR_NONE);
 						PPCCoreCallback(g_padscore.controller_data[i].connectCallback, i, WPAD_ERR_NONE);
 					}
 				}
@@ -716,7 +735,7 @@ namespace padscore
 					if (controller->m_extension_status == WPADController::ConnectCallbackStatus::ReportConnect)
 					{
 						controller->m_extension_status = WPADController::ConnectCallbackStatus::None;
-						inputLog_printf("Calling WPADextensionCallback(%d)", i);
+						cemuLog_log(LogType::InputAPI, "Calling WPADextensionCallback({})", i);
 						PPCCoreCallback(g_padscore.controller_data[i].extension_callback, i, controller->get_device_type());
 					}
 				}
@@ -726,10 +745,11 @@ namespace padscore
 		// call sampling callback
 		for (auto i = 0; i < InputManager::kMaxWPADControllers; ++i)
 		{
-			if (g_padscore.controller_data[i].sampling_callback) {
+			if (g_padscore.controller_data[i].sampling_callback)
+			{
 				if (const auto controller = instance.get_wpad_controller(i))
 				{
-					inputLog_printf("Calling WPADsamplingCallback(%d)", i);
+					cemuLog_log(LogType::InputAPI, "Calling WPADsamplingCallback({})", i);
 					PPCCoreCallback(g_padscore.controller_data[i].sampling_callback, i);
 				}
 			}
@@ -740,16 +760,16 @@ namespace padscore
 	void start()
 	{
 		OSCreateAlarm(&g_padscore.alarm);
-		const uint64 start_tick = coreinit::coreinit_getOSTime();
-		const uint64 period_tick = coreinit::EspressoTime::GetTimerClock(); // once a second
+		const uint64 start_tick = coreinit::OSGetTime();
+		const uint64 period_tick = coreinit::EspressoTime::GetTimerClock() / 200; // every 5ms
 		MPTR handler = PPCInterpreter_makeCallableExportDepr(TickFunction);
 		OSSetPeriodicAlarm(&g_padscore.alarm, start_tick, period_tick, handler);
 	}
 
 	void load()
 	{
-		cafeExportRegister("padscore", WPADIsMplsAttached, LogType::Input);
-		cafeExportRegister("padscore", WPADGetAccGravityUnit, LogType::Input);
+		cafeExportRegister("padscore", WPADIsMplsAttached, LogType::InputAPI);
+		cafeExportRegister("padscore", WPADGetAccGravityUnit, LogType::InputAPI);
 
 		// wpad
 		//osLib_addFunction("padscore", "WPADInit", padscore::export_WPADInit);
@@ -787,4 +807,4 @@ namespace padscore
 		osLib_addFunction("padscore", "WPADSetCallbackByKPAD", padscore::export_WPADSetCallbackByKPAD);
 	}
 
-}
\ No newline at end of file
+}
diff --git a/src/Cafe/OS/libs/proc_ui/proc_ui.cpp b/src/Cafe/OS/libs/proc_ui/proc_ui.cpp
index caba7237..ff38abbb 100644
--- a/src/Cafe/OS/libs/proc_ui/proc_ui.cpp
+++ b/src/Cafe/OS/libs/proc_ui/proc_ui.cpp
@@ -1,30 +1,908 @@
 #include "Cafe/OS/common/OSCommon.h"
+#include "Cafe/OS/libs/coreinit/coreinit_Alarm.h"
+#include "Cafe/OS/libs/coreinit/coreinit_Thread.h"
+#include "Cafe/OS/libs/coreinit/coreinit_MessageQueue.h"
+#include "Cafe/OS/libs/coreinit/coreinit_Misc.h"
+#include "Cafe/OS/libs/coreinit/coreinit_Memory.h"
+#include "Cafe/OS/libs/coreinit/coreinit_MEM_ExpHeap.h"
+#include "Cafe/OS/libs/coreinit/coreinit_Time.h"
+#include "Cafe/OS/libs/coreinit/coreinit_FG.h"
+#include "Cafe/OS/libs/coreinit/coreinit_DynLoad.h"
+#include "Cafe/OS/libs/gx2/GX2_Misc.h"
+#include "Cafe/OS/RPL/rpl.h"
+#include "Common/CafeString.h"
 #include "proc_ui.h"
 
-#define PROCUI_STATUS_FOREGROUND	0
-#define PROCUI_STATUS_BACKGROUND	1
-#define PROCUI_STATUS_RELEASING		2
-#define PROCUI_STATUS_EXIT			3
+// proc_ui is a utility wrapper to help apps with the transition between foreground and background
+// some games (like Xenoblades Chronicles X) bypass proc_ui.rpl and listen to OSGetSystemMessageQueue() directly
 
-uint32 ProcUIProcessMessages()
+using namespace coreinit;
+
+namespace proc_ui
 {
-	return PROCUI_STATUS_FOREGROUND;
-}
+	enum class ProcUICoreThreadCommand
+	{
+		AcquireForeground = 0x0,
+		ReleaseForeground = 0x1,
+		Exit = 0x2,
+		NetIoStart = 0x3,
+		NetIoStop = 0x4,
+		HomeButtonDenied = 0x5,
+		Initial = 0x6
+	};
+
+	struct ProcUIInternalCallbackEntry
+	{
+		coreinit::OSAlarm_t alarm;
+		uint64be tickDelay;
+		MEMPTR<void> funcPtr;
+		MEMPTR<void> userParam;
+		sint32be priority;
+		MEMPTR<ProcUIInternalCallbackEntry> next;
+	};
+	static_assert(sizeof(ProcUIInternalCallbackEntry) == 0x70);
+
+	struct ProcUICallbackList
+	{
+		MEMPTR<ProcUIInternalCallbackEntry> first;
+	};
+	static_assert(sizeof(ProcUICallbackList) == 0x4);
+
+	std::atomic_bool s_isInitialized;
+	bool s_isInForeground;
+	bool s_isInShutdown;
+	bool s_isForegroundProcess;
+	bool s_previouslyWasBlocking;
+	ProcUIStatus s_currentProcUIStatus;
+	MEMPTR<void> s_saveCallback; // no param and no return value, set by ProcUIInit()
+	MEMPTR<void> s_saveCallbackEx; // with custom param and return value, set by ProcUIInitEx()
+	MEMPTR<void> s_saveCallbackExUserParam;
+	MEMPTR<coreinit::OSMessageQueue> s_systemMessageQueuePtr;
+	SysAllocator<coreinit::OSEvent> s_eventStateMessageReceived;
+	SysAllocator<coreinit::OSEvent> s_eventWaitingBeforeReleaseForeground;
+	SysAllocator<coreinit::OSEvent> s_eventBackgroundThreadGotMessage;
+	// procUI core threads
+	uint32 s_coreThreadStackSize;
+	bool s_coreThreadsCreated;
+	std::atomic<ProcUICoreThreadCommand> s_commandForCoreThread;
+	SysAllocator<OSThread_t> s_coreThreadArray[Espresso::CORE_COUNT];
+	MEMPTR<void> s_coreThreadStackPerCore[Espresso::CORE_COUNT];
+	SysAllocator<CafeString<22>> s_coreThread0NameBuffer;
+	SysAllocator<CafeString<22>> s_coreThread1NameBuffer;
+	SysAllocator<CafeString<22>> s_coreThread2NameBuffer;
+	SysAllocator<coreinit::OSEvent> s_eventCoreThreadsNewCommandReady;
+	SysAllocator<coreinit::OSEvent> s_eventCoreThreadsCommandDone;
+	SysAllocator<coreinit::OSRendezvous> s_coreThreadRendezvousA;
+	SysAllocator<coreinit::OSRendezvous> s_coreThreadRendezvousB;
+	SysAllocator<coreinit::OSRendezvous> s_coreThreadRendezvousC;
+	// background thread
+	MEMPTR<void> s_backgroundThreadStack;
+	SysAllocator<OSThread_t> s_backgroundThread;
+	// user defined heap
+	MEMPTR<void> s_memoryPoolHeapPtr;
+	MEMPTR<void> s_memAllocPtr;
+	MEMPTR<void> s_memFreePtr;
+	// draw done release
+	bool s_drawDoneReleaseCalled;
+	// memory storage
+	MEMPTR<void> s_bucketStorageBasePtr;
+	MEMPTR<void> s_mem1StorageBasePtr;
+	// callbacks
+	ProcUICallbackList s_callbacksType0_AcquireForeground[Espresso::CORE_COUNT];
+	ProcUICallbackList s_callbacksType1_ReleaseForeground[Espresso::CORE_COUNT];
+	ProcUICallbackList s_callbacksType2_Exit[Espresso::CORE_COUNT];
+	ProcUICallbackList s_callbacksType3_NetIoStart[Espresso::CORE_COUNT];
+	ProcUICallbackList s_callbacksType4_NetIoStop[Espresso::CORE_COUNT];
+	ProcUICallbackList s_callbacksType5_HomeButtonDenied[Espresso::CORE_COUNT];
+	ProcUICallbackList* const s_CallbackTables[stdx::to_underlying(ProcUICallbackId::COUNT)] =
+		{s_callbacksType0_AcquireForeground, s_callbacksType1_ReleaseForeground, s_callbacksType2_Exit, s_callbacksType3_NetIoStart, s_callbacksType4_NetIoStop, s_callbacksType5_HomeButtonDenied};
+	ProcUICallbackList s_backgroundCallbackList;
+	// driver
+	bool s_driverIsActive;
+	uint32be s_driverArgUkn1;
+	uint32be s_driverArgUkn2;
+	bool s_driverInBackground;
+	SysAllocator<OSDriverInterface> s_ProcUIDriver;
+	SysAllocator<CafeString<16>> s_ProcUIDriverName;
 
 
-uint32 ProcUIInForeground(PPCInterpreter_t* hCPU)
-{
-	return 1; // true means application is in foreground
-}
+	void* _AllocMem(uint32 size)
+	{
+		MEMPTR<void> r{PPCCoreCallback(s_memAllocPtr, size)};
+		return r.GetPtr();
+	}
 
-uint32 ProcUIRegisterCallback(uint32 message, MPTR callback, void* data, sint32 ukn)
-{
-	return 0;
-}
+	void _FreeMem(void* ptr)
+	{
+		PPCCoreCallback(s_memFreePtr.GetMPTR(), ptr);
+	}
 
-void procui_load()
-{
-	cafeExportRegister("proc_ui", ProcUIRegisterCallback, LogType::ProcUi);
-	cafeExportRegister("proc_ui", ProcUIProcessMessages, LogType::ProcUi);
-	cafeExportRegister("proc_ui", ProcUIInForeground, LogType::ProcUi);
-}
\ No newline at end of file
+	void ClearCallbacksWithoutMemFree()
+	{
+		for (sint32 coreIndex = 0; coreIndex < Espresso::CORE_COUNT; coreIndex++)
+		{
+			for (sint32 i = 0; i < stdx::to_underlying(ProcUICallbackId::COUNT); i++)
+				s_CallbackTables[i][coreIndex].first = nullptr;
+		}
+		s_backgroundCallbackList.first = nullptr;
+	}
+
+	void ShutdownThreads()
+	{
+		if ( !s_coreThreadsCreated)
+			return;
+		s_commandForCoreThread = ProcUICoreThreadCommand::Initial;
+		coreinit::OSMemoryBarrier();
+		OSSignalEvent(&s_eventCoreThreadsNewCommandReady);
+		for (sint32 coreIndex = 0; coreIndex < Espresso::CORE_COUNT; coreIndex++)
+		{
+			coreinit::OSJoinThread(&s_coreThreadArray[coreIndex], nullptr);
+			for (sint32 i = 0; i < stdx::to_underlying(ProcUICallbackId::COUNT); i++)
+			{
+				s_CallbackTables[i][coreIndex].first = nullptr; // memory is not cleanly released?
+			}
+		}
+		OSResetEvent(&s_eventCoreThreadsNewCommandReady);
+		for (sint32 coreIndex = 0; coreIndex < Espresso::CORE_COUNT; coreIndex++)
+		{
+			_FreeMem(s_coreThreadStackPerCore[coreIndex]);
+			s_coreThreadStackPerCore[coreIndex] = nullptr;
+		}
+		_FreeMem(s_backgroundThreadStack);
+		s_backgroundThreadStack = nullptr;
+		s_backgroundCallbackList.first = nullptr; // memory is not cleanly released?
+		s_coreThreadsCreated = false;
+	}
+
+	void DoCallbackChain(ProcUIInternalCallbackEntry* entry)
+	{
+		while (entry)
+		{
+			uint32 r = PPCCoreCallback(entry->funcPtr, entry->userParam);
+			if ( r )
+				cemuLog_log(LogType::APIErrors, "ProcUI: Callback returned error {}\n", r);
+			entry = entry->next;
+		}
+	}
+
+	void AlarmDoBackgroundCallback(PPCInterpreter_t* hCPU)
+	{
+		coreinit::OSAlarm_t* arg = MEMPTR<coreinit::OSAlarm_t>(hCPU->gpr[3]);
+		ProcUIInternalCallbackEntry* entry = (ProcUIInternalCallbackEntry*)arg;
+		uint32 r = PPCCoreCallback(entry->funcPtr, entry->userParam);
+		if ( r )
+			cemuLog_log(LogType::APIErrors, "ProcUI: Background callback returned error {}\n", r);
+		osLib_returnFromFunction(hCPU, 0); // return type is void
+	}
+
+	void StartBackgroundAlarms()
+	{
+		ProcUIInternalCallbackEntry* cb = s_backgroundCallbackList.first;
+		while(cb)
+		{
+			coreinit::OSCreateAlarm(&cb->alarm);
+			uint64 currentTime = coreinit::OSGetTime();
+			coreinit::OSSetPeriodicAlarm(&cb->alarm, currentTime, cb->tickDelay, RPLLoader_MakePPCCallable(AlarmDoBackgroundCallback));
+			cb = cb->next;
+		}
+	}
+
+	void CancelBackgroundAlarms()
+	{
+		ProcUIInternalCallbackEntry* entry = s_backgroundCallbackList.first;
+		while (entry)
+		{
+			OSCancelAlarm(&entry->alarm);
+			entry = entry->next;
+		}
+	}
+
+	void ProcUICoreThread(PPCInterpreter_t* hCPU)
+	{
+		uint32 coreIndex = hCPU->gpr[3];
+		cemu_assert_debug(coreIndex == OSGetCoreId());
+		while (true)
+		{
+			OSWaitEvent(&s_eventCoreThreadsNewCommandReady);
+			ProcUIInternalCallbackEntry* cbChain = nullptr;
+			cemuLog_logDebug(LogType::Force, "ProcUI: Core {} got command {}", coreIndex, (uint32)s_commandForCoreThread.load());
+			auto cmd = s_commandForCoreThread.load();
+			switch(cmd)
+			{
+			case ProcUICoreThreadCommand::Initial:
+			{
+				// signal to shut down thread
+				osLib_returnFromFunction(hCPU, 0);
+				return;
+			}
+			case ProcUICoreThreadCommand::AcquireForeground:
+				cbChain = s_callbacksType0_AcquireForeground[coreIndex].first;
+				break;
+			case ProcUICoreThreadCommand::ReleaseForeground:
+				cbChain = s_callbacksType1_ReleaseForeground[coreIndex].first;
+				break;
+			case ProcUICoreThreadCommand::Exit:
+				cbChain = s_callbacksType2_Exit[coreIndex].first;
+				break;
+			case ProcUICoreThreadCommand::NetIoStart:
+				cbChain = s_callbacksType3_NetIoStart[coreIndex].first;
+				break;
+			case ProcUICoreThreadCommand::NetIoStop:
+				cbChain = s_callbacksType4_NetIoStop[coreIndex].first;
+				break;
+			case ProcUICoreThreadCommand::HomeButtonDenied:
+				cbChain = s_callbacksType5_HomeButtonDenied[coreIndex].first;
+				break;
+			default:
+				cemu_assert_suspicious(); // invalid command
+			}
+			if(cmd == ProcUICoreThreadCommand::AcquireForeground)
+			{
+				if (coreIndex == 2)
+					CancelBackgroundAlarms();
+				cbChain = s_callbacksType0_AcquireForeground[coreIndex].first;
+			}
+			else if(cmd == ProcUICoreThreadCommand::ReleaseForeground)
+			{
+				if (coreIndex == 2)
+					StartBackgroundAlarms();
+				cbChain = s_callbacksType1_ReleaseForeground[coreIndex].first;
+			}
+			DoCallbackChain(cbChain);
+			OSWaitRendezvous(&s_coreThreadRendezvousA, 7);
+			if ( !coreIndex )
+			{
+				OSInitRendezvous(&s_coreThreadRendezvousC);
+				OSResetEvent(&s_eventCoreThreadsNewCommandReady);
+			}
+			OSWaitRendezvous(&s_coreThreadRendezvousB, 7);
+			if ( !coreIndex )
+			{
+				OSInitRendezvous(&s_coreThreadRendezvousA);
+				OSSignalEvent(&s_eventCoreThreadsCommandDone);
+			}
+			OSWaitRendezvous(&s_coreThreadRendezvousC, 7);
+			if ( !coreIndex )
+				OSInitRendezvous(&s_coreThreadRendezvousB);
+			if (cmd == ProcUICoreThreadCommand::ReleaseForeground)
+			{
+				OSWaitEvent(&s_eventWaitingBeforeReleaseForeground);
+				OSReleaseForeground();
+			}
+		}
+		osLib_returnFromFunction(hCPU, 0);
+	}
+
+	void RecreateProcUICoreThreads()
+	{
+		ShutdownThreads();
+		for (sint32 coreIndex = 0; coreIndex < Espresso::CORE_COUNT; coreIndex++)
+		{
+			s_coreThreadStackPerCore[coreIndex] = _AllocMem(s_coreThreadStackSize);
+		}
+		s_backgroundThreadStack = _AllocMem(s_coreThreadStackSize);
+		for (sint32 coreIndex = 0; coreIndex < Espresso::CORE_COUNT; coreIndex++)
+		{
+			__OSCreateThreadType(&s_coreThreadArray[coreIndex], RPLLoader_MakePPCCallable(ProcUICoreThread), coreIndex, nullptr,
+				(uint8*)s_coreThreadStackPerCore[coreIndex].GetPtr() + s_coreThreadStackSize, s_coreThreadStackSize, 16,
+				(1<<coreIndex), OSThread_t::THREAD_TYPE::TYPE_DRIVER);
+			OSResumeThread(&s_coreThreadArray[coreIndex]);
+		}
+		s_coreThread0NameBuffer->assign("{SYS ProcUI Core 0}");
+		s_coreThread1NameBuffer->assign("{SYS ProcUI Core 1}");
+		s_coreThread2NameBuffer->assign("{SYS ProcUI Core 2}");
+		OSSetThreadName(&s_coreThreadArray[0], s_coreThread0NameBuffer->c_str());
+		OSSetThreadName(&s_coreThreadArray[1], s_coreThread1NameBuffer->c_str());
+		OSSetThreadName(&s_coreThreadArray[2], s_coreThread2NameBuffer->c_str());
+		s_coreThreadsCreated = true;
+	}
+
+	void _SubmitCommandToCoreThreads(ProcUICoreThreadCommand cmd)
+	{
+		s_commandForCoreThread = cmd;
+		OSMemoryBarrier();
+		OSResetEvent(&s_eventCoreThreadsCommandDone);
+		OSSignalEvent(&s_eventCoreThreadsNewCommandReady);
+		OSWaitEvent(&s_eventCoreThreadsCommandDone);
+	}
+
+	void ProcUIInitInternal()
+	{
+		if( s_isInitialized.exchange(true) )
+			return;
+		if (!s_memoryPoolHeapPtr)
+		{
+			// user didn't specify a custom heap, use default heap instead
+			s_memAllocPtr = gCoreinitData->MEMAllocFromDefaultHeap.GetMPTR();
+			s_memFreePtr = gCoreinitData->MEMFreeToDefaultHeap.GetMPTR();
+		}
+		OSInitEvent(&s_eventStateMessageReceived, OSEvent::EVENT_STATE::STATE_NOT_SIGNALED, OSEvent::EVENT_MODE::MODE_MANUAL);
+		OSInitEvent(&s_eventCoreThreadsNewCommandReady, OSEvent::EVENT_STATE::STATE_NOT_SIGNALED, OSEvent::EVENT_MODE::MODE_MANUAL);
+		OSInitEvent(&s_eventWaitingBeforeReleaseForeground, OSEvent::EVENT_STATE::STATE_NOT_SIGNALED, OSEvent::EVENT_MODE::MODE_MANUAL);
+		OSInitEvent(&s_eventCoreThreadsCommandDone, OSEvent::EVENT_STATE::STATE_NOT_SIGNALED, OSEvent::EVENT_MODE::MODE_MANUAL);
+		OSInitRendezvous(&s_coreThreadRendezvousA);
+		OSInitRendezvous(&s_coreThreadRendezvousB);
+		OSInitRendezvous(&s_coreThreadRendezvousC);
+		OSInitEvent(&s_eventBackgroundThreadGotMessage, OSEvent::EVENT_STATE::STATE_NOT_SIGNALED, OSEvent::EVENT_MODE::MODE_MANUAL);
+		s_currentProcUIStatus = ProcUIStatus::Foreground;
+		s_drawDoneReleaseCalled = false;
+		s_isInForeground = true;
+		s_coreThreadStackSize = 0x2000;
+		s_systemMessageQueuePtr = coreinit::OSGetSystemMessageQueue();
+		uint32 upid = coreinit::OSGetUPID();
+		s_isForegroundProcess = upid == 2 || upid == 15; // either Wii U Menu or game title, both are RAMPID 7 (foreground process)
+		RecreateProcUICoreThreads();
+		ClearCallbacksWithoutMemFree();
+	}
+
+	void ProcUIInit(MEMPTR<void> callbackReadyToRelease)
+	{
+		s_saveCallback = callbackReadyToRelease;
+		s_saveCallbackEx = nullptr;
+		s_saveCallbackExUserParam = nullptr;
+		ProcUIInitInternal();
+	}
+
+	void ProcUIInitEx(MEMPTR<void> callbackReadyToReleaseEx, MEMPTR<void> userParam)
+	{
+		s_saveCallback = nullptr;
+		s_saveCallbackEx = callbackReadyToReleaseEx;
+		s_saveCallbackExUserParam = userParam;
+		ProcUIInitInternal();
+	}
+
+	void ProcUIShutdown()
+	{
+		if (!s_isInitialized.exchange(false))
+			return;
+		if ( !s_isInForeground )
+			CancelBackgroundAlarms();
+		for (sint32 i = 0; i < Espresso::CORE_COUNT; i++)
+			OSSetThreadPriority(&s_coreThreadArray[i], 0);
+		_SubmitCommandToCoreThreads(ProcUICoreThreadCommand::Exit);
+		ProcUIClearCallbacks();
+		ShutdownThreads();
+	}
+
+	bool ProcUIIsRunning()
+	{
+		return s_isInitialized;
+	}
+
+	bool ProcUIInForeground()
+	{
+		return s_isInForeground;
+	}
+
+	bool ProcUIInShutdown()
+	{
+		return s_isInShutdown;
+	}
+
+	void AddCallbackInternal(void* funcPtr, void* userParam, uint64 tickDelay, sint32 priority, ProcUICallbackList& callbackList)
+	{
+		if ( __OSGetProcessSDKVersion() < 21102 )
+		{
+			// in earlier COS versions it was possible/allowed to register a callback before initializing ProcUI
+			s_memAllocPtr = gCoreinitData->MEMAllocFromDefaultHeap.GetMPTR();
+			s_memFreePtr = gCoreinitData->MEMFreeToDefaultHeap.GetMPTR();
+		}
+		else if ( !s_isInitialized )
+		{
+			cemuLog_log(LogType::Force, "ProcUI: Trying to register callback before init");
+			cemu_assert_suspicious();
+			// this shouldn't happen but lets set the memory pointers anyway to prevent a crash in case the user has incorrect meta info
+			s_memAllocPtr = gCoreinitData->MEMAllocFromDefaultHeap.GetMPTR();
+			s_memFreePtr = gCoreinitData->MEMFreeToDefaultHeap.GetMPTR();
+		}
+		ProcUIInternalCallbackEntry* entry = (ProcUIInternalCallbackEntry*)_AllocMem(sizeof(ProcUIInternalCallbackEntry));
+		entry->funcPtr = funcPtr;
+		entry->userParam = userParam;
+		entry->tickDelay = tickDelay;
+		entry->priority = priority;
+		ProcUIInternalCallbackEntry* cur = callbackList.first;
+		cur = callbackList.first;
+		if (!cur || cur->priority > priority)
+		{
+			// insert as the first element
+			entry->next = cur;
+			callbackList.first = entry;
+		}
+		else
+		{
+			// find the correct position to insert
+			while (cur->next && cur->next->priority < priority)
+				cur = cur->next;
+			entry->next = cur->next;
+			cur->next = entry;
+		}
+	}
+
+	void ProcUIRegisterCallbackCore(ProcUICallbackId callbackType, void* funcPtr, void* userParam, sint32 priority, uint32 coreIndex)
+	{
+		if(callbackType >= ProcUICallbackId::COUNT)
+		{
+			cemuLog_log(LogType::Force, "ProcUIRegisterCallback: Invalid callback type {}", stdx::to_underlying(callbackType));
+			return;
+		}
+		if(callbackType != ProcUICallbackId::AcquireForeground)
+			priority = -priority;
+		AddCallbackInternal(funcPtr, userParam, 0, priority, s_CallbackTables[stdx::to_underlying(callbackType)][coreIndex]);
+	}
+
+	void ProcUIRegisterCallback(ProcUICallbackId callbackType, void* funcPtr, void* userParam, sint32 priority)
+	{
+		ProcUIRegisterCallbackCore(callbackType, funcPtr, userParam, priority, OSGetCoreId());
+	}
+
+	void ProcUIRegisterBackgroundCallback(void* funcPtr, void* userParam, uint64 tickDelay)
+	{
+		AddCallbackInternal(funcPtr, userParam, tickDelay, 0, s_backgroundCallbackList);
+	}
+
+	void FreeCallbackChain(ProcUICallbackList& callbackList)
+	{
+		ProcUIInternalCallbackEntry* entry = callbackList.first;
+		while (entry)
+		{
+			ProcUIInternalCallbackEntry* next = entry->next;
+			_FreeMem(entry);
+			entry = next;
+		}
+		callbackList.first = nullptr;
+	}
+
+	void ProcUIClearCallbacks()
+	{
+		for (sint32 coreIndex = 0; coreIndex < Espresso::CORE_COUNT; coreIndex++)
+		{
+			for (sint32 i = 0; i < stdx::to_underlying(ProcUICallbackId::COUNT); i++)
+			{
+				FreeCallbackChain(s_CallbackTables[i][coreIndex]);
+			}
+		}
+		if (!s_isInForeground)
+			CancelBackgroundAlarms();
+		FreeCallbackChain(s_backgroundCallbackList);
+	}
+
+	void ProcUISetSaveCallback(void* funcPtr, void* userParam)
+	{
+		s_saveCallback = nullptr;
+		s_saveCallbackEx = funcPtr;
+		s_saveCallbackExUserParam = userParam;
+	}
+
+	void ProcUISetCallbackStackSize(uint32 newStackSize)
+	{
+		s_coreThreadStackSize = newStackSize;
+		if( s_isInitialized )
+			RecreateProcUICoreThreads();
+	}
+
+	uint32 ProcUICalcMemorySize(uint32 numCallbacks)
+	{
+		// each callback entry is 0x70 bytes with 0x14 bytes of allocator overhead (for ExpHeap). But for some reason proc_ui on 5.5.5 seems to reserve 0x8C0 bytes per callback?
+		uint32 stackReserveSize = (Espresso::CORE_COUNT + 1) * s_coreThreadStackSize; // 3 core threads + 1 message receive thread
+		uint32 callbackReserveSize = 0x8C0 * numCallbacks;
+		return stackReserveSize + callbackReserveSize + 100;
+	}
+
+	void _MemAllocFromMemoryPool(PPCInterpreter_t* hCPU)
+	{
+		uint32 size = hCPU->gpr[3];
+		MEMPTR<void> r = MEMAllocFromExpHeapEx((MEMHeapHandle)s_memoryPoolHeapPtr.GetPtr(), size, 4);
+		osLib_returnFromFunction(hCPU, r.GetMPTR());
+	}
+
+	void _FreeToMemoryPoolExpHeap(PPCInterpreter_t* hCPU)
+	{
+		MEMPTR<void> mem{hCPU->gpr[3]};
+		MEMFreeToExpHeap((MEMHeapHandle)s_memoryPoolHeapPtr.GetPtr(), mem.GetPtr());
+		osLib_returnFromFunction(hCPU, 0);
+	}
+
+	sint32 ProcUISetMemoryPool(void* memBase, uint32 size)
+	{
+		s_memAllocPtr = RPLLoader_MakePPCCallable(_MemAllocFromMemoryPool);
+		s_memFreePtr = RPLLoader_MakePPCCallable(_FreeToMemoryPoolExpHeap);
+		s_memoryPoolHeapPtr = MEMCreateExpHeapEx(memBase, size, MEM_HEAP_OPTION_THREADSAFE);
+		return s_memoryPoolHeapPtr ? 0 : -1;
+	}
+
+	void ProcUISetBucketStorage(void* memBase, uint32 size)
+	{
+		MEMPTR<void> fgBase;
+		uint32be fgFreeSize;
+		OSGetForegroundBucketFreeArea(&fgBase, &fgFreeSize);
+		if(fgFreeSize < size)
+			cemuLog_log(LogType::Force, "ProcUISetBucketStorage: Buffer size too small");
+		s_bucketStorageBasePtr = memBase;
+	}
+
+	void ProcUISetMEM1Storage(void* memBase, uint32 size)
+	{
+		MEMPTR<void> memBound;
+		uint32be memBoundSize;
+		OSGetMemBound(1, &memBound, &memBoundSize);
+		if(memBoundSize < size)
+			cemuLog_log(LogType::Force, "ProcUISetMEM1Storage: Buffer size too small");
+		s_mem1StorageBasePtr = memBase;
+	}
+
+	void ProcUIDrawDoneRelease()
+	{
+		s_drawDoneReleaseCalled = true;
+	}
+
+	OSMessage g_lastMsg;
+
+	void ProcUI_BackgroundThread_ReceiveSingleMessage(PPCInterpreter_t* hCPU)
+	{
+		// the background thread receives messages in a loop until the title is either exited or foreground is acquired
+		while ( true )
+		{
+			OSReceiveMessage(s_systemMessageQueuePtr, &g_lastMsg, OS_MESSAGE_BLOCK); // blocking receive
+			SysMessageId lastMsgId = static_cast<SysMessageId>((uint32)g_lastMsg.data0);
+			if(lastMsgId == SysMessageId::MsgExit || lastMsgId == SysMessageId::MsgAcquireForeground)
+				break;
+			else if (lastMsgId == SysMessageId::HomeButtonDenied)
+			{
+				cemu_assert_suspicious(); // Home button denied should not be sent to background app
+			}
+			else if ( lastMsgId == SysMessageId::NetIoStartOrStop )
+			{
+				if (g_lastMsg.data1 )
+				{
+					// NetIo start message
+					for (sint32 i = 0; i < Espresso::CORE_COUNT; i++)
+						DoCallbackChain(s_callbacksType3_NetIoStart[i].first);
+				}
+				else
+				{
+					// NetIo stop message
+					for (sint32 i = 0; i < Espresso::CORE_COUNT; i++)
+						DoCallbackChain(s_callbacksType4_NetIoStop[i].first);
+				}
+			}
+			else
+			{
+				cemuLog_log(LogType::Force, "ProcUI: BackgroundThread received invalid message 0x{:08x}", lastMsgId);
+			}
+		}
+		OSSignalEvent(&s_eventBackgroundThreadGotMessage);
+		osLib_returnFromFunction(hCPU, 0);
+	}
+
+	// handle received message
+	// if the message is Exit this function returns false, in all other cases it returns true
+	bool ProcessSysMessage(OSMessage* msg)
+	{
+		SysMessageId lastMsgId = static_cast<SysMessageId>((uint32)msg->data0);
+		if ( lastMsgId == SysMessageId::MsgAcquireForeground )
+		{
+			cemuLog_logDebug(LogType::Force, "ProcUI: Received Acquire Foreground message");
+			s_isInShutdown = false;
+			_SubmitCommandToCoreThreads(ProcUICoreThreadCommand::AcquireForeground);
+			s_currentProcUIStatus = ProcUIStatus::Foreground;
+			s_isInForeground = true;
+			OSMemoryBarrier();
+			OSSignalEvent(&s_eventStateMessageReceived);
+			return true;
+		}
+		else if (lastMsgId == SysMessageId::MsgExit)
+		{
+			cemuLog_logDebug(LogType::Force, "ProcUI: Received Exit message");
+			s_isInShutdown = true;
+			_SubmitCommandToCoreThreads(ProcUICoreThreadCommand::Exit);
+			for (sint32 i = 0; i < Espresso::CORE_COUNT; i++)
+				FreeCallbackChain(s_callbacksType2_Exit[i]);
+			s_currentProcUIStatus = ProcUIStatus::Exit;
+			OSMemoryBarrier();
+			OSSignalEvent(&s_eventStateMessageReceived);
+			return 0;
+		}
+		if (lastMsgId == SysMessageId::MsgReleaseForeground)
+		{
+			if (msg->data1 != 0)
+			{
+				cemuLog_logDebug(LogType::Force, "ProcUI: Received Release Foreground message as part of shutdown initiation");
+				s_isInShutdown = true;
+			}
+			else
+			{
+				cemuLog_logDebug(LogType::Force, "ProcUI: Received Release Foreground message");
+			}
+			s_currentProcUIStatus = ProcUIStatus::Releasing;
+			OSResetEvent(&s_eventStateMessageReceived);
+			// dont submit a command for the core threads yet, we need to wait for ProcUIDrawDoneRelease()
+		}
+		else if (lastMsgId == SysMessageId::HomeButtonDenied)
+		{
+			cemuLog_logDebug(LogType::Force, "ProcUI: Received Home Button Denied message");
+			_SubmitCommandToCoreThreads(ProcUICoreThreadCommand::HomeButtonDenied);
+		}
+		else if ( lastMsgId == SysMessageId::NetIoStartOrStop )
+		{
+			if (msg->data1 != 0)
+			{
+				cemuLog_logDebug(LogType::Force, "ProcUI: Received Net IO Start message");
+				_SubmitCommandToCoreThreads(ProcUICoreThreadCommand::NetIoStart);
+			}
+			else
+			{
+				cemuLog_logDebug(LogType::Force, "ProcUI: Received Net IO Stop message");
+				_SubmitCommandToCoreThreads(ProcUICoreThreadCommand::NetIoStop);
+			}
+		}
+		else
+		{
+			cemuLog_log(LogType::Force, "ProcUI: Received unknown message 0x{:08x}", (uint32)lastMsgId);
+		}
+		return true;
+	}
+
+	ProcUIStatus ProcUIProcessMessages(bool isBlockingInBackground)
+	{
+		OSMessage msg;
+		if (!s_isInitialized)
+		{
+			cemuLog_logOnce(LogType::Force, "ProcUIProcessMessages: ProcUI not initialized");
+			cemu_assert_suspicious();
+			return ProcUIStatus::Foreground;
+		}
+		if ( !isBlockingInBackground && OSGetCoreId() != 2 )
+		{
+			cemuLog_logOnce(LogType::Force, "ProcUIProcessMessages: Non-blocking call must run on core 2");
+		}
+		if (s_previouslyWasBlocking && isBlockingInBackground )
+		{
+			cemuLog_logOnce(LogType::Force, "ProcUIProcessMessages: Cannot switch to blocking mode when in background");
+		}
+		s_currentProcUIStatus = s_isInForeground ? ProcUIStatus::Foreground : ProcUIStatus::Background;
+		if (s_drawDoneReleaseCalled)
+		{
+			s_isInForeground = false;
+			s_currentProcUIStatus = ProcUIStatus::Background;
+			_SubmitCommandToCoreThreads(ProcUICoreThreadCommand::ReleaseForeground);
+			OSResetEvent(&s_eventWaitingBeforeReleaseForeground);
+			if(s_saveCallback)
+				PPCCoreCallback(s_saveCallback);
+			if(s_saveCallbackEx)
+				PPCCoreCallback(s_saveCallbackEx, s_saveCallbackExUserParam);
+			if (s_isForegroundProcess && isBlockingInBackground)
+			{
+				// start background thread
+				__OSCreateThreadType(&s_backgroundThread, RPLLoader_MakePPCCallable(ProcUI_BackgroundThread_ReceiveSingleMessage),
+					0, nullptr, (uint8*)s_backgroundThreadStack.GetPtr() + s_coreThreadStackSize, s_coreThreadStackSize,
+					16, (1<<2), OSThread_t::THREAD_TYPE::TYPE_DRIVER);
+				OSResumeThread(&s_backgroundThread);
+				s_previouslyWasBlocking = true;
+			}
+			cemuLog_logDebug(LogType::Force, "ProcUI: Releasing foreground");
+			OSSignalEvent(&s_eventWaitingBeforeReleaseForeground);
+			s_drawDoneReleaseCalled = false;
+		}
+		if (s_isInForeground || !isBlockingInBackground)
+		{
+			// non-blocking mode
+			if ( OSReceiveMessage(s_systemMessageQueuePtr, &msg, 0) )
+			{
+				s_previouslyWasBlocking = false;
+				if ( !ProcessSysMessage(&msg) )
+					return s_currentProcUIStatus;
+				// continue below, if we are now in background then ProcUIProcessMessages enters blocking mode
+			}
+		}
+		// blocking mode (if in background and param is true)
+		while (!s_isInForeground && isBlockingInBackground)
+		{
+			if ( !s_isForegroundProcess)
+			{
+				OSReceiveMessage(s_systemMessageQueuePtr, &msg, OS_MESSAGE_BLOCK);
+				s_previouslyWasBlocking = false;
+				if ( !ProcessSysMessage(&msg) )
+					return s_currentProcUIStatus;
+			}
+			// this code should only run if the background thread was started? Maybe rearrange the code to make this more clear
+			OSWaitEvent(&s_eventBackgroundThreadGotMessage);
+			OSResetEvent(&s_eventBackgroundThreadGotMessage);
+			OSJoinThread(&s_backgroundThread, nullptr);
+			msg = g_lastMsg; // g_lastMsg is set by the background thread
+			s_previouslyWasBlocking = false;
+			if ( !ProcessSysMessage(&msg) )
+				return s_currentProcUIStatus;
+		}
+		return s_currentProcUIStatus;
+	}
+
+	ProcUIStatus ProcUISubProcessMessages(bool isBlockingInBackground)
+	{
+		if (isBlockingInBackground)
+		{
+			while (s_currentProcUIStatus == ProcUIStatus::Background)
+				OSWaitEvent(&s_eventStateMessageReceived);
+		}
+		return s_currentProcUIStatus;
+	}
+
+	const char* ProcUIDriver_GetName()
+	{
+		s_ProcUIDriverName->assign("ProcUI");
+		return s_ProcUIDriverName->c_str();
+	}
+
+	void ProcUIDriver_Init(/* parameters unknown */)
+	{
+		s_driverIsActive = true;
+		OSMemoryBarrier();
+	}
+
+	void ProcUIDriver_OnDone(/* parameters unknown */)
+	{
+		if (s_driverIsActive)
+		{
+			ProcUIShutdown();
+			s_driverIsActive = false;
+			OSMemoryBarrier();
+		}
+	}
+
+	void StoreMEM1AndFGBucket()
+	{
+		if (s_mem1StorageBasePtr)
+		{
+			MEMPTR<void> memBound;
+			uint32be memBoundSize;
+			OSGetMemBound(1, &memBound, &memBoundSize);
+			OSBlockMove(s_mem1StorageBasePtr.GetPtr(), memBound.GetPtr(), memBoundSize, true);
+		}
+		if (s_bucketStorageBasePtr)
+		{
+			MEMPTR<void> memBound;
+			uint32be memBoundSize;
+			OSGetForegroundBucketFreeArea(&memBound, &memBoundSize);
+			OSBlockMove(s_bucketStorageBasePtr.GetPtr(), memBound.GetPtr(), memBoundSize, true);
+		}
+	}
+
+	void RestoreMEM1AndFGBucket()
+	{
+		if (s_mem1StorageBasePtr)
+		{
+			MEMPTR<void> memBound;
+			uint32be memBoundSize;
+			OSGetMemBound(1, &memBound, &memBoundSize);
+			OSBlockMove(memBound.GetPtr(), s_mem1StorageBasePtr, memBoundSize, true);
+			GX2::GX2Invalidate(0x40, s_mem1StorageBasePtr.GetMPTR(), memBoundSize);
+		}
+		if (s_bucketStorageBasePtr)
+		{
+			MEMPTR<void> memBound;
+			uint32be memBoundSize;
+			OSGetForegroundBucketFreeArea(&memBound, &memBoundSize);
+			OSBlockMove(memBound.GetPtr(), s_bucketStorageBasePtr, memBoundSize, true);
+			GX2::GX2Invalidate(0x40, memBound.GetMPTR(), memBoundSize);
+		}
+	}
+
+	void ProcUIDriver_OnAcquiredForeground(/* parameters unknown */)
+	{
+		if (s_driverInBackground)
+		{
+			ProcUIDriver_Init();
+			s_driverInBackground = false;
+		}
+		else
+		{
+			RestoreMEM1AndFGBucket();
+			s_driverIsActive = true;
+			OSMemoryBarrier();
+		}
+	}
+
+	void ProcUIDriver_OnReleaseForeground(/* parameters unknown */)
+	{
+		StoreMEM1AndFGBucket();
+		s_driverIsActive = false;
+		OSMemoryBarrier();
+	}
+
+	sint32 rpl_entry(uint32 moduleHandle, RplEntryReason reason)
+	{
+		if ( reason == RplEntryReason::Loaded )
+		{
+			s_ProcUIDriver->getDriverName = RPLLoader_MakePPCCallable([](PPCInterpreter_t* hCPU) {MEMPTR<const char> namePtr(ProcUIDriver_GetName()); osLib_returnFromFunction(hCPU, namePtr.GetMPTR()); });
+			s_ProcUIDriver->init = RPLLoader_MakePPCCallable([](PPCInterpreter_t* hCPU) {ProcUIDriver_Init(); osLib_returnFromFunction(hCPU, 0); });
+			s_ProcUIDriver->onAcquireForeground = RPLLoader_MakePPCCallable([](PPCInterpreter_t* hCPU) {ProcUIDriver_OnAcquiredForeground(); osLib_returnFromFunction(hCPU, 0); });
+			s_ProcUIDriver->onReleaseForeground = RPLLoader_MakePPCCallable([](PPCInterpreter_t* hCPU) {ProcUIDriver_OnReleaseForeground(); osLib_returnFromFunction(hCPU, 0); });
+			s_ProcUIDriver->done = RPLLoader_MakePPCCallable([](PPCInterpreter_t* hCPU) {ProcUIDriver_OnDone(); osLib_returnFromFunction(hCPU, 0); });
+
+			s_driverIsActive = false;
+			s_driverArgUkn1 = 0;
+			s_driverArgUkn2 = 0;
+			s_driverInBackground = false;
+			uint32be ukn3;
+			OSDriver_Register(moduleHandle, 200, &s_ProcUIDriver, 0, &s_driverArgUkn1, &s_driverArgUkn2, &ukn3);
+			if ( ukn3 )
+			{
+				if ( OSGetForegroundBucket(nullptr, nullptr) )
+				{
+					ProcUIDriver_Init();
+					OSMemoryBarrier();
+					return 0;
+				}
+				s_driverInBackground = true;
+			}
+			OSMemoryBarrier();
+		}
+		else if ( reason == RplEntryReason::Unloaded )
+		{
+			ProcUIDriver_OnDone();
+			OSDriver_Deregister(moduleHandle, 0);
+		}
+		return 0;
+	}
+
+	void reset()
+	{
+		// set variables to their initial state as if the RPL was just loaded
+		s_isInitialized = false;
+		s_isInShutdown = false;
+		s_isInForeground = false; // ProcUIInForeground returns false until ProcUIInit(Ex) is called
+		s_isForegroundProcess = true;
+		s_saveCallback = nullptr;
+		s_saveCallbackEx = nullptr;
+		s_systemMessageQueuePtr = nullptr;
+		ClearCallbacksWithoutMemFree();
+		s_currentProcUIStatus = ProcUIStatus::Foreground;
+		s_bucketStorageBasePtr = nullptr;
+		s_mem1StorageBasePtr = nullptr;
+		s_drawDoneReleaseCalled = false;
+		s_previouslyWasBlocking = false;
+		// core threads
+		s_coreThreadStackSize = 0;
+		s_coreThreadsCreated = false;
+		s_commandForCoreThread = ProcUICoreThreadCommand::Initial;
+		// background thread
+		s_backgroundThreadStack = nullptr;
+		// user defined heap
+		s_memoryPoolHeapPtr = nullptr;
+		s_memAllocPtr = nullptr;
+		s_memFreePtr = nullptr;
+		// driver
+		s_driverIsActive = false;
+		s_driverInBackground = false;
+	}
+
+	void load()
+	{
+		reset();
+
+		cafeExportRegister("proc_ui", ProcUIInit, LogType::ProcUi);
+		cafeExportRegister("proc_ui", ProcUIInitEx, LogType::ProcUi);
+		cafeExportRegister("proc_ui", ProcUIShutdown, LogType::ProcUi);
+		cafeExportRegister("proc_ui", ProcUIIsRunning, LogType::ProcUi);
+		cafeExportRegister("proc_ui", ProcUIInForeground, LogType::ProcUi);
+		cafeExportRegister("proc_ui", ProcUIInShutdown, LogType::ProcUi);
+
+		cafeExportRegister("proc_ui", ProcUIRegisterCallbackCore, LogType::ProcUi);
+		cafeExportRegister("proc_ui", ProcUIRegisterCallback, LogType::ProcUi);
+		cafeExportRegister("proc_ui", ProcUIRegisterBackgroundCallback, LogType::ProcUi);
+		cafeExportRegister("proc_ui", ProcUIClearCallbacks, LogType::ProcUi);
+		cafeExportRegister("proc_ui", ProcUISetSaveCallback, LogType::ProcUi);
+
+		cafeExportRegister("proc_ui", ProcUISetCallbackStackSize, LogType::ProcUi);
+		cafeExportRegister("proc_ui", ProcUICalcMemorySize, LogType::ProcUi);
+		cafeExportRegister("proc_ui", ProcUISetMemoryPool, LogType::ProcUi);
+		cafeExportRegister("proc_ui", ProcUISetBucketStorage, LogType::ProcUi);
+		cafeExportRegister("proc_ui", ProcUISetMEM1Storage, LogType::ProcUi);
+
+		cafeExportRegister("proc_ui", ProcUIDrawDoneRelease, LogType::ProcUi);
+		cafeExportRegister("proc_ui", ProcUIProcessMessages, LogType::ProcUi);
+		cafeExportRegister("proc_ui", ProcUISubProcessMessages, LogType::ProcUi);
+
+		// manually call rpl_entry for now
+		rpl_entry(-1, RplEntryReason::Loaded);
+	}
+};
diff --git a/src/Cafe/OS/libs/proc_ui/proc_ui.h b/src/Cafe/OS/libs/proc_ui/proc_ui.h
index 4463c5d3..8de7bb4d 100644
--- a/src/Cafe/OS/libs/proc_ui/proc_ui.h
+++ b/src/Cafe/OS/libs/proc_ui/proc_ui.h
@@ -1,2 +1,44 @@
 
-void procui_load();
\ No newline at end of file
+namespace proc_ui
+{
+	enum class ProcUIStatus
+	{
+		Foreground = 0,
+		Background = 1,
+		Releasing = 2,
+		Exit = 3
+	};
+
+	enum class ProcUICallbackId
+	{
+		AcquireForeground = 0,
+		ReleaseForeground = 1,
+		Exit = 2,
+		NetIoStart = 3,
+		NetIoStop = 4,
+		HomeButtonDenied = 5,
+		COUNT = 6
+	};
+
+	void ProcUIInit(MEMPTR<void> callbackReadyToRelease);
+	void ProcUIInitEx(MEMPTR<void> callbackReadyToReleaseEx, MEMPTR<void> userParam);
+	void ProcUIShutdown();
+	bool ProcUIIsRunning();
+	bool ProcUIInForeground();
+	bool ProcUIInShutdown();
+	void ProcUIRegisterCallback(ProcUICallbackId callbackType, void* funcPtr, void* userParam, sint32 priority);
+	void ProcUIRegisterCallbackCore(ProcUICallbackId callbackType, void* funcPtr, void* userParam, sint32 priority, uint32 coreIndex);
+	void ProcUIRegisterBackgroundCallback(void* funcPtr, void* userParam, uint64 tickDelay);
+	void ProcUIClearCallbacks();
+	void ProcUISetSaveCallback(void* funcPtr, void* userParam);
+	void ProcUISetCallbackStackSize(uint32 newStackSize);
+	uint32 ProcUICalcMemorySize(uint32 numCallbacks);
+	sint32 ProcUISetMemoryPool(void* memBase, uint32 size);
+	void ProcUISetBucketStorage(void* memBase, uint32 size);
+	void ProcUISetMEM1Storage(void* memBase, uint32 size);
+	void ProcUIDrawDoneRelease();
+	ProcUIStatus ProcUIProcessMessages(bool isBlockingInBackground);
+	ProcUIStatus ProcUISubProcessMessages(bool isBlockingInBackground);
+
+	void load();
+}
\ No newline at end of file
diff --git a/src/Cafe/OS/libs/snd_core/ax.h b/src/Cafe/OS/libs/snd_core/ax.h
index 9f7a1e1c..d9bbbf18 100644
--- a/src/Cafe/OS/libs/snd_core/ax.h
+++ b/src/Cafe/OS/libs/snd_core/ax.h
@@ -209,6 +209,8 @@ namespace snd_core
 	};
 
 	void AXVPB_Init();
+    void AXResetToDefaultState();
+
 	sint32 AXIsValidDevice(sint32 device, sint32 deviceIndex);
 
 	AXVPB* AXAcquireVoiceEx(uint32 priority, MPTR callbackEx, MPTR userParam);
diff --git a/src/Cafe/OS/libs/snd_core/ax_aux.cpp b/src/Cafe/OS/libs/snd_core/ax_aux.cpp
index 3da391fe..a9176562 100644
--- a/src/Cafe/OS/libs/snd_core/ax_aux.cpp
+++ b/src/Cafe/OS/libs/snd_core/ax_aux.cpp
@@ -218,9 +218,10 @@ namespace snd_core
 				AXAUXCBCHANNELINFO* cbStruct = __AXAuxCB_auxCBStruct.GetPtr();
 				cbStruct->numChannels = tvChannelCount;
 				cbStruct->numSamples = sampleCount;
-				ppcInterpreterCurrentInstance->gpr[3] = __AXAuxCB_dataPtrs.GetMPTR();
-				ppcInterpreterCurrentInstance->gpr[4] = __AXAuxTVCallbackUserParam[auxBusIndex];
-				ppcInterpreterCurrentInstance->gpr[5] = __AXAuxCB_auxCBStruct.GetMPTR();
+				PPCInterpreter_t* hCPU = PPCInterpreter_getCurrentInstance();
+				hCPU->gpr[3] = __AXAuxCB_dataPtrs.GetMPTR();
+				hCPU->gpr[4] = __AXAuxTVCallbackUserParam[auxBusIndex];
+				hCPU->gpr[5] = __AXAuxCB_auxCBStruct.GetMPTR();
 				PPCCore_executeCallbackInternal(auxCBFuncMPTR);
 			}
 			else
@@ -255,9 +256,10 @@ namespace snd_core
 					AXAUXCBCHANNELINFO* cbStruct = __AXAuxCB_auxCBStruct.GetPtr();
 					cbStruct->numChannels = drcChannelCount;
 					cbStruct->numSamples = sampleCount;
-					ppcInterpreterCurrentInstance->gpr[3] = __AXAuxCB_dataPtrs.GetMPTR();
-					ppcInterpreterCurrentInstance->gpr[4] = __AXAuxDRCCallbackUserParam[auxBusIndex + drcIndex * 3];
-					ppcInterpreterCurrentInstance->gpr[5] = __AXAuxCB_auxCBStruct.GetMPTR();
+					PPCInterpreter_t* hCPU = PPCInterpreter_getCurrentInstance();
+					hCPU->gpr[3] = __AXAuxCB_dataPtrs.GetMPTR();
+					hCPU->gpr[4] = __AXAuxDRCCallbackUserParam[auxBusIndex + drcIndex * 3];
+					hCPU->gpr[5] = __AXAuxCB_auxCBStruct.GetMPTR();
 					PPCCore_executeCallbackInternal(auxCBFuncMPTR);
 				}
 				else
@@ -287,7 +289,7 @@ namespace snd_core
 		}
 		else
 		{
-			forceLogDebug_printf("sndcore2.AXSetAuxReturnVolume() - unsupported device %d", device);
+			cemuLog_logDebug(LogType::Force, "sndcore2.AXSetAuxReturnVolume() - unsupported device {}", device);
 		}
 		return 0;
 	}
diff --git a/src/Cafe/OS/libs/snd_core/ax_exports.cpp b/src/Cafe/OS/libs/snd_core/ax_exports.cpp
index c84b4ca8..4ac0c568 100644
--- a/src/Cafe/OS/libs/snd_core/ax_exports.cpp
+++ b/src/Cafe/OS/libs/snd_core/ax_exports.cpp
@@ -8,11 +8,12 @@ namespace snd_core
 {
 	sndGeneric_t sndGeneric;
 
-	void resetToDefaultState()
+	void AXResetToDefaultState()
 	{
 		memset(&sndGeneric, 0x00, sizeof(sndGeneric));
 		resetNumProcessedFrames();
-	}
+        AXVBP_Reset();
+    }
 
 	bool AXIsInit()
 	{
@@ -77,14 +78,13 @@ namespace snd_core
 
 	void AXQuit()
 	{
-		forceLogDebug_printf("AXQuit called from 0x%08x", ppcInterpreterCurrentInstance->spr.LR);
-		// clean up
-		AXResetCallbacks();
-		AXVoiceList_ResetFreeVoiceList();
-		// todo - should we wait to make sure any active callbacks are finished with execution before we exit AXQuit?
+        AXResetCallbacks();
+        // todo - should we wait to make sure any active callbacks are finished with execution before we exit AXQuit?
+        // request worker thread stop and wait until complete
+        AXIst_StopThread();
+        // clean up subsystems
+        AXVBP_Reset();
 		sndGeneric.isInitialized = false;
-		// request worker thread stop and wait until complete
-		AXIst_StopThread();
 	}
 
 	sint32 AXGetMaxVoices()
@@ -97,7 +97,7 @@ namespace snd_core
 		ppcDefineParamS32(device, 0);
 		ppcDefineParamU32BEPtr(funcAddrPtr, 1);
 		sint32 r = AXGetDeviceFinalMixCallback(device, funcAddrPtr);
-		sndApiLog_printf("AXGetDeviceFinalMixCallback(%d,0x%08x)", hCPU->gpr[3], hCPU->gpr[4]);
+		cemuLog_log(LogType::SoundAPI, "AXGetDeviceFinalMixCallback({},0x{:08x})", hCPU->gpr[3], hCPU->gpr[4]);
 		osLib_returnFromFunction(hCPU, r);
 	}
 
@@ -105,14 +105,14 @@ namespace snd_core
 	{
 		ppcDefineParamS32(device, 0);
 		ppcDefineParamMPTR(funcAddr, 1);
-		sndApiLog_printf("AXRegisterDeviceFinalMixCallback(%d,0x%08x)", hCPU->gpr[3], hCPU->gpr[4]);
+		cemuLog_log(LogType::SoundAPI, "AXRegisterDeviceFinalMixCallback({},0x{:08x})", hCPU->gpr[3], hCPU->gpr[4]);
 		sint32 r = AXRegisterDeviceFinalMixCallback(device, funcAddr);
 		osLib_returnFromFunction(hCPU, r);
 	}
 
 	void export_AXRegisterAppFrameCallback(PPCInterpreter_t* hCPU)
 	{
-		sndApiLog_printf("AXRegisterAppFrameCallback(0x%08x)", hCPU->gpr[3]);
+		cemuLog_log(LogType::SoundAPI, "AXRegisterAppFrameCallback(0x{:08x})", hCPU->gpr[3]);
 		ppcDefineParamMPTR(funcAddr, 0);
 		sint32 r = AXRegisterAppFrameCallback(funcAddr);
 		osLib_returnFromFunction(hCPU, r);
@@ -120,7 +120,7 @@ namespace snd_core
 
 	void export_AXDeregisterAppFrameCallback(PPCInterpreter_t* hCPU)
 	{
-		sndApiLog_printf("AXDeregisterAppFrameCallback(0x%08x)", hCPU->gpr[3]);
+		cemuLog_log(LogType::SoundAPI, "AXDeregisterAppFrameCallback(0x{:08x})", hCPU->gpr[3]);
 		ppcDefineParamMPTR(funcAddr, 0);
 		sint32 r = AXDeregisterAppFrameCallback(funcAddr);
 		osLib_returnFromFunction(hCPU, r);
@@ -128,7 +128,7 @@ namespace snd_core
 
 	void export_AXRegisterFrameCallback(PPCInterpreter_t* hCPU)
 	{
-		sndApiLog_printf("AXRegisterFrameCallback(0x%08x)", hCPU->gpr[3]);
+		cemuLog_log(LogType::SoundAPI, "AXRegisterFrameCallback(0x{:08x})", hCPU->gpr[3]);
 		ppcDefineParamMPTR(funcAddr, 0);
 		sint32 r = AXRegisterFrameCallback(funcAddr);
 		osLib_returnFromFunction(hCPU, r);
@@ -136,7 +136,7 @@ namespace snd_core
 
 	void export_AXRegisterCallback(PPCInterpreter_t* hCPU)
 	{
-		sndApiLog_printf("AXRegisterCallback(0x%08x)", hCPU->gpr[3]);
+		cemuLog_log(LogType::SoundAPI, "AXRegisterCallback(0x{:08x})", hCPU->gpr[3]);
 		ppcDefineParamMPTR(funcAddr, 0);
 		sint32 r = AXRegisterFrameCallback(funcAddr);
 		osLib_returnFromFunction(hCPU, r);
@@ -144,7 +144,7 @@ namespace snd_core
 
 	void export_AXRegisterAuxCallback(PPCInterpreter_t* hCPU)
 	{
-		sndApiLog_printf("AXRegisterAuxCallback(0x%08x,0x%08x,0x%08x,0x%08x,0x%08x) LR %08x", hCPU->gpr[3], hCPU->gpr[4], hCPU->gpr[5], hCPU->gpr[6], hCPU->gpr[7], hCPU->spr.LR);
+		cemuLog_log(LogType::SoundAPI, "AXRegisterAuxCallback(0x{:08x},0x{:08x},0x{:08x},0x{:08x},0x{:08x}) LR {:08x}", hCPU->gpr[3], hCPU->gpr[4], hCPU->gpr[5], hCPU->gpr[6], hCPU->gpr[7], hCPU->spr.LR);
 		ppcDefineParamU32(device, 0);
 		ppcDefineParamU32(deviceIndex, 1);
 		ppcDefineParamU32(auxBusIndex, 2);
@@ -156,7 +156,7 @@ namespace snd_core
 
 	void export_AXGetAuxCallback(PPCInterpreter_t* hCPU)
 	{
-		sndApiLog_printf("AXGetAuxCallback(0x%08x,0x%08x,0x%08x,0x%08x,0x%08x)", hCPU->gpr[3], hCPU->gpr[4], hCPU->gpr[5], hCPU->gpr[6], hCPU->gpr[7]);
+		cemuLog_log(LogType::SoundAPI, "AXGetAuxCallback(0x{:08x},0x{:08x},0x{:08x},0x{:08x},0x{:08x})", hCPU->gpr[3], hCPU->gpr[4], hCPU->gpr[5], hCPU->gpr[6], hCPU->gpr[7]);
 		ppcDefineParamU32(device, 0);
 		ppcDefineParamU32(deviceIndex, 1);
 		ppcDefineParamU32(auxBusIndex, 2);
@@ -168,7 +168,7 @@ namespace snd_core
 
 	void export_AXSetAuxReturnVolume(PPCInterpreter_t* hCPU)
 	{
-		sndApiLog_printf("AXSetAuxReturnVolume(0x%08x,0x%08x,0x%08x,0x%04x)", hCPU->gpr[3], hCPU->gpr[4], hCPU->gpr[5], hCPU->gpr[6]);
+		cemuLog_log(LogType::SoundAPI, "AXSetAuxReturnVolume(0x{:08x},0x{:08x},0x{:08x},0x{:04x})", hCPU->gpr[3], hCPU->gpr[4], hCPU->gpr[5], hCPU->gpr[6]);
 		ppcDefineParamU32(device, 0);
 		ppcDefineParamU32(deviceIndex, 1);
 		ppcDefineParamU32(auxBusIndex, 2);
@@ -179,7 +179,7 @@ namespace snd_core
 
 	void export_AXGetDeviceMode(PPCInterpreter_t* hCPU)
 	{
-		sndApiLog_printf("AXGetDeviceMode(%d)", hCPU->gpr[3]);
+		cemuLog_log(LogType::SoundAPI, "AXGetDeviceMode({})", hCPU->gpr[3]);
 		ppcDefineParamS32(device, 0);
 		ppcDefineParamU32BEPtr(mode, 1);
 		*mode = AXGetDeviceMode(device);
@@ -188,7 +188,7 @@ namespace snd_core
 
 	void export_AXSetDeviceUpsampleStage(PPCInterpreter_t* hCPU)
 	{
-		sndApiLog_printf("AXSetDeviceUpsampleStage(%d,%d)", hCPU->gpr[3], hCPU->gpr[4]);
+		cemuLog_log(LogType::SoundAPI, "AXSetDeviceUpsampleStage({},{})", hCPU->gpr[3], hCPU->gpr[4]);
 		ppcDefineParamS32(device, 0);
 		ppcDefineParamS32(upsampleStage, 1);
 		sint32 r = AXSetDeviceUpsampleStage(device, upsampleStage);
@@ -197,7 +197,7 @@ namespace snd_core
 
 	void export_AXGetDeviceUpsampleStage(PPCInterpreter_t* hCPU)
 	{
-		sndApiLog_printf("AXGetDeviceUpsampleStage(%d,0x%08x)", hCPU->gpr[3], hCPU->gpr[4]);
+		cemuLog_log(LogType::SoundAPI, "AXGetDeviceUpsampleStage({},0x{:08x})", hCPU->gpr[3], hCPU->gpr[4]);
 		ppcDefineParamS32(device, 0);
 		ppcDefineParamU32BEPtr(upsampleStagePtr, 1);
 		sint32 r = AXGetDeviceUpsampleStage(device, upsampleStagePtr);
@@ -209,7 +209,7 @@ namespace snd_core
 		ppcDefineParamS32(priority, 0);
 		ppcDefineParamMPTR(callbackEx, 1);
 		ppcDefineParamMPTR(userParam, 2);
-		sndApiLog_printf("AXAcquireVoiceEx(%d,0x%08x,0x%08x)", priority, callbackEx, userParam);
+		cemuLog_log(LogType::SoundAPI, "AXAcquireVoiceEx({},0x{:08x},0x{:08x})", priority, callbackEx, userParam);
 		MEMPTR<AXVPB> r = AXAcquireVoiceEx(priority, callbackEx, userParam);
 		osLib_returnFromFunction(hCPU, r.GetMPTR());
 	}
@@ -219,7 +219,7 @@ namespace snd_core
 		ppcDefineParamS32(priority, 0);
 		ppcDefineParamMPTR(callback, 1);
 		ppcDefineParamMPTR(userParam, 2);
-		sndApiLog_printf("AXAcquireVoice(%d,0x%08x,0x%08x)", priority, callback, userParam);
+		cemuLog_log(LogType::SoundAPI, "AXAcquireVoice({},0x{:08x},0x{:08x})", priority, callback, userParam);
 		MEMPTR<AXVPB> r = AXAcquireVoiceEx(priority, MPTR_NULL, MPTR_NULL);
 		if (r.IsNull() == false)
 		{
@@ -232,7 +232,7 @@ namespace snd_core
 	void export_AXFreeVoice(PPCInterpreter_t* hCPU)
 	{
 		ppcDefineParamStructPtr(vpb, AXVPB, 0);
-		sndApiLog_printf("AXFreeVoice(0x%08x)", hCPU->gpr[3]);
+		cemuLog_log(LogType::SoundAPI, "AXFreeVoice(0x{:08x})", hCPU->gpr[3]);
 		AXFreeVoice(vpb);
 		osLib_returnFromFunction(hCPU, 0);
 	}
@@ -240,20 +240,20 @@ namespace snd_core
 	void export_AXUserIsProtected(PPCInterpreter_t* hCPU)
 	{
 		sint32 r = AXUserIsProtected();
-		sndApiLog_printf("AXUserIsProtected() -> %s", r!=0?"true":"false");
+		cemuLog_log(LogType::SoundAPI, "AXUserIsProtected() -> {}", r!=0?"true":"false");
 		osLib_returnFromFunction(hCPU, r);
 	}
 
 	void export_AXUserBegin(PPCInterpreter_t* hCPU)
 	{
-		sndApiLog_printf("AXUserBegin()");
+		cemuLog_log(LogType::SoundAPI, "AXUserBegin()");
 		sint32 r = AXUserBegin();
 		osLib_returnFromFunction(hCPU, r);
 	}
 
 	void export_AXUserEnd(PPCInterpreter_t* hCPU)
 	{
-		sndApiLog_printf("AXUserEnd()");
+		cemuLog_log(LogType::SoundAPI, "AXUserEnd()");
 		sint32 r = AXUserEnd();
 		osLib_returnFromFunction(hCPU, r);
 	}
@@ -261,7 +261,7 @@ namespace snd_core
 	void export_AXVoiceBegin(PPCInterpreter_t* hCPU)
 	{
 		ppcDefineParamStructPtr(vpb, AXVPB, 0);
-		sndApiLog_printf("AXVoiceBegin(0x%08x)", hCPU->gpr[3]);
+		cemuLog_log(LogType::SoundAPI, "AXVoiceBegin(0x{:08x})", hCPU->gpr[3]);
 		sint32 r = AXVoiceBegin(vpb);
 		osLib_returnFromFunction(hCPU, r);
 	}
@@ -269,7 +269,7 @@ namespace snd_core
 	void export_AXVoiceEnd(PPCInterpreter_t* hCPU)
 	{
 		ppcDefineParamStructPtr(vpb, AXVPB, 0);
-		sndApiLog_printf("AXVoiceEnd(0x%08x)", hCPU->gpr[3]);
+		cemuLog_log(LogType::SoundAPI, "AXVoiceEnd(0x{:08x})", hCPU->gpr[3]);
 		sint32 r = AXVoiceEnd(vpb);
 		osLib_returnFromFunction(hCPU, r);
 	}
@@ -277,7 +277,7 @@ namespace snd_core
 	void export_AXVoiceIsProtected(PPCInterpreter_t* hCPU)
 	{
 		ppcDefineParamStructPtr(vpb, AXVPB, 0);
-		sndApiLog_printf("AXVoiceIsProtected(0x%08x)", hCPU->gpr[3]);
+		cemuLog_log(LogType::SoundAPI, "AXVoiceIsProtected(0x{:08x})", hCPU->gpr[3]);
 		sint32 r = AXVoiceProtection_IsProtectedByCurrentThread(vpb)?1:0;
 		osLib_returnFromFunction(hCPU, r);
 	}
@@ -303,7 +303,7 @@ namespace snd_core
 
 	void export_AXCheckVoiceOffsets(PPCInterpreter_t* hCPU)
 	{
-		sndApiLog_printf("AXCheckVoiceOffsets(0x%08x)\n", hCPU->gpr[3]);
+		cemuLog_log(LogType::SoundAPI, "AXCheckVoiceOffsets(0x{:08x})", hCPU->gpr[3]);
 		ppcDefineParamStructPtr(pbOffset, AXPBOFFSET_t, 0);
 
 		uint16 format = _swapEndianU16(pbOffset->format);
@@ -328,7 +328,7 @@ namespace snd_core
 		ppcDefineParamU32(chanIn, 1);
 		ppcDefineParamU32(chanOut, 2);
 		ppcDefineParamMEMPTR(matrix, float32be, 3);
-		sndApiLog_printf("AXSetDeviceRemixMatrix(%d,%d,%d,0x%08x)", hCPU->gpr[3], hCPU->gpr[4], hCPU->gpr[5], hCPU->gpr[6]);
+		cemuLog_log(LogType::SoundAPI, "AXSetDeviceRemixMatrix({},{},{},0x{:08x})", hCPU->gpr[3], hCPU->gpr[4], hCPU->gpr[5], hCPU->gpr[6]);
 		const auto result = AXSetDeviceRemixMatrix(device, chanIn, chanOut, matrix);
 		osLib_returnFromFunction(hCPU, result);
 	}
@@ -339,7 +339,7 @@ namespace snd_core
 		ppcDefineParamU32(chanIn, 1);
 		ppcDefineParamU32(chanOut, 2);
 		ppcDefineParamMEMPTR(matrix, MEMPTR<float32be>, 3);
-		sndApiLog_printf("AXGetDeviceRemixMatrix(%d,%d,%d,0x%08x)", hCPU->gpr[3], hCPU->gpr[4], hCPU->gpr[5], hCPU->gpr[6]);
+		cemuLog_log(LogType::SoundAPI, "AXGetDeviceRemixMatrix({},{},{},0x{:08x})", hCPU->gpr[3], hCPU->gpr[4], hCPU->gpr[5], hCPU->gpr[6]);
 		const auto result = AXGetDeviceRemixMatrix(device, chanIn, chanOut, matrix);
 		osLib_returnFromFunction(hCPU, result);
 	}
@@ -500,7 +500,7 @@ namespace snd_core
 
 	void loadExports()
 	{
-		resetToDefaultState();
+        AXResetToDefaultState();
 
 		loadExportsSndCore1();
 		loadExportsSndCore2();
@@ -513,7 +513,9 @@ namespace snd_core
 
 	void reset()
 	{
-		sndGeneric.isInitialized = false;
+        AXOut_reset();
+        AXResetToDefaultState();
+        sndGeneric.isInitialized = false;
 	}
 
 }
diff --git a/src/Cafe/OS/libs/snd_core/ax_internal.h b/src/Cafe/OS/libs/snd_core/ax_internal.h
index 215b9ca7..697d7e96 100644
--- a/src/Cafe/OS/libs/snd_core/ax_internal.h
+++ b/src/Cafe/OS/libs/snd_core/ax_internal.h
@@ -150,23 +150,7 @@ namespace snd_core
 			/* +0x1E4 */ uint16 a1;
 			/* +0x1E6 */ uint16 a2;
 		}biquad;
-		uint16 reserved1E8[1];
-		uint16 reserved1EA;
-		uint16 reserved1EC;
-		uint16 reserved1EE;
-		uint32 reserved1F0[4];
-		uint16 reserved200;
-		uint16 reserved202;
-		uint16 reserved204;
-		uint16 reserved206;
-		uint16 reserved208;
-		uint16 reserved20A;
-		uint16 reserved20C;
-		uint16 reserved20E;
-		uint16 reserved210;
-		uint16 reserved212;
-		uint16 reserved214;
-		uint16 reserved216;
+		uint16 reserved1E8[0x18];
 		uint16 reserved218[0x20]; // not related to device mix?
 		uint16 reserved258[0x10]; // not related to device mix?
 		// rmt src related
@@ -210,7 +194,6 @@ namespace snd_core
 
 	std::vector<AXVPB*>& AXVoiceList_GetListByPriority(uint32 priority);
 	std::vector<AXVPB*>& AXVoiceList_GetFreeVoices();
-	void AXVoiceList_ResetFreeVoiceList();
 
 	inline AXVPBInternal_t* GetInternalVoice(const AXVPB* vpb)
 	{
@@ -222,6 +205,8 @@ namespace snd_core
 		return (uint32)vpb->index;
 	}
 
+    void AXVBP_Reset();
+
 	// AXIst
 	void AXIst_InitThread();
 	OSThread_t* AXIst_GetThread();
diff --git a/src/Cafe/OS/libs/snd_core/ax_ist.cpp b/src/Cafe/OS/libs/snd_core/ax_ist.cpp
index 26f975af..2ea27cbb 100644
--- a/src/Cafe/OS/libs/snd_core/ax_ist.cpp
+++ b/src/Cafe/OS/libs/snd_core/ax_ist.cpp
@@ -218,21 +218,36 @@ namespace snd_core
 		// validate parameters
 		if (deviceId == AX_DEV_TV)
 		{
-			cemu_assert(inputChannelCount <= AX_TV_CHANNEL_COUNT);
-			cemu_assert(outputChannelCount == 1 || outputChannelCount == 2 || outputChannelCount == 6);
+			if(inputChannelCount > AX_TV_CHANNEL_COUNT)
+			{
+				cemuLog_log(LogType::APIErrors, "AXSetDeviceRemixMatrix: Input channel count must be smaller or equal to 6 for TV device");
+				return -7;
+			}
+			if(outputChannelCount != 1 && outputChannelCount != 2 && outputChannelCount != 6)
+			{
+				// seems like Watch Dogs uses 4 as outputChannelCount for some reason?
+				cemuLog_log(LogType::APIErrors, "AXSetDeviceRemixMatrix: Output channel count must be 1, 2 or 6 for TV device");
+				return -8;
+			}
 		}
 		else if (deviceId == AX_DEV_DRC)
 		{
-			cemu_assert(inputChannelCount <= AX_DRC_CHANNEL_COUNT);
-			cemu_assert(outputChannelCount == 1 || outputChannelCount == 2 || outputChannelCount == 4);
-		}
-		else if (deviceId == AX_DEV_RMT)
-		{
-			cemu_assert(false);
+			if(inputChannelCount > AX_DRC_CHANNEL_COUNT)
+			{
+				cemuLog_log(LogType::APIErrors, "AXSetDeviceRemixMatrix: Input channel count must be smaller or equal to 4 for DRC device");
+				return -7;
+			}
+			if(outputChannelCount != 1 && outputChannelCount != 2 && outputChannelCount != 4)
+			{
+				cemuLog_log(LogType::APIErrors, "AXSetDeviceRemixMatrix: Output channel count must be 1, 2 or 4 for DRC device");
+				return -8;
+			}
 		}
 		else
+		{
+			cemuLog_log(LogType::APIErrors, "AXSetDeviceRemixMatrix: Only TV (0) and DRC (1) device are supported");
 			return -1;
-
+		}
 		auto matrices = g_remix_matrices.GetPtr();
 
 		// test if we already have an entry and just need to update the matrix data
@@ -778,7 +793,7 @@ namespace snd_core
 
 	void AXIst_SyncVPB(AXVPBInternal_t** lastProcessedDSPShadowCopy, AXVPBInternal_t** lastProcessedPPCShadowCopy)
 	{
-		__AXVoiceListSpinlock.acquire();
+		__AXVoiceListSpinlock.lock();
 
 		AXVPBInternal_t* previousInternalDSP = nullptr;
 		AXVPBInternal_t* previousInternalPPC = nullptr;
@@ -869,7 +884,7 @@ namespace snd_core
 			else
 				*lastProcessedPPCShadowCopy = nullptr;
 		}
-		__AXVoiceListSpinlock.release();
+		__AXVoiceListSpinlock.unlock();
 	}
 
 	void AXIst_HandleFrameCallbacks()
@@ -958,11 +973,12 @@ namespace snd_core
 
 	void AXIst_InitThread()
 	{
+        __AXIstIsProcessingFrame = false;
 		// create ist message queue
 		OSInitMessageQueue(__AXIstThreadMsgQueue.GetPtr(), __AXIstThreadMsgArray.GetPtr(), 0x10);
 		// create thread
 		uint8 istThreadAttr = 0;
-		coreinit::OSCreateThreadType(__AXIstThread.GetPtr(), PPCInterpreter_makeCallableExportDepr(AXIst_ThreadEntry), 0, &__AXIstThreadMsgQueue, __AXIstThreadStack.GetPtr() + 0x4000, 0x4000, 14, istThreadAttr, OSThread_t::THREAD_TYPE::TYPE_DRIVER);
+		coreinit::__OSCreateThreadType(__AXIstThread.GetPtr(), PPCInterpreter_makeCallableExportDepr(AXIst_ThreadEntry), 0, &__AXIstThreadMsgQueue, __AXIstThreadStack.GetPtr() + 0x4000, 0x4000, 14, istThreadAttr, OSThread_t::THREAD_TYPE::TYPE_DRIVER);
 		coreinit::OSResumeThread(__AXIstThread.GetPtr());
 	}
 
@@ -1012,7 +1028,7 @@ namespace snd_core
 			OSReceiveMessage(__AXIstThreadMsgQueue.GetPtr(), msg.GetPointer(), OS_MESSAGE_BLOCK);
 			if (msg.GetPointer()->message == 2)
 			{
-				forceLogDebug_printf("Shut down of AX thread requested");
+				cemuLog_logDebug(LogType::Force, "Shut down of AX thread requested");
 				coreinit::OSExitThread(0);
 				break;
 			}
@@ -1053,4 +1069,4 @@ namespace snd_core
 	{
 		return __AXIstIsProcessingFrame.load();
 	}
-}
\ No newline at end of file
+}
diff --git a/src/Cafe/OS/libs/snd_core/ax_mix.cpp b/src/Cafe/OS/libs/snd_core/ax_mix.cpp
index 8e959b28..3fdca1ff 100644
--- a/src/Cafe/OS/libs/snd_core/ax_mix.cpp
+++ b/src/Cafe/OS/libs/snd_core/ax_mix.cpp
@@ -262,7 +262,7 @@ namespace snd_core
 		if (numberOfDecodedAdpcmSamples >= 4096)
 		{
 			memset(output, 0, sizeof(float)*sampleCount);
-			forceLog_printf("Too many ADPCM samples to decode. ratio = %08x", ratio);
+			cemuLog_log(LogType::Force, "Too many ADPCM samples to decode. ratio = {:08x}", ratio);
 			return;
 		}
 		AX_readADPCMSamples(internalShadowCopy, adpcmSampleBuffer, numberOfDecodedAdpcmSamples);
@@ -692,10 +692,10 @@ namespace snd_core
 	{
 		if (internalShadowCopy->biquad.on == AX_BIQUAD_OFF)
 			return;
-#ifndef PUBLIC_RELEASE
+#ifdef CEMU_DEBUG_ASSERT
 		if (internalShadowCopy->biquad.on != 0x0200)
 		{
-			forceLogDebug_printf("AX_ApplyBiquad() with incorrect biquad.on value 0x%04x", _swapEndianU16(internalShadowCopy->biquad.on));
+			cemuLog_logDebug(LogType::Force, "AX_ApplyBiquad() with incorrect biquad.on value 0x{:04x}", _swapEndianU16(internalShadowCopy->biquad.on));
 		}
 #endif
 
diff --git a/src/Cafe/OS/libs/snd_core/ax_out.cpp b/src/Cafe/OS/libs/snd_core/ax_out.cpp
index 85a94e52..fe32cfb4 100644
--- a/src/Cafe/OS/libs/snd_core/ax_out.cpp
+++ b/src/Cafe/OS/libs/snd_core/ax_out.cpp
@@ -396,90 +396,35 @@ namespace snd_core
 
 	void AXOut_init()
 	{
-		auto& config = GetConfig();
-		const auto audio_api = (IAudioAPI::AudioAPI)config.audio_api;
 
 		numQueuedFramesSndGeneric = 0;
 
 		std::unique_lock lock(g_audioMutex);
 		if (!g_tvAudio)
 		{
-			sint32 channels;
-			switch (config.tv_channels)
+			try
 			{
-			case 0:
-				channels = 1; // will mix mono sound on both output channels
-				break;
-			case 2:
-				channels = 6;
-				break;
-			default: // stereo
-				channels = 2;
-				break;
+				g_tvAudio = IAudioAPI::CreateDeviceFromConfig(IAudioAPI::AudioType::TV, 48000, snd_core::AX_SAMPLES_PER_3MS_48KHZ * AX_FRAMES_PER_GROUP, 16);
 			}
-
-			IAudioAPI::DeviceDescriptionPtr device_description;
-			if (IAudioAPI::IsAudioAPIAvailable(audio_api))
+			catch (std::runtime_error& ex)
 			{
-				auto devices = IAudioAPI::GetDevices(audio_api);
-				const auto it = std::find_if(devices.begin(), devices.end(), [&config](const auto& d) {return d->GetIdentifier() == config.tv_device; });
-				if (it != devices.end())
-					device_description = *it;
-			}
-
-			if (device_description)
-			{
-				try
-				{
-					g_tvAudio = IAudioAPI::CreateDevice((IAudioAPI::AudioAPI)config.audio_api, device_description, 48000, channels, snd_core::AX_SAMPLES_PER_3MS_48KHZ * AX_FRAMES_PER_GROUP, 16);
-					g_tvAudio->SetVolume(config.tv_volume);
-				}
-				catch (std::runtime_error& ex)
-				{
-					forceLog_printf("can't initialize tv audio: %s", ex.what());
-					exit(0);
-				}
+				cemuLog_log(LogType::Force, "can't initialize tv audio: {}", ex.what());
+				exit(0);
 			}
 		}
 
 		if (!g_padAudio)
 		{
-			sint32 channels;
-			switch (config.pad_channels)
+			try
 			{
-			case 0:
-				channels = 1; // will mix mono sound on both output channels
-				break;
-			case 2:
-				channels = 6;
-				break;
-			default: // stereo
-				channels = 2;
-				break;
+				g_padAudio = IAudioAPI::CreateDeviceFromConfig(IAudioAPI::AudioType::Gamepad, 48000, snd_core::AX_SAMPLES_PER_3MS_48KHZ * AX_FRAMES_PER_GROUP, 16);
+				if(g_padAudio)
+					g_padVolume = g_padAudio->GetVolume();
 			}
-
-			IAudioAPI::DeviceDescriptionPtr device_description;
-			if (IAudioAPI::IsAudioAPIAvailable(audio_api))
+			catch (std::runtime_error& ex)
 			{
-				auto devices = IAudioAPI::GetDevices(audio_api);
-				const auto it = std::find_if(devices.begin(), devices.end(), [&config](const auto& d) {return d->GetIdentifier() == config.pad_device; });
-				if (it != devices.end())
-					device_description = *it;
-			}
-
-			if (device_description)
-			{
-				try
-				{
-					g_padAudio = IAudioAPI::CreateDevice((IAudioAPI::AudioAPI)config.audio_api, device_description, 48000, channels, snd_core::AX_SAMPLES_PER_3MS_48KHZ * AX_FRAMES_PER_GROUP, 16);
-					g_padAudio->SetVolume(config.pad_volume);
-					g_padVolume = config.pad_volume;
-				}
-				catch (std::runtime_error& ex)
-				{
-					forceLog_printf("can't initialize pad audio: %s", ex.what());
-					exit(0);
-				}
+				cemuLog_log(LogType::Force, "can't initialize pad audio: {}", ex.what());
+				exit(0);
 			}
 		}
 	}
@@ -497,6 +442,11 @@ namespace snd_core
 			g_padAudio->Stop();
 			g_padAudio.reset();
 		}
+		if (g_portalAudio)
+		{
+			g_portalAudio->Stop();
+			g_portalAudio.reset();
+		}
 	}
 
 	void AXOut_updateDevicePlayState(bool isPlaying)
@@ -517,15 +467,23 @@ namespace snd_core
 			else
 				g_padAudio->Stop();
 		}
+
+		if (g_portalAudio)
+		{
+			if (isPlaying)
+				g_portalAudio->Play();
+			else
+				g_portalAudio->Stop();
+		}
 	}
 
 	// called periodically to check for AX updates
 	void AXOut_update()
 	{
-		constexpr auto kTimeout = std::chrono::duration_cast<std::chrono::nanoseconds>(std::chrono::milliseconds(((IAudioAPI::kBlockCount * 3) / 4) * (AX_FRAMES_PER_GROUP * 3)));
-		constexpr auto kWaitDuration = std::chrono::duration_cast<std::chrono::nanoseconds>(std::chrono::milliseconds(3));
-		constexpr auto kWaitDurationFast = std::chrono::duration_cast<std::chrono::nanoseconds>(std::chrono::microseconds(2900));
-		constexpr auto kWaitDurationMinimum = std::chrono::duration_cast<std::chrono::nanoseconds>(std::chrono::microseconds(1700));
+		constexpr static auto kTimeout = std::chrono::duration_cast<std::chrono::nanoseconds>(std::chrono::milliseconds(((IAudioAPI::kBlockCount * 3) / 4) * (AX_FRAMES_PER_GROUP * 3)));
+		constexpr static auto kWaitDuration = std::chrono::duration_cast<std::chrono::nanoseconds>(std::chrono::milliseconds(3));
+		constexpr static auto kWaitDurationFast = std::chrono::duration_cast<std::chrono::nanoseconds>(std::chrono::microseconds(2900));
+		constexpr static auto kWaitDurationMinimum = std::chrono::duration_cast<std::chrono::nanoseconds>(std::chrono::microseconds(1700));
 
 		// if we haven't buffered any blocks, we will wait less time than usual
 		bool additional_blocks_required = false;
@@ -574,4 +532,4 @@ namespace snd_core
 		}
 	}
 
-}
\ No newline at end of file
+}
diff --git a/src/Cafe/OS/libs/snd_core/ax_voice.cpp b/src/Cafe/OS/libs/snd_core/ax_voice.cpp
index f60e5853..877eecab 100644
--- a/src/Cafe/OS/libs/snd_core/ax_voice.cpp
+++ b/src/Cafe/OS/libs/snd_core/ax_voice.cpp
@@ -3,6 +3,7 @@
 #include "Cafe/HW/Espresso/PPCCallback.h"
 #include "Cafe/OS/libs/snd_core/ax.h"
 #include "Cafe/OS/libs/snd_core/ax_internal.h"
+#include "Cafe/OS/libs/coreinit/coreinit_Thread.h"
 #include "util/helpers/fspinlock.h"
 
 namespace snd_core
@@ -40,11 +41,6 @@ namespace snd_core
 		return vpb;
 	}
 
-	void AXVoiceList_ResetFreeVoiceList()
-	{
-		__AXFreeVoices.clear();
-	}
-
 	std::vector<AXVPB*>& AXVoiceList_GetFreeVoices()
 	{
 		return __AXFreeVoices;
@@ -80,6 +76,13 @@ namespace snd_core
 		return __AXVoicesPerPriority[priority];
 	}
 
+    void AXVoiceList_Reset()
+    {
+        __AXFreeVoices.clear();
+        for (uint32 i = 0; i < AX_PRIORITY_MAX; i++)
+            __AXVoicesPerPriority[i].clear();
+    }
+
 	SysAllocator<AXVPBInternal_t, AX_MAX_VOICES> _buffer__AXVPBInternalVoiceArray;
 	AXVPBInternal_t* __AXVPBInternalVoiceArray;
 
@@ -118,7 +121,7 @@ namespace snd_core
 		{
 			return -2;
 		}
-		MPTR currentThreadMPTR = coreinitThread_getCurrentThreadMPTRDepr(ppcInterpreterCurrentInstance);
+		MPTR currentThreadMPTR = memory_getVirtualOffsetFromPointer(coreinit::OSGetCurrentThread());
 		for (sint32 i = __AXUserProtectionArraySize - 1; i >= 0; i--)
 		{
 			if (__AXUserProtectionArray[i].threadMPTR == currentThreadMPTR)
@@ -149,7 +152,7 @@ namespace snd_core
 		PPCCore_deboostQuantum(10000);
 		if (AXIst_IsFrameBeingProcessed())
 			return -2;
-		MPTR currentThreadMPTR = coreinitThread_getCurrentThreadMPTRDepr(ppcInterpreterCurrentInstance);
+		MPTR currentThreadMPTR = memory_getVirtualOffsetFromPointer(coreinit::OSGetCurrentThread());
 		for (sint32 i = __AXUserProtectionArraySize - 1; i >= 0; i--)
 		{
 			if (__AXUserProtectionArray[i].threadMPTR == currentThreadMPTR)
@@ -204,7 +207,7 @@ namespace snd_core
 		if (AXIst_IsFrameBeingProcessed())
 			isProtected = __AXVoiceProtection[index].threadMPTR != MPTR_NULL;
 		else
-			isProtected = __AXVoiceProtection[index].threadMPTR != coreinitThread_getCurrentThreadMPTRDepr(ppcInterpreterCurrentInstance);
+			isProtected = __AXVoiceProtection[index].threadMPTR != memory_getVirtualOffsetFromPointer(coreinit::OSGetCurrentThread());
 		return isProtected;
 	}
 
@@ -217,7 +220,7 @@ namespace snd_core
 			return;
 		if (__AXVoiceProtection[index].threadMPTR == MPTR_NULL)
 		{
-			__AXVoiceProtection[index].threadMPTR = coreinitThread_getCurrentThreadMPTRDepr(ppcInterpreterCurrentInstance);
+			__AXVoiceProtection[index].threadMPTR = memory_getVirtualOffsetFromPointer(coreinit::OSGetCurrentThread());
 			// does not set count?
 		}
 	}
@@ -233,18 +236,18 @@ namespace snd_core
 	{
 		if (voice == nullptr)
 		{
-			forceLog_printf("AXVoiceBegin(): Invalid voice");
+			cemuLog_log(LogType::Force, "AXVoiceBegin(): Invalid voice");
 			return -1;
 		}
 		uint32 index = (uint32)voice->index;
 		if (index >= AX_MAX_VOICES)
 		{
-			forceLog_printf("AXVoiceBegin(): Invalid voice index");
+			cemuLog_log(LogType::Force, "AXVoiceBegin(): Invalid voice index");
 			return -1;
 		}
 		if (AXIst_IsFrameBeingProcessed())
 			return -2;
-		MPTR currentThreadMPTR = coreinitThread_getCurrentThreadMPTRDepr(ppcInterpreterCurrentInstance);
+		MPTR currentThreadMPTR = memory_getVirtualOffsetFromPointer(coreinit::OSGetCurrentThread());
 		if (__AXVoiceProtection[index].threadMPTR == MPTR_NULL)
 		{
 			__AXVoiceProtection[index].threadMPTR = currentThreadMPTR;
@@ -273,18 +276,18 @@ namespace snd_core
 	{
 		if (voice == nullptr)
 		{
-			forceLog_printf("AXVoiceBegin(): Invalid voice");
+			cemuLog_log(LogType::Force, "AXVoiceBegin(): Invalid voice");
 			return -1;
 		}
 		uint32 index = (uint32)voice->index;
 		if (index >= AX_MAX_VOICES)
 		{
-			forceLog_printf("AXVoiceBegin(): Invalid voice index");
+			cemuLog_log(LogType::Force, "AXVoiceBegin(): Invalid voice index");
 			return -1;
 		}
 		if (AXIst_IsFrameBeingProcessed())
 			return -2;
-		MPTR currentThreadMPTR = coreinitThread_getCurrentThreadMPTRDepr(ppcInterpreterCurrentInstance);
+		MPTR currentThreadMPTR = memory_getVirtualOffsetFromPointer(coreinit::OSGetCurrentThread());
 		if (__AXVoiceProtection[index].threadMPTR == currentThreadMPTR)
 		{
 			if (__AXVoiceProtection[index].count > 0)
@@ -365,7 +368,7 @@ namespace snd_core
 				// get last voice in chain
 				while (voiceItr->next)
 					voiceItr = voiceItr->next.GetPtr();
-				forceLogDebug_printf("Dropped voice %d", (uint32)voiceItr->index);
+				cemuLog_logDebug(LogType::Force, "Dropped voice {}", (uint32)voiceItr->index);
 				// drop voice
 				if (voiceItr->playbackState != 0)
 				{
@@ -393,7 +396,7 @@ namespace snd_core
 	AXVPB* AXAcquireVoiceEx(uint32 priority, MPTR callbackEx, MPTR userParam)
 	{
 		cemu_assert(priority != AX_PRIORITY_FREE && priority < AX_PRIORITY_MAX);
-		__AXVoiceListSpinlock.acquire();
+		__AXVoiceListSpinlock.lock();
 		AXVPB* vpb = AXVoiceList_GetFreeVoice();
 		if (vpb != nullptr)
 		{
@@ -410,7 +413,7 @@ namespace snd_core
 			if (droppedVoice == nullptr)
 			{
 				// no voice available
-				__AXVoiceListSpinlock.release();
+				__AXVoiceListSpinlock.unlock();
 				return nullptr;
 			}
 			vpb->userParam = userParam;
@@ -418,18 +421,18 @@ namespace snd_core
 			vpb->callbackEx = callbackEx;
 			AXVPB_SetVoiceDefault(vpb);
 		}
-		__AXVoiceListSpinlock.release();
+		__AXVoiceListSpinlock.unlock();
 		return vpb;
 	}
 
 	void AXFreeVoice(AXVPB* vpb)
 	{
 		cemu_assert(vpb != nullptr);
-		__AXVoiceListSpinlock.acquire();
+		__AXVoiceListSpinlock.lock();
 		if (vpb->priority == (uint32be)AX_PRIORITY_FREE)
 		{
-			forceLog_printf("AXFreeVoice() called on free voice\n");
-			__AXVoiceListSpinlock.release();
+			cemuLog_log(LogType::Force, "AXFreeVoice() called on free voice");
+			__AXVoiceListSpinlock.unlock();
 			return;
 		}
 		AXVoiceProtection_Release(vpb);
@@ -442,17 +445,25 @@ namespace snd_core
 		vpb->callback = MPTR_NULL;
 		vpb->callbackEx = MPTR_NULL;
 		AXVoiceList_AddFreeVoice(vpb);
-		__AXVoiceListSpinlock.release();
+		__AXVoiceListSpinlock.unlock();
 	}
 
+    void __AXVPBResetVoices()
+    {
+        __AXVPBInternalVoiceArray = _buffer__AXVPBInternalVoiceArray.GetPtr();
+        __AXVPBInternalVoiceShadowCopyArrayPtr = _buffer__AXVPBInternalVoiceShadowCopyArray.GetPtr();
+        __AXVPBArrayPtr = _buffer__AXVPBArray.GetPtr();
+        __AXVPBItdArrayPtr = _buffer__AXVPBItdArray.GetPtr();
+
+        memset(__AXVPBInternalVoiceShadowCopyArrayPtr, 0, sizeof(AXVPBInternal_t)*AX_MAX_VOICES);
+        memset(__AXVPBInternalVoiceArray, 0, sizeof(AXVPBInternal_t)*AX_MAX_VOICES);
+        memset(__AXVPBItdArrayPtr, 0, sizeof(AXVPBItd)*AX_MAX_VOICES);
+        memset(__AXVPBArrayPtr, 0, sizeof(AXVPB)*AX_MAX_VOICES);
+    }
+
 	void AXVPBInit()
 	{
-		__AXVPBInternalVoiceArray = _buffer__AXVPBInternalVoiceArray.GetPtr();
-
-		memset(__AXVPBInternalVoiceShadowCopyArrayPtr, 0, sizeof(AXVPBInternal_t)*AX_MAX_VOICES);
-		memset(__AXVPBInternalVoiceArray, 0, sizeof(AXVPBInternal_t)*AX_MAX_VOICES);
-		memset(__AXVPBItdArrayPtr, 0, sizeof(AXVPBItd)*AX_MAX_VOICES);
-		memset(__AXVPBArrayPtr, 0, sizeof(AXVPB)*AX_MAX_VOICES);
+        __AXVPBResetVoices();
 		for (sint32 i = 0; i < AX_MAX_VOICES; i++)
 		{
 			AXVPBItd* itd = __AXVPBItdArrayPtr + i;
@@ -494,12 +505,16 @@ namespace snd_core
 
 	void AXVPB_Init()
 	{
-		__AXVPBInternalVoiceShadowCopyArrayPtr = _buffer__AXVPBInternalVoiceShadowCopyArray.GetPtr();
-		__AXVPBArrayPtr = _buffer__AXVPBArray.GetPtr();
-		__AXVPBItdArrayPtr = _buffer__AXVPBItdArray.GetPtr();
+		__AXVPBResetVoices();
 		AXVPBInit();
 	}
 
+    void AXVBP_Reset()
+    {
+        AXVoiceList_Reset();
+        __AXVPBResetVoices();
+    }
+
 	sint32 AXIsValidDevice(sint32 device, sint32 deviceIndex)
 	{
 		if (device == AX_DEV_TV)
@@ -692,7 +707,7 @@ namespace snd_core
 		}
 		else
 		{
-			forceLog_printf("AXSetVoiceSrcType(): Unsupported src type %d", srcType);
+			cemuLog_log(LogType::Force, "AXSetVoiceSrcType(): Unsupported src type {}", srcType);
 		}
 		AXSetSyncFlag(vpb, AX_SYNCFLAG_SRCFILTER);
 		AXVoiceProtection_Acquire(vpb);
@@ -702,7 +717,7 @@ namespace snd_core
 	{
 		AXVPBInternal_t* internal = __AXVPBInternalVoiceArray + (sint32)vpb->index;
 		ratio *= 65536.0f;
-#ifndef PUBLIC_RELEASE
+#ifdef CEMU_DEBUG_ASSERT
 		if (ratio >= 4294967296.0f)
 			assert_dbg();
 #endif
@@ -843,7 +858,7 @@ namespace snd_core
 		MPTR sampleBase = _swapEndianU32(pbOffset->samples);
 		if (sampleBase == MPTR_NULL)
 		{
-			forceLog_printf("AXSetVoiceOffsets(): Invalid sample address");
+			cemuLog_log(LogType::Force, "AXSetVoiceOffsets(): Invalid sample address");
 			cemu_assert_debug(false);
 			return;
 		}
@@ -1004,7 +1019,7 @@ namespace snd_core
 		{
 			cemu_assert_debug(false);
 		}
-		sndApiLog_printf("Retrieved voice offsets for voice %08x - base %08x current %08x loopFlag %04x loop %08x end %08x", memory_getVirtualOffsetFromPointer(vpb), _swapEndianU32(pbOffset->samples), _swapEndianU32(pbOffset->currentOffset), _swapEndianU16(pbOffset->loopFlag), _swapEndianU32(pbOffset->loopOffset), _swapEndianU32(pbOffset->endOffset));
+		cemuLog_log(LogType::SoundAPI, "Retrieved voice offsets for voice {:08x} - base {:08x} current {:08x} loopFlag {:04x} loop {:08x} end {:08x}", memory_getVirtualOffsetFromPointer(vpb), _swapEndianU32(pbOffset->samples), _swapEndianU32(pbOffset->currentOffset), _swapEndianU16(pbOffset->loopFlag), _swapEndianU32(pbOffset->loopOffset), _swapEndianU32(pbOffset->endOffset));
 	}
 
 	void AXGetVoiceOffsetsEx(AXVPB* vpb, AXPBOFFSET_t* pbOffset, MPTR sampleBase)
@@ -1283,4 +1298,4 @@ namespace snd_core
 		cafeExportRegister("sndcore2", AXGetVoiceOffsets, LogType::SoundAPI);
 		cafeExportRegister("sndcore2", AXGetVoiceCurrentOffsetEx, LogType::SoundAPI);
 	}
-}
\ No newline at end of file
+}
diff --git a/src/Cafe/OS/libs/snd_user/snd_user.cpp b/src/Cafe/OS/libs/snd_user/snd_user.cpp
index f8a567ce..4b884f68 100644
--- a/src/Cafe/OS/libs/snd_user/snd_user.cpp
+++ b/src/Cafe/OS/libs/snd_user/snd_user.cpp
@@ -247,7 +247,7 @@ namespace snd
 			channel->drc_control[index].fader = 0;
 			channel->drc_control[index].lfe = -960;
 
-			for (size_t i = 0; i < AX_MAX_NUM_BUS; ++i)
+			for (size_t i = 0; i < AX_AUX_BUS_COUNT; ++i)
 			{
 				channel->drc_control[index].aux[i] = -960;
 			}
@@ -272,7 +272,7 @@ namespace snd
 			channel->rmt_control[index].fader = 0;
 			channel->rmt_control[index].lfe = -960;
 
-			for (size_t i = 0; i < AX_MAX_NUM_BUS; ++i)
+			for (size_t i = 0; i < AX_AUX_BUS_COUNT; ++i)
 			{
 				channel->rmt_control[index].aux[i] = -960;
 			}
@@ -367,7 +367,7 @@ namespace snd
 
 		void MIXInit()
 		{
-			sndApiLog_printf("MIXInit()");
+			cemuLog_log(LogType::SoundAPI, "MIXInit()");
 
 			if (g_snd_user_data.initialized)
 				return;
@@ -388,7 +388,7 @@ namespace snd
 
 		void MIXSetSoundMode(uint32 sound_mode)
 		{
-			sndApiLog_printf("MIXSetSoundMode(0x%x)", sound_mode);
+			cemuLog_log(LogType::SoundAPI, "MIXSetSoundMode(0x{:x})", sound_mode);
 
 			if (sound_mode >= 2)
 				sound_mode = 1;
@@ -398,7 +398,7 @@ namespace snd
 
 		uint32 MIXGetSoundMode()
 		{
-			sndApiLog_printf("MIXGetSoundMode()");
+			cemuLog_log(LogType::SoundAPI, "MIXGetSoundMode()");
 			return g_snd_user_data.device_info.tv_sound_mode;
 		}
 
@@ -548,7 +548,7 @@ namespace snd
 
 		void MIXInitChannel(AXVPB* voice, uint16 mode, uint16 input, uint16 aux1, uint16 aux2, uint16 aux3, uint16 pan, uint16 span, uint16 fader)
 		{
-			sndApiLog_printf("MIXInitChannel(0x%x, 0x%x, 0x%x, 0x%x, 0x%x, 0x%x, 0x%x, 0x%x, 0x%x)", MEMPTR(voice).GetMPTR(), mode, input, aux1, aux2, aux3, pan, span, fader);
+			cemuLog_log(LogType::SoundAPI, "MIXInitChannel(0x{:x}, 0x{:x}, 0x{:x}, 0x{:x}, 0x{:x}, 0x{:x}, 0x{:x}, 0x{:x}, 0x{:x})", MEMPTR(voice).GetMPTR(), mode, input, aux1, aux2, aux3, pan, span, fader);
 			cemu_assert_debug(voice);
 
 			AXVoiceBegin(voice);
@@ -579,7 +579,7 @@ namespace snd
 
 		void MIXAssignChannel(AXVPB* voice)
 		{
-			sndApiLog_printf("MIXAssignChannel(0x%x)", MEMPTR(voice).GetMPTR());
+			cemuLog_log(LogType::SoundAPI, "MIXAssignChannel(0x{:x})", MEMPTR(voice).GetMPTR());
 			cemu_assert_debug(voice);
 
 			AXVoiceBegin(voice);
@@ -594,7 +594,7 @@ namespace snd
 
 		void MIXDRCInitChannel(AXVPB* voice, uint16 mode, uint16 vol1, uint16 vol2, uint16 vol3)
 		{
-			sndApiLog_printf("MIXDRCInitChannel(0x%x, 0x%x, 0x%x, 0x%x)", MEMPTR(voice).GetMPTR(), mode, vol1, vol2, vol3);
+			cemuLog_log(LogType::SoundAPI, "MIXDRCInitChannel(0x{:x}, 0x{:x}, 0x{:x}, 0x{:x}, 0x{:x})", MEMPTR(voice).GetMPTR(), mode, vol1, vol2, vol3);
 			cemu_assert_debug(voice);
 
 			AXVoiceBegin(voice);
@@ -619,7 +619,7 @@ namespace snd
 
 		void MIXSetInput(AXVPB* voice, uint16 input)
 		{
-			sndApiLog_printf("MIXSetInput(0x%x, 0x%x)", MEMPTR(voice).GetMPTR(), input);
+			cemuLog_log(LogType::SoundAPI, "MIXSetInput(0x{:x}, 0x{:x})", MEMPTR(voice).GetMPTR(), input);
 
 			const uint32 voice_index = voice->index;
 			const auto channel = &g_snd_user_data.mix_channel[voice_index];
@@ -631,7 +631,7 @@ namespace snd
 
 		void MIXUpdateSettings()
 		{
-			sndApiLog_printf("MIXUpdateSettings()");
+			cemuLog_log(LogType::SoundAPI, "MIXUpdateSettings()");
 
 			if (!g_snd_user_data.initialized)
 				return;
@@ -705,7 +705,7 @@ namespace snd
 
 		void MIXSetDeviceSoundMode(uint32 device, uint32 mode)
 		{
-			sndApiLog_printf("MIXSetDeviceSoundMode(0x%x, 0x%x)", device, mode);
+			cemuLog_log(LogType::SoundAPI, "MIXSetDeviceSoundMode(0x{:x}, 0x{:x})", device, mode);
 			cemu_assert_debug(device < AX_DEV_COUNT);
 			cemu_assert_debug(mode <= 4);
 
@@ -729,7 +729,7 @@ namespace snd
 			}
 			else
 			{
-				sndApiLog_printf("ERROR: MIXSetDeviceSoundMode(0x%x, 0x%x) -> wrong device", device, mode);
+				cemuLog_log(LogType::SoundAPI, "ERROR: MIXSetDeviceSoundMode(0x{:x}, 0x{:x}) -> wrong device", device, mode);
 			}
 
 			for (sint32 i = 0; i < g_snd_user_data.max_voices; ++i)
@@ -762,7 +762,7 @@ namespace snd
 
 		void MIXInitDeviceControl(AXVPB* voice, uint32 device_type, uint32 index, MixControl* control, uint32 mode)
 		{
-			sndApiLog_printf("MIXInitDeviceControl(0x%0x, 0x%x, 0x%x, 0x%x, 0x%x )", MEMPTR(voice).GetMPTR(), device_type, index, MEMPTR(control).GetMPTR(), mode);
+			cemuLog_log(LogType::SoundAPI, "MIXInitDeviceControl(0x{:0x}, 0x{:x}, 0x{:x}, 0x{:x}, 0x{:x} )", MEMPTR(voice).GetMPTR(), device_type, index, MEMPTR(control).GetMPTR(), mode);
 
 			cemu_assert_debug(device_type < AX_DEV_COUNT);
 			cemu_assert_debug(voice);
@@ -815,7 +815,7 @@ namespace snd
 
 		void MIXInitInputControl(AXVPB* voice, uint16 input, uint32 mode)
 		{
-			sndApiLog_printf("MIXInitInputControl(0x%x, 0x%x, 0x%x )", MEMPTR(voice).GetMPTR(), input, mode);
+			cemuLog_log(LogType::SoundAPI, "MIXInitInputControl(0x{:x}, 0x{:x}, 0x{:x} )", MEMPTR(voice).GetMPTR(), input, mode);
 			cemu_assert_debug(voice);
 
 			AXVoiceBegin(voice);
@@ -920,7 +920,7 @@ namespace snd
 
 		void SPInitSoundTable(SPSoundTable* soundTable, uint8* samples, uint32be* endOffsetPtr)
 		{
-			sndApiLog_printf("SPInitSoundTable(0x%x, 0x%x, 0x%x )", MEMPTR(soundTable).GetMPTR(), MEMPTR(samples).GetMPTR(), MEMPTR(endOffsetPtr).GetMPTR());
+			cemuLog_log(LogType::SoundAPI, "SPInitSoundTable(0x{:x}, 0x{:x}, 0x{:x} )", MEMPTR(soundTable).GetMPTR(), MEMPTR(samples).GetMPTR(), MEMPTR(endOffsetPtr).GetMPTR());
 			if (!soundTable)
 				return;
 
@@ -984,7 +984,7 @@ namespace snd
 
 		SPSoundEntry* SPGetSoundEntry(SPSoundTable* soundTable, uint32 index)
 		{
-			sndApiLog_printf("SPGetSoundEntry(0x%x, %d)", MEMPTR(soundTable).GetMPTR(), index);
+			cemuLog_log(LogType::SoundAPI, "SPGetSoundEntry(0x{:x}, {})", MEMPTR(soundTable).GetMPTR(), index);
 			if (!soundTable)
 				return nullptr;
 
@@ -1069,8 +1069,8 @@ namespace snd
 		{
 			if (gUnsupportedSoundEffectWarning)
 				return;
-			cemuLog_force("The currently running title is trying to utilize an unsupported audio effect");
-			cemuLog_force("To emulate these correctly, place snd_user.rpl and snduser2.rpl from the original Wii U firmware in /cafeLibs/ folder");
+			cemuLog_log(LogType::Force, "The currently running title is trying to utilize an unsupported audio effect");
+			cemuLog_log(LogType::Force, "To emulate these correctly, place snd_user.rpl and snduser2.rpl from the original Wii U firmware in /cafeLibs/ folder");
 			gUnsupportedSoundEffectWarning = true;
 		}
 
@@ -1104,17 +1104,17 @@ namespace snd
 
 		void AXFXReverbHiInit(AXFXReverbHiData* param)
 		{
-			cemuLog_force("AXFXReverbHiInit - stub");
+			cemuLog_log(LogType::Force, "AXFXReverbHiInit - stub");
 		}
 
 		void AXFXReverbHiSettings(AXFXReverbHiData* param)
 		{
-			cemuLog_force("AXFXReverbHiSettings - stub");
+			cemuLog_log(LogType::Force, "AXFXReverbHiSettings - stub");
 		}
 
 		void AXFXReverbHiShutdown(AXFXReverbHiData* param)
 		{
-			cemuLog_force("AXFXReverbHiShutdown - stub");
+			cemuLog_log(LogType::Force, "AXFXReverbHiShutdown - stub");
 		}
 
 		void AXFXReverbHiCallback(AUXCBSAMPLEDATA* auxSamples, AXFXReverbHiData* reverbHi)
@@ -1133,7 +1133,7 @@ namespace snd
 
 		void AXFXMultiChReverbInit(AXFXMultiChReverbData* param, int ukn2, int ukn3)
 		{
-			cemuLog_force("AXFXMultiChReverbInit (Stubbed)");
+			cemuLog_log(LogType::Force, "AXFXMultiChReverbInit (Stubbed)");
 		}
 
 		void AXFXMultiChReverbSettingsUpdate(AXFXMultiChReverbData* param)
@@ -1248,4 +1248,4 @@ namespace snd
 			cafeExportRegister("snduser2", AXFXMultiChReverbCallback, LogType::SoundAPI);
 		}
 	}
-}
\ No newline at end of file
+}
diff --git a/src/Cafe/OS/libs/swkbd/swkbd.cpp b/src/Cafe/OS/libs/swkbd/swkbd.cpp
index b7ad80f4..d30992b0 100644
--- a/src/Cafe/OS/libs/swkbd/swkbd.cpp
+++ b/src/Cafe/OS/libs/swkbd/swkbd.cpp
@@ -93,7 +93,7 @@ swkbdInternalState_t* swkbdInternalState = NULL;
 
 void swkbdExport_SwkbdCreate(PPCInterpreter_t* hCPU)
 {
-	forceLogDebug_printf("swkbd.SwkbdCreate(0x%08x,0x%08x,0x%08x,0x%08x)\n", hCPU->gpr[3], hCPU->gpr[4], hCPU->gpr[5], hCPU->gpr[6]);
+	cemuLog_logDebug(LogType::Force, "swkbd.SwkbdCreate(0x{:08x},0x{:08x},0x{:08x},0x{:08x})", hCPU->gpr[3], hCPU->gpr[4], hCPU->gpr[5], hCPU->gpr[6]);
 	if( swkbdInternalState == NULL )
 	{
 		MPTR swkbdInternalStateMPTR = coreinit_allocFromSysArea(sizeof(swkbdInternalState_t), 4);
@@ -204,7 +204,7 @@ static_assert(offsetof(swkbdAppearArg_t, cursorIndex) == 0xC4, "appearArg.cursor
 void swkbdExport_SwkbdAppearInputForm(PPCInterpreter_t* hCPU)
 {
 	ppcDefineParamStructPtr(appearArg, swkbdAppearArg_t, 0);
-	forceLogDebug_printf("SwkbdAppearInputForm__3RplFRCQ3_2nn5swkbd9AppearArg LR: %08x\n", hCPU->spr.LR);
+	cemuLog_logDebug(LogType::Force, "SwkbdAppearInputForm__3RplFRCQ3_2nn5swkbd9AppearArg");
 	swkbdInternalState->formStringLength = 0;
 	swkbdInternalState->isActive = true;
 	swkbdInternalState->decideButtonWasPressed = false;
@@ -241,7 +241,7 @@ void swkbdExport_SwkbdAppearInputForm(PPCInterpreter_t* hCPU)
 void swkbdExport_SwkbdAppearKeyboard(PPCInterpreter_t* hCPU)
 {
 	// todo: Figure out what the difference between AppearInputForm and AppearKeyboard is?
-	forceLogDebug_printf("SwkbdAppearKeyboard__3RplFRCQ3_2nn5swkbd11KeyboardArg LR: %08x\n", hCPU->spr.LR);
+	cemuLog_logDebug(LogType::Force, "SwkbdAppearKeyboard__3RplFRCQ3_2nn5swkbd11KeyboardArg");
 	SwkbdKeyboardArg_t* keyboardArg = (SwkbdKeyboardArg_t*)memory_getPointerFromVirtualOffset(hCPU->gpr[3]);
 
 	uint32 argPtr = hCPU->gpr[3];
@@ -276,7 +276,6 @@ void swkbdExport_SwkbdDisappearKeyboard(PPCInterpreter_t* hCPU)
 
 void swkbdExport_SwkbdGetInputFormString(PPCInterpreter_t* hCPU)
 {
-	debug_printf("SwkbdGetInputFormString__3RplFv LR: %08x\n", hCPU->spr.LR);
 	for(sint32 i=0; i<swkbdInternalState->formStringLength; i++)
 	{
 		swkbdInternalState->formStringBufferBE[i] = _swapEndianU16(swkbdInternalState->formStringBuffer[i]);
@@ -287,7 +286,6 @@ void swkbdExport_SwkbdGetInputFormString(PPCInterpreter_t* hCPU)
 
 void swkbdExport_SwkbdIsDecideOkButton(PPCInterpreter_t* hCPU)
 {
-	debug_printf("SwkbdIsDecideOkButton__3RplFPb LR: %08x\n", hCPU->spr.LR);
 	if (swkbdInternalState->decideButtonWasPressed)
 		osLib_returnFromFunction(hCPU, 1);
 	else
@@ -310,7 +308,7 @@ static_assert(sizeof(SwkbdDrawStringInfo_t) != 0x19, "SwkbdDrawStringInfo_t has
 
 void swkbdExport_SwkbdGetDrawStringInfo(PPCInterpreter_t* hCPU)
 {
-	forceLogDebug_printf("SwkbdGetDrawStringInfo(0x%08x) - stub LR: %08x", hCPU->gpr[3], hCPU->spr.LR);
+	cemuLog_logDebug(LogType::Force, "SwkbdGetDrawStringInfo(0x{:08x})", hCPU->gpr[3]);
 	ppcDefineParamStructPtr(drawStringInfo, SwkbdDrawStringInfo_t, 0);
 
 	drawStringInfo->ukn00 = -1;
@@ -326,7 +324,7 @@ void swkbdExport_SwkbdGetDrawStringInfo(PPCInterpreter_t* hCPU)
 
 void swkbdExport_SwkbdInitLearnDic(PPCInterpreter_t* hCPU)
 {
-	forceLogDebug_printf("SwkbdInitLearnDic(0x%08x) - stub LR: %08x", hCPU->gpr[3], hCPU->spr.LR);
+	cemuLog_logDebug(LogType::Force, "SwkbdInitLearnDic(0x{:08x})", hCPU->gpr[3]);
 	// todo
 
 	// this has to fail (at least once?) or MH3U will not boot
@@ -373,8 +371,8 @@ void swkbd_render(bool mainWindow)
 	ImGui::PushStyleVar(ImGuiStyleVar_WindowBorderSize, 0);
 	ImGui::PushStyleVar(ImGuiStyleVar_WindowPadding, { 0,0 });
 	ImGui::SetNextWindowBgAlpha(0.8f);
-	if (ImGui::Begin("Background overlay", nullptr, kPopupFlags | ImGuiWindowFlags_NoNav | ImGuiWindowFlags_NoFocusOnAppearing))
-		ImGui::End();
+	ImGui::Begin("Background overlay", nullptr, kPopupFlags | ImGuiWindowFlags_NoNav | ImGuiWindowFlags_NoFocusOnAppearing | ImGuiWindowFlags_NoBringToFrontOnFocus);
+	ImGui::End();
 	ImGui::PopStyleVar(2);
 
 	ImVec2 position = { io.DisplaySize.x / 2.0f, io.DisplaySize.y / 3.0f };
@@ -412,10 +410,8 @@ void swkbd_render(bool mainWindow)
 		ImGui::PopTextWrapPos();
 
 		position.y += ImGui::GetWindowSize().y + 100.0f;
-
-		ImGui::End();
 	}
-
+	ImGui::End();
 	ImGui::PopFont();
 
 	ImGui::SetNextWindowPos(position, ImGuiCond_Always, pivot);
@@ -490,10 +486,8 @@ void swkbd_render(bool mainWindow)
 			}
 		}
 		ImGui::NewLine();
-		
-
-		ImGui::End();
 	}
+	ImGui::End();
 
 	if (io.NavInputs[ImGuiNavInput_Cancel] > 0)
 	{
@@ -572,7 +566,7 @@ void swkbd_inputStringChanged()
 
 void swkbd_keyInput(uint32 keyCode)
 {
-	if (keyCode == 8) // backspace
+	if (keyCode == 8 || keyCode == 127) // backspace || backwards delete
 	{
 		if (swkbdInternalState->formStringLength > 0)
 			swkbdInternalState->formStringLength--;
diff --git a/src/Cafe/OS/libs/sysapp/sysapp.cpp b/src/Cafe/OS/libs/sysapp/sysapp.cpp
index 0085ee19..ecaa940a 100644
--- a/src/Cafe/OS/libs/sysapp/sysapp.cpp
+++ b/src/Cafe/OS/libs/sysapp/sysapp.cpp
@@ -2,6 +2,7 @@
 #include "sysapp.h"
 #include "Cafe/CafeSystem.h"
 #include "Cafe/OS/libs/coreinit/coreinit_FG.h"
+#include "Cafe/OS/libs/coreinit/coreinit_Misc.h"
 
 typedef struct  
 {
@@ -309,13 +310,13 @@ void cbDeserializeArg_MiiMaker(deserializedArg_t* deserializedArg, void* customP
 	}
 	else if (strcmp(deserializedArg->argument, "slot_id") == 0)
 	{
-#ifndef PUBLIC_RELEASE
+#ifdef CEMU_DEBUG_ASSERT
 		assert_dbg();
 #endif
 	}
 	else
 	{
-#ifndef PUBLIC_RELEASE
+#ifdef CEMU_DEBUG_ASSERT
 		assert_dbg();
 #endif
 	}
@@ -417,7 +418,7 @@ uint64 _SYSGetSystemApplicationTitleId(sint32 index)
 void sysappExport__SYSGetSystemApplicationTitleId(PPCInterpreter_t* hCPU)
 {
 	ppcDefineParamU32(systemApplicationId, 0);
-	forceLogDebug_printf("_SYSGetSystemApplicationTitleId(0x%d)", hCPU->gpr[3]);
+	cemuLog_logDebug(LogType::Force, "_SYSGetSystemApplicationTitleId(0x{:x})", hCPU->gpr[3]);
 
 	uint64 titleId = _SYSGetSystemApplicationTitleId(systemApplicationId);
 	osLib_returnFromFunction64(hCPU, titleId);
@@ -453,14 +454,14 @@ void sysappExport__SYSLaunchMiiStudio(PPCInterpreter_t* hCPU)
 void sysappExport__SYSReturnToCallerWithStandardResult(PPCInterpreter_t* hCPU)
 {
 	ppcDefineParamU32BEPtr(resultPtr, 0);
-	forceLog_printf("_SYSReturnToCallerWithStandardResult(0x%08x) result: 0x%08x", hCPU->gpr[3], (uint32)*resultPtr);
+	cemuLog_log(LogType::Force, "_SYSReturnToCallerWithStandardResult(0x{:08x}) result: 0x{:08x}", hCPU->gpr[3], (uint32)*resultPtr);
 	while (true) std::this_thread::sleep_for(std::chrono::milliseconds(10));
 }
 
 void sysappExport__SYSGetEShopArgs(PPCInterpreter_t* hCPU)
 {
 	ppcDefineParamStructPtr(args, eshopArguments_t, 0);
-	forceLogDebug_printf("_SYSGetEShopArgs() - placeholder");
+	cemuLog_logDebug(LogType::Force, "_SYSGetEShopArgs() - placeholder");
 	memset(args, 0, sizeof(eshopArguments_t));
 
 	osLib_returnFromFunction(hCPU, 0);
@@ -469,7 +470,6 @@ void sysappExport__SYSGetEShopArgs(PPCInterpreter_t* hCPU)
 void sysappExport_SYSGetUPIDFromTitleID(PPCInterpreter_t* hCPU)
 {
 	ppcDefineParamU64(titleId, 0);
-	forceLogDebug_printf("SYSGetUPIDFromTitleID(0x%08x%08x)", hCPU->gpr[3], hCPU->gpr[4]);
 	uint32 titleIdHigh = (titleId >> 32);
 	uint32 titleIdLow = (uint32)(titleId & 0xFFFFFFFF);
 	if ((titleIdHigh & 0xFFFF0000) != 0x50000)
@@ -537,46 +537,139 @@ void sysappExport_SYSGetUPIDFromTitleID(PPCInterpreter_t* hCPU)
 
 void sysappExport_SYSGetVodArgs(PPCInterpreter_t* hCPU)
 {
-	forceLogDebug_printf("SYSGetVodArgs() - todo");
+	cemuLog_logDebug(LogType::Force, "SYSGetVodArgs() - todo");
 	osLib_returnFromFunction(hCPU, 1);
 }
 
+struct SysLauncherArgs18
+{
+	uint64be caller_id; // titleId
+	uint64be launch_title; // titleId
+	uint32be mode;
+	uint32be slot_id;
+};
+
+static_assert(sizeof(SysLauncherArgs18) == 0x18);
+
 struct SysLauncherArgs28
 {
 	uint32 ukn00;
 	uint32 ukn04;
 	uint32 ukn08;
 	uint32 ukn0C;
-	uint32 ukn10; // caller title id? (8 byte)
-	uint32 ukn14;
-	uint32 ukn18; // launched title id? (8 byte)
-	uint32 ukn1C;
-	uint32 ukn20; // mode
-	uint32 ukn24; // slot
+	// standard args above
+	uint64be caller_id; // titleId
+	uint64be launch_title; // titleId
+	uint32be mode;
+	uint32be slot_id;
 };
 
 static_assert(sizeof(SysLauncherArgs28) == 0x28);
 
-void sysappExport__SYSGetLauncherArgs(PPCInterpreter_t* hCPU)
+uint32 _SYSGetLauncherArgs(void* argsOut)
 {
-	forceLogDebug_printf("_SYSGetLauncherArgs(0x%08x) - todo\n", hCPU->gpr[3]);
+	uint32 sdkVersion = coreinit::__OSGetProcessSDKVersion();
+	if(sdkVersion < 21103)
+	{
+		// old format
+		SysLauncherArgs18* launcherArgs18 = (SysLauncherArgs18*)argsOut;
+		memset(launcherArgs18, 0, sizeof(SysLauncherArgs18));
+	}
+	else
+	{
+		// new format
+		SysLauncherArgs28* launcherArgs28 = (SysLauncherArgs28*)argsOut;
+		memset(launcherArgs28, 0, sizeof(SysLauncherArgs28));
+	}
+	return 0; // return argument is todo
+}
 
-	// todo: Handle OS library version. Older versions used a different struct (only 0x18 bytes?)
-	//ppcDefineParamStructPtr(launcherArgs, SysLauncherArgs, 0);
-	//memset(launcherArgs, 0, sizeof(SysLauncherArgs));
+struct SysAccountArgs18
+{
+	uint32be ukn00;
+	uint32be ukn04;
+	uint32be ukn08;
+	uint32be ukn0C;
+	// shares part above with Standard arg
+	uint32be slotId; // "slot_id"
+	uint32be mode; // "mode"
+};
 
+uint32 _SYSGetAccountArgs(SysAccountArgs18* argsOut)
+{
+	memset(argsOut, 0, sizeof(SysAccountArgs18));
 
-	osLib_returnFromFunction(hCPU, 0); // return argument is todo (probably number of args?)
+	// sysDeserializeStandardArguments_t ?
+
+	return 0;
 }
 
 void sysappExport_SYSGetStandardResult(PPCInterpreter_t* hCPU)
 {
-	forceLogDebug_printf("SYSGetStandardResult(0x%08x,0x%08x,0x%08x)\n", hCPU->gpr[3], hCPU->gpr[4], hCPU->gpr[5]);
+	cemuLog_logDebug(LogType::Force, "SYSGetStandardResult(0x{:08x},0x{:08x},0x{:08x})", hCPU->gpr[3], hCPU->gpr[4], hCPU->gpr[5]);
 	memset(memory_getPointerFromVirtualOffset(hCPU->gpr[3]), 0, 4);
 
+	// r3 = uint32be* output
+	// r4 = pointer to data to parse?
+	// r5 = size to parse?
+
 	osLib_returnFromFunction(hCPU, 0);
 }
 
+namespace sysapp
+{
+	void SYSClearSysArgs()
+	{
+		cemuLog_logDebug(LogType::Force, "SYSClearSysArgs()");
+		coreinit::__OSClearCopyData();
+	}
+
+	uint32 _SYSLaunchTitleByPathFromLauncher(const char* path, uint32 pathLength)
+	{
+		coreinit::__OSClearCopyData();
+		_SYSAppendCallerInfo();
+		return coreinit::OSLaunchTitleByPathl(path, pathLength, 0);
+	}
+
+	uint32 SYSRelaunchTitle(uint32 argc, MEMPTR<char>* argv)
+	{
+		// calls ACPCheckSelfTitleNotReferAccountLaunch?
+		coreinit::__OSClearCopyData();
+		_SYSAppendCallerInfo();
+		return coreinit::OSRestartGame(argc, argv);
+	}
+
+	struct EManualArgs
+	{
+		sysStandardArguments_t stdArgs;
+		uint64be titleId;
+	};
+	static_assert(sizeof(EManualArgs) == 0x10);
+
+	void _SYSSwitchToEManual(EManualArgs* args)
+	{
+		// the struct has the titleId at offset 8 and standard args at 0 (total size is most likely 0x10)
+		cemuLog_log(LogType::Force, "SYSSwitchToEManual called. Opening the manual is not supported");
+		coreinit::StartBackgroundForegroundTransition();
+	}
+
+	void SYSSwitchToEManual()
+	{
+		EManualArgs args{};
+		args.titleId = coreinit::OSGetTitleID();
+		_SYSSwitchToEManual(&args);
+	}
+
+	void load()
+	{
+		cafeExportRegisterFunc(SYSClearSysArgs, "sysapp", "SYSClearSysArgs", LogType::Placeholder);
+		cafeExportRegisterFunc(_SYSLaunchTitleByPathFromLauncher, "sysapp", "_SYSLaunchTitleByPathFromLauncher", LogType::Placeholder);
+		cafeExportRegisterFunc(SYSRelaunchTitle, "sysapp", "SYSRelaunchTitle", LogType::Placeholder);
+		cafeExportRegister("sysapp", _SYSSwitchToEManual, LogType::Placeholder);
+		cafeExportRegister("sysapp", SYSSwitchToEManual, LogType::Placeholder);
+	}
+}
+
 // register sysapp functions
 void sysapp_load()
 {
@@ -592,6 +685,10 @@ void sysapp_load()
 
 	osLib_addFunction("sysapp", "SYSGetVodArgs", sysappExport_SYSGetVodArgs);
 
-	osLib_addFunction("sysapp", "_SYSGetLauncherArgs", sysappExport__SYSGetLauncherArgs);
 	osLib_addFunction("sysapp", "SYSGetStandardResult", sysappExport_SYSGetStandardResult);
+
+	cafeExportRegisterFunc(_SYSGetLauncherArgs, "sysapp", "_SYSGetLauncherArgs", LogType::Placeholder);
+	cafeExportRegisterFunc(_SYSGetAccountArgs, "sysapp", "_SYSGetAccountArgs", LogType::Placeholder);
+
+	sysapp::load();
 }
diff --git a/src/Cafe/OS/libs/vpad/vpad.cpp b/src/Cafe/OS/libs/vpad/vpad.cpp
index 0ad97620..21c1c9e5 100644
--- a/src/Cafe/OS/libs/vpad/vpad.cpp
+++ b/src/Cafe/OS/libs/vpad/vpad.cpp
@@ -4,7 +4,6 @@
 #include "Cafe/OS/libs/vpad/vpad.h"
 #include "audio/IAudioAPI.h"
 #include "Cafe/OS/libs/coreinit/coreinit_Time.h"
-#include <boost/range/iterator_range.hpp>
 #include "config/ActiveSettings.h"
 #include "Cafe/OS/libs/coreinit/coreinit_Alarm.h"
 #include "input/InputManager.h"
@@ -51,7 +50,6 @@
 
 extern bool isLaunchTypeELF;
 
-bool debugUseDRC = true;
 VPADDir g_vpadGyroDirOverwrite[VPAD_MAX_CONTROLLERS] =
 {
 		{{1.0f,0.0f,0.0f}, {0.0f,1.0f,0.0f}, {0.0f, 0.0f, 0.1f}},
@@ -164,7 +162,7 @@ namespace vpad
 	
 	struct
 	{
-		coreinit::OSAlarm_t alarm;
+		SysAllocator<coreinit::OSAlarm_t> alarm;
 
 		struct
 		{
@@ -205,7 +203,7 @@ namespace vpad
 
 	void VPADSetAccParam(sint32 channel, float radius, float sensitivity)
 	{
-		inputLog_printf("VPADSetAccParam(%d, %f, %f)", channel, radius, sensitivity);
+		cemuLog_log(LogType::InputAPI, "VPADSetAccParam({}, {}, {})", channel, radius, sensitivity);
 		vpadbreak();
 		g_vpad.controller_data[channel].acc_param.radius = radius;
 		g_vpad.controller_data[channel].acc_param.sensitivity = sensitivity;
@@ -213,7 +211,7 @@ namespace vpad
 
 	void VPADGetAccParam(sint32 channel, float* radius, float* sensitivity)
 	{
-		inputLog_printf("VPADGetAccParam(%d, %p, %p)", channel, (void*)radius, (void*)sensitivity);
+		cemuLog_log(LogType::InputAPI, "VPADGetAccParam({}, {}, {})", channel, (void*)radius, (void*)sensitivity);
 		vpadbreak();
 		*radius = g_vpad.controller_data[channel].acc_param.radius;
 		*sensitivity = g_vpad.controller_data[channel].acc_param.sensitivity;
@@ -226,7 +224,7 @@ namespace vpad
 		ppcDefineParamStructPtr(status, VPADStatus_t, 1);
 		ppcDefineParamU32(length, 2);
 		ppcDefineParamPtr(error, uint32be, 3);
-		inputLog_printf("VPADRead(%d, _, %d)", channel, length);*/
+		cemuLog_log(LogType::InputAPI, "VPADRead({}, _, {})", channel, length);*/
 	
 		// default init which should be always set
 		memset(status, 0x00, sizeof(VPADStatus_t));
@@ -241,19 +239,20 @@ namespace vpad
 		status->tpProcessed2.validity = VPAD_TP_VALIDITY_INVALID_XY;
 
 		const auto controller = InputManager::instance().get_vpad_controller(channel);
-		if (!controller || debugUseDRC == false)
+		if (!controller)
 		{
-			// no controller
+			// most games expect the Wii U GamePad to be connected, so even if the user has not set it up we should still return empty samples for channel 0
+			if(channel != 0)
+			{
+				if (error)
+					*error = VPAD_READ_ERR_NO_CONTROLLER;
+				if (length > 0)
+					status->vpadErr = -1;
+				return 0;
+			}
 			if (error)
-				*error = VPAD_READ_ERR_NONE; // VPAD_READ_ERR_NO_DATA; // VPAD_READ_ERR_NO_CONTROLLER;
-
+				*error = VPAD_READ_ERR_NONE;
 			return 1;
-			//osLib_returnFromFunction(hCPU, 1); return;
-		}
-
-		if (channel != 0)
-		{
-			debugBreakpoint();
 		}
 
 		const bool vpadDelayEnabled = ActiveSettings::VPADDelayEnabled();
@@ -268,16 +267,14 @@ namespace vpad
 		{
 			if (channel <= 1 && vpadDelayEnabled)
 			{
-				uint64 currentTime = coreinit::coreinit_getOSTime();
+				uint64 currentTime = coreinit::OSGetTime();
 				const auto dif = currentTime - vpad::g_vpad.controller_data[channel].drcLastCallTime;
 				if (dif <= (ESPRESSO_TIMER_CLOCK / 60ull))
 				{
 					// not ready yet
 					if (error)
 						*error = VPAD_READ_ERR_NONE;
-
 					return 0;
-					//osLib_returnFromFunction(hCPU, 0); return;
 				}
 				else if (dif <= ESPRESSO_TIMER_CLOCK)
 				{
@@ -304,7 +301,7 @@ namespace vpad
 
 	void VPADSetBtnRepeat(sint32 channel, float delay, float pulse)
 	{
-		inputLog_printf("VPADSetBtnRepeat(%d, %f, %f)", channel, delay, pulse);
+		cemuLog_log(LogType::InputAPI, "VPADSetBtnRepeat({}, {}, {})", channel, delay, pulse);
 		if(pulse == 0)
 		{
 			g_vpad.controller_data[channel].btn_repeat.delay = 40000;
@@ -320,21 +317,21 @@ namespace vpad
 
 	void VPADSetAccPlayMode(sint32 channel, PlayMode play_mode)
 	{
-		inputLog_printf("VPADSetAccPlayMode(%d, %d)", channel, (int)play_mode);
+		cemuLog_log(LogType::InputAPI, "VPADSetAccPlayMode({}, {})", channel, (int)play_mode);
 		vpadbreak();
 		g_vpad.controller_data[channel].acc_play_mode = play_mode;
 	}
 
 	PlayMode VPADGetAccPlayMode(sint32 channel)
 	{
-		inputLog_printf("VPADGetAccPlayMode(%d)", channel);
+		cemuLog_log(LogType::InputAPI, "VPADGetAccPlayMode({})", channel);
 		vpadbreak();
 		return g_vpad.controller_data[channel].acc_play_mode;
 	}
 
 	void* VPADSetSamplingCallback(sint32 channel, void* callback)
 	{
-		inputLog_printf("VPADSetSamplingCallback(%d, 0x%x)", channel, MEMPTR(callback).GetMPTR());
+		cemuLog_log(LogType::InputAPI, "VPADSetSamplingCallback({}, 0x{:x})", channel, MEMPTR(callback).GetMPTR());
 		vpadbreak();
 
 		void* result = g_vpad.controller_data[channel].sampling_callback;
@@ -350,7 +347,7 @@ namespace vpad
 
 	void VPADGetTPCalibrationParam(sint32 channel, VPADTPCalibrationParam* param)
 	{
-		inputLog_printf("VPADGetTPCalibrationParam(%d, 0x%x)", channel, MEMPTR(param).GetMPTR());
+		cemuLog_log(LogType::InputAPI, "VPADGetTPCalibrationParam({}, 0x{:x})", channel, MEMPTR(param).GetMPTR());
 		vpadbreak();
 
 		*param = g_vpad.controller_data[channel].tp_calibration_param;
@@ -358,7 +355,7 @@ namespace vpad
 
 	void VPADSetTPCalibrationParam(sint32 channel, VPADTPCalibrationParam* param)
 	{
-		inputLog_printf("VPADSetTPCalibrationParam(%d, 0x%x)", channel, MEMPTR(param).GetMPTR());
+		cemuLog_log(LogType::InputAPI, "VPADSetTPCalibrationParam({}, 0x{:x})", channel, MEMPTR(param).GetMPTR());
 		vpadbreak();
 
 		g_vpad.controller_data[channel].tp_calibration_param = *param;
@@ -366,7 +363,7 @@ namespace vpad
 
 	void VPADGetTPCalibratedPoint(sint32 channel, VPADTPData* data, VPADTPData* raw)
 	{
-		inputLog_printf("VPADGetTPCalibratedPoint(%d, 0x%x, 0x%x)", channel, MEMPTR(data).GetMPTR(), MEMPTR(raw).GetMPTR());
+		cemuLog_log(LogType::InputAPI, "VPADGetTPCalibratedPoint({}, 0x{:x}, 0x{:x})", channel, MEMPTR(data).GetMPTR(), MEMPTR(raw).GetMPTR());
 		vpadbreak();
 
 		const auto& controller_data = g_vpad.controller_data[channel];
@@ -397,14 +394,14 @@ namespace vpad
 
 	void VPADGetTPCalibratedPointEx(sint32 channel, VPADTPResolution resolution, VPADTPData* data, VPADTPData* raw)
 	{
-		inputLog_printf("VPADGetTPCalibratedPointEx(%d, %d, 0x%x, 0x%x)", channel, (int)resolution, MEMPTR(data).GetMPTR(), MEMPTR(raw).GetMPTR());
+		cemuLog_log(LogType::InputAPI, "VPADGetTPCalibratedPointEx({}, {}, 0x{:x}, 0x{:x})", channel, (int)resolution, MEMPTR(data).GetMPTR(), MEMPTR(raw).GetMPTR());
 		vpadbreak();
 
 	}
 
 	void VPADSetCrossStickEmulationParamsL(sint32 channel, float rotation, float range, float radius)
 	{
-		inputLog_printf("VPADSetCrossStickEmulationParamsL(%d, %f, %f, %f)", channel, rotation, range, radius);
+		cemuLog_log(LogType::InputAPI, "VPADSetCrossStickEmulationParamsL({}, {}, {}, {})", channel, rotation, range, radius);
 		vpadbreak();
 
 		if (range < 0 || 90.0f < range) 
@@ -420,7 +417,7 @@ namespace vpad
 
 	void VPADSetCrossStickEmulationParamsR(sint32 channel, float rotation, float range, float radius)
 	{
-		inputLog_printf("VPADSetCrossStickEmulationParamsR(%d, %f, %f, %f)", channel, rotation, range, radius);
+		cemuLog_log(LogType::InputAPI, "VPADSetCrossStickEmulationParamsR({}, {}, {}, {})", channel, rotation, range, radius);
 		vpadbreak();
 
 		if (range < 0 || 90.0f < range) 
@@ -436,7 +433,7 @@ namespace vpad
 
 	void VPADGetCrossStickEmulationParamsL(sint32 channel, float* rotation, float* range, float* radius)
 	{
-		inputLog_printf("VPADGetCrossStickEmulationParamsL(%d, 0x%x, 0x%x, 0x%x)", channel, MEMPTR(rotation).GetMPTR(),  MEMPTR(range).GetMPTR(),  MEMPTR(radius).GetMPTR());
+		cemuLog_log(LogType::InputAPI, "VPADGetCrossStickEmulationParamsL({}, 0x{:x}, 0x{:x}, 0x{:x})", channel, MEMPTR(rotation).GetMPTR(),  MEMPTR(range).GetMPTR(),  MEMPTR(radius).GetMPTR());
 		vpadbreak();
 
 		*rotation = g_vpad.controller_data[channel].cross_stick_emulation_l.rotation;
@@ -446,7 +443,7 @@ namespace vpad
 
 	void VPADGetCrossStickEmulationParamsR(sint32 channel, float* rotation, float* range, float* radius)
 	{
-		inputLog_printf("VPADGetCrossStickEmulationParamsR(%d, 0x%x, 0x%x, 0x%x)", channel, MEMPTR(rotation).GetMPTR(),  MEMPTR(range).GetMPTR(),  MEMPTR(radius).GetMPTR());
+		cemuLog_log(LogType::InputAPI, "VPADGetCrossStickEmulationParamsR({}, 0x{:x}, 0x{:x}, 0x{:x})", channel, MEMPTR(rotation).GetMPTR(),  MEMPTR(range).GetMPTR(),  MEMPTR(radius).GetMPTR());
 		vpadbreak();
 
 		*rotation = g_vpad.controller_data[channel].cross_stick_emulation_r.rotation;
@@ -456,7 +453,7 @@ namespace vpad
 
 	ButtonProcMode VPADGetButtonProcMode(sint32 channel)
 	{
-		inputLog_printf("VPADGetButtonProcMode(%d)", channel);
+		cemuLog_log(LogType::InputAPI, "VPADGetButtonProcMode({})", channel);
 		vpadbreak();
 
 		return g_vpad.controller_data[channel].button_proc_mode;
@@ -464,7 +461,7 @@ namespace vpad
 
 	void VPADSetButtonProcMode(sint32 channel, ButtonProcMode mode)
 	{
-		inputLog_printf("VPADSetButtonProcMode(%d, %d)", channel, (int)mode);
+		cemuLog_log(LogType::InputAPI, "VPADSetButtonProcMode({}, {})", channel, (int)mode);
 		vpadbreak();
 
 		g_vpad.controller_data[channel].button_proc_mode = mode;
@@ -472,21 +469,21 @@ namespace vpad
 
 	void VPADEnableStickCrossClamp(sint32 channel)
 	{
-		inputLog_printf("VPADEnableStickCrossClamp(%d)", channel);
+		cemuLog_log(LogType::InputAPI, "VPADEnableStickCrossClamp({})", channel);
 		vpadbreak();
 		g_vpad.controller_data[channel].stick_cross_clamp.enabled = true;
 	}
 
 	void VPADDisableStickCrossClamp(sint32 channel)
 	{
-		inputLog_printf("VPADDisableStickCrossClamp(%d)", channel);
+		cemuLog_log(LogType::InputAPI, "VPADDisableStickCrossClamp({})", channel);
 		vpadbreak();
 		g_vpad.controller_data[channel].stick_cross_clamp.enabled = false;
 	}
 
 	void VPADSetLStickClampThreshold(sint32 channel, sint32 max, sint32 min)
 	{
-		inputLog_printf("VPADSetLStickClampThreshold(%d, %d, %d)", channel, max, min);
+		cemuLog_log(LogType::InputAPI, "VPADSetLStickClampThreshold({}, {}, {})", channel, max, min);
 		vpadbreak();
 		g_vpad.controller_data[channel].stick_cross_clamp.left.max = std::min(0x397, max);
 		g_vpad.controller_data[channel].stick_cross_clamp.left.min = std::max(0x102, min);
@@ -494,7 +491,7 @@ namespace vpad
 
 	void VPADSetRStickClampThreshold(sint32 channel, sint32 max, sint32 min)
 	{
-		inputLog_printf("VPADSetRStickClampThreshold(%d, %d, %d)", channel, max, min);
+		cemuLog_log(LogType::InputAPI, "VPADSetRStickClampThreshold({}, {}, {})", channel, max, min);
 		vpadbreak();
 		g_vpad.controller_data[channel].stick_cross_clamp.right.max = std::min(0x397, max);
 		g_vpad.controller_data[channel].stick_cross_clamp.right.min = std::max(0x102, min);
@@ -502,7 +499,7 @@ namespace vpad
 
 	void VPADGetLStickClampThreshold(sint32 channel, sint32* max, sint32* min)
 	{
-		inputLog_printf("VPADGetLStickClampThreshold(%d, 0x%x, 0x%x)", channel, MEMPTR(max).GetMPTR(), MEMPTR(min).GetMPTR());
+		cemuLog_log(LogType::InputAPI, "VPADGetLStickClampThreshold({}, 0x{:x}, 0x{:x})", channel, MEMPTR(max).GetMPTR(), MEMPTR(min).GetMPTR());
 		vpadbreak();
 		*max = g_vpad.controller_data[channel].stick_cross_clamp.left.max;
 		*min = g_vpad.controller_data[channel].stick_cross_clamp.left.min;
@@ -510,7 +507,7 @@ namespace vpad
 
 	void VPADGetRStickClampThreshold(sint32 channel, sint32* max, sint32* min)
 	{
-		inputLog_printf("VPADGetRStickClampThreshold(%d, 0x%x, 0x%x)", channel, MEMPTR(max).GetMPTR(), MEMPTR(min).GetMPTR());
+		cemuLog_log(LogType::InputAPI, "VPADGetRStickClampThreshold({}, 0x{:x}, 0x{:x})", channel, MEMPTR(max).GetMPTR(), MEMPTR(min).GetMPTR());
 		vpadbreak();
 		*max = g_vpad.controller_data[channel].stick_cross_clamp.right.max;
 		*min = g_vpad.controller_data[channel].stick_cross_clamp.right.min;
@@ -523,7 +520,7 @@ void vpadExport_VPADGetAccParam(PPCInterpreter_t* hCPU)
 	ppcDefineParamU32(channel, 0);
 	ppcDefineParamPtr(playRadius, float32be, 1);
 	ppcDefineParamPtr(sensitivity, float32be, 2);
-	inputLog_printf("VPADGetAccParam(%d)", channel);
+	cemuLog_log(LogType::InputAPI, "VPADGetAccParam({})", channel);
 
 	if (channel < VPAD_MAX_CONTROLLERS)
 	{
@@ -541,7 +538,7 @@ void vpadExport_VPADGetAccParam(PPCInterpreter_t* hCPU)
 void vpadExport_VPADSetAccParam(PPCInterpreter_t* hCPU)
 {
 	ppcDefineParamU32(channel, 0);
-	inputLog_printf("VPADSetAccParam(%d, %f, %f)", channel, hCPU->fpr[1].fpr, hCPU->fpr[2].fpr);
+	cemuLog_log(LogType::InputAPI, "VPADSetAccParam({}, {}, {})", channel, hCPU->fpr[1].fpr, hCPU->fpr[2].fpr);
 
 	if (channel < VPAD_MAX_CONTROLLERS)
 	{
@@ -559,7 +556,7 @@ void vpadExport_VPADSetAccParam(PPCInterpreter_t* hCPU)
 void vpadExport_VPADGetAccPlayMode(PPCInterpreter_t* hCPU)
 {
 	ppcDefineParamU32(channel, 0);
-	inputLog_printf("VPADGetAccPlayMode(%d)", channel);
+	cemuLog_log(LogType::InputAPI, "VPADGetAccPlayMode({})", channel);
 
 	if (channel < VPAD_MAX_CONTROLLERS)
 	{
@@ -576,7 +573,7 @@ void vpadExport_VPADSetAccPlayMode(PPCInterpreter_t* hCPU)
 {
 	ppcDefineParamU32(channel, 0);
 	ppcDefineParamU32(playMode, 1);
-	inputLog_printf("VPADSetAccPlayMode(%d, %d)", channel, playMode);
+	cemuLog_log(LogType::InputAPI, "VPADSetAccPlayMode({}, {})", channel, playMode);
 
 	if (channel < VPAD_MAX_CONTROLLERS)
 	{
@@ -593,7 +590,7 @@ void vpadExport_VPADSetAccPlayMode(PPCInterpreter_t* hCPU)
 void vpadExport_VPADEnableStickCrossClamp(PPCInterpreter_t* hCPU)
 {
 	ppcDefineParamU32(channel, 0);
-	inputLog_printf("VPADEnableStickCrossClamp(%d)", channel);
+	cemuLog_log(LogType::InputAPI, "VPADEnableStickCrossClamp({})", channel);
 
 	if (channel < VPAD_MAX_CONTROLLERS)
 	{
@@ -610,7 +607,7 @@ void vpadExport_VPADEnableStickCrossClamp(PPCInterpreter_t* hCPU)
 void vpadExport_VPADDisableStickCrossClamp(PPCInterpreter_t* hCPU)
 {
 	ppcDefineParamU32(channel, 0);
-	inputLog_printf("VPADDisableStickCrossClamp(%d)", channel);
+	cemuLog_log(LogType::InputAPI, "VPADDisableStickCrossClamp({})", channel);
 
 	if (channel < VPAD_MAX_CONTROLLERS)
 	{
@@ -629,7 +626,7 @@ void vpadExport_VPADSetLStickClampThreshold(PPCInterpreter_t* hCPU)
 	ppcDefineParamU32(channel, 0);
 	ppcDefineParamS32(maxValue, 1);
 	ppcDefineParamS32(minValue, 2);
-	inputLog_printf("VPADSetLStickClampThreshold(%d, %d, %d)", channel, maxValue, minValue);
+	cemuLog_log(LogType::InputAPI, "VPADSetLStickClampThreshold({}, {}, {})", channel, maxValue, minValue);
 
 	if (channel < VPAD_MAX_CONTROLLERS)
 	{
@@ -649,7 +646,7 @@ void vpadExport_VPADSetRStickClampThreshold(PPCInterpreter_t* hCPU)
 	ppcDefineParamU32(channel, 0);
 	ppcDefineParamS32(maxValue, 1);
 	ppcDefineParamS32(minValue, 2);
-	inputLog_printf("VPADSetRStickClampThreshold(%d, %d, %d)", channel, maxValue, minValue);
+	cemuLog_log(LogType::InputAPI, "VPADSetRStickClampThreshold({}, {}, {})", channel, maxValue, minValue);
 
 	if (channel < VPAD_MAX_CONTROLLERS)
 	{
@@ -669,7 +666,7 @@ void vpadExport_VPADGetLStickClampThreshold(PPCInterpreter_t* hCPU)
 	ppcDefineParamU32(channel, 0);
 	ppcDefineParamPtr(maxValue, uint32be, 1);
 	ppcDefineParamPtr(minValue, uint32be, 2);
-	inputLog_printf("VPADGetLStickClampThreshold(%d)", channel);
+	cemuLog_log(LogType::InputAPI, "VPADGetLStickClampThreshold({})", channel);
 
 	if (channel < VPAD_MAX_CONTROLLERS)
 	{
@@ -689,7 +686,7 @@ void vpadExport_VPADGetRStickClampThreshold(PPCInterpreter_t* hCPU)
 	ppcDefineParamU32(channel, 0);
 	ppcDefineParamPtr(maxValue, uint32be, 1);
 	ppcDefineParamPtr(minValue, uint32be, 2);
-	inputLog_printf("VPADGetRStickClampThreshold(%d)", channel);
+	cemuLog_log(LogType::InputAPI, "VPADGetRStickClampThreshold({})", channel);
 
 	if (channel < VPAD_MAX_CONTROLLERS)
 	{
@@ -707,7 +704,7 @@ void vpadExport_VPADGetRStickClampThreshold(PPCInterpreter_t* hCPU)
 void vpadExport_VPADSetCrossStickEmulationParamsL(PPCInterpreter_t* hCPU)
 {
 	ppcDefineParamU32(channel, 0);
-	inputLog_printf("VPADSetCrossStickEmulationParamsL(%d, %f, %f, %f)", channel, hCPU->fpr[1].fpr, hCPU->fpr[2].fpr, hCPU->fpr[3].fpr);
+	cemuLog_log(LogType::InputAPI, "VPADSetCrossStickEmulationParamsL({}, {}, {}, {})", channel, hCPU->fpr[1].fpr, hCPU->fpr[2].fpr, hCPU->fpr[3].fpr);
 
 	if (channel < VPAD_MAX_CONTROLLERS)
 	{
@@ -726,7 +723,7 @@ void vpadExport_VPADSetCrossStickEmulationParamsL(PPCInterpreter_t* hCPU)
 void vpadExport_VPADSetCrossStickEmulationParamsR(PPCInterpreter_t* hCPU)
 {
 	ppcDefineParamU32(channel, 0);
-	inputLog_printf("VPADSetCrossStickEmulationParamsR(%d, %f, %f, %f)", channel, hCPU->fpr[1].fpr, hCPU->fpr[2].fpr, hCPU->fpr[3].fpr);
+	cemuLog_log(LogType::InputAPI, "VPADSetCrossStickEmulationParamsR({}, {}, {}, {})", channel, hCPU->fpr[1].fpr, hCPU->fpr[2].fpr, hCPU->fpr[3].fpr);
 
 	if (channel < VPAD_MAX_CONTROLLERS)
 	{
@@ -748,7 +745,7 @@ void vpadExport_VPADGetCrossStickEmulationParamsL(PPCInterpreter_t* hCPU)
 	ppcDefineParamPtr(rotation, float32be, 1);
 	ppcDefineParamPtr(inputRange, float32be, 2);
 	ppcDefineParamPtr(radius, float32be, 3);
-	inputLog_printf("VPADGetCrossStickEmulationParamsL(%d)", channel);
+	cemuLog_log(LogType::InputAPI, "VPADGetCrossStickEmulationParamsL({})", channel);
 
 	if (channel < VPAD_MAX_CONTROLLERS)
 	{
@@ -770,7 +767,7 @@ void vpadExport_VPADGetCrossStickEmulationParamsR(PPCInterpreter_t* hCPU)
 	ppcDefineParamPtr(rotation, float32be, 1);
 	ppcDefineParamPtr(inputRange, float32be, 2);
 	ppcDefineParamPtr(radius, float32be, 3);
-	inputLog_printf("VPADGetCrossStickEmulationParamsR(%d)", channel);
+	cemuLog_log(LogType::InputAPI, "VPADGetCrossStickEmulationParamsR({})", channel);
 
 	if (channel < VPAD_MAX_CONTROLLERS)
 	{
@@ -789,7 +786,7 @@ void vpadExport_VPADGetCrossStickEmulationParamsR(PPCInterpreter_t* hCPU)
 void vpadExport_VPADGetButtonProcMode(PPCInterpreter_t* hCPU)
 {
 	ppcDefineParamU32(channel, 0);
-	inputLog_printf("VPADGetButtonProcMode(%d)", channel);
+	cemuLog_log(LogType::InputAPI, "VPADGetButtonProcMode({})", channel);
 
 	if (channel < VPAD_MAX_CONTROLLERS)
 	{
@@ -806,7 +803,7 @@ void vpadExport_VPADSetButtonProcMode(PPCInterpreter_t* hCPU)
 {
 	ppcDefineParamU32(channel, 0);
 	ppcDefineParamU8(mode, 1);
-	inputLog_printf("VPADSetButtonProcMode(%d, %d)", channel, mode);
+	cemuLog_log(LogType::InputAPI, "VPADSetButtonProcMode({}, {})", channel, mode);
 
 	if (channel < VPAD_MAX_CONTROLLERS)
 	{
@@ -824,7 +821,7 @@ void vpadExport_VPADSetLcdMode(PPCInterpreter_t* hCPU)
 {
 	ppcDefineParamU32(channel, 0);
 	ppcDefineParamU32(mode, 1);
-	inputLog_printf("VPADSetLcdMode(%d, %d)", channel, mode);
+	cemuLog_log(LogType::InputAPI, "VPADSetLcdMode({}, {})", channel, mode);
 
 	if (channel < VPAD_MAX_CONTROLLERS)
 	{
@@ -841,7 +838,7 @@ void vpadExport_VPADGetLcdMode(PPCInterpreter_t* hCPU)
 {
 	ppcDefineParamU32(channel, 0);
 	ppcDefineParamPtr(mode, uint32be, 1);
-	inputLog_printf("VPADGetLcdMode(%d)", channel);
+	cemuLog_log(LogType::InputAPI, "VPADGetLcdMode({})", channel);
 
 	if (channel < VPAD_MAX_CONTROLLERS)
 	{
@@ -860,11 +857,11 @@ void vpadExport_VPADControlMotor(PPCInterpreter_t* hCPU)
 	ppcDefineParamU32(channel, 0);
 	ppcDefineParamUStr(pattern, 1);
 	ppcDefineParamU8(length, 2);
-	inputLog_printf("VPADControlMotor(%d, _, %d)", channel, length);
+	cemuLog_log(LogType::InputAPI, "VPADControlMotor({}, _, {})", channel, length);
 
 	if (length > 120)
 	{
-		inputLog_printf("VPADControlMotor() - length too high with %d of 120", length);
+		cemuLog_log(LogType::InputAPI, "VPADControlMotor() - length too high with {} of 120", length);
 		length = 120;
 	}
 
@@ -892,7 +889,7 @@ void vpadExport_VPADControlMotor(PPCInterpreter_t* hCPU)
 void vpadExport_VPADStopMotor(PPCInterpreter_t* hCPU)
 {
 	ppcDefineParamU32(channel, 0);
-	inputLog_printf("VPADStopMotor(%d)", channel);
+	cemuLog_log(LogType::InputAPI, "VPADStopMotor({})", channel);
 
 	if (const auto controller = InputManager::instance().get_vpad_controller(channel))
 	{
@@ -912,7 +909,7 @@ void vpadExport_VPADSetTPCalibrationParam(PPCInterpreter_t* hCPU)
 	{
 		VPADTPCalibrationParam* calibrationParam = params.GetPtr();
 
-		inputLog_printf("VPADSetTPCalibrationParam(%d, %d, %d, %f, %f)", channel, (uint16)calibrationParam->offsetX, (uint16)calibrationParam->offsetX, (float)calibrationParam->scaleX, (float)calibrationParam->scaleY);
+		cemuLog_log(LogType::InputAPI, "VPADSetTPCalibrationParam({}, {}, {}, {}, {})", channel, (uint16)calibrationParam->offsetX, (uint16)calibrationParam->offsetX, (float)calibrationParam->scaleX, (float)calibrationParam->scaleY);
 
 		vpadTPCalibrationParam[channel].offsetX = calibrationParam->offsetX;
 		vpadTPCalibrationParam[channel].offsetX = calibrationParam->offsetY;
@@ -931,7 +928,7 @@ void vpadExport_VPADGetTPCalibrationParam(PPCInterpreter_t* hCPU)
 {
 	ppcDefineParamU32(channel, 0);
 	ppcDefineParamStructPtr(calibrationParam, VPADTPCalibrationParam, 1);
-	inputLog_printf("VPADSetTPCalibrationParam(%d)", channel);
+	cemuLog_log(LogType::InputAPI, "VPADSetTPCalibrationParam({})", channel);
 
 	calibrationParam->offsetX = vpadTPCalibrationParam[channel].offsetX;
 	calibrationParam->offsetY = vpadTPCalibrationParam[channel].offsetY;
@@ -946,7 +943,7 @@ void vpadExport_VPADGetTPCalibratedPoint(PPCInterpreter_t* hCPU)
 	ppcDefineParamU32(channel, 0);
 	ppcDefineParamStructPtr(outputDisplay, VPADTPData_t, 1);
 	ppcDefineParamStructPtr(inputRaw, VPADTPData_t, 2);
-	inputLog_printf("VPADGetTPCalibratedPoint(%d)", channel);
+	cemuLog_log(LogType::InputAPI, "VPADGetTPCalibratedPoint({})", channel);
 
 	memmove(outputDisplay, inputRaw, sizeof(VPADTPData_t));
 
@@ -973,7 +970,7 @@ void vpadExport_VPADGetTPCalibratedPointEx(PPCInterpreter_t* hCPU)
 	ppcDefineParamS32(tpResolution, 1);
 	ppcDefineParamStructPtr(outputDisplay, VPADTPData_t, 2);
 	ppcDefineParamStructPtr(inputRaw, VPADTPData_t, 3);
-	inputLog_printf("VPADGetTPCalibratedPointEx(%d)", channel);
+	cemuLog_log(LogType::InputAPI, "VPADGetTPCalibratedPointEx({})", channel);
 
 	//debug_printf("TPInput: %d %d %04x %04x\n", _swapEndianU16(inputRaw->touch), _swapEndianU16(inputRaw->validity), _swapEndianU16(inputRaw->x), _swapEndianU16(inputRaw->y));
 	memmove(outputDisplay, inputRaw, sizeof(VPADTPData_t));
@@ -1017,7 +1014,8 @@ void vpadExport_VPADSetGyroDirection(PPCInterpreter_t* hCPU)
 {
 	ppcDefineParamU32(channel, 0);
 	ppcDefineParamStructPtr(dir, VPADDir, 1);
-	inputLog_printf("VPADSetGyroDirection(%d, <<%f, %f, %f>, <%f, %f, %f>, <%f, %f, %f>>)", channel, (float)dir->x.x, (float)dir->x.y, (float)dir->x.z
+	cemuLog_log(LogType::InputAPI, "VPADSetGyroDirection({}, <<{:f}, {:f}, {:f}>, <{:f}, {:f}, {:f}>, <{:f}, {:f}, {:f}>>)", channel
+		, (float)dir->x.x, (float)dir->x.y, (float)dir->x.z
 		, (float)dir->y.x, (float)dir->y.y, (float)dir->y.z
 		, (float)dir->z.x, (float)dir->z.y, (float)dir->z.z);
 
@@ -1037,7 +1035,7 @@ void vpadExport_VPADGetGyroZeroDriftMode(PPCInterpreter_t* hCPU)
 {
 	ppcDefineParamU32(channel, 0);
 	ppcDefineParamMEMPTR(gyroMode, uint32be, 1);
-	inputLog_printf("VPADGetGyroZeroDriftMode(%d)", channel);
+	cemuLog_log(LogType::InputAPI, "VPADGetGyroZeroDriftMode({})", channel);
 
 	if (channel < VPAD_MAX_CONTROLLERS)
 	{
@@ -1056,7 +1054,7 @@ void vpadExport_VPADSetGyroZeroDriftMode(PPCInterpreter_t* hCPU)
 {
 	ppcDefineParamU32(channel, 0);
 	ppcDefineParamU32(gyroMode, 1);
-	inputLog_printf("VPADSetGyroZeroDriftMode(%d, %d)", channel, gyroMode);
+	cemuLog_log(LogType::InputAPI, "VPADSetGyroZeroDriftMode({}, {})", channel, gyroMode);
 
 	if (channel < VPAD_MAX_CONTROLLERS)
 	{
@@ -1140,7 +1138,7 @@ namespace vpad
 			
 			if(const auto controller = instance.get_vpad_controller(i))
 			{
-				inputLog_printf("Calling VPADSamplingCallback(%d)", i);
+				cemuLog_log(LogType::InputAPI, "Calling VPADSamplingCallback({})", i);
 				PPCCoreCallback(g_vpad.controller_data[i].sampling_callback, i);
 			}
 		}
@@ -1151,7 +1149,7 @@ namespace vpad
 	void start()
 	{
 		coreinit::OSCreateAlarm(&g_vpad.alarm);
-		const uint64 start_tick = coreinit::coreinit_getOSTime();
+		const uint64 start_tick = coreinit::OSGetTime();
 		const uint64 period_tick = coreinit::EspressoTime::GetTimerClock() * 5 / 1000;
 		const MPTR handler = PPCInterpreter_makeCallableExportDepr(TickFunction);
 		coreinit::OSSetPeriodicAlarm(&g_vpad.alarm, start_tick, period_tick, handler);
@@ -1159,9 +1157,9 @@ namespace vpad
 
 void load()
 {
-	cafeExportRegister("vpad", VPADSetBtnRepeat, LogType::Input);
-	cafeExportRegister("vpad", VPADSetSamplingCallback, LogType::Input);
-	cafeExportRegister("vpad", VPADRead, LogType::Input);
+	cafeExportRegister("vpad", VPADSetBtnRepeat, LogType::InputAPI);
+	cafeExportRegister("vpad", VPADSetSamplingCallback, LogType::InputAPI);
+	cafeExportRegister("vpad", VPADRead, LogType::InputAPI);
 	
 	osLib_addFunction("vpad", "VPADGetAccParam", vpadExport_VPADGetAccParam);
 	osLib_addFunction("vpad", "VPADSetAccParam", vpadExport_VPADSetAccParam);
@@ -1206,4 +1204,4 @@ void load()
 	osLib_addFunction("vpad", "VPADSetGyroDirReviseParam", vpadExport_VPADSetGyroDirReviseParam);
 
 }
-}
\ No newline at end of file
+}
diff --git a/src/Cafe/OS/libs/zlib125/zlib125.cpp b/src/Cafe/OS/libs/zlib125/zlib125.cpp
index 72855c61..aec6e8c3 100644
--- a/src/Cafe/OS/libs/zlib125/zlib125.cpp
+++ b/src/Cafe/OS/libs/zlib125/zlib125.cpp
@@ -28,8 +28,7 @@ static_assert(sizeof(z_stream_ppc2) == 0x38);
 voidpf zcallocWrapper(voidpf opaque, uInt items, uInt size)
 {
 	z_stream_ppc2* zstream = (z_stream_ppc2*)opaque;
-	
-	PPCInterpreter_t* hCPU = ppcInterpreterCurrentInstance;
+	PPCInterpreter_t* hCPU = PPCInterpreter_getCurrentInstance();
 	hCPU->gpr[3] = zstream->opaque.GetMPTR();
 	hCPU->gpr[4] = items;
 	hCPU->gpr[5] = size;
@@ -41,7 +40,7 @@ voidpf zcallocWrapper(voidpf opaque, uInt items, uInt size)
 void zcfreeWrapper(voidpf opaque, voidpf baseIndex)
 {
 	z_stream_ppc2* zstream = (z_stream_ppc2*)opaque;
-	PPCInterpreter_t* hCPU = ppcInterpreterCurrentInstance;
+	PPCInterpreter_t* hCPU = PPCInterpreter_getCurrentInstance();
 	hCPU->gpr[3] = zstream->opaque.GetMPTR();
 	hCPU->gpr[4] = memory_getVirtualOffsetFromPointer(baseIndex);
 	PPCCore_executeCallbackInternal(zstream->zfree.GetMPTR());
@@ -214,6 +213,32 @@ void zlib125Export_inflateReset2(PPCInterpreter_t* hCPU)
 	osLib_returnFromFunction(hCPU, r);
 }
 
+void zlib125Export_deflateInit_(PPCInterpreter_t* hCPU)
+{
+	ppcDefineParamStructPtr(zstream, z_stream_ppc2, 0);
+	ppcDefineParamS32(level, 1);
+	ppcDefineParamStr(version, 2);
+	ppcDefineParamS32(streamsize, 3);
+
+	z_stream hzs;
+	zlib125_setupHostZStream(zstream, &hzs, false);
+
+	// setup internal memory allocator if requested
+	if (zstream->zalloc == nullptr)
+		zstream->zalloc = PPCInterpreter_makeCallableExportDepr(zlib125_zcalloc);
+	if (zstream->zfree == nullptr)
+		zstream->zfree = PPCInterpreter_makeCallableExportDepr(zlib125_zcfree);
+
+	if (streamsize != sizeof(z_stream_ppc2))
+		assert_dbg();
+
+	sint32 r = deflateInit_(&hzs, level, version, sizeof(z_stream));
+
+	zlib125_setupUpdateZStream(&hzs, zstream);
+
+	osLib_returnFromFunction(hCPU, r);
+}
+
 void zlib125Export_deflateInit2_(PPCInterpreter_t* hCPU)
 {
 	ppcDefineParamStructPtr(zstream, z_stream_ppc2, 0);
@@ -346,6 +371,7 @@ namespace zlib
 		osLib_addFunction("zlib125", "inflateReset", zlib125Export_inflateReset);
 		osLib_addFunction("zlib125", "inflateReset2", zlib125Export_inflateReset2);
 
+		osLib_addFunction("zlib125", "deflateInit_", zlib125Export_deflateInit_);
 		osLib_addFunction("zlib125", "deflateInit2_", zlib125Export_deflateInit2_);
 		osLib_addFunction("zlib125", "deflateBound", zlib125Export_deflateBound);
 		osLib_addFunction("zlib125", "deflate", zlib125Export_deflate);
diff --git a/src/Cafe/TitleList/AppType.h b/src/Cafe/TitleList/AppType.h
new file mode 100644
index 00000000..deca7560
--- /dev/null
+++ b/src/Cafe/TitleList/AppType.h
@@ -0,0 +1,23 @@
+#pragma once
+
+enum class APP_TYPE : uint32
+{
+	GAME = 0x80000000,
+	GAME_UPDATE = 0x0800001B,
+	GAME_DLC = 0x0800000E,
+	// data titles
+	VERSION_DATA_TITLE = 0x10000015,
+	DRC_FIRMWARE = 0x10000013,
+	DRC_TEXTURE_ATLAS = 0x1000001A,
+};
+
+// allow direct comparison with uint32
+inline bool operator==(APP_TYPE lhs, uint32 rhs)
+{
+	return static_cast<uint32>(lhs) == rhs;
+}
+
+inline bool operator==(uint32 lhs, APP_TYPE rhs)
+{
+	return lhs == static_cast<uint32>(rhs);
+}
diff --git a/src/Cafe/TitleList/BaseInfo.cpp b/src/Cafe/TitleList/BaseInfo.cpp
deleted file mode 100644
index 528ba948..00000000
--- a/src/Cafe/TitleList/BaseInfo.cpp
+++ /dev/null
@@ -1,68 +0,0 @@
-#include "BaseInfo.h"
-
-#include "config/CemuConfig.h"
-#include "Cafe/Filesystem/fsc.h"
-#include "Cafe/Filesystem/FST/FST.h"
-
-sint32 BaseInfo::GetLanguageIndex(std::string_view language)
-{
-	if (language == "ja")
-		return (sint32)CafeConsoleLanguage::JA;
-	else if (language == "en")
-		return (sint32)CafeConsoleLanguage::EN;
-	else if (language == "fr")
-		return (sint32)CafeConsoleLanguage::FR;
-	else if (language == "de")
-		return (sint32)CafeConsoleLanguage::DE;
-	else if (language == "it")
-		return (sint32)CafeConsoleLanguage::IT;
-	else if (language == "es")
-		return (sint32)CafeConsoleLanguage::ES;
-	else if (language == "zhs")
-		return (sint32)CafeConsoleLanguage::ZH;
-	else if (language == "ko")
-		return (sint32)CafeConsoleLanguage::KO;
-	else if (language == "nl")
-		return (sint32)CafeConsoleLanguage::NL;
-	else if (language == "pt")
-		return (sint32)CafeConsoleLanguage::PT;
-	else if (language == "ru")
-		return (sint32)CafeConsoleLanguage::RU;
-	else if (language == "zht")
-		return (sint32)CafeConsoleLanguage::ZH;
-	return -1;
-}
-
-
-std::unique_ptr<uint8[]> BaseInfo::ReadFSCFile(std::string_view filename, uint32& size) const
-{
-	size = 0;
-	sint32 fscStatus = 0;
-	// load and parse meta.xml
-	FSCVirtualFile* file = fsc_open(const_cast<char*>(std::string(filename).c_str()), FSC_ACCESS_FLAG::OPEN_FILE | FSC_ACCESS_FLAG::READ_PERMISSION, &fscStatus);
-	if (file)
-	{
-		size = fsc_getFileSize(file);
-		auto buffer = std::make_unique<uint8[]>(size);
-		fsc_readFile(file, buffer.get(), size);
-		fsc_close(file);
-		return buffer;
-	}
-
-	return nullptr;
-}
-
-std::unique_ptr<uint8[]> BaseInfo::ReadVirtualFile(FSTVolume* volume, std::string_view filename, uint32& size) const
-{
-	size = 0;
-	FSTFileHandle fileHandle;
-	if (!volume->OpenFile(filename, fileHandle, true))
-		return nullptr;
-
-	size = volume->GetFileSize(fileHandle);
-	auto buffer = std::make_unique<uint8[]>(size);
-	volume->ReadFile(fileHandle, 0, size, buffer.get());
-
-	return buffer;
-}
-
diff --git a/src/Cafe/TitleList/BaseInfo.h b/src/Cafe/TitleList/BaseInfo.h
deleted file mode 100644
index 27578235..00000000
--- a/src/Cafe/TitleList/BaseInfo.h
+++ /dev/null
@@ -1,37 +0,0 @@
-#pragma once
-
-namespace pugi
-{
-	struct xml_parse_result;
-	class xml_document;
-}
-
-class BaseInfo
-{
-public:
-	enum class GameType
-	{
-		FSC, // using fsc API
-		Directory, // rpx/meta
-		Image, // wud/wux
-	};
-	
-	virtual ~BaseInfo() = default;
-
-	[[nodiscard]] const fs::path& GetPath() const { return m_type_path; }
-	[[nodiscard]] GameType GetGameType() const { return m_type; }
-	
-protected:
-	
-	GameType m_type;
-	fs::path m_type_path; // empty / base dir / wud path
-
-	virtual void ParseDirectory(const fs::path& filename) = 0;
-	virtual bool ParseFile(const fs::path& filename) = 0;
-
-	
-	[[nodiscard]] std::unique_ptr<uint8[]> ReadFSCFile(std::string_view filename, uint32& size) const;
-	[[nodiscard]] std::unique_ptr<uint8[]> ReadVirtualFile(class FSTVolume* volume, std::string_view filename, uint32& size) const;
-
-	[[nodiscard]] static sint32 GetLanguageIndex(std::string_view language);
-};
\ No newline at end of file
diff --git a/src/Cafe/TitleList/GameInfo.h b/src/Cafe/TitleList/GameInfo.h
index 3a2e6121..6e922b93 100644
--- a/src/Cafe/TitleList/GameInfo.h
+++ b/src/Cafe/TitleList/GameInfo.h
@@ -1,7 +1,6 @@
 #pragma once
 
 #include "config/CemuConfig.h"
-#include "MetaInfo.h"
 #include "TitleInfo.h"
 #include "config/ActiveSettings.h"
 
@@ -21,19 +20,20 @@ public:
 		return m_base.IsValid(); // at least the base must be valid for this to be a runnable title
 	}
 
+	bool IsSystemDataTitle() const
+	{
+		return m_base.IsSystemDataTitle();
+	}
+
 	void SetBase(const TitleInfo& titleInfo)
 	{
-		m_base = titleInfo;
+		if (IsPrioritizedVersionOrFormat(m_base, titleInfo))
+			m_base = titleInfo;
 	}
 
 	void SetUpdate(const TitleInfo& titleInfo)
 	{
-		if (HasUpdate())
-		{
-			if (titleInfo.GetAppTitleVersion() > m_update.GetAppTitleVersion())
-				m_update = titleInfo;
-		}
-		else
+		if (IsPrioritizedVersionOrFormat(m_update, titleInfo))
 			m_update = titleInfo;
 	}
 
@@ -49,7 +49,7 @@ public:
 		auto it = std::find_if(m_aoc.begin(), m_aoc.end(), [aocTitleId](const TitleInfo& rhs) { return rhs.GetAppTitleId() == aocTitleId; });
 		if (it != m_aoc.end())
 		{
-			if(it->GetAppTitleVersion() >= aocVersion)
+			if (!IsPrioritizedVersionOrFormat(*it, titleInfo))
 				return;
 			m_aoc.erase(it);
 		}
@@ -85,7 +85,7 @@ public:
 	std::string GetTitleName()
 	{
 		cemu_assert_debug(m_base.IsValid());
-		return m_base.GetTitleName(); // long name
+		return m_base.GetMetaTitleName(); // long name
 	}
 
 	uint16 GetVersion() const
@@ -95,6 +95,13 @@ public:
 		return m_base.GetAppTitleVersion();
 	}
 
+	uint32 GetSDKVersion() const
+	{
+		if (m_update.IsValid())
+			return m_update.GetAppSDKVersion();
+		return m_base.GetAppSDKVersion();
+	}
+
 	CafeConsoleRegion GetRegion() const
 	{
 		if (m_update.IsValid())
@@ -115,6 +122,25 @@ public:
 	}
 
 private:
+  	bool IsPrioritizedVersionOrFormat(const TitleInfo& currentTitle, const TitleInfo& newTitle)
+	{
+		if (!currentTitle.IsValid())
+			return true; // always prefer a valid title over an invalid one
+		// always prefer higher version
+		if (newTitle.GetAppTitleVersion() > currentTitle.GetAppTitleVersion())
+			return true;
+		// never prefer lower version
+		if (newTitle.GetAppTitleVersion() < currentTitle.GetAppTitleVersion())
+			return false;
+		// for users which have both NUS and non-NUS titles in their games folder we want to prioritize non-NUS formats
+		// this is to stay consistent with previous Cemu versions which did not support NUS format at all
+		TitleInfo::TitleDataFormat currentFormat = currentTitle.GetFormat();
+		TitleInfo::TitleDataFormat newFormat = newTitle.GetFormat();
+		if (currentFormat != TitleInfo::TitleDataFormat::NUS && newFormat == TitleInfo::TitleDataFormat::NUS)
+			return false;
+		return true;
+	};
+
 	TitleInfo m_base;
 	TitleInfo m_update;
 	std::vector<TitleInfo> m_aoc;
diff --git a/src/Cafe/TitleList/MetaInfo.cpp b/src/Cafe/TitleList/MetaInfo.cpp
deleted file mode 100644
index 3ae77a05..00000000
--- a/src/Cafe/TitleList/MetaInfo.cpp
+++ /dev/null
@@ -1,180 +0,0 @@
-#include "MetaInfo.h"
-#include "Cafe/Filesystem/fsc.h"
-
-#include "pugixml.hpp"
-#include "Cafe/Filesystem/FST/FST.h"
-
-MetaInfo::MetaInfo()
-{
-	m_type = GameType::FSC;
-	
-	uint32 meta_size;
-	const auto meta_data = ReadFSCFile("vol/meta/meta.xml", meta_size);
-	if (meta_size == 0 || !meta_data)
-		throw std::runtime_error("meta.xml missing");
-
-	pugi::xml_document meta_doc;
-	ParseMetaFile(meta_doc, meta_doc.load_buffer_inplace(meta_data.get(), meta_size));
-}
-
-MetaInfo::MetaInfo(const fs::path& filename)
-{
-	if (!fs::exists(filename))
-		throw std::invalid_argument("filename doesn't exist");
-
-	if (fs::is_directory(filename))
-	{
-		MetaInfo::ParseDirectory(filename);
-		m_type = GameType::Directory;
-		m_type_path = filename;
-	}
-	else
-		MetaInfo::ParseFile(filename);
-}
-
-std::string MetaInfo::GetName(CafeConsoleLanguage language) const
-{
-	std::string long_name{ GetLongName(language) };
-	const auto nl = long_name.find(L'\n');
-	if (nl != std::string::npos)
-		long_name.replace(nl, 1, " - ");
-
-	return long_name;
-}
-
-const std::string& MetaInfo::GetLongName(CafeConsoleLanguage language) const
-{
-	return m_long_name[(int)language].empty() ? m_long_name[(int)CafeConsoleLanguage::EN] : m_long_name[(int)language];
-}
-
-const std::string& MetaInfo::GetShortName(CafeConsoleLanguage language) const
-{
-	return m_short_name[(int)language].empty() ? m_short_name[(int)CafeConsoleLanguage::EN] : m_short_name[(int)language];
-}
-
-const std::string& MetaInfo::GetPublisher(CafeConsoleLanguage language) const
-{
-	return m_publisher[(int)language].empty() ? m_publisher[(int)CafeConsoleLanguage::EN] : m_publisher[(int)language];
-}
-
-void MetaInfo::ParseDirectory(const fs::path& filename)
-{
-	const auto meta_dir = fs::path(filename).append(L"meta");
-	if (!fs::exists(meta_dir) || !fs::is_directory(meta_dir))
-		throw std::invalid_argument("meta directory missing");
-
-	const auto meta_file = meta_dir / L"meta.xml";
-	if (!fs::exists(meta_file) || !fs::is_regular_file(meta_file))
-		throw std::invalid_argument("meta.xml missing");
-
-	ParseMetaFile(meta_file.wstring());
-}
-
-bool MetaInfo::ParseFile(const fs::path& filename)
-{
-	const auto extension = filename.extension();
-	if (filename.filename() != "meta.xml")
-		return false;
-	
-	const auto base_dir = filename.parent_path().parent_path();
-
-	ParseMetaFile(filename);
-	m_type = GameType::Directory;
-	m_type_path = base_dir;
-	return true;
-}
-
-void MetaInfo::ParseMetaFile(const fs::path& meta_file)
-{
-	pugi::xml_document doc;
-	const auto result = doc.load_file(meta_file.wstring().c_str());
-	ParseMetaFile(doc, result);
-}
-
-void MetaInfo::ParseMetaFile(const pugi::xml_document& doc, const pugi::xml_parse_result& result)
-{
-	if (!result)
-		throw std::invalid_argument(fmt::format("error when parsing the meta.xml: {}", result.description()));
-
-	const auto root = doc.child("menu");
-	if (!root)
-		throw std::invalid_argument("meta.xml invalid");
-
-	for (const auto& child : root.children())
-	{
-		std::string_view name = child.name();
-		if (name == "title_version")
-			m_version = child.text().as_uint();
-		else if (name == "product_code")
-			m_product_code = child.text().as_string();
-		else if (name == "company_code")
-			m_company_code = child.text().as_string();
-		else if (name == "content_platform")
-			m_content_platform = child.text().as_string();
-		else if (name == "title_id")
-			m_title_id = std::stoull(child.text().as_string(), nullptr, 16);
-		else if (name == "region")
-			m_region = (CafeConsoleRegion)child.text().as_uint();
-		else if (boost::starts_with(name, "longname_"))
-		{
-			const sint32 index = GetLanguageIndex(name.substr(std::size("longname_") - 1));
-			if (index != -1)
-				m_long_name[index] = child.text().as_string();
-		}
-		else if (boost::starts_with(name, L"shortname_"))
-		{
-			const sint32 index = GetLanguageIndex(name.substr(std::size("shortname_") - 1));
-			if (index != -1)
-				m_short_name[index] = child.text().as_string();
-		}
-		else if (boost::starts_with(name, L"publisher_"))
-		{
-			const sint32 index = GetLanguageIndex(name.substr(std::size("publisher_") - 1));
-			if (index != -1)
-				m_publisher[index] = child.text().as_string();
-		}
-	}
-}
-
-std::unique_ptr<uint8[]> MetaInfo::GetIcon(uint32& size) const
-{
-	size = 0;
-	switch (m_type)
-	{
-	case GameType::FSC:
-		return ReadFSCFile("vol/meta/iconTex.tga", size);
-	case GameType::Directory:
-	{
-		cemu_assert_debug(!m_type_path.empty());
-		const auto icon = fs::path(m_type_path).append(L"meta").append(L"iconTex.tga");
-		std::ifstream file(icon, std::ios::binary | std::ios::ate);
-		if (file.is_open())
-		{
-			size = file.tellg();
-			if (size > 0)
-			{
-				file.seekg(0, std::ios::beg);
-				auto result = std::make_unique<uint8[]>(size);
-				file.read((char*)result.get(), size);
-				return result;
-			}
-		}
-		return nullptr;
-	}
-	case GameType::Image:
-	{
-		cemu_assert_debug(!m_type_path.empty());
-		FSTVolume* volume = FSTVolume::OpenFromDiscImage(m_type_path);
-		if (volume)
-		{
-			auto result = ReadVirtualFile(volume, "meta/iconTex.tga", size);
-			delete volume;
-			return result;
-		}
-		return nullptr;
-	}
-	default:
-		UNREACHABLE;
-	}
-	return nullptr;
-}
diff --git a/src/Cafe/TitleList/MetaInfo.h b/src/Cafe/TitleList/MetaInfo.h
deleted file mode 100644
index bcd511c3..00000000
--- a/src/Cafe/TitleList/MetaInfo.h
+++ /dev/null
@@ -1,61 +0,0 @@
-#pragma once
-
-#include "BaseInfo.h"
-#include "config/CemuConfig.h"
-
-class MetaInfo : public BaseInfo
-{
-public:
-	MetaInfo();
-	MetaInfo(const fs::path& filename);
-
-	// returns long name with replaces newlines to ' - '
-	[[nodiscard]] std::string GetName(CafeConsoleLanguage language = CafeConsoleLanguage::EN) const;
-	
-	[[nodiscard]] uint64 GetTitleId() const { return m_title_id; }
-	[[nodiscard]] uint32 GetTitleIdHigh() const { return (uint32)(GetTitleId() >> 32); }
-	[[nodiscard]] uint32 GetTitleIdLow() const { return (uint32)(GetTitleId() & 0xFFFFFFFF); }
-	
-	[[nodiscard]] uint64 GetBaseTitleId() const { return m_title_id & ~0xF00000000ULL; }
-	[[nodiscard]] uint32 GetBaseTitleIdHigh() const { return (uint32)(GetBaseTitleId() >> 32); }
-	[[nodiscard]] uint32 GetBaseTitleIdLow() const { return (uint32)(GetBaseTitleId() & 0xFFFFFFFF); }
-
-	[[nodiscard]] uint64 GetUpdateTitleId() const { return GetBaseTitleId() | 0xE00000000ULL; }
-	[[nodiscard]] uint32 GetUpdateTitleIdHigh() const { return (uint32)(GetUpdateTitleId() >> 32); }
-	[[nodiscard]] uint32 GetUpdateTitleIdLow() const { return (uint32)(GetUpdateTitleId() & 0xFFFFFFFF); }
-
-	[[nodiscard]] uint64 GetDLCTitleId() const { return GetBaseTitleId() | 0xC00000000ULL; }
-	[[nodiscard]] uint32 GetDLCTitleIdHigh() const { return (uint32)(GetDLCTitleId() >> 32); }
-	[[nodiscard]] uint32 GetDLCTitleIdLow() const { return (uint32)(GetDLCTitleId() & 0xFFFFFFFF); }
-
-	[[nodiscard]] const std::string& GetLongName(CafeConsoleLanguage language) const;
-	[[nodiscard]] const std::string& GetShortName(CafeConsoleLanguage language) const;
-	[[nodiscard]] const std::string& GetPublisher(CafeConsoleLanguage language) const;
-	[[nodiscard]] const std::string& GetProductCode() const { return m_product_code; }
-	[[nodiscard]] const std::string& GetCompanyCode() const { return m_company_code; }
-	[[nodiscard]] const std::string& GetContentPlatform() const { return m_content_platform; }
-	[[nodiscard]] uint32 GetVersion() const { return m_version; }
-	[[nodiscard]] CafeConsoleRegion GetRegion() const { return m_region; }
-
-	[[nodiscard]] std::unique_ptr<uint8[]> GetIcon(uint32& size) const;
-
-protected:
-	// meta.xml
-	uint32 m_version;
-	std::string m_product_code;
-	std::string m_company_code;
-	std::string m_content_platform;
-	uint64 m_title_id;
-	CafeConsoleRegion m_region;
-
-	std::array<std::string, 12> m_long_name;
-	std::array<std::string, 12> m_short_name;
-	std::array<std::string, 12> m_publisher;
-
-	void ParseDirectory(const fs::path& filename) override;
-	bool ParseFile(const fs::path& filename) override;
-
-	void ParseMetaFile(const fs::path& meta_file);
-	void ParseMetaFile(const pugi::xml_document& doc, const pugi::xml_parse_result& result);
-};
-
diff --git a/src/Cafe/TitleList/ParsedMetaXml.h b/src/Cafe/TitleList/ParsedMetaXml.h
index 2cb2e7a8..f1aee37e 100644
--- a/src/Cafe/TitleList/ParsedMetaXml.h
+++ b/src/Cafe/TitleList/ParsedMetaXml.h
@@ -16,6 +16,8 @@ struct ParsedMetaXml
 	std::array<std::string, 12> m_short_name;
 	std::array<std::string, 12> m_publisher;
 
+	uint32 m_olv_accesskey;
+
 	std::string GetShortName(CafeConsoleLanguage languageId) const
 	{
 		return m_short_name[(size_t)languageId].empty() ? m_short_name[(size_t)CafeConsoleLanguage::EN] : m_short_name[(size_t)languageId];
@@ -51,6 +53,11 @@ struct ParsedMetaXml
 		return m_company_code;
 	}
 
+	uint32 GetOlvAccesskey() const
+	{
+		return m_olv_accesskey;
+	}
+
 	static ParsedMetaXml* Parse(uint8* xmlData, size_t xmlSize)
 	{
 		if (xmlSize == 0)
@@ -83,8 +90,11 @@ struct ParsedMetaXml
 			else if (boost::starts_with(name, "longname_"))
 			{
 				const sint32 index = GetLanguageIndex(name.substr(std::size("longname_") - 1));
-				if (index != -1)
-					parsedMetaXml->m_long_name[index] = child.text().as_string();
+				if (index != -1){
+					std::string longname = child.text().as_string();
+					std::replace_if(longname.begin(), longname.end(), [](char c) { return c == '\r' || c == '\n';}, ' ');
+					parsedMetaXml->m_long_name[index] = longname;
+				}
 			}
 			else if (boost::starts_with(name, L"shortname_"))
 			{
@@ -98,6 +108,8 @@ struct ParsedMetaXml
 				if (index != -1)
 					parsedMetaXml->m_publisher[index] = child.text().as_string();
 			}
+			else if (boost::starts_with(name, L"olv_accesskey"))
+				parsedMetaXml->m_olv_accesskey = child.text().as_uint(-1);
 		}
 		if (parsedMetaXml->m_title_id == 0)
 		{
diff --git a/src/Cafe/TitleList/SaveList.cpp b/src/Cafe/TitleList/SaveList.cpp
index a86e8498..d0c0e3e2 100644
--- a/src/Cafe/TitleList/SaveList.cpp
+++ b/src/Cafe/TitleList/SaveList.cpp
@@ -1,5 +1,6 @@
 #include "SaveList.h"
 #include <charconv>
+#include <util/helpers/helpers.h>
 
 std::mutex sSLMutex;
 fs::path sSLMLCPath;
@@ -44,6 +45,7 @@ void CafeSaveList::Refresh()
 
 void CafeSaveList::RefreshThreadWorker()
 {
+	SetThreadName("SaveListWorker");
 	// clear save list
 	for (auto& itSaveInfo : sSLList)
 	{
diff --git a/src/Cafe/TitleList/TitleId.h b/src/Cafe/TitleList/TitleId.h
index b7f63b13..073472d9 100644
--- a/src/Cafe/TitleList/TitleId.h
+++ b/src/Cafe/TitleList/TitleId.h
@@ -13,6 +13,7 @@ public:
 		/* 00 */ BASE_TITLE = 0x00, // eShop and disc titles
 		/* 02 */ BASE_TITLE_DEMO = 0x02,
 		/* 0E */ BASE_TITLE_UPDATE = 0x0E, // update for BASE_TITLE (and maybe BASE_TITLE_DEMO?)
+		/* 0F */ HOMEBREW = 0x0F,
 		/* 0C */ AOC = 0x0C, // DLC
 		/* 10 */ SYSTEM_TITLE = 0x10, // eShop etc
 		/* 1B */ SYSTEM_DATA = 0x1B,
@@ -43,6 +44,8 @@ public:
 			return TITLE_TYPE::BASE_TITLE_DEMO;
 		case 0x0E:
 			return TITLE_TYPE::BASE_TITLE_UPDATE;
+		case 0x0F:
+			return TITLE_TYPE::HOMEBREW;
 		case 0x0C:
 			return TITLE_TYPE::AOC;
 		case 0x10:
diff --git a/src/Cafe/TitleList/TitleInfo.cpp b/src/Cafe/TitleList/TitleInfo.cpp
index c58e1841..12131058 100644
--- a/src/Cafe/TitleList/TitleInfo.cpp
+++ b/src/Cafe/TitleList/TitleInfo.cpp
@@ -1,13 +1,14 @@
 #include "TitleInfo.h"
-
 #include "Cafe/Filesystem/fscDeviceHostFS.h"
+#include "Cafe/Filesystem/WUHB/WUHBReader.h"
 #include "Cafe/Filesystem/FST/FST.h"
-
 #include "pugixml.hpp"
 #include "Common/FileStream.h"
-
 #include <zarchive/zarchivereader.h>
+#include "util/IniParser/IniParser.h"
+#include "util/crypto/crc32.h"
 #include "config/ActiveSettings.h"
+#include "util/helpers/helpers.h"
 
 // detect format by reading file header/footer
 CafeTitleFileType DetermineCafeSystemFileType(fs::path filePath)
@@ -77,6 +78,7 @@ TitleInfo::TitleInfo(const fs::path& path, std::string_view subPath)
 	if (!path.has_filename())
 	{
 		m_isValid = false;
+		SetInvalidReason(InvalidReason::BAD_PATH_OR_INACCESSIBLE);
 		return;
 	}
 	m_isValid = true;
@@ -98,7 +100,9 @@ TitleInfo::TitleInfo(const TitleInfo::CachedInfo& cachedInfo)
 	m_isValid = false;
 	if (cachedInfo.titleDataFormat != TitleDataFormat::HOST_FS &&
 		cachedInfo.titleDataFormat != TitleDataFormat::WIIU_ARCHIVE &&
+		cachedInfo.titleDataFormat != TitleDataFormat::WUHB &&
 		cachedInfo.titleDataFormat != TitleDataFormat::WUD &&
+		cachedInfo.titleDataFormat != TitleDataFormat::NUS &&
 		cachedInfo.titleDataFormat != TitleDataFormat::INVALID_STRUCTURE)
 		return;
 	if (cachedInfo.path.empty())
@@ -127,7 +131,8 @@ TitleInfo::CachedInfo TitleInfo::MakeCacheEntry()
 	e.subPath = m_subPath;
 	e.titleId = GetAppTitleId();
 	e.titleVersion = GetAppTitleVersion();
-	e.titleName = GetTitleName();
+	e.sdkVersion = GetAppSDKVersion();
+	e.titleName = GetMetaTitleName();
 	e.region = GetMetaRegion();
 	e.group_id = GetAppGroup();
 	e.app_type = GetAppType();
@@ -196,13 +201,19 @@ bool TitleInfo::DetectFormat(const fs::path& path, fs::path& pathOut, TitleDataF
 			}
 		}
 		else if (boost::iends_with(filenameStr, ".wud") ||
-			boost::iends_with(filenameStr, ".wux") ||
-			boost::iends_with(filenameStr, ".iso"))
+				 boost::iends_with(filenameStr, ".wux") ||
+				 boost::iends_with(filenameStr, ".iso"))
 		{
 			formatOut = TitleDataFormat::WUD;
 			pathOut = path;
 			return true;
 		}
+		else if (boost::iequals(filenameStr, "title.tmd"))
+		{
+			formatOut = TitleDataFormat::NUS;
+			pathOut = path;
+			return true;
+		}
 		else if (boost::iends_with(filenameStr, ".wua"))
 		{
 			formatOut = TitleDataFormat::WIIU_ARCHIVE;
@@ -238,6 +249,16 @@ bool TitleInfo::DetectFormat(const fs::path& path, fs::path& pathOut, TitleDataF
 			delete zar;
 			return foundBase;
 		}
+		else if (boost::iends_with(filenameStr, ".wuhb"))
+		{
+			std::unique_ptr<WUHBReader> reader{WUHBReader::FromPath(path)};
+			if(reader)
+			{
+				formatOut = TitleDataFormat::WUHB;
+				pathOut = path;
+				return true;
+			}
+		}
 		// note: Since a Wii U archive file (.wua) contains multiple titles we shouldn't auto-detect them here
 		// instead TitleInfo has a second constructor which takes a subpath
 		// unable to determine type by extension, check contents
@@ -261,6 +282,7 @@ bool TitleInfo::DetectFormat(const fs::path& path, fs::path& pathOut, TitleDataF
 			return true;
 		}
 	}
+	SetInvalidReason(InvalidReason::UNKNOWN_FORMAT);
 	return false;
 }
 
@@ -287,12 +309,11 @@ void TitleInfo::CalcUID()
 		m_uid = 0;
 		return;
 	}
-	std::error_code ec;
 	// get absolute normalized path
 	fs::path normalizedPath;
 	if (m_fullPath.is_relative())
 	{
-		normalizedPath = ActiveSettings::GetPath();
+		normalizedPath = ActiveSettings::GetUserDataPath();
 		normalizedPath /= m_fullPath;
 	}
 	else
@@ -314,6 +335,12 @@ uint64 TitleInfo::GetUID()
 	return m_uid;
 }
 
+void TitleInfo::SetInvalidReason(InvalidReason reason)
+{
+	if(m_invalidReason == InvalidReason::NONE)
+		m_invalidReason = reason; // only update reason when it hasn't been set before
+}
+
 std::mutex sZArchivePoolMtx;
 std::map<fs::path, std::pair<uint32, ZArchiveReader*>> sZArchivePool;
 
@@ -375,18 +402,29 @@ bool TitleInfo::Mount(std::string_view virtualPath, std::string_view subfolder,
 		if (!r)
 		{
 			cemuLog_log(LogType::Force, "Failed to mount {} to {}", virtualPath, subfolder);
+			SetInvalidReason(InvalidReason::BAD_PATH_OR_INACCESSIBLE);
 			return false;
 		}
 	}
-	else if (m_titleFormat == TitleDataFormat::WUD)
+	else if (m_titleFormat == TitleDataFormat::WUD || m_titleFormat == TitleDataFormat::NUS)
 	{
+		FSTVolume::ErrorCode fstError;
 		if (m_mountpoints.empty())
 		{
 			cemu_assert_debug(!m_wudVolume);
-			m_wudVolume = FSTVolume::OpenFromDiscImage(m_fullPath);
+			if(m_titleFormat == TitleDataFormat::WUD)
+				m_wudVolume = FSTVolume::OpenFromDiscImage(m_fullPath, &fstError); // open wud/wux
+			else
+				m_wudVolume = FSTVolume::OpenFromContentFolder(m_fullPath.parent_path(), &fstError); // open from .app files directory, the path points to /title.tmd
 		}
 		if (!m_wudVolume)
+		{
+			if (fstError == FSTVolume::ErrorCode::DISC_KEY_MISSING)
+				SetInvalidReason(InvalidReason::NO_DISC_KEY);
+			else if (fstError == FSTVolume::ErrorCode::TITLE_TIK_MISSING)
+				SetInvalidReason(InvalidReason::NO_TITLE_TIK);
 			return false;
+		}
 		bool r = FSCDeviceWUD_Mount(virtualPath, subfolder, m_wudVolume, mountPriority);
 		cemu_assert_debug(r);
 		if (!r)
@@ -412,6 +450,23 @@ bool TitleInfo::Mount(std::string_view virtualPath, std::string_view subfolder,
 			return false;
 		}
 	}
+	else if (m_titleFormat == TitleDataFormat::WUHB)
+	{
+		if (!m_wuhbreader)
+		{
+			m_wuhbreader = WUHBReader::FromPath(m_fullPath);
+			if (!m_wuhbreader)
+				return false;
+		}
+		bool r = FSCDeviceWUHB_Mount(virtualPath, subfolder, m_wuhbreader, mountPriority);
+		if (!r)
+		{
+			cemuLog_log(LogType::Force, "Failed to mount {} to {}", virtualPath, subfolder);
+			delete m_wuhbreader;
+			m_wuhbreader = nullptr;
+			return false;
+		}
+	}
 	else
 	{
 		cemu_assert_unimplemented();
@@ -428,22 +483,27 @@ void TitleInfo::Unmount(std::string_view virtualPath)
 			continue;
 		fsc_unmount(itr.second.c_str(), itr.first);
 		std::erase(m_mountpoints, itr);
-		// if the last mount point got unmounted, delete any open devices
+		// if the last mount point got unmounted, close any open devices
 		if (m_mountpoints.empty())
 		{
 			if (m_wudVolume)
 			{
-				cemu_assert_debug(m_titleFormat == TitleDataFormat::WUD);
+				cemu_assert_debug(m_titleFormat == TitleDataFormat::WUD || m_titleFormat == TitleDataFormat::NUS);
 				delete m_wudVolume;
 				m_wudVolume = nullptr;
 			}
-		}
-		// wua files use reference counting
-		if (m_zarchive)
-		{
-			_ZArchivePool_ReleaseInstance(m_fullPath, m_zarchive);
-			if (m_mountpoints.empty())
-				m_zarchive = nullptr;
+            if (m_zarchive)
+            {
+                _ZArchivePool_ReleaseInstance(m_fullPath, m_zarchive);
+                if (m_mountpoints.empty())
+                    m_zarchive = nullptr;
+            }
+			if (m_wuhbreader)
+			{
+				cemu_assert_debug(m_titleFormat == TitleDataFormat::WUHB);
+				delete m_wuhbreader;
+				m_wuhbreader = nullptr;
+			}
 		}
 		return;
 	}
@@ -468,7 +528,7 @@ bool TitleInfo::ParseXmlInfo()
 {
 	cemu_assert(m_isValid);
 	if (m_hasParsedXmlFiles)
-		return m_parsedMetaXml && m_parsedAppXml && m_parsedCosXml;
+		return m_isValid;
 	m_hasParsedXmlFiles = true;
 
 	std::string mountPath = GetUniqueTempMountingPath();
@@ -479,6 +539,20 @@ bool TitleInfo::ParseXmlInfo()
 	auto xmlData = fsc_extractFile(fmt::format("{}meta/meta.xml", mountPath).c_str());
 	if(xmlData)
 		m_parsedMetaXml = ParsedMetaXml::Parse(xmlData->data(), xmlData->size());
+
+	if(!m_parsedMetaXml)
+	{
+		// meta/meta.ini (WUHB)
+		auto iniData = fsc_extractFile(fmt::format("{}meta/meta.ini", mountPath).c_str());
+		if (iniData)
+			m_parsedMetaXml = ParseAromaIni(*iniData);
+		if(m_parsedMetaXml)
+		{
+			m_parsedCosXml = new ParsedCosXml{.argstr = "root.rpx"};
+			m_parsedAppXml = new ParsedAppXml{m_parsedMetaXml->m_title_id, 0, 0, 0, 0};
+		}
+	}
+
 	// code/app.xml
 	xmlData = fsc_extractFile(fmt::format("{}code/app.xml", mountPath).c_str());
 	if(xmlData)
@@ -490,10 +564,16 @@ bool TitleInfo::ParseXmlInfo()
 
 	Unmount(mountPath);
 
-	bool hasAnyXml = m_parsedMetaXml || m_parsedAppXml || m_parsedCosXml;
-
-	if (!m_parsedMetaXml || !m_parsedAppXml || !m_parsedCosXml)
+	// some system titles dont have a meta.xml file
+	bool allowMissingMetaXml = false;
+	if(m_parsedAppXml && this->IsSystemDataTitle())
 	{
+		allowMissingMetaXml = true;
+	}
+
+	if ((allowMissingMetaXml == false && !m_parsedMetaXml) || !m_parsedAppXml || !m_parsedCosXml)
+	{
+		bool hasAnyXml = m_parsedMetaXml || m_parsedAppXml || m_parsedCosXml;
 		if (hasAnyXml)
 			cemuLog_log(LogType::Force, "Title has missing meta .xml files. Title path: {}", _pathToUtf8(m_fullPath));
 		delete m_parsedMetaXml;
@@ -503,12 +583,41 @@ bool TitleInfo::ParseXmlInfo()
 		m_parsedAppXml = nullptr;
 		m_parsedCosXml = nullptr;
 		m_isValid = false;
+		SetInvalidReason(InvalidReason::MISSING_XML_FILES);
 		return false;
 	}
 	m_isValid = true;
 	return true;
 }
 
+ParsedMetaXml* TitleInfo::ParseAromaIni(std::span<unsigned char> content)
+{
+	IniParser parser{content};
+	while (parser.NextSection() && parser.GetCurrentSectionName() != "menu")
+		continue;
+	if (parser.GetCurrentSectionName() != "menu")
+		return nullptr;
+
+	auto parsed = std::make_unique<ParsedMetaXml>();
+
+	const auto author = parser.FindOption("author");
+	if (author)
+		parsed->m_publisher[(size_t)CafeConsoleLanguage::EN] = *author;
+
+	const auto longName = parser.FindOption("longname");
+	if (longName)
+		parsed->m_long_name[(size_t)CafeConsoleLanguage::EN] = *longName;
+
+	const auto shortName = parser.FindOption("shortname");
+	if (shortName)
+		parsed->m_short_name[(size_t)CafeConsoleLanguage::EN] = *shortName;
+
+	auto checksumInput = std::string{*author}.append(*longName).append(*shortName);
+	parsed->m_title_id = (0x0005000Full<<32) | crc32_calc(checksumInput.data(), checksumInput.length());
+
+	return parsed.release();
+}
+
 bool TitleInfo::ParseAppXml(std::vector<uint8>& appXmlData)
 {
 	pugi::xml_document app_doc;
@@ -532,6 +641,8 @@ bool TitleInfo::ParseAppXml(std::vector<uint8>& appXmlData)
 			m_parsedAppXml->app_type = (uint32)std::stoull(child.text().as_string(), nullptr, 16);
 		else if (name == "group_id")
 			m_parsedAppXml->group_id = (uint32)std::stoull(child.text().as_string(), nullptr, 16);
+		else if (name == "sdk_version")
+			m_parsedAppXml->sdk_version = (uint32)std::stoull(child.text().as_string(), nullptr, 10);
 	}
 	return true;
 }
@@ -558,6 +669,17 @@ uint16 TitleInfo::GetAppTitleVersion() const
 	return 0;
 }
 
+uint32 TitleInfo::GetAppSDKVersion() const
+{
+	cemu_assert_debug(m_isValid);
+	if (m_parsedAppXml)
+		return m_parsedAppXml->sdk_version;
+	if (m_cachedInfo)
+		return m_cachedInfo->sdkVersion;
+	cemu_assert_suspicious();
+	return 0;
+}
+
 uint32 TitleInfo::GetAppGroup() const
 {
 	cemu_assert_debug(m_isValid);
@@ -586,14 +708,21 @@ TitleIdParser::TITLE_TYPE TitleInfo::GetTitleType()
 	return tip.GetType();
 }
 
-std::string TitleInfo::GetTitleName() const
+std::string TitleInfo::GetMetaTitleName() const
 {
 	cemu_assert_debug(m_isValid);
 	if (m_parsedMetaXml)
-		return m_parsedMetaXml->GetShortName(CafeConsoleLanguage::EN);
+	{
+		std::string titleNameCfgLanguage;
+		titleNameCfgLanguage = m_parsedMetaXml->GetLongName(GetConfig().console_language);
+		if (titleNameCfgLanguage.empty()) //Get English Title
+			titleNameCfgLanguage = m_parsedMetaXml->GetLongName(CafeConsoleLanguage::EN);
+		if (titleNameCfgLanguage.empty()) //Unknown Title
+			titleNameCfgLanguage = "Unknown Title";
+		return titleNameCfgLanguage;
+	}
 	if (m_cachedInfo)
 		return m_cachedInfo->titleName;
-	cemu_assert_suspicious();
 	return "";
 }
 
@@ -604,10 +733,19 @@ CafeConsoleRegion TitleInfo::GetMetaRegion() const
 		return m_parsedMetaXml->GetRegion();
 	if (m_cachedInfo)
 		return m_cachedInfo->region;
-	cemu_assert_suspicious();
 	return CafeConsoleRegion::JPN;
 }
 
+uint32 TitleInfo::GetOlvAccesskey() const
+{
+	cemu_assert_debug(m_isValid);
+	if (m_parsedMetaXml)
+		return m_parsedMetaXml->GetOlvAccesskey();
+
+	cemu_assert_suspicious();
+	return -1;
+}
+
 std::string TitleInfo::GetArgStr() const
 {
 	cemu_assert_debug(m_parsedCosXml);
@@ -630,9 +768,15 @@ std::string TitleInfo::GetPrintPath() const
 	case TitleDataFormat::WUD:
 		tmp.append(" [WUD]");
 		break;
+	case TitleDataFormat::NUS:
+		tmp.append(" [NUS]");
+		break;
 	case TitleDataFormat::WIIU_ARCHIVE:
 		tmp.append(" [WUA]");
 		break;
+	case TitleDataFormat::WUHB:
+		tmp.append(" [WUHB]");
+		break;
 	default:
 		break;
 	}
@@ -645,10 +789,41 @@ std::string TitleInfo::GetInstallPath() const
 {
 	TitleId titleId = GetAppTitleId();
 	TitleIdParser tip(titleId);
-        std::string tmp;
+	std::string tmp;
 	if (tip.IsSystemTitle())
-               tmp = fmt::format("sys/title/{:08x}/{:08x}", GetTitleIdHigh(titleId), GetTitleIdLow(titleId));
-        else
-               tmp = fmt::format("usr/title/{:08x}/{:08x}", GetTitleIdHigh(titleId), GetTitleIdLow(titleId));
+		tmp = fmt::format("sys/title/{:08x}/{:08x}", GetTitleIdHigh(titleId), GetTitleIdLow(titleId));
+    else
+		tmp = fmt::format("usr/title/{:08x}/{:08x}", GetTitleIdHigh(titleId), GetTitleIdLow(titleId));
 	return tmp;
 }
+
+ParsedCosXml* ParsedCosXml::Parse(uint8* xmlData, size_t xmlLen)
+{
+	pugi::xml_document app_doc;
+	if (!app_doc.load_buffer_inplace(xmlData, xmlLen))
+		return nullptr;
+
+	const auto root = app_doc.child("app");
+	if (!root)
+		return nullptr;
+
+	ParsedCosXml* parsedCos = new ParsedCosXml();
+
+	auto node = root.child("argstr");
+	if (node)
+		parsedCos->argstr = node.text().as_string();
+
+	// parse permissions
+	auto permissionsNode = root.child("permissions");
+	for(uint32 permissionIndex = 0; permissionIndex < 19; ++permissionIndex)
+	{
+		std::string permissionName = fmt::format("p{}", permissionIndex);
+		auto permissionNode = permissionsNode.child(permissionName.c_str());
+		if (!permissionNode)
+			break;
+		parsedCos->permissions[permissionIndex].group = static_cast<CosCapabilityGroup>(ConvertString<uint32>(permissionNode.child("group").text().as_string(), 10));
+		parsedCos->permissions[permissionIndex].mask = static_cast<CosCapabilityBits>(ConvertString<uint64>(permissionNode.child("mask").text().as_string(), 16));
+	}
+
+	return parsedCos;
+}
\ No newline at end of file
diff --git a/src/Cafe/TitleList/TitleInfo.h b/src/Cafe/TitleList/TitleInfo.h
index 86f89391..fa5b9c89 100644
--- a/src/Cafe/TitleList/TitleInfo.h
+++ b/src/Cafe/TitleList/TitleInfo.h
@@ -3,6 +3,7 @@
 #include "Cafe/Filesystem/fsc.h"
 #include "config/CemuConfig.h" // for CafeConsoleRegion. Move to NCrypto?
 #include "TitleId.h"
+#include "AppType.h"
 #include "ParsedMetaXml.h"
 
 enum class CafeTitleFileType
@@ -22,31 +23,98 @@ struct ParsedAppXml
 	uint16 title_version;
 	uint32 app_type;
 	uint32 group_id;
+	uint32 sdk_version;
 };
 
+enum class CosCapabilityGroup : uint32
+{
+	None = 0,
+	BSP  =  1,
+	DK   =  3,
+	USB  =  9,
+	UHS  = 12,
+	FS   = 11,
+	MCP  = 13,
+	NIM  = 14,
+	ACT  = 15,
+	FPD  = 16,
+	BOSS = 17,
+	ACP  = 18,
+	PDM  = 19,
+	AC   = 20,
+	NDM  = 21,
+	NSEC = 22
+};
+
+enum class CosCapabilityBits : uint64
+{
+	All = 0xFFFFFFFFFFFFFFFFull
+};
+
+enum class CosCapabilityBitsFS : uint64
+{
+	ODD_READ         = (1llu << 0),
+	ODD_WRITE        = (1llu << 1),
+	ODD_RAW_OPEN     = (1llu << 2),
+	ODD_MOUNT        = (1llu << 3),
+	SLCCMPT_READ     = (1llu << 4),
+	SLCCMPT_WRITE    = (1llu << 5),
+	SLCCMPT_RAW_OPEN = (1llu << 6),
+	SLCCMPT_MOUNT    = (1llu << 7),
+	SLC_READ         = (1llu << 8),
+	SLC_WRITE        = (1llu << 9),
+	SLC_RAW_OPEN     = (1llu << 10),
+	SLC_MOUNT        = (1llu << 11),
+	MLC_READ         = (1llu << 12),
+	MLC_WRITE        = (1llu << 13),
+	MLC_RAW_OPEN     = (1llu << 14),
+	MLC_MOUNT        = (1llu << 15),
+	SDCARD_READ      = (1llu << 16),
+	SDCARD_WRITE     = (1llu << 17),
+	SDCARD_RAW_OPEN  = (1llu << 18),
+	SDCARD_MOUNT     = (1llu << 19),
+	HFIO_READ        = (1llu << 20),
+	HFIO_WRITE       = (1llu << 21),
+	HFIO_RAW_OPEN    = (1llu << 22),
+	HFIO_MOUNT       = (1llu << 23),
+	RAMDISK_READ     = (1llu << 24),
+	RAMDISK_WRITE    = (1llu << 25),
+	RAMDISK_RAW_OPEN = (1llu << 26),
+	RAMDISK_MOUNT    = (1llu << 27),
+	USB_READ         = (1llu << 28),
+	USB_WRITE        = (1llu << 29),
+	USB_RAW_OPEN     = (1llu << 30),
+	USB_MOUNT        = (1llu << 31),
+	OTHER_READ       = (1llu << 32),
+	OTHER_WRITE      = (1llu << 33),
+	OTHER_RAW_OPEN   = (1llu << 34),
+	OTHER_MOUNT      = (1llu << 35)
+};
+ENABLE_BITMASK_OPERATORS(CosCapabilityBitsFS);
+
 struct ParsedCosXml 
 {
+  public:
+
 	std::string argstr;
 
-	static ParsedCosXml* Parse(uint8* xmlData, size_t xmlLen)
+	struct Permission
 	{
-		pugi::xml_document app_doc;
-		if (!app_doc.load_buffer_inplace(xmlData, xmlLen))
-			return nullptr;
+		CosCapabilityGroup group{CosCapabilityGroup::None};
+		CosCapabilityBits mask{CosCapabilityBits::All};
+	};
+	Permission permissions[19]{};
 
-		const auto root = app_doc.child("app");
-		if (!root)
-			return nullptr;
+	static ParsedCosXml* Parse(uint8* xmlData, size_t xmlLen);
 
-		ParsedCosXml* parsedCos = new ParsedCosXml();
-
-		for (const auto& child : root.children())
+	CosCapabilityBits GetCapabilityBits(CosCapabilityGroup group) const
+	{
+		for (const auto& perm : permissions)
 		{
-			std::string_view name = child.name();
-			if (name == "argstr")
-				parsedCos->argstr = child.text().as_string();
+			if (perm.group == group)
+				return perm.mask;
 		}
-		return parsedCos;
+		return CosCapabilityBits::All;
 	}
 };
 
@@ -58,10 +126,22 @@ public:
 		HOST_FS = 1, // host filesystem directory (fullPath points to root with content/code/meta subfolders)
 		WUD = 2, // WUD or WUX
 		WIIU_ARCHIVE = 3, // Wii U compressed single-file archive (.wua)
+	  	NUS = 4, // NUS format. Directory with .app files, title.tik and title.tmd
+	  	WUHB = 5,
 		// error
 		INVALID_STRUCTURE = 0,
 	};
 
+	enum class InvalidReason : uint8
+	{
+		NONE = 0,
+		BAD_PATH_OR_INACCESSIBLE = 1,
+		UNKNOWN_FORMAT = 2,
+		NO_DISC_KEY = 3,
+		NO_TITLE_TIK = 4,
+		MISSING_XML_FILES = 4,
+	};
+
 	struct CachedInfo
 	{
 		TitleDataFormat titleDataFormat;
@@ -69,6 +149,7 @@ public:
 		std::string subPath; // for WUA
 		uint64 titleId;
 		uint16 titleVersion;
+		uint32 sdkVersion;
 		std::string titleName;
 		CafeConsoleRegion region;
 		uint32 group_id;
@@ -97,6 +178,7 @@ public:
 	CachedInfo MakeCacheEntry();
 
 	bool IsValid() const;
+	InvalidReason GetInvalidReason() const { return m_invalidReason; }
 	uint64 GetUID(); // returns a unique identifier derived from the absolute canonical title location which can be used to identify this title by its location. May not persist across sessions, especially when Cemu is used portable
 
 	fs::path GetPath() const;
@@ -115,18 +197,28 @@ public:
 		return m_uid == rhs.m_uid;
 	}
 
+	bool IsSystemDataTitle() const
+	{
+		if(!IsValid())
+			return false;
+		uint32 appType = GetAppType();
+		return appType == APP_TYPE::DRC_FIRMWARE || appType == APP_TYPE::DRC_TEXTURE_ATLAS || appType == APP_TYPE::VERSION_DATA_TITLE;
+	}
+
 	// API which requires parsed meta data or cached info
 	TitleId GetAppTitleId() const; // from app.xml
 	uint16 GetAppTitleVersion() const; // from app.xml
+	uint32 GetAppSDKVersion() const; // from app.xml
 	uint32 GetAppGroup() const; // from app.xml
 	uint32 GetAppType() const; // from app.xml
-	std::string GetTitleName() const; // from meta.xml
+	std::string GetMetaTitleName() const; // from meta.xml
 	CafeConsoleRegion GetMetaRegion() const; // from meta.xml
+	uint32 GetOlvAccesskey() const;
 
 	// cos.xml
 	std::string GetArgStr() const;
 
-	// meta.xml also contains a version which seems to match the one from app.xml
+	// meta.xml also contains a version field which seems to match the one from app.xml
 	// the titleId in meta.xml seems to be the title id of the base game for updates specifically. For AOC content it's the AOC's titleId
 
 	TitleIdParser::TITLE_TYPE GetTitleType();
@@ -135,7 +227,12 @@ public:
 		return m_parsedMetaXml;
 	}
 
-	std::string GetPrintPath() const; // formatted path for log writing
+	ParsedCosXml* GetCosInfo()
+	{
+		return m_parsedCosXml;
+	}
+
+	std::string GetPrintPath() const; // formatted path including type and WUA subpath. Intended for logging and user-facing information
 	std::string GetInstallPath() const; // installation subpath, relative to storage base. E.g. "usr/title/.../..." or "sys/title/.../..."
 
 	static std::string GetUniqueTempMountingPath();
@@ -168,7 +265,8 @@ private:
 
 	bool DetectFormat(const fs::path& path, fs::path& pathOut, TitleDataFormat& formatOut);
 	void CalcUID();
-
+	void SetInvalidReason(InvalidReason reason);
+	ParsedMetaXml* ParseAromaIni(std::span<unsigned char> content);
 	bool ParseAppXml(std::vector<uint8>& appXmlData);
 
 	bool m_isValid{ false };
@@ -176,10 +274,12 @@ private:
 	fs::path m_fullPath;
 	std::string m_subPath; // used for formats where fullPath isn't unique on its own (like WUA)
 	uint64 m_uid{};
+	InvalidReason m_invalidReason{ InvalidReason::NONE }; // if m_isValid == false, this contains a more detailed error code
 	// mounting info
 	std::vector<std::pair<sint32, std::string>> m_mountpoints;
 	class FSTVolume* m_wudVolume{};
 	class ZArchiveReader* m_zarchive{};
+	class WUHBReader* m_wuhbreader{};
 	// xml info
 	bool m_hasParsedXmlFiles{ false };
 	ParsedMetaXml* m_parsedMetaXml{};
diff --git a/src/Cafe/TitleList/TitleList.cpp b/src/Cafe/TitleList/TitleList.cpp
index f7c1b6f8..7b75fac7 100644
--- a/src/Cafe/TitleList/TitleList.cpp
+++ b/src/Cafe/TitleList/TitleList.cpp
@@ -9,7 +9,7 @@ bool sTLInitialized{ false };
 fs::path sTLCacheFilePath;
 
 // lists for tracking known titles
-// note: The list may only contain titles with valid meta data. Entries loaded from the cache may not have been parsed yet, but they will use a cached value for titleId and titleVersion
+// note: The list may only contain titles with valid meta data (except for certain system titles). Entries loaded from the cache may not have been parsed yet, but they will use a cached value for titleId and titleVersion
 std::mutex sTLMutex;
 std::vector<TitleInfo*> sTLList;
 std::vector<TitleInfo*> sTLListPending;
@@ -65,6 +65,7 @@ void CafeTitleList::LoadCacheFile()
 		if( !TitleIdParser::ParseFromStr(titleInfoNode.attribute("titleId").as_string(), titleId))
 			continue;
 		uint16 titleVersion = titleInfoNode.attribute("version").as_uint();
+		uint32 sdkVersion = titleInfoNode.attribute("sdk_version").as_uint();
 		TitleInfo::TitleDataFormat format = (TitleInfo::TitleDataFormat)ConvertString<uint32>(titleInfoNode.child_value("format"));
 		CafeConsoleRegion region = (CafeConsoleRegion)ConvertString<uint32>(titleInfoNode.child_value("region"));
 		std::string name = titleInfoNode.child_value("name");
@@ -76,11 +77,12 @@ void CafeTitleList::LoadCacheFile()
 		TitleInfo::CachedInfo cacheEntry;
 		cacheEntry.titleId = titleId;
 		cacheEntry.titleVersion = titleVersion;
+		cacheEntry.sdkVersion = sdkVersion;
 		cacheEntry.titleDataFormat = format;
 		cacheEntry.region = region;
-		cacheEntry.titleName = name;
+		cacheEntry.titleName = std::move(name);
 		cacheEntry.path = _utf8ToPath(path);
-		cacheEntry.subPath = sub_path;
+		cacheEntry.subPath = std::move(sub_path);
 		cacheEntry.group_id = group_id;
 		cacheEntry.app_type = app_type;
 
@@ -115,6 +117,7 @@ void CafeTitleList::StoreCacheFile()
 		auto titleInfoNode = title_list_node.append_child("title");
 		titleInfoNode.append_attribute("titleId").set_value(fmt::format("{:016x}", info.titleId).c_str());
 		titleInfoNode.append_attribute("version").set_value(fmt::format("{:}", info.titleVersion).c_str());
+		titleInfoNode.append_attribute("sdk_version").set_value(fmt::format("{:}", info.sdkVersion).c_str());
 		titleInfoNode.append_attribute("group_id").set_value(fmt::format("{:08x}", info.group_id).c_str());
 		titleInfoNode.append_attribute("app_type").set_value(fmt::format("{:08x}", info.app_type).c_str());
 		titleInfoNode.append_child("region").append_child(pugi::node_pcdata).set_value(fmt::format("{}", (uint32)info.region).c_str());
@@ -255,6 +258,7 @@ void CafeTitleList::AddTitleFromPath(fs::path path)
 
 bool CafeTitleList::RefreshWorkerThread()
 {
+	SetThreadName("TitleListWorker");
 	while (sTLRefreshRequests.load())
 	{
 		sTLRefreshRequests.store(0);
@@ -321,17 +325,26 @@ bool CafeTitleList::RefreshWorkerThread()
 	return true;
 }
 
-bool _IsKnownFileExtension(std::string fileExtension)
+bool _IsKnownFileNameOrExtension(const fs::path& path)
 {
+	std::string fileExtension = _pathToUtf8(path.extension());
 	for (auto& it : fileExtension)
-		if (it >= 'A' && it <= 'Z')
-			it -= ('A' - 'a');
+		it = _ansiToLower(it);
+	if(fileExtension == ".tmd")
+	{
+		// must be "title.tmd"
+		std::string fileName = _pathToUtf8(path.filename());
+		for (auto& it : fileName)
+			it = _ansiToLower(it);
+		return fileName == "title.tmd";
+	}
 	return
 		fileExtension == ".wud" ||
 		fileExtension == ".wux" ||
 		fileExtension == ".iso" ||
-		fileExtension == ".wua";
-	// note: To detect extracted titles with RPX we use the content/code/meta folder structure
+		fileExtension == ".wua" ||
+		fileExtension == ".wuhb";
+	// note: To detect extracted titles with RPX we rely on the presence of the content,code,meta directory structure
 }
 
 void CafeTitleList::ScanGamePath(const fs::path& path)
@@ -350,7 +363,6 @@ void CafeTitleList::ScanGamePath(const fs::path& path)
 		else if (it.is_directory(ec))
 		{
 			dirsInDirectory.emplace_back(it.path());
-
 			std::string dirName = _pathToUtf8(it.path().filename());
 			if (boost::iequals(dirName, "content"))
 				hasContentFolder = true;
@@ -363,10 +375,10 @@ void CafeTitleList::ScanGamePath(const fs::path& path)
 	// always check individual files
 	for (auto& it : filesInDirectory)
 	{
-		// since checking files is slow, we only do it for known file extensions
+		// since checking individual files is slow, we limit it to known file names or extensions
 		if (!it.has_extension())
 			continue;
-		if (!_IsKnownFileExtension(_pathToUtf8(it.extension())))
+		if (!_IsKnownFileNameOrExtension(it))
 			continue;
 		AddTitleFromPath(it);
 	}
@@ -482,7 +494,7 @@ void CafeTitleList::AddTitle(TitleInfo* titleInfo)
 		}
 	}
 	sTLList.emplace_back(titleInfo);
-	sTLMap.insert(std::pair(titleInfo->GetAppTitleId(), titleInfo));
+	sTLMap.emplace(titleInfo->GetAppTitleId(), titleInfo);
 	// send out notification
 	CafeTitleListCallbackEvent evt;
 	evt.eventType = CafeTitleListCallbackEvent::TYPE::TITLE_DISCOVERED;
@@ -623,8 +635,7 @@ GameInfo2 CafeTitleList::GetGameInfo(TitleId titleId)
 	uint64 baseTitleId;
 	if (!FindBaseTitleId(titleId, baseTitleId))
 	{
-		cemuLog_logDebug(LogType::Force, "Failed to translate title id in GetGameInfo()");
-		return gameInfo;
+		cemu_assert_suspicious();
 	}
 	// determine if an optional update title id exists
 	TitleIdParser tip(baseTitleId);
@@ -638,12 +649,15 @@ GameInfo2 CafeTitleList::GetGameInfo(TitleId titleId)
 	{
 		TitleId appTitleId = it->GetAppTitleId();
 		if (appTitleId == baseTitleId)
+		{
 			gameInfo.SetBase(*it);
+		}
 		if (hasSeparateUpdateTitleId && appTitleId == updateTitleId)
 		{
 			gameInfo.SetUpdate(*it);
 		}
 	}
+
 	// if this title can have AOC content then do a second scan
 	// todo - get a list of all AOC title ids from the base/update meta information
 	// for now we assume there is a direct match between the base titleId and the aoc titleId
diff --git a/src/Cemu/CMakeLists.txt b/src/Cemu/CMakeLists.txt
index df0ff1d1..1fce8ec1 100644
--- a/src/Cemu/CMakeLists.txt
+++ b/src/Cemu/CMakeLists.txt
@@ -1,8 +1,36 @@
-project(CemuComponents)
-
-file(GLOB_RECURSE CPP_FILES *.cpp)
-file(GLOB_RECURSE H_FILES *.h)
-add_library(CemuComponents ${CPP_FILES} ${H_FILES})
+add_library(CemuComponents
+  DiscordPresence/DiscordPresence.cpp
+  DiscordPresence/DiscordPresence.h
+  ExpressionParser/ExpressionParser.cpp
+  ExpressionParser/ExpressionParser.h
+  FileCache/FileCache.cpp
+  FileCache/FileCache.h
+  Logging/CemuDebugLogging.h
+  Logging/CemuLogging.cpp
+  Logging/CemuLogging.h
+  napi/napi_act.cpp
+  napi/napi_ec.cpp
+  napi/napi.h
+  napi/napi_helper.cpp
+  napi/napi_helper.h
+  napi/napi_idbe.cpp
+  napi/napi_version.cpp
+  ncrypto/ncrypto.cpp
+  ncrypto/ncrypto.h
+  nex/nex.cpp
+  nex/nexFriends.cpp
+  nex/nexFriends.h
+  nex/nex.h
+  nex/nexThread.cpp
+  nex/nexThread.h
+  nex/nexTypes.h
+  nex/prudp.cpp
+  nex/prudp.h
+  PPCAssembler/ppcAssembler.cpp
+  PPCAssembler/ppcAssembler.h
+  Tools/DownloadManager/DownloadManager.cpp
+  Tools/DownloadManager/DownloadManager.h
+)
 
 set_property(TARGET CemuComponents PROPERTY MSVC_RUNTIME_LIBRARY "MultiThreaded$<$<CONFIG:Debug>:Debug>")
 
diff --git a/src/Cemu/FileCache/FileCache.cpp b/src/Cemu/FileCache/FileCache.cpp
index 0165f0c4..b284b66b 100644
--- a/src/Cemu/FileCache/FileCache.cpp
+++ b/src/Cemu/FileCache/FileCache.cpp
@@ -50,7 +50,7 @@ struct _FileCacheAsyncWriter
 private:
 	void FileCacheThread()
 	{
-		SetThreadName("fileCache_thread");
+		SetThreadName("fileCache");
 		while (true)
 		{
 			std::unique_lock lock(m_fileCacheMutex);
@@ -87,12 +87,12 @@ private:
 #define FILECACHE_FILETABLE_NAME2			0xFEFEFEFEFEFEFEFEULL
 #define FILECACHE_FILETABLE_FREE_NAME		0ULL
 
-FileCache* FileCache::Create(wzstring_view path, uint32 extraVersion)
+FileCache* FileCache::Create(const fs::path& path, uint32 extraVersion)
 {
-	FileStream* fs = FileStream::createFile(std::wstring(path).c_str());
+	FileStream* fs = FileStream::createFile2(path);
 	if (!fs)
 	{
-		forceLog_printf("Failed to create cache file \"%ls\"", path);
+		cemuLog_log(LogType::Force, "Failed to create cache file \"{}\"", _pathToUtf8(path));
 		return nullptr;
 	}
 	// init file cache
@@ -124,9 +124,9 @@ FileCache* FileCache::Create(wzstring_view path, uint32 extraVersion)
 	return fileCache;
 }
 
-FileCache* FileCache::_OpenExisting(wzstring_view path, bool compareExtraVersion, uint32 extraVersion)
+FileCache* FileCache::_OpenExisting(const fs::path& path, bool compareExtraVersion, uint32 extraVersion)
 {
-	FileStream* fs = FileStream::openFile2(path.data(), true);
+	FileStream* fs = FileStream::openFile2(path, true);
 	if (!fs)
 		return nullptr;
 	// read header
@@ -165,7 +165,7 @@ FileCache* FileCache::_OpenExisting(wzstring_view path, bool compareExtraVersion
 	fs->readU64(headerFileTableOffset);
 	if (!fs->readU32(headerFileTableSize))
 	{
-		forceLog_printf("\"%ls\" is corrupted", path);
+		cemuLog_log(LogType::Force, "\"{}\" is corrupted", _pathToUtf8(path));
 		delete fs;
 		return nullptr;
 	}
@@ -176,7 +176,7 @@ FileCache* FileCache::_OpenExisting(wzstring_view path, bool compareExtraVersion
 	invalidFileTableSize = (headerFileTableSize % sizeof(FileTableEntry)) != 0;
 	if (invalidFileTableSize)
 	{
-		forceLog_printf("\"%ls\" is corrupted", path);
+		cemuLog_log(LogType::Force, "\"{}\" is corrupted", _pathToUtf8(path));
 		delete fs;
 		return nullptr;
 	}
@@ -212,14 +212,14 @@ FileCache* FileCache::_OpenExisting(wzstring_view path, bool compareExtraVersion
 	}
 	if (incompleteFileTable)
 	{
-		forceLog_printf("\"%ls\" is corrupted (incomplete file table)", path);
+		cemuLog_log(LogType::Force, "\"{}\" is corrupted (incomplete file table)", _pathToUtf8(path));
 		delete fileCache;
 		return nullptr;
 	}
 	return fileCache;
 }
 
-FileCache* FileCache::Open(wzstring_view path, bool allowCreate, uint32 extraVersion)
+FileCache* FileCache::Open(const fs::path& path, bool allowCreate, uint32 extraVersion)
 {
 	FileCache* fileCache = _OpenExisting(path, true, extraVersion);
 	if (fileCache)
@@ -229,7 +229,7 @@ FileCache* FileCache::Open(wzstring_view path, bool allowCreate, uint32 extraVer
 	return Create(path, extraVersion);
 }
 
-FileCache* FileCache::Open(wzstring_view path)
+FileCache* FileCache::Open(const fs::path& path)
 {
 	return _OpenExisting(path, false, 0);
 }
@@ -263,7 +263,7 @@ void FileCache::fileCache_updateFiletable(sint32 extraEntriesToAllocate)
 	// update file table info in struct
 	if (this->fileTableEntries[0].name1 != FILECACHE_FILETABLE_NAME1 || this->fileTableEntries[0].name2 != FILECACHE_FILETABLE_NAME2)
 	{
-		forceLog_printf("Corruption in cache file detected");
+		cemuLog_log(LogType::Force, "Corruption in cache file detected");
 		assert_dbg();
 	}
 	this->fileTableOffset = this->fileTableEntries[0].fileOffset;
@@ -287,7 +287,10 @@ uint8* _fileCache_compressFileData(const uint8* fileData, uint32 fileSize, sint3
 	Bytef* compressedData = (Bytef*)malloc(4 + compressedLen);
 	int zret = compress2(compressedData + 4, &compressedLen, uncompressedInput, uncompressedLen, 4); // level 4 has good compression to performance ratio
 	if (zret != Z_OK)
+	{
+		free(compressedData);
 		return nullptr;
+	}
 	compressedData[0] = ((uint32)fileSize >> 24) & 0xFF;
 	compressedData[1] = ((uint32)fileSize >> 16) & 0xFF;
 	compressedData[2] = ((uint32)fileSize >> 8) & 0xFF;
@@ -387,7 +390,7 @@ void FileCache::_addFileInternal(uint64 name1, uint64 name2, const uint8* fileDa
 			{
 				if (name1 == FILECACHE_FILETABLE_NAME1 && name2 == FILECACHE_FILETABLE_NAME2)
 				{
-					forceLog_printf("Error in cache file");
+					cemuLog_log(LogType::Force, "Error in cache file");
 					cemu_assert_debug(false);
 				}
 				// no free entry, recreate file table with larger size
@@ -549,7 +552,7 @@ bool FileCache::GetFileByIndex(sint32 index, uint64* name1, uint64* name2, std::
 	FileTableEntry* entry = this->fileTableEntries + index;
 	if (this->fileTableEntries == nullptr)
 	{
-		forceLog_printf("GetFileByIndex() fileTable is NULL");
+		cemuLog_log(LogType::Force, "GetFileByIndex() fileTable is NULL");
 		return false;
 	}
 	if (entry->name1 == FILECACHE_FILETABLE_FREE_NAME && entry->name2 == FILECACHE_FILETABLE_FREE_NAME)
@@ -611,7 +614,7 @@ sint32 FileCache::GetFileCount()
 
 void fileCache_test()
 {
-	FileCache* fc = FileCache::Create(L"testCache.bin", 0);
+	FileCache* fc = FileCache::Create("testCache.bin", 0);
 	uint32 time1 = GetTickCount();
 
 	char* testString1 = (char*)malloc(1024 * 1024 * 8);
@@ -634,7 +637,7 @@ void fileCache_test()
 	debug_printf("Writing took %dms\n", time2-time1);
 	delete fc;
 	// verify if all entries are still valid
-	FileCache* fcRead = FileCache::Open(L"testCache.bin", 0);
+	FileCache* fcRead = FileCache::Open("testCache.bin", 0);
 	uint32 time3 = GetTickCount();
 	for(sint32 i=0; i<2200; i++)
 	{
@@ -654,4 +657,4 @@ void fileCache_test()
 	delete fcRead;
 	cemu_assert_debug(false);
 	exit(0);
-}
\ No newline at end of file
+}
diff --git a/src/Cemu/FileCache/FileCache.h b/src/Cemu/FileCache/FileCache.h
index 52972fbd..de1996c5 100644
--- a/src/Cemu/FileCache/FileCache.h
+++ b/src/Cemu/FileCache/FileCache.h
@@ -1,6 +1,5 @@
 #pragma once
 
-#include "Common/zstring_view.h"
 #include <mutex>
 
 class FileCache
@@ -36,9 +35,9 @@ public:
 
 	~FileCache();
 
-	static FileCache* Create(wzstring_view path, uint32 extraVersion = 0);
-	static FileCache* Open(wzstring_view path, bool allowCreate, uint32 extraVersion = 0);
-	static FileCache* Open(wzstring_view path); // open without extraVersion check
+	static FileCache* Create(const fs::path& path, uint32 extraVersion = 0);
+	static FileCache* Open(const fs::path& path, bool allowCreate, uint32 extraVersion = 0);
+	static FileCache* Open(const fs::path& path); // open without extraVersion check
 
 	void UseCompression(bool enable) { enableCompression = enable; };
 
@@ -75,7 +74,7 @@ private:
 
 	FileCache() {};
 
-	static FileCache* _OpenExisting(wzstring_view path, bool compareExtraVersion, uint32 extraVersion = 0);
+	static FileCache* _OpenExisting(const fs::path& path, bool compareExtraVersion, uint32 extraVersion = 0);
 
 	void fileCache_updateFiletable(sint32 extraEntriesToAllocate);
 	void _addFileInternal(uint64 name1, uint64 name2, const uint8* fileData, sint32 fileSize, bool noCompression);
diff --git a/src/Cemu/Logging/CemuDebugLogging.h b/src/Cemu/Logging/CemuDebugLogging.h
index ac05c024..7724c798 100644
--- a/src/Cemu/Logging/CemuDebugLogging.h
+++ b/src/Cemu/Logging/CemuDebugLogging.h
@@ -2,7 +2,7 @@
 
 // printf-style macros that are only active in non-release builds
 
-#ifdef PUBLIC_RELEASE
+#ifndef CEMU_DEBUG_ASSERT
 #define debug_printf(...)
 static void debugBreakpoint() { }
 #else
diff --git a/src/Cemu/Logging/CemuLogging.cpp b/src/Cemu/Logging/CemuLogging.cpp
index f58e7984..f3575cc9 100644
--- a/src/Cemu/Logging/CemuLogging.cpp
+++ b/src/Cemu/Logging/CemuLogging.cpp
@@ -1,8 +1,9 @@
 #include "CemuLogging.h"
-#include "config/CemuConfig.h"
 #include "gui/LoggingWindow.h"
-#include "config/ActiveSettings.h"
 #include "util/helpers/helpers.h"
+#include "config/CemuConfig.h"
+#include "config/ActiveSettings.h"
+#include "config/LaunchSettings.h"
 
 #include <mutex>
 #include <condition_variable>
@@ -10,6 +11,8 @@
 
 #include <fmt/printf.h>
 
+uint64 s_loggingFlagMask = cemuLog_getFlag(LogType::Force);
+
 struct _LogContext
 {
 	std::condition_variable_any log_condition;
@@ -33,41 +36,37 @@ struct _LogContext
 
 const std::map<LogType, std::string> g_logging_window_mapping
 {
-	{LogType::File, "Coreinit File-Access"},
-	{LogType::GX2, "GX2"},
-	{LogType::ThreadSync, "Coreinit Thread-Synchronization"},
-	{LogType::SoundAPI, "Audio"},
-	{LogType::Input, "Input"},
-	{LogType::Socket, "Socket"},
-	{LogType::Save, "Save"},
-	{LogType::CoreinitMem, "Coreinit Memory"},
-	{LogType::H264, "H264"},
-	{LogType::OpenGL, "OpenGL"},
-	{LogType::TextureCache, "Texture Cache"},
-	{LogType::nn_nfp, "NFP"},
+	{LogType::UnsupportedAPI,     "Unsupported API calls"},
+	{LogType::APIErrors, 		  "Invalid API usage"},
+	{LogType::CoreinitLogging,    "Coreinit Logging"},
+	{LogType::CoreinitFile,       "Coreinit File-Access"},
+	{LogType::CoreinitThreadSync, "Coreinit Thread-Synchronization"},
+	{LogType::CoreinitMem,        "Coreinit Memory"},
+	{LogType::CoreinitMP,         "Coreinit MP"},
+	{LogType::CoreinitThread,     "Coreinit Thread"},
+	{LogType::NN_NFP,             "nn::nfp"},
+	{LogType::NN_FP,              "nn::fp"},
+	{LogType::NN_BOSS,            "nn::boss"},
+	{LogType::GX2,                "GX2"},
+	{LogType::SoundAPI,           "Audio"},
+	{LogType::InputAPI,           "Input"},
+	{LogType::Socket,             "Socket"},
+	{LogType::Save,               "Save"},
+	{LogType::H264,               "H264"},
+	{LogType::NFC,                "NFC"},
+	{LogType::NTAG,               "NTAG"},
+	{LogType::Patches,            "Graphic pack patches"},
+	{LogType::TextureCache,       "Texture cache"},
+	{LogType::TextureReadback,    "Texture readback"},
+	{LogType::OpenGLLogging,      "OpenGL debug output"},
+	{LogType::VulkanValidation,   "Vulkan validation layer"},
 };
 
-uint64 cemuLog_getFlag(LogType type)
-{
-	return type <= LogType::Force ? 0 : (1ULL << ((uint64)type - 1));
-}
-
 bool cemuLog_advancedPPCLoggingEnabled()
 {
 	return GetConfig().advanced_ppc_logging;
 }
 
-bool cemuLog_isLoggingEnabled(LogType type)
-{
-	if (type == LogType::Placeholder)
-		return false;
-
-	if (type == LogType::None)
-		return false;
-	
-	return (type == LogType::Force)	|| ((GetConfig().log_flag.GetValue() & cemuLog_getFlag(type)) != 0);
-}
-
 void cemuLog_thread()
 {
 	SetThreadName("cemuLog_thread");
@@ -92,13 +91,18 @@ void cemuLog_thread()
 	}
 }
 
+fs::path cemuLog_GetLogFilePath()
+{
+    return ActiveSettings::GetUserDataPath("log.txt");
+}
+
 void cemuLog_createLogFile(bool triggeredByCrash)
 {
 	std::unique_lock lock(LogContext.log_mutex);
 	if (LogContext.file_stream.is_open())
 		return;
 
-	const auto path = ActiveSettings::GetPath("log.txt");
+	const auto path = cemuLog_GetLogFilePath();
 	LogContext.file_stream.open(path, std::ios::out);
 	if (LogContext.file_stream.fail())
 	{
@@ -121,12 +125,8 @@ void cemuLog_writeLineToLog(std::string_view text, bool date, bool new_line)
 		const auto temp_time = std::chrono::system_clock::to_time_t(now);
 		const auto& time = *std::localtime(&temp_time);
 
-#ifdef PUBLIC_RELEASE
-		auto time_str = fmt::format("[{:02d}:{:02d}:{:02d}] ", time.tm_hour, time.tm_min, time.tm_sec);
-#else
 		auto time_str = fmt::format("[{:02d}:{:02d}:{:02d}.{:03d}] ", time.tm_hour, time.tm_min, time.tm_sec,
 			std::chrono::duration_cast<std::chrono::milliseconds>(now - std::chrono::time_point_cast<std::chrono::seconds>(now)).count());
-#endif
 
 		LogContext.text_cache.emplace_back(std::move(time_str));
 	}
@@ -145,6 +145,9 @@ bool cemuLog_log(LogType type, std::string_view text)
 	if (!cemuLog_isLoggingEnabled(type))
 		return false;
 
+	if (LaunchSettings::Verbose())
+		std::cout << text << std::endl;
+
 	cemuLog_writeLineToLog(text);
 
 	const auto it = std::find_if(g_logging_window_mapping.cbegin(), g_logging_window_mapping.cend(),
@@ -163,14 +166,6 @@ bool cemuLog_log(LogType type, std::u8string_view text)
 	return cemuLog_log(type, s);
 }
 
-bool cemuLog_log(LogType type, std::wstring_view text)
-{
-	if (!cemuLog_isLoggingEnabled(type))
-		return false;
-
-	return cemuLog_log(type, boost::nowide::narrow(text.data(), text.size()));
-}
-
 void cemuLog_waitForFlush()
 {
 	cemuLog_createLogFile(false);
@@ -182,93 +177,15 @@ void cemuLog_waitForFlush()
 		std::this_thread::yield();
 		lock.lock();
 	}
-	
 }
 
 // used to atomically write multiple lines to the log
-std::unique_lock<decltype(LogContext.log_mutex)> cafeLog_acquire()
+std::unique_lock<decltype(LogContext.log_mutex)> cemuLog_acquire()
 {
 	return std::unique_lock(LogContext.log_mutex);
 }
 
-void cafeLog_log(uint32 type, const char* format, ...)
+void cemuLog_setActiveLoggingFlags(uint64 flagMask)
 {
-	const auto logType = (LogType)type;
-	if (!cemuLog_isLoggingEnabled(logType))
-		return;
-	
-	char logTempStr[2048];
-	va_list(args);
-	va_start(args, format);
-#if BOOST_OS_WINDOWS
-	vsprintf_s(logTempStr, format, args);
-#else
-	vsprintf(logTempStr, format, args);
-#endif
-	va_end(args);
-
-	cemuLog_writeLineToLog(logTempStr);
-	
-	const auto it = std::find_if(g_logging_window_mapping.cbegin(), g_logging_window_mapping.cend(),
-		[logType](const auto& entry) { return entry.first == logType; });
-	if (it == g_logging_window_mapping.cend())
-		LoggingWindow::Log(logTempStr);
-	else
-		LoggingWindow::Log(it->second, logTempStr);
-}
-
-void cafeLog_logW(uint32 type, const wchar_t* format, ...)
-{
-	const auto logType = (LogType)type;
-	if (!cemuLog_isLoggingEnabled(logType))
-		return;
-	
-	wchar_t logTempStr[2048];
-	va_list(args);
-	va_start(args, format);
-#if BOOST_OS_WINDOWS
-	vswprintf_s(logTempStr, format, args);
-#else
-	vswprintf(logTempStr, 2048, format, args);
-#endif
-	va_end(args);
-	
-	cemuLog_log(logType, logTempStr);
-
-	const auto it = std::find_if(g_logging_window_mapping.cbegin(), g_logging_window_mapping.cend(),
-		[logType](const auto& entry) { return entry.first == logType; });
-	if (it == g_logging_window_mapping.cend())
-		LoggingWindow::Log(logTempStr);
-	else
-		LoggingWindow::Log(it->second, logTempStr);
-}
-
-void cemuLog_log()
-{
-	typedef void(*VoidFunc)();
-	const VoidFunc func = (VoidFunc)cafeLog_log;
-	func();
-}
-
-void cafeLog_logLine(uint32 type, const char* line)
-{
-	if (!cemuLog_isLoggingEnabled((LogType)type))
-		return;
-	
-	cemuLog_writeLineToLog(line);
-}
-
-void cafeLog_setLoggingFlagEnable(sint32 loggingType, bool isEnable)
-{
-	if (isEnable)
-		GetConfig().log_flag = GetConfig().log_flag.GetValue() | cemuLog_getFlag((LogType)loggingType);
-	else
-		GetConfig().log_flag = GetConfig().log_flag.GetValue() & ~cemuLog_getFlag((LogType)loggingType);
-	
-	g_config.Save();
-}
-
-bool cafeLog_isLoggingFlagEnabled(sint32 loggingType)
-{
-	return cemuLog_isLoggingEnabled((LogType)loggingType);
+	s_loggingFlagMask = flagMask | cemuLog_getFlag(LogType::Force);
 }
diff --git a/src/Cemu/Logging/CemuLogging.h b/src/Cemu/Logging/CemuLogging.h
index d89d9cec..d729d364 100644
--- a/src/Cemu/Logging/CemuLogging.h
+++ b/src/Cemu/Logging/CemuLogging.h
@@ -1,36 +1,52 @@
 #pragma once
 
+extern uint64 s_loggingFlagMask;
+
 enum class LogType : sint32
 {
-	Placeholder = -2,
-	None = -1,
-	Force = 0, // this logging type is always on
-	File = 1, // coreinit file?
-	GX2 = 2,
-	UnsupportedAPI = 3,
-	ThreadSync = 4,
-	SoundAPI = 5, // any audio related API
-	Input = 6, // any input related API
-	Socket = 7,
-	Save = 8,
-	CoreinitMem = 9, // coreinit memory functions
-	H264 = 10,
-	OpenGL = 11, // OpenGL debug logging
-	TextureCache = 12, // texture cache warnings and info
-	VulkanValidation = 13, // Vulkan validation layer
-	nn_nfp = 14, // nn_nfp (Amiibo) API
-	Patches = 15,
-	CoreinitMP = 16,
-	CoreinitThread = 17,
-	CoreinitLogging = 18, // OSReport, OSConsoleWrite etc.
+	// note: IDs must be in range 1-64
+	Force = 63, // always enabled
+	Placeholder = 62, // always disabled
+	APIErrors = 61, // Logs bad parameters or other API usage mistakes or unintended errors in OS libs. Intended for homebrew developers
 
-	PPC_IPC = 20,
-	NN_AOC = 21,
-	NN_PDM = 22,
+	CoreinitFile = 0,
+	GX2 = 1,
+	UnsupportedAPI = 2,
+	SoundAPI = 4, // any audio related API
+	InputAPI = 5, // any input related API
+	Socket = 6,
+	Save = 7,
+	H264 = 9,
+	OpenGLLogging = 10, // OpenGL debug logging
+	TextureCache = 11, // texture cache warnings and info
+	VulkanValidation = 12, // Vulkan validation layer
+	Patches = 14,
+	CoreinitMem = 8, // coreinit memory functions
+	CoreinitMP = 15,
+	CoreinitThread = 16,
+	CoreinitLogging = 17, // OSReport, OSConsoleWrite etc.
+	CoreinitMemoryMapping = 18, // OSGetAvailPhysAddrRange, OSAllocVirtAddr, OSMapMemory etc.
+	CoreinitAlarm = 22,
+	CoreinitThreadSync = 3,
 
-	ProcUi = 40,
+	PPC_IPC = 19,
+	NN_AOC = 20,
+	NN_PDM = 21,
+	NN_OLV = 23,
+	NN_NFP = 13,
+	NN_FP = 24,
+	NN_BOSS = 25,
+	NN_SL = 26,
 
-	APIErrors = 0, // alias for 0. Logs bad parameters or other API errors in OS libs
+	TextureReadback = 29,
+	ProcUi = 39,
+	nlibcurl = 41,
+
+	PRUDP = 40,
+
+	NFC	= 41,
+	NTAG = 42,
+	Recompiler = 60,
 };
 
 template <>
@@ -46,131 +62,74 @@ struct fmt::formatter<std::u8string_view> : formatter<string_view> {
 void cemuLog_writeLineToLog(std::string_view text, bool date = true, bool new_line = true);
 inline void cemuLog_writePlainToLog(std::string_view text) { cemuLog_writeLineToLog(text, false, false); }
 
-bool cemuLog_isLoggingEnabled(LogType type);
+void cemuLog_setActiveLoggingFlags(uint64 flagMask);
+
+inline uint64 cemuLog_getFlag(LogType type)
+{
+	return 1ULL << (uint64)type;
+}
+
+inline bool cemuLog_isLoggingEnabled(LogType type)
+{
+	return (s_loggingFlagMask & cemuLog_getFlag(type)) != 0;
+}
 
 bool cemuLog_log(LogType type, std::string_view text);
 bool cemuLog_log(LogType type, std::u8string_view text);
-bool cemuLog_log(LogType type, std::wstring_view text);
 void cemuLog_waitForFlush(); // wait until all log lines are written
 
-template <typename T>
-auto ForwardEnum(T t) 
-{
-  if constexpr (std::is_enum_v<T>)
-    return fmt::underlying(t);
-  else
-    return std::forward<T>(t);
-}
-
-template <typename... TArgs>
-auto ForwardEnum(std::tuple<TArgs...> t) 
-{ 
-	return std::apply([](auto... x) { return std::make_tuple(ForwardEnum(x)...); }, t);
-}
-
 template<typename T, typename ... TArgs>
-bool cemuLog_log(LogType type, std::basic_string<T> format, TArgs&&... args)
+bool cemuLog_log(LogType type, std::basic_string<T> formatStr, TArgs&&... args)
 {
 	if (!cemuLog_isLoggingEnabled(type))
 		return false;
-
-	const auto format_view = fmt::basic_string_view<T>(format);
-	const auto text = fmt::vformat(format_view, fmt::make_format_args<fmt::buffer_context<T>>(ForwardEnum(args)...));
-	cemuLog_log(type, std::basic_string_view(text.data(), text.size()));
+	if constexpr (sizeof...(TArgs) == 0)
+	{
+		cemuLog_log(type, std::basic_string_view<T>(formatStr.data(), formatStr.size()));
+		return true;
+	}
+	else
+	{
+		const auto format_view = fmt::basic_string_view<T>(formatStr);
+#if FMT_VERSION >= 110000
+		const auto text = fmt::vformat(format_view, fmt::make_format_args<fmt::buffered_context<T>>(args...));
+#else
+		const auto text = fmt::vformat(format_view, fmt::make_format_args<fmt::buffer_context<T>>(args...));
+#endif
+		cemuLog_log(type, std::basic_string_view(text.data(), text.size()));
+	}
 	return true;
 }
  
 template<typename T, typename ... TArgs>
 bool cemuLog_log(LogType type, const T* format, TArgs&&... args)
 {
-	auto format_str=std::basic_string<T>(format);
+	if (!cemuLog_isLoggingEnabled(type))
+		return false;
+	auto format_str = std::basic_string<T>(format);
 	return cemuLog_log(type, format_str, std::forward<TArgs>(args)...);
 }
 
-// same as cemuLog_log, but only outputs in debug/release mode
+#define cemuLog_logOnce(...) { static bool _not_first_call = false; if (!_not_first_call) { _not_first_call = true; cemuLog_log(__VA_ARGS__); } }
+
+// same as cemuLog_log, but only outputs in debug mode
 template<typename TFmt, typename ... TArgs>
 bool cemuLog_logDebug(LogType type, TFmt format, TArgs&&... args)
 {
-#ifndef PUBLIC_RELEASE
+#ifdef CEMU_DEBUG_ASSERT
 	return cemuLog_log(type, format, std::forward<TArgs>(args)...);
 #else
 	return false;
 #endif
 }
 
+#define cemuLog_logDebugOnce(...) { static bool _not_first_call = false; if (!_not_first_call) { _not_first_call = true; cemuLog_logDebug(__VA_ARGS__); } }
+
 // cafe lib calls
 bool cemuLog_advancedPPCLoggingEnabled();
 
 uint64 cemuLog_getFlag(LogType type);
-void cafeLog_setLoggingFlagEnable(sint32 loggingType, bool isEnable);
-bool cafeLog_isLoggingFlagEnabled(sint32 loggingType);
 
+fs::path cemuLog_GetLogFilePath();
 void cemuLog_createLogFile(bool triggeredByCrash);
-
-[[nodiscard]] std::unique_lock<std::recursive_mutex> cafeLog_acquire();
-
-// legacy methods
-void cafeLog_log(uint32 type, const char* format, ...);
-void cafeLog_logW(uint32 type, const wchar_t* format, ...);
-void cafeLog_logLine(uint32 type, const char* line);
-
-// legacy log types, deprecated. Use LogType instead
-#define LOG_TYPE_FORCE				(0) // this logging type is always on
-#define LOG_TYPE_FILE				(1)
-#define LOG_TYPE_GX2				(2)
-#define LOG_TYPE_UNSUPPORTED_API	(3)
-#define LOG_TYPE_THREADSYNC			(4)
-#define LOG_TYPE_SNDAPI				(5) // any audio related API
-#define LOG_TYPE_INPUT				(6) // any input related API
-#define LOG_TYPE_SOCKET				(7) // anything from nn_sysnet
-#define LOG_TYPE_SAVE				(8) // anything from nn_save
-#define LOG_TYPE_COREINIT_MEM		(9)	// coreinit memory functions
-#define LOG_TYPE_H264				(10)
-#define LOG_TYPE_OPENGL				(11) // OpenGL debug logging
-#define LOG_TYPE_TEXTURE_CACHE		(12) // texture cache warnings and info
-#define LOG_TYPE_VULKAN_VALIDATION	(13) // Vulkan validation layer
-#define LOG_TYPE_NFP				(14) // nn_nfp (Amiibo) API
-#define LOG_TYPE_PATCHES			(15) // logging for graphic pack patches
-#define LOG_TYPE_COREINIT_MP		(16)
-#define LOG_TYPE_COREINIT_THREAD	(17)
-#define LOG_TYPE_COREINIT_LOGGING	(18)
-#define LOG_TYPE_LAST				(64) // set to 64 so we can easily add more log types in the future without destroying settings file compatibility
-
-// force log. Redundant -> replace with _log(LogType::Force, ...) call
-inline bool cemuLog_force(std::string_view msg)
-{
-	return cemuLog_log(LogType::Force, msg);
-}
-
-inline bool cemuLog_force(std::wstring_view msg)
-{
-	return cemuLog_log(LogType::Force, msg);
-}
-
-template<typename TFmt, typename ... TArgs>
-void cemuLog_force(TFmt format, TArgs&&... args)
-{
-	cemuLog_log(LogType::Force, format, std::forward<TArgs>(args)...);
-}
-
-// these are deprecated. Superseded by cemuLog_log(type, ...)
-#define forceLog_printf(...)		cafeLog_log(LOG_TYPE_FORCE, __VA_ARGS__);
-#define forceLog_printfW(...)		cafeLog_logW(LOG_TYPE_FORCE, __VA_ARGS__);
-#define gx2Log_printf(...)			if( cafeLog_isLoggingFlagEnabled(LOG_TYPE_GX2) ) cafeLog_log(LOG_TYPE_GX2, __VA_ARGS__);
-#define coreinitMemLog_printf(...)	if( cafeLog_isLoggingFlagEnabled(LOG_TYPE_COREINIT_MEM) ) cafeLog_log(LOG_TYPE_COREINIT_MEM, __VA_ARGS__);
-#define sndApiLog_printf(...)		if( cafeLog_isLoggingFlagEnabled(LOG_TYPE_SNDAPI) ) cafeLog_log(LOG_TYPE_SNDAPI, __VA_ARGS__);
-#define socketLog_printf(...)		if( cafeLog_isLoggingFlagEnabled(LOG_TYPE_SOCKET) ) cafeLog_log(LOG_TYPE_SOCKET, __VA_ARGS__);
-#define inputLog_printf(...)		if( cafeLog_isLoggingFlagEnabled(LOG_TYPE_INPUT) ) cafeLog_log(LOG_TYPE_INPUT, __VA_ARGS__);
-#define saveLog_printf(...)			if( cafeLog_isLoggingFlagEnabled(LOG_TYPE_SAVE) ) cafeLog_log(LOG_TYPE_SAVE, __VA_ARGS__);
-#define nfpLog_printf(...)			if( cafeLog_isLoggingFlagEnabled(LOG_TYPE_NFP) ) cafeLog_log(LOG_TYPE_NFP, __VA_ARGS__);
-
-#ifndef PUBLIC_RELEASE
-#define forceLogDebug_printf(...)		cafeLog_log(LOG_TYPE_FORCE, __VA_ARGS__);
-#define forceLogDebug_printfW(...)		cafeLog_logW(LOG_TYPE_FORCE, __VA_ARGS__);
-
- // use this for temporary debug logging. Will trigger compilation error in release builds
-#define forceLogRemoveMe_printf(...)	cafeLog_log(LOG_TYPE_FORCE, __VA_ARGS__);
-#else
-#define forceLogDebug_printf(...)	;
-#define forceLogDebug_printfW(...)	;
-#endif
+[[nodiscard]] std::unique_lock<std::recursive_mutex> cemuLog_acquire(); // used for logging multiple lines at once
diff --git a/src/Cemu/PPCAssembler/ppcAssembler.cpp b/src/Cemu/PPCAssembler/ppcAssembler.cpp
index c8c28191..df20b21d 100644
--- a/src/Cemu/PPCAssembler/ppcAssembler.cpp
+++ b/src/Cemu/PPCAssembler/ppcAssembler.cpp
@@ -653,7 +653,7 @@ public:
 			{
 				immD = ep.Evaluate(svExpressionPart);
 				sint32 imm = (sint32)immD;
-				if (imm < -32768 && imm > 32767)
+				if (imm < -32768 || imm > 32767)
 				{
 					std::string msg = fmt::format("\"{}\" evaluates to offset out of range (Valid range is -32768 to 32767)", svExpressionPart);
 					ppcAssembler_setError(assemblerCtx->ctx, msg);
@@ -2126,7 +2126,7 @@ bool _ppcAssembler_isConstantBranchTargetExpr(std::string& expressionString, sin
 		{
 			return false;
 		}
-		relativeAddr = (uint32)branchDistance;
+		relativeAddr = (sint32)branchDistance;
 		return true;
 	}
 	return false;
@@ -2418,6 +2418,9 @@ bool ppcAssembler_assembleSingleInstruction(char const* text, PPCAssemblerInOut*
 	_ppcAssembler_translateAlias(instructionName);
 	// parse operands
 	internalInfo.listOperandStr.clear();
+
+	bool isInString = false;
+
 	while (currentPtr < endPtr)
 	{
 		currentPtr++;
@@ -2425,7 +2428,10 @@ bool ppcAssembler_assembleSingleInstruction(char const* text, PPCAssemblerInOut*
 		// find end of operand
 		while (currentPtr < endPtr)
 		{
-			if (*currentPtr == ',')
+			if (*currentPtr == '"')
+				isInString=!isInString;
+
+			if (*currentPtr == ',' && !isInString)
 				break;
 			currentPtr++;
 		}
@@ -3497,7 +3503,7 @@ void ppcAsmTestDisassembler()
 
 void ppcAsmTest()
 {
-#ifndef PUBLIC_RELEASE
+#ifdef CEMU_DEBUG_ASSERT
 	ppcAsmTestDisassembler();
 #endif
 }
diff --git a/src/Cemu/Tools/DownloadManager/DownloadManager.cpp b/src/Cemu/Tools/DownloadManager/DownloadManager.cpp
index 33af7433..9e683ed1 100644
--- a/src/Cemu/Tools/DownloadManager/DownloadManager.cpp
+++ b/src/Cemu/Tools/DownloadManager/DownloadManager.cpp
@@ -33,14 +33,7 @@ void DownloadManager::downloadTitleVersionList()
 {
 	if (m_hasTitleVersionList)
 		return;
-	NAPI::AuthInfo authInfo;
-	authInfo.accountId = m_authInfo.nnidAccountName;
-	authInfo.passwordHash = m_authInfo.passwordHash;
-	authInfo.deviceId = m_authInfo.deviceId;
-	authInfo.serial = m_authInfo.serial;
-	authInfo.country = m_authInfo.country;
-	authInfo.region = m_authInfo.region;
-	authInfo.deviceCertBase64 = m_authInfo.deviceCertBase64;
+	NAPI::AuthInfo authInfo = GetAuthInfo(false);
 	auto versionListVersionResult = NAPI::TAG_GetVersionListVersion(authInfo);
 	if (!versionListVersionResult.isValid)
 		return;
@@ -195,15 +188,7 @@ public:
 
 bool DownloadManager::_connect_refreshIASAccountIdAndDeviceToken()
 {
-	NAPI::AuthInfo authInfo;
-	authInfo.accountId = m_authInfo.nnidAccountName;
-	authInfo.passwordHash = m_authInfo.passwordHash;
-	authInfo.deviceId = m_authInfo.deviceId;
-	authInfo.serial = m_authInfo.serial;
-	authInfo.country = m_authInfo.country;
-	authInfo.region = m_authInfo.region;
-	authInfo.deviceCertBase64 = m_authInfo.deviceCertBase64;
-
+	NAPI::AuthInfo authInfo = GetAuthInfo(false);
 	// query IAS/ECS account id and device token (if not cached)
 	auto rChallenge = NAPI::IAS_GetChallenge(authInfo);
 	if (rChallenge.apiError != NAPI_RESULT::SUCCESS)
@@ -211,7 +196,6 @@ bool DownloadManager::_connect_refreshIASAccountIdAndDeviceToken()
 	auto rRegistrationInfo = NAPI::IAS_GetRegistrationInfo_QueryInfo(authInfo, rChallenge.challenge);
 	if (rRegistrationInfo.apiError != NAPI_RESULT::SUCCESS)
 		return false;
-
 	m_iasToken.serviceAccountId = rRegistrationInfo.accountId;
 	m_iasToken.deviceToken = rRegistrationInfo.deviceToken;
 	// store to cache
@@ -221,24 +205,13 @@ bool DownloadManager::_connect_refreshIASAccountIdAndDeviceToken()
 	std::vector<uint8> serializedData;
 	if (!storedTokenInfo.serialize(serializedData))
 		return false;
-	s_nupFileCache->AddFileAsync({ fmt::format("{}/token_info", m_authInfo.nnidAccountName) }, serializedData.data(), serializedData.size());
+	s_nupFileCache->AddFileAsync({ fmt::format("{}/token_info", m_authInfo.cachefileName) }, serializedData.data(), serializedData.size());
 	return true;
 }
 
 bool DownloadManager::_connect_queryAccountStatusAndServiceURLs()
 {
-	NAPI::AuthInfo authInfo;
-	authInfo.accountId = m_authInfo.nnidAccountName;
-	authInfo.passwordHash = m_authInfo.passwordHash;
-	authInfo.deviceId = m_authInfo.deviceId;
-	authInfo.serial = m_authInfo.serial;
-	authInfo.country = m_authInfo.country;
-	authInfo.region = m_authInfo.region;
-	authInfo.deviceCertBase64 = m_authInfo.deviceCertBase64;
-
-	authInfo.IASToken.accountId = m_iasToken.serviceAccountId;
-	authInfo.IASToken.deviceToken = m_iasToken.deviceToken;
-
+	NAPI::AuthInfo authInfo = GetAuthInfo(true);
 	NAPI::NAPI_ECSGetAccountStatus_Result accountStatusResult = NAPI::ECS_GetAccountStatus(authInfo);
 	if (accountStatusResult.apiError != NAPI_RESULT::SUCCESS)
 	{
@@ -291,7 +264,7 @@ void DownloadManager::loadTicketCache()
 	m_ticketCache.clear();
 	cemu_assert_debug(m_ticketCache.empty());
 	std::vector<uint8> ticketCacheBlob;	
-	if (!s_nupFileCache->GetFile({ fmt::format("{}/eticket_cache", m_authInfo.nnidAccountName) }, ticketCacheBlob))
+	if (!s_nupFileCache->GetFile({ fmt::format("{}/eticket_cache", m_authInfo.cachefileName) }, ticketCacheBlob))
 		return;
 	MemStreamReader memReader(ticketCacheBlob.data(), ticketCacheBlob.size());
 	uint8 version = memReader.readBE<uint8>();
@@ -343,23 +316,12 @@ void DownloadManager::storeTicketCache()
 			memWriter.writePODVector(cert);
 	}
 	auto serializedBlob = memWriter.getResult();
-	s_nupFileCache->AddFileAsync({ fmt::format("{}/eticket_cache", m_authInfo.nnidAccountName) }, serializedBlob.data(), serializedBlob.size());
+	s_nupFileCache->AddFileAsync({ fmt::format("{}/eticket_cache", m_authInfo.cachefileName) }, serializedBlob.data(), serializedBlob.size());
 }
 
 bool DownloadManager::syncAccountTickets()
 {
-	NAPI::AuthInfo authInfo;
-	authInfo.accountId = m_authInfo.nnidAccountName;
-	authInfo.passwordHash = m_authInfo.passwordHash;
-	authInfo.deviceId = m_authInfo.deviceId;
-	authInfo.serial = m_authInfo.serial;
-	authInfo.country = m_authInfo.country;
-	authInfo.region = m_authInfo.region;
-	authInfo.deviceCertBase64 = m_authInfo.deviceCertBase64;
-
-	authInfo.IASToken.accountId = m_iasToken.serviceAccountId;
-	authInfo.IASToken.deviceToken = m_iasToken.deviceToken;
-
+	NAPI::AuthInfo authInfo = GetAuthInfo(true);
 	// query TIV list from server
 	NAPI::NAPI_ECSAccountListETicketIds_Result resultTicketIds = NAPI::ECS_AccountListETicketIds(authInfo);
 	if (!resultTicketIds.isValid())
@@ -371,7 +333,7 @@ bool DownloadManager::syncAccountTickets()
 	for (auto& tiv : resultTicketIds.tivs)
 	{
 		index++;
-		std::string msg = _("Downloading account ticket").ToStdString();
+		std::string msg = _("Downloading account ticket").utf8_string();
 		msg.append(fmt::format(" {0}/{1}", index, count));
 		setStatusMessage(msg, DLMGR_STATUS_CODE::CONNECTING);
 		// skip if already cached
@@ -424,20 +386,8 @@ bool DownloadManager::syncAccountTickets()
 
 bool DownloadManager::syncSystemTitleTickets()
 {
-	setStatusMessage(std::string(_("Downloading system tickets...")), DLMGR_STATUS_CODE::CONNECTING);
-	// todo - add GetAuth() function
-	NAPI::AuthInfo authInfo;
-	authInfo.accountId = m_authInfo.nnidAccountName;
-	authInfo.passwordHash = m_authInfo.passwordHash;
-	authInfo.deviceId = m_authInfo.deviceId;
-	authInfo.serial = m_authInfo.serial;
-	authInfo.country = m_authInfo.country;
-	authInfo.region = m_authInfo.region;
-	authInfo.deviceCertBase64 = m_authInfo.deviceCertBase64;
-
-	authInfo.IASToken.accountId = m_iasToken.serviceAccountId;
-	authInfo.IASToken.deviceToken = m_iasToken.deviceToken;
-
+	setStatusMessage(_("Downloading system tickets...").utf8_string(), DLMGR_STATUS_CODE::CONNECTING);
+	NAPI::AuthInfo authInfo = GetAuthInfo(true);
 	auto querySystemTitleTicket = [&](uint64 titleId) -> void
 	{
 		// check if cached already
@@ -486,7 +436,7 @@ bool DownloadManager::syncSystemTitleTickets()
 // build list of updates for which either an installed game exists or the base title ticket is cached
 bool DownloadManager::syncUpdateTickets()
 {
-	setStatusMessage(std::string(_("Retrieving update information...")), DLMGR_STATUS_CODE::CONNECTING);
+	setStatusMessage(_("Retrieving update information...").utf8_string(), DLMGR_STATUS_CODE::CONNECTING);
 	// download update version list
 	downloadTitleVersionList();
 	if (!m_hasTitleVersionList)
@@ -508,7 +458,7 @@ bool DownloadManager::syncUpdateTickets()
 		if (titleIdParser.GetType() != TitleIdParser::TITLE_TYPE::BASE_TITLE_UPDATE)
 			continue;
 
-		std::string msg = _("Downloading ticket").ToStdString();
+		std::string msg = _("Downloading ticket").utf8_string();
 		msg.append(fmt::format(" {0}/{1}", updateIndex, numUpdates));
 		updateIndex++;
 		setStatusMessage(msg, DLMGR_STATUS_CODE::CONNECTING);
@@ -520,8 +470,7 @@ bool DownloadManager::syncUpdateTickets()
 		if (findTicketByTitleIdAndVersion(itr.titleId, itr.availableTitleVersion))
 			continue;
 
-		NAPI::AuthInfo dummyAuth;
-		auto cetkResult = NAPI::CCS_GetCETK(dummyAuth, itr.titleId, itr.availableTitleVersion);
+		auto cetkResult = NAPI::CCS_GetCETK(GetDownloadMgrNetworkService(), itr.titleId, itr.availableTitleVersion);
 		if (!cetkResult.isValid)
 			continue;
 		NCrypto::ETicketParser ticketParser;
@@ -561,12 +510,12 @@ bool DownloadManager::syncTicketCache()
 	for (auto& ticketInfo : m_ticketCache)
 	{
 		index++;
-		std::string msg = _("Downloading meta data").ToStdString();
+		std::string msg = _("Downloading meta data").utf8_string();
 		msg.append(fmt::format(" {0}/{1}", index, count));
 		setStatusMessage(msg, DLMGR_STATUS_CODE::CONNECTING);
 		prepareIDBE(ticketInfo.titleId);
 	}
-	setStatusMessage(std::string(_("Connected. Right click entries in the list to start downloading")), DLMGR_STATUS_CODE::CONNECTED);
+	setStatusMessage(_("Connected. Right click entries in the list to start downloading").utf8_string(), DLMGR_STATUS_CODE::CONNECTED);
 	return true;
 }
 
@@ -652,12 +601,12 @@ void DownloadManager::_handle_connect()
 	// reset login state
 	m_iasToken.serviceAccountId.clear();
 	m_iasToken.deviceToken.clear();
-	setStatusMessage(std::string(_("Logging in..")), DLMGR_STATUS_CODE::CONNECTING);
+	setStatusMessage(_("Logging in...").utf8_string(), DLMGR_STATUS_CODE::CONNECTING);
 	// retrieve ECS AccountId + DeviceToken from cache
 	if (s_nupFileCache)
 	{
 		std::vector<uint8> serializationBlob;
-		if (s_nupFileCache->GetFile({ fmt::format("{}/token_info", m_authInfo.nnidAccountName) }, serializationBlob))
+		if (s_nupFileCache->GetFile({ fmt::format("{}/token_info", m_authInfo.cachefileName) }, serializationBlob))
 		{
 			StoredTokenInfo storedTokenInfo;
 			if (storedTokenInfo.deserialize(serializationBlob))
@@ -672,10 +621,10 @@ void DownloadManager::_handle_connect()
 	{
 		if (!_connect_refreshIASAccountIdAndDeviceToken())
 		{
-			forceLog_printf("Failed to request IAS token");
+			cemuLog_log(LogType::Force, "Failed to request IAS token");
 			cemu_assert_debug(false);
 			m_connectState.store(CONNECT_STATE::FAILED);
-			setStatusMessage(std::string(_("Login failed. Outdated or incomplete online files?")), DLMGR_STATUS_CODE::FAILED);
+			setStatusMessage(_("Login failed. Outdated or incomplete online files?").utf8_string(), DLMGR_STATUS_CODE::FAILED);
 			return;
 		}
 	}
@@ -683,16 +632,16 @@ void DownloadManager::_handle_connect()
 	if (!_connect_queryAccountStatusAndServiceURLs())
 	{
 		m_connectState.store(CONNECT_STATE::FAILED);
-		setStatusMessage(std::string(_("Failed to query account status. Invalid account information?")), DLMGR_STATUS_CODE::FAILED);
+		setStatusMessage(_("Failed to query account status").utf8_string(), DLMGR_STATUS_CODE::FAILED);
 		return;
 	}
 	// load ticket cache and sync
-	setStatusMessage(std::string(_("Updating ticket cache")), DLMGR_STATUS_CODE::CONNECTING);
+	setStatusMessage(_("Updating ticket cache").utf8_string(), DLMGR_STATUS_CODE::CONNECTING);
 	loadTicketCache();
 	if (!syncTicketCache())
 	{
 		m_connectState.store(CONNECT_STATE::FAILED);
-		setStatusMessage(std::string(_("Failed to request tickets (invalid NNID?)")), DLMGR_STATUS_CODE::FAILED);
+		setStatusMessage(_("Failed to request tickets").utf8_string(), DLMGR_STATUS_CODE::FAILED);
 		return;
 	}
 	searchForIncompleteDownloads();
@@ -713,22 +662,10 @@ void DownloadManager::connect(
 	std::string_view serial,
 	std::string_view deviceCertBase64)
 {
-	if (nnidAccountName.empty())
-	{
-		m_connectState.store(CONNECT_STATE::FAILED);
-		setStatusMessage(std::string(_("This account is not linked with an NNID")), DLMGR_STATUS_CODE::FAILED);
-		return;
-	}
 	runManager();
 	m_authInfo.nnidAccountName = nnidAccountName;
 	m_authInfo.passwordHash = passwordHash;
-	if (std::all_of(m_authInfo.passwordHash.begin(), m_authInfo.passwordHash.end(), [](uint8 v) { return v == 0; }))
-	{
-		cemuLog_log(LogType::Force, "DLMgr: Invalid password hash");
-		m_connectState.store(CONNECT_STATE::FAILED);
-		setStatusMessage(std::string(_("Failed. Account does not have password set")), DLMGR_STATUS_CODE::FAILED);
-		return;
-	}
+	m_authInfo.cachefileName = nnidAccountName.empty() ? "DefaultName" : nnidAccountName;
 	m_authInfo.region = region;
 	m_authInfo.country = country;
 	m_authInfo.deviceCertBase64 = deviceCertBase64;
@@ -744,6 +681,31 @@ bool DownloadManager::IsConnected() const
 	return m_connectState.load() != CONNECT_STATE::UNINITIALIZED;
 }
 
+NetworkService DownloadManager::GetDownloadMgrNetworkService()
+{
+	return NetworkService::Nintendo;
+}
+
+NAPI::AuthInfo DownloadManager::GetAuthInfo(bool withIasToken)
+{
+	NAPI::AuthInfo authInfo;
+	authInfo.serviceOverwrite = GetDownloadMgrNetworkService();
+	authInfo.accountId = m_authInfo.nnidAccountName;
+	authInfo.passwordHash = m_authInfo.passwordHash;
+	authInfo.deviceId = m_authInfo.deviceId;
+	authInfo.serial = m_authInfo.serial;
+	authInfo.country = m_authInfo.country;
+	authInfo.region = m_authInfo.region;
+	authInfo.deviceCertBase64 = m_authInfo.deviceCertBase64;
+	if(withIasToken)
+	{
+		cemu_assert_debug(!m_iasToken.serviceAccountId.empty());
+		authInfo.IASToken.accountId = m_iasToken.serviceAccountId;
+		authInfo.IASToken.deviceToken = m_iasToken.deviceToken;
+	}
+	return authInfo;
+}
+
 /* package / downloading */
 
 // start/resume/retry download
@@ -967,7 +929,7 @@ void DownloadManager::setPackageError(Package* package, std::string errorMsg)
 	if (package->state.hasError)
 		return; // dont overwrite already set error message
 	package->state.hasError = true;
-	package->state.errorMsg = errorMsg;
+	package->state.errorMsg = std::move(errorMsg);
 	reportPackageStatus(package);
 }
 
@@ -1022,17 +984,7 @@ void DownloadManager::reportPackageProgress(Package* package, uint32 currentProg
 
 void DownloadManager::asyncPackageDownloadTMD(Package* package)
 {
-	NAPI::AuthInfo authInfo;
-	authInfo.accountId = m_authInfo.nnidAccountName;
-	authInfo.passwordHash = m_authInfo.passwordHash;
-	authInfo.deviceId = m_authInfo.deviceId;
-	authInfo.serial = m_authInfo.serial;
-	authInfo.country = m_authInfo.country;
-	authInfo.region = m_authInfo.region;
-	authInfo.deviceCertBase64 = m_authInfo.deviceCertBase64;
-	authInfo.IASToken.accountId = m_iasToken.serviceAccountId;
-	authInfo.IASToken.deviceToken = m_iasToken.deviceToken;
-
+	NAPI::AuthInfo authInfo = GetAuthInfo(true);
 	TitleIdParser titleIdParser(package->titleId);
 	NAPI::NAPI_CCSGetTMD_Result tmdResult;
 	if (titleIdParser.GetType() == TitleIdParser::TITLE_TYPE::AOC)
@@ -1054,7 +1006,7 @@ void DownloadManager::asyncPackageDownloadTMD(Package* package)
 	std::unique_lock<std::recursive_mutex> _l(m_mutex);
 	if (!tmdResult.isValid)
 	{
-		setPackageError(package, from_wxString(_("TMD download failed")));
+		setPackageError(package, _("TMD download failed").utf8_string());
 		package->state.isDownloadingTMD = false;
 		return;
 	}
@@ -1063,7 +1015,7 @@ void DownloadManager::asyncPackageDownloadTMD(Package* package)
 	NCrypto::TMDParser tmdParser;
 	if (!tmdParser.parse(tmdResult.tmdData.data(), tmdResult.tmdData.size()))
 	{
-		setPackageError(package, from_wxString(_("Invalid TMD")));
+		setPackageError(package, _("Invalid TMD").utf8_string());
 		package->state.isDownloadingTMD = false;
 		return;
 	}
@@ -1172,7 +1124,7 @@ void DownloadManager::asyncPackageDownloadContentFile(Package* package, uint16 i
 				size_t bytesWritten = callbackInfo->receiveBuffer.size();
 				if (callbackInfo->fileOutput->writeData(callbackInfo->receiveBuffer.data(), callbackInfo->receiveBuffer.size()) != (uint32)callbackInfo->receiveBuffer.size())
 				{
-					callbackInfo->downloadMgr->setPackageError(callbackInfo->package, from_wxString(_("Cannot write file. Disk full?")));
+					callbackInfo->downloadMgr->setPackageError(callbackInfo->package, _("Cannot write file. Disk full?").utf8_string());
 					return false;
 				}
 				callbackInfo->receiveBuffer.clear();
@@ -1193,12 +1145,12 @@ void DownloadManager::asyncPackageDownloadContentFile(Package* package, uint16 i
 	callbackInfoData.fileOutput = FileStream::createFile2(packageDownloadPath / fmt::format("{:08x}.app", contentId));
 	if (!callbackInfoData.fileOutput)
 	{
-		setPackageError(package, from_wxString(_("Cannot create file")));
+		setPackageError(package, _("Cannot create file").utf8_string());
 		return;
 	}
-	if (!NAPI::CCS_GetContentFile(titleId, contentId, CallbackInfo::writeCallback, &callbackInfoData))
+	if (!NAPI::CCS_GetContentFile(GetDownloadMgrNetworkService(), titleId, contentId, CallbackInfo::writeCallback, &callbackInfoData))
 	{
-		setPackageError(package, from_wxString(_("Download failed")));
+		setPackageError(package, _("Download failed").utf8_string());
 		delete callbackInfoData.fileOutput;
 		return;
 	}
@@ -1216,7 +1168,6 @@ void DownloadManager::asyncPackageDownloadContentFile(Package* package, uint16 i
 void DownloadManager::asyncPackageVerifyFile(Package* package, uint16 index, bool isCheckState)
 {
 	uint8 tmdContentHash[32];
-	std::string filePathStr;
 	// get titleId, contentId and file path
 	std::unique_lock<std::recursive_mutex> _l(m_mutex);
 	uint64 titleId = package->titleId;
@@ -1287,7 +1238,11 @@ bool DownloadManager::asyncPackageInstallRecursiveExtractFiles(Package* package,
 		setPackageError(package, "Internal error");
 		return false;
 	}
-
+	if (fstVolume->HasLinkFlag(dirItr.GetDirHandle()))
+	{
+		cemu_assert_suspicious();
+		return true;
+	}
 	FSTFileHandle itr;
 	while (fstVolume->Next(dirItr, itr))
 	{
@@ -1487,7 +1442,7 @@ void DownloadManager::prepareIDBE(uint64 titleId)
 	if (s_nupFileCache->GetFile({ fmt::format("idbe/{0:016x}", titleId) }, idbeFile) && idbeFile.size() == sizeof(NAPI::IDBEIconDataV0))
 		return addToCache(titleId, (NAPI::IDBEIconDataV0*)(idbeFile.data()));
 	// not cached, query from server
-	std::optional<NAPI::IDBEIconDataV0> iconData = NAPI::IDBE_Request(titleId);
+	std::optional<NAPI::IDBEIconDataV0> iconData = NAPI::IDBE_Request(GetDownloadMgrNetworkService(), titleId);
 	if (!iconData)
 		return;
 	s_nupFileCache->AddFileAsync({ fmt::format("idbe/{0:016x}", titleId) }, (uint8*)&(*iconData), sizeof(NAPI::IDBEIconDataV0));
@@ -1542,7 +1497,7 @@ void DownloadManager::runManager()
 	auto cacheFilePath = ActiveSettings::GetMlcPath("usr/save/system/nim/nup/");
 	fs::create_directories(cacheFilePath);
 	cacheFilePath /= "cemu_cache.dat";
-	s_nupFileCache = FileCache::Open(cacheFilePath.generic_wstring(), true);
+	s_nupFileCache = FileCache::Open(cacheFilePath, true);
 	// launch worker thread
 	std::thread t(&DownloadManager::threadFunc, this);
 	t.detach();
diff --git a/src/Cemu/Tools/DownloadManager/DownloadManager.h b/src/Cemu/Tools/DownloadManager/DownloadManager.h
index fa6749b8..8f693a3e 100644
--- a/src/Cemu/Tools/DownloadManager/DownloadManager.h
+++ b/src/Cemu/Tools/DownloadManager/DownloadManager.h
@@ -2,17 +2,14 @@
 #include "util/helpers/Semaphore.h"
 #include "Cemu/ncrypto/ncrypto.h"
 #include "Cafe/TitleList/TitleId.h"
-
 #include "util/helpers/ConcurrentQueue.h"
+#include "config/NetworkSettings.h"
 
-#include <functional>
-#include <optional>
-
-#include <future>
-
+// forward declarations
 namespace NAPI
 {
 	struct IDBEIconDataV0;
+	struct AuthInfo;
 }
 
 namespace NCrypto
@@ -86,7 +83,6 @@ public:
 
 	bool IsConnected() const;
 
-
 private:
 	/* connect / login */
 	
@@ -101,6 +97,7 @@ private:
 
 	struct 
 	{
+		std::string cachefileName;
 		std::string nnidAccountName;
 		std::array<uint8, 32> passwordHash;
 		std::string deviceCertBase64;
@@ -122,7 +119,10 @@ private:
 	void _handle_connect();
 	bool _connect_refreshIASAccountIdAndDeviceToken();
 	bool _connect_queryAccountStatusAndServiceURLs();
-	
+
+	NetworkService GetDownloadMgrNetworkService();
+	NAPI::AuthInfo GetAuthInfo(bool withIasToken);
+
 	/* idbe cache */
 public:
 	void prepareIDBE(uint64 titleId);
@@ -446,7 +446,7 @@ public:
 		std::unique_lock<std::recursive_mutex> _l(m_mutex);
 		m_packageList.clear();
 		m_statusCode = DLMGR_STATUS_CODE::UNINITIALIZED;
-		m_statusMessage = "";
+		m_statusMessage.clear();
 	}
 
 private:
diff --git a/src/Cemu/napi/napi.h b/src/Cemu/napi/napi.h
index ab17a7b3..e1397d62 100644
--- a/src/Cemu/napi/napi.h
+++ b/src/Cemu/napi/napi.h
@@ -1,6 +1,7 @@
 #pragma once
-#include <optional>
 #include "config/CemuConfig.h" // for ConsoleLanguage
+#include "config/NetworkSettings.h" // for NetworkService
+#include "config/ActiveSettings.h" // for GetNetworkService()
 
 enum class NAPI_RESULT
 {
@@ -16,8 +17,6 @@ namespace NAPI
 	// common auth info structure shared by ACT, ECS and IAS service
 	struct AuthInfo
 	{
-		// todo - constructor for account name + raw password
-
 		// nnid
 		std::string accountId;
 		std::array<uint8, 32> passwordHash;
@@ -41,9 +40,13 @@ namespace NAPI
 			std::string deviceToken;
 		}IASToken;
 
-		// ACT token (for account.nintendo.net requests)
-
+		// service selection, if not set fall back to global setting
+		std::optional<NetworkService> serviceOverwrite;
 
+		NetworkService GetService() const
+		{
+			return serviceOverwrite.value_or(ActiveSettings::GetNetworkService());
+		}
 	};
 
 	bool NAPI_MakeAuthInfoFromCurrentAccount(AuthInfo& authInfo); // helper function. Returns false if online credentials/dumped files are not available
@@ -232,9 +235,9 @@ namespace NAPI
 
 	NAPI_CCSGetTMD_Result CCS_GetTMD(AuthInfo& authInfo, uint64 titleId, uint16 titleVersion);
 	NAPI_CCSGetTMD_Result CCS_GetTMD(AuthInfo& authInfo, uint64 titleId);
-	NAPI_CCSGetETicket_Result CCS_GetCETK(AuthInfo& authInfo, uint64 titleId, uint16 titleVersion);
-	bool CCS_GetContentFile(uint64 titleId, uint32 contentId, bool(*cbWriteCallback)(void* userData, const void* ptr, size_t len, bool isLast), void* userData);
-	NAPI_CCSGetContentH3_Result CCS_GetContentH3File(uint64 titleId, uint32 contentId);
+	NAPI_CCSGetETicket_Result CCS_GetCETK(NetworkService service, uint64 titleId, uint16 titleVersion);
+	bool CCS_GetContentFile(NetworkService service, uint64 titleId, uint32 contentId, bool(*cbWriteCallback)(void* userData, const void* ptr, size_t len, bool isLast), void* userData);
+	NAPI_CCSGetContentH3_Result CCS_GetContentH3File(NetworkService service, uint64 titleId, uint32 contentId);
 
 	/* IDBE */
 
@@ -286,8 +289,8 @@ namespace NAPI
 
 	static_assert(sizeof(IDBEHeader) == 2+32);
 
-	std::optional<IDBEIconDataV0> IDBE_Request(uint64 titleId);
-	std::vector<uint8> IDBE_RequestRawEncrypted(uint64 titleId); // same as IDBE_Request but doesn't strip the header and decrypt the IDBE
+	std::optional<IDBEIconDataV0> IDBE_Request(NetworkService networkService, uint64 titleId);
+	std::vector<uint8> IDBE_RequestRawEncrypted(NetworkService networkService, uint64 titleId); // same as IDBE_Request but doesn't strip the header and decrypt the IDBE
 
 	/* Version list */
 
diff --git a/src/Cemu/napi/napi_act.cpp b/src/Cemu/napi/napi_act.cpp
index b9a9c16c..c72d9f47 100644
--- a/src/Cemu/napi/napi_act.cpp
+++ b/src/Cemu/napi/napi_act.cpp
@@ -14,6 +14,21 @@
 
 namespace NAPI
 {
+	std::string _getACTUrl(NetworkService service)
+	{
+		switch (service)
+		{
+		case NetworkService::Nintendo:
+			return NintendoURLs::ACTURL;
+		case NetworkService::Pretendo:
+			return PretendoURLs::ACTURL;
+		case NetworkService::Custom:
+			return GetNetworkConfig().urls.ACT.GetValue();
+		default:
+			return NintendoURLs::ACTURL;
+		}
+	}
+
 	struct ACTOauthToken : public _NAPI_CommonResultACT
 	{
 		std::string token;
@@ -40,16 +55,16 @@ namespace NAPI
 				sint32 errorCode = StringHelpers::ToInt(errorCodeStr);
 				if (errorCode == 0)
 				{
-					cemuLog_force("Account response with unexpected error code 0");
+					cemuLog_log(LogType::Force, "Account response with unexpected error code 0");
 					result.apiError = NAPI_RESULT::XML_ERROR;
 				}
 				else
 				{
 					result.apiError = NAPI_RESULT::SERVICE_ERROR;
 					result.serviceError = (ACT_ERROR_CODE)errorCode;
-					cemuLog_force("Account response with error code {}", errorCode);
+					cemuLog_log(LogType::Force, "Account response with error code {}", errorCode);
 					if(!errorCodeMsg.empty())
-						cemuLog_force("Message from server: {}", errorCodeMsg);
+						cemuLog_log(LogType::Force, "Message from server: {}", errorCodeMsg);
 				}
 			}
 			else
@@ -91,7 +106,7 @@ namespace NAPI
 
 	struct OAuthTokenCacheEntry 
 	{
-		OAuthTokenCacheEntry(std::string_view accountId, std::array<uint8, 32>& passwordHash, std::string_view token, std::string_view refreshToken, uint64 expiresIn) : accountId(accountId), passwordHash(passwordHash), token(token), refreshToken(refreshToken)
+		OAuthTokenCacheEntry(std::string_view accountId, std::array<uint8, 32>& passwordHash, std::string_view token, std::string_view refreshToken, uint64 expiresIn, NetworkService service) : accountId(accountId), passwordHash(passwordHash), token(token), refreshToken(refreshToken), service(service)
 		{
 			expires = HighResolutionTimer::now().getTickInSeconds() + expiresIn;
 		};
@@ -107,10 +122,10 @@ namespace NAPI
 		}
 		std::string accountId;
 		std::array<uint8, 32> passwordHash;
-
 		std::string token;
 		std::string refreshToken;
 		uint64 expires;
+		NetworkService service;
 	};
 
 	std::vector<OAuthTokenCacheEntry> g_oauthTokenCache;
@@ -122,11 +137,12 @@ namespace NAPI
 		ACTOauthToken result{};
 		
 		// check cache first
+		NetworkService service = authInfo.GetService();
 		g_oauthTokenCacheMtx.lock();
 		auto cacheItr = g_oauthTokenCache.begin();
 		while (cacheItr != g_oauthTokenCache.end())
 		{
-			if (cacheItr->CheckIfSameAccount(authInfo))
+			if (cacheItr->CheckIfSameAccount(authInfo) && cacheItr->service == service)
 			{
 				if (cacheItr->CheckIfExpired())
 				{
@@ -145,7 +161,7 @@ namespace NAPI
 		// token not cached, request from server via oauth2
 		CurlRequestHelper req;
 
-		req.initate(fmt::format("{}/v1/api/oauth20/access_token/generate", LaunchSettings::GetActURLPrefix()), CurlRequestHelper::SERVER_SSL_CONTEXT::ACT);
+		req.initate(authInfo.GetService(), fmt::format("{}/v1/api/oauth20/access_token/generate", _getACTUrl(authInfo.GetService())), CurlRequestHelper::SERVER_SSL_CONTEXT::ACT);
 		_ACTSetCommonHeaderParameters(req, authInfo);
 		_ACTSetDeviceParameters(req, authInfo);
 		_ACTSetRegionAndCountryParameters(req, authInfo);
@@ -212,7 +228,7 @@ namespace NAPI
 		result.apiError = NAPI_RESULT::SUCCESS;
 
 		if (result.token.empty())
-			cemuLog_force("OAuth20/token is empty");
+			cemuLog_log(LogType::Force, "OAuth20/token is empty");
 		sint64 expiration = StringHelpers::ToInt64(expires_in);
 		expiration = std::max(expiration - 30LL, 0LL); // subtract a few seconds to compensate for the web request delay
 
@@ -220,7 +236,7 @@ namespace NAPI
 		if (expiration > 0)
 		{
 			g_oauthTokenCacheMtx.lock();
-			g_oauthTokenCache.emplace_back(authInfo.accountId, authInfo.passwordHash, result.token, result.refreshToken, expiration);
+			g_oauthTokenCache.emplace_back(authInfo.accountId, authInfo.passwordHash, result.token, result.refreshToken, expiration, service);
 			g_oauthTokenCacheMtx.unlock();
 		}
 		return result;
@@ -230,14 +246,13 @@ namespace NAPI
 	{
 		CurlRequestHelper req;
 
-		req.initate(fmt::format("{}/v1/api/people/@me/profile", LaunchSettings::GetActURLPrefix()), CurlRequestHelper::SERVER_SSL_CONTEXT::ACT);
+		req.initate(authInfo.GetService(), fmt::format("{}/v1/api/people/@me/profile", _getACTUrl(authInfo.GetService())), CurlRequestHelper::SERVER_SSL_CONTEXT::ACT);
 
 		_ACTSetCommonHeaderParameters(req, authInfo);
 		_ACTSetDeviceParameters(req, authInfo);
 
 		// get oauth2 token
 		ACTOauthToken oauthToken = ACT_GetOauthToken_WithCache(authInfo, 0x0005001010001C00, 0x0001C);
-		
 
 		cemu_assert_unimplemented();
 		return true;
@@ -245,15 +260,16 @@ namespace NAPI
 
 	struct NexTokenCacheEntry
 	{
-		NexTokenCacheEntry(std::string_view accountId, std::array<uint8, 32>& passwordHash, uint32 gameServerId, ACTNexToken& nexToken) : accountId(accountId), passwordHash(passwordHash), nexToken(nexToken), gameServerId(gameServerId) {};
+		NexTokenCacheEntry(std::string_view accountId, std::array<uint8, 32>& passwordHash, NetworkService networkService, uint32 gameServerId, ACTNexToken& nexToken) : accountId(accountId), passwordHash(passwordHash), networkService(networkService), nexToken(nexToken), gameServerId(gameServerId) {};
 
 		bool IsMatch(const AuthInfo& authInfo, const uint32 gameServerId) const
 		{
-			return authInfo.accountId == accountId && authInfo.passwordHash == passwordHash && this->gameServerId == gameServerId;
+			return authInfo.accountId == accountId && authInfo.passwordHash == passwordHash && authInfo.GetService() == networkService && this->gameServerId == gameServerId;
 		}
 
 		std::string accountId;
 		std::array<uint8, 32> passwordHash;
+		NetworkService networkService;
 		uint32 gameServerId;
 
 		ACTNexToken nexToken;
@@ -283,7 +299,7 @@ namespace NAPI
 		ACTOauthToken oauthToken = ACT_GetOauthToken_WithCache(authInfo, titleId, titleVersion);
 		if (!oauthToken.isValid())
 		{
-			cemuLog_force("ACT_GetNexToken(): Failed to retrieve OAuth token");
+			cemuLog_log(LogType::Force, "ACT_GetNexToken(): Failed to retrieve OAuth token");
 			if (oauthToken.apiError == NAPI_RESULT::SERVICE_ERROR)
 			{
 				result.apiError = NAPI_RESULT::SERVICE_ERROR;
@@ -297,7 +313,7 @@ namespace NAPI
 		}
 		// do request
 		CurlRequestHelper req;
-		req.initate(fmt::format("{}/v1/api/provider/nex_token/@me?game_server_id={:08X}", LaunchSettings::GetActURLPrefix(), serverId), CurlRequestHelper::SERVER_SSL_CONTEXT::ACT);
+		req.initate(authInfo.GetService(), fmt::format("{}/v1/api/provider/nex_token/@me?game_server_id={:08X}", _getACTUrl(authInfo.GetService()), serverId), CurlRequestHelper::SERVER_SSL_CONTEXT::ACT);
 		_ACTSetCommonHeaderParameters(req, authInfo);
 		_ACTSetDeviceParameters(req, authInfo);
 		_ACTSetRegionAndCountryParameters(req, authInfo);
@@ -348,24 +364,23 @@ namespace NAPI
 		pugi::xml_node tokenNode = doc.child("nex_token");
 		if (!tokenNode)
 		{
-			cemuLog_force("Response does not contain NexToken node");
+			cemuLog_log(LogType::Force, "Response does not contain NexToken node");
 			result.apiError = NAPI_RESULT::XML_ERROR;
 			return result;
 		}
 
 		std::string_view host = tokenNode.child_value("host");
 		std::string_view nex_password = tokenNode.child_value("nex_password");
-		std::string_view pid = tokenNode.child_value("pid");
 		std::string_view port = tokenNode.child_value("port");
 		std::string_view token = tokenNode.child_value("token");
 
-		std::memset(&result.nexToken, 0, sizeof(result.nexToken));
+		memset(&result.nexToken, 0, sizeof(ACTNexToken));
 		if (host.size() > 15)
-			cemuLog_force("NexToken response: host field too long");
+			cemuLog_log(LogType::Force, "NexToken response: host field too long");
 		if (nex_password.size() > 64)
-			cemuLog_force("NexToken response: nex_password field too long");
+			cemuLog_log(LogType::Force, "NexToken response: nex_password field too long");
 		if (token.size() > 512)
-			cemuLog_force("NexToken response: token field too long");
+			cemuLog_log(LogType::Force, "NexToken response: token field too long");
 		for (size_t i = 0; i < std::min(host.size(), (size_t)15); i++)
 			result.nexToken.host[i] = host[i];
 		for (size_t i = 0; i < std::min(nex_password.size(), (size_t)64); i++)
@@ -375,21 +390,21 @@ namespace NAPI
 		result.nexToken.port = (uint16)StringHelpers::ToInt(port);
 		result.apiError = NAPI_RESULT::SUCCESS;
 		g_nexTokenCacheMtx.lock();
-		g_nexTokenCache.emplace_back(authInfo.accountId, authInfo.passwordHash, serverId, result.nexToken);
+		g_nexTokenCache.emplace_back(authInfo.accountId, authInfo.passwordHash, authInfo.GetService(), serverId, result.nexToken);
 		g_nexTokenCacheMtx.unlock();
 		return result;
 	}
 
 	struct IndependentTokenCacheEntry
 	{
-		IndependentTokenCacheEntry(std::string_view accountId, std::array<uint8, 32>& passwordHash, std::string_view clientId, std::string_view independentToken, sint64 expiresIn) : accountId(accountId), passwordHash(passwordHash), clientId(clientId), independentToken(independentToken)
+		IndependentTokenCacheEntry(std::string_view accountId, std::array<uint8, 32>& passwordHash, NetworkService networkService, std::string_view clientId, std::string_view independentToken, sint64 expiresIn) : accountId(accountId), passwordHash(passwordHash), networkService(networkService), clientId(clientId), independentToken(independentToken)
 		{
 			expires = HighResolutionTimer::now().getTickInSeconds() + expiresIn;
 		};
 
 		bool IsMatch(const AuthInfo& authInfo, const std::string_view clientId) const
 		{
-			return authInfo.accountId == accountId && authInfo.passwordHash == passwordHash && this->clientId == clientId;
+			return authInfo.accountId == accountId && authInfo.passwordHash == passwordHash && authInfo.GetService() == networkService && this->clientId == clientId;
 		}
 
 		bool CheckIfExpired() const
@@ -399,6 +414,7 @@ namespace NAPI
 
 		std::string accountId;
 		std::array<uint8, 32> passwordHash;
+		NetworkService networkService;
 		std::string clientId;
 		sint64 expires;
 
@@ -436,7 +452,7 @@ namespace NAPI
 		ACTOauthToken oauthToken = ACT_GetOauthToken_WithCache(authInfo, titleId, titleVersion);
 		if (!oauthToken.isValid())
 		{
-			cemuLog_force("ACT_GetIndependentToken(): Failed to retrieve OAuth token");
+			cemuLog_log(LogType::Force, "ACT_GetIndependentToken(): Failed to retrieve OAuth token");
 			if (oauthToken.apiError == NAPI_RESULT::SERVICE_ERROR)
 			{
 				result.apiError = NAPI_RESULT::SERVICE_ERROR;
@@ -450,7 +466,7 @@ namespace NAPI
 		}
 		// do request
 		CurlRequestHelper req;
-		req.initate(fmt::format("{}/v1/api/provider/service_token/@me?client_id={}", LaunchSettings::GetActURLPrefix(), clientId), CurlRequestHelper::SERVER_SSL_CONTEXT::ACT);
+		req.initate(authInfo.GetService(), fmt::format("{}/v1/api/provider/service_token/@me?client_id={}", _getACTUrl(authInfo.GetService()), clientId), CurlRequestHelper::SERVER_SSL_CONTEXT::ACT);
 		_ACTSetCommonHeaderParameters(req, authInfo);
 		_ACTSetDeviceParameters(req, authInfo);
 		_ACTSetRegionAndCountryParameters(req, authInfo);
@@ -485,7 +501,7 @@ namespace NAPI
 		pugi::xml_node tokenNode = doc.child("service_token");
 		if (!tokenNode)
 		{
-			cemuLog_force("Response does not contain service_token node");
+			cemuLog_log(LogType::Force, "Response does not contain service_token node");
 			result.apiError = NAPI_RESULT::XML_ERROR;
 			return result;
 		}
@@ -495,7 +511,7 @@ namespace NAPI
 		result.apiError = NAPI_RESULT::SUCCESS;
 
 		g_IndependentTokenCacheMtx.lock();
-		g_IndependentTokenCache.emplace_back(authInfo.accountId, authInfo.passwordHash, clientId, result.token, 3600);
+		g_IndependentTokenCache.emplace_back(authInfo.accountId, authInfo.passwordHash, authInfo.GetService(), clientId, result.token, 3600);
 		g_IndependentTokenCacheMtx.unlock();
 		return result;
 	}
@@ -507,7 +523,7 @@ namespace NAPI
 		ACTOauthToken oauthToken = ACT_GetOauthToken_WithCache(authInfo, 0x0005001010001C00, 0);
 		if (!oauthToken.isValid())
 		{
-			cemuLog_force("ACT_ACTConvertNnidToPrincipalId(): Failed to retrieve OAuth token");
+			cemuLog_log(LogType::Force, "ACT_ACTConvertNnidToPrincipalId(): Failed to retrieve OAuth token");
 			if (oauthToken.apiError == NAPI_RESULT::SERVICE_ERROR)
 			{
 				result.apiError = NAPI_RESULT::SERVICE_ERROR;
@@ -521,7 +537,7 @@ namespace NAPI
 		}
 		// do request
 		CurlRequestHelper req;
-		req.initate(fmt::format("{}/v1/api/admin/mapped_ids?input_type=user_id&output_type=pid&input={}", LaunchSettings::GetActURLPrefix(), nnid), CurlRequestHelper::SERVER_SSL_CONTEXT::ACT);
+		req.initate(authInfo.GetService(), fmt::format("{}/v1/api/admin/mapped_ids?input_type=user_id&output_type=pid&input={}", _getACTUrl(authInfo.GetService()), nnid), CurlRequestHelper::SERVER_SSL_CONTEXT::ACT);
 		_ACTSetCommonHeaderParameters(req, authInfo);
 		_ACTSetDeviceParameters(req, authInfo);
 		_ACTSetRegionAndCountryParameters(req, authInfo);
@@ -559,14 +575,14 @@ namespace NAPI
 		pugi::xml_node tokenNode = doc.child("mapped_ids");
 		if (!tokenNode)
 		{
-			cemuLog_force("Response does not contain mapped_ids node");
+			cemuLog_log(LogType::Force, "Response does not contain mapped_ids node");
 			result.apiError = NAPI_RESULT::XML_ERROR;
 			return result;
 		}
 		tokenNode = tokenNode.child("mapped_id");
 		if (!tokenNode)
 		{
-			cemuLog_force("Response does not contain mapped_id node");
+			cemuLog_log(LogType::Force, "Response does not contain mapped_id node");
 			result.apiError = NAPI_RESULT::XML_ERROR;
 			return result;
 		}
@@ -599,7 +615,7 @@ namespace NAPI
 			static bool s_showedLoginError = false;
 			if (!s_showedLoginError)
 			{
-				cemuLog_force("Account login is impossible because the cached password hash is not set");
+				cemuLog_log(LogType::Force, "Account login is impossible because the cached password hash is not set");
 				s_showedLoginError = true;
 			}
 			return false; // password hash not set
diff --git a/src/Cemu/napi/napi_ec.cpp b/src/Cemu/napi/napi_ec.cpp
index 82ab5be4..2c0812e4 100644
--- a/src/Cemu/napi/napi_ec.cpp
+++ b/src/Cemu/napi/napi_ec.cpp
@@ -8,54 +8,120 @@
 #include "Cemu/ncrypto/ncrypto.h"
 #include "util/crypto/md5.h"
 #include "config/LaunchSettings.h"
-
+#include "config/ActiveSettings.h"
+#include "config/NetworkSettings.h"
 #include "pugixml.hpp"
 #include <charconv>
 
 namespace NAPI
 {
 	/* Service URL manager */
-	std::string s_serviceURL_ContentPrefixURL;
-	std::string s_serviceURL_UncachedContentPrefixURL;
-	std::string s_serviceURL_EcsURL;
-	std::string s_serviceURL_IasURL;
-	std::string s_serviceURL_CasURL;
-	std::string s_serviceURL_NusURL;
-
-	std::string _getNUSUrl()
+	struct CachedServiceUrls
 	{
-		if (!s_serviceURL_NusURL.empty())
-			return s_serviceURL_NusURL;
-		return "https://nus.wup.shop.nintendo.net/nus/services/NetUpdateSOAP";
+		std::string s_serviceURL_ContentPrefixURL;
+		std::string s_serviceURL_UncachedContentPrefixURL;
+		std::string s_serviceURL_EcsURL;
+		std::string s_serviceURL_IasURL;
+		std::string s_serviceURL_CasURL;
+		std::string s_serviceURL_NusURL;
+	};
+
+	std::unordered_map<NetworkService, CachedServiceUrls> s_cachedServiceUrlsMap;
+
+	CachedServiceUrls& GetCachedServiceUrls(NetworkService service)
+	{
+		return s_cachedServiceUrlsMap[service];
 	}
 
-	std::string _getIASUrl()
+	std::string _getNUSUrl(NetworkService service)
 	{
-		if (!s_serviceURL_IasURL.empty())
-			return s_serviceURL_IasURL;
-		return "https://ias.wup.shop.nintendo.net/ias/services/IdentityAuthenticationSOAP";
+		auto& cachedServiceUrls = GetCachedServiceUrls(service);
+		if (!cachedServiceUrls.s_serviceURL_NusURL.empty())
+			return cachedServiceUrls.s_serviceURL_NusURL;
+		switch (service)
+		{
+		case NetworkService::Nintendo:
+			return NintendoURLs::NUSURL;
+		case NetworkService::Pretendo:
+			return PretendoURLs::NUSURL;
+		case NetworkService::Custom:
+			return GetNetworkConfig().urls.NUS;
+		default:
+			return NintendoURLs::NUSURL;
+		}
 	}
 
-	std::string _getECSUrl()
+	std::string _getIASUrl(NetworkService service)
+	{
+		auto& cachedServiceUrls = GetCachedServiceUrls(service);
+		if (!cachedServiceUrls.s_serviceURL_IasURL.empty())
+			return cachedServiceUrls.s_serviceURL_IasURL;
+		switch (service)
+		{
+		case NetworkService::Nintendo:
+			return NintendoURLs::IASURL;
+		case NetworkService::Pretendo:
+			return PretendoURLs::IASURL;
+		case NetworkService::Custom:
+			return GetNetworkConfig().urls.IAS;
+		default:
+			return NintendoURLs::IASURL;
+		}
+	}
+
+	std::string _getECSUrl(NetworkService service)
 	{
 		// this is the first url queried (GetAccountStatus). The others are dynamically set if provided by the server but will fallback to hardcoded defaults otherwise
-		if (!s_serviceURL_EcsURL.empty())
-			return s_serviceURL_EcsURL;
-		return LaunchSettings::GetServiceURL_ecs(); // by default this is "https://ecs.wup.shop.nintendo.net/ecs/services/ECommerceSOAP"
+		auto& cachedServiceUrls = GetCachedServiceUrls(service);
+		if (!cachedServiceUrls.s_serviceURL_EcsURL.empty())
+			return cachedServiceUrls.s_serviceURL_EcsURL;
+		switch (service)
+		{
+		case NetworkService::Nintendo:
+			return NintendoURLs::ECSURL;
+		case NetworkService::Pretendo:
+			return PretendoURLs::ECSURL;
+		case NetworkService::Custom:
+			return GetNetworkConfig().urls.ECS;
+		default:
+			return NintendoURLs::ECSURL;
+		}
 	}
 
-	std::string _getCCSUncachedUrl() // used for TMD requests
+	std::string _getCCSUncachedUrl(NetworkService service) // used for TMD requests
 	{
-		if (!s_serviceURL_UncachedContentPrefixURL.empty())
-			return s_serviceURL_UncachedContentPrefixURL;
-		return "https://ccs.wup.shop.nintendo.net/ccs/download";
+		auto& cachedServiceUrls = GetCachedServiceUrls(service);
+		if (!cachedServiceUrls.s_serviceURL_UncachedContentPrefixURL.empty())
+			return cachedServiceUrls.s_serviceURL_UncachedContentPrefixURL;
+		switch (service)
+		{
+		case NetworkService::Nintendo:
+			return NintendoURLs::CCSUURL;
+		case NetworkService::Pretendo:
+			return PretendoURLs::CCSUURL;
+		case NetworkService::Custom:
+			return GetNetworkConfig().urls.CCSU;
+		default:
+			return NintendoURLs::CCSUURL;
+		}
 	}
 
-	std::string _getCCSUrl() // used for game data downloads
+	std::string _getCCSUrl(NetworkService service) // used for game data downloads
 	{
-		if (!s_serviceURL_ContentPrefixURL.empty())
-			return s_serviceURL_ContentPrefixURL;
-		return "http://ccs.cdn.wup.shop.nintendo.net/ccs/download";
+		auto& cachedServiceUrls = GetCachedServiceUrls(service);
+		if (!cachedServiceUrls.s_serviceURL_ContentPrefixURL.empty())
+			return cachedServiceUrls.s_serviceURL_ContentPrefixURL;
+		switch (service)
+		{
+		case NetworkService::Nintendo:
+			return NintendoURLs::CCSURL;
+		case NetworkService::Pretendo:
+			return PretendoURLs::CCSURL;
+		case NetworkService::Custom:
+			return GetNetworkConfig().urls.CCS;
+		default:
+			return NintendoURLs::CCSURL;
+		}
 	}
 
 	/* NUS */
@@ -65,8 +131,8 @@ namespace NAPI
 	{
 		NAPI_NUSGetSystemCommonETicket_Result result{};
 
-		CurlSOAPHelper soapHelper;
-		soapHelper.SOAP_initate("nus", _getNUSUrl(), "GetSystemCommonETicket", "1.0");
+		CurlSOAPHelper soapHelper(authInfo.GetService());
+		soapHelper.SOAP_initate("nus", _getNUSUrl(authInfo.GetService()), "GetSystemCommonETicket", "1.0");
 
 		soapHelper.SOAP_addRequestField("DeviceId", fmt::format("{}", authInfo.getDeviceIdWithPlatform()));
 		soapHelper.SOAP_addRequestField("RegionId", NCrypto::GetRegionAsString(authInfo.region));
@@ -118,8 +184,8 @@ namespace NAPI
 	{
 		NAPI_IASGetChallenge_Result result{};
 		
-		CurlSOAPHelper soapHelper;
-		soapHelper.SOAP_initate("ias", _getIASUrl(), "GetChallenge", "2.0");
+		CurlSOAPHelper soapHelper(authInfo.GetService());
+		soapHelper.SOAP_initate("ias", _getIASUrl(authInfo.GetService()), "GetChallenge", "2.0");
 
 		soapHelper.SOAP_addRequestField("DeviceId", fmt::format("{}", authInfo.getDeviceIdWithPlatform())); // not validated but the generated Challenge is bound to this DeviceId
 		soapHelper.SOAP_addRequestField("Region", NCrypto::GetRegionAsString(authInfo.region));
@@ -143,8 +209,8 @@ namespace NAPI
 	NAPI_IASGetRegistrationInfo_Result IAS_GetRegistrationInfo_QueryInfo(AuthInfo& authInfo, std::string challenge)
 	{
 		NAPI_IASGetRegistrationInfo_Result result;
-		CurlSOAPHelper soapHelper;
-		soapHelper.SOAP_initate("ias", _getIASUrl(), "GetRegistrationInfo", "2.0");
+		CurlSOAPHelper soapHelper(authInfo.GetService());
+		soapHelper.SOAP_initate("ias", _getIASUrl(authInfo.GetService()), "GetRegistrationInfo", "2.0");
 
 		soapHelper.SOAP_addRequestField("DeviceId", fmt::format("{}", authInfo.getDeviceIdWithPlatform())); // this must match the DeviceId used to generate Challenge
 		soapHelper.SOAP_addRequestField("Region", NCrypto::GetRegionAsString(authInfo.region));
@@ -196,7 +262,7 @@ namespace NAPI
 		result.deviceToken = responseNode.child_value("DeviceToken");
 
 		if (boost::iequals(responseNode.child_value("DeviceTokenExpired"), "true"))
-			forceLog_printf("Unexpected server response: Device token expired");
+			cemuLog_log(LogType::Force, "Unexpected server response: Device token expired");
 
 		/*
 			example response:
@@ -244,8 +310,8 @@ namespace NAPI
 	{
 		NAPI_ECSGetAccountStatus_Result result{};
 
-		CurlSOAPHelper soapHelper;
-		soapHelper.SOAP_initate("ecs", _getECSUrl(), "GetAccountStatus", "2.0");
+		CurlSOAPHelper soapHelper(authInfo.GetService());
+		soapHelper.SOAP_initate("ecs", _getECSUrl(authInfo.GetService()), "GetAccountStatus", "2.0");
 
 		soapHelper.SOAP_addRequestField("DeviceId", fmt::format("{}", authInfo.getDeviceIdWithPlatform()));
 		soapHelper.SOAP_addRequestField("Region", NCrypto::GetRegionAsString(authInfo.region));
@@ -279,7 +345,7 @@ namespace NAPI
 				result.accountStatus = NAPI_ECSGetAccountStatus_Result::AccountStatus::UNREGISTERED;
 			else
 			{
-				cemuLog_force("ECS_GetAccountStatus: Account has unknown status code {}", accountStatusStr);
+				cemuLog_log(LogType::Force, "ECS_GetAccountStatus: Account has unknown status code {}", accountStatusStr);
 			}
 		}
 		// extract service URLs
@@ -306,23 +372,23 @@ namespace NAPI
 			else if (boost::iequals(serviceType, "NusURL"))
 				result.serviceURLs.NusURL = url;
 			else
-				forceLog_printf("GetAccountStatus: Unknown service URI type {}", serviceType);
+				cemuLog_log(LogType::Force, "GetAccountStatus: Unknown service URI type {}", serviceType);
 		}
 
 		// assign service URLs
+		auto& cachedServiceUrls = GetCachedServiceUrls(authInfo.GetService());
 		if (!result.serviceURLs.ContentPrefixURL.empty())
-			s_serviceURL_ContentPrefixURL = result.serviceURLs.ContentPrefixURL;
+			cachedServiceUrls.s_serviceURL_ContentPrefixURL = result.serviceURLs.ContentPrefixURL;
 		if (!result.serviceURLs.UncachedContentPrefixURL.empty())
-			s_serviceURL_UncachedContentPrefixURL = result.serviceURLs.UncachedContentPrefixURL;
+			cachedServiceUrls.s_serviceURL_UncachedContentPrefixURL = result.serviceURLs.UncachedContentPrefixURL;
 		if (!result.serviceURLs.IasURL.empty())
-			s_serviceURL_IasURL = result.serviceURLs.IasURL;
+			cachedServiceUrls.s_serviceURL_IasURL = result.serviceURLs.IasURL;
 		if (!result.serviceURLs.CasURL.empty())
-			s_serviceURL_CasURL = result.serviceURLs.CasURL;
+			cachedServiceUrls.s_serviceURL_CasURL = result.serviceURLs.CasURL;
 		if (!result.serviceURLs.NusURL.empty())
-			s_serviceURL_NusURL = result.serviceURLs.NusURL;
+			cachedServiceUrls.s_serviceURL_NusURL = result.serviceURLs.NusURL;
 		if (!result.serviceURLs.EcsURL.empty())
-			s_serviceURL_EcsURL = result.serviceURLs.EcsURL;
-
+			cachedServiceUrls.s_serviceURL_EcsURL = result.serviceURLs.EcsURL;
 		return result;
 	}
 
@@ -330,8 +396,8 @@ namespace NAPI
 	{
 		NAPI_ECSAccountListETicketIds_Result result{};
 
-		CurlSOAPHelper soapHelper;
-		soapHelper.SOAP_initate("ecs", _getECSUrl(), "AccountListETicketIds", "2.0");
+		CurlSOAPHelper soapHelper(authInfo.GetService());
+		soapHelper.SOAP_initate("ecs", _getECSUrl(authInfo.GetService()), "AccountListETicketIds", "2.0");
 
 		soapHelper.SOAP_addRequestField("DeviceId", fmt::format("{}", authInfo.getDeviceIdWithPlatform()));
 		soapHelper.SOAP_addRequestField("Region", NCrypto::GetRegionAsString(authInfo.region));
@@ -360,7 +426,7 @@ namespace NAPI
 			// ticketVersion starts at 0 and increments every time the ticket is updated (e.g. for AOC content, when purchasing additional DLC packages)
 			const char* tivValue = tivNode.child_value();
 			const char* tivValueEnd = tivValue + strlen(tivValue);
-			const char* tivValueSeparator = std::strstr(tivValue, ".");
+			const char* tivValueSeparator = std::strchr(tivValue, '.');
 			if (tivValueSeparator == nullptr)
 				tivValueSeparator = tivValueEnd;
 
@@ -389,8 +455,8 @@ namespace NAPI
 	{
 		NAPI_ECSAccountGetETickets_Result result{};
 
-		CurlSOAPHelper soapHelper;
-		soapHelper.SOAP_initate("ecs", _getECSUrl(), "AccountGetETickets", "2.0");
+		CurlSOAPHelper soapHelper(authInfo.GetService());
+		soapHelper.SOAP_initate("ecs", _getECSUrl(authInfo.GetService()), "AccountGetETickets", "2.0");
 
 		soapHelper.SOAP_addRequestField("DeviceId", fmt::format("{}", authInfo.getDeviceIdWithPlatform()));
 		soapHelper.SOAP_addRequestField("Region", NCrypto::GetRegionAsString(authInfo.region));
@@ -455,7 +521,7 @@ namespace NAPI
 	{
 		NAPI_CCSGetTMD_Result result{};
 		CurlRequestHelper req;
-		req.initate(fmt::format("{}/{:016x}/tmd.{}?deviceId={}&accountId={}", _getCCSUncachedUrl(), titleId, titleVersion, authInfo.getDeviceIdWithPlatform(), authInfo.IASToken.accountId), CurlRequestHelper::SERVER_SSL_CONTEXT::CCS);
+		req.initate(authInfo.GetService(), fmt::format("{}/{:016x}/tmd.{}?deviceId={}&accountId={}", _getCCSUncachedUrl(authInfo.GetService()), titleId, titleVersion, authInfo.getDeviceIdWithPlatform(), authInfo.IASToken.accountId), CurlRequestHelper::SERVER_SSL_CONTEXT::CCS);
 		req.setTimeout(180);
 		if (!req.submitRequest(false))
 		{
@@ -471,7 +537,7 @@ namespace NAPI
 	{
 		NAPI_CCSGetTMD_Result result{};
 		CurlRequestHelper req;
-		req.initate(fmt::format("{}/{:016x}/tmd?deviceId={}&accountId={}", _getCCSUncachedUrl(), titleId, authInfo.getDeviceIdWithPlatform(), authInfo.IASToken.accountId), CurlRequestHelper::SERVER_SSL_CONTEXT::CCS);
+		req.initate(authInfo.GetService(), fmt::format("{}/{:016x}/tmd?deviceId={}&accountId={}", _getCCSUncachedUrl(authInfo.GetService()), titleId, authInfo.getDeviceIdWithPlatform(), authInfo.IASToken.accountId), CurlRequestHelper::SERVER_SSL_CONTEXT::CCS);
 		req.setTimeout(180);
 		if (!req.submitRequest(false))
 		{
@@ -483,11 +549,11 @@ namespace NAPI
 		return result;
 	}
 
-	NAPI_CCSGetETicket_Result CCS_GetCETK(AuthInfo& authInfo, uint64 titleId, uint16 titleVersion)
+	NAPI_CCSGetETicket_Result CCS_GetCETK(NetworkService service, uint64 titleId, uint16 titleVersion)
 	{
 		NAPI_CCSGetETicket_Result result{};
 		CurlRequestHelper req;
-		req.initate(fmt::format("{}/{:016x}/cetk", _getCCSUncachedUrl(), titleId), CurlRequestHelper::SERVER_SSL_CONTEXT::CCS);
+		req.initate(service, fmt::format("{}/{:016x}/cetk", _getCCSUncachedUrl(service), titleId), CurlRequestHelper::SERVER_SSL_CONTEXT::CCS);
 		req.setTimeout(180);
 		if (!req.submitRequest(false))
 		{
@@ -499,10 +565,10 @@ namespace NAPI
 		return result;
 	}
 
-	bool CCS_GetContentFile(uint64 titleId, uint32 contentId, bool(*cbWriteCallback)(void* userData, const void* ptr, size_t len, bool isLast), void* userData)
+	bool CCS_GetContentFile(NetworkService service, uint64 titleId, uint32 contentId, bool(*cbWriteCallback)(void* userData, const void* ptr, size_t len, bool isLast), void* userData)
 	{
 		CurlRequestHelper req;
-		req.initate(fmt::format("{}/{:016x}/{:08x}", _getCCSUrl(), titleId, contentId), CurlRequestHelper::SERVER_SSL_CONTEXT::CCS);
+		req.initate(service, fmt::format("{}/{:016x}/{:08x}", _getCCSUrl(service), titleId, contentId), CurlRequestHelper::SERVER_SSL_CONTEXT::CCS);
 		req.setWriteCallback(cbWriteCallback, userData);
 		req.setTimeout(0);
 		if (!req.submitRequest(false))
@@ -513,11 +579,11 @@ namespace NAPI
 		return true;
 	}
 
-	NAPI_CCSGetContentH3_Result CCS_GetContentH3File(uint64 titleId, uint32 contentId)
+	NAPI_CCSGetContentH3_Result CCS_GetContentH3File(NetworkService service, uint64 titleId, uint32 contentId)
 	{
 		NAPI_CCSGetContentH3_Result result{};
 		CurlRequestHelper req;
-		req.initate(fmt::format("{}/{:016x}/{:08x}.h3", _getCCSUrl(), titleId, contentId), CurlRequestHelper::SERVER_SSL_CONTEXT::CCS);
+		req.initate(service, fmt::format("{}/{:016x}/{:08x}.h3", _getCCSUrl(service), titleId, contentId), CurlRequestHelper::SERVER_SSL_CONTEXT::CCS);
 		if (!req.submitRequest(false))
 		{
 			cemuLog_log(LogType::Force, fmt::format("Failed to request content hash file {:08x}.h3 for title {:016X}", contentId, titleId));
diff --git a/src/Cemu/napi/napi_helper.cpp b/src/Cemu/napi/napi_helper.cpp
index 188c8840..182c5371 100644
--- a/src/Cemu/napi/napi_helper.cpp
+++ b/src/Cemu/napi/napi_helper.cpp
@@ -7,7 +7,9 @@
 #include "Cemu/ncrypto/ncrypto.h"
 #include "napi_helper.h"
 #include "util/highresolutiontimer/HighResolutionTimer.h"
-
+#include "config/ActiveSettings.h"
+#include "config/NetworkSettings.h"
+#include "config/LaunchSettings.h"
 #include "pugixml.hpp"
 #include <charconv>
 
@@ -19,16 +21,16 @@ CURLcode _sslctx_function_NUS(CURL* curl, void* sslctx, void* param)
 {
 	if (iosuCrypto_addCACertificate(sslctx, 102) == false)
 	{
-		forceLog_printf("Invalid CA certificate (102)");
+		cemuLog_log(LogType::Force, "Invalid CA certificate (102)");
 	}
 	if (iosuCrypto_addCACertificate(sslctx, 0x69) == false)
 	{
-		forceLog_printf("Invalid CA certificate (105)");
+		cemuLog_log(LogType::Force, "Invalid CA certificate (105)");
 	}
 
 	if (iosuCrypto_addClientCertificate(sslctx, 3) == false)
 	{
-		forceLog_printf("Certificate error");
+		cemuLog_log(LogType::Force, "Certificate error");
 	}
 	SSL_CTX_set_mode((SSL_CTX*)sslctx, SSL_MODE_AUTO_RETRY);
 	SSL_CTX_set_verify_depth((SSL_CTX*)sslctx, 2);
@@ -40,7 +42,7 @@ CURLcode _sslctx_function_IDBE(CURL* curl, void* sslctx, void* param)
 {
 	if (iosuCrypto_addCACertificate(sslctx, 105) == false)
 	{
-		forceLog_printf("Invalid CA certificate (105)");
+		cemuLog_log(LogType::Force, "Invalid CA certificate (105)");
 	}
 	SSL_CTX_set_mode((SSL_CTX*)sslctx, SSL_MODE_AUTO_RETRY);
 	SSL_CTX_set_verify_depth((SSL_CTX*)sslctx, 2);
@@ -52,12 +54,12 @@ CURLcode _sslctx_function_SOAP(CURL* curl, void* sslctx, void* param)
 {
 	if (iosuCrypto_addCACertificate(sslctx, 102) == false)
 	{
-		forceLog_printf("Invalid CA certificate (102)");
-		forceLog_printf("Certificate error");
+		cemuLog_log(LogType::Force, "Invalid CA certificate (102)");
+		cemuLog_log(LogType::Force, "Certificate error");
 	}
 	if (iosuCrypto_addClientCertificate(sslctx, 1) == false)
 	{
-		forceLog_printf("Certificate error");
+		cemuLog_log(LogType::Force, "Certificate error");
 	}
 	SSL_CTX_set_mode((SSL_CTX*)sslctx, SSL_MODE_AUTO_RETRY);
 	SSL_CTX_set_verify_depth((SSL_CTX*)sslctx, 2);
@@ -65,6 +67,38 @@ CURLcode _sslctx_function_SOAP(CURL* curl, void* sslctx, void* param)
 	return CURLE_OK;
 }
 
+CURLcode _sslctx_function_OLIVE(CURL* curl, void* sslctx, void* param)
+{
+	if (iosuCrypto_addCACertificate(sslctx, 105) == false)
+	{
+		cemuLog_log(LogType::Force, "Invalid CA certificate (105)");
+		cemuLog_log(LogType::Force, "Certificate error");
+	}
+	if (iosuCrypto_addClientCertificate(sslctx, 7) == false)
+	{
+		cemuLog_log(LogType::Force, "Olive client certificate error");
+	}
+
+	// NSSLAddServerPKIGroups(sslCtx, 3, &x, &y);
+	{
+		std::vector<sint16> certGroups = {
+			100,  101,  102,   103,  104,  105,
+			1001, 1002, 1003, 1004, 1005, 1006, 1007, 1008, 1009,
+			1010, 1011, 1012, 1013, 1014, 1015, 1016, 1017, 1018, 1019,
+			1020, 1021, 1022, 1023, 1024, 1025, 1026, 1027, 1028, 1029,
+			1030, 1031, 1032, 1033
+		};
+
+		for (auto& certId : certGroups)
+			iosuCrypto_addCACertificate(sslctx, certId);
+	}
+
+	SSL_CTX_set_mode((SSL_CTX*)sslctx, SSL_MODE_AUTO_RETRY);
+	SSL_CTX_set_verify_depth((SSL_CTX*)sslctx, 2);
+	SSL_CTX_set_verify((SSL_CTX*)sslctx, SSL_VERIFY_PEER, nullptr);
+	return CURLE_OK;
+}
+
 CurlRequestHelper::CurlRequestHelper()
 {
 	m_curl = curl_easy_init();
@@ -73,6 +107,7 @@ CurlRequestHelper::CurlRequestHelper()
 
 	curl_easy_setopt(m_curl, CURLOPT_FOLLOWLOCATION, 1);
 	curl_easy_setopt(m_curl, CURLOPT_MAXREDIRS, 2);
+	curl_easy_setopt(m_curl, CURLOPT_HTTP_VERSION, CURL_HTTP_VERSION_1_1);
 
 	if(GetConfig().proxy_server.GetValue() != "")
 	{
@@ -85,7 +120,7 @@ CurlRequestHelper::~CurlRequestHelper()
 	curl_easy_cleanup(m_curl);
 }
 
-void CurlRequestHelper::initate(std::string url, SERVER_SSL_CONTEXT sslContext)
+void CurlRequestHelper::initate(NetworkService service, std::string url, SERVER_SSL_CONTEXT sslContext)
 {
 	// reset parameters
 	m_headerExtraFields.clear();
@@ -97,7 +132,12 @@ void CurlRequestHelper::initate(std::string url, SERVER_SSL_CONTEXT sslContext)
 	curl_easy_setopt(m_curl, CURLOPT_TIMEOUT, 60);
 
 	// SSL
-	if (sslContext == SERVER_SSL_CONTEXT::ACT || sslContext == SERVER_SSL_CONTEXT::TAGAYA)
+	curl_easy_setopt(m_curl, CURLOPT_SSL_VERIFYPEER, 1L);
+	if (IsNetworkServiceSSLDisabled(service))
+	{
+		curl_easy_setopt(m_curl, CURLOPT_SSL_VERIFYPEER, 0L);
+	}
+	else if (sslContext == SERVER_SSL_CONTEXT::ACT || sslContext == SERVER_SSL_CONTEXT::TAGAYA)
 	{
 		curl_easy_setopt(m_curl, CURLOPT_SSL_CTX_FUNCTION, _sslctx_function_NUS);
 		curl_easy_setopt(m_curl, CURLOPT_SSL_CTX_DATA, NULL);
@@ -117,6 +157,11 @@ void CurlRequestHelper::initate(std::string url, SERVER_SSL_CONTEXT sslContext)
 		curl_easy_setopt(m_curl, CURLOPT_SSL_CTX_FUNCTION, _sslctx_function_SOAP);
 		curl_easy_setopt(m_curl, CURLOPT_SSL_CTX_DATA, NULL);
 	}
+	else if (sslContext == SERVER_SSL_CONTEXT::OLIVE)
+	{
+		curl_easy_setopt(m_curl, CURLOPT_SSL_CTX_FUNCTION, _sslctx_function_OLIVE);
+		curl_easy_setopt(m_curl, CURLOPT_SSL_CTX_DATA, NULL);
+	}
 	else
 	{
 		cemu_assert(false);
@@ -173,9 +218,11 @@ bool CurlRequestHelper::submitRequest(bool isPost)
 	// post
 	if (isPost)
 	{
-		curl_easy_setopt(m_curl, CURLOPT_POST, 1);
-		curl_easy_setopt(m_curl, CURLOPT_POSTFIELDS, m_postData.data());
-		curl_easy_setopt(m_curl, CURLOPT_POSTFIELDSIZE, m_postData.size());
+		if (!m_isUsingMultipartFormData) {
+			curl_easy_setopt(m_curl, CURLOPT_POST, 1);
+			curl_easy_setopt(m_curl, CURLOPT_POSTFIELDS, m_postData.data());
+			curl_easy_setopt(m_curl, CURLOPT_POSTFIELDSIZE, m_postData.size());
+		}
 	}
 	else
 		curl_easy_setopt(m_curl, CURLOPT_POST, 0);
@@ -184,7 +231,7 @@ bool CurlRequestHelper::submitRequest(bool isPost)
 	int res = curl_easy_perform(m_curl);
 	if (res != CURLE_OK)
 	{
-		cemuLog_force("CURL web request failed with error {}. Retrying...", res);
+		cemuLog_log(LogType::Force, "CURL web request failed with error {}. Retrying...", res);
 		std::this_thread::sleep_for(std::chrono::milliseconds(1000));
 		// retry
 		res = curl_easy_perform(m_curl);
@@ -212,17 +259,25 @@ bool CurlRequestHelper::submitRequest(bool isPost)
 	return true;
 }
 
-CurlSOAPHelper::CurlSOAPHelper()
+CurlSOAPHelper::CurlSOAPHelper(NetworkService service)
 {
 	m_curl = curl_easy_init();
 	curl_easy_setopt(m_curl, CURLOPT_WRITEFUNCTION, __curlWriteCallback);
 	curl_easy_setopt(m_curl, CURLOPT_WRITEDATA, this);
+	curl_easy_setopt(m_curl, CURLOPT_HTTP_VERSION, CURL_HTTP_VERSION_1_1);
 
 	// SSL
-	curl_easy_setopt(m_curl, CURLOPT_SSL_CTX_FUNCTION, _sslctx_function_SOAP);
-	curl_easy_setopt(m_curl, CURLOPT_SSL_CTX_DATA, NULL);
-	
-	if(GetConfig().proxy_server.GetValue() != "")
+	if (!IsNetworkServiceSSLDisabled(service))
+	{
+		curl_easy_setopt(m_curl, CURLOPT_SSL_CTX_FUNCTION, _sslctx_function_SOAP);
+		curl_easy_setopt(m_curl, CURLOPT_SSL_CTX_DATA, NULL);
+		curl_easy_setopt(m_curl, CURLOPT_SSL_VERIFYPEER, 1L);
+	}
+	else
+	{
+		curl_easy_setopt(m_curl, CURLOPT_SSL_VERIFYPEER, 0L);
+	}
+	if (GetConfig().proxy_server.GetValue() != "")
 	{
 		curl_easy_setopt(m_curl, CURLOPT_PROXY, GetConfig().proxy_server.GetValue().c_str());
 	}
@@ -335,9 +390,8 @@ bool CurlSOAPHelper::submitRequest()
 	headers = curl_slist_append(headers, "Accept-Charset: UTF-8");
 	headers = curl_slist_append(headers, fmt::format("SOAPAction: urn:{}.wsapi.broadon.com/{}", m_serviceType, m_requestMethod).c_str());
 	headers = curl_slist_append(headers, "Accept: */*");
-	headers = curl_slist_append(headers, "User-Agent: EVL NUP 040800 Sep 18 2012 20:20:02");
-
 	curl_easy_setopt(m_curl, CURLOPT_HTTPHEADER, headers);
+	curl_easy_setopt(m_curl, CURLOPT_USERAGENT, "EVL NUP 040800 Sep 18 2012 20:20:02");
 
 	// send request
 	auto res = curl_easy_perform(m_curl);
@@ -368,7 +422,7 @@ namespace NAPI
 		// parse XML response
 		if (!doc.load_buffer(soapHelper.getReceivedData().data(), soapHelper.getReceivedData().size()))
 		{
-			forceLog_printf("Failed to parse GetRegistrationInfo() response");
+			cemuLog_log(LogType::Force, "Failed to parse GetRegistrationInfo() response");
 			result.apiError = NAPI_RESULT::XML_ERROR;
 			return false;
 		}
diff --git a/src/Cemu/napi/napi_helper.h b/src/Cemu/napi/napi_helper.h
index 00d57e92..adfe7393 100644
--- a/src/Cemu/napi/napi_helper.h
+++ b/src/Cemu/napi/napi_helper.h
@@ -27,6 +27,7 @@ public:
 		CCS, // ccs.
 		IDBE, // idbe-wup.
 		TAGAYA, // tagaya.wup.shop.nintendo.net
+		OLIVE, // olv.
 	};
 
 	CurlRequestHelper();
@@ -37,7 +38,7 @@ public:
 		return m_curl;
 	}
 
-	void initate(std::string url, SERVER_SSL_CONTEXT sslContext);
+	void initate(NetworkService service, std::string url, SERVER_SSL_CONTEXT sslContext);
 	void addHeaderField(const char* fieldName, std::string_view value);
 	void addPostField(const char* fieldName, std::string_view value);
 	void setWriteCallback(bool(*cbWriteCallback)(void* userData, const void* ptr, size_t len, bool isLast), void* userData);
@@ -50,6 +51,11 @@ public:
 		return m_receiveBuffer;
 	}
 
+	void setUseMultipartFormData(bool isUsingMultipartFormData)
+	{
+		m_isUsingMultipartFormData = isUsingMultipartFormData;
+	}
+
 private:
 	static size_t __curlWriteCallback(char* ptr, size_t size, size_t nmemb, void* userdata);
 
@@ -61,12 +67,14 @@ private:
 	// write callback redirect
 	bool (*m_cbWriteCallback)(void* userData, const void* ptr, size_t len, bool isLast);
 	void* m_writeCallbackUserData{};
+
+	bool m_isUsingMultipartFormData = false;
 };
 
 class CurlSOAPHelper // todo - make this use CurlRequestHelper
 {
 public:
-	CurlSOAPHelper();
+	CurlSOAPHelper(NetworkService service);
 	~CurlSOAPHelper();
 
 	CURL* getCURL()
diff --git a/src/Cemu/napi/napi_idbe.cpp b/src/Cemu/napi/napi_idbe.cpp
index 90c9c2f2..db7fda20 100644
--- a/src/Cemu/napi/napi_idbe.cpp
+++ b/src/Cemu/napi/napi_idbe.cpp
@@ -10,6 +10,8 @@
 #include "openssl/sha.h"
 #include "util/crypto/aes128.h"
 #include "util/helpers/StringHelpers.h"
+#include "config/ActiveSettings.h"
+#include "config/NetworkSettings.h"
 
 namespace NAPI
 {
@@ -52,10 +54,26 @@ namespace NAPI
 		AES128_CBC_decrypt((uint8*)iconData, (uint8*)iconData, sizeof(IDBEIconDataV0), aesKey, iv);
 	}
 
-	std::vector<uint8> IDBE_RequestRawEncrypted(uint64 titleId)
+	std::vector<uint8> IDBE_RequestRawEncrypted(NetworkService networkService, uint64 titleId)
 	{
 		CurlRequestHelper req;
-		req.initate(fmt::format("https://idbe-wup.cdn.nintendo.net/icondata/{0:02X}/{1:016X}.idbe", (uint32)((titleId >> 8) & 0xFF), titleId), CurlRequestHelper::SERVER_SSL_CONTEXT::IDBE);
+		std::string requestUrl;
+		switch (networkService)
+		{
+		case NetworkService::Pretendo:
+			requestUrl = PretendoURLs::IDBEURL;
+			break;
+		case NetworkService::Custom:
+			requestUrl = GetNetworkConfig().urls.IDBE.GetValue();
+			break;
+		case NetworkService::Nintendo:
+		default:
+			requestUrl = NintendoURLs::IDBEURL;
+			break;
+		}
+		requestUrl.append(fmt::format(fmt::runtime("/{0:02X}/{1:016X}.idbe"), (uint32)((titleId >> 8) & 0xFF), titleId));
+		req.initate(networkService, requestUrl, CurlRequestHelper::SERVER_SSL_CONTEXT::IDBE);
+
 		if (!req.submitRequest(false))
 		{
 			cemuLog_log(LogType::Force, fmt::format("Failed to request IDBE icon for title {0:016X}", titleId));
@@ -72,55 +90,41 @@ namespace NAPI
 		return receivedData;
 	}
 
-	std::optional<IDBEIconDataV0> IDBE_Request(uint64 titleId)
+	std::optional<IDBEIconDataV0> IDBE_Request(NetworkService networkService, uint64 titleId)
 	{
 		if (titleId == 0x000500301001500A ||
 			titleId == 0x000500301001510A ||
 			titleId == 0x000500301001520A)
 		{
 			// friend list has no icon, just fail immediately
-			forceLogDebug_printf("Requesting IDBE for Friend List. Return none instead");
+			cemuLog_logDebug(LogType::Force, "Requesting IDBE for Friend List. Return none instead");
 			return std::nullopt;
 		}
 
-		CurlRequestHelper req;
-		req.initate(fmt::format("https://idbe-wup.cdn.nintendo.net/icondata/{0:02X}/{1:016X}.idbe", (uint32)((titleId >> 8) & 0xFF), titleId), CurlRequestHelper::SERVER_SSL_CONTEXT::IDBE);
-		if (!req.submitRequest(false))
-		{
-			cemuLog_log(LogType::Force, fmt::format("Failed to request IDBE icon for title {0:016X}", titleId));
+		std::vector<uint8> idbeData = IDBE_RequestRawEncrypted(networkService, titleId);
+		if (idbeData.size() < 0x22)
 			return std::nullopt;
-		}
-		/*
-			format:
-			+0x00	uint8		version (0)
-			+0x01	uint8		keyIndex
-			+0x02	uint8[32]	hashSHA256
-			+0x22	uint8[]		EncryptedIconData
-		*/
-		auto& receivedData = req.getReceivedData();
-		if (receivedData.size() < 0x22)
-			return std::nullopt;
-		if (receivedData[0] != 0)
+		if (idbeData[0] != 0)
 		{
 			cemuLog_log(LogType::Force, "IDBE_Request: File has invalid version");
 			return std::nullopt;
 		}
-		uint8 keyIndex = receivedData[1];
+		uint8 keyIndex = idbeData[1];
 		if (keyIndex >= 4)
 		{
 			cemuLog_log(LogType::Force, "IDBE_Request: Key index out of range");
 			return std::nullopt;
 		}
-		if (receivedData.size() < (0x22 + sizeof(IDBEIconDataV0)))
+		if (idbeData.size() < (0x22 + sizeof(IDBEIconDataV0)))
 		{
 			cemuLog_log(LogType::Force, "IDBE_Request: File size does not match");
 			return std::nullopt;
 		}
 		// extract hash and encrypted icon data
 		uint8 hash[32];
-		std::memcpy(hash, receivedData.data() + 0x2, 32);
+		std::memcpy(hash, idbeData.data() + 0x2, 32);
 		IDBEIconDataV0 iconDataV0;
-		std::memcpy(&iconDataV0, receivedData.data() + 0x22, sizeof(IDBEIconDataV0));
+		std::memcpy(&iconDataV0, idbeData.data() + 0x22, sizeof(IDBEIconDataV0));
 		// decrypt icon data and hash
 		_decryptIDBEAndHash(&iconDataV0, hash, keyIndex);
 		// verify hash of decrypted data
diff --git a/src/Cemu/napi/napi_version.cpp b/src/Cemu/napi/napi_version.cpp
index f1c1b171..5a85dde3 100644
--- a/src/Cemu/napi/napi_version.cpp
+++ b/src/Cemu/napi/napi_version.cpp
@@ -7,6 +7,8 @@
 
 #include "Cemu/ncrypto/ncrypto.h"
 #include <charconv>
+#include "config/ActiveSettings.h"
+#include "config/NetworkSettings.h"
 
 namespace NAPI
 {
@@ -14,7 +16,24 @@ namespace NAPI
 	{
 		NAPI_VersionListVersion_Result result;
 		CurlRequestHelper req;
-		req.initate(fmt::format("https://tagaya.wup.shop.nintendo.net/tagaya/versionlist/{}/{}/latest_version", NCrypto::GetRegionAsString(authInfo.region), authInfo.country), CurlRequestHelper::SERVER_SSL_CONTEXT::TAGAYA);
+
+		std::string requestUrl;
+		switch (authInfo.GetService())
+		{
+		case NetworkService::Pretendo:
+			requestUrl = PretendoURLs::TAGAYAURL;
+			break;
+		case NetworkService::Custom:
+			requestUrl = GetNetworkConfig().urls.TAGAYA.GetValue();
+			break;
+		case NetworkService::Nintendo:
+		default:
+			requestUrl = NintendoURLs::TAGAYAURL;
+			break;
+		}
+		requestUrl.append(fmt::format(fmt::runtime("/{}/{}/latest_version"), NCrypto::GetRegionAsString(authInfo.region), authInfo.country.empty() ? "NN" : authInfo.country));
+		req.initate(authInfo.GetService(), requestUrl, CurlRequestHelper::SERVER_SSL_CONTEXT::TAGAYA);
+
 		if (!req.submitRequest(false))
 		{
 			cemuLog_log(LogType::Force, fmt::format("Failed to request version of update list"));
@@ -44,7 +63,7 @@ namespace NAPI
 	{
 		NAPI_VersionList_Result result;
 		CurlRequestHelper req;
-		req.initate(fmt::format("https://{}/tagaya/versionlist/{}/{}/list/{}.versionlist", fqdnURL, NCrypto::GetRegionAsString(authInfo.region), authInfo.country, versionListVersion), CurlRequestHelper::SERVER_SSL_CONTEXT::TAGAYA);
+		req.initate(authInfo.GetService(), fmt::format("https://{}/tagaya/versionlist/{}/{}/list/{}.versionlist", fqdnURL, NCrypto::GetRegionAsString(authInfo.region), authInfo.country.empty() ? "NN" : authInfo.country, versionListVersion), CurlRequestHelper::SERVER_SSL_CONTEXT::TAGAYA);
 		if (!req.submitRequest(false))
 		{
 			cemuLog_log(LogType::Force, fmt::format("Failed to request update list"));
@@ -55,7 +74,7 @@ namespace NAPI
 		pugi::xml_document doc;
 		if (!doc.load_buffer(receivedData.data(), receivedData.size()))
 		{
-			forceLog_printf("Failed to parse update list XML");
+			cemuLog_log(LogType::Force, "Failed to parse update list XML");
 			return result;
 		}
 		// example:
@@ -81,4 +100,4 @@ namespace NAPI
 		result.isValid = true;
 		return result;
 	}
-};
\ No newline at end of file
+};
diff --git a/src/Cemu/ncrypto/ncrypto.cpp b/src/Cemu/ncrypto/ncrypto.cpp
index 557c5228..bbda681f 100644
--- a/src/Cemu/ncrypto/ncrypto.cpp
+++ b/src/Cemu/ncrypto/ncrypto.cpp
@@ -20,7 +20,8 @@ void iosuCrypto_readOtpData(void* output, sint32 wordIndex, sint32 size);
 
 void iosuCrypto_readSeepromData(void* output, sint32 wordIndex, sint32 size);
 
-extern bool hasSeepromMem; // remove later
+extern bool hasSeepromMem; // remove later (migrate otp/seeprom loading & parsing to this class)
+extern bool hasOtpMem; // remove later
 
 namespace NCrypto
 {
@@ -447,7 +448,7 @@ namespace NCrypto
 	{
 		if (size < sizeof(TMDFileHeaderWiiU))
 		{
-			cemuLog_force("TMD size {} below minimum size of {}", size, sizeof(TMDFileHeaderWiiU));
+			cemuLog_log(LogType::Force, "TMD size {} below minimum size of {}", size, sizeof(TMDFileHeaderWiiU));
 			return false;
 		}
 		TMDFileHeaderWiiU* header = (TMDFileHeaderWiiU*)data;
@@ -456,7 +457,7 @@ namespace NCrypto
 		size_t expectedSize = sizeof(TMDFileHeaderWiiU) + sizeof(TMDFileContentEntryWiiU) * header->numContent;
 		if (size < expectedSize)
 		{
-			cemuLog_force("TMD size {} below expected size of {}. Content count: {}", size, expectedSize, (uint16)header->numContent);
+			cemuLog_log(LogType::Force, "TMD size {} below expected size of {}. Content count: {}", size, expectedSize, (uint16)header->numContent);
 			return false;
 		}
 
@@ -550,7 +551,7 @@ namespace NCrypto
 		EC_POINT_mul(group, pubkey, bn_privKey, NULL, NULL, NULL);
 		BIGNUM* bn_x = BN_new();
 		BIGNUM* bn_y = BN_new();
-		EC_POINT_get_affine_coordinates_GF2m(group, pubkey, bn_x, bn_y, NULL);
+		EC_POINT_get_affine_coordinates(group, pubkey, bn_x, bn_y, NULL);
 
 		// store public key
 		ECCPubKey genPubKey;
@@ -792,6 +793,16 @@ namespace NCrypto
 		return (CafeConsoleRegion)seepromRegionU32[3];
 	}
 
+	bool OTP_IsPresent()
+	{
+		return hasOtpMem;
+	}
+
+	bool HasDataForConsoleCert()
+	{
+		return SEEPROM_IsPresent() && OTP_IsPresent();
+	}
+
 	std::string GetRegionAsString(CafeConsoleRegion regionCode)
 	{
 		if (regionCode == CafeConsoleRegion::EUR)
@@ -806,7 +817,7 @@ namespace NCrypto
 			return "KOR";
 		else if (regionCode == CafeConsoleRegion::TWN)
 			return "TWN";
-		cemuLog_force("Unknown region code 0x{:x}", (uint32)regionCode);
+		cemuLog_log(LogType::Force, "Unknown region code 0x{:x}", (uint32)regionCode);
 		return "UKN";
 	}
 
@@ -957,6 +968,11 @@ namespace NCrypto
 		return it->second;
 	}
 
+	size_t GetCountryCount()
+	{
+		return g_countryTable.size();
+	}
+
 	void unitTests()
 	{
 		base64Tests();
diff --git a/src/Cemu/ncrypto/ncrypto.h b/src/Cemu/ncrypto/ncrypto.h
index 51f3d9cb..1ed7e91b 100644
--- a/src/Cemu/ncrypto/ncrypto.h
+++ b/src/Cemu/ncrypto/ncrypto.h
@@ -13,10 +13,17 @@ namespace NCrypto
 	std::string base64Encode(const void* inputMem, size_t inputLen);
 	std::vector<uint8> base64Decode(std::string_view inputStr);
 	
-	/* key helper struct */
+	/* key and iv helper struct */
 	struct AesKey 
 	{
-		uint8 b[16];
+		static constexpr size_t SIZE = 16;
+		uint8 b[SIZE];
+	};
+
+	struct AesIv
+	{
+		static constexpr size_t SIZE = 16;
+		uint8 iv[SIZE];
 	};
 
 	/* ECC Certificate */
@@ -205,7 +212,11 @@ namespace NCrypto
 	CafeConsoleRegion SEEPROM_GetRegion();
 	std::string GetRegionAsString(CafeConsoleRegion regionCode);
 	const char* GetCountryAsString(sint32 index); // returns NN if index is not valid or known
+	size_t GetCountryCount();
 	bool SEEPROM_IsPresent();
+	bool OTP_IsPresent();
+
+	bool HasDataForConsoleCert();
 
 	void unitTests();
 }
\ No newline at end of file
diff --git a/src/Cemu/nex/nex.cpp b/src/Cemu/nex/nex.cpp
index 147d37da..973a4395 100644
--- a/src/Cemu/nex/nex.cpp
+++ b/src/Cemu/nex/nex.cpp
@@ -29,7 +29,7 @@ sint32 nexService_parseResponse(uint8* data, sint32 length, nexServiceResponse_t
 	protocolId &= 0x7F;
 	if (isRequest)
 	{
-#ifndef PUBLIC_RELEASE
+#ifdef CEMU_DEBUG_ASSERT
 		assert_dbg(); // should never reach since we handle requests before this function is called
 #endif
 	}
@@ -106,7 +106,7 @@ nexService::nexService()
 
 nexService::nexService(prudpClient* con) : nexService()
 {
-	if (con->isConnected() == false)
+	if (con->IsConnected() == false)
 		cemu_assert_suspicious();
 	this->conNexService = con;
 	bufferReceive = std::vector<uint8>(1024 * 4);
@@ -160,11 +160,10 @@ bool nexService::isMarkedForDestruction()
 
 void nexService::callMethod(uint8 protocolId, uint32 methodId, nexPacketBuffer* parameter, void(*nexServiceResponse)(nexService* nex, nexServiceResponse_t* serviceResponse), void* custom, bool callHandlerIfError)
 {
-	// add to queue
 	queuedRequest_t queueRequest = { 0 };
 	queueRequest.protocolId = protocolId;
 	queueRequest.methodId = methodId;
-	queueRequest.parameterData = std::vector<uint8>(parameter->getDataPtr(), parameter->getDataPtr() + parameter->getWriteIndex());
+	queueRequest.parameterData.assign(parameter->getDataPtr(), parameter->getDataPtr() + parameter->getWriteIndex());
 	queueRequest.nexServiceResponse = nexServiceResponse;
 	queueRequest.custom = custom;
 	queueRequest.callHandlerIfError = callHandlerIfError;
@@ -175,11 +174,10 @@ void nexService::callMethod(uint8 protocolId, uint32 methodId, nexPacketBuffer*
 
 void nexService::callMethod(uint8 protocolId, uint32 methodId, nexPacketBuffer* parameter, std::function<void(nexServiceResponse_t*)> cb, bool callHandlerIfError)
 {
-	// add to queue
 	queuedRequest_t queueRequest = { 0 };
 	queueRequest.protocolId = protocolId;
 	queueRequest.methodId = methodId;
-	queueRequest.parameterData = std::vector<uint8>(parameter->getDataPtr(), parameter->getDataPtr() + parameter->getWriteIndex());
+	queueRequest.parameterData.assign(parameter->getDataPtr(), parameter->getDataPtr() + parameter->getWriteIndex());
 	queueRequest.nexServiceResponse = nullptr;
 	queueRequest.cb2 = cb;
 	queueRequest.callHandlerIfError = callHandlerIfError;
@@ -193,7 +191,7 @@ void nexService::processQueuedRequest(queuedRequest_t* queuedRequest)
 	uint32 callId = _currentCallId;
 	_currentCallId++;
 	// check state of connection
-	if (conNexService->getConnectionState() != prudpClient::STATE_CONNECTED)
+	if (conNexService->GetConnectionState() != prudpClient::ConnectionState::Connected)
 	{
 		nexServiceResponse_t response = { 0 };
 		response.isSuccessful = false;
@@ -216,7 +214,7 @@ void nexService::processQueuedRequest(queuedRequest_t* queuedRequest)
 		assert_dbg();
 	memcpy((packetBuffer + 0x0D), &queuedRequest->parameterData.front(), queuedRequest->parameterData.size());
 	sint32 length = 0xD + (sint32)queuedRequest->parameterData.size();
-	conNexService->sendDatagram(packetBuffer, length, true);
+	conNexService->SendDatagram(packetBuffer, length, true);
 	// remember request
 	nexActiveRequestInfo_t requestInfo = { 0 };
 	requestInfo.callId = callId;
@@ -301,13 +299,13 @@ void nexService::registerForAsyncProcessing()
 void nexService::updateTemporaryConnections()
 {
 	// check for connection
-	conNexService->update();
-	if (conNexService->isConnected())
+	conNexService->Update();
+	if (conNexService->IsConnected())
 	{
 		if (connectionState == STATE_CONNECTING)
 			connectionState = STATE_CONNECTED;
 	}
-	if (conNexService->getConnectionState() == prudpClient::STATE_DISCONNECTED)
+	if (conNexService->GetConnectionState() == prudpClient::ConnectionState::Disconnected)
 		connectionState = STATE_DISCONNECTED;
 }
 
@@ -358,18 +356,18 @@ void nexService::sendRequestResponse(nexServiceRequest_t* request, uint32 errorC
 	// update length field
 	*(uint32*)response.getDataPtr() = response.getWriteIndex()-4;
 	if(request->nex->conNexService)
-		request->nex->conNexService->sendDatagram(response.getDataPtr(), response.getWriteIndex(), true);
+		request->nex->conNexService->SendDatagram(response.getDataPtr(), response.getWriteIndex(), true);
 }
 
 void nexService::updateNexServiceConnection()
 {
-	if (conNexService->getConnectionState() == prudpClient::STATE_DISCONNECTED)
+	if (conNexService->GetConnectionState() == prudpClient::ConnectionState::Disconnected)
 	{
 		this->connectionState = STATE_DISCONNECTED;
 		return;
 	}
-	conNexService->update();
-	sint32 datagramLen = conNexService->receiveDatagram(bufferReceive);
+	conNexService->Update();
+	sint32 datagramLen = conNexService->ReceiveDatagram(bufferReceive);
 	if (datagramLen > 0)
 	{
 		if (nexIsRequest(&bufferReceive[0], datagramLen))
@@ -456,12 +454,12 @@ bool _extractStationUrlParamValue(const char* urlStr, const char* paramName, cha
 	return false;
 }
 
-void nexServiceAuthentication_parseStationURL(char* urlStr, stationUrl_t* stationUrl)
+void nexServiceAuthentication_parseStationURL(char* urlStr, prudpStationUrl* stationUrl)
 {
 	// example:
 	// prudps:/address=34.210.xxx.xxx;port=60181;CID=1;PID=2;sid=1;stream=10;type=2
 
-	memset(stationUrl, 0, sizeof(stationUrl_t));
+	memset(stationUrl, 0, sizeof(prudpStationUrl));
 
 	char optionValue[128];
 	if (_extractStationUrlParamValue(urlStr, "address", optionValue, sizeof(optionValue)))
@@ -501,7 +499,7 @@ typedef struct
 	sint32 kerberosTicketSize;
 	uint8 kerberosTicket2[4096];
 	sint32 kerberosTicket2Size;
-	stationUrl_t server;
+	prudpStationUrl server;
 	// progress info
 	bool hasError;
 	bool done;
@@ -512,21 +510,21 @@ void nexServiceAuthentication_handleResponse_requestTicket(nexService* nex, nexS
 	authenticationService_t* authService = (authenticationService_t*)response->custom;
 	if (response->isSuccessful == false)
 	{
-		forceLog_printf("NEX: RPC error while requesting auth ticket with error code 0x%08x", response->errorCode);
+		cemuLog_log(LogType::Force, "NEX: RPC error while requesting auth ticket with error code 0x{:08x}", response->errorCode);
 		authService->hasError = true;
 		return;
 	}
 	uint32 returnValue = response->data.readU32();
 	if (returnValue & 0x80000000)
 	{
-		forceLog_printf("NEX: Failed to request auth ticket with error code 0x%08x", returnValue);
+		cemuLog_log(LogType::Force, "NEX: Failed to request auth ticket with error code 0x{:08x}", returnValue);
 		authService->hasError = true;
 	}
 	authService->kerberosTicket2Size = response->data.readBuffer(authService->kerberosTicket2, sizeof(authService->kerberosTicket2));
 	if (response->data.hasReadOutOfBounds())
 	{
 		authService->hasError = true;
-		forceLog_printf("NEX: Out of bounds error while reading auth ticket");
+		cemuLog_log(LogType::Force, "NEX: Out of bounds error while reading auth ticket");
 		return;
 	}
 	authService->done = true;
@@ -538,7 +536,7 @@ void nexServiceAuthentication_handleResponse_login(nexService* nex, nexServiceRe
 	if (response->isSuccessful == false)
 	{
 		authService->hasError = true;
-		forceLog_printf("NEX: RPC error in login response 0x%08x", response->errorCode);
+		cemuLog_log(LogType::Force, "NEX: RPC error in login response 0x{:08x}", response->errorCode);
 		return;
 	}
 
@@ -546,7 +544,7 @@ void nexServiceAuthentication_handleResponse_login(nexService* nex, nexServiceRe
 	if (returnValue & 0x80000000)
 	{
 		authService->hasError = true;
-		forceLog_printf("NEX: Error 0x%08x in login response (returnCode 0x%08x)", response->errorCode, returnValue);
+		cemuLog_log(LogType::Force, "NEX: Error 0x{:08x} in login response (returnCode 0x{:08x})", response->errorCode, returnValue);
 		return;
 	}
 
@@ -571,7 +569,7 @@ void nexServiceAuthentication_handleResponse_login(nexService* nex, nexServiceRe
 	if (response->data.hasReadOutOfBounds())
 	{
 		authService->hasError = true;
-		forceLog_printf("NEX: Read out of bounds");
+		cemuLog_log(LogType::Force, "NEX: Read out of bounds");
 		return;
 	}
 	// request ticket data
@@ -595,14 +593,14 @@ void nexServiceSecure_handleResponse_RegisterEx(nexService* nex, nexServiceRespo
 	uint32 returnCode = response->data.readU32();
 	if (response->isSuccessful == false || response->data.hasReadOutOfBounds())
 	{
-		forceLog_printf("NEX: RPC error in secure register");
+		cemuLog_log(LogType::Force, "NEX: RPC error in secure register");
 		info->isSuccessful = false;
 		info->isComplete = true;
 		return;
 	}
 	if (returnCode & 0x80000000)
 	{
-		forceLog_printf("NEX: Secure register failed with error code 0x%08x", returnCode);
+		cemuLog_log(LogType::Force, "NEX: Secure register failed with error code 0x{:08x}", returnCode);
 		info->isSuccessful = false;
 		info->isComplete = true;
 		return;
@@ -613,21 +611,21 @@ void nexServiceSecure_handleResponse_RegisterEx(nexService* nex, nexServiceRespo
 	return;
 }
 
-nexService* nex_secureLogin(authServerInfo_t* authServerInfo, const char* accessKey, const char* nexToken)
+nexService* nex_secureLogin(prudpAuthServerInfo* authServerInfo, const char* accessKey, const char* nexToken)
 {
 	prudpClient* prudpSecureSock = new prudpClient(authServerInfo->server.ip, authServerInfo->server.port, accessKey, authServerInfo);
 	// wait until connected
 	while (true)
 	{
-		prudpSecureSock->update();
-		if (prudpSecureSock->isConnected())
+		prudpSecureSock->Update();
+		if (prudpSecureSock->IsConnected())
 		{
 			break;
 		}
-		if (prudpSecureSock->getConnectionState() == prudpClient::STATE_DISCONNECTED)
+		if (prudpSecureSock->GetConnectionState() == prudpClient::ConnectionState::Disconnected)
 		{
 			// timeout or disconnected
-			forceLog_printf("NEX: Secure login connection time-out");
+			cemuLog_log(LogType::Force, "NEX: Secure login connection time-out");
 			delete prudpSecureSock;
 			return nullptr;
 		}
@@ -640,7 +638,7 @@ nexService* nex_secureLogin(authServerInfo_t* authServerInfo, const char* access
 	nexPacketBuffer packetBuffer(tempNexBufferArray, sizeof(tempNexBufferArray), true);
 	
 	char clientStationUrl[256];
-	sprintf(clientStationUrl, "prudp:/port=%u;natf=0;natm=0;pmp=0;sid=15;type=2;upnp=0", (uint32)nex->getPRUDPConnection()->getSourcePort());
+	sprintf(clientStationUrl, "prudp:/port=%u;natf=0;natm=0;pmp=0;sid=15;type=2;upnp=0", (uint32)nex->getPRUDPConnection()->GetSourcePort());
 	// station url list
 	packetBuffer.writeU32(1);
 	packetBuffer.writeString(clientStationUrl);
@@ -656,13 +654,13 @@ nexService* nex_secureLogin(authServerInfo_t* authServerInfo, const char* access
 			break;
 		if (nex->getState() == nexService::STATE_DISCONNECTED)
 		{
-			forceLog_printf("NEX: Connection error while registering");
+			cemuLog_log(LogType::Force, "NEX: Connection error while registering");
 			break;
 		}
 	}
 	if (secureRegisterExData.isSuccessful == false)
 	{
-		forceLog_printf("NEX: Failed to register to secure server");
+		cemuLog_log(LogType::Force, "NEX: Failed to register to secure server");
 		nex->destroy();
 		return nullptr;
 	}
@@ -682,7 +680,7 @@ nexService* nex_establishSecureConnection(uint32 authServerIp, uint16 authServer
 	{
 		// error
 		authConnection->destroy();
-		forceLog_printf("NEX: Failed to connect to the NEX server");
+		cemuLog_log(LogType::Force, "NEX: Failed to connect to the NEX server");
 		return nullptr;
 	}
 	// send auth login request
@@ -704,7 +702,7 @@ nexService* nex_establishSecureConnection(uint32 authServerIp, uint16 authServer
 	{
 		// error
 		authConnection->destroy();
-		forceLog_printf("NEX: Error during authentication");
+		cemuLog_log(LogType::Force, "NEX: Error during authentication");
 		return nullptr;
 	}
 	// close connection to auth server
@@ -726,7 +724,7 @@ nexService* nex_establishSecureConnection(uint32 authServerIp, uint16 authServer
 	if (nexAuthService.kerberosTicket2Size < 16)
 	{
 		nexAuthService.hasError = true;
-		forceLog_printf("NEX: Kerberos ticket too short");
+		cemuLog_log(LogType::Force, "NEX: Kerberos ticket too short");
 		return nullptr;
 	}
 	// check hmac of ticket
@@ -735,13 +733,13 @@ nexService* nex_establishSecureConnection(uint32 authServerIp, uint16 authServer
 	if (memcmp(hmacTicket, nexAuthService.kerberosTicket2 + nexAuthService.kerberosTicket2Size - 16, 16) != 0)
 	{
 		nexAuthService.hasError = true;
-		forceLog_printf("NEX: Kerberos ticket hmac invalid");
+		cemuLog_log(LogType::Force, "NEX: Kerberos ticket hmac invalid");
 		return nullptr;
 	}
 	// auth info
-	std::unique_ptr<authServerInfo_t> authServerInfo(new authServerInfo_t);
+	auto authServerInfo = std::make_unique<prudpAuthServerInfo>();
 	// decrypt ticket
-	RC4Ctx_t rc4Ticket;
+	RC4Ctx rc4Ticket;
 	RC4_initCtx(&rc4Ticket, kerberosKey, 16);
 	RC4_transform(&rc4Ticket, nexAuthService.kerberosTicket2, nexAuthService.kerberosTicket2Size - 16, nexAuthService.kerberosTicket2);
 	nexPacketBuffer packetKerberosTicket(nexAuthService.kerberosTicket2, nexAuthService.kerberosTicket2Size - 16, false);
@@ -752,14 +750,14 @@ nexService* nex_establishSecureConnection(uint32 authServerIp, uint16 authServer
 
 	if (packetKerberosTicket.hasReadOutOfBounds())
 	{
-		forceLog_printf("NEX: Parse error");
+		cemuLog_log(LogType::Force, "NEX: Parse error");
 		return nullptr;
 	}
 
 	memcpy(authServerInfo->kerberosKey, kerberosKey, 16);
 	memcpy(authServerInfo->secureKey, secureKey, 16);
-	memcpy(&authServerInfo->server, &nexAuthService.server, sizeof(stationUrl_t));
+	memcpy(&authServerInfo->server, &nexAuthService.server, sizeof(prudpStationUrl));
 	authServerInfo->userPid = pid;
 
 	return nex_secureLogin(authServerInfo.get(), accessKey, nexToken);
-}
\ No newline at end of file
+}
diff --git a/src/Cemu/nex/nexFriends.cpp b/src/Cemu/nex/nexFriends.cpp
index 6d902177..36ba4a53 100644
--- a/src/Cemu/nex/nexFriends.cpp
+++ b/src/Cemu/nex/nexFriends.cpp
@@ -1,6 +1,7 @@
 #include "prudp.h"
 #include "nex.h"
 #include "nexFriends.h"
+#include "Cafe/CafeSystem.h"
 
 static const int NOTIFICATION_SRV_FRIEND_OFFLINE = 0x0A; // the opposite event (friend online) is notified via _PRESENCE_CHANGE
 static const int NOTIFICATION_SRV_FRIEND_PRESENCE_CHANGE = 0x18;
@@ -168,7 +169,7 @@ void NexFriends::processServerNotification(uint32 notificationType, uint32 pid,
 	}
 	else if (true)
 	{
-		forceLogDebug_printf("Unsupported friend server notification type 0x%02x", notificationType);
+		cemuLog_logDebug(LogType::Force, "Unsupported friend server notification type 0x{:02x}", notificationType);
 	}
 }
 
@@ -185,7 +186,7 @@ void nexFriends_protocolNotification_processRequest(nexServiceRequest_t* request
 			request->nex->sendRequestResponse(request, 0, nullptr, 0);
 			return;
 		}
-		forceLogDebug_printf("NN_NOTIFICATION methodId %d type %02x pid %08x", request->methodId, notificationType, pid);
+		cemuLog_logDebug(LogType::Force, "NN_NOTIFICATION methodId {} type {:02x} pid {:08x}", request->methodId, notificationType, pid);
 		nexFriends->processServerNotification(notificationType, pid, &request->data);
 		request->nex->sendRequestResponse(request, 0, nullptr, 0);
 		return;
@@ -220,7 +221,8 @@ NexFriends::NexFriends(uint32 authServerIp, uint16 authServerPort, const char* a
 
 NexFriends::~NexFriends()
 {
-	nexCon->destroy();
+	if(nexCon)
+		nexCon->destroy();
 }
 
 void NexFriends::doAsyncLogin()
@@ -260,7 +262,7 @@ void NexFriends::initiateLogin()
 	previousState.list_friendReqOutgoing.resize(0);
 	this->hasData = false;
 	// start login attempt
-	forceLogDebug_printf("Attempt to log into friend server...");
+	cemuLog_logDebug(LogType::Force, "Attempt to log into friend server...");
 	std::thread t(&NexFriends::doAsyncLogin, this);
 	t.detach();
 }
@@ -274,9 +276,9 @@ void NexFriends::handleResponse_getAllInformation(nexServiceResponse_t* response
 		return;
 	}
 	NexFriends* session = (NexFriends*)nexFriends;
-
-	nexPrincipalPreference preference(&response->data);
-	nexComment comment(&response->data);
+	session->myPreference = nexPrincipalPreference(&response->data);
+	auto comment = nexComment(&response->data);
+	session->myComment = comment;
 	if (response->data.hasReadOutOfBounds())
 		return;
 	// acquire lock on lists
@@ -290,29 +292,21 @@ void NexFriends::handleResponse_getAllInformation(nexServiceResponse_t* response
 	uint32 friendCount = response->data.readU32();
 	session->list_friends.resize(friendCount);
 	for (uint32 i = 0; i < friendCount; i++)
-	{
 		session->list_friends[i].readData(&response->data);
-	}
 	// friend requests (outgoing)
 	uint32 friendRequestsOutCount = response->data.readU32();
 	if (response->data.hasReadOutOfBounds())
-	{
 		return;
-	}
 	session->list_friendReqOutgoing.resize(friendRequestsOutCount);
 	for (uint32 i = 0; i < friendRequestsOutCount; i++)
-	{
 		session->list_friendReqOutgoing[i].readData(&response->data);
-	}
 	// friend requests (incoming)
 	uint32 friendRequestsInCount = response->data.readU32();
 	if (response->data.hasReadOutOfBounds())
 		return;
 	session->list_friendReqIncoming.resize(friendRequestsInCount);
 	for (uint32 i = 0; i < friendRequestsInCount; i++)
-	{
 		session->list_friendReqIncoming[i].readData(&response->data);
-	}
 	if (response->data.hasReadOutOfBounds())
 		return;
 	// blacklist
@@ -335,8 +329,8 @@ void NexFriends::handleResponse_getAllInformation(nexServiceResponse_t* response
 	uint8 isPreferenceInvalid = response->data.readU8(); // if not zero, preferences must be setup
 	if (isPreferenceInvalid)
 	{
-		forceLog_printf("NEX: First time login into friend account, setting up default preferences");
-		session->updatePreferences(nexPrincipalPreference(1, 1, 0));
+		cemuLog_log(LogType::Force, "NEX: First time login into friend account, setting up default preferences");
+		session->updatePreferencesAsync(nexPrincipalPreference(1, 1, 0), [](RpcErrorCode err){});
 	}
 
 	if (session->firstInformationRequest == false)
@@ -377,20 +371,49 @@ bool NexFriends::requestGetAllInformation(std::function<void(uint32)> cb)
 	return true;
 }
 
-void NexFriends::handleResponse_updatePreferences(nexServiceResponse_t* response, NexFriends* nexFriends, std::function<void(uint32)> cb)
-{
-	// todo
-}
-
-bool NexFriends::updatePreferences(const nexPrincipalPreference& newPreferences)
+bool NexFriends::updatePreferencesAsync(nexPrincipalPreference newPreferences, std::function<void(RpcErrorCode)> cb)
 {
 	uint8 tempNexBufferArray[1024];
 	nexPacketBuffer packetBuffer(tempNexBufferArray, sizeof(tempNexBufferArray), true);
 	newPreferences.writeData(&packetBuffer);
-	nexCon->callMethod(NEX_PROTOCOL_FRIENDS_WIIU, 16, &packetBuffer, std::bind(handleResponse_updatePreferences, std::placeholders::_1, this, nullptr), true);
+	nexCon->callMethod(NEX_PROTOCOL_FRIENDS_WIIU, 16, &packetBuffer, [this, cb, newPreferences](nexServiceResponse_t* response) -> void
+		{
+			if (!response->isSuccessful)
+				return cb(NexFriends::ERR_RPC_FAILED);
+			this->myPreference = newPreferences;
+			return cb(NexFriends::ERR_NONE);
+		}, true);
+	// TEST
 	return true;
 }
 
+void NexFriends::getMyPreference(nexPrincipalPreference& preference)
+{
+	preference = myPreference;
+}
+
+bool NexFriends::updateCommentAsync(nexComment newComment, std::function<void(RpcErrorCode)> cb)
+{
+	uint8 tempNexBufferArray[1024];
+	nexPacketBuffer packetBuffer(tempNexBufferArray, sizeof(tempNexBufferArray), true);
+	newComment.writeData(&packetBuffer);
+	nexCon->callMethod(
+		NEX_PROTOCOL_FRIENDS_WIIU, 15, &packetBuffer, [this, cb, newComment](nexServiceResponse_t* response) -> void {
+			if (!response->isSuccessful)
+				return cb(NexFriends::ERR_RPC_FAILED);
+			this->myComment = newComment;
+			return cb(NexFriends::ERR_NONE);
+		},
+		true);
+	// TEST
+	return true;
+}
+
+void NexFriends::getMyComment(nexComment& comment)
+{
+	comment = myComment;
+}
+
 bool NexFriends::addProvisionalFriendByPidGuessed(uint32 principalId)
 {
 	uint8 tempNexBufferArray[512];
@@ -401,6 +424,7 @@ bool NexFriends::addProvisionalFriendByPidGuessed(uint32 principalId)
 	return true;
 }
 
+// returns true once connection is established and friend list data is available
 bool NexFriends::isOnline()
 {
 	return isCurrentlyConnected && hasData;
@@ -683,7 +707,7 @@ bool NexFriends::getFriendRequestByPID(nexFriendRequest& friendRequestData, bool
 		{
 			friendRequestData = it;
 			if (isIncoming)
-			*isIncoming = false;
+				*isIncoming = false;
 			return true;
 		}
 	}
@@ -731,7 +755,7 @@ void addProvisionalFriendHandler(nexServiceResponse_t* nexResponse, std::functio
 	}
 }
 
-bool NexFriends::addProvisionalFriend(char* name, std::function<void(uint32)> cb)
+bool NexFriends::addProvisionalFriend(char* name, std::function<void(RpcErrorCode)> cb)
 {
 	if (nexCon == nullptr || nexCon->getState() != nexService::STATE_CONNECTED)
 	{
@@ -754,12 +778,11 @@ void addFriendRequestHandler(nexServiceResponse_t* nexResponse, NexFriends* nexF
 	{
 		// todo: Properly handle returned error code
 		cb(NexFriends::ERR_RPC_FAILED);
-		// refresh the list
-		nexFriends->requestGetAllInformation();
+		nexFriends->requestGetAllInformation(); // refresh friend list and send add/remove notifications
 	}
 }
 
-void NexFriends::addFriendRequest(uint32 pid, const char* comment, std::function<void(uint32)> cb)
+void NexFriends::addFriendRequest(uint32 pid, const char* comment, std::function<void(RpcErrorCode)> cb)
 {
 	if (nexCon == nullptr || nexCon->getState() != nexService::STATE_CONNECTED)
 	{
@@ -779,72 +802,31 @@ void NexFriends::addFriendRequest(uint32 pid, const char* comment, std::function
 	nexCon->callMethod(NEX_PROTOCOL_FRIENDS_WIIU, 5, &packetBuffer, std::bind(addFriendRequestHandler, std::placeholders::_1, this, cb), true);
 }
 
-typedef struct
-{
-	NEXFRIENDS_CALLBACK cb;
-	void* customParam;
-	NexFriends* nexFriends;
-	// command specific
-	struct  
-	{
-		nexPrincipalBasicInfo* basicInfo;
-		sint32 count;
-	}principalBaseInfo;
-}nexFriendsCallInfo_t;
-
-void NexFriends_handleResponse_requestPrincipleBaseInfoByPID(nexService* nex, nexServiceResponse_t* response)
-{
-	nexFriendsCallInfo_t* callInfo = (nexFriendsCallInfo_t*)response->custom;
-	if (response->isSuccessful == false)
-	{
-		// handle error case
-		callInfo->cb(callInfo->nexFriends, NexFriends::ERR_RPC_FAILED, callInfo->customParam);
-		free(callInfo);
-		return;
-	}
-	// process result
-	uint32 count = response->data.readU32();
-	if (count != callInfo->principalBaseInfo.count)
-	{
-		callInfo->cb(callInfo->nexFriends, NexFriends::ERR_UNEXPECTED_RESULT, callInfo->customParam);
-		free(callInfo);
-		return;
-	}
-	for (uint32 i = 0; i < count; i++)
-	{
-		callInfo->principalBaseInfo.basicInfo[i].readData(&response->data);
-	}
-	if (response->data.hasReadOutOfBounds())
-	{
-		callInfo->cb(callInfo->nexFriends, NexFriends::ERR_UNEXPECTED_RESULT, callInfo->customParam);
-		free(callInfo);
-		return;
-	}
-	// callback
-	callInfo->cb(callInfo->nexFriends, NexFriends::ERR_NONE, callInfo->customParam);
-	free(callInfo);
-}
-
-void NexFriends::requestPrincipleBaseInfoByPID(nexPrincipalBasicInfo* basicInfo, uint32* pidList, sint32 count, NEXFRIENDS_CALLBACK cb, void* customParam)
+void NexFriends::requestPrincipleBaseInfoByPID(uint32* pidList, sint32 count, const std::function<void(RpcErrorCode result, std::span<nexPrincipalBasicInfo> basicInfo)>& cb)
 {
 	if (nexCon == nullptr || nexCon->getState() != nexService::STATE_CONNECTED)
-	{
-		// not connected
-		cb(this, ERR_NOT_CONNECTED, customParam);
-		return;
-	}
+		return cb(ERR_NOT_CONNECTED, {});
 	uint8 tempNexBufferArray[512];
 	nexPacketBuffer packetBuffer(tempNexBufferArray, sizeof(tempNexBufferArray), true);
 	packetBuffer.writeU32(count);
 	for(sint32 i=0; i<count; i++)
 		packetBuffer.writeU32(pidList[i]);
-	nexFriendsCallInfo_t* callInfo = (nexFriendsCallInfo_t*)malloc(sizeof(nexFriendsCallInfo_t));
-	callInfo->principalBaseInfo.basicInfo = basicInfo;
-	callInfo->principalBaseInfo.count = count;
-	callInfo->cb = cb;
-	callInfo->customParam = customParam;
-	callInfo->nexFriends = this;
-	nexCon->callMethod(NEX_PROTOCOL_FRIENDS_WIIU, 17, &packetBuffer, NexFriends_handleResponse_requestPrincipleBaseInfoByPID, callInfo, true);
+	nexCon->callMethod(NEX_PROTOCOL_FRIENDS_WIIU, 17, &packetBuffer, [cb, count](nexServiceResponse_t* response)
+		{
+			if (!response->isSuccessful)
+				return cb(NexFriends::ERR_RPC_FAILED, {});
+			// process result
+			uint32 resultCount = response->data.readU32();
+			if (resultCount != count)
+				return cb(NexFriends::ERR_UNEXPECTED_RESULT, {});
+			std::vector<nexPrincipalBasicInfo> nexBasicInfo;
+			nexBasicInfo.resize(count);
+			for (uint32 i = 0; i < resultCount; i++)
+				nexBasicInfo[i].readData(&response->data);
+			if (response->data.hasReadOutOfBounds())
+				return cb(NexFriends::ERR_UNEXPECTED_RESULT, {});
+			return cb(NexFriends::ERR_NONE, nexBasicInfo);
+		}, true);
 }
 
 void genericFriendServiceNoResponseHandler(nexServiceResponse_t* nexResponse, std::function<void(uint32)> cb)
@@ -858,7 +840,7 @@ void genericFriendServiceNoResponseHandler(nexServiceResponse_t* nexResponse, st
 	}
 }
 
-void NexFriends::removeFriend(uint32 pid, std::function<void(uint32)> cb)
+void NexFriends::removeFriend(uint32 pid, std::function<void(RpcErrorCode)> cb)
 {
 	if (nexCon == nullptr || nexCon->getState() != nexService::STATE_CONNECTED)
 	{
@@ -869,10 +851,20 @@ void NexFriends::removeFriend(uint32 pid, std::function<void(uint32)> cb)
 	uint8 tempNexBufferArray[512];
 	nexPacketBuffer packetBuffer(tempNexBufferArray, sizeof(tempNexBufferArray), true);
 	packetBuffer.writeU32(pid);
-	nexCon->callMethod(NEX_PROTOCOL_FRIENDS_WIIU, 4, &packetBuffer, std::bind(genericFriendServiceNoResponseHandler, std::placeholders::_1, cb), true);
+	nexCon->callMethod(NEX_PROTOCOL_FRIENDS_WIIU, 4, &packetBuffer, [this, cb](nexServiceResponse_t* response) -> void
+		{
+			if (!response->isSuccessful)
+				return cb(NexFriends::ERR_RPC_FAILED);
+			else
+			{
+				cb(NexFriends::ERR_NONE);
+				this->requestGetAllInformation(); // refresh friend list and send add/remove notifications
+				return;
+			}
+		}, true);
 }
 
-void NexFriends::cancelOutgoingProvisionalFriendRequest(uint32 pid, std::function<void(uint32)> cb)
+void NexFriends::cancelOutgoingProvisionalFriendRequest(uint32 pid, std::function<void(RpcErrorCode)> cb)
 {
 	if (nexCon == nullptr || nexCon->getState() != nexService::STATE_CONNECTED)
 	{
@@ -883,58 +875,80 @@ void NexFriends::cancelOutgoingProvisionalFriendRequest(uint32 pid, std::functio
 	uint8 tempNexBufferArray[512];
 	nexPacketBuffer packetBuffer(tempNexBufferArray, sizeof(tempNexBufferArray), true);
 	packetBuffer.writeU32(pid);
-	nexCon->callMethod(NEX_PROTOCOL_FRIENDS_WIIU, 4, &packetBuffer, std::bind(genericFriendServiceNoResponseHandler, std::placeholders::_1, cb), true);
+	nexCon->callMethod(NEX_PROTOCOL_FRIENDS_WIIU, 4, &packetBuffer, [cb](nexServiceResponse_t* response) -> void
+	{
+		if (!response->isSuccessful)
+			return cb(NexFriends::ERR_RPC_FAILED);
+		else
+			return cb(NexFriends::ERR_NONE);
+		}, true);
 }
 
-void NexFriends::acceptFriendRequest(uint64 messageId, std::function<void(uint32)> cb)
+void NexFriends::acceptFriendRequest(uint64 messageId, std::function<void(RpcErrorCode)> cb)
 {
 	if (nexCon == nullptr || nexCon->getState() != nexService::STATE_CONNECTED)
-	{
-		// not connected
-		cb(ERR_NOT_CONNECTED);
-		return;
-	}
+		return cb(ERR_NOT_CONNECTED);
 	uint8 tempNexBufferArray[128];
 	nexPacketBuffer packetBuffer(tempNexBufferArray, sizeof(tempNexBufferArray), true);
 	packetBuffer.writeU64(messageId);
-	nexCon->callMethod(NEX_PROTOCOL_FRIENDS_WIIU, 7, &packetBuffer, std::bind(genericFriendServiceNoResponseHandler, std::placeholders::_1, cb), true);
+	nexCon->callMethod(NEX_PROTOCOL_FRIENDS_WIIU, 7, &packetBuffer, [cb](nexServiceResponse_t* response) -> void
+		{
+			if (!response->isSuccessful)
+				return cb(NexFriends::ERR_RPC_FAILED);
+			else
+				return cb(NexFriends::ERR_NONE);
+		}, true);
 }
 
-void markFriendRequestsAsReceivedHandler(nexServiceResponse_t* nexResponse, std::function<void(uint32)> cb)
-{
-	if (nexResponse->isSuccessful)
-		cb(0);
-	else
-	{
-		// todo: Properly handle returned error code
-		cb(NexFriends::ERR_RPC_FAILED);
-	}
-}
-
-void NexFriends::markFriendRequestsAsReceived(uint64* messageIdList, sint32 count, std::function<void(uint32)> cb)
+void NexFriends::deleteFriendRequest(uint64 messageId, std::function<void(RpcErrorCode)> cb)
 {
 	if (nexCon == nullptr || nexCon->getState() != nexService::STATE_CONNECTED)
-	{
-		// not connected
-		cb(ERR_NOT_CONNECTED);
-		return;
-	}
+		return cb(ERR_NOT_CONNECTED);
+	uint8 tempNexBufferArray[128];
+	nexPacketBuffer packetBuffer(tempNexBufferArray, sizeof(tempNexBufferArray), true);
+	packetBuffer.writeU64(messageId);
+	nexCon->callMethod(NEX_PROTOCOL_FRIENDS_WIIU, 8, &packetBuffer, [this, cb](nexServiceResponse_t* response) -> void
+		{
+			if (!response->isSuccessful)
+				return cb(NexFriends::ERR_RPC_FAILED);
+			cb(NexFriends::ERR_NONE);
+			this->requestGetAllInformation(); // refresh friend list and send add/remove notifications
+		}, true);
+}
+
+void NexFriends::markFriendRequestsAsReceived(uint64* messageIdList, sint32 count, std::function<void(RpcErrorCode)> cb)
+{
+	if (nexCon == nullptr || nexCon->getState() != nexService::STATE_CONNECTED)
+		return cb(ERR_NOT_CONNECTED);
 	uint8 tempNexBufferArray[1024];
 	nexPacketBuffer packetBuffer(tempNexBufferArray, sizeof(tempNexBufferArray), true);
 	packetBuffer.writeU32(count);
 	for(sint32 i=0; i<count; i++)
 		packetBuffer.writeU64(messageIdList[i]);
-	nexCon->callMethod(NEX_PROTOCOL_FRIENDS_WIIU, 10, &packetBuffer, std::bind(markFriendRequestsAsReceivedHandler, std::placeholders::_1, cb), true);
-}
-
-void genericFriendServiceNoResponseHandlerWithoutCB(nexServiceResponse_t* nexResponse)
-{
-
+	nexCon->callMethod(NEX_PROTOCOL_FRIENDS_WIIU, 10, &packetBuffer, [cb](nexServiceResponse_t* response) -> void
+		{
+			if (!response->isSuccessful)
+				return cb(NexFriends::ERR_RPC_FAILED);
+			else
+				return cb(NexFriends::ERR_NONE);
+		}, true);
 }
 
 void NexFriends::updateMyPresence(nexPresenceV2& myPresence)
 {
 	this->myPresence = myPresence;
+
+	if (GetTitleIdHigh(CafeSystem::GetForegroundTitleId()) == 0x00050000)
+	{
+		myPresence.gameKey.titleId = CafeSystem::GetForegroundTitleId();
+		myPresence.gameKey.ukn = CafeSystem::GetForegroundTitleVersion();
+	}
+	else
+	{
+		myPresence.gameKey.titleId = 0; // icon will not be ??? or invalid to others
+		myPresence.gameKey.ukn = 0;
+	}
+
 	if (nexCon == nullptr || nexCon->getState() != nexService::STATE_CONNECTED)
 	{
 		// not connected
@@ -943,7 +957,7 @@ void NexFriends::updateMyPresence(nexPresenceV2& myPresence)
 	uint8 tempNexBufferArray[1024];
 	nexPacketBuffer packetBuffer(tempNexBufferArray, sizeof(tempNexBufferArray), true);
 	myPresence.writeData(&packetBuffer);
-	nexCon->callMethod(NEX_PROTOCOL_FRIENDS_WIIU, 13, &packetBuffer, std::bind(genericFriendServiceNoResponseHandlerWithoutCB, std::placeholders::_1), false);
+	nexCon->callMethod(NEX_PROTOCOL_FRIENDS_WIIU, 13, &packetBuffer, +[](nexServiceResponse_t* nexResponse){}, false);
 }
 
 void NexFriends::update()
@@ -972,7 +986,7 @@ void NexFriends::update()
 			}
 			if (timeSinceLastLoginAttempt < delayTime)
 				return;
-			forceLog_printf("NEX: Attempt async friend service login");
+			cemuLog_log(LogType::Force, "NEX: Attempt async friend service login");
 			initiateLogin();
 		}
 	}
@@ -980,7 +994,7 @@ void NexFriends::update()
 	{
 		if (this->nexCon == nullptr || this->nexCon->getState() != nexService::STATE_CONNECTED)
 		{
-			forceLog_printf("NEX: Lost friend server session");
+			cemuLog_log(LogType::Force, "NEX: Lost friend server session");
 			if (this->nexCon)
 			{
 				this->nexCon->destroy();
diff --git a/src/Cemu/nex/nexFriends.h b/src/Cemu/nex/nexFriends.h
index cb935068..05cc433f 100644
--- a/src/Cemu/nex/nexFriends.h
+++ b/src/Cemu/nex/nexFriends.h
@@ -7,10 +7,7 @@
 class nexGameKey : public nexType
 {
 public:
-	nexGameKey()
-	{
-
-	}
+	nexGameKey() = default;
 
 	nexGameKey(uint64 titleId, uint16 ukn)
 	{
@@ -175,10 +172,9 @@ public:
 	}
 
 	nexPrincipalBasicInfo(uint32 principalId, char* nnid, const nexMiiV2& mii)
+		: principalId(principalId), mii(mii)
 	{
-		this->principalId = principalId;
 		strcpy(this->nnid, nnid);
-		this->mii = mii;
 	}
 
 	nexPrincipalBasicInfo(nexPacketBuffer* pb)
@@ -218,10 +214,8 @@ public:
 	}
 
 	nexNNAInfo(uint8 countryCode, uint8 countrySubCode, const nexPrincipalBasicInfo& principalBasicInfo)
+		: countryCode(countryCode), countrySubCode(countrySubCode), principalInfo(principalBasicInfo)
 	{
-		this->countryCode = countryCode;
-		this->countrySubCode = countrySubCode;
-		this->principalInfo = principalBasicInfo;
 	}
 
 	nexNNAInfo(nexPacketBuffer* pb)
@@ -250,16 +244,13 @@ public:
 class nexPrincipalPreference : public nexType
 {
 public:
-	nexPrincipalPreference()
-	{
-
-	}
+	nexPrincipalPreference() = default;
 
 	nexPrincipalPreference(uint8 ukn0, uint8 ukn1, uint8 ukn2)
 	{
-		this->ukn0 = ukn0;
-		this->ukn1 = ukn1;
-		this->ukn2 = ukn2;
+		this->showOnline = ukn0;
+		this->showGame = ukn1;
+		this->blockFriendRequests = ukn2;
 	}
 
 	nexPrincipalPreference(nexPacketBuffer* pb)
@@ -269,21 +260,21 @@ public:
 
 	void writeData(nexPacketBuffer* pb) const override
 	{
-		pb->writeU8(ukn0);
-		pb->writeU8(ukn1);
-		pb->writeU8(ukn2);
+		pb->writeU8(showOnline);
+		pb->writeU8(showGame);
+		pb->writeU8(blockFriendRequests);
 	}
 	
 	void readData(nexPacketBuffer* pb) override
 	{
-		ukn0 = pb->readU8();
-		ukn1 = pb->readU8();
-		ukn2 = pb->readU8();
+		showOnline = pb->readU8();
+		showGame = pb->readU8();
+		blockFriendRequests = pb->readU8();
 	}
 public:
-	uint8 ukn0;
-	uint8 ukn1;
-	uint8 ukn2;
+	uint8 showOnline;
+	uint8 showGame;
+	uint8 blockFriendRequests;
 };
 
 class nexComment : public nexType
@@ -306,7 +297,9 @@ public:
 
 	void writeData(nexPacketBuffer* pb) const override
 	{
-		cemu_assert_unimplemented();
+		pb->writeU8(ukn0);
+		pb->writeString(commentString.c_str());
+		pb->writeU64(ukn1);
 	}
 
 	void readData(nexPacketBuffer* pb) override
@@ -440,7 +433,7 @@ public:
 	{
 		nnaInfo.readData(pb);
 		presence.readData(pb);
-		gameModeMessage.readData(pb);
+		comment.readData(pb);
 		friendsSinceTimestamp = pb->readU64();
 		lastOnlineTimestamp = pb->readU64();
 		ukn6 = pb->readU64();
@@ -448,7 +441,7 @@ public:
 public:
 	nexNNAInfo		nnaInfo;
 	nexPresenceV2	presence;
-	nexComment		gameModeMessage;
+	nexComment		comment;
 	uint64			friendsSinceTimestamp;
 	uint64			lastOnlineTimestamp;
 	uint64			ukn6;
@@ -514,13 +507,12 @@ public:
 	uint32		type;
 	std::string	msg;
 };
-class NexFriends;
-
-typedef void (*NEXFRIENDS_CALLBACK)(NexFriends* nexFriends, uint32 result, void* custom);
 
 class NexFriends
 {
 public:
+  	using RpcErrorCode = int; // replace with enum class later
+
 	static const int ERR_NONE = 0;
 	static const int ERR_RPC_FAILED = 1;
 	static const int ERR_UNEXPECTED_RESULT = 2;
@@ -553,27 +545,31 @@ public:
 	int getPendingFriendRequestCount();
 
 	bool requestGetAllInformation();
-	bool requestGetAllInformation(std::function<void(uint32)> cb);
 	bool addProvisionalFriendByPidGuessed(uint32 principalId);
-	void acceptFriendRequest(uint64 messageId, std::function<void(uint32)> cb);
-	bool isOnline();
 
+	// synchronous API (returns immediately)
+	bool requestGetAllInformation(std::function<void(uint32)> cb);
 	void getFriendPIDs(uint32* pidList, uint32* pidCount, sint32 offset, sint32 count, bool includeFriendRequests);
 	void getFriendRequestPIDs(uint32* pidList, uint32* pidCount, sint32 offset, sint32 count, bool includeIncoming, bool includeOutgoing);
 	bool getFriendByPID(nexFriend& friendData, uint32 pid);
 	bool getFriendRequestByPID(nexFriendRequest& friendRequestData, bool* isIncoming, uint32 searchedPid);
 	bool getFriendRequestByMessageId(nexFriendRequest& friendRequestData, bool* isIncoming, uint64 messageId);
+	bool isOnline();
+	void getMyPreference(nexPrincipalPreference& preference);
+	void getMyComment(nexComment& comment);
 
-	bool addProvisionalFriend(char* name, std::function<void(uint32)> cb);
-	void addFriendRequest(uint32 pid, const char* comment, std::function<void(uint32)> cb);
-
-	void requestPrincipleBaseInfoByPID(nexPrincipalBasicInfo* basicInfo, uint32* pidList, sint32 count, NEXFRIENDS_CALLBACK cb, void* customParam);
-	void removeFriend(uint32 pid, std::function<void(uint32)> cb);
-	void cancelOutgoingProvisionalFriendRequest(uint32 pid, std::function<void(uint32)> cb);
-	void markFriendRequestsAsReceived(uint64* messageIdList, sint32 count, std::function<void(uint32)> cb);
-
+	// asynchronous API (data has to be requested)
+	bool addProvisionalFriend(char* name, std::function<void(RpcErrorCode)> cb);
+	void addFriendRequest(uint32 pid, const char* comment, std::function<void(RpcErrorCode)> cb);
+	void requestPrincipleBaseInfoByPID(uint32* pidList, sint32 count, const std::function<void(RpcErrorCode result, std::span<nexPrincipalBasicInfo> basicInfo)>& cb);
+	void removeFriend(uint32 pid, std::function<void(RpcErrorCode)> cb);
+	void cancelOutgoingProvisionalFriendRequest(uint32 pid, std::function<void(RpcErrorCode)> cb);
+	void markFriendRequestsAsReceived(uint64* messageIdList, sint32 count, std::function<void(RpcErrorCode)> cb);
+	void acceptFriendRequest(uint64 messageId, std::function<void(RpcErrorCode)> cb);
+	void deleteFriendRequest(uint64 messageId, std::function<void(RpcErrorCode)> cb); // rejecting incoming friend request (differs from blocking friend requests)
+	bool updatePreferencesAsync(const nexPrincipalPreference newPreferences, std::function<void(RpcErrorCode)> cb);
+	bool updateCommentAsync(const nexComment newComment, std::function<void(RpcErrorCode)> cb);
 	void updateMyPresence(nexPresenceV2& myPresence);
-	bool updatePreferences(const nexPrincipalPreference& newPreferences);
 
 	void setNotificationHandler(void(*notificationHandler)(NOTIFICATION_TYPE notificationType, uint32 pid));
 
@@ -587,7 +583,6 @@ private:
 
 	static void handleResponse_acceptFriendRequest(nexService* nex, nexServiceResponse_t* response);
 	static void handleResponse_getAllInformation(nexServiceResponse_t* response, NexFriends* nexFriends, std::function<void(uint32)> cb);
-	static void handleResponse_updatePreferences(nexServiceResponse_t* response, NexFriends* nexFriends, std::function<void(uint32)> cb);
 
 	void generateNotification(NOTIFICATION_TYPE notificationType, uint32 pid);
 	void trackNotifications();
@@ -627,6 +622,8 @@ private:
 	}auth;
 	// local friend state
 	nexPresenceV2 myPresence;
+	nexPrincipalPreference myPreference;
+	nexComment myComment;
 
 	std::recursive_mutex mtx_lists;
 	std::vector<nexFriend> list_friends;
diff --git a/src/Cemu/nex/nexTypes.h b/src/Cemu/nex/nexTypes.h
index 8147836c..f43a83f2 100644
--- a/src/Cemu/nex/nexTypes.h
+++ b/src/Cemu/nex/nexTypes.h
@@ -16,7 +16,9 @@ public:
 
 class nexType
 {
-public:
+  public:
+	virtual ~nexType(){};
+
 	virtual const char* getMetaName()
 	{
 		cemu_assert_unimplemented();
@@ -222,7 +224,7 @@ public:
 		if (this->currentIndex + bufferLength > this->size)
 		{
 			readOutOfBounds = true;
-			outputStr = std::string("");
+			outputStr.clear();
 			return 0;
 		}
 		sint32 copiedLength = bufferLength;
diff --git a/src/Cemu/nex/prudp.cpp b/src/Cemu/nex/prudp.cpp
index 7700e5eb..771fe097 100644
--- a/src/Cemu/nex/prudp.cpp
+++ b/src/Cemu/nex/prudp.cpp
@@ -1,72 +1,57 @@
 #include "prudp.h"
 #include "util/crypto/md5.h"
 
-#include<bitset>
-#include<random>
+#include <bitset>
+#include <random>
 
 #include <boost/random/uniform_int.hpp>
 
-void swap(unsigned char *a, unsigned char *b) 
+static void KSA(unsigned char* key, int keyLen, unsigned char* S)
 {
-	int tmp = *a;
-	*a = *b;
-	*b = tmp;
-}
-
-void KSA(unsigned char *key, int keyLen, unsigned char *S)
-{
-	int j = 0;
-
 	for (int i = 0; i < RC4_N; i++)
 		S[i] = i;
-
-	for (int i = 0; i < RC4_N; i++) 
+	int j = 0;
+	for (int i = 0; i < RC4_N; i++)
 	{
 		j = (j + S[i] + key[i % keyLen]) % RC4_N;
-
-		swap(&S[i], &S[j]);
+		std::swap(S[i], S[j]);
 	}
 }
 
-void PRGA(unsigned char *S, unsigned char* input, int len, unsigned char* output) 
+static void PRGA(unsigned char* S, unsigned char* input, int len, unsigned char* output)
 {
-	int i = 0;
-	int j = 0;
-
-	for (size_t n = 0; n < len; n++) 
+	for (size_t n = 0; n < len; n++)
 	{
-		i = (i + 1) % RC4_N;
-		j = (j + S[i]) % RC4_N;
-
-		swap(&S[i], &S[j]);
+		int i = (i + 1) % RC4_N;
+		int j = (j + S[i]) % RC4_N;
+		std::swap(S[i], S[j]);
 		int rnd = S[(S[i] + S[j]) % RC4_N];
-
 		output[n] = rnd ^ input[n];
 	}
 }
 
-void RC4(char* key, unsigned char* input, int len, unsigned char* output) 
+static void RC4(char* key, unsigned char* input, int len, unsigned char* output)
 {
 	unsigned char S[RC4_N];
 	KSA((unsigned char*)key, (int)strlen(key), S);
 	PRGA(S, input, len, output);
 }
 
-void RC4_initCtx(RC4Ctx_t* rc4Ctx, const char* key)
+void RC4_initCtx(RC4Ctx* rc4Ctx, const char* key)
 {
 	rc4Ctx->i = 0;
 	rc4Ctx->j = 0;
 	KSA((unsigned char*)key, (int)strlen(key), rc4Ctx->S);
 }
 
-void RC4_initCtx(RC4Ctx_t* rc4Ctx, unsigned char* key, int keyLen)
+void RC4_initCtx(RC4Ctx* rc4Ctx, unsigned char* key, int keyLen)
 {
 	rc4Ctx->i = 0;
 	rc4Ctx->j = 0;
 	KSA(key, keyLen, rc4Ctx->S);
 }
 
-void RC4_transform(RC4Ctx_t* rc4Ctx, unsigned char* input, int len, unsigned char* output)
+void RC4_transform(RC4Ctx* rc4Ctx, unsigned char* input, int len, unsigned char* output)
 {
 	int i = rc4Ctx->i;
 	int j = rc4Ctx->j;
@@ -75,13 +60,10 @@ void RC4_transform(RC4Ctx_t* rc4Ctx, unsigned char* input, int len, unsigned cha
 	{
 		i = (i + 1) % RC4_N;
 		j = (j + rc4Ctx->S[i]) % RC4_N;
-
-		swap(&rc4Ctx->S[i], &rc4Ctx->S[j]);
+		std::swap(rc4Ctx->S[i], rc4Ctx->S[j]);
 		int rnd = rc4Ctx->S[(rc4Ctx->S[i] + rc4Ctx->S[j]) % RC4_N];
-
 		output[n] = rnd ^ input[n];
 	}
-
 	rc4Ctx->i = i;
 	rc4Ctx->j = j;
 }
@@ -91,34 +73,14 @@ uint32 prudpGetMSTimestamp()
 	return GetTickCount();
 }
 
-std::bitset<10000> _portUsageMask;
-
-uint16 getRandomSrcPRUDPPort()
-{
-	while (true)
-	{
-		sint32 p = rand() % 10000;
-		if (_portUsageMask.test(p))
-			continue;
-		_portUsageMask.set(p);
-		return 40000 + p;
-	}
-	return 0;
-}
-
-void releasePRUDPPort(uint16 port)
-{
-	uint32 bitIndex = port - 40000;
-	_portUsageMask.reset(bitIndex);
-}
-
 std::mt19937_64 prudpRG(GetTickCount());
-// workaround for static asserts when using uniform_int_distribution
-boost::random::uniform_int_distribution<int> prudpDis8(0, 0xFF);
+// workaround for static asserts when using uniform_int_distribution (see https://github.com/cemu-project/Cemu/issues/48)
+boost::random::uniform_int_distribution<int> prudpRandomDistribution8(0, 0xFF);
+boost::random::uniform_int_distribution<int> prudpRandomDistributionPortGen(0, 10000);
 
 uint8 prudp_generateRandomU8()
 {
-	return prudpDis8(prudpRG);
+	return prudpRandomDistribution8(prudpRG);
 }
 
 uint32 prudp_generateRandomU32()
@@ -133,7 +95,29 @@ uint32 prudp_generateRandomU32()
 	return v;
 }
 
-uint8 prudp_calculateChecksum(uint8 checksumBase, uint8* data, sint32 length)
+std::bitset<10000> _portUsageMask;
+
+static uint16 AllocateRandomSrcPRUDPPort()
+{
+	while (true)
+	{
+		sint32 p = prudpRandomDistributionPortGen(prudpRG);
+		if (_portUsageMask.test(p))
+			continue;
+		_portUsageMask.set(p);
+		return 40000 + p;
+	}
+}
+
+static void ReleasePRUDPSrcPort(uint16 port)
+{
+	cemu_assert_debug(port >= 40000);
+	uint32 bitIndex = port - 40000;
+	cemu_assert_debug(_portUsageMask.test(bitIndex));
+	_portUsageMask.reset(bitIndex);
+}
+
+static uint8 prudp_calculateChecksum(uint8 checksumBase, uint8* data, sint32 length)
 {
 	uint32 checksum32 = 0;
 	for (sint32 i = 0; i < length / 4; i++)
@@ -141,7 +125,7 @@ uint8 prudp_calculateChecksum(uint8 checksumBase, uint8* data, sint32 length)
 		checksum32 += *(uint32*)(data + i * 4);
 	}
 	uint8 checksum = checksumBase;
-	for (sint32 i = length&(~3); i < length; i++)
+	for (sint32 i = length & (~3); i < length; i++)
 	{
 		checksum += data[i];
 	}
@@ -161,16 +145,16 @@ sint32 prudpPacket::calculateSizeFromPacketData(uint8* data, sint32 length)
 		return 0;
 	// get flags fields
 	uint16 typeAndFlags = *(uint16*)(data + 0x02);
-	uint16 type = (typeAndFlags&0xF);
+	uint16 type = (typeAndFlags & 0xF);
 	uint16 flags = (typeAndFlags >> 4);
-	if ((flags&FLAG_HAS_SIZE) == 0)
+	if ((flags & FLAG_HAS_SIZE) == 0)
 		return length; // without a size field, we cant calculate the length
 	sint32 calculatedSize;
 	if (type == TYPE_SYN)
 	{
 		if (length < (0xB + 0x4 + 2))
 			return 0;
-		uint16 payloadSize = *(uint16*)(data+0xB+0x4);
+		uint16 payloadSize = *(uint16*)(data + 0xB + 0x4);
 		calculatedSize = 0xB + 0x4 + 2 + (sint32)payloadSize + 1; // base header + connection signature (SYN param) + payloadSize field + checksum after payload
 		if (calculatedSize > length)
 			return 0;
@@ -212,14 +196,14 @@ sint32 prudpPacket::calculateSizeFromPacketData(uint8* data, sint32 length)
 	return length;
 }
 
-prudpPacket::prudpPacket(prudpStreamSettings_t* streamSettings, uint8 src, uint8 dst, uint8 type, uint16 flags, uint8 sessionId, uint16 sequenceId, uint32 packetSignature)
+prudpPacket::prudpPacket(prudpStreamSettings* streamSettings, uint8 src, uint8 dst, uint8 type, uint16 flags, uint8 sessionId, uint16 sequenceId, uint32 packetSignature)
 {
 	this->src = src;
 	this->dst = dst;
 	this->type = type;
 	this->flags = flags;
 	this->sessionId = sessionId;
-	this->sequenceId = sequenceId;
+	this->m_sequenceId = sequenceId;
 	this->specifiedPacketSignature = packetSignature;
 	this->streamSettings = streamSettings;
 	this->fragmentIndex = 0;
@@ -228,7 +212,7 @@ prudpPacket::prudpPacket(prudpStreamSettings_t* streamSettings, uint8 src, uint8
 
 bool prudpPacket::requiresAck()
 {
-	return (flags&FLAG_NEED_ACK) != 0;
+	return (flags & FLAG_NEED_ACK) != 0;
 }
 
 sint32 prudpPacket::buildData(uint8* output, sint32 maxLength)
@@ -257,7 +241,7 @@ sint32 prudpPacket::buildData(uint8* output, sint32 maxLength)
 	*(uint16*)(packetBuffer + 0x02) = typeAndFlags;
 	*(uint8*)(packetBuffer + 0x04) = sessionId;
 	*(uint32*)(packetBuffer + 0x05) = packetSignature();
-	*(uint16*)(packetBuffer + 0x09) = sequenceId;
+	*(uint16*)(packetBuffer + 0x09) = m_sequenceId;
 	writeIndex = 0xB;
 	// variable fields
 	if (this->type == TYPE_SYN)
@@ -286,7 +270,9 @@ sint32 prudpPacket::buildData(uint8* output, sint32 maxLength)
 		// no data
 	}
 	else
-		assert_dbg();
+	{
+		cemu_assert_suspicious();
+	}
 	// checksum
 	*(uint8*)(packetBuffer + writeIndex) = calculateChecksum(packetBuffer, writeIndex);
 	writeIndex++;
@@ -302,7 +288,7 @@ uint32 prudpPacket::packetSignature()
 		return specifiedPacketSignature;
 	else if (type == TYPE_DATA)
 	{
-		if (packetData.size() == 0)
+		if (packetData.empty())
 			return 0x12345678;
 
 		HMACMD5Ctx ctx;
@@ -321,8 +307,7 @@ uint32 prudpPacket::packetSignature()
 
 void prudpPacket::setData(uint8* data, sint32 length)
 {
-	packetData.resize(length);
-	memcpy(&packetData.front(), data, length);
+	packetData.assign(data, data + length);
 }
 
 void prudpPacket::setFragmentIndex(uint8 fragmentIndex)
@@ -350,7 +335,8 @@ prudpIncomingPacket::prudpIncomingPacket()
 	streamSettings = nullptr;
 }
 
-prudpIncomingPacket::prudpIncomingPacket(prudpStreamSettings_t* streamSettings, uint8* data, sint32 length) : prudpIncomingPacket()
+prudpIncomingPacket::prudpIncomingPacket(prudpStreamSettings* streamSettings, uint8* data, sint32 length)
+	: prudpIncomingPacket()
 {
 	if (length < 0xB + 1)
 	{
@@ -416,7 +402,7 @@ prudpIncomingPacket::prudpIncomingPacket(prudpStreamSettings_t* streamSettings,
 
 		bool hasPayloadSize = (this->flags & prudpPacket::FLAG_HAS_SIZE) != 0;
 		// verify length
-		if ((length-readIndex) < 1+(hasPayloadSize?2:0))
+		if ((length - readIndex) < 1 + (hasPayloadSize ? 2 : 0))
 		{
 			// too short
 			isInvalid = true;
@@ -452,9 +438,7 @@ prudpIncomingPacket::prudpIncomingPacket(prudpStreamSettings_t* streamSettings,
 	}
 	else
 	{
-#ifndef PUBLIC_RELEASE
-		assert_dbg();
-#endif
+		cemu_assert_suspicious();
 	}
 }
 
@@ -475,57 +459,45 @@ void prudpIncomingPacket::decrypt()
 	RC4_transform(&streamSettings->rc4Server, &packetData.front(), (int)packetData.size(), &packetData.front());
 }
 
-#define PRUDP_VPORT(__streamType, __port) (((__streamType)<<4) | (__port))
+#define PRUDP_VPORT(__streamType, __port) (((__streamType) << 4) | (__port))
 
 prudpClient::prudpClient()
 {
-	currentConnectionState = STATE_CONNECTING;
-	serverConnectionSignature = 0;
-	clientConnectionSignature = 0;
-	hasSentCon = false;
-	outgoingSequenceId = 0;
-	incomingSequenceId = 0;
+	m_currentConnectionState = ConnectionState::Connecting;
+	m_serverConnectionSignature = 0;
+	m_clientConnectionSignature = 0;
+	m_incomingSequenceId = 0;
 
-	clientSessionId = 0;
-	serverSessionId = 0;
-
-	isSecureConnection = false;
+	m_clientSessionId = 0;
+	m_serverSessionId = 0;
 }
 
-prudpClient::~prudpClient()
+prudpClient::prudpClient(uint32 dstIp, uint16 dstPort, const char* key)
+	: prudpClient()
 {
-	if (srcPort != 0)
-	{
-		releasePRUDPPort(srcPort);
-		closesocket(socketUdp);
-	}
-}
-
-prudpClient::prudpClient(uint32 dstIp, uint16 dstPort, const char* key) : prudpClient()
-{
-	this->dstIp = dstIp;
-	this->dstPort = dstPort;
+	m_dstIp = dstIp;
+	m_dstPort = dstPort;
 	// get unused random source port
 	for (sint32 tries = 0; tries < 5; tries++)
 	{
-		srcPort = getRandomSrcPRUDPPort();
+		m_srcPort = AllocateRandomSrcPRUDPPort();
 		// create and bind udp socket
-		socketUdp = socket(AF_INET, SOCK_DGRAM, 0);
+		m_socketUdp = socket(AF_INET, SOCK_DGRAM, 0);
 		struct sockaddr_in udpServer;
 		udpServer.sin_family = AF_INET;
 		udpServer.sin_addr.s_addr = INADDR_ANY;
-		udpServer.sin_port = htons(srcPort);
-		if (bind(socketUdp, (struct sockaddr *)&udpServer, sizeof(udpServer)) == SOCKET_ERROR)
+		udpServer.sin_port = htons(m_srcPort);
+		if (bind(m_socketUdp, (struct sockaddr*)&udpServer, sizeof(udpServer)) == SOCKET_ERROR)
 		{
+			ReleasePRUDPSrcPort(m_srcPort);
+			m_srcPort = 0;
 			if (tries == 4)
 			{
-				forceLog_printf("PRUDP: Failed to bind UDP socket");
-				currentConnectionState = STATE_DISCONNECTED;
-				srcPort = 0;
+				cemuLog_log(LogType::Force, "PRUDP: Failed to bind UDP socket");
+				m_currentConnectionState = ConnectionState::Disconnected;
 				return;
 			}
-			releasePRUDPPort(srcPort);
-			closesocket(socketUdp);
+			closesocket(m_socketUdp);
 			continue;
 		}
 		else
@@ -533,237 +505,298 @@ prudpClient::prudpClient(uint32 dstIp, uint16 dstPort, const char* key) : prudpC
 	}
 	// set socket to non-blocking mode
 #if BOOST_OS_WINDOWS
-	u_long nonBlockingMode = 1;  // 1 to enable non-blocking socket
-	ioctlsocket(socketUdp, FIONBIO, &nonBlockingMode);
+	u_long nonBlockingMode = 1; // 1 to enable non-blocking socket
+	ioctlsocket(m_socketUdp, FIONBIO, &nonBlockingMode);
 #else
-	int flags = fcntl(socketUdp, F_GETFL);
-	fcntl(socketUdp, F_SETFL, flags | O_NONBLOCK);
+	int flags = fcntl(m_socketUdp, F_GETFL);
+	fcntl(m_socketUdp, F_SETFL, flags | O_NONBLOCK);
 #endif
 	// generate frequently used parameters
-	this->vport_src = PRUDP_VPORT(prudpPacket::STREAM_TYPE_SECURE, 0xF);
-	this->vport_dst = PRUDP_VPORT(prudpPacket::STREAM_TYPE_SECURE, 0x1);
+	m_srcVPort = PRUDP_VPORT(prudpPacket::STREAM_TYPE_SECURE, 0xF);
+	m_dstVPort = PRUDP_VPORT(prudpPacket::STREAM_TYPE_SECURE, 0x1);
 	// set stream settings
 	uint8 checksumBase = 0;
 	for (sint32 i = 0; key[i] != '\0'; i++)
 	{
 		checksumBase += key[i];
 	}
-	streamSettings.checksumBase = checksumBase;
+	m_streamSettings.checksumBase = checksumBase;
 	MD5_CTX md5Ctx;
 	MD5_Init(&md5Ctx);
 	MD5_Update(&md5Ctx, key, (int)strlen(key));
-	MD5_Final(streamSettings.accessKeyDigest, &md5Ctx);
+	MD5_Final(m_streamSettings.accessKeyDigest, &md5Ctx);
 	// init stream ciphers
-	RC4_initCtx(&streamSettings.rc4Server, "CD&ML");
-	RC4_initCtx(&streamSettings.rc4Client, "CD&ML");
+	RC4_initCtx(&m_streamSettings.rc4Server, "CD&ML");
+	RC4_initCtx(&m_streamSettings.rc4Client, "CD&ML");
 	// send syn packet
-	prudpPacket* synPacket = new prudpPacket(&streamSettings, vport_src, vport_dst, prudpPacket::TYPE_SYN, prudpPacket::FLAG_NEED_ACK, 0, 0, 0);
-	queuePacket(synPacket, dstIp, dstPort);
-	outgoingSequenceId++;
+	SendCurrentHandshakePacket();
 	// set incoming sequence id to 1
-	incomingSequenceId = 1;
+	m_incomingSequenceId = 1;
 }
 
-prudpClient::prudpClient(uint32 dstIp, uint16 dstPort, const char* key, authServerInfo_t* authInfo) : prudpClient(dstIp, dstPort, key)
+prudpClient::prudpClient(uint32 dstIp, uint16 dstPort, const char* key, prudpAuthServerInfo* authInfo)
+	: prudpClient(dstIp, dstPort, key)
 {
-	RC4_initCtx(&streamSettings.rc4Server, authInfo->secureKey, 16);
-	RC4_initCtx(&streamSettings.rc4Client, authInfo->secureKey, 16);
-	this->isSecureConnection = true;
-	memcpy(&this->authInfo, authInfo, sizeof(authServerInfo_t));
+	RC4_initCtx(&m_streamSettings.rc4Server, authInfo->secureKey, 16);
+	RC4_initCtx(&m_streamSettings.rc4Client, authInfo->secureKey, 16);
+	m_isSecureConnection = true;
+	memcpy(&m_authInfo, authInfo, sizeof(prudpAuthServerInfo));
 }
 
-bool prudpClient::isConnected()
+prudpClient::~prudpClient()
 {
-	return currentConnectionState == STATE_CONNECTED;
-}
-
-uint8 prudpClient::getConnectionState()
-{
-	return currentConnectionState;
-}
-
-void prudpClient::acknowledgePacket(uint16 sequenceId)
-{
-	auto it = std::begin(list_packetsWithAckReq);
-	while (it != std::end(list_packetsWithAckReq))
+	if (m_srcPort != 0)
 	{
-		if (it->packet->sequenceId == sequenceId)
+		ReleasePRUDPSrcPort(m_srcPort);
+		closesocket(m_socketUdp);
+	}
+}
+
+void prudpClient::AcknowledgePacket(uint16 sequenceId)
+{
+	auto it = std::begin(m_dataPacketsWithAckReq);
+	while (it != std::end(m_dataPacketsWithAckReq))
+	{
+		if (it->packet->GetSequenceId() == sequenceId)
 		{
 			delete it->packet;
-			list_packetsWithAckReq.erase(it);
+			m_dataPacketsWithAckReq.erase(it);
 			return;
 		}
 		it++;
 	}
 }
 
-void prudpClient::sortIncomingDataPacket(prudpIncomingPacket* incomingPacket)
+void prudpClient::SortIncomingDataPacket(std::unique_ptr<prudpIncomingPacket> incomingPacket)
 {
 	uint16 sequenceIdIncomingPacket = incomingPacket->sequenceId;
 	// find insert index
 	sint32 insertIndex = 0;
-	while (insertIndex < queue_incomingPackets.size() )
+	while (insertIndex < m_incomingPacketQueue.size())
 	{
-		uint16 seqDif = sequenceIdIncomingPacket - queue_incomingPackets[insertIndex]->sequenceId;
-		if (seqDif&0x8000)
+		uint16 seqDif = sequenceIdIncomingPacket - m_incomingPacketQueue[insertIndex]->sequenceId;
+		if (seqDif & 0x8000)
 			break; // negative seqDif -> insert before current element
-#ifndef PUBLIC_RELEASE
+#ifdef CEMU_DEBUG_ASSERT
 		if (seqDif == 0)
 			assert_dbg(); // same sequence id, sort by fragment index?
 #endif
 		insertIndex++;
 	}
-	// insert
-	sint32 currentSize = (sint32)queue_incomingPackets.size();
-	queue_incomingPackets.resize(currentSize+1);
-	for(sint32 i=currentSize; i>insertIndex; i--)
+	m_incomingPacketQueue.insert(m_incomingPacketQueue.begin() + insertIndex, std::move(incomingPacket));
+	// debug check if packets are really ordered by sequence id
+#ifdef CEMU_DEBUG_ASSERT
+	for (sint32 i = 1; i < m_incomingPacketQueue.size(); i++)
 	{
-		queue_incomingPackets[i] = queue_incomingPackets[i - 1];
+		uint16 seqDif = m_incomingPacketQueue[i]->sequenceId - m_incomingPacketQueue[i - 1]->sequenceId;
+		if (seqDif & 0x8000)
+			seqDif = -seqDif;
+		if (seqDif >= 0x8000)
+			assert_dbg();
 	}
-	queue_incomingPackets[insertIndex] = incomingPacket;
+#endif
 }
 
-sint32 prudpClient::kerberosEncryptData(uint8* input, sint32 length, uint8* output)
+sint32 prudpClient::KerberosEncryptData(uint8* input, sint32 length, uint8* output)
 {
-	RC4Ctx_t rc4Kerberos;
-	RC4_initCtx(&rc4Kerberos, this->authInfo.secureKey, 16);
+	RC4Ctx rc4Kerberos;
+	RC4_initCtx(&rc4Kerberos, m_authInfo.secureKey, 16);
 	memcpy(output, input, length);
 	RC4_transform(&rc4Kerberos, output, length, output);
 	// calculate and append hmac
-	hmacMD5(this->authInfo.secureKey, 16, output, length, output+length);
+	hmacMD5(this->m_authInfo.secureKey, 16, output, length, output + length);
 	return length + 16;
 }
 
-void prudpClient::handleIncomingPacket(prudpIncomingPacket* incomingPacket)
+// (re)sends either CON or SYN based on what stage of the login we are at
+// the sequenceId for both is hardcoded for both because we'll never send anything in between
+void prudpClient::SendCurrentHandshakePacket()
 {
-	if (incomingPacket->flags&prudpPacket::FLAG_ACK)
+	if (!m_hasSynAck)
 	{
-		// ack packet
-		acknowledgePacket(incomingPacket->sequenceId);
-		if ((incomingPacket->type == prudpPacket::TYPE_DATA || incomingPacket->type == prudpPacket::TYPE_PING) && incomingPacket->packetData.empty())
-		{
-			// ack packet
-			delete incomingPacket;
-			return;
-		}
+		// send syn (with a fixed sequenceId of 0)
+		prudpPacket synPacket(&m_streamSettings, m_srcVPort, m_dstVPort, prudpPacket::TYPE_SYN, prudpPacket::FLAG_NEED_ACK, 0, 0, 0);
+		DirectSendPacket(&synPacket);
 	}
-	// special cases
-	if (incomingPacket->type == prudpPacket::TYPE_SYN)
+	else
 	{
-		if (hasSentCon == false && incomingPacket->hasData && incomingPacket->packetData.size() == 4)
+		// send con (with a fixed sequenceId of 1)
+		prudpPacket conPacket(&m_streamSettings, m_srcVPort, m_dstVPort, prudpPacket::TYPE_CON, prudpPacket::FLAG_NEED_ACK | prudpPacket::FLAG_RELIABLE, this->m_clientSessionId, 1, m_serverConnectionSignature);
+		if (this->m_isSecureConnection)
 		{
-			this->serverConnectionSignature = *(uint32*)&incomingPacket->packetData.front();
-			this->clientSessionId = prudp_generateRandomU8();
-			// generate client session id
-			this->clientConnectionSignature = prudp_generateRandomU32();
-			// send con packet
-			prudpPacket* conPacket = new prudpPacket(&streamSettings, vport_src, vport_dst, prudpPacket::TYPE_CON, prudpPacket::FLAG_NEED_ACK|prudpPacket::FLAG_RELIABLE, this->clientSessionId, outgoingSequenceId, serverConnectionSignature);
-			outgoingSequenceId++;
+			uint8 tempBuffer[512];
+			nexPacketBuffer conData(tempBuffer, sizeof(tempBuffer), true);
+			conData.writeU32(m_clientConnectionSignature);
+			conData.writeBuffer(m_authInfo.secureTicket, m_authInfo.secureTicketLength);
+			// encrypted request data
+			uint8 requestData[4 * 3];
+			uint8 requestDataEncrypted[4 * 3 + 0x10];
+			*(uint32*)(requestData + 0x0) = m_authInfo.userPid;
+			*(uint32*)(requestData + 0x4) = m_authInfo.server.cid;
+			*(uint32*)(requestData + 0x8) = prudp_generateRandomU32(); // todo - check value
+			sint32 encryptedSize = KerberosEncryptData(requestData, sizeof(requestData), requestDataEncrypted);
+			conData.writeBuffer(requestDataEncrypted, encryptedSize);
+			conPacket.setData(conData.getDataPtr(), conData.getWriteIndex());
+		}
+		else
+		{
+			conPacket.setData((uint8*)&m_clientConnectionSignature, sizeof(uint32));
+		}
+		DirectSendPacket(&conPacket);
+	}
+	m_lastHandshakeTimestamp = prudpGetMSTimestamp();
+	m_handshakeRetryCount++;
+}
 
-			if (this->isSecureConnection)
+void prudpClient::HandleIncomingPacket(std::unique_ptr<prudpIncomingPacket> incomingPacket)
+{
+	if (incomingPacket->type == prudpPacket::TYPE_PING)
+	{
+		if (incomingPacket->flags & prudpPacket::FLAG_ACK)
+		{
+			// ack for our ping packet
+			if (incomingPacket->flags & prudpPacket::FLAG_NEED_ACK)
+				cemuLog_log(LogType::PRUDP, "[PRUDP] Received unexpected ping packet with both ACK and NEED_ACK set");
+			if (m_unacknowledgedPingCount > 0)
 			{
-				// set packet specific data (client connection signature)
-				uint8 tempBuffer[512];
-				nexPacketBuffer conData(tempBuffer, sizeof(tempBuffer), true);
-				conData.writeU32(this->clientConnectionSignature);
-				conData.writeBuffer(authInfo.secureTicket, authInfo.secureTicketLength);
-				// encrypted request data
-				uint8 requestData[4 * 3];
-				uint8 requestDataEncrypted[4 * 3 + 0x10];
-				*(uint32*)(requestData + 0x0) = authInfo.userPid;
-				*(uint32*)(requestData + 0x4) = authInfo.server.cid;
-				*(uint32*)(requestData + 0x8) = prudp_generateRandomU32(); // todo - check value
-				sint32 encryptedSize = kerberosEncryptData(requestData, sizeof(requestData), requestDataEncrypted);
-				conData.writeBuffer(requestDataEncrypted, encryptedSize);
-				conPacket->setData(conData.getDataPtr(), conData.getWriteIndex());
+				if (incomingPacket->sequenceId == m_outgoingSequenceId_ping)
+				{
+					cemuLog_log(LogType::PRUDP, "[PRUDP] Received ping packet ACK (unacknowledged count: {})", m_unacknowledgedPingCount);
+					m_unacknowledgedPingCount = 0;
+				}
+				else
+				{
+					cemuLog_log(LogType::PRUDP, "[PRUDP] Received ping packet ACK with wrong sequenceId (expected: {}, received: {})", m_outgoingSequenceId_ping, incomingPacket->sequenceId);
+				}
 			}
 			else
 			{
-				// set packet specific data (client connection signature)
-				conPacket->setData((uint8*)&this->clientConnectionSignature, sizeof(uint32));
+				cemuLog_log(LogType::PRUDP, "[PRUDP] Received ping packet ACK which we dont need");
 			}
-			// sent packet
-			queuePacket(conPacket, dstIp, dstPort);
-			// remember con packet as sent
-			hasSentCon = true;
 		}
-		delete incomingPacket;
+		else if (incomingPacket->flags & prudpPacket::FLAG_NEED_ACK)
+		{
+			// other side is asking for ping ack
+			cemuLog_log(LogType::PRUDP, "[PRUDP] Received ping packet with NEED_ACK set. Sending ACK back");
+			prudpPacket ackPacket(&m_streamSettings, m_srcVPort, m_dstVPort, prudpPacket::TYPE_PING, prudpPacket::FLAG_ACK, this->m_clientSessionId, incomingPacket->sequenceId, 0);
+			if(!incomingPacket->packetData.empty())
+				ackPacket.setData(incomingPacket->packetData.data(), incomingPacket->packetData.size());
+			DirectSendPacket(&ackPacket);
+		}
+		return;
+	}
+	else if (incomingPacket->type == prudpPacket::TYPE_SYN)
+	{
+		// syn packet from server is expected to have ACK set
+		if (!(incomingPacket->flags & prudpPacket::FLAG_ACK))
+		{
+			cemuLog_log(LogType::Force, "[PRUDP] Received SYN packet without ACK flag set"); // always log this
+			return;
+		}
+		if (m_hasSynAck || !incomingPacket->hasData || incomingPacket->packetData.size() != 4)
+		{
+			// syn already acked or not a valid syn packet
+			cemuLog_log(LogType::PRUDP, "[PRUDP] Received unexpected SYN packet");
+			return;
+		}
+		m_hasSynAck = true;
+		this->m_serverConnectionSignature = *(uint32*)&incomingPacket->packetData.front();
+		// generate client session id and connection signature
+		this->m_clientSessionId = prudp_generateRandomU8();
+		this->m_clientConnectionSignature = prudp_generateRandomU32();
+		// send con packet
+		m_handshakeRetryCount = 0;
+		SendCurrentHandshakePacket();
 		return;
 	}
 	else if (incomingPacket->type == prudpPacket::TYPE_CON)
 	{
-		// connected!
-		if (currentConnectionState == STATE_CONNECTING)
+		if (!m_hasSynAck || m_hasConAck)
 		{
-			lastPingTimestamp = prudpGetMSTimestamp();
-			serverSessionId = incomingPacket->sessionId;
-			currentConnectionState = STATE_CONNECTED;
-			//printf("Connection established. ClientSession %02x ServerSession %02x\n", clientSessionId, serverSessionId);
+			cemuLog_log(LogType::PRUDP, "[PRUDP] Received unexpected CON packet");
+			return;
 		}
-		delete incomingPacket;
+		// make sure the packet has the ACK flag set
+		if (!(incomingPacket->flags & prudpPacket::FLAG_ACK))
+		{
+			cemuLog_log(LogType::Force, "[PRUDP] Received CON packet without ACK flag set");
+			return;
+		}
+		m_hasConAck = true;
+		m_handshakeRetryCount = 0;
+		cemu_assert_debug(m_currentConnectionState == ConnectionState::Connecting);
+		// connected!
+		m_lastPingTimestamp = prudpGetMSTimestamp();
+		cemu_assert_debug(m_serverSessionId == 0);
+		m_serverSessionId = incomingPacket->sessionId;
+		m_currentConnectionState = ConnectionState::Connected;
+		cemuLog_log(LogType::PRUDP, "[PRUDP] Connection established. ClientSession {:02x} ServerSession {:02x}", m_clientSessionId, m_serverSessionId);
 		return;
 	}
 	else if (incomingPacket->type == prudpPacket::TYPE_DATA)
 	{
-		// verify some values
-		uint16 seqDist = incomingPacket->sequenceId - incomingSequenceId;
+		// handle ACK
+		if (incomingPacket->flags & prudpPacket::FLAG_ACK)
+		{
+			AcknowledgePacket(incomingPacket->sequenceId);
+			if(!incomingPacket->packetData.empty())
+				cemuLog_log(LogType::PRUDP, "[PRUDP] Received ACK data packet with payload");
+			return;
+		}
+		// send ack back if requested
+		if (incomingPacket->flags & prudpPacket::FLAG_NEED_ACK)
+		{
+			prudpPacket ackPacket(&m_streamSettings, m_srcVPort, m_dstVPort, prudpPacket::TYPE_DATA, prudpPacket::FLAG_ACK, this->m_clientSessionId, incomingPacket->sequenceId, 0);
+			DirectSendPacket(&ackPacket);
+		}
+		// skip data packets without payload
+		if (incomingPacket->packetData.empty())
+			return;
+		// verify sequence id
+		uint16 seqDist = incomingPacket->sequenceId - m_incomingSequenceId;
 		if (seqDist >= 0xC000)
 		{
 			// outdated
-			delete incomingPacket;
 			return;
 		}
 		// check if packet is already queued
-		for (auto& it : queue_incomingPackets)
+		for (auto& it : m_incomingPacketQueue)
 		{
 			if (it->sequenceId == incomingPacket->sequenceId)
 			{
 				// already queued (should check other values too, like packet type?)
-				forceLogDebug_printf("Duplicate PRUDP packet received");
-				delete incomingPacket;
+				cemuLog_log(LogType::PRUDP, "Duplicate PRUDP packet received");
 				return;
 			}
 		}
 		// put into ordered receive queue
-		sortIncomingDataPacket(incomingPacket);
+		SortIncomingDataPacket(std::move(incomingPacket));
 	}
 	else if (incomingPacket->type == prudpPacket::TYPE_DISCONNECT)
 	{
-		currentConnectionState = STATE_DISCONNECTED;
+		m_currentConnectionState = ConnectionState::Disconnected;
 		return;
 	}
 	else
 	{
-		// ignore unknown packet
-		delete incomingPacket;
-		return;
-	}
-
-	if (incomingPacket->flags&prudpPacket::FLAG_NEED_ACK && incomingPacket->type == prudpPacket::TYPE_DATA)
-	{
-		// send ack back
-		prudpPacket* ackPacket = new prudpPacket(&streamSettings, vport_src, vport_dst, prudpPacket::TYPE_DATA, prudpPacket::FLAG_ACK, this->clientSessionId, incomingPacket->sequenceId, 0);
-		queuePacket(ackPacket, dstIp, dstPort);
+		cemuLog_log(LogType::PRUDP, "[PRUDP] Received unknown packet type");
 	}
 }
 
-bool prudpClient::update()
+bool prudpClient::Update()
 {
-	if (currentConnectionState == STATE_DISCONNECTED)
-	{
+	if (m_currentConnectionState == ConnectionState::Disconnected)
 		return false;
-	}
 	uint32 currentTimestamp = prudpGetMSTimestamp();
 	// check for incoming packets
 	uint8 receiveBuffer[4096];
 	while (true)
 	{
-		sockaddr receiveFrom = { 0 };
+		sockaddr receiveFrom = {0};
 		socklen_t receiveFromLen = sizeof(receiveFrom);
-		sint32 r = recvfrom(socketUdp, (char*)receiveBuffer, sizeof(receiveBuffer), 0, &receiveFrom, &receiveFromLen);
+		sint32 r = recvfrom(m_socketUdp, (char*)receiveBuffer, sizeof(receiveBuffer), 0, &receiveFrom, &receiveFromLen);
 		if (r >= 0)
 		{
-			//printf("RECV 0x%04x byte\n", r);
 			// todo: Verify sender (receiveFrom)
 			// calculate packet size
 			sint32 pIdx = 0;
@@ -772,176 +805,198 @@ bool prudpClient::update()
 				sint32 packetLength = prudpPacket::calculateSizeFromPacketData(receiveBuffer + pIdx, r - pIdx);
 				if (packetLength <= 0 || (pIdx + packetLength) > r)
 				{
-					//printf("Invalid packet length\n");
+					cemuLog_log(LogType::Force, "[PRUDP] Invalid packet length");
 					break;
 				}
-				prudpIncomingPacket* incomingPacket = new prudpIncomingPacket(&streamSettings, receiveBuffer + pIdx, packetLength);
+				auto incomingPacket = std::make_unique<prudpIncomingPacket>(&m_streamSettings, receiveBuffer + pIdx, packetLength);
 				pIdx += packetLength;
 				if (incomingPacket->hasError())
 				{
-					delete incomingPacket;
+					cemuLog_log(LogType::Force, "[PRUDP] Packet error");
 					break;
 				}
-				if (incomingPacket->type != prudpPacket::TYPE_CON && incomingPacket->sessionId != serverSessionId)
+				if (incomingPacket->type != prudpPacket::TYPE_CON && incomingPacket->sessionId != m_serverSessionId)
 				{
-					delete incomingPacket;
+					cemuLog_log(LogType::PRUDP, "[PRUDP] Invalid session id");
 					continue; // different session
 				}
-				handleIncomingPacket(incomingPacket);
+				HandleIncomingPacket(std::move(incomingPacket));
 			}
 		}
 		else
 			break;
 	}
 	// check for ack timeouts
-	for (auto &it : list_packetsWithAckReq)
+	for (auto& it : m_dataPacketsWithAckReq)
 	{
 		if ((currentTimestamp - it.lastRetryTimestamp) >= 2300)
 		{
 			if (it.retryCount >= 7)
 			{
 				// after too many retries consider the connection dead
-				currentConnectionState = STATE_DISCONNECTED;
+				m_currentConnectionState = ConnectionState::Disconnected;
 			}
 			// resend
-			directSendPacket(it.packet, dstIp, dstPort);
+			DirectSendPacket(it.packet);
 			it.lastRetryTimestamp = currentTimestamp;
 			it.retryCount++;
 		}
 	}
-	// check if we need to send another ping
-	if (currentConnectionState == STATE_CONNECTED && (currentTimestamp - lastPingTimestamp) >= 20000)
+	if (m_currentConnectionState == ConnectionState::Connecting)
 	{
-		// send ping
-		prudpPacket* pingPacket = new prudpPacket(&streamSettings, vport_src, vport_dst, prudpPacket::TYPE_PING, prudpPacket::FLAG_NEED_ACK | prudpPacket::FLAG_RELIABLE, this->clientSessionId, this->outgoingSequenceId, serverConnectionSignature);
-		this->outgoingSequenceId++; // increase since prudpPacket::FLAG_RELIABLE is set (note: official Wii U friends client sends ping packets without FLAG_RELIABLE)
-		queuePacket(pingPacket, dstIp, dstPort);
-		lastPingTimestamp = currentTimestamp;
+		// check if we need to resend SYN or CON
+		uint32 timeSinceLastHandshake = currentTimestamp - m_lastHandshakeTimestamp;
+		if (timeSinceLastHandshake >= 1200)
+		{
+			if (m_handshakeRetryCount >= 5)
+			{
+				// too many retries, assume the other side doesn't listen
+				m_currentConnectionState = ConnectionState::Disconnected;
+				cemuLog_log(LogType::PRUDP, "PRUDP: Failed to connect");
+				return false;
+			}
+			SendCurrentHandshakePacket();
+		}
+	}
+	else if (m_currentConnectionState == ConnectionState::Connected)
+	{
+		// handle pings
+		if (m_unacknowledgedPingCount != 0) // counts how many times we sent a ping packet (for the current sequenceId) without receiving an ack
+		{
+			// we are waiting for the ack of the previous ping, but it hasn't arrived yet so send another ping packet
+			if ((currentTimestamp - m_lastPingTimestamp) >= 1500)
+			{
+				cemuLog_log(LogType::PRUDP, "[PRUDP] Resending ping packet (no ack received)");
+				if (m_unacknowledgedPingCount >= 10)
+				{
+					// too many unacknowledged pings, assume the connection is dead
+					m_currentConnectionState = ConnectionState::Disconnected;
+					cemuLog_log(LogType::PRUDP, "PRUDP: Connection did not receive a ping response in a while. Assuming disconnect");
+					return false;
+				}
+				// resend the ping packet
+				prudpPacket pingPacket(&m_streamSettings, m_srcVPort, m_dstVPort, prudpPacket::TYPE_PING, prudpPacket::FLAG_NEED_ACK, this->m_clientSessionId, this->m_outgoingSequenceId_ping, m_serverConnectionSignature);
+				DirectSendPacket(&pingPacket);
+				m_unacknowledgedPingCount++;
+				m_lastPingTimestamp = currentTimestamp;
+			}
+		}
+		else
+		{
+			if ((currentTimestamp - m_lastPingTimestamp) >= 20000)
+			{
+				cemuLog_log(LogType::PRUDP, "[PRUDP] Sending new ping packet with sequenceId {}", this->m_outgoingSequenceId_ping + 1);
+				// start a new ping packet with a new sequenceId. Note that ping packets have their own sequenceId and acknowledgement happens by manually comparing the incoming ping ACK against the last sent sequenceId
+				// only one unacknowledged ping packet can be in flight at a time. We will resend the same ping packet until we receive an ack
+				m_outgoingSequenceId_ping++; // increment before sending. The first ping has a sequenceId of 1
+				prudpPacket pingPacket(&m_streamSettings, m_srcVPort, m_dstVPort, prudpPacket::TYPE_PING, prudpPacket::FLAG_NEED_ACK, this->m_clientSessionId, this->m_outgoingSequenceId_ping, m_serverConnectionSignature);
+				DirectSendPacket(&pingPacket);
+				m_unacknowledgedPingCount++;
+				m_lastPingTimestamp = currentTimestamp;
+			}
+		}
 	}
 	return false;
 }
 
-void prudpClient::directSendPacket(prudpPacket* packet, uint32 dstIp, uint16 dstPort)
+void prudpClient::DirectSendPacket(prudpPacket* packet)
 {
 	uint8 packetBuffer[prudpPacket::PACKET_RAW_SIZE_MAX];
-
 	sint32 len = packet->buildData(packetBuffer, prudpPacket::PACKET_RAW_SIZE_MAX);
-
 	sockaddr_in destAddr;
 	destAddr.sin_family = AF_INET;
-	destAddr.sin_port = htons(dstPort);
-	destAddr.sin_addr.s_addr = dstIp;
-	sendto(socketUdp, (const char*)packetBuffer, len, 0, (const sockaddr*)&destAddr, sizeof(destAddr));
+	destAddr.sin_port = htons(m_dstPort);
+	destAddr.sin_addr.s_addr = m_dstIp;
+	sendto(m_socketUdp, (const char*)packetBuffer, len, 0, (const sockaddr*)&destAddr, sizeof(destAddr));
 }
 
-void prudpClient::queuePacket(prudpPacket* packet, uint32 dstIp, uint16 dstPort)
+void prudpClient::QueuePacket(prudpPacket* packet)
 {
+	cemu_assert_debug(packet->GetType() == prudpPacket::TYPE_DATA); // only data packets should be queued
 	if (packet->requiresAck())
 	{
 		// remember this packet until we receive the ack
-		prudpAckRequired_t ackRequired = { 0 };
-		ackRequired.packet = packet;
-		ackRequired.initialSendTimestamp = prudpGetMSTimestamp();
-		ackRequired.lastRetryTimestamp = ackRequired.initialSendTimestamp;
-		list_packetsWithAckReq.push_back(ackRequired);
-		directSendPacket(packet, dstIp, dstPort);
+		m_dataPacketsWithAckReq.emplace_back(packet, prudpGetMSTimestamp());
+		DirectSendPacket(packet);
 	}
 	else
 	{
-		directSendPacket(packet, dstIp, dstPort);
+		DirectSendPacket(packet);
 		delete packet;
 	}
 }
 
-void prudpClient::sendDatagram(uint8* input, sint32 length, bool reliable)
+void prudpClient::SendDatagram(uint8* input, sint32 length, bool reliable)
 {
-	if (reliable == false)
-	{
-		assert_dbg(); // todo
-	}
+	cemu_assert_debug(reliable); // non-reliable packets require correct sequenceId handling and testing
+	cemu_assert_debug(m_hasSynAck && m_hasConAck); // cant send data packets before we are connected
 	if (length >= 0x300)
-		assert_dbg(); // too long, need to split into multiple fragments
-
+	{
+		cemuLog_logOnce(LogType::Force, "PRUDP: Datagram too long. Fragmentation not implemented yet");
+	}
 	// single fragment data packet
-	prudpPacket* packet = new prudpPacket(&streamSettings, vport_src, vport_dst, prudpPacket::TYPE_DATA, prudpPacket::FLAG_NEED_ACK | prudpPacket::FLAG_RELIABLE, clientSessionId, outgoingSequenceId, 0);
-	outgoingSequenceId++;
+	uint16 flags = prudpPacket::FLAG_NEED_ACK;
+	if (reliable)
+		flags |= prudpPacket::FLAG_RELIABLE;
+	prudpPacket* packet = new prudpPacket(&m_streamSettings, m_srcVPort, m_dstVPort, prudpPacket::TYPE_DATA, flags, m_clientSessionId, m_outgoingReliableSequenceId, 0);
+	if (reliable)
+		m_outgoingReliableSequenceId++;
 	packet->setFragmentIndex(0);
 	packet->setData(input, length);
-	queuePacket(packet, dstIp, dstPort);
+	QueuePacket(packet);
 }
 
-uint16 prudpClient::getSourcePort()
+sint32 prudpClient::ReceiveDatagram(std::vector<uint8>& outputBuffer)
 {
-	return this->srcPort;
-}
-
-SOCKET prudpClient::getSocket()
-{
-	if (currentConnectionState == STATE_DISCONNECTED)
-	{
-		return INVALID_SOCKET;
-	}
-	return this->socketUdp;
-}
-
-sint32 prudpClient::receiveDatagram(std::vector<uint8>& outputBuffer)
-{
-	if (queue_incomingPackets.empty())
+	outputBuffer.clear();
+	if (m_incomingPacketQueue.empty())
 		return -1;
-	prudpIncomingPacket* incomingPacket = queue_incomingPackets[0];
-	if (incomingPacket->sequenceId != this->incomingSequenceId)
+	prudpIncomingPacket* frontPacket = m_incomingPacketQueue[0].get();
+	if (frontPacket->sequenceId != this->m_incomingSequenceId)
 		return -1;
-
-	if (incomingPacket->fragmentIndex == 0)
+	if (frontPacket->fragmentIndex == 0)
 	{
 		// single-fragment packet
 		// decrypt
-		incomingPacket->decrypt();
+		frontPacket->decrypt();
 		// read data
-		sint32 datagramLen = (sint32)incomingPacket->packetData.size();
-		if (datagramLen > 0)
+		if (!frontPacket->packetData.empty())
 		{
-			// resize buffer if necessary
-			if (datagramLen > outputBuffer.size())
-				outputBuffer.resize(datagramLen);
-			// to conserve memory we will also shrink the buffer if it was previously extended beyond 64KB
-			constexpr size_t BUFFER_TARGET_SIZE = 1024 * 64;
-			if (datagramLen < BUFFER_TARGET_SIZE && outputBuffer.size() > BUFFER_TARGET_SIZE)
+			// to conserve memory we will also shrink the buffer if it was previously extended beyond 32KB
+			constexpr size_t BUFFER_TARGET_SIZE = 1024 * 32;
+			if (frontPacket->packetData.size() < BUFFER_TARGET_SIZE && outputBuffer.capacity() > BUFFER_TARGET_SIZE)
+			{
 				outputBuffer.resize(BUFFER_TARGET_SIZE);
-			// copy datagram to buffer
-			memcpy(outputBuffer.data(), &incomingPacket->packetData.front(), datagramLen);
+				outputBuffer.shrink_to_fit();
+				outputBuffer.clear();
+			}
+			// write packet data to output buffer
+			cemu_assert_debug(outputBuffer.empty());
+			outputBuffer.insert(outputBuffer.end(), frontPacket->packetData.begin(), frontPacket->packetData.end());
 		}
-		delete incomingPacket;
-		// remove packet from queue
-		sint32 size = (sint32)queue_incomingPackets.size();
-		size--;
-		for (sint32 i = 0; i < size; i++)
-		{
-			queue_incomingPackets[i] = queue_incomingPackets[i + 1];
-		}
-		queue_incomingPackets.resize(size);
+		m_incomingPacketQueue.erase(m_incomingPacketQueue.begin());
 		// advance expected sequence id
-		this->incomingSequenceId++;
-		return datagramLen;
+		this->m_incomingSequenceId++;
+		return (sint32)outputBuffer.size();
 	}
 	else
 	{
 		// multi-fragment packet
-		if (incomingPacket->fragmentIndex != 1)
+		if (frontPacket->fragmentIndex != 1)
 			return -1; // first packet of the chain not received yet
 		// verify chain
 		sint32 packetIndex = 1;
 		sint32 chainLength = -1; // if full chain found, set to count of packets
-		for(sint32 i=1; i<queue_incomingPackets.size(); i++)
+		for (sint32 i = 1; i < m_incomingPacketQueue.size(); i++)
 		{
-			uint8 itFragmentIndex = queue_incomingPackets[packetIndex]->fragmentIndex;
+			uint8 itFragmentIndex = m_incomingPacketQueue[packetIndex]->fragmentIndex;
 			// sequence id must increase by 1 for every packet
-			if (queue_incomingPackets[packetIndex]->sequenceId != (this->incomingSequenceId+i) )
+			if (m_incomingPacketQueue[packetIndex]->sequenceId != (m_incomingSequenceId + i))
 				return -1; // missing packets
 			// last fragment in chain is marked by fragment index 0
 			if (itFragmentIndex == 0)
 			{
-				chainLength = i+1;
+				chainLength = i + 1;
 				break;
 			}
 			packetIndex++;
@@ -949,35 +1004,17 @@ sint32 prudpClient::receiveDatagram(std::vector<uint8>& outputBuffer)
 		if (chainLength < 1)
 			return -1; // chain not complete
 		// extract data from packet chain
-		sint32 writeIndex = 0;
+		cemu_assert_debug(outputBuffer.empty());
 		for (sint32 i = 0; i < chainLength; i++)
 		{
-			incomingPacket = queue_incomingPackets[i];
-			// decrypt
+			prudpIncomingPacket* incomingPacket = m_incomingPacketQueue[i].get();
 			incomingPacket->decrypt();
-			// extract data
-			sint32 datagramLen = (sint32)incomingPacket->packetData.size();
-			if (datagramLen > 0)
-			{
-				// make sure output buffer can fit the data
-				if ((writeIndex + datagramLen) > outputBuffer.size())
-					outputBuffer.resize(writeIndex + datagramLen + 4 * 1024);
-				memcpy(outputBuffer.data()+writeIndex, &incomingPacket->packetData.front(), datagramLen);
-				writeIndex += datagramLen;
-			}
-			// free packet memory
-			delete incomingPacket;
+			outputBuffer.insert(outputBuffer.end(), incomingPacket->packetData.begin(), incomingPacket->packetData.end());
 		}
 		// remove packets from queue
-		sint32 size = (sint32)queue_incomingPackets.size();
-		size -= chainLength;
-		for (sint32 i = 0; i < size; i++)
-		{
-			queue_incomingPackets[i] = queue_incomingPackets[i + chainLength];
-		}
-		queue_incomingPackets.resize(size);
-		this->incomingSequenceId += chainLength;
-		return writeIndex;
+		m_incomingPacketQueue.erase(m_incomingPacketQueue.begin(), m_incomingPacketQueue.begin() + chainLength);
+		m_incomingSequenceId += chainLength;
+		return (sint32)outputBuffer.size();
 	}
 	return -1;
 }
diff --git a/src/Cemu/nex/prudp.h b/src/Cemu/nex/prudp.h
index aa68f4f6..3192c833 100644
--- a/src/Cemu/nex/prudp.h
+++ b/src/Cemu/nex/prudp.h
@@ -4,26 +4,26 @@
 
 #define RC4_N 256
 
-typedef struct
+struct RC4Ctx
 {
 	unsigned char S[RC4_N];
 	int i;
 	int j;
-}RC4Ctx_t;
+};
 
-void RC4_initCtx(RC4Ctx_t* rc4Ctx, char *key);
-void RC4_initCtx(RC4Ctx_t* rc4Ctx, unsigned char* key, int keyLen);
-void RC4_transform(RC4Ctx_t* rc4Ctx, unsigned char* input, int len, unsigned char* output);
+void RC4_initCtx(RC4Ctx* rc4Ctx, const char* key);
+void RC4_initCtx(RC4Ctx* rc4Ctx, unsigned char* key, int keyLen);
+void RC4_transform(RC4Ctx* rc4Ctx, unsigned char* input, int len, unsigned char* output);
 
-typedef struct
+struct prudpStreamSettings
 {
 	uint8 checksumBase; // calculated from key
 	uint8 accessKeyDigest[16]; // MD5 hash of key
-	RC4Ctx_t rc4Client;
-	RC4Ctx_t rc4Server;
-}prudpStreamSettings_t;
+	RC4Ctx rc4Client;
+	RC4Ctx rc4Server;
+};
 
-typedef struct
+struct prudpStationUrl
 {
 	uint32 ip;
 	uint16 port;
@@ -32,19 +32,17 @@ typedef struct
 	sint32 sid;
 	sint32 stream;
 	sint32 type;
-}stationUrl_t;
+};
 
-typedef struct
+struct prudpAuthServerInfo
 {
 	uint32 userPid;
 	uint8 secureKey[16];
 	uint8 kerberosKey[16];
 	uint8 secureTicket[1024];
 	sint32 secureTicketLength;
-	stationUrl_t server;
-}authServerInfo_t;
-
-uint8 prudp_calculateChecksum(uint8 checksumBase, uint8* data, sint32 length);
+	prudpStationUrl server;
+};
 
 class prudpPacket
 {
@@ -66,20 +64,19 @@ public:
 
 	static sint32 calculateSizeFromPacketData(uint8* data, sint32 length);
 
-	prudpPacket(prudpStreamSettings_t* streamSettings, uint8 src, uint8 dst, uint8 type, uint16 flags, uint8 sessionId, uint16 sequenceId, uint32 packetSignature);
+	prudpPacket(prudpStreamSettings* streamSettings, uint8 src, uint8 dst, uint8 type, uint16 flags, uint8 sessionId, uint16 sequenceId, uint32 packetSignature);
 	bool requiresAck();
 	void setData(uint8* data, sint32 length);
 	void setFragmentIndex(uint8 fragmentIndex);
 	sint32 buildData(uint8* output, sint32 maxLength);
+	uint8 GetType() const { return type; }
+	uint16 GetSequenceId() const { return m_sequenceId; }
 
 private:
 	uint32 packetSignature();
 
 	uint8 calculateChecksum(uint8* data, sint32 length);
 
-public:
-	uint16 sequenceId;
-
 private:
 	uint8 src;
 	uint8 dst;
@@ -88,15 +85,17 @@ private:
 	uint16 flags;
 	uint8 sessionId;
 	uint32 specifiedPacketSignature;
-	prudpStreamSettings_t* streamSettings;
+	prudpStreamSettings* streamSettings;
 	std::vector<uint8> packetData;
 	bool isEncrypted;
+	uint16 m_sequenceId{0};
+
 };
 
 class prudpIncomingPacket
 {
 public:
-	prudpIncomingPacket(prudpStreamSettings_t* streamSettings, uint8* data, sint32 length);
+	prudpIncomingPacket(prudpStreamSettings* streamSettings, uint8* data, sint32 length);
 
 	bool hasError();
 
@@ -121,80 +120,91 @@ public:
 
 private:
 	bool isInvalid = false;
-	prudpStreamSettings_t* streamSettings = nullptr;
-
+	prudpStreamSettings* streamSettings = nullptr;
 };
 
-typedef struct
-{
-	prudpPacket* packet;
-	uint32 initialSendTimestamp;
-	uint32 lastRetryTimestamp;
-	sint32 retryCount;
-}prudpAckRequired_t;
-
 class prudpClient
 {
+	struct PacketWithAckRequired
+	{
+		PacketWithAckRequired(prudpPacket* packet, uint32 initialSendTimestamp) :
+			packet(packet), initialSendTimestamp(initialSendTimestamp), lastRetryTimestamp(initialSendTimestamp) { }
+		prudpPacket* packet;
+		uint32 initialSendTimestamp;
+		uint32 lastRetryTimestamp;
+		sint32 retryCount{0};
+	};
 public:
-	static const int STATE_CONNECTING = 0;
-	static const int STATE_CONNECTED = 1;
-	static const int STATE_DISCONNECTED = 2;
+	enum class ConnectionState : uint8
+	{
+	  Connecting,
+	  Connected,
+	  Disconnected
+  };
 
-public:
 	prudpClient(uint32 dstIp, uint16 dstPort, const char* key);
-	prudpClient(uint32 dstIp, uint16 dstPort, const char* key, authServerInfo_t* authInfo);
+	prudpClient(uint32 dstIp, uint16 dstPort, const char* key, prudpAuthServerInfo* authInfo);
 	~prudpClient();
 
-	bool isConnected();
+	bool IsConnected() const { return m_currentConnectionState == ConnectionState::Connected; }
+	ConnectionState GetConnectionState() const { return m_currentConnectionState; }
+	uint16 GetSourcePort() const { return m_srcPort; }
 
-	uint8 getConnectionState();
-	void acknowledgePacket(uint16 sequenceId);
-	void sortIncomingDataPacket(prudpIncomingPacket* incomingPacket);
-	void handleIncomingPacket(prudpIncomingPacket* incomingPacket);
-	bool update(); // check for new incoming packets, returns true if receiveDatagram() should be called
+	bool Update(); // update connection state and check for incoming packets. Returns true if ReceiveDatagram() should be called
 
-	sint32 receiveDatagram(std::vector<uint8>& outputBuffer);
-	void sendDatagram(uint8* input, sint32 length, bool reliable = true);
-
-	uint16 getSourcePort();
-
-	SOCKET getSocket();
+	sint32 ReceiveDatagram(std::vector<uint8>& outputBuffer);
+	void SendDatagram(uint8* input, sint32 length, bool reliable = true);
 
 private:
 	prudpClient();
-	void directSendPacket(prudpPacket* packet, uint32 dstIp, uint16 dstPort);
-	sint32 kerberosEncryptData(uint8* input, sint32 length, uint8* output);
-	void queuePacket(prudpPacket* packet, uint32 dstIp, uint16 dstPort);
+
+	void HandleIncomingPacket(std::unique_ptr<prudpIncomingPacket> incomingPacket);
+	void DirectSendPacket(prudpPacket* packet);
+	sint32 KerberosEncryptData(uint8* input, sint32 length, uint8* output);
+	void QueuePacket(prudpPacket* packet);
+
+	void AcknowledgePacket(uint16 sequenceId);
+	void SortIncomingDataPacket(std::unique_ptr<prudpIncomingPacket> incomingPacket);
+
+	void SendCurrentHandshakePacket();
 
 private:
-	uint16 srcPort;
-	uint32 dstIp;
-	uint16 dstPort;
-	uint8 vport_src;
-	uint8 vport_dst;
-	prudpStreamSettings_t streamSettings;
-	std::vector<prudpAckRequired_t> list_packetsWithAckReq;
-	std::vector<prudpIncomingPacket*> queue_incomingPackets;
-	
+	uint16 m_srcPort;
+	uint32 m_dstIp;
+	uint16 m_dstPort;
+	uint8 m_srcVPort;
+	uint8 m_dstVPort;
+	prudpStreamSettings m_streamSettings;
+	std::vector<PacketWithAckRequired> m_dataPacketsWithAckReq;
+	std::vector<std::unique_ptr<prudpIncomingPacket>> m_incomingPacketQueue;
+
+	// connection handshake state
+	bool m_hasSynAck{false};
+	bool m_hasConAck{false};
+	uint32 m_lastHandshakeTimestamp{0};
+	uint8 m_handshakeRetryCount{0};
+
 	// connection
-	uint8 currentConnectionState;
-	uint32 serverConnectionSignature;
-	uint32 clientConnectionSignature;
-	bool hasSentCon;
-	uint32 lastPingTimestamp;
+	ConnectionState m_currentConnectionState;
+	uint32 m_serverConnectionSignature;
+	uint32 m_clientConnectionSignature;
+	uint32 m_lastPingTimestamp;
 
-	uint16 outgoingSequenceId;
-	uint16 incomingSequenceId;
+	uint16 m_outgoingReliableSequenceId{2}; // 1 is reserved for CON
+	uint16 m_incomingSequenceId;
 
-	uint8 clientSessionId;
-	uint8 serverSessionId;
+	uint16 m_outgoingSequenceId_ping{0};
+	uint8 m_unacknowledgedPingCount{0};
+
+	uint8 m_clientSessionId;
+	uint8 m_serverSessionId;
 
 	// secure
-	bool isSecureConnection;
-	authServerInfo_t authInfo;
+	bool m_isSecureConnection{false};
+	prudpAuthServerInfo m_authInfo;
 
 	// socket
-	SOCKET socketUdp;
+	SOCKET m_socketUdp;
 };
 
 uint32 prudpGetMSTimestamp();
\ No newline at end of file
diff --git a/src/Common/CMakeLists.txt b/src/Common/CMakeLists.txt
index f1654f31..9a764593 100644
--- a/src/Common/CMakeLists.txt
+++ b/src/Common/CMakeLists.txt
@@ -1,8 +1,28 @@
-project(CemuCommon)
-
-file(GLOB CPP_FILES *.cpp)
-file(GLOB H_FILES *.h)
-add_library(CemuCommon ${CPP_FILES} ${H_FILES})
+add_library(CemuCommon 
+  betype.h
+  cpu_features.cpp
+  cpu_features.h
+  enumFlags.h
+  ExceptionHandler/ExceptionHandler.cpp
+  ExceptionHandler/ExceptionHandler.h
+  FileStream.h
+  GLInclude/glext.h
+  GLInclude/glFunctions.h
+  GLInclude/GLInclude.h
+  GLInclude/glxext.h
+  GLInclude/khrplatform.h
+  GLInclude/wglext.h
+  MemPtr.h
+  platform.h
+  precompiled.cpp
+  precompiled.h
+  socket.h
+  StackAllocator.h
+  SysAllocator.cpp
+  SysAllocator.h
+  CafeString.h
+  version.h
+)
 
 set_property(TARGET CemuCommon PROPERTY MSVC_RUNTIME_LIBRARY "MultiThreaded$<$<CONFIG:Debug>:Debug>")
 
@@ -16,16 +36,22 @@ if(WIN32)
 else()
 target_sources(CemuCommon
 PRIVATE
+    unix/date.h
+    unix/fast_float.h
     unix/platform.cpp
     unix/platform.h
     unix/FileStream_unix.cpp
+    unix/FileStream_unix.h
     ExceptionHandler/ExceptionHandler_posix.cpp
 )
 endif()
 
-target_sources(CemuCommon PRIVATE
-	ExceptionHandler/ExceptionHandler.h
-)
+if(UNIX AND NOT APPLE)
+	target_sources(CemuCommon PRIVATE
+		ExceptionHandler/ELFSymbolTable.cpp
+		ExceptionHandler/ELFSymbolTable.h
+	)
+endif()
 
 # All the targets wanting to use the precompiled.h header
 # have to link to CemuCommon
diff --git a/src/Common/CafeString.h b/src/Common/CafeString.h
new file mode 100644
index 00000000..57fc72da
--- /dev/null
+++ b/src/Common/CafeString.h
@@ -0,0 +1,78 @@
+#pragma once
+#include "betype.h"
+#include "util/helpers/StringHelpers.h"
+
+/* Helper classes to represent CafeOS strings in emulated memory */
+template <size_t N>
+class CafeString // fixed buffer size, null-terminated, PPC char
+{
+  public:
+	bool assign(std::string_view sv)
+	{
+		if (sv.size()+1 >= N)
+		{
+			memcpy(data, sv.data(), sv.size()-1);
+			data[sv.size()-1] = '\0';
+			return false;
+		}
+		memcpy(data, sv.data(), sv.size());
+		data[sv.size()] = '\0';
+		return true;
+	}
+
+	const char* c_str()
+	{
+		return (const char*)data;
+	}
+
+	uint8be data[N];
+};
+
+template <size_t N>
+class CafeWideString // fixed buffer size, null-terminated, PPC wchar_t (16bit big-endian)
+{
+  public:
+	bool assign(const uint16be* input)
+	{
+		size_t i = 0;
+		while(input[i])
+		{
+			if(i >= N-1)
+			{
+				data[N-1] = 0;
+				return false;
+			}
+			data[i] = input[i];
+			i++;
+		}
+		data[i] = 0;
+		return true;
+	}
+
+	bool assignFromUTF8(std::string_view sv)
+	{
+		std::vector<uint16be> beStr = StringHelpers::FromUtf8(sv);
+		if(beStr.size() > N-1)
+		{
+			memcpy(data, beStr.data(), (N-1)*sizeof(uint16be));
+			data[N-1] = 0;
+			return false;
+		}
+		memcpy(data, beStr.data(), beStr.size()*sizeof(uint16be));
+		data[beStr.size()] = '\0';
+		return true;
+	}
+
+	uint16be data[N];
+};
+
+namespace CafeStringHelpers
+{
+	static uint32 Length(const uint16be* input, uint32 maxLength)
+	{
+		uint32 i = 0;
+		while(input[i] && i < maxLength)
+			i++;
+		return i;
+	}
+};
diff --git a/src/Common/ExceptionHandler/ELFSymbolTable.cpp b/src/Common/ExceptionHandler/ELFSymbolTable.cpp
new file mode 100644
index 00000000..0f297bdd
--- /dev/null
+++ b/src/Common/ExceptionHandler/ELFSymbolTable.cpp
@@ -0,0 +1,108 @@
+#include "Common/ExceptionHandler/ELFSymbolTable.h"
+#include "Common/FileStream.h"
+#include <sys/mman.h>
+#include <fcntl.h>
+
+uint16 ELFSymbolTable::FindSection(int type, const std::string_view& name)
+{
+	if (!shTable || !shStrTable)
+		return 0;
+
+	for (uint16 i = 0; i < header->e_shnum; ++i)
+	{
+		auto& entry = shTable[i];
+		if(entry.sh_type == type && std::string_view{&shStrTable[entry.sh_name]} == name)
+		{
+			return i;
+		}
+	}
+	return 0;
+}
+
+void* ELFSymbolTable::SectionPointer(uint16 index)
+{
+	return SectionPointer(shTable[index]);
+}
+
+void* ELFSymbolTable::SectionPointer(const Elf64_Shdr& section)
+{
+	return (void*)(mappedExecutable + section.sh_offset);
+}
+
+ELFSymbolTable::ELFSymbolTable()
+{
+	// create file handle
+	int fd = open("/proc/self/exe", O_RDONLY);
+	if (!fd)
+		return;
+
+	// retrieve file size.
+	struct stat filestats;
+	if (fstat(fd, &filestats))
+	{
+		close(fd);
+		return;
+	}
+	mappedExecutableSize = filestats.st_size;
+
+	// attempt to map the file
+	mappedExecutable = (uint8*)(mmap(nullptr, mappedExecutableSize, PROT_READ, MAP_PRIVATE, fd, 0));
+	close(fd);
+	if (!mappedExecutable)
+		return;
+
+	// verify signature
+	header = (Elf64_Ehdr*)(mappedExecutable);
+	constexpr uint8 signature[] = {0x7f, 0x45, 0x4c, 0x46};
+	for (size_t i = 0; i < 4; ++i)
+	{
+		if (signature[i] != header->e_ident[i])
+		{
+			return;
+		}
+	}
+
+	shTable = (Elf64_Shdr*)(mappedExecutable + header->e_shoff);
+
+	Elf64_Shdr& shStrn = shTable[header->e_shstrndx];
+	shStrTable = (char*)(mappedExecutable + shStrn.sh_offset);
+
+	strTable = (char*)SectionPointer(FindSection(SHT_STRTAB, ".strtab"));
+
+	Elf64_Shdr& symTabShdr = shTable[FindSection(SHT_SYMTAB, ".symtab")];
+	if (symTabShdr.sh_entsize == 0)
+		return;
+
+	symTableLen = symTabShdr.sh_size / symTabShdr.sh_entsize;
+	symTable = (Elf64_Sym*)(SectionPointer(symTabShdr));
+}
+
+ELFSymbolTable::~ELFSymbolTable()
+{
+	if (mappedExecutable)
+		munmap(mappedExecutable, mappedExecutableSize);
+}
+
+std::string_view ELFSymbolTable::OffsetToSymbol(uint64 ptr, uint64& fromStart) const
+{
+	if(!symTable || !strTable)
+	{
+		fromStart = -1;
+		return {};
+	}
+
+	for (auto entry = symTable+1; entry < symTable+symTableLen; ++entry)
+	{
+		if (ELF64_ST_TYPE(entry->st_info) != STT_FUNC)
+			continue;
+		auto begin = entry->st_value;
+		auto size = entry->st_size;
+		if(ptr >= begin && ptr < begin+size)
+		{
+			fromStart = ptr-begin;
+			return &strTable[entry->st_name];
+		}
+	}
+	fromStart = -1;
+	return {};
+}
diff --git a/src/Common/ExceptionHandler/ELFSymbolTable.h b/src/Common/ExceptionHandler/ELFSymbolTable.h
new file mode 100644
index 00000000..89248bbb
--- /dev/null
+++ b/src/Common/ExceptionHandler/ELFSymbolTable.h
@@ -0,0 +1,32 @@
+#pragma once
+#include <memory>
+#include <elf.h>
+
+class ELFSymbolTable
+{
+public:
+	std::string_view OffsetToSymbol(uint64 ptr, uint64& fromStart) const;
+
+	ELFSymbolTable();
+	~ELFSymbolTable();
+private:
+	uint8* mappedExecutable = nullptr;
+	size_t mappedExecutableSize = 0;
+
+	Elf64_Ehdr* header = nullptr;
+
+	Elf64_Shdr* shTable = nullptr;
+	char* shStrTable = nullptr;
+
+	Elf64_Sym* symTable = nullptr;
+	uint64 symTableLen = 0;
+	char* strTable = nullptr;
+
+	uint16 FindSection(int type, const std::string_view& name);
+
+	void* SectionPointer (uint16 index);
+	void* SectionPointer(const Elf64_Shdr& section);
+
+	// ownership of mapped memory, cannot copy.
+	ELFSymbolTable(const ELFSymbolTable&) = delete;
+};
diff --git a/src/Common/ExceptionHandler/ExceptionHandler.cpp b/src/Common/ExceptionHandler/ExceptionHandler.cpp
new file mode 100644
index 00000000..7530a2eb
--- /dev/null
+++ b/src/Common/ExceptionHandler/ExceptionHandler.cpp
@@ -0,0 +1,160 @@
+#include "config/ActiveSettings.h"
+#include "config/CemuConfig.h"
+#include "Cafe/CafeSystem.h"
+#include "Cafe/OS/libs/coreinit/coreinit_Thread.h"
+#include "Cafe/HW/Espresso/PPCState.h"
+#include "Cafe/HW/Espresso/Debugger/GDBStub.h"
+#include "ExceptionHandler.h"
+
+bool crashLogCreated = false;
+
+bool CrashLog_Create()
+{
+    if (crashLogCreated)
+        return false; // only create one crashlog
+    crashLogCreated = true;
+    cemuLog_createLogFile(true);
+    CrashLog_SetOutputChannels(true, true);
+    return true;
+}
+
+static bool s_writeToStdErr{true};
+static bool s_writeToLogTxt{true};
+
+void CrashLog_SetOutputChannels(bool writeToStdErr, bool writeToLogTxt)
+{
+    s_writeToStdErr = writeToStdErr;
+    s_writeToLogTxt = writeToLogTxt;
+}
+
+// outputs to both stderr and log.txt
+void CrashLog_WriteLine(std::string_view text, bool newLine)
+{
+    if(s_writeToLogTxt)
+        cemuLog_writeLineToLog(text, false, newLine);
+    if(s_writeToStdErr)
+    {
+        fwrite(text.data(), sizeof(char), text.size(), stderr);
+        if(newLine)
+            fwrite("\n", sizeof(char), 1, stderr);
+    }
+}
+
+void CrashLog_WriteHeader(const char* header)
+{
+    CrashLog_WriteLine("-----------------------------------------");
+    CrashLog_WriteLine("   ", false);
+    CrashLog_WriteLine(header);
+    CrashLog_WriteLine("-----------------------------------------");
+}
+
+void ExceptionHandler_LogGeneralInfo()
+{
+    char dumpLine[1024];
+    // info about game
+    CrashLog_WriteLine("");
+    CrashLog_WriteHeader("Game info");
+    if (CafeSystem::IsTitleRunning())
+    {
+        CrashLog_WriteLine("Game: ", false);
+        CrashLog_WriteLine(CafeSystem::GetForegroundTitleName());
+        // title id
+        CrashLog_WriteLine(fmt::format("TitleId: {:016x}", CafeSystem::GetForegroundTitleId()));
+        // rpx hash
+        sprintf(dumpLine, "RPXHash: %08x (Update: %08x)", CafeSystem::GetRPXHashBase(), CafeSystem::GetRPXHashUpdated());
+        CrashLog_WriteLine(dumpLine);
+    }
+    else
+    {
+        CrashLog_WriteLine("Not running");
+    }
+    // info about active PPC instance:
+    CrashLog_WriteLine("");
+    CrashLog_WriteHeader("Active PPC instance");
+	PPCInterpreter_t* hCPU = PPCInterpreter_getCurrentInstance();
+    if (hCPU)
+    {
+        OSThread_t* currentThread = coreinit::OSGetCurrentThread();
+        uint32 threadPtr = memory_getVirtualOffsetFromPointer(coreinit::OSGetCurrentThread());
+        sprintf(dumpLine, "IP 0x%08x LR 0x%08x Thread 0x%08x", hCPU->instructionPointer, hCPU->spr.LR, threadPtr);
+        CrashLog_WriteLine(dumpLine);
+
+        // GPR info
+        CrashLog_WriteLine("");
+        auto gprs = hCPU->gpr;
+        sprintf(dumpLine, "r0 =%08x r1 =%08x r2 =%08x r3 =%08x r4 =%08x r5 =%08x r6 =%08x r7 =%08x", gprs[0], gprs[1], gprs[2], gprs[3], gprs[4], gprs[5], gprs[6], gprs[7]);
+        CrashLog_WriteLine(dumpLine);
+        sprintf(dumpLine, "r8 =%08x r9 =%08x r10=%08x r11=%08x r12=%08x r13=%08x r14=%08x r15=%08x", gprs[8], gprs[9], gprs[10], gprs[11], gprs[12], gprs[13], gprs[14], gprs[15]);
+        CrashLog_WriteLine(dumpLine);
+        sprintf(dumpLine, "r16=%08x r17=%08x r18=%08x r19=%08x r20=%08x r21=%08x r22=%08x r23=%08x", gprs[16], gprs[17], gprs[18], gprs[19], gprs[20], gprs[21], gprs[22], gprs[23]);
+        CrashLog_WriteLine(dumpLine);
+        sprintf(dumpLine, "r24=%08x r25=%08x r26=%08x r27=%08x r28=%08x r29=%08x r30=%08x r31=%08x", gprs[24], gprs[25], gprs[26], gprs[27], gprs[28], gprs[29], gprs[30], gprs[31]);
+        CrashLog_WriteLine(dumpLine);
+
+        // stack trace
+        MPTR currentStackVAddr = hCPU->gpr[1];
+        CrashLog_WriteLine("");
+        CrashLog_WriteHeader("PPC stack trace");
+        DebugLogStackTrace(currentThread, currentStackVAddr, true);
+
+        // stack dump
+        CrashLog_WriteLine("");
+        CrashLog_WriteHeader("PPC stack dump");
+        for (uint32 i = 0; i < 16; i++)
+        {
+            MPTR lineAddr = currentStackVAddr + i * 8 * 4;
+            if (memory_isAddressRangeAccessible(lineAddr, 8 * 4))
+            {
+                sprintf(dumpLine, "[0x%08x] %08x %08x %08x %08x - %08x %08x %08x %08x", lineAddr, memory_readU32(lineAddr + 0), memory_readU32(lineAddr + 4), memory_readU32(lineAddr + 8), memory_readU32(lineAddr + 12), memory_readU32(lineAddr + 16), memory_readU32(lineAddr + 20), memory_readU32(lineAddr + 24), memory_readU32(lineAddr + 28));
+                CrashLog_WriteLine(dumpLine);
+            }
+            else
+            {
+                sprintf(dumpLine, "[0x%08x] ?", lineAddr);
+                CrashLog_WriteLine(dumpLine);
+            }
+        }
+    }
+    else
+    {
+        CrashLog_WriteLine("Not active");
+    }
+
+    // PPC thread log
+    CrashLog_WriteLine("");
+    CrashLog_WriteHeader("PPC threads");
+    if (activeThreadCount == 0)
+    {
+        CrashLog_WriteLine("None active");
+    }
+    for (sint32 i = 0; i < activeThreadCount; i++)
+    {
+        MPTR threadItrMPTR = activeThread[i];
+        OSThread_t* threadItrBE = (OSThread_t*)memory_getPointerFromVirtualOffset(threadItrMPTR);
+
+        // get thread state
+        OSThread_t::THREAD_STATE threadState = threadItrBE->state;
+        const char* threadStateStr = "UNDEFINED";
+        if (threadItrBE->suspendCounter != 0)
+            threadStateStr = "SUSPENDED";
+        else if (threadState == OSThread_t::THREAD_STATE::STATE_NONE)
+            threadStateStr = "NONE";
+        else if (threadState == OSThread_t::THREAD_STATE::STATE_READY)
+            threadStateStr = "READY";
+        else if (threadState == OSThread_t::THREAD_STATE::STATE_RUNNING)
+            threadStateStr = "RUNNING";
+        else if (threadState == OSThread_t::THREAD_STATE::STATE_WAITING)
+            threadStateStr = "WAITING";
+        else if (threadState == OSThread_t::THREAD_STATE::STATE_MORIBUND)
+            threadStateStr = "MORIBUND";
+        // generate log line
+        uint8 affinity = threadItrBE->attr;
+        sint32 effectivePriority = threadItrBE->effectivePriority;
+        const char* threadName = "NULL";
+        if (!threadItrBE->threadName.IsNull())
+            threadName = threadItrBE->threadName.GetPtr();
+        sprintf(dumpLine, "%08x Ent %08x IP %08x LR %08x %-9s Aff %d%d%d Pri %2d Name %s", threadItrMPTR, threadItrBE->entrypoint.GetMPTR(), threadItrBE->context.srr0, _swapEndianU32(threadItrBE->context.lr), threadStateStr, (affinity >> 0) & 1, (affinity >> 1) & 1, (affinity >> 2) & 1, effectivePriority, threadName);
+        // write line to log
+        CrashLog_WriteLine(dumpLine);
+    }
+}
diff --git a/src/Common/ExceptionHandler/ExceptionHandler.h b/src/Common/ExceptionHandler/ExceptionHandler.h
index bb139ca2..845e5f7f 100644
--- a/src/Common/ExceptionHandler/ExceptionHandler.h
+++ b/src/Common/ExceptionHandler/ExceptionHandler.h
@@ -1,3 +1,10 @@
 #pragma once
 
-void ExceptionHandler_init();
\ No newline at end of file
+void ExceptionHandler_Init();
+
+bool CrashLog_Create();
+void CrashLog_SetOutputChannels(bool writeToStdErr, bool writeToLogTxt);
+void CrashLog_WriteLine(std::string_view text, bool newLine = true);
+void CrashLog_WriteHeader(const char* header);
+
+void ExceptionHandler_LogGeneralInfo();
diff --git a/src/Common/ExceptionHandler/ExceptionHandler_posix.cpp b/src/Common/ExceptionHandler/ExceptionHandler_posix.cpp
index b9ecb782..7afbf191 100644
--- a/src/Common/ExceptionHandler/ExceptionHandler_posix.cpp
+++ b/src/Common/ExceptionHandler/ExceptionHandler_posix.cpp
@@ -1,36 +1,172 @@
 #include <signal.h>
 #include <execinfo.h>
+#include <string.h>
+#include <string>
+#include "config/CemuConfig.h"
+#include "util/helpers/StringHelpers.h"
+#include "ExceptionHandler.h"
 
-void handler_SIGSEGV(int sig)
+#include "Cafe/HW/Espresso/Debugger/GDBStub.h"
+#include "Cafe/HW/Espresso/Debugger/GDBBreakpoints.h"
+
+#if BOOST_OS_LINUX
+#include "ELFSymbolTable.h"
+#endif
+
+#if BOOST_OS_LINUX
+void DemangleAndPrintBacktrace(char** backtrace, size_t size)
 {
-    printf("SIGSEGV!\n");
+	ELFSymbolTable symTable;
+	for (char** i = backtrace; i < backtrace + size; i++)
+	{
+		std::string_view traceLine{*i};
 
-    void *array[32];
-    size_t size;
+		// basic check to see if the backtrace line matches expected format
+		size_t parenthesesOpen = traceLine.find_last_of('(');
+		size_t parenthesesClose = traceLine.find_last_of(')');
+		size_t offsetPlus = traceLine.find_last_of('+');
+		if (!parenthesesOpen || !parenthesesClose || !offsetPlus ||
+			 offsetPlus < parenthesesOpen || offsetPlus > parenthesesClose)
+		{
+			// fall back to default string
+            CrashLog_WriteLine(traceLine);
+			continue;
+		}
 
-    // get void*'s for all entries on the stack
-    size = backtrace(array, 32);
+		// attempt to resolve symbol from regular symbol table if missing from dynamic symbol table
+		uint64 newOffset = -1;
+		std::string_view symbolName = traceLine.substr(parenthesesOpen+1, offsetPlus-parenthesesOpen-1);
+		if (symbolName.empty())
+		{
+			uint64 symbolOffset = StringHelpers::ToInt64(traceLine.substr(offsetPlus+1,offsetPlus+1-parenthesesClose-1));
+			symbolName = symTable.OffsetToSymbol(symbolOffset, newOffset);
+		}
 
-    // print out all the frames to stderr
-    fprintf(stderr, "Error: signal %d:\n", sig);
-    backtrace_symbols_fd(array, size, STDERR_FILENO);
-    exit(1);
+        CrashLog_WriteLine(traceLine.substr(0, parenthesesOpen+1), false);
+
+        CrashLog_WriteLine(boost::core::demangle(symbolName.empty() ? "" : symbolName.data()), false);
+
+		// print relative or existing symbol offset.
+        CrashLog_WriteLine("+", false);
+		if (newOffset != -1)
+		{
+            CrashLog_WriteLine(fmt::format("0x{:x}", newOffset), false);
+            CrashLog_WriteLine(traceLine.substr(parenthesesClose));
+		}
+		else
+		{
+            CrashLog_WriteLine(traceLine.substr(offsetPlus+1));
+		}
+	}
+}
+#endif
+
+// handle signals that would dump core, print stacktrace and then dump depending on config
+void handlerDumpingSignal(int sig, siginfo_t *info, void *context)
+{
+#if defined(ARCH_X86_64) && BOOST_OS_LINUX
+	// Check for hardware breakpoints
+	if (info->si_signo == SIGTRAP && info->si_code == TRAP_HWBKPT)
+	{
+		uint64 dr6 = _ReadDR6();
+		g_gdbstub->HandleAccessException(dr6);
+		return;
+	}
+#endif
+
+    if(!CrashLog_Create())
+        return; // give up if crashlog was already created
+
+    char* sigName = strsignal(sig);
+	if (sigName)
+	{
+		printf("%s!\n", sigName);
+	}
+	else
+	{
+		// should never be the case
+		printf("Unknown core dumping signal!\n");
+	}
+
+	void* backtraceArray[128];
+	size_t size;
+
+	// get void*'s for all entries on the stack
+	size = backtrace(backtraceArray, 128);
+    // replace the deepest entry with the actual crash address
+#if defined(ARCH_X86_64) && BOOST_OS_LINUX > 0
+    ucontext_t *uc = (ucontext_t *)context;
+    backtraceArray[0] = (void *)uc->uc_mcontext.gregs[REG_RIP];
+#endif
+
+    CrashLog_WriteLine(fmt::format("Error: signal {}:", sig));
+
+#if BOOST_OS_LINUX
+	char** symbol_trace = backtrace_symbols(backtraceArray, size);
+
+	if (symbol_trace)
+	{
+        DemangleAndPrintBacktrace(symbol_trace, size);
+		free(symbol_trace);
+	}
+	else
+	{
+        CrashLog_WriteLine("Failed to read backtrace");
+	}
+#else
+	backtrace_symbols_fd(backtraceArray, size, STDERR_FILENO);
+#endif
+
+    std::cerr << fmt::format("\nStacktrace and additional info written to:") << std::endl;
+    std::cerr << cemuLog_GetLogFilePath().generic_string() << std::endl;
+
+    CrashLog_SetOutputChannels(false, true);
+    ExceptionHandler_LogGeneralInfo();
+    CrashLog_SetOutputChannels(true, true);
+
+	if (GetConfig().crash_dump == CrashDump::Enabled)
+	{
+		// reset signal handler to default and re-raise signal to dump core
+		signal(sig, SIG_DFL);
+		raise(sig);
+		return;
+	}
+	// exit process ignoring all issues
+	_Exit(1);
 }
 
 void handler_SIGINT(int sig)
 {
-    /*
-     * Received when pressing CTRL + C in a console
-     * Ideally should be exiting cleanly after saving settings but currently
-     * there's no clean exit pathway (at least on linux) and exiting the app
-     * by any mean ends up with a SIGABRT from the standard library destroying
-     * threads.
-     */
-    _Exit(0);
+	/*
+	 * Received when pressing CTRL + C in a console
+	 * Ideally should be exiting cleanly after saving settings but currently
+	 * there's no clean exit pathway (at least on linux) and exiting the app
+	 * by any mean ends up with a SIGABRT from the standard library destroying
+	 * threads.
+	 */
+	_Exit(0);
 }
 
-void ExceptionHandler_init()
+void ExceptionHandler_Init()
 {
-    signal(SIGSEGV, handler_SIGSEGV);
-    signal(SIGINT, handler_SIGINT);
+	struct sigaction action;
+	action.sa_flags = 0;
+	sigfillset(&action.sa_mask); // don't allow signals to be interrupted
+
+	action.sa_handler = handler_SIGINT;
+	sigaction(SIGINT, &action, nullptr);
+	sigaction(SIGTERM, &action, nullptr);
+
+    action.sa_flags = SA_SIGINFO;
+    action.sa_handler = nullptr;
+	action.sa_sigaction = handlerDumpingSignal;
+	sigaction(SIGABRT, &action, nullptr);
+	sigaction(SIGBUS, &action, nullptr);
+	sigaction(SIGFPE, &action, nullptr);
+	sigaction(SIGILL, &action, nullptr);
+	sigaction(SIGIOT, &action, nullptr);
+	sigaction(SIGQUIT, &action, nullptr);
+	sigaction(SIGSEGV, &action, nullptr);
+	sigaction(SIGSYS, &action, nullptr);
+	sigaction(SIGTRAP, &action, nullptr);
 }
diff --git a/src/Common/ExceptionHandler/ExceptionHandler_win32.cpp b/src/Common/ExceptionHandler/ExceptionHandler_win32.cpp
index 25dca26f..6b205d26 100644
--- a/src/Common/ExceptionHandler/ExceptionHandler_win32.cpp
+++ b/src/Common/ExceptionHandler/ExceptionHandler_win32.cpp
@@ -1,35 +1,22 @@
 #include "Common/precompiled.h"
 #include "Cafe/CafeSystem.h"
+#include "ExceptionHandler.h"
 
 #include <Windows.h>
 #include <Dbghelp.h>
 #include <shellapi.h>
 
-#include "Config/ActiveSettings.h"
-#include "Config/CemuConfig.h"
+#include "config/ActiveSettings.h"
+#include "config/CemuConfig.h"
 #include "Cafe/OS/libs/coreinit/coreinit_Thread.h"
 #include "Cafe/HW/Espresso/PPCState.h"
-
-extern uint32 currentBaseApplicationHash;
-extern uint32 currentUpdatedApplicationHash;
+#include "Cafe/HW/Espresso/Debugger/GDBStub.h"
 
 LONG handleException_SINGLE_STEP(PEXCEPTION_POINTERS pExceptionInfo)
 {
 	return EXCEPTION_CONTINUE_SEARCH;
 }
 
-void crashlog_writeHeader(const char* header)
-{
-	cemuLog_writePlainToLog("-----------------------------------------\n");
-
-	cemuLog_writePlainToLog("   ");
-	cemuLog_writePlainToLog(header);
-	cemuLog_writePlainToLog("\n");
-
-	cemuLog_writePlainToLog("-----------------------------------------\n");
-}
-
-bool crashLogCreated = false;
 #include <boost/algorithm/string.hpp>
 BOOL CALLBACK MyMiniDumpCallback(PVOID pParam, const PMINIDUMP_CALLBACK_INPUT pInput, PMINIDUMP_CALLBACK_OUTPUT pOutput)
 {
@@ -61,7 +48,7 @@ bool CreateMiniDump(CrashDump dump, EXCEPTION_POINTERS* pep)
 	if (dump == CrashDump::Disabled)
 		return true;
 
-	fs::path p = ActiveSettings::GetPath("crashdump");
+	fs::path p = ActiveSettings::GetUserDataPath("crashdump");
 
 	std::error_code ec;
 	fs::create_directories(p, ec);
@@ -107,8 +94,6 @@ bool CreateMiniDump(CrashDump dump, EXCEPTION_POINTERS* pep)
 	return result != FALSE;
 }
 
-void DebugLogStackTrace(OSThread_t* thread, MPTR sp);
-
 void DumpThreadStackTrace()
 {
 	HANDLE process = GetCurrentProcess();
@@ -122,7 +107,7 @@ void DumpThreadStackTrace()
 	symbol->MaxNameLen = 255;
 	symbol->SizeOfStruct = sizeof(SYMBOL_INFO);
 
-	crashlog_writeHeader("Stack trace");
+    CrashLog_WriteHeader("Stack trace");
 	for (unsigned int i = 0; i < frames; i++)
 	{
 		DWORD64 stackTraceOffset = (DWORD64)stack[i];
@@ -170,11 +155,8 @@ void DumpThreadStackTrace()
 
 void createCrashlog(EXCEPTION_POINTERS* e, PCONTEXT context)
 {
-	if (crashLogCreated)
-		return; // only create one crashlog
-	crashLogCreated = true;
-
-	cemuLog_createLogFile(true);
+    if(!CrashLog_Create())
+        return; // give up if crashlog was already created
 
 	const auto crash_dump = GetConfig().crash_dump.GetValue();
 	const auto dump_written = CreateMiniDump(crash_dump, e);
@@ -235,117 +217,10 @@ void createCrashlog(EXCEPTION_POINTERS* e, PCONTEXT context)
 	cemuLog_writePlainToLog(dumpLine);
 	sprintf(dumpLine, "R12=%016I64x R13=%016I64x R14=%016I64x R15=%016I64x\n", context->R12, context->R13, context->R14, context->R15);
 	cemuLog_writePlainToLog(dumpLine);
-	// info about game
-	cemuLog_writePlainToLog("\n");
-	crashlog_writeHeader("Game info");
-	if (CafeSystem::IsTitleRunning())
-	{
-		cemuLog_writePlainToLog("Game: ");
-		cemuLog_writePlainToLog(CafeSystem::GetForegroundTitleName().c_str());
-		cemuLog_writePlainToLog("\n");
-		// title id
-		sprintf(dumpLine, "TitleId: %I64x\n", CafeSystem::GetForegroundTitleId());
-		cemuLog_writePlainToLog(dumpLine);
-		// rpx hash
-		sprintf(dumpLine, "RPXHash: %x\n", currentBaseApplicationHash);
-		cemuLog_writePlainToLog(dumpLine);
-	}
-	else
-	{
-		cemuLog_writePlainToLog("Not running\n");
-	}
-	// info about active PPC instance:
-	cemuLog_writePlainToLog("\n");
-	crashlog_writeHeader("Active PPC instance");
-	if (ppcInterpreterCurrentInstance)
-	{		
-		OSThread_t* currentThread = coreinit::OSGetCurrentThread();
-		uint32 threadPtr = memory_getVirtualOffsetFromPointer(coreinit::OSGetCurrentThread());
-		sprintf(dumpLine, "IP 0x%08x LR 0x%08x Thread 0x%08x\n", ppcInterpreterCurrentInstance->instructionPointer, ppcInterpreterCurrentInstance->spr.LR, threadPtr);
-		cemuLog_writePlainToLog(dumpLine);
 
-		// GPR info
-		sprintf(dumpLine, "\n");
-		cemuLog_writePlainToLog(dumpLine);
-		auto gprs = ppcInterpreterCurrentInstance->gpr;
-		sprintf(dumpLine, "r0 =%08x r1 =%08x r2 =%08x r3 =%08x r4 =%08x r5 =%08x r6 =%08x r7 =%08x\n", gprs[0], gprs[1], gprs[2], gprs[3], gprs[4], gprs[5], gprs[6], gprs[7]);
-		cemuLog_writePlainToLog(dumpLine);
-		sprintf(dumpLine, "r8 =%08x r9 =%08x r10=%08x r11=%08x r12=%08x r13=%08x r14=%08x r15=%08x\n", gprs[8], gprs[9], gprs[10], gprs[11], gprs[12], gprs[13], gprs[14], gprs[15]);
-		cemuLog_writePlainToLog(dumpLine);
-		sprintf(dumpLine, "r16=%08x r17=%08x r18=%08x r19=%08x r20=%08x r21=%08x r22=%08x r23=%08x\n", gprs[16], gprs[17], gprs[18], gprs[19], gprs[20], gprs[21], gprs[22], gprs[23]);
-		cemuLog_writePlainToLog(dumpLine);
-		sprintf(dumpLine, "r24=%08x r25=%08x r26=%08x r27=%08x r28=%08x r29=%08x r30=%08x r31=%08x\n", gprs[24], gprs[25], gprs[26], gprs[27], gprs[28], gprs[29], gprs[30], gprs[31]);
-		cemuLog_writePlainToLog(dumpLine);
-
-		// write line to log
-		cemuLog_writePlainToLog(dumpLine);
-
-		// stack trace
-		MPTR currentStackVAddr = ppcInterpreterCurrentInstance->gpr[1];
-		cemuLog_writePlainToLog("\n");
-		crashlog_writeHeader("PPC stack trace");
-		DebugLogStackTrace(currentThread, currentStackVAddr);
-
-		// stack dump
-		cemuLog_writePlainToLog("\n");
-		crashlog_writeHeader("PPC stack dump");
-		for (uint32 i = 0; i < 16; i++)
-		{
-			MPTR lineAddr = currentStackVAddr + i * 8 * 4;
-			if (memory_isAddressRangeAccessible(lineAddr, 8 * 4))
-			{
-				sprintf(dumpLine, "[0x%08x] %08x %08x %08x %08x - %08x %08x %08x %08x\n", lineAddr, memory_readU32(lineAddr + 0), memory_readU32(lineAddr + 4), memory_readU32(lineAddr + 8), memory_readU32(lineAddr + 12), memory_readU32(lineAddr + 16), memory_readU32(lineAddr + 20), memory_readU32(lineAddr + 24), memory_readU32(lineAddr + 28));
-				cemuLog_writePlainToLog(dumpLine);
-			}
-			else
-			{
-				sprintf(dumpLine, "[0x%08x] ?\n", lineAddr);
-				cemuLog_writePlainToLog(dumpLine);
-			}
-		}
-	}
-	else
-	{
-		cemuLog_writePlainToLog("Not active\n");
-	}
-
-	// PPC thread log
-	cemuLog_writePlainToLog("\n");
-	crashlog_writeHeader("PPC threads");
-	if (activeThreadCount == 0)
-	{
-		cemuLog_writePlainToLog("None active\n");
-	}
-	for (sint32 i = 0; i < activeThreadCount; i++)
-	{
-		MPTR threadItrMPTR = activeThread[i];
-		OSThread_t* threadItrBE = (OSThread_t*)memory_getPointerFromVirtualOffset(threadItrMPTR);
-
-		// get thread state
-		OSThread_t::THREAD_STATE threadState = threadItrBE->state;
-		const char* threadStateStr = "UNDEFINED";
-		if (threadItrBE->suspendCounter != 0)
-			threadStateStr = "SUSPENDED";
-		else if (threadState == OSThread_t::THREAD_STATE::STATE_NONE)
-			threadStateStr = "NONE";
-		else if (threadState == OSThread_t::THREAD_STATE::STATE_READY)
-			threadStateStr = "READY";
-		else if (threadState == OSThread_t::THREAD_STATE::STATE_RUNNING)
-			threadStateStr = "RUNNING";
-		else if (threadState == OSThread_t::THREAD_STATE::STATE_WAITING)
-			threadStateStr = "WAITING";
-		else if (threadState == OSThread_t::THREAD_STATE::STATE_MORIBUND)
-			threadStateStr = "MORIBUND";
-		// generate log line
-		uint8 affinity = threadItrBE->attr;
-		sint32 effectivePriority = threadItrBE->effectivePriority;
-		const char* threadName = "NULL";
-		if (!threadItrBE->threadName.IsNull())
-			threadName = threadItrBE->threadName.GetPtr();
-		sprintf(dumpLine, "%08x Ent %08x IP %08x LR %08x %-9s Aff %d%d%d Pri %2d Name %s\n", threadItrMPTR, _swapEndianU32(threadItrBE->entrypoint), threadItrBE->context.srr0, _swapEndianU32(threadItrBE->context.lr), threadStateStr, (affinity >> 0) & 1, (affinity >> 1) & 1, (affinity >> 2) & 1, effectivePriority, threadName);
-		// write line to log
-		cemuLog_writePlainToLog(dumpLine);
-	}
+    CrashLog_SetOutputChannels(false, true);
+    ExceptionHandler_LogGeneralInfo();
+    CrashLog_SetOutputChannels(true, true);
 
 	cemuLog_waitForFlush();
 
@@ -356,11 +231,11 @@ void createCrashlog(EXCEPTION_POINTERS* e, PCONTEXT context)
 		const auto temp_time = std::chrono::system_clock::to_time_t(now);
 		const auto& time = *std::gmtime(&temp_time);
 
-		fs::path p = ActiveSettings::GetPath("crashdump");
+		fs::path p = ActiveSettings::GetUserDataPath("crashdump");
 		p /= fmt::format("log_{:04d}{:02d}{:02d}_{:02d}{:02d}{:02d}.txt", 1900 + time.tm_year, time.tm_mon + 1, time.tm_mday, time.tm_year, time.tm_hour, time.tm_min, time.tm_sec);
 
 		std::error_code ec;
-		fs::copy_file(ActiveSettings::GetPath("log.txt"), p, ec);
+		fs::copy_file(ActiveSettings::GetUserDataPath("log.txt"), p, ec);
 	}
 
 	exit(0);
@@ -378,7 +253,8 @@ int crashlogThread(void* exceptionInfoRawPtr)
 	return 0;
 }
 
-void debugger_handleSingleStepException(uint32 drMask);
+void debugger_handleSingleStepException(uint64 dr6);
+
 
 LONG WINAPI VectoredExceptionHandler(PEXCEPTION_POINTERS pExceptionInfo)
 {
@@ -387,7 +263,11 @@ LONG WINAPI VectoredExceptionHandler(PEXCEPTION_POINTERS pExceptionInfo)
 		LONG r = handleException_SINGLE_STEP(pExceptionInfo);
 		if (r != EXCEPTION_CONTINUE_SEARCH)
 			return r;
-		debugger_handleSingleStepException(pExceptionInfo->ContextRecord->Dr6 & 0xF);
+
+		if (GetBits(pExceptionInfo->ContextRecord->Dr6, 0, 1) || GetBits(pExceptionInfo->ContextRecord->Dr6, 1, 1))
+			debugger_handleSingleStepException(pExceptionInfo->ContextRecord->Dr6);
+		else if (GetBits(pExceptionInfo->ContextRecord->Dr6, 2, 1) || GetBits(pExceptionInfo->ContextRecord->Dr6, 3, 1))
+			g_gdbstub->HandleAccessException(pExceptionInfo->ContextRecord->Dr6);
 		return EXCEPTION_CONTINUE_EXECUTION;
 	}
 	return EXCEPTION_CONTINUE_SEARCH;
@@ -399,7 +279,7 @@ LONG WINAPI cemu_unhandledExceptionFilter(EXCEPTION_POINTERS* pExceptionInfo)
 	return EXCEPTION_NONCONTINUABLE_EXCEPTION;
 }
 
-void ExceptionHandler_init()
+void ExceptionHandler_Init()
 {
 	SetUnhandledExceptionFilter(cemu_unhandledExceptionFilter);
 	AddVectoredExceptionHandler(1, VectoredExceptionHandler);
diff --git a/src/Common/GLInclude/GLInclude.h b/src/Common/GLInclude/GLInclude.h
index 7fcfa6f0..86df0232 100644
--- a/src/Common/GLInclude/GLInclude.h
+++ b/src/Common/GLInclude/GLInclude.h
@@ -24,6 +24,9 @@ typedef XID GLXFBConfigID;
 typedef struct __GLXcontextRec *GLXContext;
 typedef struct __GLXFBConfigRec *GLXFBConfig;
 
+#define EGL_EGL_PROTOTYPES 0
+#include "egl.h"
+#undef EGL_EGL_PROTOTYPES
 #include "glxext.h"
 
 #undef Bool
@@ -33,10 +36,187 @@ typedef struct __GLXFBConfigRec *GLXFBConfig;
 
 #endif
 
+namespace CemuGL
+{
 #define GLFUNC(__type, __name)	extern __type __name;
+#define EGLFUNC(__type, __name) extern __type __name;
 #include "glFunctions.h"
 #undef GLFUNC
+#undef EGLFUNC
 
+// DSA-style helpers with fallback to legacy API if DSA is not supported
+
+#define DSA_FORCE_DISABLE false // set to true to simulate DSA not being supported
+
+static GLenum GetGLBindingFromTextureTarget(GLenum texTarget)
+{
+	switch(texTarget)
+	{
+	case GL_TEXTURE_1D: return GL_TEXTURE_BINDING_1D;
+	case GL_TEXTURE_2D: return GL_TEXTURE_BINDING_2D;
+	case GL_TEXTURE_3D: return GL_TEXTURE_BINDING_3D;
+	case GL_TEXTURE_2D_ARRAY: return GL_TEXTURE_BINDING_2D_ARRAY;
+	case GL_TEXTURE_CUBE_MAP: return GL_TEXTURE_BINDING_CUBE_MAP;
+	case GL_TEXTURE_CUBE_MAP_ARRAY: return GL_TEXTURE_BINDING_CUBE_MAP_ARRAY;
+	default:
+		cemu_assert_unimplemented();
+		return 0;
+	}
+}
+
+static GLuint glCreateTextureWrapper(GLenum target)
+{
+	GLuint tex;
+	if (glCreateTextures && !DSA_FORCE_DISABLE)
+	{
+		glCreateTextures(target, 1, &tex);
+		return tex;
+	}
+	GLint originalTexture;
+	glGetIntegerv(GetGLBindingFromTextureTarget(target), &originalTexture);
+	glGenTextures(1, &tex);
+	glBindTexture(target, tex);
+	glBindTexture(target, originalTexture);
+	return tex;
+}
+
+static void glTextureStorage1DWrapper(GLenum target, GLuint texture, GLsizei levels, GLenum internalformat, GLsizei width)
+{
+	if (glTextureStorage1D && !DSA_FORCE_DISABLE)
+	{
+		glTextureStorage1D(texture, levels, internalformat, width);
+		return;
+	}
+	GLenum binding = GetGLBindingFromTextureTarget(target);
+	GLint originalTexture;
+	glGetIntegerv(binding, &originalTexture);
+	glBindTexture(target, texture);
+	glTexStorage1D(target, levels, internalformat, width);
+	glBindTexture(target, originalTexture);
+}
+
+static void glTextureStorage2DWrapper(GLenum target, GLuint texture, GLsizei levels, GLenum internalformat, GLsizei width, GLsizei height)
+{
+	if (glTextureStorage2D && !DSA_FORCE_DISABLE)
+	{
+		glTextureStorage2D(texture, levels, internalformat, width, height);
+		return;
+	}
+	GLenum binding = GetGLBindingFromTextureTarget(target);
+	GLint originalTexture;
+	glGetIntegerv(binding, &originalTexture);
+	glBindTexture(target, texture);
+	glTexStorage2D(target, levels, internalformat, width, height);
+	glBindTexture(target, originalTexture);
+}
+
+static void glTextureStorage3DWrapper(GLenum target, GLuint texture, GLsizei levels, GLenum internalformat, GLsizei width, GLsizei height, GLsizei depth)
+{
+	if (glTextureStorage3D && !DSA_FORCE_DISABLE)
+	{
+		glTextureStorage3D(texture, levels, internalformat, width, height, depth);
+		return;
+	}
+	GLenum binding = GetGLBindingFromTextureTarget(target);
+	GLint originalTexture;
+	glGetIntegerv(binding, &originalTexture);
+	glBindTexture(target, texture);
+	glTexStorage3D(target, levels, internalformat, width, height, depth);
+	glBindTexture(target, originalTexture);
+}
+
+static void glTextureSubImage1DWrapper(GLenum target, GLuint texture, GLint level, GLint xoffset, GLsizei width, GLenum format, GLenum type, const void* pixels)
+{
+	if (glTextureSubImage1D && !DSA_FORCE_DISABLE)
+	{
+		glTextureSubImage1D(texture, level, xoffset, width, format, type, pixels);
+		return;
+	}
+	GLenum binding = GetGLBindingFromTextureTarget(target);
+	GLint originalTexture;
+	glGetIntegerv(binding, &originalTexture);
+	glBindTexture(target, texture);
+	glTexSubImage1D(target, level, xoffset, width, format, type, pixels);
+	glBindTexture(target, originalTexture);
+}
+
+static void glCompressedTextureSubImage1DWrapper(GLenum target, GLuint texture, GLint level, GLint xoffset, GLsizei width, GLenum format, GLsizei imageSize, const void* data)
+{
+	if (glCompressedTextureSubImage1D && !DSA_FORCE_DISABLE)
+	{
+		glCompressedTextureSubImage1D(texture, level, xoffset, width, format, imageSize, data);
+		return;
+	}
+	GLenum binding = GetGLBindingFromTextureTarget(target);
+	GLint originalTexture;
+	glGetIntegerv(binding, &originalTexture);
+	glBindTexture(target, texture);
+	glCompressedTexSubImage1D(target, level, xoffset, width, format, imageSize, data);
+	glBindTexture(target, originalTexture);
+}
+
+static void glTextureSubImage2DWrapper(GLenum target, GLuint texture, GLint level, GLint xoffset, GLint yoffset, GLsizei width, GLsizei height, GLenum format, GLenum type, const void* pixels)
+{
+	if (glTextureSubImage2D && !DSA_FORCE_DISABLE)
+	{
+		glTextureSubImage2D(texture, level, xoffset, yoffset, width, height, format, type, pixels);
+		return;
+	}
+	GLenum binding = GetGLBindingFromTextureTarget(target);
+	GLint originalTexture;
+	glGetIntegerv(binding, &originalTexture);
+	glBindTexture(target, texture);
+	glTexSubImage2D(target, level, xoffset, yoffset, width, height, format, type, pixels);
+	glBindTexture(target, originalTexture);
+}
+
+static void glCompressedTextureSubImage2DWrapper(GLenum target, GLuint texture, GLint level, GLint xoffset, GLint yoffset, GLsizei width, GLsizei height, GLenum format, GLsizei imageSize, const void* data)
+{
+	if (glCompressedTextureSubImage2D && !DSA_FORCE_DISABLE)
+	{
+		glCompressedTextureSubImage2D(texture, level, xoffset, yoffset, width, height, format, imageSize, data);
+		return;
+	}
+	GLenum binding = GetGLBindingFromTextureTarget(target);
+	GLint originalTexture;
+	glGetIntegerv(binding, &originalTexture);
+	glBindTexture(target, texture);
+	glCompressedTexSubImage2D(target, level, xoffset, yoffset, width, height, format, imageSize, data);
+	glBindTexture(target, originalTexture);
+}
+
+static void glTextureSubImage3DWrapper(GLenum target, GLuint texture, GLint level, GLint xoffset, GLint yoffset, GLint zoffset, GLsizei width, GLsizei height, GLsizei depth, GLenum format, GLenum type, const void* pixels)
+{
+	if(glTextureSubImage3D && !DSA_FORCE_DISABLE)
+	{
+		glTextureSubImage3D(texture, level, xoffset, yoffset, zoffset, width, height, depth, format, type, pixels);
+		return;
+	}
+	GLenum binding = GetGLBindingFromTextureTarget(target);
+	GLint originalTexture;
+	glGetIntegerv(binding, &originalTexture);
+	glBindTexture(target, texture);
+	glTexSubImage3D(target, level, xoffset, yoffset, zoffset, width, height, depth, format, type, pixels);
+	glBindTexture(target, originalTexture);
+}
+
+static void glCompressedTextureSubImage3DWrapper(GLenum target, GLuint texture, GLint level, GLint xoffset, GLint yoffset, GLint zoffset, GLsizei width, GLsizei height, GLsizei depth, GLenum format, GLsizei imageSize, const void* data)
+{
+	if(glCompressedTextureSubImage3D && !DSA_FORCE_DISABLE)
+	{
+		glCompressedTextureSubImage3D(texture, level, xoffset, yoffset, zoffset, width, height, depth, format, imageSize, data);
+		return;
+	}
+	GLenum binding = GetGLBindingFromTextureTarget(target);
+	GLint originalTexture;
+	glGetIntegerv(binding, &originalTexture);
+	glBindTexture(target, texture);
+	glCompressedTexSubImage3D(target, level, xoffset, yoffset, zoffset, width, height, depth, format, imageSize, data);
+	glBindTexture(target, originalTexture);
+}
+
+}
+using namespace CemuGL;
 // this prevents Windows GL.h from being included:
 #define __gl_h_
-#define __GL_H__
\ No newline at end of file
+#define __GL_H__
diff --git a/src/Common/GLInclude/egl.h b/src/Common/GLInclude/egl.h
new file mode 100644
index 00000000..c4191525
--- /dev/null
+++ b/src/Common/GLInclude/egl.h
@@ -0,0 +1,342 @@
+#ifndef __egl_h_
+#define __egl_h_ 1
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+/*
+** Copyright 2013-2020 The Khronos Group Inc.
+** SPDX-License-Identifier: Apache-2.0
+**
+** This header is generated from the Khronos EGL XML API Registry.
+** The current version of the Registry, generator scripts
+** used to make the header, and the header can be found at
+**   http://www.khronos.org/registry/egl
+**
+** Khronos $Git commit SHA1: 8c62b915dd $ on $Git commit date: 2021-11-05 23:32:01 -0400 $
+*/
+
+#include <EGL/eglplatform.h>
+
+#ifndef EGL_EGL_PROTOTYPES
+#define EGL_EGL_PROTOTYPES 1
+#endif
+
+/* Generated on date 20211116 */
+
+/* Generated C header for:
+ * API: egl
+ * Versions considered: .*
+ * Versions emitted: .*
+ * Default extensions included: None
+ * Additional extensions included: _nomatch_^
+ * Extensions removed: _nomatch_^
+ */
+
+#ifndef EGL_VERSION_1_0
+#define EGL_VERSION_1_0 1
+typedef unsigned int EGLBoolean;
+typedef void *EGLDisplay;
+#include <KHR/khrplatform.h>
+#include <EGL/eglplatform.h>
+typedef void *EGLConfig;
+typedef void *EGLSurface;
+typedef void *EGLContext;
+typedef void (*__eglMustCastToProperFunctionPointerType)(void);
+#define EGL_ALPHA_SIZE                    0x3021
+#define EGL_BAD_ACCESS                    0x3002
+#define EGL_BAD_ALLOC                     0x3003
+#define EGL_BAD_ATTRIBUTE                 0x3004
+#define EGL_BAD_CONFIG                    0x3005
+#define EGL_BAD_CONTEXT                   0x3006
+#define EGL_BAD_CURRENT_SURFACE           0x3007
+#define EGL_BAD_DISPLAY                   0x3008
+#define EGL_BAD_MATCH                     0x3009
+#define EGL_BAD_NATIVE_PIXMAP             0x300A
+#define EGL_BAD_NATIVE_WINDOW             0x300B
+#define EGL_BAD_PARAMETER                 0x300C
+#define EGL_BAD_SURFACE                   0x300D
+#define EGL_BLUE_SIZE                     0x3022
+#define EGL_BUFFER_SIZE                   0x3020
+#define EGL_CONFIG_CAVEAT                 0x3027
+#define EGL_CONFIG_ID                     0x3028
+#define EGL_CORE_NATIVE_ENGINE            0x305B
+#define EGL_DEPTH_SIZE                    0x3025
+#define EGL_DONT_CARE                     EGL_CAST(EGLint,-1)
+#define EGL_DRAW                          0x3059
+#define EGL_EXTENSIONS                    0x3055
+#define EGL_FALSE                         0
+#define EGL_GREEN_SIZE                    0x3023
+#define EGL_HEIGHT                        0x3056
+#define EGL_LARGEST_PBUFFER               0x3058
+#define EGL_LEVEL                         0x3029
+#define EGL_MAX_PBUFFER_HEIGHT            0x302A
+#define EGL_MAX_PBUFFER_PIXELS            0x302B
+#define EGL_MAX_PBUFFER_WIDTH             0x302C
+#define EGL_NATIVE_RENDERABLE             0x302D
+#define EGL_NATIVE_VISUAL_ID              0x302E
+#define EGL_NATIVE_VISUAL_TYPE            0x302F
+#define EGL_NONE                          0x3038
+#define EGL_NON_CONFORMANT_CONFIG         0x3051
+#define EGL_NOT_INITIALIZED               0x3001
+#define EGL_NO_CONTEXT                    EGL_CAST(EGLContext,0)
+#define EGL_NO_DISPLAY                    EGL_CAST(EGLDisplay,0)
+#define EGL_NO_SURFACE                    EGL_CAST(EGLSurface,0)
+#define EGL_PBUFFER_BIT                   0x0001
+#define EGL_PIXMAP_BIT                    0x0002
+#define EGL_READ                          0x305A
+#define EGL_RED_SIZE                      0x3024
+#define EGL_SAMPLES                       0x3031
+#define EGL_SAMPLE_BUFFERS                0x3032
+#define EGL_SLOW_CONFIG                   0x3050
+#define EGL_STENCIL_SIZE                  0x3026
+#define EGL_SUCCESS                       0x3000
+#define EGL_SURFACE_TYPE                  0x3033
+#define EGL_TRANSPARENT_BLUE_VALUE        0x3035
+#define EGL_TRANSPARENT_GREEN_VALUE       0x3036
+#define EGL_TRANSPARENT_RED_VALUE         0x3037
+#define EGL_TRANSPARENT_RGB               0x3052
+#define EGL_TRANSPARENT_TYPE              0x3034
+#define EGL_TRUE                          1
+#define EGL_VENDOR                        0x3053
+#define EGL_VERSION                       0x3054
+#define EGL_WIDTH                         0x3057
+#define EGL_WINDOW_BIT                    0x0004
+typedef EGLBoolean (EGLAPIENTRYP PFNEGLCHOOSECONFIGPROC) (EGLDisplay dpy, const EGLint *attrib_list, EGLConfig *configs, EGLint config_size, EGLint *num_config);
+typedef EGLBoolean (EGLAPIENTRYP PFNEGLCOPYBUFFERSPROC) (EGLDisplay dpy, EGLSurface surface, EGLNativePixmapType target);
+typedef EGLContext (EGLAPIENTRYP PFNEGLCREATECONTEXTPROC) (EGLDisplay dpy, EGLConfig config, EGLContext share_context, const EGLint *attrib_list);
+typedef EGLSurface (EGLAPIENTRYP PFNEGLCREATEPBUFFERSURFACEPROC) (EGLDisplay dpy, EGLConfig config, const EGLint *attrib_list);
+typedef EGLSurface (EGLAPIENTRYP PFNEGLCREATEPIXMAPSURFACEPROC) (EGLDisplay dpy, EGLConfig config, EGLNativePixmapType pixmap, const EGLint *attrib_list);
+typedef EGLSurface (EGLAPIENTRYP PFNEGLCREATEWINDOWSURFACEPROC) (EGLDisplay dpy, EGLConfig config, EGLNativeWindowType win, const EGLint *attrib_list);
+typedef EGLBoolean (EGLAPIENTRYP PFNEGLDESTROYCONTEXTPROC) (EGLDisplay dpy, EGLContext ctx);
+typedef EGLBoolean (EGLAPIENTRYP PFNEGLDESTROYSURFACEPROC) (EGLDisplay dpy, EGLSurface surface);
+typedef EGLBoolean (EGLAPIENTRYP PFNEGLGETCONFIGATTRIBPROC) (EGLDisplay dpy, EGLConfig config, EGLint attribute, EGLint *value);
+typedef EGLBoolean (EGLAPIENTRYP PFNEGLGETCONFIGSPROC) (EGLDisplay dpy, EGLConfig *configs, EGLint config_size, EGLint *num_config);
+typedef EGLDisplay (EGLAPIENTRYP PFNEGLGETCURRENTDISPLAYPROC) (void);
+typedef EGLSurface (EGLAPIENTRYP PFNEGLGETCURRENTSURFACEPROC) (EGLint readdraw);
+typedef EGLDisplay (EGLAPIENTRYP PFNEGLGETDISPLAYPROC) (EGLNativeDisplayType display_id);
+typedef EGLint (EGLAPIENTRYP PFNEGLGETERRORPROC) (void);
+typedef __eglMustCastToProperFunctionPointerType (EGLAPIENTRYP PFNEGLGETPROCADDRESSPROC) (const char *procname);
+typedef EGLBoolean (EGLAPIENTRYP PFNEGLINITIALIZEPROC) (EGLDisplay dpy, EGLint *major, EGLint *minor);
+typedef EGLBoolean (EGLAPIENTRYP PFNEGLMAKECURRENTPROC) (EGLDisplay dpy, EGLSurface draw, EGLSurface read, EGLContext ctx);
+typedef EGLBoolean (EGLAPIENTRYP PFNEGLQUERYCONTEXTPROC) (EGLDisplay dpy, EGLContext ctx, EGLint attribute, EGLint *value);
+typedef const char *(EGLAPIENTRYP PFNEGLQUERYSTRINGPROC) (EGLDisplay dpy, EGLint name);
+typedef EGLBoolean (EGLAPIENTRYP PFNEGLQUERYSURFACEPROC) (EGLDisplay dpy, EGLSurface surface, EGLint attribute, EGLint *value);
+typedef EGLBoolean (EGLAPIENTRYP PFNEGLSWAPBUFFERSPROC) (EGLDisplay dpy, EGLSurface surface);
+typedef EGLBoolean (EGLAPIENTRYP PFNEGLTERMINATEPROC) (EGLDisplay dpy);
+typedef EGLBoolean (EGLAPIENTRYP PFNEGLWAITGLPROC) (void);
+typedef EGLBoolean (EGLAPIENTRYP PFNEGLWAITNATIVEPROC) (EGLint engine);
+#if EGL_EGL_PROTOTYPES
+EGLAPI EGLBoolean EGLAPIENTRY eglChooseConfig (EGLDisplay dpy, const EGLint *attrib_list, EGLConfig *configs, EGLint config_size, EGLint *num_config);
+EGLAPI EGLBoolean EGLAPIENTRY eglCopyBuffers (EGLDisplay dpy, EGLSurface surface, EGLNativePixmapType target);
+EGLAPI EGLContext EGLAPIENTRY eglCreateContext (EGLDisplay dpy, EGLConfig config, EGLContext share_context, const EGLint *attrib_list);
+EGLAPI EGLSurface EGLAPIENTRY eglCreatePbufferSurface (EGLDisplay dpy, EGLConfig config, const EGLint *attrib_list);
+EGLAPI EGLSurface EGLAPIENTRY eglCreatePixmapSurface (EGLDisplay dpy, EGLConfig config, EGLNativePixmapType pixmap, const EGLint *attrib_list);
+EGLAPI EGLSurface EGLAPIENTRY eglCreateWindowSurface (EGLDisplay dpy, EGLConfig config, EGLNativeWindowType win, const EGLint *attrib_list);
+EGLAPI EGLBoolean EGLAPIENTRY eglDestroyContext (EGLDisplay dpy, EGLContext ctx);
+EGLAPI EGLBoolean EGLAPIENTRY eglDestroySurface (EGLDisplay dpy, EGLSurface surface);
+EGLAPI EGLBoolean EGLAPIENTRY eglGetConfigAttrib (EGLDisplay dpy, EGLConfig config, EGLint attribute, EGLint *value);
+EGLAPI EGLBoolean EGLAPIENTRY eglGetConfigs (EGLDisplay dpy, EGLConfig *configs, EGLint config_size, EGLint *num_config);
+EGLAPI EGLDisplay EGLAPIENTRY eglGetCurrentDisplay (void);
+EGLAPI EGLSurface EGLAPIENTRY eglGetCurrentSurface (EGLint readdraw);
+EGLAPI EGLDisplay EGLAPIENTRY eglGetDisplay (EGLNativeDisplayType display_id);
+EGLAPI EGLint EGLAPIENTRY eglGetError (void);
+EGLAPI __eglMustCastToProperFunctionPointerType EGLAPIENTRY eglGetProcAddress (const char *procname);
+EGLAPI EGLBoolean EGLAPIENTRY eglInitialize (EGLDisplay dpy, EGLint *major, EGLint *minor);
+EGLAPI EGLBoolean EGLAPIENTRY eglMakeCurrent (EGLDisplay dpy, EGLSurface draw, EGLSurface read, EGLContext ctx);
+EGLAPI EGLBoolean EGLAPIENTRY eglQueryContext (EGLDisplay dpy, EGLContext ctx, EGLint attribute, EGLint *value);
+EGLAPI const char *EGLAPIENTRY eglQueryString (EGLDisplay dpy, EGLint name);
+EGLAPI EGLBoolean EGLAPIENTRY eglQuerySurface (EGLDisplay dpy, EGLSurface surface, EGLint attribute, EGLint *value);
+EGLAPI EGLBoolean EGLAPIENTRY eglSwapBuffers (EGLDisplay dpy, EGLSurface surface);
+EGLAPI EGLBoolean EGLAPIENTRY eglTerminate (EGLDisplay dpy);
+EGLAPI EGLBoolean EGLAPIENTRY eglWaitGL (void);
+EGLAPI EGLBoolean EGLAPIENTRY eglWaitNative (EGLint engine);
+#endif
+#endif /* EGL_VERSION_1_0 */
+
+#ifndef EGL_VERSION_1_1
+#define EGL_VERSION_1_1 1
+#define EGL_BACK_BUFFER                   0x3084
+#define EGL_BIND_TO_TEXTURE_RGB           0x3039
+#define EGL_BIND_TO_TEXTURE_RGBA          0x303A
+#define EGL_CONTEXT_LOST                  0x300E
+#define EGL_MIN_SWAP_INTERVAL             0x303B
+#define EGL_MAX_SWAP_INTERVAL             0x303C
+#define EGL_MIPMAP_TEXTURE                0x3082
+#define EGL_MIPMAP_LEVEL                  0x3083
+#define EGL_NO_TEXTURE                    0x305C
+#define EGL_TEXTURE_2D                    0x305F
+#define EGL_TEXTURE_FORMAT                0x3080
+#define EGL_TEXTURE_RGB                   0x305D
+#define EGL_TEXTURE_RGBA                  0x305E
+#define EGL_TEXTURE_TARGET                0x3081
+typedef EGLBoolean (EGLAPIENTRYP PFNEGLBINDTEXIMAGEPROC) (EGLDisplay dpy, EGLSurface surface, EGLint buffer);
+typedef EGLBoolean (EGLAPIENTRYP PFNEGLRELEASETEXIMAGEPROC) (EGLDisplay dpy, EGLSurface surface, EGLint buffer);
+typedef EGLBoolean (EGLAPIENTRYP PFNEGLSURFACEATTRIBPROC) (EGLDisplay dpy, EGLSurface surface, EGLint attribute, EGLint value);
+typedef EGLBoolean (EGLAPIENTRYP PFNEGLSWAPINTERVALPROC) (EGLDisplay dpy, EGLint interval);
+#if EGL_EGL_PROTOTYPES
+EGLAPI EGLBoolean EGLAPIENTRY eglBindTexImage (EGLDisplay dpy, EGLSurface surface, EGLint buffer);
+EGLAPI EGLBoolean EGLAPIENTRY eglReleaseTexImage (EGLDisplay dpy, EGLSurface surface, EGLint buffer);
+EGLAPI EGLBoolean EGLAPIENTRY eglSurfaceAttrib (EGLDisplay dpy, EGLSurface surface, EGLint attribute, EGLint value);
+EGLAPI EGLBoolean EGLAPIENTRY eglSwapInterval (EGLDisplay dpy, EGLint interval);
+#endif
+#endif /* EGL_VERSION_1_1 */
+
+#ifndef EGL_VERSION_1_2
+#define EGL_VERSION_1_2 1
+typedef unsigned int EGLenum;
+typedef void *EGLClientBuffer;
+#define EGL_ALPHA_FORMAT                  0x3088
+#define EGL_ALPHA_FORMAT_NONPRE           0x308B
+#define EGL_ALPHA_FORMAT_PRE              0x308C
+#define EGL_ALPHA_MASK_SIZE               0x303E
+#define EGL_BUFFER_PRESERVED              0x3094
+#define EGL_BUFFER_DESTROYED              0x3095
+#define EGL_CLIENT_APIS                   0x308D
+#define EGL_COLORSPACE                    0x3087
+#define EGL_COLORSPACE_sRGB               0x3089
+#define EGL_COLORSPACE_LINEAR             0x308A
+#define EGL_COLOR_BUFFER_TYPE             0x303F
+#define EGL_CONTEXT_CLIENT_TYPE           0x3097
+#define EGL_DISPLAY_SCALING               10000
+#define EGL_HORIZONTAL_RESOLUTION         0x3090
+#define EGL_LUMINANCE_BUFFER              0x308F
+#define EGL_LUMINANCE_SIZE                0x303D
+#define EGL_OPENGL_ES_BIT                 0x0001
+#define EGL_OPENVG_BIT                    0x0002
+#define EGL_OPENGL_ES_API                 0x30A0
+#define EGL_OPENVG_API                    0x30A1
+#define EGL_OPENVG_IMAGE                  0x3096
+#define EGL_PIXEL_ASPECT_RATIO            0x3092
+#define EGL_RENDERABLE_TYPE               0x3040
+#define EGL_RENDER_BUFFER                 0x3086
+#define EGL_RGB_BUFFER                    0x308E
+#define EGL_SINGLE_BUFFER                 0x3085
+#define EGL_SWAP_BEHAVIOR                 0x3093
+#define EGL_UNKNOWN                       EGL_CAST(EGLint,-1)
+#define EGL_VERTICAL_RESOLUTION           0x3091
+typedef EGLBoolean (EGLAPIENTRYP PFNEGLBINDAPIPROC) (EGLenum api);
+typedef EGLenum (EGLAPIENTRYP PFNEGLQUERYAPIPROC) (void);
+typedef EGLSurface (EGLAPIENTRYP PFNEGLCREATEPBUFFERFROMCLIENTBUFFERPROC) (EGLDisplay dpy, EGLenum buftype, EGLClientBuffer buffer, EGLConfig config, const EGLint *attrib_list);
+typedef EGLBoolean (EGLAPIENTRYP PFNEGLRELEASETHREADPROC) (void);
+typedef EGLBoolean (EGLAPIENTRYP PFNEGLWAITCLIENTPROC) (void);
+#if EGL_EGL_PROTOTYPES
+EGLAPI EGLBoolean EGLAPIENTRY eglBindAPI (EGLenum api);
+EGLAPI EGLenum EGLAPIENTRY eglQueryAPI (void);
+EGLAPI EGLSurface EGLAPIENTRY eglCreatePbufferFromClientBuffer (EGLDisplay dpy, EGLenum buftype, EGLClientBuffer buffer, EGLConfig config, const EGLint *attrib_list);
+EGLAPI EGLBoolean EGLAPIENTRY eglReleaseThread (void);
+EGLAPI EGLBoolean EGLAPIENTRY eglWaitClient (void);
+#endif
+#endif /* EGL_VERSION_1_2 */
+
+#ifndef EGL_VERSION_1_3
+#define EGL_VERSION_1_3 1
+#define EGL_CONFORMANT                    0x3042
+#define EGL_CONTEXT_CLIENT_VERSION        0x3098
+#define EGL_MATCH_NATIVE_PIXMAP           0x3041
+#define EGL_OPENGL_ES2_BIT                0x0004
+#define EGL_VG_ALPHA_FORMAT               0x3088
+#define EGL_VG_ALPHA_FORMAT_NONPRE        0x308B
+#define EGL_VG_ALPHA_FORMAT_PRE           0x308C
+#define EGL_VG_ALPHA_FORMAT_PRE_BIT       0x0040
+#define EGL_VG_COLORSPACE                 0x3087
+#define EGL_VG_COLORSPACE_sRGB            0x3089
+#define EGL_VG_COLORSPACE_LINEAR          0x308A
+#define EGL_VG_COLORSPACE_LINEAR_BIT      0x0020
+#endif /* EGL_VERSION_1_3 */
+
+#ifndef EGL_VERSION_1_4
+#define EGL_VERSION_1_4 1
+#define EGL_DEFAULT_DISPLAY               EGL_CAST(EGLNativeDisplayType,0)
+#define EGL_MULTISAMPLE_RESOLVE_BOX_BIT   0x0200
+#define EGL_MULTISAMPLE_RESOLVE           0x3099
+#define EGL_MULTISAMPLE_RESOLVE_DEFAULT   0x309A
+#define EGL_MULTISAMPLE_RESOLVE_BOX       0x309B
+#define EGL_OPENGL_API                    0x30A2
+#define EGL_OPENGL_BIT                    0x0008
+#define EGL_SWAP_BEHAVIOR_PRESERVED_BIT   0x0400
+typedef EGLContext (EGLAPIENTRYP PFNEGLGETCURRENTCONTEXTPROC) (void);
+#if EGL_EGL_PROTOTYPES
+EGLAPI EGLContext EGLAPIENTRY eglGetCurrentContext (void);
+#endif
+#endif /* EGL_VERSION_1_4 */
+
+#ifndef EGL_VERSION_1_5
+#define EGL_VERSION_1_5 1
+typedef void *EGLSync;
+typedef intptr_t EGLAttrib;
+typedef khronos_utime_nanoseconds_t EGLTime;
+typedef void *EGLImage;
+#define EGL_CONTEXT_MAJOR_VERSION         0x3098
+#define EGL_CONTEXT_MINOR_VERSION         0x30FB
+#define EGL_CONTEXT_OPENGL_PROFILE_MASK   0x30FD
+#define EGL_CONTEXT_OPENGL_RESET_NOTIFICATION_STRATEGY 0x31BD
+#define EGL_NO_RESET_NOTIFICATION         0x31BE
+#define EGL_LOSE_CONTEXT_ON_RESET         0x31BF
+#define EGL_CONTEXT_OPENGL_CORE_PROFILE_BIT 0x00000001
+#define EGL_CONTEXT_OPENGL_COMPATIBILITY_PROFILE_BIT 0x00000002
+#define EGL_CONTEXT_OPENGL_DEBUG          0x31B0
+#define EGL_CONTEXT_OPENGL_FORWARD_COMPATIBLE 0x31B1
+#define EGL_CONTEXT_OPENGL_ROBUST_ACCESS  0x31B2
+#define EGL_OPENGL_ES3_BIT                0x00000040
+#define EGL_CL_EVENT_HANDLE               0x309C
+#define EGL_SYNC_CL_EVENT                 0x30FE
+#define EGL_SYNC_CL_EVENT_COMPLETE        0x30FF
+#define EGL_SYNC_PRIOR_COMMANDS_COMPLETE  0x30F0
+#define EGL_SYNC_TYPE                     0x30F7
+#define EGL_SYNC_STATUS                   0x30F1
+#define EGL_SYNC_CONDITION                0x30F8
+#define EGL_SIGNALED                      0x30F2
+#define EGL_UNSIGNALED                    0x30F3
+#define EGL_SYNC_FLUSH_COMMANDS_BIT       0x0001
+#define EGL_FOREVER                       0xFFFFFFFFFFFFFFFFull
+#define EGL_TIMEOUT_EXPIRED               0x30F5
+#define EGL_CONDITION_SATISFIED           0x30F6
+#define EGL_NO_SYNC                       EGL_CAST(EGLSync,0)
+#define EGL_SYNC_FENCE                    0x30F9
+#define EGL_GL_COLORSPACE                 0x309D
+#define EGL_GL_COLORSPACE_SRGB            0x3089
+#define EGL_GL_COLORSPACE_LINEAR          0x308A
+#define EGL_GL_RENDERBUFFER               0x30B9
+#define EGL_GL_TEXTURE_2D                 0x30B1
+#define EGL_GL_TEXTURE_LEVEL              0x30BC
+#define EGL_GL_TEXTURE_3D                 0x30B2
+#define EGL_GL_TEXTURE_ZOFFSET            0x30BD
+#define EGL_GL_TEXTURE_CUBE_MAP_POSITIVE_X 0x30B3
+#define EGL_GL_TEXTURE_CUBE_MAP_NEGATIVE_X 0x30B4
+#define EGL_GL_TEXTURE_CUBE_MAP_POSITIVE_Y 0x30B5
+#define EGL_GL_TEXTURE_CUBE_MAP_NEGATIVE_Y 0x30B6
+#define EGL_GL_TEXTURE_CUBE_MAP_POSITIVE_Z 0x30B7
+#define EGL_GL_TEXTURE_CUBE_MAP_NEGATIVE_Z 0x30B8
+#define EGL_IMAGE_PRESERVED               0x30D2
+#define EGL_NO_IMAGE                      EGL_CAST(EGLImage,0)
+typedef EGLSync (EGLAPIENTRYP PFNEGLCREATESYNCPROC) (EGLDisplay dpy, EGLenum type, const EGLAttrib *attrib_list);
+typedef EGLBoolean (EGLAPIENTRYP PFNEGLDESTROYSYNCPROC) (EGLDisplay dpy, EGLSync sync);
+typedef EGLint (EGLAPIENTRYP PFNEGLCLIENTWAITSYNCPROC) (EGLDisplay dpy, EGLSync sync, EGLint flags, EGLTime timeout);
+typedef EGLBoolean (EGLAPIENTRYP PFNEGLGETSYNCATTRIBPROC) (EGLDisplay dpy, EGLSync sync, EGLint attribute, EGLAttrib *value);
+typedef EGLImage (EGLAPIENTRYP PFNEGLCREATEIMAGEPROC) (EGLDisplay dpy, EGLContext ctx, EGLenum target, EGLClientBuffer buffer, const EGLAttrib *attrib_list);
+typedef EGLBoolean (EGLAPIENTRYP PFNEGLDESTROYIMAGEPROC) (EGLDisplay dpy, EGLImage image);
+typedef EGLDisplay (EGLAPIENTRYP PFNEGLGETPLATFORMDISPLAYPROC) (EGLenum platform, void *native_display, const EGLAttrib *attrib_list);
+typedef EGLSurface (EGLAPIENTRYP PFNEGLCREATEPLATFORMWINDOWSURFACEPROC) (EGLDisplay dpy, EGLConfig config, void *native_window, const EGLAttrib *attrib_list);
+typedef EGLSurface (EGLAPIENTRYP PFNEGLCREATEPLATFORMPIXMAPSURFACEPROC) (EGLDisplay dpy, EGLConfig config, void *native_pixmap, const EGLAttrib *attrib_list);
+typedef EGLBoolean (EGLAPIENTRYP PFNEGLWAITSYNCPROC) (EGLDisplay dpy, EGLSync sync, EGLint flags);
+#if EGL_EGL_PROTOTYPES
+EGLAPI EGLSync EGLAPIENTRY eglCreateSync (EGLDisplay dpy, EGLenum type, const EGLAttrib *attrib_list);
+EGLAPI EGLBoolean EGLAPIENTRY eglDestroySync (EGLDisplay dpy, EGLSync sync);
+EGLAPI EGLint EGLAPIENTRY eglClientWaitSync (EGLDisplay dpy, EGLSync sync, EGLint flags, EGLTime timeout);
+EGLAPI EGLBoolean EGLAPIENTRY eglGetSyncAttrib (EGLDisplay dpy, EGLSync sync, EGLint attribute, EGLAttrib *value);
+EGLAPI EGLImage EGLAPIENTRY eglCreateImage (EGLDisplay dpy, EGLContext ctx, EGLenum target, EGLClientBuffer buffer, const EGLAttrib *attrib_list);
+EGLAPI EGLBoolean EGLAPIENTRY eglDestroyImage (EGLDisplay dpy, EGLImage image);
+EGLAPI EGLDisplay EGLAPIENTRY eglGetPlatformDisplay (EGLenum platform, void *native_display, const EGLAttrib *attrib_list);
+EGLAPI EGLSurface EGLAPIENTRY eglCreatePlatformWindowSurface (EGLDisplay dpy, EGLConfig config, void *native_window, const EGLAttrib *attrib_list);
+EGLAPI EGLSurface EGLAPIENTRY eglCreatePlatformPixmapSurface (EGLDisplay dpy, EGLConfig config, void *native_pixmap, const EGLAttrib *attrib_list);
+EGLAPI EGLBoolean EGLAPIENTRY eglWaitSync (EGLDisplay dpy, EGLSync sync, EGLint flags);
+#endif
+#endif /* EGL_VERSION_1_5 */
+
+#ifdef __cplusplus
+}
+#endif
+
+#endif
diff --git a/src/Common/GLInclude/glFunctions.h b/src/Common/GLInclude/glFunctions.h
index e69928d1..76308fdb 100644
--- a/src/Common/GLInclude/glFunctions.h
+++ b/src/Common/GLInclude/glFunctions.h
@@ -171,10 +171,13 @@ GLFUNC(PFNGLTEXSTORAGE2DPROC, glTexStorage2D)
 GLFUNC(PFNGLTEXSTORAGE3DPROC, glTexStorage3D)
 GLFUNC(PFNGLTEXIMAGE3DPROC, glTexImage3D)
 GLFUNC(PFNGLTEXSUBIMAGE3DPROC, glTexSubImage3D)
+GLFUNC(PFNGLCOMPRESSEDTEXIMAGE1DPROC, glCompressedTexImage1D)
 GLFUNC(PFNGLCOMPRESSEDTEXIMAGE2DPROC, glCompressedTexImage2D)
 GLFUNC(PFNGLCOMPRESSEDTEXIMAGE3DPROC, glCompressedTexImage3D)
+GLFUNC(PFNGLCOMPRESSEDTEXSUBIMAGE1DPROC, glCompressedTexSubImage1D)
 GLFUNC(PFNGLCOMPRESSEDTEXSUBIMAGE2DPROC, glCompressedTexSubImage2D)
 GLFUNC(PFNGLCOMPRESSEDTEXSUBIMAGE3DPROC, glCompressedTexSubImage3D)
+GLFUNC(PFNGLCOMPRESSEDTEXTURESUBIMAGE1DPROC, glCompressedTextureSubImage1D)
 GLFUNC(PFNGLCOMPRESSEDTEXTURESUBIMAGE2DPROC, glCompressedTextureSubImage2D)
 GLFUNC(PFNGLCOMPRESSEDTEXTURESUBIMAGE3DPROC, glCompressedTextureSubImage3D)
 GLFUNC(PFNGLCOPYIMAGESUBDATAPROC, glCopyImageSubData)
@@ -184,12 +187,17 @@ GLFUNC(PFNGLINVALIDATETEXIMAGEPROC, glInvalidateTexImage)
 
 // texture DSA
 
+GLFUNC(PFNGLCREATETEXTURESPROC, glCreateTextures)
 GLFUNC(PFNGLBINDTEXTUREUNITPROC, glBindTextureUnit)
 GLFUNC(PFNGLGETTEXTURELEVELPARAMETERIVPROC, glGetTextureLevelParameteriv)
 GLFUNC(PFNGLTEXTUREPARAMETERIPROC, glTextureParameteri)
 GLFUNC(PFNGLGETTEXTURESUBIMAGEPROC, glGetTextureSubImage)
+GLFUNC(PFNGLTEXTURESUBIMAGE1DPROC, glTextureSubImage1D)
 GLFUNC(PFNGLTEXTURESUBIMAGE2DPROC, glTextureSubImage2D);
 GLFUNC(PFNGLTEXTURESUBIMAGE3DPROC, glTextureSubImage3D)
+GLFUNC(PFNGLTEXTURESTORAGE1DPROC, glTextureStorage1D)
+GLFUNC(PFNGLTEXTURESTORAGE2DPROC, glTextureStorage2D)
+GLFUNC(PFNGLTEXTURESTORAGE3DPROC, glTextureStorage3D)
 
 // instancing / draw
 
@@ -283,8 +291,13 @@ GLFUNC(PFNGLDEBUGMESSAGECONTROLPROC, glDebugMessageControl)
 
 // wgl
 
-#if BOOST_OS_WINDOWS > 0
+#if BOOST_OS_WINDOWS
 GLFUNC(PFNWGLSWAPINTERVALEXTPROC, wglSwapIntervalEXT)
 #endif
 
-// x
\ No newline at end of file
+// x
+
+#if BOOST_OS_LINUX
+EGLFUNC(PFNEGLSWAPINTERVALPROC, eglSwapInterval)
+EGLFUNC(PFNEGLGETCURRENTDISPLAYPROC, eglGetCurrentDisplay)
+#endif
diff --git a/src/Common/MemPtr.h b/src/Common/MemPtr.h
index 7ad5b76f..2dc92040 100644
--- a/src/Common/MemPtr.h
+++ b/src/Common/MemPtr.h
@@ -2,149 +2,189 @@
 #include <type_traits>
 #include "betype.h"
 
+using MPTR = uint32; // generic address in PowerPC memory space
+
+#define MPTR_NULL (0)
+
+using VAddr = uint32; // virtual address
+using PAddr = uint32; // physical address
+
 extern uint8* memory_base;
 extern uint8* PPCInterpreterGetStackPointer();
-extern uint8* PPCInterpreterGetAndModifyStackPointer(sint32 offset);
+extern uint8* PPCInterpreter_PushAndReturnStackPointer(sint32 offset);
 extern void PPCInterpreterModifyStackPointer(sint32 offset);
 
-class MEMPTRBase {};
+class MEMPTRBase
+{
+};
 
-template <typename T>
+template<typename T>
 class MEMPTR : MEMPTRBase
 {
-public:
-	constexpr MEMPTR()
-		: m_value(0) { }
+  public:
+	constexpr MEMPTR() noexcept
+		: m_value(0) {}
 
-	explicit constexpr MEMPTR(uint32 offset)
-		: m_value(offset) { }
+	explicit constexpr MEMPTR(uint32 offset) noexcept
+		: m_value(offset) {}
 
-	explicit constexpr MEMPTR(const uint32be& offset)
-		: m_value(offset) { }
+	explicit constexpr MEMPTR(const uint32be& offset) noexcept
+		: m_value(offset) {}
 
-	constexpr MEMPTR(std::nullptr_t)
-		: m_value(0) { }
+	constexpr MEMPTR(std::nullptr_t) noexcept
+		: m_value(0) {}
 
-	MEMPTR(T* ptr)
+	MEMPTR(T* ptr) noexcept
 	{
 		if (ptr == nullptr)
 			m_value = 0;
 		else
+		{
+			cemu_assert_debug((uint8*)ptr >= memory_base && (uint8*)ptr <= memory_base + 0x100000000);
 			m_value = (uint32)((uintptr_t)ptr - (uintptr_t)memory_base);
+		}
 	}
 
-	constexpr MEMPTR(const MEMPTR& memptr)
-		: m_value(memptr.m_value) { }
+	constexpr MEMPTR(const MEMPTR&) noexcept = default;
 
-	constexpr MEMPTR& operator=(const MEMPTR& memptr)
-	{
-		m_value = memptr.m_value;
-		return *this;
-	}
+	constexpr MEMPTR& operator=(const MEMPTR&) noexcept = default;
 
-	constexpr MEMPTR& operator=(const uint32& offset)
+	constexpr MEMPTR& operator=(const uint32& offset) noexcept
 	{
 		m_value = offset;
 		return *this;
 	}
 
-	constexpr MEMPTR& operator=(const std::nullptr_t rhs)
+	constexpr MEMPTR& operator=(std::nullptr_t) noexcept
 	{
 		m_value = 0;
 		return *this;
 	}
 
-	MEMPTR& operator=(T* ptr)
+	MEMPTR& operator=(T* ptr) noexcept
 	{
 		if (ptr == nullptr)
 			m_value = 0;
 		else
+		{
+			cemu_assert_debug((uint8*)ptr >= memory_base && (uint8*)ptr <= memory_base + 0x100000000);
 			m_value = (uint32)((uintptr_t)ptr - (uintptr_t)memory_base);
+		}
 		return *this;
 	}
 
-	bool atomic_compare_exchange(T* comparePtr, T* newPtr)
+	bool atomic_compare_exchange(T* comparePtr, T* newPtr) noexcept
 	{
 		MEMPTR<T> mp_compare = comparePtr;
 		MEMPTR<T> mp_new = newPtr;
-		std::atomic<uint32be>* thisValueAtomic = (std::atomic<uint32be>*)&m_value;
+		auto* thisValueAtomic = reinterpret_cast<std::atomic<uint32be>*>(&m_value);
 		return thisValueAtomic->compare_exchange_strong(mp_compare.m_value, mp_new.m_value);
 	}
 
-	explicit constexpr operator bool() const noexcept { return m_value != 0; }
-	
-	constexpr operator T*() const noexcept { return GetPtr(); } // allow implicit cast to wrapped pointer type
-
-
-	template <typename X>
-	explicit operator MEMPTR<X>() const { return MEMPTR<X>(this->m_value); }
-
-	//bool operator==(const MEMPTR<T>& v) const { return m_value == v.m_value; }
-	//bool operator==(const T* rhs) const { return (T*)(m_value == 0 ? nullptr : memory_base + (uint32)m_value) == rhs; } -> ambigious (implicit cast to T* allows for T* == T*)
-	//bool operator==(std::nullptr_t rhs) const { return m_value == 0; }
-
-	//bool operator!=(const MEMPTR<T>& v) const { return !(*this == v); }
-	//bool operator!=(const void* rhs) const { return !(*this == rhs); }
-	//bool operator!=(int rhs) const { return !(*this == rhs); }
-
-	//bool operator==(const void* rhs) const { return (void*)(m_value == 0 ? nullptr : memory_base + (uint32)m_value) == rhs; }
-
-	//explicit bool operator==(int rhs) const { return *this == (const void*)(size_t)rhs; }
-	
-
-	MEMPTR operator+(const MEMPTR& ptr) { return MEMPTR(this->GetMPTR() + ptr.GetMPTR()); }
-	MEMPTR operator-(const MEMPTR& ptr) { return MEMPTR(this->GetMPTR() - ptr.GetMPTR()); }
-
-	MEMPTR operator+(sint32 v)
+	explicit constexpr operator bool() const noexcept
 	{
-		// pointer arithmetic
-		return MEMPTR(this->GetMPTR() + v * 4);
+		return m_value != 0;
 	}
 
-	MEMPTR operator-(sint32 v)
+	// allow implicit cast to wrapped pointer type
+	constexpr operator T*() const noexcept
 	{
-		// pointer arithmetic
-		return MEMPTR(this->GetMPTR() - v * 4);
+		return GetPtr();
 	}
 
-	template <class Q = T>
-	typename std::enable_if<!std::is_same<Q, void>::value, Q>::type&
-	operator*() const { return *GetPtr(); }
+	template<typename X>
+	explicit operator MEMPTR<X>() const noexcept
+	{
+		return MEMPTR<X>(this->m_value);
+	}
 
-	T* operator->() const { return GetPtr(); }
+	sint32 operator-(const MEMPTR& ptr) noexcept
+		requires(!std::is_void_v<T>)
+	{
+		return static_cast<sint32>(this->GetMPTR() - ptr.GetMPTR());
+	}
 
-	template <class Q = T>
-	typename std::enable_if<!std::is_same<Q, void>::value, Q>::type&
-	operator[](int index) { return GetPtr()[index]; }
+	MEMPTR operator+(sint32 v) noexcept
+		requires(!std::is_void_v<T>)
+	{
+		// pointer arithmetic
+		return MEMPTR(this->GetMPTR() + v * sizeof(T));
+	}
 
-	T* GetPtr() const { return (T*)(m_value == 0 ? nullptr : memory_base + (uint32)m_value); }
+	MEMPTR operator-(sint32 v) noexcept
+		requires(!std::is_void_v<T>)
+	{
+		// pointer arithmetic
+		return MEMPTR(this->GetMPTR() - v * sizeof(T));
+	}
 
-	template <typename C>
-	C* GetPtr() const { return (C*)(GetPtr()); }
+	MEMPTR& operator+=(sint32 v) noexcept
+		requires(!std::is_void_v<T>)
+	{
+		m_value += v * sizeof(T);
+		return *this;
+	}
 
-	constexpr uint32 GetMPTR() const { return m_value.value(); }
-	constexpr uint32 GetRawValue() const { return m_value.bevalue(); } // accesses value using host-endianness
+	template<typename Q = T>
+		requires(!std::is_void_v<Q>)
+	Q& operator*() const noexcept
+	{
+		return *GetPtr();
+	}
 
-	constexpr const uint32be& GetBEValue() const { return m_value; }
+	constexpr T* operator->() const noexcept
+	{
+		return GetPtr();
+	}
 
-	constexpr bool IsNull() const { return m_value == 0; }
+	template<typename Q = T>
+		requires(!std::is_void_v<Q>)
+	Q& operator[](int index) noexcept
+	{
+		return GetPtr()[index];
+	}
 
-	constexpr uint32 GetMPTRBE() const { return m_value.bevalue(); }
+	T* GetPtr() const noexcept
+	{
+		return (T*)(m_value == 0 ? nullptr : memory_base + (uint32)m_value);
+	}
 
-	uint32be* GetBEPtr() { return &m_value; }
+	template<typename C>
+	C* GetPtr() const noexcept
+	{
+		return static_cast<C*>(GetPtr());
+	}
 
-private:
+	[[nodiscard]] constexpr uint32 GetMPTR() const noexcept
+	{
+		return m_value.value();
+	}
+	[[nodiscard]] constexpr const uint32be& GetBEValue() const noexcept
+	{
+		return m_value;
+	}
+
+	[[nodiscard]] constexpr bool IsNull() const noexcept
+	{
+		return m_value == 0;
+	}
+
+  private:
 	uint32be m_value;
 };
 
 static_assert(sizeof(MEMPTR<void*>) == sizeof(uint32be));
+static_assert(std::is_trivially_copyable_v<MEMPTR<void*>>);
 
 #include "StackAllocator.h"
 #include "SysAllocator.h"
 
-template <typename T>
+template<typename T>
 struct fmt::formatter<MEMPTR<T>> : formatter<string_view>
 {
-	template <typename FormatContext>
-	auto format(const MEMPTR<T>& v, FormatContext& ctx) { return formatter<string_view>::format(fmt::format("{:#x}", v.GetMPTR()), ctx); }
+	template<typename FormatContext>
+	auto format(const MEMPTR<T>& v, FormatContext& ctx) const -> format_context::iterator
+	{
+		return fmt::format_to(ctx.out(), "{:#x}", v.GetMPTR());
+	}
 };
diff --git a/src/Common/StackAllocator.h b/src/Common/StackAllocator.h
index 750db13f..856224cf 100644
--- a/src/Common/StackAllocator.h
+++ b/src/Common/StackAllocator.h
@@ -10,14 +10,16 @@ public:
 
 	explicit StackAllocator(const uint32 items)
 	{
+		m_items = items;
 		m_modified_size = count * sizeof(T) * items + kStaticMemOffset * 2;
-
-		auto tmp = PPCInterpreterGetStackPointer();
-		m_ptr = (T*)(PPCInterpreterGetAndModifyStackPointer(m_modified_size) + kStaticMemOffset);
+		m_modified_size = (m_modified_size/8+7) * 8; // pad to 8 bytes
+		m_ptr = new(PPCInterpreter_PushAndReturnStackPointer(m_modified_size) + kStaticMemOffset) T[count * items]();
 	}
 
 	~StackAllocator()
 	{
+		for (size_t i = 0; i < count * m_items; ++i)
+			m_ptr[i].~T();
 		PPCInterpreterModifyStackPointer(-m_modified_size);
 	}
 
@@ -28,14 +30,41 @@ public:
 
 	T* GetPointer() const { return m_ptr; }
 	uint32 GetMPTR() const { return MEMPTR<T>(m_ptr).GetMPTR(); }
-	uint32 GetMPTRBE() const { return MEMPTR<T>(m_ptr).GetMPTRBE(); }
-	
-	operator T*() const { return GetPointer(); }
+
+	T* operator&() { return GetPointer(); }
+	explicit operator T*() const { return GetPointer(); }
 	explicit operator uint32() const { return GetMPTR(); }
+	explicit operator bool() const { return *m_ptr != 0; }
+
+	// for arrays (count > 1) allow direct access via [] operator
+	template<int c = count>
+	requires (c > 1)
+	T& operator[](const uint32 index)
+	{
+		return m_ptr[index];
+	}
+
+	// if count is 1, then allow direct value assignment via = operator
+	template<int c = count>
+	requires (c == 1)
+	T& operator=(const T& rhs)
+	{
+		*m_ptr = rhs;
+		return *m_ptr;
+	}
+
+	// if count is 1, then allow == and != operators
+	template<int c = count>
+	requires (c == 1)
+	bool operator==(const T& rhs) const
+	{
+		return *m_ptr == rhs;
+	}
 
 private:
 	static const uint32 kStaticMemOffset = 64;
 
 	T* m_ptr;
 	sint32 m_modified_size;
+	uint32 m_items;
 };
\ No newline at end of file
diff --git a/src/Common/SysAllocator.h b/src/Common/SysAllocator.h
index a9bc0da1..7a11601e 100644
--- a/src/Common/SysAllocator.h
+++ b/src/Common/SysAllocator.h
@@ -1,10 +1,10 @@
 #pragma once
 
-#include <vector>
-
 uint32 coreinit_allocFromSysArea(uint32 size, uint32 alignment);
 class SysAllocatorBase;
 
+#define SYSALLOCATOR_GUARDS		0	// if 1, create a magic constant at the top of each memory allocation which is used to check for memory corruption
+
 class SysAllocatorContainer
 {
 public:
@@ -29,9 +29,7 @@ private:
 	virtual void Initialize() = 0;
 };
 
-
-
-template<typename T, size_t count = 1, size_t alignment = 8>
+template<typename T, size_t count = 1, size_t alignment = 32>
 class SysAllocator : public SysAllocatorBase
 {
 public:
@@ -49,6 +47,13 @@ public:
 			m_tempData.insert(m_tempData.end(), count - l.size(), T());
 	}
 
+	template <size_t N>
+	SysAllocator(const char(&str)[N])
+	{
+		m_tempData.reserve(count);
+		m_tempData.insert(m_tempData.begin(), str, str + N);
+	}
+
 	constexpr uint32 GetCount() const
 	{
 		return count;
@@ -61,11 +66,17 @@ public:
 
 	T* GetPtr() const
 	{
+#if SYSALLOCATOR_GUARDS
+		cemu_assert(*(uint32*)((uint8*)m_sysMem.GetPtr()+(sizeof(T) * count)) == 0x112A33C4);
+#endif
 		return m_sysMem.GetPtr();
 	}
 
 	uint32 GetMPTR() const
 	{
+#if SYSALLOCATOR_GUARDS
+		cemu_assert(*(uint32*)((uint8*)m_sysMem.GetPtr()+(sizeof(T) * count)) == 0x112A33C4);
+#endif
 		return m_sysMem.GetMPTR();
 	}
 
@@ -123,11 +134,17 @@ private:
 	{
 		if (m_sysMem.GetMPTR() != 0)
 			return;
-
 		// alloc mem
-		m_sysMem = { coreinit_allocFromSysArea(sizeof(T) * count, alignment) };
+		uint32 guardSize = 0;
+#if SYSALLOCATOR_GUARDS
+		guardSize = 4;
+#endif
+		m_sysMem = { coreinit_allocFromSysArea(sizeof(T) * count + guardSize, alignment) };
 		// copy temp buffer to mem and clear it
 		memcpy(m_sysMem.GetPtr(), m_tempData.data(), sizeof(T)*count);
+#if SYSALLOCATOR_GUARDS
+		*(uint32*)((uint8*)m_sysMem.GetPtr()+(sizeof(T) * count)) = 0x112A33C4;
+#endif
 		m_tempData.clear();
 	}
 
@@ -135,6 +152,9 @@ private:
 	std::vector<T> m_tempData;
 };
 
+template <size_t N>
+SysAllocator(const char(&str)[N]) -> SysAllocator<char, N>;
+
 template<typename T>
 class SysAllocator<T, 1> : public SysAllocatorBase
 {
@@ -187,9 +207,8 @@ private:
 	{
 		if (m_sysMem.GetMPTR() != 0)
 			return;
-
 		// alloc mem
-		m_sysMem = { coreinit_allocFromSysArea(sizeof(T), 8) };
+		m_sysMem = { coreinit_allocFromSysArea(sizeof(T), 32) };
 		// copy temp buffer to mem and clear it
 		*m_sysMem = m_tempData;
 	}
diff --git a/src/Common/betype.h b/src/Common/betype.h
index e684fb93..60a64b7a 100644
--- a/src/Common/betype.h
+++ b/src/Common/betype.h
@@ -121,6 +121,12 @@ public:
 		return *this;
 	}
 
+	betype<T>& operator+=(const T& v) requires std::integral<T>
+	{
+		m_value = SwapEndian(T(value() + v));
+		return *this;
+	}
+
 	betype<T>& operator-=(const betype<T>& v)
 	{
 		m_value = SwapEndian(T(value() - v.value()));
@@ -188,17 +194,36 @@ public:
 		return from_bevalue(T(~m_value));
 	}
 
+	// pre-increment
 	betype<T>& operator++() requires std::integral<T>
 	{
 		m_value = SwapEndian(T(value() + 1));
 		return *this;
 	}
 
+	// post-increment
+	betype<T> operator++(int) requires std::integral<T>
+	{
+		betype<T> tmp(*this);
+		m_value = SwapEndian(T(value() + 1));
+		return tmp;
+	}
+
+	// pre-decrement
 	betype<T>& operator--() requires std::integral<T>
 	{
 		m_value = SwapEndian(T(value() - 1));
 		return *this;
 	}
+
+	// post-decrement
+	betype<T> operator--(int) requires std::integral<T>
+	{
+		betype<T> tmp(*this);
+		m_value = SwapEndian(T(value() - 1));
+		return tmp;
+	}
+
 private:
 	//T m_value{}; // before 1.26.2
 	T m_value;
diff --git a/src/Common/cpu_features.cpp b/src/Common/cpu_features.cpp
new file mode 100644
index 00000000..dfea8851
--- /dev/null
+++ b/src/Common/cpu_features.cpp
@@ -0,0 +1,101 @@
+#include "cpu_features.h"
+
+// wrappers with uniform prototype for implementation-specific x86 CPU id
+#if defined(ARCH_X86_64)
+#ifdef __GNUC__
+#include <cpuid.h>
+#endif
+
+inline void cpuid(int cpuInfo[4], int functionId) {
+#if defined(_MSC_VER)
+	__cpuid(cpuInfo, functionId);
+#elif defined(__GNUC__)
+	__cpuid(functionId, cpuInfo[0], cpuInfo[1], cpuInfo[2], cpuInfo[3]);
+#else
+#error No definition for cpuid
+#endif
+}
+
+inline void cpuidex(int cpuInfo[4], int functionId, int subFunctionId) {
+#if defined(_MSC_VER)
+	__cpuidex(cpuInfo, functionId, subFunctionId);
+#elif defined(__GNUC__)
+	__cpuid_count(functionId, subFunctionId, cpuInfo[0], cpuInfo[1], cpuInfo[2], cpuInfo[3]);
+#else
+#error No definition for cpuidex
+#endif
+}
+#endif
+
+
+CPUFeaturesImpl::CPUFeaturesImpl()
+{
+#if defined(ARCH_X86_64)
+	int cpuInfo[4];
+	cpuid(cpuInfo, 0x80000001);
+	x86.lzcnt = ((cpuInfo[2] >> 5) & 1) != 0;
+	cpuid(cpuInfo, 0x1);
+	x86.movbe = ((cpuInfo[2] >> 22) & 1) != 0;
+	x86.avx = ((cpuInfo[2] >> 28) & 1) != 0;
+	x86.aesni = ((cpuInfo[2] >> 25) & 1) != 0;
+	x86.ssse3 = ((cpuInfo[2] >> 9) & 1) != 0;
+	x86.sse4_1 = ((cpuInfo[2] >> 19) & 1) != 0;
+	cpuidex(cpuInfo, 0x7, 0);
+	x86.avx2 = ((cpuInfo[1] >> 5) & 1) != 0;
+	x86.bmi2 = ((cpuInfo[1] >> 8) & 1) != 0;
+	cpuid(cpuInfo, 0x80000007);
+	x86.invariant_tsc = ((cpuInfo[3] >> 8) & 1);
+	// get CPU brand name
+	uint32_t nExIds, i = 0;
+	memset(m_cpuBrandName, 0, sizeof(m_cpuBrandName));
+	cpuid(cpuInfo, 0x80000000);
+	nExIds = (uint32_t)cpuInfo[0];
+	for (uint32_t i = 0x80000000; i <= nExIds; ++i)
+	{
+		cpuid(cpuInfo, i);
+		if (i == 0x80000002)
+			memcpy(m_cpuBrandName, cpuInfo, sizeof(cpuInfo));
+		else if (i == 0x80000003)
+			memcpy(m_cpuBrandName + 16, cpuInfo, sizeof(cpuInfo));
+		else if (i == 0x80000004)
+			memcpy(m_cpuBrandName + 32, cpuInfo, sizeof(cpuInfo));
+	}
+#endif
+}
+
+std::string CPUFeaturesImpl::GetCPUName()
+{
+	return { m_cpuBrandName };
+}
+
+std::string CPUFeaturesImpl::GetCommaSeparatedExtensionList()
+{
+	std::string tmp;
+	auto appendExt = [&tmp](const char* str)
+	{
+		if (!tmp.empty())
+			tmp.append(", ");
+		tmp.append(str);
+	};
+	if (x86.ssse3)
+		appendExt("SSSE3");
+	if (x86.sse4_1)
+		appendExt("SSE4.1");
+	if (x86.avx)
+		appendExt("AVX");
+	if (x86.avx2)
+		appendExt("AVX2");
+	if (x86.lzcnt)
+		appendExt("LZCNT");
+	if (x86.movbe)
+		appendExt("MOVBE");
+	if (x86.bmi2)
+		appendExt("BMI2");
+	if (x86.aesni)
+		appendExt("AES-NI");
+	if(x86.invariant_tsc)
+		appendExt("INVARIANT-TSC");
+	return tmp;
+}
+
+CPUFeaturesImpl g_CPUFeatures;
diff --git a/src/Common/cpu_features.h b/src/Common/cpu_features.h
new file mode 100644
index 00000000..130b51a8
--- /dev/null
+++ b/src/Common/cpu_features.h
@@ -0,0 +1,36 @@
+
+#ifdef __GNUC__
+#define ATTRIBUTE_AVX2 __attribute__((target("avx2")))
+#define ATTRIBUTE_SSE41 __attribute__((target("sse4.1")))
+#define ATTRIBUTE_AESNI __attribute__((target("aes")))
+#else
+#define ATTRIBUTE_AVX2
+#define ATTRIBUTE_SSE41
+#define ATTRIBUTE_AESNI
+#endif
+
+class CPUFeaturesImpl
+{
+public:
+	CPUFeaturesImpl();
+
+	std::string GetCPUName(); // empty if not available
+	std::string GetCommaSeparatedExtensionList();
+
+	struct
+	{
+		bool ssse3{ false };
+		bool sse4_1{ false };
+		bool avx{ false };
+		bool avx2{ false };
+		bool lzcnt{ false };
+		bool movbe{ false };
+		bool bmi2{ false };
+		bool aesni{ false };
+		bool invariant_tsc{ false };
+	}x86;
+private:
+	char m_cpuBrandName[0x40]{ 0 };
+};
+
+extern CPUFeaturesImpl g_CPUFeatures;
\ No newline at end of file
diff --git a/src/Common/precompiled.h b/src/Common/precompiled.h
index 57f69c57..26fdfd28 100644
--- a/src/Common/precompiled.h
+++ b/src/Common/precompiled.h
@@ -24,13 +24,22 @@
 // }
 // #endif
 
+// arch defines
+
+#if defined(__x86_64__) || defined(_M_X64) || defined(_M_AMD64)
+#define ARCH_X86_64
+#endif
+
 // c includes
 #include <cstdint>
 #include <cstdlib>
 #include <cmath>
 #include <ctime>
 #include <cassert>
+
+#if defined(ARCH_X86_64)
 #include <immintrin.h>
+#endif
 
 // c++ includes
 #include <string>
@@ -60,23 +69,23 @@
 #include <filesystem>
 #include <memory>
 #include <chrono>
+#include <ctime>
 #include <regex>
 #include <type_traits>
 #include <optional>
 #include <span>
+#include <ranges>
 
 #include <boost/predef.h>
 #include <boost/nowide/convert.hpp>
 #include <boost/algorithm/string.hpp>
 #include <boost/asio.hpp>
-#include <boost/filesystem.hpp>
 #include <glm/glm.hpp>
 #include <glm/gtc/quaternion.hpp>
 
 namespace fs = std::filesystem;
 
 #include "enumFlags.h"
-#include "zstring_view.h"
 
 // base types
 using uint64 = uint64_t;
@@ -89,11 +98,6 @@ using sint32 = int32_t;
 using sint16 = int16_t;
 using sint8 = int8_t;
 
-using MPTR = uint32;
-using MPTR_UINT8 = uint32;
-using MPTR_UINT16 = uint32;
-using MPTR_UINT32 = uint32;
-
 // types with explicit big endian order
 #include "betype.h"
 
@@ -107,11 +111,6 @@ using uint8le = uint8_t;
 #include "Cemu/Logging/CemuDebugLogging.h"
 #include "Cemu/Logging/CemuLogging.h"
 
-// CPU extensions
-extern bool _cpuExtension_SSSE3;
-extern bool _cpuExtension_SSE4_1;
-extern bool _cpuExtension_AVX2;
-
 // manual endian-swapping
 
 #if _MSC_VER
@@ -210,6 +209,21 @@ typedef union _LARGE_INTEGER {
     inline T& operator^= (T& a, T b) { return reinterpret_cast<T&>( reinterpret_cast<std::underlying_type<T>::type&>(a) ^= static_cast<std::underlying_type<T>::type>(b) ); }
 #endif
 
+template<typename T>
+inline T GetBits(T value, uint32 index, uint32 numBits)
+{
+	T mask = (1<<numBits)-1;
+	return (value>>index) & mask;
+}
+
+template<typename T>
+inline void SetBits(T& value, uint32 index, uint32 numBits, uint32 bitValue)
+{
+	T mask = (1<<numBits)-1;
+	value &= ~(mask << index);
+	value |= (bitValue << index);
+}
+
 #if !defined(_MSC_VER) || defined(__clang__) // clang-cl does not have built-in _udiv128
 inline uint64 _udiv128(uint64 highDividend, uint64 lowDividend, uint64 divisor, uint64 *remainder)
 {
@@ -221,10 +235,18 @@ inline uint64 _udiv128(uint64 highDividend, uint64 lowDividend, uint64 divisor,
 
 #if defined(_MSC_VER)
     #define UNREACHABLE __assume(false)
-#elif defined(__GNUC__)
+	#define ASSUME(__cond) __assume(__cond)
+	#define TLS_WORKAROUND_NOINLINE // no-op for MSVC as it has a flag for fiber-safe TLS optimizations
+#elif defined(__GNUC__) && !defined(__llvm__)
     #define UNREACHABLE __builtin_unreachable()
+	#define ASSUME(__cond) __attribute__((assume(__cond)))
+	#define TLS_WORKAROUND_NOINLINE __attribute__((noinline))
+#elif defined(__clang__)
+	#define UNREACHABLE __builtin_unreachable()
+	#define ASSUME(__cond) __builtin_assume(__cond)
+	#define TLS_WORKAROUND_NOINLINE __attribute__((noinline))
 #else
-    #define UNREACHABLE
+    #error Unknown compiler
 #endif
 
 #if defined(_MSC_VER)
@@ -246,112 +268,64 @@ inline uint64 _udiv128(uint64 highDividend, uint64 lowDividend, uint64 divisor,
     #error No definition for DLLEXPORT
 #endif
 
-#ifdef __GNUC__
-#include <cpuid.h>
-#endif
-
-inline void cpuid(int cpuInfo[4], int functionId) {
-#if defined(_MSC_VER)
-    __cpuid(cpuInfo, functionId);
+#if BOOST_OS_WINDOWS
+	#define NOEXPORT
 #elif defined(__GNUC__)
-    __cpuid(functionId, cpuInfo[0], cpuInfo[1], cpuInfo[2], cpuInfo[3]);
-#else
-    #error No definition for cpuid
+	#define NOEXPORT __attribute__ ((visibility ("hidden")))
 #endif
-}
 
-inline void cpuidex(int cpuInfo[4], int functionId, int subFunctionId) {
 #if defined(_MSC_VER)
-    __cpuidex(cpuInfo, functionId, subFunctionId);
-#elif defined(__GNUC__)
-    __cpuid_count(functionId, subFunctionId, cpuInfo[0], cpuInfo[1], cpuInfo[2], cpuInfo[3]);
+#define FORCE_INLINE __forceinline
+#elif defined(__GNUC__) || defined(__clang__)
+#define FORCE_INLINE inline __attribute__((always_inline))
 #else
-    #error No definition for cpuidex
+#define FORCE_INLINE inline
+#endif
+
+FORCE_INLINE int BSF(uint32 v) // returns index of first bit set, counting from LSB. If v is 0 then result is undefined
+{
+#if defined(_MSC_VER)
+	return _tzcnt_u32(v); // TZCNT requires BMI1. But if not supported it will execute as BSF
+#elif defined(__GNUC__) || defined(__clang__)
+	return __builtin_ctz(v);
+#else
+	return std::countr_zero(v);
 #endif
 }
 
+// On aarch64 we handle some of the x86 intrinsics by implementing them as wrappers
+#if defined(__aarch64__)
 
-// MEMPTR
-#include "Common/MemPtr.h"
-
-#define MPTR_NULL	(0)
-
-template <typename T1, typename T2>
-constexpr bool HAS_FLAG(T1 flags, T2 test_flag) { return (flags & (T1)test_flag) == (T1)test_flag; }
-template <typename T1, typename T2>
-constexpr bool HAS_BIT(T1 value, T2 index) { return (value & ((T1)1 << index)) != 0; }
-template <typename T>
-constexpr void SAFE_RELEASE(T& p) { if (p) { p->Release(); p = nullptr; } }
-
-template <typename T>
-constexpr uint32_t ppcsizeof() { return (uint32_t) sizeof(T); }
-
-// common utility functions
-
-template <typename T>
-void vectorAppendUnique(std::vector<T>& vec, const T& val) // for cases where a small vector is more efficient than a set
+inline void _mm_pause()
 {
-    if (std::find(vec.begin(), vec.end(), val) != vec.end())
-        return;
-    vec.emplace_back(val);
+    asm volatile("yield");
 }
 
-template <typename T>
-void vectorRemoveByValue(std::vector<T>& vec, const T& val)
+inline uint64 __rdtsc()
 {
-    vec.erase(std::remove(vec.begin(), vec.end(), val), vec.end());
+    uint64 t;
+    asm volatile("mrs %0, cntvct_el0" : "=r" (t));
+    return t;
 }
 
-template <typename T>
-void vectorRemoveByIndex(std::vector<T>& vec, const size_t index)
+inline void _mm_mfence()
 {
-    vec.erase(vec.begin() + index);
+	asm volatile("" ::: "memory");
+	std::atomic_thread_fence(std::memory_order_seq_cst);
 }
 
-template<typename T1, typename T2>
-int match_any_of(T1 value, T2 compareTo)
+inline unsigned char _addcarry_u64(unsigned char carry, unsigned long long a, unsigned long long b, unsigned long long *result)
 {
-    return value == compareTo;
+    *result = a + b + (unsigned long long)carry;
+    if (*result < a)
+        return 1;
+    return 0;
 }
 
-template<typename T1, typename T2, typename... Types>
-bool match_any_of(T1 value, T2 compareTo, Types&&... others)
-{
-    return value == compareTo || match_any_of(value, others...);
-}
-
-// we cache the frequency in a static variable
-[[nodiscard]] static std::chrono::high_resolution_clock::time_point now_cached() noexcept
-{
-#ifdef _WIN32
-    // get current time
-	static const long long _Freq = _Query_perf_frequency();	// doesn't change after system boot
-	const long long _Ctr = _Query_perf_counter();
-	static_assert(std::nano::num == 1, "This assumes period::num == 1.");
-	const long long _Whole = (_Ctr / _Freq) * std::nano::den;
-	const long long _Part = (_Ctr % _Freq) * std::nano::den / _Freq;
-	return (std::chrono::high_resolution_clock::time_point(std::chrono::nanoseconds(_Whole + _Part)));
-#else
-    return std::chrono::high_resolution_clock::now();
 #endif
-}
 
+// asserts
 
-[[nodiscard]] static std::chrono::steady_clock::time_point tick_cached() noexcept
-{
-#ifdef _WIN32
-    // get current time
-	static const long long _Freq = _Query_perf_frequency();	// doesn't change after system boot
-	const long long _Ctr = _Query_perf_counter();
-	static_assert(std::nano::num == 1, "This assumes period::num == 1.");
-	const long long _Whole = (_Ctr / _Freq) * std::nano::den;
-	const long long _Part = (_Ctr % _Freq) * std::nano::den / _Freq;
-	return (std::chrono::steady_clock::time_point(std::chrono::nanoseconds(_Whole + _Part)));
-#else
-    // todo: Add faster implementation for linux
-    return std::chrono::steady_clock::now();
-#endif
-}
 
 inline void cemu_assert(bool _condition)
 {
@@ -361,7 +335,7 @@ inline void cemu_assert(bool _condition)
     }
 }
 
-#ifdef PUBLIC_RELEASE
+#ifndef CEMU_DEBUG_ASSERT
 //#define cemu_assert_debug(__cond) -> Forcing __cond not to be evaluated currently has unexpected side-effects
 
 inline void cemu_assert_debug(bool _condition)
@@ -405,6 +379,82 @@ inline void cemu_assert_error()
 
 #define assert_dbg() DEBUG_BREAK // old style unconditional generic assert
 
+// MEMPTR
+#include "Common/MemPtr.h"
+
+template <typename T1, typename T2>
+constexpr bool HAS_FLAG(T1 flags, T2 test_flag) { return (flags & (T1)test_flag) == (T1)test_flag; }
+template <typename T1, typename T2>
+constexpr bool HAS_BIT(T1 value, T2 index) { return (value & ((T1)1 << index)) != 0; }
+
+template <typename T>
+constexpr uint32_t ppcsizeof() { return (uint32_t) sizeof(T); }
+
+// common utility functions
+
+template <typename T>
+void vectorAppendUnique(std::vector<T>& vec, const T& val) // for cases where a small vector is more efficient than a set
+{
+    if (std::find(vec.begin(), vec.end(), val) != vec.end())
+        return;
+    vec.emplace_back(val);
+}
+
+template <typename T>
+void vectorRemoveByValue(std::vector<T>& vec, const T& val)
+{
+    vec.erase(std::remove(vec.begin(), vec.end(), val), vec.end());
+}
+
+template <typename T>
+void vectorRemoveByIndex(std::vector<T>& vec, const size_t index)
+{
+    vec.erase(vec.begin() + index);
+}
+
+template<typename T1, typename... Types>
+bool match_any_of(T1&& value, Types&&... others)
+{
+    return ((value == others) || ...);
+}
+
+// we cache the frequency in a static variable
+[[nodiscard]] static std::chrono::high_resolution_clock::time_point now_cached() noexcept
+{
+#ifdef _WIN32
+    // get current time
+	static const long long _Freq = _Query_perf_frequency();	// doesn't change after system boot
+	const long long _Ctr = _Query_perf_counter();
+	static_assert(std::nano::num == 1, "This assumes period::num == 1.");
+	const long long _Whole = (_Ctr / _Freq) * std::nano::den;
+	const long long _Part = (_Ctr % _Freq) * std::nano::den / _Freq;
+	return (std::chrono::high_resolution_clock::time_point(std::chrono::nanoseconds(_Whole + _Part)));
+#else
+    return std::chrono::high_resolution_clock::now();
+#endif
+}
+
+[[nodiscard]] static std::chrono::steady_clock::time_point tick_cached() noexcept
+{
+#if BOOST_OS_WINDOWS
+    // get current time
+	static const long long _Freq = _Query_perf_frequency();	// doesn't change after system boot
+	const long long _Ctr = _Query_perf_counter();
+	static_assert(std::nano::num == 1, "This assumes period::num == 1.");
+	const long long _Whole = (_Ctr / _Freq) * std::nano::den;
+	const long long _Part = (_Ctr % _Freq) * std::nano::den / _Freq;
+	return (std::chrono::steady_clock::time_point(std::chrono::nanoseconds(_Whole + _Part)));
+#elif BOOST_OS_LINUX
+	struct timespec tp;
+	clock_gettime(CLOCK_MONOTONIC_RAW, &tp);
+	return std::chrono::steady_clock::time_point(
+		std::chrono::seconds(tp.tv_sec) + std::chrono::nanoseconds(tp.tv_nsec));
+#elif BOOST_OS_MACOS
+	return std::chrono::steady_clock::time_point(
+		std::chrono::nanoseconds(clock_gettime_nsec_np(CLOCK_MONOTONIC_RAW)));
+#endif
+}
+
 // Some string conversion helpers because C++20 std::u8string is too cumbersome to use in practice
 // mixing string types generally causes loads of issues and many of the libraries we use dont expose interfaces for u8string
 
@@ -435,6 +485,14 @@ inline fs::path _utf8ToPath(std::string_view input)
     return fs::path(v);
 }
 
+// locale-independent variant of tolower() which also matches Wii U behavior
+inline char _ansiToLower(char c)
+{
+	if (c >= 'A' && c <= 'Z')
+		c -= ('A' - 'a');
+	return c;
+}
+
 class RunAtCemuBoot // -> replaces this with direct function calls. Linkers other than MSVC may optimize way object files entirely if they are not referenced from outside. So a source file self-registering using this would be causing issues
 {
 public:
@@ -455,12 +513,15 @@ bool future_is_ready(std::future<T>& f)
 #endif
 }
 
+
 // helper function to cast raw pointers to std::atomic
 // this is technically not legal but works on most platforms as long as alignment restrictions are met and the implementation of atomic doesnt come with additional members
 
 template<typename T>
 std::atomic<T>* _rawPtrToAtomic(T* ptr)
 {
+	static_assert(sizeof(T) == sizeof(std::atomic<T>));
+	cemu_assert_debug((reinterpret_cast<std::uintptr_t>(ptr) % alignof(std::atomic<T>)) == 0);
     return reinterpret_cast<std::atomic<T>*>(ptr);
 }
 
@@ -497,3 +558,93 @@ inline uint32 GetTitleIdLow(uint64 titleId)
 #include "Cafe/HW/MMU/MMU.h"
 #include "Cafe/HW/Espresso/PPCState.h"
 #include "Cafe/HW/Espresso/PPCCallback.h"
+
+// PPC stack trace printer
+void DebugLogStackTrace(struct OSThread_t* thread, MPTR sp, bool printSymbols = false);
+
+// generic formatter for enums (to underlying)
+template <typename Enum>
+	requires std::is_enum_v<Enum>
+struct fmt::formatter<Enum> : fmt::formatter<underlying_t<Enum>>
+{
+	auto format(const Enum& e, format_context& ctx) const
+	{
+		//return fmt::format_to(ctx.out(), "{}", fmt::underlying(e));
+
+		return formatter<underlying_t<Enum>>::format(fmt::underlying(e), ctx);
+	}
+};
+
+// formatter for betype<T>
+template <typename T>
+struct fmt::formatter<betype<T>> : fmt::formatter<T>
+{
+	auto format(const betype<T>& e, format_context& ctx) const
+	{
+		return formatter<T>::format(static_cast<T>(e), ctx);
+	}
+};
+
+// useful future C++ stuff
+namespace stdx
+{
+	// std::to_underlying
+    template <typename EnumT, typename = std::enable_if_t < std::is_enum<EnumT>{} >>
+        constexpr std::underlying_type_t<EnumT> to_underlying(EnumT e) noexcept {
+        return static_cast<std::underlying_type_t<EnumT>>(e);
+    };
+
+	// std::scope_exit
+	template <typename Fn>
+	class scope_exit
+	{
+		Fn m_func;
+		bool m_released = false;
+	public:
+		explicit scope_exit(Fn&& f) noexcept
+			: m_func(std::forward<Fn>(f))
+		{}
+		~scope_exit()
+		{
+			if (!m_released) m_func();
+		}
+		scope_exit(scope_exit&& other) noexcept
+			: m_func(std::move(other.m_func)), m_released(std::exchange(other.m_released, true))
+		{}
+		scope_exit(const scope_exit&) = delete;
+		scope_exit& operator=(scope_exit) = delete;
+		void release() { m_released = true;}
+	};
+
+	// Xcode 16 doesn't have std::atomic_ref support and we provide a minimalist reimplementation as fallback
+#ifdef __cpp_lib_atomic_ref
+	#include <atomic>
+	template<typename T>
+	using atomic_ref = std::atomic_ref<T>;
+#else
+	template<typename T>
+	class atomic_ref
+	{
+		static_assert(std::is_trivially_copyable<T>::value, "atomic_ref requires trivially copyable types");
+	public:
+		using value_type = T;
+
+		explicit atomic_ref(T& obj) noexcept : ptr_(std::addressof(obj)) {}
+
+		T load(std::memory_order order = std::memory_order_seq_cst) const noexcept
+		{
+			auto aptr = reinterpret_cast<std::atomic<T>*>(ptr_);
+			return aptr->load(order);
+		}
+
+		void store(T desired, std::memory_order order = std::memory_order_seq_cst) const noexcept
+		{
+			auto aptr = reinterpret_cast<std::atomic<T>*>(ptr_);
+			aptr->store(desired, order);
+		}
+
+	private:
+		T* ptr_;
+	};
+#endif
+}
diff --git a/src/Common/unix/FileStream_unix.cpp b/src/Common/unix/FileStream_unix.cpp
index c65a3219..4bc9b526 100644
--- a/src/Common/unix/FileStream_unix.cpp
+++ b/src/Common/unix/FileStream_unix.cpp
@@ -1,4 +1,5 @@
 #include "Common/unix/FileStream_unix.h"
+#include <cstdarg>
 
 fs::path findPathCI(const fs::path& path)
 {
@@ -33,7 +34,6 @@ FileStream* FileStream::openFile(const wchar_t* path, bool allowWrite)
 
 FileStream* FileStream::openFile2(const fs::path& path, bool allowWrite)
 {
-	//return openFile(path.generic_wstring().c_str(), allowWrite);
 	FileStream* fs = new FileStream(path, true, allowWrite);
 	if (fs->m_isValid)
 		return fs;
diff --git a/src/Common/unix/platform.cpp b/src/Common/unix/platform.cpp
index d97f4e65..144d4f02 100644
--- a/src/Common/unix/platform.cpp
+++ b/src/Common/unix/platform.cpp
@@ -1,9 +1,14 @@
-#include <stdint.h>
-#include <time.h>
+#include <cstdint>
+#include <ctime>
 
 uint32_t GetTickCount()
 {
-        struct timespec ts;
-	clock_gettime(CLOCK_MONOTONIC, &ts);
-        return (1000 * ts.tv_sec + ts.tv_nsec / 1000000);
+#if BOOST_OS_LINUX
+	struct timespec ts;
+	clock_gettime(CLOCK_MONOTONIC_RAW, &ts);
+	return (1000 * ts.tv_sec + ts.tv_nsec / 1000000);
+#elif BOOST_OS_MACOS
+	return clock_gettime_nsec_np(CLOCK_MONOTONIC_RAW) / 1000000;
+#endif
+
 }
\ No newline at end of file
diff --git a/src/Common/version.h b/src/Common/version.h
index 0eff0197..36925a52 100644
--- a/src/Common/version.h
+++ b/src/Common/version.h
@@ -1,33 +1,19 @@
 #ifndef EMULATOR_NAME
 
 #define EMULATOR_NAME					"Cemu"
-#define EMULATOR_VERSION_LEAD			2
-#define EMULATOR_VERSION_MAJOR			0
 
-// the minor version is used for experimental builds to indicate the build index. Set by command line option from CI build script
-// if zero, the version text will be constructed as LEAD.MAJOR, otherwise as LEAD.MAJOR-MINOR
-
-#if !defined(PUBLIC_RELEASE)
-#define EMULATOR_VERSION_SUFFIX			" (dev)"
-#elif defined(EMULATOR_VERSION_MINOR) && EMULATOR_VERSION_MINOR == 0
-#define EMULATOR_VERSION_SUFFIX			"" // stable
-#else
-#define EMULATOR_VERSION_SUFFIX			" (experimental)"
-#endif
-
-#ifndef EMULATOR_VERSION_MINOR
-#define EMULATOR_VERSION_MINOR			0	
-#endif
+#define EMULATOR_VERSION_SUFFIX			""
 
 #define _XSTRINGFY(s) _STRINGFY(s)
 #define _STRINGFY(s) #s
 
-#if EMULATOR_VERSION_MINOR != 0
-#define BUILD_VERSION_WITH_NAME_STRING (EMULATOR_NAME " " _XSTRINGFY(EMULATOR_VERSION_LEAD) "." _XSTRINGFY(EMULATOR_VERSION_MAJOR) "-" _XSTRINGFY(EMULATOR_VERSION_MINOR) EMULATOR_VERSION_SUFFIX)
-#define BUILD_VERSION_STRING (_XSTRINGFY(EMULATOR_VERSION_LEAD) "." _XSTRINGFY(EMULATOR_VERSION_MAJOR) "-" _XSTRINGFY(EMULATOR_VERSION_MINOR) EMULATOR_VERSION_SUFFIX)
+#if EMULATOR_VERSION_MAJOR != 0
+#define BUILD_VERSION_WITH_NAME_STRING (EMULATOR_NAME " " _XSTRINGFY(EMULATOR_VERSION_MAJOR) "." _XSTRINGFY(EMULATOR_VERSION_MINOR) EMULATOR_VERSION_SUFFIX)
+#define BUILD_VERSION_STRING (_XSTRINGFY(EMULATOR_VERSION_MAJOR) "." _XSTRINGFY(EMULATOR_VERSION_MINOR) EMULATOR_VERSION_SUFFIX)
 #else
-#define BUILD_VERSION_STRING (_XSTRINGFY(EMULATOR_VERSION_LEAD) "." _XSTRINGFY(EMULATOR_VERSION_MAJOR) EMULATOR_VERSION_SUFFIX)
-#define BUILD_VERSION_WITH_NAME_STRING (EMULATOR_NAME " " _XSTRINGFY(EMULATOR_VERSION_LEAD) "." _XSTRINGFY(EMULATOR_VERSION_MAJOR) EMULATOR_VERSION_SUFFIX)
+// no version provided. Only show commit hash
+#define BUILD_VERSION_STRING (_XSTRINGFY(EMULATOR_HASH) EMULATOR_VERSION_SUFFIX)
+#define BUILD_VERSION_WITH_NAME_STRING (EMULATOR_NAME " " _XSTRINGFY(EMULATOR_HASH) EMULATOR_VERSION_SUFFIX)
 #endif
 
 #endif
diff --git a/src/Common/windows/FileStream_win32.h b/src/Common/windows/FileStream_win32.h
index c7ad802a..a0b1b30a 100644
--- a/src/Common/windows/FileStream_win32.h
+++ b/src/Common/windows/FileStream_win32.h
@@ -43,7 +43,7 @@ class FileStream
 	void writeLine(const char* str);
 
 	~FileStream();
-	FileStream() {};
+	FileStream() = default;
 
  private:
 	FileStream(HANDLE hFile);
diff --git a/src/Common/zstring_view.h b/src/Common/zstring_view.h
deleted file mode 100644
index 2afd605c..00000000
--- a/src/Common/zstring_view.h
+++ /dev/null
@@ -1,143 +0,0 @@
-#ifndef ASZ_ZSTRING_VIEW_HPP
-#define ASZ_ZSTRING_VIEW_HPP
-
-// https://github.com/Aszarsha/zstring_view/blob/master/zstring_view.hpp
-
-#include <string_view>
-
-// Copy interface from cppreference's std::basic_string_view page
-//  http://en.cppreference.com/w/cpp/string/basic_string_view
-// and add conversion from zstring_view to basic_string_view and CharT const*
-
-template< class CharT
-	, class Traits = std::char_traits< CharT >
->
-class basic_zstring_view
-	: private std::basic_string_view< CharT, Traits > {
-private:
-	using string_view_base = std::basic_string_view< CharT, Traits >;
-
-public:   /// Types ///
-	using typename string_view_base::traits_type;
-	using typename string_view_base::value_type;
-	using typename string_view_base::pointer;
-	using typename string_view_base::const_pointer;
-	using typename string_view_base::reference;
-	using typename string_view_base::const_reference;
-	using typename string_view_base::iterator;
-	using typename string_view_base::const_iterator;
-	using typename string_view_base::reverse_iterator;
-	using typename string_view_base::const_reverse_iterator;
-	using typename string_view_base::size_type;
-	using typename string_view_base::difference_type;
-
-public:   /// Static members ///
-	using string_view_base::npos;
-
-public:   /// Special member functions ///
-	constexpr basic_zstring_view() noexcept = default;
-
-	constexpr basic_zstring_view(basic_zstring_view const&) noexcept = default;
-	constexpr basic_zstring_view& operator=(basic_zstring_view const&) noexcept = default;
-
-	constexpr basic_zstring_view(basic_zstring_view&&) noexcept = default;
-	constexpr basic_zstring_view& operator=(basic_zstring_view&&) noexcept = default;
-
-	basic_zstring_view(CharT const* s) : string_view_base{ s } {   }
-	basic_zstring_view(CharT const* s, size_type sz) : string_view_base{ s, sz } {   }
-
-	// Explicitly no convertion from string_view, since null-termination is not guaranteed
-	basic_zstring_view(std::basic_string<CharT, std::char_traits<CharT>, std::allocator<CharT>> const& s) : string_view_base{ s } {   }
-
-public:   /// Member functions ///
-	//== Iterators ==//
-	using string_view_base::begin;
-	using string_view_base::cbegin;
-
-	using string_view_base::end;
-	using string_view_base::cend;
-
-	using string_view_base::rbegin;
-	using string_view_base::crbegin;
-
-	using string_view_base::rend;
-	using string_view_base::crend;
-
-	//== Element access ==//
-	using string_view_base::operator[];
-
-	using string_view_base::at;
-
-	using string_view_base::front;
-
-	using string_view_base::back;
-
-	using string_view_base::data;
-
-	//== Capacity ==//
-	using string_view_base::size;
-	using string_view_base::length;
-
-	using string_view_base::max_size;
-
-	using string_view_base::empty;
-
-	//== Modifiers ==//
-	using string_view_base::remove_prefix;
-
-	//Explicitly NOT
-	//using string_view_base::remove_suffix;
-
-	using string_view_base::swap;
-
-	//== Operations ==//
-	using string_view_base::copy;
-
-	//Explicitly NOT
-	//using::string_view_base::substr;
-
-	using string_view_base::compare;
-
-	// C++20
-	//using string_view_base::starts_with;
-
-	// C++20
-	//using string_view_base::ends_with;
-
-	using string_view_base::find;
-
-	using string_view_base::rfind;
-
-	using string_view_base::find_first_of;
-
-	using string_view_base::find_last_of;
-
-	using string_view_base::find_first_not_of;
-
-	using string_view_base::find_last_not_of;
-
-public:   /// Convertions ///
-	constexpr operator const_pointer() const noexcept {
-		return data();
-	}
-
-	// Ideally operator string_view_base()
-	// but by language definition (C++17) will never be used:
-	// From [class.conv.fct]: A conversion function is never used to convert a (possibly cv-qualified) object to the (possibly cv-qualified) same object type (or a reference to it), to a (possibly cv-qualified) base class of that type (or a reference to it), or to (possibly cv-qualified) void.
-	constexpr string_view_base to_string_view() const noexcept {
-		return { data(), size() };
-	}
-
-public:   /// Misc ///
-	friend inline std::ostream& operator<<(std::ostream& o, basic_zstring_view v) {
-		o << v.data();
-		return o;
-	}
-};
-
-using zstring_view = basic_zstring_view< char >;
-using wzstring_view = basic_zstring_view< wchar_t >;
-using u16zstring_view = basic_zstring_view< char16_t >;
-using u32zstring_view = basic_zstring_view< char32_t >;
-
-#endif
\ No newline at end of file
diff --git a/src/asm/CMakeLists.txt b/src/asm/CMakeLists.txt
deleted file mode 100644
index ff7f2ab4..00000000
--- a/src/asm/CMakeLists.txt
+++ /dev/null
@@ -1,39 +0,0 @@
-project(CemuAsm C)
-
-if (WIN32)
-
-	enable_language(C ASM_MASM)
-
-	add_library(CemuAsm x64util_masm.asm)
-	set_source_files_properties(x64util_masm.asm PROPERTIES LANGUAGE ASM_MASM)
-
-	# workaround for cr flag being passed to LINK.exe which considers it an input file and thus fails
-	# doesn't always seem to happen. The Windows CI builds were fine, but locally I would run into this problem
-	# possibly related to https://gitlab.kitware.com/cmake/cmake/-/issues/18889
-	set(CMAKE_ASM_MASM_CREATE_STATIC_LIBRARY "<CMAKE_AR> /OUT:<TARGET> <LINK_FLAGS> <OBJECTS>")
-
-else()
-
-	# NASM
-	if (APPLE)
-		set(CMAKE_ASM_NASM_COMPILE_OBJECT "<CMAKE_ASM_NASM_COMPILER> -g -Fdwarf -f macho64 --prefix _ -o <OBJECT> <SOURCE>")
-	else()
-		set(CMAKE_ASM_NASM_COMPILE_OBJECT "<CMAKE_ASM_NASM_COMPILER> -g -Fdwarf -f elf64 -o <OBJECT> <SOURCE>")
-	endif()
-	set(CMAKE_ASM_NASM_LINK_EXECUTABLE "ld <FLAGS> <CMAKE_ASM_NASM_LINK_FLAGS> <LINK_FLAGS> -fPIC <OBJECTS>  -o <TARGET> <LINK_LIBRARIES>")
-
-	enable_language(C ASM_NASM)
-
-	add_library(CemuAsm x64util_nasm.asm)
-	set_source_files_properties(x64util_nasm.asm PROPERTIES LANGUAGE ASM_NASM)
-
-	if (APPLE)
-		set_target_properties(CemuAsm PROPERTIES NASM_OBJ_FORMAT macho64)
-	else()
-		set_target_properties(CemuAsm PROPERTIES NASM_OBJ_FORMAT elf64)
-	endif()
-	set_target_properties(CemuAsm PROPERTIES LINKER_LANGUAGE C)
-
-endif()
-
-set_property(TARGET CemuAsm PROPERTY MSVC_RUNTIME_LIBRARY "MultiThreaded$<$<CONFIG:Debug>:Debug>")
diff --git a/src/asm/x64util.h b/src/asm/x64util.h
deleted file mode 100644
index 32669b97..00000000
--- a/src/asm/x64util.h
+++ /dev/null
@@ -1,4 +0,0 @@
-#pragma once
-
-extern "C" void recompiler_fres();
-extern "C" void recompiler_frsqrte();
diff --git a/src/asm/x64util_masm.asm b/src/asm/x64util_masm.asm
deleted file mode 100644
index 2587c786..00000000
--- a/src/asm/x64util_masm.asm
+++ /dev/null
@@ -1,233 +0,0 @@
-.code
-
-recompiler_fres	PROC
- ; store all modified registers
-push rdx
-push rcx
-push rax
-push r8
-lea         r8,[asmFresLookupTable]  
-movq	    rdx, xmm15
-mov         rcx,rdx  
-shr         rcx,2Fh  
-mov         rax,rdx  
-and         ecx,1Fh  
-shr         rax,25h  
-and         eax,3FFh  
-imul        eax,dword ptr [r8+rcx*8+4]  
-mov         r8d,dword ptr [r8+rcx*8]  
-mov         rcx,rdx  
-shr         rcx,34h  
-inc         eax  
-shr         eax,1  
-sub         r8d,eax  
-and         ecx,7FFh  
-jne         fres_espresso_label3
-mov         rax,7FF0000000000000h  
-or          rdx,rax  
-movq		xmm15, rdx
-pop r8
-pop rax
-pop rcx
-pop rdx
-ret  
-fres_espresso_label3:
-cmp         ecx,7FFh  
-jne         fres_espresso_label4
-mov         rax,0FFFFFFFFFFFFFh  
-test        rax,rdx  
-jne         fres_espresso_label1
-test        rdx,rdx  
-jns         fres_espresso_label2
-mov         rax,8000000000000000h  
-movq		xmm15, rax
-pop r8
-pop rax
-pop rcx
-pop rdx
-ret  
-fres_espresso_label2:
-xorps       xmm15,xmm15  
-pop r8
-pop rax
-pop rcx
-pop rdx
-ret  
-fres_espresso_label4:
-mov         eax,7FDh  
-sub         eax,ecx  
-mov         ecx,eax  
-mov         rax,8000000000000000h  
-and         rdx,rax  
-shl         rcx,34h  
-mov         eax,r8d  
-or          rcx,rdx  
-shl         rax,1Dh  
-add         rcx,rax  
-movq		xmm15, rcx
-fres_espresso_label1:
-pop r8
-pop rax
-pop rcx
-pop rdx
-ret  
-
-recompiler_fres ENDP
-
-asmFresLookupTable:
-DD 07ff800h, 03e1h
-DD 0783800h, 03a7h
-DD 070ea00h, 0371h
-DD 06a0800h, 0340h
-DD 0638800h, 0313h
-DD 05d6200h, 02eah
-DD 0579000h, 02c4h
-DD 0520800h, 02a0h
-DD 04cc800h, 027fh
-DD 047ca00h, 0261h
-DD 0430800h, 0245h
-DD 03e8000h, 022ah
-DD 03a2c00h, 0212h
-DD 0360800h, 01fbh
-DD 0321400h, 01e5h
-DD 02e4a00h, 01d1h
-DD 02aa800h, 01beh
-DD 0272c00h, 01ach
-DD 023d600h, 019bh
-DD 0209e00h, 018bh
-DD 01d8800h, 017ch
-DD 01a9000h, 016eh
-DD 017ae00h, 015bh
-DD 014f800h, 015bh
-DD 0124400h, 0143h
-DD 0fbe00h, 0143h
-DD 0d3800h, 012dh
-DD 0ade00h, 012dh
-DD 088400h, 011ah
-DD 065000h, 011ah
-DD 041c00h, 0108h
-DD 020c00h, 0106h
-
-recompiler_frsqrte PROC
- ; store all modified registers
-push rdx
-push rcx
-push rax
-push r8
-push r9
-movq	    r8, xmm15
-mov         rax,7FFFFFFFFFFFFFFFh  
-test        rax,r8  
-jne         frsqrte_espresso_label1
-mov         rax,0FFF0000000000000h  
-and         r8,rax  
-mov         rax,7FF0000000000000h  
-or          r8,rax  
-movq		xmm15, r8
-pop r9
-pop r8
-pop rax
-pop rcx
-pop rdx
-ret  
-frsqrte_espresso_label1:
-mov         r9,r8  
-shr         r9,34h  
-and         r9d,7FFh  
-cmp         r9d,7FFh  
-jne         frsqrte_espresso_label2
-mov         rax,0FFFFFFFFFFFFFh  
-test        rax,r8  
-jne         frsqrte_espresso_label3
-test        r8,r8  
-js          frsqrte_espresso_label4
-xorps       xmm15,xmm15 
-pop r9
-pop r8
-pop rax
-pop rcx
-pop rdx
-ret  
-frsqrte_espresso_label2:
-test        r8,r8  
-jns         frsqrte_espresso_label5
-frsqrte_espresso_label4:
-mov         rax,7FF8000000000000h  
-movq		xmm15, rax
-pop r9
-pop r8
-pop rax
-pop rcx
-pop rdx
-ret  
-frsqrte_espresso_label5:
-lea         rdx,[asmFrsqrteLookupTable]  
-mov         rax,r8  
-shr         rax,30h  
-mov         rcx,r8  
-shr         rcx,25h  
-and         eax,1Fh  
-and         ecx,7FFh  
-imul        ecx,dword ptr [rdx+rax*8+4]  
-mov         eax,dword ptr [rdx+rax*8]  
-sub         eax,ecx  
-lea         ecx,[r9-3FDh]  
-shr         ecx,1  
-movsxd      rdx,eax  
-mov         eax,3FFh  
-sub         eax,ecx  
-shl         rdx,1Ah  
-mov         ecx,eax  
-mov         rax,8000000000000000h  
-and         r8,rax  
-shl         rcx,34h  
-or          rcx,r8  
-add         rdx,rcx  
-movq		xmm15, rdx
-frsqrte_espresso_label3:
-pop r9
-pop r8
-pop rax
-pop rcx
-pop rdx
-ret  
-
-recompiler_frsqrte ENDP
-
-asmFrsqrteLookupTable:
-DD 01a7e800h, 0568h
-DD 017cb800h, 04f3h
-DD 01552800h, 048dh
-DD 0130c000h, 0435h
-DD 010f2000h, 03e7h
-DD 0eff000h, 03a2h
-DD 0d2e000h, 0365h
-DD 0b7c000h, 032eh
-DD 09e5000h, 02fch
-DD 0867000h, 02d0h
-DD 06ff000h, 02a8h
-DD 05ab800h, 0283h
-DD 046a000h, 0261h
-DD 0339800h, 0243h
-DD 0218800h, 0226h
-DD 0105800h, 020bh
-DD 03ffa000h, 07a4h
-DD 03c29000h, 0700h
-DD 038aa000h, 0670h
-DD 03572000h, 05f2h
-DD 03279000h, 0584h
-DD 02fb7000h, 0524h
-DD 02d26000h, 04cch
-DD 02ac0000h, 047eh
-DD 02881000h, 043ah
-DD 02665000h, 03fah
-DD 02468000h, 03c2h
-DD 02287000h, 038eh
-DD 020c1000h, 035eh
-DD 01f12000h, 0332h
-DD 01d79000h, 030ah
-DD 01bf4000h, 02e6h
-
-
-
-END
\ No newline at end of file
diff --git a/src/asm/x64util_nasm.asm b/src/asm/x64util_nasm.asm
deleted file mode 100644
index 89878f6e..00000000
--- a/src/asm/x64util_nasm.asm
+++ /dev/null
@@ -1,237 +0,0 @@
-DEFAULT REL
-
-SECTION .text
-
-global udiv128
-global recompiler_fres
-global recompiler_frsqrte
-
-udiv128:
-	mov rax, rcx
-	div r8
-	mov [r9], rdx
-	ret
-
-recompiler_fres:
- ; store all modified registers
-push rdx
-push rcx
-push rax
-push r8
-lea         r8,[asmFresLookupTable]  
-movq	    rdx, xmm15
-mov         rcx,rdx  
-shr         rcx,2Fh  
-mov         rax,rdx  
-and         ecx,1Fh  
-shr         rax,25h  
-and         eax,3FFh  
-imul        eax,dword [r8+rcx*8+4]
-mov         r8d,dword [r8+rcx*8]
-mov         rcx,rdx  
-shr         rcx,34h  
-inc         eax  
-shr         eax,1  
-sub         r8d,eax  
-and         ecx,7FFh  
-jne         fres_espresso_label3
-mov         rax,7FF0000000000000h  
-or          rdx,rax  
-movq		xmm15, rdx
-pop r8
-pop rax
-pop rcx
-pop rdx
-ret  
-fres_espresso_label3:
-cmp         ecx,7FFh  
-jne         fres_espresso_label4
-mov         rax,0FFFFFFFFFFFFFh  
-test        rax,rdx  
-jne         fres_espresso_label1
-test        rdx,rdx  
-jns         fres_espresso_label2
-mov         rax,8000000000000000h  
-movq		xmm15, rax
-pop r8
-pop rax
-pop rcx
-pop rdx
-ret  
-fres_espresso_label2:
-xorps       xmm15,xmm15  
-pop r8
-pop rax
-pop rcx
-pop rdx
-ret  
-fres_espresso_label4:
-mov         eax,7FDh  
-sub         eax,ecx  
-mov         ecx,eax  
-mov         rax,8000000000000000h  
-and         rdx,rax  
-shl         rcx,34h  
-mov         eax,r8d  
-or          rcx,rdx  
-shl         rax,1Dh  
-add         rcx,rax  
-movq		xmm15, rcx
-fres_espresso_label1:
-pop r8
-pop rax
-pop rcx
-pop rdx
-ret  
-
-asmFresLookupTable:
-DD 07ff800h, 03e1h
-DD 0783800h, 03a7h
-DD 070ea00h, 0371h
-DD 06a0800h, 0340h
-DD 0638800h, 0313h
-DD 05d6200h, 02eah
-DD 0579000h, 02c4h
-DD 0520800h, 02a0h
-DD 04cc800h, 027fh
-DD 047ca00h, 0261h
-DD 0430800h, 0245h
-DD 03e8000h, 022ah
-DD 03a2c00h, 0212h
-DD 0360800h, 01fbh
-DD 0321400h, 01e5h
-DD 02e4a00h, 01d1h
-DD 02aa800h, 01beh
-DD 0272c00h, 01ach
-DD 023d600h, 019bh
-DD 0209e00h, 018bh
-DD 01d8800h, 017ch
-DD 01a9000h, 016eh
-DD 017ae00h, 015bh
-DD 014f800h, 015bh
-DD 0124400h, 0143h
-DD 0fbe00h, 0143h
-DD 0d3800h, 012dh
-DD 0ade00h, 012dh
-DD 088400h, 011ah
-DD 065000h, 011ah
-DD 041c00h, 0108h
-DD 020c00h, 0106h
-
-recompiler_frsqrte:
- ; store all modified registers
-push rdx
-push rcx
-push rax
-push r8
-push r9
-movq	    r8, xmm15
-mov         rax,7FFFFFFFFFFFFFFFh  
-test        rax,r8  
-jne         frsqrte_espresso_label1
-mov         rax,0FFF0000000000000h  
-and         r8,rax  
-mov         rax,7FF0000000000000h  
-or          r8,rax  
-movq		xmm15, r8
-pop r9
-pop r8
-pop rax
-pop rcx
-pop rdx
-ret  
-frsqrte_espresso_label1:
-mov         r9,r8  
-shr         r9,34h  
-and         r9d,7FFh  
-cmp         r9d,7FFh  
-jne         frsqrte_espresso_label2
-mov         rax,0FFFFFFFFFFFFFh  
-test        rax,r8  
-jne         frsqrte_espresso_label3
-test        r8,r8  
-js          frsqrte_espresso_label4
-xorps       xmm15,xmm15 
-pop r9
-pop r8
-pop rax
-pop rcx
-pop rdx
-ret  
-frsqrte_espresso_label2:
-test        r8,r8  
-jns         frsqrte_espresso_label5
-frsqrte_espresso_label4:
-mov         rax,7FF8000000000000h  
-movq		xmm15, rax
-pop r9
-pop r8
-pop rax
-pop rcx
-pop rdx
-ret  
-frsqrte_espresso_label5:
-lea         rdx,[asmFrsqrteLookupTable]  
-mov         rax,r8  
-shr         rax,30h  
-mov         rcx,r8  
-shr         rcx,25h  
-and         eax,1Fh  
-and         ecx,7FFh  
-imul        ecx,dword [rdx+rax*8+4]
-mov         eax,dword [rdx+rax*8]
-sub         eax,ecx  
-lea         ecx,[r9-3FDh]  
-shr         ecx,1  
-movsxd      rdx,eax  
-mov         eax,3FFh  
-sub         eax,ecx  
-shl         rdx,1Ah  
-mov         ecx,eax  
-mov         rax,8000000000000000h  
-and         r8,rax  
-shl         rcx,34h  
-or          rcx,r8  
-add         rdx,rcx  
-movq		xmm15, rdx
-frsqrte_espresso_label3:
-pop r9
-pop r8
-pop rax
-pop rcx
-pop rdx
-ret  
-
-asmFrsqrteLookupTable:
-DD 01a7e800h, 0568h
-DD 017cb800h, 04f3h
-DD 01552800h, 048dh
-DD 0130c000h, 0435h
-DD 010f2000h, 03e7h
-DD 0eff000h, 03a2h
-DD 0d2e000h, 0365h
-DD 0b7c000h, 032eh
-DD 09e5000h, 02fch
-DD 0867000h, 02d0h
-DD 06ff000h, 02a8h
-DD 05ab800h, 0283h
-DD 046a000h, 0261h
-DD 0339800h, 0243h
-DD 0218800h, 0226h
-DD 0105800h, 020bh
-DD 03ffa000h, 07a4h
-DD 03c29000h, 0700h
-DD 038aa000h, 0670h
-DD 03572000h, 05f2h
-DD 03279000h, 0584h
-DD 02fb7000h, 0524h
-DD 02d26000h, 04cch
-DD 02ac0000h, 047eh
-DD 02881000h, 043ah
-DD 02665000h, 03fah
-DD 02468000h, 03c2h
-DD 02287000h, 038eh
-DD 020c1000h, 035eh
-DD 01f12000h, 0332h
-DD 01d79000h, 030ah
-DD 01bf4000h, 02e6h
diff --git a/src/audio/CMakeLists.txt b/src/audio/CMakeLists.txt
index d27273e6..a240477b 100644
--- a/src/audio/CMakeLists.txt
+++ b/src/audio/CMakeLists.txt
@@ -1,8 +1,8 @@
-project(CemuAudio)
-
 add_library(CemuAudio
 	IAudioAPI.cpp
 	IAudioAPI.h
+	IAudioInputAPI.cpp
+	IAudioInputAPI.h
 )
 
 set_property(TARGET CemuAudio PROPERTY MSVC_RUNTIME_LIBRARY "MultiThreaded$<$<CONFIG:Debug>:Debug>")
@@ -28,6 +28,8 @@ if(ENABLE_CUBEB)
 	target_sources(CemuAudio PRIVATE
 		CubebAPI.cpp
 		CubebAPI.h
+		CubebInputAPI.cpp
+		CubebInputAPI.h
 	)
 	#add_compile_definitions(HAS_CUBEB)
 endif()
diff --git a/src/audio/CubebAPI.cpp b/src/audio/CubebAPI.cpp
index c40e0f55..f6d5d516 100644
--- a/src/audio/CubebAPI.cpp
+++ b/src/audio/CubebAPI.cpp
@@ -9,7 +9,7 @@
 #endif
 
 
-void state_cb(cubeb_stream* stream, void* user, cubeb_state state)
+static void state_cb(cubeb_stream* stream, void* user, cubeb_state state)
 {
 	if (!stream)
 		return;
@@ -75,7 +75,7 @@ CubebAPI::CubebAPI(cubeb_devid devid, uint32 samplerate, uint32 channels, uint32
 		output_params.layout = CUBEB_LAYOUT_3F4_LFE;
 		break;
 	case 6:
-		output_params.layout = CUBEB_LAYOUT_QUAD_LFE | CHANNEL_FRONT_CENTER;
+		output_params.layout = CUBEB_LAYOUT_3F2_LFE_BACK;
 		break;
 	case 4:
 		output_params.layout = CUBEB_LAYOUT_QUAD;
@@ -114,7 +114,7 @@ CubebAPI::~CubebAPI()
 bool CubebAPI::NeedAdditionalBlocks() const
 {
 	std::shared_lock lock(m_mutex);
-	return m_buffer.size() < s_audioDelay * m_bytesPerBlock;
+	return m_buffer.size() < GetAudioDelay() * m_bytesPerBlock;
 }
 
 bool CubebAPI::FeedBlock(sint16* data)
@@ -122,7 +122,7 @@ bool CubebAPI::FeedBlock(sint16* data)
 	std::unique_lock lock(m_mutex);
 	if (m_buffer.capacity() <= m_buffer.size() + m_bytesPerBlock)
 	{
-		forceLogDebug_printf("dropped direct sound block since too many buffers are queued");
+		cemuLog_logDebug(LogType::Force, "dropped direct sound block since too many buffers are queued");
 		return false;
 	}
 
@@ -167,25 +167,11 @@ void CubebAPI::SetVolume(sint32 volume)
 
 bool CubebAPI::InitializeStatic()
 {
-#if BOOST_OS_WINDOWS
-	s_com_initialized = (SUCCEEDED(CoInitializeEx(nullptr, COINIT_MULTITHREADED)));
-#endif
-
 	if (cubeb_init(&s_context, "Cemu Cubeb", nullptr))
 	{
-		cemuLog_force("can't create cubeb audio api");
-
-#if BOOST_OS_WINDOWS
-		if (s_com_initialized)
-		{
-			CoUninitialize();
-			s_com_initialized = false;
-		}
-#endif
-
+		cemuLog_log(LogType::Force, "can't create cubeb audio api");
 		return false;
 	}
-
 	return true;
 }
 
@@ -193,28 +179,29 @@ void CubebAPI::Destroy()
 {
 	if (s_context)
 		cubeb_destroy(s_context);
-#if BOOST_OS_WINDOWS
-	if (s_com_initialized)
-		CoUninitialize();
-#endif
 }
 
 std::vector<IAudioAPI::DeviceDescriptionPtr> CubebAPI::GetDevices()
 {
+	std::vector<DeviceDescriptionPtr> result;
+	// Add the default device to the list
+	auto defaultDevice = std::make_shared<CubebDeviceDescription>(nullptr, "default", L"Default Device");
+	result.emplace_back(defaultDevice);
+
 	cubeb_device_collection devices;
 	if (cubeb_enumerate_devices(s_context, CUBEB_DEVICE_TYPE_OUTPUT, &devices) != CUBEB_OK)
-		return {};
+		return result;
+
+	result.reserve(devices.count + 1); // The default device already occupies one element
 
-	std::vector<DeviceDescriptionPtr> result;
-	result.reserve(devices.count);
 	for (size_t i = 0; i < devices.count; ++i)
 	{
-		//const auto& device = devices.device[i];
+		// const auto& device = devices.device[i];
 		if (devices.device[i].state == CUBEB_DEVICE_STATE_ENABLED)
 		{
 			auto device = std::make_shared<CubebDeviceDescription>(devices.device[i].devid, devices.device[i].device_id,
-			                                                       boost::nowide::widen(
-				                                                       devices.device[i].friendly_name));
+																   boost::nowide::widen(
+																	   devices.device[i].friendly_name));
 			result.emplace_back(device);
 		}
 	}
diff --git a/src/audio/CubebAPI.h b/src/audio/CubebAPI.h
index a828ce0d..2dce9374 100644
--- a/src/audio/CubebAPI.h
+++ b/src/audio/CubebAPI.h
@@ -41,7 +41,6 @@ public:
 	static void Destroy();
 
 private:
-	inline static bool s_com_initialized = false;
 	inline static cubeb* s_context = nullptr;
 
 	cubeb_stream* m_stream = nullptr;
diff --git a/src/audio/CubebInputAPI.cpp b/src/audio/CubebInputAPI.cpp
new file mode 100644
index 00000000..a9faa9c8
--- /dev/null
+++ b/src/audio/CubebInputAPI.cpp
@@ -0,0 +1,204 @@
+#include "CubebInputAPI.h"
+
+#if BOOST_OS_WINDOWS
+#include <combaseapi.h>
+#include <mmreg.h>
+#include <mmsystem.h>
+#pragma comment(lib, "Avrt.lib")
+#pragma comment(lib, "ksuser.lib")
+#endif
+
+static void state_cb(cubeb_stream* stream, void* user, cubeb_state state)
+{
+	if (!stream)
+		return;
+
+	/*switch (state)
+	{
+	case CUBEB_STATE_STARTED:
+		fprintf(stderr, "stream started\n");
+		break;
+	case CUBEB_STATE_STOPPED:
+		fprintf(stderr, "stream stopped\n");
+		break;
+	case CUBEB_STATE_DRAINED:
+		fprintf(stderr, "stream drained\n");
+		break;
+	default:
+		fprintf(stderr, "unknown stream state %d\n", state);
+	}*/
+}
+
+long CubebInputAPI::data_cb(cubeb_stream* stream, void* user, const void* inputbuffer, void* outputbuffer, long nframes)
+{
+	auto* thisptr = (CubebInputAPI*)user;
+
+	const auto size = (size_t)nframes * thisptr->m_channels * (thisptr->m_bitsPerSample / 8);
+
+	std::unique_lock lock(thisptr->m_mutex);
+	if (thisptr->m_buffer.capacity() <= thisptr->m_buffer.size() + size)
+	{
+		cemuLog_logDebug(LogType::Force, "dropped input sound block since too many buffers are queued");
+		return nframes;
+	}
+
+	thisptr->m_buffer.insert(thisptr->m_buffer.end(), (uint8*)inputbuffer, (uint8*)inputbuffer + size);
+
+	return nframes;
+}
+
+CubebInputAPI::CubebInputAPI(cubeb_devid devid, uint32 samplerate, uint32 channels, uint32 samples_per_block,
+                   uint32 bits_per_sample)
+	: IAudioInputAPI(samplerate, channels, samples_per_block, bits_per_sample)
+{
+	cubeb_stream_params input_params;
+
+	input_params.format = CUBEB_SAMPLE_S16LE;
+	input_params.rate = samplerate;
+	input_params.channels = channels;
+	input_params.prefs = CUBEB_STREAM_PREF_NONE;
+
+	switch (channels)
+	{
+	case 8:
+		input_params.layout = CUBEB_LAYOUT_3F4_LFE;
+		break;
+	case 6:
+		input_params.layout = CUBEB_LAYOUT_QUAD_LFE | CHANNEL_FRONT_CENTER;
+		break;
+	case 4:
+		input_params.layout = CUBEB_LAYOUT_QUAD;
+		break;
+	case 2:
+		input_params.layout = CUBEB_LAYOUT_STEREO;
+		break;
+	default:
+		input_params.layout = CUBEB_LAYOUT_MONO;
+		break;
+	}
+
+	uint32 latency = 1;
+	cubeb_get_min_latency(s_context, &input_params, &latency);
+
+	m_buffer.reserve((size_t)m_bytesPerBlock * kBlockCount);
+
+	if (cubeb_stream_init(s_context, &m_stream, "Cemu Cubeb input",
+	                      devid, &input_params,
+                          nullptr, nullptr,
+	                      latency, data_cb, state_cb, this) != CUBEB_OK)
+	{
+		throw std::runtime_error("can't initialize cubeb device");
+	}
+}
+
+CubebInputAPI::~CubebInputAPI()
+{
+	if (m_stream)
+	{
+		Stop();
+		cubeb_stream_destroy(m_stream);
+	}
+}
+
+bool CubebInputAPI::ConsumeBlock(sint16* data)
+{
+	std::unique_lock lock(m_mutex);
+	if (m_buffer.empty())
+	{
+		// we got no data, just write silence
+		memset(data, 0x00, m_bytesPerBlock);
+	}
+	else
+	{
+		const auto copied = std::min(m_buffer.size(), (size_t)m_bytesPerBlock);
+		memcpy(data, m_buffer.data(), copied);
+		m_buffer.erase(m_buffer.begin(), std::next(m_buffer.begin(), copied));
+		lock.unlock();
+		// fill rest with silence
+		if (copied != m_bytesPerBlock)
+			memset((uint8*)data + copied, 0x00, m_bytesPerBlock - copied);
+	}
+
+	return true;
+}
+
+bool CubebInputAPI::Play()
+{
+	if (m_is_playing)
+		return true;
+
+	if (cubeb_stream_start(m_stream) == CUBEB_OK)
+	{
+		m_is_playing = true;
+		return true;
+	}
+
+	return false;
+}
+
+bool CubebInputAPI::Stop()
+{
+	if (!m_is_playing)
+		return true;
+
+	if (cubeb_stream_stop(m_stream) == CUBEB_OK)
+	{
+		m_is_playing = false;
+		return true;
+	}
+
+	return false;
+}
+
+void CubebInputAPI::SetVolume(sint32 volume)
+{
+	IAudioInputAPI::SetVolume(volume);
+	cubeb_stream_set_volume(m_stream, (float)volume / 100.0f);
+}
+
+bool CubebInputAPI::InitializeStatic()
+{
+	if (cubeb_init(&s_context, "Cemu Input Cubeb", nullptr))
+	{
+		cemuLog_log(LogType::Force, "can't create cubeb audio api");
+		return false;
+	}
+
+	return true;
+}
+
+void CubebInputAPI::Destroy()
+{
+	if (s_context)
+		cubeb_destroy(s_context);
+}
+
+std::vector<IAudioInputAPI::DeviceDescriptionPtr> CubebInputAPI::GetDevices()
+{
+	std::vector<DeviceDescriptionPtr> result;
+	// Add the default device to the list
+	auto defaultDevice = std::make_shared<CubebDeviceDescription>(nullptr, "default", L"Default Device");
+	result.emplace_back(defaultDevice);
+
+	cubeb_device_collection devices;
+	if (cubeb_enumerate_devices(s_context, CUBEB_DEVICE_TYPE_INPUT, &devices) != CUBEB_OK)
+		return result;
+
+	result.reserve(devices.count + 1); // The default device already occupies one element
+
+	for (size_t i = 0; i < devices.count; ++i)
+	{
+		// const auto& device = devices.device[i];
+		if (devices.device[i].state == CUBEB_DEVICE_STATE_ENABLED)
+		{
+			auto device = std::make_shared<CubebDeviceDescription>(devices.device[i].devid, devices.device[i].device_id,
+																   boost::nowide::widen(
+																	   devices.device[i].friendly_name));
+			result.emplace_back(device);
+		}
+	}
+
+	cubeb_device_collection_destroy(s_context, &devices);
+
+	return result;
+}
diff --git a/src/audio/CubebInputAPI.h b/src/audio/CubebInputAPI.h
new file mode 100644
index 00000000..82be3c6b
--- /dev/null
+++ b/src/audio/CubebInputAPI.h
@@ -0,0 +1,51 @@
+#pragma once
+
+#include "IAudioInputAPI.h"
+
+#include <cubeb/cubeb.h>
+
+class CubebInputAPI : public IAudioInputAPI
+{
+public:
+	class CubebDeviceDescription : public DeviceDescription
+	{
+	public:
+		CubebDeviceDescription(cubeb_devid devid, std::string device_id, const std::wstring& name)
+			: DeviceDescription(name), m_devid(devid), m_device_id(std::move(device_id)) { }
+
+		std::wstring GetIdentifier() const override { return  boost::nowide::widen(m_device_id); }
+		cubeb_devid GetDeviceId() const { return m_devid; }
+
+	private:
+		cubeb_devid m_devid;
+		std::string m_device_id;
+	};
+
+	using CubebDeviceDescriptionPtr = std::shared_ptr<CubebDeviceDescription>;
+
+	CubebInputAPI(cubeb_devid devid, uint32 samplerate, uint32 channels, uint32 samples_per_block, uint32 bits_per_sample);
+	~CubebInputAPI();
+
+	AudioInputAPI GetType() const override { return Cubeb; }
+
+	bool ConsumeBlock(sint16* data) override;
+	bool Play() override;
+	bool Stop() override;
+	bool IsPlaying() const override { return m_is_playing;  };
+	void SetVolume(sint32 volume) override;
+
+	static std::vector<DeviceDescriptionPtr> GetDevices();
+
+	static bool InitializeStatic();
+	static void Destroy();
+
+private:
+	inline static cubeb* s_context = nullptr;
+
+	cubeb_stream* m_stream = nullptr;
+	bool m_is_playing = false;
+
+	mutable std::shared_mutex m_mutex;
+	std::vector<uint8> m_buffer;
+	static long data_cb(cubeb_stream* stream, void* user, const void* inputbuffer, void* outputbuffer, long nframes);
+};
diff --git a/src/audio/DirectSoundAPI.cpp b/src/audio/DirectSoundAPI.cpp
index ff2dc6dc..64042515 100644
--- a/src/audio/DirectSoundAPI.cpp
+++ b/src/audio/DirectSoundAPI.cpp
@@ -1,9 +1,8 @@
 #include "DirectSoundAPI.h"
 
-#include "gui/wxgui.h"
-
 #include "util/helpers/helpers.h"
 #include "gui/guiWrapper.h"
+#include <wrl/client.h>
 
 #pragma comment(lib, "Dsound.lib")
 
@@ -15,12 +14,9 @@ std::wstring DirectSoundAPI::DirectSoundDeviceDescription::GetIdentifier() const
 DirectSoundAPI::DirectSoundAPI(GUID* guid, sint32 samplerate, sint32 channels, sint32 samples_per_block, sint32 bits_per_sample)
 	: IAudioAPI(samplerate, channels, samples_per_block, bits_per_sample)
 {
-	LPDIRECTSOUND8 direct_sound;
-	if (DirectSoundCreate8(guid, &direct_sound, nullptr) != DS_OK)
+	if (DirectSoundCreate8(guid, &m_direct_sound, nullptr) != DS_OK)
 		throw std::runtime_error("can't create directsound device");
 
-	m_direct_sound = decltype(m_direct_sound)(direct_sound);
-
 	if (FAILED(m_direct_sound->SetCooperativeLevel(gui_getWindowInfo().window_main.hwnd, DSSCL_PRIORITY)))
 		throw std::runtime_error("can't set directsound priority");
 
@@ -30,7 +26,7 @@ DirectSoundAPI::DirectSoundAPI(GUID* guid, sint32 samplerate, sint32 channels, s
 	bd.dwBufferBytes = kBufferCount * m_bytesPerBlock; // kBlockCount * (samples_per_block * channels * (bits_per_sample / 8));
 	bd.lpwfxFormat = (LPWAVEFORMATEX)&m_wfx;
 
-	LPDIRECTSOUNDBUFFER sound_buffer;
+	Microsoft::WRL::ComPtr<IDirectSoundBuffer> sound_buffer;
 	if (FAILED(m_direct_sound->CreateSoundBuffer(&bd, &sound_buffer, nullptr)))
 		throw std::runtime_error("can't create directsound soundbuffer");
 
@@ -41,27 +37,17 @@ DirectSoundAPI::DirectSoundAPI(GUID* guid, sint32 samplerate, sint32 channels, s
 
 	m_sound_buffer_size = caps.dwBufferBytes;
 
-	LPDIRECTSOUNDBUFFER8 sound_buffer8;
-	LPDIRECTSOUNDNOTIFY8 notify8;
-	sound_buffer->QueryInterface(IID_IDirectSoundBuffer8, (void**)&sound_buffer8);
+	Microsoft::WRL::ComPtr<IDirectSoundNotify8> notify8;
 
-	if (!sound_buffer8)
+	if (FAILED(sound_buffer->QueryInterface(IID_IDirectSoundBuffer8, &m_sound_buffer)))
 	{
-		sound_buffer->Release();
 		throw std::runtime_error("can't get directsound buffer interface");
 	}
 
-	m_sound_buffer = decltype(m_sound_buffer)(sound_buffer8);
-
-	sound_buffer->QueryInterface(IID_IDirectSoundNotify8, (void**)&notify8);
-	if (!notify8)
+	if (FAILED(sound_buffer->QueryInterface(IID_IDirectSoundNotify8, &m_notify)))
 	{
-		sound_buffer->Release();
 		throw std::runtime_error("can't get directsound notify interface");
 	}
-	m_notify = decltype(m_notify)(notify8);
-
-	sound_buffer->Release();
 
 	{ // initialize sound buffer
 		void *ptr1, *ptr2;
@@ -116,7 +102,7 @@ void DirectSoundAPI::AudioThread()
 
 			if (FAILED(hr))
 			{
-				forceLog_printf("DirectSound: Dropped audio block due to locking failure");
+				cemuLog_log(LogType::Force, "DirectSound: Dropped audio block due to locking failure");
 				continue;
 			}
 
@@ -124,7 +110,7 @@ void DirectSoundAPI::AudioThread()
 				std::unique_lock lock(m_mutex);
 				if (m_buffer.empty())
 				{
-					//forceLogDebug_printf("DirectSound: writing silence");
+					//cemuLog_logDebug(LogType::Force, "DirectSound: writing silence");
 
 					// we got no data, just write silence
 					memset(ptr1, 0x00, bytes1);
@@ -155,10 +141,6 @@ DirectSoundAPI::~DirectSoundAPI()
 	if(m_thread.joinable())
 		m_thread.join();
 
-	m_notify.reset();
-	m_sound_buffer.reset();
-	m_direct_sound.reset();
-
 	for(auto entry : m_notify_event)
 	{
 		if (entry)
@@ -186,10 +168,10 @@ bool DirectSoundAPI::Stop()
 
 bool DirectSoundAPI::FeedBlock(sint16* data)
 {
-	std::unique_lock lock(m_mutex);
+	std::lock_guard lock(m_mutex);
 	if (m_buffer.size() > kBlockCount)
 	{
-		forceLogDebug_printf("dropped direct sound block since too many buffers are queued");
+		cemuLog_logDebug(LogType::Force, "dropped direct sound block since too many buffers are queued");
 		return false;
 	}
 
@@ -210,7 +192,7 @@ void DirectSoundAPI::SetVolume(sint32 volume)
 bool DirectSoundAPI::NeedAdditionalBlocks() const
 {
 	std::shared_lock lock(m_mutex);
-	return m_buffer.size() < s_audioDelay;
+	return m_buffer.size() < GetAudioDelay();
 }
 
 std::vector<DirectSoundAPI::DeviceDescriptionPtr> DirectSoundAPI::GetDevices()
diff --git a/src/audio/DirectSoundAPI.h b/src/audio/DirectSoundAPI.h
index c5ad0d6f..52817fbe 100644
--- a/src/audio/DirectSoundAPI.h
+++ b/src/audio/DirectSoundAPI.h
@@ -2,8 +2,8 @@
 
 #define DIRECTSOUND_VERSION 0x0800
 #include <mmsystem.h>
-//#include <mmreg.h>
 #include <dsound.h>
+#include <wrl/client.h>
 
 #include "IAudioAPI.h"
 
@@ -41,15 +41,10 @@ public:
 	static std::vector<DeviceDescriptionPtr> GetInputDevices();
 
 private:
-	struct DirectSoundDeleter
-	{
-		void operator()(IUnknown* ptr) const { if (ptr) ptr->Release(); }
-	};
-
-	std::unique_ptr<IDirectSound8, DirectSoundDeleter> m_direct_sound;
-	//std::unique_ptr<IDirectSoundCapture8, DirectSoundDeleter> m_direct_sound_capture;
-	std::unique_ptr<IDirectSoundBuffer8, DirectSoundDeleter> m_sound_buffer;
-	std::unique_ptr<IDirectSoundNotify8, DirectSoundDeleter> m_notify;
+	Microsoft::WRL::ComPtr<IDirectSound8> m_direct_sound;
+	//Microsoft::WRL::ComPtr<IDirectSoundCapture8> m_direct_sound_capture;
+	Microsoft::WRL::ComPtr<IDirectSoundBuffer8> m_sound_buffer;
+	Microsoft::WRL::ComPtr<IDirectSoundNotify8> m_notify;
 
 	DWORD m_sound_buffer_size = 0;
 	uint32_t m_offset = 0;
diff --git a/src/audio/IAudioAPI.cpp b/src/audio/IAudioAPI.cpp
index 29f74153..dc266eed 100644
--- a/src/audio/IAudioAPI.cpp
+++ b/src/audio/IAudioAPI.cpp
@@ -6,18 +6,21 @@
 #include "DirectSoundAPI.h"
 #endif
 #include "config/CemuConfig.h"
+#if HAS_CUBEB
 #include "CubebAPI.h"
+#endif
 
 std::shared_mutex g_audioMutex;
 AudioAPIPtr g_tvAudio;
 AudioAPIPtr g_padAudio;
+AudioAPIPtr g_portalAudio;
 std::atomic_int32_t g_padVolume = 0;
 
 uint32 IAudioAPI::s_audioDelay = 2;
 std::array<bool, IAudioAPI::AudioAPIEnd> IAudioAPI::s_availableApis{};
 
 IAudioAPI::IAudioAPI(uint32 samplerate, uint32 channels, uint32 samples_per_block, uint32 bits_per_sample)
-	: m_samplerate(samplerate), m_channels(channels), m_samplesPerBlock(samples_per_block), m_bitsPerSample(bits_per_sample) 
+	: m_samplerate(samplerate), m_channels(channels), m_samplesPerBlock(samples_per_block), m_bitsPerSample(bits_per_sample)
 {
 	m_bytesPerBlock = samples_per_block * channels * (bits_per_sample / 8);
 	InitWFX(m_samplerate, m_channels, m_bitsPerSample);
@@ -25,14 +28,15 @@ IAudioAPI::IAudioAPI(uint32 samplerate, uint32 channels, uint32 samples_per_bloc
 
 void IAudioAPI::PrintLogging()
 {
-	forceLog_printf("------- Init Audio backend -------");
-	forceLog_printf("DirectSound: %s", s_availableApis[DirectSound] ? "available" : "not supported");
-	forceLog_printf("XAudio 2.8: %s", s_availableApis[XAudio2] ? "available" : "not supported");
+	cemuLog_log(LogType::Force, "------- Init Audio backend -------");
+	cemuLog_log(LogType::Force, "DirectSound: {}", s_availableApis[DirectSound] ? "available" : "not supported");
+	cemuLog_log(LogType::Force, "XAudio 2.8: {}", s_availableApis[XAudio2] ? "available" : "not supported");
 	if (!s_availableApis[XAudio2])
 	{
-		forceLog_printf("XAudio 2.7: %s", s_availableApis[XAudio27] ? "available" : "not supported")
+		cemuLog_log(LogType::Force, "XAudio 2.7: {}", s_availableApis[XAudio27] ? "available" : "not supported");
 	}
-    forceLog_printf("Cubeb: %s", s_availableApis[Cubeb] ? "available" : "not supported");
+
+	cemuLog_log(LogType::Force, "Cubeb: {}", s_availableApis[Cubeb] ? "available" : "not supported");
 }
 
 void IAudioAPI::InitWFX(sint32 samplerate, sint32 channels, sint32 bits_per_sample)
@@ -77,10 +81,12 @@ void IAudioAPI::InitializeStatic()
 #if BOOST_OS_WINDOWS
 	s_availableApis[DirectSound] = true;
 	s_availableApis[XAudio2] = XAudio2API::InitializeStatic();
-	if(!s_availableApis[XAudio2]) // don't try to initialize the older lib if the newer version is available
+	if (!s_availableApis[XAudio2]) // don't try to initialize the older lib if the newer version is available
 		s_availableApis[XAudio27] = XAudio27API::InitializeStatic();
 #endif
+#if HAS_CUBEB
 	s_availableApis[Cubeb] = CubebAPI::InitializeStatic();
+#endif
 }
 
 bool IAudioAPI::IsAudioAPIAvailable(AudioAPI api)
@@ -92,14 +98,47 @@ bool IAudioAPI::IsAudioAPIAvailable(AudioAPI api)
 	return false;
 }
 
+AudioAPIPtr IAudioAPI::CreateDeviceFromConfig(AudioType type, sint32 rate, sint32 samples_per_block, sint32 bits_per_sample)
+{
+	sint32 channels = CemuConfig::AudioChannelsToNChannels(AudioTypeToChannels(type));
+	return CreateDeviceFromConfig(type, rate, channels, samples_per_block, bits_per_sample);
+}
 
+AudioAPIPtr IAudioAPI::CreateDeviceFromConfig(AudioType type, sint32 rate, sint32 channels, sint32 samples_per_block, sint32 bits_per_sample)
+{
+	AudioAPIPtr audioAPIDev;
+
+	auto& config = GetConfig();
+
+	const auto audio_api = (IAudioAPI::AudioAPI)config.audio_api;
+	auto selectedDevice = GetDeviceFromType(type);
+
+	if (selectedDevice.empty())
+		return {};
+
+	IAudioAPI::DeviceDescriptionPtr device_description;
+	if (IAudioAPI::IsAudioAPIAvailable(audio_api))
+	{
+		auto devices = IAudioAPI::GetDevices(audio_api);
+		const auto it = std::find_if(devices.begin(), devices.end(), [&selectedDevice](const auto& d) { return d->GetIdentifier() == selectedDevice; });
+		if (it != devices.end())
+			device_description = *it;
+	}
+	if (!device_description)
+		throw std::runtime_error("failed to find selected device while trying to create audio device");
+
+	audioAPIDev = CreateDevice(audio_api, device_description, rate, channels, samples_per_block, bits_per_sample);
+	audioAPIDev->SetVolume(GetVolumeFromType(type));
+
+	return audioAPIDev;
+}
 
 AudioAPIPtr IAudioAPI::CreateDevice(AudioAPI api, const DeviceDescriptionPtr& device, sint32 samplerate, sint32 channels, sint32 samples_per_block, sint32 bits_per_sample)
 {
 	if (!IsAudioAPIAvailable(api))
 		return {};
 
-	switch(api)
+	switch (api)
 	{
 #if BOOST_OS_WINDOWS
 	case DirectSound:
@@ -118,11 +157,13 @@ AudioAPIPtr IAudioAPI::CreateDevice(AudioAPI api, const DeviceDescriptionPtr& de
 		return std::make_unique<XAudio2API>(tmp->GetDeviceId(), samplerate, channels, samples_per_block, bits_per_sample);
 	}
 #endif
-    case Cubeb:
-    {
-        const auto tmp = std::dynamic_pointer_cast<CubebAPI::CubebDeviceDescription>(device);
-        return std::make_unique<CubebAPI>(tmp->GetDeviceId(), samplerate, channels, samples_per_block, bits_per_sample);
-    }
+#if HAS_CUBEB
+	case Cubeb:
+	{
+		const auto tmp = std::dynamic_pointer_cast<CubebAPI::CubebDeviceDescription>(device);
+		return std::make_unique<CubebAPI>(tmp->GetDeviceId(), samplerate, channels, samples_per_block, bits_per_sample);
+	}
+#endif
 	default:
 		throw std::runtime_error(fmt::format("invalid audio api: {}", api));
 	}
@@ -132,8 +173,8 @@ std::vector<IAudioAPI::DeviceDescriptionPtr> IAudioAPI::GetDevices(AudioAPI api)
 {
 	if (!IsAudioAPIAvailable(api))
 		return {};
-	
-	switch(api)
+
+	switch (api)
 	{
 #if BOOST_OS_WINDOWS
 	case DirectSound:
@@ -149,12 +190,71 @@ std::vector<IAudioAPI::DeviceDescriptionPtr> IAudioAPI::GetDevices(AudioAPI api)
 		return XAudio2API::GetDevices();
 	}
 #endif
+#if HAS_CUBEB
 	case Cubeb:
 	{
 		return CubebAPI::GetDevices();
 	}
+#endif
 	default:
 		throw std::runtime_error(fmt::format("invalid audio api: {}", api));
 	}
 }
 
+void IAudioAPI::SetAudioDelayOverride(uint32 delay)
+{
+	m_audioDelayOverride = delay;
+}
+
+uint32 IAudioAPI::GetAudioDelay() const
+{
+	return m_audioDelayOverride > 0 ? m_audioDelayOverride : s_audioDelay;
+}
+
+AudioChannels IAudioAPI::AudioTypeToChannels(AudioType type)
+{
+	auto& config = GetConfig();
+	switch (type)
+	{
+	case TV:
+		return config.tv_channels;
+	case Gamepad:
+		return config.pad_channels;
+	case Portal:
+		return kMono;
+	default:
+		return kMono;
+	}
+}
+
+std::wstring IAudioAPI::GetDeviceFromType(AudioType type)
+{
+	auto& config = GetConfig();
+	switch (type)
+	{
+	case TV:
+		return config.tv_device;
+	case Gamepad:
+		return config.pad_device;
+	case Portal:
+		return config.portal_device;
+	default:
+		return L"";
+	}
+}
+
+sint32 IAudioAPI::GetVolumeFromType(AudioType type)
+{
+	auto& config = GetConfig();
+	switch (type)
+	{
+	case TV:
+		return config.tv_volume;
+	case Gamepad:
+		return config.pad_volume;
+	case Portal:
+		return config.portal_volume;
+	default:
+		return 0;
+	}
+}
diff --git a/src/audio/IAudioAPI.h b/src/audio/IAudioAPI.h
index 935e3024..34df421a 100644
--- a/src/audio/IAudioAPI.h
+++ b/src/audio/IAudioAPI.h
@@ -4,6 +4,8 @@
 #include <mmreg.h>
 #endif
 
+#include "config/CemuConfig.h"
+
 class IAudioAPI
 {
 	friend class GeneralSettings2;
@@ -30,6 +32,13 @@ public:
 
 	using DeviceDescriptionPtr = std::shared_ptr<DeviceDescription>;
 
+	enum AudioType
+	{
+		TV = 0,
+		Gamepad,
+		Portal
+	};
+
 	enum AudioAPI
 	{
 		DirectSound = 0,
@@ -55,11 +64,15 @@ public:
 	virtual bool FeedBlock(sint16* data) = 0;
 	virtual bool Play() = 0;
 	virtual bool Stop() = 0;
+	void SetAudioDelayOverride(uint32 delay);
+	uint32 GetAudioDelay() const;
 
 	static void PrintLogging();
 	static void InitializeStatic();
 	static bool IsAudioAPIAvailable(AudioAPI api);
-	
+
+	static std::unique_ptr<IAudioAPI> CreateDeviceFromConfig(AudioType type, sint32 rate, sint32 samples_per_block, sint32 bits_per_sample);
+	static std::unique_ptr<IAudioAPI> CreateDeviceFromConfig(AudioType type, sint32 rate, sint32 channels, sint32 samples_per_block, sint32 bits_per_sample);
 	static std::unique_ptr<IAudioAPI> CreateDevice(AudioAPI api, const DeviceDescriptionPtr& device, sint32 samplerate, sint32 channels, sint32 samples_per_block, sint32 bits_per_sample);
 	static std::vector<DeviceDescriptionPtr> GetDevices(AudioAPI api);
 
@@ -75,10 +88,14 @@ protected:
 	bool m_playing = false;
 
 	static std::array<bool, AudioAPIEnd> s_availableApis;
-	static uint32 s_audioDelay;
+	uint32 m_audioDelayOverride = 0;
 
 private:
+	static uint32 s_audioDelay;
 	void InitWFX(sint32 samplerate, sint32 channels, sint32 bits_per_sample);
+	static AudioChannels AudioTypeToChannels(AudioType type);
+	static std::wstring GetDeviceFromType(AudioType type);
+	static sint32 GetVolumeFromType(AudioType type);
 	
 };
 
@@ -88,3 +105,5 @@ extern AudioAPIPtr g_tvAudio;
 
 extern AudioAPIPtr g_padAudio;
 extern std::atomic_int32_t g_padVolume;
+
+extern AudioAPIPtr g_portalAudio;
diff --git a/src/audio/IAudioInputAPI.cpp b/src/audio/IAudioInputAPI.cpp
new file mode 100644
index 00000000..28032eb9
--- /dev/null
+++ b/src/audio/IAudioInputAPI.cpp
@@ -0,0 +1,74 @@
+#include "IAudioInputAPI.h"
+#if HAS_CUBEB
+#include "CubebInputAPI.h"
+#endif
+
+std::shared_mutex g_audioInputMutex;
+AudioInputAPIPtr g_inputAudio;
+
+std::array<bool, IAudioInputAPI::AudioInputAPIEnd> IAudioInputAPI::s_availableApis{};
+
+IAudioInputAPI::IAudioInputAPI(uint32 samplerate, uint32 channels, uint32 samples_per_block, uint32 bits_per_sample)
+	: m_samplerate(samplerate), m_channels(channels), m_samplesPerBlock(samples_per_block), m_bitsPerSample(bits_per_sample) 
+{
+	m_bytesPerBlock = samples_per_block * channels * (bits_per_sample / 8);
+}
+
+void IAudioInputAPI::PrintLogging()
+{
+	cemuLog_log(LogType::Force, "------- Init Audio input backend -------");
+	cemuLog_log(LogType::Force, "Cubeb: {}", s_availableApis[Cubeb] ? "available" : "not supported");
+}
+
+void IAudioInputAPI::InitializeStatic()
+{
+#if HAS_CUBEB
+	s_availableApis[Cubeb] = CubebInputAPI::InitializeStatic();
+#endif
+}
+
+bool IAudioInputAPI::IsAudioInputAPIAvailable(AudioInputAPI api)
+{
+	if ((size_t)api < s_availableApis.size())
+		return s_availableApis[api];
+
+	cemu_assert_debug(false);
+	return false;
+}
+
+AudioInputAPIPtr IAudioInputAPI::CreateDevice(AudioInputAPI api, const DeviceDescriptionPtr& device, sint32 samplerate, sint32 channels, sint32 samples_per_block, sint32 bits_per_sample)
+{
+	if (!IsAudioInputAPIAvailable(api))
+		return {};
+
+	switch(api)
+	{
+#if HAS_CUBEB
+	case Cubeb:
+	{
+		const auto tmp = std::dynamic_pointer_cast<CubebInputAPI::CubebDeviceDescription>(device);
+		return std::make_unique<CubebInputAPI>(tmp->GetDeviceId(), samplerate, channels, samples_per_block, bits_per_sample);
+	}
+#endif
+	default:
+		throw std::runtime_error(fmt::format("invalid audio api: {}", api));
+	}
+}
+
+std::vector<IAudioInputAPI::DeviceDescriptionPtr> IAudioInputAPI::GetDevices(AudioInputAPI api)
+{
+	if (!IsAudioInputAPIAvailable(api))
+		return {};
+	
+	switch(api)
+	{
+#if HAS_CUBEB
+	case Cubeb:
+	{
+		return CubebInputAPI::GetDevices();
+	}
+#endif
+	default:
+		throw std::runtime_error(fmt::format("invalid audio api: {}", api));
+	}
+}
diff --git a/src/audio/IAudioInputAPI.h b/src/audio/IAudioInputAPI.h
new file mode 100644
index 00000000..66c43165
--- /dev/null
+++ b/src/audio/IAudioInputAPI.h
@@ -0,0 +1,71 @@
+#pragma once
+
+class IAudioInputAPI
+{
+	friend class GeneralSettings2;
+
+public:
+	class DeviceDescription
+	{
+	public:
+		explicit DeviceDescription(std::wstring name)
+			: m_name(std::move(name)) { }
+
+		virtual ~DeviceDescription() = default;
+		virtual std::wstring GetIdentifier() const = 0;
+		const std::wstring& GetName() const { return m_name; }
+
+		bool operator==(const DeviceDescription& o) const
+		{
+			return GetIdentifier() == o.GetIdentifier();
+		}
+
+	private:
+		std::wstring m_name;
+	};
+
+	using DeviceDescriptionPtr = std::shared_ptr<DeviceDescription>;
+
+	enum AudioInputAPI
+	{
+		Cubeb,
+
+		AudioInputAPIEnd,
+	};
+	static constexpr uint32 kBlockCount = 24;
+
+	IAudioInputAPI(uint32 samplerate, uint32 channels, uint32 samples_per_block, uint32 bits_per_sample);
+	virtual ~IAudioInputAPI() = default;
+	virtual AudioInputAPI GetType() const = 0;
+
+	sint32 GetChannels() const { return m_channels; }
+
+	virtual sint32 GetVolume() const { return m_volume; }
+	virtual void SetVolume(sint32 volume) { m_volume = volume; }
+
+	virtual bool ConsumeBlock(sint16* data) = 0;
+	virtual bool Play() = 0;
+	virtual bool Stop() = 0;
+	virtual bool IsPlaying() const = 0;
+
+	static void PrintLogging();
+	static void InitializeStatic();
+	static bool IsAudioInputAPIAvailable(AudioInputAPI api);
+
+	static std::unique_ptr<IAudioInputAPI> CreateDevice(AudioInputAPI api, const DeviceDescriptionPtr& device, sint32 samplerate, sint32 channels, sint32 samples_per_block, sint32 bits_per_sample);
+	static std::vector<DeviceDescriptionPtr> GetDevices(AudioInputAPI api);
+
+protected:
+	uint32 m_samplerate, m_channels, m_samplesPerBlock, m_bitsPerSample;
+	uint32 m_bytesPerBlock;
+
+	sint32 m_volume = 0;
+
+	static std::array<bool, AudioInputAPIEnd> s_availableApis;
+
+private:
+};
+
+using AudioInputAPIPtr = std::unique_ptr<IAudioInputAPI>;
+extern std::shared_mutex g_audioInputMutex;
+extern AudioInputAPIPtr g_inputAudio;
diff --git a/src/audio/XAudio27API.cpp b/src/audio/XAudio27API.cpp
index 4a99bfa2..cfb21c67 100644
--- a/src/audio/XAudio27API.cpp
+++ b/src/audio/XAudio27API.cpp
@@ -5,7 +5,6 @@
 static_assert(IAudioAPI::kBlockCount < XAUDIO2_MAX_QUEUED_BUFFERS, "too many xaudio2 buffers");
 
 HMODULE XAudio27API::s_xaudio_dll = nullptr;
-bool XAudio27API::s_com_initialized = false;
 std::unique_ptr<IXAudio2, XAudio27API::XAudioDeleter> XAudio27API::s_xaudio;
 
 XAudio27API::XAudio27API(uint32 device_id, uint32 samplerate, uint32 channels, uint32 samples_per_block, uint32 bits_per_sample)
@@ -34,8 +33,8 @@ XAudio27API::XAudio27API(uint32 device_id, uint32 samplerate, uint32 channels, u
 	m_wfx.Format.nChannels = channels;
 	m_wfx.Format.nSamplesPerSec = samplerate;
 	m_wfx.Format.wBitsPerSample = bits_per_sample;
-	m_wfx.Format.nBlockAlign = (m_wfx.Format.nChannels * m_wfx.Format.wBitsPerSample) / 8; // must equal (nChannels � wBitsPerSample) / 8
-	m_wfx.Format.nAvgBytesPerSec = m_wfx.Format.nSamplesPerSec * m_wfx.Format.nBlockAlign; // must equal nSamplesPerSec � nBlockAlign.
+	m_wfx.Format.nBlockAlign = (m_wfx.Format.nChannels * m_wfx.Format.wBitsPerSample) / 8; // must equal (nChannels × wBitsPerSample) / 8
+	m_wfx.Format.nAvgBytesPerSec = m_wfx.Format.nSamplesPerSec * m_wfx.Format.nBlockAlign; // must equal nSamplesPerSec × nBlockAlign.
 	m_wfx.Format.cbSize = sizeof(WAVEFORMATEXTENSIBLE) - sizeof(WAVEFORMATEX);
 
 	m_wfx.SubFormat = KSDATAFORMAT_SUBTYPE_PCM;
@@ -115,8 +114,6 @@ bool XAudio27API::InitializeStatic()
 	if (s_xaudio)
 		return true;
 
-	s_com_initialized = (SUCCEEDED(CoInitializeEx(nullptr, COINIT_MULTITHREADED | COINIT_DISABLE_OLE1DDE)));
-
 #ifdef _DEBUG
 	s_xaudio_dll = LoadLibraryExW(L"XAudioD2_7.DLL", nullptr, LOAD_LIBRARY_SEARCH_SYSTEM32);
 	if(!s_xaudio_dll)
@@ -142,9 +139,6 @@ bool XAudio27API::InitializeStatic()
 		if (s_xaudio_dll)
 			FreeLibrary(s_xaudio_dll);
 
-		if (s_com_initialized)
-			CoUninitialize();
-
 		return false;
 	}
 }
@@ -155,9 +149,6 @@ void XAudio27API::Destroy()
 
 	if (s_xaudio_dll)
 		FreeLibrary(s_xaudio_dll);
-
-	if (s_com_initialized)
-		CoUninitialize();
 }
 
 std::vector<XAudio27API::DeviceDescriptionPtr> XAudio27API::GetDevices()
@@ -208,13 +199,11 @@ bool XAudio27API::FeedBlock(sint16* data)
 	// check if we queued too many blocks
 	if(m_blocks_queued >= kBlockCount)
 	{
-		XAUDIO2_VOICE_STATE state{};
-		m_source_voice->GetState(&state);
-		m_blocks_queued = state.BuffersQueued;
+		m_blocks_queued = GetQueuedBuffers();
 
 		if (m_blocks_queued >= kBlockCount)
 		{
-			forceLogDebug_printf("dropped xaudio2 block since too many buffers are queued");
+			cemuLog_logDebug(LogType::Force, "dropped xaudio2 block since too many buffers are queued");
 			return false;
 		}
 	}
@@ -231,7 +220,14 @@ bool XAudio27API::FeedBlock(sint16* data)
 	return true;
 }
 
+uint32 XAudio27API::GetQueuedBuffers() const
+{
+	XAUDIO2_VOICE_STATE state{};
+	m_source_voice->GetState(&state);
+	return state.BuffersQueued;
+}
+
 bool XAudio27API::NeedAdditionalBlocks() const
 {
-	return m_blocks_queued < s_audioDelay;
+	return GetQueuedBuffers() < GetAudioDelay();
 }
diff --git a/src/audio/XAudio27API.h b/src/audio/XAudio27API.h
index 80e423a3..4288dcc7 100644
--- a/src/audio/XAudio27API.h
+++ b/src/audio/XAudio27API.h
@@ -47,6 +47,8 @@ public:
 	static std::vector<DeviceDescriptionPtr> GetDevices();
 
 private:
+	uint32 GetQueuedBuffers() const;
+
 	struct XAudioDeleter
 	{
 		void operator()(IXAudio2* ptr) const;
@@ -58,7 +60,6 @@ private:
 	};
 
 	static HMODULE s_xaudio_dll;
-	static bool s_com_initialized;
 	static std::unique_ptr<IXAudio2, XAudioDeleter> s_xaudio;
 
 	std::unique_ptr<IXAudio2, XAudioDeleter> m_xaudio;
diff --git a/src/audio/XAudio2API.cpp b/src/audio/XAudio2API.cpp
index 795a0ebe..6b25baed 100644
--- a/src/audio/XAudio2API.cpp
+++ b/src/audio/XAudio2API.cpp
@@ -2,6 +2,7 @@
 
 //#if (_WIN32_WINNT >= 0x0602 /*_WIN32_WINNT_WIN8*/)
 
+#include <wrl/client.h>
 #include <xaudio2.h>
 
 #ifndef XAUDIO2_DLL
@@ -23,7 +24,6 @@ static const GUID DEVINTERFACE_AUDIO_RENDER_GUID = { 0xe6327cad, 0xdcec, 0x4949,
 static_assert(IAudioAPI::kBlockCount < XAUDIO2_MAX_QUEUED_BUFFERS, "too many xaudio2 buffers");
 
 HMODULE XAudio2API::s_xaudio_dll = nullptr;
-bool XAudio2API::s_com_initialized = false;
 std::vector<XAudio2API::DeviceDescriptionPtr> XAudio2API::s_devices;
 
 XAudio2API::XAudio2API(std::wstring device_id, uint32 samplerate, uint32 channels, uint32 samples_per_block, uint32 bits_per_sample)
@@ -34,24 +34,22 @@ XAudio2API::XAudio2API(std::wstring device_id, uint32 samplerate, uint32 channel
 		throw std::runtime_error("can't find XAudio2Create import");
 
 	HRESULT hres;
-	IXAudio2* xaudio;
-	if (FAILED((hres = _XAudio2Create(&xaudio, 0, XAUDIO2_DEFAULT_PROCESSOR))))
+	if (FAILED((hres = _XAudio2Create(&m_xaudio, 0, XAUDIO2_DEFAULT_PROCESSOR))))
 		throw std::runtime_error(fmt::format("can't create xaudio device (hres: {:#x})", hres));
 
-	m_xaudio = decltype(m_xaudio)(xaudio);
 
 	IXAudio2MasteringVoice* mastering_voice;
 	if (FAILED((hres = m_xaudio->CreateMasteringVoice(&mastering_voice, channels, samplerate, 0, m_device_id.empty() ? nullptr : m_device_id.c_str()))))
 		throw std::runtime_error(fmt::format("can't create xaudio mastering voice (hres: {:#x})", hres));
 
-	m_mastering_voice = decltype(m_mastering_voice)(mastering_voice);
+	m_mastering_voice.reset(mastering_voice);
 
 	m_wfx.Format.wFormatTag = WAVE_FORMAT_EXTENSIBLE;
 	m_wfx.Format.nChannels = channels;
 	m_wfx.Format.nSamplesPerSec = samplerate;
 	m_wfx.Format.wBitsPerSample = bits_per_sample;
-	m_wfx.Format.nBlockAlign = (m_wfx.Format.nChannels * m_wfx.Format.wBitsPerSample) / 8; // must equal (nChannels � wBitsPerSample) / 8
-	m_wfx.Format.nAvgBytesPerSec = m_wfx.Format.nSamplesPerSec * m_wfx.Format.nBlockAlign; // must equal nSamplesPerSec � nBlockAlign.
+	m_wfx.Format.nBlockAlign = (m_wfx.Format.nChannels * m_wfx.Format.wBitsPerSample) / 8; // must equal (nChannels × wBitsPerSample) / 8
+	m_wfx.Format.nAvgBytesPerSec = m_wfx.Format.nSamplesPerSec * m_wfx.Format.nBlockAlign; // must equal nSamplesPerSec × nBlockAlign.
 	m_wfx.Format.cbSize = sizeof(WAVEFORMATEXTENSIBLE) - sizeof(WAVEFORMATEX);
 
 	m_wfx.SubFormat = KSDATAFORMAT_SUBTYPE_PCM;
@@ -89,12 +87,6 @@ XAudio2API::XAudio2API(std::wstring device_id, uint32 samplerate, uint32 channel
 	m_xaudio->StartEngine();
 }
 
-void XAudio2API::XAudioDeleter::operator()(IXAudio2* ptr) const
-{
-	if (ptr)
-		ptr->Release();
-}
-
 void XAudio2API::VoiceDeleter::operator()(IXAudio2Voice* ptr) const
 {
 	if (ptr)
@@ -107,10 +99,6 @@ XAudio2API::~XAudio2API()
 		m_xaudio->StopEngine();
 
 	XAudio2API::Stop();
-
-	m_source_voice.reset();
-	m_mastering_voice.reset();
-	m_xaudio.reset();
 }
 
 void XAudio2API::SetVolume(sint32 volume)
@@ -143,8 +131,6 @@ bool XAudio2API::InitializeStatic()
 {
 	if (s_xaudio_dll)
 		return true;
-	
-	s_com_initialized = (SUCCEEDED(CoInitializeEx(nullptr, COINIT_MULTITHREADED)));
 
 	// win 10
 	s_xaudio_dll = LoadLibraryEx(XAUDIO2_DLL, nullptr, LOAD_LIBRARY_SEARCH_SYSTEM32);
@@ -166,9 +152,6 @@ bool XAudio2API::InitializeStatic()
 		if (s_xaudio_dll)
 			FreeLibrary(s_xaudio_dll);
 
-		if (s_com_initialized)
-			CoUninitialize();
-
 		return false;
 	}
 }
@@ -177,25 +160,18 @@ void XAudio2API::Destroy()
 {
 	if (s_xaudio_dll)
 		FreeLibrary(s_xaudio_dll);
-
-	if (s_com_initialized)
-		CoUninitialize();
 }
 
 const std::vector<XAudio2API::DeviceDescriptionPtr>& XAudio2API::RefreshDevices()
 {
-	// this function must be called from the same thread as we called CoInitializeEx
 	s_devices.clear();
 
-	if (FAILED(CoInitializeEx(nullptr, COINIT_MULTITHREADED | COINIT_DISABLE_OLE1DDE)))
-		return s_devices;
-
 	try
 	{
-		struct IWbemLocator *wbem_locator = nullptr;
+		Microsoft::WRL::ComPtr<IWbemLocator> wbem_locator;
 
-		HRESULT hres = CoCreateInstance(__uuidof(WbemLocator), nullptr, CLSCTX_INPROC_SERVER, __uuidof(IWbemLocator), (LPVOID*)&wbem_locator);
-		if (FAILED(hres) || !wbem_locator)
+		HRESULT hres = CoCreateInstance(__uuidof(WbemLocator), nullptr, CLSCTX_INPROC_SERVER, IID_PPV_ARGS(&wbem_locator));
+		if (FAILED(hres))
 			throw std::system_error(hres, std::system_category());
 
 		std::shared_ptr<OLECHAR> path(SysAllocString(LR"(\\.\root\cimv2)"), SysFreeString);
@@ -204,20 +180,19 @@ const std::vector<XAudio2API::DeviceDescriptionPtr>& XAudio2API::RefreshDevices(
 		std::shared_ptr<OLECHAR> name_row(SysAllocString(L"Name"), SysFreeString);
 		std::shared_ptr<OLECHAR> device_id_row(SysAllocString(L"DeviceID"), SysFreeString);
 
-		IWbemServices *wbem_services = nullptr;
+		Microsoft::WRL::ComPtr<IWbemServices> wbem_services;
 		hres = wbem_locator->ConnectServer(path.get(), nullptr, nullptr, nullptr, 0, nullptr, nullptr, &wbem_services);
-		wbem_locator->Release(); // Free memory resources.
 
-		if (FAILED(hres) || !wbem_services)
-			throw std::system_error(hres, std::system_category());
-
-		hres = CoSetProxyBlanket(wbem_services, RPC_C_AUTHN_WINNT, RPC_C_AUTHZ_NONE, nullptr, RPC_C_AUTHN_LEVEL_CALL, RPC_C_IMP_LEVEL_IMPERSONATE, nullptr, EOAC_NONE);
 		if (FAILED(hres))
 			throw std::system_error(hres, std::system_category());
 
-		IEnumWbemClassObject* wbem_enum = nullptr;
+		hres = CoSetProxyBlanket(wbem_services.Get(), RPC_C_AUTHN_WINNT, RPC_C_AUTHZ_NONE, nullptr, RPC_C_AUTHN_LEVEL_CALL, RPC_C_IMP_LEVEL_IMPERSONATE, nullptr, EOAC_NONE);
+		if (FAILED(hres))
+			throw std::system_error(hres, std::system_category());
+
+		Microsoft::WRL::ComPtr<IEnumWbemClassObject> wbem_enum;
 		hres = wbem_services->ExecQuery(language.get(), query.get(), WBEM_FLAG_RETURN_WBEM_COMPLETE | WBEM_FLAG_FORWARD_ONLY, nullptr, &wbem_enum);
-		if (FAILED(hres) || !wbem_enum)
+		if (FAILED(hres))
 			throw std::system_error(hres, std::system_category());
 
 		ULONG returned;
@@ -263,15 +238,10 @@ const std::vector<XAudio2API::DeviceDescriptionPtr>& XAudio2API::RefreshDevices(
 			auto default_device = std::make_shared<XAudio2DeviceDescription>(L"Primary Sound Driver", L"");
 			s_devices.insert(s_devices.begin(), default_device);
 		}
-		
-		wbem_enum->Release();
-
-		// Clean up
-		wbem_services->Release();
 	}
 	catch (const std::system_error& ex)
 	{
-		forceLog_printf("XAudio2API::RefreshDevices: error while refreshing device list (%s - code: 0x%08x)", ex.what(), ex.code().value());
+		cemuLog_log(LogType::Force, "XAudio2API::RefreshDevices: error while refreshing device list ({} - code: 0x{:08x})", ex.what(), ex.code().value());
 	}
 
 	CoUninitialize();
@@ -283,13 +253,11 @@ bool XAudio2API::FeedBlock(sint16* data)
 	// check if we queued too many blocks
 	if (m_blocks_queued >= kBlockCount)
 	{
-		XAUDIO2_VOICE_STATE state{};
-		m_source_voice->GetState(&state);
-		m_blocks_queued = state.BuffersQueued;
+		m_blocks_queued = GetQueuedBuffers();
 
 		if (m_blocks_queued >= kBlockCount)
 		{
-			forceLogDebug_printf("dropped xaudio2 block since too many buffers are queued");
+			cemuLog_logDebug(LogType::Force, "dropped xaudio2 block since too many buffers are queued");
 			return false;
 		}
 	}
@@ -306,7 +274,14 @@ bool XAudio2API::FeedBlock(sint16* data)
 	return true;
 }
 
+uint32 XAudio2API::GetQueuedBuffers() const
+{
+	XAUDIO2_VOICE_STATE state{};
+	m_source_voice->GetState(&state);
+	return state.BuffersQueued;
+}
+
 bool XAudio2API::NeedAdditionalBlocks() const
 {
-	return m_blocks_queued < s_audioDelay;
+	return GetQueuedBuffers() < GetAudioDelay();
 }
diff --git a/src/audio/XAudio2API.h b/src/audio/XAudio2API.h
index 2b23e1cc..5bb01b10 100644
--- a/src/audio/XAudio2API.h
+++ b/src/audio/XAudio2API.h
@@ -4,6 +4,7 @@
 #include <mmsystem.h>
 #include <mmreg.h>
 #include <dsound.h>
+#include <wrl/client.h>
 
 #include "IAudioAPI.h"
 
@@ -46,12 +47,9 @@ public:
 	static const std::vector<DeviceDescriptionPtr>& GetDevices() { return s_devices;	}
 
 private:
-	static const std::vector<DeviceDescriptionPtr>& RefreshDevices();
+	uint32 GetQueuedBuffers() const;
 
-	struct XAudioDeleter
-	{
-		void operator()(IXAudio2* ptr) const;
-	};
+	static const std::vector<DeviceDescriptionPtr>& RefreshDevices();
 
 	struct VoiceDeleter
 	{
@@ -59,10 +57,9 @@ private:
 	};
 
 	static HMODULE s_xaudio_dll;
-	static bool s_com_initialized;
 	static std::vector<DeviceDescriptionPtr> s_devices;
 
-	std::unique_ptr<IXAudio2, XAudioDeleter> m_xaudio;
+	Microsoft::WRL::ComPtr<IXAudio2> m_xaudio;
 	std::wstring m_device_id;
 	std::unique_ptr<IXAudio2MasteringVoice, VoiceDeleter> m_mastering_voice;
 	std::unique_ptr<IXAudio2SourceVoice, VoiceDeleter> m_source_voice;
diff --git a/src/audio/audioDebuggerWindow.cpp b/src/audio/audioDebuggerWindow.cpp
index 41107820..3a51d187 100644
--- a/src/audio/audioDebuggerWindow.cpp
+++ b/src/audio/audioDebuggerWindow.cpp
@@ -33,93 +33,93 @@ AudioDebuggerWindow::AudioDebuggerWindow(wxFrame& parent)
 	// add columns
 	wxListItem col0;
 	col0.SetId(0);
-	col0.SetText(wxT("idx"));
+	col0.SetText("idx");
 	col0.SetWidth(40);
 	voiceListbox->InsertColumn(0, col0);
 	wxListItem col1;
 	col1.SetId(1);
-	col1.SetText(wxT("state"));
+	col1.SetText("state");
 	col1.SetWidth(48);
 	voiceListbox->InsertColumn(1, col1);
 	//wxListItem col2;
 	// format
 	col1.SetId(2);
-	col1.SetText(wxT("fmt"));
+	col1.SetText("fmt");
 	col1.SetWidth(52);
 	voiceListbox->InsertColumn(2, col1);
 	// sample base addr
 	col1.SetId(3);
-	col1.SetText(wxT("base"));
+	col1.SetText("base");
 	col1.SetWidth(70);
 	voiceListbox->InsertColumn(3, col1);
 	// current offset
 	col1.SetId(4);
-	col1.SetText(wxT("current"));
+	col1.SetText("current");
 	col1.SetWidth(70);
 	voiceListbox->InsertColumn(4, col1);
 	// loop offset
 	col1.SetId(5);
-	col1.SetText(wxT("loop"));
+	col1.SetText("loop");
 	col1.SetWidth(70);
 	voiceListbox->InsertColumn(5, col1);
 	// end offset
 	col1.SetId(6);
-	col1.SetText(wxT("end"));
+	col1.SetText("end");
 	col1.SetWidth(70);
 	voiceListbox->InsertColumn(6, col1);
 	// volume
 	col1.SetId(7);
-	col1.SetText(wxT("vol"));
+	col1.SetText("vol");
 	col1.SetWidth(46);
 	voiceListbox->InsertColumn(7, col1);
 	// volume delta
 	col1.SetId(8);
-	col1.SetText(wxT("volD"));
+	col1.SetText("volD");
 	col1.SetWidth(46);
 	voiceListbox->InsertColumn(8, col1);
 	// src
 	col1.SetId(9);
-	col1.SetText(wxT("src"));
+	col1.SetText("src");
 	col1.SetWidth(70);
 	voiceListbox->InsertColumn(9, col1);
 	// low-pass filter coef a0
 	col1.SetId(10);
-	col1.SetText(wxT("lpa0"));
+	col1.SetText("lpa0");
 	col1.SetWidth(46);
 	voiceListbox->InsertColumn(10, col1);
 	// low-pass filter coef b0
 	col1.SetId(11);
-	col1.SetText(wxT("lpb0"));
+	col1.SetText("lpb0");
 	col1.SetWidth(46);
 	voiceListbox->InsertColumn(11, col1);
 	// biquad filter coef b0
 	col1.SetId(12);
-	col1.SetText(wxT("bqb0"));
+	col1.SetText("bqb0");
 	col1.SetWidth(46);
 	voiceListbox->InsertColumn(12, col1);
 	// biquad filter coef b0
 	col1.SetId(13);
-	col1.SetText(wxT("bqb1"));
+	col1.SetText("bqb1");
 	col1.SetWidth(46);
 	voiceListbox->InsertColumn(13, col1);
 	// biquad filter coef b0
 	col1.SetId(14);
-	col1.SetText(wxT("bqb2"));
+	col1.SetText("bqb2");
 	col1.SetWidth(46);
 	voiceListbox->InsertColumn(14, col1);
 	// biquad filter coef a0
 	col1.SetId(15);
-	col1.SetText(wxT("bqa1"));
+	col1.SetText("bqa1");
 	col1.SetWidth(46);
 	voiceListbox->InsertColumn(15, col1);
 	// biquad filter coef a1
 	col1.SetId(16);
-	col1.SetText(wxT("bqa2"));
+	col1.SetText("bqa2");
 	col1.SetWidth(46);
 	voiceListbox->InsertColumn(16, col1);
 	// device mix
 	col1.SetId(17);
-	col1.SetText(wxT("deviceMix"));
+	col1.SetText("deviceMix");
 	col1.SetWidth(186);
 	voiceListbox->InsertColumn(17, col1);
 
diff --git a/src/config/ActiveSettings.cpp b/src/config/ActiveSettings.cpp
index c7ff4fe6..e552d164 100644
--- a/src/config/ActiveSettings.cpp
+++ b/src/config/ActiveSettings.cpp
@@ -1,27 +1,52 @@
-#include "config/ActiveSettings.h"
-
 #include "Cafe/GameProfile/GameProfile.h"
-#include "LaunchSettings.h"
-#include "util/helpers/helpers.h"
-
-#include <boost/dll/runtime_symbol_info.hpp>
-
 #include "Cafe/IOSU/legacy/iosu_crypto.h"
 #include "Cafe/HW/Latte/Renderer/Vulkan/VulkanAPI.h"
 #include "Cafe/CafeSystem.h"
+#include "Cemu/Logging/CemuLogging.h"
+#include "config/ActiveSettings.h"
+#include "config/LaunchSettings.h"
+#include "util/helpers/helpers.h"
 
-extern bool alwaysDisplayDRC;
-
-void ActiveSettings::LoadOnce()
+void ActiveSettings::SetPaths(bool isPortableMode,
+		const fs::path& executablePath,
+		const fs::path& userDataPath,
+		const fs::path& configPath,
+		const fs::path& cachePath,
+		const fs::path& dataPath,
+		std::set<fs::path>& failedWriteAccess)
 {
-	s_full_path = boost::dll::program_location().generic_wstring();
-	s_path = s_full_path.parent_path();
-	s_filename = s_full_path.filename();
+	cemu_assert_debug(!s_setPathsCalled); // can only change paths before loading
+	s_isPortableMode = isPortableMode;
+	s_executable_path = executablePath;
+	s_user_data_path = userDataPath;
+	s_config_path = configPath;
+	s_cache_path = cachePath;
+	s_data_path = dataPath;
+	failedWriteAccess.clear();
+	for (auto&& path : {userDataPath, configPath, cachePath})
+	{
+		std::error_code ec;
+		if (!fs::exists(path, ec))
+			fs::create_directories(path, ec);
+		if (!TestWriteAccess(path))
+		{
+			cemuLog_log(LogType::Force, "Failed to write to {}", _pathToUtf8(path));
+			failedWriteAccess.insert(path);
+		}
+	}
+	s_executable_filename = s_executable_path.filename();
+	s_setPathsCalled = true;
+}
 
-	g_config.SetFilename(GetPath("settings.xml").generic_wstring());
-	g_config.Load();
+[[nodiscard]] bool ActiveSettings::IsPortableMode()
+{
+	return s_isPortableMode;
+}
 
-	std::wstring additionalErrorInfo;
+void ActiveSettings::Init()
+{
+	cemu_assert_debug(s_setPathsCalled);
+	std::string additionalErrorInfo;
 	s_has_required_online_files = iosuCrypt_checkRequirementsForOnlineMode(additionalErrorInfo) == IOS_CRYPTO_ONLINE_REQ_OK;
 }
 
@@ -32,7 +57,6 @@ bool ActiveSettings::LoadSharedLibrariesEnabled()
 
 bool ActiveSettings::DisplayDRCEnabled()
 {
-	alwaysDisplayDRC = g_current_game_profile->StartWithGamepadView();
 	return g_current_game_profile->StartWithGamepadView();
 }
 
@@ -113,7 +137,12 @@ uint32 ActiveSettings::GetPersistentId()
 
 bool ActiveSettings::IsOnlineEnabled()
 {
-	return GetConfig().account.online_enabled && Account::GetAccount(GetPersistentId()).IsValidOnlineAccount() && HasRequiredOnlineFiles();
+	if(!Account::GetAccount(GetPersistentId()).IsValidOnlineAccount())
+		return false;
+	if(!HasRequiredOnlineFiles())
+		return false;
+	NetworkService networkService = static_cast<NetworkService>(GetConfig().GetAccountNetworkService(GetPersistentId()));
+	return networkService == NetworkService::Nintendo || networkService == NetworkService::Pretendo || networkService == NetworkService::Custom;
 }
 
 bool ActiveSettings::HasRequiredOnlineFiles()
@@ -121,6 +150,11 @@ bool ActiveSettings::HasRequiredOnlineFiles()
 	return s_has_required_online_files;
 }
 
+NetworkService ActiveSettings::GetNetworkService()
+{
+	return GetConfig().GetAccountNetworkService(GetPersistentId());
+}
+
 bool ActiveSettings::DumpShadersEnabled()
 {
 	return s_dump_shaders;
@@ -131,6 +165,11 @@ bool ActiveSettings::DumpTexturesEnabled()
 	return s_dump_textures;
 }
 
+bool ActiveSettings::DumpRecompilerFunctionsEnabled()
+{
+	return s_dump_recompiler_functions;
+}
+
 bool ActiveSettings::DumpLibcurlRequestsEnabled()
 {
 	return s_dump_libcurl_requests;
@@ -146,21 +185,16 @@ void ActiveSettings::EnableDumpTextures(bool state)
 	s_dump_textures = state;
 }
 
+void ActiveSettings::EnableDumpRecompilerFunctions(bool state)
+{
+	s_dump_recompiler_functions = state;
+}
+
 void ActiveSettings::EnableDumpLibcurlRequests(bool state)
 {
 	s_dump_libcurl_requests = state;
 }
 
-bool ActiveSettings::FrameProfilerEnabled()
-{
-	return s_frame_profiler_enabled;
-}
-
-void ActiveSettings::EnableFrameProfiler(bool state)
-{
-	s_frame_profiler_enabled = state;
-}
-
 bool ActiveSettings::VPADDelayEnabled()
 {
 	const uint64 titleId = CafeSystem::GetForegroundTitleId();
@@ -174,14 +208,20 @@ bool ActiveSettings::ShaderPreventInfiniteLoopsEnabled()
 {
 	const uint64 titleId = CafeSystem::GetForegroundTitleId();
 	// workaround for NSMBU (and variants) having a bug where shaders can get stuck in infinite loops
-	// update: As of Cemu 1.20.0 this should no longer be required
+	// Fatal Frame has an actual infinite loop in shader 0xb6a67c19f6472e00 encountered during a cutscene for the second drop (eShop version only?)
+	// update: As of Cemu 1.20.0 this should no longer be required for NSMBU/NSLU due to fixes with uniform handling. But we leave it here for good measure
+	// todo - Once we add support for loop config registers this workaround should become unnecessary
 	return /* NSMBU JP */ titleId == 0x0005000010101C00 ||
 		/* NSMBU US */ titleId == 0x0005000010101D00 ||
 		/* NSMBU EU */ titleId == 0x0005000010101E00 ||
 		/* NSMBU+L US */ titleId == 0x000500001014B700 ||
 		/* NSMBU+L EU */ titleId == 0x000500001014B800 ||
 		/* NSLU US */ titleId == 0x0005000010142300 ||
-		/* NSLU EU */ titleId == 0x0005000010142400;
+		/* NSLU EU */ titleId == 0x0005000010142400 ||
+	   /* Project Zero: Maiden of Black Water (EU) */ titleId == 0x00050000101D0300 ||
+	   /* Fatal Frame: Maiden of Black Water (US) */ titleId == 0x00050000101D0600 ||
+	   /* Project Zero: Maiden of Black Water (JP) */ titleId == 0x000500001014D200 ||
+	   /* Project Zero: Maiden of Black Water (Trial, EU) */ titleId == 0x00050000101D3F00;
 }
 
 bool ActiveSettings::FlushGPUCacheOnSwap()
@@ -211,17 +251,29 @@ bool ActiveSettings::ForceSamplerRoundToPrecision()
 
 fs::path ActiveSettings::GetMlcPath()
 {
+	cemu_assert_debug(s_setPathsCalled);
 	if(const auto launch_mlc = LaunchSettings::GetMLCPath(); launch_mlc.has_value())
 		return launch_mlc.value();
 
 	if(const auto config_mlc = GetConfig().mlc_path.GetValue(); !config_mlc.empty())
-		return config_mlc;
+		return _utf8ToPath(config_mlc);
 
 	return GetDefaultMLCPath();
 }
 
-fs::path ActiveSettings::GetDefaultMLCPath()
+bool ActiveSettings::IsCustomMlcPath()
 {
-	return GetPath("mlc01");
+	cemu_assert_debug(s_setPathsCalled);
+	return !GetConfig().mlc_path.GetValue().empty();
+}
+
+bool ActiveSettings::IsCommandLineMlcPath()
+{
+	return LaunchSettings::GetMLCPath().has_value();
+}
+
+fs::path ActiveSettings::GetDefaultMLCPath()
+{
+	return GetUserDataPath("mlc01");
 }
 
diff --git a/src/config/ActiveSettings.h b/src/config/ActiveSettings.h
index 69f6d34a..0d7ecfec 100644
--- a/src/config/ActiveSettings.h
+++ b/src/config/ActiveSettings.h
@@ -1,77 +1,90 @@
 #pragma once
 
+#include <utility>
 #include "config/CemuConfig.h"
+#include "config/NetworkSettings.h"
 
 // global active settings for fast access (reflects settings from command line and game profile)
 class ActiveSettings
 {
-public:
-	static void LoadOnce();
-	
-	[[nodiscard]] static fs::path GetFullPath() { return s_full_path; }
-	[[nodiscard]] static fs::path GetPath() { return s_path; }
-	[[nodiscard]] static fs::path GetFilename() { return s_filename; }
-	
-	[[nodiscard]] static fs::path GetMlcPath();
-
-	[[nodiscard]] static fs::path GetPath(std::string_view p) 
-	{
-		std::basic_string_view<char8_t> s((const char8_t*)p.data(), p.size());
-		return s_path / fs::path(s);
-	}
-
-	[[nodiscard]] static fs::path GetMlcPath(std::string_view p) 
-	{ 
-		std::basic_string_view<char8_t> s((const char8_t*)p.data(), p.size());
-		return GetMlcPath() / fs::path(s);
-	}
-	
+private:
 	template <typename ...TArgs>
-	[[nodiscard]] static fs::path GetPath(std::string_view format, TArgs&&... args)
+	static fs::path GetPath(const fs::path& path, std::string_view format, TArgs&&... args)
 	{
 		cemu_assert_debug(format.empty() || (format[0] != '/' && format[0] != '\\'));
 		std::string tmpPathStr = fmt::format(fmt::runtime(format), std::forward<TArgs>(args)...);
-		std::basic_string_view<char8_t> s((const char8_t*)tmpPathStr.data(), tmpPathStr.size());
-		return s_path / fs::path(s);
+		return path / _utf8ToPath(tmpPathStr);
 	}
-	
+
 	template <typename ...TArgs>
-	[[nodiscard]] static fs::path GetPath(std::wstring_view format, TArgs&&... args)
+	static fs::path GetPath(const fs::path& path, std::wstring_view format, TArgs&&... args)
 	{
 		cemu_assert_debug(format.empty() || (format[0] != L'/' && format[0] != L'\\'));
-		return s_path / fmt::format(format, std::forward<TArgs>(args)...);
+		return path / fmt::format(fmt::runtime(format), std::forward<TArgs>(args)...);
 	}
-	
-	template <typename ...TArgs>
-	[[nodiscard]] static fs::path GetMlcPath(std::string_view format, TArgs&&... args)
+	static fs::path GetPath(const fs::path& path, std::string_view p) 
 	{
-		cemu_assert_debug(format.empty() || (format[0] != '/' && format[0] != '\\'));
-		auto tmp = fmt::format(fmt::runtime(format), std::forward<TArgs>(args)...);
-		return GetMlcPath() / _utf8ToPath(tmp);
+		std::basic_string_view<char8_t> s((const char8_t*)p.data(), p.size());
+		return path / fs::path(s);
 	}
-	
-	template <typename ...TArgs>
-	[[nodiscard]] static fs::path GetMlcPath(std::wstring_view format, TArgs&&... args)
+	static fs::path GetPath(const fs::path& path)
 	{
-		cemu_assert_debug(format.empty() || (format[0] != L'/' && format[0] != L'\\'));
-		return GetMlcPath() / fmt::format(fmt::runtime(format), std::forward<TArgs>(args)...);
+		return path;
 	}
-	
+
+public:
+	// Set directories and return all directories that failed write access test
+	static void
+	SetPaths(bool isPortableMode,
+		   const fs::path& executablePath,
+		   const fs::path& userDataPath,
+		   const fs::path& configPath,
+		   const fs::path& cachePath,
+		   const fs::path& dataPath,
+		   std::set<fs::path>& failedWriteAccess);
+
+	static void Init();
+
+	[[nodiscard]] static fs::path GetExecutablePath() { return s_executable_path; }
+	[[nodiscard]] static fs::path GetExecutableFilename() { return s_executable_filename; }
+	template <typename ...TArgs>
+	[[nodiscard]] static fs::path GetUserDataPath(TArgs&&... args){ return GetPath(s_user_data_path, std::forward<TArgs>(args)...); };
+	template <typename ...TArgs>
+	[[nodiscard]] static fs::path GetConfigPath(TArgs&&... args){ return GetPath(s_config_path, std::forward<TArgs>(args)...); };
+	template <typename ...TArgs>
+	[[nodiscard]] static fs::path GetCachePath(TArgs&&... args){ return GetPath(s_cache_path, std::forward<TArgs>(args)...); };
+	template <typename ...TArgs>
+	[[nodiscard]] static fs::path GetDataPath(TArgs&&... args){ return GetPath(s_data_path, std::forward<TArgs>(args)...); };
+
+	[[nodiscard]] static fs::path GetMlcPath();
+
+	template <typename ...TArgs>
+	[[nodiscard]] static fs::path GetMlcPath(TArgs&&... args){ return GetPath(GetMlcPath(), std::forward<TArgs>(args)...); };
+	static bool IsCustomMlcPath();
+	static bool IsCommandLineMlcPath();
+
 	// get mlc path to default cemu root dir/mlc01
 	[[nodiscard]] static fs::path GetDefaultMLCPath();
 
 private:
-	inline static fs::path s_full_path; // full filename
-	inline static fs::path s_path; // path
-	inline static fs::path s_filename; // cemu.exe
+	inline static bool s_isPortableMode{false};
+	inline static fs::path s_executable_path;
+	inline static fs::path s_user_data_path;
+	inline static fs::path s_config_path;
+	inline static fs::path s_cache_path;
+	inline static fs::path s_data_path;
+	inline static fs::path s_executable_filename; // cemu.exe
 	inline static fs::path s_mlc_path;
 
-public:	
+public:
+	// can be called before Init
+	[[nodiscard]] static bool IsPortableMode();
+
 	// general
 	[[nodiscard]] static bool LoadSharedLibrariesEnabled();
 	[[nodiscard]] static bool DisplayDRCEnabled();
 	[[nodiscard]] static bool FullscreenEnabled();
-	
+
 	// cpu
 	[[nodiscard]] static CPUMode GetCPUMode();
 	[[nodiscard]] static uint8 GetTimerShiftFactor();
@@ -92,19 +105,17 @@ public:
 	[[nodiscard]] static uint32 GetPersistentId();
 	[[nodiscard]] static bool IsOnlineEnabled();
 	[[nodiscard]] static bool HasRequiredOnlineFiles();
-
+	[[nodiscard]] static NetworkService GetNetworkService();
 	// dump options
 	[[nodiscard]] static bool DumpShadersEnabled();
 	[[nodiscard]] static bool DumpTexturesEnabled();
+	[[nodiscard]] static bool DumpRecompilerFunctionsEnabled();
 	[[nodiscard]] static bool DumpLibcurlRequestsEnabled();
 	static void EnableDumpShaders(bool state);
 	static void EnableDumpTextures(bool state);
+	static void EnableDumpRecompilerFunctions(bool state);
 	static void EnableDumpLibcurlRequests(bool state);
 
-	// debug
-	[[nodiscard]] static bool FrameProfilerEnabled();
-	static void EnableFrameProfiler(bool state);
-
 	// hacks
 	[[nodiscard]] static bool VPADDelayEnabled();
 	[[nodiscard]] static bool ShaderPreventInfiniteLoopsEnabled();
@@ -112,16 +123,17 @@ public:
 	[[nodiscard]] static bool ForceSamplerRoundToPrecision();
 
 private:
+	inline static bool s_setPathsCalled = false;
 	// dump options
 	inline static bool s_dump_shaders = false;
 	inline static bool s_dump_textures = false;
+	inline static bool s_dump_recompiler_functions = false;
 	inline static bool s_dump_libcurl_requests = false;
 
 	// timer speed
 	inline static uint8 s_timer_shift = 3; // right shift factor, 0 -> 8x, 3 -> 1x, 4 -> 0.5x
 
 	// debug
-	inline static bool s_frame_profiler_enabled = false;
 	inline static bool s_audio_aux_only = false;
 
 	inline static bool s_has_required_online_files = false;
diff --git a/src/config/CMakeLists.txt b/src/config/CMakeLists.txt
index 58008e46..d53e8574 100644
--- a/src/config/CMakeLists.txt
+++ b/src/config/CMakeLists.txt
@@ -1,8 +1,15 @@
-project(CemuConfig)
-
-file(GLOB CPP_FILES *.cpp)
-file(GLOB H_FILES *.h)
-add_library(CemuConfig ${CPP_FILES} ${H_FILES})
+add_library(CemuConfig
+    ActiveSettings.cpp
+    ActiveSettings.h
+    CemuConfig.cpp
+    CemuConfig.h
+    ConfigValue.h
+    LaunchSettings.cpp
+    LaunchSettings.h
+    NetworkSettings.cpp
+    NetworkSettings.h
+    XMLConfig.h
+)
 
 set_property(TARGET CemuConfig PROPERTY MSVC_RUNTIME_LIBRARY "MultiThreaded$<$<CONFIG:Debug>:Debug>")
 
diff --git a/src/config/CemuConfig.cpp b/src/config/CemuConfig.cpp
index 31a3b3e2..809a5470 100644
--- a/src/config/CemuConfig.cpp
+++ b/src/config/CemuConfig.cpp
@@ -5,33 +5,15 @@
 
 #include <wx/language.h>
 
-#include "PermanentConfig.h"
 #include "ActiveSettings.h"
 
 XMLCemuConfig_t g_config(L"settings.xml");
 
-void CemuConfig::SetMLCPath(std::wstring_view path, bool save)
+void CemuConfig::SetMLCPath(fs::path path, bool save)
 {
-	mlc_path.SetValue(path);
+	mlc_path.SetValue(_pathToUtf8(path));
 	if(save)
 		g_config.Save();
-
-	// if custom mlc path has been selected, store it in permanent config
-	if (!boost::starts_with(path, ActiveSettings::GetDefaultMLCPath().generic_wstring()))
-	{
-		try
-		{
-			auto pconfig = PermanentConfig::Load();
-			pconfig.custom_mlc_path = boost::nowide::narrow(path.data(), path.size());
-			pconfig.Store();
-		}
-		catch (const PSDisabledException&) {}
-		catch (const std::exception& ex)
-		{
-			forceLog_printf("can't store custom mlc path in permanent storage: %s", ex.what());
-		}
-	}
-
 	Account::RefreshAccounts();
 }
 
@@ -43,32 +25,28 @@ void CemuConfig::Load(XMLConfigParser& parser)
 
 	// general settings
 	log_flag = parser.get("logflag", log_flag.GetInitValue());
+	cemuLog_setActiveLoggingFlags(GetConfig().log_flag.GetValue());
 	advanced_ppc_logging = parser.get("advanced_ppc_logging", advanced_ppc_logging.GetInitValue());
 
 	const char* mlc = parser.get("mlc_path", "");
-	try
-	{
-		mlc_path = boost::nowide::widen(mlc);
-	}
-	catch (const std::exception&)
-	{
-		forceLog_printf("config load error: can't load mlc path: %s", mlc);
-	}
+	mlc_path = mlc;
 
 	permanent_storage = parser.get("permanent_storage", permanent_storage);
 	
 	language = parser.get<sint32>("language", wxLANGUAGE_DEFAULT);
 	use_discord_presence = parser.get("use_discord_presence", true);
 	fullscreen_menubar = parser.get("fullscreen_menubar", false);
+	feral_gamemode = parser.get("feral_gamemode", false);
 	check_update = parser.get("check_update", check_update);
+	receive_untested_updates = parser.get("receive_untested_updates", receive_untested_updates);
 	save_screenshot = parser.get("save_screenshot", save_screenshot);
 	did_show_vulkan_warning = parser.get("vk_warning", did_show_vulkan_warning);
 	did_show_graphic_pack_download = parser.get("gp_download", did_show_graphic_pack_download);
+	did_show_macos_disclaimer = parser.get("macos_disclaimer", did_show_macos_disclaimer);
 	fullscreen = parser.get("fullscreen", fullscreen);
 	proxy_server = parser.get("proxy_server", "");
-
-	// cpu_mode = parser.get("cpu_mode", cpu_mode.GetInitValue());
-	//console_region = parser.get("console_region", console_region.GetInitValue());
+	disable_screensaver = parser.get("disable_screensaver", disable_screensaver);
+	play_boot_sound = parser.get("play_boot_sound", play_boot_sound);
 	console_language = parser.get("console_language", console_language.GetInitValue());
 
 	window_position.x = parser.get("window_position").get("x", -1);
@@ -89,12 +67,24 @@ void CemuConfig::Load(XMLConfigParser& parser)
 	auto gamelist = parser.get("GameList");
 	game_list_style = gamelist.get("style", 0);
 	game_list_column_order = gamelist.get("order", "");
-	column_width.name = gamelist.get("name_width", -3);
-	column_width.version = gamelist.get("version_width", -3);
-	column_width.dlc = gamelist.get("dlc_width", -3);
-	column_width.game_time = gamelist.get("game_time_width", -3);
-	column_width.game_started = gamelist.get("game_started_width", -3);
-	column_width.region = gamelist.get("region_width", -3);
+
+	show_icon_column = parser.get("show_icon_column", true);
+
+	// return default width if value in config file out of range
+	auto loadColumnSize = [&gamelist] (const char *name, uint32 defaultWidth)
+	{
+		sint64 val = gamelist.get(name, DefaultColumnSize::name);
+		if (val < 0 || val > (sint64) std::numeric_limits<uint32>::max)
+			return defaultWidth;
+		return static_cast<uint32>(val);
+	};
+	column_width.name = loadColumnSize("name_width", DefaultColumnSize::name);
+	column_width.version = loadColumnSize("version_width", DefaultColumnSize::version);
+	column_width.dlc = loadColumnSize("dlc_width", DefaultColumnSize::dlc);
+	column_width.game_time = loadColumnSize("game_time_width", DefaultColumnSize::game_time);
+	column_width.game_started = loadColumnSize("game_started_width", DefaultColumnSize::game_started);
+	column_width.region = loadColumnSize("region_width", DefaultColumnSize::region);
+    column_width.title_id = loadColumnSize("title_id", DefaultColumnSize::title_id);
 
 	recent_launch_files.clear();
 	auto launch_parser = parser.get("RecentLaunchFiles");
@@ -106,11 +96,11 @@ void CemuConfig::Load(XMLConfigParser& parser)
 
 		try
 		{
-			recent_launch_files.emplace_back(boost::nowide::widen(path));
+			recent_launch_files.emplace_back(path);
 		}
 		catch (const std::exception&)
 		{
-			forceLog_printf("config load error: can't load recently launched game file: %s", path.c_str());
+			cemuLog_log(LogType::Force, "config load error: can't load recently launched game file: {}", path);
 		}
 	}
 	
@@ -121,14 +111,13 @@ void CemuConfig::Load(XMLConfigParser& parser)
 		const std::string path = element.value("");
 		if (path.empty())
 			continue;
-
 		try
 		{
-			recent_nfc_files.emplace_back(boost::nowide::widen(path));
+			recent_nfc_files.emplace_back(path);
 		}
 		catch (const std::exception&)
 		{
-			forceLog_printf("config load error: can't load recently launched nfc file: %s", path.c_str());
+			cemuLog_log(LogType::Force, "config load error: can't load recently launched nfc file: {}", path);
 		}
 	}
 
@@ -139,14 +128,13 @@ void CemuConfig::Load(XMLConfigParser& parser)
 		const std::string path = element.value("");
 		if (path.empty())
 			continue;
-
 		try
 		{
-			game_paths.emplace_back(boost::nowide::widen(path));
+			game_paths.emplace_back(path);
 		}
 		catch (const std::exception&)
 		{
-			forceLog_printf("config load error: can't load game path: %s", path.c_str());
+			cemuLog_log(LogType::Force, "config load error: can't load game path: {}", path);
 		}
 	}
 
@@ -182,7 +170,7 @@ void CemuConfig::Load(XMLConfigParser& parser)
 		}
 		catch (const std::exception&)
 		{
-			forceLog_printf("config load error: can't load game cache entry: %s", rpx);
+			cemuLog_log(LogType::Force, "config load error: can't load game cache entry: {}", rpx);
 		}
 	}
 	_lock.unlock();
@@ -286,8 +274,11 @@ void CemuConfig::Load(XMLConfigParser& parser)
 	audio_delay = audio.get("delay", 2);
 	tv_channels = audio.get("TVChannels", kStereo);
 	pad_channels = audio.get("PadChannels", kStereo);
+	input_channels = audio.get("InputChannels", kMono);
 	tv_volume = audio.get("TVVolume", 20);
 	pad_volume = audio.get("PadVolume", 0);
+	input_volume = audio.get("InputVolume", 20);
+	portal_volume = audio.get("PortalVolume", 20);
 
 	const auto tv = audio.get("TVDevice", "");
 	try
@@ -296,7 +287,7 @@ void CemuConfig::Load(XMLConfigParser& parser)
 	}
 	catch (const std::exception&)
 	{
-		forceLog_printf("config load error: can't load tv device: %s", tv);
+		cemuLog_log(LogType::Force, "config load error: can't load tv device: {}", tv);
 	}
 
 	const auto pad = audio.get("PadDevice", "");
@@ -306,23 +297,68 @@ void CemuConfig::Load(XMLConfigParser& parser)
 	}
 	catch (const std::exception&)
 	{
-		forceLog_printf("config load error: can't load pad device: %s", pad);
+		cemuLog_log(LogType::Force, "config load error: can't load pad device: {}", pad);
+	}
+
+	const auto input_device_name = audio.get("InputDevice", "");
+	try
+	{
+		input_device = boost::nowide::widen(input_device_name);
+	}
+	catch (const std::exception&)
+	{
+		cemuLog_log(LogType::Force, "config load error: can't load input device: {}", input_device_name);
+	}
+
+	const auto portal_device_name = audio.get("PortalDevice", "");
+	try
+	{
+		portal_device = boost::nowide::widen(portal_device_name);
+	}
+	catch (const std::exception&)
+	{
+		cemuLog_log(LogType::Force, "config load error: can't load input device: {}", portal_device_name);
 	}
 
 	// account
 	auto acc = parser.get("Account");
 	account.m_persistent_id = acc.get("PersistentId", account.m_persistent_id);
-	account.online_enabled = acc.get("OnlineEnabled", account.online_enabled);
-
+	// legacy online settings, we only parse these for upgrading purposes
+	account.legacy_online_enabled = acc.get("OnlineEnabled", account.legacy_online_enabled);
+	account.legacy_active_service = acc.get("ActiveService",account.legacy_active_service);
+	// per-account online setting
+	auto accService = parser.get("AccountService");
+	account.service_select.clear();
+	for (auto element = accService.get("SelectedService"); element.valid(); element = accService.get("SelectedService", element))
+	{
+		uint32 persistentId = element.get_attribute<uint32>("PersistentId", 0);
+		sint32 serviceIndex = element.get_attribute<sint32>("Service", 0);
+		NetworkService networkService = static_cast<NetworkService>(serviceIndex);
+		if (persistentId < Account::kMinPersistendId)
+			continue;
+		if(networkService == NetworkService::Offline || networkService == NetworkService::Nintendo || networkService == NetworkService::Pretendo || networkService == NetworkService::Custom)
+			account.service_select.emplace(persistentId, networkService);
+	}
 	// debug
 	auto debug = parser.get("Debug");
-	crash_dump = debug.get("CrashDump", crash_dump);
+#if BOOST_OS_WINDOWS
+	crash_dump = debug.get("CrashDumpWindows", crash_dump);
+#elif BOOST_OS_UNIX
+	crash_dump = debug.get("CrashDumpUnix", crash_dump);
+#endif
+	gdb_port = debug.get("GDBPort", 1337);
 
 	// input
 	auto input = parser.get("Input");
 	auto dsuc = input.get("DSUC");
 	dsu_client.host = dsuc.get_attribute("host", dsu_client.host);
 	dsu_client.port = dsuc.get_attribute("port", dsu_client.port);
+
+	// emulatedusbdevices
+	auto usbdevices = parser.get("EmulatedUsbDevices");
+	emulated_usb_devices.emulate_skylander_portal = usbdevices.get("EmulateSkylanderPortal", emulated_usb_devices.emulate_skylander_portal);
+	emulated_usb_devices.emulate_infinity_base = usbdevices.get("EmulateInfinityBase", emulated_usb_devices.emulate_infinity_base);
+	emulated_usb_devices.emulate_dimensions_toypad = usbdevices.get("EmulateDimensionsToypad", emulated_usb_devices.emulate_dimensions_toypad);
 }
 
 void CemuConfig::Save(XMLConfigParser& parser)
@@ -331,18 +367,23 @@ void CemuConfig::Save(XMLConfigParser& parser)
 	// general settings
 	config.set("logflag", log_flag.GetValue());
 	config.set("advanced_ppc_logging", advanced_ppc_logging.GetValue());
-	config.set("mlc_path", boost::nowide::narrow(mlc_path.GetValue()).c_str());
+	config.set("mlc_path", mlc_path.GetValue().c_str());
 	config.set<bool>("permanent_storage", permanent_storage);
 	config.set<sint32>("language", language);
 	config.set<bool>("use_discord_presence", use_discord_presence);
 	config.set<bool>("fullscreen_menubar", fullscreen_menubar);
+    	config.set<bool>("feral_gamemode", feral_gamemode);
 	config.set<bool>("check_update", check_update);
+	config.set<bool>("receive_untested_updates", receive_untested_updates);
 	config.set<bool>("save_screenshot", save_screenshot);
 	config.set<bool>("vk_warning", did_show_vulkan_warning);
 	config.set<bool>("gp_download", did_show_graphic_pack_download);
+	config.set<bool>("macos_disclaimer", did_show_macos_disclaimer);
 	config.set<bool>("fullscreen", fullscreen);
 	config.set("proxy_server", proxy_server.GetValue().c_str());
-	
+	config.set<bool>("disable_screensaver", disable_screensaver);
+	config.set<bool>("play_boot_sound", play_boot_sound);
+
 	// config.set("cpu_mode", cpu_mode.GetValue());
 	//config.set("console_region", console_region.GetValue());
 	config.set("console_language", console_language.GetValue());
@@ -363,6 +404,7 @@ void CemuConfig::Save(XMLConfigParser& parser)
 	psize.set<sint32>("x", pad_size.x);
 	psize.set<sint32>("y", pad_size.y);
 	config.set<bool>("pad_maximized", pad_maximized);
+	config.set<bool>("show_icon_column" , show_icon_column);
 
 	auto gamelist = config.set("GameList");
 	gamelist.set("style", game_list_style);
@@ -373,24 +415,25 @@ void CemuConfig::Save(XMLConfigParser& parser)
 	gamelist.set("game_time_width", column_width.game_time);
 	gamelist.set("game_started_width", column_width.game_started);
 	gamelist.set("region_width", column_width.region);
+    gamelist.set("title_id", column_width.title_id);
 
 	auto launch_files_parser = config.set("RecentLaunchFiles");
 	for (const auto& entry : recent_launch_files)
 	{
-		launch_files_parser.set("Entry", boost::nowide::narrow(entry).c_str());
+		launch_files_parser.set("Entry", entry.c_str());
 	}
 	
 	auto nfc_files_parser = config.set("RecentNFCFiles");
 	for (const auto& entry : recent_nfc_files)
 	{
-		nfc_files_parser.set("Entry", boost::nowide::narrow(entry).c_str());
+		nfc_files_parser.set("Entry", entry.c_str());
 	}
 		
 	// game paths
 	auto game_path_parser = config.set("GamePaths");
 	for (const auto& entry : game_paths)
 	{
-		game_path_parser.set("Entry", boost::nowide::narrow(entry).c_str());
+		game_path_parser.set("Entry", entry.c_str());
 	}
 
 	// game list cache
@@ -475,25 +518,50 @@ void CemuConfig::Save(XMLConfigParser& parser)
 	audio.set("delay", audio_delay);
 	audio.set("TVChannels", tv_channels);
 	audio.set("PadChannels", pad_channels);
+	audio.set("InputChannels", input_channels);
 	audio.set("TVVolume", tv_volume);
 	audio.set("PadVolume", pad_volume);
+	audio.set("InputVolume", input_volume);
+	audio.set("PortalVolume", portal_volume);
 	audio.set("TVDevice", boost::nowide::narrow(tv_device).c_str());
 	audio.set("PadDevice", boost::nowide::narrow(pad_device).c_str());
+	audio.set("InputDevice", boost::nowide::narrow(input_device).c_str());
+	audio.set("PortalDevice", boost::nowide::narrow(portal_device).c_str());
 
 	// account
 	auto acc = config.set("Account");
 	acc.set("PersistentId", account.m_persistent_id.GetValue());
-	acc.set("OnlineEnabled", account.online_enabled.GetValue());
-
+	// legacy online mode setting
+	acc.set("OnlineEnabled", account.legacy_online_enabled.GetValue());
+	acc.set("ActiveService",account.legacy_active_service.GetValue());
+	// per-account online setting
+	auto accService = config.set("AccountService");
+	for(auto& it : account.service_select)
+	{
+		auto entry = accService.set("SelectedService");
+		entry.set_attribute("PersistentId", it.first);
+		entry.set_attribute("Service", static_cast<sint32>(it.second));
+	}
 	// debug
 	auto debug = config.set("Debug");
-	debug.set("CrashDump", crash_dump.GetValue());
+#if BOOST_OS_WINDOWS
+	debug.set("CrashDumpWindows", crash_dump.GetValue());
+#elif BOOST_OS_UNIX
+	debug.set("CrashDumpUnix", crash_dump.GetValue());
+#endif
+	debug.set("GDBPort", gdb_port);
 
 	// input
 	auto input = config.set("Input");
 	auto dsuc = input.set("DSUC");
 	dsuc.set_attribute("host", dsu_client.host);
 	dsuc.set_attribute("port", dsu_client.port);
+
+	// emulated usb devices
+	auto usbdevices = config.set("EmulatedUsbDevices");
+	usbdevices.set("EmulateSkylanderPortal", emulated_usb_devices.emulate_skylander_portal.GetValue());
+	usbdevices.set("EmulateInfinityBase", emulated_usb_devices.emulate_infinity_base.GetValue());
+	usbdevices.set("EmulateDimensionsToypad", emulated_usb_devices.emulate_dimensions_toypad.GetValue());
 }
 
 GameEntry* CemuConfig::GetGameEntryByTitleId(uint64 titleId)
@@ -557,25 +625,48 @@ void CemuConfig::SetGameListCustomName(uint64 titleId, std::string customName)
 			return;
 		gameEntry = CreateGameEntry(titleId);
 	}
-	gameEntry->custom_name = customName;
+	gameEntry->custom_name = std::move(customName);
 }
 
-void CemuConfig::AddRecentlyLaunchedFile(std::wstring_view file)
+void CemuConfig::AddRecentlyLaunchedFile(std::string_view file)
 {
-	// insert into front
-	recent_launch_files.insert(recent_launch_files.begin(), std::wstring{ file });
+	recent_launch_files.insert(recent_launch_files.begin(), std::string(file));
 	RemoveDuplicatesKeepOrder(recent_launch_files);
-	// keep maximum of entries
 	while(recent_launch_files.size() > kMaxRecentEntries)
 		recent_launch_files.pop_back();
 }
 
-void CemuConfig::AddRecentNfcFile(std::wstring_view file)
+void CemuConfig::AddRecentNfcFile(std::string_view file)
 {
-	// insert into front
-	recent_nfc_files.insert(recent_nfc_files.begin(), std::wstring{ file });
+	recent_nfc_files.insert(recent_nfc_files.begin(), std::string(file));
 	RemoveDuplicatesKeepOrder(recent_nfc_files);
-	// keep maximum of entries
 	while (recent_nfc_files.size() > kMaxRecentEntries)
 		recent_nfc_files.pop_back();
 }
+
+NetworkService CemuConfig::GetAccountNetworkService(uint32 persistentId)
+{
+	auto it = account.service_select.find(persistentId);
+	if (it != account.service_select.end())
+	{
+		NetworkService serviceIndex = it->second;
+		// make sure the returned service is valid
+		if (serviceIndex != NetworkService::Offline &&
+			serviceIndex != NetworkService::Nintendo &&
+			serviceIndex != NetworkService::Pretendo &&
+			serviceIndex != NetworkService::Custom)
+			return NetworkService::Offline;
+		if( static_cast<NetworkService>(serviceIndex) == NetworkService::Custom && !NetworkConfig::XMLExists() )
+			return NetworkService::Offline; // custom is selected but no custom config exists
+		return serviceIndex;
+	}
+	// if not found, return the legacy value
+	if(!account.legacy_online_enabled)
+		return NetworkService::Offline;
+	return static_cast<NetworkService>(account.legacy_active_service.GetValue() + 1); // +1 because "Offline" now takes index 0
+}
+
+void CemuConfig::SetAccountSelectedService(uint32 persistentId, NetworkService serviceIndex)
+{
+	account.service_select[persistentId] = serviceIndex;
+}
diff --git a/src/config/CemuConfig.h b/src/config/CemuConfig.h
index 8c43f0a5..ca896eed 100644
--- a/src/config/CemuConfig.h
+++ b/src/config/CemuConfig.h
@@ -6,6 +6,9 @@
 #include "Cafe/Account/Account.h"
 
 #include <wx/language.h>
+#include <wx/intl.h>
+
+enum class NetworkService;
 
 struct GameEntry
 {
@@ -115,11 +118,10 @@ ENABLE_ENUM_ITERATORS(PrecompiledShaderOption, PrecompiledShaderOption::Auto, Pr
 
 enum class AccurateShaderMulOption
 {
-	False = 0, // ignore non-ieee MUL special cases
-	True = 1, // fully emulate non-ieee MUL special cases
-	Min = 2, // similar to true, but avoids conditionals (instead relies on min() and abs())
+	False = 0, // always use standard multiplication
+	True = 1 // fully emulate non-ieee MUL special cases (0*anything = 0)
 };
-ENABLE_ENUM_ITERATORS(AccurateShaderMulOption, AccurateShaderMulOption::False, AccurateShaderMulOption::Min);
+ENABLE_ENUM_ITERATORS(AccurateShaderMulOption, AccurateShaderMulOption::False, AccurateShaderMulOption::True);
 
 enum class CPUMode
 {
@@ -172,6 +174,7 @@ enum class CafeConsoleLanguage
 };
 ENABLE_ENUM_ITERATORS(CafeConsoleLanguage, CafeConsoleLanguage::JA, CafeConsoleLanguage::TW);
 
+#if BOOST_OS_WINDOWS
 enum class CrashDump
 {
 	Disabled,
@@ -179,11 +182,19 @@ enum class CrashDump
 	Full
 };
 ENABLE_ENUM_ITERATORS(CrashDump, CrashDump::Disabled, CrashDump::Full);
+#elif BOOST_OS_UNIX
+enum class CrashDump
+{
+	Disabled,
+	Enabled
+};
+ENABLE_ENUM_ITERATORS(CrashDump, CrashDump::Disabled, CrashDump::Enabled);
+#endif
 
 template <>
 struct fmt::formatter<PrecompiledShaderOption> : formatter<string_view> {
 	template <typename FormatContext>
-	auto format(const PrecompiledShaderOption c, FormatContext &ctx) {
+	auto format(const PrecompiledShaderOption c, FormatContext &ctx) const {
 		string_view name;
 		switch (c)
 		{
@@ -198,13 +209,12 @@ struct fmt::formatter<PrecompiledShaderOption> : formatter<string_view> {
 template <>
 struct fmt::formatter<AccurateShaderMulOption> : formatter<string_view> {
 	template <typename FormatContext>
-	auto format(const AccurateShaderMulOption c, FormatContext &ctx) {
+	auto format(const AccurateShaderMulOption c, FormatContext &ctx) const {
 		string_view name;
 		switch (c)
 		{
 		case AccurateShaderMulOption::True: name = "true"; break;
 		case AccurateShaderMulOption::False: name = "false"; break;
-		case AccurateShaderMulOption::Min: name = "min"; break;
 		default: name = "unknown"; break;
 		}
 		return formatter<string_view>::format(name, ctx);
@@ -213,7 +223,7 @@ struct fmt::formatter<AccurateShaderMulOption> : formatter<string_view> {
 template <>
 struct fmt::formatter<CPUMode> : formatter<string_view> {
 	template <typename FormatContext>
-	auto format(const CPUMode c, FormatContext &ctx) {
+	auto format(const CPUMode c, FormatContext &ctx) const {
 		string_view name;
 		switch (c)
 		{
@@ -230,7 +240,7 @@ struct fmt::formatter<CPUMode> : formatter<string_view> {
 template <>
 struct fmt::formatter<CPUModeLegacy> : formatter<string_view> {
 	template <typename FormatContext>
-	auto format(const CPUModeLegacy c, FormatContext &ctx) {
+	auto format(const CPUModeLegacy c, FormatContext &ctx) const {
 		string_view name;
 		switch (c)
 		{
@@ -247,19 +257,19 @@ struct fmt::formatter<CPUModeLegacy> : formatter<string_view> {
 template <>
 struct fmt::formatter<CafeConsoleRegion> : formatter<string_view> {
 	template <typename FormatContext>
-	auto format(const CafeConsoleRegion v, FormatContext &ctx) {
+	auto format(const CafeConsoleRegion v, FormatContext &ctx) const {
 		string_view name;
 		switch (v)
 		{
-		case CafeConsoleRegion::JPN: name = "Japan"; break;
-		case CafeConsoleRegion::USA: name = "USA"; break;
-		case CafeConsoleRegion::EUR: name = "Europe"; break;
-		case CafeConsoleRegion::AUS_DEPR: name = "Australia"; break;
-		case CafeConsoleRegion::CHN: name = "China"; break;
-		case CafeConsoleRegion::KOR: name = "Korea"; break;
-		case CafeConsoleRegion::TWN: name = "Taiwan"; break;
-		case CafeConsoleRegion::Auto: name = "Auto"; break;
-		default: name = "many"; break;
+		case CafeConsoleRegion::JPN: name = wxTRANSLATE("Japan"); break;
+		case CafeConsoleRegion::USA: name = wxTRANSLATE("USA"); break;
+		case CafeConsoleRegion::EUR: name = wxTRANSLATE("Europe"); break;
+		case CafeConsoleRegion::AUS_DEPR: name = wxTRANSLATE("Australia"); break;
+		case CafeConsoleRegion::CHN: name = wxTRANSLATE("China"); break;
+		case CafeConsoleRegion::KOR: name = wxTRANSLATE("Korea"); break;
+		case CafeConsoleRegion::TWN: name = wxTRANSLATE("Taiwan"); break;
+		case CafeConsoleRegion::Auto: name = wxTRANSLATE("Auto"); break;
+		default: name = wxTRANSLATE("many"); break;
 		
 		}
 		return formatter<string_view>::format(name, ctx);
@@ -290,6 +300,7 @@ struct fmt::formatter<CafeConsoleLanguage> : formatter<string_view> {
 	}
 };
 
+#if BOOST_OS_WINDOWS
 template <>
 struct fmt::formatter<CrashDump> : formatter<string_view> {
 	template <typename FormatContext>
@@ -306,7 +317,35 @@ struct fmt::formatter<CrashDump> : formatter<string_view> {
 		return formatter<string_view>::format(name, ctx);
 	}
 };
+#elif BOOST_OS_UNIX
+template <>
+struct fmt::formatter<CrashDump> : formatter<string_view> {
+	template <typename FormatContext>
+	auto format(const CrashDump v, FormatContext &ctx) {
+		string_view name;
+		switch (v)
+		{
+		case CrashDump::Disabled: name = "Disabled"; break;
+		case CrashDump::Enabled: name = "Enabled"; break;
+		default: name = "unknown"; break;
 
+		}
+		return formatter<string_view>::format(name, ctx);
+	}
+};
+#endif
+
+namespace DefaultColumnSize {
+	enum : uint32 {
+		name = 500u,
+		version = 60u,
+		dlc = 50u,
+		game_time = 140u,
+		game_started = 160u,
+		region = 80u,
+        title_id = 160u
+	};
+};
 
 struct CemuConfig
 {
@@ -316,10 +355,9 @@ struct CemuConfig
 	};
 
 	CemuConfig(const CemuConfig&) = delete;
-	//
 
 	// sets mlc path, updates permanent config value, saves config
-	void SetMLCPath(std::wstring_view path, bool save = true);
+	void SetMLCPath(fs::path path, bool save = true);
 
 	ConfigValue<uint64> log_flag{ 0 };
 	ConfigValue<bool> advanced_ppc_logging{ false };
@@ -328,12 +366,23 @@ struct CemuConfig
 	
 	ConfigValue<sint32> language{ wxLANGUAGE_DEFAULT };
 	ConfigValue<bool> use_discord_presence{ true };
-	ConfigValue<std::wstring> mlc_path {};
+	ConfigValue<std::string> mlc_path{};
 	ConfigValue<bool> fullscreen_menubar{ false };
 	ConfigValue<bool> fullscreen{ false };
+	ConfigValue<bool> feral_gamemode{false};
 	ConfigValue<std::string> proxy_server{};
 
-	std::vector<std::wstring> game_paths;
+	// temporary workaround because feature crashes on macOS
+#if BOOST_OS_MACOS
+#define DISABLE_SCREENSAVER_DEFAULT false
+#else
+#define DISABLE_SCREENSAVER_DEFAULT true
+#endif
+	ConfigValue<bool> disable_screensaver{DISABLE_SCREENSAVER_DEFAULT};
+#undef DISABLE_SCREENSAVER_DEFAULT
+	ConfigValue<bool> play_boot_sound{false};
+
+	std::vector<std::string> game_paths;
 	std::mutex game_cache_entries_mutex;
 	std::vector<GameEntry> game_cache_entries;
 
@@ -353,8 +402,8 @@ struct CemuConfig
 
 	// max 15 entries
 	static constexpr size_t kMaxRecentEntries = 15;
-	std::vector<std::wstring> recent_launch_files;
-	std::vector<std::wstring> recent_nfc_files;
+	std::vector<std::string> recent_launch_files;
+	std::vector<std::string> recent_nfc_files;
 
 	Vector2i window_position{-1,-1};
 	Vector2i window_size{ -1,-1 };
@@ -365,17 +414,27 @@ struct CemuConfig
 	Vector2i pad_size{ -1,-1 };
 	ConfigValue<bool> pad_maximized;
 
-	ConfigValue<bool> check_update{false};
+	ConfigValue<bool> check_update{true};
+	ConfigValue<bool> receive_untested_updates{false};
 	ConfigValue<bool> save_screenshot{true};
 
 	ConfigValue<bool> did_show_vulkan_warning{false};
-	ConfigValue<bool> did_show_graphic_pack_download{false};
+	ConfigValue<bool> did_show_graphic_pack_download{false}; // no longer used but we keep the config value around in case people downgrade Cemu. Despite the name this was used for the Getting Started dialog
+	ConfigValue<bool> did_show_macos_disclaimer{false};
+
+	ConfigValue<bool> show_icon_column{ true };
 
 	int game_list_style = 0;
 	std::string game_list_column_order;
 	struct
 	{
-		int name = -3, version = -3, dlc = -3, game_time = -3, game_started = -3, region = -3;
+		uint32 name = DefaultColumnSize::name;
+		uint32 version = DefaultColumnSize::version;
+		uint32 dlc = DefaultColumnSize::dlc;
+		uint32 game_time = DefaultColumnSize::game_time;
+		uint32 game_started = DefaultColumnSize::game_started;
+		uint32 region = DefaultColumnSize::region;
+        uint32 title_id = 0;
 	} column_width{};
 
 	// graphics
@@ -384,7 +443,7 @@ struct CemuConfig
 	ConfigValue<int> vsync{ 0 }; // 0 = off, 1+ = on depending on render backend
 	ConfigValue<bool> gx2drawdone_sync {true};
 	ConfigValue<bool> render_upside_down{ false };
-	ConfigValue<bool> async_compile{ false };
+	ConfigValue<bool> async_compile{ true };
 
 	ConfigValue<bool> vk_accurate_barriers{ true };
 
@@ -420,15 +479,17 @@ struct CemuConfig
 	// audio
 	sint32 audio_api = 0;
 	sint32 audio_delay = 2;
-	AudioChannels tv_channels = kStereo, pad_channels = kStereo;
-	sint32 tv_volume = 50, pad_volume = 0;
-	std::wstring tv_device{ L"default" }, pad_device;
+	AudioChannels tv_channels = kStereo, pad_channels = kStereo, input_channels = kMono;
+	sint32 tv_volume = 50, pad_volume = 0, input_volume = 50, portal_volume = 50;
+	std::wstring tv_device{ L"default" }, pad_device, input_device, portal_device;
 
 	// account
 	struct
 	{
 		ConfigValueBounds<uint32> m_persistent_id{ Account::kMinPersistendId, Account::kMinPersistendId, 0xFFFFFFFF };
-		ConfigValue<bool> online_enabled{false};
+		ConfigValue<bool> legacy_online_enabled{false};
+		ConfigValue<int> legacy_active_service{0};
+		std::unordered_map<uint32, NetworkService> service_select; // per-account service index. Key is persistentId
 	}account{};
 
 	// input
@@ -440,19 +501,44 @@ struct CemuConfig
 
 	// debug
 	ConfigValueBounds<CrashDump> crash_dump{ CrashDump::Disabled };
+	ConfigValue<uint16> gdb_port{ 1337 };
 
 	void Load(XMLConfigParser& parser);
 	void Save(XMLConfigParser& parser);
 
-	void AddRecentlyLaunchedFile(std::wstring_view file);
-	void AddRecentNfcFile(std::wstring_view file);
+	void AddRecentlyLaunchedFile(std::string_view file);
+	void AddRecentNfcFile(std::string_view file);
 
 	bool IsGameListFavorite(uint64 titleId);
 	void SetGameListFavorite(uint64 titleId, bool isFavorite);
 	bool GetGameListCustomName(uint64 titleId, std::string& customName);
 	void SetGameListCustomName(uint64 titleId, std::string customName);
 
-	private:
+	NetworkService GetAccountNetworkService(uint32 persistentId);
+	void SetAccountSelectedService(uint32 persistentId, NetworkService serviceIndex);
+	
+	// emulated usb devices
+	struct
+	{
+		ConfigValue<bool> emulate_skylander_portal{false};
+		ConfigValue<bool> emulate_infinity_base{false};
+		ConfigValue<bool> emulate_dimensions_toypad{false};
+	}emulated_usb_devices{};
+
+	static int AudioChannelsToNChannels(AudioChannels kStereo)
+	{
+		switch (kStereo)
+		{
+		case 0:
+			return 1; // will mix mono sound on both output channels
+		case 2:
+			return 6;
+		default: // stereo
+			return 2;
+		}
+	}
+
+  private:
 	GameEntry* GetGameEntryByTitleId(uint64 titleId);
 	GameEntry* CreateGameEntry(uint64 titleId);
 };
diff --git a/src/config/ConfigValue.h b/src/config/ConfigValue.h
index 11fc1e48..43e2ad3b 100644
--- a/src/config/ConfigValue.h
+++ b/src/config/ConfigValue.h
@@ -39,7 +39,7 @@ public:
 		return *this;
 	}
 
-	[[nodiscard]] TType GetValue() const { return m_value.load(); }
+	[[nodiscard]] inline TType GetValue() const { return m_value.load(); }
 	void SetValue(const TType& v) { m_value = v; }
 
 	[[nodiscard]] const TType& GetInitValue() const { return m_init_value; }
@@ -232,19 +232,3 @@ private:
 	const TType m_min_value;
 	const TType m_max_value;
 };
-
-template <typename TType>
-struct fmt::formatter< ConfigValue<TType> > : formatter<TType> {
-	template <typename FormatContext>
-	auto format(const ConfigValue<TType>& v, FormatContext& ctx) {
-		return formatter<TType>::format(v.GetValue(), ctx);
-	}
-};
-
-template <typename TType>
-struct fmt::formatter< ConfigValueBounds<TType> > : formatter<TType> {
-	template <typename FormatContext>
-	auto format(const ConfigValueBounds<TType>& v, FormatContext& ctx) {
-		return formatter<TType>::format(v.GetValue(), ctx);
-	}
-};
\ No newline at end of file
diff --git a/src/config/LaunchSettings.cpp b/src/config/LaunchSettings.cpp
index 7d7c0c98..fde20539 100644
--- a/src/config/LaunchSettings.cpp
+++ b/src/config/LaunchSettings.cpp
@@ -9,9 +9,11 @@
 #include <wx/msgdlg.h>
 
 #include "config/ActiveSettings.h"
+#include "config/NetworkSettings.h"
 #include "util/crypto/aes128.h"
 
 #include "Cafe/Filesystem/FST/FST.h"
+#include "util/helpers/StringHelpers.h"
 
 void requireConsole();
 
@@ -57,8 +59,12 @@ bool LaunchSettings::HandleCommandline(const std::vector<std::wstring>& args)
 	desc.add_options()
 		("help,h", "This help screen")
 		("version,v", "Displays the version of Cemu")
+#if !BOOST_OS_WINDOWS
+		("verbose", "Log to stdout")
+#endif
 
 		("game,g", po::wvalue<std::wstring>(), "Path of game to launch")
+        ("title-id,t", po::value<std::string>(), "Title ID of the title to be launched (overridden by --game)")
 		("mlc,m", po::wvalue<std::wstring>(), "Custom mlc folder location")
 
 		("fullscreen,f", po::value<bool>()->implicit_value(true), "Launch games in fullscreen mode")
@@ -66,16 +72,16 @@ bool LaunchSettings::HandleCommandline(const std::vector<std::wstring>& args)
 
 		("account,a", po::value<std::string>(), "Persistent id of account")
 
-		("force-interpreter", po::value<bool>()->implicit_value(true), "Force interpreter CPU emulation, disables recompiler")
-
-		("act-url", po::value<std::string>(), "URL prefix for account server")
-		("ecs-url", po::value<std::string>(), "URL for ECS service");
-
+		("force-interpreter", po::value<bool>()->implicit_value(true), "Force interpreter CPU emulation, disables recompiler. Useful for debugging purposes where you want to get accurate memory accesses and stack traces.")
+		("force-multicore-interpreter", po::value<bool>()->implicit_value(true), "Force multi-core interpreter CPU emulation, disables recompiler. Only useful for getting stack traces, but slightly faster than the single-core interpreter mode.")
+		("enable-gdbstub", po::value<bool>()->implicit_value(true), "Enable GDB stub to debug executables inside Cemu using an external debugger");
 
 	po::options_description hidden{ "Hidden options" };
 	hidden.add_options()
 		("nsight", po::value<bool>()->implicit_value(true), "NSight debugging options")
-		("legacy", po::value<bool>()->implicit_value(true), "Intel legacy graphic mode");
+		("legacy", po::value<bool>()->implicit_value(true), "Intel legacy graphic mode")
+		("ppcrec-lower-addr", po::value<std::string>(), "For debugging: Lower address allowed for PPC recompilation")
+		("ppcrec-upper-addr", po::value<std::string>(), "For debugging: Upper address allowed for PPC recompilation");
 
 	po::options_description extractor{ "Extractor tool" };
 	extractor.add_options()
@@ -113,15 +119,18 @@ bool LaunchSettings::HandleCommandline(const std::vector<std::wstring>& args)
 		{
 			requireConsole();
 			std::string versionStr;
-#if EMULATOR_VERSION_MINOR == 0
-			versionStr = fmt::format("{}.{}{}", EMULATOR_VERSION_LEAD, EMULATOR_VERSION_MAJOR, EMULATOR_VERSION_SUFFIX);
+#if EMULATOR_VERSION_PATCH == 0
+			versionStr = fmt::format("{}.{}{}", EMULATOR_VERSION_MAJOR, EMULATOR_VERSION_MINOR, EMULATOR_VERSION_SUFFIX);
 #else
-			versionStr = fmt::format("{}.{}-{}{}", EMULATOR_VERSION_LEAD, EMULATOR_VERSION_MAJOR, EMULATOR_VERSION_MINOR, EMULATOR_VERSION_SUFFIX);
+			versionStr = fmt::format("{}.{}-{}{}", EMULATOR_VERSION_MAJOR, EMULATOR_VERSION_MINOR, EMULATOR_VERSION_PATCH, EMULATOR_VERSION_SUFFIX);
 #endif
 			std::cout << versionStr << std::endl;
 			return false; // exit in main
 		}
 
+		if (vm.count("verbose"))
+			s_verbose = true;
+
 		if (vm.count("game"))
 		{
 			std::wstring tmp = vm["game"].as<std::wstring>();
@@ -131,6 +140,21 @@ bool LaunchSettings::HandleCommandline(const std::vector<std::wstring>& args)
 			
 			s_load_game_file = tmp;
 		}
+        if (vm.count("title-id"))
+        {
+            auto title_param = vm["title-id"].as<std::string>();
+            try {
+
+                if (title_param.starts_with('=')){
+                    title_param.erase(title_param.begin());
+                }
+                s_load_title_id = std::stoull(title_param, nullptr, 16);
+            }
+            catch (std::invalid_argument const& e)
+            {
+                std::cerr << "Expected title_param ID as an unsigned 64-bit hexadecimal string\n";
+            }
+        }
 			
 		if (vm.count("mlc"))
 		{
@@ -156,12 +180,16 @@ bool LaunchSettings::HandleCommandline(const std::vector<std::wstring>& args)
 		
 		if (vm.count("nsight"))
 			s_nsight_mode = vm["nsight"].as<bool>();
-		if (vm.count("legacy"))
-			s_force_intel_legacy = vm["legacy"].as<bool>();
 
 		if(vm.count("force-interpreter"))
 			s_force_interpreter = vm["force-interpreter"].as<bool>();
 
+		if(vm.count("force-multicore-interpreter"))
+			s_force_multicore_interpreter = vm["force-multicore-interpreter"].as<bool>();
+		
+		if (vm.count("enable-gdbstub"))
+			s_enable_gdbstub = vm["enable-gdbstub"].as<bool>();
+
 		std::wstring extract_path, log_path;
 		std::string output_path;
 		if (vm.count("extract"))
@@ -171,15 +199,19 @@ bool LaunchSettings::HandleCommandline(const std::vector<std::wstring>& args)
 		if (vm.count("output"))
 			log_path = vm["output"].as<std::wstring>();
 
-		// urls
-		if (vm.count("act-url"))
+		// recompiler range limit for debugging
+		if (vm.count("ppcrec-lower-addr"))
 		{
-			serviceURL_ACT = vm["act-url"].as<std::string>();
-			if (serviceURL_ACT.size() > 0 && serviceURL_ACT.back() == '/')
-				serviceURL_ACT.pop_back();
+			uint32 addr = (uint32)StringHelpers::ToInt64(vm["ppcrec-lower-addr"].as<std::string>());
+			ppcRec_limitLowerAddr = addr;
 		}
-		if (vm.count("ecs-url"))
-			serviceURL_ECS = vm["ecs-url"].as<std::string>();
+		if (vm.count("ppcrec-upper-addr"))
+		{
+			uint32 addr = (uint32)StringHelpers::ToInt64(vm["ppcrec-upper-addr"].as<std::string>());
+			ppcRec_limitUpperAddr = addr;
+		}
+		if(ppcRec_limitLowerAddr != 0 && ppcRec_limitUpperAddr != 0)
+			cemuLog_log(LogType::Force, "PPCRec range limited to 0x{:08x}-0x{:08x}", ppcRec_limitLowerAddr, ppcRec_limitUpperAddr);
 
 		if(!extract_path.empty())
 		{
@@ -194,9 +226,11 @@ bool LaunchSettings::HandleCommandline(const std::vector<std::wstring>& args)
 		std::string errorMsg;
 		errorMsg.append("Error while trying to parse command line parameter:\n");
 		errorMsg.append(ex.what());
-		wxMessageBox(errorMsg, wxT("Parameter error"), wxICON_ERROR);
-		//cemuLog_log(LogType::Force, ex.what());
-		//std::cout << "Command line parameter error: " << ex.what() << std::endl;
+#if BOOST_OS_WINDOWS
+		wxMessageBox(errorMsg, "Parameter error", wxICON_ERROR);
+#else
+		std::cout << errorMsg << std::endl;
+#endif
 		return false;
 	}
 	
@@ -249,7 +283,7 @@ bool LaunchSettings::ExtractorTool(std::wstring_view wud_path, std::string_view
 		}
 		catch (const std::exception& ex)
 		{
-			forceLog_printf("can't write file: %s", ex.what());
+			cemuLog_log(LogType::Force, "can't write file: {}", ex.what());
 			puts(fmt::format("can't write file: %s\n", ex.what()).c_str());
 		}
 	}
@@ -263,5 +297,3 @@ bool LaunchSettings::ExtractorTool(std::wstring_view wud_path, std::string_view
 	
 	return true;
 }
-
-
diff --git a/src/config/LaunchSettings.h b/src/config/LaunchSettings.h
index 299dd72c..13665cb7 100644
--- a/src/config/LaunchSettings.h
+++ b/src/config/LaunchSettings.h
@@ -16,40 +16,46 @@ public:
 	static bool HandleCommandline(const std::vector<std::wstring>& args);
 
 	static std::optional<fs::path> GetLoadFile() { return s_load_game_file; }
+    static std::optional<uint64> GetLoadTitleID() {return s_load_title_id;}
 	static std::optional<fs::path> GetMLCPath() { return s_mlc_path; }
 
 	static std::optional<bool> RenderUpsideDownEnabled() { return s_render_upside_down; }
 	static std::optional<bool> FullscreenEnabled() { return s_fullscreen; }
 
+	static bool Verbose() { return s_verbose; }
+
+	static bool GDBStubEnabled() { return s_enable_gdbstub; }
 	static bool NSightModeEnabled() { return s_nsight_mode; }
-	static bool ForceIntelLegacyEnabled() { return s_force_intel_legacy; }
 
 	static bool ForceInterpreter() { return s_force_interpreter; };
+	static bool ForceMultiCoreInterpreter() { return s_force_multicore_interpreter; }
 
 	static std::optional<uint32> GetPersistentId() { return s_persistent_id; }
 
-	static std::string GetActURLPrefix() { return serviceURL_ACT; }
-	static std::string GetServiceURL_ecs() { return serviceURL_ECS; }
+	static uint32 GetPPCRecLowerAddr() { return ppcRec_limitLowerAddr; };
+	static uint32 GetPPCRecUpperAddr() { return ppcRec_limitUpperAddr; };
 
 private:
 	inline static std::optional<fs::path> s_load_game_file{};
+    inline static std::optional<uint64> s_load_title_id{};
 	inline static std::optional<fs::path> s_mlc_path{};
 
 	inline static std::optional<bool> s_render_upside_down{};
 	inline static std::optional<bool> s_fullscreen{};
+
+	inline static bool s_verbose = false;
 	
+	inline static bool s_enable_gdbstub = false;
 	inline static bool s_nsight_mode = false;
-	inline static bool s_force_intel_legacy = false;
 
 	inline static bool s_force_interpreter = false;
+	inline static bool s_force_multicore_interpreter = false;
 	
 	inline static std::optional<uint32> s_persistent_id{};
 
-	// service URLS
-	inline static std::string serviceURL_ACT = "https://account.nintendo.net";
-	inline static std::string serviceURL_ECS = "https://ecs.wup.shop.nintendo.net/ecs/services/ECommerceSOAP";
-	// todo - npts and other boss urls
-
+	// for recompiler debugging
+	inline static uint32 ppcRec_limitLowerAddr{};
+	inline static uint32 ppcRec_limitUpperAddr{};
 
 	static bool ExtractorTool(std::wstring_view wud_path, std::string_view output_path, std::wstring_view log_path);
 };
diff --git a/src/config/NetworkSettings.cpp b/src/config/NetworkSettings.cpp
new file mode 100644
index 00000000..42dc9996
--- /dev/null
+++ b/src/config/NetworkSettings.cpp
@@ -0,0 +1,48 @@
+#include "NetworkSettings.h"
+#include "ActiveSettings.h"
+#include "LaunchSettings.h"
+#include "CemuConfig.h"
+#include "Common/FileStream.h"
+
+XMLNetworkConfig_t n_config(L"network_services.xml");
+
+
+void NetworkConfig::LoadOnce() 
+{
+	n_config.SetFilename(ActiveSettings::GetConfigPath("network_services.xml").generic_wstring());
+	if (XMLExists())
+		n_config.Load();
+}
+
+void NetworkConfig::Load(XMLConfigParser& parser) 
+{
+	auto config = parser.get("content");
+	networkname = config.get("networkname", "Custom");
+	disablesslver = config.get("disablesslverification", disablesslver);
+	auto u = config.get("urls");
+	urls.ACT = u.get("act", NintendoURLs::ACTURL);
+	urls.ECS = u.get("ecs", NintendoURLs::ECSURL);
+	urls.NUS = u.get("nus", NintendoURLs::NUSURL);
+	urls.IAS = u.get("ias", NintendoURLs::IASURL);
+	urls.CCSU = u.get("ccsu", NintendoURLs::CCSUURL);
+	urls.CCS = u.get("ccs", NintendoURLs::CCSURL);
+	urls.IDBE = u.get("idbe", NintendoURLs::IDBEURL);
+	urls.BOSS = u.get("boss", NintendoURLs::BOSSURL);
+	urls.TAGAYA = u.get("tagaya", NintendoURLs::TAGAYAURL);
+	urls.OLV = u.get("olv", NintendoURLs::OLVURL);
+}
+
+bool NetworkConfig::XMLExists() 
+{
+	static std::optional<bool> s_exists; // caches result of fs::exists
+	if(s_exists.has_value())
+		return *s_exists;
+	std::error_code ec;
+	if (!fs::exists(ActiveSettings::GetConfigPath("network_services.xml"), ec))
+	{
+		s_exists = false;
+		return false;
+	}
+	s_exists = true;
+	return true;
+}
\ No newline at end of file
diff --git a/src/config/NetworkSettings.h b/src/config/NetworkSettings.h
new file mode 100644
index 00000000..6e114a0e
--- /dev/null
+++ b/src/config/NetworkSettings.h
@@ -0,0 +1,87 @@
+#pragma once
+
+#include "ConfigValue.h"
+#include "XMLConfig.h"
+
+enum class NetworkService
+{
+	Offline,
+	Nintendo,
+	Pretendo,
+	Custom,
+	COUNT = Custom
+};
+
+struct NetworkConfig
+{
+    NetworkConfig()
+	{
+
+	};
+
+	NetworkConfig(const NetworkConfig&) = delete;
+
+    ConfigValue<std::string> networkname;
+    ConfigValue<bool> disablesslver = false;
+    struct
+	{
+		 ConfigValue<std::string> ACT;
+		 ConfigValue<std::string> ECS;
+		 ConfigValue<std::string> NUS;
+		 ConfigValue<std::string> IAS;
+		 ConfigValue<std::string> CCSU;
+		 ConfigValue<std::string> CCS;
+		 ConfigValue<std::string> IDBE;
+		 ConfigValue<std::string> BOSS;
+		 ConfigValue<std::string> TAGAYA;
+		 ConfigValue<std::string> OLV;
+	}urls{};
+
+    public:
+    static void LoadOnce();
+    void Load(XMLConfigParser& parser);
+    void Save(XMLConfigParser& parser);
+    
+    static bool XMLExists();
+};
+
+struct NintendoURLs {
+   inline static std::string ACTURL = "https://account.nintendo.net";
+   inline static std::string ECSURL = "https://ecs.wup.shop.nintendo.net/ecs/services/ECommerceSOAP";
+   inline static std::string NUSURL = "https://nus.wup.shop.nintendo.net/nus/services/NetUpdateSOAP";
+   inline static std::string IASURL = "https://ias.wup.shop.nintendo.net/ias/services/IdentityAuthenticationSOAP";
+   inline static std::string CCSUURL = "https://ccs.wup.shop.nintendo.net/ccs/download";
+   inline static std::string CCSURL = "http://ccs.cdn.wup.shop.nintendo.net/ccs/download";
+   inline static std::string IDBEURL = "https://idbe-wup.cdn.nintendo.net/icondata";
+   inline static std::string BOSSURL = "https://npts.app.nintendo.net/p01/tasksheet";
+   inline static std::string TAGAYAURL = "https://tagaya.wup.shop.nintendo.net/tagaya/versionlist";
+   inline static std::string OLVURL = "https://discovery.olv.nintendo.net/v1/endpoint";
+};
+
+struct PretendoURLs {
+   inline static std::string ACTURL =  "https://account.pretendo.cc";
+   inline static std::string ECSURL = "https://ecs.wup.shop.pretendo.cc/ecs/services/ECommerceSOAP";
+   inline static std::string NUSURL = "https://nus.c.shop.pretendo.cc/nus/services/NetUpdateSOAP";
+   inline static std::string IASURL = "https://ias.c.shop.pretendo.cc/ias/services/IdentityAuthenticationSOAP";
+   inline static std::string CCSUURL = "https://ccs.c.shop.pretendo.cc/ccs/download";
+   inline static std::string CCSURL = "http://ccs.cdn.c.shop.pretendo.cc/ccs/download";
+   inline static std::string IDBEURL = "https://idbe-wup.cdn.pretendo.cc/icondata";
+   inline static std::string BOSSURL = "https://npts.app.pretendo.cc/p01/tasksheet";
+   inline static std::string TAGAYAURL = "https://tagaya.wup.shop.pretendo.cc/tagaya/versionlist";
+   inline static std::string OLVURL = "https://discovery.olv.pretendo.cc/v1/endpoint";
+};
+
+typedef XMLDataConfig<NetworkConfig, &NetworkConfig::Load, &NetworkConfig::Save> XMLNetworkConfig_t;
+extern XMLNetworkConfig_t n_config;
+inline NetworkConfig& GetNetworkConfig() { return n_config.data();};
+
+inline bool IsNetworkServiceSSLDisabled(NetworkService service)
+{
+	if(service == NetworkService::Nintendo)
+		return false;
+	else if(service == NetworkService::Pretendo)
+		return true;
+	else if(service == NetworkService::Custom)
+		return GetNetworkConfig().disablesslver.GetValue();
+	return false;
+}
\ No newline at end of file
diff --git a/src/config/PermanentConfig.cpp b/src/config/PermanentConfig.cpp
deleted file mode 100644
index 20a44d28..00000000
--- a/src/config/PermanentConfig.cpp
+++ /dev/null
@@ -1,65 +0,0 @@
-#include "PermanentConfig.h"
-
-#include "pugixml.hpp"
-
-#include "PermanentStorage.h"
-
-struct xml_string_writer : pugi::xml_writer
-{
-	std::string result;
-
-	void write(const void* data, size_t size) override
-	{
-		result.append(static_cast<const char*>(data), size);
-	}
-};
-
-std::string PermanentConfig::ToXMLString() const noexcept
-{
-	pugi::xml_document doc;
-	doc.append_child(pugi::node_declaration).append_attribute("encoding") = "UTF-8";
-	auto root = doc.append_child("config");
-	root.append_child("MlcPath").text().set(this->custom_mlc_path.c_str());
-
-	xml_string_writer writer;
-	doc.save(writer);
-	return writer.result;
-}
-
-PermanentConfig PermanentConfig::FromXMLString(std::string_view str) noexcept
-{
-	PermanentConfig result{};
-
-	pugi::xml_document doc;
-	if(doc.load_buffer(str.data(), str.size()))
-	{
-		result.custom_mlc_path = doc.select_node("/config/MlcPath").node().text().as_string();
-	}
-
-	return result;
-}
-
-PermanentConfig PermanentConfig::Load()
-{
-	PermanentStorage storage;
-
-	const auto str = storage.ReadFile(kFileName);
-	if (!str.empty())
-		return FromXMLString(str);
-
-	return {};
-}
-
-bool PermanentConfig::Store() noexcept
-{
-	try
-	{
-		PermanentStorage storage;
-		storage.WriteStringToFile(kFileName, ToXMLString());
-	}
-	catch (...)
-	{
-		return false;
-	}
-	return true;
-}
diff --git a/src/config/PermanentConfig.h b/src/config/PermanentConfig.h
deleted file mode 100644
index 8c134747..00000000
--- a/src/config/PermanentConfig.h
+++ /dev/null
@@ -1,18 +0,0 @@
-#pragma once
-
-#include "PermanentStorage.h"
-
-struct PermanentConfig
-{
-	static constexpr const char* kFileName = "perm_setting.xml";
-	
-	std::string custom_mlc_path;
-
-	[[nodiscard]] std::string ToXMLString() const noexcept;
-	static PermanentConfig FromXMLString(std::string_view str) noexcept;
-
-	// gets from permanent storage
-	static PermanentConfig Load();
-	// saves to permanent storage
-	bool Store() noexcept;
-};
diff --git a/src/config/PermanentStorage.cpp b/src/config/PermanentStorage.cpp
deleted file mode 100644
index 597e210c..00000000
--- a/src/config/PermanentStorage.cpp
+++ /dev/null
@@ -1,76 +0,0 @@
-#include "PermanentStorage.h"
-#include "config/CemuConfig.h"
-#include "util/helpers/SystemException.h"
-
-PermanentStorage::PermanentStorage()
-{
-	if (!GetConfig().permanent_storage)
-		throw PSDisabledException();
-	
-	const char* appdata = std::getenv("LOCALAPPDATA");
-	if (!appdata)
-		throw std::runtime_error("can't get LOCALAPPDATA");
-	m_storage_path = appdata;
-	m_storage_path /= "Cemu";
-	
-	fs::create_directories(m_storage_path);
-}
-
-PermanentStorage::~PermanentStorage()
-{
-	if (m_remove_storage)
-	{
-		std::error_code ec;
-		fs::remove_all(m_storage_path, ec);
-		if (ec)
-		{
-			SystemException ex(ec);
-			forceLog_printf("can't remove permanent storage: %s", ex.what());
-		}
-	}
-}
-
-void PermanentStorage::ClearAllFiles() const
-{
-	fs::remove_all(m_storage_path);
-	fs::create_directories(m_storage_path);
-}
-
-void PermanentStorage::RemoveStorage()
-{
-	m_remove_storage = true;
-}
-
-void PermanentStorage::WriteStringToFile(std::string_view filename, std::string_view content)
-{
-	const auto name = m_storage_path.append(filename.data(), filename.data() + filename.size());
-	std::ofstream file(name.string());
-	file.write(content.data(), (uint32_t)content.size());
-}
-
-std::string PermanentStorage::ReadFile(std::string_view filename) noexcept
-{
-	try
-	{
-		const auto name = m_storage_path.append(filename.data(), filename.data() + filename.size());
-		std::ifstream file(name, std::ios::in | std::ios::ate);
-		if (!file.is_open())
-			return {};
-
-		const auto end = file.tellg();
-		file.seekg(0, std::ios::beg);
-		const auto file_size = end - file.tellg();
-		if (file_size == 0)
-			return {};
-
-		std::string result;
-		result.resize(file_size);
-		file.read(result.data(), file_size);
-		return result;
-	}
-	catch (...)
-	{
-		return {};
-	}
-	
-}
diff --git a/src/config/PermanentStorage.h b/src/config/PermanentStorage.h
deleted file mode 100644
index 3cda3d6d..00000000
--- a/src/config/PermanentStorage.h
+++ /dev/null
@@ -1,27 +0,0 @@
-#pragma once
-
-// disabled by config
-class PSDisabledException : public std::runtime_error
-{
-public:
-	PSDisabledException()
-		: std::runtime_error("permanent storage is disabled by user") {}
-};
-
-class PermanentStorage
-{
-public:
-	PermanentStorage();
-	~PermanentStorage();
-
-	void ClearAllFiles() const;
-	// flags storage to be removed on destruction
-	void RemoveStorage();
-
-	void WriteStringToFile(std::string_view filename, std::string_view content);
-	std::string ReadFile(std::string_view filename) noexcept;
-	
-private:
-	fs::path m_storage_path;
-	bool m_remove_storage = false;
-};
\ No newline at end of file
diff --git a/src/config/XMLConfig.h b/src/config/XMLConfig.h
index c2cba527..2a32dc56 100644
--- a/src/config/XMLConfig.h
+++ b/src/config/XMLConfig.h
@@ -235,6 +235,12 @@ public:
 		set(name, value.load());
 	}
 
+	template <typename T>
+	void set(const char* name, const ConfigValue<T>& value)
+	{
+		set(name, value.GetValue());
+	}
+
 	void set(const char* name, uint64 value)
 	{
 		set(name, (sint64)value);
@@ -344,10 +350,9 @@ public:
 		if (L == nullptr)
 			return false;
 		FileStream* fs = FileStream::openFile(filename.c_str());
-
-		if (fs == nullptr)
+		if (!fs)
 		{
-			forceLogDebug_printfW(L"XMLConfig::Load > failed \"%s\" with error %d", filename.c_str(), errno);
+			cemuLog_logDebug(LogType::Force, "XMLConfig::Load > failed \"{}\" with error {}", boost::nowide::narrow(filename), errno);
 			return false;
 		}
 		std::vector<uint8> xmlData;
@@ -360,7 +365,7 @@ public:
 		const bool success = error == tinyxml2::XML_SUCCESS;
 		if (error != 0)
 		{
-			forceLogDebug_printf("XMLConfig::Load > LoadFile %d", error);
+			cemuLog_logDebug(LogType::Force, "XMLConfig::Load > LoadFile {}", error);
 		}
 		if (success)
 		{
@@ -391,7 +396,7 @@ public:
 		fs::create_directories(fs::path(filename).parent_path(), err);
 		if (err)
 		{
-			forceLog_printf("can't create parent path for save file: %s", err.message().c_str());
+			cemuLog_log(LogType::Force, "can't create parent path for save file: {}", err.message());
 			return false;
 		}
 
@@ -401,9 +406,9 @@ public:
 #else
 		file = fopen(boost::nowide::narrow(tmp_name).c_str(), "wb");
 #endif
-        if (file == nullptr)
+        if (!file)
         {
-            forceLogDebug_printfW(L"XMLConfig::Save > failed \"%s\" with error %d", filename.c_str(), errno);
+			cemuLog_logDebug(LogType::Force, "XMLConfig::Save > failed \"{}\" with error {}", boost::nowide::narrow(filename), errno);
             return false;
         }
 
@@ -417,7 +422,7 @@ public:
 		const tinyxml2::XMLError error = doc.SaveFile(file);
 		const bool success = error == tinyxml2::XML_SUCCESS;
 		if(error != 0)
-			forceLogDebug_printfW(L"XMLConfig::Save > SaveFile %d", error);
+			cemuLog_logDebug(LogType::Force, "XMLConfig::Save > SaveFile {}", error);
 
 		fflush(file);
 		fclose(file);
@@ -425,7 +430,7 @@ public:
 		fs::rename(tmp_name, filename, err);
 		if(err)
 		{
-			forceLog_printf("can't save settings to file: %s", err.message().c_str());
+			cemuLog_log(LogType::Force, "Unable to save settings to file: {}", err.message().c_str());
 			fs::remove(tmp_name, err);
 		}
 
@@ -463,4 +468,3 @@ public:
 private:
 	T m_data;
 };
-
diff --git a/src/gui/CMakeLists.txt b/src/gui/CMakeLists.txt
index b63135f9..7cdc208e 100644
--- a/src/gui/CMakeLists.txt
+++ b/src/gui/CMakeLists.txt
@@ -1,17 +1,136 @@
-project(CemuGui)
-
-file(GLOB_RECURSE CPP_FILES *.cpp)
-file(GLOB_RECURSE H_FILES *.h)
-add_library(CemuGui ${CPP_FILES} ${H_FILES})
+add_library(CemuGui 
+  canvas/IRenderCanvas.h
+  canvas/OpenGLCanvas.cpp
+  canvas/OpenGLCanvas.h
+  canvas/VulkanCanvas.cpp
+  canvas/VulkanCanvas.h
+  CemuApp.cpp
+  CemuApp.h
+  CemuUpdateWindow.cpp
+  CemuUpdateWindow.h
+  ChecksumTool.cpp
+  ChecksumTool.h
+  components/TextList.cpp
+  components/TextList.h
+  components/wxDownloadManagerList.cpp
+  components/wxDownloadManagerList.h
+  components/wxGameList.cpp
+  components/wxGameList.h
+  components/wxInputDraw.cpp
+  components/wxInputDraw.h
+  components/wxLogCtrl.cpp
+  components/wxLogCtrl.h
+  components/wxTitleManagerList.cpp
+  components/wxTitleManagerList.h
+  debugger/BreakpointWindow.cpp
+  debugger/BreakpointWindow.h
+  debugger/DebuggerWindow2.cpp
+  debugger/DebuggerWindow2.h
+  debugger/DisasmCtrl.cpp
+  debugger/DisasmCtrl.h
+  debugger/DumpCtrl.cpp
+  debugger/DumpCtrl.h
+  debugger/DumpWindow.cpp
+  debugger/DumpWindow.h
+  debugger/ModuleWindow.cpp
+  debugger/ModuleWindow.h
+  debugger/RegisterCtrl.cpp
+  debugger/RegisterCtrl.h
+  debugger/RegisterWindow.cpp
+  debugger/RegisterWindow.h
+  debugger/SymbolCtrl.cpp
+  debugger/SymbolCtrl.h
+  debugger/SymbolWindow.cpp
+  debugger/SymbolWindow.h
+  dialogs/CreateAccount/wxCreateAccountDialog.cpp
+  dialogs/CreateAccount/wxCreateAccountDialog.h
+  dialogs/SaveImport/SaveImportWindow.cpp
+  dialogs/SaveImport/SaveImportWindow.h
+  dialogs/SaveImport/SaveTransfer.cpp
+  dialogs/SaveImport/SaveTransfer.h
+  DownloadGraphicPacksWindow.cpp
+  DownloadGraphicPacksWindow.h
+  GameProfileWindow.cpp
+  GameProfileWindow.h
+  GameUpdateWindow.cpp
+  GameUpdateWindow.h
+  GeneralSettings2.cpp
+  GeneralSettings2.h
+  GettingStartedDialog.cpp
+  GettingStartedDialog.h
+  GraphicPacksWindow2.cpp
+  GraphicPacksWindow2.h
+  guiWrapper.cpp
+  guiWrapper.h
+  helpers/wxControlObject.h
+  helpers/wxCustomData.h
+  helpers/wxCustomEvents.cpp
+  helpers/wxCustomEvents.h
+  helpers/wxHelpers.cpp
+  helpers/wxHelpers.h
+  helpers/wxLogEvent.h
+  helpers/wxWayland.cpp
+  helpers/wxWayland.h
+  input/InputAPIAddWindow.cpp
+  input/InputAPIAddWindow.h
+  input/InputSettings2.cpp
+  input/InputSettings2.h
+  input/PairingDialog.cpp
+  input/PairingDialog.h
+  input/panels/ClassicControllerInputPanel.cpp
+  input/panels/ClassicControllerInputPanel.h
+  input/panels/InputPanel.cpp
+  input/panels/InputPanel.h
+  input/panels/ProControllerInputPanel.cpp
+  input/panels/ProControllerInputPanel.h
+  input/panels/VPADInputPanel.cpp
+  input/panels/VPADInputPanel.h
+  input/panels/WiimoteInputPanel.cpp
+  input/panels/WiimoteInputPanel.h
+  input/settings/DefaultControllerSettings.cpp
+  input/settings/DefaultControllerSettings.h
+  input/settings/WiimoteControllerSettings.cpp
+  input/settings/WiimoteControllerSettings.h
+  LoggingWindow.cpp
+  LoggingWindow.h
+  MainWindow.cpp
+  MainWindow.h
+  MemorySearcherTool.cpp
+  MemorySearcherTool.h
+  PadViewFrame.cpp
+  PadViewFrame.h
+  TitleManager.cpp
+  TitleManager.h
+  EmulatedUSBDevices/EmulatedUSBDeviceFrame.cpp
+  EmulatedUSBDevices/EmulatedUSBDeviceFrame.h
+  windows/PPCThreadsViewer
+  windows/PPCThreadsViewer/DebugPPCThreadsWindow.cpp
+  windows/PPCThreadsViewer/DebugPPCThreadsWindow.h
+  windows/TextureRelationViewer
+  windows/TextureRelationViewer/TextureRelationWindow.cpp
+  windows/TextureRelationViewer/TextureRelationWindow.h
+  wxcomponents/checked2.xpm
+  wxcomponents/checked_dis.xpm
+  wxcomponents/checked_d.xpm
+  wxcomponents/checked_ld.xpm
+  wxcomponents/checkedlistctrl.cpp
+  wxcomponents/checkedlistctrl.h
+  wxcomponents/checked_mo.xpm
+  wxcomponents/checked.xpm
+  wxcomponents/checktree.cpp
+  wxcomponents/checktree.h
+  wxcomponents/unchecked2.xpm
+  wxcomponents/unchecked_dis.xpm
+  wxcomponents/unchecked_d.xpm
+  wxcomponents/unchecked_ld.xpm
+  wxcomponents/unchecked_mo.xpm
+  wxcomponents/unchecked.xpm
+  wxgui.h
+  wxHelper.h
+)
 
 set_property(TARGET CemuGui PROPERTY MSVC_RUNTIME_LIBRARY "MultiThreaded$<$<CONFIG:Debug>:Debug>")
 
-target_sources(CemuGui PRIVATE
-	wxcomponents/checkedlistctrl.cpp
-	wxcomponents/checkedlistctrl.h
-	wxcomponents/checktree.cpp
-	wxcomponents/checktree.h
-)
 
 target_include_directories(CemuGui PUBLIC "../")
 # PUBLIC because rapidjson/document.h is included in ChecksumTool.h
@@ -34,11 +153,32 @@ target_link_libraries(CemuGui PRIVATE
 	ZArchive::zarchive
 )
 
+if(ENABLE_WXWIDGETS AND UNIX AND NOT APPLE)
+	# PUBLIC because gdk/gdkkeysyms.h is included in guiWrapper.h
+	target_link_libraries(CemuGui PUBLIC GTK3::gtk)
+  if (ENABLE_WAYLAND)
+    target_link_libraries(CemuGui PRIVATE Wayland::Client CemuWaylandProtocols)
+  endif()
+endif()
+
 if(ENABLE_CUBEB)
 	target_link_libraries(CemuGui PRIVATE cubeb::cubeb)
 endif()
 
+if(UNIX AND NOT APPLE)
+	if(ENABLE_FERAL_GAMEMODE)
+		target_link_libraries(CemuGui PRIVATE gamemode)
+	endif()
+endif()
 if (ENABLE_WXWIDGETS)
 	# PUBLIC because wx/app.h is included in CemuApp.h
 	target_link_libraries(CemuGui PUBLIC wx::base wx::core wx::gl wx::propgrid wx::xrc)
 endif()
+
+if(WIN32)
+	target_link_libraries(CemuGui PRIVATE bthprops)
+endif()
+
+if(ALLOW_PORTABLE)
+	target_compile_definitions(CemuGui PRIVATE CEMU_ALLOW_PORTABLE)
+endif ()
\ No newline at end of file
diff --git a/src/gui/CemuApp.cpp b/src/gui/CemuApp.cpp
index c3270bed..c3606292 100644
--- a/src/gui/CemuApp.cpp
+++ b/src/gui/CemuApp.cpp
@@ -3,17 +3,26 @@
 #include "gui/wxgui.h"
 #include "config/CemuConfig.h"
 #include "Cafe/HW/Latte/Renderer/Vulkan/VulkanAPI.h"
+#include "Cafe/HW/Latte/Core/LatteOverlay.h"
 #include "gui/guiWrapper.h"
 #include "config/ActiveSettings.h"
+#include "config/LaunchSettings.h"
 #include "gui/GettingStartedDialog.h"
-#include "config/PermanentConfig.h"
-#include "config/PermanentStorage.h"
 #include "input/InputManager.h"
 #include "gui/helpers/wxHelpers.h"
 #include "Cemu/ncrypto/ncrypto.h"
 
+#if BOOST_OS_LINUX && HAS_WAYLAND
+#include "gui/helpers/wxWayland.h"
+#endif
+#if __WXGTK__
+#include <glib.h>
+#endif
+
 #include <wx/image.h>
 #include <wx/filename.h>
+#include <wx/stdpaths.h>
+#include "wxHelper.h"
 
 #include "Cafe/TitleList/TitleList.h"
 #include "Cafe/TitleList/SaveList.h"
@@ -24,27 +33,17 @@ wxIMPLEMENT_APP_NO_MAIN(CemuApp);
 extern WindowInfo g_window_info;
 extern std::shared_mutex g_mutex;
 
+// forward declarations from main.cpp
+void UnitTests();
+void CemuCommonInit();
+
+void HandlePostUpdate();
 // Translation strings to extract for gettext:
 void unused_translation_dummy()
 {
 	void(_("Browse"));
 	void(_("Select a file"));
 	void(_("Select a directory"));
-	
-	void(_("base"));
-	void(_("update"));
-	void(_("dlc"));
-	void(_("save"));
-
-	void(_("Japan"));
-	void(_("USA"));
-	void(_("Europe"));
-	void(_("Australia"));
-	void(_("China"));
-	void(_("Korea"));
-	void(_("Taiwan"));
-	void(_("Auto"));
-	void(_("many"));
 
 	void(_("Japanese"));
 	void(_("English"));
@@ -59,41 +58,256 @@ void unused_translation_dummy()
 	void(_("Russian"));
 	void(_("Taiwanese"));
 	void(_("unknown"));
+}
 
+#if BOOST_OS_WINDOWS
+#include <shlobj_core.h>
+fs::path GetAppDataRoamingPath()
+{
+	PWSTR path = nullptr;
+	HRESULT result = SHGetKnownFolderPath(FOLDERID_RoamingAppData, 0, nullptr, &path);
+	if (result != S_OK || !path)
+	{
+		if (path)
+			CoTaskMemFree(path);
+		return {};
+	}
+	std::string appDataPath = boost::nowide::narrow(path);
+	CoTaskMemFree(path);
+	return _utf8ToPath(appDataPath);
+}
+#endif
 
-	// account.h
-	void(_("AccountId missing (The account is not connected to a NNID)"));
-	void(_("IsPasswordCacheEnabled is set to false (The remember password option on your Wii U must be enabled for this account before dumping it)"));
-	void(_("AccountPasswordCache is empty (The remember password option on your Wii U must be enabled for this account before dumping it)"));
-	void(_("PrincipalId missing"));
+#if BOOST_OS_WINDOWS
+void CemuApp::DeterminePaths(std::set<fs::path>& failedWriteAccess) // for Windows
+{
+	std::error_code ec;
+	bool isPortable = false;
+	fs::path user_data_path, config_path, cache_path, data_path;
+	auto standardPaths = wxStandardPaths::Get();
+	fs::path exePath(wxHelper::MakeFSPath(standardPaths.GetExecutablePath()));
+	fs::path portablePath = exePath.parent_path() / "portable";
+	data_path = exePath.parent_path(); // the data path is always the same as the exe path
+#ifdef CEMU_ALLOW_PORTABLE
+	if (fs::is_directory(portablePath, ec))
+	{
+		isPortable = true;
+		user_data_path = config_path = cache_path = portablePath;
+	}
+	else
+#endif
+	{
+		fs::path roamingPath = GetAppDataRoamingPath() / "Cemu";
+		user_data_path = config_path = cache_path = roamingPath;
+	}
+	// on Windows Cemu used to be portable by default prior to 2.0-89
+	// to remain backwards compatible with old installations we check for settings.xml in the Cemu directory
+	// if it exists, we use the exe path as the portable directory
+	if(!isPortable) // lower priority than portable directory
+	{
+		if (fs::exists(exePath.parent_path() / "settings.xml", ec))
+		{
+			isPortable = true;
+			user_data_path = config_path = cache_path = exePath.parent_path();
+		}
+	}
+	ActiveSettings::SetPaths(isPortable, exePath, user_data_path, config_path, cache_path, data_path, failedWriteAccess);
+}
+#endif
+
+#if BOOST_OS_LINUX
+void CemuApp::DeterminePaths(std::set<fs::path>& failedWriteAccess) // for Linux
+{
+	std::error_code ec;
+	bool isPortable = false;
+	fs::path user_data_path, config_path, cache_path, data_path;
+	auto standardPaths = wxStandardPaths::Get();
+	fs::path exePath(wxHelper::MakeFSPath(standardPaths.GetExecutablePath()));
+	fs::path portablePath = exePath.parent_path() / "portable";
+	// GetExecutablePath returns the AppImage's temporary mount location
+	wxString appImagePath;
+	if (wxGetEnv("APPIMAGE", &appImagePath))
+	{
+		exePath = wxHelper::MakeFSPath(appImagePath);
+		portablePath = exePath.parent_path() / "portable";
+	}
+#ifdef CEMU_ALLOW_PORTABLE
+	if (fs::is_directory(portablePath, ec))
+	{
+		isPortable = true;
+		user_data_path = config_path = cache_path = portablePath;
+		// in portable mode assume the data directories (resources, gameProfiles/default/) are next to the executable
+		data_path = exePath.parent_path();
+	}
+	else
+#endif
+	{
+		SetAppName("Cemu");
+		wxString appName = GetAppName();
+		standardPaths.SetFileLayout(wxStandardPaths::FileLayout::FileLayout_XDG);
+		auto getEnvDir = [&](const wxString& varName, const wxString& defaultValue)
+		{
+			wxString dir;
+			if (!wxGetEnv(varName, &dir) || dir.empty())
+				return defaultValue;
+			return dir;
+		};
+		wxString homeDir = wxFileName::GetHomeDir();
+		user_data_path = (getEnvDir(wxS("XDG_DATA_HOME"), homeDir + wxS("/.local/share")) + "/" + appName).ToStdString();
+		config_path = (getEnvDir(wxS("XDG_CONFIG_HOME"), homeDir + wxS("/.config")) + "/" + appName).ToStdString();
+		data_path = standardPaths.GetDataDir().ToStdString();
+		cache_path = standardPaths.GetUserDir(wxStandardPaths::Dir::Dir_Cache).ToStdString();
+		cache_path /= appName.ToStdString();
+	}
+	ActiveSettings::SetPaths(isPortable, exePath, user_data_path, config_path, cache_path, data_path, failedWriteAccess);
+}
+#endif
+
+#if BOOST_OS_MACOS
+void CemuApp::DeterminePaths(std::set<fs::path>& failedWriteAccess) // for MacOS
+{
+	std::error_code ec;
+	bool isPortable = false;
+	fs::path user_data_path, config_path, cache_path, data_path;
+	auto standardPaths = wxStandardPaths::Get();
+	fs::path exePath(wxHelper::MakeFSPath(standardPaths.GetExecutablePath()));
+    // If run from an app bundle, use its parent directory
+	fs::path appPath = exePath.parent_path().parent_path().parent_path();
+	fs::path portablePath = appPath.extension() == ".app" ? appPath.parent_path() / "portable" : exePath.parent_path() / "portable";
+#ifdef CEMU_ALLOW_PORTABLE
+	if (fs::is_directory(portablePath, ec))
+	{
+		isPortable = true;
+		user_data_path = config_path = cache_path = portablePath;
+		data_path = exePath.parent_path();
+	}
+	else
+#endif
+	{
+		SetAppName("Cemu");
+		wxString appName = GetAppName();
+		user_data_path = config_path = standardPaths.GetUserDataDir().ToStdString();
+		data_path = standardPaths.GetDataDir().ToStdString();
+		cache_path = standardPaths.GetUserDir(wxStandardPaths::Dir::Dir_Cache).ToStdString();
+		cache_path /= appName.ToStdString();
+	}
+	ActiveSettings::SetPaths(isPortable, exePath, user_data_path, config_path, cache_path, data_path, failedWriteAccess);
+}
+#endif
+
+// create default MLC files or quit if it fails
+void CemuApp::InitializeNewMLCOrFail(fs::path mlc)
+{
+	if( CemuApp::CreateDefaultMLCFiles(mlc) )
+		return; // all good
+	cemu_assert_debug(!ActiveSettings::IsCustomMlcPath()); // should not be possible?
+
+	if(ActiveSettings::IsCommandLineMlcPath() || ActiveSettings::IsCustomMlcPath())
+	{
+		// tell user that the custom path is not writable
+		wxMessageBox(formatWxString(_("Cemu failed to write to the custom mlc directory.\nThe path is:\n{}"), wxHelper::FromPath(mlc)), _("Error"), wxOK | wxCENTRE | wxICON_ERROR);
+		exit(0);
+	}
+	wxMessageBox(formatWxString(_("Cemu failed to write to the mlc directory.\nThe path is:\n{}"), wxHelper::FromPath(mlc)), _("Error"), wxOK | wxCENTRE | wxICON_ERROR);
+	exit(0);
+}
+
+void CemuApp::InitializeExistingMLCOrFail(fs::path mlc)
+{
+	if(CreateDefaultMLCFiles(mlc))
+		return; // all good
+	// failed to write mlc files
+	if(ActiveSettings::IsCommandLineMlcPath() || ActiveSettings::IsCustomMlcPath())
+	{
+		// tell user that the custom path is not writable
+		// if it's a command line path then just quit. Otherwise ask if user wants to reset the path
+		if(ActiveSettings::IsCommandLineMlcPath())
+		{
+			wxMessageBox(formatWxString(_("Cemu failed to write to the custom mlc directory.\nThe path is:\n{}"), wxHelper::FromPath(mlc)), _("Error"), wxOK | wxCENTRE | wxICON_ERROR);
+			exit(0);
+		}
+		// ask user if they want to reset the path
+		const wxString message = formatWxString(_("Cemu failed to write to the custom mlc directory.\n\nThe path is:\n{}\n\nCemu cannot start without a valid mlc path. Do you want to reset the path? You can later change it again in the General Settings."),
+												_pathToUtf8(mlc));
+		wxMessageDialog dialog(nullptr, message, _("Error"), wxCENTRE | wxYES_NO | wxICON_WARNING);
+		dialog.SetYesNoLabels(_("Reset path"), _("Exit"));
+		const auto dialogResult = dialog.ShowModal();
+		if (dialogResult == wxID_NO)
+			exit(0);
+		else // reset path
+		{
+			GetConfig().mlc_path = "";
+			g_config.Save();
+		}
+	}
+	else
+	{
+		// default path is not writeable. Just let the user know and quit. Unsure if it would be a good idea to ask the user to choose an alternative path instead
+		wxMessageBox(formatWxString(_("Cemu failed to write to the default mlc directory.\nThe path is:\n{}"), wxHelper::FromPath(mlc)), _("Error"), wxOK | wxCENTRE | wxICON_ERROR);
+		exit(0);
+	}
 }
 
 bool CemuApp::OnInit()
 {
+#if __WXGTK__
+	GTKSuppressDiagnostics(G_LOG_LEVEL_MASK & ~G_LOG_FLAG_FATAL);
+#endif
+	std::set<fs::path> failedWriteAccess;
+	DeterminePaths(failedWriteAccess);
+	// make sure default cemu directories exist
+	CreateDefaultCemuFiles();
+
+	g_config.SetFilename(ActiveSettings::GetConfigPath("settings.xml").generic_wstring());
+
+	std::error_code ec;
+	bool isFirstStart = !fs::exists(ActiveSettings::GetConfigPath("settings.xml"), ec);
+
+	NetworkConfig::LoadOnce();
+	if(!isFirstStart)
+	{
+		g_config.Load();
+		LocalizeUI(static_cast<wxLanguage>(GetConfig().language == wxLANGUAGE_DEFAULT ? wxLocale::GetSystemLanguage() : GetConfig().language.GetValue()));
+	}
+	else
+	{
+		LocalizeUI(static_cast<wxLanguage>(wxLocale::GetSystemLanguage()));
+	}
+
+	for (auto&& path : failedWriteAccess)
+	{
+		wxMessageBox(formatWxString(_("Cemu can't write to {}!"), wxString::FromUTF8(_pathToUtf8(path))),
+					 _("Warning"), wxOK | wxCENTRE | wxICON_EXCLAMATION, nullptr);
+	}
+
+	if (isFirstStart)
+	{
+		// show the getting started dialog
+		GettingStartedDialog dia(nullptr);
+		dia.ShowModal();
+		// make sure config is created. Gfx pack UI and input UI may create it earlier already, but we still want to update it
+		g_config.Save();
+		// create mlc, on failure the user can quit here. So do this after the Getting Started dialog
+		InitializeNewMLCOrFail(ActiveSettings::GetMlcPath());
+	}
+	else
+	{
+		// check if mlc is valid and recreate default files
+		InitializeExistingMLCOrFail(ActiveSettings::GetMlcPath());
+	}
+
+	ActiveSettings::Init(); // this is a bit of a misnomer, right now this call only loads certs for online play. In the future we should move the logic to a more appropriate place
+	HandlePostUpdate();
+
+	LatteOverlay_init();
+	// run a couple of tests if in non-release mode
+#ifdef CEMU_DEBUG_ASSERT
+	UnitTests();
+#endif
+	CemuCommonInit();
+
 	wxInitAllImageHandlers();
 
-	g_config.Load();
-	m_languages = GetAvailableLanguages();
-
-	const sint32 language = GetConfig().language;
-	if (language != wxLANGUAGE_ENGLISH)
-	{
-		const auto it = std::find_if(m_languages.begin(), m_languages.end(), [language](const wxLanguageInfo* info) { return info->Language == language; });
-		if (it != m_languages.end() && wxLocale::IsAvailable(language))
-		{
-			if (m_locale.Init(language))
-			{
-				m_locale.AddCatalogLookupPathPrefix("./resources");
-				m_locale.AddCatalog("cemu");
-			}
-		}
-	}
-
-	if (!m_locale.IsOk())
-	{
-		m_locale.Init(wxLANGUAGE_DEFAULT);
-	}
-
 	// fill colour db
 	wxTheColourDatabase->AddColour("ERROR", wxColour(0xCC, 0, 0));
 	wxTheColourDatabase->AddColour("SUCCESS", wxColour(0, 0xbb, 0));
@@ -107,32 +321,40 @@ bool CemuApp::OnInit()
 			__fastfail(0);
 	}
 #endif
-
-	// init input
-	InputManager::instance().load();
-	
 	InitializeGlobalVulkan();
 
 	Bind(wxEVT_ACTIVATE_APP, &CemuApp::ActivateApp, this);
 
-	if (!TestWriteAccess(ActiveSettings::GetPath()))
-		wxMessageBox(_("Cemu can't write to its directory.\nPlease move it to a different location or run Cemu as administrator!"), _("Warning"), wxOK | wxCENTRE | wxICON_EXCLAMATION, nullptr);
-
 	auto& config = GetConfig();
-	const bool first_start = !config.did_show_graphic_pack_download;
-
-	CreateDefaultFiles(first_start);
-
 	m_mainFrame = new MainWindow();
 
-	if (first_start)
-		m_mainFrame->ShowGettingStartedDialog();
-
 	std::unique_lock lock(g_mutex);
 	g_window_info.app_active = true;
 
 	SetTopWindow(m_mainFrame);
 	m_mainFrame->Show();
+
+#if BOOST_OS_LINUX && HAS_WAYLAND
+	if (wxWlIsWaylandWindow(m_mainFrame))
+		wxWlSetAppId(m_mainFrame, "info.cemu.Cemu");
+#endif
+
+	// show warning on macOS about state of builds
+#if BOOST_OS_MACOS
+	if (!GetConfig().did_show_macos_disclaimer)
+	{
+		const auto message = _(
+			"Thank you for testing the in-development build of Cemu for macOS.\n \n"
+			"The macOS port is currently purely experimental and should not be considered stable or ready for issue-free gameplay. "
+			"There are also known issues with degraded performance due to the use of MoltenVk and Rosetta for ARM Macs. We appreciate your patience while we improve Cemu for macOS.");
+		wxMessageDialog dialog(nullptr, message, _("Preview version"), wxCENTRE | wxOK | wxICON_WARNING);
+		dialog.SetOKLabel(_("I understand"));
+		dialog.ShowModal();
+		GetConfig().did_show_macos_disclaimer = true;
+		g_config.Save();
+	}
+#endif
+
 	return true;
 }
 
@@ -154,9 +376,9 @@ void CemuApp::OnAssertFailure(const wxChar* file, int line, const wxChar* func,
 {
 	cemuLog_createLogFile(false);
 	cemuLog_log(LogType::Force, "Encountered wxWidgets assert!");
-	cemuLog_log(LogType::Force, fmt::format(L"File: {0} Line: {1}", std::wstring_view(file), line));
-	cemuLog_log(LogType::Force, fmt::format(L"Func: {0} Cond: {1}", func, std::wstring_view(cond)));
-	cemuLog_log(LogType::Force, fmt::format(L"Message: {}", std::wstring_view(msg)));
+	cemuLog_log(LogType::Force, "File: {0} Line: {1}", wxString(file).utf8_string(), line);
+	cemuLog_log(LogType::Force, "Func: {0} Cond: {1}", wxString(func).utf8_string(), wxString(cond).utf8_string());
+	cemuLog_log(LogType::Force, "Message: {}", wxString(msg).utf8_string());
 
 #if BOOST_OS_WINDOWS
 	DumpThreadStackTrace();
@@ -169,100 +391,104 @@ int CemuApp::FilterEvent(wxEvent& event)
 	if(event.GetEventType() == wxEVT_KEY_DOWN)
 	{
 		const auto& key_event = (wxKeyEvent&)event;
-		wxGetKeyState(wxKeyCode::WXK_F17);
-		uint32 keycode=fix_raw_keycode(key_event.GetRawKeyCode(), key_event.GetRawKeyFlags());
-		if(keycode<256)
-			g_window_info.keydown[keycode] = true;
+		g_window_info.set_keystate(fix_raw_keycode(key_event.GetRawKeyCode(), key_event.GetRawKeyFlags()), true);
 	}
 	else if(event.GetEventType() == wxEVT_KEY_UP)
 	{
 		const auto& key_event = (wxKeyEvent&)event;
-		uint32 keycode=fix_raw_keycode(key_event.GetRawKeyCode(), key_event.GetRawKeyFlags());
-		if(keycode<256)
-			g_window_info.keydown[keycode] = false;
+		g_window_info.set_keystate(fix_raw_keycode(key_event.GetRawKeyCode(), key_event.GetRawKeyFlags()), false);
+	}
+	else if(event.GetEventType() == wxEVT_ACTIVATE_APP)
+	{
+		const auto& activate_event = (wxActivateEvent&)event;
+		if(!activate_event.GetActive())
+			g_window_info.set_keystatesup();
 	}
 
 	return wxApp::FilterEvent(event);
 }
 
-std::vector<const wxLanguageInfo*> CemuApp::GetAvailableLanguages()
-{
-	const auto path = ActiveSettings::GetPath("resources");
-	if (!exists(path))
-		return {};
-	
-	std::vector<const wxLanguageInfo*> result;
-	for (const auto& p : fs::directory_iterator(path))
-	{
-		if (!fs::is_directory(p))
-			continue;
-
-		const auto& path = p.path();
-		auto filename = path.filename();
-
-		const auto* lang_info = wxLocale::FindLanguageInfo(filename.c_str());
-		if (!lang_info)
-			continue;
-
-		const auto language_file = path / "cemu.mo";
-		if (!fs::exists(language_file))
-			continue;
-
-		result.emplace_back(lang_info);
-	}
-
-	return result;
+std::vector<const wxLanguageInfo *> CemuApp::GetLanguages() const {
+	std::vector availableLanguages(m_availableTranslations);
+	availableLanguages.insert(availableLanguages.begin(), wxLocale::GetLanguageInfo(wxLANGUAGE_ENGLISH));
+	return availableLanguages;
 }
 
-void CemuApp::CreateDefaultFiles(bool first_start)
+void CemuApp::LocalizeUI(wxLanguage languageToUse)
 {
-	std::wstring mlc = GetMLCPath().ToStdWstring();
+	std::unique_ptr<wxTranslations> translationsMgr(new wxTranslations());
+	m_availableTranslations = GetAvailableTranslationLanguages(translationsMgr.get());
 
-	// check for mlc01 folder missing if custom path has been set
-	if (!fs::exists(mlc) && !first_start)
+	bool isTranslationAvailable = std::any_of(m_availableTranslations.begin(), m_availableTranslations.end(),
+											  [languageToUse](const wxLanguageInfo* info) { return info->Language == languageToUse; });
+	if (languageToUse == wxLANGUAGE_DEFAULT || isTranslationAvailable)
 	{
-		const std::wstring message = fmt::format(fmt::runtime(_(L"Your mlc01 folder seems to be missing.\n\nThis is where Cemu stores save files, game updates and other Wii U files.\n\nThe expected path is:\n{}\n\nDo you want to create the folder at the expected path?").ToStdWstring()), mlc);
-		
-		wxMessageDialog dialog(nullptr, message, "Error", wxCENTRE | wxYES_NO | wxCANCEL| wxICON_WARNING);
-		dialog.SetYesNoCancelLabels(_("Yes"), _("No"), _("Select a custom path"));
-		const auto dialogResult = dialog.ShowModal();
-		if (dialogResult == wxID_NO)
-			exit(0);
-		else if(dialogResult == wxID_CANCEL)
-		{
-			if (!SelectMLCPath())
-				return;
+		translationsMgr->SetLanguage(static_cast<wxLanguage>(languageToUse));
+		translationsMgr->AddCatalog("cemu");
 
-			mlc = GetMLCPath();
-		}
-		else
+		if (translationsMgr->IsLoaded("cemu") && wxLocale::IsAvailable(languageToUse))
 		{
-			GetConfig().mlc_path = L"";
-			g_config.Save();
+			m_locale.Init(languageToUse);
 		}
+		// This must be run after wxLocale::Init, as the latter sets up its own wxTranslations instance which we want to override
+		wxTranslations::Set(translationsMgr.release());
 	}
+}
 
+std::vector<const wxLanguageInfo*> CemuApp::GetAvailableTranslationLanguages(wxTranslations* translationsMgr)
+{
+	wxFileTranslationsLoader::AddCatalogLookupPathPrefix(wxHelper::FromPath(ActiveSettings::GetDataPath("resources")));
+	std::vector<const wxLanguageInfo*> languages;
+	for (const auto& langName : translationsMgr->GetAvailableTranslations("cemu"))
+	{
+		const auto* langInfo = wxLocale::FindLanguageInfo(langName);
+		if (langInfo)
+			languages.emplace_back(langInfo);
+	}
+	return languages;
+}
+
+bool CemuApp::CheckMLCPath(const fs::path& mlc)
+{
+	std::error_code ec;
+	if (!fs::exists(mlc, ec))
+		return false;
+	if (!fs::exists(mlc / "usr", ec) || !fs::exists(mlc / "sys", ec))
+		return false;
+	return true;
+}
+
+bool CemuApp::CreateDefaultMLCFiles(const fs::path& mlc)
+{
+	auto CreateDirectoriesIfNotExist = [](const fs::path& path)
+	{
+		std::error_code ec;
+		if (!fs::exists(path, ec))
+			return fs::create_directories(path, ec);
+		return true;
+	};
+	// list of directories to create
+	const fs::path directories[] = {
+		mlc,
+		mlc / "sys",
+		mlc / "usr",
+		mlc / "usr/title/00050000", // base
+		mlc / "usr/title/0005000c", // dlc
+		mlc / "usr/title/0005000e", // update
+		mlc / "usr/save/00050010/1004a000/user/common/db", // Mii Maker save folders {0x500101004A000, 0x500101004A100, 0x500101004A200}
+		mlc / "usr/save/00050010/1004a100/user/common/db",
+		mlc / "usr/save/00050010/1004a200/user/common/db",
+		mlc / "sys/title/0005001b/1005c000/content" // lang files
+	};
+	for(auto& path : directories)
+	{
+		if(!CreateDirectoriesIfNotExist(path))
+			return false;
+	}
 	// create sys/usr folder in mlc01
 	try
 	{
-		const auto sysFolder = fs::path(mlc).append(L"sys");
-		fs::create_directories(sysFolder);
-
-		const auto usrFolder = fs::path(mlc).append(L"usr");
-		fs::create_directories(usrFolder);
-		fs::create_directories(fs::path(usrFolder).append("title/00050000")); // base
-		fs::create_directories(fs::path(usrFolder).append("title/0005000c")); // dlc
-		fs::create_directories(fs::path(usrFolder).append("title/0005000e")); // update
-
-		// Mii Maker save folders {0x500101004A000, 0x500101004A100, 0x500101004A200},
-		fs::create_directories(fs::path(mlc).append(L"usr/save/00050010/1004a000/user/common/db"));
-		fs::create_directories(fs::path(mlc).append(L"usr/save/00050010/1004a100/user/common/db"));
-		fs::create_directories(fs::path(mlc).append(L"usr/save/00050010/1004a200/user/common/db"));
-
-		// lang files
-		auto langDir = fs::path(mlc).append(L"sys/title/0005001b/1005c000/content");
-		fs::create_directories(langDir);
-
+		const auto langDir = fs::path(mlc).append("sys/title/0005001b/1005c000/content");
 		auto langFile = fs::path(langDir).append("language.txt");
 		if (!fs::exists(langFile))
 		{
@@ -282,7 +508,7 @@ void CemuApp::CreateDefaultFiles(bool first_start)
 		if (!fs::exists(countryFile))
 		{
 			std::ofstream file(countryFile);
-			for (sint32 i = 0; i < 201; i++)
+			for (sint32 i = 0; i < NCrypto::GetCountryCount(); i++)
 			{
 				const char* countryCode = NCrypto::GetCountryAsString(i);
 				if (boost::iequals(countryCode, "NN"))
@@ -293,110 +519,49 @@ void CemuApp::CreateDefaultFiles(bool first_start)
 			file.flush();
 			file.close();
 		}
+		// create a dummy file in the mlc folder to check if it's writable
+		const auto dummyFile = fs::path(mlc).append("writetestdummy");
+		std::ofstream file(dummyFile);
+		if (!file.is_open())
+			return false;
+		file.close();
+		fs::remove(dummyFile);
 	}
 	catch (const std::exception& ex)
 	{
-		std::stringstream errorMsg;
-		errorMsg << fmt::format(fmt::runtime(_("Couldn't create a required mlc01 subfolder or file!\n\nError: {0}\nTarget path:\n{1}").ToStdString()), ex.what(), boost::nowide::narrow(mlc));
-
-#if BOOST_OS_WINDOWS
-		const DWORD lastError = GetLastError();
-		if (lastError != ERROR_SUCCESS)
-			errorMsg << fmt::format("\n\n{}", GetSystemErrorMessage(lastError));
-
-		wxMessageBox(errorMsg.str(), "Error", wxOK | wxCENTRE | wxICON_ERROR);
-#endif
-		exit(0);
+		return false;
 	}
+	return true;
+}
 
+void CemuApp::CreateDefaultCemuFiles()
+{
 	// cemu directories
 	try
 	{
-		const auto controllerProfileFolder = GetCemuPath(L"controllerProfiles").ToStdWstring();
+		const auto controllerProfileFolder = ActiveSettings::GetConfigPath("controllerProfiles");
 		if (!fs::exists(controllerProfileFolder))
 			fs::create_directories(controllerProfileFolder);
 
-		const auto memorySearcherFolder = GetCemuPath(L"memorySearcher").ToStdWstring();
+		const auto memorySearcherFolder = ActiveSettings::GetUserDataPath("memorySearcher");
 		if (!fs::exists(memorySearcherFolder))
 			fs::create_directories(memorySearcherFolder);
 	}
 	catch (const std::exception& ex)
 	{
-		std::stringstream errorMsg;
-		errorMsg << fmt::format(fmt::runtime(_("Couldn't create a required cemu directory or file!\n\nError: {0}").ToStdString()), ex.what());
+		wxString errorMsg = formatWxString(_("Couldn't create a required cemu directory or file!\n\nError: {0}"), ex.what());
 
 #if BOOST_OS_WINDOWS
 		const DWORD lastError = GetLastError();
 		if (lastError != ERROR_SUCCESS)
 			errorMsg << fmt::format("\n\n{}", GetSystemErrorMessage(lastError));
-
-
-		wxMessageBox(errorMsg.str(), "Error", wxOK | wxCENTRE | wxICON_ERROR);
 #endif
+
+		wxMessageBox(errorMsg, _("Error"), wxOK | wxCENTRE | wxICON_ERROR);
 		exit(0);
 	}
 }
 
-
-
-bool CemuApp::SelectMLCPath(wxWindow* parent)
-{
-	auto& config = GetConfig();
-	
-	std::wstring default_path;
-	if (fs::exists(config.mlc_path.GetValue()))
-		default_path = config.mlc_path.GetValue();
-
-	// try until users selects a valid path or aborts
-	while(true)
-	{
-		wxDirDialog path_dialog(parent, _("Select a mlc directory"), default_path, wxDD_DEFAULT_STYLE | wxDD_DIR_MUST_EXIST);
-		if (path_dialog.ShowModal() != wxID_OK || path_dialog.GetPath().empty())
-			return false;
-
-		const auto path = path_dialog.GetPath().ToStdWstring();
-
-		if (!TestWriteAccess(fs::path{ path }))
-		{
-			const auto result = wxMessageBox(_("Cemu can't write to the selected mlc path!\nDo you want to select another path?"), _("Error"), wxYES_NO | wxCENTRE | wxICON_ERROR);
-			if (result == wxYES)
-				continue;
-			
-			break;
-		}
-
-		config.SetMLCPath(path);
-		// update TitleList and SaveList scanner with new MLC path
-		CafeTitleList::SetMLCPath(path);
-		CafeTitleList::Refresh();
-		CafeSaveList::SetMLCPath(path);
-		CafeSaveList::Refresh();
-		return true;
-	}
-
-	return false;
-}
-
-wxString CemuApp::GetCemuPath()
-{
-	return ActiveSettings::GetPath().generic_wstring();
-}
-
-wxString CemuApp::GetCemuPath(const wxString& cat)
-{
-	return ActiveSettings::GetPath(cat.ToStdString()).generic_wstring();
-}
-
-wxString CemuApp::GetMLCPath()
-{
-	return ActiveSettings::GetMlcPath().generic_wstring();
-}
-
-wxString CemuApp::GetMLCPath(const wxString& cat)
-{
-	return ActiveSettings::GetMlcPath(cat.ToStdString()).generic_wstring();
-}
-
 void CemuApp::ActivateApp(wxActivateEvent& event)
 {
 	g_window_info.app_active = event.GetActive();
diff --git a/src/gui/CemuApp.h b/src/gui/CemuApp.h
index 888293eb..b73d627d 100644
--- a/src/gui/CemuApp.h
+++ b/src/gui/CemuApp.h
@@ -13,23 +13,26 @@ public:
 	void OnAssertFailure(const wxChar* file, int line, const wxChar* func, const wxChar* cond, const wxChar* msg) override;
 	int FilterEvent(wxEvent& event) override;
 
-	const std::vector<const wxLanguageInfo*>& GetLanguages() const { return m_languages; }
-	static std::vector<const wxLanguageInfo*> GetAvailableLanguages();
+	std::vector<const wxLanguageInfo*> GetLanguages() const;
 
-	static void CreateDefaultFiles(bool first_start = false);
-	static bool SelectMLCPath(wxWindow* parent = nullptr);
+	static bool CheckMLCPath(const fs::path& mlc);
+	static bool CreateDefaultMLCFiles(const fs::path& mlc);
+	static void CreateDefaultCemuFiles();
 
-	static wxString GetCemuPath();
-	static wxString GetCemuPath(const wxString& cat);
-	static wxString GetMLCPath();
-	static wxString GetMLCPath(const wxString& cat);
+	static void InitializeNewMLCOrFail(fs::path mlc);
+	static void InitializeExistingMLCOrFail(fs::path mlc);
 private:
+	void LocalizeUI(wxLanguage languageToUse);
+
+	void DeterminePaths(std::set<fs::path>& failedWriteAccess);
+
 	void ActivateApp(wxActivateEvent& event);
+	static std::vector<const wxLanguageInfo*> GetAvailableTranslationLanguages(wxTranslations* translationsMgr);
 
 	MainWindow* m_mainFrame = nullptr;
 
 	wxLocale m_locale;
-	std::vector<const wxLanguageInfo*> m_languages;
+	std::vector<const wxLanguageInfo*> m_availableTranslations;
 };
 
 wxDECLARE_APP(CemuApp);
diff --git a/src/gui/CemuUpdateWindow.cpp b/src/gui/CemuUpdateWindow.cpp
index ef537a58..6a4e6885 100644
--- a/src/gui/CemuUpdateWindow.cpp
+++ b/src/gui/CemuUpdateWindow.cpp
@@ -10,6 +10,12 @@
 #include <wx/gauge.h>
 #include <wx/button.h>
 #include <wx/msgdlg.h>
+#include <wx/stdpaths.h>
+
+#ifndef BOOST_OS_WINDOWS
+#include <unistd.h>
+#include <sys/stat.h>
+#endif
 
 #include <curl/curl.h>
 #include <zip.h>
@@ -23,7 +29,7 @@ wxDECLARE_EVENT(wxEVT_PROGRESS, wxCommandEvent);
 wxDEFINE_EVENT(wxEVT_PROGRESS, wxCommandEvent);
 
 CemuUpdateWindow::CemuUpdateWindow(wxWindow* parent)
-	: wxDialog(parent, wxID_ANY, "Cemu update", wxDefaultPosition, wxDefaultSize,
+	: wxDialog(parent, wxID_ANY, _("Cemu update"), wxDefaultPosition, wxDefaultSize,
 		wxCAPTION | wxMINIMIZE_BOX | wxSYSTEM_MENU | wxTAB_TRAVERSAL | wxCLOSE_BOX)
 {
 	auto* sizer = new wxBoxSizer(wxVERTICAL);
@@ -34,7 +40,7 @@ CemuUpdateWindow::CemuUpdateWindow(wxWindow* parent)
 	auto* rows = new wxFlexGridSizer(0, 2, 0, 0);
 	rows->AddGrowableCol(1);
 
-	m_text = new wxStaticText(this, wxID_ANY, "Checking for latest version...");
+	m_text = new wxStaticText(this, wxID_ANY, _("Checking for latest version..."));
 	rows->Add(m_text, 0, wxALL | wxALIGN_CENTER_VERTICAL, 5);
 
 	{
@@ -104,15 +110,17 @@ bool CemuUpdateWindow::QueryUpdateInfo(std::string& downloadUrlOut, std::string&
 	auto* curl = curl_easy_init();
 	urlStr.append(_curlUrlEscape(curl, BUILD_VERSION_STRING));
 #if BOOST_OS_LINUX
-	urlStr.append("&platform=linux");
+	urlStr.append("&platform=linux_appimage_x86");
 #elif BOOST_OS_WINDOWS
 	urlStr.append("&platform=windows");
 #elif BOOST_OS_MACOS
-	urlStr.append("&platform=macos_x86");
+	urlStr.append("&platform=macos_bundle_x86");
 #elif
-
 #error Name for current platform is missing
 #endif
+	const auto& config = GetConfig();
+	if(config.receive_untested_updates)
+		urlStr.append("&allowNewUpdates=1");
 
 	curl_easy_setopt(curl, CURLOPT_URL, urlStr.c_str());
 	curl_easy_setopt(curl, CURLOPT_FOLLOWLOCATION, 1);
@@ -129,7 +137,7 @@ bool CemuUpdateWindow::QueryUpdateInfo(std::string& downloadUrlOut, std::string&
 		curl_easy_getinfo(curl, CURLINFO_RESPONSE_CODE, &http_code);
 		if (http_code != 0 && http_code != 200)
 		{
-			forceLog_printf("Update check failed (http code: %d)", http_code);
+			cemuLog_log(LogType::Force, "Update check failed (http code: {})", http_code);
 			cemu_assert_debug(false);
 			return false;
 		}
@@ -153,7 +161,7 @@ bool CemuUpdateWindow::QueryUpdateInfo(std::string& downloadUrlOut, std::string&
 	}
 	else
 	{
-		forceLog_printf("Update check failed with CURL error %d", (int)cr);
+		cemuLog_log(LogType::Force, "Update check failed with CURL error {}", (int)cr);
 		cemu_assert_debug(false);
 	}
 
@@ -260,7 +268,7 @@ bool CemuUpdateWindow::DownloadCemuZip(const std::string& url, const fs::path& f
 		}
 		catch (const std::exception& ex)
 		{
-			forceLog_printf("can't remove update.zip on error: %s", ex.what());
+			cemuLog_log(LogType::Force, "can't remove update.zip on error: {}", ex.what());
 		}
 	}
 	return result;
@@ -308,13 +316,13 @@ bool CemuUpdateWindow::ExtractUpdate(const fs::path& zipname, const fs::path& ta
 				catch (const std::exception& ex)
 				{
 					SystemException sys(ex);
-					forceLog_printf("can't create folder \"%s\" for update: %s", sb.name, sys.what());
+					cemuLog_log(LogType::Force, "can't create folder \"{}\" for update: {}", sb.name, sys.what());
 				}
 				// the root should have only one Cemu_... directory, we track it here
 				if ((std::count(sb.name, sb.name + len, '/') + std::count(sb.name, sb.name + len, '\\')) == 1)
 				{
 					if (!cemuFolderName.empty())
-						forceLog_printf("update zip has multiple folders in root");
+						cemuLog_log(LogType::Force, "update zip has multiple folders in root");
 					cemuFolderName.assign(sb.name, len - 1);
 				}
 				continue;
@@ -324,7 +332,7 @@ bool CemuUpdateWindow::ExtractUpdate(const fs::path& zipname, const fs::path& ta
 			auto* zf = zip_fopen_index(za, i, 0);
 			if (!zf)
 			{
-				forceLog_printf("can't open zip file \"%s\"", sb.name);
+				cemuLog_log(LogType::Force, "can't open zip file \"{}\"", sb.name);
 				zip_close(za);
 				return false;
 			}
@@ -333,7 +341,7 @@ bool CemuUpdateWindow::ExtractUpdate(const fs::path& zipname, const fs::path& ta
 			const auto read = zip_fread(zf, buffer.data(), sb.size);
 			if (read != (sint64)sb.size)
 			{
-				forceLog_printf("could only read 0x%x of 0x%x bytes from zip file \"%s\"", read, sb.size, sb.name);
+				cemuLog_log(LogType::Force, "could only read 0x{:x} of 0x{:x} bytes from zip file \"{}\"", read, sb.size, sb.name);
 				zip_close(za);
 				return false;
 			}
@@ -341,7 +349,7 @@ bool CemuUpdateWindow::ExtractUpdate(const fs::path& zipname, const fs::path& ta
 			auto* file = fopen(fname.string().c_str(), "wb");
 			if (file == nullptr)
 			{
-				forceLog_printf("can't create update file \"%s\"", sb.name);
+				cemuLog_log(LogType::Force, "can't create update file \"{}\"", sb.name);
 				zip_close(za);
 				return false;
 			}
@@ -406,7 +414,13 @@ void CemuUpdateWindow::WorkerThread()
 				if (!exists(tmppath))
 					create_directory(tmppath);
 
+#if BOOST_OS_WINDOWS
 				const auto update_file = tmppath / L"update.zip";
+#elif BOOST_OS_LINUX
+				const auto update_file = tmppath / L"Cemu.AppImage";
+#elif BOOST_OS_MACOS
+				const auto update_file = tmppath / L"cemu.dmg";
+#endif	
 				if (DownloadCemuZip(url, update_file))
 				{
 					auto* event = new wxCommandEvent(wxEVT_RESULT);
@@ -426,6 +440,7 @@ void CemuUpdateWindow::WorkerThread()
 
 				// extract
 				std::string cemuFolderName;
+#if BOOST_OS_WINDOWS
 				if (!ExtractUpdate(update_file, tmppath, cemuFolderName))
 				{
 					cemuLog_log(LogType::Force, "Extracting Cemu zip failed");
@@ -436,7 +451,7 @@ void CemuUpdateWindow::WorkerThread()
 					cemuLog_log(LogType::Force, "Cemu folder not found in zip");
 					break;
 				}
-
+#endif
 				const auto expected_path = tmppath / cemuFolderName;
 				if (exists(expected_path))
 				{
@@ -459,7 +474,7 @@ void CemuUpdateWindow::WorkerThread()
 						catch (const std::exception& ex)
 						{
 							SystemException sys(ex);
-							forceLog_printf("can't remove extracted tmp files: %s", sys.what());
+							cemuLog_log(LogType::Force, "can't remove extracted tmp files: {}", sys.what());
 						}
 					}
 
@@ -470,16 +485,29 @@ void CemuUpdateWindow::WorkerThread()
 					break;
 
 				// apply update
-				std::wstring target_directory = ActiveSettings::GetPath().generic_wstring();
+				fs::path exePath = ActiveSettings::GetExecutablePath();
+#if BOOST_OS_WINDOWS
+				std::wstring target_directory = exePath.parent_path().generic_wstring();
 				if (target_directory[target_directory.size() - 1] == '/')
 					target_directory = target_directory.substr(0, target_directory.size() - 1); // remove trailing /
 
 				// get exe name
-				const auto exec = ActiveSettings::GetFullPath();
+				const auto exec = ActiveSettings::GetExecutablePath();
 				const auto target_exe = fs::path(exec).replace_extension("exe.backup");
 				fs::rename(exec, target_exe);
-				m_restartFile = exec;
-
+				m_restartFile = exec;				
+#elif BOOST_OS_LINUX
+				const char* appimage_path = std::getenv("APPIMAGE");
+				const auto target_exe = fs::path(appimage_path).replace_extension("AppImage.backup");
+				const char* filePath = update_file.c_str();
+				mode_t permissions = S_IRUSR | S_IWUSR | S_IXUSR | S_IRGRP | S_IXGRP | S_IROTH | S_IXOTH;
+				fs::rename(appimage_path, target_exe);
+				m_restartFile = appimage_path;
+				chmod(filePath, permissions);
+				wxString wxAppPath = wxString::FromUTF8(appimage_path);
+				wxCopyFile (wxT("/tmp/cemu_update/Cemu.AppImage"), wxAppPath);
+#endif
+#if BOOST_OS_WINDOWS
 				const auto index = expected_path.wstring().size();
 				int counter = 0;
 				for (const auto& it : fs::recursive_directory_iterator(expected_path))
@@ -504,17 +532,17 @@ void CemuUpdateWindow::WorkerThread()
 					catch (const std::exception& ex)
 					{
 						SystemException sys(ex);
-						forceLog_printf("applying update error: %s", sys.what());
+						cemuLog_log(LogType::Force, "applying update error: {}", sys.what());
 					}
 
-					if ((counter++ / 10) * 10 == counter)
+					if ((counter++ % 10) == 0)
 					{
 						auto* event = new wxCommandEvent(wxEVT_PROGRESS);
 						event->SetInt(counter);
 						wxQueueEvent(this, event);
 					}
 				}
-
+#endif
 				auto* event = new wxCommandEvent(wxEVT_PROGRESS);
 				event->SetInt(m_gaugeMaxValue);
 				wxQueueEvent(this, event);
@@ -527,7 +555,7 @@ void CemuUpdateWindow::WorkerThread()
 		catch (const std::exception& ex)
 		{
 			SystemException sys(ex);
-			forceLog_printf("update error: %s", sys.what());
+			cemuLog_log(LogType::Force, "update error: {}", sys.what());
 
 			// clean leftovers
 			if (exists(tmppath))
@@ -563,8 +591,24 @@ void CemuUpdateWindow::OnClose(wxCloseEvent& event)
 
 		exit(0);
 	}
-#else
-	cemuLog_log(LogType::Force, "unimplemented - restart on update");
+#elif BOOST_OS_LINUX
+	if (m_restartRequired && !m_restartFile.empty() && fs::exists(m_restartFile))
+	{
+		const char* appimage_path = std::getenv("APPIMAGE");
+		execlp(appimage_path, appimage_path, (char *)NULL);
+
+		exit(0);
+	}
+#elif BOOST_OS_MACOS
+	if (m_restartRequired)
+	{
+	    const auto tmppath = fs::temp_directory_path() / L"cemu_update/Cemu.dmg";
+	    fs::path exePath = ActiveSettings::GetExecutablePath().parent_path();
+	    const auto apppath = exePath / L"update.sh";
+	    execlp("sh", "sh", apppath.c_str(), NULL);
+        
+        exit(0);
+	}	
 #endif
 }
 
diff --git a/src/gui/ChecksumTool.cpp b/src/gui/ChecksumTool.cpp
index b8393330..526ceef9 100644
--- a/src/gui/ChecksumTool.cpp
+++ b/src/gui/ChecksumTool.cpp
@@ -81,8 +81,8 @@ const char kSchema[] = R"(
 
 
 ChecksumTool::ChecksumTool(wxWindow* parent, wxTitleManagerList::TitleEntry& entry)
-	: wxDialog(parent, wxID_ANY, 
-		wxStringFormat2(_("Title checksum of {:08x}-{:08x}"), (uint32)(entry.title_id >> 32), (uint32)(entry.title_id & 0xFFFFFFFF)), 
+	: wxDialog(parent, wxID_ANY,
+		formatWxString(_("Title checksum of {:08x}-{:08x}"), (uint32) (entry.title_id >> 32), (uint32) (entry.title_id & 0xFFFFFFFF)),
 		wxDefaultPosition, wxDefaultSize, wxCAPTION | wxFRAME_TOOL_WINDOW | wxSYSTEM_MENU | wxTAB_TRAVERSAL | wxCLOSE_BOX), m_entry(entry)
 {
 
@@ -134,7 +134,7 @@ ChecksumTool::ChecksumTool(wxWindow* parent, wxTitleManagerList::TitleEntry& ent
 				const auto title_id_str = fmt::format("{:016x}", m_json_entry.title_id);
 				const auto default_file = fmt::format("{}_v{}.json", title_id_str, m_info.GetAppTitleVersion());
 
-				const auto checksum_path = ActiveSettings::GetPath("resources/checksums/{}", default_file);
+				const auto checksum_path = ActiveSettings::GetUserDataPath("resources/checksums/{}", default_file);
 				if (exists(checksum_path))
 					m_verify_online->Enable();
 			}
@@ -186,7 +186,7 @@ void ChecksumTool::LoadOnlineData() const
 
 		std::string latest_commit;
 
-		const auto checksum_path = ActiveSettings::GetPath("resources/checksums");
+		const auto checksum_path = ActiveSettings::GetUserDataPath("resources/checksums");
 		if (exists(checksum_path))
 		{
 			std::string current_commit;
@@ -335,7 +335,7 @@ void ChecksumTool::LoadOnlineData() const
 	}
 	catch(const std::exception& ex)
 	{
-		forceLog_printf("error on updating json checksum data: %s", ex.what());
+		cemuLog_log(LogType::Force, "error on updating json checksum data: {}", ex.what());
 	}
 	
 	wxQueueEvent(m_verify_online, new wxCommandEvent(wxEVT_ENABLE));
@@ -413,7 +413,7 @@ void ChecksumTool::OnExportChecksums(wxCommandEvent& event)
 	}
 	else
 	{
-		wxMessageBox(wxStringFormat2(_("Can't write to file: {}"), target_file.string()), _("Error"), wxOK | wxCENTRE | wxICON_ERROR, this);
+		wxMessageBox(formatWxString(_("Can't write to file: {}"), target_file.string()), _("Error"), wxOK | wxCENTRE | wxICON_ERROR, this);
 	}
 }
 
@@ -461,17 +461,17 @@ void ChecksumTool::VerifyJsonEntry(const rapidjson::Document& doc)
 
 		if (m_json_entry.title_id != test_entry.title_id)
 		{
-			wxMessageBox(wxStringFormat2(_("The file you are comparing with is for a different title.")), _("Error"), wxOK | wxCENTRE | wxICON_ERROR, this);
+			wxMessageBox(formatWxString(_("The file you are comparing with is for a different title.")), _("Error"), wxOK | wxCENTRE | wxICON_ERROR, this);
 			return;
 		}
 		if (m_json_entry.version != test_entry.version)
 		{
-			wxMessageBox(wxStringFormat2(_("Wrong version: {}"), test_entry.version), _("Error"), wxOK | wxCENTRE | wxICON_ERROR, this);
+			wxMessageBox(formatWxString(_("Wrong version: {}"), test_entry.version), _("Error"), wxOK | wxCENTRE | wxICON_ERROR, this);
 			return;
 		}
 		if (m_json_entry.region != test_entry.region)
 		{
-			wxMessageBox(wxStringFormat2(_("Wrong region: {}"), test_entry.region), _("Error"), wxOK | wxCENTRE | wxICON_ERROR, this);
+			wxMessageBox(formatWxString(_("Wrong region: {}"), test_entry.region), _("Error"), wxOK | wxCENTRE | wxICON_ERROR, this);
 			return;
 		}
 		if (!m_json_entry.wud_hash.empty())
@@ -483,7 +483,7 @@ void ChecksumTool::VerifyJsonEntry(const rapidjson::Document& doc)
 			}
 			if(!boost::iequals(test_entry.wud_hash, m_json_entry.wud_hash))
 			{
-				wxMessageBox(wxStringFormat2(_("Your game image is invalid!\n\nYour hash:\n{}\n\nExpected hash:\n{}"), m_json_entry.wud_hash, test_entry.wud_hash), _("Error"), wxOK | wxCENTRE | wxICON_ERROR, this);
+				wxMessageBox(formatWxString(_("Your game image is invalid!\n\nYour hash:\n{}\n\nExpected hash:\n{}"), m_json_entry.wud_hash, test_entry.wud_hash), _("Error"), wxOK | wxCENTRE | wxICON_ERROR, this);
 				return;
 			}
 		}
@@ -563,7 +563,9 @@ void ChecksumTool::VerifyJsonEntry(const rapidjson::Document& doc)
 			}
 			else if (missing_files.empty() && !invalid_hashes.empty())
 			{
-				const int result = wxMessageBox(wxStringFormat2(_("{} files have an invalid hash!\nDo you want to export a list of them to a file?"), invalid_hashes.size()), _("Error"), wxYES_NO | wxCENTRE | wxICON_ERROR, this);
+				const int result = wxMessageBox(formatWxString(
+						_("{} files have an invalid hash!\nDo you want to export a list of them to a file?"),
+						invalid_hashes.size()), _("Error"), wxYES_NO | wxCENTRE | wxICON_ERROR, this);
 				if (result == wxYES)
 				{
 					writeMismatchInfoToLog();
@@ -572,7 +574,9 @@ void ChecksumTool::VerifyJsonEntry(const rapidjson::Document& doc)
 			}
 			else if (!missing_files.empty() && !invalid_hashes.empty())
 			{
-				const int result = wxMessageBox(wxStringFormat2(_("Multiple issues with your game files have been found!\nDo you want to export them to a file?"), invalid_hashes.size()), _("Error"), wxYES_NO | wxCENTRE | wxICON_ERROR, this);
+				const int result = wxMessageBox(formatWxString(
+						_("Multiple issues with your game files have been found!\nDo you want to export them to a file?"),
+						invalid_hashes.size()), _("Error"), wxYES_NO | wxCENTRE | wxICON_ERROR, this);
 				if (result == wxYES)
 				{
 					writeMismatchInfoToLog();
@@ -584,7 +588,7 @@ void ChecksumTool::VerifyJsonEntry(const rapidjson::Document& doc)
 	}
 	catch (const std::exception& ex)
 	{
-		wxMessageBox(wxStringFormat2(_("JSON parse error: {}"), ex.what()), _("Error"), wxOK | wxCENTRE | wxICON_ERROR, this);
+		wxMessageBox(formatWxString(_("JSON parse error: {}"), ex.what()), _("Error"), wxOK | wxCENTRE | wxICON_ERROR, this);
 	}
 
 }
@@ -594,7 +598,7 @@ void ChecksumTool::OnVerifyOnline(wxCommandEvent& event)
 	const auto title_id_str = fmt::format("{:016x}", m_json_entry.title_id);
 	const auto default_file = fmt::format("{}_v{}.json", title_id_str, m_info.GetAppTitleVersion());
 	
-	const auto checksum_path = ActiveSettings::GetPath("resources/checksums/{}", default_file);
+	const auto checksum_path = ActiveSettings::GetUserDataPath("resources/checksums/{}", default_file);
 	if(!exists(checksum_path))
 		return;
 	
@@ -610,7 +614,7 @@ void ChecksumTool::OnVerifyOnline(wxCommandEvent& event)
 	d.ParseStream(str);
 	if (d.HasParseError())
 	{
-		wxMessageBox(_("Can't parse json file!"), _("Error"), wxOK | wxCENTRE | wxICON_ERROR, this);
+		wxMessageBox(_("Can't parse JSON file!"), _("Error"), wxOK | wxCENTRE | wxICON_ERROR, this);
 		return;
 	}
 
@@ -638,7 +642,7 @@ void ChecksumTool::OnVerifyLocal(wxCommandEvent& event)
 	d.ParseStream(str);
 	if (d.HasParseError())
 	{
-		wxMessageBox(_("Can't parse json file!"), _("Error"), wxOK | wxCENTRE | wxICON_ERROR, this);
+		wxMessageBox(_("Can't parse JSON file!"), _("Error"), wxOK | wxCENTRE | wxICON_ERROR, this);
 		return;
 	}
 
@@ -680,7 +684,7 @@ void ChecksumTool::DoWork()
 	case TitleInfo::TitleDataFormat::WUD:
 	{
 		const auto path = m_entry.path.string();
-		wxQueueEvent(this, new wxSetGaugeValue(1, m_progress, m_status, wxStringFormat2(_("Reading game image: {}"), path)));
+		wxQueueEvent(this, new wxSetGaugeValue(1, m_progress, m_status, formatWxString(_("Reading game image: {}"), path)));
 
 		wud_t* wud = wud_open(m_info.GetPath());
 		if (!wud)
@@ -709,11 +713,11 @@ void ChecksumTool::DoWork()
 
 			EVP_DigestUpdate(sha256, buffer.data(), read);
 
-			wxQueueEvent(this, new wxSetGaugeValue((int)((offset * 90) / wud_size), m_progress, m_status, wxStringFormat2(_("Reading game image: {0}/{1} kB"), offset / 1024, wud_size / 1024)));
+			wxQueueEvent(this, new wxSetGaugeValue((int)((offset * 90) / wud_size), m_progress, m_status, formatWxString(_("Reading game image: {0}/{1} kB"), offset / 1024, wud_size / 1024)));
 		} while (read != 0 && size > 0);
 		wud_close(wud);
 
-		wxQueueEvent(this, new wxSetGaugeValue(90, m_progress, m_status, wxStringFormat2(_("Generating checksum of game image: {}"), path)));
+		wxQueueEvent(this, new wxSetGaugeValue(90, m_progress, m_status, formatWxString(_("Generating checksum of game image: {}"), path)));
 
 		if (!m_running.load(std::memory_order_relaxed))
 			return;
@@ -729,7 +733,7 @@ void ChecksumTool::DoWork()
 
 		m_json_entry.wud_hash = str.str();
 
-		wxQueueEvent(this, new wxSetGaugeValue(100, m_progress, m_status, wxStringFormat2(_("Generated checksum of game image: {}"), path)));
+		wxQueueEvent(this, new wxSetGaugeValue(100, m_progress, m_status, formatWxString(_("Generated checksum of game image: {}"), path)));
 		break;
 	}
 	default:
@@ -765,7 +769,7 @@ void ChecksumTool::DoWork()
 			m_json_entry.file_hashes[filename] = str.str();
 
 			++counter;
-			wxQueueEvent(this, new wxSetGaugeValue((int)((counter * 100) / file_count), m_progress, m_status, wxStringFormat2(_("Hashing game file: {}/{}"), counter, file_count)));
+			wxQueueEvent(this, new wxSetGaugeValue((int)((counter * 100) / file_count), m_progress, m_status, formatWxString(_("Hashing game file: {}/{}"), counter, file_count)));
 
 			if (!m_running.load(std::memory_order_relaxed))
 			{
@@ -775,7 +779,7 @@ void ChecksumTool::DoWork()
 		}
 		m_info.Unmount(temporaryMountPath.c_str());
 
-		wxQueueEvent(this, new wxSetGaugeValue(100, m_progress, m_status, wxStringFormat2(_("Generated checksum of {} game files"), file_count)));
+		wxQueueEvent(this, new wxSetGaugeValue(100, m_progress, m_status, formatWxString(_("Generated checksum of {} game files"), file_count)));
 		break;
 	}
-}
\ No newline at end of file
+}
diff --git a/src/gui/DownloadGraphicPacksWindow.cpp b/src/gui/DownloadGraphicPacksWindow.cpp
index 973b7c57..f2a90959 100644
--- a/src/gui/DownloadGraphicPacksWindow.cpp
+++ b/src/gui/DownloadGraphicPacksWindow.cpp
@@ -65,7 +65,7 @@ bool DownloadGraphicPacksWindow::curlDownloadFile(const char *url, curlDownloadF
 bool checkGraphicPackDownloadedVersion(const char* nameVersion, bool& hasVersionFile)
 {
 	hasVersionFile = false;
-	const auto path = ActiveSettings::GetPath("graphicPacks/downloadedGraphicPacks/version.txt");
+	const auto path = ActiveSettings::GetUserDataPath("graphicPacks/downloadedGraphicPacks/version.txt");
 	std::unique_ptr<FileStream> file(FileStream::openFile2(path));
 
 	std::string versionInFile;
@@ -78,19 +78,19 @@ bool checkGraphicPackDownloadedVersion(const char* nameVersion, bool& hasVersion
 
 void createGraphicPackDownloadedVersionFile(const char* nameVersion)
 {
-	const auto path = ActiveSettings::GetPath("graphicPacks/downloadedGraphicPacks/version.txt");
+	const auto path = ActiveSettings::GetUserDataPath("graphicPacks/downloadedGraphicPacks/version.txt");
 	std::unique_ptr<FileStream> file(FileStream::createFile2(path));
 	if (file)
 		file->writeString(nameVersion);
 	else
 	{
-		cemuLog_force("Failed to write graphic pack version.txt");
+		cemuLog_log(LogType::Force, "Failed to write graphic pack version.txt");
 	}
 }
 
 void deleteDownloadedGraphicPacks()
 {
-	const auto path = ActiveSettings::GetPath("graphicPacks/downloadedGraphicPacks");
+	const auto path = ActiveSettings::GetUserDataPath("graphicPacks/downloadedGraphicPacks");
 	std::error_code er;
 	if (!fs::exists(path, er))
 		return;
@@ -110,20 +110,12 @@ void deleteDownloadedGraphicPacks()
 
 void DownloadGraphicPacksWindow::UpdateThread()
 {
-	if (CafeSystem::IsTitleRunning())
-	{
-		wxMessageBox(_("Graphic packs cannot be updated while a game is running."), _("Graphic packs"), 5, this->GetParent());
-		// cancel update
-		m_threadState = ThreadFinished;
-		return;
-	}
-	
 	// get github url
 	std::string githubAPIUrl;
 	curlDownloadFileState_t tempDownloadState;
 	std::string queryUrl("https://cemu.info/api2/query_graphicpack_url.php?");
 	char temp[64];
-	sprintf(temp, "version=%d.%d.%d", EMULATOR_VERSION_LEAD, EMULATOR_VERSION_MAJOR, EMULATOR_VERSION_MINOR);
+	sprintf(temp, "version=%d.%d.%d", EMULATOR_VERSION_MAJOR, EMULATOR_VERSION_MINOR, EMULATOR_VERSION_PATCH);
 	queryUrl.append(temp);
 	queryUrl.append("&");
 	sprintf(temp, "t=%u", (uint32)std::chrono::seconds(std::time(NULL)).count()); // add a dynamic part to the url to bypass overly aggressive caching (like some proxies do)
@@ -136,8 +128,8 @@ void DownloadGraphicPacksWindow::UpdateThread()
 	else
 	{
 		// cemu api request failed, use hardcoded github url
-		forceLog_printf("Graphic pack update request failed or returned invalid URL. Using default repository URL instead");
-		githubAPIUrl = "https://api.github.com/repos/slashiee/cemu_graphic_packs/releases/latest";
+		cemuLog_log(LogType::Force, "Graphic pack update request failed or returned invalid URL. Using default repository URL instead");
+		githubAPIUrl = "https://api.github.com/repos/cemu-project/cemu_graphic_packs/releases/latest";
 	}
 	// github API request
 	if (curlDownloadFile(githubAPIUrl.c_str(), &tempDownloadState) == false)
@@ -190,14 +182,14 @@ void DownloadGraphicPacksWindow::UpdateThread()
 	if (checkGraphicPackDownloadedVersion(assetName, hasVersionFile))
 	{
 		// already up to date
-		wxMessageBox(_("No updates available."), _("Graphic packs"), wxOK | wxCENTRE, this->GetParent());
+		wxMessageBox(_("No updates available."), _("Graphic packs"), wxOK | wxCENTRE, this);
 		m_threadState = ThreadFinished;
 		return;
 	}
 	if (hasVersionFile)
 	{
 		// if a version file already exists (and graphic packs are installed) ask the user if he really wants to update
-		if (wxMessageBox(_("Updated graphic packs are available. Do you want to download and install them?"), _("Graphic packs"), wxYES_NO, this->GetParent()) != wxYES)
+		if (wxMessageBox(_("Updated graphic packs are available. Do you want to download and install them?"), _("Graphic packs"), wxYES_NO, this) != wxYES)
 		{
 			// cancel update
 			m_threadState = ThreadFinished;
@@ -238,7 +230,7 @@ void DownloadGraphicPacksWindow::UpdateThread()
 		return;
 	}
 
-	auto path = ActiveSettings::GetPath("graphicPacks/downloadedGraphicPacks");
+	auto path = ActiveSettings::GetUserDataPath("graphicPacks/downloadedGraphicPacks");
 	std::error_code er;
 	//fs::remove_all(path, er); -> Don't delete the whole folder and recreate it immediately afterwards because sometimes it just fails
 	deleteDownloadedGraphicPacks();
@@ -258,7 +250,7 @@ void DownloadGraphicPacksWindow::UpdateThread()
 			std::strstr(sb.name, "..\\") != nullptr)
 			continue; // bad path
 
-		path = ActiveSettings::GetPath("graphicPacks/downloadedGraphicPacks/{}", sb.name);
+		path = ActiveSettings::GetUserDataPath("graphicPacks/downloadedGraphicPacks/{}", sb.name);
 
 		size_t sbNameLen = strlen(sb.name);
 		if(sbNameLen == 0)
@@ -326,8 +318,6 @@ DownloadGraphicPacksWindow::DownloadGraphicPacksWindow(wxWindow* parent)
 
 
 	m_downloadState = std::make_unique<curlDownloadFileState_t>();
-
-	m_thread = std::thread(&DownloadGraphicPacksWindow::UpdateThread, this);
 }
 
 DownloadGraphicPacksWindow::~DownloadGraphicPacksWindow()
@@ -344,6 +334,12 @@ const std::string& DownloadGraphicPacksWindow::GetException() const
 
 int DownloadGraphicPacksWindow::ShowModal()
 {
+	if(CafeSystem::IsTitleRunning())
+	{
+		wxMessageBox(_("Graphic packs cannot be updated while a game is running."), _("Graphic packs"), 5, this);
+		return wxID_CANCEL;
+	}
+	m_thread = std::thread(&DownloadGraphicPacksWindow::UpdateThread, this);
 	wxDialog::ShowModal();
 	return m_threadState == ThreadCanceled ? wxID_CANCEL : wxID_OK;
 }
diff --git a/src/gui/EmulatedUSBDevices/EmulatedUSBDeviceFrame.cpp b/src/gui/EmulatedUSBDevices/EmulatedUSBDeviceFrame.cpp
new file mode 100644
index 00000000..53e3b995
--- /dev/null
+++ b/src/gui/EmulatedUSBDevices/EmulatedUSBDeviceFrame.cpp
@@ -0,0 +1,834 @@
+#include "EmulatedUSBDeviceFrame.h"
+
+#include <algorithm>
+
+#include "config/CemuConfig.h"
+#include "gui/helpers/wxHelpers.h"
+#include "gui/wxHelper.h"
+#include "util/helpers/helpers.h"
+
+#include "Cafe/OS/libs/nsyshid/nsyshid.h"
+#include "Cafe/OS/libs/nsyshid/Dimensions.h"
+
+#include "Common/FileStream.h"
+
+#include <wx/arrstr.h>
+#include <wx/button.h>
+#include <wx/combobox.h>
+#include <wx/checkbox.h>
+#include <wx/combobox.h>
+#include <wx/filedlg.h>
+#include <wx/log.h>
+#include <wx/msgdlg.h>
+#include <wx/notebook.h>
+#include <wx/panel.h>
+#include <wx/sizer.h>
+#include <wx/statbox.h>
+#include <wx/stattext.h>
+#include <wx/stream.h>
+#include <wx/textctrl.h>
+#include <wx/textentry.h>
+#include <wx/valnum.h>
+#include <wx/wfstream.h>
+
+#include "resource/embedded/resources.h"
+
+EmulatedUSBDeviceFrame::EmulatedUSBDeviceFrame(wxWindow* parent)
+	: wxFrame(parent, wxID_ANY, _("Emulated USB Devices"), wxDefaultPosition,
+			  wxDefaultSize, wxDEFAULT_FRAME_STYLE | wxTAB_TRAVERSAL)
+{
+	SetIcon(wxICON(X_BOX));
+
+	auto& config = GetConfig();
+
+	auto* sizer = new wxBoxSizer(wxVERTICAL);
+	auto* notebook = new wxNotebook(this, wxID_ANY);
+
+	notebook->AddPage(AddSkylanderPage(notebook), _("Skylanders Portal"));
+	notebook->AddPage(AddInfinityPage(notebook), _("Infinity Base"));
+	notebook->AddPage(AddDimensionsPage(notebook), _("Dimensions Toypad"));
+
+	sizer->Add(notebook, 1, wxEXPAND | wxALL, 2);
+
+	SetSizerAndFit(sizer);
+	Layout();
+	Centre(wxBOTH);
+}
+
+EmulatedUSBDeviceFrame::~EmulatedUSBDeviceFrame() {}
+
+wxPanel* EmulatedUSBDeviceFrame::AddSkylanderPage(wxNotebook* notebook)
+{
+	auto* panel = new wxPanel(notebook);
+	auto* panelSizer = new wxBoxSizer(wxVERTICAL);
+	auto* box = new wxStaticBox(panel, wxID_ANY, _("Skylanders Manager"));
+	auto* boxSizer = new wxStaticBoxSizer(box, wxVERTICAL);
+
+	auto* row = new wxBoxSizer(wxHORIZONTAL);
+
+	m_emulatePortal =
+		new wxCheckBox(box, wxID_ANY, _("Emulate Skylander Portal"));
+	m_emulatePortal->SetValue(
+		GetConfig().emulated_usb_devices.emulate_skylander_portal);
+	m_emulatePortal->Bind(wxEVT_CHECKBOX, [this](wxCommandEvent&) {
+		GetConfig().emulated_usb_devices.emulate_skylander_portal =
+			m_emulatePortal->IsChecked();
+		g_config.Save();
+	});
+	row->Add(m_emulatePortal, 1, wxEXPAND | wxALL, 2);
+	boxSizer->Add(row, 1, wxEXPAND | wxALL, 2);
+	for (int i = 0; i < nsyshid::MAX_SKYLANDERS; i++)
+	{
+		boxSizer->Add(AddSkylanderRow(i, box), 1, wxEXPAND | wxALL, 2);
+	}
+	panelSizer->Add(boxSizer, 1, wxEXPAND | wxALL, 2);
+	panel->SetSizerAndFit(panelSizer);
+
+	return panel;
+}
+
+wxPanel* EmulatedUSBDeviceFrame::AddInfinityPage(wxNotebook* notebook)
+{
+	auto* panel = new wxPanel(notebook);
+	auto* panelSizer = new wxBoxSizer(wxVERTICAL);
+	auto* box = new wxStaticBox(panel, wxID_ANY, _("Infinity Manager"));
+	auto* boxSizer = new wxStaticBoxSizer(box, wxVERTICAL);
+
+	auto* row = new wxBoxSizer(wxHORIZONTAL);
+
+	m_emulateBase =
+		new wxCheckBox(box, wxID_ANY, _("Emulate Infinity Base"));
+	m_emulateBase->SetValue(
+		GetConfig().emulated_usb_devices.emulate_infinity_base);
+	m_emulateBase->Bind(wxEVT_CHECKBOX, [this](wxCommandEvent&) {
+		GetConfig().emulated_usb_devices.emulate_infinity_base =
+			m_emulateBase->IsChecked();
+		g_config.Save();
+	});
+	row->Add(m_emulateBase, 1, wxEXPAND | wxALL, 2);
+	boxSizer->Add(row, 1, wxEXPAND | wxALL, 2);
+	boxSizer->Add(AddInfinityRow("Play Set/Power Disc", 0, box), 1, wxEXPAND | wxALL, 2);
+	boxSizer->Add(AddInfinityRow("Power Disc Two", 1, box), 1, wxEXPAND | wxALL, 2);
+	boxSizer->Add(AddInfinityRow("Power Disc Three", 2, box), 1, wxEXPAND | wxALL, 2);
+	boxSizer->Add(AddInfinityRow("Player One", 3, box), 1, wxEXPAND | wxALL, 2);
+	boxSizer->Add(AddInfinityRow("Player One Ability One", 4, box), 1, wxEXPAND | wxALL, 2);
+	boxSizer->Add(AddInfinityRow("Player One Ability Two", 5, box), 1, wxEXPAND | wxALL, 2);
+	boxSizer->Add(AddInfinityRow("Player Two", 6, box), 1, wxEXPAND | wxALL, 2);
+	boxSizer->Add(AddInfinityRow("Player Two Ability One", 7, box), 1, wxEXPAND | wxALL, 2);
+	boxSizer->Add(AddInfinityRow("Player Two Ability Two", 8, box), 1, wxEXPAND | wxALL, 2);
+
+	panelSizer->Add(boxSizer, 1, wxEXPAND | wxALL, 2);
+	panel->SetSizerAndFit(panelSizer);
+
+	return panel;
+}
+
+wxPanel* EmulatedUSBDeviceFrame::AddDimensionsPage(wxNotebook* notebook)
+{
+	auto* panel = new wxPanel(notebook);
+	auto* panel_sizer = new wxBoxSizer(wxVERTICAL);
+	auto* box = new wxStaticBox(panel, wxID_ANY, _("Dimensions Manager"));
+	auto* box_sizer = new wxStaticBoxSizer(box, wxVERTICAL);
+
+	auto* row = new wxBoxSizer(wxHORIZONTAL);
+
+	m_emulateToypad =
+		new wxCheckBox(box, wxID_ANY, _("Emulate Dimensions Toypad"));
+	m_emulateToypad->SetValue(
+		GetConfig().emulated_usb_devices.emulate_dimensions_toypad);
+	m_emulateToypad->Bind(wxEVT_CHECKBOX, [this](wxCommandEvent&) {
+		GetConfig().emulated_usb_devices.emulate_dimensions_toypad =
+			m_emulateToypad->IsChecked();
+		g_config.Save();
+	});
+	row->Add(m_emulateToypad, 1, wxEXPAND | wxALL, 2);
+	box_sizer->Add(row, 1, wxEXPAND | wxALL, 2);
+	auto* top_row = new wxBoxSizer(wxHORIZONTAL);
+	auto* bottom_row = new wxBoxSizer(wxHORIZONTAL);
+
+	top_row->Add(AddDimensionPanel(2, 0, box), 1, wxEXPAND | wxALL, 2);
+	top_row->Add(0, 0, 1, wxEXPAND | wxLEFT | wxRIGHT, 2);
+	top_row->Add(AddDimensionPanel(1, 1, box), 1, wxEXPAND | wxALL, 2);
+	top_row->Add(0, 0, 1, wxEXPAND | wxLEFT | wxRIGHT, 2);
+	top_row->Add(AddDimensionPanel(3, 2, box), 1, wxEXPAND | wxALL, 2);
+
+	bottom_row->Add(AddDimensionPanel(2, 3, box), 1, wxEXPAND | wxALL, 2);
+	bottom_row->Add(AddDimensionPanel(2, 4, box), 1, wxEXPAND | wxALL, 2);
+	bottom_row->Add(0, 0, 1, wxEXPAND | wxLEFT | wxRIGHT, 0);
+	bottom_row->Add(AddDimensionPanel(3, 5, box), 1, wxEXPAND | wxALL, 2);
+	bottom_row->Add(AddDimensionPanel(3, 6, box), 1, wxEXPAND | wxALL, 2);
+
+	box_sizer->Add(top_row, 1, wxEXPAND | wxALL, 2);
+	box_sizer->Add(bottom_row, 1, wxEXPAND | wxALL, 2);
+	panel_sizer->Add(box_sizer, 1, wxEXPAND | wxALL, 2);
+	panel->SetSizerAndFit(panel_sizer);
+
+	return panel;
+}
+
+wxBoxSizer* EmulatedUSBDeviceFrame::AddSkylanderRow(uint8 rowNumber, wxStaticBox* box)
+{
+	auto* row = new wxBoxSizer(wxHORIZONTAL);
+
+	row->Add(new wxStaticText(box, wxID_ANY,
+							  fmt::format("{} {}", _("Skylander").ToStdString(),
+										  (rowNumber + 1))),
+			 1, wxEXPAND | wxALL, 2);
+	m_skylanderSlots[rowNumber] =
+		new wxTextCtrl(box, wxID_ANY, _("None"), wxDefaultPosition, wxDefaultSize,
+					   wxTE_READONLY);
+	m_skylanderSlots[rowNumber]->SetMinSize(wxSize(150, -1));
+	m_skylanderSlots[rowNumber]->Disable();
+	row->Add(m_skylanderSlots[rowNumber], 1, wxEXPAND | wxALL, 2);
+	auto* loadButton = new wxButton(box, wxID_ANY, _("Load"));
+	loadButton->Bind(wxEVT_BUTTON, [rowNumber, this](wxCommandEvent&) {
+		LoadSkylander(rowNumber);
+	});
+	auto* createButton = new wxButton(box, wxID_ANY, _("Create"));
+	createButton->Bind(wxEVT_BUTTON, [rowNumber, this](wxCommandEvent&) {
+		CreateSkylander(rowNumber);
+	});
+	auto* clearButton = new wxButton(box, wxID_ANY, _("Clear"));
+	clearButton->Bind(wxEVT_BUTTON, [rowNumber, this](wxCommandEvent&) {
+		ClearSkylander(rowNumber);
+	});
+	row->Add(loadButton, 1, wxEXPAND | wxALL, 2);
+	row->Add(createButton, 1, wxEXPAND | wxALL, 2);
+	row->Add(clearButton, 1, wxEXPAND | wxALL, 2);
+
+	return row;
+}
+
+wxBoxSizer* EmulatedUSBDeviceFrame::AddInfinityRow(wxString name, uint8 rowNumber, wxStaticBox* box)
+{
+	auto* row = new wxBoxSizer(wxHORIZONTAL);
+
+	row->Add(new wxStaticText(box, wxID_ANY, name), 1, wxEXPAND | wxALL, 2);
+	m_infinitySlots[rowNumber] =
+		new wxTextCtrl(box, wxID_ANY, _("None"), wxDefaultPosition, wxDefaultSize,
+					   wxTE_READONLY);
+	m_infinitySlots[rowNumber]->SetMinSize(wxSize(150, -1));
+	m_infinitySlots[rowNumber]->Disable();
+	row->Add(m_infinitySlots[rowNumber], 1, wxALL | wxEXPAND, 5);
+	auto* loadButton = new wxButton(box, wxID_ANY, _("Load"));
+	loadButton->Bind(wxEVT_BUTTON, [rowNumber, this](wxCommandEvent&) {
+		LoadFigure(rowNumber);
+	});
+	auto* createButton = new wxButton(box, wxID_ANY, _("Create"));
+	createButton->Bind(wxEVT_BUTTON, [rowNumber, this](wxCommandEvent&) {
+		CreateFigure(rowNumber);
+	});
+	auto* clearButton = new wxButton(box, wxID_ANY, _("Clear"));
+	clearButton->Bind(wxEVT_BUTTON, [rowNumber, this](wxCommandEvent&) {
+		ClearFigure(rowNumber);
+	});
+	row->Add(loadButton, 1, wxEXPAND | wxALL, 2);
+	row->Add(createButton, 1, wxEXPAND | wxALL, 2);
+	row->Add(clearButton, 1, wxEXPAND | wxALL, 2);
+
+	return row;
+}
+
+wxBoxSizer* EmulatedUSBDeviceFrame::AddDimensionPanel(uint8 pad, uint8 index, wxStaticBox* box)
+{
+	auto* panel = new wxBoxSizer(wxVERTICAL);
+
+	auto* combo_row = new wxBoxSizer(wxHORIZONTAL);
+	m_dimensionSlots[index] = new wxTextCtrl(box, wxID_ANY, _("None"), wxDefaultPosition, wxDefaultSize,
+											 wxTE_READONLY);
+	combo_row->Add(m_dimensionSlots[index], 1, wxEXPAND | wxALL, 2);
+	auto* move_button = new wxButton(box, wxID_ANY, _("Move"));
+	move_button->Bind(wxEVT_BUTTON, [pad, index, this](wxCommandEvent&) {
+		MoveMinifig(pad, index);
+	});
+
+	combo_row->Add(move_button, 1, wxEXPAND | wxALL, 2);
+
+	auto* button_row = new wxBoxSizer(wxHORIZONTAL);
+	auto* load_button = new wxButton(box, wxID_ANY, _("Load"));
+	load_button->Bind(wxEVT_BUTTON, [pad, index, this](wxCommandEvent&) {
+		LoadMinifig(pad, index);
+	});
+	auto* clear_button = new wxButton(box, wxID_ANY, _("Clear"));
+	clear_button->Bind(wxEVT_BUTTON, [pad, index, this](wxCommandEvent&) {
+		ClearMinifig(pad, index);
+	});
+	auto* create_button = new wxButton(box, wxID_ANY, _("Create"));
+	create_button->Bind(wxEVT_BUTTON, [pad, index, this](wxCommandEvent&) {
+		CreateMinifig(pad, index);
+	});
+	button_row->Add(clear_button, 1, wxEXPAND | wxALL, 2);
+	button_row->Add(create_button, 1, wxEXPAND | wxALL, 2);
+	button_row->Add(load_button, 1, wxEXPAND | wxALL, 2);
+
+	panel->Add(combo_row, 1, wxEXPAND | wxALL, 2);
+	panel->Add(button_row, 1, wxEXPAND | wxALL, 2);
+
+	return panel;
+}
+
+void EmulatedUSBDeviceFrame::LoadSkylander(uint8 slot)
+{
+	wxFileDialog openFileDialog(this, _("Open Skylander dump"), "", "",
+								"Skylander files (*.sky;*.bin;*.dump;*.dmp)|*.sky;*.bin;*.dump;*.dmp",
+								wxFD_OPEN | wxFD_FILE_MUST_EXIST);
+	if (openFileDialog.ShowModal() != wxID_OK || openFileDialog.GetPath().empty())
+		return;
+
+	LoadSkylanderPath(slot, openFileDialog.GetPath());
+}
+
+void EmulatedUSBDeviceFrame::LoadSkylanderPath(uint8 slot, wxString path)
+{
+	std::unique_ptr<FileStream> skyFile(FileStream::openFile2(_utf8ToPath(path.utf8_string()), true));
+	if (!skyFile)
+	{
+		wxMessageDialog open_error(this, "Error Opening File: " + path);
+		open_error.ShowModal();
+		return;
+	}
+
+	std::array<uint8, nsyshid::SKY_FIGURE_SIZE> fileData;
+	if (skyFile->readData(fileData.data(), fileData.size()) != fileData.size())
+	{
+		wxMessageDialog open_error(this, "Failed to read file! File was too small");
+		open_error.ShowModal();
+		return;
+	}
+	ClearSkylander(slot);
+
+	uint16 skyId = uint16(fileData[0x11]) << 8 | uint16(fileData[0x10]);
+	uint16 skyVar = uint16(fileData[0x1D]) << 8 | uint16(fileData[0x1C]);
+
+	uint8 portalSlot = nsyshid::g_skyportal.LoadSkylander(fileData.data(),
+														  std::move(skyFile));
+	m_skySlots[slot] = std::tuple(portalSlot, skyId, skyVar);
+	UpdateSkylanderEdits();
+}
+
+void EmulatedUSBDeviceFrame::CreateSkylander(uint8 slot)
+{
+	CreateSkylanderDialog create_dlg(this, slot);
+	create_dlg.ShowModal();
+	if (create_dlg.GetReturnCode() == 1)
+	{
+		LoadSkylanderPath(slot, create_dlg.GetFilePath());
+	}
+}
+
+void EmulatedUSBDeviceFrame::ClearSkylander(uint8 slot)
+{
+	if (auto slotInfos = m_skySlots[slot])
+	{
+		auto [curSlot, id, var] = slotInfos.value();
+		nsyshid::g_skyportal.RemoveSkylander(curSlot);
+		m_skySlots[slot] = {};
+		UpdateSkylanderEdits();
+	}
+}
+
+CreateSkylanderDialog::CreateSkylanderDialog(wxWindow* parent, uint8 slot)
+	: wxDialog(parent, wxID_ANY, _("Skylander Figure Creator"), wxDefaultPosition, wxSize(500, 150))
+{
+	auto* sizer = new wxBoxSizer(wxVERTICAL);
+
+	auto* comboRow = new wxBoxSizer(wxHORIZONTAL);
+
+	auto* comboBox = new wxComboBox(this, wxID_ANY);
+	comboBox->Append("---Select---", reinterpret_cast<void*>(0xFFFFFFFF));
+	wxArrayString filterlist;
+	for (const auto& it : nsyshid::g_skyportal.GetListSkylanders())
+	{
+		const uint32 variant = uint32(uint32(it.first.first) << 16) | uint32(it.first.second);
+		comboBox->Append(it.second, reinterpret_cast<void*>(variant));
+		filterlist.Add(it.second);
+	}
+	comboBox->SetSelection(0);
+	bool enabled = comboBox->AutoComplete(filterlist);
+	comboRow->Add(comboBox, 1, wxEXPAND | wxALL, 2);
+
+	auto* idVarRow = new wxBoxSizer(wxHORIZONTAL);
+
+	wxIntegerValidator<uint32> validator;
+
+	auto* labelId = new wxStaticText(this, wxID_ANY, "ID:");
+	auto* labelVar = new wxStaticText(this, wxID_ANY, "Variant:");
+	auto* editId = new wxTextCtrl(this, wxID_ANY, _("0"), wxDefaultPosition, wxDefaultSize, 0, validator);
+	auto* editVar = new wxTextCtrl(this, wxID_ANY, _("0"), wxDefaultPosition, wxDefaultSize, 0, validator);
+
+	idVarRow->Add(labelId, 1, wxALL, 5);
+	idVarRow->Add(editId, 1, wxALL, 5);
+	idVarRow->Add(labelVar, 1, wxALL, 5);
+	idVarRow->Add(editVar, 1, wxALL, 5);
+
+	auto* buttonRow = new wxBoxSizer(wxHORIZONTAL);
+
+	auto* createButton = new wxButton(this, wxID_ANY, _("Create"));
+	createButton->Bind(wxEVT_BUTTON, [editId, editVar, this](wxCommandEvent&) {
+		long longSkyId;
+		if (!editId->GetValue().ToLong(&longSkyId) || longSkyId > 0xFFFF)
+		{
+			wxMessageDialog idError(this, "Error Converting ID!", "ID Entered is Invalid");
+			idError.ShowModal();
+			return;
+		}
+		long longSkyVar;
+		if (!editVar->GetValue().ToLong(&longSkyVar) || longSkyVar > 0xFFFF)
+		{
+			wxMessageDialog idError(this, "Error Converting Variant!", "Variant Entered is Invalid");
+			idError.ShowModal();
+			return;
+		}
+		uint16 skyId = longSkyId & 0xFFFF;
+		uint16 skyVar = longSkyVar & 0xFFFF;
+		wxString predefName = nsyshid::g_skyportal.FindSkylander(skyId, skyVar) + ".sky";
+		wxFileDialog
+			saveFileDialog(this, _("Create Skylander file"), "", predefName,
+						   "SKY files (*.sky)|*.sky", wxFD_SAVE | wxFD_OVERWRITE_PROMPT);
+
+		if (saveFileDialog.ShowModal() == wxID_CANCEL)
+			return;
+
+		m_filePath = saveFileDialog.GetPath();
+
+		if (!nsyshid::g_skyportal.CreateSkylander(_utf8ToPath(m_filePath.utf8_string()), skyId, skyVar))
+		{
+			wxMessageDialog errorMessage(this, "Failed to create file");
+			errorMessage.ShowModal();
+			this->EndModal(0);
+			return;
+		}
+
+		this->EndModal(1);
+	});
+	auto* cancelButton = new wxButton(this, wxID_ANY, _("Cancel"));
+	cancelButton->Bind(wxEVT_BUTTON, [this](wxCommandEvent&) {
+		this->EndModal(0);
+	});
+
+	comboBox->Bind(wxEVT_COMBOBOX, [comboBox, editId, editVar, this](wxCommandEvent&) {
+		const uint64 sky_info = reinterpret_cast<uint64>(comboBox->GetClientData(comboBox->GetSelection()));
+		if (sky_info != 0xFFFFFFFF)
+		{
+			const uint16 skyId = sky_info >> 16;
+			const uint16 skyVar = sky_info & 0xFFFF;
+
+			editId->SetValue(wxString::Format(wxT("%i"), skyId));
+			editVar->SetValue(wxString::Format(wxT("%i"), skyVar));
+		}
+	});
+
+	buttonRow->Add(createButton, 1, wxALL, 5);
+	buttonRow->Add(cancelButton, 1, wxALL, 5);
+
+	sizer->Add(comboRow, 1, wxEXPAND | wxALL, 2);
+	sizer->Add(idVarRow, 1, wxEXPAND | wxALL, 2);
+	sizer->Add(buttonRow, 1, wxEXPAND | wxALL, 2);
+
+	this->SetSizer(sizer);
+	this->Centre(wxBOTH);
+}
+
+wxString CreateSkylanderDialog::GetFilePath() const
+{
+	return m_filePath;
+}
+
+void EmulatedUSBDeviceFrame::UpdateSkylanderEdits()
+{
+	for (auto i = 0; i < nsyshid::MAX_SKYLANDERS; i++)
+	{
+		std::string displayString;
+		if (auto sd = m_skySlots[i])
+		{
+			auto [portalSlot, skyId, skyVar] = sd.value();
+			displayString = nsyshid::g_skyportal.FindSkylander(skyId, skyVar);
+		}
+		else
+		{
+			displayString = "None";
+		}
+
+		m_skylanderSlots[i]->ChangeValue(displayString);
+	}
+}
+
+void EmulatedUSBDeviceFrame::LoadFigure(uint8 slot)
+{
+	wxFileDialog openFileDialog(this, _("Open Infinity Figure dump"), "", "",
+								"BIN files (*.bin)|*.bin",
+								wxFD_OPEN | wxFD_FILE_MUST_EXIST);
+	if (openFileDialog.ShowModal() != wxID_OK || openFileDialog.GetPath().empty())
+	{
+		wxMessageDialog errorMessage(this, "File Okay Error");
+		errorMessage.ShowModal();
+		return;
+	}
+
+	LoadFigurePath(slot, openFileDialog.GetPath());
+}
+
+void EmulatedUSBDeviceFrame::LoadFigurePath(uint8 slot, wxString path)
+{
+	std::unique_ptr<FileStream> infFile(FileStream::openFile2(_utf8ToPath(path.utf8_string()), true));
+	if (!infFile)
+	{
+		wxMessageDialog errorMessage(this, "File Open Error");
+		errorMessage.ShowModal();
+		return;
+	}
+
+	std::array<uint8, nsyshid::INF_FIGURE_SIZE> fileData;
+	if (infFile->readData(fileData.data(), fileData.size()) != fileData.size())
+	{
+		wxMessageDialog open_error(this, "Failed to read file! File was too small");
+		open_error.ShowModal();
+		return;
+	}
+	ClearFigure(slot);
+
+	uint32 number = nsyshid::g_infinitybase.LoadFigure(fileData, std::move(infFile), slot);
+	m_infinitySlots[slot]->ChangeValue(nsyshid::g_infinitybase.FindFigure(number).second);
+}
+
+void EmulatedUSBDeviceFrame::CreateFigure(uint8 slot)
+{
+	cemuLog_log(LogType::Force, "Create Figure: {}", slot);
+	CreateInfinityFigureDialog create_dlg(this, slot);
+	create_dlg.ShowModal();
+	if (create_dlg.GetReturnCode() == 1)
+	{
+		LoadFigurePath(slot, create_dlg.GetFilePath());
+	}
+}
+
+void EmulatedUSBDeviceFrame::ClearFigure(uint8 slot)
+{
+	m_infinitySlots[slot]->ChangeValue("None");
+	nsyshid::g_infinitybase.RemoveFigure(slot);
+}
+
+CreateInfinityFigureDialog::CreateInfinityFigureDialog(wxWindow* parent, uint8 slot)
+	: wxDialog(parent, wxID_ANY, _("Infinity Figure Creator"), wxDefaultPosition, wxSize(500, 150))
+{
+	auto* sizer = new wxBoxSizer(wxVERTICAL);
+
+	auto* comboRow = new wxBoxSizer(wxHORIZONTAL);
+
+	auto* comboBox = new wxComboBox(this, wxID_ANY);
+	comboBox->Append("---Select---", reinterpret_cast<void*>(0xFFFFFF));
+	wxArrayString filterlist;
+	for (const auto& it : nsyshid::g_infinitybase.GetFigureList())
+	{
+		const uint32 figure = it.first;
+		if ((slot == 0 &&
+			 ((figure > 0x1E8480 && figure < 0x2DC6BF) || (figure > 0x3D0900 && figure < 0x4C4B3F))) ||
+			((slot == 1 || slot == 2) && (figure > 0x3D0900 && figure < 0x4C4B3F)) ||
+			((slot == 3 || slot == 6) && figure < 0x1E847F) ||
+			((slot == 4 || slot == 5 || slot == 7 || slot == 8) &&
+			 (figure > 0x2DC6C0 && figure < 0x3D08FF)))
+		{
+			comboBox->Append(it.second.second, reinterpret_cast<void*>(figure));
+			filterlist.Add(it.second.second);
+		}
+	}
+	comboBox->SetSelection(0);
+	bool enabled = comboBox->AutoComplete(filterlist);
+	comboRow->Add(comboBox, 1, wxEXPAND | wxALL, 2);
+
+	auto* figNumRow = new wxBoxSizer(wxHORIZONTAL);
+
+	wxIntegerValidator<uint32> validator;
+
+	auto* labelFigNum = new wxStaticText(this, wxID_ANY, "Figure Number:");
+	auto* editFigNum = new wxTextCtrl(this, wxID_ANY, _("0"), wxDefaultPosition, wxDefaultSize, 0, validator);
+
+	figNumRow->Add(labelFigNum, 1, wxALL, 5);
+	figNumRow->Add(editFigNum, 1, wxALL, 5);
+
+	auto* buttonRow = new wxBoxSizer(wxHORIZONTAL);
+
+	auto* createButton = new wxButton(this, wxID_ANY, _("Create"));
+	createButton->Bind(wxEVT_BUTTON, [editFigNum, this](wxCommandEvent&) {
+		long longFigNum;
+		if (!editFigNum->GetValue().ToLong(&longFigNum))
+		{
+			wxMessageDialog idError(this, "Error Converting Figure Number!", "Number Entered is Invalid");
+			idError.ShowModal();
+			this->EndModal(0);
+		}
+		uint32 figNum = longFigNum & 0xFFFFFFFF;
+		auto figure = nsyshid::g_infinitybase.FindFigure(figNum);
+		wxString predefName = figure.second + ".bin";
+		wxFileDialog
+			saveFileDialog(this, _("Create Infinity Figure file"), "", predefName,
+						   "BIN files (*.bin)|*.bin", wxFD_SAVE | wxFD_OVERWRITE_PROMPT);
+
+		if (saveFileDialog.ShowModal() == wxID_CANCEL)
+			this->EndModal(0);
+
+		m_filePath = saveFileDialog.GetPath();
+
+		nsyshid::g_infinitybase.CreateFigure(_utf8ToPath(m_filePath.utf8_string()), figNum, figure.first);
+
+		this->EndModal(1);
+	});
+	auto* cancelButton = new wxButton(this, wxID_ANY, _("Cancel"));
+	cancelButton->Bind(wxEVT_BUTTON, [this](wxCommandEvent&) {
+		this->EndModal(0);
+	});
+
+	comboBox->Bind(wxEVT_COMBOBOX, [comboBox, editFigNum, this](wxCommandEvent&) {
+		const uint64 fig_info = reinterpret_cast<uint64>(comboBox->GetClientData(comboBox->GetSelection()));
+		if (fig_info != 0xFFFFFF)
+		{
+			const uint32 figNum = fig_info & 0xFFFFFFFF;
+
+			editFigNum->SetValue(wxString::Format(wxT("%i"), figNum));
+		}
+	});
+
+	buttonRow->Add(createButton, 1, wxALL, 5);
+	buttonRow->Add(cancelButton, 1, wxALL, 5);
+
+	sizer->Add(comboRow, 1, wxEXPAND | wxALL, 2);
+	sizer->Add(figNumRow, 1, wxEXPAND | wxALL, 2);
+	sizer->Add(buttonRow, 1, wxEXPAND | wxALL, 2);
+
+	this->SetSizer(sizer);
+	this->Centre(wxBOTH);
+}
+
+wxString CreateInfinityFigureDialog::GetFilePath() const
+{
+	return m_filePath;
+}
+
+void EmulatedUSBDeviceFrame::LoadMinifig(uint8 pad, uint8 index)
+{
+	wxFileDialog openFileDialog(this, _("Load Dimensions Figure"), "", "",
+								"Dimensions files (*.bin)|*.bin",
+								wxFD_OPEN | wxFD_FILE_MUST_EXIST);
+	if (openFileDialog.ShowModal() != wxID_OK || openFileDialog.GetPath().empty())
+		return;
+
+	LoadMinifigPath(openFileDialog.GetPath(), pad, index);
+}
+
+void EmulatedUSBDeviceFrame::LoadMinifigPath(wxString path_name, uint8 pad, uint8 index)
+{
+	std::unique_ptr<FileStream> dim_file(FileStream::openFile2(_utf8ToPath(path_name.utf8_string()), true));
+	if (!dim_file)
+	{
+		wxMessageDialog errorMessage(this, "Failed to open minifig file");
+		errorMessage.ShowModal();
+		return;
+	}
+
+	std::array<uint8, 0x2D * 0x04> file_data;
+
+	if (dim_file->readData(file_data.data(), file_data.size()) != file_data.size())
+	{
+		wxMessageDialog errorMessage(this, "Failed to read minifig file data");
+		errorMessage.ShowModal();
+		return;
+	}
+
+	ClearMinifig(pad, index);
+
+	uint32 id = nsyshid::g_dimensionstoypad.LoadFigure(file_data, std::move(dim_file), pad, index);
+	m_dimensionSlots[index]->ChangeValue(nsyshid::g_dimensionstoypad.FindFigure(id));
+	m_dimSlots[index] = id;
+}
+
+void EmulatedUSBDeviceFrame::ClearMinifig(uint8 pad, uint8 index)
+{
+	nsyshid::g_dimensionstoypad.RemoveFigure(pad, index, true);
+	m_dimensionSlots[index]->ChangeValue("None");
+	m_dimSlots[index] = std::nullopt;
+}
+
+void EmulatedUSBDeviceFrame::CreateMinifig(uint8 pad, uint8 index)
+{
+	CreateDimensionFigureDialog create_dlg(this);
+	create_dlg.ShowModal();
+	if (create_dlg.GetReturnCode() == 1)
+	{
+		LoadMinifigPath(create_dlg.GetFilePath(), pad, index);
+	}
+}
+
+void EmulatedUSBDeviceFrame::MoveMinifig(uint8 pad, uint8 index)
+{
+	if (!m_dimSlots[index])
+		return;
+
+	MoveDimensionFigureDialog move_dlg(this, index);
+	nsyshid::g_dimensionstoypad.TempRemove(index);
+	move_dlg.ShowModal();
+	if (move_dlg.GetReturnCode() == 1)
+	{
+		nsyshid::g_dimensionstoypad.MoveFigure(move_dlg.GetNewPad(), move_dlg.GetNewIndex(), pad, index);
+		if (index != move_dlg.GetNewIndex())
+		{
+			m_dimSlots[move_dlg.GetNewIndex()] = m_dimSlots[index];
+			m_dimensionSlots[move_dlg.GetNewIndex()]->ChangeValue(m_dimensionSlots[index]->GetValue());
+			m_dimSlots[index] = std::nullopt;
+			m_dimensionSlots[index]->ChangeValue("None");
+		}
+	}
+	else
+	{
+		nsyshid::g_dimensionstoypad.CancelRemove(index);
+	}
+}
+
+CreateDimensionFigureDialog::CreateDimensionFigureDialog(wxWindow* parent)
+	: wxDialog(parent, wxID_ANY, _("Dimensions Figure Creator"), wxDefaultPosition, wxSize(500, 200))
+{
+	auto* sizer = new wxBoxSizer(wxVERTICAL);
+
+	auto* comboRow = new wxBoxSizer(wxHORIZONTAL);
+
+	auto* comboBox = new wxComboBox(this, wxID_ANY);
+	comboBox->Append("---Select---", reinterpret_cast<void*>(0xFFFFFFFF));
+	wxArrayString filterlist;
+	for (const auto& it : nsyshid::g_dimensionstoypad.GetListMinifigs())
+	{
+		const uint32 figure = it.first;
+		comboBox->Append(it.second, reinterpret_cast<void*>(figure));
+		filterlist.Add(it.second);
+	}
+	comboBox->SetSelection(0);
+	bool enabled = comboBox->AutoComplete(filterlist);
+	comboRow->Add(comboBox, 1, wxEXPAND | wxALL, 2);
+
+	auto* figNumRow = new wxBoxSizer(wxHORIZONTAL);
+
+	wxIntegerValidator<uint32> validator;
+
+	auto* labelFigNum = new wxStaticText(this, wxID_ANY, "Figure Number:");
+	auto* editFigNum = new wxTextCtrl(this, wxID_ANY, _("0"), wxDefaultPosition, wxDefaultSize, 0, validator);
+
+	figNumRow->Add(labelFigNum, 1, wxALL, 5);
+	figNumRow->Add(editFigNum, 1, wxALL, 5);
+
+	auto* buttonRow = new wxBoxSizer(wxHORIZONTAL);
+
+	auto* createButton = new wxButton(this, wxID_ANY, _("Create"));
+	createButton->Bind(wxEVT_BUTTON, [editFigNum, this](wxCommandEvent&) {
+		long longFigNum;
+		if (!editFigNum->GetValue().ToLong(&longFigNum) || longFigNum > 0xFFFF)
+		{
+			wxMessageDialog idError(this, "Error Converting Figure Number!", "Number Entered is Invalid");
+			idError.ShowModal();
+			this->EndModal(0);
+		}
+		uint16 figNum = longFigNum & 0xFFFF;
+		auto figure = nsyshid::g_dimensionstoypad.FindFigure(figNum);
+		wxString predefName = figure + ".bin";
+		wxFileDialog
+			saveFileDialog(this, _("Create Dimensions Figure file"), "", predefName,
+						   "BIN files (*.bin)|*.bin", wxFD_SAVE | wxFD_OVERWRITE_PROMPT);
+
+		if (saveFileDialog.ShowModal() == wxID_CANCEL)
+			this->EndModal(0);
+
+		m_filePath = saveFileDialog.GetPath();
+
+		nsyshid::g_dimensionstoypad.CreateFigure(_utf8ToPath(m_filePath.utf8_string()), figNum);
+
+		this->EndModal(1);
+	});
+	auto* cancelButton = new wxButton(this, wxID_ANY, _("Cancel"));
+	cancelButton->Bind(wxEVT_BUTTON, [this](wxCommandEvent&) {
+		this->EndModal(0);
+	});
+
+	comboBox->Bind(wxEVT_COMBOBOX, [comboBox, editFigNum, this](wxCommandEvent&) {
+		const uint64 fig_info = reinterpret_cast<uint64>(comboBox->GetClientData(comboBox->GetSelection()));
+		if (fig_info != 0xFFFF)
+		{
+			const uint16 figNum = fig_info & 0xFFFF;
+
+			editFigNum->SetValue(wxString::Format(wxT("%i"), figNum));
+		}
+	});
+
+	buttonRow->Add(createButton, 1, wxALL, 5);
+	buttonRow->Add(cancelButton, 1, wxALL, 5);
+
+	sizer->Add(comboRow, 1, wxEXPAND | wxALL, 2);
+	sizer->Add(figNumRow, 1, wxEXPAND | wxALL, 2);
+	sizer->Add(buttonRow, 1, wxEXPAND | wxALL, 2);
+
+	this->SetSizer(sizer);
+	this->Centre(wxBOTH);
+}
+
+wxString CreateDimensionFigureDialog::GetFilePath() const
+{
+	return m_filePath;
+}
+
+MoveDimensionFigureDialog::MoveDimensionFigureDialog(EmulatedUSBDeviceFrame* parent, uint8 currentIndex)
+	: wxDialog(parent, wxID_ANY, _("Dimensions Figure Mover"), wxDefaultPosition, wxSize(700, 300))
+{
+	auto* sizer = new wxGridSizer(2, 5, 10, 10);
+
+	std::array<std::optional<uint32>, 7> ids = parent->GetCurrentMinifigs();
+
+	sizer->Add(AddMinifigSlot(2, 0, currentIndex, ids[0]), 1, wxALL, 5);
+	sizer->Add(new wxStaticText(this, wxID_ANY, ""), 1, wxALL, 5);
+	sizer->Add(AddMinifigSlot(1, 1, currentIndex, ids[1]), 1, wxALL, 5);
+	sizer->Add(new wxStaticText(this, wxID_ANY, ""), 1, wxALL, 5);
+	sizer->Add(AddMinifigSlot(3, 2, currentIndex, ids[2]), 1, wxALL, 5);
+
+	sizer->Add(AddMinifigSlot(2, 3, currentIndex, ids[3]), 1, wxALL, 5);
+	sizer->Add(AddMinifigSlot(2, 4, currentIndex, ids[4]), 1, wxALL, 5);
+	sizer->Add(new wxStaticText(this, wxID_ANY, ""), 1, wxALL, 5);
+	sizer->Add(AddMinifigSlot(3, 5, currentIndex, ids[5]), 1, wxALL, 5);
+	sizer->Add(AddMinifigSlot(3, 6, currentIndex, ids[6]), 1, wxALL, 5);
+
+	this->SetSizer(sizer);
+	this->Centre(wxBOTH);
+}
+
+wxBoxSizer* MoveDimensionFigureDialog::AddMinifigSlot(uint8 pad, uint8 index, uint8 currentIndex, std::optional<uint32> currentId)
+{
+	auto* panel = new wxBoxSizer(wxVERTICAL);
+
+	auto* label = new wxStaticText(this, wxID_ANY, "None");
+	if (currentId)
+		label->SetLabel(nsyshid::g_dimensionstoypad.FindFigure(currentId.value()));
+
+	auto* moveButton = new wxButton(this, wxID_ANY, _("Move Here"));
+	if (index == currentIndex)
+		moveButton->SetLabelText("Pick up and Place");
+
+	moveButton->Bind(wxEVT_BUTTON, [pad, index, this](wxCommandEvent&) {
+		m_newPad = pad;
+		m_newIndex = index;
+		this->EndModal(1);
+	});
+
+	panel->Add(label, 1, wxALL, 5);
+	panel->Add(moveButton, 1, wxALL, 5);
+
+	return panel;
+}
+
+uint8 MoveDimensionFigureDialog::GetNewPad() const
+{
+	return m_newPad;
+}
+
+uint8 MoveDimensionFigureDialog::GetNewIndex() const
+{
+	return m_newIndex;
+}
+
+std::array<std::optional<uint32>, 7> EmulatedUSBDeviceFrame::GetCurrentMinifigs()
+{
+	return m_dimSlots;
+}
diff --git a/src/gui/EmulatedUSBDevices/EmulatedUSBDeviceFrame.h b/src/gui/EmulatedUSBDevices/EmulatedUSBDeviceFrame.h
new file mode 100644
index 00000000..78c70a4a
--- /dev/null
+++ b/src/gui/EmulatedUSBDevices/EmulatedUSBDeviceFrame.h
@@ -0,0 +1,102 @@
+#pragma once
+
+#include <array>
+
+#include <wx/dialog.h>
+#include <wx/frame.h>
+
+#include "Cafe/OS/libs/nsyshid/Infinity.h"
+#include "Cafe/OS/libs/nsyshid/Skylander.h"
+
+class wxBoxSizer;
+class wxCheckBox;
+class wxFlexGridSizer;
+class wxNotebook;
+class wxPanel;
+class wxStaticBox;
+class wxString;
+class wxTextCtrl;
+
+class EmulatedUSBDeviceFrame : public wxFrame
+{
+  public:
+	EmulatedUSBDeviceFrame(wxWindow* parent);
+	~EmulatedUSBDeviceFrame();
+	std::array<std::optional<uint32>, 7> GetCurrentMinifigs();
+
+  private:
+	wxCheckBox* m_emulatePortal;
+	wxCheckBox* m_emulateBase;
+	wxCheckBox* m_emulateToypad;
+	std::array<wxTextCtrl*, nsyshid::MAX_SKYLANDERS> m_skylanderSlots;
+	std::array<wxTextCtrl*, nsyshid::MAX_FIGURES> m_infinitySlots;
+	std::array<wxTextCtrl*, 7> m_dimensionSlots;
+	std::array<std::optional<std::tuple<uint8, uint16, uint16>>, nsyshid::MAX_SKYLANDERS> m_skySlots;
+	std::array<std::optional<uint32>, 7> m_dimSlots;
+
+	wxPanel* AddSkylanderPage(wxNotebook* notebook);
+	wxPanel* AddInfinityPage(wxNotebook* notebook);
+	wxPanel* AddDimensionsPage(wxNotebook* notebook);
+	wxBoxSizer* AddSkylanderRow(uint8 row_number, wxStaticBox* box);
+	wxBoxSizer* AddInfinityRow(wxString name, uint8 row_number, wxStaticBox* box);
+	wxBoxSizer* AddDimensionPanel(uint8 pad, uint8 index, wxStaticBox* box);
+	void LoadSkylander(uint8 slot);
+	void LoadSkylanderPath(uint8 slot, wxString path);
+	void CreateSkylander(uint8 slot);
+	void ClearSkylander(uint8 slot);
+	void UpdateSkylanderEdits();
+	void LoadFigure(uint8 slot);
+	void LoadFigurePath(uint8 slot, wxString path);
+	void CreateFigure(uint8 slot);
+	void ClearFigure(uint8 slot);
+	void LoadMinifig(uint8 pad, uint8 index);
+	void LoadMinifigPath(wxString path_name, uint8 pad, uint8 index);
+	void CreateMinifig(uint8 pad, uint8 index);
+	void ClearMinifig(uint8 pad, uint8 index);
+	void MoveMinifig(uint8 pad, uint8 index);
+};
+
+class CreateSkylanderDialog : public wxDialog
+{
+  public:
+	explicit CreateSkylanderDialog(wxWindow* parent, uint8 slot);
+	wxString GetFilePath() const;
+
+  protected:
+	wxString m_filePath;
+};
+
+class CreateInfinityFigureDialog : public wxDialog
+{
+  public:
+	explicit CreateInfinityFigureDialog(wxWindow* parent, uint8 slot);
+	wxString GetFilePath() const;
+
+  protected:
+	wxString m_filePath;
+};
+
+class CreateDimensionFigureDialog : public wxDialog
+{
+  public:
+	explicit CreateDimensionFigureDialog(wxWindow* parent);
+	wxString GetFilePath() const;
+
+  protected:
+	wxString m_filePath;
+};
+
+class MoveDimensionFigureDialog : public wxDialog
+{
+  public:
+	explicit MoveDimensionFigureDialog(EmulatedUSBDeviceFrame* parent, uint8 currentIndex);
+	uint8 GetNewPad() const;
+	uint8 GetNewIndex() const;
+
+  protected:
+	uint8 m_newIndex = 0;
+	uint8 m_newPad = 0;
+
+  private:
+	wxBoxSizer* AddMinifigSlot(uint8 pad, uint8 index, uint8 oldIndex, std::optional<uint32> currentId);
+};
\ No newline at end of file
diff --git a/src/gui/GameProfileWindow.cpp b/src/gui/GameProfileWindow.cpp
index f710988f..f15395e4 100644
--- a/src/gui/GameProfileWindow.cpp
+++ b/src/gui/GameProfileWindow.cpp
@@ -118,7 +118,7 @@ GameProfileWindow::GameProfileWindow(wxWindow* parent, uint64_t title_id)
 		
 		first_row->Add(new wxStaticText(panel, wxID_ANY, _("Shader multiplication accuracy")), 0, wxALIGN_CENTER_VERTICAL | wxALL, 5);
 
-		wxString mul_values[] = { _("false"), _("true"), _("minimal") };
+		wxString mul_values[] = { _("false"), _("true")};
 		m_shader_mul_accuracy = new wxChoice(panel, wxID_ANY, wxDefaultPosition, wxDefaultSize, (int)std::size(mul_values), mul_values);
 		m_shader_mul_accuracy->SetToolTip(_("EXPERT OPTION\nControls the accuracy of floating point multiplication in shaders.\n\nRecommended: true"));
 		first_row->Add(m_shader_mul_accuracy, 0, wxALL, 5);
@@ -166,9 +166,8 @@ GameProfileWindow::GameProfileWindow(wxWindow* parent, uint64_t title_id)
 
 		for (int i = 0; i < 8; ++i)
 		{
-			profile_sizer->Add(new wxStaticText(panel, wxID_ANY, fmt::format("{} {}", _("Controller").ToStdString(), (i + 1))), 0, wxALIGN_CENTER_VERTICAL | wxALL, 5);
+			profile_sizer->Add(new wxStaticText(panel, wxID_ANY, formatWxString(_("Controller {}"), i + 1)), 0, wxALIGN_CENTER_VERTICAL | wxALL, 5);
 
-			wxArrayString m_controller_profileChoices;
 			m_controller_profile[i] = new wxComboBox(panel, wxID_ANY,"", wxDefaultPosition, wxDefaultSize, 0, nullptr, wxCB_DROPDOWN| wxCB_READONLY);
 			m_controller_profile[i]->SetMinSize(wxSize(250, -1));
 			m_controller_profile[i]->Bind(wxEVT_COMBOBOX_DROPDOWN, &GameProfileWindow::OnControllerProfileDropdown, this);
@@ -245,7 +244,7 @@ void GameProfileWindow::SetProfileInt(gameProfileIntegerOption_t& option, wxChec
 void GameProfileWindow::ApplyProfile()
 {
 	if(m_game_profile.m_gameName)
-		this->SetTitle(fmt::format("{} - {}", _("Edit game profile").ToStdString(), m_game_profile.m_gameName.value()));
+		this->SetTitle(_("Edit game profile") + " - " + m_game_profile.m_gameName.value());
 
 	// general
 	m_load_libs->SetValue(m_game_profile.m_loadSharedLibraries.value());
@@ -269,10 +268,7 @@ void GameProfileWindow::ApplyProfile()
 		m_graphic_api->SetSelection(0); // selecting ""
 	else
 		m_graphic_api->SetSelection(1 + m_game_profile.m_graphics_api.value()); // "", OpenGL, Vulkan
-	//m_extended_texture_readback->SetValue(m_game_profile.m_extendedTextureReadback);
-	//m_precompiled->SetSelection((int)m_game_profile.m_precompiledShaders.value());
 	m_shader_mul_accuracy->SetSelection((int)m_game_profile.m_accurateShaderMul);
-	//m_cache_accuracy->SetSelection((int)m_game_profile.m_gpuBufferCacheAccuracy.value());
 
 	//// audio
 	//m_disable_audio->Set3StateValue(GetCheckboxState(m_game_profile.disableAudio));
@@ -332,6 +328,9 @@ void GameProfileWindow::SaveProfile()
 
 	// gpu
 	m_game_profile.m_accurateShaderMul = (AccurateShaderMulOption)m_shader_mul_accuracy->GetSelection();
+	if (m_game_profile.m_accurateShaderMul != AccurateShaderMulOption::False && m_game_profile.m_accurateShaderMul != AccurateShaderMulOption::True)
+		m_game_profile.m_accurateShaderMul = AccurateShaderMulOption::True; // force a legal value
+
 	if (m_graphic_api->GetSelection() == 0)
 		m_game_profile.m_graphics_api = {};
 	else
diff --git a/src/gui/GameUpdateWindow.cpp b/src/gui/GameUpdateWindow.cpp
index 3ea3f9d1..184d5fde 100644
--- a/src/gui/GameUpdateWindow.cpp
+++ b/src/gui/GameUpdateWindow.cpp
@@ -10,32 +10,30 @@
 #include "gui/helpers/wxHelpers.h"
 #include "wxHelper.h"
 
-std::string _GetTitleIdTypeStr(TitleId titleId)
+wxString _GetTitleIdTypeStr(TitleId titleId)
 {
 	TitleIdParser tip(titleId);
 	switch (tip.GetType())
 	{
 	case TitleIdParser::TITLE_TYPE::AOC:
-		return _("DLC").ToStdString();
+		return _("DLC");
 	case TitleIdParser::TITLE_TYPE::BASE_TITLE:
-		return _("Base game").ToStdString();
+		return _("Base game");
 	case TitleIdParser::TITLE_TYPE::BASE_TITLE_DEMO:
-		return _("Demo").ToStdString();
+		return _("Demo");
 	case TitleIdParser::TITLE_TYPE::SYSTEM_TITLE:
 	case TitleIdParser::TITLE_TYPE::SYSTEM_OVERLAY_TITLE:
-		return _("System title").ToStdString();
+		return _("System title");
 	case TitleIdParser::TITLE_TYPE::SYSTEM_DATA:
-		return _("System data title").ToStdString();
+		return _("System data title");
 	case TitleIdParser::TITLE_TYPE::BASE_TITLE_UPDATE:
-		return _("Update").ToStdString();
+		return _("Update");
 	default:
 		break;
 	}
 	return "Unknown";
 }
 
-bool IsRunningInWine();
-
 bool GameUpdateWindow::ParseUpdate(const fs::path& metaPath)
 {
 	m_title_info = TitleInfo(metaPath);
@@ -59,11 +57,11 @@ bool GameUpdateWindow::ParseUpdate(const fs::path& metaPath)
 
 				if (tip.GetType() != tipOther.GetType())
 				{
-					std::string typeStrToInstall = _GetTitleIdTypeStr(m_title_info.GetAppTitleId());
-					std::string typeStrCurrentlyInstalled = _GetTitleIdTypeStr(tmp.GetAppTitleId());
+					auto typeStrToInstall = _GetTitleIdTypeStr(m_title_info.GetAppTitleId());
+					auto typeStrCurrentlyInstalled = _GetTitleIdTypeStr(tmp.GetAppTitleId());
 
-					std::string wxMsg = wxHelper::MakeUTF8(_("It seems that there is already a title installed at the target location but it has a different type.\nCurrently installed: \'{}\' Installing: \'{}\'\n\nThis can happen for titles which were installed with very old Cemu versions.\nDo you still want to continue with the installation? It will replace the currently installed title."));
-					wxMessageDialog dialog(this, fmt::format(fmt::runtime(wxMsg), typeStrCurrentlyInstalled, typeStrToInstall), _("Warning"), wxCENTRE | wxYES_NO | wxICON_EXCLAMATION);
+					auto wxMsg = _("It seems that there is already a title installed at the target location but it has a different type.\nCurrently installed: \'{}\' Installing: \'{}\'\n\nThis can happen for titles which were installed with very old Cemu versions.\nDo you still want to continue with the installation? It will replace the currently installed title.");
+					wxMessageDialog dialog(this, formatWxString(wxMsg, typeStrCurrentlyInstalled, typeStrToInstall), _("Warning"), wxCENTRE | wxYES_NO | wxICON_EXCLAMATION);
 					if (dialog.ShowModal() != wxID_YES)
 						return false;
 				}
@@ -92,7 +90,7 @@ bool GameUpdateWindow::ParseUpdate(const fs::path& metaPath)
 
 				if (ec)
 				{
-					const auto error_msg = wxStringFormat2(_("Error when trying to move former title installation:\n{}"), GetSystemErrorMessage(ec));
+					const auto error_msg = formatWxString(_("Error when trying to move former title installation:\n{}"), GetSystemErrorMessage(ec));
 					wxMessageBox(error_msg, _("Error"), wxOK | wxCENTRE, this);
 					return false;
 				}
@@ -105,7 +103,7 @@ bool GameUpdateWindow::ParseUpdate(const fs::path& metaPath)
 		}
 		catch (const std::exception& ex)
 		{
-			forceLog_printf("GameUpdateWindow::ParseUpdate exist-error: %s at %s", ex.what(), target_location.generic_u8string().c_str());
+			cemuLog_log(LogType::Force, "GameUpdateWindow::ParseUpdate exist-error: {} at {}", ex.what(), _pathToUtf8(target_location));
 		}
 	}
 
@@ -130,15 +128,11 @@ bool GameUpdateWindow::ParseUpdate(const fs::path& metaPath)
 		}
 	}
 
-	// checking size is buggy on Wine (on Steam Deck this would return values too small to install bigger updates) - we therefore skip this step
-	if(!IsRunningInWine())
+	const fs::space_info targetSpace = fs::space(ActiveSettings::GetMlcPath());
+	if (targetSpace.free <= m_required_size)
 	{
-		const fs::space_info targetSpace = fs::space(target_location.root_path());
-		if (targetSpace.free <= m_required_size)
-		{
-			auto string = wxStringFormat(_("Not enough space available.\nRequired: {0} MB\nAvailable: {1} MB"), L"%lld %lld", (m_required_size / 1024 / 1024), (targetSpace.free / 1024 / 1024));
-			throw std::runtime_error(string);
-		}
+		auto string = formatWxString(_("Not enough space available.\nRequired: {0} MB\nAvailable: {1} MB"), (m_required_size / 1024 / 1024), (targetSpace.free / 1024 / 1024));
+		throw std::runtime_error(string.utf8_string());
 	}
 
 	return true;
@@ -213,7 +207,6 @@ void GameUpdateWindow::ThreadWork()
 			create_directories(targetDir);
 		}
 
-		const auto target_path = fs::path(m_target_path);
 		for (auto& path : m_source_paths)
 		{
 			if (m_thread_state == ThreadCanceled)
@@ -251,7 +244,7 @@ void GameUpdateWindow::ThreadWork()
 		error_msg << GetSystemErrorMessage(ex);
 
 		if(currentDirEntry != fs::directory_entry{})
-			error_msg << fmt::format("\n{}\n{}",_("Current file:").ToStdString(), _pathToUtf8(currentDirEntry.path()));
+			error_msg << fmt::format("\n{}\n{}",_("Current file:").utf8_string(), _pathToUtf8(currentDirEntry.path()));
 
 		m_thread_exception = error_msg.str();
 		m_thread_state = ThreadCanceled;
@@ -308,7 +301,7 @@ void GameUpdateWindow::OnClose(wxCloseEvent& event)
 			}
 			catch (const std::exception& ex)
 			{
-				forceLogDebug_printf("can't restore update backup: %s",ex.what());
+				cemuLog_logDebug(LogType::Force, "can't restore update backup: {}",ex.what());
 			}
 		}
 		else
@@ -321,7 +314,7 @@ void GameUpdateWindow::OnClose(wxCloseEvent& event)
 			}
 			catch (const std::exception& ex)
 			{
-				forceLogDebug_printf("can't delete update backup: %s",ex.what());
+				cemuLog_logDebug(LogType::Force, "can't delete update backup: {}",ex.what());
 			}
 		}
 		
diff --git a/src/gui/GameUpdateWindow.h b/src/gui/GameUpdateWindow.h
index 60ec5d63..508e6465 100644
--- a/src/gui/GameUpdateWindow.h
+++ b/src/gui/GameUpdateWindow.h
@@ -26,7 +26,7 @@ public:
 	//bool IsDLC() const { return m_game_info->IsDLC(); }
 	//bool IsUpdate() const { return m_game_info->IsUpdate(); }
 	const std::string& GetExceptionMessage() const { return m_thread_exception; }
-	const std::string GetGameName() const { return m_title_info.GetTitleName(); }
+	const std::string GetGameName() const { return m_title_info.GetMetaTitleName(); }
 	uint32 GetTargetVersion() const { return m_title_info.GetAppTitleVersion(); }
 	fs::path GetTargetPath() const { return fs::path(m_target_path); }
 
diff --git a/src/gui/GeneralSettings2.cpp b/src/gui/GeneralSettings2.cpp
index 78e1feec..4c23aedc 100644
--- a/src/gui/GeneralSettings2.cpp
+++ b/src/gui/GeneralSettings2.cpp
@@ -14,6 +14,7 @@
 #include <wx/hyperlink.h>
 
 #include "config/CemuConfig.h"
+#include "config/NetworkSettings.h"
 
 #include "audio/IAudioAPI.h"
 #if BOOST_OS_WINDOWS
@@ -22,6 +23,8 @@
 #endif
 #include "audio/CubebAPI.h"
 
+#include "audio/IAudioInputAPI.h"
+
 #include "Cafe/HW/Latte/Renderer/Vulkan/VulkanAPI.h"
 #include "Cafe/HW/Latte/Renderer/Vulkan/VulkanRenderer.h"
 #include "Cafe/Account/Account.h"
@@ -29,7 +32,6 @@
 #include <boost/tokenizer.hpp>
 #include "util/helpers/SystemException.h"
 #include "gui/dialogs/CreateAccount/wxCreateAccountDialog.h"
-#include "config/PermanentStorage.h"
 
 #if BOOST_OS_WINDOWS
 #include <VersionHelpers.h>
@@ -39,26 +41,26 @@
 #include "config/ActiveSettings.h"
 #include "gui/helpers/wxHelpers.h"
 
-#if BOOST_OS_LINUX || BOOST_OS_MACOS
 #include "resource/embedded/resources.h"
-#endif
 
 #include "Cafe/CafeSystem.h"
 #include "Cemu/ncrypto/ncrypto.h"
 #include "Cafe/TitleList/TitleList.h"
 #include "wxHelper.h"
 
-const wxString kDirectSound(wxT("DirectSound"));
-const wxString kXAudio27(wxT("XAudio2.7"));
-const wxString kXAudio2(wxT("XAudio2"));
-const wxString kCubeb(wxT("Cubeb"));
+#include "util/ScreenSaver/ScreenSaver.h"
 
-const wxString kPropertyPersistentId(wxT("PersistentId"));
-const wxString kPropertyMiiName(wxT("MiiName"));
-const wxString kPropertyBirthday(wxT("Birthday"));
-const wxString kPropertyGender(wxT("Gender"));
-const wxString kPropertyEmail(wxT("Email"));
-const wxString kPropertyCountry(wxT("Country"));
+const wxString kDirectSound("DirectSound");
+const wxString kXAudio27("XAudio2.7");
+const wxString kXAudio2("XAudio2");
+const wxString kCubeb("Cubeb");
+
+const wxString kPropertyPersistentId("PersistentId");
+const wxString kPropertyMiiName("MiiName");
+const wxString kPropertyBirthday("Birthday");
+const wxString kPropertyGender("Gender");
+const wxString kPropertyEmail("Email");
+const wxString kPropertyCountry("Country");
 
 wxDEFINE_EVENT(wxEVT_ACCOUNTLIST_REFRESH, wxCommandEvent);
 
@@ -71,6 +73,15 @@ private:
 	IAudioAPI::DeviceDescriptionPtr m_description;
 };
 
+class wxInputDeviceDescription : public wxClientData
+{
+public:
+	wxInputDeviceDescription(const IAudioInputAPI::DeviceDescriptionPtr& description) : m_description(description) {}
+	const IAudioInputAPI::DeviceDescriptionPtr& GetDescription() const { return m_description; }
+private:
+	IAudioInputAPI::DeviceDescriptionPtr m_description;
+};
+
 class wxVulkanUUID : public wxClientData
 {
 public:
@@ -111,13 +122,13 @@ wxPanel* GeneralSettings2::AddGeneralPage(wxNotebook* notebook)
 
 			first_row->Add(new wxStaticText(box, wxID_ANY, _("Language"), wxDefaultPosition, wxDefaultSize, 0), 0, wxALIGN_CENTER_VERTICAL | wxALL, 5);
 
-			wxString language_choices[] = { _("Default"), _("English") };
+			wxString language_choices[] = { _("Default") };
 			m_language = new wxChoice(box, wxID_ANY, wxDefaultPosition, wxDefaultSize, std::size(language_choices), language_choices);
 			m_language->SetSelection(0);
 			m_language->SetToolTip(_("Changes the interface language of Cemu\nAvailable languages are stored in the translation directory\nA restart will be required after changing the language"));
 			for (const auto& language : wxGetApp().GetLanguages())
 			{
-				m_language->Append(language->Description);
+				m_language->Append(language->DescriptionNative);
 			}
 
 			first_row->Add(m_language, 0, wxALL | wxEXPAND, 5);
@@ -130,35 +141,90 @@ wxPanel* GeneralSettings2::AddGeneralPage(wxNotebook* notebook)
 			second_row->SetFlexibleDirection(wxBOTH);
 			second_row->SetNonFlexibleGrowMode(wxFLEX_GROWMODE_SPECIFIED);
 
+			sint32 checkboxCount = 0;
+			auto CountRowElement = [&]()
+			{
+				checkboxCount++;
+				if(checkboxCount != 2)
+					return;
+				second_row->AddSpacer(10);
+				checkboxCount = 0;
+			};
+
+			auto InsertEmptyRow = [&]()
+			{
+				while(checkboxCount != 0)
+					CountRowElement();
+				second_row->AddSpacer(10);
+				second_row->AddSpacer(10);
+				second_row->AddSpacer(10);
+			};
+
 			const int topflag = wxALIGN_CENTER_VERTICAL | wxALL;
 			m_save_window_position_size = new wxCheckBox(box, wxID_ANY, _("Remember main window position"));
 			m_save_window_position_size->SetToolTip(_("Restores the last known window position and size when starting Cemu"));
 			second_row->Add(m_save_window_position_size, 0, topflag, 5);
-			second_row->AddSpacer(10);
+			CountRowElement();
+			//second_row->AddSpacer(10);
 			m_save_padwindow_position_size = new wxCheckBox(box, wxID_ANY, _("Remember pad window position"));
 			m_save_padwindow_position_size->SetToolTip(_("Restores the last known pad window position and size when opening it"));
 			second_row->Add(m_save_padwindow_position_size, 0, topflag, 5);
+			CountRowElement();
 
 			const int botflag = wxALIGN_CENTER_VERTICAL | wxLEFT | wxRIGHT | wxBOTTOM;
 			m_discord_presence = new wxCheckBox(box, wxID_ANY, _("Discord Presence"));
 			m_discord_presence->SetToolTip(_("Enables the Discord Rich Presence feature\nYou will also need to enable it in the Discord settings itself!"));
 			second_row->Add(m_discord_presence, 0, botflag, 5);
-			second_row->AddSpacer(10);
+			CountRowElement();
+#ifndef ENABLE_DISCORD_RPC
+			m_discord_presence->Disable();
+#endif
+			//second_row->AddSpacer(10);
 			m_fullscreen_menubar = new wxCheckBox(box, wxID_ANY, _("Fullscreen menu bar"));
 			m_fullscreen_menubar->SetToolTip(_("Displays the menu bar when Cemu is running in fullscreen mode and the mouse cursor is moved to the top"));
 			second_row->Add(m_fullscreen_menubar, 0, botflag, 5);
+			CountRowElement();
+
+			m_save_screenshot = new wxCheckBox(box, wxID_ANY, _("Save screenshot"));
+			m_save_screenshot->SetToolTip(_("Pressing the screenshot key (F12) will save a screenshot directly to the screenshots folder"));
+			second_row->Add(m_save_screenshot, 0, botflag, 5);
+			CountRowElement();
+
+			m_disable_screensaver = new wxCheckBox(box, wxID_ANY, _("Disable screen saver"));
+			m_disable_screensaver->SetToolTip(_("Prevents the system from activating the screen saver or going to sleep while running a game."));
+			second_row->Add(m_disable_screensaver, 0, botflag, 5);
+			CountRowElement();
+
+			// Enable/disable feral interactive gamemode
+#if BOOST_OS_LINUX && defined(ENABLE_FERAL_GAMEMODE)
+			m_feral_gamemode = new wxCheckBox(box, wxID_ANY, _("Enable Feral GameMode"));
+			m_feral_gamemode->SetToolTip(_("Use FeralInteractive GameMode if installed."));
+			second_row->Add(m_feral_gamemode, 0, botflag, 5);
+			CountRowElement();
+#endif
+
+			// temporary workaround because feature crashes on macOS
+#if BOOST_OS_MACOS
+			m_disable_screensaver->Enable(false);
+#endif
+			m_play_boot_sound = new wxCheckBox(box, wxID_ANY, _("Enable intro sound"));
+			m_play_boot_sound->SetToolTip(_("Play bootSound file while compiling shaders/pipelines."));
+			second_row->Add(m_play_boot_sound, 0, botflag, 5);
+			CountRowElement();
 
 			m_auto_update = new wxCheckBox(box, wxID_ANY, _("Automatically check for updates"));
 			m_auto_update->SetToolTip(_("Automatically checks for new cemu versions on startup"));
 			second_row->Add(m_auto_update, 0, botflag, 5);
-			second_row->AddSpacer(10);
-			m_save_screenshot = new wxCheckBox(box, wxID_ANY, _("Save screenshot"));
-			m_save_screenshot->SetToolTip(_("Pressing the screenshot key (F12) will save a screenshot directly to the screenshots folder"));
-			second_row->Add(m_save_screenshot, 0, botflag, 5);
+			CountRowElement();
 
-			m_permanent_storage = new wxCheckBox(box, wxID_ANY, _("Use permanent storage"));
-			m_permanent_storage->SetToolTip(_("Cemu will remember your custom mlc path in %LOCALAPPDATA%/Cemu for new installations."));
-			second_row->Add(m_permanent_storage, 0, botflag, 5);
+			m_receive_untested_releases = new wxCheckBox(box, wxID_ANY, _("Receive untested updates"));
+			m_receive_untested_releases->SetToolTip(_("When checking for updates, include brand new and untested releases. These may contain bugs!"));
+			second_row->Add(m_receive_untested_releases, 0, botflag, 5);
+#if BOOST_OS_LINUX
+			if (!std::getenv("APPIMAGE")) {
+				m_auto_update->Disable();
+			}
+#endif
 
 			box_sizer->Add(second_row, 0, wxEXPAND, 5);
 		}
@@ -167,23 +233,33 @@ wxPanel* GeneralSettings2::AddGeneralPage(wxNotebook* notebook)
 	}
 
 	{
-		auto* box = new wxStaticBox(panel, wxID_ANY, _("MLC Path"));
-		auto* box_sizer = new wxStaticBoxSizer(box, wxHORIZONTAL);
+		auto* outerMlcBox = new wxStaticBox(panel, wxID_ANY, _("Custom MLC path"));
 
-		m_mlc_path = new wxTextCtrl(box, wxID_ANY, wxEmptyString, wxDefaultPosition, wxDefaultSize, wxTE_READONLY);
+		auto* box_sizer_mlc = new wxStaticBoxSizer(outerMlcBox, wxVERTICAL);
+		box_sizer_mlc->Add(new wxStaticText(box_sizer_mlc->GetStaticBox(), wxID_ANY, _("You can configure a custom path for the emulated internal Wii U storage (MLC).\nThis is where Cemu stores saves, accounts and other Wii U system files."), wxDefaultPosition, wxDefaultSize, 0), 0, wxALL, 5);
+
+		auto* mlcPathLineSizer = new wxBoxSizer(wxHORIZONTAL);
+
+		m_mlc_path = new wxTextCtrl(outerMlcBox, wxID_ANY, wxEmptyString, wxDefaultPosition, wxDefaultSize, wxTE_READONLY);
 		m_mlc_path->SetMinSize(wxSize(150, -1));
-		m_mlc_path->Bind(wxEVT_CHAR, &GeneralSettings2::OnMLCPathChar, this);
 		m_mlc_path->SetToolTip(_("The mlc directory contains your save games and installed game update/dlc data"));
 
-		box_sizer->Add(m_mlc_path, 1, wxALL | wxEXPAND, 5);
+		mlcPathLineSizer->Add(m_mlc_path, 1, wxALL | wxEXPAND, 5);
 
-		auto* change_path = new wxButton(box, wxID_ANY, wxT("..."));
-		change_path->Bind(wxEVT_BUTTON, &GeneralSettings2::OnMLCPathSelect, this);
-		change_path->SetToolTip(_("Select a custom mlc path\nThe mlc path is used to store Wii U related files like save games, game updates and dlc data"));
-		box_sizer->Add(change_path, 0, wxALL, 5);
+		auto* changePath = new wxButton(outerMlcBox, wxID_ANY, "Change");
+		changePath->Bind(wxEVT_BUTTON, &GeneralSettings2::OnMLCPathSelect, this);
+		mlcPathLineSizer->Add(changePath, 0, wxALL, 5);
 		if (LaunchSettings::GetMLCPath().has_value())
-			change_path->Disable();
-		general_panel_sizer->Add(box_sizer, 0, wxEXPAND | wxALL, 5);
+			changePath->Disable();
+
+		auto* clearPath = new wxButton(outerMlcBox, wxID_ANY, "Clear custom path");
+		clearPath->Bind(wxEVT_BUTTON, &GeneralSettings2::OnMLCPathClear, this);
+		mlcPathLineSizer->Add(clearPath, 0, wxALL, 5);
+		if (LaunchSettings::GetMLCPath().has_value() || !ActiveSettings::IsCustomMlcPath())
+			clearPath->Disable();
+
+		box_sizer_mlc->Add(mlcPathLineSizer, 0, wxEXPAND, 5);
+		general_panel_sizer->Add(box_sizer_mlc, 0, wxEXPAND | wxALL, 5);
 	}
 
 	{
@@ -335,7 +411,7 @@ wxPanel* GeneralSettings2::AddAudioPage(wxNotebook* notebook)
 		m_audio_latency = new wxSlider(box, wxID_ANY, 2, 0, IAudioAPI::kBlockCount - 1, wxDefaultPosition, wxDefaultSize, wxSL_HORIZONTAL);
 		m_audio_latency->SetToolTip(_("Controls the amount of buffered audio data\nHigher values will create a delay in audio playback, but may avoid audio problems when emulation is too slow"));
 		audio_general_row->Add(m_audio_latency, 0, wxEXPAND | wxALL, 5);
-		auto latency_text = new wxStaticText(box, wxID_ANY, wxT("24ms"));
+		auto latency_text = new wxStaticText(box, wxID_ANY, "24ms");
 		audio_general_row->Add(latency_text, 0, wxALIGN_CENTER_VERTICAL | wxALL | wxALIGN_RIGHT, 5);
 		m_audio_latency->Bind(wxEVT_SLIDER, &GeneralSettings2::OnLatencySliderChanged, this, wxID_ANY, wxID_ANY, new wxControlObject(latency_text));
 		m_audio_latency->Bind(wxEVT_SLIDER, &GeneralSettings2::OnAudioLatencyChanged, this);
@@ -374,7 +450,7 @@ wxPanel* GeneralSettings2::AddAudioPage(wxNotebook* notebook)
 		audio_tv_row->Add(new wxStaticText(box, wxID_ANY, _("Volume")), 0, wxALIGN_CENTER_VERTICAL | wxALL, 5);
 		m_tv_volume = new wxSlider(box, wxID_ANY, 100, 0, 100, wxDefaultPosition, wxDefaultSize, wxSL_HORIZONTAL);
 		audio_tv_row->Add(m_tv_volume, 0, wxEXPAND | wxALL, 5);
-		auto audio_tv_volume_text = new wxStaticText(box, wxID_ANY, wxT("100%"));
+		auto audio_tv_volume_text = new wxStaticText(box, wxID_ANY, "100%");
 		audio_tv_row->Add(audio_tv_volume_text, 0, wxALIGN_CENTER_VERTICAL | wxALL | wxALIGN_RIGHT, 5);
 
 		m_tv_volume->Bind(wxEVT_SLIDER, &GeneralSettings2::OnSliderChangedPercent, this, wxID_ANY, wxID_ANY, new wxControlObject(audio_tv_volume_text));
@@ -415,7 +491,7 @@ wxPanel* GeneralSettings2::AddAudioPage(wxNotebook* notebook)
 		audio_pad_row->Add(new wxStaticText(box, wxID_ANY, _("Volume")), 0, wxALIGN_CENTER_VERTICAL | wxALL, 5);
 		m_pad_volume = new wxSlider(box, wxID_ANY, 100, 0, 100);
 		audio_pad_row->Add(m_pad_volume, 0, wxEXPAND | wxALL, 5);
-		auto audio_pad_volume_text = new wxStaticText(box, wxID_ANY, wxT("100%"));
+		auto audio_pad_volume_text = new wxStaticText(box, wxID_ANY, "100%");
 		audio_pad_row->Add(audio_pad_volume_text, 0, wxALIGN_CENTER_VERTICAL | wxALL | wxALIGN_RIGHT, 5);
 
 		m_pad_volume->Bind(wxEVT_SLIDER, &GeneralSettings2::OnSliderChangedPercent, this, wxID_ANY, wxID_ANY, new wxControlObject(audio_pad_volume_text));
@@ -425,6 +501,77 @@ wxPanel* GeneralSettings2::AddAudioPage(wxNotebook* notebook)
 		audio_panel_sizer->Add(box_sizer, 0, wxEXPAND | wxALL, 5);
 	}
 
+	{
+		auto box = new wxStaticBox(audio_panel, wxID_ANY, _("Microphone (Experimental)"));
+		auto box_sizer = new wxStaticBoxSizer(box, wxVERTICAL);
+
+		auto audio_input_row = new wxFlexGridSizer(0, 3, 0, 0);
+		audio_input_row->SetFlexibleDirection(wxBOTH);
+		audio_input_row->SetNonFlexibleGrowMode(wxFLEX_GROWMODE_SPECIFIED);
+
+		audio_input_row->Add(new wxStaticText(box, wxID_ANY, _("Device")), 0, wxALIGN_CENTER_VERTICAL | wxALL, 5);
+		m_input_device = new wxChoice(box, wxID_ANY, wxDefaultPosition);
+		m_input_device->SetMinSize(wxSize(300, -1));
+		m_input_device->SetToolTip(_("Select the active audio input device for Wii U GamePad"));
+		audio_input_row->Add(m_input_device, 0, wxEXPAND | wxALL, 5);
+		audio_input_row->AddSpacer(0);
+
+		m_input_device->Bind(wxEVT_CHOICE, &GeneralSettings2::OnAudioDeviceSelected, this);
+
+		const wxString audio_channel_drc_choices[] = { _("Mono") }; // mono for now only
+
+		audio_input_row->Add(new wxStaticText(box, wxID_ANY, _("Channels")), 0, wxALIGN_CENTER_VERTICAL | wxALL, 5);
+		m_input_channels = new wxChoice(box, wxID_ANY, wxDefaultPosition, wxDefaultSize, std::size(audio_channel_drc_choices), audio_channel_drc_choices);
+
+		m_input_channels->SetSelection(0); // set default to stereo
+
+		m_input_channels->Bind(wxEVT_CHOICE, &GeneralSettings2::OnAudioChannelsSelected, this);
+		audio_input_row->Add(m_input_channels, 0, wxEXPAND | wxALL, 5);
+		audio_input_row->AddSpacer(0);
+
+		audio_input_row->Add(new wxStaticText(box, wxID_ANY, _("Volume")), 0, wxALIGN_CENTER_VERTICAL | wxALL, 5);
+		m_input_volume = new wxSlider(box, wxID_ANY, 100, 0, 100);
+		audio_input_row->Add(m_input_volume, 0, wxEXPAND | wxALL, 5);
+		auto audio_input_volume_text = new wxStaticText(box, wxID_ANY, "100%");
+		audio_input_row->Add(audio_input_volume_text, 0, wxALIGN_CENTER_VERTICAL | wxALL | wxALIGN_RIGHT, 5);
+
+		m_input_volume->Bind(wxEVT_SLIDER, &GeneralSettings2::OnSliderChangedPercent, this, wxID_ANY, wxID_ANY, new wxControlObject(audio_input_volume_text));
+		m_input_volume->Bind(wxEVT_SLIDER, &GeneralSettings2::OnVolumeChanged, this);
+
+		box_sizer->Add(audio_input_row, 1, wxEXPAND, 5);
+		audio_panel_sizer->Add(box_sizer, 0, wxEXPAND | wxALL, 5);
+	}
+
+	{
+		auto box = new wxStaticBox(audio_panel, wxID_ANY, _("Trap Team Portal"));
+		auto box_sizer = new wxStaticBoxSizer(box, wxVERTICAL);
+
+		auto portal_audio_row = new wxFlexGridSizer(0, 3, 0, 0);
+		portal_audio_row->SetFlexibleDirection(wxBOTH);
+		portal_audio_row->SetNonFlexibleGrowMode(wxFLEX_GROWMODE_SPECIFIED);
+
+		portal_audio_row->Add(new wxStaticText(box, wxID_ANY, _("Device")), 0, wxALIGN_CENTER_VERTICAL | wxALL, 5);
+		m_portal_device = new wxChoice(box, wxID_ANY, wxDefaultPosition);
+		m_portal_device->SetMinSize(wxSize(300, -1));
+		m_portal_device->SetToolTip(_("Select the active audio output device for Wii U GamePad"));
+		portal_audio_row->Add(m_portal_device, 0, wxEXPAND | wxALL, 5);
+		portal_audio_row->AddSpacer(0);
+
+		m_portal_device->Bind(wxEVT_CHOICE, &GeneralSettings2::OnAudioDeviceSelected, this);
+
+		portal_audio_row->Add(new wxStaticText(box, wxID_ANY, _("Volume")), 0, wxALIGN_CENTER_VERTICAL | wxALL, 5);
+		m_portal_volume = new wxSlider(box, wxID_ANY, 100, 0, 100);
+		portal_audio_row->Add(m_portal_volume, 0, wxEXPAND | wxALL, 5);
+		auto audio_pad_volume_text = new wxStaticText(box, wxID_ANY, "100%");
+		portal_audio_row->Add(audio_pad_volume_text, 0, wxALIGN_CENTER_VERTICAL | wxALL | wxALIGN_RIGHT, 5);
+
+		m_portal_volume->Bind(wxEVT_SLIDER, &GeneralSettings2::OnSliderChangedPercent, this, wxID_ANY, wxID_ANY, new wxControlObject(audio_pad_volume_text));
+		m_portal_volume->Bind(wxEVT_SLIDER, &GeneralSettings2::OnVolumeChanged, this);
+
+		box_sizer->Add(portal_audio_row, 1, wxEXPAND, 5);
+		audio_panel_sizer->Add(box_sizer, 0, wxEXPAND | wxALL, 5);
+	}
+
 	audio_panel->SetSizerAndFit(audio_panel_sizer);
 	return audio_panel;
 }
@@ -617,20 +764,37 @@ wxPanel* GeneralSettings2::AddAccountPage(wxNotebook* notebook)
 			m_delete_account->Enable(false);
 		}
 	}
-	
+
+
 	{
-		auto* box = new wxStaticBox(online_panel, wxID_ANY, _("Online settings"));
+		wxString choices[] = { _("Offline"),  _("Nintendo"), _("Pretendo"), _("Custom") };
+		m_active_service = new wxRadioBox(online_panel, wxID_ANY, _("Network Service"), wxDefaultPosition, wxDefaultSize, std::size(choices), choices, 4, wxRA_SPECIFY_COLS);
+		if (!NetworkConfig::XMLExists())
+			m_active_service->Enable(3, false);
+
+		m_active_service->SetItemToolTip(0, _("Online functionality disabled for this account"));
+		m_active_service->SetItemToolTip(1, _("Connect to the official Nintendo Network Service"));
+		m_active_service->SetItemToolTip(2, _("Connect to the Pretendo Network Service"));
+		m_active_service->SetItemToolTip(3, _("Connect to a custom Network Service (configured via network_services.xml)"));
+
+		m_active_service->Bind(wxEVT_RADIOBOX, &GeneralSettings2::OnAccountServiceChanged,this);
+		online_panel_sizer->Add(m_active_service, 0, wxEXPAND | wxALL, 5);
+
+		if (CafeSystem::IsTitleRunning())
+		{
+			m_active_service->Enable(false);
+		}
+	}
+
+	{
+		auto* box = new wxStaticBox(online_panel, wxID_ANY, _("Online play requirements"));
 		auto* box_sizer = new wxStaticBoxSizer(box, wxVERTICAL);
-		
-		m_online_enabled = new wxCheckBox(box, wxID_ANY, _("Enable online mode"));
-		m_online_enabled->Bind(wxEVT_CHECKBOX, &GeneralSettings2::OnOnlineEnable, this);
-		box_sizer->Add(m_online_enabled, 0, wxEXPAND | wxALL, 5);
 
 		auto* row = new wxFlexGridSizer(0, 2, 0, 0);
 		row->SetFlexibleDirection(wxBOTH);
 		row->SetNonFlexibleGrowMode(wxFLEX_GROWMODE_SPECIFIED);
 		
-		const wxImage tmp = wxBITMAP_PNG(PNG_ERROR).ConvertToImage();
+		const wxImage tmp = wxBITMAP_PNG_FROM_DATA(PNG_ERROR).ConvertToImage();
 		m_validate_online = new wxBitmapButton(box, wxID_ANY, tmp.Scale(16, 16));
 		m_validate_online->Bind(wxEVT_BUTTON, &GeneralSettings2::OnShowOnlineValidator, this);
 		row->Add(m_validate_online, 0, wxEXPAND | wxALL, 5);
@@ -661,7 +825,7 @@ wxPanel* GeneralSettings2::AddAccountPage(wxNotebook* notebook)
 		m_account_grid->SetMinSize({ 300, -1 });
 		//m_account_grid->Append(new wxPropertyCategory("Main"));
 
-		auto* persistent_id_gprop = m_account_grid->Append(new wxStringProperty(wxT("PersistentId"), kPropertyPersistentId));
+		auto* persistent_id_gprop = m_account_grid->Append(new wxStringProperty("PersistentId", kPropertyPersistentId));
 		persistent_id_gprop->SetHelpString(_("The persistent id is the internal folder name used for your saves"));
 		m_account_grid->SetPropertyReadOnly(persistent_id_gprop);
 
@@ -671,12 +835,12 @@ wxPanel* GeneralSettings2::AddAccountPage(wxNotebook* notebook)
 		wxPGChoices gender;
 		gender.Add(_("Female"), 0);
 		gender.Add(_("Male"), 1);
-		m_account_grid->Append(new wxEnumProperty("Gender", kPropertyGender, gender));
+		m_account_grid->Append(new wxEnumProperty(_("Gender"), kPropertyGender, gender));
 
 		m_account_grid->Append(new wxStringProperty(_("Email"), kPropertyEmail));
 
 		wxPGChoices countries;
-		for (int i = 0; i < 195; ++i)
+		for (int i = 0; i < NCrypto::GetCountryCount(); ++i)
 		{
 			const auto country = NCrypto::GetCountryAsString(i);
 			if (country && (i == 0 || !boost::equals(country, "NN")))
@@ -705,19 +869,42 @@ wxPanel* GeneralSettings2::AddDebugPage(wxNotebook* notebook)
 	auto* panel = new wxPanel(notebook, wxID_ANY, wxDefaultPosition, wxDefaultSize, wxTAB_TRAVERSAL);
 	auto* debug_panel_sizer = new wxBoxSizer(wxVERTICAL);
 
-	auto* debug_row = new wxFlexGridSizer(0, 2, 0, 0);
-	debug_row->SetFlexibleDirection(wxBOTH);
-	debug_row->SetNonFlexibleGrowMode(wxFLEX_GROWMODE_SPECIFIED);
+	{
+		auto* debug_row = new wxFlexGridSizer(0, 2, 0, 0);
+		debug_row->SetFlexibleDirection(wxBOTH);
+		debug_row->SetNonFlexibleGrowMode(wxFLEX_GROWMODE_SPECIFIED);
 
-	debug_row->Add(new wxStaticText(panel, wxID_ANY, _("Crash dump"), wxDefaultPosition, wxDefaultSize, 0), 0, wxALIGN_CENTER_VERTICAL | wxALL, 5);
+		debug_row->Add(new wxStaticText(panel, wxID_ANY, _("Crash dump"), wxDefaultPosition, wxDefaultSize, 0), 0, wxALIGN_CENTER_VERTICAL | wxALL, 5);
 
-	wxString dump_choices[] = { _("Disabled"), _("Lite"), _("Full") };
-	m_crash_dump = new wxChoice(panel, wxID_ANY, wxDefaultPosition, wxDefaultSize, std::size(dump_choices), dump_choices);
-	m_crash_dump->SetSelection(0);
-	m_crash_dump->SetToolTip(_("Creates a dump when Cemu crashes\nOnly enable when requested by a developer!\nThe Full option will create a very large dump file (includes a full RAM dump of the Cemu process)"));
-	debug_row->Add(m_crash_dump, 0, wxALL | wxEXPAND, 5);
+#if BOOST_OS_WINDOWS
+		wxString dump_choices[] = {_("Disabled"), _("Lite"), _("Full")};
+#elif BOOST_OS_UNIX
+		wxString dump_choices[] = {_("Disabled"), _("Enabled")};
+#endif
+		m_crash_dump = new wxChoice(panel, wxID_ANY, wxDefaultPosition, wxDefaultSize, std::size(dump_choices), dump_choices);
+		m_crash_dump->SetSelection(0);
+#if BOOST_OS_WINDOWS
+		m_crash_dump->SetToolTip(_("Creates a dump when Cemu crashes\nOnly enable when requested by a developer!\nThe Full option will create a very large dump file (includes a full RAM dump of the Cemu process)"));
+#elif BOOST_OS_UNIX
+		m_crash_dump->SetToolTip(_("Creates a core dump when Cemu crashes\nOnly enable when requested by a developer!"));
+#endif
+		debug_row->Add(m_crash_dump, 0, wxALL | wxEXPAND, 5);
+		debug_panel_sizer->Add(debug_row, 0, wxALL | wxEXPAND, 5);
+	}
 
-	debug_panel_sizer->Add(debug_row, 0, wxALL | wxEXPAND, 5);
+	{
+		auto* debug_row = new wxFlexGridSizer(0, 2, 0, 0);
+		debug_row->SetFlexibleDirection(wxBOTH);
+		debug_row->SetNonFlexibleGrowMode(wxFLEX_GROWMODE_SPECIFIED);
+
+		debug_row->Add(new wxStaticText(panel, wxID_ANY, _("GDB Stub port"), wxDefaultPosition, wxDefaultSize, 0), 0, wxALIGN_CENTER_VERTICAL | wxALL, 5);
+
+		m_gdb_port = new wxSpinCtrl(panel, wxID_ANY, "1337", wxDefaultPosition, wxDefaultSize, 0, 1000, 65535);
+		m_gdb_port->SetToolTip(_("Changes the port that the GDB stub will use, which you can use by either starting Cemu with the --enable-gdbstub option or by enabling it the Debug tab."));
+
+		debug_row->Add(m_gdb_port, 0, wxALL | wxEXPAND, 5);
+		debug_panel_sizer->Add(debug_row, 0, wxALL | wxEXPAND, 5);
+	}
 
 	panel->SetSizerAndFit(debug_panel_sizer);
 
@@ -760,6 +947,14 @@ GeneralSettings2::GeneralSettings2(wxWindow* parent, bool game_launched)
 	DisableSettings(game_launched);
 }
 
+uint32 GeneralSettings2::GetSelectedAccountPersistentId()
+{
+	const auto active_account = m_active_account->GetSelection();
+	if (active_account == wxNOT_FOUND)
+		return GetConfig().account.m_persistent_id.GetInitValue();
+	return dynamic_cast<wxAccountData*>(m_active_account->GetClientObject(active_account))->GetAccount().GetPersistentId();
+}
+
 void GeneralSettings2::StoreConfig() 
 {
 	auto* app = (CemuApp*)wxTheApp;
@@ -769,34 +964,19 @@ void GeneralSettings2::StoreConfig()
 	config.fullscreen_menubar = m_fullscreen_menubar->IsChecked();
 	config.check_update = m_auto_update->IsChecked();
 	config.save_screenshot = m_save_screenshot->IsChecked();
-
-	const bool use_ps = m_permanent_storage->IsChecked();
-	if(use_ps)
+	config.receive_untested_updates = m_receive_untested_releases->IsChecked();
+#if BOOST_OS_LINUX && defined(ENABLE_FERAL_GAMEMODE)
+    config.feral_gamemode = m_feral_gamemode->IsChecked();
+#endif
+	config.play_boot_sound = m_play_boot_sound->IsChecked();
+	config.disable_screensaver = m_disable_screensaver->IsChecked();
+	// Toggle while a game is running
+	if (CafeSystem::IsTitleRunning())
 	{
-		config.permanent_storage = use_ps;
-		try
-		{
-			
-			PermanentStorage storage;
-			storage.RemoveStorage();
-		}
-		catch (...) {}
-	}
-	else
-	{	
-		try
-		{
-			// delete permanent storage
-			PermanentStorage storage;
-			storage.RemoveStorage();
-		}
-		catch (...) {}
-		config.permanent_storage = use_ps;
+		ScreenSaver::SetInhibit(config.disable_screensaver);
 	}
 
-	if (!LaunchSettings::GetMLCPath().has_value())
-		config.SetMLCPath(m_mlc_path->GetValue().ToStdWstring(), false);
-	
+
 	// -1 is default wx widget value -> set to dummy 0 so mainwindow and padwindow will update it
 	config.window_position = m_save_window_position_size->IsChecked() ? Vector2i{ 0,0 } : Vector2i{-1,-1};
 	config.window_size = m_save_window_position_size->IsChecked() ? Vector2i{ 0,0 } : Vector2i{-1,-1};
@@ -805,19 +985,17 @@ void GeneralSettings2::StoreConfig()
 
 	config.game_paths.clear();
 	for (auto& path : m_game_paths->GetStrings())
-		config.game_paths.emplace_back(path);
+		config.game_paths.emplace_back(path.utf8_string());
 
 	auto selection = m_language->GetSelection();
 	if (selection == 0)
 		GetConfig().language = wxLANGUAGE_DEFAULT;
-	else if (selection == 1)
-		GetConfig().language = wxLANGUAGE_ENGLISH;
 	else
 	{
 		const auto language = m_language->GetStringSelection();
 		for (const auto& lang : app->GetLanguages())
 		{
-			if (lang->Description == language)
+			if (lang->DescriptionNative == language)
 			{
 				GetConfig().language = lang->Language;
 				break;
@@ -839,11 +1017,15 @@ void GeneralSettings2::StoreConfig()
 	config.tv_channels = (AudioChannels)m_tv_channels->GetSelection();
 	//config.pad_channels =  (AudioChannels)m_pad_channels->GetSelection();
 	config.pad_channels = kStereo; // (AudioChannels)m_pad_channels->GetSelection();
+	//config.input_channels =  (AudioChannels)m_input_channels->GetSelection();
+	config.input_channels = kMono; // (AudioChannels)m_input_channels->GetSelection();
 	
 	config.tv_volume = m_tv_volume->GetValue();
 	config.pad_volume = m_pad_volume->GetValue();
+	config.input_volume = m_input_volume->GetValue();
+	config.portal_volume = m_portal_volume->GetValue();
 
-	config.tv_device = L"";
+	config.tv_device.clear();
 	const auto tv_device = m_tv_device->GetSelection();
 	if (tv_device != wxNOT_FOUND && tv_device != 0 && m_tv_device->HasClientObjectData())
 	{
@@ -852,7 +1034,7 @@ void GeneralSettings2::StoreConfig()
 			config.tv_device = device_description->GetDescription()->GetIdentifier();
 	}
 
-	config.pad_device = L"";
+	config.pad_device.clear();
 	const auto pad_device = m_pad_device->GetSelection();
 	if (pad_device != wxNOT_FOUND && pad_device != 0 && m_pad_device->HasClientObjectData())
 	{
@@ -861,6 +1043,24 @@ void GeneralSettings2::StoreConfig()
 			config.pad_device = device_description->GetDescription()->GetIdentifier();
 	}
 
+	config.input_device = L"";
+	const auto input_device = m_input_device->GetSelection();
+	if (input_device != wxNOT_FOUND && input_device != 0 && m_input_device->HasClientObjectData())
+	{
+		const auto* device_description = (wxDeviceDescription*)m_input_device->GetClientObject(input_device);
+		if (device_description)
+			config.input_device = device_description->GetDescription()->GetIdentifier();
+	}
+
+	config.portal_device.clear();
+	const auto portal_device = m_portal_device->GetSelection();
+	if (portal_device != wxNOT_FOUND && portal_device != 0 && m_portal_device->HasClientObjectData())
+	{
+		const auto* device_description = (wxDeviceDescription*)m_portal_device->GetClientObject(portal_device);
+		if (device_description)
+			config.portal_device = device_description->GetDescription()->GetIdentifier();
+	}
+
 	// graphics
 	config.graphic_api = (GraphicAPI)m_graphic_api->GetSelection();
 
@@ -906,16 +1106,11 @@ void GeneralSettings2::StoreConfig()
 	config.notification.friends = m_friends_data->GetValue();
 
 	// account
-	const auto active_account = m_active_account->GetSelection();
-	if (active_account == wxNOT_FOUND)
-		config.account.m_persistent_id = config.account.m_persistent_id.GetInitValue();
-	else
-		config.account.m_persistent_id = dynamic_cast<wxAccountData*>(m_active_account->GetClientObject(active_account))->GetAccount().GetPersistentId();
-
-	config.account.online_enabled = m_online_enabled->GetValue();
+	config.account.m_persistent_id = GetSelectedAccountPersistentId();
 
 	// debug
 	config.crash_dump = (CrashDump)m_crash_dump->GetSelection();
+	config.gdb_port = m_gdb_port->GetValue();
 
 	g_config.Save();
 }
@@ -958,19 +1153,34 @@ void GeneralSettings2::OnAudioLatencyChanged(wxCommandEvent& event)
 
 void GeneralSettings2::OnVolumeChanged(wxCommandEvent& event)
 {
-	std::shared_lock lock(g_audioMutex);
-	if(event.GetEventObject() == m_pad_volume)
+	
+	if(event.GetEventObject() == m_input_volume)
 	{
-		if (g_padAudio)
-		{
-			g_padAudio->SetVolume(event.GetInt());
-			g_padVolume = event.GetInt();
-		}
+		std::shared_lock lock(g_audioInputMutex);
+		if (g_inputAudio)
+			g_inputAudio->SetVolume(event.GetInt());
 	}
 	else
 	{
-		if (g_tvAudio)
-			g_tvAudio->SetVolume(event.GetInt());
+		std::shared_lock lock(g_audioMutex);
+		if(event.GetEventObject() == m_pad_volume)
+		{
+			if (g_padAudio)
+			{
+				g_padAudio->SetVolume(event.GetInt());
+				g_padVolume = event.GetInt();
+			}
+		}
+		else if (event.GetEventObject() == m_tv_volume)
+		{
+			if (g_tvAudio)
+				g_tvAudio->SetVolume(event.GetInt());
+		}
+		else
+		{
+			if(g_portalAudio)
+				g_portalAudio->SetVolume(event.GetInt());
+		}
 	}
 	
 
@@ -1029,9 +1239,13 @@ void GeneralSettings2::UpdateAudioDeviceList()
 {
 	m_tv_device->Clear();
 	m_pad_device->Clear();
+	m_input_device->Clear();
+	m_portal_device->Clear();
 
 	m_tv_device->Append(_("Disabled"));
 	m_pad_device->Append(_("Disabled"));
+	m_input_device->Append(_("Disabled"));
+	m_portal_device->Append(_("Disabled"));
 
 	const auto audio_api = (IAudioAPI::AudioAPI)GetConfig().audio_api;
 	const auto devices = IAudioAPI::GetDevices(audio_api);
@@ -1039,6 +1253,15 @@ void GeneralSettings2::UpdateAudioDeviceList()
 	{
 		m_tv_device->Append(device->GetName(), new wxDeviceDescription(device));
 		m_pad_device->Append(device->GetName(), new wxDeviceDescription(device));
+		m_portal_device->Append(device->GetName(), new wxDeviceDescription(device));
+	}
+
+	const auto input_audio_api = IAudioInputAPI::Cubeb; //(IAudioAPI::AudioAPI)GetConfig().input_audio_api;
+	const auto input_devices = IAudioInputAPI::GetDevices(input_audio_api);
+
+	for (auto& device : input_devices)
+	{
+		m_input_device->Append(device->GetName(), new wxInputDeviceDescription(device));
 	}
 
 	if(m_tv_device->GetCount() > 1)
@@ -1048,6 +1271,10 @@ void GeneralSettings2::UpdateAudioDeviceList()
 
 	m_pad_device->SetSelection(0);
 
+	m_input_device->SetSelection(0);
+
+	m_portal_device->SetSelection(0);
+
 	// todo reset global instance of audio device
 }
 
@@ -1134,7 +1361,7 @@ void GeneralSettings2::OnAccountDelete(wxCommandEvent& event)
 	catch(const std::exception& ex)
 	{
 		SystemException sys(ex);
-		forceLog_printf((char*)sys.what());
+		cemuLog_log(LogType::Force, sys.what());
 	}
 	
 }
@@ -1215,14 +1442,13 @@ void GeneralSettings2::UpdateAccountInformation()
 {
 	m_account_grid->SetSplitterPosition(100);
 
-	m_online_status->SetLabel(_("At least one issue has been found"));
-	
 	const auto selection = m_active_account->GetSelection();
 	if(selection == wxNOT_FOUND)
 	{
-		m_validate_online->SetBitmap(wxBITMAP_PNG(PNG_ERROR).ConvertToImage().Scale(16, 16));
+		m_validate_online->SetBitmap(wxBITMAP_PNG_FROM_DATA(PNG_ERROR).ConvertToImage().Scale(16, 16));
 		m_validate_online->SetWindowStyleFlag(m_validate_online->GetWindowStyleFlag() & ~wxBORDER_NONE);
 		ResetAccountInformation();
+		m_online_status->SetLabel(_("No account selected"));
 		return;
 	}
 
@@ -1248,20 +1474,56 @@ void GeneralSettings2::UpdateAccountInformation()
 		index = 0;
 	country_property->SetChoiceSelection(index);
 
-	const bool online_valid = account.IsValidOnlineAccount() && ActiveSettings::HasRequiredOnlineFiles();
-	if (online_valid)
+	const bool online_fully_valid = account.IsValidOnlineAccount() && ActiveSettings::HasRequiredOnlineFiles();
+	if (ActiveSettings::HasRequiredOnlineFiles())
 	{
-		
-		m_online_status->SetLabel(_("Your account is a valid online account"));
-		m_validate_online->SetBitmap(wxBITMAP_PNG(PNG_CHECK_YES).ConvertToImage().Scale(16, 16));
+		if(account.IsValidOnlineAccount())
+			m_online_status->SetLabel(_("Selected account is a valid online account"));
+		else
+			m_online_status->SetLabel(_("Selected account is not linked to a NNID or PNID"));
+	}
+	else
+	{
+		if(NCrypto::OTP_IsPresent() != NCrypto::SEEPROM_IsPresent())
+			m_online_status->SetLabel(_("OTP.bin or SEEPROM.bin is missing"));
+		else if(NCrypto::OTP_IsPresent() && NCrypto::SEEPROM_IsPresent())
+			m_online_status->SetLabel(_("OTP and SEEPROM present but no certificate files were found"));
+		else
+			m_online_status->SetLabel(_("Online play is not set up. Follow the guide below to get started"));
+	}
+
+	if(online_fully_valid)
+	{
+		m_validate_online->SetBitmap(wxBITMAP_PNG_FROM_DATA(PNG_CHECK_YES).ConvertToImage().Scale(16, 16));
 		m_validate_online->SetWindowStyleFlag(m_validate_online->GetWindowStyleFlag() | wxBORDER_NONE);
 	}
 	else
 	{
-		m_validate_online->SetBitmap(wxBITMAP_PNG(PNG_ERROR).ConvertToImage().Scale(16, 16));
+		m_validate_online->SetBitmap(wxBITMAP_PNG_FROM_DATA(PNG_ERROR).ConvertToImage().Scale(16, 16));
 		m_validate_online->SetWindowStyleFlag(m_validate_online->GetWindowStyleFlag() & ~wxBORDER_NONE);
 	}
-	
+
+	// enable/disable network service field depending on online requirements
+	m_active_service->Enable(online_fully_valid && !CafeSystem::IsTitleRunning());
+	if(online_fully_valid)
+	{
+		NetworkService service = GetConfig().GetAccountNetworkService(account.GetPersistentId());
+		m_active_service->SetSelection(static_cast<int>(service));
+		// set the config option here for the selected service
+		// this will guarantee that it's actually written to settings.xml
+		// allowing us to eventually get rid of the legacy option in the (far) future
+		GetConfig().SetAccountSelectedService(account.GetPersistentId(), service);
+	}
+	else
+	{
+		m_active_service->SetSelection(0); // force offline
+	}
+	wxString tmp = _("Network service");
+	tmp.append(" (");
+	tmp.append(wxString::FromUTF8(boost::nowide::narrow(account.GetMiiName())));
+	tmp.append(")");
+	m_active_service->SetLabel(tmp);
+
 	// refresh pane size
 	m_account_grid->InvalidateBestSize();
 	//m_account_grid->GetParent()->FitInside();
@@ -1315,8 +1577,9 @@ void GeneralSettings2::HandleGraphicsApiSelection()
 		m_vsync->AppendString(_("Off"));
 		m_vsync->AppendString(_("Double buffering"));
 		m_vsync->AppendString(_("Triple buffering"));
-	
+#if BOOST_OS_WINDOWS
 		m_vsync->AppendString(_("Match emulated display (Experimental)"));
+#endif
 
 		m_vsync->Select(selection);
 		
@@ -1350,9 +1613,9 @@ void GeneralSettings2::ApplyConfig()
 	auto& config = GetConfig();
 
 	if (LaunchSettings::GetMLCPath().has_value())
-		m_mlc_path->SetValue(wxString{ LaunchSettings::GetMLCPath().value().generic_wstring() });
+		m_mlc_path->SetValue(wxHelper::FromPath(LaunchSettings::GetMLCPath().value()));
 	else
-		m_mlc_path->SetValue(config.mlc_path.GetValue());
+		m_mlc_path->SetValue(wxHelper::FromUtf8(config.mlc_path.GetValue()));
 
 	m_save_window_position_size->SetValue(config.window_position != Vector2i{-1,-1});
 	m_save_padwindow_position_size->SetValue(config.pad_position != Vector2i{-1,-1});
@@ -1361,13 +1624,23 @@ void GeneralSettings2::ApplyConfig()
 	m_fullscreen_menubar->SetValue(config.fullscreen_menubar);
 
 	m_auto_update->SetValue(config.check_update);
+	m_receive_untested_releases->SetValue(config.receive_untested_updates);
 	m_save_screenshot->SetValue(config.save_screenshot);
 
-	m_permanent_storage->SetValue(config.permanent_storage);
-	
+	m_disable_screensaver->SetValue(config.disable_screensaver);
+	m_play_boot_sound->SetValue(config.play_boot_sound);
+#if BOOST_OS_LINUX && defined(ENABLE_FERAL_GAMEMODE)
+    	m_feral_gamemode->SetValue(config.feral_gamemode);
+#endif
+	// temporary workaround because feature crashes on macOS
+#if BOOST_OS_MACOS
+	m_disable_screensaver->SetValue(false);
+#endif
+
+	m_game_paths->Clear();
 	for (auto& path : config.game_paths)
 	{
-		m_game_paths->Append(path);
+		m_game_paths->Append(to_wxString(path));
 	}
 
 	const auto app = (CemuApp*)wxTheApp;
@@ -1375,7 +1648,7 @@ void GeneralSettings2::ApplyConfig()
 	{
 		if (config.language == language->Language)
 		{
-			m_language->SetStringSelection(language->Description);
+			m_language->SetStringSelection(language->DescriptionNative);
 			break;
 		}
 	}
@@ -1433,6 +1706,8 @@ void GeneralSettings2::ApplyConfig()
 	m_tv_channels->SetSelection(config.tv_channels);
 	//m_pad_channels->SetSelection(config.pad_channels);
 	m_pad_channels->SetSelection(0);
+	//m_input_channels->SetSelection(config.pad_channels);
+	m_input_channels->SetSelection(0);
 	
 	SendSliderEvent(m_tv_volume, config.tv_volume);
 
@@ -1467,6 +1742,38 @@ void GeneralSettings2::ApplyConfig()
 	else
 		m_pad_device->SetSelection(0);
 
+	SendSliderEvent(m_input_volume, config.input_volume);
+	if (!config.input_device.empty() && m_input_device->HasClientObjectData())
+	{
+		for (uint32 i = 0; i < m_input_device->GetCount(); ++i)
+		{
+			const auto device_description = (wxInputDeviceDescription*)m_input_device->GetClientObject(i);
+			if (device_description && config.input_device == device_description->GetDescription()->GetIdentifier())
+			{
+				m_input_device->SetSelection(i);
+				break;
+			}
+		}
+	}
+	else
+		m_input_device->SetSelection(0);
+
+	SendSliderEvent(m_portal_volume, config.portal_volume);
+	if (!config.portal_device.empty() && m_portal_device->HasClientObjectData())
+	{
+		for (uint32 i = 0; i < m_portal_device->GetCount(); ++i)
+		{
+			const auto device_description = (wxDeviceDescription*)m_portal_device->GetClientObject(i);
+			if (device_description && config.portal_device == device_description->GetDescription()->GetIdentifier())
+			{
+				m_portal_device->SetSelection(i);
+				break;
+			}
+		}
+	}
+	else
+		m_portal_device->SetSelection(0);
+
 	// account
 	UpdateOnlineAccounts();
 	m_active_account->SetSelection(0);
@@ -1480,28 +1787,15 @@ void GeneralSettings2::ApplyConfig()
 			break;
 		}
 	}
-	
-	m_online_enabled->SetValue(config.account.online_enabled);
+	m_active_service->SetSelection((int)config.GetAccountNetworkService(ActiveSettings::GetPersistentId()));
+
 	UpdateAccountInformation();
 
 	// debug
 	m_crash_dump->SetSelection((int)config.crash_dump.GetValue());
+	m_gdb_port->SetValue(config.gdb_port.GetValue());
 }
 
-void GeneralSettings2::OnOnlineEnable(wxCommandEvent& event)
-{
-	event.Skip();
-	if (!m_online_enabled->GetValue())
-		return;
-
-	// show warning if player enables online mode
-	const auto result = wxMessageBox(_("Please be aware that online mode lets you connect to OFFICIAL servers and therefore there is a risk of getting banned.\nOnly proceed if you are willing to risk losing online access with your Wii U and/or NNID."),
-		_("Warning"), wxYES_NO | wxCENTRE | wxICON_EXCLAMATION, this);
-	if (result == wxNO)
-		m_online_enabled->SetValue(false);
-}
-
-
 void GeneralSettings2::OnAudioAPISelected(wxCommandEvent& event)
 {
 	IAudioAPI::AudioAPI api;
@@ -1530,6 +1824,9 @@ void GeneralSettings2::UpdateAudioDevice()
 {
 	auto& config = GetConfig();
 
+	std::unique_lock lock(g_audioMutex);
+	std::unique_lock inputLock(g_audioInputMutex);
+
 	// tv audio device
 	{
 		const auto selection = m_tv_device->GetSelection();
@@ -1539,41 +1836,27 @@ void GeneralSettings2::UpdateAudioDevice()
 			return;
 		}
 
+		g_tvAudio.reset();
+
 		if (m_tv_device->HasClientObjectData())
 		{
 			const auto description = (wxDeviceDescription*)m_tv_device->GetClientObject(selection);
 			if (description)
 			{
-				std::unique_lock lock(g_audioMutex);
-
 				sint32 channels;
 				if (m_game_launched && g_tvAudio)
 					channels = g_tvAudio->GetChannels();
 				else
-				{
-					switch (config.tv_channels)
-					{
-					case 0:
-						channels = 1;
-						break;
-					case 2:
-						channels = 6;
-						break;
-					default: // stereo
-						channels = 2;
-						break;
-					}
-				}
+					channels = CemuConfig::AudioChannelsToNChannels(config.tv_channels);
 
 				try
 				{
-					g_tvAudio.reset();
 					g_tvAudio = IAudioAPI::CreateDevice((IAudioAPI::AudioAPI)config.audio_api, description->GetDescription(), 48000, channels, snd_core::AX_SAMPLES_PER_3MS_48KHZ * AX_FRAMES_PER_GROUP, 16);
 					g_tvAudio->SetVolume(m_tv_volume->GetValue());
 				}
 				catch (std::runtime_error& ex)
 				{
-					forceLog_printf("can't initialize tv audio: %s", ex.what());
+					cemuLog_log(LogType::Force, "can't initialize tv audio: {}", ex.what());
 				}
 			}
 		}
@@ -1588,46 +1871,103 @@ void GeneralSettings2::UpdateAudioDevice()
 			return;
 		}
 
+		g_padAudio.reset();
+
 		if (m_pad_device->HasClientObjectData())
 		{
 			const auto description = (wxDeviceDescription*)m_pad_device->GetClientObject(selection);
 			if (description)
 			{
-				std::unique_lock lock(g_audioMutex);
-
 				sint32 channels;
 				if (m_game_launched && g_padAudio)
 					channels = g_padAudio->GetChannels();
 				else
-				{
-					switch (config.pad_channels)
-					{
-					case 0:
-						channels = 1;
-						break;
-					case 2:
-						channels = 6;
-						break;
-					default: // stereo
-						channels = 2;
-						break;
-					}
-				}
+					channels = CemuConfig::AudioChannelsToNChannels(config.pad_channels);
 
 				try
 				{
-					g_padAudio.reset();
 					g_padAudio = IAudioAPI::CreateDevice((IAudioAPI::AudioAPI)config.audio_api, description->GetDescription(), 48000, channels, snd_core::AX_SAMPLES_PER_3MS_48KHZ * AX_FRAMES_PER_GROUP, 16);
 					g_padAudio->SetVolume(m_pad_volume->GetValue());
 					g_padVolume = m_pad_volume->GetValue();
 				}
 				catch (std::runtime_error& ex)
 				{
-					forceLog_printf("can't initialize pad audio: %s", ex.what());
+					cemuLog_log(LogType::Force, "can't initialize pad audio: {}", ex.what());
 				}
 			}
 		}
 	}
+
+	// input audio device
+	{
+		const auto selection = m_input_device->GetSelection();
+		if (selection == wxNOT_FOUND)
+		{
+			cemu_assert_debug(false);
+			return;
+		}
+
+		g_inputAudio.reset();
+
+		if (m_input_device->HasClientObjectData())
+		{
+			const auto description = (wxInputDeviceDescription*)m_input_device->GetClientObject(selection);
+			if (description)
+			{
+				sint32 channels;
+				if (m_game_launched && g_inputAudio)
+					channels = g_inputAudio->GetChannels();
+				else
+					channels = CemuConfig::AudioChannelsToNChannels(config.input_channels);
+
+				try
+				{
+					g_inputAudio = IAudioInputAPI::CreateDevice(IAudioInputAPI::AudioInputAPI::Cubeb, description->GetDescription(), 32000, channels, snd_core::AX_SAMPLES_PER_3MS_32KHZ, 16);
+					g_inputAudio->SetVolume(m_input_volume->GetValue());
+				}
+				catch (std::runtime_error& ex)
+				{
+					cemuLog_log(LogType::Force, "can't initialize pad audio: {}", ex.what());
+				}
+			}
+		}
+	}
+
+	// skylander portal audio device
+	{
+		const auto selection = m_portal_device->GetSelection();
+		if (selection == wxNOT_FOUND)
+		{
+			cemu_assert_debug(false);
+			return;
+		}
+
+		g_portalAudio.reset();
+
+		if (m_portal_device->HasClientObjectData())
+		{
+			const auto description = (wxDeviceDescription*)m_portal_device->GetClientObject(selection);
+			if (description)
+			{
+				sint32 channels;
+				if (m_game_launched && g_portalAudio)
+					channels = g_portalAudio->GetChannels();
+				else
+					channels = 1;
+					
+				try
+				{
+					g_portalAudio = IAudioAPI::CreateDevice((IAudioAPI::AudioAPI)config.audio_api, description->GetDescription(), 8000, 1, 32, 16);
+					g_portalAudio->SetVolume(m_portal_volume->GetValue());
+				}
+				catch (std::runtime_error& ex)
+				{
+					cemuLog_log(LogType::Force, "can't initialize portal audio: {}", ex.what());
+				}
+			}
+		}
+
+	}
 }
 
 void GeneralSettings2::OnAudioDeviceSelected(wxCommandEvent& event)
@@ -1716,33 +2056,80 @@ void GeneralSettings2::OnActiveAccountChanged(wxCommandEvent& event)
 	m_has_account_change = true;
 }
 
-void GeneralSettings2::OnMLCPathSelect(wxCommandEvent& event)
+void GeneralSettings2::OnAccountServiceChanged(wxCommandEvent& event)
 {
-	if (!CemuApp::SelectMLCPath(this))
-		return;
-	
-	m_mlc_path->SetValue(ActiveSettings::GetMlcPath().generic_string());
-	m_reload_gamelist = true;
-	m_mlc_modified = true;
-	CemuApp::CreateDefaultFiles();
+	auto& config = GetConfig();
+	uint32 peristentId = GetSelectedAccountPersistentId();
+	config.SetAccountSelectedService(peristentId, static_cast<NetworkService>(m_active_service->GetSelection()));
+	UpdateAccountInformation();
 }
 
-void GeneralSettings2::OnMLCPathChar(wxKeyEvent& event)
+void GeneralSettings2::OnMLCPathSelect(wxCommandEvent& event)
 {
-	if (LaunchSettings::GetMLCPath().has_value())
-		return;
-
-	if(event.GetKeyCode() == WXK_DELETE || event.GetKeyCode() == WXK_BACK)
+	if(CafeSystem::IsTitleRunning())
 	{
-		m_mlc_path->SetValue(wxEmptyString);
-		m_reload_gamelist = true;
-
-		GetConfig().mlc_path = L"";
-		g_config.Save();
-		m_mlc_modified = true;
-		
-		CemuApp::CreateDefaultFiles();
+		wxMessageBox(_("Can't change MLC path while a game is running!"), _("Error"), wxOK | wxCENTRE | wxICON_ERROR, this);
+		return;
 	}
+	// show directory dialog
+	wxDirDialog path_dialog(this, _("Select MLC directory"), wxEmptyString, wxDD_DEFAULT_STYLE | wxDD_DIR_MUST_EXIST);
+	if (path_dialog.ShowModal() != wxID_OK || path_dialog.GetPath().empty())
+		return;
+	// check if the choosen MLC path is an already initialized MLC location
+	fs::path newMlc = wxHelper::MakeFSPath(path_dialog.GetPath());
+	if(CemuApp::CheckMLCPath(newMlc))
+	{
+		// ask user if they are sure they want to use this folder and let them know that accounts and saves wont transfer
+		wxString message = _("Note that changing the MLC location will not transfer any accounts or save files. Are you sure you want to change the path?");
+		wxMessageDialog dialog(this, message, _("Warning"), wxYES_NO | wxCENTRE | wxICON_WARNING);
+		if(dialog.ShowModal() == wxID_NO)
+			return;
+		if( !CemuApp::CreateDefaultMLCFiles(newMlc) ) // creating also acts as a check for read+write access
+		{
+			wxMessageBox(_("Failed to create default MLC files in the selected directory. The MLC path has not been changed"), _("Error"), wxOK | wxCENTRE | wxICON_ERROR, this);
+			return;
+		}
+	}
+	else
+	{
+		// ask user if they want to create a new mlc structure at the choosen location
+		wxString message = _("The selected directory does not contain the expected MLC structure. Do you want to create a new MLC structure in this directory?\nNote that changing the MLC location will not transfer any accounts or save files.");
+		wxMessageDialog dialog(this, message, _("Warning"), wxYES_NO | wxCENTRE | wxICON_WARNING);
+		if( !CemuApp::CreateDefaultMLCFiles(newMlc) )
+		{
+			wxMessageBox(_("Failed to create default MLC files in the selected directory. The MLC path has not been changed"), _("Error"), wxOK | wxCENTRE | wxICON_ERROR, this);
+			return;
+		}
+	}
+	// update MLC path and store any other modified settings
+	GetConfig().SetMLCPath(newMlc);
+	StoreConfig();
+	wxMessageBox(_("Cemu needs to be restarted for the changes to take effect."), _("Information"), wxOK | wxCENTRE | wxICON_INFORMATION, this);
+	// close settings and then cemu
+	wxCloseEvent closeEvent(wxEVT_CLOSE_WINDOW);
+	wxPostEvent(this, closeEvent);
+	wxPostEvent(GetParent(), closeEvent);
+}
+
+void GeneralSettings2::OnMLCPathClear(wxCommandEvent& event)
+{
+	if(CafeSystem::IsTitleRunning())
+	{
+		wxMessageBox(_("Can't change MLC path while a game is running!"), _("Error"), wxOK | wxCENTRE | wxICON_ERROR, this);
+		return;
+	}
+	wxString message = _("Note that changing the MLC location will not transfer any accounts or save files. Are you sure you want to change the path?");
+	wxMessageDialog dialog(this, message, _("Warning"), wxYES_NO | wxCENTRE | wxICON_WARNING);
+	if(dialog.ShowModal() == wxID_NO)
+		return;
+	GetConfig().SetMLCPath("");
+	StoreConfig();
+	g_config.Save();
+	wxMessageBox(_("Cemu needs to be restarted for the changes to take effect."), _("Information"), wxOK | wxCENTRE | wxICON_INFORMATION, this);
+	// close settings and then cemu
+	wxCloseEvent closeEvent(wxEVT_CLOSE_WINDOW);
+	wxPostEvent(this, closeEvent);
+	wxPostEvent(GetParent(), closeEvent);
 }
 
 void GeneralSettings2::OnShowOnlineValidator(wxCommandEvent& event)
@@ -1759,44 +2146,61 @@ void GeneralSettings2::OnShowOnlineValidator(wxCommandEvent& event)
 	if (validator) // everything valid? shouldn't happen
 		return;
 	
-	std::wstringstream err;
-	err << L"The following error(s) have been found:" << std::endl;
+	wxString err;
+	err << _("The following error(s) have been found:") << '\n';
 	
 	if (validator.otp == OnlineValidator::FileState::Missing)
-		err << L"otp.bin missing in cemu root directory" << std::endl;
+		err << _("otp.bin missing in Cemu directory") << '\n';
 	else if(validator.otp == OnlineValidator::FileState::Corrupted)
-		err << L"otp.bin is invalid" << std::endl;
+		err << _("otp.bin is invalid") << '\n';
 	
 	if (validator.seeprom == OnlineValidator::FileState::Missing)
-		err << L"seeprom.bin missing in cemu root directory" << std::endl;
+		err << _("seeprom.bin missing in Cemu directory") << '\n';
 	else if(validator.seeprom == OnlineValidator::FileState::Corrupted)
-		err << L"seeprom.bin is invalid" << std::endl;
+		err << _("seeprom.bin is invalid") << '\n';
 
 	if(!validator.missing_files.empty())
 	{
-		err << L"Missing certificate and key files:" << std::endl;
+		err << _("Missing certificate and key files:") << '\n';
 
 		int counter = 0;
 		for (const auto& f : validator.missing_files)
 		{
-			err << f << std::endl;
+			err << f << '\n';
 
 			++counter;
 			if(counter > 10)
 			{
-				err << L"..." << std::endl;
+				err << "..." << '\n';
 				break;
 			}
 		}
 
-		err << std::endl;
+		err << '\n';
 	}
 
 	if (!validator.valid_account)
 	{
-		err << L"The currently selected account is not a valid or dumped online account:\n" << boost::nowide::widen(fmt::format("{}", validator.account_error));
+		err << _("The currently selected account is not a valid or dumped online account:") << '\n';
+		err << GetOnlineAccountErrorMessage(validator.account_error);
+	}
+
+	wxMessageBox(err, _("Online Status"), wxOK | wxCENTRE | wxICON_INFORMATION);
+}
+
+wxString GeneralSettings2::GetOnlineAccountErrorMessage(OnlineAccountError error)
+{
+	switch (error)
+	{
+		case OnlineAccountError::kNoAccountId:
+			return _("AccountId missing (The account is not connected to a NNID/PNID)");
+		case OnlineAccountError::kNoPasswordCached:
+			return _("IsPasswordCacheEnabled is set to false (The remember password option on your Wii U must be enabled for this account before dumping it)");
+		case OnlineAccountError::kPasswordCacheEmpty:
+			return _("AccountPasswordCache is empty (The remember password option on your Wii U must be enabled for this account before dumping it)");
+		case OnlineAccountError::kNoPrincipalId:
+			return _("PrincipalId missing");
+		default:
+			return "no error";
 	}
-		
-	
-	wxMessageBox(err.str(), _("Online Status"), wxOK | wxCENTRE | wxICON_INFORMATION);
 }
diff --git a/src/gui/GeneralSettings2.h b/src/gui/GeneralSettings2.h
index ed326d5a..5e27d6e2 100644
--- a/src/gui/GeneralSettings2.h
+++ b/src/gui/GeneralSettings2.h
@@ -1,6 +1,7 @@
 #pragma once
 #include <wx/collpane.h>
 #include <wx/propgrid/propgrid.h>
+#include <Cafe/Account/Account.h>
 
 class wxColourPickerCtrl;
 
@@ -40,8 +41,12 @@ private:
 	wxCheckBox* m_save_window_position_size;
 	wxCheckBox* m_save_padwindow_position_size;
 	wxCheckBox* m_discord_presence, *m_fullscreen_menubar;
-	wxCheckBox* m_auto_update, *m_save_screenshot;
-	wxCheckBox* m_permanent_storage;
+	wxCheckBox* m_auto_update, *m_receive_untested_releases, *m_save_screenshot;
+	wxCheckBox* m_disable_screensaver;
+	wxCheckBox* m_play_boot_sound;
+#if BOOST_OS_LINUX && defined(ENABLE_FERAL_GAMEMODE)
+   	wxCheckBox* m_feral_gamemode;
+#endif
 	wxListBox* m_game_paths;
 	wxTextCtrl* m_mlc_path;
 
@@ -58,14 +63,14 @@ private:
 	// Audio
 	wxChoice* m_audio_api;
 	wxSlider *m_audio_latency;
-	wxSlider *m_tv_volume, *m_pad_volume;
-	wxChoice *m_tv_channels, *m_pad_channels;
-	wxChoice *m_tv_device, *m_pad_device;
+	wxSlider *m_tv_volume, *m_pad_volume, *m_input_volume, *m_portal_volume;
+	wxChoice *m_tv_channels, *m_pad_channels, *m_input_channels;
+	wxChoice *m_tv_device, *m_pad_device, *m_input_device, *m_portal_device;
 
 	// Account
 	wxButton* m_create_account, * m_delete_account;
 	wxChoice* m_active_account;
-	wxCheckBox* m_online_enabled;
+	wxRadioBox* m_active_service;
 	wxCollapsiblePane* m_account_information;
 	wxPropertyGrid* m_account_grid;
 	wxBitmapButton* m_validate_online;
@@ -73,6 +78,7 @@ private:
 
 	// Debug
 	wxChoice* m_crash_dump;
+	wxSpinCtrl* m_gdb_port;
 
 	void OnAccountCreate(wxCommandEvent& event);
 	void OnAccountDelete(wxCommandEvent& event);
@@ -90,9 +96,12 @@ private:
 	void OnRemovePathClicked(wxCommandEvent& event);
 	void OnActiveAccountChanged(wxCommandEvent& event);
 	void OnMLCPathSelect(wxCommandEvent& event);
-	void OnMLCPathChar(wxKeyEvent& event);
+	void OnMLCPathClear(wxCommandEvent& event);
 	void OnShowOnlineValidator(wxCommandEvent& event);
-	void OnOnlineEnable(wxCommandEvent& event);
+	void OnAccountServiceChanged(wxCommandEvent& event);
+	static wxString GetOnlineAccountErrorMessage(OnlineAccountError error);
+
+	uint32 GetSelectedAccountPersistentId();
 
 	// updates cemu audio devices
 	void UpdateAudioDevice();
diff --git a/src/gui/GettingStartedDialog.cpp b/src/gui/GettingStartedDialog.cpp
index 30e5e557..b613c38c 100644
--- a/src/gui/GettingStartedDialog.cpp
+++ b/src/gui/GettingStartedDialog.cpp
@@ -4,6 +4,8 @@
 #include <wx/filepicker.h>
 #include <wx/statbox.h>
 #include <wx/msgdlg.h>
+#include <wx/radiobox.h>
+#include <wx/button.h>
 
 #include "config/ActiveSettings.h"
 #include "gui/CemuApp.h"
@@ -11,7 +13,6 @@
 #include "gui/GraphicPacksWindow2.h"
 #include "gui/input/InputSettings2.h"
 #include "config/CemuConfig.h"
-#include "config/PermanentConfig.h"
 
 #include "Cafe/TitleList/TitleList.h"
 
@@ -21,75 +22,100 @@
 
 #include "wxHelper.h"
 
+wxDEFINE_EVENT(EVT_REFRESH_FIRST_PAGE, wxCommandEvent); // used to refresh the first page after the language change
+
 wxPanel* GettingStartedDialog::CreatePage1()
 {
-	auto* result = new wxPanel(m_notebook, wxID_ANY, wxDefaultPosition, wxDefaultSize, wxTAB_TRAVERSAL);
+	auto* mainPanel = new wxPanel(m_notebook, wxID_ANY, wxDefaultPosition, wxDefaultSize, wxTAB_TRAVERSAL);
 	auto* page1_sizer = new wxBoxSizer(wxVERTICAL);
 	{
 		auto* sizer = new wxBoxSizer(wxHORIZONTAL);
-
-		sizer->Add(new wxStaticBitmap(result, wxID_ANY, wxICON(M_WND_ICON128)), 0, wxALIGN_CENTER_VERTICAL | wxALL, 5);
-
-		auto* m_staticText11 = new wxStaticText(result, wxID_ANY, _("It looks like you're starting Cemu for the first time.\nThis quick setup assistant will help you get the best experience"), wxDefaultPosition, wxDefaultSize, 0);
-		m_staticText11->Wrap(-1);
-		sizer->Add(m_staticText11, 0, wxALL, 5);
-
+		sizer->Add(new wxStaticBitmap(mainPanel, wxID_ANY, wxICON(M_WND_ICON128)), 0, wxALIGN_CENTER_VERTICAL | wxALL, 5);
+		m_page1.staticText11 = new wxStaticText(mainPanel, wxID_ANY, _("It looks like you're starting Cemu for the first time.\nThis quick setup assistant will help you get the best experience"), wxDefaultPosition, wxDefaultSize, 0);
+		m_page1.staticText11->Wrap(-1);
+		sizer->Add(m_page1.staticText11, 0, wxALL, 5);
 		page1_sizer->Add(sizer, 0, wxALL | wxEXPAND, 5);
 	}
 
+	if(ActiveSettings::IsPortableMode())
 	{
-		m_mlc_box_sizer = new wxStaticBoxSizer(wxVERTICAL, result, _("mlc01 path"));
-		m_mlc_box_sizer->Add(new wxStaticText(m_mlc_box_sizer->GetStaticBox(), wxID_ANY, _("The mlc path is the root folder of the emulated Wii U internal flash storage. It contains all your saves, installed updates and DLCs.\nIt is strongly recommend that you create a dedicated folder for it (example: C:\\wiiu\\mlc\\) \nIf left empty, the mlc folder will be created inside the Cemu folder.")), 0, wxALL, 5);
+		m_page1.portableModeInfoText = new wxStaticText(mainPanel, wxID_ANY, _("Cemu is running in portable mode"));
+		m_page1.portableModeInfoText->Show(true);
+		page1_sizer->Add(m_page1.portableModeInfoText, 0, wxALL, 5);
 
-		m_prev_mlc_warning = new wxStaticText(m_mlc_box_sizer->GetStaticBox(), wxID_ANY, _("A custom mlc path from a previous Cemu installation has been found and filled in."));
-		m_prev_mlc_warning->SetForegroundColour(*wxRED);
-		m_prev_mlc_warning->Show(false);
-		m_mlc_box_sizer->Add(m_prev_mlc_warning, 0, wxALL, 5);
-		
-		auto* mlc_path_sizer = new wxBoxSizer(wxHORIZONTAL);
-		mlc_path_sizer->Add(new wxStaticText(m_mlc_box_sizer->GetStaticBox(), wxID_ANY, _("Custom mlc01 path")), 0, wxALIGN_CENTER_VERTICAL | wxALL, 5);
-
-		// workaround since we can't specify our own browse label? >> _("Browse")
-		m_mlc_folder = new wxDirPickerCtrl(m_mlc_box_sizer->GetStaticBox(), wxID_ANY, wxEmptyString, _("Select a folder"), wxDefaultPosition, wxDefaultSize, wxDIRP_DEFAULT_STYLE);
-		auto tTest1 = m_mlc_folder->GetTextCtrl();
-       if(m_mlc_folder->HasTextCtrl())
-       {
-           m_mlc_folder->GetTextCtrl()->SetEditable(false);
-           m_mlc_folder->GetTextCtrl()->Bind(wxEVT_CHAR, &GettingStartedDialog::OnMLCPathChar, this);
-       }
-		mlc_path_sizer->Add(m_mlc_folder, 1, wxALL, 5);
-
-		mlc_path_sizer->Add(new wxStaticText(m_mlc_box_sizer->GetStaticBox(), wxID_ANY, _("(optional)")), 0, wxALIGN_CENTER_VERTICAL | wxALL, 5);
-
-		m_mlc_box_sizer->Add(mlc_path_sizer, 0, wxEXPAND, 5);
-
-		page1_sizer->Add(m_mlc_box_sizer, 0, wxALL | wxEXPAND, 5);
 	}
 
+	// language selection
+#if 0
 	{
-		auto* sizer = new wxStaticBoxSizer(wxVERTICAL, result, _("Game paths"));
+		m_page1.languageBoxSizer = new wxStaticBoxSizer(wxVERTICAL, mainPanel, _("Language"));
+		m_page1.languageText = new wxStaticText(m_page1.languageBoxSizer->GetStaticBox(), wxID_ANY, _("Select the language you want to use in Cemu"));
+		m_page1.languageBoxSizer->Add(m_page1.languageText, 0, wxALL, 5);
 
-		sizer->Add(new wxStaticText(sizer->GetStaticBox(), wxID_ANY, _("The game path is scanned by Cemu to locate your games. We recommend creating a dedicated directory in which\nyou place all your Wii U games. (example: C:\\wiiu\\games\\)\n\nYou can also set additional paths in the general settings of Cemu.")), 0, wxALL, 5);
+		wxString language_choices[] = { _("Default") };
+		wxChoice* m_language = new wxChoice(m_page1.languageBoxSizer->GetStaticBox(), wxID_ANY, wxDefaultPosition, wxDefaultSize, std::size(language_choices), language_choices);
+		m_language->SetSelection(0);
+
+		for (const auto& language : wxGetApp().GetLanguages())
+		{
+			m_language->Append(language->DescriptionNative);
+		}
+
+		m_language->SetSelection(0);
+		m_page1.languageBoxSizer->Add(m_language, 0, wxALL | wxEXPAND, 5);
+
+		page1_sizer->Add(m_page1.languageBoxSizer, 0, wxALL | wxEXPAND, 5);
+
+		m_language->Bind(wxEVT_CHOICE, [this, m_language](const auto&)
+		{
+			const auto language = m_language->GetStringSelection();
+			auto selection = m_language->GetSelection();
+			if (selection == 0)
+				GetConfig().language = wxLANGUAGE_DEFAULT;
+			else
+			{
+				auto* app = (CemuApp*)wxTheApp;
+				const auto language = m_language->GetStringSelection();
+				for (const auto& lang : app->GetLanguages())
+				{
+					if (lang->DescriptionNative == language)
+					{
+						app->LocalizeUI(static_cast<wxLanguage>(lang->Language));
+						wxCommandEvent event(EVT_REFRESH_FIRST_PAGE);
+						wxPostEvent(this, event);
+						break;
+					}
+				}
+			}
+		});
+	}
+#endif
+
+	{
+		m_page1.gamePathBoxSizer = new wxStaticBoxSizer(wxVERTICAL, mainPanel, _("Game paths"));
+		m_page1.gamePathText = new wxStaticText(m_page1.gamePathBoxSizer->GetStaticBox(), wxID_ANY, _("The game path is scanned by Cemu to automatically locate your games, game updates and DLCs. We recommend creating a dedicated directory in which\nyou place all your Wii U game files. Additional paths can be set later in Cemu's general settings. All common Wii U game formats are supported by Cemu."));
+		m_page1.gamePathBoxSizer->Add(m_page1.gamePathText, 0, wxALL, 5);
 
 		auto* game_path_sizer = new wxBoxSizer(wxHORIZONTAL);
 
-		game_path_sizer->Add(new wxStaticText(sizer->GetStaticBox(), wxID_ANY, _("Game path")), 0, wxALIGN_CENTER_VERTICAL | wxALL, 5);
+		m_page1.gamePathText2 = new wxStaticText(m_page1.gamePathBoxSizer->GetStaticBox(), wxID_ANY, _("Game path"));
+		game_path_sizer->Add(m_page1.gamePathText2, 0, wxALIGN_CENTER_VERTICAL | wxALL, 5);
 
-		m_game_path = new wxDirPickerCtrl(sizer->GetStaticBox(), wxID_ANY, wxEmptyString, _("Select a folder"));
-		game_path_sizer->Add(m_game_path, 1, wxALL, 5);
+		m_page1.gamePathPicker = new wxDirPickerCtrl(m_page1.gamePathBoxSizer->GetStaticBox(), wxID_ANY, wxEmptyString, _("Select a folder"));
+		game_path_sizer->Add(m_page1.gamePathPicker, 1, wxALL, 5);
 
-		sizer->Add(game_path_sizer, 0, wxEXPAND, 5);
+		m_page1.gamePathBoxSizer->Add(game_path_sizer, 0, wxEXPAND, 5);
 
-		page1_sizer->Add(sizer, 0, wxALL | wxEXPAND, 5);
+		page1_sizer->Add(m_page1.gamePathBoxSizer, 0, wxALL | wxEXPAND, 5);
 	}
 
 	{
-		auto* sizer = new wxStaticBoxSizer(wxVERTICAL, result, _("Graphic packs"));
+		auto* sizer = new wxStaticBoxSizer(wxVERTICAL, mainPanel, _("Graphic packs && mods"));
 
-		sizer->Add(new wxStaticText(sizer->GetStaticBox(), wxID_ANY, _("Graphic packs improve games by offering the possibility to change resolution, tweak FPS or add other visual or gameplay modifications.\nDownload the community graphic packs to get started.\n")), 0, wxALL, 5);
+		sizer->Add(new wxStaticText(sizer->GetStaticBox(), wxID_ANY, _("Graphic packs improve games by offering the ability to change resolution, increase FPS, tweak visuals or add gameplay modifications.\nGet started by opening the graphic packs configuration window.\n")), 0, wxALL, 5);
 
-		auto* download_gp = new wxButton(sizer->GetStaticBox(), wxID_ANY, _("Download community graphic packs"));
-		download_gp->Bind(wxEVT_BUTTON, &GettingStartedDialog::OnDownloadGPs, this);
+		auto* download_gp = new wxButton(sizer->GetStaticBox(), wxID_ANY, _("Download and configure graphic packs"));
+		download_gp->Bind(wxEVT_BUTTON, &GettingStartedDialog::OnConfigureGPs, this);
 		sizer->Add(download_gp, 0, wxALIGN_CENTER | wxALL, 5);
 
 		page1_sizer->Add(sizer, 0, wxALL | wxEXPAND, 5);
@@ -102,16 +128,15 @@ wxPanel* GettingStartedDialog::CreatePage1()
 		sizer->SetFlexibleDirection(wxBOTH);
 		sizer->SetNonFlexibleGrowMode(wxFLEX_GROWMODE_ALL);
 
-		auto* next = new wxButton(result, wxID_ANY, _("Next"), wxDefaultPosition, wxDefaultSize, 0);
+		auto* next = new wxButton(mainPanel, wxID_ANY, _("Next"), wxDefaultPosition, wxDefaultSize, 0);
 		next->Bind(wxEVT_BUTTON, [this](const auto&){m_notebook->SetSelection(1); });
 		sizer->Add(next, 0, wxALIGN_BOTTOM | wxALIGN_RIGHT | wxALL, 5);
 
 		page1_sizer->Add(sizer, 1, wxEXPAND, 5);
 	}
 
-
-	result->SetSizer(page1_sizer);
-	return result;
+	mainPanel->SetSizer(page1_sizer);
+	return mainPanel;
 }
 
 wxPanel* GettingStartedDialog::CreatePage2()
@@ -138,15 +163,19 @@ wxPanel* GettingStartedDialog::CreatePage2()
 		option_sizer->SetFlexibleDirection(wxBOTH);
 		option_sizer->SetNonFlexibleGrowMode(wxFLEX_GROWMODE_SPECIFIED);
 
-		m_fullscreen = new wxCheckBox(sizer->GetStaticBox(), wxID_ANY, _("Start games with fullscreen"));
-		option_sizer->Add(m_fullscreen, 0, wxALL, 5);
+		m_page2.fullscreenCheckbox = new wxCheckBox(sizer->GetStaticBox(), wxID_ANY, _("Start games with fullscreen"));
+		option_sizer->Add(m_page2.fullscreenCheckbox, 0, wxALL, 5);
 
-		m_separate = new wxCheckBox(sizer->GetStaticBox(), wxID_ANY, _("Open separate pad screen"));
-		option_sizer->Add(m_separate, 0, wxALL, 5);
-
-		m_update = new wxCheckBox(sizer->GetStaticBox(), wxID_ANY, _("Automatically check for updates"));
-		option_sizer->Add(m_update, 0, wxALL, 5);
+		m_page2.separateCheckbox = new wxCheckBox(sizer->GetStaticBox(), wxID_ANY, _("Open separate pad screen"));
+		option_sizer->Add(m_page2.separateCheckbox, 0, wxALL, 5);
 
+		m_page2.updateCheckbox = new wxCheckBox(sizer->GetStaticBox(), wxID_ANY, _("Automatically check for updates"));
+		option_sizer->Add(m_page2.updateCheckbox, 0, wxALL, 5);
+#if BOOST_OS_LINUX 
+		if (!std::getenv("APPIMAGE")) {
+			m_page2.updateCheckbox->Disable();
+		} 
+#endif
 		sizer->Add(option_sizer, 1, wxEXPAND, 5);
 		page2_sizer->Add(sizer, 0, wxALL | wxEXPAND, 5);
 	}
@@ -158,10 +187,6 @@ wxPanel* GettingStartedDialog::CreatePage2()
 		sizer->SetFlexibleDirection(wxBOTH);
 		sizer->SetNonFlexibleGrowMode(wxFLEX_GROWMODE_ALL);
 
-		m_dont_show = new wxCheckBox(result, wxID_ANY, _("Don't show this again"));
-		m_dont_show->SetValue(true);
-		sizer->Add(m_dont_show, 0, wxALIGN_BOTTOM | wxALL, 5);
-
 		auto* previous = new wxButton(result, wxID_ANY, _("Previous"));
 		previous->Bind(wxEVT_BUTTON, [this](const auto&) {m_notebook->SetSelection(0); });
 		sizer->Add(previous, 0, wxALIGN_BOTTOM | wxALIGN_RIGHT | wxALL, 5);
@@ -180,23 +205,9 @@ wxPanel* GettingStartedDialog::CreatePage2()
 void GettingStartedDialog::ApplySettings()
 {
 	auto& config = GetConfig();
-	m_fullscreen->SetValue(config.fullscreen.GetValue());
-	m_update->SetValue(config.check_update.GetValue());
-	m_separate->SetValue(config.pad_open.GetValue());
-	m_dont_show->SetValue(true); // we want it always enabled by default
-   	m_mlc_folder->SetPath(config.mlc_path.GetValue());
-
-	try
-	{
-		const auto pconfig = PermanentConfig::Load();
-		if(!pconfig.custom_mlc_path.empty())
-		{
-   			m_mlc_folder->SetPath(wxString::FromUTF8(pconfig.custom_mlc_path));
-			m_prev_mlc_warning->Show(true);
-		}
-	}
-	catch (const PSDisabledException&) {}
-	catch (...)	{}
+	m_page2.fullscreenCheckbox->SetValue(config.fullscreen.GetValue());
+	m_page2.updateCheckbox->SetValue(config.check_update.GetValue());
+	m_page2.separateCheckbox->SetValue(config.pad_open.GetValue());
 }
 
 void GettingStartedDialog::UpdateWindowSize()
@@ -215,46 +226,25 @@ void GettingStartedDialog::OnClose(wxCloseEvent& event)
 	event.Skip();
 
 	auto& config = GetConfig();
-	config.fullscreen = m_fullscreen->GetValue();
-	config.check_update = m_update->GetValue();
-	config.pad_open = m_separate->GetValue();
-	config.did_show_graphic_pack_download = m_dont_show->GetValue();
+	config.fullscreen = m_page2.fullscreenCheckbox->GetValue();
+	config.check_update = m_page2.updateCheckbox->GetValue();
+	config.pad_open = m_page2.separateCheckbox->GetValue();
 
-	const fs::path gamePath = wxHelper::MakeFSPath(m_game_path->GetPath());
-	if (!gamePath.empty() && fs::exists(gamePath))
+	const fs::path gamePath = wxHelper::MakeFSPath(m_page1.gamePathPicker->GetPath());
+	std::error_code ec;
+	if (!gamePath.empty() && fs::exists(gamePath, ec))
 	{
 		const auto it = std::find(config.game_paths.cbegin(), config.game_paths.cend(), gamePath);
 		if (it == config.game_paths.cend())
 		{
-			config.game_paths.emplace_back(gamePath.generic_wstring());
-			m_game_path_changed = true;
+			config.game_paths.emplace_back(_pathToUtf8(gamePath));
 		}
 	}
-
-    const fs::path mlcPath = wxHelper::MakeFSPath(m_mlc_folder->GetPath());
-	if(config.mlc_path.GetValue() != mlcPath && (mlcPath.empty() || fs::exists(mlcPath)))
-	{
-		config.SetMLCPath(mlcPath.generic_wstring(), false);
-		m_mlc_changed = true;
-	}
-	
-	g_config.Save();
-
-	if(m_mlc_changed)
-		CemuApp::CreateDefaultFiles();
-
-	CafeTitleList::ClearScanPaths();
-	for (auto& it : GetConfig().game_paths)
-		CafeTitleList::AddScanPath(it);
-	CafeTitleList::Refresh();
 }
 
-
 GettingStartedDialog::GettingStartedDialog(wxWindow* parent)
 	: wxDialog(parent, wxID_ANY, _("Getting started"), wxDefaultPosition, { 740,530 }, wxDEFAULT_DIALOG_STYLE | wxRESIZE_BORDER)
 {
-	//this->SetSizeHints(wxDefaultSize, { 740,530 });
-
 	auto* sizer = new wxBoxSizer(wxVERTICAL);
 
 	m_notebook = new wxSimplebook(this, wxID_ANY, wxDefaultPosition, wxDefaultSize, 0);
@@ -270,24 +260,18 @@ GettingStartedDialog::GettingStartedDialog(wxWindow* parent)
 	this->SetSizer(sizer);
 	this->Centre(wxBOTH);
 	this->Bind(wxEVT_CLOSE_WINDOW, &GettingStartedDialog::OnClose, this);
-	
+
 	ApplySettings();
 	UpdateWindowSize();
 }
 
-void GettingStartedDialog::OnDownloadGPs(wxCommandEvent& event)
+void GettingStartedDialog::OnConfigureGPs(wxCommandEvent& event)
 {
 	DownloadGraphicPacksWindow dialog(this);
 	dialog.ShowModal();
-
 	GraphicPacksWindow2::RefreshGraphicPacks();
-
-	wxMessageDialog ask_dialog(this, _("Do you want to view the downloaded graphic packs?"), _("Graphic packs"), wxCENTRE | wxYES_NO);
-	if (ask_dialog.ShowModal() == wxID_YES)
-	{
-		GraphicPacksWindow2 window(this, 0);
-		window.ShowModal();
-	}
+	GraphicPacksWindow2 window(this, 0);
+	window.ShowModal();
 }
 
 void GettingStartedDialog::OnInputSettings(wxCommandEvent& event)
@@ -295,20 +279,3 @@ void GettingStartedDialog::OnInputSettings(wxCommandEvent& event)
 	InputSettings2 dialog(this);
 	dialog.ShowModal();
 }
-
-void GettingStartedDialog::OnMLCPathChar(wxKeyEvent& event)
-{
-	//if (LaunchSettings::GetMLCPath().has_value())
-	//	return;
-
-	if (event.GetKeyCode() == WXK_DELETE || event.GetKeyCode() == WXK_BACK)
-	{
-		m_mlc_folder->GetTextCtrl()->SetValue(wxEmptyString);
-		if(m_prev_mlc_warning->IsShown())
-		{
-			m_prev_mlc_warning->Show(false);
-			UpdateWindowSize();
-		}	
-	}
-}
-
diff --git a/src/gui/GettingStartedDialog.h b/src/gui/GettingStartedDialog.h
index ec122eab..9dfd69b4 100644
--- a/src/gui/GettingStartedDialog.h
+++ b/src/gui/GettingStartedDialog.h
@@ -13,9 +13,6 @@ class GettingStartedDialog : public wxDialog
 public:
 	GettingStartedDialog(wxWindow* parent = nullptr);
 
-	[[nodiscard]] bool HasGamePathChanged() const { return m_game_path_changed; }
-	[[nodiscard]] bool HasMLCChanged() const { return m_mlc_changed; }
-
 private:
 	wxPanel* CreatePage1();
 	wxPanel* CreatePage2();
@@ -23,22 +20,29 @@ private:
 	void UpdateWindowSize();
 
 	void OnClose(wxCloseEvent& event);
-	void OnDownloadGPs(wxCommandEvent& event);
+	void OnConfigureGPs(wxCommandEvent& event);
 	void OnInputSettings(wxCommandEvent& event);
-	void OnMLCPathChar(wxKeyEvent& event);
 
 	wxSimplebook* m_notebook;
-	wxCheckBox* m_fullscreen;
-	wxCheckBox* m_separate;
-	wxCheckBox* m_update;
-	wxCheckBox* m_dont_show;
 
-	wxStaticBoxSizer* m_mlc_box_sizer;
-	wxStaticText* m_prev_mlc_warning;
-	wxDirPickerCtrl* m_mlc_folder;
-	wxDirPickerCtrl* m_game_path;
+	struct
+	{
+		// header
+		wxStaticText* staticText11{};
+		wxStaticText* portableModeInfoText{};
 
-	bool m_game_path_changed = false;
-	bool m_mlc_changed = false;
+		// game path box
+		wxStaticBoxSizer* gamePathBoxSizer{};
+		wxStaticText* gamePathText{};
+		wxStaticText* gamePathText2{};
+		wxDirPickerCtrl* gamePathPicker{};
+	}m_page1;
+
+	struct
+	{
+		wxCheckBox* fullscreenCheckbox;
+		wxCheckBox* separateCheckbox;
+		wxCheckBox* updateCheckbox;
+	}m_page2;
 };
 
diff --git a/src/gui/GraphicPacksWindow2.cpp b/src/gui/GraphicPacksWindow2.cpp
index 3759580e..c49cbeae 100644
--- a/src/gui/GraphicPacksWindow2.cpp
+++ b/src/gui/GraphicPacksWindow2.cpp
@@ -3,12 +3,15 @@
 #include "gui/DownloadGraphicPacksWindow.h"
 #include "Cafe/GraphicPack/GraphicPack2.h"
 #include "config/CemuConfig.h"
+#include "config/ActiveSettings.h"
 
 #include "Cafe/HW/Latte/Core/LatteAsyncCommands.h"
 
 #include "Cafe/CafeSystem.h"
 #include "Cafe/TitleList/TitleList.h"
 
+#include "wxHelper.h"
+
 #if BOOST_OS_LINUX || BOOST_OS_MACOS
 #include "resource/embedded/resources.h"
 #endif
@@ -61,7 +64,7 @@ void GraphicPacksWindow2::FillGraphicPackList() const
 		{
 			bool found = false;
 
-			if (boost::icontains(p->GetPath(), m_filter))
+			if (boost::icontains(p->GetVirtualPath(), m_filter))
 				found = true;
 			else
 			{
@@ -79,7 +82,7 @@ void GraphicPacksWindow2::FillGraphicPackList() const
 				continue;
 		}
 
-		const auto& path = p->GetPath();
+		const auto& path = p->GetVirtualPath();
 		auto tokens = TokenizeView(path, '/');
 		auto node = root;
 		for(size_t i=0; i<tokens.size(); i++)
@@ -88,10 +91,10 @@ void GraphicPacksWindow2::FillGraphicPackList() const
 			const auto parent_node = node;
 			if (i < (tokens.size() - 1))
 			{
-				node = FindTreeItem(parent_node, wxString(token.data(), token.length()));
+				node = FindTreeItem(parent_node, wxHelper::FromUtf8(token));
 				if (!node.IsOk())
 				{
-					node = m_graphic_pack_tree->AppendItem(parent_node, wxString(token.data(), token.length()));
+					node = m_graphic_pack_tree->AppendItem(parent_node, wxHelper::FromUtf8(token));
 				}
 			}
 			else
@@ -100,9 +103,9 @@ void GraphicPacksWindow2::FillGraphicPackList() const
 				// if a node with same name already exists, add a number suffix
 				for (sint32 s = 0; s < 999; s++)
 				{
-					wxString nodeName(token.data(), token.length());
+					wxString nodeName = wxHelper::FromUtf8(token);
 					if (s > 0)
-						nodeName.append(fmt::format(" #{}", s + 1));
+						nodeName.append(wxHelper::FromUtf8(fmt::format(" #{}", s + 1)));
 					
 					node = FindTreeItem(parent_node, nodeName);
 					if (!node.IsOk())
@@ -217,7 +220,7 @@ GraphicPacksWindow2::GraphicPacksWindow2(wxWindow* parent, uint64_t title_id_fil
 		text->Wrap(-1);
 		filter_row->Add(text, 0, wxALIGN_CENTER_VERTICAL | wxALL, 5);
 
-		m_filter_text = new wxTextCtrl(left_panel, wxID_ANY, m_filter, wxDefaultPosition, wxDefaultSize, 0);
+		m_filter_text = new wxTextCtrl(left_panel, wxID_ANY, wxHelper::FromUtf8(m_filter), wxDefaultPosition, wxDefaultSize, 0);
 		filter_row->Add(m_filter_text, 0, wxALL | wxEXPAND, 5);
 		m_filter_text->Bind(wxEVT_COMMAND_TEXT_UPDATED, &GraphicPacksWindow2::OnFilterUpdate, this);
 
@@ -316,6 +319,7 @@ GraphicPacksWindow2::GraphicPacksWindow2(wxWindow* parent, uint64_t title_id_fil
 
 	SetSizer(main_sizer);
 
+	UpdateTitleRunning(CafeSystem::IsTitleRunning());
 	FillGraphicPackList();
 }
 
@@ -326,7 +330,7 @@ void GraphicPacksWindow2::SaveStateToConfig()
 
 	for (const auto& gp : GraphicPack2::GetGraphicPacks())
 	{
-		auto filename = MakeRelativePath(gp->GetFilename()).lexically_normal();
+		auto filename = _utf8ToPath(gp->GetNormalizedPathString());
 		if (gp->IsEnabled())
 		{
 			data.graphic_pack_entries.try_emplace(filename);
@@ -385,13 +389,14 @@ void GraphicPacksWindow2::LoadPresetSelections(const GraphicPackPtr& gp)
 		{
 			continue;
 		}
-					
-		wxString label(category.empty() ? _("Active preset") : wxString(category));
+
+		wxString categoryWxStr = wxHelper::FromUtf8(category);
+		wxString label(category.empty() ? _("Active preset") : categoryWxStr);
 		auto* box = new wxStaticBox(m_preset_sizer->GetContainingWindow(), wxID_ANY, label);
 		auto* box_sizer = new wxStaticBoxSizer(box, wxVERTICAL);
 
 		auto* preset = new wxChoice(box, wxID_ANY);
-		preset->SetClientObject(new wxStringClientData(category));
+		preset->SetClientObject(new wxStringClientData(categoryWxStr));
 		preset->Bind(wxEVT_CHOICE, &GraphicPacksWindow2::OnActivePresetChanged, this);
 
 		std::optional<std::string> active_preset;
@@ -399,14 +404,14 @@ void GraphicPacksWindow2::LoadPresetSelections(const GraphicPackPtr& gp)
 		{
 			if (!pentry->visible)
 				continue;
-						
-			preset->AppendString(pentry->name);
+
+			preset->AppendString(wxHelper::FromUtf8(pentry->name));
 			if (pentry->active)
 				active_preset = pentry->name;
 		}
 
 		if (active_preset)
-			preset->SetStringSelection(active_preset.value());
+			preset->SetStringSelection(wxHelper::FromUtf8(active_preset.value()));
 		else if (preset->GetCount() > 0)
 			preset->SetSelection(0);
 					
@@ -438,14 +443,14 @@ void GraphicPacksWindow2::OnTreeSelectionChanged(wxTreeEvent& event)
 			{
 				m_preset_sizer->Clear(true);
 				m_gp_name = gp->GetName();
-				m_graphic_pack_name->SetLabel(m_gp_name);
+				m_graphic_pack_name->SetLabel(wxHelper::FromUtf8(m_gp_name));
 
 				if (gp->GetDescription().empty())
-					m_gp_description = _("This graphic pack has no description");
+					m_gp_description = _("This graphic pack has no description").utf8_string();
 				else
 					m_gp_description = gp->GetDescription();
 
-				m_graphic_pack_description->SetLabel(m_gp_description);
+				m_graphic_pack_description->SetLabel(wxHelper::FromUtf8(m_gp_description));
 
 				LoadPresetSelections(gp);
 				
@@ -453,10 +458,10 @@ void GraphicPacksWindow2::OnTreeSelectionChanged(wxTreeEvent& event)
 
 				m_shown_graphic_pack = gp;
 
-				m_graphic_pack_name->Wrap(m_graphic_pack_name->GetParent()->GetClientSize().GetWidth() - 10);
+				m_graphic_pack_name->Wrap(m_graphic_pack_name->GetParent()->GetClientSize().GetWidth() - 20);
 				m_graphic_pack_name->GetGrandParent()->Layout();
 
-				m_graphic_pack_description->Wrap(m_graphic_pack_description->GetParent()->GetClientSize().GetWidth() - 10);
+				m_graphic_pack_description->Wrap(m_graphic_pack_description->GetParent()->GetClientSize().GetWidth() - 20);
 				m_graphic_pack_description->GetGrandParent()->Layout();
 
 				m_right_panel->FitInside();
@@ -494,15 +499,14 @@ void GraphicPacksWindow2::OnTreeChoiceChanged(wxTreeEvent& event)
 	auto& graphic_pack = data->GetGraphicPack();
 	graphic_pack->SetEnabled(state);
 
-	bool has_texture_rules = false;
-	if (CafeSystem::IsTitleRunning() && graphic_pack->ContainsTitleId(CafeSystem::GetForegroundTitleId()))
+	bool requiresRestart = graphic_pack->RequiresRestart(true, false);
+	bool isRunning = CafeSystem::IsTitleRunning() && graphic_pack->ContainsTitleId(CafeSystem::GetForegroundTitleId());
+	if (isRunning)
 	{
  		if (state)
 		{
 			GraphicPack2::ActivateGraphicPack(graphic_pack);
-			has_texture_rules = !graphic_pack->GetTextureRules().empty();
-
-			if (!has_texture_rules)
+			if (!requiresRestart)
 			{
 				ReloadPack(graphic_pack);
 				m_graphic_pack_tree->SetItemTextColour(item, 0x009900);
@@ -510,25 +514,54 @@ void GraphicPacksWindow2::OnTreeChoiceChanged(wxTreeEvent& event)
 		}
 		else
 		{
-			has_texture_rules = !graphic_pack->GetTextureRules().empty();
-
-			if (!has_texture_rules)
+			if (!requiresRestart)
 			{
 				DeleteShadersFromRuntimeCache(graphic_pack);
 				m_graphic_pack_tree->SetItemTextColour(item, *wxBLACK);
 			}
-
 			GraphicPack2::DeactivateGraphicPack(graphic_pack);
 		}
 	}
 
-	if (!m_info_bar->IsShown() && has_texture_rules)
+	if (!m_info_bar->IsShown() && (isRunning && requiresRestart))
 		m_info_bar->ShowMessage(_("Restart of Cemu required for changes to take effect"));
 
 	// also change selection to activated gp
 	m_graphic_pack_tree->SelectItem(item);
 }
 
+// In some environments with GTK (e.g. a flatpak app with org.freedesktop.Platform 22.08 runtime),
+// destroying the event source inside the handler crashes the app.
+// As a workaround to that, the wxWindow that needs to be destroyed is hidden and then 
+// destroyed at a later time, outside the handler.
+void GraphicPacksWindow2::ClearPresets()
+{
+	size_t item_count = m_preset_sizer->GetItemCount();
+	std::vector<wxSizer*> sizers;
+	sizers.reserve(item_count);
+	for (size_t i = 0; i < item_count; i++)
+		sizers.push_back(m_preset_sizer->GetItem(i)->GetSizer());
+
+	for (auto&& sizer : sizers)
+	{
+		auto static_box_sizer = dynamic_cast<wxStaticBoxSizer*>(sizer);
+		if (static_box_sizer)
+		{
+			wxStaticBox* parent_window = static_box_sizer->GetStaticBox();
+			if (parent_window)
+			{
+				m_preset_sizer->Detach(sizer);
+				parent_window->Hide();
+				CallAfter([=]()
+				{
+					parent_window->DestroyChildren();
+					delete static_box_sizer;
+				});
+			}
+		}
+	}
+}
+
 void GraphicPacksWindow2::OnActivePresetChanged(wxCommandEvent& event)
 {
 	if (!m_shown_graphic_pack)
@@ -538,11 +571,11 @@ void GraphicPacksWindow2::OnActivePresetChanged(wxCommandEvent& event)
 	wxASSERT(obj);
 	const auto string_data = dynamic_cast<wxStringClientData*>(obj->GetClientObject());
 	wxASSERT(string_data);
-	const auto preset = obj->GetStringSelection().ToStdString();
-	if(m_shown_graphic_pack->SetActivePreset(string_data->GetData().c_str().AsChar(), preset))
+	const auto preset = obj->GetStringSelection().utf8_string();
+	if(m_shown_graphic_pack->SetActivePreset(string_data->GetData().utf8_string(), preset))
 	{
 		wxWindowUpdateLocker lock(this);
-		m_preset_sizer->Clear(true);
+		ClearPresets();
 		LoadPresetSelections(m_shown_graphic_pack);
 		//m_preset_sizer->GetContainingWindow()->Layout();
 		//m_right_panel->FitInside();
@@ -550,7 +583,7 @@ void GraphicPacksWindow2::OnActivePresetChanged(wxCommandEvent& event)
 		m_right_panel->Layout();
 	}
 
-	if (m_shown_graphic_pack->GetTextureRules().empty())
+	if (!m_shown_graphic_pack->RequiresRestart(false, true))
 		ReloadPack(m_shown_graphic_pack);
 	else if (!m_info_bar->IsShown())
 		m_info_bar->ShowMessage(_("Restart of Cemu required for changes to take effect"));		
@@ -571,34 +604,30 @@ void GraphicPacksWindow2::OnCheckForUpdates(wxCommandEvent& event)
 	{
 		if (!CafeSystem::IsTitleRunning())
 		{
-			std::vector<GraphicPackPtr> old_packs = GraphicPack2::GetGraphicPacks();
+			// remember virtual paths of all the enabled packs
+			std::map<std::string, std::string> previouslyEnabledPacks;
+			for(auto& it : GraphicPack2::GetGraphicPacks())
+			{
+				if(it->IsEnabled())
+					previouslyEnabledPacks.emplace(it->GetNormalizedPathString(), it->GetVirtualPath());
+			}
+			// reload graphic packs
 			RefreshGraphicPacks();
 			FillGraphicPackList();
-
-			// check if enabled graphic packs are lost:
-			const auto& new_packs = GraphicPack2::GetGraphicPacks();
-			std::stringstream str;
-			for(const auto& p : old_packs)
+			// remove packs which are still present
+			for(auto& it : GraphicPack2::GetGraphicPacks())
+				previouslyEnabledPacks.erase(it->GetNormalizedPathString());
+			if(!previouslyEnabledPacks.empty())
 			{
-				if (!p->IsEnabled())
-					continue;
-
-				const auto it = std::find_if(new_packs.cbegin(), new_packs.cend(), [&p](const auto& gp)
-					{
-						return gp->GetFilename() == p->GetFilename();
-					});
-				
-				if(it == new_packs.cend())
+				std::string lost_packs;
+				for(auto& it : previouslyEnabledPacks)
 				{
-					str << p->GetPath() << std::endl;
+					lost_packs.append(it.second);
+					lost_packs.push_back('\n');
 				}
-			}
-
-			const auto packs = str.str();
-			if(!packs.empty())
-			{
-				wxMessageBox(fmt::format("{}\n \n{} \n{}", _("This update removed or renamed the following graphic packs:").ToStdString(), packs, _("You may need to set them up again.").ToStdString()),
-					_("Warning"), wxOK | wxCENTRE | wxICON_INFORMATION, this);
+				wxString message = _("This update removed or renamed the following graphic packs:");
+				message << "\n \n" << wxString::FromUTF8(lost_packs) << " \n" << _("You may need to set them up again.");
+				wxMessageBox(message, _("Warning"), wxOK | wxCENTRE | wxICON_INFORMATION, this);
 			}
 		}
 	}
@@ -613,10 +642,10 @@ void GraphicPacksWindow2::OnSizeChanged(wxSizeEvent& event)
 	obj->SetSashPosition((sint32)(m_ratio * width));
 
 	if (!m_gp_name.empty())
-		m_graphic_pack_name->SetLabel(m_gp_name);
+		m_graphic_pack_name->SetLabel(wxHelper::FromUtf8(m_gp_name));
 
 	if (!m_gp_description.empty())
-		m_graphic_pack_description->SetLabel(m_gp_description);
+		m_graphic_pack_description->SetLabel(wxHelper::FromUtf8(m_gp_description));
 
 	m_graphic_pack_name->Wrap(m_graphic_pack_name->GetParent()->GetClientSize().GetWidth() - 10);
 	m_graphic_pack_description->Wrap(m_graphic_pack_description->GetParent()->GetClientSize().GetWidth() - 10);
@@ -636,7 +665,7 @@ void GraphicPacksWindow2::SashPositionChanged(wxEvent& event)
 
 void GraphicPacksWindow2::OnFilterUpdate(wxEvent& event)
 {
-	m_filter = m_filter_text->GetValue();
+	m_filter = m_filter_text->GetValue().utf8_string();
 	FillGraphicPackList();
 	event.Skip();
 }
@@ -648,6 +677,15 @@ void GraphicPacksWindow2::OnInstalledGamesChanged(wxCommandEvent& event)
 	event.Skip();
 }
 
+void GraphicPacksWindow2::UpdateTitleRunning(bool running)
+{
+	m_update_graphicPacks->Enable(!running);
+	if(running)
+		m_update_graphicPacks->SetToolTip(_("Graphic packs cannot be updated while a game is running."));
+	else
+		m_update_graphicPacks->SetToolTip(nullptr);
+}
+
 void GraphicPacksWindow2::ReloadPack(const GraphicPackPtr& graphic_pack) const
 {
 	if (graphic_pack->HasShaders() || graphic_pack->HasPatches() || graphic_pack->HasCustomVSyncFrequency())
diff --git a/src/gui/GraphicPacksWindow2.h b/src/gui/GraphicPacksWindow2.h
index 82b13c72..a79c62c1 100644
--- a/src/gui/GraphicPacksWindow2.h
+++ b/src/gui/GraphicPacksWindow2.h
@@ -21,12 +21,14 @@ public:
 	~GraphicPacksWindow2();
 
 	static void RefreshGraphicPacks();
+	void UpdateTitleRunning(bool running);
 
 private:
 	std::string m_filter;
 	bool m_filter_installed_games;
 	std::vector<uint64_t> m_installed_games;
 
+	void ClearPresets();
 	void FillGraphicPackList() const;
 	void GetChildren(const wxTreeItemId& id, std::vector<wxTreeItemId>& children) const;
 	void ExpandChildren(const std::vector<wxTreeItemId>& ids, size_t& counter) const;
diff --git a/src/gui/LoggingWindow.cpp b/src/gui/LoggingWindow.cpp
index 6672bec9..4026113e 100644
--- a/src/gui/LoggingWindow.cpp
+++ b/src/gui/LoggingWindow.cpp
@@ -21,7 +21,7 @@ LoggingWindow::LoggingWindow(wxFrame* parent)
 
 		filter_row->Add(new wxStaticText( this, wxID_ANY, _("Filter")), 0, wxALIGN_CENTER_VERTICAL|wxALL, 5 );
 
-		wxString choices[] = {"Coreinit File-Access", "Coreinit Thread-Synchronization", "Coreinit Memory", "GX2", "Audio", "Input", "Socket", "Save", "H264", "Texture Cache", "OpenGL"};
+		wxString choices[] = {"Unsupported APIs calls", "Coreinit Logging", "Coreinit File-Access", "Coreinit Thread-Synchronization", "Coreinit Memory", "Coreinit MP", "Coreinit Thread", "nn::nfp", "GX2", "Audio", "Input", "Socket", "Save", "H264", "Graphic pack patches", "Texture cache", "Texture readback", "OpenGL debug output", "Vulkan validation layer"};
 		m_filter = new wxComboBox( this, wxID_ANY, wxEmptyString, wxDefaultPosition, wxDefaultSize, std::size(choices), choices, 0 );
 		m_filter->Bind(wxEVT_COMBOBOX, &LoggingWindow::OnFilterChange, this);
 		m_filter->Bind(wxEVT_TEXT, &LoggingWindow::OnFilterChange, this);
@@ -88,7 +88,7 @@ void LoggingWindow::OnLogMessage(wxLogEvent& event)
 
 void LoggingWindow::OnFilterChange(wxCommandEvent& event)
 {
-	m_log_list->SetActiveFilter(from_wxString(m_filter->GetValue()));
+	m_log_list->SetActiveFilter(m_filter->GetValue().utf8_string());
 	event.Skip();
 }
 
diff --git a/src/gui/MainWindow.cpp b/src/gui/MainWindow.cpp
index 5b65c7a1..bf880e48 100644
--- a/src/gui/MainWindow.cpp
+++ b/src/gui/MainWindow.cpp
@@ -3,6 +3,7 @@
 #include "gui/guiWrapper.h"
 
 #include <wx/mstream.h>
+#include <wx/clipbrd.h>
 
 #include "gui/GameUpdateWindow.h"
 #include "gui/PadViewFrame.h"
@@ -11,20 +12,17 @@
 #include "audio/audioDebuggerWindow.h"
 #include "gui/canvas/OpenGLCanvas.h"
 #include "gui/canvas/VulkanCanvas.h"
-#include "Cafe/OS/libs/nn_nfp/nn_nfp.h"
+#include "Cafe/OS/libs/nfc/nfc.h"
 #include "Cafe/OS/libs/swkbd/swkbd.h"
-#include "Cafe/IOSU/legacy/iosu_crypto.h"
-#include "Cafe/GameProfile/GameProfile.h"
 #include "gui/debugger/DebuggerWindow2.h"
 #include "util/helpers/helpers.h"
 #include "config/CemuConfig.h"
 #include "Cemu/DiscordPresence/DiscordPresence.h"
+#include "util/ScreenSaver/ScreenSaver.h"
 #include "gui/GeneralSettings2.h"
 #include "gui/GraphicPacksWindow2.h"
-#include "gui/GameProfileWindow.h"
 #include "gui/CemuApp.h"
 #include "gui/CemuUpdateWindow.h"
-#include "gui/helpers/wxCustomData.h"
 #include "gui/LoggingWindow.h"
 #include "config/ActiveSettings.h"
 #include "config/LaunchSettings.h"
@@ -32,11 +30,10 @@
 #include "Cafe/Filesystem/FST/FST.h"
 
 #include "gui/TitleManager.h"
+#include "gui/EmulatedUSBDevices/EmulatedUSBDeviceFrame.h"
 
 #include "Cafe/CafeSystem.h"
-#include "Cafe/TitleList/GameInfo.h"
 
-#include <boost/algorithm/string.hpp>
 #include "util/helpers/SystemException.h"
 #include "gui/DownloadGraphicPacksWindow.h"
 #include "gui/GettingStartedDialog.h"
@@ -55,6 +52,15 @@
 #include "resource/embedded/resources.h"
 #endif
 
+#if BOOST_OS_LINUX && HAS_WAYLAND
+#include "gui/helpers/wxWayland.h"
+#endif
+
+//GameMode support
+#if BOOST_OS_LINUX && defined(ENABLE_FERAL_GAMEMODE)
+#include "gamemode_client.h"
+#endif
+
 #include "Cafe/TitleList/TitleInfo.h"
 #include "Cafe/TitleList/TitleList.h"
 #include "wxHelper.h"
@@ -62,24 +68,22 @@
 extern WindowInfo g_window_info;
 extern std::shared_mutex g_mutex;
 
-wxDEFINE_EVENT(wxEVT_SET_WINDOW_TITLE, wxCommandEvent);
-
 enum
 {
-	// note - Cemuhook mirrors these ids, be careful about changing them
-
 	// ui elements
 	MAINFRAME_GAMELIST_ID = 20000, //wxID_HIGHEST + 1,
 	// file
 	MAINFRAME_MENU_ID_FILE_LOAD = 20100,
 	MAINFRAME_MENU_ID_FILE_INSTALL_UPDATE,
+	MAINFRAME_MENU_ID_FILE_OPEN_CEMU_FOLDER,
+	MAINFRAME_MENU_ID_FILE_OPEN_MLC_FOLDER,
+	MAINFRAME_MENU_ID_FILE_OPEN_SHADERCACHE_FOLDER,
 	MAINFRAME_MENU_ID_FILE_EXIT,
 	MAINFRAME_MENU_ID_FILE_END_EMULATION,
 	MAINFRAME_MENU_ID_FILE_RECENT_0,
 	MAINFRAME_MENU_ID_FILE_RECENT_LAST = MAINFRAME_MENU_ID_FILE_RECENT_0 + 15,
 	// options
 	MAINFRAME_MENU_ID_OPTIONS_FULLSCREEN = 20200,
-	MAINFRAME_MENU_ID_OPTIONS_VSYNC,
 	MAINFRAME_MENU_ID_OPTIONS_SECOND_WINDOW_PADVIEW,
 	MAINFRAME_MENU_ID_OPTIONS_GRAPHIC,
 	MAINFRAME_MENU_ID_OPTIONS_GRAPHIC_PACKS2,
@@ -87,10 +91,7 @@ enum
 	MAINFRAME_MENU_ID_OPTIONS_GENERAL2,
 	MAINFRAME_MENU_ID_OPTIONS_AUDIO,
 	MAINFRAME_MENU_ID_OPTIONS_INPUT,
-	// options -> experimental
-	MAINFRAME_MENU_ID_EXPERIMENTAL_BOTW_WORKAROUND = 20300,
-	MAINFRAME_MENU_ID_EXPERIMENTAL_SYNC_TO_GX2DRAWDONE,
-	MAINFRAME_MENU_ID_EXPERIMENTAL_DISABLE_PRECOMPILED,
+	MAINFRAME_MENU_ID_OPTIONS_MAC_SETTINGS,
 	// options -> account
 	MAINFRAME_MENU_ID_OPTIONS_ACCOUNT_1 = 20350,
 	MAINFRAME_MENU_ID_OPTIONS_ACCOUNT_12 = 20350 + 11,
@@ -112,6 +113,7 @@ enum
 	MAINFRAME_MENU_ID_TOOLS_MEMORY_SEARCHER = 20600,
 	MAINFRAME_MENU_ID_TOOLS_TITLE_MANAGER,
 	MAINFRAME_MENU_ID_TOOLS_DOWNLOAD_MANAGER,
+	MAINFRAME_MENU_ID_TOOLS_EMULATED_USB_DEVICES,
 	// cpu
 	// cpu->timer speed
 	MAINFRAME_MENU_ID_TIMER_SPEED_1X = 20700,
@@ -127,49 +129,51 @@ enum
 	MAINFRAME_MENU_ID_NFC_RECENT_0,
 	MAINFRAME_MENU_ID_NFC_RECENT_LAST = MAINFRAME_MENU_ID_NFC_RECENT_0 + 15,
 	// debug
-	MAINFRAME_MENU_ID_DEBUG_RESERVED = 21100,
-	MAINFRAME_MENU_ID_DEBUG_RENDER_UPSIDE_DOWN,
+	MAINFRAME_MENU_ID_DEBUG_RENDER_UPSIDE_DOWN = 21100,
 	MAINFRAME_MENU_ID_DEBUG_VIEW_LOGGING_WINDOW,
+	MAINFRAME_MENU_ID_DEBUG_TOGGLE_GDB_STUB,
 	MAINFRAME_MENU_ID_DEBUG_VIEW_PPC_THREADS,
 	MAINFRAME_MENU_ID_DEBUG_VIEW_PPC_DEBUGGER,
 	MAINFRAME_MENU_ID_DEBUG_VIEW_AUDIO_DEBUGGER,
 	MAINFRAME_MENU_ID_DEBUG_VIEW_TEXTURE_RELATIONS,
-	MAINFRAME_MENU_ID_DEBUG_SHOW_FRAME_PROFILER,
 	MAINFRAME_MENU_ID_DEBUG_AUDIO_AUX_ONLY,
 	MAINFRAME_MENU_ID_DEBUG_VK_ACCURATE_BARRIERS,
 
 	// debug->logging
-	MAINFRAME_MENU_ID_DEBUG_LOGGING_DISABLE_ALL = 21500,
-	MAINFRAME_MENU_ID_DEBUG_LOGGING0,
-	MAINFRAME_MENU_ID_DEBUG_LOGGING20 = MAINFRAME_MENU_ID_DEBUG_LOGGING0 + 20,
-	MAINFRAME_MENU_ID_DEBUG_ADVANCED_PPC_INFO,
+	MAINFRAME_MENU_ID_DEBUG_LOGGING_MESSAGE = 21499,
+	MAINFRAME_MENU_ID_DEBUG_LOGGING0 = 21500,
+	MAINFRAME_MENU_ID_DEBUG_ADVANCED_PPC_INFO = 21599,
 	// debug->dump
 	MAINFRAME_MENU_ID_DEBUG_DUMP_TEXTURES = 21600,
 	MAINFRAME_MENU_ID_DEBUG_DUMP_SHADERS,
+	MAINFRAME_MENU_ID_DEBUG_DUMP_RECOMPILER_FUNCTIONS,
 	MAINFRAME_MENU_ID_DEBUG_DUMP_RAM,
 	MAINFRAME_MENU_ID_DEBUG_DUMP_FST,
 	MAINFRAME_MENU_ID_DEBUG_DUMP_CURL_REQUESTS,
 	// help
-	MAINFRAME_MENU_ID_HELP_WEB = 21700,
-	MAINFRAME_MENU_ID_HELP_ABOUT,
+	MAINFRAME_MENU_ID_HELP_ABOUT = 21700,
 	MAINFRAME_MENU_ID_HELP_UPDATE,
-	MAINFRAME_MENU_ID_HELP_GETTING_STARTED,
-
 	// custom
 	MAINFRAME_ID_TIMER1 = 21800,
 };
 
+wxDEFINE_EVENT(wxEVT_SET_WINDOW_TITLE, wxCommandEvent);
 wxDEFINE_EVENT(wxEVT_REQUEST_GAMELIST_REFRESH, wxCommandEvent);
 wxDEFINE_EVENT(wxEVT_LAUNCH_GAME, wxLaunchGameEvent);
+wxDEFINE_EVENT(wxEVT_REQUEST_RECREATE_CANVAS, wxCommandEvent);
 
 wxBEGIN_EVENT_TABLE(MainWindow, wxFrame)
 EVT_TIMER(MAINFRAME_ID_TIMER1, MainWindow::OnTimer)
 EVT_CLOSE(MainWindow::OnClose)
 EVT_SIZE(MainWindow::OnSizeEvent)
+EVT_DPI_CHANGED(MainWindow::OnDPIChangedEvent)
 EVT_MOVE(MainWindow::OnMove)
 // file menu
 EVT_MENU(MAINFRAME_MENU_ID_FILE_LOAD, MainWindow::OnFileMenu)
 EVT_MENU(MAINFRAME_MENU_ID_FILE_INSTALL_UPDATE, MainWindow::OnInstallUpdate)
+EVT_MENU(MAINFRAME_MENU_ID_FILE_OPEN_CEMU_FOLDER, MainWindow::OnOpenFolder)
+EVT_MENU(MAINFRAME_MENU_ID_FILE_OPEN_MLC_FOLDER, MainWindow::OnOpenFolder)
+EVT_MENU(MAINFRAME_MENU_ID_FILE_OPEN_SHADERCACHE_FOLDER, MainWindow::OnOpenFolder)
 EVT_MENU(MAINFRAME_MENU_ID_FILE_EXIT, MainWindow::OnFileExit)
 EVT_MENU(MAINFRAME_MENU_ID_FILE_END_EMULATION, MainWindow::OnFileMenu)
 EVT_MENU_RANGE(MAINFRAME_MENU_ID_FILE_RECENT_0 + 0, MAINFRAME_MENU_ID_FILE_RECENT_LAST, MainWindow::OnFileMenu)
@@ -185,11 +189,13 @@ EVT_MENU(MAINFRAME_MENU_ID_OPTIONS_GENERAL, MainWindow::OnOptionsInput)
 EVT_MENU(MAINFRAME_MENU_ID_OPTIONS_GENERAL2, MainWindow::OnOptionsInput)
 EVT_MENU(MAINFRAME_MENU_ID_OPTIONS_AUDIO, MainWindow::OnOptionsInput)
 EVT_MENU(MAINFRAME_MENU_ID_OPTIONS_INPUT, MainWindow::OnOptionsInput)
+EVT_MENU(MAINFRAME_MENU_ID_OPTIONS_MAC_SETTINGS, MainWindow::OnOptionsInput)
 // tools menu
 EVT_MENU(MAINFRAME_MENU_ID_TOOLS_MEMORY_SEARCHER, MainWindow::OnToolsInput)
 EVT_MENU(MAINFRAME_MENU_ID_TOOLS_TITLE_MANAGER, MainWindow::OnToolsInput)
 EVT_MENU(MAINFRAME_MENU_ID_TOOLS_DOWNLOAD_MANAGER, MainWindow::OnToolsInput)
-//// cpu menu
+EVT_MENU(MAINFRAME_MENU_ID_TOOLS_EMULATED_USB_DEVICES, MainWindow::OnToolsInput)
+// cpu menu
 EVT_MENU(MAINFRAME_MENU_ID_TIMER_SPEED_8X, MainWindow::OnDebugSetting)
 EVT_MENU(MAINFRAME_MENU_ID_TIMER_SPEED_4X, MainWindow::OnDebugSetting)
 EVT_MENU(MAINFRAME_MENU_ID_TIMER_SPEED_2X, MainWindow::OnDebugSetting)
@@ -201,11 +207,12 @@ EVT_MENU(MAINFRAME_MENU_ID_TIMER_SPEED_0125X, MainWindow::OnDebugSetting)
 EVT_MENU(MAINFRAME_MENU_ID_NFC_TOUCH_NFC_FILE, MainWindow::OnNFCMenu)
 EVT_MENU_RANGE(MAINFRAME_MENU_ID_NFC_RECENT_0 + 0, MAINFRAME_MENU_ID_NFC_RECENT_LAST, MainWindow::OnNFCMenu)
 // debug -> logging menu
-EVT_MENU_RANGE(MAINFRAME_MENU_ID_DEBUG_LOGGING0 + 0, MAINFRAME_MENU_ID_DEBUG_LOGGING0 + 19, MainWindow::OnDebugLoggingToggleFlagGeneric)
+EVT_MENU_RANGE(MAINFRAME_MENU_ID_DEBUG_LOGGING0 + 0, MAINFRAME_MENU_ID_DEBUG_LOGGING0 + 98, MainWindow::OnDebugLoggingToggleFlagGeneric)
 EVT_MENU(MAINFRAME_MENU_ID_DEBUG_ADVANCED_PPC_INFO, MainWindow::OnPPCInfoToggle)
 // debug -> dump menu
-EVT_MENU(MAINFRAME_MENU_ID_DEBUG_DUMP_TEXTURES, MainWindow::OnDebugDumpUsedTextures)
-EVT_MENU(MAINFRAME_MENU_ID_DEBUG_DUMP_SHADERS, MainWindow::OnDebugDumpUsedShaders)
+EVT_MENU(MAINFRAME_MENU_ID_DEBUG_DUMP_TEXTURES, MainWindow::OnDebugDumpGeneric)
+EVT_MENU(MAINFRAME_MENU_ID_DEBUG_DUMP_SHADERS, MainWindow::OnDebugDumpGeneric)
+EVT_MENU(MAINFRAME_MENU_ID_DEBUG_DUMP_RECOMPILER_FUNCTIONS, MainWindow::OnDebugDumpGeneric)
 EVT_MENU(MAINFRAME_MENU_ID_DEBUG_DUMP_CURL_REQUESTS, MainWindow::OnDebugSetting)
 // debug -> Other options
 EVT_MENU(MAINFRAME_MENU_ID_DEBUG_RENDER_UPSIDE_DOWN, MainWindow::OnDebugSetting)
@@ -215,16 +222,14 @@ EVT_MENU(MAINFRAME_MENU_ID_DEBUG_DUMP_RAM, MainWindow::OnDebugSetting)
 EVT_MENU(MAINFRAME_MENU_ID_DEBUG_DUMP_FST, MainWindow::OnDebugSetting)
 // debug -> View ...
 EVT_MENU(MAINFRAME_MENU_ID_DEBUG_VIEW_LOGGING_WINDOW, MainWindow::OnLoggingWindow)
+EVT_MENU(MAINFRAME_MENU_ID_DEBUG_TOGGLE_GDB_STUB, MainWindow::OnGDBStubToggle)
 EVT_MENU(MAINFRAME_MENU_ID_DEBUG_VIEW_PPC_THREADS, MainWindow::OnDebugViewPPCThreads)
 EVT_MENU(MAINFRAME_MENU_ID_DEBUG_VIEW_PPC_DEBUGGER, MainWindow::OnDebugViewPPCDebugger)
 EVT_MENU(MAINFRAME_MENU_ID_DEBUG_VIEW_AUDIO_DEBUGGER, MainWindow::OnDebugViewAudioDebugger)
 EVT_MENU(MAINFRAME_MENU_ID_DEBUG_VIEW_TEXTURE_RELATIONS, MainWindow::OnDebugViewTextureRelations)
-EVT_MENU(MAINFRAME_MENU_ID_DEBUG_SHOW_FRAME_PROFILER, MainWindow::OnDebugSetting)
 // help menu
-EVT_MENU(MAINFRAME_MENU_ID_HELP_WEB, MainWindow::OnHelpVistWebpage)
 EVT_MENU(MAINFRAME_MENU_ID_HELP_ABOUT, MainWindow::OnHelpAbout)
 EVT_MENU(MAINFRAME_MENU_ID_HELP_UPDATE, MainWindow::OnHelpUpdate)
-EVT_MENU(MAINFRAME_MENU_ID_HELP_GETTING_STARTED, MainWindow::OnHelpGettingStarted)
 // misc
 EVT_COMMAND(wxID_ANY, wxEVT_REQUEST_GAMELIST_REFRESH, MainWindow::OnRequestGameListRefresh)
 
@@ -233,6 +238,8 @@ EVT_COMMAND(wxID_ANY, wxEVT_GAMELIST_END_UPDATE, MainWindow::OnGameListEndUpdate
 EVT_COMMAND(wxID_ANY, wxEVT_ACCOUNTLIST_REFRESH, MainWindow::OnAccountListRefresh)
 EVT_COMMAND(wxID_ANY, wxEVT_SET_WINDOW_TITLE, MainWindow::OnSetWindowTitle)
 
+EVT_COMMAND(wxID_ANY, wxEVT_REQUEST_RECREATE_CANVAS, MainWindow::OnRequestRecreateCanvas)
+
 wxEND_EVENT_TABLE()
 
 class wxGameDropTarget : public wxFileDropTarget
@@ -242,7 +249,7 @@ public:
 	bool OnDropFiles(wxCoord x, wxCoord y, const wxArrayString& filenames) override
 	{
 		if(!m_window->IsGameLaunched() && filenames.GetCount() == 1)
-			return m_window->FileLoad(filenames[0].wc_str(), wxLaunchGameEvent::INITIATED_BY::DRAG_AND_DROP);
+			return m_window->FileLoad(_utf8ToPath(filenames[0].utf8_string()), wxLaunchGameEvent::INITIATED_BY::DRAG_AND_DROP);
 		
 		return false;
 	}
@@ -259,20 +266,20 @@ public:
 	{
 		if (!m_window->IsGameLaunched() || filenames.GetCount() != 1)
 			return false;
-		
 		uint32 nfcError;
-		if (nnNfp_touchNfcTagFromFile(filenames[0].wc_str(), &nfcError))
+		std::string path = filenames[0].utf8_string();
+		if (nfc::TouchTagFromFile(_utf8ToPath(path), &nfcError))
 		{
-			GetConfig().AddRecentNfcFile((wchar_t*)filenames[0].wc_str());
+			GetConfig().AddRecentNfcFile(path);
 			m_window->UpdateNFCMenu();
 			return true;
 		}
 		else
 		{
-			if (nfcError == NFC_ERROR_NO_ACCESS)
+			if (nfcError == NFC_TOUCH_TAG_ERROR_NO_ACCESS)
 				wxMessageBox(_("Cannot open file"), _("Error"), wxOK | wxCENTRE | wxICON_ERROR);
-			else if (nfcError == NFC_ERROR_INVALID_FILE_FORMAT)
-				wxMessageBox(_("Not a valid NFC NTAG215 file"), _("Error"), wxOK | wxCENTRE | wxICON_ERROR);
+			else if (nfcError == NFC_TOUCH_TAG_ERROR_INVALID_FILE_FORMAT)
+				wxMessageBox(_("Not a valid NFC file"), _("Error"), wxOK | wxCENTRE | wxICON_ERROR);
 			return false;
 		}
 	}
@@ -282,77 +289,95 @@ private:
 };
 
 MainWindow::MainWindow()
-	: wxFrame(nullptr, -1, GetInitialWindowTitle(), wxDefaultPosition, wxSize(1280, 720), wxMINIMIZE_BOX | wxMAXIMIZE_BOX | wxSYSTEM_MENU | wxCAPTION | wxCLOSE_BOX | wxCLIP_CHILDREN | wxRESIZE_BORDER)
+	: wxFrame(nullptr, wxID_ANY, GetInitialWindowTitle(), wxDefaultPosition, wxSize(1280, 720), wxMINIMIZE_BOX | wxMAXIMIZE_BOX | wxSYSTEM_MENU | wxCAPTION | wxCLOSE_BOX | wxCLIP_CHILDREN | wxRESIZE_BORDER)
 {
+#ifdef __WXMAC__
+	// Not necessary to set wxApp::s_macExitMenuItemId as automatically handled
+	wxApp::s_macAboutMenuItemId = MAINFRAME_MENU_ID_HELP_ABOUT;
+	wxApp::s_macPreferencesMenuItemId = MAINFRAME_MENU_ID_OPTIONS_MAC_SETTINGS;
+#endif
 	gui_initHandleContextFromWxWidgetsWindow(g_window_info.window_main, this);
 	g_mainFrame = this;
+	CafeSystem::SetImplementation(this);
 
 	RecreateMenu();
 	SetClientSize(1280, 720);
 	SetIcon(wxICON(M_WND_ICON128));
 
+#if BOOST_OS_MACOS
+	this->EnableFullScreenView(true);
+#endif
+
 #if BOOST_OS_WINDOWS
 	HICON hWindowIcon = (HICON)LoadImageA(NULL, "M_WND_ICON16", IMAGE_ICON, 16, 16, LR_LOADFROMFILE);
 	SendMessage(this->GetHWND(), WM_SETICON, ICON_SMALL, (LPARAM)hWindowIcon);
 #endif
 
 	auto* main_sizer = new wxBoxSizer(wxVERTICAL);
-	if (!LaunchSettings::GetLoadFile().has_value())
-	{
-		{
-			m_main_panel = new wxPanel(this);
-			auto* sizer = new wxBoxSizer(wxVERTICAL);
-			// game list
-			m_game_list = new wxGameList(m_main_panel, MAINFRAME_GAMELIST_ID);
-			m_game_list->Bind(wxEVT_OPEN_SETTINGS, [this](auto&) {OpenSettings(); });
-			m_game_list->SetDropTarget(new wxGameDropTarget(this));
-			sizer->Add(m_game_list, 1, wxEXPAND);
+    auto load_file = LaunchSettings::GetLoadFile();
+    auto load_title_id = LaunchSettings::GetLoadTitleID();
+    bool quick_launch = false;
 
-			// info, warning bar
-			m_info_bar = new wxInfoBar(m_main_panel);
-			m_info_bar->SetShowHideEffects(wxSHOW_EFFECT_BLEND, wxSHOW_EFFECT_BLEND);
-			m_info_bar->SetEffectDuration(500);
-			sizer->Add(m_info_bar, 0, wxALL | wxEXPAND, 5);
+    if (load_file)
+    {
+        MainWindow::RequestLaunchGame(load_file.value(), wxLaunchGameEvent::INITIATED_BY::COMMAND_LINE);
+        quick_launch = true;
+    }
+    else if (load_title_id)
+    {
+        TitleInfo info;
+        TitleId baseId;
+        if (CafeTitleList::FindBaseTitleId(load_title_id.value(), baseId) && CafeTitleList::GetFirstByTitleId(baseId, info))
+        {
+            MainWindow::RequestLaunchGame(info.GetPath(), wxLaunchGameEvent::INITIATED_BY::COMMAND_LINE);
+            quick_launch = true;
+        }
+        else
+        {
+            wxString errorMsg = fmt::format("Title ID {:016x} not found", load_title_id.value());
+            wxMessageBox(errorMsg, _("Error"), wxOK | wxCENTRE | wxICON_ERROR);
 
-			m_main_panel->SetSizer(sizer);
-			main_sizer->Add(m_main_panel, 1, wxEXPAND, 0, nullptr);
-		}
-	}
-	else
-	{
-		// launching game via -g option. Dont setup or load game list
-		m_game_list = nullptr;
-		m_info_bar = nullptr;
-	}
-	SetSizer(main_sizer);
+        }
+    }
+    SetSizer(main_sizer);
+    if (!quick_launch)
+    {
+        CreateGameListAndStatusBar();
+    }
+    else
+    {
+      // launching game via -g or -t option. Don't set up or load game list
+      m_game_list = nullptr;
+      m_info_bar = nullptr;
+    }
+    SetSizer(main_sizer);
 
-	m_last_mouse_move_time = std::chrono::steady_clock::now();
+    m_last_mouse_move_time = std::chrono::steady_clock::now();
 
-	m_timer = new wxTimer(this, MAINFRAME_ID_TIMER1);
-	m_timer->Start(500);
+    m_timer = new wxTimer(this, MAINFRAME_ID_TIMER1);
+    m_timer->Start(500);
 
-	LoadSettings();
+    LoadSettings();
 
-#ifdef ENABLE_DISCORD_RPC
-	auto& config = GetConfig();
-	if (config.use_discord_presence)
-		m_discord = std::make_unique<DiscordPresence>();
-#endif
+    auto& config = GetConfig();
+    #ifdef ENABLE_DISCORD_RPC
+    if (config.use_discord_presence)
+            m_discord = std::make_unique<DiscordPresence>();
+    #endif
 
-	Bind(wxEVT_OPEN_GRAPHIC_PACK, &MainWindow::OnGraphicWindowOpen, this);
-	Bind(wxEVT_LAUNCH_GAME, &MainWindow::OnLaunchFromFile, this);
+    Bind(wxEVT_OPEN_GRAPHIC_PACK, &MainWindow::OnGraphicWindowOpen, this);
+    Bind(wxEVT_LAUNCH_GAME, &MainWindow::OnLaunchFromFile, this);
 
-	if (LaunchSettings::GetLoadFile().has_value())
-	{
-		MainWindow::RequestLaunchGame(LaunchSettings::GetLoadFile().value(), wxLaunchGameEvent::INITIATED_BY::COMMAND_LINE);
-	}
+    if (LaunchSettings::GDBStubEnabled())
+    {
+            g_gdbstub = std::make_unique<GDBServer>(config.gdb_port);
+    }
 }
 
 MainWindow::~MainWindow()
 {
 	if (m_padView)
 	{
-		//delete m_padView;
 		m_padView->Destroy();
 		m_padView = nullptr;
 	}
@@ -363,32 +388,49 @@ MainWindow::~MainWindow()
 	g_mainFrame = nullptr;
 }
 
+void MainWindow::CreateGameListAndStatusBar()
+{
+    if(m_main_panel)
+        return; // already displayed
+    m_main_panel = new wxPanel(this);
+    auto* sizer = new wxBoxSizer(wxVERTICAL);
+    // game list
+    m_game_list = new wxGameList(m_main_panel, MAINFRAME_GAMELIST_ID);
+    m_game_list->Bind(wxEVT_OPEN_SETTINGS, [this](auto&) {OpenSettings(); });
+    m_game_list->SetDropTarget(new wxGameDropTarget(this));
+    sizer->Add(m_game_list, 1, wxEXPAND);
+
+    // info, warning bar
+    m_info_bar = new wxInfoBar(m_main_panel);
+    m_info_bar->SetShowHideEffects(wxSHOW_EFFECT_BLEND, wxSHOW_EFFECT_BLEND);
+    m_info_bar->SetEffectDuration(500);
+    sizer->Add(m_info_bar, 0, wxALL | wxEXPAND, 5);
+
+    m_main_panel->SetSizer(sizer);
+
+    auto* main_sizer = this->GetSizer();
+    main_sizer->Add(m_main_panel, 1, wxEXPAND, 0, nullptr);
+}
+
+void MainWindow::DestroyGameListAndStatusBar()
+{
+    if(!m_main_panel)
+        return;
+    m_main_panel->Destroy();
+    m_main_panel = nullptr;
+    m_game_list = nullptr;
+    m_info_bar = nullptr;
+}
+
 wxString MainWindow::GetInitialWindowTitle()
 {
 	return BUILD_VERSION_WITH_NAME_STRING;
 }
 
-void MainWindow::ShowGettingStartedDialog()
-{	
-	GettingStartedDialog dia(this);
-	dia.ShowModal();
-	if (dia.HasGamePathChanged() || dia.HasMLCChanged())
-		m_game_list->ReloadGameEntries();
-		
-	TogglePadView();
-	
-	auto& config = GetConfig();
-	m_padViewMenuItem->Check(config.pad_open.GetValue());
-	m_fullscreenMenuItem->Check(config.fullscreen.GetValue());
-}
-
-namespace coreinit
-{
-	void OSSchedulerEnd();
-};
-
 void MainWindow::OnClose(wxCloseEvent& event)
 {
+	wxTheClipboard->Flush();
+
 	if(m_game_list)
 		m_game_list->OnClose(event);
 
@@ -400,7 +442,7 @@ void MainWindow::OnClose(wxCloseEvent& event)
 
 	event.Skip();
 
-	CafeSystem::ShutdownTitle();
+    CafeSystem::Shutdown();
 	DestroyCanvas();
 }
 
@@ -438,9 +480,8 @@ bool MainWindow::InstallUpdate(const fs::path& metaFilePath)
 	return false;
 }
 
-bool MainWindow::FileLoad(std::wstring fileName, wxLaunchGameEvent::INITIATED_BY initiatedBy)
+bool MainWindow::FileLoad(const fs::path launchPath, wxLaunchGameEvent::INITIATED_BY initiatedBy)
 {
-	const fs::path launchPath = fs::path(fileName);
 	TitleInfo launchTitle{ launchPath };
 	if (launchTitle.IsValid())
 	{
@@ -454,40 +495,40 @@ bool MainWindow::FileLoad(std::wstring fileName, wxLaunchGameEvent::INITIATED_BY
 			wxMessageBox(t, _("Error"), wxOK | wxCENTRE | wxICON_ERROR);
 			return false;
 		}
-		CafeSystem::STATUS_CODE r = CafeSystem::PrepareForegroundTitle(baseTitleId);
-		if (r == CafeSystem::STATUS_CODE::INVALID_RPX)
+		CafeSystem::PREPARE_STATUS_CODE r = CafeSystem::PrepareForegroundTitle(baseTitleId);
+		if (r == CafeSystem::PREPARE_STATUS_CODE::INVALID_RPX)
 		{
 			cemu_assert_debug(false);
 			return false;
 		}
-		else if (r == CafeSystem::STATUS_CODE::UNABLE_TO_MOUNT)
+		else if (r == CafeSystem::PREPARE_STATUS_CODE::UNABLE_TO_MOUNT)
 		{
 			wxString t = _("Unable to mount title.\nMake sure the configured game paths are still valid and refresh the game list.\n\nFile which failed to load:\n");
-			t.append(fileName);
+			t.append(_pathToUtf8(launchPath));
 			wxMessageBox(t, _("Error"), wxOK | wxCENTRE | wxICON_ERROR);
 			return false;
 		}
-		else if (r != CafeSystem::STATUS_CODE::SUCCESS)
+		else if (r != CafeSystem::PREPARE_STATUS_CODE::SUCCESS)
 		{
 			wxString t = _("Failed to launch game.");
-			t.append(fileName);
+			t.append(_pathToUtf8(launchPath));
 			wxMessageBox(t, _("Error"), wxOK | wxCENTRE | wxICON_ERROR);
 			return false;
 		}
 	}
 	else //if (launchTitle.GetFormat() == TitleInfo::TitleDataFormat::INVALID_STRUCTURE )
 	{
-		// title is invalid, if its an RPX/ELF we can launch it directly
-		// otherwise its an error
+		// title is invalid, if it's an RPX/ELF we can launch it directly
+		// otherwise it's an error
 		CafeTitleFileType fileType = DetermineCafeSystemFileType(launchPath);
 		if (fileType == CafeTitleFileType::RPX || fileType == CafeTitleFileType::ELF)
 		{
-			CafeSystem::STATUS_CODE r = CafeSystem::PrepareForegroundTitleFromStandaloneRPX(launchPath);
-			if (r != CafeSystem::STATUS_CODE::SUCCESS)
+			CafeSystem::PREPARE_STATUS_CODE r = CafeSystem::PrepareForegroundTitleFromStandaloneRPX(launchPath);
+			if (r != CafeSystem::PREPARE_STATUS_CODE::SUCCESS)
 			{
 				cemu_assert_debug(false); // todo
 				wxString t = _("Failed to launch executable. Path: ");
-				t.append(fileName);
+				t.append(_pathToUtf8(launchPath));
 				wxMessageBox(t, _("Error"), wxOK | wxCENTRE | wxICON_ERROR);
 				return false;
 			}
@@ -495,7 +536,7 @@ bool MainWindow::FileLoad(std::wstring fileName, wxLaunchGameEvent::INITIATED_BY
 		else if (initiatedBy == wxLaunchGameEvent::INITIATED_BY::GAME_LIST)
 		{
 			wxString t = _("Unable to launch title.\nMake sure the configured game paths are still valid and refresh the game list.\n\nPath which failed to load:\n");
-			t.append(fileName);
+			t.append(_pathToUtf8(launchPath));
 			wxMessageBox(t, _("Error"), wxOK | wxCENTRE | wxICON_ERROR);
 			return false;
 		}
@@ -503,69 +544,81 @@ bool MainWindow::FileLoad(std::wstring fileName, wxLaunchGameEvent::INITIATED_BY
 			initiatedBy == wxLaunchGameEvent::INITIATED_BY::COMMAND_LINE)
 		{
 			wxString t = _("Unable to launch game\nPath:\n");
-			t.append(fileName);
+			t.append(_pathToUtf8(launchPath));
+			if(launchTitle.GetInvalidReason() == TitleInfo::InvalidReason::NO_DISC_KEY)
+			{
+				t.append("\n\n");
+				t.append(_("Could not decrypt title. Make sure that keys.txt contains the correct disc key for this title."));
+			}
+			if(launchTitle.GetInvalidReason() == TitleInfo::InvalidReason::NO_TITLE_TIK)
+			{
+				t.append("\n\n");
+				t.append(_("Could not decrypt title because title.tik is missing."));
+			}
 			wxMessageBox(t, _("Error"), wxOK | wxCENTRE | wxICON_ERROR);
 			return false;
 		}
 		else
 		{
 			wxString t = _("Unable to launch game\nPath:\n");
-			t.append(fileName);
+			t.append(_pathToUtf8(launchPath));
 			wxMessageBox(t, _("Error"), wxOK | wxCENTRE | wxICON_ERROR);
 			return false;
 		}
 	}
 
 	if(launchTitle.IsValid())
-		GetConfig().AddRecentlyLaunchedFile(launchTitle.GetPath().generic_wstring());
+		GetConfig().AddRecentlyLaunchedFile(_pathToUtf8(launchTitle.GetPath()));
 	else
-		GetConfig().AddRecentlyLaunchedFile(fileName);
+		GetConfig().AddRecentlyLaunchedFile(_pathToUtf8(launchPath));
 
 	wxWindowUpdateLocker lock(this);
 
-	auto* main_sizer = GetSizer();
-	// remove old gamelist panel
-	if (m_main_panel)
-	{
-		m_main_panel->Hide();
-		main_sizer->Detach(m_main_panel);
-	}
-
-	// create render canvas rendering
-	m_game_panel = new wxPanel(this, wxID_ANY, wxDefaultPosition, wxDefaultSize, wxTAB_TRAVERSAL | wxNO_BORDER | wxWANTS_CHARS);
-	auto* sizer = new wxBoxSizer(wxVERTICAL);
-
-	// shouldn't be needed, but who knows
-	m_game_panel->Bind(wxEVT_KEY_UP, &MainWindow::OnKeyUp, this);
-	m_game_panel->Bind(wxEVT_CHAR, &MainWindow::OnChar, this);
-
-	m_game_panel->SetSizer(sizer);
-	main_sizer->Add(m_game_panel, 1, wxEXPAND, 0, nullptr);
+    DestroyGameListAndStatusBar();
 
 	m_game_launched = true;
 	m_loadMenuItem->Enable(false);
 	m_installUpdateMenuItem->Enable(false);
 	m_memorySearcherMenuItem->Enable(true);
 
-	if (m_game_list)
-	{
-		delete m_game_list;
-		m_game_list = nullptr;
-	}
-
-	const auto game_name = GetGameName(fileName);
-	m_launched_game_name = boost::nowide::narrow(game_name);
+	m_launched_game_name = CafeSystem::GetForegroundTitleName();
 	#ifdef ENABLE_DISCORD_RPC
 	if (m_discord)
 		m_discord->UpdatePresence(DiscordPresence::Playing, m_launched_game_name);
 	#endif
 
+	if (GetConfig().disable_screensaver)
+	{
+		ScreenSaver::SetInhibit(true);
+		// TODO: disable when only the game, not Cemu, is closed (a feature not yet implemented)
+		// currently unnecessary because this will happen automatically when Cemu closes
+		// ScreenSaver::SetInhibit(false);
+	}
+
 	if (ActiveSettings::FullscreenEnabled())
 		SetFullScreen(true);
 
+    //GameMode support
+#if BOOST_OS_LINUX && defined(ENABLE_FERAL_GAMEMODE)
+    if(GetConfig().feral_gamemode)
+    {
+        // attempt to start gamemode
+        if(gamemode_request_start() < 0)
+        {
+            // GameMode failed to start
+            cemuLog_log(LogType::Force, "Could not start GameMode");
+        }
+        else
+        {
+            cemuLog_log(LogType::Force, "GameMode has been started.");
+        }
+    }
+#endif
+
 	CreateCanvas();
 	CafeSystem::LaunchForegroundTitle();
 	RecreateMenu();
+	UpdateChildWindowTitleRunningState();
 
 	return true;
 }
@@ -574,7 +627,7 @@ void MainWindow::OnLaunchFromFile(wxLaunchGameEvent& event)
 {
 	if (event.GetPath().empty())
 		return;
-	FileLoad(event.GetPath().generic_wstring(), event.GetInitiatedBy());
+	FileLoad(event.GetPath(), event.GetInitiatedBy());
 }
 
 void MainWindow::OnFileMenu(wxCommandEvent& event)
@@ -582,26 +635,30 @@ void MainWindow::OnFileMenu(wxCommandEvent& event)
 	const auto menuId = event.GetId();
 	if (menuId == MAINFRAME_MENU_ID_FILE_LOAD)
 	{
-		const auto wildcard = wxStringFormat2(
-			"{}|*.wud;*.wux;*.wua;*.iso;*.rpx;*.elf"
+		const auto wildcard = formatWxString(
+			"{}|*.wud;*.wux;*.wua;*.wuhb;*.iso;*.rpx;*.elf;title.tmd"
 			"|{}|*.wud;*.wux;*.iso"
+			"|{}|title.tmd"
 			"|{}|*.wua"
+			"|{}|*.wuhb"
 			"|{}|*.rpx;*.elf"
 			"|{}|*",
-			_("All Wii U files (*.wud, *.wux, *.wua, *.iso, *.rpx, *.elf)"),
+			_("All Wii U files (*.wud, *.wux, *.wua, *.wuhb, *.iso, *.rpx, *.elf)"),
 			_("Wii U image (*.wud, *.wux, *.iso, *.wad)"),
+			_("Wii U NUS content"),
 			_("Wii U archive (*.wua)"),
+			_("Wii U homebrew bundle (*.wuhb)"),
 			_("Wii U executable (*.rpx, *.elf)"),
-			_("All files (*.*)")		
+			_("All files (*.*)")
 		);
 		
 		wxFileDialog openFileDialog(this, _("Open file to launch"), wxEmptyString, wxEmptyString, wildcard, wxFD_OPEN | wxFD_FILE_MUST_EXIST);
 
-		if (openFileDialog.ShowModal() == wxID_CANCEL)
+		if (openFileDialog.ShowModal() == wxID_CANCEL || openFileDialog.GetPath().IsEmpty())
 			return;
 
 		const wxString wxStrFilePath = openFileDialog.GetPath();	
-		FileLoad(wxStrFilePath.wc_str(), wxLaunchGameEvent::INITIATED_BY::MENU);
+		FileLoad(_utf8ToPath(wxStrFilePath.utf8_string()), wxLaunchGameEvent::INITIATED_BY::MENU);
 	}
 	else if (menuId >= MAINFRAME_MENU_ID_FILE_RECENT_0 && menuId <= MAINFRAME_MENU_ID_FILE_RECENT_LAST)
 	{
@@ -609,27 +666,43 @@ void MainWindow::OnFileMenu(wxCommandEvent& event)
 		const size_t index = menuId - MAINFRAME_MENU_ID_FILE_RECENT_0;
 		if (index < config.recent_launch_files.size())
 		{
-			const auto& path = config.recent_launch_files[index];
+			fs::path path = _utf8ToPath(config.recent_launch_files[index]);
 			if (!path.empty())
 				FileLoad(path, wxLaunchGameEvent::INITIATED_BY::MENU);
 		}
 	}
 	else if (menuId == MAINFRAME_MENU_ID_FILE_END_EMULATION)
 	{
-		CafeSystem::ShutdownTitle();
+        CafeSystem::ShutdownTitle();
 		DestroyCanvas();
 		m_game_launched = false;
 		RecreateMenu();
+        CreateGameListAndStatusBar();
+        DoLayout();
+		UpdateChildWindowTitleRunningState();
 	}
 }
 
+void MainWindow::OnOpenFolder(wxCommandEvent& event)
+{
+	const auto id = event.GetId();
+	if(id == MAINFRAME_MENU_ID_FILE_OPEN_CEMU_FOLDER)
+		wxLaunchDefaultApplication(wxHelper::FromPath(ActiveSettings::GetUserDataPath()));
+	else if(id == MAINFRAME_MENU_ID_FILE_OPEN_MLC_FOLDER)
+		wxLaunchDefaultApplication(wxHelper::FromPath(ActiveSettings::GetMlcPath()));
+	else if (id == MAINFRAME_MENU_ID_FILE_OPEN_SHADERCACHE_FOLDER)
+		wxLaunchDefaultApplication(wxHelper::FromPath(ActiveSettings::GetCachePath("shaderCache")));
+
+
+}
+
 void MainWindow::OnInstallUpdate(wxCommandEvent& event)
 {
 	while (true)
 	{
 		wxDirDialog openDirDialog(nullptr, _("Select folder of title to install"), "", wxDD_DEFAULT_STYLE | wxDD_DIR_MUST_EXIST, wxDefaultPosition, wxDefaultSize, _("Select the folder that stores your update, DLC or base game files"));
 		int modalChoice = openDirDialog.ShowModal();
-		if (modalChoice == wxID_CANCEL)
+		if (modalChoice == wxID_CANCEL || openDirDialog.GetPath().IsEmpty())
 			break;
 		if (modalChoice == wxID_OK)
 		{
@@ -643,7 +716,7 @@ void MainWindow::OnInstallUpdate(wxCommandEvent& event)
 			{
 				if (!fs::exists(dirPath.parent_path() / "code") || !fs::exists(dirPath.parent_path() / "content") || !fs::exists(dirPath.parent_path() / "meta"))
 				{
-					wxMessageBox(wxStringFormat2(_("The (parent) folder of the title you selected is missing at least one of the required subfolders (\"code\", \"content\" and \"meta\")\nMake sure that the files are complete."), dirPath.filename().string()));
+					wxMessageBox(formatWxString(_("The (parent) folder of the title you selected is missing at least one of the required subfolders (\"code\", \"content\" and \"meta\")\nMake sure that the files are complete."), dirPath.filename().string()));
 					continue;
 				}
 				else
@@ -670,20 +743,20 @@ void MainWindow::OnNFCMenu(wxCommandEvent& event)
 		wxFileDialog
 			openFileDialog(this, _("Open file to load"), "", "",
 				"All NFC files (bin, dat, nfc)|*.bin;*.dat;*.nfc|All files (*.*)|*", wxFD_OPEN | wxFD_FILE_MUST_EXIST); // TRANSLATE
-		if (openFileDialog.ShowModal() == wxID_CANCEL)
+		if (openFileDialog.ShowModal() == wxID_CANCEL || openFileDialog.GetPath().IsEmpty())
 			return;
 		wxString wxStrFilePath = openFileDialog.GetPath();
 		uint32 nfcError;
-		if (nnNfp_touchNfcTagFromFile(wxStrFilePath.wc_str(), &nfcError) == false)
+		if (nfc::TouchTagFromFile(_utf8ToPath(wxStrFilePath.utf8_string()), &nfcError) == false)
 		{
-			if (nfcError == NFC_ERROR_NO_ACCESS)
+			if (nfcError == NFC_TOUCH_TAG_ERROR_NO_ACCESS)
 				wxMessageBox(_("Cannot open file"));
-			else if (nfcError == NFC_ERROR_INVALID_FILE_FORMAT)
-				wxMessageBox(_("Not a valid NFC NTAG215 file"));
+			else if (nfcError == NFC_TOUCH_TAG_ERROR_INVALID_FILE_FORMAT)
+				wxMessageBox(_("Not a valid NFC file"));
 		}
 		else
 		{
-			GetConfig().AddRecentNfcFile((wchar_t*)wxStrFilePath.wc_str());
+			GetConfig().AddRecentNfcFile(wxStrFilePath.utf8_string());
 			UpdateNFCMenu();
 		}
 	}
@@ -697,12 +770,12 @@ void MainWindow::OnNFCMenu(wxCommandEvent& event)
 			if (!path.empty())
 			{
 				uint32 nfcError = 0;
-				if (nnNfp_touchNfcTagFromFile(path.c_str(), &nfcError) == false)
+				if (nfc::TouchTagFromFile(_utf8ToPath(path), &nfcError) == false)
 				{
-					if (nfcError == NFC_ERROR_NO_ACCESS)
+					if (nfcError == NFC_TOUCH_TAG_ERROR_NO_ACCESS)
 						wxMessageBox(_("Cannot open file"));
-					else if (nfcError == NFC_ERROR_INVALID_FILE_FORMAT)
-						wxMessageBox(_("Not a valid NFC NTAG215 file"));
+					else if (nfcError == NFC_TOUCH_TAG_ERROR_INVALID_FILE_FORMAT)
+						wxMessageBox(_("Not a valid NFC file"));
 				}
 				else
 				{
@@ -734,6 +807,12 @@ void MainWindow::TogglePadView()
 		m_padView->Bind(wxEVT_CLOSE_WINDOW, &MainWindow::OnPadClose, this);
 
 		m_padView->Show(true);
+
+#if BOOST_OS_LINUX && HAS_WAYLAND
+		if (wxWlIsWaylandWindow(m_padView))
+			wxWlSetAppId(m_padView, "info.cemu.Cemu");
+#endif
+
 		m_padView->Initialize();
 		if (m_game_launched)
 			m_padView->InitializeRenderCanvas();
@@ -773,7 +852,6 @@ void MainWindow::OpenSettings()
 	frame.ShowModal();
 	const bool paths_modified = frame.ShouldReloadGamelist();
 	const bool mlc_modified = frame.MLCModified();
-	frame.Destroy();
 
 	if (paths_modified)
 		m_game_list->ReloadGameEntries(false);
@@ -841,6 +919,7 @@ void MainWindow::OnOptionsInput(wxCommandEvent& event)
 		break;
 	}
 
+	case MAINFRAME_MENU_ID_OPTIONS_MAC_SETTINGS:
 	case MAINFRAME_MENU_ID_OPTIONS_GENERAL2:
 	{
 		OpenSettings();
@@ -868,38 +947,6 @@ void MainWindow::OnAccountSelect(wxCommandEvent& event)
 	g_config.Save();
 }
 
-//void MainWindow::OnConsoleRegion(wxCommandEvent& event)
-//{
-//	switch (event.GetId())
-//	{
-//	case MAINFRAME_MENU_ID_OPTIONS_REGION_AUTO:
-//		GetConfig().console_region = ConsoleRegion::Auto;
-//		break;
-//	case MAINFRAME_MENU_ID_OPTIONS_REGION_JPN:
-//		GetConfig().console_region = ConsoleRegion::JPN;
-//		break;
-//	case MAINFRAME_MENU_ID_OPTIONS_REGION_USA:
-//		GetConfig().console_region = ConsoleRegion::USA;
-//		break;
-//	case MAINFRAME_MENU_ID_OPTIONS_REGION_EUR:
-//		GetConfig().console_region = ConsoleRegion::EUR;
-//		break;
-//	case MAINFRAME_MENU_ID_OPTIONS_REGION_CHN:
-//		GetConfig().console_region = ConsoleRegion::CHN;
-//		break;
-//	case MAINFRAME_MENU_ID_OPTIONS_REGION_KOR:
-//		GetConfig().console_region = ConsoleRegion::KOR;
-//		break;
-//	case MAINFRAME_MENU_ID_OPTIONS_REGION_TWN:
-//		GetConfig().console_region = ConsoleRegion::TWN;
-//		break;
-//	default:
-//		cemu_assert_debug(false);
-//	}
-//	
-//	g_config.Save();
-//}
-
 void MainWindow::OnConsoleLanguage(wxCommandEvent& event)
 {
 	switch (event.GetId())
@@ -943,6 +990,11 @@ void MainWindow::OnConsoleLanguage(wxCommandEvent& event)
 	default:
 		cemu_assert_debug(false);
 	}
+	if (m_game_list)
+	{
+		m_game_list->DeleteCachedStrings();
+		m_game_list->ReloadGameEntries(false);
+	}
 	g_config.Save();
 }
 
@@ -986,10 +1038,6 @@ void MainWindow::OnDebugSetting(wxCommandEvent& event)
 				wxMessageBox(_("Dump complete"));
 			}*/
 	}
-	else if (event.GetId() == MAINFRAME_MENU_ID_DEBUG_SHOW_FRAME_PROFILER)
-	{
-		ActiveSettings::EnableFrameProfiler(event.IsChecked());
-	}
 	else if (event.GetId() == MAINFRAME_MENU_ID_DEBUG_DUMP_CURL_REQUESTS)
 	{
 		// toggle debug -> dump -> curl requests
@@ -999,13 +1047,13 @@ void MainWindow::OnDebugSetting(wxCommandEvent& event)
 		{
 			try
 			{
-				const auto path = CemuApp::GetCemuPath(L"dump\\curl").ToStdWstring();
-				fs::create_directories(path);
+				const fs::path path(ActiveSettings::GetUserDataPath());
+				fs::create_directories(path / "dump" / "curl");
 			}
 			catch (const std::exception& ex)
 			{
 				SystemException sys(ex);
-				forceLog_printf("error when creating dump curl folder: %s", sys.what());
+				cemuLog_log(LogType::Force, "error when creating dump curl folder: {}", sys.what());
 				ActiveSettings::EnableDumpLibcurlRequests(false);
 			}
 		}
@@ -1035,9 +1083,16 @@ void MainWindow::OnDebugLoggingToggleFlagGeneric(wxCommandEvent& event)
 	sint32 loggingIdBase = MAINFRAME_MENU_ID_DEBUG_LOGGING0;
 
 	sint32 id = event.GetId();
-	if (id >= loggingIdBase && id < (MAINFRAME_MENU_ID_DEBUG_LOGGING0 + 20))
+	if (id >= loggingIdBase && id < (MAINFRAME_MENU_ID_DEBUG_LOGGING0 + 64))
 	{
-		cafeLog_setLoggingFlagEnable(id - loggingIdBase, event.IsChecked());
+		bool isEnable = event.IsChecked();
+		LogType loggingType = static_cast<LogType>(id - loggingIdBase);
+		if (isEnable)
+			GetConfig().log_flag = GetConfig().log_flag.GetValue() | cemuLog_getFlag(loggingType);
+		else
+			GetConfig().log_flag = GetConfig().log_flag.GetValue() & ~cemuLog_getFlag(loggingType);
+		cemuLog_setActiveLoggingFlags(GetConfig().log_flag.GetValue());
+		g_config.Save();
 	}
 }
 
@@ -1047,43 +1102,39 @@ void MainWindow::OnPPCInfoToggle(wxCommandEvent& event)
 	g_config.Save();
 }
 
-void MainWindow::OnDebugDumpUsedTextures(wxCommandEvent& event)
+void MainWindow::OnDebugDumpGeneric(wxCommandEvent& event)
 {
-	const bool value = event.IsChecked();
-	ActiveSettings::EnableDumpTextures(value);
-	if (value)
+	std::string dumpSubpath;
+	std::function<void(bool)> setDumpState;
+	switch(event.GetId())
 	{
-		try
-		{
-			// create directory
-			const auto path = CemuApp::GetCemuPath(L"dump\\textures");
-			fs::create_directories(path.ToStdWstring());
-		}
-		catch (const std::exception& ex)
-		{
-			SystemException sys(ex);
-			forceLog_printf("can't create texture dump folder: %s", ex.what());
-			ActiveSettings::EnableDumpTextures(false);
-		}
+	case MAINFRAME_MENU_ID_DEBUG_DUMP_TEXTURES:
+		dumpSubpath = "dump/textures";
+		setDumpState = ActiveSettings::EnableDumpTextures;
+		break;
+	case MAINFRAME_MENU_ID_DEBUG_DUMP_SHADERS:
+		dumpSubpath = "dump/shaders";
+		setDumpState = ActiveSettings::EnableDumpShaders;
+		break;
+	case MAINFRAME_MENU_ID_DEBUG_DUMP_RECOMPILER_FUNCTIONS:
+		dumpSubpath = "dump/recompiler";
+		setDumpState = ActiveSettings::EnableDumpRecompilerFunctions;
+		break;
+	default:
+		UNREACHABLE;
 	}
-}
-
-void MainWindow::OnDebugDumpUsedShaders(wxCommandEvent& event)
-{
 	const bool value = event.IsChecked();
-	ActiveSettings::EnableDumpShaders(value);
+	setDumpState(value);
 	if (value)
 	{
 		try
 		{
-			// create directory
-			const auto path = CemuApp::GetCemuPath(L"dump\\shaders");
-			fs::create_directories(path.ToStdWstring());
+			fs::create_directories(ActiveSettings::GetUserDataPath("dump/shaders"));
 		}
 		catch (const std::exception & ex)
 		{
 			SystemException sys(ex);
-			forceLog_printf("can't create shaders dump folder: %s", ex.what());
+			cemuLog_log(LogType::Force, "can't create shaders dump folder: {}", ex.what());
 			ActiveSettings::EnableDumpShaders(false);
 		}
 	}
@@ -1103,6 +1154,18 @@ void MainWindow::OnLoggingWindow(wxCommandEvent& event)
 	m_logging_window->Show(true);
 }
 
+void MainWindow::OnGDBStubToggle(wxCommandEvent& event)
+{
+	if (g_gdbstub)
+	{
+		g_gdbstub.release();
+		return;
+	}
+
+	const auto& config = GetConfig();
+	g_gdbstub = std::make_unique<GDBServer>(config.gdb_port);
+}
+
 void MainWindow::OnDebugViewPPCThreads(wxCommandEvent& event)
 {
 	auto frame = new DebugPPCThreadsWindow(*this);
@@ -1309,7 +1372,8 @@ void MainWindow::OnMouseMove(wxMouseEvent& event)
 
 	auto& instance = InputManager::instance();
 	std::unique_lock lock(instance.m_main_mouse.m_mutex);
-	instance.m_main_mouse.position = { event.GetPosition().x, event.GetPosition().y };
+	auto physPos = ToPhys(event.GetPosition());
+	instance.m_main_mouse.position = { physPos.x, physPos.y };
 	lock.unlock();
 
 	if (!IsFullScreen())
@@ -1327,7 +1391,8 @@ void MainWindow::OnMouseLeft(wxMouseEvent& event)
 	
 	std::scoped_lock lock(instance.m_main_mouse.m_mutex);
 	instance.m_main_mouse.left_down = event.ButtonDown(wxMOUSE_BTN_LEFT);
-	instance.m_main_mouse.position = { event.GetPosition().x, event.GetPosition().y };
+	auto physPos = ToPhys(event.GetPosition());
+	instance.m_main_mouse.position = { physPos.x, physPos.y };
 	if (event.ButtonDown(wxMOUSE_BTN_LEFT))
 		instance.m_main_mouse.left_down_toggle = true;
 	
@@ -1340,7 +1405,8 @@ void MainWindow::OnMouseRight(wxMouseEvent& event)
 
 	std::scoped_lock lock(instance.m_main_mouse.m_mutex);
 	instance.m_main_mouse.right_down = event.ButtonDown(wxMOUSE_BTN_RIGHT);
-	instance.m_main_mouse.position = { event.GetPosition().x, event.GetPosition().y };
+	auto physPos = ToPhys(event.GetPosition());
+	instance.m_main_mouse.position = { physPos.x, physPos.y };
 	if(event.ButtonDown(wxMOUSE_BTN_RIGHT))
 		instance.m_main_mouse.right_down_toggle = true;
 	
@@ -1383,22 +1449,39 @@ void MainWindow::OnKeyUp(wxKeyEvent& event)
 	const auto code = event.GetKeyCode();
 	if (code == WXK_ESCAPE)
 		SetFullScreen(false);
-	else if (code == WXK_RETURN && event.AltDown())
+	else if (code == WXK_RETURN && event.AltDown() || code == WXK_F11)
 		SetFullScreen(!IsFullScreen());
-#ifdef PUBLIC_RELEASE
 	else if (code == WXK_F12)
-#else
-	else if (code == WXK_F11)
-#endif
 		g_window_info.has_screenshot_request = true; // async screenshot request
 }
 
+void MainWindow::OnKeyDown(wxKeyEvent& event)
+{
+#if defined(__APPLE__)
+       // On macOS, allow Cmd+Q to quit the application
+    if (event.CmdDown() && event.GetKeyCode() == 'Q')
+    {
+        Close(true);
+    }
+#else
+     // On Windows/Linux, only Alt+F4 is allowed for quitting
+    if (event.AltDown() && event.GetKeyCode() == WXK_F4)
+    {
+        Close(true);
+    }
+#endif
+    else
+    {
+        event.Skip(); 
+    }
+}
+
 void MainWindow::OnChar(wxKeyEvent& event)
 {
 	if (swkbd_hasKeyboardInputHook())
 		swkbd_keyInput(event.GetUnicodeKey());
 	
-	event.Skip();
+	// event.Skip();
 }
 
 void MainWindow::OnToolsInput(wxCommandEvent& event)
@@ -1435,6 +1518,29 @@ void MainWindow::OnToolsInput(wxCommandEvent& event)
 				});
 			m_title_manager->Show();
 		}
+		break;
+	}
+	case MAINFRAME_MENU_ID_TOOLS_EMULATED_USB_DEVICES:
+	{
+		if (m_usb_devices)
+		{
+			m_usb_devices->Show(true);
+			m_usb_devices->Raise();
+			m_usb_devices->SetFocus();
+		}
+		else
+		{
+			m_usb_devices = new EmulatedUSBDeviceFrame(this);
+			m_usb_devices->Bind(wxEVT_CLOSE_WINDOW, [this](wxCloseEvent& event)
+				{
+					if (event.CanVeto()) {
+						m_usb_devices->Show(false);
+						event.Veto();
+					}
+				});
+			m_usb_devices->Show(true);
+		}
+		break;
 	}
 	break;
 	}
@@ -1444,7 +1550,8 @@ void MainWindow::OnGesturePan(wxPanGestureEvent& event)
 {
 	auto& instance = InputManager::instance();
 	std::scoped_lock lock(instance.m_main_touch.m_mutex);
-	instance.m_main_touch.position = { event.GetPosition().x, event.GetPosition().y };
+	auto physPos = ToPhys(event.GetPosition());
+	instance.m_main_touch.position = { physPos.x, physPos.y };
 	instance.m_main_touch.left_down = event.IsGestureStart() || !event.IsGestureEnd();
 	if (event.IsGestureStart() || !event.IsGestureEnd())
 		instance.m_main_touch.left_down_toggle = true;
@@ -1468,7 +1575,19 @@ void MainWindow::AsyncSetTitle(std::string_view windowTitle)
 
 void MainWindow::CreateCanvas()
 {
-	if (ActiveSettings::GetGraphicsAPI() == kVulkan)
+    // create panel for canvas
+    m_game_panel = new wxPanel(this, wxID_ANY, wxDefaultPosition, wxDefaultSize, wxTAB_TRAVERSAL | wxNO_BORDER | wxWANTS_CHARS);
+    auto* sizer = new wxBoxSizer(wxVERTICAL);
+
+    // shouldn't be needed, but who knows
+    m_game_panel->Bind(wxEVT_KEY_UP, &MainWindow::OnKeyUp, this);
+    m_game_panel->Bind(wxEVT_CHAR, &MainWindow::OnChar, this);
+
+    m_game_panel->SetSizer(sizer);
+    this->GetSizer()->Add(m_game_panel, 1, wxEXPAND, 0, nullptr);
+
+    // create canvas
+    if (ActiveSettings::GetGraphicsAPI() == kVulkan)
 		m_render_canvas = new VulkanCanvas(m_game_panel, wxSize(1280, 720), true);
 	else
 		m_render_canvas = GLCanvas_Create(m_game_panel, wxSize(1280, 720), true);
@@ -1485,6 +1604,7 @@ void MainWindow::CreateCanvas()
 
 	// key events
 	m_render_canvas->Bind(wxEVT_KEY_UP, &MainWindow::OnKeyUp, this);
+	m_render_canvas->Bind(wxEVT_KEY_DOWN, &MainWindow::OnKeyDown, this);
 	m_render_canvas->Bind(wxEVT_CHAR, &MainWindow::OnChar, this);
 
 	m_render_canvas->SetDropTarget(new wxAmiiboDropTarget(this));
@@ -1501,87 +1621,18 @@ void MainWindow::DestroyCanvas()
 {
 	if (m_padView)
 	{
-		m_padView->Destroy();
-		m_padView = nullptr;
+		m_padView->DestroyCanvas();
 	}
 	if (m_render_canvas)
 	{
 		m_render_canvas->Destroy();
 		m_render_canvas = nullptr;
 	}
-}
-
-
-std::wstring MainWindow::GetGameName(std::wstring_view file_name)
-{
-	fs::path path{ std::wstring{file_name} };
-	const auto extension = path.extension();
-	if (extension == ".wud" || extension == ".wux")
-	{
-		std::unique_ptr<FSTVolume> volume(FSTVolume::OpenFromDiscImage(path));
-		if (!volume)
-			return path.filename().generic_wstring();
-
-		bool foundFile = false;
-		std::vector<uint8> metaContent = volume->ExtractFile("meta/meta.xml", &foundFile);
-		if (!foundFile)
-			return path.filename().generic_wstring();
-
-		namespace xml = tinyxml2;
-		xml::XMLDocument doc;
-		doc.Parse((const char*)metaContent.data(), metaContent.size());
-
-		// parse meta.xml
-		xml::XMLElement* root = doc.FirstChildElement("menu");
-		if (root)
-		{
-			xml::XMLElement* element = root->FirstChildElement("longname_en");
-			if (element)
-			{
-
-				auto game_name = boost::nowide::widen(element->GetText());
-				const auto it = game_name.find(L'\n');
-				if (it != std::wstring::npos)
-					game_name.replace(it, 1, L" - ");
-
-				return game_name;
-			}
-		}
-		return path.filename().generic_wstring();
-	}
-	else if (extension == ".rpx")
-	{
-		if (path.has_parent_path() && path.parent_path().has_parent_path())
-		{
-			auto meta_xml = path.parent_path().parent_path() / "meta/meta.xml";
-			auto metaXmlData = FileStream::LoadIntoMemory(meta_xml);
-			if (metaXmlData)
-			{
-				namespace xml = tinyxml2;
-				xml::XMLDocument doc;
-				if (doc.Parse((const char*)metaXmlData->data(), metaXmlData->size()) == xml::XML_SUCCESS)
-				{
-					xml::XMLElement* root = doc.FirstChildElement("menu");
-					if (root)
-					{
-						xml::XMLElement* element = root->FirstChildElement("longname_en");
-						if (element)
-						{
-
-							auto game_name = boost::nowide::widen(element->GetText());
-							const auto it = game_name.find(L'\n');
-							if (it != std::wstring::npos)
-								game_name.replace(it, 1, L" - ");
-
-							return game_name;
-						}
-					}
-				}
-			}
-		}
-	}
-
-	return path.filename().generic_wstring();
+    if(m_game_panel)
+    {
+        m_game_panel->Destroy();
+        m_game_panel = nullptr;
+    }
 }
 
 void MainWindow::OnSizeEvent(wxSizeEvent& event)
@@ -1592,6 +1643,9 @@ void MainWindow::OnSizeEvent(wxSizeEvent& event)
 	const wxSize client_size = GetClientSize();
 	g_window_info.width = client_size.GetWidth();
 	g_window_info.height = client_size.GetHeight();
+	g_window_info.phys_width = ToPhys(client_size.GetWidth());
+	g_window_info.phys_height = ToPhys(client_size.GetHeight());
+	g_window_info.dpi_scale = GetDPIScaleFactor();
 
 	if (m_debugger_window && m_debugger_window->IsShown())
 		m_debugger_window->OnParentMove(GetPosition(), event.GetSize());
@@ -1601,6 +1655,17 @@ void MainWindow::OnSizeEvent(wxSizeEvent& event)
 	VsyncDriver_notifyWindowPosChanged();
 }
 
+void MainWindow::OnDPIChangedEvent(wxDPIChangedEvent& event)
+{
+	event.Skip();
+	const wxSize client_size = GetClientSize();
+	g_window_info.width = client_size.GetWidth();
+	g_window_info.height = client_size.GetHeight();
+	g_window_info.phys_width = ToPhys(client_size.GetWidth());
+	g_window_info.phys_height = ToPhys(client_size.GetHeight());
+	g_window_info.dpi_scale = GetDPIScaleFactor();
+}
+
 void MainWindow::OnMove(wxMoveEvent& event)
 {
 	if (!IsMaximized() && !gui_isFullScreen())
@@ -1706,13 +1771,13 @@ void MainWindow::UpdateNFCMenu()
 		if (entry.empty())
 			continue;
 		
-		if (!fs::exists(entry))
+		if (!fs::exists(_utf8ToPath(entry)))
 			continue;
 		
 		if (recentFileIndex == 0)
 			m_nfcMenuSeparator0 = m_nfcMenu->AppendSeparator();
 
-		m_nfcMenu->Append(MAINFRAME_MENU_ID_NFC_RECENT_0 + i, fmt::format(L"{}. {}", recentFileIndex, entry ));
+		m_nfcMenu->Append(MAINFRAME_MENU_ID_NFC_RECENT_0 + i, to_wxString(fmt::format("{}. {}", recentFileIndex, entry)));
 
 		recentFileIndex++;
 		if (recentFileIndex >= 12)
@@ -1736,7 +1801,6 @@ void MainWindow::OnTimer(wxTimerEvent& event)
 			{
 				CemuUpdateWindow update_window(this);
 				update_window.ShowModal();
-				update_window.Destroy();
 			}
 		}
 
@@ -1763,8 +1827,6 @@ void MainWindow::OnTimer(wxTimerEvent& event)
 		
 }
 
-void MainWindow::OnHelpVistWebpage(wxCommandEvent& event) {}
-
 #define BUILD_DATE __DATE__ " " __TIME__
 
 class CemuAboutDialog : public wxDialog
@@ -1780,8 +1842,6 @@ public:
 	{
 		SetIcon(wxICON(M_WND_ICON128));
 
-		this->SetBackgroundColour(wxColour(0xFFFFFFFF));
-
 		wxScrolledWindow* scrolledWindow = new wxScrolledWindow(this);
 
 		wxBoxSizer* mainSizer = new wxBoxSizer(wxVERTICAL);
@@ -1805,10 +1865,10 @@ public:
 
 	void AddHeaderInfo(wxWindow* parent, wxSizer* sizer)
 	{
-		auto versionString = fmt::format(fmt::runtime(_("Cemu\nVersion {0}\nCompiled on {1}\nOriginal authors: {2}").ToStdString()), BUILD_VERSION_STRING, BUILD_DATE, "Exzap, Petergov");
+		auto versionString = formatWxString(_("Cemu\nVersion {0}\nCompiled on {1}\nOriginal authors: {2}"), BUILD_VERSION_STRING, BUILD_DATE, "Exzap, Petergov");
 
 		sizer->Add(new wxStaticText(parent, wxID_ANY, versionString), wxSizerFlags().Border(wxALL, 3).Border(wxTOP, 10));
-		sizer->Add(new wxHyperlinkCtrl(parent, -1, "https://cemu.info", "https://cemu.info"), wxSizerFlags().Expand().Border(wxTOP | wxBOTTOM, 3));
+		sizer->Add(new wxHyperlinkCtrl(parent, wxID_ANY, "https://cemu.info", "https://cemu.info"), wxSizerFlags().Expand().Border(wxTOP | wxBOTTOM, 3));
 
 		sizer->AddSpacer(3);
 		sizer->Add(new wxStaticLine(parent), wxSizerFlags().Expand().Border(wxRIGHT, 4));
@@ -1828,95 +1888,105 @@ public:
 		// zLib
 		{
 			wxSizer* lineSizer = new wxBoxSizer(wxHORIZONTAL);
-			lineSizer->Add(new wxStaticText(parent, -1, "zLib ("), 0);
-			lineSizer->Add(new wxHyperlinkCtrl(parent, -1, "http://www.zlib.net", "http://www.zlib.net"), 0);
-			lineSizer->Add(new wxStaticText(parent, -1, ")"), 0);
+			lineSizer->Add(new wxStaticText(parent, wxID_ANY, "zLib ("), 0);
+			lineSizer->Add(new wxHyperlinkCtrl(parent, wxID_ANY, "https://www.zlib.net", "https://www.zlib.net"), 0);
+			lineSizer->Add(new wxStaticText(parent, wxID_ANY, ")"), 0);
 			sizer->Add(lineSizer);
 		}
 		// wxWidgets
 		{
 			wxSizer* lineSizer = new wxBoxSizer(wxHORIZONTAL);
-			lineSizer->Add(new wxStaticText(parent, -1, "wxWidgets ("), 0);
-			lineSizer->Add(new wxHyperlinkCtrl(parent, -1, "https://www.wxwidgets.org/", "https://www.wxwidgets.org/"), 0);
-			lineSizer->Add(new wxStaticText(parent, -1, ")"), 0);
+			lineSizer->Add(new wxStaticText(parent, wxID_ANY, "wxWidgets ("), 0);
+			lineSizer->Add(new wxHyperlinkCtrl(parent, wxID_ANY, "https://www.wxwidgets.org/", "https://www.wxwidgets.org/"), 0);
+			lineSizer->Add(new wxStaticText(parent, wxID_ANY, ")"), 0);
 			sizer->Add(lineSizer);
 		}
 		// OpenSSL
 		{
 			wxSizer* lineSizer = new wxBoxSizer(wxHORIZONTAL);
-			lineSizer->Add(new wxStaticText(parent, -1, "OpenSSL ("), 0);
-			lineSizer->Add(new wxHyperlinkCtrl(parent, -1, "https://www.openssl.org/", "https://www.openssl.org/"), 0);
-			lineSizer->Add(new wxStaticText(parent, -1, ")"), 0);
+			lineSizer->Add(new wxStaticText(parent, wxID_ANY, "OpenSSL ("), 0);
+			lineSizer->Add(new wxHyperlinkCtrl(parent, wxID_ANY, "https://www.openssl.org/", "https://www.openssl.org/"), 0);
+			lineSizer->Add(new wxStaticText(parent, wxID_ANY, ")"), 0);
 			sizer->Add(lineSizer);
 		}
 		// libcurl
 		{
 			wxSizer* lineSizer = new wxBoxSizer(wxHORIZONTAL);
-			lineSizer->Add(new wxStaticText(parent, -1, "libcurl ("), 0);
-			lineSizer->Add(new wxHyperlinkCtrl(parent, -1, "https://curl.haxx.se/libcurl/", "https://curl.haxx.se/libcurl/"), 0);
-			lineSizer->Add(new wxStaticText(parent, -1, ")"), 0);
+			lineSizer->Add(new wxStaticText(parent, wxID_ANY, "libcurl ("), 0);
+			lineSizer->Add(new wxHyperlinkCtrl(parent, wxID_ANY, "https://curl.haxx.se/libcurl/", "https://curl.haxx.se/libcurl/"), 0);
+			lineSizer->Add(new wxStaticText(parent, wxID_ANY, ")"), 0);
 			sizer->Add(lineSizer);
 		}
 		// imgui
 		{
 			wxSizer* lineSizer = new wxBoxSizer(wxHORIZONTAL);
-			lineSizer->Add(new wxStaticText(parent, -1, "imgui ("), 0);
-			lineSizer->Add(new wxHyperlinkCtrl(parent, -1, "https://github.com/ocornut/imgui", "https://github.com/ocornut/imgui"), 0);
-			lineSizer->Add(new wxStaticText(parent, -1, ")"), 0);
+			lineSizer->Add(new wxStaticText(parent, wxID_ANY, "imgui ("), 0);
+			lineSizer->Add(new wxHyperlinkCtrl(parent, wxID_ANY, "https://github.com/ocornut/imgui", "https://github.com/ocornut/imgui"), 0);
+			lineSizer->Add(new wxStaticText(parent, wxID_ANY, ")"), 0);
 			sizer->Add(lineSizer);
 		}
 		// fontawesome
 		{
 			wxSizer* lineSizer = new wxBoxSizer(wxHORIZONTAL);
-			lineSizer->Add(new wxStaticText(parent, -1, "fontawesome ("), 0);
-			lineSizer->Add(new wxHyperlinkCtrl(parent, -1, "https://github.com/FortAwesome/Font-Awesome", "https://github.com/FortAwesome/Font-Awesome"), 0);
-			lineSizer->Add(new wxStaticText(parent, -1, ")"), 0);
+			lineSizer->Add(new wxStaticText(parent, wxID_ANY, "fontawesome ("), 0);
+			lineSizer->Add(new wxHyperlinkCtrl(parent, wxID_ANY, "https://github.com/FortAwesome/Font-Awesome", "https://github.com/FortAwesome/Font-Awesome"), 0);
+			lineSizer->Add(new wxStaticText(parent, wxID_ANY, ")"), 0);
 			sizer->Add(lineSizer);
 		}
 		// boost
 		{
 			wxSizer* lineSizer = new wxBoxSizer(wxHORIZONTAL);
-			lineSizer->Add(new wxStaticText(parent, -1, "boost ("), 0);
-			lineSizer->Add(new wxHyperlinkCtrl(parent, -1, "https://www.boost.org", "https://www.boost.org"), 0);
-			lineSizer->Add(new wxStaticText(parent, -1, ")"), 0);
+			lineSizer->Add(new wxStaticText(parent, wxID_ANY, "boost ("), 0);
+			lineSizer->Add(new wxHyperlinkCtrl(parent, wxID_ANY, "https://www.boost.org", "https://www.boost.org"), 0);
+			lineSizer->Add(new wxStaticText(parent, wxID_ANY, ")"), 0);
 			sizer->Add(lineSizer);
 		}
 		// libusb
 		{
 			wxSizer* lineSizer = new wxBoxSizer(wxHORIZONTAL);
-			lineSizer->Add(new wxStaticText(parent, -1, "libusb ("), 0);
-			lineSizer->Add(new wxHyperlinkCtrl(parent, -1, "https://libusb.info", "https://libusb.info"), 0);
+			lineSizer->Add(new wxStaticText(parent, wxID_ANY, "libusb ("), 0);
+			lineSizer->Add(new wxHyperlinkCtrl(parent, wxID_ANY, "https://libusb.info", "https://libusb.info"), 0);
+			lineSizer->Add(new wxStaticText(parent, wxID_ANY, ")"), 0);
+			sizer->Add(lineSizer);
+		}
+#if BOOST_OS_MACOS
+		// MoltenVK
+		{
+			wxSizer* lineSizer = new wxBoxSizer(wxHORIZONTAL);
+			lineSizer->Add(new wxStaticText(parent, -1, "MoltenVK ("), 0);
+			lineSizer->Add(new wxHyperlinkCtrl(parent, -1, "https://github.com/KhronosGroup/MoltenVK", "https://github.com/KhronosGroup/MoltenVK"), 0);
 			lineSizer->Add(new wxStaticText(parent, -1, ")"), 0);
 			sizer->Add(lineSizer);
 		}
+#endif
 		// icons
 		{
 			wxSizer* lineSizer = new wxBoxSizer(wxHORIZONTAL);
-			lineSizer->Add(new wxStaticText(parent, -1, "icons from "), 0);
-			lineSizer->Add(new wxHyperlinkCtrl(parent, -1, "https://icons8.com", "https://icons8.com"), 0);
+			lineSizer->Add(new wxStaticText(parent, wxID_ANY, "icons from "), 0);
+			lineSizer->Add(new wxHyperlinkCtrl(parent, wxID_ANY, "https://icons8.com", "https://icons8.com"), 0);
 			sizer->Add(lineSizer);
 		}
 		// Lato font (are we still using it?)
 		{
 			wxSizer* lineSizer = new wxBoxSizer(wxHORIZONTAL);
-			lineSizer->Add(new wxStaticText(parent, -1, "\"Lato\" font by tyPoland Lukasz Dziedzic (OFL, V1.1)"), 0);
+			lineSizer->Add(new wxStaticText(parent, wxID_ANY, "\"Lato\" font by tyPoland Lukasz Dziedzic (OFL, V1.1)"), 0);
 			sizer->Add(lineSizer);
 		}
 		// SDL
 		{
 			wxSizer* lineSizer = new wxBoxSizer(wxHORIZONTAL);
-			lineSizer->Add(new wxStaticText(parent, -1, "SDL ("), 0);
-			lineSizer->Add(new wxHyperlinkCtrl(parent, -1, "https://github.com/libsdl-org/SDL", "https://github.com/libsdl-org/SDL"), 0);
-			lineSizer->Add(new wxStaticText(parent, -1, ")"), 0);
+			lineSizer->Add(new wxStaticText(parent, wxID_ANY, "SDL ("), 0);
+			lineSizer->Add(new wxHyperlinkCtrl(parent, wxID_ANY, "https://github.com/libsdl-org/SDL", "https://github.com/libsdl-org/SDL"), 0);
+			lineSizer->Add(new wxStaticText(parent, wxID_ANY, ")"), 0);
 			sizer->Add(lineSizer);
 		}
 		// IH264
 		{
 			wxSizer* lineSizer = new wxBoxSizer(wxHORIZONTAL);
-			lineSizer->Add(new wxStaticText(parent, -1, "Modified ih264 from Android project ("), 0);
-			lineSizer->Add(new wxHyperlinkCtrl(parent, -1, "Source", "https://cemu.info/oss/ih264d.zip"), 0);
-			lineSizer->Add(new wxStaticText(parent, -1, "  "), 0);
-			wxHyperlinkCtrl* noticeLink = new wxHyperlinkCtrl(parent, -1, "NOTICE", "");
+			lineSizer->Add(new wxStaticText(parent, wxID_ANY, "Modified ih264 from Android project ("), 0);
+			lineSizer->Add(new wxHyperlinkCtrl(parent, wxID_ANY, "Source", "https://cemu.info/oss/ih264d.zip"), 0);
+			lineSizer->Add(new wxStaticText(parent, wxID_ANY, "  "), 0);
+			wxHyperlinkCtrl* noticeLink = new wxHyperlinkCtrl(parent, wxID_ANY, "NOTICE", "");
 			noticeLink->Bind(wxEVT_LEFT_DOWN, [](wxMouseEvent& event)
 				{
 					fs::path tempPath = fs::temp_directory_path();
@@ -1950,7 +2020,7 @@ public:
 					wxLaunchDefaultBrowser(wxHelper::FromUtf8(fmt::format("file:{}", _pathToUtf8(tempPath))));
 				});
 			lineSizer->Add(noticeLink, 0);
-			lineSizer->Add(new wxStaticText(parent, -1, ")"), 0);
+			lineSizer->Add(new wxStaticText(parent, wxID_ANY, ")"), 0);
 			sizer->Add(lineSizer);
 		}
 	}
@@ -1975,7 +2045,7 @@ public:
 			, "Faris Leonhart", "MahvZero", "PlaguedGuardian", "Stuffie", "CaptainLester", "Qtech", "Zaurexus", "Leonidas", "Artifesto"
 			, "Alca259", "SirWestofAsh", "Loli Co.", "The Technical Revolutionary", "MegaYama", "mitori", "Seymordius", "Adrian Josh Cruz", "Manuel Hoenings", "Just A Jabb"
 			, "pgantonio", "CannonXIII", "Lonewolf00708", "AlexsDesign.com", "NoskLo", "MrSirHaku", "xElite_V AKA William H. Johnson", "Zalnor", "Pig", "James \"SE4LS\"", "DairyOrange", "Horoko Lawrence", "bloodmc", "Officer Jenny", "Quasar", "Postposterous", "Jake Jackson", "Kaydax", "CthePredatorG"
-			, "Hengi", "Pyrochaser"};
+			, "Hengi", "Pyrochaser", "luma.x3"};
 
 		wxString nameListLeft, nameListRight;
 		for (size_t i = 0; i < patreonSupporterNames.size(); i++)
@@ -1984,7 +2054,7 @@ public:
 			wxString& nameList = ((i % 2) == 0) ? nameListLeft : nameListRight;
 			if (i >= 2)
 				nameList.append("\n");
-			nameList.append(name);
+			nameList.append(wxString::FromUTF8(name));
 		}
 
 		gridSizer->Add(new wxStaticText(parent, wxID_ANY, nameListLeft), wxSizerFlags());
@@ -2013,12 +2083,6 @@ void MainWindow::OnHelpUpdate(wxCommandEvent& event)
 {
 	CemuUpdateWindow test(this);
 	test.ShowModal();
-	test.Destroy();
-}
-
-void MainWindow::OnHelpGettingStarted(wxCommandEvent& event)
-{
-	ShowGettingStartedDialog();
 }
 
 void MainWindow::RecreateMenu()
@@ -2032,9 +2096,9 @@ void MainWindow::RecreateMenu()
 	
 	auto& config = GetConfig();
 	
-	m_menuBar = new wxMenuBar;
+	m_menuBar = new wxMenuBar();
 	// file submenu
-	m_fileMenu = new wxMenu;
+	m_fileMenu = new wxMenu();
 
 	if (!m_game_launched)
 	{
@@ -2046,37 +2110,36 @@ void MainWindow::RecreateMenu()
 		m_fileMenuSeparator1 = nullptr;
 		for (size_t i = 0; i < config.recent_launch_files.size(); i++)
 		{
-			const auto& entry = config.recent_launch_files[i];
-			if (entry.empty())
+			const std::string& pathStr = config.recent_launch_files[i];
+			if (pathStr.empty())
 				continue;
-
-			if (!fs::exists(entry))
-				continue;
-
 			if (recentFileIndex == 0)
 				m_fileMenuSeparator0 = m_fileMenu->AppendSeparator();
-
-			m_fileMenu->Append(MAINFRAME_MENU_ID_FILE_RECENT_0 + i, fmt::format(L"{}. {}", recentFileIndex, entry));
+			m_fileMenu->Append(MAINFRAME_MENU_ID_FILE_RECENT_0 + i, to_wxString(fmt::format("{}. {}", recentFileIndex, pathStr)));
 			recentFileIndex++;
 
 			if (recentFileIndex >= 8)
 				break;
 		}
 		m_fileMenuSeparator1 = m_fileMenu->AppendSeparator();
-
 	}
 	else
 	{
 		// add 'Stop emulation' menu entry to file menu
-#ifndef PUBLIC_RELEASE
-		m_fileMenu->Append(MAINFRAME_MENU_ID_FILE_END_EMULATION, _("End emulation"));
+#ifdef CEMU_DEBUG_ASSERT
+		m_fileMenu->Append(MAINFRAME_MENU_ID_FILE_END_EMULATION, _("Stop emulation"));
 #endif
 	}
 
+	m_fileMenu->Append(MAINFRAME_MENU_ID_FILE_OPEN_CEMU_FOLDER, _("&Open Cemu folder"));
+	m_fileMenu->Append(MAINFRAME_MENU_ID_FILE_OPEN_MLC_FOLDER, _("&Open MLC folder"));
+	m_fileMenu->Append(MAINFRAME_MENU_ID_FILE_OPEN_SHADERCACHE_FOLDER, _("Open &shader cache folder"));
+	m_fileMenu->AppendSeparator();
+
 	m_exitMenuItem = m_fileMenu->Append(MAINFRAME_MENU_ID_FILE_EXIT, _("&Exit"));
 	m_menuBar->Append(m_fileMenu, _("&File"));
 	// options->account submenu
-	m_optionsAccountMenu = new wxMenu;
+	m_optionsAccountMenu = new wxMenu();
 	const auto account_id = ActiveSettings::GetPersistentId();
 	int index = 0;
 	for(const auto& account : Account::GetAccounts())
@@ -2088,23 +2151,9 @@ void MainWindow::RecreateMenu()
 		
 		++index;
 	}
-	//optionsAccountMenu->AppendSeparator(); TODO
-	//optionsAccountMenu->AppendCheckItem(MAINFRAME_MENU_ID_OPTIONS_ACCOUNT_1 + index, _("Online enabled"))->Check(config.account.online_enabled);
-	
-	// options->region submenu
-	//wxMenu* optionsRegionMenu = new wxMenu;
-	//optionsRegionMenu->AppendRadioItem(MAINFRAME_MENU_ID_OPTIONS_REGION_AUTO, _("&Auto"), wxEmptyString)->Check(config.console_region == ConsoleRegion::Auto);
-	////optionsRegionMenu->AppendSeparator();
-	//optionsRegionMenu->AppendRadioItem(MAINFRAME_MENU_ID_OPTIONS_REGION_USA, _("&USA"), wxEmptyString)->Check(config.console_region == ConsoleRegion::USA);
-	//optionsRegionMenu->AppendRadioItem(MAINFRAME_MENU_ID_OPTIONS_REGION_EUR, _("&Europe"), wxEmptyString)->Check(config.console_region == ConsoleRegion::EUR);
-	//optionsRegionMenu->AppendRadioItem(MAINFRAME_MENU_ID_OPTIONS_REGION_JPN, _("&Japan"), wxEmptyString)->Check(config.console_region == ConsoleRegion::JPN);
-	//// optionsRegionMenu->Append(MAINFRAME_MENU_ID_OPTIONS_REGION_AUS, wxT("&Australia"), wxEmptyString, wxITEM_RADIO)->Check(config_get()->region==3); -> Was merged into Europe?
-	//optionsRegionMenu->AppendRadioItem(MAINFRAME_MENU_ID_OPTIONS_REGION_CHN, _("&China"), wxEmptyString)->Check(config.console_region == ConsoleRegion::CHN);
-	//optionsRegionMenu->AppendRadioItem(MAINFRAME_MENU_ID_OPTIONS_REGION_KOR, _("&Korea"), wxEmptyString)->Check(config.console_region == ConsoleRegion::KOR);
-	//optionsRegionMenu->AppendRadioItem(MAINFRAME_MENU_ID_OPTIONS_REGION_TWN, _("&Taiwan"), wxEmptyString)->Check(config.console_region == ConsoleRegion::TWN);
 
 	// options->console language submenu
-	wxMenu* optionsConsoleLanguageMenu = new wxMenu;
+	wxMenu* optionsConsoleLanguageMenu = new wxMenu();
 	optionsConsoleLanguageMenu->AppendRadioItem(MAINFRAME_MENU_ID_OPTIONS_LANGUAGE_ENGLISH, _("&English"), wxEmptyString)->Check(config.console_language == CafeConsoleLanguage::EN);
 	optionsConsoleLanguageMenu->AppendRadioItem(MAINFRAME_MENU_ID_OPTIONS_LANGUAGE_JAPANESE, _("&Japanese"), wxEmptyString)->Check(config.console_language == CafeConsoleLanguage::JA);
 	optionsConsoleLanguageMenu->AppendRadioItem(MAINFRAME_MENU_ID_OPTIONS_LANGUAGE_FRENCH, _("&French"), wxEmptyString)->Check(config.console_language == CafeConsoleLanguage::FR);
@@ -2117,36 +2166,47 @@ void MainWindow::RecreateMenu()
 	optionsConsoleLanguageMenu->AppendRadioItem(MAINFRAME_MENU_ID_OPTIONS_LANGUAGE_PORTUGUESE, _("&Portuguese"), wxEmptyString)->Check(config.console_language == CafeConsoleLanguage::PT);
 	optionsConsoleLanguageMenu->AppendRadioItem(MAINFRAME_MENU_ID_OPTIONS_LANGUAGE_RUSSIAN, _("&Russian"), wxEmptyString)->Check(config.console_language == CafeConsoleLanguage::RU);
 	optionsConsoleLanguageMenu->AppendRadioItem(MAINFRAME_MENU_ID_OPTIONS_LANGUAGE_TAIWANESE, _("&Taiwanese"), wxEmptyString)->Check(config.console_language == CafeConsoleLanguage::TW);
+	if(IsGameLaunched())
+	{
+		auto items = optionsConsoleLanguageMenu->GetMenuItems();
+		for (auto& item : items)
+		{
+			item->Enable(false);
+		}
+	}
 
 	// options submenu
-	wxMenu* optionsMenu = new wxMenu;
+	wxMenu* optionsMenu = new wxMenu();
 	m_fullscreenMenuItem = optionsMenu->AppendCheckItem(MAINFRAME_MENU_ID_OPTIONS_FULLSCREEN, _("&Fullscreen"), wxEmptyString);
 	m_fullscreenMenuItem->Check(ActiveSettings::FullscreenEnabled());		
 	
 	optionsMenu->Append(MAINFRAME_MENU_ID_OPTIONS_GRAPHIC_PACKS2, _("&Graphic packs"));
-	//optionsMenu->AppendSubMenu(optionsVCAMenu, _("&GPU buffer cache accuracy"));
 	m_padViewMenuItem = optionsMenu->AppendCheckItem(MAINFRAME_MENU_ID_OPTIONS_SECOND_WINDOW_PADVIEW, _("&Separate GamePad view"), wxEmptyString);
 	m_padViewMenuItem->Check(GetConfig().pad_open);
 	optionsMenu->AppendSeparator();
+	#if BOOST_OS_MACOS
+	optionsMenu->Append(MAINFRAME_MENU_ID_OPTIONS_MAC_SETTINGS, _("&Settings..." "\tCtrl-,"));
+	#endif
 	optionsMenu->Append(MAINFRAME_MENU_ID_OPTIONS_GENERAL2, _("&General settings"));
 	optionsMenu->Append(MAINFRAME_MENU_ID_OPTIONS_INPUT, _("&Input settings"));
 
 	optionsMenu->AppendSeparator();
 	optionsMenu->AppendSubMenu(m_optionsAccountMenu, _("&Active account"));
-	//optionsMenu->AppendSubMenu(optionsRegionMenu, _("&Console region"));
 	optionsMenu->AppendSubMenu(optionsConsoleLanguageMenu, _("&Console language"));
 	m_menuBar->Append(optionsMenu, _("&Options"));
 
 	// tools submenu
-	wxMenu* toolsMenu = new wxMenu;
+	wxMenu* toolsMenu = new wxMenu();
 	m_memorySearcherMenuItem = toolsMenu->Append(MAINFRAME_MENU_ID_TOOLS_MEMORY_SEARCHER, _("&Memory searcher"));
 	m_memorySearcherMenuItem->Enable(false);
 	toolsMenu->Append(MAINFRAME_MENU_ID_TOOLS_TITLE_MANAGER, _("&Title Manager"));
 	toolsMenu->Append(MAINFRAME_MENU_ID_TOOLS_DOWNLOAD_MANAGER, _("&Download Manager"));
+	toolsMenu->Append(MAINFRAME_MENU_ID_TOOLS_EMULATED_USB_DEVICES, _("&Emulated USB Devices"));
+
 	m_menuBar->Append(toolsMenu, _("&Tools"));
 
 	// cpu timer speed menu
-	wxMenu* timerSpeedMenu = new wxMenu;
+	wxMenu* timerSpeedMenu = new wxMenu();
 	timerSpeedMenu->AppendRadioItem(MAINFRAME_MENU_ID_TIMER_SPEED_1X, _("&1x speed"), wxEmptyString)->Check(ActiveSettings::GetTimerShiftFactor() == 3);
 	timerSpeedMenu->AppendRadioItem(MAINFRAME_MENU_ID_TIMER_SPEED_2X, _("&2x speed"), wxEmptyString)->Check(ActiveSettings::GetTimerShiftFactor() == 2);
 	timerSpeedMenu->AppendRadioItem(MAINFRAME_MENU_ID_TIMER_SPEED_4X, _("&4x speed"), wxEmptyString)->Check(ActiveSettings::GetTimerShiftFactor() == 1);
@@ -2156,50 +2216,63 @@ void MainWindow::RecreateMenu()
 	timerSpeedMenu->AppendRadioItem(MAINFRAME_MENU_ID_TIMER_SPEED_0125X, _("&0.125x speed"), wxEmptyString)->Check(ActiveSettings::GetTimerShiftFactor() == 6);
 
 	// cpu submenu
-	wxMenu* cpuMenu = new wxMenu;
+	wxMenu* cpuMenu = new wxMenu();
 	cpuMenu->AppendSubMenu(timerSpeedMenu, _("&Timer speed"));
 	m_menuBar->Append(cpuMenu, _("&CPU"));
 
 	// nfc submenu
-	wxMenu* nfcMenu = new wxMenu;
+	wxMenu* nfcMenu = new wxMenu();
 	m_nfcMenu = nfcMenu;
 	nfcMenu->Append(MAINFRAME_MENU_ID_NFC_TOUCH_NFC_FILE, _("&Scan NFC tag from file"))->Enable(false);
 	m_menuBar->Append(nfcMenu, _("&NFC"));
 	m_nfcMenuSeparator0 = nullptr;
 	// debug->logging submenu
-	wxMenu* debugLoggingMenu = new wxMenu;
+	wxMenu* debugLoggingMenu = new wxMenu();
 
-	debugLoggingMenu->AppendCheckItem(MAINFRAME_MENU_ID_DEBUG_LOGGING0 + LOG_TYPE_UNSUPPORTED_API, _("&Unsupported API calls"), wxEmptyString)->Check(cafeLog_isLoggingFlagEnabled(LOG_TYPE_UNSUPPORTED_API));
-	debugLoggingMenu->AppendCheckItem(MAINFRAME_MENU_ID_DEBUG_LOGGING0 + LOG_TYPE_COREINIT_LOGGING, _("&Coreinit Logging (OSReport/OSConsole)"), wxEmptyString)->Check(cafeLog_isLoggingFlagEnabled(LOG_TYPE_COREINIT_LOGGING));
-	debugLoggingMenu->AppendCheckItem(MAINFRAME_MENU_ID_DEBUG_LOGGING0 + LOG_TYPE_FILE, _("&Coreinit File-Access"), wxEmptyString)->Check(cafeLog_isLoggingFlagEnabled(LOG_TYPE_FILE));
-	debugLoggingMenu->AppendCheckItem(MAINFRAME_MENU_ID_DEBUG_LOGGING0 + LOG_TYPE_THREADSYNC, _("&Coreinit Thread-Synchronization API"), wxEmptyString)->Check(cafeLog_isLoggingFlagEnabled(LOG_TYPE_THREADSYNC));
-	debugLoggingMenu->AppendCheckItem(MAINFRAME_MENU_ID_DEBUG_LOGGING0 + LOG_TYPE_COREINIT_MEM, _("&Coreinit Memory API"), wxEmptyString)->Check(cafeLog_isLoggingFlagEnabled(LOG_TYPE_COREINIT_MEM));
-	debugLoggingMenu->AppendCheckItem(MAINFRAME_MENU_ID_DEBUG_LOGGING0 + LOG_TYPE_COREINIT_MP, _("&Coreinit MP API"), wxEmptyString)->Check(cafeLog_isLoggingFlagEnabled(LOG_TYPE_COREINIT_MP));
-	debugLoggingMenu->AppendCheckItem(MAINFRAME_MENU_ID_DEBUG_LOGGING0 + LOG_TYPE_COREINIT_THREAD, _("&Coreinit Thread API"), wxEmptyString)->Check(cafeLog_isLoggingFlagEnabled(LOG_TYPE_COREINIT_THREAD));
-	debugLoggingMenu->AppendCheckItem(MAINFRAME_MENU_ID_DEBUG_LOGGING0 + LOG_TYPE_NFP, _("&NN NFP"), wxEmptyString)->Check(cafeLog_isLoggingFlagEnabled(LOG_TYPE_NFP));
-	debugLoggingMenu->AppendCheckItem(MAINFRAME_MENU_ID_DEBUG_LOGGING0 + LOG_TYPE_GX2, _("&GX2 API"), wxEmptyString)->Check(cafeLog_isLoggingFlagEnabled(LOG_TYPE_GX2));
-	debugLoggingMenu->AppendCheckItem(MAINFRAME_MENU_ID_DEBUG_LOGGING0 + LOG_TYPE_SNDAPI, _("&Audio API"), wxEmptyString)->Check(cafeLog_isLoggingFlagEnabled(LOG_TYPE_SNDAPI));
-	debugLoggingMenu->AppendCheckItem(MAINFRAME_MENU_ID_DEBUG_LOGGING0 + LOG_TYPE_INPUT, _("&Input API"), wxEmptyString)->Check(cafeLog_isLoggingFlagEnabled(LOG_TYPE_INPUT));
-	debugLoggingMenu->AppendCheckItem(MAINFRAME_MENU_ID_DEBUG_LOGGING0 + LOG_TYPE_SOCKET, _("&Socket API"), wxEmptyString)->Check(cafeLog_isLoggingFlagEnabled(LOG_TYPE_SOCKET));
-	debugLoggingMenu->AppendCheckItem(MAINFRAME_MENU_ID_DEBUG_LOGGING0 + LOG_TYPE_SAVE, _("&Save API"), wxEmptyString)->Check(cafeLog_isLoggingFlagEnabled(LOG_TYPE_SAVE));
-	debugLoggingMenu->AppendCheckItem(MAINFRAME_MENU_ID_DEBUG_LOGGING0 + LOG_TYPE_H264, _("&H264 API"), wxEmptyString)->Check(cafeLog_isLoggingFlagEnabled(LOG_TYPE_H264));
+	debugLoggingMenu->AppendCheckItem(MAINFRAME_MENU_ID_DEBUG_LOGGING0 + stdx::to_underlying(LogType::UnsupportedAPI), _("&Unsupported API calls"), wxEmptyString)->Check(cemuLog_isLoggingEnabled(LogType::UnsupportedAPI));
+	debugLoggingMenu->AppendCheckItem(MAINFRAME_MENU_ID_DEBUG_LOGGING0 + stdx::to_underlying(LogType::APIErrors), _("&Invalid API usage"), wxEmptyString)->Check(cemuLog_isLoggingEnabled(LogType::APIErrors));
+	debugLoggingMenu->AppendCheckItem(MAINFRAME_MENU_ID_DEBUG_LOGGING0 + stdx::to_underlying(LogType::CoreinitLogging), _("&Coreinit Logging (OSReport/OSConsole)"), wxEmptyString)->Check(cemuLog_isLoggingEnabled(LogType::CoreinitLogging));
 	debugLoggingMenu->AppendSeparator();
-	debugLoggingMenu->AppendCheckItem(MAINFRAME_MENU_ID_DEBUG_LOGGING0 + LOG_TYPE_PATCHES, _("&Graphic pack patches"), wxEmptyString)->Check(cafeLog_isLoggingFlagEnabled(LOG_TYPE_PATCHES));
-	debugLoggingMenu->AppendCheckItem(MAINFRAME_MENU_ID_DEBUG_LOGGING0 + LOG_TYPE_TEXTURE_CACHE, _("&Texture cache warnings"), wxEmptyString)->Check(cafeLog_isLoggingFlagEnabled(LOG_TYPE_TEXTURE_CACHE));
+
+	wxMenu* logCosModulesMenu = new wxMenu();
+	logCosModulesMenu->AppendCheckItem(MAINFRAME_MENU_ID_DEBUG_LOGGING_MESSAGE, _("&Options below are for experts. Leave off if unsure"), wxEmptyString)->Enable(false);
+	logCosModulesMenu->AppendSeparator();
+	logCosModulesMenu->AppendCheckItem(MAINFRAME_MENU_ID_DEBUG_LOGGING0 + stdx::to_underlying(LogType::CoreinitFile), _("coreinit File-Access API"), wxEmptyString)->Check(cemuLog_isLoggingEnabled(LogType::CoreinitFile));
+	logCosModulesMenu->AppendCheckItem(MAINFRAME_MENU_ID_DEBUG_LOGGING0 + stdx::to_underlying(LogType::CoreinitThreadSync), _("coreinit Thread-Synchronization API"), wxEmptyString)->Check(cemuLog_isLoggingEnabled(LogType::CoreinitThreadSync));
+	logCosModulesMenu->AppendCheckItem(MAINFRAME_MENU_ID_DEBUG_LOGGING0 + stdx::to_underlying(LogType::CoreinitMem), _("coreinit Memory API"), wxEmptyString)->Check(cemuLog_isLoggingEnabled(LogType::CoreinitMem));
+	logCosModulesMenu->AppendCheckItem(MAINFRAME_MENU_ID_DEBUG_LOGGING0 + stdx::to_underlying(LogType::CoreinitMP), _("coreinit MP API"), wxEmptyString)->Check(cemuLog_isLoggingEnabled(LogType::CoreinitMP));
+	logCosModulesMenu->AppendCheckItem(MAINFRAME_MENU_ID_DEBUG_LOGGING0 + stdx::to_underlying(LogType::CoreinitThread), _("coreinit Thread API"), wxEmptyString)->Check(cemuLog_isLoggingEnabled(LogType::CoreinitThread));
+	logCosModulesMenu->AppendCheckItem(MAINFRAME_MENU_ID_DEBUG_LOGGING0 + stdx::to_underlying(LogType::Save), _("nn_save API"), wxEmptyString)->Check(cemuLog_isLoggingEnabled(LogType::Save));
+	logCosModulesMenu->AppendCheckItem(MAINFRAME_MENU_ID_DEBUG_LOGGING0 + stdx::to_underlying(LogType::NN_NFP), _("nn_nfp API"), wxEmptyString)->Check(cemuLog_isLoggingEnabled(LogType::NN_NFP));
+	logCosModulesMenu->AppendCheckItem(MAINFRAME_MENU_ID_DEBUG_LOGGING0 + stdx::to_underlying(LogType::NN_FP), _("nn_fp API"), wxEmptyString)->Check(cemuLog_isLoggingEnabled(LogType::NN_FP));
+	logCosModulesMenu->AppendCheckItem(MAINFRAME_MENU_ID_DEBUG_LOGGING0 + stdx::to_underlying(LogType::PRUDP), _("nn_fp PRUDP"), wxEmptyString)->Check(cemuLog_isLoggingEnabled(LogType::PRUDP));
+	logCosModulesMenu->AppendCheckItem(MAINFRAME_MENU_ID_DEBUG_LOGGING0 + stdx::to_underlying(LogType::NN_BOSS), _("nn_boss API"), wxEmptyString)->Check(cemuLog_isLoggingEnabled(LogType::NN_BOSS));
+	logCosModulesMenu->AppendCheckItem(MAINFRAME_MENU_ID_DEBUG_LOGGING0 + stdx::to_underlying(LogType::NFC), _("nfc API"), wxEmptyString)->Check(cemuLog_isLoggingEnabled(LogType::NFC));
+	logCosModulesMenu->AppendCheckItem(MAINFRAME_MENU_ID_DEBUG_LOGGING0 + stdx::to_underlying(LogType::NTAG), _("ntag API"), wxEmptyString)->Check(cemuLog_isLoggingEnabled(LogType::NTAG));
+	logCosModulesMenu->AppendCheckItem(MAINFRAME_MENU_ID_DEBUG_LOGGING0 + stdx::to_underlying(LogType::Socket), _("nsysnet API"), wxEmptyString)->Check(cemuLog_isLoggingEnabled(LogType::Socket));
+	logCosModulesMenu->AppendCheckItem(MAINFRAME_MENU_ID_DEBUG_LOGGING0 + stdx::to_underlying(LogType::H264), _("h264 API"), wxEmptyString)->Check(cemuLog_isLoggingEnabled(LogType::H264));
+	logCosModulesMenu->AppendCheckItem(MAINFRAME_MENU_ID_DEBUG_LOGGING0 + stdx::to_underlying(LogType::GX2), _("gx2 API"), wxEmptyString)->Check(cemuLog_isLoggingEnabled(LogType::GX2));
+	logCosModulesMenu->AppendCheckItem(MAINFRAME_MENU_ID_DEBUG_LOGGING0 + stdx::to_underlying(LogType::SoundAPI), _("Audio API"), wxEmptyString)->Check(cemuLog_isLoggingEnabled(LogType::SoundAPI));
+	logCosModulesMenu->AppendCheckItem(MAINFRAME_MENU_ID_DEBUG_LOGGING0 + stdx::to_underlying(LogType::InputAPI), _("Input API"), wxEmptyString)->Check(cemuLog_isLoggingEnabled(LogType::InputAPI));
+
+	debugLoggingMenu->AppendSubMenu(logCosModulesMenu, _("&CafeOS modules logging"));
 	debugLoggingMenu->AppendSeparator();
-	debugLoggingMenu->AppendCheckItem(MAINFRAME_MENU_ID_DEBUG_LOGGING0 + LOG_TYPE_OPENGL, _("&OpenGL debug output"), wxEmptyString)->Check(cafeLog_isLoggingFlagEnabled(LOG_TYPE_OPENGL));
-	debugLoggingMenu->AppendCheckItem(MAINFRAME_MENU_ID_DEBUG_LOGGING0 + LOG_TYPE_VULKAN_VALIDATION, _("&Vulkan validation layer (slow)"), wxEmptyString)->Check(cafeLog_isLoggingFlagEnabled(LOG_TYPE_VULKAN_VALIDATION));
-#ifndef PUBLIC_RELEASE
+	debugLoggingMenu->AppendCheckItem(MAINFRAME_MENU_ID_DEBUG_LOGGING0 + stdx::to_underlying(LogType::Patches), _("&Graphic pack patches"), wxEmptyString)->Check(cemuLog_isLoggingEnabled(LogType::Patches));
+	debugLoggingMenu->AppendCheckItem(MAINFRAME_MENU_ID_DEBUG_LOGGING0 + stdx::to_underlying(LogType::TextureCache), _("&Texture cache warnings"), wxEmptyString)->Check(cemuLog_isLoggingEnabled(LogType::TextureCache));
+	debugLoggingMenu->AppendCheckItem(MAINFRAME_MENU_ID_DEBUG_LOGGING0 + stdx::to_underlying(LogType::TextureReadback), _("&Texture readback"), wxEmptyString)->Check(cemuLog_isLoggingEnabled(LogType::TextureReadback));
+	debugLoggingMenu->AppendSeparator();
+	debugLoggingMenu->AppendCheckItem(MAINFRAME_MENU_ID_DEBUG_LOGGING0 + stdx::to_underlying(LogType::OpenGLLogging), _("&OpenGL debug output"), wxEmptyString)->Check(cemuLog_isLoggingEnabled(LogType::OpenGLLogging));
+	debugLoggingMenu->AppendCheckItem(MAINFRAME_MENU_ID_DEBUG_LOGGING0 + stdx::to_underlying(LogType::VulkanValidation), _("&Vulkan validation layer (slow)"), wxEmptyString)->Check(cemuLog_isLoggingEnabled(LogType::VulkanValidation));
 	debugLoggingMenu->AppendCheckItem(MAINFRAME_MENU_ID_DEBUG_ADVANCED_PPC_INFO, _("&Log PPC context for API"), wxEmptyString)->Check(cemuLog_advancedPPCLoggingEnabled());
-#endif
 	m_loggingSubmenu = debugLoggingMenu;
 	// debug->dump submenu
 	wxMenu* debugDumpMenu = new wxMenu;
 	debugDumpMenu->AppendCheckItem(MAINFRAME_MENU_ID_DEBUG_DUMP_TEXTURES, _("&Textures"), wxEmptyString)->Check(ActiveSettings::DumpTexturesEnabled());
 	debugDumpMenu->AppendCheckItem(MAINFRAME_MENU_ID_DEBUG_DUMP_SHADERS, _("&Shaders"), wxEmptyString)->Check(ActiveSettings::DumpShadersEnabled());
+	debugDumpMenu->AppendCheckItem(MAINFRAME_MENU_ID_DEBUG_DUMP_RECOMPILER_FUNCTIONS, _("&Recompiled functions"), wxEmptyString)->Check(ActiveSettings::DumpRecompilerFunctionsEnabled());
 	debugDumpMenu->AppendCheckItem(MAINFRAME_MENU_ID_DEBUG_DUMP_CURL_REQUESTS, _("&nlibcurl HTTP/HTTPS requests"), wxEmptyString);
 	// debug submenu
-	wxMenu* debugMenu = new wxMenu;
+	wxMenu* debugMenu = new wxMenu();
 	m_debugMenu = debugMenu;
 	debugMenu->AppendSubMenu(debugLoggingMenu, _("&Logging"));
 	debugMenu->AppendSubMenu(debugDumpMenu, _("&Dump"));
@@ -2215,29 +2288,32 @@ void MainWindow::RecreateMenu()
 
 	debugMenu->AppendSeparator();
 
-#ifndef PUBLIC_RELEASE
+#ifdef CEMU_DEBUG_ASSERT
 	auto audioAuxOnly = debugMenu->AppendCheckItem(MAINFRAME_MENU_ID_DEBUG_AUDIO_AUX_ONLY, _("&Audio AUX only"), wxEmptyString);
 	audioAuxOnly->Check(ActiveSettings::AudioOutputOnlyAux());
 #endif
 
-#ifndef PUBLIC_RELEASE
 	debugMenu->Append(MAINFRAME_MENU_ID_DEBUG_VIEW_LOGGING_WINDOW, _("&Open logging window"));
-#endif
+	m_gdbstub_toggle = debugMenu->AppendCheckItem(MAINFRAME_MENU_ID_DEBUG_TOGGLE_GDB_STUB, _("&Launch with GDB stub"), wxEmptyString);
+	m_gdbstub_toggle->Check(g_gdbstub != nullptr);
+	m_gdbstub_toggle->Enable(!m_game_launched);
+
 	debugMenu->Append(MAINFRAME_MENU_ID_DEBUG_VIEW_PPC_THREADS, _("&View PPC threads"));
 	debugMenu->Append(MAINFRAME_MENU_ID_DEBUG_VIEW_PPC_DEBUGGER, _("&View PPC debugger"));
 	debugMenu->Append(MAINFRAME_MENU_ID_DEBUG_VIEW_AUDIO_DEBUGGER, _("&View audio debugger"));
 	debugMenu->Append(MAINFRAME_MENU_ID_DEBUG_VIEW_TEXTURE_RELATIONS, _("&View texture cache info"));
-	debugMenu->AppendCheckItem(MAINFRAME_MENU_ID_DEBUG_SHOW_FRAME_PROFILER, _("&Show frame profiler"), wxEmptyString);
 	debugMenu->Append(MAINFRAME_MENU_ID_DEBUG_DUMP_RAM, _("&Dump current RAM"));
 	// debugMenu->Append(MAINFRAME_MENU_ID_DEBUG_DUMP_FST, _("&Dump WUD filesystem"))->Enable(false);
 
 	m_menuBar->Append(debugMenu, _("&Debug"));
 	// help menu
-	wxMenu* helpMenu = new wxMenu;
-	//helpMenu->Append(MAINFRAME_MENU_ID_HELP_WEB, wxT("&Visit website"));
-	//helpMenu->AppendSeparator();
+	wxMenu* helpMenu = new wxMenu();
 	m_check_update_menu = helpMenu->Append(MAINFRAME_MENU_ID_HELP_UPDATE, _("&Check for updates"));
-	helpMenu->Append(MAINFRAME_MENU_ID_HELP_GETTING_STARTED, _("&Getting started"));
+#if BOOST_OS_LINUX
+	if (!std::getenv("APPIMAGE")) {
+		m_check_update_menu->Enable(false);
+	}
+#endif
 	helpMenu->AppendSeparator();
 	helpMenu->Append(MAINFRAME_MENU_ID_HELP_ABOUT, _("&About Cemu"));
 
@@ -2253,10 +2329,10 @@ void MainWindow::RecreateMenu()
 
 		m_memorySearcherMenuItem->Enable(true);
 		m_nfcMenu->Enable(MAINFRAME_MENU_ID_NFC_TOUCH_NFC_FILE, true);
-		
-		// disable OpenGL logging (currently cant be toggled after OpenGL backend is initialized)
-		m_loggingSubmenu->Enable(MAINFRAME_MENU_ID_DEBUG_LOGGING0 + LOG_TYPE_OPENGL, false);
-		m_loggingSubmenu->Enable(MAINFRAME_MENU_ID_DEBUG_LOGGING0 + LOG_TYPE_VULKAN_VALIDATION, false);
+
+		// these options cant be toggled after the renderer backend is initialized:
+		m_loggingSubmenu->Enable(MAINFRAME_MENU_ID_DEBUG_LOGGING0 + stdx::to_underlying(LogType::OpenGLLogging), false);
+		m_loggingSubmenu->Enable(MAINFRAME_MENU_ID_DEBUG_LOGGING0 + stdx::to_underlying(LogType::VulkanValidation), false);
 
 		UpdateNFCMenu();
 	}
@@ -2266,55 +2342,12 @@ void MainWindow::RecreateMenu()
 		SetMenuVisible(false);
 }
 
-void MainWindow::OnAfterCallShowErrorDialog()
+void MainWindow::UpdateChildWindowTitleRunningState()
 {
-	//wxMessageBox((const wxString&)dialogText, (const wxString&)dialogTitle, wxICON_INFORMATION);
-	//wxDialog* dialog = new wxDialog(NULL,wxID_ANY,(const wxString&)dialogTitle,wxDefaultPosition,wxSize(310,170));
-	//dialog->ShowModal();
-	//dialogState = 1;
-}
+	const bool running = CafeSystem::IsTitleRunning();
 
-bool MainWindow::EnableOnlineMode() const
-{
-	// TODO: not used anymore
-	// 
-	// if enabling online mode, check if all requirements are met
-	std::wstring additionalErrorInfo;
-	const sint32 onlineReqError = iosuCrypt_checkRequirementsForOnlineMode(additionalErrorInfo);
-
-	bool enableOnline = false;
-	if (onlineReqError == IOS_CRYPTO_ONLINE_REQ_OTP_MISSING)
-	{
-		wxMessageBox(_("otp.bin could not be found"), _("Error"), wxICON_ERROR);
-	}
-	else if (onlineReqError == IOS_CRYPTO_ONLINE_REQ_OTP_CORRUPTED)
-	{
-		wxMessageBox(_("otp.bin is corrupted or has invalid size"), _("Error"), wxICON_ERROR);
-	}
-	else if (onlineReqError == IOS_CRYPTO_ONLINE_REQ_SEEPROM_MISSING)
-	{
-		wxMessageBox(_("seeprom.bin could not be found"), _("Error"), wxICON_ERROR);
-	}
-	else if (onlineReqError == IOS_CRYPTO_ONLINE_REQ_SEEPROM_CORRUPTED)
-	{
-		wxMessageBox(_("seeprom.bin is corrupted or has invalid size"), _("Error"), wxICON_ERROR);
-	}
-	else if (onlineReqError == IOS_CRYPTO_ONLINE_REQ_MISSING_FILE)
-	{
-		std::wstring errorMessage = fmt::format(L"Unable to load a necessary file:\n{}", additionalErrorInfo);
-		wxMessageBox(errorMessage.c_str(), _("Error"), wxICON_ERROR);
-	}
-	else if (onlineReqError == IOS_CRYPTO_ONLINE_REQ_OK)
-	{
-		enableOnline = true;
-	}
-	else
-	{
-		wxMessageBox(_("Unknown error occured"), _("Error"), wxICON_ERROR);
-	}
-
-	//config_get()->enableOnlineMode = enableOnline;
-	return enableOnline;
+	if(m_graphic_pack_window)
+		m_graphic_pack_window->UpdateTitleRunning(running);
 }
 
 void MainWindow::RestoreSettingsAfterGameExited()
@@ -2325,31 +2358,9 @@ void MainWindow::RestoreSettingsAfterGameExited()
 void MainWindow::UpdateSettingsAfterGameLaunch()
 {
 	m_update_available = {};
-	//m_game_launched = true;
 	RecreateMenu();
 }
 
-std::string MainWindow::GetRegionString(uint32 region) const
-{
-	switch (region)
-	{
-	case 0x1:
-		return "JPN";
-	case 0x2:
-		return "USA";
-	case 0x4:
-		return "EUR";
-	case 0x10:
-		return "CHN";
-	case 0x20:
-		return "KOR";
-	case 0x40:
-		return "TWN";
-	default:
-		return std::to_string(region);
-	}
-}
-
 void MainWindow::OnGraphicWindowClose(wxCloseEvent& event)
 {
 	m_graphic_pack_window->Destroy();
@@ -2360,7 +2371,6 @@ void MainWindow::OnGraphicWindowOpen(wxTitleIdEvent& event)
 {
 	if (m_graphic_pack_window)
 		return;
-
 	m_graphic_pack_window = new GraphicPacksWindow2(this, event.GetTitleId());
 	m_graphic_pack_window->Bind(wxEVT_CLOSE_WINDOW, &MainWindow::OnGraphicWindowClose, this);
 	m_graphic_pack_window->Show(true);
@@ -2377,3 +2387,20 @@ void MainWindow::RequestLaunchGame(fs::path filePath, wxLaunchGameEvent::INITIAT
 	wxLaunchGameEvent evt(filePath, initiatedBy);
 	wxPostEvent(g_mainFrame, evt);
 }
+
+void MainWindow::OnRequestRecreateCanvas(wxCommandEvent& event)
+{
+	CounterSemaphore* sem = (CounterSemaphore*)event.GetClientData();
+	DestroyCanvas();
+	CreateCanvas();
+	sem->increment();
+}
+
+void MainWindow::CafeRecreateCanvas()
+{
+	CounterSemaphore sem;
+	auto* evt = new wxCommandEvent(wxEVT_REQUEST_RECREATE_CANVAS);
+	evt->SetClientData((void*)&sem);
+	wxQueueEvent(g_mainFrame, evt);
+	sem.decrementWithWait();
+}
diff --git a/src/gui/MainWindow.h b/src/gui/MainWindow.h
index bcf1212d..ddb9795d 100644
--- a/src/gui/MainWindow.h
+++ b/src/gui/MainWindow.h
@@ -14,11 +14,15 @@
 #include "gui/components/wxGameList.h"
 
 #include <future>
+#include "Cafe/HW/Espresso/Debugger/GDBStub.h"
+#include "Cafe/CafeSystem.h"
 
 class DebuggerWindow2;
 struct GameEntry;
 class DiscordPresence;
 class TitleManager;
+class GraphicPacksWindow2;
+class EmulatedUSBDeviceFrame;
 class wxLaunchGameEvent;
 
 wxDECLARE_EVENT(wxEVT_LAUNCH_GAME, wxLaunchGameEvent);
@@ -49,18 +53,21 @@ private:
 	INITIATED_BY m_initiatedBy;
 };
 
-class MainWindow : public wxFrame
+class MainWindow : public wxFrame, public CafeSystem::SystemImplementation
 {
 	friend class CemuApp;
 
 public:
 	MainWindow();
 	~MainWindow();
-	
+
+    void CreateGameListAndStatusBar();
+    void DestroyGameListAndStatusBar();
+
 	void UpdateSettingsAfterGameLaunch();
 	void RestoreSettingsAfterGameExited();
 
-	bool FileLoad(std::wstring fileName, wxLaunchGameEvent::INITIATED_BY initiatedBy);
+	bool FileLoad(const fs::path launchPath, wxLaunchGameEvent::INITIATED_BY initiatedBy);
 
 	[[nodiscard]] bool IsGameLaunched() const { return m_game_launched; }
 
@@ -78,6 +85,7 @@ public:
 	PadViewFrame* GetPadView() const { return m_padView; }
 
 	void OnSizeEvent(wxSizeEvent& event);
+	void OnDPIChangedEvent(wxDPIChangedEvent& event);
 	void OnMove(wxMoveEvent& event);
 
 	void OnDebuggerClose(wxCloseEvent& event);
@@ -86,6 +94,7 @@ public:
 	void OnMouseWheel(wxMouseEvent& event);
 	void OnClose(wxCloseEvent& event);
 	void OnFileMenu(wxCommandEvent& event);
+	void OnOpenFolder(wxCommandEvent& event);
 	void OnLaunchFromFile(wxLaunchGameEvent& event);
 	void OnInstallUpdate(wxCommandEvent& event);
 	void OnFileExit(wxCommandEvent& event);
@@ -93,17 +102,14 @@ public:
 	void OnOptionsInput(wxCommandEvent& event);
 	void OnAccountSelect(wxCommandEvent& event);
 	void OnConsoleLanguage(wxCommandEvent& event);
-	void OnHelpVistWebpage(wxCommandEvent& event);
 	void OnHelpAbout(wxCommandEvent& event);
-	void OnHelpGettingStarted(wxCommandEvent& event);
 	void OnHelpUpdate(wxCommandEvent& event);
-	void OnAfterCallShowErrorDialog();
 	void OnDebugSetting(wxCommandEvent& event);
 	void OnDebugLoggingToggleFlagGeneric(wxCommandEvent& event);
 	void OnPPCInfoToggle(wxCommandEvent& event);
-	void OnDebugDumpUsedTextures(wxCommandEvent& event);
-	void OnDebugDumpUsedShaders(wxCommandEvent& event);
+	void OnDebugDumpGeneric(wxCommandEvent& event);
 	void OnLoggingWindow(wxCommandEvent& event);
+	void OnGDBStubToggle(wxCommandEvent& event);
 	void OnDebugViewPPCThreads(wxCommandEvent& event);
 	void OnDebugViewPPCDebugger(wxCommandEvent& event);
 	void OnDebugViewAudioDebugger(wxCommandEvent& event);
@@ -118,6 +124,7 @@ public:
 	void OnSetWindowTitle(wxCommandEvent& event);
 
 	void OnKeyUp(wxKeyEvent& event);
+	void OnKeyDown(wxKeyEvent& event);
 	void OnChar(wxKeyEvent& event);
 
 	void OnToolsInput(wxCommandEvent& event);
@@ -130,7 +137,6 @@ public:
 	void CreateCanvas();
 	void DestroyCanvas();
 
-	std::wstring GetGameName(std::wstring_view file_name);
 	static void ShowCursor(bool state);
 
 	uintptr_t GetRenderCanvasHWND();
@@ -140,20 +146,25 @@ public:
 
 private:
 	void RecreateMenu();
+	void UpdateChildWindowTitleRunningState();
 	static wxString GetInitialWindowTitle();
-	void ShowGettingStartedDialog();
-	bool EnableOnlineMode() const;
 
 	bool InstallUpdate(const fs::path& metaFilePath);
 
 	void OnTimer(wxTimerEvent& event);
 
+	// CafeSystem implementation
+	void CafeRecreateCanvas() override;
+
+	void OnRequestRecreateCanvas(wxCommandEvent& event);
+
 	wxRect GetDesktopRect();
 
 	MemorySearcherTool* m_toolWindow = nullptr;
 	TitleManager* m_title_manager = nullptr;
+	EmulatedUSBDeviceFrame* m_usb_devices = nullptr;
 	PadViewFrame* m_padView = nullptr;
-	wxWindow* m_graphic_pack_window = nullptr;
+	GraphicPacksWindow2* m_graphic_pack_window = nullptr;
 
 	wxTimer* m_timer;
 	wxPoint m_mouse_position{};
@@ -170,6 +181,7 @@ private:
 
 	std::string m_launched_game_name;
 
+	wxMenuItem* m_gdbstub_toggle{};
 	DebuggerWindow2* m_debugger_window = nullptr;
 	LoggingWindow* m_logging_window = nullptr;
 
@@ -179,8 +191,6 @@ private:
 	void LoadSettings();
 	void SaveSettings();
 
-	std::string GetRegionString(uint32 region) const;
-
 	void OnGraphicWindowClose(wxCloseEvent& event);
 	void OnGraphicWindowOpen(wxTitleIdEvent& event);
 
@@ -191,44 +201,42 @@ private:
 	wxWindow* m_render_canvas{};
 
 	// gamelist
-	wxGameList* m_game_list;
-	wxInfoBar* m_info_bar;
+	wxGameList* m_game_list{};
+	wxInfoBar* m_info_bar{};
 
 	// menu
-	wxMenuBar* m_menuBar = nullptr;
+	wxMenuBar* m_menuBar{};
 
 	// file
-	wxMenu* m_fileMenu;
-	wxMenuItem* m_fileMenuSeparator0;
-	wxMenuItem* m_fileMenuSeparator1;
-	wxMenuItem* m_loadMenuItem;
-	wxMenuItem* m_installUpdateMenuItem;
-	wxMenuItem* m_exitMenuItem;
+	wxMenu* m_fileMenu{};
+	wxMenuItem* m_fileMenuSeparator0{};
+	wxMenuItem* m_fileMenuSeparator1{};
+	wxMenuItem* m_loadMenuItem{};
+	wxMenuItem* m_installUpdateMenuItem{};
+	wxMenuItem* m_exitMenuItem{};
 
 	// options
-	//wxMenu* m_gpuBufferCacheAccuracySubmenu;
-	wxMenu* m_optionsAccountMenu;
+	wxMenu* m_optionsAccountMenu{};
 
-	wxMenuItem* m_fullscreenMenuItem;
-	wxMenuItem* m_padViewMenuItem;
+	wxMenuItem* m_fullscreenMenuItem{};
+	wxMenuItem* m_padViewMenuItem{};
 
 	// tools
-	wxMenuItem* m_memorySearcherMenuItem;
+	wxMenuItem* m_memorySearcherMenuItem{};
 
 	// cpu
-	//wxMenu* m_cpuModeSubmenu;
-	wxMenu* m_cpuTimerSubmenu;
+	wxMenu* m_cpuTimerSubmenu{};
 
 	// nfc
-	wxMenu* m_nfcMenu;
-	wxMenuItem* m_nfcMenuSeparator0;
+	wxMenu* m_nfcMenu{};
+	wxMenuItem* m_nfcMenuSeparator0{};
 
 	// debug
-	wxMenu* m_debugMenu;
-	wxMenu* m_loggingSubmenu;
-	wxMenuItem* m_asyncCompile;
+	wxMenu* m_debugMenu{};
+	wxMenu* m_loggingSubmenu{};
+	wxMenuItem* m_asyncCompile{};
 
 wxDECLARE_EVENT_TABLE();
 };
 
-extern MainWindow* g_mainFrame;
\ No newline at end of file
+extern MainWindow* g_mainFrame;
diff --git a/src/gui/MemorySearcherTool.cpp b/src/gui/MemorySearcherTool.cpp
index 3423e73b..8506c591 100644
--- a/src/gui/MemorySearcherTool.cpp
+++ b/src/gui/MemorySearcherTool.cpp
@@ -5,6 +5,7 @@
 #include <vector>
 #include <sstream>
 #include <thread>
+#include <wx/listctrl.h>
 
 #include "config/ActiveSettings.h"
 #include "gui/helpers/wxHelpers.h"
@@ -79,7 +80,7 @@ MemorySearcherTool::MemorySearcherTool(wxFrame* parent)
 	m_gauge->Enable(false);
 
 	m_textEntryTable = new wxStaticText(this, wxID_ANY, _("Results"));
-	m_listResults = new wxListCtrl(this, LIST_RESULTS, wxDefaultPosition, wxDefaultSize, wxLC_REPORT | wxLC_SORT_ASCENDING);
+	m_listResults = new wxListView(this, LIST_RESULTS, wxDefaultPosition, wxDefaultSize, wxLC_REPORT | wxLC_SORT_ASCENDING);
 	m_listResults->Bind(wxEVT_LEFT_DCLICK, &MemorySearcherTool::OnResultListClick, this);
 	{
 		wxListItem col0;
@@ -270,7 +271,7 @@ void MemorySearcherTool::OnFilter(wxCommandEvent& event)
 
 void MemorySearcherTool::Load()
 {
-	const auto memorySearcherPath = ActiveSettings::GetPath("memorySearcher/{:016x}.ini", CafeSystem::GetForegroundTitleId());
+	const auto memorySearcherPath = ActiveSettings::GetUserDataPath("memorySearcher/{:016x}.ini", CafeSystem::GetForegroundTitleId());
 	auto memSearcherIniContents = FileStream::LoadIntoMemory(memorySearcherPath);
 	if (!memSearcherIniContents)
 		return;
@@ -300,14 +301,14 @@ void MemorySearcherTool::Load()
 		bool found = false;
 		for (const auto& entry : kDataTypeNames)
 		{
-			if (boost::iequals(entry, *option_type))
+			if (boost::iequals(entry.ToStdString(), *option_type))
 			{
 				found = true;
 				break;
 			}
 		}
 
-		if (!found && !boost::iequals(kDatatypeString, *option_type))
+		if (!found && !boost::iequals(kDatatypeString.ToStdString(), *option_type))
 			continue;
 
 		wxVector<wxVariant> data;
@@ -322,7 +323,7 @@ void MemorySearcherTool::Load()
 
 void MemorySearcherTool::Save()
 {
-	const auto memorySearcherPath = ActiveSettings::GetPath("memorySearcher/{:016x}.ini", CafeSystem::GetForegroundTitleId());
+	const auto memorySearcherPath = ActiveSettings::GetUserDataPath("memorySearcher/{:016x}.ini", CafeSystem::GetForegroundTitleId());
 	FileStream* fs = FileStream::createFile2(memorySearcherPath);
 	if (fs)
 	{
@@ -388,14 +389,8 @@ void MemorySearcherTool::OnEntryListRightClick(wxDataViewEvent& event)
 
 void MemorySearcherTool::OnResultListClick(wxMouseEvent& event)
 {
-	long selectedIndex = -1;
-
-	while (true)
+	for (long selectedIndex = m_listResults->GetFirstSelected(); selectedIndex != wxNOT_FOUND; selectedIndex = m_listResults->GetNextSelected(selectedIndex))
 	{
-		selectedIndex = m_listResults->GetNextItem(selectedIndex, wxLIST_NEXT_ALL, wxLIST_STATE_SELECTED);
-		if (selectedIndex == -1)
-			break;
-
 		long address = m_listResults->GetItemData(selectedIndex);
 		auto currValue = m_listResults->GetItemText(selectedIndex, 1);
 
@@ -472,9 +467,7 @@ bool MemorySearcherTool::VerifySearchValue() const
 
 void MemorySearcherTool::FillResultList()
 {
-	//char text[128];
-	//sprintf(text, "Results (%u)", (uint32)m_searchBuffer.size());
-	auto text = wxStringFormat(_("Results ({0})"), L"%llu", m_searchBuffer.size());
+	auto text = formatWxString(_("Results ({0})"), m_searchBuffer.size());
 	m_textEntryTable->SetLabelText(text);
 
 	m_listResults->DeleteAllItems();
@@ -664,30 +657,6 @@ void MemorySearcherTool::SetSearchDataType()
 		m_searchDataType = SearchDataType_None;
 }
 
-std::string MemorySearcherTool::GetSearchTypeName() const
-{
-	switch (m_searchDataType)
-	{
-	case SearchDataType_String:
-		return from_wxString(kDatatypeString);
-	case SearchDataType_Float:
-		return from_wxString(kDatatypeFloat);
-	case SearchDataType_Double:
-		return from_wxString(kDatatypeDouble);
-	case SearchDataType_Int8:
-		return from_wxString(kDatatypeInt8);
-	case SearchDataType_Int16:
-		return from_wxString(kDatatypeInt16);
-	case SearchDataType_Int32:
-		return from_wxString(kDatatypeInt32);
-	case SearchDataType_Int64:
-		return from_wxString(kDatatypeInt64);
-	default: 
-		return "";
-	}
-	
-}
-
 template <>
 bool MemorySearcherTool::ConvertStringToType<signed char>(const char* inValue, sint8& outValue) const
 {
@@ -710,7 +679,7 @@ void MemorySearcherTool::OnPopupClick(wxCommandEvent& event)
 	if (event.GetId() == LIST_ENTRY_REMOVE)
 	{
 		const int row = m_listEntryTable->GetSelectedRow();
-		if (row == -1)
+		if (row == wxNOT_FOUND)
 			return;
 		
 		m_listEntryTable->DeleteItem(row);
@@ -726,7 +695,7 @@ void MemorySearcherTool::OnItemEdited(wxDataViewEvent& event)
 	else if (column == 3)
 	{
 		auto row = m_listEntryTable->GetSelectedRow();
-		if (row == -1)
+		if (row == wxNOT_FOUND)
 			return;
 
 		auto addressText = std::string(m_listEntryTable->GetTextValue(row, 1).mbc_str());
diff --git a/src/gui/MemorySearcherTool.h b/src/gui/MemorySearcherTool.h
index add9aced..27e7d27d 100644
--- a/src/gui/MemorySearcherTool.h
+++ b/src/gui/MemorySearcherTool.h
@@ -56,8 +56,6 @@ private:
 	void RefreshResultList();
 	void RefreshStashList();
 	void SetSearchDataType();
-	std::string GetSearchTypeName() const;
-	void CreateRightClickPopupMenu();
 
 	void Load();
 	void Save();
@@ -175,7 +173,7 @@ wxDECLARE_EVENT_TABLE();
 	wxComboBox* m_cbDataType;
 	wxTextCtrl* m_textValue;
 	wxButton *m_buttonStart, *m_buttonFilter;
-	wxListCtrl* m_listResults;
+	wxListView* m_listResults;
 	wxDataViewListCtrl* m_listEntryTable;
 	wxStaticText* m_textEntryTable;
 	wxGauge* m_gauge;
diff --git a/src/gui/PadViewFrame.cpp b/src/gui/PadViewFrame.cpp
index ba020b5f..e7cc5c18 100644
--- a/src/gui/PadViewFrame.cpp
+++ b/src/gui/PadViewFrame.cpp
@@ -20,23 +20,30 @@
 
 extern WindowInfo g_window_info;
 
+#define PAD_MIN_WIDTH  320
+#define PAD_MIN_HEIGHT 180
+
 PadViewFrame::PadViewFrame(wxFrame* parent)
-	: wxFrame(nullptr, wxID_ANY, _("GamePad View"), wxDefaultPosition, wxSize(854, 480), wxMINIMIZE_BOX | wxMAXIMIZE_BOX | wxSYSTEM_MENU | wxCAPTION | wxCLIP_CHILDREN | wxRESIZE_BORDER | wxCLOSE_BOX | wxWANTS_CHARS)
+	: wxFrame(nullptr, wxID_ANY, _("GamePad View"), wxDefaultPosition, wxDefaultSize, wxMINIMIZE_BOX | wxMAXIMIZE_BOX | wxSYSTEM_MENU | wxCAPTION | wxCLIP_CHILDREN | wxRESIZE_BORDER | wxCLOSE_BOX | wxWANTS_CHARS)
 {
 	gui_initHandleContextFromWxWidgetsWindow(g_window_info.window_pad, this);
-	
+
 	SetIcon(wxICON(M_WND_ICON128));
 	wxWindow::EnableTouchEvents(wxTOUCH_PAN_GESTURES);
 
-	SetMinClientSize({ 320, 180 });
+	SetMinClientSize({ PAD_MIN_WIDTH, PAD_MIN_HEIGHT });
 
 	SetPosition({ g_window_info.restored_pad_x, g_window_info.restored_pad_y });
-	SetSize({ g_window_info.restored_pad_width, g_window_info.restored_pad_height });
+	if (g_window_info.restored_pad_width >= PAD_MIN_WIDTH && g_window_info.restored_pad_height >= PAD_MIN_HEIGHT)
+		SetClientSize({ g_window_info.restored_pad_width, g_window_info.restored_pad_height });
+	else
+		SetClientSize(wxSize(854, 480));
 
 	if (g_window_info.pad_maximized)
 		Maximize();
 
 	Bind(wxEVT_SIZE, &PadViewFrame::OnSizeEvent, this);
+	Bind(wxEVT_DPI_CHANGED, &PadViewFrame::OnDPIChangedEvent, this);
 	Bind(wxEVT_MOVE, &PadViewFrame::OnMoveEvent, this);
 	Bind(wxEVT_MOTION, &PadViewFrame::OnMouseMove, this);
 
@@ -55,6 +62,8 @@ bool PadViewFrame::Initialize()
 	const wxSize client_size = GetClientSize();
 	g_window_info.pad_width = client_size.GetWidth();
 	g_window_info.pad_height = client_size.GetHeight();
+	g_window_info.phys_pad_width = ToPhys(client_size.GetWidth());
+	g_window_info.phys_pad_height = ToPhys(client_size.GetHeight());
 
 	return true;
 }
@@ -84,6 +93,15 @@ void PadViewFrame::InitializeRenderCanvas()
 	m_render_canvas->Bind(wxEVT_GESTURE_PAN, &PadViewFrame::OnGesturePan, this);
 
 	m_render_canvas->SetFocus();
+	SendSizeEvent();
+}
+
+void PadViewFrame::DestroyCanvas()
+{
+	if(!m_render_canvas)
+		return;
+	m_render_canvas->Destroy();
+	m_render_canvas = nullptr;
 }
 
 void PadViewFrame::OnSizeEvent(wxSizeEvent& event)
@@ -98,10 +116,24 @@ void PadViewFrame::OnSizeEvent(wxSizeEvent& event)
 	const wxSize client_size = GetClientSize();
 	g_window_info.pad_width = client_size.GetWidth();
 	g_window_info.pad_height = client_size.GetHeight();
+	g_window_info.phys_pad_width = ToPhys(client_size.GetWidth());
+	g_window_info.phys_pad_height = ToPhys(client_size.GetHeight());
+	g_window_info.pad_dpi_scale = GetDPIScaleFactor();
 
 	event.Skip();
 }
 
+void PadViewFrame::OnDPIChangedEvent(wxDPIChangedEvent& event)
+{
+	event.Skip();
+	const wxSize client_size = GetClientSize();
+	g_window_info.pad_width = client_size.GetWidth();
+	g_window_info.pad_height = client_size.GetHeight();
+	g_window_info.phys_pad_width = ToPhys(client_size.GetWidth());
+	g_window_info.phys_pad_height = ToPhys(client_size.GetHeight());
+	g_window_info.pad_dpi_scale = GetDPIScaleFactor();
+}
+
 void PadViewFrame::OnMoveEvent(wxMoveEvent& event)
 {
 	if (!IsMaximized() && !IsFullScreen())
@@ -121,7 +153,7 @@ void PadViewFrame::OnKeyUp(wxKeyEvent& event)
 	const auto code = event.GetKeyCode();
 	if (code == WXK_ESCAPE)
 		ShowFullScreen(false);
-	else if (code == WXK_RETURN && event.AltDown())
+	else if (code == WXK_RETURN && event.AltDown() || code == WXK_F11)
 		ShowFullScreen(!IsFullScreen());
 }
 
@@ -130,7 +162,8 @@ void PadViewFrame::OnGesturePan(wxPanGestureEvent& event)
 	auto& instance = InputManager::instance();
 
 	std::scoped_lock lock(instance.m_pad_touch.m_mutex);
-	instance.m_pad_touch.position = { event.GetPosition().x, event.GetPosition().y };
+	auto physPos = ToPhys(event.GetPosition());
+	instance.m_pad_touch.position = { physPos.x, physPos.y };
 	instance.m_pad_touch.left_down = event.IsGestureStart() || !event.IsGestureEnd();
 	if (event.IsGestureStart() || !event.IsGestureEnd())
 		instance.m_pad_touch.left_down_toggle = true;
@@ -149,7 +182,8 @@ void PadViewFrame::OnMouseMove(wxMouseEvent& event)
 	auto& instance = InputManager::instance();
 
 	std::scoped_lock lock(instance.m_pad_touch.m_mutex);
-	instance.m_pad_mouse.position = { event.GetPosition().x, event.GetPosition().y };
+	auto physPos = ToPhys(event.GetPosition());
+	instance.m_pad_mouse.position = { physPos.x, physPos.y };
 
 	event.Skip();
 }
@@ -160,7 +194,8 @@ void PadViewFrame::OnMouseLeft(wxMouseEvent& event)
 
 	std::scoped_lock lock(instance.m_pad_mouse.m_mutex);
 	instance.m_pad_mouse.left_down = event.ButtonDown(wxMOUSE_BTN_LEFT);
-	instance.m_pad_mouse.position = { event.GetPosition().x, event.GetPosition().y };
+	auto physPos = ToPhys(event.GetPosition());
+	instance.m_pad_mouse.position = { physPos.x, physPos.y };
 	if (event.ButtonDown(wxMOUSE_BTN_LEFT))
 		instance.m_pad_mouse.left_down_toggle = true;
 	
@@ -172,7 +207,8 @@ void PadViewFrame::OnMouseRight(wxMouseEvent& event)
 
 	std::scoped_lock lock(instance.m_pad_mouse.m_mutex);
 	instance.m_pad_mouse.right_down = event.ButtonDown(wxMOUSE_BTN_LEFT);
-	instance.m_pad_mouse.position = { event.GetPosition().x, event.GetPosition().y };
+	auto physPos = ToPhys(event.GetPosition());
+	instance.m_pad_mouse.position = { physPos.x, physPos.y };
 	if (event.ButtonDown(wxMOUSE_BTN_RIGHT))
 		instance.m_pad_mouse.right_down_toggle = true;
 }
@@ -187,4 +223,4 @@ void PadViewFrame::AsyncSetTitle(std::string_view windowTitle)
 	wxCommandEvent set_title_event(wxEVT_SET_WINDOW_TITLE);
 	set_title_event.SetString(wxHelper::FromUtf8(windowTitle));
 	QueueEvent(set_title_event.Clone());
-}
\ No newline at end of file
+}
diff --git a/src/gui/PadViewFrame.h b/src/gui/PadViewFrame.h
index e808ad1d..2be173ab 100644
--- a/src/gui/PadViewFrame.h
+++ b/src/gui/PadViewFrame.h
@@ -14,6 +14,7 @@ public:
 
 	bool Initialize();
 	void InitializeRenderCanvas();
+	void DestroyCanvas();
 
 	void OnKeyUp(wxKeyEvent& event);
 	void OnChar(wxKeyEvent& event);
@@ -26,9 +27,10 @@ private:
 	void OnMouseLeft(wxMouseEvent& event);
 	void OnMouseRight(wxMouseEvent& event);
 	void OnSizeEvent(wxSizeEvent& event);
+	void OnDPIChangedEvent(wxDPIChangedEvent& event);
 	void OnMoveEvent(wxMoveEvent& event);
 	void OnGesturePan(wxPanGestureEvent& event);
 	void OnSetWindowTitle(wxCommandEvent& event);
 
 	wxWindow* m_render_canvas = nullptr;
-};
\ No newline at end of file
+};
diff --git a/src/gui/TitleManager.cpp b/src/gui/TitleManager.cpp
index 657fa3ce..67f13e05 100644
--- a/src/gui/TitleManager.cpp
+++ b/src/gui/TitleManager.cpp
@@ -31,18 +31,15 @@
 #include <wx/dirdlg.h>
 #include <wx/notebook.h>
 
+#include "Cafe/IOSU/legacy/iosu_crypto.h"
 #include "config/ActiveSettings.h"
 #include "gui/dialogs/SaveImport/SaveImportWindow.h"
 #include "Cafe/Account/Account.h"
 #include "Cemu/Tools/DownloadManager/DownloadManager.h"
 #include "gui/CemuApp.h"
-
 #include "Cafe/TitleList/TitleList.h"
-
-#if BOOST_OS_LINUX || BOOST_OS_MACOS
-#include "resource/embedded/resources.h"
-#endif
 #include "Cafe/TitleList/SaveList.h"
+#include "resource/embedded/resources.h"
 
 wxDEFINE_EVENT(wxEVT_TITLE_FOUND, wxCommandEvent);
 wxDEFINE_EVENT(wxEVT_TITLE_SEARCH_COMPLETE, wxCommandEvent);
@@ -63,15 +60,15 @@ wxPanel* TitleManager::CreateTitleManagerPage()
 		m_filter->Bind(wxEVT_TEXT, &TitleManager::OnFilterChanged, this);
 		row->Add(m_filter, 1, wxALL | wxEXPAND, 5);
 
-		const wxImage refresh = wxBITMAP_PNG(PNG_REFRESH).ConvertToImage();
+		const wxImage refresh = wxBITMAP_PNG_FROM_DATA(PNG_REFRESH).ConvertToImage();
 		m_refresh_button = new wxBitmapButton(panel, wxID_ANY, refresh.Scale(16, 16));
 		m_refresh_button->Disable();
 		m_refresh_button->Bind(wxEVT_BUTTON, &TitleManager::OnRefreshButton, this);
 		m_refresh_button->SetToolTip(_("Refresh"));
 		row->Add(m_refresh_button, 0, wxALIGN_CENTER_VERTICAL | wxALL, 5);
 
-		auto* help_button = new wxStaticBitmap(panel, wxID_ANY, wxBITMAP_PNG(PNG_HELP));
-		help_button->SetToolTip(wxStringFormat2(_("The following prefixes are supported:\n{0}\n{1}\n{2}\n{3}\n{4}"),
+		auto* help_button = new wxStaticBitmap(panel, wxID_ANY, wxBITMAP_PNG_FROM_DATA(PNG_HELP));
+		help_button->SetToolTip(formatWxString(_("The following prefixes are supported:\n{0}\n{1}\n{2}\n{3}\n{4}"),
 			"titleid:", "name:", "type:", "version:", "region:"));
 		row->Add(help_button, 0, wxALIGN_CENTER_VERTICAL | wxALL, 5);
 
@@ -156,6 +153,7 @@ wxPanel* TitleManager::CreateDownloadManagerPage()
 	{
 		auto* row = new wxBoxSizer(wxHORIZONTAL);
 
+#if DOWNLOADMGR_HAS_ACCOUNT_DROPDOWN
 		m_account = new wxChoice(panel, wxID_ANY);
 		m_account->SetMinSize({ 250,-1 });
 		auto accounts = Account::GetAccounts();
@@ -173,6 +171,7 @@ wxPanel* TitleManager::CreateDownloadManagerPage()
 		}
 	
 		row->Add(m_account, 0, wxALL, 5);
+#endif
 
 		m_connect = new wxButton(panel, wxID_ANY, _("Connect"));
 		m_connect->Bind(wxEVT_BUTTON, &TitleManager::OnConnect, this);
@@ -181,7 +180,17 @@ wxPanel* TitleManager::CreateDownloadManagerPage()
 		sizer->Add(row, 0, wxEXPAND, 5);
 	}
 
+#if DOWNLOADMGR_HAS_ACCOUNT_DROPDOWN
 	m_status_text = new wxStaticText(panel, wxID_ANY, _("Select an account and press Connect"));
+#else
+	if(!NCrypto::HasDataForConsoleCert())
+	{
+		m_status_text = new wxStaticText(panel, wxID_ANY, _("Valid online files are required to download eShop titles. For more information, go to the Account tab in the General Settings."));
+		m_connect->Enable(false);
+	}
+	else
+		m_status_text = new wxStaticText(panel, wxID_ANY, _("Click on Connect to load the list of downloadable titles"));
+#endif
 	this->Bind(wxEVT_SET_TEXT, &TitleManager::OnSetStatusText, this);
 	sizer->Add(m_status_text, 0, wxALL, 5);
 	
@@ -220,7 +229,7 @@ wxPanel* TitleManager::CreateDownloadManagerPage()
 }
 
 TitleManager::TitleManager(wxWindow* parent, TitleManagerPage default_page)
-	: wxFrame(parent, wxID_ANY, _("Title manager"), wxDefaultPosition, wxDefaultSize, wxDEFAULT_FRAME_STYLE | wxTAB_TRAVERSAL)
+	: wxFrame(parent, wxID_ANY, _("Title Manager"), wxDefaultPosition, wxDefaultSize, wxDEFAULT_FRAME_STYLE | wxTAB_TRAVERSAL)
 {
 	SetIcon(wxICON(X_BOX));
 	
@@ -329,7 +338,7 @@ void TitleManager::OnTitleSearchComplete(wxCommandEvent& event)
 	}
 	// update status bar text
 	m_title_list->SortEntries(-1);
-	m_status_bar->SetStatusText(wxStringFormat2(_("Found {0} games, {1} updates, {2} DLCs and {3} save entries"),
+	m_status_bar->SetStatusText(formatWxString(_("Found {0} games, {1} updates, {2} DLCs and {3} save entries"),
 		m_title_list->GetCountByType(wxTitleManagerList::EntryType::Base) + m_title_list->GetCountByType(wxTitleManagerList::EntryType::System),
 		m_title_list->GetCountByType(wxTitleManagerList::EntryType::Update),
 		m_title_list->GetCountByType(wxTitleManagerList::EntryType::Dlc),
@@ -347,7 +356,7 @@ void TitleManager::OnTitleSearchComplete(wxCommandEvent& event)
 
 void TitleManager::OnSetStatusBarText(wxSetStatusBarTextEvent& event)
 {
-	m_status_bar->SetStatusText(_(event.GetText()), event.GetNumber());
+	m_status_bar->SetStatusText(event.GetText(), event.GetNumber());
 }
 
 void TitleManager::OnFilterChanged(wxCommandEvent& event)
@@ -368,7 +377,7 @@ void TitleManager::OnRefreshButton(wxCommandEvent& event)
 void TitleManager::OnInstallTitle(wxCommandEvent& event)
 {
 	wxFileDialog openFileDialog(this, _("Select title to install"), "", "", "meta.xml|meta.xml", wxFD_OPEN | wxFD_FILE_MUST_EXIST);
-	if (openFileDialog.ShowModal() == wxID_CANCEL)
+	if (openFileDialog.ShowModal() == wxID_CANCEL || openFileDialog.GetPath().IsEmpty())
 		return;
 
 	fs::path filePath(openFileDialog.GetPath().wc_str());
@@ -418,10 +427,12 @@ static void PopulateSavePersistentIds(wxTitleManagerList::TitleEntry& entry)
 	{
 		if(!it.is_directory(ec))
 			continue;
+		if(fs::is_empty(it.path()))
+			continue;
 		std::string dirName = it.path().filename().string();
-		uint32 persistentId = ConvertString<uint32>(dirName, 16);
-		if (persistentId != 0)
-			entry.persistent_ids.emplace_back(persistentId);
+		if(!std::regex_match(dirName, std::regex("[0-9a-fA-F]{8}")))
+			continue;
+		entry.persistent_ids.emplace_back(ConvertString<uint32>(dirName, 16));
 	}
 }
 
@@ -480,7 +491,7 @@ void TitleManager::OnSaveOpenDirectory(wxCommandEvent& event)
 	if (!fs::exists(target) || !fs::is_directory(target))
 		return;
 
-	wxLaunchDefaultBrowser(wxHelper::FromUtf8(fmt::format("file:{}", _pathToUtf8(target))));
+	wxLaunchDefaultApplication(wxHelper::FromPath(target));
 }
 
 void TitleManager::OnSaveDelete(wxCommandEvent& event)
@@ -493,7 +504,7 @@ void TitleManager::OnSaveDelete(wxCommandEvent& event)
 	if (selection.IsEmpty())
 		return;
 	
-	const auto msg = wxStringFormat2(_("Are you really sure that you want to delete the save entry for {}"), selection);
+	const auto msg = formatWxString(_("Are you really sure that you want to delete the save entry for {}"), selection);
 	const auto result = wxMessageBox(msg, _("Warning"), wxYES_NO | wxCENTRE | wxICON_EXCLAMATION, this);
 	if (result == wxNO)
 		return;
@@ -534,7 +545,7 @@ void TitleManager::OnSaveDelete(wxCommandEvent& event)
 	}
 
 	if (!meta_file_edited)
-		forceLog_printf("TitleManager::OnSaveDelete: couldn't delete save entry in saveinfo.xml: %s", saveinfo.generic_u8string().c_str());
+		cemuLog_log(LogType::Force, "TitleManager::OnSaveDelete: couldn't delete save entry in saveinfo.xml: {}", _pathToUtf8(saveinfo));
 
 	// remove from title entry
 	auto& persistent_ids = entry->persistent_ids;
@@ -544,7 +555,7 @@ void TitleManager::OnSaveDelete(wxCommandEvent& event)
 	fs::remove_all(target, ec);
 	if (ec)
 	{
-		const auto error_msg = wxStringFormat2(_("Error when trying to delete the save directory:\n{}"), GetSystemErrorMessage(ec));
+		const auto error_msg = formatWxString(_("Error when trying to delete the save directory:\n{}"), GetSystemErrorMessage(ec));
 		wxMessageBox(error_msg, _("Error"), wxOK | wxCENTRE, this);
 		return;
 	}
@@ -621,21 +632,19 @@ void TitleManager::OnSaveExport(wxCommandEvent& event)
 
 	const auto persistent_id = (uint32)(uintptr_t)m_save_account_list->GetClientData(selection_index);
 
-	wxFileDialog path_dialog(this, _("Select a target file to export the save entry"), entry->path.string(), wxEmptyString, "Exported save entry (*.zip)|*.zip", wxFD_SAVE | wxFD_OVERWRITE_PROMPT);
-	if (path_dialog.ShowModal() != wxID_OK)
+	wxFileDialog path_dialog(this, _("Select a target file to export the save entry"), wxHelper::FromPath(entry->path), wxEmptyString,
+		fmt::format("{}|*.zip", _("Exported save entry (*.zip)")), wxFD_SAVE | wxFD_OVERWRITE_PROMPT);
+	if (path_dialog.ShowModal() != wxID_OK || path_dialog.GetPath().IsEmpty())
 		return;
 
 	const auto path = path_dialog.GetPath();
-	if (path.empty())
-		return;
-
 	int ze;
 	auto* zip = zip_open(path.ToUTF8().data(), ZIP_CREATE | ZIP_TRUNCATE, &ze);
 	if (!zip)
 	{
 		zip_error_t ziperror;
 		zip_error_init_with_code(&ziperror, ze);
-		const auto error_msg = wxStringFormat2(_("Error when creating the zip for the save entry:\n{}"), zip_error_strerror(&ziperror));
+		const auto error_msg = formatWxString(_("Error when creating the zip for the save entry:\n{}"), zip_error_strerror(&ziperror));
 		wxMessageBox(error_msg, _("Error"), wxOK | wxCENTRE | wxICON_ERROR, this);
 		return;
 	}
@@ -653,7 +662,7 @@ void TitleManager::OnSaveExport(wxCommandEvent& event)
 		{
 			if(zip_dir_add(zip, (const char*)entryname.substr(savedir_str.size() + 1).c_str(), ZIP_FL_ENC_UTF_8) < 0 )
 			{
-				const auto error_msg = wxStringFormat2(_("Error when trying to add a directory to the zip:\n{}"), zip_strerror(zip));
+				const auto error_msg = formatWxString(_("Error when trying to add a directory to the zip:\n{}"), zip_strerror(zip));
 				wxMessageBox(error_msg, _("Error"), wxOK | wxCENTRE | wxICON_ERROR, this);
 			}
 		}
@@ -662,13 +671,13 @@ void TitleManager::OnSaveExport(wxCommandEvent& event)
 			auto* source = zip_source_file(zip, (const char*)entryname.c_str(), 0, 0);
 			if(!source)
 			{
-				const auto error_msg = wxStringFormat2(_("Error when trying to add a file to the zip:\n{}"), zip_strerror(zip));
+				const auto error_msg = formatWxString(_("Error when trying to add a file to the zip:\n{}"), zip_strerror(zip));
 				wxMessageBox(error_msg, _("Error"), wxOK | wxCENTRE | wxICON_ERROR, this);
 			}
 
 			if (zip_file_add(zip, (const char*)entryname.substr(savedir_str.size() + 1).c_str(), source, ZIP_FL_ENC_UTF_8) < 0)
 			{
-				const auto error_msg = wxStringFormat2(_("Error when trying to add a file to the zip:\n{}"), zip_strerror(zip));
+				const auto error_msg = formatWxString(_("Error when trying to add a file to the zip:\n{}"), zip_strerror(zip));
 				wxMessageBox(error_msg, _("Error"), wxOK | wxCENTRE | wxICON_ERROR, this);
 				
 				zip_source_free(source);
@@ -681,7 +690,7 @@ void TitleManager::OnSaveExport(wxCommandEvent& event)
 	auto* metabuff = zip_source_buffer(zip, metacontent.data(), metacontent.size(), 0);
 	if(zip_file_add(zip, "cemu_meta", metabuff, ZIP_FL_ENC_UTF_8) < 0)
 	{
-		const auto error_msg = wxStringFormat2(_("Error when trying to add cemu_meta file to the zip:\n{}"), zip_strerror(zip));
+		const auto error_msg = formatWxString(_("Error when trying to add cemu_meta file to the zip:\n{}"), zip_strerror(zip));
 		wxMessageBox(error_msg, _("Error"), wxOK | wxCENTRE | wxICON_ERROR, this);
 
 		zip_source_free(metabuff);
@@ -721,9 +730,10 @@ void TitleManager::OnSaveImport(wxCommandEvent& event)
 void TitleManager::InitiateConnect()
 {
 	// init connection to download manager if queued
+#if DOWNLOADMGR_HAS_ACCOUNT_DROPDOWN
 	uint32 persistentId = (uint32)(uintptr_t)m_account->GetClientData(m_account->GetSelection());
 	auto& account = Account::GetAccount(persistentId);
-
+#endif
 	DownloadManager* dlMgr = DownloadManager::GetInstance();
 	dlMgr->reset();
 	m_download_list->SetCurrentDownloadMgr(dlMgr);
@@ -732,18 +742,26 @@ void TitleManager::InitiateConnect()
 
 	if (!NCrypto::SEEPROM_IsPresent())
 	{
-		SetDownloadStatusText("Dumped online files not found");
+		SetDownloadStatusText(_("Dumped online files not found"));
 		return;
 	}
 
-	SetDownloadStatusText("Connecting...");
+	SetDownloadStatusText(_("Connecting..."));
 	// begin async connect
 	dlMgr->setUserData(this);
 	dlMgr->registerCallbacks(
 		TitleManager::Callback_ConnectStatusUpdate,
 		TitleManager::Callback_AddDownloadableTitle,
 		TitleManager::Callback_RemoveDownloadableTitle);
-	dlMgr->connect(account.GetAccountId(), account.GetAccountPasswordCache(), NCrypto::SEEPROM_GetRegion(), NCrypto::GetCountryAsString(account.GetCountry()), NCrypto::GetDeviceId(), NCrypto::GetSerial(), deviceCertBase64);
+	std::string accountName;
+	std::array<uint8, 32> accountPassword;
+	std::string accountCountry;
+#if DOWNLOADMGR_HAS_ACCOUNT_DROPDOWN
+	accountName = account.GetAccountId();
+	accountPassword = account.GetAccountPasswordCache();
+	accountCountry.assign(NCrypto::GetCountryAsString(account.GetCountry()));
+#endif
+	dlMgr->connect(accountName, accountPassword, NCrypto::SEEPROM_GetRegion(), accountCountry, NCrypto::GetDeviceId(), NCrypto::GetSerial(), deviceCertBase64);
 }
 
 void TitleManager::OnConnect(wxCommandEvent& event)
@@ -788,7 +806,9 @@ void TitleManager::OnDisconnect(wxCommandEvent& event)
 
 void TitleManager::SetConnected(bool state)
 {
+#if DOWNLOADMGR_HAS_ACCOUNT_DROPDOWN
 	m_account->Enable(!state);
+#endif
 	m_connect->Enable(!state);
 
 	m_show_titles->Enable(state);
@@ -800,7 +820,7 @@ void TitleManager::SetConnected(bool state)
 void TitleManager::Callback_ConnectStatusUpdate(std::string statusText, DLMGR_STATUS_CODE statusCode)
 {
 	TitleManager* titleManager = static_cast<TitleManager*>(DownloadManager::GetInstance()->getUserData());
-	titleManager->SetDownloadStatusText(statusText);
+	titleManager->SetDownloadStatusText(wxString::FromUTF8(statusText));
 	if (statusCode == DLMGR_STATUS_CODE::FAILED)
 	{
 		auto* evt = new wxCommandEvent(wxEVT_DL_DISCONNECT_COMPLETE);
diff --git a/src/gui/TitleManager.h b/src/gui/TitleManager.h
index 17a48976..ae284040 100644
--- a/src/gui/TitleManager.h
+++ b/src/gui/TitleManager.h
@@ -8,6 +8,8 @@
 
 #include "Cemu/Tools/DownloadManager/DownloadManager.h"
 
+#define DOWNLOADMGR_HAS_ACCOUNT_DROPDOWN 0
+
 class wxCheckBox;
 class wxStaticText;
 class wxListEvent;
@@ -86,7 +88,6 @@ private:
 	void OnDisconnect(wxCommandEvent& event);
 
 	void OnDlFilterCheckbox(wxCommandEvent& event);
-	void OnDlCheckboxShowUpdates(wxCommandEvent& event);
 
 	void SetConnected(bool state);
 
diff --git a/src/gui/canvas/OpenGLCanvas.cpp b/src/gui/canvas/OpenGLCanvas.cpp
index 23d575fd..29ff4294 100644
--- a/src/gui/canvas/OpenGLCanvas.cpp
+++ b/src/gui/canvas/OpenGLCanvas.cpp
@@ -36,8 +36,6 @@ public:
 	OpenGLCanvas(wxWindow* parent, const wxSize& size, bool is_main_window)
 		: IRenderCanvas(is_main_window), wxGLCanvas(parent, wxID_ANY, g_gl_attribute_list, wxDefaultPosition, size, wxFULL_REPAINT_ON_RESIZE | wxWANTS_CHARS)
 	{
-		cemuLog_logDebug(LogType::Force, "Creating OpenGL canvas");
-
 		if (m_is_main_window)
 		{
 			sGLTVView = this;
@@ -64,7 +62,31 @@ public:
 			delete sGLContext;
 	}
 
+	void UpdateVSyncState()
+	{
+		int configValue = GetConfig().vsync.GetValue();
+		if(m_activeVSyncState != configValue)
+		{
+#if BOOST_OS_WINDOWS
+			if(wglSwapIntervalEXT)
+				wglSwapIntervalEXT(configValue); // 1 = enabled, 0 = disabled
+#elif BOOST_OS_LINUX
+			if (eglSwapInterval)
+			{
+				if (eglSwapInterval(eglGetCurrentDisplay(), configValue) == EGL_FALSE)
+				{
+					cemuLog_log(LogType::Force, "Failed to set vsync using EGL");
+				}
+			}
+#else
+			cemuLog_log(LogType::Force, "OpenGL vsync not implemented");
+#endif
+			m_activeVSyncState = configValue;
+		}
+	}
+
 private:
+	int m_activeVSyncState = -1;
 	//wxGLContext* m_context = nullptr;
 };
 
@@ -90,7 +112,17 @@ bool GLCanvas_MakeCurrent(bool padView)
 void GLCanvas_SwapBuffers(bool swapTV, bool swapDRC)
 {
 	if (swapTV && sGLTVView)
+	{
+		GLCanvas_MakeCurrent(false);
 		sGLTVView->SwapBuffers();
+		sGLTVView->UpdateVSyncState();
+	}
 	if (swapDRC && sGLPadView)
+	{
+		GLCanvas_MakeCurrent(true);
 		sGLPadView->SwapBuffers();
-}
\ No newline at end of file
+		sGLPadView->UpdateVSyncState();
+	}
+
+	GLCanvas_MakeCurrent(false);
+}
diff --git a/src/gui/canvas/VulkanCanvas.cpp b/src/gui/canvas/VulkanCanvas.cpp
index b8faa8c7..8b0c8506 100644
--- a/src/gui/canvas/VulkanCanvas.cpp
+++ b/src/gui/canvas/VulkanCanvas.cpp
@@ -2,18 +2,28 @@
 #include "Cafe/HW/Latte/Renderer/Vulkan/VulkanRenderer.h"
 #include "gui/guiWrapper.h"
 
+#if BOOST_OS_LINUX && HAS_WAYLAND
+#include "gui/helpers/wxWayland.h"
+#endif
+
 #include <wx/msgdlg.h>
+#include <helpers/wxHelpers.h>
 
 VulkanCanvas::VulkanCanvas(wxWindow* parent, const wxSize& size, bool is_main_window)
-	: IRenderCanvas(is_main_window), wxWindow(parent, wxID_ANY, wxDefaultPosition, size, wxFULL_REPAINT_ON_RESIZE | wxWANTS_CHARS)
+	: IRenderCanvas(is_main_window), wxWindow(parent, wxID_ANY, wxDefaultPosition, size, wxNO_FULL_REPAINT_ON_RESIZE | wxWANTS_CHARS)
 {
 	Bind(wxEVT_PAINT, &VulkanCanvas::OnPaint, this);
 	Bind(wxEVT_SIZE, &VulkanCanvas::OnResize, this);
 
-	if(is_main_window)
-		gui_initHandleContextFromWxWidgetsWindow(gui_getWindowInfo().canvas_main, this);
-	else
-		gui_initHandleContextFromWxWidgetsWindow(gui_getWindowInfo().canvas_pad, this);
+	WindowHandleInfo& canvas = is_main_window ? gui_getWindowInfo().canvas_main : gui_getWindowInfo().canvas_pad;
+	gui_initHandleContextFromWxWidgetsWindow(canvas, this);
+	#if BOOST_OS_LINUX && HAS_WAYLAND
+	if (canvas.backend == WindowHandleInfo::Backend::WAYLAND)
+	{
+		m_subsurface = std::make_unique<wxWlSubsurface>(this);
+		canvas.surface = m_subsurface->getSurface();
+	}
+	#endif
 
 	cemu_assert(g_vulkan_available);
 
@@ -23,12 +33,12 @@ VulkanCanvas::VulkanCanvas(wxWindow* parent, const wxSize& size, bool is_main_wi
 			g_renderer = std::make_unique<VulkanRenderer>();
 
 		auto vulkan_renderer = VulkanRenderer::GetInstance();
-		vulkan_renderer->Initialize({size.x, size.y}, is_main_window);
+		vulkan_renderer->InitializeSurface({size.x, size.y}, is_main_window);
 	}
 	catch(const std::exception& ex)
 	{
-		const auto msg = fmt::format(fmt::runtime(_("Error when initializing Vulkan renderer:\n{}").ToStdString()), ex.what());
-		forceLog_printf(const_cast<char*>(msg.c_str()));
+		cemuLog_log(LogType::Force, "Error when initializing Vulkan renderer: {}", ex.what());
+		auto msg = formatWxString(_("Error when initializing Vulkan renderer:\n{}"), ex.what());
 		wxMessageDialog dialog(this, msg, _("Error"), wxOK | wxCENTRE | wxICON_ERROR);
 		dialog.ShowModal();
 		exit(0);
@@ -41,6 +51,13 @@ VulkanCanvas::~VulkanCanvas()
 {
 	Unbind(wxEVT_PAINT, &VulkanCanvas::OnPaint, this);
 	Unbind(wxEVT_SIZE, &VulkanCanvas::OnResize, this);
+
+	if(!m_is_main_window)
+	{
+		VulkanRenderer* vkr = (VulkanRenderer*)g_renderer.get();
+		if(vkr)
+			vkr->StopUsingPadAndWait();
+	}
 }
 
 void VulkanCanvas::OnPaint(wxPaintEvent& event)
@@ -50,15 +67,17 @@ void VulkanCanvas::OnPaint(wxPaintEvent& event)
 void VulkanCanvas::OnResize(wxSizeEvent& event)
 {
 	const wxSize size = GetSize();
-	if (size.GetWidth() == 0 || size.GetHeight() == 0) 
+	if (size.GetWidth() == 0 || size.GetHeight() == 0)
 		return;
 
+#if BOOST_OS_LINUX && HAS_WAYLAND
+	if(m_subsurface)
+	{
+		auto sRect = GetScreenRect();
+		m_subsurface->setSize(sRect.GetX(), sRect.GetY(), sRect.GetWidth(), sRect.GetHeight());
+	}
+#endif
+
 	const wxRect refreshRect(size);
 	RefreshRect(refreshRect, false);
-
-	if (g_renderer == nullptr)
-		return;
-
-	auto vulkan_renderer = VulkanRenderer::GetInstance();
-	vulkan_renderer->ResizeSwapchain({ size.x, size.y }, m_is_main_window);
-}
\ No newline at end of file
+}
diff --git a/src/gui/canvas/VulkanCanvas.h b/src/gui/canvas/VulkanCanvas.h
index ecc7e744..13d03a1e 100644
--- a/src/gui/canvas/VulkanCanvas.h
+++ b/src/gui/canvas/VulkanCanvas.h
@@ -7,10 +7,11 @@
 #include "Cafe/HW/Latte/Renderer/Vulkan/VulkanAPI.h"
 #include <set>
 
-
-
 class VulkanCanvas : public IRenderCanvas, public wxWindow
 {
+#if BOOST_OS_LINUX && HAS_WAYLAND
+	std::unique_ptr<class wxWlSubsurface> m_subsurface;
+#endif
 public:
 	VulkanCanvas(wxWindow* parent, const wxSize& size, bool is_main_window);
 	~VulkanCanvas();
diff --git a/src/gui/components/wxDownloadManagerList.cpp b/src/gui/components/wxDownloadManagerList.cpp
index 29e2c262..d447310c 100644
--- a/src/gui/components/wxDownloadManagerList.cpp
+++ b/src/gui/components/wxDownloadManagerList.cpp
@@ -25,9 +25,8 @@
 
 wxDEFINE_EVENT(wxEVT_REMOVE_ENTRY, wxCommandEvent);
 
-
 wxDownloadManagerList::wxDownloadManagerList(wxWindow* parent, wxWindowID id)
-	: wxListCtrl(parent, id, wxDefaultPosition, wxDefaultSize, wxLC_REPORT | wxLC_VIRTUAL)
+	: wxListView(parent, id, wxDefaultPosition, wxDefaultSize, wxLC_REPORT | wxLC_VIRTUAL)
 {
 	AddColumns();
 
@@ -48,11 +47,13 @@ wxDownloadManagerList::wxDownloadManagerList(wxWindow* parent, wxWindowID id)
 	Bind(wxEVT_REMOVE_ITEM, &wxDownloadManagerList::OnRemoveItem, this);
 	Bind(wxEVT_REMOVE_ENTRY, &wxDownloadManagerList::OnRemoveEntry, this);
 	Bind(wxEVT_CLOSE_WINDOW, &wxDownloadManagerList::OnClose, this);
+
+	ShowSortIndicator(ColumnName);
 }
 
 boost::optional<const wxDownloadManagerList::TitleEntry&> wxDownloadManagerList::GetSelectedTitleEntry() const
 {
-	const auto selection = GetNextItem(-1, wxLIST_NEXT_ALL, wxLIST_STATE_SELECTED);
+	const auto selection = GetFirstSelected();
 	if (selection != wxNOT_FOUND)
 	{
 		const auto tmp = GetTitleEntry(selection);
@@ -65,7 +66,7 @@ boost::optional<const wxDownloadManagerList::TitleEntry&> wxDownloadManagerList:
 
 boost::optional<wxDownloadManagerList::TitleEntry&> wxDownloadManagerList::GetSelectedTitleEntry()
 {
-	const auto selection = GetNextItem(-1, wxLIST_NEXT_ALL, wxLIST_STATE_SELECTED);
+	const auto selection = GetFirstSelected();
 	if (selection != wxNOT_FOUND)
 	{
 		const auto tmp = GetTitleEntry(selection);
@@ -218,16 +219,7 @@ void wxDownloadManagerList::OnColumnClick(wxListEvent& event)
 {
 	const int column = event.GetColumn();
 
-	if (column == m_sort_by_column)
-	{
-		m_sort_less = !m_sort_less;
-	}
-	else
-	{
-		m_sort_by_column = column;
-		m_sort_less = true;
-	}
-	SortEntries();
+	SortEntries(column);
 	event.Skip();
 }
 
@@ -324,7 +316,7 @@ void wxDownloadManagerList::OnContextMenu(wxContextMenuEvent& event)
 	wxMenu menu;
 	menu.Bind(wxEVT_COMMAND_MENU_SELECTED, &wxDownloadManagerList::OnContextMenuSelected, this);
 
-	const auto selection = GetNextItem(-1, wxLIST_NEXT_ALL, wxLIST_STATE_SELECTED);
+	const auto selection = GetFirstSelected();
 	if (selection == wxNOT_FOUND)
 		return;
 
@@ -379,8 +371,8 @@ void wxDownloadManagerList::OnContextMenuSelected(wxCommandEvent& event)
 	// still doing work
 	if (m_context_worker.valid() && !future_is_ready(m_context_worker))
 		return;
-	
-	const auto selection = GetNextItem(-1, wxLIST_NEXT_ALL, wxLIST_STATE_SELECTED);
+
+	const auto selection = GetFirstSelected();
 	if (selection == wxNOT_FOUND)
 		return;
 
@@ -432,13 +424,11 @@ wxString wxDownloadManagerList::GetTitleEntryText(const TitleEntry& entry, ItemC
 	switch (column)
 	{
 	case ColumnTitleId:
-		return wxStringFormat2("{:08x}-{:08x}", (uint32)(entry.titleId >> 32), (uint32)(entry.titleId & 0xFFFFFFFF));
+		return formatWxString("{:08x}-{:08x}", (uint32) (entry.titleId >> 32), (uint32) (entry.titleId & 0xFFFFFFFF));
 	case ColumnName:
-	{
 		return entry.name;
-	}
 	case ColumnType:
-		return wxStringFormat2("{}", entry.type);
+		return GetTranslatedTitleEntryType(entry.type);
 	case ColumnVersion:
 	{
 		// dont show version for base game unless it is not v0
@@ -446,7 +436,7 @@ wxString wxDownloadManagerList::GetTitleEntryText(const TitleEntry& entry, ItemC
 			return "";
 		if (entry.type == EntryType::DLC && entry.version == 0)
 			return "";
-		return wxStringFormat2("v{}", entry.version);
+		return formatWxString("v{}", entry.version);
 	}
 	case ColumnProgress:
 	{
@@ -454,11 +444,11 @@ wxString wxDownloadManagerList::GetTitleEntryText(const TitleEntry& entry, ItemC
 		{
 			if (entry.progress >= 1000)
 				return "100%";
-			return wxStringFormat2("{:.1f}%", (float)entry.progress / 10.0f); // one decimal
+			return formatWxString("{:.1f}%", (float) entry.progress / 10.0f); // one decimal
 		}
 		else if (entry.status == TitleDownloadStatus::Installing || entry.status == TitleDownloadStatus::Checking || entry.status == TitleDownloadStatus::Verifying)
 		{
-			return wxStringFormat2("{0}/{1}", entry.progress, entry.progressMax); // number of processed files/content files
+			return formatWxString("{0}/{1}", entry.progress, entry.progressMax); // number of processed files/content files
 		}
 		return "";
 	}
@@ -503,6 +493,21 @@ wxString wxDownloadManagerList::GetTitleEntryText(const TitleEntry& entry, ItemC
 	return wxEmptyString;
 }
 
+wxString wxDownloadManagerList::GetTranslatedTitleEntryType(EntryType type)
+{
+	switch (type)
+	{
+		case EntryType::Base:
+			return _("base");
+		case EntryType::Update:
+			return _("update");
+		case EntryType::DLC:
+			return _("DLC");
+		default:
+			return std::to_string(static_cast<std::underlying_type_t<EntryType>>(type));
+	}
+}
+
 void wxDownloadManagerList::AddOrUpdateTitle(TitleEntryData_t* obj)
 {
 	const auto& data = obj->GetData();
@@ -543,7 +548,7 @@ void wxDownloadManagerList::UpdateTitleStatusDepr(TitleEntryData_t* obj, const w
 		}
 	}
 
-	forceLogDebug_printf("cant update title status of %llx", data.titleId);
+	cemuLog_logDebug(LogType::Force, "cant update title status of {:x}", data.titleId);
 }
 
 int wxDownloadManagerList::AddImage(const wxImage& image) const
@@ -608,24 +613,31 @@ bool wxDownloadManagerList::SortFunc(std::span<int> sortColumnOrder, const Type_
 
 #include <boost/container/small_vector.hpp>
 
-void wxDownloadManagerList::SortEntries()
+void wxDownloadManagerList::SortEntries(int column)
 {
 	boost::container::small_vector<int, 12> s_SortColumnOrder{ ColumnName, ColumnType, ColumnVersion, ColumnTitleId, ColumnProgress };
 
-	if (m_sort_by_column != -1)
+	bool ascending;
+	if (column == -1)
 	{
-		// prioritize column by moving it to first position in the column sort order list
-		s_SortColumnOrder.erase(std::remove(s_SortColumnOrder.begin(), s_SortColumnOrder.end(), m_sort_by_column), s_SortColumnOrder.end());
-		s_SortColumnOrder.insert(s_SortColumnOrder.begin(), m_sort_by_column);
+		column = GetSortIndicator();
+		if (column == -1)
+			column = ColumnName;
+		ascending = IsAscendingSortIndicator();
 	}
+	else
+		ascending = GetUpdatedAscendingSortIndicator(column);
+
+	// prioritize column by moving it to first position in the column sort order list
+	s_SortColumnOrder.erase(std::remove(s_SortColumnOrder.begin(), s_SortColumnOrder.end(), column), s_SortColumnOrder.end());
+	s_SortColumnOrder.insert(s_SortColumnOrder.begin(), column);
 
 	std::sort(m_sorted_data.begin(), m_sorted_data.end(),
-		[this, &s_SortColumnOrder](const Type_t& v1, const Type_t& v2) -> bool
-		{
-			const bool result = SortFunc({ s_SortColumnOrder.data(), s_SortColumnOrder.size() }, v1, v2);
-			return m_sort_less ? result : !result;
-		});
-	
+			  [this, &s_SortColumnOrder, ascending](const Type_t& v1, const Type_t& v2) -> bool {
+				  return ascending ? SortFunc(s_SortColumnOrder, v1, v2) : SortFunc(s_SortColumnOrder, v2, v1);
+			  });
+
+	ShowSortIndicator(column, ascending);
 	RefreshPage();
 }
 
diff --git a/src/gui/components/wxDownloadManagerList.h b/src/gui/components/wxDownloadManagerList.h
index 0af5b082..4febb461 100644
--- a/src/gui/components/wxDownloadManagerList.h
+++ b/src/gui/components/wxDownloadManagerList.h
@@ -9,7 +9,7 @@
 #include <utility>
 #include <vector>
 
-class wxDownloadManagerList : public wxListCtrl
+class wxDownloadManagerList : public wxListView
 {
 	friend class TitleManager;
 public:
@@ -49,7 +49,7 @@ public:
 		// error state?
 	};
 
-	void SortEntries();
+	void SortEntries(int column = -1);
 	void RefreshPage();
 	void Filter(const wxString& filter);
 	void Filter2(bool showTitles, bool showUpdates, bool showInstalled);
@@ -138,9 +138,6 @@ private:
 	std::vector<ItemDataPtr> m_data;
 	std::vector<std::reference_wrapper<ItemData>> m_sorted_data;
 
-	int m_sort_by_column = ItemColumn::ColumnName;
-	bool m_sort_less = true;
-
 	bool m_filterShowTitles = true;
 	bool m_filterShowUpdates = true;
 	bool m_filterShowInstalled = true;
@@ -150,25 +147,6 @@ private:
 	bool SortFunc(std::span<int> sortColumnOrder, const Type_t& v1, const Type_t& v2);
 
 	static wxString GetTitleEntryText(const TitleEntry& entry, ItemColumn column);
+	static wxString GetTranslatedTitleEntryType(EntryType entryType);
 	std::future<bool> m_context_worker;
 };
-
-template <>
-struct fmt::formatter<wxDownloadManagerList::EntryType> : formatter<string_view>
-{
-	using base = fmt::formatter<fmt::string_view>;
-	template <typename FormatContext>
-	auto format(const wxDownloadManagerList::EntryType& type, FormatContext& ctx)
-	{
-		switch (type)
-		{
-		case wxDownloadManagerList::EntryType::Base:
-			return base::format("base", ctx);
-		case wxDownloadManagerList::EntryType::Update:
-			return base::format("update", ctx);
-		case wxDownloadManagerList::EntryType::DLC:
-			return base::format("DLC", ctx);
-		}
-		return base::format(std::to_string(static_cast<std::underlying_type_t<wxDownloadManagerList::EntryType>>(type)), ctx);
-	}
-};
\ No newline at end of file
diff --git a/src/gui/components/wxGameList.cpp b/src/gui/components/wxGameList.cpp
index 39eeb100..e30b16f5 100644
--- a/src/gui/components/wxGameList.cpp
+++ b/src/gui/components/wxGameList.cpp
@@ -6,6 +6,7 @@
 
 #include <numeric>
 
+#include <wx/listctrl.h>
 #include <wx/wupdlock.h>
 #include <wx/menu.h>
 #include <wx/mstream.h>
@@ -13,6 +14,11 @@
 #include <wx/textdlg.h>
 #include <wx/stattext.h>
 #include <wx/sizer.h>
+#include <wx/wfstream.h>
+#include <wx/imagpng.h>
+#include <wx/string.h>
+#include <wx/utils.h>
+#include <wx/clipbrd.h>
 
 #include <boost/algorithm/string.hpp>
 #include <boost/tokenizer.hpp>
@@ -30,6 +36,18 @@
 
 #include "Cafe/IOSU/PDM/iosu_pdm.h" // for last played and play time
 
+#if BOOST_OS_WINDOWS
+// for shortcut creation
+#include <windows.h>
+#include <winnls.h>
+#include <shobjidl.h>
+#include <objbase.h>
+#include <objidl.h>
+#include <shlguid.h>
+#include <shlobj.h>
+#include <wrl/client.h>
+#endif
+
 // public events
 wxDEFINE_EVENT(wxEVT_OPEN_SETTINGS, wxCommandEvent);
 wxDEFINE_EVENT(wxEVT_GAMELIST_BEGIN_UPDATE, wxCommandEvent);
@@ -47,10 +65,92 @@ void _stripPathFilename(fs::path& path)
 		path = path.parent_path();
 }
 
-wxGameList::wxGameList(wxWindow* parent, wxWindowID id)
-	: wxListCtrl(parent, id, wxDefaultPosition, wxDefaultSize, GetStyleFlags(Style::kList)), m_style(Style::kList)
+std::list<fs::path> _getCachesPaths(const TitleId& titleId)
 {
-	CreateListColumns();
+	std::list<fs::path> cachePaths{
+		ActiveSettings::GetCachePath(L"shaderCache/driver/vk/{:016x}.bin", titleId),
+		ActiveSettings::GetCachePath(L"shaderCache/precompiled/{:016x}_spirv.bin", titleId),
+		ActiveSettings::GetCachePath(L"shaderCache/precompiled/{:016x}_gl.bin", titleId),
+		ActiveSettings::GetCachePath(L"shaderCache/transferable/{:016x}_shaders.bin", titleId),
+		ActiveSettings::GetCachePath(L"shaderCache/transferable/{:016x}_vkpipeline.bin", titleId)};
+
+	cachePaths.remove_if(
+		[](const fs::path& cachePath)
+		{
+			std::error_code ec;
+			return !fs::exists(cachePath, ec);
+		});
+
+	return cachePaths;
+}
+
+// Convert PNG to Apple icon image format
+bool writeICNS(const fs::path& pngPath, const fs::path& icnsPath) {
+	// Read PNG file
+	std::ifstream pngFile(pngPath, std::ios::binary);
+	if (!pngFile)
+		return false;
+
+	// Get PNG size
+	pngFile.seekg(0, std::ios::end);
+	uint32 pngSize = static_cast<uint32>(pngFile.tellg());
+	pngFile.seekg(0, std::ios::beg);
+
+	// Calculate total file size (header + size + type + data)
+	uint32 totalSize = 8 + 8 + pngSize;
+
+	// Create output file
+	std::ofstream icnsFile(icnsPath, std::ios::binary);
+	if (!icnsFile)
+		return false;
+
+	// Write ICNS header
+	icnsFile.put(0x69); // 'i'
+	icnsFile.put(0x63); // 'c'
+	icnsFile.put(0x6e); // 'n'
+	icnsFile.put(0x73); // 's'
+
+	// Write total file size (big endian)
+	icnsFile.put((totalSize >> 24) & 0xFF);
+	icnsFile.put((totalSize >> 16) & 0xFF);
+	icnsFile.put((totalSize >> 8) & 0xFF);
+	icnsFile.put(totalSize & 0xFF);
+
+	// Write icon type (ic07 = 128x128 PNG)
+	icnsFile.put(0x69); // 'i'
+	icnsFile.put(0x63); // 'c'
+	icnsFile.put(0x30); // '0'
+	icnsFile.put(0x37); // '7'
+
+	// Write PNG size (big endian)
+	icnsFile.put((pngSize >> 24) & 0xFF);
+	icnsFile.put((pngSize >> 16) & 0xFF);
+	icnsFile.put((pngSize >> 8) & 0xFF);
+	icnsFile.put(pngSize & 0xFF);
+
+	// Copy PNG data
+	icnsFile << pngFile.rdbuf();
+
+	return true;
+}
+
+wxGameList::wxGameList(wxWindow* parent, wxWindowID id)
+	: wxListView(parent, id, wxDefaultPosition, wxDefaultSize, GetStyleFlags(Style::kList)), m_style(Style::kList)
+{
+	const auto& config = GetConfig();
+
+	InsertColumn(ColumnHiddenName, "", wxLIST_FORMAT_LEFT, 0);
+	if(config.show_icon_column)
+		InsertColumn(ColumnIcon, _("Icon"), wxLIST_FORMAT_LEFT, kListIconWidth);
+	else
+		InsertColumn(ColumnIcon, _("Icon"), wxLIST_FORMAT_LEFT, 0);
+	InsertColumn(ColumnName, _("Game"), wxLIST_FORMAT_LEFT, config.column_width.name);
+	InsertColumn(ColumnVersion, _("Version"), wxLIST_FORMAT_RIGHT, config.column_width.version);
+	InsertColumn(ColumnDLC, _("DLC"), wxLIST_FORMAT_RIGHT, config.column_width.dlc);
+	InsertColumn(ColumnGameTime, _("You've played"), wxLIST_FORMAT_LEFT, config.column_width.game_time);
+	InsertColumn(ColumnGameStarted, _("Last played"), wxLIST_FORMAT_LEFT, config.column_width.game_started);
+	InsertColumn(ColumnRegion, _("Region"), wxLIST_FORMAT_LEFT, config.column_width.region);
+    InsertColumn(ColumnTitleID, _("Title ID"), wxLIST_FORMAT_LEFT, config.column_width.title_id);
 
 	const char transparent_bitmap[kIconWidth * kIconWidth * 4] = {0};
 	wxBitmap blank(transparent_bitmap, kIconWidth, kIconWidth);
@@ -71,8 +171,8 @@ wxGameList::wxGameList(wxWindow* parent, wxWindowID id)
 	m_tooltip_window->SetBackgroundColour(wxSystemSettings::GetColour(wxSYS_COLOUR_INFOBK));
 	m_tooltip_window->SetSizerAndFit(tooltip_sizer);
 	m_tooltip_window->Hide();
-	
-	m_tooltip_timer = new wxTimer(this);	
+
+	m_tooltip_timer = new wxTimer(this);
 
 	Bind(wxEVT_CLOSE_WINDOW, &wxGameList::OnClose, this);
 	Bind(wxEVT_MOTION, &wxGameList::OnMouseMove, this);
@@ -87,12 +187,15 @@ wxGameList::wxGameList(wxWindow* parent, wxWindowID id)
 	Bind(wxEVT_LIST_COL_BEGIN_DRAG, &wxGameList::OnColumnBeginResize, this);
 	Bind(wxEVT_LIST_COL_END_DRAG, &wxGameList::OnColumnResize, this);
 	Bind(wxEVT_LIST_COL_RIGHT_CLICK, &wxGameList::OnColumnRightClick, this);
+	Bind(wxEVT_SIZE, &wxGameList::OnGameListSize, this);
 
 	m_callbackIdTitleList = CafeTitleList::RegisterCallback([](CafeTitleListCallbackEvent* evt, void* ctx) { ((wxGameList*)ctx)->HandleTitleListCallback(evt); }, this);
 
 	// start async worker (for icon loading)
 	m_async_worker_active = true;
 	m_async_worker_thread = std::thread(&wxGameList::AsyncWorkerThread, this);
+
+	ShowSortIndicator(ColumnName);
 }
 
 wxGameList::~wxGameList()
@@ -124,21 +227,101 @@ void wxGameList::LoadConfig()
 	if (!config.game_list_column_order.empty())
 	{
 		wxArrayInt order;
-		order.reserve(ColumnFavorite);
-		
+		order.reserve(ColumnCounts);
+
 		const auto order_string = std::string_view(config.game_list_column_order).substr(1);
-		
+
 		const boost::char_separator<char> sep(",");
 		boost::tokenizer tokens(order_string.begin(), order_string.end(), sep);
 		for(const auto& token : tokens)
 		{
 			order.push_back(ConvertString<int>(token, 10));
 		}
-		
-		#ifdef wxHAS_LISTCTRL_COLUMN_ORDER
-		if(order.GetCount() == ColumnFavorite)
+
+#ifdef wxHAS_LISTCTRL_COLUMN_ORDER
+		if(order.GetCount() == ColumnCounts)
 			SetColumnsOrder(order);
-		#endif
+#endif
+	}
+}
+
+void wxGameList::OnGameListSize(wxSizeEvent &event)
+{
+	event.Skip();
+
+	// when using a sizer-based layout, do not change the size of the wxComponent in its own wxSizeEvent handler to avoid some UI issues.
+	int last_col_index = 0;
+	for(int i = GetColumnCount() - 1; i > 0; i--)
+	{
+#ifdef wxHAS_LISTCTRL_COLUMN_ORDER
+		if(GetColumnWidth(GetColumnIndexFromOrder(i)) > 0) 
+		{
+			last_col_index = GetColumnIndexFromOrder(i);
+			break;
+		}
+#else
+		if(GetColumnWidth(i) > 0) 
+		{
+			last_col_index = i;
+			break;
+		}
+#endif
+	}
+	wxListEvent column_resize_event(wxEVT_LIST_COL_END_DRAG);
+	column_resize_event.SetColumn(last_col_index);
+	wxPostEvent(this, column_resize_event);
+}
+
+void wxGameList::AdjustLastColumnWidth()
+{
+	wxWindowUpdateLocker windowlock(this);
+	int last_col_index = 0;
+	int last_col_width = GetClientSize().GetWidth();
+	for (int i = 1; i < GetColumnCount(); i++)
+	{
+#ifdef wxHAS_LISTCTRL_COLUMN_ORDER
+		if (GetColumnWidth(GetColumnIndexFromOrder(i)) > 0)
+		{
+			last_col_index = GetColumnIndexFromOrder(i);
+			last_col_width -= GetColumnWidth(last_col_index);
+		}
+#else
+		if (GetColumnWidth(i) > 0)
+		{
+			last_col_index = i;
+			last_col_width -= GetColumnWidth(i);
+		}
+#endif
+	}
+	last_col_width += GetColumnWidth(last_col_index);
+	if (last_col_width < GetColumnDefaultWidth(last_col_index)) // keep a minimum width
+		last_col_width = GetColumnDefaultWidth(last_col_index);
+	SetColumnWidth(last_col_index, last_col_width);
+}
+
+// todo: scale all columns using a ratio instead of hardcoding exact widths
+int wxGameList::GetColumnDefaultWidth(int column)
+{
+	switch (column)
+	{
+	case ColumnIcon:
+		return kListIconWidth;
+	case ColumnName:
+		return DefaultColumnSize::name;
+	case ColumnVersion:
+		return DefaultColumnSize::version;
+	case ColumnDLC:
+		return DefaultColumnSize::dlc;
+	case ColumnGameTime:
+		return DefaultColumnSize::game_time;
+	case ColumnGameStarted:
+		return DefaultColumnSize::game_started;
+	case ColumnRegion:
+		return DefaultColumnSize::region;
+    case ColumnTitleID:
+        return DefaultColumnSize::title_id;
+	default:
+		return 80;
 	}
 }
 
@@ -198,7 +381,7 @@ std::string wxGameList::GetNameByTitleId(uint64 titleId)
 		return "Unknown title";
 	std::string name;
 	if (!GetConfig().GetGameListCustomName(titleId, name))
-		name = titleInfo.GetTitleName();
+		name = titleInfo.GetMetaTitleName();
 	m_name_cache.emplace(titleId, name);
 	return name;
 }
@@ -209,12 +392,12 @@ void wxGameList::SetStyle(Style style, bool save)
 		return;
 
 	wxWindowUpdateLocker updatelock(this);
-	
+
 	m_style = style;
 	SetWindowStyleFlag(GetStyleFlags(m_style));
-	
+
 	uint64 selected_title_id = 0;
-	auto selection = GetNextItem(wxNOT_FOUND, wxLIST_NEXT_ALL, wxLIST_STATE_SELECTED);
+	auto selection = GetFirstSelected();
 	if (selection != wxNOT_FOUND)
 	{
 		selected_title_id = (uint64)GetItemData(selection);
@@ -230,15 +413,15 @@ void wxGameList::SetStyle(Style style, bool save)
 		wxListCtrl::SetImageList(m_image_list_small, wxIMAGE_LIST_NORMAL);
 		break;
 	}
-	
+
 	ReloadGameEntries();
 	SortEntries();
 	UpdateItemColors();
 
 	if(selection != wxNOT_FOUND)
 	{
-		SetItemState(selection, wxLIST_STATE_SELECTED | wxLIST_STATE_FOCUSED, wxLIST_STATE_SELECTED | wxLIST_STATE_FOCUSED);
-		EnsureVisible(selection);
+		Select(selection);
+		Focus(selection);
 	}
 
 	if(save)
@@ -269,158 +452,144 @@ long wxGameList::GetStyleFlags(Style style) const
 
 void wxGameList::UpdateItemColors(sint32 startIndex)
 {
-	wxWindowUpdateLocker lock(this);
-	for (int i = startIndex; i < GetItemCount(); ++i)
-	{
-		const auto titleId = (uint64)GetItemData(i);
-		if (GetConfig().IsGameListFavorite(titleId))//entry->favorite)
+    wxWindowUpdateLocker lock(this);
+
+	wxColour bgColourPrimary = GetBackgroundColour();
+	wxColour bgColourSecondary = wxHelper::CalculateAccentColour(bgColourPrimary);
+
+    for (int i = startIndex; i < GetItemCount(); ++i)
+    {
+        const auto titleId = (uint64)GetItemData(i);
+		if (GetConfig().IsGameListFavorite(titleId))
+		{
 			SetItemBackgroundColour(i, kFavoriteColor);
+			SetItemTextColour(i, 0x000000UL);
+		}
 		else if ((i&1) != 0)
-			SetItemBackgroundColour(i, kSecondColor);
+		{
+            SetItemBackgroundColour(i, bgColourPrimary);
+            SetItemTextColour(i, wxSystemSettings::GetColour(wxSYS_COLOUR_WINDOWTEXT));
+		}
 		else
-			SetItemBackgroundColour(i, 0xFFFFFFUL);
+		{
+            SetItemBackgroundColour(i, bgColourSecondary);
+            SetItemTextColour(i, wxSystemSettings::GetColour(wxSYS_COLOUR_WINDOWTEXT));
+		}
 	}
 }
 
-static inline int strongorder_to_int(const std::strong_ordering &wo)
+static inline int order_to_int(const std::weak_ordering &wo)
 {
-	/* No easy conversion seems to exists in C++20 */
-	if (wo < 0)
+	// no easy conversion seems to exists in C++20
+	if (wo == std::weak_ordering::less)
 		return -1;
-	else if (wo > 0)
+	else if (wo == std::weak_ordering::greater)
 		return 1;
 	return 0;
 }
 
-int wxGameList::SortComparator(uint64 titleId1, uint64 titleId2, SortData* sortData)
+std::weak_ordering wxGameList::SortComparator(uint64 titleId1, uint64 titleId2, SortData* sortData)
 {
-	const auto isFavoriteA = GetConfig().IsGameListFavorite(titleId1);
-	const auto isFavoriteB = GetConfig().IsGameListFavorite(titleId2);
-	const auto& name1 = GetNameByTitleId(titleId1);
-	const auto& name2 = GetNameByTitleId(titleId2);
+	auto titleLastPlayed = [](uint64_t id)
+	{
+	  iosu::pdm::GameListStat playTimeStat{};
+	  iosu::pdm::GetStatForGamelist(id, playTimeStat);
+	  return playTimeStat;
+	};
 
-	if(sortData->dir > 0)
-		return strongorder_to_int(std::tie(isFavoriteB, name1) <=> std::tie(isFavoriteA, name2));
-	else
-		return strongorder_to_int(std::tie(isFavoriteB, name2) <=> std::tie(isFavoriteA, name1));
+	auto titlePlayMinutes = [](uint64_t id)
+	{
+	  iosu::pdm::GameListStat playTimeStat;
+	  if (!iosu::pdm::GetStatForGamelist(id, playTimeStat))
+		  return 0u;
+	  return playTimeStat.numMinutesPlayed;
+	};
+
+	auto titleRegion = [](uint64_t id)
+	{
+	  return CafeTitleList::GetGameInfo(id).GetRegion();
+	};
+
+	switch(sortData->column)
+	{
+	default:
+	case ColumnName:
+	{
+		const auto isFavoriteA = GetConfig().IsGameListFavorite(titleId1);
+		const auto isFavoriteB = GetConfig().IsGameListFavorite(titleId2);
+		const auto nameA = GetNameByTitleId(titleId1);
+		const auto nameB = GetNameByTitleId(titleId2);
+		return std::tie(isFavoriteB, nameA) <=> std::tie(isFavoriteA, nameB);
+	}
+	case ColumnGameStarted:
+		return titleLastPlayed(titleId1).last_played <=> titleLastPlayed(titleId2).last_played;
+	case ColumnGameTime:
+		return titlePlayMinutes(titleId1) <=> titlePlayMinutes(titleId2);
+	case ColumnRegion:
+		return titleRegion(titleId1) <=> titleRegion(titleId2);
+	case ColumnTitleID:
+		return titleId1 <=> titleId2;
+	}
+	// unreachable
+	cemu_assert_debug(false);
+	return std::weak_ordering::less;
 }
 
 int wxGameList::SortFunction(wxIntPtr item1, wxIntPtr item2, wxIntPtr sortData)
 {
 	const auto sort_data = (SortData*)sortData;
-	const int dir = sort_data->dir;
-	
-	return sort_data->thisptr->SortComparator((uint64)item1, (uint64)item2, sort_data);
+	return sort_data->dir * order_to_int(sort_data->thisptr->SortComparator((uint64)item1, (uint64)item2, sort_data));
 }
 
 void wxGameList::SortEntries(int column)
 {
+	bool ascending;
 	if (column == -1)
-		column = s_last_column;
-	else
 	{
-
-		if (s_last_column == column)
-		{
-			s_last_column = 0;
-			s_direction = -1;
-		}
-		else
-		{
-			s_last_column = column;
-			s_direction = 1;
-		}
+		column = GetSortIndicator();
+		if (column == -1)
+			column = ColumnName;
+		ascending = IsAscendingSortIndicator();
 	}
-	
+	else
+		ascending = GetUpdatedAscendingSortIndicator(column);
+
 	switch (column)
 	{
 	case ColumnName:
 	case ColumnGameTime:
 	case ColumnGameStarted:
 	case ColumnRegion:
+	case ColumnTitleID:
 	{
-		SortData data{ this, column, s_direction };
+		SortData data{this, ItemColumns{column}, ascending ? 1 : -1};
 		SortItems(SortFunction, (wxIntPtr)&data);
+		ShowSortIndicator(column, ascending);
 		break;
 	}
 	}
 }
 
-void wxGameList::CreateListColumns()
-{
-	DeleteAllColumns();
-	
-	const auto& config = GetConfig();
-	wxListItem col0;
-	col0.SetId(ColumnHiddenName);
-	col0.SetWidth(0);
-	InsertColumn(ColumnHiddenName, col0);
-
-	wxListItem col1;
-	col1.SetId(ColumnIcon);
-	col1.SetWidth(kListIconWidth);
-	InsertColumn(ColumnIcon, col1);
-
-	wxListItem col2;
-	col2.SetId(ColumnName);
-	col2.SetText(_("Game"));
-	col2.SetWidth(config.column_width.name);
-	InsertColumn(ColumnName, col2);
-
-	wxListItem col3;
-	col3.SetId(ColumnVersion);
-	col3.SetText(_("Version"));
-	col3.SetWidth(config.column_width.version);
-	col3.SetAlign(wxLIST_FORMAT_RIGHT);
-	InsertColumn(ColumnVersion, col3);
-
-	wxListItem col4;
-	col4.SetId(ColumnDLC);
-	col4.SetText(_("DLC"));
-	col4.SetWidth(config.column_width.dlc);
-	col4.SetAlign(wxLIST_FORMAT_RIGHT);
-	InsertColumn(ColumnDLC, col4);
-
-	wxListItem col5;
-	col5.SetId(ColumnGameTime);
-	col5.SetText(_("You've played"));
-	col5.SetWidth(config.column_width.game_time);
-	InsertColumn(ColumnGameTime, col5);
-
-	wxListItem col6;
-	col6.SetId(ColumnGameStarted);
-	col6.SetText(_("Last played"));
-	col6.SetWidth(config.column_width.game_started);
-	InsertColumn(ColumnGameStarted, col6);
-	
-	wxListItem col7;
-	col7.SetId(ColumnRegion);
-	col7.SetText(_("Region"));
-	col7.SetWidth(config.column_width.region);
-	InsertColumn(ColumnRegion, col7);
-}
-
 void wxGameList::OnKeyDown(wxListEvent& event)
 {
 	event.Skip();
 	if (m_style != Style::kList)
 		return;
-	
-	const auto keycode = std::tolower(event.m_code);
+
+	const auto keycode = event.GetKeyCode();
 	if (keycode == WXK_LEFT)
 	{
 		const auto item_count = GetItemCount();
 		if (item_count > 0)
 		{
-			auto selection = (int)GetNextItem(wxNOT_FOUND, wxLIST_NEXT_ALL, wxLIST_STATE_SELECTED);
+			auto selection = (int)GetFirstSelected();
 			if (selection == wxNOT_FOUND)
 				selection = 0;
 			else
 				selection = std::max(0, selection - GetCountPerPage());
 
-			SetItemState(wxNOT_FOUND, 0, wxLIST_STATE_SELECTED);
-			SetItemState(selection, wxLIST_STATE_SELECTED | wxLIST_STATE_FOCUSED, wxLIST_STATE_SELECTED | wxLIST_STATE_FOCUSED);
-			EnsureVisible(selection);
+			Select(selection);
+			Focus(selection);
 		}
 	}
 	else if (keycode == WXK_RIGHT)
@@ -428,29 +597,27 @@ void wxGameList::OnKeyDown(wxListEvent& event)
 		const auto item_count = GetItemCount();
 		if (item_count > 0)
 		{
-			auto selection = (int)GetNextItem(wxNOT_FOUND, wxLIST_NEXT_ALL, wxLIST_STATE_SELECTED);
+			auto selection = (int)GetFirstSelected();
 			if (selection == wxNOT_FOUND)
 				selection = 0;
 
 			selection = std::min(item_count - 1, selection + GetCountPerPage());
 
-			SetItemState(wxNOT_FOUND, 0, wxLIST_STATE_SELECTED);
-			SetItemState(selection, wxLIST_STATE_SELECTED | wxLIST_STATE_FOCUSED, wxLIST_STATE_SELECTED | wxLIST_STATE_FOCUSED);
-			EnsureVisible(selection);
+			Select(selection);
+			Focus(selection);
 		}
 	}
 }
 
-
 enum ContextMenuEntries
 {
 	kContextMenuRefreshGames = wxID_HIGHEST + 1,
-	
+
 	kContextMenuStart,
 	kWikiPage,
 	kContextMenuFavorite,
 	kContextMenuEditName,
-	
+
 	kContextMenuGameFolder,
 	kContextMenuSaveFolder,
 	kContextMenuUpdateFolder,
@@ -458,18 +625,26 @@ enum ContextMenuEntries
 	kContextMenuEditGraphicPacks,
 	kContextMenuEditGameProfile,
 
+	kContextMenuRemoveCache,
+
 	kContextMenuStyleList,
 	kContextMenuStyleIcon,
 	kContextMenuStyleIconSmall,
+
+    kContextMenuCreateShortcut,
+
+    kContextMenuCopyTitleName,
+    kContextMenuCopyTitleId,
+    kContextMenuCopyTitleImage
 };
 void wxGameList::OnContextMenu(wxContextMenuEvent& event)
 {
 	auto& config = GetConfig();
-	
+
 	wxMenu menu;
 	menu.Bind(wxEVT_COMMAND_MENU_SELECTED, &wxGameList::OnContextMenuSelected, this);
-	
-	const auto selection = GetNextItem(-1, wxLIST_NEXT_ALL, wxLIST_STATE_SELECTED);
+
+	const auto selection = GetFirstSelected();
 	if (selection != wxNOT_FOUND)
 	{
 		const auto title_id = (uint64)GetItemData(selection);
@@ -486,18 +661,27 @@ void wxGameList::OnContextMenu(wxContextMenuEvent& event)
 			menu.AppendSeparator();
 			menu.AppendCheckItem(kContextMenuFavorite, _("&Favorite"))->Check(isFavorite);
 			menu.Append(kContextMenuEditName, _("&Edit name"));
-			
+
 			menu.AppendSeparator();
 			menu.Append(kWikiPage, _("&Wiki page"));
 			menu.Append(kContextMenuGameFolder, _("&Game directory"));
 			menu.Append(kContextMenuSaveFolder, _("&Save directory"))->Enable(fs::is_directory(gameInfo.GetSaveFolder(), ec));
 			menu.Append(kContextMenuUpdateFolder, _("&Update directory"))->Enable(gameInfo.HasUpdate());
 			menu.Append(kContextMenuDLCFolder, _("&DLC directory"))->Enable(gameInfo.HasAOC());
-			
+
+			menu.AppendSeparator();
+			menu.Append(kContextMenuRemoveCache, _("&Remove shader caches"))->Enable(!_getCachesPaths(gameInfo.GetBaseTitleId()).empty());
+
 			menu.AppendSeparator();
 			menu.Append(kContextMenuEditGraphicPacks, _("&Edit graphic packs"));
 			menu.Append(kContextMenuEditGameProfile, _("&Edit game profile"));
-			
+
+            menu.AppendSeparator();
+            menu.Append(kContextMenuCreateShortcut, _("&Create shortcut"));
+            menu.AppendSeparator();
+            menu.Append(kContextMenuCopyTitleName, _("&Copy Title Name"));
+            menu.Append(kContextMenuCopyTitleId, _("&Copy Title ID"));
+            menu.Append(kContextMenuCopyTitleImage, _("&Copy Title Image"));
 			menu.AppendSeparator();
 		}
 	}
@@ -540,7 +724,7 @@ void wxGameList::OnContextMenuSelected(wxCommandEvent& event)
 				if(dialog.ShowModal() == wxID_OK)
 				{
 					const auto custom_name = dialog.GetValue();
-					GetConfig().SetGameListCustomName(title_id, wxHelper::MakeUTF8(custom_name));
+					GetConfig().SetGameListCustomName(title_id, custom_name.utf8_string());
 					m_name_cache.clear();
 					g_config.Save();
 					// update list entry
@@ -563,7 +747,7 @@ void wxGameList::OnContextMenuSelected(wxCommandEvent& event)
 				{
 				fs::path path(gameInfo.GetBase().GetPath());
 				_stripPathFilename(path);
-				wxLaunchDefaultBrowser(wxHelper::FromUtf8(fmt::format("file:{}", _pathToUtf8(path))));
+				wxLaunchDefaultApplication(wxHelper::FromPath(path));
 				break;
 				}
 			case kWikiPage:
@@ -581,24 +765,29 @@ void wxGameList::OnContextMenuSelected(wxCommandEvent& event)
 				}
 				break;
 				}
-				
+
 			case kContextMenuSaveFolder:
 			{
-				wxLaunchDefaultBrowser(wxHelper::FromUtf8(fmt::format("file:{}", _pathToUtf8(gameInfo.GetSaveFolder()))));
+				wxLaunchDefaultApplication(wxHelper::FromPath(gameInfo.GetSaveFolder()));
 				break;
 			}
 			case kContextMenuUpdateFolder:
 			{
 				fs::path path(gameInfo.GetUpdate().GetPath());
 				_stripPathFilename(path);
-				wxLaunchDefaultBrowser(wxHelper::FromUtf8(fmt::format("file:{}", _pathToUtf8(path))));
+				wxLaunchDefaultApplication(wxHelper::FromPath(path));
 				break;
 			}
 			case kContextMenuDLCFolder:
 			{
 				fs::path path(gameInfo.GetAOC().front().GetPath());
 				_stripPathFilename(path);
-				wxLaunchDefaultBrowser(wxHelper::FromUtf8(fmt::format("file:{}", _pathToUtf8(path))));
+				wxLaunchDefaultApplication(wxHelper::FromPath(path));
+				break;
+			}
+			case kContextMenuRemoveCache:
+			{
+				RemoveCache(_getCachesPaths(gameInfo.GetBaseTitleId()), gameInfo.GetTitleName());
 				break;
 			}
 			case kContextMenuEditGraphicPacks:
@@ -612,6 +801,43 @@ void wxGameList::OnContextMenuSelected(wxCommandEvent& event)
 				(new GameProfileWindow(GetParent(), title_id))->Show();
 				break;
 			}
+            case kContextMenuCreateShortcut:
+            {
+                CreateShortcut(gameInfo);
+                break;
+            }
+            case kContextMenuCopyTitleName:
+            {
+                if (wxTheClipboard->Open())
+                {
+                    wxTheClipboard->SetData(new wxTextDataObject(wxString::FromUTF8(gameInfo.GetTitleName())));
+                    wxTheClipboard->Close();
+                }
+                break;
+            }
+            case kContextMenuCopyTitleId:
+            {
+                if (wxTheClipboard->Open())
+                {
+                    wxTheClipboard->SetData(new wxTextDataObject(fmt::format("{:016x}", gameInfo.GetBaseTitleId())));
+                    wxTheClipboard->Close();
+                }
+                break;
+            }
+            case kContextMenuCopyTitleImage:
+            {
+                if (wxTheClipboard->Open())
+                {
+                    int icon_large;
+                    int icon_small;
+                    if (!QueryIconForTitle(title_id, icon_large, icon_small))
+                        break;
+                    auto icon = m_image_list->GetBitmap(icon_large);
+                    wxTheClipboard->SetData(new wxBitmapDataObject(icon));
+                    wxTheClipboard->Close();
+                }
+                break;
+            }
 			}
 		}
 	}
@@ -647,30 +873,32 @@ void wxGameList::OnColumnRightClick(wxListEvent& event)
 	{
 		ResetWidth = wxID_HIGHEST + 1,
 		ResetOrder,
-		
+
+		ShowIcon,
 		ShowName,
 		ShowVersion,
 		ShowDlc,
 		ShowGameTime,
 		ShowLastPlayed,
 		ShowRegion,
+        ShowTitleId
 	};
 	const int column = event.GetColumn();
 	wxMenu menu;
 	menu.SetClientObject(new wxCustomData(column));
-	
+
 	menu.Append(ResetWidth, _("Reset &width"));
 	menu.Append(ResetOrder, _("Reset &order"))	;
-	
+
 	menu.AppendSeparator();
+	menu.AppendCheckItem(ShowIcon, _("Show &icon"))->Check(GetColumnWidth(ColumnIcon) > 0);
 	menu.AppendCheckItem(ShowName, _("Show &name"))->Check(GetColumnWidth(ColumnName) > 0);
 	menu.AppendCheckItem(ShowVersion, _("Show &version"))->Check(GetColumnWidth(ColumnVersion) > 0);
 	menu.AppendCheckItem(ShowDlc, _("Show &dlc"))->Check(GetColumnWidth(ColumnDLC) > 0);
 	menu.AppendCheckItem(ShowGameTime, _("Show &game time"))->Check(GetColumnWidth(ColumnGameTime) > 0);
 	menu.AppendCheckItem(ShowLastPlayed, _("Show &last played"))->Check(GetColumnWidth(ColumnGameStarted) > 0);
-	menu.AppendCheckItem(ColumnRegion, _("Show &region"))->Check(GetColumnWidth(ColumnRegion) > 0);
-	//menu.AppendSeparator();
-	//menu.Append(ResetOrder, _("&Reset order"));
+	menu.AppendCheckItem(ShowRegion, _("Show &region"))->Check(GetColumnWidth(ColumnRegion) > 0);
+    menu.AppendCheckItem(ShowTitleId, _("Show &title ID"))->Check(GetColumnWidth(ColumnTitleID) > 0);
 
 	menu.Bind(wxEVT_COMMAND_MENU_SELECTED,
 		[this](wxCommandEvent& event) {
@@ -682,46 +910,56 @@ void wxGameList::OnColumnRightClick(wxListEvent& event)
 
 			switch (event.GetId())
 			{
+			case ShowIcon:
+				config.show_icon_column = menu->IsChecked(ShowIcon);
+				break;
 			case ShowName:
-				config.column_width.name = menu->IsChecked(ShowName) ? 500 : 0;
+				config.column_width.name = menu->IsChecked(ShowName) ? DefaultColumnSize::name : 0;
 				break;
 			case ShowVersion:
-				config.column_width.version = menu->IsChecked(ShowVersion) ? 60 : 0;
+				config.column_width.version = menu->IsChecked(ShowVersion) ? DefaultColumnSize::version : 0;
 				break;
 			case ShowDlc:
-				config.column_width.dlc = menu->IsChecked(ShowDlc) ? 50 : 0;
+				config.column_width.dlc = menu->IsChecked(ShowDlc) ? DefaultColumnSize::dlc : 0;
 				break;
 			case ShowGameTime:
-				config.column_width.game_time = menu->IsChecked(ShowGameTime) ? 140 : 0;
+				config.column_width.game_time = menu->IsChecked(ShowGameTime) ? DefaultColumnSize::game_time : 0;
 				break;
 			case ShowLastPlayed:
-				config.column_width.game_started = menu->IsChecked(ShowLastPlayed) ? 160 : 0;
+				config.column_width.game_started = menu->IsChecked(ShowLastPlayed) ? DefaultColumnSize::game_started : 0;
 				break;
-			case ColumnRegion:
-				config.column_width.region = menu->IsChecked(ColumnRegion) ? 80 : 0;
+			case ShowRegion:
+				config.column_width.region = menu->IsChecked(ShowRegion) ? DefaultColumnSize::region : 0;
 				break;
+            case ShowTitleId:
+                config.column_width.title_id = menu->IsChecked(ShowTitleId) ? DefaultColumnSize::title_id : 0;
+                break;
 			case ResetWidth:
 			{
 				switch (column)
 				{
+				case ColumnIcon:
+					break;
 				case ColumnName:
-					config.column_width.name = 500;
+					config.column_width.name = DefaultColumnSize::name;
 					break;
 				case ColumnVersion:
-					config.column_width.version = 60;
+					config.column_width.version = DefaultColumnSize::version;
 					break;
 				case ColumnDLC:
-					config.column_width.dlc = 50;
+					config.column_width.dlc = DefaultColumnSize::dlc;
 					break;
 				case ColumnGameTime:
-					config.column_width.game_time = 140;
+					config.column_width.game_time = DefaultColumnSize::game_time;
 					break;
 				case ColumnGameStarted:
-					config.column_width.game_started = 160;
+					config.column_width.game_started = DefaultColumnSize::game_started;
 					break;
 				case ColumnRegion:
-					config.column_width.region = 80;
+					config.column_width.region = DefaultColumnSize::region;
 					break;
+                case ColumnTitleID:
+                    config.column_width.title_id = DefaultColumnSize::title_id;
 				default:
 					return;
 				}
@@ -731,13 +969,14 @@ void wxGameList::OnColumnRightClick(wxListEvent& event)
 			case ResetOrder:
 			{
 				config.game_list_column_order.clear();
-				wxArrayInt order(ColumnFavorite);
+				wxArrayInt order(ColumnCounts);
 				std::iota(order.begin(), order.end(), 0);
 				#ifdef wxHAS_LISTCTRL_COLUMN_ORDER
 				SetColumnsOrder(order);
 				#endif
-				Refresh();
-				return;
+				//ApplyGameListColumnWidths();
+				//Refresh();
+				//return;
 			}
 			}
 
@@ -751,37 +990,57 @@ void wxGameList::OnColumnRightClick(wxListEvent& event)
 
 void wxGameList::ApplyGameListColumnWidths()
 {
-	auto set_width = [this](int id, int width)
-	{
-		if (width == -3)
-			wxAutosizeColumn(this, id);
-		else
-			this->SetColumnWidth(id, width);
-	};
-	
 	const auto& config = GetConfig();
 	wxWindowUpdateLocker lock(this);
-	set_width(ColumnName, config.column_width.name);
-	set_width(ColumnVersion, config.column_width.version);
-	set_width(ColumnDLC, config.column_width.dlc);
-	set_width(ColumnGameTime, config.column_width.game_time);
-	set_width(ColumnGameStarted, config.column_width.game_started);
-	set_width(ColumnRegion, config.column_width.region);
+	if(config.show_icon_column)
+		SetColumnWidth(ColumnIcon, kListIconWidth);
+	else
+		SetColumnWidth(ColumnIcon, 0);
+	SetColumnWidth(ColumnName, config.column_width.name);
+	SetColumnWidth(ColumnVersion, config.column_width.version);
+	SetColumnWidth(ColumnDLC, config.column_width.dlc);
+	SetColumnWidth(ColumnGameTime, config.column_width.game_time);
+	SetColumnWidth(ColumnGameStarted, config.column_width.game_started);
+	SetColumnWidth(ColumnRegion, config.column_width.region);
+    SetColumnWidth(ColumnTitleID, config.column_width.title_id);
+
+	AdjustLastColumnWidth();
 }
 
 void wxGameList::OnColumnBeginResize(wxListEvent& event)
 {
 	const int column = event.GetColumn();
 	const int width = GetColumnWidth(column);
-	if (width == 0)
+	int last_col_index = 0;
+	for(int i = GetColumnCount() - 1; i > 0; i--)
+	{
+#ifdef wxHAS_LISTCTRL_COLUMN_ORDER
+		if(GetColumnWidth(GetColumnIndexFromOrder(i)) > 0) 
+		{
+			last_col_index = GetColumnIndexFromOrder(i);
+			break;
+		}
+#else
+		if(GetColumnWidth(i) > 0) 
+		{
+			last_col_index = i;
+			break;
+		}
+#endif
+	}
+	if (width == 0 || column == ColumnIcon || column == last_col_index) // dont resize hidden name, icon, and last column
 		event.Veto();
 	else
 		event.Skip();
 }
+
 void wxGameList::OnColumnResize(wxListEvent& event)
 {
 	event.Skip();
 
+	if(m_style != Style::kList)
+		return;
+
 	const int column = event.GetColumn();
 	const int width = GetColumnWidth(column);
 
@@ -803,19 +1062,15 @@ void wxGameList::OnColumnResize(wxListEvent& event)
 	case ColumnGameStarted:
 		config.column_width.game_started = width;
 		break;
+	case ColumnRegion:
+		config.column_width.region = width;
+		break;
 	default:
-		return;
+		break;
 	}
 
 	g_config.Save();
-}
-
-void wxGameList::OnColumnDrag(wxListEvent& event)
-{
-	const auto column = event.GetColumn();
-	const auto width = GetColumnWidth(column);
-	if (column == ColumnHiddenName || width == 0)
-		event.Veto();
+	AdjustLastColumnWidth();
 }
 
 void wxGameList::OnClose(wxCloseEvent& event)
@@ -826,7 +1081,7 @@ void wxGameList::OnClose(wxCloseEvent& event)
 
 int wxGameList::FindInsertPosition(TitleId titleId)
 {
-	SortData data{ this, s_last_column, s_direction };
+	SortData data{this, ItemColumns(GetSortIndicator()), IsAscendingSortIndicator()};
 	const auto itemCount = GetItemCount();
 	if (itemCount == 0)
 		return 0;
@@ -843,13 +1098,11 @@ int wxGameList::FindInsertPosition(TitleId titleId)
 void wxGameList::OnGameEntryUpdatedByTitleId(wxTitleIdEvent& event)
 {
 	const auto titleId = event.GetTitleId();
-	// get GameInfo from title list
 	GameInfo2 gameInfo = CafeTitleList::GetGameInfo(titleId);
-
-	if (!gameInfo.IsValid())
+	if (!gameInfo.IsValid() || gameInfo.IsSystemDataTitle())
 	{
-		// entry no longer exists
-		// we dont need to do anything here because all delete operations should trigger a full list refresh
+		// entry no longer exists or is not a valid game
+		// we dont need to remove list entries here because all delete operations should trigger a full list refresh
 		return;
 	}
 	TitleId baseTitleId = gameInfo.GetBaseTitleId();
@@ -887,20 +1140,25 @@ void wxGameList::OnGameEntryUpdatedByTitleId(wxTitleIdEvent& event)
 			if (iosu::pdm::GetStatForGamelist(baseTitleId, playTimeStat))
 			{
 				// time played
-				uint32 timePlayed = playTimeStat.numMinutesPlayed * 60;
-				if (timePlayed == 0)
+				uint32 minutesPlayed = playTimeStat.numMinutesPlayed;
+				if (minutesPlayed == 0)
 					SetItem(index, ColumnGameTime, wxEmptyString);
-				else if (timePlayed < 60)
-					SetItem(index, ColumnGameTime, fmt::format("{} seconds", timePlayed));
-				else if (timePlayed < 60 * 60)
-					SetItem(index, ColumnGameTime, fmt::format("{} minutes", timePlayed / 60));
+				else if (minutesPlayed < 60)
+					SetItem(index, ColumnGameTime, formatWxString(wxPLURAL("{} minute", "{} minutes", minutesPlayed), minutesPlayed));
 				else
-					SetItem(index, ColumnGameTime, fmt::format("{} hours {} minutes", timePlayed / 3600, (timePlayed / 60) % 60));
+				{
+					uint32 hours = minutesPlayed / 60;
+					uint32 minutes = minutesPlayed % 60;
+					wxString hoursText = formatWxString(wxPLURAL("{} hour", "{} hours", hours), hours);
+					wxString minutesText = formatWxString(wxPLURAL("{} minute", "{} minutes", minutes), minutes);
+					SetItem(index, ColumnGameTime, hoursText + " " + minutesText);
+				}
+				
 				// last played
 				if (playTimeStat.last_played.year != 0)
 				{
 					const wxDateTime tmp((wxDateTime::wxDateTime_t)playTimeStat.last_played.day, (wxDateTime::Month)playTimeStat.last_played.month, (wxDateTime::wxDateTime_t)playTimeStat.last_played.year, 0, 0, 0, 0);
-					SetItem(index, ColumnGameStarted, tmp.FormatISODate());
+					SetItem(index, ColumnGameStarted, tmp.FormatDate());
 				}
 				else
 					SetItem(index, ColumnGameStarted, _("never"));
@@ -914,7 +1172,8 @@ void wxGameList::OnGameEntryUpdatedByTitleId(wxTitleIdEvent& event)
 
 
 		const auto region_text = fmt::format("{}", gameInfo.GetRegion());
-		SetItem(index, ColumnRegion, _(region_text));
+		SetItem(index, ColumnRegion, wxGetTranslation(region_text));
+        SetItem(index, ColumnTitleID, fmt::format("{:016x}", baseTitleId));
 	}
 	else if (m_style == Style::kIcons)
 	{
@@ -943,7 +1202,7 @@ void wxGameList::OnItemActivated(wxListEvent& event)
 		wxPostEvent(this, open_settings_event);
 		return;
 	}
-	
+
 	TitleInfo titleInfo;
 	if (!CafeTitleList::GetFirstByTitleId(item_data, titleInfo))
 		return;
@@ -974,7 +1233,7 @@ void wxGameList::OnTimer(wxTimerEvent& event)
 			//}
 		}
 	}
-		
+
 }
 
 void wxGameList::OnMouseMove(wxMouseEvent& event)
@@ -999,8 +1258,29 @@ void wxGameList::HandleTitleListCallback(CafeTitleListCallbackEvent* evt)
 	}
 }
 
+void wxGameList::RemoveCache(const std::list<fs::path>& cachePaths, const std::string& titleName)
+{
+	wxMessageDialog dialog(this, formatWxString(_("Remove the shader caches for {}?"), titleName), _("Remove shader caches"), wxCENTRE | wxYES_NO | wxICON_EXCLAMATION);
+	dialog.SetYesNoLabels(_("Yes"), _("No"));
+
+	const auto dialogResult = dialog.ShowModal();
+	if (dialogResult != wxID_YES)
+		return;
+	std::list<std::string> errs;
+	for (const fs::path& cachePath : cachePaths)
+	{
+		if (std::error_code ec; !fs::remove(cachePath, ec))
+			errs.emplace_back(fmt::format("{} : {}", cachePath.string(), ec.message()));
+	}
+	if (errs.empty())
+		wxMessageDialog(this, _("The shader caches were removed!"), _("Shader caches removed"), wxCENTRE | wxOK | wxICON_INFORMATION).ShowModal();
+	else
+		wxMessageDialog(this, formatWxString(_("Failed to remove the shader caches:\n{}"), fmt::join(errs, "\n")), _("Error"), wxCENTRE | wxOK | wxICON_ERROR).ShowModal();
+}
+
 void wxGameList::AsyncWorkerThread()
 {
+	SetThreadName("GameListWorker");
 	while (m_async_worker_active)
 	{
 		m_async_task_count.decrementWithWait();
@@ -1027,6 +1307,16 @@ void wxGameList::AsyncWorkerThread()
 		if(!titleInfo.Mount(tempMountPath, "", FSC_PRIORITY_BASE))
 			continue;
 		auto tgaData = fsc_extractFile((tempMountPath + "/meta/iconTex.tga").c_str());
+		// try iconTex.tga.gz
+		if (!tgaData)
+		{
+			tgaData = fsc_extractFile((tempMountPath + "/meta/iconTex.tga.gz").c_str());
+			if (tgaData)
+			{
+				auto decompressed = zlibDecompress(*tgaData, 70*1024);
+				std::swap(tgaData, decompressed);
+			}
+		}
 		bool iconSuccessfullyLoaded = false;
 		if (tgaData && tgaData->size() > 16)
 		{
@@ -1076,3 +1366,301 @@ bool wxGameList::QueryIconForTitle(TitleId titleId, int& icon, int& iconSmall)
 	m_icon_cache_mtx.unlock();
 	return true;
 }
+
+void wxGameList::DeleteCachedStrings() 
+{
+	m_name_cache.clear();
+}
+
+#if BOOST_OS_LINUX
+void wxGameList::CreateShortcut(GameInfo2& gameInfo)
+{
+	const auto titleId = gameInfo.GetBaseTitleId();
+	const auto titleName = wxString::FromUTF8(gameInfo.GetTitleName());
+	auto exePath = ActiveSettings::GetExecutablePath();
+	const char* flatpakId = getenv("FLATPAK_ID");
+
+	const wxString desktopEntryName = wxString::Format("%s.desktop", titleName);
+	wxFileDialog entryDialog(this, _("Choose desktop entry location"), "~/.local/share/applications", desktopEntryName,
+							 "Desktop file (*.desktop)|*.desktop", wxFD_SAVE | wxFD_CHANGE_DIR | wxFD_OVERWRITE_PROMPT);
+	const auto result = entryDialog.ShowModal();
+	if (result == wxID_CANCEL)
+		return;
+	const auto output_path = entryDialog.GetPath();
+
+	std::optional<fs::path> iconPath;
+	// Obtain and convert icon
+	[&]()
+	{
+		int iconIndex, smallIconIndex;
+
+		if (!QueryIconForTitle(titleId, iconIndex, smallIconIndex))
+		{
+			cemuLog_log(LogType::Force, "Icon hasn't loaded");
+			return;
+		}
+		const fs::path outIconDir = ActiveSettings::GetUserDataPath("icons");
+
+		if (!fs::exists(outIconDir) && !fs::create_directories(outIconDir))
+		{
+			cemuLog_log(LogType::Force, "Failed to create icon directory");
+			return;
+		}
+
+		iconPath = outIconDir / fmt::format("{:016x}.png", gameInfo.GetBaseTitleId());
+		wxFileOutputStream pngFileStream(_pathToUtf8(iconPath.value()));
+
+		auto image = m_image_list->GetIcon(iconIndex).ConvertToImage();
+		wxPNGHandler pngHandler;
+		if (!pngHandler.SaveFile(&image, pngFileStream, false))
+		{
+			iconPath = std::nullopt;
+			cemuLog_log(LogType::Force, "Icon failed to save");
+		}
+	}();
+
+	std::string desktopExecEntry = flatpakId ? fmt::format("/usr/bin/flatpak run {0} --title-id {1:016x}", flatpakId, titleId)
+											 : fmt::format("{0:?} --title-id {1:016x}", _pathToUtf8(exePath), titleId);
+
+	// 'Icon' accepts spaces in file name, does not accept quoted file paths
+	// 'Exec' does not accept non-escaped spaces, and can accept quoted file paths
+	auto desktopEntryString = fmt::format(
+		"[Desktop Entry]\n"
+		"Name={0}\n"
+		"Comment=Play {0} on Cemu\n"
+		"Exec={1}\n"
+		"Icon={2}\n"
+		"Terminal=false\n"
+		"Type=Application\n"
+		"Categories=Game;\n",
+		titleName.utf8_string(),
+		desktopExecEntry,
+		_pathToUtf8(iconPath.value_or("")));
+
+	if (flatpakId)
+		desktopEntryString += fmt::format("X-Flatpak={}\n", flatpakId);
+
+	std::ofstream outputStream(output_path.utf8_string());
+	if (!outputStream.good())
+	{
+		auto errorMsg = formatWxString(_("Failed to save desktop entry to {}"), output_path.utf8_string());
+		wxMessageBox(errorMsg, _("Error"), wxOK | wxCENTRE | wxICON_ERROR);
+		return;
+	}
+	outputStream << desktopEntryString;
+}
+#elif BOOST_OS_MACOS
+void wxGameList::CreateShortcut(GameInfo2& gameInfo)
+{
+	const auto titleId = gameInfo.GetBaseTitleId();
+	const auto titleName = wxString::FromUTF8(gameInfo.GetTitleName());
+	auto exePath = ActiveSettings::GetExecutablePath();
+
+	const wxString appName = wxString::Format("%s.app", titleName);
+	wxFileDialog entryDialog(this, _("Choose shortcut location"), "~/Applications", appName,
+							 "Application (*.app)|*.app", wxFD_SAVE | wxFD_CHANGE_DIR | wxFD_OVERWRITE_PROMPT);
+	const auto result = entryDialog.ShowModal();
+	if (result == wxID_CANCEL)
+		return;
+	const auto output_path = entryDialog.GetPath();
+	// Create .app folder
+	const fs::path appPath = output_path.utf8_string();
+	if (!fs::create_directories(appPath))
+	{
+		cemuLog_log(LogType::Force, "Failed to create app directory");
+		return;
+	}
+	const fs::path infoPath = appPath / "Contents/Info.plist";
+	const fs::path scriptPath = appPath / "Contents/MacOS/run.sh";
+	const fs::path icnsPath = appPath / "Contents/Resources/shortcut.icns";
+	if (!(fs::create_directories(scriptPath.parent_path()) && fs::create_directories(icnsPath.parent_path())))
+	{
+		cemuLog_log(LogType::Force, "Failed to create app shortcut directories");
+		return;
+	}
+
+	std::optional<fs::path> iconPath;
+	// Obtain and convert icon
+	[&]()
+	{
+		int iconIndex, smallIconIndex;
+
+		if (!QueryIconForTitle(titleId, iconIndex, smallIconIndex))
+		{
+			cemuLog_log(LogType::Force, "Icon hasn't loaded");
+			return;
+		}
+		const fs::path outIconDir = fs::temp_directory_path();
+
+		if (!fs::exists(outIconDir) && !fs::create_directories(outIconDir))
+		{
+			cemuLog_log(LogType::Force, "Failed to create icon directory");
+			return;
+		}
+
+		iconPath = outIconDir / fmt::format("{:016x}.png", gameInfo.GetBaseTitleId());
+		wxFileOutputStream pngFileStream(_pathToUtf8(iconPath.value()));
+
+		auto image = m_image_list->GetIcon(iconIndex).ConvertToImage();
+		wxPNGHandler pngHandler;
+		if (!pngHandler.SaveFile(&image, pngFileStream, false))
+		{
+			iconPath = std::nullopt;
+			cemuLog_log(LogType::Force, "Icon failed to save");
+		}
+	}();
+
+	std::string runCommand = fmt::format("#!/bin/zsh\n\n{0:?} --title-id {1:016x}", _pathToUtf8(exePath), titleId);
+	const std::string infoPlist = fmt::format(
+	"<?xml version=\"1.0\" encoding=\"UTF-8\"?>\n"
+	"<!DOCTYPE plist PUBLIC \"-//Apple//DTD PLIST 1.0//EN\" \"http://www.apple.com/DTDs/PropertyList-1.0.dtd\">\n"
+	"<plist version=\"1.0\">\n"
+	"<dict>\n"
+	"	<key>CFBundleDisplayName</key>\n"
+	"	<string>{0}</string>\n"
+	"	<key>CFBundleExecutable</key>\n"
+	"	<string>run.sh</string>\n"
+	"	<key>CFBundleIconFile</key>\n"
+	"	<string>shortcut.icns</string>\n"
+	"	<key>CFBundleName</key>\n"
+	"	<string>{0}</string>\n"
+	"	<key>CFBundlePackageType</key>\n"
+	"	<string>APPL</string>\n"
+	"	<key>CFBundleSignature</key>\n"
+	"	<string>\?\?\?\?</string>\n"
+	"	<key>LSApplicationCategoryType</key>\n"
+	"	<string>public.app-category.games</string>\n"
+	"	<key>CFBundleShortVersionString</key>\n"
+	"	<string>{1}</string>\n"
+	"	<key>CFBundleVersion</key>\n"
+	"	<string>{1}</string>\n"
+	"</dict>\n"
+	"</plist>\n",
+	gameInfo.GetTitleName(),
+	std::to_string(gameInfo.GetVersion())
+	);
+	// write Info.plist to infoPath
+	std::ofstream infoStream(infoPath);
+	std::ofstream scriptStream(scriptPath);
+	if (!infoStream.good() || !scriptStream.good())
+	{
+		auto errorMsg = formatWxString(_("Failed to save app shortcut to {}"), output_path.utf8_string());
+		wxMessageBox(errorMsg, _("Error"), wxOK | wxCENTRE | wxICON_ERROR);
+		return;
+	}
+	infoStream << infoPlist;
+	scriptStream << runCommand;
+	scriptStream.close();
+
+	// Set execute permissions for script
+	fs::permissions(
+		scriptPath,
+		fs::perms::owner_exec | fs::perms::group_exec | fs::perms::others_exec,
+		fs::perm_options::add
+	);
+
+	// Return if iconPath is empty
+	if (!iconPath)
+	{
+		cemuLog_log(LogType::Force, "Icon not found");
+		return;
+	}
+
+	// Convert icon to icns, only works for 128x128 PNG
+	// Alternatively, can run the command "sips -s format icns {iconPath} --out '{icnsPath}'"
+	// using std::system() to handle images of any size
+	if (!writeICNS(*iconPath, icnsPath))
+	{
+		cemuLog_log(LogType::Force, "Failed to convert icon to icns");
+		return;
+	}
+
+	// Remove temp file
+	fs::remove(*iconPath);
+}
+#elif BOOST_OS_WINDOWS
+void wxGameList::CreateShortcut(GameInfo2& gameInfo)
+{
+	const auto titleId = gameInfo.GetBaseTitleId();
+	const auto titleName = wxString::FromUTF8(gameInfo.GetTitleName());
+	auto exePath = ActiveSettings::GetExecutablePath();
+
+	// Get '%APPDATA%\Microsoft\Windows\Start Menu\Programs' path
+	PWSTR userShortcutFolder;
+	SHGetKnownFolderPath(FOLDERID_Programs, 0, NULL, &userShortcutFolder);
+	const wxString shortcutName = wxString::Format("%s.lnk", titleName);
+	wxFileDialog shortcutDialog(this, _("Choose shortcut location"), userShortcutFolder, shortcutName,
+								"Shortcut (*.lnk)|*.lnk", wxFD_SAVE | wxFD_CHANGE_DIR | wxFD_OVERWRITE_PROMPT);
+
+	CoTaskMemFree(userShortcutFolder);
+
+	const auto result = shortcutDialog.ShowModal();
+	if (result == wxID_CANCEL)
+		return;
+	const auto outputPath = shortcutDialog.GetPath();
+
+	std::optional<fs::path> icon_path = std::nullopt;
+	{
+		int iconIdx;
+		int smallIconIdx;
+		if (!QueryIconForTitle(titleId, iconIdx, smallIconIdx))
+		{
+			cemuLog_log(LogType::Force, "Icon hasn't loaded");
+			return;
+		}
+		const auto icon = m_image_list->GetIcon(iconIdx);
+		const auto folder = ActiveSettings::GetUserDataPath("icons");
+		if (!fs::exists(folder) && !fs::create_directories(folder))
+		{
+			cemuLog_log(LogType::Force, "Failed to create icon directory");
+			return;
+		}
+		wxBitmap bitmap{};
+		if (!bitmap.CopyFromIcon(icon))
+		{
+			cemuLog_log(LogType::Force, "Failed to copy icon");
+			return;
+		}
+
+		icon_path = folder / fmt::format("{:016x}.ico", titleId);
+		auto stream = wxFileOutputStream(icon_path->wstring());
+		auto image = bitmap.ConvertToImage();
+		wxICOHandler icohandler{};
+		if (!icohandler.SaveFile(&image, stream, false))
+		{
+			icon_path = std::nullopt;
+			cemuLog_log(LogType::Force, "Icon failed to save");
+		}
+	}
+
+	Microsoft::WRL::ComPtr<IShellLinkW> shellLink;
+	HRESULT hres = CoCreateInstance(__uuidof(ShellLink), nullptr, CLSCTX_INPROC_SERVER, IID_PPV_ARGS(&shellLink));
+	if (SUCCEEDED(hres))
+	{
+		const auto description = wxString::Format("Play %s on Cemu", titleName);
+		const auto args = wxString::Format("-t %016llx", titleId);
+
+		shellLink->SetPath(exePath.wstring().c_str());
+		shellLink->SetDescription(description.wc_str());
+		shellLink->SetArguments(args.wc_str());
+		shellLink->SetWorkingDirectory(exePath.parent_path().wstring().c_str());
+
+		if (icon_path)
+			shellLink->SetIconLocation(icon_path->wstring().c_str(), 0);
+		else
+			shellLink->SetIconLocation(exePath.wstring().c_str(), 0);
+
+		Microsoft::WRL::ComPtr<IPersistFile> shellLinkFile;
+		// save the shortcut
+		hres = shellLink.As(&shellLinkFile);
+		if (SUCCEEDED(hres))
+		{
+			hres = shellLinkFile->Save(outputPath.wc_str(), TRUE);
+		}
+	}
+	if (!SUCCEEDED(hres)) {
+		auto errorMsg = formatWxString(_("Failed to save shortcut to {}"), outputPath);
+		wxMessageBox(errorMsg, _("Error"), wxOK | wxCENTRE | wxICON_ERROR);
+	}
+}
+#endif
diff --git a/src/gui/components/wxGameList.h b/src/gui/components/wxGameList.h
index 1f422585..625f7976 100644
--- a/src/gui/components/wxGameList.h
+++ b/src/gui/components/wxGameList.h
@@ -10,6 +10,7 @@
 #include <wx/listctrl.h>
 #include <wx/timer.h>
 #include <wx/panel.h>
+#include <Cafe/TitleList/GameInfo.h>
 #include "util/helpers/Semaphore.h"
 
 class wxTitleIdEvent : public wxCommandEvent
@@ -29,7 +30,7 @@ wxDECLARE_EVENT(wxEVT_OPEN_GRAPHIC_PACK, wxTitleIdEvent);
 wxDECLARE_EVENT(wxEVT_GAMELIST_BEGIN_UPDATE, wxCommandEvent);
 wxDECLARE_EVENT(wxEVT_GAMELIST_END_UPDATE, wxCommandEvent);
 
-class wxGameList : public wxListCtrl
+class wxGameList : public wxListView
 {
 	friend class MainWindow;
 public:
@@ -50,10 +51,13 @@ public:
 	bool IsVisible(long item) const; // only available in wxwidgets 3.1.3
 
 	void ReloadGameEntries(bool cached = false);
+	void DeleteCachedStrings();
+
+    void CreateShortcut(GameInfo2& gameInfo);
 
 	long FindListItemByTitleId(uint64 title_id) const;
 	void OnClose(wxCloseEvent& event);
-	
+
 private:
 	std::atomic_bool m_exit = false;
 	Style m_style;
@@ -64,7 +68,7 @@ private:
 	inline static const wxColour kSecondColor{ 0xFDF9F2 };
 	void UpdateItemColors(sint32 startIndex = 0);
 
-	enum ItemColumns
+	enum ItemColumns : int
 	{
 		ColumnHiddenName = 0,
 		ColumnIcon,
@@ -74,21 +78,21 @@ private:
 		ColumnGameTime,
 		ColumnGameStarted,
 		ColumnRegion,
-		ColumnFavorite
+        ColumnTitleID,
+        //ColumnFavorite,
+		ColumnCounts,
 	};
 
-	int s_last_column = ColumnName;
-	int s_direction = 1;
 	void SortEntries(int column = -1);
 	struct SortData
 	{
 		wxGameList* thisptr;
-		int column;
+		ItemColumns column;
 		int dir;
 	};
 
 	int FindInsertPosition(TitleId titleId);
-	int SortComparator(uint64 titleId1, uint64 titleId2, SortData* sortData);
+	std::weak_ordering SortComparator(uint64 titleId1, uint64 titleId2, SortData* sortData);
 	static int SortFunction(wxIntPtr item1, wxIntPtr item2, wxIntPtr sortData);
 
 	wxTimer* m_tooltip_timer;
@@ -109,6 +113,8 @@ private:
 
 	void HandleTitleListCallback(struct CafeTitleListCallbackEvent* evt);
 
+	void RemoveCache(const std::list<fs::path>& cachePath, const std::string& titleName);
+
 	void AsyncWorkerThread();
 	void RequestLoadIconAsync(TitleId titleId);
 	bool QueryIconForTitle(TitleId titleId, int& icon, int& iconSmall);
@@ -143,6 +149,10 @@ private:
 	void OnMouseMove(wxMouseEvent& event);
 	void OnLeaveWindow(wxMouseEvent& event);
 
+	void OnGameListSize(wxSizeEvent& event);
+	void AdjustLastColumnWidth();
+	int GetColumnDefaultWidth(int column);
+
 	static inline std::once_flag s_launch_file_once;
 };
 
diff --git a/src/gui/components/wxLogCtrl.cpp b/src/gui/components/wxLogCtrl.cpp
index 50356d29..732dd26d 100644
--- a/src/gui/components/wxLogCtrl.cpp
+++ b/src/gui/components/wxLogCtrl.cpp
@@ -68,7 +68,7 @@ void wxLogCtrl::PushEntry(const wxString& filter, const wxString& message)
 	ListIt_t it = m_log_entries.back();
 	lock.unlock();
 
-	if(m_active_filter.empty() || filter == m_active_filter || (m_filter_messages && boost::icontains(message, m_active_filter)))
+	if(m_active_filter.empty() || filter == m_active_filter || (m_filter_messages && boost::icontains(message.ToStdString(), m_active_filter)))
 	{
 		std::unique_lock active_lock(m_active_mutex);
 		m_active_entries.emplace_back(std::cref(it));
@@ -149,7 +149,8 @@ void wxLogCtrl::UpdateActiveEntries()
 		{
 			for (const auto& it : m_log_entries)
 			{
-				if(it.first == m_active_filter || (m_filter_messages && boost::icontains(it.second, m_active_filter)) )
+				if(it.first == m_active_filter ||
+                              (m_filter_messages && boost::icontains(it.second.ToStdString(), m_active_filter)) )
 					m_active_entries.emplace_back(it);
 			}
 		}
diff --git a/src/gui/components/wxProgressDialogManager.h b/src/gui/components/wxProgressDialogManager.h
new file mode 100644
index 00000000..93b6c316
--- /dev/null
+++ b/src/gui/components/wxProgressDialogManager.h
@@ -0,0 +1,118 @@
+#pragma once
+
+#include <wx/event.h>
+#include <wx/progdlg.h>
+#include <wx/thread.h>
+#include "util/helpers/Semaphore.h"
+
+wxDEFINE_EVENT(wxEVT_CREATE_PROGRESS_DIALOG, wxThreadEvent);
+wxDEFINE_EVENT(wxEVT_DESTROY_PROGRESS_DIALOG, wxThreadEvent);
+wxDEFINE_EVENT(wxEVT_UPDATE_PROGRESS_DIALOG, wxThreadEvent);
+
+// wrapper for wxGenericProgressDialog which can be used from any thread
+class wxProgressDialogManager : public wxEvtHandler
+{
+public:
+    wxProgressDialogManager(wxWindow* parent) : m_parent(parent), m_dialog(nullptr)
+    {
+        Bind(wxEVT_CREATE_PROGRESS_DIALOG, &wxProgressDialogManager::OnCreateProgressDialog, this);
+        Bind(wxEVT_DESTROY_PROGRESS_DIALOG, &wxProgressDialogManager::OnDestroyProgressDialog, this);
+        Bind(wxEVT_UPDATE_PROGRESS_DIALOG, &wxProgressDialogManager::OnUpdateProgressDialog, this);
+    }
+
+    ~wxProgressDialogManager()
+    {
+        if (m_dialog)
+            Destroy();
+    }
+
+    void Create(const wxString& title, const wxString& message, int maximum, int style = wxPD_APP_MODAL | wxPD_ELAPSED_TIME | wxPD_REMAINING_TIME)
+    {
+        m_instanceSemaphore.increment();
+        m_isCancelled = false;
+        m_isSkipped = false;
+        wxThreadEvent event(wxEVT_CREATE_PROGRESS_DIALOG);
+        event.SetString(title);
+        event.SetInt(maximum);
+        event.SetExtraLong(style);
+        wxQueueEvent(this, event.Clone());
+    }
+
+    void Destroy()
+    {
+        wxThreadEvent event(wxEVT_DESTROY_PROGRESS_DIALOG);
+        wxQueueEvent(this, event.Clone());
+        m_instanceSemaphore.waitUntilZero(); // wait until destruction is complete
+    }
+
+    // this also updates the cancel and skip state
+    void Update(int value, const wxString& newmsg = wxEmptyString)
+    {
+        wxThreadEvent event(wxEVT_UPDATE_PROGRESS_DIALOG);
+        event.SetInt(value);
+        event.SetString(newmsg);
+        wxQueueEvent(this, event.Clone());
+    }
+
+    bool IsCancelled() const
+    {
+        return m_isCancelled;
+    }
+
+    bool IsSkipped() const
+    {
+        return m_isSkipped;
+    }
+
+    bool IsCancelledOrSkipped() const
+    {
+        return m_isCancelled || m_isSkipped;
+    }
+
+private:
+    void OnCreateProgressDialog(wxThreadEvent& event)
+    {
+        if (m_dialog)
+        {
+            m_dialog->Destroy();
+            m_instanceSemaphore.waitUntilZero();
+        }
+        m_maximum = event.GetInt();
+        m_dialog = new wxGenericProgressDialog(event.GetString(), "Please wait...", m_maximum, m_parent, event.GetExtraLong());
+    }
+
+    void OnDestroyProgressDialog(wxThreadEvent& event)
+    {
+        if (m_dialog)
+        {
+            m_dialog->Destroy();
+            m_dialog = nullptr;
+            m_instanceSemaphore.decrement();
+        }
+    }
+
+    void OnUpdateProgressDialog(wxThreadEvent& event)
+    {
+        if (m_dialog)
+        {
+            // make sure that progress is never >= maximum
+            // because wxGenericProgressDialog seems to become crashy on destruction otherwise
+            int progress = event.GetInt();
+            if(progress >= m_maximum)
+                progress = m_maximum - 1;
+            bool wasSkipped = false;
+            bool r = m_dialog->Update(progress, event.GetString(), &wasSkipped);
+            if(!r)
+                m_isCancelled = true;
+            if(wasSkipped)
+                m_isSkipped = true;
+        }
+    }
+
+    wxWindow* m_parent;
+    wxGenericProgressDialog* m_dialog;
+    bool m_isCancelled{false};
+    bool m_isSkipped{false};
+    int m_maximum{0};
+    CounterSemaphore m_instanceSemaphore; // used to synchronize destruction of the dialog
+};
\ No newline at end of file
diff --git a/src/gui/components/wxTitleManagerList.cpp b/src/gui/components/wxTitleManagerList.cpp
index 9a8c17a3..a5774b14 100644
--- a/src/gui/components/wxTitleManagerList.cpp
+++ b/src/gui/components/wxTitleManagerList.cpp
@@ -38,7 +38,7 @@ wxDEFINE_EVENT(wxEVT_TITLE_REMOVED, wxCommandEvent);
 wxDEFINE_EVENT(wxEVT_REMOVE_ENTRY, wxCommandEvent);
 
 wxTitleManagerList::wxTitleManagerList(wxWindow* parent, wxWindowID id)
-	: wxListCtrl(parent, id, wxDefaultPosition, wxDefaultSize, wxLC_REPORT | wxLC_VIRTUAL)
+	: wxListView(parent, id, wxDefaultPosition, wxDefaultSize, wxLC_REPORT | wxLC_VIRTUAL)
 {
 	AddColumns();
 
@@ -64,6 +64,8 @@ wxTitleManagerList::wxTitleManagerList(wxWindow* parent, wxWindowID id)
 
 	m_callbackIdTitleList = CafeTitleList::RegisterCallback([](CafeTitleListCallbackEvent* evt, void* ctx) { ((wxTitleManagerList*)ctx)->HandleTitleListCallback(evt); }, this);
 	m_callbackIdSaveList = CafeSaveList::RegisterCallback([](CafeSaveListCallbackEvent* evt, void* ctx) { ((wxTitleManagerList*)ctx)->HandleSaveListCallback(evt); }, this);
+
+	ShowSortIndicator(ColumnTitleId);
 }
 
 wxTitleManagerList::~wxTitleManagerList()
@@ -74,7 +76,7 @@ wxTitleManagerList::~wxTitleManagerList()
 
 boost::optional<const wxTitleManagerList::TitleEntry&> wxTitleManagerList::GetSelectedTitleEntry() const
 {
-	const auto selection = GetNextItem(-1, wxLIST_NEXT_ALL, wxLIST_STATE_SELECTED);
+	const auto selection = GetFirstSelected();
 	if (selection != wxNOT_FOUND)
 	{
 		const auto tmp = GetTitleEntry(selection);
@@ -87,7 +89,7 @@ boost::optional<const wxTitleManagerList::TitleEntry&> wxTitleManagerList::GetSe
 
 boost::optional<wxTitleManagerList::TitleEntry&> wxTitleManagerList::GetSelectedTitleEntry()
 {
-	const auto selection = GetNextItem(-1, wxLIST_NEXT_ALL, wxLIST_STATE_SELECTED);
+	const auto selection = GetFirstSelected();
 	if (selection != wxNOT_FOUND)
 	{
 		const auto tmp = GetTitleEntry(selection);
@@ -156,6 +158,12 @@ void wxTitleManagerList::AddColumns()
 	col5.SetText(_("Format"));
 	col5.SetWidth(63);
 	InsertColumn(ColumnFormat, col5);
+
+	wxListItem col6;
+	col6.SetId(ColumnLocation);
+	col6.SetText(_("Location"));
+	col6.SetWidth(63);
+	InsertColumn(ColumnLocation, col6);
 }
 
 wxString wxTitleManagerList::OnGetItemText(long item, long column) const
@@ -172,10 +180,11 @@ wxString wxTitleManagerList::OnGetItemText(long item, long column) const
 
 wxItemAttr* wxTitleManagerList::OnGetItemAttr(long item) const
 {
-	const auto entry = GetTitleEntry(item);
-	const wxColour kSecondColor{ 0xFDF9F2 };
-	static wxListItemAttr s_coloured_attr(GetTextColour(), kSecondColor, GetFont());
-	return item % 2 == 0 ? nullptr : &s_coloured_attr;
+	static wxColour bgColourPrimary = GetBackgroundColour();
+	static wxColour bgColourSecondary = wxHelper::CalculateAccentColour(bgColourPrimary);
+	static wxListItemAttr s_primary_attr(GetTextColour(), bgColourPrimary, GetFont());
+	static wxListItemAttr s_secondary_attr(GetTextColour(), bgColourSecondary, GetFont());
+	return item % 2 == 0 ? &s_primary_attr : &s_secondary_attr;
 }
 
 boost::optional<wxTitleManagerList::TitleEntry&> wxTitleManagerList::GetTitleEntry(long item)
@@ -197,10 +206,10 @@ boost::optional<wxTitleManagerList::TitleEntry&> wxTitleManagerList::GetTitleEnt
 
 boost::optional<const wxTitleManagerList::TitleEntry&> wxTitleManagerList::GetTitleEntry(const fs::path& path) const
 {
-	const auto tmp = path.generic_u8string();
+	const auto tmp = _pathToUtf8(path);
 	for (const auto& data : m_data)
 	{
-		if (boost::iequals(data->entry.path.generic_u8string(), tmp))
+		if (boost::iequals(_pathToUtf8(data->entry.path), tmp))
 			return data->entry;
 	}
 
@@ -208,10 +217,10 @@ boost::optional<const wxTitleManagerList::TitleEntry&> wxTitleManagerList::GetTi
 }
 boost::optional<wxTitleManagerList::TitleEntry&> wxTitleManagerList::GetTitleEntry(const fs::path& path)
 {
-	const auto tmp = path.generic_u8string();
+	const auto tmp = _pathToUtf8(path);
 	for (const auto& data : m_data)
 	{
-		if (boost::iequals(data->entry.path.generic_u8string(), tmp))
+		if (boost::iequals(_pathToUtf8(data->entry.path), tmp))
 			return data->entry;
 	}
 
@@ -235,7 +244,7 @@ boost::optional<const wxTitleManagerList::TitleEntry&> wxTitleManagerList::GetTi
 	return {};
 }
 
-void wxTitleManagerList::OnConvertToCompressedFormat(uint64 titleId)
+void wxTitleManagerList::OnConvertToCompressedFormat(uint64 titleId, uint64 rightClickedUID)
 {
 	TitleInfo titleInfo_base;
 	TitleInfo titleInfo_update;
@@ -262,22 +271,29 @@ void wxTitleManagerList::OnConvertToCompressedFormat(uint64 titleId)
 		{
 			if (!titleInfo_base.IsValid())
 			{
-				titleInfo_base = TitleInfo(data->entry.path);
-			}
-			else
-			{
-				// duplicate entry
+				titleInfo_base = CafeTitleList::GetTitleInfoByUID(data->entry.location_uid);
+				if(data->entry.location_uid == rightClickedUID)
+					break; // prefer the users selection
 			}
 		}
+	}
+	for (const auto& data : m_data)
+	{
 		if (hasUpdateTitleId && data->entry.title_id == updateTitleId)
 		{
 			if (!titleInfo_update.IsValid())
 			{
-				titleInfo_update = TitleInfo(data->entry.path);
+				titleInfo_update = CafeTitleList::GetTitleInfoByUID(data->entry.location_uid);
+				if(data->entry.location_uid == rightClickedUID)
+					break;
 			}
 			else
 			{
-				// duplicate entry
+				// if multiple updates are present use the newest one
+				if (titleInfo_update.GetAppTitleVersion() < data->entry.version)
+					titleInfo_update = CafeTitleList::GetTitleInfoByUID(data->entry.location_uid);
+				if(data->entry.location_uid == rightClickedUID)
+					break;
 			}
 		}
 	}
@@ -286,33 +302,35 @@ void wxTitleManagerList::OnConvertToCompressedFormat(uint64 titleId)
 	{
 		if (data->entry.title_id == aocTitleId)
 		{
-			titleInfo_aoc = TitleInfo(data->entry.path);
+			titleInfo_aoc = CafeTitleList::GetTitleInfoByUID(data->entry.location_uid);
+			if(data->entry.location_uid == rightClickedUID)
+				break;
 		}
 	}
 
-	std::string msg = wxHelper::MakeUTF8(_("The following content will be converted to a compressed Wii U archive file (.wua):"));
+	wxString msg = _("The following content will be converted to a compressed Wii U archive file (.wua):");
 	msg.append("\n \n");
 	
 	if (titleInfo_base.IsValid())
-		msg.append(fmt::format(fmt::runtime(wxHelper::MakeUTF8(_("Base game: {}"))), _pathToUtf8(titleInfo_base.GetPath())));
+		msg.append(formatWxString(_("Base game:\n{}"), titleInfo_base.GetPrintPath()));
 	else
-		msg.append(fmt::format(fmt::runtime(wxHelper::MakeUTF8(_("Base game: Not installed")))));
+		msg.append(_("Base game:\nNot installed"));
 
-	msg.append("\n");
+	msg.append("\n\n");
 
 	if (titleInfo_update.IsValid())
-		msg.append(fmt::format(fmt::runtime(wxHelper::MakeUTF8(_("Update: {}"))), _pathToUtf8(titleInfo_update.GetPath())));
+		msg.append(formatWxString(_("Update:\n{}"), titleInfo_update.GetPrintPath()));
 	else
-		msg.append(fmt::format(fmt::runtime(wxHelper::MakeUTF8(_("Update: Not installed")))));
+		msg.append(_("Update:\nNot installed"));
 
-	msg.append("\n");
+	msg.append("\n\n");
 
 	if (titleInfo_aoc.IsValid())
-		msg.append(fmt::format(fmt::runtime(wxHelper::MakeUTF8(_("DLC: {}"))), _pathToUtf8(titleInfo_aoc.GetPath())));
+		msg.append(formatWxString(_("DLC:\n{}"), titleInfo_aoc.GetPrintPath()));
 	else
-		msg.append(fmt::format(fmt::runtime(wxHelper::MakeUTF8(_("DLC: Not installed")))));
+		msg.append(_("DLC:\nNot installed"));
 
-	const int answer = wxMessageBox(wxString::FromUTF8(msg), _("Confirmation"), wxOK | wxCANCEL | wxCENTRE | wxICON_QUESTION, this);
+	const int answer = wxMessageBox(msg, _("Confirmation"), wxOK | wxCANCEL | wxCENTRE | wxICON_QUESTION, this);
 	if (answer != wxOK)
 		return;
 	std::vector<TitleInfo*> titlesToConvert;
@@ -339,11 +357,11 @@ void wxTitleManagerList::OnConvertToCompressedFormat(uint64 titleId)
 		boost::replace_all(shortName, ":", "");
 	}
 	// for the default output directory we use the first game path configured by the user
-	std::wstring defaultDir = L"";
+	std::string defaultDir = "";
 	if (!GetConfig().game_paths.empty())
 		defaultDir = GetConfig().game_paths.front();
 	// get the short name, which we will use as a suggested default file name
-	std::string defaultFileName = shortName;
+	std::string defaultFileName = std::move(shortName);
 	boost::replace_all(defaultFileName, "/", "");
 	boost::replace_all(defaultFileName, "\\", "");
 
@@ -368,7 +386,7 @@ void wxTitleManagerList::OnConvertToCompressedFormat(uint64 titleId)
 	// ask the user to provide a path for the output file
 	wxFileDialog saveFileDialog(this, _("Save Wii U game archive file"), defaultDir, wxHelper::FromUtf8(defaultFileName),
 			"WUA files (*.wua)|*.wua", wxFD_SAVE | wxFD_OVERWRITE_PROMPT);
-	if (saveFileDialog.ShowModal() == wxID_CANCEL)
+	if (saveFileDialog.ShowModal() == wxID_CANCEL || saveFileDialog.GetPath().IsEmpty())
 		return;
 	fs::path outputPath(wxHelper::MakeFSPath(saveFileDialog.GetPath()));
 	fs::path outputPathTmp(wxHelper::MakeFSPath(saveFileDialog.GetPath().append("__tmp")));
@@ -474,7 +492,7 @@ void wxTitleManagerList::OnConvertToCompressedFormat(uint64 titleId)
 		{
 			std::string temporaryMountPath = TitleInfo::GetUniqueTempMountingPath();
 			titleInfo->Mount(temporaryMountPath.c_str(), "", FSC_PRIORITY_BASE);
-			bool r = RecursivelyAddFiles(fmt::format("{:016x}_v{}/", titleInfo->GetAppTitleId(), titleInfo->GetAppTitleVersion()), temporaryMountPath.c_str());
+			bool r = RecursivelyAddFiles(fmt::format("{:016x}_v{}/", titleInfo->GetAppTitleId(), titleInfo->GetAppTitleVersion()), temporaryMountPath);
 			titleInfo->Unmount(temporaryMountPath.c_str());
 			return r;
 		}
@@ -558,7 +576,7 @@ void wxTitleManagerList::OnConvertToCompressedFormat(uint64 titleId)
 		}
 		else
 		{
-			progressDialog.Update(0, _("Collecting list of files..." + fmt::format(" ({})", writerContext.totalFileCount.load())));
+			progressDialog.Update(0, _("Collecting list of files...") + fmt::format(" ({})", writerContext.totalFileCount.load()));
 		}
 		if (progressDialog.WasCancelled())
 			writerContext.cancelled.store(true);
@@ -719,7 +737,7 @@ void wxTitleManagerList::OnItemSelected(wxListEvent& event)
 	//	return;;
 	//}
 
-	//m_tooltip_text->SetLabel(wxStringFormat2("{}\n{}", msg, _("You can use the context menu to fix it.")));
+	//m_tooltip_text->SetLabel(formatWxString("{}\n{}", msg, _("You can use the context menu to fix it.")));
 	//m_tooltip_window->Fit();
 	//m_tooltip_timer->StartOnce(250);
 }
@@ -741,7 +759,7 @@ void wxTitleManagerList::OnContextMenu(wxContextMenuEvent& event)
 	wxMenu menu;
 	menu.Bind(wxEVT_COMMAND_MENU_SELECTED, &wxTitleManagerList::OnContextMenuSelected, this);
 
-	const auto selection = GetNextItem(-1, wxLIST_NEXT_ALL, wxLIST_STATE_SELECTED);
+	const auto selection = GetFirstSelected();
 	if (selection == wxNOT_FOUND)
 		return;
 
@@ -779,9 +797,9 @@ bool wxTitleManagerList::DeleteEntry(long index, const TitleEntry& entry)
 	wxString msg;
 	const bool is_directory = fs::is_directory(entry.path);
 	if(is_directory)
-		msg = wxStringFormat2(_("Are you really sure that you want to delete the following folder:\n{}"), wxHelper::FromUtf8(_pathToUtf8(entry.path)));
+		msg = formatWxString(_("Are you really sure that you want to delete the following folder:\n{}"), _pathToUtf8(entry.path));
 	else
-		msg = wxStringFormat2(_("Are you really sure that you want to delete the following file:\n{}"), wxHelper::FromUtf8(_pathToUtf8(entry.path)));
+		msg = formatWxString(_("Are you really sure that you want to delete the following file:\n{}"), _pathToUtf8(entry.path));
 	
 	const auto result = wxMessageBox(msg, _("Warning"), wxYES_NO | wxCENTRE | wxICON_EXCLAMATION, this);
 	if (result == wxNO)
@@ -822,7 +840,7 @@ bool wxTitleManagerList::DeleteEntry(long index, const TitleEntry& entry)
 	
 	if(ec)
 	{
-		const auto error_msg = wxStringFormat2(_("Error when trying to delete the entry:\n{}"), GetSystemErrorMessage(ec));
+		const auto error_msg = formatWxString(_("Error when trying to delete the entry:\n{}"), GetSystemErrorMessage(ec));
 		wxMessageBox(error_msg, _("Error"), wxOK|wxCENTRE, this);
 		return false;
 	}
@@ -839,8 +857,8 @@ void wxTitleManagerList::OnContextMenuSelected(wxCommandEvent& event)
 	// still doing work
 	if (m_context_worker.valid() && !future_is_ready(m_context_worker))
 		return;
-	
-	const auto selection = GetNextItem(-1, wxLIST_NEXT_ALL, wxLIST_STATE_SELECTED);
+
+	const auto selection = GetFirstSelected();
 	if (selection == wxNOT_FOUND)
 		return;
 
@@ -853,7 +871,7 @@ void wxTitleManagerList::OnContextMenuSelected(wxCommandEvent& event)
 	case kContextMenuOpenDirectory:
 		{
 			const auto path = fs::is_directory(entry->path) ? entry->path : entry->path.parent_path();
-			wxLaunchDefaultBrowser(wxHelper::FromUtf8(fmt::format("file:{}", _pathToUtf8(path))));
+			wxLaunchDefaultApplication(wxHelper::FromPath(path));
 		}
 		break;
 	case kContextMenuDelete:
@@ -868,7 +886,7 @@ void wxTitleManagerList::OnContextMenuSelected(wxCommandEvent& event)
 			}
 			catch (const std::exception& ex)
 			{
-				forceLog_printf("wxTitleManagerList::OnContextMenuSelected: can't launch title: %s", ex.what());
+				cemuLog_log(LogType::Force, "wxTitleManagerList::OnContextMenuSelected: can't launch title: {}", ex.what());
 			}
 		}
 		break;
@@ -877,7 +895,7 @@ void wxTitleManagerList::OnContextMenuSelected(wxCommandEvent& event)
 		break;
 	case kContextMenuConvertToWUA:
 		
-		OnConvertToCompressedFormat(entry.value().title_id);
+		OnConvertToCompressedFormat(entry.value().title_id, entry.value().location_uid);
 		break;
 	}
 }
@@ -909,15 +927,15 @@ wxString wxTitleManagerList::GetTitleEntryText(const TitleEntry& entry, ItemColu
 	switch (column)
 	{
 	case ColumnTitleId:
-		return wxStringFormat2("{:08x}-{:08x}", (uint32)(entry.title_id >> 32), (uint32)(entry.title_id & 0xFFFFFFFF));
+		return formatWxString("{:08x}-{:08x}", (uint32) (entry.title_id >> 32), (uint32) (entry.title_id & 0xFFFFFFFF));
 	case ColumnName:
 		return entry.name;
 	case ColumnType:
-		return wxStringFormat2("{}", entry.type);
+		return GetTranslatedTitleEntryType(entry.type);
 	case ColumnVersion:
-		return wxStringFormat2("{}", entry.version);
+		return formatWxString("{}", entry.version);
 	case ColumnRegion:
-		return wxStringFormat2("{}", entry.region); // TODO its a flag so formatter is currently not correct
+		return wxGetTranslation(fmt::format("{}", entry.region));
 	case ColumnFormat:
 	{
 		if (entry.type == EntryType::Save)
@@ -928,11 +946,22 @@ wxString wxTitleManagerList::GetTitleEntryText(const TitleEntry& entry, ItemColu
 			return _("Folder");
 		case wxTitleManagerList::EntryFormat::WUD:
 			return _("WUD");
+		case wxTitleManagerList::EntryFormat::NUS:
+			return _("NUS");
 		case wxTitleManagerList::EntryFormat::WUA:
 			return _("WUA");
+		case wxTitleManagerList::EntryFormat::WUHB:
+			return _("WUHB");
 		}
 		return "";
-		//return wxStringFormat2("{}", entry.format);
+	}
+	case ColumnLocation:
+	{
+		const auto relative_mlc_path = _pathToUtf8(entry.path.lexically_relative(ActiveSettings::GetMlcPath()));
+		if (relative_mlc_path.starts_with("usr") || relative_mlc_path.starts_with("sys"))
+			return _("MLC");
+		else
+			return _("Game Paths");
 	}
 	default:
 		UNREACHABLE;
@@ -941,6 +970,25 @@ wxString wxTitleManagerList::GetTitleEntryText(const TitleEntry& entry, ItemColu
 	return wxEmptyString;
 }
 
+wxString wxTitleManagerList::GetTranslatedTitleEntryType(EntryType type)
+{
+	switch (type)
+	{
+		case EntryType::Base:
+			return _("base");
+		case EntryType::Update:
+			return _("update");
+		case EntryType::Dlc:
+			return _("DLC");
+		case EntryType::Save:
+			return _("save");
+		case EntryType::System:
+			return _("system");
+		default:
+			return std::to_string(static_cast<std::underlying_type_t<EntryType>>(type));
+	}
+}
+
 void wxTitleManagerList::HandleTitleListCallback(CafeTitleListCallbackEvent* evt)
 {
 	if (evt->eventType != CafeTitleListCallbackEvent::TYPE::TITLE_DISCOVERED &&
@@ -969,16 +1017,22 @@ void wxTitleManagerList::HandleTitleListCallback(CafeTitleListCallbackEvent* evt
 	wxTitleManagerList::EntryFormat entryFormat;
 	switch (titleInfo.GetFormat())
 	{
-	case TitleInfo::TitleDataFormat::HOST_FS:
-	default:
-		entryFormat = EntryFormat::Folder;
-		break;
 	case TitleInfo::TitleDataFormat::WUD:
 		entryFormat = EntryFormat::WUD;
 		break;
+	case TitleInfo::TitleDataFormat::NUS:
+		entryFormat = EntryFormat::NUS;
+		break;
 	case TitleInfo::TitleDataFormat::WIIU_ARCHIVE:
 		entryFormat = EntryFormat::WUA;
 		break;
+	case TitleInfo::TitleDataFormat::WUHB:
+		entryFormat = EntryFormat::WUHB;
+		break;
+	case TitleInfo::TitleDataFormat::HOST_FS:
+	default:
+		entryFormat = EntryFormat::Folder;
+		break;
 	}
 
 	if (evt->eventType == CafeTitleListCallbackEvent::TYPE::TITLE_DISCOVERED)
@@ -988,7 +1042,8 @@ void wxTitleManagerList::HandleTitleListCallback(CafeTitleListCallbackEvent* evt
 		wxTitleManagerList::TitleEntry entry(entryType, entryFormat, titleInfo.GetPath());
 
 		ParsedMetaXml* metaInfo = titleInfo.GetMetaInfo();
-
+		if(titleInfo.IsSystemDataTitle())
+			return; // dont show system data titles for now
 		entry.location_uid = titleInfo.GetUID();
 		entry.title_id = titleInfo.GetAppTitleId();
 		std::string name = metaInfo->GetLongName(GetConfig().console_language.GetValue());
@@ -1095,7 +1150,7 @@ bool wxTitleManagerList::SortFunc(int column, const Type_t& v1, const Type_t& v2
 	// check column: title id -> type -> path
 	if (column == ColumnTitleId)
 	{
-		// ensure strong ordering -> use type since only one entry should be now (should be changed if every save for every user is displayed spearately?)
+		// ensure strong ordering -> use type since only one entry should be now (should be changed if every save for every user is displayed separately?)
 		if (entry1.title_id == entry2.title_id)
 			return SortFunc(ColumnType, v1, v2);
 		
@@ -1111,7 +1166,7 @@ bool wxTitleManagerList::SortFunc(int column, const Type_t& v1, const Type_t& v2
 	}
 	else if (column == ColumnType)
 	{
-		if(std::underlying_type_t<EntryType>(entry1.type) == std::underlying_type_t<EntryType>(entry2.type))
+		if(entry1.type == entry2.type)
 			return SortFunc(-1, v1, v2);
 		
 		return std::underlying_type_t<EntryType>(entry1.type) < std::underlying_type_t<EntryType>(entry2.type);
@@ -1120,47 +1175,48 @@ bool wxTitleManagerList::SortFunc(int column, const Type_t& v1, const Type_t& v2
 	{
 		if(entry1.version == entry2.version)
 			return SortFunc(ColumnTitleId, v1, v2);
-		
-		return std::underlying_type_t<EntryType>(entry1.version) < std::underlying_type_t<EntryType>(entry2.version);
+
+		return entry1.version < entry2.version;
 	}
 	else if (column == ColumnRegion)
 	{
 		if(entry1.region == entry2.region)
 			return SortFunc(ColumnTitleId, v1, v2);
-		
-		return std::underlying_type_t<EntryType>(entry1.region) < std::underlying_type_t<EntryType>(entry2.region);
+
+		return std::underlying_type_t<CafeConsoleRegion>(entry1.region) < std::underlying_type_t<CafeConsoleRegion>(entry2.region);
+	}
+	else if (column == ColumnFormat)
+	{
+		if(entry1.format == entry2.format)
+			return SortFunc(ColumnType, v1, v2);
+
+		return std::underlying_type_t<EntryFormat>(entry1.format) < std::underlying_type_t<EntryFormat>(entry2.format);
 	}
 		
 	return false;
 }
 void wxTitleManagerList::SortEntries(int column)
 {
-	if(column == -1)
+	bool ascending;
+	if (column == -1)
 	{
-		column = m_last_column_sorted;
-		m_last_column_sorted = -1;
+		column = GetSortIndicator();
 		if (column == -1)
 			column = ColumnTitleId;
+		ascending = IsAscendingSortIndicator();
 	}
-	
+	else
+		ascending = GetUpdatedAscendingSortIndicator(column);
+
 	if (column != ColumnTitleId && column != ColumnName && column != ColumnType && column != ColumnVersion && column != ColumnRegion && column != ColumnFormat)
 		return;
 
-	if (m_last_column_sorted != column)
-	{
-		m_last_column_sorted = column;
-		m_sort_less = true;
-	}
-	else
-		m_sort_less = !m_sort_less;
-		
 	std::sort(m_sorted_data.begin(), m_sorted_data.end(),
-		[this, column](const Type_t& v1, const Type_t& v2) -> bool
-		{
-			const bool result = SortFunc(column, v1, v2);
-			return m_sort_less ? result : !result;
-		});
-	
+			  [this, column, ascending](const Type_t& v1, const Type_t& v2) -> bool {
+				  return ascending ? SortFunc(column, v1, v2) : SortFunc(column, v2, v1);
+			  });
+
+	ShowSortIndicator(column, ascending);
 	RefreshPage();
 }
 
@@ -1274,4 +1330,4 @@ void wxTitleManagerList::ClearItems()
 void wxTitleManagerList::AutosizeColumns()
 {
 	wxAutosizeColumns(this, ColumnTitleId, ColumnMAX - 1);
-}
\ No newline at end of file
+}
diff --git a/src/gui/components/wxTitleManagerList.h b/src/gui/components/wxTitleManagerList.h
index 2db99309..c21145b7 100644
--- a/src/gui/components/wxTitleManagerList.h
+++ b/src/gui/components/wxTitleManagerList.h
@@ -9,7 +9,7 @@
 #include <utility>
 #include <vector>
 
-class wxTitleManagerList : public wxListCtrl
+class wxTitleManagerList : public wxListView
 {
 	friend class TitleManager;
 public:
@@ -24,6 +24,7 @@ public:
 		ColumnVersion,
 		ColumnRegion,
 		ColumnFormat,
+		ColumnLocation,
 
 		ColumnMAX,
 	};
@@ -41,7 +42,9 @@ public:
 	{
 		Folder,
 		WUD,
+		NUS,
 		WUA,
+		WUHB,
 	};
 
 	// sort by column, if -1 will sort by last column or default (=titleid)
@@ -105,9 +108,8 @@ private:
 	[[nodiscard]] boost::optional<TitleEntry&> GetTitleEntry(long item);
 	[[nodiscard]] boost::optional<const TitleEntry&> GetTitleEntry(const fs::path& path) const;
 	[[nodiscard]] boost::optional<TitleEntry&> GetTitleEntry(const fs::path& path);
-	
-	bool VerifyEntryFiles(TitleEntry& entry);
-	void OnConvertToCompressedFormat(uint64 titleId);
+
+	void OnConvertToCompressedFormat(uint64 titleId, uint64 rightClickedUID);
 	bool DeleteEntry(long index, const TitleEntry& entry);
 
 	void RemoveItem(long item);
@@ -125,38 +127,13 @@ private:
 	std::vector<ItemDataPtr> m_data;
 	std::vector<std::reference_wrapper<ItemData>> m_sorted_data;
 
-	int m_last_column_sorted = -1;
-	bool m_sort_less = true;
 	using Type_t = std::reference_wrapper<const ItemData>;
 	bool SortFunc(int column, const Type_t& v1, const Type_t& v2);
 
 	static wxString GetTitleEntryText(const TitleEntry& entry, ItemColumn column);
+	static wxString GetTranslatedTitleEntryType(EntryType entryType);
 	std::future<bool> m_context_worker;
 
 	uint64 m_callbackIdTitleList;
 	uint64 m_callbackIdSaveList;
 };
-
-template <>
-struct fmt::formatter<wxTitleManagerList::EntryType> : formatter<string_view>
-{
-	using base = fmt::formatter<fmt::string_view>;
-	template <typename FormatContext>
-	auto format(const wxTitleManagerList::EntryType& type, FormatContext& ctx)
-	{
-		switch (type)
-		{
-		case wxTitleManagerList::EntryType::Base:
-			return base::format("base", ctx);
-		case wxTitleManagerList::EntryType::Update:
-			return base::format("update", ctx);
-		case wxTitleManagerList::EntryType::Dlc:
-			return base::format("DLC", ctx);
-		case wxTitleManagerList::EntryType::Save:
-			return base::format("save", ctx);
-		case wxTitleManagerList::EntryType::System:
-			return base::format("system", ctx);
-		}
-		return base::format(std::to_string(static_cast<std::underlying_type_t<wxTitleManagerList::EntryType>>(type)), ctx);
-	}
-};
\ No newline at end of file
diff --git a/src/gui/debugger/BreakpointWindow.cpp b/src/gui/debugger/BreakpointWindow.cpp
index ecb77428..c693477d 100644
--- a/src/gui/debugger/BreakpointWindow.cpp
+++ b/src/gui/debugger/BreakpointWindow.cpp
@@ -11,9 +11,11 @@
 
 enum
 {
-	MENU_ID_CREATE_MEM_BP_READ = 1,
+	MENU_ID_CREATE_CODE_BP_EXECUTION = 1,
+	MENU_ID_CREATE_CODE_BP_LOGGING,
+	MENU_ID_CREATE_MEM_BP_READ,
 	MENU_ID_CREATE_MEM_BP_WRITE,
-
+	MENU_ID_DELETE_BP,
 };
 
 enum ItemColumns
@@ -118,6 +120,8 @@ void BreakpointWindow::OnUpdateView()
 				const char* typeName = "UKN";
 				if (bp->bpType == DEBUGGER_BP_T_NORMAL)
 					typeName = "X";
+				else if (bp->bpType == DEBUGGER_BP_T_LOGGING)
+					typeName = "LOG";
 				else if (bp->bpType == DEBUGGER_BP_T_ONE_SHOT)
 					typeName = "XS";
 				else if (bp->bpType == DEBUGGER_BP_T_MEMORY_READ)
@@ -198,44 +202,69 @@ void BreakpointWindow::OnLeftDClick(wxMouseEvent& event)
 		auto it = debuggerState.breakpoints.begin();
 		std::advance(it, index);
 
-		wxTextEntryDialog set_value_dialog(this, _("Enter a new comment."), wxString::Format(_("Set comment for breakpoint at address %08x"), address), (*it)->comment);
-		if (set_value_dialog.ShowModal() == wxID_OK)
+		const wxString dialogTitle = (*it)->bpType == DEBUGGER_BP_T_LOGGING ? _("Enter a new logging message") : _("Enter a new comment");
+		const wxString dialogMessage = (*it)->bpType == DEBUGGER_BP_T_LOGGING ? _("Set logging message when code at address %08x is ran.\nUse placeholders like {r3} or {f3} to log register values") : _("Set comment for breakpoint at address %08x");
+		wxTextEntryDialog set_comment_dialog(this, dialogMessage, dialogTitle, (*it)->comment);
+		if (set_comment_dialog.ShowModal() == wxID_OK)
 		{
-			(*it)->comment = set_value_dialog.GetValue().ToStdWstring();
-			m_breakpoints->SetItem(index, ColumnComment, set_value_dialog.GetValue());
+			(*it)->comment = set_comment_dialog.GetValue().ToStdWstring();
+			m_breakpoints->SetItem(index, ColumnComment, set_comment_dialog.GetValue());
 		}
-
-		return;
 	}
 }
 
 void BreakpointWindow::OnRightDown(wxMouseEvent& event)
 {
-	wxMenu menu;
+	const auto position = event.GetPosition();
+	const sint32 index = (position.y / m_breakpoints->GetCharHeight()) - 2;
+	if (index < 0 || index >= m_breakpoints->GetItemCount())
+	{
+		wxMenu menu;
+		menu.Append(MENU_ID_CREATE_CODE_BP_EXECUTION, _("Create execution breakpoint"));
+		menu.Append(MENU_ID_CREATE_CODE_BP_LOGGING, _("Create logging breakpoint"));
+		menu.Append(MENU_ID_CREATE_MEM_BP_READ, _("Create memory breakpoint (read)"));
+		menu.Append(MENU_ID_CREATE_MEM_BP_WRITE, _("Create memory breakpoint (write)"));
 
-	menu.Append(MENU_ID_CREATE_MEM_BP_READ, _("Create memory breakpoint (read)"));
-	menu.Append(MENU_ID_CREATE_MEM_BP_WRITE, _("Create memory breakpoint (write)"));
+		menu.Connect(wxEVT_COMMAND_MENU_SELECTED, wxCommandEventHandler(BreakpointWindow::OnContextMenuClick), nullptr, this);
+		PopupMenu(&menu);
+	}
+	else
+	{
+		m_breakpoints->Focus(index);
+		m_breakpoints->Select(index);
 
-	menu.Connect(wxEVT_COMMAND_MENU_SELECTED, wxCommandEventHandler(BreakpointWindow::OnContextMenuClick), nullptr, this);
-	PopupMenu(&menu);
+		wxMenu menu;
+		menu.Append(MENU_ID_DELETE_BP, _("Delete breakpoint"));
+
+		menu.Connect(wxEVT_COMMAND_MENU_SELECTED, wxCommandEventHandler(BreakpointWindow::OnContextMenuClickSelected), nullptr, this);
+		PopupMenu(&menu);
+	}
+}
+
+void BreakpointWindow::OnContextMenuClickSelected(wxCommandEvent& evt)
+{
+	if (evt.GetId() == MENU_ID_DELETE_BP)
+	{
+		long sel = m_breakpoints->GetFirstSelected();
+		if (sel != wxNOT_FOUND)
+		{
+			if (sel >= debuggerState.breakpoints.size())
+				return;
+
+			auto it = debuggerState.breakpoints.begin();
+			std::advance(it, sel);
+
+			debugger_deleteBreakpoint(*it);
+
+			wxCommandEvent evt(wxEVT_BREAKPOINT_CHANGE);
+			wxPostEvent(this->m_parent, evt);
+		}
+	}
 }
 
 void BreakpointWindow::OnContextMenuClick(wxCommandEvent& evt)
 {
-	switch (evt.GetId())
-	{
-	case MENU_ID_CREATE_MEM_BP_READ:
-		MemoryBreakpointDialog(false);
-		return;
-	case MENU_ID_CREATE_MEM_BP_WRITE:
-		MemoryBreakpointDialog(true);
-		return;
-	}
-}
-
-void BreakpointWindow::MemoryBreakpointDialog(bool isWrite)
-{
-	wxTextEntryDialog goto_dialog(this, _("Enter a memory address"), _("Memory breakpoint"), wxEmptyString);
+	wxTextEntryDialog goto_dialog(this, _("Enter a memory address"), _("Set breakpoint"), wxEmptyString);
 	if (goto_dialog.ShowModal() == wxID_OK)
 	{
 		ExpressionParser parser;
@@ -243,22 +272,34 @@ void BreakpointWindow::MemoryBreakpointDialog(bool isWrite)
 		auto value = goto_dialog.GetValue().ToStdString();
 		std::transform(value.begin(), value.end(), value.begin(), tolower);
 
-
+		uint32_t newBreakpointAddress = 0;
 		try
 		{
 			debugger_addParserSymbols(parser);
-			const auto result = (uint32)parser.Evaluate(value);
-			debug_printf("goto eval result: %x\n", result);
-
-			debugger_createMemoryBreakpoint(result, isWrite == false, isWrite == true);
-			this->OnUpdateView();
+			newBreakpointAddress = parser.IsConstantExpression("0x"+value) ? (uint32)parser.Evaluate("0x"+value) : (uint32)parser.Evaluate(value);
 		}
-		catch (const std::exception& e)
+		catch (const std::exception& ex)
 		{
-			//ctx.errorHandler.printError(nullptr, -1, fmt::format("Unexpected error in expression \"{}\"", expressionString));
-			//return EXPRESSION_RESOLVE_RESULT::EXPRESSION_ERROR;
-			wxMessageBox(e.what(), "Invalid expression");
+			wxMessageBox(ex.what(), _("Error"), wxOK | wxCENTRE | wxICON_ERROR, this);
+			return;
 		}
-		
+
+		switch (evt.GetId())
+		{
+		case MENU_ID_CREATE_CODE_BP_EXECUTION:
+			debugger_createCodeBreakpoint(newBreakpointAddress, DEBUGGER_BP_T_NORMAL);
+			break;
+		case MENU_ID_CREATE_CODE_BP_LOGGING:
+			debugger_createCodeBreakpoint(newBreakpointAddress, DEBUGGER_BP_T_LOGGING);
+			break;
+		case MENU_ID_CREATE_MEM_BP_READ:
+			debugger_createMemoryBreakpoint(newBreakpointAddress, true, false);
+			break;
+		case MENU_ID_CREATE_MEM_BP_WRITE:
+			debugger_createMemoryBreakpoint(newBreakpointAddress, false, true);
+			break;
+		}
+
+		this->OnUpdateView();
 	}
-}
\ No newline at end of file
+}
diff --git a/src/gui/debugger/BreakpointWindow.h b/src/gui/debugger/BreakpointWindow.h
index 4851cb52..ac132950 100644
--- a/src/gui/debugger/BreakpointWindow.h
+++ b/src/gui/debugger/BreakpointWindow.h
@@ -19,8 +19,7 @@ private:
 	void OnRightDown(wxMouseEvent& event);
 
 	void OnContextMenuClick(wxCommandEvent& evt);
-
-	void MemoryBreakpointDialog(bool isWrite);
+	void OnContextMenuClickSelected(wxCommandEvent& evt);
 
 	wxCheckedListCtrl* m_breakpoints;
 };
\ No newline at end of file
diff --git a/src/gui/debugger/DebuggerWindow2.cpp b/src/gui/debugger/DebuggerWindow2.cpp
index cca9bfb8..9f25cf96 100644
--- a/src/gui/debugger/DebuggerWindow2.cpp
+++ b/src/gui/debugger/DebuggerWindow2.cpp
@@ -19,9 +19,7 @@
 #include "gui/debugger/ModuleWindow.h"
 #include "util/helpers/helpers.h"
 
-#if BOOST_OS_LINUX
 #include "resource/embedded/resources.h"
-#endif
 
 enum
 {
@@ -66,10 +64,9 @@ wxBEGIN_EVENT_TABLE(DebuggerWindow2, wxFrame)
 	EVT_COMMAND(wxID_ANY, wxEVT_RUN, DebuggerWindow2::OnRunProgram)
 	EVT_COMMAND(wxID_ANY, wxEVT_NOTIFY_MODULE_LOADED, DebuggerWindow2::OnNotifyModuleLoaded)
 	EVT_COMMAND(wxID_ANY, wxEVT_NOTIFY_MODULE_UNLOADED, DebuggerWindow2::OnNotifyModuleUnloaded)
+	EVT_COMMAND(wxID_ANY, wxEVT_DISASMCTRL_NOTIFY_GOTO_ADDRESS, DebuggerWindow2::OnDisasmCtrlGotoAddress)
 	// file menu
 	EVT_MENU(MENU_ID_FILE_EXIT, DebuggerWindow2::OnExit)
-	// setting
-	EVT_MENU(MENU_ID_OPTIONS_PIN_TO_MAINWINDOW, DebuggerWindow2::OnOptionsInput)
 	// window
 	EVT_MENU_RANGE(MENU_ID_WINDOW_REGISTERS, MENU_ID_WINDOW_MODULE, DebuggerWindow2::OnWindowMenu)
 wxEND_EVENT_TABLE()
@@ -122,7 +119,7 @@ void DebuggerModuleStorage::Load(XMLConfigParser& parser)
 		const auto comment = element.get("Comment", "");
 
 		// calculate absolute address
-		uint32 module_base_address = (type == DEBUGGER_BP_T_NORMAL ? this->rpl_module->regionMappingBase_text.GetMPTR() : this->rpl_module->regionMappingBase_data);
+		uint32 module_base_address = (type == DEBUGGER_BP_T_NORMAL || type == DEBUGGER_BP_T_LOGGING) ? this->rpl_module->regionMappingBase_text.GetMPTR() : this->rpl_module->regionMappingBase_data;
 		uint32 address = module_base_address + relative_address;
 
 		// don't change anything if there's already a breakpoint
@@ -131,7 +128,9 @@ void DebuggerModuleStorage::Load(XMLConfigParser& parser)
 
 		// register breakpoints in debugger
 		if (type == DEBUGGER_BP_T_NORMAL)
-			debugger_createExecuteBreakpoint(address);
+			debugger_createCodeBreakpoint(address, DEBUGGER_BP_T_NORMAL);
+		else if (type == DEBUGGER_BP_T_LOGGING)
+			debugger_createCodeBreakpoint(address, DEBUGGER_BP_T_LOGGING);
 		else if (type == DEBUGGER_BP_T_MEMORY_READ)
 			debugger_createMemoryBreakpoint(address, true, false);
 		else if (type == DEBUGGER_BP_T_MEMORY_WRITE)
@@ -177,7 +176,7 @@ void DebuggerModuleStorage::Save(XMLConfigParser& parser)
 
 		// check whether the breakpoint is part of the current module being saved
 		RPLModule* address_module;
-		if (bp->bpType == DEBUGGER_BP_T_NORMAL) address_module = RPLLoader_FindModuleByCodeAddr(bp->address);
+		if (bp->bpType == DEBUGGER_BP_T_NORMAL || bp->bpType == DEBUGGER_BP_T_LOGGING) address_module = RPLLoader_FindModuleByCodeAddr(bp->address);
 		else if (bp->isMemBP()) address_module = RPLLoader_FindModuleByDataAddr(bp->address);
 		else continue;
 
@@ -219,26 +218,27 @@ void DebuggerModuleStorage::Save(XMLConfigParser& parser)
 void DebuggerWindow2::CreateToolBar() 
 {
 	m_toolbar = wxFrame::CreateToolBar(wxTB_HORIZONTAL, wxID_ANY);
-	m_toolbar->SetToolBitmapSize(wxSize(1, 1));
+	m_toolbar->SetToolBitmapSize(wxSize(16, 16));
 
-	m_toolbar->AddTool(TOOL_ID_GOTO, wxEmptyString, wxBITMAP_PNG(DEBUGGER_GOTO), wxNullBitmap, wxITEM_NORMAL, _("GoTo (CTRL + G)"), "test", NULL);
+	m_toolbar->AddTool(TOOL_ID_GOTO, wxEmptyString, wxBITMAP_PNG_FROM_DATA(DEBUGGER_GOTO), wxNullBitmap, wxITEM_NORMAL, _("GoTo (CTRL + G)"), "test", NULL);
 	m_toolbar->AddSeparator();
 
-	m_toolbar->AddTool(TOOL_ID_BP, wxEmptyString, wxBITMAP_PNG(DEBUGGER_BP_RED), wxNullBitmap, wxITEM_NORMAL, _("Toggle Breakpoint (F9)"), wxEmptyString, NULL);
+	m_toolbar->AddTool(TOOL_ID_BP, wxEmptyString, wxBITMAP_PNG_FROM_DATA(DEBUGGER_BP_RED), wxNullBitmap, wxITEM_NORMAL, _("Toggle Breakpoint (F9)"), wxEmptyString, NULL);
 	m_toolbar->AddSeparator();
 
-	m_pause = wxBITMAP_PNG(DEBUGGER_PAUSE);
-	m_run = wxBITMAP_PNG(DEBUGGER_PLAY);
+	m_pause = wxBITMAP_PNG_FROM_DATA(DEBUGGER_PAUSE);
+	m_run = wxBITMAP_PNG_FROM_DATA(DEBUGGER_PLAY);
 	m_toolbar->AddTool(TOOL_ID_PAUSE, wxEmptyString, m_pause, wxNullBitmap, wxITEM_NORMAL, _("Break (F5)"), wxEmptyString, NULL);
 	
-	m_toolbar->AddTool(TOOL_ID_STEP_INTO, wxEmptyString, wxBITMAP_PNG(DEBUGGER_STEP_INTO), wxNullBitmap, wxITEM_NORMAL, _("Step Into (F11)"), wxEmptyString, NULL);
-	m_toolbar->AddTool(TOOL_ID_STEP_OVER, wxEmptyString, wxBITMAP_PNG(DEBUGGER_STEP_OVER), wxNullBitmap, wxITEM_NORMAL, _("Step Over (F10)"), wxEmptyString, NULL);
+	m_toolbar->AddTool(TOOL_ID_STEP_INTO, wxEmptyString, wxBITMAP_PNG_FROM_DATA(DEBUGGER_STEP_INTO), wxNullBitmap, wxITEM_NORMAL, _("Step Into (F11)"), wxEmptyString, NULL);
+	m_toolbar->AddTool(TOOL_ID_STEP_OVER, wxEmptyString, wxBITMAP_PNG_FROM_DATA(DEBUGGER_STEP_OVER), wxNullBitmap, wxITEM_NORMAL, _("Step Over (F10)"), wxEmptyString, NULL);
 	m_toolbar->AddSeparator();
 
 	m_toolbar->Realize();
 
 	m_toolbar->EnableTool(TOOL_ID_STEP_INTO, false);
 	m_toolbar->EnableTool(TOOL_ID_STEP_OVER, false);
+
 }
 
 void DebuggerWindow2::SaveModuleStorage(const RPLModule* module, bool delete_breakpoints)
@@ -262,7 +262,7 @@ void DebuggerWindow2::LoadModuleStorage(const RPLModule* module)
 	bool already_loaded = std::any_of(m_modules_storage.begin(), m_modules_storage.end(), [path](const std::unique_ptr<XMLDebuggerModuleConfig>& debug) { return debug->GetFilename() == path; });
 	if (!path.empty() && !already_loaded)
 	{
-		m_modules_storage.emplace_back(std::move(new XMLDebuggerModuleConfig(path, { module->moduleName2, module->patchCRC, module, false })));
+		m_modules_storage.emplace_back(new XMLDebuggerModuleConfig(path, { module->moduleName2, module->patchCRC, module, false }))->Load();
 	}
 }
 
@@ -272,7 +272,7 @@ DebuggerWindow2::DebuggerWindow2(wxFrame& parent, const wxRect& display_size)
 {
 	this->wxWindowBase::SetBackgroundColour(*wxWHITE);
 
-	const auto file = ActiveSettings::GetPath("debugger/config.xml");
+	const auto file = ActiveSettings::GetConfigPath("debugger/config.xml");
 	m_config.SetFilename(file.generic_wstring());
 	m_config.Load();
 
@@ -384,6 +384,12 @@ void DebuggerWindow2::OnMoveIP(wxCommandEvent& event)
 	m_disasm_ctrl->CenterOffset(ip);
 }
 
+void DebuggerWindow2::OnDisasmCtrlGotoAddress(wxCommandEvent& event)
+{
+	uint32 address = static_cast<uint32>(event.GetExtraLong());
+	UpdateModuleLabel(address);
+}
+
 void DebuggerWindow2::OnParentMove(const wxPoint& main_position, const wxSize& main_size)
 {
 	m_main_position = main_position;
@@ -417,7 +423,7 @@ void DebuggerWindow2::OnNotifyModuleLoaded(wxCommandEvent& event)
 
 void DebuggerWindow2::OnNotifyModuleUnloaded(wxCommandEvent& event)
 {
-	RPLModule* module = (RPLModule*)event.GetClientData();
+	RPLModule* module = (RPLModule*)event.GetClientData(); // todo - the RPL module is already unloaded at this point. Find a better way to handle this
 	SaveModuleStorage(module, true);
 	m_module_window->OnGameLoaded();
 	m_symbol_window->OnGameLoaded();
@@ -471,8 +477,8 @@ bool DebuggerWindow2::Show(bool show)
 
 std::wstring DebuggerWindow2::GetModuleStoragePath(std::string module_name, uint32_t crc_hash) const
 {
-	if (module_name.empty() || crc_hash == 0) return std::wstring();
-	return ActiveSettings::GetPath("debugger/{}_{:#10x}.xml", module_name, crc_hash).generic_wstring();
+	if (module_name.empty() || crc_hash == 0) return {};
+	return ActiveSettings::GetConfigPath("debugger/{}_{:#10x}.xml", module_name, crc_hash).generic_wstring();
 }
 
 void DebuggerWindow2::OnBreakpointHit(wxCommandEvent& event)
@@ -525,29 +531,30 @@ void DebuggerWindow2::OnToolClicked(wxCommandEvent& event)
 void DebuggerWindow2::OnBreakpointChange(wxCommandEvent& event)
 {
 	m_breakpoint_window->OnUpdateView();
+	m_disasm_ctrl->RefreshControl();
 	UpdateModuleLabel();
 }
 
 void DebuggerWindow2::OnOptionsInput(wxCommandEvent& event)
 {
-	switch(event.GetId())
+	switch (event.GetId())
 	{
 	case MENU_ID_OPTIONS_PIN_TO_MAINWINDOW:
-		{
-			const bool value = !m_config.data().pin_to_main;
-			m_config.data().pin_to_main = value;
-			if(value)
-				OnParentMove(m_main_position, m_main_size);
-			
-			break;
-		}
+	{
+		const bool value = !m_config.data().pin_to_main;
+		m_config.data().pin_to_main = value;
+		if (value)
+			OnParentMove(m_main_position, m_main_size);
+
+		break;
+	}
 	case MENU_ID_OPTIONS_BREAK_ON_START:
-		{
+	{
 		const bool value = !m_config.data().break_on_start;
 		m_config.data().break_on_start = value;
 		debuggerState.breakOnEntry = value;
 		break;
-		}
+	}
 	default:
 		return;
 	}
@@ -659,7 +666,7 @@ void DebuggerWindow2::CreateMenuBar()
 
 void DebuggerWindow2::UpdateModuleLabel(uint32 address)
 {
-	if(address == 0)
+	if (address == 0)
 		address = m_disasm_ctrl->GetViewBaseAddress();
 
 	RPLModule* module = RPLLoader_FindModuleByCodeAddr(address);
diff --git a/src/gui/debugger/DebuggerWindow2.h b/src/gui/debugger/DebuggerWindow2.h
index bae41196..145b5e1d 100644
--- a/src/gui/debugger/DebuggerWindow2.h
+++ b/src/gui/debugger/DebuggerWindow2.h
@@ -4,6 +4,7 @@
 #include "config/XMLConfig.h"
 #include "Cafe/HW/Espresso/Debugger/Debugger.h"
 #include "Cafe/OS/RPL/rpl.h"
+#include "Cafe/HW/Espresso/Debugger/GDBStub.h"
 
 #include <wx/bitmap.h>
 #include <wx/frame.h>
@@ -26,10 +27,9 @@ wxDECLARE_EVENT(wxEVT_NOTIFY_MODULE_UNLOADED, wxCommandEvent);
 struct DebuggerConfig
 {
 	DebuggerConfig()
-	: pin_to_main(true), break_on_start(true), show_register(true), show_dump(true), show_stack(true), show_breakpoints(true), show_modules(true) {}
-
+	: pin_to_main(true), break_on_start(true), show_register(true), show_dump(true), show_stack(true), show_breakpoints(true), show_modules(true), show_symbols(true) {}
+	
 	bool pin_to_main;
-
 	bool break_on_start;
 
 	bool show_register;
@@ -86,6 +86,8 @@ private:
 	void OnMoveIP(wxCommandEvent& event);
 	void OnNotifyModuleLoaded(wxCommandEvent& event);
 	void OnNotifyModuleUnloaded(wxCommandEvent& event);
+	// events from DisasmCtrl
+	void OnDisasmCtrlGotoAddress(wxCommandEvent& event);
 
 	void CreateMenuBar();
 	void UpdateModuleLabel(uint32 address = 0);
@@ -95,7 +97,7 @@ private:
 
 	wxPoint m_main_position;
 	wxSize m_main_size;
-
+	
 	RegisterWindow* m_register_window;
 	DumpWindow* m_dump_window;
 	BreakpointWindow* m_breakpoint_window;
diff --git a/src/gui/debugger/DisasmCtrl.cpp b/src/gui/debugger/DisasmCtrl.cpp
index dededf2c..1f4b739f 100644
--- a/src/gui/debugger/DisasmCtrl.cpp
+++ b/src/gui/debugger/DisasmCtrl.cpp
@@ -15,6 +15,8 @@
 #include "Cafe/HW/Espresso/Debugger/DebugSymbolStorage.h"
 #include <wx/mstream.h> // for wxMemoryInputStream
 
+wxDEFINE_EVENT(wxEVT_DISASMCTRL_NOTIFY_GOTO_ADDRESS, wxCommandEvent);
+
 #define MAX_SYMBOL_LEN			(120)
 
 #define COLOR_DEBUG_ACTIVE_BP	0xFFFFA0FF
@@ -74,6 +76,8 @@ DisasmCtrl::DisasmCtrl(wxWindow* parent, const wxWindowID& id, const wxPoint& po
 	auto tooltip_sizer = new wxBoxSizer(wxVERTICAL);
 	tooltip_sizer->Add(new wxStaticText(m_tooltip_window, wxID_ANY, wxEmptyString), 0, wxALL, 5);
 	m_tooltip_window->SetSizer(tooltip_sizer);
+
+	Bind(wxEVT_MENU, &DisasmCtrl::OnContextMenuEntryClicked, this, IDContextMenu_ToggleBreakpoint, IDContextMenu_Last);
 }
 
 void DisasmCtrl::Init()
@@ -147,7 +151,7 @@ void DisasmCtrl::DrawDisassemblyLine(wxDC& dc, const wxPoint& linePosition, MPTR
 	else if (is_active_bp)
 		background_colour = wxColour(0xFF80A0FF);
 	else if (bp != nullptr)
-		background_colour = wxColour(0xFF8080FF);
+		background_colour = wxColour(bp->bpType == DEBUGGER_BP_T_NORMAL ? 0xFF8080FF : 0x80FFFFFF);
 	else if(virtualAddress == m_lastGotoTarget)
 		background_colour = wxColour(0xFFE0E0E0);
 	else
@@ -256,7 +260,7 @@ void DisasmCtrl::DrawDisassemblyLine(wxDC& dc, const wxPoint& linePosition, MPTR
 			{
 				sint32 sImm = disasmInstr.operand[o].immS32;
 				if (disasmInstr.operand[o].immWidth == 16 && (sImm & 0x8000))
-					sImm |= 0xFFFF0000;
+					sImm |= (sint32)0xFFFF0000;
 
 				if ((sImm > -10 && sImm < 10) || forceDecDisplay)
 					string = wxString::Format("%d", sImm);
@@ -534,20 +538,18 @@ void DisasmCtrl::OnKeyPressed(sint32 key_code, const wxPoint& position)
 	auto optVirtualAddress = LinePixelPosToAddress(position.y);
 	switch (key_code)
 	{
-	case WXK_F9:
+		case WXK_F9:
 		{
 			if (optVirtualAddress)
 			{
 				debugger_toggleExecuteBreakpoint(*optVirtualAddress);
 
-				RefreshControl();
-
 				wxCommandEvent evt(wxEVT_BREAKPOINT_CHANGE);
 				wxPostEvent(this->m_parent, evt);
 			}
 			return;
 		}
-	case 'G':
+		case 'G':
 		{
 			if(IsKeyDown(WXK_CONTROL))
 			{
@@ -613,7 +615,7 @@ void DisasmCtrl::OnMouseDClick(const wxPoint& position, uint32 line)
 	{
 		// double-clicked on disassembly (operation and operand data)
 		wxString currentInstruction = wxEmptyString;
-		wxTextEntryDialog set_value_dialog(this, _("Enter a new instruction."), _(wxString::Format("Overwrite instruction at address %08x", virtualAddress)), currentInstruction);
+		wxTextEntryDialog set_value_dialog(this, _("Enter a new instruction."), wxString::Format(_("Overwrite instruction at address %08x"), virtualAddress), currentInstruction);
 		if (set_value_dialog.ShowModal() == wxID_OK)
 		{
 			PPCAssemblerInOut ctx = { 0 };
@@ -635,7 +637,7 @@ void DisasmCtrl::OnMouseDClick(const wxPoint& position, uint32 line)
 		if (comment && comment->type == RplDebugSymbolComment)
 			old_comment = comment->comment;
 
-		wxTextEntryDialog set_value_dialog(this, _("Enter a new comment."), _(wxString::Format("Create comment at address %08x", virtualAddress)), old_comment);
+		wxTextEntryDialog set_value_dialog(this, _("Enter a new comment."), wxString::Format(_("Create comment at address %08x"), virtualAddress), old_comment);
 		if (set_value_dialog.ShowModal() == wxID_OK)
 		{
 			rplDebugSymbol_createComment(virtualAddress, set_value_dialog.GetValue().wc_str());
@@ -664,29 +666,75 @@ void DisasmCtrl::CopyToClipboard(std::string text) {
 #endif
 }
 
+static uint32 GetUnrelocatedAddress(MPTR address)
+{
+	RPLModule* rplModule = RPLLoader_FindModuleByCodeAddr(address);
+	if (!rplModule)
+		return 0;
+	if (address >= rplModule->regionMappingBase_text.GetMPTR() && address < (rplModule->regionMappingBase_text.GetMPTR() + rplModule->regionSize_text))
+		return 0x02000000 + (address - rplModule->regionMappingBase_text.GetMPTR());
+	return 0;
+}
+
 void DisasmCtrl::OnContextMenu(const wxPoint& position, uint32 line)
 {
-	wxPoint pos = position;
 	auto optVirtualAddress = LinePixelPosToAddress(position.y - GetViewStart().y * m_line_height);
 	if (!optVirtualAddress)
 		return;
 	MPTR virtualAddress = *optVirtualAddress;
+	m_contextMenuAddress = virtualAddress;
+	// show dialog
+	wxMenu menu;
+	menu.Append(IDContextMenu_ToggleBreakpoint, _("Toggle breakpoint"));
+	menu.Append(IDContextMenu_ToggleLoggingBreakpoint, _("Toggle logging point"));
+	if(debugger_hasPatch(virtualAddress))
+		menu.Append(IDContextMenu_RestoreOriginalInstructions, _("Restore original instructions"));
+	menu.AppendSeparator();
+	menu.Append(IDContextMenu_CopyAddress, _("Copy address"));
+	uint32 unrelocatedAddress = GetUnrelocatedAddress(virtualAddress);
+	if (unrelocatedAddress && unrelocatedAddress != virtualAddress)
+		menu.Append(IDContextMenu_CopyUnrelocatedAddress, _("Copy virtual address (for IDA/Ghidra)"));
+	PopupMenu(&menu);
+}
 
-	// address
-	if (pos.x <= OFFSET_ADDRESS + OFFSET_ADDRESS_RELATIVE)
+void DisasmCtrl::OnContextMenuEntryClicked(wxCommandEvent& event)
+{
+	switch(event.GetId())
 	{
-		CopyToClipboard(fmt::format("{:#10x}", virtualAddress));
-		return;
-	}
-	else if (pos.x <= OFFSET_ADDRESS + OFFSET_ADDRESS_RELATIVE + OFFSET_DISASSEMBLY)
-	{
-		// double-clicked on disassembly (operation and operand data)
-		return;
-	}
-	else
-	{
-		// comment
-		return;
+		case IDContextMenu_ToggleBreakpoint:
+		{
+			debugger_toggleExecuteBreakpoint(m_contextMenuAddress);
+			wxCommandEvent evt(wxEVT_BREAKPOINT_CHANGE);
+			wxPostEvent(this->m_parent, evt);
+			break;
+		}
+		case IDContextMenu_ToggleLoggingBreakpoint:
+		{
+			debugger_toggleLoggingBreakpoint(m_contextMenuAddress);
+			wxCommandEvent evt(wxEVT_BREAKPOINT_CHANGE);
+			wxPostEvent(this->m_parent, evt);
+			break;
+		}
+		case IDContextMenu_RestoreOriginalInstructions:
+		{
+			debugger_removePatch(m_contextMenuAddress);
+			wxCommandEvent evt(wxEVT_BREAKPOINT_CHANGE); // This also refreshes the disassembly view
+			wxPostEvent(this->m_parent, evt);
+			break;
+		}
+		case IDContextMenu_CopyAddress:
+		{
+			CopyToClipboard(fmt::format("{:#10x}", m_contextMenuAddress));
+			break;
+		}
+		case IDContextMenu_CopyUnrelocatedAddress:
+		{
+			uint32 unrelocatedAddress = GetUnrelocatedAddress(m_contextMenuAddress);
+			CopyToClipboard(fmt::format("{:#10x}", unrelocatedAddress));
+			break;
+		}
+		default:
+			UNREACHABLE;
 	}
 }
 
@@ -724,7 +772,6 @@ std::optional<MPTR> DisasmCtrl::LinePixelPosToAddress(sint32 posY)
 	if (posY < 0)
 		return std::nullopt;
 
-
 	sint32 lineIndex = posY / m_line_height;
 	if (lineIndex >= m_lineToAddress.size())
 		return std::nullopt;
@@ -753,8 +800,6 @@ void DisasmCtrl::CenterOffset(uint32 offset)
 
 	m_active_line = line;
 	RefreshLine(m_active_line);
-
-	debug_printf("scroll to %x\n", debuggerState.debugSession.instructionPointer);
 }
 
 void DisasmCtrl::GoToAddressDialog()
@@ -767,40 +812,42 @@ void DisasmCtrl::GoToAddressDialog()
 		auto value = goto_dialog.GetValue().ToStdString();
 		std::transform(value.begin(), value.end(), value.begin(), tolower);
 
-		const auto module_count = RPLLoader_GetModuleCount();
-		const auto module_list = RPLLoader_GetModuleList();
+		// trim any leading spaces
+		while(!value.empty() && value[0] == ' ')
+			value.erase(value.begin());
 
-		std::vector<double> module_tmp(module_count);
-		for (int i = 0; i < module_count; i++)
-		{
-			const auto module = module_list[i];
-			if (module)
-			{
-				module_tmp[i] = (double)module->regionMappingBase_text.GetMPTR();
-				parser.AddConstant(module->moduleName2, module_tmp[i]);
-			}
-		}
+		debugger_addParserSymbols(parser);
 
-		double grp_tmp[32];
-		PPCSnapshot& ppc_snapshot = debuggerState.debugSession.ppcSnapshot;
-		for (int i = 0; i < 32; i++)
+		// try to parse expression as hex value first (it should interpret 1234 as 0x1234, not 1234)
+		if (parser.IsConstantExpression("0x"+value))
 		{
-			char var_name[32];
-			sprintf(var_name, "r%d", i);
-			grp_tmp[i] = ppc_snapshot.gpr[i];
-			parser.AddConstant(var_name, grp_tmp[i]);
-		}
-
-		try
-		{
-			const auto result = (uint32)parser.Evaluate(value);
-			debug_printf("goto eval result: %x\n", result);
+			const auto result = (uint32)parser.Evaluate("0x"+value);
 			m_lastGotoTarget = result;
 			CenterOffset(result);
-			debuggerWindow_updateViewThreadsafe2();
+			wxCommandEvent evt(wxEVT_DISASMCTRL_NOTIFY_GOTO_ADDRESS);
+			evt.SetExtraLong(static_cast<long>(result));
+			wxPostEvent(GetParent(), evt);
 		}
-		catch (const std::exception& )
+		else if (parser.IsConstantExpression(value))
 		{
+			const auto result = (uint32)parser.Evaluate(value);
+			m_lastGotoTarget = result;
+			CenterOffset(result);
+			wxCommandEvent evt(wxEVT_DISASMCTRL_NOTIFY_GOTO_ADDRESS);
+			evt.SetExtraLong(static_cast<long>(result));
+			wxPostEvent(GetParent(), evt);
+		}
+		else
+		{
+			try
+			{
+				// if not a constant expression (i.e. relying on unknown variables), then evaluating will throw an exception with a detailed error message
+				const auto _ = (uint32)parser.Evaluate(value);
+			}
+			catch (const std::exception& ex)
+			{
+				wxMessageBox(ex.what(), _("Error"), wxOK | wxCENTRE | wxICON_ERROR, this);
+			}
 		}
 	}
-}
\ No newline at end of file
+}
diff --git a/src/gui/debugger/DisasmCtrl.h b/src/gui/debugger/DisasmCtrl.h
index 993d5697..b526e8f9 100644
--- a/src/gui/debugger/DisasmCtrl.h
+++ b/src/gui/debugger/DisasmCtrl.h
@@ -1,9 +1,21 @@
 #pragma once
 #include "gui/components/TextList.h"
 
+wxDECLARE_EVENT(wxEVT_DISASMCTRL_NOTIFY_GOTO_ADDRESS, wxCommandEvent); // Notify parent that goto address operation completed. Event contains the address that was jumped to.
+
 class DisasmCtrl : public TextList
 {
+	enum
+	{
+		IDContextMenu_ToggleBreakpoint = wxID_HIGHEST + 1,
+		IDContextMenu_ToggleLoggingBreakpoint,
+		IDContextMenu_RestoreOriginalInstructions,
+		IDContextMenu_CopyAddress,
+		IDContextMenu_CopyUnrelocatedAddress,
+		IDContextMenu_Last
+	};
 public:
+
 	DisasmCtrl(wxWindow* parent, const wxWindowID& id, const wxPoint& pos, const wxSize& size, long style);
 
 	void Init();
@@ -26,6 +38,7 @@ protected:
 	void OnKeyPressed(sint32 key_code, const wxPoint& position) override;
 	void OnMouseDClick(const wxPoint& position, uint32 line) override;
 	void OnContextMenu(const wxPoint& position, uint32 line) override;
+	void OnContextMenuEntryClicked(wxCommandEvent& event);
 	bool OnShowTooltip(const wxPoint& position, uint32 line) override;
 	void ScrollWindow(int dx, int dy, const wxRect* prect) override;
 
@@ -40,6 +53,7 @@ private:
 	sint32 m_mouse_line, m_mouse_line_drawn;
 	sint32 m_active_line;
 	uint32 m_lastGotoTarget{};
+	uint32 m_contextMenuAddress{};
 	// code region info
 	uint32 currentCodeRegionStart;
 	uint32 currentCodeRegionEnd;
diff --git a/src/gui/debugger/DumpCtrl.cpp b/src/gui/debugger/DumpCtrl.cpp
index d8cd6448..fad93bd3 100644
--- a/src/gui/debugger/DumpCtrl.cpp
+++ b/src/gui/debugger/DumpCtrl.cpp
@@ -196,7 +196,7 @@ void DumpCtrl::OnMouseDClick(const wxPoint& position, uint32 line)
 		const uint32 offset = LineToOffset(line) + byte_index;
 		const uint8 value = memory_readU8(offset);
 
-		wxTextEntryDialog set_value_dialog(this, _("Enter a new value."), _(wxString::Format("Set byte at address %08x", offset)), wxString::Format("%02x", value));
+		wxTextEntryDialog set_value_dialog(this, _("Enter a new value."), wxString::Format(_("Set byte at address %08x"), offset), wxString::Format("%02x", value));
 		if (set_value_dialog.ShowModal() == wxID_OK)
 		{
 			const uint8 new_value = std::stoul(set_value_dialog.GetValue().ToStdString(), nullptr, 16);
@@ -214,46 +214,36 @@ void DumpCtrl::GoToAddressDialog()
 	wxTextEntryDialog goto_dialog(this, _("Enter a target address."), _("GoTo address"), wxEmptyString);
 	if (goto_dialog.ShowModal() == wxID_OK)
 	{
-		try
+		ExpressionParser parser;
+
+		auto value = goto_dialog.GetValue().ToStdString();
+		std::transform(value.begin(), value.end(), value.begin(), tolower);
+
+		debugger_addParserSymbols(parser);
+
+		// try to parse expression as hex value first (it should interpret 1234 as 0x1234, not 1234)
+		if (parser.IsConstantExpression("0x"+value))
 		{
-			ExpressionParser parser;
-
-			auto value = goto_dialog.GetValue().ToStdString();
-			std::transform(value.begin(), value.end(), value.begin(), tolower);
-			//parser.SetExpr(value);
-
-			const auto module_count = RPLLoader_GetModuleCount();
-			const auto module_list = RPLLoader_GetModuleList();
-
-			std::vector<double> module_tmp(module_count);
-			for (int i = 0; i < module_count; i++)
-			{
-				const auto module = module_list[i];
-				if (module)
-				{
-					module_tmp[i] = (double)module->regionMappingBase_text.GetMPTR();
-					parser.AddConstant(module->moduleName2, module_tmp[i]);
-				}
-			}
-
-			double grp_tmp[32];
-			PPCSnapshot& ppc_snapshot = debuggerState.debugSession.ppcSnapshot;
-			for (int i = 0; i < 32; i++)
-			{
-				char var_name[32];
-				sprintf(var_name, "r%d", i);
-				grp_tmp[i] = ppc_snapshot.gpr[i];
-				parser.AddConstant(var_name, grp_tmp[i]);
-			}
-
-			const auto result = (uint32)parser.Evaluate(value);
-			debug_printf("goto eval result: %x\n", result);
+			const auto result = (uint32)parser.Evaluate("0x"+value);
 			m_lastGotoOffset = result;
 			CenterOffset(result);
 		}
-		catch (const std::exception ex)
+		else if (parser.IsConstantExpression(value))
 		{
-			wxMessageBox(ex.what(), _("Error"), wxOK | wxCENTRE | wxICON_ERROR, this);
+			const auto result = (uint32)parser.Evaluate(value);
+			m_lastGotoOffset = result;
+			CenterOffset(result);
+		}
+		else
+		{
+			try
+			{
+				const auto _ = (uint32)parser.Evaluate(value);
+			}
+			catch (const std::exception& ex)
+			{
+				wxMessageBox(ex.what(), _("Error"), wxOK | wxCENTRE | wxICON_ERROR, this);
+			}
 		}
 	}
 }
@@ -313,4 +303,4 @@ void DumpCtrl::OnKeyPressed(sint32 key_code, const wxPoint& position)
 wxSize DumpCtrl::DoGetBestSize() const
 {
 	return TextList::DoGetBestSize();
-}
\ No newline at end of file
+}
diff --git a/src/gui/debugger/ModuleWindow.cpp b/src/gui/debugger/ModuleWindow.cpp
index c24517bd..8183c40c 100644
--- a/src/gui/debugger/ModuleWindow.cpp
+++ b/src/gui/debugger/ModuleWindow.cpp
@@ -126,7 +126,7 @@ void ModuleWindow::OnGameLoaded()
 void ModuleWindow::OnLeftDClick(wxMouseEvent& event)
 {
 	long selected = m_modules->GetFirstSelected();
-	if (selected == -1)
+	if (selected == wxNOT_FOUND)
 		return;
 	const auto text = m_modules->GetItemText(selected, ColumnAddress);
 	const auto address = std::stoul(text.ToStdString(), nullptr, 16);
diff --git a/src/gui/debugger/RegisterCtrl.cpp b/src/gui/debugger/RegisterCtrl.cpp
index bcf6fb5a..24cae60b 100644
--- a/src/gui/debugger/RegisterCtrl.cpp
+++ b/src/gui/debugger/RegisterCtrl.cpp
@@ -201,7 +201,7 @@ void RegisterCtrl::OnMouseDClick(const wxPoint& position, uint32 line)
 		if (position.x <= OFFSET_REGISTER + OFFSET_REGISTER_LABEL)
 		{
 			const uint32 register_value = debuggerState.debugSession.ppcSnapshot.gpr[register_index];
-			wxTextEntryDialog set_value_dialog(this, _("Enter a new value."), _(wxString::Format("Set R%d value", register_index)), wxString::Format("%08x", register_value));
+			wxTextEntryDialog set_value_dialog(this, _("Enter a new value."), wxString::Format(_("Set R%d value"), register_index), wxString::Format("%08x", register_value));
 			if (set_value_dialog.ShowModal() == wxID_OK)
 			{
 				const uint32 new_value = std::stoul(set_value_dialog.GetValue().ToStdString(), nullptr, 16);
@@ -220,7 +220,7 @@ void RegisterCtrl::OnMouseDClick(const wxPoint& position, uint32 line)
 		if (position.x <= OFFSET_REGISTER + OFFSET_FPR)
 		{
 			const double register_value = debuggerState.debugSession.ppcSnapshot.fpr[register_index].fp0;
-			wxTextEntryDialog set_value_dialog(this, _("Enter a new value."), _(wxString::Format("Set FP0_%d value", register_index)), wxString::Format("%lf", register_value));
+			wxTextEntryDialog set_value_dialog(this, _("Enter a new value."), wxString::Format(_("Set FP0_%d value"), register_index), wxString::Format("%lf", register_value));
 			if (set_value_dialog.ShowModal() == wxID_OK)
 			{
 				const double new_value = std::stod(set_value_dialog.GetValue().ToStdString());
@@ -234,7 +234,7 @@ void RegisterCtrl::OnMouseDClick(const wxPoint& position, uint32 line)
 		else
 		{
 			const double register_value = debuggerState.debugSession.ppcSnapshot.fpr[register_index].fp1;
-			wxTextEntryDialog set_value_dialog(this, _("Enter a new value."), _(wxString::Format("Set FP1_%d value", register_index)), wxString::Format("%lf", register_value));
+			wxTextEntryDialog set_value_dialog(this, _("Enter a new value."), wxString::Format(_("Set FP1_%d value"), register_index), wxString::Format("%lf", register_value));
 			if (set_value_dialog.ShowModal() == wxID_OK)
 			{
 				const double new_value = std::stod(set_value_dialog.GetValue().ToStdString());
diff --git a/src/gui/debugger/RegisterWindow.cpp b/src/gui/debugger/RegisterWindow.cpp
index 69c2273d..b18d4e27 100644
--- a/src/gui/debugger/RegisterWindow.cpp
+++ b/src/gui/debugger/RegisterWindow.cpp
@@ -145,7 +145,7 @@ void RegisterWindow::UpdateIntegerRegister(wxTextCtrl* label, wxTextCtrl* value,
 	else if (value->GetForegroundColour() != COLOR_BLACK)
 		value->SetForegroundColour(COLOR_BLACK);
 
-	value->SetLabelText(wxString::Format("%08x", registerValue));
+	value->ChangeValue(wxString::Format("%08x", registerValue));
 
 	//const auto label = dynamic_cast<wxTextCtrl*>(GetWindowChild(kRegisterLabelR0 + i));
 	//wxASSERT(label);
@@ -177,7 +177,7 @@ void RegisterWindow::UpdateIntegerRegister(wxTextCtrl* label, wxTextCtrl* value,
 
 		if (is_valid_string && buffer.tellp() > 1)
 		{
-			label->SetLabelText(wxString::Format("\"%s\"", buffer.str().c_str()));
+			label->ChangeValue(wxString::Format("\"%s\"", buffer.str().c_str()));
 			return;
 		}
 
@@ -206,7 +206,7 @@ void RegisterWindow::UpdateIntegerRegister(wxTextCtrl* label, wxTextCtrl* value,
 
 		if (is_valid_string && buffer.tellp() > 1)
 		{
-			label->SetLabelText(wxString::Format(L"ws\"%s\"", wbuffer.str().c_str()));
+			label->ChangeValue(wxString::Format(L"ws\"%s\"", wbuffer.str().c_str()));
 			return;
 		}
 	}
@@ -215,11 +215,11 @@ void RegisterWindow::UpdateIntegerRegister(wxTextCtrl* label, wxTextCtrl* value,
 	RPLModule* code_module = RPLLoader_FindModuleByCodeAddr(registerValue);
 	if (code_module)
 	{
-		label->SetLabelText(wxString::Format("<%s> + %x", code_module->moduleName2.c_str(), registerValue - code_module->regionMappingBase_text.GetMPTR()));
+		label->ChangeValue(wxString::Format("<%s> + %x", code_module->moduleName2.c_str(), registerValue - code_module->regionMappingBase_text.GetMPTR()));
 		return;
 	}
 
-	label->SetLabelText(wxEmptyString);
+	label->ChangeValue(wxEmptyString);
 }
 
 void RegisterWindow::OnUpdateView()
@@ -264,9 +264,9 @@ void RegisterWindow::OnUpdateView()
 			continue;
 
 		if(m_show_double_values)
-			value->SetLabelText(wxString::Format("%lf", debuggerState.debugSession.ppcSnapshot.fpr[i].fp0));
+			value->ChangeValue(wxString::Format("%lf", debuggerState.debugSession.ppcSnapshot.fpr[i].fp0));
 		else
-			value->SetLabelText(wxString::Format("%016llx", register_value));
+			value->ChangeValue(wxString::Format("%016llx", register_value));
 	}
 
 	for (int i = 0; i < 32; ++i)
@@ -285,9 +285,9 @@ void RegisterWindow::OnUpdateView()
 			continue;
 
 		if (m_show_double_values)
-			value->SetLabelText(wxString::Format("%lf", debuggerState.debugSession.ppcSnapshot.fpr[i].fp1));
+			value->ChangeValue(wxString::Format("%lf", debuggerState.debugSession.ppcSnapshot.fpr[i].fp1));
 		else
-			value->SetLabelText(wxString::Format("%016llx", register_value));
+			value->ChangeValue(wxString::Format("%016llx", register_value));
 	}
 
 	// update CRs
@@ -318,9 +318,9 @@ void RegisterWindow::OnUpdateView()
 			joinArray.emplace_back("SO");
 
 		if (joinArray.empty())
-			value->SetLabelText("-");
+			value->ChangeValue("-");
 		else
-			value->SetLabelText(fmt::format("{}", fmt::join(joinArray, ", ")));
+			value->ChangeValue(fmt::format("{}", fmt::join(joinArray, ", ")));
 	}
 
 	memcpy(&m_prev_snapshot, &debuggerState.debugSession.ppcSnapshot, sizeof(m_prev_snapshot));
@@ -339,7 +339,7 @@ void RegisterWindow::OnMouseDClickEvent(wxMouseEvent& event)
 	{
 		const uint32 register_index = id - kRegisterValueR0;
 		const uint32 register_value = debuggerState.debugSession.ppcSnapshot.gpr[register_index];
-		wxTextEntryDialog set_value_dialog(this, _("Enter a new value."), _(wxString::Format("Set R%d value", register_index)), wxString::Format("%08x", register_value));
+		wxTextEntryDialog set_value_dialog(this, _("Enter a new value."), wxString::Format(_("Set R%d value"), register_index), wxString::Format("%08x", register_value));
 		if (set_value_dialog.ShowModal() == wxID_OK)
 		{
 			const uint32 new_value = std::stoul(set_value_dialog.GetValue().ToStdString(), nullptr, 16);
@@ -355,7 +355,7 @@ void RegisterWindow::OnMouseDClickEvent(wxMouseEvent& event)
 	{
 		const uint32 register_index = id - kRegisterValueFPR0_0;
 		const double register_value = debuggerState.debugSession.ppcSnapshot.fpr[register_index].fp0;
-		wxTextEntryDialog set_value_dialog(this, _("Enter a new value."), _(wxString::Format("Set FP0_%d value", register_index)), wxString::Format("%lf", register_value));
+		wxTextEntryDialog set_value_dialog(this, _("Enter a new value."), wxString::Format(_("Set FP0_%d value"), register_index), wxString::Format("%lf", register_value));
 		if (set_value_dialog.ShowModal() == wxID_OK)
 		{
 			const double new_value = std::stod(set_value_dialog.GetValue().ToStdString());
@@ -371,7 +371,7 @@ void RegisterWindow::OnMouseDClickEvent(wxMouseEvent& event)
 	{
 		const uint32 register_index = id - kRegisterValueFPR1_0;
 		const double register_value = debuggerState.debugSession.ppcSnapshot.fpr[register_index].fp1;
-		wxTextEntryDialog set_value_dialog(this, _("Enter a new value."), _(wxString::Format("Set FP1_%d value", register_index)), wxString::Format("%lf", register_value));
+		wxTextEntryDialog set_value_dialog(this, _("Enter a new value."), wxString::Format(_("Set FP1_%d value"), register_index), wxString::Format("%lf", register_value));
 		if (set_value_dialog.ShowModal() == wxID_OK)
 		{
 			const double new_value = std::stod(set_value_dialog.GetValue().ToStdString());
@@ -399,13 +399,13 @@ void RegisterWindow::OnFPViewModePress(wxCommandEvent& event)
 
 		if (m_show_double_values)
 		{
-			value0->SetLabelText(wxString::Format("%lf", debuggerState.debugSession.ppcSnapshot.fpr[i].fp0));
-			value1->SetLabelText(wxString::Format("%lf", debuggerState.debugSession.ppcSnapshot.fpr[i].fp1));
+			value0->ChangeValue(wxString::Format("%lf", debuggerState.debugSession.ppcSnapshot.fpr[i].fp0));
+			value1->ChangeValue(wxString::Format("%lf", debuggerState.debugSession.ppcSnapshot.fpr[i].fp1));
 		}
 		else
 		{
-			value0->SetLabelText(wxString::Format("%016llx", debuggerState.debugSession.ppcSnapshot.fpr[i].fp0int));
-			value1->SetLabelText(wxString::Format("%016llx", debuggerState.debugSession.ppcSnapshot.fpr[i].fp1int));
+			value0->ChangeValue(wxString::Format("%016llx", debuggerState.debugSession.ppcSnapshot.fpr[i].fp0int));
+			value1->ChangeValue(wxString::Format("%016llx", debuggerState.debugSession.ppcSnapshot.fpr[i].fp1int));
 		}
 	}
 }
diff --git a/src/gui/debugger/SymbolCtrl.cpp b/src/gui/debugger/SymbolCtrl.cpp
index d9adaa32..57cc96f6 100644
--- a/src/gui/debugger/SymbolCtrl.cpp
+++ b/src/gui/debugger/SymbolCtrl.cpp
@@ -2,6 +2,7 @@
 #include "gui/guiWrapper.h"
 #include "Cafe/OS/RPL/rpl_symbol_storage.h"
 #include "Cafe/HW/Espresso/Debugger/Debugger.h"
+#include <wx/listctrl.h>
 
 enum ItemColumns
 {
@@ -10,8 +11,7 @@ enum ItemColumns
 	ColumnModule,
 };
 
-SymbolListCtrl::SymbolListCtrl(wxWindow* parent, const wxWindowID& id, const wxPoint& pos, const wxSize& size) :
-	wxListCtrl(parent, id, pos, size, wxLC_REPORT | wxLC_VIRTUAL)
+SymbolListCtrl::SymbolListCtrl(wxWindow* parent, const wxWindowID& id, const wxPoint& pos, const wxSize& size) : wxListView(parent, id, pos, size, wxLC_REPORT | wxLC_VIRTUAL)
 {    
 	wxListItem col0;
 	col0.SetId(ColumnName);
@@ -36,7 +36,7 @@ SymbolListCtrl::SymbolListCtrl(wxWindow* parent, const wxWindowID& id, const wxP
 	Bind(wxEVT_LIST_ITEM_ACTIVATED, &SymbolListCtrl::OnLeftDClick, this);
 	Bind(wxEVT_LIST_ITEM_RIGHT_CLICK, &SymbolListCtrl::OnRightClick, this);
 
-	m_list_filter = "";
+	m_list_filter.Clear();
 
 	OnGameLoaded();
 
@@ -46,26 +46,26 @@ SymbolListCtrl::SymbolListCtrl(wxWindow* parent, const wxWindowID& id, const wxP
 void SymbolListCtrl::OnGameLoaded()
 {
 	m_data.clear();
-	long itemId = 0;
 	const auto symbol_map = rplSymbolStorage_lockSymbolMap();
 	for (auto const& [address, symbol_info] : symbol_map)
 	{
 		if (symbol_info == nullptr || symbol_info->symbolName == nullptr)
 			continue;
 
+		wxString libNameWX = wxString::FromAscii((const char*)symbol_info->libName);
+		wxString symbolNameWX = wxString::FromAscii((const char*)symbol_info->symbolName);
+		wxString searchNameWX = libNameWX + symbolNameWX;
+		searchNameWX.MakeLower();
+
 		auto new_entry = m_data.try_emplace(
 			symbol_info->address,
-			(char*)(symbol_info->symbolName),
-            (char*)(symbol_info->libName),
-            "",
+            symbolNameWX,
+			libNameWX,
+            searchNameWX,
 			false
 		);
 
-		new_entry.first->second.searchName += new_entry.first->second.name;
-		new_entry.first->second.searchName += new_entry.first->second.libName;
-		new_entry.first->second.searchName.MakeLower();
-
-		if (m_list_filter == "")
+		if (m_list_filter.IsEmpty())
 			new_entry.first->second.visible = true;
 		else if (new_entry.first->second.searchName.Contains(m_list_filter))
 			new_entry.first->second.visible = true;
@@ -106,8 +106,8 @@ wxString SymbolListCtrl::OnGetItemText(long item, long column) const
 
 void SymbolListCtrl::OnLeftDClick(wxListEvent& event)
 {
-	long selected = GetNextItem(-1, wxLIST_NEXT_ALL, wxLIST_STATE_SELECTED);
-	if (selected == -1)
+	long selected = GetFirstSelected();
+	if (selected == wxNOT_FOUND)
 		return;
 	const auto text = GetItemText(selected, ColumnAddress);
 	const auto address = std::stoul(text.ToStdString(), nullptr, 16);
@@ -119,8 +119,8 @@ void SymbolListCtrl::OnLeftDClick(wxListEvent& event)
 
 void SymbolListCtrl::OnRightClick(wxListEvent& event)
 {
-	long selected = GetNextItem(-1, wxLIST_NEXT_ALL, wxLIST_STATE_SELECTED);
-	if (selected == -1)
+	long selected = GetFirstSelected();
+	if (selected == wxNOT_FOUND)
 		return;
 	auto text = GetItemText(selected, ColumnAddress);
 	text = "0x" + text;
@@ -149,7 +149,7 @@ void SymbolListCtrl::ChangeListFilter(std::string filter)
 	size_t visible_entries = m_data.size();
 	for (auto& [address, symbol] : m_data)
 	{
-		if (m_list_filter == "")
+		if (m_list_filter.IsEmpty())
 			symbol.visible = true;
 		else if (symbol.searchName.Contains(m_list_filter))
 			symbol.visible = true;
@@ -162,4 +162,4 @@ void SymbolListCtrl::ChangeListFilter(std::string filter)
 	SetItemCount(visible_entries);
 	if (visible_entries > 0)
 		RefreshItems(GetTopItem(), std::min<long>(visible_entries - 1, GetTopItem() + GetCountPerPage() + 1));
-}
\ No newline at end of file
+}
diff --git a/src/gui/debugger/SymbolCtrl.h b/src/gui/debugger/SymbolCtrl.h
index 9aebdedc..8a0161bd 100644
--- a/src/gui/debugger/SymbolCtrl.h
+++ b/src/gui/debugger/SymbolCtrl.h
@@ -2,7 +2,7 @@
 
 #include <wx/listctrl.h>
 
-class SymbolListCtrl : public wxListCtrl
+class SymbolListCtrl : public wxListView
 {
 public:
 	SymbolListCtrl(wxWindow* parent, const wxWindowID& id, const wxPoint& pos, const wxSize& size);
@@ -11,7 +11,7 @@ public:
 	void ChangeListFilter(std::string filter);
 private:
 	struct SymbolItem {
-        SymbolItem() {}
+        SymbolItem() = default;
         SymbolItem(wxString name, wxString libName, wxString searchName, bool visible) : name(name), libName(libName), searchName(searchName), visible(visible) {}
 
 
diff --git a/src/gui/dialogs/CreateAccount/wxCreateAccountDialog.cpp b/src/gui/dialogs/CreateAccount/wxCreateAccountDialog.cpp
index 71b56637..82b4d795 100644
--- a/src/gui/dialogs/CreateAccount/wxCreateAccountDialog.cpp
+++ b/src/gui/dialogs/CreateAccount/wxCreateAccountDialog.cpp
@@ -7,6 +7,7 @@
 #include <wx/button.h>
 #include <wx/textctrl.h>
 #include <wx/msgdlg.h>
+#include <helpers/wxHelpers.h>
 #include "util/helpers/helpers.h"
 
 wxCreateAccountDialog::wxCreateAccountDialog(wxWindow* parent)
@@ -17,13 +18,13 @@ wxCreateAccountDialog::wxCreateAccountDialog(wxWindow* parent)
 	main_sizer->SetFlexibleDirection(wxBOTH);
 	main_sizer->SetNonFlexibleGrowMode(wxFLEX_GROWMODE_SPECIFIED);
 
-	main_sizer->Add(new wxStaticText(this, wxID_ANY, wxT("PersistentId")), 0, wxALIGN_CENTER_VERTICAL | wxALL, 5);
+	main_sizer->Add(new wxStaticText(this, wxID_ANY, "PersistentId"), 0, wxALIGN_CENTER_VERTICAL | wxALL, 5);
 	
 	m_persistent_id = new wxTextCtrl(this, wxID_ANY, fmt::format("{:x}", Account::GetNextPersistentId()));
 	m_persistent_id->SetToolTip(_("The persistent id is the internal folder name used for your saves. Only change this if you are importing saves from a Wii U with a specific id"));
 	main_sizer->Add(m_persistent_id, 1, wxALL | wxEXPAND, 5);
 
-	main_sizer->Add(new wxStaticText(this, wxID_ANY, wxT("Mii name")), 0, wxALIGN_CENTER_VERTICAL | wxALL, 5);
+	main_sizer->Add(new wxStaticText(this, wxID_ANY, _("Mii name")), 0, wxALIGN_CENTER_VERTICAL | wxALL, 5);
 
 	m_mii_name = new wxTextCtrl(this, wxID_ANY);
 	m_mii_name->SetFocus();
@@ -71,7 +72,7 @@ void wxCreateAccountDialog::OnOK(wxCommandEvent& event)
 	const auto id = GetPersistentId();
 	if(id < Account::kMinPersistendId)
 	{
-		wxMessageBox(fmt::format(fmt::runtime(_("The persistent id must be greater than {:x}!").ToStdString()), Account::kMinPersistendId),
+		wxMessageBox(formatWxString(_("The persistent id must be greater than {:x}!"), Account::kMinPersistendId),
 			_("Error"), wxOK | wxCENTRE | wxICON_ERROR, this);
 		return;
 	}
diff --git a/src/gui/dialogs/SaveImport/SaveImportWindow.cpp b/src/gui/dialogs/SaveImport/SaveImportWindow.cpp
index 9b7b20cc..1b1fecbf 100644
--- a/src/gui/dialogs/SaveImport/SaveImportWindow.cpp
+++ b/src/gui/dialogs/SaveImport/SaveImportWindow.cpp
@@ -30,8 +30,8 @@ SaveImportWindow::SaveImportWindow(wxWindow* parent, uint64 title_id)
 
 		row1->Add(new wxStaticText(this, wxID_ANY, _("Source")), 0, wxALIGN_CENTER_VERTICAL | wxALL, 5);
 		m_source_selection = new wxFilePickerCtrl(this, wxID_ANY, wxEmptyString,
-			_("Select a zipped save file"), 
-			wxStringFormat2("{}|*.zip", _("Save entry (*.zip)")));
+			_("Select a zipped save file"),
+			formatWxString("{}|*.zip", _("Save entry (*.zip)")));
 		m_source_selection->SetMinSize({ 270, -1 });
 		row1->Add(m_source_selection, 1, wxALL | wxEXPAND, 5);
 
@@ -118,7 +118,7 @@ void SaveImportWindow::OnImport(wxCommandEvent& event)
 					const uint64_t titleId = ConvertString<uint64>(str.substr(sizeof("titleId = ") + 1), 16);
 					if(titleId != 0 && titleId != m_title_id)
 					{
-						const auto msg = wxStringFormat2(_("You are trying to import a savegame for a different title than your currently selected one: {:016x} vs {:016x}\nAre you sure that you want to continue?"), titleId, m_title_id);
+						const auto msg = formatWxString(_("You are trying to import a savegame for a different title than your currently selected one: {:016x} vs {:016x}\nAre you sure that you want to continue?"), titleId, m_title_id);
 						const auto res = wxMessageBox(msg, _("Error"), wxYES_NO | wxCENTRE | wxICON_WARNING, this);
 						if(res == wxNO)
 						{
@@ -143,7 +143,7 @@ void SaveImportWindow::OnImport(wxCommandEvent& event)
 	//auto tmp_source = fs::temp_directory_path(ec);
 	//if(ec)
 	//{
-	//	const auto error_msg = wxStringFormat2(_("Error when getting the temp directory path:\n{}"), GetSystemErrorMessage(ec));
+	//	const auto error_msg = formatWxString(_("Error when getting the temp directory path:\n{}"), GetSystemErrorMessage(ec));
 	//	wxMessageBox(error_msg, _("Error"), wxOK | wxCENTRE | wxICON_ERROR, this);
 	//	return;
 	//}
@@ -158,7 +158,7 @@ void SaveImportWindow::OnImport(wxCommandEvent& event)
 		target_id = ConvertString<uint32>(m_target_selection->GetValue().ToStdString(), 16);
 		if (target_id < Account::kMinPersistendId)
 		{
-			const auto msg = wxStringFormat2(_("The given account id is not valid!\nIt must be a hex number bigger or equal than {:08x}"), Account::kMinPersistendId);
+			const auto msg = formatWxString(_("The given account id is not valid!\nIt must be a hex number bigger or equal than {:08x}"), Account::kMinPersistendId);
 			wxMessageBox(msg, _("Error"), wxOK | wxCENTRE | wxICON_ERROR, this);
 			return;
 		}
@@ -170,7 +170,7 @@ void SaveImportWindow::OnImport(wxCommandEvent& event)
 	{
 		if (!fs::is_directory(target_path))
 		{
-			const auto msg = wxStringFormat2(_("There's already a file at the target directory:\n{}"), _pathToUtf8(target_path));
+			const auto msg = formatWxString(_("There's already a file at the target directory:\n{}"), _pathToUtf8(target_path));
 			wxMessageBox(msg, _("Error"), wxOK | wxCENTRE | wxICON_ERROR, this);
 			m_return_code = wxCANCEL;
 			Close();
@@ -193,7 +193,7 @@ void SaveImportWindow::OnImport(wxCommandEvent& event)
 
 			if (ec)
 			{
-				const auto error_msg = wxStringFormat2(_("Error when trying to delete the former save game:\n{}"), GetSystemErrorMessage(ec));
+				const auto error_msg = formatWxString(_("Error when trying to delete the former save game:\n{}"), GetSystemErrorMessage(ec));
 				wxMessageBox(error_msg, _("Error"), wxOK | wxCENTRE, this);
 				return;
 			}
@@ -213,7 +213,7 @@ void SaveImportWindow::OnImport(wxCommandEvent& event)
 	fs::create_directories(tmp_source, ec);
 	if (ec)
 	{
-		const auto error_msg = wxStringFormat2(_("Error when creating the extraction path:\n{}"), GetSystemErrorMessage(ec));
+		const auto error_msg = formatWxString(_("Error when creating the extraction path:\n{}"), GetSystemErrorMessage(ec));
 		wxMessageBox(error_msg, _("Error"), wxOK | wxCENTRE | wxICON_ERROR, this);
 		return;
 	}
@@ -221,7 +221,7 @@ void SaveImportWindow::OnImport(wxCommandEvent& event)
 	zip = zip_open(zipfile.c_str(), ZIP_RDONLY, &ziperr);
 	if (!zip)
 	{
-		const auto error_msg = wxStringFormat2(_("Error when opening the import zip file:\n{}"), GetSystemErrorMessage(ec));
+		const auto error_msg = formatWxString(_("Error when opening the import zip file:\n{}"), GetSystemErrorMessage(ec));
 		wxMessageBox(error_msg, _("Error"), wxOK | wxCENTRE | wxICON_ERROR, this);
 		return;
 	}
@@ -232,7 +232,7 @@ void SaveImportWindow::OnImport(wxCommandEvent& event)
 		zip_stat_t sb{};
 		if (zip_stat_index(zip, i, 0, &sb) != 0)
 		{
-			forceLog_printf("zip stat index failed on %d entry", i);
+			cemuLog_log(LogType::Force, "zip stat index failed on {} entry", i);
 			continue;
 		}
 
@@ -251,7 +251,7 @@ void SaveImportWindow::OnImport(wxCommandEvent& event)
 		{
 			fs::create_directories(path, ec);
 			if (ec)
-				forceLog_printf("can't create directory %s: %s", sb.name, ec.message().c_str());
+				cemuLog_log(LogType::Force, "can't create directory {}: {}", sb.name, ec.message());
 
 			continue;
 		}
@@ -304,10 +304,10 @@ void SaveImportWindow::OnImport(wxCommandEvent& event)
 					auto new_node = info_node.append_child("account");
 					new_node.append_attribute("persistentId").set_value(new_persistend_id_string.c_str());
 					auto timestamp = new_node.append_child("timestamp");
-					timestamp.text().set(fmt::format("{:016x}", coreinit::coreinit_getOSTime() / ESPRESSO_TIMER_CLOCK).c_str()); // TODO time not initialized yet?
+					timestamp.text().set(fmt::format("{:016x}", coreinit::OSGetTime() / ESPRESSO_TIMER_CLOCK).c_str()); // TODO time not initialized yet?
 					
 					if(!doc.save_file(saveinfo.c_str()))
-						forceLog_printf("couldn't insert save entry in saveinfo.xml: %s", saveinfo.generic_u8string().c_str());
+						cemuLog_log(LogType::Force, "couldn't insert save entry in saveinfo.xml: {}", _pathToUtf8(saveinfo));
 				}
 			}
 		}
@@ -319,7 +319,7 @@ void SaveImportWindow::OnImport(wxCommandEvent& event)
 	fs::rename(tmp_source, target_path, ec);
 	if (ec)
 	{
-		const auto error_msg = wxStringFormat2(_("Error when trying to move the extracted save game:\n{}"), GetSystemErrorMessage(ec));
+		const auto error_msg = formatWxString(_("Error when trying to move the extracted save game:\n{}"), GetSystemErrorMessage(ec));
 		wxMessageBox(error_msg, _("Error"), wxOK | wxCENTRE, this);
 		return;
 	}*/
diff --git a/src/gui/dialogs/SaveImport/SaveTransfer.cpp b/src/gui/dialogs/SaveImport/SaveTransfer.cpp
index ad11fba6..c763c419 100644
--- a/src/gui/dialogs/SaveImport/SaveTransfer.cpp
+++ b/src/gui/dialogs/SaveImport/SaveTransfer.cpp
@@ -92,7 +92,7 @@ void SaveTransfer::OnTransfer(wxCommandEvent& event)
 		target_id = ConvertString<uint32>(m_target_selection->GetValue().ToStdString(), 16);
 		if(target_id < Account::kMinPersistendId)
 		{
-			const auto msg = wxStringFormat2(_("The given account id is not valid!\nIt must be a hex number bigger or equal than {:08x}"), Account::kMinPersistendId);
+			const auto msg = formatWxString(_("The given account id is not valid!\nIt must be a hex number bigger or equal than {:08x}"), Account::kMinPersistendId);
 			wxMessageBox(msg, _("Error"), wxOK | wxCENTRE | wxICON_ERROR, this);
 			return;
 		}
@@ -108,7 +108,7 @@ void SaveTransfer::OnTransfer(wxCommandEvent& event)
 	{
 		if(!fs::is_directory(target_path))
 		{
-			const auto msg = wxStringFormat2(_("There's already a file at the target directory:\n{}"), _pathToUtf8(target_path));
+			const auto msg = formatWxString(_("There's already a file at the target directory:\n{}"), _pathToUtf8(target_path));
 			wxMessageBox(msg, _("Error"), wxOK | wxCENTRE | wxICON_ERROR, this);
 			m_return_code = wxCANCEL;
 			Close();
@@ -131,7 +131,7 @@ void SaveTransfer::OnTransfer(wxCommandEvent& event)
 
 			if (ec)
 			{
-				const auto error_msg = wxStringFormat2(_("Error when trying to delete the former save game:\n{}"), GetSystemErrorMessage(ec));
+				const auto error_msg = formatWxString(_("Error when trying to delete the former save game:\n{}"), GetSystemErrorMessage(ec));
 				wxMessageBox(error_msg, _("Error"), wxOK | wxCENTRE, this);
 				return;
 			}
@@ -181,13 +181,13 @@ void SaveTransfer::OnTransfer(wxCommandEvent& event)
 	}
 
 	if (!meta_file_edited)
-		forceLog_printf("SaveTransfer::OnTransfer: couldn't update save entry in saveinfo.xml: %s", saveinfo.generic_u8string().c_str());
+		cemuLog_log(LogType::Force, "SaveTransfer::OnTransfer: couldn't update save entry in saveinfo.xml: {}", _pathToUtf8(saveinfo));
 
 	std::error_code ec;
 	fs::rename(source_path, target_path, ec);
 	if (ec)
 	{
-		const auto error_msg = wxStringFormat2(_("Error when trying to move the save game:\n{}"), GetSystemErrorMessage(ec));
+		const auto error_msg = formatWxString(_("Error when trying to move the save game:\n{}"), GetSystemErrorMessage(ec));
 		wxMessageBox(error_msg, _("Error"), wxOK | wxCENTRE, this);
 		return;
 	}
diff --git a/src/gui/guiWrapper.cpp b/src/gui/guiWrapper.cpp
index 6c06f4f9..d887e89a 100644
--- a/src/gui/guiWrapper.cpp
+++ b/src/gui/guiWrapper.cpp
@@ -1,3 +1,13 @@
+#if BOOST_OS_LINUX
+#include <gtk/gtk.h>
+#include <gdk/gdk.h>
+#include <gdk/gdkwindow.h>
+#include <gdk/gdkx.h>
+#ifdef HAS_WAYLAND
+#include <gdk/gdkwayland.h>
+#endif
+#endif
+
 #include "gui/wxgui.h"
 #include "gui/guiWrapper.h"
 #include "gui/CemuApp.h"
@@ -5,6 +15,7 @@
 #include "gui/debugger/DebuggerWindow2.h"
 #include "Cafe/HW/Latte/Core/Latte.h"
 #include "config/ActiveSettings.h"
+#include "config/NetworkSettings.h"
 #include "config/CemuConfig.h"
 #include "Cafe/HW/Latte/Renderer/Renderer.h"
 #include "Cafe/CafeSystem.h"
@@ -26,7 +37,7 @@ void _wxLaunch()
 
 void gui_create()
 {
-	SetThreadName("MainThread");
+	SetThreadName("cemu");
 #if BOOST_OS_WINDOWS
 	// on Windows wxWidgets there is a bug where wxDirDialog->ShowModal will deadlock in Windows internals somehow
 	// moving the UI thread off the main thread fixes this
@@ -82,10 +93,6 @@ void gui_updateWindowTitles(bool isIdle, bool isLoading, double fps)
 	const char* graphicMode = "[Generic]";
 	if (LatteGPUState.glVendor == GLVENDOR_AMD)
 		graphicMode = "[AMD GPU]";
-	else if (LatteGPUState.glVendor == GLVENDOR_INTEL_LEGACY)
-		graphicMode = "[Intel GPU - Legacy]";
-	else if (LatteGPUState.glVendor == GLVENDOR_INTEL_NOLEGACY)
-		graphicMode = "[Intel GPU]";
 	else if (LatteGPUState.glVendor == GLVENDOR_INTEL)
 		graphicMode = "[Intel GPU]";
 	else if (LatteGPUState.glVendor == GLVENDOR_NVIDIA)
@@ -97,8 +104,14 @@ void gui_updateWindowTitles(bool isIdle, bool isLoading, double fps)
     windowText.append(fmt::format(" - FPS: {:.2f} {} {} [TitleId: {:08x}-{:08x}]", (double)fps, renderer, graphicMode, (uint32)(titleId >> 32), (uint32)(titleId & 0xFFFFFFFF)));
 
     if (ActiveSettings::IsOnlineEnabled())
-        windowText.append(" [Online]");
-
+	{
+		if (ActiveSettings::GetNetworkService() == NetworkService::Nintendo)
+			windowText.append(" [Online]");
+		else if (ActiveSettings::GetNetworkService() == NetworkService::Pretendo)
+			 windowText.append(" [Online-Pretendo]");
+		else if (ActiveSettings::GetNetworkService() == NetworkService::Custom)
+			 windowText.append(" [Online-" + GetNetworkConfig().networkname.GetValue() + "]");
+	}
     windowText.append(" ");
 	windowText.append(CafeSystem::GetForegroundTitleName());
 	// append region
@@ -119,40 +132,70 @@ void gui_updateWindowTitles(bool isIdle, bool isLoading, double fps)
 		g_mainFrame->AsyncSetTitle(windowText);
 		auto* pad = g_mainFrame->GetPadView();
 		if (pad)
-			pad->AsyncSetTitle(fmt::format("GamePad View - FPS: {:.02f}", fps));
+			pad->AsyncSetTitle(fmt::format("{} - FPS: {:.02f}", _("GamePad View").utf8_string(), fps));
 	}
 }
 
-void gui_getWindowSize(int* w, int* h)
+void gui_getWindowSize(int& w, int& h)
 {
-	*w = g_window_info.width;
-	*h = g_window_info.height;
+	w = g_window_info.width;
+	h = g_window_info.height;
 }
 
-void gui_getPadWindowSize(int* w, int* h)
+void gui_getPadWindowSize(int& w, int& h)
 {
 	if (g_window_info.pad_open)
 	{
-		*w = g_window_info.pad_width;
-		*h = g_window_info.pad_height;
+		w = g_window_info.pad_width;
+		h = g_window_info.pad_height;
 	}
 	else
 	{
-		*w = 0;
-		*h = 0;
+		w = 0;
+		h = 0;
 	}
 }
 
+void gui_getWindowPhysSize(int& w, int& h)
+{
+	w = g_window_info.phys_width;
+	h = g_window_info.phys_height;
+}
+
+void gui_getPadWindowPhysSize(int& w, int& h)
+{
+	if (g_window_info.pad_open)
+	{
+		w = g_window_info.phys_pad_width;
+		h = g_window_info.phys_pad_height;
+	}
+	else
+	{
+		w = 0;
+		h = 0;
+	}
+}
+
+double gui_getWindowDPIScale()
+{
+	return g_window_info.dpi_scale;
+}
+
+double gui_getPadDPIScale()
+{
+	return g_window_info.pad_open ? g_window_info.pad_dpi_scale.load() : 1.0;
+}
+
 bool gui_isPadWindowOpen()
 {
 	return g_window_info.pad_open;
 }
 
 #if BOOST_OS_LINUX
-#include <wx/nativewin.h>
-#include <dlfcn.h>
-
-typedef void GdkDisplay;
+std::string gui_gtkRawKeyCodeToString(uint32 keyCode)
+{
+	return gdk_keyval_name(keyCode);
+}
 #endif
 
 void gui_initHandleContextFromWxWidgetsWindow(WindowHandleInfo& handleInfoOut, class wxWindow* wxw)
@@ -160,56 +203,46 @@ void gui_initHandleContextFromWxWidgetsWindow(WindowHandleInfo& handleInfoOut, c
 #if BOOST_OS_WINDOWS
 	handleInfoOut.hwnd = wxw->GetHWND();
 #elif BOOST_OS_LINUX
-    /* dynamically retrieve GTK imports so we dont have to include and link the whole lib */
-    void (*dyn_gtk_widget_realize)(GtkWidget *widget);
-    dyn_gtk_widget_realize = (void(*)(GtkWidget* widget))dlsym(RTLD_NEXT, "gtk_widget_realize");
-
-    GdkWindow* (*dyn_gtk_widget_get_window)(GtkWidget *widget);
-    dyn_gtk_widget_get_window = (GdkWindow*(*)(GtkWidget* widget))dlsym(RTLD_NEXT, "gtk_widget_get_window");
-
-    GdkDisplay* (*dyn_gdk_window_get_display)(GdkWindow *widget);
-    dyn_gdk_window_get_display = (GdkDisplay*(*)(GdkWindow* window))dlsym(RTLD_NEXT, "gdk_window_get_display");
-
-    Display* (*dyn_gdk_x11_display_get_xdisplay)(GdkDisplay *display);
-    dyn_gdk_x11_display_get_xdisplay = (Display*(*)(GdkDisplay* display))dlsym(RTLD_NEXT, "gdk_x11_display_get_xdisplay");
-
-    Window (*dyn_gdk_x11_window_get_xid)(GdkWindow *window);
-    dyn_gdk_x11_window_get_xid = (Window(*)(GdkWindow *window))dlsym(RTLD_NEXT, "gdk_x11_window_get_xid");
-
-    if(!dyn_gtk_widget_realize || !dyn_gtk_widget_get_window ||
-    !dyn_gdk_window_get_display || !dyn_gdk_x11_display_get_xdisplay ||
-    !dyn_gdk_x11_window_get_xid)
-    {
-        cemuLog_log(LogType::Force, "Unable to load GDK symbols");
-        return;
-    }
-
-    /* end of imports */
-
-    // get window
     GtkWidget* gtkWidget = (GtkWidget*)wxw->GetHandle(); // returns GtkWidget
-    dyn_gtk_widget_realize(gtkWidget);
-    GdkWindow* gdkWindow = dyn_gtk_widget_get_window(gtkWidget);
-    handleInfoOut.xlib_window = dyn_gdk_x11_window_get_xid(gdkWindow);
-
-    // get display
-    GdkDisplay* gdkDisplay = dyn_gdk_window_get_display(gdkWindow);
-    handleInfoOut.xlib_display = dyn_gdk_x11_display_get_xdisplay(gdkDisplay);
-    if(!handleInfoOut.xlib_display)
-    {
-        cemuLog_log(LogType::Force, "Unable to get xlib display");
-    }
+    gtk_widget_realize(gtkWidget);
+    GdkWindow* gdkWindow = gtk_widget_get_window(gtkWidget);
+	GdkDisplay* gdkDisplay = gdk_window_get_display(gdkWindow);
+	if(GDK_IS_X11_WINDOW(gdkWindow))
+	{
+		handleInfoOut.backend = WindowHandleInfo::Backend::X11;
+		handleInfoOut.xlib_window = gdk_x11_window_get_xid(gdkWindow);
+		handleInfoOut.xlib_display = gdk_x11_display_get_xdisplay(gdkDisplay);
+		if(!handleInfoOut.xlib_display)
+		{
+			cemuLog_log(LogType::Force, "Unable to get xlib display");
+		}
+	}
+	else 
+#ifdef HAS_WAYLAND
+	if(GDK_IS_WAYLAND_WINDOW(gdkWindow))
+	{
+		handleInfoOut.backend = WindowHandleInfo::Backend::WAYLAND;
+		handleInfoOut.surface = gdk_wayland_window_get_wl_surface(gdkWindow);
+		handleInfoOut.display = gdk_wayland_display_get_wl_display(gdkDisplay);
+	}
+	else
+#endif
+	{
+		cemuLog_log(LogType::Force, "Unsuported GTK backend");
+	}
 #else
 	handleInfoOut.handle = wxw->GetHandle();
 #endif
 }
 
-bool gui_isKeyDown(int key)
+bool gui_isKeyDown(uint32 key)
 {
-	if (key >= 256)
-		return false;
+	return g_window_info.get_keystate(key);
+}
 
-	return g_window_info.keydown[key];
+bool gui_isKeyDown(PlatformKeyCodes key)
+{
+	return gui_isKeyDown((std::underlying_type_t<PlatformKeyCodes>)key);
 }
 
 void gui_notifyGameLoaded()
@@ -296,4 +329,4 @@ void debuggerWindow_notifyModuleUnloaded(void* module)
 		evt->SetClientData(module);
 		wxQueueEvent(g_debugger_window, evt);
 	}
-}
\ No newline at end of file
+}
diff --git a/src/gui/guiWrapper.h b/src/gui/guiWrapper.h
index a9d3e1b3..ec94c1a0 100644
--- a/src/gui/guiWrapper.h
+++ b/src/gui/guiWrapper.h
@@ -1,9 +1,12 @@
 #pragma once
 
-#include <atomic>
-
 #if BOOST_OS_LINUX
 #include "xcb/xproto.h"
+#include <gdk/gdkkeysyms.h>
+#endif
+
+#if BOOST_OS_MACOS
+#include <Carbon/Carbon.h>
 #endif
 
 struct WindowHandleInfo
@@ -11,6 +14,11 @@ struct WindowHandleInfo
 #if BOOST_OS_WINDOWS
 	std::atomic<HWND> hwnd;
 #elif BOOST_OS_LINUX
+	enum class Backend
+	{
+		X11,
+		WAYLAND,
+	} backend;
     // XLIB
     Display* xlib_display{};
     Window xlib_window{};
@@ -18,21 +26,52 @@ struct WindowHandleInfo
 	// XCB (not used by GTK so we cant retrieve these without making our own window)
 	//xcb_connection_t* xcb_con{};
 	//xcb_window_t xcb_window{};
-	// Wayland
-	// todo
+	#ifdef HAS_WAYLAND
+	struct wl_display* display;
+	struct wl_surface* surface;
+	#endif // HAS_WAYLAND
 #else
 	void* handle;
 #endif
 };
 
+enum struct PlatformKeyCodes : uint32
+{
+#if BOOST_OS_WINDOWS
+	LCONTROL = VK_LCONTROL,
+	RCONTROL = VK_RCONTROL,
+	TAB = VK_TAB,
+	ESCAPE = VK_ESCAPE,
+#elif BOOST_OS_LINUX
+	LCONTROL = GDK_KEY_Control_L,
+	RCONTROL = GDK_KEY_Control_R,
+	TAB = GDK_KEY_Tab,
+	ESCAPE = GDK_KEY_Escape,
+#elif BOOST_OS_MACOS
+	LCONTROL = kVK_Control,
+	RCONTROL = kVK_RightControl,
+	TAB = kVK_Tab,
+	ESCAPE = kVK_Escape,
+#else
+	LCONTROL = 0,
+	RCONTROL = 0,
+	TAB = 0,
+	ESCAPE = 0,
+#endif
+};
+
 struct WindowInfo
 {
 	std::atomic_bool app_active; // our app is active/has focus
 
 	std::atomic_int32_t width, height; 	// client size of main window
+	std::atomic_int32_t phys_width, phys_height; 	// client size of main window in physical pixels
+	std::atomic<double> dpi_scale;
 
 	std::atomic_bool pad_open; // if separate pad view is open
 	std::atomic_int32_t pad_width, pad_height; 	// client size of pad window
+	std::atomic_int32_t phys_pad_width, phys_pad_height; 	// client size of pad window in physical pixels
+	std::atomic<double> pad_dpi_scale;
 
 	std::atomic_bool pad_maximized = false;
 	std::atomic_int32_t restored_pad_x = -1, restored_pad_y = -1;
@@ -41,7 +80,33 @@ struct WindowInfo
 	std::atomic_bool has_screenshot_request;
 	std::atomic_bool is_fullscreen;
 
-	std::atomic_bool keydown[256]{};
+	void set_keystate(uint32 keycode, bool state)
+	{
+		const std::lock_guard<std::mutex> lock(keycode_mutex);
+		m_keydown[keycode] = state;
+	}
+
+	bool get_keystate(uint32 keycode)
+	{
+		const std::lock_guard<std::mutex> lock(keycode_mutex);
+		auto result = m_keydown.find(keycode);
+		if (result == m_keydown.end())
+			return false;
+		return result->second;
+	}
+
+	void set_keystatesup()
+	{
+		const std::lock_guard<std::mutex> lock(keycode_mutex);
+		std::for_each(m_keydown.begin(), m_keydown.end(), [](std::pair<const uint32, bool>& el){ el.second = false; });
+	}
+
+	template <typename fn>
+	void iter_keystates(fn f)
+	{
+		const std::lock_guard<std::mutex> lock(keycode_mutex);
+		std::for_each(m_keydown.cbegin(), m_keydown.cend(), f);
+	}
 
 	WindowHandleInfo window_main;
 	WindowHandleInfo window_pad;
@@ -49,6 +114,10 @@ struct WindowInfo
 	// canvas
 	WindowHandleInfo canvas_main;
 	WindowHandleInfo canvas_pad;
+   private:
+   	std::mutex keycode_mutex;
+	// m_keydown keys must be valid ImGuiKey values
+	std::unordered_map<uint32, bool> m_keydown;
 };
 
 void gui_create();
@@ -56,10 +125,15 @@ void gui_create();
 WindowInfo& gui_getWindowInfo();
 
 void gui_updateWindowTitles(bool isIdle, bool isLoading, double fps);
-void gui_getWindowSize(int* w, int* h);
-void gui_getPadWindowSize(int* w, int* h);
+void gui_getWindowSize(int& w, int& h);
+void gui_getPadWindowSize(int& w, int& h);
+void gui_getWindowPhysSize(int& w, int& h);
+void gui_getPadWindowPhysSize(int& w, int& h);
+double gui_getWindowDPIScale();
+double gui_getPadDPIScale();
 bool gui_isPadWindowOpen();
-bool gui_isKeyDown(int key);
+bool gui_isKeyDown(uint32 key);
+bool gui_isKeyDown(PlatformKeyCodes key);
 
 void gui_notifyGameLoaded();
 void gui_notifyGameExited();
@@ -68,6 +142,9 @@ bool gui_isFullScreen();
 
 void gui_initHandleContextFromWxWidgetsWindow(WindowHandleInfo& handleInfoOut, class wxWindow* wxw);
 
+#if BOOST_OS_LINUX
+std::string gui_gtkRawKeyCodeToString(uint32 keyCode);
+#endif
 /*
 * Returns true if a screenshot request is queued
 * Once this function has returned true, it will reset back to
@@ -81,4 +158,4 @@ void debuggerWindow_notifyDebugBreakpointHit2();
 void debuggerWindow_notifyRun();
 void debuggerWindow_moveIP();
 void debuggerWindow_notifyModuleLoaded(void* module);
-void debuggerWindow_notifyModuleUnloaded(void* module);
\ No newline at end of file
+void debuggerWindow_notifyModuleUnloaded(void* module);
diff --git a/src/gui/helpers/wxHelpers.h b/src/gui/helpers/wxHelpers.h
index 8fd0f8a9..9e00bf48 100644
--- a/src/gui/helpers/wxHelpers.h
+++ b/src/gui/helpers/wxHelpers.h
@@ -8,7 +8,7 @@ template <>
 struct fmt::formatter<wxString> : formatter<string_view>
 {
 	template <typename FormatContext>
-	auto format(const wxString& str, FormatContext& ctx)
+	auto format(const wxString& str, FormatContext& ctx) const
 	{
 		return formatter<string_view>::format(str.c_str().AsChar(), ctx);
 	}
@@ -45,16 +45,9 @@ public:
 };
 
 template<typename ...TArgs>
-wxString wxStringFormat2(const wxString& format, TArgs&&...args)
+wxString formatWxString(const wxString& format, TArgs&&...args)
 {
-	// ignores locale?
-	return fmt::format(fmt::runtime(format.ToStdString()), std::forward<TArgs>(args)...);
-}
-
-template<typename ...TArgs>
-wxString wxStringFormat2W(const wxString& format, TArgs&&...args)
-{
-	return fmt::format(fmt::runtime(format.ToStdWstring()), std::forward<TArgs>(args)...);
+	return wxString::FromUTF8(fmt::format(fmt::runtime(format.utf8_string()), std::forward<TArgs>(args)...));
 }
 
 // executes a function when destroying the obj
@@ -86,14 +79,6 @@ inline wxString to_wxString(std::string_view str)
 	return wxString::FromUTF8(str.data(), str.size());
 }
 
-// creates utf8 std::string from wxString
-inline std::string from_wxString(const wxString& str)
-{
-	const auto tmp = str.ToUTF8();
-	return std::string{ tmp.data(), tmp.length() };
-}
-
-
 template <typename T>
 T get_next_sibling(const T element)
 {
diff --git a/src/gui/helpers/wxLogEvent.h b/src/gui/helpers/wxLogEvent.h
index 8cef1d2d..23f6533d 100644
--- a/src/gui/helpers/wxLogEvent.h
+++ b/src/gui/helpers/wxLogEvent.h
@@ -12,7 +12,7 @@ public:
 		: wxCommandEvent(EVT_LOG), m_filter(filter), m_message(message) { }
 
 	wxLogEvent(const wxLogEvent& event)
-		:  wxCommandEvent(event), m_filter(event.m_filter), m_message(event.m_message) { }
+		:  wxCommandEvent(event), m_filter(event.GetFilter()), m_message(event.GetMessage()) { }
 
 	wxEvent* Clone() const { return new wxLogEvent(*this); }
 
diff --git a/src/gui/helpers/wxWayland.cpp b/src/gui/helpers/wxWayland.cpp
new file mode 100644
index 00000000..c677451c
--- /dev/null
+++ b/src/gui/helpers/wxWayland.cpp
@@ -0,0 +1,24 @@
+#include "gui/helpers/wxWayland.h"
+
+#if BOOST_OS_LINUX && HAS_WAYLAND
+
+#include <dlfcn.h>
+
+bool wxWlIsWaylandWindow(wxWindow* window)
+{
+	GtkWidget* gtkWindow = static_cast<GtkWidget*>(window->GetHandle());
+	GdkWindow* gdkWindow = gtk_widget_get_window(gtkWindow);
+	return GDK_IS_WAYLAND_WINDOW(gdkWindow);
+}
+
+void wxWlSetAppId(wxFrame* frame, const char* applicationId)
+{
+	GtkWidget* gtkWindow = static_cast<GtkWidget*>(frame->GetHandle());
+	gtk_widget_realize(gtkWindow);
+	GdkWindow* gdkWindow = gtk_widget_get_window(gtkWindow);
+	static auto gdk_wl_set_app_id = reinterpret_cast<void (*) (GdkWindow*, const char*)>(dlsym(nullptr, "gdk_wayland_window_set_application_id"));
+	if (gdk_wl_set_app_id)
+		gdk_wl_set_app_id(gdkWindow, applicationId);
+}
+
+#endif	// BOOST_OS_LINUX && HAS_WAYLAND
diff --git a/src/gui/helpers/wxWayland.h b/src/gui/helpers/wxWayland.h
new file mode 100644
index 00000000..a3b82119
--- /dev/null
+++ b/src/gui/helpers/wxWayland.h
@@ -0,0 +1,93 @@
+#pragma once
+
+#if BOOST_OS_LINUX && HAS_WAYLAND
+
+#include <gdk/gdk.h>
+#include <gdk/gdkwayland.h>
+#include <gtk/gtk.h>
+#include <wayland-client.h>
+#include <wx/wx.h>
+#include "wayland-viewporter-client-protocol.h"
+
+class wxWlSubsurface
+{
+	static void registry_add_object(void* data, struct wl_registry* registry, uint32_t name, const char* interface, uint32_t version)
+	{
+		auto wlSubsurface = static_cast<wxWlSubsurface*>(data);
+
+		if (!strcmp(interface, wl_subcompositor_interface.name))
+		{
+			wlSubsurface->m_subcompositor = static_cast<wl_subcompositor*>(wl_registry_bind(registry, name, &wl_subcompositor_interface, 1));
+		}
+		else if (!strcmp(interface, wp_viewporter_interface.name))
+		{
+			wlSubsurface->m_viewporter = static_cast<wp_viewporter*>(wl_registry_bind(registry, name, &wp_viewporter_interface, 1));
+		}
+	}
+	static void registry_remove_object(void* /*data*/, struct wl_registry* /*registry*/, uint32_t /*name*/) {}
+
+	wl_registry_listener m_registry_listener = {&registry_add_object, &registry_remove_object};
+	wl_subcompositor* m_subcompositor;
+	wl_surface* m_surface;
+	wl_subsurface* m_subsurface;
+	wp_viewporter* m_viewporter = NULL;
+	wp_viewport* m_viewport = NULL;
+	int32_t m_xPos = 0;
+	int32_t m_yPos = 0;
+	int32_t m_width = 0;
+	int32_t m_height = 0;
+
+public:
+	wxWlSubsurface(wxWindow* window)
+	{
+		GtkWidget* widget = static_cast<GtkWidget*>(window->GetHandle());
+		gtk_widget_realize(widget);
+		GdkWindow* gdkWindow = gtk_widget_get_window(widget);
+		GdkDisplay* gdkDisplay = gdk_window_get_display(gdkWindow);
+		wl_display* display = gdk_wayland_display_get_wl_display(gdkDisplay);
+		wl_surface* surface = gdk_wayland_window_get_wl_surface(gdkWindow);
+		wl_compositor* compositor = gdk_wayland_display_get_wl_compositor(gdkDisplay);
+		wl_registry* registry = wl_display_get_registry(display);
+		wl_registry_add_listener(registry, &m_registry_listener, this);
+		wl_display_roundtrip(display);
+		m_surface = wl_compositor_create_surface(compositor);
+		if (m_viewporter)
+			m_viewport = wp_viewporter_get_viewport(m_viewporter, m_surface);
+		wl_region* region = wl_compositor_create_region(compositor);
+		wl_surface_set_input_region(m_surface, region);
+		m_subsurface = wl_subcompositor_get_subsurface(m_subcompositor, m_surface, surface);
+		wl_subsurface_set_desync(m_subsurface);
+		auto sRect = window->GetScreenRect();
+		setSize(sRect.x, sRect.y, sRect.width, sRect.height);
+		wl_region_destroy(region);
+	}
+
+	wl_surface* getSurface() const { return m_surface; }
+
+	void setSize(int32_t xPos, int32_t yPos, int32_t width, int32_t height)
+	{
+		if (xPos != m_xPos || m_yPos != yPos || m_width != width || m_height != height)
+		{
+			m_xPos = xPos;
+			m_yPos = yPos;
+			m_height = height;
+			m_width = width;
+			wl_subsurface_set_position(m_subsurface, m_xPos, m_yPos);
+			if (m_viewport)
+				wp_viewport_set_destination(m_viewport, m_width, m_height);
+			wl_surface_commit(m_surface);
+		}
+	}
+
+	~wxWlSubsurface()
+	{
+		wl_subsurface_destroy(m_subsurface);
+		wl_surface_destroy(m_surface);
+		wl_subcompositor_destroy(m_subcompositor);
+	}
+};
+
+bool wxWlIsWaylandWindow(wxWindow* window);
+void wxWlSetAppId(wxFrame* frame, const char* application_id);
+
+#endif	// BOOST_OS_LINUX && HAS_WAYLAND
diff --git a/src/gui/input/InputAPIAddWindow.cpp b/src/gui/input/InputAPIAddWindow.cpp
index f32a85b6..6bfb589b 100644
--- a/src/gui/input/InputAPIAddWindow.cpp
+++ b/src/gui/input/InputAPIAddWindow.cpp
@@ -23,7 +23,7 @@ using wxControllerData = wxCustomData<ControllerPtr>;
 
 InputAPIAddWindow::InputAPIAddWindow(wxWindow* parent, const wxPoint& position,
                                      const std::vector<ControllerPtr>& controllers)
-	: wxDialog(parent, wxID_ANY, _("Add input API"), position, wxDefaultSize, 0), m_controllers(controllers)
+	: wxDialog(parent, wxID_ANY, "Add input API", position, wxDefaultSize, wxCAPTION), m_controllers(controllers)
 {
 	this->SetSizeHints(wxDefaultSize, wxDefaultSize);
 
@@ -90,11 +90,11 @@ InputAPIAddWindow::InputAPIAddWindow(wxWindow* parent, const wxPoint& position,
 			auto* row = new wxBoxSizer(wxHORIZONTAL);
 			// we only have dsu settings atm, so add elements now
 			row->Add(new wxStaticText(m_settings_panel, wxID_ANY, _("IP")), 0, wxALIGN_CENTER_VERTICAL | wxALL, 5);
-			m_ip = new wxTextCtrl(m_settings_panel, wxID_ANY, wxT("127.0.0.1"));
+			m_ip = new wxTextCtrl(m_settings_panel, wxID_ANY, "127.0.0.1");
 			row->Add(m_ip, 0, wxALL, 5);
 
 			row->Add(new wxStaticText(m_settings_panel, wxID_ANY, _("Port")), 0, wxALIGN_CENTER_VERTICAL | wxALL, 5);
-			m_port = new wxTextCtrl(m_settings_panel, wxID_ANY, wxT("26760"));
+			m_port = new wxTextCtrl(m_settings_panel, wxID_ANY, "26760");
 			row->Add(m_port, 0, wxALL, 5);
 
 			panel_sizer->Add(row, 0, wxEXPAND);
@@ -114,6 +114,11 @@ InputAPIAddWindow::InputAPIAddWindow(wxWindow* parent, const wxPoint& position,
 	this->Bind(wxControllersRefreshed, &InputAPIAddWindow::on_controllers_refreshed, this);
 }
 
+InputAPIAddWindow::~InputAPIAddWindow()
+{
+	discard_thread_result();
+}
+
 void InputAPIAddWindow::on_add_button(wxCommandEvent& event)
 {
 	const auto selection = m_input_api->GetSelection();
@@ -159,6 +164,8 @@ std::unique_ptr<ControllerProviderSettings> InputAPIAddWindow::get_settings() co
 
 void InputAPIAddWindow::on_api_selected(wxCommandEvent& event)
 {
+	discard_thread_result();
+
 	if (m_input_api->GetSelection() == wxNOT_FOUND)
 		return;
 
@@ -239,19 +246,25 @@ void InputAPIAddWindow::on_controller_dropdown(wxCommandEvent& event)
 	m_controller_list->Append(_("Searching for controllers..."), (wxClientData*)nullptr);
 	m_controller_list->SetSelection(wxNOT_FOUND);
 
-	std::thread([this, provider, selected_uuid]()
+	m_search_thread_data = std::make_unique<AsyncThreadData>();
+	std::thread([this, provider, selected_uuid](std::shared_ptr<AsyncThreadData> data)
 	{
 		auto available_controllers = provider->get_controllers();
 
-		wxCommandEvent event(wxControllersRefreshed);
-		event.SetEventObject(m_controller_list);
-		event.SetClientObject(new wxCustomData(std::move(available_controllers)));
-		event.SetInt(provider->api());
-		event.SetString(selected_uuid);
-		wxPostEvent(this, event);
-
-		m_search_running = false;
-	}).detach();
+		{
+			std::lock_guard lock{data->mutex};
+			if(!data->discardResult)
+			{
+				wxCommandEvent event(wxControllersRefreshed);
+				event.SetEventObject(m_controller_list);
+				event.SetClientObject(new wxCustomData(std::move(available_controllers)));
+				event.SetInt(provider->api());
+				event.SetString(selected_uuid);
+				wxPostEvent(this, event);
+				m_search_running = false;
+			}
+		}
+	}, m_search_thread_data).detach();
 }
 
 void InputAPIAddWindow::on_controller_selected(wxCommandEvent& event)
@@ -301,3 +314,13 @@ void InputAPIAddWindow::on_controllers_refreshed(wxCommandEvent& event)
 		}
 	}
 }
+
+void InputAPIAddWindow::discard_thread_result()
+{
+	m_search_running = false;
+	if(m_search_thread_data)
+	{
+		std::lock_guard lock{m_search_thread_data->mutex};
+		m_search_thread_data->discardResult = true;
+	}
+}
diff --git a/src/gui/input/InputAPIAddWindow.h b/src/gui/input/InputAPIAddWindow.h
index ebee0592..085dd623 100644
--- a/src/gui/input/InputAPIAddWindow.h
+++ b/src/gui/input/InputAPIAddWindow.h
@@ -19,6 +19,7 @@ class InputAPIAddWindow : public wxDialog
 {
 public:
 	InputAPIAddWindow(wxWindow* parent, const wxPoint& position, const std::vector<ControllerPtr>& controllers);
+	~InputAPIAddWindow();
 
 	bool is_valid() const { return m_type.has_value() && m_controller != nullptr; }
 	InputAPI::Type get_type() const { return m_type.value(); }
@@ -38,6 +39,8 @@ private:
 	void on_controller_selected(wxCommandEvent& event);
 	void on_controllers_refreshed(wxCommandEvent& event);
 
+	void discard_thread_result();
+
 	wxChoice* m_input_api;
 	wxComboBox* m_controller_list;
 	wxButton* m_ok_button;
@@ -50,4 +53,10 @@ private:
 
 	std::vector<ControllerPtr> m_controllers;
 	std::atomic_bool m_search_running = false;
+	struct AsyncThreadData
+	{
+		std::atomic_bool discardResult = false;
+		std::mutex mutex;
+	};
+	std::shared_ptr<AsyncThreadData> m_search_thread_data;
 };
diff --git a/src/gui/input/InputSettings2.cpp b/src/gui/input/InputSettings2.cpp
index 5793cbd2..2ae8a74b 100644
--- a/src/gui/input/InputSettings2.cpp
+++ b/src/gui/input/InputSettings2.cpp
@@ -20,6 +20,8 @@
 #include "gui/input/InputAPIAddWindow.h"
 #include "input/ControllerFactory.h"
 
+#include "gui/input/PairingDialog.h"
+
 #include "gui/input/panels/VPADInputPanel.h"
 #include "gui/input/panels/ProControllerInputPanel.h"
 
@@ -29,9 +31,7 @@
 #include "gui/input/settings/WiimoteControllerSettings.h"
 #include "util/EventService.h"
 
-#if BOOST_OS_LINUX
 #include "resource/embedded/resources.h"
-#endif
 
 bool g_inputConfigWindowHasFocus = false;
 
@@ -70,9 +70,9 @@ InputSettings2::InputSettings2(wxWindow* parent)
 
 	g_inputConfigWindowHasFocus = true;
 
-	m_connected = wxBITMAP_PNG(INPUT_CONNECTED);
-	m_disconnected = wxBITMAP_PNG(INPUT_DISCONNECTED);
-	m_low_battery = wxBITMAP_PNG(INPUT_LOW_BATTERY);
+	m_connected = wxBITMAP_PNG_FROM_DATA(INPUT_CONNECTED);
+	m_disconnected = wxBITMAP_PNG_FROM_DATA(INPUT_DISCONNECTED);
+	m_low_battery = wxBITMAP_PNG_FROM_DATA(INPUT_LOW_BATTERY);
 
 	auto* sizer = new wxBoxSizer(wxVERTICAL);
 
@@ -81,7 +81,7 @@ InputSettings2::InputSettings2(wxWindow* parent)
 	{
 		auto* page = new wxPanel(m_notebook, wxID_ANY, wxDefaultPosition, wxDefaultSize, wxTAB_TRAVERSAL);
 		page->SetClientObject(nullptr); // force internal type to client object
-		m_notebook->AddPage(page, wxStringFormat2(_("Controller {}"), i + 1));
+		m_notebook->AddPage(page, formatWxString(_("Controller {}"), i + 1));
 	}
 
 	m_notebook->Bind(wxEVT_NOTEBOOK_PAGE_CHANGED, &InputSettings2::on_controller_page_changed, this);
@@ -113,7 +113,7 @@ InputSettings2::InputSettings2(wxWindow* parent)
 	Bind(wxEVT_TIMER, &InputSettings2::on_timer, this);
 
 	m_timer = new wxTimer(this);
-	m_timer->Start(100);
+	m_timer->Start(25);
 
 	m_controller_changed = EventService::instance().connect<Events::ControllerChanged>(&InputSettings2::on_controller_changed, this);
 }
@@ -149,6 +149,15 @@ wxWindow* InputSettings2::initialize_page(size_t index)
 		auto* profiles = new wxComboBox(page, wxID_ANY, kDefaultProfileName);
 		sizer->Add(profiles, wxGBPosition(0, 1), wxDefaultSpan, wxALIGN_CENTER_VERTICAL | wxALL | wxEXPAND, 5);
 
+#if BOOST_OS_LINUX
+		// We rely on the wxEVT_COMBOBOX_DROPDOWN event to trigger filling the profile list,
+		// but on wxGTK the dropdown button cannot be clicked if the list is empty
+		// so as a quick and dirty workaround we fill the list here
+		wxCommandEvent tmpCmdEvt;
+		tmpCmdEvt.SetEventObject(profiles);
+		on_profile_dropdown(tmpCmdEvt);
+#endif
+
 		if (emulated_controller && emulated_controller->has_profile_name())
 		{
 			profiles->SetValue(emulated_controller->get_profile_name());
@@ -231,11 +240,11 @@ wxWindow* InputSettings2::initialize_page(size_t index)
 			// add/remove buttons
 			auto* bttn_sizer = new wxBoxSizer(wxHORIZONTAL);
 
-			auto* add_api = new wxButton(page, wxID_ANY, wxT(" + "), wxDefaultPosition, wxDefaultSize, wxBU_EXACTFIT);
+			auto* add_api = new wxButton(page, wxID_ANY, " + ", wxDefaultPosition, wxDefaultSize, wxBU_EXACTFIT);
 			add_api->Bind(wxEVT_BUTTON, &InputSettings2::on_controller_add, this);
 			bttn_sizer->Add(add_api, 0, wxALL, 5);
 
-			auto* remove_api = new wxButton(page, wxID_ANY, wxT("  -  "), wxDefaultPosition, wxDefaultSize, wxBU_EXACTFIT);
+			auto* remove_api = new wxButton(page, wxID_ANY, "  -  ", wxDefaultPosition, wxDefaultSize, wxBU_EXACTFIT);
 			remove_api->Bind(wxEVT_BUTTON, &InputSettings2::on_controller_remove, this);
 			bttn_sizer->Add(remove_api, 0, wxALL, 5);
 
@@ -245,6 +254,13 @@ wxWindow* InputSettings2::initialize_page(size_t index)
 			page_data.m_controller_api_remove = remove_api;
 		}
 
+		auto* pairingDialog = new wxButton(page, wxID_ANY, _("Pair Wii/Wii U Controller"));
+		pairingDialog->Bind(wxEVT_BUTTON, [this](wxEvent&) {
+			PairingDialog pairing_dialog(this);
+			pairing_dialog.ShowModal();
+		});
+		sizer->Add(pairingDialog, wxGBPosition(5, 0), wxDefaultSpan, wxALIGN_CENTER_VERTICAL | wxALL, 5);
+
 		// controller
 		auto* controller_bttns = new wxBoxSizer(wxHORIZONTAL);
 		auto* settings = new wxButton(page, wxID_ANY, _("Settings"), wxDefaultPosition, wxDefaultSize, 0);
@@ -288,32 +304,6 @@ wxWindow* InputSettings2::initialize_page(size_t index)
 	return page;
 }
 
-std::pair<size_t, size_t> InputSettings2::get_emulated_controller_types() const
-{
-	size_t vpad = 0, wpad = 0;
-	for(size_t i = 0; i < m_notebook->GetPageCount(); ++i)
-	{
-		auto* page = m_notebook->GetPage(i);
-		auto* page_data = (wxControllerPageData*)page->GetClientObject();
-		if (!page_data)
-			continue;
-		
-		if (!page_data->ref().m_controller) // = disabled
-			continue;
-
-		const auto api_type = page_data->ref().m_controller->type();
-		if (api_type) 
-			continue;
-
-		if (api_type == EmulatedController::VPAD)
-			++vpad;
-		else
-			++wpad;
-	}
-
-	return std::make_pair(vpad, wpad);
-}
-
 std::shared_ptr<ControllerBase> InputSettings2::get_active_controller() const
 {
 	auto& page_data = get_current_page_data();
@@ -420,7 +410,15 @@ void InputSettings2::update_state()
 
 	// enabled correct panel for active controller
 	if (active_api && emulated_controller && emulated_controller->type() == active_api.value())
+	{
+		// same controller type panel already shown, refresh content of panels
+		for (auto* panel : page_data.m_panels)
+		{
+			if (panel)
+				panel->load_controller(page_data.m_controller);
+		}
 		return;
+	}
 
 	// hide all panels
 	for (auto* panel : page_data.m_panels)
@@ -568,13 +566,9 @@ void InputSettings2::on_profile_text_changed(wxCommandEvent& event)
 
 	auto& page_data = get_current_page_data();
 
-	const auto selection = page_data.m_emulated_controller->GetStringSelection();
-
 	// load_bttn, save_bttn, delete_bttn, profile_status
 	const auto text = event.GetString();
-	const auto text_str = from_wxString(text);
-
-	const bool valid_name = InputManager::is_valid_profilename(text_str);
+	const bool valid_name = InputManager::is_valid_profilename(text.utf8_string());
 	const bool name_exists = profile_names->FindString(text) != wxNOT_FOUND;
 
 	page_data.m_profile_load->Enable(name_exists);
@@ -590,7 +584,7 @@ void InputSettings2::on_profile_load(wxCommandEvent& event)
 	auto* profile_names = page_data.m_profiles;
 	auto* text = page_data.m_profile_status;
 
-	const auto selection = from_wxString(profile_names->GetValue());
+	const auto selection = profile_names->GetValue().utf8_string();
 	text->Show();
 	if (selection.empty() || !InputManager::is_valid_profilename(selection))
 	{
@@ -626,7 +620,7 @@ void InputSettings2::on_profile_save(wxCommandEvent& event)
 	auto* profile_names = page_data.m_profiles;
 	auto* text = page_data.m_profile_status;
 
-	const auto selection = from_wxString(profile_names->GetValue());
+	const auto selection = profile_names->GetValue().utf8_string();
 	text->Show();
 	if (selection.empty() || !InputManager::is_valid_profilename(selection))
 	{
@@ -657,7 +651,7 @@ void InputSettings2::on_profile_delete(wxCommandEvent& event)
 	auto* profile_names = page_data.m_profiles;
 	auto* text = page_data.m_profile_status;
 
-	const auto selection = from_wxString(profile_names->GetStringSelection());
+	const auto selection = profile_names->GetStringSelection().utf8_string();
 
 	text->Show();
 	if (selection.empty() || !InputManager::is_valid_profilename(selection))
@@ -669,10 +663,10 @@ void InputSettings2::on_profile_delete(wxCommandEvent& event)
 	}
 	try
 	{
-		const fs::path old_path = ActiveSettings::GetPath(fmt::format("controllerProfiles/{}.txt", selection));
+		const fs::path old_path = ActiveSettings::GetConfigPath("controllerProfiles/{}.txt", selection);
 		fs::remove(old_path);
 
-		const fs::path path = ActiveSettings::GetPath(fmt::format("controllerProfiles/{}.xml", selection));
+		const fs::path path = ActiveSettings::GetConfigPath("controllerProfiles/{}.xml", selection);
 		fs::remove(path);
 
 		profile_names->ChangeValue(kDefaultProfileName);
@@ -712,10 +706,9 @@ void InputSettings2::on_emulated_controller_selected(wxCommandEvent& event)
 	}
 	else
 	{
-		const auto type_str = from_wxString(event.GetString());
 		try
 		{
-			const auto type = EmulatedController::type_from_string(type_str);
+			const auto type = EmulatedController::type_from_string(event.GetString().utf8_string());
 			// same has already been selected
 			if (page_data.m_controller && page_data.m_controller->type() == type)
 				return;
@@ -761,14 +754,16 @@ void InputSettings2::on_emulated_controller_dropdown(wxCommandEvent& event)
 	wxWindowUpdateLocker lock(emulated_controllers);
 
 	bool is_gamepad_selected = false;
+	bool is_wpad_selected = false;
 	const auto selected = emulated_controllers->GetSelection();
 	const auto selected_value = emulated_controllers->GetStringSelection();
 	if(selected != wxNOT_FOUND)
 	{
 		is_gamepad_selected = selected_value == to_wxString(EmulatedController::type_to_string(EmulatedController::Type::VPAD));
+		is_wpad_selected = !is_gamepad_selected && selected != 0;
 	}
 
-	const auto [vpad_count, wpad_count] = get_emulated_controller_types();
+	const auto [vpad_count, wpad_count] = InputManager::instance().get_controller_count();
 
 	emulated_controllers->Clear();
 	emulated_controllers->AppendString(_("Disabled"));
@@ -776,7 +771,7 @@ void InputSettings2::on_emulated_controller_dropdown(wxCommandEvent& event)
 	if (vpad_count < InputManager::kMaxVPADControllers || is_gamepad_selected)
 		emulated_controllers->Append(to_wxString(EmulatedController::type_to_string(EmulatedController::Type::VPAD)));
 
-	if (wpad_count < InputManager::kMaxWPADControllers || !is_gamepad_selected)
+	if (wpad_count < InputManager::kMaxWPADControllers || is_wpad_selected)
 	{
 		emulated_controllers->AppendString(to_wxString(EmulatedController::type_to_string(EmulatedController::Type::Pro)));
 		emulated_controllers->AppendString(to_wxString(EmulatedController::type_to_string(EmulatedController::Type::Classic)));
@@ -963,7 +958,7 @@ void InputSettings2::on_controller_settings(wxCommandEvent& event)
 
 	case InputAPI::Keyboard: break;
 
-	#if BOOST_OS_WINDOWS
+	#ifdef SUPPORTS_WIIMOTE
 	case InputAPI::Wiimote: {
 		const auto wiimote = std::dynamic_pointer_cast<NativeWiimoteController>(controller);
 		wxASSERT(wiimote);
diff --git a/src/gui/input/InputSettings2.h b/src/gui/input/InputSettings2.h
index 01313653..1a3c8bb1 100644
--- a/src/gui/input/InputSettings2.h
+++ b/src/gui/input/InputSettings2.h
@@ -27,9 +27,6 @@ private:
 
 	wxWindow* initialize_page(size_t index);
 
-	// count active <vpad, wpad> controllers
-	std::pair<size_t, size_t> get_emulated_controller_types() const; 
-	
 	// currently selected controller from active tab
 	std::shared_ptr<ControllerBase> get_active_controller() const;
 
diff --git a/src/gui/input/PairingDialog.cpp b/src/gui/input/PairingDialog.cpp
new file mode 100644
index 00000000..ecbfc110
--- /dev/null
+++ b/src/gui/input/PairingDialog.cpp
@@ -0,0 +1,300 @@
+#include "gui/wxgui.h"
+#include "PairingDialog.h"
+
+#if BOOST_OS_WINDOWS
+#include <bluetoothapis.h>
+#endif
+#if BOOST_OS_LINUX
+#include <bluetooth/bluetooth.h>
+#include <bluetooth/hci.h>
+#include <bluetooth/hci_lib.h>
+#include <input/api/Wiimote/l2cap/L2CapWiimote.h>
+#endif
+
+wxDECLARE_EVENT(wxEVT_PROGRESS_PAIR, wxCommandEvent);
+wxDEFINE_EVENT(wxEVT_PROGRESS_PAIR, wxCommandEvent);
+
+PairingDialog::PairingDialog(wxWindow* parent)
+	: wxDialog(parent, wxID_ANY, _("Pairing..."), wxDefaultPosition, wxDefaultSize, wxCAPTION | wxMINIMIZE_BOX | wxSYSTEM_MENU | wxTAB_TRAVERSAL | wxCLOSE_BOX)
+{
+	auto* sizer = new wxBoxSizer(wxVERTICAL);
+	m_gauge = new wxGauge(this, wxID_ANY, 100, wxDefaultPosition, wxSize(350, 20), wxGA_HORIZONTAL);
+	m_gauge->SetValue(0);
+	sizer->Add(m_gauge, 0, wxALL | wxEXPAND, 5);
+
+	auto* rows = new wxFlexGridSizer(0, 2, 0, 0);
+	rows->AddGrowableCol(1);
+
+	m_text = new wxStaticText(this, wxID_ANY, _("Searching for controllers..."));
+	rows->Add(m_text, 0, wxALL | wxALIGN_CENTER_VERTICAL, 5);
+
+	{
+		auto* right_side = new wxBoxSizer(wxHORIZONTAL);
+
+		m_cancelButton = new wxButton(this, wxID_ANY, _("Cancel"));
+		m_cancelButton->Bind(wxEVT_BUTTON, &PairingDialog::OnCancelButton, this);
+		right_side->Add(m_cancelButton, 0, wxALL, 5);
+
+		rows->Add(right_side, 1, wxALIGN_RIGHT, 5);
+	}
+
+	sizer->Add(rows, 0, wxALL | wxEXPAND, 5);
+
+	SetSizerAndFit(sizer);
+	Centre(wxBOTH);
+
+	Bind(wxEVT_CLOSE_WINDOW, &PairingDialog::OnClose, this);
+	Bind(wxEVT_PROGRESS_PAIR, &PairingDialog::OnGaugeUpdate, this);
+
+	m_thread = std::thread(&PairingDialog::WorkerThread, this);
+}
+
+PairingDialog::~PairingDialog()
+{
+	Unbind(wxEVT_CLOSE_WINDOW, &PairingDialog::OnClose, this);
+}
+
+void PairingDialog::OnClose(wxCloseEvent& event)
+{
+	event.Skip();
+
+	m_threadShouldQuit = true;
+	if (m_thread.joinable())
+		m_thread.join();
+}
+
+void PairingDialog::OnCancelButton(const wxCommandEvent& event)
+{
+	Close();
+}
+
+void PairingDialog::OnGaugeUpdate(wxCommandEvent& event)
+{
+	PairingState state = (PairingState)event.GetInt();
+
+	switch (state)
+	{
+	case PairingState::Pairing:
+	{
+		m_text->SetLabel(_("Found controller. Pairing..."));
+		m_gauge->SetValue(50);
+		break;
+	}
+
+	case PairingState::Finished:
+	{
+		m_text->SetLabel(_("Successfully paired the controller."));
+		m_gauge->SetValue(100);
+		m_cancelButton->SetLabel(_("Close"));
+		break;
+	}
+
+	case PairingState::NoBluetoothAvailable:
+	{
+		m_text->SetLabel(_("Failed to find a suitable Bluetooth radio."));
+		m_gauge->SetValue(0);
+		m_cancelButton->SetLabel(_("Close"));
+		break;
+	}
+
+	case PairingState::SearchFailed:
+	{
+		m_text->SetLabel(_("Failed to find controllers."));
+		m_gauge->SetValue(0);
+		m_cancelButton->SetLabel(_("Close"));
+		break;
+	}
+
+	case PairingState::PairingFailed:
+	{
+		m_text->SetLabel(_("Failed to pair with the found controller."));
+		m_gauge->SetValue(0);
+		m_cancelButton->SetLabel(_("Close"));
+		break;
+	}
+
+	case PairingState::BluetoothUnusable:
+	{
+		m_text->SetLabel(_("Please use your system's Bluetooth manager instead."));
+		m_gauge->SetValue(0);
+		m_cancelButton->SetLabel(_("Close"));
+		break;
+	}
+
+	default:
+	{
+		break;
+	}
+	}
+}
+
+#if BOOST_OS_WINDOWS
+void PairingDialog::WorkerThread()
+{
+	const std::wstring wiimoteName = L"Nintendo RVL-CNT-01";
+	const std::wstring wiiUProControllerName = L"Nintendo RVL-CNT-01-UC";
+
+	const GUID bthHidGuid = {0x00001124, 0x0000, 0x1000, {0x80, 0x00, 0x00, 0x80, 0x5F, 0x9B, 0x34, 0xFB}};
+
+	const BLUETOOTH_FIND_RADIO_PARAMS radioFindParams =
+		{
+			.dwSize = sizeof(BLUETOOTH_FIND_RADIO_PARAMS)};
+
+	HANDLE radio = INVALID_HANDLE_VALUE;
+	HBLUETOOTH_RADIO_FIND radioFind = BluetoothFindFirstRadio(&radioFindParams, &radio);
+	if (radioFind == nullptr)
+	{
+		UpdateCallback(PairingState::NoBluetoothAvailable);
+		return;
+	}
+
+	BluetoothFindRadioClose(radioFind);
+
+	BLUETOOTH_RADIO_INFO radioInfo =
+		{
+			.dwSize = sizeof(BLUETOOTH_RADIO_INFO)};
+
+	DWORD result = BluetoothGetRadioInfo(radio, &radioInfo);
+	if (result != ERROR_SUCCESS)
+	{
+		UpdateCallback(PairingState::NoBluetoothAvailable);
+		return;
+	}
+
+	const BLUETOOTH_DEVICE_SEARCH_PARAMS searchParams =
+		{
+			.dwSize = sizeof(BLUETOOTH_DEVICE_SEARCH_PARAMS),
+
+			.fReturnAuthenticated = FALSE,
+			.fReturnRemembered = FALSE,
+			.fReturnUnknown = TRUE,
+			.fReturnConnected = FALSE,
+
+			.fIssueInquiry = TRUE,
+			.cTimeoutMultiplier = 5,
+
+			.hRadio = radio};
+
+	BLUETOOTH_DEVICE_INFO info =
+		{
+			.dwSize = sizeof(BLUETOOTH_DEVICE_INFO)};
+
+	while (!m_threadShouldQuit)
+	{
+		HBLUETOOTH_DEVICE_FIND deviceFind = BluetoothFindFirstDevice(&searchParams, &info);
+		if (deviceFind == nullptr)
+		{
+			UpdateCallback(PairingState::SearchFailed);
+			return;
+		}
+
+		while (!m_threadShouldQuit)
+		{
+			if (info.szName == wiimoteName || info.szName == wiiUProControllerName)
+			{
+				BluetoothFindDeviceClose(deviceFind);
+
+				UpdateCallback(PairingState::Pairing);
+
+				wchar_t passwd[6] = {radioInfo.address.rgBytes[0], radioInfo.address.rgBytes[1], radioInfo.address.rgBytes[2], radioInfo.address.rgBytes[3], radioInfo.address.rgBytes[4], radioInfo.address.rgBytes[5]};
+				DWORD bthResult = BluetoothAuthenticateDevice(nullptr, radio, &info, passwd, 6);
+				if (bthResult != ERROR_SUCCESS)
+				{
+					UpdateCallback(PairingState::PairingFailed);
+					return;
+				}
+
+				bthResult = BluetoothSetServiceState(radio, &info, &bthHidGuid, BLUETOOTH_SERVICE_ENABLE);
+				if (bthResult != ERROR_SUCCESS)
+				{
+					UpdateCallback(PairingState::PairingFailed);
+					return;
+				}
+
+				UpdateCallback(PairingState::Finished);
+				return;
+			}
+
+			BOOL nextDevResult = BluetoothFindNextDevice(deviceFind, &info);
+			if (nextDevResult == FALSE)
+			{
+				break;
+			}
+		}
+
+		BluetoothFindDeviceClose(deviceFind);
+	}
+}
+#elif defined(HAS_BLUEZ)
+void PairingDialog::WorkerThread()
+{
+	constexpr static uint8_t LIAC_LAP[] = {0x00, 0x8b, 0x9e};
+
+	constexpr static auto isWiimoteName = [](std::string_view name) {
+		return name == "Nintendo RVL-CNT-01" || name == "Nintendo RVL-CNT-01-TR";
+	};
+
+	// Get default BT device
+	const auto hostId = hci_get_route(nullptr);
+	if (hostId < 0)
+	{
+		UpdateCallback(PairingState::NoBluetoothAvailable);
+		return;
+	}
+
+	// Search for device
+	inquiry_info* infos = nullptr;
+	m_cancelButton->Disable();
+	const auto respCount = hci_inquiry(hostId, 7, 4, LIAC_LAP, &infos, IREQ_CACHE_FLUSH);
+	m_cancelButton->Enable();
+	if (respCount <= 0)
+	{
+		UpdateCallback(PairingState::SearchFailed);
+		return;
+	}
+	stdx::scope_exit infoFree([&]() { bt_free(infos);});
+
+	if (m_threadShouldQuit)
+		return;
+
+	// Open dev to read name
+	const auto hostDev = hci_open_dev(hostId);
+	stdx::scope_exit devClose([&]() { hci_close_dev(hostDev);});
+
+	char nameBuffer[HCI_MAX_NAME_LENGTH] = {};
+
+	bool foundADevice = false;
+	// Get device name and compare. Would use product and vendor id from SDP, but many third-party Wiimotes don't store them
+	for (const auto& devInfo : std::span(infos, respCount))
+	{
+		const auto& addr = devInfo.bdaddr;
+		const auto err =  hci_read_remote_name(hostDev, &addr, HCI_MAX_NAME_LENGTH, nameBuffer,
+								 2000);
+		if (m_threadShouldQuit)
+			return;
+		if (err || !isWiimoteName(nameBuffer))
+			continue;
+
+		L2CapWiimote::AddCandidateAddress(addr);
+		foundADevice = true;
+		const auto& b = addr.b;
+		cemuLog_log(LogType::Force, "Pairing Dialog: Found '{}' with address '{:02x}:{:02x}:{:02x}:{:02x}:{:02x}:{:02x}'",
+					nameBuffer, b[5], b[4], b[3], b[2], b[1], b[0]);
+	}
+	if (foundADevice)
+		UpdateCallback(PairingState::Finished);
+	else
+		UpdateCallback(PairingState::SearchFailed);
+}
+#else
+void PairingDialog::WorkerThread()
+{
+	UpdateCallback(PairingState::BluetoothUnusable);
+}
+#endif
+void PairingDialog::UpdateCallback(PairingState state)
+{
+	auto* event = new wxCommandEvent(wxEVT_PROGRESS_PAIR);
+	event->SetInt((int)state);
+	wxQueueEvent(this, event);
+}
\ No newline at end of file
diff --git a/src/gui/input/PairingDialog.h b/src/gui/input/PairingDialog.h
new file mode 100644
index 00000000..02cab4fc
--- /dev/null
+++ b/src/gui/input/PairingDialog.h
@@ -0,0 +1,38 @@
+#pragma once
+
+#include <wx/button.h>
+#include <wx/dialog.h>
+#include <wx/gauge.h>
+#include <wx/stattext.h>
+
+class PairingDialog : public wxDialog
+{
+public:
+	PairingDialog(wxWindow* parent);
+	~PairingDialog();
+
+private:
+    enum class PairingState
+    {
+        Pairing,
+        Finished,
+        NoBluetoothAvailable,
+	  	SearchFailed,
+        PairingFailed,
+        BluetoothUnusable
+    };
+
+    void OnClose(wxCloseEvent& event);
+    void OnCancelButton(const wxCommandEvent& event);
+    void OnGaugeUpdate(wxCommandEvent& event);
+
+    void WorkerThread();
+    void UpdateCallback(PairingState state);
+
+    wxStaticText* m_text;
+    wxGauge* m_gauge;
+    wxButton* m_cancelButton;
+
+    std::thread m_thread;
+    bool m_threadShouldQuit = false;
+};
diff --git a/src/gui/input/panels/InputPanel.cpp b/src/gui/input/panels/InputPanel.cpp
index 5d07c643..941bbd66 100644
--- a/src/gui/input/panels/InputPanel.cpp
+++ b/src/gui/input/panels/InputPanel.cpp
@@ -1,3 +1,4 @@
+#include "gui/guiWrapper.h"
 #include "gui/input/panels/InputPanel.h"
 
 #include <wx/textctrl.h>
@@ -26,7 +27,7 @@ void InputPanel::on_timer(const EmulatedControllerPtr& emulated_controller, cons
 	const auto mapping = reinterpret_cast<uint64>(element->GetClientData());
 
 	// reset mapping
-	if(std::exchange(m_right_down, false) || wxGetKeyState(WXK_ESCAPE))
+	if(std::exchange(m_right_down, false) || gui_isKeyDown(PlatformKeyCodes::ESCAPE))
 	{
 		element->SetBackgroundColour(kKeyColourNormalMode);
 		m_color_backup[element->GetId()] = kKeyColourNormalMode;
@@ -41,70 +42,69 @@ void InputPanel::on_timer(const EmulatedControllerPtr& emulated_controller, cons
 	}
 
 	static bool s_was_idle = true;
-	if (state.buttons.none()) {
+	if (state.buttons.IsIdle()) 
+	{
 		s_was_idle = true;
 		return;
 	}
 
-	if (!s_was_idle) {
+	if (!s_was_idle) 
+	{
 		return;
 	}
-
 	s_was_idle = false;
-	for (size_t i = 0; i < state.buttons.size(); ++i)
+	for(const auto& id : state.buttons.GetButtonList())
 	{
-		if (state.buttons[i])
+		if (controller->has_axis())
 		{
-			if (controller->has_axis()) {
-				// test if one axis direction is pressed more than the other
-				if ((i == kAxisXP || i == kAxisXN) && (state.buttons[kAxisYP] || state.buttons[kAxisYN]))
-				{
-					if (std::abs(state.axis.y) > std::abs(state.axis.x))
-						continue;
-				}
-				else if ((i == kAxisYP || i == kAxisYN) && (state.buttons[kAxisXP] || state.buttons[kAxisXN]))
-				{
-					if (std::abs(state.axis.x) > std::abs(state.axis.y))
-						continue;
-				}
-				else if ((i == kRotationXP || i == kRotationXN) && (state.buttons[kRotationYP] || state.buttons[kRotationYN]))
-				{
-					if (std::abs(state.rotation.y) > std::abs(state.rotation.x))
-						continue;
-				}
-				else if ((i == kRotationYP || i == kRotationYN) && (state.buttons[kRotationXP] || state.buttons[kRotationXN]))
-				{
-					if (std::abs(state.rotation.x) > std::abs(state.rotation.y))
-						continue;
-				}
-				else if ((i == kTriggerXP || i == kTriggerXN) && (state.buttons[kTriggerYP] || state.buttons[kTriggerYN]))
-				{
-					if (std::abs(state.trigger.y) > std::abs(state.trigger.x))
-						continue;
-				}
-				else if ((i == kTriggerYP || i == kTriggerYN) && (state.buttons[kTriggerXP] || state.buttons[kTriggerXN]))
-				{
-					if (std::abs(state.trigger.x) > std::abs(state.trigger.y))
-						continue;
-				}
-
-				// ignore too low button values on configuration
-				if (i >= kButtonAxisStart)
-				{
-					if (controller->get_axis_value(i) < 0.33f) {
-						forceLogDebug_printf("skipping since value too low %f", controller->get_axis_value(i));
-						s_was_idle = true;
-						return;
-					}
-				}
+			// test if one axis direction is pressed more than the other
+			if ((id == kAxisXP || id == kAxisXN) && (state.buttons.GetButtonState(kAxisYP) || state.buttons.GetButtonState(kAxisYN)))
+			{
+				if (std::abs(state.axis.y) > std::abs(state.axis.x))
+					continue;
+			}
+			else if ((id == kAxisYP || id == kAxisYN) && (state.buttons.GetButtonState(kAxisXP) || state.buttons.GetButtonState(kAxisXN)))
+			{
+				if (std::abs(state.axis.x) > std::abs(state.axis.y))
+					continue;
+			}
+			else if ((id == kRotationXP || id == kRotationXN) && (state.buttons.GetButtonState(kRotationYP) || state.buttons.GetButtonState(kRotationYN)))
+			{
+				if (std::abs(state.rotation.y) > std::abs(state.rotation.x))
+					continue;
+			}
+			else if ((id == kRotationYP || id == kRotationYN) && (state.buttons.GetButtonState(kRotationXP) || state.buttons.GetButtonState(kRotationXN)))
+			{
+				if (std::abs(state.rotation.x) > std::abs(state.rotation.y))
+					continue;
+			}
+			else if ((id == kTriggerXP || id == kTriggerXN) && (state.buttons.GetButtonState(kTriggerYP) || state.buttons.GetButtonState(kTriggerYN)))
+			{
+				if (std::abs(state.trigger.y) > std::abs(state.trigger.x))
+					continue;
+			}
+			else if ((id == kTriggerYP || id == kTriggerYN) && (state.buttons.GetButtonState(kTriggerXP) || state.buttons.GetButtonState(kTriggerXN)))
+			{
+				if (std::abs(state.trigger.x) > std::abs(state.trigger.y))
+					continue;
 			}
 
-			emulated_controller->set_mapping(mapping, controller, i);
-			element->SetValue(controller->get_button_name(i));
-			element->SetBackgroundColour(kKeyColourNormalMode);
-			m_color_backup[element->GetId()] = kKeyColourNormalMode;
-			break;
+			// ignore too low button values on configuration
+			if (id >= kButtonAxisStart)
+			{
+				if (controller->get_axis_value(id) < 0.33f) {
+					cemuLog_logDebug(LogType::Force, "skipping since value too low {}", controller->get_axis_value(id));
+					s_was_idle = true;
+					return;
+				}
+			}
 		}
+
+		emulated_controller->set_mapping(mapping, controller, id);
+		element->SetValue(controller->get_button_name(id));
+		element->SetBackgroundColour(kKeyColourNormalMode);
+		m_color_backup[element->GetId()] = kKeyColourNormalMode;
+		break;
 	}
 
 	if (const auto sibling = get_next_sibling(element))
@@ -174,12 +174,7 @@ void InputPanel::load_controller(const EmulatedControllerPtr& controller)
 			continue;
 
 		auto button_name = controller->get_mapping_name(mapping);
-#if BOOST_OS_WINDOWS
-		text->SetLabelText(button_name);
-#else
-        // SetLabelText doesn't seem to work here for some reason on wxGTK
-        text->ChangeValue(button_name);
-#endif
+		text->ChangeValue(button_name);
 	}
 }
 
@@ -213,6 +208,10 @@ void InputPanel::bind_hotkey_events(wxTextCtrl* text_ctrl)
 	text_ctrl->Bind(wxEVT_SET_FOCUS, &InputPanel::on_edit_key_focus, this);
 	text_ctrl->Bind(wxEVT_KILL_FOCUS, &InputPanel::on_edit_key_kill_focus, this);
 	text_ctrl->Bind(wxEVT_RIGHT_DOWN, &InputPanel::on_right_click, this);
+#if BOOST_OS_LINUX
+	// Bind to a no-op lambda to disable arrow keys navigation
+	text_ctrl->Bind(wxEVT_KEY_DOWN, [](wxKeyEvent &) {});
+#endif
 }
 
 void InputPanel::on_left_click(wxMouseEvent& event)
diff --git a/src/gui/input/panels/InputPanel.h b/src/gui/input/panels/InputPanel.h
index 6ac15089..1c30333c 100644
--- a/src/gui/input/panels/InputPanel.h
+++ b/src/gui/input/panels/InputPanel.h
@@ -5,6 +5,8 @@
 #include "input/emulated/EmulatedController.h"
 #include "input/api/Controller.h"
 
+#include "gui/wxHelper.h"
+
 class ControllerBase;
 class wxTextCtrl;
 class wxComboBox;
@@ -12,9 +14,15 @@ class wxComboBox;
 class InputPanel : public wxPanel
 {
 public:
+#if BOOST_OS_WINDOWS
 	const wxColour kKeyColourNormalMode = 0xfafafa;
 	const wxColour kKeyColourEditMode = 0x99ccff;
 	const wxColour kKeyColourActiveMode = 0xE0E0E0;
+#else
+	const wxColour kKeyColourNormalMode = GetBackgroundColour();
+	const wxColour kKeyColourEditMode = GetBackgroundColour();
+	const wxColour kKeyColourActiveMode = wxHelper::CalculateAccentColour(kKeyColourNormalMode);
+#endif
 
 	InputPanel(wxWindow* parent);
 
diff --git a/src/gui/input/panels/VPADInputPanel.cpp b/src/gui/input/panels/VPADInputPanel.cpp
index fbcdfde4..9e6d75d6 100644
--- a/src/gui/input/panels/VPADInputPanel.cpp
+++ b/src/gui/input/panels/VPADInputPanel.cpp
@@ -5,6 +5,7 @@
 #include <wx/statline.h>
 #include <wx/textctrl.h>
 #include <wx/slider.h>
+#include <wx/checkbox.h>
 
 
 #include "gui/helpers/wxControlObject.h"
@@ -131,11 +132,23 @@ VPADInputPanel::VPADInputPanel(wxWindow* parent)
 	}
 
 	// Blow Mic
-	row = 9;
+	row = 8;
 	add_button_row(main_sizer, row, column, VPADController::kButtonId_Mic, _("blow mic"));
 	row++;
 
 	add_button_row(main_sizer, row, column, VPADController::kButtonId_Screen, _("show screen"));
+	row++;
+
+	auto toggleScreenText = new wxStaticText(this, wxID_ANY, _("toggle screen"));
+	main_sizer->Add(toggleScreenText,
+		wxGBPosition(row, column),
+		wxDefaultSpan,
+		wxALL | wxALIGN_CENTER_VERTICAL, 5);
+	m_togglePadViewCheckBox = new wxCheckBox(this, wxID_ANY, {}, wxDefaultPosition, wxDefaultSize, wxTAB_TRAVERSAL);
+	wxString toggleScreenTT = _("Makes the \"show screen\" button toggle between the TV and gamepad screens");
+	m_togglePadViewCheckBox->SetToolTip(toggleScreenTT);
+	toggleScreenText->SetToolTip(toggleScreenTT);
+	main_sizer->Add(m_togglePadViewCheckBox, wxGBPosition(row,column+1), wxDefaultSpan, wxALL | wxEXPAND, 5);
 
 	//////////////////////////////////////////////////////////////////
 
@@ -168,6 +181,8 @@ void VPADInputPanel::on_timer(const EmulatedControllerPtr& emulated_controller,
 {
 	InputPanel::on_timer(emulated_controller, controller_base);
 
+	static_cast<VPADController*>(emulated_controller.get())->set_screen_toggle(m_togglePadViewCheckBox->GetValue());
+
 	if(emulated_controller)
 	{
 		const auto axis = emulated_controller->get_axis();
@@ -182,3 +197,10 @@ void VPADInputPanel::OnVolumeChange(wxCommandEvent& event)
 {
 
 }
+void VPADInputPanel::load_controller(const EmulatedControllerPtr& controller)
+{
+	InputPanel::load_controller(controller);
+
+	const bool isToggle = static_cast<VPADController*>(controller.get())->is_screen_active_toggle();
+	m_togglePadViewCheckBox->SetValue(isToggle);
+}
diff --git a/src/gui/input/panels/VPADInputPanel.h b/src/gui/input/panels/VPADInputPanel.h
index 3513bbf7..477385f4 100644
--- a/src/gui/input/panels/VPADInputPanel.h
+++ b/src/gui/input/panels/VPADInputPanel.h
@@ -4,6 +4,7 @@
 #include "gui/input/panels/InputPanel.h"
 
 class wxInputDraw;
+class wxCheckBox;
 
 class VPADInputPanel : public InputPanel
 {
@@ -11,11 +12,13 @@ public:
 	VPADInputPanel(wxWindow* parent);
 
 	void on_timer(const EmulatedControllerPtr& emulated_controller, const ControllerPtr& controller) override;
+	virtual void load_controller(const EmulatedControllerPtr& controller) override;
 
 private:
 	void OnVolumeChange(wxCommandEvent& event);
 
 	wxInputDraw* m_left_draw, * m_right_draw;
+	wxCheckBox* m_togglePadViewCheckBox;
 
 	void add_button_row(wxGridBagSizer *sizer, sint32 row, sint32 column, const VPADController::ButtonId &button_id);
 	void add_button_row(wxGridBagSizer *sizer, sint32 row, sint32 column, const VPADController::ButtonId &button_id, const wxString &label);
diff --git a/src/gui/input/panels/WiimoteInputPanel.cpp b/src/gui/input/panels/WiimoteInputPanel.cpp
index fbc4e325..44a7c001 100644
--- a/src/gui/input/panels/WiimoteInputPanel.cpp
+++ b/src/gui/input/panels/WiimoteInputPanel.cpp
@@ -1,5 +1,6 @@
 #include "gui/input/panels/WiimoteInputPanel.h"
 
+#include <wx/button.h>
 #include <wx/gbsizer.h>
 #include <wx/stattext.h>
 #include <wx/statline.h>
@@ -36,10 +37,13 @@ WiimoteInputPanel::WiimoteInputPanel(wxWindow* parent)
 	bold_font.MakeBold();
 
 	auto* main_sizer = new wxBoxSizer(wxVERTICAL);
+    auto* horiz_main_sizer = new wxBoxSizer(wxHORIZONTAL);
 
-	auto* extensions_sizer = new wxBoxSizer(wxHORIZONTAL);
-	extensions_sizer->Add(new wxStaticText(this, wxID_ANY, _("Extensions:")));
-	extensions_sizer->AddSpacer(10);
+    auto* extensions_sizer = new wxBoxSizer(wxHORIZONTAL);
+    horiz_main_sizer->Add(extensions_sizer, wxSizerFlags(0).Align(wxALIGN_CENTER_VERTICAL));
+
+    extensions_sizer->Add(new wxStaticText(this, wxID_ANY, _("Extensions:")));
+    extensions_sizer->AddSpacer(10);
 
 	m_motion_plus = new wxCheckBox(this, wxID_ANY, _("MotionPlus"));
 	m_motion_plus->Bind(wxEVT_CHECKBOX, &WiimoteInputPanel::on_extension_change, this);
@@ -54,7 +58,7 @@ WiimoteInputPanel::WiimoteInputPanel(wxWindow* parent)
 	m_classic->Hide();
 	extensions_sizer->Add(m_classic);
 
-	main_sizer->Add(extensions_sizer, 0, wxEXPAND | wxALL, 5);
+	main_sizer->Add(horiz_main_sizer, 0, wxEXPAND | wxALL, 5);
 	main_sizer->Add(new wxStaticLine(this), 0, wxLEFT | wxRIGHT | wxTOP | wxEXPAND, 5);
 
 	m_item_sizer = new wxGridBagSizer();
diff --git a/src/gui/input/panels/WiimoteInputPanel.h b/src/gui/input/panels/WiimoteInputPanel.h
index a7aed99b..0810fbc3 100644
--- a/src/gui/input/panels/WiimoteInputPanel.h
+++ b/src/gui/input/panels/WiimoteInputPanel.h
@@ -25,6 +25,7 @@ private:
 
 	void on_volume_change(wxCommandEvent& event);
 	void on_extension_change(wxCommandEvent& event);
+    void on_pair_button(wxCommandEvent& event);
 
 	wxGridBagSizer* m_item_sizer;
 
diff --git a/src/gui/input/settings/DefaultControllerSettings.cpp b/src/gui/input/settings/DefaultControllerSettings.cpp
index 678a792d..97cf1704 100644
--- a/src/gui/input/settings/DefaultControllerSettings.cpp
+++ b/src/gui/input/settings/DefaultControllerSettings.cpp
@@ -248,6 +248,12 @@ void DefaultControllerSettings::on_timer(wxTimerEvent& event)
 	m_controller->apply_axis_setting(state.rotation, default_state.rotation, m_settings.rotation);
 	m_controller->apply_axis_setting(state.trigger, default_state.trigger, m_settings.trigger);
 
+	if (m_controller->api() == InputAPI::SDLController)
+	{
+		state.axis.y *= -1;
+		state.rotation.y *= -1;
+	}
+
 	m_axis_draw->SetDeadzone(m_settings.axis.deadzone);
 	m_axis_draw->SetAxisValue(state.axis);
 
diff --git a/src/gui/input/settings/WiimoteControllerSettings.cpp b/src/gui/input/settings/WiimoteControllerSettings.cpp
index a1ea4ecf..9830b666 100644
--- a/src/gui/input/settings/WiimoteControllerSettings.cpp
+++ b/src/gui/input/settings/WiimoteControllerSettings.cpp
@@ -14,7 +14,7 @@
 #include "gui/components/wxInputDraw.h"
 #include "gui/input/InputAPIAddWindow.h"
 
-#if BOOST_OS_WINDOWS
+#ifdef SUPPORTS_WIIMOTE
 
 WiimoteControllerSettings::WiimoteControllerSettings(wxWindow* parent, const wxPoint& position, std::shared_ptr<NativeWiimoteController> controller)
 	: wxDialog(parent, wxID_ANY, _("Controller settings"), position, wxDefaultSize,
diff --git a/src/gui/input/settings/WiimoteControllerSettings.h b/src/gui/input/settings/WiimoteControllerSettings.h
index b519b9e5..d5214efe 100644
--- a/src/gui/input/settings/WiimoteControllerSettings.h
+++ b/src/gui/input/settings/WiimoteControllerSettings.h
@@ -1,6 +1,6 @@
 #pragma once
 
-#if BOOST_OS_WINDOWS
+#ifdef SUPPORTS_WIIMOTE
 
 #include <wx/dialog.h>
 #include <wx/timer.h>
diff --git a/src/gui/windows/PPCThreadsViewer/DebugPPCThreadsWindow.cpp b/src/gui/windows/PPCThreadsViewer/DebugPPCThreadsWindow.cpp
index 0c10f325..0669321c 100644
--- a/src/gui/windows/PPCThreadsViewer/DebugPPCThreadsWindow.cpp
+++ b/src/gui/windows/PPCThreadsViewer/DebugPPCThreadsWindow.cpp
@@ -5,7 +5,11 @@
 #include "Cafe/OS/RPL/rpl.h"
 #include "Cafe/OS/RPL/rpl_symbol_storage.h"
 
+#include "gui/components/wxProgressDialogManager.h"
+
 #include <cinttypes>
+#include <helpers/wxHelpers.h>
+#include <wx/listctrl.h>
 
 enum
 {
@@ -23,22 +27,23 @@ enum
 	THREADLIST_MENU_SUSPEND,
 	THREADLIST_MENU_RESUME,
 	THREADLIST_MENU_DUMP_STACK_TRACE,
+	THREADLIST_MENU_PROFILE_THREAD,
 };
 
 wxBEGIN_EVENT_TABLE(DebugPPCThreadsWindow, wxFrame)
-		EVT_BUTTON(CLOSE_ID,DebugPPCThreadsWindow::OnCloseButton)
-		EVT_BUTTON(REFRESH_ID,DebugPPCThreadsWindow::OnRefreshButton)
-
-		EVT_CLOSE(DebugPPCThreadsWindow::OnClose)
+	EVT_BUTTON(CLOSE_ID, DebugPPCThreadsWindow::OnCloseButton)
+	EVT_BUTTON(REFRESH_ID, DebugPPCThreadsWindow::OnRefreshButton)
+	EVT_CLOSE(DebugPPCThreadsWindow::OnClose)
 wxEND_EVENT_TABLE()
 
 DebugPPCThreadsWindow::DebugPPCThreadsWindow(wxFrame& parent)
-	: wxFrame(&parent, wxID_ANY, _("PPC threads"), wxDefaultPosition, wxSize(930, 280), wxCLOSE_BOX | wxCLIP_CHILDREN | wxCAPTION | wxRESIZE_BORDER)
+	: wxFrame(&parent, wxID_ANY, _("PPC threads"), wxDefaultPosition, wxSize(930, 280),
+			  wxCLOSE_BOX | wxCLIP_CHILDREN | wxCAPTION | wxRESIZE_BORDER)
 {
 	wxFrame::SetBackgroundColour(*wxWHITE);
 
 	auto* sizer = new wxBoxSizer(wxVERTICAL);
-	m_thread_list = new wxListCtrl(this, GPLIST_ID, wxPoint(0, 0), wxSize(930, 240), wxLC_REPORT);
+	m_thread_list = new wxListView(this, GPLIST_ID, wxPoint(0, 0), wxSize(930, 240), wxLC_REPORT);
 
 	m_thread_list->SetFont(wxFont(8, wxFONTFAMILY_MODERN, wxFONTSTYLE_NORMAL, wxFONTWEIGHT_NORMAL, false, "Courier New")); //wxSystemSettings::GetFont(wxSYS_OEM_FIXED_FONT));
 
@@ -158,7 +163,6 @@ void DebugPPCThreadsWindow::OnTimer(wxTimerEvent& event)
 		RefreshThreadList();
 }
 
-
 #define _r(__idx) _swapEndianU32(cafeThread->context.gpr[__idx])
 
 void DebugPPCThreadsWindow::RefreshThreadList()
@@ -166,139 +170,236 @@ void DebugPPCThreadsWindow::RefreshThreadList()
 	wxWindowUpdateLocker lock(m_thread_list);
 
 	long selected_thread = 0;
-	const int selection = m_thread_list->GetNextItem(-1, wxLIST_NEXT_ALL, wxLIST_STATE_SELECTED);
+	const int selection = m_thread_list->GetFirstSelected();
 	if (selection != wxNOT_FOUND)
 		selected_thread = m_thread_list->GetItemData(selection);
 
 	const int scrollPos = m_thread_list->GetScrollPos(0);
 	m_thread_list->DeleteAllItems();
 
-	__OSLockScheduler();
-	srwlock_activeThreadList.LockWrite();
-	for (sint32 i = 0; i < activeThreadCount; i++)
-	{
-		MPTR threadItrMPTR = activeThread[i];
-		OSThread_t* cafeThread = (OSThread_t*)memory_getPointerFromVirtualOffset(threadItrMPTR);
+    if(activeThreadCount > 0)
+    {
+        __OSLockScheduler();
+        srwlock_activeThreadList.LockWrite();
+        for (sint32 i = 0; i < activeThreadCount; i++)
+        {
+            MPTR threadItrMPTR = activeThread[i];
+            OSThread_t* cafeThread = (OSThread_t*)memory_getPointerFromVirtualOffset(threadItrMPTR);
 
-		char tempStr[512];
-		sprintf(tempStr, "%08X", threadItrMPTR);
+            char tempStr[512];
+            sprintf(tempStr, "%08X", threadItrMPTR);
 
 
-		wxListItem item;
-		item.SetId(i);
-		item.SetText(tempStr);
-		m_thread_list->InsertItem(item);
-		m_thread_list->SetItemData(item, (long)threadItrMPTR);
-		// entry point
-		sprintf(tempStr, "%08X", _swapEndianU32(cafeThread->entrypoint));
-		m_thread_list->SetItem(i, 1, tempStr);
-		// stack base (low)
-		sprintf(tempStr, "%08X - %08X", _swapEndianU32(cafeThread->stackEnd), _swapEndianU32(cafeThread->stackBase));
-		m_thread_list->SetItem(i, 2, tempStr);
-		// pc
-		RPLStoredSymbol* symbol = rplSymbolStorage_getByAddress(cafeThread->context.srr0);
-		if (symbol)
-			sprintf(tempStr, "%s (0x%08x)", (const char*)symbol->symbolName, cafeThread->context.srr0);
-		else
-			sprintf(tempStr, "%08X", cafeThread->context.srr0);
-		m_thread_list->SetItem(i, 3, tempStr);
-		// lr
-		sprintf(tempStr, "%08X", _swapEndianU32(cafeThread->context.lr));
-		m_thread_list->SetItem(i, 4, tempStr);
-		// state
-		OSThread_t::THREAD_STATE threadState = cafeThread->state;
-		wxString threadStateStr = "UNDEFINED";
-		if (cafeThread->suspendCounter != 0)
-			threadStateStr = "SUSPENDED";
-		else if (threadState == OSThread_t::THREAD_STATE::STATE_NONE)
-			threadStateStr = "NONE";
-		else if (threadState == OSThread_t::THREAD_STATE::STATE_READY)
-			threadStateStr = "READY";
-		else if (threadState == OSThread_t::THREAD_STATE::STATE_RUNNING)
-			threadStateStr = "RUNNING";
-		else if (threadState == OSThread_t::THREAD_STATE::STATE_WAITING)
-			threadStateStr = "WAITING";
-		else if (threadState == OSThread_t::THREAD_STATE::STATE_MORIBUND)
-			threadStateStr = "MORIBUND";
-		m_thread_list->SetItem(i, 5, threadStateStr);
-		// affinity
-		uint8 affinity = cafeThread->attr&7;
-		uint8 affinityReal = cafeThread->context.affinity;
-		if(affinity != affinityReal)
-			sprintf(tempStr, "(!) %d%d%d real: %d%d%d", (affinity >> 0) & 1, (affinity >> 1) & 1, (affinity >> 2) & 1, (affinityReal >> 0) & 1, (affinityReal >> 1) & 1, (affinityReal >> 2) & 1);
-		else
-			sprintf(tempStr, "%d%d%d", (affinity >> 0) & 1, (affinity >> 1) & 1, (affinity >> 2) & 1);
-		m_thread_list->SetItem(i, 6, tempStr);
-		// priority
-		sint32 effectivePriority = cafeThread->effectivePriority;
-		sprintf(tempStr, "%d", effectivePriority);
-		m_thread_list->SetItem(i, 7, tempStr);
-		// last awake in cycles
-		uint64 lastWakeUpTime = cafeThread->wakeUpTime;
-		sprintf(tempStr, "%" PRIu64, lastWakeUpTime);
-		m_thread_list->SetItem(i, 8, tempStr);
-		// awake time in cycles
-		uint64 awakeTime = cafeThread->totalCycles;
-		sprintf(tempStr, "%" PRIu64, awakeTime);
-		m_thread_list->SetItem(i, 9, tempStr);
-		// thread name
-		const char* threadName = "NULL";
-		if (!cafeThread->threadName.IsNull())
-			threadName = cafeThread->threadName.GetPtr();
-		m_thread_list->SetItem(i, 10, threadName);
-		// GPR
-		sprintf(tempStr, "r3 %08x r4 %08x r5 %08x r6 %08x r7 %08x", _r(3), _r(4), _r(5), _r(6), _r(7));
-		m_thread_list->SetItem(i, 11, tempStr);
-		// waiting condition / extra info
-		coreinit::OSMutex* mutex = cafeThread->waitingForMutex;
-		if (mutex)
-			sprintf(tempStr, "Mutex 0x%08x (Held by thread 0x%08X Lock-Count: %d)", memory_getVirtualOffsetFromPointer(mutex), mutex->owner.GetMPTR(), (uint32)mutex->lockCount);
-		else
-			sprintf(tempStr, "");
+            wxListItem item;
+            item.SetId(i);
+            item.SetText(tempStr);
+            m_thread_list->InsertItem(item);
+            m_thread_list->SetItemData(item, (long)threadItrMPTR);
+            // entry point
+            sprintf(tempStr, "%08X", cafeThread->entrypoint.GetMPTR());
+            m_thread_list->SetItem(i, 1, tempStr);
+            // stack base (low)
+            sprintf(tempStr, "%08X - %08X", cafeThread->stackEnd.GetMPTR(), cafeThread->stackBase.GetMPTR());
+            m_thread_list->SetItem(i, 2, tempStr);
+            // pc
+            RPLStoredSymbol* symbol = rplSymbolStorage_getByAddress(cafeThread->context.srr0);
+            if (symbol)
+                sprintf(tempStr, "%s (0x%08x)", (const char*)symbol->symbolName, cafeThread->context.srr0);
+            else
+                sprintf(tempStr, "%08X", cafeThread->context.srr0);
+            m_thread_list->SetItem(i, 3, tempStr);
+            // lr
+            sprintf(tempStr, "%08X", _swapEndianU32(cafeThread->context.lr));
+            m_thread_list->SetItem(i, 4, tempStr);
+            // state
+            OSThread_t::THREAD_STATE threadState = cafeThread->state;
+            wxString threadStateStr = "UNDEFINED";
+            if (cafeThread->suspendCounter != 0)
+                threadStateStr = "SUSPENDED";
+            else if (threadState == OSThread_t::THREAD_STATE::STATE_NONE)
+                threadStateStr = "NONE";
+            else if (threadState == OSThread_t::THREAD_STATE::STATE_READY)
+                threadStateStr = "READY";
+            else if (threadState == OSThread_t::THREAD_STATE::STATE_RUNNING)
+                threadStateStr = "RUNNING";
+            else if (threadState == OSThread_t::THREAD_STATE::STATE_WAITING)
+                threadStateStr = "WAITING";
+            else if (threadState == OSThread_t::THREAD_STATE::STATE_MORIBUND)
+                threadStateStr = "MORIBUND";
+            m_thread_list->SetItem(i, 5, threadStateStr);
+            // affinity
+            uint8 affinity = cafeThread->attr&7;
+            uint8 affinityReal = cafeThread->context.affinity;
+            if(affinity != affinityReal)
+                sprintf(tempStr, "(!) %d%d%d real: %d%d%d", (affinity >> 0) & 1, (affinity >> 1) & 1, (affinity >> 2) & 1, (affinityReal >> 0) & 1, (affinityReal >> 1) & 1, (affinityReal >> 2) & 1);
+            else
+                sprintf(tempStr, "%d%d%d", (affinity >> 0) & 1, (affinity >> 1) & 1, (affinity >> 2) & 1);
+            m_thread_list->SetItem(i, 6, tempStr);
+            // priority
+            sint32 effectivePriority = cafeThread->effectivePriority;
+            sprintf(tempStr, "%d", effectivePriority);
+            m_thread_list->SetItem(i, 7, tempStr);
+            // last awake in cycles
+            uint64 lastWakeUpTime = cafeThread->wakeUpTime;
+            sprintf(tempStr, "%" PRIu64, lastWakeUpTime);
+            m_thread_list->SetItem(i, 8, tempStr);
+            // awake time in cycles
+            uint64 awakeTime = cafeThread->totalCycles;
+            sprintf(tempStr, "%" PRIu64, awakeTime);
+            m_thread_list->SetItem(i, 9, tempStr);
+            // thread name
+            const char* threadName = "NULL";
+            if (!cafeThread->threadName.IsNull())
+                threadName = cafeThread->threadName.GetPtr();
+            m_thread_list->SetItem(i, 10, threadName);
+            // GPR
+            sprintf(tempStr, "r3 %08x r4 %08x r5 %08x r6 %08x r7 %08x", _r(3), _r(4), _r(5), _r(6), _r(7));
+            m_thread_list->SetItem(i, 11, tempStr);
+            // waiting condition / extra info
+            coreinit::OSMutex* mutex = cafeThread->waitingForMutex;
+            if (mutex)
+                sprintf(tempStr, "Mutex 0x%08x (Held by thread 0x%08X Lock-Count: %d)", memory_getVirtualOffsetFromPointer(mutex), mutex->owner.GetMPTR(), (uint32)mutex->lockCount);
+            else
+                sprintf(tempStr, "");
 
-		// OSSetThreadCancelState
-		if (cafeThread->requestFlags & OSThread_t::REQUEST_FLAG_CANCEL)
-			strcat(tempStr, "[Cancel requested]");
+            // OSSetThreadCancelState
+            if (cafeThread->requestFlags & OSThread_t::REQUEST_FLAG_CANCEL)
+                strcat(tempStr, "[Cancel requested]");
 
-		m_thread_list->SetItem(i, 12, tempStr);
+            m_thread_list->SetItem(i, 12, tempStr);
 
-		if(selected_thread != 0 && selected_thread == (long)threadItrMPTR)
-			m_thread_list->SetItemState(i, wxLIST_STATE_FOCUSED | wxLIST_STATE_SELECTED, wxLIST_STATE_FOCUSED | wxLIST_STATE_SELECTED);
+			if (selected_thread != 0 && selected_thread == (long)threadItrMPTR)
+			{
+				m_thread_list->Select(i);
+				m_thread_list->Focus(i);
+			}
+		}
+		srwlock_activeThreadList.UnlockWrite();
+		__OSUnlockScheduler();
 	}
-	srwlock_activeThreadList.UnlockWrite();
-	__OSUnlockScheduler();
 
 	m_thread_list->SetScrollPos(0, scrollPos, true);
 }
 
-void DebugLogStackTrace(OSThread_t* thread, MPTR sp);
-
 void DebugPPCThreadsWindow::DumpStackTrace(OSThread_t* thread)
 {
-	cemuLog_log(LogType::Force, fmt::format("Dumping stack trace for thread {0:08x} LR: {1:08x}", memory_getVirtualOffsetFromPointer(thread), _swapEndianU32(thread->context.lr)));
-	DebugLogStackTrace(thread, _swapEndianU32(thread->context.gpr[1]));
+	cemuLog_log(LogType::Force, "Dumping stack trace for thread {0:08x} LR: {1:08x}", memory_getVirtualOffsetFromPointer(thread), _swapEndianU32(thread->context.lr));
+	DebugLogStackTrace(thread, _swapEndianU32(thread->context.gpr[1]), true);
+}
+
+void DebugPPCThreadsWindow::PresentProfileResults(OSThread_t* thread, const std::unordered_map<VAddr, uint32>& samples)
+{
+	std::vector<std::pair<VAddr, uint32>> sortedSamples;
+	// count samples
+	uint32 totalSampleCount = 0;
+	for (auto& sample : samples)
+		totalSampleCount += sample.second;
+	cemuLog_log(LogType::Force, "--- Thread {:08x} profile results with {:} samples captured ---",
+				MEMPTR<OSThread_t>(thread).GetMPTR(), totalSampleCount);
+	cemuLog_log(LogType::Force, "Exclusive time, grouped by function:");
+	// print samples grouped by function
+	sortedSamples.clear();
+	for (auto& sample : samples)
+	{
+		RPLStoredSymbol* symbol = rplSymbolStorage_getByClosestAddress(sample.first);
+		VAddr sampleAddr = sample.first;
+		if (symbol)
+			sampleAddr = symbol->address;
+		auto it = std::find_if(sortedSamples.begin(), sortedSamples.end(),
+							   [sampleAddr](const std::pair<VAddr, uint32>& a) { return a.first == sampleAddr; });
+		if (it != sortedSamples.end())
+			it->second += sample.second;
+		else
+			sortedSamples.push_back(std::make_pair(sampleAddr, sample.second));
+	}
+	std::sort(sortedSamples.begin(), sortedSamples.end(),
+			  [](const std::pair<VAddr, uint32>& a, const std::pair<VAddr, uint32>& b) { return a.second > b.second; });
+	for (auto& sample : sortedSamples)
+	{
+		if (sample.second < 3)
+			continue;
+		VAddr sampleAddr = sample.first;
+		RPLStoredSymbol* symbol = rplSymbolStorage_getByClosestAddress(sample.first);
+		std::string strName;
+		if (symbol)
+		{
+			strName = fmt::format("{}.{}+0x{:x}", (const char*)symbol->libName, (const char*)symbol->symbolName,
+								  sampleAddr - symbol->address);
+		}
+		else
+			strName = "Unknown";
+		cemuLog_log(LogType::Force, "[{:08x}] {:8.2f}% (Samples: {:5}) Symbol: {}", sample.first,
+					(double)(sample.second * 100) / (double)totalSampleCount, sample.second, strName);
+	}
+}
+
+void DebugPPCThreadsWindow::ProfileThreadWorker(OSThread_t* thread)
+{
+	wxProgressDialogManager progressDialog(this);
+	progressDialog.Create(_("Profiling thread"),
+						  _("Capturing samples..."),
+						  1000, // range
+						  wxPD_CAN_SKIP);
+
+	std::unordered_map<VAddr, uint32> samples;
+	// loop for one minute
+	uint64 startTime = std::chrono::duration_cast<std::chrono::milliseconds>(
+						   std::chrono::system_clock::now().time_since_epoch())
+						   .count();
+	uint32 totalSampleCount = 0;
+	while (true)
+	{
+		// suspend thread
+		coreinit::OSSuspendThread(thread);
+		// wait until thread is not running anymore
+		__OSLockScheduler();
+		while (coreinit::OSIsThreadRunningNoLock(thread))
+		{
+			__OSUnlockScheduler();
+			std::this_thread::sleep_for(std::chrono::milliseconds(1));
+			__OSLockScheduler();
+		}
+		uint32 sampleIP = thread->context.srr0;
+		__OSUnlockScheduler();
+		coreinit::OSResumeThread(thread);
+		// count sample
+		samples[sampleIP]++;
+		totalSampleCount++;
+		if ((totalSampleCount % 50) == 0)
+		{
+			wxString msg = formatWxString(_("Capturing samples... ({:})\nResults will be written to log.txt\n"), totalSampleCount);
+			if (totalSampleCount < 30000)
+				msg.Append(_("Click Skip button for early results with lower accuracy"));
+			else
+				msg.Append(_("Click Skip button to finish"));
+			progressDialog.Update(totalSampleCount * 1000 / 30000, msg);
+			if (progressDialog.IsCancelledOrSkipped())
+				break;
+		}
+		std::this_thread::sleep_for(std::chrono::milliseconds(1));
+	}
+	PresentProfileResults(thread, samples);
+	progressDialog.Destroy();
+}
+
+void DebugPPCThreadsWindow::ProfileThread(OSThread_t* thread)
+{
+	std::thread profileThread(&DebugPPCThreadsWindow::ProfileThreadWorker, this, thread);
+	profileThread.detach();
 }
 
 void DebugPPCThreadsWindow::OnThreadListPopupClick(wxCommandEvent& evt)
 {
-	MPTR threadMPTR = (MPTR)(size_t)static_cast<wxMenu *>(evt.GetEventObject())->GetClientData();
-	// check if thread is still active
-	bool threadIsActive = false;
-	srwlock_activeThreadList.LockWrite();
-	for (sint32 i = 0; i < activeThreadCount; i++)
-	{
-		MPTR threadItrMPTR = activeThread[i];
-		if (threadItrMPTR == threadMPTR)
-		{
-			threadIsActive = true;
-			break;
-		}
-	}
-	srwlock_activeThreadList.UnlockWrite();
-	if (threadIsActive == false)
-		return;
-	// handle command
+	MPTR threadMPTR = (MPTR)(size_t) static_cast<wxMenu*>(evt.GetEventObject())->GetClientData();
 	OSThread_t* osThread = (OSThread_t*)memory_getPointerFromVirtualOffset(threadMPTR);
+	__OSLockScheduler();
+	if (!coreinit::__OSIsThreadActive(osThread))
+	{
+		__OSUnlockScheduler();
+		return;
+	}
+	__OSUnlockScheduler();
+	// handle command
 	switch (evt.GetId())
 	{
 	case THREADLIST_MENU_BOOST_PRIO_5:
@@ -322,6 +423,9 @@ void DebugPPCThreadsWindow::OnThreadListPopupClick(wxCommandEvent& evt)
 	case THREADLIST_MENU_DUMP_STACK_TRACE:
 		DumpStackTrace(osThread);
 		break;
+	case THREADLIST_MENU_PROFILE_THREAD:
+		ProfileThread(osThread);
+		break;
 	}
 	coreinit::__OSUpdateThreadEffectivePriority(osThread);
 	// update thread list
@@ -336,28 +440,20 @@ void DebugPPCThreadsWindow::OnThreadListRightClick(wxMouseEvent& event)
 	if (itemIndex == wxNOT_FOUND)
 		return;
 	// select item
-	m_thread_list->SetItemState(itemIndex, wxLIST_STATE_FOCUSED, wxLIST_STATE_FOCUSED);
-	long sel = m_thread_list->GetNextItem(-1, wxLIST_NEXT_ALL,
-	                                   wxLIST_STATE_SELECTED);
-	if (sel != -1)
-		m_thread_list->SetItemState(sel, 0, wxLIST_STATE_SELECTED);
-	m_thread_list->SetItemState(itemIndex, wxLIST_STATE_SELECTED, wxLIST_STATE_SELECTED);
+	m_thread_list->Focus(itemIndex);
+	long sel = m_thread_list->GetFirstSelected();
+	if (sel != wxNOT_FOUND)
+		m_thread_list->Select(sel, false);
+	m_thread_list->Select(itemIndex);
 	// check if thread is still on the list of active threads
 	MPTR threadMPTR = (MPTR)m_thread_list->GetItemData(itemIndex);
-	bool threadIsActive = false;
-	srwlock_activeThreadList.LockWrite();
-	for (sint32 i = 0; i < activeThreadCount; i++)
+	__OSLockScheduler();
+	if (!coreinit::__OSIsThreadActive(MEMPTR<OSThread_t>(threadMPTR)))
 	{
-		MPTR threadItrMPTR = activeThread[i];
-		if (threadItrMPTR == threadMPTR)
-		{
-			threadIsActive = true;
-			break;
-		}
-	}
-	srwlock_activeThreadList.UnlockWrite();
-	if (threadIsActive == false)
+		__OSUnlockScheduler();
 		return;
+	}
+	__OSUnlockScheduler();
 	// create menu entry
 	wxMenu menu;
 	menu.SetClientData((void*)(size_t)threadMPTR);
@@ -371,6 +467,7 @@ void DebugPPCThreadsWindow::OnThreadListRightClick(wxMouseEvent& event)
 	menu.Append(THREADLIST_MENU_SUSPEND, _("Suspend"));
 	menu.AppendSeparator();
 	menu.Append(THREADLIST_MENU_DUMP_STACK_TRACE, _("Write stack trace to log"));
+	menu.Append(THREADLIST_MENU_PROFILE_THREAD, _("Profile thread"));
 	menu.Connect(wxEVT_COMMAND_MENU_SELECTED, wxCommandEventHandler(DebugPPCThreadsWindow::OnThreadListPopupClick), nullptr, this);
 	PopupMenu(&menu);
 }
diff --git a/src/gui/windows/PPCThreadsViewer/DebugPPCThreadsWindow.h b/src/gui/windows/PPCThreadsViewer/DebugPPCThreadsWindow.h
index e967ad7c..f6dc9060 100644
--- a/src/gui/windows/PPCThreadsViewer/DebugPPCThreadsWindow.h
+++ b/src/gui/windows/PPCThreadsViewer/DebugPPCThreadsWindow.h
@@ -15,12 +15,15 @@ public:
 	void OnThreadListPopupClick(wxCommandEvent &evt);
 	void OnThreadListRightClick(wxMouseEvent& event);
 
-	void DumpStackTrace(struct OSThread_t* thread);
-
 	void Close();
 
 private:
-	wxListCtrl* m_thread_list;
+    void ProfileThread(struct OSThread_t* thread);
+    void ProfileThreadWorker(OSThread_t* thread);
+    void PresentProfileResults(OSThread_t* thread, const std::unordered_map<VAddr, uint32>& samples);
+    void DumpStackTrace(struct OSThread_t* thread);
+
+	wxListView* m_thread_list;
 	wxCheckBox* m_auto_refresh;
 	wxTimer* m_timer;
 
@@ -29,4 +32,4 @@ private:
 	wxDECLARE_EVENT_TABLE();
 
 
-};
\ No newline at end of file
+};
diff --git a/src/gui/windows/TextureRelationViewer/TextureRelationWindow.cpp b/src/gui/windows/TextureRelationViewer/TextureRelationWindow.cpp
index 718bca3a..7f732e17 100644
--- a/src/gui/windows/TextureRelationViewer/TextureRelationWindow.cpp
+++ b/src/gui/windows/TextureRelationViewer/TextureRelationWindow.cpp
@@ -48,52 +48,57 @@ TextureRelationViewerWindow::TextureRelationViewerWindow(wxFrame& parent)
 	textureRelationListA->SetFont(wxFont(8, wxFONTFAMILY_MODERN, wxFONTSTYLE_NORMAL, wxFONTWEIGHT_NORMAL, false, "Courier New"));//wxSystemSettings::GetFont(wxSYS_OEM_FIXED_FONT));
 
 	// add columns
-	wxListItem col0;
+	wxListItem colType;
 	sint32 columnIndex = 0;
-	col0.SetId(columnIndex); columnIndex++;
-	col0.SetText("Type");
-	col0.SetWidth(85);
-	textureRelationListA->InsertColumn(columnIndex-1, col0);
-	wxListItem col1;
-	col1.SetId(columnIndex); columnIndex++;
-	col1.SetText("PhysAddr");
-	col1.SetWidth(80);
-	textureRelationListA->InsertColumn(columnIndex-1, col1);
-	wxListItem col2;
-	col2.SetId(columnIndex); columnIndex++;
-	col2.SetText("Dim");
-	col2.SetWidth(80);
-	textureRelationListA->InsertColumn(columnIndex-1, col2);
-	wxListItem col3;
-	col3.SetId(columnIndex); columnIndex++;
-	col3.SetText("Resolution");
-	col3.SetWidth(110);
-	textureRelationListA->InsertColumn(columnIndex-1, col3);
-	wxListItem col5;
-	col5.SetId(columnIndex); columnIndex++;
-	col5.SetText("Format");
-	col5.SetWidth(70);
-	textureRelationListA->InsertColumn(columnIndex-1, col5);
-	wxListItem colPriority;
-	colPriority.SetId(columnIndex); columnIndex++;
-	colPriority.SetText("Pitch");
-	colPriority.SetWidth(80);
-	textureRelationListA->InsertColumn(columnIndex-1, colPriority);
-	wxListItem col6;
-	col6.SetId(columnIndex); columnIndex++;
-	col6.SetText("Tilemode");
-	col6.SetWidth(80);
-	textureRelationListA->InsertColumn(columnIndex-1, col6);
-	wxListItem col7;
-	col7.SetId(columnIndex); columnIndex++;
-	col7.SetText("SliceRange");
-	col7.SetWidth(90);
-	textureRelationListA->InsertColumn(columnIndex-1, col7);
-	wxListItem col8;
-	col8.SetId(columnIndex); columnIndex++;
-	col8.SetText("MipRange");
-	col8.SetWidth(90);
-	textureRelationListA->InsertColumn(columnIndex-1, col8);
+	colType.SetId(columnIndex); columnIndex++;
+	colType.SetText("Type");
+	colType.SetWidth(85);
+	textureRelationListA->InsertColumn(columnIndex-1, colType);
+    wxListItem colPhysAddr;
+    colPhysAddr.SetId(columnIndex); columnIndex++;
+    colPhysAddr.SetText("PhysAddr");
+    colPhysAddr.SetWidth(80);
+    textureRelationListA->InsertColumn(columnIndex-1, colPhysAddr);
+    wxListItem colPhysMipAddr;
+    colPhysMipAddr.SetId(columnIndex); columnIndex++;
+    colPhysMipAddr.SetText("MipPAddr");
+    colPhysMipAddr.SetWidth(80);
+    textureRelationListA->InsertColumn(columnIndex-1, colPhysMipAddr);
+	wxListItem colDim;
+	colDim.SetId(columnIndex); columnIndex++;
+	colDim.SetText("Dim");
+	colDim.SetWidth(80);
+	textureRelationListA->InsertColumn(columnIndex-1, colDim);
+	wxListItem colResolution;
+	colResolution.SetId(columnIndex); columnIndex++;
+	colResolution.SetText("Resolution");
+	colResolution.SetWidth(110);
+	textureRelationListA->InsertColumn(columnIndex-1, colResolution);
+	wxListItem colFormat;
+	colFormat.SetId(columnIndex); columnIndex++;
+	colFormat.SetText("Format");
+	colFormat.SetWidth(70);
+	textureRelationListA->InsertColumn(columnIndex-1, colFormat);
+	wxListItem colPitch;
+	colPitch.SetId(columnIndex); columnIndex++;
+	colPitch.SetText("Pitch");
+	colPitch.SetWidth(80);
+	textureRelationListA->InsertColumn(columnIndex-1, colPitch);
+	wxListItem colTilemode;
+	colTilemode.SetId(columnIndex); columnIndex++;
+	colTilemode.SetText("Tilemode");
+	colTilemode.SetWidth(80);
+	textureRelationListA->InsertColumn(columnIndex-1, colTilemode);
+	wxListItem colSliceRange;
+	colSliceRange.SetId(columnIndex); columnIndex++;
+	colSliceRange.SetText("SliceRange");
+	colSliceRange.SetWidth(90);
+	textureRelationListA->InsertColumn(columnIndex-1, colSliceRange);
+	wxListItem colMipRange;
+	colMipRange.SetId(columnIndex); columnIndex++;
+	colMipRange.SetText("MipRange");
+	colMipRange.SetWidth(90);
+	textureRelationListA->InsertColumn(columnIndex-1, colMipRange);
 	wxListItem colAge;
 	colAge.SetId(columnIndex); columnIndex++;
 	colAge.SetText("Last access");
@@ -186,10 +191,14 @@ void TextureRelationViewerWindow::_setTextureRelationListItemTexture(wxListCtrl*
 	uiList->InsertItem(item);
 
 	sint32 columnIndex = 1;
-	// phys address
-	sprintf(tempStr, "%08X", texInfo->physAddress);
-	uiList->SetItem(rowIndex, columnIndex, tempStr);
-	columnIndex++;
+    // phys address
+    sprintf(tempStr, "%08X", texInfo->physAddress);
+    uiList->SetItem(rowIndex, columnIndex, tempStr);
+    columnIndex++;
+    // phys mip address
+    sprintf(tempStr, "%08X", texInfo->physMipAddress);
+    uiList->SetItem(rowIndex, columnIndex, tempStr);
+    columnIndex++;
 	// dim
 	if (texInfo->dim == Latte::E_DIM::DIM_2D)
 		strcpy(tempStr, "2D");
@@ -228,7 +237,7 @@ void TextureRelationViewerWindow::_setTextureRelationListItemTexture(wxListCtrl*
 	uiList->SetItem(rowIndex, columnIndex, tempStr);
 	columnIndex++;
 	// tilemode
-	sprintf(tempStr, "%d", texInfo->tileMode);
+	sprintf(tempStr, "%d", (int)texInfo->tileMode);
 	uiList->SetItem(rowIndex, columnIndex, tempStr);
 	columnIndex++;
 	// sliceRange
@@ -278,10 +287,14 @@ void TextureRelationViewerWindow::_setTextureRelationListItemView(wxListCtrl* ui
 	uiList->InsertItem(item);
 	//uiList->SetItemPtrData(item, (wxUIntPtr)viewInfo);
 	sint32 columnIndex = 1;
-	// phys address
-	sprintf(tempStr, "");
-	uiList->SetItem(rowIndex, columnIndex, tempStr);
-	columnIndex++;
+    // phys address
+    sprintf(tempStr, "");
+    uiList->SetItem(rowIndex, columnIndex, tempStr);
+    columnIndex++;
+    // phys mip address
+    sprintf(tempStr, "");
+    uiList->SetItem(rowIndex, columnIndex, tempStr);
+    columnIndex++;
 	// dim
 	if (viewInfo->dim == Latte::E_DIM::DIM_2D)
 		strcpy(tempStr, "2D");
diff --git a/src/gui/wxHelper.h b/src/gui/wxHelper.h
index 753a5caf..468651ac 100644
--- a/src/gui/wxHelper.h
+++ b/src/gui/wxHelper.h
@@ -3,13 +3,6 @@
 
 namespace wxHelper
 {
-    // wxString to utf8 std::string
-    inline std::string MakeUTF8(const wxString& str)
-    {
-        auto tmpUtf8 = str.ToUTF8();
-        return std::string(tmpUtf8.data(), tmpUtf8.length());
-    }
-
     inline fs::path MakeFSPath(const wxString& str)
     {
         auto tmpUtf8 = str.ToUTF8();
@@ -17,10 +10,27 @@ namespace wxHelper
         return fs::path(sv);
     }
 
-    inline wxString FromUtf8(std::string_view str)
-    {
-        return wxString::FromUTF8(str.data(), str.size());
-    }
+	inline wxString FromUtf8(std::string_view str)
+	{
+		return wxString::FromUTF8(str.data(), str.size());
+	}
 
+	inline wxString FromPath(const fs::path& path)
+	{
+		std::string str = _pathToUtf8(path);
+		return wxString::FromUTF8(str.data(), str.size());
+	}
+
+	inline wxColour CalculateAccentColour(const wxColour& bgColour)
+	{
+		wxColour bgColourSecondary;
+		const uint32 bgLightness = (bgColour.GetRed() + bgColour.GetGreen() + bgColour.GetBlue()) / 3;
+		const bool isDarkTheme = bgLightness < 128;
+		bgColourSecondary = bgColour.ChangeLightness(isDarkTheme ? 110 : 90); // color for even rows
+		// for very light themes we'll use a blue tint to match the older Windows Cemu look
+		if (bgLightness > 250)
+			bgColourSecondary = wxColour(bgColour.Red() - 13, bgColour.Green() - 6, bgColour.Blue() - 2);
+		return bgColourSecondary;
+	}
 
 };
diff --git a/src/gui/wxcomponents/checkedlistctrl.h b/src/gui/wxcomponents/checkedlistctrl.h
index 215c0004..e09536f9 100644
--- a/src/gui/wxcomponents/checkedlistctrl.h
+++ b/src/gui/wxcomponents/checkedlistctrl.h
@@ -72,7 +72,7 @@ DECLARE_EXPORTED_EVENT_TYPE(WXEXPORT, wxEVT_COMMAND_LIST_ITEM_UNCHECKED, -1);
 
 //! This is the class which performs all transactions with the server.
 //! It uses the wxSocket facilities.
-class wxCheckedListCtrl : public wxListCtrl
+class wxCheckedListCtrl : public wxListView
 {
 protected:
 
@@ -85,18 +85,18 @@ protected:
 
 public:
     wxCheckedListCtrl()
-        : wxListCtrl(), m_imageList(16, 16, TRUE) {}
+        : wxListView(), m_imageList(16, 16, TRUE) {}
 
-    wxCheckedListCtrl(wxWindow *parent, wxWindowID id = -1,
+    wxCheckedListCtrl(wxWindow *parent, wxWindowID id = wxID_ANY,
                         const wxPoint& pt = wxDefaultPosition,
                         const wxSize& sz = wxDefaultSize,
                         long style = wxCLC_CHECK_WHEN_SELECTING,
                         const wxValidator& validator = wxDefaultValidator,
                         const wxString& name = wxListCtrlNameStr)
-                        : wxListCtrl(), m_imageList(16, 16, TRUE)
+                        : wxListView(), m_imageList(16, 16, TRUE)
         { Create(parent, id, pt, sz, style, validator, name); }
 
-    bool Create(wxWindow *parent, wxWindowID id = -1,
+    bool Create(wxWindow *parent, wxWindowID id = wxID_ANY,
                         const wxPoint& pt = wxDefaultPosition,
                         const wxSize& sz = wxDefaultSize,
                         long style = wxCLC_CHECK_WHEN_SELECTING,
diff --git a/src/gui/wxgui.h b/src/gui/wxgui.h
index f09ea420..bb4352d1 100644
--- a/src/gui/wxgui.h
+++ b/src/gui/wxgui.h
@@ -1,5 +1,7 @@
 #pragma once
 
+#define wxNO_UNSAFE_WXSTRING_CONV 1
+
 #include <wx/wxprec.h>
 #ifndef WX_PRECOMP
 #include <wx/wx.h>
@@ -12,6 +14,7 @@
 #include <wx/slider.h>
 #include <wx/stattext.h>
 #include <wx/textctrl.h>
+#include <wx/spinctrl.h>
 #include <wx/listbase.h>
 #include <wx/display.h>
 #include <wx/aboutdlg.h>
@@ -35,67 +38,6 @@
 
 extern bool g_inputConfigWindowHasFocus;
 
-// wx helper functions
-#include <wx/string.h>
-struct wxStringFormatParameters
-{
-	sint32 parameter_index;
-	sint32 parameter_count;
-
-	wchar_t* token_buffer;
-	wchar_t* substitude_parameter;
-};
-
-template <typename ...Args>
-wxString wxStringFormat(std::wstring& format, wxStringFormatParameters& parameters)
-{
-	return format;
-}
-
-template <typename T, typename ...Args>
-wxString wxStringFormat(std::wstring& format, wxStringFormatParameters& parameters, T arg, Args... args)
-{
-	wchar_t tmp[64];
-	swprintf(tmp, 64, LR"(\{[%d]+\})", parameters.parameter_index);
-	const std::wregex placeholder_regex(tmp);
-
-	auto result = format;
-	while (std::regex_search(result, placeholder_regex))
-	{
-		result = std::regex_replace(result, placeholder_regex, parameters.substitude_parameter, std::regex_constants::format_first_only);
-		result = wxString::Format(wxString(result), arg);
-	}
-
-	parameters.parameter_index++;
-	if (parameters.parameter_index == parameters.parameter_count)
-		return result;
-
-	parameters.substitude_parameter = std::wcstok(nullptr, LR"( )", &parameters.token_buffer);
-	return wxStringFormat(result, parameters, args...);
-}
-
-template <typename ...T>
-wxString wxStringFormat(const wxString& format, const wchar_t* parameters, T... args)
-{
-	const auto parameter_count = std::count(parameters, parameters + wcslen(parameters), '%');
-	if (parameter_count == 0)
-		return format;
-
-	const auto copy = wcsdup(parameters);
-
-	wxStringFormatParameters para;
-	para.substitude_parameter = std::wcstok(copy, LR"( )", &para.token_buffer);
-	para.parameter_count = parameter_count;
-	para.parameter_index = 0;
-
-	auto tmp_string = format.ToStdWstring();
-	auto result = wxStringFormat(tmp_string, para, args...);
-
-	free(copy);
-
-	return result;
-}
-
 inline bool SendSliderEvent(wxSlider* slider, int new_value)
 {
 	wxCommandEvent cevent(wxEVT_SLIDER, slider->GetId());
diff --git a/src/imgui/CMakeLists.txt b/src/imgui/CMakeLists.txt
index 412330ec..db7686bd 100644
--- a/src/imgui/CMakeLists.txt
+++ b/src/imgui/CMakeLists.txt
@@ -1,10 +1,4 @@
-project(imguiImpl)
-
-add_library(imguiImpl)
-
-set_property(TARGET imguiImpl PROPERTY MSVC_RUNTIME_LIBRARY "MultiThreaded$<$<CONFIG:Debug>:Debug>")
-
-target_sources(imguiImpl PRIVATE
+add_library(imguiImpl
 	imgui_impl_opengl3.cpp
 	imgui_impl_opengl3.h
 	imgui_impl_vulkan.cpp
@@ -13,8 +7,20 @@ target_sources(imguiImpl PRIVATE
 	imgui_extension.h
 )
 
+set_property(TARGET imguiImpl PROPERTY MSVC_RUNTIME_LIBRARY "MultiThreaded$<$<CONFIG:Debug>:Debug>")
+
 target_include_directories(imguiImpl PUBLIC "../")
 
+# imgui source files
+target_sources(imguiImpl PRIVATE
+"../../dependencies/imgui/imgui.cpp"
+"../../dependencies/imgui/imgui_draw.cpp"
+"../../dependencies/imgui/imgui_tables.cpp"
+"../../dependencies/imgui/imgui_widgets.cpp"
+)
+
+target_include_directories(imguiImpl PUBLIC "../../dependencies/imgui/")
+
 target_link_libraries(imguiImpl PRIVATE
 	CemuCafe
 	CemuCommon
@@ -22,5 +28,4 @@ target_link_libraries(imguiImpl PRIVATE
 	CemuInput
 	CemuResource
 	CemuUtil
-	imgui::imgui
 )
diff --git a/src/imgui/imgui_extension.cpp b/src/imgui/imgui_extension.cpp
index 567a1e9a..f1c072fa 100644
--- a/src/imgui/imgui_extension.cpp
+++ b/src/imgui/imgui_extension.cpp
@@ -43,6 +43,10 @@ void ImRotateEnd(float rad, ImVec2 center)
 uint8* extractCafeDefaultFont(sint32* size);
 sint32 g_font_size = 0;
 uint8* g_font_data = nullptr;
+#if !BOOST_OS_WINDOWS
+extern int const g_fontawesome_size;
+extern char const g_fontawesome_data[];
+#endif
 std::unordered_map<int, ImFont*> g_imgui_fonts;
 std::stack<int> g_font_requests;
 
@@ -66,6 +70,14 @@ void ImGui_PrecacheFonts()
 		//cfg.SizePixels = size;
 		ImFont* font = io.Fonts->AddFontFromMemoryTTF(g_font_data, g_font_size, (float)size, &cfg);
 
+		ImFontConfig cfgmerge{};
+		cfgmerge.FontDataOwnedByAtlas = false;
+		cfgmerge.MergeMode = true;
+		cfgmerge.GlyphMinAdvanceX = 20.0f;
+		//cfgmerge.GlyphOffset = { 2,2 };
+
+		static const ImWchar icon_ranges[] = { ICON_MIN_FA, ICON_MAX_FA, 0 };
+
 #if BOOST_OS_WINDOWS
 		const auto hinstance = GetModuleHandle(nullptr);
 		const HRSRC res = FindResource(hinstance, MAKEINTRESOURCE(IDR_FONTAWESOME), RT_RCDATA);
@@ -77,16 +89,11 @@ void ImGui_PrecacheFonts()
 				void* data = LockResource(mem);
 				const size_t len = SizeofResource(hinstance, res);
 
-				ImFontConfig cfgmerge{};
-				cfgmerge.FontDataOwnedByAtlas = false;
-				cfgmerge.MergeMode = true;
-				cfgmerge.GlyphMinAdvanceX = 20.0f;
-				//cfgmerge.GlyphOffset = { 2,2 };
-
-				static const ImWchar icon_ranges[] = { ICON_MIN_FA, ICON_MAX_FA, 0 };
 				io.Fonts->AddFontFromMemoryTTF(data, (int)len, (float)size, &cfgmerge, icon_ranges);
 			}
 		}
+#else
+		io.Fonts->AddFontFromMemoryTTF((void*)g_fontawesome_data, (int)g_fontawesome_size, (float)size, &cfgmerge, icon_ranges);
 #endif
 
 		g_imgui_fonts[(int)size] = font;
@@ -97,6 +104,11 @@ void ImGui_PrecacheFonts()
 	}
 }
 
+void ImGui_ClearFonts()
+{
+    g_imgui_fonts.clear();
+}
+
 ImFont* ImGui_GetFont(float size)
 {
 	const auto it = g_imgui_fonts.find((int)size);
@@ -110,7 +122,8 @@ ImFont* ImGui_GetFont(float size)
 void ImGui_UpdateWindowInformation(bool mainWindow)
 {
 	extern WindowInfo g_window_info;
-
+	static std::map<uint32, ImGuiKey> keyboard_mapping;
+	static uint32 current_key = 0;
 	ImGuiIO& io = ImGui::GetIO();
 	io.BackendFlags |= ImGuiBackendFlags_HasMouseCursors;
 	io.ConfigFlags |= ImGuiConfigFlags_NavEnableGamepad;
@@ -130,9 +143,17 @@ void ImGui_UpdateWindowInformation(bool mainWindow)
 	bool padDown;
 	const auto pos = instance.get_left_down_mouse_info(&padDown);
 	io.MouseDown[0] = padDown != mainWindow && pos.has_value();
-
-	std::fill_n(io.KeysDown, std::size(io.KeysDown), false);
-	std::copy(std::cbegin(g_window_info.keydown), std::cend(g_window_info.keydown), io.KeysDown);
+	auto get_mapping = [&](uint32 key_code)
+	{
+		auto key = keyboard_mapping.find(key_code);
+		if (key != keyboard_mapping.end())
+			return key->second;
+		ImGuiKey mapped_key = (ImGuiKey)((uint32)current_key + ImGuiKey_NamedKey_BEGIN);
+		current_key = (current_key + 1) % (uint32)ImGuiKey_NamedKey_COUNT;
+		keyboard_mapping[key_code] = mapped_key;
+		return mapped_key;
+	};
+	g_window_info.iter_keystates([&](auto&& el){ io.AddKeyEvent(get_mapping(el.first), el.second); });
 
 	// printf("%f %f %d\n", io.MousePos.x, io.MousePos.y, io.MouseDown[0]);
 
diff --git a/src/imgui/imgui_extension.h b/src/imgui/imgui_extension.h
index cbc35e69..ef2ee342 100644
--- a/src/imgui/imgui_extension.h
+++ b/src/imgui/imgui_extension.h
@@ -9,6 +9,9 @@ inline ImVec2 operator-(const ImVec2& l, const ImVec2& r) { return{ l.x - r.x, l
 inline bool operator<(const ImVec2& lhs, const ImVec2& rhs) { return lhs.x < rhs.x; }
 inline bool operator>=(const ImVec2& lhs, const ImVec2& rhs) { return lhs.x >= rhs.x; }
 
+bool ImGui_BeginPadDistinct(const char* name, bool* p_open, ImGuiWindowFlags flags, bool pad);
+
 void ImGui_PrecacheFonts();
+void ImGui_ClearFonts();
 ImFont* ImGui_GetFont(float size);
 void ImGui_UpdateWindowInformation(bool mainWindow);
\ No newline at end of file
diff --git a/src/imgui/imgui_impl_vulkan.cpp b/src/imgui/imgui_impl_vulkan.cpp
index 89f94e64..f9a23166 100644
--- a/src/imgui/imgui_impl_vulkan.cpp
+++ b/src/imgui/imgui_impl_vulkan.cpp
@@ -97,7 +97,7 @@ void ImGui_ImplVulkanH_DestroyFrame(VkDevice device, ImGui_ImplVulkanH_Frame* fd
 void ImGui_ImplVulkanH_DestroyFrameSemaphores(VkDevice device, ImGui_ImplVulkanH_FrameSemaphores* fsd, const VkAllocationCallbacks* allocator);
 void ImGui_ImplVulkanH_DestroyFrameRenderBuffers(VkDevice device, ImGui_ImplVulkanH_FrameRenderBuffers* buffers, const VkAllocationCallbacks* allocator);
 void ImGui_ImplVulkanH_DestroyWindowRenderBuffers(VkDevice device, ImGui_ImplVulkanH_WindowRenderBuffers* buffers, const VkAllocationCallbacks* allocator);
-void ImGui_ImplVulkanH_CreateWindowSwapChain(VkPhysicalDevice physical_device, VkDevice device, ImGui_ImplVulkanH_Window* wd, const VkAllocationCallbacks* allocator, int w, int h, uint32_t min_image_count);
+void ImGui_ImplVulkanH_CreateWindowSwapchain(VkPhysicalDevice physical_device, VkDevice device, ImGui_ImplVulkanH_Window* wd, const VkAllocationCallbacks* allocator, int w, int h, uint32_t min_image_count);
 void ImGui_ImplVulkanH_CreateWindowCommandBuffers(VkPhysicalDevice physical_device, VkDevice device, ImGui_ImplVulkanH_Window* wd, uint32_t queue_family, const VkAllocationCallbacks* allocator);
 
 struct ImGuiTexture
@@ -245,18 +245,13 @@ static void check_vk_result(VkResult err)
 
 static void CreateOrResizeBuffer(VkBuffer& buffer, VkDeviceMemory& buffer_memory, VkDeviceSize& p_buffer_size, size_t new_size, VkBufferUsageFlagBits usage)
 {
-	VulkanRenderer* vkRenderer = VulkanRenderer::GetInstance();
-
-    ImGui_ImplVulkan_InitInfo* v = &g_VulkanInitInfo;
+	ImGui_ImplVulkan_InitInfo* v = &g_VulkanInitInfo;
+	vkDeviceWaitIdle(v->Device); // make sure previously created buffer is not in use anymore
     VkResult err;
 	if (buffer != VK_NULL_HANDLE)
-	{
-		vkRenderer->destroyBuffer(buffer);
-	}
+		vkDestroyBuffer(v->Device, buffer, v->Allocator);
 	if (buffer_memory != VK_NULL_HANDLE)
-	{
-		vkRenderer->destroyDeviceMemory(buffer_memory);
-	}
+		vkFreeMemory(v->Device, buffer_memory, v->Allocator);
     VkDeviceSize vertex_buffer_size_aligned = ((new_size - 1) / g_BufferMemoryAlignment + 1) * g_BufferMemoryAlignment;
     VkBufferCreateInfo buffer_info = {};
     buffer_info.sType = VK_STRUCTURE_TYPE_BUFFER_CREATE_INFO;
@@ -470,6 +465,15 @@ void ImGui_ImplVulkan_DestroyFontsTexture()
 	if (g_FontView)             { vkDestroyImageView(v->Device, g_FontView, v->Allocator); g_FontView = VK_NULL_HANDLE; }
     if (g_FontImage)            { vkDestroyImage(v->Device, g_FontImage, v->Allocator); g_FontImage = VK_NULL_HANDLE; }
     if (g_FontMemory)           { vkFreeMemory(v->Device, g_FontMemory, v->Allocator); g_FontMemory = VK_NULL_HANDLE; }
+
+	ImGuiIO& io = ImGui::GetIO();
+	auto texture = io.Fonts->TexID;
+	if(texture != (ImTextureID)nullptr)
+	{
+		ImGui_ImplVulkan_DeleteTexture(texture);
+		delete (ImGuiTexture*)texture;
+		io.Fonts->TexID = nullptr;
+	}
 }
 
 bool ImGui_ImplVulkan_CreateFontsTexture(VkCommandBuffer command_buffer)
@@ -912,7 +916,7 @@ void ImGui_ImplVulkan_Shutdown()
     ImGui_ImplVulkan_DestroyDeviceObjects();
 }
 
-void ImGui_ImplVulkan_NewFrame(VkCommandBuffer command_buffer, VkFramebuffer framebuffer, VkExtent2D& extend)
+void ImGui_ImplVulkan_NewFrame(VkCommandBuffer command_buffer, VkFramebuffer framebuffer, VkExtent2D extent)
 {
 	auto& io = ImGui::GetIO();
 
@@ -921,7 +925,7 @@ void ImGui_ImplVulkan_NewFrame(VkCommandBuffer command_buffer, VkFramebuffer fra
 	renderPassInfo.renderPass = g_RenderPass;
 	renderPassInfo.framebuffer = framebuffer;
 	renderPassInfo.renderArea.offset = {0, 0};
-	renderPassInfo.renderArea.extent = extend;
+	renderPassInfo.renderArea.extent = extent;
 	renderPassInfo.clearValueCount = 0;
 	vkCmdBeginRenderPass(command_buffer, &renderPassInfo, VK_SUBPASS_CONTENTS_INLINE);
 }
@@ -1082,7 +1086,7 @@ int ImGui_ImplVulkanH_GetMinImageCountFromPresentMode(VkPresentModeKHR present_m
 }
 
 // Also destroy old swap chain and in-flight frames data, if any.
-void ImGui_ImplVulkanH_CreateWindowSwapChain(VkPhysicalDevice physical_device, VkDevice device, ImGui_ImplVulkanH_Window* wd, const VkAllocationCallbacks* allocator, int w, int h, uint32_t min_image_count)
+void ImGui_ImplVulkanH_CreateWindowSwapchain(VkPhysicalDevice physical_device, VkDevice device, ImGui_ImplVulkanH_Window* wd, const VkAllocationCallbacks* allocator, int w, int h, uint32_t min_image_count)
 {
     VkResult err;
     VkSwapchainKHR old_swapchain = wd->Swapchain;
@@ -1245,7 +1249,7 @@ void ImGui_ImplVulkanH_CreateWindowSwapChain(VkPhysicalDevice physical_device, V
 void ImGui_ImplVulkanH_CreateWindow(VkInstance instance, VkPhysicalDevice physical_device, VkDevice device, ImGui_ImplVulkanH_Window* wd, uint32_t queue_family, const VkAllocationCallbacks* allocator, int width, int height, uint32_t min_image_count)
 {
     (void)instance;
-    ImGui_ImplVulkanH_CreateWindowSwapChain(physical_device, device, wd, allocator, width, height, min_image_count);
+	ImGui_ImplVulkanH_CreateWindowSwapchain(physical_device, device, wd, allocator, width, height, min_image_count);
     ImGui_ImplVulkanH_CreateWindowCommandBuffers(physical_device, device, wd, queue_family, allocator);
 }
 
@@ -1460,7 +1464,7 @@ ImTextureID ImGui_ImplVulkan_GenerateTexture(VkCommandBuffer commandBuffer, cons
     }
     catch (const std::exception & ex)
     {
-        forceLog_printf("can't generate imgui texture: %s", ex.what());
+        cemuLog_log(LogType::Force, "can't generate imgui texture: {}", ex.what());
         return nullptr;
     }
 }
diff --git a/src/imgui/imgui_impl_vulkan.h b/src/imgui/imgui_impl_vulkan.h
index c4af49c5..44bcdd50 100644
--- a/src/imgui/imgui_impl_vulkan.h
+++ b/src/imgui/imgui_impl_vulkan.h
@@ -46,7 +46,7 @@ struct ImGui_ImplVulkan_InitInfo
 // Called by user code
 IMGUI_IMPL_API bool     ImGui_ImplVulkan_Init(ImGui_ImplVulkan_InitInfo* info, VkRenderPass render_pass);
 IMGUI_IMPL_API void     ImGui_ImplVulkan_Shutdown();
-IMGUI_IMPL_API void     ImGui_ImplVulkan_NewFrame(VkCommandBuffer command_buffer, VkFramebuffer framebuffer, VkExtent2D& extend);
+IMGUI_IMPL_API void     ImGui_ImplVulkan_NewFrame(VkCommandBuffer command_buffer, VkFramebuffer framebuffer, VkExtent2D extent);
 IMGUI_IMPL_API void     ImGui_ImplVulkan_RenderDrawData(ImDrawData* draw_data, VkCommandBuffer command_buffer);
 IMGUI_IMPL_API bool     ImGui_ImplVulkan_CreateFontsTexture(VkCommandBuffer command_buffer);
 IMGUI_IMPL_API void     ImGui_ImplVulkan_DestroyFontsTexture();
diff --git a/src/input/CMakeLists.txt b/src/input/CMakeLists.txt
index 47609385..af8b8181 100644
--- a/src/input/CMakeLists.txt
+++ b/src/input/CMakeLists.txt
@@ -1,5 +1,3 @@
-project(CemuInput)
-
 add_library(CemuInput
 	InputManager.cpp
 	InputManager.h
@@ -11,6 +9,24 @@ add_library(CemuInput
 	api/ControllerState.cpp
 	api/InputAPI.h
 	api/ControllerProvider.h
+	api/DSU/DSUController.h
+	api/DSU/DSUControllerProvider.cpp
+	api/DSU/DSUController.cpp
+	api/DSU/DSUControllerProvider.h
+	api/DSU/DSUMessages.h
+	api/DSU/DSUMessages.cpp
+	api/SDL/SDLController.cpp
+	api/SDL/SDLControllerProvider.cpp
+	api/SDL/SDLController.h
+	api/SDL/SDLControllerProvider.h
+	api/Keyboard/KeyboardControllerProvider.h
+	api/Keyboard/KeyboardControllerProvider.cpp
+	api/Keyboard/KeyboardController.cpp
+	api/Keyboard/KeyboardController.h
+	api/GameCube/GameCubeController.cpp
+	api/GameCube/GameCubeControllerProvider.h
+	api/GameCube/GameCubeControllerProvider.cpp
+	api/GameCube/GameCubeController.h
 	emulated/ProController.cpp
 	emulated/EmulatedController.h
 	emulated/EmulatedController.cpp
@@ -27,53 +43,7 @@ add_library(CemuInput
 
 set_property(TARGET CemuInput PROPERTY MSVC_RUNTIME_LIBRARY "MultiThreaded$<$<CONFIG:Debug>:Debug>")
 
-# SDL
-target_sources(CemuInput PRIVATE
-	api/SDL/SDLController.cpp
-	api/SDL/SDLControllerProvider.cpp
-	api/SDL/SDLController.h
-	api/SDL/SDLControllerProvider.h
-)
-
-# DSU
-target_sources(CemuInput PRIVATE
-	api/DSU/DSUController.h
-	api/DSU/DSUControllerProvider.cpp
-	api/DSU/DSUController.cpp
-	api/DSU/DSUControllerProvider.h
-	api/DSU/DSUMessages.h
-	api/DSU/DSUMessages.cpp
-)
-
-# Keyboard controller
-target_sources(CemuInput PRIVATE
-	api/Keyboard/KeyboardControllerProvider.h
-	api/Keyboard/KeyboardControllerProvider.cpp
-	api/Keyboard/KeyboardController.cpp
-	api/Keyboard/KeyboardController.h
-)
-
-# Native gamecube
-target_sources(CemuInput PRIVATE
-	api/GameCube/GameCubeController.cpp
-	api/GameCube/GameCubeControllerProvider.h
-	api/GameCube/GameCubeControllerProvider.cpp
-	api/GameCube/GameCubeController.h
-)
-
 if(WIN32)
-	# Native wiimote (Win32 only for now)
-	target_sources(CemuInput PRIVATE
-		api/Wiimote/WiimoteControllerProvider.h
-		api/Wiimote/windows/WinWiimoteDevice.cpp
-		api/Wiimote/windows/WinWiimoteDevice.h
-		api/Wiimote/WiimoteControllerProvider.cpp
-		api/Wiimote/WiimoteMessages.h
-		api/Wiimote/NativeWiimoteController.h
-		api/Wiimote/NativeWiimoteController.cpp
-		api/Wiimote/WiimoteDevice.h
-	)
-
 	# XInput
 	target_sources(CemuInput PRIVATE
 		api/XInput/XInputControllerProvider.cpp
@@ -91,6 +61,30 @@ if(WIN32)
 	)
 endif()
 
+if (SUPPORTS_WIIMOTE)
+	target_compile_definitions(CemuInput PUBLIC SUPPORTS_WIIMOTE)
+	target_sources(CemuInput PRIVATE
+			api/Wiimote/WiimoteControllerProvider.h
+			api/Wiimote/WiimoteControllerProvider.cpp
+			api/Wiimote/WiimoteMessages.h
+			api/Wiimote/NativeWiimoteController.h
+			api/Wiimote/NativeWiimoteController.cpp
+			api/Wiimote/WiimoteDevice.h
+	)
+	if (ENABLE_HIDAPI)
+		target_sources(CemuInput PRIVATE
+				api/Wiimote/hidapi/HidapiWiimote.cpp
+				api/Wiimote/hidapi/HidapiWiimote.h)
+	endif ()
+
+	if (ENABLE_BLUEZ)
+		target_sources(CemuInput PRIVATE
+				api/Wiimote/l2cap/L2CapWiimote.cpp
+				api/Wiimote/l2cap/L2CapWiimote.h)
+	endif()
+endif ()
+
+
 target_include_directories(CemuInput PUBLIC "../")
 
 target_link_libraries(CemuInput PRIVATE
@@ -106,6 +100,14 @@ target_link_libraries(CemuInput PRIVATE
 	SDL2::SDL2
 )
 
+if (ENABLE_HIDAPI)
+	target_link_libraries(CemuInput PRIVATE hidapi::hidapi)
+endif()
+
 if (ENABLE_WXWIDGETS)
 	target_link_libraries(CemuInput PRIVATE wx::base wx::core)
 endif()
+
+if (ENABLE_BLUEZ)
+	target_link_libraries(CemuInput PRIVATE bluez::bluez)
+endif ()
\ No newline at end of file
diff --git a/src/input/ControllerFactory.cpp b/src/input/ControllerFactory.cpp
index 0facdee0..70a85a2d 100644
--- a/src/input/ControllerFactory.cpp
+++ b/src/input/ControllerFactory.cpp
@@ -159,7 +159,7 @@ ControllerProviderPtr ControllerFactory::CreateControllerProvider(InputAPI::Type
 			}
 			catch (const std::bad_cast&)
 			{
-				cemuLog_force("failing to cast ControllerProviderSettings class to DSUControllerProvider");
+				cemuLog_log(LogType::Force, "failing to cast ControllerProviderSettings class to DSUControllerProvider");
 				return std::make_shared<DSUControllerProvider>();
 			}
 		}
diff --git a/src/input/InputManager.cpp b/src/input/InputManager.cpp
index 4ae43ce3..64b238fc 100644
--- a/src/input/InputManager.cpp
+++ b/src/input/InputManager.cpp
@@ -21,7 +21,7 @@ InputManager::InputManager()
 		}
 		catch (const std::exception& ex)
 		{
-			cemuLog_force(ex.what());
+			cemuLog_log(LogType::Force, ex.what());
 		}
 	}
 	*/
@@ -67,7 +67,7 @@ void InputManager::load() noexcept
 		}
 		catch (const std::exception& ex)
 		{
-			cemuLog_force("can't load controller profile: {}", ex.what());
+			cemuLog_log(LogType::Force, "can't load controller profile: {}", ex.what());
 		}
 	}
 }
@@ -76,9 +76,9 @@ bool InputManager::load(size_t player_index, std::string_view filename)
 {
 	fs::path file_path;
 	if (filename.empty())
-		file_path = ActiveSettings::GetPath(fmt::format("controllerProfiles/controller{}", player_index));
+		file_path = ActiveSettings::GetConfigPath("controllerProfiles/controller{}", player_index);
 	else
-		file_path = ActiveSettings::GetPath(fmt::format("controllerProfiles/{}", filename));
+		file_path = ActiveSettings::GetConfigPath("controllerProfiles/{}", filename);
 
 	auto old_file = file_path;
 	old_file.replace_extension(".txt"); // test .txt extension
@@ -92,12 +92,12 @@ bool InputManager::load(size_t player_index, std::string_view filename)
 
 	try
 	{
-		std::ifstream file(file_path);
-		if (!file.is_open())
+		auto xmlData = FileStream::LoadIntoMemory(file_path);
+		if (!xmlData || xmlData->empty())
 			return false;
-
+	
 		pugi::xml_document doc;
-		if (!doc.load(file))
+		if (!doc.load_buffer(xmlData->data(), xmlData->size()))
 			return false;
 
 		const pugi::xml_node root = doc.document_element();
@@ -198,7 +198,7 @@ bool InputManager::load(size_t player_index, std::string_view filename)
 			}
 			catch (const std::exception& ex)
 			{
-				cemuLog_force("can't load controller: {}", ex.what());
+				cemuLog_log(LogType::Force, "can't load controller: {}", ex.what());
 			}
 		}
 
@@ -207,7 +207,7 @@ bool InputManager::load(size_t player_index, std::string_view filename)
 	}
 	catch (const std::exception& ex)
 	{
-		cemuLog_force("can't load config file: {}", ex.what());
+		cemuLog_log(LogType::Force, "can't load config file: {}", ex.what());
 		return false;
 	}
 }
@@ -216,12 +216,15 @@ bool InputManager::migrate_config(const fs::path& file_path)
 {
 	try
 	{
-		std::ifstream file(file_path);
-		if (!file.is_open())
+		auto xmlData = FileStream::LoadIntoMemory(file_path);
+		if (!xmlData || xmlData->empty())
 			return false;
 
+		std::string iniDataStr((const char*)xmlData->data(), xmlData->size());
+
+		std::stringstream iniData(iniDataStr);
 		boost::property_tree::ptree m_data;
-		read_ini(file, m_data);
+		read_ini(iniData, m_data);
 
 		const auto emulate_string = m_data.get<std::string>("General.emulate");
 		const auto api_string = m_data.get<std::string>("General.api");
@@ -417,7 +420,7 @@ bool InputManager::migrate_config(const fs::path& file_path)
 	}
 	catch (const std::exception& ex)
 	{
-		cemuLog_force("can't migrate config file {}: {}", file_path.string(), ex.what());
+		cemuLog_log(LogType::Force, "can't migrate config file {}: {}", file_path.string(), ex.what());
 	}
 
 	return false;
@@ -433,7 +436,7 @@ void InputManager::save() noexcept
 		}
 		catch (const std::exception& ex)
 		{
-			cemuLog_force("can't save controller profile: {}", ex.what());
+			cemuLog_log(LogType::Force, "can't save controller profile: {}", ex.what());
 		}
 	}
 }
@@ -448,14 +451,14 @@ bool InputManager::save(size_t player_index, std::string_view filename)
 	if (!emulated_controller)
 		return false;
 
-	fs::path file_path = ActiveSettings::GetPath("controllerProfiles");
+	fs::path file_path = ActiveSettings::GetConfigPath("controllerProfiles");
 	fs::create_directories(file_path);
 
 	const auto is_default_file = filename.empty();
 	if (is_default_file)
 		file_path /= fmt::format("controller{}", player_index);
 	else
-		file_path /= filename;
+		file_path /= _utf8ToPath(filename);
 
 	file_path.replace_extension(".xml"); // force .xml extension
 
@@ -469,15 +472,12 @@ bool InputManager::save(size_t player_index, std::string_view filename)
 		emulated_controller->type_string()
 	}.c_str());
 
+	if(!is_default_file)
+		emulated_controller->m_profile_name = std::string{filename};
+
 	if (emulated_controller->has_profile_name())
 		emulated_controller_node.append_child("profile").append_child(pugi::node_pcdata).set_value(
 			emulated_controller->get_profile_name().c_str());
-	else if (!is_default_file)
-	{
-		emulated_controller->m_profile_name = std::string{filename};
-		emulated_controller_node.append_child("profile").append_child(pugi::node_pcdata).set_value(
-			emulated_controller->get_profile_name().c_str());
-	}
 
 	// custom settings
 	emulated_controller->save(emulated_controller_node);
@@ -540,15 +540,15 @@ bool InputManager::save(size_t player_index, std::string_view filename)
 			}
 		}
 	}
-
-
-	std::ofstream file(file_path, std::ios::out | std::ios::trunc);
-	if (file.is_open())
-	{
-		doc.save(file);
-		return true;
-	}
-	return false;
+	FileStream* fs = FileStream::createFile2(file_path);
+	if (!fs)
+		return false;
+	std::stringstream xmlData;
+	doc.save(xmlData);
+	std::string xmlStr = xmlData.str();
+	fs->writeData(xmlStr.data(), xmlStr.size());
+	delete fs;
+	return true;
 }
 
 bool InputManager::is_gameprofile_set(size_t player_index) const
@@ -617,7 +617,7 @@ EmulatedControllerPtr InputManager::set_controller(size_t player_index, Emulated
 	}
 	catch (const std::exception& ex)
 	{
-		cemuLog_force("Unable to set controller type {} on player index {}: {}", type, player_index, ex.what());
+		cemuLog_log(LogType::Force, "Unable to set controller type {} on player index {}: {}", type, player_index, ex.what());
 	}
 
 	return {};
@@ -664,8 +664,8 @@ EmulatedControllerPtr InputManager::delete_controller(size_t player_index, bool
 			if(delete_profile)
 			{
 				std::error_code ec{};
-				fs::remove(ActiveSettings::GetPath(fmt::format("controllerProfiles/controller{}.xml", player_index)), ec);
-				fs::remove(ActiveSettings::GetPath(fmt::format("controllerProfiles/controller{}.txt", player_index)), ec);
+				fs::remove(ActiveSettings::GetConfigPath("controllerProfiles/controller{}.xml", player_index), ec);
+				fs::remove(ActiveSettings::GetConfigPath("controllerProfiles/controller{}.txt", player_index), ec);
 			}
 
 			return result;
@@ -680,8 +680,8 @@ EmulatedControllerPtr InputManager::delete_controller(size_t player_index, bool
 			controller = {};
 
 			std::error_code ec{};
-			fs::remove(ActiveSettings::GetPath(fmt::format("controllerProfiles/controller{}.xml", player_index)), ec);
-			fs::remove(ActiveSettings::GetPath(fmt::format("controllerProfiles/controller{}.txt", player_index)), ec);
+			fs::remove(ActiveSettings::GetConfigPath("controllerProfiles/controller{}.xml", player_index), ec);
+			fs::remove(ActiveSettings::GetConfigPath("controllerProfiles/controller{}.txt", player_index), ec);
 
 			return result;
 		}
@@ -782,7 +782,7 @@ void InputManager::apply_game_profile()
 
 std::vector<std::string> InputManager::get_profiles()
 {
-	const auto path = ActiveSettings::GetPath("controllerProfiles");
+	const auto path = ActiveSettings::GetConfigPath("controllerProfiles");
 	if (!exists(path))
 		return {};
 
@@ -792,7 +792,7 @@ std::vector<std::string> InputManager::get_profiles()
 		const auto& p = entry.path();
 		if (p.has_extension() && (p.extension() == ".xml" || p.extension() == ".txt"))
 		{
-			auto stem = p.filename().stem().string();
+			auto stem = _pathToUtf8(p.filename().stem());
 			if (is_valid_profilename(stem))
 			{
 				tmp.emplace(stem);
@@ -808,7 +808,7 @@ std::vector<std::string> InputManager::get_profiles()
 
 bool InputManager::is_valid_profilename(const std::string& name)
 {
-	if (!boost::filesystem::windows_name(name))
+	if (!IsValidFilename(name))
 		return false;
 
 	// dont allow default profile names
@@ -931,7 +931,7 @@ std::optional<glm::ivec2> InputManager::get_right_down_mouse_info(bool* is_pad)
 
 void InputManager::update_thread()
 {
-	SetThreadName("InputManager::update_thread");
+	SetThreadName("Input_update");
 	while (!m_update_thread_shutdown.load(std::memory_order::relaxed))
 	{
 		std::shared_lock lock(m_mutex);
diff --git a/src/input/InputManager.h b/src/input/InputManager.h
index 2af2b283..715d8f2e 100644
--- a/src/input/InputManager.h
+++ b/src/input/InputManager.h
@@ -3,6 +3,9 @@
 #if BOOST_OS_WINDOWS
 #include "input/api/DirectInput/DirectInputControllerProvider.h"
 #include "input/api/XInput/XInputControllerProvider.h"
+#endif
+
+#ifdef SUPPORTS_WIIMOTE
 #include "input/api/Wiimote/WiimoteControllerProvider.h"
 #endif
 
@@ -114,7 +117,7 @@ private:
 		}
 		catch (const std::exception& ex)
 		{
-			cemuLog_force(ex.what());
+			cemuLog_log(LogType::Force, ex.what());
 		}
 	}
 };
diff --git a/src/input/api/Controller.cpp b/src/input/api/Controller.cpp
index 0027392b..b7831def 100644
--- a/src/input/api/Controller.cpp
+++ b/src/input/api/Controller.cpp
@@ -15,8 +15,7 @@ const ControllerState& ControllerBase::update_state()
 	ControllerState result = raw_state();
 
 	// ignore default buttons
-	result.buttons &= ~m_default_state.buttons;
-
+	result.buttons.UnsetButtons(m_default_state.buttons);
 	// apply deadzone and range and ignore default axis values
 	apply_axis_setting(result.axis, m_default_state.axis, m_settings.axis);
 	apply_axis_setting(result.rotation, m_default_state.rotation, m_settings.rotation);
@@ -24,22 +23,22 @@ const ControllerState& ControllerBase::update_state()
 
 #define APPLY_AXIS_BUTTON(_axis_, _flag_) \
 	if (result._axis_.x < -ControllerState::kAxisThreshold) \
-		result.buttons.set((_flag_) + (kAxisXN - kAxisXP)); \
+		result.buttons.SetButtonState((_flag_) + (kAxisXN - kAxisXP), true); \
 	else if (result._axis_.x > ControllerState::kAxisThreshold) \
-		result.buttons.set((_flag_)); \
+		result.buttons.SetButtonState((_flag_), true); \
 	if (result._axis_.y < -ControllerState::kAxisThreshold) \
-		result.buttons.set((_flag_) + 1 + (kAxisXN - kAxisXP)); \
+		result.buttons.SetButtonState((_flag_) + 1 + (kAxisXN - kAxisXP), true); \
 	else if (result._axis_.y > ControllerState::kAxisThreshold) \
-		result.buttons.set((_flag_) + 1);
+		result.buttons.SetButtonState((_flag_) + 1, true);
 
 	if (result.axis.x < -ControllerState::kAxisThreshold) 
-		result.buttons.set((kAxisXP) + (kAxisXN - kAxisXP));
+		result.buttons.SetButtonState((kAxisXP) + (kAxisXN - kAxisXP), true);
 	else if (result.axis.x > ControllerState::kAxisThreshold) 
-		result.buttons.set((kAxisXP));
+		result.buttons.SetButtonState((kAxisXP), true);
 	if (result.axis.y < -ControllerState::kAxisThreshold) 
-		result.buttons.set((kAxisXP) + 1 + (kAxisXN - kAxisXP));
+		result.buttons.SetButtonState((kAxisXP) + 1 + (kAxisXN - kAxisXP), true);
 	else if (result.axis.y > ControllerState::kAxisThreshold) 
-		result.buttons.set((kAxisXP) + 1);;
+		result.buttons.SetButtonState((kAxisXP) + 1, true);
 	APPLY_AXIS_BUTTON(rotation, kRotationXP);
 	APPLY_AXIS_BUTTON(trigger, kTriggerXP);
 
@@ -68,7 +67,7 @@ const ControllerState& ControllerBase::update_state()
 
 #undef APPLY_AXIS_BUTTON
 
-	m_last_state = result;
+	m_last_state = std::move(result);
 	return m_last_state;
 }
 
@@ -127,7 +126,7 @@ bool ControllerBase::operator==(const ControllerBase& c) const
 
 float ControllerBase::get_axis_value(uint64 button) const
 {
-	if (m_last_state.buttons.test(button))
+	if (m_last_state.buttons.GetButtonState(button))
 	{
 		if (button <= kButtonNoneAxisMAX || !has_axis())
 			return 1.0f;
diff --git a/src/input/api/Controller.h b/src/input/api/Controller.h
index 29b01f28..e2475191 100644
--- a/src/input/api/Controller.h
+++ b/src/input/api/Controller.h
@@ -2,6 +2,7 @@
 
 #include "input/InputManager.h"
 #include "input/motion/MotionSample.h"
+#include "input/api/ControllerState.h"
 
 namespace pugi
 {
@@ -118,6 +119,7 @@ public:
 	virtual bool has_position() { return false; }
 	virtual glm::vec2 get_position() { return {}; }
 	virtual glm::vec2 get_prev_position() { return {}; }
+	virtual PositionVisibility GetPositionVisibility() {return PositionVisibility::NONE;};
 
 	virtual bool has_rumble() { return false; }
 	virtual void start_rumble() {}
@@ -189,7 +191,7 @@ public:
 	// update provider if settings are different from default provider
 	void update_provider(std::shared_ptr<TProvider> provider)
 	{
-		m_provider = provider;
+		m_provider = std::move(provider);
 	}
 
 protected:
diff --git a/src/input/api/ControllerState.h b/src/input/api/ControllerState.h
index 2739b2ef..65bfec9f 100644
--- a/src/input/api/ControllerState.h
+++ b/src/input/api/ControllerState.h
@@ -1,7 +1,122 @@
 #pragma once
 
-#include <bitset>
 #include <glm/vec2.hpp>
+#include "util/helpers/fspinlock.h"
+
+enum class PositionVisibility {
+	NONE = 0,
+	FULL = 1,
+	PARTIAL = 2
+};
+
+// helper class for storing and managing button press states in a thread-safe manner
+struct ControllerButtonState
+{
+	ControllerButtonState() = default;
+	ControllerButtonState(const ControllerButtonState& other)
+	{
+		this->m_pressedButtons = other.m_pressedButtons;
+	}
+
+	ControllerButtonState(ControllerButtonState&& other)
+	{
+		this->m_pressedButtons = std::move(other.m_pressedButtons);
+	}
+
+	void SetButtonState(uint32 buttonId, bool isPressed)
+	{
+		std::lock_guard _l(this->m_spinlock);
+		if (isPressed)
+		{
+			if (std::find(m_pressedButtons.cbegin(), m_pressedButtons.cend(), buttonId) != m_pressedButtons.end())
+				return;
+			m_pressedButtons.emplace_back(buttonId);
+		}
+		else
+		{
+			std::erase(m_pressedButtons, buttonId);
+		}
+	}
+
+	// set multiple buttons at once within a single lock interval
+	void SetPressedButtons(std::span<uint32> buttonList)
+	{
+		std::lock_guard _l(this->m_spinlock);
+		for (auto& buttonId : buttonList)
+		{
+			if (std::find(m_pressedButtons.cbegin(), m_pressedButtons.cend(), buttonId) == m_pressedButtons.end())
+				m_pressedButtons.emplace_back(buttonId);
+		}
+	}
+
+	// returns true if pressed
+	bool GetButtonState(uint32 buttonId) const
+	{
+		std::lock_guard _l(this->m_spinlock);
+		bool r = std::find(m_pressedButtons.cbegin(), m_pressedButtons.cend(), buttonId) != m_pressedButtons.cend();
+		return r;
+	}
+
+	// remove pressed state for all pressed buttons in buttonsToUnset
+	void UnsetButtons(const ControllerButtonState& buttonsToUnset)
+	{
+		std::scoped_lock _l(this->m_spinlock, buttonsToUnset.m_spinlock);
+		for (auto it = m_pressedButtons.begin(); it != m_pressedButtons.end();)
+		{
+			if (std::find(buttonsToUnset.m_pressedButtons.cbegin(), buttonsToUnset.m_pressedButtons.cend(), *it) == buttonsToUnset.m_pressedButtons.cend())
+			{
+				++it;
+				continue;
+			}
+			it = m_pressedButtons.erase(it);
+		}
+	}
+
+	// returns true if no buttons are pressed
+	bool IsIdle() const
+	{
+		std::lock_guard _l(this->m_spinlock);
+		const bool r = m_pressedButtons.empty();
+		return r;
+	}
+
+	std::vector<uint32> GetButtonList() const
+	{
+		std::lock_guard _l(this->m_spinlock);
+		std::vector<uint32> copy = m_pressedButtons;
+		return copy;
+	}
+
+	bool operator==(const ControllerButtonState& other) const
+	{
+		std::scoped_lock _l(this->m_spinlock, other.m_spinlock);
+		auto& otherButtons = other.m_pressedButtons;
+		if (m_pressedButtons.size() != otherButtons.size())
+		{
+			return false;
+		}
+		for (auto& buttonId : m_pressedButtons)
+		{
+			if (std::find(otherButtons.cbegin(), otherButtons.cend(), buttonId) == otherButtons.cend())
+			{
+				return false;
+			}
+		}
+		return true;
+	}
+
+	ControllerButtonState& operator=(ControllerButtonState&& other)
+	{
+		cemu_assert_debug(!other.m_spinlock.is_locked());
+		std::scoped_lock _l(this->m_spinlock, other.m_spinlock);
+		this->m_pressedButtons = std::move(other.m_pressedButtons);
+		return *this;
+	}
+
+private:
+	std::vector<uint32> m_pressedButtons; // since only very few buttons are pressed at a time, using a vector with linear scan is more efficient than a set/map
+	mutable FSpinlock m_spinlock;
+};
 
 struct ControllerState
 {
@@ -18,7 +133,7 @@ struct ControllerState
 	glm::vec2 rotation{ };
 	glm::vec2 trigger{ };
 
-	std::bitset<256> buttons{};
+	ControllerButtonState buttons{};
 
 	uint64 last_state = 0;
 
diff --git a/src/input/api/DSU/DSUController.cpp b/src/input/api/DSU/DSUController.cpp
index 1a961a4a..082f7e39 100644
--- a/src/input/api/DSU/DSUController.cpp
+++ b/src/input/api/DSU/DSUController.cpp
@@ -93,6 +93,13 @@ glm::vec2 DSUController::get_prev_position()
 	return {};
 }
 
+PositionVisibility DSUController::GetPositionVisibility()
+{
+	const auto state = m_provider->get_prev_state(m_index);
+
+	return (state.data.tpad1.active || state.data.tpad2.active) ? PositionVisibility::FULL : PositionVisibility::NONE;
+}
+
 std::string DSUController::get_button_name(uint64 button) const
 {
 	switch (button)
@@ -137,7 +144,7 @@ ControllerState DSUController::raw_state()
 	{
 		if (HAS_BIT(state.data.state1, i))
 		{
-			result.buttons.set(bitindex);
+			result.buttons.SetButtonState(bitindex, true);
 		}
 	}
 
@@ -145,12 +152,12 @@ ControllerState DSUController::raw_state()
 	{
 		if (HAS_BIT(state.data.state2, i))
 		{
-			result.buttons.set(bitindex);
+			result.buttons.SetButtonState(bitindex, true);
 		}
 	}
 
 	if (state.data.touch)
-		result.buttons.set(kButton16);
+		result.buttons.SetButtonState(kButton16, true);
 
 	result.axis.x = (float)state.data.lx / std::numeric_limits<uint8>::max();
 	result.axis.x = (result.axis.x * 2.0f) - 1.0f;
diff --git a/src/input/api/DSU/DSUController.h b/src/input/api/DSU/DSUController.h
index 801f609c..e6e2936d 100644
--- a/src/input/api/DSU/DSUController.h
+++ b/src/input/api/DSU/DSUController.h
@@ -32,6 +32,7 @@ public:
 	bool has_position() override;
 	glm::vec2 get_position() override;
 	glm::vec2 get_prev_position() override;
+	PositionVisibility GetPositionVisibility() override;
 
 	std::string get_button_name(uint64 button) const override;
 
diff --git a/src/input/api/DSU/DSUControllerProvider.cpp b/src/input/api/DSU/DSUControllerProvider.cpp
index 345e249f..fa00277c 100644
--- a/src/input/api/DSU/DSUControllerProvider.cpp
+++ b/src/input/api/DSU/DSUControllerProvider.cpp
@@ -78,8 +78,7 @@ bool DSUControllerProvider::connect()
 		using namespace boost::asio;
 
 		ip::udp::resolver resolver(m_io_service);
-		const ip::udp::resolver::query query(ip::udp::v4(), get_settings().ip, fmt::format("{}", get_settings().port));
-		m_receiver_endpoint = *resolver.resolve(query);
+		m_receiver_endpoint = *resolver.resolve(get_settings().ip, fmt::format("{}", get_settings().port)).cbegin();
 
 		if (m_socket.is_open())
 			m_socket.close();
@@ -102,7 +101,7 @@ bool DSUControllerProvider::connect()
 	}
 	catch (const std::exception& ex)
 	{
-		forceLog_printf("dsu client connect error: %s", ex.what());
+		cemuLog_log(LogType::Force, "dsu client connect error: {}", ex.what());
 		return false;
 	}
 }
@@ -249,7 +248,7 @@ MotionSample DSUControllerProvider::get_motion_sample(uint8_t index) const
 
 void DSUControllerProvider::reader_thread()
 {
-	SetThreadName("DSUControllerProvider::reader_thread");
+	SetThreadName("DSU-reader");
 	bool first_read = true;
 	while (m_running.load(std::memory_order_relaxed))
 	{
@@ -263,7 +262,7 @@ void DSUControllerProvider::reader_thread()
 		if (ec)
 		{
 #ifdef DEBUG_DSU_CLIENT
-				printf(" DSUControllerProvider::ReaderThread: exception %s\n", ex.what());
+				printf(" DSUControllerProvider::ReaderThread: exception %s\n", ec.what());
 #endif
 
 			// there's probably no server listening on the given address:port
@@ -382,7 +381,7 @@ void DSUControllerProvider::reader_thread()
 
 void DSUControllerProvider::writer_thread()
 {
-	SetThreadName("DSUControllerProvider::writer_thread");
+	SetThreadName("DSU-writer");
 	while (m_running.load(std::memory_order_relaxed))
 	{
 		std::unique_lock lock(m_writer_mutex);
@@ -406,10 +405,10 @@ void DSUControllerProvider::writer_thread()
 		{
 			m_socket.send_to(boost::asio::buffer(msg.get(), msg->GetSize()), m_receiver_endpoint);
 		}
-		catch (const std::exception&)
+		catch (const std::exception& ec)
 		{
 #ifdef DEBUG_DSU_CLIENT
-			printf(" DSUControllerProvider::WriterThread: exception %s\n", ex.what());
+			printf(" DSUControllerProvider::WriterThread: exception %s\n", ec.what());
 #endif
 			std::this_thread::sleep_for(std::chrono::milliseconds(250));
 		}
diff --git a/src/input/api/DSU/DSUControllerProvider.h b/src/input/api/DSU/DSUControllerProvider.h
index dfa4d7b8..692da619 100644
--- a/src/input/api/DSU/DSUControllerProvider.h
+++ b/src/input/api/DSU/DSUControllerProvider.h
@@ -102,7 +102,7 @@ private:
 	std::condition_variable m_writer_cond;
 
 	uint32 m_uid;
-	boost::asio::io_service m_io_service;
+	boost::asio::io_context m_io_service;
 	boost::asio::ip::udp::endpoint m_receiver_endpoint;
 	boost::asio::ip::udp::socket m_socket;
 
diff --git a/src/input/api/DSU/DSUMessages.cpp b/src/input/api/DSU/DSUMessages.cpp
index d0ea61af..34065add 100644
--- a/src/input/api/DSU/DSUMessages.cpp
+++ b/src/input/api/DSU/DSUMessages.cpp
@@ -1,6 +1,5 @@
 #include "input/api/DSU/DSUMessages.h"
-
-#include <boost/crc.hpp>
+#include "util/crypto/crc32.h"
 
 constexpr uint32_t kMagicClient = 'CUSD';
 constexpr uint32_t kMagicServer = 'SUSD';
@@ -17,15 +16,14 @@ void MessageHeader::Finalize(size_t size)
 
 uint32_t MessageHeader::CRC32(size_t size) const
 {
-	const auto tmp = m_crc32;
+	uint32_t tmp, tmp2;
+
+	tmp = m_crc32;
 	m_crc32 = 0;
-
-	boost::crc_32_type crc;
-	crc.process_bytes(this, size);
-	const auto result = crc.checksum();
-
+	tmp2 = crc32_calc(this, size);
 	m_crc32 = tmp;
-	return result;
+
+	return tmp2;
 }
 
 bool MessageHeader::IsClientMessage() const { return m_magic == kMagicClient; }
diff --git a/src/input/api/DirectInput/DirectInputController.cpp b/src/input/api/DirectInput/DirectInputController.cpp
index 9db551ed..234696b6 100644
--- a/src/input/api/DirectInput/DirectInputController.cpp
+++ b/src/input/api/DirectInput/DirectInputController.cpp
@@ -15,9 +15,6 @@ DirectInputController::DirectInputController(const GUID& guid, std::string_view
 
 DirectInputController::~DirectInputController()
 {
-	if (m_effect)
-		m_effect->Release();
-	
 	if (m_device)
 	{
 		m_device->Unacquire();
@@ -39,8 +36,8 @@ DirectInputController::~DirectInputController()
 		if (kGameCubeController == m_product_guid)
 			should_release_device = false;
 
-		if (should_release_device)
-			m_device->Release();
+		if (!should_release_device)
+			m_device.Detach();
 	}
 }
 
@@ -104,7 +101,6 @@ bool DirectInputController::connect()
 	// set data format
 	if (FAILED(m_device->SetDataFormat(m_provider->get_data_format())))
 	{
-		SAFE_RELEASE(m_device);
 		return false;
 	}
 
@@ -115,7 +111,6 @@ bool DirectInputController::connect()
 	{
 		if (FAILED(m_device->SetCooperativeLevel(hwndMainWindow, DISCL_BACKGROUND | DISCL_NONEXCLUSIVE)))
 		{
-			SAFE_RELEASE(m_device);
 			return false;
 		}
 		// rumble can only be used with exclusive access
@@ -245,7 +240,6 @@ ControllerState DirectInputController::raw_state()
 	ControllerState result{};
 	if (!is_connected())
 		return result;
-
 	HRESULT hr = m_device->Poll();
 	if (FAILED(hr))
 	{
@@ -277,9 +271,7 @@ ControllerState DirectInputController::raw_state()
 	for (size_t i = 0; i < std::size(state.rgbButtons); ++i)
 	{
 		if (HAS_BIT(state.rgbButtons[i], 7))
-		{
-			result.buttons.set(i);
-		}
+			result.buttons.SetButtonState(i, true);
 	}
 	
 	// axis
@@ -316,19 +308,19 @@ ControllerState DirectInputController::raw_state()
 	{
 		switch (pov)
 		{
-		case 0: result.buttons.set(kButtonUp);
+		case 0: result.buttons.SetButtonState(kButtonUp, true);
 			break;
-		case 4500: result.buttons.set(kButtonUp); // up + right
-		case 9000: result.buttons.set(kButtonRight);
+		case 4500: result.buttons.SetButtonState(kButtonUp, true); // up + right
+		case 9000: result.buttons.SetButtonState(kButtonRight, true);
 			break;
-		case 13500: result.buttons.set(kButtonRight); // right + down
-		case 18000: result.buttons.set(kButtonDown);
+		case 13500: result.buttons.SetButtonState(kButtonRight, true); // right + down
+		case 18000: result.buttons.SetButtonState(kButtonDown, true);
 			break;
-		case 22500: result.buttons.set(kButtonDown); // down + left
-		case 27000: result.buttons.set(kButtonLeft);
+		case 22500: result.buttons.SetButtonState(kButtonDown, true); // down + left
+		case 27000: result.buttons.SetButtonState(kButtonLeft, true);
 			break;
-		case 31500: result.buttons.set(kButtonLeft);; // left + up
-		result.buttons.set(kButtonUp); // left + up
+		case 31500: result.buttons.SetButtonState(kButtonLeft, true); // left + up
+					result.buttons.SetButtonState(kButtonUp, true); // left + up
 			break;
 		}
 	}
diff --git a/src/input/api/DirectInput/DirectInputController.h b/src/input/api/DirectInput/DirectInputController.h
index 2ec371a2..d2c3dba2 100644
--- a/src/input/api/DirectInput/DirectInputController.h
+++ b/src/input/api/DirectInput/DirectInputController.h
@@ -2,6 +2,7 @@
 
 #include "input/api/DirectInput/DirectInputControllerProvider.h"
 #include "input/api/Controller.h"
+#include <wrl/client.h>
 
 class DirectInputController : public Controller<DirectInputControllerProvider>
 {
@@ -41,9 +42,9 @@ private:
 	GUID m_product_guid{};
 
 	std::shared_mutex m_mutex;
-	LPDIRECTINPUTDEVICE8 m_device = nullptr;
-	LPDIRECTINPUTEFFECT m_effect = nullptr;
+	Microsoft::WRL::ComPtr<IDirectInputDevice8> m_device;
+	Microsoft::WRL::ComPtr<IDirectInputEffect> m_effect;
 
 	std::array<LONG, 6> m_min_axis{};
 	std::array<LONG, 6> m_max_axis{};
-};
\ No newline at end of file
+};
diff --git a/src/input/api/DirectInput/DirectInputControllerProvider.cpp b/src/input/api/DirectInput/DirectInputControllerProvider.cpp
index 063cb779..79f31354 100644
--- a/src/input/api/DirectInput/DirectInputControllerProvider.cpp
+++ b/src/input/api/DirectInput/DirectInputControllerProvider.cpp
@@ -19,7 +19,7 @@ DirectInputControllerProvider::DirectInputControllerProvider()
 		
 
 	const auto r = DirectInput8Create(GetModuleHandle(nullptr), DIRECTINPUT_VERSION, IID_IDirectInput8, (void**)&m_dinput8, nullptr);
-	if (FAILED(r) || !m_dinput8)
+	if (FAILED(r))
 	{
 		const auto error = GetLastError();
 		//FreeLibrary(m_module);
@@ -29,9 +29,6 @@ DirectInputControllerProvider::DirectInputControllerProvider()
 
 DirectInputControllerProvider::~DirectInputControllerProvider()
 {
-	if (m_dinput8)
-		m_dinput8->Release();
-	
 	/*if (m_module)
 		FreeLibrary(m_module);
 	*/
diff --git a/src/input/api/DirectInput/DirectInputControllerProvider.h b/src/input/api/DirectInput/DirectInputControllerProvider.h
index 5db883c0..de8c3216 100644
--- a/src/input/api/DirectInput/DirectInputControllerProvider.h
+++ b/src/input/api/DirectInput/DirectInputControllerProvider.h
@@ -4,6 +4,7 @@
 #define DIRECTINPUT_VERSION 0x0800
 
 #include <dinput.h>
+#include <wrl/client.h>
 
 #include "input/api/ControllerProvider.h"
 
@@ -22,7 +23,7 @@ public:
 
 	std::vector<std::shared_ptr<ControllerBase>> get_controllers() override;
 
-	IDirectInput8* get_dinput() const { return m_dinput8; }
+	IDirectInput8* get_dinput() const { return m_dinput8.Get(); }
 	LPCDIDATAFORMAT get_data_format() const;
 
 private:
@@ -31,7 +32,7 @@ private:
 	decltype(&DirectInput8Create) m_DirectInput8Create;
 	decltype(&GetdfDIJoystick) m_GetdfDIJoystick = nullptr;
 
-	IDirectInput8* m_dinput8 = nullptr;
+	Microsoft::WRL::ComPtr<IDirectInput8> m_dinput8;
 };
 
-#endif
\ No newline at end of file
+#endif
diff --git a/src/input/api/GameCube/GameCubeControllerProvider.cpp b/src/input/api/GameCube/GameCubeControllerProvider.cpp
index 1fe339f4..f3a2f20d 100644
--- a/src/input/api/GameCube/GameCubeControllerProvider.cpp
+++ b/src/input/api/GameCube/GameCubeControllerProvider.cpp
@@ -86,7 +86,7 @@ uint32 GameCubeControllerProvider::get_adapter_count() const
 	const auto count = m_libusb->p_libusb_get_device_list(nullptr, &devices);
 	if (count < 0)
 	{
-		forceLog_printf((char*)fmt::format("libusb error {} at libusb_get_device_list: {}", static_cast<int>(count), m_libusb->p_libusb_error_name(static_cast<int>(count))).c_str());
+		cemuLog_log(LogType::Force, "libusb error {} at libusb_get_device_list: {}", static_cast<int>(count), m_libusb->p_libusb_error_name(static_cast<int>(count)));
 		return adapter_count;
 	}
 
@@ -99,7 +99,7 @@ uint32 GameCubeControllerProvider::get_adapter_count() const
 		int ret = m_libusb->p_libusb_get_device_descriptor(devices[i], &desc);
 		if (ret != 0)
 		{
-			forceLog_printf((char*)fmt::format("libusb error {} at libusb_get_device_descriptor: {}", ret, m_libusb->p_libusb_error_name(ret)).c_str());
+			cemuLog_log(LogType::Force, "libusb error {} at libusb_get_device_descriptor: {}", ret, m_libusb->p_libusb_error_name(ret));
 			continue;
 		}
 
@@ -168,7 +168,7 @@ std::tuple<libusb_device_handle*, uint8, uint8> GameCubeControllerProvider::fetc
 	const auto count = m_libusb->p_libusb_get_device_list(nullptr, &devices);
 	if (count < 0)
 	{
-		forceLog_printf((char*)fmt::format("libusb error {} at libusb_get_device_list: {}", static_cast<int>(count), m_libusb->p_libusb_error_name(static_cast<int>(count))).c_str());
+		cemuLog_log(LogType::Force, "libusb error {} at libusb_get_device_list: {}", static_cast<int>(count), m_libusb->p_libusb_error_name(static_cast<int>(count)));
 		return result;
 	}
 
@@ -182,7 +182,7 @@ std::tuple<libusb_device_handle*, uint8, uint8> GameCubeControllerProvider::fetc
 		int ret = m_libusb->p_libusb_get_device_descriptor(devices[i], &desc);
 		if (ret != 0)
 		{
-			forceLog_printf((char*)fmt::format("libusb error {} at libusb_get_device_descriptor: {}", ret, m_libusb->p_libusb_error_name(ret)).c_str());
+			cemuLog_log(LogType::Force, "libusb error {} at libusb_get_device_descriptor: {}", ret, m_libusb->p_libusb_error_name(ret));
 			continue;
 		}
 
@@ -196,7 +196,7 @@ std::tuple<libusb_device_handle*, uint8, uint8> GameCubeControllerProvider::fetc
 		ret = m_libusb->p_libusb_open(devices[i], &device_handle);
 		if (ret != 0)
 		{
-			forceLog_printf((char*)fmt::format("libusb error {} at libusb_open: {}", ret, m_libusb->p_libusb_error_name(ret)).c_str());
+			cemuLog_log(LogType::Force, "libusb error {} at libusb_open: {}", ret, m_libusb->p_libusb_error_name(ret));
 			continue;
 		}
 
@@ -205,7 +205,7 @@ std::tuple<libusb_device_handle*, uint8, uint8> GameCubeControllerProvider::fetc
 			ret = m_libusb->p_libusb_detach_kernel_driver(device_handle, 0);
 			if (ret != 0)
 			{
-				forceLog_printf((char*)fmt::format("libusb error {} at libusb_detach_kernel_driver: {}", ret, m_libusb->p_libusb_error_name(ret)).c_str());
+				cemuLog_log(LogType::Force, "libusb error {} at libusb_detach_kernel_driver: {}", ret, m_libusb->p_libusb_error_name(ret));
 				m_libusb->p_libusb_close(device_handle);
 				continue;
 			}
@@ -214,7 +214,7 @@ std::tuple<libusb_device_handle*, uint8, uint8> GameCubeControllerProvider::fetc
 		ret = m_libusb->p_libusb_claim_interface(device_handle, 0);
 		if (ret != 0)
 		{
-			forceLog_printf((char*)fmt::format("libusb error {} at libusb_claim_interface: {}", ret, m_libusb->p_libusb_error_name(ret)).c_str());
+			cemuLog_log(LogType::Force, "libusb error {} at libusb_claim_interface: {}", ret, m_libusb->p_libusb_error_name(ret));
 			m_libusb->p_libusb_close(device_handle);
 			continue;
 		}
@@ -297,11 +297,11 @@ void GameCubeControllerProvider::reader_thread()
 			}
 			else if (result == LIBUSB_ERROR_NO_DEVICE || result == LIBUSB_ERROR_IO)
 			{
-				forceLog_printf((char*)fmt::format("libusb error {} at libusb_interrupt_transfer: {}", result, m_libusb->p_libusb_error_name(result)).c_str());
+				cemuLog_log(LogType::Force, "libusb error {} at libusb_interrupt_transfer: {}", result, m_libusb->p_libusb_error_name(result));
 				if (const auto handle = adapter.m_device_handle.exchange(nullptr))
 					m_libusb->p_libusb_close(handle);
 			}
-			else { forceLog_printf((char*)fmt::format("libusb error {} at libusb_interrupt_transfer: {}", result, m_libusb->p_libusb_error_name(result)).c_str()); }
+			else { cemuLog_log(LogType::Force, "libusb error {} at libusb_interrupt_transfer: {}", result, m_libusb->p_libusb_error_name(result)); }
 		}
 	}
 }
@@ -341,7 +341,7 @@ void GameCubeControllerProvider::writer_thread()
 
 			int written;
 			const int result = m_libusb->p_libusb_interrupt_transfer(adapter.m_device_handle, adapter.m_endpoint_writer, rumble.data(), static_cast<int>(rumble.size()), &written, 25);
-			if (result != 0) { forceLog_printf((char*)fmt::format("libusb error {} at libusb_interrupt_transfer: {}", result, m_libusb->p_libusb_error_name(result)).c_str()); }
+			if (result != 0) { cemuLog_log(LogType::Force, "libusb error {} at libusb_interrupt_transfer: {}", result, m_libusb->p_libusb_error_name(result)); }
 			cmd_sent = true;
 
 			lock.lock();
@@ -385,4 +385,4 @@ int GameCubeControllerProvider::hotplug_event(libusb_context* ctx, libusb_device
 	return 0;
 }
 
-#endif
\ No newline at end of file
+#endif
diff --git a/src/input/api/Keyboard/KeyboardController.cpp b/src/input/api/Keyboard/KeyboardController.cpp
index d8bc0a04..1f5458fa 100644
--- a/src/input/api/Keyboard/KeyboardController.cpp
+++ b/src/input/api/Keyboard/KeyboardController.cpp
@@ -1,5 +1,6 @@
-#include "input/api/Keyboard/KeyboardController.h"
+#include <boost/container/small_vector.hpp>
 
+#include "input/api/Keyboard/KeyboardController.h"
 #include "gui/guiWrapper.h"
 
 KeyboardController::KeyboardController()
@@ -35,9 +36,13 @@ std::string KeyboardController::get_button_name(uint64 button) const
 	char key_name[128];
 	if (GetKeyNameTextA(scan_code, key_name, std::size(key_name)) != 0)
 		return key_name;
-#endif
-	
+	else
+		return fmt::format("key_{}", button);
+#elif BOOST_OS_LINUX
+	return gui_gtkRawKeyCodeToString(button);
+#else
 	return fmt::format("key_{}", button);
+#endif
 }
 
 extern WindowInfo g_window_info;
@@ -45,22 +50,8 @@ extern WindowInfo g_window_info;
 ControllerState KeyboardController::raw_state()
 {
 	ControllerState result{};
-	if (g_window_info.app_active)
-	{
-		static_assert(result.buttons.size() == std::size(g_window_info.keydown), "invalid size");
-		for (uint32 i = wxKeyCode::WXK_BACK; i < result.buttons.size(); ++i)
-		{
-			if(const bool v = g_window_info.keydown[i])
-			{
-				result.buttons.set(i, v);
-			}
-		}
-		// ignore generic key codes on Windows when there is also a left/right variant
-#if BOOST_OS_WINDOWS
-		result.buttons.set(VK_SHIFT, false);
-		result.buttons.set(VK_CONTROL, false);
-		result.buttons.set(VK_MENU, false);
-#endif
-	}
+	boost::container::small_vector<uint32, 16> pressedKeys;
+	g_window_info.iter_keystates([&pressedKeys](const std::pair<const uint32, bool>& keyState) { if (keyState.second) pressedKeys.emplace_back(keyState.first); });
+	result.buttons.SetPressedButtons(pressedKeys);
 	return result;
 }
diff --git a/src/input/api/SDL/SDLController.cpp b/src/input/api/SDL/SDLController.cpp
index 0a0e3067..57971ecc 100644
--- a/src/input/api/SDL/SDLController.cpp
+++ b/src/input/api/SDL/SDLController.cpp
@@ -58,13 +58,9 @@ bool SDLController::connect()
 	if (m_diid == -1)
 		return false;
 
-	m_controller = SDL_GameControllerFromInstanceID(m_diid);
+	m_controller = SDL_GameControllerOpen(index);
 	if (!m_controller)
-	{
-		m_controller = SDL_GameControllerOpen(index);
-		if (!m_controller)
-			return false;
-	}
+		return false;
 
 	if (const char* name = SDL_GameControllerName(m_controller))
 		m_display_name = name;
@@ -146,9 +142,7 @@ ControllerState SDLController::raw_state()
 	for (int i = 0; i < SDL_CONTROLLER_BUTTON_MAX; ++i)
 	{
 		if (m_buttons[i] && SDL_GameControllerGetButton(m_controller, (SDL_GameControllerButton)i))
-		{
-			result.buttons.set(i);
-		}
+			result.buttons.SetButtonState(i, true);
 	}
 
 	if (m_axis[SDL_CONTROLLER_AXIS_LEFTX])
diff --git a/src/input/api/SDL/SDLControllerProvider.cpp b/src/input/api/SDL/SDLControllerProvider.cpp
index c700eab7..9b21b306 100644
--- a/src/input/api/SDL/SDLControllerProvider.cpp
+++ b/src/input/api/SDL/SDLControllerProvider.cpp
@@ -32,11 +32,11 @@ SDLControllerProvider::SDLControllerProvider()
 	SDL_SetHint(SDL_HINT_JOYSTICK_HIDAPI_LUNA, "1");
 
 	if (SDL_Init(SDL_INIT_JOYSTICK | SDL_INIT_GAMECONTROLLER | SDL_INIT_HAPTIC | SDL_INIT_EVENTS) < 0) 
-		throw std::runtime_error(fmt::format("couldn't initialize SDL: %s", SDL_GetError()));
+		throw std::runtime_error(fmt::format("couldn't initialize SDL: {}", SDL_GetError()));
 		
 
 	if (SDL_GameControllerEventState(SDL_ENABLE) < 0) {
-		forceLog_printf("Couldn't enable SDL gamecontroller event polling: %s", SDL_GetError());
+		cemuLog_log(LogType::Force, "Couldn't enable SDL gamecontroller event polling: {}", SDL_GetError());
 	}
 
 	m_running = true;
@@ -124,7 +124,7 @@ MotionSample SDLControllerProvider::motion_sample(int diid)
 
 void SDLControllerProvider::event_thread()
 {
-	SetThreadName("SDLControllerProvider::event_thread");
+	SetThreadName("SDL_events");
 	while (m_running.load(std::memory_order_relaxed))
 	{
 		SDL_Event event{};
diff --git a/src/input/api/Wiimote/NativeWiimoteController.cpp b/src/input/api/Wiimote/NativeWiimoteController.cpp
index 1396f1b4..9aa56d9c 100644
--- a/src/input/api/Wiimote/NativeWiimoteController.cpp
+++ b/src/input/api/Wiimote/NativeWiimoteController.cpp
@@ -98,6 +98,11 @@ glm::vec2 NativeWiimoteController::get_prev_position()
 	const auto state = m_provider->get_state(m_index);
 	return state.ir_camera.m_prev_position;
 }
+PositionVisibility NativeWiimoteController::GetPositionVisibility()
+{
+	const auto state = m_provider->get_state(m_index);
+	return state.ir_camera.m_positionVisibility;
+}
 
 bool NativeWiimoteController::has_low_battery()
 {
@@ -206,24 +211,30 @@ ControllerState NativeWiimoteController::raw_state()
 		return result;
 
 	const auto state = m_provider->get_state(m_index);
-	result.buttons = state.buttons;
+	for (int i = 0; i < std::numeric_limits<uint16>::digits; i++)
+		result.buttons.SetButtonState(i, (state.buttons & (1 << i)) != 0);
 
 	if (std::holds_alternative<NunchuckData>(state.m_extension))
 	{
 		const auto nunchuck = std::get<NunchuckData>(state.m_extension);
 		if (nunchuck.c)
-			result.buttons.set(kWiimoteButton_C);
+			result.buttons.SetButtonState(kWiimoteButton_C, true);
 
 		if (nunchuck.z)
-			result.buttons.set(kWiimoteButton_Z);
+			result.buttons.SetButtonState(kWiimoteButton_Z, true);
 
 		result.axis = nunchuck.axis;
 	}
 	else if (std::holds_alternative<ClassicData>(state.m_extension))
 	{
 		const auto classic = std::get<ClassicData>(state.m_extension);
-		result.buttons |= (uint64)classic.buttons << kHighestWiimote;
-
+		uint64 buttons = (uint64)classic.buttons << kHighestWiimote;
+		for (int i = 0; i < std::numeric_limits<uint64>::digits; i++)
+		{
+			// OR with base buttons
+			if((buttons & (1 << i)))
+				result.buttons.SetButtonState(i, true);
+		}
 		result.axis = classic.left_axis;
 		result.rotation = classic.right_axis;
 		result.trigger = classic.trigger;
diff --git a/src/input/api/Wiimote/NativeWiimoteController.h b/src/input/api/Wiimote/NativeWiimoteController.h
index ed3caa08..8e9c0774 100644
--- a/src/input/api/Wiimote/NativeWiimoteController.h
+++ b/src/input/api/Wiimote/NativeWiimoteController.h
@@ -40,6 +40,7 @@ public:
 	bool has_position() override;
 	glm::vec2 get_position() override;
 	glm::vec2 get_prev_position() override;
+	PositionVisibility GetPositionVisibility() override;
 	
 	bool has_motion() override { return true; }
 	bool has_rumble() override { return true; }
diff --git a/src/input/api/Wiimote/WiimoteControllerProvider.cpp b/src/input/api/Wiimote/WiimoteControllerProvider.cpp
index a742a9d3..c2454319 100644
--- a/src/input/api/Wiimote/WiimoteControllerProvider.cpp
+++ b/src/input/api/Wiimote/WiimoteControllerProvider.cpp
@@ -2,17 +2,22 @@
 #include "input/api/Wiimote/NativeWiimoteController.h"
 #include "input/api/Wiimote/WiimoteMessages.h"
 
-#if BOOST_OS_WINDOWS
-#include "input/api/Wiimote/windows/WinWiimoteDevice.h"
+#ifdef HAS_HIDAPI
+#include "input/api/Wiimote/hidapi/HidapiWiimote.h"
+#endif
+#ifdef HAS_BLUEZ
+#include "input/api/Wiimote/l2cap/L2CapWiimote.h"
 #endif
 
 #include <numbers>
+#include <queue>
 
 WiimoteControllerProvider::WiimoteControllerProvider()
 	: m_running(true)
 {
 	m_reader_thread = std::thread(&WiimoteControllerProvider::reader_thread, this);
 	m_writer_thread = std::thread(&WiimoteControllerProvider::writer_thread, this);
+	m_connectionThread = std::thread(&WiimoteControllerProvider::connectionThread, this);
 }
 
 WiimoteControllerProvider::~WiimoteControllerProvider()
@@ -22,29 +27,51 @@ WiimoteControllerProvider::~WiimoteControllerProvider()
 		m_running = false;
 		m_writer_thread.join();
 		m_reader_thread.join();
+		m_connectionThread.join();
 	}
 }
 
 std::vector<std::shared_ptr<ControllerBase>> WiimoteControllerProvider::get_controllers()
 {
+	m_connectedDeviceMutex.lock();
+	auto devices = m_connectedDevices;
+	m_connectedDeviceMutex.unlock();
+
 	std::scoped_lock lock(m_device_mutex);
-	for (const auto& device : WiimoteDevice_t::get_devices())
+
+	for (auto& device : devices)
 	{
-		// test connection of all devices as they might have been changed
-		const bool is_connected = device->write_data({kStatusRequest, 0x00});
-		if (is_connected)
+		const auto writeable = device->write_data({kStatusRequest, 0x00});
+        if (!writeable)
+            continue;
+
+		bool isDuplicate = false;
+		ssize_t lowestReplaceableIndex = -1;
+		for (ssize_t i = m_wiimotes.size() - 1; i >= 0; --i)
 		{
-			// only add unknown, connected devices to our list
-			const bool is_new_device = std::none_of(m_wiimotes.cbegin(), m_wiimotes.cend(),
-			                                        [&device](const auto& it) { return *it.device == *device; });
-			if (is_new_device)
+			const auto& wiimoteDevice = m_wiimotes[i].device;
+			if (wiimoteDevice)
 			{
-				m_wiimotes.push_back(std::make_unique<Wiimote>(device));
+				if (*wiimoteDevice == *device)
+				{
+					isDuplicate = true;
+					break;
+				}
+				continue;
 			}
+
+			lowestReplaceableIndex = i;
 		}
+		if (isDuplicate)
+			continue;
+		if (lowestReplaceableIndex != -1)
+			m_wiimotes.replace(lowestReplaceableIndex, std::make_unique<Wiimote>(device));
+		else
+			m_wiimotes.push_back(std::make_unique<Wiimote>(device));
 	}
 
 	std::vector<std::shared_ptr<ControllerBase>> result;
+	result.reserve(m_wiimotes.size());
 	for (size_t i = 0; i < m_wiimotes.size(); ++i)
 	{
 		result.emplace_back(std::make_shared<NativeWiimoteController>(i));
@@ -56,7 +83,7 @@ std::vector<std::shared_ptr<ControllerBase>> WiimoteControllerProvider::get_cont
 bool WiimoteControllerProvider::is_connected(size_t index)
 {
 	std::shared_lock lock(m_device_mutex);
-	return index < m_wiimotes.size() && m_wiimotes[index].connected;
+	return index < m_wiimotes.size() && m_wiimotes[index].device;
 }
 
 bool WiimoteControllerProvider::is_registered_device(size_t index)
@@ -123,14 +150,38 @@ WiimoteControllerProvider::WiimoteState WiimoteControllerProvider::get_state(siz
 	return {};
 }
 
+void WiimoteControllerProvider::connectionThread()
+{
+	SetThreadName("Wiimote-connect");
+	while (m_running.load(std::memory_order_relaxed))
+	{
+		std::vector<WiimoteDevicePtr> devices;
+#ifdef HAS_HIDAPI
+		const auto& hidDevices = HidapiWiimote::get_devices();
+		std::ranges::move(hidDevices, std::back_inserter(devices));
+#endif
+#ifdef HAS_BLUEZ
+		const auto& l2capDevices = L2CapWiimote::get_devices();
+		std::ranges::move(l2capDevices, std::back_inserter(devices));
+#endif
+		{
+			std::scoped_lock lock(m_connectedDeviceMutex);
+			m_connectedDevices.clear();
+			std::ranges::move(devices, std::back_inserter(m_connectedDevices));
+		}
+		std::this_thread::sleep_for(std::chrono::seconds(2));
+	}
+}
+
+
 void WiimoteControllerProvider::reader_thread()
 {
-	SetThreadName("WiimoteControllerProvider::reader_thread");
+	SetThreadName("Wiimote-reader");
 	std::chrono::steady_clock::time_point lastCheck = {};
 	while (m_running.load(std::memory_order_relaxed))
 	{
 		const auto now = std::chrono::steady_clock::now();
-		if (std::chrono::duration_cast<std::chrono::seconds>(now - lastCheck) > std::chrono::seconds(2))
+		if (std::chrono::duration_cast<std::chrono::seconds>(now - lastCheck) > std::chrono::milliseconds(500))
 		{
 			// check for new connected wiimotes
 			get_controllers();
@@ -142,11 +193,16 @@ void WiimoteControllerProvider::reader_thread()
 		for (size_t index = 0; index < m_wiimotes.size(); ++index)
 		{
 			auto& wiimote = m_wiimotes[index];
-			if (!wiimote.connected)
+			if (!wiimote.device)
 				continue;
 
 			const auto read_data = wiimote.device->read_data();
-			if (!read_data || read_data->empty())
+			if (!read_data)
+			{
+				wiimote.device.reset();
+				continue;
+			}
+			if (read_data->empty())
 				continue;
 			receivedAnyPacket = true;
 
@@ -163,9 +219,7 @@ void WiimoteControllerProvider::reader_thread()
 			{
 			case kStatus:
 				{
-#ifdef WIIMOTE_DEBUG
-					printf("WiimoteControllerProvider::read_thread: kStatus\n");
-#endif
+                    cemuLog_logDebug(LogType::Force,"WiimoteControllerProvider::read_thread: kStatus");
 					new_state.buttons = (*(uint16*)data) & (~0x60E0);
 					data += 2;
 					new_state.flags = *data;
@@ -183,9 +237,7 @@ void WiimoteControllerProvider::reader_thread()
 
 					if (HAS_FLAG(new_state.flags, kExtensionConnected))
 					{
-#ifdef WIIMOTE_DEBUG
-						printf("\tExtension flag is set\n");
-#endif
+                        cemuLog_logDebug(LogType::Force,"Extension flag is set");
 						if(new_state.m_extension.index() == 0)
 							request_extension(index);
 					}
@@ -199,9 +251,7 @@ void WiimoteControllerProvider::reader_thread()
 				break;
 			case kRead:
 				{
-#ifdef WIIMOTE_DEBUG
-					printf("WiimoteControllerProvider::read_thread: kRead\n");
-#endif
+                    cemuLog_logDebug(LogType::Force,"WiimoteControllerProvider::read_thread: kRead");
 					new_state.buttons = (*(uint16*)data) & (~0x60E0);
 					data += 2;
 					const uint8 error_flag = *data & 0xF, size = (*data >> 4) + 1;
@@ -209,10 +259,9 @@ void WiimoteControllerProvider::reader_thread()
 
 					if (error_flag)
 					{
+
 						// 7 means that wiimote is already enabled or not available
-#ifdef WIIMOTE_DEBUG
-						printf("Received error on data read 0x%x\n", error_flag);
-#endif
+                        cemuLog_logDebug(LogType::Force,"Received error on data read {:#x}", error_flag);
 						continue;
 					}
 
@@ -220,9 +269,7 @@ void WiimoteControllerProvider::reader_thread()
 					data += 2;
 					if (address == (kRegisterCalibration & 0xFFFF))
 					{
-#ifdef WIIMOTE_DEBUG
-						printf("Calibration received\n");
-#endif
+                        cemuLog_logDebug(LogType::Force,"Calibration received");
 
 						cemu_assert(size == 8);
 
@@ -255,17 +302,10 @@ void WiimoteControllerProvider::reader_thread()
 					{
 						if (size == 0xf)
 						{
-#ifdef WIIMOTE_DEBUG
-							printf("Extension type received but no extension connected\n");
-#endif
+							cemuLog_logDebug(LogType::Force,"Extension type received but no extension connected");
 							continue;
 						}
 
-
-#ifdef WIIMOTE_DEBUG
-						printf("Extension type received\n");
-#endif
-
 						cemu_assert(size == 6);
 						auto be_type = *(betype<uint64>*)data;
 						data += 6; // 48
@@ -274,42 +314,39 @@ void WiimoteControllerProvider::reader_thread()
 						switch (be_type.value())
 						{
 						case kExtensionNunchuck:
-#ifdef WIIMOTE_DEBUG
-							printf("\tNunchuck\n");
-#endif
+                            cemuLog_logDebug(LogType::Force,"Extension Type Received: Nunchuck");
 							new_state.m_extension = NunchuckData{};
 							break;
 						case kExtensionClassic:
-#ifdef WIIMOTE_DEBUG
-							printf("\tClassic\n");
-#endif
+                            cemuLog_logDebug(LogType::Force,"Extension Type Received: Classic");
 							new_state.m_extension = ClassicData{};
 							break;
 						case kExtensionClassicPro:
-							break;
+                            cemuLog_logDebug(LogType::Force,"Extension Type Received: Classic Pro");
+							new_state.m_extension = ClassicData{};
+                            break;
 						case kExtensionGuitar:
-							break;
+                            cemuLog_logDebug(LogType::Force,"Extension Type Received: Guitar");
+                            break;
 						case kExtensionDrums:
-							break;
+                            cemuLog_logDebug(LogType::Force,"Extension Type Received: Drums");
+                            break;
 						case kExtensionBalanceBoard:
-							break;
+                            cemuLog_logDebug(LogType::Force,"Extension Type Received: Balance Board");
+                            break;
 						case kExtensionMotionPlus:
-							//m_motion_plus = true;
-#ifdef WIIMOTE_DEBUG
-							printf("\tMotion plus detected\n");
-#endif
+                            cemuLog_logDebug(LogType::Force,"Extension Type Received: MotionPlus");
 							set_motion_plus(index, true);
 							new_state.m_motion_plus = MotionPlusData{};
 							break;
 						case kExtensionPartialyInserted:
-#ifdef WIIMOTE_DEBUG
-							printf("\tExtension only partially inserted!\n");
-#endif
+                            cemuLog_logDebug(LogType::Force,"Extension only partially inserted");
 							new_state.m_extension = {};
 							request_status(index);
 							break;
 						default:
-							new_state.m_extension = {};
+                            cemuLog_logDebug(LogType::Force,"Unknown extension: {:#x}", be_type.value());
+                            new_state.m_extension = {};
 							break;
 						}
 
@@ -319,9 +356,7 @@ void WiimoteControllerProvider::reader_thread()
 					else if (address == (kRegisterExtensionCalibration & 0xFFFF))
 					{
 						cemu_assert(size == 0x10);
-#ifdef WIIMOTE_DEBUG
-						printf("Extension calibration received\n");
-#endif
+                        cemuLog_logDebug(LogType::Force,"Extension calibration received");
 						std::visit(
 							overloaded
 							{
@@ -337,9 +372,7 @@ void WiimoteControllerProvider::reader_thread()
 									std::array<uint8, 14> zero{};
 									if (memcmp(zero.data(), data, zero.size()) == 0)
 									{
-#ifdef WIIMOTE_DEBUG
-										printf("\tExtension calibration data is zero!\n");
-#endif
+                                        cemuLog_logDebug(LogType::Force,"Extension calibration data is zero");
 										return;
 									}
 
@@ -372,15 +405,23 @@ void WiimoteControllerProvider::reader_thread()
 					}
 					else
 					{
-#ifdef WIIMOTE_DEBUG
-						printf("Unhandled read data received\n");
-#endif
-						continue;
+                        cemuLog_logDebug(LogType::Force,"Unhandled read data received");
+                        continue;
 					}
 
 					update_report = true;
 				}
 				break;
+            case kAcknowledge:
+                {
+                    new_state.buttons = *(uint16*)data & (~0x60E0);
+                    data += 2;
+                    const auto report_id = *data++;
+                    const auto error = *data++;
+                    if (error)
+                        cemuLog_logDebug(LogType::Force, "Error {:#x} from output report {:#x}", error, report_id);
+                    break;
+                }
 			case kDataCore:
 				{
 					// 30 BB BB
@@ -476,10 +517,7 @@ void WiimoteControllerProvider::reader_thread()
 								orientation /= tmp;*/
 
 								mp.orientation = orientation;
-#ifdef WIIMOTE_DEBUG
-								printf("\tmp: %.2lf %.2lf %.2lf\n", mp.orientation.x, mp.orientation.y,
-								       mp.orientation.z);
-#endif
+                                cemuLog_logDebug(LogType::Force,"MotionPlus: {:.2f}, {:.2f} {:.2f}", mp.orientation.x, mp.orientation.y, mp.orientation.z);
 							},
 							[data](NunchuckData& nunchuck) mutable
 							{
@@ -553,12 +591,11 @@ void WiimoteControllerProvider::reader_thread()
 									zero3,
 									zero4
 								);
-#ifdef WIIMOTE_DEBUG
-								printf("\tn: %d,%d | %lf - %lf | %.2lf %.2lf %.2lf\n", nunchuck.z, nunchuck.c,
-								       nunchuck.axis.x, nunchuck.axis.y,
-								       RadToDeg(nunchuck.acceleration.x), RadToDeg(nunchuck.acceleration.y),
-								       RadToDeg(nunchuck.acceleration.z));
-#endif
+                                cemuLog_logDebug(LogType::Force,"Nunchuck: Z={}, C={} | {}, {} | {:.2f}, {:.2f}, {:.2f}",
+                                                 nunchuck.z, nunchuck.c,
+                                                 nunchuck.axis.x, nunchuck.axis.y,
+                                                 RadToDeg(nunchuck.acceleration.x), RadToDeg(nunchuck.acceleration.y),
+                                                 RadToDeg(nunchuck.acceleration.z));
 							},
 							[data](ClassicData& classic) mutable
 							{
@@ -592,11 +629,11 @@ void WiimoteControllerProvider::reader_thread()
 
 								classic.trigger = classic.raw_trigger;
 								classic.trigger /= 31.0f;
-#ifdef WIIMOTE_DEBUG
-								printf("\tc: %d | %lf - %lf | %lf - %lf | %lf - %lf\n", classic.buttons,
-								       classic.left_axis.x, classic.left_axis.y, classic.right_axis.x,
-								       classic.right_axis.y, classic.trigger.x, classic.trigger.y);
-#endif
+                                cemuLog_logDebug(LogType::Force,"Classic Controller: Buttons={:b} | {}, {} | {}, {} | {}, {}",
+                                                 classic.buttons, classic.left_axis.x, classic.left_axis.y,
+                                                 classic.right_axis.x, classic.right_axis.y, classic.trigger.x,
+                                                 classic.trigger.y);
+
 							}
 						}, new_state.m_extension);
 
@@ -609,9 +646,7 @@ void WiimoteControllerProvider::reader_thread()
 					break;
 				}
 			default:
-#ifdef WIIMOTE_DEBUG
-				printf("unhandled input packet id %d for wiimote\n", data[0]);
-#endif
+                cemuLog_logDebug(LogType::Force,"unhandled input packet id {} for wiimote {}", id, index);
 			}
 
 			// update motion data
@@ -694,7 +729,6 @@ void WiimoteControllerProvider::parse_acceleration(WiimoteState& wiimote_state,
 	tmp -= calib.zero;
 	acceleration = (wiimote_state.m_acceleration / tmp);
 
-	//printf("%d, %d, %d\n", (int)m_acceleration.x, (int)m_acceleration.y, (int)m_acceleration.z);
 	const float pi_2 = (float)std::numbers::pi / 2.0f;
 	wiimote_state.m_roll = std::atan2(acceleration.z, acceleration.x) - pi_2;
 }
@@ -713,7 +747,6 @@ void WiimoteControllerProvider::rotate_ir(WiimoteState& wiimote_state)
 		i++;
 		if (!dot.visible)
 			continue;
-		//printf("%d:\t%.02lf | %.02lf\n", i, dot.pos.x, dot.pos.y);
 		// move to center, rotate and move back
 		dot.pos -= 0.5f;
 		dot.pos.x = (dot.pos.x * cos) + (dot.pos.y * (-sin));
@@ -772,14 +805,20 @@ void WiimoteControllerProvider::calculate_ir_position(WiimoteState& wiimote_stat
 		ir.middle = ir.position;
 		ir.distance = glm::length(ir.dots[indices.first].pos - ir.dots[indices.second].pos);
 		ir.indices = indices;
+		ir.m_positionVisibility = PositionVisibility::FULL;
 	}
 	else if (ir.dots[indices.first].visible)
 	{
 		ir.position = ir.middle + (ir.dots[indices.first].pos - ir.prev_dots[indices.first].pos);
+		ir.m_positionVisibility = PositionVisibility::PARTIAL;
 	}
 	else if (ir.dots[indices.second].visible)
 	{
 		ir.position = ir.middle + (ir.dots[indices.second].pos - ir.prev_dots[indices.second].pos);
+		ir.m_positionVisibility = PositionVisibility::PARTIAL;
+	}
+	else {
+		ir.m_positionVisibility = PositionVisibility::NONE;
 	}
 }
 
@@ -884,7 +923,7 @@ void WiimoteControllerProvider::set_motion_plus(size_t index, bool state)
 
 void WiimoteControllerProvider::writer_thread()
 {
-	SetThreadName("WiimoteControllerProvider::writer_thread");
+	SetThreadName("Wiimote-writer");
 	while (m_running.load(std::memory_order_relaxed))
 	{
 		std::unique_lock writer_lock(m_writer_mutex);
@@ -921,18 +960,18 @@ void WiimoteControllerProvider::writer_thread()
 
 		if (index != (size_t)-1 && !data.empty())
 		{
-			if (m_wiimotes[index].rumble)
+			auto& wiimote = m_wiimotes[index];
+			if (!wiimote.device)
+				continue;
+			if (wiimote.rumble)
 				data[1] |= 1;
-
-			m_wiimotes[index].connected = m_wiimotes[index].device->write_data(data);
-			if (m_wiimotes[index].connected)
+			if (!wiimote.device->write_data(data))
 			{
-				m_wiimotes[index].data_ts = std::chrono::high_resolution_clock::now();
+				wiimote.device.reset();
+				wiimote.rumble = false;
 			}
 			else
-			{
-				m_wiimotes[index].rumble = false;
-			}
+				wiimote.data_ts = std::chrono::high_resolution_clock::now();
 		}
 		device_lock.unlock();
 
@@ -973,9 +1012,7 @@ void WiimoteControllerProvider::update_report_type(size_t index)
 	else
 		report_type = kDataCore;
 
-#ifdef WIIMOTE_DEBUG
-	printf("Setting report type to %d\n", report_type);
-#endif
+    cemuLog_logDebug(LogType::Force,"Setting report type to {}", report_type);
 	send_packet(index, {kType, 0x04, report_type});
 
 	state.ir_camera.mode = set_ir_camera(index, true);
diff --git a/src/input/api/Wiimote/WiimoteControllerProvider.h b/src/input/api/Wiimote/WiimoteControllerProvider.h
index 40fe878a..90f28d5c 100644
--- a/src/input/api/Wiimote/WiimoteControllerProvider.h
+++ b/src/input/api/Wiimote/WiimoteControllerProvider.h
@@ -5,6 +5,7 @@
 #include "input/api/Wiimote/WiimoteMessages.h"
 
 #include "input/api/ControllerProvider.h"
+#include "input/api/ControllerState.h"
 
 #include <list>
 #include <variant>
@@ -61,6 +62,7 @@ public:
 			std::array<IRDot, 4> dots{}, prev_dots{};
 
 			glm::vec2 position{}, m_prev_position{};
+			PositionVisibility m_positionVisibility;
 			glm::vec2 middle {};
 			float distance = 0;
 			std::pair<sint32, sint32> indices{ 0,1 };
@@ -75,16 +77,17 @@ public:
 private:
 	std::atomic_bool m_running = false;
 	std::thread m_reader_thread, m_writer_thread;
-
 	std::shared_mutex m_device_mutex;
 
+	std::thread m_connectionThread;
+	std::vector<WiimoteDevicePtr> m_connectedDevices;
+	std::mutex m_connectedDeviceMutex;
 	struct Wiimote
 	{
 		Wiimote(WiimoteDevicePtr device)
 			: device(std::move(device)) {}
 
 		WiimoteDevicePtr device;
-		std::atomic_bool connected = true;
 		std::atomic_bool rumble = false;
 
 		std::shared_mutex mutex;
@@ -101,6 +104,7 @@ private:
 
 	void reader_thread();
 	void writer_thread();
+	void connectionThread();
 
 	void calibrate(size_t index);
 	IRMode set_ir_camera(size_t index, bool state);
diff --git a/src/input/api/Wiimote/WiimoteDevice.h b/src/input/api/Wiimote/WiimoteDevice.h
index 7938bbdf..8ea5b321 100644
--- a/src/input/api/Wiimote/WiimoteDevice.h
+++ b/src/input/api/Wiimote/WiimoteDevice.h
@@ -9,8 +9,7 @@ public:
 	virtual bool write_data(const std::vector<uint8>& data) = 0;
 	virtual std::optional<std::vector<uint8_t>> read_data() = 0;
 
-	virtual bool operator==(WiimoteDevice& o) const = 0;
-	bool operator!=(WiimoteDevice& o) const { return *this == o; }
+	virtual bool operator==(const WiimoteDevice& o) const = 0;
 };
 
 using WiimoteDevicePtr = std::shared_ptr<WiimoteDevice>;
diff --git a/src/input/api/Wiimote/WiimoteMessages.h b/src/input/api/Wiimote/WiimoteMessages.h
index 712c3a5c..32dd4658 100644
--- a/src/input/api/Wiimote/WiimoteMessages.h
+++ b/src/input/api/Wiimote/WiimoteMessages.h
@@ -8,7 +8,7 @@ enum InputReportId : uint8
 
 	kStatus = 0x20,
 	kRead = 0x21,
-	kWrite = 0x22,
+	kAcknowledge = 0x22,
 
 	kDataCore = 0x30,
 	kDataCoreAcc = 0x31,
diff --git a/src/input/api/Wiimote/hidapi/HidapiWiimote.cpp b/src/input/api/Wiimote/hidapi/HidapiWiimote.cpp
new file mode 100644
index 00000000..5780909f
--- /dev/null
+++ b/src/input/api/Wiimote/hidapi/HidapiWiimote.cpp
@@ -0,0 +1,59 @@
+#include "HidapiWiimote.h"
+#include <cwchar>
+
+static constexpr uint16 WIIMOTE_VENDOR_ID = 0x057e;
+static constexpr uint16 WIIMOTE_PRODUCT_ID = 0x0306;
+static constexpr uint16 WIIMOTE_MP_PRODUCT_ID = 0x0330;
+static constexpr uint16 WIIMOTE_MAX_INPUT_REPORT_LENGTH = 22;
+static constexpr auto PRO_CONTROLLER_NAME = L"Nintendo RVL-CNT-01-UC";
+
+HidapiWiimote::HidapiWiimote(hid_device* dev, std::string_view path)
+ : m_handle(dev), m_path(path) {
+
+}
+
+bool HidapiWiimote::write_data(const std::vector<uint8> &data) {
+    return hid_write(m_handle, data.data(), data.size()) >= 0;
+}
+
+std::optional<std::vector<uint8>> HidapiWiimote::read_data() {
+    std::array<uint8, WIIMOTE_MAX_INPUT_REPORT_LENGTH> read_data{};
+    const auto result = hid_read(m_handle, read_data.data(), WIIMOTE_MAX_INPUT_REPORT_LENGTH);
+    if (result < 0)
+        return {};
+    return {{read_data.cbegin(), read_data.cbegin() + result}};
+}
+
+std::vector<WiimoteDevicePtr> HidapiWiimote::get_devices() {
+    std::vector<WiimoteDevicePtr> wiimote_devices;
+    hid_init();
+    const auto device_enumeration = hid_enumerate(WIIMOTE_VENDOR_ID, 0x0);
+
+    for (auto it = device_enumeration; it != nullptr; it = it->next){
+        if (it->product_id != WIIMOTE_PRODUCT_ID && it->product_id != WIIMOTE_MP_PRODUCT_ID)
+            continue;
+        if (std::wcscmp(it->product_string, PRO_CONTROLLER_NAME) == 0)
+            continue;
+        auto dev = hid_open_path(it->path);
+        if (!dev){
+            cemuLog_logDebug(LogType::Force, "Unable to open Wiimote device at {}: {}", it->path, boost::nowide::narrow(hid_error(nullptr)));
+        }
+        else {
+            hid_set_nonblocking(dev, true);
+            wiimote_devices.push_back(std::make_shared<HidapiWiimote>(dev, it->path));
+        }
+    }
+    hid_free_enumeration(device_enumeration);
+    return wiimote_devices;
+}
+
+bool HidapiWiimote::operator==(const WiimoteDevice& rhs) const  {
+    auto other = dynamic_cast<const HidapiWiimote*>(&rhs);
+	if (!other)
+		return false;
+	return m_path == other->m_path;
+}
+
+HidapiWiimote::~HidapiWiimote() {
+    hid_close(m_handle);
+}
diff --git a/src/input/api/Wiimote/hidapi/HidapiWiimote.h b/src/input/api/Wiimote/hidapi/HidapiWiimote.h
new file mode 100644
index 00000000..952a36f0
--- /dev/null
+++ b/src/input/api/Wiimote/hidapi/HidapiWiimote.h
@@ -0,0 +1,21 @@
+#pragma once
+
+#include <api/Wiimote/WiimoteDevice.h>
+#include <hidapi.h>
+
+class HidapiWiimote : public WiimoteDevice {
+public:
+    HidapiWiimote(hid_device* dev, std::string_view path);
+    ~HidapiWiimote() override;
+
+    bool write_data(const std::vector<uint8> &data) override;
+    std::optional<std::vector<uint8>> read_data() override;
+    bool operator==(const WiimoteDevice& o) const override;
+
+    static std::vector<WiimoteDevicePtr> get_devices();
+
+private:
+    hid_device* m_handle;
+    const std::string m_path;
+
+};
diff --git a/src/input/api/Wiimote/l2cap/L2CapWiimote.cpp b/src/input/api/Wiimote/l2cap/L2CapWiimote.cpp
new file mode 100644
index 00000000..a6bdf574
--- /dev/null
+++ b/src/input/api/Wiimote/l2cap/L2CapWiimote.cpp
@@ -0,0 +1,148 @@
+#include "L2CapWiimote.h"
+#include <bluetooth/l2cap.h>
+
+constexpr auto comparator = [](const bdaddr_t& a, const bdaddr_t& b) {
+	return bacmp(&a, &b);
+};
+
+static auto s_addresses = std::map<bdaddr_t, bool, decltype(comparator)>(comparator);
+static std::mutex s_addressMutex;
+
+static bool AttemptConnect(int sockFd, const sockaddr_l2& addr)
+{
+	auto res = connect(sockFd, reinterpret_cast<const sockaddr*>(&addr),
+					   sizeof(sockaddr_l2));
+	if (res == 0)
+		return true;
+	return connect(sockFd, reinterpret_cast<const sockaddr*>(&addr),
+				   sizeof(sockaddr_l2)) == 0;
+}
+
+static bool AttemptSetNonBlock(int sockFd)
+{
+	return fcntl(sockFd, F_SETFL, fcntl(sockFd, F_GETFL) | O_NONBLOCK) == 0;
+}
+
+L2CapWiimote::L2CapWiimote(int controlFd, int dataFd, bdaddr_t addr)
+	: m_controlFd(controlFd), m_dataFd(dataFd), m_addr(addr)
+{
+}
+
+L2CapWiimote::~L2CapWiimote()
+{
+	close(m_dataFd);
+	close(m_controlFd);
+	const auto& b = m_addr.b;
+	cemuLog_logDebug(LogType::Force, "Wiimote at {:02x}:{:02x}:{:02x}:{:02x}:{:02x}:{:02x} disconnected", b[5], b[4], b[3], b[2], b[1], b[0]);
+
+	// Re-add to candidate vec
+	s_addressMutex.lock();
+	s_addresses[m_addr] = false;
+	s_addressMutex.unlock();
+}
+
+void L2CapWiimote::AddCandidateAddress(bdaddr_t addr)
+{
+	std::scoped_lock lock(s_addressMutex);
+	s_addresses.try_emplace(addr, false);
+}
+
+std::vector<WiimoteDevicePtr> L2CapWiimote::get_devices()
+{
+	s_addressMutex.lock();
+	std::vector<bdaddr_t> unconnected;
+	for (const auto& [addr, connected] : s_addresses)
+	{
+		if (!connected)
+			unconnected.push_back(addr);
+	}
+	s_addressMutex.unlock();
+
+	std::vector<WiimoteDevicePtr> outDevices;
+	for (const auto& addr : unconnected)
+	{
+		// Control socket, PSM 0x11, needs to be open for the data socket to be opened
+		auto controlFd = socket(PF_BLUETOOTH, SOCK_SEQPACKET, BTPROTO_L2CAP);
+		if (controlFd < 0)
+		{
+			cemuLog_logDebug(LogType::Force, "Failed to open control socket: {}", strerror(errno));
+			continue;
+		}
+
+		sockaddr_l2 controlAddr{};
+		controlAddr.l2_family = AF_BLUETOOTH;
+		controlAddr.l2_psm = htobs(0x11);
+		controlAddr.l2_bdaddr = addr;
+
+		if (!AttemptConnect(controlFd, controlAddr) || !AttemptSetNonBlock(controlFd))
+		{
+			const auto& b = addr.b;
+			cemuLog_logDebug(LogType::Force, "Failed to connect control socket to '{:02x}:{:02x}:{:02x}:{:02x}:{:02x}:{:02x}': {}",
+							 b[5], b[4], b[3], b[2], b[1], b[0], strerror(errno));
+			close(controlFd);
+			continue;
+		}
+
+		// Socket for sending and receiving data from controller, PSM 0x13
+		auto dataFd = socket(PF_BLUETOOTH, SOCK_SEQPACKET, BTPROTO_L2CAP);
+		if (dataFd < 0)
+		{
+			cemuLog_logDebug(LogType::Force, "Failed to open data socket: {}", strerror(errno));
+			close(controlFd);
+			continue;
+		}
+		sockaddr_l2 dataAddr{};
+		dataAddr.l2_family = AF_BLUETOOTH;
+		dataAddr.l2_psm = htobs(0x13);
+		dataAddr.l2_bdaddr = addr;
+
+		if (!AttemptConnect(dataFd, dataAddr) || !AttemptSetNonBlock(dataFd))
+		{
+			const auto& b = addr.b;
+			cemuLog_logDebug(LogType::Force, "Failed to connect data socket to '{:02x}:{:02x}:{:02x}:{:02x}:{:02x}:{:02x}': {}",
+							 b[5], b[4], b[3], b[2], b[1], b[0], strerror(errno));
+			close(dataFd);
+			close(controlFd);
+			continue;
+		}
+		outDevices.emplace_back(std::make_shared<L2CapWiimote>(controlFd, dataFd, addr));
+
+		s_addressMutex.lock();
+		s_addresses[addr] = true;
+		s_addressMutex.unlock();
+	}
+	return outDevices;
+}
+
+bool L2CapWiimote::write_data(const std::vector<uint8>& data)
+{
+	const auto size = data.size();
+	cemu_assert_debug(size < 23);
+	uint8 buffer[23];
+	// All outgoing messages must be prefixed with 0xA2
+	buffer[0] = 0xA2;
+	std::memcpy(buffer + 1, data.data(), size);
+	const auto outSize = size + 1;
+	return send(m_dataFd, buffer, outSize, 0) == outSize;
+}
+
+std::optional<std::vector<uint8>> L2CapWiimote::read_data()
+{
+	uint8 buffer[23];
+	const auto nBytes = recv(m_dataFd, buffer, 23, 0);
+
+	if (nBytes < 0 && errno == EWOULDBLOCK)
+		return std::vector<uint8>{};
+	// All incoming messages must be prefixed with 0xA1
+	if (nBytes < 2 || buffer[0] != 0xA1)
+		return std::nullopt;
+	return std::vector(buffer + 1, buffer + 1 + nBytes - 1);
+}
+
+bool L2CapWiimote::operator==(const WiimoteDevice& rhs) const
+{
+	auto mote = dynamic_cast<const L2CapWiimote*>(&rhs);
+	if (!mote)
+		return false;
+	return bacmp(&m_addr, &mote->m_addr) == 0;
+}
\ No newline at end of file
diff --git a/src/input/api/Wiimote/l2cap/L2CapWiimote.h b/src/input/api/Wiimote/l2cap/L2CapWiimote.h
new file mode 100644
index 00000000..0b6c5c19
--- /dev/null
+++ b/src/input/api/Wiimote/l2cap/L2CapWiimote.h
@@ -0,0 +1,22 @@
+#pragma once
+#include <input/api/Wiimote/WiimoteDevice.h>
+#include <bluetooth/bluetooth.h>
+
+class L2CapWiimote : public WiimoteDevice
+{
+  public:
+	L2CapWiimote(int controlFd, int dataFd, bdaddr_t addr);
+	~L2CapWiimote() override;
+
+	bool write_data(const std::vector<uint8>& data) override;
+	std::optional<std::vector<uint8>> read_data() override;
+	bool operator==(const WiimoteDevice& o) const override;
+
+	static void AddCandidateAddress(bdaddr_t addr);
+	static std::vector<WiimoteDevicePtr> get_devices();
+  private:
+	int m_controlFd;
+	int m_dataFd;
+	bdaddr_t m_addr;
+};
+
diff --git a/src/input/api/Wiimote/windows/WinWiimoteDevice.cpp b/src/input/api/Wiimote/windows/WinWiimoteDevice.cpp
deleted file mode 100644
index 546a9615..00000000
--- a/src/input/api/Wiimote/windows/WinWiimoteDevice.cpp
+++ /dev/null
@@ -1,127 +0,0 @@
-#include "input/api/Wiimote/windows/WinWiimoteDevice.h"
-
-#include <hidsdi.h>
-#include <SetupAPI.h>
-
-WinWiimoteDevice::WinWiimoteDevice(HANDLE handle, std::vector<uint8_t> identifier)
-	: m_handle(handle), m_identifier(std::move(identifier))
-{
-	m_overlapped.hEvent = CreateEvent(nullptr, TRUE, TRUE, nullptr);
-}
-
-WinWiimoteDevice::~WinWiimoteDevice()
-{
-	CancelIo(m_handle);
-	ResetEvent(m_overlapped.hEvent);
-	CloseHandle(m_handle);
-}
-
-bool WinWiimoteDevice::write_data(const std::vector<uint8>& data)
-{
-	return HidD_SetOutputReport(m_handle, (void*)data.data(), (ULONG)data.size());
-}
-
-std::optional<std::vector<uint8_t>> WinWiimoteDevice::read_data()
-{
-	DWORD read = 0;
-	std::array<uint8_t, 32> buffer{};
-
-	if (!ReadFile(m_handle, buffer.data(), (DWORD)buffer.size(), &read, &m_overlapped))
-	{
-		const auto error = GetLastError();
-		if (error == ERROR_DEVICE_NOT_CONNECTED)
-			return {};
-		else if (error == ERROR_IO_PENDING)
-		{
-			const auto wait_result = WaitForSingleObject(m_overlapped.hEvent, 100);
-			if (wait_result == WAIT_TIMEOUT)
-			{
-				CancelIo(m_handle);
-				ResetEvent(m_overlapped.hEvent);
-				return {};
-			}
-			else if (wait_result == WAIT_FAILED)
-				return {};
-
-			if (GetOverlappedResult(m_handle, &m_overlapped, &read, FALSE) == FALSE)
-				return {};
-		}
-		else if (error == ERROR_INVALID_HANDLE)
-		{
-			ResetEvent(m_overlapped.hEvent);
-			return {};
-		}
-		else
-		{
-			cemu_assert_debug(false);
-		}
-	}
-
-	ResetEvent(m_overlapped.hEvent);
-	if (read == 0)
-		return {};
-
-	return {{buffer.cbegin(), buffer.cbegin() + read}};
-}
-
-std::vector<WiimoteDevicePtr> WinWiimoteDevice::get_devices()
-{
-	std::vector<WiimoteDevicePtr> result;
-
-	GUID hid_guid;
-	HidD_GetHidGuid(&hid_guid);
-
-	const auto device_info = SetupDiGetClassDevs(&hid_guid, nullptr, nullptr, (DIGCF_DEVICEINTERFACE | DIGCF_PRESENT));
-
-	for (DWORD index = 0; ; ++index)
-	{
-		SP_DEVICE_INTERFACE_DATA device_data{};
-		device_data.cbSize = sizeof(device_data);
-		if (SetupDiEnumDeviceInterfaces(device_info, nullptr, &hid_guid, index, &device_data) == FALSE)
-			break;
-
-		DWORD device_data_len;
-		if (SetupDiGetDeviceInterfaceDetail(device_info, &device_data, nullptr, 0, &device_data_len, nullptr) == FALSE
-			&& GetLastError() != ERROR_INSUFFICIENT_BUFFER)
-			continue;
-
-		std::vector<uint8_t> detail_data_buffer;
-		detail_data_buffer.resize(device_data_len);
-
-		const auto detail_data = (PSP_DEVICE_INTERFACE_DETAIL_DATA)detail_data_buffer.data();
-		detail_data->cbSize = sizeof(SP_DEVICE_INTERFACE_DETAIL_DATA);
-
-		if (SetupDiGetDeviceInterfaceDetail(device_info, &device_data, detail_data, device_data_len, nullptr, nullptr)
-			== FALSE)
-			continue;
-
-		HANDLE device_handle = CreateFile(detail_data->DevicePath, (GENERIC_READ | GENERIC_WRITE),
-		                                  (FILE_SHARE_READ | FILE_SHARE_WRITE), nullptr, OPEN_EXISTING,
-		                                  FILE_FLAG_OVERLAPPED, nullptr);
-		if (device_handle == INVALID_HANDLE_VALUE)
-			continue;
-
-		HIDD_ATTRIBUTES attributes{};
-		attributes.Size = sizeof(attributes);
-		if (HidD_GetAttributes(device_handle, &attributes) == FALSE)
-		{
-			CloseHandle(device_handle);
-			continue;
-		}
-
-		if (attributes.VendorID != 0x057e || (attributes.ProductID != 0x0306 && attributes.ProductID != 0x0330))
-		{
-			CloseHandle(device_handle);
-			continue;
-		}
-
-		result.emplace_back(std::make_shared<WinWiimoteDevice>(device_handle, detail_data_buffer));
-	}
-
-	return result;
-}
-
-bool WinWiimoteDevice::operator==(WiimoteDevice& o) const
-{
-	return m_identifier == static_cast<WinWiimoteDevice&>(o).m_identifier;
-}
diff --git a/src/input/api/Wiimote/windows/WinWiimoteDevice.h b/src/input/api/Wiimote/windows/WinWiimoteDevice.h
deleted file mode 100644
index 077882db..00000000
--- a/src/input/api/Wiimote/windows/WinWiimoteDevice.h
+++ /dev/null
@@ -1,24 +0,0 @@
-#pragma once
-
-#include "input/api/Wiimote/WiimoteDevice.h"
-
-class WinWiimoteDevice : public WiimoteDevice
-{
-public:
-	WinWiimoteDevice(HANDLE handle, std::vector<uint8_t> identifier);
-	~WinWiimoteDevice();
-
-	bool write_data(const std::vector<uint8>& data) override;
-	std::optional<std::vector<uint8_t>> read_data() override;
-
-	static std::vector<WiimoteDevicePtr> get_devices();
-
-	bool operator==(WiimoteDevice& o) const override;
-
-private:
-	HANDLE m_handle;
-	OVERLAPPED m_overlapped{};
-	std::vector<uint8_t> m_identifier;
-};
-
-using WiimoteDevice_t = WinWiimoteDevice;
diff --git a/src/input/api/XInput/XInputController.cpp b/src/input/api/XInput/XInputController.cpp
index 08d6510d..c3ab67cf 100644
--- a/src/input/api/XInput/XInputController.cpp
+++ b/src/input/api/XInput/XInputController.cpp
@@ -120,7 +120,8 @@ ControllerState XInputController::raw_state()
 	}
 
 	// Buttons
-	result.buttons = state.Gamepad.wButtons;
+	for(int i=0;i<std::numeric_limits<WORD>::digits;i++)
+		result.buttons.SetButtonState(i, (state.Gamepad.wButtons & (1 << i)) != 0);
 
 	if (state.Gamepad.sThumbLX > 0)
 		result.axis.x = (float)state.Gamepad.sThumbLX / std::numeric_limits<sint16>::max();
diff --git a/src/input/emulated/EmulatedController.cpp b/src/input/emulated/EmulatedController.cpp
index 69c058f7..ad9b6ac1 100644
--- a/src/input/emulated/EmulatedController.cpp
+++ b/src/input/emulated/EmulatedController.cpp
@@ -2,7 +2,7 @@
 
 #include "input/api/Controller.h"
 
-#if BOOST_OS_WINDOWS
+#ifdef SUPPORTS_WIIMOTE
 #include "input/api/Wiimote/NativeWiimoteController.h"
 #endif
 
@@ -131,15 +131,15 @@ bool EmulatedController::has_second_motion() const
 		if(controller->use_motion())
 		{
 			// if wiimote has nunchuck connected, we use its acceleration
-			#if BOOST_OS_WINDOWS
-			if(controller->api() == InputAPI::Wiimote)
+            #if SUPPORTS_WIIMOTE
+            if(controller->api() == InputAPI::Wiimote)
 			{
 				if(((NativeWiimoteController*)controller.get())->get_extension() == NativeWiimoteController::Nunchuck)
 				{
 					return true;
 				}
 			}
-			#endif
+            #endif
 			motion++;
 		}
 	}
@@ -156,7 +156,7 @@ MotionSample EmulatedController::get_second_motion_data() const
 		if (controller->use_motion())
 		{
 			// if wiimote has nunchuck connected, we use its acceleration
-			#if BOOST_OS_WINDOWS
+            #ifdef SUPPORTS_WIIMOTE
 			if (controller->api() == InputAPI::Wiimote)
 			{
 				if (((NativeWiimoteController*)controller.get())->get_extension() == NativeWiimoteController::Nunchuck)
@@ -207,26 +207,26 @@ glm::vec2 EmulatedController::get_prev_position() const
 	return {};
 }
 
-std::shared_ptr<ControllerBase> EmulatedController::find_controller(std::string_view uuid, InputAPI::Type type) const
+PositionVisibility EmulatedController::GetPositionVisibility() const
 {
-	std::scoped_lock lock(m_mutex);
-	const auto it = std::find_if(m_controllers.cbegin(), m_controllers.cend(), [uuid, type](const auto& c) { return c->api() == type && c->uuid() == uuid; });
-	if (it != m_controllers.cend())
-		return *it;
-
-	return {};
+	std::shared_lock lock(m_mutex);
+	for (const auto& controller : m_controllers)
+	{
+		if (controller->has_position())
+			return controller->GetPositionVisibility();
+	}
+	return PositionVisibility::NONE;
 }
 
 void EmulatedController::add_controller(std::shared_ptr<ControllerBase> controller)
 {
 	controller->connect();
 
-	#if BOOST_OS_WINDOWS
-	if (const auto wiimote = std::dynamic_pointer_cast<NativeWiimoteController>(controller)) {
+    #ifdef SUPPORTS_WIIMOTE
+    if (const auto wiimote = std::dynamic_pointer_cast<NativeWiimoteController>(controller)) {
 		wiimote->set_player_index(m_player_index);
 	}
-	#endif
-
+    #endif
 	std::scoped_lock lock(m_mutex);
 	m_controllers.emplace_back(std::move(controller));
 }
@@ -279,11 +279,9 @@ bool EmulatedController::is_mapping_down(uint64 mapping) const
 	const auto it = m_mappings.find(mapping);
 	if (it != m_mappings.cend())
 	{
-		if (const auto controller = it->second.controller.lock()) {
-			return controller->get_state().buttons.test(it->second.button);
-		}
+		if (const auto controller = it->second.controller.lock())
+			return controller->get_state().buttons.GetButtonState(it->second.button);
 	}
-
 	return false;
 }
 
diff --git a/src/input/emulated/EmulatedController.h b/src/input/emulated/EmulatedController.h
index bcc5c165..c5adf81e 100644
--- a/src/input/emulated/EmulatedController.h
+++ b/src/input/emulated/EmulatedController.h
@@ -67,8 +67,8 @@ public:
 	bool has_position() const;
 	glm::vec2 get_position() const;
 	glm::vec2 get_prev_position() const;
-	
-	std::shared_ptr<ControllerBase> find_controller(std::string_view uuid, InputAPI::Type type) const;
+	PositionVisibility GetPositionVisibility() const;
+
 	void add_controller(std::shared_ptr<ControllerBase> controller);
 	void remove_controller(const std::shared_ptr<ControllerBase>& controller);
 	void clear_controllers();
@@ -127,7 +127,7 @@ using EmulatedControllerPtr = std::shared_ptr<EmulatedController>;
 template <>
 struct fmt::formatter<EmulatedController::Type> : formatter<string_view> {
 	template <typename FormatContext>
-	auto format(EmulatedController::Type v, FormatContext& ctx) {
+	auto format(EmulatedController::Type v, FormatContext& ctx) const {
 		switch (v)
 		{
 		case EmulatedController::Type::VPAD: return formatter<string_view>::format("Wii U Gamepad", ctx);
diff --git a/src/input/emulated/VPADController.cpp b/src/input/emulated/VPADController.cpp
index a3ff1a1c..81615c9b 100644
--- a/src/input/emulated/VPADController.cpp
+++ b/src/input/emulated/VPADController.cpp
@@ -221,7 +221,7 @@ void VPADController::update_touch(VPADStatus_t& status)
 
 		m_last_touch_position = glm::ivec2{ status.tpData.x, status.tpData.y };
 
-		/*cemuLog_force("TDATA: {},{} -> {},{} -> {},{} -> {},{} -> {},{} -> {},{}",
+		/*cemuLog_log(LogType::Force, "TDATA: {},{} -> {},{} -> {},{} -> {},{} -> {},{} -> {},{}",
 			left_mouse->x, left_mouse->y,
 			(left_mouse.value() - image_pos).x, (left_mouse.value() - image_pos).y,
 			relative_mouse_pos.x, relative_mouse_pos.y,
@@ -287,9 +287,9 @@ void VPADController::update_motion(VPADStatus_t& status)
 
 		int w, h;
 		if (pad_view)
-			gui_getPadWindowSize(&w, &h);
+			gui_getPadWindowPhysSize(w, h);
 		else
-			gui_getWindowSize(&w, &h);
+			gui_getWindowPhysSize(w, h);
 
 		float wx = mousePos.x / w;
 		float wy = mousePos.y / h;
@@ -408,7 +408,7 @@ bool VPADController::push_rumble(uint8* pattern, uint8 length)
 	std::scoped_lock lock(m_rumble_mutex);
 	if (m_rumble_queue.size() >= 5)
 	{
-		forceLogDebug_printf("too many cmds");
+		cemuLog_logDebugOnce(LogType::Force, "VPADControlMotor(): Pattern too long");
 		return false;
 	}
 
@@ -686,3 +686,14 @@ bool VPADController::set_default_mapping(const std::shared_ptr<ControllerBase>&
 
 	return mapping_updated;
 }
+
+void VPADController::load(const pugi::xml_node& node)
+{
+	if (const auto value = node.child("toggle_display"))
+		m_screen_active_toggle = ConvertString<bool>(value.child_value());
+}
+
+void VPADController::save(pugi::xml_node& node)
+{
+	node.append_child("toggle_display").append_child(pugi::node_pcdata).set_value(fmt::format("{}", (int)m_screen_active_toggle).c_str());
+}
diff --git a/src/input/emulated/VPADController.h b/src/input/emulated/VPADController.h
index 6aef16ae..937062da 100644
--- a/src/input/emulated/VPADController.h
+++ b/src/input/emulated/VPADController.h
@@ -66,6 +66,8 @@ public:
 
 	bool is_mic_active() { return m_mic_active; }
 	bool is_screen_active() { return m_screen_active; }
+	bool is_screen_active_toggle() { return m_screen_active_toggle; }
+	void set_screen_toggle(bool toggle) {m_screen_active_toggle = toggle;}
 
 	static std::string_view get_button_name(ButtonId id);
 
@@ -86,9 +88,13 @@ public:
 
 	bool set_default_mapping(const std::shared_ptr<ControllerBase>& controller) override;
 
+	void load(const pugi::xml_node& node) override;
+	void save(pugi::xml_node& node) override;
+
 private:
 	bool m_mic_active = false;
 	bool m_screen_active = false;
+	bool m_screen_active_toggle = false;
 	uint32be m_last_holdvalue = 0;
 
 	std::chrono::high_resolution_clock::time_point m_last_hold_change{}, m_last_pulse{};
diff --git a/src/input/emulated/WPADController.cpp b/src/input/emulated/WPADController.cpp
index 819596ab..2eae0f86 100644
--- a/src/input/emulated/WPADController.cpp
+++ b/src/input/emulated/WPADController.cpp
@@ -1,3 +1,4 @@
+#include <api/Controller.h>
 #include "input/emulated/WPADController.h"
 
 #include "input/emulated/ClassicController.h"
@@ -308,10 +309,13 @@ void WPADController::KPADRead(KPADStatus_t& status, const BtnRepeat& repeat)
 			status.mpls.dir.Z.z = attitude[8];
 		}
 	}
-
-	if (has_position())
+	auto visibility = GetPositionVisibility();
+	if (has_position() && visibility != PositionVisibility::NONE)
 	{
-		status.dpd_valid_fg = 1;
+		if (visibility == PositionVisibility::FULL)
+			status.dpd_valid_fg = 2;
+		else
+			status.dpd_valid_fg = -1;
 
 		const auto position = get_position();
 
@@ -324,6 +328,8 @@ void WPADController::KPADRead(KPADStatus_t& status, const BtnRepeat& repeat)
 		status.vec.y = delta.y;
 		status.speed = glm::length(delta);
 	}
+	else
+		status.dpd_valid_fg = 0;
 
 	switch (type())
 	{
diff --git a/src/input/motion/Mahony.h b/src/input/motion/Mahony.h
index b34bef9d..340282b6 100644
--- a/src/input/motion/Mahony.h
+++ b/src/input/motion/Mahony.h
@@ -33,7 +33,7 @@ public:
 		if (fabs(gv.z) < 0.015f)
 			gv.z = 0.0f;
 
-		// forceLogDebug_printf("[IMU Quat] time %7.4lf | %7.2lf %7.2lf %7.2lf %7.2lf | gyro( - bias) %7.4lf %7.4lf %7.4lf | acc %7.2lf %7.2lf %7.2lf | GyroBias %7.4lf %7.4lf %7.4lf", deltaTime, m_imuQ.x, m_imuQ.y, m_imuQ.z, m_imuQ.w, gv.x, gv.y, gv.z, ax, ay, az, m_gyroBias[0], m_gyroBias[1], m_gyroBias[2]);
+		// cemuLog_logDebug(LogType::Force, "[IMU Quat] time {:7.4} | {:7.2} {:7.2} {:7.2} {:7.2} | gyro( - bias) {:7.4} {:7.4} {:7.4} | acc {:7.2} {:7.2} {:7.2} | GyroBias {:7.4} {:7.4} {:7.4}", deltaTime, m_imuQ.x, m_imuQ.y, m_imuQ.z, m_imuQ.w, gv.x, gv.y, gv.z, ax, ay, az, m_gyroBias[0], m_gyroBias[1], m_gyroBias[2]);
 
 		if (fabs(av.x) > 0.000001f || fabs(av.y) > 0.000001f || fabs(av.z) > 0.000001f)
 		{
@@ -162,4 +162,4 @@ private:
 		float m_gyroBias[3]{};
 		double m_gyroTotalSum[3]{};
 		uint64 m_gyroTotalSampleCount{};
-};
\ No newline at end of file
+};
diff --git a/src/input/motion/MotionSample.h b/src/input/motion/MotionSample.h
index f4015afb..0697711b 100644
--- a/src/input/motion/MotionSample.h
+++ b/src/input/motion/MotionSample.h
@@ -104,9 +104,7 @@ struct Quat
 class MotionSample
 {
 public:
-	MotionSample()
-	{
-	}
+	MotionSample() = default;
 
 	MotionSample(float acc[3], float accAcceleration, float gyro[3], float orientation[3],
 		float quaternion[4]
@@ -260,48 +258,48 @@ DRC flat on table, screen facing up. Top pointing away (away from person, pointi
 0.03    0.99   -0.13
 0.01    0.13    0.99
 
-Turned 45� to the right:
+Turned 45° to the right:
  0.71   -0.03    0.71
  0.12    0.99   -0.08
 -0.70    0.14    0.70
 
-Turned 45� to the right (top of GamePad pointing right now):
+Turned 45° to the right (top of GamePad pointing right now):
  0.08   -0.03    1.00			-> Z points towards person
  0.15    0.99    0.01
 -0.99    0.15    0.09			-> DRC Z-Axis now points towards X-minus
 
-Turned 90� to the right (top of gamepad now pointing towards holder, away from monitor):
+Turned 90° to the right (top of gamepad now pointing towards holder, away from monitor):
 -1.00   -0.01    0.06
  0.00    0.99    0.15
 -0.06    0.15   -0.99
 
-Turned 90� to the right (pointing left):
+Turned 90° to the right (pointing left):
 -0.17   -0.01   -0.99
 -0.13    0.99    0.02
  0.98    0.13   -0.17
 
-After another 90� we end up in the initial position:
+After another 90° we end up in the initial position:
  0.99   -0.03   -0.11
  0.01    0.99   -0.13
  0.12    0.12    0.99
 
 ------
-From initial position, lean the GamePad on its left side. 45� up. So the screen is pointing to the top left
+From initial position, lean the GamePad on its left side. 45° up. So the screen is pointing to the top left
  0.66   -0.75   -0.03
  0.74    0.66   -0.11
  0.10    0.05    0.99
 
-Further 45�, GamePad now on its left, screen pointing left:
+Further 45°, GamePad now on its left, screen pointing left:
 -0.03   -1.00   -0.00
  0.99   -0.03   -0.15
  0.15   -0.01    0.99
 
-From initial position, lean the GamePad on its right side. 45� up. So the screen is pointing to the top right
+From initial position, lean the GamePad on its right side. 45° up. So the screen is pointing to the top right
  0.75    0.65   -0.11
 -0.65    0.76    0.07
  0.12    0.02    0.99
 
-From initial position, tilt the GamePad up 90� (bottom side remains in touch with surface):
+From initial position, tilt the GamePad up 90° (bottom side remains in touch with surface):
  0.99   -0.05   -0.10
 -0.10    0.01   -0.99
  0.05    1.00    0.01
@@ -311,7 +309,7 @@ From initial position, stand the GamePad on its top side:
  0.09   -0.01    1.00
 -0.01   -1.00   -0.01
 
-Rotate GamePad 180� around x axis, so it now lies on its screen (top of GamePad pointing to holder):
+Rotate GamePad 180° around x axis, so it now lies on its screen (top of GamePad pointing to holder):
  0.99   -0.03   -0.15
 -0.04   -1.00   -0.08
 -0.15    0.09   -0.99
diff --git a/src/main.cpp b/src/main.cpp
index 67b640b4..ea1df684 100644
--- a/src/main.cpp
+++ b/src/main.cpp
@@ -1,23 +1,24 @@
-#include "gui/guiWrapper.h"
+#include "gui/guiWrapper.h"
 #include "gui/wxgui.h"
 #include "util/crypto/aes128.h"
 #include "gui/MainWindow.h"
 #include "Cafe/OS/RPL/rpl.h"
-#include "Cafe/OS/RPL/rpl_symbol_storage.h"
 #include "Cafe/OS/libs/gx2/GX2.h"
+#include "Cafe/OS/libs/coreinit/coreinit_Thread.h"
 #include "Cafe/GameProfile/GameProfile.h"
 #include "Cafe/GraphicPack/GraphicPack2.h"
 #include "config/CemuConfig.h"
-#include "gui/CemuApp.h"
-#include "Cafe/HW/Latte/Core/LatteOverlay.h"
+#include "config/NetworkSettings.h"
 #include "config/LaunchSettings.h"
-#include "Cafe/OS/libs/coreinit/coreinit_Thread.h"
+#include "input/InputManager.h"
+#include "gui/CemuApp.h"
 
 #include "Cafe/CafeSystem.h"
 #include "Cafe/TitleList/TitleList.h"
 #include "Cafe/TitleList/SaveList.h"
 
 #include "Common/ExceptionHandler/ExceptionHandler.h"
+#include "Common/cpu_features.h"
 
 #include <wx/setup.h>
 #include "util/helpers/helpers.h"
@@ -28,6 +29,7 @@
 #include "Cafe/OS/libs/vpad/vpad.h"
 
 #include "audio/IAudioAPI.h"
+#include "audio/IAudioInputAPI.h"
 #if BOOST_OS_WINDOWS
 #pragma comment(lib,"Dbghelp.lib")
 #endif
@@ -35,8 +37,13 @@
 #define SDL_MAIN_HANDLED
 #include <SDL.h>
 
-#if BOOST_OS_LINUX || BOOST_OS_MACOS
+#if BOOST_OS_LINUX
 #define _putenv(__s) putenv((char*)(__s))
+#include <sys/sysinfo.h>
+#elif BOOST_OS_MACOS
+#define _putenv(__s) putenv((char*)(__s))
+#include <sys/types.h>
+#include <sys/sysctl.h>
 #endif
 
 #if BOOST_OS_WINDOWS
@@ -47,105 +54,10 @@ extern "C"
 }
 #endif
 
-bool _cpuExtension_SSSE3 = false;
-bool _cpuExtension_SSE4_1 = false;
-bool _cpuExtension_AVX2 = false;
-
 std::atomic_bool g_isGPUInitFinished = false;
 
 std::wstring executablePath;
 
-void logCPUAndMemoryInfo()
-{
-	#if BOOST_OS_WINDOWS
-	int CPUInfo[4] = { -1 };
-	unsigned   nExIds, i = 0;
-	char CPUBrandString[0x40];
-	// Get the information associated with each extended ID.
-	cpuid(CPUInfo, 0x80000000);
-	nExIds = CPUInfo[0];
-	for (i = 0x80000000; i <= nExIds; ++i)
-	{
-		cpuid(CPUInfo, i);
-		// Interpret CPU brand string
-		if (i == 0x80000002)
-			memcpy(CPUBrandString, CPUInfo, sizeof(CPUInfo));
-		else if (i == 0x80000003)
-			memcpy(CPUBrandString + 16, CPUInfo, sizeof(CPUInfo));
-		else if (i == 0x80000004)
-			memcpy(CPUBrandString + 32, CPUInfo, sizeof(CPUInfo));
-	}
-	forceLog_printf("CPU: %s", CPUBrandString);
-
-	MEMORYSTATUSEX statex;
-	statex.dwLength = sizeof(statex);
-	GlobalMemoryStatusEx(&statex);
-	uint32 memoryInMB = (uint32)(statex.ullTotalPhys / 1024LL / 1024LL);
-	forceLog_printf("RAM: %uMB", memoryInMB);
-	#endif
-}
-
-bool g_running_in_wine = false;
-bool IsRunningInWine()
-{
-	return g_running_in_wine;
-}
-
-void checkForWine()
-{
-	#if BOOST_OS_WINDOWS
-	const HMODULE hmodule = GetModuleHandleA("ntdll.dll");
-	if (!hmodule)
-		return;
-
-	const auto pwine_get_version = (const char*(__cdecl*)())GetProcAddress(hmodule, "wine_get_version");
-	if (pwine_get_version)
-	{
-		g_running_in_wine = true;
-		forceLog_printf("Wine version: %s", pwine_get_version());
-	}
-	#else
-	g_running_in_wine = false;
-	#endif
-}
-
-void infoLog_cemuStartup()
-{
-	cemuLog_force("------- Init {} -------", BUILD_VERSION_WITH_NAME_STRING);
-	cemuLog_force("Init Wii U memory space (base: 0x{:016x})", (size_t)memory_base);
-	cemuLog_force(u8"mlc01 path: {}", ActiveSettings::GetMlcPath().generic_u8string());
-	// check for wine version
-	checkForWine();
-	// CPU and RAM info
-	logCPUAndMemoryInfo();
-	// extensions that Cemu uses
-	char cpuExtensionStr[256];
-	strcpy(cpuExtensionStr, "");
-	if (_cpuExtension_SSSE3)
-	{
-		strcat(cpuExtensionStr, "SSSE3");
-	}
-	if (_cpuExtension_SSE4_1)
-	{
-		if (cpuExtensionStr[0] != '\0')
-			strcat(cpuExtensionStr, ", ");
-		strcat(cpuExtensionStr, "SSE4.1");
-	}
-	if (_cpuExtension_AVX2)
-	{
-		if (cpuExtensionStr[0] != '\0')
-			strcat(cpuExtensionStr, ", ");
-		strcat(cpuExtensionStr, "AVX2");
-	}
-	if (AES128_useAESNI())
-	{
-		if (cpuExtensionStr[0] != '\0')
-			strcat(cpuExtensionStr, ", ");
-		strcat(cpuExtensionStr, "AES-NI");
-	}
-	cemuLog_force("Used CPU extensions: {}", cpuExtensionStr);
-}
-
 // some implementations of _putenv dont copy the string and instead only store a pointer
 // thus we use a helper to keep a permanent copy
 std::vector<std::string*> sPutEnvMap;
@@ -160,7 +72,7 @@ void _putenvSafe(const char* c)
 void reconfigureGLDrivers()
 {
 	// reconfigure GL drivers to store 
-	const fs::path nvCacheDir = ActiveSettings::GetPath("shaderCache/driver/nvidia/");
+	const fs::path nvCacheDir = ActiveSettings::GetCachePath("shaderCache/driver/nvidia/");
 
 	std::error_code err;
 	fs::create_directories(nvCacheDir, err);
@@ -184,24 +96,9 @@ void reconfigureVkDrivers()
     _putenvSafe("DISABLE_VK_LAYER_VALVE_steam_fossilize_1=1");
 }
 
-void mainEmulatorCommonInit()
+void WindowsInitCwd()
 {
-	reconfigureGLDrivers();
-	reconfigureVkDrivers();
-	// crypto init
-	AES128_init();
-	// init PPC timer (call this as early as possible because it measures frequency of RDTSC using an asynchronous thread over 3 seconds)
-	PPCTimer_init();
-	// check available CPU extensions
-	int cpuInfo[4];
-	cpuid(cpuInfo, 0x1);
-	_cpuExtension_SSSE3 = ((cpuInfo[2] >> 9) & 1) != 0;
-	_cpuExtension_SSE4_1 = ((cpuInfo[2] >> 19) & 1) != 0;
-
-	cpuidex(cpuInfo, 0x7, 0);
-	_cpuExtension_AVX2 = ((cpuInfo[1] >> 5) & 1) != 0;
-
-#if BOOST_OS_WINDOWS
+	#if BOOST_OS_WINDOWS
 	executablePath.resize(4096);
 	int i = GetModuleFileName(NULL, executablePath.data(), executablePath.size());
 	if(i >= 0)
@@ -209,64 +106,39 @@ void mainEmulatorCommonInit()
 	else
 		executablePath.clear();
 	SetCurrentDirectory(executablePath.c_str());
-
 	// set high priority
 	SetPriorityClass(GetCurrentProcess(), ABOVE_NORMAL_PRIORITY_CLASS);
-#endif
-    ExceptionHandler_init();
+	#endif
+}
+
+void CemuCommonInit()
+{
+	reconfigureGLDrivers();
+	reconfigureVkDrivers();
+	// crypto init
+	AES128_init();
+	// init PPC timer
+	// call this as early as possible because it measures frequency of RDTSC using an asynchronous thread over 3 seconds
+	PPCTimer_init();
+
+	WindowsInitCwd();
+    ExceptionHandler_Init();
 	// read config
 	g_config.Load();
-	// symbol storage
-	rplSymbolStorage_init();
-	// static initialization
-	IAudioAPI::InitializeStatic();
-	// load graphic packs (must happen before config is loaded)
-	GraphicPack2::LoadAll();
-	// initialize file system
-	fsc_init();
-}
-
-void mainEmulatorLLE();
-void ppcAsmTest();
-void gx2CopySurfaceTest();
-void ExpressionParser_test();
-void FSTVolumeTest();
-
-void unitTests()
-{
-	ExpressionParser_test();
-	gx2CopySurfaceTest();
-	ppcAsmTest();
-	FSTVolumeTest();
-}
-
-int mainEmulatorHLE()
-{
-	if (!TestWriteAccess(ActiveSettings::GetPath()))
-		wxMessageBox("Cemu doesn't have write access to it's own directory.\nPlease move it to a different location or run Cemu as administrator!", "Warning", wxOK|wxICON_ERROR); // todo - different error messages per OS
-	LatteOverlay_init();
-	// run a couple of tests if in non-release mode
-#ifndef PUBLIC_RELEASE
-	unitTests();
-#endif
-	// init common
-	mainEmulatorCommonInit();
-	// reserve memory (no allocations yet)
-	memory_init();
-	// init ppc core
-	PPCCore_init();
-	// log Cemu startup info
-	infoLog_cemuStartup();
-	// init RPL loader
-	RPLLoader_InitState();
-	// init IOSU components
-	iosuCrypto_init();
-	// init Cafe system (todo - the stuff above should be part of this too)
+	if (NetworkConfig::XMLExists())
+		n_config.Load();
+	// parallelize expensive init code
+	std::future<int> futureInitAudioAPI = std::async(std::launch::async, []{ IAudioAPI::InitializeStatic(); IAudioInputAPI::InitializeStatic(); return 0; });
+	std::future<int> futureInitGraphicPacks = std::async(std::launch::async, []{ GraphicPack2::LoadAll(); return 0; });
+	InputManager::instance().load();
+	futureInitAudioAPI.wait();
+	futureInitGraphicPacks.wait();
+	// init Cafe system
 	CafeSystem::Initialize();
 	// init title list
-	CafeTitleList::Initialize(ActiveSettings::GetPath("title_list_cache.xml"));
+	CafeTitleList::Initialize(ActiveSettings::GetUserDataPath("title_list_cache.xml"));
 	for (auto& it : GetConfig().game_paths)
-		CafeTitleList::AddScanPath(it);
+		CafeTitleList::AddScanPath(_utf8ToPath(it));
 	fs::path mlcPath = ActiveSettings::GetMlcPath();
 	if (!mlcPath.empty())
 		CafeTitleList::SetMLCPath(mlcPath);
@@ -278,9 +150,22 @@ int mainEmulatorHLE()
 		CafeSaveList::SetMLCPath(mlcPath);
 		CafeSaveList::Refresh();
 	}
-	// Create UI
-	gui_create();
-	return 0;
+}
+
+void mainEmulatorLLE();
+void ppcAsmTest();
+void gx2CopySurfaceTest();
+void ExpressionParser_test();
+void FSTVolumeTest();
+void CRCTest();
+
+void UnitTests()
+{
+	ExpressionParser_test();
+	gx2CopySurfaceTest();
+	ppcAsmTest();
+	FSTVolumeTest();
+	CRCTest();
 }
 
 bool isConsoleConnected = false;
@@ -304,7 +189,7 @@ void HandlePostUpdate()
 {
 	// finalize update process
 	// delete update cemu.exe.backup if available
-	const auto filename = ActiveSettings::GetFullPath().replace_extension("exe.backup");
+	const auto filename = ActiveSettings::GetExecutablePath().replace_extension("exe.backup");
 	if (fs::exists(filename))
 	{
 #if BOOST_OS_WINDOWS
@@ -324,10 +209,10 @@ void HandlePostUpdate()
 			fs::remove(filename, ec);
 		}
 #else
-		while( fs::exists(filename) )
+		while (fs::exists(filename))
 		{
 			std::error_code ec;
-			fs::remove(filename, ec);		
+			fs::remove(filename, ec);
 			std::this_thread::sleep_for(std::chrono::milliseconds(1000));
 		}
 #endif
@@ -338,39 +223,32 @@ void ToolShaderCacheMerger();
 
 #if BOOST_OS_WINDOWS
 
-#ifndef PUBLIC_RELEASE
-#include <crtdbg.h>
-int wmain(int argc, wchar_t* argv[])
+// entrypoint for release builds
+int wWinMain(_In_ HINSTANCE hInstance, _In_opt_ HINSTANCE hPrevInstance, _In_ LPTSTR lpCmdLine, _In_ int nShowCmd)
 {
+	if (FAILED(CoInitializeEx(nullptr, COINIT_MULTITHREADED | COINIT_DISABLE_OLE1DDE)))
+		cemuLog_log(LogType::Force, "CoInitializeEx() failed");
 	SDL_SetMainReady();
-	_CrtSetDbgFlag(_CRTDBG_CHECK_DEFAULT_DF);
-	//ToolShaderCacheMerger();
-
-	if (!LaunchSettings::HandleCommandline(argc, argv))
-		return 0;	
-
-	ActiveSettings::LoadOnce();
-	
-	HandlePostUpdate();
-	return mainEmulatorHLE();
-}
-#else
-int wWinMain( _In_ HINSTANCE hInstance, _In_opt_ HINSTANCE hPrevInstance, _In_ LPTSTR lpCmdLine, _In_ int nShowCmd)
-{
-	SDL_SetMainReady();
-
 	if (!LaunchSettings::HandleCommandline(lpCmdLine))
 		return 0;
-
-	ActiveSettings::LoadOnce();
-
-	HandlePostUpdate();
-	return mainEmulatorHLE();
+	gui_create();
+	return 0;
 }
 
-#endif
+// entrypoint for debug builds with console
+int main(int argc, char* argv[])
+{
+	if (FAILED(CoInitializeEx(nullptr, COINIT_MULTITHREADED | COINIT_DISABLE_OLE1DDE)))
+		cemuLog_log(LogType::Force, "CoInitializeEx() failed");
+	SDL_SetMainReady();
+	if (!LaunchSettings::HandleCommandline(argc, argv))
+		return 0;
+	gui_create();
+	return 0;
+}
 
 #else
+
 int main(int argc, char *argv[])
 {
 #if BOOST_OS_LINUX
@@ -378,15 +256,12 @@ int main(int argc, char *argv[])
 #endif
     if (!LaunchSettings::HandleCommandline(argc, argv))
 		return 0;
-
-	ActiveSettings::LoadOnce();
-
-	HandlePostUpdate();
-	return mainEmulatorHLE();
+	gui_create();
+	return 0;
 }
 #endif
 
 extern "C" DLLEXPORT uint64 gameMeta_getTitleId()
 {
 	return CafeSystem::GetForegroundTitleId();
-}
\ No newline at end of file
+}
diff --git a/src/mainLLE.cpp b/src/mainLLE.cpp
index 2b7c18a0..c32b56ec 100644
--- a/src/mainLLE.cpp
+++ b/src/mainLLE.cpp
@@ -4,7 +4,7 @@
 #include "gui/guiWrapper.h"
 #include "Common/FileStream.h"
 
-void mainEmulatorCommonInit();
+void CemuCommonInit();
 
 typedef struct  
 {
@@ -33,7 +33,7 @@ void loadPPCBootrom()
 
 void mainEmulatorLLE()
 {
-	mainEmulatorCommonInit();
+	CemuCommonInit();
 	// memory init
 	memory_initPhysicalLayout();
 	
diff --git a/src/resource/CMakeLists.txt b/src/resource/CMakeLists.txt
index 24eb7f4e..78d7c6db 100644
--- a/src/resource/CMakeLists.txt
+++ b/src/resource/CMakeLists.txt
@@ -2,12 +2,20 @@ add_library(CemuResource)
 
 set_property(TARGET CemuResource PROPERTY MSVC_RUNTIME_LIBRARY "MultiThreaded$<$<CONFIG:Debug>:Debug>")
 
+enable_language(ASM)
+
 # icon resources
+target_sources(CemuResource PRIVATE
+embedded/resources.cpp
+embedded/resources.h
+)
+
 if(UNIX)
-	target_sources(CemuResource PRIVATE
-	embedded/resources.cpp
-	embedded/resources.h
-	)
+    if(NOT APPLE)
+        target_sources(CemuResource PRIVATE embedded/fontawesome.S)
+    else()
+        target_sources(CemuResource PRIVATE embedded/fontawesome_macos.S)
+    endif()
 endif()
 
 target_sources(CemuResource PRIVATE CafeDefaultFont.cpp)
diff --git a/src/resource/MacOSXBundleInfo.plist.in b/src/resource/MacOSXBundleInfo.plist.in
new file mode 100644
index 00000000..ccd1c922
--- /dev/null
+++ b/src/resource/MacOSXBundleInfo.plist.in
@@ -0,0 +1,69 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<!DOCTYPE plist PUBLIC "-//Apple Computer//DTD PLIST 1.0//EN" "http://www.apple.com/DTDs/PropertyList-1.0.dtd">
+<plist version="1.0">
+<dict>
+	<key>CFBundleDevelopmentRegion</key>
+	<string>English</string>
+	<key>CFBundleExecutable</key>
+	<string>${MACOSX_BUNDLE_EXECUTABLE_NAME}</string>
+	<key>CFBundleIconFile</key>
+	<string>${MACOSX_BUNDLE_ICON_FILE}</string>
+	<key>CFBundleIdentifier</key>
+	<string>${MACOSX_BUNDLE_GUI_IDENTIFIER}</string>
+	<key>CFBundleInfoDictionaryVersion</key>
+	<string>6.0</string>
+	<key>CFBundleName</key>
+	<string>${MACOSX_BUNDLE_BUNDLE_NAME}</string>
+	<key>CFBundlePackageType</key>
+	<string>APPL</string>
+	<key>CFBundleShortVersionString</key>
+	<string>${MACOSX_BUNDLE_SHORT_VERSION_STRING}</string>
+	<key>CFBundleSignature</key>
+	<string>????</string>
+	<key>CFBundleVersion</key>
+	<string>${MACOSX_BUNDLE_BUNDLE_VERSION}</string>
+	<key>CSResourcesFileMapped</key>
+	<true/>
+	<key>NSHumanReadableCopyright</key>
+	<string>${MACOSX_BUNDLE_COPYRIGHT}</string>
+    	<key>LSApplicationCategoryType</key>
+    	<string>${MACOSX_BUNDLE_CATEGORY}</string>
+     	<key>LSMinimumSystemVersion</key>
+    	<string>${MACOSX_MINIMUM_SYSTEM_VERSION}</string>
+	<key>CFBundleLocalizations</key>
+	<array>
+ 		<string>ca</string>
+   		<string>de</string>
+     		<string>en</string>
+       		<string>es</string>
+		<string>fr</string>
+		<string>he</string>
+		<string>hu</string>
+		<string>it</string>
+		<string>ja</string>
+		<string>ko</string>
+		<string>nb</string>
+		<string>nl</string>
+		<string>pl</string>
+  		<string>pt</string>
+		<string>ru</string>
+  		<string>sv</string>
+    		<string>tr</string>
+      		<string>uk</string>
+		<string>zh</string>
+	</array>
+     	<key>CFBundleDocumentTypes</key>
+	<array>
+		<dict>
+			<key>CFBundleTypeExtensions</key>
+			<array>
+			<string>${MACOSX_BUNDLE_TYPE_EXTENSION}</string>
+			</array>
+			<key>CFBundleTypeName</key>
+			<string>Wii U File</string>
+			<key>CFBundleTypeRole</key>
+			<string>Viewer</string>
+		</dict>
+	</array>
+</dict>
+</plist>
diff --git a/src/resource/cemu.icns b/src/resource/cemu.icns
new file mode 100644
index 00000000..c6d8c5b5
Binary files /dev/null and b/src/resource/cemu.icns differ
diff --git a/src/resource/cemu.rc b/src/resource/cemu.rc
index 9ff27732..6f78bfc3 100644
--- a/src/resource/cemu.rc
+++ b/src/resource/cemu.rc
@@ -73,8 +73,8 @@ END
 #define str(s) #s
 
 VS_VERSION_INFO VERSIONINFO
-FILEVERSION        EMULATOR_VERSION_LEAD, EMULATOR_VERSION_MAJOR, EMULATOR_VERSION_MINOR, 0
-PRODUCTVERSION     EMULATOR_VERSION_LEAD, EMULATOR_VERSION_MAJOR, EMULATOR_VERSION_MINOR, 0
+FILEVERSION        EMULATOR_VERSION_MAJOR, EMULATOR_VERSION_MINOR, EMULATOR_VERSION_PATCH, 0
+PRODUCTVERSION     EMULATOR_VERSION_MAJOR, EMULATOR_VERSION_MINOR, EMULATOR_VERSION_PATCH, 0
  FILEFLAGSMASK 0x3fL
 #ifdef _DEBUG
  FILEFLAGS 0x1L
@@ -94,7 +94,7 @@ BEGIN
             VALUE "LegalCopyright", "Team Cemu"
             VALUE "OriginalFilename", "Cemu.exe"
             VALUE "ProductName", "Cemu"
-        	VALUE "ProductVersion", xstr(EMULATOR_VERSION_LEAD) "." xstr(EMULATOR_VERSION_MAJOR) "." xstr(EMULATOR_VERSION_MINOR) EMULATOR_VERSION_SUFFIX "\0"
+        	VALUE "ProductVersion", xstr(EMULATOR_VERSION_MAJOR) "." xstr(EMULATOR_VERSION_MINOR) "." xstr(EMULATOR_VERSION_PATCH) EMULATOR_VERSION_SUFFIX "\0"
         END
     END
     BLOCK "VarFileInfo"
@@ -109,36 +109,6 @@ END
 // RCDATA
 //
 
-DEBUGGER_BP             RCDATA                  "resource\\debugger\\icons8-full-moon-filled-50.png"
-
-DEBUGGER_BP_RED         RCDATA                  "resource\\debugger\\icons8-full-moon-filled-50-red.png"
-
-DEBUGGER_PAUSE          RCDATA                  "resource\\debugger\\icons8-pause-filled-50.png"
-
-DEBUGGER_PLAY           RCDATA                  "resource\\debugger\\icons8-play-filled-50.png"
-
-DEBUGGER_STEP_INTO      RCDATA                  "resource\\debugger\\icons8-step-into-50.png"
-
-DEBUGGER_STEP_OUT       RCDATA                  "resource\\debugger\\icons8-step-out-50.png"
-
-DEBUGGER_STEP_OVER      RCDATA                  "resource\\debugger\\icons8-step-over-50.png"
-
-DEBUGGER_GOTO           RCDATA                  "resource\\debugger\\icons8-drop-down-50.png"
-
-INPUT_CONNECTED         RCDATA                  "resource\\input\\icons8-connected-50.png"
-
-INPUT_DISCONNECTED      RCDATA                  "resource\\input\\icons8-disconnected-50.png"
-
-INPUT_LOW_BATTERY       RCDATA                  "resource\\input\\icons8-low-battery-30.png"
-
-PNG_HELP                RCDATA                 "resource\\icons8-help-24.png"
-
-PNG_REFRESH             RCDATA                 "resource\\icons8-refresh-32.png"
-
-PNG_ERROR               RCDATA                 "resource\\icons8-error-32.png"
-
-PNG_CHECK_YES           RCDATA                 "resource\\icons8-checkmark-yes-32.png"
-
 IDR_FONTAWESOME         RCDATA                  "resource\\fontawesome-webfont.ttf"
 
 #endif    // Neutral (Default) (unknown sub-lang: 0x8) resources
diff --git a/src/resource/embedded/fontawesome.S b/src/resource/embedded/fontawesome.S
new file mode 100644
index 00000000..db23e7ae
--- /dev/null
+++ b/src/resource/embedded/fontawesome.S
@@ -0,0 +1,9 @@
+.section .rodata,"",%progbits
+.global g_fontawesome_data, g_fontawesome_size
+
+g_fontawesome_data:
+.incbin "fontawesome-webfont.ttf"
+g_fontawesome_size:
+.int g_fontawesome_size - g_fontawesome_data
+
+.section .note.GNU-stack,"",%progbits
\ No newline at end of file
diff --git a/src/resource/embedded/fontawesome_macos.S b/src/resource/embedded/fontawesome_macos.S
new file mode 100644
index 00000000..3faeda9f
--- /dev/null
+++ b/src/resource/embedded/fontawesome_macos.S
@@ -0,0 +1,8 @@
+.section __DATA, __const
+.global _g_fontawesome_data, _g_fontawesome_size
+
+_g_fontawesome_data:
+.incbin "fontawesome-webfont.ttf"
+_g_fontawesome_size:
+.int _g_fontawesome_size - _g_fontawesome_data
+
diff --git a/src/resource/update.sh b/src/resource/update.sh
new file mode 100755
index 00000000..5ff22160
--- /dev/null
+++ b/src/resource/update.sh
@@ -0,0 +1,8 @@
+#!/bin/sh
+
+APP=$(cd "$(dirname "0")"/;pwd)
+hdiutil attach $TMPDIR/cemu_update/cemu.dmg
+cp -rf /Volumes/Cemu/Cemu.app "$APP"
+hdiutil detach /Volumes/Cemu/
+
+open -n -a "$APP/Cemu.app"
diff --git a/src/tools/ShaderCacheMerger.cpp b/src/tools/ShaderCacheMerger.cpp
index 3cf7420d..14a54252 100644
--- a/src/tools/ShaderCacheMerger.cpp
+++ b/src/tools/ShaderCacheMerger.cpp
@@ -1,12 +1,13 @@
 #include "Cemu/FileCache/FileCache.h"
 #include "Cafe/HW/Latte/Core/LatteShaderCache.h"
 #include <regex>
+#include <cinttypes>
 
 void MergeShaderCacheFile(std::string fileName)
 {
 	// parse titleId from fileName
 	uint64 titleId = 0;
-	if (sscanf(fileName.c_str(), "%I64x", &titleId) != 1)
+	if (sscanf(fileName.c_str(), "%" SCNx64, &titleId) != 1)
 		return;
 
 	const std::string mainPath = "shaderCache/transferable/" + fileName;
@@ -26,7 +27,7 @@ void MergeShaderCacheFile(std::string fileName)
 		return;
 	}
 	// begin merging
-	printf("Merging shaders %I64x...", titleId);
+	printf("Merging shaders %" PRIx64 "...", titleId);
 	uint32 numMergedEntries = 0; // number of files added to the main cache file
 	for (sint32 i = 0; i < sourceCache->GetFileCount(); i++)
 	{
@@ -52,7 +53,7 @@ void MergePipelineCacheFile(std::string fileName)
 {
 	// parse titleId from fileName
 	uint64 titleId = 0;
-	if (sscanf(fileName.c_str(), "%I64x", &titleId) != 1)
+	if (sscanf(fileName.c_str(), "%" SCNx64, &titleId) != 1)
 		return;
 
 	const std::string mainPath = "shaderCache/transferable/" + fileName;
@@ -73,7 +74,7 @@ void MergePipelineCacheFile(std::string fileName)
 		return;
 	}
 	// begin merging
-	printf("Merging pipelines %I64x...", titleId);
+	printf("Merging pipelines %" PRIx64 "...", titleId);
 	uint32 numMergedEntries = 0; // number of files added to the main cache file
 	for (sint32 i = 0; i < sourceCache->GetFileCount(); i++)
 	{
diff --git a/src/util/CMakeLists.txt b/src/util/CMakeLists.txt
index 090b2bd1..881b20b6 100644
--- a/src/util/CMakeLists.txt
+++ b/src/util/CMakeLists.txt
@@ -1,9 +1,91 @@
-project(CemuUtil)
+add_library(CemuUtil
+  boost/bluetooth.h
+  bootSound/BootSoundReader.cpp
+  bootSound/BootSoundReader.h
+  ChunkedHeap/ChunkedHeap.h
+  containers/flat_hash_map.hpp
+  containers/IntervalBucketContainer.h
+  containers/LookupTableL3.h
+  containers/RangeStore.h
+  containers/robin_hood.h
+  containers/SmallBitset.h
+  crypto/aes128.cpp
+  crypto/aes128.h
+  crypto/crc32.cpp
+  crypto/crc32.h
+  crypto/md5.cpp
+  crypto/md5.h
+  DXGIWrapper/DXGIWrapper.h
+  EventService.h
+  Fiber/Fiber.h
+  helpers/ClassWrapper.h
+  helpers/ConcurrentQueue.h
+  helpers/enum_array.hpp
+  helpers/fixedSizeList.h
+  helpers/fspinlock.h
+  helpers/helpers.cpp
+  helpers/helpers.h
+  helpers/MapAdaptor.h
+  helpers/MemoryPool.h
+  helpers/ringbuffer.h
+  helpers/Semaphore.h
+  helpers/Serializer.cpp
+  helpers/Serializer.h
+  helpers/Singleton.h
+  helpers/StringBuf.h
+  helpers/StringHelpers.h
+  helpers/StringParser.h
+  helpers/SystemException.h
+  helpers/TempState.h
+  highresolutiontimer/HighResolutionTimer.cpp
+  highresolutiontimer/HighResolutionTimer.h
+  ImageWriter/bmp.h
+  ImageWriter/tga.h
+  IniParser/IniParser.cpp
+  IniParser/IniParser.h
+  libusbWrapper/libusbWrapper.cpp
+  libusbWrapper/libusbWrapper.h
+  math/glm.h
+  math/quaternion.h
+  math/vector2.h
+  math/vector3.h
+  MemMapper/MemMapper.h
+  SystemInfo/SystemInfo.cpp
+  SystemInfo/SystemInfo.h
+  ThreadPool/ThreadPool.h
+  tinyxml2/tinyxml2.cpp
+  tinyxml2/tinyxml2.h
+  VirtualHeap/VirtualHeap.cpp
+  VirtualHeap/VirtualHeap.h
+  Zir/Core/IR.cpp
+  Zir/Core/IR.h
+  Zir/Core/ZirUtility.h
+  Zir/Core/ZpIRBuilder.h
+  Zir/Core/ZpIRDebug.h
+  Zir/Core/ZpIRPasses.h
+  Zir/Core/ZpIRScheduler.h
+  Zir/EmitterGLSL/ZpIREmitGLSL.cpp
+  Zir/EmitterGLSL/ZpIREmitGLSL.h
+  Zir/Passes/RegisterAllocatorForGLSL.cpp
+  Zir/Passes/ZpIRRegisterAllocator.cpp
+)
 
-file(GLOB_RECURSE CPP_FILES *.cpp)
-file(GLOB_RECURSE H_FILES *.h)
-
-add_library(CemuUtil ${CPP_FILES} ${H_FILES})
+if(WIN32)
+	target_sources(CemuUtil PRIVATE Fiber/FiberWin.cpp)
+	target_sources(CemuUtil PRIVATE MemMapper/MemMapperWin.cpp)
+	target_sources(CemuUtil PRIVATE SystemInfo/SystemInfoWin.cpp)
+elseif(UNIX)
+	target_sources(CemuUtil PRIVATE Fiber/FiberUnix.cpp)
+	target_sources(CemuUtil PRIVATE MemMapper/MemMapperUnix.cpp)
+	target_sources(CemuUtil PRIVATE SystemInfo/SystemInfoUnix.cpp)
+	if(NOT APPLE)
+		target_sources(CemuUtil PRIVATE SystemInfo/SystemInfoLinux.cpp)
+	else()
+		target_sources(CemuUtil PRIVATE SystemInfo/SystemInfoMac.cpp)
+	endif()
+else()
+	target_sources(CemuUtil PRIVATE SystemInfo/SystemInfoStub.cpp)
+endif()
 
 set_property(TARGET CemuUtil PROPERTY MSVC_RUNTIME_LIBRARY "MultiThreaded$<$<CONFIG:Debug>:Debug>")
 
diff --git a/src/util/ChunkedHeap/ChunkedHeap.h b/src/util/ChunkedHeap/ChunkedHeap.h
index d2a0a036..21a1b868 100644
--- a/src/util/ChunkedHeap/ChunkedHeap.h
+++ b/src/util/ChunkedHeap/ChunkedHeap.h
@@ -1,35 +1,39 @@
 #pragma once
 
+#include <util/helpers/MemoryPool.h>
+
 struct CHAddr
 {
 	uint32 offset;
 	uint32 chunkIndex;
+	void* internal; // AllocRange
 
-	CHAddr(uint32 _offset, uint32 _chunkIndex) : offset(_offset), chunkIndex(_chunkIndex) {};
+	CHAddr(uint32 _offset, uint32 _chunkIndex, void* internal = nullptr) : offset(_offset), chunkIndex(_chunkIndex), internal(internal) {};
 	CHAddr() : offset(0xFFFFFFFF), chunkIndex(0xFFFFFFFF) {};
 
 	bool isValid() { return chunkIndex != 0xFFFFFFFF; };
 	static CHAddr getInvalid() { return CHAddr(0xFFFFFFFF, 0xFFFFFFFF); };
 };
 
+template<uint32 TMinimumAlignment = 32>
 class ChunkedHeap
 {
-	struct allocRange_t
+	struct AllocRange
 	{
-		allocRange_t* nextFree{};
-		allocRange_t* prevFree{};
-		allocRange_t* prevOrdered{};
-		allocRange_t* nextOrdered{};
+		AllocRange* nextFree{};
+		AllocRange* prevFree{};
+		AllocRange* prevOrdered{};
+		AllocRange* nextOrdered{};
 		uint32 offset;
 		uint32 chunkIndex;
 		uint32 size;
 		bool isFree;
-		allocRange_t(uint32 _offset, uint32 _chunkIndex, uint32 _size, bool _isFree) : offset(_offset), chunkIndex(_chunkIndex), size(_size), isFree(_isFree), nextFree(nullptr) {};
+		AllocRange(uint32 _offset, uint32 _chunkIndex, uint32 _size, bool _isFree) : offset(_offset), chunkIndex(_chunkIndex), size(_size), isFree(_isFree), nextFree(nullptr) {};
 	};
 
-	struct chunk_t
+	struct Chunk
 	{
-		std::unordered_map<uint32, allocRange_t*> map_allocatedRange;
+		uint32 size;
 	};
 
 public:
@@ -47,45 +51,32 @@ public:
 		_free(addr);
 	}
 
-	virtual uint32 allocateNewChunk(uint32 chunkIndex, uint32 minimumAllocationSize)
-	{
-		return 0;
-	}
+	virtual uint32 allocateNewChunk(uint32 chunkIndex, uint32 minimumAllocationSize) = 0;
 
 private:
 	unsigned ulog2(uint32 v)
 	{
-		static const unsigned MUL_DE_BRUIJN_BIT[] =
-		{
-		   0,  9,  1, 10, 13, 21,  2, 29, 11, 14, 16, 18, 22, 25,  3, 30,
-		   8, 12, 20, 28, 15, 17, 24,  7, 19, 27, 23,  6, 26,  5,  4, 31
-		};
-
-		v |= v >> 1;
-		v |= v >> 2;
-		v |= v >> 4;
-		v |= v >> 8;
-		v |= v >> 16;
-
-		return MUL_DE_BRUIJN_BIT[(v * 0x07C4ACDDu) >> 27];
+		cemu_assert_debug(v != 0);
+		return 31 - std::countl_zero(v);
 	}
 
-	void trackFreeRange(allocRange_t* range)
+	void trackFreeRange(AllocRange* range)
 	{
 		// get index of msb
 		cemu_assert_debug(range->size != 0); // size of zero is not allowed
 		uint32 bucketIndex = ulog2(range->size);
-		range->nextFree = bucketFreeRange[bucketIndex];
-		if (bucketFreeRange[bucketIndex])
-			bucketFreeRange[bucketIndex]->prevFree = range;
+		range->nextFree = m_bucketFreeRange[bucketIndex];
+		if (m_bucketFreeRange[bucketIndex])
+			m_bucketFreeRange[bucketIndex]->prevFree = range;
 		range->prevFree = nullptr;
-		bucketFreeRange[bucketIndex] = range;
+		m_bucketFreeRange[bucketIndex] = range;
+		m_bucketUseMask |= (1u << bucketIndex);
 	}
 
-	void forgetFreeRange(allocRange_t* range, uint32 bucketIndex)
+	void forgetFreeRange(AllocRange* range, uint32 bucketIndex)
 	{
-		allocRange_t* prevRange = range->prevFree;
-		allocRange_t* nextRange = range->nextFree;
+		AllocRange* prevRange = range->prevFree;
+		AllocRange* nextRange = range->nextFree;
 		if (prevRange)
 		{
 			prevRange->nextFree = nextRange;
@@ -94,36 +85,42 @@ private:
 		}
 		else
 		{
-			if (bucketFreeRange[bucketIndex] != range)
-				assert_dbg();
-			bucketFreeRange[bucketIndex] = nextRange;
+			cemu_assert_debug(m_bucketFreeRange[bucketIndex] == range);
+			m_bucketFreeRange[bucketIndex] = nextRange;
 			if (nextRange)
 				nextRange->prevFree = nullptr;
+			else
+				m_bucketUseMask &= ~(1u << bucketIndex);
 		}
 	}
 
 	bool allocateChunk(uint32 minimumAllocationSize)
 	{
-		uint32 chunkIndex = (uint32)list_chunks.size();
-		list_chunks.emplace_back(new chunk_t());
+		uint32 chunkIndex = (uint32)m_chunks.size();
+		m_chunks.emplace_back();
 		uint32 chunkSize = allocateNewChunk(chunkIndex, minimumAllocationSize);
+		cemu_assert_debug((chunkSize%TMinimumAlignment) == 0); // chunk size should be a multiple of the minimum alignment
 		if (chunkSize == 0)
 			return false;
-		allocRange_t* range = new allocRange_t(0, chunkIndex, chunkSize, true);
+		cemu_assert_debug(chunkSize < 0x80000000u); // chunk size must be below 2GB
+		AllocRange* range = m_allocEntriesPool.allocObj(0, chunkIndex, chunkSize, true);
 		trackFreeRange(range);
-		numHeapBytes += chunkSize;
+		m_numHeapBytes += chunkSize;
 		return true;
 	}
 
-	void _allocFrom(allocRange_t* range, uint32 bucketIndex, uint32 allocOffset, uint32 allocSize)
+	void _allocFrom(AllocRange* range, uint32 bucketIndex, uint32 allocOffset, uint32 allocSize)
 	{
+		cemu_assert_debug(allocSize > 0);
 		// remove the range from the chain of free ranges
 		forgetFreeRange(range, bucketIndex);
 		// split head, allocation and tail into separate ranges
-		if (allocOffset > range->offset)
+		uint32 headBytes = allocOffset - range->offset;
+		if (headBytes > 0)
 		{
 			// alignment padding -> create free range
-			allocRange_t* head = new allocRange_t(range->offset, range->chunkIndex, allocOffset - range->offset, true);
+			cemu_assert_debug(headBytes >= TMinimumAlignment);
+			AllocRange* head = m_allocEntriesPool.allocObj(range->offset, range->chunkIndex, headBytes, true);
 			trackFreeRange(head);
 			if (range->prevOrdered)
 				range->prevOrdered->nextOrdered = head;
@@ -131,10 +128,12 @@ private:
 			head->nextOrdered = range;
 			range->prevOrdered = head;
 		}
-		if ((allocOffset + allocSize) < (range->offset + range->size)) // todo - create only if it's more than a couple of bytes?
+		uint32 tailBytes = (range->offset + range->size) - (allocOffset + allocSize);
+		if (tailBytes > 0)
 		{
 			// tail -> create free range
-			allocRange_t* tail = new allocRange_t((allocOffset + allocSize), range->chunkIndex, (range->offset + range->size) - (allocOffset + allocSize), true);
+			cemu_assert_debug(tailBytes >= TMinimumAlignment);
+			AllocRange* tail = m_allocEntriesPool.allocObj((allocOffset + allocSize), range->chunkIndex, tailBytes, true);
 			trackFreeRange(tail);
 			if (range->nextOrdered)
 				range->nextOrdered->prevOrdered = tail;
@@ -149,36 +148,51 @@ private:
 
 	CHAddr _alloc(uint32 size, uint32 alignment)
 	{
+		cemu_assert_debug(size <= (0x7FFFFFFFu-TMinimumAlignment));
+		// make sure size is not zero and align it
+		if(size == 0) [[unlikely]]
+			size = TMinimumAlignment;
+		else
+			size = (size + (TMinimumAlignment - 1)) & ~(TMinimumAlignment - 1);
 		// find smallest bucket to scan
 		uint32 alignmentM1 = alignment - 1;
 		uint32 bucketIndex = ulog2(size);
-		while (bucketIndex < 32)
+		// check if the bucket is available
+		if( !(m_bucketUseMask & (1u << bucketIndex)) )
 		{
-			allocRange_t* range = bucketFreeRange[bucketIndex];
+			// skip to next non-empty bucket
+			uint32 nextIndex = BSF(m_bucketUseMask>>bucketIndex);
+			bucketIndex += nextIndex;
+		}
+		while (bucketIndex < 31)
+		{
+			AllocRange* range = m_bucketFreeRange[bucketIndex];
 			while (range)
 			{
 				if (range->size >= size)
 				{
 					// verify if aligned allocation fits
 					uint32 alignedOffset = (range->offset + alignmentM1) & ~alignmentM1;
-					uint32 alignmentLoss = alignedOffset - range->offset;
-					if (alignmentLoss < range->size && (range->size - alignmentLoss) >= size)
+					uint32 endOffset = alignedOffset + size;
+					if((range->offset+range->size) >= endOffset)
 					{
 						_allocFrom(range, bucketIndex, alignedOffset, size);
-						list_chunks[range->chunkIndex]->map_allocatedRange.emplace(alignedOffset, range);
-						numAllocatedBytes += size;
-						return CHAddr(alignedOffset, range->chunkIndex);
+						m_numAllocatedBytes += size;
+						return CHAddr(alignedOffset, range->chunkIndex, range);
 					}
 				}
 				range = range->nextFree;
 			}
-			bucketIndex++; // try higher bucket
+			// check next non-empty bucket or skip to end
+			bucketIndex++;
+			uint32 emptyBuckets = BSF(m_bucketUseMask>>bucketIndex);
+			bucketIndex += emptyBuckets;
 		}
-		if(allocationLimitReached)
+		if(m_allocationLimitReached)
 			return CHAddr(0xFFFFFFFF, 0xFFFFFFFF);
 		if (!allocateChunk(size))
 		{
-			allocationLimitReached = true;
+			m_allocationLimitReached = true;
 			return CHAddr(0xFFFFFFFF, 0xFFFFFFFF);
 		}
 		return _alloc(size, alignment);
@@ -186,24 +200,16 @@ private:
 
 	void _free(CHAddr addr)
 	{
-		auto it = list_chunks[addr.chunkIndex]->map_allocatedRange.find(addr.offset);
-		if (it == list_chunks[addr.chunkIndex]->map_allocatedRange.end())
+		if(!addr.internal)
 		{
-			forceLog_printf("Internal heap error. %08x %08x", addr.chunkIndex, addr.offset);
-			forceLog_printf("Debug info:");
-			for (auto& rangeItr : list_chunks[addr.chunkIndex]->map_allocatedRange)
-			{
-				forceLog_printf("%08x %08x", rangeItr.second->offset, rangeItr.second->size);
-			}
+			cemuLog_log(LogType::Force, "Internal heap error. {:08x} {:08x}", addr.chunkIndex, addr.offset);
 			return;
 		}
-
-		allocRange_t* range = it->second;
-		numAllocatedBytes -= it->second->size;
-		list_chunks[range->chunkIndex]->map_allocatedRange.erase(it);
+		AllocRange* range = (AllocRange*)addr.internal;
+		m_numAllocatedBytes -= range->size;
 		// try merge left or right
-		allocRange_t* prevRange = range->prevOrdered;
-		allocRange_t* nextRange = range->nextOrdered;
+		AllocRange* prevRange = range->prevOrdered;
+		AllocRange* nextRange = range->nextOrdered;
 		if (prevRange && prevRange->isFree)
 		{
 			if (nextRange && nextRange->isFree)
@@ -216,8 +222,8 @@ private:
 				forgetFreeRange(prevRange, ulog2(prevRange->size));
 				prevRange->size = newSize;
 				trackFreeRange(prevRange);
-				delete range;
-				delete nextRange;
+				m_allocEntriesPool.freeObj(range);
+				m_allocEntriesPool.freeObj(nextRange);
 			}
 			else
 			{
@@ -228,7 +234,7 @@ private:
 				forgetFreeRange(prevRange, ulog2(prevRange->size));
 				prevRange->size = newSize;
 				trackFreeRange(prevRange);
-				delete range;
+				m_allocEntriesPool.freeObj(range);
 			}
 		}
 		else if (nextRange && nextRange->isFree)
@@ -242,7 +248,7 @@ private:
 				range->prevOrdered->nextOrdered = nextRange;
 			nextRange->prevOrdered = range->prevOrdered;
 			trackFreeRange(nextRange);
-			delete range;
+			m_allocEntriesPool.freeObj(range);
 		}
 		else
 		{
@@ -265,7 +271,7 @@ private:
 
 		for (uint32 i = 0; i < 32; i++)
 		{
-			allocRange_t* ar = bucketFreeRange[i];
+			AllocRange* ar = m_bucketFreeRange[i];
 			while (ar)
 			{
 				availableRange_t dbgRange;
@@ -278,7 +284,7 @@ private:
 					if (itr.chunkIndex != dbgRange.chunkIndex)
 						continue;
 					if (itr.offset < (dbgRange.offset + dbgRange.size) && (itr.offset + itr.size) >(dbgRange.offset))
-						assert_dbg();
+						cemu_assert_error();
 				}
 
 				availRanges.emplace_back(dbgRange);
@@ -290,14 +296,16 @@ private:
 	}
 
 private:
-	std::vector<chunk_t*> list_chunks;
-	allocRange_t* bucketFreeRange[32]{};
-	bool allocationLimitReached = false;
+	std::vector<Chunk> m_chunks;
+	uint32 m_bucketUseMask{0x80000000}; // bitmask indicating non-empty buckets. MSB always set to provide an upper bound for BSF instruction
+	AllocRange* m_bucketFreeRange[32]{}; // we are only using 31 entries since the MSB is reserved (thus chunks equal or larger than 2^31 are not allowed)
+	bool m_allocationLimitReached = false;
+	MemoryPool<AllocRange> m_allocEntriesPool{64};
 
 public:
 	// statistics
-	uint32 numHeapBytes{}; // total size of the heap
-	uint32 numAllocatedBytes{};
+	uint32 m_numHeapBytes{}; // total size of the heap
+	uint32 m_numAllocatedBytes{};
 };
 
 class VGenericHeap
@@ -489,6 +497,11 @@ private:
 
 	bool _alloc(uint32 size, uint32 alignment, uint32& allocOffsetOut)
 	{
+		if(size == 0)
+		{
+			size = 1; // zero-sized allocations are not supported
+			cemu_assert_suspicious();
+		}
 		// find smallest bucket to scan
 		uint32 alignmentM1 = alignment - 1;
 		uint32 bucketIndex = ulog2(size);
@@ -521,7 +534,10 @@ private:
 	{
 		auto it = map_allocatedRange.find(addrOffset);
 		if (it == map_allocatedRange.end())
-			assert_dbg();
+		{
+			cemuLog_log(LogType::Force, "VHeap internal error");
+			cemu_assert(false);
+		}
 		allocRange_t* range = it->second;
 		map_allocatedRange.erase(it);
 		m_statsMemAllocated -= range->size;
@@ -625,7 +641,7 @@ public:
 
 	uint32 getCurrentBlockOffset() const { return m_currentBlockOffset; }
 	uint8* getCurrentBlockPtr() const { return m_currentBlockPtr; }
-	
+
 private:
 	void allocateAdditionalChunk()
 	{
@@ -638,4 +654,4 @@ private:
 	uint8* m_currentBlockPtr{};
 	uint32 m_currentBlockOffset{};
 	std::vector<void*> m_allocatedBlocks;
-};
\ No newline at end of file
+};
diff --git a/src/util/DXGIWrapper/DXGIWrapper.h b/src/util/DXGIWrapper/DXGIWrapper.h
index 54f2454d..363733e7 100644
--- a/src/util/DXGIWrapper/DXGIWrapper.h
+++ b/src/util/DXGIWrapper/DXGIWrapper.h
@@ -1,7 +1,7 @@
 #pragma once
 
 #include <dxgi1_4.h>
-//#include <atlbase.h>
+#include <wrl/client.h>
 
 class DXGIWrapper
 {
@@ -23,34 +23,28 @@ public:
 			throw std::runtime_error("can't find CreateDXGIFactory1 in dxgi module");
 		}
 
-		IDXGIFactory1* dxgiFactory = nullptr;
+		Microsoft::WRL::ComPtr<IDXGIFactory1> dxgiFactory;
 		pCreateDXGIFactory1(IID_PPV_ARGS(&dxgiFactory));
 
-		IDXGIAdapter1* tmpDxgiAdapter = nullptr;
+		Microsoft::WRL::ComPtr<IDXGIAdapter1> dxgiAdapter;
 		UINT adapterIndex = 0;
-		while (dxgiFactory->EnumAdapters1(adapterIndex, &tmpDxgiAdapter) != DXGI_ERROR_NOT_FOUND)
+		while (dxgiFactory->EnumAdapters1(adapterIndex, &dxgiAdapter) != DXGI_ERROR_NOT_FOUND)
 		{
 			DXGI_ADAPTER_DESC1 desc;
-			tmpDxgiAdapter->GetDesc1(&desc);
+			dxgiAdapter->GetDesc1(&desc);
 
 			if (deviceLUID == nullptr || memcmp(&desc.AdapterLuid, deviceLUID, sizeof(LUID)) == 0)
 			{
-				tmpDxgiAdapter->QueryInterface(IID_PPV_ARGS(&m_dxgiAdapter));
-				tmpDxgiAdapter->Release();
+				if (FAILED(dxgiAdapter.As(&m_dxgiAdapter)))
+				{
+					Cleanup();
+					throw std::runtime_error("can't create dxgi adapter");
+				}
 				break;
 			}
 
-			tmpDxgiAdapter->Release();
 			++adapterIndex;
 		}
-
-		dxgiFactory->Release();
-
-		if (!m_dxgiAdapter)
-		{
-			Cleanup();
-			throw std::runtime_error("can't create dxgi adapter");
-		}
 	}
 
 	~DXGIWrapper()
@@ -65,15 +59,11 @@ public:
 
 private:
 	HMODULE m_moduleHandle = nullptr;
-	IDXGIAdapter3* m_dxgiAdapter = nullptr;
+	Microsoft::WRL::ComPtr<IDXGIAdapter3> m_dxgiAdapter;
 
 	void Cleanup()
 	{
-		if (m_dxgiAdapter)
-		{
-			m_dxgiAdapter->Release();
-			m_dxgiAdapter = nullptr;
-		}
+		m_dxgiAdapter.Reset();
 
 		if (m_moduleHandle)
 		{
@@ -81,4 +71,4 @@ private:
 			m_moduleHandle = nullptr;
 		}
 	}
-};
\ No newline at end of file
+};
diff --git a/src/util/EventService.h b/src/util/EventService.h
index b1a3e750..4fe1737a 100644
--- a/src/util/EventService.h
+++ b/src/util/EventService.h
@@ -56,7 +56,7 @@ public:
 		}
 		catch (const std::exception& ex)
 		{
-			cemuLog_force("error when signaling {}: {}", event, ex.what());
+			cemuLog_log(LogType::Force, "error when signaling {}: {}", event, ex.what());
 		}
 	}
 
diff --git a/src/util/Fiber/FiberUnix.cpp b/src/util/Fiber/FiberUnix.cpp
index c2ced28b..36430449 100644
--- a/src/util/Fiber/FiberUnix.cpp
+++ b/src/util/Fiber/FiberUnix.cpp
@@ -1,6 +1,6 @@
 #include "Fiber.h"
-#if BOOST_OS_LINUX || BOOST_OS_MACOS
 #include <ucontext.h>
+#include <atomic>
 
 thread_local Fiber* sCurrentFiber{};
 
@@ -15,7 +15,12 @@ Fiber::Fiber(void(*FiberEntryPoint)(void* userParam), void* userParam, void* pri
 	ctx->uc_stack.ss_sp = m_stackPtr;
 	ctx->uc_stack.ss_size = stackSize;
 	ctx->uc_link = &ctx[0];
+#ifdef __arm64__
+	// https://www.man7.org/linux/man-pages/man3/makecontext.3.html#NOTES
+	makecontext(ctx, (void(*)())FiberEntryPoint, 2, (uint64) userParam >> 32, userParam);
+#else
 	makecontext(ctx, (void(*)())FiberEntryPoint, 1, userParam);
+#endif
 	this->m_implData = (void*)ctx;
 }
 
@@ -45,12 +50,12 @@ void Fiber::Switch(Fiber& targetFiber)
 {
     Fiber* leavingFiber = sCurrentFiber;
     sCurrentFiber = &targetFiber;
+	std::atomic_thread_fence(std::memory_order_seq_cst);
 	swapcontext((ucontext_t*)(leavingFiber->m_implData), (ucontext_t*)(targetFiber.m_implData));
+	std::atomic_thread_fence(std::memory_order_seq_cst);
 }
 
 void* Fiber::GetFiberPrivateData()
 {
 	return sCurrentFiber->m_privateData;
 }
-
-#endif
\ No newline at end of file
diff --git a/src/util/Fiber/FiberWin.cpp b/src/util/Fiber/FiberWin.cpp
index af7df700..ae5da517 100644
--- a/src/util/Fiber/FiberWin.cpp
+++ b/src/util/Fiber/FiberWin.cpp
@@ -1,5 +1,4 @@
 #include "Fiber.h"
-#if BOOST_OS_WINDOWS
 #include <Windows.h>
 
 thread_local Fiber* sCurrentFiber{};
@@ -39,5 +38,3 @@ void* Fiber::GetFiberPrivateData()
 {
 	return sCurrentFiber->m_privateData;
 }
-
-#endif
\ No newline at end of file
diff --git a/src/util/IniParser/IniParser.cpp b/src/util/IniParser/IniParser.cpp
index 70499a1f..881ebec7 100644
--- a/src/util/IniParser/IniParser.cpp
+++ b/src/util/IniParser/IniParser.cpp
@@ -259,5 +259,5 @@ std::span<std::pair<std::string_view, std::string_view>> IniParser::GetAllOption
 void IniParser::PrintWarning(int lineNumber, std::string_view msg, std::string_view lineView)
 {
 	// INI logging is silenced
-	// cemuLog_force("File: {} Line {}: {}", m_name, lineNumber, msg);
+	// cemuLog_log(LogType::Force, "File: {} Line {}: {}", m_name, lineNumber, msg);
 }
\ No newline at end of file
diff --git a/src/util/MemMapper/MemMapperUnix.cpp b/src/util/MemMapper/MemMapperUnix.cpp
index 0ea52aa0..8e800e53 100644
--- a/src/util/MemMapper/MemMapperUnix.cpp
+++ b/src/util/MemMapper/MemMapperUnix.cpp
@@ -1,6 +1,5 @@
 #include "util/MemMapper/MemMapper.h"
 
-#if BOOST_OS_LINUX || BOOST_OS_MACOS
 #include <unistd.h>
 #include <sys/mman.h>
 
@@ -46,7 +45,11 @@ namespace MemMapper
 		void* r;
 		if(fromReservation)
 		{
-			if( mprotect(baseAddr, size, GetProt(permissionFlags)) == 0 )
+		    uint64 page_size = sysconf(_SC_PAGESIZE);
+		    void* page = baseAddr;
+		    if ( (uint64) baseAddr % page_size != 0 )
+		        page = (void*) ((uint64)baseAddr & ~(page_size - 1));
+			if( mprotect(page, size, GetProt(permissionFlags)) == 0 )
                 r = baseAddr;
 			else
                 r = nullptr;
@@ -65,5 +68,3 @@ namespace MemMapper
 	}
 
 };
-
-#endif
\ No newline at end of file
diff --git a/src/util/MemMapper/MemMapperWin.cpp b/src/util/MemMapper/MemMapperWin.cpp
index 5c07949f..0e8d3496 100644
--- a/src/util/MemMapper/MemMapperWin.cpp
+++ b/src/util/MemMapper/MemMapperWin.cpp
@@ -1,7 +1,5 @@
 #include "util/MemMapper/MemMapper.h"
 
-#if BOOST_OS_WINDOWS
-
 #include <Windows.h>
 
 namespace MemMapper
@@ -63,5 +61,3 @@ namespace MemMapper
 	}
 
 };
-
-#endif
\ No newline at end of file
diff --git a/src/util/ScreenSaver/ScreenSaver.h b/src/util/ScreenSaver/ScreenSaver.h
new file mode 100644
index 00000000..45291122
--- /dev/null
+++ b/src/util/ScreenSaver/ScreenSaver.h
@@ -0,0 +1,40 @@
+#include "Cemu/Logging/CemuLogging.h"
+#include <SDL2/SDL.h>
+
+class ScreenSaver
+{
+public:
+  static void SetInhibit(bool inhibit)
+  {
+	  // temporary workaround because feature crashes on macOS
+#if BOOST_OS_MACOS
+	  return;
+#endif
+    // Initialize video subsystem if necessary
+    if (SDL_WasInit(SDL_INIT_VIDEO) == 0)
+    {
+      int initErr = SDL_InitSubSystem(SDL_INIT_VIDEO);
+      if (initErr)
+      {
+        cemuLog_log(LogType::Force, "Could not disable screen saver (SDL video subsystem initialization error)");
+      }
+    }
+    // Toggle SDL's screen saver inhibition
+    if (inhibit)
+    {
+      SDL_DisableScreenSaver();
+      if (SDL_IsScreenSaverEnabled() == SDL_TRUE)
+      {
+        cemuLog_log(LogType::Force, "Could not verify if screen saver was disabled (`SDL_IsScreenSaverEnabled()` returned SDL_TRUE)");
+      }
+    }
+    else
+    {
+      SDL_EnableScreenSaver();
+      if (SDL_IsScreenSaverEnabled() == SDL_FALSE)
+      {
+        cemuLog_log(LogType::Force, "Could not verify if screen saver was re-enabled (`SDL_IsScreenSaverEnabled()` returned SDL_FALSE)");
+      }
+    }
+  };
+};
diff --git a/src/util/SystemInfo/SystemInfo.cpp b/src/util/SystemInfo/SystemInfo.cpp
new file mode 100644
index 00000000..afda4e8b
--- /dev/null
+++ b/src/util/SystemInfo/SystemInfo.cpp
@@ -0,0 +1,34 @@
+#include "util/SystemInfo/SystemInfo.h"
+
+uint64 ProcessorTime::work()
+{
+	return user + kernel;
+}
+
+uint64 ProcessorTime::total()
+{
+	return idle + user + kernel;
+}
+
+double ProcessorTime::Compare(ProcessorTime &last, ProcessorTime &now)
+{
+	auto dwork = now.work() - last.work();
+	auto dtotal = now.total() - last.total();
+
+	return (double)dwork / dtotal;
+}
+
+uint32 GetProcessorCount()
+{
+	return std::thread::hardware_concurrency();
+}
+
+void QueryProcTime(ProcessorTime &out)
+{
+	uint64 now, user, kernel;
+	QueryProcTime(now, user, kernel);
+
+	out.idle = now - (user + kernel);
+	out.kernel = kernel;
+	out.user = user;
+}
\ No newline at end of file
diff --git a/src/util/SystemInfo/SystemInfo.h b/src/util/SystemInfo/SystemInfo.h
new file mode 100644
index 00000000..72ce98db
--- /dev/null
+++ b/src/util/SystemInfo/SystemInfo.h
@@ -0,0 +1,17 @@
+#pragma once
+
+struct ProcessorTime
+{
+	uint64 idle{}, kernel{}, user{};
+	
+	uint64 work();
+	uint64 total();
+
+	static double Compare(ProcessorTime &last, ProcessorTime &now);
+};
+
+uint32 GetProcessorCount();
+uint64 QueryRamUsage();
+void QueryProcTime(uint64 &out_now, uint64 &out_user, uint64 &out_kernel);
+void QueryProcTime(ProcessorTime &out);
+void QueryCoreTimes(uint32 count, std::vector<ProcessorTime>& out);
diff --git a/src/util/SystemInfo/SystemInfoLinux.cpp b/src/util/SystemInfo/SystemInfoLinux.cpp
new file mode 100644
index 00000000..a84b4eeb
--- /dev/null
+++ b/src/util/SystemInfo/SystemInfoLinux.cpp
@@ -0,0 +1,48 @@
+#include "util/SystemInfo/SystemInfo.h"
+
+#include <unistd.h>
+
+uint64 QueryRamUsage()
+{
+	static long page_size = sysconf(_SC_PAGESIZE);
+	if (page_size == -1)
+	{
+		return 0;
+	}
+
+	std::ifstream file("/proc/self/statm");
+	if (file)
+	{
+		file.ignore(std::numeric_limits<std::streamsize>::max(), ' ');
+		uint64 pages;
+		file >> pages;
+
+		return pages * page_size;
+	}
+	return 0;
+}
+
+void QueryCoreTimes(uint32 count, std::vector<ProcessorTime>& out)
+{
+	std::ifstream file("/proc/stat");
+	if (file)
+	{
+		file.ignore(std::numeric_limits<std::streamsize>::max(), '\n');
+
+		for (auto i = 0; i < out.size(); ++i)
+		{
+			uint64 user, nice, kernel, idle;
+			file.ignore(std::numeric_limits<std::streamsize>::max(), ' ');
+			file >> user >> nice >> kernel >> idle;
+			file.ignore(std::numeric_limits<std::streamsize>::max(), '\n');
+
+			out[i].idle = idle;
+			out[i].kernel = kernel;
+			out[i].user = user + nice;
+		}
+	}
+	else
+	{
+		for (auto i = 0; i < count; ++i) out[i] = { };
+	}
+}
diff --git a/src/util/SystemInfo/SystemInfoMac.cpp b/src/util/SystemInfo/SystemInfoMac.cpp
new file mode 100644
index 00000000..7be45677
--- /dev/null
+++ b/src/util/SystemInfo/SystemInfoMac.cpp
@@ -0,0 +1,62 @@
+#include "util/SystemInfo/SystemInfo.h"
+
+#include <unistd.h>
+#include <sys/resource.h>
+#include <sys/sysctl.h>
+#include <sys/types.h>
+#include <mach/mach.h>
+
+#include <mach/processor_info.h>
+#include <mach/mach_host.h>
+#include <mach/kern_return.h>
+
+// borrowed from https://en.wikichip.org/wiki/resident_set_size#OS_X
+uint64 QueryRamUsage()
+{
+	mach_task_basic_info info;
+	mach_msg_type_number_t count = MACH_TASK_BASIC_INFO_COUNT;
+	if (task_info(mach_task_self(), MACH_TASK_BASIC_INFO, (task_info_t)&info, &count) == KERN_SUCCESS)
+		return info.resident_size;
+	return 0;
+}
+
+// apple official documentation is non-existsent.
+// based on https://github.com/giampaolo/psutil/blob/master/psutil/_psutil_osx.c#L623
+void QueryCoreTimes(uint32 count, std::vector<ProcessorTime>& out)
+{
+	// initialize default
+	for (auto i = 0; i < out.size(); ++i)
+	{
+		out[i] = {};
+	}
+
+	natural_t cpu_count;
+	processor_info_array_t info_array;
+	mach_msg_type_number_t info_count;
+	kern_return_t error;
+
+	mach_port_t host_port = mach_host_self();
+	error = host_processor_info(host_port, PROCESSOR_CPU_LOAD_INFO, &cpu_count, &info_array, &info_count);
+	mach_port_deallocate(mach_task_self(), host_port);
+
+	if (error != KERN_SUCCESS)
+		return;
+
+	processor_cpu_load_info_data_t* cpuLoad = (processor_cpu_load_info_data_t*) info_array;
+
+	for (auto i = 0; i < cpu_count; ++i)
+	{
+		uint64 system = cpuLoad[i].cpu_ticks[CPU_STATE_SYSTEM];
+		uint64 user = cpuLoad[i].cpu_ticks[CPU_STATE_USER] + cpuLoad[i].cpu_ticks[CPU_STATE_NICE];
+		uint64 idle = cpuLoad[i].cpu_ticks[CPU_STATE_IDLE];
+
+		out[i].idle = idle;
+		out[i].kernel = system;
+		out[i].user = user;
+	}
+
+	int ret = vm_deallocate(mach_task_self(), (vm_address_t) info_array,
+						info_count * sizeof(int));
+	if (ret != KERN_SUCCESS)
+		cemuLog_log(LogType::Force, "vm_deallocate() failed");
+}
diff --git a/src/util/SystemInfo/SystemInfoStub.cpp b/src/util/SystemInfo/SystemInfoStub.cpp
new file mode 100644
index 00000000..b6d1fc84
--- /dev/null
+++ b/src/util/SystemInfo/SystemInfoStub.cpp
@@ -0,0 +1,21 @@
+#include "util/SystemInfo/SystemInfo.h"
+
+uint64 QueryRamUsage()
+{
+	return 0;
+}
+
+void QueryProcTime(uint64 &out_now, uint64 &out_user, uint64 &out_kernel)
+{
+	out_now = 0;
+	out_user = 0;
+	out_kernel = 0;
+}
+
+void QueryCoreTimes(uint32 count, std::vector<ProcessorTime>& out)
+{
+	for (auto i = 0; i < out.size(); ++i)
+	{
+		out[i] = { };
+	}
+}
diff --git a/src/util/SystemInfo/SystemInfoUnix.cpp b/src/util/SystemInfo/SystemInfoUnix.cpp
new file mode 100644
index 00000000..87bd9f8c
--- /dev/null
+++ b/src/util/SystemInfo/SystemInfoUnix.cpp
@@ -0,0 +1,15 @@
+#include "util/SystemInfo/SystemInfo.h"
+
+#include <sys/times.h>
+
+void QueryProcTime(uint64 &out_now, uint64 &out_user, uint64 &out_kernel)
+{
+	struct tms time_info;
+	clock_t clock_now = times(&time_info);
+	clock_t clock_user = time_info.tms_utime;
+	clock_t clock_kernel = time_info.tms_stime;
+	out_now = static_cast<uint64>(clock_now);
+	out_user = static_cast<uint64>(clock_user);
+	out_kernel = static_cast<uint64>(clock_kernel);
+}
+
diff --git a/src/util/SystemInfo/SystemInfoWin.cpp b/src/util/SystemInfo/SystemInfoWin.cpp
new file mode 100644
index 00000000..137e11b7
--- /dev/null
+++ b/src/util/SystemInfo/SystemInfoWin.cpp
@@ -0,0 +1,69 @@
+#include "util/SystemInfo/SystemInfo.h"
+
+#include <Psapi.h>
+#include <winternl.h>
+#pragma comment(lib, "ntdll.lib")
+
+uint64 QueryRamUsage()
+{
+	PROCESS_MEMORY_COUNTERS pmc{};
+	pmc.cb = sizeof(pmc);
+	if (GetProcessMemoryInfo(GetCurrentProcess(), &pmc, sizeof(pmc)))
+	{
+		return pmc.WorkingSetSize;
+	}
+	else
+	{
+		return 0;
+	}
+}
+
+void QueryProcTime(uint64 &out_now, uint64 &out_user, uint64 &out_kernel)
+{
+	FILETIME ftime, fkernel, fuser;
+	LARGE_INTEGER now, kernel, user;
+	GetSystemTimeAsFileTime(&ftime);
+	now.LowPart = ftime.dwLowDateTime;
+	now.HighPart = ftime.dwHighDateTime;
+
+	if (GetProcessTimes(GetCurrentProcess(), &ftime, &ftime, &fkernel, &fuser))
+	{
+		kernel.LowPart = fkernel.dwLowDateTime;
+		kernel.HighPart = fkernel.dwHighDateTime;
+
+		user.LowPart = fuser.dwLowDateTime;
+		user.HighPart = fuser.dwHighDateTime;
+
+		out_now = now.QuadPart;
+		out_user = user.QuadPart;
+		out_kernel = kernel.QuadPart;
+	}
+	else
+	{
+		out_now = 0;
+		out_user = 0;
+		out_kernel = 0;
+	}
+}
+
+void QueryCoreTimes(uint32 count, std::vector<ProcessorTime>& out)
+{
+	std::vector<SYSTEM_PROCESSOR_PERFORMANCE_INFORMATION> sppi(count);
+	if (NT_SUCCESS(NtQuerySystemInformation(SystemProcessorPerformanceInformation, sppi.data(), sizeof(SYSTEM_PROCESSOR_PERFORMANCE_INFORMATION) * count, nullptr)))
+	{
+		for (auto i = 0; i < out.size(); ++i)
+		{
+			out[i].idle = sppi[i].IdleTime.QuadPart;
+			out[i].kernel = sppi[i].KernelTime.QuadPart;
+			out[i].kernel -= out[i].idle;
+			out[i].user = sppi[i].UserTime.QuadPart;
+		}
+	}
+	else
+	{
+		for (auto i = 0; i < count; ++i)
+		{
+			out[i] = { };
+		}
+	}
+}
diff --git a/src/util/VirtualHeap/VirtualHeap.cpp b/src/util/VirtualHeap/VirtualHeap.cpp
index c659c853..9f122cb1 100644
--- a/src/util/VirtualHeap/VirtualHeap.cpp
+++ b/src/util/VirtualHeap/VirtualHeap.cpp
@@ -26,7 +26,7 @@ VirtualBufferHeapEntry_t* virtualBufferHeap_createEntry(VirtualBufferHeap_t* buf
 	VirtualBufferHeapEntry_t* newEntry = bufferHeap->firstUnusedEntry;
 	if (newEntry == nullptr)
 	{
-		forceLog_printf("virtualBufferHeap_createEntry: Pool empty");
+		cemuLog_log(LogType::Force, "virtualBufferHeap_createEntry: Pool empty");
 		cemu_assert_suspicious();
 	}
 	bufferHeap->firstUnusedEntry = newEntry->next;
@@ -157,4 +157,4 @@ void virtualBufferHeap_freeAddr(VirtualBufferHeap_t* bufferHeap, void* addr)
 		entry = entry->next;
 	}
 	cemu_assert_suspicious();
-}
\ No newline at end of file
+}
diff --git a/src/util/Zir/Core/IR.cpp b/src/util/Zir/Core/IR.cpp
index 9e1e3e8b..60067c01 100644
--- a/src/util/Zir/Core/IR.cpp
+++ b/src/util/Zir/Core/IR.cpp
@@ -207,11 +207,11 @@ namespace ZpIR
 		// print imports
 		printf("Imports:\n");
 		for(auto itr : block->m_imports)
-			printf("   reg: %s sym:0x%lux\n", getRegisterName(block, itr.reg).c_str(), itr.name);
+			printf("   reg: %s sym:0x%llx\n", getRegisterName(block, itr.reg).c_str(), itr.name);
 		// print exports
 		printf("Exports:\n");
 		for (auto itr : block->m_exports)
-			printf("   reg: %s sym:0x%lux\n", getRegisterName(block, itr.reg).c_str(), itr.name);
+			printf("   reg: %s sym:0x%llx\n", getRegisterName(block, itr.reg).c_str(), itr.name);
 		// print instructions
 		printf("Assembly:\n");
 		IR::__InsBase* instruction = block->m_instructionFirst;
diff --git a/src/util/Zir/Core/IR.h b/src/util/Zir/Core/IR.h
index 71191024..a59c7837 100644
--- a/src/util/Zir/Core/IR.h
+++ b/src/util/Zir/Core/IR.h
@@ -289,7 +289,7 @@ namespace ZpIR
 	// IR register constant definition stored in basic block
 	struct IRRegConstDef
 	{
-		IRRegConstDef() {};
+		IRRegConstDef() = default;
 		// todo - support for constants with more than one element?
 
 		IRRegConstDef& setU32(uint32 v) { value_u32 = v; type = DataType::U32; return *this; };
@@ -513,7 +513,7 @@ namespace ZpIR
 				LOC_TYPE_ATTRIBUTE = 3,
 			};
 		public:
-			ShaderImportLocation() {}
+			ShaderImportLocation() = default;
 			ShaderImportLocation(LocationSymbolName loc) 
 			{
 				uint64 v = (uint64)loc;
@@ -598,7 +598,7 @@ namespace ZpIR
 				LOC_TYPE_OUTPUT = 2,
 			};
 		public:
-			ShaderExportLocation() {}
+			ShaderExportLocation() = default;
 			ShaderExportLocation(LocationSymbolName loc)
 			{
 				uint64 v = (uint64)loc;
diff --git a/src/util/Zir/EmitterGLSL/ZpIREmitGLSL.cpp b/src/util/Zir/EmitterGLSL/ZpIREmitGLSL.cpp
index 0b0c2dc5..d20adc60 100644
--- a/src/util/Zir/EmitterGLSL/ZpIREmitGLSL.cpp
+++ b/src/util/Zir/EmitterGLSL/ZpIREmitGLSL.cpp
@@ -12,9 +12,7 @@ class DualStringBuffer
 public:
 	DualStringBuffer() : m_offsetBegin(N / 2), m_offsetEnd(N / 2) { }
 
-	~DualStringBuffer()
-	{
-	}
+	~DualStringBuffer() = default;
 
 	static_assert(sizeof(char) == sizeof(uint8));
 
@@ -97,7 +95,7 @@ namespace ZirEmitter
 	void GLSL::GenerateBasicBlockCode(ZpIR::ZpIRBasicBlock& basicBlock)
 	{
 		// init context		
-#ifndef PUBLIC_RELEASE
+#ifdef CEMU_DEBUG_ASSERT
 		for (auto& itr : m_blockContext.regInlinedExpression)
 		{
 			cemu_assert_debug(itr == nullptr); // leaked buffer
diff --git a/src/util/bootSound/BootSoundReader.cpp b/src/util/bootSound/BootSoundReader.cpp
new file mode 100644
index 00000000..f6b00615
--- /dev/null
+++ b/src/util/bootSound/BootSoundReader.cpp
@@ -0,0 +1,51 @@
+#include "BootSoundReader.h"
+#include "Cafe/CafeSystem.h"
+
+BootSoundReader::BootSoundReader(FSCVirtualFile* bootsndFile, sint32 blockSize) : bootsndFile(bootsndFile), blockSize(blockSize)
+{
+	// crash if this constructor is invoked with a blockSize that has a different number of samples per channel
+	cemu_assert(blockSize % (sizeof(sint16be) * 2) == 0);
+
+	fsc_setFileSeek(bootsndFile, 0);
+	fsc_readFile(bootsndFile, &muteBits, 4);
+	fsc_readFile(bootsndFile, &loopPoint, 4);
+
+	buffer.resize(blockSize / sizeof(sint16));
+	bufferBE.resize(blockSize / sizeof(sint16be));
+
+	// workaround: SM3DW has incorrect loop point
+	const auto titleId = CafeSystem::GetForegroundTitleId();
+	if(titleId == 0x0005000010145D00 || titleId == 0x0005000010145C00 || titleId == 0x0005000010106100)
+		loopPoint = 113074;
+}
+
+sint16* BootSoundReader::getSamples()
+{
+	size_t totalRead = 0;
+	const size_t loopPointOffset = 8 + loopPoint * 4;
+	while (totalRead < blockSize)
+	{
+		auto read = fsc_readFile(bootsndFile, bufferBE.data(), blockSize - totalRead);
+		if (read == 0)
+		{
+			cemuLog_log(LogType::Force, "failed to read PCM samples from bootSound.btsnd");
+			return nullptr;
+		}
+		if (read % (sizeof(sint16be) * 2) != 0)
+		{
+			cemuLog_log(LogType::Force, "failed to play bootSound.btsnd: reading PCM data stopped at an odd number of samples (is the file corrupt?)");
+			return nullptr;
+		}
+
+		std::copy_n(bufferBE.begin(), read / sizeof(sint16be), buffer.begin() + (totalRead / sizeof(sint16)));
+		totalRead += read;
+		if (totalRead < blockSize)
+			fsc_setFileSeek(bootsndFile, loopPointOffset);
+	}
+
+	// handle case where the end of a block of samples lines up with the end of the file
+	if(fsc_getFileSeek(bootsndFile) == fsc_getFileSize(bootsndFile))
+		fsc_setFileSeek(bootsndFile, loopPointOffset);
+
+	return buffer.data();
+}
diff --git a/src/util/bootSound/BootSoundReader.h b/src/util/bootSound/BootSoundReader.h
new file mode 100644
index 00000000..1953b4be
--- /dev/null
+++ b/src/util/bootSound/BootSoundReader.h
@@ -0,0 +1,20 @@
+#pragma once
+#include "Cafe/Filesystem/fsc.h"
+
+class BootSoundReader
+{
+  public:
+	BootSoundReader() = delete;
+	BootSoundReader(FSCVirtualFile* bootsndFile, sint32 blockSize);
+
+	sint16* getSamples();
+
+  private:
+	FSCVirtualFile* bootsndFile{};
+	sint32 blockSize{};
+
+	uint32be muteBits{};
+	uint32be loopPoint{};
+	std::vector<sint16> buffer{};
+	std::vector<sint16be> bufferBE{};
+};
diff --git a/src/util/containers/IntervalBucketContainer.h b/src/util/containers/IntervalBucketContainer.h
index e48d305e..a85aca78 100644
--- a/src/util/containers/IntervalBucketContainer.h
+++ b/src/util/containers/IntervalBucketContainer.h
@@ -15,7 +15,7 @@ class IntervalBucketContainer
 
 public:
 
-	IntervalBucketContainer() {};
+	IntervalBucketContainer() = default;
 
 	// range is defined as inclusive rangeStart and exclusive rangeEnd
 	void addRange(TAddr rangeStart, TAddr rangeEnd, TData* data)
diff --git a/src/util/containers/RangeStore.h b/src/util/containers/RangeStore.h
index d1167b29..211bb20f 100644
--- a/src/util/containers/RangeStore.h
+++ b/src/util/containers/RangeStore.h
@@ -13,10 +13,7 @@ public:
 		size_t lastIterationIndex;
 	}rangeEntry_t;
 
-	RangeStore()
-	{
-
-	}
+	RangeStore() = default;
 
 	size_t getBucket(_ADDR addr)
 	{
@@ -125,6 +122,15 @@ public:
 		return false;
 	}
 
+    void clear()
+    {
+        for(auto& bucket : rangeBuckets)
+        {
+            while(!bucket.list_ranges.empty())
+                deleteRange(bucket.list_ranges[0]);
+        }
+    }
+
 private:
 	typedef struct
 	{
diff --git a/src/util/containers/SmallBitset.h b/src/util/containers/SmallBitset.h
index 87fae9d8..27109183 100644
--- a/src/util/containers/SmallBitset.h
+++ b/src/util/containers/SmallBitset.h
@@ -6,7 +6,7 @@ template<size_t N>
 class SmallBitset
 {
 public:
-	SmallBitset() {};
+	SmallBitset() = default;
 	static_assert(N <= 32);
 	
 	bool test(size_t index) const
diff --git a/src/util/containers/flat_hash_map.hpp b/src/util/containers/flat_hash_map.hpp
index 3dee0b16..1eccc307 100644
--- a/src/util/containers/flat_hash_map.hpp
+++ b/src/util/containers/flat_hash_map.hpp
@@ -166,9 +166,7 @@ namespace ska
 				: distance_from_desired(distance_from_desired)
 			{
 			}
-			~sherwood_v3_entry()
-			{
-			}
+			~sherwood_v3_entry() = default;
 			static sherwood_v3_entry* empty_default_table()
 			{
 				static sherwood_v3_entry result[min_lookups] = { {}, {}, {}, {special_end_value} };
@@ -297,9 +295,7 @@ namespace ska
 			using pointer = value_type*;
 			using const_pointer = const value_type*;
 
-			sherwood_v3_table()
-			{
-			}
+			sherwood_v3_table() = default;
 			explicit sherwood_v3_table(size_type bucket_count, const ArgumentHash& hash = ArgumentHash(), const ArgumentEqual& equal = ArgumentEqual(), const ArgumentAlloc& alloc = ArgumentAlloc())
 				: EntryAlloc(alloc), Hasher(hash), Equal(equal)
 			{
@@ -1324,9 +1320,7 @@ namespace ska
 		using mapped_type = V;
 
 		using Table::Table;
-		flat_hash_map()
-		{
-		}
+		flat_hash_map() = default;
 
 		inline V& operator[](const K& key)
 		{
@@ -1442,9 +1436,7 @@ namespace ska
 		using key_type = T;
 
 		using Table::Table;
-		flat_hash_set()
-		{
-		}
+		flat_hash_set() = default;
 
 		template<typename... Args>
 		std::pair<typename Table::iterator, bool> emplace(Args &&... args)
diff --git a/src/util/containers/robin_hood.h b/src/util/containers/robin_hood.h
index 577521b1..4f76519f 100644
--- a/src/util/containers/robin_hood.h
+++ b/src/util/containers/robin_hood.h
@@ -194,7 +194,7 @@ namespace robin_hood {
 
 // workaround missing "is_trivially_copyable" in g++ < 5.0
 // See https://stackoverflow.com/a/31798726/48181
-#if defined(__GNUC__) && __GNUC__ < 5
+#if defined(__GNUC__) && __GNUC__ < 5 && !defined(__clang__)
 #    define ROBIN_HOOD_IS_TRIVIALLY_COPYABLE(...) __has_trivial_copy(__VA_ARGS__)
 #else
 #    define ROBIN_HOOD_IS_TRIVIALLY_COPYABLE(...) std::is_trivially_copyable<__VA_ARGS__>::value
diff --git a/src/util/crypto/aes128.cpp b/src/util/crypto/aes128.cpp
index c8da6c8e..e11b4b44 100644
--- a/src/util/crypto/aes128.cpp
+++ b/src/util/crypto/aes128.cpp
@@ -10,6 +10,7 @@
 /* Includes:                                                                 */
 /*****************************************************************************/
 #include "aes128.h"
+#include "Common/cpu_features.h"
 
 /*****************************************************************************/
 /* Defines:                                                                  */
@@ -23,8 +24,6 @@
 // The number of rounds in AES Cipher.
 #define Nr 10
 
-bool useAESNI = false;
-
 typedef uint8 state_t[4][4];
 
 typedef struct
@@ -601,7 +600,8 @@ void AES128_CBC_decrypt_updateIV(uint8* output, uint8* input, uint32 length, con
 	memcpy(iv, newIv, KEYLEN);
 }
 
-inline __m128i AESNI128_ASSIST(
+#if defined(ARCH_X86_64)
+ATTRIBUTE_AESNI inline __m128i AESNI128_ASSIST(
 	__m128i temp1,
 	__m128i temp2)
 {
@@ -621,7 +621,7 @@ inline __m128i AESNI128_ASSIST(
 	return temp1;
 }
 
-void AESNI128_KeyExpansionEncrypt(const unsigned char *userkey, unsigned char *key)
+ATTRIBUTE_AESNI void AESNI128_KeyExpansionEncrypt(const unsigned char *userkey, unsigned char *key)
 {
 	__m128i temp1, temp2;
 	__m128i *Key_Schedule = (__m128i*)key;
@@ -659,7 +659,7 @@ void AESNI128_KeyExpansionEncrypt(const unsigned char *userkey, unsigned char *k
 	Key_Schedule[10] = temp1;
 }
 
-void AESNI128_KeyExpansionDecrypt(const unsigned char *userkey, unsigned char *key)
+ATTRIBUTE_AESNI void AESNI128_KeyExpansionDecrypt(const unsigned char *userkey, unsigned char *key)
 {
 	__m128i temp1, temp2;
 	__m128i *Key_Schedule = (__m128i*)key;
@@ -702,7 +702,7 @@ void AESNI128_KeyExpansionDecrypt(const unsigned char *userkey, unsigned char *k
 	}
 }
 
-void AESNI128_CBC_encrypt(const unsigned char *in,
+ATTRIBUTE_AESNI void AESNI128_CBC_encrypt(const unsigned char *in,
 	unsigned char *out,
 	unsigned char ivec[16],
 	unsigned long length,
@@ -730,7 +730,7 @@ void AESNI128_CBC_encrypt(const unsigned char *in,
 	}
 }
 
-void AESNI128_CBC_decryptWithExpandedKey(const unsigned char *in,
+ATTRIBUTE_AESNI void AESNI128_CBC_decryptWithExpandedKey(const unsigned char *in,
 	unsigned char *out,
 	const unsigned char ivec[16],
 	unsigned long length,
@@ -757,7 +757,7 @@ void AESNI128_CBC_decryptWithExpandedKey(const unsigned char *in,
 	}
 }
 
-void __aesni__AES128_CBC_decrypt(uint8* output, uint8* input, uint32 length, const uint8* key, const uint8* iv)
+ATTRIBUTE_AESNI void __aesni__AES128_CBC_decrypt(uint8* output, uint8* input, uint32 length, const uint8* key, const uint8* iv)
 {
 	alignas(16) uint8 expandedKey[11 * 16];
 	AESNI128_KeyExpansionDecrypt(key, expandedKey);
@@ -772,7 +772,7 @@ void __aesni__AES128_CBC_decrypt(uint8* output, uint8* input, uint32 length, con
 	}
 }
 
-void __aesni__AES128_ECB_encrypt(uint8* input, const uint8* key, uint8* output)
+ATTRIBUTE_AESNI void __aesni__AES128_ECB_encrypt(uint8* input, const uint8* key, uint8* output)
 {
 	alignas(16) uint8 expandedKey[11 * 16];
 	AESNI128_KeyExpansionEncrypt(key, expandedKey);
@@ -792,6 +792,7 @@ void __aesni__AES128_ECB_encrypt(uint8* input, const uint8* key, uint8* output)
 	feedback = _mm_aesenclast_si128(feedback, ((__m128i*)expandedKey)[10]);
 	_mm_storeu_si128(&((__m128i*)output)[0], feedback);
 }
+#endif
 
 void(*AES128_ECB_encrypt)(uint8* input, const uint8* key, uint8* output);
 void (*AES128_CBC_decrypt)(uint8* output, uint8* input, uint32 length, const uint8* key, const uint8* iv) = nullptr;
@@ -836,10 +837,8 @@ void AES128_init()
 		lookupTable_multiply[i] = (vE << 0) | (v9 << 8) | (vD << 16) | (vB << 24);
 	}
 	// check if AES-NI is available
-	int v[4];
-	cpuid(v, 1);
-	useAESNI = (v[2] & 0x2000000) != 0;
-	if (useAESNI)
+	#if defined(ARCH_X86_64)
+	if (g_CPUFeatures.x86.aesni)
 	{
 		// AES-NI implementation
 		AES128_CBC_decrypt = __aesni__AES128_CBC_decrypt;
@@ -851,9 +850,8 @@ void AES128_init()
 		AES128_CBC_decrypt = __soft__AES128_CBC_decrypt;
 		AES128_ECB_encrypt = __soft__AES128_ECB_encrypt;
 	}
+    #else
+	AES128_CBC_decrypt = __soft__AES128_CBC_decrypt;
+	AES128_ECB_encrypt = __soft__AES128_ECB_encrypt;
+    #endif
 }
-
-bool AES128_useAESNI()
-{
-	return useAESNI;
-}
\ No newline at end of file
diff --git a/src/util/crypto/aes128.h b/src/util/crypto/aes128.h
index fbe56541..7993329c 100644
--- a/src/util/crypto/aes128.h
+++ b/src/util/crypto/aes128.h
@@ -2,7 +2,6 @@
 #define _AES_H_
 
 void AES128_init();
-bool AES128_useAESNI();
 
 extern void(*AES128_ECB_encrypt)(uint8* input, const uint8* key, uint8* output);
 
diff --git a/src/util/crypto/crc32.cpp b/src/util/crypto/crc32.cpp
index f6e88165..a5b37a5e 100644
--- a/src/util/crypto/crc32.cpp
+++ b/src/util/crypto/crc32.cpp
@@ -1,29 +1,6 @@
 #include "crc32.h"
 
-#if defined(_MSC_VER) || defined(__MINGW32__)
-#define __LITTLE_ENDIAN 1234
-#define __BIG_ENDIAN    4321
-#define __BYTE_ORDER    __LITTLE_ENDIAN
-
-#include <xmmintrin.h>
-#ifdef __MINGW32__
-#define PREFETCH(location) __builtin_prefetch(location)
-#else
-#define PREFETCH(location) _mm_prefetch(location, _MM_HINT_T0)
-#endif
-#else
-// defines __BYTE_ORDER as __LITTLE_ENDIAN or __BIG_ENDIAN
-#include <sys/param.h>
-
-#ifdef __GNUC__
-#define PREFETCH(location) __builtin_prefetch(location)
-#else
-  // no prefetching
-#define PREFETCH(location) ;
-#endif
-#endif
-
-unsigned int Crc32Lookup[8][256] =
+constexpr uint32 Crc32Lookup[8][256] =
 {
 	{
 		0x00000000,0x77073096,0xEE0E612C,0x990951BA,0x076DC419,0x706AF48F,0xE963A535,0x9E6495A3,
@@ -301,20 +278,7 @@ unsigned int Crc32Lookup[8][256] =
 	  }
 };
 
-/// swap endianess
-static inline uint32_t swap(uint32_t x)
-{
-#if defined(__GNUC__) || defined(__clang__)
-	return __builtin_bswap32(x);
-#else
-	return (x >> 24) |
-		((x >> 8) & 0x0000FF00) |
-		((x << 8) & 0x00FF0000) |
-		(x << 24);
-#endif
-}
-
-unsigned int crc32_calc_slice_by_8(unsigned int previousCrc32, const void* data, int length)
+uint32 crc32_calc_slice_by_8(uint32 previousCrc32, const void* data, size_t length)
 {
 	uint32_t crc = ~previousCrc32; // same as previousCrc32 ^ 0xFFFFFFFF
 	const uint32_t* current = (const uint32_t*)data;
@@ -322,34 +286,40 @@ unsigned int crc32_calc_slice_by_8(unsigned int previousCrc32, const void* data,
 	// process eight bytes at once (Slicing-by-8)
 	while (length >= 8)
 	{
-#if __BYTE_ORDER == __BIG_ENDIAN
-		uint32_t one = *current++ ^ swap(crc);
-		uint32_t two = *current++;
-		crc = Crc32Lookup[0][two & 0xFF] ^
-			Crc32Lookup[1][(two >> 8) & 0xFF] ^
-			Crc32Lookup[2][(two >> 16) & 0xFF] ^
-			Crc32Lookup[3][(two >> 24) & 0xFF] ^
-			Crc32Lookup[4][one & 0xFF] ^
-			Crc32Lookup[5][(one >> 8) & 0xFF] ^
-			Crc32Lookup[6][(one >> 16) & 0xFF] ^
-			Crc32Lookup[7][(one >> 24) & 0xFF];
-#else
-		uint32_t one = *current++ ^ crc;
-		uint32_t two = *current++;
-		crc = Crc32Lookup[0][(two >> 24) & 0xFF] ^
-			Crc32Lookup[1][(two >> 16) & 0xFF] ^
-			Crc32Lookup[2][(two >> 8) & 0xFF] ^
-			Crc32Lookup[3][two & 0xFF] ^
-			Crc32Lookup[4][(one >> 24) & 0xFF] ^
-			Crc32Lookup[5][(one >> 16) & 0xFF] ^
-			Crc32Lookup[6][(one >> 8) & 0xFF] ^
-			Crc32Lookup[7][one & 0xFF];
-#endif
+		if constexpr (std::endian::native == std::endian::big){
+			uint32_t one = *current++ ^ _swapEndianU32(crc);
+			uint32_t two = *current++;
+			crc = Crc32Lookup[0][two & 0xFF] ^
+				  Crc32Lookup[1][(two >> 8) & 0xFF] ^
+				  Crc32Lookup[2][(two >> 16) & 0xFF] ^
+				  Crc32Lookup[3][(two >> 24) & 0xFF] ^
+				  Crc32Lookup[4][one & 0xFF] ^
+				  Crc32Lookup[5][(one >> 8) & 0xFF] ^
+				  Crc32Lookup[6][(one >> 16) & 0xFF] ^
+				  Crc32Lookup[7][(one >> 24) & 0xFF];
+		}
+		else if constexpr (std::endian::native == std::endian::little)
+		{
+			uint32_t one = *current++ ^ crc;
+			uint32_t two = *current++;
+			crc = Crc32Lookup[0][(two >> 24) & 0xFF] ^
+				  Crc32Lookup[1][(two >> 16) & 0xFF] ^
+				  Crc32Lookup[2][(two >> 8) & 0xFF] ^
+				  Crc32Lookup[3][two & 0xFF] ^
+				  Crc32Lookup[4][(one >> 24) & 0xFF] ^
+				  Crc32Lookup[5][(one >> 16) & 0xFF] ^
+				  Crc32Lookup[6][(one >> 8) & 0xFF] ^
+				  Crc32Lookup[7][one & 0xFF];
+		}
+		else {
+			static_assert(std::endian::native == std::endian::big || std::endian::native == std::endian::little,
+						  "Platform byte-order is unsupported");
+		}
 
 		length -= 8;
 	}
 
-	const uint8_t* currentChar = (const uint8_t*)current;
+	const uint8* currentChar = (const uint8*)current;
 	// remaining 1 to 7 bytes (standard algorithm)
 	while (length-- != 0)
 		crc = (crc >> 8) ^ Crc32Lookup[0][(crc & 0xFF) ^ *currentChar++];
@@ -357,24 +327,33 @@ unsigned int crc32_calc_slice_by_8(unsigned int previousCrc32, const void* data,
 	return ~crc; // same as crc ^ 0xFFFFFFFF
 }
 
-unsigned int crc32_calc(unsigned int c, const void* data, int length)
+uint32 crc32_calc(uint32 c, const void* data, size_t length)
 {
 	if (length >= 16)
 	{
 		return crc32_calc_slice_by_8(c, data, length);
 	}
-	unsigned char* p = (unsigned char*)data;
+	const uint8* p = (const uint8*)data;
 	if (length == 0)
 		return c;
 	c ^= 0xFFFFFFFF;
 	while (length)
 	{
-		unsigned char temp = *p;
-		temp ^= (unsigned char)c;
+		uint8 temp = *p;
+		temp ^= (uint8)c;
 		c = (c >> 8) ^ Crc32Lookup[0][temp];
 		// next
 		length--;
 		p++;
 	}
 	return ~c;
+}
+
+void CRCTest()
+{
+	std::vector<uint8> testData;
+	for (uint8 i = 0; i < 89; i++)
+		testData.emplace_back(i);
+	uint32 r = crc32_calc(0, testData.data(), testData.size());
+	cemu_assert(r == 0x3fc61683);
 }
\ No newline at end of file
diff --git a/src/util/crypto/crc32.h b/src/util/crypto/crc32.h
index 6a254433..2ab37376 100644
--- a/src/util/crypto/crc32.h
+++ b/src/util/crypto/crc32.h
@@ -1,3 +1,8 @@
 #pragma once
 
-unsigned int crc32_calc(unsigned int c, const void* data, int length);
\ No newline at end of file
+uint32 crc32_calc(uint32 c, const void* data, size_t length);
+
+inline uint32 crc32_calc(const void* data, size_t length)
+{
+	return crc32_calc(0, data, length);
+}
\ No newline at end of file
diff --git a/src/util/helpers/StringBuf.h b/src/util/helpers/StringBuf.h
index 8c7b1645..6242fa4c 100644
--- a/src/util/helpers/StringBuf.h
+++ b/src/util/helpers/StringBuf.h
@@ -44,12 +44,12 @@ public:
 
 	void add(std::string_view appendedStr)
 	{
-		size_t remainingLen = this->limit - this->length;
 		size_t copyLen = appendedStr.size();
-		if (remainingLen > copyLen)
-			copyLen = remainingLen;
+		if (this->length + copyLen + 1 >= this->limit)
+			_reserve(std::max<uint32>(this->length + copyLen + 64, this->limit + this->limit / 2));
 		char* outputStart = (char*)(this->str + this->length);
 		std::copy(appendedStr.data(), appendedStr.data() + copyLen, outputStart);
+		length += copyLen;
 		outputStart[copyLen] = '\0';
 	}
 
@@ -79,6 +79,13 @@ public:
 	}
 
 private:
+	void _reserve(uint32 newLimit)
+	{
+		cemu_assert_debug(newLimit > length);
+		this->str = (uint8*)realloc(this->str, newLimit + 4);
+		this->limit = newLimit;
+	}
+
 	uint8*	str;
 	uint32	length; /* in bytes */
 	uint32	limit; /* in bytes */
diff --git a/src/util/helpers/StringHelpers.h b/src/util/helpers/StringHelpers.h
index cfe63ead..fb858f4d 100644
--- a/src/util/helpers/StringHelpers.h
+++ b/src/util/helpers/StringHelpers.h
@@ -2,6 +2,93 @@
 #include "boost/nowide/convert.hpp"
 #include <charconv>
 
+// Definition for removed templates in Apple Clang 17
+#if defined(__apple_build_version__) && (__apple_build_version__ >= 17000000)
+namespace std {
+	template<>
+	struct char_traits<uint16be> {
+		using char_type = uint16be;
+		using int_type = int;
+		using off_type = streamoff;
+		using pos_type = streampos;
+		using state_type = mbstate_t;
+
+		static inline void constexpr assign(char_type& c1, const char_type& c2) noexcept {
+			c1 = c2;
+		}
+
+		static inline constexpr bool eq(char_type c1, char_type c2) noexcept {
+			return c1 == c2;
+		}
+
+		static inline constexpr bool lt(char_type c1, char_type c2) noexcept {
+			return c1 < c2;
+		}
+
+		static constexpr int compare(const char_type* s1, const char_type* s2, size_t n) {
+			for (; n; --n, ++s1, ++s2) {
+				if (lt(*s1, *s2)) return -1;
+				if (lt(*s2, *s1)) return 1;
+			}
+			return 0;
+		}
+
+		static constexpr size_t length(const char_type* s) {
+			size_t len = 0;
+			for (; !eq(*s, char_type(0)); ++s) ++len;
+			return len;
+		}
+
+		static constexpr const char_type* find(const char_type* s, size_t n, const char_type& a) {
+			for (; n; --n) {
+				if (eq(*s, a))
+					return s;
+				++s;
+			}
+			return nullptr;
+		}
+
+		static constexpr char_type* move(char_type* s1, const char_type* s2, size_t n) {
+			if (n == 0) return s1;
+			return static_cast<char_type*>(memmove(s1, s2, n * sizeof(char_type)));
+		}
+
+		static constexpr char_type* copy(char_type* s1, const char_type* s2, size_t n) {
+			if (n == 0) return s1;
+			return static_cast<char_type*>(memcpy(s1, s2, n * sizeof(char_type)));
+		}
+
+		static constexpr char_type* assign(char_type* s, size_t n, char_type a) {
+			char_type* r = s;
+			for (; n; --n, ++s)
+				assign(*s, a);
+			return r;
+		}
+
+		static inline constexpr char_type to_char_type(int_type c) noexcept {
+			return char_type(c);
+		}
+
+		static inline constexpr int_type to_int_type(char_type c) noexcept {
+			return int_type(c);
+		}
+
+		static inline constexpr bool eq_int_type(int_type c1, int_type c2) noexcept {
+			return c1 == c2;
+		}
+
+		static inline constexpr int_type eof() noexcept {
+			return static_cast<int_type>(EOF);
+		}
+
+		static inline constexpr int_type not_eof(int_type c) noexcept {
+			return eq_int_type(c, eof()) ? ~eof() : c;
+		}
+	};
+}
+#endif
+
+// todo - move the Cafe/PPC specific parts to CafeString.h eventually
 namespace StringHelpers
 {
 	// convert Wii U big-endian wchar_t string to utf8 string
@@ -24,9 +111,9 @@ namespace StringHelpers
 	}
 
 	// convert utf8 string to Wii U big-endian wchar_t string
-	static std::basic_string<uint16be> FromUtf8(std::string_view str)
+	static std::vector<uint16be> FromUtf8(std::string_view str)
 	{
-		std::basic_string<uint16be> tmpStr;
+		std::vector<uint16be> tmpStr;
 		std::wstring w = boost::nowide::widen(str.data(), str.size());
 		for (auto& c : w)
 			tmpStr.push_back((uint16)c);
@@ -108,5 +195,94 @@ namespace StringHelpers
 		}
 		return parsedLen;
 	}
+
+	class StringLineIterator
+	{
+	public:
+		class Iterator
+		{
+		public:
+			using iterator_category = std::input_iterator_tag;
+			using value_type = std::string_view;
+			using difference_type = std::ptrdiff_t;
+			using pointer = const std::string_view*;
+			using reference = const std::string_view&;
+
+			Iterator(std::string_view str, sint32 pos) : m_str(str), m_pos(pos)
+			{
+				update_line();
+			}
+
+			reference operator*() const
+			{
+				return m_line;
+			}
+
+			pointer operator->() const
+			{
+				return &m_line;
+			}
+
+			Iterator& operator++()
+			{
+				m_pos = m_nextPos;
+				update_line();
+				return *this;
+			}
+
+			friend bool operator==(const Iterator& lhs, const Iterator& rhs)
+			{
+				return lhs.m_str.data() == rhs.m_str.data() && lhs.m_pos == rhs.m_pos;
+			}
+
+			friend bool operator!=(const Iterator& lhs, const Iterator& rhs)
+			{
+				return !(lhs == rhs);
+			}
+
+		private:
+			void update_line()
+			{
+				if (m_pos >= m_str.size())
+				{
+					m_pos = -1;
+					m_line = {};
+					return;
+				}
+				auto pos = m_str.find('\n', m_pos);
+				m_nextPos = pos != std::string_view::npos ? pos : -1;
+				if(m_nextPos < 0)
+					m_line = m_str.substr(m_pos, std::string::npos);
+				else
+				{
+					m_line = m_str.substr(m_pos, m_nextPos - m_pos);
+					++m_nextPos; // skip \n
+				}
+				while (!m_line.empty() && m_line.back() == '\r')
+					m_line.remove_suffix(1);
+			}
+
+			std::string_view m_str;
+			sint32 m_pos;
+			sint32 m_nextPos;
+			std::string_view m_line;
+		};
+
+		StringLineIterator(std::string_view str) : m_str(str) {}
+		StringLineIterator(std::span<uint8> str) : m_str((const char*)str.data(), str.size()) {}
+
+		Iterator begin() const
+		{
+			return Iterator{m_str, 0 };
+		}
+
+		Iterator end() const
+		{
+			return Iterator{m_str, -1 };
+		}
+
+	private:
+		std::string_view m_str;
+	};
 };
 
diff --git a/src/util/helpers/fspinlock.h b/src/util/helpers/fspinlock.h
index 04f761e7..3994299f 100644
--- a/src/util/helpers/fspinlock.h
+++ b/src/util/helpers/fspinlock.h
@@ -7,32 +7,34 @@
 class FSpinlock
 {
 public:
-	void acquire()
-	{
-		while( true )
-		{
-			if (!m_lockBool.exchange(true, std::memory_order_acquire)) 
-				break;
-			while (m_lockBool.load(std::memory_order_relaxed)) _mm_pause();
-		}
-	}
-
-	bool tryAcquire()
-	{
-		return !m_lockBool.exchange(true, std::memory_order_acquire);
-	}
-
-	void release()
-	{
-		m_lockBool.store(false, std::memory_order_release);
-	}
-
-	bool isHolding() const
+	bool is_locked() const
 	{
 		return m_lockBool.load(std::memory_order_relaxed);
 	}
 
+	// implement BasicLockable and Lockable
+	void lock() const
+	{
+		while (true)
+		{
+			if (!m_lockBool.exchange(true, std::memory_order_acquire))
+				break;
+			while (m_lockBool.load(std::memory_order_relaxed)) 
+                _mm_pause();
+		}
+	}
+
+	bool try_lock() const
+	{
+		return !m_lockBool.exchange(true, std::memory_order_acquire);
+	}
+
+	void unlock() const
+	{
+		m_lockBool.store(false, std::memory_order_release);
+	}
+
 private:
 	
-	std::atomic<bool> m_lockBool = false;
-};
\ No newline at end of file
+	mutable std::atomic<bool> m_lockBool = false;
+};
diff --git a/src/util/helpers/helpers.cpp b/src/util/helpers/helpers.cpp
index a52aa439..bac2d446 100644
--- a/src/util/helpers/helpers.cpp
+++ b/src/util/helpers/helpers.cpp
@@ -11,6 +11,8 @@
 
 #include <boost/random/uniform_int.hpp>
 
+#include <zlib.h>
+
 
 #if BOOST_OS_WINDOWS
 #include <TlHelp32.h>
@@ -139,8 +141,6 @@ typedef struct tagTHREADNAME_INFO
 void SetThreadName(const char* name)
 {
 #if BOOST_OS_WINDOWS
-	
-#ifndef _PUBLIC_RELEASE
 	THREADNAME_INFO info;
 	info.dwType = 0x1000;
 	info.szName = name;
@@ -154,13 +154,12 @@ void SetThreadName(const char* name)
 	__except (EXCEPTION_EXECUTE_HANDLER) {
 	}
 #pragma warning(pop)
-	
-#endif
-	
 #elif BOOST_OS_MACOS
 	pthread_setname_np(name);
 #else
-    pthread_setname_np(pthread_self(), name);
+	if(std::strlen(name) > 15)
+		cemuLog_log(LogType::Force, "Truncating thread name {} because it was longer than 15 characters", name);
+	pthread_setname_np(pthread_self(), std::string{name}.substr(0,15).c_str());
 #endif
 }
 
@@ -285,15 +284,16 @@ uint32_t GetPhysicalCoreCount()
 
 bool TestWriteAccess(const fs::path& p)
 {
+	std::error_code ec;
 	// must be path and must exist
-	if (!fs::exists(p) || !fs::is_directory(p))
+	if (!fs::exists(p, ec) || !fs::is_directory(p, ec))
 		return false;
 
 	// retry 3 times
 	for (int i = 0; i < 3; ++i)
 	{
 		const auto filename = p / fmt::format("_{}.tmp", GenerateRandomString(8));
-		if (fs::exists(filename))
+		if (fs::exists(filename, ec))
 			continue;
 
 		std::ofstream file(filename);
@@ -302,7 +302,6 @@ bool TestWriteAccess(const fs::path& p)
 		
 		file.close();
 
-		std::error_code ec;
 		fs::remove(filename, ec);
 		return true;
 	}
@@ -311,11 +310,10 @@ bool TestWriteAccess(const fs::path& p)
 }
 
 // make path relative to Cemu directory
-fs::path MakeRelativePath(const fs::path& path)
+fs::path MakeRelativePath(const fs::path& base, const fs::path& path)
 {
 	try
 	{
-		const fs::path base = ActiveSettings::GetPath();
 		return fs::relative(path, base);
 	}
 	catch (const std::exception&)
@@ -441,3 +439,42 @@ std::string GenerateRandomString(const size_t length, const std::string_view cha
 
 	return result;
 }
+
+std::optional<std::vector<uint8>> zlibDecompress(const std::vector<uint8>& compressed, size_t sizeHint)
+{
+	int err;
+	std::vector<uint8> decompressed;
+	size_t outWritten = 0;
+	size_t bytesPerIteration = sizeHint;
+	z_stream stream;
+	stream.zalloc = Z_NULL;
+	stream.zfree = Z_NULL;
+	stream.opaque = Z_NULL;
+	stream.avail_in = compressed.size();
+	stream.next_in = (Bytef*)compressed.data();
+	err = inflateInit2(&stream, 32); // 32 is a zlib magic value to enable header detection
+	if (err != Z_OK)
+		return {};
+
+	do
+	{
+		decompressed.resize(decompressed.size() + bytesPerIteration);
+		const auto availBefore = decompressed.size() - outWritten;
+		stream.avail_out = availBefore;
+		stream.next_out = decompressed.data() + outWritten;
+		err = inflate(&stream, Z_NO_FLUSH);
+		if (!(err == Z_OK || err == Z_STREAM_END))
+		{
+			inflateEnd(&stream);
+			return {};
+		}
+		outWritten += availBefore - stream.avail_out;
+		bytesPerIteration *= 2;
+	}
+	while (err != Z_STREAM_END);
+
+	inflateEnd(&stream);
+	decompressed.resize(stream.total_out);
+
+	return decompressed;
+}
diff --git a/src/util/helpers/helpers.h b/src/util/helpers/helpers.h
index 6240d56a..1edc2e19 100644
--- a/src/util/helpers/helpers.h
+++ b/src/util/helpers/helpers.h
@@ -52,7 +52,7 @@ uint32_t GetPhysicalCoreCount();
 // Creates a temporary file to test for write access
 bool TestWriteAccess(const fs::path& p);
 
-fs::path MakeRelativePath(const fs::path& path);
+fs::path MakeRelativePath(const fs::path& base, const fs::path& path);
 
 #ifdef HAS_DIRECTINPUT
 bool GUIDFromString(const char* string, GUID& guid);
@@ -231,9 +231,31 @@ inline uint64 MakeU64(uint32 high, uint32 low)
 	return ((uint64)high << 32) | ((uint64)low);
 }
 
+static bool IsValidFilename(std::string_view sv)
+{
+	for (auto& it : sv)
+	{
+		uint8 c = (uint8)it;
+		if (c < 0x20)
+			return false;
+		if (c == '.' || c == '#' || c == '/' || c == '\\' ||
+			c == '<' || c == '>' || c == '|' || c == ':' ||
+			c == '\"')
+			return false;
+	}
+	if (!sv.empty())
+	{
+		if (sv.back() == ' ' || sv.back() == '.')
+			return false;
+	}
+	return true;
+}
+
 // MAJOR; MINOR
 std::pair<DWORD, DWORD> GetWindowsVersion();
 bool IsWindows81OrGreater();
 bool IsWindows10OrGreater();
 
 fs::path GetParentProcess();
+
+std::optional<std::vector<uint8>> zlibDecompress(const std::vector<uint8>& compressed, size_t sizeHint = 32*1024);
diff --git a/src/util/highresolutiontimer/HighResolutionTimer.cpp b/src/util/highresolutiontimer/HighResolutionTimer.cpp
index 21cabff5..bb4a40ab 100644
--- a/src/util/highresolutiontimer/HighResolutionTimer.cpp
+++ b/src/util/highresolutiontimer/HighResolutionTimer.cpp
@@ -7,11 +7,13 @@ HighResolutionTimer HighResolutionTimer::now()
 	LARGE_INTEGER pc;
 	QueryPerformanceCounter(&pc);
 	return HighResolutionTimer(pc.QuadPart);
-#else
+#elif BOOST_OS_LINUX
     timespec pc;
-    clock_gettime(CLOCK_MONOTONIC, &pc);
+    clock_gettime(CLOCK_MONOTONIC_RAW, &pc);
     uint64 nsec = (uint64)pc.tv_sec * (uint64)1000000000 + (uint64)pc.tv_nsec;
     return HighResolutionTimer(nsec);
+#elif BOOST_OS_MACOS
+	return HighResolutionTimer(clock_gettime_nsec_np(CLOCK_MONOTONIC_RAW));
 #endif
 }
 
@@ -20,15 +22,16 @@ HRTick HighResolutionTimer::getFrequency()
 	return m_freq;
 }
 
-
 uint64 HighResolutionTimer::m_freq = []() -> uint64 {
 #if BOOST_OS_WINDOWS
 	LARGE_INTEGER freq;
 	QueryPerformanceFrequency(&freq);
 	return (uint64)(freq.QuadPart);
+#elif BOOST_OS_MACOS
+	return 1000000000;
 #else
     timespec pc;
-    clock_getres(CLOCK_MONOTONIC, &pc);
+    clock_getres(CLOCK_MONOTONIC_RAW, &pc);
     return (uint64)1000000000 / (uint64)pc.tv_nsec;
 #endif
 }();
diff --git a/src/util/highresolutiontimer/HighResolutionTimer.h b/src/util/highresolutiontimer/HighResolutionTimer.h
index 12dc0751..7a545c86 100644
--- a/src/util/highresolutiontimer/HighResolutionTimer.h
+++ b/src/util/highresolutiontimer/HighResolutionTimer.h
@@ -36,6 +36,16 @@ public:
 	static HighResolutionTimer now();
 	static HRTick getFrequency();
 
+	static HRTick microsecondsToTicks(uint64 microseconds)
+	{
+		return microseconds * m_freq / 1000000;
+	}
+
+	static uint64 ticksToMicroseconds(HRTick ticks)
+	{
+		return ticks * 1000000 / m_freq;
+	}
+
 private:
 	HighResolutionTimer(uint64 timePoint) : m_timePoint(timePoint) {};
 
diff --git a/src/util/libusbWrapper/libusbWrapper.cpp b/src/util/libusbWrapper/libusbWrapper.cpp
index e1d72985..8420216d 100644
--- a/src/util/libusbWrapper/libusbWrapper.cpp
+++ b/src/util/libusbWrapper/libusbWrapper.cpp
@@ -18,7 +18,7 @@ void libusbWrapper::init()
 	m_module = LoadLibraryW(L"libusb-1.0.dll");
 	if (!m_module)
 	{
-		const auto path = ActiveSettings::GetPath("resources/libusb-1.0.dll");
+		const auto path = ActiveSettings::GetDataPath("resources/libusb-1.0.dll");
 		m_module = LoadLibraryW(path.generic_wstring().c_str());
 		if (!m_module)
 		{
diff --git a/vcpkg.json b/vcpkg.json
index 519a5618..c746e00c 100644
--- a/vcpkg.json
+++ b/vcpkg.json
@@ -1,13 +1,11 @@
 {
   "name": "cemu",
   "version-string": "1.0",
-  "builtin-baseline": "1b0252ca70ca2244a711535462c7f981eb439e83",
+  "builtin-baseline": "a4275b7eee79fb24ec2e135481ef5fce8b41c339",
   "dependencies": [
-    "imgui",
     "pugixml",
     "zlib",
-    "libpng",
-	"zstd",
+    "zstd",
     {
       "name": "libzip",
       "default-features": false
@@ -19,20 +17,22 @@
     "boost-program-options",
     "boost-nowide",
     "boost-algorithm",
-    "boost-range",
     "boost-functional",
-    "boost-dll",
     "boost-optional",
     "boost-signals2",
-    "boost-crc",
     "boost-asio",
     "boost-ptr-container",
     "boost-property-tree",
     "boost-static-string",
     "boost-random",
     "fmt",
+    "hidapi",
+    "libpng",
     "glm",
-    "glslang",
+    {
+      "name": "glslang",
+      "default-features": false
+    },
     "zstd",
     {
       "name": "wxwidgets",
@@ -43,6 +43,27 @@
       "name": "curl",
       "default-features": false,
       "features": [ "openssl" ]
+    },
+    {
+      "name": "dbus",
+      "default-features": false,
+      "platform": "linux"
+    },
+    {
+      "name": "tiff",
+      "default-features": false,
+      "features": ["jpeg", "zip"]
+    },
+    "libusb"
+  ],
+  "overrides": [
+    {
+      "name": "glslang",
+      "version": "15.1.0"
+    },
+    {
+      "name": "sdl2",
+      "version": "2.30.3"
     }
   ]
 }