Fix licenses

Revert "Address turnip bug with depths"
Address some regressions with unswizzle changes + barriers reductions
2026-10-08 06:36:01 +00:00 · 2026-10-05 18:44:01 -04:00 · 2026-10-02 03:59:24 -04:00 · 2026-10-02 01:41:19 -04:00 · 2026-10-02 00:47:24 -04:00 · 2026-10-01 23:56:07 -04:00
326 changed files with 8514 additions and 17211 deletions
@@ -1,20 +0,0 @@
-#!/bin/sh -ex
-
-# SPDX-FileCopyrightText: Copyright 2026 Eden Emulator Project
-# SPDX-License-Identifier: GPL-3.0-or-later
-
-WORK_DIR="$PWD"
-xcrun --sdk iphoneos --show-sdk-path
-
-# TODO: support iphonesimulator sdk
-
-cmake -G Xcode -B build/ios \
-    -DCMAKE_OSX_DEPLOYMENT_TARGET=16.0 \
-    -DCMAKE_OSX_SYSROOT=iphoneos \
-    -DCMAKE_SYSTEM_NAME=iOS \
-    -DCMAKE_OSX_ARCHITECTURES="arm64" \
-    -DCMAKE_BUILD_TYPE=Release \
-    -DYUZU_USE_EXTERNAL_SDL2=ON \
-    "$@"
-
-cmake --build build/ios -t eden-ios --config Release
@@ -115,7 +115,7 @@ for file in $FILES; do
 		*.cmake|*.sh|*.ps1|*.py|*.rb|*.perl|*.pl|*.nix|*CMakeLists.txt)
 			begin="#"
 			;;
-		*.kt|*.kts|*.cpp|*.h|*.qml|*.c|*.hpp|*.hxx|*.cxx|*.h.in|*.inc|*.mm)
+		*.kt|*.kts|*.cpp|*.h|*.qml|*.c|*.hpp|*.hxx|*.cxx|*.h.in|*.inc)
 			begin="//"
 			;;
 		*)
@@ -1,31 +0,0 @@
-diff --git a/libs/process/src/shell.cpp b/libs/process/src/shell.cpp
-index bf4bbfd8..bc4aae89 100644
--- a/libs/process/src/shell.cpp
-+++ b/libs/process/src/shell.cpp
-@@ -19,7 +19,7 @@
- #if defined(BOOST_PROCESS_V2_WINDOWS)
- #include <windows.h>
- #include <shellapi.h>
-#elif !defined(__OpenBSD__) && !defined(__ANDROID__)
-+#elif !defined(__OpenBSD__) && !defined(__ANDROID__) && !(defined(__APPLE__) && TARGET_OS_IPHONE)
- #include <wordexp.h>
- #endif
- 
-@@ -30,7 +30,7 @@ BOOST_PROCESS_V2_DECL const error_category& get_shell_category()
- {
-     return system_category();
- }
-#elif !defined(__OpenBSD__) && !defined(__ANDROID__)
-+#elif !defined(__OpenBSD__) && !defined(__ANDROID__) && !(defined(__APPLE__) && TARGET_OS_IPHONE)
- 
- struct shell_category_t final : public error_category
- {
-@@ -99,7 +99,7 @@ auto shell::args() const-> args_type
-     return input_.c_str();
- }
- 
-#elif !defined(__OpenBSD__) && !defined(__ANDROID__)
-+#elif !defined(__OpenBSD__) && !defined(__ANDROID__) && !(defined(__APPLE__) && TARGET_OS_IPHONE)
- 
- void shell::parse_()
- {
@@ -24,29 +24,6 @@ include(CMakeDependentOption)
 include(CTest)
 include(CPMUtil)

-# TODO(crueter): Make this more automatic.
-if (IOS)
-    list(APPEND CMAKE_FIND_ROOT_PATH "${CMAKE_OSX_SYSROOT_INT}" CACHE INTERNAL "")
-    list(APPEND CMAKE_PROGRAM_PATH "/opt/homebrew/bin" CACHE INTERNAL "")
-
-    set(CMAKE_FIND_ROOT_PATH_MODE_PROGRAM BOTH CACHE INTERNAL "")
-    set(CMAKE_FIND_ROOT_PATH_MODE_LIBRARY BOTH CACHE INTERNAL "")
-    set(CMAKE_FIND_ROOT_PATH_MODE_INCLUDE BOTH CACHE INTERNAL "")
-    set(CMAKE_FIND_ROOT_PATH_MODE_PACKAGE BOTH CACHE INTERNAL "")
-
-    list(LENGTH CMAKE_OSX_ARCHITECTURES _arch_len)
-    if (NOT _arch_len EQUAL 1)
-        message(FATAL_ERROR "CMAKE_OSX_ARCHITECTURES must contain exactly one architecture.")
-    endif()
-
-    # TODO(crueter): Proper handling for this.
-    if (CMAKE_OSX_ARCHITECTURES STREQUAL arm64)
-        set(CMAKE_SYSTEM_PROCESSOR aarch64)
-    else()
-        set(CMAKE_SYSTEM_PROCESSOR ${CMAKE_OSX_ARCHITECTURES})
-    endif()
-endif()
-
 if (NOT DEFINED ARCHITECTURE)
    message(FATAL_ERROR "Architecture didn't make it out of scope, did you delete DetectArchitecture.cmake?")
 endif()
@@ -68,7 +45,7 @@ if (NETBSD)
    set(ENV{PKG_CONFIG_PATH} "${PKG_CONFIG_PATH}:${CMAKE_SYSROOT}/usr/pkg/lib/ffmpeg7/pkgconfig")
 endif()

-cmake_dependent_option(YUZU_STATIC_ROOM "Build a static room executable only (CI only)" OFF "LINUX OR (APPLE AND NOT IOS)" OFF)
+cmake_dependent_option(YUZU_STATIC_ROOM "Build a static room executable only (CI only)" OFF "LINUX" OFF)
 if (YUZU_STATIC_ROOM)
    set(YUZU_ROOM ON)
    set(YUZU_ROOM_STANDALONE ON)
@@ -94,15 +71,9 @@ if (YUZU_STATIC_ROOM)
 endif()

 # qt stuff
-if (IOS OR ANDROID)
-    set(_default_qt OFF)
-else()
-    set(_default_qt ON)
-endif()
-
-option(ENABLE_QT "Enable the Qt frontend" ${_default_qt})
+option(ENABLE_QT "Enable the Qt frontend" ON)
 option(ENABLE_QT_TRANSLATION "Enable translations for the Qt frontend" OFF)
-cmake_dependent_option(ENABLE_UPDATE_CHECKER "Enable update checker (for Qt and Android)" OFF "ENABLE_QT OR ANDROID" OFF)
+option(ENABLE_UPDATE_CHECKER "Enable update checker (for Qt and Android)" OFF)
 cmake_dependent_option(YUZU_USE_QT_MULTIMEDIA "Use QtMultimedia for Camera"  OFF "NOT YUZU_USE_BUNDLED_QT" OFF)
 cmake_dependent_option(YUZU_USE_QT_WEB_ENGINE "Use QtWebEngine for web applet implementation" OFF "NOT YUZU_USE_BUNDLED_QT" OFF)
 set(YUZU_QT_MIRROR "" CACHE STRING "What mirror to use for downloading the bundled Qt libraries")
@@ -111,8 +82,8 @@ cmake_dependent_option(YUZU_USE_BUNDLED_QT "Download bundled Qt binaries" "${MSV
 option(ENABLE_DEBUG_TOOLS "Enable debugging tools (maxwell disassembler, SPIRV translator, etc)" OFF)
 option(ENABLE_WERROR "Enable -Werror diagnostics" ON)

-# Lossless Scaling frame generation. Only Android.
-cmake_dependent_option(ENABLE_LSFG "Enable Lossless Scaling frame generation" ON "ANDROID" OFF)
+# Lossless Scaling frame generation.
+option(ENABLE_LSFG "Enable Lossless Scaling frame generation" ON)

 option(ENABLE_RESHADE "Enable ReShade FX post-processing effects" ON)

@@ -249,7 +220,7 @@ endif()
 option(ENABLE_CUBEB "Enables the cubeb audio backend" ON)

 set(EXT_DEFAULT OFF)
-if (MSVC OR ANDROID OR IOS)
+if (MSVC OR ANDROID)
    set(EXT_DEFAULT ON)
 endif()

@@ -261,14 +232,14 @@ cmake_dependent_option(YUZU_USE_EXTERNAL_FFMPEG "Build FFmpeg from external sour

 # sirit
 set(BUNDLED_SIRIT_DEFAULT OFF)
-if ((MSVC AND NOT (CMAKE_BUILD_TYPE MATCHES "Deb")) OR ANDROID OR IOS)
+if (MSVC AND NOT (CMAKE_BUILD_TYPE MATCHES "Deb") OR ANDROID)
    set(BUNDLED_SIRIT_DEFAULT ON)
 endif()

 option(YUZU_USE_BUNDLED_SIRIT "Download bundled sirit" ${BUNDLED_SIRIT_DEFAULT})

 # FreeBSD 15+ has libusb, versions below should disable it
-cmake_dependent_option(ENABLE_LIBUSB "Enable the use of LibUSB" ON "WIN32 OR LINUX OR FREEBSD OR (APPLE AND NOT IOS)" OFF)
+cmake_dependent_option(ENABLE_LIBUSB "Enable the use of LibUSB" ON "WIN32 OR LINUX OR FREEBSD OR APPLE" OFF)

 cmake_dependent_option(ENABLE_OPENGL "Enable OpenGL" ON "NOT (WIN32 AND ARCHITECTURE_arm64) AND NOT APPLE AND NOT ANDROID" OFF)
 mark_as_advanced(FORCE ENABLE_OPENGL)
@@ -290,10 +261,10 @@ option(YUZU_LEGACY "Apply patches that improve compatibility with older GPUs (e.

 option(NIGHTLY_BUILD "Use Nightly qualifiers in the update checker and build metadata" OFF)

-cmake_dependent_option(YUZU_ROOM "Enable dedicated room functionality" ON "NOT ANDROID AND NOT IOS" OFF)
+cmake_dependent_option(YUZU_ROOM "Enable dedicated room functionality" ON "NOT ANDROID" OFF)
 cmake_dependent_option(YUZU_ROOM_STANDALONE "Enable standalone room executable" ON "YUZU_ROOM" OFF)

-cmake_dependent_option(YUZU_CMD "Compile the eden-cli executable" ON "NOT ANDROID AND NOT IOS" OFF)
+cmake_dependent_option(YUZU_CMD "Compile the eden-cli executable" ON "NOT ANDROID" OFF)

 cmake_dependent_option(YUZU_CRASH_DUMPS "Compile crash dump (Minidump) support" OFF "WIN32 OR LINUX" OFF)

@@ -337,7 +308,7 @@ if (YUZU_ROOM)
    add_compile_definitions(YUZU_ROOM)
 endif()

-if ((UNIX OR IOS) AND NOT (LINUX OR WIN32))
+if (UNIX AND NOT (LINUX OR WIN32))
    if(CXX_APPLE OR CXX_CLANG)
        # libc++ has stop_token and jthread as experimental
        set(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} -fexperimental-library")
@@ -410,10 +381,7 @@ set(CMAKE_RUNTIME_OUTPUT_DIRECTORY ${PROJECT_BINARY_DIR}/bin)
 set(THREADS_PREFER_PTHREAD_FLAG ON)
 find_package(Threads REQUIRED)

-find_package(RenderDoc MODULE QUIET)
-if (NOT RenderDoc_FOUND)
-    message(WARNING "RenderDoc not found. Some debugging features may be disabled.")
-endif()
+find_package(RenderDoc MODULE)

 # openssl funniness
 if (YUZU_USE_BUNDLED_OPENSSL)
@@ -541,13 +509,9 @@ endfunction()
 # Platform-specific library requirements
 # Put these BEFORE EXTERNALS or Boost WILL die
 # =============================================
+
 if (APPLE)
-    if (IOS)
-        set(_libs Carbon Metal IOKit CoreVideo CoreMedia Security UniformTypeIdentifiers Foundation)
-    else()
-        set(_libs Carbon Metal Cocoa IOKit CoreVideo CoreMedia Security UniformTypeIdentifiers Foundation)
-    endif()
-    foreach(fw ${_libs})
+    foreach(fw Carbon Metal Cocoa IOKit CoreVideo CoreMedia Security UniformTypeIdentifiers Foundation)
        find_library(${fw}_LIBRARY ${fw} REQUIRED)
        list(APPEND PLATFORM_LIBRARIES ${${fw}_LIBRARY})
    endforeach()
@@ -6,7 +6,6 @@
 - [macOS](#macos)
 - [OpenIndiana](#openindiana)
 - [OmniOS](#omnios)
- [iOS](#ios)
 - [HaikuOS](#haikuos)
 - [OpenBSD](#openbsd)
 - [FreeBSD](#freebsd)
@@ -91,16 +90,6 @@ If it wasn't obvious already, you require a X11 server to properly run the emula

 For Solaris based OSes, `${CMAKE_SYSTEM_NAME}` isn't properly set on CMake (it's set to i686 on AMD64), you may find issues when building OpenSSL from `openssl-cmake`.

-## iOS
-
-iOS has a dedicated build script, we **highly** recommend using that instead of doing anything else, we don't support any other configuration than the one present in said build script.
-
-To build, it's simply as easy as doing
-```sh
-chmod +x .ci/ios/build.sh
-.ci/ios/build.sh
-```
-
 ## HaikuOS

 It's recommended to do a `pkgman full-sync` before installing. See [HaikuOS: Installing applications](https://www.haiku-os.org/guides/daily-tasks/install-applications/). Sometimes the process may be interrupted by an error like "Interrupted syscall". Simply firing the command again fixes the issue. By default `g++` is included on the default installation.
@@ -272,12 +272,6 @@ if (VulkanMemoryAllocator_ADDED)
    endif()
 endif()

-# httplib
-if (IOS)
-    set(HTTPLIB_USE_BROTLI_IF_AVAILABLE OFF)
-endif()
-AddJsonPackage(httplib)
-
 # cpp-jwt
 if (ENABLE_WEB_SERVICE OR ENABLE_UPDATE_CHECKER)
    AddJsonPackage(cpp-jwt)
@@ -35,21 +35,16 @@ This file is based off of Yuzu and Dynarmic.
 # Do note that situations where multiple architectures are defined
 # should NOT be too dependent on the architecture
 # otherwise, you may end up with duplicate code
-if (DEFINED CMAKE_OSX_ARCHITECTURES)
+if (CMAKE_OSX_ARCHITECTURES)
    set(MULTIARCH_BUILD 1)
    set(ARCHITECTURE "${CMAKE_OSX_ARCHITECTURES}")
-    if (IOS)
-        # TODO: Right... the toolchain file won't properly accomodate OSX_ARCHITECTURE
-        # they aren't defining it as a list properly I assume?
-        set(ARCHITECTURE_arm64 1)
-        add_definitions(-DARCHITECTURE_arm64=1)
-    else ()
-        # hope and pray the architecture names match
-        foreach(ARCH ${CMAKE_OSX_ARCHITECTURES})
-            set(ARCHITECTURE_${ARCH} 1)
-            add_definitions(-DARCHITECTURE_${ARCH}=1)
-        endforeach()
-    endif()
+
+    # hope and pray the architecture names match
+    foreach(ARCH IN ${CMAKE_OSX_ARCHITECTURES})
+        set(ARCHITECTURE_${ARCH} 1 PARENT_SCOPE)
+        add_definitions(-DARCHITECTURE_${ARCH}=1)
+    endforeach()
+
    return()
 endif()

@@ -223,4 +218,4 @@ if (NOT DEFINED ARCHITECTURE)
    add_definitions(-DARCHITECTURE_GENERIC=1)
 endif()

-message(STATUS "[DetectArchitecture] Target architecture: ${ARCHITECTURE}")
+message(STATUS "[DetectArchitecture] Target architecture: ${ARCHITECTURE}")
@@ -54,12 +54,6 @@ elseif (CMAKE_CXX_COMPILER_ID STREQUAL "AppleClang")
    set(CXX_APPLE ON)
 endif()

-# This fixes some quirks with xcrun or weird iOS toolchain cmake files
-if (IOS)
-    unset(CXX_CLANG)
-    set(CXX_APPLE ON)
-endif()
-
 # https://gitlab.kitware.com/cmake/cmake/-/merge_requests/11112
 # This works totally fine on MinGW64, but not CLANG{,ARM}64
 if(MINGW AND CXX_CLANG)
@@ -29,22 +29,6 @@ if (NOT YUZU_USE_BUNDLED_FFMPEG)
            --extra-ldflags="-nostdlib"
        )
        set(FFmpeg_IS_CROSS_COMPILING TRUE)
-    elseif(IOS)
-        execute_process(COMMAND xcrun --sdk iphoneos --show-sdk-path OUTPUT_VARIABLE SYSROOT)
-        # Lovely extra newline apple adds that **we** must remove... thank you apple!
-        string(STRIP "${SYSROOT}" SYSROOT)
-        set(FFmpeg_CC xcrun --sdk iphoneos clang -arch arm64)
-        set(FFmpeg_CXX xcrun --sdk iphoneos clang++ -arch arm64)
-        list(APPEND FFmpeg_CROSS_COMPILE_FLAGS
-            --arch=arm64
-            --enable-cross-compile
-            --sysroot="${SYSROOT}"
-            --extra-ldflags="-miphoneos-version-min=16.0"
-            --install-name-dir='@rpath'
-            --disable-audiotoolbox
-            --disable-videotoolbox
-        )
-        set(FFmpeg_IS_CROSS_COMPILING TRUE)
    # User attempts to do a FFmpeg cross compilation because...
    # Here we just quickly test against host/system processors not matching
    # TODO: Test for versions not matching as well?
@@ -78,7 +62,7 @@ elseif (ANDROID)
        --enable-mediacodec
        --enable-jni
    )
-elseif (UNIX AND NOT DEFINED FFmpeg_IS_CROSS_COMPILING AND NOT ANDROID AND NOT IOS)
+elseif (UNIX AND NOT DEFINED FFmpeg_IS_CROSS_COMPILING AND NOT ANDROID)
    find_package(PkgConfig REQUIRED)
    pkg_check_modules(LIBVA libva)
    pkg_check_modules(CUDA cuda)
@@ -24,8 +24,7 @@ if (MINGW OR LINUX OR APPLE)
        message(FATAL_ERROR "Required program `autoconf` not found.")
    endif()

-    find_program(LIBTOOLIZE
-        NAMES libtoolize glibtoolize)
+    find_program(LIBTOOLIZE libtoolize)
    if ("${LIBTOOLIZE}" STREQUAL "LIBTOOLIZE-NOTFOUND")
        message(FATAL_ERROR "Required program `libtoolize` not found.")
    endif()
@@ -177,9 +177,6 @@ else()
        $<$<COMPILE_LANGUAGE:C,CXX>:-Wno-invalid-offsetof>
        $<$<COMPILE_LANGUAGE:C,CXX>:-Wno-unused-parameter>
        $<$<COMPILE_LANGUAGE:C,CXX>:-Wno-missing-field-initializers>)
-    if (NOT IOS)
-        add_compile_options($<$<COMPILE_LANGUAGE:C,CXX>:-Werror=missing-declarations>)
-    endif()

    if (CXX_CLANG OR CXX_ICC OR CXX_APPLE) # Clang, AppleClang, or Intel C++
        if (NOT MSVC)
@@ -298,9 +295,4 @@ if (ANDROID)
    target_include_directories(yuzu-android PRIVATE android/app/src/main)
 endif()

-if (IOS)
-    add_subdirectory(ios)
-    add_compile_options($<$<COMPILE_LANGUAGE:C,CXX>:-Wno-error>)
-endif()
-
 include(GenerateDepHashes)
@@ -1,4 +1,4 @@
-// SPDX-FileCopyrightText: Copyright 2025 Eden Emulator Project
+// SPDX-FileCopyrightText: Copyright 2026 Eden Emulator Project
 // SPDX-License-Identifier: GPL-3.0-or-later

 package org.yuzu.yuzu_emu.adapters
@@ -20,18 +20,21 @@ enum class BooleanSetting(override val key: String) : AbstractBooleanSetting {
    EMULATE_BGR565("emulate_bgr565"),
    RESCALE_HACK("rescale_hack"),
    CPUOPT_UNSAFE_HOST_MMU("cpuopt_unsafe_host_mmu"),
+    RELOCATE_36BIT_ADDRESS_SPACE("relocate_36bit_address_space"),
    USE_DOCKED_MODE("use_docked_mode"),
    USE_AUTO_STUB("use_auto_stub"),
    RENDERER_USE_DISK_SHADER_CACHE("use_disk_shader_cache"),
    RENDERER_FORCE_MAX_CLOCK("force_max_clock"),
    RENDERER_ASYNCHRONOUS_GPU_EMULATION("use_asynchronous_gpu_emulation"),
-    RENDERER_ASYNC_PRESENTATION("async_presentation"),
    RENDERER_ASYNCHRONOUS_SHADERS("use_asynchronous_shaders"),
    RENDERER_REACTIVE_FLUSHING("use_reactive_flushing"),
+    RENDERER_BARRIER_FEEDBACK_LOOPS("barrier_feedback_loops"),
    ENABLE_BUFFER_HISTORY("enable_buffer_history"),
    USE_OPTIMIZED_VERTEX_BUFFERS("use_optimized_vertex_buffers"),
    ENABLE_GPU_BUFFER_READBACK("enable_gpu_buffer_readback"),
+    USE_UNIFIED_MEMORY("use_unified_memory"),
    SYNC_MEMORY_OPERATIONS("sync_memory_operations"),
+    STALL_ON_GPU_FENCE_WAIT("stall_on_gpu_fence_wait"),
    BUFFER_REORDER_DISABLE("disable_buffer_reorder"),
    RENDERER_DEBUG("debug"),
    RENDERER_PATCH_OLD_QCOM_DRIVERS("patch_old_qcom_drivers"),
@@ -39,7 +42,6 @@ enum class BooleanSetting(override val key: String) : AbstractBooleanSetting {
    RENDERER_SAMPLE_SHADING("sample_shading"),
    RENDERER_FRAME_GEN("frame_gen"),
    RENDERER_FRAME_GEN_FLOW_SCALE_AUTO("frame_gen_flow_scale_auto"),
-    GPU_UNSWIZZLE_ENABLED("gpu_unswizzle_enabled"),
    PICTURE_IN_PICTURE("picture_in_picture"),
    USE_CUSTOM_RTC("custom_rtc_enabled"),
    BLACK_BACKGROUNDS("black_backgrounds"),
@@ -32,7 +32,6 @@ enum class IntSetting(override val key: String) : AbstractIntSetting {
    RENDERER_DYNA_STATE("dyna_state"),
    DMA_ACCURACY("dma_accuracy"),
    GPU_FENCE_BEHAVIOR("gpu_fence_behavior"),
-    FRAME_PACING_MODE("frame_pacing_mode"),
    AUDIO_OUTPUT_ENGINE("output_engine"),
    MAX_ANISOTROPY("max_anisotropy"),
    THEME("theme"),
@@ -51,9 +50,6 @@ enum class IntSetting(override val key: String) : AbstractIntSetting {
    FAST_CPU_TIME("fast_cpu_time"),
    CPU_TICKS("cpu_ticks"),
    FAST_GPU_TIME("fast_gpu_time"),
-    GPU_UNSWIZZLE_TEXTURE_SIZE("gpu_unswizzle_texture_size"),
-    GPU_UNSWIZZLE_STREAM_SIZE("gpu_unswizzle_stream_size"),
-    GPU_UNSWIZZLE_CHUNK_SIZE("gpu_unswizzle_chunk_size"),
    BAT_TEMPERATURE_UNIT("bat_temperature_unit"),
    CABINET_APPLET("cabinet_applet_mode"),
    CONTROLLER_APPLET("controller_applet_mode"),
@@ -1,89 +0,0 @@
-// SPDX-FileCopyrightText: Copyright 2026 Eden Emulator Project
-// SPDX-License-Identifier: GPL-3.0-or-later
-
-package org.yuzu.yuzu_emu.features.settings.model.view
-
-import androidx.annotation.ArrayRes
-import androidx.annotation.StringRes
-import org.yuzu.yuzu_emu.features.settings.model.AbstractSetting
-import org.yuzu.yuzu_emu.features.settings.model.BooleanSetting
-import org.yuzu.yuzu_emu.features.settings.model.IntSetting
-
-class GpuUnswizzleSetting(
-    @StringRes titleId: Int = 0,
-    titleString: String = "",
-    @StringRes descriptionId: Int = 0,
-    descriptionString: String = "",
-    @ArrayRes val textureSizeChoicesId: Int,
-    @ArrayRes val textureSizeValuesId: Int,
-    @ArrayRes val streamSizeChoicesId: Int,
-    @ArrayRes val streamSizeValuesId: Int,
-    @ArrayRes val chunkSizeChoicesId: Int,
-    @ArrayRes val chunkSizeValuesId: Int
-) : SettingsItem(
-    object : AbstractSetting {
-        override val key: String = SettingsItem.GPU_UNSWIZZLE_COMBINED
-        override val defaultValue: Any = false
-        override val isSaveable = true
-        override val isRuntimeModifiable = true
-        override val isSwitchable = true
-        override val pairedSettingKey: String = ""
-        override var global: Boolean
-            get() {
-                return BooleanSetting.GPU_UNSWIZZLE_ENABLED.global &&
-                    IntSetting.GPU_UNSWIZZLE_TEXTURE_SIZE.global &&
-                    IntSetting.GPU_UNSWIZZLE_STREAM_SIZE.global &&
-                    IntSetting.GPU_UNSWIZZLE_CHUNK_SIZE.global
-            }
-            set(value) {
-                BooleanSetting.GPU_UNSWIZZLE_ENABLED.global = value
-                IntSetting.GPU_UNSWIZZLE_TEXTURE_SIZE.global = value
-                IntSetting.GPU_UNSWIZZLE_STREAM_SIZE.global = value
-                IntSetting.GPU_UNSWIZZLE_CHUNK_SIZE.global = value
-            }
-        override fun getValueAsString(needsGlobal: Boolean): String = "combined"
-        override fun reset() {
-            BooleanSetting.GPU_UNSWIZZLE_ENABLED.reset()
-            IntSetting.GPU_UNSWIZZLE_TEXTURE_SIZE.reset()
-            IntSetting.GPU_UNSWIZZLE_STREAM_SIZE.reset()
-            IntSetting.GPU_UNSWIZZLE_CHUNK_SIZE.reset()
-        }
-    },
-    titleId,
-    titleString,
-    descriptionId,
-    descriptionString
-) {
-    override val type = SettingsItem.TYPE_GPU_UNSWIZZLE
-
-    // Check if GPU unswizzle is enabled via the dedicated boolean setting
-    fun isEnabled(needsGlobal: Boolean = false): Boolean =
-        BooleanSetting.GPU_UNSWIZZLE_ENABLED.getBoolean(needsGlobal)
-
-    fun setEnabled(value: Boolean) =
-        BooleanSetting.GPU_UNSWIZZLE_ENABLED.setBoolean(value)
-
-    fun enable() = setEnabled(true)
-
-    fun disable() = setEnabled(false)
-
-    fun getTextureSize(needsGlobal: Boolean = false): Int =
-        IntSetting.GPU_UNSWIZZLE_TEXTURE_SIZE.getInt(needsGlobal)
-
-    fun setTextureSize(value: Int) =
-        IntSetting.GPU_UNSWIZZLE_TEXTURE_SIZE.setInt(value)
-
-    fun getStreamSize(needsGlobal: Boolean = false): Int =
-        IntSetting.GPU_UNSWIZZLE_STREAM_SIZE.getInt(needsGlobal)
-
-    fun setStreamSize(value: Int) =
-        IntSetting.GPU_UNSWIZZLE_STREAM_SIZE.setInt(value)
-
-    fun getChunkSize(needsGlobal: Boolean = false): Int =
-        IntSetting.GPU_UNSWIZZLE_CHUNK_SIZE.getInt(needsGlobal)
-
-    fun setChunkSize(value: Int) =
-        IntSetting.GPU_UNSWIZZLE_CHUNK_SIZE.setInt(value)
-
-    fun reset() = setting.reset()
-}
@@ -141,14 +141,12 @@ abstract class SettingsItem(
        const val TYPE_SPINBOX = 12
        const val TYPE_LAUNCHABLE = 13
        const val TYPE_PATH = 14
-        const val TYPE_GPU_UNSWIZZLE = 15
        const val TYPE_FX_TOOLBAR = 16
        const val TYPE_FX_PRESET = 17
        const val TYPE_FX_SHADER = 18
        const val TYPE_FX_BUTTON = 19

        const val FASTMEM_COMBINED = "fastmem_combined"
-        const val GPU_UNSWIZZLE_COMBINED = "gpu_unswizzle_combined"

        val emptySetting = object : AbstractSetting {
            override val key: String = ""
@@ -753,13 +751,6 @@ abstract class SettingsItem(
                    descriptionId = R.string.renderer_asynchronous_gpu_emulation_description
                )
            )
-            put(
-                SwitchSetting(
-                    BooleanSetting.RENDERER_ASYNC_PRESENTATION,
-                    titleId = R.string.renderer_async_presentation,
-                    descriptionId = R.string.renderer_async_presentation_description
-                )
-            )
            put(
                SingleChoiceSetting(
                    IntSetting.DMA_ACCURACY,
@@ -794,45 +785,6 @@ abstract class SettingsItem(
                    valuesId = R.array.gpuValues
                )
            )
-            put(
-                SingleChoiceSetting(
-                    IntSetting.GPU_UNSWIZZLE_TEXTURE_SIZE,
-                    titleId = R.string.gpu_unswizzle_texture_size,
-                    descriptionId = R.string.gpu_unswizzle_texture_size_description,
-                    choicesId = R.array.gpuTextureSizeSwizzleEntries,
-                    valuesId = R.array.gpuTextureSizeSwizzleValues
-                )
-            )
-            put(
-                SingleChoiceSetting(
-                    IntSetting.GPU_UNSWIZZLE_STREAM_SIZE,
-                    titleId = R.string.gpu_unswizzle_stream_size,
-                    descriptionId = R.string.gpu_unswizzle_stream_size_description,
-                    choicesId = R.array.gpuSwizzleEntries,
-                    valuesId = R.array.gpuSwizzleValues
-                )
-            )
-            put(
-                SingleChoiceSetting(
-                    IntSetting.GPU_UNSWIZZLE_CHUNK_SIZE,
-                    titleId = R.string.gpu_unswizzle_chunk_size,
-                    descriptionId = R.string.gpu_unswizzle_chunk_size_description,
-                    choicesId = R.array.gpuSwizzleChunkEntries,
-                    valuesId = R.array.gpuSwizzleChunkValues
-                )
-            )
-            put(
-                GpuUnswizzleSetting(
-                    titleId = R.string.gpu_unswizzle_settings,
-                    descriptionId = R.string.gpu_unswizzle_settings_description,
-                    textureSizeChoicesId = R.array.gpuTextureSizeSwizzleEntries,
-                    textureSizeValuesId = R.array.gpuTextureSizeSwizzleValues,
-                    streamSizeChoicesId = R.array.gpuSwizzleEntries,
-                    streamSizeValuesId = R.array.gpuSwizzleValues,
-                    chunkSizeChoicesId = R.array.gpuSwizzleChunkEntries,
-                    chunkSizeValuesId = R.array.gpuSwizzleChunkValues
-                )
-            )
            put(
                SingleChoiceSetting(
                    IntSetting.FAST_CPU_TIME,
@@ -894,6 +846,13 @@ abstract class SettingsItem(
                    descriptionId = R.string.cpuopt_unsafe_host_mmu_description
                )
            )
+            put(
+                SwitchSetting(
+                    BooleanSetting.RELOCATE_36BIT_ADDRESS_SPACE,
+                    titleId = R.string.relocate_36bit_address_space,
+                    descriptionId = R.string.relocate_36bit_address_space_description
+                )
+            )
            put(
                SwitchSetting(
                    BooleanSetting.RENDERER_REACTIVE_FLUSHING,
@@ -901,6 +860,13 @@ abstract class SettingsItem(
                    descriptionId = R.string.renderer_reactive_flushing_description
                )
            )
+            put(
+                SwitchSetting(
+                    BooleanSetting.RENDERER_BARRIER_FEEDBACK_LOOPS,
+                    titleId = R.string.renderer_barrier_feedback_loops,
+                    descriptionId = R.string.renderer_barrier_feedback_loops_description
+                )
+            )
            put(
                SwitchSetting(
                    BooleanSetting.ENABLE_BUFFER_HISTORY,
@@ -915,6 +881,13 @@ abstract class SettingsItem(
                    descriptionId = R.string.enable_gpu_buffer_readback_description
                )
            )
+            put(
+                SwitchSetting(
+                    BooleanSetting.USE_UNIFIED_MEMORY,
+                    titleId = R.string.use_unified_memory,
+                    descriptionId = R.string.use_unified_memory_description
+                )
+            )
            put(
                SwitchSetting(
                    BooleanSetting.USE_OPTIMIZED_VERTEX_BUFFERS,
@@ -929,6 +902,13 @@ abstract class SettingsItem(
                    descriptionId = R.string.sync_memory_operations_description
                )
            )
+            put(
+                SwitchSetting(
+                    BooleanSetting.STALL_ON_GPU_FENCE_WAIT,
+                    titleId = R.string.stall_on_gpu_fence_wait,
+                    descriptionId = R.string.stall_on_gpu_fence_wait_description
+                )
+            )
            put(
                SwitchSetting(
                    BooleanSetting.BUFFER_REORDER_DISABLE,
@@ -1,206 +0,0 @@
-// SPDX-FileCopyrightText: Copyright 2026 Eden Emulator Project
-// SPDX-License-Identifier: GPL-3.0-or-later
-
-package org.yuzu.yuzu_emu.features.settings.ui
-
-import android.app.Dialog
-import android.content.DialogInterface
-import android.os.Bundle
-import android.view.LayoutInflater
-import android.widget.ArrayAdapter
-import androidx.fragment.app.DialogFragment
-import androidx.fragment.app.activityViewModels
-import com.google.android.material.dialog.MaterialAlertDialogBuilder
-import org.yuzu.yuzu_emu.R
-import org.yuzu.yuzu_emu.databinding.DialogGpuUnswizzleBinding
-import org.yuzu.yuzu_emu.features.settings.model.view.GpuUnswizzleSetting
-
-class GpuUnswizzleDialogFragment : DialogFragment() {
-    private var position = 0
-    private val settingsViewModel: SettingsViewModel by activityViewModels()
-    private lateinit var binding: DialogGpuUnswizzleBinding
-
-    override fun onCreate(savedInstanceState: Bundle?) {
-        super.onCreate(savedInstanceState)
-        position = requireArguments().getInt(POSITION)
-
-        if (settingsViewModel.clickedItem == null) dismiss()
-    }
-
-    override fun onCreateDialog(savedInstanceState: Bundle?): Dialog {
-        binding = DialogGpuUnswizzleBinding.inflate(LayoutInflater.from(requireContext()))
-        val item = settingsViewModel.clickedItem as GpuUnswizzleSetting
-
-        // Setup texture size dropdown
-        val textureSizeEntries = resources.getStringArray(item.textureSizeChoicesId)
-        val textureSizeValues = resources.getIntArray(item.textureSizeValuesId)
-        val textureSizeAdapter = ArrayAdapter(
-            requireContext(),
-            android.R.layout.simple_dropdown_item_1line,
-            textureSizeEntries.toMutableList()
-        )
-        binding.dropdownTextureSize.setAdapter(textureSizeAdapter)
-
-        // Setup stream size dropdown
-        val streamSizeEntries = resources.getStringArray(item.streamSizeChoicesId)
-        val streamSizeValues = resources.getIntArray(item.streamSizeValuesId)
-        val streamSizeAdapter = ArrayAdapter(
-            requireContext(),
-            android.R.layout.simple_dropdown_item_1line,
-            streamSizeEntries.toMutableList()
-        )
-        binding.dropdownStreamSize.setAdapter(streamSizeAdapter)
-
-        // Setup chunk size dropdown
-        val chunkSizeEntries = resources.getStringArray(item.chunkSizeChoicesId)
-        val chunkSizeValues = resources.getIntArray(item.chunkSizeValuesId)
-        val chunkSizeAdapter = ArrayAdapter(
-            requireContext(),
-            android.R.layout.simple_dropdown_item_1line,
-            chunkSizeEntries.toMutableList()
-        )
-        binding.dropdownChunkSize.setAdapter(chunkSizeAdapter)
-
-        // Load current values
-        val isEnabled = item.isEnabled()
-        binding.switchEnable.isChecked = isEnabled
-
-        if (isEnabled) {
-            val textureSizeIndex = textureSizeValues.indexOf(item.getTextureSize())
-            if (textureSizeIndex >= 0) {
-                binding.dropdownTextureSize.setText(textureSizeEntries[textureSizeIndex], false)
-            }
-
-            val streamSizeIndex = streamSizeValues.indexOf(item.getStreamSize())
-            if (streamSizeIndex >= 0) {
-                binding.dropdownStreamSize.setText(streamSizeEntries[streamSizeIndex], false)
-            }
-
-            val chunkSizeIndex = chunkSizeValues.indexOf(item.getChunkSize())
-            if (chunkSizeIndex >= 0) {
-                binding.dropdownChunkSize.setText(chunkSizeEntries[chunkSizeIndex], false)
-            }
-        } else {
-            // Set default/recommended values when disabling
-            binding.dropdownTextureSize.setText(textureSizeEntries[3], false)
-            binding.dropdownStreamSize.setText(streamSizeEntries[3], false)
-            binding.dropdownChunkSize.setText(chunkSizeEntries[3], false)
-        }
-
-        // Clear adapter filters after setText to fix rotation bug
-        textureSizeAdapter.filter.filter(null)
-        streamSizeAdapter.filter.filter(null)
-        chunkSizeAdapter.filter.filter(null)
-
-        // Enable/disable dropdowns based on switch state
-        updateDropdownsState(isEnabled)
-        binding.switchEnable.setOnCheckedChangeListener { _, checked ->
-            updateDropdownsState(checked)
-        }
-
-        val dialog = MaterialAlertDialogBuilder(requireContext())
-            .setTitle(item.title)
-            .setView(binding.root)
-            .create()
-
-        // Setup button listeners
-        binding.btnDefault.setOnClickListener {
-            // Reset to defaults
-            item.reset()
-            // Refresh values with adapters reset
-            val textureSizeIndex = textureSizeValues.indexOf(item.getTextureSize())
-            if (textureSizeIndex >= 0) {
-                binding.dropdownTextureSize.setText(textureSizeEntries[textureSizeIndex], false)
-            }
-            val streamSizeIndex = streamSizeValues.indexOf(item.getStreamSize())
-            if (streamSizeIndex >= 0) {
-                binding.dropdownStreamSize.setText(streamSizeEntries[streamSizeIndex], false)
-            }
-            val chunkSizeIndex = chunkSizeValues.indexOf(item.getChunkSize())
-            if (chunkSizeIndex >= 0) {
-                binding.dropdownChunkSize.setText(chunkSizeEntries[chunkSizeIndex], false)
-            }
-            // Clear filters
-            textureSizeAdapter.filter.filter(null)
-            streamSizeAdapter.filter.filter(null)
-            chunkSizeAdapter.filter.filter(null)
-
-            settingsViewModel.setAdapterItemChanged(position)
-            settingsViewModel.setShouldReloadSettingsList(true)
-        }
-
-        binding.btnCancel.setOnClickListener {
-            dialog.dismiss()
-        }
-
-        binding.btnOk.setOnClickListener {
-            if (binding.switchEnable.isChecked) {
-                item.enable()
-                // Save the selected values
-                val selectedTextureIndex = textureSizeEntries.indexOf(
-                    binding.dropdownTextureSize.text.toString()
-                )
-                if (selectedTextureIndex >= 0) {
-                    item.setTextureSize(textureSizeValues[selectedTextureIndex])
-                }
-
-                val selectedStreamIndex = streamSizeEntries.indexOf(
-                    binding.dropdownStreamSize.text.toString()
-                )
-                if (selectedStreamIndex >= 0) {
-                    item.setStreamSize(streamSizeValues[selectedStreamIndex])
-                }
-
-                val selectedChunkIndex = chunkSizeEntries.indexOf(
-                    binding.dropdownChunkSize.text.toString()
-                )
-                if (selectedChunkIndex >= 0) {
-                    item.setChunkSize(chunkSizeValues[selectedChunkIndex])
-                }
-            } else {
-                // Disable GPU unswizzle
-                item.disable()
-            }
-
-            settingsViewModel.setAdapterItemChanged(position)
-            settingsViewModel.setShouldReloadSettingsList(true)
-            dialog.dismiss()
-        }
-
-        // Ensure filters are cleared after dialog is shown
-        binding.root.post {
-            textureSizeAdapter.filter.filter(null)
-            streamSizeAdapter.filter.filter(null)
-            chunkSizeAdapter.filter.filter(null)
-        }
-
-        return dialog
-    }
-
-    private fun updateDropdownsState(enabled: Boolean) {
-        binding.layoutTextureSize.isEnabled = enabled
-        binding.dropdownTextureSize.isEnabled = enabled
-        binding.layoutStreamSize.isEnabled = enabled
-        binding.dropdownStreamSize.isEnabled = enabled
-        binding.layoutChunkSize.isEnabled = enabled
-        binding.dropdownChunkSize.isEnabled = enabled
-    }
-
-    companion object {
-        const val TAG = "GpuUnswizzleDialogFragment"
-        const val POSITION = "Position"
-
-        fun newInstance(
-            settingsViewModel: SettingsViewModel,
-            item: GpuUnswizzleSetting,
-            position: Int
-        ): GpuUnswizzleDialogFragment {
-            val dialog = GpuUnswizzleDialogFragment()
-            val args = Bundle()
-            args.putInt(POSITION, position)
-            dialog.arguments = args
-            settingsViewModel.clickedItem = item
-            return dialog
-        }
-    }
-}
@@ -106,10 +106,6 @@ class SettingsAdapter(
                PathViewHolder(ListItemSettingBinding.inflate(inflater), this)
            }

-            SettingsItem.TYPE_GPU_UNSWIZZLE -> {
-                GpuUnswizzleViewHolder(ListItemSettingBinding.inflate(inflater), this)
-            }
-
            SettingsItem.TYPE_FX_TOOLBAR -> {
                FxToolbarViewHolder(
                    ListItemSettingFxToolbarBinding.inflate(inflater, parent, false),
@@ -511,14 +507,6 @@ class SettingsAdapter(
        settingsViewModel.setShouldShowPathResetDialog(true)
    }

-    fun onGpuUnswizzleClick(item: GpuUnswizzleSetting, position: Int) {
-        GpuUnswizzleDialogFragment.newInstance(
-            settingsViewModel,
-            item,
-            position
-        ).show(fragment.childFragmentManager, GpuUnswizzleDialogFragment.TAG)
-    }
-
    private class DiffCallback : DiffUtil.ItemCallback<SettingsItem>() {
        override fun areItemsTheSame(oldItem: SettingsItem, newItem: SettingsItem): Boolean {
            return oldItem.setting.key == newItem.setting.key
@@ -545,11 +545,14 @@ class SettingsFragmentPresenter(
            add(IntSetting.RENDERER_NVDEC_EMULATION.key)

            add(BooleanSetting.SYNC_MEMORY_OPERATIONS.key)
+            add(BooleanSetting.STALL_ON_GPU_FENCE_WAIT.key)
            add(BooleanSetting.RENDERER_USE_DISK_SHADER_CACHE.key)
            add(BooleanSetting.RENDERER_FORCE_MAX_CLOCK.key)
            add(BooleanSetting.RENDERER_REACTIVE_FLUSHING.key)
+            add(BooleanSetting.RENDERER_BARRIER_FEEDBACK_LOOPS.key)
            add(BooleanSetting.ENABLE_BUFFER_HISTORY.key)
            add(BooleanSetting.ENABLE_GPU_BUFFER_READBACK.key)
+            add(BooleanSetting.USE_UNIFIED_MEMORY.key)
            add(BooleanSetting.USE_OPTIMIZED_VERTEX_BUFFERS.key)

            add(HeaderSetting(R.string.hacks))
@@ -560,8 +563,6 @@ class SettingsFragmentPresenter(
            add(BooleanSetting.RENDERER_ASYNCHRONOUS_SHADERS.key)
            add(IntSetting.ANDROID_PIPELINE_WORKERS.key)
            add(BooleanSetting.RENDERER_ASYNCHRONOUS_GPU_EMULATION.key)
-            add(BooleanSetting.RENDERER_ASYNC_PRESENTATION.key)
-            add(SettingsItem.GPU_UNSWIZZLE_COMBINED)

            add(HeaderSetting(R.string.extensions))

@@ -1527,6 +1528,7 @@ class SettingsFragmentPresenter(
            add(HeaderSetting(R.string.cpu))

            add(IntSetting.CPU_BACKEND.key)
+            add(BooleanSetting.RELOCATE_36BIT_ADDRESS_SPACE.key)
            add(IntSetting.CPU_ACCURACY.key)
            add(BooleanSetting.USE_AUTO_STUB.key)
            add(SettingsItem.FASTMEM_COMBINED)
@@ -1,71 +0,0 @@
-// SPDX-FileCopyrightText: Copyright 2026 Eden Emulator Project
-// SPDX-License-Identifier: GPL-3.0-or-later
-
-package org.yuzu.yuzu_emu.features.settings.ui.viewholder
-
-import android.view.View
-import org.yuzu.yuzu_emu.R
-import org.yuzu.yuzu_emu.databinding.ListItemSettingBinding
-import org.yuzu.yuzu_emu.features.settings.model.view.GpuUnswizzleSetting
-import org.yuzu.yuzu_emu.features.settings.model.view.SettingsItem
-import org.yuzu.yuzu_emu.features.settings.ui.SettingsAdapter
-import org.yuzu.yuzu_emu.utils.ViewUtils.setVisible
-
-class GpuUnswizzleViewHolder(val binding: ListItemSettingBinding, adapter: SettingsAdapter) :
-    SettingViewHolder(binding.root, adapter) {
-    private lateinit var setting: GpuUnswizzleSetting
-
-    override fun bind(item: SettingsItem) {
-        setting = item as GpuUnswizzleSetting
-        binding.textSettingName.text = setting.title
-        binding.textSettingDescription.setVisible(item.description.isNotEmpty())
-        binding.textSettingDescription.text = item.description
-
-        binding.textSettingValue.setVisible(true)
-        val resMgr = binding.root.context.resources
-
-        if (setting.isEnabled()) {
-            // Show a summary of current settings
-            val textureSizeEntries = resMgr.getStringArray(setting.textureSizeChoicesId)
-            val textureSizeValues = resMgr.getIntArray(setting.textureSizeValuesId)
-            val textureSizeIndex = textureSizeValues.indexOf(setting.getTextureSize())
-            val textureSizeLabel = if (textureSizeIndex >= 0) textureSizeEntries[textureSizeIndex] else "?"
-
-            val streamSizeEntries = resMgr.getStringArray(setting.streamSizeChoicesId)
-            val streamSizeValues = resMgr.getIntArray(setting.streamSizeValuesId)
-            val streamSizeIndex = streamSizeValues.indexOf(setting.getStreamSize())
-            val streamSizeLabel = if (streamSizeIndex >= 0) streamSizeEntries[streamSizeIndex] else "?"
-
-            val chunkSizeEntries = resMgr.getStringArray(setting.chunkSizeChoicesId)
-            val chunkSizeValues = resMgr.getIntArray(setting.chunkSizeValuesId)
-            val chunkSizeIndex = chunkSizeValues.indexOf(setting.getChunkSize())
-            val chunkSizeLabel = if (chunkSizeIndex >= 0) chunkSizeEntries[chunkSizeIndex] else "?"
-
-            binding.textSettingValue.text = "$textureSizeLabel ⋅ $streamSizeLabel ⋅ $chunkSizeLabel"
-        } else {
-            binding.textSettingValue.text = resMgr.getString(R.string.gpu_unswizzle_disabled)
-        }
-
-        binding.buttonClear.setVisible(setting.clearable)
-        binding.buttonClear.setOnClickListener {
-            adapter.onClearClick(setting, bindingAdapterPosition)
-        }
-
-        setStyle(setting.isEditable, binding)
-    }
-
-    override fun onClick(clicked: View) {
-        if (!setting.isEditable) {
-            return
-        }
-
-        adapter.onGpuUnswizzleClick(setting, bindingAdapterPosition)
-    }
-
-    override fun onLongClick(clicked: View): Boolean {
-        if (setting.isEditable) {
-            return adapter.onLongClick(setting, bindingAdapterPosition)
-        }
-        return false
-    }
-}
@@ -1,4 +1,4 @@
-// SPDX-FileCopyrightText: Copyright 2025 Eden Emulator Project
+// SPDX-FileCopyrightText: Copyright 2026 Eden Emulator Project
 // SPDX-License-Identifier: GPL-3.0-or-later

 // SPDX-FileCopyrightText: 2023 yuzu Emulator Project
@@ -64,8 +64,8 @@ void EmuWindow_Android::OnTouchReleased(int id) {
    EmulationSession::GetInstance().GetInputSubsystem().GetTouchScreen()->TouchReleased(id);
 }

-void EmuWindow_Android::OnFrameDisplayed() {
-    UpdateObservedFrameRate();
+void EmuWindow_Android::OnFrameDisplayed(u32 presented_frames) {
+    UpdateObservedFrameRate(presented_frames);
    UpdateFrameRateHint();

    if (!m_first_frame) {
@@ -75,15 +75,16 @@ void EmuWindow_Android::OnFrameDisplayed() {
    }
 }

-void EmuWindow_Android::UpdateObservedFrameRate() {
+void EmuWindow_Android::UpdateObservedFrameRate(u32 presented_frames) {
+    m_presented_frames = static_cast<float>((std::max)(presented_frames, 1u));
    const auto now = Clock::now();
    if (m_last_frame_display_time.time_since_epoch().count() != 0) {
        const auto frame_time = std::chrono::duration<float>(now - m_last_frame_display_time);
        const float seconds = frame_time.count();
        if (seconds > 0.0f) {
-            const float instantaneous_rate = 1.0f / seconds;
+            const float instantaneous_rate = m_presented_frames / seconds;
            if (std::isfinite(instantaneous_rate) && instantaneous_rate >= 1.0f &&
-                instantaneous_rate <= 240.0f) {
+                instantaneous_rate <= 240.0f * m_presented_frames) {
                constexpr float SmoothingFactor = 0.15f;
                if (m_smoothed_present_rate <= 0.0f) {
                    m_smoothed_present_rate = instantaneous_rate;
@@ -124,18 +125,9 @@ float EmuWindow_Android::GetFrameTimeVerifiedHint() const {
    return QuantizeFrameRateHint(verified_rate);
 }

-float EmuWindow_Android::GetPresentedFrameMultiplier() {
-    if (!Settings::values.frame_gen.GetValue()) {
-        return 1.0f;
-    }
-    return static_cast<float>(std::clamp<u32>(Settings::values.frame_gen_multiplier.GetValue(), 2, 4));
-}
-
 float EmuWindow_Android::GetFrameRateHint() const {
-    const float presented_multiplier = GetPresentedFrameMultiplier();
-    const float observed_rate =
-        std::clamp(m_smoothed_present_rate * presented_multiplier, 0.0f, 240.0f);
-    const float frame_time_verified_hint = GetFrameTimeVerifiedHint() * presented_multiplier;
+    const float observed_rate = std::clamp(m_smoothed_present_rate, 0.0f, 240.0f);
+    const float frame_time_verified_hint = GetFrameTimeVerifiedHint() * m_presented_frames;

    if (m_last_frame_rate_hint > 0.0f && observed_rate > 0.0f) {
        const float tolerance = std::max(m_last_frame_rate_hint * 0.12f, 4.0f);
@@ -159,7 +151,7 @@ float EmuWindow_Android::GetFrameRateHint() const {
        return frame_time_verified_hint;
    }

-    const float nominal_rate = 60.0f * presented_multiplier;
+    const float nominal_rate = 60.0f * m_presented_frames;
    if (!Settings::values.use_speed_limit.GetValue()) {
        return QuantizeFrameRateHint(nominal_rate);
    }
@@ -41,7 +41,7 @@ public:
    ~EmuWindow_Android() = default;

    void OnSurfaceChanged(ANativeWindow* surface);
-    void OnFrameDisplayed() override;
+    void OnFrameDisplayed(u32 presented_frames) override;

    void OnTouchPressed(int id, float x, float y);
    void OnTouchMoved(int id, float x, float y);
@@ -58,10 +58,9 @@ private:
    using Clock = std::chrono::steady_clock;

    void UpdateFrameRateHint();
-    void UpdateObservedFrameRate();
+    void UpdateObservedFrameRate(u32 presented_frames);
    [[nodiscard]] float GetFrameRateHint() const;
    [[nodiscard]] float GetFrameTimeVerifiedHint() const;
-    [[nodiscard]] static float GetPresentedFrameMultiplier();
    [[nodiscard]] static float QuantizeFrameRateHint(float frame_rate);

    float m_window_width{};
@@ -73,6 +72,7 @@ private:
    float m_last_frame_rate_hint = -1.0f;
    float m_pending_frame_rate_hint = -1.0f;
    float m_smoothed_present_rate = 0.0f;
+    float m_presented_frames = 1.0f;
    Clock::time_point m_last_frame_display_time{};
    Clock::time_point m_pending_frame_rate_since{};
    std::uint32_t m_pending_frame_rate_hint_votes = 0;
@@ -738,6 +738,35 @@ const char* fallback_cpu_detection() {
    return s_result.c_str();
 }

+#ifdef ARCHITECTURE_arm64
+struct SystemDriverInfo {
+    VkPhysicalDeviceProperties properties{};
+    VkPhysicalDeviceDriverProperties driver{};
+};
+
+SystemDriverInfo QuerySystemDriverInfo(JNIEnv* env, jstring j_hook_lib_dir) {
+    const std::string hook_lib_dir = Common::Android::GetJString(env, j_hook_lib_dir);
+    const Common::DynamicLibrary library{adrenotools_open_libvulkan(
+        RTLD_NOW, 0, nullptr, hook_lib_dir.c_str(), nullptr, nullptr, nullptr, nullptr)};
+    Vulkan::vk::InstanceDispatch dld;
+    const Vulkan::vk::Instance instance = Vulkan::CreateInstance(library, dld, VK_API_VERSION_1_1);
+    const std::vector<VkPhysicalDevice> devices = instance.EnumeratePhysicalDevices();
+    if (devices.empty()) {
+        throw Vulkan::vk::Exception(VK_ERROR_INITIALIZATION_FAILED);
+    }
+    SystemDriverInfo info{};
+    info.driver.sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DRIVER_PROPERTIES;
+    VkPhysicalDeviceProperties2 properties2{
+        .sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PROPERTIES_2,
+        .pNext = &info.driver,
+        .properties = {},
+    };
+    Vulkan::vk::PhysicalDevice(devices[0], dld).GetProperties2(properties2);
+    info.properties = properties2.properties;
+    return info;
+}
+#endif
+
 } // namespace

 extern "C" {
@@ -857,34 +886,18 @@ jboolean JNICALL Java_org_yuzu_yuzu_1emu_utils_GpuDriverHelper_supportsCustomDri

 jobjectArray Java_org_yuzu_yuzu_1emu_utils_GpuDriverHelper_getSystemDriverInfo(
    JNIEnv* env, jobject j_obj, jobject j_surf, jstring j_hook_lib_dir) {
+    std::string version_string{"1.1.0"};
+    std::string driver_name{"generic"};
 #ifdef ARCHITECTURE_arm64
-    const char* file_redirect_dir_{};
-    int featureFlags{};
-    std::string hook_lib_dir = Common::Android::GetJString(env, j_hook_lib_dir);
-    auto handle = adrenotools_open_libvulkan(RTLD_NOW, featureFlags, nullptr, hook_lib_dir.c_str(),
-                                             nullptr, nullptr, file_redirect_dir_, nullptr);
-    auto driver_library = std::make_shared<Common::DynamicLibrary>(handle);
-    InputCommon::InputSubsystem input_subsystem;
-    auto window =
-        std::make_unique<EmuWindow_Android>(ANativeWindow_fromSurface(env, j_surf), driver_library);
-
-    Vulkan::vk::InstanceDispatch dld;
-    Vulkan::vk::Instance vk_instance = Vulkan::CreateInstance(
-        *driver_library, dld, VK_API_VERSION_1_1, Core::Frontend::WindowSystemType::Android);
-
-    auto surface = Vulkan::CreateSurface(vk_instance, window->GetWindowInfo());
-
-    auto device = Vulkan::CreateDevice(vk_instance, dld, *surface);
-
-    auto driver_version = device.GetDriverVersion();
-    auto version_string =
-        fmt::format("{}.{}.{}", VK_API_VERSION_MAJOR(driver_version),
-                    VK_API_VERSION_MINOR(driver_version), VK_API_VERSION_PATCH(driver_version));
-    auto driver_name = device.GetDriverName();
-#else
-    auto driver_version = "1.0.0";
-    auto version_string = "1.1.0"; //Assume lowest Vulkan level
-    auto driver_name = "generic";
+    try {
+        const SystemDriverInfo info = QuerySystemDriverInfo(env, j_hook_lib_dir);
+        const u32 driver_version = info.properties.driverVersion;
+        version_string =
+            fmt::format("{}.{}.{}", VK_API_VERSION_MAJOR(driver_version),
+                        VK_API_VERSION_MINOR(driver_version), VK_API_VERSION_PATCH(driver_version));
+        driver_name = Vulkan::vk::GetDriverName(info.driver);
+    } catch (...) {
+    }
 #endif
    jobjectArray j_driver_info = env->NewObjectArray(2, Common::Android::GetStringClass(), Common::Android::ToJString(env, version_string));
    env->SetObjectArrayElement(j_driver_info, 1, Common::Android::ToJString(env, driver_name));
@@ -893,32 +906,12 @@ jobjectArray Java_org_yuzu_yuzu_1emu_utils_GpuDriverHelper_getSystemDriverInfo(

 jstring Java_org_yuzu_yuzu_1emu_utils_GpuDriverHelper_getGpuModel(JNIEnv *env, jobject j_obj, jobject j_surf, jstring j_hook_lib_dir) {
 #ifdef ARCHITECTURE_arm64
-    const char* file_redirect_dir_{};
-    int featureFlags{};
-    std::string hook_lib_dir = Common::Android::GetJString(env, j_hook_lib_dir);
-    auto handle = adrenotools_open_libvulkan(RTLD_NOW, featureFlags, nullptr, hook_lib_dir.c_str(),
-                                             nullptr, nullptr, file_redirect_dir_, nullptr);
-    auto driver_library = std::make_shared<Common::DynamicLibrary>(handle);
-    InputCommon::InputSubsystem input_subsystem;
-    auto window =
-            std::make_unique<EmuWindow_Android>(ANativeWindow_fromSurface(env, j_surf), driver_library);
-
-    Vulkan::vk::InstanceDispatch dld;
-    Vulkan::vk::Instance vk_instance = Vulkan::CreateInstance(
-            *driver_library, dld, VK_API_VERSION_1_1, Core::Frontend::WindowSystemType::Android);
-
-    auto surface = Vulkan::CreateSurface(vk_instance, window->GetWindowInfo());
-
-    auto device = Vulkan::CreateDevice(vk_instance, dld, *surface);
-
-    const std::string model_name{device.GetModelName()};
-
-    window.release();
-
-    return Common::Android::ToJString(env, model_name);
-#else
-    return Common::Android::ToJString(env, "no-info");
+    try {
+        return Common::Android::ToJString(env, QuerySystemDriverInfo(env, j_hook_lib_dir).properties.deviceName);
+    } catch (...) {
+    }
 #endif
+    return Common::Android::ToJString(env, "no-info");
 }

 jboolean Java_org_yuzu_yuzu_1emu_NativeLibrary_reloadKeys(JNIEnv* env, jclass clazz) {
@@ -1,96 +0,0 @@
-<?xml version="1.0" encoding="utf-8"?>
-<ScrollView xmlns:android="http://schemas.android.com/apk/res/android"
-    xmlns:app="http://schemas.android.com/apk/res-auto"
-    android:layout_width="match_parent"
-    android:layout_height="wrap_content"
-    android:scrollbars="vertical">
-
-    <LinearLayout
-        android:layout_width="match_parent"
-        android:layout_height="wrap_content"
-        android:orientation="vertical"
-        android:padding="24dp">
-
-        <com.google.android.material.switchmaterial.SwitchMaterial
-            android:id="@+id/switch_enable"
-            android:layout_width="match_parent"
-            android:layout_height="wrap_content"
-            android:layout_marginBottom="16dp"
-            android:text="@string/gpu_unswizzle_enable" />
-
-        <com.google.android.material.textfield.TextInputLayout
-        android:id="@+id/layout_texture_size"
-        style="@style/Widget.Material3.TextInputLayout.OutlinedBox.ExposedDropdownMenu"
-        android:layout_width="match_parent"
-        android:layout_height="wrap_content"
-        android:layout_marginBottom="12dp"
-        android:hint="@string/gpu_unswizzle_texture_size">
-
-        <com.google.android.material.textfield.MaterialAutoCompleteTextView
-            android:id="@+id/dropdown_texture_size"
-            android:layout_width="match_parent"
-            android:layout_height="wrap_content"
-            android:inputType="none" />
-        </com.google.android.material.textfield.TextInputLayout>
-
-        <com.google.android.material.textfield.TextInputLayout
-            android:id="@+id/layout_stream_size"
-            style="@style/Widget.Material3.TextInputLayout.OutlinedBox.ExposedDropdownMenu"
-            android:layout_width="match_parent"
-            android:layout_height="wrap_content"
-            android:layout_marginBottom="12dp"
-            android:hint="@string/gpu_unswizzle_stream_size">
-
-            <com.google.android.material.textfield.MaterialAutoCompleteTextView
-                android:id="@+id/dropdown_stream_size"
-                android:layout_width="match_parent"
-                android:layout_height="wrap_content"
-                android:inputType="none" />
-        </com.google.android.material.textfield.TextInputLayout>
-
-        <com.google.android.material.textfield.TextInputLayout
-            android:id="@+id/layout_chunk_size"
-            style="@style/Widget.Material3.TextInputLayout.OutlinedBox.ExposedDropdownMenu"
-            android:layout_width="match_parent"
-            android:layout_height="wrap_content"
-            android:hint="@string/gpu_unswizzle_chunk_size">
-
-            <com.google.android.material.textfield.MaterialAutoCompleteTextView
-                android:id="@+id/dropdown_chunk_size"
-                android:layout_width="match_parent"
-                android:layout_height="wrap_content"
-                android:inputType="none" />
-        </com.google.android.material.textfield.TextInputLayout>
-
-        <LinearLayout
-            android:layout_width="match_parent"
-            android:layout_height="wrap_content"
-            android:layout_marginTop="24dp"
-            android:orientation="horizontal"
-            android:gravity="end"
-            android:spacing="8dp">
-
-            <com.google.android.material.button.MaterialButton
-                android:id="@+id/btn_default"
-                style="@style/Widget.Material3.Button.TextButton"
-                android:layout_width="wrap_content"
-                android:layout_height="wrap_content"
-                android:text="@string/gpu_unswizzle_default_button" />
-
-            <com.google.android.material.button.MaterialButton
-                android:id="@+id/btn_cancel"
-                style="@style/Widget.Material3.Button.TextButton"
-                android:layout_width="wrap_content"
-                android:layout_height="wrap_content"
-                android:text="@android:string/cancel" />
-
-            <com.google.android.material.button.MaterialButton
-                android:id="@+id/btn_ok"
-                style="@style/Widget.Material3.Button.TextButton"
-                android:layout_width="wrap_content"
-                android:layout_height="wrap_content"
-                android:text="@android:string/ok" />
-        </LinearLayout>
-
-    </LinearLayout>
-</ScrollView>
@@ -574,8 +574,6 @@
    <string name="renderer_force_max_clock_description">يجبر وحدة معالجة الرسومات على العمل بأقصى سرعة ممكنة (سيظل يتم تطبيق القيود الحرارية).</string>
    <string name="renderer_asynchronous_gpu_emulation">محاكاة غير متزامنة لوحدة معالجة الرسومات</string>
    <string name="renderer_asynchronous_gpu_emulation_description">يمكن لهذه الحيلة أن تزيد الأداء عن طريق تشغيل محاكاة وحدة معالجة الرسومات بشكل غير متزامن على حساب مشاكل الرسومات وزيادة معدلات الأعطال بسبب العمليات المتعلقة بالتوقيت.</string>
-    <string name="renderer_async_presentation">عرض غير متزامن</string>
-    <string name="renderer_async_presentation_description">يمكن لهذه الحيلة أن تزيد من الأداء عن طريق نقل عملية العرض إلى خيط معالجة منفصل على حساب مشاكل الرسوميات.</string>
    <string name="renderer_reactive_flushing">استخدم التنظيف التفاعلي</string>
    <string name="renderer_reactive_flushing_description">يحسن دقة العرض في بعض الألعاب على حساب الأداء.</string>
    <string name="enable_buffer_history">تمكين سجل التخزين المؤقت</string>
@@ -599,17 +597,6 @@
    <string name="rescale_hack_description">يُمكّن هذا الخيار من التعامل مع عملية إعادة تحجيم الألعاب بطريقة تقليدية باستخدام مسار إعادة التحجيم السريع</string>
    <string name="renderer_asynchronous_shaders">استخدم تظليل غير متزامن</string>
    <string name="renderer_asynchronous_shaders_description">يقوم بتجميع التظليل بشكل غير متزامن. قد يقلل ذلك من التقطعات ولكنه قد يؤدي أيضًا إلى حدوث أخطاء.</string>
-    <string name="gpu_unswizzle_settings">إعدادات إلغاء ترتيب بيانات وحدة معالجة الرسومات</string>
-    <string name="gpu_unswizzle_settings_description">قم بضبط معلمات فكّ تشابك النسيج المستندة إلى وحدة معالجة الرسومات أو تعطيلها تمامًا. اضبط هذه الإعدادات لتحقيق التوازن بين الأداء وجودة تحميل النسيج.</string>
-    <string name="gpu_unswizzle_enable">تفعيل إلغاء ترتيب بيانات وحدة معالجة الرسومات</string>
-    <string name="gpu_unswizzle_disabled">تعطيل</string>
-    <string name="gpu_unswizzle_texture_size">الحد الأقصى لحجم النسيج في وحدة معالجة الرسومات بعد إعادة ترتيب البيانات</string>
-    <string name="gpu_unswizzle_texture_size_description">يُحدد هذا الخيار الحد الأقصى لحجم (ميغابايت) معالجة الصور باستخدام وحدة معالجة الرسومات. مع أن وحدة معالجة الرسومات أسرع في معالجة الصور المتوسطة والكبيرة، إلا أن وحدة المعالجة المركزية قد تكون أكثر كفاءة في معالجة الصور الصغيرة جدًا. اضبط هذا الخيار لتحقيق التوازن الأمثل بين سرعة معالجة الرسومات واستهلاك وحدة المعالجة المركزية.</string>
-    <string name="gpu_unswizzle_stream_size">حجم تدفق إلغاء ترتيب بيانات وحدة معالجة الرسومات</string>
-    <string name="gpu_unswizzle_stream_size_description">يحدد هذا الخيار حد البيانات لكل إطار لمعالجة الصور الكبيرة. القيم الأعلى تُسرّع تحميل الصور على حساب زيادة زمن استجابة الإطارات؛ أما القيم الأقل فتُقلل من الحمل الزائد على وحدة معالجة الرسومات، ولكنها قد تتسبب في ظهور الصور بشكل مفاجئ.</string>
-    <string name="gpu_unswizzle_chunk_size">حجم كتلة إلغاء ترتيب بيانات وحدة معالجة الرسومات</string>
-    <string name="gpu_unswizzle_chunk_size_description">يُحدد هذا الخيار عدد شرائح العمق التي تتم معالجتها لكل دفعة من الصور ثلاثية الأبعاد (3D). زيادة هذا العدد تُحسّن كفاءة الإنتاجية على وحدات معالجة الرسومات القوية، ولكنها قد تُسبب تقطعًا أو انقطاعًا في عمل برنامج التشغيل على الأجهزة ذات المواصفات الأقل قوة.</string>
-    <string name="gpu_unswizzle_default_button">افتراضي</string>


    <string name="extensions">إضافات</string>
@@ -1050,25 +1037,10 @@
    <string name="fast_gpu_high">كسر السرعة</string>

    <!-- GPU swizzle texture size -->
-    <string name="gpu_texturesizeswizzle_verysmall">صغير جدًا (16 ميغابايت)</string>
-    <string name="gpu_texturesizeswizzle_small">صغير (32 ميغابايت)</string>
-    <string name="gpu_texturesizeswizzle_normal">قياسي (128 ميغابايت)</string>
-    <string name="gpu_texturesizeswizzle_large">كبير (256 ميغابايت)</string>
-    <string name="gpu_texturesizeswizzle_verylarge">كبير جدًا (512 ميغابايت)</string>

    <!-- GPU swizzle streams -->
-    <string name="gpu_swizzle_verylow">منخفض جدًا (4 ميغابايت)</string>
-    <string name="gpu_swizzle_low">منخفض (8 ميغابايت)</string>
-    <string name="gpu_swizzle_normal">قياسي (16 ميغابايت)</string>
-    <string name="gpu_swizzle_medium">متوسط (32 ميغابايت)</string>
-    <string name="gpu_swizzle_high">عالي (64 ميغابايت)</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>
@@ -508,7 +508,6 @@ Wird der Handheld-Modus verwendet, verringert es die Auflösung und erhöht die
    <string name="skip_cpu_inner_invalidation_description">Überspringt bestimmte Cache-Invalidierungen auf CPU-Seite während Speicherupdates, reduziert die CPU-Auslastung und verbessert die Leistung. Kann in einigen Spielen zu Fehlern oder Abstürzen führen.</string>
    <string name="renderer_asynchronous_shaders">Asynchrone Shader</string>
    <string name="renderer_asynchronous_shaders_description">Kompiliert Shader asynchron. Dies kann Ruckler reduzieren, aber auch Grafikfehler verursachen.</string>
-    <string name="gpu_unswizzle_default_button">Standard</string>


    <string name="extensions">Erweiterungen</string>
@@ -918,25 +917,10 @@ Wirklich fortfahren?</string>
    <string name="fast_gpu_high">Übertaktung</string>

    <!-- GPU swizzle texture size -->
-    <string name="gpu_texturesizeswizzle_verysmall">Sehr klein (16 MB)</string>
-    <string name="gpu_texturesizeswizzle_small">Klein (32 MB)</string>
-    <string name="gpu_texturesizeswizzle_normal">Normal (128 MB)</string>
-    <string name="gpu_texturesizeswizzle_large">Groß (256 MB)</string>
-    <string name="gpu_texturesizeswizzle_verylarge">Sehr groß (512 MB)</string>

    <!-- GPU swizzle streams -->
-    <string name="gpu_swizzle_verylow">Sehr niedrig (4 MB)</string>
-    <string name="gpu_swizzle_low">Niedrig (8 MB)</string>
-    <string name="gpu_swizzle_normal">Normal (16 MB)</string>
-    <string name="gpu_swizzle_medium">Mittel (32 MB)</string>
-    <string name="gpu_swizzle_high">Hoch (64 MB)</string>

    <!-- GPU swizzle chunks -->
-    <string name="gpu_swizzlechunk_verylow">Sehr niedrig (32)</string>
-    <string name="gpu_swizzlechunk_low">Niedrig (64)</string>
-    <string name="gpu_swizzlechunk_normal">Normal (128)</string>
-    <string name="gpu_swizzlechunk_medium">Mittel (256)</string>
-    <string name="gpu_swizzlechunk_high">Hoch (512)</string>

    <!-- Temperature Units -->
    <string name="temperature_celsius">Celsius</string>
@@ -517,8 +517,6 @@
    <string name="renderer_force_max_clock_description">Fuerza a la GPU a ejecutarse a la velocidad máxima de reloj posible (se seguirán aplicando restricciones térmicas).</string>
    <string name="renderer_asynchronous_gpu_emulation">Emulación de GPU asíncrona</string>
    <string name="renderer_asynchronous_gpu_emulation_description">Este hack puede aumentar el rendimiento ejecutando la emulación de la GPU de forma asíncrona, a costa de problemas gráficos y un aumento en la tasa de fallos debido a operaciones relacionadas con la sincronización.</string>
-    <string name="renderer_async_presentation">Presentación asíncrona</string>
-    <string name="renderer_async_presentation_description">Este hack puede aumentar el rendimiento al mover la presentación a un hilo independiente de la CPU a costa de problemas gráficos.</string>
    <string name="renderer_reactive_flushing">Usar limpieza reactiva</string>
    <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>
@@ -541,17 +539,6 @@
    <string name="rescale_hack_description">Permite el manejo de versiones anteriores para el paso de configuración de reescalado para juegos mediante el uso de una ruta de reescalado rápida.</string>
    <string name="renderer_asynchronous_shaders">Usar sombreadores asíncronos</string>
    <string name="renderer_asynchronous_shaders_description">Compila los sombreadores de forma asíncrona. Esto puede reducir los tirones, pero también puede introducir errores gráficos.</string>
-    <string name="gpu_unswizzle_settings">Ajustes de desentrelazado de la GPU</string>
-    <string name="gpu_unswizzle_settings_description">Configura los parámetros de desentrelazado de texturas basadas en la GPU o desactívelos por completo. Modifique estos ajustes para equilibrar el rendimiento y la calidad de las texturas cargadas.</string>
-    <string name="gpu_unswizzle_enable">Activar desentrelazado de la GPU</string>
-    <string name="gpu_unswizzle_disabled">Desactivado</string>
-    <string name="gpu_unswizzle_texture_size">Tamaño máximo de textura de desentrelazado de la GPU</string>
-    <string name="gpu_unswizzle_texture_size_description">Establece el tamaño máximo (en MB) para el desentrelazado de texturas basada en GPU. Aunque la GPU es más rápida para texturas medianas y grandes, la CPU puede ser más eficiente para texturas muy pequeñas. Ajuste este valor para encontrar el equilibrio entre la aceleración de la GPU y la sobrecarga de la CPU.</string>
-    <string name="gpu_unswizzle_stream_size">Tamaño del flujo de desentrelazado de la GPU</string>
-    <string name="gpu_unswizzle_stream_size_description">Establece el límite de datos por fotograma para desentrelazar texturas grandes. Los valores altos aceleran la carga de texturas, a coste de una mayor latencia por fotograma; los valores bajos reducen la carga de la GPU, pero pueden causar parpadeos visibles en las texturas.</string>
-    <string name="gpu_unswizzle_chunk_size">Tamaño del trozo de desentrelazado de la GPU</string>
-    <string name="gpu_unswizzle_chunk_size_description">Determina la cantidad de cortes de profundidad procesados en un solo envío de texturas 3D. Aumentar este valor puede mejorar el rendimiento en una GPU de gama alta, pero puede causar tirones y problemas en los tiempos de respuesta en hardware más modesto.</string>
-    <string name="gpu_unswizzle_default_button">Por defecto</string>


    <string name="extensions">Extensiones</string>
@@ -988,25 +975,10 @@
    <string name="fast_gpu_high">Overclock</string>

    <!-- GPU swizzle texture size -->
-    <string name="gpu_texturesizeswizzle_verysmall">Muy pequeño (16 MB)</string>
-    <string name="gpu_texturesizeswizzle_small">Pequeño (32 MB)</string>
-    <string name="gpu_texturesizeswizzle_normal">Normal (128 MB)</string>
-    <string name="gpu_texturesizeswizzle_large">Grande (256 MB)</string>
-    <string name="gpu_texturesizeswizzle_verylarge">Muy grande (512 MB)</string>

    <!-- GPU swizzle streams -->
-    <string name="gpu_swizzle_verylow">Muy bajo (4 MB)</string>
-    <string name="gpu_swizzle_low">Bajo (8 MB)</string>
-    <string name="gpu_swizzle_normal">Normal (16 MB)</string>
-    <string name="gpu_swizzle_medium">Medio (32 MB)</string>
-    <string name="gpu_swizzle_high">Alto (64 MB)</string>

    <!-- GPU swizzle chunks -->
-    <string name="gpu_swizzlechunk_verylow">Muy bajo (32)</string>
-    <string name="gpu_swizzlechunk_low">Bajo (64)</string>
-    <string name="gpu_swizzlechunk_normal">Normal (128)</string>
-    <string name="gpu_swizzlechunk_medium">Medio (256)</string>
-    <string name="gpu_swizzlechunk_high">Alto (512)</string>

    <!-- Temperature Units -->
    <string name="temperature_celsius">Celsius</string>
@@ -482,8 +482,6 @@
    <string name="emulate_bgr565">Emuler BGR565</string>
    <string name="renderer_asynchronous_shaders">Utiliser les shaders asynchrones</string>
    <string name="renderer_asynchronous_shaders_description">Compile les shaders de manière asynchrone. Cela peut réduire les saccades mais peut aussi provoquer des problèmes graphiques.</string>
-    <string name="gpu_unswizzle_disabled">Désactivé</string>
-    <string name="gpu_unswizzle_default_button">Par défaut</string>


    <string name="extensions">Extensions</string>
@@ -884,25 +882,10 @@
    <string name="memory_8gb">8 Go (Dangereux)</string>

    <!-- GPU swizzle texture size -->
-    <string name="gpu_texturesizeswizzle_verysmall">Très petit (16 Mo)</string>
-    <string name="gpu_texturesizeswizzle_small">Petit (32 Mo)</string>
-    <string name="gpu_texturesizeswizzle_normal">Normal (128 Mo)</string>
-    <string name="gpu_texturesizeswizzle_large">Large (256 Mo)</string>
-    <string name="gpu_texturesizeswizzle_verylarge">Très large (512 Mo)</string>

    <!-- GPU swizzle streams -->
-    <string name="gpu_swizzle_verylow">Très faible (4 Mo)</string>
-    <string name="gpu_swizzle_low">Faible (8 Mo)</string>
-    <string name="gpu_swizzle_normal">Normal (16 Mo)</string>
-    <string name="gpu_swizzle_medium">Moyen (32 Mo)</string>
-    <string name="gpu_swizzle_high">Élevé (64 Mo)</string>

    <!-- GPU swizzle chunks -->
-    <string name="gpu_swizzlechunk_verylow">Très faible (32)</string>
-    <string name="gpu_swizzlechunk_low">Faible (64)</string>
-    <string name="gpu_swizzlechunk_normal">Normal (128)</string>
-    <string name="gpu_swizzlechunk_medium">Moyen (256)</string>
-    <string name="gpu_swizzlechunk_high">Élevé (512)</string>

    <!-- Temperature Units -->
    <string name="temperature_celsius">Celsius</string>
@@ -554,8 +554,6 @@
    <string name="renderer_force_max_clock_description">Заставляет ГПУ работать на максимально возможных тактовых частотах (тепловые ограничения все равно будут применяться).</string>
    <string name="renderer_asynchronous_gpu_emulation">Асинхронная эмуляция ГПУ</string>
    <string name="renderer_asynchronous_gpu_emulation_description">Может повысить производительность за счёт асинхронного запуска эмуляции ГПУ, но ценой появления графических ошибок и увеличения частоты вылетов из-за операций, зависящих от синхронизации.</string>
-    <string name="renderer_async_presentation">Асинхронная презентация</string>
-    <string name="renderer_async_presentation_description">Может повысить производительность за счёт перемещения вывода кадров в отдельный поток ЦП, но ценой возникновения графических проблем.</string>
    <string name="renderer_reactive_flushing">Реактивная очистка</string>
    <string name="renderer_reactive_flushing_description">Повышение точности рендеринга в некоторых играх за счет снижения производительности.</string>
    <string name="enable_buffer_history">Включить историю буфера</string>
@@ -579,17 +577,6 @@
    <string name="rescale_hack_description">Включает старый метод обработки этапа перенастройки масштабирования для игр за счёт использования быстрого алгоритма перемасштабирования.</string>
    <string name="renderer_asynchronous_shaders">Использовать асинхронные шейдеры</string>
    <string name="renderer_asynchronous_shaders_description">Компилирует шейдеры асинхронно. Это может уменьшить подтормаживания, но также может вызвать графические артефакты.</string>
-    <string name="gpu_unswizzle_settings">Настройки распаковки текстур (Unswizzle)</string>
-    <string name="gpu_unswizzle_settings_description">Настройте параметры распаковки текстур на стороне ГПУ либо полностью отключите эту функцию. Изменение этих параметров позволяет найти баланс между производительностью и качеством загрузки текстур.</string>
-    <string name="gpu_unswizzle_enable">Включить распаковку текстур (Unswizzle)</string>
-    <string name="gpu_unswizzle_disabled">Отключено</string>
-    <string name="gpu_unswizzle_texture_size">Макс. размер текстуры Unswizzle</string>
-    <string name="gpu_unswizzle_texture_size_description">Задает максимальный размер (в МБ) текстур для преобразования формата (unswizzle) на ГПУ. Хотя ГПУ быстрее работает со средними и большими текстурами, ЦП может быть эффективнее для очень маленьких. Настройте это значение, чтобы найти баланс между ускорением на ГПУ и нагрузкой на ЦП.</string>
-    <string name="gpu_unswizzle_stream_size">Размер потока Unswizzle</string>
-    <string name="gpu_unswizzle_stream_size_description">Задает лимит данных на кадр для преобразования крупных текстур (unswizzle). Высокие значения ускоряют загрузку текстур ценой увеличения задержки кадра; низкие значения снижают нагрузку на ГПУ, но могут вызывать заметную постепенную подгрузку текстур.</string>
-    <string name="gpu_unswizzle_chunk_size">Размер блока Unswizzle</string>
-    <string name="gpu_unswizzle_chunk_size_description">Задает количество слоёв глубины, обрабатываемых за одну пачку для 3D-текстур. Увеличение этого значения улучшает пропускную способность на мощных ГПУ, но может вызывать подтормаживания или таймауты драйвера на слабом железе.</string>
-    <string name="gpu_unswizzle_default_button">По умолчанию</string>


    <string name="extensions">Расширения</string>
@@ -1030,25 +1017,10 @@
    <string name="fast_gpu_high">Разгон</string>

    <!-- GPU swizzle texture size -->
-    <string name="gpu_texturesizeswizzle_verysmall">Очень малый (16 МБ)</string>
-    <string name="gpu_texturesizeswizzle_small">Малый (32 МБ)</string>
-    <string name="gpu_texturesizeswizzle_normal">Обычный (128 МБ)</string>
-    <string name="gpu_texturesizeswizzle_large">Большой (256 МБ)</string>
-    <string name="gpu_texturesizeswizzle_verylarge">Очень большой (512 МБ)</string>

    <!-- GPU swizzle streams -->
-    <string name="gpu_swizzle_verylow">Очень низкий (4 МБ)</string>
-    <string name="gpu_swizzle_low">Низкий (8 МБ)</string>
-    <string name="gpu_swizzle_normal">Обычный (16 МБ)</string>
-    <string name="gpu_swizzle_medium">Средний (32 МБ)</string>
-    <string name="gpu_swizzle_high">Высокий (64 МБ)</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>
@@ -481,8 +481,6 @@
    <string name="renderer_force_max_clock_description">Змушує GPU працювати на максимальній тактовій частоті.</string>
    <string name="renderer_asynchronous_gpu_emulation">Асинхронна емуляція ГП</string>
    <string name="renderer_asynchronous_gpu_emulation_description">Це обхідне рішення може покращити продуктивність завдяки асинхронному виконанню емуляції ГП, але спричинить проблеми з графікою та збільшить частоту збоїв чутливих до таймінгів операцій.</string>
-    <string name="renderer_async_presentation">Асинхронне подання</string>
-    <string name="renderer_async_presentation_description">Це обхідне рішення може покращити продуктивність завдяки переміщенню подання на окремий потік ЦП, але спричинить проблеми з графікою.</string>
    <string name="renderer_reactive_flushing">Реактивне очищення</string>
    <string name="renderer_reactive_flushing_description">Покращує точність рендерингу в деяких іграх.</string>
    <string name="enable_buffer_history">Увімкнути історію буфера</string>
@@ -502,17 +500,6 @@
    <string name="rescale_hack_description">Вмикає застарілу обробку масштабування для ігор, використовуючи швидкий шлях масштабування</string>
    <string name="renderer_asynchronous_shaders">Асинхронні шейдери</string>
    <string name="renderer_asynchronous_shaders_description">Компілює шейдери асинхронно. Це може зменшити затримки, але також може спричинити графічні баги.</string>
-    <string name="gpu_unswizzle_settings">Налаштування розпакування за допомогою ГП</string>
-    <string name="gpu_unswizzle_settings_description">Налаштуйте розпакування текстур за допомогою ГП або повністю вимкнути його. Відкоригуйте ці налаштування, щоб урівноважити продуктивність і якість завантаження текстур.</string>
-    <string name="gpu_unswizzle_enable">Увімкнути розпакування за допомогою ГП</string>
-    <string name="gpu_unswizzle_disabled">Вимкнено</string>
-    <string name="gpu_unswizzle_texture_size">Максимальний розмір текстур для розпакування ГП за допомогою ГП</string>
-    <string name="gpu_unswizzle_texture_size_description">Встановлює максимальний розмір (МБ) для розпакування текстур за допомогою ГП. ГП швидше справляється з текстурами середніх і великих розмірів, а ЦП ефективніший для дуже маленьких. Налаштуйте, щоб збалансувати ГП-прискоренням і навантаженням на ЦП.</string>
-    <string name="gpu_unswizzle_stream_size">Розмір потоку розпакування за допомогою ГП</string>
-    <string name="gpu_unswizzle_stream_size_description">Встановлює обмеження даних на кадр для розпакування великих текстур. Вищі значення пришвидшують завантаження текстур за рахунок більших кадрових затримок; менші значення зменшують перевантаження ГП але може спричинити помітні появи текстур.</string>
-    <string name="gpu_unswizzle_chunk_size">Розмір блоків розпакування за допомогою ГП</string>
-    <string name="gpu_unswizzle_chunk_size_description">Визначає кількість зрізів глибини, оброблених за партію 3D-текстур. Збільшення здатне покращити пропускну здатність на потужних ГП, але може призвести до затримок або затримок драйвера зі слабшим устаткуванням.</string>
-    <string name="gpu_unswizzle_default_button">Стандартно</string>


    <string name="extensions">Розширення</string>
@@ -929,25 +916,10 @@
    <string name="memory_8gb">8 ГБ (Небезпечно)</string>

    <!-- GPU swizzle texture size -->
-    <string name="gpu_texturesizeswizzle_verysmall">Дуже малий (16 МБ)</string>
-    <string name="gpu_texturesizeswizzle_small">Малий (32 МБ)</string>
-    <string name="gpu_texturesizeswizzle_normal">Нормальний (128 МБ)</string>
-    <string name="gpu_texturesizeswizzle_large">Великий (256 МБ)</string>
-    <string name="gpu_texturesizeswizzle_verylarge">Дуже великий (512 МБ)</string>

    <!-- GPU swizzle streams -->
-    <string name="gpu_swizzle_verylow">Дуже низький (4 МБ)</string>
-    <string name="gpu_swizzle_low">Низький (8 МБ)</string>
-    <string name="gpu_swizzle_normal">Нормальний (16 МБ)</string>
-    <string name="gpu_swizzle_medium">Середній (32 МБ)</string>
-    <string name="gpu_swizzle_high">Високий (64 МБ)</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>
@@ -535,8 +535,6 @@
    <string name="renderer_force_max_clock_description">强制 GPU 以最大时钟运行 (温控依然生效)。</string>
    <string name="renderer_asynchronous_gpu_emulation">GPU 异步模拟</string>
    <string name="renderer_asynchronous_gpu_emulation_description">此技巧可通过异步运行 GPU 模拟来提升性能，但在执行与时序相关的操作时，可能带来图形显示问题以及增加崩溃概率。</string>
-    <string name="renderer_async_presentation">异步呈现</string>
-    <string name="renderer_async_presentation_description">此技巧通过将图形呈现移至独立的 CPU 线程来提升性能，但可能会带来图形显示问题。</string>
    <string name="renderer_reactive_flushing">启用反应性刷新</string>
    <string name="renderer_reactive_flushing_description">通过牺牲性能来提升某些游戏的渲染精度。</string>
    <string name="enable_buffer_history">启用缓冲区历史</string>
@@ -560,17 +558,6 @@
    <string name="rescale_hack_description">启用通过使用快速缩放路径，来为游戏提供缩放配置处理的传统处理方式</string>
    <string name="renderer_asynchronous_shaders">使用异步着色器</string>
    <string name="renderer_asynchronous_shaders_description">以异步方式编译着色器。采用此方式或可减少卡顿，但也可能引入故障点。</string>
-    <string name="gpu_unswizzle_settings">GPU Unswizzle 设置</string>
-    <string name="gpu_unswizzle_settings_description">配置基于 GPU 的纹理 unswizzling 参数，或完全禁用该功能。通过调整这些设置，以尝试在性能与纹理加载质量之间取得平衡。</string>
-    <string name="gpu_unswizzle_enable">启用 GPU Unswizzle</string>
-    <string name="gpu_unswizzle_disabled">禁用</string>
-    <string name="gpu_unswizzle_texture_size">GPU Unswizzle 最大纹理尺寸</string>
-    <string name="gpu_unswizzle_texture_size_description">设置基于 GPU 的纹理 unswizzling 的最大尺寸（MB）。虽然 GPU 处理中等和大型纹理的速度更快，但对于非常小的纹理，CPU 可能更为高效。通过调节此项设置，以平衡GPU 加速与 CPU 开销。</string>
-    <string name="gpu_unswizzle_stream_size">GPU Unswizzle 流大小</string>
-    <string name="gpu_unswizzle_stream_size_description">设置用于 unswizzling 大型纹理时的每帧数据限制。较高的数值可以加速纹理的加载过程，但会带来更高的帧延迟。而较低的数值则可以降低 GPU 的开销，但也可能会导致可见的纹理闪现。</string>
-    <string name="gpu_unswizzle_chunk_size">GPU Unswizzle 块大小</string>
-    <string name="gpu_unswizzle_chunk_size_description">定义了 3D 纹理每批次处理的深度切片数量。增加此数值可在高性能 GPU 上提升吞吐效率，但在性能较弱的硬件上可能会导致卡顿或驱动超时。</string>
-    <string name="gpu_unswizzle_default_button">默认</string>


    <string name="extensions">扩展</string>
@@ -1004,25 +991,10 @@
    <string name="fast_gpu_high">超频</string>

    <!-- GPU swizzle texture size -->
-    <string name="gpu_texturesizeswizzle_verysmall">极小 (16 MB)</string>
-    <string name="gpu_texturesizeswizzle_small">较小 (32 MB)</string>
-    <string name="gpu_texturesizeswizzle_normal">正常 (128 MB)</string>
-    <string name="gpu_texturesizeswizzle_large">较大 (256 MB)</string>
-    <string name="gpu_texturesizeswizzle_verylarge">极大 (512 MB)</string>

    <!-- GPU swizzle streams -->
-    <string name="gpu_swizzle_verylow">极低 (4 MB)</string>
-    <string name="gpu_swizzle_low">低 (8 MB)</string>
-    <string name="gpu_swizzle_normal">正常 (16 MB)</string>
-    <string name="gpu_swizzle_medium">中 (32 MB)</string>
-    <string name="gpu_swizzle_high">高 (64 MB)</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>
@@ -555,8 +555,6 @@
    <string name="renderer_force_max_clock_description">強制 GPU 以可能的最大時脈執行 (熱溫限制仍會被套用)</string>
    <string name="renderer_asynchronous_gpu_emulation">GPU 非同步模擬</string>
    <string name="renderer_asynchronous_gpu_emulation_description">此修改可透過使用 GPU 非同步模擬來提升性能，不過可能會導致圖形問題且會提高在進行時序相關操作時當機的機率</string>
-    <string name="renderer_async_presentation">非同步呈現</string>
-    <string name="renderer_async_presentation_description">此修改可以透過將渲染移至單獨的 CPU 執行緒來提升性能，但可能會導致圖形問題</string>
    <string name="renderer_reactive_flushing">使用重新啟用排清</string>
    <string name="renderer_reactive_flushing_description">犧牲效能，以改善部分遊戲的轉譯準確度</string>
    <string name="enable_buffer_history">啟用緩衝區歷史</string>
@@ -580,17 +578,6 @@
    <string name="rescale_hack_description">透過快速重新縮放處理來啟用遊戲重新縮放設定階段的舊版處理方式</string>
    <string name="renderer_asynchronous_shaders">使用非同步著色器</string>
    <string name="renderer_asynchronous_shaders_description">使用非同步編譯著色器。這可能會減少卡頓，但也可能導致圖形錯誤。</string>
-    <string name="gpu_unswizzle_settings">GPU Unswizzle 設定</string>
-    <string name="gpu_unswizzle_settings_description">設定基於 GPU 的 Unswizzling 參數或完全停用此功能。調整此設定以在性能與紋理載入品質中取得平衡</string>
-    <string name="gpu_unswizzle_enable">啟用 GPU Unswizzle</string>
-    <string name="gpu_unswizzle_disabled">停用</string>
-    <string name="gpu_unswizzle_texture_size">GPU Unswizzle 最大紋理尺寸</string>
-    <string name="gpu_unswizzle_texture_size_description">設定 GPU 紋理 Unswizzling 的最大值 （MB）。雖然 GPU 處理中型和大型紋理的速度較快，但 CPU 處理非常小的紋理可能更有效率。整此設定以在 GPU 加速與 CPU 負載之間取得平衡</string>
-    <string name="gpu_unswizzle_stream_size">GPU Unswizzle 流大小</string>
-    <string name="gpu_unswizzle_stream_size_description">設定每個影格處理大型紋理 Unswizzling 的資料上限。數值越高載入紋理的速度越快，但會增加畫面延遲；數值較低則能降低 GPU 負載，不過有可能導致至紋理載入不完全甚至突然出現</string>
-    <string name="gpu_unswizzle_chunk_size">GPU Unswizzle 塊大小</string>
-    <string name="gpu_unswizzle_chunk_size_description">設定 3D 紋理每批次處理的深度切片數量。增加此數值可提升規格較佳 GPU 的處理效率，但在較低規格的硬體上可能導致卡頓或驅動程式逾時</string>
-    <string name="gpu_unswizzle_default_button">預設</string>


    <string name="extensions">擴充功能</string>
@@ -591,54 +591,6 @@
        <item>2</item>
    </integer-array>

-    <string-array name="gpuTextureSizeSwizzleEntries">
-        <item>@string/gpu_texturesizeswizzle_verysmall</item>
-        <item>@string/gpu_texturesizeswizzle_small</item>
-        <item>@string/gpu_texturesizeswizzle_normal</item>
-        <item>@string/gpu_texturesizeswizzle_large</item>
-        <item>@string/gpu_texturesizeswizzle_verylarge</item>
-    </string-array>
-
-    <integer-array name="gpuTextureSizeSwizzleValues">
-        <item>0</item>
-        <item>1</item>
-        <item>2</item>
-        <item>3</item>
-        <item>4</item>
-    </integer-array>
-
-    <string-array name="gpuSwizzleEntries">
-        <item>@string/gpu_swizzle_verylow</item>
-        <item>@string/gpu_swizzle_low</item>
-        <item>@string/gpu_swizzle_normal</item>
-        <item>@string/gpu_swizzle_medium</item>
-        <item>@string/gpu_swizzle_high</item>
-    </string-array>
-
-    <integer-array name="gpuSwizzleValues">
-        <item>0</item>
-        <item>1</item>
-        <item>2</item>
-        <item>3</item>
-        <item>4</item>
-    </integer-array>
-    
-    <string-array name="gpuSwizzleChunkEntries">
-        <item>@string/gpu_swizzlechunk_verylow</item>
-        <item>@string/gpu_swizzlechunk_low</item>
-        <item>@string/gpu_swizzlechunk_normal</item>
-        <item>@string/gpu_swizzlechunk_medium</item>
-        <item>@string/gpu_swizzlechunk_high</item>
-    </string-array>
-
-    <integer-array name="gpuSwizzleChunkValues">
-        <item>0</item>
-        <item>1</item>
-        <item>2</item>
-        <item>3</item>
-        <item>4</item>
-    </integer-array>
-
    <string-array name="temperatureUnitEntries">
        <item>@string/temperature_celsius</item>
        <item>@string/temperature_fahrenheit</item>
@@ -105,6 +105,8 @@
    <string name="use_sync_core_description">Synchronize the core tick speed to the maximum speed percentage to improve performance without altering the game\'s actual speed.</string>
    <string name="cpuopt_unsafe_host_mmu">Enable Host MMU Emulation</string>
    <string name="cpuopt_unsafe_host_mmu_description">This optimization speeds up memory accesses by the guest program. Enabling it causes guest memory reads/writes to be done directly into memory and make use of Host\'s MMU. Disabling this forces all memory accesses to use Software MMU Emulation.</string>
+    <string name="relocate_36bit_address_space">Run 36-bit games natively</string>
+    <string name="relocate_36bit_address_space_description">Gives games built for the 36-bit address space the 39-bit layout so they can run with NCE instead of the JIT. Experimental: a game that relies on 36-bit addresses can crash.</string>
    <string name="debug_knobs">Debug knobs</string>
    <string name="debug_knobs_description">For development use only.</string>
    <string name="debug_knobs_hint">0 to 65535</string>
@@ -346,7 +348,7 @@
    <string name="frame_gen_flow_scale_auto">Match motion estimation to the game</string>
    <string name="frame_gen_flow_scale_auto_description">Estimate motion at the resolution the game actually renders instead of the upscaled output. Costs nothing in accuracy, since upscaling adds no motion detail.</string>
    <string name="frame_gen_flow_scale">Motion estimation resolution</string>
-    <string name="frame_gen_flow_scale_description">Resolution of the optical flow pass, as a fraction of the output. Lowering it is the cheapest way to reclaim performance.</string>
+    <string name="frame_gen_flow_scale_description">Resolution of the optical flow pass, as a fraction of the game\'s render resolution. Lowering it is the cheapest way to reclaim performance.</string>
    <string name="frame_gen_unsupported">Frame generation unavailable</string>
    <string name="frame_gen_unsupported_description">This GPU driver lacks the Vulkan memory model or half precision (float16) support that the Lossless Scaling shaders require.</string>
    <string name="lossless_scaling_setup_description">Optional. Provide your own Lossless.dll to enable frame generation later</string>
@@ -573,6 +575,8 @@
    <string name="accelerate_astc_description">Pick how ASTC-compressed textures are decoded for rendering: CPU (slow, safe), GPU (fast, recommended), or CPU Async (no stutters, may cause issues)</string>

    <string name="sync_memory_operations">Sync Memory Operations</string>
+    <string name="stall_on_gpu_fence_wait">Pause CPU on GPU fence timeouts</string>
+    <string name="stall_on_gpu_fence_wait_description">When a game keeps timing out while waiting for the GPU, pauses every CPU thread until the GPU catches up. Disabling it keeps the other threads running, which can reduce stutter but may break games that rely on it.</string>
    <string name="sync_memory_operations_description">Ensures data consistency between compute and memory operations. This option should fix issues in some games, but may also reduce performance in some cases. Unreal Engine 4 games often see the most significant changes thereof.</string>
    <string name="use_disk_shader_cache">Disk shader cache</string>
    <string name="use_disk_shader_cache_description">Reduces stuttering by locally storing and loading generated shaders.</string>
@@ -580,13 +584,15 @@
    <string name="renderer_force_max_clock_description">Forces the GPU to run at the maximum possible clocks (thermal constraints will still be applied).</string>
    <string name="renderer_asynchronous_gpu_emulation">GPU async emulation</string>
    <string name="renderer_asynchronous_gpu_emulation_description">This hack can increase performance by running GPU emulation asynchronously at the cost of graphical issues and increased crash rates by timing-related operations.</string>
-    <string name="renderer_async_presentation">Asynchronous presentation</string>
-    <string name="renderer_async_presentation_description">This hack can increase performance by moving presentation to a separate CPU thread at the cost of graphical issues.</string>
    <string name="renderer_reactive_flushing">Use reactive flushing</string>
    <string name="renderer_reactive_flushing_description">Improves rendering accuracy in some games at the cost of performance.</string>
+    <string name="renderer_barrier_feedback_loops">Barrier feedback loops</string>
+    <string name="renderer_barrier_feedback_loops_description">Improves rendering of transparency effects in specific 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="use_unified_memory">Unified Memory</string>
+    <string name="use_unified_memory_description">Backs part of the emulated memory with GPU-shared buffers so textures are unswizzled directly from it, skipping a CPU copy. Needs 12 GB of RAM or more and a GPU with I/O coherency; it turns itself off otherwise. Takes effect on the next game launch.</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>
@@ -605,17 +611,6 @@
    <string name="rescale_hack_description">Enables a legacy handling for the rescale configuration pass for games by using a quick rescale path</string>
    <string name="renderer_asynchronous_shaders">Use asynchronous shaders</string>
    <string name="renderer_asynchronous_shaders_description">Compiles shaders asynchronously. This may reduce stutters but may also introduce glitches.</string>
-    <string name="gpu_unswizzle_settings">GPU Unswizzle Settings</string>
-    <string name="gpu_unswizzle_settings_description">Configure GPU-based texture unswizzling parameters or disable it entirely. Adjust these settings to balance performance and texture loading quality.</string>
-    <string name="gpu_unswizzle_enable">Enable GPU Unswizzle</string>
-    <string name="gpu_unswizzle_disabled">Disabled</string>
-    <string name="gpu_unswizzle_texture_size">GPU Unswizzle Max Texture Size</string>
-    <string name="gpu_unswizzle_texture_size_description">Sets the maximum size (MB) for GPU-based texture unswizzling. While the GPU is faster for medium and large textures, the CPU may be more efficient for very small ones. Adjust this to find the balance between GPU acceleration and CPU overhead.</string>
-    <string name="gpu_unswizzle_stream_size">GPU Unswizzle Stream Size</string>
-    <string name="gpu_unswizzle_stream_size_description">Sets the data limit per frame for unswizzling large textures. Higher values speed up texture loading at the cost of higher frame latency; lower values reduce GPU overhead but may cause visible texture pop-in.</string>
-    <string name="gpu_unswizzle_chunk_size">GPU Unswizzle Chunk Size</string>
-    <string name="gpu_unswizzle_chunk_size_description">Defines the number of depth slices processed per batch for 3D textures. Increasing this improves throughput efficiency on powerful GPUs but may cause stuttering or driver timeouts on weaker hardware.</string>
-    <string name="gpu_unswizzle_default_button">Default</string>


    <string name="extensions">Extensions</string>
@@ -1065,25 +1060,10 @@
    <string name="fast_gpu_high">Overclock</string>

    <!-- GPU swizzle texture size -->
-    <string name="gpu_texturesizeswizzle_verysmall">Very Small (16 MB)</string>
-    <string name="gpu_texturesizeswizzle_small">Small (32 MB)</string>
-    <string name="gpu_texturesizeswizzle_normal">Normal (128 MB)</string>
-    <string name="gpu_texturesizeswizzle_large">Large (256 MB)</string>
-    <string name="gpu_texturesizeswizzle_verylarge">Very Large (512 MB)</string>

    <!-- GPU swizzle streams -->
-    <string name="gpu_swizzle_verylow">Very Low (4 MB)</string>
-    <string name="gpu_swizzle_low">Low (8 MB)</string>
-    <string name="gpu_swizzle_normal">Normal (16 MB)</string>
-    <string name="gpu_swizzle_medium">Medium (32 MB)</string>
-    <string name="gpu_swizzle_high">High (64 MB)</string>

    <!-- GPU swizzle chunks -->
-    <string name="gpu_swizzlechunk_verylow">Very Low (32)</string>
-    <string name="gpu_swizzlechunk_low">Low (64)</string>
-    <string name="gpu_swizzlechunk_normal">Normal (128)</string>
-    <string name="gpu_swizzlechunk_medium">Medium (256)</string>
-    <string name="gpu_swizzlechunk_high">High (512)</string>

    <!-- Temperature Units -->
    <string name="temperature_celsius">Celsius</string>
@@ -108,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
@@ -138,6 +137,8 @@ add_library(
    uuid.cpp
    uuid.h
    vector_math.h
+    virtual_buffer.cpp
+    virtual_buffer.h
    zstd_compression.cpp
    zstd_compression.h
    fs/ryujinx_compat.h fs/ryujinx_compat.cpp
@@ -244,8 +244,7 @@ WallClock::WallClock(bool invariant_, u64 rdtsc_frequency_) noexcept
    , ns_rdtsc_factor{invariant_ ? GetFixedPoint64Factor(NsRatio::den, rdtsc_frequency_) : 0}
    , us_rdtsc_factor{invariant_ ? GetFixedPoint64Factor(UsRatio::den, rdtsc_frequency_) : 0}
    , ms_rdtsc_factor{invariant_ ? GetFixedPoint64Factor(MsRatio::den, rdtsc_frequency_) : 0}
-    , rdtsc_ns_integer{invariant_ ? rdtsc_frequency_ / NsRatio::den : 1}
-    , rdtsc_ns_factor{invariant_ ? GetFixedPoint64Factor(rdtsc_frequency_ % NsRatio::den, NsRatio::den) : 0}
+    , rdtsc_ns_factor{invariant_ ? GetFixedPoint64Factor(rdtsc_frequency_, NsRatio::den) : 1}
    , cntpct_rdtsc_factor{invariant_ ? GetFixedPoint64Factor(CNTFRQ, rdtsc_frequency_) : 0}
    , gputick_rdtsc_factor{invariant_ ? GetFixedPoint64Factor(GPUTickFreq, rdtsc_frequency_) : 0}
    , invariant{invariant_}
@@ -292,7 +291,7 @@ bool WallClock::IsNative() const {
 }

 u64 WallClock::NsToTicks(std::chrono::nanoseconds ns) const {
-    return ns.count() * rdtsc_ns_integer + MultiplyHigh(ns.count(), rdtsc_ns_factor);
+    return invariant ? MultiplyHigh(ns.count(), rdtsc_ns_factor) : ns.count();
 }
 #elif defined(HAS_NCE)
 namespace {
@@ -417,7 +416,7 @@ u64 WallClock::NsToTicks(std::chrono::nanoseconds ns) const {
 const WallClock g_wall_clock = [] {
 #if defined(ARCHITECTURE_x86_64)
    auto const& caps = Common::g_cpu_caps;
-    return WallClock(caps.invariant_tsc && caps.tsc_frequency > std::nano::den, caps.tsc_frequency);
+    return WallClock(caps.invariant_tsc && caps.tsc_frequency >= std::nano::den, caps.tsc_frequency);
 #elif defined(HAS_NCE)
    return WallClock(false, 1);
 #else
@@ -96,7 +96,6 @@ public:
    u64 ns_rdtsc_factor;
    u64 us_rdtsc_factor;
    u64 ms_rdtsc_factor;
-    u64 rdtsc_ns_integer;
    u64 rdtsc_ns_factor;
    u64 cntpct_rdtsc_factor;
    u64 gputick_rdtsc_factor;
@@ -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

 #include "device_power_state.h"
@@ -14,14 +14,11 @@ extern std::atomic<bool> g_has_battery;

 #elif defined(__APPLE__)
 #include <TargetConditionals.h>
-#if defined(TARGET_OS_MAC) && TARGET_OS_MAC
-#if TARGET_OS_IPHONE
-// ios doesnt have this
-#else
+#if TARGET_OS_MAC
 #include <IOKit/ps/IOPSKeys.h>
 #include <IOKit/ps/IOPowerSources.h>
 #endif
-#endif
+
 #elif defined(__linux__)
 #include <fstream>
 #include <string>
@@ -51,9 +48,7 @@ namespace Common {
        info.percentage = g_battery_percentage.load(std::memory_order_relaxed);
        info.charging = g_is_charging.load(std::memory_order_relaxed);
        info.has_battery = g_has_battery.load(std::memory_order_relaxed);
-#elif defined(__APPLE__) && TARGET_OS_IPHONE
-        // Not implemented
-        info.has_battery = false;
+
 #elif defined(__APPLE__) && TARGET_OS_MAC
        CFTypeRef info_ref = IOPSCopyPowerSourcesInfo();
        CFArrayRef sources = IOPSCopyPowerSourcesList(info_ref);
@@ -101,6 +96,7 @@ namespace Common {
 #else
        info.has_battery = false;
 #endif
+
        return info;
    }
 }
@@ -9,6 +9,7 @@

 #include "common/assert.h"
 #include "common/fiber.h"
+#include "common/virtual_buffer.h"

 #include <boost/context/detail/fcontext.hpp>

@@ -5,7 +5,6 @@
 // SPDX-License-Identifier: GPL-2.0-or-later

 #include <algorithm>
-#include <cctype>
 #include <iostream>
 #include <sstream>
 #include "common/container/unordered_map.h"
@@ -481,80 +480,28 @@ std::string SanitizePath(std::string_view path_, DirectorySeparator directory_se
                           [type2](char c1, char c2) { return c1 == type2 && c2 == type2; }),
               path.end());

-    std::string root;
-    std::string_view components{path};
-    bool drive_relative = false;
-
-#ifdef _WIN32
-    const bool network = path.size() > 1 && path[0] == type2 && path[1] == type2;
-    const bool drive =
-        path.size() > 1 && std::isalpha(static_cast<unsigned char>(path[0])) && path[1] == ':';
-
-    if (network) {
-        root.assign(2, type2);
-        components.remove_prefix(2);
-    } else if (drive) {
-        root.assign(path.data(), 2);
-        components.remove_prefix(2);
-        if (!components.empty() && components.front() == type2) {
-            root += type2;
-            components.remove_prefix(1);
-        } else {
-            drive_relative = true;
-        }
-    }
-#endif
-
-    if (root.empty() && !components.empty() && components.front() == type2) {
-        root += type2;
-        components.remove_prefix(1);
-    }
-
-    const auto path_parts = SplitPathComponents(components);
-    std::size_t root_component_count = 0;
-#ifdef _WIN32
-    if (network) {
-        root_component_count = 2;
-
-        const auto is_unc = [](std::string_view part) {
-            return part.size() == 3 && (part[0] == 'U' || part[0] == 'u') &&
-                   (part[1] == 'N' || part[1] == 'n') && (part[2] == 'C' || part[2] == 'c');
-        };
-        if (path_parts.size() >= 2 && path_parts[0] == "?" && is_unc(path_parts[1])) {
-            root_component_count = 4;
-        }
-    }
-#endif
-
+    const bool absolute = !path.empty() && path[0] == type2;
    std::vector<std::string_view> parts;
-    for (std::size_t i = 0; i < path_parts.size(); ++i) {
-        const auto part = path_parts[i];
-        if (i < root_component_count) {
-            parts.push_back(part);
-        } else if (part.empty() || part == ".") {
+
+    for (const auto part : SplitPathComponents(path))
+    {
+        if (part.empty() || part == ".")
            continue;
-        } else if (part == "..") {
-            if (parts.size() > root_component_count) {
-                parts.pop_back();
-            }
-        } else {
-            parts.push_back(part);
-        }
+        if (part == ".." && !parts.empty() && parts.back() != "..")
+            parts.pop_back();
+        else if (part != "..") parts.push_back(part);
    }

-    const std::size_t root_length = root.size();
-    std::string resolved = std::move(root);
-    for (std::size_t i = 0; i < parts.size(); ++i) {
-        if (i != 0 || (!resolved.empty() && resolved.back() != type2 && !drive_relative))
+    std::string resolved = absolute ? std::string(1, type2) : std::string{};
+    for (std::size_t i = 0; i < parts.size(); ++i)
+    {
+        if (i != 0)
            resolved += type2;
        resolved.append(parts[i].data(), parts[i].size());
    }

    path = std::move(resolved);

-    if (!path.empty() && path.size() == root_length) {
-        return path;
-    }
    return std::string(RemoveTrailingSlash(path));
 }

@@ -347,9 +347,8 @@ enum class DirectorySeparator {
 // i.e. "C:\Users\Yuzu\Documents\save.bin" becomes {"C:", "Users", "Yuzu", "Documents", "save.bin" }
 [[nodiscard]] std::vector<std::string> SplitPathComponentsCopy(std::string_view filename);

-// Normalizes directory separators, removes duplicate and non-root trailing separators, and resolves
-// '.' and '..' components without traversing above the path root. Windows drive and UNC roots are
-// preserved.
+// Removes trailing slash, makes all '\\' into '/', and removes duplicate '/'. Makes '/' into '\\'
+// depending if directory_separator is BackwardSlash or PlatformDefault and running on windows
 [[nodiscard]] std::string SanitizePath(
    std::string_view path,
    DirectorySeparator directory_separator = DirectorySeparator::ForwardSlash);
@@ -27,11 +27,7 @@
 #include <sys/random.h>
 #elif defined(__APPLE__)
 #include <sys/types.h>
-#if defined(TARGET_OS_IPHONE) && TARGET_OS_IPHONE
-// Not available on iOS for some fucking stupid reason...
-#else
 #include <sys/random.h>
-#endif
 #include <mach/vm_map.h>
 #include <mach/mach.h>
 #elif defined(__FreeBSD__)
@@ -182,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)) {
@@ -410,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) {
@@ -438,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) {
@@ -458,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
@@ -556,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));
@@ -586,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);
@@ -714,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;
@@ -728,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;

@@ -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
@@ -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
@@ -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
@@ -48,7 +48,6 @@ SWITCHABLE(AnisotropyMode, true);
 SWITCHABLE(AntiAliasing, false);
 SWITCHABLE(AspectRatio, true);
 SWITCHABLE(AstcDecodeMode, true);
-SWITCHABLE(AstcRecompression, true);
 SWITCHABLE(AudioMode, true);
 SWITCHABLE(CpuBackend, true);
 SWITCHABLE(CpuAccuracy, true);
@@ -65,7 +65,6 @@ SWITCHABLE(AnisotropyMode, true);
 SWITCHABLE(AntiAliasing, false);
 SWITCHABLE(AspectRatio, true);
 SWITCHABLE(AstcDecodeMode, true);
-SWITCHABLE(AstcRecompression, true);
 SWITCHABLE(AudioMode, true);
 SWITCHABLE(CpuBackend, true);
 SWITCHABLE(CpuAccuracy, true);
@@ -260,6 +259,8 @@ struct Values {
                                                    Category::Cpu};
    SwitchableSetting<CpuAccuracy, true> cpu_accuracy{linkage, CpuAccuracy::Auto,
                                                      "cpu_accuracy", Category::Cpu};
+    SwitchableSetting<bool> relocate_36bit_address_space{
+        linkage, false, "relocate_36bit_address_space", Category::Cpu};
    SwitchableSetting<CpuClock> cpu_clock{linkage,
                                              CpuClock::Normal,
                                              "fast_cpu_time",
@@ -553,22 +554,6 @@ struct Values {
                                                            "accelerate_astc",
                                                            Category::RendererAdvanced};

-    SwitchableSetting<FramePacingMode, true> frame_pacing_mode{linkage,
-                                                               FramePacingMode::Target_Auto,
-                                                               FramePacingMode::Target_Auto,
-                                                               FramePacingMode::Target_120,
-                                                               "frame_pacing_mode",
-                                                               Category::RendererAdvanced,
-                                                               Specialization::Default,
-                                                               true,
-                                                               true};
-
-    SwitchableSetting<AstcRecompression, true> astc_recompression{linkage,
-                                                                  AstcRecompression::Uncompressed,
-                                                                  "astc_recompression",
-                                                                  Category::RendererAdvanced};
-
-
    SwitchableSetting<bool> sync_memory_operations{linkage,
                                                   false,
                                                   "sync_memory_operations",
@@ -576,6 +561,8 @@ struct Values {
                                                   Specialization::Default,
                                                   true,
                                                   true};
+    SwitchableSetting<bool> stall_on_gpu_fence_wait{linkage, true, "stall_on_gpu_fence_wait",
+                                                    Category::RendererAdvanced};

    SwitchableSetting<bool> renderer_force_max_clock{linkage, false, "force_max_clock",
                                                     Category::RendererAdvanced};
@@ -602,8 +589,13 @@ struct Values {
                                                  "use_reactive_flushing",
                                                  Category::RendererAdvanced};

-    SwitchableSetting<bool> barrier_feedback_loops{linkage, true, "barrier_feedback_loops",
-                                                   Category::RendererAdvanced};
+    SwitchableSetting<bool> barrier_feedback_loops{linkage,
+                                                   true,
+                                                   "barrier_feedback_loops",
+                                                   Category::RendererAdvanced,
+                                                   Specialization::Default,
+                                                   true,
+                                                   true};

    SwitchableSetting<bool> enable_buffer_history{linkage,
                                                  false,
@@ -641,7 +633,7 @@ struct Values {
                                                        true};
    SwitchableSetting<bool> async_presentation{linkage,
 #ifdef __ANDROID__
-                                               false,
+                                               true,
 #else
                                               false,
 #endif
@@ -666,26 +658,8 @@ struct Values {
    SwitchableSetting<bool> use_asynchronous_shaders{linkage, false, "use_asynchronous_shaders",
                                                     Category::RendererHacks};

-    SwitchableSetting<GpuUnswizzleSize> gpu_unswizzle_texture_size{linkage,
-                                                  GpuUnswizzleSize::Large,
-                                                  "gpu_unswizzle_texture_size",
-                                                  Category::RendererHacks,
-                                                  Specialization::Default};
-
-    SwitchableSetting<GpuUnswizzle> gpu_unswizzle_stream_size{linkage,
-                                                  GpuUnswizzle::Medium,
-                                                  "gpu_unswizzle_stream_size",
-                                                  Category::RendererHacks,
-                                                  Specialization::Default};
-
-    SwitchableSetting<GpuUnswizzleChunk> gpu_unswizzle_chunk_size{linkage,
-                                                  GpuUnswizzleChunk::Medium,
-                                                  "gpu_unswizzle_chunk_size",
-                                                  Category::RendererHacks,
-                                                  Specialization::Default};
-
-    SwitchableSetting<bool> gpu_unswizzle_enabled{linkage, false, "gpu_unswizzle_enabled",
-                                                  Category::RendererHacks};
+    SwitchableSetting<bool> use_unified_memory{linkage, false, "use_unified_memory",
+                                               Category::RendererHacks};

    SwitchableSetting<ExtendedDynamicState> dyna_state{linkage,
 #if defined(__ANDROID__)
@@ -130,8 +130,6 @@ ENUM(TimeZone, Auto, Default, Cet, Cst6Cdt, Cuba, Eet, Egypt, Eire, Est, Est5Edt
    Roc, Rok, Singapore, Turkey, Uct, Universal, Utc, WSu, Wet, Zulu);
 ENUM(AnisotropyMode, Automatic, Default, X2, X4, X8, X16);
 ENUM(AstcDecodeMode, Cpu, Gpu, CpuAsynchronous);
-ENUM(AstcRecompression, Uncompressed, Bc1, Bc3);
-ENUM(FramePacingMode, Target_Auto, Target_30, Target_60, Target_90, Target_120);
 ENUM(VSyncMode, Immediate, Mailbox, Fifo, FifoRelaxed);
 ENUM(VramUsageMode, Conservative, Aggressive);
 ENUM(RendererBackend, OpenGL_GLSL, Vulkan, Null, OpenGL_GLASM, OpenGL_SPIRV);
@@ -153,9 +151,6 @@ ENUM(ConsoleMode, Handheld, Docked);
 ENUM(AppletMode, HLE, LLE);
 ENUM(SpirvOptimizeMode, Never, OnLoad, Always);
 ENUM(GpuClock, Normal, Boost, Overclock)
-ENUM(GpuUnswizzleSize, VerySmall, Small, Normal, Large, VeryLarge)
-ENUM(GpuUnswizzle, VeryLow, Low, Normal, Medium, High)
-ENUM(GpuUnswizzleChunk, VeryLow, Low, Normal, Medium, High)
 ENUM(TemperatureUnits, Celsius, Fahrenheit)
 ENUM(ExtendedDynamicState, Disabled, EDS1, EDS2, EDS3);
 ENUM(GpuLogLevel, Off, Errors, Standard, Verbose, All)
@@ -1,143 +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 <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 {};
-
-// 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->ExceptionAddress);
-
-    if (code != EXCEPTION_ACCESS_VIOLATION) {
-        // Not our problem
-        return EXCEPTION_CONTINUE_SEARCH;
-    }
-
-    u64 addr = 0, addr2 = 0;
-
-    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_RESERVE) {
-        LOG_ERROR(HW_Memory, "Tried to commit an unreserved large buffer region at {:#x} that is not mapped or is already committed (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
-
-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) {
-        vector_regions.emplace_back(reinterpret_cast<u64>(base), reinterpret_cast<u64>(base) + size);
-
-        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
-    ASSERT(VirtualFree(base, 0, MEM_RELEASE));
-#else
-    ASSERT(munmap(base, size) == 0);
-#endif
-}
-
-} // namespace Common
@@ -1,195 +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
-const u64 HostPageSize = sysconf(_SC_PAGESIZE);
-const u64 HostPageBits = std::countr_zero(HostPageSize);
-const u64 HostPageMask = ~(HostPageSize - 1);
-#endif
-
-void* AllocateMemoryPages(std::size_t size) noexcept;
-void FreeMemoryPages(void* base, std::size_t size) 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);
-        }
-        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 / sizeof(T))) {
-            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) {
-            if (!IsCommittedPage((page - reinterpret_cast<u64>(base_ptr)) / sizeof(T))) {
-                continue;
-            }
-
-            std::memset(reinterpret_cast<void*>(page), 0, (std::min)( HostPageSize, 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 void 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)
-        CommitVectorPage(page, true);
-#else
-        mprotect(reinterpret_cast<void*>(page), HostPageSize, PROT_READ | PROT_WRITE);
-#endif
-
-        committed_pages[page_index >> 6].fetch_or(1ULL << (page_index & 63), std::memory_order_release);
-    }
-
-    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
@@ -0,0 +1,50 @@
+// SPDX-FileCopyrightText: Copyright 2025 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
+
+#ifdef _MSC_VER
+#include <intrin.h>
+#elif defined(ARCHITECTURE_x86_64)
+#include <xmmintrin.h>
+#endif
+#include <atomic>
+
+namespace Common {
+
+/// @brief A lock similar to mutex that forces a thread to spin wait instead calling the
+/// supervisor. Should be used on short sequences of code.
+struct SpinLock {
+    SpinLock() noexcept = default;
+    SpinLock(const SpinLock&) noexcept = delete;
+    SpinLock& operator=(const SpinLock&) noexcept = delete;
+    SpinLock(SpinLock&&) noexcept = delete;
+    SpinLock& operator=(SpinLock&&) noexcept = delete;
+
+    inline void lock() noexcept {
+        while (lck.test_and_set(std::memory_order_acquire)) {
+#if defined(ARCHITECTURE_x86_64)
+            _mm_pause();
+#elif defined(ARCHITECTURE_arm64) && defined(_MSC_VER)
+            __yield();
+#elif defined(ARCHITECTURE_arm64)
+            asm("yield");
+#endif
+        }
+    }
+
+    inline void unlock() noexcept {
+        lck.clear(std::memory_order_release);
+    }
+
+    [[nodiscard]] inline bool try_lock() noexcept {
+        return !lck.test_and_set(std::memory_order_acquire);
+    }
+
+    std::atomic_flag lck = ATOMIC_FLAG_INIT;
+};
+
+} // namespace Common
@@ -116,119 +116,18 @@ std::string ReplaceAll(std::string result, const std::string& src, const std::st
 }

 std::string UTF16ToUTF8(std::u16string_view input) {
-    std::string result;
-    result.reserve(input.size());
-    for (size_t i = 0; i < input.size(); ++i) {
-        uint32_t codepoint = input[i];
-        // Handle surrogate pairs
-        if (codepoint >= 0xD800 && codepoint <= 0xDBFF) {
-            if (i + 1 < input.size()) {
-                uint32_t low = input[i + 1];
-                if (low >= 0xDC00 && low <= 0xDFFF) {
-                    codepoint = ((codepoint - 0xD800) << 10) + (low - 0xDC00) + 0x10000;
-                    ++i;
-                }
-            }
-        }
-        if (codepoint <= 0x7F) {
-            result.push_back(static_cast<char>(codepoint));
-        } else if (codepoint <= 0x7FF) {
-            result.push_back(static_cast<char>(0xC0 | (codepoint >> 6)));
-            result.push_back(static_cast<char>(0x80 | (codepoint & 0x3F)));
-        } else if (codepoint <= 0xFFFF) {
-            result.push_back(static_cast<char>(0xE0 | (codepoint >> 12)));
-            result.push_back(static_cast<char>(0x80 | ((codepoint >> 6) & 0x3F)));
-            result.push_back(static_cast<char>(0x80 | (codepoint & 0x3F)));
-        } else {
-            result.push_back(static_cast<char>(0xF0 | (codepoint >> 18)));
-            result.push_back(static_cast<char>(0x80 | ((codepoint >> 12) & 0x3F)));
-            result.push_back(static_cast<char>(0x80 | ((codepoint >> 6) & 0x3F)));
-            result.push_back(static_cast<char>(0x80 | (codepoint & 0x3F)));
-        }
-    }
-    return result;
+    std::wstring_convert<std::codecvt_utf8_utf16<char16_t>, char16_t> convert;
+    return convert.to_bytes(input.data(), input.data() + input.size());
 }

 std::u16string UTF8ToUTF16(std::string_view input) {
-    std::u16string result;
-    size_t i = 0;
-    while (i < input.size()) {
-        uint32_t codepoint = 0;
-        unsigned char c = input[i];
-        size_t extra = 0;
-        if ((c & 0x80) == 0) {
-            codepoint = c;
-            extra = 0;
-        } else if ((c & 0xE0) == 0xC0) {
-            codepoint = c & 0x1F;
-            extra = 1;
-        } else if ((c & 0xF0) == 0xE0) {
-            codepoint = c & 0x0F;
-            extra = 2;
-        } else if ((c & 0xF8) == 0xF0) {
-            codepoint = c & 0x07;
-            extra = 3;
-        } else {
-            // Invalid UTF-8
-            ++i;
-            continue;
-        }
-        if (i + extra >= input.size()) break;
-        for (size_t j = 1; j <= extra; ++j) {
-            if ((input[i + j] & 0xC0) != 0x80) {
-                codepoint = 0xFFFD;
-                break;
-            }
-            codepoint = (codepoint << 6) | (input[i + j] & 0x3F);
-        }
-        if (codepoint <= 0xFFFF) {
-            result.push_back(static_cast<char16_t>(codepoint));
-        } else {
-            codepoint -= 0x10000;
-            result.push_back(static_cast<char16_t>(0xD800 + (codepoint >> 10)));
-            result.push_back(static_cast<char16_t>(0xDC00 + (codepoint & 0x3FF)));
-        }
-        i += extra + 1;
-    }
-    return result;
+    std::wstring_convert<std::codecvt_utf8_utf16<char16_t>, char16_t> convert;
+    return convert.from_bytes(input.data(), input.data() + input.size());
 }

 std::u32string UTF8ToUTF32(std::string_view input) {
-    std::u32string result;
-    size_t i = 0;
-    while (i < input.size()) {
-        uint32_t codepoint = 0;
-        unsigned char c = input[i];
-        size_t extra = 0;
-        if ((c & 0x80) == 0) {
-            codepoint = c;
-            extra = 0;
-        } else if ((c & 0xE0) == 0xC0) {
-            codepoint = c & 0x1F;
-            extra = 1;
-        } else if ((c & 0xF0) == 0xE0) {
-            codepoint = c & 0x0F;
-            extra = 2;
-        } else if ((c & 0xF8) == 0xF0) {
-            codepoint = c & 0x07;
-            extra = 3;
-        } else {
-            // Invalid UTF-8
-            ++i;
-            continue;
-        }
-        if (i + extra >= input.size()) break;
-        for (size_t j = 1; j <= extra; ++j) {
-            if ((input[i + j] & 0xC0) != 0x80) {
-                codepoint = 0xFFFD;
-                break;
-            }
-            codepoint = (codepoint << 6) | (input[i + j] & 0x3F);
-        }
-        result.push_back(codepoint);
-        i += extra + 1;
-    }
-    return result;
+    std::wstring_convert<std::codecvt_utf8<char32_t>, char32_t> convert;
+    return convert.from_bytes(input.data(), input.data() + input.size());
 }

 #ifdef _WIN32
@@ -208,9 +208,9 @@ UUID UUID::MakeRandomRFC4122V4() {
    return uuid;
 }

-UUID UUID::MakeRFC4122V5(std::span<u8, 16> sha1) {
+UUID UUID::MakeRFC4122V5(std::span<u8, 20> sha1) {
    UUID uuid{};
-    std::memcpy(&uuid.uuid, sha1.data(), sha1.size());
+    std::memcpy(&uuid.uuid, sha1.data(), sizeof(UUID));
    uuid.uuid[8] = 0x80 | (uuid.uuid[8] & 0x3F);
    uuid.uuid[6] = 0x50 | (uuid.uuid[6] & 0xF);
    return uuid;
@@ -104,7 +104,7 @@ struct UUID {
    /// @returns A random UUID that is RFC 4122 Version 4 compliant.
    [[nodiscard]] static UUID MakeRandomRFC4122V4();

-    [[nodiscard]] static UUID MakeRFC4122V5(std::span<u8, 16> sha1);
+    [[nodiscard]] static UUID MakeRFC4122V5(std::span<u8, 20> sha1);

    friend constexpr bool operator==(const UUID& lhs, const UUID& rhs) = default;
 };
@@ -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
@@ -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
@@ -796,8 +796,6 @@ add_library(core STATIC
    hle/service/ns/application_manager_interface.h
    hle/service/ns/application_version_interface.cpp
    hle/service/ns/application_version_interface.h
-    hle/service/ns/async_result.cpp
-    hle/service/ns/async_result.h
    hle/service/ns/content_management_interface.cpp
    hle/service/ns/content_management_interface.h
    hle/service/ns/develop_interface.cpp
@@ -812,6 +810,8 @@ add_library(core STATIC
    hle/service/ns/ecommerce_interface.h
    hle/service/ns/factory_reset_interface.cpp
    hle/service/ns/factory_reset_interface.h
+    hle/service/ns/i_async_result.cpp
+    hle/service/ns/i_async_result.h
    hle/service/ns/language.cpp
    hle/service/ns/language.h
    hle/service/ns/ns.cpp
@@ -1238,8 +1238,7 @@ if (HAS_NCE)
        arm/nce/interpreter_visitor.cpp
        arm/nce/interpreter_visitor.h
        arm/nce/patcher.cpp
-        arm/nce/patcher.h
-        arm/nce/visitor_base.h)
+        arm/nce/patcher.h)
    target_link_libraries(core PRIVATE merry::oaknut)
 endif()

@@ -1261,10 +1260,6 @@ if (ARCHITECTURE_x86_64 OR ARCHITECTURE_arm64 OR ARCHITECTURE_riscv64 OR ARCHITE
        hle/service/jit/jit.cpp
        hle/service/jit/jit.h)
    target_link_libraries(core PRIVATE dynarmic::dynarmic)
-    # Quick hack for XCode generator...
-    if (IOS)
-        target_include_directories(core PRIVATE "${CMAKE_SOURCE_DIR}/dynarmic/src")
-    endif()
 endif()

 if (TARGET OpenSSL::SSL)
@@ -6,7 +6,7 @@

 #pragma once

-#include "dynarmic/src/dynarmic/interface/halt_reason.h"
+#include <dynarmic/interface/halt_reason.h>

 #include "core/arm/arm_interface.h"

@@ -172,12 +172,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;
@@ -188,13 +188,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
@@ -427,7 +420,6 @@ void ArmDynarmic32::SignalInterrupt(Kernel::KThread* thread) {
 }

 void ArmDynarmic32::ClearInstructionCache() {
-    m_cb->last_code_addr = u64(-1);
    m_jit->ClearCache();
 }

@@ -6,8 +6,8 @@

 #pragma once

-#include "dynarmic/src/dynarmic/interface/A32/a32.h"
-#include "dynarmic/src/dynarmic/interface/code_page.h"
+#include <dynarmic/interface/A32/a32.h>
+#include <dynarmic/interface/code_page.h>

 #include "core/arm/arm_interface.h"
 #include "core/arm/dynarmic/dynarmic_exclusive_monitor.h"
@@ -211,12 +211,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;
@@ -230,13 +231,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
@@ -453,7 +447,6 @@ void ArmDynarmic64::SignalInterrupt(Kernel::KThread* thread) {
 }

 void ArmDynarmic64::ClearInstructionCache() {
-    m_cb->last_code_addr = u64(-1);
    m_jit->ClearCache();
 }

@@ -10,12 +10,12 @@
 #include <memory>
 #include "common/container/unordered_map.h"

-#include "../../../dynarmic/src/dynarmic/interface/A64/a64.h"
-#include "../../../dynarmic/src/dynarmic/interface/code_page.h"
-#include "../../../common/common_types.h"
-#include "../../../common/hash.h"
-#include "../arm_interface.h"
-#include "dynarmic_exclusive_monitor.h"
+#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"

 namespace Core::Memory {
 class Memory;
@@ -1,6 +1,3 @@
-// SPDX-FileCopyrightText: Copyright 2026 Eden Emulator Project
-// SPDX-License-Identifier: GPL-3.0-or-later
-
 // SPDX-FileCopyrightText: 2017 Citra Emulator Project
 // SPDX-License-Identifier: GPL-2.0-or-later

@@ -8,7 +5,7 @@

 #include <optional>

-#include "dynarmic/interface/A32/coprocessor.h"
+#include <dynarmic/interface/A32/coprocessor.h>
 #include "common/common_types.h"

 namespace Core {
@@ -1,12 +1,9 @@
-// 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 "dynarmic/src/dynarmic/interface/exclusive_monitor.h"
+#include <dynarmic/interface/exclusive_monitor.h>

 #include "common/common_types.h"
 #include "core/arm/exclusive_monitor.h"
@@ -7,97 +7,77 @@

 #pragma once

-#include <atomic>
-#include <signal.h>
-#include <unistd.h>
+#include <optional>
 #include <span>
+#include <signal.h>
+
+#pragma GCC diagnostic push
+#pragma GCC diagnostic ignored "-Wshadow"
+#include <dynarmic/frontend/A64/a64_types.h>
+#include <dynarmic/frontend/imm.h>
+#pragma GCC diagnostic pop

-#include "core/hle/kernel/k_thread.h"
 #include "core/memory.h"
-#include "common/logging.h"
-#include "core/arm/nce/visitor_base.h"

 namespace Core {

-namespace Memory {
-class Memory;
-}
-
-class InterpreterVisitor final : public VisitorBase {
+class InterpreterVisitor {
 public:
    explicit InterpreterVisitor(Core::Memory::Memory& memory, std::span<u64, 31> regs,
                                std::span<u128, 32> fpsimd_regs, u64& sp, const u64& pc)
        : m_memory(memory), m_regs(regs), m_fpsimd_regs(fpsimd_regs), m_sp(sp), m_pc(pc) {}
-    ~InterpreterVisitor() override = default;

-    enum class MemOp {
-        Load,
-        Store,
-        Prefetch,
-    };
-
-    u128 GetVec(Vec v);
-    u64 GetReg(Reg r);
-    u64 GetSp();
-    u64 GetPc();
-
-    void SetVec(Vec v, u128 value);
-    void SetReg(Reg r, u64 value);
-    void SetSp(u64 value);
-
-    u64 ExtendReg(size_t bitsize, Reg reg, Imm<3> option, u8 shift);
-
-    // Loads and stores - Load/Store Exclusive
-    bool Ordered(size_t size, bool L, bool o0, Reg Rn, Reg Rt);
-    bool STLLR(Imm<2> size, Reg Rn, Reg Rt) override;
-    bool STLR(Imm<2> size, Reg Rn, Reg Rt) override;
-    bool LDLAR(Imm<2> size, Reg Rn, Reg Rt) override;
-    bool LDAR(Imm<2> size, Reg Rn, Reg Rt) override;
-
-    // Loads and stores - Load register (literal)
-    bool LDR_lit_gen(bool opc_0, Imm<19> imm19, Reg Rt) override;
-    bool LDR_lit_fpsimd(Imm<2> opc, Imm<19> imm19, Vec Vt) override;
-
-    // Loads and stores - Load/Store register pair
-    bool STP_LDP_gen(Imm<2> opc, bool not_postindex, bool wback, Imm<1> L, Imm<7> imm7, Reg Rt2,
-                     Reg Rn, Reg Rt) override;
-    bool STP_LDP_fpsimd(Imm<2> opc, bool not_postindex, bool wback, Imm<1> L, Imm<7> imm7, Vec Vt2,
-                        Reg Rn, Vec Vt) override;
-
-    // Loads and stores - Load/Store register (immediate)
-    bool RegisterImmediate(bool wback, bool postindex, size_t scale, u64 offset, Imm<2> size,
-                           Imm<2> opc, Reg Rn, Reg Rt);
-    bool STRx_LDRx_imm_1(Imm<2> size, Imm<2> opc, Imm<9> imm9, bool not_postindex, Reg Rn,
-                         Reg Rt) override;
-    bool STRx_LDRx_imm_2(Imm<2> size, Imm<2> opc, Imm<12> imm12, Reg Rn, Reg Rt) override;
-    bool STURx_LDURx(Imm<2> size, Imm<2> opc, Imm<9> imm9, Reg Rn, Reg Rt) override;
-
-    bool SIMDImmediate(bool wback, bool postindex, size_t scale, u64 offset, MemOp memop, Reg Rn,
-                       Vec Vt);
-    bool STR_imm_fpsimd_1(Imm<2> size, Imm<1> opc_1, Imm<9> imm9, bool not_postindex, Reg Rn,
-                          Vec Vt) override;
-    bool STR_imm_fpsimd_2(Imm<2> size, Imm<1> opc_1, Imm<12> imm12, Reg Rn, Vec Vt) override;
-    bool LDR_imm_fpsimd_1(Imm<2> size, Imm<1> opc_1, Imm<9> imm9, bool not_postindex, Reg Rn,
-                          Vec Vt) override;
-    bool LDR_imm_fpsimd_2(Imm<2> size, Imm<1> opc_1, Imm<12> imm12, Reg Rn, Vec Vt) override;
-    bool STUR_fpsimd(Imm<2> size, Imm<1> opc_1, Imm<9> imm9, Reg Rn, Vec Vt) override;
-    bool LDUR_fpsimd(Imm<2> size, Imm<1> opc_1, Imm<9> imm9, Reg Rn, Vec Vt) override;
-
-    // Loads and stores - Load/Store register (register offset)
-    bool RegisterOffset(size_t scale, u8 shift, Imm<2> size, Imm<1> opc_1, Imm<1> opc_0, Reg Rm,
-                        Imm<3> option, Reg Rn, Reg Rt);
-    bool STRx_reg(Imm<2> size, Imm<1> opc_1, Reg Rm, Imm<3> option, bool S, Reg Rn,
-                  Reg Rt) override;
-    bool LDRx_reg(Imm<2> size, Imm<1> opc_1, Reg Rm, Imm<3> option, bool S, Reg Rn,
-                  Reg Rt) override;
-
-    bool SIMDOffset(size_t scale, u8 shift, Imm<1> opc_0, Reg Rm, Imm<3> option, Reg Rn, Vec Vt);
-    bool STR_reg_fpsimd(Imm<2> size, Imm<1> opc_1, Reg Rm, Imm<3> option, bool S, Reg Rn,
-                        Vec Vt) override;
-    bool LDR_reg_fpsimd(Imm<2> size, Imm<1> opc_1, Reg Rm, Imm<3> option, bool S, Reg Rn,
-                        Vec Vt) override;
+    bool Execute(u32 inst);

 private:
+    template <size_t BitSize>
+    using Imm = Dynarmic::Imm<BitSize>;
+    using Reg = Dynarmic::A64::Reg;
+    using Vec = Dynarmic::A64::Vec;
+
+    u128 GetVec(Vec v) const {
+        return m_fpsimd_regs[static_cast<u32>(v)];
+    }
+    void SetVec(Vec v, u128 value) {
+        m_fpsimd_regs[static_cast<u32>(v)] = value;
+    }
+    u64 GetReg(Reg r) const {
+        return m_regs[static_cast<u32>(r)];
+    }
+    void SetReg(Reg r, u64 value) {
+        m_regs[static_cast<u32>(r)] = value;
+    }
+    u64 GetRegSp(Reg r) const {
+        if (r == Reg::SP) {
+            return m_sp;
+        }
+        return m_regs[static_cast<u32>(r)];
+    }
+    void SetRegSp(Reg r, u64 value) {
+        if (r == Reg::SP) {
+            m_sp = value;
+            return;
+        }
+        m_regs[static_cast<u32>(r)] = value;
+    }
+
+    u64 ExtendReg(Reg reg, Imm<3> option, u8 shift);
+
+    bool Ordered(size_t size, bool load, Reg Rn, Reg Rt);
+    bool LoadLiteral(bool wide, Imm<19> imm19, Reg Rt);
+    bool LoadLiteralSimd(Imm<2> opc, Imm<19> imm19, Vec Vt);
+    bool Pair(Imm<2> opc, bool not_postindex, bool wback, bool load, Imm<7> imm7, Reg Rt2, Reg Rn,
+              Reg Rt);
+    bool PairSimd(Imm<2> opc, bool not_postindex, bool wback, bool load, Imm<7> imm7, Vec Vt2,
+                  Reg Rn, Vec Vt);
+    bool RegisterImmediate(bool wback, bool postindex, u64 offset, Imm<2> size, Imm<2> opc, Reg Rn,
+                           Reg Rt);
+    bool RegisterOffset(bool S, Imm<2> size, Imm<1> opc_1, Imm<1> opc_0, Reg Rm, Imm<3> option,
+                        Reg Rn, Reg Rt);
+    bool SimdImmediate(bool wback, bool postindex, size_t scale, u64 offset, bool load, Reg Rn,
+                       Vec Vt);
+    bool SimdOffset(size_t scale, bool S, bool load, Reg Rm, Imm<3> option, Reg Rn, Vec Vt);
+
    Core::Memory::Memory& m_memory;
    std::span<u64, 31> m_regs;
    std::span<u128, 32> m_fpsimd_regs;
@@ -371,14 +371,9 @@ size_t Patcher::GetPreSectionSize() const noexcept {
 }

 void Patcher::WriteLoadContext(oaknut::VectorCodeGenerator& cg) {
-    // This function was called, which modifies X30, so use that as a scratch register.
-    // SP contains the guest X30, so save our return X30 to SP + 8, since we have allocated 16 bytes
-    // of stack.
    cg.STR(X30, SP, 8);
-    cg.MRS(X30, oaknut::SystemReg::TPIDR_EL0);
-    cg.LDR(X30, X30, offsetof(NativeExecutionParameters, native_context));
+    cg.LDR(X30, SP, 0);

-    // Load system registers.
    cg.LDR(W0, X30, offsetof(GuestContext, fpsr));
    cg.MSR(oaknut::SystemReg::FPSR, X0);
    cg.LDR(W0, X30, offsetof(GuestContext, fpcr));
@@ -386,7 +381,9 @@ void Patcher::WriteLoadContext(oaknut::VectorCodeGenerator& cg) {
    cg.LDR(W0, X30, offsetof(GuestContext, nzcv));
    cg.MSR(oaknut::SystemReg::NZCV, X0);

-    // Load all vector registers.
+    cg.LDR(X0, X30, 8 * 30);
+    cg.STR(X0, SP, 0);
+
    static constexpr size_t VEC_OFF = offsetof(GuestContext, vector_registers);
    for (int i = 0; i <= 30; i += 2) {
        cg.LDP(oaknut::QReg{i}, oaknut::QReg{i + 1}, X30, VEC_OFF + 16 * i);
@@ -436,7 +433,7 @@ void Patcher::WriteSaveContext(oaknut::VectorCodeGenerator& cg) {
    cg.STR(W0, X30, offsetof(GuestContext, nzcv));
    cg.LDR(X0, SP, POST_INDEXED, 16);

-    // Reload our return X30 from the stack, and return.
+    cg.MOV(X1, X30);
    cg.LDR(X30, SP, 8);
    cg.RET();
 }
@@ -457,8 +454,6 @@ void Patcher::WriteSvcTrampoline(ModuleDestLabel module_dest, u32 svc_id, oaknut
    // Now that we've saved all registers, we can use any registers as scratch.
    // Store PC + 4 to arm interface, since we know the instruction offset from the entry point.
    oaknut::Label pc_after_svc;
-    cg.MRS(X1, oaknut::SystemReg::TPIDR_EL0);
-    cg.LDR(X1, X1, offsetof(NativeExecutionParameters, native_context));
    cg.LDR(X2, pc_after_svc);
    cg.STR(X2, X1, offsetof(GuestContext, pc));

@@ -514,24 +509,13 @@ void Patcher::WriteSvcTrampoline(ModuleDestLabel module_dest, u32 svc_id, oaknut

    // Host called this location. Save the return address so we can
    // unwind the stack properly when jumping back.
-    cg.MRS(X2, oaknut::SystemReg::TPIDR_EL0);
-    cg.LDR(X2, X2, offsetof(NativeExecutionParameters, native_context));
-    cg.ADD(X0, X2, offsetof(GuestContext, host_ctx));
+    cg.ADD(X0, X1, offsetof(GuestContext, host_ctx));
    cg.STR(X30, X0, offsetof(HostContext, host_saved_regs) + 11 * sizeof(u64));

-    // Reload all guest registers except X30 and PC.
-    // The function also expects 16 bytes of stack already allocated.
-    cg.STR(X30, SP, PRE_INDEXED, -16);
+    cg.STR(X1, SP, PRE_INDEXED, -16);
    cg.BL(load_ctx);
    cg.LDR(X30, SP, POST_INDEXED, 16);

-    // Use X1 as a scratch register to restore X30.
-    cg.STR(X1, SP, PRE_INDEXED, -16);
-    cg.MRS(X1, oaknut::SystemReg::TPIDR_EL0);
-    cg.LDR(X1, X1, offsetof(NativeExecutionParameters, native_context));
-    cg.LDR(X30, X1, offsetof(GuestContext, cpu_registers) + sizeof(u64) * 30);
-    cg.LDR(X1, SP, POST_INDEXED, 16);
-
    // Unlock the context.
    this->UnlockContext(cg);

@@ -29,11 +29,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;
    }

@@ -18,7 +18,11 @@
 #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 Common {
+class HostMemory;
+}

 namespace Core {

@@ -126,6 +130,10 @@ public:
    // New batch API to update multiple ranges with a single lock acquisition.
    void UpdatePagesCachedBatch(std::span<const std::pair<DAddr, size_t>> ranges, s32 delta);

+    const Common::HostMemory& GetHostMemory() const noexcept {
+        return host_memory;
+    }
+
 private:
    struct TranslationEntry {
        DAddr guest_page{};
@@ -171,6 +179,7 @@ private:
    std::unique_ptr<DeviceMemoryManagerAllocator<Traits>> impl;

    const uintptr_t physical_base;
+    const Common::HostMemory& host_memory;
    DeviceInterface* device_inter;

    struct TrackedEntry {
@@ -178,8 +187,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 +209,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{};
@@ -171,12 +171,24 @@ struct DeviceMemoryManagerAllocator {
 template <typename Traits>
 DeviceMemoryManager<Traits>::DeviceMemoryManager(const DeviceMemory& device_memory_)
    : physical_base{uintptr_t(device_memory_.buffer.BackingBasePointer())}
+    , host_memory{device_memory_.buffer}
    , device_inter{nullptr}
    , compressed_device_addr(1ULL << ((Settings::values.memory_layout_mode.GetValue() == Settings::MemoryLayout::Memory_4Gb ? physical_min_bits : physical_max_bits) - Memory::YUZU_PAGEBITS))
    , tracked_entries(device_as_size >> Memory::YUZU_PAGEBITS)
 {
    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 +221,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 +256,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 +286,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 +297,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 +314,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 +384,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{
@@ -100,7 +100,8 @@ VirtualFile PatchIPS(const VirtualFile& in, const VirtualFile& ips) {


 struct IPSwitchRecord {
-    std::vector<uint8_t> data;
+    std::array<uint8_t, 256 - sizeof(size_t)> data;
+    size_t count;
 };
 struct IPSwitchCompiler::IPSwitchPatch {
    ::Common::unordered_map<u32, IPSwitchRecord> records;
@@ -121,23 +122,22 @@ static IPSwitchRecord EscapeStringSequences(std::string_view sv) {
    IPSwitchRecord r{};
    for (auto it = sv.cbegin(); it < sv.cend(); ) {
        if (*it == '\\' && it + 1 < sv.cend()) {
-            r.data.push_back([it]() {
-                switch (it[1]) {
-                case 'a': return '\a';
-                case 'b': return '\b';
-                case 'e': return '\e';
-                case 'f': return '\f';
-                case 'n': return '\n';
-                case 'r': return '\r';
-                case 't': return '\t';
-                case 'v': return '\v';
-                case '?': return '\?';
-                default: return it[1];
-                }
-            }());
+            switch (it[1]) {
+            case 'a': r.data[r.count] = '\a'; break;
+            case 'b': r.data[r.count] = '\b'; break;
+            case 'e': r.data[r.count] = '\e'; break;
+            case 'f': r.data[r.count] = '\f'; break;
+            case 'n': r.data[r.count] = '\n'; break;
+            case 'r': r.data[r.count] = '\r'; break;
+            case 't': r.data[r.count] = '\t'; break;
+            case 'v': r.data[r.count] = '\v'; break;
+            case '?': r.data[r.count] = '\?'; break;
+            default: r.data[r.count] = it[1]; break;
+            }
+            ++r.count;
            it += 2;
        } else {
-            r.data.push_back(*it);
+            ++r.count;
            ++it;
        }
    }
@@ -223,8 +223,8 @@ void IPSwitchCompiler::Parse(std::span<u8 const> bytes) {
                if (start <= line.cend() && end <= line.cend()) {
                    // Actually IPS wants ordering from {lsb, ..., msb} -- so LE and BE are inverted, fun!
                    auto const hs = Common::HexStringToVector({start, end}, is_little_endian);
-                    r.data.resize(hs.size());
                    std::memcpy(r.data.data(), hs.data(), hs.size());
+                    r.count = hs.size();
                    LOG_INFO(Loader, "[H] value @ {:#08X}", offset);
                    patches.back().records.insert_or_assign(u32(offset), std::move(r));
                } else {
@@ -293,7 +293,7 @@ VirtualFile IPSwitchCompiler::Apply(const VirtualFile& in) const {
        if (patch.enabled) {
            for (const auto& record : patch.records) {
                if (record.first < in_data.size()) {
-                    auto replace_size = record.second.data.size();
+                    auto replace_size = record.second.count;
                    if (record.first + replace_size > in_data.size())
                        replace_size = in_data.size() - record.first;
                    std::memcpy(in_data.data() + record.first, record.second.data.data(), replace_size);
@@ -9,7 +9,6 @@
 #include <cstddef>
 #include <cstring>

-#include "common/assert.h"
 #include "common/hex_util.h"
 #include "common/logging.h"
 #include "common/settings.h"
@@ -157,15 +156,12 @@ std::string GetUpdateVersionStringFromSlot(const ContentProvider* provider, u64
    NACP nacp{nacp_file};
    return nacp.GetVersionString();
 }
-YUZU_NO_INLINE std::optional<u64> GetParentApplicationId(const ContentProvider* provider, u64 title_id) {
-    return provider == nullptr ? std::nullopt : provider->GetParentApplicationId(title_id);
-}
 } // Anonymous namespace

 PatchManager::PatchManager(u64 title_id_,
                           const Service::FileSystem::FileSystemController& fs_controller_,
                           const ContentProvider& content_provider_)
-    : title_id{title_id_}, parent_title_id{GetParentApplicationId(std::addressof(content_provider_), title_id_)}, fs_controller{fs_controller_}, content_provider{content_provider_} {}
+    : title_id{title_id_}, fs_controller{fs_controller_}, content_provider{content_provider_} {}

 PatchManager::~PatchManager() = default;

@@ -173,35 +169,13 @@ u64 PatchManager::GetTitleID() const {
    return title_id;
 }

-VirtualDir PatchManager::GetModificationLoadRoot(bool sdmc) const {
-    const auto get_root = [&](u64 id) {
-        return sdmc ? fs_controller.GetSDMCModificationLoadRoot(id) : fs_controller.GetModificationLoadRoot(id);
-    };
-    auto root = get_root(title_id);
-    if (!parent_title_id) {
-        return root;
-    }
-    std::vector<VirtualDir> roots{std::move(root), get_root(*parent_title_id)};
-    std::erase(roots, nullptr);
-    return LayeredVfsDirectory::MakeLayeredDirectory(std::move(roots));
-}
-
-std::vector<std::string> PatchManager::GetDisabledAddons() const {
-    auto disabled = Settings::values.disabled_addons[title_id];
-    if (parent_title_id) {
-        const auto& shared = Settings::values.disabled_addons[*parent_title_id];
-        disabled.insert(disabled.end(), shared.begin(), shared.end());
-    }
-    return disabled;
-}
-
 VirtualDir PatchManager::PatchExeFS(VirtualDir exefs) const {
    LOG_INFO(Loader, "Patching ExeFS for title_id={:016X}", title_id);

    if (exefs == nullptr)
        return exefs;

-    const auto disabled = GetDisabledAddons();
+    const auto& disabled = Settings::values.disabled_addons[title_id];

    bool update_disabled = true;
    std::optional<u32> enabled_version;
@@ -329,8 +303,8 @@ VirtualDir PatchManager::PatchExeFS(VirtualDir exefs) const {
    }

    // LayeredExeFS
-    const auto load_dir = GetModificationLoadRoot();
-    const auto sdmc_load_dir = GetModificationLoadRoot(true);
+    const auto load_dir = fs_controller.GetModificationLoadRoot(title_id);
+    const auto sdmc_load_dir = fs_controller.GetSDMCModificationLoadRoot(title_id);

    std::vector<VirtualDir> patch_dirs = {sdmc_load_dir};
    if (load_dir != nullptr) {
@@ -372,7 +346,7 @@ VirtualDir PatchManager::PatchExeFS(VirtualDir exefs) const {
 }

 std::vector<VirtualFile> PatchManager::CollectPatches(const std::vector<VirtualDir>& patch_dirs, const std::string& build_id) const {
-    const auto disabled = GetDisabledAddons();
+    const auto& disabled = Settings::values.disabled_addons[title_id];
    const auto nso_build_id = fmt::format("{:0<64}", build_id);

    std::vector<VirtualFile> out;
@@ -431,7 +405,7 @@ std::vector<u8> PatchManager::PatchNSO(const std::vector<u8>& nso, const std::st

    LOG_INFO(Loader, "Patching NSO for name={}, build_id={}", name, build_id);

-    const auto load_dir = GetModificationLoadRoot();
+    const auto load_dir = fs_controller.GetModificationLoadRoot(title_id);
    if (load_dir == nullptr) {
        LOG_ERROR(Loader, "Cannot load mods for invalid title_id={:016X}", title_id);
        return nso;
@@ -474,7 +448,7 @@ bool PatchManager::HasNSOPatch(const BuildID& build_id_, std::string_view name)

    LOG_INFO(Loader, "Querying NSO patch existence for build_id={}, name={}", build_id, name);

-    const auto load_dir = GetModificationLoadRoot();
+    const auto load_dir = fs_controller.GetModificationLoadRoot(title_id);
    if (load_dir == nullptr) {
        LOG_ERROR(Loader, "Cannot load mods for invalid title_id={:016X}", title_id);
        return false;
@@ -488,13 +462,13 @@ bool PatchManager::HasNSOPatch(const BuildID& build_id_, std::string_view name)
 }

 std::vector<Core::Memory::CheatEntry> PatchManager::CreateCheatList(const BuildID& build_id_) const {
-    const auto load_dir = GetModificationLoadRoot();
+    const auto load_dir = fs_controller.GetModificationLoadRoot(title_id);
    if (load_dir == nullptr) {
        LOG_ERROR(Loader, "Cannot load mods for invalid title_id={:016X}", title_id);
        return {};
    }

-    const auto disabled = GetDisabledAddons();
+    const auto& disabled = Settings::values.disabled_addons[title_id];
    auto patch_dirs = load_dir->GetSubdirectories();
    std::sort(patch_dirs.begin(), patch_dirs.end(), [](auto const& l, auto const& r) { return l->GetName() < r->GetName(); });

@@ -528,16 +502,17 @@ std::vector<Core::Memory::CheatEntry> PatchManager::CreateCheatList(const BuildI
    return out;
 }

-void PatchManager::ApplyLayeredFS(VirtualFile& romfs, ContentRecordType type) const {
-    const auto load_dir = GetModificationLoadRoot();
-    const auto sdmc_load_dir = GetModificationLoadRoot(true);
+static void ApplyLayeredFS(VirtualFile& romfs, u64 title_id, ContentRecordType type,
+                           const Service::FileSystem::FileSystemController& fs_controller) {
+    const auto load_dir = fs_controller.GetModificationLoadRoot(title_id);
+    const auto sdmc_load_dir = fs_controller.GetSDMCModificationLoadRoot(title_id);
    if ((type != ContentRecordType::Program && type != ContentRecordType::Data &&
         type != ContentRecordType::HtmlDocument) ||
        (load_dir == nullptr && sdmc_load_dir == nullptr)) {
        return;
    }

-    const auto disabled = GetDisabledAddons();
+    const auto& disabled = Settings::values.disabled_addons[title_id];
    std::vector<VirtualDir> patch_dirs = load_dir->GetSubdirectories();
    if (std::find(disabled.cbegin(), disabled.cend(), "SDMC") == disabled.cend()) {
        patch_dirs.push_back(sdmc_load_dir);
@@ -616,7 +591,7 @@ VirtualFile PatchManager::PatchRomFS(const NCA* base_nca, VirtualFile base_romfs

    // Game Updates
    const auto update_tid = GetUpdateTitleID(title_id);
-    const auto disabled = GetDisabledAddons();
+    const auto& disabled = Settings::values.disabled_addons[title_id];

    bool update_disabled = true;
    std::optional<u32> enabled_version;
@@ -723,7 +698,7 @@ VirtualFile PatchManager::PatchRomFS(const NCA* base_nca, VirtualFile base_romfs

    // LayeredFS
    if (apply_layeredfs) {
-        ApplyLayeredFS(romfs, type);
+        ApplyLayeredFS(romfs, title_id, type, fs_controller);
    }

    return romfs;
@@ -1097,22 +1072,15 @@ std::vector<Patch> PatchManager::GetPatches(VirtualFile update_raw) const {
 std::optional<u32> PatchManager::GetGameVersion() const {
    const auto update_tid = GetUpdateTitleID(title_id);
    if (content_provider.HasEntry(update_tid, ContentRecordType::Program)) {
-        const auto version = content_provider.GetEntryVersion(update_tid);
-        return version || !parent_title_id ? version : content_provider.GetEntryVersion(GetUpdateTitleID(*parent_title_id));
+        return content_provider.GetEntryVersion(update_tid);
    }

-    const auto version = content_provider.GetEntryVersion(title_id);
-    return version || !parent_title_id ? version : content_provider.GetEntryVersion(*parent_title_id);
+    return content_provider.GetEntryVersion(title_id);
 }

 PatchManager::Metadata PatchManager::GetControlMetadata() const {
    const auto base_control_nca = content_provider.GetEntry(title_id, ContentRecordType::Control);
    if (base_control_nca == nullptr) {
-        if (parent_title_id) {
-            const auto control_id = content_provider.HasEntry(*parent_title_id, ContentRecordType::Control) ? *parent_title_id : GetUpdateTitleID(*parent_title_id);
-            const PatchManager parent{control_id, fs_controller, content_provider};
-            return parent.GetControlMetadata();
-        }
        return {};
    }

@@ -109,14 +109,10 @@ public:
    [[nodiscard]] static PatchManager::Metadata GetMetadataFromBaseOrUpdate(Core::System& system, u64 application_id) noexcept;

 private:
-    [[nodiscard]] VirtualDir GetModificationLoadRoot(bool sdmc = false) const;
-    [[nodiscard]] std::vector<std::string> GetDisabledAddons() const;
-    void ApplyLayeredFS(VirtualFile& romfs, ContentRecordType type) const;
    [[nodiscard]] std::vector<VirtualFile> CollectPatches(const std::vector<VirtualDir>& patch_dirs,
                                                          const std::string& build_id) const;

    u64 title_id;
-    std::optional<u64> parent_title_id;
    const Service::FileSystem::FileSystemController& fs_controller;
    const ContentProvider& content_provider;
 };
@@ -147,6 +147,10 @@ ProgramAddressSpaceType ProgramMetadata::GetAddressSpaceType() const {
    return npdm_header.address_space_type;
 }

+void ProgramMetadata::SetAddressSpaceType(ProgramAddressSpaceType address_space) {
+    npdm_header.address_space_type.Assign(address_space);
+}
+
 u8 ProgramMetadata::GetMainThreadPriority() const {
    return npdm_header.main_thread_priority;
 }
@@ -1,3 +1,6 @@
+// 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

@@ -73,6 +76,7 @@ public:

    bool Is64BitProgram() const;
    ProgramAddressSpaceType GetAddressSpaceType() const;
+    void SetAddressSpaceType(ProgramAddressSpaceType address_space);
    u8 GetMainThreadPriority() const;
    u8 GetMainThreadCore() const;
    u32 GetMainThreadStackSize() const;
@@ -5,7 +5,6 @@
 // SPDX-License-Identifier: GPL-2.0-or-later

 #include <algorithm>
-#include <limits>
 #include <random>
 #include <regex>
 #include <openssl/evp.h>
@@ -349,22 +348,6 @@ std::vector<ContentProviderEntry> ContentProvider::ListEntries() const {
    return ListEntriesFilter(std::nullopt, std::nullopt, std::nullopt);
 }

-std::optional<u64> ContentProvider::GetParentApplicationId(u64 program_id) const {
-    const auto application_id = GetBaseTitleID(program_id);
-    const auto program_index = program_id - application_id;
-    if (program_index == 0 || program_index > std::numeric_limits<u8>::max()) {
-        return std::nullopt;
-    }
-    if (!ListEntriesFilter(TitleType::Application, ContentRecordType::Meta, program_id).empty()) {
-        return std::nullopt;
-    }
-    if ((!ListEntriesFilter(TitleType::Application, ContentRecordType::Meta, application_id).empty() && HasEntry(program_id, ContentRecordType::Program))
-     || (!ListEntriesFilter(TitleType::Update, ContentRecordType::Meta, GetUpdateTitleID(application_id)).empty() && HasEntry(GetUpdateTitleID(program_id), ContentRecordType::Program))) {
-        return application_id;
-    }
-    return std::nullopt;
-}
-
 PlaceholderCache::PlaceholderCache(VirtualDir dir_) : dir(std::move(dir_)) {}

 bool PlaceholderCache::Create(const NcaID& id, u64 size) const {
@@ -100,8 +100,6 @@ public:
        std::optional<TitleType> title_type = {}, std::optional<ContentRecordType> record_type = {},
        std::optional<u64> title_id = {}) const = 0;

-    [[nodiscard]] std::optional<u64> GetParentApplicationId(u64 program_id) const;
-
 protected:
    // A single instance of KeyManager to be used by GetEntry()
    Core::Crypto::KeyManager& keys = Core::Crypto::KeyManager::Instance();
@@ -9,7 +9,6 @@
 #include "common/logging.h"
 #include "common/uuid.h"
 #include "core/core.h"
-#include "core/file_sys/registered_cache.h"
 #include "core/file_sys/savedata_factory.h"
 #include "core/file_sys/vfs/vfs.h"

@@ -62,24 +61,17 @@ SaveDataFactory::SaveDataFactory(Core::System& system_, ProgramId program_id_,

 SaveDataFactory::~SaveDataFactory() = default;

-std::string SaveDataFactory::GetSaveDataPath(SaveDataSpaceId space, SaveDataType type, u64 title_id, u128 user_id, u64 save_id) const {
-    if (type == SaveDataType::Account || type == SaveDataType::Device) {
-        const auto requested_id = title_id != 0 ? title_id : program_id;
-        const auto parent_id = system.GetContentProvider().GetParentApplicationId(requested_id);
-        title_id = parent_id.value_or(requested_id);
-    }
-    return GetFullPath(program_id, dir, space, type, title_id, user_id, save_id);
-}
-
 VirtualDir SaveDataFactory::Create(SaveDataSpaceId space, const SaveDataAttribute& meta) const {
-    const auto save_directory = GetSaveDataPath(space, meta.type, meta.program_id, meta.user_id, meta.system_save_data_id);
+    const auto save_directory = GetFullPath(program_id, dir, space, meta.type, meta.program_id,
+                                            meta.user_id, meta.system_save_data_id);

    return dir->CreateDirectoryRelative(save_directory);
 }

 VirtualDir SaveDataFactory::Open(SaveDataSpaceId space, const SaveDataAttribute& meta) const {

-    const auto save_directory = GetSaveDataPath(space, meta.type, meta.program_id, meta.user_id, meta.system_save_data_id);
+    const auto save_directory = GetFullPath(program_id, dir, space, meta.type, meta.program_id,
+                                            meta.user_id, meta.system_save_data_id);

    auto out = dir->GetDirectoryRelative(save_directory);

@@ -162,7 +154,8 @@ std::string SaveDataFactory::GetUserGameSaveDataRoot(u128 user_id, bool future)

 SaveDataSize SaveDataFactory::ReadSaveDataSize(SaveDataType type, u64 title_id,
                                               u128 user_id) const {
-    const auto path = GetSaveDataPath(SaveDataSpaceId::User, type, title_id, user_id, 0);
+    const auto path =
+        GetFullPath(program_id, dir, SaveDataSpaceId::User, type, title_id, user_id, 0);
    const auto relative_dir = GetOrCreateDirectoryRelative(dir, path);

    const auto size_file = relative_dir->GetFile(GetSaveDataSizeFileName());
@@ -180,7 +173,8 @@ SaveDataSize SaveDataFactory::ReadSaveDataSize(SaveDataType type, u64 title_id,

 void SaveDataFactory::WriteSaveDataSize(SaveDataType type, u64 title_id, u128 user_id,
                                        SaveDataSize new_value) const {
-    const auto path = GetSaveDataPath(SaveDataSpaceId::User, type, title_id, user_id, 0);
+    const auto path =
+        GetFullPath(program_id, dir, SaveDataSpaceId::User, type, title_id, user_id, 0);
    const auto relative_dir = GetOrCreateDirectoryRelative(dir, path);

    const auto size_file = relative_dir->CreateFile(GetSaveDataSizeFileName());
@@ -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

@@ -50,7 +47,6 @@ public:
    void SetAutoCreate(bool state);

 private:
-    std::string GetSaveDataPath(SaveDataSpaceId space, SaveDataType type, u64 title_id, u128 user_id, u64 save_id) const;
    Core::System& system;
    ProgramId program_id;
    VirtualDir dir;
@@ -1,4 +1,4 @@
-// SPDX-FileCopyrightText: Copyright 2025 Eden Emulator Project
+// SPDX-FileCopyrightText: Copyright 2026 Eden Emulator Project
 // SPDX-License-Identifier: GPL-3.0-or-later

 // SPDX-FileCopyrightText: 2014 Citra Emulator Project
@@ -74,7 +74,7 @@ public:
    };

    /// Called from GPU thread when a frame is displayed.
-    virtual void OnFrameDisplayed() {}
+    virtual void OnFrameDisplayed([[maybe_unused]] u32 presented_frames) {}

    /**
     * Returns a GraphicsContext that the frontend provides to be used for rendering.
@@ -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.
@@ -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:
@@ -465,10 +465,6 @@ void KScheduler::ScheduleImplFiber(KernelCore& kernel) {
        // Check if we need scheduling. If we do, then we can't complete the switch and should
        // retry.
        if (m_state.needs_scheduling.load(std::memory_order_seq_cst)) {
-            // Some libc++ lazily init mutex
-            [[maybe_unused]] auto const can_lock = highest_priority_thread->m_context_guard.try_lock();
-            DEBUG_ASSERT(!can_lock);
-
            // Our switch failed.
            // We should unlock the thread context, and then retry.
            highest_priority_thread->m_context_guard.unlock();
@@ -500,10 +496,6 @@ void KScheduler::Unload(KernelCore& kernel, KThread* thread) {

    // Check if the thread is terminated by checking the DPC flags.
    if ((thread->GetStackParameters().dpc_flags & static_cast<u32>(DpcFlag::Terminated)) == 0) {
-        // Some libc++ lazily init mutex
-        [[maybe_unused]] auto const can_lock = thread->m_context_guard.try_lock();
-        DEBUG_ASSERT(!can_lock);
-
        // The thread isn't terminated, so we want to unlock it.
        thread->m_context_guard.unlock();
    }
@@ -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 2020 yuzu Emulator Project
@@ -12,6 +12,7 @@
 #include "common/atomic_ops.h"
 #include "common/common_funcs.h"
 #include "common/common_types.h"
+#include "common/spin_lock.h"

 namespace Kernel {

@@ -29,7 +30,7 @@ public:
    };

 public:
-    KSlabHeapImpl() = default;
+    constexpr KSlabHeapImpl() = default;

    void Initialize() {
        ASSERT(m_head == nullptr);
@@ -67,7 +68,7 @@ public:

 private:
    std::atomic<Node*> m_head{};
-    std::mutex m_lock;
+    Common::SpinLock m_lock;
 };

 } // namespace impl
@@ -19,6 +19,7 @@

 #include "common/intrusive_red_black_tree.h"
 #include "common/scratch_buffer.h"
+#include "common/spin_lock.h"
 #include "core/arm/arm_interface.h"
 #include "core/hle/kernel/k_affinity_mask.h"
 #include "core/hle/kernel/k_light_lock.h"
@@ -919,7 +920,7 @@ private:
    bool m_resource_limit_release_hint{};
    bool m_is_kernel_address_key{};
    StackParameters m_stack_parameters{};
-    std::mutex m_context_guard{};
+    Common::SpinLock m_context_guard{};

    // For emulation
    std::shared_ptr<Common::Fiber> m_host_context{};
@@ -23,12 +23,6 @@ constexpr std::size_t profile_username_size{32};
 using ProfileUsername = std::array<u8, profile_username_size>;
 using UserIDArray = std::array<Common::UUID, MAX_USERS>;

-// This is nn::account::Uid
-struct Uid {
-    std::array<u8, 0x10> unk0;
-};
-static_assert(sizeof(Uid) == 0x10);
-
 /// Contains extra data related to a user.
 /// TODO: RE this structure
 struct UserData {
@@ -92,13 +92,6 @@ public:
        }
    }

-    void RequestFocusStateChangedNotification(Kernel::KernelCore& kernel) {
-        if (m_focus_state_changed_notification_enabled) {
-            m_has_focus_state_changed = true;
-            this->SignalSystemEventIfNeeded(kernel);
-        }
-    }
-
    void OnOperationAndPerformanceModeChanged(Kernel::KernelCore& kernel);

 public:
@@ -347,22 +347,21 @@ Result IApplicationFunctions::NotifyRunning(Out<bool> out_became_running) {

 Result IApplicationFunctions::GetPseudoDeviceId(Out<Common::UUID> out_pseudo_device_id) {
    LOG_WARNING(Service_AM, "(stubbed)");
-    R_UNLESS(out_pseudo_device_id != nullptr, ResultUnknown);
+    R_UNLESS(out_pseudo_device_id, ResultUnknown);

    // This should be hashed with the device specific hash
    // for now this will do
    const auto res = FileSys::PatchManager::GetMetadataFromBaseOrUpdate(system, m_applet->program_id);
-    R_UNLESS(res.first != nullptr, ResultUnknown);
-    std::array<u8, EVP_MAX_MD_SIZE> hash;
+    u8 hash[EVP_MAX_MD_SIZE];
    unsigned int hash_len = 0;
    auto const seed = res.first->raw.seed_for_pseudo_device_id;
    EVP_MD_CTX *ctx = EVP_MD_CTX_new();
    auto const algorithm = EVP_sha1();
    EVP_DigestInit_ex(ctx, algorithm, nullptr);
    EVP_DigestUpdate(ctx, &seed, sizeof(seed));
-    EVP_DigestFinal_ex(ctx, hash.data(), &hash_len);
+    EVP_DigestFinal_ex(ctx, hash, &hash_len);
    EVP_MD_CTX_free(ctx);
-    *out_pseudo_device_id = Common::UUID::MakeRFC4122V5(std::span<u8, 16>{hash.begin(), hash.begin() + 16});
+    *out_pseudo_device_id = Common::UUID::MakeRFC4122V5(std::span<u8, 20>{hash, std::size(hash)});
    R_SUCCEED();
 }

@@ -164,15 +164,15 @@ Result ILibraryAppletAccessor::PushInData(SharedPointer<IStorage> storage) {
 Result ILibraryAppletAccessor::PopOutData(Out<SharedPointer<IStorage>> out_storage) {
    LOG_DEBUG(Service_AM, "called");

-    R_TRY(m_broker->GetOutData().Pop(system.Kernel(), out_storage.Get()));
    if (auto caller_applet = m_applet->caller_applet.lock(); caller_applet) {
-        std::scoped_lock lk{caller_applet->lock};
-        const bool focus_state_changed = caller_applet->lifecycle_manager.UpdateRequestedFocusState();
-        const bool is_front_app = m_applet->frontend && caller_applet->lifecycle_manager.IsApplication();
-        if (focus_state_changed) caller_applet->lifecycle_manager.SignalSystemEventIfNeeded(system.Kernel());
-        else if (is_front_app) caller_applet->lifecycle_manager.RequestFocusStateChangedNotification(system.Kernel());
+        caller_applet->lifecycle_manager.GetSystemEvent().Signal(system.Kernel());
+        caller_applet->lifecycle_manager.RequestResumeNotification();
+        caller_applet->lifecycle_manager.GetSystemEvent().Clear(system.Kernel());
+        caller_applet->lifecycle_manager.UpdateRequestedFocusState();
    }

+    R_TRY(m_broker->GetOutData().Pop(system.Kernel(), out_storage.Get()));
+
    if (m_applet->applet_id == AppletId::ProfileSelect && *out_storage) {
        auto impl = (*out_storage)->GetImpl();

@@ -154,9 +154,6 @@ FSP_SRV::FSP_SRV(Core::System& system_)
        {720, nullptr, "AbandonAccessFailure"},
        {800, nullptr, "GetAndClearFileSystemProxyErrorInfo"},
        {810, nullptr, "RegisterProgramIndexMapInfo"},
-        {820, nullptr, "GetContentStorageInfoIndex"},
-        {830, nullptr, "EncryptStreamPlaySaveData"},
-        {831, nullptr, "DecryptStreamPlaySaveData"},
        {1000, nullptr, "SetBisRootForHost"},
        {1001, nullptr, "SetSaveDataSize"},
        {1002, nullptr, "SetSaveDataRootPath"},
@@ -121,7 +121,7 @@ IHidSystemServer::IHidSystemServer(Core::System& system_, std::shared_ptr<Resour
        {547, nullptr, "GetAllowedBluetoothLinksCount"},
        {548, &IHidSystemServer::GetRegisteredDevices, "GetRegisteredDevices"},
        {549, nullptr, "GetConnectableRegisteredDevices"},
-        {551, &IHidSystemServer::GetRegisteredDevices, "GetRegisteredDevicesForControllerSupport"}, //20.0.0+ //mocked via 548 for Diablo 3 (at least)
+        {551, nullptr, "GetRegisteredDevicesForControllerSupport"}, //20.0.0+
        {700, nullptr, "ActivateUniquePad"},
        {702, &IHidSystemServer::AcquireUniquePadConnectionEventHandle, "AcquireUniquePadConnectionEventHandle"},
        {703, &IHidSystemServer::GetUniquePadIds, "GetUniquePadIds"},
@@ -758,7 +758,7 @@ void IHidSystemServer::AcquireDeviceRegisteredEventForControllerSupport(HLEReque
 }

 void IHidSystemServer::GetRegisteredDevices(HLERequestContext& ctx) {
-    LOG_WARNING(Service_HID, "(STUBBED) called, command={}", ctx.GetCommand()); //548 or 551
+    LOG_WARNING(Service_HID, "(STUBBED) called");

    struct RegisterData {
        std::array<u8, 0x68> data;
@@ -22,7 +22,6 @@

 namespace IPC {

-constexpr Result ResultNotSupported{ErrorModule::HIPC, 1};
 constexpr Result ResultSessionClosed{ErrorModule::HIPC, 301};

 struct ResponseBuilder {
@@ -8,9 +8,9 @@
 #include <map>
 #include <span>
 #include <boost/icl/interval_set.hpp>
-#include "dynarmic/interface/A64/a64.h"
-#include "dynarmic/interface/A64/config.h"
-#include "dynarmic/interface/code_page.h"
+#include <dynarmic/interface/A64/a64.h>
+#include <dynarmic/interface/A64/config.h>
+#include <dynarmic/interface/code_page.h>

 #include "common/alignment.h"
 #include "common/common_funcs.h"
@@ -6,16 +6,10 @@

 #include "common/string_util.h"
 #include "core/core.h"
-#include "core/hle/kernel/k_client_session.h"
-#include "core/hle/result.h"
-#include "core/hle/service/acc/profile_manager.h"
-#include "core/hle/service/cmif_types.h"
-#include "core/hle/service/cmif_serialization.h"
 #include "core/hle/service/ipc_helpers.h"
 #include "core/hle/service/ngc/ngc.h"
 #include "core/hle/service/server_manager.h"
 #include "core/hle/service/service.h"
-#include "frontend_common/firmware_manager.h"

 namespace Service::NGC {

@@ -172,123 +166,12 @@ public:
    }
 };

-struct SaveDataHandle {
-    u64 unk0;
-};
-static_assert(sizeof(SaveDataHandle) == 0x08);
-
-class IUserShimScopedObject final : public ServiceFramework<IUserShimScopedObject> {
-public:
-    explicit IUserShimScopedObject(Core::System& system_) : ServiceFramework(system_, "IUserShimScopedObject") {
-        // clang-format off
-        static const FunctionInfo functions[] = {
-            {450, nullptr, "InitializeForSaveData"},
-            {451, nullptr, "FinalizeForSaveData"},
-            {452, D<&IUserShimScopedObject::OpenSaveData>, "OpenSaveData"},
-            {453, nullptr, "CloseSaveData"},
-            {454, D<&IUserShimScopedObject::ReadSaveSlot>, "ReadSaveSlot"},
-            {455, D<&IUserShimScopedObject::WriteSaveSlot>, "WriteSaveSlot"},
-            {456, nullptr, "FlushSaveSlot"},
-            {457, nullptr, "CommitSaveData"},
-        };
-        // clang-format on
-        RegisterHandlers(functions);
-    }
-
-    Result OpenSaveData(Account::Uid unk0, Out<SaveDataHandle> unk1) {
-        LOG_WARNING(Service_NGC, "stubbed");
-        R_THROW(IPC::ResultNotSupported);
-    }
-
-    Result ReadSaveSlot(s32 offset, SaveDataHandle handle, OutBuffer<BufferAttr_HipcAutoSelect> out_data, Out<u32> out_size) {
-        LOG_WARNING(Service_NGC, "stubbed");
-        R_THROW(IPC::ResultNotSupported);
-    }
-
-    Result WriteSaveSlot(s32 offset, SaveDataHandle handle, InBuffer<BufferAttr_HipcAutoSelect> out_data) {
-        LOG_WARNING(Service_NGC, "stubbed");
-        // to implement
-        R_SUCCEED();
-    }
-};
-
-class IUserService final : public ServiceFramework<IUserService> {
-public:
-    explicit IUserService(Core::System& system_) : ServiceFramework(system_, "stpl:u") {
-        // clang-format off
-        static const FunctionInfo functions[] = {
-            {0 , D<&IUserService::Cmd0>, "Cmd0"},
-        };
-        // clang-format on
-        RegisterHandlers(functions);
-    }
-    Result Cmd0(u32 unk0, OutInterface<IUserShimScopedObject> out_interface) {
-        LOG_WARNING(Service_NGC, "stubbed");
-        *out_interface = std::make_shared<IUserShimScopedObject>(system);
-        R_SUCCEED();
-    }
-};
-
-class ISystemShimScopedObject final : public ServiceFramework<ISystemShimScopedObject> {
-public:
-    explicit ISystemShimScopedObject(Core::System& system_) : ServiceFramework(system_, "ISystemShimScopedObject") {
-        // clang-format off
-        static const FunctionInfo functions[] = {
-            {106, nullptr, "Cmd106"},
-            {107, nullptr, "Cmd107"},
-            {108, D<&ISystemShimScopedObject::Cmd108>, "Cmd108"},
-            {207, nullptr, "Cmd207"},
-            {208, D<&ISystemShimScopedObject::Cmd208>, "Cmd208"},
-            {209, nullptr, "Cmd209"},
-            {210, nullptr, "Cmd210"},
-            {211, nullptr, "Cmd211"},
-            {212, nullptr, "Cmd212"},
-        };
-        // clang-format on
-        RegisterHandlers(functions);
-    }
-
-    Result Cmd108() {
-        LOG_WARNING(Service_NGC, "stubbed");
-        R_THROW(IPC::ResultNotSupported);
-    }
-
-    Result Cmd208(Out<std::array<u8, 0x20>> unk0) {
-        LOG_WARNING(Service_NGC, "stubbed");
-        R_THROW(IPC::ResultNotSupported);
-    }
-};
-
-class ISystemService final : public ServiceFramework<ISystemService> {
-public:
-    explicit ISystemService(Core::System& system_) : ServiceFramework(system_, "stpl:sys") {
-        // clang-format off
-        static const FunctionInfo functions[] = {
-            {0 , D<&ISystemService::Cmd0>, "Cmd0"},
-        };
-        // clang-format on
-        RegisterHandlers(functions);
-    }
-    Result Cmd0(OutInterface<ISystemShimScopedObject> out_interface) {
-        LOG_WARNING(Service_NGC, "stubbed");
-        *out_interface = std::make_shared<ISystemShimScopedObject>(system);
-        R_SUCCEED();
-    }
-};
-
 void LoopProcess(Core::System& system) {
    auto server_manager = std::make_unique<ServerManager>(system);

    server_manager->RegisterNamedService("ngct:u", std::make_shared<IService>(system), 4);
    server_manager->RegisterNamedService("ngct:s", std::make_shared<IServiceWithManagementApi>(system), 4);
    server_manager->RegisterNamedService("ngc:u", std::make_shared<NgcServiceImpl>(system), 4);
-
-    // +23.0.0
-    if (FirmwareManager::GetFirmwareVersion(system).first.major >= 23) {
-        server_manager->RegisterNamedService("stpl:u", std::make_shared<IUserService>(system), 4);
-        server_manager->RegisterNamedService("stpl:sys", std::make_shared<ISystemService>(system), 4);
-    }
-
    ServerManager::RunServer(std::move(server_manager));
 }

@@ -7,7 +7,7 @@
 #pragma once

 #include "core/hle/service/cmif_types.h"
-#include "core/hle/service/ns/async_result.h"
+#include "core/hle/service/ns/i_async_result.h"
 #include "core/hle/service/ns/language.h"
 #include "core/hle/service/ns/ns_types.h"
 #include "core/hle/service/os/event.h"
@@ -2,7 +2,7 @@
 // SPDX-License-Identifier: GPL-3.0-or-later

 #include "core/hle/service/cmif_serialization.h"
-#include "core/hle/service/ns/async_result.h"
+#include "core/hle/service/ns/i_async_result.h"

 #include <cstring>

@@ -32,4 +32,4 @@ Result IAsyncResult::Cancel() {
    R_SUCCEED();
 }

-} // namespace Service::NS
+} // namespace Service::NS
@@ -311,30 +311,27 @@ void IReadOnlyApplicationControlDataInterface::ListApplicationIcon(HLERequestCon
        // u64 - app count
        memory.WriteBlock(t_mem_address + out_length, &app_count, sizeof(u64));
        out_length += sizeof(u64);
-        ASSERT(out_length <= t_mem->GetSize());
        // [list of u64] - size of icons
        for (size_t i = 0; i < app_count; ++i) {
            const u64 app_id = app_ids_buffer[i];
            const FileSys::PatchManager pm{app_id, system.GetFileSystemController(), system.GetContentProvider()};
-            if (const auto control = pm.GetControlMetadata(); control.second) {
-                u64 full_size = control.second->GetSize();
-                memory.WriteBlock(t_mem_address + out_length, &full_size, sizeof(u64));
-            }
+            const auto control = pm.GetControlMetadata();
+            u64 full_size = control.second->GetSize();
+            memory.WriteBlock(t_mem_address + out_length, &full_size, sizeof(u64));
            out_length += sizeof(u64);
-            ASSERT(out_length <= t_mem->GetSize());
        }
        // [list of raw icon data]
+        std::vector<u8> full_icon_data;
        for (size_t i = 0; i < app_count; ++i) {
            const u64 app_id = app_ids_buffer[i];
            const FileSys::PatchManager pm{app_id, system.GetFileSystemController(), system.GetContentProvider()};
-            if (const auto control = pm.GetControlMetadata(); control.second) {
-                if (auto const full_size = control.second->GetSize(); full_size > 0) {
-                    std::vector<u8> full_icon_data(full_size);
-                    control.second->Read(full_icon_data.data(), full_size, 0);
-                    memory.WriteBlock(t_mem_address + out_length, full_icon_data.data(), full_size);
-                    out_length += full_size;
-                    ASSERT(out_length <= t_mem->GetSize());
-                }
+            const auto control = pm.GetControlMetadata();
+            auto const full_size = control.second->GetSize();
+            if (full_size > 0) {
+                full_icon_data.resize(full_size);
+                control.second->Read(full_icon_data.data(), full_size, 0);
+                memory.WriteBlock(t_mem_address + out_length, full_icon_data.data(), full_size);
+                out_length += full_size;
            }
        }
    }
@@ -348,12 +345,6 @@ void IReadOnlyApplicationControlDataInterface::ListApplicationIcon(HLERequestCon
 void IReadOnlyApplicationControlDataInterface::ListApplicationTitle(HLERequestContext& ctx) {
    const auto app_ids_buffer = ctx.ReadBuffer();
    const size_t app_count = app_ids_buffer.size() / sizeof(u64);
-
-    std::vector<u64> application_ids(app_count);
-    if (app_count > 0) {
-        std::memcpy(application_ids.data(), app_ids_buffer.data(), app_count * sizeof(u64));
-    }
-
    auto t_mem_obj = ctx.GetObjectFromHandle<Kernel::KTransferMemory>(ctx.GetCopyHandle(0));
    auto* t_mem = t_mem_obj.GetPointerUnsafe();
    constexpr size_t title_entry_size = sizeof(FileSys::LanguageEntry);
@@ -363,9 +354,8 @@ void IReadOnlyApplicationControlDataInterface::ListApplicationTitle(HLERequestCo
        auto& memory = system.ApplicationMemory();
        const auto t_mem_address = t_mem->GetSourceAddress();
        for (size_t i = 0; i < app_count; ++i) {
-            const u64 app_id = application_ids[i];
-            const FileSys::PatchManager pm{app_id, system.GetFileSystemController(),
-                                           system.GetContentProvider()};
+            const u64 app_id = app_ids_buffer[i];
+            const FileSys::PatchManager pm{app_id, system.GetFileSystemController(), system.GetContentProvider()};
            const auto control = pm.GetControlMetadata();
            FileSys::LanguageEntry entry{};
            if (control.first != nullptr) {
--- a/Show More
+++ b/Show More
Author	SHA1	Message	Date
CamilleLaVey	9c18bd44e7	Fix licenses	2026-10-05 18:44:01 -04:00
CamilleLaVey	013deb4f3f	Revert "Address turnip bug with depths"	2026-10-02 03:59:24 -04:00
CamilleLaVey	0b7d216a09	Address some regressions with unswizzle changes + barriers reductions	2026-10-02 01:41:19 -04:00
CamilleLaVey	b8478a570b	Experiments with TS on turnip	2026-10-02 00:47:24 -04:00
CamilleLaVey	9d620bba88	Address son sync issues	2026-10-01 23:56:07 -04:00
CamilleLaVey	165a1d1da1	Experiments with gpu stalls per fence wait	2026-10-01 22:52:42 -04:00
CamilleLaVey	5c7520f572	Address some regressions with UMA	2026-10-01 20:56:23 -04:00
CamilleLaVey	7db354a25a	Framerate display corrections	2026-10-01 20:27:22 -04:00
CamilleLaVey	f759409cc2	Address turnip bug with depths	2026-10-01 19:30:50 -04:00
CamilleLaVey	e11ea7f008	Port UMA part 5.3 (NCE EXT)	2026-10-01 16:52:15 -04:00
CamilleLaVey	73cac64037	Port UMA part 5.2	2026-10-01 16:26:33 -04:00
CamilleLaVey	fb174abf04	Port UMA part 5.1	2026-10-01 14:07:31 -04:00
CamilleLaVey	1b764efad9	Port UMA part 4.1	2026-10-01 12:23:20 -04:00
CamilleLaVey	488dcefec5	Port UMA part 4	2026-10-01 02:49:53 -04:00
CamilleLaVey	df36685c9b	Port UMA part 3	2026-10-01 02:01:24 -04:00
CamilleLaVey	9cc9a1fc35	Port UMA part 2	2026-10-01 01:09:01 -04:00
CamilleLaVey	0a88e761eb	Port UMA part 1	2026-10-01 00:19:46 -04:00
CamilleLaVey	451b8eb80c	Some adjustments to EDS	2026-09-30 23:09:44 -04:00
CamilleLaVey	e4f74863d2	Overlap barriers on window adapt filter + lsfg dedup	2026-09-30 20:58:40 -04:00
CamilleLaVey	51584f5a63	1st phase of framepacer rework	2026-09-30 17:54:48 -04:00
CamilleLaVey	148a7b24cd	Another intent to fix build	2026-09-30 17:27:43 -04:00
CamilleLaVey	940568bb33	fix lsfg build desktop + adjustments	2026-09-30 15:06:43 -04:00
CamilleLaVey	5714c3e477	Experiments with polishing LSFG impl	2026-09-30 14:14:57 -04:00
CamilleLaVey	bad10039ae	Address some corrections towards MSAA discard/enable removal	2026-09-30 13:03:09 -04:00
CamilleLaVey	dd1c024efc	Some corrections towards HCR + Discard MSAA	2026-09-30 12:05:15 -04:00
CamilleLaVey	4f5fc58b6e	Use copy commands 2	2026-09-30 03:00:07 -04:00
CamilleLaVey	efba499fd3	Remove some dependencies to framebuffer and renderpass	2026-09-30 02:47:44 -04:00
CamilleLaVey	41d8da1612	Remove deferred clears	2026-09-30 00:47:14 -04:00
CamilleLaVey	63fc150635	Addresing some problems with TFB and DR	2026-09-30 00:22:27 -04:00
CamilleLaVey	92cbcb8fe5	Revert "God has forsaken me to BDA"	2026-09-29 23:54:39 -04:00
CamilleLaVey	8040f06c87	Revert "quick test to add pointer range management on buffer binding from indirect draws"	2026-09-29 23:54:21 -04:00
CamilleLaVey	bdc890f647	quick test to add pointer range management on buffer binding from indirect draws	2026-09-29 23:17:06 -04:00
CamilleLaVey	08917afe0e	God has forsaken me to BDA	2026-09-29 21:57:46 -04:00
CamilleLaVey	213d9fb4a7	Just force reads on 8/16bits	2026-09-29 17:46:53 -04:00
CamilleLaVey	2d6f28c50e	Some work around CAS	2026-09-29 16:13:50 -04:00
CamilleLaVey	ef7cde0c2b	Barrier feedback loops toggle android	2026-09-27 02:48:26 -04:00
CamilleLaVey	2d5c79c9f3	Address some bugs with load none vs lrz	2026-09-27 02:44:37 -04:00
CamilleLaVey	14b6160fcd	first try on dynamic rendering unused attachments	2026-09-27 01:15:26 -04:00
CamilleLaVey	dfe0b7e7c7	A quick test on global memory cbuf tracker	2026-09-26 23:23:38 -04:00
CamilleLaVey	b8d9f44421	Another change on GS	2026-09-26 21:38:39 -04:00
CamilleLaVey	7d61946b7c	Tfb fix x62132321	2026-09-26 21:33:17 -04:00
CamilleLaVey	d8fc94093d	More work on GS	2026-09-26 21:14:21 -04:00
CamilleLaVey	4ce91d18b8	Avoid constant calls to fixed pipelines	2026-09-26 18:50:48 -04:00
CamilleLaVey	f6cd6128ff	Experiment on tfb draws again	2026-09-26 18:28:32 -04:00
CamilleLaVey	f3ce6acf53	Another intent on load store op none impl	2026-09-26 17:21:32 -04:00
CamilleLaVey	656370e70a	Upload only images needed	2026-09-26 16:43:23 -04:00
CamilleLaVey	16483a27ed	Remove PostCopyBarrier on buffers	2026-09-26 15:43:34 -04:00
CamilleLaVey	d6f69e14dc	experiment with depth ranges	2026-09-26 14:59:01 -04:00
CamilleLaVey	1a65725a35	Fix licenses	2026-09-26 13:37:49 -04:00
CamilleLaVey	381d97639f	Rework dynamic rendering impl	2026-09-26 13:30:28 -04:00
CamilleLaVey	be4bcbee85	Merge pull request '[arm, vulkan] 5th Vulkan Global Maintenance + NCE maintenance' (#1 ) from cleanup-vk into master Reviewed-on: https://git.eden-emu.dev/CamilleLaVey/Eden/pulls/1	2026-09-26 18:57:15 +02:00
CamilleLaVey	49c3a79fa8	Keep adjusting memory barriers to be more explicit	2026-09-26 12:45:27 -04:00
CamilleLaVey	9d4355064b	Another try to make barriers more explicit	2026-09-26 12:45:27 -04:00
CamilleLaVey	d832f5e156	Re-do geometry compaction pass	2026-09-26 12:45:27 -04:00
CamilleLaVey	5dc91d7e25	Another take on the qcom/turnip missing handling for geometry stages	2026-09-26 12:45:27 -04:00
CamilleLaVey	ccbaa75e5e	Adjust cuts on depth draws	2026-09-26 12:45:27 -04:00
CamilleLaVey	63ce0a0527	Fix build	2026-09-26 12:45:26 -04:00
CamilleLaVey	d2d2220b24	Address some regressions with TFB + SSBO's due to WFI removal	2026-09-26 12:45:26 -04:00
CamilleLaVey	bc121efc19	Corrections on the barriers for compute dispatch	2026-09-26 12:45:26 -04:00
CamilleLaVey	bcb3fbcf12	Remove the binding/rt image cache	2026-09-26 12:45:26 -04:00
CamilleLaVey	ab11282def	Keep adjusting the barriers until qcom is finally fixed	2026-09-26 12:45:26 -04:00
CamilleLaVey	a5c5966cd8	Keep adjusting barriers	2026-09-26 12:45:26 -04:00
CamilleLaVey	7a007fbf48	Another intent to fix qcom driver bugs with render	2026-09-26 12:45:26 -04:00
CamilleLaVey	3f3240caed	Fix android build	2026-09-26 12:45:26 -04:00
CamilleLaVey	19298b713b	Removal of WFI + address device creation crash on A6xx	2026-09-26 12:45:26 -04:00
CamilleLaVey	10a21bf246	Another try on sparse binding	2026-09-26 12:45:26 -04:00
CamilleLaVey	108c991431	Experiment on descriptors payloads	2026-09-26 12:45:26 -04:00
CamilleLaVey	98ad2d5e4c	Quick tests on payloads	2026-09-26 12:45:26 -04:00
CamilleLaVey	3ff00afd59	Some other dead code removal	2026-09-26 12:45:26 -04:00
CamilleLaVey	fd8da678df	Re-adjust dispatch draw + masks	2026-09-26 12:45:26 -04:00
CamilleLaVey	f71a80671c	Remove final references to sync1	2026-09-26 12:45:26 -04:00
CamilleLaVey	6ffd65adaf	another intent to remove sync1 and replace it with sync2 completely	2026-09-26 12:45:26 -04:00
CamilleLaVey	e6fe763afa	Correction on the descriptor pool	2026-09-26 12:45:26 -04:00
CamilleLaVey	fa9e069907	Adjust buffer stream size + reduce descriptor loads	2026-09-26 12:45:26 -04:00
CamilleLaVey	3ab215fd30	experiment to address some TPIDR_EL0 stalls	2026-09-26 12:45:26 -04:00
CamilleLaVey	8d8e67cd7f	Just an small experiment to simply interpreter	2026-09-26 12:45:26 -04:00
CamilleLaVey	36b06254b4	Fix licenses	2026-09-26 12:45:26 -04:00
CamilleLaVey	ffb75c2b68	Revert "[common/core/dynarmic] Optimize page table allocations (#4219 )"	2026-09-26 12:43:32 -04:00
CamilleLaVey	d82a9c3ba5	Adjust stagging buffer ring	2026-09-26 12:43:32 -04:00
CamilleLaVey	b7b90c183f	Add checks on texel buffer alignments	2026-09-26 12:43:32 -04:00
CamilleLaVey	1fbb1a0499	Revert QCOM spoof	2026-09-26 12:43:32 -04:00
CamilleLaVey	09371eab60	Remove dead code om VMA	2026-09-26 12:43:32 -04:00
CamilleLaVey	8a8c7f4c06	addresing MHR regression	2026-09-26 12:43:31 -04:00
CamilleLaVey	3a22f908a3	Re-add pitch 2D pass	2026-09-26 12:43:31 -04:00
CamilleLaVey	0dd78bbd07	Re-add unswizzle 3D pass	2026-09-26 12:43:31 -04:00
CamilleLaVey	20d3a4370a	Remove the dependency test + remove color texture filter per shasder storage view	2026-09-26 12:43:31 -04:00
CamilleLaVey	1529e30435	quick tests with dependency flags per attachment stage	2026-09-26 12:43:31 -04:00
CamilleLaVey	51d64c298d	Some reviews on storage views	2026-09-26 12:43:31 -04:00
CamilleLaVey	3cabafc06a	Re-add unswizzle linear 2D to the pass	2026-09-26 12:43:31 -04:00
CamilleLaVey	e9436f8094	A test to remove uneeded Finish()	2026-09-26 12:43:31 -04:00
CamilleLaVey	228a400752	Quick change to previous GC adjustment	2026-09-26 12:43:31 -04:00
CamilleLaVey	08741c919a	Some changes to GC	2026-09-26 12:43:31 -04:00
CamilleLaVey	17adc28b2c	Remove some dead accesors	2026-09-26 12:43:31 -04:00
CamilleLaVey	10528f1ceb	Revert some previous changes partially + maintenance5 changes	2026-09-26 12:43:31 -04:00
CamilleLaVey	377478cd46	A quick topology test	2026-09-26 12:43:31 -04:00
CamilleLaVey	f92e326e17	Adjustments from the previous change for pipelines	2026-09-26 12:43:30 -04:00
CamilleLaVey	b10212fe94	Let's try to change a bit the redundancy	2026-09-26 12:43:30 -04:00
CamilleLaVey	521d3922f5	Fix build	2026-09-26 12:43:30 -04:00
CamilleLaVey	8cdf552c28	Some adjustments to vertex attributes	2026-09-26 12:43:30 -04:00
CamilleLaVey	d633c43aae	Remove static pipelines	2026-09-26 12:43:30 -04:00
CamilleLaVey	27bcaba75c	first intent to pinpoint performance decrease on virtual buffer table + multi-range	2026-09-26 12:43:30 -04:00
CamilleLaVey	64a307c6dc	Port some changes from Lizzie's optimization with some exceptions	2026-09-26 12:43:30 -04:00
CamilleLaVey	691b63e79b	Quick adjustments on overlapped buffers	2026-09-26 12:43:30 -04:00
CamilleLaVey	f955dfedcb	remove async vulkan presentation toggle android	2026-09-26 12:43:30 -04:00
CamilleLaVey	86f826c313	Remove astc recompression method	2026-09-26 12:43:30 -04:00
CamilleLaVey	052a04e610	Correcting some bugs on the vulkan async presentation thread	2026-09-26 12:43:30 -04:00
CamilleLaVey	bd82351d73	First try to align GOB's	2026-09-26 12:43:30 -04:00
CamilleLaVey	a152596f29	Chinga su madre que perramente molesto es este puto juego	2026-09-26 12:43:30 -04:00
CamilleLaVey	40036eb0f8	Remove the thread opt for unswizzle images	2026-09-26 12:43:30 -04:00
CamilleLaVey	0cc76f1f22	First intent to relax the pressure on the gpu thread for unswizzling images	2026-09-26 12:43:30 -04:00
CamilleLaVey	b016c88768	Remove the unswizzle path on the extra shaders	2026-09-26 12:43:30 -04:00
CamilleLaVey	6221bd2c43	Reduce accelerated unswizzle path	2026-09-26 12:43:30 -04:00
CamilleLaVey	facee08b5e	More tests to find out the texture corruption on previous unswizzle changes	2026-09-26 12:43:30 -04:00
CamilleLaVey	43622f463d	A test for a corrupted unswizzled textures	2026-09-26 12:43:30 -04:00
CamilleLaVey	9bedcf6202	Keep working on ASTC	2026-09-26 12:43:29 -04:00
CamilleLaVey	66a25a3d79	Some unvalid checks on astc decoder	2026-09-26 12:43:29 -04:00
CamilleLaVey	b24c3d7226	Keep refining astc decoding math	2026-09-26 12:43:29 -04:00
CamilleLaVey	26031c0940	Fixes on the astc decoder	2026-09-26 12:43:29 -04:00
CamilleLaVey	930b64858e	Fix build	2026-09-26 12:43:29 -04:00
CamilleLaVey	b1e512c152	Some cleanups	2026-09-15 21:10:36 -04:00