sadfs

2026-01-31 01:15:24 +01:00 · 2023-02-10 20:05:39 +00:00
553 changed files with 38350 additions and 39491 deletions
--- a/.github/ISSUE_TEMPLATE/app_bug_report.yaml
+++ b/.github/ISSUE_TEMPLATE/app_bug_report.yaml
@@ -12,23 +12,19 @@ body:
        ## Important: Read First

        Please do not make support requests on GitHub. Our issue tracker is for tracking bugs and feature requests only
-        If you need help configuring the emulator please make a request on our forums or contact us on discord.
+        If you need help configuring the emulator please make a request on our forums or contact us on discord

-        If you are unsure, start with [discord](https://discord.com/invite/TCz3t9k) or the [forums](https://forums.pcsx2.net/index.php).
+        If you are unsure, start with [discord](https://discord.com/invite/TCz3t9k) or the [forums](https://forums.pcsx2.net/index.php)

-        Please make an effort to make sure your issue isn't already reported.
+        Please make an effort to make sure your issue isn't already reported

        ### Please Avoid Issues Pertaining to the Following:
-        - We are **not** accepting bug reports for **PSX mode** at this time.
-          - If you are interested in helping contribute to PSX mode please do so on the forums. Otherwise our recommendation is that you use  [Duckstation](https://github.com/stenzek/duckstation/releases/tag/latest).
-        - We do **not** accept issues relating to **upscaling** at this time.
-          - We are aware of the various problems with upscaling. The issue spans many games and having hundreds of issues for the same fundamental issues isn't particularly helpful. There are several workarounds for graphical problems that come as a result of upscaling.
-          - Please try your game at native resolution before creating an issue.
-          - If your bug is the result of upscaling please use the forums or discord for assistance with various upscaling workarounds. Additionally, the unofficial PCSX2 [Wiki](https://wiki.pcsx2.net/Main_Page) often lists various fixes for upscaling issues.
-        - We do **not** accept issues relating to Widescreen/no-interlace patches at this time.
-          - Any issues pertaining to Widescreen/no-interlace patches please forward them to the [patches repository](https://github.com/PCSX2/pcsx2_patches). 
-        -If PCSX2 crashed, please post crash logs and the .dmp file if appropiate.
-
+        - We are **not** accepting bug reports for **PSX mode** at this time
+          - If you are interested in helping contribute to PSX mode please do so on the forums. Otherwise our recommendation is that you use a [proper PSX emulator](https://emulation.gametechwiki.com/index.php/PlayStation_emulators)
+        - We do **not** accept issues relating to **upscaling** at this time
+          - We are aware of the various problems with upscaling. The issue spans many games and having hundreds of issues for the same fundamental issues isn't particularly helpful. There are several workarounds for graphical problems that come as a result of upscaling
+          - Please try your game at native resolution before creating an issue
+          - If your bug is the result of upscaling please use the forums or discord for assistance with various upscaling workarounds. Additionally, the unofficial PCSX2 [Wiki](https://wiki.pcsx2.net/Main_Page) often lists various fixes for upscaling issues
  - type: textarea
    id: desc
    attributes:
--- a/.github/ISSUE_TEMPLATE/emu_bug_report.yaml
+++ b/.github/ISSUE_TEMPLATE/emu_bug_report.yaml
@@ -12,22 +12,19 @@ body:
        ## Important: Read First

        Please do not make support requests on GitHub. Our issue tracker is for tracking bugs and feature requests only
-        If you need help configuring the emulator please make a request on our forums or contact us on discord.
+        If you need help configuring the emulator please make a request on our forums or contact us on discord

-        If you are unsure, start with [discord](https://discord.com/invite/TCz3t9k) or the [forums](https://forums.pcsx2.net/index.php).
+        If you are unsure, start with [discord](https://discord.com/invite/TCz3t9k) or the [forums](https://forums.pcsx2.net/index.php)

-        Please make an effort to make sure your issue isn't already reported.
+        Please make an effort to make sure your issue isn't already reported

        ### Please Avoid Issues Pertaining to the Following:
-        - We are **not** accepting bug reports for **PSX mode** at this time.
-          - If you are interested in helping contribute to PSX mode please do so on the forums. Otherwise our recommendation is that you use  [Duckstation](https://github.com/stenzek/duckstation/releases/tag/latest).
-        - We do **not** accept issues relating to **upscaling** at this time.
-          - We are aware of the various problems with upscaling. The issue spans many games and having hundreds of issues for the same fundamental issues isn't particularly helpful. There are several workarounds for graphical problems that come as a result of upscaling.
-          - Please try your game at native resolution before creating an issue.
-          - If your bug is the result of upscaling please use the forums or discord for assistance with various upscaling workarounds. Additionally, the unofficial PCSX2 [Wiki](https://wiki.pcsx2.net/Main_Page) often lists various fixes for upscaling issues.
-        - We do **not** accept issues relating to Widescreen/no-interlace patches at this time.
-          - Any issues pertaining to Widescreen/no-interlace patches please forward them to the [patches repository](https://github.com/PCSX2/pcsx2_patches). 
-
+        - We are **not** accepting bug reports for **PSX mode** at this time
+          - If you are interested in helping contribute to PSX mode please do so on the forums. Otherwise our recommendation is that you use a [proper PSX emulator](https://emulation.gametechwiki.com/index.php/PlayStation_emulators)
+        - We do **not** accept issues relating to **upscaling** at this time
+          - We are aware of the various problems with upscaling. The issue spans many games and having hundreds of issues for the same fundamental issues isn't particularly helpful. There are several workarounds for graphical problems that come as a result of upscaling
+          - Please try your game at native resolution before creating an issue
+          - If your bug is the result of upscaling please use the forums or discord for assistance with various upscaling workarounds. Additionally, the unofficial PCSX2 [Wiki](https://wiki.pcsx2.net/Main_Page) often lists various fixes for upscaling issues
  - type: textarea
    id: desc
    attributes:
@@ -55,13 +52,13 @@ body:
        ## System Info

        Please make sure your system meets our requirements for OS version, CPU and GPU
-        - [System Requirements](https://github.com/PCSX2/pcsx2#system-requirements).
+        - [System Requirements](https://github.com/PCSX2/pcsx2#system-requirements)

-        Performance issues as a result of not meeting our hardware requirements are not valid.
+        Performance issues as a result of not meeting our hardware requirements are not valid

        Please read our known issues pages for AMD and Intel drivers.
-        - [Intel Drivers](https://github.com/PCSX2/pcsx2/wiki/OpenGL-and-Intel-GPUs-All-you-need-to-know).
-        - [AMD Drivers](https://github.com/PCSX2/pcsx2/wiki/OpenGL-and-AMD-GPUs---All-you-need-to-know).
+        - [Intel Drivers](https://github.com/PCSX2/pcsx2/wiki/OpenGL-and-Intel-GPUs-All-you-need-to-know)
+        - [AMD Drivers](https://github.com/PCSX2/pcsx2/wiki/OpenGL-and-AMD-GPUs---All-you-need-to-know)

        We are **not** accepting issues related to the **libretro** core. The libretro core is being maintained separately at this time
  - type: input
@@ -120,11 +117,11 @@ body:
    attributes:
      label: Emulation Settings
      description: |
-        Any non-default core settings. If you don't want to list them out, please provide screenshots of your configuration window.
+        Any non-default core settings. If you don't want to list them out, please provide screenshots of your configuration window

-        Please note that the safe preset works for most games. MTVU can have some compatibility issues so please disable it before making a report.
+        Please note that the safe preset works for most games. MTVU can have some compatibility issues so please disable it before making a report

-        If you need to modify the settings manually because a game requires you to do so to work, please state that explicitly.
+        If you need to modify the settings manually because a game requires you to do so to work, please state that explicitly
    validations:
      required: false
  - type: textarea
@@ -139,8 +136,8 @@ body:
    attributes:
      label: "Logs & Dumps"
      description: |
-        Please feel free to attach any logs, block dumps, GSdump, etc here.
-        If PCSX2 crashed, please post crash logs and the .dmp file if appropiate.
+        Please feel free to attach any logs, block dumps, GSdump, etc here
+
        If your problem is graphical in nature it is highly recommended that you provide a GSdump. [GSdump Guide](https://forums.pcsx2.net/Thread-How-to-create-a-proper-GS-dump)
    validations:
      required: false
--- a/.github/labeler.yml
+++ b/.github/labeler.yml
@@ -39,8 +39,8 @@
 'Debugger':
  - 'pcsx2/DebugTools/*'
  - 'pcsx2/DebugTools/**/*'
-  - 'pcsx2-qt/Debugger/*'
-  - 'pcsx2-qt/Debugger/**/*'
+  - 'pcsx2/gui/Debugger/*'
+  - 'pcsx2/gui/Debugger/**/*'
 'IPC':
  - 'pcsx2/IPC*'
  - 'pcsx2/**/IPC*'
--- a/.github/workflows/cron_update_controller_db.yml
+++ b/.github/workflows/cron_update_controller_db.yml
@@ -19,7 +19,7 @@ jobs:
          mv ./game_controller_db.txt ${{github.workspace}}/bin/resources/game_controller_db.txt

      - name: Create Pull Request
-        uses: peter-evans/create-pull-request@v5
+        uses: peter-evans/create-pull-request@v4
        with:
          title: "PAD: Update to latest controller database"
          commit-message: "PAD: Update to latest controller database."
--- a/.github/workflows/macos_build.yml
+++ b/.github/workflows/macos_build.yml
@@ -144,12 +144,12 @@ jobs:
            APPNAME="PCSX2-$TAG"
          fi
          mv build/pcsx2*/PCSX2.app "$APPNAME.app"
-          tar --options xz:compression-level=9 -cvJf "${{ steps.artifact-metadata.outputs.artifact-name }}.tar.xz" "$APPNAME.app"
+          tar cvzf "${{ steps.artifact-metadata.outputs.artifact-name }}.tar.gz" "$APPNAME.app"
          mkdir ci-artifacts
-          cp "${{ steps.artifact-metadata.outputs.artifact-name }}.tar.xz" ci-artifacts/macOS-${{ inputs.gui }}.tar.xz
+          cp "${{ steps.artifact-metadata.outputs.artifact-name }}.tar.gz" ci-artifacts/macOS-${{ inputs.gui }}.tar.gz

      - name: Upload Artifact
        uses: actions/upload-artifact@v3
        with:
          name: ${{ steps.artifact-metadata.outputs.artifact-name }}
-          path: "*.tar.xz"
+          path: "*.tar.gz"
--- a/.github/workflows/release_pipeline.yml
+++ b/.github/workflows/release_pipeline.yml
@@ -28,7 +28,25 @@ jobs:
      jobName: Qt
      configuration: CMake
      buildSystem: cmake
-      cmakeFlags: -DCMAKE_C_COMPILER=clang-cl -DCMAKE_CXX_COMPILER=clang-cl
+    secrets: inherit
+
+  build_qt_sse4:
+    if: github.repository == 'PCSX2/pcsx2'
+    name: "Windows - SSE4"
+    uses: ./.github/workflows/windows_build_qt.yml
+    with:
+      jobName: Qt
+      configuration: Release
+      simd: "SSE4"
+    secrets: inherit
+
+  build_qt_avx2:
+    if: github.repository == 'PCSX2/pcsx2'
+    name: "Windows - AVX2"
+    uses: ./.github/workflows/windows_build_qt.yml
+    with:
+      jobName: Qt
+      configuration: Release AVX2
    secrets: inherit

  # MacOS
@@ -47,6 +65,8 @@ jobs:
    needs:
      - build_linux_qt
      - build_windows_qt
+      - build_qt_sse4
+      - build_qt_avx2
      - build_macos_qt
    name: "Upload Artifacts"
    runs-on: ubuntu-latest
--- a/.github/workflows/scripts/linux/appimage-qt.sh
+++ b/.github/workflows/scripts/linux/appimage-qt.sh
@@ -87,7 +87,6 @@ declare -a SYSLIBS=(
 	"libvorbis.so.0"
 	"libvorbisenc.so.2"
 	"libxcb.so.1"
-	"libxcb-cursor.so.0"
 	"libxcb-render.so.0"
 	"libxcb-shm.so.0"
 	"libxkbcommon.so.0"
@@ -158,7 +157,6 @@ declare -a SYSLIBS=(
 	"libhx509.so.5"
 	"libsqlite3.so.0"
 	"libcrypt.so.1"
-	"libdbus-1.so.3"
 )

 declare -a DEPLIBS=(
@@ -208,9 +206,6 @@ mkdir "$OUTDIR/usr"
 echo "Copying binary and resources..."
 cp -a "$BUILDDIR/bin" "$OUTDIR/usr"

-# Get rid of unit tests, we don't want them bloating the squashfs.
-rm -fv "$OUTDIR"/usr/bin/*_test
-
 # Patch RPATH so the binary goes hunting for shared libraries in the AppDir instead of system.
 echo "Patching RPATH in ${BINARY}..."
 patchelf --set-rpath '$ORIGIN/../lib' "$OUTDIR/usr/bin/$BINARY"
--- a/.github/workflows/scripts/linux/build-dependencies-qt.sh
+++ b/.github/workflows/scripts/linux/build-dependencies-qt.sh
@@ -4,26 +4,23 @@ set -e

 INSTALLDIR="$HOME/deps"
 NPROCS="$(getconf _NPROCESSORS_ONLN)"
-SDL=SDL2-2.26.5
-QT=6.5.0
-LIBBACKTRACE=ad106d5fdd5d960bd33fae1c48a351af567fd075
+SDL=SDL2-2.26.0
+QT=6.3.1

 mkdir -p deps-build
 cd deps-build

 cat > SHASUMS <<EOF
-ad8fea3da1be64c83c45b1d363a6b4ba8fd60f5bde3b23ec73855709ec5eabf7  $SDL.tar.gz
-fd6f417fe9e3a071cf1424a5152d926a34c4a3c5070745470be6cf12a404ed79  $LIBBACKTRACE.zip
-fde1aa7b4fbe64ec1b4fc576a57f4688ad1453d2fab59cbadd948a10a6eaf5ef  qtbase-everywhere-src-$QT.tar.xz
-64ca7e61f44d51e28bcbb4e0509299b53a9a7e38879e00a7fe91643196067a4f  qtsvg-everywhere-src-$QT.tar.xz
-49c33d96b0a44988be954269b8ce3d1a495b439726e03a6be7c0d50a686369c4  qttools-everywhere-src-$QT.tar.xz
-fc85d0fd8393f518653ccada1014177a56df6e73f30f3b64eea0c2e4a0067a3d  qttranslations-everywhere-src-$QT.tar.xz
-ccc57fa277fc5f1c1c2c4733eae80a60996b67a067233c47809e542aa31759a3  qtwayland-everywhere-src-$QT.tar.xz
+8000d7169febce93c84b6bdf376631f8179132fd69f7015d4dadb8b9c2bdb295  $SDL.tar.gz
+0a64421d9c2469c2c48490a032ab91d547017c9cc171f3f8070bc31888f24e03  qtbase-everywhere-src-$QT.tar.xz
+7b19f418e6f7b8e23344082dd04440aacf5da23c5a73980ba22ae4eba4f87df7  qtsvg-everywhere-src-$QT.tar.xz
+c412750f2aa3beb93fce5f30517c607f55daaeb7d0407af206a8adf917e126c1  qttools-everywhere-src-$QT.tar.xz
+d7bdd55e2908ded901dcc262157100af2a490bf04d31e32995f6d91d78dfdb97  qttranslations-everywhere-src-$QT.tar.xz
+6f14fea2d172a5b4170be3efcb0e58535f6605b61bcd823f6d5c9d165bb8c0f0  qtwayland-everywhere-src-$QT.tar.xz
 EOF

 curl -L \
 	-O "https://libsdl.org/release/$SDL.tar.gz" \
-	-O "https://github.com/ianlancetaylor/libbacktrace/archive/$LIBBACKTRACE.zip" \
 	-O "https://download.qt.io/official_releases/qt/${QT%.*}/$QT/submodules/qtbase-everywhere-src-$QT.tar.xz" \
 	-O "https://download.qt.io/official_releases/qt/${QT%.*}/$QT/submodules/qtsvg-everywhere-src-$QT.tar.xz" \
 	-O "https://download.qt.io/official_releases/qt/${QT%.*}/$QT/submodules/qttools-everywhere-src-$QT.tar.xz" \
@@ -40,14 +37,6 @@ make "-j$NPROCS"
 make install
 cd ..

-echo "Building libbacktrace..."
-unzip "$LIBBACKTRACE.zip"
-cd "libbacktrace-$LIBBACKTRACE"
-./configure --prefix="$HOME/deps"
-make
-make install
-cd ..
-
 # Couple notes:
 # -fontconfig is needed otherwise Qt Widgets render only boxes.
 # -qt-doubleconversion avoids a dependency on libdouble-conversion.
@@ -76,6 +65,19 @@ cd ../../
 echo "Building Qt Wayland..."
 tar xf "qtwayland-everywhere-src-$QT.tar.xz"
 cd "qtwayland-everywhere-src-$QT"
+# qtwayland does not build without qml/qtdeclarative in 6.3.1. Work around it.
+patch -u src/compositor/CMakeLists.txt <<EOF
+--- src/compositor/CMakeLists.txt	2022-06-08 13:44:30.000000000 +1000
+++ src/compositor/CMakeLists.txt	2022-07-17 20:05:25.461881785 +1000
+@@ -46,7 +46,6 @@
+         global/qtwaylandcompositorglobal.h
+         global/qtwaylandqmlinclude.h
+         global/qwaylandcompositorextension.cpp global/qwaylandcompositorextension.h global/qwaylandcompositorextension_p.h
+-        global/qwaylandquickextension.cpp global/qwaylandquickextension.h
+         global/qwaylandutils_p.h
+         hardware_integration/qwlclientbufferintegration.cpp hardware_integration/qwlclientbufferintegration_p.h
+         wayland_wrapper/qwlbuffermanager.cpp wayland_wrapper/qwlbuffermanager_p.h
+EOF
 mkdir build
 cd build
 cmake -G Ninja -DCMAKE_PREFIX_PATH="$INSTALLDIR" -DCMAKE_INSTALL_PREFIX="$INSTALLDIR" -DCMAKE_BUILD_TYPE=Release ..
@@ -101,30 +103,6 @@ patch -u src/linguist/CMakeLists.txt <<EOF
     add_subdirectory(linguist)
 endif()
 EOF
-
-# Also force disable clang scanning, it gets very confused.
-patch -u configure.cmake <<EOF
--- configure.cmake
-+++ configure.cmake
-@@ -14,12 +14,12 @@
- # Presumably because 6.0 ClangConfig.cmake files are not good enough?
- # In any case explicitly request a minimum version of 8.x for now, otherwise
- # building with CMake will fail at compilation time.
-qt_find_package(WrapLibClang 8 PROVIDED_TARGETS WrapLibClang::WrapLibClang)
-+#qt_find_package(WrapLibClang 8 PROVIDED_TARGETS WrapLibClang::WrapLibClang)
- # special case end
-
-if(TARGET WrapLibClang::WrapLibClang)
-    set(TEST_libclang "ON" CACHE BOOL "Required libclang version found." FORCE)
-endif()
-+#if(TARGET WrapLibClang::WrapLibClang)
-+#    set(TEST_libclang "ON" CACHE BOOL "Required libclang version found." FORCE)
-+#endif()
-
-
-
-EOF
-
 mkdir build
 cd build
 cmake -G Ninja -DCMAKE_PREFIX_PATH="$INSTALLDIR" -DCMAKE_INSTALL_PREFIX="$INSTALLDIR" -DCMAKE_BUILD_TYPE=Release -DFEATURE_assistant=OFF -DFEATURE_clang=OFF -DFEATURE_designer=OFF -DFEATURE_kmap2qmap=OFF -DFEATURE_pixeltool=OFF -DFEATURE_pkg_config=OFF -DFEATURE_qev=OFF -DFEATURE_qtattributionsscanner=OFF -DFEATURE_qtdiag=OFF -DFEATURE_qtplugininfo=OFF ..
--- a/.github/workflows/scripts/macos/build-dependencies.sh
+++ b/.github/workflows/scripts/macos/build-dependencies.sh
@@ -6,11 +6,11 @@ export MACOSX_DEPLOYMENT_TARGET=10.14

 INSTALLDIR="$HOME/deps"
 NPROCS="$(getconf _NPROCESSORS_ONLN)"
-SDL=SDL2-2.26.5
+SDL=SDL2-2.26.0
 PNG=1.6.37
 JPG=9e
 SOUNDTOUCH=soundtouch-2.3.1
-QT=6.4.3
+QT=6.3.1

 mkdir deps-build
 cd deps-build
@@ -21,14 +21,14 @@ export CFLAGS="-I$INSTALLDIR/include -Os $CFLAGS"
 export CXXFLAGS="-I$INSTALLDIR/include -Os $CXXFLAGS"

 cat > SHASUMS <<EOF
-ad8fea3da1be64c83c45b1d363a6b4ba8fd60f5bde3b23ec73855709ec5eabf7  $SDL.tar.gz
+8000d7169febce93c84b6bdf376631f8179132fd69f7015d4dadb8b9c2bdb295  $SDL.tar.gz
 505e70834d35383537b6491e7ae8641f1a4bed1876dbfe361201fc80868d88ca  libpng-$PNG.tar.xz
 4077d6a6a75aeb01884f708919d25934c93305e49f7e3f36db9129320e6f4f3d  jpegsrc.v$JPG.tar.gz
 6900996607258496ce126924a19fe9d598af9d892cf3f33d1e4daaa9b42ae0b1  $SOUNDTOUCH.tar.gz
-5087c9e5b0165e7bc3c1a4ab176b35d0cd8f52636aea903fa377bdba00891a60  qtbase-everywhere-src-$QT.tar.xz
-88315f886cf81898705e487cedba6e6160724359d23c518c92c333c098879a4a  qtsvg-everywhere-src-$QT.tar.xz
-867df829cd5cd3ae8efe62e825503123542764b13c96953511e567df70c5a091  qttools-everywhere-src-$QT.tar.xz
-79e56b7800d49649a8a8010818538c367a829e0b7a09d5f60bd3aecf5abe972c  qttranslations-everywhere-src-$QT.tar.xz
+0a64421d9c2469c2c48490a032ab91d547017c9cc171f3f8070bc31888f24e03  qtbase-everywhere-src-$QT.tar.xz
+7b19f418e6f7b8e23344082dd04440aacf5da23c5a73980ba22ae4eba4f87df7  qtsvg-everywhere-src-$QT.tar.xz
+c412750f2aa3beb93fce5f30517c607f55daaeb7d0407af206a8adf917e126c1  qttools-everywhere-src-$QT.tar.xz
+d7bdd55e2908ded901dcc262157100af2a490bf04d31e32995f6d91d78dfdb97  qttranslations-everywhere-src-$QT.tar.xz
 EOF

 curl -L \
--- a/.github/workflows/scripts/releases/rename-release-assets.py
+++ b/.github/workflows/scripts/releases/rename-release-assets.py
@@ -4,7 +4,7 @@ import shutil
 tag = os.environ['TAG'].split("refs/tags/")[1]
 scan_dir = os.environ['SCAN_DIR']
 output_dir = os.environ['OUT_DIR']
-accepted_exts = ["AppImage", "tar.xz", "7z"]
+accepted_exts = ["AppImage", "tar.gz", "7z"]


 for dir_name in os.listdir(scan_dir):
--- a/.github/workflows/windows_build_matrix.yml
+++ b/.github/workflows/windows_build_matrix.yml
@@ -38,8 +38,8 @@ jobs:
      configuration: Release AVX2
    secrets: inherit

-  build_qt_cmake:
-    name: "CMake"
+  build_qt_sse4_cmake:
+    name: "CMake SSE4"
    uses: ./.github/workflows/windows_build_qt.yml
    with:
      jobName: Qt
@@ -65,13 +65,3 @@ jobs:
      jobName: Qt Clang
      configuration: Release Clang AVX2
    secrets: inherit
-
-  build_qt_cmake_clang:
-    name: "CMake"
-    uses: ./.github/workflows/windows_build_qt.yml
-    with:
-      jobName: Qt Clang
-      configuration: CMake
-      buildSystem: cmake
-      cmakeFlags: -DCMAKE_C_COMPILER=clang-cl -DCMAKE_CXX_COMPILER=clang-cl -DPCSX2_EXE_NAME=pcsx2-qt-clang
-    secrets: inherit
--- a/.github/workflows/windows_build_qt.yml
+++ b/.github/workflows/windows_build_qt.yml
@@ -25,18 +25,14 @@ on:
        required: false
        type: string
        default: msbuild
-      cmakeFlags:
-        required: false
-        type: string
-        default: ""
      qt_binary_url:
        required: false
        type: string
-        default: https://github.com/PCSX2/pcsx2-windows-dependencies/releases/download/2023-04-25/qt-6.5.0-x64.7z
+        default: https://github.com/PCSX2/pcsx2-windows-dependencies/releases/download/2022-11-20/qt-6.4.0-x64.7z
      qt_dir:
        required: false
        type: string
-        default: 3rdparty\qt\6.5.0\msvc2022_64
+        default: 3rdparty\qt\6.4.0\msvc2022_64
      cheats_url:
        required: false
        type: string
@@ -96,7 +92,7 @@ jobs:
        shell: cmd
        run: |
          call "%ProgramFiles%\Microsoft Visual Studio\2022\Enterprise\VC\Auxiliary\Build\vcvars64.bat"
-          cmake . -B build ${{ inputs.cmakeFlags }} "-DCMAKE_PREFIX_PATH=%cd%\${{ inputs.qt_dir }}" -DQT_BUILD=ON -DCMAKE_BUILD_TYPE=Release -DCMAKE_INTERPROCEDURAL_OPTIMIZATION=ON -DDISABLE_ADVANCE_SIMD=ON -G Ninja
+          cmake . -B build "-DCMAKE_PREFIX_PATH=%cd%\${{ inputs.qt_dir }}" -DQT_BUILD=ON -DCMAKE_BUILD_TYPE=Release -DCMAKE_INTERPROCEDURAL_OPTIMIZATION=ON -DDISABLE_ADVANCE_SIMD=ON -G Ninja

      - name: Build PCSX2
        shell: cmd
--- a/3rdparty/imgui/imgui.vcxproj
+++ b/3rdparty/imgui/imgui.vcxproj
@@ -33,9 +33,14 @@
    <ClCompile>
      <PreprocessorDefinitions>%(PreprocessorDefinitions)</PreprocessorDefinitions>
      <WarningLevel>TurnOffAllWarnings</WarningLevel>
-      <AdditionalIncludeDirectories>$(ProjectDir)include;$(ProjectDir)src;%(AdditionalIncludeDirectories)</AdditionalIncludeDirectories>
+      <AdditionalIncludeDirectories>$(SolutionDir)3rdparty\glad\include;$(ProjectDir)include;$(ProjectDir)src;%(AdditionalIncludeDirectories)</AdditionalIncludeDirectories>
    </ClCompile>
  </ItemDefinitionGroup>
+  <ItemGroup>
+    <ProjectReference Include="$(SolutionDir)3rdparty\glad\glad.vcxproj">
+      <Project>{c0293b32-5acf-40f0-aa6c-e6da6f3bf33a}</Project>
+    </ProjectReference>
+  </ItemGroup>
  <ItemGroup>
    <ClInclude Include="include\imconfig.h" />
    <ClInclude Include="include\imgui.h" />
@@ -55,4 +60,4 @@
  </ItemGroup>
  <Import Project="$(VCTargetsPath)\Microsoft.Cpp.targets" />
  <ImportGroup Label="ExtensionTargets" />
-</Project>
+</Project>
--- a/3rdparty/libchdr/libchdr
+++ b/3rdparty/libchdr/libchdr
--- a/3rdparty/rainterface/CMakeLists.txt
+++ b/3rdparty/rainterface/CMakeLists.txt
@@ -1,10 +0,0 @@
-add_library(rainterface
-	RA_Consoles.h
-	RA_Emulators.h
-	RA_Interface.cpp
-	RA_Interface.h
-)
-
-target_include_directories(rainterface PRIVATE "${CMAKE_CURRENT_SOURCE_DIR}")
-target_include_directories(rainterface INTERFACE "${CMAKE_CURRENT_SOURCE_DIR}")
-
--- a/3rdparty/sdl2/CMakeLists.txt
+++ b/3rdparty/sdl2/CMakeLists.txt
@@ -18,7 +18,7 @@ set(SDL_X11 OFF CACHE BOOL "")
 set(SDL_WAYLAND OFF CACHE BOOL "")
 set(SDL_RPI OFF CACHE BOOL "")
 set(SDL_COCOA ON CACHE BOOL "")
-set(SDL_DIRECTX ON CACHE BOOL "")
+set(SDL_DIRECTX OFF CACHE BOOL "")
 set(SDL_WASAPI OFF CACHE BOOL "")
 set(SDL_RENDER_D3D OFF CACHE BOOL "")
 set(SDL_RENDER_METAL OFF CACHE BOOL "")
--- a/3rdparty/sdl2/SDL
+++ b/3rdparty/sdl2/SDL
--- a/PCSX2_qt.sln
+++ b/PCSX2_qt.sln
@@ -25,7 +25,7 @@ Project("{8BC9CEB8-8B4A-11D0-8D11-00A0C91BC942}") = "jpgd", "3rdparty\jpgd\jpgd.
 EndProject
 Project("{8BC9CEB8-8B4A-11D0-8D11-00A0C91BC942}") = "common", "common\common.vcxproj", "{4639972E-424E-4E13-8B07-CA403C481346}"
 EndProject
-Project("{8BC9CEB8-8B4A-11D0-8D11-00A0C91BC942}") = "pcsx2", "pcsx2\pcsx2.vcxproj", "{6C7986C4-3E4D-4DCC-B3C6-6BB12B238995}"
+Project("{8BC9CEB8-8B4A-11D0-8D11-00A0C91BC942}") = "pcsx2core", "pcsx2\pcsx2core.vcxproj", "{6C7986C4-3E4D-4DCC-B3C6-6BB12B238995}"
 EndProject
 Project("{8BC9CEB8-8B4A-11D0-8D11-00A0C91BC942}") = "glad", "3rdparty\glad\glad.vcxproj", "{C0293B32-5ACF-40F0-AA6C-E6DA6F3BF33A}"
 EndProject
--- a/README.md
+++ b/README.md
@@ -22,7 +22,7 @@ Installers and binaries for both stable and development builds are available fro

 | Operating System                                                                                                               | CPU                                                                                                                                                                                             | GPU                                                                                                                                                                                               | RAM  |
 | ------------------------------------------------------------------------------------------------------------------------------ | ----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- | ------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- | ---- |
-| - Windows 10 21H2 (1809 or later) (64-bit) <br/> - Ubuntu 20.04/Debian or newer, Arch Linux, or other distro (64-bit) <br/> - macOS 10.14 | - Supports SSE4.1 <br/> - [PassMark Thread Performance](https://www.cpubenchmark.net/CPU_mega_page.html) rating near or greater than 1800<br/> - Two physical cores, with hyperthreading | - Direct3D10 support <br/> - OpenGL 3.x support <br/> - Vulkan 1.1 support <br/> - Metal support <br/> - [PassMark G3D Mark](https://www.videocardbenchmark.net/high_end_gpus.html) rating around 3000 (Geforce GTX 750, Radeon RX 560, Intel Arc A380) <br/> - 2 GB Video Memory | 4 GB |
+| - Windows 10 21H2 (1809 or later) (64-bit) <br/> - Ubuntu 20.04/Debian or newer, Arch Linux, or other distro (64-bit) <br/> - macOS 10.14 | - Supports SSE4.1 <br/> - [PassMark Single Thread Performance](https://www.cpubenchmark.net/singleThread.html) rating near or greater than 1800 <br/> - Two physical cores, with hyperthreading | - Direct3D10 support <br/> - OpenGL 3.x support <br/> - Vulkan 1.1 support <br/> - Metal support <br/> - [PassMark G3D Mark](https://www.videocardbenchmark.net/high_end_gpus.html) rating around 3000 (Geforce GTX 750 Radeon RX 560 Intel Arc A380) <br/> - 2 GB Video Memory | 4 GB |

 _Note: Recommended Single Thread Performance is based on moderately complex games. Games that pushed the PS2 hardware to its limits will struggle on CPUs at this level. Some release titles and 2D games which underutilized the PS2 hardware may run on CPUs rated as low as 1200. A quick reference for CPU **intensive games**: [Wiki](https://wiki.pcsx2.net/Category:CPU_intensive_games), [Forum](https://forums.pcsx2.net/Thread-LIST-The-Most-CPU-Intensive-Games) and CPU **light** games: [Forum](https://forums.pcsx2.net/Thread-LIST-Games-that-don-t-need-a-strong-CPU-to-emulate)_

@@ -30,16 +30,16 @@ _Note: Recommended Single Thread Performance is based on moderately complex game

 | Operating System                                                                                                              | CPU                                                                                                                                                                                                       | GPU                                                                                                                                                                                                   | RAM  |
 | ----------------------------------------------------------------------------------------------------------------------------- | --------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- | ----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- | ---- |
-| - Windows 10 21H2 (1809 or later) (64-bit) <br/> - Ubuntu 22.04/Debian or newer, Arch Linux, or other distro (64-bit) <br/> - macOS 10.14 | - Supports AVX2 <br/> - [PassMark Single Thread Performance](https://www.cpubenchmark.net/CPU_mega_page.html) rating near or greater than 2600<br/> - Four physical cores, with or without hyperthreading | - Direct3D12 support <br/> - OpenGL 4.6 support <br/> - Vulkan 1.3 support <br/> - Metal support <br/> - [PassMark G3D Mark](https://www.videocardbenchmark.net/high_end_gpus.html) rating around 6000 (GeForce GTX 1650, Radeon RX 570) <br/> - 4 GB Video Memory | 8 GB |
+| - Windows 10 21H2 (1809 or later) (64-bit) <br/> - Ubuntu 22.04/Debian or newer, Arch Linux, or other distro (64-bit) <br/> - macOS 10.14 | - Supports AVX2 <br/> - [PassMark Single Thread Performance](https://www.cpubenchmark.net/singleThread.html) rating near or greater than 2600 <br/> - Four physical cores, with or without hyperthreading | - Direct3D12 support <br/> - OpenGL 4.6 support <br/> - Vulkan 1.3 support <br/> - Metal support <br/> - [PassMark G3D Mark](https://www.videocardbenchmark.net/high_end_gpus.html) rating around 6000 (GeForce GTX 1650 Radeon RX 570) <br/> - 4 GB Video Memory | 8 GB |

 _Note: Recommended GPU is based on 3x Internal, ~1080p resolution requirements. Higher resolutions will require stronger cards; 6x Internal, ~4K resolution will require a [PassMark G3D Mark](https://www.videocardbenchmark.net/high_end_gpus.html) rating around 12000 (GeForce RTX 2060 Radeon RX 6600 Intel Arc A750). Just like CPU requirements, this is also highly game dependent. A quick reference for GPU **intensive games**: [Wiki](https://wiki.pcsx2.net/Category:GPU_intensive_games)_

 ### Technical Notes

-   You need the [Visual C++ 2019 x64 Redistributables](https://support.microsoft.com/en-us/help/2977003/) to run PCSX2 on Windows.
+-   You need the [Visual C++ 2019 x64 Redistributables](https://support.microsoft.com/en-us/help/2977003/) to run PCSX2.
 -   Windows XP and Direct3D9 support was dropped after stable release 1.4.0.
 -   Windows 7, Windows 8.0, and Windows 8.1 support was dropped after stable release 1.6.0.
-   32-bit and wxWidgets support was dropped after stable release 1.6.0, with the wxWidgets code being removed completely on 25th December 2022.
+-   32-bit and wxwidgets support was dropped after stable release 1.6.0, with the wxwidgets code being removed completely on 25th December 2022.
 -   Make sure to update your operating system and drivers to ensure you have the best experience possible. Having a newer GPU is also recommended so you have the latest supported drivers.
 -   Because of copyright issues, and the complexity of trying to work around it, you need a BIOS dump extracted from a legitimately-owned PS2 console to use the emulator. For more information about the BIOS and how to get it from your console, visit [this page](pcsx2/Docs/PCSX2_FAQ.md#question-13-where-do-i-get-a-ps2-bios).
 -   PCSX2 uses two CPU cores for emulation by default. A third core can be used via the MTVU speed hack, which is compatible with most games. This can be a significant speedup on CPUs with 3+ cores, but it may be a slowdown on GS-limited games (or on CPUs with fewer than 2 cores). Software renderers will then additionally use however many rendering threads it is set to and will need higher core counts to run efficiently.
--- a/bin/docs/PCSX2.1
+++ b/bin/docs/PCSX2.1
@@ -0,0 +1,189 @@
+.\" Copyright 2002-2017 PCSX2 Dev Team
+.\"
+.\" This is free documentation; you can redistribute it and/or
+.\" modify it under the terms of the GNU General Public License as
+.\" published by the Free Software Foundation; either version 3 of
+.\" the License, or (at your option) any later version.
+.\"
+.\" The GNU General Public License's references to "object code"
+.\" and "executables" are to be interpreted as the output of any
+.\" document formatting or typesetting system, including
+.\" intermediate and printed output.
+.\"
+.\" This manual is distributed in the hope that it will be useful,
+.\" but WITHOUT ANY WARRANTY; without even the implied warranty of
+.\" MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+.\" GNU General Public License for more details.
+.\"
+.\" You should have received a copy of the GNU General Public
+.\" License along with this manual; if not, see
+.\" http://www.gnu.org/licenses.
+.Dd January 10, 2017
+.Dt PCSX2 1
+.Os
+.Sh NAME
+.Nm PCSX2
+.Nd PlayStation(R)2 Console Emulator
+.Sh SYNOPSIS
+.Nm
+.Op Fl h
+.Op Fl \-cfg Ns = Ns Ar file
+.Op Fl \-cfgpath Ns = Ns Ar path
+.Op Fl \-console
+.Op Fl \-forcewiz
+.Op Fl \-portable
+.Op Fl \-profiling
+.Op Fl \-elf Ns = Ns Ar file
+.Op Fl \-irx Ns = Ns Ar file
+.Op Fl \-nogui
+.Op Fl \-noguiprompt
+.Op Fl \-nodisc
+.Op Fl \-usecd
+.Op Fl \-fullscreen
+.Op Fl \-windowed
+.Op Fl \-nohacks
+.Op Fl \-fullboot
+.Op Fl \-gamefixes Ns = Ns Ar string
+.Op Fl \-gs Ns = Ns Ar file
+.Op Fl \-pad Ns = Ns Ar file
+.Op Fl \-spu2 Ns = Ns Ar file
+.Op Fl \-cdvd Ns = Ns Ar file
+.Op Fl \-usb Ns = Ns Ar file
+.Op Fl \-fw Ns = Ns Ar file
+.Op Fl \-dev9 Ns = Ns Ar file
+.Op Ar iso
+.Sh DESCRIPTION
+.Nm
+is an open-source PlayStation 2 (AKA PS2) emulator.
+Its purpose is to emulate the PS2 hardware, using a combination of MIPS CPU
+interpreters, recompilers and a virtual machine that manages hardware states and
+PS2 memory.
+This allows you to play PS2 games on your PC, with many additional features and
+benefits.
+.Sh GENERAL OPTIONS
+.Bl -tag -width Ds
+.It Fl h , Fl \-help
+Displays the list of available command line options.
+.It Fl \-cfg Ns = Ns Ar file
+Uses
+.Ar file
+instead of PCSX2_vm.ini as the configuration file.
+It does not affect plugins.
+.It Fl \-cfgpath Ns = Ns Ar path
+Specifies
+.Ar path
+as the configuration file path.
+It affects both
+.Nm
+and the plugins.
+.It Fl \-console
+Forces the program log to be visible.
+.It Fl \-forcewiz
+Forces the First-Time Wizard to run.
+.It Fl \-portable
+Runs
+.Nm
+in portable mode.
+.It Fl \-profiling
+Makes it easier to use profiling tools.
+.El
+.Sh AUTO-RUN OPTIONS
+.Bl -tag -width Ds
+.It Ar iso
+Loads and runs
+.Ar iso
+at startup using the
+.Nm
+internal ISO loader.
+.It Fl \-elf Ns = Ns Ar file
+Executes
+.Ar file
+as an ELF image.
+.It Fl \-irx Ns = Ns Ar file
+Executes
+.Ar file
+as an IRX image.
+.It Fl \-nogui
+Disables display of the GUI while running games.
+.Nm
+will terminate when the game window is closed.
+.It Fl \-noguiprompt
+Prompt before exiting when
+.Fl \-nogui
+is used.
+.It Fl \-nodisc
+Boots with an empty DVD tray.
+Use this to boot into the PS2 system menu.
+.It Fl \-usecd
+Boots using the configured CDVD plugin instead of booting
+.Ar iso .
+.It Fl \-fullscreen
+Runs the game in fullscreen mode.
+.It Fl \-windowed
+Runs the game in windowed mode.
+.El
+.Sh COMPATIBILITY OPTIONS
+.Bl -tag -width Ds
+.It Fl \-nohacks
+Disables all speedhacks.
+.It Fl \-fullboot
+Disables the fast boot feature.
+.It Fl \-gamefixes= Ns Ar string
+Enable specific gamefixes for this session.
+.Ar string
+is a comma-separated list of gamefixes.
+.Pp
+Valid gamefixes: VuAddSub, VuClipFlag, FpuCompare, FpuMul, FpuNegDiv, XGKick,
+IpuWait, EETiming, SkipMpeg, OPHFlag, DMABusy,VIFFIFO, VIF1Stall, GIFFIFO,
+FMVinSoftware, GoemonTlb, ScarfaceIbit.
+.El
+.Sh PLUGIN OVERRIDES
+.Bl -tag -width Ds
+.It Fl \-gs Ns = Ns Ar file
+Uses
+.Ar file
+as the GS plugin.
+.It Fl \-pad Ns = Ns Ar file
+Uses
+.Ar file
+as the PAD plugin.
+.It Fl \-spu2 Ns = Ns Ar file
+Uses
+.Ar file
+as the SPU2 plugin.
+.It Fl \-cdvd Ns = Ns Ar file
+Uses
+.Ar file
+as the CDVD plugin.
+.It Fl \-usb Ns = Ns Ar file
+Uses
+.Ar file
+as the USB plugin.
+.It Fl \-fw Ns = Ns Ar file
+Uses
+.Ar file
+as the FW plugin.
+.It Fl \-dev9 Ns = Ns Ar file
+Uses
+.Ar file
+as the DEV9 plugin.
+.El
+.Sh FILES
+.Bl -tag -width Ds
+.It $XDG_CONFIG_DIR/PCSX2 or $HOME/PCSX2
+User configuration and data directory.
+.El
+.Sh AUTHORS
+.An PCSX2 Dev Team and many other contributors
+.Sh BUGS
+Bugs can be reported by submitting an issue at the
+.Lk https://github.com/PCSX2/pcsx2/issues "PCSX2 GitHub issue tracker" .
+.Sh PCSX2 RELATED WEBSITES
+.Bl -bullet
+.It
+.Lk http://github.com/PCSX2/pcsx2 "PCSX2 git repository"
+.It
+.Lk http://pcsx2.net "PCSX2 website"
+.It
+.Lk http://forums.pcsx2.net "PCSX2 forums"
+.El
--- a/bin/docs/PCSX2_FAQ.pdf
+++ b/bin/docs/PCSX2_FAQ.pdf
--- a/bin/resources/GameIndex.yaml
+++ b/bin/resources/GameIndex.yaml
--- a/bin/resources/game_controller_db.txt
+++ b/bin/resources/game_controller_db.txt
@@ -66,12 +66,12 @@
 03000000c82d00000021000000000000,8BitDo SN30 Pro,a:b0,b:b1,back:b10,dpdown:h0.4,dpleft:h0.8,dpright:h0.2,dpup:h0.1,leftshoulder:b6,leftstick:b13,lefttrigger:b8,leftx:a0,lefty:a1,rightshoulder:b7,rightstick:b14,righttrigger:b9,rightx:a2,righty:a5,start:b11,x:b3,y:b4,platform:Windows,
 03000000c82d00000160000000000000,8BitDo SN30 Pro,a:b1,b:b0,back:b10,dpdown:h0.4,dpleft:h0.8,dpright:h0.2,dpup:h0.1,guide:b2,leftshoulder:b6,leftstick:b13,lefttrigger:b8,leftx:a0,lefty:a1,rightshoulder:b7,rightstick:b14,righttrigger:b9,rightx:a2,righty:a3,start:b11,x:b4,y:b3,platform:Windows,
 03000000c82d00000161000000000000,8BitDo SN30 Pro,a:b1,b:b0,back:b10,dpdown:h0.4,dpleft:h0.8,dpright:h0.2,dpup:h0.1,guide:b2,leftshoulder:b6,leftstick:b13,lefttrigger:b8,leftx:a0,lefty:a1,rightshoulder:b7,rightstick:b14,righttrigger:b9,rightx:a2,righty:a3,start:b11,x:b4,y:b3,platform:Windows,
+03000000c82d00000121000000000000,8BitDo SN30 Pro for Android,a:b0,b:b1,back:b10,dpdown:h0.4,dpleft:h0.8,dpright:h0.2,dpup:h0.1,guide:b12,leftshoulder:b6,leftstick:b13,lefttrigger:b8,leftx:a0,lefty:a1,rightshoulder:b7,rightstick:b14,righttrigger:b9,rightx:a3,righty:a4,start:b11,x:b3,y:b4,platform:Windows,
 03000000c82d00000260000000000000,8BitDo SN30 Pro Plus,a:b1,b:b0,back:b10,dpdown:h0.4,dpleft:h0.8,dpright:h0.2,dpup:h0.1,guide:b2,leftshoulder:b6,leftstick:b13,lefttrigger:b8,leftx:a0,lefty:a1,rightshoulder:b7,rightstick:b14,righttrigger:b9,rightx:a2,righty:a3,start:b11,x:b4,y:b3,platform:Windows,
 03000000c82d00000261000000000000,8BitDo SN30 Pro Plus,a:b1,b:b0,back:b10,dpdown:h0.4,dpleft:h0.8,dpright:h0.2,dpup:h0.1,guide:b2,leftshoulder:b6,leftstick:b13,lefttrigger:b8,leftx:a0,lefty:a1,rightshoulder:b7,rightstick:b14,righttrigger:b9,rightx:a2,righty:a3,start:b11,x:b4,y:b3,platform:Windows,
 03000000c82d00001130000000000000,8BitDo Ultimate Wired,a:b0,b:b1,back:b10,dpdown:h0.4,dpleft:h0.8,dpright:h0.2,dpup:h0.1,guide:b12,leftshoulder:b6,leftstick:b13,lefttrigger:b8,leftx:a0,lefty:a1,misc1:b26,paddle1:b24,paddle2:b25,rightshoulder:b7,rightstick:b14,righttrigger:b9,rightx:a3,righty:a4,start:b11,x:b3,y:b4,platform:Windows,
 03000000c82d00001230000000000000,8BitDo Ultimate Wireless,a:b0,b:b1,back:b10,dpdown:h0.4,dpleft:h0.8,dpright:h0.2,dpup:h0.1,guide:b12,leftshoulder:b6,leftstick:b13,lefttrigger:b8,leftx:a0,lefty:a1,rightshoulder:b7,rightstick:b14,righttrigger:b9,rightx:a3,righty:a4,start:b11,x:b3,y:b4,platform:Windows,
 03000000c82d00001330000000000000,8BitDo Ultimate Wireless,a:b0,b:b1,back:b10,dpdown:h0.4,dpleft:h0.8,dpright:h0.2,dpup:h0.1,guide:b12,leftshoulder:b6,leftstick:b13,lefttrigger:a5,leftx:a0,lefty:a1,misc1:b26,paddle1:b23,paddle2:b19,rightshoulder:b7,rightstick:b14,righttrigger:a4,rightx:a2,righty:a3,start:b11,x:b3,y:b4,platform:Windows,
-03000000c82d00000121000000000000,8BitDo Xbox One SN30 Pro,a:b0,b:b1,back:b10,dpdown:h0.4,dpleft:h0.8,dpright:h0.2,dpup:h0.1,guide:b12,leftshoulder:b6,leftstick:b13,lefttrigger:b8,leftx:a0,lefty:a1,rightshoulder:b7,rightstick:b14,righttrigger:b9,rightx:a3,righty:a4,start:b11,x:b3,y:b4,platform:Windows,
 03000000a00500003232000000000000,8BitDo Zero,a:b0,b:b1,back:b10,dpdown:+a2,dpleft:-a0,dpright:+a0,dpup:-a2,leftshoulder:b6,rightshoulder:b7,start:b11,x:b3,y:b4,platform:Windows,
 03000000c82d00001890000000000000,8BitDo Zero 2,a:b1,b:b0,back:b10,dpdown:+a1,dpleft:-a0,dpright:+a0,dpup:-a1,leftshoulder:b6,rightshoulder:b7,start:b11,x:b4,y:b3,platform:Windows,
 03000000c82d00003032000000000000,8BitDo Zero 2,a:b1,b:b0,back:b10,dpdown:h0.4,dpleft:h0.8,dpright:h0.2,dpup:h0.1,leftshoulder:b6,leftx:a0,lefty:a1,rightshoulder:b7,rightx:a2,righty:a3,start:b11,x:b4,y:b3,platform:Windows,
@@ -105,8 +105,6 @@
 03000000a30c00002800000000000000,Astro City Mini,a:b2,b:b1,back:b8,leftx:a3,lefty:a4,rightshoulder:b4,righttrigger:b5,start:b9,x:b3,y:b0,platform:Windows,
 03000000050b00000579000000000000,ASUS ROG Kunai 3,a:b0,b:b1,back:b10,dpdown:h0.4,dpleft:h0.8,dpright:h0.2,dpup:h0.1,guide:b12,leftshoulder:b6,leftstick:b13,lefttrigger:b8,leftx:a0,lefty:a1,rightshoulder:b7,rightstick:b14,righttrigger:b9,rightx:a3,righty:a4,start:b11,x:b3,y:b4,platform:Windows,
 03000000050b00000679000000000000,ASUS ROG Kunai 3,a:b0,b:b1,back:b10,dpdown:h0.4,dpleft:h0.8,dpright:h0.2,dpup:h0.1,guide:b12,leftshoulder:b6,leftstick:b13,lefttrigger:b8,leftx:a0,lefty:a1,misc1:b15,rightshoulder:b7,rightstick:b14,righttrigger:b9,rightx:a3,righty:a4,start:b11,x:b3,y:b4,platform:Windows,
-03000000503200000110000000000000,Atari VCS Classic Controller,a:b0,b:b1,back:b4,dpdown:h0.4,dpleft:h0.8,dpright:h0.2,dpup:h0.1,guide:b2,start:b3,platform:Windows,
-03000000503200000210000000000000,Atari VCS Modern Controller,a:b0,b:b1,back:b10,dpdown:h0.4,dpleft:h0.8,dpright:h0.2,dpup:h0.1,guide:b8,leftshoulder:b4,leftstick:b6,leftx:a0,lefty:a1,rightshoulder:b5,rightstick:b7,rightx:a3,righty:a4,start:b9,x:b2,y:b3,platform:Windows,
 03000000e4150000103f000000000000,Batarang,a:b0,b:b1,back:b6,dpdown:h0.4,dpleft:h0.8,dpright:h0.2,dpup:h0.1,leftshoulder:b4,leftstick:b8,lefttrigger:b10,leftx:a0,lefty:a1,rightshoulder:b5,rightstick:b9,righttrigger:b11,rightx:a3,righty:a4,start:b7,x:b2,y:b3,platform:Windows,
 03000000d6200000e557000000000000,Batarang PlayStation Controller,a:b1,b:b2,back:b8,dpdown:h0.4,dpleft:h0.8,dpright:h0.2,dpup:h0.1,guide:b12,leftshoulder:b4,leftstick:b10,lefttrigger:b6,leftx:a0,lefty:a1,rightshoulder:b5,rightstick:b11,righttrigger:b7,rightx:a2,righty:a3,start:b9,x:b0,y:b3,platform:Windows,
 03000000c01100001352000000000000,Battalife Joystick,a:b6,b:b7,back:b2,leftshoulder:b0,leftx:a0,lefty:a1,rightshoulder:b1,start:b3,x:b4,y:b5,platform:Windows,
@@ -186,14 +184,13 @@
 03000000ad1b000028f0000000000000,Fightpad,a:b0,b:b1,back:b6,dpdown:h0.4,dpleft:h0.8,dpright:h0.2,dpup:h0.1,leftshoulder:b4,lefttrigger:b10,leftx:a0,lefty:a1,rightshoulder:b5,righttrigger:b11,rightx:a3,righty:a4,start:b7,x:b2,y:b3,platform:Windows,
 03000000ad1b00002ef0000000000000,Fightpad,a:b0,b:b1,back:b6,dpdown:h0.4,dpleft:h0.8,dpright:h0.2,dpup:h0.1,leftshoulder:b4,leftstick:b8,lefttrigger:b6,leftx:a0,lefty:a1,rightshoulder:b5,rightstick:b9,righttrigger:b7,rightx:a3,righty:a4,start:b7,x:b2,y:b3,platform:Windows,
 03000000ad1b000038f0000000000000,Fightpad TE,a:b0,b:b1,back:b6,dpdown:h0.4,dpleft:h0.8,dpright:h0.2,dpup:h0.1,leftshoulder:b4,lefttrigger:b8,rightshoulder:b5,righttrigger:b9,start:b7,x:b2,y:b3,platform:Windows,
-03005036852100000000000000000000,Final Fantasy XIV Online Controller,a:b1,b:b2,back:b8,dpdown:h0.4,dpleft:h0.8,dpright:h0.2,dpup:h0.1,leftshoulder:b4,leftstick:b10,lefttrigger:b6,leftx:a0,lefty:a1,rightshoulder:b5,rightstick:b11,righttrigger:b7,rightx:a2,righty:a3,start:b9,x:b0,y:b3,platform:Windows,
 03000000f806000001a3000000000000,Firestorm,a:b9,b:b7,dpdown:h0.4,dpleft:h0.8,dpright:h0.2,dpup:h0.1,leftshoulder:b0,leftstick:b10,lefttrigger:b1,leftx:a0,lefty:a1,rightshoulder:b2,rightstick:b11,righttrigger:b3,start:b12,x:b8,y:b4,platform:Windows,
 03000000b50700000399000000000000,Firestorm 2,a:b2,b:b4,back:b10,leftshoulder:b6,lefttrigger:b7,leftx:a0,lefty:a1,rightshoulder:b8,righttrigger:b9,start:b11,x:b3,y:b5,platform:Windows,
 03000000b50700001302000000000000,Firestorm D3,a:b0,b:b2,leftshoulder:b4,lefttrigger:b5,leftx:a0,lefty:a1,rightshoulder:b6,righttrigger:b7,x:b1,y:b3,platform:Windows,
 03000000b40400001024000000000000,Flydigi Apex,a:b0,b:b1,back:b10,dpdown:h0.4,dpleft:h0.8,dpright:h0.2,dpup:h0.1,leftshoulder:b6,leftstick:b13,lefttrigger:b8,leftx:a0,lefty:a1,rightshoulder:b7,rightstick:b14,righttrigger:b9,rightx:a2,righty:a5,start:b11,x:b3,y:b4,platform:Windows,
-03000000151900004000000000000000,Flydigi Vader 2,a:b27,b:b26,back:b19,dpdown:h0.4,dpleft:h0.8,dpright:h0.2,dpup:h0.1,guide:b6,leftshoulder:b23,leftstick:b17,lefttrigger:b21,leftx:a0,lefty:a1,misc1:b15,paddle1:b11,paddle2:b10,paddle3:b13,paddle4:b12,rightshoulder:b22,rightstick:b16,righttrigger:b20,rightx:a3,righty:a4,start:b18,x:b25,y:b24,platform:Windows,
-03000000b40400001124000000000000,Flydigi Vader 2,a:b0,b:b1,back:b10,dpdown:h0.4,dpleft:h0.8,dpright:h0.2,dpup:h0.1,leftshoulder:b6,leftstick:b12,lefttrigger:b8,leftx:a0,lefty:a1,misc1:b14,paddle1:b4,paddle2:b5,paddle3:b16,paddle4:b17,rightshoulder:b7,rightstick:b13,righttrigger:b9,rightx:a3,righty:a4,start:b11,x:b2,y:b3,platform:Windows,
-03000000b40400001224000000000000,Flydigi Vader 2,a:b0,b:b1,back:b10,dpdown:h0.4,dpleft:h0.8,dpright:h0.2,dpup:h0.1,leftshoulder:b6,leftstick:b12,lefttrigger:b8,leftx:a0,lefty:a1,misc1:b2,paddle1:b16,paddle2:b17,paddle3:b14,paddle4:b15,rightshoulder:b7,rightstick:b13,righttrigger:b9,rightx:a3,righty:a4,start:b11,x:b3,y:b4,platform:Windows,
+03000000151900004000000000000000,Flydigi Vader 2,a:b11,b:b10,back:b3,dpdown:h0.4,dpleft:h0.8,dpright:h0.2,dpup:h0.1,leftshoulder:b7,leftstick:b1,lefttrigger:b5,leftx:a0,lefty:a1,rightshoulder:b6,rightstick:b0,righttrigger:b4,rightx:a3,righty:a4,start:b2,x:b9,y:b8,platform:Windows,
+03000000b40400001124000000000000,Flydigi Vader 2,a:b0,b:b1,back:b10,dpdown:h0.4,dpleft:h0.8,dpright:h0.2,dpup:h0.1,leftshoulder:b6,leftstick:b12,lefttrigger:b8,leftx:a0,lefty:a1,paddle1:b4,paddle2:b5,paddle4:b17,rightshoulder:b7,rightstick:b13,righttrigger:b9,rightx:a3,righty:a4,start:b11,x:b2,y:b3,platform:Windows,
+03000000b40400001224000000000000,Flydigi Vader 2 Pro,a:b0,b:b1,back:b10,dpdown:h0.4,dpleft:h0.8,dpright:h0.2,dpup:h0.1,leftshoulder:b6,leftstick:b12,lefttrigger:a5,leftx:a0,lefty:a1,paddle1:b15,paddle2:b16,paddle3:b17,paddle4:b18,rightshoulder:b7,rightstick:b13,righttrigger:a4,rightx:a2,righty:a3,start:b11,x:b3,y:b4,platform:Windows,
 030000008305000000a0000000000000,G08XU,a:b0,b:b1,back:b4,dpdown:+a1,dpleft:-a0,dpright:+a0,dpup:-a1,leftshoulder:b6,rightshoulder:b7,start:b5,x:b2,y:b3,platform:Windows,
 0300000066f700000100000000000000,Game VIB Joystick,a:b2,b:b3,back:b10,dpdown:h0.4,dpleft:h0.8,dpright:h0.2,dpup:h0.1,leftshoulder:b4,leftstick:b8,lefttrigger:b6,leftx:a0,lefty:a1,rightshoulder:b5,rightstick:b9,righttrigger:b7,rightx:a3,righty:a2,start:b11,x:b0,y:b1,platform:Windows,
 03000000260900002625000000000000,GameCube Controller,a:b0,b:b1,dpdown:h0.4,dpleft:h0.8,dpright:h0.2,dpup:h0.1,guide:b6,lefttrigger:a4,leftx:a0,lefty:a1,righttrigger:a5,rightx:a2,righty:a3,start:b7,x:b2,y:b3,platform:Windows,
@@ -305,7 +302,6 @@
 03000000242e00000b20000000000000,Hyperkin Admiral N64 Controller,+rightx:b11,+righty:b13,-rightx:b8,-righty:b12,a:b1,b:b0,dpdown:h0.4,dpleft:h0.8,dpright:h0.2,dpup:h0.1,leftshoulder:b4,lefttrigger:b14,leftx:a0,lefty:a1,rightshoulder:b5,start:b9,platform:Windows,
 03000000242e0000ff0b000000000000,Hyperkin N64 Adapter,a:b1,b:b2,dpdown:h0.4,dpleft:h0.8,dpright:h0.2,dpup:h0.1,leftshoulder:b4,lefttrigger:b6,leftx:a0,lefty:a1,rightshoulder:b5,rightx:a2,righty:a3,start:b9,platform:Windows,
 03000000790000004e95000000000000,Hyperkin N64 Controller Adapter,a:b1,b:b2,dpdown:h0.4,dpleft:h0.8,dpright:h0.2,dpup:h0.1,leftshoulder:b7,lefttrigger:b4,leftx:a0,lefty:a1,rightshoulder:b5,rightx:a5,righty:a2,start:b9,platform:Windows,
-03000000242e00006a38000000000000,Hyperkin Trooper 2,a:b0,b:b1,back:b4,leftshoulder:b2,leftx:a0,lefty:a1,rightshoulder:b3,start:b5,platform:Windows,
 03000000d81d00000e00000000000000,iBuffalo AC02 Arcade Joystick,a:b0,b:b1,back:b9,dpdown:h0.4,dpleft:h0.8,dpright:h0.2,dpup:h0.1,leftshoulder:b6,leftstick:b10,lefttrigger:b7,leftx:a0,lefty:a1,rightshoulder:b2,rightstick:b11,righttrigger:b3,rightx:a2,righty:a5,start:b8,x:b4,y:b5,platform:Windows,
 03000000d81d00000f00000000000000,iBuffalo BSGP1204 Series,a:b2,b:b1,back:b8,dpdown:h0.4,dpleft:h0.8,dpright:h0.2,dpup:h0.1,leftshoulder:b6,leftstick:b10,lefttrigger:b4,leftx:a0,lefty:a1,rightshoulder:b7,rightstick:b11,righttrigger:b5,rightx:a2,righty:a3,start:b9,x:b3,y:b0,platform:Windows,
 03000000d81d00001000000000000000,iBuffalo BSGP1204P Series,a:b2,b:b1,back:b8,dpdown:h0.4,dpleft:h0.8,dpright:h0.2,dpup:h0.1,leftshoulder:b6,leftstick:b10,lefttrigger:b4,leftx:a0,lefty:a1,rightshoulder:b7,rightstick:b11,righttrigger:b5,rightx:a2,righty:a3,start:b9,x:b3,y:b0,platform:Windows,
@@ -378,7 +374,7 @@
 030000009f000000adbb000000000000,MaxJoypad Virtual Controller,a:b1,b:b2,back:b9,dpdown:h0.4,dpleft:h0.8,dpright:h0.2,dpup:h0.1,leftshoulder:b4,lefttrigger:b6,leftx:a0,lefty:a1,rightshoulder:b5,righttrigger:b7,rightx:a2,righty:a3,start:b8,x:b3,y:b0,platform:Windows,
 03000000250900000128000000000000,Mayflash Arcade Stick,a:b1,b:b2,back:b8,leftshoulder:b0,lefttrigger:b4,leftx:a0,lefty:a1,rightshoulder:b3,righttrigger:b7,start:b9,x:b5,y:b6,platform:Windows,
 030000008f0e00001330000000000000,Mayflash Controller Adapter,a:b1,b:b2,back:b8,dpdown:h0.8,dpleft:h0.2,dpright:h0.1,dpup:h0.4,leftshoulder:b6,lefttrigger:b8,leftx:a0,lefty:a1,rightshoulder:b7,rightx:a3~,righty:a2,start:b9,x:b0,y:b3,platform:Windows,
-03000000242f00003700000000000000,Mayflash F101,a:b1,b:b2,back:b8,dpdown:h0.4,dpleft:h0.8,dpright:h0.2,dpup:h0.1,guide:b12,leftshoulder:b4,lefttrigger:b6,rightshoulder:b5,righttrigger:b7,start:b9,x:b0,y:b3,platform:Windows,
+03000000242f00003700000000000000,Mayflash F101,a:b1,b:b2,back:b8,dpleft:h0.8,dpright:h0.2,dpup:h0.1,guide:b12,leftshoulder:b4,lefttrigger:b6,rightshoulder:b5,righttrigger:b7,start:b9,x:b0,y:b3,platform:Windows,
 03000000790000003018000000000000,Mayflash F300 Arcade Joystick,a:b1,b:b2,back:b8,dpdown:h0.4,dpleft:h0.8,dpright:h0.2,dpup:h0.1,leftshoulder:b4,lefttrigger:b6,leftx:a0,lefty:a1,rightshoulder:b5,righttrigger:b7,start:b9,x:b0,y:b3,platform:Windows,
 03000000242f00003900000000000000,Mayflash F300 Elite Arcade Joystick,a:b1,b:b2,back:b8,dpdown:h0.4,dpleft:h0.8,dpright:h0.2,dpup:h0.1,leftshoulder:b4,leftstick:b10,lefttrigger:b6,leftx:a0,lefty:a1,rightshoulder:b5,rightstick:b11,righttrigger:b7,rightx:a2,righty:a5,start:b9,x:b0,y:b3,platform:Windows,
 03000000790000004418000000000000,Mayflash GameCube Controller,a:b1,b:b2,dpdown:h0.4,dpleft:h0.8,dpright:h0.2,dpup:h0.1,lefttrigger:a3,leftx:a0,lefty:a1,rightshoulder:b7,righttrigger:a4,rightx:a5,righty:a2,start:b9,x:b0,y:b3,platform:Windows,
@@ -450,7 +446,7 @@
 03000000120c0000f60e000000000000,P4 Gamepad,a:b1,b:b2,back:b12,dpdown:h0.4,dpleft:h0.8,dpright:h0.2,dpup:h0.1,guide:b8,leftshoulder:b5,lefttrigger:b7,rightshoulder:b4,righttrigger:b6,start:b9,x:b0,y:b3,platform:Windows,
 03000000790000002201000000000000,PC Controller,a:b2,b:b1,back:b8,dpdown:h0.4,dpleft:h0.8,dpright:h0.2,dpup:h0.1,leftshoulder:b4,leftstick:b10,lefttrigger:b6,leftx:a0,lefty:a1,rightshoulder:b5,rightstick:b11,righttrigger:b7,rightx:a2,righty:a3,start:b9,x:b3,y:b0,platform:Windows,
 030000006f0e00008501000000000000,PDP Fightpad Pro,a:b2,b:b3,back:b8,dpdown:h0.4,dpleft:h0.8,dpright:h0.2,dpup:h0.1,leftshoulder:b4,leftstick:b10,lefttrigger:b6,leftx:a0,lefty:a1,rightshoulder:b5,rightstick:b11,righttrigger:b7,rightx:a2,righty:a3,start:b9,x:b1,y:b0,platform:Windows,
-030000006f0e00000901000000000000,PDP PS3 Versus Fighting,a:b1,b:b2,back:b8,dpdown:h0.4,dpleft:h0.8,dpright:h0.2,dpup:h0.1,guide:b12,leftshoulder:b4,lefttrigger:b6,rightshoulder:b5,righttrigger:b7,start:b9,x:b0,y:b3,platform:Windows,
+030000006f0e00000901000000000000,PDP Versus Fighting,a:b1,b:b2,back:b8,dpdown:h0.4,dpleft:h0.8,dpright:h0.2,dpup:h0.1,guide:b12,leftshoulder:b4,lefttrigger:b6,rightshoulder:b5,righttrigger:b7,start:b9,x:b0,y:b3,platform:Windows,
 030000008f0e00004100000000000000,PlaySega,a:b1,b:b0,dpdown:+a1,dpleft:-a0,dpright:+a0,dpup:-a1,leftshoulder:b6,lefttrigger:b7,rightshoulder:b5,righttrigger:b2,start:b8,x:b4,y:b3,platform:Windows,
 03000000666600006706000000000000,PlayStation Adapter,a:b2,b:b1,back:b8,dpdown:b14,dpleft:b15,dpright:b13,dpup:b12,leftshoulder:b6,leftstick:b9,lefttrigger:b4,leftx:a0,lefty:a1,rightshoulder:b7,rightstick:b10,righttrigger:b5,rightx:a2,righty:a3,start:b11,x:b3,y:b0,platform:Windows,
 03000000e30500009605000000000000,PlayStation Adapter,a:b2,b:b1,back:b9,dpdown:h0.4,dpleft:h0.8,dpright:h0.2,dpup:h0.1,leftshoulder:b6,leftstick:b10,lefttrigger:b4,leftx:a0,lefty:a1,rightshoulder:b7,rightstick:b11,righttrigger:b5,rightx:a2,righty:a3,start:b8,x:b3,y:b0,platform:Windows,
@@ -534,11 +530,9 @@
 030000009b2800002300000000000000,Raphnet 3DO Adapter,a:b0,b:b1,back:b4,dpdown:h0.4,dpleft:h0.8,dpright:h0.2,dpup:h0.1,leftshoulder:b6,lefttrigger:b5,leftx:a0,lefty:a1,rightshoulder:b2,start:b3,platform:Windows,
 030000009b2800006900000000000000,Raphnet 3DO Adapter,a:b0,b:b1,back:b4,dpdown:h0.4,dpleft:h0.8,dpright:h0.2,dpup:h0.1,leftshoulder:b6,lefttrigger:b5,leftx:a0,lefty:a1,rightshoulder:b2,start:b3,platform:Windows,
 030000009b2800000800000000000000,Raphnet Dreamcast Adapter,a:b2,b:b1,dpdown:b5,dpleft:b6,dpright:b7,dpup:b4,lefttrigger:a2,leftx:a0,righttrigger:a3,righty:a1,start:b3,x:b10,y:b9,platform:Windows,
-030000009b2800006200000000000000,Raphnet GameCube Adapter,a:b0,b:b7,dpdown:b11,dpleft:b12,dpright:b13,dpup:b10,lefttrigger:b4,leftx:a0,lefty:a1,rightshoulder:b2,righttrigger:b5,rightx:a3,righty:a4,start:b3,x:b1,y:b8,platform:Windows,
 030000009b2800003200000000000000,Raphnet GC and N64 Adapter,a:b0,b:b7,dpdown:b11,dpleft:b12,dpright:b13,dpup:b10,lefttrigger:+a5,leftx:a0,lefty:a1,rightshoulder:b2,righttrigger:+a2,rightx:a3,righty:a4,start:b3,x:b1,y:b8,platform:Windows,
 030000009b2800006000000000000000,Raphnet GC and N64 Adapter,a:b0,b:b7,dpdown:b11,dpleft:b12,dpright:b13,dpup:b10,lefttrigger:+a5,leftx:a0,lefty:a1,rightshoulder:b2,righttrigger:+a2,rightx:a3,righty:a4,start:b3,x:b1,y:b8,platform:Windows,
 030000009b2800001800000000000000,Raphnet Jaguar Adapter,a:b2,b:b1,back:b4,dpdown:h0.4,dpleft:h0.8,dpright:h0.2,dpup:h0.1,leftshoulder:b13,lefttrigger:b8,leftx:a0,lefty:a1,rightshoulder:b0,righttrigger:b10,start:b3,x:b11,y:b12,platform:Windows,
-030000009b2800006300000000000000,Raphnet N64 Adapter,+rightx:b9,+righty:b7,-rightx:b8,-righty:b6,a:b0,b:b1,dpdown:b11,dpleft:b12,dpright:b13,dpup:b10,leftshoulder:b4,lefttrigger:b2,leftx:a0,lefty:a1,rightshoulder:b5,start:b3,platform:Windows,
 030000009b2800000200000000000000,Raphnet NES Adapter,a:b7,b:b6,back:b5,dpdown:h0.4,dpleft:h0.8,dpright:h0.2,dpup:h0.1,leftx:a0,lefty:a1,start:b4,platform:Windows,
 030000009b2800004400000000000000,Raphnet PS1 and PS2 Adapter,a:b1,b:b2,back:b5,dpdown:b13,dpleft:b14,dpright:b15,dpup:b12,leftshoulder:b6,leftstick:b10,lefttrigger:b8,leftx:a0,lefty:a1,rightshoulder:b7,rightstick:b11,righttrigger:b9,rightx:a3,righty:a4,start:b4,x:b0,y:b3,platform:Windows,
 030000009b2800004300000000000000,Raphnet Saturn,a:b0,b:b1,dpdown:b13,dpleft:b14,dpright:b15,dpup:b12,leftshoulder:b6,lefttrigger:b7,leftx:a0,lefty:a1,rightshoulder:b5,righttrigger:b2,start:b8,x:b3,y:b4,platform:Windows,
@@ -549,9 +543,8 @@
 030000009b2800001e00000000000000,Raphnet Vectrex Adapter,a:b0,b:b1,dpdown:h0.4,dpleft:h0.8,dpright:h0.2,dpup:h0.1,leftx:a1,lefty:a2,x:b2,y:b3,platform:Windows,
 030000009b2800002b00000000000000,Raphnet Wii Classic Adapter,a:b1,b:b4,back:b2,dpdown:b13,dpleft:b14,dpright:b15,dpup:b12,guide:b10,leftshoulder:b6,lefttrigger:b8,leftx:a0,lefty:a1,rightshoulder:b7,righttrigger:b9,rightx:a3,righty:a4,start:b3,x:b0,y:b5,platform:Windows,
 030000009b2800002c00000000000000,Raphnet Wii Classic Adapter,a:b1,b:b4,back:b2,dpdown:b13,dpleft:b14,dpright:b15,dpup:b12,guide:b10,leftshoulder:b6,lefttrigger:b8,leftx:a0,lefty:a1,rightshoulder:b7,righttrigger:b9,rightx:a3,righty:a4,start:b3,x:b0,y:b5,platform:Windows,
-030000009b2800008000000000000000,Raphnet Wii Classic Adapter,a:b1,b:b4,back:b2,dpdown:b13,dpleft:b14,dpright:b15,dpup:b12,guide:b10,leftshoulder:b6,lefttrigger:b8,leftx:a0,lefty:a1,rightshoulder:b7,righttrigger:b9,rightx:a3,righty:a4,start:b3,x:b0,y:b5,platform:Windows,
+030000009b2800008000000000000000,Raphnet Wii Classic Adapter,a:b1,b:b4,x:b0,y:b5,back:b2,guide:b10,start:b3,leftshoulder:b6,rightshoulder:b7,dpup:b12,dpleft:b14,dpdown:b13,dpright:b15,leftx:a0,lefty:a1,rightx:a3,righty:a4,lefttrigger:b8,righttrigger:b9,platform:Windows,
 03000000321500000003000000000000,Razer Hydra,a:b0,b:b1,back:b6,dpdown:h0.4,dpleft:h0.8,dpright:h0.2,dpup:h0.1,leftshoulder:b4,leftstick:b8,leftx:a0,lefty:a1,rightshoulder:b5,rightstick:b9,righttrigger:a2,rightx:a3,righty:a4,start:b7,x:b2,y:b3,platform:Windows,
-03000000f8270000bf0b000000000000,Razer Kishi,a:b6,b:b7,back:b16,dpdown:h0.4,dpleft:h0.8,dpright:h0.2,dpup:h0.1,guide:b18,leftshoulder:b12,leftstick:b19,lefttrigger:b14,leftx:a0,lefty:a1,rightshoulder:b13,rightstick:b20,righttrigger:b15,rightx:a2,righty:a5,start:b17,x:b9,y:b10,platform:Windows,
 03000000321500000204000000000000,Razer Panthera PS3 Controller,a:b1,b:b2,back:b8,dpdown:h0.4,dpleft:h0.8,dpright:h0.2,dpup:h0.1,guide:b12,leftshoulder:b4,leftstick:b10,lefttrigger:b6,leftx:a0,lefty:a1,rightshoulder:b5,rightstick:b11,righttrigger:b7,rightx:a2,righty:a3,start:b9,x:b0,y:b3,platform:Windows,
 03000000321500000104000000000000,Razer Panthera PS4,a:b1,b:b2,back:b8,dpdown:h0.4,dpleft:h0.8,dpright:h0.2,dpup:h0.1,guide:b12,leftshoulder:b4,leftstick:b10,lefttrigger:a3,leftx:a0,lefty:a1,rightshoulder:b5,rightstick:b11,righttrigger:a4,rightx:a2,righty:a5,start:b9,x:b0,y:b3,platform:Windows,
 03000000321500000010000000000000,Razer Raiju,a:b1,b:b2,back:b8,dpdown:h0.4,dpleft:h0.8,dpright:h0.2,dpup:h0.1,leftshoulder:b4,leftstick:b10,lefttrigger:a3,leftx:a0,lefty:a1,rightshoulder:b5,rightstick:b11,righttrigger:a4,rightx:a2,righty:a5,start:b9,x:b0,y:b3,platform:Windows,
@@ -664,8 +657,6 @@
 03000000ba2200000701000000000000,Technology Innovation PS2 Adapter,a:b0,b:b1,back:b8,dpdown:h0.4,dpleft:h0.8,dpright:h0.2,dpup:h0.1,leftshoulder:b4,leftstick:b10,lefttrigger:b6,leftx:a0,lefty:a1,rightshoulder:b5,rightstick:b11,righttrigger:b7,rightx:a3,righty:a2,start:b9,x:b3,y:b2,platform:Windows,
 03000000c61100001000000000000000,Tencent Xianyou Gamepad,a:b0,b:b1,dpdown:h0.4,dpleft:h0.8,dpright:h0.2,dpup:h0.1,leftshoulder:b6,leftstick:b13,lefttrigger:b8,leftx:a0,lefty:a1,rightshoulder:b7,rightstick:b14,righttrigger:b9,rightx:a3,righty:a4,x:b3,y:b4,platform:Windows,
 03000000790000002601000000000000,TGZ,a:b2,b:b1,back:b8,dpdown:h0.4,dpleft:h0.8,dpright:h0.2,dpup:h0.1,leftshoulder:b4,leftstick:b10,lefttrigger:b6,leftx:a0,lefty:a1,rightshoulder:b5,rightstick:b11,righttrigger:b7,rightx:a2,righty:a5,start:b9,x:b3,y:b0,platform:Windows,
-03000000591c00002400000000000000,THEC64 Joystick,a:b0,b:b1,back:b6,leftshoulder:b4,leftx:a0,lefty:a4,rightshoulder:b5,start:b7,x:b2,y:b3,platform:Windows,
-03000000591c00002600000000000000,THEGamepad,a:b2,b:b1,back:b6,leftx:a0,lefty:a1,start:b7,x:b3,y:b0,platform:Windows,
 030000004f04000015b3000000000000,Thrustmaster Dual Analog 4,a:b0,b:b2,back:b8,dpdown:h0.4,dpleft:h0.8,dpright:h0.2,dpup:h0.1,leftshoulder:b4,leftstick:b10,lefttrigger:b5,leftx:a0,lefty:a1,rightshoulder:b6,rightstick:b11,righttrigger:b7,rightx:a2,righty:a3,start:b9,x:b1,y:b3,platform:Windows,
 030000004f04000023b3000000000000,Thrustmaster Dual Trigger PlayStation Controller,a:b1,b:b2,back:b8,dpdown:h0.4,dpleft:h0.8,dpright:h0.2,dpup:h0.1,leftshoulder:b4,leftstick:b10,lefttrigger:b6,leftx:a0,lefty:a1,rightshoulder:b5,rightstick:b11,righttrigger:b7,rightx:a2,righty:a5,start:b9,x:b0,y:b3,platform:Windows,
 030000004f0400000ed0000000000000,ThrustMaster eSwap Pro Controller,a:b1,b:b2,back:b8,dpdown:h0.4,dpleft:h0.8,dpright:h0.2,dpup:h0.1,guide:b12,leftshoulder:b4,leftstick:b10,lefttrigger:a3,leftx:a0,lefty:a1,rightshoulder:b5,rightstick:b11,righttrigger:a4,rightx:a2,righty:a5,start:b9,x:b0,y:b3,platform:Windows,
@@ -821,8 +812,6 @@ xinput,XInput Controller,a:b0,b:b1,back:b6,dpdown:h0.4,dpleft:h0.8,dpright:h0.2,
 03000000050b00000045000031000000,ASUS Gamepad,a:b0,b:b1,back:b10,dpdown:h0.4,dpleft:h0.8,dpright:h0.2,dpup:h0.1,leftshoulder:b4,leftstick:b7,lefttrigger:a5,leftx:a0,lefty:a1,rightshoulder:b5,rightstick:b8,righttrigger:a4,rightx:a2,righty:a3,start:b9,x:b2,y:b3,platform:Mac OS X,
 03000000050b00000579000000010000,ASUS ROG Kunai 3,a:b0,b:b1,back:b12,dpdown:h0.4,dpleft:h0.8,dpright:h0.2,dpup:h0.1,guide:b14,leftshoulder:b6,leftstick:b15,lefttrigger:a5,leftx:a0,lefty:a1,misc1:b42,paddle1:b9,paddle2:b11,rightshoulder:b7,rightstick:b16,righttrigger:a4,rightx:a2,righty:a3,start:b13,x:b3,y:b4,platform:Mac OS X,
 03000000050b00000679000000010000,ASUS ROG Kunai 3,a:b0,b:b1,back:b12,dpdown:h0.4,dpleft:h0.8,dpright:h0.2,dpup:h0.1,guide:b14,leftshoulder:b6,leftstick:b15,lefttrigger:a5,leftx:a0,lefty:a1,misc1:b23,rightshoulder:b7,rightstick:b16,righttrigger:a4,rightx:a2,righty:a3,start:b13,x:b3,y:b4,platform:Mac OS X,
-03000000503200000110000047010000,Atari VCS Classic Controller,a:b0,b:b1,back:b4,dpdown:h0.4,dpleft:h0.8,dpright:h0.2,dpup:h0.1,guide:b3,start:b2,platform:Mac OS X,
-03000000503200000210000047010000,Atari VCS Modern Controller,a:b0,b:b1,back:b10,dpdown:h0.4,dpleft:h0.8,dpright:h0.2,dpup:h0.1,guide:b9,leftshoulder:b4,leftstick:b6,lefttrigger:a5,leftx:a0,lefty:a1,rightshoulder:b5,rightstick:b7,righttrigger:a4,rightx:a2,righty:a3,start:b8,x:b2,y:b3,platform:Mac OS X,
 03000000c62400001a89000000010000,BDA MOGA XP5-X Plus,a:b0,b:b1,back:b12,dpdown:h0.4,dpleft:h0.8,dpright:h0.2,dpup:h0.1,guide:b14,leftshoulder:b6,leftstick:b15,lefttrigger:a5,leftx:a0,lefty:a1,rightshoulder:b7,rightstick:b16,righttrigger:a4,rightx:a2,righty:a3,start:b13,x:b3,y:b4,platform:Mac OS X,
 03000000c62400001b89000000010000,BDA MOGA XP5-X Plus,a:b0,b:b1,back:b10,dpdown:h0.4,dpleft:h0.8,dpright:h0.2,dpup:h0.1,guide:b12,leftshoulder:b6,leftstick:b13,lefttrigger:a5,leftx:a0,lefty:a1,rightshoulder:b7,rightstick:b14,righttrigger:a4,rightx:a2,righty:a3,start:b11,x:b3,y:b4,platform:Mac OS X,
 03000000d62000002a79000000010000,BDA PS4 Fightpad,a:b1,b:b2,back:b8,dpdown:h0.4,dpleft:h0.8,dpright:h0.2,dpup:h0.1,guide:b12,leftshoulder:b4,leftstick:b10,lefttrigger:a3,leftx:a0,lefty:a1,rightshoulder:b5,rightstick:b11,righttrigger:a4,rightx:a2,righty:a5,start:b9,x:b0,y:b3,platform:Mac OS X,
@@ -835,9 +824,8 @@ xinput,XInput Controller,a:b0,b:b1,back:b6,dpdown:h0.4,dpleft:h0.8,dpright:h0.2,
 03000000791d00000103000009010000,Dual Box Wii Classic Adapter,a:b2,b:b1,back:b8,dpdown:b14,dpleft:b15,dpright:b13,dpup:b12,guide:b10,leftshoulder:b6,lefttrigger:b4,leftx:a0,lefty:a1,rightshoulder:b7,righttrigger:b5,rightx:a2,righty:a3,start:b9,x:b3,y:b0,platform:Mac OS X,
 030000006e0500000720000010020000,Elecom JC-W01U,a:b2,b:b3,back:b8,dpdown:h0.4,dpleft:h0.8,dpright:h0.2,dpup:h0.1,leftshoulder:b4,lefttrigger:b6,leftx:a0,lefty:a1,rightshoulder:b5,righttrigger:b7,rightx:a2,righty:a3,start:b9,x:b0,y:b1,platform:Mac OS X,
 030000006f0e00008401000003010000,Faceoff Premiere Wired Pro Controller for Nintendo Switch,a:b1,b:b2,back:b8,dpdown:h0.4,dpleft:h0.8,dpright:h0.2,dpup:h0.1,guide:b12,leftshoulder:b4,leftstick:b10,lefttrigger:b6,leftx:a0,lefty:a1,rightshoulder:b5,rightstick:b13,righttrigger:b7,rightx:a2,righty:a3,start:b9,x:b0,y:b3,platform:Mac OS X,
-03000000151900004000000001000000,Flydigi Vader 2,a:b14,b:b15,back:b10,dpdown:h0.4,dpleft:h0.8,dpright:h0.2,dpup:h0.1,guide:b21,leftshoulder:b6,leftstick:b12,lefttrigger:a5,leftx:a0,lefty:a1,paddle1:b2,paddle2:b5,paddle3:b16,paddle4:b17,rightshoulder:b7,rightstick:b13,righttrigger:a4,rightx:a2,righty:a3,start:b11,x:b0,y:b1,platform:Mac OS X,
-03000000b40400001124000001040000,Flydigi Vader 2,a:b0,b:b1,back:b10,dpdown:h0.4,dpleft:h0.8,dpright:h0.2,dpup:h0.1,leftshoulder:b6,leftstick:b12,lefttrigger:a5,leftx:a0,lefty:a1,misc1:b14,paddle1:b2,paddle2:b5,paddle3:b16,paddle4:b17,rightshoulder:b7,rightstick:b13,righttrigger:a4,rightx:a2,righty:a3,start:b11,x:b3,y:b4,platform:Mac OS X,
-03000000b40400001224000003030000,Flydigi Vader 2,a:b0,b:b1,back:b10,dpdown:h0.4,dpleft:h0.8,dpright:h0.2,dpup:h0.1,leftshoulder:b6,leftstick:b12,lefttrigger:a5,leftx:a0,lefty:a1,misc1:b2,paddle1:b16,paddle2:b17,paddle3:b14,paddle4:b15,rightshoulder:b7,rightstick:b13,righttrigger:a4,rightx:a2,righty:a3,start:b11,x:b3,y:b4,platform:Mac OS X,
+03000000151900004000000001000000,Flydigi Vader 2,a:b0,b:b1,back:b8,dpdown:h0.4,dpleft:h0.8,dpright:h0.2,dpup:h0.1,leftshoulder:b4,leftstick:b10,lefttrigger:a5,leftx:a0,lefty:a1,rightshoulder:b5,rightstick:b11,righttrigger:a4,rightx:a2,righty:a3,start:b9,x:b2,y:b3,platform:Mac OS X,
+03000000b40400001124000000000000,Flydigi Vader 2,a:b0,b:b1,back:b10,dpdown:h0.4,dpleft:h0.8,dpright:h0.2,dpup:h0.1,leftshoulder:b6,leftstick:b12,lefttrigger:b8,leftx:a0,lefty:a1,paddle1:b4,paddle2:b5,paddle3:b17,rightshoulder:b7,rightstick:b13,righttrigger:b9,rightx:a3,righty:a4,start:b11,x:b2,y:b3,platform:Mac OS X,
 03000000790000004618000000010000,GameCube Controller Adapter,a:b4,b:b0,dpdown:b56,dpleft:b60,dpright:b52,dpup:b48,lefttrigger:a12,leftx:a0,lefty:a4,rightshoulder:b28,righttrigger:a16,rightx:a20,righty:a8,start:b36,x:b8,y:b12,platform:Mac OS X,
 03000000ac0500001a06000002020000,GameSir-T3 2.02,a:b0,b:b1,back:b10,dpdown:h0.4,dpleft:h0.8,dpright:h0.2,dpup:h0.1,guide:b15,leftshoulder:b6,leftstick:b13,lefttrigger:a5,leftx:a0,lefty:a1,rightshoulder:b7,rightstick:b14,righttrigger:a4,rightx:a2,righty:a3,start:b11,x:b3,y:b4,platform:Mac OS X,
 03000000ad1b000001f9000000000000,Gamestop BB070 X360 Controller,a:b0,b:b1,back:b9,dpdown:b12,dpleft:b13,dpright:b14,dpup:b11,guide:b10,leftshoulder:b4,leftstick:b6,lefttrigger:a2,leftx:a0,lefty:a1,rightshoulder:b5,rightstick:b7,righttrigger:a5,rightx:a3,righty:a4,start:b8,x:b2,y:b3,platform:Mac OS X,
@@ -862,14 +850,13 @@ xinput,XInput Controller,a:b0,b:b1,back:b6,dpdown:h0.4,dpleft:h0.8,dpright:h0.2,
 030000000d0f00003801000008010000,Hori PC Engine Mini Controller,a:b1,b:b2,back:b8,dpdown:h0.4,dpleft:h0.8,dpright:h0.2,dpup:h0.1,start:b9,platform:Mac OS X,
 030000000d0f00009200000000010000,Hori Pokken Tournament DX Pro,a:b1,b:b2,back:b8,dpdown:h0.4,dpleft:h0.8,dpright:h0.2,dpup:h0.1,leftshoulder:b4,lefttrigger:b6,rightshoulder:b5,righttrigger:b7,start:b9,x:b0,y:b3,platform:Mac OS X,
 030000000d0f0000aa00000072050000,Hori Real Arcade Pro,a:b2,b:b1,back:b8,dpdown:h0.4,dpleft:h0.8,dpright:h0.2,dpup:h0.1,guide:b12,leftshoulder:b4,leftstick:b10,lefttrigger:b6,leftx:a0,lefty:a1,rightshoulder:b5,rightstick:b11,righttrigger:b7,rightx:a2,righty:a3,start:b9,x:b3,y:b0,platform:Mac OS X,
-030000000d0f00000002000015010000,Hori Switch Split Pad Pro,a:b1,b:b2,back:b8,dpdown:h0.4,dpleft:h0.8,dpright:h0.2,dpup:h0.1,guide:b12,leftshoulder:b4,leftstick:b10,lefttrigger:b6,leftx:a0,lefty:a1,misc1:b13,rightshoulder:b5,rightstick:b11,righttrigger:b7,rightx:a2,righty:a3,start:b9,x:b0,y:b3,platform:Mac OS X,
 030000000d0f00006e00000000010000,Horipad 4 PS3,a:b1,b:b2,back:b8,dpdown:h0.4,dpleft:h0.8,dpright:h0.2,dpup:h0.1,guide:b12,leftshoulder:b4,leftstick:b10,lefttrigger:b6,leftx:a0,lefty:a1,rightshoulder:b5,rightstick:b11,righttrigger:b7,rightx:a2,righty:a3,start:b9,x:b0,y:b3,platform:Mac OS X,
 030000000d0f00006600000000010000,Horipad 4 PS4,a:b1,b:b2,back:b8,dpdown:h0.4,dpleft:h0.8,dpright:h0.2,dpup:h0.1,guide:b12,leftshoulder:b4,leftstick:b10,lefttrigger:a3,leftx:a0,lefty:a1,rightshoulder:b5,rightstick:b11,righttrigger:a4,rightx:a2,righty:a5,start:b9,x:b0,y:b3,platform:Mac OS X,
 030000000d0f00006600000000000000,Horipad FPS Plus 4,a:b1,b:b2,back:b8,dpdown:h0.4,dpleft:h0.8,dpright:h0.2,dpup:h0.1,guide:b12,leftshoulder:b4,leftstick:b10,lefttrigger:b6,leftx:a0,lefty:a1,rightshoulder:b5,rightstick:b11,righttrigger:a4,rightx:a2,righty:a5,start:b9,x:b0,y:b3,platform:Mac OS X,
 030000000d0f0000ee00000000010000,Horipad Mini 4,a:b1,b:b2,back:b8,dpdown:h0.4,dpleft:h0.8,dpright:h0.2,dpup:h0.1,guide:b12,leftshoulder:b4,leftstick:b10,lefttrigger:b6,leftx:a0,lefty:a1,rightshoulder:b5,rightstick:b11,righttrigger:b7,rightx:a2,righty:a5,start:b9,x:b0,y:b3,platform:Mac OS X,
 03000000242e0000ff0b000000010000,Hyperkin N64 Adapter,a:b1,b:b2,dpdown:h0.4,dpleft:h0.8,dpright:h0.2,dpup:h0.1,leftshoulder:b4,lefttrigger:b6,leftx:a0,lefty:a1,rightshoulder:b5,rightx:a2,righty:a3,start:b9,platform:Mac OS X,
 03000000790000004e95000000010000,Hyperkin N64 Controller Adapter,a:b1,b:b2,dpdown:b14,dpleft:b15,dpright:b13,dpup:b12,leftshoulder:b7,lefttrigger:a3,leftx:a0,lefty:a1,rightshoulder:b5,rightx:a5,righty:a2,start:b9,platform:Mac OS X,
-03000000830500006020000000000000,iBuffalo Super Famicom Controller,a:b1,b:b0,back:b6,dpdown:+a1,dpleft:-a0,dpright:+a0,dpup:-a1,leftshoulder:b4,rightshoulder:b5,start:b7,x:b3,y:b2,platform:Mac OS X,
+03000000830500006020000000000000,iBuffalo Gamepad,a:b1,b:b0,back:b6,dpdown:+a1,dpleft:-a0,dpright:+a0,dpup:-a1,leftshoulder:b4,rightshoulder:b5,start:b7,x:b3,y:b2,platform:Mac OS X,
 03000000ef0500000300000000020000,InterAct AxisPad,a:b2,b:b3,back:b10,dpdown:h0.4,dpleft:h0.8,dpright:h0.2,dpup:h0.1,leftshoulder:b4,leftstick:b8,lefttrigger:b6,leftx:a0,lefty:a1,rightshoulder:b5,rightstick:b9,righttrigger:b7,rightx:a3,righty:a2,start:b11,x:b0,y:b1,platform:Mac OS X,
 03000000fd0500000030000010010000,Interact GoPad,a:b3,b:b4,leftshoulder:b6,lefttrigger:b7,leftx:a0,lefty:a1,rightshoulder:b2,righttrigger:b5,x:b0,y:b1,platform:Mac OS X,
 030000007e0500000620000001000000,Joy-Con (L),+leftx:h0.2,+lefty:h0.4,-leftx:h0.8,-lefty:h0.1,a:b0,b:b1,back:b13,leftshoulder:b4,leftstick:b10,rightshoulder:b5,start:b8,x:b2,y:b3,platform:Mac OS X,
@@ -901,8 +888,6 @@ xinput,XInput Controller,a:b0,b:b1,back:b6,dpdown:h0.4,dpleft:h0.8,dpright:h0.2,
 03000000790000000018000000000000,Mayflash Wii U Pro Adapter,a:b4,b:b8,back:b32,dpdown:h0.4,dpleft:h0.8,dpright:h0.2,dpup:h0.1,leftshoulder:b16,leftstick:b40,lefttrigger:b24,leftx:a0,lefty:a4,rightshoulder:b20,rightstick:b44,righttrigger:b28,rightx:a8,righty:a12,start:b36,x:b0,y:b12,platform:Mac OS X,
 03000000790000000018000000010000,Mayflash Wii U Pro Adapter,a:b4,b:b8,back:b32,dpdown:h0.4,dpleft:h0.8,dpright:h0.2,dpup:h0.1,leftshoulder:b16,leftstick:b40,lefttrigger:b24,leftx:a0,lefty:a4,rightshoulder:b20,rightstick:b44,righttrigger:b28,rightx:a8,righty:a12,start:b36,x:b0,y:b12,platform:Mac OS X,
 030000005e0400002800000002010000,Microsoft Dual Strike,a:b3,b:b2,back:b4,dpdown:h0.4,dpleft:h0.8,dpright:h0.2,dpup:h0.1,leftshoulder:b6,lefttrigger:b8,rightshoulder:b7,rightx:a0,righty:a1~,start:b5,x:b1,y:b0,platform:Mac OS X,
-030000005e0400000300000006010000,Microsoft SideWinder,a:b0,b:b1,back:b9,leftshoulder:b6,lefttrigger:b7,leftx:a0,lefty:a1,rightshoulder:b5,righttrigger:b2,start:b8,x:b3,y:b4,platform:Mac OS X,
-030000005e0400000700000006010000,Microsoft SideWinder,a:b0,b:b1,back:b8,leftshoulder:b6,lefttrigger:b7,leftx:a0,lefty:a1,rightshoulder:b5,righttrigger:b2,start:b9,x:b3,y:b4,platform:Mac OS X,
 030000005e0400002700000001010000,Microsoft SideWinder Plug and Play,a:b0,b:b1,dpdown:+a1,dpleft:-a0,dpright:+a0,dpup:-a1,lefttrigger:b4,righttrigger:b5,x:b2,y:b3,platform:Mac OS X,
 03000000d62000007162000001000000,Moga Pro 2,a:b0,b:b1,back:b9,dpdown:h0.4,dpleft:h0.8,dpright:h0.2,dpup:h0.1,leftshoulder:b4,leftstick:b7,lefttrigger:a5,leftx:a0,lefty:a1,rightshoulder:b5,rightstick:b8,righttrigger:a4,rightx:a2,righty:a3,start:b6,x:b2,y:b3,platform:Mac OS X,
 03000000c62400002a89000000010000,MOGA XP5A Plus,a:b0,b:b1,back:b10,dpdown:h0.4,dpleft:h0.8,dpright:h0.2,dpup:h0.1,guide:b21,leftshoulder:b6,leftstick:b13,lefttrigger:a5,leftx:a0,lefty:a1,rightshoulder:b7,rightstick:b14,righttrigger:a4,rightx:a2,righty:a3,start:b11,x:b3,y:b4,platform:Mac OS X,
@@ -919,7 +904,7 @@ xinput,XInput Controller,a:b0,b:b1,back:b6,dpdown:h0.4,dpleft:h0.8,dpright:h0.2,
 030000007e0500001720000001000000,NSO SNES Controller,a:b0,b:b1,back:b8,dpdown:h0.4,dpleft:h0.8,dpright:h0.2,dpup:h0.1,leftshoulder:b4,lefttrigger:b6,rightshoulder:b5,righttrigger:b15,start:b9,x:b2,y:b3,platform:Mac OS X,
 03000000550900001472000025050000,NVIDIA Controller,a:b0,b:b1,back:b17,dpdown:h0.4,dpleft:h0.8,dpright:h0.2,dpup:h0.1,guide:b15,leftshoulder:b4,leftstick:b7,lefttrigger:a3,leftx:a0,lefty:a1,rightshoulder:b5,rightstick:b8,righttrigger:a4,rightx:a2,righty:a5,start:b6,x:b2,y:b3,platform:Mac OS X,
 030000004b120000014d000000010000,Nyko Airflo EX,a:b0,b:b1,back:b8,dpdown:h0.4,dpleft:h0.8,dpright:h0.2,dpup:h0.1,guide:b10,leftshoulder:b4,leftstick:b11,lefttrigger:b6,leftx:a0,lefty:a1,rightshoulder:b5,rightstick:b12,righttrigger:b7,rightx:a3,righty:a2,start:b9,x:b2,y:b3,platform:Mac OS X,
-030000006f0e00000901000002010000,PDP PS3 Versus Fighting,a:b1,b:b2,back:b8,dpdown:h0.4,dpleft:h0.8,dpright:h0.2,dpup:h0.1,guide:b12,leftshoulder:b4,lefttrigger:b6,rightshoulder:b5,righttrigger:b7,start:b9,x:b0,y:b3,platform:Mac OS X,
+030000006f0e00000901000002010000,PDP Versus Fighting,a:b1,b:b2,back:b8,dpdown:h0.4,dpleft:h0.8,dpright:h0.2,dpup:h0.1,guide:b12,leftshoulder:b4,lefttrigger:b6,rightshoulder:b5,righttrigger:b7,start:b9,x:b0,y:b3,platform:Mac OS X,
 030000008f0e00000300000000000000,Piranha Xtreme PS3 Controller,a:b2,b:b1,back:b8,dpdown:h0.4,dpleft:h0.8,dpright:h0.2,dpup:h0.1,leftshoulder:b6,leftstick:b10,lefttrigger:b4,leftx:a0,lefty:a1,rightshoulder:b7,rightstick:b11,righttrigger:b5,rightx:a3,righty:a2,start:b9,x:b3,y:b0,platform:Mac OS X,
 03000000666600006706000088020000,PlayStation Adapter,a:b2,b:b1,back:b8,dpdown:b14,dpleft:b15,dpright:b13,dpup:b12,leftshoulder:b6,lefttrigger:b4,leftx:a0,lefty:a1,rightshoulder:b7,righttrigger:b5,rightx:a2,righty:a3,start:b11,x:b3,y:b0,platform:Mac OS X,
 030000004c050000da0c000000010000,PlayStation Classic Controller,a:b2,b:b1,back:b8,dpdown:+a1,dpleft:-a0,dpright:+a0,dpup:-a1,leftshoulder:b6,lefttrigger:b4,rightshoulder:b7,righttrigger:b5,start:b9,x:b3,y:b0,platform:Mac OS X,
@@ -962,7 +947,6 @@ xinput,XInput Controller,a:b0,b:b1,back:b6,dpdown:h0.4,dpleft:h0.8,dpright:h0.2,
 030000004c0500006802000002100000,Rii RK707,a:b14,b:b13,back:b0,dpdown:b6,dpleft:b7,dpright:b5,dpup:b4,guide:b16,leftshoulder:b10,leftstick:b2,lefttrigger:b8,leftx:a0,lefty:a1,rightshoulder:b11,rightstick:b3,righttrigger:b9,rightx:a2,righty:a3,start:b1,x:b15,y:b12,platform:Mac OS X,
 03000000c6240000fefa000000000000,Rock Candy PS3,a:b0,b:b1,back:b9,dpdown:b12,dpleft:b13,dpright:b14,dpup:b11,guide:b10,leftshoulder:b4,leftstick:b6,lefttrigger:a2,leftx:a0,lefty:a1,rightshoulder:b5,rightstick:b7,righttrigger:a5,rightx:a3,righty:a4,start:b8,x:b2,y:b3,platform:Mac OS X,
 030000006f0e00008701000005010000,Rock Candy Switch Controller,a:b1,b:b2,back:b8,dpdown:h0.4,dpleft:h0.8,dpright:h0.2,dpup:h0.1,leftshoulder:b4,leftstick:b10,lefttrigger:b6,leftx:a0,lefty:a1,rightshoulder:b5,rightstick:b11,righttrigger:b7,rightx:a2,righty:a3,start:b9,x:b0,y:b3,platform:Mac OS X,
-03000000e804000000a000001b010000,Samsung EIGP20,a:b1,b:b3,back:b15,dpdown:h0.4,dpleft:h0.8,dpright:h0.2,dpup:h0.1,guide:b20,leftshoulder:b11,leftx:a1,lefty:a3,rightshoulder:b12,rightx:a4,righty:a5,start:b16,x:b7,y:b9,platform:Mac OS X,
 03000000730700000401000000010000,Sanwa PlayOnline Mobile,a:b0,b:b1,back:b2,dpdown:+a1,dpleft:-a0,dpright:+a0,dpup:-a1,start:b3,platform:Mac OS X,
 03000000a30c00002500000006020000,Sega Genesis Mini 3B Controller,a:b2,b:b1,dpdown:+a4,dpleft:-a3,dpright:+a3,dpup:-a4,righttrigger:b5,start:b9,platform:Mac OS X,
 03000000811700007e05000000000000,Sega Saturn,a:b2,b:b4,dpdown:b16,dpleft:b15,dpright:b14,dpup:b17,leftshoulder:b8,lefttrigger:a5,leftx:a0,lefty:a2,rightshoulder:b9,righttrigger:a4,start:b13,x:b0,y:b6,platform:Mac OS X,
@@ -985,8 +969,6 @@ xinput,XInput Controller,a:b0,b:b1,back:b6,dpdown:h0.4,dpleft:h0.8,dpright:h0.2,
 030000000d0f0000f600000000010000,Switch Hori Pad,a:b0,b:b1,back:b8,dpdown:h0.4,dpleft:h0.8,dpright:h0.2,dpup:h0.1,leftshoulder:b4,leftstick:b10,lefttrigger:b6,leftx:a0,lefty:a1,rightshoulder:b5,rightstick:b11,righttrigger:b7,rightx:a2,righty:a3,start:b9,x:b2,y:b3,platform:Mac OS X,
 03000000457500002211000000010000,SZMY Power PC Gamepad,a:b1,b:b2,back:b8,dpdown:h0.4,dpleft:h0.8,dpright:h0.2,dpup:h0.1,guide:b12,leftshoulder:b4,leftstick:b10,lefttrigger:b6,leftx:a0,lefty:a1,rightshoulder:b5,rightstick:b11,righttrigger:b7,rightx:a2,righty:a3,start:b9,x:b0,y:b3,platform:Mac OS X,
 03000000790000001c18000003100000,TGZ Controller,a:b0,b:b1,back:b10,dpdown:h0.4,dpleft:h0.8,dpright:h0.2,dpup:h0.1,leftshoulder:b6,leftstick:b13,lefttrigger:a5,leftx:a0,lefty:a1,rightshoulder:b7,rightstick:b14,righttrigger:a4,rightx:a2,righty:a3,start:b11,x:b3,y:b4,platform:Mac OS X,
-03000000591c00002400000021000000,THEC64 Joystick,a:b0,b:b1,back:b6,leftshoulder:b4,leftx:a0,lefty:a4,rightshoulder:b5,start:b7,x:b2,y:b3,platform:Mac OS X,
-03000000591c00002600000021000000,THEGamepad,a:b2,b:b1,back:b6,dpdown:+a4,dpleft:-a0,dpright:+a0,dpup:-a4,leftshoulder:b4,rightshoulder:b5,start:b7,x:b3,y:b0,platform:Mac OS X,
 030000004f04000015b3000000000000,Thrustmaster Dual Analog 3.2,a:b0,b:b2,back:b8,dpdown:h0.4,dpleft:h0.8,dpright:h0.2,dpup:h0.1,leftshoulder:b4,leftstick:b10,lefttrigger:b5,leftx:a0,lefty:a1,rightshoulder:b6,rightstick:b11,righttrigger:b7,rightx:a2,righty:a3,start:b9,x:b1,y:b3,platform:Mac OS X,
 030000004f0400000ed0000000020000,ThrustMaster eSwap Pro Controller,a:b1,b:b2,back:b8,dpdown:h0.4,dpleft:h0.8,dpright:h0.2,dpup:h0.1,guide:b12,leftshoulder:b4,leftstick:b10,lefttrigger:a3,leftx:a0,lefty:a1,rightshoulder:b5,rightstick:b11,righttrigger:a4,rightx:a2,righty:a5,start:b9,x:b0,y:b3,platform:Mac OS X,
 030000004f04000000b3000000000000,Thrustmaster Firestorm Dual Power,a:b0,b:b2,back:b9,dpdown:h0.4,dpleft:h0.8,dpright:h0.2,dpup:h0.1,guide:b8,leftshoulder:b4,leftstick:b11,lefttrigger:b5,leftx:a0,lefty:a1,rightshoulder:b6,righttrigger:b7,rightx:a2,righty:a3,start:b10,x:b1,y:b3,platform:Mac OS X,
@@ -1010,7 +992,6 @@ xinput,XInput Controller,a:b0,b:b1,back:b6,dpdown:h0.4,dpleft:h0.8,dpright:h0.2,
 030000005e040000130b000011050000,Xbox One Controller,a:b0,b:b1,back:b10,dpdown:h0.4,dpleft:h0.8,dpright:h0.2,dpup:h0.1,guide:b12,leftshoulder:b6,leftstick:b13,lefttrigger:a5,leftx:a0,lefty:a1,rightshoulder:b7,rightstick:b14,righttrigger:a4,rightx:a2,righty:a3,start:b11,x:b3,y:b4,platform:Mac OS X,
 030000005e040000200b000011050000,Xbox One Controller,a:b0,b:b1,back:b10,dpdown:h0.4,dpleft:h0.8,dpright:h0.2,dpup:h0.1,guide:b12,leftshoulder:b6,leftstick:b13,lefttrigger:a5,leftx:a0,lefty:a1,rightshoulder:b7,rightstick:b14,righttrigger:a4,rightx:a2,righty:a3,start:b11,x:b3,y:b4,platform:Mac OS X,
 030000005e040000200b000013050000,Xbox One Controller,a:b0,b:b1,back:b10,dpdown:h0.4,dpleft:h0.8,dpright:h0.2,dpup:h0.1,guide:b12,leftshoulder:b6,leftstick:b13,lefttrigger:a5,leftx:a0,lefty:a1,rightshoulder:b7,rightstick:b14,righttrigger:a4,rightx:a2,righty:a3,start:b11,x:b3,y:b4,platform:Mac OS X,
-030000005e040000200b000015050000,Xbox One Controller,a:b0,b:b1,back:b10,dpdown:h0.4,dpleft:h0.8,dpright:h0.2,dpup:h0.1,guide:b12,leftshoulder:b6,leftstick:b13,lefttrigger:a5,leftx:a0,lefty:a1,rightshoulder:b7,rightstick:b14,righttrigger:a4,rightx:a2,righty:a3,start:b11,x:b3,y:b4,platform:Mac OS X,
 030000005e040000d102000000000000,Xbox One Controller,a:b0,b:b1,back:b9,dpdown:b12,dpleft:b13,dpright:b14,dpup:b11,guide:b10,leftshoulder:b4,leftstick:b6,lefttrigger:a2,leftx:a0,lefty:a1,rightshoulder:b5,rightstick:b7,righttrigger:a5,rightx:a3,righty:a4,start:b8,x:b2,y:b3,platform:Mac OS X,
 030000005e040000dd02000000000000,Xbox One Controller,a:b0,b:b1,back:b9,dpdown:b12,dpleft:b13,dpright:b14,dpup:b11,guide:b10,leftshoulder:b4,leftstick:b6,lefttrigger:a2,leftx:a0,lefty:a1,rightshoulder:b5,rightstick:b7,righttrigger:a5,rightx:a3,righty:a4,start:b8,x:b2,y:b3,platform:Mac OS X,
 030000005e040000e002000000000000,Xbox One Controller,a:b0,b:b1,back:b6,dpdown:h0.4,dpleft:h0.8,dpright:h0.2,dpup:h0.1,guide:b10,leftshoulder:b4,leftstick:b8,lefttrigger:a2,leftx:a0,lefty:a1,rightshoulder:b5,rightstick:b9,righttrigger:a5,rightx:a3,righty:a4,start:b7,x:b2,y:b3,platform:Mac OS X,
@@ -1086,8 +1067,6 @@ xinput,XInput Controller,a:b0,b:b1,back:b6,dpdown:h0.4,dpleft:h0.8,dpright:h0.2,
 03000000c82d00000760000011010000,8BitDo Ultimate Wireless,a:b1,b:b0,back:b10,dpdown:h0.4,dpleft:h0.8,dpright:h0.2,dpup:h0.1,leftshoulder:b6,leftstick:b13,lefttrigger:a5,leftx:a0,lefty:a1,rightshoulder:b7,rightstick:b14,righttrigger:a4,rightx:a2,righty:a3,start:b11,x:b4,y:b3,platform:Linux,
 03000000c82d00001230000011010000,8BitDo Ultimate Wireless,a:b0,b:b1,back:b10,dpdown:h0.4,dpleft:h0.8,dpright:h0.2,dpup:h0.1,guide:b12,leftshoulder:b6,leftstick:b13,lefttrigger:a5,leftx:a0,lefty:a1,rightshoulder:b7,rightstick:b14,righttrigger:a4,rightx:a2,righty:a3,start:b11,x:b3,y:b4,platform:Linux,
 03000000c82d00001330000011010000,8BitDo Ultimate Wireless,a:b0,b:b1,back:b10,dpdown:h0.4,dpleft:h0.8,dpright:h0.2,dpup:h0.1,guide:b12,leftshoulder:b6,leftstick:b13,lefttrigger:a5,leftx:a0,lefty:a1,misc1:b26,paddle1:b23,paddle2:b19,rightshoulder:b7,rightstick:b14,righttrigger:a4,rightx:a2,righty:a3,start:b11,x:b3,y:b4,platform:Linux,
-03000000c82d00000121000011010000,8BitDo Xbox One SN30 Pro,a:b0,b:b1,back:b10,dpdown:h0.4,dpleft:h0.8,dpright:h0.2,dpup:h0.1,guide:b12,leftshoulder:b6,leftstick:b13,lefttrigger:a5,leftx:a0,lefty:a1,rightshoulder:b7,rightstick:b14,righttrigger:a4,rightx:a2,righty:a3,start:b11,x:b3,y:b4,platform:Linux,
-05000000c82d00000121000000010000,8BitDo Xbox One SN30 Pro,a:b0,b:b1,back:b10,dpdown:h0.4,dpleft:h0.8,dpright:h0.2,dpup:h0.1,guide:b12,leftshoulder:b6,leftstick:b13,lefttrigger:a5,leftx:a0,lefty:a1,rightshoulder:b7,rightstick:b14,righttrigger:a4,rightx:a2,righty:a3,start:b11,x:b3,y:b4,platform:Linux,
 05000000a00500003232000001000000,8BitDo Zero,a:b0,b:b1,back:b10,dpdown:+a1,dpleft:-a0,dpright:+a0,dpup:-a1,leftshoulder:b6,rightshoulder:b7,start:b11,x:b3,y:b4,platform:Linux,
 05000000a00500003232000008010000,8BitDo Zero,a:b0,b:b1,back:b10,dpdown:+a1,dpleft:-a0,dpright:+a0,dpup:-a1,leftshoulder:b6,rightshoulder:b7,start:b11,x:b3,y:b4,platform:Linux,
 03000000c82d00001890000011010000,8BitDo Zero 2,a:b1,b:b0,back:b10,dpdown:+a1,dpleft:-a0,dpright:+a0,dpup:-a1,leftshoulder:b6,rightshoulder:b7,start:b11,x:b4,y:b3,platform:Linux,
@@ -1145,17 +1124,14 @@ xinput,XInput Controller,a:b0,b:b1,back:b6,dpdown:h0.4,dpleft:h0.8,dpright:h0.2,
 030000006e0500000720000010010000,Elecom W01U,a:b2,b:b3,back:b8,dpdown:h0.4,dpleft:h0.8,dpright:h0.2,dpup:h0.1,leftshoulder:b4,lefttrigger:b6,leftx:a0,lefty:a1,rightshoulder:b5,righttrigger:b7,rightx:a2,righty:a3,start:b9,x:b0,y:b1,platform:Linux,
 030000007d0400000640000010010000,Eliminator AfterShock,a:b1,b:b2,back:b9,dpdown:+a3,dpleft:-a5,dpright:+a5,dpup:-a3,leftshoulder:b4,lefttrigger:b6,leftx:a0,lefty:a1,rightshoulder:b5,righttrigger:b7,rightx:a4,righty:a2,start:b8,x:b0,y:b3,platform:Linux,
 03000000430b00000300000000010000,EMS Production PS2 Adapter,a:b2,b:b1,back:b8,dpdown:b14,dpleft:b15,dpright:b13,dpup:b12,leftshoulder:b6,leftstick:b10,lefttrigger:b4,leftx:a0,lefty:a1,rightshoulder:b7,rightstick:b11,righttrigger:b5,rightx:a5,righty:a2,start:b9,x:b3,y:b0,platform:Linux,
-03005036852100000201000010010000,Final Fantasy XIV Online Controller,a:b1,b:b2,back:b8,dpdown:h0.4,dpleft:h0.8,dpright:h0.2,dpup:h0.1,leftshoulder:b4,leftstick:b10,lefttrigger:b6,leftx:a0,lefty:a1,rightshoulder:b5,rightstick:b11,righttrigger:b7,rightx:a2,righty:a3,start:b9,x:b0,y:b3,platform:Linux,
-03000000b40400001124000011010000,Flydigi Vader 2,a:b0,b:b1,back:b10,dpdown:h0.4,dpleft:h0.8,dpright:h0.2,dpup:h0.1,leftshoulder:b6,leftstick:b12,lefttrigger:a5,leftx:a0,lefty:a1,misc1:b14,paddle1:b2,paddle2:b5,paddle3:b16,paddle4:b17,rightshoulder:b7,rightstick:b13,righttrigger:a4,rightx:a2,righty:a3,start:b11,x:b3,y:b4,platform:Linux,
-03000000b40400001224000011010000,Flydigi Vader 2,a:b0,b:b1,back:b10,dpdown:h0.4,dpleft:h0.8,dpright:h0.2,dpup:h0.1,leftshoulder:b6,leftstick:b12,lefttrigger:a5,leftx:a0,lefty:a1,misc1:b2,paddle1:b16,paddle2:b17,paddle3:b14,paddle4:b15,rightshoulder:b7,rightstick:b13,righttrigger:a4,rightx:a2,righty:a3,start:b11,x:b3,y:b4,platform:Linux,
-05000000151900004000000001000000,Flydigi Vader 2,a:b0,b:b1,back:b10,dpdown:h0.4,dpleft:h0.8,dpright:h0.2,dpup:h0.1,guide:b21,leftshoulder:b6,leftstick:b12,lefttrigger:a5,leftx:a0,lefty:a1,misc1:b14,paddle1:b2,paddle2:b5,paddle3:b16,paddle4:b17,rightshoulder:b7,rightstick:b13,righttrigger:a4,rightx:a2,righty:a3,start:b11,x:b3,y:b4,platform:Linux,
+03000000b40400001124000011010000,Flydigi Vader 2,a:b0,b:b1,back:b10,dpdown:h0.4,dpleft:h0.8,dpright:h0.2,dpup:h0.1,leftshoulder:b6,leftstick:b12,lefttrigger:a5,leftx:a0,lefty:a1,paddle1:b2,paddle2:b5,paddle4:b17,rightshoulder:b7,rightstick:b13,righttrigger:a4,rightx:a2,righty:a3,start:b11,x:b3,y:b4,platform:Linux,
+05000000151900004000000001000000,Flydigi Vader 2,a:b0,b:b1,back:b8,dpdown:h0.4,dpleft:h0.8,dpright:h0.2,dpup:h0.1,leftshoulder:b4,leftstick:b10,lefttrigger:a5,leftx:a0,lefty:a1,rightshoulder:b5,rightstick:b11,righttrigger:a4,rightx:a2,righty:a3,start:b9,x:b2,y:b3,platform:Linux,
 030000007e0500003703000000000000,GameCube Adapter,a:b0,b:b1,dpdown:b9,dpleft:b10,dpright:b11,dpup:b8,lefttrigger:a2,leftx:a0,lefty:a1,rightshoulder:b6,righttrigger:a5,rightx:a3,righty:a4,start:b7,x:b3,y:b2,platform:Linux,
 19000000030000000300000002030000,GameForce Controller,a:b1,b:b0,back:b8,dpdown:b11,dpleft:b12,dpright:b13,dpup:b10,guide:b16,leftshoulder:b4,leftstick:b14,lefttrigger:b6,leftx:a1,lefty:a0,rightshoulder:b5,rightstick:b15,righttrigger:b7,rightx:a3,righty:a2,start:b9,x:b2,y:b3,platform:Linux,
 03000000ac0500005b05000010010000,GameSir G3w,a:b2,b:b1,back:b8,dpdown:h0.4,dpleft:h0.8,dpright:h0.2,dpup:h0.1,guide:b12,leftshoulder:b4,leftstick:b10,lefttrigger:b6,leftx:a0,lefty:a1,rightshoulder:b5,rightstick:b11,righttrigger:b7,rightx:a2,righty:a3,start:b9,x:b3,y:b0,platform:Linux,
 03000000bc2000000055000011010000,GameSir G3w,a:b0,b:b1,back:b10,dpdown:h0.4,dpleft:h0.8,dpright:h0.2,dpup:h0.1,leftshoulder:b6,leftstick:b13,lefttrigger:a5,leftx:a0,lefty:a1,rightshoulder:b7,rightstick:b14,righttrigger:a4,rightx:a2,righty:a3,start:b11,x:b3,y:b4,platform:Linux,
 03000000558500001b06000010010000,GameSir G4 Pro,a:b0,b:b1,back:b10,dpdown:h0.4,dpleft:h0.8,dpright:h0.2,dpup:h0.1,leftshoulder:b6,leftstick:b13,lefttrigger:b8,leftx:a0,lefty:a1,rightshoulder:b7,rightstick:b14,righttrigger:b9,rightx:a2,righty:a3,start:b11,x:b3,y:b4,platform:Linux,
 05000000ac0500002d0200001b010000,GameSir G4s,a:b0,b:b1,back:b10,dpdown:h0.4,dpleft:h0.8,dpright:h0.2,dpup:h0.1,guide:b33,leftshoulder:b6,leftstick:b13,lefttrigger:a5,leftx:a0,lefty:a1,rightshoulder:b7,rightstick:b14,righttrigger:a4,rightx:a2,righty:a3,start:b11,x:b3,y:b4,platform:Linux,
-03000000ac0500007a05000011010000,GameSir G5,a:b0,b:b1,back:b10,dpdown:h0.4,dpleft:h0.8,dpright:h0.2,dpup:h0.1,guide:b12,leftshoulder:b6,leftstick:b13,lefttrigger:b8,leftx:a0,lefty:a1,rightshoulder:b7,rightstick:b16,righttrigger:b9,rightx:a2,righty:a3,start:b11,x:b3,y:b4,platform:Linux,
 03000000bc2000005656000011010000,GameSir T4w,a:b1,b:b2,back:b8,dpdown:h0.4,dpleft:h0.8,dpright:h0.2,dpup:h0.1,guide:b12,leftshoulder:b4,leftstick:b10,lefttrigger:b6,leftx:a0,lefty:a1,rightshoulder:b5,rightstick:b11,righttrigger:b7,rightx:a2,righty:a3,start:b9,x:b0,y:b3,platform:Linux,
 03000000ac0500001a06000011010000,GameSir-T3 2.02,a:b0,b:b1,back:b10,dpdown:h0.4,dpleft:h0.8,dpright:h0.2,dpup:h0.1,guide:b15,leftshoulder:b6,leftstick:b13,lefttrigger:a5,leftx:a0,lefty:a1,rightshoulder:b7,rightstick:b14,righttrigger:a4,rightx:a2,righty:a3,start:b11,x:b3,y:b4,platform:Linux,
 0500000047532047616d657061640000,GameStop Gamepad,a:b0,b:b1,back:b8,dpdown:h0.4,dpleft:h0.8,dpright:h0.2,dpup:h0.1,leftshoulder:b4,leftstick:b10,lefttrigger:b6,leftx:a0,lefty:a1,rightshoulder:b5,rightstick:b11,righttrigger:b7,rightx:a2,righty:a3,start:b9,x:b2,y:b3,platform:Linux,
@@ -1200,7 +1176,6 @@ xinput,XInput Controller,a:b0,b:b1,back:b6,dpdown:h0.4,dpleft:h0.8,dpright:h0.2,
 030000000d0f00006a00000011010000,Hori Real Arcade Pro 4,a:b1,b:b2,back:b8,dpdown:h0.4,dpleft:h0.8,dpright:h0.2,dpup:h0.1,guide:b12,leftshoulder:b4,leftstick:b10,lefttrigger:a3,leftx:a0,lefty:a1,rightshoulder:b5,rightstick:b11,righttrigger:a4,rightx:a2,righty:a5,start:b9,x:b0,y:b3,platform:Linux,
 030000000d0f00006b00000011010000,Hori Real Arcade Pro 4,a:b1,b:b2,back:b8,dpdown:h0.4,dpleft:h0.8,dpright:h0.2,dpup:h0.1,guide:b12,leftshoulder:b4,leftstick:b10,lefttrigger:b6,leftx:a0,lefty:a1,rightshoulder:b5,rightstick:b11,righttrigger:b7,rightx:a2,righty:a3,start:b9,x:b0,y:b3,platform:Linux,
 030000000d0f00001600000000010000,Hori Real Arcade Pro EXSE,a:b0,b:b1,back:b8,dpdown:h0.4,dpleft:h0.8,dpright:h0.2,dpup:h0.1,guide:b10,leftshoulder:b4,lefttrigger:b6,rightshoulder:b5,righttrigger:b7,start:b9,x:b2,y:b3,platform:Linux,
-030000000d0f00008501000015010000,Hori Switch Split Pad Pro,a:b0,b:b1,back:b6,dpdown:h0.4,dpleft:h0.8,dpright:h0.2,dpup:h0.1,guide:b8,leftshoulder:b4,leftstick:b9,lefttrigger:a2,leftx:a0,lefty:a1,rightshoulder:b5,rightstick:b10,righttrigger:a5,rightx:a3,righty:a4,start:b7,x:b2,y:b3,platform:Linux,
 030000000d0f00006e00000011010000,Horipad 4 PS3,a:b1,b:b2,back:b8,dpdown:h0.4,dpleft:h0.8,dpright:h0.2,dpup:h0.1,guide:b12,leftshoulder:b4,leftstick:b10,lefttrigger:b6,leftx:a0,lefty:a1,rightshoulder:b5,rightstick:b11,righttrigger:b7,rightx:a2,righty:a3,start:b9,x:b0,y:b3,platform:Linux,
 030000000d0f00006600000011010000,Horipad 4 PS4,a:b1,b:b2,back:b8,dpdown:h0.4,dpleft:h0.8,dpright:h0.2,dpup:h0.1,guide:b12,leftshoulder:b4,leftstick:b10,lefttrigger:a3,leftx:a0,lefty:a1,rightshoulder:b5,rightstick:b11,righttrigger:a4,rightx:a2,righty:a5,start:b9,x:b0,y:b3,platform:Linux,
 030000000d0f0000ee00000011010000,Horipad Mini 4,a:b1,b:b2,back:b8,dpdown:h0.4,dpleft:h0.8,dpright:h0.2,dpup:h0.1,guide:b12,leftshoulder:b4,leftstick:b10,lefttrigger:b6,leftx:a0,lefty:a1,rightshoulder:b5,rightstick:b11,righttrigger:b7,rightx:a2,righty:a5,start:b9,x:b0,y:b3,platform:Linux,
@@ -1210,10 +1185,9 @@ xinput,XInput Controller,a:b0,b:b1,back:b6,dpdown:h0.4,dpleft:h0.8,dpright:h0.2,
 03000000341a000005f7000010010000,HuiJia GameCube Controller Adapter,a:b1,b:b2,dpdown:b14,dpleft:b15,dpright:b13,dpup:b12,lefttrigger:a3,leftx:a0,lefty:a1,rightshoulder:b7,righttrigger:a4,rightx:a5,righty:a2,start:b9,x:b0,y:b3,platform:Linux,
 05000000242e00000b20000001000000,Hyperkin Admiral N64 Controller,+rightx:b11,+righty:b13,-rightx:b8,-righty:b12,a:b1,b:b0,dpdown:h0.4,dpleft:h0.8,dpright:h0.2,dpup:h0.1,leftshoulder:b4,lefttrigger:b14,leftx:a0,lefty:a1,rightshoulder:b5,start:b9,platform:Linux,
 03000000242e0000ff0b000011010000,Hyperkin N64 Adapter,a:b1,b:b2,dpdown:h0.4,dpleft:h0.8,dpright:h0.2,dpup:h0.1,leftshoulder:b4,lefttrigger:b6,leftx:a0,lefty:a1,rightshoulder:b5,rightx:a2,righty:a3,start:b9,platform:Linux,
-03000000242e00006a38000010010000,Hyperkin Trooper 2,a:b0,b:b1,back:b4,leftshoulder:b2,leftx:a0,lefty:a1,rightshoulder:b3,start:b5,platform:Linux,
 03000000242e00008816000001010000,Hyperkin X91,a:b0,b:b1,back:b6,dpdown:h0.4,dpleft:h0.8,dpright:h0.2,dpup:h0.1,guide:b8,leftshoulder:b4,leftstick:b9,lefttrigger:a2,leftx:a0,lefty:a1,rightshoulder:b5,rightstick:b10,righttrigger:a5,rightx:a3,righty:a4,start:b7,x:b2,y:b3,platform:Linux,
 03000000f00300008d03000011010000,HyperX Clutch,a:b0,b:b1,back:b10,dpdown:h0.4,dpleft:h0.8,dpright:h0.2,dpup:h0.1,guide:b12,leftshoulder:b6,leftstick:b13,lefttrigger:a5,leftx:a0,lefty:a1,rightshoulder:b7,rightstick:b14,righttrigger:a4,rightx:a2,righty:a3,start:b11,x:b3,y:b4,platform:Linux,
-03000000830500006020000010010000,iBuffalo Super Famicom Controller,a:b1,b:b0,back:b6,dpdown:+a1,dpleft:-a0,dpright:+a0,dpup:-a1,leftshoulder:b4,rightshoulder:b5,start:b7,x:b3,y:b2,platform:Linux,
+03000000830500006020000010010000,iBuffalo SNES Controller,a:b1,b:b0,back:b6,dpdown:+a1,dpleft:-a0,dpright:+a0,dpup:-a1,leftshoulder:b4,rightshoulder:b5,start:b7,x:b3,y:b2,platform:Linux,
 050000006964726f69643a636f6e0000,idroidcon Controller,a:b1,b:b2,back:b8,dpdown:h0.4,dpleft:h0.8,dpright:h0.2,dpup:h0.1,leftshoulder:b4,leftstick:b10,lefttrigger:b6,leftx:a0,lefty:a1,rightshoulder:b5,rightstick:b11,righttrigger:b7,rightx:a2,righty:a3,start:b9,x:b0,y:b3,platform:Linux,
 03000000b50700001503000010010000,Impact,a:b2,b:b3,back:b8,dpdown:h0.4,dpleft:h0.8,dpright:h0.2,dpup:h0.1,leftshoulder:b4,leftstick:b10,lefttrigger:b5,leftx:a0,lefty:a1,rightshoulder:b6,rightstick:b11,righttrigger:b7,rightx:a3,righty:a2,start:b9,x:b0,y:b1,platform:Linux,
 03000000d80400008200000003000000,IMS PCU0,a:b1,b:b0,back:b4,dpdown:+a1,dpleft:-a0,dpright:+a0,dpup:-a1,start:b5,x:b3,y:b2,platform:Linux,
@@ -1275,31 +1249,28 @@ xinput,XInput Controller,a:b0,b:b1,back:b6,dpdown:h0.4,dpleft:h0.8,dpright:h0.2,
 03000000790000000318000011010000,Mayflash Wii DolphinBar,a:b2,b:b3,back:b8,dpdown:h0.4,dpleft:h0.8,dpright:h0.2,dpup:h0.1,guide:b11,leftshoulder:b4,lefttrigger:b6,leftx:a0,lefty:a1,rightshoulder:b5,righttrigger:b7,rightx:a2,righty:a3,start:b9,x:b0,y:b1,platform:Linux,
 03000000790000000018000011010000,Mayflash Wii U Pro Adapter,a:b1,b:b2,back:b8,dpdown:h0.4,dpleft:h0.8,dpright:h0.2,dpup:h0.1,leftshoulder:b4,leftstick:b10,lefttrigger:b6,leftx:a0,lefty:a1,rightshoulder:b5,rightstick:b11,righttrigger:b7,rightx:a2,righty:a3,start:b9,x:b0,y:b3,platform:Linux,
 03000000b50700001203000010010000,Mega World Logic 3 Controller,a:b2,b:b3,back:b8,dpdown:h0.4,dpleft:h0.8,dpright:h0.2,dpup:h0.1,leftshoulder:b4,leftstick:b10,lefttrigger:b5,leftx:a0,lefty:a1,rightshoulder:b6,rightstick:b11,righttrigger:b7,rightx:a3,righty:a2,start:b9,x:b0,y:b1,platform:Linux,
-03000000b50700004f00000000010000,Mega World Logic 3 Controller,a:b2,b:b3,back:b8,dpdown:h0.4,dpleft:h0.8,dpright:h0.2,dpup:h0.1,leftshoulder:b4,leftstick:b10,lefttrigger:b5,leftx:a0,lefty:a1,rightshoulder:b6,rightstick:b11,righttrigger:b7,rightx:a2,righty:a3,start:b9,x:b0,y:b1,platform:Linux,
 03000000780000000600000010010000,Microntek Joystick,a:b2,b:b1,back:b8,leftshoulder:b6,lefttrigger:b4,leftx:a0,lefty:a1,rightshoulder:b7,righttrigger:b5,start:b9,x:b3,y:b0,platform:Linux,
 030000005e0400002800000000010000,Microsoft Dual Strike,a:b3,b:b2,back:b4,dpdown:h0.4,dpleft:h0.8,dpright:h0.2,dpup:h0.1,leftshoulder:b6,lefttrigger:b8,rightshoulder:b7,rightx:a0,righty:a1~,start:b5,x:b1,y:b0,platform:Linux,
-030000005e0400000300000000010000,Microsoft SideWinder,a:b0,b:b1,back:b9,leftshoulder:b6,lefttrigger:b7,leftx:a0,lefty:a1,rightshoulder:b5,righttrigger:b2,start:b8,x:b3,y:b4,platform:Linux,
-030000005e0400000700000000010000,Microsoft SideWinder,a:b0,b:b1,back:b8,leftshoulder:b6,lefttrigger:b7,leftx:a0,lefty:a1,rightshoulder:b5,righttrigger:b2,start:b9,x:b3,y:b4,platform:Linux,
-030000005e0400000e00000000010000,Microsoft SideWinder Freestyle Pro,a:b0,b:b1,back:b9,dpdown:h0.4,dpleft:h0.8,dpright:h0.2,dpup:h0.1,leftshoulder:b6,rightshoulder:b7,start:b8,x:b3,y:b4,platform:Linux,
+030000005e0400000e00000000010000,Microsoft SideWinder,a:b0,b:b1,back:b9,dpdown:h0.4,dpleft:h0.8,dpright:h0.2,dpup:h0.1,leftshoulder:b6,rightshoulder:b7,start:b8,x:b3,y:b4,platform:Linux,
+030000005e0400000700000000010000,Microsoft SideWinder Gamepad,a:b0,b:b1,back:b8,dpdown:+a1,dpleft:-a0,dpright:+a0,dpup:-a1,leftshoulder:b6,lefttrigger:b7,rightshoulder:b5,righttrigger:b2,start:b9,x:b3,y:b4,platform:Linux,
 030000005e0400002700000000010000,Microsoft SideWinder Plug and Play,a:b0,b:b1,dpdown:+a1,dpleft:-a0,dpright:+a0,dpup:-a1,lefttrigger:b4,righttrigger:b5,x:b2,y:b3,platform:Linux,
 030000005e0400008502000000010000,Microsoft Xbox,a:b0,b:b1,back:b6,dpdown:h0.4,dpleft:h0.8,dpright:h0.2,dpup:h0.1,leftshoulder:b5,leftstick:b8,lefttrigger:a2,leftx:a0,lefty:a1,rightshoulder:b2,rightstick:b9,righttrigger:a5,rightx:a3,righty:a4,start:b7,x:b3,y:b4,platform:Linux,
-030000005e0400008902000021010000,Microsoft Xbox,a:b0,b:b1,back:b6,dpdown:h0.4,dpleft:h0.8,dpright:h0.2,dpup:h0.1,leftshoulder:b5,leftstick:b8,lefttrigger:a2,leftx:a0,lefty:a1,rightshoulder:b2,rightstick:b9,righttrigger:a5,rightx:a3,righty:a4,start:b7,x:b3,y:b4,platform:Linux,
 030000005e0400008e02000001000000,Microsoft Xbox 360,a:b0,b:b1,back:b6,dpdown:h0.1,dpleft:h0.2,dpright:h0.8,dpup:h0.4,leftshoulder:b4,leftstick:b9,lefttrigger:a2,leftx:a0,lefty:a1,rightshoulder:b5,rightstick:b10,righttrigger:a5,rightx:a3,righty:a4,start:b7,x:b2,y:b3,platform:Linux,
 030000005e0400008e02000004010000,Microsoft Xbox 360,a:b0,b:b1,back:b6,dpdown:h0.4,dpleft:h0.8,dpright:h0.2,dpup:h0.1,guide:b8,leftshoulder:b4,leftstick:b9,lefttrigger:a2,leftx:a0,lefty:a1,rightshoulder:b5,rightstick:b10,righttrigger:a5,rightx:a3,righty:a4,start:b7,x:b2,y:b3,platform:Linux,
 030000005e0400008e02000056210000,Microsoft Xbox 360,a:b0,b:b1,back:b6,dpdown:h0.4,dpleft:h0.8,dpright:h0.2,dpup:h0.1,guide:b8,leftshoulder:b4,leftstick:b9,lefttrigger:a2,leftx:a0,lefty:a1,rightshoulder:b5,rightstick:b10,righttrigger:a5,rightx:a3,righty:a4,start:b7,x:b2,y:b3,platform:Linux,
 030000005e0400008e02000062230000,Microsoft Xbox 360,a:b0,b:b1,back:b6,dpdown:h0.4,dpleft:h0.8,dpright:h0.2,dpup:h0.1,guide:b8,leftshoulder:b4,leftstick:b9,lefttrigger:a2,leftx:a0,lefty:a1,rightshoulder:b5,rightstick:b10,righttrigger:a5,rightx:a3,righty:a4,start:b7,x:b2,y:b3,platform:Linux,
+030000005e040000120b00000b050000,Microsoft Xbox One,a:b0,b:b1,back:b6,dpdown:h0.4,dpleft:h0.8,dpright:h0.2,dpup:h0.1,guide:b8,leftshoulder:b4,leftstick:b9,lefttrigger:a2,leftx:a0,lefty:a1,rightshoulder:b5,rightstick:b10,righttrigger:a5,rightx:a3,righty:a4,start:b7,x:b2,y:b3,platform:Linux,
 030000005e040000d102000001010000,Microsoft Xbox One,a:b0,b:b1,back:b6,dpdown:h0.4,dpleft:h0.8,dpright:h0.2,dpup:h0.1,guide:b8,leftshoulder:b4,leftstick:b9,lefttrigger:a2,leftx:a0,lefty:a1,rightshoulder:b5,rightstick:b10,righttrigger:a5,rightx:a3,righty:a4,start:b7,x:b2,y:b3,platform:Linux,
 030000005e040000d102000003020000,Microsoft Xbox One,a:b0,b:b1,back:b6,dpdown:h0.4,dpleft:h0.8,dpright:h0.2,dpup:h0.1,guide:b8,leftshoulder:b4,leftstick:b9,lefttrigger:a2,leftx:a0,lefty:a1,rightshoulder:b5,rightstick:b10,righttrigger:a5,rightx:a3,righty:a4,start:b7,x:b2,y:b3,platform:Linux,
-030000005e040000dd02000003020000,Microsoft Xbox One,a:b0,b:b1,back:b6,dpdown:h0.4,dpleft:h0.8,dpright:h0.2,dpup:h0.1,guide:b8,leftshoulder:b4,leftstick:b9,lefttrigger:a2,leftx:a0,lefty:a1,rightshoulder:b5,rightstick:b10,righttrigger:a5,rightx:a3,righty:a4,start:b7,x:b2,y:b3,platform:Linux,
-030000005e040000ea02000008040000,Microsoft Xbox One,a:b0,b:b1,back:b6,dpdown:h0.4,dpleft:h0.8,dpright:h0.2,dpup:h0.1,guide:b8,leftshoulder:b4,leftstick:b9,lefttrigger:a2,leftx:a0,lefty:a1,rightshoulder:b5,rightstick:b10,righttrigger:a5,rightx:a3,righty:a4,start:b7,x:b2,y:b3,platform:Linux,
-060000005e040000120b000009050000,Microsoft Xbox One,a:b0,b:b1,back:b6,dpdown:h0.4,dpleft:h0.8,dpright:h0.2,dpup:h0.1,guide:b8,leftshoulder:b4,leftstick:b9,lefttrigger:a2,leftx:a0,lefty:a1,misc1:b11,rightshoulder:b5,rightstick:b10,righttrigger:a5,rightx:a3,righty:a4,start:b7,x:b2,y:b3,platform:Linux,
+060000005e040000120b000009050000,Microsoft Xbox One,a:b0,b:b1,back:b6,dpdown:h0.4,dpleft:h0.8,dpright:h0.2,dpup:h0.1,guide:b8,leftshoulder:b4,leftstick:b9,lefttrigger:a2,leftx:a0,lefty:a1,rightshoulder:b5,rightstick:b10,righttrigger:a5,rightx:a3,righty:a4,start:b7,x:b2,y:b3,platform:Linux,
+030000005e040000dd02000003020000,Microsoft Xbox One 2015,a:b0,b:b1,back:b6,dpdown:h0.4,dpleft:h0.8,dpright:h0.2,dpup:h0.1,guide:b8,leftshoulder:b4,leftstick:b9,lefttrigger:a2,leftx:a0,lefty:a1,rightshoulder:b5,rightstick:b10,righttrigger:a5,rightx:a3,righty:a4,start:b7,x:b2,y:b3,platform:Linux,
 030000005e040000e302000003020000,Microsoft Xbox One Elite,a:b0,b:b1,back:b6,dpdown:h0.4,dpleft:h0.8,dpright:h0.2,dpup:h0.1,guide:b8,leftshoulder:b4,leftstick:b9,lefttrigger:a2,leftx:a0,lefty:a1,rightshoulder:b5,rightstick:b10,righttrigger:a5,rightx:a3,righty:a4,start:b7,x:b2,y:b3,platform:Linux,
 030000005e040000000b000008040000,Microsoft Xbox One Elite 2,a:b0,b:b1,back:b6,dpdown:h0.4,dpleft:h0.8,dpright:h0.2,dpup:h0.1,guide:b8,leftshoulder:b4,leftstick:b9,lefttrigger:a2,leftx:a0,lefty:a1,rightshoulder:b5,rightstick:b10,righttrigger:a5,rightx:a3,righty:a4,start:b7,x:b2,y:b3,platform:Linux,
 050000005e040000050b000003090000,Microsoft Xbox One Elite 2,a:b0,b:b1,back:b17,dpdown:h0.4,dpleft:h0.8,dpright:h0.2,dpup:h0.1,guide:b12,leftshoulder:b6,leftstick:b13,lefttrigger:a6,leftx:a0,lefty:a1,rightshoulder:b7,rightstick:b14,righttrigger:a5,rightx:a2,righty:a3,start:b11,x:b3,y:b4,platform:Linux,
-030000005e040000120b00000b050000,Microsoft Xbox Series Controller,a:b0,b:b1,back:b6,dpdown:h0.4,dpleft:h0.8,dpright:h0.2,dpup:h0.1,guide:b8,leftshoulder:b4,leftstick:b9,lefttrigger:a2,leftx:a0,lefty:a1,rightshoulder:b5,rightstick:b10,righttrigger:a5,rightx:a3,righty:a4,start:b7,x:b2,y:b3,platform:Linux,
+030000005e040000ea02000008040000,Microsoft Xbox One S,a:b0,b:b1,back:b6,dpdown:h0.4,dpleft:h0.8,dpright:h0.2,dpup:h0.1,guide:b8,leftshoulder:b4,leftstick:b9,lefttrigger:a2,leftx:a0,lefty:a1,rightshoulder:b5,rightstick:b10,righttrigger:a5,rightx:a3,righty:a4,start:b7,x:b2,y:b3,platform:Linux,
+030000005e0400008902000021010000,Microsoft Xbox pad v2,a:b0,b:b1,back:b6,dpdown:h0.4,dpleft:h0.8,dpright:h0.2,dpup:h0.1,leftshoulder:b5,leftstick:b8,lefttrigger:a2,leftx:a0,lefty:a1,rightshoulder:b2,rightstick:b9,righttrigger:a5,rightx:a3,righty:a4,start:b7,x:b3,y:b4,platform:Linux,
 03000000030000000300000002000000,Miroof,a:b1,b:b0,back:b6,leftshoulder:b4,leftx:a0,lefty:a1,rightshoulder:b5,start:b7,x:b3,y:b2,platform:Linux,
 050000004d4f435554452d3035335800,Mocute 053X,a:b0,b:b1,back:b8,dpdown:h0.4,dpleft:h0.8,dpright:h0.2,dpup:h0.1,leftshoulder:b4,leftstick:b10,lefttrigger:b6,leftx:a0,lefty:a1,rightshoulder:b5,rightstick:b11,righttrigger:b7,rightx:a2,righty:a3,start:b9,x:b2,y:b3,platform:Linux,
-05000000e80400006e0400001b010000,Mocute 053X M59,a:b0,b:b1,back:b10,dpdown:h0.4,dpleft:h0.8,dpright:h0.2,dpup:h0.1,leftshoulder:b6,leftstick:b13,lefttrigger:b8,leftx:a0,lefty:a1,rightshoulder:b7,rightstick:b14,righttrigger:b9,rightx:a2,righty:a3,start:b11,x:b3,y:b4,platform:Linux,
 050000004d4f435554452d3035305800,Mocute 054X,a:b0,b:b1,back:b10,dpdown:h0.4,dpleft:h0.8,dpright:h0.2,dpup:h0.1,leftshoulder:b6,leftstick:b13,lefttrigger:a5,leftx:a0,lefty:a1,rightshoulder:b7,rightstick:b14,righttrigger:a4,rightx:a2,righty:a3,start:b11,x:b3,y:b4,platform:Linux,
 05000000d6200000e589000001000000,Moga 2,a:b0,b:b1,back:b9,dpdown:h0.4,dpleft:h0.8,dpright:h0.2,dpup:h0.1,leftshoulder:b4,leftstick:b7,lefttrigger:a5,leftx:a0,lefty:a1,rightshoulder:b5,rightstick:b8,righttrigger:a4,rightx:a2,righty:a3,start:b6,x:b2,y:b3,platform:Linux,
 05000000d6200000ad0d000001000000,Moga Pro,a:b0,b:b1,dpdown:h0.4,dpleft:h0.8,dpright:h0.2,dpup:h0.1,leftshoulder:b4,leftstick:b7,lefttrigger:a5,leftx:a0,lefty:a1,rightshoulder:b5,rightstick:b8,righttrigger:a4,rightx:a2,righty:a3,start:b6,x:b2,y:b3,platform:Linux,
@@ -1330,18 +1301,14 @@ xinput,XInput Controller,a:b0,b:b1,back:b6,dpdown:h0.4,dpleft:h0.8,dpright:h0.2,
 03000000d620000011a7000011010000,Nintendo Switch PowerA Core Plus Controller,a:b1,b:b2,back:b8,dpdown:h0.4,dpleft:h0.8,dpright:h0.2,dpup:h0.1,guide:b12,leftshoulder:b4,leftstick:b10,lefttrigger:b6,leftx:a0,lefty:a1,rightshoulder:b5,rightstick:b11,righttrigger:b7,rightx:a2,righty:a3,start:b9,x:b0,y:b3,platform:Linux,
 030000007e0500000920000000026803,Nintendo Switch Pro Controller,a:b1,b:b0,back:b4,dpdown:b12,dpleft:b13,dpright:b14,dpup:b11,guide:b5,leftshoulder:b9,leftstick:b7,lefttrigger:a4,leftx:a0,lefty:a1,rightshoulder:b10,rightstick:b8,righttrigger:a5,rightx:a2,righty:a3,start:b6,x:b3,y:b2,platform:Linux,
 030000007e0500000920000011810000,Nintendo Switch Pro Controller,a:b0,b:b1,back:b9,dpdown:h0.4,dpleft:h0.8,dpright:h0.2,dpup:h0.1,guide:b11,leftshoulder:b5,leftstick:b12,lefttrigger:b7,leftx:a0,lefty:a1,misc1:b4,rightshoulder:b6,rightstick:b13,righttrigger:b8,rightx:a2,righty:a3,start:b10,x:b3,y:b2,platform:Linux,
-050000007e0500000920000001000000,Nintendo Switch Pro Controller,a:b0,b:b1,back:b8,dpdown:h0.4,dpleft:h0.8,dpright:h0.2,dpup:h0.1,guide:b12,leftshoulder:b4,leftstick:b10,lefttrigger:b6,leftx:a0,lefty:a1,misc1:b13,rightshoulder:b5,rightstick:b11,righttrigger:b7,rightx:a2,righty:a3,start:b9,x:b2,y:b3,platform:Linux,
+050000007e0500000920000001000000,Nintendo Switch Pro Controller,a:b0,b:b1,back:b8,dpdown:h0.4,dpleft:h0.8,dpright:h0.2,dpup:h0.1,guide:b12,leftshoulder:b4,leftstick:b10,lefttrigger:b6,leftx:a0,lefty:a1,misc1:b4,rightshoulder:b5,rightstick:b11,righttrigger:b7,rightx:a2,righty:a3,start:b9,x:b2,y:b3,platform:Linux,
 050000007e0500000920000001800000,Nintendo Switch Pro Controller,a:b0,b:b1,back:b9,dpdown:h0.4,dpleft:h0.8,dpright:h0.2,dpup:h0.1,guide:b11,leftshoulder:b5,leftstick:b12,lefttrigger:b7,leftx:a0,lefty:a1,misc1:b4,rightshoulder:b6,rightstick:b13,righttrigger:b8,rightx:a2,righty:a3,start:b10,x:b3,y:b2,platform:Linux,
 050000007e0500000720000001800000,Nintendo Switch Right Joy-Con,a:b1,b:b2,back:b9,leftshoulder:b4,leftstick:b10,leftx:a1~,lefty:a0,rightshoulder:b6,start:b8,x:b0,y:b3,platform:Linux,
 05000000010000000100000003000000,Nintendo Wii Remote,a:b0,b:b1,back:b8,dpdown:h0.4,dpleft:h0.8,dpright:h0.2,dpup:h0.1,guide:b10,leftshoulder:b4,leftstick:b11,lefttrigger:b6,leftx:a0,lefty:a1,rightshoulder:b5,rightstick:b12,righttrigger:b7,rightx:a2,righty:a3,start:b9,x:b2,y:b3,platform:Linux,
 050000007e0500003003000001000000,Nintendo Wii U Pro Controller,a:b0,b:b1,back:b8,dpdown:b14,dpleft:b15,dpright:b16,dpup:b13,guide:b10,leftshoulder:b4,leftstick:b11,lefttrigger:b6,leftx:a0,lefty:a1,rightshoulder:b5,rightstick:b12,righttrigger:b7,rightx:a2,righty:a3,start:b9,x:b3,y:b2,platform:Linux,
 030000000d0500000308000010010000,Nostromo n45 Dual Analog,a:b0,b:b1,back:b8,dpdown:h0.4,dpleft:h0.8,dpright:h0.2,dpup:h0.1,guide:b9,leftshoulder:b4,leftstick:b12,lefttrigger:b5,leftx:a0,lefty:a1,rightshoulder:b6,rightstick:b11,righttrigger:b7,rightx:a3,righty:a2,start:b10,x:b2,y:b3,platform:Linux,
-030000007e0500001920000011810000,NSO N64 Controller,+rightx:b10,+righty:b8,-rightx:b9,-righty:b7,a:b0,b:b1,dpdown:h0.4,dpleft:h0.8,dpright:h0.2,dpup:h0.1,guide:b11,leftshoulder:b3,lefttrigger:b2,leftx:a0,lefty:a1,misc1:b12,rightshoulder:b4,righttrigger:b5,start:b6,platform:Linux,
 050000007e0500001920000001000000,NSO N64 Controller,+rightx:b8,+righty:b7,-rightx:b3,-righty:b2,a:b1,b:b0,dpdown:h0.4,dpleft:h0.8,dpright:h0.2,dpup:h0.1,guide:b12,leftshoulder:b4,lefttrigger:b6,leftx:a0,lefty:a1,misc1:b13,rightshoulder:b5,righttrigger:b10,start:b9,platform:Linux,
-050000007e0500001920000001800000,NSO N64 Controller,+rightx:b10,+righty:b8,-rightx:b9,-righty:b7,a:b0,b:b1,dpdown:h0.4,dpleft:h0.8,dpright:h0.2,dpup:h0.1,guide:b11,leftshoulder:b3,lefttrigger:b2,leftx:a0,lefty:a1,misc1:b12,rightshoulder:b4,righttrigger:b5,start:b6,platform:Linux,
-030000007e0500001720000011810000,NSO SNES Controller,a:b1,b:b0,back:b8,dpdown:h0.4,dpleft:h0.8,dpright:h0.2,dpup:h0.1,leftshoulder:b4,lefttrigger:b6,rightshoulder:b5,righttrigger:b7,start:b9,x:b3,y:b2,platform:Linux,
-050000007e0500001720000001000000,NSO SNES Controller,a:b0,b:b1,back:b9,dpdown:h0.4,dpleft:h0.8,dpright:h0.2,dpup:h0.1,leftshoulder:b5,lefttrigger:b7,rightshoulder:b6,righttrigger:b8,start:b10,x:b3,y:b2,platform:Linux,
-050000007e0500001720000001800000,NSO SNES Controller,a:b1,b:b0,back:b8,dpdown:h0.4,dpleft:h0.8,dpright:h0.2,dpup:h0.1,leftshoulder:b4,lefttrigger:b6,rightshoulder:b5,righttrigger:b7,start:b9,x:b3,y:b2,platform:Linux,
+050000007e0500001720000001000000,NSO SNES Controller,a:b0,b:b1,back:b9,dpdown:h0.4,dpleft:h0.8,dpright:h0.2,dpup:h0.1,guide:b11,leftshoulder:b5,leftstick:b12,lefttrigger:b7,leftx:a0,lefty:a1,rightshoulder:b6,rightstick:b13,righttrigger:b8,rightx:a2,righty:a3,start:b10,x:b3,y:b2,platform:Linux,
 03000000550900001072000011010000,NVIDIA Controller,a:b0,b:b1,dpdown:h0.4,dpleft:h0.8,dpright:h0.2,dpup:h0.1,guide:b13,leftshoulder:b4,leftstick:b8,lefttrigger:a5,leftx:a0,lefty:a1,rightshoulder:b5,rightstick:b9,righttrigger:a4,rightx:a2,righty:a3,start:b7,x:b2,y:b3,platform:Linux,
 03000000550900001472000011010000,NVIDIA Controller v01.04,a:b0,b:b1,back:b14,dpdown:h0.4,dpleft:h0.8,dpright:h0.2,dpup:h0.1,guide:b16,leftshoulder:b4,leftstick:b7,lefttrigger:a3,leftx:a0,lefty:a1,rightshoulder:b5,rightstick:b8,righttrigger:a4,rightx:a2,righty:a5,start:b6,x:b2,y:b3,platform:Linux,
 05000000550900001472000001000000,NVIDIA Controller v01.04,a:b0,b:b1,back:b14,dpdown:h0.4,dpleft:h0.8,dpright:h0.2,dpup:h0.1,guide:b16,leftshoulder:b4,leftstick:b7,lefttrigger:a3,leftx:a0,lefty:a1,rightshoulder:b5,rightstick:b8,righttrigger:a4,rightx:a2,righty:a5,start:b6,x:b2,y:b3,platform:Linux,
@@ -1363,11 +1330,9 @@ xinput,XInput Controller,a:b0,b:b1,back:b6,dpdown:h0.4,dpleft:h0.8,dpright:h0.2,
 030000006f0e0000c802000012010000,PDP Kingdom Hearts Controller,a:b0,b:b1,back:b6,dpdown:h0.4,dpleft:h0.8,dpright:h0.2,dpup:h0.1,guide:b8,leftshoulder:b4,leftstick:b9,lefttrigger:a2,leftx:a0,lefty:a1,rightshoulder:b5,rightstick:b10,righttrigger:a5,rightx:a3,righty:a4,start:b7,x:b2,y:b3,platform:Linux,
 030000006f0e00008501000011010000,PDP Nintendo Switch Fightpad Pro,a:b2,b:b1,back:b8,dpdown:h0.4,dpleft:h0.8,dpright:h0.2,dpup:h0.1,guide:b12,leftshoulder:b4,leftstick:b10,lefttrigger:b6,leftx:a0,lefty:a1,rightshoulder:b5,rightstick:b11,righttrigger:b7,rightx:a2,righty:a3,start:b9,x:b3,y:b0,platform:Linux,
 030000006f0e00002801000011010000,PDP PS3 Rock Candy Controller,a:b1,b:b2,back:b8,dpdown:h0.4,dpleft:h0.8,dpright:h0.2,dpup:h0.1,leftshoulder:b4,leftstick:b10,lefttrigger:b6,leftx:a0,lefty:a1,rightshoulder:b5,rightstick:b11,righttrigger:b7,rightx:a2,righty:a3,start:b9,x:b0,y:b3,platform:Linux,
-030000006f0e00000901000011010000,PDP PS3 Versus Fighting,a:b1,b:b2,back:b8,dpdown:h0.4,dpleft:h0.8,dpright:h0.2,dpup:h0.1,guide:b12,leftshoulder:b4,lefttrigger:b6,rightshoulder:b5,righttrigger:b7,start:b9,x:b0,y:b3,platform:Linux,
-03000000ad1b000004f9000000010000,PDP Xbox 360 Versus Fighting,a:b0,b:b1,back:b6,dpdown:h0.4,dpleft:h0.8,dpright:h0.2,dpup:h0.1,guide:b8,leftshoulder:b4,lefttrigger:a2,rightshoulder:b5,righttrigger:a5,start:b7,x:b2,y:b3,platform:Linux,
+030000006f0e00000901000011010000,PDP Versus Fighting,a:b1,b:b2,back:b8,dpdown:h0.4,dpleft:h0.8,dpright:h0.2,dpup:h0.1,guide:b12,leftshoulder:b4,lefttrigger:b6,rightshoulder:b5,righttrigger:b7,start:b9,x:b0,y:b3,platform:Linux,
 030000006f0e0000a802000023020000,PDP Xbox One Controller,a:b0,b:b1,back:b8,dpdown:h0.4,dpleft:h0.8,dpright:h0.2,dpup:h0.1,guide:b10,leftshoulder:b4,leftstick:b11,lefttrigger:b6,leftx:a0,lefty:a1,rightshoulder:b5,rightstick:b12,righttrigger:b7,rightx:a2,righty:a3,start:b9,x:b2,y:b3,platform:Linux,
 030000006f0e0000a702000023020000,PDP Xbox One Raven Black,a:b0,b:b1,back:b6,dpdown:h0.4,dpleft:h0.8,dpright:h0.2,dpup:h0.1,guide:b8,leftshoulder:b4,leftstick:b9,lefttrigger:a2,leftx:a0,lefty:a1,rightshoulder:b5,rightstick:b10,righttrigger:a5,rightx:a3,righty:a4,start:b7,x:b2,y:b3,platform:Linux,
-030000006f0e0000d802000006640000,PDP Xbox Series Controller,a:b0,b:b1,back:b6,dpdown:h0.4,dpleft:h0.8,dpright:h0.2,dpup:h0.1,guide:b8,leftshoulder:b4,leftstick:b9,lefttrigger:a2,leftx:a0,lefty:a1,rightshoulder:b5,rightstick:b10,righttrigger:a5,rightx:a3,righty:a4,start:b7,x:b2,y:b3,platform:Linux,
 03000000666600006706000000010000,PlayStation Adapter,a:b2,b:b1,back:b8,dpdown:b14,dpleft:b15,dpright:b13,dpup:b12,leftshoulder:b6,leftstick:b9,lefttrigger:b4,leftx:a0,lefty:a1,rightshoulder:b7,rightstick:b10,righttrigger:b5,rightx:a2,righty:a3,start:b11,x:b3,y:b0,platform:Linux,
 030000004c050000da0c000011010000,PlayStation Controller,a:b2,b:b1,back:b8,leftshoulder:b6,lefttrigger:b4,leftx:a0,lefty:a1,rightshoulder:b7,righttrigger:b5,start:b9,x:b3,y:b0,platform:Linux,
 03000000d9040000160f000000010000,PlayStation Controller Adapter,a:b2,b:b1,back:b8,dpdown:h0.4,dpleft:h0.8,dpright:h0.2,dpup:h0.1,leftshoulder:b6,leftstick:b10,lefttrigger:b4,leftx:a0,lefty:a1,rightshoulder:b7,rightstick:b11,righttrigger:b5,rightx:a3,righty:a2,start:b9,x:b3,y:b0,platform:Linux,
@@ -1467,7 +1432,6 @@ xinput,XInput Controller,a:b0,b:b1,back:b6,dpdown:h0.4,dpleft:h0.8,dpright:h0.2,
 03000000a30600000901000000010000,Saitek P880,a:b2,b:b3,dpdown:h0.4,dpleft:h0.8,dpright:h0.2,dpup:h0.1,leftshoulder:b4,leftstick:b8,lefttrigger:b6,leftx:a0,lefty:a1,rightshoulder:b5,rightstick:b9,righttrigger:b7,rightx:a3,righty:a2,x:b0,y:b1,platform:Linux,
 03000000a30600000b04000000010000,Saitek P990 Dual Analog,a:b1,b:b2,back:b9,dpdown:h0.4,dpleft:h0.8,dpright:h0.2,dpup:h0.1,leftshoulder:b4,leftstick:b10,lefttrigger:b6,leftx:a0,lefty:a1,rightshoulder:b5,rightstick:b11,righttrigger:b7,rightx:a3,righty:a2,start:b8,x:b0,y:b3,platform:Linux,
 03000000a306000020f6000011010000,Saitek PS2700 Rumble,a:b1,b:b2,back:b8,dpdown:h0.4,dpleft:h0.8,dpright:h0.2,dpup:h0.1,guide:b12,leftshoulder:b4,leftstick:b10,lefttrigger:b6,leftx:a0,lefty:a1,rightshoulder:b5,rightstick:b11,righttrigger:b7,rightx:a2,righty:a4,start:b9,x:b0,y:b3,platform:Linux,
-05000000e804000000a000001b010000,Samsung EIGP20,a:b0,b:b1,back:b10,dpdown:h0.4,dpleft:h0.8,dpright:h0.2,dpup:h0.1,guide:b15,leftshoulder:b6,leftx:a0,lefty:a1,rightshoulder:b7,rightx:a2,righty:a3,start:b11,x:b3,y:b4,platform:Linux,
 03000000d81d00000e00000010010000,Savior,a:b0,b:b1,back:b8,leftshoulder:b6,leftstick:b10,lefttrigger:b7,leftx:a0,lefty:a1,rightshoulder:b2,rightstick:b11,righttrigger:b3,start:b9,x:b4,y:b5,platform:Linux,
 03000000a30c00002500000011010000,Sega Genesis Mini 3B Controller,a:b2,b:b1,dpdown:+a4,dpleft:-a3,dpright:+a3,dpup:-a4,righttrigger:b5,start:b9,platform:Linux,
 03000000790000001100000011010000,Sega Saturn,a:b1,b:b2,back:b8,dpdown:+a1,dpleft:-a0,dpright:+a0,dpup:-a1,leftshoulder:b6,lefttrigger:b7,rightshoulder:b5,righttrigger:b4,start:b9,x:b0,y:b3,platform:Linux,
@@ -1513,8 +1477,6 @@ xinput,XInput Controller,a:b0,b:b1,back:b6,dpdown:h0.4,dpleft:h0.8,dpright:h0.2,
 030000008f0e00001431000010010000,SZMY Power PS3,a:b1,b:b2,back:b8,dpdown:h0.4,dpleft:h0.8,dpright:h0.2,dpup:h0.1,guide:b12,leftshoulder:b4,leftstick:b10,lefttrigger:b6,leftx:a0,lefty:a1,rightshoulder:b5,rightstick:b11,righttrigger:b7,rightx:a2,righty:a3,start:b9,x:b0,y:b3,platform:Linux,
 03000000ba2200000701000001010000,Technology Innovation PS2 Adapter,a:b0,b:b1,back:b8,dpdown:h0.4,dpleft:h0.8,dpright:h0.2,dpup:h0.1,leftshoulder:b4,leftstick:b10,lefttrigger:b6,leftx:a0,lefty:a1,rightshoulder:b5,rightstick:b11,righttrigger:b7,rightx:a5,righty:a2,start:b9,x:b3,y:b2,platform:Linux,
 03000000790000001c18000011010000,TGZ Controller,a:b0,b:b1,back:b10,dpdown:h0.4,dpleft:h0.8,dpright:h0.2,dpup:h0.1,leftshoulder:b6,leftstick:b13,lefttrigger:b8,leftx:a0,lefty:a1,rightshoulder:b7,rightstick:b14,righttrigger:b9,rightx:a2,righty:a3,start:b11,x:b3,y:b4,platform:Linux,
-03000000591c00002400000010010000,THEC64 Joystick,a:b0,b:b1,back:b6,leftshoulder:b4,leftx:a0,lefty:a1,rightshoulder:b5,start:b7,x:b2,y:b3,platform:Linux,
-03000000591c00002600000010010000,THEGamepad,a:b2,b:b1,back:b6,leftx:a0,lefty:a1,leftshoulder:b4,rightshoulder:b5,x:b3,y:b0,start:b7,platform:Linux,
 030000004f04000015b3000001010000,Thrustmaster Dual Analog 3.2,a:b0,b:b2,back:b8,dpdown:h0.4,dpleft:h0.8,dpright:h0.2,dpup:h0.1,leftshoulder:b4,leftstick:b10,lefttrigger:b5,leftx:a0,lefty:a1,rightshoulder:b6,rightstick:b11,righttrigger:b7,rightx:a2,righty:a3,start:b9,x:b1,y:b3,platform:Linux,
 030000004f04000015b3000010010000,Thrustmaster Dual Analog 4,a:b0,b:b2,back:b8,dpdown:h0.4,dpleft:h0.8,dpright:h0.2,dpup:h0.1,leftshoulder:b4,leftstick:b10,lefttrigger:b5,leftx:a0,lefty:a1,rightshoulder:b6,rightstick:b11,righttrigger:b7,rightx:a2,righty:a3,start:b9,x:b1,y:b3,platform:Linux,
 030000004f04000020b3000010010000,Thrustmaster Dual Trigger,a:b0,b:b2,back:b8,dpdown:h0.4,dpleft:h0.8,dpright:h0.2,dpup:h0.1,leftshoulder:b4,leftstick:b10,lefttrigger:b5,leftx:a0,lefty:a1,rightshoulder:b6,rightstick:b11,righttrigger:b7,rightx:a2,righty:a3,start:b9,x:b1,y:b3,platform:Linux,
@@ -1563,12 +1525,14 @@ xinput,XInput Controller,a:b0,b:b1,back:b6,dpdown:h0.4,dpleft:h0.8,dpright:h0.2,
 03000000ffff0000ffff000000010000,Xbox Controller,a:b0,b:b1,back:b6,dpdown:h0.4,dpleft:h0.8,dpright:h0.2,dpup:h0.1,leftshoulder:b5,leftstick:b8,lefttrigger:a2,leftx:a0,lefty:a1,rightshoulder:b2,rightstick:b9,righttrigger:a5,rightx:a3,righty:a4,start:b7,x:b3,y:b4,platform:Linux,
 0000000058626f782047616d65706100,Xbox Gamepad,a:b0,b:b1,back:b6,dpdown:h0.4,dpleft:h0.8,dpright:h0.2,dpup:h0.1,guide:b8,leftshoulder:b4,leftstick:b9,lefttrigger:a5,leftx:a0,lefty:a1,rightshoulder:b5,rightstick:b10,righttrigger:a4,rightx:a2,righty:a3,start:b7,x:b2,y:b3,platform:Linux,
 030000005e0400000a0b000005040000,Xbox One Controller,a:b1,b:b0,back:b8,dpdown:h0.4,dpleft:h0.8,dpright:h0.2,dpup:h0.1,leftshoulder:b4,leftstick:b11,lefttrigger:b6,leftx:a0,lefty:a1,rightshoulder:b5,rightstick:b12,righttrigger:b7,rightx:a2,righty:a3,start:b9,x:b3,y:b2,platform:Linux,
+030000005e040000120b000009050000,Xbox One Controller,a:b0,b:b1,back:b6,dpdown:h0.4,dpleft:h0.8,dpright:h0.2,dpup:h0.1,guide:b8,leftshoulder:b4,leftstick:b9,lefttrigger:a2,leftx:a0,lefty:a1,rightshoulder:b5,rightstick:b10,righttrigger:a5,rightx:a3,righty:a4,start:b7,x:b2,y:b3,platform:Linux,
 030000005e040000d102000002010000,Xbox One Controller,a:b0,b:b1,back:b6,dpdown:h0.4,dpleft:h0.8,dpright:h0.2,dpup:h0.1,guide:b8,leftshoulder:b4,leftstick:b9,lefttrigger:a2,leftx:a0,lefty:a1,rightshoulder:b5,rightstick:b10,righttrigger:a5,rightx:a3,righty:a4,start:b7,x:b2,y:b3,platform:Linux,
 030000005e040000ea02000000000000,Xbox One Controller,a:b0,b:b1,back:b6,dpdown:h0.4,dpleft:h0.8,dpright:h0.2,dpup:h0.1,guide:b8,leftshoulder:b4,leftstick:b9,lefttrigger:a2,leftx:a0,lefty:a1,rightshoulder:b5,rightstick:b10,righttrigger:a5,rightx:a3,righty:a4,start:b7,x:b2,y:b3,platform:Linux,
 030000005e040000ea02000001030000,Xbox One Controller,a:b0,b:b1,back:b6,dpdown:h0.4,dpleft:h0.8,dpright:h0.2,dpup:h0.1,guide:b8,leftshoulder:b4,leftstick:b9,lefttrigger:a2,leftx:a0,lefty:a1,rightshoulder:b5,rightstick:b10,righttrigger:a5,rightx:a3,righty:a4,start:b7,x:b2,y:b3,platform:Linux,
 050000005e040000e002000003090000,Xbox One Controller,a:b0,b:b1,back:b6,dpdown:h0.4,dpleft:h0.8,dpright:h0.2,dpup:h0.1,guide:b10,leftshoulder:b4,leftstick:b8,lefttrigger:a2,leftx:a0,lefty:a1,rightshoulder:b5,rightstick:b9,righttrigger:a5,rightx:a3,righty:a4,start:b7,x:b2,y:b3,platform:Linux,
 050000005e040000fd02000003090000,Xbox One Controller,a:b0,b:b1,back:b15,dpdown:h0.4,dpleft:h0.8,dpright:h0.2,dpup:h0.1,guide:b16,leftshoulder:b6,leftstick:b13,lefttrigger:a5,leftx:a0,lefty:a1,rightshoulder:b7,rightstick:b14,righttrigger:a4,rightx:a2,righty:a3,start:b11,x:b3,y:b4,platform:Linux,
 050000005e040000fd02000030110000,Xbox One Controller,a:b0,b:b1,back:b6,dpdown:h0.4,dpleft:h0.8,dpright:h0.2,dpup:h0.1,guide:b8,leftshoulder:b4,leftstick:b9,lefttrigger:a2,leftx:a0,lefty:a1,rightshoulder:b5,rightstick:b10,righttrigger:a5,rightx:a3,righty:a4,start:b7,x:b2,y:b3,platform:Linux,
+060000005e040000120b000007050000,Xbox One Controller,a:b0,b:b1,back:b6,dpdown:h0.4,dpleft:h0.8,dpright:h0.2,dpup:h0.1,guide:b8,leftshoulder:b4,leftstick:b9,lefttrigger:a2,leftx:a0,lefty:a1,rightshoulder:b5,rightstick:b10,righttrigger:a5,rightx:a3,righty:a4,start:b7,x:b2,y:b3,platform:Linux,
 050000005e040000e302000002090000,Xbox One Elite,a:b0,b:b1,back:b136,dpdown:h0.4,dpleft:h0.8,dpright:h0.2,dpup:h0.1,leftshoulder:b6,leftstick:b13,lefttrigger:a6,leftx:a0,lefty:a1,rightshoulder:b7,rightstick:b14,righttrigger:a5,rightx:a2,righty:a3,start:b11,x:b3,y:b4,platform:Linux,
 050000005e040000220b000013050000,Xbox One Elite 2 Controller,a:b0,b:b1,back:b10,dpdown:h0.4,dpleft:h0.8,dpright:h0.2,dpup:h0.1,guide:b12,leftshoulder:b6,leftstick:b13,lefttrigger:a5,leftx:a0,lefty:a1,rightshoulder:b7,rightstick:b14,righttrigger:a4,rightx:a2,righty:a3,start:b11,x:b3,y:b4,platform:Linux,
 050000005e040000050b000002090000,Xbox One Elite Series 2,a:b0,b:b1,back:b136,dpdown:h0.4,dpleft:h0.8,dpright:h0.2,dpup:h0.1,leftshoulder:b6,leftstick:b13,lefttrigger:a6,leftx:a0,lefty:a1,rightshoulder:b7,rightstick:b14,righttrigger:a5,rightx:a2,righty:a3,start:b11,x:b3,y:b4,platform:Linux,
@@ -1576,21 +1540,16 @@ xinput,XInput Controller,a:b0,b:b1,back:b6,dpdown:h0.4,dpleft:h0.8,dpright:h0.2,
 060000005e040000ea0200000d050000,Xbox One S Controller,a:b0,b:b1,back:b6,dpdown:h0.4,dpleft:h0.8,dpright:h0.2,dpup:h0.1,guide:b8,leftshoulder:b4,leftstick:b9,lefttrigger:a2,leftx:a0,lefty:a1,rightshoulder:b5,rightstick:b10,righttrigger:a5,rightx:a3,righty:a4,start:b7,x:b2,y:b3,platform:Linux,
 030000005e040000120b000001050000,Xbox Series Controller,a:b0,b:b1,back:b6,dpdown:h0.4,dpleft:h0.8,dpright:h0.2,dpup:h0.1,guide:b8,leftshoulder:b4,leftstick:b9,lefttrigger:a2,leftx:a0,lefty:a1,rightshoulder:b5,rightstick:b10,righttrigger:a5,rightx:a3,righty:a4,start:b7,x:b2,y:b3,platform:Linux,
 030000005e040000120b000005050000,Xbox Series Controller,a:b0,b:b1,back:b6,dpdown:h0.4,dpleft:h0.8,dpright:h0.2,dpup:h0.1,guide:b8,leftshoulder:b4,leftstick:b9,lefttrigger:a2,leftx:a0,lefty:a1,rightshoulder:b5,rightstick:b10,righttrigger:a5,rightx:a3,righty:a4,start:b7,x:b2,y:b3,platform:Linux,
-030000005e040000120b000007050000,Xbox Series Controller,a:b0,b:b1,back:b6,dpdown:h0.4,dpleft:h0.8,dpright:h0.2,dpup:h0.1,guide:b8,leftshoulder:b4,leftstick:b9,lefttrigger:a2,leftx:a0,lefty:a1,misc1:b11,rightshoulder:b5,rightstick:b10,righttrigger:a5,rightx:a3,righty:a4,start:b7,x:b2,y:b3,platform:Linux,
-030000005e040000120b000009050000,Xbox Series Controller,a:b0,b:b1,back:b6,dpdown:h0.4,dpleft:h0.8,dpright:h0.2,dpup:h0.1,guide:b8,leftshoulder:b4,leftstick:b9,lefttrigger:a2,leftx:a0,lefty:a1,rightshoulder:b5,rightstick:b10,righttrigger:a5,rightx:a3,righty:a4,start:b7,x:b2,y:b3,platform:Linux,
 030000005e040000120b00000d050000,Xbox Series Controller,a:b0,b:b1,back:b6,dpdown:h0.4,dpleft:h0.8,dpright:h0.2,dpup:h0.1,guide:b8,leftshoulder:b4,leftstick:b9,lefttrigger:a2,leftx:a0,lefty:a1,misc1:b11,rightshoulder:b5,rightstick:b10,righttrigger:a5,rightx:a3,righty:a4,start:b7,x:b2,y:b3,platform:Linux,
-030000005e040000120b00000f050000,Xbox Series Controller,a:b0,b:b1,back:b6,dpdown:b13,dpleft:b14,dpright:b15,dpup:b12,leftshoulder:b4,leftstick:b9,lefttrigger:a2,leftx:a0,lefty:a1,rightshoulder:b5,rightstick:b10,righttrigger:a5,rightx:a3,righty:a4,start:b7,x:b2,y:b3,platform:Linux,
 030000005e040000130b000005050000,Xbox Series Controller,a:b0,b:b1,back:b10,dpdown:h0.4,dpleft:h0.8,dpright:h0.2,dpup:h0.1,guide:b12,leftshoulder:b6,leftstick:b13,lefttrigger:a5,leftx:a0,lefty:a1,rightshoulder:b7,rightstick:b14,righttrigger:a4,rightx:a2,righty:a3,start:b11,x:b3,y:b4,platform:Linux,
 050000005e040000130b000001050000,Xbox Series Controller,a:b0,b:b1,back:b10,dpdown:h0.4,dpleft:h0.8,dpright:h0.2,dpup:h0.1,guide:b12,leftshoulder:b6,leftstick:b13,lefttrigger:a5,leftx:a0,lefty:a1,rightshoulder:b7,rightstick:b14,righttrigger:a4,rightx:a2,righty:a3,start:b11,x:b3,y:b4,platform:Linux,
 050000005e040000130b000005050000,Xbox Series Controller,a:b0,b:b1,back:b10,dpdown:h0.4,dpleft:h0.8,dpright:h0.2,dpup:h0.1,guide:b12,leftshoulder:b6,leftstick:b13,lefttrigger:a5,leftx:a0,lefty:a1,rightshoulder:b7,rightstick:b14,righttrigger:a4,rightx:a2,righty:a3,start:b11,x:b3,y:b4,platform:Linux,
-050000005e040000130b000007050000,Xbox Series Controller,a:b0,b:b1,back:b10,dpdown:h0.4,dpleft:h0.8,dpright:h0.2,dpup:h0.1,guide:b12,leftshoulder:b6,leftstick:b13,lefttrigger:a5,leftx:a0,lefty:a1,misc1:b15,rightshoulder:b7,rightstick:b14,righttrigger:a4,rightx:a2,righty:a3,start:b11,x:b3,y:b4,platform:Linux,
 050000005e040000130b000009050000,Xbox Series Controller,a:b0,b:b1,back:b10,dpdown:h0.4,dpleft:h0.8,dpright:h0.2,dpup:h0.1,guide:b12,leftshoulder:b6,leftstick:b13,lefttrigger:a5,leftx:a0,lefty:a1,misc1:b15,rightshoulder:b7,rightstick:b14,righttrigger:a4,rightx:a2,righty:a3,start:b11,x:b3,y:b4,platform:Linux,
-050000005e040000130b000011050000,Xbox Series Controller,a:b0,b:b1,back:b10,dpdown:h0.4,dpleft:h0.8,dpright:h0.2,dpup:h0.1,guide:b12,leftshoulder:b6,leftstick:b13,lefttrigger:a5,leftx:a0,lefty:a1,misc1:b15,rightshoulder:b7,rightstick:b14,righttrigger:a4,rightx:a2,righty:a3,start:b11,x:b3,y:b4,platform:Linux,
 050000005e040000130b000013050000,Xbox Series Controller,a:b0,b:b1,back:b10,dpdown:h0.4,dpleft:h0.8,dpright:h0.2,dpup:h0.1,guide:b12,leftshoulder:b6,leftstick:b13,lefttrigger:a5,leftx:a0,lefty:a1,misc1:b15,rightshoulder:b7,rightstick:b14,righttrigger:a4,rightx:a2,righty:a3,start:b11,x:b3,y:b4,platform:Linux,
-050000005e040000130b000015050000,Xbox Series Controller,a:b0,b:b1,back:b10,dpdown:h0.4,dpleft:h0.8,dpright:h0.2,dpup:h0.1,guide:b12,leftshoulder:b6,leftstick:b13,lefttrigger:a5,leftx:a0,lefty:a1,misc1:b15,rightshoulder:b7,rightstick:b14,righttrigger:a4,rightx:a2,righty:a3,start:b11,x:b3,y:b4,platform:Linux,
-060000005e040000120b000007050000,Xbox Series Controller,a:b0,b:b1,back:b6,dpdown:h0.4,dpleft:h0.8,dpright:h0.2,dpup:h0.1,guide:b8,leftshoulder:b4,leftstick:b9,lefttrigger:a2,leftx:a0,lefty:a1,rightshoulder:b5,rightstick:b10,righttrigger:a5,rightx:a3,righty:a4,start:b7,x:b2,y:b3,platform:Linux,
 060000005e040000120b00000b050000,Xbox Series Controller,a:b0,b:b1,back:b6,dpdown:h0.4,dpleft:h0.8,dpright:h0.2,dpup:h0.1,guide:b8,leftshoulder:b4,leftstick:b9,lefttrigger:a2,leftx:a0,lefty:a1,rightshoulder:b5,rightstick:b10,righttrigger:a5,rightx:a3,righty:a4,start:b7,x:b2,y:b3,platform:Linux,
-060000005e040000120b00000f050000,Xbox Series Controller,a:b0,b:b1,back:b6,dpdown:h0.4,dpleft:h0.8,dpright:h0.2,dpup:h0.1,guide:b8,leftshoulder:b4,leftstick:b9,lefttrigger:a2,leftx:a0,lefty:a1,misc1:b11,rightshoulder:b5,rightstick:b10,righttrigger:a5,rightx:a3,righty:a4,start:b7,x:b2,y:b3,platform:Linux,
+030000005e040000120b000007050000,Xbox Series X Controller,a:b0,b:b1,back:b6,dpdown:h0.4,dpleft:h0.8,dpright:h0.2,dpup:h0.1,guide:b8,leftshoulder:b4,leftstick:b9,lefttrigger:a2,leftx:a0,lefty:a1,misc1:b11,rightshoulder:b5,rightstick:b10,righttrigger:a5,rightx:a3,righty:a4,start:b7,x:b2,y:b3,platform:Linux,
+050000005e040000130b000007050000,Xbox Series X Controller,a:b0,b:b1,back:b10,dpdown:h0.4,dpleft:h0.8,dpright:h0.2,dpup:h0.1,guide:b12,leftshoulder:b6,leftstick:b13,lefttrigger:a5,leftx:a0,lefty:a1,misc1:b15,rightshoulder:b7,rightstick:b14,righttrigger:a4,rightx:a2,righty:a3,start:b11,x:b3,y:b4,platform:Linux,
+050000005e040000130b000011050000,Xbox Series X Controller,a:b0,b:b1,back:b10,dpdown:h0.4,dpleft:h0.8,dpright:h0.2,dpup:h0.1,guide:b12,leftshoulder:b6,leftstick:b13,lefttrigger:a5,leftx:a0,lefty:a1,misc1:b15,rightshoulder:b7,rightstick:b14,righttrigger:a4,rightx:a2,righty:a3,start:b11,x:b3,y:b4,platform:Linux,
 050000005e040000200b000013050000,Xbox Wireless Controller,a:b0,b:b1,back:b10,dpdown:h0.4,dpleft:h0.8,dpright:h0.2,dpup:h0.1,guide:b12,leftshoulder:b6,leftstick:b13,lefttrigger:a5,leftx:a0,lefty:a1,rightshoulder:b7,rightstick:b14,righttrigger:a4,rightx:a2,righty:a3,start:b11,x:b3,y:b4,platform:Linux,
 03000000450c00002043000010010000,XEOX SL6556 BK,a:b0,b:b1,back:b8,dpdown:h0.4,dpleft:h0.8,dpright:h0.2,dpup:h0.1,leftshoulder:b4,leftstick:b10,lefttrigger:b6,leftx:a0,lefty:a1,rightshoulder:b5,rightstick:b11,righttrigger:b7,rightx:a2,righty:a3,start:b9,x:b2,y:b3,platform:Linux,
 05000000172700004431000029010000,XiaoMi Controller,a:b0,b:b1,back:b10,dpdown:h0.4,dpleft:h0.8,dpright:h0.2,dpup:h0.1,guide:b20,leftshoulder:b6,leftstick:b13,lefttrigger:a7,leftx:a0,lefty:a1,rightshoulder:b7,rightstick:b14,righttrigger:a6,rightx:a2,righty:a5,start:b11,x:b3,y:b4,platform:Linux,
--- a/bin/resources/shaders/common/fxaa.fx
+++ b/bin/resources/shaders/common/fxaa.fx
@@ -28,7 +28,6 @@
 in vec2 PSin_t;

 layout(location = 0) out vec4 SV_Target0;
-layout(binding = 0) uniform sampler2D TextureSampler;

 #elif (FXAA_GLSL_VK == 1)

--- a/bin/resources/shaders/dx11/convert.fx
+++ b/bin/resources/shaders/dx11/convert.fx
@@ -1,5 +1,9 @@
 #ifdef SHADER_MODEL // make safe to include in resource file to enforce dependency

+#ifndef PS_SCALE_FACTOR
+#define PS_SCALE_FACTOR 1
+#endif
+
 struct VS_INPUT
 {
 	float4 p : POSITION;
@@ -20,6 +24,7 @@ cbuffer cb0 : register(b0)
 	int EMODA;
 	int EMODC;
 	int DOFFSET;
+	int cb0_pad;
 };

 static const float3x3 rgb2yuv =
@@ -269,25 +274,16 @@ PS_OUTPUT ps_convert_rgba_8i(PS_INPUT input)
 	uint2 subblock = pos & uint2(7u, 1u);
 	uint2 coord = block | subblock;

-	// Compensate for potentially differing page pitch.
-	uint SBW = uint(EMODA);
-	uint DBW = uint(EMODC);
-	uint2 block_xy = coord / uint2(64, 32);
-	uint block_num = (block_xy.y * (DBW / 128)) + block_xy.x;
-	uint2 block_offset = uint2((block_num % (SBW / 64)) * 64, (block_num / (SBW / 64)) * 32);
-	coord = (coord % uint2(64, 32)) + block_offset;
-
 	// Apply offset to cols 1 and 2
 	uint is_col23 = pos.y & 4u;
 	uint is_col13 = pos.y & 2u;
 	uint is_col12 = is_col23 ^ (is_col13 << 1);
 	coord.x ^= is_col12; // If cols 1 or 2, flip bit 3 of x

-	float ScaleFactor = BGColor.x;
-	if (floor(ScaleFactor) != ScaleFactor)
-		coord = uint2(float2(coord) * ScaleFactor);
+	if (floor(PS_SCALE_FACTOR) != PS_SCALE_FACTOR)
+		coord = uint2(float2(coord) * PS_SCALE_FACTOR);
 	else
-		coord *= uint(ScaleFactor);
+		coord *= PS_SCALE_FACTOR;

 	float4 pixel = Texture.Load(int3(int2(coord), 0));
 	float2 sel0 = (pos.y & 2u) == 0u ? pixel.rb : pixel.ga;
@@ -299,7 +295,7 @@ PS_OUTPUT ps_convert_rgba_8i(PS_INPUT input)
 PS_OUTPUT ps_convert_clut_4(PS_INPUT input)
 {
 	// Borrowing the YUV constant buffer.
-	float scale = BGColor.x;
+	float2 scale = BGColor.xy;
 	uint2 offset = uint2(uint(EMODA), uint(EMODC)) + uint(DOFFSET);

 	// CLUT4 is easy, just two rows of 8x8.
@@ -314,7 +310,7 @@ PS_OUTPUT ps_convert_clut_4(PS_INPUT input)

 PS_OUTPUT ps_convert_clut_8(PS_INPUT input)
 {
-	float scale = BGColor.x;
+	float2 scale = BGColor.xy;
 	uint2 offset = uint2(uint(EMODA), uint(EMODC));
 	uint index = min(uint(input.p.x) + uint(DOFFSET), 255u);

--- a/bin/resources/shaders/dx11/imgui.fx
+++ b/bin/resources/shaders/dx11/imgui.fx
@@ -1,36 +0,0 @@
-cbuffer vertexBuffer : register(b0)
-{
-	float4x4 ProjectionMatrix;
-};
-
-struct VS_INPUT
-{
-	float2 pos : POSITION;
-	float4 col : COLOR0;
-	float2 uv : TEXCOORD0;
-};
-
-struct PS_INPUT
-{
-	float4 pos : SV_POSITION;
-	float4 col : COLOR0;
-	float2 uv : TEXCOORD0;
-};
-
-PS_INPUT vs_main(VS_INPUT input)
-{
-	PS_INPUT output;
-	output.pos = mul(ProjectionMatrix, float4(input.pos.xy, 0.f, 1.f));
-	output.col = input.col;
-	output.uv = input.uv;
-	return output;
-}
-
-sampler sampler0 : register(s0);
-Texture2D texture0 : register(t0);
-
-float4 ps_main(PS_INPUT input) : SV_Target
-{
-	float4 out_col = input.col * texture0.Sample(sampler0, input.uv);
-	return out_col;
-}
--- a/bin/resources/shaders/dx11/interlace.fx
+++ b/bin/resources/shaders/dx11/interlace.fx
@@ -23,7 +23,7 @@ float4 ps_main0(PS_INPUT input) : SV_Target0
 	const int vpos  = int(input.p.y); // vertical position of destination texture

 	if ((vpos & 1) == field)
-		return Texture.SampleLevel(Sampler, input.t, 0);
+		return Texture.Sample(Sampler, input.t);
 	else
 		discard;

@@ -34,7 +34,7 @@ float4 ps_main0(PS_INPUT input) : SV_Target0
 // Bob shader
 float4 ps_main1(PS_INPUT input) : SV_Target0
 {
-	return Texture.SampleLevel(Sampler, input.t, 0);
+	return Texture.Sample(Sampler, input.t);
 }


@@ -42,9 +42,9 @@ float4 ps_main1(PS_INPUT input) : SV_Target0
 float4 ps_main2(PS_INPUT input) : SV_Target0
 {
 	float2 vstep = float2(0.0f, ZrH.y);
-	float4 c0 = Texture.SampleLevel(Sampler, input.t - vstep, 0);
-	float4 c1 = Texture.SampleLevel(Sampler, input.t, 0);
-	float4 c2 = Texture.SampleLevel(Sampler, input.t + vstep, 0);
+	float4 c0 = Texture.Sample(Sampler, input.t - vstep);
+	float4 c1 = Texture.Sample(Sampler, input.t);
+	float4 c2 = Texture.Sample(Sampler, input.t + vstep);

 	return (c0 + c1 * 2 + c2) / 4;
 }
@@ -66,11 +66,15 @@ float4 ps_main3(PS_INPUT input) : SV_Target0
 	const int    vres   = int(ZrH.z) >> 1;                           // vertical resolution of source texture
 	const int    lofs   = ((((vres + 1) >> 1) << 1) - vres) & bank;  // line alignment offset for bank 1
 	const int    vpos   = int(input.p.y) + lofs;                     // vertical position of destination texture
+	const float2 bofs   = float2(0.0f, 0.5f * bank);                 // vertical offset of the current bank relative to source texture size
+	const float2 vscale = float2(1.0f, 2.0f);                        // scaling factor from source to destination texture
+	const float2 optr   = input.t - bofs;                            // used to check if the current destination line is within the current bank
+	const float2 iptr   = optr * vscale;                             // pointer to the current pixel in the source texture

 	// if the index of current destination line belongs to the current fiels we update it, otherwise
 	// we leave the old line in the destination buffer
-	if ((vpos & 1) == field)
-		return Texture.SampleLevel(Sampler, input.t, 0);
+	if ((optr.y >= 0.0f) && (optr.y < 0.5f) && ((vpos & 1) == field))
+		return Texture.Sample(Sampler, iptr);
 	else
 		discard;

@@ -129,13 +133,13 @@ float4 ps_main4(PS_INPUT input) : SV_Target0

 	// calculating motion, only relevant for missing lines where the "center line" is pointed by p_t1

-	float4 hn = Texture.SampleLevel(Sampler, p_t0 - lofs, 0); // new high pixel
-	float4 cn = Texture.SampleLevel(Sampler, p_t1, 0);        // new center pixel
-	float4 ln = Texture.SampleLevel(Sampler, p_t0 + lofs, 0); // new low pixel
+	float4 hn = Texture.Sample(Sampler, p_t0 - lofs); // new high pixel
+	float4 cn = Texture.Sample(Sampler, p_t1);        // new center pixel
+	float4 ln = Texture.Sample(Sampler, p_t0 + lofs); // new low pixel

-	float4 ho = Texture.SampleLevel(Sampler, p_t2 - lofs, 0); // old high pixel
-	float4 co = Texture.SampleLevel(Sampler, p_t3, 0);        // old center pixel
-	float4 lo = Texture.SampleLevel(Sampler, p_t2 + lofs, 0); // old low pixel
+	float4 ho = Texture.Sample(Sampler, p_t2 - lofs); // old high pixel
+	float4 co = Texture.Sample(Sampler, p_t3);        // old center pixel
+	float4 lo = Texture.Sample(Sampler, p_t2 + lofs); // old low pixel

 	float3 mh = hn.rgb - ho.rgb; // high pixel motion
 	float3 mc = cn.rgb - co.rgb; // center pixel motion
@@ -160,7 +164,7 @@ float4 ps_main4(PS_INPUT input) : SV_Target0
 	if ((vpos & 1) == field)
 	{
 		// output coordinate present on current field
-		return Texture.SampleLevel(Sampler, p_t0, 0);
+		return Texture.Sample(Sampler, p_t0);
 	}
 	else if ((iptr.y > 0.5f - lofs.y) || (iptr.y < 0.0 + lofs.y))
 	{
--- a/bin/resources/shaders/dx11/tfx.fx
+++ b/bin/resources/shaders/dx11/tfx.fx
@@ -1,3 +1,5 @@
+#ifdef SHADER_MODEL // make safe to include in resource file to enforce dependency
+
 #define FMT_32 0
 #define FMT_24 1
 #define FMT_16 2
@@ -28,23 +30,22 @@
 #define PS_ATST 1
 #define PS_FOG 0
 #define PS_IIP 0
-#define PS_BLEND_HW 0
-#define PS_A_MASKED 0
+#define PS_CLR_HW 0
 #define PS_FBA 0
 #define PS_FBMASK 0
 #define PS_LTF 1
 #define PS_TCOFFSETHACK 0
 #define PS_POINT_SAMPLER 0
-#define PS_REGION_RECT 0
 #define PS_SHUFFLE 0
 #define PS_READ_BA 0
-#define PS_READ16_SRC 0
+#define PS_SWAP_GA 0
 #define PS_DFMT 0
 #define PS_DEPTH_FMT 0
 #define PS_PAL_FMT 0
 #define PS_CHANNEL_FETCH 0
 #define PS_TALES_OF_ABYSS_HLE 0
 #define PS_URBAN_CHAOS_HLE 0
+#define PS_SCALE_FACTOR 1.0
 #define PS_HDR 0
 #define PS_COLCLIP 0
 #define PS_BLEND_A 0
@@ -52,7 +53,6 @@
 #define PS_BLEND_C 0
 #define PS_BLEND_D 0
 #define PS_BLEND_MIX 0
-#define PS_ROUND_INV 0
 #define PS_FIXED_ONE_A 0
 #define PS_PABE 0
 #define PS_DITHER 0
@@ -70,7 +70,6 @@

 #define SW_BLEND (PS_BLEND_A || PS_BLEND_B || PS_BLEND_D)
 #define SW_BLEND_NEEDS_RT (SW_BLEND && (PS_BLEND_A == 1 || PS_BLEND_B == 1 || PS_BLEND_C == 1 || PS_BLEND_D == 1))
-#define SW_AD_TO_HW (PS_BLEND_C == 1 && PS_A_MASKED)

 struct VS_INPUT
 {
@@ -111,8 +110,6 @@ struct PS_INPUT
 #endif
 };

-#ifdef PIXEL_SHADER
-
 struct PS_OUTPUT
 {
 #if !PS_NO_COLOR
@@ -136,6 +133,21 @@ Texture2D<float4> RtTexture : register(t2);
 Texture2D<float> PrimMinTexture : register(t3);
 SamplerState TextureSampler : register(s0);

+#ifdef DX12
+cbuffer cb0 : register(b0)
+#else
+cbuffer cb0
+#endif
+{
+	float2 VertexScale;
+	float2 VertexOffset;
+	float2 TextureScale;
+	float2 TextureOffset;
+	float2 PointSize;
+	uint MaxDepth;
+	uint pad_cb0;
+};
+
 #ifdef DX12
 cbuffer cb1 : register(b1)
 #else
@@ -156,16 +168,12 @@ cbuffer cb1
 	float2 TC_OffsetHack;
 	float2 STScale;
 	float4x4 DitherMatrix;
-	float ScaledScaleFactor;
-	float RcpScaleFactor;
 };

 float4 sample_c(float2 uv, float uv_w)
 {
 #if PS_TEX_IS_FB == 1
 	return RtTexture.Load(int3(int2(uv * WH.zw), 0));
-#elif PS_REGION_RECT == 1
-	return Texture.Load(int3(int2(uv), 0));
 #else
 	if (PS_POINT_SAMPLER)
 	{
@@ -229,15 +237,7 @@ float4 clamp_wrap_uv(float4 uv)

 	if(PS_WMS == PS_WMT)
 	{
-		if(PS_REGION_RECT != 0 && PS_WMS == 0)
-		{
-			uv = frac(uv);
-		}
-		else if(PS_REGION_RECT != 0 && PS_WMS == 1)
-		{
-			uv = saturate(uv);
-		}
-		else if(PS_WMS == 2)
+		if(PS_WMS == 2)
 		{
 			uv = clamp(uv, MinMax.xyxy, MinMax.zwzw);
 		}
@@ -253,15 +253,7 @@ float4 clamp_wrap_uv(float4 uv)
 	}
 	else
 	{
-		if(PS_REGION_RECT != 0 && PS_WMS == 0)
-		{
-			uv.xz = frac(uv.xz);
-		}
-		else if(PS_REGION_RECT != 0 && PS_WMS == 1)
-		{
-			uv.xz = saturate(uv.xz);
-		}
-		else if(PS_WMS == 2)
+		if(PS_WMS == 2)
 		{
 			uv.xz = clamp(uv.xz, MinMax.xx, MinMax.zz);
 		}
@@ -272,15 +264,7 @@ float4 clamp_wrap_uv(float4 uv)
 			#endif
 			uv.xz = (float2)(((uint2)(uv.xz * tex_size.xx) & asuint(MinMax.xx)) | asuint(MinMax.zz)) / tex_size.xx;
 		}
-		if(PS_REGION_RECT != 0 && PS_WMT == 0)
-		{
-			uv.yw = frac(uv.yw);
-		}
-		else if(PS_REGION_RECT != 0 && PS_WMT == 1)
-		{
-			uv.yw = saturate(uv.yw);
-		}
-		else if(PS_WMT == 2)
+		if(PS_WMT == 2)
 		{
 			uv.yw = clamp(uv.yw, MinMax.yy, MinMax.ww);
 		}
@@ -293,12 +277,6 @@ float4 clamp_wrap_uv(float4 uv)
 		}
 	}

-	if(PS_REGION_RECT != 0)
-	{
-		// Normalized -> Integer Coordinates.
-		uv = clamp(uv * WH.zwzw + STRange.xyxy, STRange.xyxy, STRange.zwzw);
-	}
-
 	return uv;
 }

@@ -421,13 +399,9 @@ int2 clamp_wrap_uv_depth(int2 uv)

 float4 sample_depth(float2 st, float2 pos)
 {
-	float2 uv_f = (float2)clamp_wrap_uv_depth(int2(st)) * (float2)ScaledScaleFactor;
-
-#if PS_REGION_RECT == 1
-	uv_f = clamp(uv_f + STRange.xy, STRange.xy, STRange.zw);
-#endif
-
+	float2 uv_f = (float2)clamp_wrap_uv_depth(int2(st)) * (float2)PS_SCALE_FACTOR * (float2)(1.0f / 16.0f);
 	int2 uv = (int2)uv_f;
+
 	float4 t = (float4)(0.0f);

 	if (PS_TALES_OF_ABYSS_HLE == 1)
@@ -586,7 +560,7 @@ float4 sample_color(float2 st, float uv_w)
 	float4x4 c;
 	float2 dd;

-	if (PS_LTF == 0 && PS_AEM_FMT == FMT_32 && PS_PAL_FMT == 0 && PS_REGION_RECT == 0 && PS_WMS < 2 && PS_WMT < 2)
+	if (PS_LTF == 0 && PS_AEM_FMT == FMT_32 && PS_PAL_FMT == 0 && PS_WMS < 2 && PS_WMT < 2)
 	{
 		c[0] = sample_c(st, uv_w);
 	}
@@ -765,13 +739,9 @@ void ps_dither(inout float3 C, float2 pos_xy)
 		if (PS_DITHER == 2)
 			fpos = int2(pos_xy);
 		else
-			fpos = int2(pos_xy * RcpScaleFactor);
+			fpos = int2(pos_xy / (float)PS_SCALE_FACTOR);

-		float value = DitherMatrix[fpos.x & 3][fpos.y & 3];
-		if (PS_ROUND_INV)
-			C -= value;
-		else
-			C += value;
+		C += DitherMatrix[fpos.x & 3][fpos.y & 3];
 	}
 }

@@ -781,9 +751,6 @@ void ps_color_clamp_wrap(inout float3 C)
 	// so we need to limit the color depth on dithered items
 	if (SW_BLEND || PS_DITHER || PS_FBMASK)
 	{
-		if (PS_DFMT == FMT_16 && PS_BLEND_MIX == 0 && PS_ROUND_INV)
-			C += 7.0f; // Need to round up, not down since the shader will invert
-
 		// Standard Clamp
 		if (PS_COLCLIP == 0 && PS_HDR == 0)
 			C = clamp(C, (float3)0.0f, (float3)255.0f);
@@ -796,10 +763,8 @@ void ps_color_clamp_wrap(inout float3 C)
 	}
 }

-void ps_blend(inout float4 Color, inout float4 As_rgba, float2 pos_xy)
+void ps_blend(inout float4 Color, inout float As, float2 pos_xy)
 {
-	float As = As_rgba.a;
-
 	if (SW_BLEND)
 	{
 		// PABE
@@ -823,9 +788,9 @@ void ps_blend(inout float4 Color, inout float4 As_rgba, float2 pos_xy)
 		float3 D = (PS_BLEND_D == 0) ? Cs : ((PS_BLEND_D == 1) ? Cd : (float3)0.0f);

 		// As/Af clamp alpha for Blend mix
-		// We shouldn't clamp blend mix with blend hw 1 as we want alpha higher
+		// We shouldn't clamp blend mix with clr1 as we want alpha higher
 		float C_clamped = C;
-		if (PS_BLEND_MIX > 0 && PS_BLEND_HW != 1)
+		if (PS_BLEND_MIX > 0 && PS_CLR_HW != 1)
 			C_clamped = min(C_clamped, 1.0f);

 		if (PS_BLEND_A == PS_BLEND_B)
@@ -844,19 +809,21 @@ void ps_blend(inout float4 Color, inout float4 As_rgba, float2 pos_xy)
 		else
 			Color.rgb = trunc(((A - B) * C) + D);

-		if (PS_BLEND_HW == 1)
+		if (PS_CLR_HW == 1)
 		{
-			// As or Af
-			As_rgba.rgb = (float3)C;
+			// Replace Af with As so we can do proper compensation for Alpha.
+			if (PS_BLEND_C == 2)
+				As = Af;
 			// Subtract 1 for alpha to compensate for the changed equation,
 			// if c.rgb > 255.0f then we further need to adjust alpha accordingly,
 			// we pick the lowest overflow from all colors because it's the safest,
 			// we divide by 255 the color because we don't know Cd value,
 			// changed alpha should only be done for hw blend.
-			float3 alpha_compensate = max((float3)1.0f, Color.rgb / (float3)255.0f);
-			As_rgba.rgb -= alpha_compensate;
+			float min_color = min(min(Color.r, Color.g), Color.b);
+			float alpha_compensate = max(1.0f, min_color / 255.0f);
+			As -= alpha_compensate;
 		}
-		else if (PS_BLEND_HW == 2)
+		else if (PS_CLR_HW == 2)
 		{
 			// Compensate slightly for Cd*(As + 1) - Cs*As.
 			// The initial factor we chose is 1 (0.00392)
@@ -866,26 +833,16 @@ void ps_blend(inout float4 Color, inout float4 As_rgba, float2 pos_xy)
 			float color_compensate = 1.0f * (C + 1.0f);
 			Color.rgb -= (float3)color_compensate;
 		}
-		else if (PS_BLEND_HW == 3)
-		{
-			// As, Ad or Af clamped.
-			As_rgba.rgb = (float3)C_clamped;
-			// Cs*(Alpha + 1) might overflow, if it does then adjust alpha value
-			// that is sent on second output to compensate.
-			float3 overflow_check = (Color.rgb - (float3)255.0f) / 255.0f;
-			float3 alpha_compensate = max((float3)0.0f, overflow_check);
-			As_rgba.rgb -= alpha_compensate;
-		}
 	}
 	else
 	{
-		if (PS_BLEND_HW == 1)
+		if (PS_CLR_HW == 1 || PS_CLR_HW == 5)
 		{
 			// Needed for Cd * (As/Ad/F + 1) blending modes

 			Color.rgb = (float3)255.0f;
 		}
-		else if (PS_BLEND_HW == 2)
+		else if (PS_CLR_HW == 2 || PS_CLR_HW == 4)
 		{
 			// Cd*As,Cd*Ad or Cd*F

@@ -894,16 +851,12 @@ void ps_blend(inout float4 Color, inout float4 As_rgba, float2 pos_xy)
 			Color.rgb = max((float3)0.0f, (Alpha - (float3)1.0f));
 			Color.rgb *= (float3)255.0f;
 		}
-		else if (PS_BLEND_HW == 3)
+		else if (PS_CLR_HW == 3)
 		{
 			// Needed for Cs*Ad, Cs*Ad + Cd, Cd - Cs*Ad
-			// Multiply Color.rgb by (255/128) to compensate for wrong Ad/255 value when rgb are below 128.
-			// When any color channel is higher than 128 then adjust the compensation automatically
-			// to give us more accurate colors, otherwise they will be wrong.
-			// The higher the value (>128) the lower the compensation will be.
-			float max_color = max(max(Color.r, Color.g), Color.b);
-			float color_compensate = 255.0f / max(128.0f, max_color);
-			Color.rgb *= (float3)color_compensate;
+			// Multiply Color.rgb by (255/128) to compensate for wrong Ad/255 value
+
+			Color.rgb *= (255.0f / 128.0f);
 		}
 	}
 }
@@ -923,19 +876,17 @@ PS_OUTPUT ps_main(PS_INPUT input)

 	if (PS_SHUFFLE)
 	{
-		uint4 denorm_c = uint4(C);
-		uint2 denorm_TA = uint2(float2(TA.xy) * 255.0f + 0.5f);
-		
-		if (PS_READ16_SRC)
+		if(PS_SWAP_GA)
 		{
-			C.rb = (float2)float((denorm_c.r >> 3) | (((denorm_c.g >> 3) & 0x7u) << 5));
-			if (denorm_c.a & 0x80u)
-				C.ga = (float2)float((denorm_c.g >> 6) | ((denorm_c.b >> 3) << 2) | (denorm_TA.y & 0x80u));
-			else
-				C.ga = (float2)float((denorm_c.g >> 6) | ((denorm_c.b >> 3) << 2) | (denorm_TA.x & 0x80u));
+			float4 RT = trunc(RtTexture.Load(int3(input.p.xy, 0)) * 255.0f + 0.1f);
+			C.a = C.g;
+			C.g = C.a;
 		}
 		else
 		{
+			uint4 denorm_c = uint4(C);
+			uint2 denorm_TA = uint2(float2(TA.xy) * 255.0f + 0.5f);
+
 			// Mask will take care of the correct destination
 			if (PS_READ_BA)
 				C.rb = C.bb;
@@ -967,15 +918,15 @@ PS_OUTPUT ps_main(PS_INPUT input)
 		C.a = 128.0f;
 	}

-	float4 alpha_blend;
-	if (SW_AD_TO_HW)
+	float alpha_blend;
+	if (PS_BLEND_C == 1 && PS_CLR_HW > 3)
 	{
 		float4 RT = trunc(RtTexture.Load(int3(input.p.xy, 0)) * 255.0f + 0.1f);
-		alpha_blend = (float4)(RT.a / 128.0f);
+		alpha_blend = RT.a / 128.0f;
 	}
 	else
 	{
-		alpha_blend = (float4)(C.a / 128.0f);
+		alpha_blend = C.a / 128.0f;
 	}

 	// Alpha correction
@@ -1025,12 +976,12 @@ PS_OUTPUT ps_main(PS_INPUT input)
 #if !PS_NO_COLOR
 	output.c0 = PS_HDR ? float4(C.rgb / 65535.0f, C.a / 255.0f) : C / 255.0f;
 #if !PS_NO_COLOR1
-	output.c1 = alpha_blend;
+	output.c1 = (float4)(alpha_blend);
 #endif

 #if PS_NO_ABLEND
 	// write alpha blend factor into col0
-	output.c0.a = alpha_blend.a;
+	output.c0.a = alpha_blend;
 #endif
 #if PS_ONLY_ALPHA
 	// rgb isn't used
@@ -1047,29 +998,10 @@ PS_OUTPUT ps_main(PS_INPUT input)
 	return output;
 }

-#endif // PIXEL_SHADER
-
 //////////////////////////////////////////////////////////////////////
 // Vertex Shader
 //////////////////////////////////////////////////////////////////////

-#ifdef VERTEX_SHADER
-
-#ifdef DX12
-cbuffer cb0 : register(b0)
-#else
-cbuffer cb0
-#endif
-{
-	float2 VertexScale;
-	float2 VertexOffset;
-	float2 TextureScale;
-	float2 TextureOffset;
-	float2 PointSize;
-	uint MaxDepth;
-	uint BaseVertex; // Only used in DX11.
-};
-
 VS_OUTPUT vs_main(VS_INPUT input)
 {
 	// Clamp to max depth, gs doesn't wrap
@@ -1122,101 +1054,156 @@ VS_OUTPUT vs_main(VS_INPUT input)
 	return output;
 }

-#if VS_EXPAND != 0
+//////////////////////////////////////////////////////////////////////
+// Geometry Shader
+//////////////////////////////////////////////////////////////////////

-struct VS_RAW_INPUT
+#if GS_FORWARD_PRIMID
+#define PRIMID_IN , uint primid : SV_PrimitiveID
+#define VS2PS(x) vs2ps_impl(x, primid)
+PS_INPUT vs2ps_impl(VS_OUTPUT vs, uint primid)
 {
-	float2 ST;
-	uint RGBA;
-	float Q;
-	uint XY;
-	uint Z;
-	uint UV;
-	uint FOG;
-};
-
-StructuredBuffer<VS_RAW_INPUT> vertices : register(t0);
-
-VS_INPUT load_vertex(uint index)
-{
-#ifdef DX12
-	VS_RAW_INPUT raw = vertices.Load(index);
+	PS_INPUT o;
+	o.p = vs.p;
+	o.t = vs.t;
+	o.ti = vs.ti;
+	o.c = vs.c;
+	o.primid = primid;
+	return o;
+}
 #else
-	VS_RAW_INPUT raw = vertices.Load(BaseVertex + index);
+#define PRIMID_IN
+#define VS2PS(x) vs2ps_impl(x)
+PS_INPUT vs2ps_impl(VS_OUTPUT vs)
+{
+	PS_INPUT o;
+	o.p = vs.p;
+	o.t = vs.t;
+	o.ti = vs.ti;
+	o.c = vs.c;
+	return o;
+}
 #endif

-	VS_INPUT vert;
-	vert.st = raw.ST;
-	vert.c = uint4(raw.RGBA & 0xFFu, (raw.RGBA >> 8) & 0xFFu, (raw.RGBA >> 16) & 0xFFu, raw.RGBA >> 24);
-	vert.q = raw.Q;
-	vert.p = uint2(raw.XY & 0xFFFFu, raw.XY >> 16);
-	vert.z = raw.Z;
-	vert.uv = uint2(raw.UV & 0xFFFFu, raw.UV >> 16);
-	vert.f = float4(float(raw.FOG & 0xFFu), float((raw.FOG >> 8) & 0xFFu), float((raw.FOG >> 16) & 0xFFu), float(raw.FOG >> 24)) / 255.0f;
-	return vert;
+#if GS_PRIM == 0
+
+[maxvertexcount(6)]
+void gs_main(point VS_OUTPUT input[1], inout TriangleStream<PS_INPUT> stream PRIMID_IN)
+{
+	// Transform a point to a NxN sprite
+	PS_INPUT Point = VS2PS(input[0]);
+
+	// Get new position
+	float4 lt_p = input[0].p;
+	float4 rb_p = input[0].p + float4(PointSize.x, PointSize.y, 0.0f, 0.0f);
+	float4 lb_p = rb_p;
+	float4 rt_p = rb_p;
+	lb_p.x = lt_p.x;
+	rt_p.y = lt_p.y;
+
+	// Triangle 1
+	Point.p = lt_p;
+	stream.Append(Point);
+
+	Point.p = lb_p;
+	stream.Append(Point);
+
+	Point.p = rt_p;
+	stream.Append(Point);
+
+	// Triangle 2
+	Point.p = lb_p;
+	stream.Append(Point);
+
+	Point.p = rt_p;
+	stream.Append(Point);
+
+	Point.p = rb_p;
+	stream.Append(Point);
 }

-VS_OUTPUT vs_main_expand(uint vid : SV_VertexID)
+#elif GS_PRIM == 1
+
+[maxvertexcount(6)]
+void gs_main(line VS_OUTPUT input[2], inout TriangleStream<PS_INPUT> stream PRIMID_IN)
 {
-#if VS_EXPAND == 1 // Point
+	// Transform a line to a thick line-sprite
+	PS_INPUT left = VS2PS(input[0]);
+	PS_INPUT right = VS2PS(input[1]);
+	float2 lt_p = input[0].p.xy;
+	float2 rt_p = input[1].p.xy;

-	VS_OUTPUT vtx = vs_main(load_vertex(vid >> 2));
-
-	vtx.p.x += ((vid & 1u) != 0u) ? PointSize.x : 0.0f;
-	vtx.p.y += ((vid & 2u) != 0u) ? PointSize.y : 0.0f;
-
-	return vtx;
-
-#elif VS_EXPAND == 2 // Line
-
-	uint vid_base = vid >> 2;
-	bool is_bottom = vid & 2;
-	bool is_right = vid & 1;
-	// All lines will be a pair of vertices next to each other
-	// Since DirectX uses provoking vertex first, the bottom point will be the lower of the two
-	uint vid_other = is_bottom ? vid_base + 1 : vid_base - 1;
-	VS_OUTPUT vtx = vs_main(load_vertex(vid_base));
-	VS_OUTPUT other = vs_main(load_vertex(vid_other));
-
-	float2 line_vector = normalize(vtx.p.xy - other.p.xy);
+	// Potentially there is faster math
+	float2 line_vector = normalize(rt_p.xy - lt_p.xy);
 	float2 line_normal = float2(line_vector.y, -line_vector.x);
 	float2 line_width = (line_normal * PointSize) / 2;
-	// line_normal is inverted for bottom point
-	float2 offset = (is_bottom ^ is_right) ? line_width : -line_width;
-	vtx.p.xy += offset;

-	// Lines will be run as (0 1 2) (1 2 3)
-	// This means that both triangles will have a point based off the top line point as their first point
-	// So we don't have to do anything for !IIP
+	lt_p -= line_width;
+	rt_p -= line_width;
+	float2 lb_p = input[0].p.xy + line_width;
+	float2 rb_p = input[1].p.xy + line_width;

-	return vtx;
+	#if GS_IIP == 0
+	left.c = right.c;
+	#endif

-#elif VS_EXPAND == 3 // Sprite
+	// Triangle 1
+	left.p.xy = lt_p;
+	stream.Append(left);

-	// Sprite points are always in pairs
-	uint vid_base = vid >> 1;
-	uint vid_lt = vid_base & ~1u;
-	uint vid_rb = vid_base | 1u;
+	left.p.xy = lb_p;
+	stream.Append(left);

-	VS_OUTPUT lt = vs_main(load_vertex(vid_lt));
-	VS_OUTPUT rb = vs_main(load_vertex(vid_rb));
-	VS_OUTPUT vtx = rb;
+	right.p.xy = rt_p;
+	stream.Append(right);
+	stream.RestartStrip();

-	bool is_right = ((vid & 1u) != 0u);
-	vtx.p.x = is_right ? lt.p.x : vtx.p.x;
-	vtx.t.x = is_right ? lt.t.x : vtx.t.x;
-	vtx.ti.xz = is_right ? lt.ti.xz : vtx.ti.xz;
+	// Triangle 2
+	left.p.xy = lb_p;
+	stream.Append(left);

-	bool is_bottom = ((vid & 2u) != 0u);
-	vtx.p.y = is_bottom ? lt.p.y : vtx.p.y;
-	vtx.t.y = is_bottom ? lt.t.y : vtx.t.y;
-	vtx.ti.yw = is_bottom ? lt.ti.yw : vtx.ti.yw;
+	right.p.xy = rt_p;
+	stream.Append(right);

-	return vtx;
-
-#endif
+	right.p.xy = rb_p;
+	stream.Append(right);
+	stream.RestartStrip();
 }

-#endif // VS_EXPAND
+#elif GS_PRIM == 3

-#endif // VERTEX_SHADER
+[maxvertexcount(4)]
+void gs_main(line VS_OUTPUT input[2], inout TriangleStream<PS_INPUT> stream PRIMID_IN)
+{
+	PS_INPUT lt = VS2PS(input[0]);
+	PS_INPUT rb = VS2PS(input[1]);
+
+	// flat depth
+	lt.p.z = rb.p.z;
+	// flat fog and texture perspective
+	lt.t.zw = rb.t.zw;
+
+	// flat color
+	lt.c = rb.c;
+
+	// Swap texture and position coordinate
+	PS_INPUT lb = rb;
+	lb.p.x = lt.p.x;
+	lb.t.x = lt.t.x;
+	lb.ti.x = lt.ti.x;
+	lb.ti.z = lt.ti.z;
+
+	PS_INPUT rt = rb;
+	rt.p.y = lt.p.y;
+	rt.t.y = lt.t.y;
+	rt.ti.y = lt.ti.y;
+	rt.ti.w = lt.ti.w;
+
+	stream.Append(lt);
+	stream.Append(lb);
+	stream.Append(rt);
+	stream.Append(rb);
+}
+
+#endif
+#endif
--- a/bin/resources/shaders/opengl/cas.glsl
+++ b/bin/resources/shaders/opengl/cas.glsl
@@ -30,7 +30,7 @@ layout(binding=0, rgba8) uniform writeonly image2D imgDst;

 AF3 CasLoad(ASU2 p)
 {
-	return texelFetch(imgSrc, srcOffset + ivec2(p), 0).rgb;
+    return texelFetch(imgSrc, srcOffset + ivec2(p), 0).rgb;
 }

 // Lets you transform input from the load into a linear color space between 0 and 1. See ffx_cas.h
@@ -42,23 +42,23 @@ void CasInput(inout AF1 r, inout AF1 g, inout AF1 b) {}
 layout(local_size_x=64) in;
 void main()
 {
-	// Do remapping of local xy in workgroup for a more PS-like swizzle pattern.
-	AU2 gxy = ARmp8x8(gl_LocalInvocationID.x)+AU2(gl_WorkGroupID.x<<4u,gl_WorkGroupID.y<<4u);
+    // Do remapping of local xy in workgroup for a more PS-like swizzle pattern.
+    AU2 gxy = ARmp8x8(gl_LocalInvocationID.x)+AU2(gl_WorkGroupID.x<<4u,gl_WorkGroupID.y<<4u);

-	// Filter.
-	AF4 c;
-	CasFilter(c.r, c.g, c.b, gxy, const0, const1, CAS_SHARPEN_ONLY);
-	imageStore(imgDst, ASU2(gxy), c);
-	gxy.x += 8u;
+    // Filter.
+    AF4 c;
+    CasFilter(c.r, c.g, c.b, gxy, const0, const1, CAS_SHARPEN_ONLY);
+    imageStore(imgDst, ASU2(gxy), c);
+    gxy.x += 8u;

-	CasFilter(c.r, c.g, c.b, gxy, const0, const1, CAS_SHARPEN_ONLY);
-	imageStore(imgDst, ASU2(gxy), c);
-	gxy.y += 8u;
+    CasFilter(c.r, c.g, c.b, gxy, const0, const1, CAS_SHARPEN_ONLY);
+    imageStore(imgDst, ASU2(gxy), c);
+    gxy.y += 8u;

-	CasFilter(c.r, c.g, c.b, gxy, const0, const1, CAS_SHARPEN_ONLY);
-	imageStore(imgDst, ASU2(gxy), c);
-	gxy.x -= 8u;
+    CasFilter(c.r, c.g, c.b, gxy, const0, const1, CAS_SHARPEN_ONLY);
+    imageStore(imgDst, ASU2(gxy), c);
+    gxy.x -= 8u;

-	CasFilter(c.r, c.g, c.b, gxy, const0, const1, CAS_SHARPEN_ONLY);
-	imageStore(imgDst, ASU2(gxy), c);
+    CasFilter(c.r, c.g, c.b, gxy, const0, const1, CAS_SHARPEN_ONLY);
+    imageStore(imgDst, ASU2(gxy), c);
 }
--- a/bin/resources/shaders/opengl/common_header.glsl
+++ b/bin/resources/shaders/opengl/common_header.glsl
@@ -0,0 +1,101 @@
+//#version 420 // Keep it for editor detection
+
+//////////////////////////////////////////////////////////////////////
+// Common Interface Definition
+//////////////////////////////////////////////////////////////////////
+
+#ifdef VERTEX_SHADER
+
+#if !pGL_ES
+out gl_PerVertex {
+    vec4 gl_Position;
+    float gl_PointSize;
+#if !pGL_ES
+    float gl_ClipDistance[1];
+#endif
+};
+#endif
+
+#endif
+
+
+
+#ifdef GEOMETRY_SHADER
+
+#if !pGL_ES
+in gl_PerVertex {
+    vec4 gl_Position;
+    float gl_PointSize;
+#if !pGL_ES
+    float gl_ClipDistance[1];
+#endif
+} gl_in[];
+
+out gl_PerVertex {
+    vec4 gl_Position;
+    float gl_PointSize;
+#if !pGL_ES
+    float gl_ClipDistance[1];
+#endif
+};
+#endif
+
+#endif
+
+//////////////////////////////////////////////////////////////////////
+// Constant Buffer Definition
+//////////////////////////////////////////////////////////////////////
+// Performance note, some drivers (nouveau) will validate all Constant Buffers
+// even if only one was updated.
+
+#if defined(VERTEX_SHADER) || defined(GEOMETRY_SHADER)
+layout(std140, binding = 1) uniform cb20
+{
+    vec2  VertexScale;
+    vec2  VertexOffset;
+
+    vec2  TextureScale;
+    vec2  TextureOffset;
+
+    vec2  PointSize;
+    uint  MaxDepth;
+    uint  pad_cb20;
+};
+#endif
+
+#if defined(VERTEX_SHADER) || defined(FRAGMENT_SHADER)
+layout(std140, binding = 0) uniform cb21
+{
+    vec3 FogColor;
+    float AREF;
+
+    vec4 WH;
+
+    vec2 TA;
+    float MaxDepthPS;
+    float Af;
+
+    uvec4 FbMask;
+
+    vec4 HalfTexel;
+
+    vec4 MinMax;
+    vec4 STRange;
+
+    ivec4 ChannelShuffle;
+
+    vec2 TC_OffsetHack;
+    vec2 STScale;
+
+    mat4 DitherMatrix;
+};
+#endif
+
+//////////////////////////////////////////////////////////////////////
+// Default Sampler
+//////////////////////////////////////////////////////////////////////
+#ifdef FRAGMENT_SHADER
+
+layout(binding = 0) uniform sampler2D TextureSampler;
+
+#endif
--- a/bin/resources/shaders/opengl/convert.glsl
+++ b/bin/resources/shaders/opengl/convert.glsl
@@ -21,10 +21,10 @@ out vec4 PSin_c;

 void vs_main()
 {
-	PSin_p = vec4(POSITION, 0.5f, 1.0f);
-	PSin_t = TEXCOORD0;
-	PSin_c = COLOR;
-	gl_Position = vec4(POSITION, 0.5f, 1.0f); // NOTE I don't know if it is possible to merge POSITION_OUT and gl_Position
+    PSin_p = vec4(POSITION, 0.5f, 1.0f);
+    PSin_t = TEXCOORD0;
+    PSin_c = COLOR;
+    gl_Position = vec4(POSITION, 0.5f, 1.0f); // NOTE I don't know if it is possible to merge POSITION_OUT and gl_Position
 }

 #endif
@@ -35,8 +35,6 @@ in vec4 PSin_p;
 in vec2 PSin_t;
 in vec4 PSin_c;

-layout(binding = 0) uniform sampler2D TextureSampler;
-
 // Give a different name so I remember there is a special case!
 #if defined(ps_convert_rgba8_16bits) || defined(ps_convert_float32_32bits)
 layout(location = 0) out uint SV_Target1;
@@ -46,13 +44,13 @@ layout(location = 0) out vec4 SV_Target0;

 vec4 sample_c()
 {
-	return texture(TextureSampler, PSin_t);
+    return texture(TextureSampler, PSin_t);
 }

 #ifdef ps_copy
 void ps_copy()
 {
-	SV_Target0 = sample_c();
+    SV_Target0 = sample_c();
 }
 #endif

@@ -67,20 +65,20 @@ void ps_depth_copy()
 // Need to be careful with precision here, it can break games like Spider-Man 3 and Dogs Life
 void ps_convert_rgba8_16bits()
 {
-	highp uvec4 i = uvec4(sample_c() * vec4(255.5f, 255.5f, 255.5f, 255.5f));
+    highp uvec4 i = uvec4(sample_c() * vec4(255.5f, 255.5f, 255.5f, 255.5f));

-	SV_Target1 = ((i.x & 0x00F8u) >> 3) | ((i.y & 0x00F8u) << 2) | ((i.z & 0x00f8u) << 7) | ((i.w & 0x80u) << 8);
+    SV_Target1 = ((i.x & 0x00F8u) >> 3) | ((i.y & 0x00F8u) << 2) | ((i.z & 0x00f8u) << 7) | ((i.w & 0x80u) << 8);
 }
 #endif

 #ifdef ps_convert_float32_32bits
 void ps_convert_float32_32bits()
 {
-	// Convert a GL_FLOAT32 depth texture into a 32 bits UINT texture
+    // Convert a GL_FLOAT32 depth texture into a 32 bits UINT texture
 #if HAS_CLIP_CONTROL
-	SV_Target1 = uint(exp2(32.0f) * sample_c().r);
+    SV_Target1 = uint(exp2(32.0f) * sample_c().r);
 #else
-	SV_Target1 = uint(exp2(24.0f) * sample_c().r);
+    SV_Target1 = uint(exp2(24.0f) * sample_c().r);
 #endif
 }
 #endif
@@ -88,205 +86,195 @@ void ps_convert_float32_32bits()
 #ifdef ps_convert_float32_rgba8
 void ps_convert_float32_rgba8()
 {
-	// Convert a GL_FLOAT32 depth texture into a RGBA color texture
+    // Convert a GL_FLOAT32 depth texture into a RGBA color texture
 #if HAS_CLIP_CONTROL
-	uint d = uint(sample_c().r * exp2(32.0f));
+    uint d = uint(sample_c().r * exp2(32.0f));
 #else
-	uint d = uint(sample_c().r * exp2(24.0f));
+    uint d = uint(sample_c().r * exp2(24.0f));
 #endif
-	SV_Target0 = vec4(uvec4((d & 0xFFu), ((d >> 8) & 0xFFu), ((d >> 16) & 0xFFu), (d >> 24))) / vec4(255.0);
+    SV_Target0 = vec4(uvec4((d & 0xFFu), ((d >> 8) & 0xFFu), ((d >> 16) & 0xFFu), (d >> 24))) / vec4(255.0);
 }
 #endif

 #ifdef ps_convert_float16_rgb5a1
 void ps_convert_float16_rgb5a1()
 {
-	// Convert a GL_FLOAT32 (only 16 lsb) depth into a RGB5A1 color texture
+    // Convert a GL_FLOAT32 (only 16 lsb) depth into a RGB5A1 color texture
 #if HAS_CLIP_CONTROL
-	uint d = uint(sample_c().r * exp2(32.0f));
+    uint d = uint(sample_c().r * exp2(32.0f));
 #else
-	uint d = uint(sample_c().r * exp2(24.0f));
+    uint d = uint(sample_c().r * exp2(24.0f));
 #endif
-	SV_Target0 = vec4(uvec4((d & 0x1Fu), ((d >> 5) & 0x1Fu), ((d >> 10) & 0x1Fu), (d >> 15) & 0x01u)) / vec4(32.0f, 32.0f, 32.0f, 1.0f);
+    SV_Target0 = vec4(uvec4((d & 0x1Fu), ((d >> 5) & 0x1Fu), ((d >> 10) & 0x1Fu), (d >> 15) & 0x01u)) / vec4(32.0f, 32.0f, 32.0f, 1.0f);
 }
 #endif

 float rgba8_to_depth32(vec4 unorm)
 {
-	uvec4 c = uvec4(unorm * vec4(255.5f));
+    uvec4 c = uvec4(unorm * vec4(255.5f));
 #if HAS_CLIP_CONTROL
-	return float(c.r | (c.g << 8) | (c.b << 16) | (c.a << 24)) * exp2(-32.0f);
+    return float(c.r | (c.g << 8) | (c.b << 16) | (c.a << 24)) * exp2(-32.0f);
 #else
-	return float(c.r | (c.g << 8) | (c.b << 16) | (c.a << 24)) * exp2(-24.0f);
+    return float(c.r | (c.g << 8) | (c.b << 16) | (c.a << 24)) * exp2(-24.0f);
 #endif
 }

 float rgba8_to_depth24(vec4 unorm)
 {
-	uvec3 c = uvec3(unorm.rgb * vec3(255.5f));
+    uvec3 c = uvec3(unorm.rgb * vec3(255.5f));
 #if HAS_CLIP_CONTROL
-	return float(c.r | (c.g << 8) | (c.b << 16)) * exp2(-32.0f);
+    return float(c.r | (c.g << 8) | (c.b << 16)) * exp2(-32.0f);
 #else
-	return float(c.r | (c.g << 8) | (c.b << 16)) * exp2(-24.0f);
+    return float(c.r | (c.g << 8) | (c.b << 16)) * exp2(-24.0f);
 #endif
 }

 float rgba8_to_depth16(vec4 unorm)
 {
-	uvec2 c = uvec2(unorm.rg * vec2(255.5f));
+    uvec2 c = uvec2(unorm.rg * vec2(255.5f));
 #if HAS_CLIP_CONTROL
-	return float(c.r | (c.g << 8)) * exp2(-32.0f);
+    return float(c.r | (c.g << 8)) * exp2(-32.0f);
 #else
-	return float(c.r | (c.g << 8)) * exp2(-24.0f);
+    return float(c.r | (c.g << 8)) * exp2(-24.0f);
 #endif
 }

 float rgb5a1_to_depth16(vec4 unorm)
 {
-	uvec4 c = uvec4(unorm * vec4(255.5f));
+    uvec4 c = uvec4(unorm * vec4(255.5f));
 #if HAS_CLIP_CONTROL
-	return float(((c.r & 0xF8u) >> 3) | ((c.g & 0xF8u) << 2) | ((c.b & 0xF8u) << 7) | ((c.a & 0x80u) << 8)) * exp2(-32.0f);
+    return float(((c.r & 0xF8u) >> 3) | ((c.g & 0xF8u) << 2) | ((c.b & 0xF8u) << 7) | ((c.a & 0x80u) << 8)) * exp2(-32.0f);
 #else
-	return float(((c.r & 0xF8u) >> 3) | ((c.g & 0xF8u) << 2) | ((c.b & 0xF8u) << 7) | ((c.a & 0x80u) << 8)) * exp2(-24.0f);
+    return float(((c.r & 0xF8u) >> 3) | ((c.g & 0xF8u) << 2) | ((c.b & 0xF8u) << 7) | ((c.a & 0x80u) << 8)) * exp2(-24.0f);
 #endif
 }

 #ifdef ps_convert_rgba8_float32
 void ps_convert_rgba8_float32()
 {
-	// Convert an RGBA texture into a float depth texture
-	gl_FragDepth = rgba8_to_depth32(sample_c());
+    // Convert an RGBA texture into a float depth texture
+    gl_FragDepth = rgba8_to_depth32(sample_c());
 }
 #endif

 #ifdef ps_convert_rgba8_float24
 void ps_convert_rgba8_float24()
 {
-	// Same as above but without the alpha channel (24 bits Z)
+    // Same as above but without the alpha channel (24 bits Z)

-	// Convert an RGBA texture into a float depth texture
-	gl_FragDepth = rgba8_to_depth24(sample_c());
+    // Convert an RGBA texture into a float depth texture
+    gl_FragDepth = rgba8_to_depth24(sample_c());
 }
 #endif

 #ifdef ps_convert_rgba8_float16
 void ps_convert_rgba8_float16()
 {
-	// Same as above but without the A/B channels (16 bits Z)
+    // Same as above but without the A/B channels (16 bits Z)

-	// Convert an RGBA texture into a float depth texture
-	gl_FragDepth = rgba8_to_depth16(sample_c());
+    // Convert an RGBA texture into a float depth texture
+    gl_FragDepth = rgba8_to_depth16(sample_c());
 }
 #endif

 #ifdef ps_convert_rgb5a1_float16
 void ps_convert_rgb5a1_float16()
 {
-	// Convert an RGB5A1 (saved as RGBA8) color to a 16 bit Z
-	gl_FragDepth = rgb5a1_to_depth16(sample_c());
+    // Convert an RGB5A1 (saved as RGBA8) color to a 16 bit Z
+    gl_FragDepth = rgb5a1_to_depth16(sample_c());
 }
 #endif

 #define SAMPLE_RGBA_DEPTH_BILN(CONVERT_FN) \
-	ivec2 dims = textureSize(TextureSampler, 0); \
-	vec2 top_left_f = PSin_t * vec2(dims) - 0.5f; \
-	ivec2 top_left = ivec2(floor(top_left_f)); \
-	ivec4 coords = clamp(ivec4(top_left, top_left + 1), ivec4(0), dims.xyxy - 1); \
-	vec2 mix_vals = fract(top_left_f); \
-	float depthTL = CONVERT_FN(texelFetch(TextureSampler, coords.xy, 0)); \
-	float depthTR = CONVERT_FN(texelFetch(TextureSampler, coords.zy, 0)); \
-	float depthBL = CONVERT_FN(texelFetch(TextureSampler, coords.xw, 0)); \
-	float depthBR = CONVERT_FN(texelFetch(TextureSampler, coords.zw, 0)); \
-	gl_FragDepth = mix(mix(depthTL, depthTR, mix_vals.x), mix(depthBL, depthBR, mix_vals.x), mix_vals.y);
+    ivec2 dims = textureSize(TextureSampler, 0); \
+    vec2 top_left_f = PSin_t * vec2(dims) - 0.5f; \
+    ivec2 top_left = ivec2(floor(top_left_f)); \
+    ivec4 coords = clamp(ivec4(top_left, top_left + 1), ivec4(0), dims.xyxy - 1); \
+    vec2 mix_vals = fract(top_left_f); \
+    float depthTL = CONVERT_FN(texelFetch(TextureSampler, coords.xy, 0)); \
+    float depthTR = CONVERT_FN(texelFetch(TextureSampler, coords.zy, 0)); \
+    float depthBL = CONVERT_FN(texelFetch(TextureSampler, coords.xw, 0)); \
+    float depthBR = CONVERT_FN(texelFetch(TextureSampler, coords.zw, 0)); \
+    gl_FragDepth = mix(mix(depthTL, depthTR, mix_vals.x), mix(depthBL, depthBR, mix_vals.x), mix_vals.y);

 #ifdef ps_convert_rgba8_float32_biln
 void ps_convert_rgba8_float32_biln()
 {
-	// Convert an RGBA texture into a float depth texture
-	SAMPLE_RGBA_DEPTH_BILN(rgba8_to_depth32);
+    // Convert an RGBA texture into a float depth texture
+    SAMPLE_RGBA_DEPTH_BILN(rgba8_to_depth32);
 }
 #endif

 #ifdef ps_convert_rgba8_float24_biln
 void ps_convert_rgba8_float24_biln()
 {
-	// Same as above but without the alpha channel (24 bits Z)
+    // Same as above but without the alpha channel (24 bits Z)

-	// Convert an RGBA texture into a float depth texture
-	SAMPLE_RGBA_DEPTH_BILN(rgba8_to_depth24);
+    // Convert an RGBA texture into a float depth texture
+    SAMPLE_RGBA_DEPTH_BILN(rgba8_to_depth24);
 }
 #endif

 #ifdef ps_convert_rgba8_float16_biln
 void ps_convert_rgba8_float16_biln()
 {
-	// Same as above but without the A/B channels (16 bits Z)
+    // Same as above but without the A/B channels (16 bits Z)

-	// Convert an RGBA texture into a float depth texture
-	SAMPLE_RGBA_DEPTH_BILN(rgba8_to_depth16);
+    // Convert an RGBA texture into a float depth texture
+    SAMPLE_RGBA_DEPTH_BILN(rgba8_to_depth16);
 }
 #endif

 #ifdef ps_convert_rgb5a1_float16_biln
 void ps_convert_rgb5a1_float16_biln()
 {
-	// Convert an RGB5A1 (saved as RGBA8) color to a 16 bit Z
-	SAMPLE_RGBA_DEPTH_BILN(rgb5a1_to_depth16);
+    // Convert an RGB5A1 (saved as RGBA8) color to a 16 bit Z
+    SAMPLE_RGBA_DEPTH_BILN(rgb5a1_to_depth16);
 }
 #endif

 #ifdef ps_convert_rgba_8i
-uniform uint SBW;
-uniform uint DBW;
-uniform float ScaleFactor;
-
 void ps_convert_rgba_8i()
 {
-	// Convert a RGBA texture into a 8 bits packed texture
-	// Input column: 8x2 RGBA pixels
-	// 0: 8 RGBA
-	// 1: 8 RGBA
-	// Output column: 16x4 Index pixels
-	// 0: 8 R | 8 B
-	// 1: 8 R | 8 B
-	// 2: 8 G | 8 A
-	// 3: 8 G | 8 A
-	uvec2 pos = uvec2(gl_FragCoord.xy);
+    // Convert a RGBA texture into a 8 bits packed texture
+    // Input column: 8x2 RGBA pixels
+    // 0: 8 RGBA
+    // 1: 8 RGBA
+    // Output column: 16x4 Index pixels
+    // 0: 8 R | 8 B
+    // 1: 8 R | 8 B
+    // 2: 8 G | 8 A
+    // 3: 8 G | 8 A
+    uvec2 pos = uvec2(gl_FragCoord.xy);

-	// Collapse separate R G B A areas into their base pixel
-	uvec2 block = (pos & ~uvec2(15u, 3u)) >> 1;
-	uvec2 subblock = pos & uvec2(7u, 1u);
-	uvec2 coord = block | subblock;
+    // Collapse separate R G B A areas into their base pixel
+    uvec2 block = (pos & ~uvec2(15u, 3u)) >> 1;
+    uvec2 subblock = pos & uvec2(7u, 1u);
+    uvec2 coord = block | subblock;

-	// Compensate for potentially differing page pitch.
-	uvec2 block_xy = coord / uvec2(64u, 32u);
-	uint block_num = (block_xy.y * (DBW / 128u)) + block_xy.x;
-	uvec2 block_offset = uvec2((block_num % (SBW / 64u)) * 64u, (block_num / (SBW / 64u)) * 32u);
-	coord = (coord % uvec2(64u, 32u)) + block_offset;
+    // Apply offset to cols 1 and 2
+    uint is_col23 = pos.y & 4u;
+    uint is_col13 = pos.y & 2u;
+    uint is_col12 = is_col23 ^ (is_col13 << 1);
+    coord.x ^= is_col12; // If cols 1 or 2, flip bit 3 of x

-	// Apply offset to cols 1 and 2
-	uint is_col23 = pos.y & 4u;
-	uint is_col13 = pos.y & 2u;
-	uint is_col12 = is_col23 ^ (is_col13 << 1);
-	coord.x ^= is_col12; // If cols 1 or 2, flip bit 3 of x
+    if (floor(PS_SCALE_FACTOR) != PS_SCALE_FACTOR)
+        coord = uvec2(vec2(coord) * PS_SCALE_FACTOR);
+    else
+        coord *= uvec2(PS_SCALE_FACTOR);

-	if (floor(ScaleFactor) != ScaleFactor)
-		coord = uvec2(vec2(coord) * ScaleFactor);
-	else
-		coord *= uvec2(ScaleFactor);
-
-	vec4 pixel = texelFetch(TextureSampler, ivec2(coord), 0);
-	vec2  sel0 = (pos.y & 2u) == 0u ? pixel.rb : pixel.ga;
-	float sel1 = (pos.x & 8u) == 0u ? sel0.x : sel0.y;
-	SV_Target0 = vec4(sel1);
+    vec4 pixel = texelFetch(TextureSampler, ivec2(coord), 0);
+    vec2  sel0 = (pos.y & 2u) == 0u ? pixel.rb : pixel.ga;
+    float sel1 = (pos.x & 8u) == 0u ? sel0.x : sel0.y;
+    SV_Target0 = vec4(sel1);
 }
 #endif

 #ifdef ps_filter_transparency
 void ps_filter_transparency()
 {
-	vec4 c = sample_c();
-	SV_Target0 = vec4(c.rgb, 1.0);
+    vec4 c = sample_c();
+    SV_Target0 = vec4(c.rgb, 1.0);
 }
 #endif

@@ -295,8 +283,8 @@ void ps_filter_transparency()
 #ifdef ps_datm1
 void ps_datm1()
 {
-	if(sample_c().a < (127.5f / 255.0f)) // >= 0x80 pass
-		discard;
+    if(sample_c().a < (127.5f / 255.0f)) // >= 0x80 pass
+        discard;
 }
 #endif

@@ -305,30 +293,30 @@ void ps_datm1()
 #ifdef ps_datm0
 void ps_datm0()
 {
-	if((127.5f / 255.0f) < sample_c().a) // < 0x80 pass (== 0x80 should not pass)
-		discard;
+    if((127.5f / 255.0f) < sample_c().a) // < 0x80 pass (== 0x80 should not pass)
+        discard;
 }
 #endif

 #ifdef ps_hdr_init
 void ps_hdr_init()
 {
-	vec4 value = sample_c();
-	SV_Target0 = vec4(round(value.rgb * 255.0f) / 65535.0f, value.a);
+    vec4 value = sample_c();
+    SV_Target0 = vec4(round(value.rgb * 255.0f) / 65535.0f, value.a);
 }
 #endif

 #ifdef ps_hdr_resolve
 void ps_hdr_resolve()
 {
-	vec4 value = sample_c();
-	SV_Target0 = vec4(vec3(uvec3(value.rgb * 65535.0f) & 255u) / 255.0f, value.a);
+    vec4 value = sample_c();
+    SV_Target0 = vec4(vec3(uvec3(value.rgb * 65535.0f) & 255u) / 255.0f, value.a);
 }
 #endif

 #ifdef ps_convert_clut_4
 uniform uvec3 offset;
-uniform float scale;
+uniform vec2 scale;

 void ps_convert_clut_4()
 {
@@ -336,14 +324,14 @@ void ps_convert_clut_4()
 	uint index = uint(gl_FragCoord.x) + offset.z;
 	uvec2 pos = uvec2(index % 8u, index / 8u);

-	ivec2 final = ivec2(floor(vec2(offset.xy + pos) * vec2(scale)));
+	ivec2 final = ivec2(floor(vec2(offset.xy + pos) * scale));
 	SV_Target0 = texelFetch(TextureSampler, final, 0);
 }
 #endif

 #ifdef ps_convert_clut_8
 uniform uvec3 offset;
-uniform float scale;
+uniform vec2 scale;

 void ps_convert_clut_8()
 {
@@ -356,7 +344,7 @@ void ps_convert_clut_8()
 	pos.x = (index % 8u) + ((subgroup >= 2u) ? 8u : 0u);
 	pos.y = ((index / 32u) * 2u) + (subgroup % 2u);

-	ivec2 final = ivec2(floor(vec2(offset.xy + pos) * vec2(scale)));
+	ivec2 final = ivec2(floor(vec2(offset.xy + pos) * scale));
 	SV_Target0 = texelFetch(TextureSampler, final, 0);
 }
 #endif
@@ -366,51 +354,51 @@ uniform ivec2 EMOD;

 void ps_yuv()
 {
-	vec4 i = sample_c();
-	vec4 o;
+    vec4 i = sample_c();
+    vec4 o;

-	mat3 rgb2yuv; // Value from GS manual
-	rgb2yuv[0] = vec3(0.587, -0.311, -0.419);
-	rgb2yuv[1] = vec3(0.114, 0.500, -0.081);
-	rgb2yuv[2] = vec3(0.299, -0.169, 0.500);
+    mat3 rgb2yuv; // Value from GS manual
+    rgb2yuv[0] = vec3(0.587, -0.311, -0.419);
+    rgb2yuv[1] = vec3(0.114, 0.500, -0.081);
+    rgb2yuv[2] = vec3(0.299, -0.169, 0.500);

-	vec3 yuv = rgb2yuv * i.gbr;
+    vec3 yuv = rgb2yuv * i.gbr;

-	float Y = float(0xDB)/255.0f * yuv.x + float(0x10)/255.0f;
-	float Cr = float(0xE0)/255.0f * yuv.y + float(0x80)/255.0f;
-	float Cb = float(0xE0)/255.0f * yuv.z + float(0x80)/255.0f;
+    float Y = float(0xDB)/255.0f * yuv.x + float(0x10)/255.0f;
+    float Cr = float(0xE0)/255.0f * yuv.y + float(0x80)/255.0f;
+    float Cb = float(0xE0)/255.0f * yuv.z + float(0x80)/255.0f;

-	switch(EMOD.x) {
-		case 0:
-			o.a = i.a;
-			break;
-		case 1:
-			o.a = Y;
-			break;
-		case 2:
-			o.a = Y/2.0f;
-			break;
-		case 3:
-			o.a = 0.0f;
-			break;
-	}
+    switch(EMOD.x) {
+        case 0:
+            o.a = i.a;
+            break;
+        case 1:
+            o.a = Y;
+            break;
+        case 2:
+            o.a = Y/2.0f;
+            break;
+        case 3:
+            o.a = 0.0f;
+            break;
+    }

-	switch(EMOD.y) {
-		case 0:
-			o.rgb = i.rgb;
-			break;
-		case 1:
-			o.rgb = vec3(Y);
-			break;
-		case 2:
-			o.rgb = vec3(Y, Cb, Cr);
-			break;
-		case 3:
-			o.rgb = vec3(i.a);
-			break;
-	}
+    switch(EMOD.y) {
+        case 0:
+            o.rgb = i.rgb;
+            break;
+        case 1:
+            o.rgb = vec3(Y);
+            break;
+        case 2:
+            o.rgb = vec3(Y, Cb, Cr);
+            break;
+        case 3:
+            o.rgb = vec3(i.a);
+            break;
+    }

-	SV_Target0 = o;
+    SV_Target0 = o;
 }
 #endif

@@ -418,16 +406,16 @@ void ps_yuv()

 void main()
 {
-	SV_Target0 = vec4(0x7FFFFFFF);
+    SV_Target0 = vec4(0x7FFFFFFF);

-	#ifdef ps_stencil_image_init_0
-		if((127.5f / 255.0f) < sample_c().a) // < 0x80 pass (== 0x80 should not pass)
-			SV_Target0 = vec4(-1);
-	#endif
-	#ifdef ps_stencil_image_init_1
-		if(sample_c().a < (127.5f / 255.0f)) // >= 0x80 pass
-			SV_Target0 = vec4(-1);
-	#endif
+    #ifdef ps_stencil_image_init_0
+        if((127.5f / 255.0f) < sample_c().a) // < 0x80 pass (== 0x80 should not pass)
+            SV_Target0 = vec4(-1);
+    #endif
+    #ifdef ps_stencil_image_init_1
+        if(sample_c().a < (127.5f / 255.0f)) // >= 0x80 pass
+            SV_Target0 = vec4(-1);
+    #endif
 }
 #endif

--- a/bin/resources/shaders/opengl/imgui.glsl
+++ b/bin/resources/shaders/opengl/imgui.glsl
@@ -1,35 +0,0 @@
-#ifdef VERTEX_SHADER
-
-layout(location = 0) in vec2 Position;
-layout(location = 1) in vec2 UV;
-layout(location = 2) in vec4 Color;
-
-uniform mat4 ProjMtx;
-
-out vec2 Frag_UV;
-out vec4 Frag_Color;
-
-void vs_main()
-{
-	Frag_UV = UV;
-	Frag_Color = Color;
-	gl_Position = ProjMtx * vec4(Position.xy, 0.0, 1.0);
-}
-
-#endif
-
-#ifdef FRAGMENT_SHADER
-
-layout(binding = 0) uniform sampler2D Texture;
-
-in vec2 Frag_UV;
-in vec4 Frag_Color;
-
-layout(location = 0) out vec4 Out_Color;
-
-void ps_main()
-{
-	Out_Color = Frag_Color * texture(Texture, Frag_UV.st);
-}
-
-#endif
--- a/bin/resources/shaders/opengl/interlace.glsl
+++ b/bin/resources/shaders/opengl/interlace.glsl
@@ -8,8 +8,6 @@ in vec4 PSin_c;

 uniform vec4 ZrH;

-layout(binding = 0) uniform sampler2D TextureSampler;
-
 layout(location = 0) out vec4 SV_Target0;


@@ -21,7 +19,7 @@ void ps_main0()
 	int vpos  = int(gl_FragCoord.y); // vertical position of destination texture

 	if ((vpos & 1) == field)
-		SV_Target0 = textureLod(TextureSampler, PSin_t, 0);
+		SV_Target0 = texture(TextureSampler, PSin_t);
 	else
 		discard;
 }
@@ -30,7 +28,7 @@ void ps_main0()
 // Bob shader
 void ps_main1()
 {
-	SV_Target0 = textureLod(TextureSampler, PSin_t, 0);
+	SV_Target0 = texture(TextureSampler, PSin_t);
 }


@@ -38,9 +36,9 @@ void ps_main1()
 void ps_main2()
 {
 	vec2 vstep = vec2(0.0f, ZrH.y);
-	vec4 c0 = textureLod(TextureSampler, PSin_t - vstep, 0);
-	vec4 c1 = textureLod(TextureSampler, PSin_t, 0);
-	vec4 c2 = textureLod(TextureSampler, PSin_t + vstep, 0);
+	vec4 c0 = texture(TextureSampler, PSin_t - vstep);
+	vec4 c1 = texture(TextureSampler, PSin_t);
+	vec4 c2 = texture(TextureSampler, PSin_t + vstep);

 	SV_Target0 = (c0 + c1 * 2.0f + c2) / 4.0f;
 }
@@ -62,11 +60,15 @@ void ps_main3()
 	int  vres   = int(ZrH.z) >> 1;                           // vertical resolution of source texture
 	int  lofs   = ((((vres + 1) >> 1) << 1) - vres) & bank;  // line alignment offset for bank 1
 	int  vpos   = int(gl_FragCoord.y) + lofs;                // vertical position of destination texture
+	vec2 bofs   = vec2(0.0f, 0.5f * float(bank));            // vertical offset of the current bank relative to source texture size
+	vec2 vscale = vec2(1.0f, 2.0f);                          // scaling factor from source to destination texture
+	vec2 optr   = PSin_t - bofs;                             // used to check if the current destination line is within the current bank
+	vec2 iptr   = optr * vscale;                             // pointer to the current pixel in the source texture

 	// if the index of current destination line belongs to the current fiels we update it, otherwise
 	// we leave the old line in the destination buffer
-	if ((vpos & 1) == field)
-		SV_Target0 = textureLod(TextureSampler, PSin_t, 0);
+	if ((optr.y >= 0.0f) && (optr.y < 0.5f) && ((vpos & 1) == field))
+		SV_Target0 = texture(TextureSampler, iptr);
 	else
 		discard;
 }
@@ -124,13 +126,13 @@ void ps_main4()
 	// calculating motion, only relevant for missing lines where the "center line" is pointed
 	// by p_t1

-	vec4 hn = textureLod(TextureSampler, p_t0 - lofs, 0); // new high pixel
-	vec4 cn = textureLod(TextureSampler, p_t1, 0);        // new center pixel
-	vec4 ln = textureLod(TextureSampler, p_t0 + lofs, 0); // new low pixel
+	vec4 hn = texture(TextureSampler, p_t0 - lofs); // new high pixel
+	vec4 cn = texture(TextureSampler, p_t1);        // new center pixel
+	vec4 ln = texture(TextureSampler, p_t0 + lofs); // new low pixel

-	vec4 ho = textureLod(TextureSampler, p_t2 - lofs, 0); // old high pixel
-	vec4 co = textureLod(TextureSampler, p_t3, 0);        // old center pixel
-	vec4 lo = textureLod(TextureSampler, p_t2 + lofs, 0); // old low pixel
+	vec4 ho = texture(TextureSampler, p_t2 - lofs); // old high pixel
+	vec4 co = texture(TextureSampler, p_t3);        // old center pixel
+	vec4 lo = texture(TextureSampler, p_t2 + lofs); // old low pixel

 	vec3 mh = hn.rgb - ho.rgb; // high pixel motion
 	vec3 mc = cn.rgb - co.rgb; // center pixel motion
@@ -156,7 +158,7 @@ void ps_main4()
 	if ((vpos & 1) == field)
 	{
 		// output coordinate present on current field
-		SV_Target0 = textureLod(TextureSampler, p_t0, 0);
+		SV_Target0 = texture(TextureSampler, p_t0);
 	}
 	else if ((iptr.y > 0.5f - lofs.y) || (iptr.y < 0.0 + lofs.y))
 	{
--- a/bin/resources/shaders/opengl/merge.glsl
+++ b/bin/resources/shaders/opengl/merge.glsl
@@ -8,23 +8,21 @@ in vec4 PSin_c;

 uniform vec4 BGColor;

-layout(binding = 0) uniform sampler2D TextureSampler;
-
 layout(location = 0) out vec4 SV_Target0;

 void ps_main0()
 {
-	vec4 c = texture(TextureSampler, PSin_t);
-	// Note: clamping will be done by fixed unit
-	c.a *= 2.0f;
-	SV_Target0 = c;
+    vec4 c = texture(TextureSampler, PSin_t);
+    // Note: clamping will be done by fixed unit
+    c.a *= 2.0f;
+    SV_Target0 = c;
 }

 void ps_main1()
 {
-	vec4 c = texture(TextureSampler, PSin_t);
-	c.a = BGColor.a;
-	SV_Target0 = c;
+    vec4 c = texture(TextureSampler, PSin_t);
+    c.a = BGColor.a;
+    SV_Target0 = c;
 }

 #endif
--- a/bin/resources/shaders/opengl/present.glsl
+++ b/bin/resources/shaders/opengl/present.glsl
@@ -46,8 +46,6 @@ in vec4 PSin_p;
 in vec2 PSin_t;
 in vec4 PSin_c;

-layout(binding = 0) uniform sampler2D TextureSampler;
-
 layout(location = 0) out vec4 SV_Target0;

 vec4 sample_c()
@@ -119,10 +117,10 @@ void ps_filter_triangular() // triangular
 #ifdef ps_filter_complex
 void ps_filter_complex()
 {
-	const float PI = 3.14159265359f;
-	vec2 texdim = vec2(textureSize(TextureSampler, 0));
-	float factor = (0.9f - 0.4f * cos(2.0f * PI * PSin_t.y * texdim.y));
-	vec4 c = factor * texture(TextureSampler, vec2(PSin_t.x, (floor(PSin_t.y * texdim.y) + 0.5f) / texdim.y));
+    const float PI = 3.14159265359f;
+    vec2 texdim = vec2(textureSize(TextureSampler, 0));
+    float factor = (0.9f - 0.4f * cos(2.0f * PI * PSin_t.y * texdim.y));
+    vec4 c =  factor * texture(TextureSampler, vec2(PSin_t.x, (floor(PSin_t.y * texdim.y) + 0.5f) / texdim.y));

 	SV_Target0 = c;
 }
--- a/bin/resources/shaders/opengl/shadeboost.glsl
+++ b/bin/resources/shaders/opengl/shadeboost.glsl
@@ -17,40 +17,38 @@ in vec4 PSin_p;
 in vec2 PSin_t;
 in vec4 PSin_c;

-layout(binding = 0) uniform sampler2D TextureSampler;
-
 layout(location = 0) out vec4 SV_Target0;

 // For all settings: 1.0 = 100% 0.5=50% 1.5 = 150%
 vec4 ContrastSaturationBrightness(vec4 color)
 {
-	float brt = params.x;
-	float con = params.y;
-	float sat = params.z;
+    float brt = params.x;
+    float con = params.y;
+    float sat = params.z;

-	// Increase or decrease these values to adjust r, g and b color channels separately
-	const float AvgLumR = 0.5;
-	const float AvgLumG = 0.5;
-	const float AvgLumB = 0.5;
+    // Increase or decrease these values to adjust r, g and b color channels separately
+    const float AvgLumR = 0.5;
+    const float AvgLumG = 0.5;
+    const float AvgLumB = 0.5;

-	const vec3 LumCoeff = vec3(0.2125, 0.7154, 0.0721);
+    const vec3 LumCoeff = vec3(0.2125, 0.7154, 0.0721);

-	vec3 AvgLumin = vec3(AvgLumR, AvgLumG, AvgLumB);
-	vec3 brtColor = color.rgb * brt;
-	float dot_intensity = dot(brtColor, LumCoeff);
-	vec3 intensity = vec3(dot_intensity, dot_intensity, dot_intensity);
-	vec3 satColor = mix(intensity, brtColor, sat);
-	vec3 conColor = mix(AvgLumin, satColor, con);
+    vec3 AvgLumin = vec3(AvgLumR, AvgLumG, AvgLumB);
+    vec3 brtColor = color.rgb * brt;
+    float dot_intensity = dot(brtColor, LumCoeff);
+    vec3 intensity = vec3(dot_intensity, dot_intensity, dot_intensity);
+    vec3 satColor = mix(intensity, brtColor, sat);
+    vec3 conColor = mix(AvgLumin, satColor, con);

-	color.rgb = conColor;
-	return color;
+    color.rgb = conColor;
+    return color;
 }


 void ps_main()
 {
-	vec4 c = texture(TextureSampler, PSin_t);
-	SV_Target0 = ContrastSaturationBrightness(c);
+    vec4 c = texture(TextureSampler, PSin_t);
+    SV_Target0 = ContrastSaturationBrightness(c);
 }


--- a/bin/resources/shaders/opengl/tfx_fs.glsl
+++ b/bin/resources/shaders/opengl/tfx_fs.glsl
--- a/bin/resources/shaders/opengl/tfx_vgs.glsl
+++ b/bin/resources/shaders/opengl/tfx_vgs.glsl
@@ -1,35 +1,6 @@
 //#version 420 // Keep it for text editor detection

-layout(std140, binding = 1) uniform cb20
-{
-	vec2  VertexScale;
-	vec2  VertexOffset;
-
-	vec2  TextureScale;
-	vec2  TextureOffset;
-
-	vec2  PointSize;
-	uint  MaxDepth;
-	uint  pad_cb20;
-};
-
 #ifdef VERTEX_SHADER
-
-out SHADER
-{
-	vec4 t_float;
-	vec4 t_int;
-	#if VS_IIP != 0
-		vec4 c;
-	#else
-		flat vec4 c;
-	#endif
-} VSout;
-
-const float exp_min32 = exp2(-32.0f);
-
-#if VS_EXPAND == 0
-
 layout(location = 0) in vec2  i_st;
 layout(location = 2) in vec4  i_c;
 layout(location = 3) in float i_q;
@@ -38,202 +9,241 @@ layout(location = 5) in uint  i_z;
 layout(location = 6) in uvec2 i_uv;
 layout(location = 7) in vec4  i_f;

+#if !defined(BROKEN_DRIVER) && (pGL_ES || defined(GL_ARB_enhanced_layouts) && GL_ARB_enhanced_layouts)
+layout(location = 0)
+#endif
+out SHADER
+{
+    vec4 t_float;
+    vec4 t_int;
+    #if VS_IIP != 0
+      vec4 c;
+    #else
+      flat vec4 c;
+    #endif
+} VSout;
+
+const float exp_min32 = exp2(-32.0f);
+
 void texture_coord()
 {
-	vec2 uv = vec2(i_uv) - TextureOffset;
-	vec2 st = i_st - TextureOffset;
+    vec2 uv = vec2(i_uv) - TextureOffset;
+    vec2 st = i_st - TextureOffset;

-	// Float coordinate
-	VSout.t_float.xy = st;
-	VSout.t_float.w  = i_q;
+    // Float coordinate
+    VSout.t_float.xy = st;
+    VSout.t_float.w  = i_q;

-	// Integer coordinate => normalized
-	VSout.t_int.xy = uv * TextureScale;
-#if VS_FST
-	// Integer coordinate => integral
-	VSout.t_int.zw = uv;
+    // Integer coordinate => normalized
+    VSout.t_int.xy = uv * TextureScale;
+#if VS_INT_FST == 1
+    // Some games uses float coordinate for post-processing effect
+    VSout.t_int.zw = st / TextureScale;
 #else
-	// Some games uses float coordinate for post-processing effect
-	VSout.t_int.zw = st / TextureScale;
+    // Integer coordinate => integral
+    VSout.t_int.zw = uv;
 #endif
 }

 void vs_main()
 {
-	// Clamp to max depth, gs doesn't wrap
-	highp uint z = min(i_z, MaxDepth);
+    // Clamp to max depth, gs doesn't wrap
+    highp uint z = min(i_z, MaxDepth);

-	// pos -= 0.05 (1/320 pixel) helps avoiding rounding problems (integral part of pos is usually 5 digits, 0.05 is about as low as we can go)
-	// example: ceil(afterseveralvertextransformations(y = 133)) => 134 => line 133 stays empty
-	// input granularity is 1/16 pixel, anything smaller than that won't step drawing up/left by one pixel
-	// example: 133.0625 (133 + 1/16) should start from line 134, ceil(133.0625 - 0.05) still above 133
-	vec4 p;
+    // pos -= 0.05 (1/320 pixel) helps avoiding rounding problems (integral part of pos is usually 5 digits, 0.05 is about as low as we can go)
+    // example: ceil(afterseveralvertextransformations(y = 133)) => 134 => line 133 stays empty
+    // input granularity is 1/16 pixel, anything smaller than that won't step drawing up/left by one pixel
+    // example: 133.0625 (133 + 1/16) should start from line 134, ceil(133.0625 - 0.05) still above 133
+    vec4 p;

-	p.xy = vec2(i_p) - vec2(0.05f, 0.05f);
-	p.xy = p.xy * VertexScale - VertexOffset;
-	p.w = 1.0f;
+    p.xy = vec2(i_p) - vec2(0.05f, 0.05f);
+    p.xy = p.xy * VertexScale - VertexOffset;
+    p.w = 1.0f;

 #if HAS_CLIP_CONTROL
-	p.z = float(z) * exp_min32;
+    p.z = float(z) * exp_min32;
 #else
-	// GLES doesn't support ARB_clip_control, so remap it to -1..1. We also reduce the range from 32 bits
-	// to 24 bits, which means some games with very large depth ranges will not render correctly. But,
-	// for most, it's okay, and really, the best we can do.
-	p.z = min(float(z) * exp2(-23.0f), 2.0f) - 1.0f;
+    // GLES doesn't support ARB_clip_control, so remap it to -1..1. We also reduce the range from 32 bits
+    // to 24 bits, which means some games with very large depth ranges will not render correctly. But,
+    // for most, it's okay, and really, the best we can do.
+    p.z = min(float(z) * exp2(-23.0f), 2.0f) - 1.0f;
 #endif

-	gl_Position = p;
+    gl_Position = p;

-	texture_coord();
+    texture_coord();

-	VSout.c = i_c;
-	VSout.t_float.z = i_f.x; // pack for with texture
+    VSout.c = i_c;
+    VSout.t_float.z = i_f.x; // pack for with texture

-	#if VS_POINT_SIZE
-		gl_PointSize = PointSize.x;
-	#endif
+    #if VS_POINT_SIZE
+        gl_PointSize = float(VS_POINT_SIZE_VALUE);
+    #endif
 }

-#else // VS_EXPAND
-
-struct RawVertex
-{
-	vec2 ST;
-	uint RGBA;
-	float Q;
-	uint XY;
-	uint Z;
-	uint UV;
-	uint FOG;
-};
-
-layout(std140, binding = 2) readonly buffer VertexBuffer {
-	RawVertex vertex_buffer[];
-};
-
-struct ProcessedVertex
-{
-	vec4 p;
-	vec4 t_float;
-	vec4 t_int;
-	vec4 c;
-};
-
-ProcessedVertex load_vertex(uint index)
-{
-#if defined(GL_ARB_shader_draw_parameters) && GL_ARB_shader_draw_parameters
-	RawVertex rvtx = vertex_buffer[index + gl_BaseVertexARB];
-#else
-	RawVertex rvtx = vertex_buffer[index];
 #endif

-	vec2 i_st = rvtx.ST;
-	vec4 i_c = vec4(uvec4(bitfieldExtract(rvtx.RGBA, 0, 8), bitfieldExtract(rvtx.RGBA, 8, 8),
-	                      bitfieldExtract(rvtx.RGBA, 16, 8), bitfieldExtract(rvtx.RGBA, 24, 8)));
-	float i_q = rvtx.Q;
-	uvec2 i_p = uvec2(bitfieldExtract(rvtx.XY, 0, 16), bitfieldExtract(rvtx.XY, 16, 16));
-	uint i_z = rvtx.Z;
-	uvec2 i_uv = uvec2(bitfieldExtract(rvtx.UV, 0, 16), bitfieldExtract(rvtx.UV, 16, 16));
-	vec4 i_f = unpackUnorm4x8(rvtx.FOG);
+#ifdef GEOMETRY_SHADER

-	ProcessedVertex vtx;
-
-	uint z = min(i_z, MaxDepth);
-	vtx.p.xy = vec2(i_p) - vec2(0.05f, 0.05f);
-	vtx.p.xy = vtx.p.xy * VertexScale - VertexOffset;
-	vtx.p.w = 1.0f;
-
-#if HAS_CLIP_CONTROL
-	vtx.p.z = float(z) * exp_min32;
-#else
-	vtx.p.z = min(float(z) * exp2(-23.0f), 2.0f) - 1.0f;
+#if !defined(BROKEN_DRIVER) && (pGL_ES || defined(GL_ARB_enhanced_layouts) && GL_ARB_enhanced_layouts)
+layout(location = 0)
 #endif
+in SHADER
+{
+    vec4 t_float;
+    vec4 t_int;
+    #if GS_IIP != 0
+      vec4 c;
+    #else
+      flat vec4 c;
+    #endif
+} GSin[];

-	vec2 uv = vec2(i_uv) - TextureOffset;
-	vec2 st = i_st - TextureOffset;
-
-	vtx.t_float.xy = st;
-	vtx.t_float.w  = i_q;
-
-	vtx.t_int.xy = uv * TextureScale;
-#if VS_FST
-	vtx.t_int.zw = uv;
-#else
-	vtx.t_int.zw = st / TextureScale;
+#if !defined(BROKEN_DRIVER) && (pGL_ES || defined(GL_ARB_enhanced_layouts) && GL_ARB_enhanced_layouts)
+layout(location = 0)
 #endif
+out SHADER
+{
+    vec4 t_float;
+    vec4 t_int;
+    #if GS_IIP != 0
+      vec4 c;
+    #else
+      flat vec4 c;
+    #endif
+} GSout;

-	vtx.c = i_c;
-	vtx.t_float.z = i_f.x;
+struct vertex
+{
+    vec4 t_float;
+    vec4 t_int;
+    vec4 c;
+};

-	return vtx;
+void out_vertex(in vec4 position, in vertex v)
+{
+    GSout.t_float  = v.t_float;
+    GSout.t_int    = v.t_int;
+    // Flat output
+#if GS_POINT == 1
+    GSout.c        = GSin[0].c;
+#else
+    GSout.c        = GSin[1].c;
+#endif
+    gl_Position = position;
+    gl_PrimitiveID = gl_PrimitiveIDIn;
+    EmitVertex();
 }

-void main()
-{
-	ProcessedVertex vtx;
-
-#if defined(GL_ARB_shader_draw_parameters) && GL_ARB_shader_draw_parameters
-	uint vid = uint(gl_VertexID - gl_BaseVertexARB);
+#if GS_POINT == 1
+layout(points) in;
 #else
-	uint vid = uint(gl_VertexID);
+layout(lines) in;
 #endif
+layout(triangle_strip, max_vertices = 4) out;

-#if VS_EXPAND == 1 // Point
+#if GS_POINT == 1

-	vtx = load_vertex(vid >> 2);
+void gs_main()
+{
+    // Transform a point to a NxN sprite
+    vertex point = vertex(GSin[0].t_float, GSin[0].t_int, GSin[0].c);

-	vtx.p.x += ((vid & 1u) != 0u) ? PointSize.x : 0.0f;
-	vtx.p.y += ((vid & 2u) != 0u) ? PointSize.y : 0.0f;
+    // Get new position
+    vec4 lt_p = gl_in[0].gl_Position;
+    vec4 rb_p = gl_in[0].gl_Position + vec4(PointSize.x, PointSize.y, 0.0f, 0.0f);
+    vec4 lb_p = rb_p;
+    vec4 rt_p = rb_p;
+    lb_p.x    = lt_p.x;
+    rt_p.y    = lt_p.y;

-#elif VS_EXPAND == 2 // Line
+    out_vertex(lt_p, point);

-	uint vid_base = vid >> 2;
-	bool is_bottom = (vid & 2u) != 0u;
-	bool is_right = (vid & 1u) != 0u;
-	uint vid_other = is_bottom ? vid_base - 1 : vid_base + 1;
-	vtx = load_vertex(vid_base);
-	ProcessedVertex other = load_vertex(vid_other);
+    out_vertex(lb_p, point);

-	vec2 line_vector = normalize(vtx.p.xy - other.p.xy);
-	vec2 line_normal = vec2(line_vector.y, -line_vector.x);
-	vec2 line_width = (line_normal * PointSize) / 2;
-	// line_normal is inverted for bottom point
-	vec2 offset = ((uint(is_bottom) ^ uint(is_right)) != 0u) ? line_width : -line_width;
-	vtx.p.xy += offset;
+    out_vertex(rt_p, point);

-	// Lines will be run as (0 1 2) (1 2 3)
-	// This means that both triangles will have a point based off the top line point as their first point
-	// So we don't have to do anything for !IIP
+    out_vertex(rb_p, point);

-#elif VS_EXPAND == 3 // Sprite
-
-	// Sprite points are always in pairs
-	uint vid_base = vid >> 1;
-	uint vid_lt = vid_base & ~1u;
-	uint vid_rb = vid_base | 1u;
-
-	ProcessedVertex lt = load_vertex(vid_lt);
-	ProcessedVertex rb = load_vertex(vid_rb);
-	vtx = rb;
-
-	bool is_right = ((vid & 1u) != 0u);
-	vtx.p.x = is_right ? lt.p.x : vtx.p.x;
-	vtx.t_float.x = is_right ? lt.t_float.x : vtx.t_float.x;
-	vtx.t_int.xz = is_right ? lt.t_int.xz : vtx.t_int.xz;
-
-	bool is_bottom = ((vid & 2u) != 0u);
-	vtx.p.y = is_bottom ? lt.p.y : vtx.p.y;
-	vtx.t_float.y = is_bottom ? lt.t_float.y : vtx.t_float.y;
-	vtx.t_int.yw = is_bottom ? lt.t_int.yw : vtx.t_int.yw;
-
-#endif
-
-	gl_Position = vtx.p;
-	VSout.t_float = vtx.t_float;
-	VSout.t_int = vtx.t_int;
-	VSout.c = vtx.c;
+    EndPrimitive();
 }

-#endif // VS_EXPAND
+#elif GS_LINE == 1

-#endif // VERTEX_SHADER
+void gs_main()
+{
+    // Transform a line to a thick line-sprite
+    vertex left  = vertex(GSin[0].t_float, GSin[0].t_int, GSin[0].c);
+    vertex right = vertex(GSin[1].t_float, GSin[1].t_int, GSin[1].c);
+    vec4 lt_p = gl_in[0].gl_Position;
+    vec4 rt_p = gl_in[1].gl_Position;
+
+    // Potentially there is faster math
+    vec2 line_vector = normalize(rt_p.xy - lt_p.xy);
+    vec2 line_normal = vec2(line_vector.y, -line_vector.x);
+    vec2 line_width  = (line_normal * PointSize) / 2.0f;
+
+    lt_p.xy -= line_width;
+    rt_p.xy -= line_width;
+    vec4 lb_p = gl_in[0].gl_Position + vec4(line_width, 0.0f, 0.0f);
+    vec4 rb_p = gl_in[1].gl_Position + vec4(line_width, 0.0f, 0.0f);
+
+    out_vertex(lt_p, left);
+
+    out_vertex(lb_p, left);
+
+    out_vertex(rt_p, right);
+
+    out_vertex(rb_p, right);
+
+    EndPrimitive();
+}
+
+#else
+
+void gs_main()
+{
+    // left top     => GSin[0];
+    // right bottom => GSin[1];
+    vertex rb = vertex(GSin[1].t_float, GSin[1].t_int, GSin[1].c);
+    vertex lt = vertex(GSin[0].t_float, GSin[0].t_int, GSin[0].c);
+
+    vec4 rb_p = gl_in[1].gl_Position;
+    vec4 lb_p = rb_p;
+    vec4 rt_p = rb_p;
+    vec4 lt_p = gl_in[0].gl_Position;
+
+    // flat depth
+    lt_p.z = rb_p.z;
+    // flat fog and texture perspective
+    lt.t_float.zw = rb.t_float.zw;
+    // flat color
+    lt.c = rb.c;
+
+    // Swap texture and position coordinate
+    vertex lb    = rb;
+    lb.t_float.x = lt.t_float.x;
+    lb.t_int.x   = lt.t_int.x;
+    lb.t_int.z   = lt.t_int.z;
+    lb_p.x       = lt_p.x;
+
+    vertex rt    = rb;
+    rt_p.y       = lt_p.y;
+    rt.t_float.y = lt.t_float.y;
+    rt.t_int.y   = lt.t_int.y;
+    rt.t_int.w   = lt.t_int.w;
+
+    out_vertex(lt_p, lt);
+
+    out_vertex(lb_p, lb);
+
+    out_vertex(rt_p, rt);
+
+    out_vertex(rb_p, rb);
+
+    EndPrimitive();
+}
+
+#endif
+
+#endif
--- a/bin/resources/shaders/vulkan/convert.glsl
+++ b/bin/resources/shaders/vulkan/convert.glsl
@@ -1,3 +1,7 @@
+#ifndef PS_SCALE_FACTOR
+#define PS_SCALE_FACTOR 1.0
+#endif
+
 #ifdef VERTEX_SHADER

 layout(location = 0) in vec4 a_pos;
@@ -19,17 +23,7 @@ layout(location = 0) in vec2 v_tex;

 #if defined(ps_convert_rgba8_16bits) || defined(ps_convert_float32_32bits)
 layout(location = 0) out uint o_col0;
-#elif !defined(ps_datm1) && \
-	!defined(ps_datm0) && \
-	!defined(ps_convert_rgba8_float32) && \
-	!defined(ps_convert_rgba8_float24) && \
-	!defined(ps_convert_rgba8_float16) && \
-	!defined(ps_convert_rgb5a1_float16) && \
-	!defined(ps_convert_rgba8_float32_biln) && \
-	!defined(ps_convert_rgba8_float24_biln) && \
-	!defined(ps_convert_rgba8_float16_biln) && \
-	!defined(ps_convert_rgb5a1_float16_biln) && \
-	!defined(ps_depth_copy)
+#else
 layout(location = 0) out vec4 o_col0;
 #endif

@@ -75,6 +69,8 @@ void ps_convert_rgba8_16bits()
 #ifdef ps_datm1
 void ps_datm1()
 {
+	o_col0 = vec4(0, 0, 0, 0);
+
 	if(sample_c(v_tex).a < (127.5f / 255.0f)) // >= 0x80 pass
 		discard;

@@ -84,6 +80,8 @@ void ps_datm1()
 #ifdef ps_datm0
 void ps_datm0()
 {
+	o_col0 = vec4(0, 0, 0, 0);
+
 	if((127.5f / 255.0f) < sample_c(v_tex).a) // < 0x80 pass (== 0x80 should not pass)
 		discard;
 }
@@ -240,15 +238,6 @@ void ps_convert_rgb5a1_float16_biln()
 #endif

 #ifdef ps_convert_rgba_8i
-layout(push_constant) uniform cb10
-{
-	uint SBW;
-	uint DBW;
-	uvec2 cb_pad1;
-	float ScaleFactor;
-	vec3 cb_pad2;
-};
-
 void ps_convert_rgba_8i()
 {
 	// Convert a RGBA texture into a 8 bits packed texture
@@ -260,45 +249,37 @@ void ps_convert_rgba_8i()
 	// 1: 8 R | 8 B
 	// 2: 8 G | 8 A
 	// 3: 8 G | 8 A
-	uvec2 pos = uvec2(gl_FragCoord.xy);
+  uvec2 pos = uvec2(gl_FragCoord.xy);

-	// Collapse separate R G B A areas into their base pixel
-	uvec2 block = (pos & ~uvec2(15u, 3u)) >> 1;
-	uvec2 subblock = pos & uvec2(7u, 1u);
-	uvec2 coord = block | subblock;
+  // Collapse separate R G B A areas into their base pixel
+  uvec2 block = (pos & ~uvec2(15u, 3u)) >> 1;
+  uvec2 subblock = pos & uvec2(7u, 1u);
+  uvec2 coord = block | subblock;

-	// Compensate for potentially differing page pitch.
-	uvec2 block_xy = coord / uvec2(64u, 32u);
-	uint block_num = (block_xy.y * (DBW / 128u)) + block_xy.x;
-	uvec2 block_offset = uvec2((block_num % (SBW / 64u)) * 64u, (block_num / (SBW / 64u)) * 32u);
-	coord = (coord % uvec2(64u, 32u)) + block_offset;
+  // Apply offset to cols 1 and 2
+  uint is_col23 = pos.y & 4u;
+  uint is_col13 = pos.y & 2u;
+  uint is_col12 = is_col23 ^ (is_col13 << 1);
+  coord.x ^= is_col12; // If cols 1 or 2, flip bit 3 of x

-	// Apply offset to cols 1 and 2
-	uint is_col23 = pos.y & 4u;
-	uint is_col13 = pos.y & 2u;
-	uint is_col12 = is_col23 ^ (is_col13 << 1);
-	coord.x ^= is_col12; // If cols 1 or 2, flip bit 3 of x
+  if (floor(PS_SCALE_FACTOR) != PS_SCALE_FACTOR)
+    coord = uvec2(vec2(coord) * PS_SCALE_FACTOR);
+  else
+    coord *= uvec2(PS_SCALE_FACTOR);

-	if (floor(ScaleFactor) != ScaleFactor)
-		coord = uvec2(vec2(coord) * ScaleFactor);
-	else
-		coord *= uvec2(ScaleFactor);
-
-	vec4 pixel = texelFetch(samp0, ivec2(coord), 0);
-	vec2  sel0 = (pos.y & 2u) == 0u ? pixel.rb : pixel.ga;
-	float sel1 = (pos.x & 8u) == 0u ? sel0.x : sel0.y;
-	o_col0 = vec4(sel1); // Divide by something here?
+  vec4 pixel = texelFetch(samp0, ivec2(coord), 0);
+  vec2  sel0 = (pos.y & 2u) == 0u ? pixel.rb : pixel.ga;
+  float sel1 = (pos.x & 8u) == 0u ? sel0.x : sel0.y;
+  o_col0 = vec4(sel1); // Divide by something here?
 }
 #endif

 #ifdef ps_convert_clut_4
 layout(push_constant) uniform cb10
 {
+	vec2 scale;
 	uvec2 offset;
 	uint doffset;
-	uint cb_pad1;
-	float scale;
-	vec3 cb_pad2;
 };

 void ps_convert_clut_4()
@@ -307,7 +288,7 @@ void ps_convert_clut_4()
 	uint index = uint(gl_FragCoord.x) + doffset;
 	uvec2 pos = uvec2(index % 8u, index / 8u);

-	ivec2 final = ivec2(floor(vec2(offset + pos) * vec2(scale)));
+	ivec2 final = ivec2(floor(vec2(offset + pos) * scale));
 	o_col0 = texelFetch(samp0, final, 0);
 }
 #endif
@@ -315,11 +296,9 @@ void ps_convert_clut_4()
 #ifdef ps_convert_clut_8
 layout(push_constant) uniform cb10
 {
+	vec2 scale;
 	uvec2 offset;
 	uint doffset;
-	uint cb_pad1;
-	float scale;
-	vec3 cb_pad2;
 };

 void ps_convert_clut_8()
@@ -333,7 +312,7 @@ void ps_convert_clut_8()
 	pos.x = (index % 8u) + ((subgroup >= 2u) ? 8u : 0u);
 	pos.y = ((index / 32u) * 2u) + (subgroup % 2u);

-	ivec2 final = ivec2(floor(vec2(offset + pos) * vec2(scale)));
+	ivec2 final = ivec2(floor(vec2(offset + pos) * scale));
 	o_col0 = texelFetch(samp0, final, 0);
 }
 #endif
--- a/bin/resources/shaders/vulkan/imgui.glsl
+++ b/bin/resources/shaders/vulkan/imgui.glsl
@@ -1,39 +0,0 @@
-#ifdef VERTEX_SHADER
-
-layout(location = 0) in vec2 Position;
-layout(location = 1) in vec2 UV;
-layout(location = 2) in vec4 Color;
-
-layout(push_constant) uniform PushConstants
-{
-	vec2 uScale;
-	vec2 uTranslate;
-};
-
-layout(location = 0) out vec2 Frag_UV;
-layout(location = 1) out vec4 Frag_Color;
-
-void vs_main()
-{
-	Frag_UV = UV;
-	Frag_Color = Color;
-	gl_Position = vec4(Position * uScale + uTranslate, 0.0f, 1.0f);
-}
-
-#endif
-
-#ifdef FRAGMENT_SHADER
-
-layout(binding = 0) uniform sampler2D Texture;
-
-layout(location = 0) in vec2 Frag_UV;
-layout(location = 1) in vec4 Frag_Color;
-
-layout(location = 0) out vec4 Out_Color;
-
-void ps_main()
-{
-	Out_Color = Frag_Color * texture(Texture, Frag_UV.st);
-}
-
-#endif
--- a/bin/resources/shaders/vulkan/interlace.glsl
+++ b/bin/resources/shaders/vulkan/interlace.glsl
@@ -35,7 +35,7 @@ void ps_main0()
 	const int vpos  = int(gl_FragCoord.y); // vertical position of destination texture

 	if ((vpos & 1) == field)
-		o_col0 = textureLod(samp0, v_tex, 0);
+		o_col0 = texture(samp0, v_tex);
 	else
 		discard;
 }
@@ -46,7 +46,7 @@ void ps_main0()
 #ifdef ps_main1
 void ps_main1()
 {
-	o_col0 = textureLod(samp0, v_tex, 0);
+	o_col0 = texture(samp0, v_tex);
 }
 #endif

@@ -56,9 +56,9 @@ void ps_main1()
 void ps_main2()
 {
 	vec2 vstep = vec2(0.0f, ZrH.y);
-	vec4 c0 = textureLod(samp0, v_tex - vstep, 0);
-	vec4 c1 = textureLod(samp0, v_tex, 0);
-	vec4 c2 = textureLod(samp0, v_tex + vstep, 0);
+	vec4 c0 = texture(samp0, v_tex - vstep);
+	vec4 c1 = texture(samp0, v_tex);
+	vec4 c2 = texture(samp0, v_tex + vstep);

 	o_col0 = (c0 + c1 * 2.0f + c2) / 4.0f;
 }
@@ -82,11 +82,15 @@ void ps_main3()
 	const int  vres   = int(ZrH.z) >> 1;                          // vertical resolution of source texture
 	const int  lofs   = ((((vres + 1) >> 1) << 1) - vres) & bank; // line alignment offset for bank 1
 	const int  vpos   = int(gl_FragCoord.y) + lofs;               // vertical position of destination texture
+	const vec2 bofs   = vec2(0.0f, 0.5f * bank);                  // vertical offset of the current bank relative to source texture size
+	const vec2 vscale = vec2(1.0f, 2.0f);                         // scaling factor from source to destination texture
+	const vec2 optr   = v_tex - bofs;                             // used to check if the current destination line is within the current bank
+	const vec2 iptr   = optr * vscale;                            // pointer to the current pixel in the source texture

 	// if the index of current destination line belongs to the current fiels we update it, otherwise
 	// we leave the old line in the destination buffer
-	if ((vpos & 1) == field)
-		o_col0 = textureLod(samp0, v_tex, 0);
+	if ((optr.y >= 0.0f) && (optr.y < 0.5f) && ((vpos & 1) == field))
+		o_col0 = texture(samp0, iptr);
 	else
 		discard;
 }
@@ -146,13 +150,13 @@ void ps_main4()

 	// calculating motion, only relevant for missing lines where the "center line" is pointed by p_t1

-	vec4 hn = textureLod(samp0, p_t0 - lofs, 0); // new high pixel
-	vec4 cn = textureLod(samp0, p_t1, 0);        // new center pixel
-	vec4 ln = textureLod(samp0, p_t0 + lofs, 0); // new low pixel
+	vec4 hn = texture(samp0, p_t0 - lofs); // new high pixel
+	vec4 cn = texture(samp0, p_t1);        // new center pixel
+	vec4 ln = texture(samp0, p_t0 + lofs); // new low pixel

-	vec4 ho = textureLod(samp0, p_t2 - lofs, 0); // old high pixel
-	vec4 co = textureLod(samp0, p_t3, 0);        // old center pixel
-	vec4 lo = textureLod(samp0, p_t2 + lofs, 0); // old low pixel
+	vec4 ho = texture(samp0, p_t2 - lofs); // old high pixel
+	vec4 co = texture(samp0, p_t3);        // old center pixel
+	vec4 lo = texture(samp0, p_t2 + lofs); // old low pixel

 	vec3 mh = hn.rgb - ho.rgb; // high pixel motion
 	vec3 mc = cn.rgb - co.rgb; // center pixel motion
@@ -177,7 +181,7 @@ void ps_main4()
 	if ((vpos & 1) == field) // output coordinate present on current field
 	{
 		// output coordinate present on current field
-		o_col0 = textureLod(samp0, p_t0, 0);
+		o_col0 = texture(samp0, p_t0);
 	}
 	else if ((iptr.y > 0.5f - lofs.y) || (iptr.y < 0.0 + lofs.y))
 	{
--- a/bin/resources/shaders/vulkan/tfx.glsl
+++ b/bin/resources/shaders/vulkan/tfx.glsl
--- a/cmake/ApiValidation.cmake
+++ b/cmake/ApiValidation.cmake
@@ -0,0 +1,113 @@
+set(wx_sdl_c_code "
+#include <wx/setup.h>
+
+#if (wxUSE_LIBSDL == 0)
+#error cmake_WX_SDL
+#endif
+
+int main()
+{
+	return 0;
+}
+")
+
+set(gcc7_mmx_code "
+#include <stdio.h>
+#include <stdint.h>
+#include <xmmintrin.h>
+#include <emmintrin.h>
+
+class alignas(16) GSVector4i
+{
+public:
+	__m128i m;
+
+	explicit GSVector4i(__m128i m)
+	{
+		this->m = m;
+	}
+
+	static void storel(void* p, const GSVector4i& v)
+	{
+		_mm_storel_epi64((__m128i*)p, v.m);
+	}
+
+	static GSVector4i loadl(const void* p)
+	{
+		return GSVector4i(_mm_loadl_epi64((__m128i*)p));
+	}
+
+	bool eq(const GSVector4i& v) const
+	{
+		return _mm_movemask_epi8(_mm_cmpeq_epi32(m, v.m)) == 0xffff;
+	}
+};
+
+
+union GIFRegTRXPOS
+{
+	unsigned long long u64;
+	void operator = (const GSVector4i& v) {GSVector4i::storel(this, v);}
+	bool operator != (const union GIFRegTRXPOS& r) const {return !((GSVector4i)r).eq(*this);}
+	operator GSVector4i() const {return GSVector4i::loadl(this);}
+};
+
+extern GIFRegTRXPOS	TRXPOS;
+GIFRegTRXPOS TRXPOS = {};
+
+void GIFRegHandlerTRXPOS(const GIFRegTRXPOS&  p)
+{
+	if(p != TRXPOS)
+	{
+		printf(\"foo\");
+	}
+
+	TRXPOS = (GSVector4i)p;
+}
+
+int main()
+{
+	GIFRegTRXPOS r = {};
+	GIFRegHandlerTRXPOS(r);
+
+	uint16_t fpu[16] = {0};
+	__asm__ __volatile__(\"fstenv %0\" : \"=m\"(fpu));
+
+	bool ok = fpu[4] == 0xFFFF;
+
+	if (!ok) {
+		printf(\"Wrong MMX state !\");
+		exit(1);
+	}
+
+	return 0;
+}
+")
+
+function(GCC7_BUG)
+	# try_run doesn't work when cross-compiling is enabled. It is completely silly in our case
+	# as i386 binaries are 100% fine on x64.
+	set(OLD_CMAKE_CROSSCOMPILING ${CMAKE_CROSSCOMPILING})
+	set(CMAKE_CROSSCOMPILING 0)
+
+	set(IN "${CMAKE_BINARY_DIR}/gcc7_mmx.cpp")
+	file(WRITE "${IN}" "${gcc7_mmx_code}")
+
+	enable_language(CXX)
+
+	try_run(
+		run_result
+		compile_result_unused
+		"${CMAKE_BINARY_DIR}"
+		"${IN}"
+		CMAKE_FLAGS "-DCOMPILE_DEFINITIONS:STRING=-msse -msse2 -O2 -m32 -march=i686"
+	)
+
+	if (${run_result})
+		message(FATAL_ERROR "GCC 7.0/7.1  generates invalid code => https://gcc.gnu.org/bugzilla/show_bug.cgi?id=80799\n"
+			"You can either backport the fix or swith to another version of GCC.")
+	endif()
+
+	set(CMAKE_CROSSCOMPILING ${OLD_CMAKE_CROSSCOMPILING})
+
+endfunction()
--- a/cmake/BuildParameters.cmake
+++ b/cmake/BuildParameters.cmake
@@ -34,7 +34,6 @@ if(UNIX AND NOT APPLE)
 	option(USE_LEGACY_USER_DIRECTORY "Use legacy home/PCSX2 user directory instead of XDG standard" OFF)
 	option(X11_API "Enable X11 support" ON)
 	option(WAYLAND_API "Enable Wayland support" ON)
-	option(DBUS_API "Enable DBus support for screensaver inhibiting" ON)
 endif()

 if(APPLE)
@@ -47,12 +46,12 @@ endif()
 #-------------------------------------------------------------------------------
 option(USE_ASAN "Enable address sanitizer")

-if(MSVC AND CMAKE_CXX_COMPILER_ID STREQUAL "Clang")
-	set(USE_CLANG_CL TRUE)
-	message(STATUS "Building with Clang-CL.")
-elseif(CMAKE_CXX_COMPILER_ID STREQUAL "Clang" OR CMAKE_CXX_COMPILER_ID STREQUAL "AppleClang")
+if(CMAKE_CXX_COMPILER_ID STREQUAL "Clang" OR CMAKE_CXX_COMPILER_ID STREQUAL "AppleClang")
 	set(USE_CLANG TRUE)
 	message(STATUS "Building with Clang/LLVM.")
+elseif(CMAKE_CXX_COMPILER_ID STREQUAL "Intel")
+	set(USE_ICC TRUE)
+	message(STATUS "Building with Intel's ICC.")
 elseif(CMAKE_CXX_COMPILER_ID STREQUAL "GNU")
 	set(USE_GCC TRUE)
 	message(STATUS "Building with GNU GCC")
@@ -104,23 +103,33 @@ include(TargetArch)
 target_architecture(PCSX2_TARGET_ARCHITECTURES)
 if(${PCSX2_TARGET_ARCHITECTURES} MATCHES "x86_64")
 	message(STATUS "Compiling a ${PCSX2_TARGET_ARCHITECTURES} build on a ${CMAKE_HOST_SYSTEM_PROCESSOR} host.")
+else()
+	message(FATAL_ERROR "Unsupported architecture: ${PCSX2_TARGET_ARCHITECTURES}")
+endif()

+if(${PCSX2_TARGET_ARCHITECTURES} MATCHES "x86_64")
 	# x86_64 requires -fPIC
 	set(CMAKE_POSITION_INDEPENDENT_CODE ON)

 	if(NOT DEFINED ARCH_FLAG AND NOT MSVC)
 		if (DISABLE_ADVANCE_SIMD)
-			set(ARCH_FLAG "-msse -msse2 -msse4.1 -mfxsr")
+			if (USE_ICC)
+				set(ARCH_FLAG "-msse2 -msse4.1")
+			else()
+				set(ARCH_FLAG "-msse -msse2 -msse4.1 -mfxsr")
+			endif()
 		else()
 			#set(ARCH_FLAG "-march=native -fabi-version=6")
 			set(ARCH_FLAG "-march=native")
 		endif()
-	elseif(NOT DEFINED ARCH_FLAG AND USE_CLANG_CL)
-		set(ARCH_FLAG "-msse4.1")
 	endif()
-	list(APPEND PCSX2_DEFS _M_X86=1)
+	list(APPEND PCSX2_DEFS _ARCH_64=1 _M_X86=1)
+	set(_ARCH_64 1)
 	set(_M_X86 1)
 else()
+	# All but i386 requires -fPIC
+	set(CMAKE_POSITION_INDEPENDENT_CODE ON)
+
 	message(FATAL_ERROR "Unsupported architecture: ${PCSX2_TARGET_ARCHITECTURES}")
 endif()
 string(REPLACE " " ";" ARCH_FLAG_LIST "${ARCH_FLAG}")
@@ -134,16 +143,13 @@ option(USE_PGO_OPTIMIZE "Enable PGO optimization (use profile)")

 # Note1: Builtin strcmp/memcmp was proved to be slower on Mesa than stdlib version.
 # Note2: float operation SSE is impacted by the PCSX2 SSE configuration. In particular, flush to zero denormal.
-if(MSVC AND NOT USE_CLANG_CL)
-	add_compile_options(
-		"$<$<COMPILE_LANGUAGE:CXX>:/Zc:externConstexpr>"
-		"$<$<COMPILE_LANGUAGE:CXX>:/Zc:__cplusplus>"
-		"$<$<COMPILE_LANGUAGE:CXX>:/permissive->"
-		"/Zo"
-		"/utf-8"
-	)
-elseif(NOT MSVC)
+if(MSVC)
+	add_compile_options("$<$<COMPILE_LANGUAGE:CXX>:/Zc:externConstexpr>")
+else()
 	add_compile_options(-pipe -fvisibility=hidden -pthread -fno-builtin-strcmp -fno-builtin-memcmp -mfpmath=sse)
+
+	# -fno-operator-names should only be for C++ files, not C files.
+	add_compile_options($<$<COMPILE_LANGUAGE:CXX>:-fno-operator-names>)
 endif()

 set(CONFIG_REL_NO_DEB $<OR:$<CONFIG:Release>,$<CONFIG:MinSizeRel>>)
@@ -158,12 +164,6 @@ if(WIN32)
 	list(APPEND PCSX2_DEFS TIXML_USE_STL _SCL_SECURE_NO_WARNINGS _UNICODE UNICODE)
 endif()

-# Enable debug information in release builds for Linux.
-# Makes the backtrace actually meaningful.
-if(UNIX AND NOT APPLE)
-	add_compile_options($<$<CONFIG:Release>:-g1>)
-endif()
-
 if(MSVC)
 	# Enable PDB generation in release builds
 	add_compile_options(
@@ -209,13 +209,24 @@ endif()
 if (MSVC)
 	set(DEFAULT_WARNINGS)
 else()
-	set(DEFAULT_WARNINGS -Wall -Wextra -Wno-attributes -Wno-unused-function -Wno-unused-parameter -Wno-missing-field-initializers -Wno-format -Wno-format-security -Wno-unused-value)
+	set(DEFAULT_WARNINGS -Wall -Wextra -Wno-attributes -Wno-unused-function -Wno-unused-parameter -Wno-missing-field-initializers -Wno-format -Wno-format-security)
+	if (NOT USE_ICC)
+		list(APPEND DEFAULT_WARNINGS -Wno-unused-value)
+	endif()
 endif()

 if (USE_GCC)
 	list(APPEND DEFAULT_WARNINGS -Wno-stringop-truncation -Wno-stringop-overflow -Wno-maybe-uninitialized )
 endif()

+
+# -Wstrict-aliasing=n: to fix one day aliasing issue. n=1/2/3
+if (USE_ICC)
+	set(AGGRESSIVE_WARNING -Wstrict-aliasing)
+elseif(NOT MSVC)
+	set(AGGRESSIVE_WARNING -Wstrict-aliasing -Wstrict-overflow=1)
+endif()
+
 if (USE_PGO_GENERATE OR USE_PGO_OPTIMIZE)
 	add_compile_options("-fprofile-dir=${CMAKE_SOURCE_DIR}/profile")
 endif()
@@ -242,7 +253,7 @@ if(USE_CLANG AND TIMETRACE)
 	add_compile_options(-ftime-trace)
 endif()

-set(PCSX2_WARNINGS ${DEFAULT_WARNINGS})
+set(PCSX2_WARNINGS ${DEFAULT_WARNINGS} ${AGGRESSIVE_WARNING})

 if(DISABLE_BUILD_DATE)
 	message(STATUS "Disabling the inclusion of the binary compile date.")
--- a/cmake/FindLibbacktrace.cmake
+++ b/cmake/FindLibbacktrace.cmake
@@ -1,31 +0,0 @@
-# - Try to find libbacktrace
-# Once done this will define
-#  LIBBACKTRACE_FOUND - System has libbacktrace
-#  LIBBACKTRACE_INCLUDE_DIRS - The libbacktrace include directories
-#  LIBBACKTRACE_LIBRARIES - The libraries needed to use libbacktrace
-
-FIND_PATH(
-    LIBBACKTRACE_INCLUDE_DIR backtrace.h
-    HINTS /usr/include /usr/local/include
-    ${LIBBACKTRACE_PATH_INCLUDES}
-)
-
-FIND_LIBRARY(
-    LIBBACKTRACE_LIBRARY
-    NAMES backtrace
-    PATHS ${ADDITIONAL_LIBRARY_PATHS} ${LIBBACKTRACE_PATH_LIB}
-)
-
-include(FindPackageHandleStandardArgs)
-find_package_handle_standard_args(Libbacktrace DEFAULT_MSG
-                                  LIBBACKTRACE_LIBRARY LIBBACKTRACE_INCLUDE_DIR)
-
-if(LIBBACKTRACE_FOUND)
-    add_library(libbacktrace::libbacktrace UNKNOWN IMPORTED)
-    set_target_properties(libbacktrace::libbacktrace PROPERTIES
-        IMPORTED_LOCATION ${LIBBACKTRACE_LIBRARY}
-        INTERFACE_INCLUDE_DIRECTORIES ${LIBBACKTRACE_INCLUDE_DIR}
-    )
-endif()
-
-mark_as_advanced(LIBBACKTRACE_INCLUDE_DIR LIBBACKTRACE_LIBRARY)
--- a/cmake/FindVtune.cmake
+++ b/cmake/FindVtune.cmake
@@ -12,12 +12,21 @@ find_path(VTUNE_INCLUDE_DIRS NAMES jitprofiling.h PATHS
 	/opt/intel/vtune_amplifier_xe_2016/include
 )

-find_library(VTUNE_LIBRARIES NAMES libjitprofiling.a PATHS
-	/opt/intel/oneapi/vtune/latest/lib64
-	/opt/intel/vtune_amplifier_xe_2018/lib64
-	/opt/intel/vtune_amplifier_xe_2017/lib64
-	/opt/intel/vtune_amplifier_xe_2016/lib64
-)
+if(${PCSX2_TARGET_ARCHITECTURES} MATCHES "i386")
+	find_library(VTUNE_LIBRARIES NAMES libjitprofiling.a PATHS
+		/opt/intel/oneapi/vtune/latest/lib32
+		/opt/intel/vtune_amplifier_xe_2018/lib32
+		/opt/intel/vtune_amplifier_xe_2017/lib32
+		/opt/intel/vtune_amplifier_xe_2016/lib32
+	)
+else()
+	find_library(VTUNE_LIBRARIES NAMES libjitprofiling.a PATHS
+		/opt/intel/oneapi/vtune/latest/lib64
+		/opt/intel/vtune_amplifier_xe_2018/lib64
+		/opt/intel/vtune_amplifier_xe_2017/lib64
+		/opt/intel/vtune_amplifier_xe_2016/lib64
+	)
+endif()

 # handle the QUIETLY and REQUIRED arguments and set VTUNE_FOUND to TRUE if
 # all listed variables are TRUE
@@ -32,3 +41,4 @@ if(VTUNE_LIBRARIES AND NOT TARGET Vtune::Vtune)
 endif()

 mark_as_advanced(VTUNE_FOUND VTUNE_INCLUDE_DIRS VTUNE_LIBRARIES)
+
--- a/cmake/Pcsx2Utils.cmake
+++ b/cmake/Pcsx2Utils.cmake
@@ -10,9 +10,8 @@ function(detectOperatingSystem)
 	if(WIN32)
 		set(Windows TRUE PARENT_SCOPE)
 	elseif(UNIX AND APPLE)
-		if(IOS)
-			message(WARNING "iOS isn't supported, the build will most likely fail")
-		endif()
+		# No easy way to filter out iOS.
+		message(WARNING "OS X/iOS isn't supported, the build will most likely fail")
 		set(MacOSX TRUE PARENT_SCOPE)
 	elseif(UNIX)
 		if(CMAKE_SYSTEM_NAME MATCHES "Linux")
--- a/cmake/SearchForStuff.cmake
+++ b/cmake/SearchForStuff.cmake
@@ -86,8 +86,6 @@ else()
 		if(WAYLAND_API)
 			find_package(Wayland REQUIRED)
 		endif()
-
-		find_package(Libbacktrace)
 	endif()
 endif(WIN32)

@@ -102,7 +100,18 @@ if(ENABLE_TESTS)
 	endif()
 endif()

-if(GCC_VERSION VERSION_GREATER_EQUAL "9.0" AND GCC_VERSION VERSION_LESS "9.2")
+#----------------------------------------
+# Check correctness of the parameter
+# Note: wxWidgets_INCLUDE_DIRS must be defined
+#----------------------------------------
+include(ApiValidation)
+
+# Blacklist bad GCC
+if(GCC_VERSION VERSION_EQUAL "7.0" OR GCC_VERSION VERSION_EQUAL "7.1")
+	GCC7_BUG()
+endif()
+
+if((GCC_VERSION VERSION_EQUAL "9.0" OR GCC_VERSION VERSION_GREATER "9.0") AND GCC_VERSION LESS "9.2")
 	message(WARNING "
 	It looks like you are compiling with 9.0.x or 9.1.x. Using these versions is not recommended,
 	as there is a bug known to cause the compiler to segfault while compiling. See patch
@@ -123,7 +132,7 @@ find_optional_system_library(libzip 3rdparty/libzip 1.8.0)
 if(QT_BUILD)
 	# Default to bundled Qt6 for Windows.
 	if(WIN32 AND NOT DEFINED Qt6_DIR)
-		set(Qt6_DIR ${CMAKE_SOURCE_DIR}/3rdparty/qt/6.5.0/msvc2022_64/lib/cmake/Qt6)
+		set(Qt6_DIR ${CMAKE_SOURCE_DIR}/3rdparty/qt/6.4.0/msvc2022_64/lib/cmake/Qt6)
 	endif()

 	# Find the Qt components that we need.
@@ -143,9 +152,6 @@ if(QT_BUILD)
 	# rcheevos backend for RetroAchievements.
 	if(USE_ACHIEVEMENTS)
 		add_subdirectory(3rdparty/rcheevos EXCLUDE_FROM_ALL)
-		if(WIN32)
-			add_subdirectory(3rdparty/rainterface EXCLUDE_FROM_ALL)
-		endif()
 	endif()

 	# Discord-RPC library for rich presence.
--- a/common/CMakeLists.txt
+++ b/common/CMakeLists.txt
@@ -128,6 +128,50 @@ target_sources(common PRIVATE
 	emitter/x86types.h
 )

+if(USE_OPENGL)
+	target_sources(common PRIVATE
+		GL/Context.cpp
+		GL/Program.cpp
+		GL/ShaderCache.cpp
+		GL/StreamBuffer.cpp
+	)
+	target_sources(common PRIVATE
+		GL/Context.h
+		GL/Program.h
+		GL/ShaderCache.h
+		GL/StreamBuffer.h
+	)
+	target_link_libraries(common PUBLIC glad)
+endif()
+
+if(USE_VULKAN)
+	target_link_libraries(common PUBLIC
+		Vulkan-Headers glslang
+	)
+	target_sources(common PRIVATE
+		Vulkan/ShaderCache.cpp
+		Vulkan/Texture.cpp
+		Vulkan/Loader.cpp
+		Vulkan/ShaderCompiler.cpp
+		Vulkan/Util.cpp
+		Vulkan/SwapChain.cpp
+		Vulkan/StreamBuffer.cpp
+		Vulkan/Context.cpp
+		Vulkan/Builders.cpp
+		Vulkan/vk_mem_alloc.cpp
+		Vulkan/Context.h
+		Vulkan/Texture.h
+		Vulkan/ShaderCompiler.h
+		Vulkan/SwapChain.h
+		Vulkan/Builders.h
+		Vulkan/StreamBuffer.h
+		Vulkan/ShaderCache.h
+		Vulkan/EntryPoints.h
+		Vulkan/Loader.h
+		Vulkan/Util.h
+	)
+endif()
+
 if(USE_VTUNE)
 	target_link_libraries(common PUBLIC Vtune::Vtune)
 endif()
@@ -135,7 +179,7 @@ endif()
 if(WIN32)
 	enable_language(ASM_MASM)
 	target_sources(common PRIVATE FastJmp.asm)
-	target_link_libraries(common PUBLIC WIL::WIL winmm)
+	target_link_libraries(common PUBLIC WIL::WIL D3D12MemAlloc winmm)
 	target_sources(common PRIVATE
 		CrashHandler.cpp
 		CrashHandler.h
@@ -144,6 +188,24 @@ if(WIN32)
 		HTTPDownloaderWinHTTP.h
 		StackWalker.cpp
 		StackWalker.h
+		D3D11/ShaderCache.cpp
+		D3D11/ShaderCache.h
+		D3D11/ShaderCompiler.cpp
+		D3D11/ShaderCompiler.h
+		D3D12/Builders.cpp
+		D3D12/Builders.h
+		D3D12/Context.cpp
+		D3D12/Context.h
+		D3D12/DescriptorHeapManager.cpp
+		D3D12/DescriptorHeapManager.h
+		D3D12/ShaderCache.cpp
+		D3D12/ShaderCache.h
+		D3D12/StreamBuffer.cpp
+		D3D12/StreamBuffer.h
+		D3D12/Texture.cpp
+		D3D12/Texture.h
+		D3D12/Util.cpp
+		D3D12/Util.h
 	)
 endif()

@@ -154,23 +216,62 @@ if(APPLE)
 	)
 	target_compile_options(common PRIVATE -fobjc-arc)
 	target_link_options(common PRIVATE -fobjc-link-runtime)
-	target_link_libraries(common PRIVATE
-		"-framework Foundation"
-		"-framework IOKit"
-	)
 endif()

-if(DBUS_API)
-	target_compile_definitions(common PRIVATE DBUS_API)
-	find_package(PkgConfig REQUIRED)
-	pkg_check_modules(DBUS REQUIRED dbus-1)
-	target_include_directories(common PRIVATE ${DBUS_INCLUDE_DIRS})
-	target_link_libraries(common PRIVATE ${DBUS_LINK_LIBRARIES})
+if(USE_OPENGL)
+	if(WIN32)
+		target_sources(common PRIVATE
+			GL/ContextWGL.cpp
+			GL/ContextWGL.h
+		)
+		target_link_libraries(common PUBLIC opengl32.lib)
+	elseif(APPLE)
+		target_sources(common PRIVATE
+			GL/ContextAGL.mm
+			GL/ContextAGL.h
+		)
+	else()
+		if(X11_API OR WAYLAND_API)
+			target_sources(common PRIVATE
+				GL/ContextEGL.cpp
+				GL/ContextEGL.h
+			)
+			target_link_libraries(common PRIVATE PkgConfig::EGL)
+		endif()
+
+		if(X11_API)
+			target_sources(common PRIVATE
+				GL/ContextEGLX11.cpp
+				GL/ContextEGLX11.h
+			)
+			if(TARGET PkgConfig::XRANDR)
+				target_link_libraries(common PRIVATE PkgConfig::XRANDR)
+				target_compile_definitions(common PRIVATE "HAS_XRANDR=1")
+			endif()
+		endif()
+
+		if(WAYLAND_API)
+			target_sources(common PRIVATE
+				GL/ContextEGLWayland.cpp
+				GL/ContextEGLWayland.h
+			)
+		endif()
+	endif()
 endif()

-if(X11_API AND TARGET PkgConfig::XRANDR)
-	target_link_libraries(common PRIVATE PkgConfig::XRANDR)
-	target_compile_definitions(common PRIVATE "HAS_XRANDR=1")
+if(USE_VULKAN)
+	if(APPLE)
+		# Needed for Metal surface creation.
+		target_compile_options(common PRIVATE -fobjc-arc)
+		target_link_options(common PRIVATE -fobjc-link-runtime)
+	elseif(NOT WIN32)
+		if(X11_API)
+			target_compile_definitions(common PUBLIC "VULKAN_USE_X11=1")
+		endif()
+		if(WAYLAND_API)
+			target_compile_definitions(common PUBLIC "VULKAN_USE_WAYLAND=1")
+		endif()
+	endif()
 endif()

 if (USE_GCC AND CMAKE_INTERPROCEDURAL_OPTIMIZATION)
@@ -187,11 +288,6 @@ if(NOT WIN32 AND (QT_BUILD OR NOGUI_BUILD))
 	target_link_libraries(common PRIVATE CURL::libcurl)
 endif()

-if(UNIX AND NOT APPLE AND TARGET libbacktrace::libbacktrace)
-	target_compile_definitions(common PRIVATE "HAS_LIBBACKTRACE=1")
-	target_link_libraries(common PRIVATE libbacktrace::libbacktrace)
-endif()
-
 target_link_libraries(common PRIVATE
 	${LIBC_LIBRARIES}
 	PNG::PNG
--- a/common/CrashHandler.cpp
+++ b/common/CrashHandler.cpp
@@ -1,5 +1,5 @@
 /*  PCSX2 - PS2 Emulator for PCs
- *  Copyright (C) 2002-2023  PCSX2 Dev Team
+ *  Copyright (C) 2002-2022  PCSX2 Dev Team
 *
 *  PCSX2 is free software: you can redistribute it and/or modify it under the terms
 *  of the GNU Lesser General Public License as published by the Free Software Found-
@@ -215,199 +215,6 @@ void CrashHandler::Uninstall()
 	}
 }

-#elif defined(HAS_LIBBACKTRACE)
-
-#include "FileSystem.h"
-
-#include <backtrace.h>
-#include <signal.h>
-#include <sys/mman.h>
-#include <unistd.h>
-#include <cstdarg>
-#include <cstdio>
-#include <mutex>
-
-namespace CrashHandler
-{
-	struct BacktraceBuffer
-	{
-		char* buffer;
-		size_t used;
-		size_t size;
-	};
-
-	static const char* GetSignalName(int signal_no);
-	static void AllocateBuffer(BacktraceBuffer* buf);
-	static void FreeBuffer(BacktraceBuffer* buf);
-	static void AppendToBuffer(BacktraceBuffer* buf, const char* format, ...);
-	static int BacktraceFullCallback(void* data, uintptr_t pc, const char* filename, int lineno, const char* function);
-	static void CallExistingSignalHandler(int signal, siginfo_t* siginfo, void* ctx);
-	static void CrashSignalHandler(int signal, siginfo_t* siginfo, void* ctx);
-
-	static std::recursive_mutex s_crash_mutex;
-	static bool s_in_signal_handler = false;
-
-	static backtrace_state* s_backtrace_state = nullptr;
-	static struct sigaction s_old_sigbus_action;
-	static struct sigaction s_old_sigsegv_action;
-}
-
-const char* CrashHandler::GetSignalName(int signal_no)
-{
-	switch (signal_no)
-	{
-		// Don't need to list all of them, there's only a couple we register.
-		// clang-format off
-		case SIGSEGV: return "SIGSEGV";
-		case SIGBUS: return "SIGBUS";
-		default: return "UNKNOWN";
-		// clang-format on
-	}
-}
-
-void CrashHandler::AllocateBuffer(BacktraceBuffer* buf)
-{
-	buf->used = 0;
-	buf->size = __pagesize;
-	buf->buffer = static_cast<char*>(mmap(nullptr, buf->size, PROT_READ | PROT_WRITE, MAP_ANONYMOUS | MAP_PRIVATE, -1, 0));
-	if (buf->buffer == static_cast<char*>(MAP_FAILED))
-	{
-		buf->buffer = nullptr;
-		buf->size = 0;
-	}
-}
-
-void CrashHandler::FreeBuffer(BacktraceBuffer* buf)
-{
-	if (buf->buffer)
-		munmap(buf->buffer, buf->size);
-}
-
-void CrashHandler::AppendToBuffer(BacktraceBuffer* buf, const char* format, ...)
-{
-	std::va_list ap;
-	va_start(ap, format);
-
-	// Hope this doesn't allocate memory... it *can*, but hopefully unlikely since
-	// it won't be the first call, and we're providing the buffer.
-	if (buf->size > 0 && buf->used < (buf->size - 1))
-	{
-		const int written = std::vsnprintf(buf->buffer + buf->used, buf->size - buf->used, format, ap);
-		if (written > 0)
-			buf->used += static_cast<size_t>(written);
-	}
-
-	va_end(ap);
-}
-
-int CrashHandler::BacktraceFullCallback(void* data, uintptr_t pc, const char* filename, int lineno, const char* function)
-{
-	BacktraceBuffer* buf = static_cast<BacktraceBuffer*>(data);
-	AppendToBuffer(buf, "  %016p", pc);
-	if (function)
-		AppendToBuffer(buf, " %s", function);
-	if (filename)
-		AppendToBuffer(buf, " [%s:%d]", filename, lineno);
-	
-	AppendToBuffer(buf, "\n");
-	return 0;
-}
-
-void CrashHandler::CallExistingSignalHandler(int signal, siginfo_t* siginfo, void* ctx)
-{
-	const struct sigaction& sa = (signal == SIGBUS) ? s_old_sigbus_action : s_old_sigsegv_action;
-	if (sa.sa_flags & SA_SIGINFO)
-	{
-		sa.sa_sigaction(signal, siginfo, ctx);
-	}
-	else if (sa.sa_handler == SIG_DFL)
-	{
-		// Re-raising the signal would just queue it, and since we'd restore the handler back to us,
-		// we'd end up right back here again. So just abort, because that's probably what it'd do anyway.
-		abort();
-	}
-	else if (sa.sa_handler != SIG_IGN)
-	{
-		sa.sa_handler(signal);
-	}
-}
-
-void CrashHandler::CrashSignalHandler(int signal, siginfo_t* siginfo, void* ctx)
-{
-	std::unique_lock lock(s_crash_mutex);
-	
-	// If we crash somewhere in libbacktrace, don't bother trying again.
-	if (!s_in_signal_handler)
-	{
-		s_in_signal_handler = true;
-
-#if defined(__APPLE__) && defined(__x86_64__)
-		void* const exception_pc = reinterpret_cast<void*>(static_cast<ucontext_t*>(ctx)->uc_mcontext->__ss.__rip);
-#elif defined(__FreeBSD__) && defined(__x86_64__)
-		void* const exception_pc = reinterpret_cast<void*>(static_cast<ucontext_t*>(ctx)->uc_mcontext.mc_rip);
-#elif defined(__x86_64__)
-		void* const exception_pc = reinterpret_cast<void*>(static_cast<ucontext_t*>(ctx)->uc_mcontext.gregs[REG_RIP]);
-#else
-		void* const exception_pc = nullptr;
-#endif
-
-		BacktraceBuffer buf;
-		AllocateBuffer(&buf);
-		AppendToBuffer(&buf, "*************** Unhandled %s at %p ***************\n", GetSignalName(signal), exception_pc);
-
-		const int rc = backtrace_full(s_backtrace_state, 0, BacktraceFullCallback, nullptr, &buf);
-		if (rc != 0)
-			AppendToBuffer(&buf, "  backtrace_full() failed: %d\n");
-
-		AppendToBuffer(&buf, "*******************************************************************\n");
-
-		if (buf.used > 0)
-			write(STDERR_FILENO, buf.buffer, buf.used);
-
-		FreeBuffer(&buf);
-
-		s_in_signal_handler = false;
-	}
-
-	// Chances are we're not going to have anything else to call, but just in case.
-	lock.unlock();
-	CallExistingSignalHandler(signal, siginfo, ctx);
-}
-
-bool CrashHandler::Install()
-{
-	const std::string progpath = FileSystem::GetProgramPath();
-	s_backtrace_state = backtrace_create_state(progpath.empty() ? nullptr : progpath.c_str(), 0, nullptr, nullptr);
-	if (!s_backtrace_state)
-		return false;
-	
-	struct sigaction sa;
-
-	sigemptyset(&sa.sa_mask);
-	sa.sa_flags = SA_SIGINFO | SA_NODEFER;
-	sa.sa_sigaction = CrashSignalHandler;
-	if (sigaction(SIGBUS, &sa, &s_old_sigbus_action) != 0)
-		return false;
-	if (sigaction(SIGSEGV, &sa, &s_old_sigsegv_action) != 0)
-		return false;
-
-	return true;
-}
-
-void CrashHandler::SetWriteDirectory(const std::string_view& dump_directory)
-{
-}
-
-void CrashHandler::WriteDumpForCaller()
-{
-}
-
-void CrashHandler::Uninstall()
-{
-	// We can't really unchain the signal handlers... so, YOLO.
-}
-
-
 #else

 bool CrashHandler::Install()
--- a/pcsx2/GS/Renderers/DX11/D3D11ShaderCache.cpp
+++ b/pcsx2/GS/Renderers/DX11/D3D11ShaderCache.cpp
@@ -1,5 +1,5 @@
 /*  PCSX2 - PS2 Emulator for PCs
- *  Copyright (C) 2002-2023  PCSX2 Dev Team
+ *  Copyright (C) 2002-2022  PCSX2 Dev Team
 *
 *  PCSX2 is free software: you can redistribute it and/or modify it under the terms
 *  of the GNU Lesser General Public License as published by the Free Software Found-
@@ -13,19 +13,12 @@
 *  If not, see <http://www.gnu.org/licenses/>.
 */

-#include "PrecompiledHeader.h"
-
-#include "GS/Renderers/DX11/D3D11ShaderCache.h"
-#include "GS/GS.h"
-
-#include "Config.h"
-#include "ShaderCacheVersion.h"
-
+#include "common/PrecompiledHeader.h"
+#include "common/D3D11/ShaderCache.h"
+#include "common/D3D11/ShaderCompiler.h"
 #include "common/FileSystem.h"
 #include "common/Console.h"
 #include "common/MD5Digest.h"
-#include "common/Path.h"
-
 #include <d3dcompiler.h>

 #pragma pack(push, 1)
@@ -44,14 +37,17 @@ struct CacheIndexEntry
 };
 #pragma pack(pop)

-D3D11ShaderCache::D3D11ShaderCache() = default;
+D3D11::ShaderCache::ShaderCache() = default;

-D3D11ShaderCache::~D3D11ShaderCache()
+D3D11::ShaderCache::~ShaderCache()
 {
-	Close();
+	if (m_index_file)
+		std::fclose(m_index_file);
+	if (m_blob_file)
+		std::fclose(m_blob_file);
 }

-bool D3D11ShaderCache::CacheIndexKey::operator==(const CacheIndexKey& key) const
+bool D3D11::ShaderCache::CacheIndexKey::operator==(const CacheIndexKey& key) const
 {
 	return (source_hash_low == key.source_hash_low && source_hash_high == key.source_hash_high &&
 			macro_hash_low == key.macro_hash_low && macro_hash_high == key.macro_hash_high &&
@@ -59,7 +55,7 @@ bool D3D11ShaderCache::CacheIndexKey::operator==(const CacheIndexKey& key) const
 			shader_type == key.shader_type && source_length == key.source_length);
 }

-bool D3D11ShaderCache::CacheIndexKey::operator!=(const CacheIndexKey& key) const
+bool D3D11::ShaderCache::CacheIndexKey::operator!=(const CacheIndexKey& key) const
 {
 	return (source_hash_low != key.source_hash_low || source_hash_high != key.source_hash_high ||
 			macro_hash_low != key.macro_hash_low || macro_hash_high != key.macro_hash_high ||
@@ -67,14 +63,15 @@ bool D3D11ShaderCache::CacheIndexKey::operator!=(const CacheIndexKey& key) const
 			shader_type != key.shader_type || source_length != key.source_length);
 }

-bool D3D11ShaderCache::Open(D3D_FEATURE_LEVEL feature_level, bool debug)
+bool D3D11::ShaderCache::Open(std::string_view base_path, D3D_FEATURE_LEVEL feature_level, u32 version, bool debug)
 {
 	m_feature_level = feature_level;
+	m_version = version;
 	m_debug = debug;

-	if (!GSConfig.DisableShaderCache)
+	if (!base_path.empty())
 	{
-		const std::string base_filename = GetCacheBaseFileName(feature_level, debug);
+		const std::string base_filename = GetCacheBaseFileName(base_path, feature_level, debug);
 		const std::string index_filename = base_filename + ".idx";
 		const std::string blob_filename = base_filename + ".bin";

@@ -85,21 +82,7 @@ bool D3D11ShaderCache::Open(D3D_FEATURE_LEVEL feature_level, bool debug)
 	return true;
 }

-void D3D11ShaderCache::Close()
-{
-	if (m_index_file)
-	{
-		std::fclose(m_index_file);
-		m_index_file = nullptr;
-	}
-	if (m_blob_file)
-	{
-		std::fclose(m_blob_file);
-		m_blob_file = nullptr;
-	}
-}
-
-bool D3D11ShaderCache::CreateNew(const std::string& index_filename, const std::string& blob_filename)
+bool D3D11::ShaderCache::CreateNew(const std::string& index_filename, const std::string& blob_filename)
 {
 	if (FileSystem::FileExists(index_filename.c_str()))
 	{
@@ -119,8 +102,9 @@ bool D3D11ShaderCache::CreateNew(const std::string& index_filename, const std::s
 		return false;
 	}

-	const u32 file_version = SHADER_CACHE_VERSION;
-	if (std::fwrite(&file_version, sizeof(file_version), 1, m_index_file) != 1)
+	const u32 index_version = FILE_VERSION;
+	if (std::fwrite(&index_version, sizeof(index_version), 1, m_index_file) != 1 ||
+		std::fwrite(&m_version, sizeof(m_version), 1, m_index_file) != 1)
 	{
 		Console.Error("Failed to write version to index file '%s'", index_filename.c_str());
 		std::fclose(m_index_file);
@@ -142,7 +126,7 @@ bool D3D11ShaderCache::CreateNew(const std::string& index_filename, const std::s
 	return true;
 }

-bool D3D11ShaderCache::ReadExisting(const std::string& index_filename, const std::string& blob_filename)
+bool D3D11::ShaderCache::ReadExisting(const std::string& index_filename, const std::string& blob_filename)
 {
 	m_index_file = FileSystem::OpenCFile(index_filename.c_str(), "r+b");
 	if (!m_index_file)
@@ -159,7 +143,9 @@ bool D3D11ShaderCache::ReadExisting(const std::string& index_filename, const std
 	}

 	u32 file_version = 0;
-	if (std::fread(&file_version, sizeof(file_version), 1, m_index_file) != 1 || file_version != SHADER_CACHE_VERSION)
+	u32 data_version = 0;
+	if (std::fread(&file_version, sizeof(file_version), 1, m_index_file) != 1 || file_version != FILE_VERSION ||
+		std::fread(&data_version, sizeof(data_version), 1, m_index_file) != 1 || data_version != m_version)
 	{
 		Console.Error("Bad file/data version in '%s'", index_filename.c_str());
 		std::fclose(m_index_file);
@@ -197,9 +183,11 @@ bool D3D11ShaderCache::ReadExisting(const std::string& index_filename, const std
 			return false;
 		}

-		const CacheIndexKey key{entry.source_hash_low, entry.source_hash_high, entry.macro_hash_low,
-			entry.macro_hash_high, entry.entry_point_low, entry.entry_point_high, entry.source_length,
-			static_cast<D3D::ShaderType>(entry.shader_type)};
+		const CacheIndexKey key{
+			entry.source_hash_low, entry.source_hash_high,
+			entry.macro_hash_low, entry.macro_hash_high,
+			entry.entry_point_low, entry.entry_point_high,
+			entry.source_length, static_cast<ShaderCompiler::Type>(entry.shader_type)};
 		const CacheIndexData data{entry.file_offset, entry.blob_size};
 		m_index.emplace(key, data);
 	}
@@ -211,9 +199,11 @@ bool D3D11ShaderCache::ReadExisting(const std::string& index_filename, const std
 	return true;
 }

-std::string D3D11ShaderCache::GetCacheBaseFileName(D3D_FEATURE_LEVEL feature_level, bool debug)
+std::string D3D11::ShaderCache::GetCacheBaseFileName(const std::string_view& base_path, D3D_FEATURE_LEVEL feature_level,
+	bool debug)
 {
-	std::string base_filename = "d3d_shaders_";
+	std::string base_filename(base_path);
+	base_filename += FS_OSPATH_SEPARATOR_STR "d3d_shaders_";

 	switch (feature_level)
 	{
@@ -234,11 +224,11 @@ std::string D3D11ShaderCache::GetCacheBaseFileName(D3D_FEATURE_LEVEL feature_lev
 	if (debug)
 		base_filename += "_debug";

-	return Path::Combine(EmuFolders::Cache, base_filename);
+	return base_filename;
 }

-D3D11ShaderCache::CacheIndexKey D3D11ShaderCache::GetCacheKey(
-	D3D::ShaderType type, const std::string_view& shader_code, const D3D_SHADER_MACRO* macros, const char* entry_point)
+D3D11::ShaderCache::CacheIndexKey D3D11::ShaderCache::GetCacheKey(ShaderCompiler::Type type, const std::string_view& shader_code,
+	const D3D_SHADER_MACRO* macros, const char* entry_point)
 {
 	union
 	{
@@ -282,9 +272,8 @@ D3D11ShaderCache::CacheIndexKey D3D11ShaderCache::GetCacheKey(
 	return key;
 }

-wil::com_ptr_nothrow<ID3DBlob> D3D11ShaderCache::GetShaderBlob(D3D::ShaderType type,
-	const std::string_view& shader_code, const D3D_SHADER_MACRO* macros /* = nullptr */,
-	const char* entry_point /* = "main" */)
+wil::com_ptr_nothrow<ID3DBlob> D3D11::ShaderCache::GetShaderBlob(ShaderCompiler::Type type, const std::string_view& shader_code,
+	const D3D_SHADER_MACRO* macros /* = nullptr */, const char* entry_point /* = "main" */)
 {
 	const auto key = GetCacheKey(type, shader_code, macros, entry_point);
 	auto iter = m_index.find(key);
@@ -296,51 +285,37 @@ wil::com_ptr_nothrow<ID3DBlob> D3D11ShaderCache::GetShaderBlob(D3D::ShaderType t
 	if (FAILED(hr) || std::fseek(m_blob_file, iter->second.file_offset, SEEK_SET) != 0 ||
 		std::fread(blob->GetBufferPointer(), 1, iter->second.blob_size, m_blob_file) != iter->second.blob_size)
 	{
-		Console.Error("(GSShaderCache11::GetShaderBlob): Read blob from file failed");
+		Console.Error("(D3D11::ShaderCache::GetShaderBlob): Read blob from file failed");
 		return {};
 	}

 	return blob;
 }

-wil::com_ptr_nothrow<ID3D11VertexShader> D3D11ShaderCache::GetVertexShader(ID3D11Device* device,
-	const std::string_view& shader_code, const D3D_SHADER_MACRO* macros /* = nullptr */,
-	const char* entry_point /* = "main" */)
+wil::com_ptr_nothrow<ID3D11VertexShader> D3D11::ShaderCache::GetVertexShader(ID3D11Device* device,
+	const std::string_view& shader_code, const D3D_SHADER_MACRO* macros /* = nullptr */, const char* entry_point /* = "main" */)
 {
-	wil::com_ptr_nothrow<ID3DBlob> blob = GetShaderBlob(D3D::ShaderType::Vertex, shader_code, macros, entry_point);
+	wil::com_ptr_nothrow<ID3DBlob> blob = GetShaderBlob(ShaderCompiler::Type::Vertex, shader_code, macros, entry_point);
 	if (!blob)
 		return {};

-	wil::com_ptr_nothrow<ID3D11VertexShader> shader;
-	const HRESULT hr =
-		device->CreateVertexShader(blob->GetBufferPointer(), blob->GetBufferSize(), nullptr, shader.put());
-	if (FAILED(hr))
-	{
-		Console.Error("Failed to create vertex shader: 0x%08X", hr);
-		return {};
-	}
-
-	return shader;
+	return D3D11::ShaderCompiler::CreateVertexShader(device, blob.get());
 }

-bool D3D11ShaderCache::GetVertexShaderAndInputLayout(ID3D11Device* device, ID3D11VertexShader** vs,
-	ID3D11InputLayout** il, const D3D11_INPUT_ELEMENT_DESC* layout, size_t layout_size,
-	const std::string_view& shader_code, const D3D_SHADER_MACRO* macros /* = nullptr */,
-	const char* entry_point /* = "main" */)
+bool D3D11::ShaderCache::GetVertexShaderAndInputLayout(ID3D11Device* device,
+	ID3D11VertexShader** vs, ID3D11InputLayout** il,
+	const D3D11_INPUT_ELEMENT_DESC* layout, size_t layout_size, const std::string_view& shader_code,
+	const D3D_SHADER_MACRO* macros /* = nullptr */, const char* entry_point /* = "main" */)
 {
-	wil::com_ptr_nothrow<ID3DBlob> blob = GetShaderBlob(D3D::ShaderType::Vertex, shader_code, macros, entry_point);
+	wil::com_ptr_nothrow<ID3DBlob> blob = GetShaderBlob(ShaderCompiler::Type::Vertex, shader_code, macros, entry_point);
 	if (!blob)
 		return false;

-	wil::com_ptr_nothrow<ID3D11VertexShader> actual_vs;
-	HRESULT hr = device->CreateVertexShader(blob->GetBufferPointer(), blob->GetBufferSize(), nullptr, actual_vs.put());
-	if (FAILED(hr))
-	{
-		Console.Error("Failed to create vertex shader: 0x%08X", hr);
-		return {};
-	}
+	wil::com_ptr_nothrow<ID3D11VertexShader> actual_vs = D3D11::ShaderCompiler::CreateVertexShader(device, blob.get());
+	if (!actual_vs)
+		return false;

-	hr = device->CreateInputLayout(layout, layout_size, blob->GetBufferPointer(), blob->GetBufferSize(), il);
+	HRESULT hr = device->CreateInputLayout(layout, layout_size, blob->GetBufferPointer(), blob->GetBufferSize(), il);
 	if (FAILED(hr))
 	{
 		Console.Error("(GetVertexShaderAndInputLayout) Failed to create input layout: %08X", hr);
@@ -351,51 +326,40 @@ bool D3D11ShaderCache::GetVertexShaderAndInputLayout(ID3D11Device* device, ID3D1
 	return true;
 }

-wil::com_ptr_nothrow<ID3D11PixelShader> D3D11ShaderCache::GetPixelShader(ID3D11Device* device,
-	const std::string_view& shader_code, const D3D_SHADER_MACRO* macros /* = nullptr */,
-	const char* entry_point /* = "main" */)
+wil::com_ptr_nothrow<ID3D11GeometryShader> D3D11::ShaderCache::GetGeometryShader(ID3D11Device* device,
+	const std::string_view& shader_code, const D3D_SHADER_MACRO* macros /* = nullptr */, const char* entry_point /* = "main" */)
 {
-	wil::com_ptr_nothrow<ID3DBlob> blob = GetShaderBlob(D3D::ShaderType::Pixel, shader_code, macros, entry_point);
+	wil::com_ptr_nothrow<ID3DBlob> blob = GetShaderBlob(ShaderCompiler::Type::Geometry, shader_code, macros, entry_point);
 	if (!blob)
 		return {};

-	wil::com_ptr_nothrow<ID3D11PixelShader> shader;
-	const HRESULT hr =
-		device->CreatePixelShader(blob->GetBufferPointer(), blob->GetBufferSize(), nullptr, shader.put());
-	if (FAILED(hr))
-	{
-		Console.Error("Failed to create pixel shader: 0x%08X", hr);
-		return {};
-	}
-
-	return shader;
+	return D3D11::ShaderCompiler::CreateGeometryShader(device, blob.get());
 }

-wil::com_ptr_nothrow<ID3D11ComputeShader> D3D11ShaderCache::GetComputeShader(ID3D11Device* device,
-	const std::string_view& shader_code, const D3D_SHADER_MACRO* macros /* = nullptr */,
-	const char* entry_point /* = "main" */)
+wil::com_ptr_nothrow<ID3D11PixelShader> D3D11::ShaderCache::GetPixelShader(ID3D11Device* device,
+	const std::string_view& shader_code, const D3D_SHADER_MACRO* macros /* = nullptr */, const char* entry_point /* = "main" */)
 {
-	wil::com_ptr_nothrow<ID3DBlob> blob = GetShaderBlob(D3D::ShaderType::Compute, shader_code, macros, entry_point);
+	wil::com_ptr_nothrow<ID3DBlob> blob = GetShaderBlob(ShaderCompiler::Type::Pixel, shader_code, macros, entry_point);
 	if (!blob)
 		return {};

-	wil::com_ptr_nothrow<ID3D11ComputeShader> shader;
-	const HRESULT hr =
-		device->CreateComputeShader(blob->GetBufferPointer(), blob->GetBufferSize(), nullptr, shader.put());
-	if (FAILED(hr))
-	{
-		Console.Error("Failed to create compute shader: 0x%08X", hr);
-		return {};
-	}
-
-	return shader;
+	return D3D11::ShaderCompiler::CreatePixelShader(device, blob.get());
 }

-wil::com_ptr_nothrow<ID3DBlob> D3D11ShaderCache::CompileAndAddShaderBlob(const CacheIndexKey& key,
+wil::com_ptr_nothrow<ID3D11ComputeShader> D3D11::ShaderCache::GetComputeShader(ID3D11Device* device,
+	const std::string_view& shader_code, const D3D_SHADER_MACRO* macros /* = nullptr */, const char* entry_point /* = "main" */)
+{
+	wil::com_ptr_nothrow<ID3DBlob> blob = GetShaderBlob(ShaderCompiler::Type::Compute, shader_code, macros, entry_point);
+	if (!blob)
+		return {};
+
+	return D3D11::ShaderCompiler::CreateComputeShader(device, blob.get());
+}
+
+wil::com_ptr_nothrow<ID3DBlob> D3D11::ShaderCache::CompileAndAddShaderBlob(const CacheIndexKey& key,
 	const std::string_view& shader_code, const D3D_SHADER_MACRO* macros, const char* entry_point)
 {
-	wil::com_ptr_nothrow<ID3DBlob> blob =
-		D3D::CompileShader(key.shader_type, m_feature_level, m_debug, shader_code, macros, entry_point);
+	wil::com_ptr_nothrow<ID3DBlob> blob = ShaderCompiler::CompileShader(key.shader_type, m_feature_level, m_debug, shader_code, macros, entry_point);
 	if (!blob)
 		return {};

@@ -422,7 +386,7 @@ wil::com_ptr_nothrow<ID3DBlob> D3D11ShaderCache::CompileAndAddShaderBlob(const C
 		std::fflush(m_blob_file) != 0 || std::fwrite(&entry, sizeof(entry), 1, m_index_file) != 1 ||
 		std::fflush(m_index_file) != 0)
 	{
-		Console.Error("(GSShaderCache11::CompileAndAddShaderBlob) Failed to write shader blob to file");
+		Console.Error("(D3D11::ShaderCache::CompileAndAddShaderBlob) Failed to write shader blob to file");
 		return blob;
 	}

--- a/common/D3D11/ShaderCache.h
+++ b/common/D3D11/ShaderCache.h
@@ -0,0 +1,120 @@
+/*  PCSX2 - PS2 Emulator for PCs
+ *  Copyright (C) 2002-2022  PCSX2 Dev Team
+ *
+ *  PCSX2 is free software: you can redistribute it and/or modify it under the terms
+ *  of the GNU Lesser General Public License as published by the Free Software Found-
+ *  ation, either version 3 of the License, or (at your option) any later version.
+ *
+ *  PCSX2 is distributed in the hope that it will be useful, but WITHOUT ANY WARRANTY;
+ *  without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR
+ *  PURPOSE.  See the GNU General Public License for more details.
+ *
+ *  You should have received a copy of the GNU General Public License along with PCSX2.
+ *  If not, see <http://www.gnu.org/licenses/>.
+ */
+
+#pragma once
+#include "common/Pcsx2Defs.h"
+#include "common/HashCombine.h"
+#include "common/RedtapeWindows.h"
+#include "common/RedtapeWilCom.h"
+#include "common/D3D11/ShaderCompiler.h"
+
+#include <cstdio>
+#include <d3d11.h>
+#include <string_view>
+#include <unordered_map>
+#include <vector>
+
+namespace D3D11
+{
+	class ShaderCache
+	{
+	public:
+		ShaderCache();
+		~ShaderCache();
+
+		D3D_FEATURE_LEVEL GetFeatureLevel() const { return m_feature_level; }
+		bool UsingDebugShaders() const { return m_debug; }
+
+		bool Open(std::string_view base_path, D3D_FEATURE_LEVEL feature_level, u32 version, bool debug);
+
+		wil::com_ptr_nothrow<ID3DBlob> GetShaderBlob(ShaderCompiler::Type type, const std::string_view& shader_code,
+			const D3D_SHADER_MACRO* macros = nullptr, const char* entry_point = "main");
+
+		wil::com_ptr_nothrow<ID3D11VertexShader> GetVertexShader(ID3D11Device* device, const std::string_view& shader_code,
+			const D3D_SHADER_MACRO* macros = nullptr, const char* entry_point = "main");
+
+		bool GetVertexShaderAndInputLayout(ID3D11Device* device,
+			ID3D11VertexShader** vs, ID3D11InputLayout** il,
+			const D3D11_INPUT_ELEMENT_DESC* layout, size_t layout_size,
+			const std::string_view& shader_code, const D3D_SHADER_MACRO* macros = nullptr, const char* entry_point = "main");
+
+		wil::com_ptr_nothrow<ID3D11GeometryShader> GetGeometryShader(ID3D11Device* device, const std::string_view& shader_code,
+			const D3D_SHADER_MACRO* macros = nullptr, const char* entry_point = "main");
+
+		wil::com_ptr_nothrow<ID3D11PixelShader> GetPixelShader(ID3D11Device* device, const std::string_view& shader_code,
+			const D3D_SHADER_MACRO* macros = nullptr, const char* entry_point = "main");
+
+		wil::com_ptr_nothrow<ID3D11ComputeShader> GetComputeShader(ID3D11Device* device, const std::string_view& shader_code,
+			const D3D_SHADER_MACRO* macros = nullptr, const char* entry_point = "main");
+
+	private:
+		static constexpr u32 FILE_VERSION = 1;
+
+		struct CacheIndexKey
+		{
+			u64 source_hash_low;
+			u64 source_hash_high;
+			u64 macro_hash_low;
+			u64 macro_hash_high;
+			u64 entry_point_low;
+			u64 entry_point_high;
+			u32 source_length;
+			ShaderCompiler::Type shader_type;
+
+			bool operator==(const CacheIndexKey& key) const;
+			bool operator!=(const CacheIndexKey& key) const;
+		};
+
+		struct CacheIndexEntryHasher
+		{
+			std::size_t operator()(const CacheIndexKey& e) const noexcept
+			{
+				std::size_t h = 0;
+				HashCombine(h, e.entry_point_low, e.entry_point_high, e.macro_hash_low, e.macro_hash_high,
+					e.source_hash_low, e.source_hash_high, e.source_length, e.shader_type);
+				return h;
+			}
+		};
+
+		struct CacheIndexData
+		{
+			u32 file_offset;
+			u32 blob_size;
+		};
+
+		using CacheIndex = std::unordered_map<CacheIndexKey, CacheIndexData, CacheIndexEntryHasher>;
+
+		static std::string GetCacheBaseFileName(const std::string_view& base_path, D3D_FEATURE_LEVEL feature_level,
+			bool debug);
+		static CacheIndexKey GetCacheKey(ShaderCompiler::Type type, const std::string_view& shader_code,
+			const D3D_SHADER_MACRO* macros, const char* entry_point);
+
+		bool CreateNew(const std::string& index_filename, const std::string& blob_filename);
+		bool ReadExisting(const std::string& index_filename, const std::string& blob_filename);
+		void Close();
+
+		wil::com_ptr_nothrow<ID3DBlob> CompileAndAddShaderBlob(const CacheIndexKey& key, const std::string_view& shader_code,
+			const D3D_SHADER_MACRO* macros, const char* entry_point);
+
+		std::FILE* m_index_file = nullptr;
+		std::FILE* m_blob_file = nullptr;
+
+		CacheIndex m_index;
+
+		D3D_FEATURE_LEVEL m_feature_level = D3D_FEATURE_LEVEL_11_0;
+		u32 m_version = 0;
+		bool m_debug = false;
+	};
+} // namespace D3D11
--- a/common/D3D11/ShaderCompiler.cpp
+++ b/common/D3D11/ShaderCompiler.cpp
@@ -0,0 +1,215 @@
+/*  PCSX2 - PS2 Emulator for PCs
+ *  Copyright (C) 2002-2022  PCSX2 Dev Team
+ *
+ *  PCSX2 is free software: you can redistribute it and/or modify it under the terms
+ *  of the GNU Lesser General Public License as published by the Free Software Found-
+ *  ation, either version 3 of the License, or (at your option) any later version.
+ *
+ *  PCSX2 is distributed in the hope that it will be useful, but WITHOUT ANY WARRANTY;
+ *  without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR
+ *  PURPOSE.  See the GNU General Public License for more details.
+ *
+ *  You should have received a copy of the GNU General Public License along with PCSX2.
+ *  If not, see <http://www.gnu.org/licenses/>.
+ */
+
+#include "common/PrecompiledHeader.h"
+#include "common/D3D11/ShaderCompiler.h"
+#include "common/Console.h"
+#include "common/StringUtil.h"
+#include <array>
+#include <d3dcompiler.h>
+#include <fstream>
+
+static unsigned s_next_bad_shader_id = 1;
+
+wil::com_ptr_nothrow<ID3DBlob> D3D11::ShaderCompiler::CompileShader(Type type, D3D_FEATURE_LEVEL feature_level, bool debug,
+	const std::string_view& code, const D3D_SHADER_MACRO* macros /* = nullptr */, const char* entry_point /* = "main" */)
+{
+	const char* target;
+	switch (feature_level)
+	{
+		case D3D_FEATURE_LEVEL_10_0:
+		{
+			static constexpr std::array<const char*, 4> targets = {{"vs_4_0", "gs_4_0", "ps_4_0", "cs_4_0"}};
+			target = targets[static_cast<int>(type)];
+		}
+		break;
+
+		case D3D_FEATURE_LEVEL_10_1:
+		{
+			static constexpr std::array<const char*, 4> targets = {{"vs_4_1", "gs_4_1", "ps_4_1", "cs_4_1"}};
+			target = targets[static_cast<int>(type)];
+		}
+		break;
+
+		case D3D_FEATURE_LEVEL_11_0:
+		{
+			static constexpr std::array<const char*, 4> targets = {{"vs_5_0", "gs_5_0", "ps_5_0", "cs_5_0"}};
+			target = targets[static_cast<int>(type)];
+		}
+		break;
+
+		case D3D_FEATURE_LEVEL_11_1:
+		default:
+		{
+			static constexpr std::array<const char*, 4> targets = {{"vs_5_1", "gs_5_1", "ps_5_1", "cs_5_1"}};
+			target = targets[static_cast<int>(type)];
+		}
+		break;
+	}
+
+	static constexpr UINT flags_non_debug = D3DCOMPILE_OPTIMIZATION_LEVEL3;
+	static constexpr UINT flags_debug = D3DCOMPILE_SKIP_OPTIMIZATION | D3DCOMPILE_DEBUG;
+
+	wil::com_ptr_nothrow<ID3DBlob> blob;
+	wil::com_ptr_nothrow<ID3DBlob> error_blob;
+	const HRESULT hr =
+		D3DCompile(code.data(), code.size(), "0", macros, nullptr, entry_point, target, debug ? flags_debug : flags_non_debug,
+			0, blob.put(), error_blob.put());
+
+	std::string error_string;
+	if (error_blob)
+	{
+		error_string.append(static_cast<const char*>(error_blob->GetBufferPointer()), error_blob->GetBufferSize());
+		error_blob.reset();
+	}
+
+	if (FAILED(hr))
+	{
+		Console.WriteLn("Failed to compile '%s':\n%s", target, error_string.c_str());
+
+		std::ofstream ofs(StringUtil::StdStringFromFormat("bad_shader_%u.txt", s_next_bad_shader_id++).c_str(),
+			std::ofstream::out | std::ofstream::binary);
+		if (ofs.is_open())
+		{
+			ofs << code;
+			ofs << "\n\nCompile as " << target << " failed: " << hr << "\n";
+			ofs.write(error_string.c_str(), error_string.size());
+			ofs.close();
+		}
+
+		return {};
+	}
+
+	if (!error_string.empty())
+		Console.Warning("'%s' compiled with warnings:\n%s", target, error_string.c_str());
+
+	return blob;
+}
+
+wil::com_ptr_nothrow<ID3D11VertexShader> D3D11::ShaderCompiler::CompileAndCreateVertexShader(ID3D11Device* device, bool debug,
+	const std::string_view& code, const D3D_SHADER_MACRO* macros /* = nullptr */, const char* entry_point /* = "main" */)
+{
+	wil::com_ptr_nothrow<ID3DBlob> blob = CompileShader(Type::Vertex, device->GetFeatureLevel(), debug, code, macros, entry_point);
+	if (!blob)
+		return {};
+
+	return CreateVertexShader(device, blob.get());
+}
+
+wil::com_ptr_nothrow<ID3D11GeometryShader> D3D11::ShaderCompiler::CompileAndCreateGeometryShader(ID3D11Device* device, bool debug,
+	const std::string_view& code, const D3D_SHADER_MACRO* macros /* = nullptr */, const char* entry_point /* = "main" */)
+{
+	wil::com_ptr_nothrow<ID3DBlob> blob = CompileShader(Type::Geometry, device->GetFeatureLevel(), debug, code, macros, entry_point);
+	if (!blob)
+		return {};
+
+	return CreateGeometryShader(device, blob.get());
+}
+
+wil::com_ptr_nothrow<ID3D11PixelShader> D3D11::ShaderCompiler::CompileAndCreatePixelShader(ID3D11Device* device, bool debug,
+	const std::string_view& code, const D3D_SHADER_MACRO* macros /* = nullptr */, const char* entry_point /* = "main" */)
+{
+	wil::com_ptr_nothrow<ID3DBlob> blob = CompileShader(Type::Pixel, device->GetFeatureLevel(), debug, code, macros, entry_point);
+	if (!blob)
+		return {};
+
+	return CreatePixelShader(device, blob.get());
+}
+
+wil::com_ptr_nothrow<ID3D11ComputeShader> D3D11::ShaderCompiler::CompileAndCreateComputeShader(ID3D11Device* device, bool debug,
+	const std::string_view& code, const D3D_SHADER_MACRO* macros /* = nullptr */, const char* entry_point /* = "main" */)
+{
+	wil::com_ptr_nothrow<ID3DBlob> blob = CompileShader(Type::Compute, device->GetFeatureLevel(), debug, code, macros, entry_point);
+	if (!blob)
+		return {};
+
+	return CreateComputeShader(device, blob.get());
+}
+
+wil::com_ptr_nothrow<ID3D11VertexShader> D3D11::ShaderCompiler::CreateVertexShader(ID3D11Device* device, const void* bytecode, size_t bytecode_length)
+{
+	wil::com_ptr_nothrow<ID3D11VertexShader> shader;
+	const HRESULT hr = device->CreateVertexShader(bytecode, bytecode_length, nullptr, shader.put());
+	if (FAILED(hr))
+	{
+		Console.Error("Failed to create vertex shader: 0x%08X", hr);
+		return {};
+	}
+
+	return shader;
+}
+
+wil::com_ptr_nothrow<ID3D11VertexShader> D3D11::ShaderCompiler::CreateVertexShader(ID3D11Device* device, const ID3DBlob* blob)
+{
+	return CreateVertexShader(device, const_cast<ID3DBlob*>(blob)->GetBufferPointer(),
+		const_cast<ID3DBlob*>(blob)->GetBufferSize());
+}
+
+wil::com_ptr_nothrow<ID3D11GeometryShader> D3D11::ShaderCompiler::CreateGeometryShader(ID3D11Device* device, const void* bytecode, size_t bytecode_length)
+{
+	wil::com_ptr_nothrow<ID3D11GeometryShader> shader;
+	const HRESULT hr = device->CreateGeometryShader(bytecode, bytecode_length, nullptr, shader.put());
+	if (FAILED(hr))
+	{
+		Console.Error("Failed to create geometry shader: 0x%08X", hr);
+		return {};
+	}
+
+	return shader;
+}
+
+wil::com_ptr_nothrow<ID3D11GeometryShader> D3D11::ShaderCompiler::CreateGeometryShader(ID3D11Device* device, const ID3DBlob* blob)
+{
+	return CreateGeometryShader(device, const_cast<ID3DBlob*>(blob)->GetBufferPointer(),
+		const_cast<ID3DBlob*>(blob)->GetBufferSize());
+}
+
+wil::com_ptr_nothrow<ID3D11PixelShader> D3D11::ShaderCompiler::CreatePixelShader(ID3D11Device* device, const void* bytecode, size_t bytecode_length)
+{
+	wil::com_ptr_nothrow<ID3D11PixelShader> shader;
+	const HRESULT hr = device->CreatePixelShader(bytecode, bytecode_length, nullptr, shader.put());
+	if (FAILED(hr))
+	{
+		Console.Error("Failed to create pixel shader: 0x%08X", hr);
+		return {};
+	}
+
+	return shader;
+}
+
+wil::com_ptr_nothrow<ID3D11PixelShader> D3D11::ShaderCompiler::CreatePixelShader(ID3D11Device* device, const ID3DBlob* blob)
+{
+	return CreatePixelShader(device, const_cast<ID3DBlob*>(blob)->GetBufferPointer(),
+		const_cast<ID3DBlob*>(blob)->GetBufferSize());
+}
+
+wil::com_ptr_nothrow<ID3D11ComputeShader> D3D11::ShaderCompiler::CreateComputeShader(ID3D11Device* device, const void* bytecode, size_t bytecode_length)
+{
+	wil::com_ptr_nothrow<ID3D11ComputeShader> shader;
+	const HRESULT hr = device->CreateComputeShader(bytecode, bytecode_length, nullptr, shader.put());
+	if (FAILED(hr))
+	{
+		Console.Error("Failed to create compute shader: 0x%08X", hr);
+		return {};
+	}
+
+	return shader;
+}
+
+wil::com_ptr_nothrow<ID3D11ComputeShader> D3D11::ShaderCompiler::CreateComputeShader(ID3D11Device* device, const ID3DBlob* blob)
+{
+	return CreateComputeShader(device, const_cast<ID3DBlob*>(blob)->GetBufferPointer(),
+		const_cast<ID3DBlob*>(blob)->GetBufferSize());
+}
--- a/common/D3D11/ShaderCompiler.h
+++ b/common/D3D11/ShaderCompiler.h
@@ -0,0 +1,55 @@
+/*  PCSX2 - PS2 Emulator for PCs
+ *  Copyright (C) 2002-2022  PCSX2 Dev Team
+ *
+ *  PCSX2 is free software: you can redistribute it and/or modify it under the terms
+ *  of the GNU Lesser General Public License as published by the Free Software Found-
+ *  ation, either version 3 of the License, or (at your option) any later version.
+ *
+ *  PCSX2 is distributed in the hope that it will be useful, but WITHOUT ANY WARRANTY;
+ *  without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR
+ *  PURPOSE.  See the GNU General Public License for more details.
+ *
+ *  You should have received a copy of the GNU General Public License along with PCSX2.
+ *  If not, see <http://www.gnu.org/licenses/>.
+ */
+
+#pragma once
+
+#include "common/RedtapeWindows.h"
+#include "common/RedtapeWilCom.h"
+
+#include <d3d11.h>
+#include <string_view>
+#include <type_traits>
+
+namespace D3D11::ShaderCompiler
+{
+	enum class Type
+	{
+		Vertex,
+		Geometry,
+		Pixel,
+		Compute
+	};
+
+	wil::com_ptr_nothrow<ID3DBlob> CompileShader(Type type, D3D_FEATURE_LEVEL feature_level, bool debug, const std::string_view& code,
+		const D3D_SHADER_MACRO* macros = nullptr, const char* entry_point = "main");
+
+	wil::com_ptr_nothrow<ID3D11VertexShader> CompileAndCreateVertexShader(ID3D11Device* device, bool debug, const std::string_view& code,
+		const D3D_SHADER_MACRO* macros = nullptr, const char* entry_point = "main");
+	wil::com_ptr_nothrow<ID3D11GeometryShader> CompileAndCreateGeometryShader(ID3D11Device* device, bool debug, const std::string_view& code,
+		const D3D_SHADER_MACRO* macros = nullptr, const char* entry_point = "main");
+	wil::com_ptr_nothrow<ID3D11PixelShader> CompileAndCreatePixelShader(ID3D11Device* device, bool debug, const std::string_view& code,
+		const D3D_SHADER_MACRO* macros = nullptr, const char* entry_point = "main");
+	wil::com_ptr_nothrow<ID3D11ComputeShader> CompileAndCreateComputeShader(ID3D11Device* device, bool debug, const std::string_view& code,
+		const D3D_SHADER_MACRO* macros = nullptr, const char* entry_point = "main");
+
+	wil::com_ptr_nothrow<ID3D11VertexShader> CreateVertexShader(ID3D11Device* device, const void* bytecode, size_t bytecode_length);
+	wil::com_ptr_nothrow<ID3D11VertexShader> CreateVertexShader(ID3D11Device* device, const ID3DBlob* blob);
+	wil::com_ptr_nothrow<ID3D11GeometryShader> CreateGeometryShader(ID3D11Device* device, const void* bytecode, size_t bytecode_length);
+	wil::com_ptr_nothrow<ID3D11GeometryShader> CreateGeometryShader(ID3D11Device* device, const ID3DBlob* blob);
+	wil::com_ptr_nothrow<ID3D11PixelShader> CreatePixelShader(ID3D11Device* device, const void* bytecode, size_t bytecode_length);
+	wil::com_ptr_nothrow<ID3D11PixelShader> CreatePixelShader(ID3D11Device* device, const ID3DBlob* blob);
+	wil::com_ptr_nothrow<ID3D11ComputeShader> CreateComputeShader(ID3D11Device* device, const void* bytecode, size_t bytecode_length);
+	wil::com_ptr_nothrow<ID3D11ComputeShader> CreateComputeShader(ID3D11Device* device, const ID3DBlob* blob);
+}; // namespace D3D11::ShaderCompiler
--- a/pcsx2/GS/Renderers/DX12/D3D12Builders.cpp
+++ b/pcsx2/GS/Renderers/DX12/D3D12Builders.cpp
@@ -1,5 +1,5 @@
 /*  PCSX2 - PS2 Emulator for PCs
- *  Copyright (C) 2002-2023  PCSX2 Dev Team
+ *  Copyright (C) 2002-2022  PCSX2 Dev Team
 *
 *  PCSX2 is free software: you can redistribute it and/or modify it under the terms
 *  of the GNU Lesser General Public License as published by the Free Software Found-
@@ -13,22 +13,24 @@
 *  If not, see <http://www.gnu.org/licenses/>.
 */

-#include "PrecompiledHeader.h"
+#include "common/PrecompiledHeader.h"

-#include "GS/Renderers/DX12/D3D12Builders.h"
-#include "GS/Renderers/DX12/D3D12Context.h"
-#include "GS/Renderers/DX12/D3D12ShaderCache.h"
+#include "common/D3D12/Builders.h"
+#include "common/D3D12/Context.h"
+#include "common/D3D12/ShaderCache.h"
 #include "common/Console.h"

 #include <cstdarg>
 #include <limits>

-D3D12::GraphicsPipelineBuilder::GraphicsPipelineBuilder()
+using namespace D3D12;
+
+GraphicsPipelineBuilder::GraphicsPipelineBuilder()
 {
 	Clear();
 }

-void D3D12::GraphicsPipelineBuilder::Clear()
+void GraphicsPipelineBuilder::Clear()
 {
 	std::memset(&m_desc, 0, sizeof(m_desc));
 	std::memset(m_input_elements.data(), 0, sizeof(D3D12_INPUT_ELEMENT_DESC) * m_input_elements.size());
@@ -37,8 +39,7 @@ void D3D12::GraphicsPipelineBuilder::Clear()
 	m_desc.SampleDesc.Count = 1;
 }

-wil::com_ptr_nothrow<ID3D12PipelineState> D3D12::GraphicsPipelineBuilder::Create(
-	ID3D12Device* device, bool clear /*= true*/)
+wil::com_ptr_nothrow<ID3D12PipelineState> GraphicsPipelineBuilder::Create(ID3D12Device* device, bool clear /*= true*/)
 {
 	wil::com_ptr_nothrow<ID3D12PipelineState> ps;
 	HRESULT hr = device->CreateGraphicsPipelineState(&m_desc, IID_PPV_ARGS(ps.put()));
@@ -54,8 +55,8 @@ wil::com_ptr_nothrow<ID3D12PipelineState> D3D12::GraphicsPipelineBuilder::Create
 	return ps;
 }

-wil::com_ptr_nothrow<ID3D12PipelineState> D3D12::GraphicsPipelineBuilder::Create(
-	ID3D12Device* device, D3D12ShaderCache& cache, bool clear /*= true*/)
+wil::com_ptr_nothrow<ID3D12PipelineState> GraphicsPipelineBuilder::Create(ID3D12Device* device, ShaderCache& cache,
+	bool clear /*= true*/)
 {
 	wil::com_ptr_nothrow<ID3D12PipelineState> pso = cache.GetPipelineState(device, m_desc);
 	if (!pso)
@@ -67,49 +68,46 @@ wil::com_ptr_nothrow<ID3D12PipelineState> D3D12::GraphicsPipelineBuilder::Create
 	return pso;
 }

-void D3D12::GraphicsPipelineBuilder::SetRootSignature(ID3D12RootSignature* rs)
+void GraphicsPipelineBuilder::SetRootSignature(ID3D12RootSignature* rs)
 {
 	m_desc.pRootSignature = rs;
 }

-void D3D12::GraphicsPipelineBuilder::SetVertexShader(const ID3DBlob* blob)
+void GraphicsPipelineBuilder::SetVertexShader(const ID3DBlob* blob)
 {
-	SetVertexShader(const_cast<ID3DBlob*>(blob)->GetBufferPointer(),
-		static_cast<u32>(const_cast<ID3DBlob*>(blob)->GetBufferSize()));
+	SetVertexShader(const_cast<ID3DBlob*>(blob)->GetBufferPointer(), static_cast<u32>(const_cast<ID3DBlob*>(blob)->GetBufferSize()));
 }

-void D3D12::GraphicsPipelineBuilder::SetVertexShader(const void* data, u32 data_size)
+void GraphicsPipelineBuilder::SetVertexShader(const void* data, u32 data_size)
 {
 	m_desc.VS.pShaderBytecode = data;
 	m_desc.VS.BytecodeLength = data_size;
 }

-void D3D12::GraphicsPipelineBuilder::SetGeometryShader(const ID3DBlob* blob)
+void GraphicsPipelineBuilder::SetGeometryShader(const ID3DBlob* blob)
 {
-	SetGeometryShader(const_cast<ID3DBlob*>(blob)->GetBufferPointer(),
-		static_cast<u32>(const_cast<ID3DBlob*>(blob)->GetBufferSize()));
+	SetGeometryShader(const_cast<ID3DBlob*>(blob)->GetBufferPointer(), static_cast<u32>(const_cast<ID3DBlob*>(blob)->GetBufferSize()));
 }

-void D3D12::GraphicsPipelineBuilder::SetGeometryShader(const void* data, u32 data_size)
+void GraphicsPipelineBuilder::SetGeometryShader(const void* data, u32 data_size)
 {
 	m_desc.GS.pShaderBytecode = data;
 	m_desc.GS.BytecodeLength = data_size;
 }

-void D3D12::GraphicsPipelineBuilder::SetPixelShader(const ID3DBlob* blob)
+void GraphicsPipelineBuilder::SetPixelShader(const ID3DBlob* blob)
 {
-	SetPixelShader(const_cast<ID3DBlob*>(blob)->GetBufferPointer(),
-		static_cast<u32>(const_cast<ID3DBlob*>(blob)->GetBufferSize()));
+	SetPixelShader(const_cast<ID3DBlob*>(blob)->GetBufferPointer(), static_cast<u32>(const_cast<ID3DBlob*>(blob)->GetBufferSize()));
 }

-void D3D12::GraphicsPipelineBuilder::SetPixelShader(const void* data, u32 data_size)
+void GraphicsPipelineBuilder::SetPixelShader(const void* data, u32 data_size)
 {
 	m_desc.PS.pShaderBytecode = data;
 	m_desc.PS.BytecodeLength = data_size;
 }

-void D3D12::GraphicsPipelineBuilder::AddVertexAttribute(
-	const char* semantic_name, u32 semantic_index, DXGI_FORMAT format, u32 buffer, u32 offset)
+void GraphicsPipelineBuilder::AddVertexAttribute(const char* semantic_name, u32 semantic_index, DXGI_FORMAT format,
+	u32 buffer, u32 offset)
 {
 	const u32 index = m_desc.InputLayout.NumElements;
 	m_input_elements[index].SemanticIndex = semantic_index;
@@ -124,38 +122,38 @@ void D3D12::GraphicsPipelineBuilder::AddVertexAttribute(
 	m_desc.InputLayout.NumElements++;
 }

-void D3D12::GraphicsPipelineBuilder::SetPrimitiveTopologyType(D3D12_PRIMITIVE_TOPOLOGY_TYPE type)
+void GraphicsPipelineBuilder::SetPrimitiveTopologyType(D3D12_PRIMITIVE_TOPOLOGY_TYPE type)
 {
 	m_desc.PrimitiveTopologyType = type;
 }

-void D3D12::GraphicsPipelineBuilder::SetRasterizationState(
-	D3D12_FILL_MODE polygon_mode, D3D12_CULL_MODE cull_mode, bool front_face_ccw)
+void GraphicsPipelineBuilder::SetRasterizationState(D3D12_FILL_MODE polygon_mode, D3D12_CULL_MODE cull_mode,
+	bool front_face_ccw)
 {
 	m_desc.RasterizerState.FillMode = polygon_mode;
 	m_desc.RasterizerState.CullMode = cull_mode;
 	m_desc.RasterizerState.FrontCounterClockwise = front_face_ccw;
 }

-void D3D12::GraphicsPipelineBuilder::SetMultisamples(u32 multisamples)
+void GraphicsPipelineBuilder::SetMultisamples(u32 multisamples)
 {
 	m_desc.RasterizerState.MultisampleEnable = multisamples > 1;
 	m_desc.SampleDesc.Count = multisamples;
 }

-void D3D12::GraphicsPipelineBuilder::SetNoCullRasterizationState()
+void GraphicsPipelineBuilder::SetNoCullRasterizationState()
 {
 	SetRasterizationState(D3D12_FILL_MODE_SOLID, D3D12_CULL_MODE_NONE, false);
 }

-void D3D12::GraphicsPipelineBuilder::SetDepthState(bool depth_test, bool depth_write, D3D12_COMPARISON_FUNC compare_op)
+void GraphicsPipelineBuilder::SetDepthState(bool depth_test, bool depth_write, D3D12_COMPARISON_FUNC compare_op)
 {
 	m_desc.DepthStencilState.DepthEnable = depth_test;
 	m_desc.DepthStencilState.DepthWriteMask = depth_write ? D3D12_DEPTH_WRITE_MASK_ALL : D3D12_DEPTH_WRITE_MASK_ZERO;
 	m_desc.DepthStencilState.DepthFunc = compare_op;
 }

-void D3D12::GraphicsPipelineBuilder::SetStencilState(bool stencil_test, u8 read_mask, u8 write_mask,
+void GraphicsPipelineBuilder::SetStencilState(bool stencil_test, u8 read_mask, u8 write_mask,
 	const D3D12_DEPTH_STENCILOP_DESC& front, const D3D12_DEPTH_STENCILOP_DESC& back)
 {
 	m_desc.DepthStencilState.StencilEnable = stencil_test;
@@ -165,20 +163,21 @@ void D3D12::GraphicsPipelineBuilder::SetStencilState(bool stencil_test, u8 read_
 	m_desc.DepthStencilState.BackFace = back;
 }

-void D3D12::GraphicsPipelineBuilder::SetNoDepthTestState()
+void GraphicsPipelineBuilder::SetNoDepthTestState()
 {
 	SetDepthState(false, false, D3D12_COMPARISON_FUNC_ALWAYS);
 }

-void D3D12::GraphicsPipelineBuilder::SetNoStencilState()
+void GraphicsPipelineBuilder::SetNoStencilState()
 {
 	D3D12_DEPTH_STENCILOP_DESC empty = {};
 	SetStencilState(false, 0, 0, empty, empty);
 }

-void D3D12::GraphicsPipelineBuilder::SetBlendState(u32 rt, bool blend_enable, D3D12_BLEND src_factor,
-	D3D12_BLEND dst_factor, D3D12_BLEND_OP op, D3D12_BLEND alpha_src_factor, D3D12_BLEND alpha_dst_factor,
-	D3D12_BLEND_OP alpha_op, u8 write_mask /*= 0xFF*/)
+void GraphicsPipelineBuilder::SetBlendState(u32 rt, bool blend_enable, D3D12_BLEND src_factor, D3D12_BLEND dst_factor,
+	D3D12_BLEND_OP op, D3D12_BLEND alpha_src_factor,
+	D3D12_BLEND alpha_dst_factor, D3D12_BLEND_OP alpha_op,
+	u8 write_mask /*= 0xFF*/)
 {
 	m_desc.BlendState.RenderTarget[rt].BlendEnable = blend_enable;
 	m_desc.BlendState.RenderTarget[rt].SrcBlend = src_factor;
@@ -193,49 +192,49 @@ void D3D12::GraphicsPipelineBuilder::SetBlendState(u32 rt, bool blend_enable, D3
 		m_desc.BlendState.IndependentBlendEnable = TRUE;
 }

-void D3D12::GraphicsPipelineBuilder::SetNoBlendingState()
+void GraphicsPipelineBuilder::SetNoBlendingState()
 {
 	SetBlendState(0, false, D3D12_BLEND_ONE, D3D12_BLEND_ZERO, D3D12_BLEND_OP_ADD, D3D12_BLEND_ONE, D3D12_BLEND_ZERO,
 		D3D12_BLEND_OP_ADD, D3D12_COLOR_WRITE_ENABLE_ALL);
 	m_desc.BlendState.IndependentBlendEnable = FALSE;
 }

-void D3D12::GraphicsPipelineBuilder::ClearRenderTargets()
+void GraphicsPipelineBuilder::ClearRenderTargets()
 {
 	m_desc.NumRenderTargets = 0;
 	for (u32 i = 0; i < sizeof(m_desc.RTVFormats) / sizeof(m_desc.RTVFormats[0]); i++)
 		m_desc.RTVFormats[i] = DXGI_FORMAT_UNKNOWN;
 }

-void D3D12::GraphicsPipelineBuilder::SetRenderTarget(u32 rt, DXGI_FORMAT format)
+void GraphicsPipelineBuilder::SetRenderTarget(u32 rt, DXGI_FORMAT format)
 {
 	m_desc.RTVFormats[rt] = format;
 	if (rt >= m_desc.NumRenderTargets)
 		m_desc.NumRenderTargets = rt + 1;
 }

-void D3D12::GraphicsPipelineBuilder::ClearDepthStencilFormat()
+void GraphicsPipelineBuilder::ClearDepthStencilFormat()
 {
 	m_desc.DSVFormat = DXGI_FORMAT_UNKNOWN;
 }

-void D3D12::GraphicsPipelineBuilder::SetDepthStencilFormat(DXGI_FORMAT format)
+void GraphicsPipelineBuilder::SetDepthStencilFormat(DXGI_FORMAT format)
 {
 	m_desc.DSVFormat = format;
 }

-D3D12::ComputePipelineBuilder::ComputePipelineBuilder()
+
+ComputePipelineBuilder::ComputePipelineBuilder()
 {
 	Clear();
 }

-void D3D12::ComputePipelineBuilder::Clear()
+void ComputePipelineBuilder::Clear()
 {
 	std::memset(&m_desc, 0, sizeof(m_desc));
 }

-wil::com_ptr_nothrow<ID3D12PipelineState> D3D12::ComputePipelineBuilder::Create(
-	ID3D12Device* device, bool clear /*= true*/)
+wil::com_ptr_nothrow<ID3D12PipelineState> ComputePipelineBuilder::Create(ID3D12Device* device, bool clear /*= true*/)
 {
 	wil::com_ptr_nothrow<ID3D12PipelineState> ps;
 	HRESULT hr = device->CreateComputePipelineState(&m_desc, IID_PPV_ARGS(ps.put()));
@@ -251,8 +250,7 @@ wil::com_ptr_nothrow<ID3D12PipelineState> D3D12::ComputePipelineBuilder::Create(
 	return ps;
 }

-wil::com_ptr_nothrow<ID3D12PipelineState> D3D12::ComputePipelineBuilder::Create(
-	ID3D12Device* device, D3D12ShaderCache& cache, bool clear /*= true*/)
+wil::com_ptr_nothrow<ID3D12PipelineState> ComputePipelineBuilder::Create(ID3D12Device* device, ShaderCache& cache, bool clear /*= true*/)
 {
 	wil::com_ptr_nothrow<ID3D12PipelineState> pso = cache.GetPipelineState(device, m_desc);
 	if (!pso)
@@ -264,23 +262,23 @@ wil::com_ptr_nothrow<ID3D12PipelineState> D3D12::ComputePipelineBuilder::Create(
 	return pso;
 }

-void D3D12::ComputePipelineBuilder::SetRootSignature(ID3D12RootSignature* rs)
+void ComputePipelineBuilder::SetRootSignature(ID3D12RootSignature* rs)
 {
 	m_desc.pRootSignature = rs;
 }

-void D3D12::ComputePipelineBuilder::SetShader(const void* data, u32 data_size)
+void ComputePipelineBuilder::SetShader(const void* data, u32 data_size)
 {
 	m_desc.CS.pShaderBytecode = data;
 	m_desc.CS.BytecodeLength = data_size;
 }

-D3D12::RootSignatureBuilder::RootSignatureBuilder()
+RootSignatureBuilder::RootSignatureBuilder()
 {
 	Clear();
 }

-void D3D12::RootSignatureBuilder::Clear()
+void RootSignatureBuilder::Clear()
 {
 	m_desc = {};
 	m_desc.pParameters = m_params.data();
@@ -289,7 +287,7 @@ void D3D12::RootSignatureBuilder::Clear()
 	m_num_descriptor_ranges = 0;
 }

-wil::com_ptr_nothrow<ID3D12RootSignature> D3D12::RootSignatureBuilder::Create(bool clear /*= true*/)
+wil::com_ptr_nothrow<ID3D12RootSignature> RootSignatureBuilder::Create(bool clear /*= true*/)
 {
 	wil::com_ptr_nothrow<ID3D12RootSignature> rs = g_d3d12_context->CreateRootSignature(&m_desc);
 	if (!rs)
@@ -301,12 +299,12 @@ wil::com_ptr_nothrow<ID3D12RootSignature> D3D12::RootSignatureBuilder::Create(bo
 	return rs;
 }

-void D3D12::RootSignatureBuilder::SetInputAssemblerFlag()
+void RootSignatureBuilder::SetInputAssemblerFlag()
 {
 	m_desc.Flags |= D3D12_ROOT_SIGNATURE_FLAG_ALLOW_INPUT_ASSEMBLER_INPUT_LAYOUT;
 }

-u32 D3D12::RootSignatureBuilder::Add32BitConstants(u32 shader_reg, u32 num_values, D3D12_SHADER_VISIBILITY visibility)
+u32 RootSignatureBuilder::Add32BitConstants(u32 shader_reg, u32 num_values, D3D12_SHADER_VISIBILITY visibility)
 {
 	const u32 index = m_desc.NumParameters++;

@@ -319,7 +317,7 @@ u32 D3D12::RootSignatureBuilder::Add32BitConstants(u32 shader_reg, u32 num_value
 	return index;
 }

-u32 D3D12::RootSignatureBuilder::AddCBVParameter(u32 shader_reg, D3D12_SHADER_VISIBILITY visibility)
+u32 RootSignatureBuilder::AddCBVParameter(u32 shader_reg, D3D12_SHADER_VISIBILITY visibility)
 {
 	const u32 index = m_desc.NumParameters++;

@@ -331,7 +329,7 @@ u32 D3D12::RootSignatureBuilder::AddCBVParameter(u32 shader_reg, D3D12_SHADER_VI
 	return index;
 }

-u32 D3D12::RootSignatureBuilder::AddSRVParameter(u32 shader_reg, D3D12_SHADER_VISIBILITY visibility)
+u32 RootSignatureBuilder::AddSRVParameter(u32 shader_reg, D3D12_SHADER_VISIBILITY visibility)
 {
 	const u32 index = m_desc.NumParameters++;

@@ -343,8 +341,8 @@ u32 D3D12::RootSignatureBuilder::AddSRVParameter(u32 shader_reg, D3D12_SHADER_VI
 	return index;
 }

-u32 D3D12::RootSignatureBuilder::AddDescriptorTable(
-	D3D12_DESCRIPTOR_RANGE_TYPE rt, u32 start_shader_reg, u32 num_shader_regs, D3D12_SHADER_VISIBILITY visibility)
+u32 RootSignatureBuilder::AddDescriptorTable(D3D12_DESCRIPTOR_RANGE_TYPE rt, u32 start_shader_reg, u32 num_shader_regs,
+	D3D12_SHADER_VISIBILITY visibility)
 {
 	const u32 index = m_desc.NumParameters++;
 	const u32 dr_index = m_num_descriptor_ranges++;
--- a/pcsx2/GS/Renderers/DX12/D3D12Builders.h
+++ b/pcsx2/GS/Renderers/DX12/D3D12Builders.h
@@ -1,5 +1,5 @@
 /*  PCSX2 - PS2 Emulator for PCs
- *  Copyright (C) 2002-2023  PCSX2 Dev Team
+ *  Copyright (C) 2002-2022  PCSX2 Dev Team
 *
 *  PCSX2 is free software: you can redistribute it and/or modify it under the terms
 *  of the GNU Lesser General Public License as published by the Free Software Found-
@@ -22,10 +22,10 @@
 #include <array>
 #include <d3d12.h>

-class D3D12ShaderCache;
-
 namespace D3D12
 {
+	class ShaderCache;
+
 	class RootSignatureBuilder
 	{
 	public:
@@ -71,8 +71,7 @@ namespace D3D12
 		void Clear();

 		wil::com_ptr_nothrow<ID3D12PipelineState> Create(ID3D12Device* device, bool clear = true);
-		wil::com_ptr_nothrow<ID3D12PipelineState> Create(
-			ID3D12Device* device, D3D12ShaderCache& cache, bool clear = true);
+		wil::com_ptr_nothrow<ID3D12PipelineState> Create(ID3D12Device* device, ShaderCache& cache, bool clear = true);

 		void SetRootSignature(ID3D12RootSignature* rs);

@@ -84,8 +83,7 @@ namespace D3D12
 		void SetGeometryShader(const ID3DBlob* blob);
 		void SetPixelShader(const ID3DBlob* blob);

-		void AddVertexAttribute(
-			const char* semantic_name, u32 semantic_index, DXGI_FORMAT format, u32 buffer, u32 offset);
+		void AddVertexAttribute(const char* semantic_name, u32 semantic_index, DXGI_FORMAT format, u32 buffer, u32 offset);

 		void SetPrimitiveTopologyType(D3D12_PRIMITIVE_TOPOLOGY_TYPE type);

@@ -96,8 +94,7 @@ namespace D3D12
 		void SetNoCullRasterizationState();

 		void SetDepthState(bool depth_test, bool depth_write, D3D12_COMPARISON_FUNC compare_op);
-		void SetStencilState(bool stencil_test, u8 read_mask, u8 write_mask, const D3D12_DEPTH_STENCILOP_DESC& front,
-			const D3D12_DEPTH_STENCILOP_DESC& back);
+		void SetStencilState(bool stencil_test, u8 read_mask, u8 write_mask, const D3D12_DEPTH_STENCILOP_DESC& front, const D3D12_DEPTH_STENCILOP_DESC& back);

 		void SetNoDepthTestState();
 		void SetNoStencilState();
@@ -130,13 +127,11 @@ namespace D3D12
 		void Clear();

 		wil::com_ptr_nothrow<ID3D12PipelineState> Create(ID3D12Device* device, bool clear = true);
-		wil::com_ptr_nothrow<ID3D12PipelineState> Create(
-			ID3D12Device* device, D3D12ShaderCache& cache, bool clear = true);
+		wil::com_ptr_nothrow<ID3D12PipelineState> Create(ID3D12Device* device, ShaderCache& cache, bool clear = true);

 		void SetRootSignature(ID3D12RootSignature* rs);

 		void SetShader(const void* data, u32 data_size);
-
 	private:
 		D3D12_COMPUTE_PIPELINE_STATE_DESC m_desc;
 	};
--- a/pcsx2/GS/Renderers/DX12/D3D12Context.cpp
+++ b/pcsx2/GS/Renderers/DX12/D3D12Context.cpp
@@ -1,5 +1,5 @@
 /*  PCSX2 - PS2 Emulator for PCs
- *  Copyright (C) 2002-2023  PCSX2 Dev Team
+ *  Copyright (C) 2002-2022  PCSX2 Dev Team
 *
 *  PCSX2 is free software: you can redistribute it and/or modify it under the terms
 *  of the GNU Lesser General Public License as published by the Free Software Found-
@@ -13,16 +13,13 @@
 *  If not, see <http://www.gnu.org/licenses/>.
 */

-#include "PrecompiledHeader.h"
-
-#include "GS/Renderers/DX12/D3D12Context.h"
+#include "common/PrecompiledHeader.h"

+#include "common/D3D12/Context.h"
 #include "common/Assertions.h"
-#include "common/Console.h"
 #include "common/General.h"
 #include "common/ScopedGuard.h"
-#include "common/StringUtil.h"
-
+#include "common/Console.h"
 #include "D3D12MemAlloc.h"

 #include <algorithm>
@@ -31,20 +28,64 @@
 #include <queue>
 #include <vector>

-std::unique_ptr<D3D12Context> g_d3d12_context;
+std::unique_ptr<D3D12::Context> g_d3d12_context;

-D3D12Context::D3D12Context() = default;
+using namespace D3D12;

-D3D12Context::~D3D12Context()
+// Private D3D12 state
+static HMODULE s_d3d12_library;
+static PFN_D3D12_CREATE_DEVICE s_d3d12_create_device;
+static PFN_D3D12_GET_DEBUG_INTERFACE s_d3d12_get_debug_interface;
+static PFN_D3D12_SERIALIZE_ROOT_SIGNATURE s_d3d12_serialize_root_signature;
+
+static bool LoadD3D12Library()
+{
+	if ((s_d3d12_library = LoadLibraryW(L"d3d12.dll")) == nullptr ||
+		(s_d3d12_create_device =
+				reinterpret_cast<PFN_D3D12_CREATE_DEVICE>(GetProcAddress(s_d3d12_library, "D3D12CreateDevice"))) == nullptr ||
+		(s_d3d12_get_debug_interface = reinterpret_cast<PFN_D3D12_GET_DEBUG_INTERFACE>(
+			 GetProcAddress(s_d3d12_library, "D3D12GetDebugInterface"))) == nullptr ||
+		(s_d3d12_serialize_root_signature = reinterpret_cast<PFN_D3D12_SERIALIZE_ROOT_SIGNATURE>(
+			 GetProcAddress(s_d3d12_library, "D3D12SerializeRootSignature"))) == nullptr)
+	{
+		Console.Error("d3d12.dll could not be loaded.");
+		s_d3d12_create_device = nullptr;
+		s_d3d12_get_debug_interface = nullptr;
+		s_d3d12_serialize_root_signature = nullptr;
+		if (s_d3d12_library)
+			FreeLibrary(s_d3d12_library);
+		s_d3d12_library = nullptr;
+		return false;
+	}
+
+	return true;
+}
+
+static void UnloadD3D12Library()
+{
+	s_d3d12_serialize_root_signature = nullptr;
+	s_d3d12_get_debug_interface = nullptr;
+	s_d3d12_create_device = nullptr;
+	if (s_d3d12_library)
+	{
+		FreeLibrary(s_d3d12_library);
+		s_d3d12_library = nullptr;
+	}
+}
+
+Context::Context() = default;
+
+Context::~Context()
 {
 	DestroyResources();
 }

-D3D12Context::ComPtr<ID3DBlob> D3D12Context::SerializeRootSignature(const D3D12_ROOT_SIGNATURE_DESC* desc)
+Context::ComPtr<ID3DBlob> Context::SerializeRootSignature(const D3D12_ROOT_SIGNATURE_DESC* desc)
 {
 	ComPtr<ID3DBlob> blob;
 	ComPtr<ID3DBlob> error_blob;
-	const HRESULT hr = D3D12SerializeRootSignature(desc, D3D_ROOT_SIGNATURE_VERSION_1, blob.put(), error_blob.put());
+	const HRESULT hr = s_d3d12_serialize_root_signature(desc, D3D_ROOT_SIGNATURE_VERSION_1, blob.put(),
+		error_blob.put());
 	if (FAILED(hr))
 	{
 		Console.Error("D3D12SerializeRootSignature() failed: %08X", hr);
@@ -57,7 +98,7 @@ D3D12Context::ComPtr<ID3DBlob> D3D12Context::SerializeRootSignature(const D3D12_
 	return blob;
 }

-D3D12Context::ComPtr<ID3D12RootSignature> D3D12Context::CreateRootSignature(const D3D12_ROOT_SIGNATURE_DESC* desc)
+D3D12::Context::ComPtr<ID3D12RootSignature> Context::CreateRootSignature(const D3D12_ROOT_SIGNATURE_DESC* desc)
 {
 	ComPtr<ID3DBlob> blob = SerializeRootSignature(desc);
 	if (!blob)
@@ -75,7 +116,7 @@ D3D12Context::ComPtr<ID3D12RootSignature> D3D12Context::CreateRootSignature(cons
 	return rs;
 }

-bool D3D12Context::SupportsTextureFormat(DXGI_FORMAT format)
+bool Context::SupportsTextureFormat(DXGI_FORMAT format)
 {
 	constexpr u32 required = D3D12_FORMAT_SUPPORT1_TEXTURE2D | D3D12_FORMAT_SUPPORT1_SHADER_SAMPLE;

@@ -84,12 +125,15 @@ bool D3D12Context::SupportsTextureFormat(DXGI_FORMAT format)
 		   (support.Support1 & required) == required;
 }

-bool D3D12Context::Create(IDXGIFactory5* dxgi_factory, IDXGIAdapter1* adapter, bool enable_debug_layer)
+bool Context::Create(IDXGIFactory* dxgi_factory, u32 adapter_index, bool enable_debug_layer)
 {
 	pxAssertRel(!g_d3d12_context, "No context exists");

-	g_d3d12_context.reset(new D3D12Context());
-	if (!g_d3d12_context->CreateDevice(dxgi_factory, adapter, enable_debug_layer) ||
+	if (!LoadD3D12Library())
+		return false;
+
+	g_d3d12_context.reset(new Context());
+	if (!g_d3d12_context->CreateDevice(dxgi_factory, adapter_index, enable_debug_layer) ||
 		!g_d3d12_context->CreateCommandQueue() || !g_d3d12_context->CreateAllocator() ||
 		!g_d3d12_context->CreateFence() || !g_d3d12_context->CreateDescriptorHeaps() ||
 		!g_d3d12_context->CreateCommandLists() || !g_d3d12_context->CreateTimestampQuery() ||
@@ -102,13 +146,15 @@ bool D3D12Context::Create(IDXGIFactory5* dxgi_factory, IDXGIAdapter1* adapter, b
 	return true;
 }

-void D3D12Context::Destroy()
+void Context::Destroy()
 {
 	if (g_d3d12_context)
 		g_d3d12_context.reset();
+
+	UnloadD3D12Library();
 }

-u32 D3D12Context::GetAdapterVendorID() const
+u32 Context::GetAdapterVendorID() const
 {
 	if (!m_adapter)
 		return 0;
@@ -120,14 +166,36 @@ u32 D3D12Context::GetAdapterVendorID() const
 	return desc.VendorId;
 }

-bool D3D12Context::CreateDevice(IDXGIFactory5* dxgi_factory, IDXGIAdapter1* adapter, bool enable_debug_layer)
+bool Context::CreateDevice(IDXGIFactory* dxgi_factory, u32 adapter_index, bool enable_debug_layer)
 {
-	HRESULT hr;
+	ComPtr<IDXGIAdapter> adapter;
+	HRESULT hr = dxgi_factory->EnumAdapters(adapter_index, &adapter);
+	if (FAILED(hr))
+	{
+		Console.Error("Adapter %u not found, using default", adapter_index);
+		adapter = nullptr;
+	}
+	else
+	{
+		DXGI_ADAPTER_DESC adapter_desc;
+		if (SUCCEEDED(adapter->GetDesc(&adapter_desc)))
+		{
+			char adapter_name_buffer[128];
+			const int name_length = WideCharToMultiByte(CP_UTF8, 0, adapter_desc.Description,
+				static_cast<int>(std::wcslen(adapter_desc.Description)),
+				adapter_name_buffer, std::size(adapter_name_buffer), 0, nullptr);
+			if (name_length >= 0)
+			{
+				adapter_name_buffer[name_length] = 0;
+				Console.WriteLn("D3D Adapter: %s", adapter_name_buffer);
+			}
+		}
+	}

 	// Enabling the debug layer will fail if the Graphics Tools feature is not installed.
 	if (enable_debug_layer)
 	{
-		hr = D3D12GetDebugInterface(IID_PPV_ARGS(&m_debug_interface));
+		hr = s_d3d12_get_debug_interface(IID_PPV_ARGS(&m_debug_interface));
 		if (SUCCEEDED(hr))
 		{
 			m_debug_interface->EnableDebugLayer();
@@ -140,17 +208,18 @@ bool D3D12Context::CreateDevice(IDXGIFactory5* dxgi_factory, IDXGIAdapter1* adap
 	}

 	// Create the actual device.
-	hr = D3D12CreateDevice(adapter, D3D_FEATURE_LEVEL_11_0, IID_PPV_ARGS(&m_device));
+	hr = s_d3d12_create_device(adapter.get(), D3D_FEATURE_LEVEL_11_0, IID_PPV_ARGS(&m_device));
 	if (FAILED(hr))
-	{
-		Console.Error("Failed to create D3D12 device: %08X", hr);
 		return false;
-	}

 	// get adapter
-	const LUID luid(m_device->GetAdapterLuid());
-	if (FAILED(dxgi_factory->EnumAdapterByLuid(luid, IID_PPV_ARGS(m_adapter.put()))))
-		Console.Error("Failed to get lookup adapter by device LUID");
+	ComPtr<IDXGIFactory4> dxgi_factory4;
+	if (SUCCEEDED(dxgi_factory->QueryInterface<IDXGIFactory4>(dxgi_factory4.put())))
+	{
+		const LUID luid(m_device->GetAdapterLuid());
+		if (FAILED(dxgi_factory4->EnumAdapterByLuid(luid, IID_PPV_ARGS(m_adapter.put()))))
+			Console.Error("Failed to get lookup adapter by device LUID");
+	}

 	if (enable_debug_layer)
 	{
@@ -180,23 +249,21 @@ bool D3D12Context::CreateDevice(IDXGIFactory5* dxgi_factory, IDXGIAdapter1* adap
 	return true;
 }

-bool D3D12Context::CreateCommandQueue()
+bool Context::CreateCommandQueue()
 {
-	const D3D12_COMMAND_QUEUE_DESC queue_desc = {
-		D3D12_COMMAND_LIST_TYPE_DIRECT, D3D12_COMMAND_QUEUE_PRIORITY_NORMAL, D3D12_COMMAND_QUEUE_FLAG_NONE};
+	const D3D12_COMMAND_QUEUE_DESC queue_desc = {D3D12_COMMAND_LIST_TYPE_DIRECT, D3D12_COMMAND_QUEUE_PRIORITY_NORMAL,
+		D3D12_COMMAND_QUEUE_FLAG_NONE};
 	HRESULT hr = m_device->CreateCommandQueue(&queue_desc, IID_PPV_ARGS(&m_command_queue));
 	pxAssertRel(SUCCEEDED(hr), "Create command queue");
 	return SUCCEEDED(hr);
 }

-bool D3D12Context::CreateAllocator()
+bool Context::CreateAllocator()
 {
 	D3D12MA::ALLOCATOR_DESC allocatorDesc = {};
 	allocatorDesc.pDevice = m_device.get();
 	allocatorDesc.pAdapter = m_adapter.get();
-	allocatorDesc.Flags =
-		D3D12MA::ALLOCATOR_FLAG_SINGLETHREADED |
-		D3D12MA::ALLOCATOR_FLAG_DEFAULT_POOLS_NOT_ZEROED /* | D3D12MA::ALLOCATOR_FLAG_ALWAYS_COMMITTED*/;
+	allocatorDesc.Flags = D3D12MA::ALLOCATOR_FLAG_SINGLETHREADED | D3D12MA::ALLOCATOR_FLAG_DEFAULT_POOLS_NOT_ZEROED /* | D3D12MA::ALLOCATOR_FLAG_ALWAYS_COMMITTED*/;

 	const HRESULT hr = D3D12MA::CreateAllocator(&allocatorDesc, m_allocator.put());
 	if (FAILED(hr))
@@ -208,7 +275,7 @@ bool D3D12Context::CreateAllocator()
 	return true;
 }

-bool D3D12Context::CreateFence()
+bool Context::CreateFence()
 {
 	HRESULT hr = m_device->CreateFence(m_completed_fence_value, D3D12_FENCE_FLAG_NONE, IID_PPV_ARGS(&m_fence));
 	pxAssertRel(SUCCEEDED(hr), "Create fence");
@@ -223,7 +290,7 @@ bool D3D12Context::CreateFence()
 	return true;
 }

-bool D3D12Context::CreateDescriptorHeaps()
+bool Context::CreateDescriptorHeaps()
 {
 	static constexpr size_t MAX_SRVS = 32768;
 	static constexpr size_t MAX_RTVS = 16384;
@@ -239,8 +306,8 @@ bool D3D12Context::CreateDescriptorHeaps()
 	}

 	// Allocate null SRV descriptor for unbound textures.
-	constexpr D3D12_SHADER_RESOURCE_VIEW_DESC null_srv_desc = {
-		DXGI_FORMAT_R8G8B8A8_UNORM, D3D12_SRV_DIMENSION_TEXTURE2D, D3D12_DEFAULT_SHADER_4_COMPONENT_MAPPING};
+	constexpr D3D12_SHADER_RESOURCE_VIEW_DESC null_srv_desc = {DXGI_FORMAT_R8G8B8A8_UNORM, D3D12_SRV_DIMENSION_TEXTURE2D,
+		D3D12_DEFAULT_SHADER_4_COMPONENT_MAPPING};

 	if (!m_descriptor_heap_manager.Allocate(&m_null_srv_descriptor))
 	{
@@ -252,7 +319,7 @@ bool D3D12Context::CreateDescriptorHeaps()
 	return true;
 }

-bool D3D12Context::CreateCommandLists()
+bool Context::CreateCommandLists()
 {
 	static constexpr size_t MAX_GPU_SRVS = 32768;
 	static constexpr size_t MAX_GPU_SAMPLERS = 2048;
@@ -264,14 +331,15 @@ bool D3D12Context::CreateCommandLists()

 		for (u32 i = 0; i < 2; i++)
 		{
-			hr = m_device->CreateCommandAllocator(
-				D3D12_COMMAND_LIST_TYPE_DIRECT, IID_PPV_ARGS(res.command_allocators[i].put()));
+			hr = m_device->CreateCommandAllocator(D3D12_COMMAND_LIST_TYPE_DIRECT,
+				IID_PPV_ARGS(res.command_allocators[i].put()));
 			pxAssertRel(SUCCEEDED(hr), "Create command allocator");
 			if (FAILED(hr))
 				return false;

-			hr = m_device->CreateCommandList(0, D3D12_COMMAND_LIST_TYPE_DIRECT, res.command_allocators[i].get(),
-				nullptr, IID_PPV_ARGS(res.command_lists[i].put()));
+			hr = m_device->CreateCommandList(0, D3D12_COMMAND_LIST_TYPE_DIRECT,
+				res.command_allocators[i].get(), nullptr,
+				IID_PPV_ARGS(res.command_lists[i].put()));
 			if (FAILED(hr))
 			{
 				Console.Error("Failed to create command list: %08X", hr);
@@ -302,12 +370,12 @@ bool D3D12Context::CreateCommandLists()
 	return true;
 }

-bool D3D12Context::CreateTextureStreamBuffer()
+bool Context::CreateTextureStreamBuffer()
 {
 	return m_texture_stream_buffer.Create(TEXTURE_UPLOAD_BUFFER_SIZE);
 }

-void D3D12Context::MoveToNextCommandList()
+void Context::MoveToNextCommandList()
 {
 	m_current_command_list = (m_current_command_list + 1) % NUM_COMMAND_LISTS;
 	m_current_fence_value++;
@@ -337,8 +405,7 @@ void D3D12Context::MoveToNextCommandList()
 		{
 			u64 timestamps[2];
 			std::memcpy(timestamps, static_cast<const u8*>(map) + offset, sizeof(timestamps));
-			m_accumulated_gpu_time +=
-				static_cast<float>(static_cast<double>(timestamps[1] - timestamps[0]) / m_timestamp_frequency);
+			m_accumulated_gpu_time += static_cast<float>(static_cast<double>(timestamps[1] - timestamps[0]) / m_timestamp_frequency);

 			const D3D12_RANGE write_range = {};
 			m_timestamp_query_buffer->Unmap(0, &write_range);
@@ -356,14 +423,13 @@ void D3D12Context::MoveToNextCommandList()
 			m_current_command_list * NUM_TIMESTAMP_QUERIES_PER_CMDLIST);
 	}

-	ID3D12DescriptorHeap* heaps[2] = {
-		res.descriptor_allocator.GetDescriptorHeap(), res.sampler_allocator.GetDescriptorHeap()};
+	ID3D12DescriptorHeap* heaps[2] = {res.descriptor_allocator.GetDescriptorHeap(), res.sampler_allocator.GetDescriptorHeap()};
 	res.command_lists[1]->SetDescriptorHeaps(std::size(heaps), heaps);

 	m_allocator->SetCurrentFrameIndex(static_cast<UINT>(m_current_fence_value));
 }

-ID3D12GraphicsCommandList4* D3D12Context::GetInitCommandList()
+ID3D12GraphicsCommandList4* Context::GetInitCommandList()
 {
 	CommandListResources& res = m_command_lists[m_current_command_list];
 	if (!res.init_command_list_used)
@@ -379,7 +445,7 @@ ID3D12GraphicsCommandList4* D3D12Context::GetInitCommandList()
 	return res.command_lists[0].get();
 }

-bool D3D12Context::ExecuteCommandList(WaitType wait_for_completion)
+void Context::ExecuteCommandList(WaitType wait_for_completion)
 {
 	CommandListResources& res = m_command_lists[m_current_command_list];
 	HRESULT hr;
@@ -397,21 +463,12 @@ bool D3D12Context::ExecuteCommandList(WaitType wait_for_completion)
 	if (res.init_command_list_used)
 	{
 		hr = res.command_lists[0]->Close();
-		if (FAILED(hr))
-		{
-			Console.Error("Closing init command list failed with HRESULT %08X", hr);
-			return false;
-		}
+		pxAssertRel(SUCCEEDED(hr), "Close init command list");
 	}

 	// Close and queue command list.
 	hr = res.command_lists[1]->Close();
-	if (FAILED(hr))
-	{
-		Console.Error("Closing main command list failed with HRESULT %08X", hr);
-		return false;
-	}
-
+	pxAssertRel(SUCCEEDED(hr), "Close command list");
 	if (res.init_command_list_used)
 	{
 		const std::array<ID3D12CommandList*, 2> execute_lists{res.command_lists[0].get(), res.command_lists[1].get()};
@@ -430,17 +487,15 @@ bool D3D12Context::ExecuteCommandList(WaitType wait_for_completion)
 	MoveToNextCommandList();
 	if (wait_for_completion != WaitType::None)
 		WaitForFence(res.ready_fence_value, wait_for_completion == WaitType::Spin);
-
-	return true;
 }

-void D3D12Context::InvalidateSamplerGroups()
+void Context::InvalidateSamplerGroups()
 {
 	for (CommandListResources& res : m_command_lists)
 		res.sampler_allocator.InvalidateCache();
 }

-void D3D12Context::DeferObjectDestruction(ID3D12DeviceChild* resource)
+void Context::DeferObjectDestruction(ID3D12DeviceChild* resource)
 {
 	if (!resource)
 		return;
@@ -449,7 +504,7 @@ void D3D12Context::DeferObjectDestruction(ID3D12DeviceChild* resource)
 	m_command_lists[m_current_command_list].pending_resources.emplace_back(nullptr, resource);
 }

-void D3D12Context::DeferResourceDestruction(D3D12MA::Allocation* allocation, ID3D12Resource* resource)
+void Context::DeferResourceDestruction(D3D12MA::Allocation* allocation, ID3D12Resource* resource)
 {
 	if (!resource)
 		return;
@@ -461,21 +516,21 @@ void D3D12Context::DeferResourceDestruction(D3D12MA::Allocation* allocation, ID3
 	m_command_lists[m_current_command_list].pending_resources.emplace_back(allocation, resource);
 }

-void D3D12Context::DeferDescriptorDestruction(D3D12DescriptorHeapManager& manager, u32 index)
+void Context::DeferDescriptorDestruction(DescriptorHeapManager& manager, u32 index)
 {
 	m_command_lists[m_current_command_list].pending_descriptors.emplace_back(manager, index);
 }

-void D3D12Context::DeferDescriptorDestruction(D3D12DescriptorHeapManager& manager, D3D12DescriptorHandle* handle)
+void Context::DeferDescriptorDestruction(DescriptorHeapManager& manager, DescriptorHandle* handle)
 {
-	if (handle->index == D3D12DescriptorHandle::INVALID_INDEX)
+	if (handle->index == DescriptorHandle::INVALID_INDEX)
 		return;

 	m_command_lists[m_current_command_list].pending_descriptors.emplace_back(manager, handle->index);
 	handle->Clear();
 }

-void D3D12Context::DestroyPendingResources(CommandListResources& cmdlist)
+void Context::DestroyPendingResources(CommandListResources& cmdlist)
 {
 	for (const auto& dd : cmdlist.pending_descriptors)
 		dd.first.Free(dd.second);
@@ -490,7 +545,7 @@ void D3D12Context::DestroyPendingResources(CommandListResources& cmdlist)
 	cmdlist.pending_resources.clear();
 }

-void D3D12Context::DestroyResources()
+void Context::DestroyResources()
 {
 	if (m_command_queue)
 	{
@@ -522,7 +577,7 @@ void D3D12Context::DestroyResources()
 	m_device.reset();
 }

-void D3D12Context::WaitForFence(u64 fence, bool spin)
+void Context::WaitForFence(u64 fence, bool spin)
 {
 	if (m_completed_fence_value >= fence)
 		return;
@@ -561,7 +616,7 @@ void D3D12Context::WaitForFence(u64 fence, bool spin)
 	}
 }

-void D3D12Context::WaitForGPUIdle()
+void Context::WaitForGPUIdle()
 {
 	u32 index = (m_current_command_list + 1) % NUM_COMMAND_LISTS;
 	for (u32 i = 0; i < (NUM_COMMAND_LISTS - 1); i++)
@@ -571,7 +626,7 @@ void D3D12Context::WaitForGPUIdle()
 	}
 }

-bool D3D12Context::CreateTimestampQuery()
+bool Context::CreateTimestampQuery()
 {
 	constexpr u32 QUERY_COUNT = NUM_TIMESTAMP_QUERIES_PER_CMDLIST * NUM_COMMAND_LISTS;
 	constexpr u32 BUFFER_SIZE = sizeof(u64) * QUERY_COUNT;
@@ -585,8 +640,9 @@ bool D3D12Context::CreateTimestampQuery()
 	}

 	const D3D12MA::ALLOCATION_DESC allocation_desc = {D3D12MA::ALLOCATION_FLAG_NONE, D3D12_HEAP_TYPE_READBACK};
-	const D3D12_RESOURCE_DESC resource_desc = {D3D12_RESOURCE_DIMENSION_BUFFER, 0, BUFFER_SIZE, 1, 1, 1,
-		DXGI_FORMAT_UNKNOWN, {1, 0}, D3D12_TEXTURE_LAYOUT_ROW_MAJOR, D3D12_RESOURCE_FLAG_NONE};
+	const D3D12_RESOURCE_DESC resource_desc = {
+		D3D12_RESOURCE_DIMENSION_BUFFER, 0, BUFFER_SIZE, 1, 1, 1, DXGI_FORMAT_UNKNOWN, {1, 0}, D3D12_TEXTURE_LAYOUT_ROW_MAJOR,
+		D3D12_RESOURCE_FLAG_NONE};
 	hr = m_allocator->CreateResource(&allocation_desc, &resource_desc, D3D12_RESOURCE_STATE_COPY_DEST, nullptr,
 		m_timestamp_query_allocation.put(), IID_PPV_ARGS(m_timestamp_query_buffer.put()));
 	if (FAILED(hr))
@@ -607,80 +663,14 @@ bool D3D12Context::CreateTimestampQuery()
 	return true;
 }

-float D3D12Context::GetAndResetAccumulatedGPUTime()
+float Context::GetAndResetAccumulatedGPUTime()
 {
 	const float time = m_accumulated_gpu_time;
 	m_accumulated_gpu_time = 0.0f;
 	return time;
 }

-void D3D12Context::SetEnableGPUTiming(bool enabled)
+void Context::SetEnableGPUTiming(bool enabled)
 {
 	m_gpu_timing_enabled = enabled;
 }
-
-bool D3D12Context::AllocatePreinitializedGPUBuffer(u32 size, ID3D12Resource** gpu_buffer,
-	D3D12MA::Allocation** gpu_allocation, const std::function<void(void*)>& fill_callback)
-{
-	// Try to place the fixed index buffer in GPU local memory.
-	// Use the staging buffer to copy into it.
-	const D3D12_RESOURCE_DESC rd = {D3D12_RESOURCE_DIMENSION_BUFFER, 0, size, 1, 1, 1, DXGI_FORMAT_UNKNOWN, {1, 0},
-		D3D12_TEXTURE_LAYOUT_ROW_MAJOR, D3D12_RESOURCE_FLAG_NONE};
-
-	const D3D12MA::ALLOCATION_DESC cpu_ad = {D3D12MA::ALLOCATION_FLAG_NONE, D3D12_HEAP_TYPE_UPLOAD};
-
-	ComPtr<ID3D12Resource> cpu_buffer;
-	ComPtr<D3D12MA::Allocation> cpu_allocation;
-	HRESULT hr = m_allocator->CreateResource(
-		&cpu_ad, &rd, D3D12_RESOURCE_STATE_GENERIC_READ, nullptr, cpu_allocation.put(), IID_PPV_ARGS(cpu_buffer.put()));
-	pxAssertMsg(SUCCEEDED(hr), "Allocate CPU buffer");
-	if (FAILED(hr))
-		return false;
-
-	static constexpr const D3D12_RANGE read_range = {};
-	const D3D12_RANGE write_range = {0, size};
-	void* mapped;
-	hr = cpu_buffer->Map(0, &read_range, &mapped);
-	pxAssertMsg(SUCCEEDED(hr), "Map CPU buffer");
-	if (FAILED(hr))
-		return false;
-	fill_callback(mapped);
-	cpu_buffer->Unmap(0, &write_range);
-
-	const D3D12MA::ALLOCATION_DESC gpu_ad = {D3D12MA::ALLOCATION_FLAG_COMMITTED, D3D12_HEAP_TYPE_DEFAULT};
-
-	hr = m_allocator->CreateResource(
-		&gpu_ad, &rd, D3D12_RESOURCE_STATE_COPY_DEST, nullptr, gpu_allocation, IID_PPV_ARGS(gpu_buffer));
-	pxAssertMsg(SUCCEEDED(hr), "Allocate GPU buffer");
-	if (FAILED(hr))
-		return false;
-
-	GetInitCommandList()->CopyBufferRegion(*gpu_buffer, 0, cpu_buffer.get(), 0, size);
-
-	D3D12_RESOURCE_BARRIER rb = {D3D12_RESOURCE_BARRIER_TYPE_TRANSITION, D3D12_RESOURCE_BARRIER_FLAG_NONE};
-	rb.Transition.Subresource = D3D12_RESOURCE_BARRIER_ALL_SUBRESOURCES;
-	rb.Transition.pResource = *gpu_buffer;
-	rb.Transition.StateBefore = D3D12_RESOURCE_STATE_COPY_DEST;
-	rb.Transition.StateAfter = D3D12_RESOURCE_STATE_INDEX_BUFFER;
-	GetInitCommandList()->ResourceBarrier(1, &rb);
-
-	DeferResourceDestruction(cpu_allocation.get(), cpu_buffer.get());
-	return true;
-}
-
-#ifdef _DEBUG
-
-void D3D12::SetObjectName(ID3D12Object* object, const char* name)
-{
-	object->SetName(StringUtil::UTF8StringToWideString(name).c_str());
-}
-
-void D3D12::SetObjectNameFormatted(ID3D12Object* object, const char* format, ...)
-{
-	std::va_list ap;
-	va_start(ap, format);
-	SetObjectName(object, StringUtil::StdStringFromFormatV(format, ap).c_str());
-	va_end(ap);
-}
-
-#endif
--- a/common/D3D12/Context.h
+++ b/common/D3D12/Context.h
@@ -0,0 +1,214 @@
+/*  PCSX2 - PS2 Emulator for PCs
+ *  Copyright (C) 2002-2022  PCSX2 Dev Team
+ *
+ *  PCSX2 is free software: you can redistribute it and/or modify it under the terms
+ *  of the GNU Lesser General Public License as published by the Free Software Found-
+ *  ation, either version 3 of the License, or (at your option) any later version.
+ *
+ *  PCSX2 is distributed in the hope that it will be useful, but WITHOUT ANY WARRANTY;
+ *  without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR
+ *  PURPOSE.  See the GNU General Public License for more details.
+ *
+ *  You should have received a copy of the GNU General Public License along with PCSX2.
+ *  If not, see <http://www.gnu.org/licenses/>.
+ */
+
+#pragma once
+
+#include "common/Pcsx2Defs.h"
+#include "common/RedtapeWindows.h"
+#include "common/D3D12/DescriptorHeapManager.h"
+#include "common/D3D12/StreamBuffer.h"
+
+#include <array>
+#include <d3d12.h>
+#include <memory>
+#include <vector>
+#include <wil/com.h>
+
+struct IDXGIAdapter;
+struct IDXGIFactory;
+namespace D3D12MA
+{
+	class Allocator;
+	class Allocation;
+} // namespace D3D12MA
+
+namespace D3D12
+{
+	class Context
+	{
+	public:
+		template <typename T>
+		using ComPtr = wil::com_ptr_nothrow<T>;
+
+		enum : u32
+		{
+			/// Number of command lists. One is being built while the other(s) are executed.
+			NUM_COMMAND_LISTS = 3,
+
+			/// Textures that don't fit into this buffer will be uploaded with a staging buffer.
+			TEXTURE_UPLOAD_BUFFER_SIZE = 64 * 1024 * 1024,
+
+			/// Maximum number of samples in a single allocation group.
+			SAMPLER_GROUP_SIZE = 2,
+
+			/// Start/End timestamp queries.
+			NUM_TIMESTAMP_QUERIES_PER_CMDLIST = 2,
+		};
+
+		~Context();
+
+		/// Creates new device and context.
+		static bool Create(IDXGIFactory* dxgi_factory, u32 adapter_index, bool enable_debug_layer);
+
+		/// Destroys active context.
+		static void Destroy();
+
+		__fi IDXGIAdapter* GetAdapter() const { return m_adapter.get(); }
+		__fi ID3D12Device* GetDevice() const { return m_device.get(); }
+		__fi ID3D12CommandQueue* GetCommandQueue() const { return m_command_queue.get(); }
+		__fi D3D12MA::Allocator* GetAllocator() const { return m_allocator.get(); }
+
+		/// Returns the PCI vendor ID of the device, if known.
+		u32 GetAdapterVendorID() const;
+
+		/// Returns the current command list, commands can be recorded directly.
+		ID3D12GraphicsCommandList4* GetCommandList() const
+		{
+			return m_command_lists[m_current_command_list].command_lists[1].get();
+		}
+
+		/// Returns the init command list for uploading.
+		ID3D12GraphicsCommandList4* GetInitCommandList();
+
+		/// Returns the per-frame SRV/CBV/UAV allocator.
+		DescriptorAllocator& GetDescriptorAllocator()
+		{
+			return m_command_lists[m_current_command_list].descriptor_allocator;
+		}
+
+		/// Returns the per-frame sampler allocator.
+		GroupedSamplerAllocator<SAMPLER_GROUP_SIZE>& GetSamplerAllocator()
+		{
+			return m_command_lists[m_current_command_list].sampler_allocator;
+		}
+
+		/// Invalidates GPU-side sampler caches for all command lists. Call after you've freed samplers,
+		/// and are going to re-use the handles from GetSamplerHeapManager().
+		void InvalidateSamplerGroups();
+
+		// Descriptor manager access.
+		DescriptorHeapManager& GetDescriptorHeapManager() { return m_descriptor_heap_manager; }
+		DescriptorHeapManager& GetRTVHeapManager() { return m_rtv_heap_manager; }
+		DescriptorHeapManager& GetDSVHeapManager() { return m_dsv_heap_manager; }
+		DescriptorHeapManager& GetSamplerHeapManager() { return m_sampler_heap_manager; }
+		const DescriptorHandle& GetNullSRVDescriptor() const { return m_null_srv_descriptor; }
+		StreamBuffer& GetTextureStreamBuffer() { return m_texture_stream_buffer; }
+
+		// Root signature access.
+		ComPtr<ID3DBlob> SerializeRootSignature(const D3D12_ROOT_SIGNATURE_DESC* desc);
+		ComPtr<ID3D12RootSignature> CreateRootSignature(const D3D12_ROOT_SIGNATURE_DESC* desc);
+
+		/// Fence value for current command list.
+		u64 GetCurrentFenceValue() const { return m_current_fence_value; }
+
+		/// Last "completed" fence.
+		u64 GetCompletedFenceValue() const { return m_completed_fence_value; }
+
+		/// Feature level to use when compiling shaders.
+		D3D_FEATURE_LEVEL GetFeatureLevel() const { return m_feature_level; }
+
+		/// Test for support for the specified texture format.
+		bool SupportsTextureFormat(DXGI_FORMAT format);
+
+		enum class WaitType
+		{
+			None,  ///< Don't wait (async)
+			Sleep, ///< Wait normally
+			Spin,  ///< Wait by spinning
+		};
+
+		/// Executes the current command list.
+		void ExecuteCommandList(WaitType wait_for_completion);
+
+		/// Waits for a specific fence.
+		void WaitForFence(u64 fence, bool spin);
+
+		/// Waits for any in-flight command buffers to complete.
+		void WaitForGPUIdle();
+
+		/// Defers destruction of a D3D resource (associates it with the current list).
+		void DeferObjectDestruction(ID3D12DeviceChild* resource);
+
+		/// Defers destruction of a D3D resource (associates it with the current list).
+		void DeferResourceDestruction(D3D12MA::Allocation* allocation, ID3D12Resource* resource);
+
+		/// Defers destruction of a descriptor handle (associates it with the current list).
+		void DeferDescriptorDestruction(DescriptorHeapManager& manager, u32 index);
+		void DeferDescriptorDestruction(DescriptorHeapManager& manager, DescriptorHandle* handle);
+
+		float GetAndResetAccumulatedGPUTime();
+		void SetEnableGPUTiming(bool enabled);
+
+	private:
+		struct CommandListResources
+		{
+			std::array<ComPtr<ID3D12CommandAllocator>, 2> command_allocators;
+			std::array<ComPtr<ID3D12GraphicsCommandList4>, 2> command_lists;
+			DescriptorAllocator descriptor_allocator;
+			GroupedSamplerAllocator<SAMPLER_GROUP_SIZE> sampler_allocator;
+			std::vector<std::pair<D3D12MA::Allocation*, ID3D12DeviceChild*>> pending_resources;
+			std::vector<std::pair<DescriptorHeapManager&, u32>> pending_descriptors;
+			u64 ready_fence_value = 0;
+			bool init_command_list_used = false;
+			bool has_timestamp_query = false;
+		};
+
+		Context();
+
+		bool CreateDevice(IDXGIFactory* dxgi_factory, u32 adapter_index, bool enable_debug_layer);
+		bool CreateCommandQueue();
+		bool CreateAllocator();
+		bool CreateFence();
+		bool CreateDescriptorHeaps();
+		bool CreateCommandLists();
+		bool CreateTextureStreamBuffer();
+		bool CreateTimestampQuery();
+		void MoveToNextCommandList();
+		void DestroyPendingResources(CommandListResources& cmdlist);
+		void DestroyResources();
+
+		ComPtr<IDXGIAdapter> m_adapter;
+		ComPtr<ID3D12Debug> m_debug_interface;
+		ComPtr<ID3D12Device> m_device;
+		ComPtr<ID3D12CommandQueue> m_command_queue;
+		ComPtr<D3D12MA::Allocator> m_allocator;
+
+		ComPtr<ID3D12Fence> m_fence;
+		HANDLE m_fence_event = {};
+		u32 m_current_fence_value = 0;
+		u64 m_completed_fence_value = 0;
+
+		std::array<CommandListResources, NUM_COMMAND_LISTS> m_command_lists;
+		u32 m_current_command_list = NUM_COMMAND_LISTS - 1;
+
+		ComPtr<ID3D12QueryHeap> m_timestamp_query_heap;
+		ComPtr<ID3D12Resource> m_timestamp_query_buffer;
+		ComPtr<D3D12MA::Allocation> m_timestamp_query_allocation;
+		double m_timestamp_frequency = 0.0;
+		float m_accumulated_gpu_time = 0.0f;
+		bool m_gpu_timing_enabled = false;
+
+		DescriptorHeapManager m_descriptor_heap_manager;
+		DescriptorHeapManager m_rtv_heap_manager;
+		DescriptorHeapManager m_dsv_heap_manager;
+		DescriptorHeapManager m_sampler_heap_manager;
+		DescriptorHandle m_null_srv_descriptor;
+		StreamBuffer m_texture_stream_buffer;
+
+		D3D_FEATURE_LEVEL m_feature_level = D3D_FEATURE_LEVEL_11_0;
+	};
+} // namespace D3D12
+
+extern std::unique_ptr<D3D12::Context> g_d3d12_context;
--- a/pcsx2/GS/Renderers/DX12/D3D12DescriptorHeapManager.cpp
+++ b/pcsx2/GS/Renderers/DX12/D3D12DescriptorHeapManager.cpp
@@ -1,5 +1,5 @@
 /*  PCSX2 - PS2 Emulator for PCs
- *  Copyright (C) 2002-2023  PCSX2 Dev Team
+ *  Copyright (C) 2002-2022  PCSX2 Dev Team
 *
 *  PCSX2 is free software: you can redistribute it and/or modify it under the terms
 *  of the GNU Lesser General Public License as published by the Free Software Found-
@@ -13,19 +13,22 @@
 *  If not, see <http://www.gnu.org/licenses/>.
 */

-#include "PrecompiledHeader.h"
+#include "common/PrecompiledHeader.h"

-#include "GS/Renderers/DX12/D3D12DescriptorHeapManager.h"
+#include "common/D3D12/DescriptorHeapManager.h"
 #include "common/Assertions.h"

-D3D12DescriptorHeapManager::D3D12DescriptorHeapManager() = default;
-D3D12DescriptorHeapManager::~D3D12DescriptorHeapManager() = default;
+using namespace D3D12;

-bool D3D12DescriptorHeapManager::Create(
-	ID3D12Device* device, D3D12_DESCRIPTOR_HEAP_TYPE type, u32 num_descriptors, bool shader_visible)
+DescriptorHeapManager::DescriptorHeapManager() = default;
+DescriptorHeapManager::~DescriptorHeapManager() = default;
+
+bool DescriptorHeapManager::Create(ID3D12Device* device, D3D12_DESCRIPTOR_HEAP_TYPE type, u32 num_descriptors,
+	bool shader_visible)
 {
 	D3D12_DESCRIPTOR_HEAP_DESC desc = {type, static_cast<UINT>(num_descriptors),
-		shader_visible ? D3D12_DESCRIPTOR_HEAP_FLAG_SHADER_VISIBLE : D3D12_DESCRIPTOR_HEAP_FLAG_NONE};
+		shader_visible ? D3D12_DESCRIPTOR_HEAP_FLAG_SHADER_VISIBLE :
+                         D3D12_DESCRIPTOR_HEAP_FLAG_NONE};

 	HRESULT hr = device->CreateDescriptorHeap(&desc, IID_PPV_ARGS(m_descriptor_heap.put()));
 	pxAssertRel(SUCCEEDED(hr), "Create descriptor heap");
@@ -49,7 +52,7 @@ bool D3D12DescriptorHeapManager::Create(
 	return true;
 }

-void D3D12DescriptorHeapManager::Destroy()
+void DescriptorHeapManager::Destroy()
 {
 	for (BitSetType& bs : m_free_slots)
 	{
@@ -65,7 +68,7 @@ void D3D12DescriptorHeapManager::Destroy()
 	m_free_slots.clear();
 }

-bool D3D12DescriptorHeapManager::Allocate(D3D12DescriptorHandle* handle)
+bool DescriptorHeapManager::Allocate(DescriptorHandle* handle)
 {
 	// Start past the temporary slots, no point in searching those.
 	for (u32 group = 0; group < m_free_slots.size(); group++)
@@ -94,7 +97,7 @@ bool D3D12DescriptorHeapManager::Allocate(D3D12DescriptorHandle* handle)
 	return false;
 }

-void D3D12DescriptorHeapManager::Free(u32 index)
+void DescriptorHeapManager::Free(u32 index)
 {
 	pxAssert(index < m_num_descriptors);

@@ -103,22 +106,23 @@ void D3D12DescriptorHeapManager::Free(u32 index)
 	m_free_slots[group][bit] = true;
 }

-void D3D12DescriptorHeapManager::Free(D3D12DescriptorHandle* handle)
+void DescriptorHeapManager::Free(DescriptorHandle* handle)
 {
-	if (handle->index == D3D12DescriptorHandle::INVALID_INDEX)
+	if (handle->index == DescriptorHandle::INVALID_INDEX)
 		return;

 	Free(handle->index);
 	handle->Clear();
 }

-D3D12DescriptorAllocator::D3D12DescriptorAllocator() = default;
-D3D12DescriptorAllocator::~D3D12DescriptorAllocator() = default;
+DescriptorAllocator::DescriptorAllocator() = default;
+DescriptorAllocator::~DescriptorAllocator() = default;

-bool D3D12DescriptorAllocator::Create(ID3D12Device* device, D3D12_DESCRIPTOR_HEAP_TYPE type, u32 num_descriptors)
+bool DescriptorAllocator::Create(ID3D12Device* device, D3D12_DESCRIPTOR_HEAP_TYPE type,
+	u32 num_descriptors)
 {
-	const D3D12_DESCRIPTOR_HEAP_DESC desc = {
-		type, static_cast<UINT>(num_descriptors), D3D12_DESCRIPTOR_HEAP_FLAG_SHADER_VISIBLE};
+	const D3D12_DESCRIPTOR_HEAP_DESC desc = {type, static_cast<UINT>(num_descriptors),
+		D3D12_DESCRIPTOR_HEAP_FLAG_SHADER_VISIBLE};
 	const HRESULT hr = device->CreateDescriptorHeap(&desc, IID_PPV_ARGS(&m_descriptor_heap));
 	pxAssertRel(SUCCEEDED(hr), "Creating descriptor heap for linear allocator");
 	if (FAILED(hr))
@@ -131,7 +135,7 @@ bool D3D12DescriptorAllocator::Create(ID3D12Device* device, D3D12_DESCRIPTOR_HEA
 	return true;
 }

-void D3D12DescriptorAllocator::Destroy()
+void DescriptorAllocator::Destroy()
 {
 	m_descriptor_heap.reset();
 	m_descriptor_increment_size = 0;
@@ -141,19 +145,21 @@ void D3D12DescriptorAllocator::Destroy()
 	m_heap_base_gpu = {};
 }

-bool D3D12DescriptorAllocator::Allocate(u32 num_handles, D3D12DescriptorHandle* out_base_handle)
+bool DescriptorAllocator::Allocate(u32 num_handles, DescriptorHandle* out_base_handle)
 {
 	if ((m_current_offset + num_handles) > m_num_descriptors)
 		return false;

 	out_base_handle->index = m_current_offset;
-	out_base_handle->cpu_handle.ptr = m_heap_base_cpu.ptr + m_current_offset * m_descriptor_increment_size;
-	out_base_handle->gpu_handle.ptr = m_heap_base_gpu.ptr + m_current_offset * m_descriptor_increment_size;
+	out_base_handle->cpu_handle.ptr =
+		m_heap_base_cpu.ptr + m_current_offset * m_descriptor_increment_size;
+	out_base_handle->gpu_handle.ptr =
+		m_heap_base_gpu.ptr + m_current_offset * m_descriptor_increment_size;
 	m_current_offset += num_handles;
 	return true;
 }

-void D3D12DescriptorAllocator::Reset()
+void DescriptorAllocator::Reset()
 {
 	m_current_offset = 0;
-}
+}
--- a/common/D3D12/DescriptorHeapManager.h
+++ b/common/D3D12/DescriptorHeapManager.h
@@ -0,0 +1,269 @@
+/*  PCSX2 - PS2 Emulator for PCs
+ *  Copyright (C) 2002-2022  PCSX2 Dev Team
+ *
+ *  PCSX2 is free software: you can redistribute it and/or modify it under the terms
+ *  of the GNU Lesser General Public License as published by the Free Software Found-
+ *  ation, either version 3 of the License, or (at your option) any later version.
+ *
+ *  PCSX2 is distributed in the hope that it will be useful, but WITHOUT ANY WARRANTY;
+ *  without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR
+ *  PURPOSE.  See the GNU General Public License for more details.
+ *
+ *  You should have received a copy of the GNU General Public License along with PCSX2.
+ *  If not, see <http://www.gnu.org/licenses/>.
+ */
+
+#pragma once
+
+#include "common/Pcsx2Defs.h"
+#include "common/HashCombine.h"
+#include "common/RedtapeWindows.h"
+#include "common/RedtapeWilCom.h"
+
+#include <bitset>
+#include <cstring>
+#include <d3d12.h>
+#include <unordered_map>
+#include <vector>
+
+namespace D3D12
+{
+	// This class provides an abstraction for D3D12 descriptor heaps.
+	struct DescriptorHandle final
+	{
+		enum : u32
+		{
+			INVALID_INDEX = 0xFFFFFFFF
+		};
+
+		D3D12_CPU_DESCRIPTOR_HANDLE cpu_handle{};
+		D3D12_GPU_DESCRIPTOR_HANDLE gpu_handle{};
+		u32 index = INVALID_INDEX;
+
+		__fi operator bool() const { return index != INVALID_INDEX; }
+
+		__fi operator D3D12_CPU_DESCRIPTOR_HANDLE() const { return cpu_handle; }
+		__fi operator D3D12_GPU_DESCRIPTOR_HANDLE() const { return gpu_handle; }
+
+		__fi bool operator==(const DescriptorHandle& rhs) const { return (index == rhs.index); }
+		__fi bool operator!=(const DescriptorHandle& rhs) const { return (index != rhs.index); }
+		__fi bool operator<(const DescriptorHandle& rhs) const { return (index < rhs.index); }
+		__fi bool operator<=(const DescriptorHandle& rhs) const { return (index <= rhs.index); }
+		__fi bool operator>(const DescriptorHandle& rhs) const { return (index > rhs.index); }
+		__fi bool operator>=(const DescriptorHandle& rhs) const { return (index >= rhs.index); }
+
+		__fi void Clear()
+		{
+			cpu_handle = {};
+			gpu_handle = {};
+			index = INVALID_INDEX;
+		}
+	};
+
+	class DescriptorHeapManager final
+	{
+	public:
+		DescriptorHeapManager();
+		~DescriptorHeapManager();
+
+		ID3D12DescriptorHeap* GetDescriptorHeap() const { return m_descriptor_heap.get(); }
+		u32 GetDescriptorIncrementSize() const { return m_descriptor_increment_size; }
+
+		bool Create(ID3D12Device* device, D3D12_DESCRIPTOR_HEAP_TYPE type, u32 num_descriptors, bool shader_visible);
+		void Destroy();
+
+		bool Allocate(DescriptorHandle* handle);
+		void Free(DescriptorHandle* handle);
+		void Free(u32 index);
+
+	private:
+		wil::com_ptr_nothrow<ID3D12DescriptorHeap> m_descriptor_heap;
+		u32 m_num_descriptors = 0;
+		u32 m_descriptor_increment_size = 0;
+		bool m_shader_visible = false;
+
+		D3D12_CPU_DESCRIPTOR_HANDLE m_heap_base_cpu = {};
+		D3D12_GPU_DESCRIPTOR_HANDLE m_heap_base_gpu = {};
+
+		static constexpr u32 BITSET_SIZE = 1024;
+		using BitSetType = std::bitset<BITSET_SIZE>;
+		std::vector<BitSetType> m_free_slots = {};
+	};
+
+	class DescriptorAllocator
+	{
+	public:
+		DescriptorAllocator();
+		~DescriptorAllocator();
+
+		__fi ID3D12DescriptorHeap* GetDescriptorHeap() const { return m_descriptor_heap.get(); }
+		__fi u32 GetDescriptorIncrementSize() const { return m_descriptor_increment_size; }
+
+		bool Create(ID3D12Device* device, D3D12_DESCRIPTOR_HEAP_TYPE type, u32 num_descriptors);
+		void Destroy();
+
+		bool Allocate(u32 num_handles, DescriptorHandle* out_base_handle);
+		void Reset();
+
+	private:
+		wil::com_ptr_nothrow<ID3D12DescriptorHeap> m_descriptor_heap;
+		u32 m_descriptor_increment_size = 0;
+		u32 m_num_descriptors = 0;
+		u32 m_current_offset = 0;
+
+		D3D12_CPU_DESCRIPTOR_HANDLE m_heap_base_cpu = {};
+		D3D12_GPU_DESCRIPTOR_HANDLE m_heap_base_gpu = {};
+	};
+
+	template <u32 NumSamplers>
+	class GroupedSamplerAllocator : private DescriptorAllocator
+	{
+		struct Key
+		{
+			u32 idx[NumSamplers];
+
+			__fi bool operator==(const Key& rhs) const
+			{
+				return (std::memcmp(idx, rhs.idx, sizeof(idx)) == 0);
+			}
+			__fi bool operator!=(const Key& rhs) const
+			{
+				return (std::memcmp(idx, rhs.idx, sizeof(idx)) != 0);
+			}
+		};
+
+		struct KeyHash
+		{
+			__fi std::size_t operator()(const Key& key) const
+			{
+				size_t seed = 0;
+				for (u32 key : key.idx)
+					HashCombine(seed, key);
+				return seed;
+			}
+		};
+
+
+	public:
+		GroupedSamplerAllocator();
+		~GroupedSamplerAllocator();
+
+		using DescriptorAllocator::GetDescriptorHeap;
+		using DescriptorAllocator::GetDescriptorIncrementSize;
+
+		bool Create(ID3D12Device* device, u32 num_descriptors);
+		void Destroy();
+
+		bool LookupSingle(DescriptorHandle* gpu_handle, const DescriptorHandle& cpu_handle);
+		bool LookupGroup(DescriptorHandle* gpu_handle, const DescriptorHandle* cpu_handles);
+
+		// Clears cache but doesn't reset allocator.
+		void InvalidateCache();
+
+		void Reset();
+		bool ShouldReset() const;
+
+	private:
+		wil::com_ptr_nothrow<ID3D12Device> m_device;
+		std::unordered_map<Key, D3D12::DescriptorHandle, KeyHash> m_groups;
+	};
+
+	template <u32 NumSamplers>
+	GroupedSamplerAllocator<NumSamplers>::GroupedSamplerAllocator() = default;
+
+	template <u32 NumSamplers>
+	GroupedSamplerAllocator<NumSamplers>::~GroupedSamplerAllocator() = default;
+
+	template <u32 NumSamplers>
+	bool GroupedSamplerAllocator<NumSamplers>::Create(ID3D12Device* device, u32 num_descriptors)
+	{
+		if (!DescriptorAllocator::Create(device, D3D12_DESCRIPTOR_HEAP_TYPE_SAMPLER, num_descriptors))
+			return false;
+
+		m_device = device;
+		return true;
+	}
+
+	template <u32 NumSamplers>
+	void GroupedSamplerAllocator<NumSamplers>::Destroy()
+	{
+		DescriptorAllocator::Destroy();
+		m_device.reset();
+	}
+
+	template <u32 NumSamplers>
+	void GroupedSamplerAllocator<NumSamplers>::Reset()
+	{
+		m_groups.clear();
+		DescriptorAllocator::Reset();
+	}
+
+	template <u32 NumSamplers>
+	void GroupedSamplerAllocator<NumSamplers>::InvalidateCache()
+	{
+		m_groups.clear();
+	}
+
+	template <u32 NumSamplers>
+	bool GroupedSamplerAllocator<NumSamplers>::LookupSingle(DescriptorHandle* gpu_handle, const DescriptorHandle& cpu_handle)
+	{
+		Key key;
+		key.idx[0] = cpu_handle.index;
+		for (u32 i = 1; i < NumSamplers; i++)
+			key.idx[i] = 0;
+
+		auto it = m_groups.find(key);
+		if (it != m_groups.end())
+		{
+			*gpu_handle = it->second;
+			return true;
+		}
+
+		if (!Allocate(1, gpu_handle))
+			return false;
+
+		m_device->CopyDescriptorsSimple(1, *gpu_handle, cpu_handle, D3D12_DESCRIPTOR_HEAP_TYPE_SAMPLER);
+		m_groups.emplace(key, *gpu_handle);
+		return true;
+	}
+
+	template <u32 NumSamplers>
+	bool GroupedSamplerAllocator<NumSamplers>::LookupGroup(DescriptorHandle* gpu_handle, const DescriptorHandle* cpu_handles)
+	{
+		Key key;
+		for (u32 i = 0; i < NumSamplers; i++)
+			key.idx[i] = cpu_handles[i].index;
+
+		auto it = m_groups.find(key);
+		if (it != m_groups.end())
+		{
+			*gpu_handle = it->second;
+			return true;
+		}
+
+		if (!Allocate(NumSamplers, gpu_handle))
+			return false;
+
+		D3D12_CPU_DESCRIPTOR_HANDLE dst_handle = *gpu_handle;
+		UINT dst_size = NumSamplers;
+		D3D12_CPU_DESCRIPTOR_HANDLE src_handles[NumSamplers];
+		UINT src_sizes[NumSamplers];
+		for (u32 i = 0; i < NumSamplers; i++)
+		{
+			src_handles[i] = cpu_handles[i];
+			src_sizes[i] = 1;
+		}
+		m_device->CopyDescriptors(1, &dst_handle, &dst_size, NumSamplers, src_handles, src_sizes, D3D12_DESCRIPTOR_HEAP_TYPE_SAMPLER);
+
+		m_groups.emplace(key, *gpu_handle);
+		return true;
+	}
+
+	template <u32 NumSamplers>
+	bool GroupedSamplerAllocator<NumSamplers>::ShouldReset() const
+	{
+		// We only reset the sampler heap if more than half of the descriptors are used.
+		// This saves descriptor copying when there isn't a large number of sampler configs per frame.
+		return m_groups.size() >= (D3D12_MAX_SHADER_VISIBLE_SAMPLER_HEAP_SIZE / 2);
+	}
+} // namespace D3D12
--- a/pcsx2/GS/Renderers/DX12/D3D12ShaderCache.cpp
+++ b/pcsx2/GS/Renderers/DX12/D3D12ShaderCache.cpp
@@ -1,5 +1,5 @@
 /*  PCSX2 - PS2 Emulator for PCs
- *  Copyright (C) 2002-2023  PCSX2 Dev Team
+ *  Copyright (C) 2002-2022  PCSX2 Dev Team
 *
 *  PCSX2 is free software: you can redistribute it and/or modify it under the terms
 *  of the GNU Lesser General Public License as published by the Free Software Found-
@@ -13,22 +13,18 @@
 *  If not, see <http://www.gnu.org/licenses/>.
 */

-#include "PrecompiledHeader.h"
-
-#include "GS/Renderers/DX12/D3D12ShaderCache.h"
-#include "GS/Renderers/DX11/D3D.h"
-#include "GS/GS.h"
-
-#include "Config.h"
-#include "ShaderCacheVersion.h"
+#include "common/PrecompiledHeader.h"

+#include "common/D3D12/ShaderCache.h"
+#include "common/D3D11/ShaderCompiler.h"
 #include "common/FileSystem.h"
 #include "common/Console.h"
 #include "common/MD5Digest.h"
-#include "common/Path.h"

 #include <d3dcompiler.h>

+using namespace D3D12;
+
 #pragma pack(push, 1)
 struct CacheIndexEntry
 {
@@ -45,59 +41,67 @@ struct CacheIndexEntry
 };
 #pragma pack(pop)

-D3D12ShaderCache::D3D12ShaderCache() = default;
+ShaderCache::ShaderCache() = default;

-D3D12ShaderCache::~D3D12ShaderCache()
+ShaderCache::~ShaderCache()
 {
-	Close();
+	if (m_pipeline_index_file)
+		std::fclose(m_pipeline_index_file);
+	if (m_pipeline_blob_file)
+		std::fclose(m_pipeline_blob_file);
+	if (m_shader_index_file)
+		std::fclose(m_shader_index_file);
+	if (m_shader_blob_file)
+		std::fclose(m_shader_blob_file);
 }

-bool D3D12ShaderCache::CacheIndexKey::operator==(const CacheIndexKey& key) const
+bool ShaderCache::CacheIndexKey::operator==(const CacheIndexKey& key) const
 {
 	return (source_hash_low == key.source_hash_low && source_hash_high == key.source_hash_high &&
 			macro_hash_low == key.macro_hash_low && macro_hash_high == key.macro_hash_high &&
-			entry_point_low == key.entry_point_low && entry_point_high == key.entry_point_high && type == key.type &&
-			source_length == key.source_length);
+			entry_point_low == key.entry_point_low && entry_point_high == key.entry_point_high &&
+			type == key.type && source_length == key.source_length);
 }

-bool D3D12ShaderCache::CacheIndexKey::operator!=(const CacheIndexKey& key) const
+bool ShaderCache::CacheIndexKey::operator!=(const CacheIndexKey& key) const
 {
 	return (source_hash_low != key.source_hash_low || source_hash_high != key.source_hash_high ||
 			macro_hash_low != key.macro_hash_low || macro_hash_high != key.macro_hash_high ||
-			entry_point_low != key.entry_point_low || entry_point_high != key.entry_point_high || type != key.type ||
-			source_length != key.source_length);
+			entry_point_low != key.entry_point_low || entry_point_high != key.entry_point_high ||
+			type != key.type || source_length != key.source_length);
 }

-bool D3D12ShaderCache::Open(D3D_FEATURE_LEVEL feature_level, bool debug)
+bool ShaderCache::Open(std::string_view base_path, D3D_FEATURE_LEVEL feature_level, u32 version, bool debug)
 {
+	m_base_path = base_path;
 	m_feature_level = feature_level;
+	m_data_version = version;
 	m_debug = debug;

 	bool result = true;

-	if (!GSConfig.DisableShaderCache)
+	if (!base_path.empty())
 	{
-		const std::string base_shader_filename = GetCacheBaseFileName("shaders", feature_level, debug);
+		const std::string base_shader_filename = GetCacheBaseFileName(base_path, "shaders", feature_level, debug);
 		const std::string shader_index_filename = base_shader_filename + ".idx";
 		const std::string shader_blob_filename = base_shader_filename + ".bin";

-		if (!ReadExisting(
-				shader_index_filename, shader_blob_filename, m_shader_index_file, m_shader_blob_file, m_shader_index))
+		if (!ReadExisting(shader_index_filename, shader_blob_filename, m_shader_index_file, m_shader_blob_file,
+				m_shader_index))
 		{
 			result = CreateNew(shader_index_filename, shader_blob_filename, m_shader_index_file, m_shader_blob_file);
 		}

 		if (result)
 		{
-			const std::string base_pipelines_filename = GetCacheBaseFileName("pipelines", feature_level, debug);
+			const std::string base_pipelines_filename = GetCacheBaseFileName(base_path, "pipelines", feature_level, debug);
 			const std::string pipelines_index_filename = base_pipelines_filename + ".idx";
 			const std::string pipelines_blob_filename = base_pipelines_filename + ".bin";

-			if (!ReadExisting(pipelines_index_filename, pipelines_blob_filename, m_pipeline_index_file,
-					m_pipeline_blob_file, m_pipeline_index))
+			if (!ReadExisting(pipelines_index_filename, pipelines_blob_filename, m_pipeline_index_file, m_pipeline_blob_file,
+					m_pipeline_index))
 			{
-				result = CreateNew(
-					pipelines_index_filename, pipelines_blob_filename, m_pipeline_index_file, m_pipeline_blob_file);
+				result = CreateNew(pipelines_index_filename, pipelines_blob_filename, m_pipeline_index_file, m_pipeline_blob_file);
 			}
 		}
 	}
@@ -105,31 +109,7 @@ bool D3D12ShaderCache::Open(D3D_FEATURE_LEVEL feature_level, bool debug)
 	return result;
 }

-void D3D12ShaderCache::Close()
-{
-	if (m_pipeline_index_file)
-	{
-		std::fclose(m_pipeline_index_file);
-		m_pipeline_index_file = nullptr;
-	}
-	if (m_pipeline_blob_file)
-	{
-		std::fclose(m_pipeline_blob_file);
-		m_pipeline_blob_file = nullptr;
-	}
-	if (m_shader_index_file)
-	{
-		std::fclose(m_shader_index_file);
-		m_shader_index_file = nullptr;
-	}
-	if (m_shader_blob_file)
-	{
-		std::fclose(m_shader_blob_file);
-		m_shader_blob_file = nullptr;
-	}
-}
-
-void D3D12ShaderCache::InvalidatePipelineCache()
+void ShaderCache::InvalidatePipelineCache()
 {
 	m_pipeline_index.clear();
 	if (m_pipeline_blob_file)
@@ -144,17 +124,15 @@ void D3D12ShaderCache::InvalidatePipelineCache()
 		m_pipeline_index_file = nullptr;
 	}

-	if (GSConfig.DisableShaderCache)
-		return;
-
-	const std::string base_pipelines_filename = GetCacheBaseFileName("pipelines", m_feature_level, m_debug);
+	const std::string base_pipelines_filename =
+		GetCacheBaseFileName(m_base_path, "pipelines", m_feature_level, m_debug);
 	const std::string pipelines_index_filename = base_pipelines_filename + ".idx";
 	const std::string pipelines_blob_filename = base_pipelines_filename + ".bin";
 	CreateNew(pipelines_index_filename, pipelines_blob_filename, m_pipeline_index_file, m_pipeline_blob_file);
 }

-bool D3D12ShaderCache::CreateNew(
-	const std::string& index_filename, const std::string& blob_filename, std::FILE*& index_file, std::FILE*& blob_file)
+bool ShaderCache::CreateNew(const std::string& index_filename, const std::string& blob_filename, std::FILE*& index_file,
+	std::FILE*& blob_file)
 {
 	if (FileSystem::FileExists(index_filename.c_str()))
 	{
@@ -174,8 +152,9 @@ bool D3D12ShaderCache::CreateNew(
 		return false;
 	}

-	const u32 file_version = SHADER_CACHE_VERSION;
-	if (std::fwrite(&file_version, sizeof(file_version), 1, index_file) != 1)
+	const u32 index_version = FILE_VERSION;
+	if (std::fwrite(&index_version, sizeof(index_version), 1, index_file) != 1 ||
+		std::fwrite(&m_data_version, sizeof(m_data_version), 1, index_file) != 1)
 	{
 		Console.Error("Failed to write version to index file '%s'", index_filename.c_str());
 		std::fclose(index_file);
@@ -197,7 +176,7 @@ bool D3D12ShaderCache::CreateNew(
 	return true;
 }

-bool D3D12ShaderCache::ReadExisting(const std::string& index_filename, const std::string& blob_filename,
+bool ShaderCache::ReadExisting(const std::string& index_filename, const std::string& blob_filename,
 	std::FILE*& index_file, std::FILE*& blob_file, CacheIndex& index)
 {
 	index_file = FileSystem::OpenCFile(index_filename.c_str(), "r+b");
@@ -215,7 +194,9 @@ bool D3D12ShaderCache::ReadExisting(const std::string& index_filename, const std
 	}

 	u32 file_version;
-	if (std::fread(&file_version, sizeof(file_version), 1, index_file) != 1 || file_version != SHADER_CACHE_VERSION)
+	u32 data_version;
+	if (std::fread(&file_version, sizeof(file_version), 1, index_file) != 1 || file_version != FILE_VERSION ||
+		std::fread(&data_version, sizeof(data_version), 1, index_file) != 1 || data_version != m_data_version)
 	{
 		Console.Error("Bad file version in '%s'", index_filename.c_str());
 		std::fclose(index_file);
@@ -238,8 +219,7 @@ bool D3D12ShaderCache::ReadExisting(const std::string& index_filename, const std
 	for (;;)
 	{
 		CacheIndexEntry entry;
-		if (std::fread(&entry, sizeof(entry), 1, index_file) != 1 ||
-			(entry.file_offset + entry.blob_size) > blob_file_size)
+		if (std::fread(&entry, sizeof(entry), 1, index_file) != 1 || (entry.file_offset + entry.blob_size) > blob_file_size)
 		{
 			if (std::feof(index_file))
 				break;
@@ -253,9 +233,11 @@ bool D3D12ShaderCache::ReadExisting(const std::string& index_filename, const std
 			return false;
 		}

-		const CacheIndexKey key{entry.source_hash_low, entry.source_hash_high, entry.macro_hash_low,
-			entry.macro_hash_high, entry.entry_point_low, entry.entry_point_high, entry.source_length,
-			static_cast<EntryType>(entry.shader_type)};
+		const CacheIndexKey key{
+			entry.source_hash_low, entry.source_hash_high,
+			entry.macro_hash_low, entry.macro_hash_high,
+			entry.entry_point_low, entry.entry_point_high,
+			entry.source_length, static_cast<EntryType>(entry.shader_type)};
 		const CacheIndexData data{entry.file_offset, entry.blob_size};
 		index.emplace(key, data);
 	}
@@ -267,9 +249,11 @@ bool D3D12ShaderCache::ReadExisting(const std::string& index_filename, const std
 	return true;
 }

-std::string D3D12ShaderCache::GetCacheBaseFileName(const std::string_view& type, D3D_FEATURE_LEVEL feature_level, bool debug)
+std::string ShaderCache::GetCacheBaseFileName(const std::string_view& base_path, const std::string_view& type,
+	D3D_FEATURE_LEVEL feature_level, bool debug)
 {
-	std::string base_filename = "d3d12_";
+	std::string base_filename(base_path);
+	base_filename += FS_OSPATH_SEPARATOR_STR "d3d12_";
 	base_filename += type;
 	base_filename += "_";

@@ -292,7 +276,7 @@ std::string D3D12ShaderCache::GetCacheBaseFileName(const std::string_view& type,
 	if (debug)
 		base_filename += "_debug";

-	return Path::Combine(EmuFolders::Cache, base_filename);
+	return base_filename;
 }

 union MD5Hash
@@ -305,8 +289,8 @@ union MD5Hash
 	u8 hash[16];
 };

-D3D12ShaderCache::CacheIndexKey D3D12ShaderCache::GetShaderCacheKey(
-	EntryType type, const std::string_view& shader_code, const D3D_SHADER_MACRO* macros, const char* entry_point)
+ShaderCache::CacheIndexKey ShaderCache::GetShaderCacheKey(EntryType type, const std::string_view& shader_code,
+	const D3D_SHADER_MACRO* macros, const char* entry_point)
 {
 	union
 	{
@@ -350,7 +334,7 @@ D3D12ShaderCache::CacheIndexKey D3D12ShaderCache::GetShaderCacheKey(
 	return key;
 }

-D3D12ShaderCache::CacheIndexKey D3D12ShaderCache::GetPipelineCacheKey(const D3D12_GRAPHICS_PIPELINE_STATE_DESC& gpdesc)
+ShaderCache::CacheIndexKey ShaderCache::GetPipelineCacheKey(const D3D12_GRAPHICS_PIPELINE_STATE_DESC& gpdesc)
 {
 	MD5Digest digest;
 	u32 length = sizeof(D3D12_GRAPHICS_PIPELINE_STATE_DESC);
@@ -403,7 +387,7 @@ D3D12ShaderCache::CacheIndexKey D3D12ShaderCache::GetPipelineCacheKey(const D3D1
 	return CacheIndexKey{h.low, h.high, 0, 0, 0, 0, length, EntryType::GraphicsPipeline};
 }

-D3D12ShaderCache::CacheIndexKey D3D12ShaderCache::GetPipelineCacheKey(const D3D12_COMPUTE_PIPELINE_STATE_DESC& gpdesc)
+ShaderCache::CacheIndexKey ShaderCache::GetPipelineCacheKey(const D3D12_COMPUTE_PIPELINE_STATE_DESC& gpdesc)
 {
 	MD5Digest digest;
 	u32 length = sizeof(D3D12_GRAPHICS_PIPELINE_STATE_DESC);
@@ -420,7 +404,7 @@ D3D12ShaderCache::CacheIndexKey D3D12ShaderCache::GetPipelineCacheKey(const D3D1
 	return CacheIndexKey{h.low, h.high, 0, 0, 0, 0, length, EntryType::ComputePipeline};
 }

-D3D12ShaderCache::ComPtr<ID3DBlob> D3D12ShaderCache::GetShaderBlob(EntryType type, std::string_view shader_code,
+ShaderCache::ComPtr<ID3DBlob> ShaderCache::GetShaderBlob(EntryType type, std::string_view shader_code,
 	const D3D_SHADER_MACRO* macros /* = nullptr */, const char* entry_point /* = "main" */)
 {
 	const auto key = GetShaderCacheKey(type, shader_code, macros, entry_point);
@@ -440,8 +424,8 @@ D3D12ShaderCache::ComPtr<ID3DBlob> D3D12ShaderCache::GetShaderBlob(EntryType typ
 	return blob;
 }

-D3D12ShaderCache::ComPtr<ID3D12PipelineState> D3D12ShaderCache::GetPipelineState(
-	ID3D12Device* device, const D3D12_GRAPHICS_PIPELINE_STATE_DESC& desc)
+ShaderCache::ComPtr<ID3D12PipelineState> ShaderCache::GetPipelineState(ID3D12Device* device,
+	const D3D12_GRAPHICS_PIPELINE_STATE_DESC& desc)
 {
 	const auto key = GetPipelineCacheKey(desc);

@@ -474,8 +458,8 @@ D3D12ShaderCache::ComPtr<ID3D12PipelineState> D3D12ShaderCache::GetPipelineState
 	return pso;
 }

-D3D12ShaderCache::ComPtr<ID3D12PipelineState> D3D12ShaderCache::GetPipelineState(
-	ID3D12Device* device, const D3D12_COMPUTE_PIPELINE_STATE_DESC& desc)
+ShaderCache::ComPtr<ID3D12PipelineState> ShaderCache::GetPipelineState(ID3D12Device* device,
+	const D3D12_COMPUTE_PIPELINE_STATE_DESC& desc)
 {
 	const auto key = GetPipelineCacheKey(desc);

@@ -508,24 +492,24 @@ D3D12ShaderCache::ComPtr<ID3D12PipelineState> D3D12ShaderCache::GetPipelineState
 	return pso;
 }

-D3D12ShaderCache::ComPtr<ID3DBlob> D3D12ShaderCache::CompileAndAddShaderBlob(
-	const CacheIndexKey& key, std::string_view shader_code, const D3D_SHADER_MACRO* macros, const char* entry_point)
+ShaderCache::ComPtr<ID3DBlob> ShaderCache::CompileAndAddShaderBlob(const CacheIndexKey& key, std::string_view shader_code,
+	const D3D_SHADER_MACRO* macros, const char* entry_point)
 {
 	ComPtr<ID3DBlob> blob;

 	switch (key.type)
 	{
 		case EntryType::VertexShader:
-			blob =
-				D3D::CompileShader(D3D::ShaderType::Vertex, m_feature_level, m_debug, shader_code, macros, entry_point);
+			blob = D3D11::ShaderCompiler::CompileShader(D3D11::ShaderCompiler::Type::Vertex, m_feature_level, m_debug, shader_code, macros, entry_point);
+			break;
+		case EntryType::GeometryShader:
+			blob = D3D11::ShaderCompiler::CompileShader(D3D11::ShaderCompiler::Type::Geometry, m_feature_level, m_debug, shader_code, macros, entry_point);
 			break;
 		case EntryType::PixelShader:
-			blob =
-				D3D::CompileShader(D3D::ShaderType::Pixel, m_feature_level, m_debug, shader_code, macros, entry_point);
+			blob = D3D11::ShaderCompiler::CompileShader(D3D11::ShaderCompiler::Type::Pixel, m_feature_level, m_debug, shader_code, macros, entry_point);
 			break;
 		case EntryType::ComputeShader:
-			blob = D3D::CompileShader(
-				D3D::ShaderType::Compute, m_feature_level, m_debug, shader_code, macros, entry_point);
+			blob = D3D11::ShaderCompiler::CompileShader(D3D11::ShaderCompiler::Type::Compute, m_feature_level, m_debug, shader_code, macros, entry_point);
 			break;
 		default:
 			break;
@@ -565,8 +549,9 @@ D3D12ShaderCache::ComPtr<ID3DBlob> D3D12ShaderCache::CompileAndAddShaderBlob(
 	return blob;
 }

-D3D12ShaderCache::ComPtr<ID3D12PipelineState> D3D12ShaderCache::CompileAndAddPipeline(
-	ID3D12Device* device, const CacheIndexKey& key, const D3D12_GRAPHICS_PIPELINE_STATE_DESC& gpdesc)
+ShaderCache::ComPtr<ID3D12PipelineState>
+ShaderCache::CompileAndAddPipeline(ID3D12Device* device, const CacheIndexKey& key,
+	const D3D12_GRAPHICS_PIPELINE_STATE_DESC& gpdesc)
 {
 	ComPtr<ID3D12PipelineState> pso;
 	HRESULT hr = device->CreateGraphicsPipelineState(&gpdesc, IID_PPV_ARGS(pso.put()));
@@ -580,8 +565,9 @@ D3D12ShaderCache::ComPtr<ID3D12PipelineState> D3D12ShaderCache::CompileAndAddPip
 	return pso;
 }

-D3D12ShaderCache::ComPtr<ID3D12PipelineState> D3D12ShaderCache::CompileAndAddPipeline(
-	ID3D12Device* device, const CacheIndexKey& key, const D3D12_COMPUTE_PIPELINE_STATE_DESC& gpdesc)
+ShaderCache::ComPtr<ID3D12PipelineState>
+ShaderCache::CompileAndAddPipeline(ID3D12Device* device, const CacheIndexKey& key,
+	const D3D12_COMPUTE_PIPELINE_STATE_DESC& gpdesc)
 {
 	ComPtr<ID3D12PipelineState> pso;
 	HRESULT hr = device->CreateComputePipelineState(&gpdesc, IID_PPV_ARGS(pso.put()));
@@ -595,7 +581,7 @@ D3D12ShaderCache::ComPtr<ID3D12PipelineState> D3D12ShaderCache::CompileAndAddPip
 	return pso;
 }

-bool D3D12ShaderCache::AddPipelineToBlob(const CacheIndexKey& key, ID3D12PipelineState* pso)
+bool ShaderCache::AddPipelineToBlob(const CacheIndexKey& key, ID3D12PipelineState* pso)
 {
 	if (!m_pipeline_blob_file || std::fseek(m_pipeline_blob_file, 0, SEEK_END) != 0)
 		return false;
--- a/common/D3D12/ShaderCache.h
+++ b/common/D3D12/ShaderCache.h
@@ -0,0 +1,156 @@
+/*  PCSX2 - PS2 Emulator for PCs
+ *  Copyright (C) 2002-2022  PCSX2 Dev Team
+ *
+ *  PCSX2 is free software: you can redistribute it and/or modify it under the terms
+ *  of the GNU Lesser General Public License as published by the Free Software Found-
+ *  ation, either version 3 of the License, or (at your option) any later version.
+ *
+ *  PCSX2 is distributed in the hope that it will be useful, but WITHOUT ANY WARRANTY;
+ *  without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR
+ *  PURPOSE.  See the GNU General Public License for more details.
+ *
+ *  You should have received a copy of the GNU General Public License along with PCSX2.
+ *  If not, see <http://www.gnu.org/licenses/>.
+ */
+
+#pragma once
+
+#include "common/Pcsx2Defs.h"
+#include "common/HashCombine.h"
+#include "common/RedtapeWindows.h"
+#include "common/RedtapeWilCom.h"
+
+#include <cstdio>
+#include <d3d12.h>
+#include <string_view>
+#include <unordered_map>
+#include <vector>
+
+namespace D3D12
+{
+	class ShaderCache
+	{
+	public:
+		template <typename T>
+		using ComPtr = wil::com_ptr_nothrow<T>;
+
+		enum class EntryType
+		{
+			VertexShader,
+			GeometryShader,
+			PixelShader,
+			ComputeShader,
+			GraphicsPipeline,
+			ComputePipeline,
+		};
+
+		ShaderCache();
+		~ShaderCache();
+
+		__fi D3D_FEATURE_LEVEL GetFeatureLevel() const { return m_feature_level; }
+		__fi u32 GetDataVersion() const { return m_data_version; }
+		__fi bool UsingDebugShaders() const { return m_debug; }
+
+		bool Open(std::string_view base_path, D3D_FEATURE_LEVEL feature_level, u32 version, bool debug);
+
+		__fi ComPtr<ID3DBlob> GetVertexShader(std::string_view shader_code,
+			const D3D_SHADER_MACRO* macros = nullptr, const char* entry_point = "main")
+		{
+			return GetShaderBlob(EntryType::VertexShader, shader_code, macros, entry_point);
+		}
+		__fi ComPtr<ID3DBlob> GetGeometryShader(std::string_view shader_code,
+			const D3D_SHADER_MACRO* macros = nullptr, const char* entry_point = "main")
+		{
+			return GetShaderBlob(EntryType::GeometryShader, shader_code, macros, entry_point);
+		}
+		__fi ComPtr<ID3DBlob> GetPixelShader(std::string_view shader_code,
+			const D3D_SHADER_MACRO* macros = nullptr, const char* entry_point = "main")
+		{
+			return GetShaderBlob(EntryType::PixelShader, shader_code, macros, entry_point);
+		}
+		__fi ComPtr<ID3DBlob> GetComputeShader(std::string_view shader_code,
+			const D3D_SHADER_MACRO* macros = nullptr, const char* entry_point = "main")
+		{
+			return GetShaderBlob(EntryType::ComputeShader, shader_code, macros, entry_point);
+		}
+
+		ComPtr<ID3DBlob> GetShaderBlob(EntryType type, std::string_view shader_code,
+			const D3D_SHADER_MACRO* macros = nullptr, const char* entry_point = "main");
+
+		ComPtr<ID3D12PipelineState> GetPipelineState(ID3D12Device* device, const D3D12_GRAPHICS_PIPELINE_STATE_DESC& desc);
+		ComPtr<ID3D12PipelineState> GetPipelineState(ID3D12Device* device, const D3D12_COMPUTE_PIPELINE_STATE_DESC& desc);
+
+	private:
+		static constexpr u32 FILE_VERSION = 1;
+
+		struct CacheIndexKey
+		{
+			u64 source_hash_low;
+			u64 source_hash_high;
+			u64 macro_hash_low;
+			u64 macro_hash_high;
+			u64 entry_point_low;
+			u64 entry_point_high;
+			u32 source_length;
+			EntryType type;
+
+			bool operator==(const CacheIndexKey& key) const;
+			bool operator!=(const CacheIndexKey& key) const;
+		};
+
+		struct CacheIndexEntryHasher
+		{
+			std::size_t operator()(const CacheIndexKey& e) const noexcept
+			{
+				std::size_t h = 0;
+				HashCombine(h, e.entry_point_low, e.entry_point_high, e.macro_hash_low, e.macro_hash_high,
+					e.source_hash_low, e.source_hash_high, e.source_length, e.type);
+				return h;
+			}
+		};
+
+		struct CacheIndexData
+		{
+			u32 file_offset;
+			u32 blob_size;
+		};
+
+		using CacheIndex = std::unordered_map<CacheIndexKey, CacheIndexData, CacheIndexEntryHasher>;
+
+		static std::string GetCacheBaseFileName(const std::string_view& base_path, const std::string_view& type,
+			D3D_FEATURE_LEVEL feature_level, bool debug);
+		static CacheIndexKey GetShaderCacheKey(EntryType type, const std::string_view& shader_code,
+			const D3D_SHADER_MACRO* macros, const char* entry_point);
+		static CacheIndexKey GetPipelineCacheKey(const D3D12_GRAPHICS_PIPELINE_STATE_DESC& gpdesc);
+		static CacheIndexKey GetPipelineCacheKey(const D3D12_COMPUTE_PIPELINE_STATE_DESC& gpdesc);
+
+		bool CreateNew(const std::string& index_filename, const std::string& blob_filename, std::FILE*& index_file,
+			std::FILE*& blob_file);
+		bool ReadExisting(const std::string& index_filename, const std::string& blob_filename, std::FILE*& index_file,
+			std::FILE*& blob_file, CacheIndex& index);
+		void InvalidatePipelineCache();
+		void Close();
+
+		ComPtr<ID3DBlob> CompileAndAddShaderBlob(const CacheIndexKey& key, std::string_view shader_code,
+			const D3D_SHADER_MACRO* macros, const char* entry_point);
+		ComPtr<ID3D12PipelineState> CompileAndAddPipeline(ID3D12Device* device, const CacheIndexKey& key,
+			const D3D12_GRAPHICS_PIPELINE_STATE_DESC& gpdesc);
+		ComPtr<ID3D12PipelineState> CompileAndAddPipeline(ID3D12Device* device, const CacheIndexKey& key,
+			const D3D12_COMPUTE_PIPELINE_STATE_DESC& gpdesc);
+		bool AddPipelineToBlob(const CacheIndexKey& key, ID3D12PipelineState* pso);
+
+		std::string m_base_path;
+
+		std::FILE* m_shader_index_file = nullptr;
+		std::FILE* m_shader_blob_file = nullptr;
+		CacheIndex m_shader_index;
+
+		std::FILE* m_pipeline_index_file = nullptr;
+		std::FILE* m_pipeline_blob_file = nullptr;
+		CacheIndex m_pipeline_index;
+
+		D3D_FEATURE_LEVEL m_feature_level = D3D_FEATURE_LEVEL_11_0;
+		u32 m_data_version = 0;
+		bool m_debug = false;
+	};
+} // namespace D3D12
--- a/pcsx2/GS/Renderers/DX12/D3D12StreamBuffer.cpp
+++ b/pcsx2/GS/Renderers/DX12/D3D12StreamBuffer.cpp
@@ -1,5 +1,5 @@
 /*  PCSX2 - PS2 Emulator for PCs
- *  Copyright (C) 2002-2023  PCSX2 Dev Team
+ *  Copyright (C) 2002-2022  PCSX2 Dev Team
 *
 *  PCSX2 is free software: you can redistribute it and/or modify it under the terms
 *  of the GNU Lesser General Public License as published by the Free Software Found-
@@ -13,31 +13,32 @@
 *  If not, see <http://www.gnu.org/licenses/>.
 */

-#include "PrecompiledHeader.h"
-
-#include "GS/Renderers/DX12/D3D12StreamBuffer.h"
-#include "GS/Renderers/DX12/D3D12Context.h"
+#include "common/PrecompiledHeader.h"

+#include "common/D3D12/StreamBuffer.h"
+#include "common/D3D12/Context.h"
 #include "common/Align.h"
 #include "common/Assertions.h"
 #include "common/Console.h"
-
 #include "D3D12MemAlloc.h"

 #include <algorithm>
 #include <functional>

-D3D12StreamBuffer::D3D12StreamBuffer() = default;
+using namespace D3D12;

-D3D12StreamBuffer::~D3D12StreamBuffer()
+StreamBuffer::StreamBuffer() = default;
+
+StreamBuffer::~StreamBuffer()
 {
 	Destroy();
 }

-bool D3D12StreamBuffer::Create(u32 size)
+bool StreamBuffer::Create(u32 size)
 {
-	const D3D12_RESOURCE_DESC resource_desc = {D3D12_RESOURCE_DIMENSION_BUFFER, 0, size, 1, 1, 1, DXGI_FORMAT_UNKNOWN,
-		{1, 0}, D3D12_TEXTURE_LAYOUT_ROW_MAJOR, D3D12_RESOURCE_FLAG_NONE};
+	const D3D12_RESOURCE_DESC resource_desc = {
+		D3D12_RESOURCE_DIMENSION_BUFFER, 0, size, 1, 1, 1, DXGI_FORMAT_UNKNOWN, {1, 0}, D3D12_TEXTURE_LAYOUT_ROW_MAJOR,
+		D3D12_RESOURCE_FLAG_NONE};

 	D3D12MA::ALLOCATION_DESC allocationDesc = {};
 	allocationDesc.Flags = D3D12MA::ALLOCATION_FLAG_COMMITTED;
@@ -45,8 +46,9 @@ bool D3D12StreamBuffer::Create(u32 size)

 	wil::com_ptr_nothrow<ID3D12Resource> buffer;
 	wil::com_ptr_nothrow<D3D12MA::Allocation> allocation;
-	HRESULT hr = g_d3d12_context->GetAllocator()->CreateResource(&allocationDesc, &resource_desc,
-		D3D12_RESOURCE_STATE_GENERIC_READ, nullptr, allocation.put(), IID_PPV_ARGS(buffer.put()));
+	HRESULT hr = g_d3d12_context->GetAllocator()->CreateResource(&allocationDesc,
+		&resource_desc, D3D12_RESOURCE_STATE_GENERIC_READ,
+		nullptr, allocation.put(), IID_PPV_ARGS(buffer.put()));
 	pxAssertMsg(SUCCEEDED(hr), "Allocate buffer");
 	if (FAILED(hr))
 		return false;
@@ -68,7 +70,7 @@ bool D3D12StreamBuffer::Create(u32 size)
 	return true;
 }

-bool D3D12StreamBuffer::ReserveMemory(u32 num_bytes, u32 alignment)
+bool StreamBuffer::ReserveMemory(u32 num_bytes, u32 alignment)
 {
 	const u32 required_bytes = num_bytes + alignment;

@@ -137,7 +139,7 @@ bool D3D12StreamBuffer::ReserveMemory(u32 num_bytes, u32 alignment)
 	return false;
 }

-void D3D12StreamBuffer::CommitMemory(u32 final_num_bytes)
+void StreamBuffer::CommitMemory(u32 final_num_bytes)
 {
 	pxAssert((m_current_offset + final_num_bytes) <= m_size);
 	pxAssert(final_num_bytes <= m_current_space);
@@ -145,7 +147,7 @@ void D3D12StreamBuffer::CommitMemory(u32 final_num_bytes)
 	m_current_space -= final_num_bytes;
 }

-void D3D12StreamBuffer::Destroy(bool defer)
+void StreamBuffer::Destroy(bool defer)
 {
 	if (m_host_pointer)
 	{
@@ -165,7 +167,7 @@ void D3D12StreamBuffer::Destroy(bool defer)
 	m_tracked_fences.clear();
 }

-void D3D12StreamBuffer::UpdateCurrentFencePosition()
+void StreamBuffer::UpdateCurrentFencePosition()
 {
 	// Don't create a tracking entry if the GPU is caught up with the buffer.
 	if (m_current_offset == m_current_gpu_position)
@@ -184,7 +186,7 @@ void D3D12StreamBuffer::UpdateCurrentFencePosition()
 	m_tracked_fences.emplace_back(fence, m_current_offset);
 }

-void D3D12StreamBuffer::UpdateGPUPosition()
+void StreamBuffer::UpdateGPUPosition()
 {
 	auto start = m_tracked_fences.begin();
 	auto end = start;
@@ -200,7 +202,7 @@ void D3D12StreamBuffer::UpdateGPUPosition()
 		m_tracked_fences.erase(start, end);
 }

-bool D3D12StreamBuffer::WaitForClearSpace(u32 num_bytes)
+bool StreamBuffer::WaitForClearSpace(u32 num_bytes)
 {
 	u32 new_offset = 0;
 	u32 new_space = 0;
@@ -272,8 +274,7 @@ bool D3D12StreamBuffer::WaitForClearSpace(u32 num_bytes)

 	// Wait until this fence is signaled. This will fire the callback, updating the GPU position.
 	g_d3d12_context->WaitForFence(iter->first, false);
-	m_tracked_fences.erase(
-		m_tracked_fences.begin(), m_current_offset == iter->second ? m_tracked_fences.end() : ++iter);
+	m_tracked_fences.erase(m_tracked_fences.begin(), m_current_offset == iter->second ? m_tracked_fences.end() : ++iter);
 	m_current_offset = new_offset;
 	m_current_space = new_space;
 	m_current_gpu_position = new_gpu_position;
--- a/common/D3D12/StreamBuffer.h
+++ b/common/D3D12/StreamBuffer.h
@@ -0,0 +1,77 @@
+/*  PCSX2 - PS2 Emulator for PCs
+ *  Copyright (C) 2002-2022  PCSX2 Dev Team
+ *
+ *  PCSX2 is free software: you can redistribute it and/or modify it under the terms
+ *  of the GNU Lesser General Public License as published by the Free Software Found-
+ *  ation, either version 3 of the License, or (at your option) any later version.
+ *
+ *  PCSX2 is distributed in the hope that it will be useful, but WITHOUT ANY WARRANTY;
+ *  without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR
+ *  PURPOSE.  See the GNU General Public License for more details.
+ *
+ *  You should have received a copy of the GNU General Public License along with PCSX2.
+ *  If not, see <http://www.gnu.org/licenses/>.
+ */
+
+#pragma once
+
+#include "common/Pcsx2Defs.h"
+#include "common/RedtapeWindows.h"
+#include "common/RedtapeWilCom.h"
+
+#include <d3d12.h>
+#include <deque>
+#include <utility>
+
+namespace D3D12MA
+{
+	class Allocation;
+}
+
+namespace D3D12
+{
+	class StreamBuffer
+	{
+	public:
+		StreamBuffer();
+		~StreamBuffer();
+
+		bool Create(u32 size);
+
+		__fi bool IsValid() const { return static_cast<bool>(m_buffer); }
+		__fi ID3D12Resource* GetBuffer() const { return m_buffer.get(); }
+		__fi D3D12_GPU_VIRTUAL_ADDRESS GetGPUPointer() const { return m_gpu_pointer; }
+		__fi void* GetHostPointer() const { return m_host_pointer; }
+		__fi void* GetCurrentHostPointer() const { return m_host_pointer + m_current_offset; }
+		__fi D3D12_GPU_VIRTUAL_ADDRESS GetCurrentGPUPointer() const { return m_gpu_pointer + m_current_offset; }
+		__fi u32 GetSize() const { return m_size; }
+		__fi u32 GetCurrentOffset() const { return m_current_offset; }
+		__fi u32 GetCurrentSpace() const { return m_current_space; }
+
+		bool ReserveMemory(u32 num_bytes, u32 alignment);
+		void CommitMemory(u32 final_num_bytes);
+
+		void Destroy(bool defer = true);
+
+	private:
+		void UpdateCurrentFencePosition();
+		void UpdateGPUPosition();
+
+		// Waits for as many fences as needed to allocate num_bytes bytes from the buffer.
+		bool WaitForClearSpace(u32 num_bytes);
+
+		u32 m_size = 0;
+		u32 m_current_offset = 0;
+		u32 m_current_space = 0;
+		u32 m_current_gpu_position = 0;
+
+		wil::com_ptr_nothrow<ID3D12Resource> m_buffer;
+		wil::com_ptr_nothrow<D3D12MA::Allocation> m_allocation;
+		D3D12_GPU_VIRTUAL_ADDRESS m_gpu_pointer = {};
+		u8* m_host_pointer = nullptr;
+
+		// List of fences and the corresponding positions in the buffer
+		std::deque<std::pair<u64, u32>> m_tracked_fences;
+	};
+
+} // namespace D3D12
--- a/common/D3D12/Texture.cpp
+++ b/common/D3D12/Texture.cpp
@@ -0,0 +1,506 @@
+/*  PCSX2 - PS2 Emulator for PCs
+ *  Copyright (C) 2002-2022  PCSX2 Dev Team
+ *
+ *  PCSX2 is free software: you can redistribute it and/or modify it under the terms
+ *  of the GNU Lesser General Public License as published by the Free Software Found-
+ *  ation, either version 3 of the License, or (at your option) any later version.
+ *
+ *  PCSX2 is distributed in the hope that it will be useful, but WITHOUT ANY WARRANTY;
+ *  without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR
+ *  PURPOSE.  See the GNU General Public License for more details.
+ *
+ *  You should have received a copy of the GNU General Public License along with PCSX2.
+ *  If not, see <http://www.gnu.org/licenses/>.
+ */
+
+#include "common/PrecompiledHeader.h"
+
+#include "common/D3D12/Texture.h"
+#include "common/D3D12/Context.h"
+#include "common/D3D12/Util.h"
+#include "common/Align.h"
+#include "common/Assertions.h"
+#include "common/Console.h"
+#include "common/StringUtil.h"
+#include "D3D12MemAlloc.h"
+
+using namespace D3D12;
+
+Texture::Texture() = default;
+
+Texture::Texture(ID3D12Resource* resource, D3D12_RESOURCE_STATES state)
+	: m_resource(std::move(resource))
+{
+	const D3D12_RESOURCE_DESC desc = GetDesc();
+	m_width = static_cast<u32>(desc.Width);
+	m_height = desc.Height;
+	m_levels = desc.MipLevels;
+	m_format = desc.Format;
+}
+
+Texture::Texture(Texture&& texture)
+	: m_resource(std::move(texture.m_resource))
+	, m_allocation(std::move(texture.m_allocation))
+	, m_srv_descriptor(texture.m_srv_descriptor)
+	, m_write_descriptor(texture.m_write_descriptor)
+	, m_width(texture.m_width)
+	, m_height(texture.m_height)
+	, m_levels(texture.m_levels)
+	, m_format(texture.m_format)
+	, m_state(texture.m_state)
+	, m_write_descriptor_type(texture.m_write_descriptor_type)
+{
+	texture.m_srv_descriptor = {};
+	texture.m_write_descriptor = {};
+	texture.m_width = 0;
+	texture.m_height = 0;
+	texture.m_levels = 0;
+	texture.m_format = DXGI_FORMAT_UNKNOWN;
+	texture.m_state = D3D12_RESOURCE_STATE_COMMON;
+	texture.m_write_descriptor_type = WriteDescriptorType::None;
+}
+
+Texture::~Texture()
+{
+	Destroy();
+}
+
+Texture& Texture::operator=(Texture&& texture)
+{
+	Destroy();
+	m_resource = std::move(texture.m_resource);
+	m_allocation = std::move(texture.m_allocation);
+	m_srv_descriptor = texture.m_srv_descriptor;
+	m_write_descriptor = texture.m_write_descriptor;
+	m_width = texture.m_width;
+	m_height = texture.m_height;
+	m_levels = texture.m_levels;
+	m_format = texture.m_format;
+	m_state = texture.m_state;
+	m_write_descriptor_type = texture.m_write_descriptor_type;
+	texture.m_srv_descriptor = {};
+	texture.m_write_descriptor = {};
+	texture.m_width = 0;
+	texture.m_height = 0;
+	texture.m_levels = 0;
+	texture.m_format = DXGI_FORMAT_UNKNOWN;
+	texture.m_state = D3D12_RESOURCE_STATE_COMMON;
+	texture.m_write_descriptor_type = WriteDescriptorType::None;
+	return *this;
+}
+
+D3D12_RESOURCE_DESC Texture::GetDesc() const
+{
+	return m_resource->GetDesc();
+}
+
+bool Texture::Create(u32 width, u32 height, u32 levels, DXGI_FORMAT format, DXGI_FORMAT srv_format,
+	DXGI_FORMAT rtv_format, DXGI_FORMAT dsv_format, D3D12_RESOURCE_FLAGS flags, u32 alloc_flags)
+{
+	D3D12_RESOURCE_DESC desc = {};
+	desc.Dimension = D3D12_RESOURCE_DIMENSION_TEXTURE2D;
+	desc.Width = width;
+	desc.Height = height;
+	desc.DepthOrArraySize = 1;
+	desc.MipLevels = levels;
+	desc.Format = format;
+	desc.SampleDesc.Count = 1;
+	desc.Layout = D3D12_TEXTURE_LAYOUT_UNKNOWN;
+	desc.Flags = flags;
+
+	D3D12_CLEAR_VALUE optimized_clear_value = {};
+	D3D12_RESOURCE_STATES state;
+	if (rtv_format != DXGI_FORMAT_UNKNOWN)
+	{
+		optimized_clear_value.Format = rtv_format;
+		state = D3D12_RESOURCE_STATE_RENDER_TARGET;
+	}
+	else if (dsv_format != DXGI_FORMAT_UNKNOWN)
+	{
+		optimized_clear_value.Format = dsv_format;
+		state = D3D12_RESOURCE_STATE_DEPTH_WRITE;
+	}
+	else
+	{
+		state = D3D12_RESOURCE_STATE_PIXEL_SHADER_RESOURCE;
+	}
+
+	D3D12MA::ALLOCATION_DESC allocationDesc = {};
+	allocationDesc.Flags = static_cast<D3D12MA::ALLOCATION_FLAGS>(alloc_flags) | D3D12MA::ALLOCATION_FLAG_WITHIN_BUDGET;
+	allocationDesc.HeapType = D3D12_HEAP_TYPE_DEFAULT;
+
+	ComPtr<ID3D12Resource> resource;
+	ComPtr<D3D12MA::Allocation> allocation;
+	HRESULT hr = g_d3d12_context->GetAllocator()->CreateResource(
+		&allocationDesc, &desc, state,
+		(rtv_format != DXGI_FORMAT_UNKNOWN || dsv_format != DXGI_FORMAT_UNKNOWN) ? &optimized_clear_value : nullptr,
+		allocation.put(), IID_PPV_ARGS(resource.put()));
+	if (FAILED(hr))
+	{
+		// OOM isn't fatal.
+		if (hr != E_OUTOFMEMORY)
+			Console.Error("Create texture failed: 0x%08X", hr);
+
+		return false;
+	}
+
+	DescriptorHandle srv_descriptor, write_descriptor;
+	WriteDescriptorType write_descriptor_type = WriteDescriptorType::None;
+	if (srv_format != DXGI_FORMAT_UNKNOWN)
+	{
+		if (!CreateSRVDescriptor(resource.get(), levels, srv_format, &srv_descriptor))
+			return false;
+	}
+
+	if (rtv_format != DXGI_FORMAT_UNKNOWN)
+	{
+		pxAssert(dsv_format == DXGI_FORMAT_UNKNOWN && !(flags & D3D12_RESOURCE_FLAG_ALLOW_UNORDERED_ACCESS));
+		write_descriptor_type = Texture::WriteDescriptorType::RTV;
+		if (!CreateRTVDescriptor(resource.get(), rtv_format, &write_descriptor))
+		{
+			g_d3d12_context->GetRTVHeapManager().Free(&srv_descriptor);
+			return false;
+		}
+
+	}
+	else if (dsv_format != DXGI_FORMAT_UNKNOWN && !(flags & D3D12_RESOURCE_FLAG_ALLOW_UNORDERED_ACCESS))
+	{
+		write_descriptor_type = Texture::WriteDescriptorType::DSV;
+		if (!CreateDSVDescriptor(resource.get(), dsv_format, &write_descriptor))
+		{
+			g_d3d12_context->GetDSVHeapManager().Free(&srv_descriptor);
+			return false;
+		}
+	}
+	else if (flags & D3D12_RESOURCE_FLAG_ALLOW_UNORDERED_ACCESS)
+	{
+		write_descriptor_type = Texture::WriteDescriptorType::UAV;
+		if (!CreateUAVDescriptor(resource.get(), dsv_format, &write_descriptor))
+		{
+			g_d3d12_context->GetDescriptorHeapManager().Free(&srv_descriptor);
+			return false;
+		}
+	}
+
+	Destroy(true);
+
+	m_resource = std::move(resource);
+	m_allocation = std::move(allocation);
+	m_srv_descriptor = std::move(srv_descriptor);
+	m_write_descriptor = std::move(write_descriptor);
+	m_width = width;
+	m_height = height;
+	m_levels = levels;
+	m_format = format;
+	m_state = state;
+	m_write_descriptor_type = write_descriptor_type;
+	return true;
+}
+
+bool Texture::Adopt(ComPtr<ID3D12Resource> texture, DXGI_FORMAT srv_format, DXGI_FORMAT rtv_format,
+	DXGI_FORMAT dsv_format, D3D12_RESOURCE_STATES state)
+{
+	const D3D12_RESOURCE_DESC desc(texture->GetDesc());
+
+	DescriptorHandle srv_descriptor, write_descriptor;
+	WriteDescriptorType write_descriptor_type = WriteDescriptorType::None;
+	if (srv_format != DXGI_FORMAT_UNKNOWN)
+	{
+		if (!CreateSRVDescriptor(texture.get(), desc.MipLevels, srv_format, &srv_descriptor))
+			return false;
+	}
+
+	if (rtv_format != DXGI_FORMAT_UNKNOWN)
+	{
+		pxAssert(dsv_format == DXGI_FORMAT_UNKNOWN);
+		write_descriptor_type = Texture::WriteDescriptorType::RTV;
+		if (!CreateRTVDescriptor(texture.get(), rtv_format, &write_descriptor))
+		{
+			g_d3d12_context->GetRTVHeapManager().Free(&srv_descriptor);
+			return false;
+		}
+	}
+	else if (dsv_format != DXGI_FORMAT_UNKNOWN)
+	{
+		write_descriptor_type = Texture::WriteDescriptorType::DSV;
+		if (!CreateDSVDescriptor(texture.get(), dsv_format, &write_descriptor))
+		{
+			g_d3d12_context->GetDSVHeapManager().Free(&srv_descriptor);
+			return false;
+		}
+	}
+	else if (desc.Flags & D3D12_RESOURCE_FLAG_ALLOW_UNORDERED_ACCESS)
+	{
+		write_descriptor_type = Texture::WriteDescriptorType::UAV;
+		if (!CreateUAVDescriptor(texture.get(), srv_format, &write_descriptor))
+		{
+			g_d3d12_context->GetDescriptorHeapManager().Free(&srv_descriptor);
+			return false;
+		}
+	}
+
+	m_resource = std::move(texture);
+	m_allocation.reset();
+	m_srv_descriptor = std::move(srv_descriptor);
+	m_write_descriptor = std::move(write_descriptor);
+	m_write_descriptor_type = write_descriptor_type;
+	m_width = static_cast<u32>(desc.Width);
+	m_height = desc.Height;
+	m_levels = desc.MipLevels;
+	m_format = desc.Format;
+	m_state = state;
+	return true;
+}
+
+void Texture::Destroy(bool defer /* = true */)
+{
+	if (defer)
+	{
+		g_d3d12_context->DeferDescriptorDestruction(g_d3d12_context->GetDescriptorHeapManager(), &m_srv_descriptor);
+
+		switch (m_write_descriptor_type)
+		{
+			case Texture::WriteDescriptorType::RTV:
+				g_d3d12_context->DeferDescriptorDestruction(g_d3d12_context->GetRTVHeapManager(), &m_write_descriptor);
+				break;
+			case Texture::WriteDescriptorType::DSV:
+				g_d3d12_context->DeferDescriptorDestruction(g_d3d12_context->GetDSVHeapManager(), &m_write_descriptor);
+				break;
+			case Texture::WriteDescriptorType::UAV:
+				g_d3d12_context->DeferDescriptorDestruction(g_d3d12_context->GetDescriptorHeapManager(), &m_write_descriptor);
+				break;
+			case Texture::WriteDescriptorType::None:
+			default:
+				break;
+		}
+
+		g_d3d12_context->DeferResourceDestruction(m_allocation.get(), m_resource.get());
+		m_resource.reset();
+		m_allocation.reset();
+	}
+	else
+	{
+		g_d3d12_context->GetDescriptorHeapManager().Free(&m_srv_descriptor);
+
+		switch (m_write_descriptor_type)
+		{
+			case Texture::WriteDescriptorType::RTV:
+				g_d3d12_context->GetRTVHeapManager().Free(&m_write_descriptor);
+				break;
+			case Texture::WriteDescriptorType::DSV:
+				g_d3d12_context->GetDSVHeapManager().Free(&m_write_descriptor);
+				break;
+			case Texture::WriteDescriptorType::UAV:
+				g_d3d12_context->GetDescriptorHeapManager().Free(&m_write_descriptor);
+				break;
+			case Texture::WriteDescriptorType::None:
+			default:
+				break;
+		}
+
+		m_resource.reset();
+		m_allocation.reset();
+	}
+
+	m_width = 0;
+	m_height = 0;
+	m_levels = 0;
+	m_format = DXGI_FORMAT_UNKNOWN;
+	m_write_descriptor_type = WriteDescriptorType::None;
+}
+
+void Texture::TransitionToState(ID3D12GraphicsCommandList* cmdlist, D3D12_RESOURCE_STATES state)
+{
+	if (m_state == state)
+		return;
+
+	ResourceBarrier(cmdlist, m_resource.get(), m_state, state);
+	m_state = state;
+}
+
+void Texture::TransitionSubresourceToState(ID3D12GraphicsCommandList* cmdlist, u32 level,
+	D3D12_RESOURCE_STATES before_state, D3D12_RESOURCE_STATES after_state) const
+{
+	const D3D12_RESOURCE_BARRIER barrier = {D3D12_RESOURCE_BARRIER_TYPE_TRANSITION,
+		D3D12_RESOURCE_BARRIER_FLAG_NONE,
+		{{m_resource.get(), level, before_state, after_state}}};
+	cmdlist->ResourceBarrier(1, &barrier);
+}
+
+ID3D12GraphicsCommandList* Texture::BeginStreamUpdate(ID3D12GraphicsCommandList* cmdlist, u32 level, u32 x, u32 y, u32 width, u32 height, void** out_data, u32* out_data_pitch)
+{
+	const u32 copy_pitch = Common::AlignUpPow2(width * GetTexelSize(m_format), D3D12_TEXTURE_DATA_PITCH_ALIGNMENT);
+	const u32 upload_size = copy_pitch * height;
+
+	if (!g_d3d12_context->GetTextureStreamBuffer().ReserveMemory(upload_size, D3D12_TEXTURE_DATA_PLACEMENT_ALIGNMENT))
+	{
+		DevCon.WriteLn("Executing command buffer while waiting for %u bytes (%ux%u) in upload buffer", upload_size, width,
+			height);
+		g_d3d12_context->ExecuteCommandList(Context::WaitType::None);
+		if (!g_d3d12_context->GetTextureStreamBuffer().ReserveMemory(upload_size, D3D12_TEXTURE_DATA_PLACEMENT_ALIGNMENT))
+		{
+			Console.Error("Failed to reserve %u bytes for %ux%u upload", upload_size, width, height);
+			return nullptr;
+		}
+
+		// cmdlist change
+		cmdlist = g_d3d12_context->GetInitCommandList();
+	}
+
+	*out_data = g_d3d12_context->GetTextureStreamBuffer().GetCurrentHostPointer();
+	*out_data_pitch = copy_pitch;
+	return cmdlist;
+}
+
+void Texture::EndStreamUpdate(ID3D12GraphicsCommandList* cmdlist, u32 level, u32 x, u32 y, u32 width, u32 height)
+{
+	const u32 copy_pitch = Common::AlignUpPow2(width * GetTexelSize(m_format), D3D12_TEXTURE_DATA_PITCH_ALIGNMENT);
+	const u32 upload_size = copy_pitch * height;
+
+	StreamBuffer& sb = g_d3d12_context->GetTextureStreamBuffer();
+	const u32 sb_offset = sb.GetCurrentOffset();
+	sb.CommitMemory(upload_size);
+
+	CopyFromBuffer(cmdlist, level, x, y, width, height, copy_pitch, sb.GetBuffer(), sb_offset);
+}
+
+void Texture::CopyFromBuffer(ID3D12GraphicsCommandList* cmdlist, u32 level, u32 x, u32 y, u32 width, u32 height, u32 pitch, ID3D12Resource* buffer, u32 buffer_offset)
+{
+	D3D12_TEXTURE_COPY_LOCATION src;
+	src.pResource = buffer;
+	src.Type = D3D12_TEXTURE_COPY_TYPE_PLACED_FOOTPRINT;
+	src.PlacedFootprint.Offset = buffer_offset;
+	src.PlacedFootprint.Footprint.Width = width;
+	src.PlacedFootprint.Footprint.Height = height;
+	src.PlacedFootprint.Footprint.Depth = 1;
+	src.PlacedFootprint.Footprint.RowPitch = pitch;
+	src.PlacedFootprint.Footprint.Format = m_format;
+
+	D3D12_TEXTURE_COPY_LOCATION dst;
+	dst.pResource = m_resource.get();
+	dst.SubresourceIndex = level;
+	dst.Type = D3D12_TEXTURE_COPY_TYPE_SUBRESOURCE_INDEX;
+
+	const D3D12_BOX src_box{0u, 0u, 0u, width, height, 1u};
+	const D3D12_RESOURCE_STATES old_state = m_state;
+	TransitionToState(cmdlist, D3D12_RESOURCE_STATE_COPY_DEST);
+	cmdlist->CopyTextureRegion(&dst, x, y, 0, &src, &src_box);
+	TransitionToState(cmdlist, old_state);
+}
+
+static ID3D12Resource* CreateStagingBuffer(u32 height, const void* data, u32 pitch, u32 upload_pitch, u32 upload_size)
+{
+	wil::com_ptr_nothrow<ID3D12Resource> resource;
+	wil::com_ptr_nothrow<D3D12MA::Allocation> allocation;
+
+	const D3D12MA::ALLOCATION_DESC allocation_desc = {D3D12MA::ALLOCATION_FLAG_NONE, D3D12_HEAP_TYPE_UPLOAD};
+	const D3D12_RESOURCE_DESC resource_desc = {
+		D3D12_RESOURCE_DIMENSION_BUFFER, 0, upload_size, 1, 1, 1, DXGI_FORMAT_UNKNOWN, {1, 0}, D3D12_TEXTURE_LAYOUT_ROW_MAJOR,
+		D3D12_RESOURCE_FLAG_NONE};
+	HRESULT hr = g_d3d12_context->GetAllocator()->CreateResource(&allocation_desc, &resource_desc, D3D12_RESOURCE_STATE_GENERIC_READ,
+		nullptr, allocation.put(), IID_PPV_ARGS(resource.put()));
+	if (FAILED(hr))
+	{
+		Console.Error("CreateResource() for upload staging buffer failed: %08X", hr);
+		return nullptr;
+	}
+
+	void* map;
+	const D3D12_RANGE read_range = {};
+	hr = resource->Map(0, &read_range, &map);
+	if (FAILED(hr))
+	{
+		Console.Error("Map() for upload staging buffer failed: %08X", hr);
+		return nullptr;
+	}
+
+	StringUtil::StrideMemCpy(map, upload_pitch, data, pitch, std::min(pitch, upload_pitch), height);
+
+	const D3D12_RANGE write_range = {0u, upload_size};
+	resource->Unmap(0, &write_range);
+
+	// queue them for destruction, since the upload happens in this cmdlist
+	g_d3d12_context->DeferResourceDestruction(allocation.get(), resource.get());
+
+	// AddRef()'ed by the defer above.
+	return resource.get();
+}
+
+bool Texture::LoadData(ID3D12GraphicsCommandList* cmdlist, u32 level, u32 x, u32 y, u32 width, u32 height, const void* data, u32 pitch)
+{
+	const u32 texel_size = GetTexelSize(m_format);
+	const u32 upload_pitch = Common::AlignUpPow2(width * texel_size, D3D12_TEXTURE_DATA_PITCH_ALIGNMENT);
+	const u32 upload_size = upload_pitch * height;
+	if (upload_size >= g_d3d12_context->GetTextureStreamBuffer().GetSize())
+	{
+		ID3D12Resource* staging_buffer = CreateStagingBuffer(height, data, pitch, upload_pitch, upload_size);
+		if (!staging_buffer)
+			return false;
+
+		CopyFromBuffer(cmdlist, level, x, y, width, height, upload_pitch, staging_buffer, 0);
+		return true;
+	}
+
+	void* write_ptr;
+	u32 write_pitch;
+	if (!(cmdlist = BeginStreamUpdate(cmdlist, level, x, y, width, height, &write_ptr, &write_pitch)))
+		return false;
+
+	StringUtil::StrideMemCpy(write_ptr, write_pitch, data, pitch, std::min(pitch, upload_pitch), height);
+	EndStreamUpdate(cmdlist, level, x, y, width, height);
+	return true;
+}
+
+bool Texture::CreateSRVDescriptor(ID3D12Resource* resource, u32 levels, DXGI_FORMAT format, DescriptorHandle* dh)
+{
+	if (!g_d3d12_context->GetDescriptorHeapManager().Allocate(dh))
+	{
+		Console.Error("Failed to allocate SRV descriptor");
+		return false;
+	}
+
+	D3D12_SHADER_RESOURCE_VIEW_DESC desc = {format, D3D12_SRV_DIMENSION_TEXTURE2D, D3D12_DEFAULT_SHADER_4_COMPONENT_MAPPING};
+	desc.Texture2D.MipLevels = levels;
+
+	g_d3d12_context->GetDevice()->CreateShaderResourceView(resource, &desc, dh->cpu_handle);
+	return true;
+}
+
+bool Texture::CreateRTVDescriptor(ID3D12Resource* resource, DXGI_FORMAT format, DescriptorHandle* dh)
+{
+	if (!g_d3d12_context->GetRTVHeapManager().Allocate(dh))
+	{
+		Console.Error("Failed to allocate SRV descriptor");
+		return false;
+	}
+
+	const D3D12_RENDER_TARGET_VIEW_DESC desc = {format, D3D12_RTV_DIMENSION_TEXTURE2D};
+	g_d3d12_context->GetDevice()->CreateRenderTargetView(resource, &desc, dh->cpu_handle);
+	return true;
+}
+
+bool Texture::CreateDSVDescriptor(ID3D12Resource* resource, DXGI_FORMAT format, DescriptorHandle* dh)
+{
+	if (!g_d3d12_context->GetDSVHeapManager().Allocate(dh))
+	{
+		Console.Error("Failed to allocate SRV descriptor");
+		return false;
+	}
+
+	const D3D12_DEPTH_STENCIL_VIEW_DESC desc = {format, D3D12_DSV_DIMENSION_TEXTURE2D, D3D12_DSV_FLAG_NONE};
+	g_d3d12_context->GetDevice()->CreateDepthStencilView(resource, &desc, dh->cpu_handle);
+	return true;
+}
+
+bool Texture::CreateUAVDescriptor(ID3D12Resource* resource, DXGI_FORMAT format, DescriptorHandle* dh)
+{
+	if (!g_d3d12_context->GetDescriptorHeapManager().Allocate(dh))
+	{
+		Console.Error("Failed to allocate UAV descriptor");
+		return false;
+	}
+
+	const D3D12_UNORDERED_ACCESS_VIEW_DESC desc = {format, D3D12_UAV_DIMENSION_TEXTURE2D};
+	g_d3d12_context->GetDevice()->CreateUnorderedAccessView(resource, nullptr, &desc, dh->cpu_handle);
+	return true;
+}
--- a/common/D3D12/Texture.h
+++ b/common/D3D12/Texture.h
@@ -0,0 +1,109 @@
+/*  PCSX2 - PS2 Emulator for PCs
+ *  Copyright (C) 2002-2022  PCSX2 Dev Team
+ *
+ *  PCSX2 is free software: you can redistribute it and/or modify it under the terms
+ *  of the GNU Lesser General Public License as published by the Free Software Found-
+ *  ation, either version 3 of the License, or (at your option) any later version.
+ *
+ *  PCSX2 is distributed in the hope that it will be useful, but WITHOUT ANY WARRANTY;
+ *  without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR
+ *  PURPOSE.  See the GNU General Public License for more details.
+ *
+ *  You should have received a copy of the GNU General Public License along with PCSX2.
+ *  If not, see <http://www.gnu.org/licenses/>.
+ */
+
+#pragma once
+
+#include "common/Pcsx2Defs.h"
+#include "common/RedtapeWindows.h"
+#include "common/D3D12/DescriptorHeapManager.h"
+
+#include <d3d12.h>
+#include <wil/com.h>
+
+namespace D3D12MA
+{
+class Allocation;
+}
+
+namespace D3D12
+{
+	class StreamBuffer;
+
+	class Texture final
+	{
+	public:
+		template <typename T>
+		using ComPtr = wil::com_ptr_nothrow<T>;
+
+		Texture();
+		Texture(ID3D12Resource* resource, D3D12_RESOURCE_STATES state);
+		Texture(Texture&& texture);
+		Texture(const Texture&) = delete;
+		~Texture();
+
+		__fi ID3D12Resource* GetResource() const { return m_resource.get(); }
+		__fi D3D12MA::Allocation* GetAllocation() const { return m_allocation.get(); }
+		__fi const DescriptorHandle& GetSRVDescriptor() const { return m_srv_descriptor; }
+		__fi const DescriptorHandle& GetWriteDescriptor() const { return m_write_descriptor; }
+		__fi D3D12_RESOURCE_STATES GetState() const { return m_state; }
+
+		__fi u32 GetWidth() const { return m_width; }
+		__fi u32 GetHeight() const { return m_height; }
+		__fi u32 GetLevels() const { return m_levels; }
+		__fi DXGI_FORMAT GetFormat() const { return m_format; }
+
+		__fi operator ID3D12Resource*() const { return m_resource.get(); }
+		__fi operator bool() const { return static_cast<bool>(m_resource); }
+
+		bool Create(u32 width, u32 height, u32 levels, DXGI_FORMAT format, DXGI_FORMAT srv_format,
+			DXGI_FORMAT rtv_format, DXGI_FORMAT dsv_format, D3D12_RESOURCE_FLAGS flags, u32 alloc_flags = 0);
+		bool Adopt(ComPtr<ID3D12Resource> texture, DXGI_FORMAT srv_format, DXGI_FORMAT rtv_format, DXGI_FORMAT dsv_format,
+			D3D12_RESOURCE_STATES state);
+
+		D3D12_RESOURCE_DESC GetDesc() const;
+
+		void Destroy(bool defer = true);
+
+		void TransitionToState(ID3D12GraphicsCommandList* cmdlist, D3D12_RESOURCE_STATES state);
+		void TransitionSubresourceToState(ID3D12GraphicsCommandList* cmdlist, u32 level,
+			D3D12_RESOURCE_STATES before_state, D3D12_RESOURCE_STATES after_state) const;
+
+		Texture& operator=(const Texture&) = delete;
+		Texture& operator=(Texture&& texture);
+
+		// NOTE: Does not handle compressed formats.
+		ID3D12GraphicsCommandList* BeginStreamUpdate(ID3D12GraphicsCommandList* cmdlist, u32 level, u32 x, u32 y, u32 width, u32 height, void** out_data, u32* out_data_pitch);
+		void EndStreamUpdate(ID3D12GraphicsCommandList* cmdlist, u32 level, u32 x, u32 y, u32 width, u32 height);
+		bool LoadData(ID3D12GraphicsCommandList* cmdlist, u32 level, u32 x, u32 y, u32 width, u32 height, const void* data, u32 pitch);
+		void CopyFromBuffer(ID3D12GraphicsCommandList* cmdlist, u32 level, u32 x, u32 y, u32 width, u32 height, u32 pitch, ID3D12Resource* buffer, u32 buffer_offset);
+
+	private:
+		static bool CreateSRVDescriptor(ID3D12Resource* resource, u32 levels, DXGI_FORMAT format, DescriptorHandle* dh);
+		static bool CreateRTVDescriptor(ID3D12Resource* resource, DXGI_FORMAT format, DescriptorHandle* dh);
+		static bool CreateDSVDescriptor(ID3D12Resource* resource, DXGI_FORMAT format, DescriptorHandle* dh);
+		static bool CreateUAVDescriptor(ID3D12Resource* resource, DXGI_FORMAT format, DescriptorHandle* dh);
+
+		enum class WriteDescriptorType : u8
+		{
+			None,
+			RTV,
+			DSV,
+			UAV
+		};
+
+		ComPtr<ID3D12Resource> m_resource;
+		ComPtr<D3D12MA::Allocation> m_allocation;
+		DescriptorHandle m_srv_descriptor = {};
+		DescriptorHandle m_write_descriptor = {};
+		u32 m_width = 0;
+		u32 m_height = 0;
+		u32 m_levels = 0;
+		DXGI_FORMAT m_format = DXGI_FORMAT_UNKNOWN;
+
+		D3D12_RESOURCE_STATES m_state = D3D12_RESOURCE_STATE_COMMON;
+
+		WriteDescriptorType m_write_descriptor_type = WriteDescriptorType::None;
+	};
+} // namespace D3D12
--- a/common/D3D12/Util.cpp
+++ b/common/D3D12/Util.cpp
@@ -0,0 +1,93 @@
+/*  PCSX2 - PS2 Emulator for PCs
+ *  Copyright (C) 2002-2022  PCSX2 Dev Team
+ *
+ *  PCSX2 is free software: you can redistribute it and/or modify it under the terms
+ *  of the GNU Lesser General Public License as published by the Free Software Found-
+ *  ation, either version 3 of the License, or (at your option) any later version.
+ *
+ *  PCSX2 is distributed in the hope that it will be useful, but WITHOUT ANY WARRANTY;
+ *  without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR
+ *  PURPOSE.  See the GNU General Public License for more details.
+ *
+ *  You should have received a copy of the GNU General Public License along with PCSX2.
+ *  If not, see <http://www.gnu.org/licenses/>.
+ */
+
+#include "common/PrecompiledHeader.h"
+
+#include "common/D3D12/Util.h"
+#include "common/Assertions.h"
+#include "common/StringUtil.h"
+
+u32 D3D12::GetTexelSize(DXGI_FORMAT format)
+{
+	switch (format)
+	{
+		case DXGI_FORMAT_R32G32B32A32_FLOAT:
+		case DXGI_FORMAT_BC1_UNORM:
+		case DXGI_FORMAT_BC2_UNORM:
+		case DXGI_FORMAT_BC3_UNORM:
+		case DXGI_FORMAT_BC7_UNORM:
+			return 16;
+
+		case DXGI_FORMAT_D32_FLOAT_S8X24_UINT:
+			return 4;
+
+		case DXGI_FORMAT_R8G8B8A8_UNORM:
+		case DXGI_FORMAT_R8G8B8A8_SNORM:
+		case DXGI_FORMAT_R8G8B8A8_TYPELESS:
+		case DXGI_FORMAT_B8G8R8A8_UNORM:
+		case DXGI_FORMAT_B8G8R8A8_TYPELESS:
+		case DXGI_FORMAT_R32_UINT:
+		case DXGI_FORMAT_R32_SINT:
+			return 4;
+
+		case DXGI_FORMAT_B5G5R5A1_UNORM:
+		case DXGI_FORMAT_B5G6R5_UNORM:
+		case DXGI_FORMAT_R16_UINT:
+		case DXGI_FORMAT_R16_SINT:
+			return 2;
+
+		case DXGI_FORMAT_A8_UNORM:
+		case DXGI_FORMAT_R8_UNORM:
+			return 1;
+
+		default:
+			pxFailRel("Unknown format");
+			return 1;
+	}
+}
+
+void D3D12::SetDefaultSampler(D3D12_SAMPLER_DESC* desc)
+{
+	desc->Filter = D3D12_FILTER_MIN_MAG_MIP_LINEAR;
+	desc->AddressU = D3D12_TEXTURE_ADDRESS_MODE_CLAMP;
+	desc->AddressV = D3D12_TEXTURE_ADDRESS_MODE_CLAMP;
+	desc->AddressW = D3D12_TEXTURE_ADDRESS_MODE_CLAMP;
+	desc->MipLODBias = 0;
+	desc->MaxAnisotropy = 1;
+	desc->ComparisonFunc = D3D12_COMPARISON_FUNC_NEVER;
+	desc->BorderColor[0] = 1.0f;
+	desc->BorderColor[1] = 1.0f;
+	desc->BorderColor[2] = 1.0f;
+	desc->BorderColor[3] = 1.0f;
+	desc->MinLOD = -3.402823466e+38F; // -FLT_MAX
+	desc->MaxLOD = 3.402823466e+38F; // FLT_MAX
+}
+
+#ifdef _DEBUG
+
+void D3D12::SetObjectName(ID3D12Object* object, const char* name)
+{
+	object->SetName(StringUtil::UTF8StringToWideString(name).c_str());
+}
+
+void D3D12::SetObjectNameFormatted(ID3D12Object* object, const char* format, ...)
+{
+	std::va_list ap;
+	va_start(ap, format);
+	SetObjectName(object, StringUtil::StdStringFromFormatV(format, ap).c_str());
+	va_end(ap);
+}
+
+#endif
--- a/common/D3D12/Util.h
+++ b/common/D3D12/Util.h
@@ -0,0 +1,77 @@
+/*  PCSX2 - PS2 Emulator for PCs
+ *  Copyright (C) 2002-2022  PCSX2 Dev Team
+ *
+ *  PCSX2 is free software: you can redistribute it and/or modify it under the terms
+ *  of the GNU Lesser General Public License as published by the Free Software Found-
+ *  ation, either version 3 of the License, or (at your option) any later version.
+ *
+ *  PCSX2 is distributed in the hope that it will be useful, but WITHOUT ANY WARRANTY;
+ *  without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR
+ *  PURPOSE.  See the GNU General Public License for more details.
+ *
+ *  You should have received a copy of the GNU General Public License along with PCSX2.
+ *  If not, see <http://www.gnu.org/licenses/>.
+ */
+
+#pragma once
+
+#include "common/Pcsx2Defs.h"
+#include "common/RedtapeWindows.h"
+
+#include <array>
+#include <d3d12.h>
+
+namespace D3D12
+{
+	static inline void ResourceBarrier(ID3D12GraphicsCommandList* cmdlist, ID3D12Resource* resource,
+		D3D12_RESOURCE_STATES from_state, D3D12_RESOURCE_STATES to_state)
+	{
+		const D3D12_RESOURCE_BARRIER barrier = {D3D12_RESOURCE_BARRIER_TYPE_TRANSITION,
+			D3D12_RESOURCE_BARRIER_FLAG_NONE,
+			{{resource, D3D12_RESOURCE_BARRIER_ALL_SUBRESOURCES, from_state, to_state}}};
+		cmdlist->ResourceBarrier(1, &barrier);
+	}
+
+	static inline void SetViewport(ID3D12GraphicsCommandList* cmdlist, int x, int y, int width, int height,
+		float min_depth = 0.0f, float max_depth = 1.0f)
+	{
+		const D3D12_VIEWPORT vp{static_cast<float>(x),
+			static_cast<float>(y),
+			static_cast<float>(width),
+			static_cast<float>(height),
+			min_depth,
+			max_depth};
+		cmdlist->RSSetViewports(1, &vp);
+	}
+
+	static inline void SetScissor(ID3D12GraphicsCommandList* cmdlist, int x, int y, int width, int height)
+	{
+		const D3D12_RECT r{x, y, x + width, y + height};
+		cmdlist->RSSetScissorRects(1, &r);
+	}
+
+	static inline void SetViewportAndScissor(ID3D12GraphicsCommandList* cmdlist, int x, int y, int width, int height,
+		float min_depth = 0.0f, float max_depth = 1.0f)
+	{
+		SetViewport(cmdlist, x, y, width, height, min_depth, max_depth);
+		SetScissor(cmdlist, x, y, width, height);
+	}
+
+	u32 GetTexelSize(DXGI_FORMAT format);
+
+	void SetDefaultSampler(D3D12_SAMPLER_DESC* desc);
+
+#ifdef _DEBUG
+
+	void SetObjectName(ID3D12Object* object, const char* name);
+	void SetObjectNameFormatted(ID3D12Object* object, const char* format, ...);
+
+#else
+
+	static inline void SetObjectName(ID3D12Object* object, const char* name)
+	{
+	}
+	static inline void SetObjectNameFormatted(ID3D12Object* object, const char* format, ...) {}
+
+#endif
+} // namespace D3D12
--- a/common/GL/Context.cpp
+++ b/common/GL/Context.cpp
@@ -0,0 +1,184 @@
+/*  PCSX2 - PS2 Emulator for PCs
+ *  Copyright (C) 2002-2021  PCSX2 Dev Team
+ *
+ *  PCSX2 is free software: you can redistribute it and/or modify it under the terms
+ *  of the GNU Lesser General Public License as published by the Free Software Found-
+ *  ation, either version 3 of the License, or (at your option) any later version.
+ *
+ *  PCSX2 is distributed in the hope that it will be useful, but WITHOUT ANY WARRANTY;
+ *  without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR
+ *  PURPOSE.  See the GNU General Public License for more details.
+ *
+ *  You should have received a copy of the GNU General Public License along with PCSX2.
+ *  If not, see <http://www.gnu.org/licenses/>.
+ */
+
+#include "common/PrecompiledHeader.h"
+
+#include "common/Console.h"
+#include "common/GL/Context.h"
+#include "glad.h"
+
+#include <cstdio>
+#include <cstdlib>
+#include <cstring>
+#ifdef __APPLE__
+#include <stdlib.h>
+#else
+#include <malloc.h>
+#endif
+
+#if defined(_WIN32) && !defined(_M_ARM64)
+#include "common/GL/ContextWGL.h"
+#elif defined(__APPLE__)
+#include "common/GL/ContextAGL.h"
+#else
+#ifdef X11_API
+#include "common/GL/ContextEGLX11.h"
+#endif
+#ifdef WAYLAND_API
+#include "common/GL/ContextEGLWayland.h"
+#endif
+#endif
+
+namespace GL
+{
+	static bool ShouldPreferESContext()
+	{
+#ifndef _MSC_VER
+		const char* value = std::getenv("PREFER_GLES_CONTEXT");
+		return (value && std::strcmp(value, "1") == 0);
+#else
+		char buffer[2] = {};
+		size_t buffer_size = sizeof(buffer);
+		getenv_s(&buffer_size, buffer, "PREFER_GLES_CONTEXT");
+		return (std::strcmp(buffer, "1") == 0);
+#endif
+	}
+
+	static void DisableBrokenExtensions(const char* gl_vendor, const char* gl_renderer)
+	{
+		if (std::strstr(gl_vendor, "ARM"))
+		{
+			// GL_{EXT,OES}_copy_image seem to be implemented on the CPU in the Mali drivers...
+			Console.Warning("Mali driver detected, disabling GL_{EXT,OES}_copy_image");
+			GLAD_GL_EXT_copy_image = 0;
+			GLAD_GL_OES_copy_image = 0;
+		}
+	}
+
+	Context::Context(const WindowInfo& wi)
+		: m_wi(wi)
+	{
+	}
+
+	Context::~Context() = default;
+
+	std::vector<Context::FullscreenModeInfo> Context::EnumerateFullscreenModes()
+	{
+		return {};
+	}
+
+	std::unique_ptr<GL::Context> Context::Create(const WindowInfo& wi, gsl::span<const Version> versions_to_try)
+	{
+		if (ShouldPreferESContext())
+		{
+			// move ES versions to the front
+			Version* new_versions_to_try = static_cast<Version*>(alloca(sizeof(Version) * versions_to_try.size()));
+			size_t count = 0;
+			for (size_t i = 0; i < versions_to_try.size(); i++)
+			{
+				if (versions_to_try[i].profile == Profile::ES)
+					new_versions_to_try[count++] = versions_to_try[i];
+			}
+			for (size_t i = 0; i < versions_to_try.size(); i++)
+			{
+				if (versions_to_try[i].profile != Profile::ES)
+					new_versions_to_try[count++] = versions_to_try[i];
+			}
+			versions_to_try = gsl::span<const Version>(new_versions_to_try, versions_to_try.size());
+		}
+
+		std::unique_ptr<Context> context;
+#if defined(_WIN32) && !defined(_M_ARM64)
+		context = ContextWGL::Create(wi, versions_to_try);
+#elif defined(__APPLE__)
+		context = ContextAGL::Create(wi, versions_to_try);
+#endif
+
+#if defined(X11_API)
+		if (wi.type == WindowInfo::Type::X11)
+			context = ContextEGLX11::Create(wi, versions_to_try);
+#endif
+
+#if defined(WAYLAND_API)
+		if (wi.type == WindowInfo::Type::Wayland)
+			context = ContextEGLWayland::Create(wi, versions_to_try);
+#endif
+
+		if (!context)
+			return nullptr;
+
+		Console.WriteLn("Created a %s context", context->IsGLES() ? "OpenGL ES" : "OpenGL");
+
+		// NOTE: Not thread-safe. But this is okay, since we're not going to be creating more than one context at a time.
+		static Context* context_being_created;
+		context_being_created = context.get();
+
+		// load up glad
+		if (!context->IsGLES())
+		{
+			if (!gladLoadGLLoader([](const char* name) { return context_being_created->GetProcAddress(name); }))
+			{
+				Console.Error("Failed to load GL functions for GLAD");
+				return nullptr;
+			}
+		}
+		else
+		{
+			if (!gladLoadGLES2Loader([](const char* name) { return context_being_created->GetProcAddress(name); }))
+			{
+				Console.Error("Failed to load GLES functions for GLAD");
+				return nullptr;
+			}
+		}
+
+		context_being_created = nullptr;
+
+		const char* gl_vendor = reinterpret_cast<const char*>(glGetString(GL_VENDOR));
+		const char* gl_renderer = reinterpret_cast<const char*>(glGetString(GL_RENDERER));
+		const char* gl_version = reinterpret_cast<const char*>(glGetString(GL_VERSION));
+		const char* gl_shading_language_version = reinterpret_cast<const char*>(glGetString(GL_SHADING_LANGUAGE_VERSION));
+		DevCon.WriteLn(Color_Magenta, "GL_VENDOR: %s", gl_vendor);
+		DevCon.WriteLn(Color_Magenta, "GL_RENDERER: %s", gl_renderer);
+		DevCon.WriteLn(Color_Magenta, "GL_VERSION: %s", gl_version);
+		DevCon.WriteLn(Color_Magenta, "GL_SHADING_LANGUAGE_VERSION: %s", gl_shading_language_version);
+
+		DisableBrokenExtensions(gl_vendor, gl_renderer);
+
+		return context;
+	}
+
+	gsl::span<const Context::Version> Context::GetAllVersionsList()
+	{
+		static constexpr Version vlist[] = {
+			{Profile::Core, 4, 6},
+			{Profile::Core, 4, 5},
+			{Profile::Core, 4, 4},
+			{Profile::Core, 4, 3},
+			{Profile::Core, 4, 2},
+			{Profile::Core, 4, 1},
+			{Profile::Core, 4, 0},
+			{Profile::Core, 3, 3},
+			{Profile::Core, 3, 2},
+			{Profile::Core, 3, 1},
+			{Profile::Core, 3, 0},
+			{Profile::ES, 3, 2},
+			{Profile::ES, 3, 1},
+			{Profile::ES, 3, 0},
+			{Profile::ES, 2, 0},
+			{Profile::NoProfile, 0, 0}
+		};
+		return vlist;
+	}
+} // namespace GL
--- a/common/GL/Context.h
+++ b/common/GL/Context.h
@@ -0,0 +1,80 @@
+/*  PCSX2 - PS2 Emulator for PCs
+ *  Copyright (C) 2002-2021  PCSX2 Dev Team
+ *
+ *  PCSX2 is free software: you can redistribute it and/or modify it under the terms
+ *  of the GNU Lesser General Public License as published by the Free Software Found-
+ *  ation, either version 3 of the License, or (at your option) any later version.
+ *
+ *  PCSX2 is distributed in the hope that it will be useful, but WITHOUT ANY WARRANTY;
+ *  without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR
+ *  PURPOSE.  See the GNU General Public License for more details.
+ *
+ *  You should have received a copy of the GNU General Public License along with PCSX2.
+ *  If not, see <http://www.gnu.org/licenses/>.
+ */
+
+#pragma once
+
+#include "common/Pcsx2Defs.h"
+#include "common/WindowInfo.h"
+
+#include <gsl/span>
+#include <array>
+#include <memory>
+#include <vector>
+
+namespace GL {
+	class Context
+	{
+	public:
+		Context(const WindowInfo& wi);
+		virtual ~Context();
+
+		enum class Profile
+		{
+			NoProfile,
+			Core,
+			ES
+		};
+
+		struct Version
+		{
+			Profile profile;
+			int major_version;
+			int minor_version;
+		};
+
+		struct FullscreenModeInfo
+		{
+			u32 width;
+			u32 height;
+			float refresh_rate;
+		};
+
+		__fi const WindowInfo& GetWindowInfo() const { return m_wi; }
+		__fi bool IsGLES() const { return (m_version.profile == Profile::ES); }
+		__fi u32 GetSurfaceWidth() const { return m_wi.surface_width; }
+		__fi u32 GetSurfaceHeight() const { return m_wi.surface_height; }
+
+		virtual void* GetProcAddress(const char* name) = 0;
+		virtual bool ChangeSurface(const WindowInfo& new_wi) = 0;
+		virtual void ResizeSurface(u32 new_surface_width = 0, u32 new_surface_height = 0) = 0;
+		virtual bool SwapBuffers() = 0;
+		virtual bool MakeCurrent() = 0;
+		virtual bool DoneCurrent() = 0;
+		virtual bool SetSwapInterval(s32 interval) = 0;
+		virtual std::unique_ptr<Context> CreateSharedContext(const WindowInfo& wi) = 0;
+
+		virtual std::vector<FullscreenModeInfo> EnumerateFullscreenModes();
+
+		static std::unique_ptr<Context> Create(const WindowInfo& wi, gsl::span<const Version> versions_to_try);
+
+		static std::unique_ptr<Context> Create(const WindowInfo& wi) { return Create(wi, GetAllVersionsList()); }
+
+		static gsl::span<const Version> GetAllVersionsList();
+
+	protected:
+		WindowInfo m_wi;
+		Version m_version = {};
+	};
+} // namespace GL
--- a/common/GL/ContextAGL.h
+++ b/common/GL/ContextAGL.h
@@ -0,0 +1,62 @@
+/*  PCSX2 - PS2 Emulator for PCs
+ *  Copyright (C) 2002-2021  PCSX2 Dev Team
+ *
+ *  PCSX2 is free software: you can redistribute it and/or modify it under the terms
+ *  of the GNU Lesser General Public License as published by the Free Software Found-
+ *  ation, either version 3 of the License, or (at your option) any later version.
+ *
+ *  PCSX2 is distributed in the hope that it will be useful, but WITHOUT ANY WARRANTY;
+ *  without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR
+ *  PURPOSE.  See the GNU General Public License for more details.
+ *
+ *  You should have received a copy of the GNU General Public License along with PCSX2.
+ *  If not, see <http://www.gnu.org/licenses/>.
+ */
+
+#pragma once
+#include "common/GL/Context.h"
+#include "glad.h"
+
+#if defined(__APPLE__) && defined(__OBJC__)
+#import <AppKit/AppKit.h>
+#else
+struct NSView;
+struct NSOpenGLContext;
+struct NSOpenGLPixelFormat;
+#endif
+
+namespace GL
+{
+	class ContextAGL final : public Context
+	{
+	public:
+		ContextAGL(const WindowInfo& wi);
+		~ContextAGL() override;
+
+		static std::unique_ptr<Context> Create(const WindowInfo& wi, gsl::span<const Version> versions_to_try);
+
+		void* GetProcAddress(const char* name) override;
+		bool ChangeSurface(const WindowInfo& new_wi) override;
+		void ResizeSurface(u32 new_surface_width = 0, u32 new_surface_height = 0) override;
+		bool SwapBuffers() override;
+		bool MakeCurrent() override;
+		bool DoneCurrent() override;
+		bool SetSwapInterval(s32 interval) override;
+		std::unique_ptr<Context> CreateSharedContext(const WindowInfo& wi) override;
+
+	private:
+		bool Initialize(gsl::span<const Version> versions_to_try);
+		bool CreateContext(NSOpenGLContext* share_context, int profile, bool make_current);
+		void BindContextToView();
+		void CleanupView();
+
+		// returns true if dimensions have changed
+		bool UpdateDimensions();
+
+		NSView* m_view = nullptr;
+		NSOpenGLContext* m_context = nullptr;
+		NSOpenGLPixelFormat* m_pixel_format = nullptr;
+		void* m_opengl_module_handle = nullptr;
+	};
+
+} // namespace GL
--- a/common/GL/ContextAGL.mm
+++ b/common/GL/ContextAGL.mm
@@ -0,0 +1,243 @@
+/*  PCSX2 - PS2 Emulator for PCs
+ *  Copyright (C) 2002-2021  PCSX2 Dev Team
+ *
+ *  PCSX2 is free software: you can redistribute it and/or modify it under the terms
+ *  of the GNU Lesser General Public License as published by the Free Software Found-
+ *  ation, either version 3 of the License, or (at your option) any later version.
+ *
+ *  PCSX2 is distributed in the hope that it will be useful, but WITHOUT ANY WARRANTY;
+ *  without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR
+ *  PURPOSE.  See the GNU General Public License for more details.
+ *
+ *  You should have received a copy of the GNU General Public License along with PCSX2.
+ *  If not, see <http://www.gnu.org/licenses/>.
+ */
+
+#include "common/GL/ContextAGL.h"
+#include "common/Assertions.h"
+#include "common/Console.h"
+#include "glad.h"
+#include <dlfcn.h>
+
+#if ! __has_feature(objc_arc)
+#error "Compile this with -fobjc-arc"
+#endif
+
+namespace GL
+{
+	ContextAGL::ContextAGL(const WindowInfo& wi)
+		: Context(wi)
+	{
+		m_opengl_module_handle = dlopen("/System/Library/Frameworks/OpenGL.framework/Versions/Current/OpenGL", RTLD_NOW);
+		if (!m_opengl_module_handle)
+			Console.Error("Could not open OpenGL.framework, function lookups will probably fail");
+	}
+
+	ContextAGL::~ContextAGL()
+	{
+		if ([NSOpenGLContext currentContext] == m_context)
+			[NSOpenGLContext clearCurrentContext];
+
+		CleanupView();
+
+		if (m_opengl_module_handle)
+			dlclose(m_opengl_module_handle);
+	}
+
+	std::unique_ptr<Context> ContextAGL::Create(const WindowInfo& wi, gsl::span<const Version> versions_to_try)
+	{
+		std::unique_ptr<ContextAGL> context = std::make_unique<ContextAGL>(wi);
+		if (!context->Initialize(versions_to_try))
+			return nullptr;
+
+		return context;
+	}
+
+	bool ContextAGL::Initialize(gsl::span<const Version> versions_to_try)
+	{
+		for (const Version& cv : versions_to_try)
+		{
+			if (cv.profile == Profile::NoProfile && CreateContext(nullptr, NSOpenGLProfileVersionLegacy, true))
+			{
+				// we already have the dummy context, so just use that
+				m_version = cv;
+				return true;
+			}
+			else if (cv.profile == Profile::Core)
+			{
+				if (cv.major_version > 4 || cv.minor_version > 1)
+					continue;
+
+				const NSOpenGLPixelFormatAttribute profile = (cv.major_version > 3 || cv.minor_version > 2) ? NSOpenGLProfileVersion4_1Core : NSOpenGLProfileVersion3_2Core;
+				if (CreateContext(nullptr, static_cast<int>(profile), true))
+				{
+					m_version = cv;
+					return true;
+				}
+			}
+		}
+
+		return false;
+	}
+
+	void* ContextAGL::GetProcAddress(const char* name)
+	{
+		void* addr = m_opengl_module_handle ? dlsym(m_opengl_module_handle, name) : nullptr;
+		if (addr)
+			return addr;
+
+		return dlsym(RTLD_NEXT, name);
+	}
+
+	bool ContextAGL::ChangeSurface(const WindowInfo& new_wi)
+	{
+		m_wi = new_wi;
+		BindContextToView();
+		return true;
+	}
+
+	void ContextAGL::ResizeSurface(u32 new_surface_width /*= 0*/, u32 new_surface_height /*= 0*/)
+	{
+		UpdateDimensions();
+	}
+
+	bool ContextAGL::UpdateDimensions()
+	{
+		if (![NSThread isMainThread])
+		{
+			bool ret;
+			dispatch_sync(dispatch_get_main_queue(), [this, &ret]{ ret = UpdateDimensions(); });
+			return ret;
+		}
+
+		const NSSize window_size = [m_view frame].size;
+		const CGFloat window_scale = [[m_view window] backingScaleFactor];
+		const u32 new_width = static_cast<u32>(window_size.width * window_scale);
+		const u32 new_height = static_cast<u32>(window_size.height * window_scale);
+
+		if (m_wi.surface_width == new_width && m_wi.surface_height == new_height)
+			return false;
+
+		m_wi.surface_width = new_width;
+		m_wi.surface_height = new_height;
+
+		[m_context update];
+
+		return true;
+	}
+
+	bool ContextAGL::SwapBuffers()
+	{
+		[m_context flushBuffer];
+		return true;
+	}
+
+	bool ContextAGL::MakeCurrent()
+	{
+		[m_context makeCurrentContext];
+		return true;
+	}
+
+	bool ContextAGL::DoneCurrent()
+	{
+		[NSOpenGLContext clearCurrentContext];
+		return true;
+	}
+
+	bool ContextAGL::SetSwapInterval(s32 interval)
+	{
+		GLint gl_interval = static_cast<GLint>(interval);
+		[m_context setValues:&gl_interval forParameter:NSOpenGLCPSwapInterval];
+		return true;
+	}
+
+	std::unique_ptr<Context> ContextAGL::CreateSharedContext(const WindowInfo& wi)
+	{
+		std::unique_ptr<ContextAGL> context = std::make_unique<ContextAGL>(wi);
+
+		context->m_context = [[NSOpenGLContext alloc] initWithFormat:m_pixel_format shareContext:m_context];
+		if (context->m_context == nil)
+			return nullptr;
+
+		context->m_version = m_version;
+		context->m_pixel_format = m_pixel_format;
+
+		if (wi.type == WindowInfo::Type::MacOS)
+			context->BindContextToView();
+
+		return context;
+	}
+
+	bool ContextAGL::CreateContext(NSOpenGLContext* share_context, int profile, bool make_current)
+	{
+		if (m_context)
+			m_context = nullptr;
+
+		const NSOpenGLPixelFormatAttribute attribs[] = {
+			NSOpenGLPFADoubleBuffer,
+			NSOpenGLPFAOpenGLProfile, static_cast<NSOpenGLPixelFormatAttribute>(profile),
+			NSOpenGLPFAAccelerated,
+			0
+		};
+
+		m_pixel_format = [[NSOpenGLPixelFormat alloc] initWithAttributes:attribs];
+		if (m_pixel_format == nil)
+		{
+			Console.Error("(ContextAGL) Failed to initialize pixel format");
+			return false;
+		}
+
+		m_context = [[NSOpenGLContext alloc] initWithFormat:m_pixel_format shareContext:nil];
+		if (m_context == nil)
+			return false;
+
+		if (m_wi.type == WindowInfo::Type::MacOS)
+			BindContextToView();
+
+		if (make_current)
+			[m_context makeCurrentContext];
+
+		return true;
+	}
+
+	void ContextAGL::BindContextToView()
+	{
+		if (![NSThread isMainThread])
+		{
+			dispatch_sync(dispatch_get_main_queue(), [this]{ BindContextToView(); });
+			return;
+		}
+
+#ifdef PCSX2_CORE
+		m_view = (__bridge NSView*)m_wi.window_handle;
+#else
+		// Drawing to wx's wxView somehow causes fighting between us and wx, resulting in massive CPU usage on the main thread and no image
+		// Avoid that by adding our own subview
+		CleanupView();
+		NSView* const superview = (__bridge NSView*)m_wi.window_handle;
+		m_view = [[NSView alloc] initWithFrame:[superview frame]];
+		[superview addSubview:m_view];
+		[m_view setAutoresizingMask:NSViewWidthSizable|NSViewHeightSizable];
+#endif
+		[m_view setWantsBestResolutionOpenGLSurface:YES];
+
+		UpdateDimensions();
+
+		[m_context setView:m_view];
+	}
+
+	void ContextAGL::CleanupView()
+	{
+#ifndef PCSX2_CORE
+		if (![NSThread isMainThread])
+		{
+			dispatch_sync(dispatch_get_main_queue(), [this]{ CleanupView(); });
+			return;
+		}
+
+		if (m_view)
+			[m_view removeFromSuperview];
+#endif
+		m_view = nullptr;
+	}
+} // namespace GL
--- a/common/GL/ContextEGL.cpp
+++ b/common/GL/ContextEGL.cpp
@@ -0,0 +1,391 @@
+/*  PCSX2 - PS2 Emulator for PCs
+ *  Copyright (C) 2002-2021  PCSX2 Dev Team
+ *
+ *  PCSX2 is free software: you can redistribute it and/or modify it under the terms
+ *  of the GNU Lesser General Public License as published by the Free Software Found-
+ *  ation, either version 3 of the License, or (at your option) any later version.
+ *
+ *  PCSX2 is distributed in the hope that it will be useful, but WITHOUT ANY WARRANTY;
+ *  without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR
+ *  PURPOSE.  See the GNU General Public License for more details.
+ *
+ *  You should have received a copy of the GNU General Public License along with PCSX2.
+ *  If not, see <http://www.gnu.org/licenses/>.
+ */
+
+#include "common/PrecompiledHeader.h"
+
+#include "common/Console.h"
+#include "ContextEGL.h"
+#include <algorithm>
+#include <cstring>
+#include <optional>
+#include <vector>
+
+namespace GL
+{
+	ContextEGL::ContextEGL(const WindowInfo& wi)
+		: Context(wi)
+	{
+	}
+
+	ContextEGL::~ContextEGL()
+	{
+		DestroySurface();
+		DestroyContext();
+	}
+
+	std::unique_ptr<Context> ContextEGL::Create(const WindowInfo& wi, gsl::span<const Version> versions_to_try)
+	{
+		std::unique_ptr<ContextEGL> context = std::make_unique<ContextEGL>(wi);
+		if (!context->Initialize(versions_to_try))
+			return nullptr;
+
+		return context;
+	}
+
+	bool ContextEGL::Initialize(gsl::span<const Version> versions_to_try)
+	{
+		if (!gladLoadEGL())
+		{
+			Console.Error("Loading GLAD EGL functions failed");
+			return false;
+		}
+
+		if (!SetDisplay())
+			return false;
+
+		int egl_major, egl_minor;
+		if (!eglInitialize(m_display, &egl_major, &egl_minor))
+		{
+			Console.Error("eglInitialize() failed: %d", eglGetError());
+			return false;
+		}
+		Console.WriteLn("EGL Version: %d.%d", egl_major, egl_minor);
+
+		const char* extensions = eglQueryString(m_display, EGL_EXTENSIONS);
+		if (extensions)
+		{
+			Console.WriteLn("EGL Extensions: %s", extensions);
+			m_supports_surfaceless = std::strstr(extensions, "EGL_KHR_surfaceless_context") != nullptr;
+		}
+		if (!m_supports_surfaceless)
+			Console.Warning("EGL implementation does not support surfaceless contexts, emulating with pbuffers");
+
+		for (const Version& version : versions_to_try)
+		{
+			if (CreateContextAndSurface(version, nullptr, true))
+				return true;
+		}
+
+		return false;
+	}
+
+	bool ContextEGL::SetDisplay()
+	{
+		m_display = eglGetDisplay(static_cast<EGLNativeDisplayType>(m_wi.display_connection));
+		if (!m_display)
+		{
+			Console.Error("eglGetDisplay() failed: %d", eglGetError());
+			return false;
+		}
+
+		return true;
+	}
+
+	void* ContextEGL::GetProcAddress(const char* name)
+	{
+		return reinterpret_cast<void*>(eglGetProcAddress(name));
+	}
+
+	bool ContextEGL::ChangeSurface(const WindowInfo& new_wi)
+	{
+		const bool was_current = (eglGetCurrentContext() == m_context);
+		if (was_current)
+			eglMakeCurrent(m_display, EGL_NO_SURFACE, EGL_NO_SURFACE, EGL_NO_CONTEXT);
+
+		if (m_surface != EGL_NO_SURFACE)
+		{
+			eglDestroySurface(m_display, m_surface);
+			m_surface = EGL_NO_SURFACE;
+		}
+
+		m_wi = new_wi;
+		if (!CreateSurface())
+			return false;
+
+		if (was_current && !eglMakeCurrent(m_display, m_surface, m_surface, m_context))
+		{
+			Console.Error("Failed to make context current again after surface change");
+			return false;
+		}
+
+		return true;
+	}
+
+	void ContextEGL::ResizeSurface(u32 new_surface_width /*= 0*/, u32 new_surface_height /*= 0*/)
+	{
+		if (new_surface_width == 0 && new_surface_height == 0)
+		{
+			EGLint surface_width, surface_height;
+			if (eglQuerySurface(m_display, m_surface, EGL_WIDTH, &surface_width) &&
+				eglQuerySurface(m_display, m_surface, EGL_HEIGHT, &surface_height))
+			{
+				m_wi.surface_width = static_cast<u32>(surface_width);
+				m_wi.surface_height = static_cast<u32>(surface_height);
+				return;
+			}
+			else
+			{
+				Console.Error("eglQuerySurface() failed: %d", eglGetError());
+			}
+		}
+
+		m_wi.surface_width = new_surface_width;
+		m_wi.surface_height = new_surface_height;
+	}
+
+	bool ContextEGL::SwapBuffers()
+	{
+		return eglSwapBuffers(m_display, m_surface);
+	}
+
+	bool ContextEGL::MakeCurrent()
+	{
+		if (!eglMakeCurrent(m_display, m_surface, m_surface, m_context))
+		{
+			Console.Error("eglMakeCurrent() failed: %d", eglGetError());
+			return false;
+		}
+
+		return true;
+	}
+
+	bool ContextEGL::DoneCurrent()
+	{
+		return eglMakeCurrent(m_display, EGL_NO_SURFACE, EGL_NO_SURFACE, EGL_NO_CONTEXT);
+	}
+
+	bool ContextEGL::SetSwapInterval(s32 interval)
+	{
+		return eglSwapInterval(m_display, interval);
+	}
+
+	std::unique_ptr<Context> ContextEGL::CreateSharedContext(const WindowInfo& wi)
+	{
+		std::unique_ptr<ContextEGL> context = std::make_unique<ContextEGL>(wi);
+		context->m_display = m_display;
+		context->m_supports_surfaceless = m_supports_surfaceless;
+
+		if (!context->CreateContextAndSurface(m_version, m_context, false))
+			return nullptr;
+
+		return context;
+	}
+
+	EGLNativeWindowType ContextEGL::GetNativeWindow(EGLConfig config)
+	{
+		return {};
+	}
+
+	bool ContextEGL::CreateSurface()
+	{
+		if (m_wi.type == WindowInfo::Type::Surfaceless)
+		{
+			if (m_supports_surfaceless)
+				return true;
+			else
+				return CreatePBufferSurface();
+		}
+
+		EGLNativeWindowType native_window = GetNativeWindow(m_config);
+		m_surface = eglCreateWindowSurface(m_display, m_config, native_window, nullptr);
+		if (!m_surface)
+		{
+			Console.Error("eglCreateWindowSurface() failed: %d", eglGetError());
+			return false;
+		}
+
+		// Some implementations may require the size to be queried at runtime.
+		EGLint surface_width, surface_height;
+		if (eglQuerySurface(m_display, m_surface, EGL_WIDTH, &surface_width) &&
+			eglQuerySurface(m_display, m_surface, EGL_HEIGHT, &surface_height))
+		{
+			m_wi.surface_width = static_cast<u32>(surface_width);
+			m_wi.surface_height = static_cast<u32>(surface_height);
+		}
+		else
+		{
+			Console.Error("eglQuerySurface() failed: %d", eglGetError());
+		}
+
+		return true;
+	}
+
+	bool ContextEGL::CreatePBufferSurface()
+	{
+		const u32 width = std::max<u32>(m_wi.surface_width, 1);
+		const u32 height = std::max<u32>(m_wi.surface_height, 1);
+
+		EGLint attrib_list[] = {
+			EGL_WIDTH, static_cast<EGLint>(width),
+			EGL_HEIGHT, static_cast<EGLint>(height),
+			EGL_NONE,
+		};
+
+		m_surface = eglCreatePbufferSurface(m_display, m_config, attrib_list);
+		if (!m_surface)
+		{
+			Console.Error("eglCreatePbufferSurface() failed: %d", eglGetError());
+			return false;
+		}
+
+		Console.WriteLn("Created %ux%u pbuffer surface", width, height);
+		return true;
+	}
+
+	bool ContextEGL::CheckConfigSurfaceFormat(EGLConfig config) const
+	{
+		int red_size, green_size, blue_size;
+		if (!eglGetConfigAttrib(m_display, config, EGL_RED_SIZE, &red_size) ||
+			!eglGetConfigAttrib(m_display, config, EGL_GREEN_SIZE, &green_size) ||
+			!eglGetConfigAttrib(m_display, config, EGL_BLUE_SIZE, &blue_size))
+		{
+			return false;
+		}
+
+		return (red_size == 8 && green_size == 8 && blue_size == 8);
+	}
+
+	void ContextEGL::DestroyContext()
+	{
+		if (eglGetCurrentContext() == m_context)
+			eglMakeCurrent(m_display, EGL_NO_SURFACE, EGL_NO_SURFACE, EGL_NO_CONTEXT);
+
+		if (m_context != EGL_NO_CONTEXT)
+		{
+			eglDestroyContext(m_display, m_context);
+			m_context = EGL_NO_CONTEXT;
+		}
+	}
+
+	void ContextEGL::DestroySurface()
+	{
+		if (eglGetCurrentSurface(EGL_DRAW) == m_surface)
+			eglMakeCurrent(m_display, EGL_NO_SURFACE, EGL_NO_SURFACE, EGL_NO_CONTEXT);
+
+		if (m_surface != EGL_NO_SURFACE)
+		{
+			eglDestroySurface(m_display, m_surface);
+			m_surface = EGL_NO_SURFACE;
+		}
+	}
+
+	bool ContextEGL::CreateContext(const Version& version, EGLContext share_context)
+	{
+		Console.WriteLn(
+			"Trying version %u.%u (%s)", version.major_version, version.minor_version,
+			version.profile == Context::Profile::ES ? "ES" : (version.profile == Context::Profile::Core ? "Core" : "None"));
+
+		const int renderable_type = version.profile == Profile::ES
+			? ((version.major_version >= 3) ? EGL_OPENGL_ES3_BIT : ((version.major_version == 2) ? EGL_OPENGL_ES2_BIT : EGL_OPENGL_ES_BIT))
+			: EGL_OPENGL_BIT;
+		const int surface_attribs[] = {
+			EGL_RENDERABLE_TYPE, renderable_type,
+			EGL_SURFACE_TYPE, (m_wi.type != WindowInfo::Type::Surfaceless) ? EGL_WINDOW_BIT : 0,
+			EGL_RED_SIZE, 8,
+			EGL_GREEN_SIZE, 8,
+			EGL_BLUE_SIZE, 8,
+			EGL_NONE
+		};
+
+		EGLint num_configs;
+		if (!eglChooseConfig(m_display, surface_attribs, nullptr, 0, &num_configs) || num_configs == 0)
+		{
+			Console.Error("eglChooseConfig() failed: %d", eglGetError());
+			return false;
+		}
+
+		std::vector<EGLConfig> configs(static_cast<u32>(num_configs));
+		if (!eglChooseConfig(m_display, surface_attribs, configs.data(), num_configs, &num_configs))
+		{
+			Console.Error("eglChooseConfig() failed: %d", eglGetError());
+			return false;
+		}
+		configs.resize(static_cast<u32>(num_configs));
+
+		m_config = [this, &configs]() {
+			const auto found_config = std::find_if(std::begin(configs), std::end(configs), [&](const auto& check_config) {
+				 return CheckConfigSurfaceFormat(check_config);
+			});
+			if (found_config == std::end(configs))
+			{
+				Console.Warning("No EGL configs matched exactly, using first.");
+				return configs.front();
+			}
+			else
+			{
+				return *found_config;
+			}
+		}();
+
+		const auto attribs = [version]() -> std::array<int, 8> {
+			if (version.profile != Profile::NoProfile)
+				return {
+					EGL_CONTEXT_MAJOR_VERSION, version.major_version,
+					EGL_CONTEXT_MINOR_VERSION, version.minor_version,
+					EGL_NONE
+				};
+			return {EGL_NONE};
+		}();
+
+		if (!eglBindAPI((version.profile == Profile::ES) ? EGL_OPENGL_ES_API : EGL_OPENGL_API))
+		{
+			Console.Error("eglBindAPI(%s) failed", (version.profile == Profile::ES) ? "EGL_OPENGL_ES_API" : "EGL_OPENGL_API");
+			return false;
+		}
+
+		m_context = eglCreateContext(m_display, m_config, share_context, attribs.data());
+		if (!m_context)
+		{
+			Console.Error("eglCreateContext() failed: %d", eglGetError());
+			return false;
+		}
+
+		Console.WriteLn(
+			"Got version %u.%u (%s)", version.major_version, version.minor_version,
+			version.profile == Context::Profile::ES ? "ES" : (version.profile == Context::Profile::Core ? "Core" : "None"));
+
+		m_version = version;
+		return true;
+	}
+
+	bool ContextEGL::CreateContextAndSurface(const Version& version, EGLContext share_context, bool make_current)
+	{
+		if (!CreateContext(version, share_context))
+			return false;
+
+		if (!CreateSurface())
+		{
+			Console.Error("Failed to create surface for context");
+			eglDestroyContext(m_display, m_context);
+			m_context = EGL_NO_CONTEXT;
+			return false;
+		}
+
+		if (make_current && !eglMakeCurrent(m_display, m_surface, m_surface, m_context))
+		{
+			Console.Error("eglMakeCurrent() failed: %d", eglGetError());
+			if (m_surface != EGL_NO_SURFACE)
+			{
+				eglDestroySurface(m_display, m_surface);
+				m_surface = EGL_NO_SURFACE;
+			}
+			eglDestroyContext(m_display, m_context);
+			m_context = EGL_NO_CONTEXT;
+			return false;
+		}
+
+		return true;
+	}
+} // namespace GL
--- a/common/GL/ContextEGL.h
+++ b/common/GL/ContextEGL.h
@@ -0,0 +1,63 @@
+/*  PCSX2 - PS2 Emulator for PCs
+ *  Copyright (C) 2002-2021  PCSX2 Dev Team
+ *
+ *  PCSX2 is free software: you can redistribute it and/or modify it under the terms
+ *  of the GNU Lesser General Public License as published by the Free Software Found-
+ *  ation, either version 3 of the License, or (at your option) any later version.
+ *
+ *  PCSX2 is distributed in the hope that it will be useful, but WITHOUT ANY WARRANTY;
+ *  without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR
+ *  PURPOSE.  See the GNU General Public License for more details.
+ *
+ *  You should have received a copy of the GNU General Public License along with PCSX2.
+ *  If not, see <http://www.gnu.org/licenses/>.
+ */
+
+#pragma once
+
+#include "common/GL/Context.h"
+#include "glad_egl.h"
+
+namespace GL
+{
+	class ContextEGL : public Context
+	{
+	public:
+		ContextEGL(const WindowInfo& wi);
+		~ContextEGL() override;
+
+		static std::unique_ptr<Context> Create(const WindowInfo& wi, gsl::span<const Version> versions_to_try);
+
+		void* GetProcAddress(const char* name) override;
+		virtual bool ChangeSurface(const WindowInfo& new_wi) override;
+		virtual void ResizeSurface(u32 new_surface_width = 0, u32 new_surface_height = 0) override;
+		bool SwapBuffers() override;
+		bool MakeCurrent() override;
+		bool DoneCurrent() override;
+		bool SetSwapInterval(s32 interval) override;
+		virtual std::unique_ptr<Context> CreateSharedContext(const WindowInfo& wi) override;
+
+	protected:
+		virtual bool SetDisplay();
+		virtual EGLNativeWindowType GetNativeWindow(EGLConfig config);
+
+		bool Initialize(gsl::span<const Version> versions_to_try);
+		bool CreateDisplay();
+		bool CreateContext(const Version& version, EGLContext share_context);
+		bool CreateContextAndSurface(const Version& version, EGLContext share_context, bool make_current);
+		bool CreateSurface();
+		bool CreatePBufferSurface();
+		bool CheckConfigSurfaceFormat(EGLConfig config) const;
+		void DestroyContext();
+		void DestroySurface();
+
+		EGLDisplay m_display = EGL_NO_DISPLAY;
+		EGLSurface m_surface = EGL_NO_SURFACE;
+		EGLContext m_context = EGL_NO_CONTEXT;
+
+		EGLConfig m_config = {};
+
+		bool m_supports_surfaceless = false;
+	};
+
+} // namespace GL
--- a/common/GL/ContextEGLWayland.cpp
+++ b/common/GL/ContextEGLWayland.cpp
@@ -0,0 +1,104 @@
+/*  PCSX2 - PS2 Emulator for PCs
+ *  Copyright (C) 2002-2021  PCSX2 Dev Team
+ *
+ *  PCSX2 is free software: you can redistribute it and/or modify it under the terms
+ *  of the GNU Lesser General Public License as published by the Free Software Found-
+ *  ation, either version 3 of the License, or (at your option) any later version.
+ *
+ *  PCSX2 is distributed in the hope that it will be useful, but WITHOUT ANY WARRANTY;
+ *  without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR
+ *  PURPOSE.  See the GNU General Public License for more details.
+ *
+ *  You should have received a copy of the GNU General Public License along with PCSX2.
+ *  If not, see <http://www.gnu.org/licenses/>.
+ */
+
+#include "common/PrecompiledHeader.h"
+#include "common/Console.h"
+
+#include "ContextEGLWayland.h"
+
+#include <dlfcn.h>
+
+namespace GL
+{
+	static const char* WAYLAND_EGL_MODNAME = "libwayland-egl.so.1";
+
+	ContextEGLWayland::ContextEGLWayland(const WindowInfo& wi)
+		: ContextEGL(wi)
+	{
+	}
+
+	ContextEGLWayland::~ContextEGLWayland()
+	{
+		if (m_wl_window)
+			m_wl_egl_window_destroy(m_wl_window);
+		if (m_wl_module)
+			dlclose(m_wl_module);
+	}
+
+	std::unique_ptr<Context> ContextEGLWayland::Create(const WindowInfo& wi, gsl::span<const Version> versions_to_try)
+	{
+		std::unique_ptr<ContextEGLWayland> context = std::make_unique<ContextEGLWayland>(wi);
+		if (!context->LoadModule() || !context->Initialize(versions_to_try))
+			return nullptr;
+
+		return context;
+	}
+
+	std::unique_ptr<Context> ContextEGLWayland::CreateSharedContext(const WindowInfo& wi)
+	{
+		std::unique_ptr<ContextEGLWayland> context = std::make_unique<ContextEGLWayland>(wi);
+		context->m_display = m_display;
+
+		if (!context->LoadModule() || !context->CreateContextAndSurface(m_version, m_context, false))
+			return nullptr;
+
+		return context;
+	}
+
+	void ContextEGLWayland::ResizeSurface(u32 new_surface_width, u32 new_surface_height)
+	{
+		if (m_wl_window)
+			m_wl_egl_window_resize(m_wl_window, new_surface_width, new_surface_height, 0, 0);
+
+		ContextEGL::ResizeSurface(new_surface_width, new_surface_height);
+	}
+
+	EGLNativeWindowType ContextEGLWayland::GetNativeWindow(EGLConfig config)
+	{
+		if (m_wl_window)
+		{
+			m_wl_egl_window_destroy(m_wl_window);
+			m_wl_window = nullptr;
+		}
+
+		m_wl_window =
+			m_wl_egl_window_create(static_cast<wl_surface*>(m_wi.window_handle), m_wi.surface_width, m_wi.surface_height);
+		if (!m_wl_window)
+			return {};
+
+		return reinterpret_cast<EGLNativeWindowType>(m_wl_window);
+	}
+
+	bool ContextEGLWayland::LoadModule()
+	{
+		m_wl_module = dlopen(WAYLAND_EGL_MODNAME, RTLD_NOW | RTLD_GLOBAL);
+		if (!m_wl_module)
+		{
+			Console.Error("Failed to load %s.", WAYLAND_EGL_MODNAME);
+			return false;
+		}
+
+		m_wl_egl_window_create = reinterpret_cast<decltype(m_wl_egl_window_create)>(dlsym(m_wl_module, "wl_egl_window_create"));
+		m_wl_egl_window_destroy = reinterpret_cast<decltype(m_wl_egl_window_destroy)>(dlsym(m_wl_module, "wl_egl_window_destroy"));
+		m_wl_egl_window_resize = reinterpret_cast<decltype(m_wl_egl_window_resize)>(dlsym(m_wl_module, "wl_egl_window_resize"));
+		if (!m_wl_egl_window_create || !m_wl_egl_window_destroy || !m_wl_egl_window_resize)
+		{
+			Console.Error("Failed to load one or more functions from %s.", WAYLAND_EGL_MODNAME);
+			return false;
+		}
+
+		return true;
+	}
+} // namespace GL
--- a/common/GL/ContextEGLWayland.h
+++ b/common/GL/ContextEGLWayland.h
@@ -0,0 +1,49 @@
+/*  PCSX2 - PS2 Emulator for PCs
+ *  Copyright (C) 2002-2021  PCSX2 Dev Team
+ *
+ *  PCSX2 is free software: you can redistribute it and/or modify it under the terms
+ *  of the GNU Lesser General Public License as published by the Free Software Found-
+ *  ation, either version 3 of the License, or (at your option) any later version.
+ *
+ *  PCSX2 is distributed in the hope that it will be useful, but WITHOUT ANY WARRANTY;
+ *  without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR
+ *  PURPOSE.  See the GNU General Public License for more details.
+ *
+ *  You should have received a copy of the GNU General Public License along with PCSX2.
+ *  If not, see <http://www.gnu.org/licenses/>.
+ */
+
+#pragma once
+
+#include "common/GL/ContextEGL.h"
+
+struct wl_egl_window;
+struct wl_surface;
+
+namespace GL
+{
+	class ContextEGLWayland final : public ContextEGL
+	{
+	public:
+		ContextEGLWayland(const WindowInfo& wi);
+		~ContextEGLWayland() override;
+
+		static std::unique_ptr<Context> Create(const WindowInfo& wi, gsl::span<const Version> versions_to_try);
+
+		std::unique_ptr<Context> CreateSharedContext(const WindowInfo& wi) override;
+		void ResizeSurface(u32 new_surface_width = 0, u32 new_surface_height = 0) override;
+
+	protected:
+		EGLNativeWindowType GetNativeWindow(EGLConfig config) override;
+
+	private:
+		bool LoadModule();
+
+		wl_egl_window* m_wl_window = nullptr;
+
+		void* m_wl_module = nullptr;
+		wl_egl_window* (*m_wl_egl_window_create)(struct wl_surface* surface, int width, int height);
+		void (*m_wl_egl_window_destroy)(struct wl_egl_window* egl_window);
+		void (*m_wl_egl_window_resize)(struct wl_egl_window* egl_window, int width, int height, int dx, int dy);
+	};
+} // namespace GL
--- a/common/GL/ContextEGLX11.cpp
+++ b/common/GL/ContextEGLX11.cpp
@@ -0,0 +1,59 @@
+/*  PCSX2 - PS2 Emulator for PCs
+ *  Copyright (C) 2002-2021  PCSX2 Dev Team
+ *
+ *  PCSX2 is free software: you can redistribute it and/or modify it under the terms
+ *  of the GNU Lesser General Public License as published by the Free Software Found-
+ *  ation, either version 3 of the License, or (at your option) any later version.
+ *
+ *  PCSX2 is distributed in the hope that it will be useful, but WITHOUT ANY WARRANTY;
+ *  without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR
+ *  PURPOSE.  See the GNU General Public License for more details.
+ *
+ *  You should have received a copy of the GNU General Public License along with PCSX2.
+ *  If not, see <http://www.gnu.org/licenses/>.
+ */
+
+#include "common/PrecompiledHeader.h"
+
+#include "common/GL/ContextEGLX11.h"
+
+#include <X11/Xlib.h>
+
+namespace GL
+{
+	ContextEGLX11::ContextEGLX11(const WindowInfo& wi)
+		: ContextEGL(wi)
+	{
+	}
+	ContextEGLX11::~ContextEGLX11() = default;
+
+	std::unique_ptr<Context> ContextEGLX11::Create(const WindowInfo& wi, gsl::span<const Version> versions_to_try)
+	{
+		std::unique_ptr<ContextEGLX11> context = std::make_unique<ContextEGLX11>(wi);
+		if (!context->Initialize(versions_to_try))
+			return nullptr;
+
+		return context;
+	}
+
+	std::unique_ptr<Context> ContextEGLX11::CreateSharedContext(const WindowInfo& wi)
+	{
+		std::unique_ptr<ContextEGLX11> context = std::make_unique<ContextEGLX11>(wi);
+		context->m_display = m_display;
+
+		if (!context->CreateContextAndSurface(m_version, m_context, false))
+			return nullptr;
+
+		return context;
+	}
+
+	void ContextEGLX11::ResizeSurface(u32 new_surface_width, u32 new_surface_height)
+	{
+		ContextEGL::ResizeSurface(new_surface_width, new_surface_height);
+	}
+
+	EGLNativeWindowType ContextEGLX11::GetNativeWindow(EGLConfig config)
+	{
+		return (EGLNativeWindowType)reinterpret_cast<Window>(m_wi.window_handle);
+	}
+} // namespace GL
--- a/pcsx2/GS/Renderers/OpenGL/GLContextEGLX11.h
+++ b/pcsx2/GS/Renderers/OpenGL/GLContextEGLX11.h
@@ -1,5 +1,5 @@
 /*  PCSX2 - PS2 Emulator for PCs
- *  Copyright (C) 2002-2023  PCSX2 Dev Team
+ *  Copyright (C) 2002-2021  PCSX2 Dev Team
 *
 *  PCSX2 is free software: you can redistribute it and/or modify it under the terms
 *  of the GNU Lesser General Public License as published by the Free Software Found-
@@ -15,19 +15,22 @@

 #pragma once

-#include "GS/Renderers/OpenGL/GLContextEGL.h"
+#include "common/GL/ContextEGL.h"

-class GLContextEGLX11 final : public GLContextEGL
+namespace GL
 {
-public:
-	GLContextEGLX11(const WindowInfo& wi);
-	~GLContextEGLX11() override;
+	class ContextEGLX11 final : public ContextEGL
+	{
+	public:
+		ContextEGLX11(const WindowInfo& wi);
+		~ContextEGLX11() override;

-	static std::unique_ptr<GLContext> Create(const WindowInfo& wi, gsl::span<const Version> versions_to_try);
+		static std::unique_ptr<Context> Create(const WindowInfo& wi, gsl::span<const Version> versions_to_try);

-	std::unique_ptr<GLContext> CreateSharedContext(const WindowInfo& wi) override;
-	void ResizeSurface(u32 new_surface_width = 0, u32 new_surface_height = 0) override;
+		std::unique_ptr<Context> CreateSharedContext(const WindowInfo& wi) override;
+		void ResizeSurface(u32 new_surface_width = 0, u32 new_surface_height = 0) override;

-protected:
-	EGLNativeWindowType GetNativeWindow(EGLConfig config) override;
-};
+	protected:
+		EGLNativeWindowType GetNativeWindow(EGLConfig config) override;
+	};
+} // namespace GL
--- a/common/GL/ContextWGL.cpp
+++ b/common/GL/ContextWGL.cpp
@@ -0,0 +1,487 @@
+/*  PCSX2 - PS2 Emulator for PCs
+ *  Copyright (C) 2002-2021  PCSX2 Dev Team
+ *
+ *  PCSX2 is free software: you can redistribute it and/or modify it under the terms
+ *  of the GNU Lesser General Public License as published by the Free Software Found-
+ *  ation, either version 3 of the License, or (at your option) any later version.
+ *
+ *  PCSX2 is distributed in the hope that it will be useful, but WITHOUT ANY WARRANTY;
+ *  without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR
+ *  PURPOSE.  See the GNU General Public License for more details.
+ *
+ *  You should have received a copy of the GNU General Public License along with PCSX2.
+ *  If not, see <http://www.gnu.org/licenses/>.
+ */
+
+#include "common/GL/ContextWGL.h"
+#include "common/Assertions.h"
+#include "common/Console.h"
+#include "common/ScopedGuard.h"
+
+static void* GetProcAddressCallback(const char* name)
+{
+	void* addr = reinterpret_cast<void*>(wglGetProcAddress(name));
+	if (addr)
+		return addr;
+
+	// try opengl32.dll
+	return reinterpret_cast<void*>(::GetProcAddress(GetModuleHandleA("opengl32.dll"), name));
+}
+
+static bool ReloadWGL(HDC dc)
+{
+	if (!gladLoadWGLLoader([](const char* name) -> void* { return reinterpret_cast<void*>(wglGetProcAddress(name)); }, dc))
+	{
+		Console.Error("Loading GLAD WGL functions failed");
+		return false;
+	}
+
+	return true;
+}
+
+namespace GL
+{
+	ContextWGL::ContextWGL(const WindowInfo& wi)
+		: Context(wi)
+	{
+	}
+
+	ContextWGL::~ContextWGL()
+	{
+		if (wglGetCurrentContext() == m_rc)
+			wglMakeCurrent(m_dc, nullptr);
+
+		if (m_rc)
+			wglDeleteContext(m_rc);
+
+		ReleaseDC();
+	}
+
+	std::unique_ptr<Context> ContextWGL::Create(const WindowInfo& wi, gsl::span<const Version> versions_to_try)
+	{
+		std::unique_ptr<ContextWGL> context = std::make_unique<ContextWGL>(wi);
+		if (!context->Initialize(versions_to_try))
+			return nullptr;
+
+		return context;
+	}
+
+	bool ContextWGL::Initialize(gsl::span<const Version> versions_to_try)
+	{
+		if (m_wi.type == WindowInfo::Type::Win32)
+		{
+			if (!InitializeDC())
+				return false;
+		}
+		else
+		{
+			if (!CreatePBuffer())
+				return false;
+		}
+
+		// Everything including core/ES requires a dummy profile to load the WGL extensions.
+		if (!CreateAnyContext(nullptr, true))
+			return false;
+
+		for (const Version& cv : versions_to_try)
+		{
+			if (cv.profile == Profile::NoProfile)
+			{
+				// we already have the dummy context, so just use that
+				m_version = cv;
+				return true;
+			}
+			else if (CreateVersionContext(cv, nullptr, true))
+			{
+				m_version = cv;
+				return true;
+			}
+		}
+
+		return false;
+	}
+
+	void* ContextWGL::GetProcAddress(const char* name)
+	{
+		return GetProcAddressCallback(name);
+	}
+
+	bool ContextWGL::ChangeSurface(const WindowInfo& new_wi)
+	{
+		const bool was_current = (wglGetCurrentContext() == m_rc);
+
+		ReleaseDC();
+
+		m_wi = new_wi;
+		if (!InitializeDC())
+			return false;
+
+		if (was_current && !wglMakeCurrent(m_dc, m_rc))
+		{
+			Console.Error("Failed to make context current again after surface change: 0x%08X", GetLastError());
+			return false;
+		}
+
+		return true;
+	}
+
+	void ContextWGL::ResizeSurface(u32 new_surface_width /*= 0*/, u32 new_surface_height /*= 0*/)
+	{
+		RECT client_rc = {};
+		GetClientRect(GetHWND(), &client_rc);
+		m_wi.surface_width = static_cast<u32>(client_rc.right - client_rc.left);
+		m_wi.surface_height = static_cast<u32>(client_rc.bottom - client_rc.top);
+	}
+
+	bool ContextWGL::SwapBuffers()
+	{
+		return ::SwapBuffers(m_dc);
+	}
+
+	bool ContextWGL::MakeCurrent()
+	{
+		if (!wglMakeCurrent(m_dc, m_rc))
+		{
+			Console.Error("wglMakeCurrent() failed: 0x%08X", GetLastError());
+			return false;
+		}
+
+		return true;
+	}
+
+	bool ContextWGL::DoneCurrent()
+	{
+		return wglMakeCurrent(m_dc, nullptr);
+	}
+
+	bool ContextWGL::SetSwapInterval(s32 interval)
+	{
+		if (!GLAD_WGL_EXT_swap_control)
+			return false;
+
+		return wglSwapIntervalEXT(interval);
+	}
+
+	std::unique_ptr<Context> ContextWGL::CreateSharedContext(const WindowInfo& wi)
+	{
+		std::unique_ptr<ContextWGL> context = std::make_unique<ContextWGL>(wi);
+		if (wi.type == WindowInfo::Type::Win32)
+		{
+			if (!context->InitializeDC())
+				return nullptr;
+		}
+		else
+		{
+			if (!context->CreatePBuffer())
+				return nullptr;
+		}
+
+		if (m_version.profile == Profile::NoProfile)
+		{
+			if (!context->CreateAnyContext(m_rc, false))
+				return nullptr;
+		}
+		else
+		{
+			if (!context->CreateVersionContext(m_version, m_rc, false))
+				return nullptr;
+		}
+
+		context->m_version = m_version;
+		return context;
+	}
+
+	HDC ContextWGL::GetDCAndSetPixelFormat(HWND hwnd)
+	{
+		PIXELFORMATDESCRIPTOR pfd = {};
+		pfd.nSize = sizeof(pfd);
+		pfd.nVersion = 1;
+		pfd.dwFlags = PFD_DRAW_TO_WINDOW | PFD_SUPPORT_OPENGL | PFD_DOUBLEBUFFER;
+		pfd.iPixelType = PFD_TYPE_RGBA;
+		pfd.dwLayerMask = PFD_MAIN_PLANE;
+		pfd.cRedBits = 8;
+		pfd.cGreenBits = 8;
+		pfd.cBlueBits = 8;
+		pfd.cColorBits = 24;
+
+		HDC hDC = ::GetDC(hwnd);
+		if (!hDC)
+		{
+			Console.Error("GetDC() failed: 0x%08X", GetLastError());
+			return {};
+		}
+
+		if (!m_pixel_format.has_value())
+		{
+			const int pf = ChoosePixelFormat(hDC, &pfd);
+			if (pf == 0)
+			{
+				Console.Error("ChoosePixelFormat() failed: 0x%08X", GetLastError());
+				::ReleaseDC(hwnd, hDC);
+				return {};
+			}
+
+			m_pixel_format = pf;
+		}
+
+		if (!SetPixelFormat(hDC, m_pixel_format.value(), &pfd))
+		{
+			Console.Error("SetPixelFormat() failed: 0x%08X", GetLastError());
+			::ReleaseDC(hwnd, hDC);
+			return {};
+		}
+
+		return hDC;
+	}
+
+	bool ContextWGL::InitializeDC()
+	{
+		if (m_wi.type == WindowInfo::Type::Win32)
+		{
+			m_dc = GetDCAndSetPixelFormat(GetHWND());
+			if (!m_dc)
+			{
+				Console.Error("Failed to get DC for window");
+				return false;
+			}
+
+			return true;
+		}
+		else if (m_wi.type == WindowInfo::Type::Surfaceless)
+		{
+			return CreatePBuffer();
+		}
+		else
+		{
+			Console.Error("Unknown window info type %u", static_cast<unsigned>(m_wi.type));
+			return false;
+		}
+	}
+
+	void ContextWGL::ReleaseDC()
+	{
+		if (m_pbuffer)
+		{
+			wglReleasePbufferDCARB(m_pbuffer, m_dc);
+			m_dc = {};
+
+			wglDestroyPbufferARB(m_pbuffer);
+			m_pbuffer = {};
+
+			::ReleaseDC(m_dummy_window, m_dummy_dc);
+			m_dummy_dc = {};
+
+			DestroyWindow(m_dummy_window);
+			m_dummy_window = {};
+		}
+		else if (m_dc)
+		{
+			::ReleaseDC(GetHWND(), m_dc);
+			m_dc = {};
+		}
+	}
+
+	bool ContextWGL::CreatePBuffer()
+	{
+		static bool window_class_registered = false;
+		static const wchar_t* window_class_name = L"ContextWGLPBuffer";
+
+		if (!window_class_registered)
+		{
+			WNDCLASSEXW wc = {};
+			wc.cbSize = sizeof(WNDCLASSEXW);
+			wc.style = 0;
+			wc.lpfnWndProc = DefWindowProcW;
+			wc.cbClsExtra = 0;
+			wc.cbWndExtra = 0;
+			wc.hInstance = GetModuleHandle(nullptr);
+			wc.hIcon = NULL;
+			wc.hCursor = LoadCursor(NULL, IDC_ARROW);
+			wc.hbrBackground = (HBRUSH)(COLOR_WINDOW + 1);
+			wc.lpszMenuName = NULL;
+			wc.lpszClassName = window_class_name;
+			wc.hIconSm = NULL;
+
+			if (!RegisterClassExW(&wc))
+			{
+				Console.Error("(ContextWGL::CreatePBuffer) RegisterClassExW() failed");
+				return false;
+			}
+
+			window_class_registered = true;
+		}
+
+		HWND hwnd = CreateWindowExW(0, window_class_name, window_class_name, 0, 0, 0, 0, 0, NULL, NULL, NULL, NULL);
+		if (!hwnd)
+		{
+			Console.Error("(ContextWGL::CreatePBuffer) CreateWindowEx() failed");
+			return false;
+		}
+
+		ScopedGuard hwnd_guard([hwnd]() { DestroyWindow(hwnd); });
+
+		HDC hdc = GetDCAndSetPixelFormat(hwnd);
+		if (!hdc)
+			return false;
+
+		ScopedGuard hdc_guard([hdc, hwnd]() { ::ReleaseDC(hwnd, hdc); });
+
+		static constexpr const int pb_attribs[] = {0, 0};
+
+		HGLRC temp_rc = nullptr;
+		ScopedGuard temp_rc_guard([&temp_rc, hdc]() { if (temp_rc) {
+			wglMakeCurrent(hdc, nullptr);
+			wglDeleteContext(temp_rc);
+		} });
+
+		if (!GLAD_WGL_ARB_pbuffer)
+		{
+			// we're probably running completely surfaceless... need a temporary context.
+			temp_rc = wglCreateContext(hdc);
+			if (!temp_rc || !wglMakeCurrent(hdc, temp_rc))
+			{
+				Console.Error("Failed to create temporary context to load WGL for pbuffer.");
+				return false;
+			}
+
+			if (!ReloadWGL(hdc) || !GLAD_WGL_ARB_pbuffer)
+			{
+				Console.Error("Missing WGL_ARB_pbuffer");
+				return false;
+			}
+		}
+
+		pxAssertRel(m_pixel_format.has_value(), "Has pixel format for pbuffer");
+		HPBUFFERARB pbuffer = wglCreatePbufferARB(hdc, m_pixel_format.value(), 1, 1, pb_attribs);
+		if (!pbuffer)
+		{
+			Console.Error("(ContextWGL::CreatePBuffer) wglCreatePbufferARB() failed");
+			return false;
+		}
+
+		ScopedGuard pbuffer_guard([pbuffer]() { wglDestroyPbufferARB(pbuffer); });
+
+		m_dc = wglGetPbufferDCARB(pbuffer);
+		if (!m_dc)
+		{
+			Console.Error("(ContextWGL::CreatePbuffer) wglGetPbufferDCARB() failed");
+			return false;
+		}
+
+		m_dummy_window = hwnd;
+		m_dummy_dc = hdc;
+		m_pbuffer = pbuffer;
+
+		temp_rc_guard.Run();
+		pbuffer_guard.Cancel();
+		hdc_guard.Cancel();
+		hwnd_guard.Cancel();
+		return true;
+	}
+
+	bool ContextWGL::CreateAnyContext(HGLRC share_context, bool make_current)
+	{
+		m_rc = wglCreateContext(m_dc);
+		if (!m_rc)
+		{
+			Console.Error("wglCreateContext() failed: 0x%08X", GetLastError());
+			return false;
+		}
+
+		if (make_current)
+		{
+			if (!wglMakeCurrent(m_dc, m_rc))
+			{
+				Console.Error("wglMakeCurrent() failed: 0x%08X", GetLastError());
+				return false;
+			}
+
+			// re-init glad-wgl
+			if (!gladLoadWGLLoader([](const char* name) -> void* { return reinterpret_cast<void*>(wglGetProcAddress(name)); }, m_dc))
+			{
+				Console.Error("Loading GLAD WGL functions failed");
+				return false;
+			}
+		}
+
+		if (share_context && !wglShareLists(share_context, m_rc))
+		{
+			Console.Error("wglShareLists() failed: 0x%08X", GetLastError());
+			return false;
+		}
+
+		return true;
+	}
+
+	bool ContextWGL::CreateVersionContext(const Version& version, HGLRC share_context, bool make_current)
+	{
+		// we need create context attribs
+		if (!GLAD_WGL_ARB_create_context)
+		{
+			Console.Error("Missing GLAD_WGL_ARB_create_context.");
+			return false;
+		}
+
+		HGLRC new_rc;
+		if (version.profile == Profile::Core)
+		{
+			const int attribs[] = {
+				WGL_CONTEXT_PROFILE_MASK_ARB, WGL_CONTEXT_CORE_PROFILE_BIT_ARB,
+				WGL_CONTEXT_MAJOR_VERSION_ARB, version.major_version,
+				WGL_CONTEXT_MINOR_VERSION_ARB, version.minor_version,
+#ifdef _DEBUG
+				WGL_CONTEXT_FLAGS_ARB, WGL_CONTEXT_FORWARD_COMPATIBLE_BIT_ARB | WGL_CONTEXT_DEBUG_BIT_ARB,
+#else
+				WGL_CONTEXT_FLAGS_ARB, WGL_CONTEXT_FORWARD_COMPATIBLE_BIT_ARB,
+#endif
+				0, 0};
+
+			new_rc = wglCreateContextAttribsARB(m_dc, share_context, attribs);
+		}
+		else if (version.profile == Profile::ES)
+		{
+			if ((version.major_version >= 2 && !GLAD_WGL_EXT_create_context_es2_profile) ||
+				(version.major_version < 2 && !GLAD_WGL_EXT_create_context_es_profile))
+			{
+				Console.Error("WGL_EXT_create_context_es_profile not supported");
+				return false;
+			}
+
+			const int attribs[] = {
+				WGL_CONTEXT_PROFILE_MASK_ARB, ((version.major_version >= 2) ? WGL_CONTEXT_ES2_PROFILE_BIT_EXT : WGL_CONTEXT_ES_PROFILE_BIT_EXT),
+				WGL_CONTEXT_MAJOR_VERSION_ARB, version.major_version,
+				WGL_CONTEXT_MINOR_VERSION_ARB, version.minor_version,
+				0, 0};
+
+			new_rc = wglCreateContextAttribsARB(m_dc, share_context, attribs);
+		}
+		else
+		{
+			Console.Error("Unknown profile");
+			return false;
+		}
+
+		if (!new_rc)
+			return false;
+
+		// destroy and swap contexts
+		if (m_rc)
+		{
+			if (!wglMakeCurrent(m_dc, make_current ? new_rc : nullptr))
+			{
+				Console.Error("wglMakeCurrent() failed: 0x%08X", GetLastError());
+				wglDeleteContext(new_rc);
+				return false;
+			}
+
+			// re-init glad-wgl
+			if (make_current && !ReloadWGL(m_dc))
+				return false;
+
+			wglDeleteContext(m_rc);
+		}
+
+		m_rc = new_rc;
+		return true;
+	}
+} // namespace GL
--- a/common/GL/ContextWGL.h
+++ b/common/GL/ContextWGL.h
@@ -0,0 +1,71 @@
+/*  PCSX2 - PS2 Emulator for PCs
+ *  Copyright (C) 2002-2021  PCSX2 Dev Team
+ *
+ *  PCSX2 is free software: you can redistribute it and/or modify it under the terms
+ *  of the GNU Lesser General Public License as published by the Free Software Found-
+ *  ation, either version 3 of the License, or (at your option) any later version.
+ *
+ *  PCSX2 is distributed in the hope that it will be useful, but WITHOUT ANY WARRANTY;
+ *  without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR
+ *  PURPOSE.  See the GNU General Public License for more details.
+ *
+ *  You should have received a copy of the GNU General Public License along with PCSX2.
+ *  If not, see <http://www.gnu.org/licenses/>.
+ */
+
+#pragma once
+
+#include "common/GL/Context.h"
+
+#include "glad_wgl.h"
+#include "glad.h"
+
+#ifndef WIN32_LEAN_AND_MEAN
+#define WIN32_LEAN_AND_MEAN
+#endif
+#include <windows.h>
+#include <optional>
+
+namespace GL
+{
+	class ContextWGL final : public Context
+	{
+	public:
+		ContextWGL(const WindowInfo& wi);
+		~ContextWGL() override;
+
+		static std::unique_ptr<Context> Create(const WindowInfo& wi, gsl::span<const Version> versions_to_try);
+
+		void* GetProcAddress(const char* name) override;
+		bool ChangeSurface(const WindowInfo& new_wi) override;
+		void ResizeSurface(u32 new_surface_width = 0, u32 new_surface_height = 0) override;
+		bool SwapBuffers() override;
+		bool MakeCurrent() override;
+		bool DoneCurrent() override;
+		bool SetSwapInterval(s32 interval) override;
+		std::unique_ptr<Context> CreateSharedContext(const WindowInfo& wi) override;
+
+	private:
+		__fi HWND GetHWND() const { return static_cast<HWND>(m_wi.window_handle); }
+
+		HDC GetDCAndSetPixelFormat(HWND hwnd);
+
+		bool Initialize(gsl::span<const Version> versions_to_try);
+		bool InitializeDC();
+		void ReleaseDC();
+		bool CreatePBuffer();
+		bool CreateAnyContext(HGLRC share_context, bool make_current);
+		bool CreateVersionContext(const Version& version, HGLRC share_context, bool make_current);
+
+		HDC m_dc = {};
+		HGLRC m_rc = {};
+
+		// Can't change pixel format once it's set for a RC.
+		std::optional<int> m_pixel_format;
+
+		// Dummy window for creating a PBuffer off when we're surfaceless.
+		HWND m_dummy_window = {};
+		HDC m_dummy_dc = {};
+		HPBUFFERARB m_pbuffer = {};
+	};
+} // namespace GL
--- a/common/GL/Program.cpp
+++ b/common/GL/Program.cpp
@@ -0,0 +1,673 @@
+/*  PCSX2 - PS2 Emulator for PCs
+ *  Copyright (C) 2002-2021  PCSX2 Dev Team
+ *
+ *  PCSX2 is free software: you can redistribute it and/or modify it under the terms
+ *  of the GNU Lesser General Public License as published by the Free Software Found-
+ *  ation, either version 3 of the License, or (at your option) any later version.
+ *
+ *  PCSX2 is distributed in the hope that it will be useful, but WITHOUT ANY WARRANTY;
+ *  without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR
+ *  PURPOSE.  See the GNU General Public License for more details.
+ *
+ *  You should have received a copy of the GNU General Public License along with PCSX2.
+ *  If not, see <http://www.gnu.org/licenses/>.
+ */
+
+#include "common/PrecompiledHeader.h"
+
+#include "common/GL/Program.h"
+#include "common/Assertions.h"
+#include "common/Console.h"
+#include "common/StringUtil.h"
+#include <array>
+#include <fstream>
+
+namespace GL
+{
+	GLuint Program::s_last_program_id = 0;
+	static GLuint s_next_bad_shader_id = 1;
+
+	Program::Program() = default;
+
+	Program::Program(Program&& prog)
+	{
+		m_program_id = prog.m_program_id;
+		prog.m_program_id = 0;
+		m_vertex_shader_id = prog.m_vertex_shader_id;
+		prog.m_vertex_shader_id = 0;
+		m_fragment_shader_id = prog.m_fragment_shader_id;
+		prog.m_fragment_shader_id = 0;
+		m_uniform_locations = std::move(prog.m_uniform_locations);
+	}
+
+	Program::~Program()
+	{
+		Destroy();
+	}
+
+	GLuint Program::CompileShader(GLenum type, const std::string_view source)
+	{
+		GLuint id = glCreateShader(type);
+
+		std::array<const GLchar*, 1> sources = {{source.data()}};
+		std::array<GLint, 1> source_lengths = {{static_cast<GLint>(source.size())}};
+		glShaderSource(id, static_cast<GLsizei>(sources.size()), sources.data(), source_lengths.data());
+		glCompileShader(id);
+
+		GLint status = GL_FALSE;
+		glGetShaderiv(id, GL_COMPILE_STATUS, &status);
+
+		GLint info_log_length = 0;
+		glGetShaderiv(id, GL_INFO_LOG_LENGTH, &info_log_length);
+
+		// Log will create a new line when there are no warnings so let's set a minimum log length of 1.
+		constexpr int info_log_min_length = 1;
+
+		if (status == GL_FALSE || info_log_length > info_log_min_length)
+		{
+			std::string info_log;
+			info_log.resize(info_log_length + 1);
+			glGetShaderInfoLog(id, info_log_length, &info_log_length, &info_log[0]);
+
+			if (status == GL_TRUE)
+			{
+				Console.Warning("Shader compiled with warnings:\n%s", info_log.c_str());
+			}
+			else
+			{
+				Console.Error("Shader failed to compile:\n%s", info_log.c_str());
+
+				std::ofstream ofs(StringUtil::StdStringFromFormat("bad_shader_%u.txt", s_next_bad_shader_id++).c_str(),
+					std::ofstream::out | std::ofstream::binary);
+				if (ofs.is_open())
+				{
+					ofs.write(sources[0], source_lengths[0]);
+					ofs << "\n\nCompile failed, info log:\n";
+					ofs << info_log;
+					ofs.close();
+				}
+
+				glDeleteShader(id);
+				return 0;
+			}
+		}
+
+		return id;
+	}
+
+	void Program::ResetLastProgram()
+	{
+		s_last_program_id = 0;
+	}
+
+	bool Program::Compile(const std::string_view vertex_shader, const std::string_view geometry_shader,
+		const std::string_view fragment_shader)
+	{
+		GLuint vertex_shader_id = 0;
+		if (!vertex_shader.empty())
+		{
+			vertex_shader_id = CompileShader(GL_VERTEX_SHADER, vertex_shader);
+			if (vertex_shader_id == 0)
+				return false;
+		}
+
+		GLuint geometry_shader_id = 0;
+		if (!geometry_shader.empty())
+		{
+			geometry_shader_id = CompileShader(GL_GEOMETRY_SHADER, geometry_shader);
+			if (geometry_shader_id == 0)
+				return false;
+		}
+
+		GLuint fragment_shader_id = 0;
+		if (!fragment_shader.empty())
+		{
+			fragment_shader_id = CompileShader(GL_FRAGMENT_SHADER, fragment_shader);
+			if (fragment_shader_id == 0)
+			{
+				glDeleteShader(vertex_shader_id);
+				return false;
+			}
+		}
+
+		m_program_id = glCreateProgram();
+		if (vertex_shader_id != 0)
+			glAttachShader(m_program_id, vertex_shader_id);
+		if (geometry_shader_id != 0)
+			glAttachShader(m_program_id, geometry_shader_id);
+		if (fragment_shader_id != 0)
+			glAttachShader(m_program_id, fragment_shader_id);
+		return true;
+	}
+
+	bool Program::CompileCompute(const std::string_view glsl)
+	{
+		GLuint id = CompileShader(GL_COMPUTE_SHADER, glsl);
+		if (id == 0)
+			return false;
+
+		m_program_id = glCreateProgram();
+		glAttachShader(m_program_id, id);
+		return true;
+	}
+
+	bool Program::CreateFromBinary(const void* data, u32 data_length, u32 data_format)
+	{
+		GLuint prog = glCreateProgram();
+		glProgramBinary(prog, static_cast<GLenum>(data_format), data, data_length);
+
+		GLint link_status;
+		glGetProgramiv(prog, GL_LINK_STATUS, &link_status);
+		if (link_status != GL_TRUE)
+		{
+			Console.Error("Failed to create GL program from binary: status %d", link_status);
+			glDeleteProgram(prog);
+			return false;
+		}
+
+		m_program_id = prog;
+		return true;
+	}
+
+	bool Program::GetBinary(std::vector<u8>* out_data, u32* out_data_format)
+	{
+		GLint binary_size = 0;
+		glGetProgramiv(m_program_id, GL_PROGRAM_BINARY_LENGTH, &binary_size);
+		if (binary_size == 0)
+		{
+			Console.Warning("glGetProgramiv(GL_PROGRAM_BINARY_LENGTH) returned 0");
+			return false;
+		}
+
+		GLenum format = 0;
+		out_data->resize(static_cast<size_t>(binary_size));
+		glGetProgramBinary(m_program_id, binary_size, &binary_size, &format, out_data->data());
+		if (binary_size == 0)
+		{
+			Console.Warning("glGetProgramBinary() failed");
+			return false;
+		}
+		else if (static_cast<size_t>(binary_size) != out_data->size())
+		{
+			Console.Warning("Size changed from %zu to %d after glGetProgramBinary()", out_data->size(), binary_size);
+			out_data->resize(static_cast<size_t>(binary_size));
+		}
+
+		*out_data_format = static_cast<u32>(format);
+		DevCon.WriteLn("Program binary retrieved, %zu bytes, format %u", out_data->size(), *out_data_format);
+		return true;
+	}
+
+	void Program::SetBinaryRetrievableHint()
+	{
+		glProgramParameteri(m_program_id, GL_PROGRAM_BINARY_RETRIEVABLE_HINT, GL_TRUE);
+	}
+
+	void Program::BindAttribute(GLuint index, const char* name)
+	{
+		glBindAttribLocation(m_program_id, index, name);
+	}
+
+	void Program::BindDefaultAttributes()
+	{
+		BindAttribute(0, "a_position");
+		BindAttribute(1, "a_texcoord");
+		BindAttribute(2, "a_color");
+	}
+
+	void Program::BindFragData(GLuint index /*= 0*/, const char* name /*= "o_col0"*/)
+	{
+		glBindFragDataLocation(m_program_id, index, name);
+	}
+
+	void Program::BindFragDataIndexed(GLuint color_number /*= 0*/, const char* name /*= "o_col0"*/)
+	{
+		if (GLAD_GL_VERSION_3_3 || GLAD_GL_ARB_blend_func_extended)
+		{
+			glBindFragDataLocationIndexed(m_program_id, color_number, 0, name);
+			return;
+		}
+		else if (GLAD_GL_EXT_blend_func_extended)
+		{
+			glBindFragDataLocationIndexedEXT(m_program_id, color_number, 0, name);
+			return;
+		}
+
+		Console.Error("BindFragDataIndexed() called without ARB or EXT extension, we'll probably crash.");
+		glBindFragDataLocationIndexed(m_program_id, color_number, 0, name);
+	}
+
+	bool Program::Link()
+	{
+		glLinkProgram(m_program_id);
+
+		if (m_vertex_shader_id != 0)
+			glDeleteShader(m_vertex_shader_id);
+		m_vertex_shader_id = 0;
+		if (m_fragment_shader_id != 0)
+			glDeleteShader(m_fragment_shader_id);
+		m_fragment_shader_id = 0;
+
+		GLint status = GL_FALSE;
+		glGetProgramiv(m_program_id, GL_LINK_STATUS, &status);
+
+		GLint info_log_length = 0;
+
+		// Log will create a new line when there are no warnings so let's set a minimum log length of 1.
+		constexpr int info_log_min_length = 1;
+
+		glGetProgramiv(m_program_id, GL_INFO_LOG_LENGTH, &info_log_length);
+
+		if (status == GL_FALSE || info_log_length > info_log_min_length)
+		{
+			std::string info_log;
+			info_log.resize(info_log_length + 1);
+			glGetProgramInfoLog(m_program_id, info_log_length, &info_log_length, &info_log[0]);
+
+			if (status == GL_TRUE)
+			{
+				Console.Error("Program linked with warnings:\n%s", info_log.c_str());
+			}
+			else
+			{
+				Console.Error("Program failed to link:\n%s", info_log.c_str());
+				glDeleteProgram(m_program_id);
+				m_program_id = 0;
+				return false;
+			}
+		}
+
+		return true;
+	}
+
+	void Program::Bind() const
+	{
+		if (s_last_program_id == m_program_id)
+			return;
+
+		glUseProgram(m_program_id);
+		s_last_program_id = m_program_id;
+	}
+
+	void Program::Destroy()
+	{
+		if (m_vertex_shader_id != 0)
+		{
+			glDeleteShader(m_vertex_shader_id);
+			m_vertex_shader_id = 0;
+		}
+		if (m_fragment_shader_id != 0)
+		{
+			glDeleteShader(m_fragment_shader_id);
+			m_fragment_shader_id = 0;
+		}
+		if (m_program_id != 0)
+		{
+			glDeleteProgram(m_program_id);
+			m_program_id = 0;
+		}
+
+		m_uniform_locations.clear();
+	}
+
+	int Program::RegisterUniform(const char* name)
+	{
+		int id = static_cast<int>(m_uniform_locations.size());
+		m_uniform_locations.push_back(glGetUniformLocation(m_program_id, name));
+		return id;
+	}
+
+	void Program::Uniform1ui(int index, u32 x) const
+	{
+		pxAssert(static_cast<size_t>(index) < m_uniform_locations.size());
+		const GLint location = m_uniform_locations[index];
+		if (location >= 0)
+			glUniform1ui(location, x);
+	}
+
+	void Program::Uniform2ui(int index, u32 x, u32 y) const
+	{
+		pxAssert(static_cast<size_t>(index) < m_uniform_locations.size());
+		const GLint location = m_uniform_locations[index];
+		if (location >= 0)
+			glUniform2ui(location, x, y);
+	}
+
+	void Program::Uniform3ui(int index, u32 x, u32 y, u32 z) const
+	{
+		pxAssert(static_cast<size_t>(index) < m_uniform_locations.size());
+		const GLint location = m_uniform_locations[index];
+		if (location >= 0)
+			glUniform3ui(location, x, y, z);
+	}
+
+	void Program::Uniform4ui(int index, u32 x, u32 y, u32 z, u32 w) const
+	{
+		pxAssert(static_cast<size_t>(index) < m_uniform_locations.size());
+		const GLint location = m_uniform_locations[index];
+		if (location >= 0)
+			glUniform4ui(location, x, y, z, w);
+	}
+
+	void Program::Uniform1i(int index, s32 x) const
+	{
+		pxAssert(static_cast<size_t>(index) < m_uniform_locations.size());
+		const GLint location = m_uniform_locations[index];
+		if (location >= 0)
+			glUniform1i(location, x);
+	}
+
+	void Program::Uniform2i(int index, s32 x, s32 y) const
+	{
+		pxAssert(static_cast<size_t>(index) < m_uniform_locations.size());
+		const GLint location = m_uniform_locations[index];
+		if (location >= 0)
+			glUniform2i(location, x, y);
+	}
+
+	void Program::Uniform3i(int index, s32 x, s32 y, s32 z) const
+	{
+		pxAssert(static_cast<size_t>(index) < m_uniform_locations.size());
+		const GLint location = m_uniform_locations[index];
+		if (location >= 0)
+			glUniform3i(location, x, y, z);
+	}
+
+	void Program::Uniform4i(int index, s32 x, s32 y, s32 z, s32 w) const
+	{
+		pxAssert(static_cast<size_t>(index) < m_uniform_locations.size());
+		const GLint location = m_uniform_locations[index];
+		if (location >= 0)
+			glUniform4i(location, x, y, z, w);
+	}
+
+	void Program::Uniform1f(int index, float x) const
+	{
+		pxAssert(static_cast<size_t>(index) < m_uniform_locations.size());
+		const GLint location = m_uniform_locations[index];
+		if (location >= 0)
+			glUniform1f(location, x);
+	}
+
+	void Program::Uniform2f(int index, float x, float y) const
+	{
+		pxAssert(static_cast<size_t>(index) < m_uniform_locations.size());
+		const GLint location = m_uniform_locations[index];
+		if (location >= 0)
+			glUniform2f(location, x, y);
+	}
+
+	void Program::Uniform3f(int index, float x, float y, float z) const
+	{
+		pxAssert(static_cast<size_t>(index) < m_uniform_locations.size());
+		const GLint location = m_uniform_locations[index];
+		if (location >= 0)
+			glUniform3f(location, x, y, z);
+	}
+
+	void Program::Uniform4f(int index, float x, float y, float z, float w) const
+	{
+		pxAssert(static_cast<size_t>(index) < m_uniform_locations.size());
+		const GLint location = m_uniform_locations[index];
+		if (location >= 0)
+			glUniform4f(location, x, y, z, w);
+	}
+
+	void Program::Uniform2uiv(int index, const u32* v) const
+	{
+		pxAssert(static_cast<size_t>(index) < m_uniform_locations.size());
+		const GLint location = m_uniform_locations[index];
+		if (location >= 0)
+			glUniform2uiv(location, 1, v);
+	}
+
+	void Program::Uniform3uiv(int index, const u32* v) const
+	{
+		pxAssert(static_cast<size_t>(index) < m_uniform_locations.size());
+		const GLint location = m_uniform_locations[index];
+		if (location >= 0)
+			glUniform3uiv(location, 1, v);
+	}
+
+	void Program::Uniform4uiv(int index, const u32* v) const
+	{
+		pxAssert(static_cast<size_t>(index) < m_uniform_locations.size());
+		const GLint location = m_uniform_locations[index];
+		if (location >= 0)
+			glUniform4uiv(location, 1, v);
+	}
+
+	void Program::Uniform2iv(int index, const s32* v) const
+	{
+		pxAssert(static_cast<size_t>(index) < m_uniform_locations.size());
+		const GLint location = m_uniform_locations[index];
+		if (location >= 0)
+			glUniform2iv(location, 1, v);
+	}
+
+	void Program::Uniform3iv(int index, const s32* v) const
+	{
+		pxAssert(static_cast<size_t>(index) < m_uniform_locations.size());
+		const GLint location = m_uniform_locations[index];
+		if (location >= 0)
+			glUniform3iv(location, 1, v);
+	}
+
+	void Program::Uniform4iv(int index, const s32* v) const
+	{
+		pxAssert(static_cast<size_t>(index) < m_uniform_locations.size());
+		const GLint location = m_uniform_locations[index];
+		if (location >= 0)
+			glUniform4iv(location, 1, v);
+	}
+
+	void Program::Uniform2fv(int index, const float* v) const
+	{
+		pxAssert(static_cast<size_t>(index) < m_uniform_locations.size());
+		const GLint location = m_uniform_locations[index];
+		if (location >= 0)
+			glUniform2fv(location, 1, v);
+	}
+
+	void Program::Uniform3fv(int index, const float* v) const
+	{
+		pxAssert(static_cast<size_t>(index) < m_uniform_locations.size());
+		const GLint location = m_uniform_locations[index];
+		if (location >= 0)
+			glUniform3fv(location, 1, v);
+	}
+
+	void Program::Uniform4fv(int index, const float* v) const
+	{
+		pxAssert(static_cast<size_t>(index) < m_uniform_locations.size());
+		const GLint location = m_uniform_locations[index];
+		if (location >= 0)
+			glUniform4fv(location, 1, v);
+	}
+
+	void Program::Uniform1ui(const char* name, u32 x) const
+	{
+		const GLint location = glGetUniformLocation(m_program_id, name);
+		if (location >= 0)
+			glUniform1ui(location, x);
+	}
+
+	void Program::Uniform2ui(const char* name, u32 x, u32 y) const
+	{
+		const GLint location = glGetUniformLocation(m_program_id, name);
+		if (location >= 0)
+			glUniform2ui(location, x, y);
+	}
+
+	void Program::Uniform3ui(const char* name, u32 x, u32 y, u32 z) const
+	{
+		const GLint location = glGetUniformLocation(m_program_id, name);
+		if (location >= 0)
+			glUniform3ui(location, x, y, z);
+	}
+
+	void Program::Uniform4ui(const char* name, u32 x, u32 y, u32 z, u32 w) const
+	{
+		const GLint location = glGetUniformLocation(m_program_id, name);
+		if (location >= 0)
+			glUniform4ui(location, x, y, z, w);
+	}
+
+	void Program::Uniform1i(const char* name, s32 x) const
+	{
+		const GLint location = glGetUniformLocation(m_program_id, name);
+		if (location >= 0)
+			glUniform1i(location, x);
+	}
+
+	void Program::Uniform2i(const char* name, s32 x, s32 y) const
+	{
+		const GLint location = glGetUniformLocation(m_program_id, name);
+		if (location >= 0)
+			glUniform2i(location, x, y);
+	}
+
+	void Program::Uniform3i(const char* name, s32 x, s32 y, s32 z) const
+	{
+		const GLint location = glGetUniformLocation(m_program_id, name);
+		if (location >= 0)
+			glUniform3i(location, x, y, z);
+	}
+
+	void Program::Uniform4i(const char* name, s32 x, s32 y, s32 z, s32 w) const
+	{
+		const GLint location = glGetUniformLocation(m_program_id, name);
+		if (location >= 0)
+			glUniform4i(location, x, y, z, w);
+	}
+
+	void Program::Uniform1f(const char* name, float x) const
+	{
+		const GLint location = glGetUniformLocation(m_program_id, name);
+		if (location >= 0)
+			glUniform1f(location, x);
+	}
+
+	void Program::Uniform2f(const char* name, float x, float y) const
+	{
+		const GLint location = glGetUniformLocation(m_program_id, name);
+		if (location >= 0)
+			glUniform2f(location, x, y);
+	}
+
+	void Program::Uniform3f(const char* name, float x, float y, float z) const
+	{
+		const GLint location = glGetUniformLocation(m_program_id, name);
+		if (location >= 0)
+			glUniform3f(location, x, y, z);
+	}
+
+	void Program::Uniform4f(const char* name, float x, float y, float z, float w) const
+	{
+		const GLint location = glGetUniformLocation(m_program_id, name);
+		if (location >= 0)
+			glUniform4f(location, x, y, z, w);
+	}
+
+	void Program::Uniform2uiv(const char* name, const u32* v) const
+	{
+		const GLint location = glGetUniformLocation(m_program_id, name);
+		if (location >= 0)
+			glUniform2uiv(location, 1, v);
+	}
+
+	void Program::Uniform3uiv(const char* name, const u32* v) const
+	{
+		const GLint location = glGetUniformLocation(m_program_id, name);
+		if (location >= 0)
+			glUniform3uiv(location, 1, v);
+	}
+
+	void Program::Uniform4uiv(const char* name, const u32* v) const
+	{
+		const GLint location = glGetUniformLocation(m_program_id, name);
+		if (location >= 0)
+			glUniform4uiv(location, 1, v);
+	}
+
+	void Program::Uniform2iv(const char* name, const s32* v) const
+	{
+		const GLint location = glGetUniformLocation(m_program_id, name);
+		if (location >= 0)
+			glUniform2iv(location, 1, v);
+	}
+
+	void Program::Uniform3iv(const char* name, const s32* v) const
+	{
+		const GLint location = glGetUniformLocation(m_program_id, name);
+		if (location >= 0)
+			glUniform3iv(location, 1, v);
+	}
+
+	void Program::Uniform4iv(const char* name, const s32* v) const
+	{
+		const GLint location = glGetUniformLocation(m_program_id, name);
+		if (location >= 0)
+			glUniform4iv(location, 1, v);
+	}
+
+	void Program::Uniform2fv(const char* name, const float* v) const
+	{
+		const GLint location = glGetUniformLocation(m_program_id, name);
+		if (location >= 0)
+			glUniform2fv(location, 1, v);
+	}
+
+	void Program::Uniform3fv(const char* name, const float* v) const
+	{
+		const GLint location = glGetUniformLocation(m_program_id, name);
+		if (location >= 0)
+			glUniform3fv(location, 1, v);
+	}
+
+	void Program::Uniform4fv(const char* name, const float* v) const
+	{
+		const GLint location = glGetUniformLocation(m_program_id, name);
+		if (location >= 0)
+			glUniform4fv(location, 1, v);
+	}
+
+	void Program::BindUniformBlock(const char* name, u32 index)
+	{
+		const GLint location = glGetUniformBlockIndex(m_program_id, name);
+		if (location >= 0)
+			glUniformBlockBinding(m_program_id, location, index);
+	}
+
+	void Program::SetName(const std::string_view& name)
+	{
+		if (name.empty())
+			return;
+
+#ifdef _DEBUG
+		glObjectLabel(GL_PROGRAM, m_program_id, name.length(), name.data());
+#endif
+	}
+
+	void Program::SetFormattedName(const char* format, ...)
+	{
+		va_list ap;
+		va_start(ap, format);
+		std::string n = StringUtil::StdStringFromFormatV(format, ap);
+		va_end(ap);
+		SetName(n);
+	}
+
+	Program& Program::operator=(Program&& prog)
+	{
+		Destroy();
+		m_program_id = prog.m_program_id;
+		prog.m_program_id = 0;
+		m_vertex_shader_id = prog.m_vertex_shader_id;
+		prog.m_vertex_shader_id = 0;
+		m_fragment_shader_id = prog.m_fragment_shader_id;
+		prog.m_fragment_shader_id = 0;
+		m_uniform_locations = std::move(prog.m_uniform_locations);
+		return *this;
+	}
+} // namespace GL
--- a/common/GL/Program.h
+++ b/common/GL/Program.h
@@ -0,0 +1,124 @@
+/*  PCSX2 - PS2 Emulator for PCs
+ *  Copyright (C) 2002-2021  PCSX2 Dev Team
+ *
+ *  PCSX2 is free software: you can redistribute it and/or modify it under the terms
+ *  of the GNU Lesser General Public License as published by the Free Software Found-
+ *  ation, either version 3 of the License, or (at your option) any later version.
+ *
+ *  PCSX2 is distributed in the hope that it will be useful, but WITHOUT ANY WARRANTY;
+ *  without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR
+ *  PURPOSE.  See the GNU General Public License for more details.
+ *
+ *  You should have received a copy of the GNU General Public License along with PCSX2.
+ *  If not, see <http://www.gnu.org/licenses/>.
+ */
+
+#pragma once
+#include "../Pcsx2Defs.h"
+#include "glad.h"
+#include <string_view>
+#include <vector>
+
+namespace GL
+{
+	class Program
+	{
+	public:
+		Program();
+		Program(const Program&) = delete;
+		Program(Program&& prog);
+		~Program();
+
+		static GLuint CompileShader(GLenum type, const std::string_view source);
+		static void ResetLastProgram();
+
+		bool IsValid() const { return m_program_id != 0; }
+
+		bool Compile(const std::string_view vertex_shader, const std::string_view geometry_shader,
+			const std::string_view fragment_shader);
+
+		bool CompileCompute(const std::string_view glsl);
+
+		bool CreateFromBinary(const void* data, u32 data_length, u32 data_format);
+
+		bool GetBinary(std::vector<u8>* out_data, u32* out_data_format);
+		void SetBinaryRetrievableHint();
+
+		void BindAttribute(GLuint index, const char* name);
+		void BindDefaultAttributes();
+
+		void BindFragData(GLuint index = 0, const char* name = "o_col0");
+		void BindFragDataIndexed(GLuint color_number = 0, const char* name = "o_col0");
+
+		bool Link();
+
+		void Bind() const;
+
+		void Destroy();
+
+		int RegisterUniform(const char* name);
+		void Uniform1ui(int index, u32 x) const;
+		void Uniform2ui(int index, u32 x, u32 y) const;
+		void Uniform3ui(int index, u32 x, u32 y, u32 z) const;
+		void Uniform4ui(int index, u32 x, u32 y, u32 z, u32 w) const;
+		void Uniform1i(int index, s32 x) const;
+		void Uniform2i(int index, s32 x, s32 y) const;
+		void Uniform3i(int index, s32 x, s32 y, s32 z) const;
+		void Uniform4i(int index, s32 x, s32 y, s32 z, s32 w) const;
+		void Uniform1f(int index, float x) const;
+		void Uniform2f(int index, float x, float y) const;
+		void Uniform3f(int index, float x, float y, float z) const;
+		void Uniform4f(int index, float x, float y, float z, float w) const;
+		void Uniform2uiv(int index, const u32* v) const;
+		void Uniform3uiv(int index, const u32* v) const;
+		void Uniform4uiv(int index, const u32* v) const;
+		void Uniform2iv(int index, const s32* v) const;
+		void Uniform3iv(int index, const s32* v) const;
+		void Uniform4iv(int index, const s32* v) const;
+		void Uniform2fv(int index, const float* v) const;
+		void Uniform3fv(int index, const float* v) const;
+		void Uniform4fv(int index, const float* v) const;
+
+		void Uniform1ui(const char* name, u32 x) const;
+		void Uniform2ui(const char* name, u32 x, u32 y) const;
+		void Uniform3ui(const char* name, u32 x, u32 y, u32 z) const;
+		void Uniform4ui(const char* name, u32 x, u32 y, u32 z, u32 w) const;
+		void Uniform1i(const char* name, s32 x) const;
+		void Uniform2i(const char* name, s32 x, s32 y) const;
+		void Uniform3i(const char* name, s32 x, s32 y, s32 z) const;
+		void Uniform4i(const char* name, s32 x, s32 y, s32 z, s32 w) const;
+		void Uniform1f(const char* name, float x) const;
+		void Uniform2f(const char* name, float x, float y) const;
+		void Uniform3f(const char* name, float x, float y, float z) const;
+		void Uniform4f(const char* name, float x, float y, float z, float w) const;
+		void Uniform2uiv(const char* name, const u32* v) const;
+		void Uniform3uiv(const char* name, const u32* v) const;
+		void Uniform4uiv(const char* name, const u32* v) const;
+		void Uniform2iv(const char* name, const s32* v) const;
+		void Uniform3iv(const char* name, const s32* v) const;
+		void Uniform4iv(const char* name, const s32* v) const;
+		void Uniform2fv(const char* name, const float* v) const;
+		void Uniform3fv(const char* name, const float* v) const;
+		void Uniform4fv(const char* name, const float* v) const;
+
+		void BindUniformBlock(const char* name, u32 index);
+
+		void SetName(const std::string_view& name);
+		void SetFormattedName(const char* format, ...);
+
+		Program& operator=(const Program&) = delete;
+		Program& operator=(Program&& prog);
+
+		__fi bool operator==(const Program& rhs) const { return m_program_id == rhs.m_program_id; }
+		__fi bool operator!=(const Program& rhs) const { return m_program_id != rhs.m_program_id; }
+
+	private:
+		static u32 s_last_program_id;
+
+		GLuint m_program_id = 0;
+		GLuint m_vertex_shader_id = 0;
+		GLuint m_fragment_shader_id = 0;
+
+		std::vector<GLint> m_uniform_locations;
+	};
+} // namespace GL
--- a/common/GL/ShaderCache.cpp
+++ b/common/GL/ShaderCache.cpp
@@ -0,0 +1,566 @@
+/*  PCSX2 - PS2 Emulator for PCs
+ *  Copyright (C) 2002-2021 PCSX2 Dev Team
+ *
+ *  PCSX2 is free software: you can redistribute it and/or modify it under the terms
+ *  of the GNU Lesser General Public License as published by the Free Software Found-
+ *  ation, either version 3 of the License, or (at your option) any later version.
+ *
+ *  PCSX2 is distributed in the hope that it will be useful, but WITHOUT ANY WARRANTY;
+ *  without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR
+ *  PURPOSE.  See the GNU General Public License for more details.
+ *
+ *  You should have received a copy of the GNU General Public License along with PCSX2.
+ *  If not, see <http://www.gnu.org/licenses/>.
+ */
+
+#include "common/GL/ShaderCache.h"
+#include "common/FileSystem.h"
+#include "common/Console.h"
+#include "common/MD5Digest.h"
+#include "common/StringUtil.h"
+#include "common/Timer.h"
+
+namespace GL
+{
+#pragma pack(push, 1)
+	struct CacheIndexEntry
+	{
+		u64 vertex_source_hash_low;
+		u64 vertex_source_hash_high;
+		u32 vertex_source_length;
+		u64 geometry_source_hash_low;
+		u64 geometry_source_hash_high;
+		u32 geometry_source_length;
+		u64 fragment_source_hash_low;
+		u64 fragment_source_hash_high;
+		u32 fragment_source_length;
+		u32 file_offset;
+		u32 blob_size;
+		u32 blob_format;
+	};
+#pragma pack(pop)
+
+	ShaderCache::ShaderCache() = default;
+
+	ShaderCache::~ShaderCache()
+	{
+		Close();
+	}
+
+	bool ShaderCache::CacheIndexKey::operator==(const CacheIndexKey& key) const
+	{
+		return (
+			vertex_source_hash_low == key.vertex_source_hash_low && vertex_source_hash_high == key.vertex_source_hash_high &&
+			vertex_source_length == key.vertex_source_length && geometry_source_hash_low == key.geometry_source_hash_low &&
+			geometry_source_hash_high == key.geometry_source_hash_high &&
+			geometry_source_length == key.geometry_source_length && fragment_source_hash_low == key.fragment_source_hash_low &&
+			fragment_source_hash_high == key.fragment_source_hash_high && fragment_source_length == key.fragment_source_length);
+	}
+
+	bool ShaderCache::CacheIndexKey::operator!=(const CacheIndexKey& key) const
+	{
+		return (
+			vertex_source_hash_low != key.vertex_source_hash_low || vertex_source_hash_high != key.vertex_source_hash_high ||
+			vertex_source_length != key.vertex_source_length || geometry_source_hash_low != key.geometry_source_hash_low ||
+			geometry_source_hash_high != key.geometry_source_hash_high ||
+			geometry_source_length != key.geometry_source_length || fragment_source_hash_low != key.fragment_source_hash_low ||
+			fragment_source_hash_high != key.fragment_source_hash_high || fragment_source_length != key.fragment_source_length);
+	}
+
+	bool ShaderCache::Open(bool is_gles, std::string_view base_path, u32 version)
+	{
+		m_base_path = base_path;
+		m_version = version;
+		m_program_binary_supported = is_gles || GLAD_GL_ARB_get_program_binary;
+		if (m_program_binary_supported)
+		{
+			// check that there's at least one format and the extension isn't being "faked"
+			GLint num_formats = 0;
+			glGetIntegerv(GL_NUM_PROGRAM_BINARY_FORMATS, &num_formats);
+			Console.WriteLn("%u program binary formats supported by driver", num_formats);
+			m_program_binary_supported = (num_formats > 0);
+		}
+
+		if (!m_program_binary_supported)
+		{
+			Console.Warning("Your GL driver does not support program binaries. Hopefully it has a built-in cache.");
+			return true;
+		}
+
+		if (!base_path.empty())
+		{
+			const std::string index_filename = GetIndexFileName();
+			const std::string blob_filename = GetBlobFileName();
+
+			if (ReadExisting(index_filename, blob_filename))
+				return true;
+
+			return CreateNew(index_filename, blob_filename);
+		}
+
+		return true;
+	}
+
+	bool ShaderCache::CreateNew(const std::string& index_filename, const std::string& blob_filename)
+	{
+		if (FileSystem::FileExists(index_filename.c_str()))
+		{
+			Console.Warning("Removing existing index file '%s'", index_filename.c_str());
+			FileSystem::DeleteFilePath(index_filename.c_str());
+		}
+		if (FileSystem::FileExists(blob_filename.c_str()))
+		{
+			Console.Warning("Removing existing blob file '%s'", blob_filename.c_str());
+			FileSystem::DeleteFilePath(blob_filename.c_str());
+		}
+
+		m_index_file = FileSystem::OpenCFile(index_filename.c_str(), "wb");
+		if (!m_index_file)
+		{
+			Console.Error("Failed to open index file '%s' for writing", index_filename.c_str());
+			return false;
+		}
+
+		const u32 index_version = FILE_VERSION;
+		if (std::fwrite(&index_version, sizeof(index_version), 1, m_index_file) != 1 ||
+			std::fwrite(&m_version, sizeof(m_version), 1, m_index_file) != 1)
+		{
+			Console.Error("Failed to write version to index file '%s'", index_filename.c_str());
+			std::fclose(m_index_file);
+			m_index_file = nullptr;
+			FileSystem::DeleteFilePath(index_filename.c_str());
+			return false;
+		}
+
+		m_blob_file = FileSystem::OpenCFile(blob_filename.c_str(), "w+b");
+		if (!m_blob_file)
+		{
+			Console.Error("Failed to open blob file '%s' for writing", blob_filename.c_str());
+			std::fclose(m_index_file);
+			m_index_file = nullptr;
+			FileSystem::DeleteFilePath(index_filename.c_str());
+			return false;
+		}
+
+		return true;
+	}
+
+	bool ShaderCache::ReadExisting(const std::string& index_filename, const std::string& blob_filename)
+	{
+		m_index_file = FileSystem::OpenCFile(index_filename.c_str(), "r+b");
+		if (!m_index_file)
+		{
+			// special case here: when there's a sharing violation (i.e. two instances running),
+			// we don't want to blow away the cache. so just continue without a cache.
+			if (errno == EACCES)
+			{
+				Console.WriteLn("Failed to open shader cache index with EACCES, are you running two instances?");
+				return true;
+			}
+
+			return false;
+		}
+
+		u32 file_version = 0;
+		u32 data_version = 0;
+		if (std::fread(&file_version, sizeof(file_version), 1, m_index_file) != 1 || file_version != FILE_VERSION ||
+			std::fread(&data_version, sizeof(data_version), 1, m_index_file) != 1 || data_version != m_version)
+		{
+			Console.Error("Bad file/data version in '%s'", index_filename.c_str());
+			std::fclose(m_index_file);
+			m_index_file = nullptr;
+			return false;
+		}
+
+		m_blob_file = FileSystem::OpenCFile(blob_filename.c_str(), "a+b");
+		if (!m_blob_file)
+		{
+			Console.Error("Blob file '%s' is missing", blob_filename.c_str());
+			std::fclose(m_index_file);
+			m_index_file = nullptr;
+			return false;
+		}
+
+		std::fseek(m_blob_file, 0, SEEK_END);
+		const u32 blob_file_size = static_cast<u32>(std::ftell(m_blob_file));
+
+		for (;;)
+		{
+			CacheIndexEntry entry;
+			if (std::fread(&entry, sizeof(entry), 1, m_index_file) != 1 ||
+				(entry.file_offset + entry.blob_size) > blob_file_size)
+			{
+				if (std::feof(m_index_file))
+					break;
+
+				Console.Error("Failed to read entry from '%s', corrupt file?", index_filename.c_str());
+				m_index.clear();
+				std::fclose(m_blob_file);
+				m_blob_file = nullptr;
+				std::fclose(m_index_file);
+				m_index_file = nullptr;
+				return false;
+			}
+
+			const CacheIndexKey key{
+				entry.vertex_source_hash_low, entry.vertex_source_hash_high, entry.vertex_source_length,
+				entry.geometry_source_hash_low, entry.geometry_source_hash_high, entry.geometry_source_length,
+				entry.fragment_source_hash_low, entry.fragment_source_hash_high, entry.fragment_source_length};
+			const CacheIndexData data{entry.file_offset, entry.blob_size, entry.blob_format};
+			m_index.emplace(key, data);
+		}
+
+		Console.WriteLn("Read %zu entries from '%s'", m_index.size(), index_filename.c_str());
+		return true;
+	}
+
+	void ShaderCache::Close()
+	{
+		m_index.clear();
+		if (m_index_file)
+			std::fclose(m_index_file);
+		if (m_blob_file)
+			std::fclose(m_blob_file);
+	}
+
+	bool ShaderCache::Recreate()
+	{
+		Close();
+
+		const std::string index_filename = GetIndexFileName();
+		const std::string blob_filename = GetBlobFileName();
+
+		return CreateNew(index_filename, blob_filename);
+	}
+
+	ShaderCache::CacheIndexKey ShaderCache::GetCacheKey(const std::string_view& vertex_shader,
+		const std::string_view& geometry_shader,
+		const std::string_view& fragment_shader)
+	{
+		union ShaderHash
+		{
+			struct
+			{
+				u64 low;
+				u64 high;
+			};
+			u8 bytes[16];
+		};
+
+		ShaderHash vertex_hash = {};
+		ShaderHash geometry_hash = {};
+		ShaderHash fragment_hash = {};
+
+		MD5Digest digest;
+		if (!vertex_shader.empty())
+		{
+			digest.Update(vertex_shader.data(), static_cast<u32>(vertex_shader.length()));
+			digest.Final(vertex_hash.bytes);
+		}
+
+		if (!geometry_shader.empty())
+		{
+			digest.Reset();
+			digest.Update(geometry_shader.data(), static_cast<u32>(geometry_shader.length()));
+			digest.Final(geometry_hash.bytes);
+		}
+
+		if (!fragment_shader.empty())
+		{
+			digest.Reset();
+			digest.Update(fragment_shader.data(), static_cast<u32>(fragment_shader.length()));
+			digest.Final(fragment_hash.bytes);
+		}
+
+		return CacheIndexKey{vertex_hash.low, vertex_hash.high, static_cast<u32>(vertex_shader.length()),
+			geometry_hash.low, geometry_hash.high, static_cast<u32>(geometry_shader.length()),
+			fragment_hash.low, fragment_hash.high, static_cast<u32>(fragment_shader.length())};
+	}
+
+	std::string ShaderCache::GetIndexFileName() const
+	{
+		return StringUtil::StdStringFromFormat("%s/gl_programs.idx", m_base_path.c_str());
+	}
+
+	std::string ShaderCache::GetBlobFileName() const
+	{
+		return StringUtil::StdStringFromFormat("%s/gl_programs.bin", m_base_path.c_str());
+	}
+
+	std::optional<Program> ShaderCache::GetProgram(const std::string_view vertex_shader,
+		const std::string_view geometry_shader,
+		const std::string_view fragment_shader, const PreLinkCallback& callback)
+	{
+		if (!m_program_binary_supported || !m_blob_file)
+		{
+#ifdef PCSX2_DEVBUILD
+			Common::Timer timer;
+#endif
+
+			std::optional<Program> res = CompileProgram(vertex_shader, geometry_shader, fragment_shader, callback, false);
+
+#ifdef PCSX2_DEVBUILD
+			Console.WriteLn("Time to compile shader without caching: %.2fms", timer.GetTimeMilliseconds());
+#endif
+			return res;
+		}
+
+		const auto key = GetCacheKey(vertex_shader, geometry_shader, fragment_shader);
+		auto iter = m_index.find(key);
+		if (iter == m_index.end())
+			return CompileAndAddProgram(key, vertex_shader, geometry_shader, fragment_shader, callback);
+
+		std::vector<u8> data(iter->second.blob_size);
+		if (std::fseek(m_blob_file, iter->second.file_offset, SEEK_SET) != 0 ||
+			std::fread(data.data(), 1, iter->second.blob_size, m_blob_file) != iter->second.blob_size)
+		{
+			Console.Error("Read blob from file failed");
+			return {};
+		}
+
+#ifdef PCSX2_DEVBUILD
+		Common::Timer timer;
+#endif
+
+		Program prog;
+		if (prog.CreateFromBinary(data.data(), static_cast<u32>(data.size()), iter->second.blob_format))
+		{
+#ifdef PCSX2_DEVBUILD
+			Console.WriteLn("Time to create program from binary: %.2fms", timer.GetTimeMilliseconds());
+#endif
+
+			return std::optional<Program>(std::move(prog));
+		}
+
+		Console.Warning(
+			"Failed to create program from binary, this may be due to a driver or GPU Change. Recreating cache.");
+		if (!Recreate())
+			return CompileProgram(vertex_shader, geometry_shader, fragment_shader, callback, false);
+		else
+			return CompileAndAddProgram(key, vertex_shader, geometry_shader, fragment_shader, callback);
+	}
+
+	bool ShaderCache::GetProgram(Program* out_program, const std::string_view vertex_shader,
+		const std::string_view geometry_shader, const std::string_view fragment_shader,
+		const PreLinkCallback& callback /* = */)
+	{
+		auto prog = GetProgram(vertex_shader, geometry_shader, fragment_shader, callback);
+		if (!prog)
+			return false;
+
+		*out_program = std::move(*prog);
+		return true;
+	}
+
+	bool ShaderCache::WriteToBlobFile(const CacheIndexKey& key, const std::vector<u8>& prog_data, u32 prog_format)
+	{
+		if (!m_blob_file || std::fseek(m_blob_file, 0, SEEK_END) != 0)
+			return false;
+
+		CacheIndexData data;
+		data.file_offset = static_cast<u32>(std::ftell(m_blob_file));
+		data.blob_size = static_cast<u32>(prog_data.size());
+		data.blob_format = prog_format;
+
+		CacheIndexEntry entry = {};
+		entry.vertex_source_hash_low = key.vertex_source_hash_low;
+		entry.vertex_source_hash_high = key.vertex_source_hash_high;
+		entry.vertex_source_length = key.vertex_source_length;
+		entry.geometry_source_hash_low = key.geometry_source_hash_low;
+		entry.geometry_source_hash_high = key.geometry_source_hash_high;
+		entry.geometry_source_length = key.geometry_source_length;
+		entry.fragment_source_hash_low = key.fragment_source_hash_low;
+		entry.fragment_source_hash_high = key.fragment_source_hash_high;
+		entry.fragment_source_length = key.fragment_source_length;
+		entry.file_offset = data.file_offset;
+		entry.blob_size = data.blob_size;
+		entry.blob_format = data.blob_format;
+
+		if (std::fwrite(prog_data.data(), 1, entry.blob_size, m_blob_file) != entry.blob_size ||
+			std::fflush(m_blob_file) != 0 || std::fwrite(&entry, sizeof(entry), 1, m_index_file) != 1 ||
+			std::fflush(m_index_file) != 0)
+		{
+			Console.Error("Failed to write shader blob to file");
+			return false;
+		}
+
+		m_index.emplace(key, data);
+		return true;
+	}
+
+	std::optional<Program> ShaderCache::CompileProgram(const std::string_view& vertex_shader,
+		const std::string_view& geometry_shader,
+		const std::string_view& fragment_shader,
+		const PreLinkCallback& callback, bool set_retrievable)
+	{
+		Program prog;
+		if (!prog.Compile(vertex_shader, geometry_shader, fragment_shader))
+			return std::nullopt;
+
+		if (callback)
+			callback(prog);
+
+		if (set_retrievable)
+			prog.SetBinaryRetrievableHint();
+
+		if (!prog.Link())
+			return std::nullopt;
+
+		return std::optional<Program>(std::move(prog));
+	}
+
+	std::optional<Program> ShaderCache::CompileComputeProgram(const std::string_view& glsl,
+		const PreLinkCallback& callback, bool set_retrievable)
+	{
+		Program prog;
+		if (!prog.CompileCompute(glsl))
+			return std::nullopt;
+
+		if (callback)
+			callback(prog);
+
+		if (set_retrievable)
+			prog.SetBinaryRetrievableHint();
+
+		if (!prog.Link())
+			return std::nullopt;
+
+		return std::optional<Program>(std::move(prog));
+	}
+
+	std::optional<Program> ShaderCache::CompileAndAddProgram(const CacheIndexKey& key,
+		const std::string_view& vertex_shader,
+		const std::string_view& geometry_shader,
+		const std::string_view& fragment_shader,
+		const PreLinkCallback& callback)
+	{
+#ifdef PCSX2_DEVBUILD
+		Common::Timer timer;
+#endif
+
+		std::optional<Program> prog = CompileProgram(vertex_shader, geometry_shader, fragment_shader, callback, true);
+		if (!prog)
+			return std::nullopt;
+
+#ifdef PCSX2_DEVBUILD
+		const float compile_time = timer.GetTimeMilliseconds();
+		timer.Reset();
+#endif
+
+		std::vector<u8> prog_data;
+		u32 prog_format = 0;
+		if (!prog->GetBinary(&prog_data, &prog_format))
+			return std::nullopt;
+
+#ifdef PCSX2_DEVBUILD
+		const float binary_time = timer.GetTimeMilliseconds();
+		timer.Reset();
+#endif
+		
+		WriteToBlobFile(key, prog_data, prog_format);
+
+#ifdef PCSX2_DEVBUILD
+		const float write_time = timer.GetTimeMilliseconds();
+		Console.WriteLn("Compiled and cached shader: Compile: %.2fms, Binary: %.2fms, Write: %.2fms", compile_time, binary_time, write_time);
+#endif
+
+		return prog;
+	}
+
+	std::optional<Program> ShaderCache::GetComputeProgram(const std::string_view glsl, const PreLinkCallback& callback)
+	{
+		if (!m_program_binary_supported || !m_blob_file)
+		{
+#ifdef PCSX2_DEVBUILD
+			Common::Timer timer;
+#endif
+
+			std::optional<Program> res = CompileComputeProgram(glsl, callback, false);
+
+#ifdef PCSX2_DEVBUILD
+			Console.WriteLn("Time to compile shader without caching: %.2fms", timer.GetTimeMilliseconds());
+#endif
+			return res;
+		}
+
+		const auto key = GetCacheKey(glsl, std::string_view(), std::string_view());
+		auto iter = m_index.find(key);
+		if (iter == m_index.end())
+			return CompileAndAddComputeProgram(key, glsl, callback);
+
+		std::vector<u8> data(iter->second.blob_size);
+		if (std::fseek(m_blob_file, iter->second.file_offset, SEEK_SET) != 0 ||
+			std::fread(data.data(), 1, iter->second.blob_size, m_blob_file) != iter->second.blob_size)
+		{
+			Console.Error("Read blob from file failed");
+			return {};
+		}
+
+#ifdef PCSX2_DEVBUILD
+		Common::Timer timer;
+#endif
+
+		Program prog;
+		if (prog.CreateFromBinary(data.data(), static_cast<u32>(data.size()), iter->second.blob_format))
+		{
+#ifdef PCSX2_DEVBUILD
+			Console.WriteLn("Time to create program from binary: %.2fms", timer.GetTimeMilliseconds());
+#endif
+
+			return std::optional<Program>(std::move(prog));
+		}
+
+		Console.Warning(
+			"Failed to create program from binary, this may be due to a driver or GPU Change. Recreating cache.");
+		if (!Recreate())
+			return CompileComputeProgram(glsl, callback, false);
+		else
+			return CompileAndAddComputeProgram(key, glsl, callback);
+	}
+
+	bool ShaderCache::GetComputeProgram(Program* out_program, const std::string_view glsl, const PreLinkCallback& callback)
+	{
+		auto prog = GetComputeProgram(glsl, callback);
+		if (!prog)
+			return false;
+
+		*out_program = std::move(*prog);
+		return true;
+	}
+
+	std::optional<Program> ShaderCache::CompileAndAddComputeProgram(
+		const CacheIndexKey& key, const std::string_view& glsl, const PreLinkCallback& callback)
+	{
+#ifdef PCSX2_DEVBUILD
+		Common::Timer timer;
+#endif
+
+		std::optional<Program> prog = CompileComputeProgram(glsl, callback, true);
+		if (!prog)
+			return std::nullopt;
+
+#ifdef PCSX2_DEVBUILD
+		const float compile_time = timer.GetTimeMilliseconds();
+		timer.Reset();
+#endif
+
+		std::vector<u8> prog_data;
+		u32 prog_format = 0;
+		if (!prog->GetBinary(&prog_data, &prog_format))
+			return std::nullopt;
+
+#ifdef PCSX2_DEVBUILD
+		const float binary_time = timer.GetTimeMilliseconds();
+		timer.Reset();
+#endif
+
+		WriteToBlobFile(key, prog_data, prog_format);
+
+#ifdef PCSX2_DEVBUILD
+		const float write_time = timer.GetTimeMilliseconds();
+		Console.WriteLn("Compiled and cached compute shader: Compile: %.2fms, Binary: %.2fms, Write: %.2fms", compile_time, binary_time, write_time);
+#endif
+
+		return prog;
+	}
+} // namespace GL
--- a/common/GL/ShaderCache.h
+++ b/common/GL/ShaderCache.h
@@ -0,0 +1,120 @@
+/*  PCSX2 - PS2 Emulator for PCs
+ *  Copyright (C) 2002-2021 PCSX2 Dev Team
+ *
+ *  PCSX2 is free software: you can redistribute it and/or modify it under the terms
+ *  of the GNU Lesser General Public License as published by the Free Software Found-
+ *  ation, either version 3 of the License, or (at your option) any later version.
+ *
+ *  PCSX2 is distributed in the hope that it will be useful, but WITHOUT ANY WARRANTY;
+ *  without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR
+ *  PURPOSE.  See the GNU General Public License for more details.
+ *
+ *  You should have received a copy of the GNU General Public License along with PCSX2.
+ *  If not, see <http://www.gnu.org/licenses/>.
+ */
+
+#pragma once
+#include "common/Pcsx2Defs.h"
+#include "common/HashCombine.h"
+#include "common/GL/Program.h"
+#include <cstdio>
+#include <functional>
+#include <optional>
+#include <string>
+#include <string_view>
+#include <unordered_map>
+#include <vector>
+
+namespace GL
+{
+	class ShaderCache
+	{
+	public:
+		using PreLinkCallback = std::function<void(Program&)>;
+
+		ShaderCache();
+		~ShaderCache();
+
+		bool Open(bool is_gles, std::string_view base_path, u32 version);
+
+		std::optional<Program> GetProgram(const std::string_view vertex_shader, const std::string_view geometry_shader,
+			const std::string_view fragment_shader, const PreLinkCallback& callback = {});
+		bool GetProgram(Program* out_program, const std::string_view vertex_shader, const std::string_view geometry_shader,
+			const std::string_view fragment_shader, const PreLinkCallback& callback = {});
+
+		std::optional<Program> GetComputeProgram(const std::string_view glsl, const PreLinkCallback& callback = {});
+		bool GetComputeProgram(Program* out_program, const std::string_view glsl, const PreLinkCallback& callback = {});
+
+	private:
+		static constexpr u32 FILE_VERSION = 1;
+
+		struct CacheIndexKey
+		{
+			u64 vertex_source_hash_low;
+			u64 vertex_source_hash_high;
+			u32 vertex_source_length;
+			u64 geometry_source_hash_low;
+			u64 geometry_source_hash_high;
+			u32 geometry_source_length;
+			u64 fragment_source_hash_low;
+			u64 fragment_source_hash_high;
+			u32 fragment_source_length;
+
+			bool operator==(const CacheIndexKey& key) const;
+			bool operator!=(const CacheIndexKey& key) const;
+		};
+
+		struct CacheIndexEntryHasher
+		{
+			std::size_t operator()(const CacheIndexKey& e) const noexcept
+			{
+				std::size_t h = 0;
+				HashCombine(h,
+					e.vertex_source_hash_low, e.vertex_source_hash_high, e.vertex_source_length,
+					e.geometry_source_hash_low, e.geometry_source_hash_high, e.geometry_source_length,
+					e.fragment_source_hash_low, e.fragment_source_hash_high, e.fragment_source_length);
+				return h;
+			}
+		};
+
+		struct CacheIndexData
+		{
+			u32 file_offset;
+			u32 blob_size;
+			u32 blob_format;
+		};
+
+		using CacheIndex = std::unordered_map<CacheIndexKey, CacheIndexData, CacheIndexEntryHasher>;
+
+		static CacheIndexKey GetCacheKey(const std::string_view& vertex_shader, const std::string_view& geometry_shader,
+			const std::string_view& fragment_shader);
+
+		std::string GetIndexFileName() const;
+		std::string GetBlobFileName() const;
+
+		bool CreateNew(const std::string& index_filename, const std::string& blob_filename);
+		bool ReadExisting(const std::string& index_filename, const std::string& blob_filename);
+		void Close();
+		bool Recreate();
+
+		bool WriteToBlobFile(const CacheIndexKey& key, const std::vector<u8>& prog_data, u32 prog_format);
+
+		std::optional<Program> CompileProgram(const std::string_view& vertex_shader, const std::string_view& geometry_shader,
+			const std::string_view& fragment_shader, const PreLinkCallback& callback,
+			bool set_retrievable);
+		std::optional<Program> CompileAndAddProgram(const CacheIndexKey& key, const std::string_view& vertex_shader,
+			const std::string_view& geometry_shader,
+			const std::string_view& fragment_shader, const PreLinkCallback& callback);
+
+		std::optional<Program> CompileComputeProgram(const std::string_view& glsl, const PreLinkCallback& callback, bool set_retrievable);
+		std::optional<Program> CompileAndAddComputeProgram(const CacheIndexKey& key, const std::string_view& glsl, const PreLinkCallback& callback);
+
+		std::string m_base_path;
+		std::FILE* m_index_file = nullptr;
+		std::FILE* m_blob_file = nullptr;
+
+		CacheIndex m_index;
+		u32 m_version = 0;
+		bool m_program_binary_supported = false;
+	};
+} // namespace GL
--- a/common/GL/StreamBuffer.cpp
+++ b/common/GL/StreamBuffer.cpp
@@ -0,0 +1,346 @@
+/*  PCSX2 - PS2 Emulator for PCs
+ *  Copyright (C) 2002-2021  PCSX2 Dev Team
+ *
+ *  PCSX2 is free software: you can redistribute it and/or modify it under the terms
+ *  of the GNU Lesser General Public License as published by the Free Software Found-
+ *  ation, either version 3 of the License, or (at your option) any later version.
+ *
+ *  PCSX2 is distributed in the hope that it will be useful, but WITHOUT ANY WARRANTY;
+ *  without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR
+ *  PURPOSE.  See the GNU General Public License for more details.
+ *
+ *  You should have received a copy of the GNU General Public License along with PCSX2.
+ *  If not, see <http://www.gnu.org/licenses/>.
+ */
+
+#include "StreamBuffer.h"
+#include "common/Align.h"
+#include "common/Assertions.h"
+#include <array>
+#include <cstring>
+
+namespace GL
+{
+	StreamBuffer::StreamBuffer(GLenum target, GLuint buffer_id, u32 size)
+		: m_target(target)
+		, m_buffer_id(buffer_id)
+		, m_size(size)
+	{
+	}
+
+	StreamBuffer::~StreamBuffer()
+	{
+		glDeleteBuffers(1, &m_buffer_id);
+	}
+
+	void StreamBuffer::Bind()
+	{
+		glBindBuffer(m_target, m_buffer_id);
+	}
+
+	void StreamBuffer::Unbind()
+	{
+		glBindBuffer(m_target, 0);
+	}
+
+	namespace detail
+	{
+		// Uses glBufferSubData() to update. Preferred for drivers which don't support {ARB,EXT}_buffer_storage.
+		class BufferSubDataStreamBuffer final : public StreamBuffer
+		{
+		public:
+			~BufferSubDataStreamBuffer() override = default;
+
+			MappingResult Map(u32 alignment, u32 min_size) override
+			{
+				return MappingResult{static_cast<void*>(m_cpu_buffer.data()), 0, 0, m_size / alignment};
+			}
+
+			void Unmap(u32 used_size) override
+			{
+				if (used_size == 0)
+					return;
+
+				glBindBuffer(m_target, m_buffer_id);
+				glBufferSubData(m_target, 0, used_size, m_cpu_buffer.data());
+			}
+
+			u32 GetChunkSize() const override
+			{
+				return m_size;
+			}
+
+			static std::unique_ptr<StreamBuffer> Create(GLenum target, u32 size)
+			{
+				glGetError();
+
+				GLuint buffer_id;
+				glGenBuffers(1, &buffer_id);
+				glBindBuffer(target, buffer_id);
+				glBufferData(target, size, nullptr, GL_STREAM_DRAW);
+
+				GLenum err = glGetError();
+				if (err != GL_NO_ERROR)
+				{
+					glBindBuffer(target, 0);
+					glDeleteBuffers(1, &buffer_id);
+					return {};
+				}
+
+				return std::unique_ptr<StreamBuffer>(new BufferSubDataStreamBuffer(target, buffer_id, size));
+			}
+
+		private:
+			BufferSubDataStreamBuffer(GLenum target, GLuint buffer_id, u32 size)
+				: StreamBuffer(target, buffer_id, size)
+				, m_cpu_buffer(size)
+			{
+			}
+
+			std::vector<u8> m_cpu_buffer;
+		};
+
+		// Uses BufferData() to orphan the buffer after every update. Used on Mali where BufferSubData forces a sync.
+		class BufferDataStreamBuffer final : public StreamBuffer
+		{
+		public:
+			~BufferDataStreamBuffer() override = default;
+
+			MappingResult Map(u32 alignment, u32 min_size) override
+			{
+				return MappingResult{static_cast<void*>(m_cpu_buffer.data()), 0, 0, m_size / alignment};
+			}
+
+			void Unmap(u32 used_size) override
+			{
+				if (used_size == 0)
+					return;
+
+				glBindBuffer(m_target, m_buffer_id);
+				glBufferData(m_target, used_size, m_cpu_buffer.data(), GL_STREAM_DRAW);
+			}
+
+			u32 GetChunkSize() const override
+			{
+				return m_size;
+			}
+
+			static std::unique_ptr<StreamBuffer> Create(GLenum target, u32 size)
+			{
+				glGetError();
+
+				GLuint buffer_id;
+				glGenBuffers(1, &buffer_id);
+				glBindBuffer(target, buffer_id);
+				glBufferData(target, size, nullptr, GL_STREAM_DRAW);
+
+				GLenum err = glGetError();
+				if (err != GL_NO_ERROR)
+				{
+					glBindBuffer(target, 0);
+					glDeleteBuffers(1, &buffer_id);
+					return {};
+				}
+
+				return std::unique_ptr<StreamBuffer>(new BufferDataStreamBuffer(target, buffer_id, size));
+			}
+
+		private:
+			BufferDataStreamBuffer(GLenum target, GLuint buffer_id, u32 size)
+				: StreamBuffer(target, buffer_id, size)
+				, m_cpu_buffer(size)
+			{
+			}
+
+			std::vector<u8> m_cpu_buffer;
+		};
+
+		// Base class for implementations which require syncing.
+		class SyncingStreamBuffer : public StreamBuffer
+		{
+		public:
+			enum : u32
+			{
+				NUM_SYNC_POINTS = 16
+			};
+
+			virtual ~SyncingStreamBuffer() override
+			{
+				for (u32 i = m_available_block_index; i <= m_used_block_index; i++)
+				{
+					pxAssert(m_sync_objects[i]);
+					glDeleteSync(m_sync_objects[i]);
+				}
+			}
+
+		protected:
+			SyncingStreamBuffer(GLenum target, GLuint buffer_id, u32 size)
+				: StreamBuffer(target, buffer_id, size)
+				, m_bytes_per_block((size + (NUM_SYNC_POINTS)-1) / NUM_SYNC_POINTS)
+			{
+			}
+
+			__fi u32 GetSyncIndexForOffset(u32 offset) { return offset / m_bytes_per_block; }
+
+			__fi void AddSyncsForOffset(u32 offset)
+			{
+				const u32 end = GetSyncIndexForOffset(offset);
+				for (; m_used_block_index < end; m_used_block_index++)
+				{
+					pxAssert(!m_sync_objects[m_used_block_index]);
+					m_sync_objects[m_used_block_index] = glFenceSync(GL_SYNC_GPU_COMMANDS_COMPLETE, 0);
+				}
+			}
+
+			__fi void WaitForSync(GLsync& sync)
+			{
+				glClientWaitSync(sync, GL_SYNC_FLUSH_COMMANDS_BIT, GL_TIMEOUT_IGNORED);
+				glDeleteSync(sync);
+				sync = nullptr;
+			}
+
+			__fi void EnsureSyncsWaitedForOffset(u32 offset)
+			{
+				const u32 end = std::min<u32>(GetSyncIndexForOffset(offset) + 1, NUM_SYNC_POINTS);
+				for (; m_available_block_index < end; m_available_block_index++)
+				{
+					pxAssert(m_sync_objects[m_available_block_index]);
+					WaitForSync(m_sync_objects[m_available_block_index]);
+				}
+			}
+
+			void AllocateSpace(u32 size)
+			{
+				// add sync objects for writes since the last allocation
+				AddSyncsForOffset(m_position);
+
+				// wait for sync objects for the space we want to use
+				EnsureSyncsWaitedForOffset(m_position + size);
+
+				// wrap-around?
+				if ((m_position + size) > m_size)
+				{
+					// current position ... buffer end
+					AddSyncsForOffset(m_size);
+
+					// rewind, and try again
+					m_position = 0;
+
+					// wait for the sync at the start of the buffer
+					WaitForSync(m_sync_objects[0]);
+					m_available_block_index = 1;
+
+					// and however much more we need to satisfy the allocation
+					EnsureSyncsWaitedForOffset(size);
+					m_used_block_index = 0;
+				}
+			}
+
+			u32 GetChunkSize() const override
+			{
+				return m_size / NUM_SYNC_POINTS;
+			}
+
+			u32 m_position = 0;
+			u32 m_used_block_index = 0;
+			u32 m_available_block_index = NUM_SYNC_POINTS;
+			u32 m_bytes_per_block;
+			std::array<GLsync, NUM_SYNC_POINTS> m_sync_objects{};
+		};
+
+		class BufferStorageStreamBuffer : public SyncingStreamBuffer
+		{
+		public:
+			~BufferStorageStreamBuffer() override
+			{
+				glBindBuffer(m_target, m_buffer_id);
+				glUnmapBuffer(m_target);
+				glBindBuffer(m_target, 0);
+			}
+
+			MappingResult Map(u32 alignment, u32 min_size) override
+			{
+				if (m_position > 0)
+					m_position = Common::AlignUp(m_position, alignment);
+
+				AllocateSpace(min_size);
+				pxAssert((m_position + min_size) <= (m_available_block_index * m_bytes_per_block));
+
+				const u32 free_space_in_block = ((m_available_block_index * m_bytes_per_block) - m_position);
+				return MappingResult{static_cast<void*>(m_mapped_ptr + m_position), m_position, m_position / alignment,
+					free_space_in_block / alignment};
+			}
+
+			void Unmap(u32 used_size) override
+			{
+				pxAssert((m_position + used_size) <= m_size);
+				if (!m_coherent)
+				{
+					Bind();
+					glFlushMappedBufferRange(m_target, m_position, used_size);
+				}
+
+				m_position += used_size;
+			}
+
+			static std::unique_ptr<StreamBuffer> Create(GLenum target, u32 size, bool coherent = true)
+			{
+				glGetError();
+
+				GLuint buffer_id;
+				glGenBuffers(1, &buffer_id);
+				glBindBuffer(target, buffer_id);
+
+				const u32 flags = GL_MAP_WRITE_BIT | GL_MAP_PERSISTENT_BIT | (coherent ? GL_MAP_COHERENT_BIT : 0);
+				const u32 map_flags = GL_MAP_WRITE_BIT | GL_MAP_PERSISTENT_BIT | (coherent ? 0 : GL_MAP_FLUSH_EXPLICIT_BIT);
+				if (GLAD_GL_VERSION_4_4 || GLAD_GL_ARB_buffer_storage)
+					glBufferStorage(target, size, nullptr, flags);
+				else if (GLAD_GL_EXT_buffer_storage)
+					glBufferStorageEXT(target, size, nullptr, flags);
+
+				GLenum err = glGetError();
+				if (err != GL_NO_ERROR)
+				{
+					glBindBuffer(target, 0);
+					glDeleteBuffers(1, &buffer_id);
+					return {};
+				}
+
+				u8* mapped_ptr = static_cast<u8*>(glMapBufferRange(target, 0, size, map_flags));
+				pxAssertRel(mapped_ptr, "Persistent buffer was mapped");
+
+				return std::unique_ptr<StreamBuffer>(new BufferStorageStreamBuffer(target, buffer_id, size, mapped_ptr, coherent));
+			}
+
+		private:
+			BufferStorageStreamBuffer(GLenum target, GLuint buffer_id, u32 size, u8* mapped_ptr, bool coherent)
+				: SyncingStreamBuffer(target, buffer_id, size)
+				, m_mapped_ptr(mapped_ptr)
+				, m_coherent(coherent)
+			{
+			}
+
+			u8* m_mapped_ptr;
+			bool m_coherent;
+		};
+
+	} // namespace detail
+
+	std::unique_ptr<StreamBuffer> StreamBuffer::Create(GLenum target, u32 size)
+	{
+		std::unique_ptr<StreamBuffer> buf;
+		if (GLAD_GL_VERSION_4_4 || GLAD_GL_ARB_buffer_storage || GLAD_GL_EXT_buffer_storage)
+		{
+			buf = detail::BufferStorageStreamBuffer::Create(target, size);
+			if (buf)
+				return buf;
+		}
+
+		// BufferSubData is slower on all drivers except NVIDIA...
+		const char* vendor = reinterpret_cast<const char*>(glGetString(GL_VENDOR));
+		if (std::strstr(vendor, "NVIDIA"))
+			return detail::BufferSubDataStreamBuffer::Create(target, size);
+		else
+			return detail::BufferDataStreamBuffer::Create(target, size);
+	}
+} // namespace GL
--- a/common/GL/StreamBuffer.h
+++ b/common/GL/StreamBuffer.h
@@ -0,0 +1,61 @@
+/*  PCSX2 - PS2 Emulator for PCs
+ *  Copyright (C) 2002-2021  PCSX2 Dev Team
+ *
+ *  PCSX2 is free software: you can redistribute it and/or modify it under the terms
+ *  of the GNU Lesser General Public License as published by the Free Software Found-
+ *  ation, either version 3 of the License, or (at your option) any later version.
+ *
+ *  PCSX2 is distributed in the hope that it will be useful, but WITHOUT ANY WARRANTY;
+ *  without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR
+ *  PURPOSE.  See the GNU General Public License for more details.
+ *
+ *  You should have received a copy of the GNU General Public License along with PCSX2.
+ *  If not, see <http://www.gnu.org/licenses/>.
+ */
+
+#pragma once
+#include "common/Pcsx2Defs.h"
+#include "glad.h"
+#include <memory>
+#include <tuple>
+#include <vector>
+
+namespace GL
+{
+	/// Provides a buffer for streaming data to the GPU, ideally in write-combined memory.
+	class StreamBuffer
+	{
+	public:
+		virtual ~StreamBuffer();
+
+		__fi GLuint GetGLBufferId() const { return m_buffer_id; }
+		__fi GLenum GetGLTarget() const { return m_target; }
+		__fi u32 GetSize() const { return m_size; }
+
+		void Bind();
+		void Unbind();
+
+		struct MappingResult
+		{
+			void* pointer;
+			u32 buffer_offset;
+			u32 index_aligned; // offset / alignment, suitable for base vertex
+			u32 space_aligned; // remaining space / alignment
+		};
+
+		virtual MappingResult Map(u32 alignment, u32 min_size) = 0;
+		virtual void Unmap(u32 used_size) = 0;
+
+		/// Returns the minimum granularity of blocks which sync objects will be created around.
+		virtual u32 GetChunkSize() const = 0;
+
+		static std::unique_ptr<StreamBuffer> Create(GLenum target, u32 size);
+
+	protected:
+		StreamBuffer(GLenum target, GLuint buffer_id, u32 size);
+
+		GLenum m_target;
+		GLuint m_buffer_id;
+		u32 m_size;
+	};
+} // namespace GL
--- a/common/Linux/LnxHostSys.cpp
+++ b/common/Linux/LnxHostSys.cpp
@@ -89,7 +89,6 @@ static void SysPageFaultSignalFilter(int signal, siginfo_t* siginfo, void* ctx)
 	// Prevent recursive exception filtering.
 	if (s_in_exception_handler)
 	{
-		lock.unlock();
 		CallExistingSignalHandler(signal, siginfo, ctx);
 		return;
 	}
@@ -101,8 +100,6 @@ static void SysPageFaultSignalFilter(int signal, siginfo_t* siginfo, void* ctx)

 #if defined(__APPLE__) && defined(__x86_64__)
 	void* const exception_pc = reinterpret_cast<void*>(static_cast<ucontext_t*>(ctx)->uc_mcontext->__ss.__rip);
-#elif defined(__FreeBSD__) && defined(__x86_64__)
-	void* const exception_pc = reinterpret_cast<void*>(static_cast<ucontext_t*>(ctx)->uc_mcontext.mc_rip);
 #elif defined(__x86_64__)
 	void* const exception_pc = reinterpret_cast<void*>(static_cast<ucontext_t*>(ctx)->uc_mcontext.gregs[REG_RIP]);
 #else
@@ -122,7 +119,6 @@ static void SysPageFaultSignalFilter(int signal, siginfo_t* siginfo, void* ctx)
 		return;

 	// Call old signal handler, which will likely dump core.
-	lock.unlock();
 	CallExistingSignalHandler(signal, siginfo, ctx);
 }

@@ -137,10 +133,6 @@ bool HostSys::InstallPageFaultHandler(PageFaultHandler handler)
 		sigemptyset(&sa.sa_mask);
 		sa.sa_flags = SA_SIGINFO;
 		sa.sa_sigaction = SysPageFaultSignalFilter;
-#ifdef __linux__
-		// Don't block the signal from executing recursively, we want to fire the original handler.
-		sa.sa_flags |= SA_NODEFER;
-#endif
 #ifdef __APPLE__
 		// MacOS uses SIGBUS for memory permission violations
 		if (sigaction(SIGBUS, &sa, &s_old_sigbus_action) != 0)
--- a/common/Linux/LnxMisc.cpp
+++ b/common/Linux/LnxMisc.cpp
@@ -31,10 +31,6 @@
 #include "common/Threading.h"
 #include "common/WindowInfo.h"

-#ifdef DBUS_API
-#include <dbus/dbus.h>
-#endif
-
 // Returns 0 on failure (not supported by the operating system).
 u64 GetPhysicalMemory()
 {
@@ -73,77 +69,11 @@ std::string GetOSVersionString()
 #endif
 }

-#ifdef DBUS_API
-
-bool ChangeScreenSaverStateDBus(const bool inhibit_requested, const char* program_name, const char* reason)
-{
-	static dbus_uint32_t s_cookie;
-	// "error_dbus" doesn't need to be cleared in the end with "dbus_message_unref" at least if there is
-	// no error set, since calling "dbus_error_free" reinitializes it like "dbus_error_init" after freeing.
-	DBusError error_dbus;
-	dbus_error_init(&error_dbus);
-	DBusConnection* connection = nullptr;
-	DBusMessage* message = nullptr;
-	DBusMessage* response = nullptr;
-	// Initialized here because initializations should be before "goto" statements.
-	const char* bus_method = (inhibit_requested) ? "Inhibit" : "UnInhibit";
-	// "dbus_bus_get" gets a pointer to the same connection in libdbus, if exists, without creating a new connection.
-	// this doesn't need to be deleted, except if there's an error then calling "dbus_connection_unref", to free it,
-	// might be better so a new connection is established on the next try.
-	if (!(connection = dbus_bus_get(DBUS_BUS_SESSION, &error_dbus)) || (dbus_error_is_set(&error_dbus)))
-		goto cleanup;
-	if (!(message = dbus_message_new_method_call("org.freedesktop.ScreenSaver", "/org/freedesktop/ScreenSaver", "org.freedesktop.ScreenSaver", bus_method)))
-		goto cleanup;
-	// Initialize an append iterator for the message, gets freed with the message.
-	DBusMessageIter message_itr;
-	dbus_message_iter_init_append(message, &message_itr);
-	if (inhibit_requested)
-	{
-		// Append process/window name.
-		if (!dbus_message_iter_append_basic(&message_itr, DBUS_TYPE_STRING, &program_name))
-			goto cleanup;
-		// Append reason for inhibiting the screensaver.
-		if (!dbus_message_iter_append_basic(&message_itr, DBUS_TYPE_STRING, &reason))
-			goto cleanup;
-	}
-	else
-	{
-		// Only Append the cookie.
-		if (!dbus_message_iter_append_basic(&message_itr, DBUS_TYPE_UINT32, &s_cookie))
-			goto cleanup;
-	}
-	// Send message and get response.
-	if (!(response = dbus_connection_send_with_reply_and_block(connection, message, DBUS_TIMEOUT_USE_DEFAULT, &error_dbus)) 
-		|| dbus_error_is_set(&error_dbus))
-		goto cleanup;
-	if (inhibit_requested)
-	{
-		// Get the cookie from the response message.
-		if (!dbus_message_get_args(response, &error_dbus, DBUS_TYPE_UINT32, &s_cookie, DBUS_TYPE_INVALID))
-			goto cleanup;
-	}
-	dbus_message_unref(message);
-	dbus_message_unref(response);
-	return true;
-cleanup:
-	if (dbus_error_is_set(&error_dbus))
-		dbus_error_free(&error_dbus);
-	if (connection)
-		dbus_connection_unref(connection);
-	if (message)
-		dbus_message_unref(message);
-	if (response)
-		dbus_message_unref(response);
-	return false;
-}
-
-#endif
-
-#if !defined(DBUS_API) && defined(X11_API)
+#ifdef X11_API

 static bool SetScreensaverInhibitX11(const WindowInfo& wi, bool inhibit)
 {
-	extern char** environ;
+	extern char **environ;

 	const char* command = "xdg-screensaver";
 	const char* operation = inhibit ? "suspend" : "resume";
@@ -158,6 +88,8 @@ static bool SetScreensaverInhibitX11(const WindowInfo& wi, bool inhibit)
 	return (res == 0);
 }

+#endif
+
 static bool SetScreensaverInhibit(const WindowInfo& wi, bool inhibit)
 {
 	switch (wi.type)
@@ -174,18 +106,8 @@ static bool SetScreensaverInhibit(const WindowInfo& wi, bool inhibit)

 static std::optional<WindowInfo> s_inhibit_window_info;

-#endif
-
 bool WindowInfo::InhibitScreensaver(const WindowInfo& wi, bool inhibit)
 {
-
-#ifdef DBUS_API
-
-	return ChangeScreenSaverStateDBus(inhibit, "PCSX2", "PCSX2 VM is running.");
-
-#else
-
-	//ChangeScreenSaverStateDBus
 	if (s_inhibit_window_info.has_value())
 	{
 		// Bit of extra logic here, because wx spams it and we don't want to
@@ -210,9 +132,6 @@ bool WindowInfo::InhibitScreensaver(const WindowInfo& wi, bool inhibit)

 	s_inhibit_window_info = wi;
 	return true;
-
-#endif
-
 }

 bool Common::PlaySoundAsync(const char* path)
--- a/common/Perf.cpp
+++ b/common/Perf.cpp
@@ -15,207 +15,197 @@

 #include "common/Perf.h"
 #include "common/Pcsx2Defs.h"
-#include "common/Assertions.h"
-#include "common/StringUtil.h"
-
+#ifdef __unix__
+#include <unistd.h>
+#endif
 #ifdef ENABLE_VTUNE
 #include "jitprofiling.h"
-#endif

-#include <array>
-#include <cstring>
-
-#ifdef __linux__
-#include <atomic>
-#include <ctime>
-#include <mutex>
-#include <elf.h>
-#include <unistd.h>
-#include <sys/mman.h>
-#include <sys/syscall.h>
+#include <string> // std::string
+#include <cstring> // strncpy
+#include <algorithm> // std::remove_if
 #endif

 //#define ProfileWithPerf
-//#define ProfileWithPerfJitDump
+#define MERGE_BLOCK_RESULT

-#if defined(ENABLE_VTUNE) && defined(_WIN32)
+#ifdef ENABLE_VTUNE
+#ifdef _WIN32
 #pragma comment(lib, "jitprofiling.lib")
 #endif
+#endif

 namespace Perf
 {
-	Group any("");
-	Group ee("EE");
-	Group iop("IOP");
-	Group vu0("VU0");
-	Group vu1("VU1");
-	Group vif("VIF");
+	// Warning object aren't thread safe
+	InfoVector any("");
+	InfoVector ee("EE");
+	InfoVector iop("IOP");
+	InfoVector vu("VU");
+	InfoVector vif("VIF");

 // Perf is only supported on linux
-#if defined(__linux__) && defined(ProfileWithPerf)
-	static std::FILE* s_map_file = nullptr;
-	static bool s_map_file_opened = false;
-	static std::mutex s_mutex;
-	static void RegisterMethod(const void* ptr, size_t size, const char* symbol)
-	{
-		std::unique_lock lock(s_mutex);
+#if defined(__linux__) && (defined(ProfileWithPerf) || defined(ENABLE_VTUNE))

-		if (!s_map_file)
-		{
-			if (s_map_file_opened)
-				return;
+	////////////////////////////////////////////////////////////////////////////////
+	// Implementation of the Info object
+	////////////////////////////////////////////////////////////////////////////////

-			char file[256];
-			snprintf(file, std::size(file), "/tmp/perf-%d.map", getpid());
-			s_map_file = std::fopen(file, "wb");
-			s_map_file_opened = true;
-			if (!s_map_file)
-				return;
-		}
-
-		std::fprintf(s_map_file, "%" PRIx64 " %zx %s\n", static_cast<u64>(reinterpret_cast<uintptr_t>(ptr)), size, symbol);
-		std::fflush(s_map_file);
-	}
-#elif defined(__linux__) && defined(ProfileWithPerfJitDump)
-	enum : u32
+	Info::Info(uptr x86, u32 size, const char* symbol)
+		: m_x86(x86)
+		, m_size(size)
+		, m_dynamic(false)
 	{
-		JIT_CODE_LOAD = 0,
-		JIT_CODE_MOVE = 1,
-		JIT_CODE_DEBUG_INFO = 2,
-		JIT_CODE_CLOSE = 3,
-		JIT_CODE_UNWINDING_INFO = 4
-	};
-
-#pragma pack(push, 1)
-	struct JITDUMP_HEADER
-	{
-		u32 magic = 0x4A695444; // JiTD
-		u32 version = 1;
-		u32 header_size = sizeof(JITDUMP_HEADER);
-		u32 elf_mach;
-		u32 pad1 = 0;
-		u32 pid;
-		u64 timestamp;
-		u64 flags = 0;
-	};
-	struct JITDUMP_RECORD_HEADER
-	{
-		u32 id;
-		u32 total_size;
-		u64 timestamp;
-	};
-	struct JITDUMP_CODE_LOAD
-	{
-		JITDUMP_RECORD_HEADER header;
-		u32 pid;
-		u32 tid;
-		u64 vma;
-		u64 code_addr;
-		u64 code_size;
-		u64 code_index;
-		// name
-	};
-#pragma pack(pop)
-
-	static u64 JitDumpTimestamp()
-	{
-		struct timespec ts = {};
-		clock_gettime(CLOCK_MONOTONIC, &ts);
-		return (static_cast<u64>(ts.tv_sec) * 1000000000ULL) + static_cast<u64>(ts.tv_nsec);
+		strncpy(m_symbol, symbol, sizeof(m_symbol));
 	}

-	static FILE* s_jitdump_file = nullptr;
-	static bool s_jitdump_file_opened = false;
-	static std::mutex s_jitdump_mutex;
-	static u32 s_jitdump_record_id;
-
-	static void RegisterMethod(const void* ptr, size_t size, const char* symbol)
+	Info::Info(uptr x86, u32 size, const char* symbol, u32 pc)
+		: m_x86(x86)
+		, m_size(size)
+		, m_dynamic(true)
 	{
-		const u32 namelen = std::strlen(symbol) + 1;
-
-		std::unique_lock lock(s_jitdump_mutex);
-		if (!s_jitdump_file)
-		{
-			if (!s_jitdump_file_opened)
-			{
-				char file[256];
-				snprintf(file, std::size(file), "jit-%d.dump", getpid());
-				s_jitdump_file = fopen(file, "w+b");
-				s_jitdump_file_opened = true;
-				if (!s_jitdump_file)
-					return;
-			}
-
-			void* perf_marker = mmap(nullptr, 4096, PROT_READ | PROT_EXEC, MAP_PRIVATE, fileno(s_jitdump_file), 0);
-			pxAssertRel(perf_marker != MAP_FAILED, "Map perf marker");
-
-			JITDUMP_HEADER jh = {};
-			jh.elf_mach = EM_X86_64;
-			jh.pid = getpid();
-			jh.timestamp = JitDumpTimestamp();
-			std::fwrite(&jh, sizeof(jh), 1, s_jitdump_file);
-		}
-
-		JITDUMP_CODE_LOAD cl = {};
-		cl.header.id = JIT_CODE_LOAD;
-		cl.header.total_size = sizeof(cl) + namelen + static_cast<u32>(size);
-		cl.header.timestamp = JitDumpTimestamp();
-		cl.pid = getpid();
-		cl.tid = syscall(SYS_gettid);
-		cl.vma = 0;
-		cl.code_addr = static_cast<u64>(reinterpret_cast<uintptr_t>(ptr));
-		cl.code_size = static_cast<u64>(size);
-		cl.code_index = s_jitdump_record_id++;
-		std::fwrite(&cl, sizeof(cl), 1, s_jitdump_file);
-		std::fwrite(symbol, namelen, 1, s_jitdump_file);
-		std::fwrite(ptr, size, 1, s_jitdump_file);
-		std::fflush(s_jitdump_file);
+		snprintf(m_symbol, sizeof(m_symbol), "%s_0x%08x", symbol, pc);
 	}
-#elif defined(ENABLE_VTUNE)
-	static void RegisterMethod(const void* ptr, size_t size, const char* symbol)
+
+	void Info::Print(FILE* fp)
 	{
-		iJIT_Method_Load_V2 ml = {};
-		ml.method_id = iJIT_GetNewMethodID();
-		ml.method_name = const_cast<char*>(symbol);
-		ml.method_load_address = const_cast<void*>(ptr);
-		ml.method_size = static_cast<unsigned int>(size);
-		iJIT_NotifyEvent(iJVM_EVENT_TYPE_METHOD_LOAD_FINISHED_V2, &ml);
+		fprintf(fp, "%x %x %s\n", m_x86, m_size, m_symbol);
 	}
+
+	////////////////////////////////////////////////////////////////////////////////
+	// Implementation of the InfoVector object
+	////////////////////////////////////////////////////////////////////////////////
+
+	InfoVector::InfoVector(const char* prefix)
+	{
+		strncpy(m_prefix, prefix, sizeof(m_prefix));
+#ifdef ENABLE_VTUNE
+		m_vtune_id = iJIT_GetNewMethodID();
+#else
+		m_vtune_id = 0;
+#endif
+	}
+
+	void InfoVector::print(FILE* fp)
+	{
+		for (auto&& it : m_v)
+			it.Print(fp);
+	}
+
+	void InfoVector::map(uptr x86, u32 size, const char* symbol)
+	{
+// This function is typically used for dispatcher and recompiler.
+// Dispatchers are on a page and must always be kept.
+// Recompilers are much bigger (TODO check VIF) and are only
+// useful when MERGE_BLOCK_RESULT is defined
+#if defined(ENABLE_VTUNE) || !defined(MERGE_BLOCK_RESULT)
+		u32 max_code_size = 16 * _1kb;
+#else
+		u32 max_code_size = _1gb;
 #endif

-#if (defined(__linux__) && (defined(ProfileWithPerf) || defined(ProfileWithPerfJitDump))) || defined(ENABLE_VTUNE)
-	void Group::Register(const void* ptr, size_t size, const char* symbol)
-	{
-		char full_symbol[128];
-		if (HasPrefix())
-			std::snprintf(full_symbol, std::size(full_symbol), "%s_%s", m_prefix, symbol);
-		else
-			StringUtil::Strlcpy(full_symbol, symbol, std::size(full_symbol));
-		RegisterMethod(ptr, size, full_symbol);
+		if (size < max_code_size)
+		{
+			m_v.emplace_back(x86, size, symbol);
+
+#ifdef ENABLE_VTUNE
+			std::string name = std::string(symbol);
+
+			iJIT_Method_Load ml;
+
+			memset(&ml, 0, sizeof(ml));
+
+			ml.method_id = iJIT_GetNewMethodID();
+			ml.method_name = (char*)name.c_str();
+			ml.method_load_address = (void*)x86;
+			ml.method_size = size;
+
+			iJIT_NotifyEvent(iJVM_EVENT_TYPE_METHOD_LOAD_FINISHED, &ml);
+
+//fprintf(stderr, "mapF %s: %p size %dKB\n", ml.method_name, ml.method_load_address, ml.method_size / 1024u);
+#endif
+		}
 	}

-	void Group::RegisterPC(const void* ptr, size_t size, u32 pc)
+	void InfoVector::map(uptr x86, u32 size, u32 pc)
 	{
-		char full_symbol[128];
-		if (HasPrefix())
-			std::snprintf(full_symbol, std::size(full_symbol), "%s_%08X", m_prefix, pc);
-		else
-			std::snprintf(full_symbol, std::size(full_symbol), "%08X", pc);
-		RegisterMethod(ptr, size, full_symbol);
-	}
+#ifndef MERGE_BLOCK_RESULT
+		m_v.emplace_back(x86, size, m_prefix, pc);
+#endif

-	void Group::RegisterKey(const void* ptr, size_t size, const char* prefix, u64 key)
-	{
-		char full_symbol[128];
-		if (HasPrefix())
-			std::snprintf(full_symbol, std::size(full_symbol), "%s_%s%016" PRIX64, m_prefix, prefix, key);
-		else
-			std::snprintf(full_symbol, std::size(full_symbol), "%s%016" PRIX64, prefix, key);
-		RegisterMethod(ptr, size, full_symbol);
-	}
+#ifdef ENABLE_VTUNE
+		iJIT_Method_Load_V2 ml;
+
+		memset(&ml, 0, sizeof(ml));
+
+#ifdef MERGE_BLOCK_RESULT
+		ml.method_id = m_vtune_id;
+		ml.method_name = m_prefix;
 #else
-	void Group::Register(const void* ptr, size_t size, const char* symbol) {}
-	void Group::RegisterPC(const void* ptr, size_t size, u32 pc) {}
-	void Group::RegisterKey(const void* ptr, size_t size, const char* prefix, u64 key) {}
+		std::string name = std::string(m_prefix) + "_" + std::to_string(pc);
+		ml.method_id = iJIT_GetNewMethodID();
+		ml.method_name = (char*)name.c_str();
+#endif
+		ml.method_load_address = (void*)x86;
+		ml.method_size = size;
+
+		iJIT_NotifyEvent(iJVM_EVENT_TYPE_METHOD_LOAD_FINISHED_V2, &ml);
+
+//fprintf(stderr, "mapB %s: %p size %d\n", ml.method_name, ml.method_load_address, ml.method_size);
+#endif
+	}
+
+	void InfoVector::reset()
+	{
+		auto dynamic = std::remove_if(m_v.begin(), m_v.end(), [](Info i) { return i.m_dynamic; });
+		m_v.erase(dynamic, m_v.end());
+	}
+
+	////////////////////////////////////////////////////////////////////////////////
+	// Global function
+	////////////////////////////////////////////////////////////////////////////////
+
+	void dump()
+	{
+		char file[256];
+		snprintf(file, 250, "/tmp/perf-%d.map", getpid());
+		FILE* fp = fopen(file, "w");
+
+		any.print(fp);
+		ee.print(fp);
+		iop.print(fp);
+		vu.print(fp);
+
+		if (fp)
+			fclose(fp);
+	}
+
+	void dump_and_reset()
+	{
+		dump();
+
+		any.reset();
+		ee.reset();
+		iop.reset();
+		vu.reset();
+	}
+
+#else
+
+	////////////////////////////////////////////////////////////////////////////////
+	// Dummy implementation
+	////////////////////////////////////////////////////////////////////////////////
+
+	InfoVector::InfoVector(const char* prefix)
+		: m_vtune_id(0)
+	{
+	}
+	void InfoVector::map(uptr x86, u32 size, const char* symbol) {}
+	void InfoVector::map(uptr x86, u32 size, u32 pc) {}
+	void InfoVector::reset() {}
+
+	void dump() {}
+	void dump_and_reset() {}
+
 #endif
 } // namespace Perf
--- a/common/Perf.h
+++ b/common/Perf.h
@@ -21,23 +21,42 @@

 namespace Perf
 {
-	class Group
+
+	struct Info
 	{
-		const char* m_prefix;
+		uptr m_x86;
+		u32 m_size;
+		char m_symbol[20];
+		// The idea is to keep static zones that are set only
+		// once.
+		bool m_dynamic;

-	public:
-		constexpr Group(const char* prefix) : m_prefix(prefix) {}
-		bool HasPrefix() const { return (m_prefix && m_prefix[0]); }
-
-		void Register(const void* ptr, size_t size, const char* symbol);
-		void RegisterPC(const void* ptr, size_t size, u32 pc);
-		void RegisterKey(const void* ptr, size_t size, const char* prefix, u64 key);
+		Info(uptr x86, u32 size, const char* symbol);
+		Info(uptr x86, u32 size, const char* symbol, u32 pc);
+		void Print(FILE* fp);
 	};

-	extern Group any;
-	extern Group ee;
-	extern Group iop;
-	extern Group vu0;
-	extern Group vu1;
-	extern Group vif;
+	class InfoVector
+	{
+		std::vector<Info> m_v;
+		char m_prefix[20];
+		unsigned int m_vtune_id;
+
+	public:
+		InfoVector(const char* prefix);
+
+		void print(FILE* fp);
+		void map(uptr x86, u32 size, const char* symbol);
+		void map(uptr x86, u32 size, u32 pc);
+		void reset();
+	};
+
+	void dump();
+	void dump_and_reset();
+
+	extern InfoVector any;
+	extern InfoVector ee;
+	extern InfoVector iop;
+	extern InfoVector vu;
+	extern InfoVector vif;
 } // namespace Perf
--- a/common/SafeArray.h
+++ b/common/SafeArray.h
@@ -97,3 +97,114 @@ public:

 	virtual SafeArray<T>* Clone() const;
 };
+
+//////////////////////////////////////////////////////////////////////////////////////////
+// SafeList - Simple growable container without all the mess or hassle of std containers.
+//
+// This container is intended for reasonably simple class types only.  Things which this
+// container does not handle with desired robustness:
+//
+//  * Classes with non-trivial constructors (such that construction creates much overhead)
+//  * Classes with copy constructors (copying is done using performance memcpy)
+//  * Classes with destructors (they're not called, sorry!)
+//
+template <typename T>
+class SafeList
+{
+	DeclareNoncopyableObject(SafeList);
+
+public:
+	static const int DefaultChunkSize = 0x80 * sizeof(T);
+
+public:
+	std::string Name; // user-assigned block name
+	int ChunkSize; // assigned DefaultChunkSize on init, reconfigurable at any time.
+
+protected:
+	T* m_ptr;
+	int m_allocsize; // size of the allocation of memory
+	uint m_length; // length of the array (active items, not buffer allocation)
+
+protected:
+	virtual T* _virtual_realloc(int newsize);
+	void _MakeRoomFor_threshold(int newsize);
+
+	T* _getPtr(uint i) const;
+
+public:
+	virtual ~SafeList();
+	explicit SafeList(const char* name = "Unnamed");
+	explicit SafeList(int initialSize, const char* name = "Unnamed");
+	virtual SafeList<T>* Clone() const;
+
+	void Remove(int index);
+	void MakeRoomFor(int blockSize);
+
+	T& New();
+	int Add(const T& src);
+	T& AddNew(const T& src);
+
+	// Returns the size of the list, as according to the array type.  This includes
+	// mapped items only.  The actual size of the allocation may differ.
+	int GetLength() const { return m_length; }
+
+	// Returns the size of the list, in bytes.  This includes mapped items only.
+	// The actual size of the allocation may differ.
+	int GetSizeInBytes() const { return m_length * sizeof(T); }
+
+	void MatchLengthToAllocatedSize()
+	{
+		m_length = m_allocsize;
+	}
+
+	void GrowBy(int items)
+	{
+		MakeRoomFor(m_length + ChunkSize + items + 1);
+	}
+
+	// Sets the item length to zero.  Does not free memory allocations.
+	void Clear()
+	{
+		m_length = 0;
+	}
+
+	// Gets an element of this memory allocation much as if it were an array.
+	// DevBuilds : Generates assertion if the index is invalid.
+	T& operator[](int idx) { return *_getPtr((uint)idx); }
+	const T& operator[](int idx) const { return *_getPtr((uint)idx); }
+
+	T* GetPtr() { return m_ptr; }
+	const T* GetPtr() const { return m_ptr; }
+
+	T& GetLast() { return m_ptr[m_length - 1]; }
+	const T& GetLast() const { return m_ptr[m_length - 1]; }
+};
+
+// --------------------------------------------------------------------------------------
+//  SafeAlignedArray<T>
+// --------------------------------------------------------------------------------------
+// Handy little class for allocating a resizable memory block, complete with
+// exception-based error handling and automatic cleanup.
+// This one supports aligned data allocations too!
+
+template <typename T, uint Alignment>
+class SafeAlignedArray : public SafeArray<T>
+{
+	typedef SafeArray<T> _parent;
+
+protected:
+	T* _virtual_realloc(int newsize);
+
+public:
+	using _parent::operator[];
+
+	virtual ~SafeAlignedArray();
+
+	explicit SafeAlignedArray(std::string name = "Unnamed")
+		: SafeArray<T>::SafeArray(name)
+	{
+	}
+
+	explicit SafeAlignedArray(int initialSize, std::string name = "Unnamed");
+	virtual SafeAlignedArray<T, Alignment>* Clone() const;
+};
--- a/common/SafeArray.inl
+++ b/common/SafeArray.inl
@@ -15,9 +15,13 @@

 #pragma once

+#include "common/AlignedMalloc.h"
 #include "common/Assertions.h"
+#include "common/Exceptions.h"
 #include "common/SafeArray.h"

+#include "fmt/core.h"
+
 // Internal constructor for use by derived classes.  This allows a derived class to
 // use its own memory allocation (with an aligned memory, for example).
 // Throws:
@@ -119,3 +123,165 @@ SafeArray<T>* SafeArray<T>::Clone() const
 	memcpy(retval->GetPtr(), m_ptr, sizeof(T) * m_size);
 	return retval;
 }
+
+
+// --------------------------------------------------------------------------------------
+//  SafeAlignedArray<T>  (implementations)
+// --------------------------------------------------------------------------------------
+
+template <typename T, uint Alignment>
+T* SafeAlignedArray<T, Alignment>::_virtual_realloc(int newsize)
+{
+	return (T*)((this->m_ptr == NULL) ?
+                    _aligned_malloc(newsize * sizeof(T), Alignment) :
+                    pcsx2_aligned_realloc(this->m_ptr, newsize * sizeof(T), Alignment, this->m_size * sizeof(T)));
+}
+
+// Appends "(align: xx)" to the name of the allocation in devel builds.
+// Maybe useful,maybe not... no harm in attaching it. :D
+
+template <typename T, uint Alignment>
+SafeAlignedArray<T, Alignment>::~SafeAlignedArray()
+{
+	safe_aligned_free(this->m_ptr);
+	// mptr is set to null, so the parent class's destructor won't re-free it.
+}
+
+template <typename T, uint Alignment>
+SafeAlignedArray<T, Alignment>::SafeAlignedArray(int initialSize, std::string name)
+	: SafeArray<T>::SafeArray(
+		  std::move(name),
+		  (T*)_aligned_malloc(initialSize * sizeof(T), Alignment),
+		  initialSize)
+{
+}
+
+template <typename T, uint Alignment>
+SafeAlignedArray<T, Alignment>* SafeAlignedArray<T, Alignment>::Clone() const
+{
+	SafeAlignedArray<T, Alignment>* retval = new SafeAlignedArray<T, Alignment>(this->m_size);
+	memcpy(retval->GetPtr(), this->m_ptr, sizeof(T) * this->m_size);
+	return retval;
+}
+
+// --------------------------------------------------------------------------------------
+//  SafeList<T>  (implementations)
+// --------------------------------------------------------------------------------------
+
+template <typename T>
+T* SafeList<T>::_virtual_realloc(int newsize)
+{
+	return (T*)realloc(m_ptr, newsize * sizeof(T));
+}
+
+template <typename T>
+SafeList<T>::~SafeList()
+{
+	safe_free(m_ptr);
+}
+
+template <typename T>
+SafeList<T>::SafeList(const char* name)
+	: Name(name)
+{
+	ChunkSize = DefaultChunkSize;
+	m_ptr = NULL;
+	m_allocsize = 0;
+	m_length = 0;
+}
+
+template <typename T>
+SafeList<T>::SafeList(int initialSize, const char* name)
+	: Name(name)
+{
+	ChunkSize = DefaultChunkSize;
+	m_allocsize = initialSize;
+	m_length = 0;
+	m_ptr = (T*)malloc(initialSize * sizeof(T));
+
+	if (m_ptr == NULL)
+		pxFailRel("SafeList exact alloc failed");
+
+	for (int i = 0; i < m_allocsize; ++i)
+	{
+		new (&m_ptr[i]) T();
+	}
+}
+
+template <typename T>
+T* SafeList<T>::_getPtr(uint i) const
+{
+	pxAssumeDev(i < m_length, "Index in bounds");
+	return &m_ptr[i];
+}
+
+// Ensures that the allocation is large enough to fit data of the
+// amount requested.  The memory allocation is not resized smaller.
+template <typename T>
+void SafeList<T>::MakeRoomFor(int blockSize)
+{
+	if (blockSize > m_allocsize)
+	{
+		const int newalloc = blockSize + ChunkSize;
+		m_ptr = _virtual_realloc(newalloc);
+		if (m_ptr == NULL)
+			pxFailRel("SafeList MakeRoomFor failed");
+
+		for (; m_allocsize < newalloc; ++m_allocsize)
+		{
+			new (&m_ptr[m_allocsize]) T();
+		}
+	}
+}
+
+// Appends an item to the end of the list and returns a handle to it.
+template <typename T>
+T& SafeList<T>::New()
+{
+	_MakeRoomFor_threshold(m_length + 1);
+	return m_ptr[m_length++];
+}
+
+template <typename T>
+int SafeList<T>::Add(const T& src)
+{
+	_MakeRoomFor_threshold(m_length + 1);
+	m_ptr[m_length] = src;
+	return m_length++;
+}
+
+// Same as Add, but returns the handle of the new object instead of it's array index.
+template <typename T>
+T& SafeList<T>::AddNew(const T& src)
+{
+	_MakeRoomFor_threshold(m_length + 1);
+	m_ptr[m_length] = src;
+	return m_ptr[m_length];
+}
+
+// Performs a standard array-copy removal of the given item.  All items past the
+// given item are copied over.
+// DevBuilds : Generates assertion if the index is invalid.
+template <typename T>
+void SafeList<T>::Remove(int index)
+{
+	pxAssert(index < m_length);
+
+	int copylen = m_length - index;
+	if (copylen > 0)
+		memcpy(&m_ptr[index], &m_ptr[index + 1], copylen);
+}
+
+template <typename T>
+SafeList<T>* SafeList<T>::Clone() const
+{
+	SafeList<T>* retval = new SafeList<T>(m_length);
+	memcpy(retval->m_ptr, m_ptr, sizeof(T) * m_length);
+	return retval;
+}
+
+template <typename T>
+void SafeList<T>::_MakeRoomFor_threshold(int newsize)
+{
+	MakeRoomFor(newsize + ChunkSize);
+}
--- a/common/StringUtil.h
+++ b/common/StringUtil.h
@@ -100,7 +100,10 @@ namespace StringUtil
 			return std::nullopt;

 		if (endptr)
-			*endptr = (result.ptr < end) ? std::string_view(result.ptr, end - result.ptr) : std::string_view();
+		{
+			const size_t remaining_len = end - ptr - 1;
+			*endptr = (remaining_len > 0) ? std::string_view(result.ptr, remaining_len) : std::string_view();
+		}

 		return value;
 	}
@@ -128,7 +131,10 @@ namespace StringUtil
 			return std::nullopt;

 		if (endptr)
-			*endptr = (result.ptr < end) ? std::string_view(result.ptr, end - result.ptr) : std::string_view();
+		{
+			const size_t remaining_len = end - ptr - 1;
+			*endptr = (remaining_len > 0) ? std::string_view(result.ptr, remaining_len) : std::string_view();
+		}

 		return value;
 	}
--- a/common/Vulkan/Builders.cpp
+++ b/common/Vulkan/Builders.cpp
@@ -0,0 +1,957 @@
+/*  PCSX2 - PS2 Emulator for PCs
+ *  Copyright (C) 2002-2021  PCSX2 Dev Team
+ *
+ *  PCSX2 is free software: you can redistribute it and/or modify it under the terms
+ *  of the GNU Lesser General Public License as published by the Free Software Found-
+ *  ation, either version 3 of the License, or (at your option) any later version.
+ *
+ *  PCSX2 is distributed in the hope that it will be useful, but WITHOUT ANY WARRANTY;
+ *  without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR
+ *  PURPOSE.  See the GNU General Public License for more details.
+ *
+ *  You should have received a copy of the GNU General Public License along with PCSX2.
+ *  If not, see <http://www.gnu.org/licenses/>.
+ */
+
+#include "common/Vulkan/Builders.h"
+#include "common/Vulkan/Util.h"
+#include "common/Assertions.h"
+#include <limits>
+
+namespace Vulkan
+{
+	DescriptorSetLayoutBuilder::DescriptorSetLayoutBuilder() { Clear(); }
+
+	void DescriptorSetLayoutBuilder::Clear()
+	{
+		m_ci.sType = VK_STRUCTURE_TYPE_DESCRIPTOR_SET_LAYOUT_CREATE_INFO;
+		m_ci.pNext = nullptr;
+		m_ci.flags = 0;
+		m_ci.pBindings = nullptr;
+		m_ci.bindingCount = 0;
+	}
+
+	VkDescriptorSetLayout DescriptorSetLayoutBuilder::Create(VkDevice device)
+	{
+		VkDescriptorSetLayout layout;
+		VkResult res = vkCreateDescriptorSetLayout(device, &m_ci, nullptr, &layout);
+		if (res != VK_SUCCESS)
+		{
+			LOG_VULKAN_ERROR(res, "vkCreateDescriptorSetLayout() failed: ");
+			return VK_NULL_HANDLE;
+		}
+
+		Clear();
+		return layout;
+	}
+
+	void DescriptorSetLayoutBuilder::AddBinding(
+		u32 binding, VkDescriptorType dtype, u32 dcount, VkShaderStageFlags stages)
+	{
+		pxAssert(m_ci.bindingCount < MAX_BINDINGS);
+
+		VkDescriptorSetLayoutBinding& b = m_bindings[m_ci.bindingCount];
+		b.binding = binding;
+		b.descriptorType = dtype;
+		b.descriptorCount = dcount;
+		b.stageFlags = stages;
+		b.pImmutableSamplers = nullptr;
+
+		m_ci.pBindings = m_bindings.data();
+		m_ci.bindingCount++;
+	}
+
+	PipelineLayoutBuilder::PipelineLayoutBuilder() { Clear(); }
+
+	void PipelineLayoutBuilder::Clear()
+	{
+		m_ci.sType = VK_STRUCTURE_TYPE_PIPELINE_LAYOUT_CREATE_INFO;
+		m_ci.pNext = nullptr;
+		m_ci.flags = 0;
+		m_ci.pSetLayouts = nullptr;
+		m_ci.setLayoutCount = 0;
+		m_ci.pPushConstantRanges = nullptr;
+		m_ci.pushConstantRangeCount = 0;
+	}
+
+	VkPipelineLayout PipelineLayoutBuilder::Create(VkDevice device)
+	{
+		VkPipelineLayout layout;
+		VkResult res = vkCreatePipelineLayout(device, &m_ci, nullptr, &layout);
+		if (res != VK_SUCCESS)
+		{
+			LOG_VULKAN_ERROR(res, "vkCreatePipelineLayout() failed: ");
+			return VK_NULL_HANDLE;
+		}
+
+		Clear();
+		return layout;
+	}
+
+	void PipelineLayoutBuilder::AddDescriptorSet(VkDescriptorSetLayout layout)
+	{
+		pxAssert(m_ci.setLayoutCount < MAX_SETS);
+
+		m_sets[m_ci.setLayoutCount] = layout;
+
+		m_ci.setLayoutCount++;
+		m_ci.pSetLayouts = m_sets.data();
+	}
+
+	void PipelineLayoutBuilder::AddPushConstants(VkShaderStageFlags stages, u32 offset, u32 size)
+	{
+		pxAssert(m_ci.pushConstantRangeCount < MAX_PUSH_CONSTANTS);
+
+		VkPushConstantRange& r = m_push_constants[m_ci.pushConstantRangeCount];
+		r.stageFlags = stages;
+		r.offset = offset;
+		r.size = size;
+
+		m_ci.pushConstantRangeCount++;
+		m_ci.pPushConstantRanges = m_push_constants.data();
+	}
+
+	GraphicsPipelineBuilder::GraphicsPipelineBuilder() { Clear(); }
+
+	void GraphicsPipelineBuilder::Clear()
+	{
+		m_ci = {};
+		m_ci.sType = VK_STRUCTURE_TYPE_GRAPHICS_PIPELINE_CREATE_INFO;
+
+		m_shader_stages = {};
+
+		m_vertex_input_state = {};
+		m_vertex_input_state.sType = VK_STRUCTURE_TYPE_PIPELINE_VERTEX_INPUT_STATE_CREATE_INFO;
+		m_ci.pVertexInputState = &m_vertex_input_state;
+		m_vertex_attributes = {};
+		m_vertex_buffers = {};
+
+		m_input_assembly = {};
+		m_input_assembly.sType = VK_STRUCTURE_TYPE_PIPELINE_INPUT_ASSEMBLY_STATE_CREATE_INFO;
+
+		m_rasterization_state = {};
+		m_rasterization_state.sType = VK_STRUCTURE_TYPE_PIPELINE_RASTERIZATION_STATE_CREATE_INFO;
+		m_rasterization_state.lineWidth = 1.0f;
+		m_depth_state = {};
+		m_depth_state.sType = VK_STRUCTURE_TYPE_PIPELINE_DEPTH_STENCIL_STATE_CREATE_INFO;
+		m_blend_state = {};
+		m_blend_state.sType = VK_STRUCTURE_TYPE_PIPELINE_COLOR_BLEND_STATE_CREATE_INFO;
+		m_blend_attachments = {};
+
+		m_viewport_state = {};
+		m_viewport_state.sType = VK_STRUCTURE_TYPE_PIPELINE_VIEWPORT_STATE_CREATE_INFO;
+		m_viewport = {};
+		m_scissor = {};
+
+		m_dynamic_state = {};
+		m_dynamic_state.sType = VK_STRUCTURE_TYPE_PIPELINE_DYNAMIC_STATE_CREATE_INFO;
+		m_dynamic_state_values = {};
+
+		m_multisample_state = {};
+		m_multisample_state.sType = VK_STRUCTURE_TYPE_PIPELINE_MULTISAMPLE_STATE_CREATE_INFO;
+
+		m_provoking_vertex = {};
+		m_provoking_vertex.sType = VK_STRUCTURE_TYPE_PIPELINE_RASTERIZATION_PROVOKING_VERTEX_STATE_CREATE_INFO_EXT;
+
+		m_line_rasterization_state = {};
+		m_line_rasterization_state.sType = VK_STRUCTURE_TYPE_PIPELINE_RASTERIZATION_LINE_STATE_CREATE_INFO_EXT;
+
+		// set defaults
+		SetNoCullRasterizationState();
+		SetNoDepthTestState();
+		SetNoBlendingState();
+		SetPrimitiveTopology(VK_PRIMITIVE_TOPOLOGY_TRIANGLE_LIST);
+
+		// have to be specified even if dynamic
+		SetViewport(0.0f, 0.0f, 1.0f, 1.0f, 0.0f, 1.0f);
+		SetScissorRect(0, 0, 1, 1);
+		SetMultisamples(VK_SAMPLE_COUNT_1_BIT);
+	}
+
+	VkPipeline GraphicsPipelineBuilder::Create(VkDevice device, VkPipelineCache pipeline_cache, bool clear /* = true */)
+	{
+		VkPipeline pipeline;
+		VkResult res = vkCreateGraphicsPipelines(device, pipeline_cache, 1, &m_ci, nullptr, &pipeline);
+		if (res != VK_SUCCESS)
+		{
+			LOG_VULKAN_ERROR(res, "vkCreateGraphicsPipelines() failed: ");
+			return VK_NULL_HANDLE;
+		}
+
+		if (clear)
+			Clear();
+
+		return pipeline;
+	}
+
+	void GraphicsPipelineBuilder::SetShaderStage(
+		VkShaderStageFlagBits stage, VkShaderModule module, const char* entry_point)
+	{
+		pxAssert(m_ci.stageCount < MAX_SHADER_STAGES);
+
+		u32 index = 0;
+		for (; index < m_ci.stageCount; index++)
+		{
+			if (m_shader_stages[index].stage == stage)
+				break;
+		}
+		if (index == m_ci.stageCount)
+		{
+			m_ci.stageCount++;
+			m_ci.pStages = m_shader_stages.data();
+		}
+
+		VkPipelineShaderStageCreateInfo& s = m_shader_stages[index];
+		s.sType = VK_STRUCTURE_TYPE_PIPELINE_SHADER_STAGE_CREATE_INFO;
+		s.stage = stage;
+		s.module = module;
+		s.pName = entry_point;
+	}
+
+	void GraphicsPipelineBuilder::AddVertexBuffer(
+		u32 binding, u32 stride, VkVertexInputRate input_rate /*= VK_VERTEX_INPUT_RATE_VERTEX*/)
+	{
+		pxAssert(m_vertex_input_state.vertexAttributeDescriptionCount < MAX_VERTEX_BUFFERS);
+
+		VkVertexInputBindingDescription& b = m_vertex_buffers[m_vertex_input_state.vertexBindingDescriptionCount];
+		b.binding = binding;
+		b.stride = stride;
+		b.inputRate = input_rate;
+
+		m_vertex_input_state.vertexBindingDescriptionCount++;
+		m_vertex_input_state.pVertexBindingDescriptions = m_vertex_buffers.data();
+		m_ci.pVertexInputState = &m_vertex_input_state;
+	}
+
+	void GraphicsPipelineBuilder::AddVertexAttribute(u32 location, u32 binding, VkFormat format, u32 offset)
+	{
+		pxAssert(m_vertex_input_state.vertexAttributeDescriptionCount < MAX_VERTEX_BUFFERS);
+
+		VkVertexInputAttributeDescription& a =
+			m_vertex_attributes[m_vertex_input_state.vertexAttributeDescriptionCount];
+		a.location = location;
+		a.binding = binding;
+		a.format = format;
+		a.offset = offset;
+
+		m_vertex_input_state.vertexAttributeDescriptionCount++;
+		m_vertex_input_state.pVertexAttributeDescriptions = m_vertex_attributes.data();
+		m_ci.pVertexInputState = &m_vertex_input_state;
+	}
+
+	void GraphicsPipelineBuilder::SetPrimitiveTopology(
+		VkPrimitiveTopology topology, bool enable_primitive_restart /*= false*/)
+	{
+		m_input_assembly.topology = topology;
+		m_input_assembly.primitiveRestartEnable = enable_primitive_restart;
+
+		m_ci.pInputAssemblyState = &m_input_assembly;
+	}
+
+	void GraphicsPipelineBuilder::SetRasterizationState(
+		VkPolygonMode polygon_mode, VkCullModeFlags cull_mode, VkFrontFace front_face)
+	{
+		m_rasterization_state.polygonMode = polygon_mode;
+		m_rasterization_state.cullMode = cull_mode;
+		m_rasterization_state.frontFace = front_face;
+
+		m_ci.pRasterizationState = &m_rasterization_state;
+	}
+
+	void GraphicsPipelineBuilder::SetLineWidth(float width)
+	{
+		m_rasterization_state.lineWidth = width;
+	}
+
+	void GraphicsPipelineBuilder::SetLineRasterizationMode(VkLineRasterizationModeEXT mode)
+	{
+		Util::AddPointerToChain(&m_rasterization_state, &m_line_rasterization_state);
+
+		m_line_rasterization_state.lineRasterizationMode = mode;
+	}
+
+	void GraphicsPipelineBuilder::SetMultisamples(u32 multisamples, bool per_sample_shading)
+	{
+		m_multisample_state.rasterizationSamples = static_cast<VkSampleCountFlagBits>(multisamples);
+		m_multisample_state.sampleShadingEnable = per_sample_shading;
+		m_multisample_state.minSampleShading = (multisamples > 1) ? 1.0f : 0.0f;
+	}
+
+	void GraphicsPipelineBuilder::SetNoCullRasterizationState()
+	{
+		SetRasterizationState(VK_POLYGON_MODE_FILL, VK_CULL_MODE_NONE, VK_FRONT_FACE_CLOCKWISE);
+	}
+
+	void GraphicsPipelineBuilder::SetDepthState(bool depth_test, bool depth_write, VkCompareOp compare_op)
+	{
+		m_depth_state.depthTestEnable = depth_test;
+		m_depth_state.depthWriteEnable = depth_write;
+		m_depth_state.depthCompareOp = compare_op;
+
+		m_ci.pDepthStencilState = &m_depth_state;
+	}
+
+	void GraphicsPipelineBuilder::SetStencilState(
+		bool stencil_test, const VkStencilOpState& front, const VkStencilOpState& back)
+	{
+		m_depth_state.stencilTestEnable = stencil_test;
+		m_depth_state.front = front;
+		m_depth_state.back = back;
+	}
+
+	void GraphicsPipelineBuilder::SetNoStencilState()
+	{
+		m_depth_state.stencilTestEnable = VK_FALSE;
+		m_depth_state.front = {};
+		m_depth_state.back = {};
+	}
+
+	void GraphicsPipelineBuilder::SetNoDepthTestState() { SetDepthState(false, false, VK_COMPARE_OP_ALWAYS); }
+
+	void GraphicsPipelineBuilder::SetBlendConstants(float r, float g, float b, float a)
+	{
+		m_blend_state.blendConstants[0] = r;
+		m_blend_state.blendConstants[1] = g;
+		m_blend_state.blendConstants[2] = b;
+		m_blend_state.blendConstants[3] = a;
+		m_ci.pColorBlendState = &m_blend_state;
+	}
+
+	void GraphicsPipelineBuilder::AddBlendAttachment(bool blend_enable, VkBlendFactor src_factor,
+		VkBlendFactor dst_factor, VkBlendOp op, VkBlendFactor alpha_src_factor, VkBlendFactor alpha_dst_factor,
+		VkBlendOp alpha_op,
+		VkColorComponentFlags
+			write_mask /* = VK_COLOR_COMPONENT_R_BIT | VK_COLOR_COMPONENT_G_BIT | VK_COLOR_COMPONENT_B_BIT | VK_COLOR_COMPONENT_A_BIT */)
+	{
+		pxAssert(m_blend_state.attachmentCount < MAX_ATTACHMENTS);
+
+		VkPipelineColorBlendAttachmentState& bs = m_blend_attachments[m_blend_state.attachmentCount];
+		bs.blendEnable = blend_enable;
+		bs.srcColorBlendFactor = src_factor;
+		bs.dstColorBlendFactor = dst_factor;
+		bs.colorBlendOp = op;
+		bs.srcAlphaBlendFactor = alpha_src_factor;
+		bs.dstAlphaBlendFactor = alpha_dst_factor;
+		bs.alphaBlendOp = alpha_op;
+		bs.colorWriteMask = write_mask;
+
+		m_blend_state.attachmentCount++;
+		m_blend_state.pAttachments = m_blend_attachments.data();
+		m_ci.pColorBlendState = &m_blend_state;
+	}
+
+	void GraphicsPipelineBuilder::SetBlendAttachment(u32 attachment, bool blend_enable, VkBlendFactor src_factor,
+		VkBlendFactor dst_factor, VkBlendOp op, VkBlendFactor alpha_src_factor, VkBlendFactor alpha_dst_factor,
+		VkBlendOp alpha_op,
+		VkColorComponentFlags
+			write_mask /*= VK_COLOR_COMPONENT_R_BIT | VK_COLOR_COMPONENT_G_BIT | VK_COLOR_COMPONENT_B_BIT | VK_COLOR_COMPONENT_A_BIT*/)
+	{
+		pxAssert(attachment < MAX_ATTACHMENTS);
+
+		VkPipelineColorBlendAttachmentState& bs = m_blend_attachments[attachment];
+		bs.blendEnable = blend_enable;
+		bs.srcColorBlendFactor = src_factor;
+		bs.dstColorBlendFactor = dst_factor;
+		bs.colorBlendOp = op;
+		bs.srcAlphaBlendFactor = alpha_src_factor;
+		bs.dstAlphaBlendFactor = alpha_dst_factor;
+		bs.alphaBlendOp = alpha_op;
+		bs.colorWriteMask = write_mask;
+
+		if (attachment >= m_blend_state.attachmentCount)
+		{
+			m_blend_state.attachmentCount = attachment + 1u;
+			m_blend_state.pAttachments = m_blend_attachments.data();
+			m_ci.pColorBlendState = &m_blend_state;
+		}
+	}
+
+	void GraphicsPipelineBuilder::AddBlendFlags(u32 flags)
+	{
+		m_blend_state.flags |= flags;
+	}
+
+	void GraphicsPipelineBuilder::ClearBlendAttachments()
+	{
+		m_blend_attachments = {};
+		m_blend_state.attachmentCount = 0;
+	}
+
+	void GraphicsPipelineBuilder::SetNoBlendingState()
+	{
+		ClearBlendAttachments();
+		SetBlendAttachment(0, false, VK_BLEND_FACTOR_ONE, VK_BLEND_FACTOR_ZERO, VK_BLEND_OP_ADD, VK_BLEND_FACTOR_ONE,
+			VK_BLEND_FACTOR_ZERO, VK_BLEND_OP_ADD,
+			VK_COLOR_COMPONENT_R_BIT | VK_COLOR_COMPONENT_G_BIT | VK_COLOR_COMPONENT_B_BIT | VK_COLOR_COMPONENT_A_BIT);
+	}
+
+	void GraphicsPipelineBuilder::AddDynamicState(VkDynamicState state)
+	{
+		pxAssert(m_dynamic_state.dynamicStateCount < MAX_DYNAMIC_STATE);
+
+		m_dynamic_state_values[m_dynamic_state.dynamicStateCount] = state;
+		m_dynamic_state.dynamicStateCount++;
+		m_dynamic_state.pDynamicStates = m_dynamic_state_values.data();
+		m_ci.pDynamicState = &m_dynamic_state;
+	}
+
+	void GraphicsPipelineBuilder::SetDynamicViewportAndScissorState()
+	{
+		AddDynamicState(VK_DYNAMIC_STATE_VIEWPORT);
+		AddDynamicState(VK_DYNAMIC_STATE_SCISSOR);
+	}
+
+	void GraphicsPipelineBuilder::SetViewport(
+		float x, float y, float width, float height, float min_depth, float max_depth)
+	{
+		m_viewport.x = x;
+		m_viewport.y = y;
+		m_viewport.width = width;
+		m_viewport.height = height;
+		m_viewport.minDepth = min_depth;
+		m_viewport.maxDepth = max_depth;
+
+		m_viewport_state.pViewports = &m_viewport;
+		m_viewport_state.viewportCount = 1u;
+		m_ci.pViewportState = &m_viewport_state;
+	}
+
+	void GraphicsPipelineBuilder::SetScissorRect(s32 x, s32 y, u32 width, u32 height)
+	{
+		m_scissor.offset.x = x;
+		m_scissor.offset.y = y;
+		m_scissor.extent.width = width;
+		m_scissor.extent.height = height;
+
+		m_viewport_state.pScissors = &m_scissor;
+		m_viewport_state.scissorCount = 1u;
+		m_ci.pViewportState = &m_viewport_state;
+	}
+
+	void GraphicsPipelineBuilder::SetMultisamples(VkSampleCountFlagBits samples)
+	{
+		m_multisample_state.rasterizationSamples = samples;
+		m_ci.pMultisampleState = &m_multisample_state;
+	}
+
+	void GraphicsPipelineBuilder::SetPipelineLayout(VkPipelineLayout layout) { m_ci.layout = layout; }
+
+	void GraphicsPipelineBuilder::SetRenderPass(VkRenderPass render_pass, u32 subpass)
+	{
+		m_ci.renderPass = render_pass;
+		m_ci.subpass = subpass;
+	}
+
+	void GraphicsPipelineBuilder::SetProvokingVertex(VkProvokingVertexModeEXT mode)
+	{
+		Util::AddPointerToChain(&m_rasterization_state, &m_provoking_vertex);
+
+		m_provoking_vertex.provokingVertexMode = mode;
+	}
+
+	ComputePipelineBuilder::ComputePipelineBuilder() { Clear(); }
+
+	void ComputePipelineBuilder::Clear()
+	{
+		m_ci = {};
+		m_ci.sType = VK_STRUCTURE_TYPE_COMPUTE_PIPELINE_CREATE_INFO;
+		m_si = {};
+		m_smap_entries = {};
+		m_smap_constants = {};
+	}
+
+	VkPipeline ComputePipelineBuilder::Create(VkDevice device, VkPipelineCache pipeline_cache /*= VK_NULL_HANDLE*/, bool clear /*= true*/)
+	{
+		VkPipeline pipeline;
+		VkResult res = vkCreateComputePipelines(device, pipeline_cache, 1, &m_ci, nullptr, &pipeline);
+		if (res != VK_SUCCESS)
+		{
+			LOG_VULKAN_ERROR(res, "vkCreateComputePipelines() failed: ");
+			return VK_NULL_HANDLE;
+		}
+
+		if (clear)
+			Clear();
+
+		return pipeline;
+	}
+
+	void ComputePipelineBuilder::SetShader(VkShaderModule module, const char* entry_point)
+	{
+		m_ci.stage.sType = VK_STRUCTURE_TYPE_PIPELINE_SHADER_STAGE_CREATE_INFO;
+		m_ci.stage.stage = VK_SHADER_STAGE_COMPUTE_BIT;
+		m_ci.stage.module = module;
+		m_ci.stage.pName = entry_point;
+	}
+
+	void ComputePipelineBuilder::SetPipelineLayout(VkPipelineLayout layout)
+	{
+		m_ci.layout = layout;
+	}
+
+	void ComputePipelineBuilder::SetSpecializationBool(u32 index, bool value)
+	{
+		const u32 u32_value = static_cast<u32>(value);
+		SetSpecializationValue(index, u32_value);
+	}
+
+	void ComputePipelineBuilder::SetSpecializationValue(u32 index, u32 value)
+	{
+		if (m_si.mapEntryCount == 0)
+		{
+			m_si.pMapEntries = m_smap_entries.data();
+			m_si.pData = m_smap_constants.data();
+			m_ci.stage.pSpecializationInfo = &m_si;
+		}
+
+		m_smap_entries[m_si.mapEntryCount++] = {index, index * SPECIALIZATION_CONSTANT_SIZE, SPECIALIZATION_CONSTANT_SIZE};
+		m_si.dataSize += SPECIALIZATION_CONSTANT_SIZE;
+	}
+
+	SamplerBuilder::SamplerBuilder() { Clear(); }
+
+	void SamplerBuilder::Clear()
+	{
+		m_ci = {};
+		m_ci.sType = VK_STRUCTURE_TYPE_SAMPLER_CREATE_INFO;
+	}
+
+	VkSampler SamplerBuilder::Create(VkDevice device, bool clear /* = true */)
+	{
+		VkSampler sampler;
+		VkResult res = vkCreateSampler(device, &m_ci, nullptr, &sampler);
+		if (res != VK_SUCCESS)
+		{
+			LOG_VULKAN_ERROR(res, "vkCreateSampler() failed: ");
+			return VK_NULL_HANDLE;
+		}
+
+		return sampler;
+	}
+
+	void SamplerBuilder::SetFilter(VkFilter mag_filter, VkFilter min_filter, VkSamplerMipmapMode mip_filter)
+	{
+		m_ci.magFilter = mag_filter;
+		m_ci.minFilter = min_filter;
+		m_ci.mipmapMode = mip_filter;
+	}
+
+	void SamplerBuilder::SetAddressMode(VkSamplerAddressMode u, VkSamplerAddressMode v, VkSamplerAddressMode w)
+	{
+		m_ci.addressModeU = u;
+		m_ci.addressModeV = v;
+		m_ci.addressModeW = w;
+	}
+
+	void SamplerBuilder::SetPointSampler(
+		VkSamplerAddressMode address_mode /* = VK_SAMPLER_ADDRESS_MODE_CLAMP_TO_BORDER */)
+	{
+		Clear();
+		SetFilter(VK_FILTER_NEAREST, VK_FILTER_NEAREST, VK_SAMPLER_MIPMAP_MODE_NEAREST);
+		SetAddressMode(address_mode, address_mode, address_mode);
+	}
+
+	void SamplerBuilder::SetLinearSampler(
+		bool mipmaps, VkSamplerAddressMode address_mode /* = VK_SAMPLER_ADDRESS_MODE_CLAMP_TO_BORDER */)
+	{
+		Clear();
+		SetFilter(VK_FILTER_LINEAR, VK_FILTER_LINEAR,
+			mipmaps ? VK_SAMPLER_MIPMAP_MODE_LINEAR : VK_SAMPLER_MIPMAP_MODE_NEAREST);
+		SetAddressMode(address_mode, address_mode, address_mode);
+
+		if (mipmaps)
+		{
+			m_ci.minLod = std::numeric_limits<float>::min();
+			m_ci.maxLod = std::numeric_limits<float>::max();
+		}
+	}
+
+	DescriptorSetUpdateBuilder::DescriptorSetUpdateBuilder() { Clear(); }
+
+	void DescriptorSetUpdateBuilder::Clear()
+	{
+		m_writes = {};
+		m_num_writes = 0;
+	}
+
+	void DescriptorSetUpdateBuilder::Update(VkDevice device, bool clear /*= true*/)
+	{
+		pxAssert(m_num_writes > 0);
+
+		vkUpdateDescriptorSets(device, m_num_writes, (m_num_writes > 0) ? m_writes.data() : nullptr, 0, nullptr);
+
+		if (clear)
+			Clear();
+	}
+
+	void DescriptorSetUpdateBuilder::AddImageDescriptorWrite(VkDescriptorSet set, u32 binding, VkImageView view,
+		VkImageLayout layout /*= VK_IMAGE_LAYOUT_SHADER_READ_ONLY_OPTIMAL*/)
+	{
+		pxAssert(m_num_writes < MAX_WRITES && m_num_image_infos < MAX_IMAGE_INFOS);
+
+		VkDescriptorImageInfo& ii = m_image_infos[m_num_image_infos++];
+		ii.imageView = view;
+		ii.imageLayout = layout;
+		ii.sampler = VK_NULL_HANDLE;
+
+		VkWriteDescriptorSet& dw = m_writes[m_num_writes++];
+		dw.sType = VK_STRUCTURE_TYPE_WRITE_DESCRIPTOR_SET;
+		dw.dstSet = set;
+		dw.dstBinding = binding;
+		dw.descriptorCount = 1;
+		dw.descriptorType = VK_DESCRIPTOR_TYPE_SAMPLED_IMAGE;
+		dw.pImageInfo = &ii;
+	}
+
+
+	void DescriptorSetUpdateBuilder::AddImageDescriptorWrites(VkDescriptorSet set, u32 binding,
+		const VkImageView* views, u32 num_views, VkImageLayout layout /*= VK_IMAGE_LAYOUT_SHADER_READ_ONLY_OPTIMAL*/)
+	{
+		pxAssert(m_num_writes < MAX_WRITES && (m_num_image_infos + num_views) < MAX_IMAGE_INFOS);
+
+#if 1
+		// NOTE: This is deliberately split up - updating multiple descriptors in one write is broken on Adreno.
+		for (u32 i = 0; i < num_views; i++)
+			AddImageDescriptorWrite(set, binding + i, views[i], layout);
+#else
+		VkWriteDescriptorSet& dw = m_writes[m_num_writes++];
+		dw.sType = VK_STRUCTURE_TYPE_WRITE_DESCRIPTOR_SET;
+		dw.dstSet = set;
+		dw.dstBinding = binding;
+		dw.descriptorCount = num_views;
+		dw.descriptorType = VK_DESCRIPTOR_TYPE_SAMPLED_IMAGE;
+		dw.pImageInfo = &m_image_infos[m_num_image_infos];
+
+		for (u32 i = 0; i < num_views; i++)
+		{
+			VkDescriptorImageInfo& ii = m_image_infos[m_num_image_infos++];
+			ii.imageView = views[i];
+			ii.imageLayout = layout;
+			ii.sampler = VK_NULL_HANDLE;
+		}
+#endif
+	}
+
+	void DescriptorSetUpdateBuilder::AddSamplerDescriptorWrite(VkDescriptorSet set, u32 binding, VkSampler sampler)
+	{
+		pxAssert(m_num_writes < MAX_WRITES && m_num_image_infos < MAX_IMAGE_INFOS);
+
+		VkDescriptorImageInfo& ii = m_image_infos[m_num_image_infos++];
+		ii.imageView = VK_NULL_HANDLE;
+		ii.imageLayout = VK_IMAGE_LAYOUT_UNDEFINED;
+		ii.sampler = sampler;
+
+		VkWriteDescriptorSet& dw = m_writes[m_num_writes++];
+		dw.sType = VK_STRUCTURE_TYPE_WRITE_DESCRIPTOR_SET;
+		dw.dstSet = set;
+		dw.dstBinding = binding;
+		dw.descriptorCount = 1;
+		dw.descriptorType = VK_DESCRIPTOR_TYPE_SAMPLER;
+		dw.pImageInfo = &ii;
+	}
+
+
+	void DescriptorSetUpdateBuilder::AddSamplerDescriptorWrites(
+		VkDescriptorSet set, u32 binding, const VkSampler* samplers, u32 num_samplers)
+	{
+		pxAssert(m_num_writes < MAX_WRITES && (m_num_image_infos + num_samplers) < MAX_IMAGE_INFOS);
+
+		VkWriteDescriptorSet& dw = m_writes[m_num_writes++];
+		dw.sType = VK_STRUCTURE_TYPE_WRITE_DESCRIPTOR_SET;
+		dw.dstSet = set;
+		dw.dstBinding = binding;
+		dw.descriptorCount = num_samplers;
+		dw.descriptorType = VK_DESCRIPTOR_TYPE_SAMPLER;
+		dw.pImageInfo = &m_image_infos[m_num_image_infos];
+
+		for (u32 i = 0; i < num_samplers; i++)
+		{
+			VkDescriptorImageInfo& ii = m_image_infos[m_num_image_infos++];
+			ii.imageView = VK_NULL_HANDLE;
+			ii.imageLayout = VK_IMAGE_LAYOUT_SHADER_READ_ONLY_OPTIMAL;
+			ii.sampler = samplers[i];
+		}
+	}
+
+	void DescriptorSetUpdateBuilder::AddCombinedImageSamplerDescriptorWrite(VkDescriptorSet set, u32 binding,
+		VkImageView view, VkSampler sampler, VkImageLayout layout /*= VK_IMAGE_LAYOUT_SHADER_READ_ONLY_OPTIMAL*/)
+	{
+		pxAssert(m_num_writes < MAX_WRITES && m_num_image_infos < MAX_IMAGE_INFOS);
+
+		VkDescriptorImageInfo& ii = m_image_infos[m_num_image_infos++];
+		ii.imageView = view;
+		ii.imageLayout = layout;
+		ii.sampler = sampler;
+
+		VkWriteDescriptorSet& dw = m_writes[m_num_writes++];
+		dw.sType = VK_STRUCTURE_TYPE_WRITE_DESCRIPTOR_SET;
+		dw.dstSet = set;
+		dw.dstBinding = binding;
+		dw.descriptorCount = 1;
+		dw.descriptorType = VK_DESCRIPTOR_TYPE_COMBINED_IMAGE_SAMPLER;
+		dw.pImageInfo = &ii;
+	}
+
+	void DescriptorSetUpdateBuilder::AddCombinedImageSamplerDescriptorWrites(VkDescriptorSet set, u32 binding,
+		const VkImageView* views, const VkSampler* samplers, u32 num_views,
+		VkImageLayout layout /* = VK_IMAGE_LAYOUT_SHADER_READ_ONLY_OPTIMAL */)
+	{
+		pxAssert(m_num_writes < MAX_WRITES && (m_num_image_infos + num_views) < MAX_IMAGE_INFOS);
+
+#if 1
+		// NOTE: This is deliberately split up - updating multiple descriptors in one write is broken on Adreno.
+		for (u32 i = 0; i < num_views; i++)
+			AddCombinedImageSamplerDescriptorWrite(set, binding + i, views[i], samplers[i], layout);
+#else
+		VkWriteDescriptorSet& dw = m_writes[m_num_writes++];
+		dw.sType = VK_STRUCTURE_TYPE_WRITE_DESCRIPTOR_SET;
+		dw.dstSet = set;
+		dw.dstBinding = binding;
+		dw.descriptorCount = num_views;
+		dw.descriptorType = VK_DESCRIPTOR_TYPE_COMBINED_IMAGE_SAMPLER;
+		dw.pImageInfo = &m_image_infos[m_num_image_infos];
+
+		for (u32 i = 0; i < num_views; i++)
+		{
+			VkDescriptorImageInfo& ii = m_image_infos[m_num_image_infos++];
+			ii.imageView = views[i];
+			ii.sampler = samplers[i];
+			ii.imageLayout = layout;
+		}
+#endif
+	}
+
+	void DescriptorSetUpdateBuilder::AddBufferDescriptorWrite(
+		VkDescriptorSet set, u32 binding, VkDescriptorType dtype, VkBuffer buffer, u32 offset, u32 size)
+	{
+		pxAssert(m_num_writes < MAX_WRITES && m_num_buffer_infos < MAX_BUFFER_INFOS);
+
+		VkDescriptorBufferInfo& bi = m_buffer_infos[m_num_buffer_infos++];
+		bi.buffer = buffer;
+		bi.offset = offset;
+		bi.range = size;
+
+		VkWriteDescriptorSet& dw = m_writes[m_num_writes++];
+		dw.sType = VK_STRUCTURE_TYPE_WRITE_DESCRIPTOR_SET;
+		dw.dstSet = set;
+		dw.dstBinding = binding;
+		dw.descriptorCount = 1;
+		dw.descriptorType = dtype;
+		dw.pBufferInfo = &bi;
+	}
+
+	void DescriptorSetUpdateBuilder::AddBufferViewDescriptorWrite(
+		VkDescriptorSet set, u32 binding, VkDescriptorType dtype, VkBufferView view)
+	{
+		pxAssert(m_num_writes < MAX_WRITES && m_num_views < MAX_VIEWS);
+
+		VkBufferView& bi = m_views[m_num_views++];
+		bi = view;
+
+		VkWriteDescriptorSet& dw = m_writes[m_num_writes++];
+		dw.sType = VK_STRUCTURE_TYPE_WRITE_DESCRIPTOR_SET;
+		dw.dstSet = set;
+		dw.dstBinding = binding;
+		dw.descriptorCount = 1;
+		dw.descriptorType = dtype;
+		dw.pTexelBufferView = &bi;
+	}
+
+	void DescriptorSetUpdateBuilder::AddInputAttachmentDescriptorWrite(
+		VkDescriptorSet set, u32 binding, VkImageView view, VkImageLayout layout /*= VK_IMAGE_LAYOUT_GENERAL*/)
+	{
+		pxAssert(m_num_writes < MAX_WRITES && m_num_image_infos < MAX_IMAGE_INFOS);
+
+		VkWriteDescriptorSet& dw = m_writes[m_num_writes++];
+		dw.sType = VK_STRUCTURE_TYPE_WRITE_DESCRIPTOR_SET;
+		dw.dstSet = set;
+		dw.dstBinding = binding;
+		dw.descriptorCount = 1;
+		dw.descriptorType = VK_DESCRIPTOR_TYPE_INPUT_ATTACHMENT;
+		dw.pImageInfo = &m_image_infos[m_num_image_infos];
+
+		VkDescriptorImageInfo& ii = m_image_infos[m_num_image_infos++];
+		ii.imageView = view;
+		ii.imageLayout = layout;
+		ii.sampler = VK_NULL_HANDLE;
+	}
+
+	void DescriptorSetUpdateBuilder::AddStorageImageDescriptorWrite(
+		VkDescriptorSet set, u32 binding, VkImageView view, VkImageLayout layout /*= VK_IMAGE_LAYOUT_GENERAL*/)
+	{
+		pxAssert(m_num_writes < MAX_WRITES && m_num_image_infos < MAX_IMAGE_INFOS);
+
+		VkWriteDescriptorSet& dw = m_writes[m_num_writes++];
+		dw.sType = VK_STRUCTURE_TYPE_WRITE_DESCRIPTOR_SET;
+		dw.dstSet = set;
+		dw.dstBinding = binding;
+		dw.descriptorCount = 1;
+		dw.descriptorType = VK_DESCRIPTOR_TYPE_STORAGE_IMAGE;
+		dw.pImageInfo = &m_image_infos[m_num_image_infos];
+
+		VkDescriptorImageInfo& ii = m_image_infos[m_num_image_infos++];
+		ii.imageView = view;
+		ii.imageLayout = layout;
+		ii.sampler = VK_NULL_HANDLE;
+	}
+
+	FramebufferBuilder::FramebufferBuilder() { Clear(); }
+
+	void FramebufferBuilder::Clear()
+	{
+		m_ci = {};
+		m_ci.sType = VK_STRUCTURE_TYPE_FRAMEBUFFER_CREATE_INFO;
+		m_images = {};
+	}
+
+	VkFramebuffer FramebufferBuilder::Create(VkDevice device, bool clear /*= true*/)
+	{
+		VkFramebuffer fb;
+		VkResult res = vkCreateFramebuffer(device, &m_ci, nullptr, &fb);
+		if (res != VK_SUCCESS)
+		{
+			LOG_VULKAN_ERROR(res, "vkCreateFramebuffer() failed: ");
+			return VK_NULL_HANDLE;
+		}
+
+		if (clear)
+			Clear();
+
+		return fb;
+	}
+
+	void FramebufferBuilder::AddAttachment(VkImageView image)
+	{
+		pxAssert(m_ci.attachmentCount < MAX_ATTACHMENTS);
+
+		m_images[m_ci.attachmentCount] = image;
+
+		m_ci.attachmentCount++;
+		m_ci.pAttachments = m_images.data();
+	}
+
+	void FramebufferBuilder::SetSize(u32 width, u32 height, u32 layers)
+	{
+		m_ci.width = width;
+		m_ci.height = height;
+		m_ci.layers = layers;
+	}
+
+	void FramebufferBuilder::SetRenderPass(VkRenderPass render_pass) { m_ci.renderPass = render_pass; }
+
+	RenderPassBuilder::RenderPassBuilder() { Clear(); }
+
+	void RenderPassBuilder::Clear()
+	{
+		m_ci = {};
+		m_ci.sType = VK_STRUCTURE_TYPE_RENDER_PASS_CREATE_INFO;
+		m_attachments = {};
+		m_attachment_references = {};
+		m_num_attachment_references = 0;
+		m_subpasses = {};
+	}
+
+	VkRenderPass RenderPassBuilder::Create(VkDevice device, bool clear /*= true*/)
+	{
+		VkRenderPass rp;
+		VkResult res = vkCreateRenderPass(device, &m_ci, nullptr, &rp);
+		if (res != VK_SUCCESS)
+		{
+			LOG_VULKAN_ERROR(res, "vkCreateRenderPass() failed: ");
+			return VK_NULL_HANDLE;
+		}
+
+		return rp;
+	}
+
+	u32 RenderPassBuilder::AddAttachment(VkFormat format, VkSampleCountFlagBits samples, VkAttachmentLoadOp load_op,
+		VkAttachmentStoreOp store_op, VkImageLayout initial_layout, VkImageLayout final_layout)
+	{
+		pxAssert(m_ci.attachmentCount < MAX_ATTACHMENTS);
+
+		const u32 index = m_ci.attachmentCount;
+		VkAttachmentDescription& ad = m_attachments[index];
+		ad.format = format;
+		ad.samples = samples;
+		ad.loadOp = load_op;
+		ad.storeOp = store_op;
+		ad.stencilLoadOp = VK_ATTACHMENT_LOAD_OP_DONT_CARE;
+		ad.stencilStoreOp = VK_ATTACHMENT_STORE_OP_DONT_CARE;
+		ad.initialLayout = initial_layout;
+		ad.finalLayout = final_layout;
+
+		m_ci.attachmentCount++;
+		m_ci.pAttachments = m_attachments.data();
+
+		return index;
+	}
+
+	u32 RenderPassBuilder::AddSubpass()
+	{
+		pxAssert(m_ci.subpassCount < MAX_SUBPASSES);
+
+		const u32 index = m_ci.subpassCount;
+		VkSubpassDescription& sp = m_subpasses[index];
+		sp.pipelineBindPoint = VK_PIPELINE_BIND_POINT_GRAPHICS;
+
+		m_ci.subpassCount++;
+		m_ci.pSubpasses = m_subpasses.data();
+
+		return index;
+	}
+
+	void RenderPassBuilder::AddSubpassColorAttachment(u32 subpass, u32 attachment, VkImageLayout layout)
+	{
+		pxAssert(subpass < m_ci.subpassCount && m_num_attachment_references < MAX_ATTACHMENT_REFERENCES);
+
+		VkAttachmentReference& ar = m_attachment_references[m_num_attachment_references++];
+		ar.attachment = attachment;
+		ar.layout = layout;
+
+		VkSubpassDescription& sp = m_subpasses[subpass];
+		if (sp.colorAttachmentCount == 0)
+			sp.pColorAttachments = &ar;
+		sp.colorAttachmentCount++;
+	}
+
+	void RenderPassBuilder::AddSubpassDepthAttachment(u32 subpass, u32 attachment, VkImageLayout layout)
+	{
+		pxAssert(subpass < m_ci.subpassCount && m_num_attachment_references < MAX_ATTACHMENT_REFERENCES);
+
+		VkAttachmentReference& ar = m_attachment_references[m_num_attachment_references++];
+		ar.attachment = attachment;
+		ar.layout = layout;
+
+		VkSubpassDescription& sp = m_subpasses[subpass];
+		sp.pDepthStencilAttachment = &ar;
+	}
+
+	BufferViewBuilder::BufferViewBuilder() { Clear(); }
+
+	void BufferViewBuilder::Clear()
+	{
+		m_ci = {};
+		m_ci.sType = VK_STRUCTURE_TYPE_BUFFER_VIEW_CREATE_INFO;
+	}
+
+	VkBufferView BufferViewBuilder::Create(VkDevice device, bool clear /*= true*/)
+	{
+		VkBufferView bv;
+		VkResult res = vkCreateBufferView(device, &m_ci, nullptr, &bv);
+		if (res != VK_SUCCESS)
+		{
+			LOG_VULKAN_ERROR(res, "vkCreateBufferView() failed: ");
+			return VK_NULL_HANDLE;
+		}
+
+		return bv;
+	}
+
+	void BufferViewBuilder::Set(VkBuffer buffer, VkFormat format, u32 offset, u32 size)
+	{
+		m_ci.buffer = buffer;
+		m_ci.format = format;
+		m_ci.offset = offset;
+		m_ci.range = size;
+	}
+} // namespace Vulkan
--- a/pcsx2/GS/Renderers/Vulkan/VKBuilders.h
+++ b/pcsx2/GS/Renderers/Vulkan/VKBuilders.h
@@ -1,5 +1,5 @@
 /*  PCSX2 - PS2 Emulator for PCs
- *  Copyright (C) 2002-2023  PCSX2 Dev Team
+ *  Copyright (C) 2002-2021  PCSX2 Dev Team
 *
 *  PCSX2 is free software: you can redistribute it and/or modify it under the terms
 *  of the GNU Lesser General Public License as published by the Free Software Found-
@@ -14,9 +14,8 @@
 */

 #pragma once
-
-#include "GS/Renderers/Vulkan/VKLoader.h"
-
+#include "common/Pcsx2Defs.h"
+#include "common/Vulkan/Loader.h"
 #include <array>

 namespace Vulkan
@@ -232,6 +231,8 @@ namespace Vulkan

 		void AddImageDescriptorWrite(VkDescriptorSet set, u32 binding, VkImageView view,
 			VkImageLayout layout = VK_IMAGE_LAYOUT_SHADER_READ_ONLY_OPTIMAL);
+		void AddImageDescriptorWrites(VkDescriptorSet set, u32 binding, const VkImageView* views, u32 num_views,
+			VkImageLayout layout = VK_IMAGE_LAYOUT_SHADER_READ_ONLY_OPTIMAL);
 		void AddSamplerDescriptorWrite(VkDescriptorSet set, u32 binding, VkSampler sampler);
 		void AddSamplerDescriptorWrites(VkDescriptorSet set, u32 binding, const VkSampler* samplers, u32 num_samplers);
 		void AddCombinedImageSamplerDescriptorWrite(VkDescriptorSet set, u32 binding, VkImageView view,
--- a/common/Vulkan/Context.cpp
+++ b/common/Vulkan/Context.cpp
--- a/common/Vulkan/Context.h
+++ b/common/Vulkan/Context.h
@@ -0,0 +1,407 @@
+/*  PCSX2 - PS2 Emulator for PCs
+ *  Copyright (C) 2002-2021  PCSX2 Dev Team
+ *
+ *  PCSX2 is free software: you can redistribute it and/or modify it under the terms
+ *  of the GNU Lesser General Public License as published by the Free Software Found-
+ *  ation, either version 3 of the License, or (at your option) any later version.
+ *
+ *  PCSX2 is distributed in the hope that it will be useful, but WITHOUT ANY WARRANTY;
+ *  without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR
+ *  PURPOSE.  See the GNU General Public License for more details.
+ *
+ *  You should have received a copy of the GNU General Public License along with PCSX2.
+ *  If not, see <http://www.gnu.org/licenses/>.
+ */
+
+#pragma once
+
+#include "common/Pcsx2Defs.h"
+
+#include "common/ReadbackSpinManager.h"
+#include "common/Vulkan/Loader.h"
+#include "common/Vulkan/StreamBuffer.h"
+
+#include <array>
+#include <atomic>
+#include <condition_variable>
+#include <functional>
+#include <map>
+#include <memory>
+#include <mutex>
+#include <string>
+#include <thread>
+#include <vector>
+
+struct WindowInfo;
+
+namespace Vulkan
+{
+	class SwapChain;
+
+	class Context
+	{
+	public:
+		enum : u32
+		{
+			NUM_COMMAND_BUFFERS = 3,
+			TEXTURE_BUFFER_SIZE = 64 * 1024 * 1024,
+		};
+
+		struct OptionalExtensions
+		{
+			bool vk_ext_provoking_vertex : 1;
+			bool vk_ext_memory_budget : 1;
+			bool vk_ext_calibrated_timestamps : 1;
+			bool vk_ext_line_rasterization : 1;
+			bool vk_khr_driver_properties : 1;
+			bool vk_arm_rasterization_order_attachment_access : 1;
+			bool vk_khr_fragment_shader_barycentric : 1;
+		};
+
+		~Context();
+
+		// Helper method to create a Vulkan instance.
+		static VkInstance CreateVulkanInstance(
+			const WindowInfo* wi, bool enable_debug_utils, bool enable_validation_layer);
+
+		// Returns a list of Vulkan-compatible GPUs.
+		using GPUList = std::vector<VkPhysicalDevice>;
+		using GPUNameList = std::vector<std::string>;
+		static GPUList EnumerateGPUs(VkInstance instance);
+		static GPUNameList EnumerateGPUNames(VkInstance instance);
+
+		// Creates a new context and sets it up as global.
+		static bool Create(std::string_view gpu_name, const WindowInfo* wi, std::unique_ptr<SwapChain>* out_swap_chain,
+			VkPresentModeKHR preferred_present_mode, bool threaded_presentation, bool enable_debug_utils,
+			bool enable_validation_layer);
+
+		// Destroys context.
+		static void Destroy();
+
+		// Enable/disable debug message runtime.
+		bool EnableDebugUtils();
+		void DisableDebugUtils();
+
+		// Global state accessors
+		__fi VkInstance GetVulkanInstance() const { return m_instance; }
+		__fi VkPhysicalDevice GetPhysicalDevice() const { return m_physical_device; }
+		__fi VkDevice GetDevice() const { return m_device; }
+		__fi VmaAllocator GetAllocator() const { return m_allocator; }
+		__fi VkQueue GetGraphicsQueue() const { return m_graphics_queue; }
+		__fi u32 GetGraphicsQueueFamilyIndex() const { return m_graphics_queue_family_index; }
+		__fi VkQueue GetPresentQueue() const { return m_present_queue; }
+		__fi u32 GetPresentQueueFamilyIndex() const { return m_present_queue_family_index; }
+		__fi const VkQueueFamilyProperties& GetGraphicsQueueProperties() const { return m_graphics_queue_properties; }
+		__fi const VkPhysicalDeviceMemoryProperties& GetDeviceMemoryProperties() const
+		{
+			return m_device_memory_properties;
+		}
+		__fi const VkPhysicalDeviceProperties& GetDeviceProperties() const { return m_device_properties; }
+		__fi const VkPhysicalDeviceFeatures& GetDeviceFeatures() const { return m_device_features; }
+		__fi const VkPhysicalDeviceLimits& GetDeviceLimits() const { return m_device_properties.limits; }
+		__fi const VkPhysicalDeviceDriverProperties& GetDeviceDriverProperties() const { return m_device_driver_properties; }
+		__fi const OptionalExtensions& GetOptionalExtensions() const { return m_optional_extensions; }
+
+		// Helpers for getting constants
+		__fi u32 GetUniformBufferAlignment() const
+		{
+			return static_cast<u32>(m_device_properties.limits.minUniformBufferOffsetAlignment);
+		}
+		__fi u32 GetTexelBufferAlignment() const
+		{
+			return static_cast<u32>(m_device_properties.limits.minTexelBufferOffsetAlignment);
+		}
+		__fi u32 GetStorageBufferAlignment() const
+		{
+			return static_cast<u32>(m_device_properties.limits.minStorageBufferOffsetAlignment);
+		}
+		__fi u32 GetBufferImageGranularity() const
+		{
+			return static_cast<u32>(m_device_properties.limits.bufferImageGranularity);
+		}
+		__fi u32 GetBufferCopyOffsetAlignment() const
+		{
+			return static_cast<u32>(m_device_properties.limits.optimalBufferCopyOffsetAlignment);
+		}
+		__fi u32 GetBufferCopyRowPitchAlignment() const
+		{
+			return static_cast<u32>(m_device_properties.limits.optimalBufferCopyRowPitchAlignment);
+		}
+		__fi u32 GetMaxImageDimension2D() const
+		{
+			return m_device_properties.limits.maxImageDimension2D;
+		}
+
+		// Creates a simple render pass.
+		__ri VkRenderPass GetRenderPass(VkFormat color_format, VkFormat depth_format,
+			VkAttachmentLoadOp color_load_op = VK_ATTACHMENT_LOAD_OP_LOAD,
+			VkAttachmentStoreOp color_store_op = VK_ATTACHMENT_STORE_OP_STORE,
+			VkAttachmentLoadOp depth_load_op = VK_ATTACHMENT_LOAD_OP_LOAD,
+			VkAttachmentStoreOp depth_store_op = VK_ATTACHMENT_STORE_OP_STORE,
+			VkAttachmentLoadOp stencil_load_op = VK_ATTACHMENT_LOAD_OP_DONT_CARE,
+			VkAttachmentStoreOp stencil_store_op = VK_ATTACHMENT_STORE_OP_DONT_CARE, bool color_feedback_loop = false)
+		{
+			RenderPassCacheKey key = {};
+			key.color_format = color_format;
+			key.depth_format = depth_format;
+			key.color_load_op = color_load_op;
+			key.color_store_op = color_store_op;
+			key.depth_load_op = depth_load_op;
+			key.depth_store_op = depth_store_op;
+			key.stencil_load_op = stencil_load_op;
+			key.stencil_store_op = stencil_store_op;
+			key.color_feedback_loop = color_feedback_loop;
+
+			auto it = m_render_pass_cache.find(key.key);
+			if (it != m_render_pass_cache.end())
+				return it->second;
+
+			return CreateCachedRenderPass(key);
+		}
+
+		// These command buffers are allocated per-frame. They are valid until the command buffer
+		// is submitted, after that you should call these functions again.
+		__fi u32 GetCurrentCommandBufferIndex() const { return m_current_frame; }
+		__fi VkDescriptorPool GetGlobalDescriptorPool() const { return m_global_descriptor_pool; }
+		__fi VkCommandBuffer GetCurrentCommandBuffer() const { return m_current_command_buffer; }
+		__fi StreamBuffer& GetTextureUploadBuffer() { return m_texture_upload_buffer; }
+		__fi VkDescriptorPool GetCurrentDescriptorPool() const
+		{
+			return m_frame_resources[m_current_frame].descriptor_pool;
+		}
+		VkCommandBuffer GetCurrentInitCommandBuffer();
+
+		/// Allocates a descriptor set from the pool reserved for the current frame.
+		VkDescriptorSet AllocateDescriptorSet(VkDescriptorSetLayout set_layout);
+
+		/// Allocates a descriptor set from the pool reserved for the current frame.
+		VkDescriptorSet AllocatePersistentDescriptorSet(VkDescriptorSetLayout set_layout);
+
+		/// Frees a descriptor set allocated from the global pool.
+		void FreeGlobalDescriptorSet(VkDescriptorSet set);
+
+		// Gets the fence that will be signaled when the currently executing command buffer is
+		// queued and executed. Do not wait for this fence before the buffer is executed.
+		__fi VkFence GetCurrentCommandBufferFence() const { return m_frame_resources[m_current_frame].fence; }
+
+		// Fence "counters" are used to track which commands have been completed by the GPU.
+		// If the last completed fence counter is greater or equal to N, it means that the work
+		// associated counter N has been completed by the GPU. The value of N to associate with
+		// commands can be retreived by calling GetCurrentFenceCounter().
+		u64 GetCompletedFenceCounter() const { return m_completed_fence_counter; }
+
+		// Gets the fence that will be signaled when the currently executing command buffer is
+		// queued and executed. Do not wait for this fence before the buffer is executed.
+		u64 GetCurrentFenceCounter() const { return m_frame_resources[m_current_frame].fence_counter; }
+
+		void SubmitCommandBuffer(SwapChain* present_swap_chain = nullptr, bool submit_on_thread = false);
+		void MoveToNextCommandBuffer();
+
+		enum class WaitType
+		{
+			None,
+			Sleep,
+			Spin,
+		};
+
+		void ExecuteCommandBuffer(WaitType wait_for_completion);
+		void WaitForPresentComplete();
+
+		// Was the last present submitted to the queue a failure? If so, we must recreate our swapchain.
+		bool CheckLastPresentFail();
+
+		// Schedule a vulkan resource for destruction later on. This will occur when the command buffer
+		// is next re-used, and the GPU has finished working with the specified resource.
+		void DeferBufferDestruction(VkBuffer object);
+		void DeferBufferDestruction(VkBuffer object, VmaAllocation allocation);
+		void DeferBufferViewDestruction(VkBufferView object);
+		void DeferDeviceMemoryDestruction(VkDeviceMemory object);
+		void DeferFramebufferDestruction(VkFramebuffer object);
+		void DeferImageDestruction(VkImage object);
+		void DeferImageDestruction(VkImage object, VmaAllocation allocation);
+		void DeferImageViewDestruction(VkImageView object);
+		void DeferPipelineDestruction(VkPipeline pipeline);
+		void DeferSamplerDestruction(VkSampler sampler);
+
+		// Wait for a fence to be completed.
+		// Also invokes callbacks for completion.
+		void WaitForFenceCounter(u64 fence_counter);
+
+		void WaitForGPUIdle();
+
+		float GetAndResetAccumulatedGPUTime();
+		bool SetEnableGPUTiming(bool enabled);
+
+		void CountRenderPass() { m_command_buffer_render_passes++; }
+		void NotifyOfReadback();
+
+	private:
+		Context(VkInstance instance, VkPhysicalDevice physical_device);
+
+		union RenderPassCacheKey
+		{
+			struct
+			{
+				u32 color_format : 8;
+				u32 depth_format : 8;
+				u32 color_load_op : 2;
+				u32 color_store_op : 1;
+				u32 depth_load_op : 2;
+				u32 depth_store_op : 1;
+				u32 stencil_load_op : 2;
+				u32 stencil_store_op : 1;
+				u32 color_feedback_loop : 1;
+			};
+
+			u32 key;
+		};
+
+		using ExtensionList = std::vector<const char*>;
+		static bool SelectInstanceExtensions(
+			ExtensionList* extension_list, const WindowInfo* wi, bool enable_debug_utils);
+		bool SelectDeviceExtensions(ExtensionList* extension_list, bool enable_surface);
+		bool SelectDeviceFeatures(const VkPhysicalDeviceFeatures* required_features);
+		bool CreateDevice(VkSurfaceKHR surface, bool enable_validation_layer, const char** required_device_extensions,
+			u32 num_required_device_extensions, const char** required_device_layers, u32 num_required_device_layers,
+			const VkPhysicalDeviceFeatures* required_features);
+		void ProcessDeviceExtensions();
+
+		bool CreateAllocator();
+		void DestroyAllocator();
+		bool CreateCommandBuffers();
+		void DestroyCommandBuffers();
+		bool CreateGlobalDescriptorPool();
+		void DestroyGlobalDescriptorPool();
+		bool CreateTextureStreamBuffer();
+
+		VkRenderPass CreateCachedRenderPass(RenderPassCacheKey key);
+		void DestroyRenderPassCache();
+
+		void CommandBufferCompleted(u32 index);
+		void ActivateCommandBuffer(u32 index);
+		void ScanForCommandBufferCompletion();
+		void WaitForCommandBufferCompletion(u32 index);
+
+		void DoSubmitCommandBuffer(u32 index, SwapChain* present_swap_chain, u32 spin_cycles);
+		void DoPresent(SwapChain* present_swap_chain);
+		void WaitForPresentComplete(std::unique_lock<std::mutex>& lock);
+		void PresentThread();
+		void StartPresentThread();
+		void StopPresentThread();
+
+		bool InitSpinResources();
+		void DestroySpinResources();
+		void WaitForSpinCompletion(u32 index);
+		void SpinCommandCompleted(u32 index);
+		void SubmitSpinCommand(u32 index, u32 cycles);
+		void CalibrateSpinTimestamp();
+		u64 GetCPUTimestamp();
+
+		struct FrameResources
+		{
+			// [0] - Init (upload) command buffer, [1] - draw command buffer
+			VkCommandPool command_pool = VK_NULL_HANDLE;
+			std::array<VkCommandBuffer, 2> command_buffers{VK_NULL_HANDLE, VK_NULL_HANDLE};
+			VkDescriptorPool descriptor_pool = VK_NULL_HANDLE;
+			VkFence fence = VK_NULL_HANDLE;
+			u64 fence_counter = 0;
+			s32 spin_id = -1;
+			u32 submit_timestamp = 0;
+			bool init_buffer_used = false;
+			bool needs_fence_wait = false;
+			bool timestamp_written = false;
+
+			std::vector<std::function<void()>> cleanup_resources;
+		};
+
+		struct SpinResources
+		{
+			VkCommandPool command_pool = VK_NULL_HANDLE;
+			VkCommandBuffer command_buffer = VK_NULL_HANDLE;
+			VkSemaphore semaphore = VK_NULL_HANDLE;
+			VkFence fence = VK_NULL_HANDLE;
+			u32 cycles = 0;
+			bool in_progress = false;
+		};
+
+		VkInstance m_instance = VK_NULL_HANDLE;
+		VkPhysicalDevice m_physical_device = VK_NULL_HANDLE;
+		VkDevice m_device = VK_NULL_HANDLE;
+		VmaAllocator m_allocator = VK_NULL_HANDLE;
+
+		VkCommandBuffer m_current_command_buffer = VK_NULL_HANDLE;
+
+		VkDescriptorPool m_global_descriptor_pool = VK_NULL_HANDLE;
+
+		VkQueue m_graphics_queue = VK_NULL_HANDLE;
+		VkQueue m_present_queue = VK_NULL_HANDLE;
+		u32 m_graphics_queue_family_index = 0;
+		u32 m_present_queue_family_index = 0;
+
+		ReadbackSpinManager m_spin_manager;
+		VkQueue m_spin_queue = VK_NULL_HANDLE;
+		VkDescriptorSetLayout m_spin_descriptor_set_layout = VK_NULL_HANDLE;
+		VkPipelineLayout m_spin_pipeline_layout = VK_NULL_HANDLE;
+		VkPipeline m_spin_pipeline = VK_NULL_HANDLE;
+		VkBuffer m_spin_buffer = VK_NULL_HANDLE;
+		VmaAllocation m_spin_buffer_allocation = VK_NULL_HANDLE;
+		VkDescriptorSet m_spin_descriptor_set = VK_NULL_HANDLE;
+		std::array<SpinResources, NUM_COMMAND_BUFFERS> m_spin_resources;
+#ifdef _WIN32
+		double m_queryperfcounter_to_ns = 0;
+#endif
+		double m_spin_timestamp_scale = 0;
+		double m_spin_timestamp_offset = 0;
+		u32 m_spin_queue_family_index = 0;
+		u32 m_command_buffer_render_passes = 0;
+		u32 m_spin_timer = 0;
+		bool m_spinning_supported = false;
+		bool m_spin_queue_is_graphics_queue = false;
+		bool m_spin_buffer_initialized = false;
+
+		VkQueryPool m_timestamp_query_pool = VK_NULL_HANDLE;
+		float m_accumulated_gpu_time = 0.0f;
+		bool m_gpu_timing_enabled = false;
+		bool m_gpu_timing_supported = false;
+		bool m_wants_new_timestamp_calibration = false;
+		VkTimeDomainEXT m_calibrated_timestamp_type = VK_TIME_DOMAIN_DEVICE_EXT;
+
+		std::array<FrameResources, NUM_COMMAND_BUFFERS> m_frame_resources;
+		u64 m_next_fence_counter = 1;
+		u64 m_completed_fence_counter = 0;
+		u32 m_current_frame = 0;
+
+		StreamBuffer m_texture_upload_buffer;
+
+		std::atomic_bool m_last_present_failed{false};
+		std::atomic_bool m_present_done{true};
+		std::mutex m_present_mutex;
+		std::condition_variable m_present_queued_cv;
+		std::condition_variable m_present_done_cv;
+		std::thread m_present_thread;
+		std::atomic_bool m_present_thread_done{false};
+
+		struct QueuedPresent
+		{
+			SwapChain* swap_chain;
+			u32 command_buffer_index;
+			u32 spin_cycles;
+		};
+
+		QueuedPresent m_queued_present = {};
+
+		std::map<u32, VkRenderPass> m_render_pass_cache;
+
+		VkDebugUtilsMessengerEXT m_debug_messenger_callback = VK_NULL_HANDLE;
+
+		VkQueueFamilyProperties m_graphics_queue_properties = {};
+		VkPhysicalDeviceFeatures m_device_features = {};
+		VkPhysicalDeviceProperties m_device_properties = {};
+		VkPhysicalDeviceMemoryProperties m_device_memory_properties = {};
+		VkPhysicalDeviceDriverPropertiesKHR m_device_driver_properties = {};
+		OptionalExtensions m_optional_extensions = {};
+	};
+
+} // namespace Vulkan
+
+extern std::unique_ptr<Vulkan::Context> g_vulkan_context;
--- a/common/Vulkan/EntryPoints.h
+++ b/common/Vulkan/EntryPoints.h
@@ -0,0 +1,237 @@
+/*  PCSX2 - PS2 Emulator for PCs
+ *  Copyright (C) 2002-2021  PCSX2 Dev Team
+ *
+ *  PCSX2 is free software: you can redistribute it and/or modify it under the terms
+ *  of the GNU Lesser General Public License as published by the Free Software Found-
+ *  ation, either version 3 of the License, or (at your option) any later version.
+ *
+ *  PCSX2 is distributed in the hope that it will be useful, but WITHOUT ANY WARRANTY;
+ *  without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR
+ *  PURPOSE.  See the GNU General Public License for more details.
+ *
+ *  You should have received a copy of the GNU General Public License along with PCSX2.
+ *  If not, see <http://www.gnu.org/licenses/>.
+ */
+
+#pragma once
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+// We abuse the preprocessor here to only need to specify function names once.
+// Function names are prefixed so to not conflict with system symbols at runtime.
+#define VULKAN_MODULE_ENTRY_POINT(name, required) extern PFN_##name pcsx2_##name;
+#define VULKAN_INSTANCE_ENTRY_POINT(name, required) extern PFN_##name pcsx2_##name;
+#define VULKAN_DEVICE_ENTRY_POINT(name, required) extern PFN_##name pcsx2_##name;
+#define VULKAN_DEFINE_NAME_PREFIX pcsx2_
+#include "EntryPoints.inl"
+#undef VULKAN_DEFINE_NAME_PREFIX
+#undef VULKAN_DEVICE_ENTRY_POINT
+#undef VULKAN_INSTANCE_ENTRY_POINT
+#undef VULKAN_MODULE_ENTRY_POINT
+
+#ifdef __cplusplus
+}
+#endif
+
+#define vkCreateInstance pcsx2_vkCreateInstance
+#define vkGetInstanceProcAddr pcsx2_vkGetInstanceProcAddr
+#define vkEnumerateInstanceExtensionProperties pcsx2_vkEnumerateInstanceExtensionProperties
+#define vkEnumerateInstanceLayerProperties pcsx2_vkEnumerateInstanceLayerProperties
+#define vkEnumerateInstanceVersion pcsx2_vkEnumerateInstanceVersion
+
+#define vkGetDeviceProcAddr pcsx2_vkGetDeviceProcAddr
+#define vkDestroyInstance pcsx2_vkDestroyInstance
+#define vkEnumeratePhysicalDevices pcsx2_vkEnumeratePhysicalDevices
+#define vkGetPhysicalDeviceFeatures pcsx2_vkGetPhysicalDeviceFeatures
+#define vkGetPhysicalDeviceFormatProperties pcsx2_vkGetPhysicalDeviceFormatProperties
+#define vkGetPhysicalDeviceImageFormatProperties pcsx2_vkGetPhysicalDeviceImageFormatProperties
+#define vkGetPhysicalDeviceProperties pcsx2_vkGetPhysicalDeviceProperties
+#define vkGetPhysicalDeviceQueueFamilyProperties pcsx2_vkGetPhysicalDeviceQueueFamilyProperties
+#define vkGetPhysicalDeviceMemoryProperties pcsx2_vkGetPhysicalDeviceMemoryProperties
+#define vkCreateDevice pcsx2_vkCreateDevice
+#define vkEnumerateDeviceExtensionProperties pcsx2_vkEnumerateDeviceExtensionProperties
+#define vkEnumerateDeviceLayerProperties pcsx2_vkEnumerateDeviceLayerProperties
+#define vkGetPhysicalDeviceSparseImageFormatProperties pcsx2_vkGetPhysicalDeviceSparseImageFormatProperties
+#define vkDestroySurfaceKHR pcsx2_vkDestroySurfaceKHR
+#define vkGetPhysicalDeviceSurfaceSupportKHR pcsx2_vkGetPhysicalDeviceSurfaceSupportKHR
+#define vkGetPhysicalDeviceSurfaceCapabilitiesKHR pcsx2_vkGetPhysicalDeviceSurfaceCapabilitiesKHR
+#define vkGetPhysicalDeviceSurfaceFormatsKHR pcsx2_vkGetPhysicalDeviceSurfaceFormatsKHR
+#define vkGetPhysicalDeviceSurfacePresentModesKHR pcsx2_vkGetPhysicalDeviceSurfacePresentModesKHR
+#define vkCreateWin32SurfaceKHR pcsx2_vkCreateWin32SurfaceKHR
+#define vkGetPhysicalDeviceWin32PresentationSupportKHR pcsx2_vkGetPhysicalDeviceWin32PresentationSupportKHR
+#define vkCreateXlibSurfaceKHR pcsx2_vkCreateXlibSurfaceKHR
+#define vkGetPhysicalDeviceXlibPresentationSupportKHR pcsx2_vkGetPhysicalDeviceXlibPresentationSupportKHR
+#define vkCreateWaylandSurfaceKHR pcsx2_vkCreateWaylandSurfaceKHR
+#define vkCreateAndroidSurfaceKHR pcsx2_vkCreateAndroidSurfaceKHR
+#define vkCreateMacOSSurfaceMVK pcsx2_vkCreateMacOSSurfaceMVK
+#define vkCreateMetalSurfaceEXT pcsx2_vkCreateMetalSurfaceEXT
+
+// VK_EXT_debug_utils
+#define vkCmdBeginDebugUtilsLabelEXT pcsx2_vkCmdBeginDebugUtilsLabelEXT
+#define vkCmdEndDebugUtilsLabelEXT pcsx2_vkCmdEndDebugUtilsLabelEXT
+#define vkCmdInsertDebugUtilsLabelEXT pcsx2_vkCmdInsertDebugUtilsLabelEXT
+#define vkCreateDebugUtilsMessengerEXT pcsx2_vkCreateDebugUtilsMessengerEXT
+#define vkDestroyDebugUtilsMessengerEXT pcsx2_vkDestroyDebugUtilsMessengerEXT
+#define vkQueueBeginDebugUtilsLabelEXT pcsx2_vkQueueBeginDebugUtilsLabelEXT
+#define vkQueueEndDebugUtilsLabelEXT pcsx2_vkQueueEndDebugUtilsLabelEXT
+#define vkQueueInsertDebugUtilsLabelEXT pcsx2_vkQueueInsertDebugUtilsLabelEXT
+#define vkSetDebugUtilsObjectNameEXT pcsx2_vkSetDebugUtilsObjectNameEXT
+#define vkSetDebugUtilsObjectTagEXT pcsx2_vkSetDebugUtilsObjectTagEXT
+#define vkSubmitDebugUtilsMessageEXT pcsx2_vkSubmitDebugUtilsMessageEXT
+
+#define vkGetPhysicalDeviceSurfaceCapabilities2KHR pcsx2_vkGetPhysicalDeviceSurfaceCapabilities2KHR
+#define vkGetPhysicalDeviceDisplayPropertiesKHR pcsx2_vkGetPhysicalDeviceDisplayPropertiesKHR
+#define vkGetPhysicalDeviceDisplayPlanePropertiesKHR pcsx2_vkGetPhysicalDeviceDisplayPlanePropertiesKHR
+#define vkGetDisplayPlaneSupportedDisplaysKHR pcsx2_vkGetDisplayPlaneSupportedDisplaysKHR
+#define vkGetDisplayModePropertiesKHR pcsx2_vkGetDisplayModePropertiesKHR
+#define vkCreateDisplayModeKHR pcsx2_vkCreateDisplayModeKHR
+#define vkGetDisplayPlaneCapabilitiesKHR pcsx2_vkGetDisplayPlaneCapabilitiesKHR
+#define vkCreateDisplayPlaneSurfaceKHR pcsx2_vkCreateDisplayPlaneSurfaceKHR
+
+// Vulkan 1.1 functions.
+#define vkGetPhysicalDeviceFeatures2 pcsx2_vkGetPhysicalDeviceFeatures2
+#define vkGetPhysicalDeviceProperties2 pcsx2_vkGetPhysicalDeviceProperties2
+#define vkGetPhysicalDeviceMemoryProperties2 pcsx2_vkGetPhysicalDeviceMemoryProperties2
+
+#define vkDestroyDevice pcsx2_vkDestroyDevice
+#define vkGetDeviceQueue pcsx2_vkGetDeviceQueue
+#define vkQueueSubmit pcsx2_vkQueueSubmit
+#define vkQueueWaitIdle pcsx2_vkQueueWaitIdle
+#define vkDeviceWaitIdle pcsx2_vkDeviceWaitIdle
+#define vkAllocateMemory pcsx2_vkAllocateMemory
+#define vkFreeMemory pcsx2_vkFreeMemory
+#define vkMapMemory pcsx2_vkMapMemory
+#define vkUnmapMemory pcsx2_vkUnmapMemory
+#define vkFlushMappedMemoryRanges pcsx2_vkFlushMappedMemoryRanges
+#define vkInvalidateMappedMemoryRanges pcsx2_vkInvalidateMappedMemoryRanges
+#define vkGetDeviceMemoryCommitment pcsx2_vkGetDeviceMemoryCommitment
+#define vkBindBufferMemory pcsx2_vkBindBufferMemory
+#define vkBindImageMemory pcsx2_vkBindImageMemory
+#define vkGetBufferMemoryRequirements pcsx2_vkGetBufferMemoryRequirements
+#define vkGetImageMemoryRequirements pcsx2_vkGetImageMemoryRequirements
+#define vkGetImageSparseMemoryRequirements pcsx2_vkGetImageSparseMemoryRequirements
+#define vkQueueBindSparse pcsx2_vkQueueBindSparse
+#define vkCreateFence pcsx2_vkCreateFence
+#define vkDestroyFence pcsx2_vkDestroyFence
+#define vkResetFences pcsx2_vkResetFences
+#define vkGetFenceStatus pcsx2_vkGetFenceStatus
+#define vkWaitForFences pcsx2_vkWaitForFences
+#define vkCreateSemaphore pcsx2_vkCreateSemaphore
+#define vkDestroySemaphore pcsx2_vkDestroySemaphore
+#define vkCreateEvent pcsx2_vkCreateEvent
+#define vkDestroyEvent pcsx2_vkDestroyEvent
+#define vkGetEventStatus pcsx2_vkGetEventStatus
+#define vkSetEvent pcsx2_vkSetEvent
+#define vkResetEvent pcsx2_vkResetEvent
+#define vkCreateQueryPool pcsx2_vkCreateQueryPool
+#define vkDestroyQueryPool pcsx2_vkDestroyQueryPool
+#define vkGetQueryPoolResults pcsx2_vkGetQueryPoolResults
+#define vkCreateBuffer pcsx2_vkCreateBuffer
+#define vkDestroyBuffer pcsx2_vkDestroyBuffer
+#define vkCreateBufferView pcsx2_vkCreateBufferView
+#define vkDestroyBufferView pcsx2_vkDestroyBufferView
+#define vkCreateImage pcsx2_vkCreateImage
+#define vkDestroyImage pcsx2_vkDestroyImage
+#define vkGetImageSubresourceLayout pcsx2_vkGetImageSubresourceLayout
+#define vkCreateImageView pcsx2_vkCreateImageView
+#define vkDestroyImageView pcsx2_vkDestroyImageView
+#define vkCreateShaderModule pcsx2_vkCreateShaderModule
+#define vkDestroyShaderModule pcsx2_vkDestroyShaderModule
+#define vkCreatePipelineCache pcsx2_vkCreatePipelineCache
+#define vkDestroyPipelineCache pcsx2_vkDestroyPipelineCache
+#define vkGetPipelineCacheData pcsx2_vkGetPipelineCacheData
+#define vkMergePipelineCaches pcsx2_vkMergePipelineCaches
+#define vkCreateGraphicsPipelines pcsx2_vkCreateGraphicsPipelines
+#define vkCreateComputePipelines pcsx2_vkCreateComputePipelines
+#define vkDestroyPipeline pcsx2_vkDestroyPipeline
+#define vkCreatePipelineLayout pcsx2_vkCreatePipelineLayout
+#define vkDestroyPipelineLayout pcsx2_vkDestroyPipelineLayout
+#define vkCreateSampler pcsx2_vkCreateSampler
+#define vkDestroySampler pcsx2_vkDestroySampler
+#define vkCreateDescriptorSetLayout pcsx2_vkCreateDescriptorSetLayout
+#define vkDestroyDescriptorSetLayout pcsx2_vkDestroyDescriptorSetLayout
+#define vkCreateDescriptorPool pcsx2_vkCreateDescriptorPool
+#define vkDestroyDescriptorPool pcsx2_vkDestroyDescriptorPool
+#define vkResetDescriptorPool pcsx2_vkResetDescriptorPool
+#define vkAllocateDescriptorSets pcsx2_vkAllocateDescriptorSets
+#define vkFreeDescriptorSets pcsx2_vkFreeDescriptorSets
+#define vkUpdateDescriptorSets pcsx2_vkUpdateDescriptorSets
+#define vkCreateFramebuffer pcsx2_vkCreateFramebuffer
+#define vkDestroyFramebuffer pcsx2_vkDestroyFramebuffer
+#define vkCreateRenderPass pcsx2_vkCreateRenderPass
+#define vkDestroyRenderPass pcsx2_vkDestroyRenderPass
+#define vkGetRenderAreaGranularity pcsx2_vkGetRenderAreaGranularity
+#define vkCreateCommandPool pcsx2_vkCreateCommandPool
+#define vkDestroyCommandPool pcsx2_vkDestroyCommandPool
+#define vkResetCommandPool pcsx2_vkResetCommandPool
+#define vkAllocateCommandBuffers pcsx2_vkAllocateCommandBuffers
+#define vkFreeCommandBuffers pcsx2_vkFreeCommandBuffers
+#define vkBeginCommandBuffer pcsx2_vkBeginCommandBuffer
+#define vkEndCommandBuffer pcsx2_vkEndCommandBuffer
+#define vkResetCommandBuffer pcsx2_vkResetCommandBuffer
+#define vkCmdBindPipeline pcsx2_vkCmdBindPipeline
+#define vkCmdSetViewport pcsx2_vkCmdSetViewport
+#define vkCmdSetScissor pcsx2_vkCmdSetScissor
+#define vkCmdSetLineWidth pcsx2_vkCmdSetLineWidth
+#define vkCmdSetDepthBias pcsx2_vkCmdSetDepthBias
+#define vkCmdSetBlendConstants pcsx2_vkCmdSetBlendConstants
+#define vkCmdSetDepthBounds pcsx2_vkCmdSetDepthBounds
+#define vkCmdSetStencilCompareMask pcsx2_vkCmdSetStencilCompareMask
+#define vkCmdSetStencilWriteMask pcsx2_vkCmdSetStencilWriteMask
+#define vkCmdSetStencilReference pcsx2_vkCmdSetStencilReference
+#define vkCmdBindDescriptorSets pcsx2_vkCmdBindDescriptorSets
+#define vkCmdBindIndexBuffer pcsx2_vkCmdBindIndexBuffer
+#define vkCmdBindVertexBuffers pcsx2_vkCmdBindVertexBuffers
+#define vkCmdDraw pcsx2_vkCmdDraw
+#define vkCmdDrawIndexed pcsx2_vkCmdDrawIndexed
+#define vkCmdDrawIndirect pcsx2_vkCmdDrawIndirect
+#define vkCmdDrawIndexedIndirect pcsx2_vkCmdDrawIndexedIndirect
+#define vkCmdDispatch pcsx2_vkCmdDispatch
+#define vkCmdDispatchIndirect pcsx2_vkCmdDispatchIndirect
+#define vkCmdCopyBuffer pcsx2_vkCmdCopyBuffer
+#define vkCmdCopyImage pcsx2_vkCmdCopyImage
+#define vkCmdBlitImage pcsx2_vkCmdBlitImage
+#define vkCmdCopyBufferToImage pcsx2_vkCmdCopyBufferToImage
+#define vkCmdCopyImageToBuffer pcsx2_vkCmdCopyImageToBuffer
+#define vkCmdUpdateBuffer pcsx2_vkCmdUpdateBuffer
+#define vkCmdFillBuffer pcsx2_vkCmdFillBuffer
+#define vkCmdClearColorImage pcsx2_vkCmdClearColorImage
+#define vkCmdClearDepthStencilImage pcsx2_vkCmdClearDepthStencilImage
+#define vkCmdClearAttachments pcsx2_vkCmdClearAttachments
+#define vkCmdResolveImage pcsx2_vkCmdResolveImage
+#define vkCmdSetEvent pcsx2_vkCmdSetEvent
+#define vkCmdResetEvent pcsx2_vkCmdResetEvent
+#define vkCmdWaitEvents pcsx2_vkCmdWaitEvents
+#define vkCmdPipelineBarrier pcsx2_vkCmdPipelineBarrier
+#define vkCmdBeginQuery pcsx2_vkCmdBeginQuery
+#define vkCmdEndQuery pcsx2_vkCmdEndQuery
+#define vkCmdResetQueryPool pcsx2_vkCmdResetQueryPool
+#define vkCmdWriteTimestamp pcsx2_vkCmdWriteTimestamp
+#define vkCmdCopyQueryPoolResults pcsx2_vkCmdCopyQueryPoolResults
+#define vkCmdPushConstants pcsx2_vkCmdPushConstants
+#define vkCmdBeginRenderPass pcsx2_vkCmdBeginRenderPass
+#define vkCmdNextSubpass pcsx2_vkCmdNextSubpass
+#define vkCmdEndRenderPass pcsx2_vkCmdEndRenderPass
+#define vkCmdExecuteCommands pcsx2_vkCmdExecuteCommands
+#define vkCreateSwapchainKHR pcsx2_vkCreateSwapchainKHR
+#define vkDestroySwapchainKHR pcsx2_vkDestroySwapchainKHR
+#define vkGetSwapchainImagesKHR pcsx2_vkGetSwapchainImagesKHR
+#define vkAcquireNextImageKHR pcsx2_vkAcquireNextImageKHR
+#define vkQueuePresentKHR pcsx2_vkQueuePresentKHR
+
+// Vulkan 1.1 functions.
+#define vkGetBufferMemoryRequirements2 pcsx2_vkGetBufferMemoryRequirements2
+#define vkGetImageMemoryRequirements2 pcsx2_vkGetImageMemoryRequirements2
+#define vkBindBufferMemory2 pcsx2_vkBindBufferMemory2
+#define vkBindImageMemory2 pcsx2_vkBindImageMemory2
+
+#ifdef SUPPORTS_VULKAN_EXCLUSIVE_FULLSCREEN
+#define vkAcquireFullScreenExclusiveModeEXT pcsx2_vkAcquireFullScreenExclusiveModeEXT
+#define vkReleaseFullScreenExclusiveModeEXT pcsx2_vkReleaseFullScreenExclusiveModeEXT
+#endif
+
+// VK_EXT_calibrated_timestamps
+#define vkGetCalibratedTimestampsEXT pcsx2_vkGetCalibratedTimestampsEXT
+#define vkGetPhysicalDeviceCalibrateableTimeDomainsEXT pcsx2_vkGetPhysicalDeviceCalibrateableTimeDomainsEXT
--- a/pcsx2/GS/Renderers/Vulkan/VKEntryPoints.inl
+++ b/pcsx2/GS/Renderers/Vulkan/VKEntryPoints.inl
@@ -64,6 +64,14 @@ VULKAN_INSTANCE_ENTRY_POINT(vkGetPhysicalDeviceXlibPresentationSupportKHR, false
 VULKAN_INSTANCE_ENTRY_POINT(vkCreateWaylandSurfaceKHR, false)
 #endif

+#if defined(VK_USE_PLATFORM_ANDROID_KHR)
+VULKAN_INSTANCE_ENTRY_POINT(vkCreateAndroidSurfaceKHR, false)
+#endif
+
+#if defined(VK_USE_PLATFORM_MACOS_MVK)
+VULKAN_INSTANCE_ENTRY_POINT(vkCreateMacOSSurfaceMVK, false)
+#endif
+
 #if defined(VK_USE_PLATFORM_METAL_EXT)
 VULKAN_INSTANCE_ENTRY_POINT(vkCreateMetalSurfaceEXT, false)
 #endif
@@ -235,7 +243,7 @@ VULKAN_DEVICE_ENTRY_POINT(vkGetImageMemoryRequirements2, true)
 VULKAN_DEVICE_ENTRY_POINT(vkBindBufferMemory2, true)
 VULKAN_DEVICE_ENTRY_POINT(vkBindImageMemory2, true)

-#ifdef _WIN32
+#ifdef SUPPORTS_VULKAN_EXCLUSIVE_FULLSCREEN
 VULKAN_DEVICE_ENTRY_POINT(vkAcquireFullScreenExclusiveModeEXT, false)
 VULKAN_DEVICE_ENTRY_POINT(vkReleaseFullScreenExclusiveModeEXT, false)
 #endif
--- a/common/Vulkan/Loader.cpp
+++ b/common/Vulkan/Loader.cpp
@@ -0,0 +1,260 @@
+/*  PCSX2 - PS2 Emulator for PCs
+ *  Copyright (C) 2002-2021  PCSX2 Dev Team
+ *
+ *  PCSX2 is free software: you can redistribute it and/or modify it under the terms
+ *  of the GNU Lesser General Public License as published by the Free Software Found-
+ *  ation, either version 3 of the License, or (at your option) any later version.
+ *
+ *  PCSX2 is distributed in the hope that it will be useful, but WITHOUT ANY WARRANTY;
+ *  without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR
+ *  PURPOSE.  See the GNU General Public License for more details.
+ *
+ *  You should have received a copy of the GNU General Public License along with PCSX2.
+ *  If not, see <http://www.gnu.org/licenses/>.
+ */
+
+#include <atomic>
+#include <cstdarg>
+#include <cstdio>
+#include <cstdlib>
+#include <cstring>
+#include <string>
+
+#include "Loader.h"
+
+#ifndef _WIN32
+#include <dlfcn.h>
+#endif
+
+#ifdef __APPLE__
+#include <mach-o/dyld.h>
+#endif
+
+extern "C" {
+
+#define VULKAN_MODULE_ENTRY_POINT(name, required) PFN_##name pcsx2_##name;
+#define VULKAN_INSTANCE_ENTRY_POINT(name, required) PFN_##name pcsx2_##name;
+#define VULKAN_DEVICE_ENTRY_POINT(name, required) PFN_##name pcsx2_##name;
+#include "EntryPoints.inl"
+#undef VULKAN_DEVICE_ENTRY_POINT
+#undef VULKAN_INSTANCE_ENTRY_POINT
+#undef VULKAN_MODULE_ENTRY_POINT
+
+}
+
+namespace Vulkan
+{
+	void ResetVulkanLibraryFunctionPointers()
+	{
+#define VULKAN_MODULE_ENTRY_POINT(name, required) pcsx2_##name = nullptr;
+#define VULKAN_INSTANCE_ENTRY_POINT(name, required) pcsx2_##name = nullptr;
+#define VULKAN_DEVICE_ENTRY_POINT(name, required) pcsx2_##name = nullptr;
+#include "EntryPoints.inl"
+#undef VULKAN_DEVICE_ENTRY_POINT
+#undef VULKAN_INSTANCE_ENTRY_POINT
+#undef VULKAN_MODULE_ENTRY_POINT
+	}
+
+#if defined(_WIN32)
+
+	static HMODULE vulkan_module;
+	static std::atomic_int vulkan_module_ref_count = {0};
+
+	bool LoadVulkanLibrary()
+	{
+		// Not thread safe if a second thread calls the loader whilst the first is still in-progress.
+		if (vulkan_module)
+		{
+			vulkan_module_ref_count++;
+			return true;
+		}
+
+		vulkan_module = LoadLibraryA("vulkan-1.dll");
+		if (!vulkan_module)
+		{
+			std::fprintf(stderr, "Failed to load vulkan-1.dll\n");
+			return false;
+		}
+
+		bool required_functions_missing = false;
+		auto LoadFunction = [&](FARPROC* func_ptr, const char* name, bool is_required) {
+			*func_ptr = GetProcAddress(vulkan_module, name);
+			if (!(*func_ptr) && is_required)
+			{
+				std::fprintf(stderr, "Vulkan: Failed to load required module function %s\n", name);
+				required_functions_missing = true;
+			}
+		};
+
+#define VULKAN_MODULE_ENTRY_POINT(name, required) LoadFunction(reinterpret_cast<FARPROC*>(&name), #name, required);
+#include "EntryPoints.inl"
+#undef VULKAN_MODULE_ENTRY_POINT
+
+		if (required_functions_missing)
+		{
+			ResetVulkanLibraryFunctionPointers();
+			FreeLibrary(vulkan_module);
+			vulkan_module = nullptr;
+			return false;
+		}
+
+		vulkan_module_ref_count++;
+		return true;
+	}
+
+	void UnloadVulkanLibrary()
+	{
+		if ((--vulkan_module_ref_count) > 0)
+			return;
+
+		ResetVulkanLibraryFunctionPointers();
+		FreeLibrary(vulkan_module);
+		vulkan_module = nullptr;
+	}
+
+#else
+
+	static void* vulkan_module;
+	static std::atomic_int vulkan_module_ref_count = {0};
+
+	bool LoadVulkanLibrary()
+	{
+		// Not thread safe if a second thread calls the loader whilst the first is still in-progress.
+		if (vulkan_module)
+		{
+			vulkan_module_ref_count++;
+			return true;
+		}
+
+#if defined(__APPLE__)
+		// Check if a path to a specific Vulkan library has been specified.
+		char* libvulkan_env = getenv("LIBVULKAN_PATH");
+		if (libvulkan_env)
+			vulkan_module = dlopen(libvulkan_env, RTLD_NOW);
+		if (!vulkan_module)
+		{
+			unsigned path_size = 0;
+			_NSGetExecutablePath(nullptr, &path_size);
+			std::string path;
+			path.resize(path_size);
+			if (_NSGetExecutablePath(path.data(), &path_size) == 0)
+			{
+				path[path_size] = 0;
+
+				size_t pos = path.rfind('/');
+				if (pos != std::string::npos)
+				{
+					path.erase(pos);
+					path += "/../Frameworks/libvulkan.dylib";
+					vulkan_module = dlopen(path.c_str(), RTLD_NOW);
+					if (!vulkan_module)
+					{
+						path.erase(pos);
+						path += "/../Frameworks/libMoltenVK.dylib";
+						vulkan_module = dlopen(path.c_str(), RTLD_NOW);
+					}
+				}
+			}
+		}
+		if (!vulkan_module)
+		{
+			vulkan_module = dlopen("libvulkan.dylib", RTLD_NOW);
+			if (!vulkan_module)
+				vulkan_module = dlopen("libMoltenVK.dylib", RTLD_NOW);
+		}
+#else
+		// Names of libraries to search. Desktop should use libvulkan.so.1 or libvulkan.so.
+		static const char* search_lib_names[] = {"libvulkan.so.1", "libvulkan.so"};
+		for (size_t i = 0; i < sizeof(search_lib_names) / sizeof(search_lib_names[0]); i++)
+		{
+			vulkan_module = dlopen(search_lib_names[i], RTLD_NOW);
+			if (vulkan_module)
+				break;
+		}
+#endif
+
+		if (!vulkan_module)
+		{
+			std::fprintf(stderr, "Failed to load or locate libvulkan.so\n");
+			return false;
+		}
+
+		bool required_functions_missing = false;
+		auto LoadFunction = [&](void** func_ptr, const char* name, bool is_required) {
+			*func_ptr = dlsym(vulkan_module, name);
+			if (!(*func_ptr) && is_required)
+			{
+				std::fprintf(stderr, "Vulkan: Failed to load required module function %s\n", name);
+				required_functions_missing = true;
+			}
+		};
+
+#define VULKAN_MODULE_ENTRY_POINT(name, required) LoadFunction(reinterpret_cast<void**>(&name), #name, required);
+#include "EntryPoints.inl"
+#undef VULKAN_MODULE_ENTRY_POINT
+
+		if (required_functions_missing)
+		{
+			ResetVulkanLibraryFunctionPointers();
+			dlclose(vulkan_module);
+			vulkan_module = nullptr;
+			return false;
+		}
+
+		vulkan_module_ref_count++;
+		return true;
+	}
+
+	void UnloadVulkanLibrary()
+	{
+		if ((--vulkan_module_ref_count) > 0)
+			return;
+
+		ResetVulkanLibraryFunctionPointers();
+		dlclose(vulkan_module);
+		vulkan_module = nullptr;
+	}
+
+#endif
+
+	bool LoadVulkanInstanceFunctions(VkInstance instance)
+	{
+		bool required_functions_missing = false;
+		auto LoadFunction = [&](PFN_vkVoidFunction* func_ptr, const char* name, bool is_required) {
+			*func_ptr = vkGetInstanceProcAddr(instance, name);
+			if (!(*func_ptr) && is_required)
+			{
+				std::fprintf(stderr, "Vulkan: Failed to load required instance function %s\n", name);
+				required_functions_missing = true;
+			}
+		};
+
+#define VULKAN_INSTANCE_ENTRY_POINT(name, required) \
+	LoadFunction(reinterpret_cast<PFN_vkVoidFunction*>(&name), #name, required);
+#include "EntryPoints.inl"
+#undef VULKAN_INSTANCE_ENTRY_POINT
+
+		return !required_functions_missing;
+	}
+
+	bool LoadVulkanDeviceFunctions(VkDevice device)
+	{
+		bool required_functions_missing = false;
+		auto LoadFunction = [&](PFN_vkVoidFunction* func_ptr, const char* name, bool is_required) {
+			*func_ptr = vkGetDeviceProcAddr(device, name);
+			if (!(*func_ptr) && is_required)
+			{
+				std::fprintf(stderr, "Vulkan: Failed to load required device function %s\n", name);
+				required_functions_missing = true;
+			}
+		};
+
+#define VULKAN_DEVICE_ENTRY_POINT(name, required) \
+	LoadFunction(reinterpret_cast<PFN_vkVoidFunction*>(&name), #name, required);
+#include "EntryPoints.inl"
+#undef VULKAN_DEVICE_ENTRY_POINT
+
+		return !required_functions_missing;
+	}
+
+} // namespace Vulkan
--- a/Show More
+++ b/Show More