Step back + keeping fixes from unified download + shared mem refactor

another take
Keep AHB limitations
2026-08-16 13:22:41 +00:00 · 2026-08-11 18:50:22 -04:00 · 2026-08-11 17:37:46 -04:00 · 2026-08-11 14:44:58 -04:00 · 2026-08-07 22:46:16 -04:00 · 2026-08-07 22:46:16 -04:00
100 changed files with 2640 additions and 1113 deletions
@@ -1,9 +1,9 @@
 name: tx-pull

 on:
-  #  monday at 4pm
+  #  tuesday, saturday at 2pm
  schedule:
-    - cron: '0 16 * * 1'
+    - cron: '0 14 * * 2,6'
  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 Eden.
+      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.
  - 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://git.eden-emu.dev/eden-emu/eden/src/branch/master/docs/user/HowToAccessLogs.md).
+      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).
    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 Eden 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 yuzu 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 Eden better.
+      description: A brief description of why this feature would make yuzu better.
    validations:
      required: true
@@ -28,24 +28,27 @@ if (NOT DEFINED ARCHITECTURE)
 endif()

 # Needed for FFmpeg w/ VAAPI and DRM
-if (OPENBSD)
+if (PLATFORM_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 (NETBSD)
+elseif (PLATFORM_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 (NETBSD)
+if (PLATFORM_NETBSD)
    set(ENV{PKG_CONFIG_PATH} "${PKG_CONFIG_PATH}:${CMAKE_SYSROOT}/usr/pkg/lib/ffmpeg7/pkgconfig")
 endif()

-cmake_dependent_option(YUZU_STATIC_ROOM "Build a static room executable only (CI only)" OFF "LINUX" OFF)
+cmake_dependent_option(YUZU_STATIC_ROOM "Build a static room executable only (CI only)" OFF "PLATFORM_LINUX" OFF)
 if (YUZU_STATIC_ROOM)
+    set(YUZU_ROOM ON)
+    set(YUZU_ROOM_STANDALONE ON)
+
    # disable e v e r y t h i n g
    set(ENABLE_QT OFF)
    set(YUZU_CMD OFF)
@@ -76,7 +79,6 @@ set(YUZU_QT_MIRROR "" CACHE STRING "What mirror to use for downloading the bundl
 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))
@@ -155,19 +157,6 @@ 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)
@@ -221,7 +210,7 @@ endif()

 # ffmpeg
 option(YUZU_USE_BUNDLED_FFMPEG "Download bundled FFmpeg" ${EXT_DEFAULT})
-cmake_dependent_option(YUZU_USE_EXTERNAL_FFMPEG "Build FFmpeg from external source" "${SOLARIS}" "NOT WIN32 AND NOT ANDROID" OFF)
+cmake_dependent_option(YUZU_USE_EXTERNAL_FFMPEG "Build FFmpeg from external source" "${PLATFORM_SUN}" "NOT WIN32 AND NOT ANDROID" OFF)

 # sirit
 set(BUNDLED_SIRIT_DEFAULT OFF)
@@ -232,7 +221,7 @@ endif()
 option(YUZU_USE_BUNDLED_SIRIT "Download bundled sirit" ${BUNDLED_SIRIT_DEFAULT})

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

 cmake_dependent_option(ENABLE_OPENGL "Enable OpenGL" ON "NOT (WIN32 AND ARCHITECTURE_arm64) AND NOT APPLE" OFF)
 mark_as_advanced(FORCE ENABLE_OPENGL)
@@ -246,7 +235,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 "LINUX" OFF)
+cmake_dependent_option(YUZU_INSTALL_UDEV_RULES "Install udev rules for gyro access" OFF "PLATFORM_LINUX" OFF)

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

@@ -254,9 +243,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_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_CRASH_DUMPS "Compile crash dump (Minidump) support" OFF "WIN32 OR LINUX" OFF)
+cmake_dependent_option(YUZU_CRASH_DUMPS "Compile crash dump (Minidump) support" OFF "WIN32 OR PLATFORM_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")
@@ -266,7 +258,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 SOLARIS OR OPENBSD)
+if (EXT_DEFAULT OR PLATFORM_SUN OR PLATFORM_OPENBSD)
    set(DEFAULT_YUZU_USE_BUNDLED_OPENSSL ON)
 endif()

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

-if (ARCHITECTURE_arm64 AND (ANDROID OR LINUX))
+if (ARCHITECTURE_arm64 AND (ANDROID OR PLATFORM_LINUX))
    set(HAS_NCE 1)
    add_compile_definitions(HAS_NCE=1)
 endif()

-if (UNIX AND NOT (LINUX OR WIN32))
+if (YUZU_ROOM)
+    add_compile_definitions(YUZU_ROOM)
+endif()
+
+if (UNIX AND NOT (PLATFORM_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")
@@ -408,7 +404,7 @@ if (Boost_ADDED)

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

@@ -512,9 +508,9 @@ elseif (WIN32)
        # PSAPI is the Process Status API
        set(PLATFORM_LIBRARIES ${PLATFORM_LIBRARIES} psapi imm32 version crypt32 rpcrt4 gdi32 wldap32 mswsock)
    endif()
-elseif (MANAGARM)
+elseif (PLATFORM_MANAGARM)
    set(PLATFORM_LIBRARIES iconv intl)
-elseif (HAIKUOS)
+elseif (PLATFORM_HAIKU)
    # Haiku is so special :)
    set(PLATFORM_LIBRARIES bsd /boot/system/lib/libnetwork.so)
 elseif (CMAKE_SYSTEM_NAME MATCHES "^(Linux|kFreeBSD|GNU|SunOS)$")
@@ -608,7 +604,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 (LINUX OR FREEBSD)
+    if (PLATFORM_LINUX OR PLATFORM_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 (MSYS2)
+if (PLATFORM_MSYS)
    FixMsysPath(PkgConfig::OPUS)
 endif()

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

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

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

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

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

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

@@ -22,13 +22,9 @@ 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 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.
+  - 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!
 - 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.

@@ -46,8 +46,6 @@ 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

@@ -65,6 +63,8 @@ These options control executables and build flavors.
 **Desktop only**:

 - `YUZU_CMD` (ON) Compile the SDL-based frontend (eden-cli)
+- `YUZU_ROOM` (OFF) Compile dedicated room functionality into the main executable
+- `YUZU_ROOM_STANDALONE` (OFF) Compile a separate executable for room functionality
 - `YUZU_STATIC_ROOM` (OFF) Compile the room executable *only* as a static, portable executable
  - This is only usable on Alpine Linux.

@@ -99,7 +99,5 @@ The following options were a part of Eden at one point, but have since been reti
 - `YUZU_USE_CPM` - This option once had a purpose, but that purpose has long since passed us by. *All* builds use CPMUtil to manage dependencies now.
  - If you want to *force* the usage of system dependencies, use `-DCPMUTIL_FORCE_SYSTEM=ON`.
 - `YUZU_USE_EXTERNAL_SDL` - This is now handled automatically. It was included even after CPM for purposes that have not applied for a very long time.
- `YUZU_ROOM` - Room functionality is now built-in into eden-cli unconditionally.
- `YUZU_ROOM_STANDALONE` - Likewise.

 See `src/dynarmic/CMakeLists.txt` for additional options--usually, these don't need changed
@@ -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.
- Function parameters are cheap. Don't be afraid to use as many as needed (API usability permitting).
+- Remember function parameters are extremelly cheap as fuck, don't be afraid to place upto 8 parameters on a given function.
 - Don't save a reference in structures of a parent object, i.e:

    ```c++
@@ -1,47 +1,32 @@
 # User Handbook - Command Line

-There are two main applications, an SDL-based app (`eden-cli`) and a Qt based app (`eden`); both accept command line arguments and share almost the same accepted arguments.
+There are two main applications, an SDL-based app (`eden-cli`) and a Qt based app (`eden`); both accept command line arguments.

 ## eden

 - `./eden <path>`: Running with a single argument and nothing else, will make the emulator look for the given file and load it, this behaviour is similar to `eden-cli`; allows dragging and dropping games into the application.
- `--hlaunch`: Launch homebrew launcher `nx-hbloader`.
+- `-g <path>`: Alternate way to specify what to load, overrides. However let it be noted that arguments that use `-` will be treated as options/ignored, if your game, for some reason, starts with `-`, in order to safely handle it you may need to specify it as an argument.
+- `-f`: Use fullscreen.
+- `-u <number>`: Select the index of the user to load as.
+- `-input-profile <name>`: Specifies input profile name to use (for player #0 only).
+- `-qlaunch`: Launch QLaunch.
+- `-hlaunch`: Launch homebrew launcher `nx-hbloader`.
    - Requires a copy of Atmosphere to be extracted onto `sdmc`.
    - This is a shorthand for `<eden folder>/sdmc/atmosphere/hbl.nsp`.
- `--setup`: Launch setup applet.
- `-q/--qlaunch`: Launch QLaunch.
- `-d/--debug`: Enter debug mode, allow gdb stub at port `1234`
- `-c/--config`: Specify alternate configuration file.
- `-f/--fullscreen`: Set fullscreen.
- `-h/--help`: Display help.
- `-g/--game`: Alternate way to specify what to load, overrides. However let it be noted that arguments that use `-` will be treated as options/ignored, if your game, for some reason, starts with `-`, in order to safely handle it you may need to specify it as an argument.
- `-m/--multiplayer`: Specify multiplayer options.
- `-p/--program`: Specify the program arguments to pass (optional).
- `-u/--user`: Select the index of the user to load as.
- `-v/--version`: Display version and quit.
- `-i/--input-profile`: Specifies input profile name to use (for player #0 only).
- `-n/--null-render`: Forces the usage of the "Null" render backend irrespective of settings.
- `-x/--filter`: Sets the debug log filter irrespective of settings.
- `-s/--singlecore`: Forces single-core regardless of settings.
- `-l/--log-file`: The file for storing the room log.
- `-H/--headless`: Force headless mode (no GUI). Currently only used for rooms.
+- `-setup`: Launch setup applet.

-Room settings:
- `-N/--name`: The name of the room.
- `-D/--description`: The room description.
- `-S/--bind-address`: The bind address for the room.
- `-P/--port`: The port used for the room.
- `-M/--max-members`: The maximum number of players for this room.
- `-W/--password`: The password for the room.
- `-G/--preferred-game`: The preferred game for this room.
- `-I/--preferred-game-id`: The preferred game-id for this room.
- `-U/--username`: The username used for announce.
- `-T/--token`: The token used for announce.
- `-A/--web-api-url`: yuzu Web API url.
- `-B/--ban-list-file`: The file for storing the room ban list.
- `-h/--help`: Display this help and exit.
- `-v/--version`: Output version information and exit.,
+## eden-cli

-If the name and description of the room is specified, then it will default to headless mode if not already specified.
-
-Old settings `-hlaunch`, `-qlaunch` and `-setup` are recognized independently. They're kept for backwards compatibility with shortcuts made before the change. Using one of these makes the parser immediately halt and ignore every other option.
+- `--debug/-d`: Enter debug mode, allow gdb stub at port `1234`
+- `--config/-c`: Specify alternate configuration file.
+- `--fullscreen/-f`: Set fullscreen.
+- `--help/-h`: Display help.
+- `--game/-g`: Specify the game to run.
+- `--multiplayer/-m`: Specify multiplayer options.
+- `--program/-p`: Specify the program arguments to pass (optional).
+- `--user/-u`: Specify the user index.
+- `--version/-v`: Display version and quit.
+- `--input-profile/-i`: Specifies input profile name to use (for player #0 only).
+- `--null-render/-n`: Forces the usage of the "Null" render backend irrespective of settings.
+- `--filter/-x`: Sets the debug log filter irrespective of settings.
+- `--singlecore/-s`: Forces single-core regardless of settings.
@@ -164,7 +164,7 @@ if (NOT ANDROID)
        AddJsonPackage(sdl3)
    else()
        message(STATUS "Using bundled SDL3")
-        if (FREEBSD)
+        if (PLATFORM_FREEBSD)
            set(BUILD_SHARED_LIBS ON)
        endif()
        AddJsonPackage(sdl3-ci)
@@ -1,46 +1,45 @@
-# SPDX-FileCopyrightText: Copyright 2026 crueter
+# SPDX-FileCopyrightText: Copyright 2025 crueter
 # SPDX-License-Identifier: LGPL-3.0-or-later

 ## DetectPlatform ##

-# This is a small helper that sets platform variables for various
+# This is a small helper that sets PLATFORM_<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(SOLARIS ON)
+    set(PLATFORM_SUN ON)
 elseif (${CMAKE_SYSTEM_NAME} STREQUAL "OpenOrbis")
-    set(OPENORBIS ON)
+    set(PLATFORM_PS4 ON)
 elseif (${CMAKE_SYSTEM_NAME} STREQUAL "managarm")
-    set(MANAGARM ON)
+    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)
 elseif (${CMAKE_SYSTEM_NAME} STREQUAL "Haiku")
-    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()
+    set(PLATFORM_HAIKU ON)
+elseif (${CMAKE_SYSTEM_NAME} STREQUAL "Linux")
+    set(PLATFORM_LINUX ON)
 endif()

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

-# compiler checks
 if (CMAKE_CXX_COMPILER_ID STREQUAL "Clang")
    set(CXX_CLANG ON)
    if (MSVC)
@@ -48,6 +47,8 @@ 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")
@@ -60,13 +61,37 @@ 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 (MSYS2)
+    if (PLATFORM_MSYS)
        FixMsysPath(PkgConfig::OPUS)
    endif()
 ]]
@@ -91,9 +116,41 @@ function(FixMsysPath target)
        INTERFACE_INCLUDE_DIRECTORIES ${include_dir})
 endfunction()

-# Saves linking time
+# 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
 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()
@@ -56,7 +56,7 @@ if (NOT YUZU_USE_BUNDLED_FFMPEG)
    endif()
 endif()

-if (OPENORBIS OR MANAGARM)
+if (PLATFORM_PS4 OR PLATFORM_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)
@@ -75,7 +75,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(SOLARIS)
+            if(PLATFORM_SUN)
                list(APPEND FFmpeg_HWACCEL_LIBRARIES
                    X11
                    "${CMAKE_SYSROOT}/usr/lib/xorg/amd64/libdrm.so")
@@ -158,7 +158,7 @@ elseif (UNIX AND NOT DEFINED FFmpeg_IS_CROSS_COMPILING AND NOT ANDROID)
    endif()
 endif()

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

    # BSD make or Solaris make don't support ffmpeg make-j8
-    if (LINUX OR ANDROID OR APPLE OR WIN32 OR FREEBSD)
+    if (PLATFORM_LINUX OR ANDROID OR APPLE OR WIN32 OR PLATFORM_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 LINUX OR APPLE)
+if (MINGW OR PLATFORM_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)

@@ -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 bad test!
+   // test tga last because it's a crappy 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 bad test!
+   // test tga last because it's a crappy test!
   #ifndef STBI_NO_TGA
   if (stbi__tga_info(s, x, y, comp))
       return 1;
@@ -155,24 +155,12 @@ 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>
@@ -181,9 +169,9 @@ else()
    if (CXX_CLANG OR CXX_ICC OR CXX_APPLE) # Clang, AppleClang, or Intel C++
        if (NOT MSVC)
            add_compile_options(
-                $<$<COMPILE_LANGUAGE:C,CXX>:-Wshadow-uncaptured-local>
-                $<$<COMPILE_LANGUAGE:C,CXX>:-Wimplicit-fallthrough>
-                $<$<COMPILE_LANGUAGE:C,CXX>:-Wtype-limits>)
+                $<$<COMPILE_LANGUAGE:C,CXX>:-Werror=shadow-uncaptured-local>
+                $<$<COMPILE_LANGUAGE:C,CXX>:-Werror=implicit-fallthrough>
+                $<$<COMPILE_LANGUAGE:C,CXX>:-Werror=type-limits>)
        endif()
        add_compile_options(
            $<$<COMPILE_LANGUAGE:C,CXX>:-Wno-braced-scalar-init>
@@ -193,7 +181,7 @@ else()

    if (ARCHITECTURE_x86_64)
        add_compile_options($<$<COMPILE_LANGUAGE:C,CXX>:-mcx16>)
-        if (LINUX OR FREEBSD)
+        if (PLATFORM_LINUX OR PLATFORM_FREEBSD)
            add_compile_options($<$<COMPILE_LANGUAGE:C,CXX>:-mtls-dialect=gnu2>)
        endif()
    endif()
@@ -251,6 +239,15 @@ endif()
 add_subdirectory(common)
 add_subdirectory(network)

+if (YUZU_ROOM)
+    add_subdirectory(dedicated_room)
+endif()
+
+if (YUZU_ROOM_STANDALONE)
+    add_subdirectory(yuzu_room_standalone)
+    set_target_properties(yuzu-room PROPERTIES OUTPUT_NAME "eden-room")
+endif()
+
 if (YUZU_STATIC_ROOM)
    return()
 endif()
@@ -27,6 +27,7 @@ enum class BooleanSetting(override val key: String) : AbstractBooleanSetting {
    RENDERER_ASYNCHRONOUS_GPU_EMULATION("use_asynchronous_gpu_emulation"),
    RENDERER_ASYNC_PRESENTATION("async_presentation"),
    RENDERER_ASYNCHRONOUS_SHADERS("use_asynchronous_shaders"),
+    RENDERER_UNIFIED_MEMORY("use_unified_memory"),
    RENDERER_REACTIVE_FLUSHING("use_reactive_flushing"),
    ENABLE_BUFFER_HISTORY("enable_buffer_history"),
    USE_OPTIMIZED_VERTEX_BUFFERS("use_optimized_vertex_buffers"),
@@ -685,6 +685,13 @@ abstract class SettingsItem(
                    descriptionId = R.string.renderer_asynchronous_shaders_description
                )
            )
+            put(
+                SwitchSetting(
+                    BooleanSetting.RENDERER_UNIFIED_MEMORY,
+                    titleId = R.string.renderer_unified_memory,
+                    descriptionId = R.string.renderer_unified_memory_description
+                )
+            )
            put(
                SingleChoiceSetting(
                    IntSetting.FAST_GPU_TIME,
@@ -304,6 +304,7 @@ class SettingsFragmentPresenter(
            add(BooleanSetting.EMULATE_BGR565.key)
            add(BooleanSetting.RESCALE_HACK.key)
            add(BooleanSetting.RENDERER_ASYNCHRONOUS_SHADERS.key)
+            add(BooleanSetting.RENDERER_UNIFIED_MEMORY.key)
            add(IntSetting.ANDROID_PIPELINE_WORKERS.key)
            add(BooleanSetting.RENDERER_ASYNCHRONOUS_GPU_EMULATION.key)
            add(BooleanSetting.RENDERER_ASYNC_PRESENTATION.key)
@@ -524,6 +524,8 @@
    <string name="rescale_hack_description">Enables a legacy handling for the rescale configuration pass for games by using a quick rescale path</string>
    <string name="renderer_asynchronous_shaders">Use asynchronous shaders</string>
    <string name="renderer_asynchronous_shaders_description">Compiles shaders asynchronously. This may reduce stutters but may also introduce glitches.</string>
+    <string name="renderer_unified_memory">Unified memory access</string>
+    <string name="renderer_unified_memory_description">Allows GPU write buffer readbacks directly into guest memory, skipping the CPU staging copy.</string>
    <string name="gpu_unswizzle_settings">GPU Unswizzle Settings</string>
    <string name="gpu_unswizzle_settings_description">Configure GPU-based texture unswizzling parameters or disable it entirely. Adjust these settings to balance performance and texture loading quality.</string>
    <string name="gpu_unswizzle_enable">Enable GPU Unswizzle</string>
@@ -222,7 +222,7 @@ if (MSVC)
    )
 else()
    target_compile_options(audio_core PRIVATE
-        $<$<COMPILE_LANGUAGE:C,CXX>:-Wconversion>
+        $<$<COMPILE_LANGUAGE:C,CXX>:-Werror=conversion>
        $<$<COMPILE_LANGUAGE:C,CXX>:-Wno-sign-conversion>)
 endif()

@@ -133,8 +133,6 @@ add_library(
    typed_address.h
    uint128.h
    unique_function.h
-    program_args.cpp
-    program_args.h
    random.cpp
    random.h
    uuid.cpp
@@ -156,9 +154,7 @@ if(WIN32)
        windows/timer_resolution.h)
    target_link_libraries(common PRIVATE ntdll)
 endif()
-if (MSVC)
-    target_link_libraries(common PRIVATE getopt)
-endif()
+
 if(NOT WIN32)
    target_sources(common PRIVATE signal_chain.cpp signal_chain.h)
 endif()
@@ -224,7 +220,7 @@ endif()
 if(CXX_CLANG)
    target_compile_options(common PRIVATE
        $<$<COMPILE_LANGUAGE:C,CXX>:-fsized-deallocation>
-        $<$<COMPILE_LANGUAGE:C,CXX>:-Wunreachable-code-aggressive>)
+        $<$<COMPILE_LANGUAGE:C,CXX>:-Werror=unreachable-code-aggressive>)
    target_compile_definitions(
        common
        PRIVATE
@@ -31,7 +31,9 @@ s64 GetMaxPermissibleResidentMapCount() {
 } // namespace

 HeapTracker::HeapTracker(Common::HostMemory& buffer)
-    : m_buffer(buffer), m_max_resident_map_count(GetMaxPermissibleResidentMapCount()) {}
+    : m_buffer(buffer),
+      m_has_hardware_buffer_backing(!buffer.BackingHardwareBuffers().empty()),
+      m_max_resident_map_count(GetMaxPermissibleResidentMapCount()) {}
 HeapTracker::~HeapTracker() = default;

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

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

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

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

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

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

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

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

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

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

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

    AddrTree::iterator GetNearestHeapMapLocked(VAddr offset);

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

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

    std::shared_mutex m_rebuild_lock{};
@@ -51,14 +51,45 @@

 #endif // ^^^ POSIX ^^^

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

 #include "common/alignment.h"
 #include "common/assert.h"
 #include "common/free_region_manager.h"
 #include "common/host_memory.h"
 #include "common/logging.h"
+#include "common/memory_detect.h"
+#include "common/settings.h"
+
+#ifdef __ANDROID__
+#include <dlfcn.h>
+#include <android/hardware_buffer.h>
+
+namespace {
+
+struct NativeHandle {
+    int version;
+    int numFds;
+    int numInts;
+    int data[1];
+};
+
+using PFN_AHardwareBuffer_getNativeHandle = const NativeHandle* (*)(const AHardwareBuffer*);
+
+PFN_AHardwareBuffer_getNativeHandle ResolveGetNativeHandle() {
+    void* const lib = dlopen("libnativewindow.so", RTLD_NOW);
+    if (lib == nullptr) {
+        return nullptr;
+    }
+    return reinterpret_cast<PFN_AHardwareBuffer_getNativeHandle>(
+        dlsym(lib, "AHardwareBuffer_getNativeHandle"));
+}
+
+} // namespace
+#endif

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

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

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

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

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

@@ -501,9 +542,10 @@ static int shm_open_anon(int flags, mode_t mode) {

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

    bool Init() {
@@ -543,10 +585,15 @@ public:
            LOG_WARNING(Common_Memory, "Using private mappings instead of shared ones");
            backing_base = static_cast<u8*>(mmap(nullptr, backing_size, PROT_READ | PROT_WRITE, MAP_ANONYMOUS | MAP_PRIVATE, -1, 0));
            if (fd > 0) {
-                fd = -1;
                close(fd);
            }
+            fd = -1;
        } else {
+#ifdef __ANDROID__
+            if (InitAhbBacking()) {
+                return InitVirtual();
+            }
+#endif
            backing_base = static_cast<u8*>(mmap(nullptr, backing_size, PROT_READ | PROT_WRITE, MAP_SHARED, fd, 0));
        }
        if (backing_base == MAP_FAILED) {
@@ -554,7 +601,10 @@ public:
            return false;
        }

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

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

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

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

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

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

 #endif // ^^^ POSIX ^^^

-HostMemory::HostMemory(size_t backing_size_, size_t virtual_size_)
+HostMemory::HostMemory(size_t backing_size_, size_t virtual_size_, size_t preferred_offset_)
    : backing_size(backing_size_)
    , virtual_size(virtual_size_)
 {
@@ -697,7 +1019,7 @@ HostMemory::HostMemory(size_t backing_size_, size_t virtual_size_)
 #else
    // Try to allocate a fastmem arena.
    // The implementation will fail with std::bad_alloc on errors.
-    impl = std::make_unique<HostMemory::Impl>(AlignUp(backing_size, PageAlignment), AlignUp(virtual_size, PageAlignment) + HugePageSize);
+    impl = std::make_unique<HostMemory::Impl>(AlignUp(backing_size, PageAlignment), AlignUp(virtual_size, PageAlignment) + HugePageSize, preferred_offset_);
    if (impl->Init()) {
        backing_base = impl->backing_base;
        virtual_base = impl->virtual_base;
@@ -767,6 +1089,46 @@ void HostMemory::ClearBackingRegion(size_t physical_offset, size_t length, u32 f
    std::memset(backing_base + physical_offset, fill_value, length);
 }

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

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

+struct AHardwareBuffer;
+
 namespace Common {

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

    /**
@@ -62,6 +67,20 @@ public:
        return backing_base;
    }

+    [[nodiscard]] size_t BackingSize() const noexcept {
+        return backing_size;
+    }
+
+    [[nodiscard]] size_t BackingMapCount(size_t host_offset, size_t length) const noexcept;
+
+    [[nodiscard]] std::span<AHardwareBuffer* const> BackingHardwareBuffers() const noexcept;
+
+    [[nodiscard]] size_t BackingHardwareBufferWindowSize() const noexcept;
+
+    [[nodiscard]] size_t BackingHardwareBufferBase() const noexcept;
+
+    [[nodiscard]] bool IsBackingShared() const noexcept;
+
    [[nodiscard]] u8* VirtualBasePointer() noexcept {
        return virtual_base;
    }
@@ -1,3 +1,6 @@
+// SPDX-FileCopyrightText: Copyright 2026 Eden Emulator Project
+// SPDX-License-Identifier: GPL-3.0-or-later
+
 // SPDX-FileCopyrightText: Copyright 2020 yuzu Emulator Project
 // SPDX-License-Identifier: GPL-2.0-or-later

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

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

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

+u64 GetAvailablePhysicalMemory() {
+#ifdef _WIN32
+    MEMORYSTATUSEX memorystatus;
+    memorystatus.dwLength = sizeof(memorystatus);
+    if (GlobalMemoryStatusEx(&memorystatus)) {
+        return memorystatus.ullAvailPhys;
+    }
+    return 0;
+#elif defined(__linux__)
+    if (std::FILE* const file = std::fopen("/proc/meminfo", "re")) {
+        char line[256];
+        u64 available = 0;
+        while (std::fgets(line, sizeof(line), file) != nullptr) {
+            if (std::strncmp(line, "MemAvailable:", 13) == 0) {
+                available = std::strtoull(line + 13, nullptr, 10) * 1024ULL;
+                break;
+            }
+        }
+        std::fclose(file);
+        if (available != 0) {
+            return available;
+        }
+    }
+    struct sysinfo info;
+    if (sysinfo(&info) == 0) {
+        const u64 unit = info.mem_unit != 0 ? info.mem_unit : 1ULL;
+        return (static_cast<u64>(info.freeram) + static_cast<u64>(info.bufferram)) * unit;
+    }
+    return 0;
+#else
+    return 0;
+#endif
+}
+
+u64 GetMaxMapCount() {
+#ifdef __linux__
+    if (std::FILE* const file = std::fopen("/proc/sys/vm/max_map_count", "re")) {
+        char line[32];
+        u64 count = 0;
+        if (std::fgets(line, sizeof(line), file) != nullptr) {
+            count = std::strtoull(line, nullptr, 10);
+        }
+        std::fclose(file);
+        return count;
+    }
+    return 0;
+#else
+    return 0;
+#endif
+}
+
 } // namespace Common
@@ -1,3 +1,6 @@
+// SPDX-FileCopyrightText: Copyright 2026 Eden Emulator Project
+// SPDX-License-Identifier: GPL-3.0-or-later
+
 // SPDX-FileCopyrightText: Copyright 2020 yuzu Emulator Project
 // SPDX-License-Identifier: GPL-2.0-or-later

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

+[[nodiscard]] u64 GetAvailablePhysicalMemory();
+
+[[nodiscard]] u64 GetMaxMapCount();
+
 } // namespace Common
@@ -1,280 +0,0 @@
-// SPDX-FileCopyrightText: Copyright 2026 Eden Emulator Project
-// SPDX-License-Identifier: GPL-3.0-or-later
-
-#include <regex>
-#include "common/assert.h"
-#include "common/program_args.h"
-#include "common/logging.h"
-#include "common/scm_rev.h"
-#include "common/string_util.h"
-#include "network/room.h"
-
-#ifdef _WIN32
-// windows.h needs to be included before shellapi.h
-#include <windows.h>
-#include <shellapi.h>
-#include "common/windows/timer_resolution.h"
-#endif
-
-#undef _UNICODE
-#include <getopt.h>
-#ifndef _MSC_VER
-#include <unistd.h>
-#endif
-
-namespace Common {
-
-static void PrintHelp(const char* argv0) {
-    LOG_INFO(Frontend, "Usage: {} [options] <filename>\n"
-        "Core options:\n"
-        "-c, --config            Load the specified configuration file\n"
-        "-f, --fullscreen        Start in fullscreen mode\n"
-        "-g, --game              File path of the game to load\n"
-        "-h, --help              Display this help and exit\n"
-        "-m, --multiplayer=nick:password@address:port Nickname, password, address and port for multiplayer\n"
-        "-p, --program           Pass following string as arguments to executable\n"
-        "-u, --user              Select a specific user profile from 0 to 7\n"
-        "-d, --debug             Run the GDB stub on a port from 1 to 65535\n"
-        "-i, --input-profile     Specifies input profile name to use (for player #0 only)\n"
-        "-n, --null-render       Forces the usage of the \"Null\" render backend irrespective of settings\n"
-        "-x, --filter            Sets the debug log filter irrespective of settings\n"
-        "-s, --singlecore        Forces single-core regardless of settings\n"
-        "Shared options:\n"
-        "-l, --log-file          The file for storing the room log\n"
-        "-H, --headless          Force headless mode (no GUI). Currently only used for rooms\n"
-        "Room options:\n"
-        "-N, --name              The name of the room\n"
-        "-D, --description       The room description\n"
-        "-S, --bind-address      The bind address for the room\n"
-        "-P, --port              The port used for the room\n"
-        "-M, --max-members       The maximum number of players for this room\n"
-        "-W, --password          The password for the room\n"
-        "-G, --preferred-game    The preferred game for this room\n"
-        "-I, --preferred-game-id The preferred game-id for this room\n"
-        "-U, --username          The username used for announce\n"
-        "-T, --token             The token used for announce\n"
-        "-A, --web-api-url       yuzu Web API url\n"
-        "-B, --ban-list-file     The file for storing the room ban list\n"
-        "Misc. options:\n"
-        "-h, --help              Display this help and exit\n"
-        "-v, --version           Output version information and exit\n",
-        argv0);
-}
-
-static void PrintVersion() {
-    LOG_INFO(Frontend, "Eden {} {}, Libnetwork: {}", Common::g_scm_branch, Common::g_scm_desc, Network::network_version);
-}
-
-int ParseArguments(ProgramArguments& args, int argc, char *argv[]) {
-    int option_index = 0;
-#ifdef _WIN32
-    int argc_w;
-    auto argv_w = CommandLineToArgvW(GetCommandLineW(), &argc_w);
-    if (argv_w == nullptr) {
-        LOG_CRITICAL(Frontend, "Failed to get command line arguments");
-        return -1;
-    }
-#endif
-
-    static struct option long_options[] = {
-        // clang-format off
-        {"debug", no_argument, 0, 'd'},
-        {"config", required_argument, 0, 'c'},
-        {"fullscreen", no_argument, 0, 'f'},
-        {"help", no_argument, 0, 'h'},
-        {"game", required_argument, 0, 'g'},
-        {"multiplayer", required_argument, 0, 'm'},
-        {"program", optional_argument, 0, 'p'},
-        {"user", required_argument, 0, 'u'},
-        {"version", no_argument, 0, 'v'},
-        {"input-profile", no_argument, 0, 'i'},
-        {"null-render", no_argument, 0, 'n'},
-        {"singlecore", no_argument, 0, 's'},
-        {"filter", no_argument, 0, 'x'},
-
-        {"log-file", required_argument, 0, 'l'},
-        {"headless", required_argument, 0, 'H'},
-        {"room-name", required_argument, 0, 'N'},
-        {"room-description", required_argument, 0, 'D'},
-        {"bind-address", required_argument, 0, 'S'},
-        {"port", required_argument, 0, 'P'},
-        {"max-members", required_argument, 0, 'M'},
-        {"password", required_argument, 0, 'W'},
-        {"preferred-game", required_argument, 0, 'G'},
-        {"preferred-game-id", required_argument, 0, 'I'},
-        {"username", optional_argument, 0, 'U'},
-        {"token", required_argument, 0, 'T'},
-        {"web-api-url", required_argument, 0, 'A'},
-        {"ban-list-file", required_argument, 0, 'B'},
-        // Entry option
-        {"room", no_argument, 0, 0},
-        {"hlaunch", no_argument, 0, 500},
-        {"qlaunch", no_argument, 0, 'q'},
-        {"setup", no_argument, 0, 502},
-        {0, 0, 0, 0},
-        // clang-format on
-    };
-
-    // Kept for compatibility!
-    for (int i = 1; i < argc; i++) {
-        if (strcmp(argv[i], "-hlaunch") == 0) {
-            args.should_launch_hlaunch = true;
-            return 0;
-        } else if (strcmp(argv[i], "-qlaunch") == 0) {
-            args.should_launch_qlaunch = true;
-            return 0;
-        } else if (strcmp(argv[i], "-setup") == 0) {
-            args.should_launch_setup = true;
-            return 0;
-        }
-    }
-
-    // Preserves drag and drop functionality (i.e ./eden <game path>)
-    [[maybe_unused]] char *endarg = nullptr;
-    while (optind < argc) {
-        int arg = getopt_long(argc, argv, "g:fhvcip::c:u:d:", long_options, &option_index);
-        if (arg != -1) {
-            switch (arg) {
-            case 'd':
-                args.override_gdb_port = uint16_t(atoi(optarg));
-                break;
-            case 'c':
-                args.config_path = optarg;
-                break;
-            case 'f':
-                args.fullscreen = true;
-                LOG_INFO(Frontend, "Starting in fullscreen mode...");
-                break;
-            case 'h':
-                PrintHelp(argv[0]);
-                return 0;
-            case 'g':
-                args.filepath = std::string(optarg);
-                break;
-            case 'i': {
-                args.input_profile = std::string(optarg);
-                break;
-            }
-            case 'm': {
-                args.use_multiplayer = true;
-                const std::string str_arg(optarg);
-                // regex to check if the format is nickname:password@ip:port
-                // with optional :password
-                const std::regex re("^([^:]+)(?::(.+))?@([^:]+)(?::([0-9]+))?$");
-                if (!std::regex_match(str_arg, re)) {
-                    LOG_ERROR(Frontend, "Wrong format for option --multiplayer");
-                    return -1;
-                } else {
-                    std::smatch match;
-                    std::regex_search(str_arg, match, re);
-                    ASSERT(match.size() == 5);
-                    args.nickname = match[1];
-                    args.password = match[2];
-                    args.address = match[3];
-                    if (!match[4].str().empty()) {
-                        args.port = u16(std::strtoul(match[4].str().c_str(), nullptr, 0));
-                    }
-                    std::regex nickname_re("^[a-zA-Z0-9._\\- ]+$");
-                    if (!std::regex_match(args.nickname, nickname_re)) {
-                        LOG_ERROR(Frontend, "Nickname is not valid. Must be 4 to 20 alphanumeric characters");
-                        return -1;
-                    } else {
-                        if (args.address.empty()) {
-                            LOG_ERROR(Frontend, "Address to room must not be empty");
-                            return -1;
-                        }
-                    }
-                }
-                break;
-            }
-            case 'p':
-                args.program_args.assign(optarg);
-                break;
-            case 'u':
-                args.selected_user = atoi(optarg);
-                break;
-            case 'v':
-                PrintVersion();
-                break;
-            case 'n':
-                args.force_null_render = true;
-                break;
-            case 's':
-                args.force_single_core = true;
-                break;
-            case 'x':
-                args.log_filter.emplace(optarg);
-                break;
-            // shared
-            case 'l':
-                args.log_file.assign(optarg);
-                break;
-            case 'H':
-                args.headless.emplace(true);
-                break;
-            // room
-            case 'N':
-                args.room_name.assign(optarg);
-                break;
-            case 'D':
-                args.room_description.assign(optarg);
-                break;
-            case 'S':
-                args.bind_address.assign(optarg);
-                break;
-            case 'P': {
-                auto const value = strtoul(optarg, &endarg, 0);
-                if (value <= USHRT_MAX) {
-                    args.port = value;
-                } else {
-                    LOG_ERROR(Frontend, "port must be between 0-{}", USHRT_MAX);
-                }
-                break;
-            }
-            case 'M': {
-                auto const value = strtoul(optarg, &endarg, 0);
-                if (value >= 2 && value <= Network::MaxConcurrentConnections) {
-                    args.max_members = value;
-                } else {
-                    LOG_ERROR(Frontend, "max members must be between 2-{}", value, Network::MaxConcurrentConnections);
-                }
-                break;
-            }
-            case 'W':
-                args.password.assign(optarg);
-                break;
-            case 'G':
-                args.preferred_game.assign(optarg);
-                break;
-            case 'I':
-                args.preferred_game_id = strtoull(optarg, &endarg, 16);
-                break;
-            case 'U':
-                args.nickname.assign(optarg);
-                break;
-            case 'T':
-                args.token.assign(optarg);
-                break;
-            case 'A':
-                args.web_api_url.assign(optarg);
-                break;
-            case 'B':
-                args.ban_list_file.assign(optarg);
-                break;
-            }
-        } else {
-#ifdef _WIN32
-            args.filepath = Common::UTF16ToUTF8(argv_w[optind]);
-#else
-            args.filepath = argv[optind];
-#endif
-            optind++;
-        }
-    }
-#ifdef _WIN32
-    LocalFree(argv_w);
-#endif
-    return 0;
-}
-
-}
@@ -1,49 +0,0 @@
-// SPDX-FileCopyrightText: Copyright 2026 Eden Emulator Project
-// SPDX-License-Identifier: GPL-3.0-or-later
-
-#pragma once
-
-#include <string>
-#include <optional>
-#include "common/common_types.h"
-
-namespace Common {
-
-inline constexpr u16 DEFAULT_ROOM_PORT = 24872;
-struct ProgramArguments {
-    std::optional<std::string> config_path{};
-    std::optional<std::string> log_filter{};
-    std::string nickname{};
-    std::string password{};
-    std::string address{};
-    std::string input_profile{};
-    std::string filepath{};
-    std::string program_args{};
-    std::string room_name{};
-    std::string room_description{};
-    std::string preferred_game{};
-    std::string username{};
-    std::string token{};
-    std::string web_api_url{};
-    std::string ban_list_file{};
-    std::string log_file = "eden-room.log";
-    std::string bind_address{};
-    std::optional<int> selected_user{};
-    std::optional<u16> override_gdb_port{};
-    std::optional<bool> headless{};
-    u64 preferred_game_id = 0;
-    u32 max_members = 16;
-    u16 port = DEFAULT_ROOM_PORT;
-    bool use_multiplayer = false;
-    bool fullscreen = false;
-    bool force_null_render = false;
-    bool force_single_core = false;
-
-    bool should_launch_qlaunch = false;
-    bool should_launch_hlaunch = false;
-    bool should_launch_setup = false;
-};
-
-int ParseArguments(ProgramArguments& args, int argc, char *argv[]);
-
-}
@@ -587,6 +587,9 @@ struct Values {
    SwitchableSetting<bool> use_asynchronous_shaders{linkage, false, "use_asynchronous_shaders",
                                                     Category::RendererHacks};

+    SwitchableSetting<bool> use_unified_memory{linkage, false, "use_unified_memory",
+                                               Category::RendererHacks};
+
    SwitchableSetting<GpuUnswizzleSize> gpu_unswizzle_texture_size{linkage,
                                                  GpuUnswizzleSize::Large,
                                                  "gpu_unswizzle_texture_size",
@@ -702,15 +705,7 @@ 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
@@ -1173,7 +1173,7 @@ add_library(core STATIC

 if (ENABLE_WIFI_SCAN)
    target_sources(core PRIVATE internal_network/wifi_scanner.cpp)
-    if (LINUX)
+    if (PLATFORM_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>:-Wconversion>
+        $<$<COMPILE_LANGUAGE:C,CXX>:-Werror=conversion>
        $<$<COMPILE_LANGUAGE:C,CXX>:-Wno-sign-conversion>
        $<$<COMPILE_LANGUAGE:C,CXX>:-Wno-cast-function-type>
        $<$<CXX_COMPILER_ID:Clang>:-fsized-deallocation>)
@@ -119,6 +119,7 @@ struct System::Impl {

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

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

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

        Initialize(system);
    }
@@ -503,6 +506,7 @@ struct System::Impl {
    std::atomic_bool is_powered_on{};
    bool is_multicore : 1 = false;
    bool extended_memory_layout : 1 = false;
+    bool unified_memory : 1 = false;
    bool exit_locked : 1 = false;
    bool exit_requested : 1 = false;
    bool nvdec_active : 1 = false;
@@ -1,3 +1,6 @@
+// SPDX-FileCopyrightText: Copyright 2026 Eden Emulator Project
+// SPDX-License-Identifier: GPL-3.0-or-later
+
 // SPDX-FileCopyrightText: Copyright 2020 yuzu Emulator Project
 // SPDX-License-Identifier: GPL-2.0-or-later

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

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

 DeviceMemory::~DeviceMemory() = default;

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

+struct AHardwareBuffer;
+
 namespace Core {

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

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

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

    struct TrackedEntry {
@@ -171,6 +171,11 @@ struct DeviceMemoryManagerAllocator {
 template <typename Traits>
 DeviceMemoryManager<Traits>::DeviceMemoryManager(const DeviceMemory& device_memory_)
    : physical_base{uintptr_t(device_memory_.buffer.BackingBasePointer())}
+    , physical_size{device_memory_.buffer.BackingSize()}
+    , ahb_windows{device_memory_.buffer.BackingHardwareBuffers()}
+    , ahb_window_size{device_memory_.buffer.BackingHardwareBufferWindowSize()}
+    , ahb_base{device_memory_.buffer.BackingHardwareBufferBase()}
+    , backing_is_shared{device_memory_.buffer.IsBackingShared()}
    , device_inter{nullptr}
    , compressed_device_addr(1ULL << ((Settings::values.memory_layout_mode.GetValue() == Settings::MemoryLayout::Memory_4Gb ? physical_min_bits : physical_max_bits) - Memory::YUZU_PAGEBITS))
    , tracked_entries(device_as_size >> Memory::YUZU_PAGEBITS)
@@ -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_TRACE(Kernel_SVC, "called handle {:#08x}", handle);
+    LOG_DEBUG(Kernel_SVC, "called handle {:#08x}", handle);

    // Get the current handle table.
    const auto& handle_table = GetCurrentProcess(system.Kernel()).GetHandleTable();
@@ -1,4 +1,4 @@
-// SPDX-FileCopyrightText: Copyright 2026 Eden Emulator Project
+// SPDX-FileCopyrightText: Copyright 2025 Eden Emulator Project
 // SPDX-License-Identifier: GPL-3.0-or-later

 // SPDX-FileCopyrightText: Copyright 2024 yuzu Emulator
@@ -84,7 +84,7 @@ private:
    RestrictionSettings restriction_settings{};
    std::array<char, 8> pin_code{};
    Capability capability{};
-    // TODO: this is raw
+    // TODO: this is RAW as fuck
    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: what do the letters mean?
+        // TODO: I have no fucking idea what the letters mean
        c.lot_number[4] = 'H';
        c.lot_number[5] = 'Z';
        c.lot_number[6] = 'Z';
@@ -531,8 +531,7 @@ int TranslateTypeToNative(Type type) {
    NETWORK_PROTOCOL_TRANSLATE_ELEM(MPLS) \
    NETWORK_PROTOCOL_TRANSLATE_ELEM(PFSYNC)
 #elif defined(__linux__)
-// Other platforms may not support some niche protocols.
-// This is usually not an issue
+// Other platforms get fucked
 #define NETWORK_PROTOCOL_TRANSLATE_LIST \
    NETWORK_PROTOCOL_TRANSLATE_ELEM(IP) \
    /*NETWORK_PROTOCOL_TRANSLATE_ELEM(HOPOPTS)*/ \
@@ -0,0 +1,27 @@
+# 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
+
+add_library(yuzu-room STATIC EXCLUDE_FROM_ALL
+    yuzu_room.cpp
+    yuzu_room.h
+    yuzu_room.rc)
+
+target_link_libraries(yuzu-room PRIVATE common network)
+if (ENABLE_WEB_SERVICE)
+    target_compile_definitions(yuzu-room PRIVATE ENABLE_WEB_SERVICE)
+    target_link_libraries(yuzu-room PRIVATE web_service)
+endif()
+
+target_link_libraries(yuzu-room PRIVATE
+    OpenSSL::SSL
+    OpenSSL::Crypto)
+
+if (MSVC)
+    target_link_libraries(yuzu-room PRIVATE getopt)
+endif()
+target_link_libraries(yuzu-room PRIVATE ${PLATFORM_LIBRARIES} Threads::Threads)
+
+create_target_directory_groups(yuzu-room)
@@ -0,0 +1,394 @@
+// SPDX-FileCopyrightText: Copyright 2026 Eden Emulator Project
+// SPDX-License-Identifier: GPL-3.0-or-later
+
+// SPDX-FileCopyrightText: Copyright 2017 Citra Emulator Project
+// SPDX-License-Identifier: GPL-2.0-or-later
+
+// SPDX-FileCopyrightText: Copyright yuzu/Citra Emulator Project
+// SPDX-License-Identifier: GPL-3.0-or-later
+
+#include <chrono>
+#include <fstream>
+#include <iostream>
+#include <memory>
+#include <regex>
+#include <string>
+#include <thread>
+
+#ifdef _WIN32
+// windows.h needs to be included before shellapi.h
+#include <windows.h>
+
+#include <shellapi.h>
+#endif
+
+#include <openssl/evp.h>
+#include "common/common_types.h"
+#include "common/fs/file.h"
+#include "common/fs/fs.h"
+#include "common/fs/path_util.h"
+#include "common/logging.h"
+#include "common/scm_rev.h"
+#include "common/settings.h"
+#include "common/string_util.h"
+#include "core/core.h"
+#include "network/announce_multiplayer_session.h"
+#include "network/network.h"
+#include "network/room.h"
+#include "network/verify_user.h"
+
+#ifdef ENABLE_WEB_SERVICE
+#include "web_service/verify_user_jwt.h"
+#endif
+
+#undef _UNICODE
+#include <getopt.h>
+#ifndef _MSC_VER
+#include <unistd.h>
+#endif
+
+#include "yuzu_room.h"
+
+static void PrintHelp(const char* argv0) {
+    LOG_INFO(Network,
+             "Usage: {}"
+             " [options] <filename>\n"
+             "-n, --room-name         The name of the room\n"
+             "-d, --room-description  The room description\n"
+             "-s, --bind-address      The bind address for the room\n"
+             "-p, --port              The port used for the room\n"
+             "-m, --max-members       The maximum number of players for this room\n"
+             "-w, --password          The password for the room\n"
+             "-g, --preferred-game    The preferred game for this room\n"
+             "-i, --preferred-game-id The preferred game-id for this room\n"
+             "-u, --username          The username used for announce\n"
+             "-t, --token             The token used for announce\n"
+             "-a, --web-api-url       yuzu Web API url\n"
+             "-b, --ban-list-file     The file for storing the room ban list\n"
+             "-l, --log-file          The file for storing the room log\n"
+             "-h, --help              Display this help and exit\n"
+             "-v, --version           Output version information and exit\n",
+             argv0);
+}
+
+static void PrintVersion() {
+    LOG_INFO(Network, "Eden dedicated room {} {} Libnetwork: {}", Common::g_scm_branch,
+             Common::g_scm_desc, Network::network_version);
+}
+
+/// The magic text at the beginning of a yuzu-room ban list file.
+static constexpr char BanListMagic[] = "YuzuRoom-BanList-1";
+
+static constexpr char token_delimiter{':'};
+
+static void PadToken(std::string& token) {
+    std::array<unsigned char, 512> output{};
+    std::array<unsigned char, 2048> roundtrip{};
+    for (size_t i = 0; i < 3; i++) {
+        EVP_DecodeBlock(output.data(), reinterpret_cast<const unsigned char*>(token.c_str()), token.size());
+        EVP_EncodeBlock(output.data(), roundtrip.data(), roundtrip.size());
+        if (memcmp(roundtrip.data(), token.data(), token.size()) == 0) {
+            break;
+        }
+        token.push_back('=');
+    }
+}
+
+static std::string UsernameFromDisplayToken(const std::string& display_token) {
+    std::size_t outlen = 4 * ((display_token.length() + 2) / 3);
+    std::array<unsigned char, 512> output{};
+    EVP_DecodeBlock(output.data(), reinterpret_cast<const unsigned char*>(display_token.c_str()), display_token.length());
+    std::string decoded_display_token(reinterpret_cast<char*>(&output), outlen);
+    return decoded_display_token.substr(0, decoded_display_token.find(token_delimiter));
+}
+
+static std::string TokenFromDisplayToken(const std::string& display_token) {
+    std::size_t outlen = 4 * ((display_token.length() + 2) / 3);
+    std::array<unsigned char, 512> output{};
+    EVP_DecodeBlock(output.data(), reinterpret_cast<const unsigned char*>(display_token.c_str()), display_token.length());
+    std::string decoded_display_token(reinterpret_cast<char*>(&output), outlen);
+    return decoded_display_token.substr(decoded_display_token.find(token_delimiter) + 1);
+}
+
+static Network::Room::BanList LoadBanList(const std::string& path) {
+    std::ifstream file;
+    Common::FS::OpenFileStream(file, path, std::ios_base::in);
+    if (!file || file.eof()) {
+        LOG_ERROR(Network, "Could not open ban list!");
+        return {};
+    }
+    std::string magic;
+    std::getline(file, magic);
+    if (magic != BanListMagic) {
+        LOG_ERROR(Network, "Ban list is not valid!");
+        return {};
+    }
+
+    // false = username ban list, true = ip ban list
+    bool ban_list_type = false;
+    Network::Room::UsernameBanList username_ban_list;
+    Network::Room::IPBanList ip_ban_list;
+    while (!file.eof()) {
+        std::string line;
+        std::getline(file, line);
+        line.erase(std::remove(line.begin(), line.end(), '\0'), line.end());
+        line = Common::StripSpaces(line);
+        if (line.empty()) {
+            // An empty line marks start of the IP ban list
+            ban_list_type = true;
+            continue;
+        }
+        if (ban_list_type) {
+            ip_ban_list.emplace_back(line);
+        } else {
+            username_ban_list.emplace_back(line);
+        }
+    }
+
+    return {username_ban_list, ip_ban_list};
+}
+
+static void SaveBanList(const Network::Room::BanList& ban_list, const std::string& path) {
+    std::ofstream file;
+    Common::FS::OpenFileStream(file, path, std::ios_base::out);
+    if (!file) {
+        LOG_ERROR(Network, "Could not save ban list!");
+        return;
+    }
+
+    file << BanListMagic << "\n";
+
+    // Username ban list
+    for (const auto& username : ban_list.first) {
+        file << username << "\n";
+    }
+    file << "\n";
+
+    // IP ban list
+    for (const auto& ip : ban_list.second) {
+        file << ip << "\n";
+    }
+}
+
+/// Application entry point
+void LaunchRoom(int argc, char** argv, bool called_by_option) {
+    int option_index = 0;
+    char* endarg;
+
+    char* new_argv0 = argv[0];
+    if (called_by_option) {
+        strncat(new_argv0, " --room", 8);
+    }
+
+    std::string room_name;
+    std::string room_description;
+    std::string password;
+    std::string preferred_game;
+    std::string username;
+    std::string token;
+    std::string web_api_url;
+    std::string ban_list_file;
+    std::string log_file = "eden-room.log";
+    std::string bind_address;
+    u64 preferred_game_id = 0;
+    u32 port = Network::DefaultRoomPort;
+    u32 max_members = 16;
+
+    static struct option long_options[] = {
+        {"room-name", required_argument, 0, 'n'},
+        {"room-description", required_argument, 0, 'd'},
+        {"bind-address", required_argument, 0, 's'},
+        {"port", required_argument, 0, 'p'},
+        {"max-members", required_argument, 0, 'm'},
+        {"password", required_argument, 0, 'w'},
+        {"preferred-game", required_argument, 0, 'g'},
+        {"preferred-game-id", required_argument, 0, 'i'},
+        {"username", optional_argument, 0, 'u'},
+        {"token", required_argument, 0, 't'},
+        {"web-api-url", required_argument, 0, 'a'},
+        {"ban-list-file", required_argument, 0, 'b'},
+        {"log-file", required_argument, 0, 'l'},
+        {"help", no_argument, 0, 'h'},
+        {"version", no_argument, 0, 'v'},
+        // Entry option
+        {"room", 0, 0, 0},
+        {0, 0, 0, 0},
+    };
+
+    Common::Log::Initialize();
+    Common::Log::SetColorConsoleBackendEnabled(true);
+    Common::Log::Start();
+
+    while (optind < argc) {
+        int arg = getopt_long(argc, argv, "n:d:s:p:m:w:g:u:t:a:i:l:hv", long_options, &option_index);
+        if (arg != -1) {
+            char carg = static_cast<char>(arg);
+
+            switch (carg) {
+            case 'n':
+                room_name.assign(optarg);
+                break;
+            case 'd':
+                room_description.assign(optarg);
+                break;
+            case 's':
+                bind_address.assign(optarg);
+                break;
+            case 'p':
+                port = strtoul(optarg, &endarg, 0);
+                break;
+            case 'm':
+                max_members = strtoul(optarg, &endarg, 0);
+                break;
+            case 'w':
+                password.assign(optarg);
+                break;
+            case 'g':
+                preferred_game.assign(optarg);
+                break;
+            case 'i':
+                preferred_game_id = strtoull(optarg, &endarg, 16);
+                break;
+            case 'u':
+                username.assign(optarg);
+                break;
+            case 't':
+                token.assign(optarg);
+                break;
+            case 'a':
+                web_api_url.assign(optarg);
+                break;
+            case 'b':
+                ban_list_file.assign(optarg);
+                break;
+            case 'l':
+                log_file.assign(optarg);
+                break;
+            case 'h':
+                PrintHelp(argv[0]);
+                std::exit(0);
+            case 'v':
+                PrintVersion();
+                std::exit(0);
+            default:
+                break;
+            }
+        }
+    }
+
+    if (room_name.empty()) {
+        LOG_ERROR(Network, "Room name is empty!");
+        PrintHelp(argv[0]);
+        std::exit(-1);
+    }
+    if (preferred_game.empty()) {
+        LOG_ERROR(Network, "Preferred game is empty!");
+        PrintHelp(argv[0]);
+        std::exit(-1);
+    }
+    if (preferred_game_id == 0) {
+        LOG_ERROR(Network,
+                  "preferred-game-id not set!\nThis should get set to allow users to find your "
+                  "room.\nSet with --preferred-game-id id");
+    }
+    if (max_members > Network::MaxConcurrentConnections || max_members < 2) {
+        LOG_ERROR(Network,
+                  "max_members needs to be in the range 2 - {}!",
+                  Network::MaxConcurrentConnections);
+        PrintHelp(argv[0]);
+        std::exit(-1);
+    }
+    if (bind_address.empty()) {
+        LOG_INFO(Network, "Bind address is empty: defaulting to 0.0.0.0");
+    }
+    if (port > UINT16_MAX) {
+        LOG_ERROR(Network, "Port needs to be in the range 0 - 65535!");
+        PrintHelp(argv[0]);
+        std::exit(-1);
+    }
+    if (ban_list_file.empty()) {
+        LOG_ERROR(Network,
+                  "Ban list file not set!\nThis should get set to load and save room ban "
+                  "list.\nSet with --ban-list-file <file>");
+    }
+    bool announce = true;
+    if (token.empty() && announce) {
+        announce = false;
+        LOG_INFO(Network, "Token is empty: Hosting a private room");
+    }
+    if (web_api_url.empty() && announce) {
+        announce = false;
+        LOG_INFO(Network, "Endpoint url is empty: Hosting a private room");
+    }
+    if (announce) {
+        if (username.empty()) {
+            LOG_INFO(Network, "Hosting a public room");
+            Settings::values.web_api_url = web_api_url;
+            PadToken(token);
+            Settings::values.eden_username = UsernameFromDisplayToken(token);
+            username = Settings::values.eden_username.GetValue();
+            Settings::values.eden_token = TokenFromDisplayToken(token);
+        } else {
+            LOG_INFO(Network, "Hosting a public room");
+            Settings::values.web_api_url = web_api_url;
+            Settings::values.eden_username = username;
+            Settings::values.eden_token = token;
+        }
+    }
+
+    // Load the ban list
+    Network::Room::BanList ban_list;
+    if (!ban_list_file.empty()) {
+        ban_list = LoadBanList(ban_list_file);
+    }
+
+    std::unique_ptr<Network::VerifyUser::Backend> verify_backend;
+    if (announce) {
+#ifdef ENABLE_WEB_SERVICE
+        verify_backend =
+            std::make_unique<WebService::VerifyUserJWT>(Settings::values.web_api_url.GetValue());
+#else
+        LOG_INFO(Network,
+                 "Eden Web Services is not available with this build: validation is disabled.");
+        verify_backend = std::make_unique<Network::VerifyUser::NullBackend>();
+#endif
+    } else {
+        verify_backend = std::make_unique<Network::VerifyUser::NullBackend>();
+    }
+
+    Network::Init();
+    if (auto room = Network::GetRoom().lock()) {
+        AnnounceMultiplayerRoom::GameInfo preferred_game_info{.name = preferred_game,
+                                                              .id = preferred_game_id};
+        if (!room->Create(room_name, room_description, bind_address, static_cast<u16>(port),
+                          password, max_members, username, preferred_game_info,
+                          std::move(verify_backend), ban_list)) {
+            LOG_INFO(Network, "Failed to create room: ");
+            std::exit(-1);
+        }
+        LOG_INFO(Network, "Room is open. Close with Q+Enter...");
+        auto announce_session = std::make_unique<Core::AnnounceMultiplayerSession>();
+        if (announce) {
+            announce_session->Start();
+        }
+        while (room->GetState() == Network::Room::State::Open) {
+            std::string in;
+            std::cin >> in;
+            if (in.size() > 0) {
+                break;
+            }
+            std::this_thread::sleep_for(std::chrono::milliseconds(100));
+        }
+        if (announce) {
+            announce_session->Stop();
+        }
+        announce_session.reset();
+        // Save the ban list
+        if (!ban_list_file.empty()) {
+            SaveBanList(room->GetBanList(), ban_list_file);
+        }
+        room->Destroy();
+    }
+    Network::Shutdown();
+    std::exit(0);
+}
@@ -0,0 +1,7 @@
+// Copyright eden Emulator Project
+// Licensed under GPLv3 or any later version
+// Refer to the license.txt file included.
+
+#pragma once
+
+void LaunchRoom(int argc, char** argv, bool called_by_option);
@@ -0,0 +1,20 @@
+// SPDX-FileCopyrightText: 2017 Citra Emulator Project
+// SPDX-License-Identifier: GPL-2.0-or-later
+
+#include "winresrc.h"
+/////////////////////////////////////////////////////////////////////////////
+//
+// Icon
+//
+
+// Icon with lowest ID value placed first to ensure application icon
+// remains consistent on all systems.
+YUZU_ICON              ICON                    "../../dist/eden.ico"
+
+
+/////////////////////////////////////////////////////////////////////////////
+//
+// RT_MANIFEST
+//
+
+0                       RT_MANIFEST             "../../dist/yuzu.manifest"
@@ -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 (OPENBSD OR DRAGONFLY OR NETBSD)
+if (PLATFORM_OPENBSD OR PLATFORM_DRAGONFLY OR PLATFORM_NETBSD)
    set(REQUIRE_WX ON)
 else()
    set(REQUIRE_WX OFF)
@@ -363,7 +363,7 @@ elseif (APPLE)
            backend/exception_handler_macos_mig.c
        )
    endif()
-elseif (UNIX AND NOT HAIKUOS)
+elseif (UNIX AND NOT PLATFORM_HAIKU)
    # 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 in order to not mess with initializer lists
+    // Keep it here, you don't wanna mess with the fuckery that's initializer lists
    const A32::UserConfig conf;
    Jit* jit_interface;

@@ -2160,6 +2160,8 @@ 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)
@@ -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 errata)
+/// 2a. 0x8000_0000 / 0xFFFF_FFFF -> 0x8000_0000 (NOTE: More ARM bullshit)
 /// 2b. 0x8000_0000_0000_0000 / 0xFFFF_FFFF_FFFF_FFFF -> 0x8000_0000_0000_0000
 /// 3. imm_x / imm_y -> result
 /// 4. x / 1 -> x
@@ -151,7 +151,7 @@ if (MSVC)
    )
 else()
    target_compile_options(hid_core PRIVATE
-        $<$<COMPILE_LANGUAGE:C,CXX>:-Wconversion>
+        $<$<COMPILE_LANGUAGE:C,CXX>:-Werror=conversion>
        $<$<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>:-Wconversion>)
+    target_compile_options(input_common PRIVATE $<$<COMPILE_LANGUAGE:C,CXX>:-Werror=conversion>)
 endif()

 if (ANDROID)
@@ -1,6 +1,3 @@
-// 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

@@ -160,8 +157,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 dev_str = device.RawString();
-        if (dev_str.find(vids[i]) != std::string::npos) {
+        auto fucker = device.RawString();
+        if (fucker.find(vids[i]) != std::string::npos) {
            return true;
        }
    }
@@ -648,13 +648,6 @@ 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");
@@ -1,4 +1,4 @@
-# SPDX-FileCopyrightText: Copyright 2026 Eden Emulator Project
+# SPDX-FileCopyrightText: Copyright 2025 Eden Emulator Project
 # SPDX-License-Identifier: GPL-3.0-or-later

 # SPDX-FileCopyrightText: 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 (SOLARIS)
+if (PLATFORM_SUN)
    target_link_libraries(network PRIVATE socket nsl)
 endif()
@@ -6,31 +6,18 @@
 #include <algorithm>
 #include <atomic>
 #include <iomanip>
-#include <iostream>
 #include <mutex>
 #include <random>
 #include <regex>
 #include <shared_mutex>
 #include <sstream>
 #include <thread>
-#include <fstream>
-
-#include <openssl/evp.h>
-
-#include "common/fs/file.h"
 #include "common/polyfill_thread.h"
 #include "common/logging.h"
-#include "common/settings.h"
-#include "common/string_util.h"
 #include "enet/enet.h"
-#include "network/announce_multiplayer_session.h"
 #include "network/packet.h"
 #include "network/room.h"
-#include "network/network.h"
 #include "network/verify_user.h"
-#ifdef ENABLE_WEB_SERVICE
-#include "web_service/verify_user_jwt.h"
-#endif

 namespace Network {

@@ -1155,199 +1142,4 @@ void Room::Destroy() {
    room_impl->room_information.name.clear();
 }

-/// The magic text at the beginning of a yuzu-room ban list file.
-static constexpr char BAN_LIST_MAGIC[] = "YuzuRoom-BanList-1";
-static constexpr char TOKEN_DELIMITER{':'};
-
-static void PadToken(std::string& token) {
-    std::array<unsigned char, 512> output{};
-    std::array<unsigned char, 2048> roundtrip{};
-    for (size_t i = 0; i < 3; i++) {
-        EVP_DecodeBlock(output.data(), reinterpret_cast<const unsigned char*>(token.c_str()), token.size());
-        EVP_EncodeBlock(output.data(), roundtrip.data(), roundtrip.size());
-        if (memcmp(roundtrip.data(), token.data(), token.size()) == 0) {
-            break;
-        }
-        token.push_back('=');
-    }
-}
-
-static std::string UsernameFromDisplayToken(const std::string& display_token) {
-    std::size_t outlen = 4 * ((display_token.length() + 2) / 3);
-    std::array<unsigned char, 512> output{};
-    EVP_DecodeBlock(output.data(), reinterpret_cast<const unsigned char*>(display_token.c_str()), display_token.length());
-    std::string decoded_display_token(reinterpret_cast<char*>(&output), outlen);
-    return decoded_display_token.substr(0, decoded_display_token.find(TOKEN_DELIMITER));
-}
-
-static std::string TokenFromDisplayToken(const std::string& display_token) {
-    std::size_t outlen = 4 * ((display_token.length() + 2) / 3);
-    std::array<unsigned char, 512> output{};
-    EVP_DecodeBlock(output.data(), reinterpret_cast<const unsigned char*>(display_token.c_str()), display_token.length());
-    std::string decoded_display_token(reinterpret_cast<char*>(&output), outlen);
-    return decoded_display_token.substr(decoded_display_token.find(TOKEN_DELIMITER) + 1);
-}
-
-static Network::Room::BanList LoadBanList(const std::string& path) {
-    std::ifstream file;
-    Common::FS::OpenFileStream(file, path, std::ios_base::in);
-    if (!file || file.eof()) {
-        LOG_ERROR(Network, "Could not open ban list!");
-        return {};
-    }
-    std::string magic;
-    std::getline(file, magic);
-    if (magic != BAN_LIST_MAGIC) {
-        LOG_ERROR(Network, "Ban list is not valid!");
-        return {};
-    }
-
-    // false = username ban list, true = ip ban list
-    bool ban_list_type = false;
-    Network::Room::UsernameBanList username_ban_list;
-    Network::Room::IPBanList ip_ban_list;
-    while (!file.eof()) {
-        std::string line;
-        std::getline(file, line);
-        line.erase(std::remove(line.begin(), line.end(), '\0'), line.end());
-        line = Common::StripSpaces(line);
-        if (line.empty()) {
-            // An empty line marks start of the IP ban list
-            ban_list_type = true;
-            continue;
-        }
-        if (ban_list_type) {
-            ip_ban_list.emplace_back(line);
-        } else {
-            username_ban_list.emplace_back(line);
-        }
-    }
-    return {username_ban_list, ip_ban_list};
-}
-
-static void SaveBanList(const Network::Room::BanList& ban_list, const std::string& path) {
-    std::ofstream file;
-    Common::FS::OpenFileStream(file, path, std::ios_base::out);
-    if (!file) {
-        LOG_ERROR(Network, "Could not save ban list!");
-        return;
-    }
-    file << BAN_LIST_MAGIC << "\n";
-    // Username ban list
-    for (const auto& username : ban_list.first)
-        file << username << "\n";
-    file << "\n";
-    // IP ban list
-    for (const auto& ip : ban_list.second)
-        file << ip << "\n";
-}
-
-int LaunchRoomLoopWithArguments(Common::ProgramArguments& args) {
-    if (args.room_name.empty()) {
-        LOG_ERROR(Network, "Room name is empty!");
-        return -1;
-    }
-    if (args.preferred_game.empty()) {
-        LOG_ERROR(Network, "Preferred game is empty!");
-        return -1;
-    }
-    if (args.preferred_game_id == 0) {
-        LOG_WARNING(Network,
-            "preferred-game-id not set!\n"
-            "This should get set to allow users to find your room.\n"
-            "Set with --preferred-game-id id");
-    }
-    if (args.bind_address.empty()) {
-        LOG_INFO(Network, "Bind address is empty: defaulting to 0.0.0.0");
-    }
-    if (args.ban_list_file.empty()) {
-        LOG_WARNING(Network,
-            "Ban list file not set!\n"
-            "This should get set to load and save room ban list.\n"
-            "Set with --ban-list-file <file>");
-    }
-    bool announce = true;
-    if (args.token.empty() && announce) {
-        announce = false;
-        LOG_INFO(Network, "Token is empty: Hosting a private room");
-    }
-    if (args.web_api_url.empty() && announce) {
-        announce = false;
-        LOG_INFO(Network, "Endpoint url is empty: Hosting a private room");
-    }
-    if (announce) {
-        if (args.username.empty()) {
-            LOG_INFO(Network, "Hosting a public room");
-            Settings::values.web_api_url = args.web_api_url;
-            PadToken(args.token);
-            Settings::values.eden_username = UsernameFromDisplayToken(args.token);
-            args.username = Settings::values.eden_username.GetValue();
-            Settings::values.eden_token = TokenFromDisplayToken(args.token);
-        } else {
-            LOG_INFO(Network, "Hosting a public room");
-            Settings::values.web_api_url = args.web_api_url;
-            Settings::values.eden_username = args.username;
-            Settings::values.eden_token = args.token;
-        }
-    }
-
-    // Load the ban list
-    Network::Room::BanList ban_list;
-    if (!args.ban_list_file.empty()) {
-        ban_list = LoadBanList(args.ban_list_file);
-    }
-
-    std::unique_ptr<Network::VerifyUser::Backend> verify_backend;
-    if (announce) {
-#ifdef ENABLE_WEB_SERVICE
-        verify_backend =
-            std::make_unique<WebService::VerifyUserJWT>(Settings::values.web_api_url.GetValue());
-#else
-        LOG_INFO(Network,
-                 "Eden Web Services is not available with this build: validation is disabled.");
-        verify_backend = std::make_unique<Network::VerifyUser::NullBackend>();
-#endif
-    } else {
-        verify_backend = std::make_unique<Network::VerifyUser::NullBackend>();
-    }
-
-    Network::Init();
-    if (auto room = Network::GetRoom().lock()) {
-        AnnounceMultiplayerRoom::GameInfo preferred_game_info{
-            .name = args.preferred_game,
-            .id = args.preferred_game_id
-        };
-        if (!room->Create(args.room_name, args.room_description, args.bind_address, u16(args.port),
-                          args.password, args.max_members, args.username, preferred_game_info,
-                          std::move(verify_backend), ban_list)) {
-            LOG_INFO(Network, "Failed to create room: ");
-            return -1;
-        }
-        LOG_INFO(Network, "Room is open. Close with Q+Enter...");
-        auto announce_session = std::make_unique<Core::AnnounceMultiplayerSession>();
-        if (announce) {
-            announce_session->Start();
-        }
-        while (room->GetState() == Network::Room::State::Open) {
-            std::string in;
-            std::cin >> in;
-            if (in.size() > 0) {
-                break;
-            }
-            std::this_thread::sleep_for(std::chrono::milliseconds(100));
-        }
-        if (announce) {
-            announce_session->Stop();
-        }
-        announce_session.reset();
-        // Save the ban list
-        if (!args.ban_list_file.empty()) {
-            SaveBanList(room->GetBanList(), args.ban_list_file);
-        }
-        room->Destroy();
-    }
-    Network::Shutdown();
-    return 0;
-}
-
 } // namespace Network
@@ -1,4 +1,4 @@
-// SPDX-FileCopyrightText: Copyright 2026 Eden Emulator Project
+// SPDX-FileCopyrightText: Copyright 2025 Eden Emulator Project
 // SPDX-License-Identifier: GPL-3.0-or-later

 // SPDX-FileCopyrightText: Copyright 2017 Citra Emulator Project
@@ -10,7 +10,6 @@
 #include <memory>
 #include <string>
 #include <vector>
-#include "common/program_args.h"
 #include "common/announce_multiplayer_room.h"
 #include "common/common_types.h"
 #include "common/socket_types.h"
@@ -149,6 +148,4 @@ private:
    std::unique_ptr<RoomImpl> room_impl;
 };

-int LaunchRoomLoopWithArguments(Common::ProgramArguments& args);
-
 } // namespace Network
@@ -227,6 +227,8 @@ std::unique_ptr<TranslationMap> InitializeTranslations(QObject* parent) {
           tr("Preserves GPU-modified data by reading it back before uploading.\nSome games require this to render certain effects properly."));
    INSERT(Settings, use_asynchronous_shaders, tr("Enable asynchronous shader compilation"),
           tr("May reduce shader stutter."));
+    INSERT(Settings, use_unified_memory, tr("Enable unified memory access"),
+           tr("Lets the GPU write buffer readbacks directly into guest memory."));
    INSERT(Settings, gpu_clock, tr("GPU Clocks"),
           tr("Makes the game believe GPU work finishes faster than it does, so it stops lowering "
              "resolution and render distance to fit the Switch's clocks."));
@@ -253,7 +253,7 @@ if (MSVC)
    )
 else()
    target_compile_options(shader_recompiler PRIVATE
-        $<$<COMPILE_LANGUAGE:C,CXX>:-Wconversion>
+        $<$<COMPILE_LANGUAGE:C,CXX>:-Werror=conversion>
        # 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>
@@ -13,6 +13,7 @@
 namespace Shader::Backend::SPIRV {
 namespace {
 Id SharedPointer(EmitContext& ctx, Id offset, u32 index_offset = 0) {
+    offset = ctx.BoundSharedOffset(offset, 4 + index_offset * 4);
    const Id shift_id{ctx.Const(2U)};
    Id index{ctx.OpShiftRightArithmetic(ctx.U32[1], offset, shift_id)};
    if (index_offset > 0) {
@@ -160,7 +161,8 @@ Id EmitSharedAtomicExchange32(EmitContext& ctx, Id offset, Id value) {
 Id EmitSharedAtomicExchange64(EmitContext& ctx, Id offset, Id value) {
    if (ctx.profile.support_shared_int64_atomics && ctx.uses_explicit_workgroup_layout) {
        const Id shift_id{ctx.Const(3U)};
-        const Id index{ctx.OpShiftRightArithmetic(ctx.U32[1], offset, shift_id)};
+        const Id index{
+            ctx.OpShiftRightArithmetic(ctx.U32[1], ctx.BoundSharedOffset(offset, 8), shift_id)};
        const Id pointer{
            ctx.OpAccessChain(ctx.shared_u64, ctx.shared_memory_u64, ctx.u32_zero_value, index)};
        const auto [scope, semantics]{AtomicArgs(ctx)};
@@ -31,6 +31,7 @@ std::pair<Id, Id> ExtractArgs(EmitContext& ctx, Id offset, u32 mask, u32 count)
 } // Anonymous namespace

 Id EmitLoadSharedU8(EmitContext& ctx, Id offset) {
+    offset = ctx.BoundSharedOffset(offset, 1);
    if (ctx.uses_explicit_workgroup_layout) {
        const Id pointer{
            ctx.OpAccessChain(ctx.shared_u8, ctx.shared_memory_u8, ctx.u32_zero_value, offset)};
@@ -42,6 +43,7 @@ Id EmitLoadSharedU8(EmitContext& ctx, Id offset) {
 }

 Id EmitLoadSharedS8(EmitContext& ctx, Id offset) {
+    offset = ctx.BoundSharedOffset(offset, 1);
    if (ctx.uses_explicit_workgroup_layout) {
        const Id pointer{
            ctx.OpAccessChain(ctx.shared_u8, ctx.shared_memory_u8, ctx.u32_zero_value, offset)};
@@ -53,6 +55,7 @@ Id EmitLoadSharedS8(EmitContext& ctx, Id offset) {
 }

 Id EmitLoadSharedU16(EmitContext& ctx, Id offset) {
+    offset = ctx.BoundSharedOffset(offset, 2);
    if (ctx.uses_explicit_workgroup_layout) {
        const Id pointer{Pointer(ctx, ctx.shared_u16, ctx.shared_memory_u16, offset, 1)};
        return ctx.OpUConvert(ctx.U32[1], ctx.OpLoad(ctx.U16, pointer));
@@ -63,6 +66,7 @@ Id EmitLoadSharedU16(EmitContext& ctx, Id offset) {
 }

 Id EmitLoadSharedS16(EmitContext& ctx, Id offset) {
+    offset = ctx.BoundSharedOffset(offset, 2);
    if (ctx.uses_explicit_workgroup_layout) {
        const Id pointer{Pointer(ctx, ctx.shared_u16, ctx.shared_memory_u16, offset, 1)};
        return ctx.OpSConvert(ctx.U32[1], ctx.OpLoad(ctx.U16, pointer));
@@ -73,6 +77,7 @@ Id EmitLoadSharedS16(EmitContext& ctx, Id offset) {
 }

 Id EmitLoadSharedU32(EmitContext& ctx, Id offset) {
+    offset = ctx.BoundSharedOffset(offset, 4);
    if (ctx.uses_explicit_workgroup_layout) {
        const Id pointer{Pointer(ctx, ctx.shared_u32, ctx.shared_memory_u32, offset, 2)};
        return ctx.OpLoad(ctx.U32[1], pointer);
@@ -82,6 +87,7 @@ Id EmitLoadSharedU32(EmitContext& ctx, Id offset) {
 }

 Id EmitLoadSharedU64(EmitContext& ctx, Id offset) {
+    offset = ctx.BoundSharedOffset(offset, 8);
    if (ctx.uses_explicit_workgroup_layout) {
        const Id pointer{Pointer(ctx, ctx.shared_u32x2, ctx.shared_memory_u32x2, offset, 3)};
        return ctx.OpLoad(ctx.U32[2], pointer);
@@ -97,6 +103,7 @@ Id EmitLoadSharedU64(EmitContext& ctx, Id offset) {
 }

 Id EmitLoadSharedU128(EmitContext& ctx, Id offset) {
+    offset = ctx.BoundSharedOffset(offset, 16);
    if (ctx.uses_explicit_workgroup_layout) {
        const Id pointer{Pointer(ctx, ctx.shared_u32x4, ctx.shared_memory_u32x4, offset, 4)};
        return ctx.OpLoad(ctx.U32[4], pointer);
@@ -113,6 +120,7 @@ Id EmitLoadSharedU128(EmitContext& ctx, Id offset) {
 }

 void EmitWriteSharedU8(EmitContext& ctx, Id offset, Id value) {
+    offset = ctx.BoundSharedOffset(offset, 1);
    if (ctx.uses_explicit_workgroup_layout) {
        const Id pointer{
            ctx.OpAccessChain(ctx.shared_u8, ctx.shared_memory_u8, ctx.u32_zero_value, offset)};
@@ -123,6 +131,7 @@ void EmitWriteSharedU8(EmitContext& ctx, Id offset, Id value) {
 }

 void EmitWriteSharedU16(EmitContext& ctx, Id offset, Id value) {
+    offset = ctx.BoundSharedOffset(offset, 2);
    if (ctx.uses_explicit_workgroup_layout) {
        const Id pointer{Pointer(ctx, ctx.shared_u16, ctx.shared_memory_u16, offset, 1)};
        ctx.OpStore(pointer, ctx.OpUConvert(ctx.U16, value));
@@ -132,6 +141,7 @@ void EmitWriteSharedU16(EmitContext& ctx, Id offset, Id value) {
 }

 void EmitWriteSharedU32(EmitContext& ctx, Id offset, Id value) {
+    offset = ctx.BoundSharedOffset(offset, 4);
    Id pointer{};
    if (ctx.uses_explicit_workgroup_layout) {
        pointer = Pointer(ctx, ctx.shared_u32, ctx.shared_memory_u32, offset, 2);
@@ -144,6 +154,7 @@ void EmitWriteSharedU32(EmitContext& ctx, Id offset, Id value) {
 }

 void EmitWriteSharedU64(EmitContext& ctx, Id offset, Id value) {
+    offset = ctx.BoundSharedOffset(offset, 8);
    if (ctx.uses_explicit_workgroup_layout) {
        const Id pointer{Pointer(ctx, ctx.shared_u32x2, ctx.shared_memory_u32x2, offset, 3)};
        ctx.OpStore(pointer, value);
@@ -159,6 +170,7 @@ void EmitWriteSharedU64(EmitContext& ctx, Id offset, Id value) {
 }

 void EmitWriteSharedU128(EmitContext& ctx, Id offset, Id value) {
+    offset = ctx.BoundSharedOffset(offset, 16);
    if (ctx.uses_explicit_workgroup_layout) {
        const Id pointer{Pointer(ctx, ctx.shared_u32x4, ctx.shared_memory_u32x4, offset, 4)};
        ctx.OpStore(pointer, value);
@@ -600,6 +600,16 @@ void EmitContext::DefineLocalMemory(const IR::Program& program) {
    }
 }

+Id EmitContext::BoundSharedOffset(Id offset, u32 access_bytes) {
+    if (shared_memory_declared_bytes == 0) {
+        return offset;
+    }
+    const u32 last_valid{shared_memory_declared_bytes > access_bytes
+                             ? shared_memory_declared_bytes - access_bytes
+                             : 0U};
+    return OpUMin(U32[1], offset, Const(last_valid));
+}
+
 void EmitContext::DefineSharedMemory(const IR::Program& program) {
    uses_explicit_workgroup_layout =
        profile.support_explicit_workgroup_layout &&
@@ -608,8 +618,15 @@ void EmitContext::DefineSharedMemory(const IR::Program& program) {
    if (program.shared_memory_size == 0) {
        return;
    }
+    const u32 device_limit{profile.max_shared_memory_size};
+    const u32 shared_memory_size{device_limit != 0 && program.shared_memory_size > device_limit
+                                     ? device_limit
+                                     : program.shared_memory_size};
+    if (shared_memory_size != program.shared_memory_size) {
+        shared_memory_declared_bytes = shared_memory_size;
+    }
    const auto make{[&](Id element_type, u32 element_size) {
-        const u32 num_elements{Common::DivCeil(program.shared_memory_size, element_size)};
+        const u32 num_elements{Common::DivCeil(shared_memory_size, element_size)};
        const Id array_type{TypeArray(element_type, Const(num_elements))};
        Decorate(array_type, spv::Decoration::ArrayStride, element_size);

@@ -644,7 +661,7 @@ void EmitContext::DefineSharedMemory(const IR::Program& program) {
        std::tie(shared_memory_u32x4, shared_u32x4, std::ignore) = make(U32[4], 16);
        return;
    }
-    const u32 num_elements{Common::DivCeil(program.shared_memory_size, 4U)};
+    const u32 num_elements{Common::DivCeil(shared_memory_size, 4U)};
    const Id type{TypeArray(U32[1], Const(num_elements))};
    shared_memory_u32_type = TypePointer(spv::StorageClass::Workgroup, type);

@@ -312,6 +312,8 @@ public:
    Id local_memory{};

    bool uses_explicit_workgroup_layout{};
+    u32 shared_memory_declared_bytes{};
+    [[nodiscard]] Id BoundSharedOffset(Id offset, u32 access_bytes);
    Id shared_memory_u8{};
    Id shared_memory_u16{};
    Id shared_memory_u32{};
@@ -101,6 +101,9 @@ struct Profile {

    u32 gl_max_compute_smem_size{};

+    /// Largest workgroup shared memory allocation the device accepts, 0 when unconstrained
+    u32 max_shared_memory_size{};
+
    /// Maxwell and earlier nVidia architectures have broken robust support
    bool has_broken_robust{};

@@ -373,7 +373,7 @@ 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>:-Wconversion>)
+        target_compile_options(video_core PRIVATE $<$<COMPILE_LANGUAGE:C,CXX>:-Werror=conversion>)
    endif()

    target_compile_options(video_core PRIVATE $<$<COMPILE_LANGUAGE:C,CXX>:-Wno-sign-conversion>)
@@ -571,7 +571,11 @@ void BufferCache<P>::AccumulateFlushes() {

 template <class P>
 bool BufferCache<P>::ShouldWaitAsyncFlushes() const noexcept {
-    return (!async_buffers.empty() && async_buffers.front().has_value());
+    if (async_buffers.empty()) {
+        return false;
+    }
+    return async_buffers.front().has_value() ||
+           !pending_downloads.front().unified_copies.empty();
 }

 template <class P>
@@ -579,6 +583,7 @@ void BufferCache<P>::CommitAsyncFlushesHigh() {
    AccumulateFlushes();

    if (committed_gpu_modified_ranges.empty()) {
+        pending_downloads.emplace_back();
        async_buffers.emplace_back(std::optional<Async_Buffer>{});
        return;
    }
@@ -638,27 +643,84 @@ void BufferCache<P>::CommitAsyncFlushesHigh() {
    }
    committed_gpu_modified_ranges.clear();
    if (downloads.empty()) {
+        pending_downloads.emplace_back();
        async_buffers.emplace_back(std::optional<Async_Buffer>{});
        return;
    }
-    auto download_staging = runtime.DownloadStagingBuffer(total_size_bytes, true);
-    boost::container::small_vector<BufferCopy, 4> normalized_copies;
-    runtime.PreCopyBarrier();
+
+    struct QueuedUnifiedCopy {
+        u64 window;
+        BufferId buffer_id;
+        boost::container::small_vector<BufferCopy, 16> copies;
+    };
+
+    AsyncDownloadBatch batch;
+    boost::container::small_vector<std::pair<BufferCopy, BufferId>, 16> staging_downloads;
+    boost::container::small_vector<QueuedUnifiedCopy, 4> unified_copy_queue;
+    boost::container::small_vector<u64, 4> window_ids;
+    UnifiedWindowGroups groups;
+    u64 staging_size_bytes = 0;
    for (auto& [copy, buffer_id] : downloads) {
-        copy.dst_offset += download_staging.offset;
-        const std::array copies{copy};
-        BufferCopy second_copy{copy};
        Buffer& buffer = slot_buffers[buffer_id];
-        second_copy.src_offset = static_cast<size_t>(buffer.CpuAddr()) + copy.src_offset;
-        const DAddr orig_device_addr = static_cast<DAddr>(second_copy.src_offset);
+        const DAddr orig_device_addr = buffer.CpuAddr() + copy.src_offset;
+        bool unified = false;
+        if constexpr (USE_UNIFIED_MEMORY) {
+            if (runtime.HasUnifiedMemory()) {
+                window_ids.clear();
+                groups.clear();
+                unified = ResolveUnifiedWindows(orig_device_addr, copy.src_offset, copy.size,
+                                                window_ids, groups);
+            }
+        }
+        BufferCopy record{copy};
+        record.src_offset = static_cast<size_t>(orig_device_addr);
+        if (unified) {
+            async_downloads.Add(orig_device_addr, copy.size);
+            buffer.MarkUsage(copy.src_offset, copy.size);
+            for (size_t i = 0; i < window_ids.size(); ++i) {
+                unified_copy_queue.push_back(
+                    QueuedUnifiedCopy{window_ids[i], buffer_id, std::move(groups[i])});
+            }
+            batch.unified_copies.push_back(record);
+            continue;
+        }
+        copy.dst_offset = staging_size_bytes;
+        constexpr u64 align = 64ULL;
+        staging_size_bytes += (copy.size + align - 1) & ~(align - 1ULL);
+        staging_downloads.push_back({copy, buffer_id});
+    }
+
+    std::optional<Async_Buffer> download_staging;
+    if (!staging_downloads.empty()) {
+        download_staging = runtime.DownloadStagingBuffer(staging_size_bytes, true);
+    }
+    runtime.PreCopyBarrier();
+    for (auto& [copy, buffer_id] : staging_downloads) {
+        copy.dst_offset += download_staging->offset;
+        const std::array copies{copy};
+        Buffer& buffer = slot_buffers[buffer_id];
+        BufferCopy record{copy};
+        record.src_offset = static_cast<size_t>(buffer.CpuAddr()) + copy.src_offset;
+        const DAddr orig_device_addr = static_cast<DAddr>(record.src_offset);
        async_downloads.Add(orig_device_addr, copy.size);
        buffer.MarkUsage(copy.src_offset, copy.size);
-        runtime.CopyBuffer(download_staging.buffer, buffer, copies, false);
-        normalized_copies.push_back(second_copy);
+        runtime.CopyBuffer(download_staging->buffer, buffer, copies, false);
+        batch.staging_copies.push_back(record);
+    }
+    if constexpr (USE_UNIFIED_MEMORY) {
+        for (const auto& queued : unified_copy_queue) {
+            const std::span<const BufferCopy> group_span(queued.copies.data(),
+                                                         queued.copies.size());
+            runtime.CopyToUnifiedMemory(queued.window, slot_buffers[queued.buffer_id], group_span);
+        }
+        if (!unified_copy_queue.empty()) {
+            runtime.FlushUnifiedMemoryCopies();
+            runtime.UnifiedMemoryHostBarrier();
+        }
    }
    runtime.PostCopyBarrier();
-    pending_downloads.emplace_back(std::move(normalized_copies));
-    async_buffers.emplace_back(download_staging);
+    pending_downloads.emplace_back(std::move(batch));
+    async_buffers.emplace_back(std::move(download_staging));
 }

 template <class P>
@@ -673,32 +735,49 @@ void BufferCache<P>::PopAsyncFlushes() {

 template <class P>
 void BufferCache<P>::PopAsyncBuffers() {
-    if (async_buffers.empty()) {
-        return;
-    }
-    if (!async_buffers.front().has_value()) {
+    struct Writeback {
+        DAddr addr;
+        const u8* src;
+        u64 size;
+    };
+    boost::container::small_vector<Writeback, 8> writebacks;
+    {
+        std::scoped_lock lock{mutex};
+        if (async_buffers.empty()) {
+            return;
+        }
+        auto& batch = pending_downloads.front();
+        auto& async_buffer = async_buffers.front();
+        if (async_buffer.has_value()) {
+            const u8* base = async_buffer->mapped_span.data();
+            const size_t base_offset = async_buffer->offset;
+            for (const auto& copy : batch.staging_copies) {
+                const DAddr device_addr = static_cast<DAddr>(copy.src_offset);
+                const u64 dst_offset = copy.dst_offset - base_offset;
+                const u8* read_mapped_memory = base + dst_offset;
+                async_downloads.ForEachInRange(
+                    device_addr, copy.size, [&](DAddr start, DAddr end, s32) {
+                        writebacks.push_back(
+                            {start, &read_mapped_memory[start - device_addr], end - start});
+                    });
+                async_downloads.Subtract(device_addr, copy.size, [&](DAddr start, DAddr end) {
+                    gpu_modified_ranges.Subtract(start, end - start);
+                });
+            }
+            async_buffers_death_ring.emplace_back(*async_buffer);
+        }
+        for (const auto& copy : batch.unified_copies) {
+            const DAddr device_addr = static_cast<DAddr>(copy.src_offset);
+            async_downloads.Subtract(device_addr, copy.size, [&](DAddr start, DAddr end) {
+                gpu_modified_ranges.Subtract(start, end - start);
+            });
+        }
        async_buffers.pop_front();
-        return;
+        pending_downloads.pop_front();
    }
-    auto& downloads = pending_downloads.front();
-    auto& async_buffer = async_buffers.front();
-    u8* base = async_buffer->mapped_span.data();
-    const size_t base_offset = async_buffer->offset;
-    for (const auto& copy : downloads) {
-        const DAddr device_addr = static_cast<DAddr>(copy.src_offset);
-        const u64 dst_offset = copy.dst_offset - base_offset;
-        const u8* read_mapped_memory = base + dst_offset;
-        async_downloads.ForEachInRange(device_addr, copy.size, [&](DAddr start, DAddr end, s32) {
-            device_memory.WriteBlockUnsafe(start, &read_mapped_memory[start - device_addr],
-                                           end - start);
-        });
-        async_downloads.Subtract(device_addr, copy.size, [&](DAddr start, DAddr end) {
-            gpu_modified_ranges.Subtract(start, end - start);
-        });
+    for (const auto& wb : writebacks) {
+        device_memory.WriteBlockUnsafe(wb.addr, wb.src, wb.size);
    }
-    async_buffers_death_ring.emplace_back(*async_buffer);
-    async_buffers.pop_front();
-    pending_downloads.pop_front();
 }

 template <class P>
@@ -1699,6 +1778,99 @@ void BufferCache<P>::ImmediateUploadMemory([[maybe_unused]] Buffer& buffer,
    }
 }

+template <class P>
+bool BufferCache<P>::ResolveUnifiedWindows(
+    [[maybe_unused]] DAddr device_addr, [[maybe_unused]] u64 buffer_offset,
+    [[maybe_unused]] u64 size, [[maybe_unused]] boost::container::small_vector<u64, 4>& window_ids,
+    [[maybe_unused]] UnifiedWindowGroups& groups) {
+    if constexpr (USE_UNIFIED_MEMORY) {
+        const u8* const physical_base = device_memory.GetPhysicalBase();
+        const u64 unified_base = runtime.UnifiedMemoryBase();
+        const u64 unified_size = runtime.UnifiedMemorySize();
+        const u64 window_size = runtime.UnifiedMemoryWindowSize();
+        if (window_size == 0) {
+            return false;
+        }
+        const auto group_for = [&](u64 window) -> boost::container::small_vector<BufferCopy, 16>& {
+            for (size_t i = 0; i < window_ids.size(); ++i) {
+                if (window_ids[i] == window) {
+                    return groups[i];
+                }
+            }
+            window_ids.push_back(window);
+            groups.emplace_back();
+            return groups.back();
+        };
+        u64 downloaded = 0;
+        while (downloaded < size) {
+            const DAddr page_addr = device_addr + downloaded;
+            const u8* const ptr = device_memory.GetPointer<u8>(page_addr);
+            if (ptr == nullptr) {
+                return false;
+            }
+            const u64 page_offset = page_addr & Core::DEVICE_PAGEMASK;
+            u64 chunk = (std::min)(size - downloaded,
+                                   static_cast<u64>(Core::DEVICE_PAGESIZE) - page_offset);
+            const u64 phys_offset = static_cast<u64>(ptr - physical_base);
+            if (phys_offset < unified_base || phys_offset - unified_base + chunk > unified_size) {
+                return false;
+            }
+            const u64 relative = phys_offset - unified_base;
+            const u64 window = relative / window_size;
+            const u64 local_offset = relative % window_size;
+            chunk = (std::min)(chunk, window_size - local_offset);
+            auto& group = group_for(window);
+            if (!group.empty()) {
+                BufferCopy& last = group.back();
+                if (last.src_offset + last.size == buffer_offset + downloaded &&
+                    last.dst_offset + last.size == local_offset) {
+                    last.size += chunk;
+                    downloaded += chunk;
+                    continue;
+                }
+            }
+            group.push_back(BufferCopy{
+                .src_offset = buffer_offset + downloaded,
+                .dst_offset = local_offset,
+                .size = chunk,
+            });
+            downloaded += chunk;
+        }
+        return true;
+    } else {
+        return false;
+    }
+}
+
+template <class P>
+bool BufferCache<P>::TryUnifiedDownloadMemory([[maybe_unused]] Buffer& buffer,
+                                              [[maybe_unused]] std::span<BufferCopy> copies) {
+    if constexpr (USE_UNIFIED_MEMORY) {
+        boost::container::small_vector<u64, 4> window_ids;
+        UnifiedWindowGroups groups;
+        for (const BufferCopy& copy : copies) {
+            if (!ResolveUnifiedWindows(buffer.CpuAddr() + copy.src_offset, copy.src_offset,
+                                       copy.size, window_ids, groups)) {
+                return false;
+            }
+        }
+        for (const BufferCopy& copy : copies) {
+            buffer.MarkUsage(copy.src_offset, copy.size);
+        }
+        runtime.PreCopyBarrier();
+        for (size_t i = 0; i < window_ids.size(); ++i) {
+            const std::span<const BufferCopy> group_span(groups[i].data(), groups[i].size());
+            runtime.CopyToUnifiedMemory(window_ids[i], buffer, group_span);
+        }
+        runtime.FlushUnifiedMemoryCopies();
+        runtime.UnifiedMemoryHostBarrier();
+        runtime.Finish();
+        return true;
+    } else {
+        return false;
+    }
+}
+
 template <class P>
 void BufferCache<P>::MappedUploadMemory([[maybe_unused]] Buffer& buffer,
                                        [[maybe_unused]] u64 total_size_bytes,
@@ -1802,6 +1974,12 @@ void BufferCache<P>::DownloadBufferMemory(Buffer& buffer, DAddr device_addr, u64
    }

    if constexpr (USE_MEMORY_MAPS) {
+        if constexpr (USE_UNIFIED_MEMORY) {
+            if (runtime.HasUnifiedMemory() &&
+                TryUnifiedDownloadMemory(buffer, std::span(copies.data(), copies.size()))) {
+                return;
+            }
+        }
        auto download_staging = runtime.DownloadStagingBuffer(total_size_bytes);
        const u8* const mapped_memory = download_staging.mapped_span.data();
        const std::span<BufferCopy> copies_span(copies.data(), copies.data() + copies.size());
@@ -180,6 +180,7 @@ class BufferCache : public VideoCommon::ChannelSetupCaches<BufferCacheChannelInf
    static constexpr bool USE_MEMORY_MAPS = P::USE_MEMORY_MAPS;
    static constexpr bool SEPARATE_IMAGE_BUFFERS_BINDINGS = P::SEPARATE_IMAGE_BUFFER_BINDINGS;
    static constexpr bool USE_MEMORY_MAPS_FOR_UPLOADS = P::USE_MEMORY_MAPS_FOR_UPLOADS;
+    static constexpr bool USE_UNIFIED_MEMORY = P::USE_UNIFIED_MEMORY;

 #ifdef YUZU_LEGACY
    static constexpr s64 TARGET_THRESHOLD = 3_GiB;
@@ -443,6 +444,15 @@ private:

    void MappedUploadMemory(Buffer& buffer, u64 total_size_bytes, std::span<BufferCopy> copies);

+    bool TryUnifiedDownloadMemory(Buffer& buffer, std::span<BufferCopy> copies);
+
+    using UnifiedWindowGroups =
+        boost::container::small_vector<boost::container::small_vector<BufferCopy, 16>, 4>;
+
+    bool ResolveUnifiedWindows(DAddr device_addr, u64 buffer_offset, u64 size,
+                               boost::container::small_vector<u64, 4>& window_ids,
+                               UnifiedWindowGroups& groups);
+
    void DownloadBufferMemory(Buffer& buffer_id);

    void DownloadBufferMemory(Buffer& buffer_id, DAddr device_addr, u64 size);
@@ -498,9 +508,14 @@ private:
    std::deque<Common::RangeSet<DAddr>> committed_gpu_modified_ranges;

    // Async Buffers
+    struct AsyncDownloadBatch {
+        boost::container::small_vector<BufferCopy, 4> staging_copies;
+        boost::container::small_vector<BufferCopy, 4> unified_copies;
+    };
+
    Common::OverlapRangeSet<DAddr> async_downloads;
    std::deque<std::optional<Async_Buffer>> async_buffers;
-    std::deque<boost::container::small_vector<BufferCopy, 4>> pending_downloads;
+    std::deque<AsyncDownloadBatch> pending_downloads;
    std::optional<Async_Buffer> current_buffer;

    std::deque<Async_Buffer> async_buffers_death_ring;
@@ -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]);
+                return bool(is_instanced[index]); //FUCK YOU MSVC
            }
        };

@@ -40,6 +40,7 @@ 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 shift on read and bring the range
+                    // Right-shift the channels by 16 to un-do the left shit 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 (HAIKUOS)
+if (PLATFORM_HAIKU)
    # 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 chaos will ensue
+    // Vector must hold its last indices otherwise wonky shit will happen
    // The next parameter index starts at 1, because $r1 already has the value of the first
    // parameter.
    next_parameter_index = 1;
@@ -261,6 +261,7 @@ struct BufferCacheParams {

    // TODO: Investigate why OpenGL seems to perform worse with persistently mapped buffer uploads
    static constexpr bool USE_MEMORY_MAPS_FOR_UPLOADS = false;
+    static constexpr bool USE_UNIFIED_MEMORY = false;
 };

 using BufferCache = VideoCommon::BufferCache<BufferCacheParams>;
@@ -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)
+        if (p != nullptr) // Fuck you? - sincerely, buggy mesa drivers
            extensions.push_back(std::string{p});
    }
    return extensions;
@@ -237,6 +237,7 @@ ShaderCache::ShaderCache(Tegra::MaxwellDeviceMemoryManager& device_memory_,
          .has_gl_bool_ref_bug = device.HasBoolRefBug(),
          .ignore_nan_fp_comparisons = true,
          .gl_max_compute_smem_size = device.GetMaxComputeSharedMemorySize(),
+          .max_shared_memory_size = device.GetMaxComputeSharedMemorySize(),
          .min_ssbo_alignment = device.GetShaderStorageBufferAlignment(),
          // Use the host limit, but never more than the guest can produce. Maxwell exposes 8 clip
          // distances and the SPIR-V output array is sized for at most 8, so clamping here keeps a
@@ -8,6 +8,7 @@
 #include <array>
 #include <cstring>
 #include <span>
+#include <utility>
 #include <vector>

 #include "video_core/buffer_cache/buffer_cache_base.h"
@@ -32,6 +33,32 @@ VkBufferCopy MakeBufferCopy(const VideoCommon::BufferCopy& copy) {
    };
 }

+constexpr size_t MAX_WINDOW_BARRIER_RANGES = 8;
+
+using WindowRange = std::pair<VkDeviceSize, VkDeviceSize>;
+using WindowRanges = boost::container::small_vector<WindowRange, MAX_WINDOW_BARRIER_RANGES>;
+
+void CoalesceWindowRanges(WindowRanges& ranges) {
+    if (ranges.size() < 2) {
+        return;
+    }
+    std::sort(ranges.begin(), ranges.end());
+    size_t merged = 0;
+    for (size_t index = 1; index < ranges.size(); ++index) {
+        if (ranges[index].first <= ranges[merged].second) {
+            ranges[merged].second = (std::max)(ranges[merged].second, ranges[index].second);
+        } else {
+            ranges[++merged] = ranges[index];
+        }
+    }
+    ranges.resize(merged + 1);
+    if (ranges.size() > MAX_WINDOW_BARRIER_RANGES) {
+        const WindowRange bounding{ranges.front().first, ranges.back().second};
+        ranges.clear();
+        ranges.push_back(bounding);
+    }
+}
+
 VkIndexType IndexTypeFromNumElements(const Device& device, u32 num_elements) {
    if (num_elements <= 0xff && device.IsExtIndexTypeUint8Supported()) {
        return VK_INDEX_TYPE_UINT8_EXT;
@@ -365,6 +392,141 @@ BufferCacheRuntime::BufferCacheRuntime(const Device& device_, MemoryAllocator& m
                                                                     scheduler_, staging_pool_);
 }

+void BufferCacheRuntime::TryEnableUnifiedMemory(void* base, size_t size,
+                                                std::span<AHardwareBuffer* const> hardware_buffers,
+                                                size_t hardware_buffer_window,
+                                                size_t hardware_buffer_base) {
+    unified_memory = std::make_unique<HostMemoryImport>(
+        device, base, size, hardware_buffers, hardware_buffer_window, hardware_buffer_base);
+    if (!unified_memory->IsValid()) {
+        unified_memory.reset();
+    }
+}
+
+void BufferCacheRuntime::CopyToUnifiedMemory(
+    size_t window_index, VkBuffer src_buffer,
+    std::span<const VideoCommon::BufferCopy> copies) {
+    if (!unified_memory || src_buffer == VK_NULL_HANDLE || copies.empty() ||
+        window_index >= unified_memory->GetWindowCount() ||
+        unified_memory->GetWindowBuffer(window_index) == VK_NULL_HANDLE) {
+        return;
+    }
+    PendingUnifiedCopy& pending = pending_unified_copies.emplace_back();
+    pending.window = window_index;
+    pending.buffer = src_buffer;
+    pending.copies.resize(copies.size());
+    std::ranges::transform(copies, pending.copies.begin(), MakeBufferCopy);
+}
+
+void BufferCacheRuntime::FlushUnifiedMemoryCopies() {
+    if (pending_unified_copies.empty()) {
+        return;
+    }
+    struct UnifiedCopyCommand {
+        VkBuffer buffer;
+        boost::container::small_vector<VkBufferCopy, 8> copies;
+    };
+
+    std::stable_sort(pending_unified_copies.begin(), pending_unified_copies.end(),
+                     [](const PendingUnifiedCopy& lhs, const PendingUnifiedCopy& rhs) {
+                         return lhs.window < rhs.window;
+                     });
+
+    const bool foreign = unified_memory->NeedsForeignOwnershipTransfer();
+    const u32 queue_family = device.GetGraphicsFamily();
+
+    size_t group_begin = 0;
+    while (group_begin < pending_unified_copies.size()) {
+        const size_t window = pending_unified_copies[group_begin].window;
+        size_t group_end = group_begin;
+        while (group_end < pending_unified_copies.size() &&
+               pending_unified_copies[group_end].window == window) {
+            ++group_end;
+        }
+        const VkBuffer window_buffer = unified_memory->GetWindowBuffer(window);
+
+        WindowRanges ranges;
+        for (size_t index = group_begin; index < group_end; ++index) {
+            for (const VkBufferCopy& copy : pending_unified_copies[index].copies) {
+                ranges.emplace_back(copy.dstOffset, copy.dstOffset + copy.size);
+            }
+        }
+        CoalesceWindowRanges(ranges);
+
+        boost::container::small_vector<VkBufferMemoryBarrier, MAX_WINDOW_BARRIER_RANGES> acquire;
+        boost::container::small_vector<VkBufferMemoryBarrier, MAX_WINDOW_BARRIER_RANGES> release;
+        if (foreign) {
+            for (const WindowRange& range : ranges) {
+                acquire.push_back(VkBufferMemoryBarrier{
+                    .sType = VK_STRUCTURE_TYPE_BUFFER_MEMORY_BARRIER,
+                    .pNext = nullptr,
+                    .srcAccessMask = 0,
+                    .dstAccessMask = VK_ACCESS_TRANSFER_WRITE_BIT,
+                    .srcQueueFamilyIndex = VK_QUEUE_FAMILY_FOREIGN_EXT,
+                    .dstQueueFamilyIndex = queue_family,
+                    .buffer = window_buffer,
+                    .offset = range.first,
+                    .size = range.second - range.first,
+                });
+                release.push_back(VkBufferMemoryBarrier{
+                    .sType = VK_STRUCTURE_TYPE_BUFFER_MEMORY_BARRIER,
+                    .pNext = nullptr,
+                    .srcAccessMask = VK_ACCESS_TRANSFER_WRITE_BIT,
+                    .dstAccessMask = 0,
+                    .srcQueueFamilyIndex = queue_family,
+                    .dstQueueFamilyIndex = VK_QUEUE_FAMILY_FOREIGN_EXT,
+                    .buffer = window_buffer,
+                    .offset = range.first,
+                    .size = range.second - range.first,
+                });
+            }
+        }
+
+        boost::container::small_vector<UnifiedCopyCommand, 4> commands;
+        commands.reserve(group_end - group_begin);
+        for (size_t index = group_begin; index < group_end; ++index) {
+            PendingUnifiedCopy& pending = pending_unified_copies[index];
+            commands.push_back(UnifiedCopyCommand{pending.buffer, std::move(pending.copies)});
+        }
+
+        scheduler.RequestOutsideRenderPassOperationContext();
+        scheduler.Record([window_buffer, acquire = std::move(acquire), release = std::move(release),
+                          commands = std::move(commands)](vk::CommandBuffer cmdbuf) {
+            if (!acquire.empty()) {
+                cmdbuf.PipelineBarrier(VK_PIPELINE_STAGE_TOP_OF_PIPE_BIT,
+                                       VK_PIPELINE_STAGE_TRANSFER_BIT, 0, {},
+                                       VideoCommon::FixSmallVectorADL(acquire), {});
+            }
+            for (const UnifiedCopyCommand& command : commands) {
+                cmdbuf.CopyBuffer(command.buffer, window_buffer,
+                                  VideoCommon::FixSmallVectorADL(command.copies));
+            }
+            if (!release.empty()) {
+                cmdbuf.PipelineBarrier(VK_PIPELINE_STAGE_TRANSFER_BIT,
+                                       VK_PIPELINE_STAGE_BOTTOM_OF_PIPE_BIT, 0, {},
+                                       VideoCommon::FixSmallVectorADL(release), {});
+            }
+        });
+
+        group_begin = group_end;
+    }
+    pending_unified_copies.clear();
+}
+
+void BufferCacheRuntime::UnifiedMemoryHostBarrier() {
+    static constexpr VkMemoryBarrier HOST_BARRIER{
+        .sType = VK_STRUCTURE_TYPE_MEMORY_BARRIER,
+        .pNext = nullptr,
+        .srcAccessMask = VK_ACCESS_TRANSFER_WRITE_BIT,
+        .dstAccessMask = VK_ACCESS_HOST_READ_BIT,
+    };
+    scheduler.RequestOutsideRenderPassOperationContext();
+    scheduler.Record([](vk::CommandBuffer cmdbuf) {
+        cmdbuf.PipelineBarrier(VK_PIPELINE_STAGE_TRANSFER_BIT, VK_PIPELINE_STAGE_HOST_BIT, 0,
+                               HOST_BARRIER);
+    });
+}
+
 StagingBufferRef BufferCacheRuntime::UploadStagingBuffer(size_t size) {
    return staging_pool.Request(size, MemoryUsage::Upload);
 }
@@ -402,6 +564,7 @@ u32 BufferCacheRuntime::GetStorageBufferAlignment() const {
 }

 void BufferCacheRuntime::TickFrame(Common::SlotVector<Buffer>& slot_buffers) noexcept {
+    FlushUnifiedMemoryCopies();
    for (auto it = slot_buffers.begin(); it != slot_buffers.end(); it++) {
        if (scheduler.IsFree(it->LastUsageTick())) {
            it->ResetUsageTracking();
@@ -7,6 +7,10 @@
 #pragma once

 #include <limits>
+#include <memory>
+#include <span>
+
+#include <boost/container/small_vector.hpp>

 #include "video_core/buffer_cache/buffer_cache_base.h"
 #include "video_core/buffer_cache/memory_tracker_base.h"
@@ -97,6 +101,33 @@ public:

    void TickFrame(Common::SlotVector<Buffer>& slot_buffers) noexcept;

+    void TryEnableUnifiedMemory(void* base, size_t size,
+                                std::span<AHardwareBuffer* const> hardware_buffers,
+                                size_t hardware_buffer_window, size_t hardware_buffer_base);
+
+    [[nodiscard]] bool HasUnifiedMemory() const noexcept {
+        return unified_memory != nullptr && unified_memory->IsValid();
+    }
+
+    [[nodiscard]] u64 UnifiedMemorySize() const noexcept {
+        return unified_memory ? unified_memory->GetSize() : 0;
+    }
+
+    [[nodiscard]] u64 UnifiedMemoryBase() const noexcept {
+        return unified_memory ? unified_memory->GetBaseOffset() : 0;
+    }
+
+    [[nodiscard]] u64 UnifiedMemoryWindowSize() const noexcept {
+        return unified_memory ? unified_memory->GetWindowSize() : 0;
+    }
+
+    void CopyToUnifiedMemory(size_t window_index, VkBuffer src_buffer,
+                             std::span<const VideoCommon::BufferCopy> copies);
+
+    void FlushUnifiedMemoryCopies();
+
+    void UnifiedMemoryHostBarrier();
+
    u64 CurrentTick();

    u64 KnownGpuTick();
@@ -180,6 +211,12 @@ public:
    }

 private:
+    struct PendingUnifiedCopy {
+        size_t window;
+        VkBuffer buffer;
+        boost::container::small_vector<VkBufferCopy, 8> copies;
+    };
+
    void BindBuffer(const Buffer& buffer, u32 offset, u32 size) {
        const VkBuffer handle = buffer.Handle();
        if (handle == VK_NULL_HANDLE) {
@@ -204,6 +241,8 @@ private:
    std::shared_ptr<QuadStripIndexBuffer> quad_strip_index_buffer;

    vk::Buffer null_buffer;
+    std::unique_ptr<HostMemoryImport> unified_memory;
+    boost::container::small_vector<PendingUnifiedCopy, 8> pending_unified_copies;

    std::unique_ptr<Uint8Pass> uint8_pass;
    QuadIndexedPass quad_index_pass;
@@ -226,6 +265,7 @@ struct BufferCacheParams {
    static constexpr bool USE_MEMORY_MAPS = true;
    static constexpr bool SEPARATE_IMAGE_BUFFER_BINDINGS = false;
    static constexpr bool USE_MEMORY_MAPS_FOR_UPLOADS = true;
+    static constexpr bool USE_UNIFIED_MEMORY = true;
 };

 using BufferCache = VideoCommon::BufferCache<BufferCacheParams>;
@@ -446,6 +446,7 @@ PipelineCache::PipelineCache(Tegra::MaxwellDeviceMemoryManager& device_memory_,
        .has_broken_fp16_float_controls = driver_id == VK_DRIVER_ID_NVIDIA_PROPRIETARY,
        .ignore_nan_fp_comparisons = false,
        .has_broken_spirv_subgroup_mask_vector_extract_dynamic = false,
+        .max_shared_memory_size = device.GetMaxComputeSharedMemorySize(),
        .has_broken_robust =
            device.IsNvidia() && device.GetNvidiaArch() <= NvidiaArchitecture::Arch_Pascal,
        .min_ssbo_alignment = device.GetStorageBufferAlignment(),
@@ -921,19 +922,6 @@ std::unique_ptr<ComputePipeline> PipelineCache::CreateComputePipeline(
    }

    auto program{TranslateProgram(pools.inst, pools.block, env, cfg, host_info)};
-    const VkDriverIdKHR driver_id = device.GetDriverID();
-    const bool needs_shared_mem_clamp =
-        driver_id == VK_DRIVER_ID_QUALCOMM_PROPRIETARY ||
-        driver_id == VK_DRIVER_ID_ARM_PROPRIETARY;
-    const u32 max_shared_memory = device.GetMaxComputeSharedMemorySize();
-    if (needs_shared_mem_clamp && program.shared_memory_size > max_shared_memory) {
-        LOG_WARNING(Render_Vulkan,
-                    "Compute shader {:#016x} requests {}KB shared memory but device max is {}KB - clamping",
-                    key.unique_hash,
-                    program.shared_memory_size / 1024,
-                    max_shared_memory / 1024);
-        program.shared_memory_size = max_shared_memory;
-    }
    const std::vector<u32> code{EmitSPIRV(profile, program)};
    device.SaveShader(code);
    vk::ShaderModule spv_module{BuildShader(device, code)};
@@ -225,6 +225,13 @@ RasterizerVulkan::RasterizerVulkan(Core::Frontend::EmuWindow& emu_window_, Tegra
      fence_manager(*this, gpu, texture_cache, buffer_cache, query_cache, device, scheduler),
      wfi_event(device.GetLogical().CreateEvent()) {
    scheduler.SetQueryCache(query_cache);
+    if (Settings::values.use_unified_memory.GetValue() && device_memory.IsBackingShared()) {
+        buffer_cache_runtime.TryEnableUnifiedMemory(
+            device_memory.GetPhysicalBase(), device_memory.GetPhysicalSize(),
+            device_memory.GetBackingHardwareBuffers(),
+            device_memory.GetBackingHardwareBufferWindowSize(),
+            device_memory.GetBackingHardwareBufferBase());
+    }
 }

 RasterizerVulkan::~RasterizerVulkan() {
@@ -16,6 +16,7 @@
 #include <fmt/format.h>

 #include "common/assert.h"
+#include "common/host_memory.h"
 #include "common/literals.h"
 #include <ranges>
 #include "common/settings.h"
@@ -974,6 +975,7 @@ bool Device::GetSuitability(bool requires_swapchain) {

    FOR_EACH_VK_FEATURE_EXT(FEATURE_EXTENSION);
    FOR_EACH_VK_EXTENSION(EXTENSION);
+    FOR_EACH_VK_PLATFORM_EXTENSION(EXTENSION);

    if (supported_extensions.contains(VK_KHR_ROBUSTNESS_2_EXTENSION_NAME)) {
        loaded_extensions.erase(VK_EXT_ROBUSTNESS_2_EXTENSION_NAME);
@@ -986,6 +988,13 @@ bool Device::GetSuitability(bool requires_swapchain) {
        extensions.robustness_2 = false;
    }

+#ifdef __ANDROID__
+    if (extensions.external_memory_ahb && !extensions.queue_family_foreign) {
+        loaded_extensions.erase(VK_ANDROID_EXTERNAL_MEMORY_ANDROID_HARDWARE_BUFFER_EXTENSION_NAME);
+        extensions.external_memory_ahb = false;
+    }
+#endif
+
 #undef FEATURE_EXTENSION
 #undef EXTENSION

@@ -1142,6 +1151,21 @@ bool Device::GetSuitability(bool requires_swapchain) {
            VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MAINTENANCE_5_PROPERTIES_KHR;
        SetNext(next, properties.maintenance5);
    }
+    if (extensions.external_memory_host) {
+        properties.external_memory_host.sType =
+            VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_EXTERNAL_MEMORY_HOST_PROPERTIES_EXT;
+        SetNext(next, properties.external_memory_host);
+    }
+    if (extensions.maintenance3 || instance_version >= VK_API_VERSION_1_1) {
+        properties.maintenance3.sType =
+            VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MAINTENANCE_3_PROPERTIES;
+        SetNext(next, properties.maintenance3);
+    }
+    if (extensions.maintenance4 || features.maintenance4.maintenance4) {
+        properties.maintenance4.sType =
+            VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MAINTENANCE_4_PROPERTIES;
+        SetNext(next, properties.maintenance4);
+    }

    // Perform the property fetch.
    physical.GetProperties2(properties2);
@@ -1516,12 +1540,27 @@ void Device::CollectPhysicalMemoryInfo() {
    device_access_memory = 0;
    u64 device_initial_usage = 0;
    u64 local_memory = 0;
+    const auto heap_has_usable_type = [&mem_properties](size_t heap) {
+        for (u32 index = 0; index < mem_properties.memoryTypeCount; ++index) {
+            if (mem_properties.memoryTypes[index].heapIndex != heap) {
+                continue;
+            }
+            if ((mem_properties.memoryTypes[index].propertyFlags &
+                 VK_MEMORY_PROPERTY_PROTECTED_BIT) == 0) {
+                return true;
+            }
+        }
+        return false;
+    };
    for (size_t element = 0; element < num_properties; ++element) {
        const bool is_heap_local =
            (mem_properties.memoryHeaps[element].flags & VK_MEMORY_HEAP_DEVICE_LOCAL_BIT) != 0;
        if (!is_integrated && !is_heap_local) {
            continue;
        }
+        if (!heap_has_usable_type(element)) {
+            continue;
+        }
        valid_heap_memory.push_back(element);
        if (is_heap_local) {
            local_memory += mem_properties.memoryHeaps[element].size;
@@ -1533,6 +1572,13 @@ void Device::CollectPhysicalMemoryInfo() {
        }
        device_access_memory += mem_properties.memoryHeaps[element].size;
    }
+    const u64 committed_backing = Common::GetCommittedBackingSize();
+    if (committed_backing != 0) {
+        LOG_INFO(Render_Vulkan, "Discounting {} MiB of guest memory committed by the host",
+                 committed_backing >> 20);
+        local_memory -= std::min(local_memory, committed_backing);
+        device_access_memory -= std::min(device_access_memory, committed_backing);
+    }
    if (is_integrated) {
        const s64 available_memory = static_cast<s64>(device_access_memory - device_initial_usage);
        const u64 memory_size = Settings::values.vram_usage_mode.GetValue() == Settings::VramUsageMode::Aggressive ? 6_GiB : 4_GiB;
@@ -83,6 +83,7 @@ VK_DEFINE_HANDLE(VmaAllocator)
    EXTENSION(EXT, CONDITIONAL_RENDERING, conditional_rendering)                                   \
    EXTENSION(EXT, CONSERVATIVE_RASTERIZATION, conservative_rasterization)                         \
    EXTENSION(EXT, DEPTH_RANGE_UNRESTRICTED, depth_range_unrestricted)                             \
+    EXTENSION(EXT, EXTERNAL_MEMORY_HOST, external_memory_host)                                     \
    EXTENSION(EXT, MEMORY_BUDGET, memory_budget)                                                   \
    EXTENSION(EXT, ROBUSTNESS_2, robustness_2)                                                     \
    EXTENSION(EXT, SAMPLER_FILTER_MINMAX, sampler_filter_minmax)                                   \
@@ -112,6 +113,14 @@ VK_DEFINE_HANDLE(VmaAllocator)
    EXTENSION(IMG, FILTER_CUBIC, filter_cubic_img)                                                 \
    EXTENSION(QCOM, FILTER_CUBIC_WEIGHTS, filter_cubic_weights)

+#ifdef __ANDROID__
+#define FOR_EACH_VK_PLATFORM_EXTENSION(EXTENSION)                                                  \
+    EXTENSION(EXT, QUEUE_FAMILY_FOREIGN, queue_family_foreign)                                     \
+    EXTENSION(ANDROID, EXTERNAL_MEMORY_ANDROID_HARDWARE_BUFFER, external_memory_ahb)
+#else
+#define FOR_EACH_VK_PLATFORM_EXTENSION(EXTENSION)
+#endif
+
 // Define extensions which must be supported.
 #define FOR_EACH_VK_MANDATORY_EXTENSION(EXTENSION_NAME)                                            \
    EXTENSION_NAME(VK_EXT_VERTEX_ATTRIBUTE_DIVISOR_EXTENSION_NAME)                                 \
@@ -838,6 +847,30 @@ FN_MAX_LIMIT_LIST
        return extensions.conditional_rendering;
    }

+    bool IsExtExternalMemoryHostSupported() const {
+        return extensions.external_memory_host;
+    }
+
+    bool IsExtExternalMemoryAhbSupported() const {
+#ifdef __ANDROID__
+        return extensions.external_memory_ahb && extensions.queue_family_foreign;
+#else
+        return false;
+#endif
+    }
+
+    u64 GetMinImportedHostPointerAlignment() const {
+        return properties.external_memory_host.minImportedHostPointerAlignment;
+    }
+
+    u64 GetMaxBufferSize() const {
+        return properties.maintenance4.maxBufferSize;
+    }
+
+    u64 GetMaxMemoryAllocationSize() const {
+        return properties.maintenance3.maxMemoryAllocationSize;
+    }
+
    bool IsExtAstcDecodeModeSupported() const {
        return extensions.astc_decode_mode;
    }
@@ -1110,6 +1143,7 @@ private:
        FOR_EACH_VK_FEATURE_1_4(FEATURE);
        FOR_EACH_VK_FEATURE_EXT(FEATURE);
        FOR_EACH_VK_EXTENSION(EXTENSION);
+        FOR_EACH_VK_PLATFORM_EXTENSION(EXTENSION);

 #undef EXTENSION
 #undef FEATURE
@@ -1141,7 +1175,10 @@ private:
        VkPhysicalDeviceDescriptorBufferPropertiesEXT descriptor_buffer{};
        VkPhysicalDeviceSubgroupSizeControlProperties subgroup_size_control{};
        VkPhysicalDeviceTransformFeedbackPropertiesEXT transform_feedback{};
+        VkPhysicalDeviceMaintenance3Properties maintenance3{};
+        VkPhysicalDeviceMaintenance4Properties maintenance4{};
        VkPhysicalDeviceMaintenance5PropertiesKHR maintenance5{};
+        VkPhysicalDeviceExternalMemoryHostPropertiesEXT external_memory_host{};

        VkPhysicalDeviceProperties properties{};
    };
@@ -25,9 +25,34 @@
 #include "video_core/gpu_logging/gpu_logging.h"
 #include "common/settings.h"

+#ifdef __ANDROID__
+#include <android/hardware_buffer.h>
+#endif
+
 namespace Vulkan {
    namespace {

+        [[nodiscard]] std::optional<u32> FindImportMemoryType(
+                const VkPhysicalDeviceMemoryProperties &props, u32 type_mask) {
+            const auto find = [&](VkMemoryPropertyFlags wanted) -> std::optional<u32> {
+                for (u32 i = 0; i < props.memoryTypeCount; ++i) {
+                    if (((type_mask >> i) & 1u) != 0 &&
+                        (props.memoryTypes[i].propertyFlags & wanted) == wanted) {
+                        return i;
+                    }
+                }
+                return std::nullopt;
+            };
+            auto type_index = find(VK_MEMORY_PROPERTY_HOST_VISIBLE_BIT |
+                                   VK_MEMORY_PROPERTY_HOST_COHERENT_BIT |
+                                   VK_MEMORY_PROPERTY_HOST_CACHED_BIT);
+            if (!type_index) {
+                type_index = find(VK_MEMORY_PROPERTY_HOST_VISIBLE_BIT |
+                                  VK_MEMORY_PROPERTY_HOST_COHERENT_BIT);
+            }
+            return type_index;
+        }
+
 // Helpers translating MemoryUsage to flags/usage

        [[maybe_unused]] VkMemoryPropertyFlags MemoryUsagePropertyFlags(MemoryUsage usage) {
@@ -200,6 +225,263 @@ namespace Vulkan {
        size = 0;
    }

+    HostMemoryImport::HostMemoryImport(const Device &device_, void *base, size_t size,
+                                       std::span<AHardwareBuffer *const> hardware_buffers,
+                                       size_t hardware_buffer_window, size_t hardware_buffer_base)
+            : device{device_} {
+        if (ImportHardwareBuffers(hardware_buffers, hardware_buffer_window, hardware_buffer_base,
+                                  size)) {
+            return;
+        }
+        if (device.IsTiler()) {
+            return;
+        }
+        if (!hardware_buffers.empty()) {
+            return;
+        }
+        if (ImportHostPointer(base, size)) {
+            return;
+        }
+        LOG_INFO(Render_Vulkan, "Unified memory disabled, no host memory import path");
+    }
+
+    bool HostMemoryImport::ImportHostPointer(void *base, size_t size) {
+        if (!device.IsExtExternalMemoryHostSupported()) {
+            return false;
+        }
+        const u64 alignment = device.GetMinImportedHostPointerAlignment();
+        if (alignment == 0 || !Common::IsAligned(reinterpret_cast<uintptr_t>(base), alignment) ||
+            !Common::IsAligned(size, alignment)) {
+            return false;
+        }
+        using namespace Common::Literals;
+        constexpr VkDeviceSize DesktopWindowSize = 4_GiB;
+        VkDeviceSize candidate_window = DesktopWindowSize;
+        const u64 max_buffer_size = device.GetMaxBufferSize();
+        if (max_buffer_size != 0 && max_buffer_size < candidate_window) {
+            candidate_window = max_buffer_size;
+        }
+        const u64 max_allocation_size = device.GetMaxMemoryAllocationSize();
+        if (max_allocation_size != 0 && max_allocation_size < candidate_window) {
+            candidate_window = max_allocation_size;
+        }
+        candidate_window = Common::AlignDown(candidate_window, alignment);
+        if (candidate_window == 0) {
+            return false;
+        }
+        window_size = candidate_window;
+
+        const auto &logical = device.GetLogical();
+        const auto memory_props = device.GetPhysical().GetMemoryProperties().memoryProperties;
+
+        for (size_t offset = 0; offset < size; offset += window_size) {
+            u8 *const window_base = static_cast<u8 *>(base) + offset;
+            const VkDeviceSize window_len =
+                    (std::min)(static_cast<VkDeviceSize>(size - offset), window_size);
+            VkMemoryHostPointerPropertiesEXT host_props{
+                    .sType = VK_STRUCTURE_TYPE_MEMORY_HOST_POINTER_PROPERTIES_EXT,
+                    .pNext = nullptr,
+                    .memoryTypeBits = 0,
+            };
+            if (logical.GetMemoryHostPointerPropertiesEXT(
+                        VK_EXTERNAL_MEMORY_HANDLE_TYPE_HOST_ALLOCATION_BIT_EXT, window_base,
+                        &host_props) != VK_SUCCESS ||
+                host_props.memoryTypeBits == 0) {
+                break;
+            }
+            const VkExternalMemoryBufferCreateInfo external_info{
+                    .sType = VK_STRUCTURE_TYPE_EXTERNAL_MEMORY_BUFFER_CREATE_INFO,
+                    .pNext = nullptr,
+                    .handleTypes = VK_EXTERNAL_MEMORY_HANDLE_TYPE_HOST_ALLOCATION_BIT_EXT,
+            };
+            const VkBufferCreateInfo buffer_ci{
+                    .sType = VK_STRUCTURE_TYPE_BUFFER_CREATE_INFO,
+                    .pNext = &external_info,
+                    .flags = 0,
+                    .size = window_len,
+                    .usage = VK_BUFFER_USAGE_TRANSFER_SRC_BIT | VK_BUFFER_USAGE_TRANSFER_DST_BIT,
+                    .sharingMode = VK_SHARING_MODE_EXCLUSIVE,
+                    .queueFamilyIndexCount = 0,
+                    .pQueueFamilyIndices = nullptr,
+            };
+            VkBuffer new_buffer{};
+            if (logical.CreateBufferRaw(buffer_ci, &new_buffer) != VK_SUCCESS) {
+                break;
+            }
+            const VkMemoryRequirements requirements =
+                    logical.GetBufferMemoryRequirements(new_buffer);
+            const u32 type_mask = requirements.memoryTypeBits & host_props.memoryTypeBits;
+            if (type_mask == 0 || requirements.size > window_len) {
+                logical.DestroyBufferRaw(new_buffer);
+                break;
+            }
+            const auto type_index = FindImportMemoryType(memory_props, type_mask);
+            if (!type_index) {
+                logical.DestroyBufferRaw(new_buffer);
+                break;
+            }
+            const u32 heap_index = memory_props.memoryTypes[*type_index].heapIndex;
+            const VkDeviceSize heap_size = memory_props.memoryHeaps[heap_index].size;
+            if (imported_size + window_len > heap_size / 2) {
+                logical.DestroyBufferRaw(new_buffer);
+                break;
+            }
+            const VkImportMemoryHostPointerInfoEXT import_info{
+                    .sType = VK_STRUCTURE_TYPE_IMPORT_MEMORY_HOST_POINTER_INFO_EXT,
+                    .pNext = nullptr,
+                    .handleType = VK_EXTERNAL_MEMORY_HANDLE_TYPE_HOST_ALLOCATION_BIT_EXT,
+                    .pHostPointer = window_base,
+            };
+            const VkMemoryAllocateInfo alloc_info{
+                    .sType = VK_STRUCTURE_TYPE_MEMORY_ALLOCATE_INFO,
+                    .pNext = &import_info,
+                    .allocationSize = window_len,
+                    .memoryTypeIndex = *type_index,
+            };
+            vk::DeviceMemory memory = logical.TryAllocateMemory(alloc_info);
+            if (!memory) {
+                logical.DestroyBufferRaw(new_buffer);
+                break;
+            }
+            if (logical.BindBufferMemory(new_buffer, *memory, 0) != VK_SUCCESS) {
+                logical.DestroyBufferRaw(new_buffer);
+                break;
+            }
+            windows.push_back(Window{
+                    .memory = std::move(memory),
+                    .buffer = new_buffer,
+            });
+            imported_size += static_cast<size_t>(window_len);
+        }
+        if (windows.empty()) {
+            return false;
+        }
+        return true;
+    }
+
+    bool HostMemoryImport::ImportHardwareBuffers(
+            [[maybe_unused]] std::span<AHardwareBuffer *const> hardware_buffers,
+            [[maybe_unused]] size_t hardware_buffer_window,
+            [[maybe_unused]] size_t hardware_buffer_base, [[maybe_unused]] size_t size) {
+#ifdef __ANDROID__
+        if (hardware_buffers.empty() || hardware_buffer_window == 0 ||
+            !device.IsExtExternalMemoryAhbSupported()) {
+            return false;
+        }
+        const u64 max_allocation_size = device.GetMaxMemoryAllocationSize();
+        if (max_allocation_size != 0 && hardware_buffer_window > max_allocation_size) {
+            return false;
+        }
+        if (hardware_buffer_base >= size) {
+            return false;
+        }
+        const auto &logical = device.GetLogical();
+        const auto memory_props = device.GetPhysical().GetMemoryProperties().memoryProperties;
+        window_size = hardware_buffer_window;
+        base_offset = hardware_buffer_base;
+        for (size_t i = 0; i < hardware_buffers.size(); ++i) {
+            const size_t offset = hardware_buffer_base + i * hardware_buffer_window;
+            if (offset >= size) {
+                break;
+            }
+            const VkDeviceSize window_len = (std::min)(
+                    static_cast<VkDeviceSize>(size - offset),
+                    static_cast<VkDeviceSize>(hardware_buffer_window));
+            VkAndroidHardwareBufferPropertiesANDROID ahb_props{
+                    .sType = VK_STRUCTURE_TYPE_ANDROID_HARDWARE_BUFFER_PROPERTIES_ANDROID,
+                    .pNext = nullptr,
+                    .allocationSize = 0,
+                    .memoryTypeBits = 0,
+            };
+            if (logical.GetAndroidHardwareBufferPropertiesANDROID(hardware_buffers[i],
+                                                                  &ahb_props) != VK_SUCCESS ||
+                ahb_props.memoryTypeBits == 0 || ahb_props.allocationSize < window_len) {
+                break;
+            }
+            const VkExternalMemoryBufferCreateInfo external_info{
+                    .sType = VK_STRUCTURE_TYPE_EXTERNAL_MEMORY_BUFFER_CREATE_INFO,
+                    .pNext = nullptr,
+                    .handleTypes =
+                            VK_EXTERNAL_MEMORY_HANDLE_TYPE_ANDROID_HARDWARE_BUFFER_BIT_ANDROID,
+            };
+            const VkBufferCreateInfo buffer_ci{
+                    .sType = VK_STRUCTURE_TYPE_BUFFER_CREATE_INFO,
+                    .pNext = &external_info,
+                    .flags = 0,
+                    .size = window_len,
+                    .usage = VK_BUFFER_USAGE_TRANSFER_SRC_BIT | VK_BUFFER_USAGE_TRANSFER_DST_BIT,
+                    .sharingMode = VK_SHARING_MODE_EXCLUSIVE,
+                    .queueFamilyIndexCount = 0,
+                    .pQueueFamilyIndices = nullptr,
+            };
+            VkBuffer new_buffer{};
+            if (logical.CreateBufferRaw(buffer_ci, &new_buffer) != VK_SUCCESS) {
+                break;
+            }
+            const VkMemoryRequirements requirements =
+                    logical.GetBufferMemoryRequirements(new_buffer);
+            const u32 type_mask = requirements.memoryTypeBits & ahb_props.memoryTypeBits;
+            if (type_mask == 0 || requirements.size > ahb_props.allocationSize) {
+                logical.DestroyBufferRaw(new_buffer);
+                break;
+            }
+            const auto type_index = FindImportMemoryType(memory_props, type_mask);
+            if (!type_index) {
+                logical.DestroyBufferRaw(new_buffer);
+                break;
+            }
+            const VkImportAndroidHardwareBufferInfoANDROID import_info{
+                    .sType = VK_STRUCTURE_TYPE_IMPORT_ANDROID_HARDWARE_BUFFER_INFO_ANDROID,
+                    .pNext = nullptr,
+                    .buffer = hardware_buffers[i],
+            };
+            const VkMemoryDedicatedAllocateInfo dedicated_info{
+                    .sType = VK_STRUCTURE_TYPE_MEMORY_DEDICATED_ALLOCATE_INFO,
+                    .pNext = &import_info,
+                    .image = VK_NULL_HANDLE,
+                    .buffer = new_buffer,
+            };
+            const VkMemoryAllocateInfo alloc_info{
+                    .sType = VK_STRUCTURE_TYPE_MEMORY_ALLOCATE_INFO,
+                    .pNext = &dedicated_info,
+                    .allocationSize = ahb_props.allocationSize,
+                    .memoryTypeIndex = *type_index,
+            };
+            vk::DeviceMemory memory = logical.TryAllocateMemory(alloc_info);
+            if (!memory) {
+                logical.DestroyBufferRaw(new_buffer);
+                break;
+            }
+            if (logical.BindBufferMemory(new_buffer, *memory, 0) != VK_SUCCESS) {
+                logical.DestroyBufferRaw(new_buffer);
+                break;
+            }
+            windows.push_back(Window{
+                    .memory = std::move(memory),
+                    .buffer = new_buffer,
+            });
+            imported_size += static_cast<size_t>(window_len);
+        }
+        if (windows.empty()) {
+            window_size = 0;
+            base_offset = 0;
+            return false;
+        }
+        foreign_ownership = true;
+        return true;
+#else
+        return false;
+#endif
+    }
+
+    HostMemoryImport::~HostMemoryImport() {
+        for (Window &window : windows) {
+            if (window.buffer != VK_NULL_HANDLE) {
+                device.GetLogical().DestroyBufferRaw(window.buffer);
+            }
+        }
+    }
+
    MemoryAllocator::MemoryAllocator(const Device &device_)
            : device{device_}, allocator{device.GetAllocator()},
              properties{device_.GetPhysical().GetMemoryProperties().memoryProperties},
@@ -15,6 +15,8 @@
 #include "video_core/vulkan_common/vulkan_wrapper.h"
 #include "video_core/vulkan_common/vma.h"

+struct AHardwareBuffer;
+
 namespace Vulkan {

    class Device;
@@ -84,6 +86,66 @@ namespace Vulkan {
        void *mapped_ptr{};  ///< Optional persistent mapped pointer
    };

+    class HostMemoryImport {
+    public:
+        explicit HostMemoryImport(const Device &device_, void *base, size_t size,
+                                  std::span<AHardwareBuffer *const> hardware_buffers,
+                                  size_t hardware_buffer_window, size_t hardware_buffer_base);
+
+        ~HostMemoryImport();
+
+        HostMemoryImport(const HostMemoryImport &) = delete;
+
+        HostMemoryImport &operator=(const HostMemoryImport &) = delete;
+
+        [[nodiscard]] bool IsValid() const noexcept {
+            return !windows.empty();
+        }
+
+        [[nodiscard]] size_t GetSize() const noexcept {
+            return imported_size;
+        }
+
+        [[nodiscard]] size_t GetBaseOffset() const noexcept {
+            return base_offset;
+        }
+
+        [[nodiscard]] bool NeedsForeignOwnershipTransfer() const noexcept {
+            return foreign_ownership;
+        }
+
+        [[nodiscard]] VkDeviceSize GetWindowSize() const noexcept {
+            return window_size;
+        }
+
+        [[nodiscard]] VkBuffer GetWindowBuffer(size_t index) const noexcept {
+            return windows[index].buffer;
+        }
+
+        [[nodiscard]] size_t GetWindowCount() const noexcept {
+            return windows.size();
+        }
+
+    private:
+        struct Window {
+            vk::DeviceMemory memory;
+            VkBuffer buffer{};
+        };
+
+        bool ImportHostPointer(void *base, size_t size);
+
+        bool ImportHardwareBuffers(std::span<AHardwareBuffer *const> hardware_buffers,
+                                   size_t hardware_buffer_window, size_t hardware_buffer_base,
+                                   size_t size);
+
+        const Device &device;
+        std::vector<Window> windows;
+        VkDeviceSize window_size{};
+        size_t imported_size{};
+        size_t base_offset{};
+        bool foreign_ownership{};
+    };
+
 /// Memory allocator container.
 /// Allocates and releases memory allocations on demand.
    class MemoryAllocator {
@@ -216,12 +216,16 @@ void Load(VkDevice device, DeviceDispatch& dld) noexcept {
    X(vkGetBufferMemoryRequirements2);
    X(vkGetDeviceQueue);
    X(vkGetEventStatus);
+    X(vkGetMemoryHostPointerPropertiesEXT);
    X(vkGetFenceStatus);
    X(vkGetImageMemoryRequirements);
    X(vkGetPipelineCacheData);
    X(vkGetMemoryFdKHR);
 #ifdef _WIN32
    X(vkGetMemoryWin32HandleKHR);
+#endif
+#ifdef __ANDROID__
+    X(vkGetAndroidHardwareBufferPropertiesANDROID);
 #endif
    X(vkGetQueryPoolResults);
    X(vkGetPipelineExecutablePropertiesKHR);
@@ -332,12 +332,16 @@ struct DeviceDispatch : InstanceDispatch {
    PFN_vkGetBufferMemoryRequirements2 vkGetBufferMemoryRequirements2{};
    PFN_vkGetDeviceQueue vkGetDeviceQueue{};
    PFN_vkGetEventStatus vkGetEventStatus{};
+    PFN_vkGetMemoryHostPointerPropertiesEXT vkGetMemoryHostPointerPropertiesEXT{};
    PFN_vkGetFenceStatus vkGetFenceStatus{};
    PFN_vkGetImageMemoryRequirements vkGetImageMemoryRequirements{};
    PFN_vkGetPipelineCacheData vkGetPipelineCacheData{};
    PFN_vkGetMemoryFdKHR vkGetMemoryFdKHR{};
 #ifdef _WIN32
    PFN_vkGetMemoryWin32HandleKHR vkGetMemoryWin32HandleKHR{};
+#endif
+#ifdef __ANDROID__
+    PFN_vkGetAndroidHardwareBufferPropertiesANDROID vkGetAndroidHardwareBufferPropertiesANDROID{};
 #endif
    PFN_vkGetPipelineExecutablePropertiesKHR vkGetPipelineExecutablePropertiesKHR{};
    PFN_vkGetPipelineExecutableStatisticsKHR vkGetPipelineExecutableStatisticsKHR{};
@@ -1082,6 +1086,34 @@ public:
    VkMemoryRequirements GetBufferMemoryRequirements(VkBuffer buffer,
                                                     void* pnext = nullptr) const noexcept;

+    VkResult GetMemoryHostPointerPropertiesEXT(
+        VkExternalMemoryHandleTypeFlagBits handle_type, const void* host_pointer,
+        VkMemoryHostPointerPropertiesEXT* out_properties) const noexcept {
+        return dld->vkGetMemoryHostPointerPropertiesEXT(handle, handle_type, host_pointer,
+                                                        out_properties);
+    }
+
+#ifdef __ANDROID__
+    VkResult GetAndroidHardwareBufferPropertiesANDROID(
+        const struct AHardwareBuffer* buffer,
+        VkAndroidHardwareBufferPropertiesANDROID* out_properties) const noexcept {
+        return dld->vkGetAndroidHardwareBufferPropertiesANDROID(handle, buffer, out_properties);
+    }
+#endif
+
+    VkResult CreateBufferRaw(const VkBufferCreateInfo& ci, VkBuffer* out_buffer) const noexcept {
+        return dld->vkCreateBuffer(handle, &ci, nullptr, out_buffer);
+    }
+
+    void DestroyBufferRaw(VkBuffer buffer) const noexcept {
+        dld->vkDestroyBuffer(handle, buffer, nullptr);
+    }
+
+    VkResult BindBufferMemory(VkBuffer buffer, VkDeviceMemory memory,
+                              VkDeviceSize offset) const noexcept {
+        return dld->vkBindBufferMemory(handle, buffer, memory, offset);
+    }
+
    VkMemoryRequirements GetImageMemoryRequirements(VkImage image) const noexcept;

    std::vector<VkPipelineExecutablePropertiesKHR> GetPipelineExecutablePropertiesKHR(
@@ -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 LINUX)
+if (YUZU_USE_BUNDLED_QT AND PLATFORM_LINUX)
    set(CMAKE_BUILD_RPATH "${CMAKE_BINARY_DIR}/bin/lib/")
 endif()

@@ -398,9 +398,6 @@ endif()
 target_link_libraries(yuzu PRIVATE nlohmann_json::nlohmann_json)
 target_link_libraries(yuzu PRIVATE common core input_common frontend_common network video_core qt_common)
 target_link_libraries(yuzu PRIVATE Boost::headers Qt6::Widgets Qt6::Charts Qt6::Concurrent)
-target_link_libraries(yuzu PRIVATE
-    OpenSSL::SSL
-    OpenSSL::Crypto)
 target_link_libraries(yuzu PRIVATE ${PLATFORM_LIBRARIES} Threads::Threads)
 if (ENABLE_OPENGL)
    target_link_libraries(yuzu PRIVATE glad)
@@ -437,6 +434,10 @@ if (ARCHITECTURE_x86_64 OR ARCHITECTURE_arm64)
    target_link_libraries(yuzu PRIVATE dynarmic::dynarmic)
 endif()

+if (YUZU_ROOM)
+    target_link_libraries(yuzu PRIVATE yuzu-room)
+endif()
+
 if (NOT MSVC AND (APPLE OR NOT YUZU_STATIC_BUILD))
    # needed for vma
    target_compile_options(yuzu PRIVATE
@@ -99,7 +99,6 @@ ConfigureInputAdvanced::ConfigureInputAdvanced(Core::HID::HIDCore& hid_core_, QW

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

    LoadConfiguration();
@@ -140,7 +139,6 @@ 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();
@@ -176,7 +174,6 @@ 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,22 +2757,6 @@
                       </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>
@@ -2,10 +2,12 @@
 // SPDX-License-Identifier: GPL-3.0-or-later

 #include <QApplication>
-#include "common/program_args.h"
-#include "network/room.h"
 #include "startup_checks.h"

+#if YUZU_ROOM
+#include <cstring>
+#include "dedicated_room/yuzu_room.h"
+#endif
 #ifdef __unix__
 #include "qt_common/gui_settings.h"
 #endif
@@ -14,12 +16,6 @@
 #include <sys/resource.h>
 #endif

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

 #ifdef _WIN32
@@ -76,6 +72,20 @@ static Qt::HighDpiScaleFactorRoundingPolicy GetHighDpiRoundingPolicy() {
 }

 int main(int argc, char* argv[]) {
+#if YUZU_ROOM
+    bool launch_room = false;
+    for (int i = 1; i < argc; i++) {
+        if (strcmp(argv[i], "--room") == 0) {
+            launch_room = true;
+        }
+    }
+
+    if (launch_room) {
+        LaunchRoom(argc, argv, true);
+        return 0;
+    }
+#endif
+
    bool has_broken_vulkan = false;
    bool is_child = false;
    if (CheckEnvVars(&is_child)) {
@@ -116,16 +126,6 @@ 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
@@ -184,15 +184,7 @@ int main(int argc, char* argv[]) {
    // generating shaders
    setlocale(LC_ALL, "C");

-    Common::ProgramArguments args{};
-    Common::ParseArguments(args, argc, argv);
-    if (!args.room_name.empty() || !args.room_description.empty()) {
-        LOG_INFO(Frontend, "Assuming (headless) room mode");
-        Network::LaunchRoomLoopWithArguments(args);
-        return -1;
-    }
-
-    MainWindow main_window{std::move(args), has_broken_vulkan};
+    MainWindow main_window{has_broken_vulkan};
    // After settings have been loaded by GMainWindow, apply the filter
    main_window.show();

@@ -1,8 +1,7 @@
 // SPDX-FileCopyrightText: Copyright 2026 Eden Emulator Project
 // SPDX-License-Identifier: GPL-3.0-or-later

-// Static Qt on macOS doesn't use Vulkan
-// Other platforms do, and thus have conflicting VulkanMemoryAllocator symbols
+// Qt on macOS doesn't define VMA shit
 #if defined(QT_STATICPLUGIN) && !defined(__APPLE__)
 #undef VMA_IMPLEMENTATION
 #endif
@@ -350,7 +349,7 @@ inline static bool isDarkMode() {
 }
 #endif // _WIN32

-MainWindow::MainWindow(Common::ProgramArguments&& opts, bool has_broken_vulkan)
+MainWindow::MainWindow(bool has_broken_vulkan)
    : ui{std::make_unique<Ui::MainWindow>()},
      input_subsystem{std::make_shared<InputCommon::InputSubsystem>()}, user_data_migrator{this} {
    QtCommon::Init(this);
@@ -512,33 +511,73 @@ MainWindow::MainWindow(Common::ProgramArguments&& opts, bool has_broken_vulkan)
        return;
    }

-    if (opts.selected_user) {
-        auto user_index = *opts.selected_user;
-        if (QtCommon::system->GetProfileManager().UserExistsIndex(user_index)) {
-            Settings::values.current_user = s32(user_index);
-            user_flag_cmd_line = true;
+    QString game_path;
+    bool should_launch_qlaunch = false;
+    bool should_launch_hlaunch = false;
+    bool should_launch_setup = false;
+    bool has_gamepath = false;
+    bool is_fullscreen = false;
+
+    // Preserves drag/drop functionality
+    for (int i = 1; i < args.size(); ++i) {
+        if (args[i] == QStringLiteral("-f")) {
+            // Launch game in fullscreen mode
+            is_fullscreen = true;
+        } else if (args[i] == QStringLiteral("-u") && i < args.size() - 1) {
+            // Launch game with a specific user
+            int user_arg_idx = ++i;
+            bool argument_ok;
+            std::size_t selected_user = args[user_arg_idx].toUInt(&argument_ok);
+            if (!argument_ok) {
+                // try to look it up by username, only finds the first username that matches.
+                std::string const user_arg_str = args[user_arg_idx].toStdString();
+                auto const user_idx =
+                    QtCommon::system->GetProfileManager().GetUserIndex(user_arg_str);
+                if (user_idx != std::nullopt) {
+                    selected_user = user_idx.value();
+                } else {
+                    LOG_ERROR(Frontend, "Invalid user argument '{}'", user_arg_str);
+                    continue;
+                }
+            }
+            if (QtCommon::system->GetProfileManager().UserExistsIndex(selected_user)) {
+                Settings::values.current_user = s32(selected_user);
+                user_flag_cmd_line = true;
+            } else {
+                LOG_ERROR(Frontend, "Selected user {} doesn't exist", selected_user);
+            }
+        } else if (args[i] == QStringLiteral("-g") && i < args.size() - 1) {
+            // Launch game at path
+            game_path = args[++i];
+            has_gamepath = true;
+        } else if (args[i] == QStringLiteral("-input-profile") && i < args.size() - 1) {
+            auto& players = Settings::values.players.GetValue();
+            players[0].profile_name = args[++i].toStdString();
+        } else if (args[i] == QStringLiteral("-qlaunch")) {
+            should_launch_qlaunch = true;
+        } else if (args[i] == QStringLiteral("-hlaunch")) {
+            should_launch_hlaunch = true;
+        } else if (args[i] == QStringLiteral("-setup")) {
+            should_launch_setup = true;
        } else {
-            LOG_ERROR(Frontend, "Selected user {} doesn't exist", user_index);
+            game_path = args[i];
+            has_gamepath = true;
        }
    }

-    if (!opts.input_profile.empty()) {
-        Settings::values.players.GetValue()[0].profile_name = opts.input_profile;
-    }
-
    // Override fullscreen setting if gamepath or argument is provided
-    if (!opts.filepath.empty() && opts.fullscreen) {
-        ui->action_Fullscreen->setChecked(opts.fullscreen);
+    if (has_gamepath || is_fullscreen) {
+        ui->action_Fullscreen->setChecked(is_fullscreen);
    }

-    if (opts.should_launch_setup) {
+    if (should_launch_setup) {
        LaunchFirmwareApplet(u64(Service::AM::AppletProgramId::Starter), std::nullopt);
    } else {
-        if (!opts.filepath.empty()) {
-            BootGame(QString::fromStdString(opts.filepath), ApplicationAppletParameters());
-        } else if (opts.should_launch_qlaunch) {
+        if (!game_path.isEmpty()) {
+            BootGame(game_path, ApplicationAppletParameters());
+        } else if (should_launch_qlaunch) {
            LaunchFirmwareApplet(u64(Service::AM::AppletProgramId::QLaunch), std::nullopt);
-        } else if (opts.should_launch_hlaunch) {
+        } else if (should_launch_hlaunch) {
            std::filesystem::path const sd_dir =
                Common::FS::GetEdenPathString(Common::FS::EdenPath::SDMCDir);
            auto const hbl_path = (sd_dir / "atmosphere" / "hbl.nsp").string();
@@ -17,7 +17,6 @@
 #include <QTranslator>
 #include <qaction.h>

-#include "common/program_args.h"
 #include "common/common_types.h"
 #include "common/settings_enums.h"
 #include "frontend_common/content_manager.h"
@@ -166,7 +165,7 @@ class MainWindow : public QMainWindow {
 public:
    void filterBarSetChecked(bool state);
    void UpdateUITheme();
-    explicit MainWindow(Common::ProgramArguments&& args, bool has_broken_vulkan);
+    explicit MainWindow(bool has_broken_vulkan);
    ~MainWindow() override;

    bool DropAction(QDropEvent* event);
@@ -38,7 +38,7 @@ void MigrationWorker::process() {
    try {
        fs::remove_all(eden_dir);
    } catch (fs::filesystem_error& _) {
-        // directory may not exist at this point, that's fine
+        // ignore because linux does stupid crap sometimes
    }

    switch (strategy) {
@@ -38,16 +38,7 @@ add_executable(yuzu-cmd
    ${OPENGL_SOURCES}
 )

-target_link_libraries(yuzu-cmd PRIVATE common network core input_common frontend_common video_core)
-if (ENABLE_WEB_SERVICE)
-    target_compile_definitions(yuzu-cmd PRIVATE ENABLE_WEB_SERVICE)
-    target_link_libraries(yuzu-cmd PRIVATE web_service)
-endif()
-
-target_link_libraries(yuzu-cmd PRIVATE
-    OpenSSL::SSL
-    OpenSSL::Crypto)
-
+target_link_libraries(yuzu-cmd PRIVATE common core input_common frontend_common video_core)
 if (ENABLE_OPENGL)
    target_link_libraries(yuzu-cmd PRIVATE glad)
 endif()
@@ -5,10 +5,6 @@
 // SPDX-License-Identifier: GPL-2.0-or-later

 #include <SDL3/SDL.h>
-#include <SDL3/SDL_timer.h>
-#ifdef __EMSCRIPTEN__
-#include <emscripten.h>
-#endif

 #include "common/logging.h"
 #include "common/scm_rev.h"
@@ -30,17 +26,9 @@ EmuWindow_SDL3::EmuWindow_SDL3(InputCommon::InputSubsystem* input_subsystem_, Co
        LOG_CRITICAL(Frontend, "Failed to initialize SDL3: {}, Exiting...", SDL_GetError());
        exit(1);
    }
-    titlebar_timer = SDL_AddTimer(2000, [](void *userdata, SDL_TimerID, Uint32) -> Uint32 {
-        auto* this_ = (EmuWindow_SDL3*)userdata;
-        auto const results = this_->system.GetAndResetPerfStats();
-        auto const title = fmt::format("{} | {}-{} | FPS: {:.0f} ({:.0f}%)", Common::g_build_fullname, Common::g_scm_branch, Common::g_scm_desc, results.average_game_fps, results.emulation_speed * 100.0f);
-        SDL_SetWindowTitle(this_->render_window, title.c_str());
-        return 2000;
-    }, this);
 }

 EmuWindow_SDL3::~EmuWindow_SDL3() {
-    SDL_RemoveTimer(titlebar_timer);
    system.HIDCore().UnloadInputDevices();
    input_subsystem->Shutdown();
    SDL_Quit();
@@ -144,7 +132,8 @@ void EmuWindow_SDL3::Fullscreen() {
    switch (Settings::values.fullscreen_mode.GetValue()) {
    case Settings::FullscreenMode::Exclusive:
        // Set window size to render size before entering fullscreen in exclusive mode.
-        if (const SDL_DisplayMode* display_mode_ptr = SDL_GetDesktopDisplayMode(SDL_GetDisplayForWindow(render_window))) {
+        if (const SDL_DisplayMode* display_mode_ptr =
+                SDL_GetDesktopDisplayMode(SDL_GetDisplayForWindow(render_window))) {
            display_mode = *display_mode_ptr;
            SDL_SetWindowSize(render_window, display_mode.w, display_mode.h);
            SDL_SetWindowFullscreenMode(render_window, &display_mode);
@@ -176,60 +165,92 @@ void EmuWindow_SDL3::Fullscreen() {
    }
 }

-void EmuWindow_SDL3::OnEvent(SDL_Event& event) {
-    // Notice how we skip the "update title" aspect on most events
-    // this is because some WMs do NOT like changing titles while resizing
-    // so let's just... not do that, thanks :)
-    // Afterall we don't really expect the user to pay attention to the titlebar
-    // while they're moving a lot of shit around...
+void EmuWindow_SDL3::WaitEvent() {
+    // Called on main thread
+    SDL_Event event;
+
+    if (!SDL_WaitEvent(&event)) {
+        const char* error = SDL_GetError();
+        if (!error || strcmp(error, "") == 0) {
+            // https://github.com/libsdl-org/SDL/issues/5780
+            // Sometimes SDL will return without actually having hit an error condition;
+            // just ignore it in this case.
+            return;
+        }
+
+        LOG_CRITICAL(Frontend, "SDL_WaitEvent failed: {}", error);
+        exit(1);
+    }
+
    switch (event.type) {
    case SDL_EVENT_WINDOW_RESIZED:
    case SDL_EVENT_WINDOW_PIXEL_SIZE_CHANGED:
    case SDL_EVENT_WINDOW_MAXIMIZED:
    case SDL_EVENT_WINDOW_RESTORED:
-        return OnResize();
+        OnResize();
+        break;
    case SDL_EVENT_WINDOW_MINIMIZED:
        is_shown = false;
-        return OnResize();
+        OnResize();
+        break;
    case SDL_EVENT_WINDOW_EXPOSED:
        is_shown = true;
-        return OnResize();
+        OnResize();
+        break;
    case SDL_EVENT_WINDOW_CLOSE_REQUESTED:
        is_open = false;
-        return;
+        break;
    case SDL_EVENT_KEY_DOWN:
    case SDL_EVENT_KEY_UP:
-        return OnKeyEvent(int(event.key.scancode), event.key.down ? 1 : 0);
+        OnKeyEvent(static_cast<int>(event.key.scancode), event.key.down ? 1 : 0);
+        break;
    case SDL_EVENT_MOUSE_MOTION:
        // ignore if it came from touch
        if (event.button.which != SDL_TOUCH_MOUSEID)
            OnMouseMotion(event.motion.x, event.motion.y);
-        return;
+        break;
    case SDL_EVENT_MOUSE_BUTTON_DOWN:
    case SDL_EVENT_MOUSE_BUTTON_UP:
        // ignore if it came from touch
-        if (event.button.which != SDL_TOUCH_MOUSEID)
-            OnMouseButton(event.button.button, event.button.down ? 1 : 0, s32(event.button.x), s32(event.button.y));
-        return;
+        if (event.button.which != SDL_TOUCH_MOUSEID) {
+            OnMouseButton(event.button.button, event.button.down ? 1 : 0,
+                          static_cast<s32>(event.button.x), static_cast<s32>(event.button.y));
+        }
+        break;
    case SDL_EVENT_FINGER_DOWN:
-        return OnFingerDown(event.tfinger.x, event.tfinger.y, std::size_t(event.tfinger.touchID));
+        OnFingerDown(event.tfinger.x, event.tfinger.y,
+                     static_cast<std::size_t>(event.tfinger.touchID));
+        break;
    case SDL_EVENT_FINGER_MOTION:
-        return OnFingerMotion(event.tfinger.x, event.tfinger.y, std::size_t(event.tfinger.touchID));
+        OnFingerMotion(event.tfinger.x, event.tfinger.y,
+                       static_cast<std::size_t>(event.tfinger.touchID));
+        break;
    case SDL_EVENT_FINGER_UP:
-        return OnFingerUp();
+        OnFingerUp();
+        break;
    case SDL_EVENT_QUIT:
        is_open = false;
-        return;
+        break;
    default:
        break;
    }
+
+    const u32 current_time = SDL_GetTicks();
+    if (current_time > last_time + 2000) {
+        const auto results = system.GetAndResetPerfStats();
+        const auto title = fmt::format("{} | {}-{} | FPS: {:.0f} ({:.0f}%)",
+                                       Common::g_build_fullname,
+                                       Common::g_scm_branch,
+                                       Common::g_scm_desc,
+                                       results.average_game_fps,
+                                       results.emulation_speed * 100.0);
+        SDL_SetWindowTitle(render_window, title.c_str());
+        last_time = current_time;
+    }
 }

 // Credits to Samantas5855 and others for this function.
 void EmuWindow_SDL3::SetWindowIcon() {
-#if defined(__EMSCRIPTEN__) || defined(__wasi__)
-    // Icons do not work yet
-#else
    SDL_IOStream* const yuzu_icon_stream = SDL_IOFromConstMem((void*)yuzu_icon, yuzu_icon_size);
    if (yuzu_icon_stream == nullptr) {
        LOG_WARNING(Frontend, "Failed to create Eden icon stream.");
@@ -243,7 +264,6 @@ void EmuWindow_SDL3::SetWindowIcon() {
    // The icon is attached to the window pointer
    SDL_SetWindowIcon(render_window, window_icon);
    SDL_DestroySurface(window_icon);
-#endif
 }

 void EmuWindow_SDL3::OnMinimalClientAreaChangeRequest(std::pair<u32, u32> minimal_size) {
@@ -9,12 +9,11 @@
 #include <tuple>
 #include <utility>

-#include <SDL3/SDL.h>
-#include <SDL3/SDL_timer.h>
-
 #include "core/frontend/emu_window.h"
 #include "core/frontend/graphics_context.h"

+struct SDL_Window;
+
 namespace Core {
 class System;
 }
@@ -36,7 +35,7 @@ public:
    bool IsShown() const override;

    /// Wait for the next event on the main thread.
-    void OnEvent(SDL_Event& event);
+    void WaitEvent();

    // Sets the window icon from yuzu.bmp
    void SetWindowIcon();
@@ -81,9 +80,6 @@ protected:
    /// Called when a configuration change affects the minimal size of the window
    void OnMinimalClientAreaChangeRequest(std::pair<u32, u32> minimal_size) override;

-    /// Periodic changer of titlebar (independent of event loop)
-    SDL_TimerID titlebar_timer;
-
    /// Is the window still open?
    bool is_open = true;

@@ -93,6 +89,9 @@ protected:
    /// Internal SDL3 render window
    SDL_Window* render_window{};

+    /// Keeps track of how often to update the title bar during gameplay
+    u32 last_time = 0;
+
    /// Input subsystem to use with this window.
    InputCommon::InputSubsystem* input_subsystem;

@@ -8,16 +8,6 @@
 #include <memory>
 #include <regex>
 #include <string>
-#include <SDL3/SDL_init.h>
-#include <openssl/evp.h>
-#include "common/fs/file.h"
-#include "common/program_args.h"
-#include "common/settings_enums.h"
-#ifdef __EMSCRIPTEN__
-#include <emscripten.h>
-#endif
-#define SDL_MAIN_USE_CALLBACKS 1
-#include <SDL3/SDL_main.h>

 #include <fmt/ostream.h>

@@ -36,14 +26,9 @@
 #include "core/loader/loader.h"
 #include "frontend_common/config.h"
 #include "input_common/main.h"
-#include "network/announce_multiplayer_session.h"
 #include "network/network.h"
-#include "network/room.h"
-#include "network/verify_user.h"
-
-#include "yuzu_cmd/sdl_config.h"
+#include "sdl_config.h"
 #include "video_core/renderer_base.h"
-
 #include "yuzu_cmd/emu_window/emu_window_sdl3.h"
 #ifdef HAS_OPENGL
 #include "yuzu_cmd/emu_window/emu_window_sdl3_gl.h"
@@ -54,7 +39,9 @@
 #ifdef _WIN32
 // windows.h needs to be included before shellapi.h
 #include <windows.h>
+
 #include <shellapi.h>
+
 #include "common/windows/timer_resolution.h"
 #endif

@@ -73,6 +60,25 @@ __declspec(dllexport) int AmdPowerXpressRequestHighPerformance = 1;
 }
 #endif

+static void PrintHelp(const char* argv0) {
+    std::cout << "Usage: " << argv0
+              << " [options] <filename>\n"
+                 "-c, --config          Load the specified configuration file\n"
+                 "-f, --fullscreen      Start in fullscreen mode\n"
+                 "-g, --game            File path of the game to load\n"
+                 "-h, --help            Display this help and exit\n"
+                 "-m, --multiplayer=nick:password@address:port"
+                 " Nickname, password, address and port for multiplayer\n"
+                 "-p, --program         Pass following string as arguments to executable\n"
+                 "-u, --user            Select a specific user profile from 0 to 7\n"
+                 "-d, --debug           Run the GDB stub on a port from 1 to 65535\n"
+                 "-v, --version         Output version information and exit\n";
+}
+
+static void PrintVersion() {
+    std::cout << "Eden " << Common::g_scm_branch << " " << Common::g_scm_desc << std::endl;
+}
+
 static void OnStateChanged(const Network::RoomMember::State& state) {
    switch (state) {
    case Network::RoomMember::State::Idle:
@@ -168,154 +174,8 @@ static void OnStatusMessageReceived(const Network::StatusMessageEntry& msg) {
        std::cout << std::endl << "* " << message << std::endl << std::endl;
 }

-struct SdlState {
-    Core::System system{};
-    std::unique_ptr<EmuWindow_SDL3> emu_window;
-    // settings
-    Common::ProgramArguments opts = {};
-};
-
-static SDL_AppResult ExecuteWithGUI(SdlState& state) {
-    SdlConfig config{state.opts.config_path};
-
-    // apply the log_filter setting
-    // the logger was initialized before and doesn't pick up the filter on its own
-    Common::Log::Filter filter;
-    filter.ParseFilterString(state.opts.log_filter.value_or(Settings::values.log_filter.GetValue()));
-    Common::Log::SetGlobalFilter(filter);
-
-    if (!state.opts.program_args.empty()) {
-        Settings::values.program_args = state.opts.program_args;
-    }
-
-    if (!state.opts.input_profile.empty()) {
-        auto& players = Settings::values.players.GetValue();
-        players[0].profile_name = state.opts.input_profile;
-    }
-
-    if (state.opts.selected_user.has_value()) {
-        Settings::values.current_user = std::clamp(*state.opts.selected_user, 0, 7);
-    }
-
-    if (state.opts.override_gdb_port.has_value()) {
-        Settings::values.use_gdbstub = true;
-        Settings::values.gdbstub_port = *state.opts.override_gdb_port;
-    }
-
-    if (state.opts.force_single_core) {
-        Settings::values.use_multi_core = false;
-    }
-
-    if (state.opts.force_null_render) {
-        Settings::values.renderer_backend = Settings::RendererBackend::Null;
-    }
-
-    if (state.opts.filepath.empty()) {
-        LOG_CRITICAL(Frontend, "Failed to load ROM: No ROM specified");
-        return SDL_APP_FAILURE;
-    }
-
-    state.system.Initialize();
-
-    InputCommon::InputSubsystem input_subsystem{};
-
-    // Apply the command line arguments
-    state.system.ApplySettings();
-
-    switch (Settings::values.renderer_backend.GetValue()) {
-#ifdef HAS_OPENGL
-    case Settings::RendererBackend::OpenGL_GLSL:
-    case Settings::RendererBackend::OpenGL_GLASM:
-    case Settings::RendererBackend::OpenGL_SPIRV:
-        state.emu_window = std::make_unique<EmuWindow_SDL3_GL>(&input_subsystem, state.system, state.opts.fullscreen);
-        break;
-#endif
-    case Settings::RendererBackend::Vulkan:
-        state.emu_window = std::make_unique<EmuWindow_SDL3_VK>(&input_subsystem, state.system, state.opts.fullscreen);
-        break;
-    case Settings::RendererBackend::Null:
-        state.emu_window = std::make_unique<EmuWindow_SDL3_Null>(&input_subsystem, state.system, state.opts.fullscreen);
-        break;
-    default:
-        LOG_CRITICAL(Frontend, "Invalid renderer backend");
-        return SDL_APP_FAILURE;
-    }
-
-#ifdef _WIN32
-    Common::Windows::SetCurrentTimerResolutionToMaximum();
-    state.system.CoreTiming().SetTimerResolutionNs(Common::Windows::GetCurrentTimerResolution());
-#endif
-
-    state.system.SetContentProvider(std::make_unique<FileSys::ContentProviderUnion>());
-    state.system.SetFilesystem(std::make_shared<FileSys::RealVfsFilesystem>());
-    state.system.GetFileSystemController().CreateFactories(*state.system.GetFilesystem());
-    state.system.GetUserChannel().clear();
-
-    Service::AM::FrontendAppletParameters load_parameters{
-        .applet_id = Service::AM::AppletId::Application,
-    };
-    const Core::SystemResultStatus load_result = state.system.Load(*state.emu_window, state.opts.filepath, load_parameters);
-    switch (load_result) {
-    case Core::SystemResultStatus::Success:
-        break; // Expected case
-    case Core::SystemResultStatus::ErrorGetLoader:
-        LOG_CRITICAL(Frontend, "Failed to obtain loader for {}!", state.opts.filepath);
-        return SDL_APP_FAILURE;
-    case Core::SystemResultStatus::ErrorLoader:
-        LOG_CRITICAL(Frontend, "Failed to load ROM!");
-        return SDL_APP_FAILURE;
-    case Core::SystemResultStatus::ErrorNotInitialized:
-        LOG_CRITICAL(Frontend, "CPUCore not initialized");
-        return SDL_APP_FAILURE;
-    case Core::SystemResultStatus::ErrorVideoCore:
-        LOG_CRITICAL(Frontend, "Failed to initialize VideoCore!");
-        return SDL_APP_FAILURE;
-    default:
-        const u16 loader_id = u16(Core::SystemResultStatus::ErrorLoader);
-        const u16 error_id = u16(load_result) - loader_id;
-        LOG_CRITICAL(Frontend,
-            "While attempting to load the ROM requested, an error occurred. Please "
-            "refer to the Eden wiki for more information or the Eden discord for "
-            "additional help.\n\nError Code: {:04X}-{:04X}\nError Description: {}",
-            loader_id, error_id, Loader::ResultStatus(error_id));
-        return SDL_APP_FAILURE;
-    }
-
-    if (state.opts.use_multiplayer) {
-        if (auto member = Network::GetRoomMember().lock()) {
-            member->BindOnChatMessageReceived(OnMessageReceived);
-            member->BindOnStatusMessageReceived(OnStatusMessageReceived);
-            member->BindOnStateChanged(OnStateChanged);
-            member->BindOnError(OnNetworkError);
-            LOG_DEBUG(Network, "Start connection to {}:{} with nickname {}", state.opts.address, state.opts.port, state.opts.nickname);
-            member->Join(state.opts.nickname, state.opts.address.c_str(), state.opts.port, 0, Network::NoPreferredIP, state.opts.password);
-        } else {
-            LOG_ERROR(Network, "Could not access RoomMember");
-            return SDL_APP_FAILURE;
-        }
-    }
-
-    // Core is loaded, start the GPU (makes the GPU contexts current to this thread)
-    state.system.GPU().Start();
-    state.system.GetCpuManager().OnGpuReady();
-
-    if (Settings::values.use_disk_shader_cache.GetValue()) {
-        state.system.Renderer().ReadRasterizer()->LoadDiskResources(
-            state.system.GetApplicationProcessProgramID(), std::stop_token{},
-            [](VideoCore::LoadCallbackStage, size_t value, size_t total) {});
-    }
-
-    // don't do anything, SDL3 already exists for us :D
-    state.system.RegisterExitCallback([] {});
-    void(state.system.Run());
-    if (state.system.DebuggerEnabled())
-        state.system.InitializeDebugger();
-    return SDL_APP_SUCCESS;
-}
-
-extern "C" SDL_AppResult SDL_AppInit(void **appstate, int argc, char **argv) {
-    SdlState* state = new SdlState();
-
+/// Application entry point
+int main(int argc, char** argv) {
 #ifdef _WIN32
    if (AttachConsole(ATTACH_PARENT_PROCESS)) {
        freopen("CONOUT$", "wb", stdout);
@@ -327,29 +187,292 @@ extern "C" SDL_AppResult SDL_AppInit(void **appstate, int argc, char **argv) {
    Common::Log::SetColorConsoleBackendEnabled(true);
    Common::Log::Start();

-    Common::ParseArguments(state->opts, argc, argv);
-    if (!state->opts.room_name.empty() || !state->opts.room_description.empty()) {
-        LOG_INFO(Frontend, "Assuming (headless) room mode");
-        Network::LaunchRoomLoopWithArguments(state->opts);
-        return SDL_APP_FAILURE;
+    int option_index = 0;
+#ifdef _WIN32
+    int argc_w;
+    auto argv_w = CommandLineToArgvW(GetCommandLineW(), &argc_w);
+    if (argv_w == nullptr) {
+        LOG_CRITICAL(Frontend, "Failed to get command line arguments");
+        return -1;
    }
-    return ExecuteWithGUI(*state);
-}
-extern "C" SDL_AppResult SDL_AppIterate(void *appstate) {
-    SdlState *state = (SdlState *)appstate;
-    return state->emu_window->IsOpen() ? SDL_APP_CONTINUE : SDL_APP_SUCCESS;
-}
-extern "C" SDL_AppResult SDL_AppEvent(void *appstate, SDL_Event *event) {
-    SdlState *state = (SdlState *)appstate;
-    state->emu_window->OnEvent(*event);
-    return SDL_APP_SUCCESS;
-}
-extern "C" void SDL_AppQuit(void *appstate, SDL_AppResult result) {
-    SdlState *state = (SdlState *)appstate;
-    state->system.DetachDebugger();
-    void(state->system.Pause());
-    state->system.ShutdownMainProcess();
-    delete state;
+#endif
+    std::string filepath;
+    std::optional<std::string> config_path{};
+    std::string program_args;
+    std::optional<int> selected_user{};
+    std::optional<u16> override_gdb_port{};
+    bool use_multiplayer = false;
+    bool fullscreen = false;
+    bool force_null_render = false;
+    bool force_single_core = false;
+    std::string nickname{};
+    std::string password{};
+    std::string address{};
+    std::string input_profile{};
+    std::optional<std::string> log_filter{};
+    u16 port = Network::DefaultRoomPort;
+
+    static struct option long_options[] = {
+        // clang-format off
+        {"debug", no_argument, 0, 'd'},
+        {"config", required_argument, 0, 'c'},
+        {"fullscreen", no_argument, 0, 'f'},
+        {"help", no_argument, 0, 'h'},
+        {"game", required_argument, 0, 'g'},
+        {"multiplayer", required_argument, 0, 'm'},
+        {"program", optional_argument, 0, 'p'},
+        {"user", required_argument, 0, 'u'},
+        {"version", no_argument, 0, 'v'},
+        {"input-profile", no_argument, 0, 'i'},
+        {"null-render", no_argument, 0, 'n'},
+        {"singlecore", no_argument, 0, 's'},
+        {"filter", no_argument, 0, 'x'},
+        {0, 0, 0, 0},
+        // clang-format on
+    };
+
+    while (optind < argc) {
+        int arg = getopt_long(argc, argv, "g:fhvcip::c:u:d:", long_options, &option_index);
+        if (arg != -1) {
+            switch (char(arg)) {
+            case 'd':
+                override_gdb_port = uint16_t(atoi(optarg));
+                break;
+            case 'c':
+                config_path = optarg;
+                break;
+            case 'f':
+                fullscreen = true;
+                LOG_INFO(Frontend, "Starting in fullscreen mode...");
+                break;
+            case 'h':
+                PrintHelp(argv[0]);
+                return 0;
+            case 'g':
+                filepath = std::string(optarg);
+                break;
+            case 'i': {
+                input_profile = std::string(optarg);
+                break;
+            }
+            case 'm': {
+                use_multiplayer = true;
+                const std::string str_arg(optarg);
+                // regex to check if the format is nickname:password@ip:port
+                // with optional :password
+                const std::regex re("^([^:]+)(?::(.+))?@([^:]+)(?::([0-9]+))?$");
+                if (!std::regex_match(str_arg, re)) {
+                    std::cout << "Wrong format for option --multiplayer\n";
+                    PrintHelp(argv[0]);
+                    return -1;
+                }
+
+                std::smatch match;
+                std::regex_search(str_arg, match, re);
+                ASSERT(match.size() == 5);
+                nickname = match[1];
+                password = match[2];
+                address = match[3];
+                if (!match[4].str().empty()) {
+                    port = u16(std::strtoul(match[4].str().c_str(), nullptr, 0));
+                }
+                std::regex nickname_re("^[a-zA-Z0-9._\\- ]+$");
+                if (!std::regex_match(nickname, nickname_re)) {
+                    LOG_ERROR(Frontend, "Nickname is not valid. Must be 4 to 20 alphanumeric characters");
+                    return -1;
+                }
+                if (address.empty()) {
+                    LOG_ERROR(Frontend, "Address to room must not be empty");
+                    return -1;
+                }
+                break;
+            }
+            case 'p':
+                program_args = argv[optind];
+                ++optind;
+                break;
+            case 'u':
+                selected_user = atoi(optarg);
+                break;
+            case 'v':
+                PrintVersion();
+                return -1;
+            case 'n':
+                force_null_render = true;
+                break;
+            case 's':
+                force_single_core = true;
+                break;
+            case 'x':
+                log_filter = argv[optind];
+                ++optind;
+                break;
+            }
+        } else {
+#ifdef _WIN32
+            filepath = Common::UTF16ToUTF8(argv_w[optind]);
+#else
+            filepath = argv[optind];
+#endif
+            optind++;
+        }
+    }
+
+    SdlConfig config{config_path};
+
+    // apply the log_filter setting
+    // the logger was initialized before and doesn't pick up the filter on its own
+    Common::Log::Filter filter;
+    filter.ParseFilterString(log_filter.value_or(Settings::values.log_filter.GetValue()));
+    Common::Log::SetGlobalFilter(filter);
+
+    if (!program_args.empty()) {
+        Settings::values.program_args = program_args;
+    }
+
+    if (!input_profile.empty()) {
+        auto& players = Settings::values.players.GetValue();
+        players[0].profile_name = input_profile;
+    }
+
+    if (selected_user.has_value()) {
+        Settings::values.current_user = std::clamp(*selected_user, 0, 7);
+    }
+
+    if (override_gdb_port.has_value()) {
+        Settings::values.use_gdbstub = true;
+        Settings::values.gdbstub_port = *override_gdb_port;
+    }
+
+    if (force_single_core) {
+        Settings::values.use_multi_core = false;
+    }
+
+    if (force_null_render) {
+        Settings::values.renderer_backend = Settings::RendererBackend::Null;
+    }
+
+#ifdef _WIN32
+    LocalFree(argv_w);
+#endif
+
+    if (filepath.empty()) {
+        LOG_CRITICAL(Frontend, "Failed to load ROM: No ROM specified");
+        return -1;
+    }
+
+    Core::System system{};
+    system.Initialize();
+
+    InputCommon::InputSubsystem input_subsystem{};
+
+    // Apply the command line arguments
+    system.ApplySettings();
+
+    std::unique_ptr<EmuWindow_SDL3> emu_window;
+    switch (Settings::values.renderer_backend.GetValue()) {
+#ifdef HAS_OPENGL
+    case Settings::RendererBackend::OpenGL_GLSL:
+    case Settings::RendererBackend::OpenGL_GLASM:
+    case Settings::RendererBackend::OpenGL_SPIRV:
+        emu_window = std::make_unique<EmuWindow_SDL3_GL>(&input_subsystem, system, fullscreen);
+        break;
+#endif
+    case Settings::RendererBackend::Vulkan:
+        emu_window = std::make_unique<EmuWindow_SDL3_VK>(&input_subsystem, system, fullscreen);
+        break;
+    case Settings::RendererBackend::Null:
+        emu_window = std::make_unique<EmuWindow_SDL3_Null>(&input_subsystem, system, fullscreen);
+        break;
+    default:
+        LOG_CRITICAL(Frontend, "Invalid renderer backend");
+        return -1;
+    }
+
+#ifdef _WIN32
+    Common::Windows::SetCurrentTimerResolutionToMaximum();
+    system.CoreTiming().SetTimerResolutionNs(Common::Windows::GetCurrentTimerResolution());
+#endif
+
+    system.SetContentProvider(std::make_unique<FileSys::ContentProviderUnion>());
+    system.SetFilesystem(std::make_shared<FileSys::RealVfsFilesystem>());
+    system.GetFileSystemController().CreateFactories(*system.GetFilesystem());
+    system.GetUserChannel().clear();
+
+    Service::AM::FrontendAppletParameters load_parameters{
+        .applet_id = Service::AM::AppletId::Application,
+    };
+    const Core::SystemResultStatus load_result{system.Load(*emu_window, filepath, load_parameters)};
+
+    switch (load_result) {
+    case Core::SystemResultStatus::ErrorGetLoader:
+        LOG_CRITICAL(Frontend, "Failed to obtain loader for {}!", filepath);
+        return -1;
+    case Core::SystemResultStatus::ErrorLoader:
+        LOG_CRITICAL(Frontend, "Failed to load ROM!");
+        return -1;
+    case Core::SystemResultStatus::ErrorNotInitialized:
+        LOG_CRITICAL(Frontend, "CPUCore not initialized");
+        return -1;
+    case Core::SystemResultStatus::ErrorVideoCore:
+        LOG_CRITICAL(Frontend, "Failed to initialize VideoCore!");
+        return -1;
+    case Core::SystemResultStatus::Success:
+        break; // Expected case
+    default:
+        if (static_cast<u32>(load_result) >
+            static_cast<u32>(Core::SystemResultStatus::ErrorLoader)) {
+            const u16 loader_id = static_cast<u16>(Core::SystemResultStatus::ErrorLoader);
+            const u16 error_id = static_cast<u16>(load_result) - loader_id;
+            LOG_CRITICAL(Frontend,
+                         "While attempting to load the ROM requested, an error occurred. Please "
+                         "refer to the Eden wiki for more information or the Eden discord for "
+                         "additional help.\n\nError Code: {:04X}-{:04X}\nError Description: {}",
+                         loader_id, error_id, static_cast<Loader::ResultStatus>(error_id));
+        }
+        break;
+    }
+
+    if (use_multiplayer) {
+        if (auto member = Network::GetRoomMember().lock()) {
+            member->BindOnChatMessageReceived(OnMessageReceived);
+            member->BindOnStatusMessageReceived(OnStatusMessageReceived);
+            member->BindOnStateChanged(OnStateChanged);
+            member->BindOnError(OnNetworkError);
+            LOG_DEBUG(Network, "Start connection to {}:{} with nickname {}", address, port,
+                      nickname);
+            member->Join(nickname, address.c_str(), port, 0, Network::NoPreferredIP, password);
+        } else {
+            LOG_ERROR(Network, "Could not access RoomMember");
+            return 0;
+        }
+    }
+
+    // Core is loaded, start the GPU (makes the GPU contexts current to this thread)
+    system.GPU().Start();
+    system.GetCpuManager().OnGpuReady();
+
+    if (Settings::values.use_disk_shader_cache.GetValue()) {
+        system.Renderer().ReadRasterizer()->LoadDiskResources(
+            system.GetApplicationProcessProgramID(), std::stop_token{},
+            [](VideoCore::LoadCallbackStage, size_t value, size_t total) {});
+    }
+
+    system.RegisterExitCallback([&] {
+        // Just exit right away.
+        exit(0);
+    });
+    void(system.Run());
+    if (system.DebuggerEnabled()) {
+        system.InitializeDebugger();
+    }
+    while (emu_window->IsOpen()) {
+        emu_window->WaitEvent();
+    }
+    system.DetachDebugger();
+    void(system.Pause());
+    system.ShutdownMainProcess();
+    return 0;
 }

 #define VMA_IMPLEMENTATION
@@ -0,0 +1,18 @@
+# SPDX-FileCopyrightText: Copyright 2026 Eden Emulator Project
+# SPDX-License-Identifier: GPL-3.0-or-later
+
+add_executable(yuzu_room_standalone yuzu_room_standalone.cpp)
+
+set_target_properties(yuzu_room_standalone PROPERTIES OUTPUT_NAME "eden-room")
+
+target_link_libraries(yuzu_room_standalone PRIVATE yuzu-room)
+
+if(UNIX AND NOT APPLE)
+    install(TARGETS yuzu_room_standalone RUNTIME DESTINATION "${CMAKE_INSTALL_PREFIX}/bin")
+endif()
+
+if (YUZU_STATIC_ROOM)
+    target_link_options(yuzu_room_standalone PRIVATE "-static")
+endif()
+
+create_target_directory_groups(yuzu_room_standalone)
@@ -0,0 +1,9 @@
+#include <iostream>
+
+using namespace std;
+
+int main()
+{
+    cout << "Hello World!" << endl;
+    return 0;
+}
@@ -0,0 +1,9 @@
+// SPDX-FileCopyrightText: Copyright 2025 Eden Emulator Project
+// SPDX-License-Identifier: GPL-3.0-or-later
+
+#include "dedicated_room/yuzu_room.h"
+
+int main(int argc, char* argv[])
+{
+    LaunchRoom(argc, argv, false);
+}
Author	SHA1	Message	Date
CamilleLaVey	4ae14993ae	Step back + keeping fixes from unified download + shared mem refactor	2026-08-11 18:50:22 -04:00
CamilleLaVey	b69a998b1a	another take	2026-08-11 17:37:46 -04:00
CamilleLaVey	cf65326b2b	Keep AHB limitations	2026-08-11 14:44:58 -04:00
CamilleLaVey	fd75a6d1e4	[TEST] Another increased on windows size	2026-08-07 22:46:16 -04:00
CamilleLaVey	9c596696ae	Increased windows size	2026-08-07 22:46:16 -04:00
CamilleLaVey	7067a5f298	[TEST] Increased window limiter on AHB	2026-08-07 22:46:16 -04:00
CamilleLaVey	ba11ea2eb9	[TEST] Adjustment AHB to tiled-gpu-v2 state	2026-08-07 22:46:16 -04:00
CamilleLaVey	2a15ff7b69	[memory, vulkan] Initial implementation for Unified Memory	2026-08-07 22:46:16 -04:00