TEST

Experiments on window mirroring + add vertex/index to the virtual page
another try to add compute shaders to the uma path
2026-10-10 06:56:49 +00:00 · 2026-09-15 05:02:32 -04:00 · 2026-09-15 03:02:55 -04:00 · 2026-09-14 22:04:56 -04:00 · 2026-09-14 20:15:13 -04:00 · 2026-09-14 20:15:13 -04:00
161 changed files with 4877 additions and 5170 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="//"
 			;;
 		*)
@@ -0,0 +1,13 @@
+diff --git a/libs/cobalt/include/boost/cobalt/concepts.hpp b/libs/cobalt/include/boost/cobalt/concepts.hpp
+index d49f2ec..a9bdb80 100644
+--- a/libs/cobalt/include/boost/cobalt/concepts.hpp
+++ b/libs/cobalt/include/boost/cobalt/concepts.hpp
+@@ -62,7 +62,7 @@ struct enable_awaitables
+ template <typename T>
+ concept with_get_executor = requires (T& t)
+ {
+-  {t.get_executor()} -> asio::execution::executor;
+  t.get_executor();
+ };
+ 
+ 
@@ -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")
@@ -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)
@@ -449,9 +417,12 @@ AddJsonPackage(boost)
 set(BOOST_NO_HEADERS ${Boost_ADDED})

 if (Boost_ADDED)
-    add_compile_definitions(YUZU_BOOST_v1)
+    if (MSVC OR ANDROID)
+        add_compile_definitions(YUZU_BOOST_v1)
+    endif()
+
    if (NOT MSVC OR CXX_CLANG)
-        # solaris sucks
+        # boost sucks
        if (SOLARIS)
            add_compile_options($<$<COMPILE_LANGUAGE:C,CXX>:-pthreads>)
        endif()
@@ -460,7 +431,8 @@ if (Boost_ADDED)
        target_compile_options(boost_icl INTERFACE $<$<COMPILE_LANGUAGE:C,CXX>:-Wno-shadow>)
        target_compile_options(boost_asio INTERFACE
            $<$<COMPILE_LANGUAGE:C,CXX>:-Wno-conversion>
-            $<$<COMPILE_LANGUAGE:C,CXX>:-Wno-implicit-fallthrough>)
+            $<$<COMPILE_LANGUAGE:C,CXX>:-Wno-implicit-fallthrough>
+        )
    endif()
 endif()

@@ -541,13 +513,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,19 +6,22 @@
        "version": "v0.19.0"
    },
    "boost": {
-        "artifact": "boost-%VERSION%.tar.zst",
+        "artifact": "%VERSION%-cmake.tar.xz",
        "find_args": "CONFIG OPTIONAL_COMPONENTS headers context system fiber filesystem",
-        "hash": "681d97be4386767662e230b2e7c9754d45e709cc5db4e747c23c27d1f5b0e87770bdf19b0bc44dcb0e8349324887bbb8fffb432098f4d0ce74a5043021a90afc",
+        "hash": "6ae6e94664fe7f2fb01976b59b276ac5df8085c7503fa829d810fbfe495960cfec44fa2c36e2cb23480bc19c956ed199d4952b02639a00a6c07625d4e7130c2d",
        "min_version": "1.57",
        "package": "Boost",
-        "repo": "eden-emulator/ext-boost",
-        "version": "1.92.0"
+        "patches": [
+            "0001-clang-cl.patch"
+        ],
+        "repo": "boostorg/boost",
+        "version": "boost-1.90.0"
    },
    "boost_headers": {
        "bundled": true,
-        "hash": "c5fa2cd72f6e6666b7963b97bc359c75284b8fb540c30f3629a028b85270c9bc66c8a051383964f2bd4c1e005a4691593d15696e7ef39ea87cf6cff9e5691fb2",
+        "hash": "4ef845775e2277a8104ded6ddf749aa262ce52cf8438042869a048f9a0156dd772fbbcfa74efa1378fecef339b7286f6fe4b4feb5c45d49966b35d08e3e83507",
        "repo": "boostorg/headers",
-        "version": "boost-1.91.0"
+        "version": "boost-1.90.0"
    },
    "catch2": {
        "hash": "7eea385d79d88a5690cde131fe7ccda97d5c54ea09d6f515000d7bf07c828809d61c1ac99912c1ee507cf933f61c1c47ecdcc45df7850ffa82714034b0fccf35",
@@ -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)
@@ -27,6 +27,7 @@ enum class BooleanSetting(override val key: String) : AbstractBooleanSetting {
    RENDERER_ASYNCHRONOUS_GPU_EMULATION("use_asynchronous_gpu_emulation"),
    RENDERER_ASYNC_PRESENTATION("async_presentation"),
    RENDERER_ASYNCHRONOUS_SHADERS("use_asynchronous_shaders"),
+    RENDERER_UNIFIED_MEMORY("use_unified_memory"),
    RENDERER_REACTIVE_FLUSHING("use_reactive_flushing"),
    ENABLE_BUFFER_HISTORY("enable_buffer_history"),
    USE_OPTIMIZED_VERTEX_BUFFERS("use_optimized_vertex_buffers"),
@@ -785,6 +785,13 @@ abstract class SettingsItem(
                    descriptionId = R.string.renderer_asynchronous_shaders_description
                )
            )
+            put(
+                SwitchSetting(
+                    BooleanSetting.RENDERER_UNIFIED_MEMORY,
+                    titleId = R.string.renderer_unified_memory,
+                    descriptionId = R.string.renderer_unified_memory_description
+                )
+            )
            put(
                SingleChoiceSetting(
                    IntSetting.FAST_GPU_TIME,
@@ -558,6 +558,7 @@ class SettingsFragmentPresenter(
            add(BooleanSetting.FIX_BLOOM_EFFECTS.key)
            add(BooleanSetting.EMULATE_BGR565.key)
            add(BooleanSetting.RENDERER_ASYNCHRONOUS_SHADERS.key)
+            add(BooleanSetting.RENDERER_UNIFIED_MEMORY.key)
            add(IntSetting.ANDROID_PIPELINE_WORKERS.key)
            add(BooleanSetting.RENDERER_ASYNCHRONOUS_GPU_EMULATION.key)
            add(BooleanSetting.RENDERER_ASYNC_PRESENTATION.key)
@@ -605,6 +605,8 @@
    <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="renderer_unified_memory">Unified memory access</string>
+    <string name="renderer_unified_memory_description">Allows GPU write buffer readbacks directly into guest memory, skipping the CPU staging copy.</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>
@@ -110,6 +110,7 @@ add_library(
    socket_types.h
    sparse_large_vector.cpp
    sparse_large_vector.h
+    spin_lock.h
    stb.cpp
    stb.h
    steady_clock.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;
    }
 }
@@ -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);
@@ -4,34 +4,17 @@
 // SPDX-FileCopyrightText: Copyright 2023 yuzu Emulator Project
 // SPDX-License-Identifier: GPL-2.0-or-later

-#include <fstream>
 #include "common/heap_tracker.h"
 #include "common/logging.h"
+#include "common/memory_detect.h"
 #include "common/assert.h"

 namespace Common {

-namespace {
-
-s64 GetMaxPermissibleResidentMapCount() {
-    // Default value.
-    s64 value = 65530;
-
-    // Try to read how many mappings we can make.
-    std::ifstream s("/proc/sys/vm/max_map_count");
-    s >> value;
-
-    // Print, for debug.
-    LOG_INFO(HW_Memory, "Current maximum map count: {}", value);
-
-    // Allow 20000 maps for other code and to account for split inaccuracy.
-    return std::max<s64>(value - 20000, 0);
-}
-
-} // namespace
-
 HeapTracker::HeapTracker(Common::HostMemory& buffer)
-    : m_buffer(buffer), m_max_resident_map_count(GetMaxPermissibleResidentMapCount()) {}
+    : m_buffer(buffer),
+      m_has_hardware_buffer_backing(!buffer.BackingHardwareBuffers().empty()),
+      m_max_resident_map_count(static_cast<s64>(GetPermissibleMapCount())) {}
 HeapTracker::~HeapTracker() = default;

 void HeapTracker::Map(size_t virtual_offset, size_t host_offset, size_t length,
@@ -85,7 +68,8 @@ void HeapTracker::Unmap(size_t virtual_offset, size_t size, bool is_separate_hea

            // If resident, erase from resident map.
            if (item->is_resident) {
-                ASSERT(--m_resident_map_count >= 0);
+                m_resident_map_count -= this->HostMapCount(item->paddr, item->size);
+                ASSERT(m_resident_map_count >= 0);
                m_resident_mappings.erase(m_resident_mappings.iterator_to(*item));
            }

@@ -191,7 +175,7 @@ bool HeapTracker::DeferredMapSeparateHeap(size_t virtual_offset) {

        // This map is now resident.
        it->is_resident = true;
-        m_resident_map_count++;
+        m_resident_map_count += this->HostMapCount(it->paddr, it->size);
        m_resident_mappings.insert(*it);
    }

@@ -213,17 +197,17 @@ void HeapTracker::RebuildSeparateHeapAddressSpace() {
    // Despite being worse in theory, this has proven to be better in practice than more
    // regularly dumping a smaller amount, because it significantly reduces average case
    // lock contention.
-    std::size_t const desired_count = (std::min)(m_resident_map_count, m_max_resident_map_count) / 2;
-    std::size_t const evict_count = m_resident_map_count - desired_count;
+    s64 const desired_count = (std::min)(m_resident_map_count, m_max_resident_map_count) / 2;
    auto it = m_resident_mappings.begin();

-    for (size_t i = 0; i < evict_count && it != m_resident_mappings.end(); i++) {
+    while (m_resident_map_count > desired_count && it != m_resident_mappings.end()) {
        // Unmark and unmap.
        it->is_resident = false;
        m_buffer.Unmap(it->vaddr, it->size, false);

        // Advance.
-        ASSERT(--m_resident_map_count >= 0);
+        m_resident_map_count -= this->HostMapCount(it->paddr, it->size);
+        ASSERT(m_resident_map_count >= 0);
        it = m_resident_mappings.erase(it);
    }
 }
@@ -245,6 +229,7 @@ void HeapTracker::SplitHeapMapLocked(VAddr offset) {
    // Cache the original values.
    auto* const left = std::addressof(*it);
    const size_t orig_size = left->size;
+    const s64 orig_host_map_count = this->HostMapCount(left->paddr, orig_size);

    // Adjust the left map.
    const size_t left_size = offset - left->vaddr;
@@ -266,11 +251,20 @@ void HeapTracker::SplitHeapMapLocked(VAddr offset) {

    // If resident, also insert into resident map.
    if (right->is_resident) {
-        m_resident_map_count++;
+        m_resident_map_count += this->HostMapCount(left->paddr, left->size) +
+                                this->HostMapCount(right->paddr, right->size) -
+                                orig_host_map_count;
        m_resident_mappings.insert(*right);
    }
 }

+s64 HeapTracker::HostMapCount(PAddr paddr, size_t size) const {
+    if (!m_has_hardware_buffer_backing) {
+        return size != 0 ? 1 : 0;
+    }
+    return static_cast<s64>(m_buffer.BackingMapCount(paddr, size));
+}
+
 HeapTracker::AddrTree::iterator HeapTracker::GetNearestHeapMapLocked(VAddr offset) {
    const SeparateHeapMap key{
        .vaddr = offset,
@@ -1,3 +1,6 @@
+// SPDX-FileCopyrightText: Copyright 2026 Eden Emulator Project
+// SPDX-License-Identifier: GPL-3.0-or-later
+
 // SPDX-FileCopyrightText: Copyright 2023 yuzu Emulator Project
 // SPDX-License-Identifier: GPL-2.0-or-later

@@ -82,10 +85,13 @@ private:

    AddrTree::iterator GetNearestHeapMapLocked(VAddr offset);

+    s64 HostMapCount(PAddr paddr, size_t size) const;
+
    void RebuildSeparateHeapAddressSpace();

 private:
    Common::HostMemory& m_buffer;
+    const bool m_has_hardware_buffer_backing;
    const s64 m_max_resident_map_count;

    std::shared_mutex m_rebuild_lock{};
@@ -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__)
@@ -55,14 +51,65 @@

 #endif // ^^^ POSIX ^^^

+#include <atomic>
 #include <mutex>
 #include <random>
+#include <vector>

 #include "common/alignment.h"
 #include "common/assert.h"
 #include "common/free_region_manager.h"
 #include "common/host_memory.h"
 #include "common/logging.h"
+#include "common/memory_detect.h"
+#include "common/settings.h"
+
+#ifdef __ANDROID__
+#include <cerrno>
+#include <dlfcn.h>
+#include <sys/ioctl.h>
+#include <android/hardware_buffer.h>
+
+namespace {
+
+struct NativeHandle {
+    int version;
+    int numFds;
+    int numInts;
+    int data[1];
+};
+
+using PFN_AHardwareBuffer_getNativeHandle = const NativeHandle* (*)(const AHardwareBuffer*);
+
+PFN_AHardwareBuffer_getNativeHandle ResolveGetNativeHandle() {
+    void* const lib = dlopen("libnativewindow.so", RTLD_NOW);
+    if (lib == nullptr) {
+        return nullptr;
+    }
+    return reinterpret_cast<PFN_AHardwareBuffer_getNativeHandle>(
+        dlsym(lib, "AHardwareBuffer_getNativeHandle"));
+}
+
+struct DmaBufSync {
+    u64 flags;
+};
+
+constexpr u64 DmaBufSyncRead = 1ULL << 0;
+constexpr u64 DmaBufSyncWrite = 1ULL << 1;
+constexpr u64 DmaBufSyncStart = 0ULL << 2;
+constexpr u64 DmaBufSyncEnd = 1ULL << 2;
+
+void SyncDmaBufCpuAccess(int fd, u64 phase) {
+    DmaBufSync sync{.flags = phase | DmaBufSyncRead | DmaBufSyncWrite};
+    while (ioctl(fd, _IOW('b', 0, DmaBufSync), &sync) != 0) {
+        if (errno != EINTR) {
+            return;
+        }
+    }
+}
+
+} // namespace
+#endif

 #if defined(__ANDROID__) && __ANDROID_API__ < 30
 #include <sys/syscall.h>
@@ -79,6 +126,12 @@ namespace Common {
 [[maybe_unused]] constexpr size_t PageAlignment = 0x1000;
 [[maybe_unused]] constexpr size_t HugePageSize = 0x200000;

+static std::atomic<u64> committed_backing_size{};
+
+u64 GetCommittedBackingSize() noexcept {
+    return committed_backing_size.load(std::memory_order_relaxed);
+}
+
 #ifdef _WIN32

 // Manually imported for MinGW compatibility
@@ -126,7 +179,7 @@ static void GetFuncAddress(Common::DynamicLibrary& dll, const char* name, T& pfn

 class HostMemory::Impl {
 public:
-    explicit Impl(size_t backing_size_, size_t virtual_size_)
+    explicit Impl(size_t backing_size_, size_t virtual_size_, size_t)
        : backing_size{backing_size_}
        , virtual_size{virtual_size_}
        , process{GetCurrentProcess()}
@@ -240,6 +293,10 @@ public:
        UNREACHABLE();
    }

+    bool IsBackingShared() const noexcept {
+        return true;
+    }
+
    const size_t backing_size; ///< Size of the backing memory in bytes
    const size_t virtual_size; ///< Size of the virtual address placeholder in bytes

@@ -516,9 +573,10 @@ static int shm_open_anon(int flags, mode_t mode) {

 class HostMemory::Impl {
 public:
-    explicit Impl(size_t backing_size_, size_t virtual_size_)
+    explicit Impl(size_t backing_size_, size_t virtual_size_, size_t preferred_offset_)
        : backing_size{backing_size_}
        , virtual_size{virtual_size_}
+        , preferred_offset{preferred_offset_}
    {}

    bool Init() {
@@ -558,10 +616,15 @@ public:
            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));
            if (fd > 0) {
-                fd = -1;
                close(fd);
            }
+            fd = -1;
        } else {
+#ifdef __ANDROID__
+            if (InitAhbBacking()) {
+                return InitVirtual();
+            }
+#endif
            backing_base = static_cast<u8*>(mmap(nullptr, backing_size, PROT_READ | PROT_WRITE, MAP_SHARED | MAP_NOCORE, fd, 0));
        }
        if (backing_base == MAP_FAILED) {
@@ -569,7 +632,10 @@ public:
            return false;
        }

-        // Virtual memory initialization
+        return InitVirtual();
+    }
+
+    bool InitVirtual() {
        virtual_base = virtual_map_base = static_cast<u8*>(ChooseVirtualBase(virtual_size));
        if (virtual_base == MAP_FAILED) {
            LOG_CRITICAL(HW_Memory, "mmap failed: {}", strerror(errno));
@@ -582,6 +648,244 @@ public:
        return true;
    }

+#ifdef __ANDROID__
+    static AHardwareBuffer_Desc MakeBlobDesc(size_t len) {
+        return AHardwareBuffer_Desc{
+            .width = static_cast<u32>(len),
+            .height = 1,
+            .layers = 1,
+            .format = AHARDWAREBUFFER_FORMAT_BLOB,
+            .usage = AHARDWAREBUFFER_USAGE_CPU_READ_OFTEN |
+                     AHARDWAREBUFFER_USAGE_CPU_WRITE_OFTEN |
+                     AHARDWAREBUFFER_USAGE_GPU_DATA_BUFFER,
+            .stride = 0,
+            .rfu0 = 0,
+            .rfu1 = 0,
+        };
+    }
+
+    static bool ProbeAhbBacking(PFN_AHardwareBuffer_getNativeHandle get_native_handle) {
+        const AHardwareBuffer_Desc desc = MakeBlobDesc(PageAlignment * 2);
+        AHardwareBuffer* buffer{};
+        if (AHardwareBuffer_allocate(&desc, &buffer) != 0 || buffer == nullptr) {
+            return false;
+        }
+        const NativeHandle* const handle = get_native_handle(buffer);
+        if (handle == nullptr || handle->numFds < 1) {
+            AHardwareBuffer_release(buffer);
+            return false;
+        }
+        const int probe_fd = handle->data[0];
+        bool ok = true;
+        const auto try_map = [&](int prot, off_t offset) {
+            if (!ok) {
+                return;
+            }
+            void* const ptr = mmap(nullptr, PageAlignment, prot, MAP_SHARED, probe_fd, offset);
+            if (ptr == MAP_FAILED) {
+                ok = false;
+                return;
+            }
+            munmap(ptr, PageAlignment);
+        };
+        try_map(PROT_READ | PROT_WRITE, 0);
+        try_map(PROT_READ | PROT_WRITE, static_cast<off_t>(PageAlignment));
+#ifdef ARCHITECTURE_arm64
+        try_map(PROT_READ | PROT_EXEC, 0);
+#endif
+        AHardwareBuffer_release(buffer);
+        return ok;
+    }
+
+    size_t ComputeAhbBudget(size_t window_size) const {
+        const u64 total_physical = Common::GetMemInfo().TotalPhysicalMemory;
+        constexpr u64 BaselineFootprint = 6ULL << 30;
+        if (total_physical <= BaselineFootprint) {
+            return 0;
+        }
+        const u64 permissible_maps = Common::GetPermissibleMapCount();
+        if (permissible_maps == 0) {
+            return 0;
+        }
+        u64 budget = (total_physical - BaselineFootprint) / 2;
+        constexpr u64 MapSlotsPerWindow = 64;
+        const u64 affordable_windows = permissible_maps / MapSlotsPerWindow;
+        budget = (std::min)(budget, affordable_windows * window_size);
+        const u64 available = Common::GetAvailablePhysicalMemory();
+        if (available != 0) {
+            budget = (std::min)(budget, available / 2);
+        }
+        budget = (std::min)(budget, static_cast<u64>(backing_size));
+        budget = Common::AlignDown(budget, window_size);
+        constexpr u64 MinimumBudget = 256ULL << 20;
+        if (budget < MinimumBudget) {
+            return 0;
+        }
+        return static_cast<size_t>(budget);
+    }
+
+    bool InitAhbBacking() {
+        if (!Settings::values.use_unified_memory.GetValue()) {
+            return false;
+        }
+        static const PFN_AHardwareBuffer_getNativeHandle get_native_handle =
+            ResolveGetNativeHandle();
+        if (get_native_handle == nullptr) {
+            return false;
+        }
+        constexpr size_t window_size = 256ULL << 20;
+        const size_t budget = ComputeAhbBudget(window_size);
+        if (budget == 0) {
+            return false;
+        }
+        if (!ProbeAhbBacking(get_native_handle)) {
+            return false;
+        }
+        const size_t aligned_backing = Common::AlignDown(backing_size, window_size);
+        const size_t max_windows = (std::min)(budget, aligned_backing) / window_size;
+
+        std::vector<AHardwareBuffer*> buffers;
+        std::vector<int> buffer_fds;
+        const auto cleanup = [&] {
+            for (AHardwareBuffer* buffer : buffers) {
+                AHardwareBuffer_release(buffer);
+            }
+            buffers.clear();
+            buffer_fds.clear();
+        };
+        for (size_t i = 0; i < max_windows; ++i) {
+            const AHardwareBuffer_Desc desc = MakeBlobDesc(window_size);
+            AHardwareBuffer* buffer{};
+            if (AHardwareBuffer_allocate(&desc, &buffer) != 0 || buffer == nullptr) {
+                break;
+            }
+            const NativeHandle* const handle = get_native_handle(buffer);
+            if (handle == nullptr || handle->numFds < 1) {
+                AHardwareBuffer_release(buffer);
+                break;
+            }
+            const int buffer_fd = handle->data[0];
+            const off_t buffer_len = lseek(buffer_fd, 0, SEEK_END);
+            if (buffer_len < static_cast<off_t>(window_size)) {
+                AHardwareBuffer_release(buffer);
+                break;
+            }
+            buffers.push_back(buffer);
+            buffer_fds.push_back(buffer_fd);
+        }
+        const size_t num_windows = buffers.size();
+        if (num_windows == 0) {
+            return false;
+        }
+        const size_t region_size = num_windows * window_size;
+        const size_t region_base = Common::AlignDown(
+            (std::min)(preferred_offset, aligned_backing - region_size), window_size);
+        u8* const base = static_cast<u8*>(mmap(nullptr, backing_size, PROT_NONE,
+                                               MAP_PRIVATE | MAP_ANONYMOUS | MAP_NORESERVE, -1, 0));
+        if (base == MAP_FAILED) {
+            cleanup();
+            return false;
+        }
+        const auto map_over_reservation = [&](size_t offset, size_t len, int map_fd,
+                                              off_t map_offset) {
+            if (len == 0) {
+                return true;
+            }
+            if (mmap(base + offset, len, PROT_READ | PROT_WRITE, MAP_SHARED | MAP_FIXED, map_fd,
+                     map_offset) == MAP_FAILED) {
+                munmap(base, backing_size);
+                cleanup();
+                return false;
+            }
+            return true;
+        };
+        if (!map_over_reservation(0, region_base, fd, 0)) {
+            return false;
+        }
+        for (size_t i = 0; i < num_windows; ++i) {
+            if (!map_over_reservation(region_base + i * window_size, window_size, buffer_fds[i],
+                                      0)) {
+                return false;
+            }
+        }
+        const size_t tail_offset = region_base + region_size;
+        if (!map_over_reservation(tail_offset, backing_size - tail_offset, fd,
+                                  static_cast<off_t>(tail_offset))) {
+            return false;
+        }
+        backing_base = base;
+        ahb_windows = std::move(buffers);
+        ahb_fds = std::move(buffer_fds);
+        ahb_window_size = window_size;
+        ahb_base = region_base;
+        ahb_bytes = region_size;
+        committed_backing_size.store(region_size, std::memory_order_relaxed);
+        for (const int window_fd : ahb_fds) {
+            SyncDmaBufCpuAccess(window_fd, DmaBufSyncStart);
+        }
+        return true;
+    }
+
+    void MapBackingRange(size_t virtual_offset, size_t host_offset, size_t length, int prot_flags) {
+        while (length > 0) {
+            int map_fd = fd;
+            off_t map_offset = static_cast<off_t>(host_offset);
+            size_t chunk = length;
+            if (host_offset < ahb_base) {
+                chunk = (std::min)(chunk, ahb_base - host_offset);
+            } else if (host_offset < ahb_base + ahb_bytes) {
+                const size_t relative = host_offset - ahb_base;
+                const size_t window = relative / ahb_window_size;
+                const size_t local = relative % ahb_window_size;
+                map_fd = ahb_fds[window];
+                map_offset = static_cast<off_t>(local);
+                chunk = (std::min)(chunk, ahb_window_size - local);
+            }
+            void* const ret = mmap(virtual_base + virtual_offset, chunk, prot_flags,
+                                   MAP_SHARED | MAP_FIXED, map_fd, map_offset);
+            ASSERT_MSG(ret != MAP_FAILED, "mmap: {}", strerror(errno));
+            virtual_offset += chunk;
+            host_offset += chunk;
+            length -= chunk;
+        }
+    }
+
+    size_t BackingMapCount(size_t host_offset, size_t length) const noexcept {
+        if (length == 0) {
+            return 0;
+        }
+        if (ahb_bytes == 0) {
+            return 1;
+        }
+        size_t count = 0;
+        while (length > 0) {
+            size_t chunk = length;
+            if (host_offset < ahb_base) {
+                chunk = (std::min)(chunk, ahb_base - host_offset);
+            } else if (host_offset < ahb_base + ahb_bytes) {
+                const size_t local = (host_offset - ahb_base) % ahb_window_size;
+                chunk = (std::min)(chunk, ahb_window_size - local);
+            }
+            host_offset += chunk;
+            length -= chunk;
+            ++count;
+        }
+        return count;
+    }
+
+    std::span<AHardwareBuffer* const> AhbWindows() const noexcept {
+        return ahb_windows;
+    }
+
+    size_t AhbWindowSize() const noexcept {
+        return ahb_bytes != 0 ? ahb_window_size : 0;
+    }
+
+    size_t AhbBase() const noexcept {
+        return ahb_base;
+    }
+#endif
+
    ~Impl() {
        Release();
    }
@@ -610,6 +914,12 @@ public:
 #ifdef ARCHITECTURE_arm64
        if (True(perms & MemoryPermission::Execute))
            prot_flags |= PROT_EXEC;
+#endif
+#ifdef __ANDROID__
+        if (ahb_bytes != 0) {
+            MapBackingRange(virtual_offset, host_offset, length, prot_flags);
+            return;
+        }
 #endif
        int flags = (fd >= 0 ? MAP_SHARED : MAP_PRIVATE) | MAP_FIXED;
        void* ret = mmap(virtual_base + virtual_offset, length, prot_flags, flags, fd, host_offset);
@@ -655,8 +965,18 @@ public:
        virtual_base = nullptr;
    }

+    bool IsBackingShared() const noexcept {
+#ifdef __ANDROID__
+        if (ahb_bytes != 0) {
+            return true;
+        }
+#endif
+        return fd >= 0;
+    }
+
    const size_t backing_size; ///< Size of the backing memory in bytes
    const size_t virtual_size; ///< Size of the virtual address placeholder in bytes
+    const size_t preferred_offset;

    u8* backing_base{reinterpret_cast<u8*>(MAP_FAILED)};
    u8* virtual_base{reinterpret_cast<u8*>(MAP_FAILED)};
@@ -679,6 +999,21 @@ private:
            int ret = close(fd);
            ASSERT_MSG(ret == 0, "close failed: {}", strerror(errno));
        }
+
+#ifdef __ANDROID__
+        for (const int window_fd : ahb_fds) {
+            SyncDmaBufCpuAccess(window_fd, DmaBufSyncEnd);
+        }
+        for (AHardwareBuffer* buffer : ahb_windows) {
+            AHardwareBuffer_release(buffer);
+        }
+        ahb_windows.clear();
+        ahb_fds.clear();
+        if (ahb_bytes != 0) {
+            committed_backing_size.store(0, std::memory_order_relaxed);
+            ahb_bytes = 0;
+        }
+#endif
    }

    void AdjustMap(size_t* virtual_offset, size_t* length) {
@@ -704,11 +1039,19 @@ private:

    int fd{-1}; // memfd file descriptor, -1 is the error value of memfd_create
    FreeRegionManager free_manager{};
+
+#ifdef __ANDROID__
+    std::vector<AHardwareBuffer*> ahb_windows;
+    std::vector<int> ahb_fds;
+    size_t ahb_window_size{};
+    size_t ahb_base{};
+    size_t ahb_bytes{};
+#endif
 };

 #endif // ^^^ POSIX ^^^

-HostMemory::HostMemory(size_t backing_size_, size_t virtual_size_)
+HostMemory::HostMemory(size_t backing_size_, size_t virtual_size_, size_t preferred_offset_)
    : backing_size(backing_size_)
    , virtual_size(virtual_size_)
 {
@@ -718,7 +1061,7 @@ HostMemory::HostMemory(size_t backing_size_, size_t virtual_size_)
    virtual_base = nullptr;
 #else
    // Try to allocate a fastmem arena.
-    impl = std::make_unique<HostMemory::Impl>(AlignUp(backing_size, PageAlignment), AlignUp(virtual_size, PageAlignment) + HugePageSize);
+    impl = std::make_unique<HostMemory::Impl>(AlignUp(backing_size, PageAlignment), AlignUp(virtual_size, PageAlignment) + HugePageSize, preferred_offset_);
    if (impl->Init()) {
        backing_base = impl->backing_base;
        virtual_base = impl->virtual_base;
@@ -798,6 +1141,46 @@ void HostMemory::ClearBackingRegion(size_t physical_offset, size_t length, u32 f
    std::memset(backing_base + physical_offset, fill_value, length);
 }

+std::span<AHardwareBuffer* const> HostMemory::BackingHardwareBuffers() const noexcept {
+#ifdef __ANDROID__
+    return impl ? impl->AhbWindows() : std::span<AHardwareBuffer* const>{};
+#else
+    return {};
+#endif
+}
+
+size_t HostMemory::BackingMapCount(size_t host_offset, size_t length) const noexcept {
+#ifdef __ANDROID__
+    return impl ? impl->BackingMapCount(host_offset, length) : (length != 0 ? 1 : 0);
+#else
+    return length != 0 ? 1 : 0;
+#endif
+}
+
+size_t HostMemory::BackingHardwareBufferWindowSize() const noexcept {
+#ifdef __ANDROID__
+    return impl ? impl->AhbWindowSize() : 0;
+#else
+    return 0;
+#endif
+}
+
+bool HostMemory::IsBackingShared() const noexcept {
+#if defined(__OPENORBIS__) || defined(__managarm__)
+    return false;
+#else
+    return impl && impl->IsBackingShared();
+#endif
+}
+
+size_t HostMemory::BackingHardwareBufferBase() const noexcept {
+#ifdef __ANDROID__
+    return impl ? impl->AhbBase() : 0;
+#else
+    return 0;
+#endif
+}
+
 void HostMemory::EnableDirectMappedAddress() {
 #if !(defined(__OPENORBIS__) || defined(__managarm__))
    if (impl) {
@@ -8,11 +8,16 @@

 #include <memory>
 #include <optional>
+#include <span>
 #include "common/common_funcs.h"
 #include "common/common_types.h"

+struct AHardwareBuffer;
+
 namespace Common {

+[[nodiscard]] u64 GetCommittedBackingSize() noexcept;
+
 enum class MemoryPermission : u32 {
    Read = 1 << 0,
    Write = 1 << 1,
@@ -27,7 +32,7 @@ DECLARE_ENUM_FLAG_OPERATORS(MemoryPermission)
 */
 class HostMemory {
 public:
-    explicit HostMemory(size_t backing_size_, size_t virtual_size_);
+    explicit HostMemory(size_t backing_size_, size_t virtual_size_, size_t preferred_offset_ = 0);
    ~HostMemory();

    /**
@@ -61,6 +66,20 @@ public:
        return backing_base;
    }

+    [[nodiscard]] size_t BackingSize() const noexcept {
+        return backing_size;
+    }
+
+    [[nodiscard]] size_t BackingMapCount(size_t host_offset, size_t length) const noexcept;
+
+    [[nodiscard]] std::span<AHardwareBuffer* const> BackingHardwareBuffers() const noexcept;
+
+    [[nodiscard]] size_t BackingHardwareBufferWindowSize() const noexcept;
+
+    [[nodiscard]] size_t BackingHardwareBufferBase() const noexcept;
+
+    [[nodiscard]] bool IsBackingShared() const noexcept;
+
    [[nodiscard]] u8* VirtualBasePointer() noexcept {
        return virtual_base;
    }
@@ -1,3 +1,6 @@
+// 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

@@ -17,6 +20,10 @@
 #endif
 #endif

+#include <cstdio>
+#include <cstdlib>
+#include <cstring>
+
 #include "common/memory_detect.h"

 namespace Common {
@@ -69,4 +76,61 @@ const MemoryInfo& GetMemInfo() {
    return mem_info;
 }

+u64 GetPermissibleMapCount() {
+    constexpr u64 DefaultMapCount = 65530;
+    constexpr u64 ReservedMaps = 20000;
+    u64 count = DefaultMapCount;
+#ifdef __linux__
+    if (std::FILE* const file = std::fopen("/proc/sys/vm/max_map_count", "re")) {
+        char line[32];
+        if (std::fgets(line, sizeof(line), file) != nullptr) {
+            const u64 parsed = std::strtoull(line, nullptr, 10);
+            if (parsed != 0) {
+                count = parsed;
+            }
+        }
+        std::fclose(file);
+    }
+#endif
+    if (count <= ReservedMaps) {
+        return 0;
+    }
+    return count - ReservedMaps;
+}
+
+u64 GetAvailablePhysicalMemory() {
+#ifdef _WIN32
+    MEMORYSTATUSEX memorystatus;
+    memorystatus.dwLength = sizeof(memorystatus);
+    if (GlobalMemoryStatusEx(&memorystatus) == 0) {
+        return 0;
+    }
+    return memorystatus.ullAvailPhys;
+#elif defined(__linux__)
+    static constexpr char AvailableKey[] = "MemAvailable:";
+    if (std::FILE* const file = std::fopen("/proc/meminfo", "re")) {
+        char line[256];
+        u64 available = 0;
+        while (std::fgets(line, sizeof(line), file) != nullptr) {
+            if (std::strncmp(line, AvailableKey, sizeof(AvailableKey) - 1) != 0) {
+                continue;
+            }
+            available = std::strtoull(line + sizeof(AvailableKey) - 1, nullptr, 10) * 1024;
+            break;
+        }
+        std::fclose(file);
+        if (available != 0) {
+            return available;
+        }
+    }
+    struct sysinfo meminfo;
+    if (sysinfo(&meminfo) != 0) {
+        return 0;
+    }
+    return static_cast<u64>(meminfo.freeram) * static_cast<u64>(meminfo.mem_unit);
+#else
+    return 0;
+#endif
+}
+
 } // namespace Common
@@ -1,3 +1,6 @@
+// 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

@@ -18,4 +21,8 @@ struct MemoryInfo {
 */
 [[nodiscard]] const MemoryInfo& GetMemInfo();

+[[nodiscard]] u64 GetPermissibleMapCount();
+
+[[nodiscard]] u64 GetAvailablePhysicalMemory();
+
 } // namespace Common
@@ -96,15 +96,15 @@ struct PageTable {
        }

        /// Write page info atomically
-        inline void Store(bool marked, PageType type, u16 block, uintptr_t pointer) noexcept {
+        constexpr void Store(bool marked, PageType type, u16 block, uintptr_t pointer) noexcept {
            data_raw.store(std::bit_cast<u64>(Data{marked, type, block, pointer}));
        }

-        inline void MarkRasterizerCached() noexcept {
+        constexpr void MarkRasterizerCached() noexcept {
            data_raw.fetch_or(0b111);
        }

-        inline void MarkDebug(u64 ptr, u16 block) noexcept {
+        constexpr void MarkDebug(u64 ptr, u16 block) noexcept {
            Store(true, PageType::DebugMemory, block, ptr);
        }

@@ -666,6 +666,9 @@ struct Values {
    SwitchableSetting<bool> use_asynchronous_shaders{linkage, false, "use_asynchronous_shaders",
                                                     Category::RendererHacks};

+    SwitchableSetting<bool> use_unified_memory{linkage, false, "use_unified_memory",
+                                               Category::RendererHacks};
+
    SwitchableSetting<GpuUnswizzleSize> gpu_unswizzle_texture_size{linkage,
                                                  GpuUnswizzleSize::Large,
                                                  "gpu_unswizzle_texture_size",
@@ -38,8 +38,7 @@ 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>
+requires std::is_trivially_copyable_v<T>
 class SparseLargeVector final {
 public:
    constexpr SparseLargeVector() = default;
@@ -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;
 };
@@ -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
@@ -1261,10 +1259,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"

@@ -177,7 +177,7 @@ void ArmDynarmic32::MakeJit(Common::PageTable* page_table) {
        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_marked_bit = 0;
        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;
@@ -193,7 +193,7 @@ void ArmDynarmic32::MakeJit(Common::PageTable* page_table) {
            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);
+            config.page_table_sign_extension = Common::PageTable::SIGN_BIT;
        }
    }

@@ -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"
@@ -216,7 +216,7 @@ void ArmDynarmic64::MakeJit(Common::PageTable* page_table, std::size_t address_s
            const_cast<Common::PageTable::PageEntryData*>(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_marked_bit = 0;
        config.silently_mirror_page_table = false;
        config.absolute_offset_page_table = true;
        config.detect_misaligned_access_via_page_table = 16 | 32 | 64 | 128;
@@ -235,7 +235,7 @@ void ArmDynarmic64::MakeJit(Common::PageTable* page_table, std::size_t address_s
            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);
+            config.page_table_sign_extension = Common::PageTable::SIGN_BIT;
        }
    }

@@ -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"
@@ -1,6 +1,3 @@
-// SPDX-FileCopyrightText: Copyright 2026 Eden Emulator Project
-// SPDX-License-Identifier: GPL-3.0-or-later
-
 // SPDX-FileCopyrightText: Copyright 2023 yuzu Emulator Project
 // SPDX-FileCopyrightText: Copyright 2023 merryhime <https://mary.rs>
 // SPDX-License-Identifier: GPL-2.0-or-later
@@ -10,9 +7,9 @@
 #pragma GCC diagnostic push
 #pragma GCC diagnostic ignored "-Wshadow"

-#include "dynarmic/frontend/A64/a64_types.h"
-#include "dynarmic/frontend/A64/decoder/a64.h"
-#include "dynarmic/frontend/imm.h"
+#include <dynarmic/frontend/A64/a64_types.h>
+#include <dynarmic/frontend/A64/decoder/a64.h>
+#include <dynarmic/frontend/imm.h>

 #pragma GCC diagnostic pop

@@ -120,6 +120,7 @@ struct System::Impl {

        is_multicore = Settings::values.use_multi_core.GetValue();
        extended_memory_layout = Settings::values.memory_layout_mode.GetValue() != Settings::MemoryLayout::Memory_4Gb;
+        unified_memory = Settings::values.use_unified_memory.GetValue();

        core_timing.SetMulticore(is_multicore);
        core_timing.Initialize([&system]() { system.RegisterHostThread(); });
@@ -147,7 +148,8 @@ struct System::Impl {
            !device_memory.has_value() ||
            is_multicore != Settings::values.use_multi_core.GetValue() ||
            extended_memory_layout != (Settings::values.memory_layout_mode.GetValue() !=
-                                       Settings::MemoryLayout::Memory_4Gb);
+                                       Settings::MemoryLayout::Memory_4Gb) ||
+            unified_memory != Settings::values.use_unified_memory.GetValue();

        if (!must_reinitialize) {
            return;
@@ -158,6 +160,7 @@ struct System::Impl {
        is_multicore = Settings::values.use_multi_core.GetValue();
        extended_memory_layout =
            Settings::values.memory_layout_mode.GetValue() != Settings::MemoryLayout::Memory_4Gb;
+        unified_memory = Settings::values.use_unified_memory.GetValue();

        Initialize(system);
    }
@@ -535,6 +538,7 @@ struct System::Impl {
    std::atomic_bool is_powered_on{};
    bool is_multicore : 1 = false;
    bool extended_memory_layout : 1 = false;
+    bool unified_memory : 1 = false;
    bool exit_locked : 1 = false;
    bool exit_requested : 1 = false;

@@ -1,3 +1,6 @@
+// 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

@@ -12,9 +15,18 @@ constexpr size_t VirtualReserveSize = 1ULL << 38;
 constexpr size_t VirtualReserveSize = 1ULL << 39;
 #endif

+namespace {
+size_t ApplicationPoolOffset() {
+    using Init = Kernel::Board::Nintendo::Nx::KSystemControl::Init;
+    const size_t dram_size = Init::GetIntendedMemorySize();
+    const size_t application_pool_size = Init::GetApplicationPoolSize();
+    return dram_size > application_pool_size ? dram_size - application_pool_size : 0;
+}
+}
+
 DeviceMemory::DeviceMemory()
    : buffer{Kernel::Board::Nintendo::Nx::KSystemControl::Init::GetIntendedMemorySize(),
-             VirtualReserveSize} {}
+             VirtualReserveSize, ApplicationPoolOffset()} {}

 DeviceMemory::~DeviceMemory() = default;

@@ -20,6 +20,8 @@
 #include "common/scratch_buffer.h"
 #include "common/sparse_large_vector.h"

+struct AHardwareBuffer;
+
 namespace Core {

 constexpr size_t DEVICE_PAGEBITS = 12ULL;
@@ -95,6 +97,34 @@ public:
        ApplyOpOnPAddr(address, buffer, operation);
    }

+    u8* GetPhysicalBase() noexcept {
+        return reinterpret_cast<u8*>(physical_base);
+    }
+
+    const u8* GetPhysicalBase() const noexcept {
+        return reinterpret_cast<const u8*>(physical_base);
+    }
+
+    size_t GetPhysicalSize() const noexcept {
+        return physical_size;
+    }
+
+    std::span<AHardwareBuffer* const> GetBackingHardwareBuffers() const noexcept {
+        return ahb_windows;
+    }
+
+    size_t GetBackingHardwareBufferWindowSize() const noexcept {
+        return ahb_window_size;
+    }
+
+    size_t GetBackingHardwareBufferBase() const noexcept {
+        return ahb_base;
+    }
+
+    bool IsBackingShared() const noexcept {
+        return backing_is_shared;
+    }
+
    PAddr GetPhysicalRawAddressFromDAddr(DAddr address) const {
        PAddr subbits = PAddr(address & page_mask);
        auto paddr = tracked_entries[(address >> page_bits)].compressed_physical_ptr;
@@ -171,6 +201,11 @@ private:
    std::unique_ptr<DeviceMemoryManagerAllocator<Traits>> impl;

    const uintptr_t physical_base;
+    const size_t physical_size;
+    const std::span<AHardwareBuffer* const> ahb_windows;
+    const size_t ahb_window_size;
+    const size_t ahb_base;
+    const bool backing_is_shared;
    DeviceInterface* device_inter;

    struct TrackedEntry {
@@ -171,6 +171,11 @@ struct DeviceMemoryManagerAllocator {
 template <typename Traits>
 DeviceMemoryManager<Traits>::DeviceMemoryManager(const DeviceMemory& device_memory_)
    : physical_base{uintptr_t(device_memory_.buffer.BackingBasePointer())}
+    , physical_size{device_memory_.buffer.BackingSize()}
+    , ahb_windows{device_memory_.buffer.BackingHardwareBuffers()}
+    , ahb_window_size{device_memory_.buffer.BackingHardwareBufferWindowSize()}
+    , ahb_base{device_memory_.buffer.BackingHardwareBufferBase()}
+    , backing_is_shared{device_memory_.buffer.IsBackingShared()}
    , 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)
@@ -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;
 };
@@ -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;
@@ -12,7 +12,6 @@
 #include "hid_core/frontend/emulated_controller.h"
 #include "hid_core/hid_core.h"
 #include "hid_core/hid_types.h"
-#include <array>

 namespace Core::Frontend {

@@ -30,39 +29,23 @@ void DefaultControllerApplet::ReconfigureControllers(ReconfigureCallback callbac

    const std::size_t min_supported_players =
        parameters.enable_single_mode ? 1 : parameters.min_players;
-    using Core::HID::NpadStyleIndex;
-    const std::size_t max_supported_players = parameters.enable_single_mode ? 1 : parameters.max_players;
-    std::size_t num_selected_players = 0;
-    std::array<bool, HID::HIDCore::available_controllers> keep_connected{};

-    // reserve existing AND valid players before filling slots. include Handheld, but not other
-    for (std::size_t index = 0; index < hid_core.available_controllers - 1; ++index) {
-        const auto* controller = hid_core.GetEmulatedControllerByIndex(index);
-        if (!parameters.keep_controllers_connected || !controller->IsConnected() || num_selected_players >= max_supported_players) continue;
-
-        const auto style = controller->GetNpadStyleIndex();
-        keep_connected[index] =
-            (style == NpadStyleIndex::Fullkey && parameters.allow_pro_controller) ||
-            (style == NpadStyleIndex::JoyconDual && parameters.allow_dual_joycons) ||
-            (style == NpadStyleIndex::JoyconLeft && parameters.allow_left_joycon) ||
-            (style == NpadStyleIndex::JoyconRight && parameters.allow_right_joycon) ||
-            (style == NpadStyleIndex::Handheld && parameters.enable_single_mode && parameters.allow_handheld && !Settings::IsDockedMode()) ||
-            (style == NpadStyleIndex::GameCube && parameters.allow_gamecube_controller);
-        num_selected_players += keep_connected[index];
-    }
+    // Disconnect Handheld first.
    auto* handheld = hid_core.GetEmulatedController(Core::HID::NpadIdType::Handheld);
-    if (!keep_connected[hid_core.available_controllers - 2]) handheld->Disconnect();
+    handheld->Disconnect();

    // Deduce the best configuration based on the input parameters.
    for (std::size_t index = 0; index < hid_core.available_controllers - 2; ++index) {
        auto* controller = hid_core.GetEmulatedControllerByIndex(index);

-        if (keep_connected[index]) continue;
+        // First, disconnect all controllers regardless of the value of keep_controllers_connected.
+        // This makes it easy to connect the desired controllers.
        controller->Disconnect();

-        // only add players still needed to reach the minimum
-        if (num_selected_players >= min_supported_players) continue;
-        ++num_selected_players;
+        // Only connect the minimum number of required players.
+        if (index >= min_supported_players) {
+            continue;
+        }

        // Connect controllers based on the following priority list from highest to lowest priority:
        // Pro Controller -> Dual Joycons -> Left Joycon/Right Joycon -> Handheld
@@ -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));
 }

@@ -228,9 +228,9 @@ IApplicationManagerInterface::IApplicationManagerInterface(Core::System& system_
        {930, nullptr, "Unknown930"}, //20.0.0+
        {931, nullptr, "Unknown931"}, //20.0.0+
        {933, nullptr, "Unknown933"}, //20.0.0+
-        {934, nullptr, "Unknown934"}, //21.0.0+
-        {935, nullptr, "Unknown935"}, //21.0.0+
-        {936, D<&IApplicationManagerInterface::Unknown936>, "Unknown936"}, //21.0.0+
+        {934, nullptr, "Unknown934"}, //20.0.0+
+        {935, nullptr, "Unknown935"}, //20.0.0+
+        {936, nullptr, "Unknown936"}, //20.0.0+
        {1000, nullptr, "RequestVerifyApplicationDeprecated"},
        {1001, nullptr, "CorruptApplicationForDebug"},
        {1002, nullptr, "RequestVerifyAddOnContentsRights"},
@@ -422,7 +422,7 @@ IApplicationManagerInterface::IApplicationManagerInterface(Core::System& system_
        {4039, nullptr, "Unknown4039"}, //20.0.0+
        {4040, nullptr, "Unknown4040"}, //20.0.0+
        {4041, nullptr, "Unknown4041"}, //20.0.0+
-        {4042, D<&IApplicationManagerInterface::Unknown4042>, "Unknown4042"}, //20.0.0+
+        {4042, nullptr, "Unknown4042"}, //20.0.0+
        {4043, nullptr, "Unknown4043"}, //20.0.0+
        {4044, nullptr, "Unknown4044"}, //20.0.0+
        {4045, nullptr, "Unknown4045"}, //20.0.0+
@@ -639,12 +639,6 @@ Result IApplicationManagerInterface::IsGameCardApplicationRunning(Out<bool> out_
    R_SUCCEED();
 }

-Result IApplicationManagerInterface::Unknown936(Out<u64> out_result) {
-    LOG_WARNING(Service_NS, "(STUBBED) called.");
-    *out_result = 0;
-    R_SUCCEED();
-}
-
 Result IApplicationManagerInterface::IsAnyApplicationEntityInstalled(
    Out<bool> out_is_any_application_entity_installed) {
    LOG_WARNING(Service_NS, "(STUBBED) called");
@@ -868,15 +862,6 @@ Result IApplicationManagerInterface::Unknown4023(Out<u64> out_result) {
    R_SUCCEED();
 }

-Result IApplicationManagerInterface::Unknown4042(OutInterface<IAsyncResult> out_interface,
-                                                 OutCopyHandle<Kernel::KReadableEvent> out_event,
-                                                 u64 arg1, u64 arg2) {
-    LOG_WARNING(Service_NS, "(STUBBED) called, arg1={:016X}, arg2={:016X}", arg1, arg2);
-    *out_event = unknown_event.GetHandle();
-    *out_interface = std::make_shared<IAsyncResult>(system, &unknown_event);
-    R_SUCCEED();
-}
-
 Result IApplicationManagerInterface::Unknown4053() {
    LOG_WARNING(Service_NS, "(STUBBED) called.");
    R_SUCCEED();
@@ -7,7 +7,6 @@
 #pragma once

 #include "core/hle/service/cmif_types.h"
-#include "core/hle/service/ns/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"
@@ -35,7 +34,6 @@ public:
    Result GetGameCardMountFailureEvent(OutCopyHandle<Kernel::KReadableEvent> out_event);
    Result GetGameCardWakenReadyEvent(OutCopyHandle<Kernel::KReadableEvent> out_event);
    Result IsGameCardApplicationRunning(Out<bool> out_is_running);
-    Result Unknown936(Out<u64> out_result);
    Result IsAnyApplicationEntityInstalled(Out<bool> out_is_any_application_entity_installed);
    Result GetApplicationViewDeprecated(
        OutArray<ApplicationViewV19, BufferAttr_HipcMapAlias> out_application_views,
@@ -73,9 +71,6 @@ public:
                                  InBuffer<BufferAttr_HipcMapAlias> logo_path_buffer);
    Result Unknown4022(OutCopyHandle<Kernel::KReadableEvent> out_event);
    Result Unknown4023(Out<u64> out_result);
-    Result Unknown4042(OutInterface<IAsyncResult> out_interface,
-                       OutCopyHandle<Kernel::KReadableEvent> out_event,
-                       u64 arg1, u64 arg2);
    Result Unknown4053();
    Result Unknown4105();

@@ -1,35 +0,0 @@
-// SPDX-FileCopyrightText: Copyright 2026 Eden Emulator Project
-// SPDX-License-Identifier: GPL-3.0-or-later
-
-#include "core/hle/service/cmif_serialization.h"
-#include "core/hle/service/ns/async_result.h"
-
-#include <cstring>
-
-namespace Service::NS {
-
-IAsyncResult::IAsyncResult(Core::System& system_, Service::Event* event_)
-    : ServiceFramework{system_, "nn::ns::detail::IAsyncResult"}, event{event_} {
-    // clang-format off
-    static const FunctionInfo functions[] = {
-        {0, nullptr, "Get"},
-        {1, D<&IAsyncResult::Cancel>, "Cancel"},
-        {2, nullptr, "GetErrorContext"}, // 4.0.0+
-    };
-    // clang-format on
-
-    RegisterHandlers(functions);
-}
-
-IAsyncResult::~IAsyncResult() = default;
-
-Result IAsyncResult::Cancel() {
-    LOG_DEBUG(Service_NS, "called");
-    if (event != nullptr) {
-        event->Signal(system.Kernel());
-    }
-
-    R_SUCCEED();
-}
-
-} // namespace Service::NS
@@ -1,19 +0,0 @@
-// SPDX-FileCopyrightText: Copyright 2026 Eden Emulator Project
-// SPDX-License-Identifier: GPL-3.0-or-later
-
-#include "core/hle/service/service.h"
-
-namespace Service::NS {
-
-class IAsyncResult final : public ServiceFramework<IAsyncResult> {
-public:
-    explicit IAsyncResult(Core::System& system_, Service::Event* event_);
-    ~IAsyncResult() override;
-
-private:
-    Result Cancel();
-
-    Service::Event* event{};
-};
-
-} // 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) {
@@ -48,12 +48,6 @@ enum class OptionType : u32 {
    EnableAlpn = 3,
 };

-// This is nn::ssl::sf::RenegotiationMode
-enum RenegotiationMode : u32 {
-    None = 0, ///< None
-    Secure = 1, ///< Secure
-};
-
 // This is nn::ssl::sf::SslVersion
 struct SslVersion {
    union {
@@ -81,34 +75,34 @@ public:
          shared_data{shared_data_in}, backend{std::move(backend_in)} {
        // clang-format off
        static const FunctionInfo functions[] = {
-            {0, D<&ISslConnection::SetSocketDescriptor>, "SetSocketDescriptor"},
-            {1, D<&ISslConnection::SetHostName>, "SetHostName"},
-            {2, D<&ISslConnection::SetVerifyOption>, "SetVerifyOption"},
-            {3, D<&ISslConnection::SetIoMode>, "SetIoMode"},
-            {4, D<&ISslConnection::GetSocketDescriptor>, "GetSocketDescriptor"},
-            {5, D<&ISslConnection::GetHostName>, "GetHostName"},
+            {0, &ISslConnection::SetSocketDescriptor, "SetSocketDescriptor"},
+            {1, &ISslConnection::SetHostName, "SetHostName"},
+            {2, &ISslConnection::SetVerifyOption, "SetVerifyOption"},
+            {3, &ISslConnection::SetIoMode, "SetIoMode"},
+            {4, nullptr, "GetSocketDescriptor"},
+            {5, nullptr, "GetHostName"},
            {6, nullptr, "GetVerifyOption"},
-            {7, D<&ISslConnection::GetIoMode>, "GetIoMode"},
-            {8, D<&ISslConnection::DoHandshake>, "DoHandshake"},
+            {7, nullptr, "GetIoMode"},
+            {8, &ISslConnection::DoHandshake, "DoHandshake"},
            {9, &ISslConnection::DoHandshakeGetServerCert, "DoHandshakeGetServerCert"},
-            {10, D<&ISslConnection::Read>, "Read"},
-            {11, D<&ISslConnection::Write>, "Write"},
-            {12, D<&ISslConnection::Pending>, "Pending"},
-            {13, D<&ISslConnection::Peek>, "Peek"},
-            {14, D<&ISslConnection::Poll>, "Poll"},
-            {15, D<&ISslConnection::GetVerifyCertError>, "GetVerifyCertError"},
-            {16, D<&ISslConnection::GetNeededServerCertBufferSize>, "GetNeededServerCertBufferSize"},
-            {17, D<&ISslConnection::SetSessionCacheMode>, "SetSessionCacheMode"},
-            {18, D<&ISslConnection::GetSessionCacheMode>, "GetSessionCacheMode"},
-            {19, D<&ISslConnection::FlushSessionCache>, "FlushSessionCache"},
-            {20, D<&ISslConnection::SetRenegotiationMode>, "SetRenegotiationMode"},
-            {21, D<&ISslConnection::GetRenegotiationMode>, "GetRenegotiationMode"},
-            {22, D<&ISslConnection::SetOption>, "SetOption"},
-            {23, D<&ISslConnection::GetOption>, "GetOption"},
+            {10, &ISslConnection::Read, "Read"},
+            {11, &ISslConnection::Write, "Write"},
+            {12, &ISslConnection::Pending, "Pending"},
+            {13, nullptr, "Peek"},
+            {14, nullptr, "Poll"},
+            {15, nullptr, "GetVerifyCertError"},
+            {16, nullptr, "GetNeededServerCertBufferSize"},
+            {17, &ISslConnection::SetSessionCacheMode, "SetSessionCacheMode"},
+            {18, nullptr, "GetSessionCacheMode"},
+            {19, nullptr, "FlushSessionCache"},
+            {20, nullptr, "SetRenegotiationMode"},
+            {21, nullptr, "GetRenegotiationMode"},
+            {22, &ISslConnection::SetOption, "SetOption"},
+            {23, &ISslConnection::GetOption, "GetOption"},
            {24, nullptr, "GetVerifyCertErrors"},
            {25, nullptr, "GetCipherInfo"},
-            {26, D<&ISslConnection::SetNextAlpnProto>, "SetNextAlpnProto"},
-            {27, D<&ISslConnection::GetNextAlpnProto>, "GetNextAlpnProto"},
+            {26, &ISslConnection::SetNextAlpnProto, "SetNextAlpnProto"},
+            {27, &ISslConnection::GetNextAlpnProto, "GetNextAlpnProto"},
            {28, nullptr, "SetDtlsSocketDescriptor"},
            {29, nullptr, "GetDtlsHandshakeTimeout"},
            {30, nullptr, "SetPrivateOption"},
@@ -147,6 +141,80 @@ public:
    }

 private:
+    SslVersion ssl_version;
+    std::shared_ptr<SslContextSharedData> shared_data;
+    std::unique_ptr<SSLConnectionBackend> backend;
+    std::optional<int> fd_to_close;
+    bool do_not_close_socket = false;
+    bool get_server_cert_chain = false;
+    bool skip_default_verify = false;
+    bool enable_alpn = false;
+    std::shared_ptr<Network::SocketBase> socket;
+    std::vector<u8> next_alpn_proto;
+    bool did_handshake = false;
+    u32 verify_option = 0;
+
+    Result SetSocketDescriptorImpl(s32* out_fd, s32 fd) {
+        LOG_DEBUG(Service_SSL, "called, fd={}", fd);
+        ASSERT(!did_handshake);
+        auto bsd = system.ServiceManager().GetService<Service::Sockets::BSD_USA>("bsd:u");
+        ASSERT_OR_EXECUTE(bsd, { return ResultInternalError; });
+
+        auto const res_v = bsd->DuplicateSocketImpl(fd);
+        if (auto *res = std::get_if<s32>(&res_v)) {
+            const s32 duplicated_fd = *res;
+            if (do_not_close_socket) {
+                *out_fd = duplicated_fd;
+            } else {
+                *out_fd = -1;
+                fd_to_close = duplicated_fd;
+            }
+            std::optional<std::shared_ptr<Network::SocketBase>> sock = bsd->GetSocket(duplicated_fd);
+            if (!sock.has_value()) {
+                LOG_ERROR(Service_SSL, "invalid socket fd {} after duplication", duplicated_fd);
+                return ResultInvalidSocket;
+            }
+            socket = std::move(*sock);
+            backend->SetSocket(socket);
+            return ResultSuccess;
+        }
+        LOG_ERROR(Service_SSL, "Failed to duplicate socket with fd {}", fd);
+        return ResultInvalidSocket;
+    }
+
+    Result SetHostNameImpl(const std::string& hostname) {
+        LOG_DEBUG(Service_SSL, "called. hostname={}", hostname);
+        ASSERT(!did_handshake);
+        return backend->SetHostName(hostname);
+    }
+
+    Result SetVerifyOptionImpl(u32 option) {
+        ASSERT(!did_handshake);
+        LOG_DEBUG(Service_SSL, "called. option={} (forcing 0)", option);
+        verify_option = 0;
+        backend->SetVerifyOption(0);
+        return ResultSuccess;
+    }
+
+    Result SetIoModeImpl(u32 input_mode) {
+        auto mode = static_cast<IoMode>(input_mode);
+        ASSERT(mode == IoMode::Blocking || mode == IoMode::NonBlocking);
+        ASSERT_OR_EXECUTE(socket, { return ResultNoSocket; });
+
+        const bool non_block = mode == IoMode::NonBlocking;
+        const Network::Errno error = socket->SetNonBlock(non_block);
+        if (error != Network::Errno::SUCCESS) {
+            LOG_ERROR(Service_SSL, "Failed to set native socket non-block flag to {}", non_block);
+        }
+        return ResultSuccess;
+    }
+
+    Result SetSessionCacheModeImpl(u32 mode) {
+        ASSERT(!did_handshake);
+        LOG_WARNING(Service_SSL, "(STUBBED) called. value={}", mode);
+        return ResultSuccess;
+    }
+
    Result DoHandshakeImpl() {
        ASSERT_OR_EXECUTE(!did_handshake && socket, { return ResultNoSocket; });
        Result res = backend->DoHandshake();
@@ -166,17 +234,19 @@ private:
        };
        if (!get_server_cert_chain) {
            // Just return the first one, unencoded.
-            ASSERT_OR_EXECUTE_MSG(!certs.empty(), { return {}; }, "Should be at least one server cert");
+            ASSERT_OR_EXECUTE_MSG(
+                !certs.empty(), { return {}; }, "Should be at least one server cert");
            return certs[0];
        }
        std::vector<u8> ret;
-        Header header{0x4E4D684374726543, u32(certs.size()), 0};
+        Header header{0x4E4D684374726543, static_cast<u32>(certs.size()), 0};
        ret.insert(ret.end(), reinterpret_cast<u8*>(&header), reinterpret_cast<u8*>(&header + 1));
        size_t data_offset = sizeof(Header) + certs.size() * sizeof(EntryHeader);
        for (auto& cert : certs) {
-            EntryHeader entry_header{u32(cert.size()), u32(data_offset)};
+            EntryHeader entry_header{static_cast<u32>(cert.size()), static_cast<u32>(data_offset)};
            data_offset += cert.size();
-            ret.insert(ret.end(), reinterpret_cast<u8*>(&entry_header), reinterpret_cast<u8*>(&entry_header + 1));
+            ret.insert(ret.end(), reinterpret_cast<u8*>(&entry_header),
+                       reinterpret_cast<u8*>(&entry_header + 1));
        }
        for (auto& cert : certs) {
            ret.insert(ret.end(), cert.begin(), cert.end());
@@ -184,77 +254,65 @@ private:
        return ret;
    }

-    Result SetSocketDescriptor(s32 in_fd, Out<s32> out_fd) {
-        LOG_DEBUG(Service_SSL, "called, fd={}", in_fd);
-        ASSERT(!did_handshake);
-        auto bsd = system.ServiceManager().GetService<Service::Sockets::BSD_USA>("bsd:u");
-        ASSERT_OR_EXECUTE(bsd, { return ResultInternalError; });
-
-        auto const res_v = bsd->DuplicateSocketImpl(in_fd);
-        if (auto *res = std::get_if<s32>(&res_v)) {
-            const s32 dup_fd = *res;
-            *out_fd = do_not_close_socket ? dup_fd : -1;
-            if (!do_not_close_socket)
-                fd_to_close = dup_fd;
-            auto const sock = bsd->GetSocket(dup_fd);
-            if (!sock.has_value()) {
-                LOG_ERROR(Service_SSL, "invalid socket fd {} after duplication", dup_fd);
-                return ResultInvalidSocket;
-            }
-            socket = std::move(*sock);
-            backend->SetSocket(std::move(socket));
-            return ResultSuccess;
+    Result ReadImpl(std::vector<u8>* out_data) {
+        ASSERT_OR_EXECUTE(did_handshake, { return ResultInternalError; });
+        size_t actual_size{};
+        Result res = backend->Read(&actual_size, *out_data);
+        if (res != ResultSuccess) {
+            return res;
        }
-        LOG_ERROR(Service_SSL, "Failed to duplicate socket with fd {}", in_fd);
-        return ResultInvalidSocket;
+        out_data->resize(actual_size);
+        return res;
    }

-    Result SetHostName(InBuffer<BufferAttr_HipcMapAlias> buf) {
-        auto const hostname = Common::StringFromBuffer(buf);
-        LOG_DEBUG(Service_SSL, "called. hostname={}", hostname);
-        ASSERT(!did_handshake);
-        return backend->SetHostName(hostname.c_str());
+    Result WriteImpl(size_t* out_size, std::span<const u8> data) {
+        ASSERT_OR_EXECUTE(did_handshake, { return ResultInternalError; });
+        return backend->Write(out_size, data);
    }

-    Result SetVerifyOption(u32 option) {
-        LOG_DEBUG(Service_SSL, "called. option={} (forcing 0)", option);
-        ASSERT(!did_handshake);
-        verify_option = 0;
-        backend->SetVerifyOption(0);
-        R_SUCCEED();
+    Result PendingImpl(s32* out_pending) {
+        LOG_WARNING(Service_SSL, "(STUBBED) called.");
+        *out_pending = 0;
+        return ResultSuccess;
    }

-    Result SetIoMode(u32 input_mode) {
-        auto mode = IoMode(input_mode);
-        ASSERT(mode == IoMode::Blocking || mode == IoMode::NonBlocking);
-        R_UNLESS(socket, ResultNoSocket);
-        const bool non_block = mode == IoMode::NonBlocking;
-        const Network::Errno error = socket->SetNonBlock(non_block);
-        if (error != Network::Errno::SUCCESS) {
-            LOG_ERROR(Service_SSL, "Failed to set native socket non-block flag to {}", non_block);
-        }
-        R_SUCCEED();
+    void SetSocketDescriptor(HLERequestContext& ctx) {
+        IPC::RequestParser rp{ctx};
+        const s32 in_fd = rp.Pop<s32>();
+        s32 out_fd{-1};
+        const Result res = SetSocketDescriptorImpl(&out_fd, in_fd);
+        IPC::ResponseBuilder rb{ctx, 3};
+        rb.Push(res);
+        rb.Push<s32>(out_fd);
    }

-    Result GetSocketDescriptor(Out<u32> out_fd) {
-        LOG_WARNING(Service_SSL, "(STUBBED)");
-        *out_fd = uint32_t(socket->GetFD());
-        R_SUCCEED();
+    void SetHostName(HLERequestContext& ctx) {
+        const std::string hostname = Common::StringFromBuffer(ctx.ReadBuffer());
+        const Result res = SetHostNameImpl(hostname);
+        IPC::ResponseBuilder rb{ctx, 2};
+        rb.Push(res);
    }

-    Result GetHostName(OutBuffer<BufferAttr_HipcMapAlias> data, Out<u32> out_size) {
-        LOG_WARNING(Service_SSL, "(STUBBED)");
-        ASSERT(!did_handshake);
-        return backend->GetHostName(std::span<u8>{data.begin(), data.end()}, out_size);
+    void SetVerifyOption(HLERequestContext& ctx) {
+        IPC::RequestParser rp{ctx};
+        const u32 option = rp.Pop<u32>();
+        const Result res = SetVerifyOptionImpl(option);
+        IPC::ResponseBuilder rb{ctx, 2};
+        rb.Push(res);
    }

-    Result GetIoMode(Out<u32> out_mode) {
-        LOG_WARNING(Service_SSL, "(STUBBED)");
-        R_SUCCEED();
+    void SetIoMode(HLERequestContext& ctx) {
+        IPC::RequestParser rp{ctx};
+        const u32 mode = rp.Pop<u32>();
+        const Result res = SetIoModeImpl(mode);
+        IPC::ResponseBuilder rb{ctx, 2};
+        rb.Push(res);
    }

-    Result DoHandshake() {
-        return DoHandshakeImpl();
+    void DoHandshake(HLERequestContext& ctx) {
+        const Result res = DoHandshakeImpl();
+        IPC::ResponseBuilder rb{ctx, 2};
+        rb.Push(res);
    }

    void DoHandshakeGetServerCert(HLERequestContext& ctx) {
@@ -293,158 +351,131 @@ private:
        rb.PushRaw(out);
    }

-    Result Read(OutBuffer<BufferAttr_HipcMapAlias> data, Out<u32> out_size) {
-        R_UNLESS(did_handshake, ResultInternalError);
-        size_t tmp{};
-        auto const res = backend->Read(&tmp, data);
-        *out_size = u32(tmp);
-        return res;
+    void Read(HLERequestContext& ctx) {
+        std::vector<u8> output_bytes(ctx.GetWriteBufferSize());
+        const Result res = ReadImpl(&output_bytes);
+        IPC::ResponseBuilder rb{ctx, 3};
+        rb.Push(res);
+        if (res == ResultSuccess) {
+            rb.Push(static_cast<u32>(output_bytes.size()));
+            ctx.WriteBuffer(output_bytes);
+        } else {
+            rb.Push(static_cast<u32>(0));
+        }
    }

-    Result Write(InBuffer<BufferAttr_HipcMapAlias> data, Out<u32> out_size) {
-        R_UNLESS(did_handshake, ResultInternalError);
-        size_t tmp{};
-        auto const res = backend->Write(&tmp, data);
-        *out_size = u32(tmp);
-        return res;
+    void Write(HLERequestContext& ctx) {
+        size_t write_size{0};
+        const Result res = WriteImpl(&write_size, ctx.ReadBuffer());
+        IPC::ResponseBuilder rb{ctx, 3};
+        rb.Push(res);
+        rb.Push(static_cast<u32>(write_size));
    }

-    Result Pending(Out<s32> out_pending_size) {
-        LOG_WARNING(Service_SSL, "(STUBBED)");
-        *out_pending_size = s32(backend->Pending());
-        R_SUCCEED();
+    void Pending(HLERequestContext& ctx) {
+        s32 pending_size{0};
+        const Result res = PendingImpl(&pending_size);
+        IPC::ResponseBuilder rb{ctx, 3};
+        rb.Push(res);
+        rb.Push<s32>(pending_size);
    }

-    Result Peek(OutBuffer<BufferAttr_HipcMapAlias> data, Out<u32> out_size) {
-        LOG_WARNING(Service_SSL, "(STUBBED)");
-        size_t tmp{};
-        auto const res = backend->Peek(&tmp, data);
-        *out_size = u32(tmp);
-        return res;
+    void SetSessionCacheMode(HLERequestContext& ctx) {
+        IPC::RequestParser rp{ctx};
+        const u32 mode = rp.Pop<u32>();
+        const Result res = SetSessionCacheModeImpl(mode);
+        IPC::ResponseBuilder rb{ctx, 2};
+        rb.Push(res);
    }

-    Result Poll(u32 in_pollevent, u32 timer, Out<u32> out_pollevent) {
-        LOG_WARNING(Service_SSL, "(STUBBED)");
-        R_SUCCEED();
-    }
+    void SetOption(HLERequestContext& ctx) {
+        struct Parameters {
+            OptionType option;
+            s32 value;
+        };
+        static_assert(sizeof(Parameters) == 0x8, "Parameters is an invalid size");

-    Result GetVerifyCertError() {
-        LOG_WARNING(Service_SSL, "(STUBBED)");
-        R_SUCCEED();
-    }
+        IPC::RequestParser rp{ctx};
+        const auto parameters = rp.PopRaw<Parameters>();

-    Result GetNeededServerCertBufferSize(Out<u32> out_needed_buffer_size) {
-        LOG_WARNING(Service_SSL, "(STUBBED)");
-        R_SUCCEED();
-    }
-
-    Result SetSessionCacheMode(u32 mode) {
-        LOG_WARNING(Service_SSL, "(STUBBED) called. value={}", mode);
-        R_UNLESS(!did_handshake, ResultInternalError);
-        R_SUCCEED();
-    }
-
-    Result GetSessionCacheMode(Out<u32> mode) {
-        LOG_WARNING(Service_SSL, "(STUBBED)");
-        R_UNLESS(!did_handshake, ResultInternalError);
-        R_SUCCEED();
-    }
-
-    Result FlushSessionCache() {
-        LOG_WARNING(Service_SSL, "(STUBBED)");
-        R_UNLESS(!did_handshake, ResultInternalError);
-        R_SUCCEED();
-    }
-
-    Result SetRenegotiationMode(RenegotiationMode mode) {
-        LOG_WARNING(Service_SSL, "(STUBBED)");
-        backend->SetRenegotiationMode(u32(mode));
-        R_SUCCEED();
-    }
-
-    Result GetRenegotiationMode(Out<RenegotiationMode> mode) {
-        LOG_WARNING(Service_SSL, "(STUBBED)");
-        u32 tmp{};
-        auto const res = backend->GetRenegotiationMode(&tmp);
-        *mode = RenegotiationMode(tmp);
-        return res;
-    }
-
-    Result SetOption(OptionType option, s32 value) {
-        switch (option) {
+        switch (parameters.option) {
        case OptionType::DoNotCloseSocket:
-            do_not_close_socket = bool(value);
+            do_not_close_socket = static_cast<bool>(parameters.value);
            break;
        case OptionType::GetServerCertChain:
-            get_server_cert_chain = bool(value);
+            get_server_cert_chain = static_cast<bool>(parameters.value);
            break;
        case OptionType::SkipDefaultVerify:
-            skip_default_verify = bool(value);
+            skip_default_verify = static_cast<bool>(parameters.value);
            break;
        case OptionType::EnableAlpn:
-            enable_alpn = bool(value);
+            enable_alpn = static_cast<bool>(parameters.value);
            break;
        default:
-            LOG_WARNING(Service_SSL, "Unknown option={}, value={}", option, value);
+            LOG_WARNING(Service_SSL, "Unknown option={}, value={}", parameters.option,
+                        parameters.value);
        }
-        R_SUCCEED();
+
+        IPC::ResponseBuilder rb{ctx, 2};
+        rb.Push(ResultSuccess);
    }

-    Result GetOption(OptionType option, Out<u8> value) {
+    void GetOption(HLERequestContext& ctx) {
+        IPC::RequestParser rp{ctx};
+        const auto option = rp.PopRaw<OptionType>();
+
+        u8 value = 0;
+
        switch (option) {
        case OptionType::DoNotCloseSocket:
-            *value = u8(do_not_close_socket);
+            value = static_cast<u8>(do_not_close_socket);
            break;
        case OptionType::GetServerCertChain:
-            *value = u8(get_server_cert_chain);
+            value = static_cast<u8>(get_server_cert_chain);
            break;
        case OptionType::SkipDefaultVerify:
-            *value = u8(skip_default_verify);
+            value = static_cast<u8>(skip_default_verify);
            break;
        case OptionType::EnableAlpn:
-            *value = u8(enable_alpn);
+            value = static_cast<u8>(enable_alpn);
            break;
        default:
-            LOG_WARNING(Service_SSL, "Unknown option={}", u32(option));
-            *value = 0;
+            LOG_WARNING(Service_SSL, "Unknown option={}", option);
+            value = 0;
            break;
        }
-        LOG_DEBUG(Service_SSL, "GetOption called, option={}, ret value={}", u32(option), *value);
-        R_SUCCEED();
+
+        LOG_DEBUG(Service_SSL, "GetOption called, option={}, ret value={}", option, value);
+
+        IPC::ResponseBuilder rb{ctx, 3};
+        rb.Push(ResultSuccess);
+        rb.Push<u8>(value);
    }

-    Result SetNextAlpnProto(InBuffer<BufferAttr_HipcMapAlias> data) {
-        auto const to_write = u32((std::min)(next_alpn_proto.size(), data.size()));
-        next_alpn_proto.assign(data.begin(), data.begin() + to_write);
+    void SetNextAlpnProto(HLERequestContext& ctx) {
+        const auto data = ctx.ReadBuffer(0);
+        next_alpn_proto.assign(data.begin(), data.end());
+
        LOG_DEBUG(Service_SSL, "SetNextAlpnProto called, size={}", next_alpn_proto.size());
-        R_SUCCEED();
+
+        IPC::ResponseBuilder rb{ctx, 2};
+        rb.Push(ResultSuccess);
    }

-    Result GetNextAlpnProto(OutBuffer<BufferAttr_HipcMapAlias> data, Out<u32> to_write) {
-        *to_write = u32((std::min)(next_alpn_proto.size(), data.size()));
-        next_alpn_proto.assign(data.begin(), data.begin() + *to_write);
-        LOG_DEBUG(Service_SSL, "GetNextAlpnProto called, size={}", *to_write);
-        R_SUCCEED();
+    void GetNextAlpnProto(HLERequestContext& ctx) {
+        const size_t writable = ctx.GetWriteBufferSize();
+        const size_t to_write = (std::min)(next_alpn_proto.size(), writable);
+
+        if (to_write != 0) {
+            ctx.WriteBuffer(std::span<const u8>(next_alpn_proto.data(), to_write));
+        }
+
+        LOG_DEBUG(Service_SSL, "GetNextAlpnProto called, size={}", to_write);
+
+        IPC::ResponseBuilder rb{ctx, 3};
+        rb.Push(ResultSuccess);
+        rb.Push<u32>(static_cast<u32>(to_write));
    }
-
-    Result GetVerifyCertErrors(OutBuffer<BufferAttr_HipcMapAlias> unk0, Out<u32> unk1, Out<u32> unk2) {
-        LOG_WARNING(Service_SSL, "(STUBBED)");
-        R_SUCCEED();
-    }
-
-    SslVersion ssl_version;
-    std::shared_ptr<SslContextSharedData> shared_data;
-    std::unique_ptr<SSLConnectionBackend> backend;
-    std::optional<int> fd_to_close;
-    std::shared_ptr<Network::SocketBase> socket;
-    std::vector<u8> next_alpn_proto;
-    u32 verify_option = 0;
-
-    bool do_not_close_socket = false;
-    bool get_server_cert_chain = false;
-    bool skip_default_verify = false;
-    bool enable_alpn = false;
-    bool did_handshake = false;
 };

 class ISslContext final : public ServiceFramework<ISslContext> {
@@ -461,7 +492,7 @@ public:
            {5, &ISslContext::ImportClientPki, "ImportClientPki"},
            {6, nullptr, "RemoveServerPki"},
            {7, nullptr, "RemoveClientPki"},
-            {8, D<&ISslContext::RegisterInternalPki>, "RegisterInternalPki"},
+            {8, nullptr, "RegisterInternalPki"},
            {9, nullptr, "AddPolicyOid"},
            {10, nullptr, "ImportCrl"},
            {11, nullptr, "RemoveCrl"},
@@ -556,11 +587,6 @@ private:
        rb.Push(ResultSuccess);
        rb.Push(client_id);
    }
-
-    Result RegisterInternalPki() {
-        LOG_WARNING(Service_SSL, "(STUBBED) called");
-        R_SUCCEED();
-    }
 };

 class ISslService final : public ServiceFramework<ISslService> {
@@ -36,17 +36,12 @@ class SSLConnectionBackend {
 public:
    virtual ~SSLConnectionBackend() {}
    virtual void SetSocket(std::shared_ptr<Network::SocketBase> socket) = 0;
+    virtual Result SetHostName(const std::string& hostname) = 0;
    virtual void SetVerifyOption(u32 option) = 0;
    virtual Result DoHandshake() = 0;
    virtual Result Read(size_t* out_size, std::span<u8> data) = 0;
-    virtual Result Peek(size_t* out_size, std::span<u8> data) = 0;
    virtual Result Write(size_t* out_size, std::span<const u8> data) = 0;
    virtual Result GetServerCerts(std::vector<std::vector<u8>>* out_certs) = 0;
-    virtual Result SetHostName(const char* hostname) = 0;
-    virtual Result GetHostName(std::span<u8> hostname, u32* out_size) = 0;
-    virtual int Pending() = 0;
-    virtual Result SetRenegotiationMode(u32 mode) = 0;
-    virtual Result GetRenegotiationMode(u32* mode) = 0;
 };

 Result CreateSSLConnectionBackend(std::unique_ptr<SSLConnectionBackend>* out_backend);
@@ -157,30 +157,18 @@ public:
        socket = std::move(socket_in);
    }

-    Result SetHostName(const char* hostname) override {
+    Result SetHostName(const std::string& hostname) override {
        if (!skip_cert_verification) {
-            if (!SSL_set1_host(ssl, hostname)) {
+            if (!SSL_set1_host(ssl, hostname.c_str())) {
                LOG_ERROR(Service_SSL, "SSL_set1_host({}) failed", hostname);
                return CheckOpenSSLErrors();
            }
        }
-        if (!SSL_set_tlsext_host_name(ssl, hostname)) { // hostname for SNI
+        if (!SSL_set_tlsext_host_name(ssl, hostname.c_str())) { // hostname for SNI
            LOG_ERROR(Service_SSL, "SSL_set_tlsext_host_name({}) failed", hostname);
            return CheckOpenSSLErrors();
        }
-        R_SUCCEED();
-    }
-
-    Result GetHostName(std::span<u8> data, u32* out_size) override {
-        auto const peer_name = SSL_get0_peername(ssl);
-        if (peer_name == nullptr) {
-            LOG_ERROR(Service_SSL, "SSL_get0_peername()");
-            return CheckOpenSSLErrors();
-        }
-        auto const s = std::string{peer_name};
-        *out_size = u32(s.size());
-        std::memcpy(data.data(), s.data(), (std::min)(s.size(), data.size()));
-        R_SUCCEED();
+        return ResultSuccess;
    }

    void SetVerifyOption(u32 option) override {
@@ -225,13 +213,6 @@ public:
        return HandleReturn("SSL_read_ex", out_size, ret);
    }

-    Result Peek(size_t* out_size, std::span<u8> data) override {
-        auto const n = (std::min)(data.size(), *out_size);
-        const int ret = SSL_peek(ssl, data.data(), int(n));
-        *out_size = n;
-        return HandleReturn("SSL_write_ex", out_size, ret);
-    }
-
    Result Write(size_t* out_size, std::span<const u8> data) override {
        const int ret = SSL_write_ex(ssl, data.data(), data.size(), out_size);
        return HandleReturn("SSL_write_ex", out_size, ret);
@@ -282,25 +263,7 @@ public:
            out_certs->emplace_back(buf, buf + len);
            OPENSSL_free(buf);
        }
-        R_SUCCEED();
-    }
-
-    int Pending() override {
-        return SSL_pending(ssl);
-    }
-
-    Result SetRenegotiationMode(u32 mode) override {
-        if (mode == 0) {
-            SSL_CTX_set_options(ssl_ctx, SSL_OP_NO_RENEGOTIATION);
-        } else {
-            SSL_CTX_set_options(ssl_ctx, SSL_OP_ALLOW_CLIENT_RENEGOTIATION);
-        }
-        R_SUCCEED();
-    }
-
-    Result GetRenegotiationMode(u32* mode) override {
-        *mode = SSL_get_secure_renegotiation_support(ssl) ? 1 : 0;
-        R_SUCCEED();
+        return ResultSuccess;
    }

    ~SSLConnectionBackendOpenSSL() {
@@ -0,0 +1,29 @@
+# SPDX-FileCopyrightText: Copyright 2025 Eden Emulator Project
+# SPDX-License-Identifier: GPL-3.0-or-later
+
+function(target_architecture_specific_sources project arch)
+    if (NOT MULTIARCH_BUILD)
+        target_sources("${project}" PRIVATE ${ARGN})
+        return()
+    endif()
+
+    foreach(input_file IN LISTS ARGN)
+        if(input_file MATCHES ".cpp$")
+            if(NOT IS_ABSOLUTE ${input_file})
+                set(input_file "${CMAKE_CURRENT_SOURCE_DIR}/${input_file}")
+            endif()
+
+            set(output_file "${CMAKE_CURRENT_BINARY_DIR}/arch_gen/${input_file}")
+            add_custom_command(
+                OUTPUT "${output_file}"
+                COMMAND ${CMAKE_COMMAND} "-Darch=${arch}"
+                                         "-Dinput_file=${input_file}"
+                                         "-Doutput_file=${output_file}"
+                                         -P "${CMAKE_CURRENT_FUNCTION_LIST_DIR}/impl/TargetArchitectureSpecificSourcesWrapFile.cmake"
+                DEPENDS "${input_file}"
+                VERBATIM
+            )
+            target_sources(${project} PRIVATE "${output_file}")
+        endif()
+    endforeach()
+endfunction()
@@ -1,5 +1,6 @@
 # SPDX-FileCopyrightText: Copyright 2026 Eden Emulator Project
 # SPDX-License-Identifier: GPL-3.0-or-later
+include(TargetArchitectureSpecificSources)

 add_library(dynarmic STATIC
    mcl/bit.hpp
@@ -142,7 +143,7 @@ if ("x86_64" IN_LIST ARCHITECTURE)
    target_compile_definitions(dynarmic PRIVATE XBYAK_OLD_DISP_CHECK=1)
    target_link_libraries(dynarmic PRIVATE xbyak::xbyak)

-    target_sources(dynarmic PRIVATE
+    target_architecture_specific_sources(dynarmic "x86_64"
        backend/x64/abi.cpp
        backend/x64/abi.h
        backend/x64/block_of_code.cpp
@@ -203,7 +204,7 @@ endif()
 if ("arm64" IN_LIST ARCHITECTURE)
    target_link_libraries(dynarmic PRIVATE merry::oaknut)

-    target_sources(dynarmic PRIVATE
+    target_architecture_specific_sources(dynarmic "arm64"
        backend/arm64/a32_jitstate.cpp
        backend/arm64/a32_jitstate.h
        backend/arm64/a64_jitstate.h
@@ -90,7 +90,7 @@ template<>
        code.shl(tmp, int(ctx.conf.page_table_log2_stride));
        code.mov(page, qword[r14 + tmp.cvt64()]);
    } else {
-        code.mov(page, qword[r14 + tmp.cvt64() * int(1 << ctx.conf.page_table_log2_stride)]);
+        code.mov(page, qword[r14 + tmp.cvt64() * int(ctx.conf.page_table_log2_stride)]);
    }

    // check for marked bit, use as unmapped if marked
@@ -161,12 +161,8 @@ template<>
        code.jnz(abort, code.T_NEAR);
    }

-    if (ctx.conf.page_table_log2_stride > 3) {
-        code.shl(tmp, int(ctx.conf.page_table_log2_stride));
-        code.mov(page, qword[r14 + tmp.cvt64()]);
-    } else {
-        code.mov(page, qword[r14 + tmp.cvt64() * int(1 << ctx.conf.page_table_log2_stride)]);
-    }
+    code.shl(tmp, int(ctx.conf.page_table_log2_stride));
+    code.mov(page, qword[r14 + tmp]);

    // check for marked bit, use as unmapped if marked
    if (ctx.conf.page_table_marked_bit) {
@@ -182,7 +178,6 @@ template<>
        code.mov(tmp, ctx.conf.page_table_pointer_mask);
        code.and_(page, tmp);
    }
-    // check for sign bit, apply sign extension as needed
    if (ctx.conf.page_table_sign_extension) {
        code.shl(page, *ctx.conf.page_table_sign_extension);
        code.sar(page, *ctx.conf.page_table_sign_extension);
@@ -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

 /* This file is part of the dynarmic project.
@@ -14,8 +14,8 @@
 #include <string>
 #include <vector>

-#include "config.h"
-#include "dynarmic/src/dynarmic/interface/halt_reason.h"
+#include "dynarmic/interface/A32/config.h"
+#include "dynarmic/interface/halt_reason.h"

 namespace Dynarmic {
 namespace A32 {
@@ -14,9 +14,9 @@
 #include <memory>
 #include <optional>

-#include "../../frontend/A32/translate/translate_callbacks.h"
-#include "arch_version.h"
-#include "../optimization_flags.h"
+#include "dynarmic/frontend/A32/translate/translate_callbacks.h"
+#include "dynarmic/interface/A32/arch_version.h"
+#include "dynarmic/interface/optimization_flags.h"

 namespace Dynarmic {
 class ExclusiveMonitor;
@@ -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

 /* This file is part of the dynarmic project.
@@ -15,8 +15,8 @@
 #include <string>
 #include <vector>

-#include "config.h"
-#include "../halt_reason.h"
+#include "dynarmic/interface/A64/config.h"
+#include "dynarmic/interface/halt_reason.h"

 namespace Dynarmic {
 namespace A64 {
@@ -14,7 +14,7 @@
 #include <memory>
 #include <optional>

-#include "../optimization_flags.h"
+#include "dynarmic/interface/optimization_flags.h"

 namespace Dynarmic {
 class ExclusiveMonitor;
@@ -14,7 +14,7 @@
 #include <cstring>
 #include <boost/container/static_vector.hpp>

-#include "dynarmic/src/dynarmic/common/spin_lock.h"
+#include <dynarmic/common/spin_lock.h>

 namespace Dynarmic {

@@ -1,5 +1,6 @@
 # SPDX-FileCopyrightText: Copyright 2026 Eden Emulator Project
 # SPDX-License-Identifier: GPL-3.0-or-later
+include(TargetArchitectureSpecificSources)

 add_executable(dynarmic_tests
    fp/FPToFixed.cpp
@@ -49,7 +50,7 @@ endif()

 if ("x86_64" IN_LIST ARCHITECTURE)
    target_link_libraries(dynarmic_tests PRIVATE xbyak::xbyak)
-    target_sources(dynarmic PRIVATE
+    target_architecture_specific_sources(dynarmic_tests "x86_64"
        x64_cpu_info.cpp
        native/preserve_xmm.cpp
    )
@@ -398,21 +398,21 @@ void NPad::InitNewlyAddedController(Kernel::KernelCore& kernel, u64 aruid, Core:
 void NPad::WriteEmptyEntry(NpadInternalState* npad) {
    NPadGenericState dummy_pad_state{};
    NpadGcTriggerState dummy_gc_state{};
-    dummy_pad_state.sampling_number = npad->fullkey_lifo.ReadCurrentEntry().state.sampling_number + 1;
+    dummy_pad_state.sampling_number = npad->fullkey_lifo.ReadCurrentEntry().sampling_number + 1;
    npad->fullkey_lifo.WriteNextEntry(dummy_pad_state);
-    dummy_pad_state.sampling_number = npad->handheld_lifo.ReadCurrentEntry().state.sampling_number + 1;
+    dummy_pad_state.sampling_number = npad->handheld_lifo.ReadCurrentEntry().sampling_number + 1;
    npad->handheld_lifo.WriteNextEntry(dummy_pad_state);
-    dummy_pad_state.sampling_number = npad->joy_dual_lifo.ReadCurrentEntry().state.sampling_number + 1;
+    dummy_pad_state.sampling_number = npad->joy_dual_lifo.ReadCurrentEntry().sampling_number + 1;
    npad->joy_dual_lifo.WriteNextEntry(dummy_pad_state);
-    dummy_pad_state.sampling_number = npad->joy_left_lifo.ReadCurrentEntry().state.sampling_number + 1;
+    dummy_pad_state.sampling_number = npad->joy_left_lifo.ReadCurrentEntry().sampling_number + 1;
    npad->joy_left_lifo.WriteNextEntry(dummy_pad_state);
-    dummy_pad_state.sampling_number = npad->joy_right_lifo.ReadCurrentEntry().state.sampling_number + 1;
+    dummy_pad_state.sampling_number = npad->joy_right_lifo.ReadCurrentEntry().sampling_number + 1;
    npad->joy_right_lifo.WriteNextEntry(dummy_pad_state);
-    dummy_pad_state.sampling_number = npad->palma_lifo.ReadCurrentEntry().state.sampling_number + 1;
+    dummy_pad_state.sampling_number = npad->palma_lifo.ReadCurrentEntry().sampling_number + 1;
    npad->palma_lifo.WriteNextEntry(dummy_pad_state);
-    dummy_pad_state.sampling_number = npad->system_ext_lifo.ReadCurrentEntry().state.sampling_number + 1;
+    dummy_pad_state.sampling_number = npad->system_ext_lifo.ReadCurrentEntry().sampling_number + 1;
    npad->system_ext_lifo.WriteNextEntry(dummy_pad_state);
-    dummy_gc_state.sampling_number = npad->gc_trigger_lifo.ReadCurrentEntry().state.sampling_number + 1;
+    dummy_gc_state.sampling_number = npad->gc_trigger_lifo.ReadCurrentEntry().sampling_number + 1;
    npad->gc_trigger_lifo.WriteNextEntry(dummy_gc_state);
 }

@@ -1,11 +0,0 @@
-// SPDX-FileCopyrightText: Copyright 2026 Eden Emulator Project
-// SPDX-License-Identifier: GPL-3.0-or-later
-// SPDX-FileCopyrightText: Copyright 2024 Jarrod Norwell
-// SPDX-License-Identifier: GPL-2.0-or-later
-
-#ifndef AppUI_Bridging_Header_h
-#define AppUI_Bridging_Header_h
-
-#import "AppUIObjC.h"
-
-#endif /* AppUI_Bridging_Header_h */
@@ -1,113 +0,0 @@
-// SPDX-FileCopyrightText: Copyright 2026 Eden Emulator Project
-// SPDX-License-Identifier: GPL-3.0-or-later
-// SPDX-FileCopyrightText: Copyright 2024 Jarrod Norwell
-// SPDX-License-Identifier: GPL-2.0-or-later
-
-import UIKit
-import Foundation
-import QuartzCore.CAMetalLayer
-import SwiftUI
-
-public struct AppUI {
-    public static let shared = AppUI()
-    fileprivate let appUIObjC = AppUIObjC.shared()
-
-    public func configure(layer: CAMetalLayer, with size: CGSize) {
-        appUIObjC.configure(layer: layer, with: size)
-    }
-
-    public func information(for url: URL) -> AppUIInformation {
-        appUIObjC.gameInformation.information(for: url)
-    }
-
-    public func insert(game url: URL) {
-        appUIObjC.insert(game: url)
-    }
-
-    public func insert(games urls: [URL]) {
-        appUIObjC.insert(games: urls)
-    }
-
-    public func bootOS() {
-        appUIObjC.bootOS()
-    }
-
-    public func pause() {
-        appUIObjC.pause()
-    }
-
-    public func play() {
-        appUIObjC.play()
-    }
-
-    public func ispaused() -> Bool {
-        return appUIObjC.ispaused()
-    }
-
-    public func FirstFrameShowed() -> Bool {
-        return appUIObjC.hasfirstfame()
-    }
-
-    public func canGetFullPath() -> Bool {
-        return appUIObjC.canGetFullPath()
-    }
-
-
-    public func exit() {
-        appUIObjC.quit()
-    }
-
-    public func step() {
-        appUIObjC.step()
-    }
-
-    public func orientationChanged(orientation: UIInterfaceOrientation, with layer: CAMetalLayer, size: CGSize) {
-        appUIObjC.orientationChanged(orientation: orientation, with: layer, size: size)
-    }
-
-    public func touchBegan(at point: CGPoint, for index: UInt) {
-        appUIObjC.touchBegan(at: point, for: index)
-    }
-
-    public func touchEnded(for index: UInt) {
-        appUIObjC.touchEnded(for: index)
-    }
-
-    public func touchMoved(at point: CGPoint, for index: UInt) {
-        appUIObjC.touchMoved(at: point, for: index)
-    }
-
-    public func gyroMoved(x: Float, y: Float, z: Float, accelX: Float, accelY: Float, accelZ: Float, controllerId: Int32, deltaTimestamp: Int32) {
-        // Calling the Objective-C function with both gyroscope and accelerometer data
-        appUIObjC.virtualControllerGyro(controllerId,
-            deltaTimestamp: deltaTimestamp,
-            gyroX: x, gyroY: y, gyroZ: z,
-            accelX: accelX, accelY: accelY, accelZ: accelZ)
-    }
-
-
-    public func thumbstickMoved(analog: VirtualControllerAnalogType, x: Float, y: Float, controllerid: Int) {
-        appUIObjC.thumbstickMoved(analog, x: CGFloat(x), y: CGFloat(y), controllerId: Int32(controllerid))
-    }
-
-    public func virtualControllerButtonDown(button: VirtualControllerButtonType, controllerid: Int) {
-        appUIObjC.virtualControllerButtonDown(button, controllerId: Int32(controllerid))
-    }
-
-    public func virtualControllerButtonUp(button: VirtualControllerButtonType, controllerid: Int) {
-        appUIObjC.virtualControllerButtonUp(button, controllerId: Int32(controllerid))
-    }
-
-    public func settingsSaved() {
-        appUIObjC.settingsChanged()
-    }
-}
-
-struct EdenApp: App {
-    @StateObject private var core = EmulationViewModel()
-    var body: some Scene {
-        WindowGroup {
-            ContentView(core: core)
-        }
-    }
-}
@@ -1,26 +0,0 @@
-// SPDX-FileCopyrightText: Copyright 2026 Eden Emulator Project
-// SPDX-License-Identifier: GPL-3.0-or-later
-// SPDX-FileCopyrightText: Copyright 2024 Jarrod Norwell
-// SPDX-License-Identifier: GPL-2.0-or-later
-
-#import <Foundation/Foundation.h>
-
-NS_ASSUME_NONNULL_BEGIN
-
-@interface AppUIInformation : NSObject
-@property (nonatomic, strong) NSString *developer;
-@property (nonatomic, strong) NSData *iconData;
-@property (nonatomic) BOOL isHomebrew;
-@property (nonatomic) uint64_t programID;
-@property (nonatomic, strong) NSString *title, *version;
-
-(AppUIInformation *) initWithDeveloper:(NSString *)developer iconData:(NSData *)iconData isHomebrew:(BOOL)isHomebrew programID:(uint64_t)programID title:(NSString *)title version:(NSString *)version;
-@end
-
-@interface AppUIGameInformation : NSObject
-+(AppUIGameInformation *) sharedInstance NS_SWIFT_NAME(shared());
-
-(AppUIInformation *) informationForGame:(NSURL *)url NS_SWIFT_NAME(information(for:));
-@end
-
-NS_ASSUME_NONNULL_END
@@ -1,436 +0,0 @@
-// SPDX-FileCopyrightText: Copyright 2026 Eden Emulator Project
-// SPDX-License-Identifier: GPL-3.0-or-later
-// SPDX-FileCopyrightText: Copyright 2024 Jarrod Norwell
-// SPDX-License-Identifier: GPL-2.0-or-later
-
-#import <Foundation/Foundation.h>
-#import "AppUIGameInformation.h"
-#import "EmulationSession.h"
-
-#include "common/fs/fs.h"
-#include "common/fs/path_util.h"
-#include "core/core.h"
-#include "core/file_sys/fs_filesystem.h"
-#include "core/file_sys/patch_manager.h"
-#include "core/loader/loader.h"
-#include "core/loader/nro.h"
-#include "frontend_common/config.h"
-
-struct GameMetadata {
-    std::string title;
-    u64 programId;
-    std::string developer;
-    std::string version;
-    std::vector<u8> icon;
-    bool isHomebrew;
-};
-
-
-class SdlConfig final : public Config {
-public:
-    explicit SdlConfig(std::optional<std::string> config_path);
-    ~SdlConfig() override;
-
-    void ReloadAllValues() override;
-    void SaveAllValues() override;
-
-protected:
-    void ReadSdlValues();
-    void ReadSdlPlayerValues(std::size_t player_index);
-    void ReadSdlControlValues();
-    void ReadHidbusValues() override;
-    void ReadDebugControlValues() override;
-    void ReadPathValues() override {}
-    void ReadShortcutValues() override {}
-    void ReadUIValues() override {}
-    void ReadUIGamelistValues() override {}
-    void ReadUILayoutValues() override {}
-    void ReadMultiplayerValues() override {}
-
-    void SaveSdlValues();
-    void SaveSdlPlayerValues(std::size_t player_index);
-    void SaveSdlControlValues();
-    void SaveHidbusValues() override;
-    void SaveDebugControlValues() override;
-    void SavePathValues() override {}
-    void SaveShortcutValues() override {}
-    void SaveUIValues() override {}
-    void SaveUIGamelistValues() override {}
-    void SaveUILayoutValues() override {}
-    void SaveMultiplayerValues() override {}
-
-    std::vector<Settings::BasicSetting*>& FindRelevantList(Settings::Category category) override;
-
-public:
-    static const std::array<int, Settings::NativeButton::NumButtons> default_buttons;
-    static const std::array<int, Settings::NativeMotion::NumMotions> default_motions;
-    static const std::array<std::array<int, 4>, Settings::NativeAnalog::NumAnalogs> default_analogs;
-    static const std::array<int, 2> default_stick_mod;
-    static const std::array<int, 2> default_ringcon_analogs;
-};
-
-
-#define SDL_MAIN_HANDLED
-#include <SDL.h>
-
-#include "common/logging.h"
-#include "input_common/main.h"
-
-const std::array<int, Settings::NativeButton::NumButtons> SdlConfig::default_buttons = {
-    SDL_SCANCODE_A, SDL_SCANCODE_S, SDL_SCANCODE_Z, SDL_SCANCODE_X, SDL_SCANCODE_T,
-    SDL_SCANCODE_G, SDL_SCANCODE_F, SDL_SCANCODE_H, SDL_SCANCODE_Q, SDL_SCANCODE_W,
-    SDL_SCANCODE_M, SDL_SCANCODE_N, SDL_SCANCODE_1, SDL_SCANCODE_2, SDL_SCANCODE_B,
-};
-
-const std::array<int, Settings::NativeMotion::NumMotions> SdlConfig::default_motions = {
-    SDL_SCANCODE_7,
-    SDL_SCANCODE_8,
-};
-
-const std::array<std::array<int, 4>, Settings::NativeAnalog::NumAnalogs> SdlConfig::default_analogs{
-    {
-        {
-            SDL_SCANCODE_UP,
-            SDL_SCANCODE_DOWN,
-            SDL_SCANCODE_LEFT,
-            SDL_SCANCODE_RIGHT,
-        },
-        {
-            SDL_SCANCODE_I,
-            SDL_SCANCODE_K,
-            SDL_SCANCODE_J,
-            SDL_SCANCODE_L,
-        },
-    }};
-
-const std::array<int, 2> SdlConfig::default_stick_mod = {
-    SDL_SCANCODE_D,
-    0,
-};
-
-const std::array<int, 2> SdlConfig::default_ringcon_analogs{{
-    0,
-    0,
-}};
-
-SdlConfig::SdlConfig(const std::optional<std::string> config_path) {
-    Initialize(config_path);
-    ReadSdlValues();
-    SaveSdlValues();
-}
-
-SdlConfig::~SdlConfig() {
-    if (global) {
-        SdlConfig::SaveAllValues();
-    }
-}
-
-void SdlConfig::ReloadAllValues() {
-    Reload();
-    ReadSdlValues();
-    SaveSdlValues();
-}
-
-void SdlConfig::SaveAllValues() {
-    SaveValues();
-    SaveSdlValues();
-}
-
-void SdlConfig::ReadSdlValues() {
-    ReadSdlControlValues();
-}
-
-void SdlConfig::ReadSdlControlValues() {
-    BeginGroup(Settings::TranslateCategory(Settings::Category::Controls));
-
-    Settings::values.players.SetGlobal(!IsCustomConfig());
-    for (std::size_t p = 0; p < Settings::values.players.GetValue().size(); ++p) {
-        ReadSdlPlayerValues(p);
-    }
-    if (IsCustomConfig()) {
-        EndGroup();
-        return;
-    }
-    ReadDebugControlValues();
-    ReadHidbusValues();
-
-    EndGroup();
-}
-
-void SdlConfig::ReadSdlPlayerValues(const std::size_t player_index) {
-    std::string player_prefix;
-    if (type != ConfigType::InputProfile) {
-        player_prefix.append("player_").append(ToString(player_index)).append("_");
-    }
-
-    auto& player = Settings::values.players.GetValue()[player_index];
-    if (IsCustomConfig()) {
-        const auto profile_name =
-            ReadStringSetting(std::string(player_prefix).append("profile_name"));
-        if (profile_name.empty()) {
-            // Use the global input config
-            player = Settings::values.players.GetValue(true)[player_index];
-            player.profile_name = "";
-            return;
-        }
-    }
-
-    for (int i = 0; i < Settings::NativeButton::NumButtons; ++i) {
-        const std::string default_param = InputCommon::GenerateKeyboardParam(default_buttons[i]);
-        auto& player_buttons = player.buttons[i];
-
-        player_buttons = ReadStringSetting(
-            std::string(player_prefix).append(Settings::NativeButton::mapping[i]), default_param);
-        if (player_buttons.empty()) {
-            player_buttons = default_param;
-        }
-    }
-
-    for (int i = 0; i < Settings::NativeAnalog::NumAnalogs; ++i) {
-        const std::string default_param = InputCommon::GenerateAnalogParamFromKeys(
-            default_analogs[i][0], default_analogs[i][1], default_analogs[i][2],
-            default_analogs[i][3], default_stick_mod[i], 0.5f);
-        auto& player_analogs = player.analogs[i];
-
-        player_analogs = ReadStringSetting(
-            std::string(player_prefix).append(Settings::NativeAnalog::mapping[i]), default_param);
-        if (player_analogs.empty()) {
-            player_analogs = default_param;
-        }
-    }
-
-    for (int i = 0; i < Settings::NativeMotion::NumMotions; ++i) {
-        const std::string default_param = InputCommon::GenerateKeyboardParam(default_motions[i]);
-        auto& player_motions = player.motions[i];
-
-        player_motions = ReadStringSetting(
-            std::string(player_prefix).append(Settings::NativeMotion::mapping[i]), default_param);
-        if (player_motions.empty()) {
-            player_motions = default_param;
-        }
-    }
-}
-
-void SdlConfig::ReadDebugControlValues() {
-    for (int i = 0; i < Settings::NativeButton::NumButtons; ++i) {
-        const std::string default_param = InputCommon::GenerateKeyboardParam(default_buttons[i]);
-        auto& debug_pad_buttons = Settings::values.debug_pad_buttons[i];
-        debug_pad_buttons = ReadStringSetting(
-            std::string("debug_pad_").append(Settings::NativeButton::mapping[i]), default_param);
-        if (debug_pad_buttons.empty()) {
-            debug_pad_buttons = default_param;
-        }
-    }
-    for (int i = 0; i < Settings::NativeAnalog::NumAnalogs; ++i) {
-        const std::string default_param = InputCommon::GenerateAnalogParamFromKeys(
-            default_analogs[i][0], default_analogs[i][1], default_analogs[i][2],
-            default_analogs[i][3], default_stick_mod[i], 0.5f);
-        auto& debug_pad_analogs = Settings::values.debug_pad_analogs[i];
-        debug_pad_analogs = ReadStringSetting(
-            std::string("debug_pad_").append(Settings::NativeAnalog::mapping[i]), default_param);
-        if (debug_pad_analogs.empty()) {
-            debug_pad_analogs = default_param;
-        }
-    }
-}
-
-void SdlConfig::ReadHidbusValues() {
-    const std::string default_param = InputCommon::GenerateAnalogParamFromKeys(
-        0, 0, default_ringcon_analogs[0], default_ringcon_analogs[1], 0, 0.05f);
-    auto& ringcon_analogs = Settings::values.ringcon_analogs;
-
-    ringcon_analogs = ReadStringSetting(std::string("ring_controller"), default_param);
-    if (ringcon_analogs.empty()) {
-        ringcon_analogs = default_param;
-    }
-}
-
-void SdlConfig::SaveSdlValues() {
-    LOG_DEBUG(Config, "Saving SDL configuration values");
-    SaveSdlControlValues();
-
-    WriteToIni();
-}
-
-void SdlConfig::SaveSdlControlValues() {
-    BeginGroup(Settings::TranslateCategory(Settings::Category::Controls));
-
-    Settings::values.players.SetGlobal(!IsCustomConfig());
-    for (std::size_t p = 0; p < Settings::values.players.GetValue().size(); ++p) {
-        SaveSdlPlayerValues(p);
-    }
-    if (IsCustomConfig()) {
-        EndGroup();
-        return;
-    }
-    SaveDebugControlValues();
-    SaveHidbusValues();
-
-    EndGroup();
-}
-
-void SdlConfig::SaveSdlPlayerValues(const std::size_t player_index) {
-    std::string player_prefix;
-    if (type != ConfigType::InputProfile) {
-        player_prefix = std::string("player_").append(ToString(player_index)).append("_");
-    }
-
-    const auto& player = Settings::values.players.GetValue()[player_index];
-    if (IsCustomConfig() && player.profile_name.empty()) {
-        // No custom profile selected
-        return;
-    }
-
-    for (int i = 0; i < Settings::NativeButton::NumButtons; ++i) {
-        const std::string default_param = InputCommon::GenerateKeyboardParam(default_buttons[i]);
-        WriteStringSetting(std::string(player_prefix).append(Settings::NativeButton::mapping[i]),
-                           player.buttons[i], std::make_optional(default_param));
-    }
-    for (int i = 0; i < Settings::NativeAnalog::NumAnalogs; ++i) {
-        const std::string default_param = InputCommon::GenerateAnalogParamFromKeys(
-            default_analogs[i][0], default_analogs[i][1], default_analogs[i][2],
-            default_analogs[i][3], default_stick_mod[i], 0.5f);
-        WriteStringSetting(std::string(player_prefix).append(Settings::NativeAnalog::mapping[i]),
-                           player.analogs[i], std::make_optional(default_param));
-    }
-    for (int i = 0; i < Settings::NativeMotion::NumMotions; ++i) {
-        const std::string default_param = InputCommon::GenerateKeyboardParam(default_motions[i]);
-        WriteStringSetting(std::string(player_prefix).append(Settings::NativeMotion::mapping[i]),
-                           player.motions[i], std::make_optional(default_param));
-    }
-}
-
-void SdlConfig::SaveDebugControlValues() {
-    for (int i = 0; i < Settings::NativeButton::NumButtons; ++i) {
-        const std::string default_param = InputCommon::GenerateKeyboardParam(default_buttons[i]);
-        WriteStringSetting(std::string("debug_pad_").append(Settings::NativeButton::mapping[i]),
-                           Settings::values.debug_pad_buttons[i],
-                           std::make_optional(default_param));
-    }
-    for (int i = 0; i < Settings::NativeAnalog::NumAnalogs; ++i) {
-        const std::string default_param = InputCommon::GenerateAnalogParamFromKeys(
-            default_analogs[i][0], default_analogs[i][1], default_analogs[i][2],
-            default_analogs[i][3], default_stick_mod[i], 0.5f);
-        WriteStringSetting(std::string("debug_pad_").append(Settings::NativeAnalog::mapping[i]),
-                           Settings::values.debug_pad_analogs[i],
-                           std::make_optional(default_param));
-    }
-}
-
-void SdlConfig::SaveHidbusValues() {
-    const std::string default_param = InputCommon::GenerateAnalogParamFromKeys(
-        0, 0, default_ringcon_analogs[0], default_ringcon_analogs[1], 0, 0.05f);
-    WriteStringSetting(std::string("ring_controller"), Settings::values.ringcon_analogs,
-                       std::make_optional(default_param));
-}
-
-std::vector<Settings::BasicSetting*>& SdlConfig::FindRelevantList(Settings::Category category) {
-    return Settings::values.linkage.by_category[category];
-}
-
-
-
-
-
-
-
-std::unordered_map<std::string, GameMetadata> m_game_metadata_cache;
-
-GameMetadata CacheGameMetadata(const std::string& path) {
-    const auto file =
-        Core::GetGameFileFromPath(EmulationSession::GetInstance().System().GetFilesystem(), path);
-    auto loader = Loader::GetLoader(EmulationSession::GetInstance().System(), file, 0, 0);
-
-    GameMetadata entry;
-    loader->ReadTitle(entry.title);
-    loader->ReadProgramId(entry.programId);
-    loader->ReadIcon(entry.icon);
-
-    const FileSys::PatchManager pm{
-        entry.programId, EmulationSession::GetInstance().System().GetFileSystemController(),
-        EmulationSession::GetInstance().System().GetContentProvider()};
-    const auto control = pm.GetControlMetadata();
-
-    if (control.first != nullptr) {
-        entry.developer = control.first->GetDeveloperName();
-        entry.version = control.first->GetVersionString();
-    } else {
-        FileSys::NACP nacp;
-        if (loader->ReadControlData(nacp) == Loader::ResultStatus::Success) {
-            entry.developer = nacp.GetDeveloperName();
-        } else {
-            entry.developer = "";
-        }
-
-        entry.version = "1.0.0";
-    }
-
-    if (loader->GetFileType() == Loader::FileType::NRO) {
-        auto loader_nro = reinterpret_cast<Loader::AppLoader_NRO*>(loader.get());
-        entry.isHomebrew = loader_nro->IsHomebrew();
-    } else {
-        entry.isHomebrew = false;
-    }
-
-    m_game_metadata_cache[path] = entry;
-
-    return entry;
-}
-
-GameMetadata GameMetadata(const std::string& path, bool reload = false) {
-    if (!EmulationSession::GetInstance().IsInitialized()) {
-        NSURL *dir_url = [[[NSFileManager defaultManager] URLsForDirectory:NSDocumentDirectory inDomains:NSUserDomainMask] firstObject];
-        const char *directory_cstr = [[dir_url path] UTF8String];
-        Common::FS::SetAppDirectory(directory_cstr);
-
-        EmulationSession::GetInstance().System().Initialize();
-        EmulationSession::GetInstance().InitializeSystem(false);
-    }
-
-    if (reload) {
-        return CacheGameMetadata(path);
-    }
-
-    if (auto search = m_game_metadata_cache.find(path); search != m_game_metadata_cache.end()) {
-        return search->second;
-    }
-
-    return CacheGameMetadata(path);
-}
-
-
-@implementation AppUIInformation
-(AppUIInformation *) initWithDeveloper:(NSString *)developer iconData:(NSData *)iconData isHomebrew:(BOOL)isHomebrew programID:(uint64_t)programID
-                                    title:(NSString *)title version:(NSString *)version {
-    if (self = [super init]) {
-        self.developer = developer;
-        self.iconData = iconData;
-        self.isHomebrew = isHomebrew;
-        self.programID = programID;
-        self.title = title;
-        self.version = version;
-    } return self;
-}
-@end
-
-@implementation AppUIGameInformation
-+(AppUIGameInformation *) sharedInstance {
-    static AppUIGameInformation *sharedInstance = NULL;
-    static dispatch_once_t onceToken;
-    dispatch_once(&onceToken, ^{
-        sharedInstance = [[self alloc] init];
-    });
-    return sharedInstance;
-}
-
-
-(AppUIInformation *) informationForGame:(NSURL *)url {
-    auto gameMetadata = GameMetadata([url.path UTF8String]);
-
-    return [[AppUIInformation alloc] initWithDeveloper:[NSString stringWithCString:gameMetadata.developer.c_str() encoding:NSUTF8StringEncoding]
-                                                iconData:[NSData dataWithBytes:gameMetadata.icon.data() length:gameMetadata.icon.size()]
-                                              isHomebrew:gameMetadata.isHomebrew programID:gameMetadata.programId
-                                                   title:[NSString stringWithCString:gameMetadata.title.c_str() encoding:NSUTF8StringEncoding]
-                                                 version:[NSString stringWithCString:gameMetadata.version.c_str() encoding:NSUTF8StringEncoding]];
-}
-@end
@@ -1,93 +0,0 @@
-// SPDX-FileCopyrightText: Copyright 2026 Eden Emulator Project
-// SPDX-License-Identifier: GPL-3.0-or-later
-// SPDX-FileCopyrightText: Copyright 2024 Jarrod Norwell
-// SPDX-License-Identifier: GPL-2.0-or-later
-
-#import <Foundation/Foundation.h>
-#import <MetalKit/MetalKit.h>
-#import <UIKit/UIKit.h>
-
-#import "AppUIGameInformation.h"
-
-NS_ASSUME_NONNULL_BEGIN
-
-typedef NS_ENUM(NSUInteger, VirtualControllerAnalogType) {
-    VirtualControllerAnalogTypeLeft = 0,
-    VirtualControllerAnalogTypeRight = 1
-};
-
-typedef NS_ENUM(NSUInteger, VirtualControllerButtonType) {
-    VirtualControllerButtonTypeA = 0,
-    VirtualControllerButtonTypeB = 1,
-    VirtualControllerButtonTypeX = 2,
-    VirtualControllerButtonTypeY = 3,
-    VirtualControllerButtonTypeL = 4,
-    VirtualControllerButtonTypeR = 5,
-    VirtualControllerButtonTypeTriggerL = 6,
-    VirtualControllerButtonTypeTriggerR = 7,
-    VirtualControllerButtonTypeTriggerZL = 8,
-    VirtualControllerButtonTypeTriggerZR = 9,
-    VirtualControllerButtonTypePlus = 10,
-    VirtualControllerButtonTypeMinus = 11,
-    VirtualControllerButtonTypeDirectionalPadLeft = 12,
-    VirtualControllerButtonTypeDirectionalPadUp = 13,
-    VirtualControllerButtonTypeDirectionalPadRight = 14,
-    VirtualControllerButtonTypeDirectionalPadDown = 15,
-    VirtualControllerButtonTypeSL = 16,
-    VirtualControllerButtonTypeSR = 17,
-    VirtualControllerButtonTypeHome = 18,
-    VirtualControllerButtonTypeCapture = 19
-};
-
-@interface AppUIObjC : NSObject {
-    CAMetalLayer *_layer;
-    CGSize _size;
-}
-
-@property (nonatomic, strong) AppUIGameInformation *gameInformation;
-
-+(AppUIObjC *) sharedInstance NS_SWIFT_NAME(shared());
-(void) configureLayer:(CAMetalLayer *)layer withSize:(CGSize)size NS_SWIFT_NAME(configure(layer:with:));
-(void) bootOS;
-(void) pause;
-(void) play;
-(BOOL) ispaused;
-(BOOL) canGetFullPath;
-(void) quit;
-(void) insertGame:(NSURL *)url NS_SWIFT_NAME(insert(game:));
-(void) insertGames:(NSArray<NSURL *> *)games NS_SWIFT_NAME(insert(games:));
-(void) step;
-(BOOL) hasfirstfame;
-
-(void) touchBeganAtPoint:(CGPoint)point index:(NSUInteger)index NS_SWIFT_NAME(touchBegan(at:for:));
-(void) touchEndedForIndex:(NSUInteger)index;
-(void) touchMovedAtPoint:(CGPoint)point index:(NSUInteger)index NS_SWIFT_NAME(touchMoved(at:for:));
-
-(void) thumbstickMoved:(VirtualControllerAnalogType)analog
-                      x:(CGFloat)x
-                      y:(CGFloat)y
-             controllerId:(int)controllerId;
-
-(void) virtualControllerGyro:(int)controllerId
-            deltaTimestamp:(int)delta_timestamp
-                    gyroX:(float)gyro_x
-                    gyroY:(float)gyro_y
-                    gyroZ:(float)gyro_z
-                  accelX:(float)accel_x
-                  accelY:(float)accel_y
-                       accelZ:(float)accel_z;
-
-(void) virtualControllerButtonDown:(VirtualControllerButtonType)button
-                       controllerId:(int)controllerId;
-
-(void) virtualControllerButtonUp:(VirtualControllerButtonType)button
-                     controllerId:(int)controllerId;
-
-
-(void) orientationChanged:(UIInterfaceOrientation)orientation with:(CAMetalLayer *)layer size:(CGSize)size NS_SWIFT_NAME(orientationChanged(orientation:with:size:));
-
-(void) settingsChanged;
-
-@end
-
-NS_ASSUME_NONNULL_END
@@ -1,251 +0,0 @@
-// SPDX-FileCopyrightText: Copyright 2026 Eden Emulator Project
-// SPDX-License-Identifier: GPL-3.0-or-later
-// SPDX-FileCopyrightText: Copyright 2024 Jarrod Norwell
-// SPDX-License-Identifier: GPL-2.0-or-later
-
-#import "AppUIObjC.h"
-
-#import "Config.h"
-#import "EmulationSession.h"
-
-#include "common/fs/fs.h"
-#include "common/fs/path_util.h"
-#include "common/settings.h"
-#include "common/fs/fs.h"
-#include "core/file_sys/patch_manager.h"
-#include "core/file_sys/savedata_factory.h"
-#include "core/loader/nro.h"
-#include "frontend_common/content_manager.h"
-#include "common/settings_enums.h"
-#include "network/announce_multiplayer_session.h"
-#include "common/announce_multiplayer_room.h"
-#include "network/network.h"
-
-#include "common/detached_tasks.h"
-#include "common/dynamic_library.h"
-#include "common/fs/path_util.h"
-#include "common/logging.h"
-#include "common/scope_exit.h"
-#include "common/settings.h"
-#include "common/string_util.h"
-#include "core/core.h"
-#include "core/cpu_manager.h"
-#include "core/crypto/key_manager.h"
-#include "core/file_sys/card_image.h"
-#include "core/file_sys/content_archive.h"
-#include "core/file_sys/fs_filesystem.h"
-#include "core/file_sys/submission_package.h"
-#include "core/file_sys/vfs/vfs.h"
-#include "core/file_sys/vfs/vfs_real.h"
-#include "core/frontend/applets/cabinet.h"
-#include "core/frontend/applets/controller.h"
-#include "core/frontend/applets/error.h"
-#include "core/frontend/applets/general.h"
-#include "core/frontend/applets/mii_edit.h"
-#include "core/frontend/applets/profile_select.h"
-#include "core/frontend/applets/software_keyboard.h"
-#include "core/frontend/applets/web_browser.h"
-#include "core/hle/service/am/applet_manager.h"
-#include "core/hle/service/am/frontend/applets.h"
-#include "core/hle/service/filesystem/filesystem.h"
-#include "core/loader/loader.h"
-#include "hid_core/hid_core.h"
-#include "hid_core/hid_types.h"
-#include "video_core/renderer_base.h"
-#include "video_core/renderer_vulkan/renderer_vulkan.h"
-#include "video_core/vulkan_common/vulkan_instance.h"
-#include "video_core/vulkan_common/vulkan_surface.h"
-
-
-#import <mach/mach.h>
-
-@implementation AppUIObjC
-(AppUIObjC *) init {
-    if (self = [super init]) {
-        _gameInformation = [AppUIGameInformation sharedInstance];
-
-        NSURL *dir_url = [[[NSFileManager defaultManager] URLsForDirectory:NSDocumentDirectory inDomains:NSUserDomainMask] firstObject];
-        const char *directory_cstr = [[dir_url path] UTF8String];
-
-        Common::FS::SetAppDirectory(directory_cstr);
-        // Config{"config", Config::ConfigType::GlobalConfig};
-
-        EmulationSession::GetInstance().System().Initialize();
-        EmulationSession::GetInstance().InitializeSystem(false);
-        EmulationSession::GetInstance().InitializeGpuDriver();
-
-
-        Settings::values.dump_shaders.SetValue(true);
-        Settings::values.use_asynchronous_shaders.SetValue(true);
-        // Settings::values.astc_recompression.SetValue(Settings::AstcRecompression::Bc3);
-        // Settings::values.resolution_setup.SetValue(Settings::ResolutionSetup::Res1X);
-        // Settings::values.scaling_filter.SetValue(Settings::ScalingFilter::Bilinear);
-    } return self;
-}
-
-
-+(AppUIObjC *) sharedInstance {
-    static AppUIObjC *sharedInstance = NULL;
-    static dispatch_once_t onceToken;
-    dispatch_once(&onceToken, ^{
-        sharedInstance = [[self alloc] init];
-    });
-    return sharedInstance;
-}
-
- (BOOL)ispaused {
-    return EmulationSession::GetInstance().IsPaused();
-}
-
-(void) pause {
-    EmulationSession::GetInstance().System().Pause();
-    EmulationSession::GetInstance().HaltEmulation();
-    EmulationSession::GetInstance().PauseEmulation();
-}
-
-(void) play {
-
-    EmulationSession::GetInstance().System().Run();
-    EmulationSession::GetInstance().RunEmulation();
-    EmulationSession::GetInstance().UnPauseEmulation();
-}
-
-(BOOL)hasfirstfame {
-    @try {
-        auto* window = &EmulationSession::GetInstance().Window();
-        if (window && window->HasFirstFrame()) {
-            return YES;
-        }
-    }
-    @catch (NSException *exception) {
-        NSLog(@"Exception occurred: %@", exception);
-        // Handle the exception, maybe return a default value
-        return NO;
-    }
-    return NO;
-}
-
- (BOOL)canGetFullPath {
-    @try {
-        Core::System& system = EmulationSession::GetInstance().System();
-        auto bis_system = system.GetFileSystemController().GetSystemNANDContents();
-
-        if (bis_system == nullptr) {
-            return NO;
-        }
-
-        constexpr u64 QLaunchId = static_cast<u64>(Service::AM::AppletProgramId::QLaunch);
-        auto qlaunch_applet_nca = bis_system->GetEntry(QLaunchId, FileSys::ContentRecordType::Program);
-
-        if (qlaunch_applet_nca == nullptr) {
-            return NO;
-        }
-
-        const auto filename = qlaunch_applet_nca->GetFullPath();
-
-        // If GetFullPath() is successful
-        return YES;
-    } @catch (NSException *exception) {
-        // Handle the exception if needed
-        return NO;
-    }
-}
-
-(void) quit {
-    EmulationSession::GetInstance().ShutdownEmulation();
-}
-
-(void) configureLayer:(CAMetalLayer *)layer withSize:(CGSize)size {
-    _layer = layer;
-    _size = size;
-    EmulationSession::GetInstance().SetNativeWindow(layer, size);
-}
-
-(void) bootOS {
-    EmulationSession::GetInstance().BootOS();
-}
-
-(void) insertGame:(NSURL *)url {
-    EmulationSession::GetInstance().InitializeEmulation([url.path UTF8String], [_gameInformation informationForGame:url].programID, true);
-}
-
-(void) insertGames:(NSArray<NSURL *> *)games {
-    for (NSURL *url in games) {
-        EmulationSession::GetInstance().ConfigureFilesystemProvider([url.path UTF8String]);
-    }
-}
-
-(void) step {
-    void(EmulationSession::GetInstance().System().Run());
-}
-
-(void) touchBeganAtPoint:(CGPoint)point index:(NSUInteger)index {
-    float h_ratio, w_ratio;
-    h_ratio = EmulationSession::GetInstance().Window().GetFramebufferLayout().height / (_size.height * [[UIScreen mainScreen] nativeScale]);
-    w_ratio = EmulationSession::GetInstance().Window().GetFramebufferLayout().width / (_size.width * [[UIScreen mainScreen] nativeScale]);
-
-    EmulationSession::GetInstance().Window().OnTouchPressed([[NSNumber numberWithUnsignedInteger:index] intValue],
-                                                            (point.x) * [[UIScreen mainScreen] nativeScale] * w_ratio,
-                                                            ((point.y) * [[UIScreen mainScreen] nativeScale] * h_ratio));
-}
-
-(void) touchEndedForIndex:(NSUInteger)index {
-    EmulationSession::GetInstance().Window().OnTouchReleased([[NSNumber numberWithUnsignedInteger:index] intValue]);
-}
-
-(void) touchMovedAtPoint:(CGPoint)point index:(NSUInteger)index {
-    float h_ratio, w_ratio;
-    h_ratio = EmulationSession::GetInstance().Window().GetFramebufferLayout().height / (_size.height * [[UIScreen mainScreen] nativeScale]);
-    w_ratio = EmulationSession::GetInstance().Window().GetFramebufferLayout().width / (_size.width * [[UIScreen mainScreen] nativeScale]);
-
-    EmulationSession::GetInstance().Window().OnTouchMoved([[NSNumber numberWithUnsignedInteger:index] intValue],
-                                                          (point.x) * [[UIScreen mainScreen] nativeScale] * w_ratio,
-                                                          ((point.y) * [[UIScreen mainScreen] nativeScale] * h_ratio));
-}
-
-(void) thumbstickMoved:(VirtualControllerAnalogType)analog
-                      x:(CGFloat)x
-                      y:(CGFloat)y
-           controllerId:(int)controllerId {
-    EmulationSession::GetInstance().OnGamepadConnectEvent(controllerId);
-    EmulationSession::GetInstance().Window().OnGamepadJoystickEvent(controllerId, [[NSNumber numberWithUnsignedInteger:analog] intValue], CGFloat(x), CGFloat(y));
-}
-
-(void) virtualControllerButtonDown:(VirtualControllerButtonType)button
-                       controllerId:(int)controllerId {
-    EmulationSession::GetInstance().OnGamepadConnectEvent(controllerId);
-    EmulationSession::GetInstance().Window().OnGamepadButtonEvent(controllerId, [[NSNumber numberWithUnsignedInteger:button] intValue], true);
-}
-
-(void) virtualControllerGyro:(int)controllerId
-            deltaTimestamp:(int)delta_timestamp
-                    gyroX:(float)gyro_x
-                    gyroY:(float)gyro_y
-                    gyroZ:(float)gyro_z
-                  accelX:(float)accel_x
-                  accelY:(float)accel_y
-                  accelZ:(float)accel_z
-{
-    EmulationSession::GetInstance().OnGamepadConnectEvent(controllerId);
-    EmulationSession::GetInstance().Window().OnGamepadMotionEvent(controllerId, delta_timestamp, gyro_x, gyro_y, gyro_z, accel_x, accel_y, accel_z);
-}
-
-
-(void) virtualControllerButtonUp:(VirtualControllerButtonType)button
-                     controllerId:(int)controllerId {
-    EmulationSession::GetInstance().OnGamepadConnectEvent(controllerId);
-    EmulationSession::GetInstance().Window().OnGamepadButtonEvent(controllerId, [[NSNumber numberWithUnsignedInteger:button] intValue], false);
-}
-
-
-(void) orientationChanged:(UIInterfaceOrientation)orientation with:(CAMetalLayer *)layer size:(CGSize)size {
-    _layer = layer;
-    _size = size;
-    EmulationSession::GetInstance().Window().OnSurfaceChanged(layer, size);
-}
-
-(void) settingsChanged {
-    //
-}
-
-@end
@@ -1,86 +0,0 @@
-# SPDX-FileCopyrightText: Copyright 2026 Eden Emulator Project
-# SPDX-License-Identifier: GPL-3.0-or-later
-
-enable_language(Swift OBJCXX)
-add_executable(eden-ios
-    AppUI-Bridging-Header.h
-    AppUI.swift
-    AppUIGameInformation.h
-    AppUIGameInformation.mm
-    AppUIObjC.h
-    AppUIObjC.mm
-    Config.h
-    Config.mm
-    EmulationSession.h
-    EmulationSession.mm
-    EmulationWindow.h
-    EmulationWindow.mm
-    VMA.cpp
-
-    EmulationGame.swift
-    JoystickView.swift
-    EmulationHandler.swift
-    PomeloApp.swift
-    FileManager.swift
-    EmulationView.swift
-    LibraryView.swift
-    KeyboardHostingController.swift
-    FolderMonitor.swift
-    GameButtonView.swift
-    EmulationScreenView.swift
-    GameListView.swift
-
-    # Extensions
-    SwiftUIJoystick.swift
-)
-
-set(MACOSX_BUNDLE_GUI_IDENTIFIER "dev.eden-emu.eden")
-set(MACOSX_BUNDLE_BUNDLE_NAME "Eden")
-set(MACOSX_BUNDLE_INFO_STRING "Eden: A high-performance Nintendo Switch emulator")
-
-# TODO(crueter): Copyright, and versioning
-
-# Keep bundle identifier as-is, for compatibility sake
-set_target_properties(eden-ios PROPERTIES
-    XCODE_ATTRIBUTE_SWIFT_OBJC_BRIDGING_HEADER "${CMAKE_CURRENT_SOURCE_DIR}/AppUI-Bridging-Header.h"
-    XCODE_ATTRIBUTE_SWIFT_OBJC_INTERFACE_HEADER_NAME "eden-ios-Swift.h"
-    XCODE_ATTRIBUTE_DERIVED_FILE_DIR "${CMAKE_CURRENT_BINARY_DIR}")
-
-target_link_libraries(eden-ios PRIVATE common core input_common frontend_common video_core sirit::sirit)
-target_link_libraries(eden-ios PRIVATE ${PLATFORM_LIBRARIES} Threads::Threads)
-target_link_libraries(eden-ios PRIVATE SDL3::SDL3 glad stb::headers)
-create_target_directory_groups(eden-ios)
-
-# FIXME(crueter): This should /all/ be in a module of some kind!
-
-# Xcode will automatically generate the Assets.car and icns file for us.
-set(_dist "${CMAKE_SOURCE_DIR}/dist")
-if (CMAKE_GENERATOR MATCHES "Xcode")
-    set(_icons "${_dist}/eden.icon")
-
-    set_target_properties(eden-ios PROPERTIES
-        XCODE_ATTRIBUTE_ASSETCATALOG_COMPILER_APPICON_NAME eden
-        MACOSX_BUNDLE_ICON_FILE eden
-        # Also force xcode to manage signing for us.
-        XCODE_ATTRIBUTE_CODE_SIGNING_REQUIRED ON
-        XCODE_ATTRIBUTE_CODE_SIGNING_ALLOWED ON
-        XCODE_ATTRIBUTE_CODE_SIGN_STYLE Automatic)
-# Otherwise, we'll use our own.
-else()
-    set(_icons "${_dist}/eden.icns" "${_dist}/Assets.car")
-endif()
-
-set_source_files_properties(${_icons} PROPERTIES
-    MACOSX_PACKAGE_LOCATION Resources)
-target_sources(eden-ios PRIVATE ${_icons})
-
-set_target_properties(eden-ios PROPERTIES MACOSX_BUNDLE TRUE)
-
-set(CMAKE_FIND_LIBRARY_SUFFIXES ".dylib")
-find_library(MOLTENVK_LIBRARY MoltenVK REQUIRED)
-message(STATUS "Using MoltenVK at ${MOLTENVK_LIBRARY}.")
-
-set_source_files_properties(${MOLTENVK_LIBRARY} PROPERTIES
-    MACOSX_PACKAGE_LOCATION Frameworks
-    XCODE_FILE_ATTRIBUTES "CodeSignOnCopy")
-target_sources(eden-ios PRIVATE ${MOLTENVK_LIBRARY})
@@ -1,19 +0,0 @@
-// SPDX-FileCopyrightText: Copyright 2026 Eden Emulator Project
-// SPDX-License-Identifier: GPL-3.0-or-later
-
-#pragma once
-
-#include <common/settings_common.h>
-#include "common/common_types.h"
-#include "common/settings_setting.h"
-#include "common/settings_enums.h"
-
-namespace IOSSettings {
-    struct Values {
-        Settings::Linkage linkage;
-        Settings::Setting<bool> touchscreen{linkage, true, "touchscreen", Settings::Category::Overlay};
-    };
-
-    extern Values values;
-
-} // namespace IOSSettings
@@ -1,11 +0,0 @@
-// SPDX-FileCopyrightText: Copyright 2026 Eden Emulator Project
-// SPDX-License-Identifier: GPL-3.0-or-later
-
-
-#include "Config.h"
-
-namespace IOSSettings {
-
-Values values;
-
-} // namespace IOSSettings
@@ -1,31 +0,0 @@
-// SPDX-FileCopyrightText: Copyright 2026 Eden Emulator Project
-// SPDX-License-Identifier: GPL-3.0-or-later
-// SPDX-FileCopyrightText: Copyright 2024 Pomelo, Stossy11
-// SPDX-License-Identifier: GPL-3.0-or-later
-
-import Foundation
-
-struct EmulationGame : Comparable, Hashable, Identifiable {
-    var id = UUID()
-
-    let developer: String
-    let fileURL: URL
-    let imageData: Data
-    let title: String
-
-    func hash(into hasher: inout Hasher) {
-        hasher.combine(id)
-        hasher.combine(developer)
-        hasher.combine(fileURL)
-        hasher.combine(imageData)
-        hasher.combine(title)
-    }
-
-    static func < (lhs: EmulationGame, rhs: EmulationGame) -> Bool {
-        lhs.title < rhs.title
-    }
-
-    static func == (lhs: EmulationGame, rhs: EmulationGame) -> Bool {
-        lhs.title == rhs.title
-    }
-}
@@ -1,96 +0,0 @@
-// SPDX-FileCopyrightText: Copyright 2026 Eden Emulator Project
-// SPDX-License-Identifier: GPL-3.0-or-later
-// SPDX-FileCopyrightText: Copyright 2024 Pomelo, Stossy11
-// SPDX-License-Identifier: GPL-3.0-or-later
-
-import SwiftUI
-
-import Metal
-import Foundation
-
-class EmulationSessionViewModel: ObservableObject {
-    @Published var isShowingCustomButton = true
-    @State var should = false
-    var device: MTLDevice?
-    @State var mtkView: MTKView = MTKView()
-    var CaLayer: CAMetalLayer?
-    private var sudachiGame: EmulationGame?
-    private let appui = AppUI.shared
-    private var thread: Thread!
-    private var isRunning = false
-    var doesneedresources = false
-    @State var iscustom: Bool = false
-
-    init(game: EmulationGame?) {
-        self.device = MTLCreateSystemDefaultDevice()
-        self.sudachiGame = game
-    }
-
-    func configureAppUI(with mtkView: MTKView) {
-        self.mtkView = mtkView
-        device = self.mtkView.device
-        guard !isRunning else { return }
-        isRunning = true
-        appui.configure(layer: mtkView.layer as! CAMetalLayer, with: mtkView.frame.size)
-
-        iscustom = ((sudachiGame?.fileURL.startAccessingSecurityScopedResource()) != nil)
-
-        DispatchQueue.global(qos: .userInitiated).async { [self] in
-            if let sudachiGame = self.sudachiGame {
-                self.appui.insert(game: sudachiGame.fileURL)
-            } else {
-                self.appui.bootOS()
-            }
-        }
-
-        thread = .init(block: self.step)
-        thread.name = "Yuzu"
-        thread.qualityOfService = .userInteractive
-        thread.threadPriority = 0.9
-        thread.start()
-    }
-
-    private func step() {
-        while true {
-            appui.step()
-        }
-    }
-
-    func customButtonTapped() {
-        stopEmulation()
-    }
-
-    private func stopEmulation() {
-        if isRunning {
-            isRunning = false
-            appui.exit()
-            thread.cancel()
-            if iscustom {
-                sudachiGame?.fileURL.stopAccessingSecurityScopedResource()
-            }
-        }
-    }
-
-    func handleOrientationChange() {
-        DispatchQueue.main.async { [weak self] in
-            guard let self = self else { return }
-            let interfaceOrientation = self.getInterfaceOrientation(from: UIDevice.current.orientation)
-            self.appui.orientationChanged(orientation: interfaceOrientation, with: self.mtkView.layer as! CAMetalLayer, size: mtkView.frame.size)
-        }
-    }
-
-    private func getInterfaceOrientation(from deviceOrientation: UIDeviceOrientation) -> UIInterfaceOrientation {
-        switch deviceOrientation {
-        case .portrait:
-            return .portrait
-        case .portraitUpsideDown:
-            return .portraitUpsideDown
-        case .landscapeLeft:
-            return .landscapeRight
-        case .landscapeRight:
-            return .landscapeLeft
-        default:
-            return .unknown
-        }
-    }
-}
@@ -1,133 +0,0 @@
-// SPDX-FileCopyrightText: Copyright 2026 Eden Emulator Project
-// SPDX-License-Identifier: GPL-3.0-or-later
-// SPDX-FileCopyrightText: Copyright 2024 Pomelo, Stossy11
-// SPDX-License-Identifier: GPL-3.0-or-later
-
-import SwiftUI
-
-import MetalKit
-
-class EmulationScreenView: UIView {
-    var primaryScreen: UIView!
-    var portraitconstraints = [NSLayoutConstraint]()
-    var landscapeconstraints = [NSLayoutConstraint]()
-    var fullscreenconstraints = [NSLayoutConstraint]()
-    let appui = AppUI.shared
-    let userDefaults = UserDefaults.standard
-
-    override init(frame: CGRect) {
-        super.init(frame: frame)
-        if UIDevice.current.userInterfaceIdiom == .pad {
-            setupAppUIScreenforiPad()
-        } else {
-            setupAppUIScreen()
-        }
-    }
-
-    required init?(coder: NSCoder) {
-        super.init(coder: coder)
-        if UIDevice.current.userInterfaceIdiom == .pad {
-            setupAppUIScreenforiPad()
-        } else {
-            setupAppUIScreen()
-        }
-
-    }
-
-    override func touchesBegan(_ touches: Set<UITouch>, with event: UIEvent?) {
-        super.touchesBegan(touches, with: event)
-        guard let touch = touches.first else {
-            return
-        }
-
-        print("Location: \(touch.location(in: primaryScreen))")
-        appui.touchBegan(at: touch.location(in: primaryScreen), for: 0)
-    }
-
-    override func touchesEnded(_ touches: Set<UITouch>, with event: UIEvent?) {
-        super.touchesEnded(touches, with: event)
-        print("Touch Ended")
-        appui.touchEnded(for: 0)
-    }
-
-    override func touchesMoved(_ touches: Set<UITouch>, with event: UIEvent?) {
-        super.touchesMoved(touches, with: event)
-        guard let touch = touches.first else {
-            return
-        }
-        let location = touch.location(in: primaryScreen)
-        print("Location Moved: \(location)")
-        appui.touchMoved(at: location, for: 0)
-    }
-
-    func setupAppUIScreenforiPad() {
-        primaryScreen = MTKView(frame: .zero, device: MTLCreateSystemDefaultDevice())
-        primaryScreen.translatesAutoresizingMaskIntoConstraints = false
-        primaryScreen.clipsToBounds = true
-        primaryScreen.layer.borderColor = UIColor.secondarySystemBackground.cgColor
-        primaryScreen.layer.borderWidth = 3
-        primaryScreen.layer.cornerCurve = .continuous
-        primaryScreen.layer.cornerRadius = 10
-        addSubview(primaryScreen)
-
-
-        portraitconstraints = [
-            primaryScreen.topAnchor.constraint(equalTo: safeAreaLayoutGuide.topAnchor, constant: 10),
-            primaryScreen.leadingAnchor.constraint(equalTo: safeAreaLayoutGuide.leadingAnchor, constant: 10),
-            primaryScreen.trailingAnchor.constraint(equalTo: safeAreaLayoutGuide.trailingAnchor, constant: -10),
-            primaryScreen.heightAnchor.constraint(equalTo: primaryScreen.widthAnchor, multiplier: 9 / 16),
-        ]
-
-        landscapeconstraints = [
-            primaryScreen.topAnchor.constraint(equalTo: safeAreaLayoutGuide.topAnchor, constant: 50),
-            primaryScreen.bottomAnchor.constraint(equalTo: safeAreaLayoutGuide.bottomAnchor, constant: -100),
-            primaryScreen.widthAnchor.constraint(equalTo: primaryScreen.heightAnchor, multiplier: 16 / 9),
-            primaryScreen.centerXAnchor.constraint(equalTo: safeAreaLayoutGuide.centerXAnchor),
-        ]
-
-
-        updateConstraintsForOrientation()
-    }
-
-
-
-    func setupAppUIScreen() {
-        primaryScreen = MTKView(frame: .zero, device: MTLCreateSystemDefaultDevice())
-        primaryScreen.translatesAutoresizingMaskIntoConstraints = false
-        primaryScreen.clipsToBounds = true
-        primaryScreen.layer.borderColor = UIColor.secondarySystemBackground.cgColor
-        primaryScreen.layer.borderWidth = 3
-        primaryScreen.layer.cornerCurve = .continuous
-        primaryScreen.layer.cornerRadius = 10
-        addSubview(primaryScreen)
-
-
-        portraitconstraints = [
-            primaryScreen.topAnchor.constraint(equalTo: safeAreaLayoutGuide.topAnchor, constant: 10),
-            primaryScreen.leadingAnchor.constraint(equalTo: safeAreaLayoutGuide.leadingAnchor, constant: 10),
-            primaryScreen.trailingAnchor.constraint(equalTo: safeAreaLayoutGuide.trailingAnchor, constant: -10),
-            primaryScreen.heightAnchor.constraint(equalTo: primaryScreen.widthAnchor, multiplier: 9 / 16),
-        ]
-
-        landscapeconstraints = [
-            primaryScreen.topAnchor.constraint(equalTo: safeAreaLayoutGuide.topAnchor, constant: 10),
-            primaryScreen.bottomAnchor.constraint(equalTo: safeAreaLayoutGuide.bottomAnchor, constant: -10),
-            primaryScreen.widthAnchor.constraint(equalTo: primaryScreen.heightAnchor, multiplier: 16 / 9),
-            primaryScreen.centerXAnchor.constraint(equalTo: safeAreaLayoutGuide.centerXAnchor),
-        ]
-
-        updateConstraintsForOrientation()
-    }
-
-    override func layoutSubviews() {
-        super.layoutSubviews()
-        updateConstraintsForOrientation()
-    }
-
-    private func updateConstraintsForOrientation() {
-        removeConstraints(portraitconstraints)
-        removeConstraints(landscapeconstraints)
-        let isPortrait = UIApplication.shared.statusBarOrientation.isPortrait
-        addConstraints(isPortrait ? portraitconstraints : landscapeconstraints)
-    }
-}
@@ -1,103 +0,0 @@
-// SPDX-FileCopyrightText: Copyright 2026 Eden Emulator Project
-// SPDX-License-Identifier: GPL-3.0-or-later
-// SPDX-FileCopyrightText: Copyright 2024 Jarrod Norwell
-// SPDX-License-Identifier: GPL-2.0-or-later
-
-#pragma once
-
-#import <QuartzCore/QuartzCore.h>
-#import <QuartzCore/CAMetalLayer.h>
-
-#if __has_include(<Metal/Metal.hpp>)
-#import <Metal/Metal.hpp>
-#else
-#import <Metal/Metal.h>
-#endif
-#import "EmulationWindow.h"
-
-#include "common/detached_tasks.h"
-#include "core/core.h"
-#include "core/file_sys/registered_cache.h"
-#include "core/hle/service/acc/profile_manager.h"
-#include "core/perf_stats.h"
-#include "frontend_common/content_manager.h"
-#include "video_core/rasterizer_interface.h"
-
-class EmulationSession final {
-public:
-    explicit EmulationSession();
-    ~EmulationSession() = default;
-
-    static EmulationSession& GetInstance();
-    const Core::System& System() const;
-    Core::System& System();
-    FileSys::ManualContentProvider* GetContentProvider();
-    InputCommon::InputSubsystem& GetInputSubsystem();
-
-    const EmulationWindow& Window() const;
-    EmulationWindow& Window();
-    CAMetalLayer* NativeWindow() const;
-    void SetNativeWindow(CAMetalLayer* native_window, CGSize size);
-    void SurfaceChanged();
-
-    void InitializeGpuDriver();
-
-    bool IsRunning() const;
-    bool IsPaused() const;
-    void PauseEmulation();
-    void UnPauseEmulation();
-    void HaltEmulation();
-    void RunEmulation();
-    void ShutdownEmulation();
-
-    const Core::PerfStatsResults& PerfStats();
-    void ConfigureFilesystemProvider(const std::string& filepath);
-    void InitializeSystem(bool reload);
-    void SetAppletId(int applet_id);
-    Core::SystemResultStatus InitializeEmulation(const std::string& filepath,
-                                                 const std::size_t program_index,
-                                                 const bool frontend_initiated);
-    Core::SystemResultStatus BootOS();
-
-    static void OnEmulationStarted();
-    static u64 GetProgramId(std::string programId);
-    bool IsInitialized() { return is_initialized; };
-
-    bool IsHandheldOnly();
-    void SetDeviceType([[maybe_unused]] int index, int type);
-    void OnGamepadConnectEvent([[maybe_unused]] int index);
-    void OnGamepadDisconnectEvent([[maybe_unused]] int index);
-private:
-    static void LoadDiskCacheProgress(VideoCore::LoadCallbackStage stage, int progress, int max);
-    static void OnEmulationStopped(Core::SystemResultStatus result);
-    static void ChangeProgram(std::size_t program_index);
-
-private:
-    // Window management
-    std::unique_ptr<EmulationWindow> m_window;
-    CAMetalLayer* m_native_window{};
-
-    // Core emulation
-    Core::System m_system;
-    InputCommon::InputSubsystem m_input_subsystem;
-    Common::DetachedTasks m_detached_tasks;
-    Core::PerfStatsResults m_perf_stats{};
-    std::shared_ptr<FileSys::VfsFilesystem> m_vfs;
-    Core::SystemResultStatus m_load_result{Core::SystemResultStatus::ErrorNotInitialized};
-    std::atomic<bool> m_is_running = false;
-    std::atomic<bool> m_is_paused = false;
-    std::unique_ptr<FileSys::ManualContentProvider> m_manual_provider;
-    int m_applet_id{1};
-
-    // GPU driver parameters
-    std::shared_ptr<Common::DynamicLibrary> m_vulkan_library;
-
-    // Synchronization
-    std::condition_variable_any m_cv;
-    mutable std::mutex m_mutex;
-    bool is_initialized = false;
-    CGSize m_size;
-
-    // Program index for next boot
-    std::atomic<s32> m_next_program_index = -1;
-};
--- a/Show More
+++ b/Show More
Author	SHA1	Message	Date
CamilleLaVey	6e85c23070	TEST	2026-09-15 05:02:32 -04:00
CamilleLaVey	36b1b23d40	Experiments on window mirroring + add vertex/index to the virtual page	2026-09-15 03:02:55 -04:00
CamilleLaVey	08ba001529	another try to add compute shaders to the uma path	2026-09-14 22:04:56 -04:00
CamilleLaVey	10a75d80eb	Pure and simply meow	2026-09-14 20:15:13 -04:00
CamilleLaVey	8ec648d663	Let's try this on memory reclamations	2026-09-14 20:15:13 -04:00
CamilleLaVey	ebedba1f2c	Extended the impact on AHB fallback	2026-09-14 20:15:13 -04:00
CamilleLaVey	8ebbdc9bee	What if we just rely entirely on SGSR common than using EdgeDir?	2026-09-14 20:15:13 -04:00
CamilleLaVey	0495255867	Another intent	2026-09-14 20:15:13 -04:00
CamilleLaVey	7be3fc3ad5	Just cries internally	2026-09-14 20:15:13 -04:00
CamilleLaVey	a4276b598b	Meow.	2026-09-14 20:15:13 -04:00
CamilleLaVey	122afb04f7	Adjustments on upload for textures	2026-09-14 20:15:12 -04:00
CamilleLaVey	ea3de6ee81	Fix build	2026-09-14 20:15:12 -04:00
CamilleLaVey	32c76f1e0a	Fix msvc build	2026-09-14 20:15:12 -04:00
CamilleLaVey	bce8e0aa6d	[TEST] Bring the unswizzle work from tiled-gpu-v2 x2 + revert of vertex, indexes from AHB path	2026-09-14 20:15:12 -04:00
CamilleLaVey	a4864176f5	Just a quick test	2026-09-14 20:15:12 -04:00
CamilleLaVey	1f2aa7e40b	Added vertex, uniform and indexes on the upload path	2026-09-14 20:15:12 -04:00
CamilleLaVey	ce8c754eb3	Meowly The Build Destroyer	2026-09-14 20:15:12 -04:00
CamilleLaVey	50e59cf09d	Another intent on write/read on the fly	2026-09-14 20:15:11 -04:00
CamilleLaVey	5caa0bd567	Changes on the maps counts again	2026-09-14 20:15:11 -04:00
CamilleLaVey	d93039fb42	Step back + keeping fixes from unified download + shared mem refactor	2026-09-14 20:15:11 -04:00
CamilleLaVey	17463f7b0d	another take	2026-09-14 20:15:11 -04:00
CamilleLaVey	0ebf1ff07c	Keep AHB limitations	2026-09-14 20:15:11 -04:00
CamilleLaVey	c0c0af6085	[TEST] Another increased on windows size	2026-09-14 20:15:11 -04:00
CamilleLaVey	a8589321bc	Increased windows size	2026-09-14 20:15:11 -04:00
CamilleLaVey	ce864eac38	[TEST] Increased window limiter on AHB	2026-09-14 20:15:11 -04:00
CamilleLaVey	4a3a2c0a11	[TEST] Adjustment AHB to tiled-gpu-v2 state	2026-09-14 20:15:10 -04:00
CamilleLaVey	42636ba127	[memory, vulkan] Initial implementation for Unified Memory	2026-09-14 20:15:10 -04:00