swift reworks

fix
fix shit 2
2026-09-10 22:16:11 +00:00 · 2026-08-14 21:14:57 +00:00 · 2026-08-14 21:14:57 +00:00 · 2026-08-14 21:14:57 +00:00 · 2026-08-14 21:14:57 +00:00 · 2026-08-14 21:14:57 +00:00
105 changed files with 4438 additions and 390 deletions
@@ -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
@@ -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="//"
 			;;
 		*)
@@ -1,9 +1,9 @@
 name: tx-pull

 on:
-  #  tuesday, saturday at 2pm
+  #  monday at 4pm
  schedule:
-    - cron: '0 14 * * 2,6'
+    - cron: '0 16 * * 1'
  workflow_dispatch:

 jobs:
@@ -3,7 +3,7 @@ description: File a bug report
 body:
  - type: markdown
    attributes:
-      value: Tech support does not belong here. You should only file an issue here if you think you have experienced an actual bug with yuzu.
+      value: Tech support does not belong here. You should only file an issue here if you think you have experienced an actual bug with Eden.
  - type: checkboxes
    attributes:
      label: Is there an existing issue for this?
@@ -43,7 +43,7 @@ body:
    id: log
    attributes:
      label: Log File
-      description: A log file will help our developers to better diagnose and fix the issue. Instructions can be found [here](https://yuzu-emu.org/help/reference/log-files).
+      description: A log file will help our developers to better diagnose and fix the issue. Instructions can be found [here](https://git.eden-emu.dev/eden-emu/eden/src/branch/master/docs/user/HowToAccessLogs.md).
    validations:
      required: true
  - type: textarea
@@ -4,7 +4,7 @@ labels: "request"
 body:
  - type: markdown
    attributes:
-      value: Tech support does not belong here. You should only file an issue here if you are requesting a feature you believe would make yuzu better.
+      value: Tech support does not belong here. You should only file an issue here if you are requesting a feature you believe would make Eden better.
  - type: checkboxes
    attributes:
      label: Is there an existing issue for this?
@@ -23,6 +23,6 @@ body:
    id: why-feature
    attributes:
      label: Why would this feature be useful?
-      description: A brief description of why this feature would make yuzu better.
+      description: A brief description of why this feature would make Eden better.
    validations:
      required: true
@@ -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_()
+ {
@@ -23,28 +23,51 @@ 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()

 # Needed for FFmpeg w/ VAAPI and DRM
-if (PLATFORM_OPENBSD)
+if (OPENBSD)
    # OpenBSD 7.8 broke libcxx when upgrading, so we must define the PSTL backend manually
    set(CMAKE_C_FLAGS "${CMAKE_C_FLAGS} -I${CMAKE_SYSROOT}/usr/X11R6/include -D_LIBCPP_PSTL_BACKEND_SERIAL=1")
    set(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} -I${CMAKE_SYSROOT}/usr/X11R6/include -D_LIBCPP_PSTL_BACKEND_SERIAL=1")
    set(CMAKE_EXE_LINKER_FLAGS "${CMAKE_EXE_LINKER_FLAGS} -L${CMAKE_SYSROOT}/usr/X11R6/lib")
-elseif (PLATFORM_NETBSD)
+elseif (NETBSD)
    set(CMAKE_C_FLAGS "${CMAKE_C_FLAGS} -I${CMAKE_SYSROOT}/usr/X11R7/include -I${CMAKE_SYSROOT}/usr/pkg/include/c++/v1")
    set(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} -I${CMAKE_SYSROOT}/usr/X11R7/include -I${CMAKE_SYSROOT}/usr/pkg/include/c++/v1")
    set(CMAKE_EXE_LINKER_FLAGS "${CMAKE_EXE_LINKER_FLAGS} -L${CMAKE_SYSROOT}/usr/X11R7/lib")
 endif()

 # NetBSD: Fun for the whole family!
-if (PLATFORM_NETBSD)
+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 "PLATFORM_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)
@@ -70,15 +93,22 @@ 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")
 cmake_dependent_option(YUZU_USE_BUNDLED_QT "Download bundled Qt binaries" "${MSVC}" "ENABLE_QT" OFF)

 option(ENABLE_DEBUG_TOOLS "Enable debugging tools (maxwell disassembler, SPIRV translator, etc)" OFF)
+option(ENABLE_WERROR "Enable -Werror diagnostics" ON)

 # non-linux bundled qt are static
 if (YUZU_USE_BUNDLED_QT AND (APPLE OR NOT UNIX))
@@ -157,6 +187,19 @@ if (CXX_CLANG_CL)
        $<$<COMPILE_LANGUAGE:C,CXX>:-Wno-reserved-identifier>
        $<$<COMPILE_LANGUAGE:C,CXX>:-Wno-deprecated-declarations>
        $<$<COMPILE_LANGUAGE:C,CXX>:-Wno-cast-function-type-mismatch>
+        $<$<COMPILE_LANGUAGE:C,CXX>:-Wno-c99-extensions>
+        $<$<COMPILE_LANGUAGE:C,CXX>:-Wno-c++17-compat>
+        $<$<COMPILE_LANGUAGE:C,CXX>:-Wno-c++11-compat-reserved-user-defined-literal>
+        $<$<COMPILE_LANGUAGE:C,CXX>:-Wno-c++11-compat-deprecated-writable-strings>
+        $<$<COMPILE_LANGUAGE:C,CXX>:-Wno-c++11-compat-pedantic>
+        $<$<COMPILE_LANGUAGE:C,CXX>:-Wno-c++11-compat>
+        $<$<COMPILE_LANGUAGE:C,CXX>:-Wno-c++0x-compat>
+        $<$<COMPILE_LANGUAGE:C,CXX>:-Wno-c++98-c++11-compat-binary-literal>
+        $<$<COMPILE_LANGUAGE:C,CXX>:-Wno-c++98-compat-pedantic>
+        $<$<COMPILE_LANGUAGE:C,CXX>:-Wno-c++98-compat>
+        $<$<COMPILE_LANGUAGE:C,CXX>:-Wno-c99-compat>
+        $<$<COMPILE_LANGUAGE:C,CXX>:-Wno-c98-compat>
+        $<$<COMPILE_LANGUAGE:C,CXX>:-Wno-c99-extensions>
        $<$<COMPILE_LANGUAGE:C,CXX>:/EHsc>)
    # REQUIRED CPU features IN Windows-amd64
    if (ARCHITECTURE_x86_64)
@@ -204,24 +247,31 @@ cmake_dependent_option(YUZU_USE_BUNDLED_SDL3 "Download bundled SDL3 build" "${MS
 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()

+# TODO(crueter): Cleanup, each dep that has a bundled option should allow to choose between bundled, external, system
+cmake_dependent_option(YUZU_USE_EXTERNAL_SDL2 "Build SDL2 from external source" OFF "NOT MSVC;NOT ANDROID" OFF)
+cmake_dependent_option(YUZU_USE_BUNDLED_SDL2 "Download bundled SDL2 build" "${EXT_DEFAULT}" "NOT ANDROID" OFF)
+
+# TODO(crueter): did not find header 'AudioHardware.h' in framework 'CoreAudio'
+cmake_dependent_option(ENABLE_CUBEB "Enables the cubeb audio backend" ON "NOT IOS" OFF)
+
 # ffmpeg
 option(YUZU_USE_BUNDLED_FFMPEG "Download bundled FFmpeg" ${EXT_DEFAULT})
-cmake_dependent_option(YUZU_USE_EXTERNAL_FFMPEG "Build FFmpeg from external source" "${PLATFORM_SUN}" "NOT WIN32 AND NOT ANDROID" OFF)
+cmake_dependent_option(YUZU_USE_EXTERNAL_FFMPEG "Build FFmpeg from external source" "${SOLARIS}" "NOT WIN32 AND NOT ANDROID" OFF)

 # 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 PLATFORM_LINUX OR PLATFORM_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" OFF)
 mark_as_advanced(FORCE ENABLE_OPENGL)
@@ -235,7 +285,7 @@ option(YUZU_TESTS "Compile tests" "${BUILD_TESTING}")

 # Install udev rules on Linux (mainly for gyros)
 # Only acts on joysticks and nothing else.
-cmake_dependent_option(YUZU_INSTALL_UDEV_RULES "Install udev rules for gyro access" OFF "PLATFORM_LINUX" OFF)
+cmake_dependent_option(YUZU_INSTALL_UDEV_RULES "Install udev rules for gyro access" OFF "LINUX" OFF)

 option(YUZU_DOWNLOAD_ANDROID_VVL "Download validation layer binary for android" ON)

@@ -243,12 +293,12 @@ 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 PLATFORM_LINUX" OFF)
+cmake_dependent_option(YUZU_CRASH_DUMPS "Compile crash dump (Minidump) support" OFF "WIN32 OR LINUX" OFF)

 option(YUZU_DOWNLOAD_TIME_ZONE_DATA "Always download time zone binaries" ON)
 set(YUZU_TZDB_PATH "" CACHE STRING "Path to a pre-downloaded timezone database")
@@ -258,7 +308,7 @@ cmake_dependent_option(YUZU_USE_BUNDLED_MOLTENVK "Download bundled MoltenVK lib"
 option(YUZU_DISABLE_LLVM "Disable LLVM (useful for CI)" OFF)

 set(DEFAULT_YUZU_USE_BUNDLED_OPENSSL OFF)
-if (EXT_DEFAULT OR PLATFORM_SUN OR PLATFORM_OPENBSD)
+if (EXT_DEFAULT OR SOLARIS OR OPENBSD)
    set(DEFAULT_YUZU_USE_BUNDLED_OPENSSL ON)
 endif()

@@ -281,7 +331,7 @@ if(EXISTS ${PROJECT_SOURCE_DIR}/hooks/pre-commit AND NOT EXISTS ${PROJECT_SOURCE
    endif()
 endif()

-if (ARCHITECTURE_arm64 AND (ANDROID OR PLATFORM_LINUX))
+if (ARCHITECTURE_arm64 AND (ANDROID OR LINUX))
    set(HAS_NCE 1)
    add_compile_definitions(HAS_NCE=1)
 endif()
@@ -290,7 +340,7 @@ if (YUZU_ROOM)
    add_compile_definitions(YUZU_ROOM)
 endif()

-if (UNIX AND NOT (PLATFORM_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")
@@ -362,7 +412,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)
@@ -404,7 +457,7 @@ if (Boost_ADDED)

    if (NOT MSVC OR CXX_CLANG)
        # boost sucks
-        if (PLATFORM_SUN)
+        if (SOLARIS)
            add_compile_options($<$<COMPILE_LANGUAGE:C,CXX>:-pthreads>)
        endif()

@@ -494,9 +547,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)
+    if (IOS)
+        set(_libs Metal IOKit CoreVideo CoreMedia Security UniformTypeIdentifiers)
+    else()
+        set(_libs Carbon Metal Cocoa IOKit CoreVideo CoreMedia Security UniformTypeIdentifiers)
+    endif()
+    foreach(fw ${_libs})
        find_library(${fw}_LIBRARY ${fw} REQUIRED)
        list(APPEND PLATFORM_LIBRARIES ${${fw}_LIBRARY})
    endforeach()
@@ -508,9 +565,9 @@ elseif (WIN32)
        # PSAPI is the Process Status API
        set(PLATFORM_LIBRARIES ${PLATFORM_LIBRARIES} psapi imm32 version crypt32 rpcrt4 gdi32 wldap32 mswsock)
    endif()
-elseif (PLATFORM_MANAGARM)
+elseif (MANAGARM)
    set(PLATFORM_LIBRARIES iconv intl)
-elseif (PLATFORM_HAIKU)
+elseif (HAIKUOS)
    # Haiku is so special :)
    set(PLATFORM_LIBRARIES bsd /boot/system/lib/libnetwork.so)
 elseif (CMAKE_SYSTEM_NAME MATCHES "^(Linux|kFreeBSD|GNU|SunOS)$")
@@ -604,7 +661,7 @@ if (ENABLE_QT)

    # Best practice is to ask for all components at once, so they are from the same version
    set(YUZU_QT_COMPONENTS Core Widgets Charts Concurrent Gui)
-    if (PLATFORM_LINUX OR PLATFORM_FREEBSD)
+    if (LINUX OR FREEBSD)
        list(APPEND YUZU_QT_COMPONENTS DBus)
        # yes Qt, we get it
        set(QT_NO_PRIVATE_MODULE_WARNING ON)
@@ -13,7 +13,7 @@ find_package_handle_standard_args(Opus
    VERSION_VAR OPUS_VERSION
 )

-if (PLATFORM_MSYS)
+if (MSYS2)
    FixMsysPath(PkgConfig::OPUS)
 endif()

@@ -14,7 +14,7 @@ find_package_handle_standard_args(enet
    VERSION_VAR ENET_VERSION
 )

-if (PLATFORM_MSYS)
+if (MSYS2)
    FixMsysPath(PkgConfig::ENET)
 endif()

@@ -14,7 +14,7 @@ find_package_handle_standard_args(libusb
    VERSION_VAR LIBUSB_VERSION
 )

-if (PLATFORM_MSYS)
+if (MSYS2)
    FixMsysPath(PkgConfig::LIBUSB)
 endif()

@@ -13,7 +13,7 @@ else()
    find_package(PkgConfig QUIET)
    pkg_search_module(LZ4 QUIET IMPORTED_TARGET liblz4)

-    if (PLATFORM_MSYS)
+    if (MSYS2)
        FixMsysPath(PkgConfig::LZ4)
    endif()

@@ -22,9 +22,13 @@ Eden is free, open-source, copyleft software, licensed under the terms of the [G

 - No LLM or AI usage, *period*, for patches, pull requests, issues, comments, debugging, brainstorming, etc.
  - For details on why, see the [detailed AI policy](docs/policies/AI.md).
+- Usage of any form of profanity or otherwise unsavory language is generally discouraged.
+  - This is primarily because it rarely helps to actually understand what's going on.
+  - Remember that your comments should be focused and actually address what's happening. With very few exceptions, expletives are actively detrimental at best.
 - New code must follow the same general style as the surrounding codebase. Exceptions may be granted in certain cases.
 - Maintainers reserve the right to change your patches and pull requests at will. We will try to avoid this.
-  - You should respect all decisions made by the [code owners](docs/CODEOWNERS) in your particular subsystem. If you feel they are overstepping or are incorrect, don't be afraid to stand your ground!
+  - You should generally respect all decisions made by the [code owners](docs/CODEOWNERS) in your particular subsystem.
+  - However, if you feel they are overstepping or are incorrect, don't be afraid to stand your ground! Maintainers are not always correct.
 - While we do *not* adhere to the terms of a formal code of conduct, you will generally be expected to respect other developers, contributors, and community members.
 - You **must** have basic knowledge of [Git](https://git-scm.com/learn). Knowing how to manage your branches and follow proper fork policies is a necessity.

@@ -12,7 +12,8 @@
        "min_version": "1.57",
        "package": "Boost",
        "patches": [
-            "0001-clang-cl.patch"
+            "0001-clang-cl.patch",
+            "0002-ios-fix.patch"
        ],
        "repo": "boostorg/boost",
        "version": "boost-1.90.0"
@@ -6,6 +6,7 @@
 - [macOS](#macos)
 - [OpenIndiana](#openindiana)
 - [OmniOS](#omnios)
+- [iOS](#ios)
 - [HaikuOS](#haikuos)
 - [OpenBSD](#openbsd)
 - [FreeBSD](#freebsd)
@@ -92,6 +93,16 @@ You may also need to install `gmake` in order to properly build FFmpeg, this is

 If it wasn't obvious already, you require a X11 server to properly run the emulator within OmniOS, [this guide](https://web.archive.org/web/20260424200928/https://geekblood.wordpress.com/2017/10/26/installing-x11-and-a-desktop-environment-on-omnios/) is a great starting point for that, the links to pkgsrc are outdated so follow [this exemplar](https://pkgsrc.smartos.org/install-on-illumos/) as well:

+## 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.
@@ -46,6 +46,8 @@ These options control dependencies.
 - `YUZU_INSTALL_UDEV_RULES` (OFF) Install udev rules to enable hidraw access
  - Needed for gyroscopes
  - Only available on Linux
+- `ENABLE_DEBUG_TOOLS` (OFF) Enables debugging and development tools, see [tools](../tools/README.md).
+- `ENABLE_WERROR` (ON) Enables warnings as errors (-Werror).

 ### Flavors

@@ -34,7 +34,7 @@ Everyone has their own way of viewing good/bad C++ practices, my general outline
  - The reason is because the project has `-fno-rtti` disabled by default, due to the costs of dynamic polymorphism.
 - Always copy-on-value for objects with `sizeof(void *) >= sizeof(T) * 2`, i.e objects sized as 2 pointers or less, for bigger objects you can use ref/pointer as usual.
 - Try using move semantics instead of references, whenever possible.
- Remember function parameters are extremelly cheap as fuck, don't be afraid to place upto 8 parameters on a given function.
+- Function parameters are cheap. Don't be afraid to use as many as needed (API usability permitting).
 - Don't save a reference in structures of a parent object, i.e:

    ```c++
@@ -164,7 +164,7 @@ if (NOT ANDROID)
        AddJsonPackage(sdl3)
    else()
        message(STATUS "Using bundled SDL3")
-        if (PLATFORM_FREEBSD)
+        if (FREEBSD)
            set(BUILD_SHARED_LIBS ON)
        endif()
        AddJsonPackage(sdl3-ci)
@@ -233,6 +233,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)
@@ -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}")
@@ -1,45 +1,46 @@
-# SPDX-FileCopyrightText: Copyright 2025 crueter
+# SPDX-FileCopyrightText: Copyright 2026 crueter
 # SPDX-License-Identifier: LGPL-3.0-or-later

 ## DetectPlatform ##

-# This is a small helper that sets PLATFORM_<platform> variables for various
+# This is a small helper that sets platform variables for various
 # operating systems and distributions. Note that Apple, Windows, Android, etc.
 # are not covered, as CMake already does that for us.

 # It also sets CXX_<compiler> for the C++ compiler.

-# Furthermore, some platforms have really silly requirements/quirks, so this
-# also does a few of those.
-
 # This module contains contributions from the Eden Emulator Project,
 # notably from crueter and Lizzie.

 if (${CMAKE_SYSTEM_NAME} STREQUAL "SunOS")
-    set(PLATFORM_SUN ON)
+    set(SOLARIS ON)
 elseif (${CMAKE_SYSTEM_NAME} STREQUAL "OpenOrbis")
-    set(PLATFORM_PS4 ON)
+    set(OPENORBIS ON)
 elseif (${CMAKE_SYSTEM_NAME} STREQUAL "managarm")
-    set(PLATFORM_MANAGARM ON)
-elseif (${CMAKE_SYSTEM_NAME} STREQUAL "FreeBSD")
-    set(PLATFORM_FREEBSD ON)
-elseif (${CMAKE_SYSTEM_NAME} STREQUAL "OpenBSD")
-    set(PLATFORM_OPENBSD ON)
-elseif (${CMAKE_SYSTEM_NAME} STREQUAL "NetBSD")
-    set(PLATFORM_NETBSD ON)
-elseif (${CMAKE_SYSTEM_NAME} STREQUAL "DragonFly")
-    set(PLATFORM_DRAGONFLYBSD ON)
+    set(MANAGARM ON)
 elseif (${CMAKE_SYSTEM_NAME} STREQUAL "Haiku")
-    set(PLATFORM_HAIKU ON)
-elseif (${CMAKE_SYSTEM_NAME} STREQUAL "Linux")
-    set(PLATFORM_LINUX ON)
+    set(HAIKUOS ON)
+endif()
+
+# BSD
+if (DEFINED BSD)
+    if ("${BSD}" STREQUAL "DragonFlyBSD")
+        set(DRAGONFLYBSD ON)
+    elseif ("${BSD}" STREQUAL "FreeBSD")
+        set(FREEBSD ON)
+    elseif ("${BSD}" STREQUAL "OpenBSD")
+        set(OPENBSD ON)
+    elseif ("${BSD}" STREQUAL "NetBSD")
+        set(NETBSD ON)
+    endif()
 endif()

 # dumb heuristic to detect msys2
 if (CMAKE_COMMAND MATCHES "msys64")
-    set(PLATFORM_MSYS ON)
+    set(MSYS2 ON)
 endif()

+# compiler checks
 if (CMAKE_CXX_COMPILER_ID STREQUAL "Clang")
    set(CXX_CLANG ON)
    if (MSVC)
@@ -47,51 +48,31 @@ if (CMAKE_CXX_COMPILER_ID STREQUAL "Clang")
    endif()
 elseif (CMAKE_CXX_COMPILER_ID STREQUAL "GNU")
    set(CXX_GCC ON)
-elseif (CMAKE_CXX_COMPILER_ID STREQUAL "MSVC")
-    set(CXX_CL ON)
 elseif (CMAKE_CXX_COMPILER_ID STREQUAL "IntelLLVM")
    set(CXX_ICC ON)
 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)
    set(CMAKE_SYSTEM_VERSION 10.0.0)
 endif()

-# NB: this does not account for SPARC
-if (PLATFORM_SUN)
-    # Terrific OpenIndiana pkg shenanigans
-    list(APPEND CMAKE_PREFIX_PATH
-        "${CMAKE_SYSROOT}/usr/lib/qt/6.6/lib/amd64/cmake")
-    list(APPEND CMAKE_MODULE_PATH
-        "${CMAKE_SYSROOT}/usr/lib/qt/6.6/lib/amd64/cmake")
-
-    # Amazing - absolutely incredible
-    list(APPEND CMAKE_PREFIX_PATH "${CMAKE_SYSROOT}/usr/lib/amd64/cmake")
-    list(APPEND CMAKE_MODULE_PATH "${CMAKE_SYSROOT}/usr/lib/amd64/cmake")
-
-    # For some mighty reason, doing a normal release build sometimes
-    # may not trigger the proper -O3 switch to materialize
-    if (CMAKE_BUILD_TYPE MATCHES "Release")
-        set(CMAKE_C_FLAGS "${CMAKE_C_FLAGS} -O3")
-        set(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} -O3")
-    endif()
-    if (CMAKE_BUILD_TYPE MATCHES "RelWithDebInfo")
-        set(CMAKE_C_FLAGS "${CMAKE_C_FLAGS} -O2")
-        set(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} -O2")
-    endif()
-endif()
-
 # MSYS2 utilities

 # Sometimes, PkgConfig modules will incorrectly reference / when CMake
 # wants you to reference it as C:/msys64/. This function corrects that.
 # Example in a Find module:
 #[[
-    if (PLATFORM_MSYS)
+    if (MSYS2)
        FixMsysPath(PkgConfig::OPUS)
    endif()
 ]]
@@ -116,41 +97,9 @@ function(FixMsysPath target)
        INTERFACE_INCLUDE_DIRECTORIES ${include_dir})
 endfunction()

-# MSYSTEM handling + program_path
-if (PLATFORM_MSYS)
-    # really, really dumb heuristic to detect what environment we are in
-    macro(system var)
-        if (CMAKE_COMMAND MATCHES ${var})
-            set(MSYSTEM ${var})
-        endif()
-    endmacro()
-
-    system(mingw64)
-    system(clang64)
-    system(clangarm64)
-    system(ucrt64)
-
-    if (NOT DEFINED MSYSTEM)
-        set(MSYSTEM msys2)
-    endif()
-
-    # We generally want to prioritize environment-specific binaries if possible
-    # some, like autoconf, are not present on environments besides msys2 though
-    set(CMAKE_PROGRAM_PATH C:/msys64/${MSYSTEM}/bin C:/msys64/usr/bin)
-    set(ENV{PKG_CONFIG_PATH} C:/msys64/${MSYSTEM}/lib/pkgconfig)
-endif()
-
-# This saves a truly ridiculous amount of time during linking
-# In my tests, without this, Eden takes 2 mins, with this, it takes 3-5 seconds
-# or on GitHub Actions, 10 minutes -> 3 seconds
+# Saves linking time
 if (MINGW)
    set(MINGW_FLAGS "-Wl,--strip-all -Wl,--gc-sections")
    set(CMAKE_EXE_LINKER_FLAGS_RELEASE
        "${CMAKE_EXE_LINKER_FLAGS_RELEASE} ${MINGW_FLAGS}")
 endif()
-
-# awesome
-if (PLATFORM_FREEBSD OR PLATFORM_DRAGONFLYBSD)
-    set(CMAKE_EXE_LINKER_FLAGS
-        "${CMAKE_EXE_LINKER_FLAGS} -L${CMAKE_SYSROOT}/usr/local/lib")
-endif()
@@ -31,6 +31,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?
@@ -56,7 +72,7 @@ if (NOT YUZU_USE_BUNDLED_FFMPEG)
    endif()
 endif()

-if (PLATFORM_PS4 OR PLATFORM_MANAGARM)
+if (OPENORBIS OR MANAGARM)
    # Doesn't support VA-API, don't go thru the embarrassment of trying to enable it
    list(APPEND FFmpeg_HWACCEL_FLAGS --disable-vaapi)
 elseif (ANDROID)
@@ -64,7 +80,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)
@@ -75,7 +91,7 @@ elseif (UNIX AND NOT DEFINED FFmpeg_IS_CROSS_COMPILING AND NOT ANDROID)
    if(X11_FOUND)
        if (NOT APPLE)
            # In Solaris needs explicit linking for ffmpeg which links to /lib/amd64/libX11.so
-            if(PLATFORM_SUN)
+            if(SOLARIS)
                list(APPEND FFmpeg_HWACCEL_LIBRARIES
                    X11
                    "${CMAKE_SYSROOT}/usr/lib/xorg/amd64/libdrm.so")
@@ -158,7 +174,7 @@ elseif (UNIX AND NOT DEFINED FFmpeg_IS_CROSS_COMPILING AND NOT ANDROID)
    endif()
 endif()

-if (PLATFORM_PS4)
+if (OPENORBIS)
    list(APPEND FFmpeg_CROSS_COMPILE_LIBS
        -lkernel
        -lSceUserService
@@ -172,7 +188,7 @@ if (PLATFORM_PS4)
        --extra-cxxflags=${CMAKE_SYSROOT}/usr/include
        --extra-libs="${FFmpeg_CROSS_COMPILE_LIBS}"
    )
-elseif (PLATFORM_MANAGARM)
+elseif (MANAGARM)
    # Required for proper stuff
    list(APPEND FFmpeg_CROSS_COMPILE_FLAGS
        --disable-pthreads
@@ -299,7 +315,7 @@ else()
    set(FFmpeg_BUILD_LIBRARIES ${FFmpeg_LIBRARIES})

    # BSD make or Solaris make don't support ffmpeg make-j8
-    if (PLATFORM_LINUX OR ANDROID OR APPLE OR WIN32 OR PLATFORM_FREEBSD)
+    if (LINUX OR ANDROID OR APPLE OR WIN32 OR FREEBSD)
        set(FFmpeg_MAKE_ARGS -j${SYSTEM_THREADS})
    else()
        set(FFmpeg_MAKE_ARGS "")
@@ -11,7 +11,7 @@ if (NOT libusb_ADDED)
 endif()

 # TODO: *BSD fails to compile--may need different configs/symbols
-if (MINGW OR PLATFORM_LINUX OR APPLE)
+if (MINGW OR LINUX OR APPLE)
    set(LIBUSB_FOUND ON CACHE BOOL "libusb is present" FORCE)
    set(LIBUSB_VERSION "1.0.24" CACHE STRING "libusb version string" FORCE)

@@ -24,7 +24,8 @@ if (MINGW OR PLATFORM_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()
@@ -1177,7 +1177,7 @@ static void *stbi__load_main(stbi__context *s, int *x, int *y, int *comp, int re
   #endif

   #ifndef STBI_NO_TGA
-   // test tga last because it's a crappy test!
+   // test tga last because it's a bad test!
   if (stbi__tga_test(s))
      return stbi__tga_load(s,x,y,comp,req_comp, ri);
   #endif
@@ -7662,7 +7662,7 @@ static int stbi__info_main(stbi__context *s, int *x, int *y, int *comp)
   if (stbi__hdr_info(s, x, y, comp))  return 1;
   #endif

-   // test tga last because it's a crappy test!
+   // test tga last because it's a bad test!
   #ifndef STBI_NO_TGA
   if (stbi__tga_info(s, x, y, comp))
       return 1;
@@ -155,23 +155,38 @@ else()
            $<$<COMPILE_LANGUAGE:CXX>:-fno-rtti>)
    endif()

+    if (ENABLE_WERROR)
+        add_compile_options(
+            $<$<COMPILE_LANGUAGE:C,CXX>:-Werror=all>
+            $<$<COMPILE_LANGUAGE:C,CXX>:-Werror=extra>
+            $<$<COMPILE_LANGUAGE:C,CXX>:-Werror=missing-declarations>
+            $<$<COMPILE_LANGUAGE:C,CXX>:-Werror=shadow>
+            $<$<COMPILE_LANGUAGE:C,CXX>:-Werror=unused>)
+    else()
+        add_compile_options(
+            $<$<COMPILE_LANGUAGE:C,CXX>:-Wall>
+            $<$<COMPILE_LANGUAGE:C,CXX>:-Wextra>
+            $<$<COMPILE_LANGUAGE:C,CXX>:-Wmissing-declarations>
+            $<$<COMPILE_LANGUAGE:C,CXX>:-Wshadow>
+            $<$<COMPILE_LANGUAGE:C,CXX>:-Wunused>
+            # Some compilers could particularly misbehave :)
+            $<$<COMPILE_LANGUAGE:C,CXX>:-Wno-error-all>)
+    endif()
    add_compile_options(
-        $<$<COMPILE_LANGUAGE:C,CXX>:-Werror=all>
-        $<$<COMPILE_LANGUAGE:C,CXX>:-Werror=extra>
-        $<$<COMPILE_LANGUAGE:C,CXX>:-Werror=missing-declarations>
-        $<$<COMPILE_LANGUAGE:C,CXX>:-Werror=shadow>
-        $<$<COMPILE_LANGUAGE:C,CXX>:-Werror=unused>
        $<$<COMPILE_LANGUAGE:C,CXX>:-Wno-attributes>
        $<$<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)
            add_compile_options(
-                $<$<COMPILE_LANGUAGE:C,CXX>:-Werror=shadow-uncaptured-local>
-                $<$<COMPILE_LANGUAGE:C,CXX>:-Werror=implicit-fallthrough>
-                $<$<COMPILE_LANGUAGE:C,CXX>:-Werror=type-limits>)
+                $<$<COMPILE_LANGUAGE:C,CXX>:-Wshadow-uncaptured-local>
+                $<$<COMPILE_LANGUAGE:C,CXX>:-Wimplicit-fallthrough>
+                $<$<COMPILE_LANGUAGE:C,CXX>:-Wtype-limits>)
        endif()
        add_compile_options(
            $<$<COMPILE_LANGUAGE:C,CXX>:-Wno-braced-scalar-init>
@@ -181,7 +196,7 @@ else()

    if (ARCHITECTURE_x86_64)
        add_compile_options($<$<COMPILE_LANGUAGE:C,CXX>:-mcx16>)
-        if (PLATFORM_LINUX OR PLATFORM_FREEBSD)
+        if (LINUX OR FREEBSD)
            add_compile_options($<$<COMPILE_LANGUAGE:C,CXX>:-mtls-dialect=gnu2>)
        endif()
    endif()
@@ -283,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)
@@ -222,7 +222,7 @@ if (MSVC)
    )
 else()
    target_compile_options(audio_core PRIVATE
-        $<$<COMPILE_LANGUAGE:C,CXX>:-Werror=conversion>
+        $<$<COMPILE_LANGUAGE:C,CXX>:-Wconversion>
        $<$<COMPILE_LANGUAGE:C,CXX>:-Wno-sign-conversion>)
 endif()

@@ -220,7 +220,7 @@ endif()
 if(CXX_CLANG)
    target_compile_options(common PRIVATE
        $<$<COMPILE_LANGUAGE:C,CXX>:-fsized-deallocation>
-        $<$<COMPILE_LANGUAGE:C,CXX>:-Werror=unreachable-code-aggressive>)
+        $<$<COMPILE_LANGUAGE:C,CXX>:-Wunreachable-code-aggressive>)
    target_compile_definitions(
        common
        PRIVATE
@@ -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;
    }
 }
@@ -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__)
@@ -702,7 +702,15 @@ struct Values {

    // Controls
    InputSetting<std::array<PlayerInput, 10>> players;
-
+    Setting<bool> disable_wgi_xinput{
+        linkage, false, "disable_wgi_xinput", Category::Controls, Specialization::Default,
+// Only read/write disable_wgi_xinput on Windows platforms
+#ifdef _WIN32
+        true
+#else
+        false
+#endif
+    };
    Setting<bool> enable_raw_input{
        linkage, false, "enable_raw_input", Category::Controls, Specialization::Default,
 // Only read/write enable_raw_input on Windows platforms
@@ -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
@@ -1173,7 +1173,7 @@ add_library(core STATIC

 if (ENABLE_WIFI_SCAN)
    target_sources(core PRIVATE internal_network/wifi_scanner.cpp)
-    if (PLATFORM_LINUX)
+    if (LINUX)
        target_link_libraries(core PRIVATE iw)
    endif()
 else()
@@ -1199,7 +1199,7 @@ if (MSVC)
    )
 else()
    target_compile_options(core PRIVATE
-        $<$<COMPILE_LANGUAGE:C,CXX>:-Werror=conversion>
+        $<$<COMPILE_LANGUAGE:C,CXX>:-Wconversion>
        $<$<COMPILE_LANGUAGE:C,CXX>:-Wno-sign-conversion>
        $<$<COMPILE_LANGUAGE:C,CXX>:-Wno-cast-function-type>
        $<$<CXX_COMPILER_ID:Clang>:-fsized-deallocation>)
@@ -1269,6 +1269,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()

 target_sources(core PRIVATE hle/service/ssl/ssl_backend_openssl.cpp)
@@ -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"

@@ -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"
@@ -10,12 +10,12 @@
 #include <memory>
 #include <ankerl/unordered_dense.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;
@@ -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 {
@@ -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"
@@ -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

@@ -28,7 +28,7 @@ Result CloseHandle(Core::System& system, Handle handle) {

 /// Clears the signaled state of an event or process.
 Result ResetSignal(Core::System& system, Handle handle) {
-    LOG_DEBUG(Kernel_SVC, "called handle {:#08x}", handle);
+    LOG_TRACE(Kernel_SVC, "called handle {:#08x}", handle);

    // Get the current handle table.
    const auto& handle_table = GetCurrentProcess(system.Kernel()).GetHandleTable();
@@ -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"
@@ -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 2024 yuzu Emulator
@@ -84,7 +84,7 @@ private:
    RestrictionSettings restriction_settings{};
    std::array<char, 8> pin_code{};
    Capability capability{};
-    // TODO: this is RAW as fuck
+    // TODO: this is raw
    PlayTimerSettings raw_play_timer_settings{};

    KernelHelpers::ServiceContext service_context;
@@ -1020,7 +1020,7 @@ Result ISystemSettingsServer::GetBatteryLot(Out<BatteryLot> out_battery_lot) {
        c.lot_number[1] = 'H';
        c.lot_number[2] = 'A';
        c.lot_number[3] = 'C';
-        // TODO: I have no fucking idea what the letters mean
+        // TODO: what do the letters mean?
        c.lot_number[4] = 'H';
        c.lot_number[5] = 'Z';
        c.lot_number[6] = 'Z';
@@ -531,7 +531,8 @@ int TranslateTypeToNative(Type type) {
    NETWORK_PROTOCOL_TRANSLATE_ELEM(MPLS) \
    NETWORK_PROTOCOL_TRANSLATE_ELEM(PFSYNC)
 #elif defined(__linux__)
-// Other platforms get fucked
+// Other platforms may not support some niche protocols.
+// This is usually not an issue
 #define NETWORK_PROTOCOL_TRANSLATE_LIST \
    NETWORK_PROTOCOL_TRANSLATE_ELEM(IP) \
    /*NETWORK_PROTOCOL_TRANSLATE_ELEM(HOPOPTS)*/ \
@@ -25,7 +25,7 @@ endif()
 # Dynarmic project options
 option(DYNARMIC_ENABLE_CPU_FEATURE_DETECTION "Turning this off causes dynarmic to assume the host CPU doesn't support anything later than SSE3" ON)

-if (PLATFORM_OPENBSD OR PLATFORM_DRAGONFLY OR PLATFORM_NETBSD)
+if (OPENBSD OR DRAGONFLY OR NETBSD)
    set(REQUIRE_WX ON)
 else()
    set(REQUIRE_WX OFF)
@@ -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()
@@ -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
@@ -363,7 +362,7 @@ elseif (APPLE)
            backend/exception_handler_macos_mig.c
        )
    endif()
-elseif (UNIX AND NOT PLATFORM_HAIKU)
+elseif (UNIX AND NOT HAIKUOS)
    # Haiku lacks <ucontext.h>
    if (CMAKE_SYSTEM_NAME STREQUAL "Linux")
        target_link_libraries(dynarmic PRIVATE rt)
@@ -234,7 +234,7 @@ private:
    BlockOfCode block_of_code;
    A32EmitX64 emitter;
    Optimization::PolyfillOptions polyfill_options;
-    // Keep it here, you don't wanna mess with the fuckery that's initializer lists
+    // Keep it here in order to not mess with initializer lists
    const A32::UserConfig conf;
    Jit* jit_interface;

@@ -2160,8 +2160,6 @@ void EmitFPVectorToFixed(BlockOfCode& code, EmitContext& ctx, IR::Inst* inst) {
    ROUNDING_MODE_CASE(CASE, 0x3e) \
    ROUNDING_MODE_CASE(CASE, 0x3f)

-        // FUCK YOU MSVC, FUCKING DEPTH CANT EVEN HANDLE 8+16+32+64 DEPTH OF A ELSE STATMENT YOU FUCKING STUPID
-        // BURN MSVC BURN IT STUPID COMPILER CAN'T EVEN COMPILE THE MOST BASIC C++
        ROUNDING_MODE_SWITCH(ToNearest_TieEven)
        ROUNDING_MODE_SWITCH(TowardsPlusInfinity)
        ROUNDING_MODE_SWITCH(TowardsMinusInfinity)
@@ -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 {
@@ -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;
@@ -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 {
@@ -14,7 +14,7 @@
 #include <memory>
 #include <optional>

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

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

@@ -787,7 +787,7 @@ static void FoldCountLeadingZeros(IR::Inst& inst, bool is_32_bit) {
 /// Folds division operations based on the following:
 ///
 /// 1. x / 0 -> 0 (NOTE: This is an ARM-specific behavior defined in the architecture reference manual)
-/// 2a. 0x8000_0000 / 0xFFFF_FFFF -> 0x8000_0000 (NOTE: More ARM bullshit)
+/// 2a. 0x8000_0000 / 0xFFFF_FFFF -> 0x8000_0000 (NOTE: More ARM errata)
 /// 2b. 0x8000_0000_0000_0000 / 0xFFFF_FFFF_FFFF_FFFF -> 0x8000_0000_0000_0000
 /// 3. imm_x / imm_y -> result
 /// 4. x / 1 -> x
@@ -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
    )
@@ -151,7 +151,7 @@ if (MSVC)
    )
 else()
    target_compile_options(hid_core PRIVATE
-        $<$<COMPILE_LANGUAGE:C,CXX>:-Werror=conversion>
+        $<$<COMPILE_LANGUAGE:C,CXX>:-Wconversion>
        $<$<COMPILE_LANGUAGE:C,CXX>:-Wno-sign-conversion>
        $<$<COMPILE_LANGUAGE:C,CXX>:-Wno-cast-function-type>
        $<$<CXX_COMPILER_ID:Clang>:-fsized-deallocation>)
@@ -44,7 +44,7 @@ if (MSVC)
        /we4800 # Implicit conversion from 'type' to bool. Possible information loss
    )
 else()
-    target_compile_options(input_common PRIVATE $<$<COMPILE_LANGUAGE:C,CXX>:-Werror=conversion>)
+    target_compile_options(input_common PRIVATE $<$<COMPILE_LANGUAGE:C,CXX>:-Wconversion>)
 endif()

 if (ANDROID)
@@ -1,3 +1,6 @@
+// SPDX-FileCopyrightText: Copyright 2026 Eden Emulator Project
+// SPDX-License-Identifier: GPL-3.0-or-later
+
 // SPDX-FileCopyrightText: Copyright 2024 yuzu Emulator Project
 // SPDX-License-Identifier: GPL-3.0-or-later

@@ -157,8 +160,8 @@ Common::ParamPackage Android::BuildButtonParamPackageForButton(PadIdentifier ide

 bool Android::MatchVID(Common::UUID device, const std::vector<std::string>& vids) const {
    for (size_t i = 0; i < vids.size(); ++i) {
-        auto fucker = device.RawString();
-        if (fucker.find(vids[i]) != std::string::npos) {
+        auto dev_str = device.RawString();
+        if (dev_str.find(vids[i]) != std::string::npos) {
            return true;
        }
    }
@@ -648,6 +648,13 @@ SDLDriver::SDLDriver(std::string input_engine_) : InputEngine(std::move(input_en
    // Disable raw input. When enabled this setting causes SDL to die when a web applet opens
    SDL_SetHint(SDL_HINT_JOYSTICK_RAWINPUT, Settings::values.enable_raw_input ? "1" : "0");

+#ifdef _WIN32
+    if (Settings::values.disable_wgi_xinput) {
+        SDL_SetHintWithPriority(SDL_HINT_JOYSTICK_RAWINPUT_CORRELATE_XINPUT, "0", SDL_HINT_OVERRIDE);
+        SDL_SetHintWithPriority(SDL_HINT_JOYSTICK_WGI, "0", SDL_HINT_OVERRIDE);
+    }
+#endif
+
    // SDL3 defaults Steam Controller Bluetooth HIDAPI support to off, which can disable gyro.
    SDL_SetHint(SDL_HINT_JOYSTICK_HIDAPI_STEAM, "1");
    SDL_SetHint(SDL_HINT_GAMECONTROLLER_SENSOR_FUSION, "1");
@@ -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 */
@@ -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)
+        }
+    }
+}
@@ -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
@@ -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
@@ -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
@@ -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
@@ -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 SDL2::SDL2 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})
@@ -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
@@ -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
@@ -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
+    }
+}
@@ -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
+        }
+    }
+}
@@ -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)
+    }
+}
@@ -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;
+};
@@ -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();
+}
@@ -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()
+    }
+}
@@ -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
@@ -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();
+}
@@ -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
+    }
+}
@@ -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()
+    }
+}
@@ -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)
+//                 }
+//             }
+//         }
+//     }
+// }
@@ -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
+        }
+    }
+}
@@ -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)
+                }
+            }
+        }
+    }
+}
@@ -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(""))
+    }
+}
@@ -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)
+    }
+}
@@ -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) }
+    }
+}
@@ -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))
+    }
+}
@@ -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"
@@ -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: 2022 yuzu Emulator Project
@@ -28,6 +28,6 @@ if (ENABLE_WEB_SERVICE)
 endif()

 # Solaris uses /lib/amd64/libsocket.so and /lib/amd64/libnsl.so
-if (PLATFORM_SUN)
+if (SOLARIS)
    target_link_libraries(network PRIVATE socket nsl)
 endif()
@@ -253,7 +253,7 @@ if (MSVC)
    )
 else()
    target_compile_options(shader_recompiler PRIVATE
-        $<$<COMPILE_LANGUAGE:C,CXX>:-Werror=conversion>
+        $<$<COMPILE_LANGUAGE:C,CXX>:-Wconversion>
        # Bracket depth determines maximum size of a fold expression in Clang since 9c9974c3ccb6.
        # And this in turns limits the size of a std::array.
        $<$<CXX_COMPILER_ID:Clang>:-fbracket-depth=1024>
@@ -373,9 +373,8 @@ else()
            $<$<COMPILE_LANGUAGE:C,CXX>:-Wno-shadow>
            $<$<COMPILE_LANGUAGE:C,CXX>:-Wno-unused-local-typedef>)
    else()
-        target_compile_options(video_core PRIVATE $<$<COMPILE_LANGUAGE:C,CXX>:-Werror=conversion>)
+        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
@@ -2257,7 +2257,7 @@ public:
            /// Returns whether the vertex array specified by index is supposed to be
            /// accessed per instance or not.
            bool IsInstancingEnabled(std::size_t index) const {
-                return bool(is_instanced[index]); //FUCK YOU MSVC
+                return bool(is_instanced[index]);
            }
        };

@@ -40,7 +40,6 @@ public:
    }

    struct Regs {
-        // No fucking idea
        INSERT_PADDING_BYTES_NOINIT(0x48);
    } regs{};
 private:
@@ -963,7 +963,7 @@ void Vic::WriteABGR(const OutputSurfaceConfig& output_surface_config, VideoPixel
                    auto pixel1213 = _mm_load_si128((__m128i*)&inp[src + x + 12]);
                    auto pixel1415 = _mm_load_si128((__m128i*)&inp[src + x + 14]);

-                    // Right-shift the channels by 16 to un-do the left shit on read and bring the range
+                    // Right-shift the channels by 16 to un-do the left shift on read and bring the range
                    // back to 8-bit.
                    pixel01 = _mm_srli_epi16(pixel01, 2);
                    pixel23 = _mm_srli_epi16(pixel23, 2);
@@ -88,7 +88,7 @@ set(SHADER_FILES
    ${CMAKE_CURRENT_SOURCE_DIR}/sgsr1_shader_mobile_edge_direction.frag
 )

-if (PLATFORM_HAIKU)
+if (HAIKUOS)
    # glslangValidator WILL crash, glslang will not
    set(GLSLANGVALIDATOR "glslang")
 else()
@@ -441,7 +441,7 @@ void MacroInterpreterImpl::Reset() {
    pc = 0;
    delayed_pc = {};
    method_address.raw = 0;
-    // Vector must hold its last indices otherwise wonky shit will happen
+    // Vector must hold its last indices otherwise chaos will ensue
    // The next parameter index starts at 1, because $r1 already has the value of the first
    // parameter.
    next_parameter_index = 1;
@@ -59,7 +59,7 @@ std::vector<std::string> GetExtensions() {
    std::vector<std::string> extensions;
    for (GLint index = 0; index < num_extensions; ++index) {
        auto const* p = reinterpret_cast<const char*>(glGetStringi(GL_EXTENSIONS, GLuint(index)));
-        if (p != nullptr) // Fuck you? - sincerely, buggy mesa drivers
+        if (p != nullptr)
            extensions.push_back(std::string{p});
    }
    return extensions;
@@ -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
@@ -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()
@@ -8,7 +8,7 @@ set(CMAKE_INCLUDE_CURRENT_DIR ON)

 # Set the RPATH for Qt Libraries
 # This must be done before the `yuzu` target is created
-if (YUZU_USE_BUNDLED_QT AND PLATFORM_LINUX)
+if (YUZU_USE_BUNDLED_QT AND LINUX)
    set(CMAKE_BUILD_RPATH "${CMAKE_BINARY_DIR}/bin/lib/")
 endif()

@@ -357,7 +357,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.
@@ -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>
@@ -99,6 +99,7 @@ ConfigureInputAdvanced::ConfigureInputAdvanced(Core::HID::HIDCore& hid_core_, QW

 #ifndef _WIN32
    ui->enable_raw_input->setVisible(false);
+    ui->disable_wgi_xinput->setVisible(false);
 #endif

    LoadConfiguration();
@@ -139,6 +140,7 @@ void ConfigureInputAdvanced::ApplyConfiguration() {
    Settings::values.emulate_analog_keyboard = ui->emulate_analog_keyboard->isChecked();
    Settings::values.touchscreen.enabled = ui->touchscreen_enabled->isChecked();
    Settings::values.enable_raw_input = ui->enable_raw_input->isChecked();
+    Settings::values.disable_wgi_xinput = ui->disable_wgi_xinput->isChecked();
    Settings::values.enable_udp_controller = ui->enable_udp_controller->isChecked();
    Settings::values.controller_navigation = ui->controller_navigation->isChecked();
    Settings::values.enable_ring_controller = ui->enable_ring_controller->isChecked();
@@ -174,6 +176,7 @@ void ConfigureInputAdvanced::LoadConfiguration() {
    ui->emulate_analog_keyboard->setChecked(Settings::values.emulate_analog_keyboard.GetValue());
    ui->touchscreen_enabled->setChecked(Settings::values.touchscreen.enabled);
    ui->enable_raw_input->setChecked(Settings::values.enable_raw_input.GetValue());
+    ui->disable_wgi_xinput->setChecked(Settings::values.disable_wgi_xinput.GetValue());
    ui->enable_udp_controller->setChecked(Settings::values.enable_udp_controller.GetValue());
    ui->controller_navigation->setChecked(Settings::values.controller_navigation.GetValue());
    ui->enable_ring_controller->setChecked(Settings::values.enable_ring_controller.GetValue());
@@ -2757,6 +2757,22 @@
                       </property>
                     </widget>
                   </item>
+                   <item row="9" column="0">
+                     <widget class="QCheckBox" name="disable_wgi_xinput">
+                       <property name="toolTip">
+                         <string>Aimed to disable SDL GUIDE button hack: synthetic GUIDE(HOME) event when SELECT(MINUS) + START(PLUS) pressed. May impact Win related trigger/rumble/etc stuff</string>
+                       </property>
+                       <property name="minimumSize">
+                         <size>
+                           <width>0</width>
+                           <height>23</height>
+                         </size>
+                       </property>
+                       <property name="text">
+                         <string>Disable SDL WGI/XInput (Requires restart)</string>
+                       </property>
+                     </widget>
+                   </item>
                 </layout>
               </widget>
             </item>
@@ -16,6 +16,12 @@
 #include <sys/resource.h>
 #endif

+#if defined(__APPLE__)
+#include <climits>
+#include <cstdlib>
+#include <cstring>
+#endif
+
 #include "main_window.h"

 #ifdef _WIN32
@@ -126,6 +132,16 @@ int main(int argc, char* argv[]) {
 #endif // _WIN32

 #if defined(__APPLE__)
+    // Convert the relative path to an absolute path before the chdir
+    char resolved[PATH_MAX];
+    for (int i = 1; i < argc; ++i) {
+        if (strcmp(argv[i], "-u") == 0 || strcmp(argv[i], "-input-profile") == 0) {
+            ++i;
+        } else if (argv[i][0] != '-' && argv[i][0] != '/' && realpath(argv[i], resolved)) {
+            argv[i] = strdup(resolved);
+        }
+    }
+
    // If you start a bundle (binary) on OSX without the Terminal, the working directory is "/".
    // But since we require the working directory to be the executable path for the location of
    // the user folder in the Qt Frontend, we need to cd into that working directory
--- a/Show More
+++ b/Show More
Author	SHA1	Message	Date
lizzie	08d212e582	swift reworks	2026-08-14 21:14:57 +00:00
lizzie	e669d3cf04	fix	2026-08-14 21:14:57 +00:00
lizzie	959ef253c6	fix shit 2	2026-08-14 21:14:57 +00:00
lizzie	61e4584ce3	swiftuijoystick	2026-08-14 21:14:57 +00:00
lizzie	38a8c84134	merge more	2026-08-14 21:14:57 +00:00
lizzie	1c5da6a941	add YUZU_USE_EXTERNAL_SDL2	2026-08-14 21:14:57 +00:00
lizzie	4752dd6a17	fix?	2026-08-14 21:14:57 +00:00
lizzie	cc7f784910	pomelo scraps	2026-08-14 21:14:57 +00:00
lizzie	1054283e2b	remove toolchain file + remove multibuild thingy	2026-08-14 21:14:57 +00:00
crueter	422d99cab5	Fix build script Signed-off-by: crueter <crueter@eden-emu.dev>	2026-08-14 21:14:57 +00:00
lizzie	be5f99e150	AAAAAA	2026-08-14 21:14:57 +00:00
crueter	c718e84c15	Build fixes Signed-off-by: crueter <crueter@eden-emu.dev>	2026-08-14 21:14:56 +00:00
lizzie	918d40c8c7	add basic ios shit	2026-08-14 21:14:34 +00:00
crueter	270dbd646d	Revert stbi Signed-off-by: crueter <crueter@eden-emu.dev>	2026-08-14 21:14:34 +00:00
crueter	45ef72272a	fix libs Signed-off-by: crueter <crueter@eden-emu.dev>	2026-08-14 21:14:34 +00:00
crueter	40b8d56b17	Fix most build errors Signed-off-by: crueter <crueter@eden-emu.dev>	2026-08-14 21:14:34 +00:00
crueter	b2acce5ac3	Update CPMUtil, and fix script Signed-off-by: crueter <crueter@eden-emu.dev>	2026-08-14 21:14:33 +00:00
lizzie	caa2e1fc21	DISABLE BY DEFAULT ON IOS FFS	2026-08-14 21:14:10 +00:00
lizzie	77230a64c6	fix life	2026-08-14 21:14:10 +00:00
lizzie	623bb81a6f	fix sirit i think, add ios-aarch64	2026-08-14 21:14:10 +00:00
lizzie	4f2f3f8523	changes?	2026-08-14 21:14:10 +00:00
lizzie	dc8b22d6ac	fix shit?	2026-08-14 21:14:10 +00:00
lizzie	cd2345b6e8	fix #include "common/logging.h"	2026-08-14 21:14:10 +00:00
lizzie	ffd7ac17d5	fix IOS again fucking objc bridge	2026-08-14 21:14:10 +00:00
lizzie	3e9d8eebf9	fix?	2026-08-14 21:14:10 +00:00
lizzie	c24965011f	properly use bridging header, fix headers	2026-08-14 21:14:10 +00:00
lizzie	a67a484077	fix swift driver I HOPE	2026-08-14 21:14:10 +00:00
lizzie	14dc272c4b	license	2026-08-14 21:14:10 +00:00
lizzie	90b24d9336	[temporary c++ shit]	2026-08-14 21:14:10 +00:00
lizzie	7684e50d5e	bit of cmake fuckery	2026-08-14 21:14:10 +00:00
lizzie	5690312587	use language generator exprs	2026-08-14 21:14:10 +00:00
lizzie	2396a0f859	$<$<COMPILE_LANGUAGE:C,CXX>:-Werror=missing-declarations>	2026-08-14 21:14:08 +00:00
lizzie	8f17093671	proper linkings?!	2026-08-14 21:13:48 +00:00
lizzie	385b819d07	bridge changes/fixes	2026-08-14 21:13:48 +00:00
lizzie	f8244bb19e	fix license	2026-08-14 21:13:48 +00:00
lizzie	62d0619c21	fix xcode 2?	2026-08-14 21:13:48 +00:00
lizzie	98062c95f5	fix xcode paths?	2026-08-14 21:13:48 +00:00
lizzie	4be6d7bef0	fx	2026-08-14 21:13:48 +00:00
lizzie	5034954a4f	fx	2026-08-14 21:13:48 +00:00
lizzie	c9059d602d	fix boost	2026-08-14 21:13:48 +00:00
lizzie	152cc4b0f7	fx	2026-08-14 21:13:48 +00:00
lizzie	413d6b249e	fix stuff	2026-08-14 21:13:48 +00:00
lizzie	e94231cad0	stupid macos	2026-08-14 21:13:48 +00:00
lizzie	0399f3f4ba	fix1	2026-08-14 21:13:46 +00:00
lizzie	f03094cd34	fx	2026-08-14 21:13:19 +00:00
lizzie	85b0c96333	fix spirv-tools	2026-08-14 21:13:19 +00:00
lizzie	26e5d989d9	fix license	2026-08-14 21:13:19 +00:00
lizzie	b686ddc471	fix ffmpeg	2026-08-14 21:13:19 +00:00
lizzie	ceea1b4e20	fx	2026-08-14 21:13:19 +00:00
lizzie	a2aa482107	fx	2026-08-14 21:13:19 +00:00
lizzie	ce66ad9973	license	2026-08-14 21:13:19 +00:00
lizzie	2d83aa4a86	ios toolchain cmake	2026-08-14 21:13:19 +00:00
lizzie	9b8a152f07	license	2026-08-14 21:13:19 +00:00
lizzie	607d3eeab0	license headers	2026-08-14 21:13:19 +00:00
lizzie	0c20200264	flatten + cmake	2026-08-14 21:13:19 +00:00
lizzie	84b95e5cab	flatten	2026-08-14 21:13:19 +00:00
lizzie	fd227aa67e	loicense	2026-08-14 21:13:19 +00:00
lizzie	fdd7bc5419	modernize #1	2026-08-14 21:13:19 +00:00
lizzie	25a413d2ab	sudachi ios stuff	2026-08-14 21:13:19 +00:00
lizzie	e7a931d06b	[eden-cli] rework loop to use new SDL3 event dispatch system (#4108 ) modernized into the new SDL3 API for event dispatching. also stopped using the periodic comparison and just added a SDL timer like it wants us to do is it better than before? well it's certainly more portable now. docs say this improves battery usage on busywaits for event polling. Signed-off-by: lizzie <lizzie@eden-emu.dev> Reviewed-on: https://git.eden-emu.dev/eden-emu/eden/pulls/4108 Reviewed-by: Maufeat <sahyno1996@gmail.com> Reviewed-by: MaranBr <maranbr@eden-emu.dev>	2026-08-12 18:10:24 +02:00
crueter	8648c27cbb	[cmake] Simplify DetectPlatform and normalize platform names (#4183 ) Since 3.25 introduced `LINUX` and `BSD`, use them, and standardize other platforms to that style Signed-off-by: crueter <crueter@eden-emu.dev> Reviewed-on: https://git.eden-emu.dev/eden-emu/eden/pulls/4183 Reviewed-by: Samuel <lizzie@eden-emu.dev> Reviewed-by: CamilleLaVey <camillelavey99@gmail.com>	2026-08-10 04:57:38 +02:00
codeman4033	def76946f0	[forgejo] Replace mentions of yuzu in issue templates with eden (#3842 ) Also fix the broken link for log files in the bug report Signed-off-by: codeman4033 <codeman4033@eden-emu.dev> Reviewed-on: https://git.eden-emu.dev/eden-emu/eden/pulls/3842 Reviewed-by: crueter <crueter@eden-emu.dev> Reviewed-by: Samuel <lizzie@eden-emu.dev>	2026-08-10 03:55:03 +02:00
BoiledElectricity	13d39f39aa	[qt] fix relative ROM paths passed on the CLI on macOS (#4105 ) On macOS, convert relative paths to absolute paths before changing the working directory. Otherwise, valid Switch formats may incorrectly fail with a "The ROM format is not supported" error. Fixes: https://github.com/eden-emulator/Issue-Reports/issues/404 Reviewed-on: https://git.eden-emu.dev/eden-emu/eden/pulls/4105 Reviewed-by: crueter <crueter@eden-emu.dev> Reviewed-by: Samuel <lizzie@eden-emu.dev> Reviewed-by: MaranBr <maranbr@eden-emu.dev>	2026-08-09 17:18:58 +02:00
lizzie	7731b5bc86	[core/hle/kernel/svc] demote ResetSignal log Debug->Trace (#4161 ) I don't see why it's LOG_DEBUG if WaitSynchronization is LOG_TRACE, leaves incomplete data may as well bundle it to trace with the others? :) Signed-off-by: lizzie <lizzie@eden-emu.dev> Reviewed-on: https://git.eden-emu.dev/eden-emu/eden/pulls/4161 Reviewed-by: CamilleLaVey <camillelavey99@gmail.com> Reviewed-by: Maufeat <sahyno1996@gmail.com>	2026-08-09 14:13:27 +02:00
lizzie	c4ab2f6b9e	[cmake] Add ENABLE_WERROR option (#4080 ) Should warnings be errors? that's a philosophical debate which I can only answer with "no, but if you think otherwise here is an option for you" Signed-off-by: lizzie <lizzie@eden-emu.dev> Reviewed-on: https://git.eden-emu.dev/eden-emu/eden/pulls/4080 Reviewed-by: crueter <crueter@eden-emu.dev> Reviewed-by: MaranBr <maranbr@eden-emu.dev>	2026-08-09 02:56:28 +02:00
xbzk	dd12266c26	[input] added option to disable wgi/xinput to prevent SDL GUIDE hack (#4237 ) - [x] I have read and followed the [Contribution Guidelines](https://git.eden-emu.dev/eden-emu/eden/src/branch/master/CONTRIBUTING.md#code-contributions). - [x] I have read and followed the [AI Policy](https://git.eden-emu.dev/eden-emu/eden/src/branch/master/docs/policies/AI.md) - [x] I have read and followed the [Coding Guidelines](https://git.eden-emu.dev/eden-emu/eden/src/branch/master/docs/policies/Coding.md) to the best of my ability. ------------------- So, many users hate the fact when they press START+SELECT, an additional HOME event is sent. That is annoying coz for most users' default hotkey settings, it closes eden when not in game, and when in game it calls a NOT controller responsive prompt about leaving Eden. There are several games with reasons to press start+select, also there are homebrews which relies on that combo to open internal menus. Again. That is annoying. Digging deep i've found that SDL implements something called guide hack: When Start+Select is pressed it sends a synthetic GUIDE(which code equals to HOME). This was intended for controllers missing the HOME button, but SDL fails to track them all, and misses API to disabling it. I've figured out a patch to SDL to disable it, but since it would be better to invest on a PR straight into SDL repo, on our side i thought it better to simply add an option to disable WGI (Windows.Gaming.Input) and Xinput, both paths which could lead into the hack enabling. Setting is available in a remote place no one will bother. Reviewed-on: https://git.eden-emu.dev/eden-emu/eden/pulls/4237 Reviewed-by: Samuel <lizzie@eden-emu.dev> Reviewed-by: MaranBr <maranbr@eden-emu.dev>	2026-08-09 02:53:37 +02:00
crueter	a3d32a18b8	[meta] Discourage profanity usage (#4239 ) I'm not into millennial humor, personally. Proactively removed as much profanity as I could grep. Signed-off-by: crueter <crueter@eden-emu.dev> Reviewed-on: https://git.eden-emu.dev/eden-emu/eden/pulls/4239 Reviewed-by: MaranBr <maranbr@eden-emu.dev> Reviewed-by: Samuel <lizzie@eden-emu.dev>	2026-08-09 02:53:16 +02:00
crueter	c0ffc900cd	[ci] Only update translations once a week (#4256 ) They've slowed down enough at this point. Signed-off-by: crueter <crueter@eden-emu.dev> Reviewed-on: https://git.eden-emu.dev/eden-emu/eden/pulls/4256	2026-08-08 05:46:52 +02:00