2026-09-18 17:28:36

Signed-off-by: lizzie <lizzie@eden-emu.dev>

.ci/ios/build.sh

@@ -0,0 +1,20 @@
+#!/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

.ci/license-header.sh

@@ -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)
+		*.kt|*.kts|*.cpp|*.h|*.qml|*.c|*.hpp|*.hxx|*.cxx|*.h.in|*.inc|*.mm)
 			begin="//"
 			;;
 		*)

.patch/boost/0002-ios-fix.patch

@@ -0,0 +1,31 @@
+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_()
+ {

CMakeLists.txt

@@ -24,6 +24,29 @@ 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()
@@ -45,7 +68,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" OFF)
+cmake_dependent_option(YUZU_STATIC_ROOM "Build a static room executable only (CI only)" OFF "LINUX OR (APPLE AND NOT IOS)" OFF)
 if (YUZU_STATIC_ROOM)
     set(YUZU_ROOM ON)
     set(YUZU_ROOM_STANDALONE ON)
@@ -71,9 +94,15 @@ if (YUZU_STATIC_ROOM)
 endif()
 
 # qt stuff
-option(ENABLE_QT "Enable the Qt frontend" ON)
+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_TRANSLATION "Enable translations for the Qt frontend" OFF)
-option(ENABLE_UPDATE_CHECKER "Enable update checker (for Qt and Android)" OFF)
+cmake_dependent_option(ENABLE_UPDATE_CHECKER "Enable update checker (for Qt and Android)" OFF "ENABLE_QT OR 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")
@@ -220,7 +249,7 @@ endif()
 option(ENABLE_CUBEB "Enables the cubeb audio backend" ON)
 
 set(EXT_DEFAULT OFF)
-if (MSVC OR ANDROID)
+if (MSVC OR ANDROID OR IOS)
     set(EXT_DEFAULT ON)
 endif()
 
@@ -232,14 +261,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)
+if ((MSVC AND NOT (CMAKE_BUILD_TYPE MATCHES "Deb")) OR ANDROID OR IOS)
     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" OFF)
+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_OPENGL "Enable OpenGL" ON "NOT (WIN32 AND ARCHITECTURE_arm64) AND NOT APPLE AND NOT ANDROID" OFF)
 mark_as_advanced(FORCE ENABLE_OPENGL)
@@ -261,10 +290,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" OFF)
+cmake_dependent_option(YUZU_ROOM "Enable dedicated room functionality" ON "NOT ANDROID AND NOT IOS" 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" OFF)
+cmake_dependent_option(YUZU_CMD "Compile the eden-cli executable" ON "NOT ANDROID AND NOT IOS" OFF)
 
 cmake_dependent_option(YUZU_CRASH_DUMPS "Compile crash dump (Minidump) support" OFF "WIN32 OR LINUX" OFF)
 
@@ -308,7 +337,7 @@ if (YUZU_ROOM)
     add_compile_definitions(YUZU_ROOM)
 endif()
 
-if (UNIX AND NOT (LINUX OR WIN32))
+if ((UNIX OR IOS) 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")
@@ -381,7 +410,10 @@ set(CMAKE_RUNTIME_OUTPUT_DIRECTORY ${PROJECT_BINARY_DIR}/bin)
 set(THREADS_PREFER_PTHREAD_FLAG ON)
 find_package(Threads REQUIRED)
 
-find_package(RenderDoc MODULE)
+find_package(RenderDoc MODULE QUIET)
+if (NOT RenderDoc_FOUND)
+    message(WARNING "RenderDoc not found. Some debugging features may be disabled.")
+endif()
 
 # openssl funniness
 if (YUZU_USE_BUNDLED_OPENSSL)
@@ -509,9 +541,13 @@ endfunction()
 # Platform-specific library requirements
 # Put these BEFORE EXTERNALS or Boost WILL die
 # =============================================
-
 if (APPLE)
-    foreach(fw Carbon Metal Cocoa IOKit CoreVideo CoreMedia Security UniformTypeIdentifiers Foundation)
+    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})
         find_library(${fw}_LIBRARY ${fw} REQUIRED)
         list(APPEND PLATFORM_LIBRARIES ${${fw}_LIBRARY})
     endforeach()

docs/Caveats.md

@@ -6,6 +6,7 @@
 - [macOS](#macos)
 - [OpenIndiana](#openindiana)
 - [OmniOS](#omnios)
+- [iOS](#ios)
 - [HaikuOS](#haikuos)
 - [OpenBSD](#openbsd)
 - [FreeBSD](#freebsd)
@@ -90,6 +91,16 @@ 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.

externals/CMakeLists.txt

@@ -272,6 +272,12 @@ 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)

externals/cmake-modules/DetectArchitecture.cmake

@@ -35,16 +35,21 @@ 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 (CMAKE_OSX_ARCHITECTURES)
+if (DEFINED CMAKE_OSX_ARCHITECTURES)
     set(MULTIARCH_BUILD 1)
     set(ARCHITECTURE "${CMAKE_OSX_ARCHITECTURES}")
-
-    # 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()
-
+    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()
     return()
 endif()
 
@@ -218,4 +223,4 @@ if (NOT DEFINED ARCHITECTURE)
     add_definitions(-DARCHITECTURE_GENERIC=1)
 endif()
 
-message(STATUS "[DetectArchitecture] Target architecture: ${ARCHITECTURE}")
+message(STATUS "[DetectArchitecture] Target architecture: ${ARCHITECTURE}")

externals/cmake-modules/DetectPlatform.cmake

@@ -54,6 +54,12 @@ 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)

externals/ffmpeg/CMakeLists.txt

@@ -29,6 +29,22 @@ 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?
@@ -62,7 +78,7 @@ elseif (ANDROID)
         --enable-mediacodec
         --enable-jni
     )
-elseif (UNIX AND NOT DEFINED FFmpeg_IS_CROSS_COMPILING AND NOT ANDROID)
+elseif (UNIX AND NOT DEFINED FFmpeg_IS_CROSS_COMPILING AND NOT ANDROID AND NOT IOS)
     find_package(PkgConfig REQUIRED)
     pkg_check_modules(LIBVA libva)
     pkg_check_modules(CUDA cuda)

externals/libusb/CMakeLists.txt

@@ -24,7 +24,8 @@ if (MINGW OR LINUX OR APPLE)
         message(FATAL_ERROR "Required program `autoconf` not found.")
     endif()
 
-    find_program(LIBTOOLIZE libtoolize)
+    find_program(LIBTOOLIZE
+        NAMES libtoolize glibtoolize)
     if ("${LIBTOOLIZE}" STREQUAL "LIBTOOLIZE-NOTFOUND")
         message(FATAL_ERROR "Required program `libtoolize` not found.")
     endif()

src/CMakeLists.txt

@@ -177,6 +177,9 @@ 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)
@@ -295,4 +298,9 @@ 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)

src/common/cpu_features.cpp

@@ -244,7 +244,8 @@ 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_factor{invariant_ ? GetFixedPoint64Factor(rdtsc_frequency_, NsRatio::den) : 1}
+    , rdtsc_ns_integer{invariant_ ? rdtsc_frequency_ / NsRatio::den : 1}
+    , rdtsc_ns_factor{invariant_ ? GetFixedPoint64Factor(rdtsc_frequency_ % NsRatio::den, NsRatio::den) : 0}
     , cntpct_rdtsc_factor{invariant_ ? GetFixedPoint64Factor(CNTFRQ, rdtsc_frequency_) : 0}
     , gputick_rdtsc_factor{invariant_ ? GetFixedPoint64Factor(GPUTickFreq, rdtsc_frequency_) : 0}
     , invariant{invariant_}
@@ -291,7 +292,7 @@ bool WallClock::IsNative() const {
 }
 
 u64 WallClock::NsToTicks(std::chrono::nanoseconds ns) const {
-    return invariant ? MultiplyHigh(ns.count(), rdtsc_ns_factor) : ns.count();
+    return ns.count() * rdtsc_ns_integer + MultiplyHigh(ns.count(), rdtsc_ns_factor);
 }
 #elif defined(HAS_NCE)
 namespace {
@@ -416,7 +417,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

src/common/cpu_features.h

@@ -96,6 +96,7 @@ 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;

src/common/device_power_state.cpp

@@ -1,4 +1,4 @@
-// SPDX-FileCopyrightText: Copyright 2025 Eden Emulator Project
+// SPDX-FileCopyrightText: Copyright 2026 Eden Emulator Project
 // SPDX-License-Identifier: GPL-3.0-or-later
 
 #include "device_power_state.h"
@@ -14,11 +14,14 @@ extern std::atomic<bool> g_has_battery;
 
 #elif defined(__APPLE__)
 #include <TargetConditionals.h>
-#if TARGET_OS_MAC
+#if defined(TARGET_OS_MAC) && TARGET_OS_MAC
+#if TARGET_OS_IPHONE
+// ios doesnt have this
+#else
 #include <IOKit/ps/IOPSKeys.h>
 #include <IOKit/ps/IOPowerSources.h>
 #endif
-
+#endif
 #elif defined(__linux__)
 #include <fstream>
 #include <string>
@@ -48,7 +51,9 @@ 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);
@@ -96,7 +101,6 @@ namespace Common {
 #else
         info.has_battery = false;
 #endif
-
         return info;
     }
 }

src/common/host_memory.cpp

@@ -27,7 +27,11 @@
 #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__)

src/common/string_util.cpp

@@ -116,18 +116,119 @@ std::string ReplaceAll(std::string result, const std::string& src, const std::st
 }
 
 std::string UTF16ToUTF8(std::u16string_view input) {
-    std::wstring_convert<std::codecvt_utf8_utf16<char16_t>, char16_t> convert;
-    return convert.to_bytes(input.data(), input.data() + input.size());
+    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::u16string UTF8ToUTF16(std::string_view input) {
-    std::wstring_convert<std::codecvt_utf8_utf16<char16_t>, char16_t> convert;
-    return convert.from_bytes(input.data(), input.data() + input.size());
+    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::u32string UTF8ToUTF32(std::string_view input) {
-    std::wstring_convert<std::codecvt_utf8<char32_t>, char32_t> convert;
-    return convert.from_bytes(input.data(), input.data() + input.size());
+    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;
 }
 
 #ifdef _WIN32

src/core/CMakeLists.txt

@@ -1261,6 +1261,10 @@ 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)

src/core/arm/dynarmic/arm_dynarmic.h

@@ -6,7 +6,7 @@
 
 #pragma once
 
-#include <dynarmic/interface/halt_reason.h>
+#include "dynarmic/src/dynarmic/interface/halt_reason.h"
 
 #include "core/arm/arm_interface.h"
 

src/core/arm/dynarmic/arm_dynarmic_32.h

@@ -6,8 +6,8 @@
 
 #pragma once
 
-#include <dynarmic/interface/A32/a32.h>
-#include <dynarmic/interface/code_page.h>
+#include "dynarmic/src/dynarmic/interface/A32/a32.h"
+#include "dynarmic/src/dynarmic/interface/code_page.h"
 
 #include "core/arm/arm_interface.h"
 #include "core/arm/dynarmic/dynarmic_exclusive_monitor.h"

src/core/arm/dynarmic/arm_dynarmic_64.h

@@ -10,12 +10,12 @@
 #include <memory>
 #include "common/container/unordered_map.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"
+#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"
 
 namespace Core::Memory {
 class Memory;

src/core/arm/dynarmic/dynarmic_cp15.h

@@ -1,3 +1,6 @@
+// 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
 
@@ -5,7 +8,7 @@
 
 #include <optional>
 
-#include <dynarmic/interface/A32/coprocessor.h>
+#include "dynarmic/interface/A32/coprocessor.h"
 #include "common/common_types.h"
 
 namespace Core {

src/core/arm/dynarmic/dynarmic_exclusive_monitor.h

@@ -1,9 +1,12 @@
+// 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/interface/exclusive_monitor.h>
+#include "dynarmic/src/dynarmic/interface/exclusive_monitor.h"
 
 #include "common/common_types.h"
 #include "core/arm/exclusive_monitor.h"

src/core/arm/nce/visitor_base.h

@@ -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-FileCopyrightText: Copyright 2023 merryhime <https://mary.rs>
 // SPDX-License-Identifier: GPL-2.0-or-later
@@ -7,9 +10,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
 

src/core/file_sys/patch_manager.cpp

@@ -9,6 +9,7 @@
 #include <cstddef>
 #include <cstring>
 
+#include "common/assert.h"
 #include "common/hex_util.h"
 #include "common/logging.h"
 #include "common/settings.h"
@@ -156,12 +157,15 @@ 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_}, fs_controller{fs_controller_}, content_provider{content_provider_} {}
+    : title_id{title_id_}, parent_title_id{GetParentApplicationId(std::addressof(content_provider_), title_id_)}, fs_controller{fs_controller_}, content_provider{content_provider_} {}
 
 PatchManager::~PatchManager() = default;
 
@@ -169,13 +173,35 @@ 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 = Settings::values.disabled_addons[title_id];
+    const auto disabled = GetDisabledAddons();
 
     bool update_disabled = true;
     std::optional<u32> enabled_version;
@@ -303,8 +329,8 @@ VirtualDir PatchManager::PatchExeFS(VirtualDir exefs) const {
     }
 
     // LayeredExeFS
-    const auto load_dir = fs_controller.GetModificationLoadRoot(title_id);
-    const auto sdmc_load_dir = fs_controller.GetSDMCModificationLoadRoot(title_id);
+    const auto load_dir = GetModificationLoadRoot();
+    const auto sdmc_load_dir = GetModificationLoadRoot(true);
 
     std::vector<VirtualDir> patch_dirs = {sdmc_load_dir};
     if (load_dir != nullptr) {
@@ -346,7 +372,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 = Settings::values.disabled_addons[title_id];
+    const auto disabled = GetDisabledAddons();
     const auto nso_build_id = fmt::format("{:0<64}", build_id);
 
     std::vector<VirtualFile> out;
@@ -405,7 +431,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 = fs_controller.GetModificationLoadRoot(title_id);
+    const auto load_dir = GetModificationLoadRoot();
     if (load_dir == nullptr) {
         LOG_ERROR(Loader, "Cannot load mods for invalid title_id={:016X}", title_id);
         return nso;
@@ -448,7 +474,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 = fs_controller.GetModificationLoadRoot(title_id);
+    const auto load_dir = GetModificationLoadRoot();
     if (load_dir == nullptr) {
         LOG_ERROR(Loader, "Cannot load mods for invalid title_id={:016X}", title_id);
         return false;
@@ -462,13 +488,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 = fs_controller.GetModificationLoadRoot(title_id);
+    const auto load_dir = GetModificationLoadRoot();
     if (load_dir == nullptr) {
         LOG_ERROR(Loader, "Cannot load mods for invalid title_id={:016X}", title_id);
         return {};
     }
 
-    const auto& disabled = Settings::values.disabled_addons[title_id];
+    const auto disabled = GetDisabledAddons();
     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(); });
 
@@ -502,17 +528,16 @@ std::vector<Core::Memory::CheatEntry> PatchManager::CreateCheatList(const BuildI
     return out;
 }
 
-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);
+void PatchManager::ApplyLayeredFS(VirtualFile& romfs, ContentRecordType type) const {
+    const auto load_dir = GetModificationLoadRoot();
+    const auto sdmc_load_dir = GetModificationLoadRoot(true);
     if ((type != ContentRecordType::Program && type != ContentRecordType::Data &&
          type != ContentRecordType::HtmlDocument) ||
         (load_dir == nullptr && sdmc_load_dir == nullptr)) {
         return;
     }
 
-    const auto& disabled = Settings::values.disabled_addons[title_id];
+    const auto disabled = GetDisabledAddons();
     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);
@@ -591,7 +616,7 @@ VirtualFile PatchManager::PatchRomFS(const NCA* base_nca, VirtualFile base_romfs
 
     // Game Updates
     const auto update_tid = GetUpdateTitleID(title_id);
-    const auto& disabled = Settings::values.disabled_addons[title_id];
+    const auto disabled = GetDisabledAddons();
 
     bool update_disabled = true;
     std::optional<u32> enabled_version;
@@ -698,7 +723,7 @@ VirtualFile PatchManager::PatchRomFS(const NCA* base_nca, VirtualFile base_romfs
 
     // LayeredFS
     if (apply_layeredfs) {
-        ApplyLayeredFS(romfs, title_id, type, fs_controller);
+        ApplyLayeredFS(romfs, type);
     }
 
     return romfs;
@@ -1072,15 +1097,22 @@ 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)) {
-        return content_provider.GetEntryVersion(update_tid);
+        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(title_id);
+    const auto version = content_provider.GetEntryVersion(title_id);
+    return version || !parent_title_id ? version : content_provider.GetEntryVersion(*parent_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 {};
     }
 

src/core/file_sys/patch_manager.h

@@ -109,10 +109,14 @@ 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;
 };

src/core/file_sys/registered_cache.cpp

@@ -5,6 +5,7 @@
 // SPDX-License-Identifier: GPL-2.0-or-later
 
 #include <algorithm>
+#include <limits>
 #include <random>
 #include <regex>
 #include <openssl/evp.h>
@@ -348,6 +349,22 @@ 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 {

src/core/file_sys/registered_cache.h

@@ -100,6 +100,8 @@ 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();

src/core/file_sys/savedata_factory.cpp

@@ -9,6 +9,7 @@
 #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"
 
@@ -61,17 +62,24 @@ 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 = GetFullPath(program_id, dir, space, meta.type, meta.program_id,
-                                            meta.user_id, meta.system_save_data_id);
+    const auto save_directory = GetSaveDataPath(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 = GetFullPath(program_id, dir, space, meta.type, meta.program_id,
-                                            meta.user_id, meta.system_save_data_id);
+    const auto save_directory = GetSaveDataPath(space, meta.type, meta.program_id, meta.user_id, meta.system_save_data_id);
 
     auto out = dir->GetDirectoryRelative(save_directory);
 
@@ -154,8 +162,7 @@ std::string SaveDataFactory::GetUserGameSaveDataRoot(u128 user_id, bool future)
 
 SaveDataSize SaveDataFactory::ReadSaveDataSize(SaveDataType type, u64 title_id,
                                                u128 user_id) const {
-    const auto path =
-        GetFullPath(program_id, dir, SaveDataSpaceId::User, type, title_id, user_id, 0);
+    const auto path = GetSaveDataPath(SaveDataSpaceId::User, type, title_id, user_id, 0);
     const auto relative_dir = GetOrCreateDirectoryRelative(dir, path);
 
     const auto size_file = relative_dir->GetFile(GetSaveDataSizeFileName());
@@ -173,8 +180,7 @@ 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 =
-        GetFullPath(program_id, dir, SaveDataSpaceId::User, type, title_id, user_id, 0);
+    const auto path = GetSaveDataPath(SaveDataSpaceId::User, type, title_id, user_id, 0);
     const auto relative_dir = GetOrCreateDirectoryRelative(dir, path);
 
     const auto size_file = relative_dir->CreateFile(GetSaveDataSizeFileName());

src/core/file_sys/savedata_factory.h

@@ -1,3 +1,6 @@
+// SPDX-FileCopyrightText: Copyright 2026 Eden Emulator Project
+// SPDX-License-Identifier: GPL-3.0-or-later
+
 // SPDX-FileCopyrightText: Copyright 2018 yuzu Emulator Project
 // SPDX-License-Identifier: GPL-2.0-or-later
 
@@ -47,6 +50,7 @@ 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;

src/core/hle/service/am/lifecycle_manager.h

@@ -92,6 +92,13 @@ 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:

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

@@ -164,14 +164,14 @@ Result ILibraryAppletAccessor::PushInData(SharedPointer<IStorage> storage) {
 Result ILibraryAppletAccessor::PopOutData(Out<SharedPointer<IStorage>> out_storage) {
     LOG_DEBUG(Service_AM, "called");
 
-    if (auto caller_applet = m_applet->caller_applet.lock(); caller_applet) {
-        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 (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());
+    }
 
     if (m_applet->applet_id == AppletId::ProfileSelect && *out_storage) {
         auto impl = (*out_storage)->GetImpl();

src/core/hle/service/hid/hid_system_server.cpp

@@ -121,7 +121,7 @@ IHidSystemServer::IHidSystemServer(Core::System& system_, std::shared_ptr<Resour
         {547, nullptr, "GetAllowedBluetoothLinksCount"},
         {548, &IHidSystemServer::GetRegisteredDevices, "GetRegisteredDevices"},
         {549, nullptr, "GetConnectableRegisteredDevices"},
-        {551, nullptr, "GetRegisteredDevicesForControllerSupport"}, //20.0.0+
+        {551, &IHidSystemServer::GetRegisteredDevices, "GetRegisteredDevicesForControllerSupport"}, //20.0.0+ //mocked via 548 for Diablo 3 (at least)
         {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");
+    LOG_WARNING(Service_HID, "(STUBBED) called, command={}", ctx.GetCommand()); //548 or 551
 
     struct RegisterData {
         std::array<u8, 0x68> data;

src/core/hle/service/jit/jit_context.cpp

@@ -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"

src/dynarmic/CMakeModules/TargetArchitectureSpecificSources.cmake

@@ -1,29 +0,0 @@
-# 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()

src/dynarmic/src/dynarmic/CMakeLists.txt

@@ -1,6 +1,5 @@
 # SPDX-FileCopyrightText: Copyright 2026 Eden Emulator Project
 # SPDX-License-Identifier: GPL-3.0-or-later
-include(TargetArchitectureSpecificSources)
 
 add_library(dynarmic STATIC
     mcl/bit.hpp
@@ -143,7 +142,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_architecture_specific_sources(dynarmic "x86_64"
+    target_sources(dynarmic PRIVATE
         backend/x64/abi.cpp
         backend/x64/abi.h
         backend/x64/block_of_code.cpp
@@ -204,7 +203,7 @@ endif()
 if ("arm64" IN_LIST ARCHITECTURE)
     target_link_libraries(dynarmic PRIVATE merry::oaknut)
 
-    target_architecture_specific_sources(dynarmic "arm64"
+    target_sources(dynarmic PRIVATE
         backend/arm64/a32_jitstate.cpp
         backend/arm64/a32_jitstate.h
         backend/arm64/a64_jitstate.h

src/dynarmic/src/dynarmic/interface/A32/a32.h

@@ -1,4 +1,4 @@
-// SPDX-FileCopyrightText: Copyright 2025 Eden Emulator Project
+// SPDX-FileCopyrightText: Copyright 2026 Eden Emulator Project
 // SPDX-License-Identifier: GPL-3.0-or-later
 
 /* This file is part of the dynarmic project.
@@ -14,8 +14,8 @@
 #include <string>
 #include <vector>
 
-#include "dynarmic/interface/A32/config.h"
-#include "dynarmic/interface/halt_reason.h"
+#include "config.h"
+#include "dynarmic/src/dynarmic/interface/halt_reason.h"
 
 namespace Dynarmic {
 namespace A32 {

src/dynarmic/src/dynarmic/interface/A32/config.h

@@ -14,9 +14,9 @@
 #include <memory>
 #include <optional>
 
-#include "dynarmic/frontend/A32/translate/translate_callbacks.h"
-#include "dynarmic/interface/A32/arch_version.h"
-#include "dynarmic/interface/optimization_flags.h"
+#include "../../frontend/A32/translate/translate_callbacks.h"
+#include "arch_version.h"
+#include "../optimization_flags.h"
 
 namespace Dynarmic {
 class ExclusiveMonitor;

src/dynarmic/src/dynarmic/interface/A64/a64.h

@@ -1,4 +1,4 @@
-// SPDX-FileCopyrightText: Copyright 2025 Eden Emulator Project
+// SPDX-FileCopyrightText: Copyright 2026 Eden Emulator Project
 // SPDX-License-Identifier: GPL-3.0-or-later
 
 /* This file is part of the dynarmic project.
@@ -15,8 +15,8 @@
 #include <string>
 #include <vector>
 
-#include "dynarmic/interface/A64/config.h"
-#include "dynarmic/interface/halt_reason.h"
+#include "config.h"
+#include "../halt_reason.h"
 
 namespace Dynarmic {
 namespace A64 {

src/dynarmic/src/dynarmic/interface/A64/config.h

@@ -14,7 +14,7 @@
 #include <memory>
 #include <optional>
 
-#include "dynarmic/interface/optimization_flags.h"
+#include "../optimization_flags.h"
 
 namespace Dynarmic {
 class ExclusiveMonitor;

src/dynarmic/src/dynarmic/interface/exclusive_monitor.h

@@ -14,7 +14,7 @@
 #include <cstring>
 #include <boost/container/static_vector.hpp>
 
-#include <dynarmic/common/spin_lock.h>
+#include "dynarmic/src/dynarmic/common/spin_lock.h"
 
 namespace Dynarmic {
 

src/dynarmic/tests/CMakeLists.txt

@@ -1,6 +1,5 @@
 # SPDX-FileCopyrightText: Copyright 2026 Eden Emulator Project
 # SPDX-License-Identifier: GPL-3.0-or-later
-include(TargetArchitectureSpecificSources)
 
 add_executable(dynarmic_tests
     fp/FPToFixed.cpp
@@ -50,7 +49,7 @@ endif()
 
 if ("x86_64" IN_LIST ARCHITECTURE)
     target_link_libraries(dynarmic_tests PRIVATE xbyak::xbyak)
-    target_architecture_specific_sources(dynarmic_tests "x86_64"
+    target_sources(dynarmic PRIVATE
         x64_cpu_info.cpp
         native/preserve_xmm.cpp
     )

src/hid_core/resources/npad/npad.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().sampling_number + 1;
+    dummy_pad_state.sampling_number = npad->fullkey_lifo.ReadCurrentEntry().state.sampling_number + 1;
     npad->fullkey_lifo.WriteNextEntry(dummy_pad_state);
-    dummy_pad_state.sampling_number = npad->handheld_lifo.ReadCurrentEntry().sampling_number + 1;
+    dummy_pad_state.sampling_number = npad->handheld_lifo.ReadCurrentEntry().state.sampling_number + 1;
     npad->handheld_lifo.WriteNextEntry(dummy_pad_state);
-    dummy_pad_state.sampling_number = npad->joy_dual_lifo.ReadCurrentEntry().sampling_number + 1;
+    dummy_pad_state.sampling_number = npad->joy_dual_lifo.ReadCurrentEntry().state.sampling_number + 1;
     npad->joy_dual_lifo.WriteNextEntry(dummy_pad_state);
-    dummy_pad_state.sampling_number = npad->joy_left_lifo.ReadCurrentEntry().sampling_number + 1;
+    dummy_pad_state.sampling_number = npad->joy_left_lifo.ReadCurrentEntry().state.sampling_number + 1;
     npad->joy_left_lifo.WriteNextEntry(dummy_pad_state);
-    dummy_pad_state.sampling_number = npad->joy_right_lifo.ReadCurrentEntry().sampling_number + 1;
+    dummy_pad_state.sampling_number = npad->joy_right_lifo.ReadCurrentEntry().state.sampling_number + 1;
     npad->joy_right_lifo.WriteNextEntry(dummy_pad_state);
-    dummy_pad_state.sampling_number = npad->palma_lifo.ReadCurrentEntry().sampling_number + 1;
+    dummy_pad_state.sampling_number = npad->palma_lifo.ReadCurrentEntry().state.sampling_number + 1;
     npad->palma_lifo.WriteNextEntry(dummy_pad_state);
-    dummy_pad_state.sampling_number = npad->system_ext_lifo.ReadCurrentEntry().sampling_number + 1;
+    dummy_pad_state.sampling_number = npad->system_ext_lifo.ReadCurrentEntry().state.sampling_number + 1;
     npad->system_ext_lifo.WriteNextEntry(dummy_pad_state);
-    dummy_gc_state.sampling_number = npad->gc_trigger_lifo.ReadCurrentEntry().sampling_number + 1;
+    dummy_gc_state.sampling_number = npad->gc_trigger_lifo.ReadCurrentEntry().state.sampling_number + 1;
     npad->gc_trigger_lifo.WriteNextEntry(dummy_gc_state);
 }
 

src/ios/AppUI-Bridging-Header.h

@@ -0,0 +1,11 @@
+// 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 */

src/ios/AppUI.swift

@@ -0,0 +1,113 @@
+// 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)
+        }
+    }
+}

src/ios/AppUIGameInformation.h

@@ -0,0 +1,26 @@
+// 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

src/ios/AppUIGameInformation.mm

@@ -0,0 +1,436 @@
+// 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

src/ios/AppUIObjC.h

@@ -0,0 +1,93 @@
+// 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

src/ios/AppUIObjC.mm

@@ -0,0 +1,251 @@
+// 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

src/ios/CMakeLists.txt

@@ -0,0 +1,86 @@
+# 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})

src/ios/Config.h

@@ -0,0 +1,19 @@
+// 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

src/ios/Config.mm

@@ -0,0 +1,11 @@
+// SPDX-FileCopyrightText: Copyright 2026 Eden Emulator Project
+// SPDX-License-Identifier: GPL-3.0-or-later
+
+
+#include "Config.h"
+
+namespace IOSSettings {
+
+Values values;
+
+} // namespace IOSSettings

src/ios/EmulationGame.swift

@@ -0,0 +1,31 @@
+// 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
+    }
+}

src/ios/EmulationHandler.swift

@@ -0,0 +1,96 @@
+// 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
+        }
+    }
+}

src/ios/EmulationScreenView.swift

@@ -0,0 +1,133 @@
+// 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)
+    }
+}

src/ios/EmulationSession.h

@@ -0,0 +1,103 @@
+// 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;
+};

src/ios/EmulationSession.mm

@@ -0,0 +1,474 @@
+// 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 "EmulationSession.h"
+
+#include <SDL.h>
+
+#include <codecvt>
+#include <locale>
+#include <string>
+#include <string_view>
+#include <dlfcn.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/detached_tasks.h"
+#include "common/dynamic_library.h"
+#include "common/fs/path_util.h"
+#include "common/logging.h"
+#include "common/scm_rev.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 "frontend_common/config.h"
+#include "hid_core/frontend/emulated_controller.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"
+
+#define jconst [[maybe_unused]] const auto
+#define jauto [[maybe_unused]] auto
+
+static EmulationSession s_instance;
+
+EmulationSession::EmulationSession() {
+    m_vfs = std::make_shared<FileSys::RealVfsFilesystem>();
+}
+
+EmulationSession& EmulationSession::GetInstance() {
+    return s_instance;
+}
+
+const Core::System& EmulationSession::System() const {
+    return m_system;
+}
+
+Core::System& EmulationSession::System() {
+    return m_system;
+}
+
+FileSys::ManualContentProvider* EmulationSession::GetContentProvider() {
+    return m_manual_provider.get();
+}
+
+InputCommon::InputSubsystem& EmulationSession::GetInputSubsystem() {
+    return m_input_subsystem;
+}
+
+const EmulationWindow& EmulationSession::Window() const {
+    return *m_window;
+}
+
+EmulationWindow& EmulationSession::Window() {
+    return *m_window;
+}
+
+CAMetalLayer* EmulationSession::NativeWindow() const {
+    return m_native_window;
+}
+
+void EmulationSession::SetNativeWindow(CAMetalLayer* native_window, CGSize size) {
+    m_native_window = native_window;
+    m_size = size;
+}
+
+void EmulationSession::InitializeGpuDriver() {
+    m_vulkan_library = std::make_shared<Common::DynamicLibrary>(dlopen("@executable_path/Frameworks/MoltenVK", RTLD_NOW));
+}
+
+bool EmulationSession::IsRunning() const {
+    return m_is_running;
+}
+
+bool EmulationSession::IsPaused() const {
+    return m_is_running && m_is_paused;
+}
+
+const Core::PerfStatsResults& EmulationSession::PerfStats() {
+    m_perf_stats = m_system.GetAndResetPerfStats();
+    return m_perf_stats;
+}
+
+void EmulationSession::SurfaceChanged() {
+    if (!IsRunning()) {
+        return;
+    }
+    m_window->OnSurfaceChanged(m_native_window, m_size);
+}
+
+void EmulationSession::ConfigureFilesystemProvider(const std::string& filepath) {
+    const auto file = m_system.GetFilesystem()->OpenFile(filepath, FileSys::OpenMode::Read);
+    if (!file) {
+        return;
+    }
+
+    auto loader = Loader::GetLoader(m_system, file);
+    if (!loader) {
+        return;
+    }
+
+    const auto file_type = loader->GetFileType();
+    if (file_type == Loader::FileType::Unknown || file_type == Loader::FileType::Error) {
+        return;
+    }
+
+    u64 program_id = 0;
+    const auto res2 = loader->ReadProgramId(program_id);
+    if (res2 == Loader::ResultStatus::Success && file_type == Loader::FileType::NCA) {
+        m_manual_provider->AddEntry(FileSys::TitleType::Application,
+                                    FileSys::GetCRTypeFromNCAType(FileSys::NCA{file}.GetType()),
+                                    program_id, file);
+    } else if (res2 == Loader::ResultStatus::Success &&
+               (file_type == Loader::FileType::XCI || file_type == Loader::FileType::NSP)) {
+        const auto nsp = file_type == Loader::FileType::NSP
+                             ? std::make_shared<FileSys::NSP>(file)
+                             : FileSys::XCI{file}.GetSecurePartitionNSP();
+        for (const auto& title : nsp->GetNCAs()) {
+            for (const auto& entry : title.second) {
+                m_manual_provider->AddEntry(entry.first.first, entry.first.second, title.first,
+                                            entry.second->GetBaseFile());
+            }
+        }
+    }
+}
+
+void EmulationSession::InitializeSystem(bool reload) {
+    if (!reload) {
+        SDL_SetMainReady();
+
+        // Initialize logging system
+        Common::Log::Initialize();
+        Common::Log::SetColorConsoleBackendEnabled(true);
+        Common::Log::Start();
+    }
+
+    // Initialize filesystem.
+    m_system.SetFilesystem(m_vfs);
+    m_system.GetUserChannel().clear();
+    m_manual_provider = std::make_unique<FileSys::ManualContentProvider>();
+    m_system.SetContentProvider(std::make_unique<FileSys::ContentProviderUnion>());
+    m_system.RegisterContentProvider(FileSys::ContentProviderUnionSlot::FrontendManual,
+                                     m_manual_provider.get());
+    m_system.GetFileSystemController().CreateFactories(*m_vfs);
+
+    is_initialized = true;
+}
+
+void EmulationSession::SetAppletId(int applet_id) {
+    m_applet_id = applet_id;
+    m_system.GetFrontendAppletHolder().SetCurrentAppletId(
+        static_cast<Service::AM::AppletId>(m_applet_id));
+}
+
+Core::SystemResultStatus EmulationSession::InitializeEmulation(const std::string& filepath,
+                                                               const std::size_t program_index,
+                                                               const bool frontend_initiated) {
+    std::scoped_lock lock(m_mutex);
+
+    // Create the render window.
+    m_window = std::make_unique<EmulationWindow>(&m_input_subsystem, m_native_window, m_size, m_vulkan_library);
+
+    // Initialize system.
+    m_system.SetShuttingDown(false);
+    m_system.ApplySettings();
+    Settings::LogSettings();
+    m_system.HIDCore().ReloadInputDevices();
+    m_system.SetFrontendAppletSet(Service::AM::Frontend::FrontendAppletSet{});
+
+    // Initialize filesystem.
+    ConfigureFilesystemProvider(filepath);
+
+    // Load the ROM.
+    Service::AM::FrontendAppletParameters params{
+        .applet_id = static_cast<Service::AM::AppletId>(m_applet_id),
+        .launch_type = frontend_initiated ? Service::AM::LaunchType::FrontendInitiated
+                                          : Service::AM::LaunchType::ApplicationInitiated,
+        .program_index = static_cast<s32>(program_index),
+    };
+    m_load_result = m_system.Load(EmulationSession::GetInstance().Window(), filepath, params);
+    if (m_load_result != Core::SystemResultStatus::Success) {
+        return m_load_result;
+    }
+
+    // Complete initialization.
+    m_system.GPU().Start();
+    m_system.GetCpuManager().OnGpuReady();
+    m_system.RegisterExitCallback([&] { HaltEmulation(); });
+
+    if (Settings::values.use_disk_shader_cache.GetValue()) {
+        m_system.Renderer().ReadRasterizer()->LoadDiskResources(
+                                                              m_system.GetApplicationProcessProgramID(), std::stop_token{},
+                                                              [](VideoCore::LoadCallbackStage, size_t value, size_t total) {});
+    }
+
+    // Register an ExecuteProgram callback such that Core can execute a sub-program
+    m_system.RegisterExecuteProgramCallback([&](std::size_t program_index_) {
+        m_next_program_index = program_index_;
+        EmulationSession::GetInstance().HaltEmulation();
+        ChangeProgram(m_next_program_index);
+    });
+
+    OnEmulationStarted();
+    return Core::SystemResultStatus::Success;
+}
+
+
+Core::SystemResultStatus EmulationSession::BootOS() {
+    std::scoped_lock lock(m_mutex);
+
+    // Create the render window.
+    m_window = std::make_unique<EmulationWindow>(&m_input_subsystem, m_native_window, m_size, m_vulkan_library);
+
+    // Initialize system.
+    m_system.SetShuttingDown(false);
+    m_system.ApplySettings();
+    Settings::LogSettings();
+    m_system.HIDCore().ReloadInputDevices();
+    m_system.SetFrontendAppletSet(Service::AM::Frontend::FrontendAppletSet{});
+
+    constexpr u64 QLaunchId = static_cast<u64>(Service::AM::AppletProgramId::QLaunch);
+    auto bis_system = m_system.GetFileSystemController().GetSystemNANDContents();
+
+    auto qlaunch_applet_nca = bis_system->GetEntry(QLaunchId, FileSys::ContentRecordType::Program);
+
+    m_system.GetFrontendAppletHolder().SetCurrentAppletId(Service::AM::AppletId::QLaunch);
+
+    const auto filename = qlaunch_applet_nca->GetFullPath();
+
+    auto params = Service::AM::FrontendAppletParameters {
+        .program_id = QLaunchId,
+        .applet_id = Service::AM::AppletId::QLaunch,
+        .applet_type = Service::AM::AppletType::LibraryApplet
+    };
+
+    m_load_result = m_system.Load(EmulationSession::GetInstance().Window(), filename, params);
+
+    if (m_load_result != Core::SystemResultStatus::Success) {
+        return m_load_result;
+    }
+
+    // Complete initialization.
+    m_system.GPU().Start();
+    m_system.GetCpuManager().OnGpuReady();
+    m_system.RegisterExitCallback([&] { HaltEmulation(); });
+
+    if (Settings::values.use_disk_shader_cache.GetValue()) {
+        m_system.Renderer().ReadRasterizer()->LoadDiskResources(
+                                                              m_system.GetApplicationProcessProgramID(), std::stop_token{},
+                                                              [](VideoCore::LoadCallbackStage, size_t value, size_t total) {});
+    }
+
+    // Register an ExecuteProgram callback such that Core can execute a sub-program
+    m_system.RegisterExecuteProgramCallback([&](std::size_t program_index_) {
+        m_next_program_index = program_index_;
+        EmulationSession::GetInstance().HaltEmulation();
+    });
+
+    OnEmulationStarted();
+    return Core::SystemResultStatus::Success;
+}
+
+void EmulationSession::ShutdownEmulation() {
+    std::scoped_lock lock(m_mutex);
+
+    if (m_next_program_index != -1) {
+        ChangeProgram(m_next_program_index);
+        m_next_program_index = -1;
+    }
+
+    m_is_running = false;
+
+    // Unload user input.
+    m_system.HIDCore().UnloadInputDevices();
+
+    // Enable all controllers
+    m_system.HIDCore().SetSupportedStyleTag({Core::HID::NpadStyleSet::All});
+
+    // Shutdown the main emulated process
+    if (m_load_result == Core::SystemResultStatus::Success) {
+        m_system.DetachDebugger();
+        m_system.ShutdownMainProcess();
+        m_detached_tasks.WaitForAllTasks();
+        m_load_result = Core::SystemResultStatus::ErrorNotInitialized;
+        m_window.reset();
+        OnEmulationStopped(Core::SystemResultStatus::Success);
+        return;
+    }
+
+    // Tear down the render window.
+    m_window.reset();
+}
+
+void EmulationSession::PauseEmulation() {
+    std::scoped_lock lock(m_mutex);
+    m_system.Pause();
+    m_is_paused = true;
+}
+
+void EmulationSession::UnPauseEmulation() {
+    std::scoped_lock lock(m_mutex);
+    m_system.Run();
+    m_is_paused = false;
+}
+
+void EmulationSession::HaltEmulation() {
+    std::scoped_lock lock(m_mutex);
+    m_is_running = false;
+    m_cv.notify_one();
+}
+
+void EmulationSession::RunEmulation() {
+    {
+        std::scoped_lock lock(m_mutex);
+        m_is_running = true;
+    }
+
+    // Load the disk shader cache.
+    if (Settings::values.use_disk_shader_cache.GetValue()) {
+        LoadDiskCacheProgress(VideoCore::LoadCallbackStage::Prepare, 0, 0);
+        m_system.Renderer().ReadRasterizer()->LoadDiskResources(
+            m_system.GetApplicationProcessProgramID(), std::stop_token{}, LoadDiskCacheProgress);
+        LoadDiskCacheProgress(VideoCore::LoadCallbackStage::Complete, 0, 0);
+    }
+
+    void(m_system.Run());
+
+    if (m_system.DebuggerEnabled()) {
+        m_system.InitializeDebugger();
+    }
+
+    while (true) {
+        {
+            [[maybe_unused]] std::unique_lock lock(m_mutex);
+            if (m_cv.wait_for(lock, std::chrono::milliseconds(800),
+                              [&]() { return !m_is_running; })) {
+                // Emulation halted.
+                break;
+            }
+        }
+    }
+
+    // Reset current applet ID.
+    m_applet_id = static_cast<int>(Service::AM::AppletId::Application);
+}
+
+void EmulationSession::LoadDiskCacheProgress(VideoCore::LoadCallbackStage stage, int progress,
+                                             int max) {
+
+}
+
+void EmulationSession::OnEmulationStarted() {
+
+}
+
+void EmulationSession::OnEmulationStopped(Core::SystemResultStatus result) {
+
+}
+
+void EmulationSession::ChangeProgram(std::size_t program_index) {
+    LOG_INFO(Frontend, "Trying To Switch Program");
+    // Halt current emulation session
+    EmulationSession::GetInstance().HaltEmulation();
+    // Save the current state if necessary
+
+    // Shutdown the current emulation session cleanly
+        // Update the program index
+    EmulationSession::GetInstance().m_next_program_index = program_index;
+
+    // Initialize the new program
+    // Start the new emulation session
+    EmulationSession::GetInstance().RunEmulation();
+}
+
+u64 EmulationSession::GetProgramId(std::string programId) {
+    try {
+        return std::stoull(programId);
+    } catch (...) {
+        return 0;
+    }
+}
+
+bool EmulationSession::IsHandheldOnly() {
+    jconst npad_style_set = m_system.HIDCore().GetSupportedStyleTag();
+
+    if (npad_style_set.fullkey == 1) {
+        return false;
+    }
+
+    if (npad_style_set.handheld == 0) {
+        return false;
+    }
+
+    return !Settings::IsDockedMode();
+}
+
+void EmulationSession::SetDeviceType([[maybe_unused]] int index, int type) {
+    jauto controller = m_system.HIDCore().GetEmulatedControllerByIndex(index);
+    controller->SetNpadStyleIndex(static_cast<Core::HID::NpadStyleIndex>(type));
+}
+
+void EmulationSession::OnGamepadConnectEvent([[maybe_unused]] int index) {
+    jauto controller = m_system.HIDCore().GetEmulatedControllerByIndex(index);
+
+    // Ensure that player1 is configured correctly and handheld disconnected
+    if (controller->GetNpadIdType() == Core::HID::NpadIdType::Player1) {
+        jauto handheld = m_system.HIDCore().GetEmulatedController(Core::HID::NpadIdType::Handheld);
+
+        if (controller->GetNpadStyleIndex() == Core::HID::NpadStyleIndex::Handheld) {
+            handheld->SetNpadStyleIndex(Core::HID::NpadStyleIndex::Fullkey);
+            controller->SetNpadStyleIndex(Core::HID::NpadStyleIndex::Fullkey);
+            handheld->Disconnect();
+        }
+    }
+
+    // Ensure that handheld is configured correctly and player 1 disconnected
+    if (controller->GetNpadIdType() == Core::HID::NpadIdType::Handheld) {
+        jauto player1 = m_system.HIDCore().GetEmulatedController(Core::HID::NpadIdType::Player1);
+
+        if (controller->GetNpadStyleIndex() != Core::HID::NpadStyleIndex::Handheld) {
+            player1->SetNpadStyleIndex(Core::HID::NpadStyleIndex::Handheld);
+            controller->SetNpadStyleIndex(Core::HID::NpadStyleIndex::Handheld);
+            player1->Disconnect();
+        }
+    }
+
+    if (!controller->IsConnected()) {
+        controller->Connect();
+    }
+}
+
+void EmulationSession::OnGamepadDisconnectEvent([[maybe_unused]] int index) {
+    jauto controller = m_system.HIDCore().GetEmulatedControllerByIndex(index);
+    controller->Disconnect();
+}

src/ios/EmulationView.swift

@@ -0,0 +1,558 @@
+// 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 Foundation
+import GameController
+import UIKit
+import Metal
+
+struct MetalView: UIViewRepresentable {
+    let device: MTLDevice?
+    let configure: (UIView) -> Void
+    func makeUIView(context: Context) -> EmulationScreenView {
+        let view = EmulationScreenView()
+        configure(view.primaryScreen)
+        return view
+    }
+    func updateUIView(_ uiView: EmulationScreenView, context: Context) {
+        //
+    }
+}
+
+struct ControllerView: View {
+    let appui = AppUI.shared
+    @State var isPressed = false
+    @State var controllerconnected = false
+    @State private var x: CGFloat = 0.0
+    @State private var y: CGFloat = 0.0
+    @Environment(\.presentationMode) var presentationMode
+
+    var body: some View {
+        GeometryReader { geometry in
+            ZStack {
+                if !controllerconnected {
+                    OnScreenController(geometry: geometry) // i did this to clean it up as it was quite long lmfao
+                }
+            }
+        }
+        .onAppear {
+            print("checking for controller:")
+            controllerconnected = false
+            DispatchQueue.main.async {
+                setupControllers() // i dont know what half of this shit does
+            }
+        }
+    }
+
+    // Add a dictionary to track controller IDs
+    @State var controllerIDs: [GCController: Int] = [:]
+
+    private func setupControllers() {
+        NotificationCenter.default.addObserver(forName: .GCControllerDidConnect, object: nil, queue: .main) { notification in
+            if let controller = notification.object as? GCController {
+                print("wow controller onstart") // yippeeee
+                self.setupController(controller)
+                self.controllerconnected = true
+            } else {
+                print("not GCController :((((((") // wahhhhhhh
+            }
+        }
+
+
+        NotificationCenter.default.addObserver(forName: .GCControllerDidDisconnect, object: nil, queue: .main) { notification in
+            if let controller = notification.object as? GCController {
+                print("wow controller gone")
+                if self.controllerIDs.isEmpty {
+                    controllerconnected = false
+                }
+                self.controllerIDs.removeValue(forKey: controller) // Remove the controller ID
+            }
+        }
+
+        GCController.controllers().forEach { controller in
+            print("wow controller")
+            self.controllerconnected = true
+            self.setupController(controller)
+        }
+    }
+
+    private func setupController(_ controller: GCController) {
+        // Assign a unique ID to the controller, max 5 controllers
+        if controllerIDs.count < 6, controllerIDs[controller] == nil {
+            controllerIDs[controller] = controllerIDs.count
+        }
+        guard let controllerId = controllerIDs[controller] else { return }
+        if let extendedGamepad = controller.extendedGamepad {
+            // Handle extended gamepad
+            extendedGamepad.dpad.up.pressedChangedHandler = { button, value, pressed in
+                pressed ? self.touchDown(.directionalPadUp, controllerId: controllerId) : self.touchUpInside(.directionalPadUp, controllerId: controllerId)
+            }
+            extendedGamepad.dpad.down.pressedChangedHandler = { button, value, pressed in
+                pressed ? self.touchDown(.directionalPadDown, controllerId: controllerId) : self.touchUpInside(.directionalPadDown, controllerId: controllerId)
+            }
+            extendedGamepad.dpad.left.pressedChangedHandler = { button, value, pressed in
+                pressed ? self.touchDown(.directionalPadLeft, controllerId: controllerId) : self.touchUpInside(.directionalPadLeft, controllerId: controllerId)
+            }
+            extendedGamepad.dpad.right.pressedChangedHandler = { button, value, pressed in
+                pressed ? self.touchDown(.directionalPadRight, controllerId: controllerId) : self.touchUpInside(.directionalPadRight, controllerId: controllerId)
+            }
+            extendedGamepad.buttonOptions?.pressedChangedHandler = { button, value, pressed in
+                pressed ? self.touchDown(.minus, controllerId: controllerId) : self.touchUpInside(.minus, controllerId: controllerId)
+            }
+            extendedGamepad.buttonMenu.pressedChangedHandler = { button, value, pressed in
+                pressed ? self.touchDown(.plus, controllerId: controllerId) : self.touchUpInside(.plus, controllerId: controllerId)
+            }
+            extendedGamepad.buttonA.pressedChangedHandler = { button, value, pressed in
+                pressed ? self.touchDown(.A, controllerId: controllerId) : self.touchUpInside(.A, controllerId: controllerId)
+            }
+            extendedGamepad.buttonB.pressedChangedHandler = { button, value, pressed in
+                pressed ? self.touchDown(.B, controllerId: controllerId) : self.touchUpInside(.B, controllerId: controllerId)
+            }
+            extendedGamepad.buttonX.pressedChangedHandler = { button, value, pressed in
+                pressed ? self.touchDown(.X, controllerId: controllerId) : self.touchUpInside(.X, controllerId: controllerId)
+            }
+            extendedGamepad.buttonY.pressedChangedHandler = { button, value, pressed in
+                pressed ? self.touchDown(.Y, controllerId: controllerId) : self.touchUpInside(.Y, controllerId: controllerId)
+            }
+            extendedGamepad.leftShoulder.pressedChangedHandler = { button, value, pressed in
+                pressed ? self.touchDown(.triggerL, controllerId: controllerId) : self.touchUpInside(.L, controllerId: controllerId)
+            }
+            extendedGamepad.leftTrigger.pressedChangedHandler = { button, value, pressed in
+                pressed ? self.touchDown(.triggerZL, controllerId: controllerId) : self.touchUpInside(.triggerZL, controllerId: controllerId)
+            }
+            extendedGamepad.rightShoulder.pressedChangedHandler = { button, value, pressed in
+                pressed ? self.touchDown(.triggerR, controllerId: controllerId) : self.touchUpInside(.triggerR, controllerId: controllerId)
+            }
+            extendedGamepad.leftThumbstickButton?.pressedChangedHandler = { button, value, pressed in
+                pressed ? self.touchDown(.L, controllerId: controllerId) : self.touchUpInside(.triggerR, controllerId: controllerId)
+            }
+            extendedGamepad.rightThumbstickButton?.pressedChangedHandler = { button, value, pressed in
+                pressed ? self.touchDown(.R, controllerId: controllerId) : self.touchUpInside(.triggerR, controllerId: controllerId)
+            }
+            extendedGamepad.rightTrigger.pressedChangedHandler = { button, value, pressed in
+                pressed ? self.touchDown(.triggerZR, controllerId: controllerId) : self.touchUpInside(.triggerZR, controllerId: controllerId)
+            }
+            extendedGamepad.buttonHome?.pressedChangedHandler = { button, value, pressed in
+                if pressed {
+                    appui.exit()
+                    presentationMode.wrappedValue.dismiss()
+                }
+            }
+            extendedGamepad.leftThumbstick.valueChangedHandler = { dpad, x, y in
+                self.appui.thumbstickMoved(analog: .left, x: x, y: y, controllerid: controllerId)
+            }
+            extendedGamepad.rightThumbstick.valueChangedHandler = { dpad, x, y in
+                self.appui.thumbstickMoved(analog: .right, x: x, y: y, controllerid: controllerId)
+            }
+            if let motion = controller.motion {
+                var lastTimestamp = Date().timeIntervalSince1970 // Initialize timestamp when motion starts
+                motion.valueChangedHandler = { motion in
+                    // Get current time
+                    let currentTimestamp = Date().timeIntervalSince1970
+
+                    // Update last timestamp
+                    lastTimestamp = currentTimestamp
+
+                    // Get gyroscope data
+                    let gyroX = motion.rotationRate.x
+                    let gyroY = motion.rotationRate.y
+                    let gyroZ = motion.rotationRate.z
+
+                    // Get accelerometer data
+                    let accelX = motion.gravity.x + motion.userAcceleration.x
+                    let accelY = motion.gravity.y + motion.userAcceleration.y
+                    let accelZ = motion.gravity.z + motion.userAcceleration.z
+
+                    print("\(gyroX), \(gyroY), \(gyroZ), \(accelX), \(accelY), \(accelZ)")
+
+                    // Call your gyroMoved function with the motion data
+                    appui.gyroMoved(x: Float(gyroX), y: Float(gyroY), z: Float(gyroZ), accelX: Float(accelX), accelY: Float(accelY), accelZ: Float(accelZ), controllerId: Int32(controllerId), deltaTimestamp: Int32(lastTimestamp))
+                }
+            }
+        } else if let microGamepad = controller.microGamepad {
+            // Handle micro gamepad
+            microGamepad.dpad.up.pressedChangedHandler = { button, value, pressed in
+                pressed ? self.touchDown(.directionalPadUp, controllerId: controllerId) : self.touchUpInside(.directionalPadUp, controllerId: controllerId)
+            }
+            microGamepad.dpad.down.pressedChangedHandler = { button, value, pressed in
+                pressed ? self.touchDown(.directionalPadDown, controllerId: controllerId) : self.touchUpInside(.directionalPadDown, controllerId: controllerId)
+            }
+            microGamepad.dpad.left.pressedChangedHandler = { button, value, pressed in
+                pressed ? self.touchDown(.directionalPadLeft, controllerId: controllerId) : self.touchUpInside(.directionalPadLeft, controllerId: controllerId)
+            }
+            microGamepad.dpad.right.pressedChangedHandler = { button, value, pressed in
+                pressed ? self.touchDown(.directionalPadRight, controllerId: controllerId) : self.touchUpInside(.directionalPadRight, controllerId: controllerId)
+            }
+            microGamepad.buttonA.pressedChangedHandler = { button, value, pressed in
+                pressed ? self.touchDown(.A, controllerId: controllerId) : self.touchUpInside(.A, controllerId: controllerId)
+            }
+            microGamepad.buttonX.pressedChangedHandler = { button, value, pressed in
+                pressed ? self.touchDown(.X, controllerId: controllerId) : self.touchUpInside(.X, controllerId: controllerId)
+            }
+        }
+    }
+
+    private func touchDown(_ button: VirtualControllerButtonType, controllerId: Int) {
+        appui.virtualControllerButtonDown(button: button, controllerid: controllerId)    }
+
+    private func touchUpInside(_ button: VirtualControllerButtonType, controllerId: Int) {
+        appui.virtualControllerButtonUp(button: button, controllerid: controllerId)
+    }
+}
+
+struct OnScreenController: View {
+    @State var geometry: GeometryProxy
+    var body: some View {
+        if geometry.size.height > geometry.size.width && UIDevice.current.userInterfaceIdiom != .pad {
+            // portrait
+            VStack {
+                Spacer()
+                VStack {
+                    HStack {
+                        VStack {
+                            ShoulderButtonsViewLeft()
+                            ZStack {
+                                Joystick()
+                                DPadView()
+                            }
+                        }
+                        .padding()
+                        VStack {
+                            ShoulderButtonsViewRight()
+                            ZStack {
+                                Joystick(iscool: true) // hope this works
+                                ABXYView()
+                            }
+                        }
+                        .padding()
+                    }
+                    HStack {
+                        ButtonView(button: .plus).padding(.horizontal, 40)
+                        ButtonView(button: .minus).padding(.horizontal, 40)
+                    }
+                }
+                .padding(.bottom, geometry.size.height / 3.2) // very broken
+            }
+        } else {
+            // could be landscape
+            VStack {
+                HStack {
+                    Spacer()
+                    ButtonView(button: .home)
+                        .padding(.horizontal)
+                }
+                Spacer()
+                VStack {
+                    HStack {
+
+                        // gotta fuckin add + and - now
+                        VStack {
+                            ShoulderButtonsViewLeft()
+                            ZStack {
+                                Joystick()
+                                DPadView()
+                            }
+                        }
+                        HStack {
+                            Spacer()
+                            VStack {
+                                Spacer()
+                                ButtonView(button: .plus) // Adding the + button
+                            }
+                            VStack {
+                                Spacer()
+                                ButtonView(button: .minus) // Adding the - button
+                            }
+                            Spacer()
+                        }
+                        VStack {
+                            ShoulderButtonsViewRight()
+                            ZStack {
+                                Joystick(iscool: true) // hope this work s
+                                ABXYView()
+                            }
+                        }
+                    }
+                }
+                .padding(.bottom, geometry.size.height / 11) // also extremally broken (
+            }
+        }
+    }
+}
+
+struct ShoulderButtonsViewLeft: View {
+    var body: some View {
+        HStack {
+            ButtonView(button: .triggerZL).padding(.horizontal)
+            ButtonView(button: .triggerL).padding(.horizontal)
+        }
+        .frame(width: 160, height: 20)
+    }
+}
+
+struct ShoulderButtonsViewRight: View {
+    var body: some View {
+        HStack {
+            ButtonView(button: .triggerR).padding(.horizontal)
+            ButtonView(button: .triggerZR).padding(.horizontal)
+        }
+        .frame(width: 160, height: 20)
+
+    }
+}
+
+struct DPadView: View {
+    var body: some View {
+        VStack {
+            ButtonView(button: .directionalPadUp)
+            HStack {
+                ButtonView(button: .directionalPadLeft)
+                Spacer(minLength: 20)
+                ButtonView(button: .directionalPadRight)
+            }
+            ButtonView(button: .directionalPadDown).padding(.horizontal)
+        }
+        .frame(width: 145, height: 145)
+    }
+}
+
+struct ABXYView: View {
+    var body: some View {
+        VStack {
+            ButtonView(button: .X)
+            HStack {
+                ButtonView(button: .Y)
+                Spacer(minLength: 20)
+                ButtonView(button: .A)
+            }
+            ButtonView(button: .B).padding(.horizontal)
+        }
+        .frame(width: 145, height: 145)
+    }
+}
+
+class Haptics {
+    static let shared = Haptics()
+    private init() { }
+    func play(_ feedbackStyle: UIImpactFeedbackGenerator.FeedbackStyle) {
+        print("haptics")
+        UIImpactFeedbackGenerator(style: feedbackStyle).impactOccurred()
+    }
+    func notify(_ feedbackType: UINotificationFeedbackGenerator.FeedbackType) {
+        UINotificationFeedbackGenerator().notificationOccurred(feedbackType)
+    }
+}
+
+struct ButtonView: View {
+    var button: VirtualControllerButtonType
+    @StateObject private var viewModel: EmulationViewModel = EmulationViewModel()
+    let appui = AppUI.shared
+    @State var mtkView: MTKView?
+    @State var width: CGFloat = 45
+    @State var height: CGFloat = 45
+    @State var isPressed = false
+    var id: Int {
+        if onscreenjoy {
+            return 8
+        }
+        return 0
+    }
+    @AppStorage("onscreenhandheld") var onscreenjoy: Bool = false
+    @Environment(\.colorScheme) var colorScheme
+    @Environment(\.presentationMode) var presentationMode
+
+    var body: some View {
+        Image(systemName: buttonText)
+            .resizable()
+            .frame(width: width, height: height)
+            .foregroundColor(colorScheme == .dark ? Color.gray : Color.gray)
+            .opacity(isPressed ? 0.5 : 1)
+            .gesture(
+                DragGesture(minimumDistance: 0)
+                    .onChanged { _ in
+                        if !self.isPressed {
+                            self.isPressed = true
+                            DispatchQueue.main.async {
+                                if button == .home {
+                                    presentationMode.wrappedValue.dismiss()
+                                    appui.exit()
+                                } else {
+                                    appui.virtualControllerButtonDown(button: button, controllerid: id)
+                                    Haptics.shared.play(.heavy)
+                                }
+                            }
+                        }
+                    }
+                    .onEnded { _ in
+                        self.isPressed = false
+                        DispatchQueue.main.async {
+                            if button != .home {
+                                appui.virtualControllerButtonUp(button: button, controllerid: id)
+                            }
+                        }
+                    }
+            )
+            .onAppear() {
+                if button == .triggerL || button == .triggerZL || button == .triggerZR || button == .triggerR {
+                    width = 65
+                }
+
+
+                if button == .minus || button == .plus || button == .home {
+                    width = 35
+                    height = 35
+                }
+            }
+    }
+
+    private var buttonText: String {
+        switch button {
+        case .A: return "a.circle.fill"
+        case .B: return "b.circle.fill"
+        case .X: return "x.circle.fill"
+        case .Y: return "y.circle.fill"
+        case .directionalPadUp: return "arrowtriangle.up.circle.fill"
+        case .directionalPadDown: return "arrowtriangle.down.circle.fill"
+        case .directionalPadLeft: return "arrowtriangle.left.circle.fill"
+        case .directionalPadRight: return "arrowtriangle.right.circle.fill"
+        case .triggerZL: return"zl.rectangle.roundedtop.fill"
+        case .triggerZR: return "zr.rectangle.roundedtop.fill"
+        case .triggerL: return "l.rectangle.roundedbottom.fill"
+        case .triggerR: return "r.rectangle.roundedbottom.fill"
+        case .plus: return "plus.circle.fill"
+        case .minus: return "minus.circle.fill"
+        case .home: return "house.circle.fill"
+        default: return ""
+        }
+    }
+}
+
+struct EmulationView: View {
+    @StateObject private var viewModel: EmulationViewModel
+    @State var controllerconnected = false
+    @State var appui = AppUI.shared
+    var device: MTLDevice? = MTLCreateSystemDefaultDevice()
+    @State var CaLayer: CAMetalLayer?
+    @State var ShowPopup: Bool = false
+    @State var mtkview: MTKView?
+    @State private var thread: Thread!
+    @State var uiTabBarController: UITabBarController?
+    @State private var isFirstFrameShown = false
+    @State private var timer: Timer?
+    @Environment(\.scenePhase) var scenePhase
+
+    init(game: EmulationGame?) {
+        _viewModel = StateObject(wrappedValue: EmulationViewModel())
+    }
+
+    var body: some View {
+        ZStack {
+            MetalView(device: device) { view in
+                DispatchQueue.main.async {
+                    if let metalView = view as? MTKView {
+                        mtkview = metalView
+                        viewModel.configureAppUI(with: metalView)
+                    } else {
+                        print("Error: view is not of type MTKView")
+                    }
+                }
+            }
+            .onRotate { size in
+                viewModel.handleOrientationChange()
+            }
+            ControllerView()
+        }
+        .overlay(
+            // Loading screen overlay on top of MetalView
+            Group {
+                if !isFirstFrameShown {
+                    LoadingView()
+                }
+            }
+            .transition(.opacity)
+        )
+        .onAppear {
+            UIApplication.shared.isIdleTimerDisabled = true
+            startPollingFirstFrameShowed()
+        }
+        .onDisappear {
+            stopPollingFirstFrameShowed()
+            uiTabBarController?.tabBar.isHidden = false
+            viewModel.customButtonTapped()
+        }
+        .navigationBarBackButtonHidden(true)
+        // .introspect(.tabView, on: .iOS(.v13, .v14, .v15, .v16, .v17)) { (tabBarController) in
+        //     tabBarController.tabBar.isHidden = true
+        //     uiTabBarController = tabBarController
+        // }
+    }
+
+    private func startPollingFirstFrameShowed() {
+        timer = Timer.scheduledTimer(withTimeInterval: 0.1, repeats: true) { _ in
+            if appui.FirstFrameShowed() {
+                withAnimation {
+                    isFirstFrameShown = true
+                }
+                stopPollingFirstFrameShowed()
+            }
+        }
+    }
+
+    private func stopPollingFirstFrameShowed() {
+        timer?.invalidate()
+        timer = nil
+        print("Timer Invalidated")
+    }
+}
+
+struct LoadingView: View {
+    var body: some View {
+        VStack {
+            ProgressView("Loading...")
+                // .font(.system(size: 90))
+                .progressViewStyle(CircularProgressViewStyle())
+                .padding()
+            Text("Please wait while the game loads.")
+        }
+        .frame(maxWidth: .infinity, maxHeight: .infinity)
+        .background(Color.black.opacity(0.8))
+        .foregroundColor(.white)
+    }
+}
+
+extension View {
+    func onRotate(perform action: @escaping (CGSize) -> Void) -> some View {
+        self.modifier(DeviceRotationModifier(action: action))
+    }
+}
+
+struct DeviceRotationModifier: ViewModifier {
+    let action: (CGSize) -> Void
+    @State var startedfirst: Bool = false
+
+    func body(content: Content) -> some View { content
+        .background(GeometryReader { geometry in
+            Color.clear
+                .preference(key: SizePreferenceKey.self, value: geometry.size)
+        })
+        .onPreferenceChange(SizePreferenceKey.self) { newSize in
+            if startedfirst {
+                action(newSize)
+            } else {
+                startedfirst = true
+            }
+        }
+    }
+}
+
+struct SizePreferenceKey: PreferenceKey {
+    static var defaultValue: CGSize = .zero
+
+    static func reduce(value: inout CGSize, nextValue: () -> CGSize) {
+        value = nextValue()
+    }
+}

src/ios/EmulationWindow.h

@@ -0,0 +1,86 @@
+// 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
+
+#if __has_include(<Metal/Metal.hpp>)
+#import <Metal/Metal.hpp>
+#else
+#import <Metal/Metal.h>
+#endif
+#import <Foundation/Foundation.h>
+#import <UIKit/UIKit.h>
+#import <QuartzCore/QuartzCore.h>
+#import <QuartzCore/CAMetalLayer.h>
+
+#include <memory>
+#include <span>
+
+#include "core/frontend/emu_window.h"
+#include "core/frontend/graphics_context.h"
+#include "input_common/main.h"
+
+class GraphicsContext_Apple final : public Core::Frontend::GraphicsContext {
+public:
+    explicit GraphicsContext_Apple(std::shared_ptr<Common::DynamicLibrary> driver_library)
+        : m_driver_library{driver_library} {}
+
+    ~GraphicsContext_Apple() = default;
+
+    std::shared_ptr<Common::DynamicLibrary> GetDriverLibrary() override {
+        return m_driver_library;
+    }
+
+private:
+    std::shared_ptr<Common::DynamicLibrary> m_driver_library;
+};
+
+NS_ASSUME_NONNULL_BEGIN
+
+class EmulationWindow final : public Core::Frontend::EmuWindow {
+public:
+    EmulationWindow(InputCommon::InputSubsystem* input_subsystem, CAMetalLayer* surface, CGSize size,
+                      std::shared_ptr<Common::DynamicLibrary> driver_library);
+
+    ~EmulationWindow() = default;
+
+    void OnSurfaceChanged(CAMetalLayer* surface, CGSize size);
+    void OrientationChanged(UIInterfaceOrientation orientation);
+    void OnFrameDisplayed() override;
+
+    void OnTouchPressed(int id, float x, float y);
+    void OnTouchMoved(int id, float x, float y);
+    void OnTouchReleased(int id);
+
+    void OnGamepadButtonEvent(int player_index, int button_id, bool pressed);
+    void OnGamepadJoystickEvent(int player_index, int stick_id, float x, float y);
+    void OnGamepadMotionEvent(int player_index, u64 delta_timestamp, float gyro_x, float gyro_y, float gyro_z, float accel_x, float accel_y, float accel_z);
+
+    std::unique_ptr<Core::Frontend::GraphicsContext> CreateSharedContext() const override {
+        return {std::make_unique<GraphicsContext_Apple>(m_driver_library)};
+    }
+
+
+    bool HasFirstFrame() const {
+        return m_first_frame;
+    }
+
+    bool IsShown() const override {
+        return true;
+    };
+
+private:
+    float m_window_width{};
+    float m_window_height{};
+    CGSize m_size;
+    bool is_portrait = true;
+
+    InputCommon::InputSubsystem* m_input_subsystem{};
+    std::shared_ptr<Common::DynamicLibrary> m_driver_library;
+
+    bool m_first_frame = false;
+};
+
+NS_ASSUME_NONNULL_END

src/ios/EmulationWindow.mm

@@ -0,0 +1,82 @@
+// 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 "EmulationWindow.h"
+#import "EmulationSession.h"
+
+#include <SDL.h>
+
+#include "common/logging.h"
+#include "input_common/drivers/touch_screen.h"
+#include "input_common/drivers/virtual_amiibo.h"
+#include "input_common/drivers/virtual_gamepad.h"
+#include "input_common/main.h"
+
+void EmulationWindow::OnSurfaceChanged(CAMetalLayer* surface, CGSize size) {
+    m_size = size;
+
+    m_window_width = size.width;
+    m_window_height = size.height;
+
+    // Ensures that we emulate with the correct aspect ratio.
+    // UpdateCurrentFramebufferLayout(m_window_width, m_window_height);
+
+    window_info.render_surface = (__bridge void *)surface;
+    window_info.render_surface_scale = [[UIScreen mainScreen] nativeScale];
+}
+
+void EmulationWindow::OrientationChanged(UIInterfaceOrientation orientation) {
+    is_portrait = orientation == UIInterfaceOrientationPortrait;
+}
+
+void EmulationWindow::OnTouchPressed(int id, float x, float y) {
+    const auto [touch_x, touch_y] = MapToTouchScreen(x, y);
+    EmulationSession::GetInstance().GetInputSubsystem().GetTouchScreen()->TouchPressed(touch_x,
+                                                                                       touch_y, id);
+}
+
+void EmulationWindow::OnTouchMoved(int id, float x, float y) {
+    const auto [touch_x, touch_y] = MapToTouchScreen(x, y);
+    EmulationSession::GetInstance().GetInputSubsystem().GetTouchScreen()->TouchMoved(touch_x,
+                                                                                     touch_y, id);
+}
+
+void EmulationWindow::OnTouchReleased(int id) {
+    EmulationSession::GetInstance().GetInputSubsystem().GetTouchScreen()->TouchReleased(id);
+}
+
+void EmulationWindow::OnGamepadButtonEvent(int player_index, int button_id, bool pressed) {
+    m_input_subsystem->GetVirtualGamepad()->SetButtonState(player_index, button_id, pressed);
+}
+
+void EmulationWindow::OnGamepadJoystickEvent(int player_index, int stick_id, float x, float y) {
+    m_input_subsystem->GetVirtualGamepad()->SetStickPosition(player_index, stick_id, x, y);
+}
+
+void EmulationWindow::OnGamepadMotionEvent(int player_index, u64 delta_timestamp, float gyro_x, float gyro_y, float gyro_z, float accel_x, float accel_y, float accel_z) {
+    m_input_subsystem->GetVirtualGamepad()->SetMotionState(player_index, delta_timestamp, gyro_x, gyro_y, gyro_z, accel_x, accel_y, accel_z);
+}
+
+void EmulationWindow::OnFrameDisplayed() {
+    if (!m_first_frame) {
+        m_first_frame = true;
+    }
+}
+
+EmulationWindow::EmulationWindow(InputCommon::InputSubsystem* input_subsystem, CAMetalLayer* surface, CGSize size, std::shared_ptr<Common::DynamicLibrary> driver_library)
+    : m_window_width{}, m_window_height{}, m_size{size}, is_portrait{true}, m_input_subsystem{input_subsystem}, m_driver_library{driver_library}, m_first_frame{false} {
+    LOG_INFO(Frontend, "initializing");
+
+    if (!surface) {
+        LOG_CRITICAL(Frontend, "surface is nullptr");
+        return;
+    }
+
+    OnSurfaceChanged(surface, m_size);
+    window_info.render_surface_scale = [[UIScreen mainScreen] nativeScale];
+    window_info.type = Core::Frontend::WindowSystemType::Cocoa;
+
+    m_input_subsystem->Initialize();
+}

src/ios/FileManager.swift

@@ -0,0 +1,197 @@
+// 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 Foundation
+import UIKit
+
+struct Core : Comparable, Hashable {
+
+    let name = "Yuzu"
+    var games: [EmulationGame]
+    let root: URL
+
+    static func < (lhs: Core, rhs: Core) -> Bool {
+        lhs.name < rhs.name
+    }
+
+    func AddFirmware(at fileURL: URL) {
+        do {
+            let fileManager = FileManager.default
+            let documentsDirectory = fileManager.urls(for: .documentDirectory, in: .userDomainMask).first!
+            let destinationURL = documentsDirectory.appendingPathComponent("nand/system/Contents/registered")
+            if !fileManager.fileExists(atPath: destinationURL.path) {
+                try fileManager.createDirectory(at: destinationURL, withIntermediateDirectories: true, attributes: nil)
+            }
+            //try Zip.unzipFile(fileURL, destination: destinationURL, overwrite: true, password: nil)
+            print("File unzipped successfully to \(destinationURL.path)")
+        } catch {
+            print("Failed to unzip file: \(error)")
+        }
+    }
+}
+
+enum LibManError : Error {
+    case ripenum, urlgobyebye
+}
+
+class LibraryManager {
+    static let shared = LibraryManager()
+    let documentdir = FileManager.default.urls(for: .documentDirectory, in: .userDomainMask)[0].appendingPathComponent("roms", conformingTo: .folder)
+
+    func removerom(_ game: EmulationGame) throws {
+        do {
+            try FileManager.default.removeItem(at: game.fileURL)
+        } catch {
+            throw error
+        }
+    }
+
+    func homebrewroms() -> [EmulationGame] {
+        // TODO(lizzie): this is horrible
+        var urls: [URL] = []
+        let sdmc = FileManager.default.urls(for: .documentDirectory, in: .userDomainMask)[0].appendingPathComponent("sdmc", conformingTo: .folder)
+        let sdfolder = sdmc.appendingPathComponent("switch", conformingTo: .folder)
+        if FileManager.default.fileExists(atPath: sdfolder.path) {
+            if let dirContents = FileManager.default.enumerator(at: sdmc, includingPropertiesForKeys: nil, options: []) {
+                do {
+                    try dirContents.forEach() { files in
+                        if let file = files as? URL {
+                            let getaboutfile = try file.resourceValues(forKeys: [.isRegularFileKey])
+                            if let isfile = getaboutfile.isRegularFile, isfile {
+                                if ["nso", "nro"].contains(file.pathExtension.lowercased()) {
+                                    urls.append(file)
+                                }
+                            }
+                        }
+                    }
+                } catch {
+                    if let dirContents = FileManager.default.enumerator(at: documentdir, includingPropertiesForKeys: nil, options: []) {
+                        do {
+                            try dirContents.forEach() { files in
+                                if let file = files as? URL {
+                                    let getaboutfile = try file.resourceValues(forKeys: [.isRegularFileKey])
+                                    if let isfile = getaboutfile.isRegularFile, isfile {
+                                        if ["nso", "nro"].contains(file.pathExtension.lowercased()) {
+                                            urls.append(file)
+                                        }
+                                    }
+                                }
+                            }
+                        } catch {
+                            print("damn")
+                            if let dirContents = FileManager.default.enumerator(at: documentdir, includingPropertiesForKeys: nil, options: []) {
+                                do {
+                                    try dirContents.forEach() { files in
+                                        if let file = files as? URL {
+                                            let getaboutfile = try file.resourceValues(forKeys: [.isRegularFileKey])
+                                            if let isfile = getaboutfile.isRegularFile, isfile {
+                                                if ["nso", "nro"].contains(file.pathExtension.lowercased()) {
+                                                    urls.append(file)
+                                                }
+                                            }
+                                        }
+                                    }
+                                } catch {
+                                    return []
+                                }
+                            } else {
+                                return []
+                            }
+
+                        }
+                    }
+                }
+            }
+        }
+        if let dirContents = FileManager.default.enumerator(at: documentdir, includingPropertiesForKeys: nil, options: []) {
+            do {
+                try dirContents.forEach() { files in
+                    if let file = files as? URL {
+                        let getaboutfile = try file.resourceValues(forKeys: [.isRegularFileKey])
+                        if let isfile = getaboutfile.isRegularFile, isfile {
+                            if ["nso", "nro"].contains(file.pathExtension.lowercased()) {
+                                urls.append(file)
+                            }
+                        }
+                    }
+                }
+            } catch {
+                return []
+            }
+        } else {
+            return []
+        }
+        func games(from urls: [URL]) -> [EmulationGame] {
+            var pomelogames: [EmulationGame] = []
+            pomelogames = urls.reduce(into: [EmulationGame]()) { partialResult, element in
+                let iscustom = element.startAccessingSecurityScopedResource()
+                let information = AppUI.shared.information(for: element)
+                let game = EmulationGame(developer: information.developer, fileURL: element, imageData: information.iconData, title: information.title)
+                if iscustom {
+                    element.stopAccessingSecurityScopedResource()
+                }
+                partialResult.append(game)
+            }
+            return pomelogames
+        }
+        return games(from: urls)
+    }
+
+    func library() throws -> Core {
+        func getromsfromdir() throws -> [URL] {
+            guard let dirContents = FileManager.default.enumerator(at: documentdir, includingPropertiesForKeys: nil, options: []) else {
+                print("uhoh how unfortunate for some reason FileManager.default.enumerator aint workin")
+                throw LibManError.ripenum
+            }
+            let appui = AppUI.shared
+            var urls: [URL] = []
+            try dirContents.forEach() { files in
+                if let file = files as? URL {
+                    let getaboutfile = try file.resourceValues(forKeys: [.isRegularFileKey])
+                    if let isfile = getaboutfile.isRegularFile, isfile {
+                        if ["nca", "nro", "nsp", "nso", "xci"].contains(file.pathExtension.lowercased()) {
+                            urls.append(file)
+                        }
+                    }
+                }
+            }
+            let sdmc = FileManager.default.urls(for: .documentDirectory, in: .userDomainMask)[0].appendingPathComponent("sdmc", conformingTo: .folder)
+            let sdfolder = sdmc.appendingPathComponent("switch", conformingTo: .folder)
+            if FileManager.default.fileExists(atPath: sdfolder.path) {
+                if let dirContents = FileManager.default.enumerator(at: sdmc, includingPropertiesForKeys: nil, options: []) {
+                    try dirContents.forEach() { files in
+                        if let file = files as? URL {
+                            let getaboutfile = try file.resourceValues(forKeys: [.isRegularFileKey])
+                            if let isfile = getaboutfile.isRegularFile, isfile {
+                                if ["nso", "nro"].contains(file.pathExtension.lowercased()) {
+                                    urls.append(file)
+                                }
+                            }
+                        }
+                    }
+                }
+            }
+            appui.insert(games: urls)
+            return urls
+        }
+
+        func games(from urls: [URL], core: inout Core) {
+            core.games = urls.reduce(into: [EmulationGame]()) { partialResult, element in
+                let iscustom = element.startAccessingSecurityScopedResource()
+                let information = AppUI.shared.information(for: element)
+                let game = EmulationGame(developer: information.developer, fileURL: element, imageData: information.iconData, title: information.title)
+                if iscustom {
+                    element.stopAccessingSecurityScopedResource()
+                }
+                partialResult.append(game)
+            }
+        }
+        let directory = FileManager.default.urls(for: .documentDirectory, in: .userDomainMask)[0]
+        var YuzuCore = Core(games: [], root: directory)
+        games(from: try getromsfromdir(), core: &YuzuCore)
+        return YuzuCore
+    }
+}

src/ios/FolderMonitor.swift

@@ -0,0 +1,49 @@
+// 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
+
+class FolderMonitor {
+    private var folderDescriptor: Int32 = -1
+    private var folderMonitorSource: DispatchSourceFileSystemObject?
+    private let folderURL: URL
+    private let onFolderChange: () -> Void
+    init(folderURL: URL, onFolderChange: @escaping () -> Void) {
+        self.folderURL = folderURL
+        self.onFolderChange = onFolderChange
+        startMonitoring()
+    }
+    private func startMonitoring() {
+        folderDescriptor = open(folderURL.path, O_EVTONLY)
+        guard folderDescriptor != -1 else {
+            print("Failed to open folder descriptor.")
+            return
+        }
+
+        folderMonitorSource = DispatchSource.makeFileSystemObjectSource(
+            fileDescriptor: folderDescriptor,
+            eventMask: .write,
+            queue: DispatchQueue.global()
+        )
+        folderMonitorSource?.setEventHandler { [weak self] in
+            self?.folderDidChange()
+        }
+        folderMonitorSource?.setCancelHandler {
+            close(self.folderDescriptor)
+        }
+        folderMonitorSource?.resume()
+    }
+
+    private func folderDidChange() {
+        // Detect the change and call the refreshcore function
+        print("Folder changed! New file added or removed.")
+        DispatchQueue.main.async { [weak self] in
+            self?.onFolderChange()
+        }
+    }
+    deinit {
+        folderMonitorSource?.cancel()
+    }
+}

src/ios/GameButtonView.swift

@@ -0,0 +1,147 @@
+// 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 Foundation
+import UIKit
+import UniformTypeIdentifiers
+import Combine
+
+struct SettingsView: View {
+    @ObservedObject var core: EmulationViewModel
+    @State var showprompt = false
+
+    @AppStorage("icon") var iconused = 1
+    var body: some View {
+        NavigationStack {
+
+        }
+    }
+}
+
+struct GameIconView: View {
+    var game: EmulationGame
+    @Binding var selectedGame: EmulationGame?
+    @State var startgame: Bool = false
+    @State var timesTapped: Int = 0
+
+    var isSelected: Bool {
+        selectedGame == game
+    }
+
+    var body: some View {
+        NavigationLink(
+            destination: EmulationView(game: game).toolbar(.hidden, for: .tabBar),
+            isActive: $startgame,
+            label: {
+                EmptyView()
+            }
+        )
+        VStack(spacing: 5) {
+            if isSelected {
+                Text(game.title)
+                    .foregroundColor(.blue)
+                    .font(.title2)
+            }
+            if let uiImage = UIImage(data: game.imageData) {
+                Image(uiImage: uiImage)
+                    .resizable()
+                    .scaledToFit()
+                    .frame(width: isSelected ? 200 : 180, height: isSelected ? 200 : 180)
+                    .cornerRadius(10)
+                    .overlay(
+                        isSelected ? RoundedRectangle(cornerRadius: 10)
+                            .stroke(Color.blue, lineWidth: 5)
+                            : nil
+                    )
+                    .onTapGesture {
+                        if isSelected {
+                            startgame = true
+                            print(isSelected)
+                        }
+                        if !isSelected {
+                            selectedGame = game
+                        }
+                    }
+            } else {
+                Image(systemName: "questionmark")
+                    .resizable()
+                    .scaledToFit()
+                    .frame(width: 200, height: 200)
+                    .cornerRadius(10)
+                    .onTapGesture { selectedGame = game }
+            }
+        }
+        .frame(width: 200, height: 250)
+    }
+}
+
+// Remove or refactor HomeView and GameCarouselView to not use Core or BottomMenuView(core: core) with Core.
+// If these are not used in the iOS UI, comment them out to avoid build errors.
+// struct HomeView: View {
+//     @State private var selectedGame: EmulationGame? = nil
+
+//     @State var core: Core
+
+//     init(selectedGame: EmulationGame? = nil, core: Core) {
+//         _core = State(wrappedValue: core)
+//         self.selectedGame = selectedGame
+//         refreshcore()
+//     }
+
+//     var body: some View {
+//         NavigationStack {
+//             GeometryReader { geometry in
+//                 VStack {
+//                     GameCarouselView(core: core, selectedGame: $selectedGame)
+//                     Spacer()
+//                     BottomMenuView(core: core)
+//                 }
+//             }
+//         }
+//         .background(Color.gray.opacity(0.1))
+//         .edgesIgnoringSafeArea(.all)
+//         .onAppear {
+//             refreshcore()
+//             if let documentsDirectory = FileManager.default.urls(for: .documentDirectory, in: .userDomainMask).first {
+//                 let romsFolderURL = documentsDirectory.appendingPathComponent("roms")
+//                 let folderMonitor = FolderMonitor(folderURL: romsFolderURL) {
+//                     do {
+//                         core = Core(games: [], root: documentsDirectory)
+//                         core = try LibraryManager.shared.library()
+//                     } catch {
+//                         print("Error refreshing core: \(error)")
+//                     }
+//                 }
+//             }
+//         }
+//     }
+
+//     func refreshcore() {
+//         print("Loading library...")
+//         do {
+//             core = try LibraryManager.shared.library()
+//             print(core.games)
+//         } catch {
+//             print("Failed to fetch library: \(error)")
+//             return
+//         }
+//     }
+// }
+
+// struct GameCarouselView: View {
+//     // let games: [EmulationGame]
+//     @State var core: Core
+//     @Binding var selectedGame: EmulationGame?
+//     var body: some View {
+//         ScrollView(.horizontal, showsIndicators: false) {
+//             HStack(spacing: 20) {
+//                 ForEach(core.games) { game in
+//                     GameIconView(game: game, selectedGame: $selectedGame)
+//                 }
+//             }
+//         }
+//     }
+// }

src/ios/GameListView.swift

@@ -0,0 +1,171 @@
+// 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 Foundation
+import UIKit
+import UniformTypeIdentifiers
+
+
+struct GameButtonListView: View {
+    var game: EmulationGame
+    @Environment(\.colorScheme) var colorScheme
+
+    var body: some View {
+        HStack(spacing: 15) {
+            if let image = UIImage(data: game.imageData) {
+                Image(uiImage: image)
+                    .resizable()
+                    .frame(width: 60, height: 60)
+                    .cornerRadius(8)
+            } else {
+                Image(systemName: "photo")
+                    .resizable()
+                    .frame(width: 60, height: 60)
+                    .cornerRadius(8)
+            }
+
+            VStack(alignment: .leading, spacing: 4) {
+                Text(game.title)
+                    .font(.headline)
+                    .foregroundColor(colorScheme == .dark ? Color.white : Color.black)
+                Text(game.developer)
+                    .font(.subheadline)
+                    .foregroundColor(.gray)
+            }
+            Spacer()
+        }
+        .padding(.vertical, 8)
+    }
+}
+
+struct GameListView: View {
+    @State var core: Core
+    @State private var searchText = ""
+    @State var game: Int = 1
+    @State var startgame: Bool = false
+    @Binding var isGridView: Bool
+    @State var showAlert = false
+    @State var alertMessage: Alert? = nil
+
+    var body: some View {
+        let filteredGames = core.games.filter { game in
+            guard let EmulationGame = game as? EmulationGame else { return false }
+            return searchText.isEmpty || EmulationGame.title.localizedCaseInsensitiveContains(searchText)
+        }
+        ScrollView {
+            VStack {
+                VStack(alignment: .leading) {
+
+                    if isGridView {
+                        LazyVGrid(columns: [GridItem(.adaptive(minimum: 160))], spacing: 10) {
+                            ForEach(0..<filteredGames.count, id: \.self) { index in
+                                let game = filteredGames[index] // Use filteredGames here
+                                NavigationLink(destination: EmulationView(game: game).toolbar(.hidden, for: .tabBar)) {
+                                    // GameButtonView(game: game)
+                                        // .frame(maxWidth: .infinity, minHeight: 200)
+                                }
+                                .contextMenu {
+                                    Button(action: {
+                                        do {
+                                            try LibraryManager.shared.removerom(filteredGames[index])
+                                        } catch {
+                                            showAlert = true
+                                            alertMessage = Alert(title: Text("Unable to Remove Game"), message: Text(error.localizedDescription))
+                                        }
+                                    }) {
+                                        Text("Remove")
+                                    }
+                                    Button(action: {
+                                        if let documentsURL = FileManager.default.urls(for: .documentDirectory, in: .userDomainMask).first?.appending(path: "roms") {
+                                            UIApplication.shared.open(documentsURL, options: [:], completionHandler: nil)
+                                        }
+                                    }) {
+                                        if ProcessInfo.processInfo.isMacCatalystApp {
+                                            Text("Open in Finder")
+                                        } else {
+                                            Text("Open in Files")
+                                        }
+                                    }
+                                    NavigationLink(destination: EmulationView(game: game).toolbar(.hidden, for: .tabBar)) {
+                                        Text("Launch")
+                                    }
+                                }
+                            }
+                        }
+                    } else {
+                        LazyVStack() {
+                            ForEach(0..<filteredGames.count, id: \.self) { index in
+                                let game = filteredGames[index] // Use filteredGames here
+                                NavigationLink(destination: EmulationView(game: game).toolbar(.hidden, for: .tabBar)) {
+                                    GameButtonListView(game: game)
+                                        .frame(maxWidth: .infinity, minHeight: 75)
+                                }
+                                .contextMenu {
+                                    Button(action: {
+                                        do {
+                                            try LibraryManager.shared.removerom(filteredGames[index])
+                                            try FileManager.default.removeItem(atPath: game.fileURL.path)
+                                        } catch {
+                                            showAlert = true
+                                            alertMessage = Alert(title: Text("Unable to Remove Game"), message: Text(error.localizedDescription))
+                                        }
+                                    }) {
+                                        Text("Remove")
+                                    }
+
+                                    Button(action: {
+                                        if let documentsURL = FileManager.default.urls(for: .documentDirectory, in: .userDomainMask).first?.appending(path: "roms") {
+                                            UIApplication.shared.open(documentsURL, options: [:], completionHandler: nil)
+                                        }
+                                    }) {
+                                        if ProcessInfo.processInfo.isMacCatalystApp {
+                                            Text("Open in Finder")
+                                        } else {
+                                            Text("Open in Files")
+                                        }
+                                    }
+                                    NavigationLink(destination: EmulationView(game: game).toolbar(.hidden, for: .tabBar)) {
+                                        Text("Launch")
+                                    }
+                                }
+                            }
+                        }
+                    }
+                }
+                .searchable(text: $searchText)
+                .padding()
+            }
+            .onAppear {
+                refreshcore()
+
+                if let documentsDirectory = FileManager.default.urls(for: .documentDirectory, in: .userDomainMask).first {
+                    let romsFolderURL = documentsDirectory.appendingPathComponent("roms")
+
+                    let folderMonitor = FolderMonitor(folderURL: romsFolderURL) {
+                        do {
+                            core = Core(games: [], root: documentsDirectory)
+                            core = try LibraryManager.shared.library()
+                        } catch {
+                            print("Error refreshing core: \(error)")
+                        }
+                    }
+                }
+            }
+            .alert(isPresented: $showAlert) {
+                alertMessage ?? Alert(title: Text("Error Not Found"))
+            }
+        }
+    }
+
+    func refreshcore() {
+        do {
+            core = try LibraryManager.shared.library()
+        } catch {
+            print("Failed to fetch library: \(error)")
+            return
+        }
+    }
+}

src/ios/JoystickView.swift

@@ -0,0 +1,54 @@
+// 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
+
+
+public struct Joystick: View {
+    @State var iscool: Bool? = nil
+    var id: Int {
+        if onscreenjoy {
+            return 8
+        }
+        return 0
+    }
+    @AppStorage("onscreenhandheld") var onscreenjoy: Bool = false
+
+    let appui = AppUI.shared
+
+    @ObservedObject public var joystickMonitor = JoystickMonitor()
+    private let dragDiameter: CGFloat = 160
+    private let shape: JoystickShape = .circle
+
+    public var body: some View {
+        VStack{
+            JoystickBuilder(
+                monitor: self.joystickMonitor,
+                width: self.dragDiameter,
+                shape: .circle,
+                background: {
+                    // Example Background
+                    RoundedRectangle(cornerRadius: 8).fill(Color.gray.opacity(0))
+                },
+                foreground: {
+                    // Example Thumb
+                    Circle().fill(Color.gray)
+                },
+                locksInPlace: false)
+            .onChange(of: self.joystickMonitor.xyPoint) { newValue in
+                let scaledX = Float(newValue.x)
+                let scaledY = Float(-newValue.y) // my dumbass broke this by having -y instead of y :/ (well it appears that with the new joystick code, its supposed to be -y)
+                joystickMonitor.objectWillChange
+                print("Joystick Position: (\(scaledX), \(scaledY))")
+
+                if iscool != nil {
+                    appui.thumbstickMoved(analog: .right, x: scaledX, y: scaledY, controllerid: id)
+                } else {
+                    appui.thumbstickMoved(analog: .left, x: scaledX, y: scaledY, controllerid: id)
+                }
+            }
+        }
+    }
+}

src/ios/KeyboardHostingController.swift

@@ -0,0 +1,74 @@
+// 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 UIKit
+
+class KeyboardHostingController<Content: View>: UIHostingController<Content> {
+    override var canBecomeFirstResponder: Bool {
+        return true
+    }
+
+    override func viewDidLoad() {
+        super.viewDidLoad()
+        becomeFirstResponder() // Make sure the view can become the first responder
+    }
+
+    override var keyCommands: [UIKeyCommand]? {
+        return [
+            UIKeyCommand(input: UIKeyInputUpArrow, modifierFlags: [], action: #selector(handleKeyCommand)),
+            UIKeyCommand(input: UIKeyInputDownArrow, modifierFlags: [], action: #selector(handleKeyCommand)),
+            UIKeyCommand(input: UIKeyInputLeftArrow, modifierFlags: [], action: #selector(handleKeyCommand)),
+            UIKeyCommand(input: UIKeyInputRightArrow, modifierFlags: [], action: #selector(handleKeyCommand)),
+            UIKeyCommand(input: "w", modifierFlags: [], action: #selector(handleKeyCommand)),
+            UIKeyCommand(input: "s", modifierFlags: [], action: #selector(handleKeyCommand)),
+            UIKeyCommand(input: "a", modifierFlags: [], action: #selector(handleKeyCommand)),
+            UIKeyCommand(input: "d", modifierFlags: [], action: #selector(handleKeyCommand))
+        ]
+    }
+
+    @objc func handleKeyCommand(_ sender: UIKeyCommand) {
+        if let input = sender.input {
+            switch input {
+            case UIKeyInputUpArrow:
+                print("Up Arrow Pressed")
+            case UIKeyInputDownArrow:
+                print("Down Arrow Pressed")
+            case UIKeyInputLeftArrow:
+                print("Left Arrow Pressed")
+            case UIKeyInputRightArrow:
+                print("Right Arrow Pressed")
+            case "w":
+                print("W Key Pressed")
+            case "s":
+                print("S Key Pressed")
+            case "a":
+                print("A Key Pressed")
+            case "d":
+                print("D Key Pressed")
+            default:
+                break
+            }
+        }
+    }
+}
+
+struct KeyboardSupportView: UIViewControllerRepresentable {
+    let content: Text
+
+    func makeUIViewController(context: Context) -> KeyboardHostingController<Text> {
+        return KeyboardHostingController(rootView: content)
+    }
+
+    func updateUIViewController(_ uiViewController: KeyboardHostingController<Text>, context: Context) {
+        // Handle any updates needed
+    }
+}
+
+struct KeyboardView: View {
+    var body: some View {
+        KeyboardSupportView(content: Text(""))
+    }
+}

src/ios/LibraryView.swift

@@ -0,0 +1,89 @@
+// SPDX-FileCopyrightText: Copyright 2026 Eden Emulator Project
+// SPDX-License-Identifier: GPL-3.0-or-later
+
+import SwiftUI
+import Foundation
+
+struct LibraryView: View {
+    @State private var selectedGame: EmulationGame? = nil
+    @Binding var urlgame: EmulationGame?
+    @ObservedObject var core: EmulationViewModel
+
+    var binding: Binding<Bool> {
+        Binding(
+            get: { urlgame != nil },
+            set: { newValue in
+                if !newValue {
+                    urlgame = nil
+                }
+            }
+        )
+    }
+
+    var body: some View {
+        NavigationView {
+            GeometryReader { geometry in
+                VStack {
+                    TopBarView()
+
+                    if UIDevice.current.userInterfaceIdiom == .pad {
+                        Spacer()
+                    }
+
+                    ScrollView {
+                        LazyVGrid(columns: [
+                            GridItem(.adaptive(minimum: 140), spacing: 10)
+                        ], spacing: 10) {
+                            ForEach(core.games, id: \EmulationGame.id) { game in
+                                GameCardView(game: game)
+                                    .frame(width: 140, height: 160)
+                                    .onTapGesture {
+                                        selectedGame = game
+                                        urlgame = game
+                                    }
+                            }
+                        }
+                        .padding()
+                    }
+
+                    Spacer()
+
+                    BottomMenuView(core: core)
+                }
+
+                NavigationLink(
+                    destination: EmulationView(game: urlgame),
+                    isActive: binding,
+                    label: {
+                        EmptyView()
+                    }
+                )
+                .hidden()
+            }
+        }
+        .background(Color.gray.opacity(0.1))
+        .edgesIgnoringSafeArea(.all)
+        .onAppear {
+        }
+    }
+}
+
+struct GameCardView: View {
+    let game: EmulationGame
+
+    var body: some View {
+        VStack {
+            Rectangle()
+                .fill(Color.gray)
+                .frame(height: 120)
+
+            Text(game.title)
+                .font(.caption)
+                .lineLimit(1)
+                .truncationMode(.tail)
+        }
+        .background(Color.white)
+        .cornerRadius(8)
+        .shadow(radius: 4)
+    }
+}

src/ios/PomeloApp.swift

@@ -0,0 +1,59 @@
+// 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 Foundation
+import UIKit
+
+infix operator --: LogicalDisjunctionPrecedence
+
+func --(lhs: Bool, rhs: Bool) -> Bool {
+    return lhs || rhs
+}
+
+class YuzuFileManager {
+    static var shared = YuzuFileManager()
+    func directories() -> [String : [String : String]] {
+        [
+            "themes" : [:],
+            "amiibo" : [:],
+            "cache" : [:],
+            "config" : [:],
+            "crash_dumps" : [:],
+            "dump" : [:],
+            "keys" : [:],
+            "load" : [:],
+            "log" : [:],
+            "nand" : [:],
+            "play_time" : [:],
+            "roms" : [:],
+            "screenshots" : [:],
+            "sdmc" : [:],
+            "shader" : [:],
+            "tas" : [:],
+            "icons" : [:]
+        ]
+    }
+
+    func createdirectories() throws {
+        let documentdir = FileManager.default.urls(for: .documentDirectory, in: .userDomainMask)[0]
+        try directories().forEach() { directory, filename in
+            let directoryURL = documentdir.appendingPathComponent(directory)
+
+            if !FileManager.default.fileExists(atPath: directoryURL.path) {
+                print("creating dir at \(directoryURL.path)") // yippee
+                try FileManager.default.createDirectory(at: directoryURL, withIntermediateDirectories: false, attributes: nil)
+            }
+        }
+    }
+}
+
+@main
+struct PomeloApp: App {
+    @StateObject private var core = EmulationViewModel(game: nil)
+    var body: some Scene {
+        WindowGroup { ContentView(core: core) }
+    }
+}

src/ios/SwiftUIJoystick.swift

@@ -0,0 +1,309 @@
+// SPDX-FileCopyrightText: Copyright 2026 Eden Emulator Project
+// SPDX-License-Identifier: GPL-3.0-or-later
+// SPDX-FileCopyrightText: Copyright 2021 Eden Emulator Project
+// SPDX-License-Identifier: MIT
+
+import SwiftUI
+
+public protocol PolarCoordinate {
+    /// The direction the thumb handle is pointing, up is 0° and right is 90°
+    var degrees: CGFloat { get set }
+    /// The thumb handle's distance from the center/origin
+    var distance: CGFloat { get set }
+}
+
+public struct PolarPoint: PolarCoordinate {
+    /// The direction from origin, up is 0° and right is 90°
+    public var degrees: CGFloat
+    /// The distance from center/origin
+    public var distance: CGFloat
+
+    public static let zero: PolarPoint = PolarPoint(degrees: 0, distance: 0)
+
+    public init(degrees: CGFloat, distance: CGFloat) {
+        self.degrees = degrees
+        self.distance = distance
+    }
+}
+
+/// The type of background shape used for the touch/click hitbox
+///
+/// Rect will allow every coordinate to be used by the joystick's thumb position
+/// Circle will limit the position output to the circular area defined by the midpoint and diameter/width
+public enum JoystickShape {
+    /// Will allow the cursor to go from 0,0 to 0, width, and width, 0
+    case rect
+    /// Will limit the curser to a circular area surrounding the center of the joystick
+    /// This cannot reach the corners but can reach min and max for both the x and y axis any edge's midpoint
+    case circle
+}
+
+public extension CGPoint {
+    internal static func +(_ lhs: CGPoint, _ rhs: CGPoint) -> CGPoint {
+        return CGPoint(x: lhs.x + rhs.x, y: lhs.y + rhs.y)
+    }
+
+    internal static func -(_ lhs: CGPoint, _ rhs: CGPoint) -> CGPoint {
+        return CGPoint(x: lhs.x - rhs.x, y: lhs.y - rhs.y)
+    }
+
+    internal static func *(_ lhs: CGPoint, _ rhs: CGFloat) -> CGPoint {
+        return CGPoint(x: lhs.x * rhs, y: lhs.y * rhs)
+    }
+
+    func distance(to point: CGPoint) -> CGFloat {
+        return sqrt(pow((point.x - x), 2) + pow((point.y - y), 2))
+    }
+
+    func getPointOnCircle(radius: CGFloat, radian: CGFloat) -> CGPoint {
+        let x = self.x + radius * cos(radian)
+        let y = self.y + radius * sin(radian)
+
+        return CGPoint(x: x, y: y)
+    }
+
+    func getRadian(pointOnCircle: CGPoint) -> CGFloat {
+        let originX = pointOnCircle.x - self.x
+        let originY = pointOnCircle.y - self.y
+        var radian = atan2(originY, originX)
+        while radian < 0 {
+            radian += CGFloat(2 * Double.pi)
+        }
+        return radian
+    }
+
+    func getPolarPoint(from origin: CGPoint = CGPoint.zero) -> PolarPoint {
+        let deltaX = self.x - origin.x
+        let deltaY = self.y - origin.y
+        let radians = -1 * atan2(deltaY, deltaX)
+        let degrees = radians * (180.0 / CGFloat.pi)
+        let distance = self.distance(to: origin)
+
+        guard degrees < 0 else {
+            return PolarPoint(degrees: degrees, distance: distance)
+        }
+        return PolarPoint(degrees: degrees + 360.0, distance: distance)
+    }
+}
+
+public class JoystickMonitor: ObservableObject {
+    @Published public var xyPoint: CGPoint = .zero
+    @Published public var polarPoint: PolarPoint = .zero
+
+    public init() { }
+}
+
+/// A convenience SwiftUI ViewModifier to make a view behave like a Joystick
+public struct JoystickGestureRecognizer: ViewModifier {
+    @ObservedObject public var joystickMonitor: JoystickMonitor
+    /// The size of the control area in which the drag gesture is monitored and reported, is diameter for a circular Joystick
+    private var width: CGFloat
+    /// The shape of the hitbox for the position output of the Joystick Thumb position
+    private var shapeType: JoystickShape
+    /// The center point of the Joystick where it goes to rest when not being used in `locksInPlace` is false
+    private let midPoint: CGPoint
+    /// Determines whether or not the Joystick Thumb control goes back to the center point when released
+    private let locksInPlace: Bool
+    @Binding private(set) public var thumbPosition: CGPoint
+
+    /// Creates a custom joystick with the following configuration
+    ///
+    ///     parameter joystickMonitor: An object used to monitor the valid position of the thumb on the Joystick
+    ///     parameter width: Width of the joystick control area, for a circular Joystick this is the diameter
+    ///     parameter type: Shape of the hitbox for the position output of the Joystick Thumb position
+    ///     parameter background: The view displayed as the Joystick background
+    ///     parameter foreground: The view displayed as the Joystick Thumb Control
+    ///     parameter locksInPlace: Determines if the thumb control returns to the center point when released
+    public init(thumbPosition: Binding<CGPoint>, monitor: JoystickMonitor, width: CGFloat, type: JoystickShape, locksInPlace locks: Bool = false) {
+        self.joystickMonitor = monitor
+        self._thumbPosition = thumbPosition
+        self.width = width
+        self.midPoint = CGPoint(x: width / 2, y: width / 2)
+        self.shapeType = type
+        self.locksInPlace = locks
+    }
+
+    /// Produce the correct shape of Joystick
+    public func body(content: Content) -> some View {
+        switch self.shapeType {
+        case .rect:
+            rectBody(content)
+        case .circle:
+            circleBody(content)
+        }
+    }
+
+    internal func getValidThumbCoordinate(for value: inout CGFloat) {
+        if value <= 0 {
+            value = 0
+        } else if value > width {
+            value = self.width
+        }
+    }
+
+    internal func validateCoordinate(_ emitPoint: inout CGPoint) {
+        emitPoint = emitPoint * 2
+        if emitPoint.x > width {
+            emitPoint.x = width
+        } else if emitPoint.x < -width {
+            emitPoint.x = -width
+        }
+        if emitPoint.y > width {
+            emitPoint.y = width
+        } else if emitPoint.y < -width {
+            emitPoint.y = -width
+        }
+    }
+
+    /// Sets the coordinates of the user's thumb to the JoystickMonitor, which emits an object change since it is an observable
+    internal func emitPosition(for xyPoint: CGPoint) {
+        var emitPoint = xyPoint
+        validateCoordinate(&emitPoint)
+        self.joystickMonitor.xyPoint = emitPoint
+        self.joystickMonitor.polarPoint = emitPoint.getPolarPoint(from: self.midPoint)
+    }
+
+    /// Provides a Rectangular area in which the Joystick control can move within and report values for
+    ///
+    /// - parameter content: The view for which to apply the Joystick listener/DragGesture
+    public func rectBody(_ content: Content) -> some View {
+        content
+            .contentShape(Rectangle())
+            .gesture(
+                DragGesture(minimumDistance: 0, coordinateSpace: .local)
+                    .onChanged({ value in
+                        var thumbX = value.location.x
+                        var thumbY = value.location.y
+                        self.getValidThumbCoordinate(for: &thumbX)
+                        self.getValidThumbCoordinate(for: &thumbY)
+                        self.thumbPosition = CGPoint(x: thumbX, y: thumbY)
+                        let position = value.location - self.midPoint
+                        self.emitPosition(for: position)
+                    })
+                    .onEnded({ value in
+                        if !locksInPlace {
+                            self.thumbPosition = self.midPoint
+                            self.emitPosition(for: .zero)
+                        }
+                    })
+                    .exclusively(
+                        before:
+                            LongPressGesture(minimumDuration: 0.0, maximumDistance: 0.0)
+                            .onEnded({ _ in
+                                if !locksInPlace {
+                                    self.thumbPosition = self.midPoint
+                                    self.emitPosition(for: .zero)
+                                }
+                            })
+                    )
+            )
+    }
+
+    /// Provides a Circular area in which the Joystick control can move within and report values forr
+    ///
+    /// - parameter content: The view for which to apply the Joystick listener/DragGesture
+    public func circleBody(_ content: Content) -> some View {
+        content
+            .contentShape(Circle())
+            .gesture(
+                DragGesture(minimumDistance: 0, coordinateSpace: .local)
+                    .onChanged() { value in
+                        let distance = self.midPoint.distance(to: value.location)
+                        if distance > self.width / 2 {
+                            // Limit to radius
+                           let k = (self.width / 2) / distance
+                            let position = (value.location - self.midPoint) * k
+                            // Order matters
+                            self.thumbPosition = position + self.midPoint
+                            self.emitPosition(for: position)
+                        } else {
+                            self.thumbPosition = value.location
+                            let position = value.location - self.midPoint
+                            self.emitPosition(for: position)
+                        }
+                    }
+                    .onEnded({ value in
+                        if !locksInPlace {
+                            self.thumbPosition = self.midPoint
+                            self.emitPosition(for: .zero)
+                        }
+                    })
+                    .exclusively(
+                        before:
+                            LongPressGesture(minimumDuration: 0.0, maximumDistance: 0.0)
+                            .onEnded({ _ in
+                                if !locksInPlace {
+                                    self.thumbPosition = self.midPoint
+                                    self.emitPosition(for: .zero)
+                                }
+                            })
+                    )
+            )
+    }
+}
+
+/// A convenience SwiftUI struct to make a Joystick control
+public struct JoystickBuilder<background: View, foreground: View>: View {
+    /// The width of the joystick control area, for a circular Joystick this is the diameter
+    private(set) public var width: CGFloat
+    /// The shape of the hitbox for the position output of the Joystick Thumb position
+    private(set) public var controlShape: JoystickShape
+
+    @ObservedObject private(set) public var joystickMonitor: JoystickMonitor
+    @State private(set) public var thumbPosition: CGPoint = .zero
+    /// The view displayed as the Joystick background, which also holds a Joystick DragGesture recognizer
+    @ViewBuilder public var controlBackground: () -> background
+    /// The view displayed as the Joystick Thumb Control, which also holds a Joystick DragGesture recognizer
+    @ViewBuilder public var controlThumb: () -> foreground
+    /// Determines whether or not the Joystick Thumb control goes back to the center point when released
+    private let locksInPlace: Bool
+
+    /// Creates a custom joystick with two views that are passed to it
+    ///
+    ///     parameter position: Will output the valid position of the thumb on the Joystick, from 0 to width
+    ///     parameter width: Width of the joystick control area, for a circular Joystick this is the diameter
+    ///     parameter shape: Shape of the hitbox for the position output of the Joystick Thumb position
+    ///     parameter background: The view displayed as the Joystick background
+    ///     parameter foreground: The view displayed as the Joystick Thumb Control
+    ///     parameter locksInPlace: Determines if the thumb control returns to the center point when released
+    public init(monitor: JoystickMonitor, width: CGFloat, shape: JoystickShape, @ViewBuilder background: @escaping () -> background, @ViewBuilder foreground: @escaping () -> foreground, locksInPlace locks: Bool) {
+        self.joystickMonitor = monitor
+        self.width = width
+        self.controlShape = shape
+        self.controlBackground = background
+        self.controlThumb = foreground
+        self.locksInPlace = locks
+    }
+
+    public var body: some View {
+        controlBackground()
+            .frame(width: self.width, height: self.width)
+            .joystickGestureRecognizer(thumbPosition: self.$thumbPosition, monitor: self.joystickMonitor, width: self.width, shape: self.controlShape, locksInPlace: self.locksInPlace)
+            .overlay(
+                controlThumb()
+                    .frame(width: self.width / 4, height: self.width / 4)
+                    .position(x: self.thumbPosition.x, y: self.thumbPosition.y)
+                    .joystickGestureRecognizer(thumbPosition: self.$thumbPosition, monitor: self.joystickMonitor, width: self.width, shape: self.controlShape, locksInPlace: self.locksInPlace)
+            )
+            .onAppear(perform: {
+                let midPoint = self.width / 2
+                self.thumbPosition = CGPoint(x: midPoint, y: midPoint)
+            })
+    }
+}
+
+public extension View {
+    /// Convenience modifier for adding a Joystick recognizer
+    /// Creates a custom joystick with the following configuration
+    ///
+    ///     parameter joystickMonitor: An object used to monitor the valid position of the thumb on the Joystick
+    ///     parameter width: Width of the joystick control area, for a circular Joystick this is the diameter
+    ///     parameter shape: (.rect || .circle) - Shape of the hitbox for the position output of the Joystick Thumb position
+    ///     parameter background: The view displayed as the Joystick background
+    ///     parameter foreground: The view displayed as the Joystick Thumb Control
+    ///     parameter locksInPlace: default false - Determines if the thumb control returns to the center point when released
+    ///     parameter locksInPlace: default false - Determines if the thumb control returns to the center point when released
+    func joystickGestureRecognizer(thumbPosition: Binding<CGPoint>, monitor: JoystickMonitor, width: CGFloat, shape: JoystickShape, locksInPlace locks: Bool = false) -> some View {
+        modifier(JoystickGestureRecognizer(thumbPosition: thumbPosition, monitor: monitor, width: width, type: shape, locksInPlace: locks))
+    }
+}

src/ios/VMA.cpp

@@ -0,0 +1,5 @@
+// SPDX-FileCopyrightText: Copyright 2026 Eden Emulator Project
+// SPDX-License-Identifier: GPL-3.0-or-later
+
+#define VMA_IMPLEMENTATION
+#include "video_core/vulkan_common/vma.h"

src/video_core/CMakeLists.txt

@@ -454,7 +454,6 @@ else()
     else()
         target_compile_options(video_core PRIVATE $<$<COMPILE_LANGUAGE:C,CXX>:-Wconversion>)
     endif()
-
     target_compile_options(video_core PRIVATE $<$<COMPILE_LANGUAGE:C,CXX>:-Wno-sign-conversion>)
 
     # xbyak

src/video_core/vulkan_common/vma.h

@@ -1,4 +1,4 @@
-// SPDX-FileCopyrightText: Copyright 2025 Eden Emulator Project
+// SPDX-FileCopyrightText: Copyright 2026 Eden Emulator Project
 // SPDX-License-Identifier: GPL-3.0-or-later
 // SPDX-FileCopyrightText: Copyright 2023 yuzu Emulator Project
 // SPDX-License-Identifier: GPL-2.0-or-later
@@ -13,9 +13,14 @@
 #ifdef _MSC_VER
 #pragma warning( push )
 #pragma warning( disable : 4189 )
+#elif defined(__clang__)
+#pragma clang diagnostic push
+#pragma clang diagnostic ignored "-Wunused-variable"
 #endif
 #include "vk_mem_alloc.h"
 
 #ifdef _MSC_VER
 #pragma warning( pop )
+#elif defined(__clang__)
+#pragma clang diagnostic pop
 #endif

src/web_service/CMakeLists.txt

@@ -22,3 +22,27 @@ target_link_libraries(web_service PRIVATE common network nlohmann_json::nlohmann
 
 find_package(OpenSSL REQUIRED)
 target_link_libraries(web_service PRIVATE OpenSSL::SSL OpenSSL::Crypto)
+if (IOS)
+    # TODO: this is horrific
+    find_package(OpenSSL 3 QUIET)
+    if (OpenSSL_FOUND)
+        target_link_libraries(web_service PRIVATE OpenSSL::SSL OpenSSL::Crypto)
+        if (NOT IOS)
+            target_compile_definitions(web_service PRIVATE CPPHTTPLIB_OPENSSL_SUPPORT)
+        endif()
+    else()
+        find_package(OpenSSL 3 QUIET PATHS /usr/local/opt/openssl /opt/homebrew/opt/openssl NO_DEFAULT_PATH)
+        if (OpenSSL_FOUND)
+            target_link_libraries(web_service PRIVATE OpenSSL::SSL OpenSSL::Crypto)
+            if (NOT IOS)
+                target_compile_definitions(web_service PRIVATE CPPHTTPLIB_OPENSSL_SUPPORT)
+            endif()
+        else()
+            message(WARNING "OpenSSL not found or version is less than 3. Some features in web_service may be disabled.")
+        endif()
+    endif()
+else()
+    find_package(OpenSSL REQUIRED)
+    target_link_libraries(web_service PRIVATE OpenSSL::SSL OpenSSL::Crypto)
+    target_compile_definitions(web_service PRIVATE CPPHTTPLIB_OPENSSL_SUPPORT)
+endif()

src/yuzu/CMakeLists.txt

@@ -363,7 +363,7 @@ if (APPLE)
     if (CMAKE_GENERATOR MATCHES "Xcode")
         set(_icons "${_dist}/eden.icon")
 
-        set_target_properties(eden PROPERTIES
+        set_target_properties(yuzu PROPERTIES
             XCODE_ATTRIBUTE_ASSETCATALOG_COMPILER_APPICON_NAME eden
             MACOSX_BUNDLE_ICON_FILE eden
             # Also force xcode to manage signing for us.

src/yuzu/Info.plist

@@ -13,7 +13,7 @@ SPDX-License-Identifier: GPL-2.0-or-later
     <key>CFBundleDevelopmentRegion</key>
     <string>English</string>
     <key>CFBundleExecutable</key>
-    <string>${EXECUTABLE_NAME}</string>
+    <string>$(EXECUTABLE_NAME)</string>
     <key>CFBundleGetInfoString</key>
     <string></string>
     <key>CFBundleIconFile</key>