diff --git a/CMakeLists.txt b/CMakeLists.txt
index 163ea2c943..04bcdde4c2 100644
--- a/CMakeLists.txt
+++ b/CMakeLists.txt
@@ -980,6 +980,10 @@ else()
   set(DOLPHIN_WC_IS_STABLE "0")
 endif()
 
+# Remove in-tree revision information generated by Visual Studio
+# This is because the compiler will check in-tree first and use this, even if it is outdated
+file(REMOVE "${PROJECT_SOURCE_DIR}/Source/Core/Common/scmrev.h")
+
 configure_file(
   "${PROJECT_SOURCE_DIR}/Source/Core/Common/scmrev.h.in"
   "${PROJECT_BINARY_DIR}/Source/Core/Common/scmrev.h"
diff --git a/Externals/hidapi/CMakeLists.txt b/Externals/hidapi/CMakeLists.txt
index 1cf77404f0..a5d88df5fe 100644
--- a/Externals/hidapi/CMakeLists.txt
+++ b/Externals/hidapi/CMakeLists.txt
@@ -9,7 +9,7 @@ if(APPLE)
 elseif(MSVC)
   target_sources(hidapi PRIVATE windows/hid.c)
 else()
-  find_package(Libudev)
+  find_package(LIBUDEV)
   if(CMAKE_SYSTEM_NAME STREQUAL "Linux" AND LIBUDEV_FOUND)
     target_sources(hidapi PRIVATE linux/hid.c)
     target_link_libraries(hidapi PRIVATE udev)
diff --git a/Installer/Installer.nsi b/Installer/Installer.nsi
index c08ada69c9..1ad09ddce8 100644
--- a/Installer/Installer.nsi
+++ b/Installer/Installer.nsi
@@ -154,20 +154,6 @@ Section "Base" SEC01
   
   SetOutPath "$TEMP"
   SetOverwrite on
-  File /r "dxredist"
-  File /r "vcredist"
-SectionEnd
-
-Section "DirectX Runtime" SEC02
-   DetailPrint "Running DirectX runtime setup..."
-   ExecWait '"$TEMP\dxredist\DXSETUP.exe" /silent'
-   DetailPrint "Finished DirectX runtime setup"
-SectionEnd
-
-Section "Visual C++ 2015 Redistributable" SEC03
-   DetailPrint "Running Visual C++ 2015 Redistributable setup..."
-   ExecWait '"$TEMP\vcredist\vc_redist.x64.exe" /install /quiet /norestart'
-   DetailPrint "Finished Visual C++ 2015 Redistributable setup"
 SectionEnd
 
 Section -AdditionalIcons
@@ -193,8 +179,6 @@ SectionEnd
 ; Section descriptions
 !insertmacro MUI_FUNCTION_DESCRIPTION_BEGIN
   !insertmacro MUI_DESCRIPTION_TEXT ${SEC01} "Installs all files required to run the Dolphin Emulator."
-  !insertmacro MUI_DESCRIPTION_TEXT ${SEC02} "Installs the recommended DirectX runtime libraries that are needed by Dolphin."
-  !insertmacro MUI_DESCRIPTION_TEXT ${SEC03} "Installs the required Visual C++ 2015 Redistributable that is needed by Dolphin."
 !insertmacro MUI_FUNCTION_DESCRIPTION_END
 
 Section Uninstall
diff --git a/Installer/dxredist/APR2007_xinput_x64.cab b/Installer/dxredist/APR2007_xinput_x64.cab
deleted file mode 100644
index 732f8a8f36..0000000000
Binary files a/Installer/dxredist/APR2007_xinput_x64.cab and /dev/null differ
diff --git a/Installer/dxredist/APR2007_xinput_x86.cab b/Installer/dxredist/APR2007_xinput_x86.cab
deleted file mode 100644
index f414d55571..0000000000
Binary files a/Installer/dxredist/APR2007_xinput_x86.cab and /dev/null differ
diff --git a/Installer/dxredist/DSETUP.dll b/Installer/dxredist/DSETUP.dll
deleted file mode 100644
index 691025af7e..0000000000
Binary files a/Installer/dxredist/DSETUP.dll and /dev/null differ
diff --git a/Installer/dxredist/DXSETUP.exe b/Installer/dxredist/DXSETUP.exe
deleted file mode 100644
index 5d062aa978..0000000000
Binary files a/Installer/dxredist/DXSETUP.exe and /dev/null differ
diff --git a/Installer/dxredist/dsetup32.dll b/Installer/dxredist/dsetup32.dll
deleted file mode 100644
index 1781afa4b0..0000000000
Binary files a/Installer/dxredist/dsetup32.dll and /dev/null differ
diff --git a/Installer/dxredist/dxupdate.cab b/Installer/dxredist/dxupdate.cab
deleted file mode 100644
index ed3b5b89f5..0000000000
Binary files a/Installer/dxredist/dxupdate.cab and /dev/null differ
diff --git a/Installer/vcredist/vc_redist.x64.exe b/Installer/vcredist/vc_redist.x64.exe
deleted file mode 100644
index f986317bff..0000000000
Binary files a/Installer/vcredist/vc_redist.x64.exe and /dev/null differ
diff --git a/Readme.md b/Readme.md
index 699e943c44..a6747c9cba 100644
--- a/Readme.md
+++ b/Readme.md
@@ -16,7 +16,7 @@ Primehack is now supported on MacOS thanks to the efforts of [Brandon Sorensen](
 
 # Original Dolphin Readme file contents:
 
-[Homepage](https://dolphin-emu.org/) | [Project Site](https://github.com/dolphin-emu/dolphin) | [Buildbot](https://dolphin.ci) | [Forums](https://forums.dolphin-emu.org) | [Wiki](https://wiki.dolphin-emu.org) | [Github Wiki](https://github.com/dolphin-emu/dolphin/wiki) | [Issue Tracker](https://bugs.dolphin-emu.org/projects/emulator/issues) | [Coding Style](https://github.com/dolphin-emu/dolphin/blob/master/Contributing.md) | [Transifex Page](https://www.transifex.com/projects/p/dolphin-emu)
+[Homepage](https://dolphin-emu.org/) | [Project Site](https://github.com/dolphin-emu/dolphin) | [Buildbot](https://dolphin.ci/) | [Forums](https://forums.dolphin-emu.org/) | [Wiki](https://wiki.dolphin-emu.org/) | [GitHub Wiki](https://github.com/dolphin-emu/dolphin/wiki) | [Issue Tracker](https://bugs.dolphin-emu.org/projects/emulator/issues) | [Coding Style](https://github.com/dolphin-emu/dolphin/blob/master/Contributing.md) | [Transifex Page](https://explore.transifex.com/delroth/dolphin-emu/)
 
 Dolphin is an emulator for running GameCube and Wii games on Windows,
 Linux, macOS, and recent Android devices. It's licensed under the terms
diff --git a/Source/Android/app/src/main/java/org/dolphinemu/dolphinemu/features/cheats/ui/CheatListFragment.java b/Source/Android/app/src/main/java/org/dolphinemu/dolphinemu/features/cheats/ui/CheatListFragment.java
index efc446d50e..a2cf37dba8 100644
--- a/Source/Android/app/src/main/java/org/dolphinemu/dolphinemu/features/cheats/ui/CheatListFragment.java
+++ b/Source/Android/app/src/main/java/org/dolphinemu/dolphinemu/features/cheats/ui/CheatListFragment.java
@@ -14,9 +14,10 @@ import androidx.lifecycle.ViewModelProvider;
 import androidx.recyclerview.widget.LinearLayoutManager;
 import androidx.recyclerview.widget.RecyclerView;
 
+import com.google.android.material.divider.MaterialDividerItemDecoration;
+
 import org.dolphinemu.dolphinemu.R;
 import org.dolphinemu.dolphinemu.features.cheats.model.CheatsViewModel;
-import org.dolphinemu.dolphinemu.ui.DividerItemDecoration;
 
 public class CheatListFragment extends Fragment
 {
@@ -38,6 +39,10 @@ public class CheatListFragment extends Fragment
 
     recyclerView.setAdapter(new CheatsAdapter(activity, viewModel));
     recyclerView.setLayoutManager(new LinearLayoutManager(activity));
-    recyclerView.addItemDecoration(new DividerItemDecoration(activity, null));
+
+    MaterialDividerItemDecoration divider =
+            new MaterialDividerItemDecoration(requireActivity(), LinearLayoutManager.VERTICAL);
+    divider.setLastItemDecorated(false);
+    recyclerView.addItemDecoration(divider);
   }
 }
diff --git a/Source/Android/app/src/main/java/org/dolphinemu/dolphinemu/features/settings/ui/SettingsFragment.java b/Source/Android/app/src/main/java/org/dolphinemu/dolphinemu/features/settings/ui/SettingsFragment.java
index 86a5650de5..89587ea535 100644
--- a/Source/Android/app/src/main/java/org/dolphinemu/dolphinemu/features/settings/ui/SettingsFragment.java
+++ b/Source/Android/app/src/main/java/org/dolphinemu/dolphinemu/features/settings/ui/SettingsFragment.java
@@ -14,10 +14,11 @@ import androidx.fragment.app.Fragment;
 import androidx.recyclerview.widget.LinearLayoutManager;
 import androidx.recyclerview.widget.RecyclerView;
 
+import com.google.android.material.divider.MaterialDividerItemDecoration;
+
 import org.dolphinemu.dolphinemu.R;
 import org.dolphinemu.dolphinemu.features.settings.model.Settings;
 import org.dolphinemu.dolphinemu.features.settings.model.view.SettingsItem;
-import org.dolphinemu.dolphinemu.ui.DividerItemDecoration;
 
 import java.util.ArrayList;
 import java.util.HashMap;
@@ -136,7 +137,11 @@ public final class SettingsFragment extends Fragment implements SettingsFragment
 
     recyclerView.setAdapter(mAdapter);
     recyclerView.setLayoutManager(manager);
-    recyclerView.addItemDecoration(new DividerItemDecoration(requireActivity(), null));
+
+    MaterialDividerItemDecoration divider =
+            new MaterialDividerItemDecoration(requireActivity(), LinearLayoutManager.VERTICAL);
+    divider.setLastItemDecorated(false);
+    recyclerView.addItemDecoration(divider);
 
     SettingsActivityView activity = (SettingsActivityView) getActivity();
     mPresenter.onViewCreated(menuTag, activity.getSettings());
diff --git a/Source/Android/app/src/main/java/org/dolphinemu/dolphinemu/ui/DividerItemDecoration.java b/Source/Android/app/src/main/java/org/dolphinemu/dolphinemu/ui/DividerItemDecoration.java
deleted file mode 100644
index f7a1689af5..0000000000
--- a/Source/Android/app/src/main/java/org/dolphinemu/dolphinemu/ui/DividerItemDecoration.java
+++ /dev/null
@@ -1,162 +0,0 @@
-// SPDX-License-Identifier: GPL-2.0-or-later
-
-package org.dolphinemu.dolphinemu.ui;
-
-import android.content.Context;
-import android.content.res.TypedArray;
-import android.graphics.Canvas;
-import android.graphics.Rect;
-import android.graphics.drawable.Drawable;
-import android.util.AttributeSet;
-import android.view.View;
-
-import androidx.annotation.NonNull;
-import androidx.recyclerview.widget.LinearLayoutManager;
-import androidx.recyclerview.widget.RecyclerView;
-
-/**
- * Implementation from:
- * https://gist.github.com/lapastillaroja/858caf1a82791b6c1a36
- */
-public final class DividerItemDecoration extends RecyclerView.ItemDecoration
-{
-
-  private Drawable mDivider;
-  private boolean mShowFirstDivider = false;
-  private boolean mShowLastDivider = false;
-
-  public DividerItemDecoration(Context context, AttributeSet attrs)
-  {
-    final TypedArray a = context
-            .obtainStyledAttributes(attrs, new int[]{android.R.attr.listDivider});
-    mDivider = a.getDrawable(0);
-    a.recycle();
-  }
-
-  public DividerItemDecoration(Context context, AttributeSet attrs, boolean showFirstDivider,
-          boolean showLastDivider)
-  {
-    this(context, attrs);
-    mShowFirstDivider = showFirstDivider;
-    mShowLastDivider = showLastDivider;
-  }
-
-  public DividerItemDecoration(Drawable divider)
-  {
-    mDivider = divider;
-  }
-
-  public DividerItemDecoration(Drawable divider, boolean showFirstDivider,
-          boolean showLastDivider)
-  {
-    this(divider);
-    mShowFirstDivider = showFirstDivider;
-    mShowLastDivider = showLastDivider;
-  }
-
-  @Override
-  public void getItemOffsets(@NonNull Rect outRect, @NonNull View view,
-          @NonNull RecyclerView parent,
-          @NonNull RecyclerView.State state)
-  {
-    super.getItemOffsets(outRect, view, parent, state);
-    if (mDivider == null)
-    {
-      return;
-    }
-    if (parent.getChildAdapterPosition(view) < 1)
-    {
-      return;
-    }
-
-    if (getOrientation(parent) == LinearLayoutManager.VERTICAL)
-    {
-      outRect.top = mDivider.getIntrinsicHeight();
-    }
-    else
-    {
-      outRect.left = mDivider.getIntrinsicWidth();
-    }
-  }
-
-  @Override
-  public void onDrawOver(@NonNull Canvas c, @NonNull RecyclerView parent,
-          @NonNull RecyclerView.State state)
-  {
-    if (mDivider == null)
-    {
-      super.onDrawOver(c, parent, state);
-      return;
-    }
-
-    // Initialization needed to avoid compiler warning
-    int left = 0, right = 0, top = 0, bottom = 0, size;
-    int orientation = getOrientation(parent);
-    int childCount = parent.getChildCount();
-
-    if (orientation == LinearLayoutManager.VERTICAL)
-    {
-      size = mDivider.getIntrinsicHeight();
-      left = parent.getPaddingLeft();
-      right = parent.getWidth() - parent.getPaddingRight();
-    }
-    else
-    { //horizontal
-      size = mDivider.getIntrinsicWidth();
-      top = parent.getPaddingTop();
-      bottom = parent.getHeight() - parent.getPaddingBottom();
-    }
-
-    for (int i = mShowFirstDivider ? 0 : 1; i < childCount; i++)
-    {
-      View child = parent.getChildAt(i);
-      RecyclerView.LayoutParams params = (RecyclerView.LayoutParams) child.getLayoutParams();
-
-      if (orientation == LinearLayoutManager.VERTICAL)
-      {
-        top = child.getTop() - params.topMargin;
-        bottom = top + size;
-      }
-      else
-      { //horizontal
-        left = child.getLeft() - params.leftMargin;
-        right = left + size;
-      }
-      mDivider.setBounds(left, top, right, bottom);
-      mDivider.draw(c);
-    }
-
-    // show last divider
-    if (mShowLastDivider && childCount > 0)
-    {
-      View child = parent.getChildAt(childCount - 1);
-      RecyclerView.LayoutParams params = (RecyclerView.LayoutParams) child.getLayoutParams();
-      if (orientation == LinearLayoutManager.VERTICAL)
-      {
-        top = child.getBottom() + params.bottomMargin;
-        bottom = top + size;
-      }
-      else
-      { // horizontal
-        left = child.getRight() + params.rightMargin;
-        right = left + size;
-      }
-      mDivider.setBounds(left, top, right, bottom);
-      mDivider.draw(c);
-    }
-  }
-
-  private int getOrientation(RecyclerView parent)
-  {
-    if (parent.getLayoutManager() instanceof LinearLayoutManager)
-    {
-      LinearLayoutManager layoutManager = (LinearLayoutManager) parent.getLayoutManager();
-      return layoutManager.getOrientation();
-    }
-    else
-    {
-      throw new IllegalStateException(
-              "DividerItemDecoration can only be used with a LinearLayoutManager.");
-    }
-  }
-}
diff --git a/Source/Android/app/src/main/res/layout-land/activity_user_data.xml b/Source/Android/app/src/main/res/layout-land/activity_user_data.xml
index 597e598266..24863dcd5f 100644
--- a/Source/Android/app/src/main/res/layout-land/activity_user_data.xml
+++ b/Source/Android/app/src/main/res/layout-land/activity_user_data.xml
@@ -50,7 +50,7 @@
                 app:layout_constraintWidth_max="400dp"
                 app:layout_constraintEnd_toStartOf="@id/divider"
                 app:layout_constraintStart_toStartOf="parent"
-                app:layout_constraintTop_toTopOf="@id/divider"
+                app:layout_constraintTop_toTopOf="parent"
                 tools:text="@string/user_data_new_location" />
 
             <TextView
@@ -84,15 +84,14 @@
                 app:barrierDirection="end"
                 app:constraint_referenced_ids="text_type,text_path,text_android_11" />
 
-            <View
+            <com.google.android.material.divider.MaterialDivider
                 android:id="@+id/divider"
                 android:layout_width="1dp"
                 android:layout_height="0dp"
-                android:background="#1F000000"
                 android:layout_marginStart="24dp"
                 android:layout_marginEnd="24dp"
-                app:layout_constraintTop_toTopOf="parent"
-                app:layout_constraintBottom_toBottomOf="parent"
+                app:layout_constraintTop_toTopOf="@id/text_type"
+                app:layout_constraintBottom_toBottomOf="@id/text_android_11"
                 app:layout_constraintStart_toEndOf="@id/barrier_text"
                 app:layout_constraintEnd_toStartOf="@id/barrier_buttons" />
 
diff --git a/Source/Android/app/src/main/res/layout-w680dp-land/activity_convert.xml b/Source/Android/app/src/main/res/layout-w680dp-land/activity_convert.xml
index 8091203873..1c00d679a6 100644
--- a/Source/Android/app/src/main/res/layout-w680dp-land/activity_convert.xml
+++ b/Source/Android/app/src/main/res/layout-w680dp-land/activity_convert.xml
@@ -53,11 +53,10 @@
                 app:layout_constraintStart_toStartOf="parent"
                 app:layout_constraintEnd_toStartOf="@id/divider" />
 
-            <View
+            <com.google.android.material.divider.MaterialDivider
                 android:id="@+id/divider"
                 android:layout_width="1dp"
                 android:layout_height="0dp"
-                android:background="#1F000000"
                 android:layout_marginStart="24dp"
                 app:layout_constraintTop_toTopOf="parent"
                 app:layout_constraintBottom_toBottomOf="parent"
diff --git a/Source/Android/app/src/main/res/layout/activity_convert.xml b/Source/Android/app/src/main/res/layout/activity_convert.xml
index b4b7b925dd..f2e07bf56f 100644
--- a/Source/Android/app/src/main/res/layout/activity_convert.xml
+++ b/Source/Android/app/src/main/res/layout/activity_convert.xml
@@ -51,11 +51,10 @@
                 app:layout_constraintTop_toTopOf="parent"
                 app:layout_constraintBottom_toTopOf="@id/divider" />
 
-            <View
+            <com.google.android.material.divider.MaterialDivider
                 android:id="@+id/divider"
                 android:layout_width="0dp"
-                android:layout_height="1dp"
-                android:background="#1F000000"
+                android:layout_height="wrap_content"
                 android:layout_marginTop="24dp"
                 app:layout_constraintStart_toStartOf="parent"
                 app:layout_constraintEnd_toEndOf="parent"
diff --git a/Source/Android/app/src/main/res/layout/activity_riivolution_boot.xml b/Source/Android/app/src/main/res/layout/activity_riivolution_boot.xml
index acc2d06ac7..1ab3315646 100644
--- a/Source/Android/app/src/main/res/layout/activity_riivolution_boot.xml
+++ b/Source/Android/app/src/main/res/layout/activity_riivolution_boot.xml
@@ -52,11 +52,10 @@
                 app:layout_constraintTop_toTopOf="parent"
                 app:layout_constraintBottom_toTopOf="@id/divider" />
 
-            <View
+            <com.google.android.material.divider.MaterialDivider
                 android:id="@+id/divider"
                 android:layout_width="0dp"
-                android:layout_height="1dp"
-                android:background="#1F000000"
+                android:layout_height="wrap_content"
                 android:layout_marginHorizontal="@dimen/spacing_large"
                 android:layout_marginVertical="@dimen/spacing_small"
                 app:layout_constraintStart_toStartOf="parent"
diff --git a/Source/Android/app/src/main/res/layout/dialog_game_details.xml b/Source/Android/app/src/main/res/layout/dialog_game_details.xml
index 006e270ee8..3f35eecb4d 100644
--- a/Source/Android/app/src/main/res/layout/dialog_game_details.xml
+++ b/Source/Android/app/src/main/res/layout/dialog_game_details.xml
@@ -44,11 +44,10 @@
             app:layout_constraintStart_toStartOf="parent"
             app:layout_constraintTop_toBottomOf="@id/text_description" />
 
-        <View
+        <com.google.android.material.divider.MaterialDivider
             android:id="@+id/divider_1"
             android:layout_width="0dp"
-            android:layout_height="1dp"
-            android:background="#1F000000"
+            android:layout_height="wrap_content"
             android:layout_marginTop="32dp"
             app:layout_constraintStart_toStartOf="parent"
             app:layout_constraintEnd_toEndOf="parent"
@@ -145,11 +144,10 @@
             app:layout_constraintEnd_toEndOf="parent"
             app:layout_constraintBaseline_toBaselineOf="@id/label_revision" />
 
-        <View
+        <com.google.android.material.divider.MaterialDivider
             android:id="@+id/divider_2"
             android:layout_width="0dp"
-            android:layout_height="1dp"
-            android:background="#1F000000"
+            android:layout_height="wrap_content"
             android:layout_marginTop="32dp"
             app:layout_constraintStart_toStartOf="parent"
             app:layout_constraintEnd_toEndOf="parent"
diff --git a/Source/Android/app/src/main/res/layout/fragment_ingame_menu.xml b/Source/Android/app/src/main/res/layout/fragment_ingame_menu.xml
index 23aa8d6152..5e674fc5a5 100644
--- a/Source/Android/app/src/main/res/layout/fragment_ingame_menu.xml
+++ b/Source/Android/app/src/main/res/layout/fragment_ingame_menu.xml
@@ -110,13 +110,12 @@
 
     </ScrollView>
 
-    <View
-        android:id="@+id/divider"
+    <com.google.android.material.divider.MaterialDivider
+        android:id="@+id/divider_2"
         android:layout_width="match_parent"
-        android:layout_height="1dp"
-        android:background="?attr/colorOnSurfaceVariant"
+        android:layout_height="wrap_content"
         android:layout_marginTop="24dp"
-        android:layout_marginBottom="16dp"/>
+        android:layout_marginBottom="16dp" />
 
     <Button
         android:id="@+id/menu_exit"
diff --git a/Source/Android/app/src/main/res/values/styles.xml b/Source/Android/app/src/main/res/values/styles.xml
index ee9c32fd0d..91883bdb60 100644
--- a/Source/Android/app/src/main/res/values/styles.xml
+++ b/Source/Android/app/src/main/res/values/styles.xml
@@ -58,4 +58,8 @@
         <item name="tickVisible">false</item>
         <item name="labelBehavior">gone</item>
     </style>
+
+    <style name="DolphinDivider" parent="Widget.Material3.MaterialDivider">
+        <item name="dividerColor">?attr/colorSurfaceVariant</item>
+    </style>
 </resources>
diff --git a/Source/Android/app/src/main/res/values/themes.xml b/Source/Android/app/src/main/res/values/themes.xml
index f31e87f72e..c2dc17afdf 100644
--- a/Source/Android/app/src/main/res/values/themes.xml
+++ b/Source/Android/app/src/main/res/values/themes.xml
@@ -54,6 +54,7 @@
         <item name="materialAlertDialogTheme">@style/DolphinMaterialDialog</item>
         <item name="popupTheme">@style/DolphinPopup</item>
         <item name="sliderStyle">@style/DolphinSlider</item>
+        <item name="materialDividerStyle">@style/DolphinDivider</item>
     </style>
 
     <!-- Trick for API >= 27 specific changes -->
diff --git a/Source/Core/Common/Arm64Emitter.cpp b/Source/Core/Common/Arm64Emitter.cpp
index 075987c3f4..013285329f 100644
--- a/Source/Core/Common/Arm64Emitter.cpp
+++ b/Source/Core/Common/Arm64Emitter.cpp
@@ -485,13 +485,22 @@ void ARM64XEmitter::EncodeLoadStorePairedInst(u32 op, ARM64Reg Rt, ARM64Reg Rt2,
   bool bVec = IsVector(Rt);
 
   if (b128Bit)
+  {
+    ASSERT_MSG(DYNA_REC, (imm & 0xf) == 0, "128-bit load/store must use aligned offset: {}", imm);
     imm >>= 4;
+  }
   else if (b64Bit)
+  {
+    ASSERT_MSG(DYNA_REC, (imm & 0x7) == 0, "64-bit load/store must use aligned offset: {}", imm);
     imm >>= 3;
+  }
   else
+  {
+    ASSERT_MSG(DYNA_REC, (imm & 0x3) == 0, "32-bit load/store must use aligned offset: {}", imm);
     imm >>= 2;
+  }
 
-  ASSERT_MSG(DYNA_REC, !(imm & ~0xF), "offset too large {}", imm);
+  ASSERT_MSG(DYNA_REC, (imm & ~0xF) == 0, "offset too large {}", imm);
 
   u32 opc = 0;
   if (b128Bit)
@@ -524,11 +533,20 @@ void ARM64XEmitter::EncodeLoadStoreIndexedInst(u32 op, ARM64Reg Rt, ARM64Reg Rn,
   bool bVec = IsVector(Rt);
 
   if (size == 64)
+  {
+    ASSERT_MSG(DYNA_REC, (imm & 0x7) == 0, "64-bit load/store must use aligned offset: {}", imm);
     imm >>= 3;
+  }
   else if (size == 32)
+  {
+    ASSERT_MSG(DYNA_REC, (imm & 0x3) == 0, "32-bit load/store must use aligned offset: {}", imm);
     imm >>= 2;
+  }
   else if (size == 16)
+  {
+    ASSERT_MSG(DYNA_REC, (imm & 0x1) == 0, "16-bit load/store must use aligned offset: {}", imm);
     imm >>= 1;
+  }
 
   ASSERT_MSG(DYNA_REC, imm >= 0, "(IndexType::Unsigned): offset must be positive {}", imm);
   ASSERT_MSG(DYNA_REC, !(imm & ~0xFFF), "(IndexType::Unsigned): offset too large {}", imm);
@@ -615,10 +633,12 @@ void ARM64XEmitter::EncodeLoadStorePair(u32 op, u32 load, IndexType type, ARM64R
   if (b64Bit)
   {
     op |= 0b10;
+    ASSERT_MSG(DYNA_REC, (imm & 0x7) == 0, "64-bit load/store must use aligned offset: {}", imm);
     imm >>= 3;
   }
   else
   {
+    ASSERT_MSG(DYNA_REC, (imm & 0x3) == 0, "32-bit load/store must use aligned offset: {}", imm);
     imm >>= 2;
   }
 
@@ -2072,19 +2092,29 @@ void ARM64FloatEmitter::EmitLoadStoreImmediate(u8 size, u32 opc, IndexType type,
 
   if (type == IndexType::Unsigned)
   {
-    ASSERT_MSG(DYNA_REC, !(imm & ((size - 1) >> 3)),
-               "(IndexType::Unsigned) immediate offset must be aligned to size! ({}) ({})", imm,
-               fmt::ptr(m_emit->GetCodePtr()));
     ASSERT_MSG(DYNA_REC, imm >= 0, "(IndexType::Unsigned) immediate offset must be positive! ({})",
                imm);
     if (size == 16)
+    {
+      ASSERT_MSG(DYNA_REC, (imm & 0x1) == 0, "16-bit load/store must use aligned offset: {}", imm);
       imm >>= 1;
+    }
     else if (size == 32)
+    {
+      ASSERT_MSG(DYNA_REC, (imm & 0x3) == 0, "32-bit load/store must use aligned offset: {}", imm);
       imm >>= 2;
+    }
     else if (size == 64)
+    {
+      ASSERT_MSG(DYNA_REC, (imm & 0x7) == 0, "64-bit load/store must use aligned offset: {}", imm);
       imm >>= 3;
+    }
     else if (size == 128)
+    {
+      ASSERT_MSG(DYNA_REC, (imm & 0xf) == 0, "128-bit load/store must use aligned offset: {}", imm);
       imm >>= 4;
+    }
+    ASSERT_MSG(DYNA_REC, imm <= 0xFFF, "Immediate value is too big: {}", imm);
     encoded_imm = (imm & 0xFFF);
   }
   else
diff --git a/Source/Core/Common/Matrix.h b/Source/Core/Common/Matrix.h
index 1c6c53787e..c2bd78d36c 100644
--- a/Source/Core/Common/Matrix.h
+++ b/Source/Core/Common/Matrix.h
@@ -24,6 +24,11 @@ union TVec3
   {
   }
 
+  constexpr bool operator==(const TVec3& other) const
+  {
+    return x == other.x && y == other.y && z == other.z;
+  }
+
   constexpr TVec3 Cross(const TVec3& rhs) const
   {
     return {(y * rhs.z) - (rhs.y * z), (z * rhs.x) - (rhs.z * x), (x * rhs.y) - (rhs.x * y)};
@@ -153,6 +158,11 @@ union TVec4
   constexpr TVec4(TVec3<T> _vec, T _w) : TVec4{_vec.x, _vec.y, _vec.z, _w} {}
   constexpr TVec4(T _x, T _y, T _z, T _w) : data{_x, _y, _z, _w} {}
 
+  constexpr bool operator==(const TVec4& other) const
+  {
+    return x == other.x && y == other.y && z == other.z && w == other.w;
+  }
+
   constexpr T Dot(const TVec4& other) const
   {
     return x * other.x + y * other.y + z * other.z + w * other.w;
@@ -216,6 +226,8 @@ union TVec2
   {
   }
 
+  constexpr bool operator==(const TVec2& other) const { return x == other.x && y == other.y; }
+
   constexpr T Cross(const TVec2& rhs) const { return (x * rhs.y) - (y * rhs.x); }
   constexpr T Dot(const TVec2& rhs) const { return (x * rhs.x) + (y * rhs.y); }
   constexpr T LengthSquared() const { return Dot(*this); }
diff --git a/Source/Core/Common/MsgHandler.h b/Source/Core/Common/MsgHandler.h
index e3ed2c80db..23f8e9036d 100644
--- a/Source/Core/Common/MsgHandler.h
+++ b/Source/Core/Common/MsgHandler.h
@@ -29,7 +29,7 @@ using StringTranslator = std::string (*)(const char* text);
 void RegisterMsgAlertHandler(MsgAlertHandler handler);
 void RegisterStringTranslator(StringTranslator translator);
 
-std::string GetStringT(const char* string);
+[[nodiscard]] std::string GetStringT(const char* string);
 
 bool MsgAlertFmtImpl(bool yes_no, MsgType style, Common::Log::LogType log_type, const char* file,
                      int line, fmt::string_view format, const fmt::format_args& args);
diff --git a/Source/Core/Core/BootManager.cpp b/Source/Core/Core/BootManager.cpp
index 574b8becc5..7a17307af9 100644
--- a/Source/Core/Core/BootManager.cpp
+++ b/Source/Core/Core/BootManager.cpp
@@ -91,11 +91,7 @@ bool BootCore(std::unique_ptr<BootParameters> boot, const WindowSystemInfo& wsi)
       return false;
 
     Config::AddLayer(ConfigLoaders::GenerateNetPlayConfigLoader(*netplay_settings));
-    StartUp.bCopyWiiSaveNetplay = netplay_settings->m_CopyWiiSave;
-  }
-  else
-  {
-    g_SRAM_netplay_initialized = false;
+    StartUp.bCopyWiiSaveNetplay = netplay_settings->copy_wii_save;
   }
 
   // Override out-of-region languages/countries to prevent games from crashing or behaving oddly
diff --git a/Source/Core/Core/ConfigLoaders/NetPlayConfigLoader.cpp b/Source/Core/Core/ConfigLoaders/NetPlayConfigLoader.cpp
index f52a828719..02eef5aaee 100644
--- a/Source/Core/Core/ConfigLoaders/NetPlayConfigLoader.cpp
+++ b/Source/Core/Core/ConfigLoaders/NetPlayConfigLoader.cpp
@@ -30,99 +30,99 @@ public:
 
   void Load(Config::Layer* layer) override
   {
-    layer->Set(Config::MAIN_CPU_THREAD, m_settings.m_CPUthread);
-    layer->Set(Config::MAIN_CPU_CORE, m_settings.m_CPUcore);
-    layer->Set(Config::MAIN_ENABLE_CHEATS, m_settings.m_EnableCheats);
-    layer->Set(Config::MAIN_GC_LANGUAGE, m_settings.m_SelectedLanguage);
-    layer->Set(Config::MAIN_OVERRIDE_REGION_SETTINGS, m_settings.m_OverrideRegionSettings);
-    layer->Set(Config::MAIN_DSP_HLE, m_settings.m_DSPHLE);
-    layer->Set(Config::MAIN_OVERCLOCK_ENABLE, m_settings.m_OCEnable);
-    layer->Set(Config::MAIN_OVERCLOCK, m_settings.m_OCFactor);
+    layer->Set(Config::MAIN_CPU_THREAD, m_settings.cpu_thread);
+    layer->Set(Config::MAIN_CPU_CORE, m_settings.cpu_core);
+    layer->Set(Config::MAIN_ENABLE_CHEATS, m_settings.enable_cheats);
+    layer->Set(Config::MAIN_GC_LANGUAGE, m_settings.selected_language);
+    layer->Set(Config::MAIN_OVERRIDE_REGION_SETTINGS, m_settings.override_region_settings);
+    layer->Set(Config::MAIN_DSP_HLE, m_settings.dsp_hle);
+    layer->Set(Config::MAIN_OVERCLOCK_ENABLE, m_settings.oc_enable);
+    layer->Set(Config::MAIN_OVERCLOCK, m_settings.oc_factor);
     for (ExpansionInterface::Slot slot : ExpansionInterface::SLOTS)
-      layer->Set(Config::GetInfoForEXIDevice(slot), m_settings.m_EXIDevice[slot]);
-    layer->Set(Config::MAIN_MEMORY_CARD_SIZE, m_settings.m_MemcardSizeOverride);
-    layer->Set(Config::SESSION_SAVE_DATA_WRITABLE, m_settings.m_WriteToMemcard);
-    layer->Set(Config::MAIN_RAM_OVERRIDE_ENABLE, m_settings.m_RAMOverrideEnable);
-    layer->Set(Config::MAIN_MEM1_SIZE, m_settings.m_Mem1Size);
-    layer->Set(Config::MAIN_MEM2_SIZE, m_settings.m_Mem2Size);
-    layer->Set(Config::MAIN_FALLBACK_REGION, m_settings.m_FallbackRegion);
-    layer->Set(Config::MAIN_ALLOW_SD_WRITES, m_settings.m_AllowSDWrites);
-    layer->Set(Config::MAIN_DSP_JIT, m_settings.m_DSPEnableJIT);
+      layer->Set(Config::GetInfoForEXIDevice(slot), m_settings.exi_device[slot]);
+    layer->Set(Config::MAIN_MEMORY_CARD_SIZE, m_settings.memcard_size_override);
+    layer->Set(Config::SESSION_SAVE_DATA_WRITABLE, m_settings.write_to_memcard);
+    layer->Set(Config::MAIN_RAM_OVERRIDE_ENABLE, m_settings.ram_override_enable);
+    layer->Set(Config::MAIN_MEM1_SIZE, m_settings.mem1_size);
+    layer->Set(Config::MAIN_MEM2_SIZE, m_settings.mem2_size);
+    layer->Set(Config::MAIN_FALLBACK_REGION, m_settings.fallback_region);
+    layer->Set(Config::MAIN_ALLOW_SD_WRITES, m_settings.allow_sd_writes);
+    layer->Set(Config::MAIN_DSP_JIT, m_settings.dsp_enable_jit);
 
     for (size_t i = 0; i < Config::SYSCONF_SETTINGS.size(); ++i)
     {
       std::visit(
           [&](auto* info) {
             layer->Set(*info, static_cast<decltype(info->GetDefaultValue())>(
-                                  m_settings.m_SYSCONFSettings[i]));
+                                  m_settings.sysconf_settings[i]));
           },
           Config::SYSCONF_SETTINGS[i].config_info);
     }
 
-    layer->Set(Config::GFX_HACK_EFB_ACCESS_ENABLE, m_settings.m_EFBAccessEnable);
-    layer->Set(Config::GFX_HACK_BBOX_ENABLE, m_settings.m_BBoxEnable);
-    layer->Set(Config::GFX_HACK_FORCE_PROGRESSIVE, m_settings.m_ForceProgressive);
-    layer->Set(Config::GFX_HACK_SKIP_EFB_COPY_TO_RAM, m_settings.m_EFBToTextureEnable);
-    layer->Set(Config::GFX_HACK_SKIP_XFB_COPY_TO_RAM, m_settings.m_XFBToTextureEnable);
-    layer->Set(Config::GFX_HACK_DISABLE_COPY_TO_VRAM, m_settings.m_DisableCopyToVRAM);
-    layer->Set(Config::GFX_HACK_IMMEDIATE_XFB, m_settings.m_ImmediateXFBEnable);
-    layer->Set(Config::GFX_HACK_EFB_EMULATE_FORMAT_CHANGES, m_settings.m_EFBEmulateFormatChanges);
+    layer->Set(Config::GFX_HACK_EFB_ACCESS_ENABLE, m_settings.efb_access_enable);
+    layer->Set(Config::GFX_HACK_BBOX_ENABLE, m_settings.bbox_enable);
+    layer->Set(Config::GFX_HACK_FORCE_PROGRESSIVE, m_settings.force_progressive);
+    layer->Set(Config::GFX_HACK_SKIP_EFB_COPY_TO_RAM, m_settings.efb_to_texture_enable);
+    layer->Set(Config::GFX_HACK_SKIP_XFB_COPY_TO_RAM, m_settings.xfb_to_texture_enable);
+    layer->Set(Config::GFX_HACK_DISABLE_COPY_TO_VRAM, m_settings.disable_copy_to_vram);
+    layer->Set(Config::GFX_HACK_IMMEDIATE_XFB, m_settings.immediate_xfb_enable);
+    layer->Set(Config::GFX_HACK_EFB_EMULATE_FORMAT_CHANGES, m_settings.efb_emulate_format_changes);
     layer->Set(Config::GFX_SAFE_TEXTURE_CACHE_COLOR_SAMPLES,
-               m_settings.m_SafeTextureCacheColorSamples);
-    layer->Set(Config::GFX_PERF_QUERIES_ENABLE, m_settings.m_PerfQueriesEnable);
-    layer->Set(Config::MAIN_FLOAT_EXCEPTIONS, m_settings.m_FloatExceptions);
-    layer->Set(Config::MAIN_DIVIDE_BY_ZERO_EXCEPTIONS, m_settings.m_DivideByZeroExceptions);
-    layer->Set(Config::MAIN_FPRF, m_settings.m_FPRF);
-    layer->Set(Config::MAIN_ACCURATE_NANS, m_settings.m_AccurateNaNs);
-    layer->Set(Config::MAIN_DISABLE_ICACHE, m_settings.m_DisableICache);
-    layer->Set(Config::MAIN_SYNC_ON_SKIP_IDLE, m_settings.m_SyncOnSkipIdle);
-    layer->Set(Config::MAIN_SYNC_GPU, m_settings.m_SyncGPU);
-    layer->Set(Config::MAIN_SYNC_GPU_MAX_DISTANCE, m_settings.m_SyncGpuMaxDistance);
-    layer->Set(Config::MAIN_SYNC_GPU_MIN_DISTANCE, m_settings.m_SyncGpuMinDistance);
-    layer->Set(Config::MAIN_SYNC_GPU_OVERCLOCK, m_settings.m_SyncGpuOverclock);
+               m_settings.safe_texture_cache_color_samples);
+    layer->Set(Config::GFX_PERF_QUERIES_ENABLE, m_settings.perf_queries_enable);
+    layer->Set(Config::MAIN_FLOAT_EXCEPTIONS, m_settings.float_exceptions);
+    layer->Set(Config::MAIN_DIVIDE_BY_ZERO_EXCEPTIONS, m_settings.divide_by_zero_exceptions);
+    layer->Set(Config::MAIN_FPRF, m_settings.fprf);
+    layer->Set(Config::MAIN_ACCURATE_NANS, m_settings.accurate_nans);
+    layer->Set(Config::MAIN_DISABLE_ICACHE, m_settings.disable_icache);
+    layer->Set(Config::MAIN_SYNC_ON_SKIP_IDLE, m_settings.sync_on_skip_idle);
+    layer->Set(Config::MAIN_SYNC_GPU, m_settings.sync_gpu);
+    layer->Set(Config::MAIN_SYNC_GPU_MAX_DISTANCE, m_settings.sync_gpu_max_distance);
+    layer->Set(Config::MAIN_SYNC_GPU_MIN_DISTANCE, m_settings.sync_gpu_min_distance);
+    layer->Set(Config::MAIN_SYNC_GPU_OVERCLOCK, m_settings.sync_gpu_overclock);
 
-    layer->Set(Config::MAIN_JIT_FOLLOW_BRANCH, m_settings.m_JITFollowBranch);
-    layer->Set(Config::MAIN_FAST_DISC_SPEED, m_settings.m_FastDiscSpeed);
-    layer->Set(Config::MAIN_MMU, m_settings.m_MMU);
-    layer->Set(Config::MAIN_FASTMEM, m_settings.m_Fastmem);
-    layer->Set(Config::MAIN_SKIP_IPL, m_settings.m_SkipIPL);
-    layer->Set(Config::SESSION_LOAD_IPL_DUMP, m_settings.m_LoadIPLDump);
+    layer->Set(Config::MAIN_JIT_FOLLOW_BRANCH, m_settings.jit_follow_branch);
+    layer->Set(Config::MAIN_FAST_DISC_SPEED, m_settings.fast_disc_speed);
+    layer->Set(Config::MAIN_MMU, m_settings.mmu);
+    layer->Set(Config::MAIN_FASTMEM, m_settings.fastmem);
+    layer->Set(Config::MAIN_SKIP_IPL, m_settings.skip_ipl);
+    layer->Set(Config::SESSION_LOAD_IPL_DUMP, m_settings.load_ipl_dump);
 
-    layer->Set(Config::GFX_HACK_DEFER_EFB_COPIES, m_settings.m_DeferEFBCopies);
-    layer->Set(Config::GFX_HACK_EFB_ACCESS_TILE_SIZE, m_settings.m_EFBAccessTileSize);
-    layer->Set(Config::GFX_HACK_EFB_DEFER_INVALIDATION, m_settings.m_EFBAccessDeferInvalidation);
+    layer->Set(Config::GFX_HACK_DEFER_EFB_COPIES, m_settings.defer_efb_copies);
+    layer->Set(Config::GFX_HACK_EFB_ACCESS_TILE_SIZE, m_settings.efb_access_tile_size);
+    layer->Set(Config::GFX_HACK_EFB_DEFER_INVALIDATION, m_settings.efb_access_defer_invalidation);
 
-    layer->Set(Config::SESSION_USE_FMA, m_settings.m_UseFMA);
+    layer->Set(Config::SESSION_USE_FMA, m_settings.use_fma);
 
     layer->Set(Config::MAIN_BLUETOOTH_PASSTHROUGH_ENABLED, false);
 
-    if (m_settings.m_StrictSettingsSync)
+    if (m_settings.strict_settings_sync)
     {
-      layer->Set(Config::GFX_HACK_VERTEX_ROUNDING, m_settings.m_VertexRounding);
-      layer->Set(Config::GFX_EFB_SCALE, m_settings.m_InternalResolution);
-      layer->Set(Config::GFX_HACK_COPY_EFB_SCALED, m_settings.m_EFBScaledCopy);
-      layer->Set(Config::GFX_FAST_DEPTH_CALC, m_settings.m_FastDepthCalc);
-      layer->Set(Config::GFX_ENABLE_PIXEL_LIGHTING, m_settings.m_EnablePixelLighting);
-      layer->Set(Config::GFX_WIDESCREEN_HACK, m_settings.m_WidescreenHack);
-      layer->Set(Config::GFX_ENHANCE_FORCE_FILTERING, m_settings.m_ForceFiltering);
-      layer->Set(Config::GFX_ENHANCE_MAX_ANISOTROPY, m_settings.m_MaxAnisotropy);
-      layer->Set(Config::GFX_ENHANCE_FORCE_TRUE_COLOR, m_settings.m_ForceTrueColor);
-      layer->Set(Config::GFX_ENHANCE_DISABLE_COPY_FILTER, m_settings.m_DisableCopyFilter);
-      layer->Set(Config::GFX_DISABLE_FOG, m_settings.m_DisableFog);
+      layer->Set(Config::GFX_HACK_VERTEX_ROUNDING, m_settings.vertex_rounding);
+      layer->Set(Config::GFX_EFB_SCALE, m_settings.internal_resolution);
+      layer->Set(Config::GFX_HACK_COPY_EFB_SCALED, m_settings.efb_scaled_copy);
+      layer->Set(Config::GFX_FAST_DEPTH_CALC, m_settings.fast_depth_calc);
+      layer->Set(Config::GFX_ENABLE_PIXEL_LIGHTING, m_settings.enable_pixel_lighting);
+      layer->Set(Config::GFX_WIDESCREEN_HACK, m_settings.widescreen_hack);
+      layer->Set(Config::GFX_ENHANCE_FORCE_FILTERING, m_settings.force_filtering);
+      layer->Set(Config::GFX_ENHANCE_MAX_ANISOTROPY, m_settings.max_anisotropy);
+      layer->Set(Config::GFX_ENHANCE_FORCE_TRUE_COLOR, m_settings.force_true_color);
+      layer->Set(Config::GFX_ENHANCE_DISABLE_COPY_FILTER, m_settings.disable_copy_filter);
+      layer->Set(Config::GFX_DISABLE_FOG, m_settings.disable_fog);
       layer->Set(Config::GFX_ENHANCE_ARBITRARY_MIPMAP_DETECTION,
-                 m_settings.m_ArbitraryMipmapDetection);
+                 m_settings.arbitrary_mipmap_detection);
       layer->Set(Config::GFX_ENHANCE_ARBITRARY_MIPMAP_DETECTION_THRESHOLD,
-                 m_settings.m_ArbitraryMipmapDetectionThreshold);
-      layer->Set(Config::GFX_ENABLE_GPU_TEXTURE_DECODING, m_settings.m_EnableGPUTextureDecoding);
+                 m_settings.arbitrary_mipmap_detection_threshold);
+      layer->Set(Config::GFX_ENABLE_GPU_TEXTURE_DECODING, m_settings.enable_gpu_texture_decoding);
 
       // Disable AA as it isn't deterministic across GPUs
       layer->Set(Config::GFX_MSAA, 1);
       layer->Set(Config::GFX_SSAA, false);
     }
 
-    if (m_settings.m_SyncSaveData)
+    if (m_settings.sync_save_data)
     {
-      if (!m_settings.m_IsHosting)
+      if (!m_settings.is_hosting)
       {
         const std::string path = File::GetUserPath(D_GCUSER_IDX) + GC_MEMCARD_NETPLAY DIR_SEP;
         layer->Set(Config::MAIN_GCI_FOLDER_A_PATH_OVERRIDE, path + "Card A");
@@ -130,7 +130,7 @@ public:
 
         const auto make_memcard_path = [this](char letter) {
           return fmt::format("{}{}{}.{}.raw", File::GetUserPath(D_GCUSER_IDX), GC_MEMCARD_NETPLAY,
-                             letter, m_settings.m_SaveDataRegion);
+                             letter, m_settings.save_data_region);
         };
         layer->Set(Config::MAIN_MEMCARD_A_PATH, make_memcard_path('A'));
         layer->Set(Config::MAIN_MEMCARD_B_PATH, make_memcard_path('B'));
@@ -140,14 +140,14 @@ public:
     }
 
 #ifdef HAS_LIBMGBA
-    for (size_t i = 0; i < m_settings.m_GBARomPaths.size(); ++i)
+    for (size_t i = 0; i < m_settings.gba_rom_paths.size(); ++i)
     {
-      layer->Set(Config::MAIN_GBA_ROM_PATHS[i], m_settings.m_GBARomPaths[i]);
+      layer->Set(Config::MAIN_GBA_ROM_PATHS[i], m_settings.gba_rom_paths[i]);
     }
 #endif
 
     // Check To Override Client's Cheat Codes
-    if (m_settings.m_SyncCodes && !m_settings.m_IsHosting)
+    if (m_settings.sync_codes && !m_settings.is_hosting)
     {
       // Raise flag to use host's codes
       layer->Set(Config::SESSION_CODE_SYNC_OVERRIDE, true);
diff --git a/Source/Core/Core/Core.cpp b/Source/Core/Core/Core.cpp
index a3d2379db7..913c9956e9 100644
--- a/Source/Core/Core/Core.cpp
+++ b/Source/Core/Core/Core.cpp
@@ -511,7 +511,7 @@ static void EmuThread(std::unique_ptr<BootParameters> boot, WindowSystemInfo wsi
   AudioCommon::InitSoundStream();
   Common::ScopeGuard audio_guard{&AudioCommon::ShutdownSoundStream};
 
-  HW::Init();
+  HW::Init(NetPlay::IsNetPlayRunning() ? &(boot_session_data.GetNetplaySettings()->sram) : nullptr);
 
   Common::ScopeGuard hw_guard{[] {
     // We must set up this flag before executing HW::Shutdown()
diff --git a/Source/Core/Core/FifoPlayer/FifoPlayer.cpp b/Source/Core/Core/FifoPlayer/FifoPlayer.cpp
index b93fcf980a..e6a3a6e224 100644
--- a/Source/Core/Core/FifoPlayer/FifoPlayer.cpp
+++ b/Source/Core/Core/FifoPlayer/FifoPlayer.cpp
@@ -55,6 +55,11 @@ public:
 
   OPCODE_CALLBACK(CPState& GetCPState()) { return m_cpmem; }
 
+  OPCODE_CALLBACK(u32 GetVertexSize(u8 vat))
+  {
+    return VertexLoaderBase::GetVertexSize(GetCPState().vtx_desc, GetCPState().vtx_attr[vat]);
+  }
+
   bool m_start_of_primitives = false;
   bool m_end_of_primitives = false;
   bool m_efb_copy = false;
diff --git a/Source/Core/Core/FifoPlayer/FifoRecorder.cpp b/Source/Core/Core/FifoPlayer/FifoRecorder.cpp
index a47877ef4f..4464615495 100644
--- a/Source/Core/Core/FifoPlayer/FifoRecorder.cpp
+++ b/Source/Core/Core/FifoPlayer/FifoRecorder.cpp
@@ -45,6 +45,11 @@ public:
 
   OPCODE_CALLBACK(CPState& GetCPState()) { return m_cpmem; }
 
+  OPCODE_CALLBACK(u32 GetVertexSize(u8 vat))
+  {
+    return VertexLoaderBase::GetVertexSize(GetCPState().vtx_desc, GetCPState().vtx_attr[vat]);
+  }
+
 private:
   void ProcessVertexComponent(CPArray array_index, VertexComponentFormat array_type,
                               u32 component_offset, u32 vertex_size, u16 num_vertices,
diff --git a/Source/Core/Core/HW/EXI/EXI.cpp b/Source/Core/Core/HW/EXI/EXI.cpp
index c480e09235..76d5356db1 100644
--- a/Source/Core/Core/HW/EXI/EXI.cpp
+++ b/Source/Core/Core/HW/EXI/EXI.cpp
@@ -8,6 +8,7 @@
 
 #include "Common/ChunkFile.h"
 #include "Common/CommonTypes.h"
+#include "Common/IOFile.h"
 
 #include "Core/Config/MainSettings.h"
 #include "Core/ConfigManager.h"
@@ -20,11 +21,11 @@
 #include "Core/HW/Sram.h"
 #include "Core/HW/SystemTimers.h"
 #include "Core/Movie.h"
+#include "Core/System.h"
 
 #include "DiscIO/Enums.h"
 
-Sram g_SRAM;
-bool g_SRAM_netplay_initialized = false;
+bool s_using_overridden_sram = false;
 
 namespace ExpansionInterface
 {
@@ -102,11 +103,18 @@ u8 SlotToEXIDevice(Slot slot)
   }
 }
 
-void Init()
+void Init(const Sram* override_sram)
 {
-  if (!g_SRAM_netplay_initialized)
+  auto& sram = Core::System::GetInstance().GetSRAM();
+  if (override_sram)
   {
-    InitSRAM();
+    sram = *override_sram;
+    s_using_overridden_sram = true;
+  }
+  else
+  {
+    InitSRAM(&sram, SConfig::GetInstance().m_strSRAM);
+    s_using_overridden_sram = false;
   }
 
   CEXIMemoryCard::Init();
@@ -118,9 +126,9 @@ void Init()
       size_mbits = Memcard::MBIT_SIZE_MEMORY_CARD_59 << size_override;
     const bool shift_jis =
         Config::ToGameCubeRegion(SConfig::GetInstance().m_region) == DiscIO::Region::NTSC_J;
-    const CardFlashId& flash_id = g_SRAM.settings_ex.flash_id[Memcard::SLOT_A];
-    const u32 rtc_bias = g_SRAM.settings.rtc_bias;
-    const u32 sram_language = static_cast<u32>(g_SRAM.settings.language);
+    const CardFlashId& flash_id = sram.settings_ex.flash_id[Memcard::SLOT_A];
+    const u32 rtc_bias = sram.settings.rtc_bias;
+    const u32 sram_language = static_cast<u32>(sram.settings.language);
     const u64 format_time =
         Common::Timer::GetLocalTimeSinceJan1970() - ExpansionInterface::CEXIIPL::GC_EPOCH;
 
@@ -151,6 +159,13 @@ void Shutdown()
     channel.reset();
 
   CEXIMemoryCard::Shutdown();
+
+  if (!s_using_overridden_sram)
+  {
+    File::IOFile file(SConfig::GetInstance().m_strSRAM, "wb");
+    auto& sram = Core::System::GetInstance().GetSRAM();
+    file.WriteArray(&sram, 1);
+  }
 }
 
 void DoState(PointerWrap& p)
diff --git a/Source/Core/Core/HW/EXI/EXI.h b/Source/Core/Core/HW/EXI/EXI.h
index 01661a0920..c18070f514 100644
--- a/Source/Core/Core/HW/EXI/EXI.h
+++ b/Source/Core/Core/HW/EXI/EXI.h
@@ -10,6 +10,7 @@
 #include "Core/CoreTiming.h"
 
 class PointerWrap;
+struct Sram;
 
 namespace CoreTiming
 {
@@ -51,7 +52,7 @@ constexpr bool IsMemcardSlot(Slot slot)
 u8 SlotToEXIChannel(Slot slot);
 u8 SlotToEXIDevice(Slot slot);
 
-void Init();
+void Init(const Sram* override_sram);
 void Shutdown();
 void DoState(PointerWrap& p);
 void PauseAndLock(bool doLock, bool unpauseOnUnlock);
diff --git a/Source/Core/Core/HW/EXI/EXI_DeviceIPL.cpp b/Source/Core/Core/HW/EXI/EXI_DeviceIPL.cpp
index 6f4d7ad2c2..f331f86284 100644
--- a/Source/Core/Core/HW/EXI/EXI_DeviceIPL.cpp
+++ b/Source/Core/Core/HW/EXI/EXI_DeviceIPL.cpp
@@ -28,6 +28,7 @@
 #include "Core/HW/SystemTimers.h"
 #include "Core/Movie.h"
 #include "Core/NetPlayProto.h"
+#include "Core/System.h"
 
 #include "DiscIO/Enums.h"
 
@@ -129,28 +130,25 @@ CEXIIPL::CEXIIPL()
     LoadFontFile((File::GetSysDirectory() + GC_SYS_DIR + DIR_SEP + FONT_WINDOWS_1252), 0x1fcf00);
   }
 
+  auto& sram = Core::System::GetInstance().GetSRAM();
+
   // Clear RTC
-  g_SRAM.rtc = 0;
+  sram.rtc = 0;
 
   // We Overwrite language selection here since it's possible on the GC to change the language as
   // you please
-  g_SRAM.settings.language = Config::Get(Config::MAIN_GC_LANGUAGE);
-  g_SRAM.settings.rtc_bias = 0;
-  FixSRAMChecksums();
+  sram.settings.language = Config::Get(Config::MAIN_GC_LANGUAGE);
+  sram.settings.rtc_bias = 0;
+  FixSRAMChecksums(&sram);
 }
 
-CEXIIPL::~CEXIIPL()
-{
-  // SRAM
-  if (!g_SRAM_netplay_initialized)
-  {
-    File::IOFile file(SConfig::GetInstance().m_strSRAM, "wb");
-    file.WriteArray(&g_SRAM, 1);
-  }
-}
+CEXIIPL::~CEXIIPL() = default;
+
 void CEXIIPL::DoState(PointerWrap& p)
 {
-  p.Do(g_SRAM);
+  auto& sram = Core::System::GetInstance().GetSRAM();
+
+  p.Do(sram);
   p.Do(g_rtc_flags);
   p.Do(m_command);
   p.Do(m_command_bytes_received);
@@ -253,7 +251,8 @@ void CEXIIPL::SetCS(int cs)
 
 void CEXIIPL::UpdateRTC()
 {
-  g_SRAM.rtc = GetEmulatedTime(GC_EPOCH);
+  auto& sram = Core::System::GetInstance().GetSRAM();
+  sram.rtc = GetEmulatedTime(GC_EPOCH);
 }
 
 bool CEXIIPL::IsPresent() const
@@ -343,11 +342,12 @@ void CEXIIPL::TransferByte(u8& data)
     }
     else if (IN_RANGE(SRAM))
     {
+      auto& sram = Core::System::GetInstance().GetSRAM();
       u32 dev_addr = DEV_ADDR_CURSOR(SRAM);
       if (m_command.is_write())
-        g_SRAM[dev_addr] = data;
+        sram[dev_addr] = data;
       else
-        data = g_SRAM[dev_addr];
+        data = sram[dev_addr];
     }
     else if (IN_RANGE(UART))
     {
diff --git a/Source/Core/Core/HW/EXI/EXI_DeviceMemoryCard.cpp b/Source/Core/Core/HW/EXI/EXI_DeviceMemoryCard.cpp
index 5e012e44db..0a48ffe7b9 100644
--- a/Source/Core/Core/HW/EXI/EXI_DeviceMemoryCard.cpp
+++ b/Source/Core/Core/HW/EXI/EXI_DeviceMemoryCard.cpp
@@ -34,6 +34,7 @@
 #include "Core/HW/Sram.h"
 #include "Core/HW/SystemTimers.h"
 #include "Core/Movie.h"
+#include "Core/System.h"
 #include "DiscIO/Enums.h"
 
 namespace ExpansionInterface
@@ -141,7 +142,8 @@ CEXIMemoryCard::CEXIMemoryCard(const Slot slot, bool gci_folder,
   m_memory_card_size = m_memory_card->GetCardId() * SIZE_TO_Mb;
   std::array<u8, 20> header{};
   m_memory_card->Read(0, static_cast<s32>(header.size()), header.data());
-  SetCardFlashID(header.data(), m_card_slot);
+  auto& sram = Core::System::GetInstance().GetSRAM();
+  SetCardFlashID(&sram, header.data(), m_card_slot);
 }
 
 std::pair<std::string /* path */, bool /* migrate */>
diff --git a/Source/Core/Core/HW/GCMemcard/GCMemcardRaw.cpp b/Source/Core/Core/HW/GCMemcard/GCMemcardRaw.cpp
index 23bca41df1..033bcd1952 100644
--- a/Source/Core/Core/HW/GCMemcard/GCMemcardRaw.cpp
+++ b/Source/Core/Core/HW/GCMemcard/GCMemcardRaw.cpp
@@ -30,6 +30,7 @@
 #include "Core/HW/EXI/EXI_DeviceIPL.h"
 #include "Core/HW/GCMemcard/GCMemcard.h"
 #include "Core/HW/Sram.h"
+#include "Core/System.h"
 
 #define SIZE_TO_Mb (1024 * 8 * 16)
 #define MC_HDR_SIZE 0xA000
@@ -59,10 +60,11 @@ MemoryCard::MemoryCard(const std::string& filename, ExpansionInterface::Slot car
     m_memcard_data = std::make_unique<u8[]>(m_memory_card_size);
 
     // Fills in the first 5 blocks (MC_HDR_SIZE bytes)
-    const CardFlashId& flash_id = g_SRAM.settings_ex.flash_id[Memcard::SLOT_A];
+    auto& sram = Core::System::GetInstance().GetSRAM();
+    const CardFlashId& flash_id = sram.settings_ex.flash_id[Memcard::SLOT_A];
     const bool shift_jis = m_filename.find(".JAP.raw") != std::string::npos;
-    const u32 rtc_bias = g_SRAM.settings.rtc_bias;
-    const u32 sram_language = static_cast<u32>(g_SRAM.settings.language);
+    const u32 rtc_bias = sram.settings.rtc_bias;
+    const u32 sram_language = static_cast<u32>(sram.settings.language);
     const u64 format_time =
         Common::Timer::GetLocalTimeSinceJan1970() - ExpansionInterface::CEXIIPL::GC_EPOCH;
     Memcard::GCMemcard::Format(&m_memcard_data[0], flash_id, size_mbits, shift_jis, rtc_bias,
diff --git a/Source/Core/Core/HW/HW.cpp b/Source/Core/Core/HW/HW.cpp
index b0a873bae9..3ea1ab665a 100644
--- a/Source/Core/Core/HW/HW.cpp
+++ b/Source/Core/Core/HW/HW.cpp
@@ -31,7 +31,7 @@
 
 namespace HW
 {
-void Init()
+void Init(const Sram* override_sram)
 {
   CoreTiming::Init();
   SystemTimers::PreInit();
@@ -43,7 +43,7 @@ void Init()
   VideoInterface::Init();
   SerialInterface::Init();
   ProcessorInterface::Init();
-  ExpansionInterface::Init();  // Needs to be initialized before Memory
+  ExpansionInterface::Init(override_sram);  // Needs to be initialized before Memory
   HSP::Init();
   Memory::Init();  // Needs to be initialized before AddressSpace
   AddressSpace::Init();
diff --git a/Source/Core/Core/HW/HW.h b/Source/Core/Core/HW/HW.h
index a527f65f85..1122ca5e2d 100644
--- a/Source/Core/Core/HW/HW.h
+++ b/Source/Core/Core/HW/HW.h
@@ -4,10 +4,11 @@
 #pragma once
 
 class PointerWrap;
+struct Sram;
 
 namespace HW
 {
-void Init();
+void Init(const Sram* override_sram);
 void Shutdown();
 void DoState(PointerWrap& p);
 }  // namespace HW
diff --git a/Source/Core/Core/HW/Sram.cpp b/Source/Core/Core/HW/Sram.cpp
index 1f8b29116a..b177ed6443 100644
--- a/Source/Core/Core/HW/Sram.cpp
+++ b/Source/Core/Core/HW/Sram.cpp
@@ -9,7 +9,6 @@
 #include "Common/MsgHandler.h"
 #include "Common/Swap.h"
 
-#include "Core/ConfigManager.h"
 #include "Core/HW/EXI/EXI.h"
 
 // English
@@ -58,24 +57,24 @@ const SRAM sram_dump_german = {{
 }};
 #endif
 
-void InitSRAM()
+void InitSRAM(Sram* sram, const std::string& filename)
 {
-  File::IOFile file(SConfig::GetInstance().m_strSRAM, "rb");
+  File::IOFile file(filename, "rb");
   if (file)
   {
-    if (!file.ReadArray(&g_SRAM, 1))
+    if (!file.ReadArray(sram, 1))
     {
       ERROR_LOG_FMT(EXPANSIONINTERFACE, "EXI IPL-DEV: Could not read all of SRAM");
-      g_SRAM = sram_dump;
+      *sram = sram_dump;
     }
   }
   else
   {
-    g_SRAM = sram_dump;
+    *sram = sram_dump;
   }
 }
 
-void SetCardFlashID(const u8* buffer, ExpansionInterface::Slot card_slot)
+void SetCardFlashID(Sram* sram, const u8* buffer, ExpansionInterface::Slot card_slot)
 {
   u8 card_index;
   switch (card_slot)
@@ -96,25 +95,25 @@ void SetCardFlashID(const u8* buffer, ExpansionInterface::Slot card_slot)
   for (int i = 0; i < 12; i++)
   {
     rand = (((rand * (u64)0x0000000041c64e6dULL) + (u64)0x0000000000003039ULL) >> 16);
-    csum += g_SRAM.settings_ex.flash_id[card_index][i] = buffer[i] - ((u8)rand & 0xff);
+    csum += sram->settings_ex.flash_id[card_index][i] = buffer[i] - ((u8)rand & 0xff);
     rand = (((rand * (u64)0x0000000041c64e6dULL) + (u64)0x0000000000003039ULL) >> 16);
     rand &= (u64)0x0000000000007fffULL;
   }
-  g_SRAM.settings_ex.flash_id_checksum[card_index] = csum ^ 0xFF;
+  sram->settings_ex.flash_id_checksum[card_index] = csum ^ 0xFF;
 }
 
-void FixSRAMChecksums()
+void FixSRAMChecksums(Sram* sram)
 {
   // 16bit big-endian additive checksum
   u16 checksum = 0;
   u16 checksum_inv = 0;
-  for (auto p = reinterpret_cast<u16*>(&g_SRAM.settings.rtc_bias);
-       p != reinterpret_cast<u16*>(&g_SRAM.settings_ex); p++)
+  for (auto p = reinterpret_cast<u16*>(&sram->settings.rtc_bias);
+       p != reinterpret_cast<u16*>(&sram->settings_ex); p++)
   {
     u16 value = Common::FromBigEndian(*p);
     checksum += value;
     checksum_inv += ~value;
   }
-  g_SRAM.settings.checksum = checksum;
-  g_SRAM.settings.checksum_inv = checksum_inv;
+  sram->settings.checksum = checksum;
+  sram->settings.checksum_inv = checksum_inv;
 }
diff --git a/Source/Core/Core/HW/Sram.h b/Source/Core/Core/HW/Sram.h
index 92262ca331..c58d8ad73c 100644
--- a/Source/Core/Core/HW/Sram.h
+++ b/Source/Core/Core/HW/Sram.h
@@ -34,6 +34,7 @@ distribution.
 #pragma once
 
 #include <array>
+#include <string>
 
 #include "Common/CommonTypes.h"
 #include "Common/Swap.h"
@@ -133,9 +134,6 @@ static_assert(sizeof(Sram) == 0x44);
 
 #pragma pack(pop)
 
-void InitSRAM();
-void SetCardFlashID(const u8* buffer, ExpansionInterface::Slot card_slot);
-void FixSRAMChecksums();
-
-extern Sram g_SRAM;
-extern bool g_SRAM_netplay_initialized;
+void InitSRAM(Sram* sram, const std::string& filename);
+void SetCardFlashID(Sram* sram, const u8* buffer, ExpansionInterface::Slot card_slot);
+void FixSRAMChecksums(Sram* sram);
diff --git a/Source/Core/Core/NetPlayClient.cpp b/Source/Core/Core/NetPlayClient.cpp
index e756a9b603..9c744420e5 100644
--- a/Source/Core/Core/NetPlayClient.cpp
+++ b/Source/Core/Core/NetPlayClient.cpp
@@ -432,10 +432,6 @@ void NetPlayClient::OnData(sf::Packet& packet)
     OnDesyncDetected(packet);
     break;
 
-  case MessageID::SyncGCSRAM:
-    OnSyncGCSRAM(packet);
-    break;
-
   case MessageID::SyncSaveData:
     OnSyncSaveData(packet);
     break;
@@ -635,7 +631,7 @@ void NetPlayClient::OnGBAConfig(sf::Packet& packet)
         std::tie(old_config.has_rom, old_config.title, old_config.hash))
     {
       m_dialog->OnMsgChangeGBARom(static_cast<int>(i), config);
-      m_net_settings.m_GBARomPaths[i] =
+      m_net_settings.gba_rom_paths[i] =
           config.has_rom ?
               m_dialog->FindGBARomPath(config.hash, config.title, static_cast<int>(i)) :
               "";
@@ -809,92 +805,94 @@ void NetPlayClient::OnStartGame(sf::Packet& packet)
     INFO_LOG_FMT(NETPLAY, "Start of game {}", m_selected_game.game_id);
 
     packet >> m_current_game;
-    packet >> m_net_settings.m_CPUthread;
-    packet >> m_net_settings.m_CPUcore;
-    packet >> m_net_settings.m_EnableCheats;
-    packet >> m_net_settings.m_SelectedLanguage;
-    packet >> m_net_settings.m_OverrideRegionSettings;
-    packet >> m_net_settings.m_DSPEnableJIT;
-    packet >> m_net_settings.m_DSPHLE;
-    packet >> m_net_settings.m_WriteToMemcard;
-    packet >> m_net_settings.m_RAMOverrideEnable;
-    packet >> m_net_settings.m_Mem1Size;
-    packet >> m_net_settings.m_Mem2Size;
-    packet >> m_net_settings.m_FallbackRegion;
-    packet >> m_net_settings.m_AllowSDWrites;
-    packet >> m_net_settings.m_CopyWiiSave;
-    packet >> m_net_settings.m_OCEnable;
-    packet >> m_net_settings.m_OCFactor;
+    packet >> m_net_settings.cpu_thread;
+    packet >> m_net_settings.cpu_core;
+    packet >> m_net_settings.enable_cheats;
+    packet >> m_net_settings.selected_language;
+    packet >> m_net_settings.override_region_settings;
+    packet >> m_net_settings.dsp_enable_jit;
+    packet >> m_net_settings.dsp_hle;
+    packet >> m_net_settings.write_to_memcard;
+    packet >> m_net_settings.ram_override_enable;
+    packet >> m_net_settings.mem1_size;
+    packet >> m_net_settings.mem2_size;
+    packet >> m_net_settings.fallback_region;
+    packet >> m_net_settings.allow_sd_writes;
+    packet >> m_net_settings.copy_wii_save;
+    packet >> m_net_settings.oc_enable;
+    packet >> m_net_settings.oc_factor;
 
     for (auto slot : ExpansionInterface::SLOTS)
-      packet >> m_net_settings.m_EXIDevice[slot];
+      packet >> m_net_settings.exi_device[slot];
 
-    packet >> m_net_settings.m_MemcardSizeOverride;
+    packet >> m_net_settings.memcard_size_override;
 
-    for (u32& value : m_net_settings.m_SYSCONFSettings)
+    for (u32& value : m_net_settings.sysconf_settings)
       packet >> value;
 
-    packet >> m_net_settings.m_EFBAccessEnable;
-    packet >> m_net_settings.m_BBoxEnable;
-    packet >> m_net_settings.m_ForceProgressive;
-    packet >> m_net_settings.m_EFBToTextureEnable;
-    packet >> m_net_settings.m_XFBToTextureEnable;
-    packet >> m_net_settings.m_DisableCopyToVRAM;
-    packet >> m_net_settings.m_ImmediateXFBEnable;
-    packet >> m_net_settings.m_EFBEmulateFormatChanges;
-    packet >> m_net_settings.m_SafeTextureCacheColorSamples;
-    packet >> m_net_settings.m_PerfQueriesEnable;
-    packet >> m_net_settings.m_FloatExceptions;
-    packet >> m_net_settings.m_DivideByZeroExceptions;
-    packet >> m_net_settings.m_FPRF;
-    packet >> m_net_settings.m_AccurateNaNs;
-    packet >> m_net_settings.m_DisableICache;
-    packet >> m_net_settings.m_SyncOnSkipIdle;
-    packet >> m_net_settings.m_SyncGPU;
-    packet >> m_net_settings.m_SyncGpuMaxDistance;
-    packet >> m_net_settings.m_SyncGpuMinDistance;
-    packet >> m_net_settings.m_SyncGpuOverclock;
-    packet >> m_net_settings.m_JITFollowBranch;
-    packet >> m_net_settings.m_FastDiscSpeed;
-    packet >> m_net_settings.m_MMU;
-    packet >> m_net_settings.m_Fastmem;
-    packet >> m_net_settings.m_SkipIPL;
-    packet >> m_net_settings.m_LoadIPLDump;
-    packet >> m_net_settings.m_VertexRounding;
-    packet >> m_net_settings.m_InternalResolution;
-    packet >> m_net_settings.m_EFBScaledCopy;
-    packet >> m_net_settings.m_FastDepthCalc;
-    packet >> m_net_settings.m_EnablePixelLighting;
-    packet >> m_net_settings.m_WidescreenHack;
-    packet >> m_net_settings.m_ForceFiltering;
-    packet >> m_net_settings.m_MaxAnisotropy;
-    packet >> m_net_settings.m_ForceTrueColor;
-    packet >> m_net_settings.m_DisableCopyFilter;
-    packet >> m_net_settings.m_DisableFog;
-    packet >> m_net_settings.m_ArbitraryMipmapDetection;
-    packet >> m_net_settings.m_ArbitraryMipmapDetectionThreshold;
-    packet >> m_net_settings.m_EnableGPUTextureDecoding;
-    packet >> m_net_settings.m_DeferEFBCopies;
-    packet >> m_net_settings.m_EFBAccessTileSize;
-    packet >> m_net_settings.m_EFBAccessDeferInvalidation;
-    packet >> m_net_settings.m_StrictSettingsSync;
+    packet >> m_net_settings.efb_access_enable;
+    packet >> m_net_settings.bbox_enable;
+    packet >> m_net_settings.force_progressive;
+    packet >> m_net_settings.efb_to_texture_enable;
+    packet >> m_net_settings.xfb_to_texture_enable;
+    packet >> m_net_settings.disable_copy_to_vram;
+    packet >> m_net_settings.immediate_xfb_enable;
+    packet >> m_net_settings.efb_emulate_format_changes;
+    packet >> m_net_settings.safe_texture_cache_color_samples;
+    packet >> m_net_settings.perf_queries_enable;
+    packet >> m_net_settings.float_exceptions;
+    packet >> m_net_settings.divide_by_zero_exceptions;
+    packet >> m_net_settings.fprf;
+    packet >> m_net_settings.accurate_nans;
+    packet >> m_net_settings.disable_icache;
+    packet >> m_net_settings.sync_on_skip_idle;
+    packet >> m_net_settings.sync_gpu;
+    packet >> m_net_settings.sync_gpu_max_distance;
+    packet >> m_net_settings.sync_gpu_min_distance;
+    packet >> m_net_settings.sync_gpu_overclock;
+    packet >> m_net_settings.jit_follow_branch;
+    packet >> m_net_settings.fast_disc_speed;
+    packet >> m_net_settings.mmu;
+    packet >> m_net_settings.fastmem;
+    packet >> m_net_settings.skip_ipl;
+    packet >> m_net_settings.load_ipl_dump;
+    packet >> m_net_settings.vertex_rounding;
+    packet >> m_net_settings.internal_resolution;
+    packet >> m_net_settings.efb_scaled_copy;
+    packet >> m_net_settings.fast_depth_calc;
+    packet >> m_net_settings.enable_pixel_lighting;
+    packet >> m_net_settings.widescreen_hack;
+    packet >> m_net_settings.force_filtering;
+    packet >> m_net_settings.max_anisotropy;
+    packet >> m_net_settings.force_true_color;
+    packet >> m_net_settings.disable_copy_filter;
+    packet >> m_net_settings.disable_fog;
+    packet >> m_net_settings.arbitrary_mipmap_detection;
+    packet >> m_net_settings.arbitrary_mipmap_detection_threshold;
+    packet >> m_net_settings.enable_gpu_texture_decoding;
+    packet >> m_net_settings.defer_efb_copies;
+    packet >> m_net_settings.efb_access_tile_size;
+    packet >> m_net_settings.efb_access_defer_invalidation;
+    packet >> m_net_settings.strict_settings_sync;
 
     m_initial_rtc = Common::PacketReadU64(packet);
 
-    packet >> m_net_settings.m_SyncSaveData;
-    packet >> m_net_settings.m_SaveDataRegion;
-    packet >> m_net_settings.m_SyncCodes;
-    packet >> m_net_settings.m_SyncAllWiiSaves;
+    packet >> m_net_settings.sync_save_data;
+    packet >> m_net_settings.save_data_region;
+    packet >> m_net_settings.sync_codes;
+    packet >> m_net_settings.sync_all_wii_saves;
 
-    for (int& extension : m_net_settings.m_WiimoteExtension)
+    for (int& extension : m_net_settings.wiimote_extension)
       packet >> extension;
 
-    packet >> m_net_settings.m_GolfMode;
-    packet >> m_net_settings.m_UseFMA;
-    packet >> m_net_settings.m_HideRemoteGBAs;
+    packet >> m_net_settings.golf_mode;
+    packet >> m_net_settings.use_fma;
+    packet >> m_net_settings.hide_remote_gbas;
 
-    m_net_settings.m_IsHosting = m_local_player->IsHost();
-    m_net_settings.m_HostInputAuthority = m_host_input_authority;
+    for (size_t i = 0; i < sizeof(m_net_settings.sram); ++i)
+      packet >> m_net_settings.sram[i];
+
+    m_net_settings.is_hosting = m_local_player->IsHost();
   }
 
   m_dialog->OnMsgStartGame();
@@ -910,6 +908,7 @@ void NetPlayClient::OnStopGame(sf::Packet& packet)
 
 void NetPlayClient::OnPowerButton()
 {
+  InvokeStop();
   m_dialog->OnMsgPowerButton();
 }
 
@@ -960,20 +959,6 @@ void NetPlayClient::OnDesyncDetected(sf::Packet& packet)
   m_dialog->OnDesync(frame, player);
 }
 
-void NetPlayClient::OnSyncGCSRAM(sf::Packet& packet)
-{
-  const size_t sram_settings_len = sizeof(g_SRAM) - offsetof(Sram, settings);
-  u8 sram[sram_settings_len];
-  for (u8& cell : sram)
-    packet >> cell;
-
-  {
-    std::lock_guard lkg(m_crit.game);
-    memcpy(&g_SRAM.settings, sram, sram_settings_len);
-    g_SRAM_netplay_initialized = true;
-  }
-}
-
 void NetPlayClient::OnSyncSaveData(sf::Packet& packet)
 {
   SyncSaveDataID sub_id;
@@ -2048,6 +2033,22 @@ u64 NetPlayClient::GetInitialRTCValue() const
   return m_initial_rtc;
 }
 
+bool NetPlayClient::WaitForWiimoteBuffer(int _number)
+{
+  while (m_wiimote_buffer[_number].Size() == 0)
+  {
+    if (!m_is_running.IsSet())
+    {
+      return false;
+    }
+
+    // wait for receiving thread to push some data
+    m_wii_pad_event.Wait();
+  }
+
+  return true;
+}
+
 // called from ---CPU--- thread
 bool NetPlayClient::WiimoteUpdate(int _number, u8* data, const std::size_t size, u8 reporting_mode)
 {
@@ -2073,16 +2074,8 @@ bool NetPlayClient::WiimoteUpdate(int _number, u8* data, const std::size_t size,
 
   }  // unlock players
 
-  while (m_wiimote_buffer[_number].Size() == 0)
-  {
-    if (!m_is_running.IsSet())
-    {
-      return false;
-    }
-
-    // wait for receiving thread to push some data
-    m_wii_pad_event.Wait();
-  }
+  if (!WaitForWiimoteBuffer(_number))
+    return false;
 
   m_wiimote_buffer[_number].Pop(nw);
 
@@ -2093,16 +2086,8 @@ bool NetPlayClient::WiimoteUpdate(int _number, u8* data, const std::size_t size,
     u32 tries = 0;
     while (nw.report_id != reporting_mode)
     {
-      while (m_wiimote_buffer[_number].Size() == 0)
-      {
-        if (!m_is_running.IsSet())
-        {
-          return false;
-        }
-
-        // wait for receiving thread to push some data
-        m_wii_pad_event.Wait();
-      }
+      if (!WaitForWiimoteBuffer(_number))
+        return false;
 
       m_wiimote_buffer[_number].Pop(nw);
 
@@ -2244,8 +2229,7 @@ void NetPlayClient::SendPadHostPoll(const PadIndex pad_num)
   SendAsync(std::move(packet));
 }
 
-// called from ---GUI--- thread and ---NETPLAY--- thread (client side)
-bool NetPlayClient::StopGame()
+void NetPlayClient::InvokeStop()
 {
   m_is_running.Clear();
 
@@ -2254,6 +2238,12 @@ bool NetPlayClient::StopGame()
   m_wii_pad_event.Set();
   m_first_pad_status_received_event.Set();
   m_wait_on_input_event.Set();
+}
+
+// called from ---GUI--- thread and ---NETPLAY--- thread (client side)
+bool NetPlayClient::StopGame()
+{
+  InvokeStop();
 
   NetPlay_Disable();
 
@@ -2269,13 +2259,7 @@ void NetPlayClient::Stop()
   if (!m_is_running.IsSet())
     return;
 
-  m_is_running.Clear();
-
-  // stop waiting for input
-  m_gc_pad_event.Set();
-  m_wii_pad_event.Set();
-  m_first_pad_status_received_event.Set();
-  m_wait_on_input_event.Set();
+  InvokeStop();
 
   // Tell the server to stop if we have a pad mapped in game.
   if (LocalPlayerHasControllerMapped())
@@ -2300,7 +2284,7 @@ void NetPlayClient::SendPowerButtonEvent()
 
 void NetPlayClient::RequestGolfControl(const PlayerId pid)
 {
-  if (!m_host_input_authority || !m_net_settings.m_GolfMode)
+  if (!m_host_input_authority || !m_net_settings.golf_mode)
     return;
 
   sf::Packet packet;
@@ -2402,7 +2386,7 @@ void NetPlayClient::SendGameStatus()
   for (size_t i = 0; i < 4; ++i)
   {
     if (m_gba_config[i].enabled && m_gba_config[i].has_rom &&
-        m_net_settings.m_GBARomPaths[i].empty())
+        m_net_settings.gba_rom_paths[i].empty())
     {
       result = SyncIdentifierComparison::DifferentGame;
     }
@@ -2592,7 +2576,7 @@ bool IsSyncingAllWiiSaves()
   std::lock_guard lk(crit_netplay_client);
 
   if (netplay_client)
-    return netplay_client->GetNetSettings().m_SyncAllWiiSaves;
+    return netplay_client->GetNetSettings().sync_all_wii_saves;
 
   return false;
 }
@@ -2602,14 +2586,14 @@ void SetupWiimotes()
   ASSERT(IsNetPlayRunning());
   const NetSettings& netplay_settings = netplay_client->GetNetSettings();
   const PadMappingArray& wiimote_map = netplay_client->GetWiimoteMapping();
-  for (size_t i = 0; i < netplay_settings.m_WiimoteExtension.size(); i++)
+  for (size_t i = 0; i < netplay_settings.wiimote_extension.size(); i++)
   {
     if (wiimote_map[i] > 0)
     {
       static_cast<ControllerEmu::Attachments*>(
           static_cast<WiimoteEmu::Wiimote*>(Wiimote::GetConfig()->GetController(int(i)))
               ->GetWiimoteGroup(WiimoteEmu::WiimoteGroup::Attachments))
-          ->SetSelectedAttachment(netplay_settings.m_WiimoteExtension[i]);
+          ->SetSelectedAttachment(netplay_settings.wiimote_extension[i]);
     }
   }
 }
@@ -2618,7 +2602,7 @@ std::string GetGBASavePath(int pad_num)
 {
   std::lock_guard lk(crit_netplay_client);
 
-  if (!netplay_client || netplay_client->GetNetSettings().m_IsHosting)
+  if (!netplay_client || netplay_client->GetNetSettings().is_hosting)
   {
 #ifdef HAS_LIBMGBA
     std::string rom_path = Config::Get(Config::MAIN_GBA_ROM_PATHS[pad_num]);
@@ -2628,7 +2612,7 @@ std::string GetGBASavePath(int pad_num)
 #endif
   }
 
-  if (!netplay_client->GetNetSettings().m_SyncSaveData)
+  if (!netplay_client->GetNetSettings().sync_save_data)
     return {};
 
   return fmt::format("{}{}{}.sav", File::GetUserPath(D_GBAUSER_IDX), GBA_SAVE_NETPLAY, pad_num + 1);
@@ -2664,7 +2648,7 @@ PadDetails GetPadDetails(int pad_num)
   }
   res.is_local = netplay_client->IsLocalPlayer(pad_map[pad_num]);
   res.local_pad = res.is_local ? local_pad : netplay_client->NumLocalPads() + non_local_pad;
-  res.hide_gba = !res.is_local && netplay_client->GetNetSettings().m_HideRemoteGBAs &&
+  res.hide_gba = !res.is_local && netplay_client->GetNetSettings().hide_remote_gbas &&
                  netplay_client->LocalPlayerHasControllerMapped();
   return res;
 }
diff --git a/Source/Core/Core/NetPlayClient.h b/Source/Core/Core/NetPlayClient.h
index d3d0273325..5e7fe3a3c5 100644
--- a/Source/Core/Core/NetPlayClient.h
+++ b/Source/Core/Core/NetPlayClient.h
@@ -117,6 +117,7 @@ public:
   // Called from the GUI thread.
   bool IsConnected() const { return m_is_connected; }
   bool StartGame(const std::string& path);
+  void InvokeStop();
   bool StopGame();
   void Stop();
   bool ChangeGame(const std::string& game);
@@ -252,6 +253,8 @@ private:
   void DisplayPlayersPing();
   u32 GetPlayersMaxPing() const;
 
+  bool WaitForWiimoteBuffer(int _number);
+
   void OnData(sf::Packet& packet);
   void OnPlayerJoin(sf::Packet& packet);
   void OnPlayerLeave(sf::Packet& packet);
@@ -278,7 +281,6 @@ private:
   void OnPing(sf::Packet& packet);
   void OnPlayerPingData(sf::Packet& packet);
   void OnDesyncDetected(sf::Packet& packet);
-  void OnSyncGCSRAM(sf::Packet& packet);
   void OnSyncSaveData(sf::Packet& packet);
   void OnSyncSaveDataNotify(sf::Packet& packet);
   void OnSyncSaveDataRaw(sf::Packet& packet);
diff --git a/Source/Core/Core/NetPlayProto.h b/Source/Core/Core/NetPlayProto.h
index 35f6dddf53..cd78e6700b 100644
--- a/Source/Core/Core/NetPlayProto.h
+++ b/Source/Core/Core/NetPlayProto.h
@@ -12,6 +12,7 @@
 #include "Core/Config/SYSCONFSettings.h"
 #include "Core/HW/EXI/EXI.h"
 #include "Core/HW/EXI/EXI_Device.h"
+#include "Core/HW/Sram.h"
 
 namespace DiscIO
 {
@@ -30,85 +31,86 @@ namespace NetPlay
 {
 struct NetSettings
 {
-  bool m_CPUthread = false;
-  PowerPC::CPUCore m_CPUcore{};
-  bool m_EnableCheats = false;
-  int m_SelectedLanguage = 0;
-  bool m_OverrideRegionSettings = false;
-  bool m_DSPHLE = false;
-  bool m_DSPEnableJIT = false;
-  bool m_WriteToMemcard = false;
-  bool m_RAMOverrideEnable = false;
-  u32 m_Mem1Size = 0;
-  u32 m_Mem2Size = 0;
-  DiscIO::Region m_FallbackRegion{};
-  bool m_AllowSDWrites = false;
-  bool m_CopyWiiSave = false;
-  bool m_OCEnable = false;
-  float m_OCFactor = 0;
-  Common::EnumMap<ExpansionInterface::EXIDeviceType, ExpansionInterface::MAX_SLOT> m_EXIDevice{};
-  int m_MemcardSizeOverride = -1;
+  bool cpu_thread = false;
+  PowerPC::CPUCore cpu_core{};
+  bool enable_cheats = false;
+  int selected_language = 0;
+  bool override_region_settings = false;
+  bool dsp_hle = false;
+  bool dsp_enable_jit = false;
+  bool write_to_memcard = false;
+  bool ram_override_enable = false;
+  u32 mem1_size = 0;
+  u32 mem2_size = 0;
+  DiscIO::Region fallback_region{};
+  bool allow_sd_writes = false;
+  bool copy_wii_save = false;
+  bool oc_enable = false;
+  float oc_factor = 0;
+  Common::EnumMap<ExpansionInterface::EXIDeviceType, ExpansionInterface::MAX_SLOT> exi_device{};
+  int memcard_size_override = -1;
 
-  std::array<u32, Config::SYSCONF_SETTINGS.size()> m_SYSCONFSettings{};
+  std::array<u32, Config::SYSCONF_SETTINGS.size()> sysconf_settings{};
 
-  bool m_EFBAccessEnable = false;
-  bool m_BBoxEnable = false;
-  bool m_ForceProgressive = false;
-  bool m_EFBToTextureEnable = false;
-  bool m_XFBToTextureEnable = false;
-  bool m_DisableCopyToVRAM = false;
-  bool m_ImmediateXFBEnable = false;
-  bool m_EFBEmulateFormatChanges = false;
-  int m_SafeTextureCacheColorSamples = 0;
-  bool m_PerfQueriesEnable = false;
-  bool m_FloatExceptions = false;
-  bool m_DivideByZeroExceptions = false;
-  bool m_FPRF = false;
-  bool m_AccurateNaNs = false;
-  bool m_DisableICache = false;
-  bool m_SyncOnSkipIdle = false;
-  bool m_SyncGPU = false;
-  int m_SyncGpuMaxDistance = 0;
-  int m_SyncGpuMinDistance = 0;
-  float m_SyncGpuOverclock = 0;
-  bool m_JITFollowBranch = false;
-  bool m_FastDiscSpeed = false;
-  bool m_MMU = false;
-  bool m_Fastmem = false;
-  bool m_SkipIPL = false;
-  bool m_LoadIPLDump = false;
-  bool m_VertexRounding = false;
-  int m_InternalResolution = 0;
-  bool m_EFBScaledCopy = false;
-  bool m_FastDepthCalc = false;
-  bool m_EnablePixelLighting = false;
-  bool m_WidescreenHack = false;
-  bool m_ForceFiltering = false;
-  int m_MaxAnisotropy = 0;
-  bool m_ForceTrueColor = false;
-  bool m_DisableCopyFilter = false;
-  bool m_DisableFog = false;
-  bool m_ArbitraryMipmapDetection = false;
-  float m_ArbitraryMipmapDetectionThreshold = 0;
-  bool m_EnableGPUTextureDecoding = false;
-  bool m_DeferEFBCopies = false;
-  int m_EFBAccessTileSize = 0;
-  bool m_EFBAccessDeferInvalidation = false;
+  bool efb_access_enable = false;
+  bool bbox_enable = false;
+  bool force_progressive = false;
+  bool efb_to_texture_enable = false;
+  bool xfb_to_texture_enable = false;
+  bool disable_copy_to_vram = false;
+  bool immediate_xfb_enable = false;
+  bool efb_emulate_format_changes = false;
+  int safe_texture_cache_color_samples = 0;
+  bool perf_queries_enable = false;
+  bool float_exceptions = false;
+  bool divide_by_zero_exceptions = false;
+  bool fprf = false;
+  bool accurate_nans = false;
+  bool disable_icache = false;
+  bool sync_on_skip_idle = false;
+  bool sync_gpu = false;
+  int sync_gpu_max_distance = 0;
+  int sync_gpu_min_distance = 0;
+  float sync_gpu_overclock = 0;
+  bool jit_follow_branch = false;
+  bool fast_disc_speed = false;
+  bool mmu = false;
+  bool fastmem = false;
+  bool skip_ipl = false;
+  bool load_ipl_dump = false;
+  bool vertex_rounding = false;
+  int internal_resolution = 0;
+  bool efb_scaled_copy = false;
+  bool fast_depth_calc = false;
+  bool enable_pixel_lighting = false;
+  bool widescreen_hack = false;
+  bool force_filtering = false;
+  int max_anisotropy = 0;
+  bool force_true_color = false;
+  bool disable_copy_filter = false;
+  bool disable_fog = false;
+  bool arbitrary_mipmap_detection = false;
+  float arbitrary_mipmap_detection_threshold = 0;
+  bool enable_gpu_texture_decoding = false;
+  bool defer_efb_copies = false;
+  int efb_access_tile_size = 0;
+  bool efb_access_defer_invalidation = false;
 
-  bool m_StrictSettingsSync = false;
-  bool m_SyncSaveData = false;
-  bool m_SyncCodes = false;
-  std::string m_SaveDataRegion;
-  bool m_SyncAllWiiSaves = false;
-  std::array<int, 4> m_WiimoteExtension{};
-  bool m_GolfMode = false;
-  bool m_UseFMA = false;
-  bool m_HideRemoteGBAs = false;
+  bool strict_settings_sync = false;
+  bool sync_save_data = false;
+  bool sync_codes = false;
+  std::string save_data_region;
+  bool sync_all_wii_saves = false;
+  std::array<int, 4> wiimote_extension{};
+  bool golf_mode = false;
+  bool use_fma = false;
+  bool hide_remote_gbas = false;
+
+  Sram sram;
 
   // These aren't sent over the network directly
-  bool m_IsHosting = false;
-  bool m_HostInputAuthority = false;
-  std::array<std::string, 4> m_GBARomPaths{};
+  bool is_hosting = false;
+  std::array<std::string, 4> gba_rom_paths{};
 };
 
 struct NetTraversalConfig
@@ -181,7 +183,6 @@ enum class MessageID : u8
   Pong = 0xE1,
   PlayerPingData = 0xE2,
 
-  SyncGCSRAM = 0xF0,
   SyncSaveData = 0xF1,
   SyncCodes = 0xF2,
 };
diff --git a/Source/Core/Core/NetPlayServer.cpp b/Source/Core/Core/NetPlayServer.cpp
index da69d1abfa..f521e20a24 100644
--- a/Source/Core/Core/NetPlayServer.cpp
+++ b/Source/Core/Core/NetPlayServer.cpp
@@ -862,7 +862,7 @@ unsigned int NetPlayServer::OnData(sf::Packet& packet, Client& player)
     if (!m_players.count(pid) || !PlayerHasControllerMapped(player.pid))
       break;
 
-    if (m_host_input_authority && m_settings.m_GolfMode && m_pending_golfer == 0 &&
+    if (m_host_input_authority && m_settings.golf_mode && m_pending_golfer == 0 &&
         m_current_golfer != pid && PlayerHasControllerMapped(pid))
     {
       m_pending_golfer = pid;
@@ -1254,22 +1254,22 @@ bool NetPlayServer::SetupNetSettings()
       ConfigLoaders::GenerateLocalGameConfigLoader(game->GetGameID(), game->GetRevision()));
 
   // Copy all relevant settings
-  settings.m_CPUthread = Config::Get(Config::MAIN_CPU_THREAD);
-  settings.m_CPUcore = Config::Get(Config::MAIN_CPU_CORE);
-  settings.m_EnableCheats = Config::Get(Config::MAIN_ENABLE_CHEATS);
-  settings.m_SelectedLanguage = Config::Get(Config::MAIN_GC_LANGUAGE);
-  settings.m_OverrideRegionSettings = Config::Get(Config::MAIN_OVERRIDE_REGION_SETTINGS);
-  settings.m_DSPHLE = Config::Get(Config::MAIN_DSP_HLE);
-  settings.m_DSPEnableJIT = Config::Get(Config::MAIN_DSP_JIT);
-  settings.m_WriteToMemcard = Config::Get(Config::NETPLAY_WRITE_SAVE_DATA);
-  settings.m_RAMOverrideEnable = Config::Get(Config::MAIN_RAM_OVERRIDE_ENABLE);
-  settings.m_Mem1Size = Config::Get(Config::MAIN_MEM1_SIZE);
-  settings.m_Mem2Size = Config::Get(Config::MAIN_MEM2_SIZE);
-  settings.m_FallbackRegion = Config::Get(Config::MAIN_FALLBACK_REGION);
-  settings.m_AllowSDWrites = Config::Get(Config::MAIN_ALLOW_SD_WRITES);
-  settings.m_CopyWiiSave = Config::Get(Config::NETPLAY_LOAD_WII_SAVE);
-  settings.m_OCEnable = Config::Get(Config::MAIN_OVERCLOCK_ENABLE);
-  settings.m_OCFactor = Config::Get(Config::MAIN_OVERCLOCK);
+  settings.cpu_thread = Config::Get(Config::MAIN_CPU_THREAD);
+  settings.cpu_core = Config::Get(Config::MAIN_CPU_CORE);
+  settings.enable_cheats = Config::Get(Config::MAIN_ENABLE_CHEATS);
+  settings.selected_language = Config::Get(Config::MAIN_GC_LANGUAGE);
+  settings.override_region_settings = Config::Get(Config::MAIN_OVERRIDE_REGION_SETTINGS);
+  settings.dsp_hle = Config::Get(Config::MAIN_DSP_HLE);
+  settings.dsp_enable_jit = Config::Get(Config::MAIN_DSP_JIT);
+  settings.write_to_memcard = Config::Get(Config::NETPLAY_WRITE_SAVE_DATA);
+  settings.ram_override_enable = Config::Get(Config::MAIN_RAM_OVERRIDE_ENABLE);
+  settings.mem1_size = Config::Get(Config::MAIN_MEM1_SIZE);
+  settings.mem2_size = Config::Get(Config::MAIN_MEM2_SIZE);
+  settings.fallback_region = Config::Get(Config::MAIN_FALLBACK_REGION);
+  settings.allow_sd_writes = Config::Get(Config::MAIN_ALLOW_SD_WRITES);
+  settings.copy_wii_save = Config::Get(Config::NETPLAY_LOAD_WII_SAVE);
+  settings.oc_enable = Config::Get(Config::MAIN_OVERCLOCK_ENABLE);
+  settings.oc_factor = Config::Get(Config::MAIN_OVERCLOCK);
 
   for (ExpansionInterface::Slot slot : ExpansionInterface::SLOTS)
   {
@@ -1283,75 +1283,75 @@ bool NetPlayServer::SetupNetSettings()
     {
       device = Config::Get(Config::GetInfoForEXIDevice(slot));
     }
-    settings.m_EXIDevice[slot] = device;
+    settings.exi_device[slot] = device;
   }
 
-  settings.m_MemcardSizeOverride = Config::Get(Config::MAIN_MEMORY_CARD_SIZE);
+  settings.memcard_size_override = Config::Get(Config::MAIN_MEMORY_CARD_SIZE);
 
   for (size_t i = 0; i < Config::SYSCONF_SETTINGS.size(); ++i)
   {
     std::visit(
         [&](auto* info) {
           static_assert(sizeof(info->GetDefaultValue()) <= sizeof(u32));
-          settings.m_SYSCONFSettings[i] = static_cast<u32>(Config::Get(*info));
+          settings.sysconf_settings[i] = static_cast<u32>(Config::Get(*info));
         },
         Config::SYSCONF_SETTINGS[i].config_info);
   }
 
-  settings.m_EFBAccessEnable = Config::Get(Config::GFX_HACK_EFB_ACCESS_ENABLE);
-  settings.m_BBoxEnable = Config::Get(Config::GFX_HACK_BBOX_ENABLE);
-  settings.m_ForceProgressive = Config::Get(Config::GFX_HACK_FORCE_PROGRESSIVE);
-  settings.m_EFBToTextureEnable = Config::Get(Config::GFX_HACK_SKIP_EFB_COPY_TO_RAM);
-  settings.m_XFBToTextureEnable = Config::Get(Config::GFX_HACK_SKIP_XFB_COPY_TO_RAM);
-  settings.m_DisableCopyToVRAM = Config::Get(Config::GFX_HACK_DISABLE_COPY_TO_VRAM);
-  settings.m_ImmediateXFBEnable = Config::Get(Config::GFX_HACK_IMMEDIATE_XFB);
-  settings.m_EFBEmulateFormatChanges = Config::Get(Config::GFX_HACK_EFB_EMULATE_FORMAT_CHANGES);
-  settings.m_SafeTextureCacheColorSamples =
+  settings.efb_access_enable = Config::Get(Config::GFX_HACK_EFB_ACCESS_ENABLE);
+  settings.bbox_enable = Config::Get(Config::GFX_HACK_BBOX_ENABLE);
+  settings.force_progressive = Config::Get(Config::GFX_HACK_FORCE_PROGRESSIVE);
+  settings.efb_to_texture_enable = Config::Get(Config::GFX_HACK_SKIP_EFB_COPY_TO_RAM);
+  settings.xfb_to_texture_enable = Config::Get(Config::GFX_HACK_SKIP_XFB_COPY_TO_RAM);
+  settings.disable_copy_to_vram = Config::Get(Config::GFX_HACK_DISABLE_COPY_TO_VRAM);
+  settings.immediate_xfb_enable = Config::Get(Config::GFX_HACK_IMMEDIATE_XFB);
+  settings.efb_emulate_format_changes = Config::Get(Config::GFX_HACK_EFB_EMULATE_FORMAT_CHANGES);
+  settings.safe_texture_cache_color_samples =
       Config::Get(Config::GFX_SAFE_TEXTURE_CACHE_COLOR_SAMPLES);
-  settings.m_PerfQueriesEnable = Config::Get(Config::GFX_PERF_QUERIES_ENABLE);
-  settings.m_FloatExceptions = Config::Get(Config::MAIN_FLOAT_EXCEPTIONS);
-  settings.m_DivideByZeroExceptions = Config::Get(Config::MAIN_DIVIDE_BY_ZERO_EXCEPTIONS);
-  settings.m_FPRF = Config::Get(Config::MAIN_FPRF);
-  settings.m_AccurateNaNs = Config::Get(Config::MAIN_ACCURATE_NANS);
-  settings.m_DisableICache = Config::Get(Config::MAIN_DISABLE_ICACHE);
-  settings.m_SyncOnSkipIdle = Config::Get(Config::MAIN_SYNC_ON_SKIP_IDLE);
-  settings.m_SyncGPU = Config::Get(Config::MAIN_SYNC_GPU);
-  settings.m_SyncGpuMaxDistance = Config::Get(Config::MAIN_SYNC_GPU_MAX_DISTANCE);
-  settings.m_SyncGpuMinDistance = Config::Get(Config::MAIN_SYNC_GPU_MIN_DISTANCE);
-  settings.m_SyncGpuOverclock = Config::Get(Config::MAIN_SYNC_GPU_OVERCLOCK);
-  settings.m_JITFollowBranch = Config::Get(Config::MAIN_JIT_FOLLOW_BRANCH);
-  settings.m_FastDiscSpeed = Config::Get(Config::MAIN_FAST_DISC_SPEED);
-  settings.m_MMU = Config::Get(Config::MAIN_MMU);
-  settings.m_Fastmem = Config::Get(Config::MAIN_FASTMEM);
-  settings.m_SkipIPL = Config::Get(Config::MAIN_SKIP_IPL) || !DoAllPlayersHaveIPLDump();
-  settings.m_LoadIPLDump = Config::Get(Config::SESSION_LOAD_IPL_DUMP) && DoAllPlayersHaveIPLDump();
-  settings.m_VertexRounding = Config::Get(Config::GFX_HACK_VERTEX_ROUNDING);
-  settings.m_InternalResolution = Config::Get(Config::GFX_EFB_SCALE);
-  settings.m_EFBScaledCopy = Config::Get(Config::GFX_HACK_COPY_EFB_SCALED);
-  settings.m_FastDepthCalc = Config::Get(Config::GFX_FAST_DEPTH_CALC);
-  settings.m_EnablePixelLighting = Config::Get(Config::GFX_ENABLE_PIXEL_LIGHTING);
-  settings.m_WidescreenHack = Config::Get(Config::GFX_WIDESCREEN_HACK);
-  settings.m_ForceFiltering = Config::Get(Config::GFX_ENHANCE_FORCE_FILTERING);
-  settings.m_MaxAnisotropy = Config::Get(Config::GFX_ENHANCE_MAX_ANISOTROPY);
-  settings.m_ForceTrueColor = Config::Get(Config::GFX_ENHANCE_FORCE_TRUE_COLOR);
-  settings.m_DisableCopyFilter = Config::Get(Config::GFX_ENHANCE_DISABLE_COPY_FILTER);
-  settings.m_DisableFog = Config::Get(Config::GFX_DISABLE_FOG);
-  settings.m_ArbitraryMipmapDetection = Config::Get(Config::GFX_ENHANCE_ARBITRARY_MIPMAP_DETECTION);
-  settings.m_ArbitraryMipmapDetectionThreshold =
+  settings.perf_queries_enable = Config::Get(Config::GFX_PERF_QUERIES_ENABLE);
+  settings.float_exceptions = Config::Get(Config::MAIN_FLOAT_EXCEPTIONS);
+  settings.divide_by_zero_exceptions = Config::Get(Config::MAIN_DIVIDE_BY_ZERO_EXCEPTIONS);
+  settings.fprf = Config::Get(Config::MAIN_FPRF);
+  settings.accurate_nans = Config::Get(Config::MAIN_ACCURATE_NANS);
+  settings.disable_icache = Config::Get(Config::MAIN_DISABLE_ICACHE);
+  settings.sync_on_skip_idle = Config::Get(Config::MAIN_SYNC_ON_SKIP_IDLE);
+  settings.sync_gpu = Config::Get(Config::MAIN_SYNC_GPU);
+  settings.sync_gpu_max_distance = Config::Get(Config::MAIN_SYNC_GPU_MAX_DISTANCE);
+  settings.sync_gpu_min_distance = Config::Get(Config::MAIN_SYNC_GPU_MIN_DISTANCE);
+  settings.sync_gpu_overclock = Config::Get(Config::MAIN_SYNC_GPU_OVERCLOCK);
+  settings.jit_follow_branch = Config::Get(Config::MAIN_JIT_FOLLOW_BRANCH);
+  settings.fast_disc_speed = Config::Get(Config::MAIN_FAST_DISC_SPEED);
+  settings.mmu = Config::Get(Config::MAIN_MMU);
+  settings.fastmem = Config::Get(Config::MAIN_FASTMEM);
+  settings.skip_ipl = Config::Get(Config::MAIN_SKIP_IPL) || !DoAllPlayersHaveIPLDump();
+  settings.load_ipl_dump = Config::Get(Config::SESSION_LOAD_IPL_DUMP) && DoAllPlayersHaveIPLDump();
+  settings.vertex_rounding = Config::Get(Config::GFX_HACK_VERTEX_ROUNDING);
+  settings.internal_resolution = Config::Get(Config::GFX_EFB_SCALE);
+  settings.efb_scaled_copy = Config::Get(Config::GFX_HACK_COPY_EFB_SCALED);
+  settings.fast_depth_calc = Config::Get(Config::GFX_FAST_DEPTH_CALC);
+  settings.enable_pixel_lighting = Config::Get(Config::GFX_ENABLE_PIXEL_LIGHTING);
+  settings.widescreen_hack = Config::Get(Config::GFX_WIDESCREEN_HACK);
+  settings.force_filtering = Config::Get(Config::GFX_ENHANCE_FORCE_FILTERING);
+  settings.max_anisotropy = Config::Get(Config::GFX_ENHANCE_MAX_ANISOTROPY);
+  settings.force_true_color = Config::Get(Config::GFX_ENHANCE_FORCE_TRUE_COLOR);
+  settings.disable_copy_filter = Config::Get(Config::GFX_ENHANCE_DISABLE_COPY_FILTER);
+  settings.disable_fog = Config::Get(Config::GFX_DISABLE_FOG);
+  settings.arbitrary_mipmap_detection = Config::Get(Config::GFX_ENHANCE_ARBITRARY_MIPMAP_DETECTION);
+  settings.arbitrary_mipmap_detection_threshold =
       Config::Get(Config::GFX_ENHANCE_ARBITRARY_MIPMAP_DETECTION_THRESHOLD);
-  settings.m_EnableGPUTextureDecoding = Config::Get(Config::GFX_ENABLE_GPU_TEXTURE_DECODING);
-  settings.m_DeferEFBCopies = Config::Get(Config::GFX_HACK_DEFER_EFB_COPIES);
-  settings.m_EFBAccessTileSize = Config::Get(Config::GFX_HACK_EFB_ACCESS_TILE_SIZE);
-  settings.m_EFBAccessDeferInvalidation = Config::Get(Config::GFX_HACK_EFB_DEFER_INVALIDATION);
+  settings.enable_gpu_texture_decoding = Config::Get(Config::GFX_ENABLE_GPU_TEXTURE_DECODING);
+  settings.defer_efb_copies = Config::Get(Config::GFX_HACK_DEFER_EFB_COPIES);
+  settings.efb_access_tile_size = Config::Get(Config::GFX_HACK_EFB_ACCESS_TILE_SIZE);
+  settings.efb_access_defer_invalidation = Config::Get(Config::GFX_HACK_EFB_DEFER_INVALIDATION);
 
-  settings.m_StrictSettingsSync = Config::Get(Config::NETPLAY_STRICT_SETTINGS_SYNC);
-  settings.m_SyncSaveData = Config::Get(Config::NETPLAY_SYNC_SAVES);
-  settings.m_SyncCodes = Config::Get(Config::NETPLAY_SYNC_CODES);
-  settings.m_SyncAllWiiSaves =
+  settings.strict_settings_sync = Config::Get(Config::NETPLAY_STRICT_SETTINGS_SYNC);
+  settings.sync_save_data = Config::Get(Config::NETPLAY_SYNC_SAVES);
+  settings.sync_codes = Config::Get(Config::NETPLAY_SYNC_CODES);
+  settings.sync_all_wii_saves =
       Config::Get(Config::NETPLAY_SYNC_ALL_WII_SAVES) && Config::Get(Config::NETPLAY_SYNC_SAVES);
-  settings.m_GolfMode = Config::Get(Config::NETPLAY_NETWORK_MODE) == "golf";
-  settings.m_UseFMA = DoAllPlayersHaveHardwareFMA();
-  settings.m_HideRemoteGBAs = Config::Get(Config::NETPLAY_HIDE_REMOTE_GBAS);
+  settings.golf_mode = Config::Get(Config::NETPLAY_NETWORK_MODE) == "golf";
+  settings.use_fma = DoAllPlayersHaveHardwareFMA();
+  settings.hide_remote_gbas = Config::Get(Config::NETPLAY_HIDE_REMOTE_GBAS);
 
   // Unload GameINI to restore things to normal
   Config::RemoveLayer(Config::LayerType::GlobalGame);
@@ -1382,7 +1382,7 @@ bool NetPlayServer::RequestStartGame()
 
   bool start_now = true;
 
-  if (m_settings.m_SyncSaveData && m_players.size() > 1)
+  if (m_settings.sync_save_data && m_players.size() > 1)
   {
     start_now = false;
     m_start_pending = true;
@@ -1395,7 +1395,7 @@ bool NetPlayServer::RequestStartGame()
   }
 
   // Check To Send Codes to Clients
-  if (m_settings.m_SyncCodes && m_players.size() > 1)
+  if (m_settings.sync_codes && m_players.size() > 1)
   {
     start_now = false;
     m_start_pending = true;
@@ -1436,101 +1436,90 @@ bool NetPlayServer::StartGame()
   const std::string region = Config::GetDirectoryForRegion(
       Config::ToGameCubeRegion(m_dialog->FindGameFile(m_selected_game_identifier)->GetRegion()));
 
-  // sync GC SRAM with clients
-  if (!g_SRAM_netplay_initialized)
-  {
-    SConfig::GetInstance().m_strSRAM = File::GetUserPath(F_GCSRAM_IDX);
-    InitSRAM();
-    g_SRAM_netplay_initialized = true;
-  }
-  sf::Packet srampac;
-  srampac << MessageID::SyncGCSRAM;
-  for (size_t i = 0; i < sizeof(g_SRAM) - offsetof(Sram, settings); ++i)
-  {
-    srampac << g_SRAM[offsetof(Sram, settings) + i];
-  }
-  SendAsyncToClients(std::move(srampac), 1);
+  // load host's GC SRAM
+  SConfig::GetInstance().m_strSRAM = File::GetUserPath(F_GCSRAM_IDX);
+  InitSRAM(&m_settings.sram, SConfig::GetInstance().m_strSRAM);
 
   // tell clients to start game
   sf::Packet spac;
   spac << MessageID::StartGame;
   spac << m_current_game;
-  spac << m_settings.m_CPUthread;
-  spac << m_settings.m_CPUcore;
-  spac << m_settings.m_EnableCheats;
-  spac << m_settings.m_SelectedLanguage;
-  spac << m_settings.m_OverrideRegionSettings;
-  spac << m_settings.m_DSPEnableJIT;
-  spac << m_settings.m_DSPHLE;
-  spac << m_settings.m_WriteToMemcard;
-  spac << m_settings.m_RAMOverrideEnable;
-  spac << m_settings.m_Mem1Size;
-  spac << m_settings.m_Mem2Size;
-  spac << m_settings.m_FallbackRegion;
-  spac << m_settings.m_AllowSDWrites;
-  spac << m_settings.m_CopyWiiSave;
-  spac << m_settings.m_OCEnable;
-  spac << m_settings.m_OCFactor;
+  spac << m_settings.cpu_thread;
+  spac << m_settings.cpu_core;
+  spac << m_settings.enable_cheats;
+  spac << m_settings.selected_language;
+  spac << m_settings.override_region_settings;
+  spac << m_settings.dsp_enable_jit;
+  spac << m_settings.dsp_hle;
+  spac << m_settings.write_to_memcard;
+  spac << m_settings.ram_override_enable;
+  spac << m_settings.mem1_size;
+  spac << m_settings.mem2_size;
+  spac << m_settings.fallback_region;
+  spac << m_settings.allow_sd_writes;
+  spac << m_settings.copy_wii_save;
+  spac << m_settings.oc_enable;
+  spac << m_settings.oc_factor;
 
   for (auto slot : ExpansionInterface::SLOTS)
-    spac << static_cast<int>(m_settings.m_EXIDevice[slot]);
+    spac << static_cast<int>(m_settings.exi_device[slot]);
 
-  spac << m_settings.m_MemcardSizeOverride;
+  spac << m_settings.memcard_size_override;
 
-  for (u32 value : m_settings.m_SYSCONFSettings)
+  for (u32 value : m_settings.sysconf_settings)
     spac << value;
 
-  spac << m_settings.m_EFBAccessEnable;
-  spac << m_settings.m_BBoxEnable;
-  spac << m_settings.m_ForceProgressive;
-  spac << m_settings.m_EFBToTextureEnable;
-  spac << m_settings.m_XFBToTextureEnable;
-  spac << m_settings.m_DisableCopyToVRAM;
-  spac << m_settings.m_ImmediateXFBEnable;
-  spac << m_settings.m_EFBEmulateFormatChanges;
-  spac << m_settings.m_SafeTextureCacheColorSamples;
-  spac << m_settings.m_PerfQueriesEnable;
-  spac << m_settings.m_FloatExceptions;
-  spac << m_settings.m_DivideByZeroExceptions;
-  spac << m_settings.m_FPRF;
-  spac << m_settings.m_AccurateNaNs;
-  spac << m_settings.m_DisableICache;
-  spac << m_settings.m_SyncOnSkipIdle;
-  spac << m_settings.m_SyncGPU;
-  spac << m_settings.m_SyncGpuMaxDistance;
-  spac << m_settings.m_SyncGpuMinDistance;
-  spac << m_settings.m_SyncGpuOverclock;
-  spac << m_settings.m_JITFollowBranch;
-  spac << m_settings.m_FastDiscSpeed;
-  spac << m_settings.m_MMU;
-  spac << m_settings.m_Fastmem;
-  spac << m_settings.m_SkipIPL;
-  spac << m_settings.m_LoadIPLDump;
-  spac << m_settings.m_VertexRounding;
-  spac << m_settings.m_InternalResolution;
-  spac << m_settings.m_EFBScaledCopy;
-  spac << m_settings.m_FastDepthCalc;
-  spac << m_settings.m_EnablePixelLighting;
-  spac << m_settings.m_WidescreenHack;
-  spac << m_settings.m_ForceFiltering;
-  spac << m_settings.m_MaxAnisotropy;
-  spac << m_settings.m_ForceTrueColor;
-  spac << m_settings.m_DisableCopyFilter;
-  spac << m_settings.m_DisableFog;
-  spac << m_settings.m_ArbitraryMipmapDetection;
-  spac << m_settings.m_ArbitraryMipmapDetectionThreshold;
-  spac << m_settings.m_EnableGPUTextureDecoding;
-  spac << m_settings.m_DeferEFBCopies;
-  spac << m_settings.m_EFBAccessTileSize;
-  spac << m_settings.m_EFBAccessDeferInvalidation;
-  spac << m_settings.m_StrictSettingsSync;
+  spac << m_settings.efb_access_enable;
+  spac << m_settings.bbox_enable;
+  spac << m_settings.force_progressive;
+  spac << m_settings.efb_to_texture_enable;
+  spac << m_settings.xfb_to_texture_enable;
+  spac << m_settings.disable_copy_to_vram;
+  spac << m_settings.immediate_xfb_enable;
+  spac << m_settings.efb_emulate_format_changes;
+  spac << m_settings.safe_texture_cache_color_samples;
+  spac << m_settings.perf_queries_enable;
+  spac << m_settings.float_exceptions;
+  spac << m_settings.divide_by_zero_exceptions;
+  spac << m_settings.fprf;
+  spac << m_settings.accurate_nans;
+  spac << m_settings.disable_icache;
+  spac << m_settings.sync_on_skip_idle;
+  spac << m_settings.sync_gpu;
+  spac << m_settings.sync_gpu_max_distance;
+  spac << m_settings.sync_gpu_min_distance;
+  spac << m_settings.sync_gpu_overclock;
+  spac << m_settings.jit_follow_branch;
+  spac << m_settings.fast_disc_speed;
+  spac << m_settings.mmu;
+  spac << m_settings.fastmem;
+  spac << m_settings.skip_ipl;
+  spac << m_settings.load_ipl_dump;
+  spac << m_settings.vertex_rounding;
+  spac << m_settings.internal_resolution;
+  spac << m_settings.efb_scaled_copy;
+  spac << m_settings.fast_depth_calc;
+  spac << m_settings.enable_pixel_lighting;
+  spac << m_settings.widescreen_hack;
+  spac << m_settings.force_filtering;
+  spac << m_settings.max_anisotropy;
+  spac << m_settings.force_true_color;
+  spac << m_settings.disable_copy_filter;
+  spac << m_settings.disable_fog;
+  spac << m_settings.arbitrary_mipmap_detection;
+  spac << m_settings.arbitrary_mipmap_detection_threshold;
+  spac << m_settings.enable_gpu_texture_decoding;
+  spac << m_settings.defer_efb_copies;
+  spac << m_settings.efb_access_tile_size;
+  spac << m_settings.efb_access_defer_invalidation;
+  spac << m_settings.strict_settings_sync;
   spac << initial_rtc;
-  spac << m_settings.m_SyncSaveData;
+  spac << m_settings.sync_save_data;
   spac << region;
-  spac << m_settings.m_SyncCodes;
-  spac << m_settings.m_SyncAllWiiSaves;
+  spac << m_settings.sync_codes;
+  spac << m_settings.sync_all_wii_saves;
 
-  for (size_t i = 0; i < m_settings.m_WiimoteExtension.size(); i++)
+  for (size_t i = 0; i < m_settings.wiimote_extension.size(); i++)
   {
     const int extension =
         static_cast<ControllerEmu::Attachments*>(
@@ -1540,9 +1529,12 @@ bool NetPlayServer::StartGame()
     spac << extension;
   }
 
-  spac << m_settings.m_GolfMode;
-  spac << m_settings.m_UseFMA;
-  spac << m_settings.m_HideRemoteGBAs;
+  spac << m_settings.golf_mode;
+  spac << m_settings.use_fma;
+  spac << m_settings.hide_remote_gbas;
+
+  for (size_t i = 0; i < sizeof(m_settings.sram); ++i)
+    spac << m_settings.sram[i];
 
   SendAsyncToClients(std::move(spac));
 
@@ -1574,7 +1566,7 @@ bool NetPlayServer::SyncSaveData()
 
   for (ExpansionInterface::Slot slot : ExpansionInterface::MEMCARD_SLOTS)
   {
-    if (m_settings.m_EXIDevice[slot] == ExpansionInterface::EXIDeviceType::MemoryCard ||
+    if (m_settings.exi_device[slot] == ExpansionInterface::EXIDeviceType::MemoryCard ||
         Config::Get(Config::GetInfoForEXIDevice(slot)) ==
             ExpansionInterface::EXIDeviceType::MemoryCardFolder)
     {
@@ -1590,7 +1582,7 @@ bool NetPlayServer::SyncSaveData()
   }
 
   bool wii_save = false;
-  if (m_settings.m_CopyWiiSave && (game->GetPlatform() == DiscIO::Platform::WiiDisc ||
+  if (m_settings.copy_wii_save && (game->GetPlatform() == DiscIO::Platform::WiiDisc ||
                                    game->GetPlatform() == DiscIO::Platform::WiiWAD ||
                                    game->GetPlatform() == DiscIO::Platform::ELFOrDOL))
   {
@@ -1635,9 +1627,9 @@ bool NetPlayServer::SyncSaveData()
   {
     const bool is_slot_a = slot == ExpansionInterface::Slot::A;
 
-    if (m_settings.m_EXIDevice[slot] == ExpansionInterface::EXIDeviceType::MemoryCard)
+    if (m_settings.exi_device[slot] == ExpansionInterface::EXIDeviceType::MemoryCard)
     {
-      const int size_override = m_settings.m_MemcardSizeOverride;
+      const int size_override = m_settings.memcard_size_override;
       const u16 card_size_mbits =
           size_override >= 0 && size_override <= 4 ?
               static_cast<u16>(Memcard::MBIT_SIZE_MEMORY_CARD_59 << size_override) :
@@ -1703,7 +1695,7 @@ bool NetPlayServer::SyncSaveData()
     const auto configured_fs = IOS::HLE::FS::MakeFileSystem(IOS::HLE::FS::Location::Configured);
 
     std::vector<std::pair<u64, WiiSave::StoragePointer>> saves;
-    if (m_settings.m_SyncAllWiiSaves)
+    if (m_settings.sync_all_wii_saves)
     {
       IOS::HLE::Kernel ios;
       for (const u64 title : ios.GetES()->GetInstalledTitles())
diff --git a/Source/Core/Core/PowerPC/JitArm64/JitArm64_SystemRegisters.cpp b/Source/Core/Core/PowerPC/JitArm64/JitArm64_SystemRegisters.cpp
index 3d48711d04..6a8245b8bb 100644
--- a/Source/Core/Core/PowerPC/JitArm64/JitArm64_SystemRegisters.cpp
+++ b/Source/Core/Core/PowerPC/JitArm64/JitArm64_SystemRegisters.cpp
@@ -336,6 +336,7 @@ void JitArm64::mfspr(UGeckoInstruction inst)
 
     ADD(Xresult, XA, Xresult, ArithOption(Xresult, ShiftType::LSR, 3));
     STR(IndexType::Unsigned, Xresult, PPC_REG, PPCSTATE_OFF_SPR(SPR_TL));
+    static_assert((PPCSTATE_OFF_SPR(SPR_TL) & 0x7) == 0);
 
     if (CanMergeNextInstructions(1))
     {
diff --git a/Source/Core/Core/PowerPC/PowerPC.h b/Source/Core/Core/PowerPC/PowerPC.h
index bc0ba48ad3..8fc43ef551 100644
--- a/Source/Core/Core/PowerPC/PowerPC.h
+++ b/Source/Core/Core/PowerPC/PowerPC.h
@@ -162,7 +162,8 @@ struct PowerPCState
 
   // special purpose registers - controls quantizers, DMA, and lots of other misc extensions.
   // also for power management, but we don't care about that.
-  u32 spr[1024]{};
+  // JitArm64 needs 64-bit alignment for SPR_TL.
+  alignas(8) u32 spr[1024]{};
 
   // Storage for the stack pointer of the BLR optimization.
   u8* stored_stack_pointer = nullptr;
diff --git a/Source/Core/Core/State.cpp b/Source/Core/Core/State.cpp
index a6467f2b2c..f97e166f19 100644
--- a/Source/Core/Core/State.cpp
+++ b/Source/Core/Core/State.cpp
@@ -74,7 +74,7 @@ static std::recursive_mutex g_save_thread_mutex;
 static std::thread g_save_thread;
 
 // Don't forget to increase this after doing changes on the savestate system
-constexpr u32 STATE_VERSION = 148;  // Last changed in PR 10768
+constexpr u32 STATE_VERSION = 149;  // Last changed in PR 10781
 
 // Maps savestate versions to Dolphin versions.
 // Versions after 42 don't need to be added to this list,
diff --git a/Source/Core/Core/System.cpp b/Source/Core/Core/System.cpp
index cf8be13ab9..b6ec853f2d 100644
--- a/Source/Core/Core/System.cpp
+++ b/Source/Core/Core/System.cpp
@@ -10,6 +10,7 @@
 #include "Core/HW/AudioInterface.h"
 #include "Core/HW/DVD/DVDInterface.h"
 #include "Core/HW/DVD/DVDThread.h"
+#include "Core/HW/Sram.h"
 
 namespace Core
 {
@@ -22,6 +23,7 @@ struct System::Impl
   AudioInterface::AudioInterfaceState m_audio_interface_state;
   DVDInterface::DVDInterfaceState m_dvd_interface_state;
   DVDThread::DVDThreadState m_dvd_thread_state;
+  Sram m_sram;
 };
 
 System::System() : m_impl{std::make_unique<Impl>()}
@@ -80,4 +82,9 @@ DVDThread::DVDThreadState& System::GetDVDThreadState() const
 {
   return m_impl->m_dvd_thread_state;
 }
+
+Sram& System::GetSRAM() const
+{
+  return m_impl->m_sram;
+}
 }  // namespace Core
diff --git a/Source/Core/Core/System.h b/Source/Core/Core/System.h
index 83b93d4b19..a616bfbe71 100644
--- a/Source/Core/Core/System.h
+++ b/Source/Core/Core/System.h
@@ -6,6 +6,7 @@
 #include <memory>
 
 class SoundStream;
+struct Sram;
 
 namespace AudioInterface
 {
@@ -56,6 +57,7 @@ public:
   AudioInterface::AudioInterfaceState& GetAudioInterfaceState() const;
   DVDInterface::DVDInterfaceState& GetDVDInterfaceState() const;
   DVDThread::DVDThreadState& GetDVDThreadState() const;
+  Sram& GetSRAM() const;
 
 private:
   System();
diff --git a/Source/Core/DiscIO/VolumeVerifier.cpp b/Source/Core/DiscIO/VolumeVerifier.cpp
index 109b4c2f64..a2810b5919 100644
--- a/Source/Core/DiscIO/VolumeVerifier.cpp
+++ b/Source/Core/DiscIO/VolumeVerifier.cpp
@@ -1432,8 +1432,9 @@ void VolumeVerifier::Finish()
       }
       else
       {
-        Common::GetStringT("Problems with low severity were found. They will most "
-                           "likely not prevent the game from running.");
+        m_result.summary_text =
+            Common::GetStringT("Problems with low severity were found. They will most "
+                               "likely not prevent the game from running.");
       }
       break;
     case Severity::Medium:
diff --git a/Source/Core/DolphinQt/Config/CommonControllersWidget.cpp b/Source/Core/DolphinQt/Config/CommonControllersWidget.cpp
index 0f43658ae3..e988509f6a 100644
--- a/Source/Core/DolphinQt/Config/CommonControllersWidget.cpp
+++ b/Source/Core/DolphinQt/Config/CommonControllersWidget.cpp
@@ -13,12 +13,17 @@
 
 #include "DolphinQt/Config/ControllerInterface/ControllerInterfaceWindow.h"
 #include "DolphinQt/QtUtils/NonDefaultQPushButton.h"
+#include "DolphinQt/QtUtils/SignalBlocking.h"
+#include "DolphinQt/Settings.h"
 
 CommonControllersWidget::CommonControllersWidget(QWidget* parent) : QWidget(parent)
 {
   CreateLayout();
   LoadSettings();
   ConnectWidgets();
+
+  connect(&Settings::Instance(), &Settings::ConfigChanged, this,
+          &CommonControllersWidget::LoadSettings);
 }
 
 void CommonControllersWidget::CreateLayout()
@@ -59,7 +64,7 @@ void CommonControllersWidget::OnControllerInterfaceConfigure()
 
 void CommonControllersWidget::LoadSettings()
 {
-  m_common_bg_input->setChecked(Config::Get(Config::MAIN_INPUT_BACKGROUND_INPUT));
+  SignalBlocking(m_common_bg_input)->setChecked(Config::Get(Config::MAIN_INPUT_BACKGROUND_INPUT));
 }
 
 void CommonControllersWidget::SaveSettings()
diff --git a/Source/Core/DolphinQt/Config/GamecubeControllersWidget.cpp b/Source/Core/DolphinQt/Config/GamecubeControllersWidget.cpp
index 7a6ce9335c..b660bba5f7 100644
--- a/Source/Core/DolphinQt/Config/GamecubeControllersWidget.cpp
+++ b/Source/Core/DolphinQt/Config/GamecubeControllersWidget.cpp
@@ -26,23 +26,26 @@
 #include "DolphinQt/Config/Mapping/MappingWindow.h"
 #include "DolphinQt/QtUtils/ModalMessageBox.h"
 #include "DolphinQt/QtUtils/NonDefaultQPushButton.h"
+#include "DolphinQt/QtUtils/SignalBlocking.h"
 #include "DolphinQt/Settings.h"
 
 #include "InputCommon/GCAdapter.h"
 
-static const std::vector<std::pair<SerialInterface::SIDevices, const char*>> s_gc_types = {
-    {SerialInterface::SIDEVICE_NONE, _trans("None")},
-    {SerialInterface::SIDEVICE_GC_CONTROLLER, _trans("Standard Controller")},
-    {SerialInterface::SIDEVICE_GC_METROID, _trans("Metroid Controller")},
-    {SerialInterface::SIDEVICE_WIIU_ADAPTER, _trans("GameCube Adapter for Wii U")},
-    {SerialInterface::SIDEVICE_GC_STEERING, _trans("Steering Wheel")},
-    {SerialInterface::SIDEVICE_DANCEMAT, _trans("Dance Mat")},
-    {SerialInterface::SIDEVICE_GC_TARUKONGA, _trans("DK Bongos")},
+using SIDeviceName = std::pair<SerialInterface::SIDevices, const char*>;
+static constexpr std::array s_gc_types = {
+    SIDeviceName{SerialInterface::SIDEVICE_NONE, _trans("None")},
+    SIDeviceName{SerialInterface::SIDEVICE_GC_CONTROLLER, _trans("Standard Controller")},
+    SIDeviceName{SerialInterface::SIDEVICE_GC_METROID, _trans("Metroid Controller")},
+    SIDeviceName{SerialInterface::SIDEVICE_WIIU_ADAPTER, _trans("GameCube Adapter for Wii U")},
+    SIDeviceName{SerialInterface::SIDEVICE_GC_STEERING, _trans("Steering Wheel")},
+    SIDeviceName{SerialInterface::SIDEVICE_DANCEMAT, _trans("Dance Mat")},
+    SIDeviceName{SerialInterface::SIDEVICE_GC_TARUKONGA, _trans("DK Bongos")},
 #ifdef HAS_LIBMGBA
-    {SerialInterface::SIDEVICE_GC_GBA_EMULATED, _trans("GBA (Integrated)")},
+    SIDeviceName{SerialInterface::SIDEVICE_GC_GBA_EMULATED, _trans("GBA (Integrated)")},
 #endif
-    {SerialInterface::SIDEVICE_GC_GBA, _trans("GBA (TCP)")},
-    {SerialInterface::SIDEVICE_GC_KEYBOARD, _trans("Keyboard")}};
+    SIDeviceName{SerialInterface::SIDEVICE_GC_GBA, _trans("GBA (TCP)")},
+    SIDeviceName{SerialInterface::SIDEVICE_GC_KEYBOARD, _trans("Keyboard")},
+};
 
 static std::optional<int> ToGCMenuIndex(const SerialInterface::SIDevices sidevice)
 {
@@ -59,16 +62,14 @@ static SerialInterface::SIDevices FromGCMenuIndex(const int menudevice)
   return s_gc_types[menudevice].first;
 }
 
-static bool IsConfigurable(SerialInterface::SIDevices sidevice)
-{
-  return sidevice != SerialInterface::SIDEVICE_NONE && sidevice != SerialInterface::SIDEVICE_GC_GBA;
-}
-
 GamecubeControllersWidget::GamecubeControllersWidget(QWidget* parent) : QWidget(parent)
 {
   CreateLayout();
   LoadSettings();
   ConnectWidgets();
+
+  connect(&Settings::Instance(), &Settings::ConfigChanged, this,
+          &GamecubeControllersWidget::LoadSettings);
 }
 
 void GamecubeControllersWidget::CreateLayout()
@@ -105,43 +106,27 @@ void GamecubeControllersWidget::CreateLayout()
 
 void GamecubeControllersWidget::ConnectWidgets()
 {
-  for (size_t i = 0; i < m_gc_controller_boxes.size(); i++)
+  for (size_t i = 0; i < m_gc_controller_boxes.size(); ++i)
   {
     connect(m_gc_controller_boxes[i], qOverload<int>(&QComboBox::currentIndexChanged), this,
-            &GamecubeControllersWidget::SaveSettings);
-    connect(m_gc_controller_boxes[i], qOverload<int>(&QComboBox::currentIndexChanged), this,
-            &GamecubeControllersWidget::OnGCTypeChanged);
-    connect(m_gc_buttons[i], &QPushButton::clicked, this,
-            &GamecubeControllersWidget::OnGCPadConfigure);
+            [this, i] {
+              OnGCTypeChanged(i);
+              SaveSettings();
+            });
+    connect(m_gc_buttons[i], &QPushButton::clicked, this, [this, i] { OnGCPadConfigure(i); });
   }
 }
 
-void GamecubeControllersWidget::OnGCTypeChanged(int type)
+void GamecubeControllersWidget::OnGCTypeChanged(size_t index)
 {
-  const auto* box = static_cast<QComboBox*>(QObject::sender());
-
-  for (size_t i = 0; i < m_gc_groups.size(); i++)
-  {
-    if (m_gc_controller_boxes[i] == box)
-    {
-      const SerialInterface::SIDevices si_device = FromGCMenuIndex(box->currentIndex());
-      m_gc_buttons[i]->setEnabled(IsConfigurable(si_device));
-      return;
-    }
-  }
-
-  SaveSettings();
+  const SerialInterface::SIDevices si_device =
+      FromGCMenuIndex(m_gc_controller_boxes[index]->currentIndex());
+  m_gc_buttons[index]->setEnabled(si_device != SerialInterface::SIDEVICE_NONE &&
+                                  si_device != SerialInterface::SIDEVICE_GC_GBA);
 }
 
-void GamecubeControllersWidget::OnGCPadConfigure()
+void GamecubeControllersWidget::OnGCPadConfigure(size_t index)
 {
-  size_t index;
-  for (index = 0; index < m_gc_groups.size(); index++)
-  {
-    if (m_gc_buttons[index] == QObject::sender())
-      break;
-  }
-
   MappingWindow::Type type;
 
   switch (FromGCMenuIndex(m_gc_controller_boxes[index]->currentIndex()))
@@ -207,30 +192,32 @@ void GamecubeControllersWidget::LoadSettings()
     const std::optional<int> gc_index = ToGCMenuIndex(si_device);
     if (gc_index)
     {
-      m_gc_controller_boxes[i]->setCurrentIndex(*gc_index);
-      m_gc_buttons[i]->setEnabled(IsConfigurable(si_device));
+      SignalBlocking(m_gc_controller_boxes[i])->setCurrentIndex(*gc_index);
+      OnGCTypeChanged(i);
     }
   }
 }
 
 void GamecubeControllersWidget::SaveSettings()
 {
-  for (size_t i = 0; i < m_gc_groups.size(); i++)
   {
-    const int index = m_gc_controller_boxes[i]->currentIndex();
-    const SerialInterface::SIDevices si_device = FromGCMenuIndex(index);
-    Config::SetBaseOrCurrent(Config::GetInfoForSIDevice(static_cast<int>(i)), si_device);
+    Config::ConfigChangeCallbackGuard config_guard;
 
-    if (Core::IsRunning())
-      SerialInterface::ChangeDevice(si_device, static_cast<s32>(i));
+    for (size_t i = 0; i < m_gc_groups.size(); ++i)
+    {
+      const SerialInterface::SIDevices si_device =
+          FromGCMenuIndex(m_gc_controller_boxes[i]->currentIndex());
+      Config::SetBaseOrCurrent(Config::GetInfoForSIDevice(static_cast<int>(i)), si_device);
 
-    m_gc_buttons[i]->setEnabled(IsConfigurable(si_device));
+      if (Core::IsRunning())
+        SerialInterface::ChangeDevice(si_device, static_cast<s32>(i));
+    }
+
+    if (GCAdapter::UseAdapter())
+      GCAdapter::StartScanThread();
+    else
+      GCAdapter::StopScanThread();
   }
 
-  if (GCAdapter::UseAdapter())
-    GCAdapter::StartScanThread();
-  else
-    GCAdapter::StopScanThread();
-
   SConfig::GetInstance().SaveSettings();
 }
diff --git a/Source/Core/DolphinQt/Config/GamecubeControllersWidget.h b/Source/Core/DolphinQt/Config/GamecubeControllersWidget.h
index 236fd1774a..edaf405476 100644
--- a/Source/Core/DolphinQt/Config/GamecubeControllersWidget.h
+++ b/Source/Core/DolphinQt/Config/GamecubeControllersWidget.h
@@ -23,8 +23,8 @@ private:
   void LoadSettings();
   void SaveSettings();
 
-  void OnGCTypeChanged(int state);
-  void OnGCPadConfigure();
+  void OnGCTypeChanged(size_t index);
+  void OnGCPadConfigure(size_t index);
 
   void CreateLayout();
   void ConnectWidgets();
diff --git a/Source/Core/DolphinQt/Config/Graphics/AdvancedWidget.cpp b/Source/Core/DolphinQt/Config/Graphics/AdvancedWidget.cpp
index 7a2570f97c..f1261c453e 100644
--- a/Source/Core/DolphinQt/Config/Graphics/AdvancedWidget.cpp
+++ b/Source/Core/DolphinQt/Config/Graphics/AdvancedWidget.cpp
@@ -33,8 +33,9 @@ AdvancedWidget::AdvancedWidget(GraphicsWindow* parent)
   AddDescriptions();
 
   connect(parent, &GraphicsWindow::BackendChanged, this, &AdvancedWidget::OnBackendChanged);
-  connect(&Settings::Instance(), &Settings::EmulationStateChanged, this,
-          [=](Core::State state) { OnEmulationStateChanged(state != Core::State::Uninitialized); });
+  connect(&Settings::Instance(), &Settings::EmulationStateChanged, this, [this](Core::State state) {
+    OnEmulationStateChanged(state != Core::State::Uninitialized);
+  });
 
   OnBackendChanged();
   OnEmulationStateChanged(Core::GetState() != Core::State::Uninitialized);
diff --git a/Source/Core/DolphinQt/Config/Graphics/GeneralWidget.cpp b/Source/Core/DolphinQt/Config/Graphics/GeneralWidget.cpp
index 0353a69eea..733da068c9 100644
--- a/Source/Core/DolphinQt/Config/Graphics/GeneralWidget.cpp
+++ b/Source/Core/DolphinQt/Config/Graphics/GeneralWidget.cpp
@@ -41,8 +41,9 @@ GeneralWidget::GeneralWidget(X11Utils::XRRConfiguration* xrr_config, GraphicsWin
   emit BackendChanged(QString::fromStdString(Config::Get(Config::MAIN_GFX_BACKEND)));
 
   connect(parent, &GraphicsWindow::BackendChanged, this, &GeneralWidget::OnBackendChanged);
-  connect(&Settings::Instance(), &Settings::EmulationStateChanged, this,
-          [=](Core::State state) { OnEmulationStateChanged(state != Core::State::Uninitialized); });
+  connect(&Settings::Instance(), &Settings::EmulationStateChanged, this, [this](Core::State state) {
+    OnEmulationStateChanged(state != Core::State::Uninitialized);
+  });
   OnEmulationStateChanged(Core::GetState() != Core::State::Uninitialized);
 }
 
diff --git a/Source/Core/DolphinQt/Config/Graphics/SoftwareRendererWidget.cpp b/Source/Core/DolphinQt/Config/Graphics/SoftwareRendererWidget.cpp
index bb5c2f23d7..432f09ab3b 100644
--- a/Source/Core/DolphinQt/Config/Graphics/SoftwareRendererWidget.cpp
+++ b/Source/Core/DolphinQt/Config/Graphics/SoftwareRendererWidget.cpp
@@ -34,8 +34,9 @@ SoftwareRendererWidget::SoftwareRendererWidget(GraphicsWindow* parent)
   emit BackendChanged(QString::fromStdString(Config::Get(Config::MAIN_GFX_BACKEND)));
 
   connect(parent, &GraphicsWindow::BackendChanged, [this] { LoadSettings(); });
-  connect(&Settings::Instance(), &Settings::EmulationStateChanged, this,
-          [=](Core::State state) { OnEmulationStateChanged(state != Core::State::Uninitialized); });
+  connect(&Settings::Instance(), &Settings::EmulationStateChanged, this, [this](Core::State state) {
+    OnEmulationStateChanged(state != Core::State::Uninitialized);
+  });
   OnEmulationStateChanged(Core::GetState() != Core::State::Uninitialized);
 }
 
diff --git a/Source/Core/DolphinQt/Config/WiimoteControllersWidget.cpp b/Source/Core/DolphinQt/Config/WiimoteControllersWidget.cpp
index e42b3739c3..1f3fb09cb0 100644
--- a/Source/Core/DolphinQt/Config/WiimoteControllersWidget.cpp
+++ b/Source/Core/DolphinQt/Config/WiimoteControllersWidget.cpp
@@ -32,6 +32,7 @@
 #include "DolphinQt/Config/Mapping/MappingWindow.h"
 #include "DolphinQt/QtUtils/ModalMessageBox.h"
 #include "DolphinQt/QtUtils/NonDefaultQPushButton.h"
+#include "DolphinQt/QtUtils/SignalBlocking.h"
 #include "DolphinQt/Settings.h"
 
 #include "UICommon/UICommon.h"
@@ -39,8 +40,13 @@
 WiimoteControllersWidget::WiimoteControllersWidget(QWidget* parent) : QWidget(parent)
 {
   CreateLayout();
-  LoadSettings();
   ConnectWidgets();
+
+  connect(&Settings::Instance(), &Settings::ConfigChanged, this,
+          [this] { LoadSettings(Core::GetState()); });
+  connect(&Settings::Instance(), &Settings::EmulationStateChanged, this,
+          [this](Core::State state) { LoadSettings(state); });
+  LoadSettings(Core::GetState());
 }
 
 static int GetRadioButtonIndicatorWidth()
@@ -153,20 +159,20 @@ void WiimoteControllersWidget::CreateLayout()
 
 void WiimoteControllersWidget::ConnectWidgets()
 {
-  connect(&Settings::Instance(), &Settings::EmulationStateChanged, this,
-          &WiimoteControllersWidget::UpdateDisabledWiimoteControls);
+  connect(m_wiimote_passthrough, &QRadioButton::toggled, this, [this] {
+    SaveSettings();
+    LoadSettings(Core::GetState());
+  });
+  connect(m_wiimote_ciface, &QCheckBox::toggled, this, [this] {
+    SaveSettings();
+    LoadSettings(Core::GetState());
+    WiimoteReal::HandleWiimotesInControllerInterfaceSettingChange();
+  });
+  connect(m_wiimote_continuous_scanning, &QCheckBox::toggled, this, [this] {
+    SaveSettings();
+    LoadSettings(Core::GetState());
+  });
 
-  connect(m_wiimote_passthrough, &QRadioButton::toggled, this,
-          &WiimoteControllersWidget::OnWiimoteModeChanged);
-  connect(m_wiimote_ciface, &QCheckBox::toggled, this,
-          &WiimoteControllersWidget::OnWiimoteModeChanged);
-  connect(m_wiimote_ciface, &QCheckBox::toggled, this,
-          &WiimoteReal::HandleWiimotesInControllerInterfaceSettingChange);
-  connect(m_wiimote_continuous_scanning, &QCheckBox::toggled, this,
-          &WiimoteControllersWidget::OnWiimoteModeChanged);
-
-  connect(m_wiimote_continuous_scanning, &QCheckBox::toggled, this,
-          &WiimoteControllersWidget::SaveSettings);
   connect(m_wiimote_real_balance_board, &QCheckBox::toggled, this,
           &WiimoteControllersWidget::SaveSettings);
   connect(m_wiimote_speaker_data, &QCheckBox::toggled, this,
@@ -180,61 +186,15 @@ void WiimoteControllersWidget::ConnectWidgets()
 
   for (size_t i = 0; i < m_wiimote_groups.size(); i++)
   {
-    connect(m_wiimote_boxes[i], qOverload<int>(&QComboBox::currentIndexChanged), this,
-            &WiimoteControllersWidget::SaveSettings);
-    connect(m_wiimote_boxes[i], qOverload<int>(&QComboBox::currentIndexChanged), this,
-            &WiimoteControllersWidget::OnWiimoteModeChanged);
+    connect(m_wiimote_boxes[i], qOverload<int>(&QComboBox::currentIndexChanged), this, [this] {
+      SaveSettings();
+      LoadSettings(Core::GetState());
+    });
     connect(m_wiimote_buttons[i], &QPushButton::clicked, this,
-            &WiimoteControllersWidget::OnWiimoteConfigure);
+            [this, i] { OnWiimoteConfigure(i); });
   }
 }
 
-void WiimoteControllersWidget::OnWiimoteModeChanged()
-{
-  SaveSettings();
-
-  // Make sure continuous scanning setting is applied.
-  WiimoteReal::Initialize(::Wiimote::InitializeMode::DO_NOT_WAIT_FOR_WIIMOTES);
-
-  UpdateDisabledWiimoteControls();
-}
-
-void WiimoteControllersWidget::UpdateDisabledWiimoteControls()
-{
-  const bool running = Core::GetState() != Core::State::Uninitialized;
-
-  m_wiimote_emu->setEnabled(!running);
-  m_wiimote_passthrough->setEnabled(!running);
-
-  const bool running_gc = running && !SConfig::GetInstance().bWii;
-  const bool enable_passthrough = m_wiimote_passthrough->isChecked() && !running_gc;
-  const bool enable_emu_bt = !m_wiimote_passthrough->isChecked() && !running_gc;
-
-  m_wiimote_sync->setEnabled(enable_passthrough);
-  m_wiimote_reset->setEnabled(enable_passthrough);
-
-  for (auto* pt_label : m_wiimote_pt_labels)
-    pt_label->setEnabled(enable_passthrough);
-
-  for (size_t i = 0; i < m_wiimote_groups.size(); i++)
-  {
-    m_wiimote_labels[i]->setEnabled(enable_emu_bt);
-    m_wiimote_boxes[i]->setEnabled(enable_emu_bt);
-
-    const bool is_emu_wiimote = m_wiimote_boxes[i]->currentIndex() == 1 || m_wiimote_boxes[i]->currentIndex() == 3;
-    m_wiimote_buttons[i]->setEnabled(enable_emu_bt && is_emu_wiimote);
-  }
-
-  m_wiimote_real_balance_board->setEnabled(enable_emu_bt);
-  m_wiimote_speaker_data->setEnabled(enable_emu_bt);
-
-  const bool ciface_wiimotes = m_wiimote_ciface->isChecked();
-
-  m_wiimote_refresh->setEnabled((enable_emu_bt || ciface_wiimotes) &&
-                                !m_wiimote_continuous_scanning->isChecked());
-  m_wiimote_continuous_scanning->setEnabled(enable_emu_bt || ciface_wiimotes);
-}
-
 void WiimoteControllersWidget::OnBluetoothPassthroughResetPressed()
 {
   const auto ios = IOS::HLE::GetIOS();
@@ -273,15 +233,8 @@ void WiimoteControllersWidget::OnWiimoteRefreshPressed()
   WiimoteReal::Refresh();
 }
 
-void WiimoteControllersWidget::OnWiimoteConfigure()
+void WiimoteControllersWidget::OnWiimoteConfigure(size_t index)
 {
-  size_t index;
-  for (index = 0; index < m_wiimote_groups.size(); index++)
-  {
-    if (m_wiimote_buttons[index] == QObject::sender())
-      break;
-  }
-
   MappingWindow::Type type;
   switch (m_wiimote_boxes[index]->currentIndex())
   {
@@ -320,45 +273,86 @@ void WiimoteControllersWidget::OnWiimoteConfigure()
   window->show();
 }
 
-void WiimoteControllersWidget::LoadSettings()
+void WiimoteControllersWidget::LoadSettings(Core::State state)
 {
   for (size_t i = 0; i < m_wiimote_groups.size(); i++)
   {
-    m_wiimote_boxes[i]->setCurrentIndex(int(Config::Get(Config::GetInfoForWiimoteSource(int(i)))));
+    SignalBlocking(m_wiimote_boxes[i])
+        ->setCurrentIndex(int(Config::Get(Config::GetInfoForWiimoteSource(int(i)))));
   }
-  m_wiimote_real_balance_board->setChecked(Config::Get(Config::WIIMOTE_BB_SOURCE) ==
-                                           WiimoteSource::Real);
-  m_wiimote_speaker_data->setChecked(Config::Get(Config::MAIN_WIIMOTE_ENABLE_SPEAKER));
-  m_wiimote_ciface->setChecked(Config::Get(Config::MAIN_CONNECT_WIIMOTES_FOR_CONTROLLER_INTERFACE));
-  m_wiimote_continuous_scanning->setChecked(Config::Get(Config::MAIN_WIIMOTE_CONTINUOUS_SCANNING));
+  SignalBlocking(m_wiimote_real_balance_board)
+      ->setChecked(Config::Get(Config::WIIMOTE_BB_SOURCE) == WiimoteSource::Real);
+  SignalBlocking(m_wiimote_speaker_data)
+      ->setChecked(Config::Get(Config::MAIN_WIIMOTE_ENABLE_SPEAKER));
+  SignalBlocking(m_wiimote_ciface)
+      ->setChecked(Config::Get(Config::MAIN_CONNECT_WIIMOTES_FOR_CONTROLLER_INTERFACE));
+  SignalBlocking(m_wiimote_continuous_scanning)
+      ->setChecked(Config::Get(Config::MAIN_WIIMOTE_CONTINUOUS_SCANNING));
 
   if (Config::Get(Config::MAIN_BLUETOOTH_PASSTHROUGH_ENABLED))
-    m_wiimote_passthrough->setChecked(true);
+    SignalBlocking(m_wiimote_passthrough)->setChecked(true);
   else
-    m_wiimote_emu->setChecked(true);
+    SignalBlocking(m_wiimote_emu)->setChecked(true);
 
-  OnWiimoteModeChanged();
+  // Make sure continuous scanning setting is applied.
+  WiimoteReal::Initialize(::Wiimote::InitializeMode::DO_NOT_WAIT_FOR_WIIMOTES);
+
+  const bool running = state != Core::State::Uninitialized;
+
+  m_wiimote_emu->setEnabled(!running);
+  m_wiimote_passthrough->setEnabled(!running);
+
+  const bool running_gc = running && !SConfig::GetInstance().bWii;
+  const bool enable_passthrough = m_wiimote_passthrough->isChecked() && !running_gc;
+  const bool enable_emu_bt = !m_wiimote_passthrough->isChecked() && !running_gc;
+
+  m_wiimote_sync->setEnabled(enable_passthrough);
+  m_wiimote_reset->setEnabled(enable_passthrough);
+
+  for (auto* pt_label : m_wiimote_pt_labels)
+    pt_label->setEnabled(enable_passthrough);
+
+  for (size_t i = 0; i < m_wiimote_groups.size(); i++)
+  {
+    m_wiimote_labels[i]->setEnabled(enable_emu_bt);
+    m_wiimote_boxes[i]->setEnabled(enable_emu_bt);
+
+    const bool is_emu_wiimote = m_wiimote_boxes[i]->currentIndex() == 1;
+    m_wiimote_buttons[i]->setEnabled(enable_emu_bt && is_emu_wiimote);
+  }
+
+  m_wiimote_real_balance_board->setEnabled(enable_emu_bt);
+  m_wiimote_speaker_data->setEnabled(enable_emu_bt);
+
+  const bool ciface_wiimotes = m_wiimote_ciface->isChecked();
+
+  m_wiimote_refresh->setEnabled((enable_emu_bt || ciface_wiimotes) &&
+                                !m_wiimote_continuous_scanning->isChecked());
+  m_wiimote_continuous_scanning->setEnabled(enable_emu_bt || ciface_wiimotes);
 }
 
 void WiimoteControllersWidget::SaveSettings()
 {
-  Config::SetBaseOrCurrent(Config::MAIN_WIIMOTE_ENABLE_SPEAKER,
-                           m_wiimote_speaker_data->isChecked());
-  Config::SetBaseOrCurrent(Config::MAIN_CONNECT_WIIMOTES_FOR_CONTROLLER_INTERFACE,
-                           m_wiimote_ciface->isChecked());
-  Config::SetBaseOrCurrent(Config::MAIN_WIIMOTE_CONTINUOUS_SCANNING,
-                           m_wiimote_continuous_scanning->isChecked());
-  Config::SetBaseOrCurrent(Config::MAIN_BLUETOOTH_PASSTHROUGH_ENABLED,
-                           m_wiimote_passthrough->isChecked());
-
-  const WiimoteSource bb_source =
-      m_wiimote_real_balance_board->isChecked() ? WiimoteSource::Real : WiimoteSource::None;
-  Config::SetBaseOrCurrent(Config::WIIMOTE_BB_SOURCE, bb_source);
-
-  for (size_t i = 0; i < m_wiimote_groups.size(); i++)
   {
-    const int index = m_wiimote_boxes[i]->currentIndex();
-    Config::SetBaseOrCurrent(Config::GetInfoForWiimoteSource(int(i)), WiimoteSource(index));
+    Config::ConfigChangeCallbackGuard config_guard;
+    Config::SetBaseOrCurrent(Config::MAIN_WIIMOTE_ENABLE_SPEAKER,
+                             m_wiimote_speaker_data->isChecked());
+    Config::SetBaseOrCurrent(Config::MAIN_CONNECT_WIIMOTES_FOR_CONTROLLER_INTERFACE,
+                             m_wiimote_ciface->isChecked());
+    Config::SetBaseOrCurrent(Config::MAIN_WIIMOTE_CONTINUOUS_SCANNING,
+                             m_wiimote_continuous_scanning->isChecked());
+    Config::SetBaseOrCurrent(Config::MAIN_BLUETOOTH_PASSTHROUGH_ENABLED,
+                             m_wiimote_passthrough->isChecked());
+
+    const WiimoteSource bb_source =
+        m_wiimote_real_balance_board->isChecked() ? WiimoteSource::Real : WiimoteSource::None;
+    Config::SetBaseOrCurrent(Config::WIIMOTE_BB_SOURCE, bb_source);
+
+    for (size_t i = 0; i < m_wiimote_groups.size(); i++)
+    {
+      const int index = m_wiimote_boxes[i]->currentIndex();
+      Config::SetBaseOrCurrent(Config::GetInfoForWiimoteSource(int(i)), WiimoteSource(index));
+    }
   }
 
   SConfig::GetInstance().SaveSettings();
diff --git a/Source/Core/DolphinQt/Config/WiimoteControllersWidget.h b/Source/Core/DolphinQt/Config/WiimoteControllersWidget.h
index 4ba49e2771..e8cf91ce4b 100644
--- a/Source/Core/DolphinQt/Config/WiimoteControllersWidget.h
+++ b/Source/Core/DolphinQt/Config/WiimoteControllersWidget.h
@@ -16,6 +16,11 @@ class QLabel;
 class QPushButton;
 class QRadioButton;
 
+namespace Core
+{
+enum class State;
+}
+
 class WiimoteControllersWidget final : public QWidget
 {
   Q_OBJECT
@@ -23,17 +28,15 @@ public:
   explicit WiimoteControllersWidget(QWidget* parent);
 
 private:
-  void OnWiimoteModeChanged();
-  void UpdateDisabledWiimoteControls();
   void SaveSettings();
   void OnBluetoothPassthroughSyncPressed();
   void OnBluetoothPassthroughResetPressed();
   void OnWiimoteRefreshPressed();
-  void OnWiimoteConfigure();
+  void OnWiimoteConfigure(size_t index);
 
   void CreateLayout();
   void ConnectWidgets();
-  void LoadSettings();
+  void LoadSettings(Core::State state);
 
   QGroupBox* m_wiimote_box;
   QGridLayout* m_wiimote_layout;
diff --git a/Source/Core/DolphinQt/Debugger/MemoryWidget.cpp b/Source/Core/DolphinQt/Debugger/MemoryWidget.cpp
index 55af3dbc80..f6189ebb62 100644
--- a/Source/Core/DolphinQt/Debugger/MemoryWidget.cpp
+++ b/Source/Core/DolphinQt/Debugger/MemoryWidget.cpp
@@ -17,6 +17,7 @@
 #include <QHBoxLayout>
 #include <QLabel>
 #include <QLineEdit>
+#include <QMenuBar>
 #include <QPushButton>
 #include <QRegularExpression>
 #include <QScrollArea>
@@ -114,7 +115,6 @@ void MemoryWidget::CreateWidgets()
   m_data_edit = new QLineEdit;
   m_base_check = new QCheckBox(tr("Hex"));
   m_set_value = new QPushButton(tr("Set &Value"));
-  m_from_file = new QPushButton(tr("Set Value From File"));
   m_data_preview = new QLabel;
 
   m_base_check->setLayoutDirection(Qt::RightToLeft);
@@ -140,20 +140,6 @@ void MemoryWidget::CreateWidgets()
   m_input_combo->addItem(tr("Signed 16"), int(Type::Signed16));
   m_input_combo->addItem(tr("Signed 32"), int(Type::Signed32));
 
-  // Dump
-  auto* dump_group = new QGroupBox(tr("Dump"));
-  auto* dump_layout = new QVBoxLayout;
-  dump_group->setLayout(dump_layout);
-  m_dump_mram = new QPushButton(tr("Dump &MRAM"));
-  m_dump_exram = new QPushButton(tr("Dump &ExRAM"));
-  m_dump_aram = new QPushButton(tr("Dump &ARAM"));
-  m_dump_fake_vmem = new QPushButton(tr("Dump &FakeVMEM"));
-
-  dump_layout->addWidget(m_dump_mram);
-  dump_layout->addWidget(m_dump_exram);
-  dump_layout->addWidget(m_dump_aram);
-  dump_layout->addWidget(m_dump_fake_vmem);
-
   // Search Options
   auto* search_group = new QGroupBox(tr("Search"));
   auto* search_layout = new QVBoxLayout;
@@ -253,14 +239,31 @@ void MemoryWidget::CreateWidgets()
   // Sidebar
   auto* sidebar = new QWidget;
   auto* sidebar_layout = new QVBoxLayout;
+
+  // Sidebar top menu
+  QMenuBar* menubar = new QMenuBar(sidebar);
+  menubar->setNativeMenuBar(false);
+  QMenu* menu_actions = new QMenu(tr("&Actions"));
+
+  menu_actions->addAction(tr("&Load file to current address"), this,
+                          &MemoryWidget::OnSetValueFromFile);
+  menu_actions->addSeparator();
+  menu_actions->addAction(tr("Dump &MRAM"), this, &MemoryWidget::OnDumpMRAM);
+  menu_actions->addAction(tr("Dump &ExRAM"), this, &MemoryWidget::OnDumpExRAM);
+  menu_actions->addAction(tr("Dump &ARAM"), this, &MemoryWidget::OnDumpARAM);
+  menu_actions->addAction(tr("Dump &FakeVMEM"), this, &MemoryWidget::OnDumpFakeVMEM);
+
+  menubar->addMenu(menu_actions);
+
   sidebar_layout->setSpacing(1);
   sidebar->setLayout(sidebar_layout);
+  sidebar_layout->addItem(new QSpacerItem(1, 20));
   sidebar_layout->addWidget(m_address_splitter);
   sidebar_layout->addLayout(input_layout);
   sidebar_layout->addWidget(m_input_combo);
+  sidebar_layout->addItem(new QSpacerItem(1, 10));
   sidebar_layout->addWidget(m_data_preview);
   sidebar_layout->addWidget(m_set_value);
-  sidebar_layout->addWidget(m_from_file);
   sidebar_layout->addItem(new QSpacerItem(1, 10));
   sidebar_layout->addWidget(search_group);
   sidebar_layout->addItem(new QSpacerItem(1, 10));
@@ -269,8 +272,6 @@ void MemoryWidget::CreateWidgets()
   sidebar_layout->addWidget(address_space_group);
   sidebar_layout->addItem(new QSpacerItem(1, 10));
   sidebar_layout->addWidget(bp_group);
-  sidebar_layout->addItem(new QSpacerItem(1, 10));
-  sidebar_layout->addWidget(dump_group);
   sidebar_layout->addItem(new QSpacerItem(0, 0, QSizePolicy::Expanding, QSizePolicy::Expanding));
 
   // Splitter
@@ -302,14 +303,7 @@ void MemoryWidget::ConnectWidgets()
 
   connect(m_input_combo, qOverload<int>(&QComboBox::currentIndexChanged), this,
           &MemoryWidget::ValidateAndPreviewInputValue);
-
   connect(m_set_value, &QPushButton::clicked, this, &MemoryWidget::OnSetValue);
-  connect(m_from_file, &QPushButton::clicked, this, &MemoryWidget::OnSetValueFromFile);
-
-  connect(m_dump_mram, &QPushButton::clicked, this, &MemoryWidget::OnDumpMRAM);
-  connect(m_dump_exram, &QPushButton::clicked, this, &MemoryWidget::OnDumpExRAM);
-  connect(m_dump_aram, &QPushButton::clicked, this, &MemoryWidget::OnDumpARAM);
-  connect(m_dump_fake_vmem, &QPushButton::clicked, this, &MemoryWidget::OnDumpFakeVMEM);
 
   connect(m_find_next, &QPushButton::clicked, this, &MemoryWidget::OnFindNextValue);
   connect(m_find_previous, &QPushButton::clicked, this, &MemoryWidget::OnFindPreviousValue);
diff --git a/Source/Core/DolphinQt/Debugger/MemoryWidget.h b/Source/Core/DolphinQt/Debugger/MemoryWidget.h
index 4e344af37b..acf2abef5f 100644
--- a/Source/Core/DolphinQt/Debugger/MemoryWidget.h
+++ b/Source/Core/DolphinQt/Debugger/MemoryWidget.h
@@ -85,11 +85,6 @@ private:
   QComboBox* m_row_length_combo;
   QCheckBox* m_dual_check;
   QPushButton* m_set_value;
-  QPushButton* m_from_file;
-  QPushButton* m_dump_mram;
-  QPushButton* m_dump_exram;
-  QPushButton* m_dump_aram;
-  QPushButton* m_dump_fake_vmem;
 
   // Search
   QPushButton* m_find_next;
diff --git a/Source/Core/DolphinQt/FIFO/FIFOAnalyzer.cpp b/Source/Core/DolphinQt/FIFO/FIFOAnalyzer.cpp
index d593a7419d..bcf0276a02 100644
--- a/Source/Core/DolphinQt/FIFO/FIFOAnalyzer.cpp
+++ b/Source/Core/DolphinQt/FIFO/FIFOAnalyzer.cpp
@@ -316,6 +316,11 @@ public:
 
   OPCODE_CALLBACK(CPState& GetCPState()) { return m_cpmem; }
 
+  OPCODE_CALLBACK(u32 GetVertexSize(u8 vat))
+  {
+    return VertexLoaderBase::GetVertexSize(GetCPState().vtx_desc, GetCPState().vtx_attr[vat]);
+  }
+
   QString text;
   CPState m_cpmem;
 };
@@ -731,6 +736,11 @@ public:
 
   OPCODE_CALLBACK(CPState& GetCPState()) { return m_cpmem; }
 
+  OPCODE_CALLBACK(u32 GetVertexSize(u8 vat))
+  {
+    return VertexLoaderBase::GetVertexSize(GetCPState().vtx_desc, GetCPState().vtx_attr[vat]);
+  }
+
   QString text;
   CPState m_cpmem;
 };
diff --git a/Source/Core/DolphinQt/MainWindow.cpp b/Source/Core/DolphinQt/MainWindow.cpp
index d618d54d59..c2915ec947 100644
--- a/Source/Core/DolphinQt/MainWindow.cpp
+++ b/Source/Core/DolphinQt/MainWindow.cpp
@@ -358,7 +358,7 @@ void MainWindow::ShutdownControllers()
 
 void MainWindow::InitCoreCallbacks()
 {
-  connect(&Settings::Instance(), &Settings::EmulationStateChanged, this, [=](Core::State state) {
+  connect(&Settings::Instance(), &Settings::EmulationStateChanged, this, [this](Core::State state) {
     if (state == Core::State::Uninitialized)
       OnStopComplete();
     if (state != Core::State::Uninitialized && NetPlay::IsNetPlayRunning() && m_controllers_window)
@@ -375,7 +375,7 @@ void MainWindow::InitCoreCallbacks()
 
   // Handle file open events
   auto* filter = new FileOpenEventFilter(QGuiApplication::instance());
-  connect(filter, &FileOpenEventFilter::fileOpened, this, [=](const QString& file_name) {
+  connect(filter, &FileOpenEventFilter::fileOpened, this, [this](const QString& file_name) {
     StartGame(BootParameters::GenerateFromFile(file_name.toStdString()));
   });
 }
diff --git a/Source/Core/DolphinQt/MenuBar.cpp b/Source/Core/DolphinQt/MenuBar.cpp
index 1cc9500e6c..ea9e134114 100644
--- a/Source/Core/DolphinQt/MenuBar.cpp
+++ b/Source/Core/DolphinQt/MenuBar.cpp
@@ -90,7 +90,7 @@ MenuBar::MenuBar(QWidget* parent) : QMenuBar(parent)
   AddPrimeHackMenu();
 
   connect(&Settings::Instance(), &Settings::EmulationStateChanged, this,
-          [=](Core::State state) { OnEmulationStateChanged(state); });
+          [=, this](Core::State state) { OnEmulationStateChanged(state); });
   connect(Host::GetInstance(), &Host::UpdateDisasmDialog, this,
           [this] { OnEmulationStateChanged(Core::GetState()); });
 
@@ -343,7 +343,7 @@ void MenuBar::AddStateLoadMenu(QMenu* emu_menu)
   {
     QAction* action = m_state_load_slots_menu->addAction(QString{});
 
-    connect(action, &QAction::triggered, this, [=]() { emit StateLoadSlotAt(i); });
+    connect(action, &QAction::triggered, this, [=, this]() { emit StateLoadSlotAt(i); });
   }
 }
 
@@ -360,7 +360,7 @@ void MenuBar::AddStateSaveMenu(QMenu* emu_menu)
   {
     QAction* action = m_state_save_slots_menu->addAction(QString{});
 
-    connect(action, &QAction::triggered, this, [=]() { emit StateSaveSlotAt(i); });
+    connect(action, &QAction::triggered, this, [=, this]() { emit StateSaveSlotAt(i); });
   }
 }
 
@@ -377,7 +377,7 @@ void MenuBar::AddStateSlotMenu(QMenu* emu_menu)
     if (Settings::Instance().GetStateSlot() == i)
       action->setChecked(true);
 
-    connect(action, &QAction::triggered, this, [=]() { emit SetStateSlot(i); });
+    connect(action, &QAction::triggered, this, [=, this]() { emit SetStateSlot(i); });
   }
 }
 
diff --git a/Source/Core/DolphinQt/NetPlay/NetPlayDialog.cpp b/Source/Core/DolphinQt/NetPlay/NetPlayDialog.cpp
index b994bd93f3..06db7b0b2b 100644
--- a/Source/Core/DolphinQt/NetPlay/NetPlayDialog.cpp
+++ b/Source/Core/DolphinQt/NetPlay/NetPlayDialog.cpp
@@ -369,7 +369,7 @@ void NetPlayDialog::ConnectWidgets()
     }
   });
 
-  connect(&Settings::Instance(), &Settings::EmulationStateChanged, this, [=](Core::State state) {
+  connect(&Settings::Instance(), &Settings::EmulationStateChanged, this, [this](Core::State state) {
     if (isVisible())
     {
       GameStatusChanged(state != Core::State::Uninitialized);
@@ -850,8 +850,7 @@ void NetPlayDialog::OnMsgStartGame()
   g_netplay_chat_ui =
       std::make_unique<NetPlayChatUI>([this](const std::string& message) { SendMessage(message); });
 
-  if (m_host_input_authority &&
-      Settings::Instance().GetNetPlayClient()->GetNetSettings().m_GolfMode)
+  if (m_host_input_authority && Settings::Instance().GetNetPlayClient()->GetNetSettings().golf_mode)
   {
     g_netplay_golf_ui = std::make_unique<NetPlayGolfUI>(Settings::Instance().GetNetPlayClient());
   }
diff --git a/Source/Core/DolphinQt/Settings/AudioPane.cpp b/Source/Core/DolphinQt/Settings/AudioPane.cpp
index f6f2629fe3..1da51c1da5 100644
--- a/Source/Core/DolphinQt/Settings/AudioPane.cpp
+++ b/Source/Core/DolphinQt/Settings/AudioPane.cpp
@@ -35,8 +35,9 @@ AudioPane::AudioPane()
   ConnectWidgets();
 
   connect(&Settings::Instance(), &Settings::VolumeChanged, this, &AudioPane::OnVolumeChanged);
-  connect(&Settings::Instance(), &Settings::EmulationStateChanged, this,
-          [=](Core::State state) { OnEmulationStateChanged(state != Core::State::Uninitialized); });
+  connect(&Settings::Instance(), &Settings::EmulationStateChanged, this, [this](Core::State state) {
+    OnEmulationStateChanged(state != Core::State::Uninitialized);
+  });
 
   OnEmulationStateChanged(Core::GetState() != Core::State::Uninitialized);
 }
diff --git a/Source/Core/DolphinQt/Settings/InterfacePane.cpp b/Source/Core/DolphinQt/Settings/InterfacePane.cpp
index d96adcf8b4..d5a1916a37 100644
--- a/Source/Core/DolphinQt/Settings/InterfacePane.cpp
+++ b/Source/Core/DolphinQt/Settings/InterfacePane.cpp
@@ -213,8 +213,9 @@ void InterfacePane::ConnectLayout()
   connect(m_checkbox_disable_screensaver, &QCheckBox::toggled, this, &InterfacePane::OnSaveConfig);
   connect(m_checkbox_show_debugging_ui, &QCheckBox::toggled, this, &InterfacePane::OnSaveConfig);
   connect(m_checkbox_focused_hotkeys, &QCheckBox::toggled, this, &InterfacePane::OnSaveConfig);
-  connect(m_combobox_theme, qOverload<int>(&QComboBox::currentIndexChanged), this,
-          [=](int index) { Settings::Instance().SetThemeName(m_combobox_theme->itemText(index)); });
+  connect(
+      m_combobox_theme, qOverload<int>(&QComboBox::currentIndexChanged), this,
+      [this](int index) { Settings::Instance().SetThemeName(m_combobox_theme->itemText(index)); });
   connect(m_combobox_userstyle, qOverload<int>(&QComboBox::currentIndexChanged), this,
           &InterfacePane::OnSaveConfig);
   connect(m_combobox_language, qOverload<int>(&QComboBox::currentIndexChanged), this,
diff --git a/Source/Core/DolphinQt/Settings/PathPane.cpp b/Source/Core/DolphinQt/Settings/PathPane.cpp
index 3382f8f7f9..8d91e31d50 100644
--- a/Source/Core/DolphinQt/Settings/PathPane.cpp
+++ b/Source/Core/DolphinQt/Settings/PathPane.cpp
@@ -196,7 +196,7 @@ QGridLayout* PathPane::MakePathsLayout()
 
   m_dump_edit = new QLineEdit(QString::fromStdString(File::GetUserPath(D_DUMP_IDX)));
   connect(m_dump_edit, &QLineEdit::editingFinished,
-          [=] { Config::SetBase(Config::MAIN_DUMP_PATH, m_dump_edit->text().toStdString()); });
+          [this] { Config::SetBase(Config::MAIN_DUMP_PATH, m_dump_edit->text().toStdString()); });
   QPushButton* dump_open = new NonDefaultQPushButton(QStringLiteral("..."));
   connect(dump_open, &QPushButton::clicked, this, &PathPane::BrowseDump);
   layout->addWidget(new QLabel(tr("Dump Path:")), 2, 0);
@@ -205,7 +205,7 @@ QGridLayout* PathPane::MakePathsLayout()
 
   m_load_edit = new QLineEdit(QString::fromStdString(File::GetUserPath(D_LOAD_IDX)));
   connect(m_load_edit, &QLineEdit::editingFinished,
-          [=] { Config::SetBase(Config::MAIN_LOAD_PATH, m_load_edit->text().toStdString()); });
+          [this] { Config::SetBase(Config::MAIN_LOAD_PATH, m_load_edit->text().toStdString()); });
   QPushButton* load_open = new NonDefaultQPushButton(QStringLiteral("..."));
   connect(load_open, &QPushButton::clicked, this, &PathPane::BrowseLoad);
   layout->addWidget(new QLabel(tr("Load Path:")), 3, 0);
@@ -214,7 +214,7 @@ QGridLayout* PathPane::MakePathsLayout()
 
   m_resource_pack_edit =
       new QLineEdit(QString::fromStdString(File::GetUserPath(D_RESOURCEPACK_IDX)));
-  connect(m_resource_pack_edit, &QLineEdit::editingFinished, [=] {
+  connect(m_resource_pack_edit, &QLineEdit::editingFinished, [this] {
     Config::SetBase(Config::MAIN_RESOURCEPACK_PATH, m_resource_pack_edit->text().toStdString());
   });
   QPushButton* resource_pack_open = new NonDefaultQPushButton(QStringLiteral("..."));
@@ -225,7 +225,7 @@ QGridLayout* PathPane::MakePathsLayout()
 
   m_wfs_edit = new QLineEdit(QString::fromStdString(File::GetUserPath(D_WFSROOT_IDX)));
   connect(m_load_edit, &QLineEdit::editingFinished,
-          [=] { Config::SetBase(Config::MAIN_WFS_PATH, m_wfs_edit->text().toStdString()); });
+          [this] { Config::SetBase(Config::MAIN_WFS_PATH, m_wfs_edit->text().toStdString()); });
   QPushButton* wfs_open = new NonDefaultQPushButton(QStringLiteral("..."));
   connect(wfs_open, &QPushButton::clicked, this, &PathPane::BrowseWFS);
   layout->addWidget(new QLabel(tr("WFS Path:")), 5, 0);
diff --git a/Source/Core/DolphinQt/Settings/WiiPane.cpp b/Source/Core/DolphinQt/Settings/WiiPane.cpp
index 918a294b74..c6483f07b8 100644
--- a/Source/Core/DolphinQt/Settings/WiiPane.cpp
+++ b/Source/Core/DolphinQt/Settings/WiiPane.cpp
@@ -107,8 +107,9 @@ void WiiPane::ConnectLayout()
   connect(m_wiimote_motor, &QCheckBox::toggled, this, &WiiPane::OnSaveConfig);
 
   // Emulation State
-  connect(&Settings::Instance(), &Settings::EmulationStateChanged, this,
-          [=](Core::State state) { OnEmulationStateChanged(state != Core::State::Uninitialized); });
+  connect(&Settings::Instance(), &Settings::EmulationStateChanged, this, [this](Core::State state) {
+    OnEmulationStateChanged(state != Core::State::Uninitialized);
+  });
 }
 
 void WiiPane::CreateMisc()
diff --git a/Source/Core/InputCommon/ControllerEmu/ControllerEmu.h b/Source/Core/InputCommon/ControllerEmu/ControllerEmu.h
index 104240023d..2db991eb82 100644
--- a/Source/Core/InputCommon/ControllerEmu/ControllerEmu.h
+++ b/Source/Core/InputCommon/ControllerEmu/ControllerEmu.h
@@ -103,13 +103,15 @@ struct ThreePointCalibration
 template <typename T, size_t Bits>
 struct RawValue
 {
-  RawValue() = default;
-  explicit RawValue(const T& value_) : value{value_} {}
+  constexpr RawValue() = default;
+  constexpr explicit RawValue(const T& value_) : value{value_} {}
 
   static constexpr size_t BITS_OF_PRECISION = Bits;
 
   T value;
 
+  constexpr bool operator==(const RawValue& other) const = default;
+
   template <typename OtherT, size_t OtherBits>
   auto GetNormalizedValue(const TwoPointCalibration<OtherT, OtherBits>& calibration) const
   {
@@ -206,9 +208,9 @@ public:
     static_assert(std::is_integral<T>(), "T is only sane for int types.");
     static_assert(std::is_floating_point<F>(), "F is only sane for float types.");
 
-    static_assert(std::numeric_limits<long>::min() <= std::numeric_limits<T>::min() &&
-                      std::numeric_limits<long>::max() >= std::numeric_limits<T>::max(),
-                  "long is not a superset of T. use of std::lround is not sane.");
+    static_assert(std::numeric_limits<long long>::min() <= std::numeric_limits<T>::min() &&
+                      std::numeric_limits<long long>::max() >= std::numeric_limits<T>::max(),
+                  "long long is not a superset of T. use of std::llround is not sane.");
 
     // Here we round when converting from float to int.
     // After applying our deadzone, resizing, and reshaping math
@@ -216,9 +218,9 @@ public:
     // Casting would round down but rounding will yield our "zero_value".
 
     if (input_value > 0)
-      return T(std::lround((pos_1_value - zero_value) * input_value + zero_value));
+      return T(std::llround((pos_1_value - zero_value) * input_value + zero_value));
     else
-      return T(std::lround((zero_value - neg_1_value) * input_value + zero_value));
+      return T(std::llround((zero_value - neg_1_value) * input_value + zero_value));
   }
 
 protected:
diff --git a/Source/Core/UpdaterCommon/UpdaterCommon.cpp b/Source/Core/UpdaterCommon/UpdaterCommon.cpp
index 6bbe5b936a..fb9606ca49 100644
--- a/Source/Core/UpdaterCommon/UpdaterCommon.cpp
+++ b/Source/Core/UpdaterCommon/UpdaterCommon.cpp
@@ -4,6 +4,7 @@
 #include "UpdaterCommon/UpdaterCommon.h"
 
 #include <array>
+#include <memory>
 #include <optional>
 
 #include <OptionParser.h>
@@ -132,16 +133,17 @@ std::optional<std::string> GzipInflate(const std::string& data)
   inflateInit2(&zstrm, 16 + MAX_WBITS);
 
   std::string out;
-  char buffer[4096];
+  const size_t buf_len = 20 * 1024 * 1024;
+  auto buffer = std::make_unique<char[]>(buf_len);
   int ret;
 
   do
   {
-    zstrm.avail_out = sizeof(buffer);
-    zstrm.next_out = reinterpret_cast<u8*>(buffer);
+    zstrm.avail_out = buf_len;
+    zstrm.next_out = reinterpret_cast<u8*>(buffer.get());
 
     ret = inflate(&zstrm, 0);
-    out.append(buffer, sizeof(buffer) - zstrm.avail_out);
+    out.append(buffer.get(), buf_len - zstrm.avail_out);
   } while (ret == Z_OK);
 
   inflateEnd(&zstrm);
diff --git a/Source/Core/VideoBackends/D3D/D3DMain.cpp b/Source/Core/VideoBackends/D3D/D3DMain.cpp
index b8d7fb5871..755f0cf590 100644
--- a/Source/Core/VideoBackends/D3D/D3DMain.cpp
+++ b/Source/Core/VideoBackends/D3D/D3DMain.cpp
@@ -112,6 +112,7 @@ void VideoBackend::FillBackendInfo()
   g_Config.backend_info.bSupportsLogicOp = D3D::SupportsLogicOp(g_Config.iAdapter);
   g_Config.backend_info.bSupportsSettingObjectNames = true;
   g_Config.backend_info.bSupportsPartialMultisampleResolve = true;
+  g_Config.backend_info.bSupportsDynamicVertexLoader = false;
 
   g_Config.backend_info.Adapters = D3DCommon::GetAdapterNames();
   g_Config.backend_info.AAModes = D3D::GetAAModes(g_Config.iAdapter);
diff --git a/Source/Core/VideoBackends/D3D12/D3D12Renderer.cpp b/Source/Core/VideoBackends/D3D12/D3D12Renderer.cpp
index b1cb3378ed..80872086a9 100644
--- a/Source/Core/VideoBackends/D3D12/D3D12Renderer.cpp
+++ b/Source/Core/VideoBackends/D3D12/D3D12Renderer.cpp
@@ -180,7 +180,8 @@ void Renderer::SetPipeline(const AbstractPipeline* pipeline)
       m_state.root_signature = dx_pipeline->GetRootSignature();
       m_dirty_bits |= DirtyState_RootSignature | DirtyState_PS_CBV | DirtyState_VS_CBV |
                       DirtyState_GS_CBV | DirtyState_SRV_Descriptor |
-                      DirtyState_Sampler_Descriptor | DirtyState_UAV_Descriptor;
+                      DirtyState_Sampler_Descriptor | DirtyState_UAV_Descriptor |
+                      DirtyState_VS_SRV_Descriptor;
     }
     if (dx_pipeline->UseIntegerRTV() != m_state.using_integer_rtv)
     {
@@ -362,6 +363,11 @@ void Renderer::DrawIndexed(u32 base_index, u32 num_indices, u32 base_vertex)
   if (!ApplyState())
     return;
 
+  // DX12 is great and doesn't include the base vertex in SV_VertexID
+  if (static_cast<const DXPipeline*>(m_current_pipeline)->GetUsage() ==
+      AbstractPipelineUsage::GXUber)
+    g_dx_context->GetCommandList()->SetGraphicsRoot32BitConstant(
+        ROOT_PARAMETER_BASE_VERTEX_CONSTANT, base_vertex, 0);
   g_dx_context->GetCommandList()->DrawIndexedInstanced(num_indices, 1, base_index, base_vertex, 0);
 }
 
@@ -494,18 +500,22 @@ void Renderer::SetPixelShaderUAV(D3D12_CPU_DESCRIPTOR_HANDLE handle)
   m_dirty_bits |= DirtyState_PS_UAV;
 }
 
-void Renderer::SetVertexBuffer(D3D12_GPU_VIRTUAL_ADDRESS address, u32 stride, u32 size)
+void Renderer::SetVertexBuffer(D3D12_GPU_VIRTUAL_ADDRESS address, D3D12_CPU_DESCRIPTOR_HANDLE srv,
+                               u32 stride, u32 size)
 {
-  if (m_state.vertex_buffer.BufferLocation == address &&
-      m_state.vertex_buffer.StrideInBytes == stride && m_state.vertex_buffer.SizeInBytes == size)
+  if (m_state.vertex_buffer.BufferLocation != address ||
+      m_state.vertex_buffer.StrideInBytes != stride || m_state.vertex_buffer.SizeInBytes != size)
   {
-    return;
+    m_state.vertex_buffer.BufferLocation = address;
+    m_state.vertex_buffer.StrideInBytes = stride;
+    m_state.vertex_buffer.SizeInBytes = size;
+    m_dirty_bits |= DirtyState_VertexBuffer;
+  }
+  if (m_state.vs_srv.ptr != srv.ptr)
+  {
+    m_state.vs_srv = srv;
+    m_dirty_bits |= DirtyState_VS_SRV;
   }
-
-  m_state.vertex_buffer.BufferLocation = address;
-  m_state.vertex_buffer.StrideInBytes = stride;
-  m_state.vertex_buffer.SizeInBytes = size;
-  m_dirty_bits |= DirtyState_VertexBuffer;
 }
 
 void Renderer::SetIndexBuffer(D3D12_GPU_VIRTUAL_ADDRESS address, u32 size, DXGI_FORMAT format)
@@ -535,15 +545,17 @@ bool Renderer::ApplyState()
   // Clear bits before actually changing state. Some state (e.g. cbuffers) can't be set
   // if utility pipelines are bound.
   const u32 dirty_bits = m_dirty_bits;
-  m_dirty_bits &= ~(
-      DirtyState_Framebuffer | DirtyState_Pipeline | DirtyState_Viewport | DirtyState_ScissorRect |
-      DirtyState_PS_UAV | DirtyState_PS_CBV | DirtyState_VS_CBV | DirtyState_GS_CBV |
-      DirtyState_SRV_Descriptor | DirtyState_Sampler_Descriptor | DirtyState_UAV_Descriptor |
-      DirtyState_VertexBuffer | DirtyState_IndexBuffer | DirtyState_PrimitiveTopology);
+  m_dirty_bits &=
+      ~(DirtyState_Framebuffer | DirtyState_Pipeline | DirtyState_Viewport |
+        DirtyState_ScissorRect | DirtyState_PS_UAV | DirtyState_PS_CBV | DirtyState_VS_CBV |
+        DirtyState_GS_CBV | DirtyState_SRV_Descriptor | DirtyState_Sampler_Descriptor |
+        DirtyState_UAV_Descriptor | DirtyState_VertexBuffer | DirtyState_IndexBuffer |
+        DirtyState_PrimitiveTopology | DirtyState_VS_SRV_Descriptor);
 
   auto* const cmdlist = g_dx_context->GetCommandList();
+  auto* const pipeline = static_cast<const DXPipeline*>(m_current_pipeline);
   if (dirty_bits & DirtyState_Pipeline)
-    cmdlist->SetPipelineState(static_cast<const DXPipeline*>(m_current_pipeline)->GetPipeline());
+    cmdlist->SetPipelineState(pipeline->GetPipeline());
 
   if (dirty_bits & DirtyState_Framebuffer)
     BindFramebuffer(static_cast<DXFramebuffer*>(m_current_framebuffer));
@@ -572,7 +584,7 @@ bool Renderer::ApplyState()
                                             m_state.sampler_descriptor_base);
   }
 
-  if (static_cast<const DXPipeline*>(m_current_pipeline)->GetUsage() == AbstractPipelineUsage::GX)
+  if (pipeline->GetUsage() != AbstractPipelineUsage::Utility)
   {
     if (dirty_bits & DirtyState_VS_CBV)
     {
@@ -589,6 +601,13 @@ bool Renderer::ApplyState()
       }
     }
 
+    if (dirty_bits & DirtyState_VS_SRV_Descriptor &&
+        pipeline->GetUsage() == AbstractPipelineUsage::GXUber)
+    {
+      cmdlist->SetGraphicsRootDescriptorTable(ROOT_PARAMETER_VS_SRV,
+                                              m_state.vertex_srv_descriptor_base);
+    }
+
     if (dirty_bits & DirtyState_GS_CBV)
     {
       cmdlist->SetGraphicsRootConstantBufferView(ROOT_PARAMETER_GS_CBV,
@@ -641,7 +660,9 @@ void Renderer::UpdateDescriptorTables()
   const bool sampler_update_failed =
       (m_dirty_bits & DirtyState_Samplers) && !UpdateSamplerDescriptorTable();
   const bool uav_update_failed = (m_dirty_bits & DirtyState_PS_UAV) && !UpdateUAVDescriptorTable();
-  if (texture_update_failed || sampler_update_failed || uav_update_failed)
+  const bool srv_update_failed =
+      (m_dirty_bits & DirtyState_VS_SRV) && !UpdateVSSRVDescriptorTable();
+  if (texture_update_failed || sampler_update_failed || uav_update_failed || srv_update_failed)
   {
     WARN_LOG_FMT(VIDEO, "Executing command list while waiting for temporary {}",
                  texture_update_failed ? "descriptors" : "samplers");
@@ -651,6 +672,7 @@ void Renderer::UpdateDescriptorTables()
     UpdateSRVDescriptorTable();
     UpdateSamplerDescriptorTable();
     UpdateUAVDescriptorTable();
+    UpdateVSSRVDescriptorTable();
   }
 }
 
@@ -700,6 +722,26 @@ bool Renderer::UpdateUAVDescriptorTable()
   return true;
 }
 
+bool Renderer::UpdateVSSRVDescriptorTable()
+{
+  if (!g_ActiveConfig.backend_info.bSupportsDynamicVertexLoader ||
+      static_cast<const DXPipeline*>(m_current_pipeline)->GetUsage() !=
+          AbstractPipelineUsage::GXUber)
+  {
+    return true;
+  }
+
+  DescriptorHandle handle;
+  if (!g_dx_context->GetDescriptorAllocator()->Allocate(1, &handle))
+    return false;
+
+  g_dx_context->GetDevice()->CopyDescriptorsSimple(1, handle.cpu_handle, m_state.vs_srv,
+                                                   D3D12_DESCRIPTOR_HEAP_TYPE_CBV_SRV_UAV);
+  m_state.vertex_srv_descriptor_base = handle.gpu_handle;
+  m_dirty_bits = (m_dirty_bits & ~DirtyState_VS_SRV) | DirtyState_VS_SRV_Descriptor;
+  return true;
+}
+
 bool Renderer::UpdateComputeUAVDescriptorTable()
 {
   DescriptorHandle handle;
diff --git a/Source/Core/VideoBackends/D3D12/D3D12Renderer.h b/Source/Core/VideoBackends/D3D12/D3D12Renderer.h
index 9624199aa4..19188a5acf 100644
--- a/Source/Core/VideoBackends/D3D12/D3D12Renderer.h
+++ b/Source/Core/VideoBackends/D3D12/D3D12Renderer.h
@@ -88,7 +88,8 @@ public:
   void SetPixelShaderUAV(D3D12_CPU_DESCRIPTOR_HANDLE handle);
 
   // Graphics vertex/index buffer binding.
-  void SetVertexBuffer(D3D12_GPU_VIRTUAL_ADDRESS address, u32 stride, u32 size);
+  void SetVertexBuffer(D3D12_GPU_VIRTUAL_ADDRESS address, D3D12_CPU_DESCRIPTOR_HANDLE srv,
+                       u32 stride, u32 size);
   void SetIndexBuffer(D3D12_GPU_VIRTUAL_ADDRESS address, u32 size, DXGI_FORMAT format);
 
   // Binds all dirty state
@@ -126,6 +127,8 @@ private:
     DirtyState_RootSignature = (1 << 17),
     DirtyState_ComputeRootSignature = (1 << 18),
     DirtyState_DescriptorHeaps = (1 << 19),
+    DirtyState_VS_SRV = (1 << 20),
+    DirtyState_VS_SRV_Descriptor = (1 << 21),
 
     DirtyState_All =
         DirtyState_Framebuffer | DirtyState_Pipeline | DirtyState_Textures | DirtyState_Samplers |
@@ -133,7 +136,8 @@ private:
         DirtyState_PS_UAV | DirtyState_PS_CBV | DirtyState_VS_CBV | DirtyState_GS_CBV |
         DirtyState_SRV_Descriptor | DirtyState_Sampler_Descriptor | DirtyState_UAV_Descriptor |
         DirtyState_VertexBuffer | DirtyState_IndexBuffer | DirtyState_PrimitiveTopology |
-        DirtyState_RootSignature | DirtyState_ComputeRootSignature | DirtyState_DescriptorHeaps
+        DirtyState_RootSignature | DirtyState_ComputeRootSignature | DirtyState_DescriptorHeaps |
+        DirtyState_VS_SRV | DirtyState_VS_SRV_Descriptor
   };
 
   void CheckForSwapChainChanges();
@@ -144,6 +148,7 @@ private:
   void UpdateDescriptorTables();
   bool UpdateSRVDescriptorTable();
   bool UpdateUAVDescriptorTable();
+  bool UpdateVSSRVDescriptorTable();
   bool UpdateComputeUAVDescriptorTable();
   bool UpdateSamplerDescriptorTable();
 
@@ -157,11 +162,13 @@ private:
     DXShader* compute_shader = nullptr;
     std::array<D3D12_GPU_VIRTUAL_ADDRESS, 3> constant_buffers = {};
     std::array<D3D12_CPU_DESCRIPTOR_HANDLE, MAX_TEXTURES> textures = {};
+    D3D12_CPU_DESCRIPTOR_HANDLE vs_srv = {};
     D3D12_CPU_DESCRIPTOR_HANDLE ps_uav = {};
     SamplerStateSet samplers = {};
     const DXTexture* compute_image_texture = nullptr;
     D3D12_VIEWPORT viewport = {};
     D3D12_RECT scissor = {};
+    D3D12_GPU_DESCRIPTOR_HANDLE vertex_srv_descriptor_base = {};
     D3D12_GPU_DESCRIPTOR_HANDLE srv_descriptor_base = {};
     D3D12_GPU_DESCRIPTOR_HANDLE sampler_descriptor_base = {};
     D3D12_GPU_DESCRIPTOR_HANDLE uav_descriptor_base = {};
diff --git a/Source/Core/VideoBackends/D3D12/D3D12VertexManager.cpp b/Source/Core/VideoBackends/D3D12/D3D12VertexManager.cpp
index b85e4e459c..5a9efc0d6c 100644
--- a/Source/Core/VideoBackends/D3D12/D3D12VertexManager.cpp
+++ b/Source/Core/VideoBackends/D3D12/D3D12VertexManager.cpp
@@ -64,6 +64,18 @@ bool VertexManager::Initialize()
                                                         &srv_desc, dh.cpu_handle);
   }
 
+  if (!g_dx_context->GetDescriptorHeapManager().Allocate(&m_vertex_srv))
+  {
+    PanicAlertFmt("Failed to allocate descriptor for vertex srv");
+    return false;
+  }
+
+  D3D12_SHADER_RESOURCE_VIEW_DESC srv_desc = {DXGI_FORMAT_R32_UINT, D3D12_SRV_DIMENSION_BUFFER,
+                                              D3D12_DEFAULT_SHADER_4_COMPONENT_MAPPING};
+  srv_desc.Buffer.NumElements = m_vertex_stream_buffer.GetSize() / sizeof(u32);
+  g_dx_context->GetDevice()->CreateShaderResourceView(m_vertex_stream_buffer.GetBuffer(), &srv_desc,
+                                                      m_vertex_srv.cpu_handle);
+
   UploadAllConstants();
   return true;
 }
@@ -115,7 +127,8 @@ void VertexManager::CommitBuffer(u32 num_vertices, u32 vertex_stride, u32 num_in
   ADDSTAT(g_stats.this_frame.bytes_vertex_streamed, static_cast<int>(vertex_data_size));
   ADDSTAT(g_stats.this_frame.bytes_index_streamed, static_cast<int>(index_data_size));
 
-  Renderer::GetInstance()->SetVertexBuffer(m_vertex_stream_buffer.GetGPUPointer(), vertex_stride,
+  Renderer::GetInstance()->SetVertexBuffer(m_vertex_stream_buffer.GetGPUPointer(),
+                                           m_vertex_srv.cpu_handle, vertex_stride,
                                            m_vertex_stream_buffer.GetSize());
   Renderer::GetInstance()->SetIndexBuffer(m_index_stream_buffer.GetGPUPointer(),
                                           m_index_stream_buffer.GetSize(), DXGI_FORMAT_R16_UINT);
diff --git a/Source/Core/VideoBackends/D3D12/D3D12VertexManager.h b/Source/Core/VideoBackends/D3D12/D3D12VertexManager.h
index 6bcff92bb7..2dd2cdfee9 100644
--- a/Source/Core/VideoBackends/D3D12/D3D12VertexManager.h
+++ b/Source/Core/VideoBackends/D3D12/D3D12VertexManager.h
@@ -46,6 +46,7 @@ protected:
   StreamBuffer m_uniform_stream_buffer;
   StreamBuffer m_texel_stream_buffer;
   std::array<DescriptorHandle, NUM_TEXEL_BUFFER_FORMATS> m_texel_buffer_views = {};
+  DescriptorHandle m_vertex_srv = {};
 };
 
 }  // namespace DX12
diff --git a/Source/Core/VideoBackends/D3D12/DX12Context.cpp b/Source/Core/VideoBackends/D3D12/DX12Context.cpp
index e3ff8a7417..5cf0e414c4 100644
--- a/Source/Core/VideoBackends/D3D12/DX12Context.cpp
+++ b/Source/Core/VideoBackends/D3D12/DX12Context.cpp
@@ -261,6 +261,16 @@ bool DXContext::CreateDescriptorHeaps()
   return true;
 }
 
+static void SetRootParamConstant(D3D12_ROOT_PARAMETER* rp, u32 shader_reg, u32 num_values,
+                                 D3D12_SHADER_VISIBILITY visibility)
+{
+  rp->ParameterType = D3D12_ROOT_PARAMETER_TYPE_32BIT_CONSTANTS;
+  rp->Constants.Num32BitValues = num_values;
+  rp->Constants.ShaderRegister = shader_reg;
+  rp->Constants.RegisterSpace = 0;
+  rp->ShaderVisibility = visibility;
+}
+
 static void SetRootParamCBV(D3D12_ROOT_PARAMETER* rp, u32 shader_reg,
                             D3D12_SHADER_VISIBILITY visibility)
 {
@@ -345,6 +355,11 @@ bool DXContext::CreateGXRootSignature()
   param_count++;
   SetRootParamCBV(&params[param_count], 0, D3D12_SHADER_VISIBILITY_GEOMETRY);
   param_count++;
+  SetRootParamTable(&params[param_count], &ranges[param_count], D3D12_DESCRIPTOR_RANGE_TYPE_SRV, 3,
+                    1, D3D12_SHADER_VISIBILITY_VERTEX);
+  param_count++;
+  SetRootParamConstant(&params[param_count], 2, 1, D3D12_SHADER_VISIBILITY_VERTEX);
+  param_count++;
 
   // Since these must be contiguous, pixel lighting goes to bbox if not enabled.
   if (g_ActiveConfig.bBBoxEnable)
diff --git a/Source/Core/VideoBackends/D3D12/DX12Context.h b/Source/Core/VideoBackends/D3D12/DX12Context.h
index d1c5b38798..ad9ef9fe74 100644
--- a/Source/Core/VideoBackends/D3D12/DX12Context.h
+++ b/Source/Core/VideoBackends/D3D12/DX12Context.h
@@ -27,6 +27,8 @@ enum ROOT_PARAMETER
   ROOT_PARAMETER_VS_CBV,
   ROOT_PARAMETER_VS_CBV2,
   ROOT_PARAMETER_GS_CBV,
+  ROOT_PARAMETER_VS_SRV,
+  ROOT_PARAMETER_BASE_VERTEX_CONSTANT,
   ROOT_PARAMETER_PS_UAV_OR_CBV2,
   ROOT_PARAMETER_PS_CBV2,  // ROOT_PARAMETER_PS_UAV_OR_CBV2 if bbox is not enabled
   NUM_ROOT_PARAMETERS
diff --git a/Source/Core/VideoBackends/D3D12/DX12Pipeline.cpp b/Source/Core/VideoBackends/D3D12/DX12Pipeline.cpp
index 52b73e6911..bca820a2c3 100644
--- a/Source/Core/VideoBackends/D3D12/DX12Pipeline.cpp
+++ b/Source/Core/VideoBackends/D3D12/DX12Pipeline.cpp
@@ -165,6 +165,7 @@ std::unique_ptr<DXPipeline> DXPipeline::Create(const AbstractPipelineConfig& con
   switch (config.usage)
   {
   case AbstractPipelineUsage::GX:
+  case AbstractPipelineUsage::GXUber:
     desc.pRootSignature = g_dx_context->GetGXRootSignature();
     break;
   case AbstractPipelineUsage::Utility:
diff --git a/Source/Core/VideoBackends/D3D12/VideoBackend.cpp b/Source/Core/VideoBackends/D3D12/VideoBackend.cpp
index b0611a8690..b901b994e0 100644
--- a/Source/Core/VideoBackends/D3D12/VideoBackend.cpp
+++ b/Source/Core/VideoBackends/D3D12/VideoBackend.cpp
@@ -87,6 +87,7 @@ void VideoBackend::FillBackendInfo()
   g_Config.backend_info.bSupportsLodBiasInSampler = true;
   g_Config.backend_info.bSupportsSettingObjectNames = true;
   g_Config.backend_info.bSupportsPartialMultisampleResolve = true;
+  g_Config.backend_info.bSupportsDynamicVertexLoader = true;
 
   // We can only check texture support once we have a device.
   if (g_dx_context)
diff --git a/Source/Core/VideoBackends/Metal/MTLObjectCache.mm b/Source/Core/VideoBackends/Metal/MTLObjectCache.mm
index 3181e1fdee..48a8ad7dae 100644
--- a/Source/Core/VideoBackends/Metal/MTLObjectCache.mm
+++ b/Source/Core/VideoBackends/Metal/MTLObjectCache.mm
@@ -220,7 +220,7 @@ static MTLCullMode Convert(CullMode cull)
   switch (cull)
   {
   case CullMode::None:
-  case CullMode::All:  // Handled by disabling rasterization
+  case CullMode::All:  // Handled by VertexLoaderManager::RunVertices
     return MTLCullModeNone;
   case CullMode::Front:
     return MTLCullModeFront;
@@ -289,7 +289,8 @@ public:
       }
     };
     template <size_t N>
-    static void CopyAll(std::array<VertexAttribute, N>& output, const AttributeFormat (&input)[N])
+    static void CopyAll(std::array<VertexAttribute, N>& output,
+                        const std::array<AttributeFormat, N>& input)
     {
       for (size_t i = 0; i < N; ++i)
         output[i] = VertexAttribute(input[i]);
@@ -327,13 +328,14 @@ public:
         blend.subtractAlpha  = cfg.blending_state.subtractAlpha.Value();
         // clang-format on
       }
-      // Throw extras in bits we don't otherwise use
-      if (cfg.rasterization_state.cullmode == CullMode::All)
-        blend.hex |= 1 << 29;
-      if (cfg.rasterization_state.primitive == PrimitiveType::Points)
-        blend.hex |= 1 << 30;
-      else if (cfg.rasterization_state.primitive == PrimitiveType::Lines)
-        blend.hex |= 1 << 31;
+
+      if (cfg.usage != AbstractPipelineUsage::GXUber)
+      {
+        if (cfg.rasterization_state.primitive == PrimitiveType::Points)
+          is_points = true;
+        else if (cfg.rasterization_state.primitive == PrimitiveType::Lines)
+          is_lines = true;
+      }
     }
     PipelineID() { memset(this, 0, sizeof(*this)); }
     PipelineID(const PipelineID& other) { memcpy(this, &other, sizeof(*this)); }
@@ -359,7 +361,13 @@ public:
     VertexAttribute v_posmtx;
     const Shader* vertex_shader;
     const Shader* fragment_shader;
-    BlendingState blend;
+    union
+    {
+      BlendingState blend;
+      // Throw extras in bits we don't otherwise use
+      BitField<30, 1, bool, u32> is_points;
+      BitField<31, 1, bool, u32> is_lines;
+    };
     FramebufferState framebuffer;
   };
 
@@ -377,24 +385,17 @@ public:
       auto desc = MRCTransfer([MTLRenderPipelineDescriptor new]);
       [desc setVertexFunction:static_cast<const Shader*>(config.vertex_shader)->GetShader()];
       [desc setFragmentFunction:static_cast<const Shader*>(config.pixel_shader)->GetShader()];
-      if (config.usage == AbstractPipelineUsage::GX)
-      {
-        if ([[[desc vertexFunction] label] containsString:@"Uber"])
-          [desc
-              setLabel:[NSString stringWithFormat:@"GX Uber Pipeline %d", m_pipeline_counter[0]++]];
-        else
-          [desc setLabel:[NSString stringWithFormat:@"GX Pipeline %d", m_pipeline_counter[1]++]];
-      }
+      if (config.usage == AbstractPipelineUsage::GXUber)
+        [desc setLabel:[NSString stringWithFormat:@"GX Uber Pipeline %d", m_pipeline_counter[0]++]];
+      else if (config.usage == AbstractPipelineUsage::GX)
+        [desc setLabel:[NSString stringWithFormat:@"GX Pipeline %d", m_pipeline_counter[1]++]];
       else
-      {
         [desc setLabel:[NSString stringWithFormat:@"Utility Pipeline %d", m_pipeline_counter[2]++]];
-      }
       if (config.vertex_format)
         [desc setVertexDescriptor:static_cast<const VertexFormat*>(config.vertex_format)->Get()];
       RasterizationState rs = config.rasterization_state;
-      [desc setInputPrimitiveTopology:GetClass(rs.primitive)];
-      if (rs.cullmode == CullMode::All)
-        [desc setRasterizationEnabled:NO];
+      if (config.usage != AbstractPipelineUsage::GXUber)
+        [desc setInputPrimitiveTopology:GetClass(rs.primitive)];
       MTLRenderPipelineColorAttachmentDescriptor* color0 =
           [[desc colorAttachments] objectAtIndexedSubscript:0];
       BlendingState bs = config.blending_state;
diff --git a/Source/Core/VideoBackends/Metal/MTLStateTracker.mm b/Source/Core/VideoBackends/Metal/MTLStateTracker.mm
index 3ab6224f83..0004c81089 100644
--- a/Source/Core/VideoBackends/Metal/MTLStateTracker.mm
+++ b/Source/Core/VideoBackends/Metal/MTLStateTracker.mm
@@ -608,7 +608,7 @@ void Metal::StateTracker::PrepareRender()
     BeginRenderPass(MTLLoadActionLoad);
   id<MTLRenderCommandEncoder> enc = m_current_render_encoder;
   const Pipeline* pipe = m_state.render_pipeline;
-  bool is_gx = pipe->Usage() == AbstractPipelineUsage::GX;
+  bool is_gx = pipe->Usage() != AbstractPipelineUsage::Utility;
   NSString* label = is_gx ? LABEL_GX : LABEL_UTIL;
   if (m_flags.should_apply_label && m_current.label != label)
   {
diff --git a/Source/Core/VideoBackends/Metal/MTLUtil.mm b/Source/Core/VideoBackends/Metal/MTLUtil.mm
index 14c83b5c17..30eb305de3 100644
--- a/Source/Core/VideoBackends/Metal/MTLUtil.mm
+++ b/Source/Core/VideoBackends/Metal/MTLUtil.mm
@@ -74,6 +74,7 @@ void Metal::Util::PopulateBackendInfo(VideoConfig* config)
   config->backend_info.bSupportsSettingObjectNames = true;
   // Metal requires multisample resolve to be done on a render pass
   config->backend_info.bSupportsPartialMultisampleResolve = false;
+  config->backend_info.bSupportsDynamicVertexLoader = true;
 }
 
 void Metal::Util::PopulateBackendInfoAdapters(VideoConfig* config,
@@ -426,6 +427,7 @@ std::optional<std::string> Metal::Util::TranslateShaderToMSL(ShaderStage stage,
   static const spirv_cross::MSLResourceBinding resource_bindings[] = {
       MakeResourceBinding(spv::ExecutionModelVertex,    0, 0, 1, 0, 0), // vs/ubo
       MakeResourceBinding(spv::ExecutionModelVertex,    0, 1, 1, 0, 0), // vs/ubo
+      MakeResourceBinding(spv::ExecutionModelVertex,    2, 1, 0, 0, 0), // vs/ssbo
       MakeResourceBinding(spv::ExecutionModelFragment,  0, 0, 0, 0, 0), // vs/ubo
       MakeResourceBinding(spv::ExecutionModelFragment,  0, 1, 1, 0, 0), // vs/ubo
       MakeResourceBinding(spv::ExecutionModelFragment,  1, 0, 0, 0, 0), // ps/samp0
diff --git a/Source/Core/VideoBackends/Metal/MTLVertexFormat.mm b/Source/Core/VideoBackends/Metal/MTLVertexFormat.mm
index 6453c5189a..d9407402e2 100644
--- a/Source/Core/VideoBackends/Metal/MTLVertexFormat.mm
+++ b/Source/Core/VideoBackends/Metal/MTLVertexFormat.mm
@@ -125,7 +125,7 @@ static void SetAttribute(MTLVertexDescriptor* desc, u32 attribute, const Attribu
 
 template <size_t N>
 static void SetAttributes(MTLVertexDescriptor* desc, u32 attribute,
-                          const AttributeFormat (&format)[N])
+                          const std::array<AttributeFormat, N>& format)
 {
   for (size_t i = 0; i < N; ++i)
     SetAttribute(desc, attribute + i, format[i]);
diff --git a/Source/Core/VideoBackends/Null/NullBackend.cpp b/Source/Core/VideoBackends/Null/NullBackend.cpp
index b68c9cfd94..7cc8919ad0 100644
--- a/Source/Core/VideoBackends/Null/NullBackend.cpp
+++ b/Source/Core/VideoBackends/Null/NullBackend.cpp
@@ -60,6 +60,7 @@ void VideoBackend::InitBackendInfo()
   g_Config.backend_info.bSupportsLodBiasInSampler = false;
   g_Config.backend_info.bSupportsSettingObjectNames = false;
   g_Config.backend_info.bSupportsPartialMultisampleResolve = true;
+  g_Config.backend_info.bSupportsDynamicVertexLoader = false;
 
   // aamodes: We only support 1 sample, so no MSAA
   g_Config.backend_info.Adapters.clear();
diff --git a/Source/Core/VideoBackends/OGL/OGLMain.cpp b/Source/Core/VideoBackends/OGL/OGLMain.cpp
index 24a65f746d..f6a84240e0 100644
--- a/Source/Core/VideoBackends/OGL/OGLMain.cpp
+++ b/Source/Core/VideoBackends/OGL/OGLMain.cpp
@@ -94,6 +94,8 @@ void VideoBackend::InitBackendInfo()
   g_Config.backend_info.bSupportsPipelineCacheData = false;
   g_Config.backend_info.bSupportsLodBiasInSampler = true;
   g_Config.backend_info.bSupportsPartialMultisampleResolve = true;
+  // Unneccessary since OGL doesn't use pipelines
+  g_Config.backend_info.bSupportsDynamicVertexLoader = false;
 
   // TODO: There is a bug here, if texel buffers or SSBOs/atomics are not supported the graphics
   // options will show the option when it is not supported. The only way around this would be
diff --git a/Source/Core/VideoBackends/Software/SWmain.cpp b/Source/Core/VideoBackends/Software/SWmain.cpp
index 80dc4603f2..5076106089 100644
--- a/Source/Core/VideoBackends/Software/SWmain.cpp
+++ b/Source/Core/VideoBackends/Software/SWmain.cpp
@@ -89,6 +89,7 @@ void VideoSoftware::InitBackendInfo()
   g_Config.backend_info.bSupportsLodBiasInSampler = false;
   g_Config.backend_info.bSupportsSettingObjectNames = false;
   g_Config.backend_info.bSupportsPartialMultisampleResolve = true;
+  g_Config.backend_info.bSupportsDynamicVertexLoader = false;
 
   // aamodes
   g_Config.backend_info.AAModes = {1};
diff --git a/Source/Core/VideoBackends/Vulkan/Constants.h b/Source/Core/VideoBackends/Vulkan/Constants.h
index c1218f9a67..52d59b4f45 100644
--- a/Source/Core/VideoBackends/Vulkan/Constants.h
+++ b/Source/Core/VideoBackends/Vulkan/Constants.h
@@ -39,6 +39,8 @@ enum DESCRIPTOR_SET_LAYOUT
 //       - Per-stage UBO (VS/GS/PS, VS constants accessible from PS) [set=0, binding=0-2]
 //       - 8 combined image samplers (accessible from PS) [set=1, binding=0-7]
 //       - 1 SSBO accessible from PS if supported [set=2, binding=0]
+//   - Uber
+//       - Like standard, plus 1 SSBO accessible from VS if supported [set=2, binding=1]
 //   - Utility
 //       - 1 combined UBO, accessible from VS/GS/PS [set=0, binding=0]
 //       - 8 combined image samplers (accessible from PS) [set=1, binding=0-7]
@@ -55,6 +57,7 @@ enum DESCRIPTOR_SET_LAYOUT
 enum PIPELINE_LAYOUT
 {
   PIPELINE_LAYOUT_STANDARD,
+  PIPELINE_LAYOUT_UBER,
   PIPELINE_LAYOUT_UTILITY,
   PIPELINE_LAYOUT_COMPUTE,
   NUM_PIPELINE_LAYOUTS
diff --git a/Source/Core/VideoBackends/Vulkan/ObjectCache.cpp b/Source/Core/VideoBackends/Vulkan/ObjectCache.cpp
index fd296457e4..353cb6da3f 100644
--- a/Source/Core/VideoBackends/Vulkan/ObjectCache.cpp
+++ b/Source/Core/VideoBackends/Vulkan/ObjectCache.cpp
@@ -123,8 +123,10 @@ bool ObjectCache::CreateDescriptorSetLayouts()
        VK_SHADER_STAGE_FRAGMENT_BIT},
   }};
 
-  static const std::array<VkDescriptorSetLayoutBinding, 1> standard_ssbo_bindings{{
+  // The dynamic veretex loader's vertex buffer must be last here, for similar reasons
+  static const std::array<VkDescriptorSetLayoutBinding, 2> standard_ssbo_bindings{{
       {0, VK_DESCRIPTOR_TYPE_STORAGE_BUFFER, 1, VK_SHADER_STAGE_FRAGMENT_BIT},
+      {1, VK_DESCRIPTOR_TYPE_STORAGE_BUFFER, 1, VK_SHADER_STAGE_VERTEX_BIT},
   }};
 
   static const std::array<VkDescriptorSetLayoutBinding, 1> utility_ubo_bindings{{
@@ -173,6 +175,10 @@ bool ObjectCache::CreateDescriptorSetLayouts()
   if (!g_ActiveConfig.backend_info.bSupportsGeometryShaders)
     create_infos[DESCRIPTOR_SET_LAYOUT_STANDARD_UNIFORM_BUFFERS].bindingCount--;
 
+  // Remove the dynamic vertex loader's buffer if it'll never be needed
+  if (!g_ActiveConfig.backend_info.bSupportsDynamicVertexLoader)
+    create_infos[DESCRIPTOR_SET_LAYOUT_STANDARD_SHADER_STORAGE_BUFFERS].bindingCount--;
+
   for (size_t i = 0; i < create_infos.size(); i++)
   {
     VkResult res = vkCreateDescriptorSetLayout(g_vulkan_context->GetDevice(), &create_infos[i],
@@ -206,6 +212,11 @@ bool ObjectCache::CreatePipelineLayouts()
       m_descriptor_set_layouts[DESCRIPTOR_SET_LAYOUT_STANDARD_SAMPLERS],
       m_descriptor_set_layouts[DESCRIPTOR_SET_LAYOUT_STANDARD_SHADER_STORAGE_BUFFERS],
   };
+  const std::array<VkDescriptorSetLayout, 3> uber_sets{
+      m_descriptor_set_layouts[DESCRIPTOR_SET_LAYOUT_STANDARD_UNIFORM_BUFFERS],
+      m_descriptor_set_layouts[DESCRIPTOR_SET_LAYOUT_STANDARD_SAMPLERS],
+      m_descriptor_set_layouts[DESCRIPTOR_SET_LAYOUT_STANDARD_SHADER_STORAGE_BUFFERS],
+  };
   const std::array<VkDescriptorSetLayout, 2> utility_sets{
       m_descriptor_set_layouts[DESCRIPTOR_SET_LAYOUT_UTILITY_UNIFORM_BUFFER],
       m_descriptor_set_layouts[DESCRIPTOR_SET_LAYOUT_UTILITY_SAMPLERS],
@@ -220,6 +231,10 @@ bool ObjectCache::CreatePipelineLayouts()
       {VK_STRUCTURE_TYPE_PIPELINE_LAYOUT_CREATE_INFO, nullptr, 0,
        static_cast<u32>(standard_sets.size()), standard_sets.data(), 0, nullptr},
 
+      // Uber
+      {VK_STRUCTURE_TYPE_PIPELINE_LAYOUT_CREATE_INFO, nullptr, 0,
+       static_cast<u32>(uber_sets.size()), uber_sets.data(), 0, nullptr},
+
       // Utility
       {VK_STRUCTURE_TYPE_PIPELINE_LAYOUT_CREATE_INFO, nullptr, 0,
        static_cast<u32>(utility_sets.size()), utility_sets.data(), 0, nullptr},
@@ -232,6 +247,10 @@ bool ObjectCache::CreatePipelineLayouts()
   // If bounding box is unsupported, don't bother with the SSBO descriptor set.
   if (!g_ActiveConfig.backend_info.bSupportsBBox)
     pipeline_layout_info[PIPELINE_LAYOUT_STANDARD].setLayoutCount--;
+  // If neither SSBO-using feature is supported, skip in ubershaders too
+  if (!g_ActiveConfig.backend_info.bSupportsBBox &&
+      !g_ActiveConfig.backend_info.bSupportsDynamicVertexLoader)
+    pipeline_layout_info[PIPELINE_LAYOUT_UBER].setLayoutCount--;
 
   for (size_t i = 0; i < pipeline_layout_info.size(); i++)
   {
diff --git a/Source/Core/VideoBackends/Vulkan/StateTracker.cpp b/Source/Core/VideoBackends/Vulkan/StateTracker.cpp
index db59b16398..686bbce973 100644
--- a/Source/Core/VideoBackends/Vulkan/StateTracker.cpp
+++ b/Source/Core/VideoBackends/Vulkan/StateTracker.cpp
@@ -77,14 +77,23 @@ bool StateTracker::Initialize()
   return true;
 }
 
-void StateTracker::SetVertexBuffer(VkBuffer buffer, VkDeviceSize offset)
+void StateTracker::SetVertexBuffer(VkBuffer buffer, VkDeviceSize offset, u32 size)
 {
-  if (m_vertex_buffer == buffer && m_vertex_buffer_offset == offset)
-    return;
-
-  m_vertex_buffer = buffer;
-  m_vertex_buffer_offset = offset;
-  m_dirty_flags |= DIRTY_FLAG_VERTEX_BUFFER;
+  if (m_vertex_buffer != buffer || m_vertex_buffer_offset != offset)
+  {
+    m_vertex_buffer = buffer;
+    m_vertex_buffer_offset = offset;
+    m_dirty_flags |= DIRTY_FLAG_VERTEX_BUFFER;
+  }
+  if (m_bindings.gx_uber_vertex_ssbo.buffer != buffer ||
+      m_bindings.gx_uber_vertex_ssbo.offset != offset ||
+      m_bindings.gx_uber_vertex_ssbo.range != size)
+  {
+    m_bindings.gx_uber_vertex_ssbo.buffer = buffer;
+    m_bindings.gx_uber_vertex_ssbo.offset = offset;
+    m_bindings.gx_uber_vertex_ssbo.range = size;
+    m_dirty_flags |= DIRTY_FLAG_GX_SSBO;
+  }
 }
 
 void StateTracker::SetIndexBuffer(VkBuffer buffer, VkDeviceSize offset, VkIndexType type)
@@ -366,8 +375,13 @@ bool StateTracker::Bind()
 
   // Re-bind parts of the pipeline
   const VkCommandBuffer command_buffer = g_command_buffer_mgr->GetCurrentCommandBuffer();
-  if (m_dirty_flags & DIRTY_FLAG_VERTEX_BUFFER)
+  const bool needs_vertex_buffer = !g_ActiveConfig.backend_info.bSupportsDynamicVertexLoader ||
+                                   m_pipeline->GetUsage() != AbstractPipelineUsage::GXUber;
+  if (needs_vertex_buffer && (m_dirty_flags & DIRTY_FLAG_VERTEX_BUFFER))
+  {
     vkCmdBindVertexBuffers(command_buffer, 0, 1, &m_vertex_buffer, &m_vertex_buffer_offset);
+    m_dirty_flags &= ~DIRTY_FLAG_VERTEX_BUFFER;
+  }
 
   if (m_dirty_flags & DIRTY_FLAG_INDEX_BUFFER)
     vkCmdBindIndexBuffer(command_buffer, m_index_buffer, m_index_buffer_offset, m_index_type);
@@ -381,8 +395,8 @@ bool StateTracker::Bind()
   if (m_dirty_flags & DIRTY_FLAG_SCISSOR)
     vkCmdSetScissor(command_buffer, 0, 1, &m_scissor);
 
-  m_dirty_flags &= ~(DIRTY_FLAG_VERTEX_BUFFER | DIRTY_FLAG_INDEX_BUFFER | DIRTY_FLAG_PIPELINE |
-                     DIRTY_FLAG_VIEWPORT | DIRTY_FLAG_SCISSOR);
+  m_dirty_flags &=
+      ~(DIRTY_FLAG_INDEX_BUFFER | DIRTY_FLAG_PIPELINE | DIRTY_FLAG_VIEWPORT | DIRTY_FLAG_SCISSOR);
   return true;
 }
 
@@ -452,7 +466,7 @@ void StateTracker::EndClearRenderPass()
 
 bool StateTracker::UpdateDescriptorSet()
 {
-  if (m_pipeline->GetUsage() == AbstractPipelineUsage::GX)
+  if (m_pipeline->GetUsage() != AbstractPipelineUsage::Utility)
     return UpdateGXDescriptorSet();
   else
     return UpdateUtilityDescriptorSet();
@@ -462,7 +476,7 @@ bool StateTracker::UpdateGXDescriptorSet()
 {
   const size_t MAX_DESCRIPTOR_WRITES = NUM_UBO_DESCRIPTOR_SET_BINDINGS +  // UBO
                                        1 +                                // Samplers
-                                       1;                                 // SSBO
+                                       2;                                 // SSBO
   std::array<VkWriteDescriptorSet, MAX_DESCRIPTOR_WRITES> writes;
   u32 num_writes = 0;
 
@@ -516,7 +530,12 @@ bool StateTracker::UpdateGXDescriptorSet()
     m_dirty_flags = (m_dirty_flags & ~DIRTY_FLAG_GX_SAMPLERS) | DIRTY_FLAG_DESCRIPTOR_SETS;
   }
 
-  if (g_ActiveConfig.backend_info.bSupportsBBox &&
+  const bool needs_bbox_ssbo = g_ActiveConfig.backend_info.bSupportsBBox;
+  const bool needs_vertex_ssbo = g_ActiveConfig.backend_info.bSupportsDynamicVertexLoader &&
+                                 m_pipeline->GetUsage() == AbstractPipelineUsage::GXUber;
+  const bool needs_ssbo = needs_bbox_ssbo || needs_vertex_ssbo;
+
+  if (needs_ssbo &&
       (m_dirty_flags & DIRTY_FLAG_GX_SSBO || m_gx_descriptor_sets[2] == VK_NULL_HANDLE))
   {
     m_gx_descriptor_sets[2] =
@@ -528,6 +547,21 @@ bool StateTracker::UpdateGXDescriptorSet()
     writes[num_writes++] = {
         VK_STRUCTURE_TYPE_WRITE_DESCRIPTOR_SET, nullptr, m_gx_descriptor_sets[2], 0,      0, 1,
         VK_DESCRIPTOR_TYPE_STORAGE_BUFFER,      nullptr, &m_bindings.ssbo,        nullptr};
+
+    if (g_ActiveConfig.backend_info.bSupportsDynamicVertexLoader)
+    {
+      writes[num_writes++] = {VK_STRUCTURE_TYPE_WRITE_DESCRIPTOR_SET,
+                              nullptr,
+                              m_gx_descriptor_sets[2],
+                              1,
+                              0,
+                              1,
+                              VK_DESCRIPTOR_TYPE_STORAGE_BUFFER,
+                              nullptr,
+                              &m_bindings.gx_uber_vertex_ssbo,
+                              nullptr};
+    }
+
     m_dirty_flags = (m_dirty_flags & ~DIRTY_FLAG_GX_SSBO) | DIRTY_FLAG_DESCRIPTOR_SETS;
   }
 
@@ -538,9 +572,7 @@ bool StateTracker::UpdateGXDescriptorSet()
   {
     vkCmdBindDescriptorSets(g_command_buffer_mgr->GetCurrentCommandBuffer(),
                             VK_PIPELINE_BIND_POINT_GRAPHICS, m_pipeline->GetVkPipelineLayout(), 0,
-                            g_ActiveConfig.backend_info.bSupportsBBox ?
-                                NUM_GX_DESCRIPTOR_SETS :
-                                (NUM_GX_DESCRIPTOR_SETS - 1),
+                            needs_ssbo ? NUM_GX_DESCRIPTOR_SETS : (NUM_GX_DESCRIPTOR_SETS - 1),
                             m_gx_descriptor_sets.data(),
                             g_ActiveConfig.backend_info.bSupportsGeometryShaders ?
                                 NUM_UBO_DESCRIPTOR_SET_BINDINGS :
diff --git a/Source/Core/VideoBackends/Vulkan/StateTracker.h b/Source/Core/VideoBackends/Vulkan/StateTracker.h
index 7184a2ae4c..bb7311d932 100644
--- a/Source/Core/VideoBackends/Vulkan/StateTracker.h
+++ b/Source/Core/VideoBackends/Vulkan/StateTracker.h
@@ -32,7 +32,7 @@ public:
 
   VKFramebuffer* GetFramebuffer() const { return m_framebuffer; }
   const VKPipeline* GetPipeline() const { return m_pipeline; }
-  void SetVertexBuffer(VkBuffer buffer, VkDeviceSize offset);
+  void SetVertexBuffer(VkBuffer buffer, VkDeviceSize offset, u32 size);
   void SetIndexBuffer(VkBuffer buffer, VkDeviceSize offset, VkIndexType type);
   void SetFramebuffer(VKFramebuffer* framebuffer);
   void SetPipeline(const VKPipeline* pipeline);
@@ -145,6 +145,7 @@ private:
     std::array<VkDescriptorImageInfo, NUM_PIXEL_SHADER_SAMPLERS> samplers;
     std::array<VkBufferView, NUM_COMPUTE_TEXEL_BUFFERS> texel_buffers;
     VkDescriptorBufferInfo ssbo;
+    VkDescriptorBufferInfo gx_uber_vertex_ssbo;
     VkDescriptorImageInfo image_texture;
   } m_bindings = {};
   std::array<VkDescriptorSet, NUM_GX_DESCRIPTOR_SETS> m_gx_descriptor_sets = {};
diff --git a/Source/Core/VideoBackends/Vulkan/VKPipeline.cpp b/Source/Core/VideoBackends/Vulkan/VKPipeline.cpp
index f21fb9bf5e..564f93d802 100644
--- a/Source/Core/VideoBackends/Vulkan/VKPipeline.cpp
+++ b/Source/Core/VideoBackends/Vulkan/VKPipeline.cpp
@@ -251,6 +251,9 @@ std::unique_ptr<VKPipeline> VKPipeline::Create(const AbstractPipelineConfig& con
   case AbstractPipelineUsage::GX:
     pipeline_layout = g_object_cache->GetPipelineLayout(PIPELINE_LAYOUT_STANDARD);
     break;
+  case AbstractPipelineUsage::GXUber:
+    pipeline_layout = g_object_cache->GetPipelineLayout(PIPELINE_LAYOUT_UBER);
+    break;
   case AbstractPipelineUsage::Utility:
     pipeline_layout = g_object_cache->GetPipelineLayout(PIPELINE_LAYOUT_UTILITY);
     break;
diff --git a/Source/Core/VideoBackends/Vulkan/VKVertexManager.cpp b/Source/Core/VideoBackends/Vulkan/VKVertexManager.cpp
index 1c47ea0b8e..146eb2921e 100644
--- a/Source/Core/VideoBackends/Vulkan/VKVertexManager.cpp
+++ b/Source/Core/VideoBackends/Vulkan/VKVertexManager.cpp
@@ -62,7 +62,8 @@ bool VertexManager::Initialize()
     return false;
 
   m_vertex_stream_buffer =
-      StreamBuffer::Create(VK_BUFFER_USAGE_VERTEX_BUFFER_BIT, VERTEX_STREAM_BUFFER_SIZE);
+      StreamBuffer::Create(VK_BUFFER_USAGE_VERTEX_BUFFER_BIT | VK_BUFFER_USAGE_STORAGE_BUFFER_BIT,
+                           VERTEX_STREAM_BUFFER_SIZE);
   m_index_stream_buffer =
       StreamBuffer::Create(VK_BUFFER_USAGE_INDEX_BUFFER_BIT, INDEX_STREAM_BUFFER_SIZE);
   m_uniform_stream_buffer =
@@ -186,7 +187,8 @@ void VertexManager::CommitBuffer(u32 num_vertices, u32 vertex_stride, u32 num_in
   ADDSTAT(g_stats.this_frame.bytes_vertex_streamed, static_cast<int>(vertex_data_size));
   ADDSTAT(g_stats.this_frame.bytes_index_streamed, static_cast<int>(index_data_size));
 
-  StateTracker::GetInstance()->SetVertexBuffer(m_vertex_stream_buffer->GetBuffer(), 0);
+  StateTracker::GetInstance()->SetVertexBuffer(m_vertex_stream_buffer->GetBuffer(), 0,
+                                               VERTEX_STREAM_BUFFER_SIZE);
   StateTracker::GetInstance()->SetIndexBuffer(m_index_stream_buffer->GetBuffer(), 0,
                                               VK_INDEX_TYPE_UINT16);
 }
diff --git a/Source/Core/VideoBackends/Vulkan/VulkanContext.cpp b/Source/Core/VideoBackends/Vulkan/VulkanContext.cpp
index cad326c83a..5b970cc9b1 100644
--- a/Source/Core/VideoBackends/Vulkan/VulkanContext.cpp
+++ b/Source/Core/VideoBackends/Vulkan/VulkanContext.cpp
@@ -295,6 +295,7 @@ void VulkanContext::PopulateBackendInfo(VideoConfig* config)
   config->backend_info.bSupportsLodBiasInSampler = false;          // Dependent on OS.
   config->backend_info.bSupportsSettingObjectNames = false;        // Dependent on features.
   config->backend_info.bSupportsPartialMultisampleResolve = true;  // Assumed support.
+  config->backend_info.bSupportsDynamicVertexLoader = true;        // Assumed support.
 }
 
 void VulkanContext::PopulateBackendInfoAdapters(VideoConfig* config, const GPUList& gpu_list)
diff --git a/Source/Core/VideoCommon/AbstractPipeline.h b/Source/Core/VideoCommon/AbstractPipeline.h
index 0be46eaf5a..60381d0cd9 100644
--- a/Source/Core/VideoCommon/AbstractPipeline.h
+++ b/Source/Core/VideoCommon/AbstractPipeline.h
@@ -20,6 +20,8 @@ class NativeVertexFormat;
 //       - Per-stage UBO (VS/GS/PS, VS constants accessible from PS)
 //       - 8 combined image samplers (accessible from PS)
 //       - 1 SSBO, accessible from PS if bounding box is enabled
+//   - GX Uber
+//       - Same as GX, plus one VS SSBO for vertices if dynamic vertex loading is enabled
 //   - Utility
 //       - Single UBO, accessible from all stages [set=0, binding=1]
 //       - 8 combined image samplers (accessible from PS) [set=1, binding=0-7]
@@ -32,6 +34,7 @@ class NativeVertexFormat;
 enum class AbstractPipelineUsage
 {
   GX,
+  GXUber,
   Utility
 };
 
diff --git a/Source/Core/VideoCommon/ConstantManager.h b/Source/Core/VideoCommon/ConstantManager.h
index 9fd4c060cd..c3427ba37f 100644
--- a/Source/Core/VideoCommon/ConstantManager.h
+++ b/Source/Core/VideoCommon/ConstantManager.h
@@ -93,6 +93,13 @@ struct VertexShaderConstants
 
   float4 cached_tangent;
   float4 cached_binormal;
+  // For UberShader vertex loader
+  u32 vertex_stride;
+  std::array<u32, 3> vertex_offset_normals;
+  u32 vertex_offset_position;
+  u32 vertex_offset_posmtx;
+  std::array<u32, 2> vertex_offset_colors;
+  std::array<u32, 8> vertex_offset_texcoords;
 };
 
 struct GeometryShaderConstants
diff --git a/Source/Core/VideoCommon/NativeVertexFormat.h b/Source/Core/VideoCommon/NativeVertexFormat.h
index 55e1a40178..89f3a06db5 100644
--- a/Source/Core/VideoCommon/NativeVertexFormat.h
+++ b/Source/Core/VideoCommon/NativeVertexFormat.h
@@ -58,9 +58,9 @@ struct PortableVertexDeclaration
   int stride;
 
   AttributeFormat position;
-  AttributeFormat normals[3];
-  AttributeFormat colors[2];
-  AttributeFormat texcoords[8];
+  std::array<AttributeFormat, 3> normals;
+  std::array<AttributeFormat, 2> colors;
+  std::array<AttributeFormat, 8> texcoords;
   AttributeFormat posmtx;
 
   inline bool operator<(const PortableVertexDeclaration& b) const
diff --git a/Source/Core/VideoCommon/OpcodeDecoding.cpp b/Source/Core/VideoCommon/OpcodeDecoding.cpp
index 3f90a2b6e3..bc19a1c2de 100644
--- a/Source/Core/VideoCommon/OpcodeDecoding.cpp
+++ b/Source/Core/VideoCommon/OpcodeDecoding.cpp
@@ -122,7 +122,7 @@ public:
     // HACK
     DataReader src{const_cast<u8*>(vertex_data), const_cast<u8*>(vertex_data) + size};
     const u32 bytes =
-        VertexLoaderManager::RunVertices(vat, primitive, num_vertices, src, is_preprocess);
+        VertexLoaderManager::RunVertices<is_preprocess>(vat, primitive, num_vertices, src);
 
     ASSERT(bytes == size);
 
@@ -228,6 +228,12 @@ public:
       return g_main_cp_state;
   }
 
+  OPCODE_CALLBACK(u32 GetVertexSize(u8 vat))
+  {
+    VertexLoaderBase* loader = VertexLoaderManager::RefreshLoader<is_preprocess>(vat);
+    return loader->m_vertex_size;
+  }
+
   u32 m_cycles = 0;
   bool m_in_display_list = false;
 };
diff --git a/Source/Core/VideoCommon/OpcodeDecoding.h b/Source/Core/VideoCommon/OpcodeDecoding.h
index 1badf63196..2035f5c733 100644
--- a/Source/Core/VideoCommon/OpcodeDecoding.h
+++ b/Source/Core/VideoCommon/OpcodeDecoding.h
@@ -110,6 +110,8 @@ public:
 
   // Get the current CP state.  Needed for vertex decoding; will also be mutated for CP commands.
   virtual CPState& GetCPState() = 0;
+
+  virtual u32 GetVertexSize(u8 vat) = 0;
 #endif
 };
 
@@ -229,8 +231,7 @@ static DOLPHIN_FORCE_INLINE u32 RunCommand(const u8* data, u32 available, T& cal
           (cmdbyte & OpcodeDecoder::GX_PRIMITIVE_MASK) >> OpcodeDecoder::GX_PRIMITIVE_SHIFT);
       const u8 vat = cmdbyte & OpcodeDecoder::GX_VAT_MASK;
 
-      const u32 vertex_size = VertexLoaderBase::GetVertexSize(callback.GetCPState().vtx_desc,
-                                                              callback.GetCPState().vtx_attr[vat]);
+      const u32 vertex_size = callback.GetVertexSize(vat);
       const u16 num_vertices = Common::swap16(&data[1]);
 
       if (available < 3 + num_vertices * vertex_size)
diff --git a/Source/Core/VideoCommon/ShaderCache.cpp b/Source/Core/VideoCommon/ShaderCache.cpp
index 6049fd29a7..f281024f22 100644
--- a/Source/Core/VideoCommon/ShaderCache.cpp
+++ b/Source/Core/VideoCommon/ShaderCache.cpp
@@ -588,10 +588,10 @@ AbstractPipelineConfig ShaderCache::GetGXPipelineConfig(
     const NativeVertexFormat* vertex_format, const AbstractShader* vertex_shader,
     const AbstractShader* geometry_shader, const AbstractShader* pixel_shader,
     const RasterizationState& rasterization_state, const DepthState& depth_state,
-    const BlendingState& blending_state)
+    const BlendingState& blending_state, AbstractPipelineUsage usage)
 {
   AbstractPipelineConfig config = {};
-  config.usage = AbstractPipelineUsage::GX;
+  config.usage = usage;
   config.vertex_format = vertex_format;
   config.vertex_shader = vertex_shader;
   config.geometry_shader = geometry_shader;
@@ -735,7 +735,7 @@ ShaderCache::GetGXPipelineConfig(const GXPipelineUid& config_in)
   }
 
   return GetGXPipelineConfig(config.vertex_format, vs, gs, ps, config.rasterization_state,
-                             config.depth_state, config.blending_state);
+                             config.depth_state, config.blending_state, AbstractPipelineUsage::GX);
 }
 
 /// Edits the UID based on driver bugs and other special configurations
@@ -743,6 +743,8 @@ static GXUberPipelineUid ApplyDriverBugs(const GXUberPipelineUid& in)
 {
   GXUberPipelineUid out;
   memcpy(&out, &in, sizeof(out));  // Copy padding
+  if (g_ActiveConfig.backend_info.bSupportsDynamicVertexLoader)
+    out.vertex_format = nullptr;
   if (g_ActiveConfig.backend_info.bSupportsFramebufferFetch)
   {
     // Always blend in shader
@@ -798,7 +800,8 @@ ShaderCache::GetGXPipelineConfig(const GXUberPipelineUid& config_in)
   }
 
   return GetGXPipelineConfig(config.vertex_format, vs, gs, ps, config.rasterization_state,
-                             config.depth_state, config.blending_state);
+                             config.depth_state, config.blending_state,
+                             AbstractPipelineUsage::GXUber);
 }
 
 const AbstractPipeline* ShaderCache::InsertGXPipeline(const GXPipelineUid& config,
@@ -1233,32 +1236,32 @@ void ShaderCache::QueueUberShaderPipelines()
   dummy_vertex_decl.stride = sizeof(float) * 4;
   NativeVertexFormat* dummy_vertex_format =
       VertexLoaderManager::GetUberVertexFormat(dummy_vertex_decl);
-  auto QueueDummyPipeline = [&](const UberShader::VertexShaderUid& vs_uid,
-                                const GeometryShaderUid& gs_uid,
-                                const UberShader::PixelShaderUid& ps_uid) {
-    GXUberPipelineUid config;
-    config.vertex_format = dummy_vertex_format;
-    config.vs_uid = vs_uid;
-    config.gs_uid = gs_uid;
-    config.ps_uid = ps_uid;
-    config.rasterization_state = RenderState::GetCullBackFaceRasterizationState(
-        static_cast<PrimitiveType>(gs_uid.GetUidData()->primitive_type));
-    config.depth_state = RenderState::GetNoDepthTestingDepthState();
-    config.blending_state = RenderState::GetNoBlendingBlendState();
-    if (ps_uid.GetUidData()->uint_output)
-    {
-      // uint_output is only ever enabled when logic ops are enabled.
-      config.blending_state.logicopenable = true;
-      config.blending_state.logicmode = LogicOp::And;
-    }
+  auto QueueDummyPipeline =
+      [&](const UberShader::VertexShaderUid& vs_uid, const GeometryShaderUid& gs_uid,
+          const UberShader::PixelShaderUid& ps_uid, const BlendingState& blend) {
+        GXUberPipelineUid config;
+        config.vertex_format = dummy_vertex_format;
+        config.vs_uid = vs_uid;
+        config.gs_uid = gs_uid;
+        config.ps_uid = ps_uid;
+        config.rasterization_state = RenderState::GetCullBackFaceRasterizationState(
+            static_cast<PrimitiveType>(gs_uid.GetUidData()->primitive_type));
+        config.depth_state = RenderState::GetNoDepthTestingDepthState();
+        config.blending_state = blend;
+        if (ps_uid.GetUidData()->uint_output)
+        {
+          // uint_output is only ever enabled when logic ops are enabled.
+          config.blending_state.logicopenable = true;
+          config.blending_state.logicmode = LogicOp::And;
+        }
 
-    auto iter = m_gx_uber_pipeline_cache.find(config);
-    if (iter != m_gx_uber_pipeline_cache.end())
-      return;
+        auto iter = m_gx_uber_pipeline_cache.find(config);
+        if (iter != m_gx_uber_pipeline_cache.end())
+          return;
 
-    auto& entry = m_gx_uber_pipeline_cache[config];
-    entry.second = false;
-  };
+        auto& entry = m_gx_uber_pipeline_cache[config];
+        entry.second = false;
+      };
 
   // Populate the pipeline configs with empty entries, these will be compiled afterwards.
   UberShader::EnumerateVertexShaderUids([&](const UberShader::VertexShaderUid& vuid) {
@@ -1275,7 +1278,45 @@ void ShaderCache::QueueUberShaderPipelines()
         {
           return;
         }
-        QueueDummyPipeline(vuid, guid, cleared_puid);
+        BlendingState blend = RenderState::GetNoBlendingBlendState();
+        QueueDummyPipeline(vuid, guid, cleared_puid, blend);
+        if (g_ActiveConfig.backend_info.bSupportsDynamicVertexLoader)
+        {
+          // Not all GPUs need all the pipeline state compiled into shaders, so they tend to key
+          // compiled shaders based on some subset of the pipeline state.
+          // Some test results:
+          //   (GPUs tested: AMD Radeon Pro 5600M, Nvidia GT 750M, Intel UHD 630,
+          //    Intel Iris Pro 5200, Apple M1)
+          // MacOS Metal:
+          //  - AMD, Nvidia, Intel GPUs: Shaders are keyed on vertex layout and whether or not
+          //    dual source blend is enabled.  That's it.
+          //  - Apple GPUs: Shaders are keyed on vertex layout and all blending settings.  We use
+          //    framebuffer fetch here, so the only blending settings used by ubershaders are the
+          //    alphaupdate and colorupdate ones.  Also keyed on primitive type, but Metal supports
+          //    setting it to "unknown" and we do for ubershaders (but MoltenVK won't).
+          // Windows Vulkan:
+          //  - AMD, Nvidia: Definitely keyed on dual source blend, but the others seem more random
+          //    Changing a setting on one shader will require a recompile, but changing the same
+          //    setting on another won't.  Compiling a copy with alphaupdate off, colorupdate off,
+          //    and one with DSB on seems to get pretty good coverage though.
+          // Windows D3D12:
+          //  - AMD: Keyed on dual source blend and vertex layout
+          //  - Nvidia Kepler: No recompiles for changes to vertex layout or blend
+          blend.alphaupdate = false;
+          QueueDummyPipeline(vuid, guid, cleared_puid, blend);
+          blend.alphaupdate = true;
+          blend.colorupdate = false;
+          QueueDummyPipeline(vuid, guid, cleared_puid, blend);
+          blend.colorupdate = true;
+          if (!cleared_puid.GetUidData()->no_dual_src && !cleared_puid.GetUidData()->uint_output)
+          {
+            blend.blendenable = true;
+            blend.usedualsrc = true;
+            blend.srcfactor = SrcBlendFactor::SrcAlpha;
+            blend.dstfactor = DstBlendFactor::InvSrcAlpha;
+            QueueDummyPipeline(vuid, guid, cleared_puid, blend);
+          }
+        }
       });
     });
   });
diff --git a/Source/Core/VideoCommon/ShaderCache.h b/Source/Core/VideoCommon/ShaderCache.h
index ee59fe9ae7..2721cd7319 100644
--- a/Source/Core/VideoCommon/ShaderCache.h
+++ b/Source/Core/VideoCommon/ShaderCache.h
@@ -151,7 +151,7 @@ private:
   GetGXPipelineConfig(const NativeVertexFormat* vertex_format, const AbstractShader* vertex_shader,
                       const AbstractShader* geometry_shader, const AbstractShader* pixel_shader,
                       const RasterizationState& rasterization_state, const DepthState& depth_state,
-                      const BlendingState& blending_state);
+                      const BlendingState& blending_state, AbstractPipelineUsage usage);
   std::optional<AbstractPipelineConfig> GetGXPipelineConfig(const GXPipelineUid& uid);
   std::optional<AbstractPipelineConfig> GetGXPipelineConfig(const GXUberPipelineUid& uid);
   const AbstractPipeline* InsertGXPipeline(const GXPipelineUid& config,
diff --git a/Source/Core/VideoCommon/ShaderGenCommon.cpp b/Source/Core/VideoCommon/ShaderGenCommon.cpp
index b9965421cc..7b407f9aaf 100644
--- a/Source/Core/VideoCommon/ShaderGenCommon.cpp
+++ b/Source/Core/VideoCommon/ShaderGenCommon.cpp
@@ -43,6 +43,7 @@ ShaderHostConfig ShaderHostConfig::GetCurrent()
   bits.manual_texture_sampling_custom_texture_sizes =
       g_ActiveConfig.ManualTextureSamplingWithHiResTextures();
   bits.backend_sampler_lod_bias = g_ActiveConfig.backend_info.bSupportsLodBiasInSampler;
+  bits.backend_dynamic_vertex_loader = g_ActiveConfig.backend_info.bSupportsDynamicVertexLoader;
   return bits;
 }
 
diff --git a/Source/Core/VideoCommon/ShaderGenCommon.h b/Source/Core/VideoCommon/ShaderGenCommon.h
index 1cbff2bfcf..73fa68af03 100644
--- a/Source/Core/VideoCommon/ShaderGenCommon.h
+++ b/Source/Core/VideoCommon/ShaderGenCommon.h
@@ -177,6 +177,7 @@ union ShaderHostConfig
   BitField<24, 1, bool, u32> manual_texture_sampling;
   BitField<25, 1, bool, u32> manual_texture_sampling_custom_texture_sizes;
   BitField<26, 1, bool, u32> backend_sampler_lod_bias;
+  BitField<27, 1, bool, u32> backend_dynamic_vertex_loader;
 
   static ShaderHostConfig GetCurrent();
 };
@@ -302,6 +303,15 @@ static const char s_shader_uniforms[] = "\tuint    components;\n"
                                         "\tuint4   xfmem_pack1[8];\n"
                                         "\tfloat4 " I_CACHED_TANGENT ";\n"
                                         "\tfloat4 " I_CACHED_BINORMAL ";\n"
+                                        "\tuint vertex_stride;\n"
+                                        "\tuint vertex_offset_rawnormal;\n"
+                                        "\tuint vertex_offset_rawtangent;\n"
+                                        "\tuint vertex_offset_rawbinormal;\n"
+                                        "\tuint vertex_offset_rawpos;\n"
+                                        "\tuint vertex_offset_posmtx;\n"
+                                        "\tuint vertex_offset_rawcolor0;\n"
+                                        "\tuint vertex_offset_rawcolor1;\n"
+                                        "\tuint4 vertex_offset_rawtex[2];\n"  // std140 is pain
                                         "\t#define xfmem_texMtxInfo(i) (xfmem_pack1[(i)].x)\n"
                                         "\t#define xfmem_postMtxInfo(i) (xfmem_pack1[(i)].y)\n"
                                         "\t#define xfmem_color(i) (xfmem_pack1[(i)].z)\n"
diff --git a/Source/Core/VideoCommon/UberShaderVertex.cpp b/Source/Core/VideoCommon/UberShaderVertex.cpp
index 67dd84bb7f..04f2b27a14 100644
--- a/Source/Core/VideoCommon/UberShaderVertex.cpp
+++ b/Source/Core/VideoCommon/UberShaderVertex.cpp
@@ -22,7 +22,11 @@ VertexShaderUid GetVertexShaderUid()
   return out;
 }
 
-static void GenVertexShaderTexGens(APIType api_type, u32 num_texgen, ShaderCode& out);
+static void GenVertexShaderTexGens(APIType api_type, const ShaderHostConfig& host_config,
+                                   u32 num_texgen, ShaderCode& out);
+static void LoadVertexAttribute(ShaderCode& code, const ShaderHostConfig& host_config, u32 indent,
+                                std::string_view name, std::string_view shader_type,
+                                std::string_view stored_type, std::string_view offset_name = {});
 
 ShaderCode GenVertexShader(APIType api_type, const ShaderHostConfig& host_config,
                            const vertex_ubershader_uid_data* uid_data)
@@ -50,15 +54,99 @@ ShaderCode GenVertexShader(APIType api_type, const ShaderHostConfig& host_config
   WriteBitfieldExtractHeader(out, api_type, host_config);
   WriteLightingFunction(out);
 
-  out.Write("ATTRIBUTE_LOCATION({}) in float4 rawpos;\n", SHADER_POSITION_ATTRIB);
-  out.Write("ATTRIBUTE_LOCATION({}) in uint4 posmtx;\n", SHADER_POSMTX_ATTRIB);
-  out.Write("ATTRIBUTE_LOCATION({}) in float3 rawnormal;\n", SHADER_NORMAL_ATTRIB);
-  out.Write("ATTRIBUTE_LOCATION({}) in float3 rawtangent;\n", SHADER_TANGENT_ATTRIB);
-  out.Write("ATTRIBUTE_LOCATION({}) in float3 rawbinormal;\n", SHADER_BINORMAL_ATTRIB);
-  out.Write("ATTRIBUTE_LOCATION({}) in float4 rawcolor0;\n", SHADER_COLOR0_ATTRIB);
-  out.Write("ATTRIBUTE_LOCATION({}) in float4 rawcolor1;\n", SHADER_COLOR1_ATTRIB);
-  for (int i = 0; i < 8; ++i)
-    out.Write("ATTRIBUTE_LOCATION({}) in float3 rawtex{};\n", SHADER_TEXTURE0_ATTRIB + i, i);
+  if (host_config.backend_dynamic_vertex_loader)
+  {
+    out.Write(R"(
+SSBO_BINDING(1) readonly restrict buffer Vertices {{
+  uint vertex_buffer[];
+}};
+)");
+    if (api_type == APIType::D3D)
+    {
+      // Write a function to get an offset into vertex_buffer corresponding to this vertex.
+      // This must be done differently for D3D compared to OpenGL/Vulkan/Metal, as on OpenGL, etc.,
+      // gl_VertexID starts counting at the base vertex specified in glDrawElementsBaseVertex,
+      // while on D3D, SV_VertexID (which spirv-cross translates gl_VertexID into) starts counting
+      // at 0 regardless of the BaseVertexLocation value passed to DrawIndexed.  In both cases,
+      // offset 0 of vertex_buffer corresponds to index 0 with basevertex set to 0, so we have to
+      // manually apply the basevertex offset for D3D
+      // D3D12 uses a root constant for this uniform, since it changes with every draw.
+      // D3D11 doesn't currently support dynamic vertex loader, and we'll have to figure something
+      // out for it if we want to support it in the future.
+      out.Write("UBO_BINDING(std140, 3) uniform DX_Constants {{\n"
+                "  uint base_vertex;\n"
+                "}};\n\n"
+                "uint GetVertexBaseOffset() {{\n"
+                "  return (gl_VertexID + base_vertex) * vertex_stride;\n"
+                "}}\n");
+    }
+    else
+    {
+      out.Write("uint GetVertexBaseOffset() {{\n"
+                "  return gl_VertexID * vertex_stride;\n"
+                "}}\n");
+    }
+
+    out.Write(R"(
+uint4 load_input_uint4_ubyte4(uint vtx_offset, uint attr_offset) {{
+  uint value = vertex_buffer[vtx_offset + attr_offset];
+  return uint4(value & 0xff, (value >> 8) & 0xff, (value >> 16) & 0xff, value >> 24);
+}}
+
+float4 load_input_float4_ubyte4(uint vtx_offset, uint attr_offset) {{
+  return float4(load_input_uint4_ubyte4(vtx_offset, attr_offset)) / 255.0f;
+}}
+
+float3 load_input_float3_float3(uint vtx_offset, uint attr_offset) {{
+  uint offset = vtx_offset + attr_offset;
+  return float3(uintBitsToFloat(vertex_buffer[offset + 0]),
+                uintBitsToFloat(vertex_buffer[offset + 1]),
+                uintBitsToFloat(vertex_buffer[offset + 2]));
+}}
+
+float4 load_input_float4_rawpos(uint vtx_offset, uint attr_offset) {{
+  uint components = attr_offset >> 16;
+  uint offset = vtx_offset + (attr_offset & 0xffff);
+  if (components < 3)
+    return float4(uintBitsToFloat(vertex_buffer[offset + 0]),
+                  uintBitsToFloat(vertex_buffer[offset + 1]),
+                  0.0f, 1.0f);
+  else
+    return float4(uintBitsToFloat(vertex_buffer[offset + 0]),
+                  uintBitsToFloat(vertex_buffer[offset + 1]),
+                  uintBitsToFloat(vertex_buffer[offset + 2]),
+                  1.0f);
+}}
+
+float3 load_input_float3_rawtex(uint vtx_offset, uint attr_offset) {{
+  uint components = attr_offset >> 16;
+  uint offset = vtx_offset + (attr_offset & 0xffff);
+  if (components < 2)
+    return float3(uintBitsToFloat(vertex_buffer[offset + 0]), 0.0f, 0.0f);
+  else if (components < 3)
+    return float3(uintBitsToFloat(vertex_buffer[offset + 0]),
+                  uintBitsToFloat(vertex_buffer[offset + 1]),
+                  0.0f);
+  else
+    return float3(uintBitsToFloat(vertex_buffer[offset + 0]),
+                  uintBitsToFloat(vertex_buffer[offset + 1]),
+                  uintBitsToFloat(vertex_buffer[offset + 2]));
+}}
+
+)");
+  }
+  else
+  {
+    out.Write("ATTRIBUTE_LOCATION({}) in float4 rawpos;\n", SHADER_POSITION_ATTRIB);
+    out.Write("ATTRIBUTE_LOCATION({}) in uint4 posmtx;\n", SHADER_POSMTX_ATTRIB);
+    out.Write("ATTRIBUTE_LOCATION({}) in float3 rawnormal;\n", SHADER_NORMAL_ATTRIB);
+    out.Write("ATTRIBUTE_LOCATION({}) in float3 rawtangent;\n", SHADER_TANGENT_ATTRIB);
+    out.Write("ATTRIBUTE_LOCATION({}) in float3 rawbinormal;\n", SHADER_BINORMAL_ATTRIB);
+    out.Write("ATTRIBUTE_LOCATION({}) in float4 rawcolor0;\n", SHADER_COLOR0_ATTRIB);
+    out.Write("ATTRIBUTE_LOCATION({}) in float4 rawcolor1;\n", SHADER_COLOR1_ATTRIB);
+    for (int i = 0; i < 8; ++i)
+      out.Write("ATTRIBUTE_LOCATION({}) in float3 rawtex{};\n", SHADER_TEXTURE0_ATTRIB + i, i);
+  }
 
   if (host_config.backend_geometry_shaders)
   {
@@ -99,7 +187,12 @@ ShaderCode GenVertexShader(APIType api_type, const ShaderHostConfig& host_config
 
   out.Write("VS_OUTPUT o;\n"
             "\n");
-
+  if (host_config.backend_dynamic_vertex_loader)
+  {
+    out.Write("uint vertex_base_offset = GetVertexBaseOffset();\n");
+  }
+  // rawpos is always needed
+  LoadVertexAttribute(out, host_config, 0, "rawpos", "float4", "rawpos");
   // Transforms
   out.Write("// Position matrix\n"
             "float4 P0;\n"
@@ -113,6 +206,7 @@ ShaderCode GenVertexShader(APIType api_type, const ShaderHostConfig& host_config
             "\n"
             "if ((components & {}u) != 0u) {{ // VB_HAS_POSMTXIDX\n",
             VB_HAS_POSMTXIDX);
+  LoadVertexAttribute(out, host_config, 2, "posmtx", "uint4", "ubyte4");
   out.Write("  // Vertex format has a per-vertex matrix\n"
             "  int posidx = int(posmtx.r);\n"
             "  P0 = " I_TRANSFORMMATRICES "[posidx];\n"
@@ -144,27 +238,40 @@ ShaderCode GenVertexShader(APIType api_type, const ShaderHostConfig& host_config
             "// by lighting calculations and needs to be unit length), the same transform matrix\n"
             "// can do double duty, scaling for emboss mapping, and not scaling for lighting.\n"
             "float3 _normal = float3(0.0, 0.0, 0.0);\n"
-            "if ((components & {}u) != 0u) // VB_HAS_NORMAL\n",
+            "if ((components & {}u) != 0u) // VB_HAS_NORMAL\n"
+            "{{\n",
             VB_HAS_NORMAL);
+  LoadVertexAttribute(out, host_config, 2, "rawnormal", "float3", "float3");
   out.Write("  _normal = normalize(float3(dot(N0, rawnormal), dot(N1, rawnormal), dot(N2, "
             "rawnormal)));\n"
+            "}}\n"
             "\n"
             "float3 _tangent = float3(0.0, 0.0, 0.0);\n"
-            "if ((components & {}u) != 0u) // VB_HAS_TANGENT\n",
+            "if ((components & {}u) != 0u) // VB_HAS_TANGENT\n"
+            "{{\n",
             VB_HAS_TANGENT);
+  LoadVertexAttribute(out, host_config, 2, "rawtangent", "float3", "float3");
   out.Write("  _tangent = float3(dot(N0, rawtangent), dot(N1, rawtangent), dot(N2, rawtangent));\n"
+            "}}\n"
             "else\n"
+            "{{\n"
             "  _tangent = float3(dot(N0, " I_CACHED_TANGENT ".xyz), dot(N1, " I_CACHED_TANGENT
             ".xyz), dot(N2, " I_CACHED_TANGENT ".xyz));\n"
+            "}}\n"
             "\n"
             "float3 _binormal = float3(0.0, 0.0, 0.0);\n"
-            "if ((components & {}u) != 0u) // VB_HAS_BINORMAL\n",
+            "if ((components & {}u) != 0u) // VB_HAS_BINORMAL\n"
+            "{{\n",
             VB_HAS_BINORMAL);
+  LoadVertexAttribute(out, host_config, 2, "rawbinormal", "float3", "float3");
   out.Write("  _binormal = float3(dot(N0, rawbinormal), dot(N1, rawbinormal), dot(N2, "
             "rawbinormal));\n"
+            "}}\n"
             "else\n"
+            "{{\n"
             "  _binormal = float3(dot(N0, " I_CACHED_BINORMAL ".xyz), dot(N1, " I_CACHED_BINORMAL
             ".xyz), dot(N2, " I_CACHED_BINORMAL ".xyz));\n"
+            "}}\n"
             "\n");
 
   // Hardware Lighting
@@ -178,34 +285,40 @@ ShaderCode GenVertexShader(APIType api_type, const ShaderHostConfig& host_config
             "bool use_color_1 = ((components & {0}u) == {0}u); // VB_HAS_COL0 | VB_HAS_COL1\n",
             VB_HAS_COL0 | VB_HAS_COL1);
 
-  out.Write("for (uint color = 0u; color < {}u; color++) {{\n", NUM_XF_COLOR_CHANNELS);
-  out.Write("  if ((color == 0u || use_color_1) && (components & ({}u << color)) != 0u) {{\n",
-            VB_HAS_COL0);
-  out.Write("    // Use color0 for channel 0, and color1 for channel 1 if both colors 0 and 1 are "
-            "present.\n"
-            "    if (color == 0u)\n"
-            "      vertex_color_0 = rawcolor0;\n"
-            "    else\n"
-            "      vertex_color_1 = rawcolor1;\n"
-            "  }} else if (color == 0u && (components & {}u) != 0u) {{\n",
-            VB_HAS_COL1);
-  out.Write("    // Use color1 for channel 0 if color0 is not present.\n"
-            "    vertex_color_0 = rawcolor1;\n"
-            "  }} else {{\n"
-            "    if (color == 0u)\n"
-            "      vertex_color_0 = missing_color_value;\n"
-            "    else\n"
-            "      vertex_color_1 = missing_color_value;\n"
-            "  }}\n"
+  out.Write("if ((components & {0}u) == {0}u) // VB_HAS_COL0 | VB_HAS_COL1\n"
+            "{{\n",
+            VB_HAS_COL0 | VB_HAS_COL1);
+  LoadVertexAttribute(out, host_config, 2, "rawcolor0", "float4", "ubyte4");
+  LoadVertexAttribute(out, host_config, 2, "rawcolor1", "float4", "ubyte4");
+  out.Write("  vertex_color_0 = rawcolor0;\n"
+            "  vertex_color_1 = rawcolor1;\n"
             "}}\n"
-            "\n");
+            "else if ((components & {}u) != 0u) // VB_HAS_COL0\n"
+            "{{\n",
+            VB_HAS_COL0);
+  LoadVertexAttribute(out, host_config, 2, "rawcolor0", "float4", "ubyte4");
+  out.Write("  vertex_color_0 = rawcolor0;\n"
+            "  vertex_color_1 = rawcolor0;\n"
+            "}}\n"
+            "else if ((components & {}u) != 0u) // VB_HAS_COL1\n"
+            "{{\n",
+            VB_HAS_COL1);
+  LoadVertexAttribute(out, host_config, 2, "rawcolor1", "float4", "ubyte4");
+  out.Write("  vertex_color_0 = rawcolor1;\n"
+            "  vertex_color_1 = rawcolor1;\n"
+            "}}\n"
+            "else\n"
+            "{{\n"
+            "  vertex_color_0 = missing_color_value;\n"
+            "  vertex_color_1 = missing_color_value;\n"
+            "}}\n");
 
   WriteVertexLighting(out, api_type, "pos.xyz", "_normal", "vertex_color_0", "vertex_color_1",
                       "o.colors_0", "o.colors_1");
 
   // Texture Coordinates
   if (num_texgen > 0)
-    GenVertexShaderTexGens(api_type, num_texgen, out);
+    GenVertexShaderTexGens(api_type, host_config, num_texgen, out);
 
   if (per_pixel_lighting)
   {
@@ -352,7 +465,8 @@ ShaderCode GenVertexShader(APIType api_type, const ShaderHostConfig& host_config
   return out;
 }
 
-static void GenVertexShaderTexGens(APIType api_type, u32 num_texgen, ShaderCode& out)
+static void GenVertexShaderTexGens(APIType api_type, const ShaderHostConfig& host_config,
+                                   u32 num_texgen, ShaderCode& out)
 {
   // The HLSL compiler complains that the output texture coordinates are uninitialized when trying
   // to dynamically index them.
@@ -377,27 +491,40 @@ static void GenVertexShaderTexGens(APIType api_type, u32 num_texgen, ShaderCode&
   out.Write("    coord.xyz = rawpos.xyz;\n");
   out.Write("    break;\n\n");
   out.Write("  case {:s}:\n", SourceRow::Normal);
-  out.Write("    coord.xyz = ((components & {}u /* VB_HAS_NORMAL */) != 0u) ? rawnormal.xyz : "
-            "coord.xyz;",
+  out.Write("    if ((components & {}u) != 0u) // VB_HAS_NORMAL\n"
+            "    {{\n",
             VB_HAS_NORMAL);
-  out.Write("    break;\n\n");
+  LoadVertexAttribute(out, host_config, 6, "rawnormal", "float3", "float3");
+  out.Write("      coord.xyz = rawnormal.xyz;\n"
+            "    }}\n"
+            "    break;\n\n");
   out.Write("  case {:s}:\n", SourceRow::BinormalT);
-  out.Write("    coord.xyz = ((components & {}u /* VB_HAS_TANGENT */) != 0u) ? rawtangent.xyz : "
-            "coord.xyz;",
+  out.Write("    if ((components & {}u) != 0u) // VB_HAS_TANGENT\n"
+            "    {{\n",
             VB_HAS_TANGENT);
-  out.Write("    break;\n\n");
+  LoadVertexAttribute(out, host_config, 6, "rawtangent", "float3", "float3");
+  out.Write("      coord.xyz = rawtangent.xyz;\n"
+            "    }}\n"
+            "    break;\n\n");
   out.Write("  case {:s}:\n", SourceRow::BinormalB);
-  out.Write("    coord.xyz = ((components & {}u /* VB_HAS_BINORMAL */) != 0u) ? rawbinormal.xyz : "
-            "coord.xyz;",
+  out.Write("    if ((components & {}u) != 0u) // VB_HAS_BINORMAL\n"
+            "    {{\n",
             VB_HAS_BINORMAL);
-  out.Write("    break;\n\n");
+  LoadVertexAttribute(out, host_config, 6, "rawbinormal", "float3", "float3");
+  out.Write("      coord.xyz = rawbinormal.xyz;\n"
+            "    }}\n"
+            "    break;\n\n");
   for (u32 i = 0; i < 8; i++)
   {
     out.Write("  case {:s}:\n", static_cast<SourceRow>(static_cast<u32>(SourceRow::Tex0) + i));
-    out.Write(
-        "    coord = ((components & {}u /* VB_HAS_UV{} */) != 0u) ? float4(rawtex{}.x, rawtex{}.y, "
-        "1.0, 1.0) : coord;\n",
-        VB_HAS_UV0 << i, i, i, i);
+    out.Write("    if ((components & {}u) != 0u) // VB_HAS_UV{}\n"
+              "    {{\n",
+              VB_HAS_UV0 << i, i);
+    LoadVertexAttribute(out, host_config, 6, fmt::format("rawtex{}", i), "float3", "rawtex",
+                        fmt::format("rawtex[{}][{}]", i / 4, i % 4));
+    out.Write("      coord = float4(rawtex{}.x, rawtex{}.y, 1.0f, 1.0f);\n"
+              "    }}\n",
+              i, i);
     out.Write("    break;\n\n");
   }
   out.Write("  }}\n"
@@ -447,14 +574,24 @@ static void GenVertexShaderTexGens(APIType api_type, u32 num_texgen, ShaderCode&
             "    {{\n");
   out.Write("      if ((components & ({}u /* VB_HAS_TEXMTXIDX0 */ << texgen)) != 0u) {{\n",
             VB_HAS_TEXMTXIDX0);
-  out.Write("        // This is messy, due to dynamic indexing of the input texture coordinates.\n"
-            "        // Hopefully the compiler will unroll this whole loop anyway and the switch.\n"
-            "        int tmp = 0;\n"
-            "        switch (texgen) {{\n");
-  for (u32 i = 0; i < num_texgen; i++)
-    out.Write("        case {}u: tmp = int(rawtex{}.z); break;\n", i, i);
-  out.Write("        }}\n"
-            "\n");
+  if (host_config.backend_dynamic_vertex_loader)
+  {
+    out.Write("        int tmp = int(load_input_float3_rawtex(vertex_base_offset, "
+              "vertex_offset_rawtex[texgen / 4][texgen % 4]).z);\n"
+              "\n");
+  }
+  else
+  {
+    out.Write(
+        "        // This is messy, due to dynamic indexing of the input texture coordinates.\n"
+        "        // Hopefully the compiler will unroll this whole loop anyway and the switch.\n"
+        "        int tmp = 0;\n"
+        "        switch (texgen) {{\n");
+    for (u32 i = 0; i < num_texgen; i++)
+      out.Write("        case {}u: tmp = int(rawtex{}.z); break;\n", i, i);
+    out.Write("        }}\n"
+              "\n");
+  }
   out.Write("        if ({} == {:s}) {{\n", BitfieldExtract<&TexMtxInfo::projection>("texMtxInfo"),
             TexSize::STQ);
   out.Write("          output_tex.xyz = float3(dot(coord, " I_TRANSFORMMATRICES "[tmp]),\n"
@@ -514,6 +651,19 @@ static void GenVertexShaderTexGens(APIType api_type, u32 num_texgen, ShaderCode&
             "}}\n");
 }
 
+static void LoadVertexAttribute(ShaderCode& code, const ShaderHostConfig& host_config, u32 indent,
+                                std::string_view name, std::string_view shader_type,
+                                std::string_view stored_type, std::string_view offset_name)
+{
+  if (host_config.backend_dynamic_vertex_loader)
+  {
+    code.Write("{:{}}{} {} = load_input_{}_{}(vertex_base_offset, vertex_offset_{});\n", "", indent,
+               shader_type, name, shader_type, stored_type,
+               offset_name.empty() ? name : offset_name);
+  }
+  // else inputs are always available
+}
+
 void EnumerateVertexShaderUids(const std::function<void(const VertexShaderUid&)>& callback)
 {
   VertexShaderUid uid;
diff --git a/Source/Core/VideoCommon/VertexLoaderARM64.cpp b/Source/Core/VideoCommon/VertexLoaderARM64.cpp
index 9388c21a7b..99ba5b3357 100644
--- a/Source/Core/VideoCommon/VertexLoaderARM64.cpp
+++ b/Source/Core/VideoCommon/VertexLoaderARM64.cpp
@@ -60,38 +60,22 @@ VertexLoaderARM64::VertexLoaderARM64(const TVtxDesc& vtx_desc, const VAT& vtx_at
   WriteProtect();
 }
 
-void VertexLoaderARM64::GetVertexAddr(CPArray array, VertexComponentFormat attribute, ARM64Reg reg)
+// Returns the register to use as the base and an offset from that register.
+// For indexed attributes, the index is read into scratch1_reg, and then scratch1_reg with no offset
+// is returned. For direct attributes, an offset from src_reg is returned.
+std::pair<Arm64Gen::ARM64Reg, u32> VertexLoaderARM64::GetVertexAddr(CPArray array,
+                                                                    VertexComponentFormat attribute)
 {
   if (IsIndexed(attribute))
   {
     if (attribute == VertexComponentFormat::Index8)
     {
-      if (m_src_ofs < 4096)
-      {
-        LDRB(IndexType::Unsigned, scratch1_reg, src_reg, m_src_ofs);
-      }
-      else
-      {
-        ADD(reg, src_reg, m_src_ofs);
-        LDRB(IndexType::Unsigned, scratch1_reg, reg, 0);
-      }
+      LDURB(scratch1_reg, src_reg, m_src_ofs);
       m_src_ofs += 1;
     }
-    else
+    else  // Index16
     {
-      if (m_src_ofs < 256)
-      {
-        LDURH(scratch1_reg, src_reg, m_src_ofs);
-      }
-      else if (m_src_ofs <= 8190 && !(m_src_ofs & 1))
-      {
-        LDRH(IndexType::Unsigned, scratch1_reg, src_reg, m_src_ofs);
-      }
-      else
-      {
-        ADD(reg, src_reg, m_src_ofs);
-        LDRH(IndexType::Unsigned, scratch1_reg, reg, 0);
-      }
+      LDURH(scratch1_reg, src_reg, m_src_ofs);
       m_src_ofs += 2;
       REV16(scratch1_reg, scratch1_reg);
     }
@@ -109,25 +93,19 @@ void VertexLoaderARM64::GetVertexAddr(CPArray array, VertexComponentFormat attri
 
     LDR(IndexType::Unsigned, EncodeRegTo64(scratch2_reg), arraybase_reg,
         static_cast<u8>(array) * 8);
-    ADD(EncodeRegTo64(reg), EncodeRegTo64(scratch1_reg), EncodeRegTo64(scratch2_reg));
+    ADD(EncodeRegTo64(scratch1_reg), EncodeRegTo64(scratch1_reg), EncodeRegTo64(scratch2_reg));
+    return {EncodeRegTo64(scratch1_reg), 0};
   }
   else
-    ADD(reg, src_reg, m_src_ofs);
+  {
+    return {src_reg, m_src_ofs};
+  }
 }
 
-s32 VertexLoaderARM64::GetAddressImm(CPArray array, VertexComponentFormat attribute,
-                                     Arm64Gen::ARM64Reg reg, u32 align)
-{
-  if (IsIndexed(attribute) || (m_src_ofs > 255 && (m_src_ofs & (align - 1))))
-    GetVertexAddr(array, attribute, reg);
-  else
-    return m_src_ofs;
-  return -1;
-}
-
-int VertexLoaderARM64::ReadVertex(VertexComponentFormat attribute, ComponentFormat format,
-                                  int count_in, int count_out, bool dequantize, u8 scaling_exponent,
-                                  AttributeFormat* native_format, s32 offset)
+void VertexLoaderARM64::ReadVertex(VertexComponentFormat attribute, ComponentFormat format,
+                                   int count_in, int count_out, bool dequantize,
+                                   u8 scaling_exponent, AttributeFormat* native_format,
+                                   ARM64Reg reg, u32 offset)
 {
   ARM64Reg coords = count_in == 3 ? ARM64Reg::Q31 : ARM64Reg::D31;
   ARM64Reg scale = count_in == 3 ? ARM64Reg::Q30 : ARM64Reg::D30;
@@ -136,23 +114,8 @@ int VertexLoaderARM64::ReadVertex(VertexComponentFormat attribute, ComponentForm
   int load_bytes = elem_size * count_in;
   int load_size = GetLoadSize(load_bytes);
   load_size <<= 3;
-  elem_size <<= 3;
 
-  if (offset == -1)
-  {
-    if (count_in == 1)
-      m_float_emit.LDR(elem_size, IndexType::Unsigned, coords, EncodeRegTo64(scratch1_reg), 0);
-    else
-      m_float_emit.LD1(elem_size, 1, coords, EncodeRegTo64(scratch1_reg));
-  }
-  else if (offset & (load_size - 1))  // Not aligned - unscaled
-  {
-    m_float_emit.LDUR(load_size, coords, src_reg, offset);
-  }
-  else
-  {
-    m_float_emit.LDR(load_size, IndexType::Unsigned, coords, src_reg, offset);
-  }
+  m_float_emit.LDUR(load_size, coords, reg, offset);
 
   if (format != ComponentFormat::Float)
   {
@@ -191,20 +154,7 @@ int VertexLoaderARM64::ReadVertex(VertexComponentFormat attribute, ComponentForm
   }
 
   const u32 write_size = count_out == 3 ? 128 : count_out * 32;
-  const u32 mask = count_out == 3 ? 0xF : count_out == 2 ? 0x7 : 0x3;
-  if (m_dst_ofs < 256)
-  {
-    m_float_emit.STUR(write_size, coords, dst_reg, m_dst_ofs);
-  }
-  else if (!(m_dst_ofs & mask))
-  {
-    m_float_emit.STR(write_size, IndexType::Unsigned, coords, dst_reg, m_dst_ofs);
-  }
-  else
-  {
-    ADD(EncodeRegTo64(scratch2_reg), dst_reg, m_dst_ofs);
-    m_float_emit.ST1(32, 1, coords, EncodeRegTo64(scratch2_reg));
-  }
+  m_float_emit.STUR(write_size, coords, dst_reg, m_dst_ofs);
 
   // Z-Freeze
   if (native_format == &m_native_vtx_decl.position)
@@ -239,11 +189,10 @@ int VertexLoaderARM64::ReadVertex(VertexComponentFormat attribute, ComponentForm
 
   if (attribute == VertexComponentFormat::Direct)
     m_src_ofs += load_bytes;
-
-  return load_bytes;
 }
 
-void VertexLoaderARM64::ReadColor(VertexComponentFormat attribute, ColorFormat format, s32 offset)
+void VertexLoaderARM64::ReadColor(VertexComponentFormat attribute, ColorFormat format, ARM64Reg reg,
+                                  u32 offset)
 {
   int load_bytes = 0;
   switch (format)
@@ -251,12 +200,7 @@ void VertexLoaderARM64::ReadColor(VertexComponentFormat attribute, ColorFormat f
   case ColorFormat::RGB888:
   case ColorFormat::RGB888x:
   case ColorFormat::RGBA8888:
-    if (offset == -1)
-      LDR(IndexType::Unsigned, scratch2_reg, EncodeRegTo64(scratch1_reg), 0);
-    else if (offset & 3)  // Not aligned - unscaled
-      LDUR(scratch2_reg, src_reg, offset);
-    else
-      LDR(IndexType::Unsigned, scratch2_reg, src_reg, offset);
+    LDUR(scratch2_reg, reg, offset);
 
     if (format != ColorFormat::RGBA8888)
       ORR(scratch2_reg, scratch2_reg, LogicalImm(0xFF000000, 32));
@@ -267,12 +211,7 @@ void VertexLoaderARM64::ReadColor(VertexComponentFormat attribute, ColorFormat f
   case ColorFormat::RGB565:
     //                   RRRRRGGG GGGBBBBB
     // AAAAAAAA BBBBBBBB GGGGGGGG RRRRRRRR
-    if (offset == -1)
-      LDRH(IndexType::Unsigned, scratch3_reg, EncodeRegTo64(scratch1_reg), 0);
-    else if (offset & 1)  // Not aligned - unscaled
-      LDURH(scratch3_reg, src_reg, offset);
-    else
-      LDRH(IndexType::Unsigned, scratch3_reg, src_reg, offset);
+    LDURH(scratch3_reg, reg, offset);
 
     REV16(scratch3_reg, scratch3_reg);
 
@@ -304,12 +243,7 @@ void VertexLoaderARM64::ReadColor(VertexComponentFormat attribute, ColorFormat f
     //                   BBBBAAAA RRRRGGGG
     //           REV16 - RRRRGGGG BBBBAAAA
     // AAAAAAAA BBBBBBBB GGGGGGGG RRRRRRRR
-    if (offset == -1)
-      LDRH(IndexType::Unsigned, scratch3_reg, EncodeRegTo64(scratch1_reg), 0);
-    else if (offset & 1)  // Not aligned - unscaled
-      LDURH(scratch3_reg, src_reg, offset);
-    else
-      LDRH(IndexType::Unsigned, scratch3_reg, src_reg, offset);
+    LDURH(scratch3_reg, reg, offset);
 
     // R
     UBFM(scratch1_reg, scratch3_reg, 4, 7);
@@ -336,18 +270,7 @@ void VertexLoaderARM64::ReadColor(VertexComponentFormat attribute, ColorFormat f
   case ColorFormat::RGBA6666:
     //          RRRRRRGG GGGGBBBB BBAAAAAA
     // AAAAAAAA BBBBBBBB GGGGGGGG RRRRRRRR
-    if (offset == -1)
-    {
-      LDUR(scratch3_reg, EncodeRegTo64(scratch1_reg), -1);
-    }
-    else
-    {
-      offset -= 1;
-      if (offset & 3)  // Not aligned - unscaled
-        LDUR(scratch3_reg, src_reg, offset);
-      else
-        LDR(IndexType::Unsigned, scratch3_reg, src_reg, offset);
-    }
+    LDUR(scratch3_reg, reg, offset - 1);
 
     REV32(scratch3_reg, scratch3_reg);
 
@@ -385,6 +308,12 @@ void VertexLoaderARM64::ReadColor(VertexComponentFormat attribute, ColorFormat f
 
 void VertexLoaderARM64::GenerateVertexLoader()
 {
+  // The largest input vertex (with the position matrix index and all texture matrix indices
+  // enabled, and all components set as direct) is 129 bytes (corresponding to a 156-byte
+  // output). This is small enough that we can always use the unscaled load/store instructions
+  // (which allow an offset from -256 to +255).
+  ASSERT(m_vertex_size <= 255);
+
   // R0 - Source pointer
   // R1 - Destination pointer
   // R2 - Count
@@ -456,49 +385,45 @@ void VertexLoaderARM64::GenerateVertexLoader()
 
   // Position
   {
-    int elem_size = GetElementSize(m_VtxAttr.g0.PosFormat);
-    int pos_elements = m_VtxAttr.g0.PosElements == CoordComponentCount::XY ? 2 : 3;
-    int load_bytes = elem_size * pos_elements;
-    int load_size = GetLoadSize(load_bytes);
-    load_size <<= 3;
+    const int pos_elements = m_VtxAttr.g0.PosElements == CoordComponentCount::XY ? 2 : 3;
 
-    s32 offset = GetAddressImm(CPArray::Position, m_VtxDesc.low.Position,
-                               EncodeRegTo64(scratch1_reg), load_size);
+    const auto [reg, offset] = GetVertexAddr(CPArray::Position, m_VtxDesc.low.Position);
     ReadVertex(m_VtxDesc.low.Position, m_VtxAttr.g0.PosFormat, pos_elements, pos_elements,
-               m_VtxAttr.g0.ByteDequant, m_VtxAttr.g0.PosFrac, &m_native_vtx_decl.position, offset);
+               m_VtxAttr.g0.ByteDequant, m_VtxAttr.g0.PosFrac, &m_native_vtx_decl.position, reg,
+               offset);
   }
 
   if (m_VtxDesc.low.Normal != VertexComponentFormat::NotPresent)
   {
-    static const u8 map[8] = {7, 6, 15, 14};
-    const u8 scaling_exponent = map[u32(m_VtxAttr.g0.NormalFormat.Value())];
-    const int limit = m_VtxAttr.g0.NormalElements == NormalComponentCount::NTB ? 3 : 1;
+    static constexpr Common::EnumMap<u8, static_cast<ComponentFormat>(7)> SCALE_MAP = {7, 6, 15, 14,
+                                                                                       0, 0, 0,  0};
+    const u8 scaling_exponent = SCALE_MAP[m_VtxAttr.g0.NormalFormat];
 
-    s32 offset = -1;
-    for (int i = 0; i < limit; i++)
+    // Normal
+    auto [reg, offset] = GetVertexAddr(CPArray::Normal, m_VtxDesc.low.Normal);
+    ReadVertex(m_VtxDesc.low.Normal, m_VtxAttr.g0.NormalFormat, 3, 3, true, scaling_exponent,
+               &m_native_vtx_decl.normals[0], reg, offset);
+
+    if (m_VtxAttr.g0.NormalElements == NormalComponentCount::NTB)
     {
-      if (!i || m_VtxAttr.g0.NormalIndex3)
-      {
-        int elem_size = GetElementSize(m_VtxAttr.g0.NormalFormat);
+      const bool index3 = IsIndexed(m_VtxDesc.low.Normal) && m_VtxAttr.g0.NormalIndex3;
+      const int elem_size = GetElementSize(m_VtxAttr.g0.NormalFormat);
+      const int load_bytes = elem_size * 3;
 
-        int load_bytes = elem_size * 3;
-        int load_size = GetLoadSize(load_bytes);
-
-        offset = GetAddressImm(CPArray::Normal, m_VtxDesc.low.Normal, EncodeRegTo64(scratch1_reg),
-                               load_size << 3);
-
-        if (offset == -1)
-          ADD(EncodeRegTo64(scratch1_reg), EncodeRegTo64(scratch1_reg), i * elem_size * 3);
-        else
-          offset += i * elem_size * 3;
-      }
-      int bytes_read = ReadVertex(m_VtxDesc.low.Normal, m_VtxAttr.g0.NormalFormat, 3, 3, true,
-                                  scaling_exponent, &m_native_vtx_decl.normals[i], offset);
-
-      if (offset == -1)
-        ADD(EncodeRegTo64(scratch1_reg), EncodeRegTo64(scratch1_reg), bytes_read);
-      else
-        offset += bytes_read;
+      // Tangent
+      // If in Index3 mode, and indexed components are used, replace the index with a new index.
+      if (index3)
+        std::tie(reg, offset) = GetVertexAddr(CPArray::Normal, m_VtxDesc.low.Normal);
+      // The tangent comes after the normal; even in index3 mode, an extra offset of load_bytes is
+      // applied. Note that this is different from adding 1 to the index, as the stride for indices
+      // may be different from the size of the tangent itself.
+      ReadVertex(m_VtxDesc.low.Normal, m_VtxAttr.g0.NormalFormat, 3, 3, true, scaling_exponent,
+                 &m_native_vtx_decl.normals[1], reg, offset + load_bytes);
+      // Binormal
+      if (index3)
+        std::tie(reg, offset) = GetVertexAddr(CPArray::Normal, m_VtxDesc.low.Normal);
+      ReadVertex(m_VtxDesc.low.Normal, m_VtxAttr.g0.NormalFormat, 3, 3, true, scaling_exponent,
+                 &m_native_vtx_decl.normals[2], reg, offset + load_bytes * 2);
     }
   }
 
@@ -510,14 +435,8 @@ void VertexLoaderARM64::GenerateVertexLoader()
 
     if (m_VtxDesc.low.Color[i] != VertexComponentFormat::NotPresent)
     {
-      u32 align = 4;
-      if (m_VtxAttr.GetColorFormat(i) == ColorFormat::RGB565 ||
-          m_VtxAttr.GetColorFormat(i) == ColorFormat::RGBA4444)
-        align = 2;
-
-      s32 offset = GetAddressImm(CPArray::Color0 + i, m_VtxDesc.low.Color[i],
-                                 EncodeRegTo64(scratch1_reg), align);
-      ReadColor(m_VtxDesc.low.Color[i], m_VtxAttr.GetColorFormat(i), offset);
+      const auto [reg, offset] = GetVertexAddr(CPArray::Color0 + i, m_VtxDesc.low.Color[i]);
+      ReadColor(m_VtxDesc.low.Color[i], m_VtxAttr.GetColorFormat(i), reg, offset);
       m_native_vtx_decl.colors[i].components = 4;
       m_native_vtx_decl.colors[i].enable = true;
       m_native_vtx_decl.colors[i].offset = m_dst_ofs;
@@ -533,20 +452,14 @@ void VertexLoaderARM64::GenerateVertexLoader()
     m_native_vtx_decl.texcoords[i].type = ComponentFormat::Float;
     m_native_vtx_decl.texcoords[i].integer = false;
 
-    int elements = m_VtxAttr.GetTexElements(i) == TexComponentCount::S ? 1 : 2;
+    const int elements = m_VtxAttr.GetTexElements(i) == TexComponentCount::S ? 1 : 2;
     if (m_VtxDesc.high.TexCoord[i] != VertexComponentFormat::NotPresent)
     {
-      int elem_size = GetElementSize(m_VtxAttr.GetTexFormat(i));
-      int load_bytes = elem_size * (elements + 2);
-      int load_size = GetLoadSize(load_bytes);
-      load_size <<= 3;
-
-      s32 offset = GetAddressImm(CPArray::TexCoord0 + i, m_VtxDesc.high.TexCoord[i],
-                                 EncodeRegTo64(scratch1_reg), load_size);
+      const auto [reg, offset] = GetVertexAddr(CPArray::TexCoord0 + i, m_VtxDesc.high.TexCoord[i]);
       u8 scaling_exponent = m_VtxAttr.GetTexFrac(i);
       ReadVertex(m_VtxDesc.high.TexCoord[i], m_VtxAttr.GetTexFormat(i), elements,
                  m_VtxDesc.low.TexMatIdx[i] ? 2 : elements, m_VtxAttr.g0.ByteDequant,
-                 scaling_exponent, &m_native_vtx_decl.texcoords[i], offset);
+                 scaling_exponent, &m_native_vtx_decl.texcoords[i], reg, offset);
     }
     if (m_VtxDesc.low.TexMatIdx[i])
     {
@@ -567,22 +480,7 @@ void VertexLoaderARM64::GenerateVertexLoader()
       {
         m_native_vtx_decl.texcoords[i].offset = m_dst_ofs;
 
-        if (m_dst_ofs < 256)
-        {
-          STUR(ARM64Reg::SP, dst_reg, m_dst_ofs);
-        }
-        else if (!(m_dst_ofs & 7))
-        {
-          // If m_dst_ofs isn't 8byte aligned we can't store an 8byte zero register
-          // So store two 4byte zero registers
-          // The destination is always 4byte aligned
-          STR(IndexType::Unsigned, ARM64Reg::WSP, dst_reg, m_dst_ofs);
-          STR(IndexType::Unsigned, ARM64Reg::WSP, dst_reg, m_dst_ofs + 4);
-        }
-        else
-        {
-          STR(IndexType::Unsigned, ARM64Reg::SP, dst_reg, m_dst_ofs);
-        }
+        STUR(ARM64Reg::SP, dst_reg, m_dst_ofs);
         m_float_emit.STR(32, IndexType::Unsigned, ARM64Reg::D31, dst_reg, m_dst_ofs + 8);
 
         m_dst_ofs += sizeof(float) * 3;
diff --git a/Source/Core/VideoCommon/VertexLoaderARM64.h b/Source/Core/VideoCommon/VertexLoaderARM64.h
index eccf3f0ad8..83ebbc1a7a 100644
--- a/Source/Core/VideoCommon/VertexLoaderARM64.h
+++ b/Source/Core/VideoCommon/VertexLoaderARM64.h
@@ -3,6 +3,8 @@
 
 #pragma once
 
+#include <utility>
+
 #include "Common/Arm64Emitter.h"
 #include "Common/CommonTypes.h"
 #include "VideoCommon/VertexLoaderBase.h"
@@ -26,12 +28,11 @@ private:
   u32 m_dst_ofs = 0;
   Arm64Gen::FixupBranch m_skip_vertex;
   Arm64Gen::ARM64FloatEmitter m_float_emit;
-  void GetVertexAddr(CPArray array, VertexComponentFormat attribute, Arm64Gen::ARM64Reg reg);
-  s32 GetAddressImm(CPArray array, VertexComponentFormat attribute, Arm64Gen::ARM64Reg reg,
-                    u32 align);
-  int ReadVertex(VertexComponentFormat attribute, ComponentFormat format, int count_in,
-                 int count_out, bool dequantize, u8 scaling_exponent,
-                 AttributeFormat* native_format, s32 offset = -1);
-  void ReadColor(VertexComponentFormat attribute, ColorFormat format, s32 offset);
+  std::pair<Arm64Gen::ARM64Reg, u32> GetVertexAddr(CPArray array, VertexComponentFormat attribute);
+  void ReadVertex(VertexComponentFormat attribute, ComponentFormat format, int count_in,
+                  int count_out, bool dequantize, u8 scaling_exponent,
+                  AttributeFormat* native_format, Arm64Gen::ARM64Reg reg, u32 offset);
+  void ReadColor(VertexComponentFormat attribute, ColorFormat format, Arm64Gen::ARM64Reg reg,
+                 u32 offset);
   void GenerateVertexLoader();
 };
diff --git a/Source/Core/VideoCommon/VertexLoaderBase.cpp b/Source/Core/VideoCommon/VertexLoaderBase.cpp
index 678246783d..bf4e364147 100644
--- a/Source/Core/VideoCommon/VertexLoaderBase.cpp
+++ b/Source/Core/VideoCommon/VertexLoaderBase.cpp
@@ -12,6 +12,7 @@
 #include <fmt/format.h>
 
 #include "Common/Assert.h"
+#include "Common/BitSet.h"
 #include "Common/CommonTypes.h"
 #include "Common/Logging/Log.h"
 #include "Common/MsgHandler.h"
@@ -96,45 +97,33 @@ private:
   std::vector<u8> buffer_b;
 };
 
-template <class Function>
-static void GetComponentSizes(const TVtxDesc& vtx_desc, const VAT& vtx_attr, Function f)
+u32 VertexLoaderBase::GetVertexSize(const TVtxDesc& vtx_desc, const VAT& vtx_attr)
 {
-  if (vtx_desc.low.PosMatIdx)
-    f(1);
-  for (auto texmtxidx : vtx_desc.low.TexMatIdx)
-  {
-    if (texmtxidx)
-      f(1);
-  }
+  u32 size = 0;
+
+  // Each enabled TexMatIdx adds one byte, as does PosMatIdx
+  size += Common::CountSetBits(vtx_desc.low.Hex & 0x1FF);
+
   const u32 pos_size = VertexLoader_Position::GetSize(vtx_desc.low.Position, vtx_attr.g0.PosFormat,
                                                       vtx_attr.g0.PosElements);
-  if (pos_size != 0)
-    f(pos_size);
+  size += pos_size;
   const u32 norm_size =
       VertexLoader_Normal::GetSize(vtx_desc.low.Normal, vtx_attr.g0.NormalFormat,
                                    vtx_attr.g0.NormalElements, vtx_attr.g0.NormalIndex3);
-  if (norm_size != 0)
-    f(norm_size);
+  size += norm_size;
   for (u32 i = 0; i < vtx_desc.low.Color.Size(); i++)
   {
     const u32 color_size =
         VertexLoader_Color::GetSize(vtx_desc.low.Color[i], vtx_attr.GetColorFormat(i));
-    if (color_size != 0)
-      f(color_size);
+    size += color_size;
   }
   for (u32 i = 0; i < vtx_desc.high.TexCoord.Size(); i++)
   {
     const u32 tc_size = VertexLoader_TextCoord::GetSize(
         vtx_desc.high.TexCoord[i], vtx_attr.GetTexFormat(i), vtx_attr.GetTexElements(i));
-    if (tc_size != 0)
-      f(tc_size);
+    size += tc_size;
   }
-}
 
-u32 VertexLoaderBase::GetVertexSize(const TVtxDesc& vtx_desc, const VAT& vtx_attr)
-{
-  u32 size = 0;
-  GetComponentSizes(vtx_desc, vtx_attr, [&size](u32 s) { size += s; });
   return size;
 }
 
@@ -168,14 +157,6 @@ u32 VertexLoaderBase::GetVertexComponents(const TVtxDesc& vtx_desc, const VAT& v
   return components;
 }
 
-std::vector<u32> VertexLoaderBase::GetVertexComponentSizes(const TVtxDesc& vtx_desc,
-                                                           const VAT& vtx_attr)
-{
-  std::vector<u32> sizes;
-  GetComponentSizes(vtx_desc, vtx_attr, [&sizes](u32 s) { sizes.push_back(s); });
-  return sizes;
-}
-
 std::unique_ptr<VertexLoaderBase> VertexLoaderBase::CreateVertexLoader(const TVtxDesc& vtx_desc,
                                                                        const VAT& vtx_attr)
 {
diff --git a/Source/Core/VideoCommon/VertexLoaderBase.h b/Source/Core/VideoCommon/VertexLoaderBase.h
index 26ec5c6026..11e9136251 100644
--- a/Source/Core/VideoCommon/VertexLoaderBase.h
+++ b/Source/Core/VideoCommon/VertexLoaderBase.h
@@ -62,7 +62,6 @@ class VertexLoaderBase
 public:
   static u32 GetVertexSize(const TVtxDesc& vtx_desc, const VAT& vtx_attr);
   static u32 GetVertexComponents(const TVtxDesc& vtx_desc, const VAT& vtx_attr);
-  static std::vector<u32> GetVertexComponentSizes(const TVtxDesc& vtx_desc, const VAT& vtx_attr);
   static std::unique_ptr<VertexLoaderBase> CreateVertexLoader(const TVtxDesc& vtx_desc,
                                                               const VAT& vtx_attr);
   virtual ~VertexLoaderBase() {}
diff --git a/Source/Core/VideoCommon/VertexLoaderManager.cpp b/Source/Core/VideoCommon/VertexLoaderManager.cpp
index 102eb5f94e..bb843a6120 100644
--- a/Source/Core/VideoCommon/VertexLoaderManager.cpp
+++ b/Source/Core/VideoCommon/VertexLoaderManager.cpp
@@ -54,7 +54,6 @@ Common::EnumMap<u8*, CPArray::TexCoord7> cached_arraybases;
 BitSet8 g_main_vat_dirty;
 BitSet8 g_preprocess_vat_dirty;
 bool g_bases_dirty;  // Main only
-u8 g_current_vat;    // Main only
 std::array<VertexLoaderBase*, CP_NUM_VAT_REG> g_main_vertex_loaders;
 std::array<VertexLoaderBase*, CP_NUM_VAT_REG> g_preprocess_vertex_loaders;
 
@@ -78,7 +77,7 @@ void Clear()
 void UpdateVertexArrayPointers()
 {
   // Anything to update?
-  if (!g_bases_dirty)
+  if (!g_bases_dirty) [[likely]]
     return;
 
   // Some games such as Burnout 2 can put invalid addresses into
@@ -198,59 +197,50 @@ NativeVertexFormat* GetUberVertexFormat(const PortableVertexDeclaration& decl)
   return GetOrCreateMatchingFormat(new_decl);
 }
 
-static VertexLoaderBase* RefreshLoader(int vtx_attr_group, bool preprocess = false)
+namespace detail
 {
-  CPState* state = preprocess ? &g_preprocess_cp_state : &g_main_cp_state;
-  BitSet8& attr_dirty = preprocess ? g_preprocess_vat_dirty : g_main_vat_dirty;
-  auto& vertex_loaders = preprocess ? g_main_vertex_loaders : g_preprocess_vertex_loaders;
-  g_current_vat = vtx_attr_group;
+template <bool IsPreprocess>
+VertexLoaderBase* GetOrCreateLoader(int vtx_attr_group)
+{
+  constexpr CPState* state = IsPreprocess ? &g_preprocess_cp_state : &g_main_cp_state;
+  constexpr BitSet8& attr_dirty = IsPreprocess ? g_preprocess_vat_dirty : g_main_vat_dirty;
+  constexpr auto& vertex_loaders =
+      IsPreprocess ? g_preprocess_vertex_loaders : g_main_vertex_loaders;
 
   VertexLoaderBase* loader;
-  if (attr_dirty[vtx_attr_group])
-  {
-    // We are not allowed to create a native vertex format on preprocessing as this is on the wrong
-    // thread
-    bool check_for_native_format = !preprocess;
 
-    VertexLoaderUID uid(state->vtx_desc, state->vtx_attr[vtx_attr_group]);
-    std::lock_guard<std::mutex> lk(s_vertex_loader_map_lock);
-    VertexLoaderMap::iterator iter = s_vertex_loader_map.find(uid);
-    if (iter != s_vertex_loader_map.end())
-    {
-      loader = iter->second.get();
-      check_for_native_format &= !loader->m_native_vertex_format;
-    }
-    else
-    {
-      s_vertex_loader_map[uid] =
-          VertexLoaderBase::CreateVertexLoader(state->vtx_desc, state->vtx_attr[vtx_attr_group]);
-      loader = s_vertex_loader_map[uid].get();
-      INCSTAT(g_stats.num_vertex_loaders);
-    }
-    if (check_for_native_format)
-    {
-      // search for a cached native vertex format
-      const PortableVertexDeclaration& format = loader->m_native_vtx_decl;
-      std::unique_ptr<NativeVertexFormat>& native = s_native_vertex_map[format];
-      if (!native)
-        native = g_renderer->CreateNativeVertexFormat(format);
-      loader->m_native_vertex_format = native.get();
-    }
-    vertex_loaders[vtx_attr_group] = loader;
-    attr_dirty[vtx_attr_group] = false;
+  // We are not allowed to create a native vertex format on preprocessing as this is on the wrong
+  // thread
+  bool check_for_native_format = !IsPreprocess;
+
+  VertexLoaderUID uid(state->vtx_desc, state->vtx_attr[vtx_attr_group]);
+  std::lock_guard<std::mutex> lk(s_vertex_loader_map_lock);
+  VertexLoaderMap::iterator iter = s_vertex_loader_map.find(uid);
+  if (iter != s_vertex_loader_map.end())
+  {
+    loader = iter->second.get();
+    check_for_native_format &= !loader->m_native_vertex_format;
   }
   else
   {
-    loader = vertex_loaders[vtx_attr_group];
+    auto [it, added] = s_vertex_loader_map.try_emplace(
+        uid,
+        VertexLoaderBase::CreateVertexLoader(state->vtx_desc, state->vtx_attr[vtx_attr_group]));
+    loader = it->second.get();
+    INCSTAT(g_stats.num_vertex_loaders);
   }
-
-  // Lookup pointers for any vertex arrays.
-  if (!preprocess)
-    UpdateVertexArrayPointers();
-
+  if (check_for_native_format)
+  {
+    // search for a cached native vertex format
+    loader->m_native_vertex_format = GetOrCreateMatchingFormat(loader->m_native_vtx_decl);
+  }
+  vertex_loaders[vtx_attr_group] = loader;
+  attr_dirty[vtx_attr_group] = false;
   return loader;
 }
 
+}  // namespace detail
+
 static void CheckCPConfiguration(int vtx_attr_group)
 {
   // Validate that the XF input configuration matches the CP configuration
@@ -335,53 +325,62 @@ static void CheckCPConfiguration(int vtx_attr_group)
   }
 }
 
-int RunVertices(int vtx_attr_group, OpcodeDecoder::Primitive primitive, int count, DataReader src,
-                bool is_preprocess)
+template <bool IsPreprocess>
+int RunVertices(int vtx_attr_group, OpcodeDecoder::Primitive primitive, int count, DataReader src)
 {
   if (count == 0)
     return 0;
   ASSERT(count > 0);
 
-  VertexLoaderBase* loader = RefreshLoader(vtx_attr_group, is_preprocess);
+  VertexLoaderBase* loader = RefreshLoader<IsPreprocess>(vtx_attr_group);
 
   int size = count * loader->m_vertex_size;
   if ((int)src.size() < size)
     return -1;
 
-  if (is_preprocess)
-    return size;
-
-  CheckCPConfiguration(vtx_attr_group);
-
-  // If the native vertex format changed, force a flush.
-  if (loader->m_native_vertex_format != s_current_vtx_fmt ||
-      loader->m_native_components != g_current_components)
+  if constexpr (!IsPreprocess)
   {
-    g_vertex_manager->Flush();
+    // Doing early return for the opposite case would be cleaner
+    // but triggers a false unreachable code warning in MSVC debug builds.
+
+    CheckCPConfiguration(vtx_attr_group);
+
+    // If the native vertex format changed, force a flush.
+    if (loader->m_native_vertex_format != s_current_vtx_fmt ||
+        loader->m_native_components != g_current_components)
+    {
+      g_vertex_manager->Flush();
+    }
+    s_current_vtx_fmt = loader->m_native_vertex_format;
+    g_current_components = loader->m_native_components;
+    VertexShaderManager::SetVertexFormat(loader->m_native_components,
+                                         loader->m_native_vertex_format->GetVertexDeclaration());
+
+    // if cull mode is CULL_ALL, tell VertexManager to skip triangles and quads.
+    // They still need to go through vertex loading, because we need to calculate a zfreeze refrence
+    // slope.
+    bool cullall = (bpmem.genMode.cullmode == CullMode::All &&
+                    primitive < OpcodeDecoder::Primitive::GX_DRAW_LINES);
+
+    DataReader dst = g_vertex_manager->PrepareForAdditionalData(
+        primitive, count, loader->m_native_vtx_decl.stride, cullall);
+
+    count = loader->RunVertices(src, dst, count);
+
+    g_vertex_manager->AddIndices(primitive, count);
+    g_vertex_manager->FlushData(count, loader->m_native_vtx_decl.stride);
+
+    ADDSTAT(g_stats.this_frame.num_prims, count);
+    INCSTAT(g_stats.this_frame.num_primitive_joins);
   }
-  s_current_vtx_fmt = loader->m_native_vertex_format;
-  g_current_components = loader->m_native_components;
-  VertexShaderManager::SetVertexFormat(loader->m_native_components);
-
-  // if cull mode is CULL_ALL, tell VertexManager to skip triangles and quads.
-  // They still need to go through vertex loading, because we need to calculate a zfreeze refrence
-  // slope.
-  bool cullall = (bpmem.genMode.cullmode == CullMode::All &&
-                  primitive < OpcodeDecoder::Primitive::GX_DRAW_LINES);
-
-  DataReader dst = g_vertex_manager->PrepareForAdditionalData(
-      primitive, count, loader->m_native_vtx_decl.stride, cullall);
-
-  count = loader->RunVertices(src, dst, count);
-
-  g_vertex_manager->AddIndices(primitive, count);
-  g_vertex_manager->FlushData(count, loader->m_native_vtx_decl.stride);
-
-  ADDSTAT(g_stats.this_frame.num_prims, count);
-  INCSTAT(g_stats.this_frame.num_primitive_joins);
   return size;
 }
 
+template int RunVertices<false>(int vtx_attr_group, OpcodeDecoder::Primitive primitive, int count,
+                                DataReader src);
+template int RunVertices<true>(int vtx_attr_group, OpcodeDecoder::Primitive primitive, int count,
+                               DataReader src);
+
 NativeVertexFormat* GetCurrentVertexFormat()
 {
   return s_current_vtx_fmt;
diff --git a/Source/Core/VideoCommon/VertexLoaderManager.h b/Source/Core/VideoCommon/VertexLoaderManager.h
index c5f9ae5376..464f024697 100644
--- a/Source/Core/VideoCommon/VertexLoaderManager.h
+++ b/Source/Core/VideoCommon/VertexLoaderManager.h
@@ -42,8 +42,16 @@ NativeVertexFormat* GetOrCreateMatchingFormat(const PortableVertexDeclaration& d
 NativeVertexFormat* GetUberVertexFormat(const PortableVertexDeclaration& decl);
 
 // Returns -1 if buf_size is insufficient, else the amount of bytes consumed
-int RunVertices(int vtx_attr_group, OpcodeDecoder::Primitive primitive, int count, DataReader src,
-                bool is_preprocess);
+template <bool IsPreprocess = false>
+int RunVertices(int vtx_attr_group, OpcodeDecoder::Primitive primitive, int count, DataReader src);
+
+namespace detail
+{
+// This will look for an existing loader in the global hashmap or create a new one if there is none.
+// It should not be used directly because RefreshLoaders() has another cache for fast lookups.
+template <bool IsPreprocess = false>
+VertexLoaderBase* GetOrCreateLoader(int vtx_attr_group);
+}  // namespace detail
 
 NativeVertexFormat* GetCurrentVertexFormat();
 
@@ -66,7 +74,31 @@ extern u32 g_current_components;
 extern BitSet8 g_main_vat_dirty;
 extern BitSet8 g_preprocess_vat_dirty;
 extern bool g_bases_dirty;  // Main only
-extern u8 g_current_vat;    // Main only
 extern std::array<VertexLoaderBase*, CP_NUM_VAT_REG> g_main_vertex_loaders;
 extern std::array<VertexLoaderBase*, CP_NUM_VAT_REG> g_preprocess_vertex_loaders;
+
+template <bool IsPreprocess = false>
+VertexLoaderBase* RefreshLoader(int vtx_attr_group)
+{
+  constexpr const BitSet8& attr_dirty = IsPreprocess ? g_preprocess_vat_dirty : g_main_vat_dirty;
+  constexpr const auto& vertex_loaders =
+      IsPreprocess ? g_preprocess_vertex_loaders : g_main_vertex_loaders;
+
+  VertexLoaderBase* loader;
+  if (!attr_dirty[vtx_attr_group]) [[likely]]
+  {
+    loader = vertex_loaders[vtx_attr_group];
+  }
+  else [[unlikely]]
+  {
+    loader = detail::GetOrCreateLoader<IsPreprocess>(vtx_attr_group);
+  }
+
+  // Lookup pointers for any vertex arrays.
+  if constexpr (!IsPreprocess)
+    UpdateVertexArrayPointers();
+
+  return loader;
+}
+
 }  // namespace VertexLoaderManager
diff --git a/Source/Core/VideoCommon/VertexLoaderX64.cpp b/Source/Core/VideoCommon/VertexLoaderX64.cpp
index 27e24e6f28..b1474fd2fa 100644
--- a/Source/Core/VideoCommon/VertexLoaderX64.cpp
+++ b/Source/Core/VideoCommon/VertexLoaderX64.cpp
@@ -79,9 +79,10 @@ OpArg VertexLoaderX64::GetVertexAddr(CPArray array, VertexComponentFormat attrib
   }
 }
 
-int VertexLoaderX64::ReadVertex(OpArg data, VertexComponentFormat attribute, ComponentFormat format,
-                                int count_in, int count_out, bool dequantize, u8 scaling_exponent,
-                                AttributeFormat* native_format)
+void VertexLoaderX64::ReadVertex(OpArg data, VertexComponentFormat attribute,
+                                 ComponentFormat format, int count_in, int count_out,
+                                 bool dequantize, u8 scaling_exponent,
+                                 AttributeFormat* native_format)
 {
   static const __m128i shuffle_lut[5][3] = {
       {_mm_set_epi32(0xFFFFFFFFL, 0xFFFFFFFFL, 0xFFFFFFFFL, 0xFFFFFF00L),   // 1x u8
@@ -276,8 +277,6 @@ int VertexLoaderX64::ReadVertex(OpArg data, VertexComponentFormat attribute, Com
   }
 
   write_zfreeze();
-
-  return load_bytes;
 }
 
 void VertexLoaderX64::ReadColor(OpArg data, VertexComponentFormat attribute, ColorFormat format)
@@ -459,20 +458,45 @@ void VertexLoaderX64::GenerateVertexLoader()
 
   if (m_VtxDesc.low.Normal != VertexComponentFormat::NotPresent)
   {
-    static const u8 map[8] = {7, 6, 15, 14};
-    const u8 scaling_exponent = map[u32(m_VtxAttr.g0.NormalFormat.Value())];
-    const int limit = m_VtxAttr.g0.NormalElements == NormalComponentCount::NTB ? 3 : 1;
+    static constexpr Common::EnumMap<u8, static_cast<ComponentFormat>(7)> SCALE_MAP = {7, 6, 15, 14,
+                                                                                       0, 0, 0,  0};
+    const u8 scaling_exponent = SCALE_MAP[m_VtxAttr.g0.NormalFormat];
 
-    for (int i = 0; i < limit; i++)
+    // Normal
+    data = GetVertexAddr(CPArray::Normal, m_VtxDesc.low.Normal);
+    ReadVertex(data, m_VtxDesc.low.Normal, m_VtxAttr.g0.NormalFormat, 3, 3, true, scaling_exponent,
+               &m_native_vtx_decl.normals[0]);
+
+    if (m_VtxAttr.g0.NormalElements == NormalComponentCount::NTB)
     {
-      if (!i || m_VtxAttr.g0.NormalIndex3)
-      {
+      const bool index3 = IsIndexed(m_VtxDesc.low.Normal) && m_VtxAttr.g0.NormalIndex3;
+      const int elem_size = GetElementSize(m_VtxAttr.g0.NormalFormat);
+      const int load_bytes = elem_size * 3;
+
+      // Tangent
+      // If in Index3 mode, and indexed components are used, replace the index with a new index.
+      if (index3)
         data = GetVertexAddr(CPArray::Normal, m_VtxDesc.low.Normal);
-        int elem_size = GetElementSize(m_VtxAttr.g0.NormalFormat);
-        data.AddMemOffset(i * elem_size * 3);
-      }
-      data.AddMemOffset(ReadVertex(data, m_VtxDesc.low.Normal, m_VtxAttr.g0.NormalFormat, 3, 3,
-                                   true, scaling_exponent, &m_native_vtx_decl.normals[i]));
+      // The tangent comes after the normal; even in index3 mode, this offset is applied.
+      // Note that this is different from adding 1 to the index, as the stride for indices may be
+      // different from the size of the tangent itself.
+      data.AddMemOffset(load_bytes);
+
+      ReadVertex(data, m_VtxDesc.low.Normal, m_VtxAttr.g0.NormalFormat, 3, 3, true,
+                 scaling_exponent, &m_native_vtx_decl.normals[1]);
+
+      // Undo the offset above so that data points to the normal instead of the tangent.
+      // This way, we can add 2*elem_size below to always point to the binormal, even if we replace
+      // data with a new index (which would point to the normal).
+      data.AddMemOffset(-load_bytes);
+
+      // Binormal
+      if (index3)
+        data = GetVertexAddr(CPArray::Normal, m_VtxDesc.low.Normal);
+      data.AddMemOffset(load_bytes * 2);
+
+      ReadVertex(data, m_VtxDesc.low.Normal, m_VtxAttr.g0.NormalFormat, 3, 3, true,
+                 scaling_exponent, &m_native_vtx_decl.normals[2]);
     }
   }
 
diff --git a/Source/Core/VideoCommon/VertexLoaderX64.h b/Source/Core/VideoCommon/VertexLoaderX64.h
index 6a0cf7b785..8650c70c27 100644
--- a/Source/Core/VideoCommon/VertexLoaderX64.h
+++ b/Source/Core/VideoCommon/VertexLoaderX64.h
@@ -25,9 +25,9 @@ private:
   u32 m_dst_ofs = 0;
   Gen::FixupBranch m_skip_vertex;
   Gen::OpArg GetVertexAddr(CPArray array, VertexComponentFormat attribute);
-  int ReadVertex(Gen::OpArg data, VertexComponentFormat attribute, ComponentFormat format,
-                 int count_in, int count_out, bool dequantize, u8 scaling_exponent,
-                 AttributeFormat* native_format);
+  void ReadVertex(Gen::OpArg data, VertexComponentFormat attribute, ComponentFormat format,
+                  int count_in, int count_out, bool dequantize, u8 scaling_exponent,
+                  AttributeFormat* native_format);
   void ReadColor(Gen::OpArg data, VertexComponentFormat attribute, ColorFormat format);
   void GenerateVertexLoader();
 };
diff --git a/Source/Core/VideoCommon/VertexLoader_Color.cpp b/Source/Core/VideoCommon/VertexLoader_Color.cpp
index b41272cbf1..05a50d9660 100644
--- a/Source/Core/VideoCommon/VertexLoader_Color.cpp
+++ b/Source/Core/VideoCommon/VertexLoader_Color.cpp
@@ -205,24 +205,8 @@ constexpr Table<TPipelineFunction> s_table_read_color = {
        Color_ReadIndex_32b_8888<u16>}),
 };
 
-constexpr Table<u32> s_table_read_color_vertex_size = {
-    g({0u, 0u, 0u, 0u, 0u, 0u}),
-    g({2u, 3u, 4u, 2u, 3u, 4u}),
-    g({1u, 1u, 1u, 1u, 1u, 1u}),
-    g({2u, 2u, 2u, 2u, 2u, 2u}),
-};
 }  // Anonymous namespace
 
-u32 VertexLoader_Color::GetSize(VertexComponentFormat type, ColorFormat format)
-{
-  if (format > ColorFormat::RGBA8888)
-  {
-    PanicAlertFmt("Invalid color format {}", format);
-    return 0;
-  }
-  return s_table_read_color_vertex_size[type][format];
-}
-
 TPipelineFunction VertexLoader_Color::GetFunction(VertexComponentFormat type, ColorFormat format)
 {
   if (format > ColorFormat::RGBA8888)
diff --git a/Source/Core/VideoCommon/VertexLoader_Color.h b/Source/Core/VideoCommon/VertexLoader_Color.h
index a3c631ff1f..0e66bfbf86 100644
--- a/Source/Core/VideoCommon/VertexLoader_Color.h
+++ b/Source/Core/VideoCommon/VertexLoader_Color.h
@@ -4,14 +4,44 @@
 #pragma once
 
 #include "Common/CommonTypes.h"
-#include "VideoCommon/VertexLoader.h"
+#include "Common/EnumMap.h"
+#include "Common/Inline.h"
 
-enum class VertexComponentFormat;
-enum class ColorFormat;
+#include "VideoCommon/CPMemory.h"
+#include "VideoCommon/VertexLoader.h"
 
 class VertexLoader_Color
 {
 public:
-  static u32 GetSize(VertexComponentFormat type, ColorFormat format);
+  static DOLPHIN_FORCE_INLINE u32 GetSize(VertexComponentFormat type, ColorFormat format)
+  {
+    if (format > ColorFormat::RGBA8888)
+    {
+      PanicAlertFmt("Invalid color format {}", format);
+      return 0;
+    }
+    return s_table_size[type][format];
+  }
+
   static TPipelineFunction GetFunction(VertexComponentFormat type, ColorFormat format);
+
+private:
+  template <typename T, auto last_member>
+  using EnumMap = typename Common::EnumMap<T, last_member>;
+
+  using SizeTable = EnumMap<EnumMap<u32, ColorFormat::RGBA8888>, VertexComponentFormat::Index16>;
+
+  static constexpr SizeTable s_table_size = []() consteval
+  {
+    SizeTable table{};
+
+    using VCF = VertexComponentFormat;
+
+    table[VCF::Direct] = {2u, 3u, 4u, 2u, 3u, 4u};
+    table[VCF::Index8] = {1u, 1u, 1u, 1u, 1u, 1u};
+    table[VCF::Index16] = {2u, 2u, 2u, 2u, 2u, 2u};
+
+    return table;
+  }
+  ();
 };
diff --git a/Source/Core/VideoCommon/VertexLoader_Normal.cpp b/Source/Core/VideoCommon/VertexLoader_Normal.cpp
index 6813e4128c..3b685e0ca4 100644
--- a/Source/Core/VideoCommon/VertexLoader_Normal.cpp
+++ b/Source/Core/VideoCommon/VertexLoader_Normal.cpp
@@ -63,20 +63,15 @@ void ReadIndirect(VertexLoader* loader, const T* data)
 }
 
 template <typename T, u32 N>
-struct Normal_Direct
+void Normal_ReadDirect(VertexLoader* loader)
 {
-  static void function(VertexLoader* loader)
-  {
-    const auto source = reinterpret_cast<const T*>(DataGetPosition());
-    ReadIndirect<T, N * 3>(loader, source);
-    DataSkip<N * 3 * sizeof(T)>();
-  }
-
-  static constexpr u32 size = sizeof(T) * N * 3;
-};
+  const auto source = reinterpret_cast<const T*>(DataGetPosition());
+  ReadIndirect<T, N * 3>(loader, source);
+  DataSkip<N * 3 * sizeof(T)>();
+}
 
 template <typename I, typename T, u32 N, u32 Offset>
-void Normal_Index_Offset(VertexLoader* loader)
+void Normal_ReadIndex_Offset(VertexLoader* loader)
 {
   static_assert(std::is_unsigned_v<I>, "Only unsigned I is sane!");
 
@@ -88,46 +83,26 @@ void Normal_Index_Offset(VertexLoader* loader)
 }
 
 template <typename I, typename T, u32 N>
-struct Normal_Index
+void Normal_ReadIndex(VertexLoader* loader)
 {
-  static void function(VertexLoader* loader) { Normal_Index_Offset<I, T, N, 0>(loader); }
-  static constexpr u32 size = sizeof(I);
-};
+  Normal_ReadIndex_Offset<I, T, N, 0>(loader);
+}
 
 template <typename I, typename T>
-struct Normal_Index_Indices3
+void Normal_ReadIndex_Indices3(VertexLoader* loader)
 {
-  static void function(VertexLoader* loader)
-  {
-    Normal_Index_Offset<I, T, 1, 0>(loader);
-    Normal_Index_Offset<I, T, 1, 1>(loader);
-    Normal_Index_Offset<I, T, 1, 2>(loader);
-  }
-
-  static constexpr u32 size = sizeof(I) * 3;
-};
-
-struct Set
-{
-  template <typename T>
-  constexpr Set& operator=(const T&)
-  {
-    gc_size = T::size;
-    function = T::function;
-    return *this;
-  }
-
-  u32 gc_size;
-  TPipelineFunction function;
-};
+  Normal_ReadIndex_Offset<I, T, 1, 0>(loader);
+  Normal_ReadIndex_Offset<I, T, 1, 1>(loader);
+  Normal_ReadIndex_Offset<I, T, 1, 2>(loader);
+}
 
 using Common::EnumMap;
-using Formats = EnumMap<Set, ComponentFormat::Float>;
+using Formats = EnumMap<TPipelineFunction, ComponentFormat::Float>;
 using Elements = EnumMap<Formats, NormalComponentCount::NTB>;
 using Indices = std::array<Elements, 2>;
 using Types = EnumMap<Indices, VertexComponentFormat::Index16>;
 
-constexpr Types InitializeTable()
+consteval Types InitializeTable()
 {
   Types table{};
 
@@ -135,90 +110,84 @@ constexpr Types InitializeTable()
   using NCC = NormalComponentCount;
   using FMT = ComponentFormat;
 
-  table[VCF::Direct][false][NCC::N][FMT::UByte] = Normal_Direct<u8, 1>();
-  table[VCF::Direct][false][NCC::N][FMT::Byte] = Normal_Direct<s8, 1>();
-  table[VCF::Direct][false][NCC::N][FMT::UShort] = Normal_Direct<u16, 1>();
-  table[VCF::Direct][false][NCC::N][FMT::Short] = Normal_Direct<s16, 1>();
-  table[VCF::Direct][false][NCC::N][FMT::Float] = Normal_Direct<float, 1>();
-  table[VCF::Direct][false][NCC::NTB][FMT::UByte] = Normal_Direct<u8, 3>();
-  table[VCF::Direct][false][NCC::NTB][FMT::Byte] = Normal_Direct<s8, 3>();
-  table[VCF::Direct][false][NCC::NTB][FMT::UShort] = Normal_Direct<u16, 3>();
-  table[VCF::Direct][false][NCC::NTB][FMT::Short] = Normal_Direct<s16, 3>();
-  table[VCF::Direct][false][NCC::NTB][FMT::Float] = Normal_Direct<float, 3>();
+  table[VCF::Direct][false][NCC::N][FMT::UByte] = Normal_ReadDirect<u8, 1>;
+  table[VCF::Direct][false][NCC::N][FMT::Byte] = Normal_ReadDirect<s8, 1>;
+  table[VCF::Direct][false][NCC::N][FMT::UShort] = Normal_ReadDirect<u16, 1>;
+  table[VCF::Direct][false][NCC::N][FMT::Short] = Normal_ReadDirect<s16, 1>;
+  table[VCF::Direct][false][NCC::N][FMT::Float] = Normal_ReadDirect<float, 1>;
+  table[VCF::Direct][false][NCC::NTB][FMT::UByte] = Normal_ReadDirect<u8, 3>;
+  table[VCF::Direct][false][NCC::NTB][FMT::Byte] = Normal_ReadDirect<s8, 3>;
+  table[VCF::Direct][false][NCC::NTB][FMT::UShort] = Normal_ReadDirect<u16, 3>;
+  table[VCF::Direct][false][NCC::NTB][FMT::Short] = Normal_ReadDirect<s16, 3>;
+  table[VCF::Direct][false][NCC::NTB][FMT::Float] = Normal_ReadDirect<float, 3>;
 
   // Same as above, since there are no indices
-  table[VCF::Direct][true][NCC::N][FMT::UByte] = Normal_Direct<u8, 1>();
-  table[VCF::Direct][true][NCC::N][FMT::Byte] = Normal_Direct<s8, 1>();
-  table[VCF::Direct][true][NCC::N][FMT::UShort] = Normal_Direct<u16, 1>();
-  table[VCF::Direct][true][NCC::N][FMT::Short] = Normal_Direct<s16, 1>();
-  table[VCF::Direct][true][NCC::N][FMT::Float] = Normal_Direct<float, 1>();
-  table[VCF::Direct][true][NCC::NTB][FMT::UByte] = Normal_Direct<u8, 3>();
-  table[VCF::Direct][true][NCC::NTB][FMT::Byte] = Normal_Direct<s8, 3>();
-  table[VCF::Direct][true][NCC::NTB][FMT::UShort] = Normal_Direct<u16, 3>();
-  table[VCF::Direct][true][NCC::NTB][FMT::Short] = Normal_Direct<s16, 3>();
-  table[VCF::Direct][true][NCC::NTB][FMT::Float] = Normal_Direct<float, 3>();
+  table[VCF::Direct][true][NCC::N][FMT::UByte] = Normal_ReadDirect<u8, 1>;
+  table[VCF::Direct][true][NCC::N][FMT::Byte] = Normal_ReadDirect<s8, 1>;
+  table[VCF::Direct][true][NCC::N][FMT::UShort] = Normal_ReadDirect<u16, 1>;
+  table[VCF::Direct][true][NCC::N][FMT::Short] = Normal_ReadDirect<s16, 1>;
+  table[VCF::Direct][true][NCC::N][FMT::Float] = Normal_ReadDirect<float, 1>;
+  table[VCF::Direct][true][NCC::NTB][FMT::UByte] = Normal_ReadDirect<u8, 3>;
+  table[VCF::Direct][true][NCC::NTB][FMT::Byte] = Normal_ReadDirect<s8, 3>;
+  table[VCF::Direct][true][NCC::NTB][FMT::UShort] = Normal_ReadDirect<u16, 3>;
+  table[VCF::Direct][true][NCC::NTB][FMT::Short] = Normal_ReadDirect<s16, 3>;
+  table[VCF::Direct][true][NCC::NTB][FMT::Float] = Normal_ReadDirect<float, 3>;
 
-  table[VCF::Index8][false][NCC::N][FMT::UByte] = Normal_Index<u8, u8, 1>();
-  table[VCF::Index8][false][NCC::N][FMT::Byte] = Normal_Index<u8, s8, 1>();
-  table[VCF::Index8][false][NCC::N][FMT::UShort] = Normal_Index<u8, u16, 1>();
-  table[VCF::Index8][false][NCC::N][FMT::Short] = Normal_Index<u8, s16, 1>();
-  table[VCF::Index8][false][NCC::N][FMT::Float] = Normal_Index<u8, float, 1>();
-  table[VCF::Index8][false][NCC::NTB][FMT::UByte] = Normal_Index<u8, u8, 3>();
-  table[VCF::Index8][false][NCC::NTB][FMT::Byte] = Normal_Index<u8, s8, 3>();
-  table[VCF::Index8][false][NCC::NTB][FMT::UShort] = Normal_Index<u8, u16, 3>();
-  table[VCF::Index8][false][NCC::NTB][FMT::Short] = Normal_Index<u8, s16, 3>();
-  table[VCF::Index8][false][NCC::NTB][FMT::Float] = Normal_Index<u8, float, 3>();
+  table[VCF::Index8][false][NCC::N][FMT::UByte] = Normal_ReadIndex<u8, u8, 1>;
+  table[VCF::Index8][false][NCC::N][FMT::Byte] = Normal_ReadIndex<u8, s8, 1>;
+  table[VCF::Index8][false][NCC::N][FMT::UShort] = Normal_ReadIndex<u8, u16, 1>;
+  table[VCF::Index8][false][NCC::N][FMT::Short] = Normal_ReadIndex<u8, s16, 1>;
+  table[VCF::Index8][false][NCC::N][FMT::Float] = Normal_ReadIndex<u8, float, 1>;
+  table[VCF::Index8][false][NCC::NTB][FMT::UByte] = Normal_ReadIndex<u8, u8, 3>;
+  table[VCF::Index8][false][NCC::NTB][FMT::Byte] = Normal_ReadIndex<u8, s8, 3>;
+  table[VCF::Index8][false][NCC::NTB][FMT::UShort] = Normal_ReadIndex<u8, u16, 3>;
+  table[VCF::Index8][false][NCC::NTB][FMT::Short] = Normal_ReadIndex<u8, s16, 3>;
+  table[VCF::Index8][false][NCC::NTB][FMT::Float] = Normal_ReadIndex<u8, float, 3>;
 
   // Same for NormalComponentCount::N; differs for NTB
-  table[VCF::Index8][true][NCC::N][FMT::UByte] = Normal_Index<u8, u8, 1>();
-  table[VCF::Index8][true][NCC::N][FMT::Byte] = Normal_Index<u8, s8, 1>();
-  table[VCF::Index8][true][NCC::N][FMT::UShort] = Normal_Index<u8, u16, 1>();
-  table[VCF::Index8][true][NCC::N][FMT::Short] = Normal_Index<u8, s16, 1>();
-  table[VCF::Index8][true][NCC::N][FMT::Float] = Normal_Index<u8, float, 1>();
-  table[VCF::Index8][true][NCC::NTB][FMT::UByte] = Normal_Index_Indices3<u8, u8>();
-  table[VCF::Index8][true][NCC::NTB][FMT::Byte] = Normal_Index_Indices3<u8, s8>();
-  table[VCF::Index8][true][NCC::NTB][FMT::UShort] = Normal_Index_Indices3<u8, u16>();
-  table[VCF::Index8][true][NCC::NTB][FMT::Short] = Normal_Index_Indices3<u8, s16>();
-  table[VCF::Index8][true][NCC::NTB][FMT::Float] = Normal_Index_Indices3<u8, float>();
+  table[VCF::Index8][true][NCC::N][FMT::UByte] = Normal_ReadIndex<u8, u8, 1>;
+  table[VCF::Index8][true][NCC::N][FMT::Byte] = Normal_ReadIndex<u8, s8, 1>;
+  table[VCF::Index8][true][NCC::N][FMT::UShort] = Normal_ReadIndex<u8, u16, 1>;
+  table[VCF::Index8][true][NCC::N][FMT::Short] = Normal_ReadIndex<u8, s16, 1>;
+  table[VCF::Index8][true][NCC::N][FMT::Float] = Normal_ReadIndex<u8, float, 1>;
+  table[VCF::Index8][true][NCC::NTB][FMT::UByte] = Normal_ReadIndex_Indices3<u8, u8>;
+  table[VCF::Index8][true][NCC::NTB][FMT::Byte] = Normal_ReadIndex_Indices3<u8, s8>;
+  table[VCF::Index8][true][NCC::NTB][FMT::UShort] = Normal_ReadIndex_Indices3<u8, u16>;
+  table[VCF::Index8][true][NCC::NTB][FMT::Short] = Normal_ReadIndex_Indices3<u8, s16>;
+  table[VCF::Index8][true][NCC::NTB][FMT::Float] = Normal_ReadIndex_Indices3<u8, float>;
 
-  table[VCF::Index16][false][NCC::N][FMT::UByte] = Normal_Index<u16, u8, 1>();
-  table[VCF::Index16][false][NCC::N][FMT::Byte] = Normal_Index<u16, s8, 1>();
-  table[VCF::Index16][false][NCC::N][FMT::UShort] = Normal_Index<u16, u16, 1>();
-  table[VCF::Index16][false][NCC::N][FMT::Short] = Normal_Index<u16, s16, 1>();
-  table[VCF::Index16][false][NCC::N][FMT::Float] = Normal_Index<u16, float, 1>();
-  table[VCF::Index16][false][NCC::NTB][FMT::UByte] = Normal_Index<u16, u8, 3>();
-  table[VCF::Index16][false][NCC::NTB][FMT::Byte] = Normal_Index<u16, s8, 3>();
-  table[VCF::Index16][false][NCC::NTB][FMT::UShort] = Normal_Index<u16, u16, 3>();
-  table[VCF::Index16][false][NCC::NTB][FMT::Short] = Normal_Index<u16, s16, 3>();
-  table[VCF::Index16][false][NCC::NTB][FMT::Float] = Normal_Index<u16, float, 3>();
+  table[VCF::Index16][false][NCC::N][FMT::UByte] = Normal_ReadIndex<u16, u8, 1>;
+  table[VCF::Index16][false][NCC::N][FMT::Byte] = Normal_ReadIndex<u16, s8, 1>;
+  table[VCF::Index16][false][NCC::N][FMT::UShort] = Normal_ReadIndex<u16, u16, 1>;
+  table[VCF::Index16][false][NCC::N][FMT::Short] = Normal_ReadIndex<u16, s16, 1>;
+  table[VCF::Index16][false][NCC::N][FMT::Float] = Normal_ReadIndex<u16, float, 1>;
+  table[VCF::Index16][false][NCC::NTB][FMT::UByte] = Normal_ReadIndex<u16, u8, 3>;
+  table[VCF::Index16][false][NCC::NTB][FMT::Byte] = Normal_ReadIndex<u16, s8, 3>;
+  table[VCF::Index16][false][NCC::NTB][FMT::UShort] = Normal_ReadIndex<u16, u16, 3>;
+  table[VCF::Index16][false][NCC::NTB][FMT::Short] = Normal_ReadIndex<u16, s16, 3>;
+  table[VCF::Index16][false][NCC::NTB][FMT::Float] = Normal_ReadIndex<u16, float, 3>;
 
   // Same for NormalComponentCount::N; differs for NTB
-  table[VCF::Index16][true][NCC::N][FMT::UByte] = Normal_Index<u16, u8, 1>();
-  table[VCF::Index16][true][NCC::N][FMT::Byte] = Normal_Index<u16, s8, 1>();
-  table[VCF::Index16][true][NCC::N][FMT::UShort] = Normal_Index<u16, u16, 1>();
-  table[VCF::Index16][true][NCC::N][FMT::Short] = Normal_Index<u16, s16, 1>();
-  table[VCF::Index16][true][NCC::N][FMT::Float] = Normal_Index<u16, float, 1>();
-  table[VCF::Index16][true][NCC::NTB][FMT::UByte] = Normal_Index_Indices3<u16, u8>();
-  table[VCF::Index16][true][NCC::NTB][FMT::Byte] = Normal_Index_Indices3<u16, s8>();
-  table[VCF::Index16][true][NCC::NTB][FMT::UShort] = Normal_Index_Indices3<u16, u16>();
-  table[VCF::Index16][true][NCC::NTB][FMT::Short] = Normal_Index_Indices3<u16, s16>();
-  table[VCF::Index16][true][NCC::NTB][FMT::Float] = Normal_Index_Indices3<u16, float>();
+  table[VCF::Index16][true][NCC::N][FMT::UByte] = Normal_ReadIndex<u16, u8, 1>;
+  table[VCF::Index16][true][NCC::N][FMT::Byte] = Normal_ReadIndex<u16, s8, 1>;
+  table[VCF::Index16][true][NCC::N][FMT::UShort] = Normal_ReadIndex<u16, u16, 1>;
+  table[VCF::Index16][true][NCC::N][FMT::Short] = Normal_ReadIndex<u16, s16, 1>;
+  table[VCF::Index16][true][NCC::N][FMT::Float] = Normal_ReadIndex<u16, float, 1>;
+  table[VCF::Index16][true][NCC::NTB][FMT::UByte] = Normal_ReadIndex_Indices3<u16, u8>;
+  table[VCF::Index16][true][NCC::NTB][FMT::Byte] = Normal_ReadIndex_Indices3<u16, s8>;
+  table[VCF::Index16][true][NCC::NTB][FMT::UShort] = Normal_ReadIndex_Indices3<u16, u16>;
+  table[VCF::Index16][true][NCC::NTB][FMT::Short] = Normal_ReadIndex_Indices3<u16, s16>;
+  table[VCF::Index16][true][NCC::NTB][FMT::Float] = Normal_ReadIndex_Indices3<u16, float>;
 
   return table;
 }
 
-constexpr Types s_table = InitializeTable();
+constexpr Types s_table_read_normal = InitializeTable();
 }  // Anonymous namespace
 
-u32 VertexLoader_Normal::GetSize(VertexComponentFormat type, ComponentFormat format,
-                                 NormalComponentCount elements, bool index3)
-{
-  return s_table[type][index3][elements][format].gc_size;
-}
-
 TPipelineFunction VertexLoader_Normal::GetFunction(VertexComponentFormat type,
                                                    ComponentFormat format,
                                                    NormalComponentCount elements, bool index3)
 {
-  return s_table[type][index3][elements][format].function;
+  return s_table_read_normal[type][index3][elements][format];
 }
diff --git a/Source/Core/VideoCommon/VertexLoader_Normal.h b/Source/Core/VideoCommon/VertexLoader_Normal.h
index 30674159fb..b5200dc875 100644
--- a/Source/Core/VideoCommon/VertexLoader_Normal.h
+++ b/Source/Core/VideoCommon/VertexLoader_Normal.h
@@ -4,18 +4,110 @@
 #pragma once
 
 #include "Common/CommonTypes.h"
-#include "VideoCommon/VertexLoader.h"
+#include "Common/EnumMap.h"
+#include "Common/Inline.h"
 
-enum class VertexComponentFormat;
-enum class ComponentFormat;
-enum class NormalComponentCount;
+#include "VideoCommon/CPMemory.h"
+#include "VideoCommon/VertexLoader.h"
 
 class VertexLoader_Normal
 {
 public:
-  static u32 GetSize(VertexComponentFormat type, ComponentFormat format,
-                     NormalComponentCount elements, bool index3);
+  static DOLPHIN_FORCE_INLINE u32 GetSize(VertexComponentFormat type, ComponentFormat format,
+                                          NormalComponentCount elements, bool index3)
+  {
+    return s_table_size[type][index3][elements][format];
+  }
 
   static TPipelineFunction GetFunction(VertexComponentFormat type, ComponentFormat format,
                                        NormalComponentCount elements, bool index3);
+
+private:
+  template <typename T, auto last_member>
+  using EnumMap = typename Common::EnumMap<T, last_member>;
+
+  using SizeTable = EnumMap<
+      std::array<EnumMap<EnumMap<u32, ComponentFormat::Float>, NormalComponentCount::NTB>, 2>,
+      VertexComponentFormat::Index16>;
+
+  static constexpr SizeTable s_table_size = []() consteval
+  {
+    SizeTable table{};
+
+    using VCF = VertexComponentFormat;
+    using NCC = NormalComponentCount;
+    using FMT = ComponentFormat;
+
+    table[VCF::Direct][false][NCC::N][FMT::UByte] = 3;
+    table[VCF::Direct][false][NCC::N][FMT::Byte] = 3;
+    table[VCF::Direct][false][NCC::N][FMT::UShort] = 6;
+    table[VCF::Direct][false][NCC::N][FMT::Short] = 6;
+    table[VCF::Direct][false][NCC::N][FMT::Float] = 12;
+    table[VCF::Direct][false][NCC::NTB][FMT::UByte] = 9;
+    table[VCF::Direct][false][NCC::NTB][FMT::Byte] = 9;
+    table[VCF::Direct][false][NCC::NTB][FMT::UShort] = 18;
+    table[VCF::Direct][false][NCC::NTB][FMT::Short] = 18;
+    table[VCF::Direct][false][NCC::NTB][FMT::Float] = 36;
+
+    // Same as above, since there are no indices
+    table[VCF::Direct][true][NCC::N][FMT::UByte] = 3;
+    table[VCF::Direct][true][NCC::N][FMT::Byte] = 3;
+    table[VCF::Direct][true][NCC::N][FMT::UShort] = 6;
+    table[VCF::Direct][true][NCC::N][FMT::Short] = 6;
+    table[VCF::Direct][true][NCC::N][FMT::Float] = 12;
+    table[VCF::Direct][true][NCC::NTB][FMT::UByte] = 9;
+    table[VCF::Direct][true][NCC::NTB][FMT::Byte] = 9;
+    table[VCF::Direct][true][NCC::NTB][FMT::UShort] = 18;
+    table[VCF::Direct][true][NCC::NTB][FMT::Short] = 18;
+    table[VCF::Direct][true][NCC::NTB][FMT::Float] = 36;
+
+    table[VCF::Index8][false][NCC::N][FMT::UByte] = 1;
+    table[VCF::Index8][false][NCC::N][FMT::Byte] = 1;
+    table[VCF::Index8][false][NCC::N][FMT::UShort] = 1;
+    table[VCF::Index8][false][NCC::N][FMT::Short] = 1;
+    table[VCF::Index8][false][NCC::N][FMT::Float] = 1;
+    table[VCF::Index8][false][NCC::NTB][FMT::UByte] = 1;
+    table[VCF::Index8][false][NCC::NTB][FMT::Byte] = 1;
+    table[VCF::Index8][false][NCC::NTB][FMT::UShort] = 1;
+    table[VCF::Index8][false][NCC::NTB][FMT::Short] = 1;
+    table[VCF::Index8][false][NCC::NTB][FMT::Float] = 1;
+
+    // Same for NormalComponentCount::N; differs for NTB
+    table[VCF::Index8][true][NCC::N][FMT::UByte] = 1;
+    table[VCF::Index8][true][NCC::N][FMT::Byte] = 1;
+    table[VCF::Index8][true][NCC::N][FMT::UShort] = 1;
+    table[VCF::Index8][true][NCC::N][FMT::Short] = 1;
+    table[VCF::Index8][true][NCC::N][FMT::Float] = 1;
+    table[VCF::Index8][true][NCC::NTB][FMT::UByte] = 3;
+    table[VCF::Index8][true][NCC::NTB][FMT::Byte] = 3;
+    table[VCF::Index8][true][NCC::NTB][FMT::UShort] = 3;
+    table[VCF::Index8][true][NCC::NTB][FMT::Short] = 3;
+    table[VCF::Index8][true][NCC::NTB][FMT::Float] = 3;
+
+    table[VCF::Index16][false][NCC::N][FMT::UByte] = 2;
+    table[VCF::Index16][false][NCC::N][FMT::Byte] = 2;
+    table[VCF::Index16][false][NCC::N][FMT::UShort] = 2;
+    table[VCF::Index16][false][NCC::N][FMT::Short] = 2;
+    table[VCF::Index16][false][NCC::N][FMT::Float] = 2;
+    table[VCF::Index16][false][NCC::NTB][FMT::UByte] = 2;
+    table[VCF::Index16][false][NCC::NTB][FMT::Byte] = 2;
+    table[VCF::Index16][false][NCC::NTB][FMT::UShort] = 2;
+    table[VCF::Index16][false][NCC::NTB][FMT::Short] = 2;
+    table[VCF::Index16][false][NCC::NTB][FMT::Float] = 2;
+
+    // Same for NormalComponentCount::N; differs for NTB
+    table[VCF::Index16][true][NCC::N][FMT::UByte] = 2;
+    table[VCF::Index16][true][NCC::N][FMT::Byte] = 2;
+    table[VCF::Index16][true][NCC::N][FMT::UShort] = 2;
+    table[VCF::Index16][true][NCC::N][FMT::Short] = 2;
+    table[VCF::Index16][true][NCC::N][FMT::Float] = 2;
+    table[VCF::Index16][true][NCC::NTB][FMT::UByte] = 6;
+    table[VCF::Index16][true][NCC::NTB][FMT::Byte] = 6;
+    table[VCF::Index16][true][NCC::NTB][FMT::UShort] = 6;
+    table[VCF::Index16][true][NCC::NTB][FMT::Short] = 6;
+    table[VCF::Index16][true][NCC::NTB][FMT::Float] = 6;
+
+    return table;
+  }
+  ();
 };
diff --git a/Source/Core/VideoCommon/VertexLoader_Position.cpp b/Source/Core/VideoCommon/VertexLoader_Position.cpp
index 15d2f6d94e..a568518798 100644
--- a/Source/Core/VideoCommon/VertexLoader_Position.cpp
+++ b/Source/Core/VideoCommon/VertexLoader_Position.cpp
@@ -138,45 +138,8 @@ constexpr Table<TPipelineFunction> s_table_read_position = {
         e(Pos_ReadIndex<u16, float, 2>, Pos_ReadIndex<u16, float, 3>),
     }),
 };
-
-constexpr Table<u32> s_table_read_position_vertex_size = {
-    g({
-        e(0u, 0u),
-        e(0u, 0u),
-        e(0u, 0u),
-        e(0u, 0u),
-        e(0u, 0u),
-    }),
-    g({
-        e(2, 3),
-        e(2, 3),
-        e(4, 6),
-        e(4, 6),
-        e(8, 12),
-    }),
-    g({
-        e(1, 1),
-        e(1, 1),
-        e(1, 1),
-        e(1, 1),
-        e(1, 1),
-    }),
-    g({
-        e(2, 2),
-        e(2, 2),
-        e(2, 2),
-        e(2, 2),
-        e(2, 2),
-    }),
-};
 }  // Anonymous namespace
 
-u32 VertexLoader_Position::GetSize(VertexComponentFormat type, ComponentFormat format,
-                                   CoordComponentCount elements)
-{
-  return s_table_read_position_vertex_size[type][format][elements];
-}
-
 TPipelineFunction VertexLoader_Position::GetFunction(VertexComponentFormat type,
                                                      ComponentFormat format,
                                                      CoordComponentCount elements)
diff --git a/Source/Core/VideoCommon/VertexLoader_Position.h b/Source/Core/VideoCommon/VertexLoader_Position.h
index 59bfe99da4..da095419fd 100644
--- a/Source/Core/VideoCommon/VertexLoader_Position.h
+++ b/Source/Core/VideoCommon/VertexLoader_Position.h
@@ -4,18 +4,57 @@
 #pragma once
 
 #include "Common/CommonTypes.h"
-#include "VideoCommon/VertexLoader.h"
+#include "Common/EnumMap.h"
+#include "Common/Inline.h"
 
-enum class VertexComponentFormat;
-enum class ComponentFormat;
-enum class CoordComponentCount;
+#include "VideoCommon/CPMemory.h"
+#include "VideoCommon/VertexLoader.h"
 
 class VertexLoader_Position
 {
 public:
-  static u32 GetSize(VertexComponentFormat type, ComponentFormat format,
-                     CoordComponentCount elements);
+  static DOLPHIN_FORCE_INLINE u32 GetSize(VertexComponentFormat type, ComponentFormat format,
+                                          CoordComponentCount elements)
+  {
+    return s_table_size[type][format][elements];
+  }
 
   static TPipelineFunction GetFunction(VertexComponentFormat type, ComponentFormat format,
                                        CoordComponentCount elements);
+
+private:
+  template <typename T, auto last_member>
+  using EnumMap = typename Common::EnumMap<T, last_member>;
+
+  using SizeTable = EnumMap<EnumMap<EnumMap<u32, CoordComponentCount::XYZ>, ComponentFormat::Float>,
+                            VertexComponentFormat::Index16>;
+
+  static constexpr SizeTable s_table_size = []() consteval
+  {
+    SizeTable table{};
+
+    using VCF = VertexComponentFormat;
+    using FMT = ComponentFormat;
+
+    table[VCF::Direct][FMT::UByte] = {2, 3};
+    table[VCF::Direct][FMT::Byte] = {2, 3};
+    table[VCF::Direct][FMT::UShort] = {4, 6};
+    table[VCF::Direct][FMT::Short] = {4, 6};
+    table[VCF::Direct][FMT::Float] = {8, 12};
+
+    table[VCF::Index8][FMT::UByte] = {1, 1};
+    table[VCF::Index8][FMT::Byte] = {1, 1};
+    table[VCF::Index8][FMT::UShort] = {1, 1};
+    table[VCF::Index8][FMT::Short] = {1, 1};
+    table[VCF::Index8][FMT::Float] = {1, 1};
+
+    table[VCF::Index16][FMT::UByte] = {2, 2};
+    table[VCF::Index16][FMT::Byte] = {2, 2};
+    table[VCF::Index16][FMT::UShort] = {2, 2};
+    table[VCF::Index16][FMT::Short] = {2, 2};
+    table[VCF::Index16][FMT::Float] = {2, 2};
+
+    return table;
+  }
+  ();
 };
diff --git a/Source/Core/VideoCommon/VertexLoader_TextCoord.cpp b/Source/Core/VideoCommon/VertexLoader_TextCoord.cpp
index 89891df5a8..8b2bbf5560 100644
--- a/Source/Core/VideoCommon/VertexLoader_TextCoord.cpp
+++ b/Source/Core/VideoCommon/VertexLoader_TextCoord.cpp
@@ -127,45 +127,8 @@ constexpr Table<TPipelineFunction> s_table_read_tex_coord = {
         e(TexCoord_ReadIndex<u16, float, 1>, TexCoord_ReadIndex<u16, float, 2>),
     }),
 };
-
-constexpr Table<u32> s_table_read_tex_coord_vertex_size = {
-    g({
-        e(0u, 0u),
-        e(0u, 0u),
-        e(0u, 0u),
-        e(0u, 0u),
-        e(0u, 0u),
-    }),
-    g({
-        e(1, 2),
-        e(1, 2),
-        e(2, 4),
-        e(2, 4),
-        e(4, 8),
-    }),
-    g({
-        e(1, 1),
-        e(1, 1),
-        e(1, 1),
-        e(1, 1),
-        e(1, 1),
-    }),
-    g({
-        e(2, 2),
-        e(2, 2),
-        e(2, 2),
-        e(2, 2),
-        e(2, 2),
-    }),
-};
 }  // Anonymous namespace
 
-u32 VertexLoader_TextCoord::GetSize(VertexComponentFormat type, ComponentFormat format,
-                                    TexComponentCount elements)
-{
-  return s_table_read_tex_coord_vertex_size[type][format][elements];
-}
-
 TPipelineFunction VertexLoader_TextCoord::GetFunction(VertexComponentFormat type,
                                                       ComponentFormat format,
                                                       TexComponentCount elements)
diff --git a/Source/Core/VideoCommon/VertexLoader_TextCoord.h b/Source/Core/VideoCommon/VertexLoader_TextCoord.h
index e2dac72021..9041185490 100644
--- a/Source/Core/VideoCommon/VertexLoader_TextCoord.h
+++ b/Source/Core/VideoCommon/VertexLoader_TextCoord.h
@@ -4,21 +4,60 @@
 #pragma once
 
 #include "Common/CommonTypes.h"
-#include "VideoCommon/VertexLoader.h"
+#include "Common/EnumMap.h"
+#include "Common/Inline.h"
 
-enum class VertexComponentFormat;
-enum class ComponentFormat;
-enum class TexComponentCount;
+#include "VideoCommon/CPMemory.h"
+#include "VideoCommon/VertexLoader.h"
 
 class VertexLoader_TextCoord
 {
 public:
-  static u32 GetSize(VertexComponentFormat type, ComponentFormat format,
-                     TexComponentCount elements);
+  static DOLPHIN_FORCE_INLINE u32 GetSize(VertexComponentFormat type, ComponentFormat format,
+                                          TexComponentCount elements)
+  {
+    return s_table_size[type][format][elements];
+  }
 
   static TPipelineFunction GetFunction(VertexComponentFormat type, ComponentFormat format,
                                        TexComponentCount elements);
 
   // It is important to synchronize tcIndex.
   static TPipelineFunction GetDummyFunction();
+
+private:
+  template <typename T, auto last_member>
+  using EnumMap = typename Common::EnumMap<T, last_member>;
+
+  using SizeTable = EnumMap<EnumMap<EnumMap<u32, TexComponentCount::ST>, ComponentFormat::Float>,
+                            VertexComponentFormat::Index16>;
+
+  static constexpr SizeTable s_table_size = []() consteval
+  {
+    SizeTable table{};
+
+    using VCF = VertexComponentFormat;
+    using FMT = ComponentFormat;
+
+    table[VCF::Direct][FMT::UByte] = {1, 2};
+    table[VCF::Direct][FMT::Byte] = {1, 2};
+    table[VCF::Direct][FMT::UShort] = {2, 4};
+    table[VCF::Direct][FMT::Short] = {2, 4};
+    table[VCF::Direct][FMT::Float] = {4, 8};
+
+    table[VCF::Index8][FMT::UByte] = {1, 1};
+    table[VCF::Index8][FMT::Byte] = {1, 1};
+    table[VCF::Index8][FMT::UShort] = {1, 1};
+    table[VCF::Index8][FMT::Short] = {1, 1};
+    table[VCF::Index8][FMT::Float] = {1, 1};
+
+    table[VCF::Index16][FMT::UByte] = {2, 2};
+    table[VCF::Index16][FMT::Byte] = {2, 2};
+    table[VCF::Index16][FMT::UShort] = {2, 2};
+    table[VCF::Index16][FMT::Short] = {2, 2};
+    table[VCF::Index16][FMT::Float] = {2, 2};
+
+    return table;
+  }
+  ();
 };
diff --git a/Source/Core/VideoCommon/VertexShaderManager.cpp b/Source/Core/VideoCommon/VertexShaderManager.cpp
index ce43235977..b74c820271 100644
--- a/Source/Core/VideoCommon/VertexShaderManager.cpp
+++ b/Source/Core/VideoCommon/VertexShaderManager.cpp
@@ -606,13 +606,42 @@ void VertexShaderManager::SetMaterialColorChanged(int index)
   nMaterialsChanged[index] = true;
 }
 
-void VertexShaderManager::SetVertexFormat(u32 components)
+static void UpdateValue(bool* dirty, u32* old_value, u32 new_value)
 {
-  if (components != constants.components)
-  {
-    constants.components = components;
-    dirty = true;
-  }
+  if (*old_value == new_value)
+    return;
+  *old_value = new_value;
+  *dirty = true;
+}
+
+static void UpdateOffset(bool* dirty, bool include_components, u32* old_value,
+                         const AttributeFormat& attribute)
+{
+  if (!attribute.enable)
+    return;
+  u32 new_value = attribute.offset / 4;  // GPU uses uint offsets
+  if (include_components)
+    new_value |= attribute.components << 16;
+  UpdateValue(dirty, old_value, new_value);
+}
+
+template <size_t N>
+static void UpdateOffsets(bool* dirty, bool include_components, std::array<u32, N>* old_value,
+                          const std::array<AttributeFormat, N>& attribute)
+{
+  for (size_t i = 0; i < N; i++)
+    UpdateOffset(dirty, include_components, &(*old_value)[i], attribute[i]);
+}
+
+void VertexShaderManager::SetVertexFormat(u32 components, const PortableVertexDeclaration& format)
+{
+  UpdateValue(&dirty, &constants.components, components);
+  UpdateValue(&dirty, &constants.vertex_stride, format.stride / 4);
+  UpdateOffset(&dirty, true, &constants.vertex_offset_position, format.position);
+  UpdateOffset(&dirty, false, &constants.vertex_offset_posmtx, format.posmtx);
+  UpdateOffsets(&dirty, true, &constants.vertex_offset_texcoords, format.texcoords);
+  UpdateOffsets(&dirty, false, &constants.vertex_offset_colors, format.colors);
+  UpdateOffsets(&dirty, false, &constants.vertex_offset_normals, format.normals);
 }
 
 void VertexShaderManager::SetTexMatrixInfoChanged(int index)
diff --git a/Source/Core/VideoCommon/VertexShaderManager.h b/Source/Core/VideoCommon/VertexShaderManager.h
index 3bddf28fb0..2a8aa7b596 100644
--- a/Source/Core/VideoCommon/VertexShaderManager.h
+++ b/Source/Core/VideoCommon/VertexShaderManager.h
@@ -10,6 +10,7 @@
 #include "VideoCommon/ConstantManager.h"
 
 class PointerWrap;
+struct PortableVertexDeclaration;
 
 // The non-API dependent parts.
 class VertexShaderManager
@@ -29,7 +30,7 @@ public:
   static void SetProjectionChanged();
   static void SetMaterialColorChanged(int index);
 
-  static void SetVertexFormat(u32 components);
+  static void SetVertexFormat(u32 components, const PortableVertexDeclaration& format);
   static void SetTexMatrixInfoChanged(int index);
   static void SetLightingConfigChanged();
 
diff --git a/Source/Core/VideoCommon/VideoBackendBase.cpp b/Source/Core/VideoCommon/VideoBackendBase.cpp
index da100732f9..4c2cd704fb 100644
--- a/Source/Core/VideoCommon/VideoBackendBase.cpp
+++ b/Source/Core/VideoCommon/VideoBackendBase.cpp
@@ -226,11 +226,13 @@ const std::vector<std::unique_ptr<VideoBackendBase>>& VideoBackendBase::GetAvail
     backends.push_back(std::make_unique<DX11::VideoBackend>());
     backends.push_back(std::make_unique<DX12::VideoBackend>());
 #endif
+#ifdef __APPLE__
+    backends.push_back(std::make_unique<Metal::VideoBackend>());
+#endif
 #ifdef HAS_VULKAN
 #ifdef __APPLE__
     // Emplace the Vulkan backend at the beginning so it takes precedence over OpenGL.
     backends.emplace(backends.begin(), std::make_unique<Vulkan::VideoBackend>());
-    backends.push_back(std::make_unique<Metal::VideoBackend>());
 #else
     backends.push_back(std::make_unique<Vulkan::VideoBackend>());
 #endif
diff --git a/Source/Core/VideoCommon/VideoConfig.h b/Source/Core/VideoCommon/VideoConfig.h
index 22817d1f61..105840bafa 100644
--- a/Source/Core/VideoCommon/VideoConfig.h
+++ b/Source/Core/VideoCommon/VideoConfig.h
@@ -232,6 +232,7 @@ struct VideoConfig final
     bool bSupportsLodBiasInSampler = false;
     bool bSupportsSettingObjectNames = false;
     bool bSupportsPartialMultisampleResolve = false;
+    bool bSupportsDynamicVertexLoader = false;
   } backend_info;
 
   // Utility
diff --git a/Source/UnitTests/VideoCommon/VertexLoaderTest.cpp b/Source/UnitTests/VideoCommon/VertexLoaderTest.cpp
index b12dad1661..5e3898ed28 100644
--- a/Source/UnitTests/VideoCommon/VertexLoaderTest.cpp
+++ b/Source/UnitTests/VideoCommon/VertexLoaderTest.cpp
@@ -366,3 +366,413 @@ TEST_F(VertexLoaderTest, LargeFloatVertexSpeed)
   for (int i = 0; i < 100; ++i)
     RunVertices(100000);
 }
+
+TEST_F(VertexLoaderTest, DirectAllComponents)
+{
+  m_vtx_desc.low.PosMatIdx = 1;
+  m_vtx_desc.low.Tex0MatIdx = 1;
+  m_vtx_desc.low.Tex1MatIdx = 1;
+  m_vtx_desc.low.Tex2MatIdx = 1;
+  m_vtx_desc.low.Tex3MatIdx = 1;
+  m_vtx_desc.low.Tex4MatIdx = 1;
+  m_vtx_desc.low.Tex5MatIdx = 1;
+  m_vtx_desc.low.Tex6MatIdx = 1;
+  m_vtx_desc.low.Tex7MatIdx = 1;
+  m_vtx_desc.low.Position = VertexComponentFormat::Direct;
+  m_vtx_desc.low.Normal = VertexComponentFormat::Direct;
+  m_vtx_desc.low.Color0 = VertexComponentFormat::Direct;
+  m_vtx_desc.low.Color1 = VertexComponentFormat::Direct;
+  m_vtx_desc.high.Tex0Coord = VertexComponentFormat::Direct;
+  m_vtx_desc.high.Tex1Coord = VertexComponentFormat::Direct;
+  m_vtx_desc.high.Tex2Coord = VertexComponentFormat::Direct;
+  m_vtx_desc.high.Tex3Coord = VertexComponentFormat::Direct;
+  m_vtx_desc.high.Tex4Coord = VertexComponentFormat::Direct;
+  m_vtx_desc.high.Tex5Coord = VertexComponentFormat::Direct;
+  m_vtx_desc.high.Tex6Coord = VertexComponentFormat::Direct;
+  m_vtx_desc.high.Tex7Coord = VertexComponentFormat::Direct;
+
+  m_vtx_attr.g0.PosElements = CoordComponentCount::XYZ;
+  m_vtx_attr.g0.PosFormat = ComponentFormat::Float;
+  m_vtx_attr.g0.NormalElements = NormalComponentCount::NTB;
+  m_vtx_attr.g0.NormalFormat = ComponentFormat::Float;
+  m_vtx_attr.g0.Color0Elements = ColorComponentCount::RGBA;
+  m_vtx_attr.g0.Color0Comp = ColorFormat::RGBA8888;
+  m_vtx_attr.g0.Color1Elements = ColorComponentCount::RGBA;
+  m_vtx_attr.g0.Color1Comp = ColorFormat::RGBA8888;
+  m_vtx_attr.g0.Tex0CoordElements = TexComponentCount::ST;
+  m_vtx_attr.g0.Tex0CoordFormat = ComponentFormat::Float;
+  m_vtx_attr.g1.Tex1CoordElements = TexComponentCount::ST;
+  m_vtx_attr.g1.Tex1CoordFormat = ComponentFormat::Float;
+  m_vtx_attr.g1.Tex2CoordElements = TexComponentCount::ST;
+  m_vtx_attr.g1.Tex2CoordFormat = ComponentFormat::Float;
+  m_vtx_attr.g1.Tex3CoordElements = TexComponentCount::ST;
+  m_vtx_attr.g1.Tex3CoordFormat = ComponentFormat::Float;
+  m_vtx_attr.g1.Tex4CoordElements = TexComponentCount::ST;
+  m_vtx_attr.g1.Tex4CoordFormat = ComponentFormat::Float;
+  m_vtx_attr.g2.Tex5CoordElements = TexComponentCount::ST;
+  m_vtx_attr.g2.Tex5CoordFormat = ComponentFormat::Float;
+  m_vtx_attr.g2.Tex6CoordElements = TexComponentCount::ST;
+  m_vtx_attr.g2.Tex6CoordFormat = ComponentFormat::Float;
+  m_vtx_attr.g2.Tex7CoordElements = TexComponentCount::ST;
+  m_vtx_attr.g2.Tex7CoordFormat = ComponentFormat::Float;
+
+  CreateAndCheckSizes(129, 39 * sizeof(float));
+
+  // Pos matrix idx
+  Input<u8>(20);
+  // Tex matrix idx
+  Input<u8>(0);
+  Input<u8>(1);
+  Input<u8>(2);
+  Input<u8>(3);
+  Input<u8>(4);
+  Input<u8>(5);
+  Input<u8>(6);
+  Input<u8>(7);
+  // Position
+  Input(-1.0f);
+  Input(-2.0f);
+  Input(-3.0f);
+  // Normal
+  Input(-4.0f);
+  Input(-5.0f);
+  Input(-6.0f);
+  // Tangent
+  Input(-7.0f);
+  Input(-8.0f);
+  Input(-9.0f);
+  // Binormal
+  Input(-10.0f);
+  Input(-11.0f);
+  Input(-12.0f);
+  // Colors
+  Input<u32>(0x01234567);
+  Input<u32>(0x89abcdef);
+  // Texture coordinates
+  Input(0.1f);
+  Input(-0.9f);
+  Input(1.1f);
+  Input(-1.9f);
+  Input(2.1f);
+  Input(-2.9f);
+  Input(3.1f);
+  Input(-3.9f);
+  Input(4.1f);
+  Input(-4.9f);
+  Input(5.1f);
+  Input(-5.9f);
+  Input(6.1f);
+  Input(-6.9f);
+  Input(7.1f);
+  Input(-7.9f);
+
+  RunVertices(1);
+
+  // Position matrix
+  ASSERT_EQ(m_loader->m_native_vtx_decl.posmtx.offset, 0 * sizeof(float));
+  EXPECT_EQ((m_dst.Read<u32, false>()), 20u);
+  // Position
+  ASSERT_EQ(m_loader->m_native_vtx_decl.position.offset, 1 * sizeof(float));
+  ExpectOut(-1.0f);
+  ExpectOut(-2.0f);
+  ExpectOut(-3.0f);
+  // Normal
+  ASSERT_EQ(m_loader->m_native_vtx_decl.normals[0].offset, 4 * sizeof(float));
+  ExpectOut(-4.0f);
+  ExpectOut(-5.0f);
+  ExpectOut(-6.0f);
+  // Tangent
+  ASSERT_EQ(m_loader->m_native_vtx_decl.normals[1].offset, 7 * sizeof(float));
+  ExpectOut(-7.0f);
+  ExpectOut(-8.0f);
+  ExpectOut(-9.0f);
+  // Binormal
+  ASSERT_EQ(m_loader->m_native_vtx_decl.normals[2].offset, 10 * sizeof(float));
+  ExpectOut(-10.0f);
+  ExpectOut(-11.0f);
+  ExpectOut(-12.0f);
+  // Colors
+  ASSERT_EQ(m_loader->m_native_vtx_decl.colors[0].offset, 13 * sizeof(float));
+  EXPECT_EQ((m_dst.Read<u32, true>()), 0x01234567u);
+  ASSERT_EQ(m_loader->m_native_vtx_decl.colors[1].offset, 14 * sizeof(float));
+  EXPECT_EQ((m_dst.Read<u32, true>()), 0x89abcdefu);
+  // Texture coordinates and matrices (interleaved)
+  ASSERT_EQ(m_loader->m_native_vtx_decl.texcoords[0].offset, 15 * sizeof(float));
+  ExpectOut(0.1f);   // S
+  ExpectOut(-0.9f);  // T
+  ExpectOut(0.0f);   // matrix (yes, a float)
+  ASSERT_EQ(m_loader->m_native_vtx_decl.texcoords[1].offset, 18 * sizeof(float));
+  ExpectOut(1.1f);
+  ExpectOut(-1.9f);
+  ExpectOut(1.0f);
+  ASSERT_EQ(m_loader->m_native_vtx_decl.texcoords[2].offset, 21 * sizeof(float));
+  ExpectOut(2.1f);
+  ExpectOut(-2.9f);
+  ExpectOut(2.0f);
+  ASSERT_EQ(m_loader->m_native_vtx_decl.texcoords[3].offset, 24 * sizeof(float));
+  ExpectOut(3.1f);
+  ExpectOut(-3.9f);
+  ExpectOut(3.0f);
+  ASSERT_EQ(m_loader->m_native_vtx_decl.texcoords[4].offset, 27 * sizeof(float));
+  ExpectOut(4.1f);
+  ExpectOut(-4.9f);
+  ExpectOut(4.0f);
+  ASSERT_EQ(m_loader->m_native_vtx_decl.texcoords[5].offset, 30 * sizeof(float));
+  ExpectOut(5.1f);
+  ExpectOut(-5.9f);
+  ExpectOut(5.0f);
+  ASSERT_EQ(m_loader->m_native_vtx_decl.texcoords[6].offset, 33 * sizeof(float));
+  ExpectOut(6.1f);
+  ExpectOut(-6.9f);
+  ExpectOut(6.0f);
+  ASSERT_EQ(m_loader->m_native_vtx_decl.texcoords[7].offset, 36 * sizeof(float));
+  ExpectOut(7.1f);
+  ExpectOut(-7.9f);
+  ExpectOut(7.0f);
+}
+
+class VertexLoaderNormalTest
+    : public VertexLoaderTest,
+      public ::testing::WithParamInterface<
+          std::tuple<VertexComponentFormat, ComponentFormat, NormalComponentCount, bool>>
+{
+};
+INSTANTIATE_TEST_CASE_P(
+    AllCombinations, VertexLoaderNormalTest,
+    ::testing::Combine(
+        ::testing::Values(VertexComponentFormat::NotPresent, VertexComponentFormat::Direct,
+                          VertexComponentFormat::Index8, VertexComponentFormat::Index16),
+        ::testing::Values(ComponentFormat::UByte, ComponentFormat::Byte, ComponentFormat::UShort,
+                          ComponentFormat::Short, ComponentFormat::Float),
+        ::testing::Values(NormalComponentCount::N, NormalComponentCount::NTB),
+        ::testing::Values(false, true)));
+
+TEST_P(VertexLoaderNormalTest, NormalAll)
+{
+  VertexComponentFormat addr;
+  ComponentFormat format;
+  NormalComponentCount elements;
+  bool index3;
+  std::tie(addr, format, elements, index3) = GetParam();
+
+  m_vtx_desc.low.Position = VertexComponentFormat::Direct;
+  m_vtx_attr.g0.PosFormat = ComponentFormat::Float;
+  m_vtx_attr.g0.PosElements = CoordComponentCount::XY;
+  m_vtx_attr.g0.PosFrac = 0;
+  m_vtx_desc.low.Normal = addr;
+  m_vtx_attr.g0.NormalFormat = format;
+  m_vtx_attr.g0.NormalElements = elements;
+  m_vtx_attr.g0.NormalIndex3 = index3;
+
+  const u32 in_size = [&]() -> u32 {
+    if (addr == VertexComponentFormat::NotPresent)
+      return 0;
+
+    if (IsIndexed(addr))
+    {
+      const u32 base_size = (addr == VertexComponentFormat::Index8) ? 1 : 2;
+      if (elements == NormalComponentCount::NTB)
+        return (index3 ? 3 : 1) * base_size;
+      else
+        return 1 * base_size;
+    }
+    else
+    {
+      const u32 base_count = (elements == NormalComponentCount::NTB) ? 9 : 3;
+      const u32 base_size = GetElementSize(format);
+      return base_count * base_size;
+    }
+  }();
+  const u32 out_size = [&]() -> u32 {
+    if (addr == VertexComponentFormat::NotPresent)
+      return 0;
+
+    const u32 base_count = (elements == NormalComponentCount::NTB) ? 9 : 3;
+    return base_count * sizeof(float);
+  }();
+
+  CreateAndCheckSizes(2 * sizeof(float) + in_size, 2 * sizeof(float) + out_size);
+
+  auto input_with_expected_type = [&](float value) {
+    switch (format)
+    {
+    case ComponentFormat::UByte:
+      Input<u8>(value * (1 << 7));
+      break;
+    case ComponentFormat::Byte:
+      Input<s8>(value * (1 << 6));
+      break;
+    case ComponentFormat::UShort:
+      Input<u16>(value * (1 << 15));
+      break;
+    case ComponentFormat::Short:
+      Input<s16>(value * (1 << 14));
+      break;
+    case ComponentFormat::Float:
+    default:
+      Input<float>(value);
+      break;
+    }
+  };
+
+  auto create_normal = [&](int counter_base) {
+    if (addr == VertexComponentFormat::Direct)
+    {
+      input_with_expected_type(counter_base / 32.f);
+      input_with_expected_type((counter_base + 1) / 32.f);
+      input_with_expected_type((counter_base + 2) / 32.f);
+    }
+    else if (addr == VertexComponentFormat::Index8)
+    {
+      // We set up arrays so that this works
+      Input<u8>(counter_base);
+    }
+    else if (addr == VertexComponentFormat::Index16)
+    {
+      Input<u16>(counter_base);
+    }
+    // Do nothing for NotPresent
+  };
+  auto create_tangent_and_binormal = [&](int counter_base) {
+    if (IsIndexed(addr))
+    {
+      // With NormalIndex3, specifying the same index 3 times should give the same result
+      // as specifying one index in non-index3 mode (as the index is biased by bytes).
+      // If index3 is disabled, we don't want to write any more indices.
+      if (index3)
+      {
+        // Tangent
+        create_normal(counter_base);
+        // Binormal
+        create_normal(counter_base);
+      }
+    }
+    else
+    {
+      // Tangent
+      create_normal(counter_base + 3);
+      // Binormal
+      create_normal(counter_base + 6);
+    }
+  };
+
+  // Create our two vertices
+  // Position 1
+  Input(4.0f);
+  Input(8.0f);
+  // Normal 1
+  create_normal(1);
+  if (elements == NormalComponentCount::NTB)
+  {
+    create_tangent_and_binormal(1);
+  }
+
+  // Position 2
+  Input(6.0f);
+  Input(12.0f);
+  // Normal 1
+  create_normal(10);
+  if (elements == NormalComponentCount::NTB)
+  {
+    create_tangent_and_binormal(10);
+  }
+
+  // Create an array for indexed representations
+  for (int i = 0; i < NUM_VERTEX_COMPONENT_ARRAYS; i++)
+  {
+    VertexLoaderManager::cached_arraybases[static_cast<CPArray>(i)] = m_src.GetPointer();
+    g_main_cp_state.array_strides[static_cast<CPArray>(i)] = GetElementSize(format);
+  }
+
+  for (int i = 0; i < 32; i++)
+    input_with_expected_type(i / 32.f);
+
+  // Pre-fill these values to detect if they're modified
+  VertexLoaderManager::binormal_cache = {42.f, 43.f, 44.f, 45.f};
+  VertexLoaderManager::tangent_cache = {46.f, 47.f, 48.f, 49.f};
+
+  RunVertices(2);
+
+  // First vertex, position
+  ExpectOut(4.0f);
+  ExpectOut(8.0f);
+  if (addr != VertexComponentFormat::NotPresent)
+  {
+    // Normal
+    ExpectOut(1 / 32.f);
+    ExpectOut(2 / 32.f);
+    ExpectOut(3 / 32.f);
+    if (elements == NormalComponentCount::NTB)
+    {
+      // Tangent
+      ExpectOut(4 / 32.f);
+      ExpectOut(5 / 32.f);
+      ExpectOut(6 / 32.f);
+      // Binormal
+      ExpectOut(7 / 32.f);
+      ExpectOut(8 / 32.f);
+      ExpectOut(9 / 32.f);
+    }
+  }
+
+  // Second vertex, position
+  ExpectOut(6.0f);
+  ExpectOut(12.0f);
+  if (addr != VertexComponentFormat::NotPresent)
+  {
+    // Normal
+    ExpectOut(10 / 32.f);
+    ExpectOut(11 / 32.f);
+    ExpectOut(12 / 32.f);
+    if (elements == NormalComponentCount::NTB)
+    {
+      // Tangent
+      ExpectOut(13 / 32.f);
+      ExpectOut(14 / 32.f);
+      ExpectOut(15 / 32.f);
+      // Binormal
+      ExpectOut(16 / 32.f);
+      ExpectOut(17 / 32.f);
+      ExpectOut(18 / 32.f);
+
+      EXPECT_EQ(VertexLoaderManager::tangent_cache[0], 13 / 32.f);
+      EXPECT_EQ(VertexLoaderManager::tangent_cache[1], 14 / 32.f);
+      EXPECT_EQ(VertexLoaderManager::tangent_cache[2], 15 / 32.f);
+      // Last index is padding/junk
+      EXPECT_EQ(VertexLoaderManager::binormal_cache[0], 16 / 32.f);
+      EXPECT_EQ(VertexLoaderManager::binormal_cache[1], 17 / 32.f);
+      EXPECT_EQ(VertexLoaderManager::binormal_cache[2], 18 / 32.f);
+    }
+  }
+
+  if (addr == VertexComponentFormat::NotPresent || elements == NormalComponentCount::N)
+  {
+    // Expect these to not be written
+    EXPECT_EQ(VertexLoaderManager::binormal_cache[0], 42.f);
+    EXPECT_EQ(VertexLoaderManager::binormal_cache[1], 43.f);
+    EXPECT_EQ(VertexLoaderManager::binormal_cache[2], 44.f);
+    EXPECT_EQ(VertexLoaderManager::binormal_cache[3], 45.f);
+    EXPECT_EQ(VertexLoaderManager::tangent_cache[0], 46.f);
+    EXPECT_EQ(VertexLoaderManager::tangent_cache[1], 47.f);
+    EXPECT_EQ(VertexLoaderManager::tangent_cache[2], 48.f);
+    EXPECT_EQ(VertexLoaderManager::tangent_cache[3], 49.f);
+  }
+}
+
+// For gtest, which doesn't know about our fmt::formatters by default
+static void PrintTo(const VertexComponentFormat& t, std::ostream* os)
+{
+  *os << fmt::to_string(t);
+}
+static void PrintTo(const ComponentFormat& t, std::ostream* os)
+{
+  *os << fmt::to_string(t);
+}
+static void PrintTo(const CoordComponentCount& t, std::ostream* os)
+{
+  *os << fmt::to_string(t);
+}
+static void PrintTo(const NormalComponentCount& t, std::ostream* os)
+{
+  *os << fmt::to_string(t);
+}
diff --git a/Source/VSProps/Base.Dolphin.props b/Source/VSProps/Base.Dolphin.props
index 7f5c2a83d4..43af6653a1 100644
--- a/Source/VSProps/Base.Dolphin.props
+++ b/Source/VSProps/Base.Dolphin.props
@@ -42,8 +42,9 @@
       <PreprocessorDefinitions Condition="'$(Platform)'=='x64'">HAS_OPENGL;%(PreprocessorDefinitions)</PreprocessorDefinitions>
       <PreprocessorDefinitions>HAS_VULKAN;%(PreprocessorDefinitions)</PreprocessorDefinitions>
       <PreprocessorDefinitions>HAS_LIBMGBA;%(PreprocessorDefinitions)</PreprocessorDefinitions>
-      <PreprocessorDefinitions>AUTOUPDATE;%(PreprocessorDefinitions)</PreprocessorDefinitions>
+      <PreprocessorDefinitions Condition="'$(AutoUpdate)'!='false'">AUTOUPDATE;%(PreprocessorDefinitions)</PreprocessorDefinitions>
       <PreprocessorDefinitions>HAVE_SDL2;%(PreprocessorDefinitions)</PreprocessorDefinitions>
+      <PreprocessorDefinitions Condition="'$(Steam)'=='true'">STEAM;%(PreprocessorDefinitions)</PreprocessorDefinitions>
 
       <!-- Warnings one may want to ignore when using Level4.
       4201  nonstandard extension used : nameless struct/union