Revert

cpmfile.json

@@ -333,11 +333,6 @@
         "repo": "herumi/xbyak",
         "version": "v7.40.1"
     },
-    "zbic": {
-        "hash": "fbe2f37986377d7f0d96ae3224c80b5971df6e8b6961f68061f1975ebb2e8cb78f07b90f014b007be4023dbf5513581504e7f7d61a5237cb2a8a7a61ae11e482",
-        "repo": "kinnay/zbic",
-        "version": "11b08f2712264bbed731545085cbd9702096ceb7"
-    },
     "zlib": {
         "hash": "16fea4df307a68cf0035858abe2fd550250618a97590e202037acd18a666f57afc10f8836cbbd472d54a0e76539d0e558cb26f059d53de52ff90634bbf4f47d4",
         "min_version": "1.2",

docs/user/CommandLine.md

@@ -1,44 +1,32 @@
 # User Handbook - Command Line
 
-There are two main applications, an SDL-based app (`eden-cli`) and a Qt based app (`eden`); both accept the same command line arguments.
+There are two main applications, an SDL-based app (`eden-cli`) and a Qt based app (`eden`); both accept command line arguments.
+
+## eden
 
 - `./eden <path>`: Running with a single argument and nothing else, will make the emulator look for the given file and load it, this behavior is similar to `eden-cli`; allows dragging and dropping games into the application.
-- `--debug/-d`: Enter debug mode, allow gdb stub at port `1234`
-- `--config/-c`: Specify alternate configuration file.
-- `--fullscreen/-f`: Use fullscreen.
-- `--help/-h`: Display help.
-- `--game/-g <path>`: Alternate way to specify what to load, overrides. However let it be noted that arguments that use `-` will be treated as options/ignored, if your game, for some reason, starts with `-`, in order to safely handle it you may need to specify it as an argument.
-- `--multiplayer/-m`: Specify multiplayer options.
-- `--program/-p`: Specify the program arguments to pass (optional).
-- `--user/-u <number>`: Specify the user index.
-- `--version/-v`: Display version and quit.
-- `--input-profile/-i <name>`: Specifies input profile name to use (for player #0 only).
-- `--null-render/-n`: Forces the usage of the "Null" render backend irrespective of settings.
-- `--filter/-x`: Sets the debug log filter irrespective of settings.
-- `--singlecore/-s`: Forces single-core regardless of settings.
-
-Only the Qt frontend supports the following arguments:
-
+- `-g <path>`: Alternate way to specify what to load, overrides. However let it be noted that arguments that use `-` will be treated as options/ignored, if your game, for some reason, starts with `-`, in order to safely handle it you may need to specify it as an argument.
+- `-f`: Use fullscreen.
+- `-u <number>`: Select the index of the user to load as.
+- `-input-profile <name>`: Specifies input profile name to use (for player #0 only).
 - `-qlaunch`: Launch QLaunch.
 - `-hlaunch`: Launch homebrew launcher `nx-hbloader`.
     - Requires a copy of Atmosphere to be extracted onto `sdmc`.
     - This is a shorthand for `<eden folder>/sdmc/atmosphere/hbl.nsp`.
 - `-setup`: Launch setup applet.
 
-`eden` (provided with `--room`), and `eden-room` supports the following options as well:
+## eden-cli
 
-- `-n/--room-name`: The name of the room.
-- `-d/--room-description`: The room description.
-- `-s/--bind-address`: The bind address for the room.
-- `-p/--port`: The port used for the room.
-- `-m/--max-members`: The maximum number of players for this room.
-- `-w/--password`: The password for the room.
-- `-g/--preferred-game`: The preferred game for this room.
-- `-i/--preferred-game-id`: The preferred game-id for this room.
-- `-u/--username`: The username used for announce.
-- `-t/--token`: The token used for announce.
-- `-a/--web-api-url`: yuzu Web API url.
-- `-b/--ban-list-file`: The file for storing the room ban list.
-- `-l/--log-file`: The file for storing the room log.
-- `-h/--help`: Display this help and exit.
-- `-v/--version`: Output version information and exit.
+- `--debug/-d`: Enter debug mode, allow gdb stub at port `1234`
+- `--config/-c`: Specify alternate configuration file.
+- `--fullscreen/-f`: Set fullscreen.
+- `--help/-h`: Display help.
+- `--game/-g`: Specify the game to run.
+- `--multiplayer/-m`: Specify multiplayer options.
+- `--program/-p`: Specify the program arguments to pass (optional).
+- `--user/-u`: Specify the user index.
+- `--version/-v`: Display version and quit.
+- `--input-profile/-i`: Specifies input profile name to use (for player #0 only).
+- `--null-render/-n`: Forces the usage of the "Null" render backend irrespective of settings.
+- `--filter/-x`: Sets the debug log filter irrespective of settings.
+- `--singlecore/-s`: Forces single-core regardless of settings.

externals/CMakeLists.txt

@@ -48,11 +48,6 @@ if (NOT TARGET stb::headers)
     add_library(stb::headers ALIAS stb)
 endif()
 
-AddJsonPackage(NAME zbic DOWNLOAD_ONLY)
-set(ZBIC_INCLUDE_DIR
-    "${zbic_SOURCE_DIR}/src"
-    PARENT_SCOPE)
-
 # ItaniumDemangle (Windows only)
 if (WIN32 AND NOT TARGET LLVM::Demangle)
     add_library(demangle demangle/ItaniumDemangle.cpp)

src/android/app/src/main/java/org/yuzu/yuzu_emu/features/settings/model/BooleanSetting.kt

@@ -30,6 +30,7 @@ enum class BooleanSetting(override val key: String) : AbstractBooleanSetting {
     RENDERER_REACTIVE_FLUSHING("use_reactive_flushing"),
     ENABLE_BUFFER_HISTORY("enable_buffer_history"),
     USE_OPTIMIZED_VERTEX_BUFFERS("use_optimized_vertex_buffers"),
+    ENABLE_GPU_BUFFER_READBACK("enable_gpu_buffer_readback"),
     SYNC_MEMORY_OPERATIONS("sync_memory_operations"),
     BUFFER_REORDER_DISABLE("disable_buffer_reorder"),
     RENDERER_DEBUG("debug"),

src/android/app/src/main/java/org/yuzu/yuzu_emu/features/settings/model/view/SettingsItem.kt

@@ -908,6 +908,13 @@ abstract class SettingsItem(
                     descriptionId = R.string.enable_buffer_history_description
                 )
             )
+            put(
+                SwitchSetting(
+                    BooleanSetting.ENABLE_GPU_BUFFER_READBACK,
+                    titleId = R.string.enable_gpu_buffer_readback,
+                    descriptionId = R.string.enable_gpu_buffer_readback_description
+                )
+            )
             put(
                 SwitchSetting(
                     BooleanSetting.USE_OPTIMIZED_VERTEX_BUFFERS,

src/android/app/src/main/java/org/yuzu/yuzu_emu/features/settings/ui/SettingsFragmentPresenter.kt

@@ -549,6 +549,7 @@ class SettingsFragmentPresenter(
             add(BooleanSetting.RENDERER_FORCE_MAX_CLOCK.key)
             add(BooleanSetting.RENDERER_REACTIVE_FLUSHING.key)
             add(BooleanSetting.ENABLE_BUFFER_HISTORY.key)
+            add(BooleanSetting.ENABLE_GPU_BUFFER_READBACK.key)
             add(BooleanSetting.USE_OPTIMIZED_VERTEX_BUFFERS.key)
 
             add(HeaderSetting(R.string.hacks))

src/android/app/src/main/jni/native.cpp

@@ -788,7 +788,7 @@ int Java_org_yuzu_yuzu_1emu_NativeLibrary_installFileToNand(JNIEnv* env, jobject
 jboolean Java_org_yuzu_yuzu_1emu_NativeLibrary_doesUpdateMatchProgram(JNIEnv* env, jobject jobj,
                                                                       jstring jprogramId,
                                                                       jstring jupdatePath) {
-    const u64 program_id = FileSys::GetBaseTitleID(EmulationSession::GetProgramId(env, jprogramId));
+    u64 program_id = EmulationSession::GetProgramId(env, jprogramId);
     std::string updatePath = Common::Android::GetJString(env, jupdatePath);
     std::shared_ptr<FileSys::NSP> nsp = std::make_shared<FileSys::NSP>(
         EmulationSession::GetInstance().System().GetFilesystem()->OpenFile(
@@ -796,7 +796,7 @@ jboolean Java_org_yuzu_yuzu_1emu_NativeLibrary_doesUpdateMatchProgram(JNIEnv* en
     for (const auto& item : nsp->GetNCAs()) {
         for (const auto& nca_details : item.second) {
             if (nca_details.second->GetName().ends_with(".cnmt.nca")) {
-                const auto update_id = FileSys::GetBaseTitleID(nca_details.second->GetTitleId());
+                auto update_id = nca_details.second->GetTitleId() & ~0xFFFULL;
                 if (update_id == program_id) {
                     return true;
                 }

src/android/app/src/main/res/values-ar/strings.xml

@@ -580,6 +580,8 @@
     <string name="renderer_reactive_flushing_description">يحسن دقة العرض في بعض الألعاب على حساب الأداء.</string>
     <string name="enable_buffer_history">تمكين سجل التخزين المؤقت</string>
     <string name="enable_buffer_history_description">يُتيح هذا الخيار الوصول إلى حالات التخزين المؤقت السابقة. وقد يُحسّن جودة العرض وثبات الأداء في بعض الألعاب.</string>
+    <string name="enable_gpu_buffer_readback">تفعيل قراءة مخزن وحدة معالجة الرسومات</string>
+    <string name="enable_gpu_buffer_readback_description">يحافظ هذا النظام على بيانات المخزن المؤقت المُعدّلة بواسطة وحدة معالجة الرسومات عن طريق قراءتها مرة أخرى قبل التحميل. تتطلب بعض الألعاب ذلك لعرض بعض التأثيرات بشكل صحيح. قد يُسبب ذلك مشاكل إذا لم يتمكن الجهاز من التعامل مع عبء العمل الإضافي.</string>
     <string name="use_optimized_vertex_buffers">مخازن الرؤوس المُحسّنة</string>
     <string name="use_optimized_vertex_buffers_description">يُتيح ربطًا مُحسَّنًا لمخازن الرؤوس لتحسين الأداء. يتطلب برامج تشغيل Mesa 26.0+ Turnip/ برامج تشغيل QCOM. قد يتعطل على برامج تشغيل Turnip القديمة (25.3 وما دون).</string>
 
@@ -1097,6 +1099,7 @@
     <string name="gpu_fence_behavior_immediate">فوري</string>
     <string name="gpu_fence_behavior_balanced">متوازن</string>
     <string name="gpu_fence_behavior_accurate">دقيق</string>
+    <string name="gpu_fence_behavior_strict">صارم</string>
 
     <string name="vram_usage_conservative">محافظ</string>
     <string name="vram_usage_aggressive">عدواني</string>

src/android/app/src/main/res/values-de/strings.xml

@@ -967,6 +967,7 @@ Wirklich fortfahren?</string>
     <string name="gpu_fence_behavior_immediate">Direkt</string>
     <string name="gpu_fence_behavior_balanced">Ausgewogen</string>
     <string name="gpu_fence_behavior_accurate">Genau</string>
+    <string name="gpu_fence_behavior_strict">Strikt</string>
 
     <string name="vram_usage_conservative">Konservativ</string>
     <string name="vram_usage_aggressive">Aggressiv</string>

src/android/app/src/main/res/values-es/strings.xml

@@ -289,7 +289,6 @@
     <string name="gpu_driver_fetcher">Obtenedor de controladores de la GPU</string>
     <string name="gpu_driver_manager">Gestor de controladores de la GPU</string>
     <string name="install_gpu_driver_description">Instale los controladores alternativos para obtener un posible mejor rendimiento o precisión</string>
-    <string name="post_processing_add">Añadir efecto</string>
     <string name="post_processing_open_list">Abrir lista</string>
     <string name="post_processing_close_list">Cerrar lista</string>
     <string name="post_processing_reset">Restablecer a predeterminado</string>
@@ -524,6 +523,8 @@
     <string name="renderer_reactive_flushing_description">Mejora la precisión de renderizado en algunos juegos, pero reduce el rendimiento.</string>
     <string name="enable_buffer_history">Activar el historial del búfer</string>
     <string name="enable_buffer_history_description">Permite el acceso al estado del búfer anterior. Esta opción puede mejorar la calidad de renderizado y la consistencia en el rendimiento de algunos juegos.</string>
+    <string name="enable_gpu_buffer_readback">Activar la lectura del buffer de la GPU</string>
+    <string name="enable_gpu_buffer_readback_description">Conserva los datos del búfer modificados por la GPU leyéndolos antes de subirlos.\nAlgunos juegos requieren esto para renderizar correctamente ciertos efectos.\nPuede causar problemas si el hardware no puede soportar la carga de trabajo adicional.</string>
     <string name="use_optimized_vertex_buffers">Búferes de vértices optimizados</string>
     <string name="use_optimized_vertex_buffers_description">Permite la optimización del enlace del búfer de vértices para un mejor rendimiento. Requiere controladores Mesa 26.0+ Turnip/ controladores QCOM. Fallará con controladores Turnip más antiguos (versión 25.3 o inferior).</string>
 
@@ -1036,6 +1037,7 @@
     <string name="gpu_fence_behavior_immediate">Inmediato</string>
     <string name="gpu_fence_behavior_balanced">Equilibrado</string>
     <string name="gpu_fence_behavior_accurate">Preciso</string>
+    <string name="gpu_fence_behavior_strict">Estricto</string>
 
     <string name="vram_usage_conservative">Conservador</string>
     <string name="vram_usage_aggressive">Agresivo</string>

src/android/app/src/main/res/values-ru/strings.xml

@@ -318,13 +318,6 @@
     <string name="frame_gen_target_rate">Целевая частота кадров</string>
     <string name="frame_gen_target_rate_description">Выберите значение под ваш дисплей. Множитель подстроится сам, чтобы его держать, и откатит изменения, если игра начнёт тормозить.</string>
     <string name="frame_gen_target_rate_off">Использовать фиксированный множитель</string>
-    <string name="frame_gen_on">Вкл.</string>
-    <string name="frame_gen_off">Выкл.</string>
-    <string name="frame_gen_fixed">Фикс.</string>
-    <string name="frame_gen_flow_auto">Авто</string>
-    <string name="frame_gen_quick_description">Включите или выключите генерацию кадров и выберите множитель кадров.</string>
-    <string name="frame_gen_target_rate_quick_description">Генерация кадров с заданной частотой кадров. Множитель регулируется автоматически.</string>
-    <string name="frame_gen_flow_scale_quick_description">Разрешение, используемое для оценки движения между кадрами. Меньшие значения экономят время ГПУ.</string>
     <string name="frame_gen_queue_target">Целевой размер очереди кадров</string>
     <string name="frame_gen_queue_target_description">Сколько готовых кадров может ожидать перед выводом на экран. Более длинные очереди сглаживают скачки ГПУ ценой задержки ввода.</string>
     <string name="frame_gen_queue_target_0">Минимальная задержка (Без буферизации)</string>
@@ -335,14 +328,12 @@
     <string name="frame_gen_flow_scale">Разрешение оценки движения</string>
     <string name="frame_gen_flow_scale_description">Разрешение прохода оптического потока в долях от выходного разрешения. Его понижение — самый дешёвый способ вернуть производительность.</string>
     <string name="frame_gen_unsupported">Генерация кадров недоступна</string>
-    <string name="frame_gen_unsupported_description">В этом ГПУ драйвере отсутствует поддержка модели памяти Vulkan или половинной точности (float16), которая требуется шейдерам Lossless Scaling.</string>
     <string name="lossless_scaling_setup_description">Опционально. Укажите свой Lossless.dll для включения генерации кадров позже.</string>
     <string name="lossless_scaling_install">Установить Lossless.dll</string>
     <string name="lossless_scaling_install_description">Для генерации кадров требуется ваша собственная легальная копия Lossless.dll из Lossless Scaling</string>
     <string name="lossless_scaling_replace_description">Выбрать другой файл Lossless.dll</string>
     <string name="frame_generation_support">Генерация кадров</string>
     <string name="frame_generation_supported">Поддерживается</string>
-    <string name="frame_generation_unsupported">Не поддерживается (нет модели памяти Vulkan или float16)</string>
     <string name="lossless_scaling_description">Предоставьте свою копию Lossless.dll для включения генерации кадров</string>
     <string name="lossless_scaling_installed">Установлена</string>
     <string name="lossless_scaling_not_installed">Не установлена</string>
@@ -569,6 +560,8 @@
     <string name="renderer_reactive_flushing_description">Повышение точности рендеринга в некоторых играх за счет снижения производительности.</string>
     <string name="enable_buffer_history">Включить историю буфера</string>
     <string name="enable_buffer_history_description">Позволяет обращаться к предыдущим состояниям буфера. Эта опция может повысить качество рендеринга и стабильность производительности в некоторых играх.</string>
+    <string name="enable_gpu_buffer_readback">Включить обратное чтение буфера ГПУ</string>
+    <string name="enable_gpu_buffer_readback_description">Сохраняет измененные ГПУ данные буфера путем чтения их обратно перед выгрузками. Некоторые игры требуют этого, чтобы рендерить определенные эффекты правильно. Может вызывать проблемы если оборудование не может обработать дополнительную рабочую нагрузку.</string>
     <string name="use_optimized_vertex_buffers">Оптимизированные вершинные буферы</string>
     <string name="use_optimized_vertex_buffers_description">Включает оптимизированную привязку вершинного буфера для повышения производительности. Требует Mesa Turnip 26.0+ / QCOM. Приводит к вылету на старых версиях драйверов Turnip (25.3 и ниже).</string>
 
@@ -1086,6 +1079,7 @@
     <string name="gpu_fence_behavior_immediate">Мгновенный</string>
     <string name="gpu_fence_behavior_balanced">Сбалансированный</string>
     <string name="gpu_fence_behavior_accurate">Точный</string>
+    <string name="gpu_fence_behavior_strict">Строгий</string>
 
     <string name="vram_usage_conservative">Консервативный</string>
     <string name="vram_usage_aggressive">Агрессивный</string>

src/android/app/src/main/res/values-zh-rCN/strings.xml

@@ -1,7 +1,6 @@
 <?xml version="1.0" encoding="utf-8"?>
 <resources xmlns:tools="http://schemas.android.com/tools" tools:ignore="MissingTranslation">
 
-    <string name="app_disclaimer">本软件可以运行用于 Nintendo Switch 游戏机的游戏。不包含任何游戏或密钥。<br /><br />在您开始之前, 请定位您设备存储上的 <![CDATA[<b> prod.keys </b>]]> 文件。<br /><br /><![CDATA[<a href=\"https://git.eden-emu.dev/eden-emu/eden/src/branch/master/docs/user/QuickStart.md\">了解更多</a>]]></string>
     <string name="notice_notification_channel_name">错误与注意事项</string>
     <string name="notice_notification_channel_description">当发生错误时显示通知。</string>
     <string name="notification_permission_not_granted">未授予通知权限！</string>
@@ -291,25 +290,6 @@
     <string name="gpu_driver_fetcher">GPU驱动获取器</string>
     <string name="gpu_driver_manager">GPU 驱动管理器</string>
     <string name="install_gpu_driver_description">安装替代的驱动程序以获得更好的性能和精度</string>
-    <string name="post_processing">后处理效果</string>
-    <string name="post_processing_description">在渲染完成后应用 ReShade FX 效果</string>
-    <string name="post_processing_per_game_description">配置此游戏的效果链</string>
-    <string name="post_processing_add">添加效果</string>
-    <string name="post_processing_remove">移除</string>
-    <string name="post_processing_open_list">打开列表</string>
-    <string name="post_processing_close_list">关闭列表</string>
-    <string name="post_processing_remove_all">移除效果</string>
-    <string name="post_processing_preset_locked">预设已激活。在开始游戏前可以在后处理效果中编辑它。</string>
-    <string name="post_processing_preset_modified">数值已从原始预设被更改。</string>
-    <string name="post_processing_presets">预设</string>
-    <string name="post_processing_preset_new">新建预设</string>
-    <string name="post_processing_preset_new_description">把您加载的效果及当前数值保存为一个预设,以便今后选用。</string>
-    <string name="post_processing_preset_name_invalid">请给预设起一个不含等号的名称。</string>
-    <string name="post_processing_preset_none">无预设</string>
-    <string name="post_processing_preset_delete">删除预设</string>
-    <string name="post_processing_preset_reset">重置预设值</string>
-    <string name="post_processing_reset">重置为默认值</string>
-    <string name="post_processing_empty">找不到效果。请在此文件中放置 .fx 文件:</string>
     <string name="frame_gen">帧生成</string>
     <string name="frame_gen_per_game_description">配置针对此游戏的帧生成设定</string>
     <string name="frame_gen_description">设定要在使用无损缩放渲染的帧之间应用的插帧。启用后强制采用FIFO呈现模式 。</string>
@@ -324,13 +304,6 @@
     <string name="frame_gen_target_rate_60">60 FPS</string>
     <string name="frame_gen_target_rate_90">90 FPS</string>
     <string name="frame_gen_target_rate_120">120 FPS</string>
-    <string name="frame_gen_on">开</string>
-    <string name="frame_gen_off">关</string>
-    <string name="frame_gen_fixed">固定</string>
-    <string name="frame_gen_flow_auto">自动</string>
-    <string name="frame_gen_quick_description">打开或关闭帧生成并选择帧生成倍数。</string>
-    <string name="frame_gen_target_rate_quick_description">生成帧到目标帧率。倍率会自动调整。</string>
-    <string name="frame_gen_flow_scale_quick_description">用来估算帧间运动的分辨率。较低的值可以节省 GPU 时间。</string>
     <string name="frame_gen_queue_target">帧队列目标</string>
     <string name="frame_gen_queue_target_description">在显示之前有多少已完成渲染的帧正在等待。较大的队列可以缓解 GPU 突发的压力，但会增加输入延迟。</string>
     <string name="frame_gen_queue_target_0">最低延迟 (无缓冲)</string>
@@ -341,14 +314,12 @@
     <string name="frame_gen_flow_scale">运动预估分辨率</string>
     <string name="frame_gen_flow_scale_description">光流通道的分辨率,以输出的比例表示。降低它是提升性能最经济的做法。</string>
     <string name="frame_gen_unsupported">帧生成不可用</string>
-    <string name="frame_gen_unsupported_description">这个 GPU 驱动缺少 Lossless Scaling 着色器所需的 Vulkan 内存模型或半精度 (float16) 支持。</string>
     <string name="lossless_scaling_setup_description">作为可选项。请提供您自己的 Lossless.dll 以便在之后可以启用帧生成。</string>
     <string name="lossless_scaling_install">安装 Lossless.dll</string>
     <string name="lossless_scaling_install_description">帧生成需要您自己从 Lossless Scaling 获得合法的 Lossless.dll 副本</string>
     <string name="lossless_scaling_replace_description">选择其它 Lossless.dll 副本</string>
     <string name="frame_generation_support">帧生成</string>
     <string name="frame_generation_supported">支持</string>
-    <string name="frame_generation_unsupported">不支持 (无 Vulkan 内存模型或 float16)</string>
     <string name="lossless_scaling">无损缩放</string>
     <string name="lossless_scaling_description">提供您自己的 Lossless.dll 文件以启用帧生成</string>
     <string name="lossless_scaling_installed">已安装</string>
@@ -570,6 +541,8 @@
     <string name="renderer_reactive_flushing_description">通过牺牲性能来提升某些游戏的渲染精度。</string>
     <string name="enable_buffer_history">启用缓冲区历史</string>
     <string name="enable_buffer_history_description">启用对先前缓冲区状态的访问。此选项可在某些游戏中提升渲染质量并保持性能的一致性。</string>
+    <string name="enable_gpu_buffer_readback">启用 GPU 缓冲区回读</string>
+    <string name="enable_gpu_buffer_readback_description">在上传前回读经由 GPU 修改过的缓冲区数据，以将其保留。一些游戏会用到这项设定以正确渲染某些效果。如果硬件无法处理额外的工作负载，则可能会导致问题。</string>
     <string name="use_optimized_vertex_buffers">优化顶点缓冲区</string>
     <string name="use_optimized_vertex_buffers_description">启用经过优化的顶点缓冲区绑定以提升性能。需要 Mesa 26.0 及以上版本的 Turnip 或 QCOM 驱动程序。若使用较旧版本的 Turnip 驱动 (25.3 及以下版本) 则会导致崩溃。</string>
 
@@ -638,11 +611,6 @@
     <string name="log">日志记录</string>
     <string name="flush_by_line">按行刷新调试日志</string>
     <string name="flush_by_line_description">在每行写入时刷新调试日志，使在崩溃或冻结时调试更容易。</string>
-    <string name="extended_logging">开启扩展日志</string>
-    <string name="extended_logging_description">将最大日志文件大小从 100 MiB 提升至 1GiB。</string>
-    <string name="log_filter">日志筛选器</string>
-    <string name="log_filter_description">控制 Eden 的日志类别。例如: *:Info Service.LM:Debug</string>
-
     <!-- GPU Logging strings -->
     <string name="gpu_logging_header">GPU 日志</string>
     <string name="gpu_log_level">日志等级</string>
@@ -926,8 +894,6 @@
     <string name="loader_error_file_not_found">ROM 文件不存在</string>
 
     <string name="loader_requires_firmware">游戏需要固件</string>
-    <string name="loader_requires_firmware_description"><![CDATA[这个游戏可能需要固件才能正常运行,但您还没有安装任何固件。请在启动前安装固件,或者按 “确定” 继续启动。]]></string>
-
     <!-- Intent Launch strings -->
     <string name="searching_for_game">正在搜索游戏...</string>
     <string name="game_not_found_for_title_id">未找到标题ID的游戏: %1$s</string>
@@ -1087,6 +1053,7 @@
     <string name="gpu_fence_behavior_immediate">即时</string>
     <string name="gpu_fence_behavior_balanced">均衡</string>
     <string name="gpu_fence_behavior_accurate">精确</string>
+    <string name="gpu_fence_behavior_strict">严格</string>
 
     <string name="vram_usage_conservative">保守式</string>
     <string name="vram_usage_aggressive">主动式</string>

src/android/app/src/main/res/values-zh-rTW/strings.xml

@@ -229,7 +229,7 @@
     <string name="add_directory_success">遊戲目錄新增成功</string>
     <string name="enable_update_checks">檢查更新</string>
     <string name="enable_update_checks_description">在Eden啟動時檢查有無新版本並選擇是否要下載與安裝更新</string>
-    <string name="update_available">發現新版本</string>
+    <string name="update_available">偵測到新版本</string>
     <string name="update_available_description">有更新可供安裝：%1$s\n\n您要進行更新嗎？</string>
     <string name="downloading_update">下載更新中</string>
     <string name="update_download_failed">更新下載失敗</string>
@@ -561,6 +561,8 @@
     <string name="renderer_reactive_flushing_description">犧牲效能，以改善部分遊戲的轉譯準確度</string>
     <string name="enable_buffer_history">啟用緩衝區歷史</string>
     <string name="enable_buffer_history_description">允許存取先前的緩衝區狀態。此選項可能會改善部分遊戲的渲染品質與效能穩定性</string>
+    <string name="enable_gpu_buffer_readback">啟用 GPU 緩衝區讀回</string>
+    <string name="enable_gpu_buffer_readback_description">透過在上傳之前先將 GPU 修改過的緩衝區資料讀回來保存資料，部分遊戲需要啟用此功能才能正常渲染遊戲特效。如果硬體無法負荷可能會導致錯誤</string>
     <string name="use_optimized_vertex_buffers">最佳化頂點緩衝區</string>
     <string name="use_optimized_vertex_buffers_description">啟用最佳化的頂點緩衝區綁定。需要安裝 Mesa 26.0+ Turnip drivers/Qualcomm drivers。使用舊版 Turnip drivers 會導致當機 (25.3版和更低的版本)</string>
 
@@ -1018,40 +1020,9 @@
     <string name="memory_6gb">6GB (不穩定)</string>
     <string name="memory_8gb">8GB (不穩定)</string>
 
-    <!-- CPU clock levels -->
-    <string name="clock_normal">正常</string>
-    <string name="clock_boost">加速</string>
-    <string name="clock_fast">超頻</string>
-
-    <!-- GPU clock levels -->
-    <string name="fast_gpu_normal">正常</string>
-    <string name="fast_gpu_medium">加速</string>
-    <string name="fast_gpu_high">超頻</string>
-
-    <!-- GPU swizzle texture size -->
-    <string name="gpu_texturesizeswizzle_verysmall">極小 （16MB）</string>
-    <string name="gpu_texturesizeswizzle_small">小（32MB）</string>
-    <string name="gpu_texturesizeswizzle_normal">正常（128MB）</string>
-    <string name="gpu_texturesizeswizzle_large">大（256MB）</string>
-    <string name="gpu_texturesizeswizzle_verylarge">極大（512MB）</string>
-
-    <!-- GPU swizzle streams -->
-    <string name="gpu_swizzle_verylow">極小（4MB）</string>
-    <string name="gpu_swizzle_low">小（8MB）</string>
-    <string name="gpu_swizzle_normal">正常（16MB）</string>
-    <string name="gpu_swizzle_medium">中（32MB）</string>
-    <string name="gpu_swizzle_high">大（64MB）</string>
-
-    <!-- GPU swizzle chunks -->
-    <string name="gpu_swizzlechunk_verylow">極小（32）</string>
-    <string name="gpu_swizzlechunk_low">小（64）</string>
-    <string name="gpu_swizzlechunk_normal">正常（128）</string>
-    <string name="gpu_swizzlechunk_medium">中（256）</string>
-    <string name="gpu_swizzlechunk_high">大（512）</string>
-
     <!-- Temperature Units -->
-    <string name="temperature_celsius">攝氏</string>
-    <string name="temperature_fahrenheit">華氏</string>
+    <string name="temperature_celsius">攝氏度</string>
+    <string name="temperature_fahrenheit">華氏度</string>
 
     <!-- Memory Sizes -->
     <string name="memory_byte_shorthand">B</string>
@@ -1064,8 +1035,6 @@
 
     <string name="renderer_none">無</string>
 
-    <!-- Renderer Accuracy -->
-    <string name="renderer_accuracy_low">效能</string>
     <string name="renderer_accuracy_high">準確</string>
 
     <!-- DMA Accuracy -->

src/android/app/src/main/res/values/arrays.xml

@@ -558,6 +558,7 @@
         <item>@string/gpu_fence_behavior_immediate</item>
         <item>@string/gpu_fence_behavior_balanced</item>
         <item>@string/gpu_fence_behavior_accurate</item>
+        <item>@string/gpu_fence_behavior_strict</item>
     </string-array>
     <integer-array name="gpuFenceBehaviorValues">
         <item>0</item>

src/android/app/src/main/res/values/strings.xml

@@ -586,6 +586,8 @@
     <string name="renderer_reactive_flushing_description">Improves rendering accuracy in some games at the cost of performance.</string>
     <string name="enable_buffer_history">Enable buffer history</string>
     <string name="enable_buffer_history_description">Enables access to previous buffer states. This option may improve rendering quality and performance consistency in some games.</string>
+    <string name="enable_gpu_buffer_readback">Enable GPU Buffer Readback</string>
+    <string name="enable_gpu_buffer_readback_description">Preserves GPU-modified buffer data by reading it back before uploads. Some games require this to render certain effects properly. May cause issues if the hardware cannot handle the additional workload.</string>
     <string name="use_optimized_vertex_buffers">Optimized Vertex Buffers</string>
     <string name="use_optimized_vertex_buffers_description">Enables optimized vertex buffer binding for improved performance. Requires Mesa 26.0+ Turnip drivers/ QCOM drivers. Will crash on older Turnip drivers (25.3 and below).</string>
 
@@ -1136,6 +1138,7 @@
     <string name="gpu_fence_behavior_immediate">Immediate</string>
     <string name="gpu_fence_behavior_balanced">Balanced</string>
     <string name="gpu_fence_behavior_accurate">Accurate</string>
+    <string name="gpu_fence_behavior_strict">Strict</string>
 
     <!-- ASTC Decoding Method Choices -->
     <string name="accelerate_astc_cpu" translatable="false">CPU</string>

src/common/CMakeLists.txt

@@ -62,6 +62,7 @@ add_library(
     fs/fs_util.h
     fs/path_util.cpp
     fs/path_util.h
+    hash.h
     heap_tracker.cpp
     heap_tracker.h
     hex_util.cpp
@@ -75,6 +76,7 @@ add_library(
     logging.h
     lz4_compression.cpp
     lz4_compression.h
+    make_unique_for_overwrite.h
     math_util.h
     memory_detect.cpp
     memory_detect.h
@@ -106,8 +108,7 @@ add_library(
     settings_setting.h
     slot_vector.h
     socket_types.h
-    sparse_large_vector.cpp
-    sparse_large_vector.h
+    spin_lock.h
     stb.cpp
     stb.h
     steady_clock.cpp
@@ -136,8 +137,8 @@ add_library(
     uuid.cpp
     uuid.h
     vector_math.h
-    zbic_compression.cpp
-    zbic_compression.h
+    virtual_buffer.cpp
+    virtual_buffer.h
     zstd_compression.cpp
     zstd_compression.h
     fs/ryujinx_compat.h fs/ryujinx_compat.cpp
@@ -148,10 +149,6 @@ add_library(
     net/net.h net/net.cpp
     container/unordered_map.h container/unordered_set.h)
 
-set_source_files_properties(zbic_compression.cpp PROPERTIES
-    INCLUDE_DIRECTORIES "${ZBIC_INCLUDE_DIR}"
-    COMPILE_OPTIONS "$<$<CXX_COMPILER_ID:Clang,GNU>:-Wno-unused-function;-Wno-missing-declarations;-Wno-shadow>")
-
 if(WIN32)
     target_sources(common PRIVATE windows/timer_resolution.cpp
         windows/timer_resolution.h)

src/common/android/id_cache.cpp

@@ -12,94 +12,93 @@
 #include "common/android/multiplayer/multiplayer.h"
 #include <network/network.h>
 
-static struct {
-    JavaVM *java_vm;
-    jclass native_library_class;
-    jclass disk_cache_progress_class;
-    jclass load_callback_stage_class;
-    jclass game_dir_class;
-    jmethodID game_dir_constructor;
-    jmethodID exit_emulation_activity;
-    jmethodID disk_cache_load_progress;
-    jmethodID on_emulation_started;
-    jmethodID on_emulation_stopped;
-    jmethodID on_program_changed;
-    jmethodID copy_to_storage;
-    jmethodID file_exists;
-    jmethodID file_extension;
 
-    jclass game_class;
-    jmethodID game_constructor;
-    jfieldID game_title_field;
-    jfieldID game_path_field;
-    jfieldID game_program_id_field;
-    jfieldID game_developer_field;
-    jfieldID game_version_field;
-    jfieldID game_is_homebrew_field;
+static JavaVM *s_java_vm;
+static jclass s_native_library_class;
+static jclass s_disk_cache_progress_class;
+static jclass s_load_callback_stage_class;
+static jclass s_game_dir_class;
+static jmethodID s_game_dir_constructor;
+static jmethodID s_exit_emulation_activity;
+static jmethodID s_disk_cache_load_progress;
+static jmethodID s_on_emulation_started;
+static jmethodID s_on_emulation_stopped;
+static jmethodID s_on_program_changed;
+static jmethodID s_copy_to_storage;
+static jmethodID s_file_exists;
+static jmethodID s_file_extension;
 
-    jclass string_class;
-    jclass pair_class;
-    jmethodID pair_constructor;
-    jfieldID pair_first_field;
-    jfieldID pair_second_field;
+static jclass s_game_class;
+static jmethodID s_game_constructor;
+static jfieldID s_game_title_field;
+static jfieldID s_game_path_field;
+static jfieldID s_game_program_id_field;
+static jfieldID s_game_developer_field;
+static jfieldID s_game_version_field;
+static jfieldID s_game_is_homebrew_field;
 
-    jclass overlay_control_data_class;
-    jmethodID overlay_control_data_constructor;
-    jfieldID overlay_control_data_id_field;
-    jfieldID overlay_control_data_enabled_field;
-    jfieldID overlay_control_data_individual_scale_field;
-    jfieldID overlay_control_data_landscape_position_field;
-    jfieldID overlay_control_data_portrait_position_field;
-    jfieldID overlay_control_data_foldable_position_field;
+static jclass s_string_class;
+static jclass s_pair_class;
+static jmethodID s_pair_constructor;
+static jfieldID s_pair_first_field;
+static jfieldID s_pair_second_field;
 
-    jclass patch_class;
-    jmethodID patch_constructor;
-    jfieldID patch_enabled_field;
-    jfieldID patch_name_field;
-    jfieldID patch_version_field;
-    jfieldID patch_type_field;
-    jfieldID patch_program_id_field;
-    jfieldID patch_title_id_field;
+static jclass s_overlay_control_data_class;
+static jmethodID s_overlay_control_data_constructor;
+static jfieldID s_overlay_control_data_id_field;
+static jfieldID s_overlay_control_data_enabled_field;
+static jfieldID s_overlay_control_data_individual_scale_field;
+static jfieldID s_overlay_control_data_landscape_position_field;
+static jfieldID s_overlay_control_data_portrait_position_field;
+static jfieldID s_overlay_control_data_foldable_position_field;
 
-    jclass double_class;
-    jmethodID double_constructor;
-    jmethodID double_value_method;
+static jclass s_patch_class;
+static jmethodID s_patch_constructor;
+static jfieldID s_patch_enabled_field;
+static jfieldID s_patch_name_field;
+static jfieldID s_patch_version_field;
+static jfieldID s_patch_type_field;
+static jfieldID s_patch_program_id_field;
+static jfieldID s_patch_title_id_field;
 
-    jclass integer_class;
-    jmethodID integer_constructor;
-    jmethodID integer_value_method;
+static jclass s_double_class;
+static jmethodID s_double_constructor;
+static jmethodID s_double_value_method;
 
-    jclass boolean_class;
-    jmethodID boolean_constructor;
-    jmethodID boolean_value_method;
+static jclass s_integer_class;
+static jmethodID s_integer_constructor;
+static jmethodID s_integer_value_method;
 
-    jclass player_input_class;
-    jmethodID player_input_constructor;
-    jfieldID player_input_connected_field;
-    jfieldID player_input_buttons_field;
-    jfieldID player_input_analogs_field;
-    jfieldID player_input_motions_field;
-    jfieldID player_input_vibration_enabled_field;
-    jfieldID player_input_vibration_strength_field;
-    jfieldID player_input_body_color_left_field;
-    jfieldID player_input_body_color_right_field;
-    jfieldID player_input_button_color_left_field;
-    jfieldID player_input_button_color_right_field;
-    jfieldID player_input_profile_name_field;
-    jfieldID player_input_use_system_vibrator_field;
+static jclass s_boolean_class;
+static jmethodID s_boolean_constructor;
+static jmethodID s_boolean_value_method;
 
-    jclass yuzu_input_device_interface;
-    jmethodID yuzu_input_device_get_name;
-    jmethodID yuzu_input_device_get_guid;
-    jmethodID yuzu_input_device_get_port;
-    jmethodID yuzu_input_device_get_supports_vibration;
-    jmethodID yuzu_input_device_vibrate;
-    jmethodID yuzu_input_device_get_axes;
-    jmethodID yuzu_input_device_has_keys;
+static jclass s_player_input_class;
+static jmethodID s_player_input_constructor;
+static jfieldID s_player_input_connected_field;
+static jfieldID s_player_input_buttons_field;
+static jfieldID s_player_input_analogs_field;
+static jfieldID s_player_input_motions_field;
+static jfieldID s_player_input_vibration_enabled_field;
+static jfieldID s_player_input_vibration_strength_field;
+static jfieldID s_player_input_body_color_left_field;
+static jfieldID s_player_input_body_color_right_field;
+static jfieldID s_player_input_button_color_left_field;
+static jfieldID s_player_input_button_color_right_field;
+static jfieldID s_player_input_profile_name_field;
+static jfieldID s_player_input_use_system_vibrator_field;
 
-    jmethodID add_netplay_message;
-    jmethodID clear_chat;
-} state;
+static jclass s_yuzu_input_device_interface;
+static jmethodID s_yuzu_input_device_get_name;
+static jmethodID s_yuzu_input_device_get_guid;
+static jmethodID s_yuzu_input_device_get_port;
+static jmethodID s_yuzu_input_device_get_supports_vibration;
+static jmethodID s_yuzu_input_device_vibrate;
+static jmethodID s_yuzu_input_device_get_axes;
+static jmethodID s_yuzu_input_device_has_keys;
+
+static jmethodID s_add_netplay_message;
+static jmethodID s_clear_chat;
 
 static constexpr jint JNI_VERSION = JNI_VERSION_1_6;
 
@@ -107,14 +106,14 @@ namespace Common::Android {
     JNIEnv *GetEnvForThread() {
         thread_local static struct OwnedEnv {
             OwnedEnv() {
-                status = state.java_vm->GetEnv(reinterpret_cast<void **>(&env), JNI_VERSION_1_6);
+                status = s_java_vm->GetEnv(reinterpret_cast<void **>(&env), JNI_VERSION_1_6);
                 if (status == JNI_EDETACHED)
-                    state.java_vm->AttachCurrentThread(&env, nullptr);
+                    s_java_vm->AttachCurrentThread(&env, nullptr);
             }
 
             ~OwnedEnv() {
                 if (status == JNI_EDETACHED)
-                    state.java_vm->DetachCurrentThread();
+                    s_java_vm->DetachCurrentThread();
             }
 
             int status;
@@ -124,303 +123,303 @@ namespace Common::Android {
     }
 
     jclass GetNativeLibraryClass() {
-        return state.native_library_class;
+        return s_native_library_class;
     }
 
     jclass GetDiskCacheProgressClass() {
-        return state.disk_cache_progress_class;
+        return s_disk_cache_progress_class;
     }
 
     jclass GetDiskCacheLoadCallbackStageClass() {
-        return state.load_callback_stage_class;
+        return s_load_callback_stage_class;
     }
 
     jclass GetGameDirClass() {
-        return state.game_dir_class;
+        return s_game_dir_class;
     }
 
     jmethodID GetGameDirConstructor() {
-        return state.game_dir_constructor;
+        return s_game_dir_constructor;
     }
 
     jmethodID GetExitEmulationActivity() {
-        return state.exit_emulation_activity;
+        return s_exit_emulation_activity;
     }
 
     jmethodID GetDiskCacheLoadProgress() {
-        return state.disk_cache_load_progress;
+        return s_disk_cache_load_progress;
     }
 
     jmethodID GetCopyToStorage() {
-        return state.copy_to_storage;
+        return s_copy_to_storage;
     }
 
     jmethodID GetFileExists() {
-        return state.file_exists;
+        return s_file_exists;
     }
 
     jmethodID GetFileExtension() {
-        return state.file_extension;
+        return s_file_extension;
     }
 
     jmethodID GetOnEmulationStarted() {
-        return state.on_emulation_started;
+        return s_on_emulation_started;
     }
 
     jmethodID GetOnEmulationStopped() {
-        return state.on_emulation_stopped;
+        return s_on_emulation_stopped;
     }
 
     jmethodID GetOnProgramChanged() {
-        return state.on_program_changed;
+        return s_on_program_changed;
     }
 
     jclass GetGameClass() {
-        return state.game_class;
+        return s_game_class;
     }
 
     jmethodID GetGameConstructor() {
-        return state.game_constructor;
+        return s_game_constructor;
     }
 
     jfieldID GetGameTitleField() {
-        return state.game_title_field;
+        return s_game_title_field;
     }
 
     jfieldID GetGamePathField() {
-        return state.game_path_field;
+        return s_game_path_field;
     }
 
     jfieldID GetGameProgramIdField() {
-        return state.game_program_id_field;
+        return s_game_program_id_field;
     }
 
     jfieldID GetGameDeveloperField() {
-        return state.game_developer_field;
+        return s_game_developer_field;
     }
 
     jfieldID GetGameVersionField() {
-        return state.game_version_field;
+        return s_game_version_field;
     }
 
     jfieldID GetGameIsHomebrewField() {
-        return state.game_is_homebrew_field;
+        return s_game_is_homebrew_field;
     }
 
     jclass GetStringClass() {
-        return state.string_class;
+        return s_string_class;
     }
 
     jclass GetPairClass() {
-        return state.pair_class;
+        return s_pair_class;
     }
 
     jmethodID GetPairConstructor() {
-        return state.pair_constructor;
+        return s_pair_constructor;
     }
 
     jfieldID GetPairFirstField() {
-        return state.pair_first_field;
+        return s_pair_first_field;
     }
 
     jfieldID GetPairSecondField() {
-        return state.pair_second_field;
+        return s_pair_second_field;
     }
 
     jclass GetOverlayControlDataClass() {
-        return state.overlay_control_data_class;
+        return s_overlay_control_data_class;
     }
 
     jmethodID GetOverlayControlDataConstructor() {
-        return state.overlay_control_data_constructor;
+        return s_overlay_control_data_constructor;
     }
 
     jfieldID GetOverlayControlDataIdField() {
-        return state.overlay_control_data_id_field;
+        return s_overlay_control_data_id_field;
     }
 
     jfieldID GetOverlayControlDataEnabledField() {
-        return state.overlay_control_data_enabled_field;
+        return s_overlay_control_data_enabled_field;
     }
 
     jfieldID GetOverlayControlDataIndividualScaleField() {
-        return state.overlay_control_data_individual_scale_field;
+        return s_overlay_control_data_individual_scale_field;
     }
 
     jfieldID GetOverlayControlDataLandscapePositionField() {
-        return state.overlay_control_data_landscape_position_field;
+        return s_overlay_control_data_landscape_position_field;
     }
 
     jfieldID GetOverlayControlDataPortraitPositionField() {
-        return state.overlay_control_data_portrait_position_field;
+        return s_overlay_control_data_portrait_position_field;
     }
 
     jfieldID GetOverlayControlDataFoldablePositionField() {
-        return state.overlay_control_data_foldable_position_field;
+        return s_overlay_control_data_foldable_position_field;
     }
 
     jclass GetPatchClass() {
-        return state.patch_class;
+        return s_patch_class;
     }
 
     jmethodID GetPatchConstructor() {
-        return state.patch_constructor;
+        return s_patch_constructor;
     }
 
     jfieldID GetPatchEnabledField() {
-        return state.patch_enabled_field;
+        return s_patch_enabled_field;
     }
 
     jfieldID GetPatchNameField() {
-        return state.patch_name_field;
+        return s_patch_name_field;
     }
 
     jfieldID GetPatchVersionField() {
-        return state.patch_version_field;
+        return s_patch_version_field;
     }
 
     jfieldID GetPatchTypeField() {
-        return state.patch_type_field;
+        return s_patch_type_field;
     }
 
     jfieldID GetPatchProgramIdField() {
-        return state.patch_program_id_field;
+        return s_patch_program_id_field;
     }
 
     jfieldID GetPatchTitleIdField() {
-        return state.patch_title_id_field;
+        return s_patch_title_id_field;
     }
 
     jclass GetDoubleClass() {
-        return state.double_class;
+        return s_double_class;
     }
 
     jmethodID GetDoubleConstructor() {
-        return state.double_constructor;
+        return s_double_constructor;
     }
 
     jmethodID GetDoubleValueMethod() {
-        return state.double_value_method;
+        return s_double_value_method;
     }
 
     jclass GetIntegerClass() {
-        return state.integer_class;
+        return s_integer_class;
     }
 
     jmethodID GetIntegerConstructor() {
-        return state.integer_constructor;
+        return s_integer_constructor;
     }
 
     jmethodID GetIntegerValueMethod() {
-        return state.integer_value_method;
+        return s_integer_value_method;
     }
 
     jclass GetBooleanClass() {
-        return state.boolean_class;
+        return s_boolean_class;
     }
 
     jmethodID GetBooleanConstructor() {
-        return state.boolean_constructor;
+        return s_boolean_constructor;
     }
 
     jmethodID GetBooleanValueMethod() {
-        return state.boolean_value_method;
+        return s_boolean_value_method;
     }
 
     jclass GetPlayerInputClass() {
-        return state.player_input_class;
+        return s_player_input_class;
     }
 
     jmethodID GetPlayerInputConstructor() {
-        return state.player_input_constructor;
+        return s_player_input_constructor;
     }
 
     jfieldID GetPlayerInputConnectedField() {
-        return state.player_input_connected_field;
+        return s_player_input_connected_field;
     }
 
     jfieldID GetPlayerInputButtonsField() {
-        return state.player_input_buttons_field;
+        return s_player_input_buttons_field;
     }
 
     jfieldID GetPlayerInputAnalogsField() {
-        return state.player_input_analogs_field;
+        return s_player_input_analogs_field;
     }
 
     jfieldID GetPlayerInputMotionsField() {
-        return state.player_input_motions_field;
+        return s_player_input_motions_field;
     }
 
     jfieldID GetPlayerInputVibrationEnabledField() {
-        return state.player_input_vibration_enabled_field;
+        return s_player_input_vibration_enabled_field;
     }
 
     jfieldID GetPlayerInputVibrationStrengthField() {
-        return state.player_input_vibration_strength_field;
+        return s_player_input_vibration_strength_field;
     }
 
     jfieldID GetPlayerInputBodyColorLeftField() {
-        return state.player_input_body_color_left_field;
+        return s_player_input_body_color_left_field;
     }
 
     jfieldID GetPlayerInputBodyColorRightField() {
-        return state.player_input_body_color_right_field;
+        return s_player_input_body_color_right_field;
     }
 
     jfieldID GetPlayerInputButtonColorLeftField() {
-        return state.player_input_button_color_left_field;
+        return s_player_input_button_color_left_field;
     }
 
     jfieldID GetPlayerInputButtonColorRightField() {
-        return state.player_input_button_color_right_field;
+        return s_player_input_button_color_right_field;
     }
 
     jfieldID GetPlayerInputProfileNameField() {
-        return state.player_input_profile_name_field;
+        return s_player_input_profile_name_field;
     }
 
     jfieldID GetPlayerInputUseSystemVibratorField() {
-        return state.player_input_use_system_vibrator_field;
+        return s_player_input_use_system_vibrator_field;
     }
 
     jclass GetYuzuInputDeviceInterface() {
-        return state.yuzu_input_device_interface;
+        return s_yuzu_input_device_interface;
     }
 
     jmethodID GetYuzuDeviceGetName() {
-        return state.yuzu_input_device_get_name;
+        return s_yuzu_input_device_get_name;
     }
 
     jmethodID GetYuzuDeviceGetGUID() {
-        return state.yuzu_input_device_get_guid;
+        return s_yuzu_input_device_get_guid;
     }
 
     jmethodID GetYuzuDeviceGetPort() {
-        return state.yuzu_input_device_get_port;
+        return s_yuzu_input_device_get_port;
     }
 
     jmethodID GetYuzuDeviceGetSupportsVibration() {
-        return state.yuzu_input_device_get_supports_vibration;
+        return s_yuzu_input_device_get_supports_vibration;
     }
 
     jmethodID GetYuzuDeviceVibrate() {
-        return state.yuzu_input_device_vibrate;
+        return s_yuzu_input_device_vibrate;
     }
 
     jmethodID GetYuzuDeviceGetAxes() {
-        return state.yuzu_input_device_get_axes;
+        return s_yuzu_input_device_get_axes;
     }
 
     jmethodID GetYuzuDeviceHasKeys() {
-        return state.yuzu_input_device_has_keys;
+        return s_yuzu_input_device_has_keys;
     }
 
     jmethodID GetAddNetPlayMessage() {
-        return state.add_netplay_message;
+        return s_add_netplay_message;
     }
 
     jmethodID ClearChat() {
-        return state.clear_chat;
+        return s_clear_chat;
     }
 
 #ifdef __cplusplus
@@ -437,20 +436,20 @@ namespace Common::Android {
 
         // UnInitialize Android Storage
         Common::FS::Android::UnRegisterCallbacks();
-        env->DeleteGlobalRef(state.native_library_class);
-        env->DeleteGlobalRef(state.disk_cache_progress_class);
-        env->DeleteGlobalRef(state.load_callback_stage_class);
-        env->DeleteGlobalRef(state.game_dir_class);
-        env->DeleteGlobalRef(state.game_class);
-        env->DeleteGlobalRef(state.string_class);
-        env->DeleteGlobalRef(state.pair_class);
-        env->DeleteGlobalRef(state.overlay_control_data_class);
-        env->DeleteGlobalRef(state.patch_class);
-        env->DeleteGlobalRef(state.double_class);
-        env->DeleteGlobalRef(state.integer_class);
-        env->DeleteGlobalRef(state.boolean_class);
-        env->DeleteGlobalRef(state.player_input_class);
-        env->DeleteGlobalRef(state.yuzu_input_device_interface);
+        env->DeleteGlobalRef(s_native_library_class);
+        env->DeleteGlobalRef(s_disk_cache_progress_class);
+        env->DeleteGlobalRef(s_load_callback_stage_class);
+        env->DeleteGlobalRef(s_game_dir_class);
+        env->DeleteGlobalRef(s_game_class);
+        env->DeleteGlobalRef(s_string_class);
+        env->DeleteGlobalRef(s_pair_class);
+        env->DeleteGlobalRef(s_overlay_control_data_class);
+        env->DeleteGlobalRef(s_patch_class);
+        env->DeleteGlobalRef(s_double_class);
+        env->DeleteGlobalRef(s_integer_class);
+        env->DeleteGlobalRef(s_boolean_class);
+        env->DeleteGlobalRef(s_player_input_class);
+        env->DeleteGlobalRef(s_yuzu_input_device_interface);
 
         // UnInitialize applets
         SoftwareKeyboard::CleanupJNI(env);
@@ -464,7 +463,7 @@ namespace Common::Android {
 #endif
 
 void Initialize(JavaVM* vm, JNIEnv *env) {
-    state.java_vm = vm;
+    s_java_vm = vm;
     InitFFmpegOnLoad(vm);
 
     if (env->ExceptionCheck()) {
@@ -473,169 +472,169 @@ void Initialize(JavaVM* vm, JNIEnv *env) {
 
     // Initialize Java classes
     const jclass native_library_class = env->FindClass("org/yuzu/yuzu_emu/NativeLibrary");
-    state.native_library_class = reinterpret_cast<jclass>(env->NewGlobalRef(native_library_class));
-    state.disk_cache_progress_class = reinterpret_cast<jclass>(env->NewGlobalRef(
+    s_native_library_class = reinterpret_cast<jclass>(env->NewGlobalRef(native_library_class));
+    s_disk_cache_progress_class = reinterpret_cast<jclass>(env->NewGlobalRef(
         env->FindClass("org/yuzu/yuzu_emu/disk_shader_cache/DiskShaderCacheProgress")));
-    state.load_callback_stage_class = reinterpret_cast<jclass>(env->NewGlobalRef(env->FindClass(
+    s_load_callback_stage_class = reinterpret_cast<jclass>(env->NewGlobalRef(env->FindClass(
         "org/yuzu/yuzu_emu/disk_shader_cache/DiskShaderCacheProgress$LoadCallbackStage")));
 
     const jclass game_dir_class = env->FindClass("org/yuzu/yuzu_emu/model/GameDir");
-    state.game_dir_class = reinterpret_cast<jclass>(env->NewGlobalRef(game_dir_class));
-    state.game_dir_constructor = env->GetMethodID(game_dir_class, "<init>",
+    s_game_dir_class = reinterpret_cast<jclass>(env->NewGlobalRef(game_dir_class));
+    s_game_dir_constructor = env->GetMethodID(game_dir_class, "<init>",
                                               "(Ljava/lang/String;Z)V");
     env->DeleteLocalRef(game_dir_class);
 
     // Initialize methods
-    state.exit_emulation_activity =
-        env->GetStaticMethodID(state.native_library_class, "exitEmulationActivity", "(I)V");
-    state.disk_cache_load_progress =
-        env->GetStaticMethodID(state.disk_cache_progress_class, "loadProgress", "(III)V");
-    state.copy_to_storage = env->GetStaticMethodID(state.native_library_class, "copyFileToStorage",
+    s_exit_emulation_activity =
+        env->GetStaticMethodID(s_native_library_class, "exitEmulationActivity", "(I)V");
+    s_disk_cache_load_progress =
+        env->GetStaticMethodID(s_disk_cache_progress_class, "loadProgress", "(III)V");
+    s_copy_to_storage = env->GetStaticMethodID(s_native_library_class, "copyFileToStorage",
                                                "(Ljava/lang/String;Ljava/lang/String;)Z");
-    state.file_exists = env->GetStaticMethodID(state.native_library_class, "exists",
+    s_file_exists = env->GetStaticMethodID(s_native_library_class, "exists",
                                            "(Ljava/lang/String;)Z");
-    state.file_extension = env->GetStaticMethodID(state.native_library_class, "getFileExtension",
+    s_file_extension = env->GetStaticMethodID(s_native_library_class, "getFileExtension",
                                               "(Ljava/lang/String;)Ljava/lang/String;");
-    state.on_emulation_started =
-        env->GetStaticMethodID(state.native_library_class, "onEmulationStarted", "()V");
-    state.on_emulation_stopped =
-        env->GetStaticMethodID(state.native_library_class, "onEmulationStopped", "(I)V");
-    state.on_program_changed =
-        env->GetStaticMethodID(state.native_library_class, "onProgramChanged", "(I)V");
+    s_on_emulation_started =
+        env->GetStaticMethodID(s_native_library_class, "onEmulationStarted", "()V");
+    s_on_emulation_stopped =
+        env->GetStaticMethodID(s_native_library_class, "onEmulationStopped", "(I)V");
+    s_on_program_changed =
+        env->GetStaticMethodID(s_native_library_class, "onProgramChanged", "(I)V");
 
     const jclass game_class = env->FindClass("org/yuzu/yuzu_emu/model/Game");
-    state.game_class = reinterpret_cast<jclass>(env->NewGlobalRef(game_class));
-    state.game_constructor = env->GetMethodID(game_class, "<init>",
+    s_game_class = reinterpret_cast<jclass>(env->NewGlobalRef(game_class));
+    s_game_constructor = env->GetMethodID(game_class, "<init>",
                                           "(Ljava/lang/String;Ljava/lang/String;Ljava/lang/"
                                           "String;Ljava/lang/String;Ljava/lang/String;Z)V");
-    state.game_title_field = env->GetFieldID(game_class, "title", "Ljava/lang/String;");
-    state.game_path_field = env->GetFieldID(game_class, "path", "Ljava/lang/String;");
-    state.game_program_id_field = env->GetFieldID(game_class, "programId", "Ljava/lang/String;");
-    state.game_developer_field = env->GetFieldID(game_class, "developer", "Ljava/lang/String;");
-    state.game_version_field = env->GetFieldID(game_class, "version", "Ljava/lang/String;");
-    state.game_is_homebrew_field = env->GetFieldID(game_class, "isHomebrew", "Z");
+    s_game_title_field = env->GetFieldID(game_class, "title", "Ljava/lang/String;");
+    s_game_path_field = env->GetFieldID(game_class, "path", "Ljava/lang/String;");
+    s_game_program_id_field = env->GetFieldID(game_class, "programId", "Ljava/lang/String;");
+    s_game_developer_field = env->GetFieldID(game_class, "developer", "Ljava/lang/String;");
+    s_game_version_field = env->GetFieldID(game_class, "version", "Ljava/lang/String;");
+    s_game_is_homebrew_field = env->GetFieldID(game_class, "isHomebrew", "Z");
     env->DeleteLocalRef(game_class);
 
     const jclass string_class = env->FindClass("java/lang/String");
-    state.string_class = reinterpret_cast<jclass>(env->NewGlobalRef(string_class));
+    s_string_class = reinterpret_cast<jclass>(env->NewGlobalRef(string_class));
     env->DeleteLocalRef(string_class);
 
     const jclass pair_class = env->FindClass("kotlin/Pair");
-    state.pair_class = reinterpret_cast<jclass>(env->NewGlobalRef(pair_class));
-    state.pair_constructor =
+    s_pair_class = reinterpret_cast<jclass>(env->NewGlobalRef(pair_class));
+    s_pair_constructor =
         env->GetMethodID(pair_class, "<init>", "(Ljava/lang/Object;Ljava/lang/Object;)V");
-    state.pair_first_field = env->GetFieldID(pair_class, "first", "Ljava/lang/Object;");
-    state.pair_second_field = env->GetFieldID(pair_class, "second", "Ljava/lang/Object;");
+    s_pair_first_field = env->GetFieldID(pair_class, "first", "Ljava/lang/Object;");
+    s_pair_second_field = env->GetFieldID(pair_class, "second", "Ljava/lang/Object;");
     env->DeleteLocalRef(pair_class);
 
     const jclass overlay_control_data_class =
         env->FindClass("org/yuzu/yuzu_emu/overlay/model/OverlayControlData");
-    state.overlay_control_data_class =
+    s_overlay_control_data_class =
         reinterpret_cast<jclass>(env->NewGlobalRef(overlay_control_data_class));
-    state.overlay_control_data_constructor =
+    s_overlay_control_data_constructor =
         env->GetMethodID(overlay_control_data_class, "<init>",
                          "(Ljava/lang/String;ZLkotlin/Pair;Lkotlin/Pair;Lkotlin/Pair;F)V");
-    state.overlay_control_data_id_field =
+    s_overlay_control_data_id_field =
         env->GetFieldID(overlay_control_data_class, "id", "Ljava/lang/String;");
-    state.overlay_control_data_enabled_field =
+    s_overlay_control_data_enabled_field =
         env->GetFieldID(overlay_control_data_class, "enabled", "Z");
-    state.overlay_control_data_landscape_position_field =
+    s_overlay_control_data_landscape_position_field =
         env->GetFieldID(overlay_control_data_class, "landscapePosition", "Lkotlin/Pair;");
-    state.overlay_control_data_portrait_position_field =
+    s_overlay_control_data_portrait_position_field =
         env->GetFieldID(overlay_control_data_class, "portraitPosition", "Lkotlin/Pair;");
-    state.overlay_control_data_foldable_position_field =
+    s_overlay_control_data_foldable_position_field =
         env->GetFieldID(overlay_control_data_class, "foldablePosition", "Lkotlin/Pair;");
-    state.overlay_control_data_individual_scale_field =
+    s_overlay_control_data_individual_scale_field =
         env->GetFieldID(overlay_control_data_class, "individualScale", "F");
     env->DeleteLocalRef(overlay_control_data_class);
 
     const jclass patch_class = env->FindClass("org/yuzu/yuzu_emu/model/Patch");
-    state.patch_class = reinterpret_cast<jclass>(env->NewGlobalRef(patch_class));
-    state.patch_constructor = env->GetMethodID(
+    s_patch_class = reinterpret_cast<jclass>(env->NewGlobalRef(patch_class));
+    s_patch_constructor = env->GetMethodID(
         patch_class, "<init>",
         "(ZLjava/lang/String;Ljava/lang/String;ILjava/lang/String;Ljava/lang/String;JI)V");
-    state.patch_enabled_field = env->GetFieldID(patch_class, "enabled", "Z");
-    state.patch_name_field = env->GetFieldID(patch_class, "name", "Ljava/lang/String;");
-    state.patch_version_field = env->GetFieldID(patch_class, "version", "Ljava/lang/String;");
-    state.patch_type_field = env->GetFieldID(patch_class, "type", "I");
-    state.patch_program_id_field = env->GetFieldID(patch_class, "programId", "Ljava/lang/String;");
-    state.patch_title_id_field = env->GetFieldID(patch_class, "titleId", "Ljava/lang/String;");
+    s_patch_enabled_field = env->GetFieldID(patch_class, "enabled", "Z");
+    s_patch_name_field = env->GetFieldID(patch_class, "name", "Ljava/lang/String;");
+    s_patch_version_field = env->GetFieldID(patch_class, "version", "Ljava/lang/String;");
+    s_patch_type_field = env->GetFieldID(patch_class, "type", "I");
+    s_patch_program_id_field = env->GetFieldID(patch_class, "programId", "Ljava/lang/String;");
+    s_patch_title_id_field = env->GetFieldID(patch_class, "titleId", "Ljava/lang/String;");
     env->DeleteLocalRef(patch_class);
 
     const jclass double_class = env->FindClass("java/lang/Double");
-    state.double_class = reinterpret_cast<jclass>(env->NewGlobalRef(double_class));
-    state.double_constructor = env->GetMethodID(double_class, "<init>", "(D)V");
-    state.double_value_method = env->GetMethodID(double_class, "doubleValue", "()D");
+    s_double_class = reinterpret_cast<jclass>(env->NewGlobalRef(double_class));
+    s_double_constructor = env->GetMethodID(double_class, "<init>", "(D)V");
+    s_double_value_method = env->GetMethodID(double_class, "doubleValue", "()D");
     env->DeleteLocalRef(double_class);
 
     const jclass int_class = env->FindClass("java/lang/Integer");
-    state.integer_class = reinterpret_cast<jclass>(env->NewGlobalRef(int_class));
-    state.integer_constructor = env->GetMethodID(int_class, "<init>", "(I)V");
-    state.integer_value_method = env->GetMethodID(int_class, "intValue", "()I");
+    s_integer_class = reinterpret_cast<jclass>(env->NewGlobalRef(int_class));
+    s_integer_constructor = env->GetMethodID(int_class, "<init>", "(I)V");
+    s_integer_value_method = env->GetMethodID(int_class, "intValue", "()I");
     env->DeleteLocalRef(int_class);
 
     const jclass boolean_class = env->FindClass("java/lang/Boolean");
-    state.boolean_class = reinterpret_cast<jclass>(env->NewGlobalRef(boolean_class));
-    state.boolean_constructor = env->GetMethodID(boolean_class, "<init>", "(Z)V");
-    state.boolean_value_method = env->GetMethodID(boolean_class, "booleanValue", "()Z");
+    s_boolean_class = reinterpret_cast<jclass>(env->NewGlobalRef(boolean_class));
+    s_boolean_constructor = env->GetMethodID(boolean_class, "<init>", "(Z)V");
+    s_boolean_value_method = env->GetMethodID(boolean_class, "booleanValue", "()Z");
     env->DeleteLocalRef(boolean_class);
 
     const jclass player_input_class =
         env->FindClass("org/yuzu/yuzu_emu/features/input/model/PlayerInput");
-    state.player_input_class = reinterpret_cast<jclass>(env->NewGlobalRef(player_input_class));
-    state.player_input_constructor = env->GetMethodID(
+    s_player_input_class = reinterpret_cast<jclass>(env->NewGlobalRef(player_input_class));
+    s_player_input_constructor = env->GetMethodID(
         player_input_class, "<init>",
         "(Z[Ljava/lang/String;[Ljava/lang/String;[Ljava/lang/String;ZIJJJJLjava/lang/String;Z)V");
-    state.player_input_connected_field = env->GetFieldID(player_input_class, "connected", "Z");
-    state.player_input_buttons_field =
+    s_player_input_connected_field = env->GetFieldID(player_input_class, "connected", "Z");
+    s_player_input_buttons_field =
         env->GetFieldID(player_input_class, "buttons", "[Ljava/lang/String;");
-    state.player_input_analogs_field =
+    s_player_input_analogs_field =
         env->GetFieldID(player_input_class, "analogs", "[Ljava/lang/String;");
-    state.player_input_motions_field =
+    s_player_input_motions_field =
         env->GetFieldID(player_input_class, "motions", "[Ljava/lang/String;");
-    state.player_input_vibration_enabled_field =
+    s_player_input_vibration_enabled_field =
         env->GetFieldID(player_input_class, "vibrationEnabled", "Z");
-    state.player_input_vibration_strength_field =
+    s_player_input_vibration_strength_field =
         env->GetFieldID(player_input_class, "vibrationStrength", "I");
-    state.player_input_body_color_left_field =
+    s_player_input_body_color_left_field =
         env->GetFieldID(player_input_class, "bodyColorLeft", "J");
-    state.player_input_body_color_right_field =
+    s_player_input_body_color_right_field =
         env->GetFieldID(player_input_class, "bodyColorRight", "J");
-    state.player_input_button_color_left_field =
+    s_player_input_button_color_left_field =
         env->GetFieldID(player_input_class, "buttonColorLeft", "J");
-    state.player_input_button_color_right_field =
+    s_player_input_button_color_right_field =
         env->GetFieldID(player_input_class, "buttonColorRight", "J");
-    state.player_input_profile_name_field =
+    s_player_input_profile_name_field =
         env->GetFieldID(player_input_class, "profileName", "Ljava/lang/String;");
-    state.player_input_use_system_vibrator_field =
+    s_player_input_use_system_vibrator_field =
         env->GetFieldID(player_input_class, "useSystemVibrator", "Z");
     env->DeleteLocalRef(player_input_class);
 
     const jclass yuzu_input_device_interface =
         env->FindClass("org/yuzu/yuzu_emu/features/input/YuzuInputDevice");
-    state.yuzu_input_device_interface =
+    s_yuzu_input_device_interface =
         reinterpret_cast<jclass>(env->NewGlobalRef(yuzu_input_device_interface));
-    state.yuzu_input_device_get_name =
+    s_yuzu_input_device_get_name =
         env->GetMethodID(yuzu_input_device_interface, "getName", "()Ljava/lang/String;");
-    state.yuzu_input_device_get_guid =
+    s_yuzu_input_device_get_guid =
         env->GetMethodID(yuzu_input_device_interface, "getGUID", "()Ljava/lang/String;");
-    state.yuzu_input_device_get_port = env->GetMethodID(yuzu_input_device_interface, "getPort",
+    s_yuzu_input_device_get_port = env->GetMethodID(yuzu_input_device_interface, "getPort",
                                                     "()I");
-    state.yuzu_input_device_get_supports_vibration =
+    s_yuzu_input_device_get_supports_vibration =
         env->GetMethodID(yuzu_input_device_interface, "getSupportsVibration", "()Z");
-    state.yuzu_input_device_vibrate = env->GetMethodID(yuzu_input_device_interface, "vibrate",
+    s_yuzu_input_device_vibrate = env->GetMethodID(yuzu_input_device_interface, "vibrate",
                                                    "(F)V");
-    state.yuzu_input_device_get_axes =
+    s_yuzu_input_device_get_axes =
         env->GetMethodID(yuzu_input_device_interface, "getAxes", "()[Ljava/lang/Integer;");
-    state.yuzu_input_device_has_keys =
+    s_yuzu_input_device_has_keys =
         env->GetMethodID(yuzu_input_device_interface, "hasKeys", "([I)[Z");
     env->DeleteLocalRef(yuzu_input_device_interface);
-    state.add_netplay_message = env->GetStaticMethodID(state.native_library_class, "addNetPlayMessage",
+    s_add_netplay_message = env->GetStaticMethodID(s_native_library_class, "addNetPlayMessage",
                                                    "(ILjava/lang/String;)V");
-    state.clear_chat = env->GetStaticMethodID(state.native_library_class, "clearChat", "()V");
+    s_clear_chat = env->GetStaticMethodID(s_native_library_class, "clearChat", "()V");
 
     // Initialize Android Storage
-    Common::FS::Android::RegisterCallbacks(env, state.native_library_class);
+    Common::FS::Android::RegisterCallbacks(env, s_native_library_class);
 
     // Initialize applets
     Common::Android::SoftwareKeyboard::InitJNI(env);

src/common/bit_util.h

@@ -22,22 +22,36 @@ template <typename T>
     return std::size_t(sizeof(T) * CHAR_BIT);
 }
 
+template<typename T>
+    requires std::is_integral_v<T>
+[[nodiscard]] constexpr u32 MostSignificantBit(const T value) {
+    return u32(sizeof(T) * CHAR_BIT - 1 - std::countl_zero(value));
+}
+
 template<typename T>
     requires std::is_integral_v<T>
 [[nodiscard]] constexpr T Log2Floor(const T value) {
-    return std::bit_width(value) - 1;
+    return T(MostSignificantBit<T>(value));
 }
 
 template<typename T>
     requires std::is_integral_v<T>
 [[nodiscard]] constexpr T Log2Ceil(const T value) {
-    return std::bit_width(value - 1);
+    const T log2_f = Log2Floor<T>(value);
+    return T(log2_f + T((value ^ (T(1ULL) << log2_f)) != T(0ULL)));
+}
+
+template <typename T>
+    requires std::is_integral_v<T>
+[[nodiscard]] T NextPow2(T value) {
+    return T(1ULL << (sizeof(T) * CHAR_BIT - std::countl_zero(value - 1U)));
 }
 
 template <size_t bit_index, typename T>
-    requires (std::is_integral_v<T> && bit_index < BitSize<T>())
+    requires std::is_integral_v<T>
 [[nodiscard]] constexpr bool Bit(const T value) {
-    return (T(value >> bit_index) & T(1)) == T(1);
+    static_assert(bit_index < BitSize<T>(), "bit_index must be smaller than size of T");
+    return ((value >> bit_index) & T(1)) == T(1);
 }
 
 } // namespace Common

src/common/container_hash.h

@@ -25,18 +25,26 @@ template <typename T>
     requires std::is_unsigned_v<T>
 inline std::size_t HashValue(T val) {
     const unsigned int size_t_bits = std::numeric_limits<std::size_t>::digits;
-    const unsigned int length = (std::numeric_limits<T>::digits - 1) / static_cast<unsigned int>(size_t_bits);
+    const unsigned int length =
+        (std::numeric_limits<T>::digits - 1) / static_cast<unsigned int>(size_t_bits);
+
     std::size_t seed = 0;
-    for (unsigned int i = length * size_t_bits; i > 0; i -= size_t_bits)
-        seed ^= std::size_t(val >> i) + (seed << 6) + (seed >> 2);
-    return seed ^= std::size_t(val) + (seed << 6) + (seed >> 2);
+
+    for (unsigned int i = length * size_t_bits; i > 0; i -= size_t_bits) {
+        seed ^= static_cast<size_t>(val >> i) + (seed << 6) + (seed >> 2);
+    }
+
+    seed ^= static_cast<size_t>(val) + (seed << 6) + (seed >> 2);
+
+    return seed;
 }
 
 template <size_t Bits>
 struct HashCombineImpl {
     template <typename T>
     static inline T fn(T seed, T value) {
-        return seed ^= value + 0x9e3779b9 + (seed << 6) + (seed >> 2);
+        seed ^= value + 0x9e3779b9 + (seed << 6) + (seed >> 2);
+        return seed;
     }
 };
 

src/common/div_ceil.h

@@ -1,6 +1,3 @@
-// SPDX-FileCopyrightText: Copyright 2026 Eden Emulator Project
-// SPDX-License-Identifier: GPL-3.0-or-later
-
 // SPDX-FileCopyrightText: Copyright 2020 yuzu Emulator Project
 // SPDX-License-Identifier: GPL-2.0-or-later
 
@@ -15,14 +12,14 @@ namespace Common {
 template <typename N, typename D>
     requires std::is_integral_v<N> && std::is_unsigned_v<D>
 [[nodiscard]] constexpr N DivCeil(N number, D divisor) {
-    return N((D(number) + divisor - 1) / divisor);
+    return static_cast<N>((static_cast<D>(number) + divisor - 1) / divisor);
 }
 
 /// Ceiled integer division with logarithmic divisor in base 2
 template <typename N, typename D>
     requires std::is_integral_v<N> && std::is_unsigned_v<D>
 [[nodiscard]] constexpr N DivCeilLog2(N value, D alignment_log2) {
-    return N((D(value) + (D(1) << alignment_log2) - 1) >> alignment_log2);
+    return static_cast<N>((static_cast<D>(value) + (D(1) << alignment_log2) - 1) >> alignment_log2);
 }
 
 } // namespace Common

src/common/fiber.cpp

@@ -9,6 +9,7 @@
 
 #include "common/assert.h"
 #include "common/fiber.h"
+#include "common/virtual_buffer.h"
 
 #include <boost/context/detail/fcontext.hpp>
 

src/common/hash.h

@@ -0,0 +1,28 @@
+// SPDX-FileCopyrightText: 2015 Citra Emulator Project
+// SPDX-License-Identifier: GPL-2.0-or-later
+
+#pragma once
+
+#include <cstddef>
+#include <utility>
+#include <boost/functional/hash.hpp>
+
+namespace Common {
+
+struct PairHash {
+    template <class T1, class T2>
+    std::size_t operator()(const std::pair<T1, T2>& pair) const noexcept {
+        std::size_t seed = std::hash<T1>()(pair.first);
+        boost::hash_combine(seed, std::hash<T2>()(pair.second));
+        return seed;
+    }
+};
+
+template <typename T>
+struct IdentityHash {
+    [[nodiscard]] size_t operator()(T value) const noexcept {
+        return static_cast<size_t>(value);
+    }
+};
+
+} // namespace Common

src/common/hex_util.h

@@ -1,6 +1,3 @@
-// SPDX-FileCopyrightText: Copyright 2026 Eden Emulator Project
-// SPDX-License-Identifier: GPL-3.0-or-later
-
 // SPDX-FileCopyrightText: 2013 Dolphin Emulator Project
 // SPDX-FileCopyrightText: 2014 Citra Emulator Project
 // SPDX-License-Identifier: GPL-2.0-or-later
@@ -19,12 +16,14 @@ namespace Common {
 
 [[nodiscard]] constexpr u8 ToHexNibble(char c) {
     if (c >= 65 && c <= 70) {
-        return u8(c - 55);
+        return static_cast<u8>(c - 55);
     }
+
     if (c >= 97 && c <= 102) {
-        return u8(c - 87);
+        return static_cast<u8>(c - 87);
     }
-    return u8(c - 48);
+
+    return static_cast<u8>(c - 48);
 }
 
 [[nodiscard]] std::vector<u8> HexStringToVector(std::string_view str, bool little_endian);
@@ -32,28 +31,35 @@ namespace Common {
 template <std::size_t Size, bool le = false>
 [[nodiscard]] constexpr std::array<u8, Size> HexStringToArray(std::string_view str) {
     ASSERT_MSG(Size * 2 <= str.size(), "Invalid string size");
+
     std::array<u8, Size> out{};
     if constexpr (le) {
         for (std::size_t i = 2 * Size - 2; i <= 2 * Size; i -= 2) {
-            out[i / 2] = u8((ToHexNibble(str[i]) << 4) | ToHexNibble(str[i + 1]));
+            out[i / 2] = static_cast<u8>((ToHexNibble(str[i]) << 4) | ToHexNibble(str[i + 1]));
         }
     } else {
         for (std::size_t i = 0; i < 2 * Size; i += 2) {
-            out[i / 2] = u8((ToHexNibble(str[i]) << 4) | ToHexNibble(str[i + 1]));
+            out[i / 2] = static_cast<u8>((ToHexNibble(str[i]) << 4) | ToHexNibble(str[i + 1]));
         }
     }
     return out;
 }
 
 template <typename ContiguousContainer>
-    requires std::is_same_v<typename ContiguousContainer::value_type, u8>
 [[nodiscard]] std::string HexToString(const ContiguousContainer& data, bool upper = true) {
+    static_assert(std::is_same_v<typename ContiguousContainer::value_type, u8>,
+                  "Underlying type within the contiguous container must be u8.");
+
     constexpr std::size_t pad_width = 2;
+
     std::string out;
     out.reserve(std::size(data) * pad_width);
+
     const auto format_str = fmt::runtime(upper ? "{:02X}" : "{:02x}");
-    for (const u8 c : data)
+    for (const u8 c : data) {
         out += fmt::format(format_str, c);
+    }
+
     return out;
 }
 

src/common/host_memory.cpp

@@ -178,14 +178,6 @@ public:
         Release();
     }
 
-    void* Allocate(size_t size) {
-        auto* ptr = VirtualAlloc(nullptr, size, MEM_RESERVE | MEM_COMMIT, PAGE_READWRITE);
-        if (ptr == nullptr) {
-            LOG_CRITICAL(HW_Memory, "Failed to allocate fallback buffer with size {:#x}, error {}", size, GetLastError());
-        }
-        return ptr;
-    }
-
     void Map(size_t virtual_offset, size_t host_offset, size_t length, MemoryPermission perms) {
         std::unique_lock lock{placeholder_mutex};
         if (!IsNiechePlaceholder(virtual_offset, length)) {
@@ -406,10 +398,6 @@ private:
 // For managarm: see https://github.com/managarm/managarm/issues/1370
 #else // ^^^ Windows ^^^ vvv POSIX vvv
 
-#ifndef MAP_NOCORE
-#define MAP_NOCORE 0
-#endif
-
 #ifdef ARCHITECTURE_arm64
 
 static void* ChooseVirtualBase(size_t virtual_size) {
@@ -434,7 +422,7 @@ static void* ChooseVirtualBase(size_t virtual_size) {
         // Note: we may be able to take advantage of MAP_FIXED_NOREPLACE here.
         void* map_pointer =
             mmap(reinterpret_cast<void*>(hint_address), virtual_size, PROT_READ | PROT_WRITE,
-                 MAP_PRIVATE | MAP_ANONYMOUS | MAP_NORESERVE | MAP_NOCORE, -1, 0);
+                 MAP_PRIVATE | MAP_ANONYMOUS | MAP_NORESERVE, -1, 0);
 
         // If we successfully mapped, we're done.
         if (reinterpret_cast<uintptr_t>(map_pointer) == hint_address) {
@@ -454,11 +442,11 @@ static void* ChooseVirtualBase(size_t virtual_size) {
 
 static void* ChooseVirtualBase(size_t virtual_size) {
 #if defined(__FreeBSD__) || defined(__DragonFly__) || defined(__OpenBSD__) || defined(__sun__) || defined(__HAIKU__) || defined(__managarm__) || defined(__AIX__)
-    void* virtual_base = mmap(nullptr, virtual_size, PROT_READ | PROT_WRITE, MAP_PRIVATE | MAP_ANONYMOUS | MAP_NORESERVE | MAP_ALIGNED_SUPER | MAP_NOCORE, -1, 0);
+    void* virtual_base = mmap(nullptr, virtual_size, PROT_READ | PROT_WRITE, MAP_PRIVATE | MAP_ANONYMOUS | MAP_NORESERVE | MAP_ALIGNED_SUPER, -1, 0);
     if (virtual_base != MAP_FAILED)
         return virtual_base;
 #endif
-    return mmap(nullptr, virtual_size, PROT_READ | PROT_WRITE, MAP_PRIVATE | MAP_ANONYMOUS | MAP_NORESERVE | MAP_NOCORE, -1, 0);
+    return mmap(nullptr, virtual_size, PROT_READ | PROT_WRITE, MAP_PRIVATE | MAP_ANONYMOUS | MAP_NORESERVE, -1, 0);
 }
 
 #endif
@@ -552,13 +540,13 @@ public:
         }
         if (use_anon) {
             LOG_WARNING(Common_Memory, "Using private mappings instead of shared ones");
-            backing_base = static_cast<u8*>(mmap(nullptr, backing_size, PROT_READ | PROT_WRITE, MAP_ANONYMOUS | MAP_PRIVATE | MAP_NOCORE, -1, 0));
+            backing_base = static_cast<u8*>(mmap(nullptr, backing_size, PROT_READ | PROT_WRITE, MAP_ANONYMOUS | MAP_PRIVATE, -1, 0));
             if (fd > 0) {
                 fd = -1;
                 close(fd);
             }
         } else {
-            backing_base = static_cast<u8*>(mmap(nullptr, backing_size, PROT_READ | PROT_WRITE, MAP_SHARED | MAP_NOCORE, fd, 0));
+            backing_base = static_cast<u8*>(mmap(nullptr, backing_size, PROT_READ | PROT_WRITE, MAP_SHARED, fd, 0));
         }
         if (backing_base == MAP_FAILED) {
             LOG_CRITICAL(HW_Memory, "mmap failed: {}", strerror(errno));
@@ -582,14 +570,6 @@ public:
         Release();
     }
 
-    void* Allocate(size_t size) {
-        auto* ptr = mmap(nullptr, size, PROT_READ | PROT_WRITE, MAP_ANONYMOUS | MAP_PRIVATE, -1, 0);
-        if (ptr == MAP_FAILED) {
-            LOG_CRITICAL(HW_Memory, "Failed to allocate fallback buffer with size {:#x}, {}", size, strerror(errno));
-        }
-        return ptr;
-    }
-
     void Map(size_t virtual_offset, size_t host_offset, size_t length, MemoryPermission perms) {
         // Intersect the range with our address space.
         AdjustMap(&virtual_offset, &length);
@@ -710,10 +690,12 @@ HostMemory::HostMemory(size_t backing_size_, size_t virtual_size_)
 {
 #if defined(__OPENORBIS__) || defined(__managarm__)
     LOG_WARNING(HW_Memory, "Platform doesn't support fastmem");
-    backing_base = static_cast<u8*>(mmap(nullptr, backing_size, PROT_READ | PROT_WRITE, MAP_PRIVATE | MAP_ANONYMOUS, -1, 0));
+    fallback_buffer.emplace(backing_size);
+    backing_base = fallback_buffer->data();
     virtual_base = nullptr;
 #else
     // Try to allocate a fastmem arena.
+    // The implementation will fail with std::bad_alloc on errors.
     impl = std::make_unique<HostMemory::Impl>(AlignUp(backing_size, PageAlignment), AlignUp(virtual_size, PageAlignment) + HugePageSize);
     if (impl->Init()) {
         backing_base = impl->backing_base;
@@ -724,26 +706,16 @@ HostMemory::HostMemory(size_t backing_size_, size_t virtual_size_)
             virtual_base_offset = virtual_base - impl->virtual_base;
         }
     } else {
-        LOG_WARNING(HW_Memory, "Platform can support fastmem, but can't create it");
-        fallback_buffer = true;
-        backing_base = static_cast<u8*>(impl->Allocate(backing_size));
-        virtual_base = nullptr;
         impl.reset();
+        LOG_WARNING(HW_Memory, "Platform can support fastmem, but can't create it");
+        fallback_buffer.emplace(backing_size);
+        backing_base = fallback_buffer->data();
+        virtual_base = nullptr;
     }
 #endif
 }
 
-HostMemory::~HostMemory() {
-#ifdef _WIN32
-    if (fallback_buffer) {
-        VirtualFree(backing_base, backing_size, MEM_RELEASE);
-    }
-#else
-    if (fallback_buffer) {
-        munmap(backing_base, backing_size);
-    }
-#endif
-}
+HostMemory::~HostMemory() = default;
 
 HostMemory::HostMemory(HostMemory&&) noexcept = default;
 

src/common/host_memory.h

@@ -10,6 +10,7 @@
 #include <optional>
 #include "common/common_funcs.h"
 #include "common/common_types.h"
+#include "common/virtual_buffer.h"
 
 namespace Common {
 
@@ -85,7 +86,7 @@ private:
     u8* virtual_base{};
     size_t virtual_base_offset{};
     // Windows requires it for kernels whom lack proper support for some functions!
-    bool fallback_buffer{false};
+    std::optional<Common::VirtualBuffer<u8>> fallback_buffer;
 };
 
 } // namespace Common

src/common/logging.cpp

@@ -10,7 +10,6 @@
 #include <cstdlib>
 #include <regex>
 #include <thread>
-#include <boost/algorithm/string/predicate.hpp>
 
 #if defined(__ANDROID__)
 #include <android/log.h>
@@ -96,10 +95,9 @@ std::string FormatLogMessage(const Entry& entry) noexcept {
 
 template <typename It>
 Level GetLevelByName(const It begin, const It end) {
-    std::string_view const sv{begin, end};
     for (u32 i = 0; i < u32(Level::Count); ++i) {
-        auto const level_name = GetLevelName(Level(i));
-        if (boost::iequals(sv, level_name))
+        const char* level_name = GetLevelName(Level(i));
+        if (Common::ComparePartialString(begin, end, level_name))
             return Level(i);
     }
     return Level::Count;
@@ -107,10 +105,9 @@ Level GetLevelByName(const It begin, const It end) {
 
 template <typename It>
 Class GetClassByName(const It begin, const It end) {
-    std::string_view const sv{begin, end};
     for (u32 i = 0; i < u32(Class::Count); ++i) {
-        auto const level_name = GetLogClassName(Class(i));
-        if (boost::iequals(sv, level_name))
+        const char* level_name = GetLogClassName(Class(i));
+        if (Common::ComparePartialString(begin, end, level_name))
             return Class(i);
     }
     return Class::Count;
@@ -123,13 +120,12 @@ bool ParseFilterRule(Filter& instance, Iterator begin, Iterator end) {
         LOG_ERROR(Log, "Invalid log filter. Must specify a log level after `:`: {}", std::string(begin, end));
         return false;
     }
-    auto const sv = std::string_view{begin, level_separator};
-    auto const level = GetLevelByName(level_separator + 1, end);
+    const Level level = GetLevelByName(level_separator + 1, end);
     if (level == Level::Count) {
         LOG_ERROR(Log, "Unknown log level in filter: {}", std::string(begin, end));
         return false;
     }
-    if (boost::iequals(sv, "*")) {
+    if (Common::ComparePartialString(begin, level_separator, "*")) {
         instance.class_levels.fill(level);
         return true;
     }

src/common/make_unique_for_overwrite.h

@@ -0,0 +1,27 @@
+// SPDX-FileCopyrightText: Copyright 2022 yuzu Emulator Project
+// SPDX-License-Identifier: GPL-2.0-or-later
+
+#pragma once
+
+#include <memory>
+#include <type_traits>
+
+namespace Common {
+
+template <class T>
+    requires(!std::is_array_v<T>)
+std::unique_ptr<T> make_unique_for_overwrite() {
+    return std::unique_ptr<T>(new T);
+}
+
+template <class T>
+    requires std::is_unbounded_array_v<T>
+std::unique_ptr<T> make_unique_for_overwrite(std::size_t n) {
+    return std::unique_ptr<T>(new std::remove_extent_t<T>[n]);
+}
+
+template <class T, class... Args>
+    requires std::is_bounded_array_v<T>
+void make_unique_for_overwrite(Args&&...) = delete;
+
+} // namespace Common

src/common/page_table.cpp

@@ -1,4 +1,4 @@
-// SPDX-FileCopyrightText: Copyright 2026 Eden Emulator Project
+// SPDX-FileCopyrightText: Copyright 2025 Eden Emulator Project
 // SPDX-License-Identifier: GPL-3.0-or-later
 
 // SPDX-FileCopyrightText: Copyright 2019 yuzu Emulator Project
@@ -13,11 +13,39 @@ PageTable::PageTable() = default;
 
 PageTable::~PageTable() noexcept = default;
 
-void PageTable::Resize(std::size_t address_space_width_in_bits, std::size_t page_bits) {
-    auto const num_page_table_entries = 1ULL << (address_space_width_in_bits - page_bits);
-    entries.ResizeAndClear(num_page_table_entries);
+bool PageTable::BeginTraversal(TraversalEntry* out_entry, TraversalContext* out_context,
+                               Common::ProcessAddress address) const {
+    out_context->next_offset = GetInteger(address);
+    out_context->next_page = address / page_size;
+
+    return this->ContinueTraversal(out_entry, out_context);
+}
+
+bool PageTable::ContinueTraversal(TraversalEntry* out_entry, TraversalContext* context) const {
+    // Setup invalid defaults.
+    out_entry->phys_addr = 0;
+    out_entry->block_size = page_size;
+    // Validate that we can read the actual entry.
+    if (auto const page = context->next_page; page < entries.size()) {
+        // Validate that the entry is mapped.
+        if (auto const paddr = entries[page].addr; paddr != 0) {
+            // Populate the results.
+            out_entry->phys_addr = paddr + context->next_offset;
+            context->next_page += 1;
+            context->next_offset += page_size;
+            return true;
+        }
+    }
+    context->next_page += 1;
+    context->next_offset += page_size;
+    return false;
+}
+
+void PageTable::Resize(std::size_t address_space_width_in_bits, std::size_t page_size_in_bits) {
+    auto const num_page_table_entries = 1ULL << (address_space_width_in_bits - page_size_in_bits);
+    entries.resize(num_page_table_entries);
     current_address_space_width_in_bits = address_space_width_in_bits;
-    current_page_bits = page_bits;
+    page_size = 1ULL << page_size_in_bits;
 }
 
 } // namespace Common

src/common/page_table.h

@@ -9,22 +9,22 @@
 #include <atomic>
 
 #include "common/common_types.h"
-#include "common/sparse_large_vector.h"
 #include "common/typed_address.h"
+#include "common/virtual_buffer.h"
 
 namespace Common {
 
 enum class PageType : u8 {
     /// Page is unmapped and should cause an access error.
-    Unmapped = 0b00,
+    Unmapped,
     /// Page is mapped to regular memory. This is the only type you can get pointers to.
-    Memory = 0b01,
+    Memory,
     /// Page is mapped to regular memory, but inaccessible from CPU fastmem and must use
     /// the callbacks.
-    DebugMemory = 0b10,
+    DebugMemory,
     /// Page is mapped to regular memory, but also needs to check for rasterizer cache flushing and
     /// invalidation
-    RasterizerCachedMemory = 0b11,
+    RasterizerCachedMemory,
 };
 
 /**
@@ -42,86 +42,57 @@ struct PageTable {
         u64 next_offset{};
     };
 
-    /// Masks out bits reserved for attribute tagging.
-    static constexpr u64 ATTRIBUTE_MASK = ((1ULL << 44) - 1) << 12;
-
-    /// Specifies sign bit for page table entries.
-    static constexpr u64 SIGN_BIT = 45 + 12; // 44 bits of data + page offset
+    /// Number of bits reserved for attribute tagging.
+    /// This can be at most the guaranteed alignment of the pointers in the page table.
+    static constexpr int ATTRIBUTE_BITS = 2;
 
     /**
-     * Atomic tuple of host pointer, page type, and block id.
-     * This uses the lower bits of a given pointer to store the attributes.
+     * Pair of host pointer and page type attribute.
+     * This uses the lower bits of a given pointer to store the attribute tag.
      * Writing and reading the pointer attribute pair is guaranteed to be atomic for the same method
      * call. In other words, they are guaranteed to be synchronized at all times.
      */
-    class PageEntryData {
+    class PageInfo {
     public:
-        struct Data {
-            Data(bool marked_, PageType type_, u16 block_, u64 page_)
-                : marked(static_cast<u64>(marked_)       & 0b1)
-                , type(static_cast<u64>(type_)           & ((1ULL << 2) - 1))
-                , block(static_cast<u64>(block_)         & ((1ULL << 9) - 1))
-                , page((page_ >> 12)                     & ((1ULL << 45) - 1))
-                , block2((static_cast<u64>(block_) >> 9) & ((1ULL << 7) - 1)) {}
-            u64 marked : 1;
-            u64 type   : 2;
-            u64 block  : 9;
-            u64 page   : 45; // 44 bits of actual data (64 - page offset (12) - reserved (8)) + a sign bit
-            u64 block2 : 7;
-        };
-
-        [[nodiscard]] Data Raw() const noexcept {
-            return std::bit_cast<Data>(data_raw.load(std::memory_order_relaxed));
-        }
-
         /// Returns the page pointer
-        [[nodiscard]] uintptr_t Pointer(bool ignored_marked = false) const noexcept {
-            return ExtractPointer(std::bit_cast<Data>(data_raw.load(std::memory_order_relaxed)), ignored_marked);
+        [[nodiscard]] uintptr_t Pointer() const noexcept {
+            return ExtractPointer(raw.load(std::memory_order_relaxed));
         }
 
         /// Returns the page type attribute
         [[nodiscard]] PageType Type() const noexcept {
-            return static_cast<PageType>(std::bit_cast<Data>(data_raw.load(std::memory_order_relaxed)).type);
-        }
-
-        /// Returns the block identifier.
-        [[nodiscard]] u16 Block() const noexcept {
-            return ExtractBlock(std::bit_cast<Data>(data_raw.load(std::memory_order_relaxed)));
+            return ExtractType(raw.load(std::memory_order_relaxed));
         }
 
         /// Returns the page pointer and attribute pair, extracted from the same atomic read
-        [[nodiscard]] std::tuple<uintptr_t, PageType, u16> PointerTypeBlock(bool ignore_marked = false) const noexcept {
-            const auto non_atomic_raw = std::bit_cast<Data>(data_raw.load(std::memory_order_relaxed));
-            return {ExtractPointer(non_atomic_raw, ignore_marked), static_cast<PageType>(non_atomic_raw.type), ExtractBlock(non_atomic_raw)};
+        [[nodiscard]] std::pair<uintptr_t, PageType> PointerType() const noexcept {
+            const uintptr_t non_atomic_raw = raw.load(std::memory_order_relaxed);
+            return {ExtractPointer(non_atomic_raw), ExtractType(non_atomic_raw)};
         }
 
-        /// Write page info atomically
-        inline void Store(bool marked, PageType type, u16 block, uintptr_t pointer) noexcept {
-            data_raw.store(std::bit_cast<u64>(Data{marked, type, block, pointer}));
+        /// Returns the raw representation of the page information.
+        /// Use ExtractPointer and ExtractType to unpack the value.
+        [[nodiscard]] uintptr_t Raw() const noexcept {
+            return raw.load(std::memory_order_relaxed);
         }
 
-        inline void MarkRasterizerCached() noexcept {
-            data_raw.fetch_or(0b111);
-        }
-
-        inline void MarkDebug(u64 ptr, u16 block) noexcept {
-            Store(true, PageType::DebugMemory, block, ptr);
+        /// Write a page pointer and type pair atomically
+        void Store(uintptr_t pointer, PageType type) noexcept {
+            raw.store(pointer | uintptr_t(type));
         }
 
         /// Unpack a pointer from a page info raw representation
-        [[nodiscard]] static uintptr_t ExtractPointer(Data raw, bool ignore_marked = false) noexcept {
-            return raw.marked && !ignore_marked ? 0
-                // shift raw.page's fake sign bit to the actual sign bit, then sign extend
-                : ((s64)(raw.page << (64 - 44))) >> (64 - 44 - 12);
+        [[nodiscard]] static uintptr_t ExtractPointer(uintptr_t raw) noexcept {
+            return raw & (~uintptr_t{0} << ATTRIBUTE_BITS);
         }
 
-        [[nodiscard]] static u16 ExtractBlock(Data raw) noexcept {
-            return static_cast<u16>(raw.block | (raw.block2 << 9));
+        /// Unpack a page type from a page info raw representation
+        [[nodiscard]] static PageType ExtractType(uintptr_t raw) noexcept {
+            return static_cast<PageType>(raw & ((uintptr_t{1} << ATTRIBUTE_BITS) - 1));
         }
 
     private:
-        std::atomic<u64> data_raw;
-        static_assert(sizeof(Data) == sizeof(std::atomic<u64>));
+        std::atomic<uintptr_t> raw;
     };
 
     PageTable();
@@ -129,8 +100,13 @@ struct PageTable {
 
     PageTable(const PageTable&) = delete;
     PageTable& operator=(const PageTable&) = delete;
-    PageTable(PageTable&&) noexcept = delete;
-    PageTable& operator=(PageTable&&) noexcept = delete;
+
+    PageTable(PageTable&&) noexcept = default;
+    PageTable& operator=(PageTable&&) noexcept = default;
+
+    bool BeginTraversal(TraversalEntry* out_entry, TraversalContext* out_context,
+                        Common::ProcessAddress address) const;
+    bool ContinueTraversal(TraversalEntry* out_entry, TraversalContext* context) const;
 
     /**
      * Resizes the page table to be able to accommodate enough pages within
@@ -145,14 +121,30 @@ struct PageTable {
         return current_address_space_width_in_bits;
     }
 
+    bool GetPhysicalAddress(Common::PhysicalAddress* out_phys_addr,
+                            Common::ProcessAddress virt_addr) const {
+        if (virt_addr > (1ULL << this->GetAddressSpaceBits())) {
+            return false;
+        }
+
+        *out_phys_addr = entries[virt_addr / page_size].addr + GetInteger(virt_addr);
+        return true;
+    }
+
     /// Vector of memory pointers backing each page. An entry can only be non-null if the
     /// corresponding attribute element is of type `Memory`.
-    SparseLargeVector<PageEntryData> entries;
-    static_assert(sizeof(PageEntryData) == 8);
+    struct PageEntryData {
+        PageInfo ptr;
+        u64 block;
+        u64 addr;
+        u64 padding;
+    };
+    VirtualBuffer<PageEntryData> entries;
+    static_assert(sizeof(PageEntryData) == 32);
 
     u8* fastmem_arena{};
     std::size_t current_address_space_width_in_bits{};
-    std::size_t current_page_bits{};
+    std::size_t page_size{};
 };
 
 } // namespace Common

src/common/param_package.cpp

@@ -8,9 +8,6 @@
 #include <stdexcept>
 #include <utility>
 #include <vector>
-#include <boost/algorithm/string/classification.hpp>
-#include <boost/algorithm/string/replace.hpp>
-#include <boost/algorithm/string/split.hpp>
 
 #include "common/logging.h"
 #include "common/param_package.h"
@@ -18,16 +15,17 @@
 
 namespace Common {
 
-constexpr auto KEY_VALUE_SEPARATOR = ":";
-constexpr auto PARAM_SEPARATOR = ",";
-constexpr auto ESCAPE_CHARACTER = "$";
-constexpr auto KEY_VALUE_SEPARATOR_ESCAPE = "$0";
-constexpr auto PARAM_SEPARATOR_ESCAPE = "$1";
-constexpr auto ESCAPE_CHARACTER_ESCAPE = "$2";
+constexpr char KEY_VALUE_SEPARATOR = ':';
+constexpr char PARAM_SEPARATOR = ',';
+
+constexpr char ESCAPE_CHARACTER = '$';
+constexpr char KEY_VALUE_SEPARATOR_ESCAPE[] = "$0";
+constexpr char PARAM_SEPARATOR_ESCAPE[] = "$1";
+constexpr char ESCAPE_CHARACTER_ESCAPE[] = "$2";
 
 /// A placeholder for empty param packages to avoid empty strings
 /// (they may be recognized as "not set" by some frontend libraries like qt)
-constexpr auto EMPTY_PLACEHOLDER = "[empty]";
+constexpr char EMPTY_PLACEHOLDER[] = "[empty]";
 
 ParamPackage::ParamPackage(const std::string& serialized) {
     if (serialized == EMPTY_PLACEHOLDER) {
@@ -35,20 +33,20 @@ ParamPackage::ParamPackage(const std::string& serialized) {
     }
 
     std::vector<std::string> pairs;
-    boost::split(pairs, serialized, boost::is_any_of(PARAM_SEPARATOR));
+    Common::SplitString(serialized, PARAM_SEPARATOR, pairs);
 
     for (const std::string& pair : pairs) {
         std::vector<std::string> key_value;
-        boost::split(key_value, pair, boost::is_any_of(KEY_VALUE_SEPARATOR));
+        Common::SplitString(pair, KEY_VALUE_SEPARATOR, key_value);
         if (key_value.size() != 2) {
             LOG_ERROR(Common, "invalid key pair {}", pair);
             continue;
         }
 
-        for (auto& part : key_value) {
-            boost::replace_all(part, KEY_VALUE_SEPARATOR_ESCAPE, KEY_VALUE_SEPARATOR);
-            boost::replace_all(part, PARAM_SEPARATOR_ESCAPE, PARAM_SEPARATOR);
-            boost::replace_all(part, ESCAPE_CHARACTER_ESCAPE, ESCAPE_CHARACTER);
+        for (std::string& part : key_value) {
+            part = Common::ReplaceAll(part, KEY_VALUE_SEPARATOR_ESCAPE, {KEY_VALUE_SEPARATOR});
+            part = Common::ReplaceAll(part, PARAM_SEPARATOR_ESCAPE, {PARAM_SEPARATOR});
+            part = Common::ReplaceAll(part, ESCAPE_CHARACTER_ESCAPE, {ESCAPE_CHARACTER});
         }
 
         Set(key_value[0], std::move(key_value[1]));
@@ -65,10 +63,10 @@ std::string ParamPackage::Serialize() const {
 
     for (const auto& pair : data) {
         std::array<std::string, 2> key_value{{pair.first, pair.second}};
-        for (auto& part : key_value) {
-            boost::replace_all(part, ESCAPE_CHARACTER, ESCAPE_CHARACTER_ESCAPE);
-            boost::replace_all(part, PARAM_SEPARATOR, PARAM_SEPARATOR_ESCAPE);
-            boost::replace_all(part, KEY_VALUE_SEPARATOR, KEY_VALUE_SEPARATOR_ESCAPE);
+        for (std::string& part : key_value) {
+            part = Common::ReplaceAll(part, {ESCAPE_CHARACTER}, ESCAPE_CHARACTER_ESCAPE);
+            part = Common::ReplaceAll(part, {PARAM_SEPARATOR}, PARAM_SEPARATOR_ESCAPE);
+            part = Common::ReplaceAll(part, {KEY_VALUE_SEPARATOR}, KEY_VALUE_SEPARATOR_ESCAPE);
         }
         result += key_value[0] + KEY_VALUE_SEPARATOR + key_value[1] + PARAM_SEPARATOR;
     }

src/common/scratch_buffer.h

@@ -8,7 +8,8 @@
 
 #include <iterator>
 #include <cstring>
-#include <memory>
+
+#include "common/make_unique_for_overwrite.h"
 
 namespace Common {
 
@@ -37,9 +38,8 @@ public:
     ScratchBuffer() = default;
 
     explicit ScratchBuffer(size_type initial_capacity)
-        : last_requested_size{initial_capacity}
-        , buffer_capacity{initial_capacity}
-        , buffer{std::make_unique_for_overwrite<T[]>(initial_capacity)} {}
+        : last_requested_size{initial_capacity}, buffer_capacity{initial_capacity},
+          buffer{Common::make_unique_for_overwrite<T[]>(initial_capacity)} {}
 
     ~ScratchBuffer() = default;
     ScratchBuffer(const ScratchBuffer&) = delete;
@@ -64,7 +64,7 @@ public:
     /// The previously held data will remain intact.
     void resize(size_type size) {
         if (size > buffer_capacity) {
-            auto new_buffer = std::make_unique_for_overwrite<T[]>(size);
+            auto new_buffer = Common::make_unique_for_overwrite<T[]>(size);
             std::memcpy(new_buffer.get(), buffer.get(), buffer_capacity * sizeof(T));
             buffer = std::move(new_buffer);
             buffer_capacity = size;
@@ -77,7 +77,7 @@ public:
     void resize_destructive(size_type size) {
         if (size > buffer_capacity) {
             buffer_capacity = size;
-            buffer = std::make_unique_for_overwrite<T[]>(buffer_capacity);
+            buffer = Common::make_unique_for_overwrite<T[]>(buffer_capacity);
         }
         last_requested_size = size;
     }

src/common/settings.cpp

@@ -178,6 +178,10 @@ bool IsGPUFenceBehaviorAccurate() {
     return values.gpu_fence_behavior.GetValue() == GpuFenceBehavior::Accurate;
 }
 
+bool IsGPUFenceBehaviorStrict() {
+    return values.gpu_fence_behavior.GetValue() == GpuFenceBehavior::Strict;
+}
+
 bool IsFastmemEnabled() {
     if (values.cpu_accuracy.GetValue() == Settings::CpuAccuracy::Debugging)
         return bool(values.cpuopt_fastmem);

src/common/settings.h

@@ -525,7 +525,7 @@ struct Values {
     SwitchableSetting<GpuFenceBehavior, true> gpu_fence_behavior{linkage,
                                                                  GpuFenceBehavior::Default,
                                                                  GpuFenceBehavior::Default,
-                                                                 GpuFenceBehavior::Accurate,
+                                                                 GpuFenceBehavior::Strict,
                                                                  "gpu_fence_behavior",
                                                                  Category::RendererAdvanced,
                                                                  Specialization::Default,
@@ -655,6 +655,13 @@ struct Values {
 
     SwitchableSetting<bool> rescale_hack{linkage, false, "rescale_hack",
                                          Category::RendererHacks};
+    SwitchableSetting<bool> enable_gpu_buffer_readback{linkage,
+                                                       false,
+                                                       "enable_gpu_buffer_readback",
+                                                       Category::RendererAdvanced,
+                                                       Specialization::Default,
+                                                       true,
+                                                       true};
 
     SwitchableSetting<bool> use_asynchronous_shaders{linkage, false, "use_asynchronous_shaders",
                                                      Category::RendererHacks};
@@ -972,6 +979,7 @@ bool IsDMALevelSafe();
 bool IsGPUFenceBehaviorDefault();
 bool IsGPUFenceBehaviorBalanced();
 bool IsGPUFenceBehaviorAccurate();
+bool IsGPUFenceBehaviorStrict();
 
 bool IsFastmemEnabled();
 void SetNceEnabled(bool is_64bit);

src/common/settings_enums.h

@@ -137,7 +137,7 @@ ENUM(VramUsageMode, Conservative, Aggressive);
 ENUM(RendererBackend, OpenGL_GLSL, Vulkan, Null, OpenGL_GLASM, OpenGL_SPIRV);
 ENUM(GpuAccuracy, Low, High);
 ENUM(DmaAccuracy, Default, Unsafe, Safe);
-ENUM(GpuFenceBehavior, Default, Immediate, Balanced, Accurate);
+ENUM(GpuFenceBehavior, Default, Immediate, Balanced, Accurate, Strict);
 ENUM(CpuBackend, Dynarmic, Nce);
 ENUM(CpuAccuracy, Auto, Accurate, Unsafe, Paranoid, Debugging);
 ENUM(CpuClock, Normal, Boost, Overclock)

src/common/sparse_large_vector.cpp

@@ -1,174 +0,0 @@
-// SPDX-FileCopyrightText: Copyright 2026 Eden Emulator Project
-// SPDX-License-Identifier: GPL-3.0-or-later
-
-/* virtual_buffer.cpp */
-// SPDX-FileCopyrightText: Copyright 2020 yuzu Emulator Project
-// SPDX-License-Identifier: GPL-2.0-or-later
-
-#ifdef _WIN32
-#include <algorithm>
-#include <windows.h>
-#include <mutex>
-#else
-#include <sys/mman.h>
-#endif
-
-#include "common/alignment.h"
-#include "common/assert.h"
-#include "common/sparse_large_vector.h"
-
-namespace Common {
-
-#ifdef _WIN32
-static std::vector<std::pair<u64, u64>> vector_regions {};
-static std::mutex vector_regions_mutex {};
-
-// Workaround for handling non-commited memory accessed by Dynarmic; usually result of an error
-static LONG WINAPI FakePageFaultHandler(PEXCEPTION_POINTERS info) {
-    DWORD code = info->ExceptionRecord->ExceptionCode;
-    u64 exception_addr = reinterpret_cast<u64>(info->ExceptionRecord->ExceptionInformation[1]);
-
-    if (code != EXCEPTION_ACCESS_VIOLATION || info->ExceptionRecord->ExceptionInformation[0] == 1) {
-        // Not our problem
-        return EXCEPTION_CONTINUE_SEARCH;
-    }
-
-    u64 addr = 0, addr2 = 0;
-
-    {
-        std::lock_guard lock(vector_regions_mutex);
-        for (auto region: vector_regions) {
-            auto addr_shifted = exception_addr >> HostPageBits;
-            if (region.first <= addr_shifted && addr_shifted <= region.second) {
-                addr = addr_shifted;
-            }
-
-            // Page-boundary accesses
-            if (auto addr_ = (exception_addr + 0x40) >> HostPageBits; addr_ != addr_shifted && region.first <= addr_ && addr_ <= region.second) {
-                addr2 = addr_;
-            }
-
-            if (addr != 0 || addr2 != 0) {
-                break;
-            }
-        }
-    }
-
-    if (addr == 0 && addr2 == 0) {
-        // Not our problem
-        return EXCEPTION_CONTINUE_SEARCH;
-    }
-
-    LOG_ERROR(HW_Memory, "Accessing an unallocated region of a SparseLargeVector at {:#x}; this shouldn't happen and is likely a Dynarmic error!", exception_addr);
-
-    // Commit this region
-    if (addr != 0) {
-        if (!CommitVectorPage(addr << HostPageBits, false)) {
-            return EXCEPTION_CONTINUE_SEARCH;
-        }
-    }
-    // Commit next region if needed
-    if (addr2 != 0) {
-        if (!CommitVectorPage(addr2 << HostPageBits, false)) {
-            return EXCEPTION_CONTINUE_SEARCH;
-        }
-    }
-
-    return EXCEPTION_CONTINUE_EXECUTION;
-}
-
-bool CommitVectorPage(uintptr_t addr, bool write) noexcept {
-    MEMORY_BASIC_INFORMATION info {};
-    auto res = VirtualQuery(reinterpret_cast<void*>(addr), &info, sizeof(info));
-    if (res == 0) {
-        LOG_CRITICAL(HW_Memory, "Failed to query large buffer region at {:#x} with error {}, will try committing anyway", addr, GetLastError());
-    } else if (info.State == MEM_COMMIT) {
-        DWORD old_protect {};
-        auto perm = write ? PAGE_READWRITE : PAGE_READONLY;
-        if (!VirtualProtect(reinterpret_cast<void*>(addr), HostPageSize, perm, &old_protect)) {
-            LOG_ERROR(HW_Memory, "Failed to change permissions of large buffer region at {:#x}, error {}", addr, GetLastError());
-            return false;
-        }
-        return true;
-    } else if (info.State != MEM_RESERVE) {
-        LOG_ERROR(HW_Memory, "Tried to commit an unreserved large buffer region at {:#x} that is not mapped (state {:#x})", addr, info.State);
-        return false;
-    }
-
-    auto perm = write ? PAGE_READWRITE : PAGE_READONLY;
-    void* res2 = VirtualAlloc(reinterpret_cast<LPVOID>(addr), HostPageSize, MEM_COMMIT, perm);
-    if (res2 == nullptr) {
-        LOG_ERROR(HW_Memory, "Failed to commit large buffer region at {:#x}, error {}", addr, GetLastError());
-        return false;
-    }
-
-    return true;
-}
-#endif
-
-#ifndef MAP_NOCORE
-#define MAP_NOCORE 0
-#endif
-#ifndef MADV_FREE
-#define MADV_FREE MADV_DONTNEED
-#endif
-
-void DecommitVectorPage(uintptr_t base) noexcept {
-#if defined(_WIN32)
-    VirtualFree(reinterpret_cast<LPVOID>(base), HostPageSize, MEM_DECOMMIT);
-#elif defined(__linux__)
-    // Linux's MADV_DONTNEED zeros out pages for us
-    madvise(reinterpret_cast<void*>(base), HostPageSize, MADV_DONTNEED);
-#else
-    madvise(reinterpret_cast<void*>(base), HostPageSize, MADV_FREE);
-    std::memset(reinterpret_cast<void*>(base), 0, HostPageSize);
-#endif
-}
-
-void* AllocateMemoryPages(std::size_t size) noexcept {
-    if (auto page = HostPageSize; size % page != 0) {
-        LOG_WARNING(HW_Memory, "Allocating unaligned large vector with size {:#x}; aligning to {} page size", size, page);
-        size = AlignUp(size, page);
-    }
-
-#ifdef _WIN32
-    // We will never use this memory entirely so instead of committing it up front let's just reserve it and commit each page individually
-    void* base = VirtualAlloc(nullptr, size, MEM_RESERVE, PAGE_READWRITE);
-
-    if (base != nullptr) {
-        std::lock_guard lock(vector_regions_mutex);
-        vector_regions.emplace_back(reinterpret_cast<u64>(base) >> HostPageBits, (reinterpret_cast<u64>(base) + size) >> HostPageBits);
-
-        static std::once_flag flag;
-        std::call_once(flag, []() { AddVectoredExceptionHandler(1, FakePageFaultHandler); });
-    } else {
-        // Try committing everything instead??
-        LOG_WARNING(HW_Memory, "Failed to reserve large vector region with error {}, trying to commit instead..", GetLastError());
-        base = VirtualAlloc(nullptr, size, MEM_COMMIT, PAGE_READWRITE);
-    }
-    ASSERT_MSG(base, "Failed to reserve {:#x} sized region with error {}", size, GetLastError());
-#else
-    void* base = mmap(nullptr, size, PROT_READ, MAP_ANON | MAP_PRIVATE | MAP_NOCORE, -1, 0);
-    if (base == MAP_FAILED)
-        base = nullptr;
-    ASSERT_MSG(base, "Failed to allocate {:#x} sized region with error {}", size, strerror(errno));
-#endif
-    return base;
-}
-
-void FreeMemoryPages(void* base, [[maybe_unused]] std::size_t size) noexcept {
-    if (auto page = HostPageSize; size % page != 0) {
-        size = AlignUp(size, page);
-    }
-    if (!base)
-        return;
-#ifdef _WIN32
-    std::lock_guard lock(vector_regions_mutex);
-    std::erase_if(vector_regions, [base](const auto& r) {return r.first == reinterpret_cast<u64>(base); });
-    ASSERT(VirtualFree(base, 0, MEM_RELEASE));
-#else
-    ASSERT(munmap(base, size) == 0);
-#endif
-}
-
-} // namespace Common

src/common/sparse_large_vector.h

@@ -1,214 +0,0 @@
-// SPDX-FileCopyrightText: Copyright 2026 Eden Emulator Project
-// SPDX-License-Identifier: GPL-3.0-or-later
-
-/* virtual_buffer.h */
-// SPDX-FileCopyrightText: Copyright 2020 yuzu Emulator Project
-// SPDX-License-Identifier: GPL-2.0-or-later
-
-#pragma once
-
-#include <atomic>
-#include <bit>
-#include <utility>
-#include <vector>
-
-#ifndef _WIN32
-#include <unistd.h>
-#include <sys/mman.h>
-#endif
-
-#include "common/alignment.h"
-#include "common/assert.h"
-
-namespace Common {
-
-#ifdef _WIN32
-constexpr u64 HostPageSize = 0x1000;
-constexpr u64 HostPageBits = 12;
-constexpr u64 HostPageMask = ~(HostPageSize - 1);
-bool CommitVectorPage(uintptr_t addr, bool write) noexcept;
-#else
-inline const u64 HostPageSize = sysconf(_SC_PAGESIZE);
-inline const u64 HostPageBits = std::countr_zero(HostPageSize);
-inline const u64 HostPageMask = ~(HostPageSize - 1);
-#endif
-
-void* AllocateMemoryPages(std::size_t size) noexcept;
-void FreeMemoryPages(void* base, std::size_t size) noexcept;
-void DecommitVectorPage(uintptr_t base) noexcept;
-
-/// A large page-aligned buffer that has optimized memory usage for zero-writes.
-template <typename T>
-    // MSVC doesn't regard structs with atomics as trivially copyable
-    // requires std::is_trivially_copyable_v<T>
-class SparseLargeVector final {
-public:
-    constexpr SparseLargeVector() = default;
-
-    explicit SparseLargeVector(std::size_t count) noexcept
-        : alloc_size{count * sizeof(T)}
-    {
-        base_ptr = static_cast<T*>(AllocateMemoryPages(alloc_size));
-
-        // each item in vector holds information for 64 pages
-        auto denom = HostPageSize * 64;
-        committed_pages = std::vector<std::atomic<u64>>((alloc_size + denom - 1) / denom);
-    }
-
-    ~SparseLargeVector() noexcept {
-        FreeMemoryPages(base_ptr, alloc_size);
-    }
-
-    SparseLargeVector(const SparseLargeVector&) = delete;
-    SparseLargeVector& operator=(const SparseLargeVector&) = delete;
-    SparseLargeVector(SparseLargeVector&& other) = delete;
-    SparseLargeVector& operator=(SparseLargeVector&& other) = delete;
-
-    void ResizeAndClear(std::size_t count) noexcept {
-        if (auto const new_size = count * sizeof(T); new_size != alloc_size) {
-            FreeMemoryPages(base_ptr, alloc_size);
-            alloc_size = new_size;
-            base_ptr = static_cast<T*>(AllocateMemoryPages(alloc_size));
-
-            auto denom = HostPageSize * 64;
-            committed_pages = std::vector<std::atomic<u64>>((alloc_size + denom - 1) / denom);
-        }
-    }
-
-    /// Returns a reference to the value of the requested index and allocates memory if needed.
-    T& GetAndFault(std::size_t index) noexcept {
-        if (index > alloc_size / sizeof(T)) {
-            UNREACHABLE_MSG("Out of bounds RW access on SparseLargeVector @ {}", index);
-        }
-
-        if (!IsCommittedPage(index) && !CommitPage(index)) {
-            UNREACHABLE_MSG("Cannot access SparseLargeVector index {} with RW permission", index);
-        }
-        return base_ptr[index];
-    }
-
-    /// Returns a reference to the value of the requested index if initialized, or will otherwise return a zero-initialized object.
-    const T& GetOrDefault(std::size_t index) const {
-#ifdef _WIN32
-        if (!IsCommittedPage(index)) {
-            return *reinterpret_cast<const T*>(&default_val);
-        }
-#endif
-        // On non-Windows, OS page table should optimize this by pointing to a zero page if unallocated.
-        return base_ptr[index];
-    }
-
-    void Set(std::size_t index, const T& value) noexcept {
-        if (index > alloc_size / sizeof(T)) {
-            LOG_CRITICAL(Common_Memory, "Out of bounds write on SparseLargeVector @ {}", index);
-            return;
-        }
-        if (IsCommittedPage(index) || CommitPage(index))
-            base_ptr[index] = value;
-    }
-
-    void ZeroRegion(std::size_t start, std::size_t end_) noexcept {
-        u64 base = reinterpret_cast<u64>(&base_ptr[start]);
-        const u64 end = reinterpret_cast<u64>(&base_ptr[end_]);
-
-        const u64 end_page = AlignUp(base, HostPageSize);
-        const u64 first_size = (std::min)(end_page, end) - base;
-
-        if (IsCommittedPage(start)) {
-            std::memset(reinterpret_cast<void*>(base), 0, first_size);
-        }
-
-        if (end <= end_page)
-            return;
-
-        base = end_page;
-
-        for (u64 page = base; page < end; page += HostPageSize) {
-            auto index = (page - reinterpret_cast<u64>(base_ptr)) / sizeof(T);
-            if (!IsCommittedPage(index)) {
-                continue;
-            }
-
-            if (end - page >= HostPageSize) {
-                DecommitPage(index);
-            } else {
-                std::memset(reinterpret_cast<void*>(page), 0, end - page);
-            }
-        }
-    }
-
-    constexpr void CommitRegion(size_t index, size_t end_) {
-        const u64 base = static_cast<u64>(index) * sizeof(T);
-        const u64 end = static_cast<u64>(end_) * sizeof(T);
-
-        for (u64 page = AlignDown(base, HostPageSize); page < end; page += HostPageSize) {
-            if (!IsCommittedPage(page / sizeof(T))) {
-                CommitPage(page / sizeof(T));
-            }
-        }
-    }
-
-    constexpr T& GetUnchecked(size_t index) {
-        return base_ptr[index];
-    }
-
-    [[nodiscard]] constexpr const T& operator[](std::size_t index) const noexcept {
-        return GetOrDefault(index);
-    }
-
-    [[nodiscard]] constexpr const T* data() const noexcept {
-        return base_ptr;
-    }
-
-    [[nodiscard]] constexpr std::size_t size() const noexcept {
-        return alloc_size / sizeof(T);
-    }
-
-private:
-    [[nodiscard]] constexpr bool IsCommittedPage(std::size_t index) const noexcept {
-        if (index > alloc_size / sizeof(T)) {
-            LOG_CRITICAL(Common_Memory, "Out of bounds access on large vector @ {}", index);
-            return false;
-        }
-
-        auto page = (index * sizeof(T)) >> HostPageBits;
-        auto val = committed_pages[page >> 6].load(std::memory_order_acquire);
-        return (val >> (page & 63)) & 1;
-    }
-
-    constexpr bool CommitPage(std::size_t index) noexcept {
-        auto page_index = (index * sizeof(T)) >> HostPageBits;
-        auto page = reinterpret_cast<uintptr_t>(base_ptr + index) & HostPageMask;
-#if defined(_WIN32)
-        if (!CommitVectorPage(page, true)) {
-            return false;
-        }
-#else
-        if (mprotect(reinterpret_cast<void*>(page), HostPageSize, PROT_READ | PROT_WRITE) != 0) {
-            LOG_ERROR(Common_Memory, "Failed to commit large buffer region at index {}, error {}", index, strerror(errno));
-            return false;
-        }
-#endif
-
-        committed_pages[page_index >> 6].fetch_or(1ULL << (page_index & 63), std::memory_order_release);
-        return true;
-    }
-
-    constexpr void DecommitPage(std::size_t index) noexcept {
-        auto page_index = (index * sizeof(T)) >> HostPageBits;
-        auto page = reinterpret_cast<uintptr_t>(base_ptr + index) & HostPageMask;
-
-        committed_pages[page_index >> 6].fetch_and(~(1ULL << (page_index & 63)), std::memory_order_release);
-        DecommitVectorPage(page);
-    }
-
-    std::size_t alloc_size{};
-    T* base_ptr{};
-
-    std::vector<std::atomic<u64>> committed_pages{};
-#ifdef _WIN32
-    const std::array<u8, sizeof(T)> default_val{};
-#endif
-};
-
-} // namespace Common

src/common/string_util.cpp

@@ -24,6 +24,22 @@
 
 namespace Common {
 
+/// Make a string lowercase
+std::string ToLower(const std::string_view sv) {
+    std::string str{sv};
+    std::transform(str.begin(), str.end(), str.begin(),
+                   [](auto const c) { return char(std::tolower(c)); });
+    return str;
+}
+
+/// Make a string uppercase
+std::string ToUpper(const std::string_view sv) {
+    std::string str{sv};
+    std::transform(str.begin(), str.end(), str.begin(),
+                   [](auto const c) { return char(std::toupper(c)); });
+    return str;
+}
+
 bool SplitPath(const std::string& full_path, std::string* _pPath, std::string* _pFilename,
                std::string* _pExtension) {
     if (full_path.empty())
@@ -64,6 +80,41 @@ bool SplitPath(const std::string& full_path, std::string* _pPath, std::string* _
     return true;
 }
 
+void SplitString(const std::string& str, const char delim, std::vector<std::string>& output) {
+    std::istringstream iss(str);
+    output.resize(1);
+
+    while (std::getline(iss, *output.rbegin(), delim)) {
+        output.emplace_back();
+    }
+
+    output.pop_back();
+}
+
+std::string TabsToSpaces(int tab_size, std::string in) {
+    std::size_t i = 0;
+
+    while ((i = in.find('\t')) != std::string::npos) {
+        in.replace(i, 1, tab_size, ' ');
+    }
+
+    return in;
+}
+
+std::string ReplaceAll(std::string result, const std::string& src, const std::string& dest) {
+    std::size_t pos = 0;
+
+    if (src == dest)
+        return result;
+
+    while ((pos = result.find(src, pos)) != std::string::npos) {
+        result.replace(pos, src.size(), dest);
+        pos += dest.length();
+    }
+
+    return result;
+}
+
 std::string UTF16ToUTF8(std::u16string_view input) {
     std::wstring_convert<std::codecvt_utf8_utf16<char16_t>, char16_t> convert;
     return convert.to_bytes(input.data(), input.data() + input.size());

src/common/string_util.h

@@ -1,4 +1,4 @@
-// SPDX-FileCopyrightText: Copyright 2026 Eden Emulator Project
+// SPDX-FileCopyrightText: Copyright 2025 Eden Emulator Project
 // SPDX-License-Identifier: GPL-3.0-or-later
 
 // SPDX-FileCopyrightText: 2013 Dolphin Emulator Project
@@ -16,6 +16,12 @@
 
 namespace Common {
 
+/// Make a string lowercase
+[[nodiscard]] std::string ToLower(const std::string_view sv);
+
+/// Make a string uppercase
+[[nodiscard]] std::string ToUpper(const std::string_view sv);
+
 [[nodiscard]] inline std::string StringFromBuffer(std::span<const u8> data) noexcept {
     return std::string(data.begin(), std::find(data.begin(), data.end(), '\0'));
 }
@@ -23,8 +29,37 @@ namespace Common {
     return std::string(data.begin(), std::find(data.begin(), data.end(), '\0'));
 }
 
+/// Turns "  hej " into "hej". Also handles tabs.
+[[nodiscard]] inline std::string StripSpaces(const std::string_view str) noexcept {
+    const std::size_t s = str.find_first_not_of(" \t\r\n");
+    if (str.npos != s)
+        return std::string{str.substr(s, str.find_last_not_of(" \t\r\n") - s + 1)};
+    return {};
+}
+
+/// "\"hello\"" is turned to "hello"
+/// This one assumes that the string has already been space stripped in both
+/// ends, as done by StripSpaces above, for example.
+[[nodiscard]] inline std::string StripQuotes(const std::string_view s) noexcept {
+    if (s.size() && '\"' == s[0] && '\"' == *s.rbegin())
+        return std::string{s.substr(1, s.size() - 2)};
+    return std::string{s};
+}
+
+[[nodiscard]] inline std::string StringFromBool(bool value) noexcept {
+    return value ? "True" : "False";
+}
+
+[[nodiscard]] std::string TabsToSpaces(int tab_size, std::string in);
+
+void SplitString(const std::string& str, char delim, std::vector<std::string>& output);
+
 // "C:/Windows/winhelp.exe" to "C:/Windows/", "winhelp", ".exe"
-bool SplitPath(const std::string& full_path, std::string* _pPath, std::string* _pFilename, std::string* _pExtension);
+bool SplitPath(const std::string& full_path, std::string* _pPath, std::string* _pFilename,
+               std::string* _pExtension);
+
+[[nodiscard]] std::string ReplaceAll(std::string result, const std::string& src,
+                                     const std::string& dest);
 
 [[nodiscard]] std::string UTF16ToUTF8(std::u16string_view input);
 [[nodiscard]] std::u16string UTF8ToUTF16(std::string_view input);
@@ -38,13 +73,30 @@ bool SplitPath(const std::string& full_path, std::string* _pPath, std::string* _
 
 [[nodiscard]] std::u16string U16StringFromBuffer(const u16* input, std::size_t length);
 
+/**
+ * Compares the string defined by the range [`begin`, `end`) to the null-terminated C-string
+ * `other` for equality.
+ */
+template <typename InIt>
+[[nodiscard]] inline bool ComparePartialString(InIt begin, InIt end, const char* other) noexcept {
+    for (; begin != end && *other != '\0'; ++begin, ++other) {
+        if (*begin != *other) {
+            return false;
+        }
+    }
+    // Only return true if both strings finished at the same point
+    return (begin == end) == (*other == '\0');
+}
+
 /// Creates a std::string from a fixed-size NUL-terminated char buffer. If the buffer isn't
 /// NUL-terminated then the string ends at max_len characters.
-[[nodiscard]] std::string StringFromFixedZeroTerminatedBuffer(std::string_view buffer, std::size_t max_len);
+[[nodiscard]] std::string StringFromFixedZeroTerminatedBuffer(std::string_view buffer,
+                                                              std::size_t max_len);
 
 /// Creates a UTF-16 std::u16string from a fixed-size NUL-terminated char buffer. If the buffer isn't
 /// null-terminated, then the string ends at the greatest multiple of two less then or equal to
 /// max_len_bytes.
-[[nodiscard]] std::u16string UTF16StringFromFixedZeroTerminatedBuffer(std::u16string_view buffer, std::size_t max_len);
+[[nodiscard]] std::u16string UTF16StringFromFixedZeroTerminatedBuffer(std::u16string_view buffer,
+                                                                      std::size_t max_len);
 
 } // namespace Common

src/common/virtual_buffer.cpp

@@ -0,0 +1,44 @@
+// SPDX-FileCopyrightText: Copyright 2026 Eden Emulator Project
+// SPDX-License-Identifier: GPL-3.0-or-later
+
+// SPDX-FileCopyrightText: Copyright 2020 yuzu Emulator Project
+// SPDX-License-Identifier: GPL-2.0-or-later
+
+#ifdef _WIN32
+#include <windows.h>
+#else
+#include <sys/mman.h>
+#endif
+
+#include "common/assert.h"
+#include "common/virtual_buffer.h"
+
+namespace Common {
+
+void* AllocateMemoryPages(std::size_t size) noexcept {
+#ifdef _WIN32
+    void* base = VirtualAlloc(nullptr, size, MEM_COMMIT | MEM_RESERVE, PAGE_READWRITE);
+    if (base == nullptr) {
+        // Probably failing to reserve is less likely than failing to commit
+        base = VirtualAlloc(nullptr, size, MEM_COMMIT, PAGE_READWRITE);
+    }
+#else
+    void* base = mmap(nullptr, size, PROT_READ | PROT_WRITE, MAP_ANON | MAP_PRIVATE, -1, 0);
+    if (base == MAP_FAILED)
+        base = nullptr;
+#endif
+    ASSERT(base);
+    return base;
+}
+
+void FreeMemoryPages(void* base, [[maybe_unused]] std::size_t size) noexcept {
+    if (!base)
+        return;
+#ifdef _WIN32
+    ASSERT(VirtualFree(base, 0, MEM_RELEASE));
+#else
+    ASSERT(munmap(base, size) == 0);
+#endif
+}
+
+} // namespace Common

src/common/virtual_buffer.h

@@ -0,0 +1,84 @@
+// SPDX-FileCopyrightText: Copyright 2026 Eden Emulator Project
+// SPDX-License-Identifier: GPL-3.0-or-later
+
+// SPDX-FileCopyrightText: Copyright 2020 yuzu Emulator Project
+// SPDX-License-Identifier: GPL-2.0-or-later
+
+#pragma once
+
+#include <utility>
+
+namespace Common {
+
+void* AllocateMemoryPages(std::size_t size) noexcept;
+void FreeMemoryPages(void* base, std::size_t size) noexcept;
+
+template <typename T>
+class VirtualBuffer final {
+public:
+    // TODO: Uncomment this and change Common::PageTable::PageInfo to be trivially constructible
+    // using std::atomic_ref once libc++ has support for it
+    // static_assert(
+    //     std::is_trivially_constructible_v<T>,
+    //     "T must be trivially constructible, as non-trivial constructors will not be executed "
+    //     "with the current allocator");
+
+    constexpr VirtualBuffer() = default;
+    explicit VirtualBuffer(std::size_t count) noexcept
+        : alloc_size{count * sizeof(T)}
+    {
+        base_ptr = reinterpret_cast<T*>(AllocateMemoryPages(alloc_size));
+    }
+
+    ~VirtualBuffer() noexcept {
+        FreeMemoryPages(base_ptr, alloc_size);
+    }
+
+    VirtualBuffer(const VirtualBuffer&) = delete;
+    VirtualBuffer& operator=(const VirtualBuffer&) = delete;
+
+    VirtualBuffer(VirtualBuffer&& other) noexcept
+        : alloc_size{std::exchange(other.alloc_size, 0)}
+        , base_ptr{std::exchange(other.base_ptr, nullptr)}
+    {}
+
+    VirtualBuffer& operator=(VirtualBuffer&& other) noexcept {
+        alloc_size = std::exchange(other.alloc_size, 0);
+        base_ptr = std::exchange(other.base_ptr, nullptr);
+        return *this;
+    }
+
+    void resize(std::size_t count) noexcept {
+        if (auto const new_size = count * sizeof(T); new_size != alloc_size) {
+            FreeMemoryPages(base_ptr, alloc_size);
+            alloc_size = new_size;
+            base_ptr = reinterpret_cast<T*>(AllocateMemoryPages(alloc_size));
+        }
+    }
+
+    [[nodiscard]] constexpr const T& operator[](std::size_t index) const noexcept {
+        return base_ptr[index];
+    }
+
+    [[nodiscard]] constexpr T& operator[](std::size_t index) noexcept {
+        return base_ptr[index];
+    }
+
+    [[nodiscard]] constexpr T* data() noexcept {
+        return base_ptr;
+    }
+
+    [[nodiscard]] constexpr const T* data() const noexcept {
+        return base_ptr;
+    }
+
+    [[nodiscard]] constexpr std::size_t size() const noexcept {
+        return alloc_size / sizeof(T);
+    }
+
+private:
+    std::size_t alloc_size{};
+    T* base_ptr{};
+};
+
+} // namespace Common

src/common/zbic_compression.cpp

@@ -1,46 +0,0 @@
-// SPDX-FileCopyrightText: Copyright 2026 Eden Emulator Project
-// SPDX-License-Identifier: GPL-3.0-or-later
-
-#include <cstring>
-
-#include "common/zbic_compression.h"
-
-#define ZSTD_ZBIC_SUPPORT 1
-#define ZSTDLIB_VISIBLE static
-#define ZSTDLIB_HIDDEN static
-#define ZSTDERRORLIB_VISIBLE static
-#define ZSTDERRORLIB_HIDDEN static
-#undef ZSTD_MULTITHREAD
-
-#if defined(__ANDROID__)
-#undef _GNU_SOURCE
-#endif
-
-#include "zstd.h"
-#define g_ZSTD_threading_useless_symbol g_ZSTD_zbic_threading_useless_symbol
-#include "zstd.c"
-#undef g_ZSTD_threading_useless_symbol
-
-namespace Common::Compression {
-
-bool IsZBIC(std::span<const u8> src) {
-    if (src.size() < sizeof(u32)) {
-        return false;
-    }
-    u32 magic = 0;
-    std::memcpy(&magic, src.data(), sizeof(u32));
-    return magic == ZSTD_MAGICNUMBER; // 0x4349425A ("ZBIC")
-}
-
-int DecompressDataZBIC(std::span<u8> dst, std::span<const u8> src) {
-    if (dst.empty() || src.empty()) {
-        return -1;
-    }
-    const size_t res = ZSTD_decompress(dst.data(), dst.size(), src.data(), src.size());
-    if (ZSTD_isError(res)) {
-        return -1;
-    }
-    return static_cast<int>(res);
-}
-
-} // namespace Common::Compression

src/common/zbic_compression.h

@@ -1,15 +0,0 @@
-// SPDX-FileCopyrightText: Copyright 2026 Eden Emulator Project
-// SPDX-License-Identifier: GPL-3.0-or-later
-
-#pragma once
-
-#include <span>
-#include "common/common_types.h"
-
-namespace Common::Compression {
-
-[[nodiscard]] bool IsZBIC(std::span<const u8> src);
-
-[[nodiscard]] int DecompressDataZBIC(std::span<u8> dst, std::span<const u8> src);
-
-} // namespace Common::Compression

src/core/CMakeLists.txt

@@ -23,8 +23,6 @@ add_library(core STATIC
     core_timing.h
     cpu_manager.cpp
     cpu_manager.h
-    launch_params.cpp
-    launch_params.h
     crypto/aes_util.cpp
     crypto/aes_util.h
     crypto/ctr_encryption_layer.cpp
@@ -1205,9 +1203,6 @@ endif()
 
 target_include_directories(core PRIVATE ${OPUS_INCLUDE_DIRS})
 target_link_libraries(core PUBLIC common PRIVATE audio_core hid_core network video_core nx_tzdb tz)
-if (MSVC)
-    target_link_libraries(core PRIVATE getopt)
-endif()
 
 if (BOOST_NO_HEADERS)
     target_link_libraries(core PUBLIC Boost::container Boost::heap Boost::asio Boost::process Boost::crc)

src/core/arm/dynarmic/arm_dynarmic_32.cpp

@@ -156,12 +156,12 @@ void ArmDynarmic32::MakeJit(Common::PageTable* page_table) {
     if (page_table) {
         constexpr size_t PageBits = 12;
         constexpr size_t NumPageTableEntries = 1 << (32 - PageBits);
+        constexpr size_t PageLog2Stride = 5;
+        static_assert(1 << PageLog2Stride == sizeof(Common::PageTable::PageEntryData));
 
-        // Dynarmic will not write to the page table, const_cast is safe here
-        config.page_table = reinterpret_cast<std::array<std::uint8_t*, NumPageTableEntries>*>(
-            const_cast<Common::PageTable::PageEntryData*>(page_table->entries.data()));
-        config.page_table_pointer_mask = Common::PageTable::ATTRIBUTE_MASK;
-        config.page_table_marked_bit = uint8_t(0);
+        config.page_table = reinterpret_cast<std::array<std::uint8_t*, NumPageTableEntries>*>(page_table->entries.data());
+        config.page_table_pointer_mask_bits = Common::PageTable::ATTRIBUTE_BITS;
+        config.page_table_log2_stride = PageLog2Stride;
         config.absolute_offset_page_table = true;
         config.detect_misaligned_access_via_page_table = 16 | 32 | 64 | 128;
         config.only_detect_misalignment_via_page_table_on_page_boundary = true;
@@ -172,13 +172,6 @@ void ArmDynarmic32::MakeJit(Common::PageTable* page_table) {
 
         config.fastmem_exclusive_access = config.fastmem_pointer  != std::nullopt;
         config.recompile_on_exclusive_fastmem_failure = true;
-
-        if (reinterpret_cast<u64>(m_system.DeviceMemory().buffer.BackingBasePointer() +
-            Kernel::Board::Nintendo::Nx::KSystemControl::Init::GetIntendedMemorySize()) < (1ULL << 39)) {
-            // Systems like FreeBSD allocate memory really low by default, and since we pack our page table entries,
-            // we have to manually sign extend when our actual pointer is negative.
-            config.page_table_sign_extension = std::uint8_t(Common::PageTable::SIGN_BIT);
-        }
     }
 
     // Multi-process state
@@ -411,7 +404,6 @@ void ArmDynarmic32::SignalInterrupt(Kernel::KThread* thread) {
 }
 
 void ArmDynarmic32::ClearInstructionCache() {
-    m_cb->last_code_addr = u64(-1);
     m_jit->ClearCache();
 }
 

src/core/arm/dynarmic/arm_dynarmic_64.cpp

@@ -197,12 +197,13 @@ void ArmDynarmic64::MakeJit(Common::PageTable* page_table, std::size_t address_s
 
     // Memory
     if (page_table) {
-        // Dynarmic will not write to the page table, const_cast is safe here
-        config.page_table = reinterpret_cast<void**>(
-            const_cast<Common::PageTable::PageEntryData*>(page_table->entries.data()));
+        constexpr size_t PageLog2Stride = 5;
+        static_assert(1 << PageLog2Stride == sizeof(Common::PageTable::PageEntryData));
+
+        config.page_table = reinterpret_cast<void**>(page_table->entries.data());
         config.page_table_address_space_bits = std::uint32_t(address_space_bits);
-        config.page_table_pointer_mask = Common::PageTable::ATTRIBUTE_MASK;
-        config.page_table_marked_bit = uint8_t(0);
+        config.page_table_pointer_mask_bits = Common::PageTable::ATTRIBUTE_BITS;
+        config.page_table_log2_stride = PageLog2Stride;
         config.silently_mirror_page_table = false;
         config.absolute_offset_page_table = true;
         config.detect_misaligned_access_via_page_table = 16 | 32 | 64 | 128;
@@ -216,13 +217,6 @@ void ArmDynarmic64::MakeJit(Common::PageTable* page_table, std::size_t address_s
 
         config.fastmem_exclusive_access = config.fastmem_pointer != std::nullopt;
         config.recompile_on_exclusive_fastmem_failure = true;
-
-        if (reinterpret_cast<u64>(m_system.DeviceMemory().buffer.BackingBasePointer() +
-            Kernel::Board::Nintendo::Nx::KSystemControl::Init::GetIntendedMemorySize()) < (1ULL << 39)) {
-            // Systems like FreeBSD allocate memory really low by default, and since we pack our page table entries,
-            // we have to manually sign extend when our actual pointer is negative.
-            config.page_table_sign_extension = std::uint8_t(Common::PageTable::SIGN_BIT);
-        }
     }
 
     // Multi-process state
@@ -439,7 +433,6 @@ void ArmDynarmic64::SignalInterrupt(Kernel::KThread* thread) {
 }
 
 void ArmDynarmic64::ClearInstructionCache() {
-    m_cb->last_code_addr = u64(-1);
     m_jit->ClearCache();
 }
 

src/core/arm/dynarmic/arm_dynarmic_64.h

@@ -13,6 +13,7 @@
 #include <dynarmic/interface/A64/a64.h>
 #include <dynarmic/interface/code_page.h>
 #include "common/common_types.h"
+#include "common/hash.h"
 #include "core/arm/arm_interface.h"
 #include "core/arm/dynarmic/dynarmic_exclusive_monitor.h"
 #include "dynarmic/interface/A64/config.h"

src/core/cpu_manager.cpp

@@ -168,7 +168,7 @@ void CpuManager::ShutdownThread(Kernel::KernelCore& kernel) {
     UNREACHABLE();
 }
 
-void CpuManager::RunThread(std::stop_token stop_token, std::size_t core) {
+void CpuManager::RunThread(std::stop_token token, std::size_t core) {
     /// Initialization
     system.RegisterCoreThread(core);
     std::string name = is_multicore ? ("CPUCore_" + std::to_string(core)) : std::string{"CPUThread"};
@@ -178,19 +178,26 @@ void CpuManager::RunThread(std::stop_token stop_token, std::size_t core) {
     auto& data = core_data[core];
     data.host_context = Common::Fiber::ThreadToFiber();
 
+    // Cleanup
+    SCOPE_EXIT {
+        data.host_context->Exit();
+    };
+
     // Running
-    gpu_barrier->arrive_and_wait();
-    if (!stop_token.stop_requested()) {
-        if (!is_async_gpu && !is_multicore) {
-            system.GPU().ObtainContext();
-        }
-        auto& kernel = system.Kernel();
-        auto& scheduler = *kernel.CurrentScheduler();
-        auto* thread = scheduler.GetSchedulerCurrentThread();
-        Kernel::SetCurrentThread(kernel, thread);
-        Common::Fiber::YieldTo(data.host_context, *thread->GetHostContext());
+    if (!gpu_barrier->Sync(token)) {
+        return;
     }
-    data.host_context->Exit();
+
+    if (!is_async_gpu && !is_multicore) {
+        system.GPU().ObtainContext();
+    }
+
+    auto& kernel = system.Kernel();
+    auto& scheduler = *kernel.CurrentScheduler();
+    auto* thread = scheduler.GetSchedulerCurrentThread();
+    Kernel::SetCurrentThread(kernel, thread);
+
+    Common::Fiber::YieldTo(data.host_context, *thread->GetHostContext());
 }
 
 } // namespace Core

src/core/cpu_manager.h

@@ -8,7 +8,6 @@
 
 #include <array>
 #include <atomic>
-#include <barrier>
 #include <functional>
 #include <memory>
 #include <thread>
@@ -53,7 +52,7 @@ public:
     }
 
     void OnGpuReady() {
-        gpu_barrier->arrive_and_wait();
+        gpu_barrier->Sync();
     }
 
     void Initialize();
@@ -96,7 +95,7 @@ private:
 
     static constexpr std::size_t max_cycle_runs = 5;
 
-    std::optional<std::barrier<>> gpu_barrier{};
+    std::optional<Common::Barrier> gpu_barrier{};
     struct CoreData {
         std::shared_ptr<Common::Fiber> host_context;
         std::jthread host_thread;

src/core/crypto/key_manager.cpp

@@ -14,7 +14,6 @@
 #include <tuple>
 #include <vector>
 
-#include <boost/algorithm/string/case_conv.hpp>
 #include <openssl/evp.h>
 
 #include "common/fs/file.h"
@@ -623,7 +622,7 @@ void KeyManager::LoadFromFile(const std::filesystem::path& file_path, bool is_ti
                 Key128 key = Common::HexStringToArray<16>(out[1]);
                 s128_keys[{S128KeyType::Titlekey, rights_id[1], rights_id[0]}] = key;
             } else {
-                boost::algorithm::to_lower(out[0]);
+                out[0] = Common::ToLower(out[0]);
                 if (const auto iter128 = Find128ByName(out[0]); iter128 != s128_file_id.end()) {
                     const auto& index = iter128->second;
                     const Key128 key = Common::HexStringToArray<16>(out[1]);

src/core/crypto/partition_data_manager.cpp

@@ -6,7 +6,6 @@
 
 #include <array>
 #include <cstring>
-#include <boost/algorithm/string/case_conv.hpp>
 #include "common/common_funcs.h"
 #include "common/common_types.h"
 #include "common/hex_util.h"
@@ -42,13 +41,16 @@ static_assert(sizeof(Package2Header) == 0x200, "Package2Header has incorrect siz
 
 const u8 PartitionDataManager::MAX_KEYBLOB_SOURCE_HASH = 32;
 
-static FileSys::VirtualFile FindFileInDirWithNames(const FileSys::VirtualDir& dir, const std::string& name) {
-    const auto upper = boost::algorithm::to_upper_copy(name);
+static FileSys::VirtualFile FindFileInDirWithNames(const FileSys::VirtualDir& dir,
+                                                   const std::string& name) {
+    const auto upper = Common::ToUpper(name);
+
     for (const auto& fname : {name, name + ".bin", upper, upper + ".BIN"}) {
         if (dir->GetFile(fname) != nullptr) {
             return dir->GetFile(fname);
         }
     }
+
     return nullptr;
 }
 

src/core/device_memory.h

@@ -1,6 +1,3 @@
-// SPDX-FileCopyrightText: Copyright 2026 Eden Emulator Project
-// SPDX-License-Identifier: GPL-3.0-or-later
-
 // SPDX-FileCopyrightText: Copyright 2020 yuzu Emulator Project
 // SPDX-License-Identifier: GPL-2.0-or-later
 
@@ -29,11 +26,8 @@ public:
 
     template <typename T>
     Common::PhysicalAddress GetPhysicalAddr(const T* ptr) const {
-        return GetPhysicalAddr(reinterpret_cast<uintptr_t>(ptr));
-    }
-
-    Common::PhysicalAddress GetPhysicalAddr(uintptr_t ptr) const {
-        return (ptr - reinterpret_cast<uintptr_t>(buffer.BackingBasePointer())) +
+        return (reinterpret_cast<uintptr_t>(ptr) -
+                reinterpret_cast<uintptr_t>(buffer.BackingBasePointer())) +
                DramMemoryMap::Base;
     }
 

src/core/device_memory_manager.h

@@ -18,7 +18,7 @@
 #include "common/common_types.h"
 #include "common/range_mutex.h"
 #include "common/scratch_buffer.h"
-#include "common/sparse_large_vector.h"
+#include "common/virtual_buffer.h"
 
 namespace Core {
 
@@ -178,8 +178,8 @@ private:
         u32 continuity_tracker;
         u32 compressed_physical_ptr;
     };
-    Common::SparseLargeVector<u32> compressed_device_addr;
-    Common::SparseLargeVector<TrackedEntry> tracked_entries;
+    Common::VirtualBuffer<u32> compressed_device_addr;
+    Common::VirtualBuffer<TrackedEntry> tracked_entries;
 
     // Process memory interfaces
 
@@ -200,8 +200,8 @@ private:
         return std::make_pair(asid, address);
     }
 
-    constexpr void InsertCPUBacking(size_t page_index, VAddr address, Asid asid) {
-        tracked_entries.GetUnchecked(page_index).cpu_backing_address = address | (asid.id << asid_start_bit);
+    void InsertCPUBacking(size_t page_index, VAddr address, Asid asid) {
+        tracked_entries[page_index].cpu_backing_address = address | (asid.id << asid_start_bit);
     }
 
     std::array<TranslationEntry, 4> t_slot{};

src/core/device_memory_manager.inc

@@ -177,6 +177,17 @@ DeviceMemoryManager<Traits>::DeviceMemoryManager(const DeviceMemory& device_memo
 {
     impl = std::make_unique<DeviceMemoryManagerAllocator<Traits>>();
     cached_pages = std::make_unique<CachedPages>();
+
+    const size_t total_virtual = device_as_size >> Memory::YUZU_PAGEBITS;
+    for (size_t i = 0; i < total_virtual; i++) {
+        tracked_entries[i].compressed_physical_ptr = 0;
+        tracked_entries[i].continuity_tracker = 1;
+        tracked_entries[i].cpu_backing_address = 0;
+    }
+    const size_t total_phys = 1ULL << ((Settings::values.memory_layout_mode.GetValue() == Settings::MemoryLayout::Memory_4Gb ? physical_min_bits : physical_max_bits) - Memory::YUZU_PAGEBITS);
+    for (size_t i = 0; i < total_phys; i++) {
+        compressed_device_addr[i] = 0;
+    }
 }
 
 template <typename Traits>
@@ -209,28 +220,26 @@ void DeviceMemoryManager<Traits>::Map(DAddr address, VAddr virtual_address, size
     size_t start_page_d = address >> Memory::YUZU_PAGEBITS;
     size_t num_pages = Common::AlignUp(size, Memory::YUZU_PAGESIZE) >> Memory::YUZU_PAGEBITS;
     std::scoped_lock lk(mapping_guard);
-
-    tracked_entries.CommitRegion(start_page_d, start_page_d + num_pages);
     for (size_t i = 0; i < num_pages; i++) {
         const VAddr new_vaddress = virtual_address + i * Memory::YUZU_PAGESIZE;
         auto* ptr = process_memory->GetPointerSilent(Common::ProcessAddress(new_vaddress));
         if (ptr == nullptr) [[unlikely]] {
-            tracked_entries.GetUnchecked(start_page_d + i).compressed_physical_ptr = 0;
+            tracked_entries[start_page_d + i].compressed_physical_ptr = 0;
             continue;
         }
         auto phys_addr = static_cast<u32>(GetRawPhysicalAddr(ptr) >> Memory::YUZU_PAGEBITS) + 1U;
-        tracked_entries.GetUnchecked(start_page_d + i).compressed_physical_ptr = phys_addr;
+        tracked_entries[start_page_d + i].compressed_physical_ptr = phys_addr;
         InsertCPUBacking(start_page_d + i, new_vaddress, asid);
         const u32 base_dev = compressed_device_addr[phys_addr - 1U];
         const u32 new_dev = static_cast<u32>(start_page_d + i);
         if (base_dev == 0) [[likely]] {
-            compressed_device_addr.GetAndFault(phys_addr - 1U) = new_dev;
+            compressed_device_addr[phys_addr - 1U] = new_dev;
             continue;
         }
         u32 start_id = base_dev & MULTI_MASK;
         if ((base_dev >> MULTI_FLAG_BITS) == 0) {
             start_id = impl->multi_dev_address.Register(base_dev);
-            compressed_device_addr.GetAndFault(phys_addr - 1U) = MULTI_FLAG | start_id;
+            compressed_device_addr[phys_addr - 1U] = MULTI_FLAG | start_id;
         }
         impl->multi_dev_address.Register(new_dev, start_id);
     }
@@ -246,26 +255,24 @@ void DeviceMemoryManager<Traits>::Unmap(DAddr address, size_t size) {
     size_t num_pages = Common::AlignUp(size, Memory::YUZU_PAGESIZE) >> Memory::YUZU_PAGEBITS;
     device_inter->InvalidateRegion(address, size);
     std::scoped_lock lk(mapping_guard);
-
-    tracked_entries.CommitRegion(start_page_d, start_page_d + num_pages); // should already be committed, but just in case
     for (size_t i = 0; i < num_pages; i++) {
-        auto& entry = tracked_entries.GetUnchecked(start_page_d + i);
-        auto phys_addr = entry.compressed_physical_ptr;
-        entry.compressed_physical_ptr = 0;
-        entry.cpu_backing_address = 0;
+        auto phys_addr = tracked_entries[start_page_d + i].compressed_physical_ptr;
+        tracked_entries[start_page_d + i].compressed_physical_ptr = 0;
+        tracked_entries[start_page_d + i].cpu_backing_address = 0;
         if (phys_addr != 0) [[likely]] {
-            u32& base_dev = compressed_device_addr.GetAndFault(phys_addr - 1U);
+            const u32 base_dev = compressed_device_addr[phys_addr - 1U];
             if ((base_dev >> MULTI_FLAG_BITS) == 0) [[likely]] {
-                base_dev = 0;
+                compressed_device_addr[phys_addr - 1] = 0;
                 continue;
             }
             const auto [more_entries, new_start] = impl->multi_dev_address.Unregister(
                 static_cast<u32>(start_page_d + i), base_dev & MULTI_MASK);
             if (!more_entries) {
-                base_dev = impl->multi_dev_address.ReleaseEntry(new_start);
+                compressed_device_addr[phys_addr - 1] =
+                    impl->multi_dev_address.ReleaseEntry(new_start);
                 continue;
             }
-            base_dev = new_start | MULTI_FLAG;
+            compressed_device_addr[phys_addr - 1] = new_start | MULTI_FLAG;
         }
     }
     t_slot = {};
@@ -278,8 +285,6 @@ void DeviceMemoryManager<Traits>::TrackContinuityImpl(DAddr address, VAddr virtu
     size_t num_pages = Common::AlignUp(size, Memory::YUZU_PAGESIZE) >> Memory::YUZU_PAGEBITS;
     uintptr_t last_ptr = 0;
     size_t page_count = 1;
-
-    tracked_entries.CommitRegion(start_page_d, start_page_d + num_pages);
     for (size_t i = num_pages; i > 0; i--) {
         size_t index = i - 1;
         const VAddr new_vaddress = virtual_address + index * Memory::YUZU_PAGESIZE;
@@ -291,14 +296,14 @@ void DeviceMemoryManager<Traits>::TrackContinuityImpl(DAddr address, VAddr virtu
             page_count = 1;
         }
         last_ptr = new_ptr;
-        tracked_entries.GetUnchecked(start_page_d + index).continuity_tracker = static_cast<u32>(page_count) - 1;
+        tracked_entries[start_page_d + index].continuity_tracker = static_cast<u32>(page_count);
     }
 }
 template <typename Traits>
 u8* DeviceMemoryManager<Traits>::GetSpan(const DAddr src_addr, const std::size_t size) {
     size_t page_index = src_addr >> page_bits;
     size_t subbits = src_addr & page_mask;
-    if ((static_cast<size_t>(tracked_entries[page_index].continuity_tracker+1) << page_bits) >= size + subbits) {
+    if ((static_cast<size_t>(tracked_entries[page_index].continuity_tracker) << page_bits) >= size + subbits) {
         return GetPointer<u8>(src_addr);
     }
     return nullptr;
@@ -308,7 +313,7 @@ template <typename Traits>
 const u8* DeviceMemoryManager<Traits>::GetSpan(const DAddr src_addr, const std::size_t size) const {
     size_t page_index = src_addr >> page_bits;
     size_t subbits = src_addr & page_mask;
-    if ((static_cast<size_t>(tracked_entries[page_index].continuity_tracker+1) << page_bits) >= size + subbits) {
+    if ((static_cast<size_t>(tracked_entries[page_index].continuity_tracker) << page_bits) >= size + subbits) {
         return GetPointer<u8>(src_addr);
     }
     return nullptr;
@@ -378,7 +383,7 @@ void DeviceMemoryManager<Traits>::WalkBlock(DAddr addr, std::size_t size, auto o
     std::size_t page_index = addr >> Memory::YUZU_PAGEBITS;
     std::size_t page_offset = addr & Memory::YUZU_PAGEMASK;
     while (remaining_size) {
-        const size_t next_pages = std::size_t(tracked_entries[page_index].continuity_tracker+1);
+        const size_t next_pages = std::size_t(tracked_entries[page_index].continuity_tracker);
         const std::size_t copy_amount = (std::min)((next_pages << Memory::YUZU_PAGEBITS) - page_offset, remaining_size);
         const auto current_vaddr = u64((page_index << Memory::YUZU_PAGEBITS) + page_offset);
         SCOPE_EXIT{

src/core/file_sys/ips_layer.cpp

@@ -35,20 +35,17 @@ static IPSFileType IdentifyMagic(std::span<const u8> magic) {
 }
 
 static bool IsEOF(IPSFileType type, std::span<const u8> magic) {
-    return (type == IPSFileType::IPS && magic.size() >= 3 && std::memcmp(magic.data(), "EOF", 3) == 0)
-        || (type == IPSFileType::IPS32 && magic.size() >= 4 && std::memcmp(magic.data(), "EEOF", 4) == 0);
+    return (type == IPSFileType::IPS && magic.size() > 3 && std::memcmp(magic.data(), "EOF", 3) == 0)
+        || (type == IPSFileType::IPS32 && magic.size() > 4 && std::memcmp(magic.data(), "EEOF", 4) == 0);
 }
 
 VirtualFile PatchIPS(const VirtualFile& in, const VirtualFile& ips) {
     if (in == nullptr || ips == nullptr)
         return nullptr;
 
-    const auto type = IdentifyMagic(ips->ReadBytes(0x5));
-    if (type == IPSFileType::Error)
-        return nullptr;
-
     auto in_data = in->ReadAllBytes();
-    if (in_data.size() == 0)
+    auto const type = IdentifyMagic(in_data);
+    if (type == IPSFileType::Error)
         return nullptr;
 
     std::vector<u8> temp(type == IPSFileType::IPS ? 3 : 4);

src/core/file_sys/patch_manager.cpp

@@ -8,7 +8,6 @@
 #include <array>
 #include <cstddef>
 #include <cstring>
-#include <boost/algorithm/string/case_conv.hpp>
 
 #include "common/assert.h"
 #include "common/hex_util.h"
@@ -74,10 +73,12 @@ VirtualDir FindSubdirectoryCaseless(const VirtualDir dir, std::string_view name)
 #else
     const auto subdirs = dir->GetSubdirectories();
     for (const auto& subdir : subdirs) {
-        if (name == boost::algorithm::to_lower_copy(subdir->GetName())) {
+        std::string dir_name = Common::ToLower(subdir->GetName());
+        if (dir_name == name) {
             return subdir;
         }
     }
+
     return nullptr;
 #endif
 }

src/core/file_sys/registered_cache.cpp

@@ -8,7 +8,6 @@
 #include <limits>
 #include <random>
 #include <regex>
-#include <boost/algorithm/string/case_conv.hpp>
 #include <openssl/evp.h>
 #include "common/assert.h"
 #include "common/fs/path_util.h"
@@ -1415,10 +1414,11 @@ void ExternalContentProvider::ScanDirectory(const VirtualDir& dir) {
             continue;
         }
 
-        const auto ext = boost::to_lower_copy(filename.substr(dot_pos + 1));
-        if (ext == "nsp") {
+        const auto extension = Common::ToLower(filename.substr(dot_pos + 1));
+
+        if (extension == "nsp") {
             ProcessNSP(file);
-        } else if (ext == "xci") {
+        } else if (extension == "xci") {
             ProcessXCI(file);
         }
     }

src/core/file_sys/vfs/vfs_real.cpp

@@ -109,7 +109,8 @@ VirtualFile RealVfsFilesystem::OpenFileFromEntry(std::string_view path_, std::op
     auto reference = std::make_unique<FileReference>();
     this->InsertReferenceIntoListLocked(*reference);
 
-    auto file = std::make_shared<RealVfsFile>(*this, std::move(reference), path, perms, size, std::move(parent_path));
+    auto file = std::shared_ptr<RealVfsFile>(
+        new RealVfsFile(*this, std::move(reference), path, perms, size, std::move(parent_path)));
     cache[path] = file;
 
     return file;
@@ -176,7 +177,7 @@ bool RealVfsFilesystem::DeleteFile(std::string_view path_) {
 
 VirtualDir RealVfsFilesystem::OpenDirectory(std::string_view path_, OpenMode perms) {
     const auto path = FS::SanitizePath(path_, FS::DirectorySeparator::PlatformDefault);
-    return std::make_shared<RealVfsDirectory>(*this, path, perms);
+    return std::shared_ptr<RealVfsDirectory>(new RealVfsDirectory(*this, path, perms));
 }
 
 VirtualDir RealVfsFilesystem::CreateDirectory(std::string_view path_, OpenMode perms) {
@@ -184,7 +185,7 @@ VirtualDir RealVfsFilesystem::CreateDirectory(std::string_view path_, OpenMode p
     if (!FS::CreateDirs(path)) {
         return nullptr;
     }
-    return std::make_shared<RealVfsDirectory>(*this, path, perms);
+    return std::shared_ptr<RealVfsDirectory>(new RealVfsDirectory(*this, path, perms));
 }
 
 VirtualDir RealVfsFilesystem::CopyDirectory(std::string_view old_path_,

src/core/file_sys/vfs/vfs_real.h

@@ -82,9 +82,6 @@ class RealVfsFile : public VfsFile {
     friend class RealVfsFilesystem;
 
 public:
-    RealVfsFile(RealVfsFilesystem& base, std::unique_ptr<FileReference> reference,
-                const std::string& path, OpenMode perms = OpenMode::Read,
-                std::optional<u64> size = {}, std::optional<std::string> parent_path = {});
     ~RealVfsFile() override;
 
     std::string GetName() const override;
@@ -98,6 +95,9 @@ public:
     bool Rename(std::string_view name) override;
 
 private:
+    RealVfsFile(RealVfsFilesystem& base, std::unique_ptr<FileReference> reference,
+                const std::string& path, OpenMode perms = OpenMode::Read,
+                std::optional<u64> size = {}, std::optional<std::string> parent_path = {});
 
     RealVfsFilesystem& base;
     std::unique_ptr<FileReference> reference;
@@ -113,8 +113,6 @@ class RealVfsDirectory : public VfsDirectory {
     friend class RealVfsFilesystem;
 
 public:
-    RealVfsDirectory(RealVfsFilesystem& base, const std::string& path,
-                     OpenMode perms = OpenMode::Read);
     ~RealVfsDirectory() override;
 
     VirtualFile GetFileRelative(std::string_view relative_path) const override;
@@ -140,6 +138,9 @@ public:
     std::map<std::string, VfsEntryType, std::less<>> GetEntries() const override;
 
 private:
+    RealVfsDirectory(RealVfsFilesystem& base, const std::string& path,
+                     OpenMode perms = OpenMode::Read);
+
     template <typename T, typename R>
     std::vector<std::shared_ptr<R>> IterateEntries() const;
 

src/core/file_sys/xts_archive.cpp

@@ -9,7 +9,6 @@
 #include <regex>
 #include <string>
 
-#include <boost/algorithm/string/case_conv.hpp>
 #include <openssl/err.h>
 #include <openssl/evp.h>
 
@@ -64,8 +63,8 @@ NAX::NAX(VirtualFile file_)
         return;
     }
 
-    const std::string two_dir = boost::algorithm::to_upper_copy(std::string{match[1]});
-    const std::string nca_id = boost::algorithm::to_lower_copy(std::string{match[2]});
+    const std::string two_dir = Common::ToUpper(std::string{match[1]});
+    const std::string nca_id = Common::ToLower(std::string{match[2]});
     status = Parse(fmt::format("/registered/{}/{}.nca", two_dir, nca_id));
 }
 

src/core/hardware_properties.h

@@ -1,6 +1,3 @@
-// SPDX-FileCopyrightText: Copyright 2026 Eden Emulator Project
-// SPDX-License-Identifier: GPL-3.0-or-later
-
 // SPDX-FileCopyrightText: Copyright 2020 yuzu Emulator Project
 // SPDX-License-Identifier: GPL-2.0-or-later
 
@@ -22,14 +19,8 @@ constexpr u32 NUM_CPU_CORES = 4;               // Number of CPU Cores - sync wit
 
 // Virtual to Physical core map.
 constexpr std::array<s32, Common::BitSize<u64>()> VirtualToPhysicalCoreMap{
-    0, 1, 2, 3, 0, 0, 0, 0,
-    0, 0, 0, 0, 0, 0, 0, 0,
-    0, 0, 0, 0, 0, 0, 0, 0,
-    0, 0, 0, 0, 0, 0, 0, 0,
-    0, 0, 0, 0, 0, 0, 0, 0,
-    0, 0, 0, 0, 0, 0, 0, 0,
-    0, 0, 0, 0, 0, 0, 0, 0,
-    0, 0, 0, 0, 0, 0, 0, 3,
+    0, 1, 2, 3, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+    0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 3,
 };
 
 static constexpr inline size_t NumVirtualCores = Common::BitSize<u64>();

src/core/hle/kernel/k_page_table_base.cpp

@@ -635,36 +635,6 @@ Result KPageTableBase::CheckMemoryState(const KMemoryInfo& info, KMemoryState st
     R_SUCCEED();
 }
 
-bool KPageTableBase::BeginTraversal(const Common::PageTable &impl, TraversalEntry *out_entry, TraversalContext *out_context,
-    Common::ProcessAddress address) const {
-    out_context->next_offset = GetInteger(address);
-    out_context->next_page = GetInteger(address) >> PageBits;
-
-    return ContinueTraversal(impl, out_entry, out_context);
-}
-
-bool KPageTableBase::ContinueTraversal(const Common::PageTable &impl, TraversalEntry *out_entry,
-    TraversalContext *context) const {
-    // Setup invalid defaults.
-    out_entry->phys_addr = 0;
-    out_entry->block_size = PageSize;
-    // Validate that we can read the actual entry.
-    if (auto const page = context->next_page; page < impl.entries.size()) {
-        // Validate that the entry is mapped.
-        if (auto const paddr = impl.entries[page].Pointer(true); paddr != 0) {
-            // Populate the results and return true
-            out_entry->phys_addr = GetInteger(m_system.DeviceMemory().GetPhysicalAddr(paddr + context->next_offset));
-            context->next_page += 1;
-            context->next_offset += PageSize;
-            return true;
-        }
-    }
-    context->next_page += 1;
-    context->next_offset += PageSize;
-    // Otherwise return false
-    return false;
-}
-
 Result KPageTableBase::CheckMemoryStateContiguous(size_t* out_blocks_needed, KProcessAddress addr,
                                                   size_t size, KMemoryState state_mask,
                                                   KMemoryState state, KMemoryPermission perm_mask,
@@ -970,7 +940,7 @@ Result KPageTableBase::QueryMappingImpl(KProcessAddress* out, KPhysicalAddress a
     size_t tot_size = 0;
 
     next_valid =
-        BeginTraversal(impl, std::addressof(next_entry), std::addressof(context), region_start);
+        impl.BeginTraversal(std::addressof(next_entry), std::addressof(context), region_start);
     next_entry.block_size =
         (next_entry.block_size - (GetInteger(region_start) & (next_entry.block_size - 1)));
 
@@ -1006,7 +976,7 @@ Result KPageTableBase::QueryMappingImpl(KProcessAddress* out, KPhysicalAddress a
             break;
         }
 
-        next_valid = ContinueTraversal(impl, std::addressof(next_entry), std::addressof(context));
+        next_valid = impl.ContinueTraversal(std::addressof(next_entry), std::addressof(context));
     }
 
     // Check the last entry.
@@ -1784,7 +1754,7 @@ Result KPageTableBase::MakePageGroup(KPageGroup& pg, KProcessAddress addr, size_
     // Begin traversal.
     TraversalContext context;
     TraversalEntry next_entry;
-    R_UNLESS(BeginTraversal(impl, std::addressof(next_entry), std::addressof(context), addr),
+    R_UNLESS(impl.BeginTraversal(std::addressof(next_entry), std::addressof(context), addr),
              ResultInvalidCurrentMemory);
 
     // Prepare tracking variables.
@@ -1794,7 +1764,7 @@ Result KPageTableBase::MakePageGroup(KPageGroup& pg, KProcessAddress addr, size_
 
     // Iterate, adding to group as we go.
     while (tot_size < size) {
-        R_UNLESS(ContinueTraversal(impl, std::addressof(next_entry), std::addressof(context)),
+        R_UNLESS(impl.ContinueTraversal(std::addressof(next_entry), std::addressof(context)),
                  ResultInvalidCurrentMemory);
 
         if (next_entry.phys_addr != (cur_addr + cur_size)) {
@@ -1858,7 +1828,7 @@ bool KPageTableBase::IsValidPageGroup(const KPageGroup& pg, KProcessAddress addr
     // Begin traversal.
     TraversalContext context;
     TraversalEntry next_entry;
-    if (!BeginTraversal(impl, std::addressof(next_entry), std::addressof(context), addr)) {
+    if (!impl.BeginTraversal(std::addressof(next_entry), std::addressof(context), addr)) {
         return false;
     }
 
@@ -1869,7 +1839,7 @@ bool KPageTableBase::IsValidPageGroup(const KPageGroup& pg, KProcessAddress addr
 
     // Iterate, comparing expected to actual.
     while (tot_size < size) {
-        if (!ContinueTraversal(impl, std::addressof(next_entry), std::addressof(context))) {
+        if (!impl.ContinueTraversal(std::addressof(next_entry), std::addressof(context))) {
             return false;
         }
 
@@ -1926,7 +1896,7 @@ Result KPageTableBase::GetContiguousMemoryRangeWithState(
     // Begin a traversal.
     TraversalContext context;
     TraversalEntry cur_entry = {.phys_addr = 0, .block_size = 0};
-    R_UNLESS(BeginTraversal(impl, std::addressof(cur_entry), std::addressof(context), address),
+    R_UNLESS(impl.BeginTraversal(std::addressof(cur_entry), std::addressof(context), address),
              ResultInvalidCurrentMemory);
 
     // Traverse until we have enough size or we aren't contiguous any more.
@@ -1935,7 +1905,7 @@ Result KPageTableBase::GetContiguousMemoryRangeWithState(
     for (contig_size =
              cur_entry.block_size - (GetInteger(phys_address) & (cur_entry.block_size - 1));
          contig_size < size; contig_size += cur_entry.block_size) {
-        if (!ContinueTraversal(impl, std::addressof(cur_entry), std::addressof(context))) {
+        if (!impl.ContinueTraversal(std::addressof(cur_entry), std::addressof(context))) {
             break;
         }
         if (cur_entry.phys_addr != phys_address + contig_size) {
@@ -2364,7 +2334,7 @@ Result KPageTableBase::QueryPhysicalAddress(Svc::lp64::PhysicalMemoryInfo* out,
         TraversalContext context;
         TraversalEntry next_entry;
         bool traverse_valid =
-            BeginTraversal(m_impl, std::addressof(next_entry), std::addressof(context), virt_addr);
+            m_impl.BeginTraversal(std::addressof(next_entry), std::addressof(context), virt_addr);
         R_UNLESS(traverse_valid, ResultInvalidCurrentMemory);
 
         // Set tracking variables.
@@ -2375,7 +2345,7 @@ Result KPageTableBase::QueryPhysicalAddress(Svc::lp64::PhysicalMemoryInfo* out,
         while (true) {
             // Continue the traversal.
             traverse_valid =
-                ContinueTraversal(m_impl, std::addressof(next_entry), std::addressof(context));
+                m_impl.ContinueTraversal(std::addressof(next_entry), std::addressof(context));
             if (!traverse_valid) {
                 break;
             }
@@ -2597,7 +2567,7 @@ Result KPageTableBase::UnmapIoRegion(KProcessAddress dst_address, KPhysicalAddre
         TraversalContext context;
         TraversalEntry next_entry;
         ASSERT(
-            BeginTraversal(impl, std::addressof(next_entry), std::addressof(context), dst_address));
+            impl.BeginTraversal(std::addressof(next_entry), std::addressof(context), dst_address));
 
         // Check that the physical region matches.
         R_UNLESS(next_entry.phys_addr == phys_addr, ResultInvalidMemoryRegion);
@@ -2607,7 +2577,7 @@ Result KPageTableBase::UnmapIoRegion(KProcessAddress dst_address, KPhysicalAddre
                  next_entry.block_size - (GetInteger(phys_addr) & (next_entry.block_size - 1));
              checked_size < size; checked_size += next_entry.block_size) {
             // Continue the traversal.
-            ASSERT(ContinueTraversal(impl, std::addressof(next_entry), std::addressof(context)));
+            ASSERT(impl.ContinueTraversal(std::addressof(next_entry), std::addressof(context)));
 
             // Check that the physical region matches.
             R_UNLESS(next_entry.phys_addr == phys_addr + checked_size, ResultInvalidMemoryRegion);
@@ -3059,7 +3029,7 @@ Result KPageTableBase::InvalidateProcessDataCache(KProcessAddress address, size_
     TraversalContext context;
     TraversalEntry next_entry;
     bool traverse_valid =
-        BeginTraversal(impl, std::addressof(next_entry), std::addressof(context), address);
+        impl.BeginTraversal(std::addressof(next_entry), std::addressof(context), address);
     R_UNLESS(traverse_valid, ResultInvalidCurrentMemory);
 
     // Prepare tracking variables.
@@ -3071,7 +3041,7 @@ Result KPageTableBase::InvalidateProcessDataCache(KProcessAddress address, size_
     while (tot_size < size) {
         // Continue the traversal.
         traverse_valid =
-            ContinueTraversal(impl, std::addressof(next_entry), std::addressof(context));
+            impl.ContinueTraversal(std::addressof(next_entry), std::addressof(context));
         R_UNLESS(traverse_valid, ResultInvalidCurrentMemory);
 
         if (next_entry.phys_addr != (cur_addr + cur_size)) {
@@ -3159,7 +3129,7 @@ Result KPageTableBase::ReadDebugMemory(KProcessAddress dst_address, KProcessAddr
     TraversalContext context;
     TraversalEntry next_entry;
     bool traverse_valid =
-        BeginTraversal(impl, std::addressof(next_entry), std::addressof(context), src_address);
+        impl.BeginTraversal(std::addressof(next_entry), std::addressof(context), src_address);
     R_UNLESS(traverse_valid, ResultInvalidCurrentMemory);
 
     // Prepare tracking variables.
@@ -3197,7 +3167,7 @@ Result KPageTableBase::ReadDebugMemory(KProcessAddress dst_address, KProcessAddr
     while (tot_size < size) {
         // Continue the traversal.
         traverse_valid =
-            ContinueTraversal(impl, std::addressof(next_entry), std::addressof(context));
+            impl.ContinueTraversal(std::addressof(next_entry), std::addressof(context));
         ASSERT(traverse_valid);
 
         if (next_entry.phys_addr != (cur_addr + cur_size)) {
@@ -3255,7 +3225,7 @@ Result KPageTableBase::WriteDebugMemory(KProcessAddress dst_address, KProcessAdd
     TraversalContext context;
     TraversalEntry next_entry;
     bool traverse_valid =
-        BeginTraversal(impl, std::addressof(next_entry), std::addressof(context), dst_address);
+        impl.BeginTraversal(std::addressof(next_entry), std::addressof(context), dst_address);
     R_UNLESS(traverse_valid, ResultInvalidCurrentMemory);
 
     // Prepare tracking variables.
@@ -3297,7 +3267,7 @@ Result KPageTableBase::WriteDebugMemory(KProcessAddress dst_address, KProcessAdd
     while (tot_size < size) {
         // Continue the traversal.
         traverse_valid =
-            ContinueTraversal(impl, std::addressof(next_entry), std::addressof(context));
+            impl.ContinueTraversal(std::addressof(next_entry), std::addressof(context));
         ASSERT(traverse_valid);
 
         if (next_entry.phys_addr != (cur_addr + cur_size)) {
@@ -3758,7 +3728,7 @@ Result KPageTableBase::CopyMemoryFromLinearToUser(
         TraversalContext context;
         TraversalEntry next_entry;
         bool traverse_valid =
-            BeginTraversal(impl, std::addressof(next_entry), std::addressof(context), src_addr);
+            impl.BeginTraversal(std::addressof(next_entry), std::addressof(context), src_addr);
         ASSERT(traverse_valid);
 
         // Prepare tracking variables.
@@ -3798,7 +3768,7 @@ Result KPageTableBase::CopyMemoryFromLinearToUser(
         while (tot_size < size) {
             // Continue the traversal.
             traverse_valid =
-                ContinueTraversal(impl, std::addressof(next_entry), std::addressof(context));
+                impl.ContinueTraversal(std::addressof(next_entry), std::addressof(context));
             ASSERT(traverse_valid);
 
             if (next_entry.phys_addr != (cur_addr + cur_size)) {
@@ -3852,7 +3822,7 @@ Result KPageTableBase::CopyMemoryFromLinearToKernel(
         TraversalContext context;
         TraversalEntry next_entry;
         bool traverse_valid =
-            BeginTraversal(impl, std::addressof(next_entry), std::addressof(context), src_addr);
+            impl.BeginTraversal(std::addressof(next_entry), std::addressof(context), src_addr);
         ASSERT(traverse_valid);
 
         // Prepare tracking variables.
@@ -3875,7 +3845,7 @@ Result KPageTableBase::CopyMemoryFromLinearToKernel(
         while (tot_size < size) {
             // Continue the traversal.
             traverse_valid =
-                ContinueTraversal(impl, std::addressof(next_entry), std::addressof(context));
+                impl.ContinueTraversal(std::addressof(next_entry), std::addressof(context));
             ASSERT(traverse_valid);
 
             if (next_entry.phys_addr != (cur_addr + cur_size)) {
@@ -3932,7 +3902,7 @@ Result KPageTableBase::CopyMemoryFromUserToLinear(
         TraversalContext context;
         TraversalEntry next_entry;
         bool traverse_valid =
-            BeginTraversal(impl, std::addressof(next_entry), std::addressof(context), dst_addr);
+            impl.BeginTraversal(std::addressof(next_entry), std::addressof(context), dst_addr);
         ASSERT(traverse_valid);
 
         // Prepare tracking variables.
@@ -3971,7 +3941,7 @@ Result KPageTableBase::CopyMemoryFromUserToLinear(
         while (tot_size < size) {
             // Continue the traversal.
             traverse_valid =
-                ContinueTraversal(impl, std::addressof(next_entry), std::addressof(context));
+                impl.ContinueTraversal(std::addressof(next_entry), std::addressof(context));
             ASSERT(traverse_valid);
 
             if (next_entry.phys_addr != (cur_addr + cur_size)) {
@@ -4027,7 +3997,7 @@ Result KPageTableBase::CopyMemoryFromKernelToLinear(KProcessAddress dst_addr, si
         TraversalContext context;
         TraversalEntry next_entry;
         bool traverse_valid =
-            BeginTraversal(impl, std::addressof(next_entry), std::addressof(context), dst_addr);
+            impl.BeginTraversal(std::addressof(next_entry), std::addressof(context), dst_addr);
         ASSERT(traverse_valid);
 
         // Prepare tracking variables.
@@ -4050,7 +4020,7 @@ Result KPageTableBase::CopyMemoryFromKernelToLinear(KProcessAddress dst_addr, si
         while (tot_size < size) {
             // Continue the traversal.
             traverse_valid =
-                ContinueTraversal(impl, std::addressof(next_entry), std::addressof(context));
+                impl.ContinueTraversal(std::addressof(next_entry), std::addressof(context));
             ASSERT(traverse_valid);
 
             if (next_entry.phys_addr != (cur_addr + cur_size)) {
@@ -4119,10 +4089,10 @@ Result KPageTableBase::CopyMemoryFromHeapToHeap(
         bool traverse_valid;
 
         // Begin traversal.
-        traverse_valid = BeginTraversal(src_impl, std::addressof(src_next_entry),
+        traverse_valid = src_impl.BeginTraversal(std::addressof(src_next_entry),
                                                  std::addressof(src_context), src_addr);
         ASSERT(traverse_valid);
-        traverse_valid = BeginTraversal(dst_impl, std::addressof(dst_next_entry),
+        traverse_valid = dst_impl.BeginTraversal(std::addressof(dst_next_entry),
                                                  std::addressof(dst_context), dst_addr);
         ASSERT(traverse_valid);
 
@@ -4157,7 +4127,7 @@ Result KPageTableBase::CopyMemoryFromHeapToHeap(
             if (ofs + cur_copy_size != size) {
                 if (cur_src_addr + cur_min_size == cur_src_block_addr + cur_src_size) {
                     // Continue the src traversal.
-                    traverse_valid = ContinueTraversal(src_impl, std::addressof(src_next_entry),
+                    traverse_valid = src_impl.ContinueTraversal(std::addressof(src_next_entry),
                                                                 std::addressof(src_context));
                     ASSERT(traverse_valid);
 
@@ -4168,7 +4138,7 @@ Result KPageTableBase::CopyMemoryFromHeapToHeap(
                 if (cur_dst_addr + cur_min_size ==
                     dst_next_entry.phys_addr + dst_next_entry.block_size) {
                     // Continue the dst traversal.
-                    traverse_valid = ContinueTraversal(dst_impl, std::addressof(dst_next_entry),
+                    traverse_valid = dst_impl.ContinueTraversal(std::addressof(dst_next_entry),
                                                                 std::addressof(dst_context));
                     ASSERT(traverse_valid);
 
@@ -4253,10 +4223,10 @@ Result KPageTableBase::CopyMemoryFromHeapToHeapWithoutCheckDestination(
         bool traverse_valid;
 
         // Begin traversal.
-        traverse_valid = BeginTraversal(src_impl, std::addressof(src_next_entry),
+        traverse_valid = src_impl.BeginTraversal(std::addressof(src_next_entry),
                                                  std::addressof(src_context), src_addr);
         ASSERT(traverse_valid);
-        traverse_valid = BeginTraversal(dst_impl, std::addressof(dst_next_entry),
+        traverse_valid = dst_impl.BeginTraversal(std::addressof(dst_next_entry),
                                                  std::addressof(dst_context), dst_addr);
         ASSERT(traverse_valid);
 
@@ -4291,7 +4261,7 @@ Result KPageTableBase::CopyMemoryFromHeapToHeapWithoutCheckDestination(
             if (ofs + cur_copy_size != size) {
                 if (cur_src_addr + cur_min_size == cur_src_block_addr + cur_src_size) {
                     // Continue the src traversal.
-                    traverse_valid = ContinueTraversal(src_impl, std::addressof(src_next_entry),
+                    traverse_valid = src_impl.ContinueTraversal(std::addressof(src_next_entry),
                                                                 std::addressof(src_context));
                     ASSERT(traverse_valid);
 
@@ -4302,7 +4272,7 @@ Result KPageTableBase::CopyMemoryFromHeapToHeapWithoutCheckDestination(
                 if (cur_dst_addr + cur_min_size ==
                     dst_next_entry.phys_addr + dst_next_entry.block_size) {
                     // Continue the dst traversal.
-                    traverse_valid = ContinueTraversal(dst_impl, std::addressof(dst_next_entry),
+                    traverse_valid = dst_impl.ContinueTraversal(std::addressof(dst_next_entry),
                                                                 std::addressof(dst_context));
                     ASSERT(traverse_valid);
 
@@ -4577,7 +4547,7 @@ Result KPageTableBase::SetupForIpcServer(KProcessAddress* out_addr, size_t size,
     // Begin traversal.
     TraversalContext context;
     TraversalEntry next_entry;
-    bool traverse_valid = BeginTraversal(src_impl, std::addressof(next_entry),
+    bool traverse_valid = src_impl.BeginTraversal(std::addressof(next_entry),
                                                   std::addressof(context), aligned_src_start);
     ASSERT(traverse_valid);
 
@@ -4627,7 +4597,7 @@ Result KPageTableBase::SetupForIpcServer(KProcessAddress* out_addr, size_t size,
         // If the block's size was one page, we may need to continue traversal.
         if (cur_block_size == 0 && aligned_src_size > PageSize) {
             traverse_valid =
-                ContinueTraversal(src_impl, std::addressof(next_entry), std::addressof(context));
+                src_impl.ContinueTraversal(std::addressof(next_entry), std::addressof(context));
             ASSERT(traverse_valid);
 
             cur_block_addr = next_entry.phys_addr;
@@ -4640,7 +4610,7 @@ Result KPageTableBase::SetupForIpcServer(KProcessAddress* out_addr, size_t size,
     while (aligned_src_start + tot_block_size < mapping_src_end) {
         // Continue the traversal.
         traverse_valid =
-            ContinueTraversal(src_impl, std::addressof(next_entry), std::addressof(context));
+            src_impl.ContinueTraversal(std::addressof(next_entry), std::addressof(context));
         ASSERT(traverse_valid);
 
         // Process the block.
@@ -4683,7 +4653,7 @@ Result KPageTableBase::SetupForIpcServer(KProcessAddress* out_addr, size_t size,
         if (mapped_block_end + cur_block_size < aligned_src_end &&
             cur_block_size == last_block_size) {
             traverse_valid =
-                ContinueTraversal(src_impl, std::addressof(next_entry), std::addressof(context));
+                src_impl.ContinueTraversal(std::addressof(next_entry), std::addressof(context));
             ASSERT(traverse_valid);
 
             cur_block_addr = next_entry.phys_addr;
@@ -5631,7 +5601,7 @@ Result KPageTableBase::UnmapProcessMemory(KProcessAddress dst_address, size_t si
             ContiguousRangeInfo(KPageTableBase& pt, KProcessAddress address, size_t size)
                 : m_pt(pt), m_remaining_size(size) {
                 // Begin a traversal.
-                ASSERT(m_pt.BeginTraversal(m_pt.GetImpl(), std::addressof(m_entry),
+                ASSERT(m_pt.GetImpl().BeginTraversal(std::addressof(m_entry),
                                                      std::addressof(m_context), address));
 
                 // Setup tracking fields.
@@ -5662,7 +5632,7 @@ Result KPageTableBase::UnmapProcessMemory(KProcessAddress dst_address, size_t si
             void DetermineContiguousBlockExtents() {
                 // Continue traversing until we're not contiguous, or we have enough.
                 while (m_cur_size < m_remaining_size) {
-                    ASSERT(m_pt.ContinueTraversal(m_pt.GetImpl(), std::addressof(m_entry),
+                    ASSERT(m_pt.GetImpl().ContinueTraversal(std::addressof(m_entry),
                                                             std::addressof(m_context)));
 
                     // If we're not contiguous, we're done.

src/core/hle/kernel/k_page_table_base.h

@@ -370,10 +370,6 @@ private:
                                  size_t num_pages, size_t alignment, size_t offset,
                                  size_t guard_pages) const;
 
-    bool BeginTraversal(const Common::PageTable& impl, TraversalEntry* out_entry, TraversalContext* out_context,
-                        Common::ProcessAddress address) const;
-    bool ContinueTraversal(const Common::PageTable& impl, TraversalEntry* out_entry, TraversalContext* context) const;
-
     Result CheckMemoryStateContiguous(size_t* out_blocks_needed, KProcessAddress addr, size_t size,
                                       KMemoryState state_mask, KMemoryState state,
                                       KMemoryPermission perm_mask, KMemoryPermission perm,
@@ -478,14 +474,7 @@ private:
         // Validate pre-conditions.
         ASSERT(this->IsLockedByCurrentThread());
 
-        if (virt_addr > (1ULL << m_address_space_width)) {
-            return false;
-        }
-
-        *out = m_system.DeviceMemory().GetPhysicalAddr(
-            this->GetImpl().entries[GetInteger(virt_addr) >> PageBits].Pointer(true) + GetInteger(virt_addr));
-
-        return true;
+        return this->GetImpl().GetPhysicalAddress(out, virt_addr);
     }
 
 public:

src/core/hle/service/am/window_system.cpp

@@ -517,7 +517,7 @@ void WindowSystem::UpdateAppletStateLocked(Applet* applet, bool is_foreground, b
     // Layer ordering. Composition sorts back-to-front. Now with enums for calrity.
     s32 z_index = Background;
     if (is_overlay) {
-        z_index = this->IsOverlayOpenLocked(*applet) ? Overlay : Background;
+        z_index = Overlay;
     } else if (inherited_foreground) {
         z_index = is_obscured ? Foreground : ForegroundVisible;
     }

src/core/hle/service/audio/audio.cpp

@@ -191,7 +191,7 @@ void LoopProcess(Core::System& system) {
     server_manager->RegisterNamedService("audout:d", std::make_shared<IAudioOutManagerForDebugger>(system), 30);
     server_manager->RegisterNamedService("audin:d", std::make_shared<IAudioInManagerForDebugger>(system), 30);
     server_manager->RegisterNamedService("audrec:d", std::make_shared<IFinalOutputRecorderManagerForDebugger>(system), 30);
-    server_manager->RegisterNamedService("audren:d", std::make_shared<IAudioRendererManagerForDebugger>(system), 30);
+    server_manager->RegisterNamedService("audren:d", std::make_shared<IAudioInManager>(system), 30);
 
     server_manager->RegisterNamedService("audin:u", std::make_shared<IAudioInManager>(system), 30);
     server_manager->RegisterNamedService("audin:a", std::make_shared<IAudioInManagerForApplet>(system), 30);

src/core/hle/service/psc/ovln/receiver_service.cpp

@@ -1,4 +1,4 @@
-// SPDX-FileCopyrightText: Copyright 2026 Eden Emulator Project
+// SPDX-FileCopyrightText: Copyright 2025 Eden Emulator Project
 // SPDX-License-Identifier: GPL-3.0-or-later
 
 // SPDX-FileCopyrightText: Copyright 2024 yuzu Emulator Project
@@ -24,7 +24,7 @@ IReceiverService::~IReceiverService() = default;
 
 Result IReceiverService::OpenReceiver(Out<SharedPointer<IReceiver>> out_receiver) {
     LOG_DEBUG(Service_PSC, "called");
-    *out_receiver = std::make_shared<IReceiver>(system);
+    *out_receiver = std::shared_ptr<IReceiver>(new IReceiver(system));
     R_SUCCEED();
 }
 

src/core/launch_params.cpp

@@ -1,205 +0,0 @@
-// SPDX-FileCopyrightText: Copyright 2026 Eden Emulator Project
-// SPDX-License-Identifier: GPL-3.0-or-later
-
-#include <regex>
-#include <cctype>
-
-#include "common/assert.h"
-#include "common/logging.h"
-#include "common/settings.h"
-#include "common/string_util.h"
-#include "common/scm_rev.h"
-#include "core/core.h"
-#include "core/hle/service/acc/profile_manager.h"
-#include "core/launch_params.h"
-
-#undef _UNICODE
-#include <getopt.h>
-#ifndef _MSC_VER
-#include <unistd.h>
-#endif
-
-namespace Core {
-LaunchParams ParseLaunchParams(Core::System& system, int argc, char *argv[], wchar_t *argv_w[]) noexcept {
-    LaunchParams p{};
-
-    int option_index = 0;
-    static struct option long_options[] = {
-        // clang-format off
-        {"debug", no_argument, 0, 'd'},
-        {"config", required_argument, 0, 'c'},
-        {"fullscreen", no_argument, 0, 'f'},
-        {"help", no_argument, 0, 'h'},
-        {"game", required_argument, 0, 'g'},
-        {"multiplayer", required_argument, 0, 'm'},
-        {"program", optional_argument, 0, 'p'},
-        {"user", required_argument, 0, 'u'},
-        {"version", no_argument, 0, 'v'},
-        {"input-profile", no_argument, 0, 'i'},
-        {"null-render", no_argument, 0, 'n'},
-        {"singlecore", no_argument, 0, 's'},
-        {"filter", no_argument, 0, 'x'},
-        {0, 0, 0, 0},
-        // clang-format on
-    };
-
-    while (optind < argc) {
-        if (int arg = getopt_long(argc, argv, "dc:fhg:m:p:u:vinsx", long_options, &option_index); arg != -1) {
-            switch (char(arg)) {
-            case 'd':
-                p.override_gdb_port = uint16_t(atoi(optarg));
-                break;
-            case 'c':
-                p.config_path = optarg;
-                break;
-            case 'f':
-                p.fullscreen = true;
-                LOG_INFO(Frontend, "Starting in fullscreen mode...");
-                break;
-            case 'h':
-                p.print_help = true;
-                break;
-            case 'g':
-                p.filepath = std::string(optarg);
-                break;
-            case 'i': {
-                p.input_profile = std::string(optarg);
-                break;
-            }
-            case 'm': {
-                p.use_multiplayer = true;
-                const std::string str_arg(optarg);
-                // regex to check if the format is nickname:password@ip:port
-                // with optional :password
-                const std::regex re("^([^:]+)(?::(.+))?@([^:]+)(?::([0-9]+))?$");
-                if (std::regex_match(str_arg, re)) {
-                    std::smatch match;
-                    std::regex_search(str_arg, match, re);
-                    ASSERT(match.size() == 5);
-                    p.nickname = match[1];
-                    p.password = match[2];
-                    p.address = match[3];
-                    if (!match[4].str().empty()) {
-                        p.port = u16(std::strtoul(match[4].str().c_str(), nullptr, 0));
-                    }
-                    std::regex nickname_re("^[a-zA-Z0-9._\\- ]+$");
-                    ASSERT(std::regex_match(p.nickname, nickname_re) && "Nickname is not valid. Must be 4 to 20 alphanumeric characters");
-                    ASSERT(!p.address.empty() && "Address is empty");
-                }
-                break;
-            }
-            case 'p':
-                p.program_args = argv[optind];
-                ++optind;
-                break;
-            case 'u': {
-                // Launch game with a specific user
-                bool argument_ok = isdigit(optarg[0]);
-                p.selected_user = atoi(optarg);
-                if (!argument_ok) {
-                    // try to look it up by username, only finds the first username that matches.
-                    auto const user_idx = system.GetProfileManager().GetUserIndex(optarg);
-                    if (user_idx != std::nullopt) {
-                        p.selected_user = user_idx.value();
-                    } else {
-                        LOG_ERROR(Frontend, "Invalid user argument '{}'", optarg);
-                        break;
-                    }
-                }
-                if (system.GetProfileManager().UserExistsIndex(*p.selected_user)) {
-                    Settings::values.current_user = s32(*p.selected_user);
-                } else {
-                    LOG_ERROR(Frontend, "Selected user {} doesn't exist", *p.selected_user);
-                }
-                break;
-            }
-            case 'v':
-                p.print_version = true;
-                break;
-            case 'n':
-                p.force_null_render = true;
-                break;
-            case 's':
-                p.force_single_core = true;
-                break;
-            case 'x':
-                p.log_filter = argv[optind];
-                ++optind;
-                break;
-            }
-        } else {
-            // only kept due to shortcuts made by Qt frontend which use "-qlaunch"
-            if (strcmp(argv[optind], "-hlaunch") == 0) {
-                p.launch_hlaunch = true;
-            } else if (strcmp(argv[optind], "-qlaunch") == 0) {
-                p.launch_qlaunch = true;
-            } else if (strcmp(argv[optind], "-setup") == 0) {
-                p.launch_setup = true;
-            } else {
-                // qt feeds utf8 data, sdl frontend feeds raw utf16 data
-#ifdef _WIN32
-                p.filepath = argv_w != nullptr
-                    ? Common::UTF16ToUTF8(argv_w[optind])
-                    : argv[optind];
-#else
-                p.filepath = argv[optind];
-#endif
-            }
-            optind++;
-        }
-    }
-    p.argv0 = argv[0];
-    return p;
-}
-
-void ApplyLaunchParams(LaunchParams const& lp) noexcept {
-    // apply the log_filter setting
-    // the logger was initialized before and doesn't pick up the filter on its own
-    Common::Log::Filter filter{};
-    filter.ParseFilterString(lp.log_filter.value_or(Settings::values.log_filter.GetValue()));
-    Common::Log::SetGlobalFilter(filter);
-
-    if (!lp.program_args.empty()) {
-        Settings::values.program_args = lp.program_args;
-    }
-    if (!lp.input_profile.empty()) {
-        auto& players = Settings::values.players.GetValue();
-        players[0].profile_name = lp.input_profile;
-    }
-    if (lp.selected_user.has_value()) {
-        Settings::values.current_user = std::clamp(*lp.selected_user, 0, 7);
-    }
-    if (lp.override_gdb_port.has_value()) {
-        Settings::values.use_gdbstub = true;
-        Settings::values.gdbstub_port = *lp.override_gdb_port;
-    }
-    if (lp.force_single_core) {
-        Settings::values.use_multi_core = false;
-    }
-    if (lp.force_null_render) {
-        Settings::values.renderer_backend = Settings::RendererBackend::Null;
-    }
-
-    if (lp.print_version) {
-        LOG_INFO(Frontend, "Eden {} {}", Common::g_scm_branch, Common::g_scm_desc);
-    }
-    if (lp.print_help) {
-        LOG_INFO(Frontend,
-            "Usage: {}"
-            " [options] <filename>\n"
-            "-c, --config          Load the specified configuration file\n"
-            "-f, --fullscreen      Start in fullscreen mode\n"
-            "-g, --game            File path of the game to load\n"
-            "-h, --help            Display this help and exit\n"
-            "-m, --multiplayer=nick:password@address:port"
-            " Nickname, password, address and port for multiplayer\n"
-            "-p, --program         Pass following string as arguments to executable\n"
-            "-u, --user            Select a specific user profile from 0 to 7\n"
-            "-d, --debug           Run the GDB stub on a port from 1 to 65535\n"
-            "-v, --version         Output version information and exit\n",
-            lp.argv0
-        );
-    }
-}
-
-}

src/core/launch_params.h

@@ -1,43 +0,0 @@
-// SPDX-FileCopyrightText: Copyright 2026 Eden Emulator Project
-// SPDX-License-Identifier: GPL-3.0-or-later
-
-#pragma once
-
-#include <string>
-#include <optional>
-#include "common/common_types.h"
-#include "network/room.h"
-
-namespace Core {
-
-class System;
-struct LaunchParams {
-    std::string argv0{};
-    std::string filepath{};
-    std::string nickname{};
-    std::string password{};
-    std::string address{};
-    std::string input_profile{};
-    std::string program_args{};
-    std::optional<std::string> config_path{};
-    std::optional<int> selected_user{};
-    std::optional<u16> override_gdb_port{};
-    std::optional<std::string> log_filter{};
-    u16 port = Network::DefaultRoomPort;
-    bool use_multiplayer = false;
-    bool fullscreen = false;
-    bool force_null_render = false;
-    bool force_single_core = false;
-    // print
-    bool print_version = false;
-    bool print_help = false;
-    // qt
-    bool launch_hlaunch = false;
-    bool launch_qlaunch = false;
-    bool launch_setup = false;
-};
-
-LaunchParams ParseLaunchParams(Core::System& system, int argc, char *argv[], wchar_t *argv_w[]) noexcept;
-void ApplyLaunchParams(LaunchParams const& lp) noexcept;
-
-}

src/core/loader/loader.cpp

@@ -10,7 +10,6 @@
 #include <string>
 #include <concepts>
 #include <algorithm>
-#include <boost/algorithm/string/case_conv.hpp>
 #include "common/concepts.h"
 #include "common/fs/path_util.h"
 #include "common/logging.h"
@@ -171,7 +170,8 @@ FileType GuessFromFilename(const std::string& name) {
     else if (name == "00")
         return FileType::NCA;
 
-    auto const extension = boost::algorithm::to_lower_copy(std::string(Common::FS::GetExtensionFromFilename(name)));
+    auto const extension =
+        Common::ToLower(std::string(Common::FS::GetExtensionFromFilename(name)));
     if (extension == "nro")
         return FileType::NRO;
     else if (extension == "nso")

src/core/loader/nso.cpp

@@ -7,14 +7,12 @@
 #include <algorithm>
 #include <cinttypes>
 #include <cstring>
-#include <span>
 #include <vector>
 
 #include "common/common_funcs.h"
 #include "common/hex_util.h"
 #include "common/logging.h"
 #include "common/lz4_compression.h"
-#include "common/zbic_compression.h"
 #include "common/settings.h"
 #include "common/swap.h"
 #include "core/core.h"
@@ -106,36 +104,11 @@ std::optional<VAddr> AppLoader_NSO::LoadModule(Kernel::KProcess& process, Core::
         for (std::size_t i = 0; i < nso_header.segments.size(); ++i) {
             nso_file.Read(compressed_data.data(), nso_header.segments_compressed_size[i], nso_header.segments[i].offset);
             if (nso_header.IsSegmentCompressed(i)) {
-                if (nso_header.IsZBICCompressed()) {
-                    // ZBIC compression
-                    const int r = Common::Compression::DecompressDataZBIC(
-                        std::span<u8>{decompressed_size}.first(nso_header.segments[i].size),
-                        std::span<const u8>{compressed_data}.first(nso_header.segments_compressed_size[i])
-                    );
-                    ASSERT(r > 0);
-                } else {
-                    // LZ4 compression
-                    int r = Common::Compression::DecompressDataLZ4(
-                        decompressed_size.data(),
-                        nso_header.segments[i].size,
-                        compressed_data.data(),
-                        nso_header.segments_compressed_size[i]
-                    );
-                    ASSERT(r == int(nso_header.segments[i].size));
-                }
-
-                std::memcpy(
-                    codeset.memory.data() + module_start + nso_header.segments[i].location,
-                    decompressed_size.data(),
-                    nso_header.segments[i].size
-                );
+                int r = Common::Compression::DecompressDataLZ4(decompressed_size.data(), nso_header.segments[i].size, compressed_data.data(), nso_header.segments_compressed_size[i]);
+                ASSERT(r == int(nso_header.segments[i].size));
+                std::memcpy(codeset.memory.data() + module_start + nso_header.segments[i].location, decompressed_size.data(), nso_header.segments[i].size);
             } else {
-                // Not compressed
-                std::memcpy(
-                    codeset.memory.data() + module_start + nso_header.segments[i].location,
-                    compressed_data.data(),
-                    nso_header.segments[i].size
-                );
+                std::memcpy(codeset.memory.data() + module_start + nso_header.segments[i].location, compressed_data.data(), nso_header.segments[i].size);
             }
             codeset.segments[i].addr = module_start + nso_header.segments[i].location;
             codeset.segments[i].offset = module_start + nso_header.segments[i].location;

src/core/loader/nso.h

@@ -1,6 +1,3 @@
-// SPDX-FileCopyrightText: Copyright 2026 Eden Emulator Project
-// SPDX-License-Identifier: GPL-3.0-or-later
-
 // SPDX-FileCopyrightText: Copyright 2018 yuzu Emulator Project
 // SPDX-License-Identifier: GPL-2.0-or-later
 
@@ -61,9 +58,6 @@ struct NSOHeader {
     std::array<SHA256Hash, 3> segment_hashes;
 
     bool IsSegmentCompressed(size_t segment_num) const;
-    bool IsZBICCompressed() const {
-        return ((flags >> 7) & 1) != 0;
-    }
 };
 static_assert(sizeof(NSOHeader) == 0x100, "NSOHeader has incorrect size.");
 static_assert(std::is_trivially_copyable_v<NSOHeader>, "NSOHeader must be trivially copyable.");

src/core/memory.cpp

@@ -101,10 +101,8 @@ struct Memory::Impl {
         }
 
         u64 protect_bytes = 0, protect_begin = 0;
-
-        current_page_table->entries.CommitRegion(vaddr >> YUZU_PAGEBITS, (vaddr + size) >> YUZU_PAGEBITS);
         for (u64 addr = vaddr; addr < vaddr + size; addr += YUZU_PAGESIZE) {
-            const Common::PageType page_type = current_page_table->entries.GetUnchecked(addr >> YUZU_PAGEBITS).Type();
+            const Common::PageType page_type = current_page_table->entries[addr >> YUZU_PAGEBITS].ptr.Type();
             switch (page_type) {
             case Common::PageType::RasterizerCachedMemory:
                 if (protect_bytes > 0) {
@@ -125,14 +123,16 @@ struct Memory::Impl {
     }
 
     [[nodiscard]] u8* GetPointerFromRasterizerCachedMemory(u64 vaddr) const {
-        if (u64 paddr = current_page_table->entries[vaddr >> YUZU_PAGEBITS].Pointer(true); paddr)
-            return reinterpret_cast<u8*>(paddr) + vaddr;
+        Common::PhysicalAddress const paddr = current_page_table->entries[vaddr >> YUZU_PAGEBITS].addr;
+        if (paddr)
+            return system.DeviceMemory().GetPointer<u8>(paddr + vaddr);
         return {};
     }
 
     [[nodiscard]] u8* GetPointerFromDebugMemory(u64 vaddr) const {
-        if (u64 paddr = current_page_table->entries[vaddr >> YUZU_PAGEBITS].Pointer(true); paddr)
-            return reinterpret_cast<u8*>(paddr) + vaddr;
+        const Common::PhysicalAddress paddr = current_page_table->entries[vaddr >> YUZU_PAGEBITS].addr;
+        if (paddr != 0)
+            return system.DeviceMemory().GetPointer<u8>(paddr + vaddr);
         return {};
     }
 
@@ -243,12 +243,10 @@ struct Memory::Impl {
         std::size_t page_index = addr >> YUZU_PAGEBITS;
         std::size_t page_offset = addr & YUZU_PAGEMASK;
         bool user_accessible = true;
-
-        current_page_table->entries.CommitRegion(page_index, page_index + (size >> YUZU_PAGEBITS) + 1);
         while (remaining_size != 0) {
             const std::size_t copy_amount = (std::min)(std::size_t(YUZU_PAGESIZE) - page_offset, remaining_size);
             const auto current_vaddr = u64((page_index << YUZU_PAGEBITS) + page_offset);
-            const auto [pointer, type, _] = current_page_table->entries.GetUnchecked(page_index).PointerTypeBlock();
+            const auto [pointer, type] = current_page_table->entries[page_index].ptr.PointerType();
             switch (type) {
             case Common::PageType::Unmapped: {
                 user_accessible = false;
@@ -299,10 +297,10 @@ struct Memory::Impl {
     }
 
     [[nodiscard]] inline const u8* GetSpan(const VAddr addr, const std::size_t size) const noexcept {
-        return (current_page_table->entries[addr >> YUZU_PAGEBITS].Block() == current_page_table->entries[(addr + size) >> YUZU_PAGEBITS].Block()) ? GetPointerSilent(addr) : nullptr;
+        return (current_page_table->entries[addr >> YUZU_PAGEBITS].block == current_page_table->entries[(addr + size) >> YUZU_PAGEBITS].block) ? GetPointerSilent(addr) : nullptr;
     }
     [[nodiscard]] inline u8* GetSpan(const VAddr addr, const std::size_t size) noexcept {
-        return (current_page_table->entries[addr >> YUZU_PAGEBITS].Block() == current_page_table->entries[(addr + size) >> YUZU_PAGEBITS].Block()) ? GetPointerSilent(addr) : nullptr;
+        return (current_page_table->entries[addr >> YUZU_PAGEBITS].block == current_page_table->entries[(addr + size) >> YUZU_PAGEBITS].block) ? GetPointerSilent(addr) : nullptr;
     }
 
     bool WriteBlockImpl(const Common::ProcessAddress addr, const void* buffer, const std::size_t size, bool unsafe) {
@@ -406,14 +404,11 @@ struct Memory::Impl {
         // The region is at a granularity of CPU pages.
 
         const u64 num_pages = ((vaddr + size - 1) >> YUZU_PAGEBITS) - (vaddr >> YUZU_PAGEBITS) + 1;
-
-        current_page_table->entries.CommitRegion(vaddr >> YUZU_PAGEBITS, (vaddr >> YUZU_PAGEBITS) + num_pages);
         for (u64 i = 0; i < num_pages; ++i, vaddr += YUZU_PAGESIZE) {
-            auto& entry = current_page_table->entries.GetUnchecked(vaddr >> YUZU_PAGEBITS);
-            const auto [pointer, type, block] = entry.PointerTypeBlock(true);
+            const Common::PageType page_type = current_page_table->entries[vaddr >> YUZU_PAGEBITS].ptr.Type();
             if (debug) {
                 // Switch page type to debug if now debug
-                switch (type) {
+                switch (page_type) {
                 case Common::PageType::Unmapped:
                     ASSERT(false && "Attempted to mark unmapped pages as debug");
                     break;
@@ -422,14 +417,14 @@ struct Memory::Impl {
                     // Page is already marked.
                     break;
                 case Common::PageType::Memory:
-                    entry.MarkDebug(pointer, block);
+                    current_page_table->entries[vaddr >> YUZU_PAGEBITS].ptr.Store(0, Common::PageType::DebugMemory);
                     break;
                 default:
                     UNREACHABLE();
                 }
             } else {
                 // Switch page type to non-debug if now non-debug
-                switch (type) {
+                switch (page_type) {
                 case Common::PageType::Unmapped:
                     ASSERT(false && "Attempted to mark unmapped pages as non-debug");
                     break;
@@ -438,7 +433,8 @@ struct Memory::Impl {
                     // Don't mess with already non-debug or rasterizer memory.
                     break;
                 case Common::PageType::DebugMemory: {
-                    entry.Store(false, Common::PageType::Memory, block, pointer);
+                    u8* const pointer = GetPointerFromDebugMemory(vaddr & ~YUZU_PAGEMASK);
+                    current_page_table->entries[vaddr >> YUZU_PAGEBITS].ptr.Store(uintptr_t(pointer) - (vaddr & ~YUZU_PAGEMASK), Common::PageType::Memory);
                     break;
                 }
                 default:
@@ -470,10 +466,8 @@ struct Memory::Impl {
         // is different). This assumes the specified GPU address region is contiguous as well.
 
         const u64 num_pages = ((vaddr + size - 1) >> YUZU_PAGEBITS) - (vaddr >> YUZU_PAGEBITS) + 1;
-        current_page_table->entries.CommitRegion(vaddr >> YUZU_PAGEBITS, (vaddr >> YUZU_PAGEBITS) + num_pages);
         for (u64 i = 0; i < num_pages; ++i, vaddr += YUZU_PAGESIZE) {
-            auto& entry = current_page_table->entries.GetUnchecked(vaddr >> YUZU_PAGEBITS);
-            const Common::PageType page_type = entry.Type();
+            const Common::PageType page_type= current_page_table->entries[vaddr >> YUZU_PAGEBITS].ptr.Type();
             if (cached) {
                 // Switch page type to cached if now cached
                 switch (page_type) {
@@ -483,7 +477,7 @@ struct Memory::Impl {
                     break;
                 case Common::PageType::DebugMemory:
                 case Common::PageType::Memory:
-                    entry.MarkRasterizerCached();
+                    current_page_table->entries[vaddr >> YUZU_PAGEBITS].ptr.Store(0, Common::PageType::RasterizerCachedMemory);
                     break;
                 case Common::PageType::RasterizerCachedMemory:
                     // There can be more than one GPU region mapped per CPU region, so it's common
@@ -505,13 +499,13 @@ struct Memory::Impl {
                     // that this area is already unmarked as cached.
                     break;
                 case Common::PageType::RasterizerCachedMemory: {
-                    if (auto [ptr, _, block] = entry.PointerTypeBlock(true); ptr == 0) {
+                    if (u8* const pointer = GetPointerFromRasterizerCachedMemory(vaddr & ~YUZU_PAGEMASK); pointer == nullptr) {
                         // It's possible that this function has been called while updating the
                         // pagetable after unmapping a VMA. In that case the underlying VMA will no
                         // longer exist, and we should just leave the pagetable entry blank.
-                        entry.Store(false, Common::PageType::Unmapped, block, 0);
+                        current_page_table->entries[vaddr >> YUZU_PAGEBITS].ptr.Store(0, Common::PageType::Unmapped);
                     } else {
-                        entry.Store(false, Common::PageType::Memory, block, ptr);
+                        current_page_table->entries[vaddr >> YUZU_PAGEBITS].ptr.Store(uintptr_t(pointer) - (vaddr & ~YUZU_PAGEMASK), Common::PageType::Memory);
                     }
                     break;
                 }
@@ -545,18 +539,22 @@ struct Memory::Impl {
             ASSERT_MSG(type != Common::PageType::Memory,
                        "Mapping memory page without a pointer @ {:016x}", base * YUZU_PAGESIZE);
 
-            page_table.entries.ZeroRegion(base, end);
-        } else {
-            auto current_block = block_count.fetch_add(1, std::memory_order_relaxed);
-            ASSERT(current_block != 65535);
-
-            page_table.entries.CommitRegion(base, end);
             while (base != end) {
-                auto host_ptr = reinterpret_cast<u64>(system.DeviceMemory().GetPointer<u8>(target)) - (base << YUZU_PAGEBITS);;
-                auto& entry = page_table.entries.GetUnchecked(base);
+                page_table.entries[base].ptr.Store(0, type);
+                page_table.entries[base].addr = 0;
+                page_table.entries[base].block = 0;
+                base += 1;
+            }
+        } else {
+            auto orig_base = base;
+            while (base != end) {
+                auto host_ptr = uintptr_t(system.DeviceMemory().GetPointer<u8>(target)) - (base << YUZU_PAGEBITS);
+                auto backing = GetInteger(target) - (base << YUZU_PAGEBITS);
+                page_table.entries[base].ptr.Store(host_ptr, type);
+                page_table.entries[base].addr = backing;
+                page_table.entries[base].block = orig_base << YUZU_PAGEBITS;
 
-                entry.Store(false, type, current_block, host_ptr);
-                ASSERT_MSG(page_table.entries[base].Pointer(),
+                ASSERT_MSG(page_table.entries[base].ptr.Pointer(),
                            "memory mapping base yield a nullptr within the table");
 
                 base += 1;
@@ -571,11 +569,11 @@ struct Memory::Impl {
         vaddr &= 0xffffffffffffULL;
         if (AddressSpaceContains(*current_page_table, vaddr, 1)) [[likely]] {
             // Avoid adding any extra logic to this fast-path block
-            const auto raw = current_page_table->entries[vaddr >> YUZU_PAGEBITS].Raw();
-            if (auto pointer = Common::PageTable::PageEntryData::ExtractPointer(raw); pointer) [[likely]] {
+            const uintptr_t raw_pointer = current_page_table->entries[vaddr >> YUZU_PAGEBITS].ptr.Raw();
+            if (const uintptr_t pointer = Common::PageTable::PageInfo::ExtractPointer(raw_pointer)) [[likely]] {
                 return reinterpret_cast<u8*>(pointer + vaddr);
             } else {
-                switch (static_cast<Common::PageType>(raw.type)) {
+                switch (Common::PageTable::PageInfo::ExtractType(raw_pointer)) {
                 case Common::PageType::Memory:
                     ASSERT_MSG(false, "Mapped memory page without a pointer @ {:#016x}", vaddr);
                     return nullptr;
@@ -775,7 +773,6 @@ struct Memory::Impl {
 #else
     Common::HostMemory* host_buffer{};
 #endif
-    std::atomic<u16> block_count = 0;
 };
 
 Memory::Memory(Core::System& system_) : system{system_} {
@@ -814,7 +811,7 @@ bool Memory::IsValidVirtualAddress(const Common::ProcessAddress vaddr) const {
     if (page >= page_table.entries.size()) {
         return false;
     }
-    const auto [pointer, type, _] = page_table.entries[page].PointerTypeBlock();
+    const auto [pointer, type] = page_table.entries[page].ptr.PointerType();
     return pointer != 0 || type == Common::PageType::RasterizerCachedMemory ||
            type == Common::PageType::DebugMemory;
 }

src/dedicated_room/yuzu_room.cpp

@@ -14,7 +14,6 @@
 #include <regex>
 #include <string>
 #include <thread>
-#include <boost/algorithm/string/trim.hpp>
 
 #ifdef _WIN32
 // windows.h needs to be included before shellapi.h
@@ -133,7 +132,7 @@ static Network::Room::BanList LoadBanList(const std::string& path) {
         std::string line;
         std::getline(file, line);
         line.erase(std::remove(line.begin(), line.end(), '\0'), line.end());
-        boost::trim(line);
+        line = Common::StripSpaces(line);
         if (line.empty()) {
             // An empty line marks start of the IP ban list
             ban_list_type = true;

src/dynarmic/src/dynarmic/backend/arm64/a32_address_space.cpp

@@ -407,10 +407,8 @@ EmitConfig A32AddressSpace::GetEmitConfig() {
 
         .page_table_pointer = std::bit_cast<u64>(conf.page_table),
         .page_table_address_space_bits = 32,
-        .page_table_pointer_mask = conf.page_table_pointer_mask,
+        .page_table_pointer_mask_bits = conf.page_table_pointer_mask_bits,
         .page_table_log2_stride = conf.page_table_log2_stride,
-        .page_table_marked_bit = conf.page_table_marked_bit,
-        .page_table_sign_extension = conf.page_table_sign_extension,
         .silently_mirror_page_table = true,
         .absolute_offset_page_table = conf.absolute_offset_page_table,
         .detect_misaligned_access_via_page_table = conf.detect_misaligned_access_via_page_table,